diff --git a/.github/workflows/cicd-main.yml.disabled b/.github/workflows/cicd-main.yml.disabled new file mode 100644 index 0000000..4d97c6c --- /dev/null +++ b/.github/workflows/cicd-main.yml.disabled @@ -0,0 +1,76 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +name: CICD NeMo +on: + pull_request: + branches: + - main + - dev + - r** + +concurrency: + group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}-${{ github.event.label.name || 'main' }}-${{ github.event_name }} + cancel-in-progress: true + +jobs: + pre-flight: + uses: NVIDIA-NeMo/FW-CI-templates/.github/workflows/_cicd_preflight.yml@v0.64.2 + + lint-check: + name: Lint check + runs-on: ubuntu-latest + needs: [pre-flight] + if: | + ( + needs.pre-flight.outputs.is_deployment_workflow == 'false' + && needs.pre-flight.outputs.is_ci_workload == 'true' + ) || ( + needs.pre-flight.outputs.is_deployment_workflow == 'false' + && needs.pre-flight.outputs.is_ci_workload == 'false' + && needs.pre-flight.outputs.docs_only == 'false' + ) + steps: + - name: Checkout repository + uses: actions/checkout@v4 + + - name: Check lint + run: | + pip install pre-commit==3.6.0 + pre-commit install + pre-commit run --all-files --show-diff-on-failure --color=always + + cicd-unit-tests: + if: | + ( + success() + || needs.pre-flight.outputs.is_ci_workload == 'true' + || needs.pre-flight.outputs.force_run_all == 'true' + ) + && !cancelled() + needs: [pre-flight] + runs-on: ubuntu-latest + name: Launch_Unit_Tests + environment: nemo-ci + steps: + - name: Checkout + uses: actions/checkout@v4 + + - name: Install uv + uses: astral-sh/setup-uv@v7 + with: + version: "0.9.5" + + - name: Run tests + run: | + uv run --all-extras pytest --cov=src/nemotron tests diff --git a/.github/workflows/copyright-check.yml.disabled b/.github/workflows/copyright-check.yml.disabled new file mode 100644 index 0000000..4f7da06 --- /dev/null +++ b/.github/workflows/copyright-check.yml.disabled @@ -0,0 +1,60 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +name: Copyright check + +on: + pull_request: + branches: + - main + - dev + - r** + +jobs: + pre-flight: + uses: NVIDIA-NeMo/FW-CI-templates/.github/workflows/_cicd_preflight.yml@v0.64.2 + + copyright-check: + needs: [pre-flight] + if: | + !(needs.pre-flight.outputs.docs_only == 'true' + || needs.pre-flight.outputs.is_deployment_workflow == 'true') + uses: NVIDIA-NeMo/FW-CI-templates/.github/workflows/_copyright_check.yml@v0.2.0 + with: + paths: src tests + + copyright-check-summary: + needs: [pre-flight, copyright-check] + if: | + ( + needs.pre-flight.outputs.docs_only == 'true' + || needs.pre-flight.outputs.is_deployment_workflow == 'true' + || always() + ) + && !cancelled() + runs-on: ubuntu-latest + steps: + - name: Result + run: | + FAILED_JOBS=$(gh run view $GITHUB_RUN_ID --json jobs --jq '[.jobs[] | select(.status == "completed" and .conclusion != "success")] | length') || echo 0 + + if [ "${FAILED_JOBS:-0}" -eq 0 ] || [ "$SKIPPING_IS_ALLOWED" == "true" ]; then + echo "✅ All previous jobs completed successfully" + exit 0 + else + echo "❌ Found $FAILED_JOBS failed job(s)" + # Show which jobs failed + gh run view $GITHUB_RUN_ID --json jobs --jq '.jobs[] | select(.status == "completed" and .conclusion != "success") | .name' + exit 1 + fi diff --git a/.github/workflows/docs-deploy.yml b/.github/workflows/docs-deploy.yml new file mode 100644 index 0000000..feff293 --- /dev/null +++ b/.github/workflows/docs-deploy.yml @@ -0,0 +1,81 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +name: Deploy Documentation + +on: + push: + branches: + - dev + - main + paths: + - "docs/**" + - "pyproject.toml" + - ".github/workflows/docs-deploy.yml" + workflow_dispatch: + +concurrency: + group: docs-deploy-${{ github.ref }} + cancel-in-progress: true + +permissions: + contents: write + +jobs: + build-and-deploy: + runs-on: ubuntu-latest + steps: + - name: Checkout repository + uses: actions/checkout@v4 + + - name: Install uv + uses: astral-sh/setup-uv@v7 + with: + version: "0.9.5" + enable-cache: true + cache-dependency-glob: "pyproject.toml" + + - name: Build documentation (dev) + if: github.ref == 'refs/heads/dev' + run: DOCS_VERSION=dev uv run --group docs sphinx-build docs docs/_build/html -W --keep-going + + - name: Build documentation (stable) + if: github.ref == 'refs/heads/main' + run: DOCS_VERSION=stable uv run --group docs sphinx-build docs docs/_build/html -W --keep-going + + - name: Deploy docs (dev branch) + if: github.ref == 'refs/heads/dev' + uses: peaceiris/actions-gh-pages@v4 + with: + github_token: ${{ secrets.GITHUB_TOKEN }} + publish_dir: ./docs/_build/html + publish_branch: gh-pages + destination_dir: dev + keep_files: true + user_name: "github-actions[bot]" + user_email: "github-actions[bot]@users.noreply.github.com" + commit_message: "docs: deploy dev from ${{ github.sha }}" + + - name: Deploy docs (main branch) + if: github.ref == 'refs/heads/main' + uses: peaceiris/actions-gh-pages@v4 + with: + github_token: ${{ secrets.GITHUB_TOKEN }} + publish_dir: ./docs/_build/html + publish_branch: gh-pages + destination_dir: stable + keep_files: true + user_name: "github-actions[bot]" + user_email: "github-actions[bot]@users.noreply.github.com" + commit_message: "docs: deploy stable from ${{ github.sha }}" diff --git a/.github/workflows/docs-preview.yml b/.github/workflows/docs-preview.yml new file mode 100644 index 0000000..1a52e67 --- /dev/null +++ b/.github/workflows/docs-preview.yml @@ -0,0 +1,124 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +name: Deploy PR Documentation Preview + +on: + pull_request: + branches: + - dev + # - main # Uncomment after dev is merged into main + paths: + - "docs/**" + - "pyproject.toml" + - ".github/workflows/docs-preview.yml" + types: [opened, synchronize, reopened, closed] + +concurrency: + group: docs-preview-${{ github.event.pull_request.number }} + cancel-in-progress: true + +permissions: + contents: write + pull-requests: write + +jobs: + build-and-deploy-preview: + if: github.event.action != 'closed' + runs-on: ubuntu-latest + steps: + - name: Checkout repository + uses: actions/checkout@v4 + + - name: Install uv + uses: astral-sh/setup-uv@v7 + with: + version: "0.9.5" + enable-cache: true + cache-dependency-glob: "pyproject.toml" + + - name: Build documentation + run: uv run --group docs sphinx-build docs docs/_build/html + + - name: Deploy PR preview + uses: peaceiris/actions-gh-pages@v4 + with: + github_token: ${{ secrets.GITHUB_TOKEN }} + publish_dir: ./docs/_build/html + publish_branch: gh-pages + destination_dir: pr-${{ github.event.pull_request.number }} + keep_files: true + user_name: "github-actions[bot]" + user_email: "github-actions[bot]@users.noreply.github.com" + commit_message: "docs: preview for PR #${{ github.event.pull_request.number }}" + + - name: Comment PR with preview link + uses: actions/github-script@v7 + with: + script: | + const prNumber = context.payload.pull_request.number; + const owner = context.repo.owner; + const repo = context.repo.repo; + const previewUrl = `https://${owner}.github.io/${repo}/pr-${prNumber}/`; + + const comments = await github.rest.issues.listComments({ + owner, + repo, + issue_number: prNumber, + }); + + const botComment = comments.data.find( + (c) => c.user.type === "Bot" && c.body.includes("Documentation Preview") + ); + + const body = `## Documentation Preview\n\n📖 **Preview URL:** ${previewUrl}\n\n_Built from commit ${context.sha.substring(0, 7)}_`; + + if (botComment) { + await github.rest.issues.updateComment({ + owner, + repo, + comment_id: botComment.id, + body, + }); + } else { + await github.rest.issues.createComment({ + owner, + repo, + issue_number: prNumber, + body, + }); + } + + cleanup-preview: + if: github.event.action == 'closed' + runs-on: ubuntu-latest + steps: + - name: Checkout gh-pages branch + uses: actions/checkout@v4 + with: + ref: gh-pages + fetch-depth: 0 + + - name: Delete preview directory + run: | + PR_DIR="pr-${{ github.event.pull_request.number }}" + if [ -d "$PR_DIR" ]; then + git config user.name "github-actions[bot]" + git config user.email "github-actions[bot]@users.noreply.github.com" + git rm -rf "$PR_DIR" + git commit -m "docs: cleanup preview for PR #${{ github.event.pull_request.number }}" + git push origin gh-pages + else + echo "Preview directory $PR_DIR does not exist, skipping cleanup" + fi diff --git a/.gitignore b/.gitignore index 950defe..68e93fe 100644 --- a/.gitignore +++ b/.gitignore @@ -47,6 +47,7 @@ htmlcov/ # Jupyter .ipynb_checkpoints/ +*.ipynb # mypy .mypy_cache/ @@ -59,13 +60,27 @@ dmypy.json # Environment .env .env.local +env.toml +conductor.json # Project specific +output/ outputs/ logs/ checkpoints/ data/ +!src/nemotron/cli/nano3/data/ workspace/ +wandb/ +.nemotron/ +.conductor/ # Claude Code CLAUDE.md +.claude/ + +# Compiled config +config.yaml + +# Documentation build +docs/_build/ \ No newline at end of file diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml new file mode 100644 index 0000000..570c7c3 --- /dev/null +++ b/.pre-commit-config.yaml @@ -0,0 +1,37 @@ +repos: + - repo: https://github.com/pre-commit/pre-commit-hooks + rev: v4.4.0 + hooks: + - id: end-of-file-fixer + # only include python files + files: \.py$ + - id: trailing-whitespace + # only include python files + files: \.py$ + + - repo: https://github.com/astral-sh/ruff-pre-commit + rev: "v0.9.9" # Use the appropriate version + hooks: + - id: ruff + args: ["--fix"] + - id: ruff + args: ["check", "--select", "I", "--fix"] + - id: ruff-format + + - repo: local + hooks: + - id: no-underscore-md + name: "Disallow '_' in Markdown filenames" + language: system + entry: | + bash -c ' + # Report the offending files + echo "[pre-commit] ERROR: Found Markdown files with underscores:" >&2 + for file in "$@"; do + echo " - $file (use hyphens instead)" >&2 + done + exit 1 + ' + files: '.*\/[^\/]*_[^\/]*\.md$' + exclude: '^\.github/' + types: [file] diff --git a/.python-version b/.python-version new file mode 100644 index 0000000..e4fba21 --- /dev/null +++ b/.python-version @@ -0,0 +1 @@ +3.12 diff --git a/CHANGELOG.md b/CHANGELOG.md index 4e73b1c..0fa184f 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -16,7 +16,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - Unix piping support between pipeline steps - Atomic file writes for artifact metadata - WandbTracker for optional W&B integration -- CLI generation with tyro +- CLI generation with typer and OmegaConf #### Training Recipe Structure - Recipe package structure at `src/nemotron/recipes/` @@ -41,9 +41,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - NVIDIA AI stack integration details (Curator, Megatron-Bridge, Automodel, NeMo-RL, Evaluator) - Recipe overview with paper links - Usage examples and quick start -- Training recipe documentation: - - `docs/training/run-recipe.md` - Guide for running recipes - - `docs/training/add-recipe.md` - Guide for contributing recipes - Recipe-specific READMEs with detailed TODO lists - Contribution guidelines inspired by NVIDIA-NeMo/Megatron-Bridge @@ -56,7 +53,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 **Dependencies:** - pydantic >= 2.0.0 -- tyro >= 0.8.0 +- typer >= 0.12.0 +- omegaconf >= 2.3.0 - rich >= 13.0.0 - wandb (optional) diff --git a/README.md b/README.md index 0d8208a..9639a8f 100644 --- a/README.md +++ b/README.md @@ -1,125 +1,175 @@ # NVIDIA Nemotron Developer Repository -Developer companion repo for working with NVIDIA's Nemotron models: inference, fine-tuning, agents, visual reasoning, deployment. +**Open and efficient models for agentic AI** — training recipes, deployment guides, and use-case examples for the Nemotron family. [![Python 3.10+](https://img.shields.io/badge/python-3.10%2B-blue.svg)](https://www.python.org/downloads/) [![License: Apache 2.0](https://img.shields.io/badge/License-Apache%202.0-green.svg)](https://opensource.org/licenses/Apache-2.0) [![Contributions Welcome](https://img.shields.io/badge/contributions-welcome-brightgreen.svg)](CONTRIBUTING.md) +[![Docs](https://img.shields.io/badge/docs-dev-76B900.svg)](https://nvidia-nemo.github.io/Nemotron/dev/) + +
+ +[![Watch the Nemotron Overview](https://img.youtube.com/vi/_y9SEtn1lU8/hqdefault.jpg)](https://www.youtube.com/watch?v=_y9SEtn1lU8) + +**[Watch: Nemotron Overview](https://www.youtube.com/watch?v=_y9SEtn1lU8)** + +
--- -## 📂 Repo Layout +## Why Nemotron? + +| | | +|---|---| +| **Open Models** | Fully transparent training data, techniques, and weights for community innovation | +| **Compute Efficiency** | Model pruning and optimization enabling higher throughput via TensorRT-LLM | +| **High Accuracy** | Built on frontier open models with human-aligned reasoning for agentic workflows | +| **Flexible Deployment** | Deploy anywhere — edge, single GPU, or data center with NIM microservices | + +--- + +## Repository Overview ``` nemotron/ │ -├── usage-cookbook/ Usage cookbooks (how to deploy, and simple model usage guides) +├── src/nemotron/recipes/ Training recipes (complete, reproducible pipelines) │ +├── usage-cookbook/ Usage cookbooks (deployment and model usage guides) │ -└── use-case-examples/ Examples of leveraging Nemotron Models in Agentic Workflows and more +└── use-case-examples/ Examples of leveraging Nemotron in agentic workflows ``` --- ## What is Nemotron? -[NVIDIA Nemotron™](https://developer.nvidia.com/nemotron) is a family of open, high-efficiency models with fully transparent training data, weights, and recipes. +[NVIDIA Nemotron](https://www.nvidia.com/en-us/ai-data-science/foundation-models/nemotron/) is a family of open, high-efficiency multimodal models purpose-built for agentic AI. + +**Model Tiers:** -Nemotron models are designed for **agentic AI workflows** — they excel at coding, math, scientific reasoning, tool calling, instruction following, and visual reasoning (for the VL models). +- **Nano** — Optimized for edge and PC deployments +- **Super** — Single GPU deployment with highest throughput +- **Ultra** — Multi-GPU datacenter applications -They are optimized for deployment across a spectrum of compute tiers (edge, single GPU, data center) and support frameworks like NeMo and TensorRT-LLM, vLLM, and SGLang, with NIM microservice options for scalable serving. +Nemotron models excel at coding, math, scientific reasoning, tool calling, instruction following, and visual reasoning. Deploy across edge, single GPU, or data center environments with support for NeMo, TensorRT-LLM, vLLM, SGLang, and NIM microservices. --- -### More Resources +## Training Recipes -- **[Usage Cookbook](usage-cookbook/)** - Practical deployment and simple model usage guides for Nemotron models -- **[Use Case Examples](use-case-examples/)** - Practical use-case examples and apps -- **[Nemotron Developer Page](https://developer.nvidia.com/nemotron)** - Developer resources for the Nemotron family of models -- **[Nemotron Research Hub](https://research.nvidia.com/labs/nemotron/)** - Research affiliated with the Nemotron effort -- **[Nemotron Datasets](https://huggingface.co/nvidia/datasets?search=nemotron)** - Datasets part of various Nemotron collections, from pre-training to post-training +The Nemotron Training Cookbook provides complete, reproducible training pipelines that show the full journey from raw data to deployment-ready models. These implementations reflect how large language models are trained at leading AI labs—through rigorous, scientific processes with careful experimentation, validation gates, and systematic optimization. ---- +### Why Complete Training Pipelines -## 💡 Feature Requests & Ideas +Training a production model involves interconnected components where isolated examples miss critical interactions between stages. Complete pipelines show: -Have an idea for improving Nemotron models? Visit the **[Nemotron Ideas Portal](https://nemotron.ideas.nvidia.com/)** to: +- **How data quality affects downstream performance** across pretraining, SFT, and RL stages +- **Which training techniques work together** in practice, not just theory +- **Where validation gates prevent failures** and ensure reproducibility +- **How to balance competing objectives** across training stages -- 🗳️ **Vote** on existing feature requests -- 💭 **Submit** your own ideas and suggestions -- 📊 **See** what the community is requesting +Because these are complete systems, practitioners can extract specific techniques with confidence—each component has been proven to work in a production context. -Your feedback helps shape the future of Nemotron models! +### Available Recipes ---- +| Model | Description | Stages | Guide | +|-------|-------------|--------|-------| +| **[Nemotron 3 Nano](docs/train/nano3/README.md)** | 3.6B active / 31.6B total MoE Hybrid Mamba-Transformer for agentic reasoning | Pretrain → SFT → RL | [Training Guide](docs/train/nano3/README.md) | -## Training Recipes (Coming Soon) +### Nemotron 3 Nano -Full, reproducible training pipelines will be included in the `nemotron` package at `src/nemotron/recipes/`. +A complete training recipe for the open, efficient Mixture-of-Experts hybrid Mamba-Transformer model optimized for agentic reasoning. -### Each Recipe Includes -- 🎨 **Synthetic Data Generation** - Scripts to generate synthetic datasets using [NVIDIA-NeMo/DataDesigner](https://github.com/NVIDIA-NeMo/DataDesigner) -- 🗂️ **Data Curation** - Scripts to prepare training data using [NVIDIA-NeMo/Curator](https://github.com/NVIDIA-NeMo/Curator) -- 🔁 **Training** - Complete training loops with hyperparameters using: - - [NVIDIA-NeMo/Megatron-Bridge](https://github.com/NVIDIA-NeMo/Megatron-Bridge/tree/main) for Megatron models - - [NVIDIA-NeMo/Automodel](https://github.com/NVIDIA-NeMo/Automodel) for HuggingFace models - - [NVIDIA-NeMo/NeMo-RL](https://github.com/NVIDIA-NeMo/RL/tree/main) when RL is needed -- 📊 **Evaluation** - Benchmark evaluation on standard suites using [NVIDIA-NeMo/Evaluator](https://github.com/NVIDIA-NeMo/Evaluator) -- 📖 **Documentation** - Detailed explanations of each stage +> **Open-Source Data Only**: These recipes train exclusively on the open-sourced subset of training data. Results will differ from the tech report benchmarks, which used additional proprietary data. Use these recipes as reference implementations to apply the methodology with your own data. ---- +**Model Specifications**: +- 31.6B total parameters, 3.6B active per forward pass +- 25 trillion pretraining tokens with curriculum learning +- Up to 1M context length +- 3.3x higher inference throughput than similarly sized models -## Model Specific Usage Cookbooks +**What You Can Extract**: +- Curriculum-based pretraining with two-phase data mixture +- Long-context extension via CPT methodology +- Multi-domain SFT with 12+ data sources +- InfinityByte cross-domain code synthesis +- Tool-calling fine-tuning and budget-controlled reasoning +- Multi-environment RLVR with GRPO +- GenRM reward modeling with circular comparison +- DPO for tool hallucination reduction -Learn how to deploy and use the models through an API. +**Resources**: +- [Training Guide](docs/train/nano3/README.md) +- [Tech Report](https://arxiv.org/abs/2506.XXXXX) +- [Model Weights (Base)](https://huggingface.co/nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-Base-BF16) +- [Model Weights (Instruct)](https://huggingface.co/nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-BF16) +- [Model Weights (FP8)](https://huggingface.co/nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-FP8) -| Model | Best For | Key Features | Trade-offs | Resources | -|-------|----------|--------------|------------|-----------| -| [**NVIDIA-Nemotron-3-Nano**](https://huggingface.co/collections/nvidia/nvidia-nemotron-v3) | High-throughput agentic workflows, reasoning, tool-use, chat | • 31.6B total / 3.6B active (MoE)
• Hybrid Mamba-Transformer MoE
• 1M-token context window
• Reasoning ON/OFF + thinking budget | Sparse MoE trades total params for efficiency | [📁 Cookbooks](./usage-cookbook/Nemotron-3-Nano/) | -| [**Llama-3.3-Nemotron-Super-49B-v1.5**](https://huggingface.co/nvidia/Llama-3_3-Nemotron-Super-49B-v1_5) | Production deployments needing strong reasoning with efficiency | • 128K context
• Single H200 GPU
• RAG & tool calling
• Optimized via NAS | Balances accuracy & throughput | [📁 Cookbooks](./usage-cookbook/Llama-Nemotron-Super-49B-v1.5/) | -| [**NVIDIA-Nemotron-Nano-9B-v2**](https://huggingface.co/nvidia/NVIDIA-Nemotron-Nano-9B-v2) | Resource-constrained environments needing flexible reasoning | • 9B params
• Hybrid Mamba-2 architecture
• Controllable reasoning traces
• Unified reasoning/non-reasoning | Smaller model with configurable reasoning | [📁 Cookbooks](./usage-cookbook/Nemotron-Nano-9B-v2/) | -| [**NVIDIA-Nemotron-Nano-12B-v2-VL**](https://huggingface.co/nvidia/NVIDIA-Nemotron-Nano-12B-v2-VL) | Document intelligence and video understanding | • 12B VLM
• Video & multi-image reasoning
• Controllable reasoning (/think mode)
• Efficient Video Sampling (EVS) | Vision-language with configurable reasoning | [📁 Cookbooks](./usage-cookbook/Nemotron-Nano2-VL/) | -| [**Llama-3.1-Nemotron-Safety-Guard-8B-v3**](https://huggingface.co/nvidia/Llama-3.1-Nemotron-Safety-Guard-8B-v3) | Multilingual content moderation with cultural nuance | • 9 languages
• 23 safety categories
• Cultural sensitivity
• NeMo Guardrails integration | Focused on safety/moderation tasks | [📁 Cookbooks](./usage-cookbook/Llama-3.1-Nemotron-Safety-Guard-V3/) | -| **Nemotron-Parse** (link coming soon!) | Document parsing for RAG and AI agents | • VLM for document parsing
• Table extraction (LaTeX)
• Semantic segmentation
• Spatial grounding (bbox) | Specialized for document structure | [📁 Cookbooks](./usage-cookbook/Nemotron-Parse-v1.1/) | +--- +## Usage Cookbooks -## Nemotron Use Case Examples +Practical deployment and model usage guides for Nemotron models. -Below is an outline of the end-to-end use case examples provided in the [`use-case-examples`](./use-case-examples/) directory. These scenarios demonstrate practical applications that go beyond basic model inference. +| Model | Best For | Key Features | Resources | +|-------|----------|--------------|-----------| +| [**Llama-3.3-Nemotron-Super-49B-v1.5**](https://huggingface.co/nvidia/Llama-3_3-Nemotron-Super-49B-v1_5) | Production deployments needing strong reasoning | 128K context, single H200 GPU, RAG & tool calling | [Cookbooks](./usage-cookbook/Llama-Nemotron-Super-49B-v1.5/) | +| [**NVIDIA-Nemotron-Nano-9B-v2**](https://huggingface.co/nvidia/NVIDIA-Nemotron-Nano-9B-v2) | Resource-constrained environments | 9B params, hybrid Mamba-2, controllable reasoning | [Cookbooks](./usage-cookbook/Nemotron-Nano-9B-v2/) | +| [**NVIDIA-Nemotron-Nano-12B-v2-VL**](https://huggingface.co/nvidia/NVIDIA-Nemotron-Nano-12B-v2-VL) | Document intelligence and video understanding | 12B VLM, video reasoning, Efficient Video Sampling | [Cookbooks](./usage-cookbook/Nemotron-Nano2-VL/) | +| [**Llama-3.1-Nemotron-Safety-Guard-8B-v3**](https://huggingface.co/nvidia/Llama-3.1-Nemotron-Safety-Guard-8B-v3) | Multilingual content moderation | 9 languages, 23 safety categories | [Cookbooks](./usage-cookbook/Llama-3.1-Nemotron-Safety-Guard-V3/) | +| **Nemotron-Parse** | Document parsing for RAG and AI agents | Table extraction, semantic segmentation | [Cookbooks](./usage-cookbook/Nemotron-Parse-v1.1/) | -### What You'll Find +--- -- **Agentic Workflows** - Orchestration of multi-step AI agents, integrating planning, context management, and external tools/APIs. +## Use Case Examples -- **Retrieval-Augmented Generation (RAG) Systems** - Building pipelines that combine retrieval components (vector databases, search APIs) with Nemotron models for grounded, accurate outputs. +End-to-end examples demonstrating practical applications in the [`use-case-examples/`](./use-case-examples/) directory: -- **Integration with External Tools & APIs** - Examples of Nemotron models powering applications with structured tool calling, function execution, or data enrichment. +- **Agentic Workflows** — Multi-step AI agents with planning, context management, and external tools +- **RAG Systems** — Pipelines combining retrieval with Nemotron models for grounded outputs +- **Tool Integration** — Structured tool calling, function execution, and data enrichment +- **Production Patterns** — Scalability, monitoring, and deployment architectures -- **Production-Ready Application Patterns** - Architectures supporting scalability, monitoring, data pipelines, and real-world deployment considerations. +### Each Recipe Includes +- 🎨 **Synthetic Data Generation** - Scripts to generate synthetic datasets using [NVIDIA-NeMo/DataDesigner](https://github.com/NVIDIA-NeMo/DataDesigner) +- 🗂️ **Data Curation** - Scripts to prepare training data using [NVIDIA NeMo Curator](https://github.com/NVIDIA/NeMo-Curator) for scalable data processing, filtering, and quality enhancement +- 🔁 **Training** - Complete training loops with hyperparameters using: + - [NVIDIA-NeMo/Megatron-Bridge](https://github.com/NVIDIA-NeMo/Megatron-Bridge/tree/main) for Megatron models + - [NVIDIA-NeMo/Automodel](https://github.com/NVIDIA-NeMo/Automodel) for HuggingFace models + - [NVIDIA-NeMo/NeMo-RL](https://github.com/NVIDIA-NeMo/RL/tree/main) when RL is needed + - Includes GPU-accelerated last-mile data processing (tokenization + optional sequence packing) for optimal training efficiency +- 📊 **Evaluation** - Benchmark evaluation on standard suites using [NVIDIA NeMo Evaluator](https://github.com/NVIDIA-NeMo/Evaluator) +- 📖 **Documentation** - Detailed explanations of each stage -> See the [`use-case-examples/`](./use-case-examples/) subfolders for in-depth, runnable examples illustrating these concepts. +--- -## Contributing +## Feature Requests -We welcome contributions! Whether it's examples, recipes, or other tools you'd find useful. +Have an idea for improving Nemotron models? Visit the **[Nemotron Ideas Portal](https://nemotron.ideas.nvidia.com/)** to vote on existing requests or submit your own. -Please read our **[Contributing Guidelines](CONTRIBUTING.md)** before submitting pull requests. +--- ## Documentation -- **[Contributing Guidelines](CONTRIBUTING.md)** - How to contribute to this project -- **[Changelog](CHANGELOG.md)** - Version history and changes +- [Nemotron 3 Nano Training Guide](docs/train/nano3/README.md) — Complete training recipe +- [NeMo-Run Configuration](docs/train/nemo-run.md) — Execution profiles and job orchestration +- [Data Preparation](docs/train/data-prep.md) — Data preparation module documentation +- [Contributing Guidelines](CONTRIBUTING.md) — How to contribute +- [Changelog](CHANGELOG.md) — Version history + +--- + +## Contributing + +We welcome contributions—examples, recipes, or other tools. Please read the [Contributing Guidelines](CONTRIBUTING.md) before submitting pull requests. --- ## License -Apache 2.0 License - see [LICENSE](LICENSE) file for details. +Apache 2.0 License — see [LICENSE](LICENSE) for details. --- -**NVIDIA Nemotron** - Open, transparent, and reproducible. +**NVIDIA Nemotron** — Open and efficient models for agentic AI. diff --git a/docs/_static/css/termynal.css b/docs/_static/css/termynal.css new file mode 100644 index 0000000..de6ed28 --- /dev/null +++ b/docs/_static/css/termynal.css @@ -0,0 +1,144 @@ +/** + * termynal.css + * Styling for Termynal terminal animations. + * + * @author Ines Montani + * @license MIT + * + * Adapted for NVIDIA Sphinx theme + */ + +:root { + --termynal-bg: #252a33; + --termynal-text: #eee; + --termynal-text-subtle: #a2a2a2; + --termynal-comment: #76b900; /* NVIDIA green */ +} + +[data-termynal] { + width: 100%; + max-width: 100%; + background: var(--termynal-bg); + color: var(--termynal-text); + font-size: 15px; + font-family: 'Roboto Mono', 'Fira Mono', Consolas, Menlo, Monaco, 'Courier New', Courier, monospace; + border-radius: 4px; + padding: 75px 45px 35px; + position: relative; + box-sizing: border-box; + line-height: 1.4; + margin: 1em 0; +} + +/* macOS-style window chrome */ +[data-termynal]:before { + content: ''; + position: absolute; + top: 15px; + left: 15px; + display: inline-block; + width: 15px; + height: 15px; + border-radius: 50%; + background: #d9515d; + box-shadow: 25px 0 0 #f4c025, 50px 0 0 #3ec930; +} + +/* "bash" label at top */ +[data-termynal]:after { + content: 'bash'; + position: absolute; + color: var(--termynal-text-subtle); + top: 5px; + left: 0; + width: 100%; + text-align: center; +} + +/* Control links (fast/restart) */ +a[data-terminal-control] { + text-align: right; + display: block; + color: #aebbff; + font-size: 0.85em; + margin-top: 0.5em; +} + +a[data-terminal-control]:hover { + color: #d4dbff; + text-decoration: none; +} + +/* Line styling */ +[data-ty] { + display: block; + line-height: 2; +} + +[data-ty]:before { + content: ''; + display: inline-block; + vertical-align: middle; +} + +/* Input prompt ($) */ +[data-ty="input"]:before, +[data-ty-prompt]:before { + margin-right: 0.75em; + color: var(--termynal-text-subtle); +} + +[data-ty="input"]:before { + content: '$'; +} + +/* Custom prompt */ +[data-ty][data-ty-prompt]:before { + content: attr(data-ty-prompt); +} + +/* Cursor animation */ +[data-ty-cursor]:after { + content: attr(data-ty-cursor); + font-family: monospace; + margin-left: 0.5em; + animation: blink 1s infinite; +} + +@keyframes blink { + 50% { + opacity: 0; + } +} + +/* Comment styling */ +.termynal-comment { + color: var(--termynal-comment); + font-style: italic; +} + +/* Container wrapper for .termy divs */ +.termy { + margin: 1.5em 0; +} + +/* Hide the original code block when inside .termy */ +.termy .highlight { + display: none; +} + +/* Responsive adjustments */ +@media (max-width: 768px) { + [data-termynal] { + padding: 55px 20px 25px; + font-size: 13px; + } + + [data-termynal]:before { + width: 12px; + height: 12px; + top: 12px; + left: 12px; + box-shadow: 20px 0 0 #f4c025, 40px 0 0 #3ec930; + } +} diff --git a/docs/_static/js/termynal-init.js b/docs/_static/js/termynal-init.js new file mode 100644 index 0000000..d845953 --- /dev/null +++ b/docs/_static/js/termynal-init.js @@ -0,0 +1,139 @@ +/** + * termynal-init.js + * Sphinx/MyST integration for Termynal terminal animations. + * + * Parses code blocks inside .termy containers and converts them + * to animated terminal widgets. + */ + +'use strict'; + +function setupTermynal() { + const progressLiteralStart = "---> 100%"; + const promptLiteralStart = "$ "; + const customPromptLiteralStart = "# "; + const termynalActivateClass = "termy"; + let termynals = []; + + function createTermynals() { + // Find all .termy containers with code blocks inside + // Sphinx/MyST generates: .termy > .highlight > pre + document + .querySelectorAll(`.${termynalActivateClass}`) + .forEach(container => { + // Find the code content - try different selectors for Sphinx HTML structure + const codeNode = container.querySelector('.highlight pre') || + container.querySelector('pre') || + container.querySelector('code'); + + if (!codeNode) { + console.warn('Termynal: No code block found in .termy container'); + return; + } + + const text = codeNode.textContent; + const lines = text.split("\n"); + const useLines = []; + let buffer = []; + + function saveBuffer() { + if (buffer.length) { + let isBlankSpace = true; + buffer.forEach(line => { + if (line) { + isBlankSpace = false; + } + }); + let dataValue = {}; + if (isBlankSpace) { + dataValue["delay"] = 0; + } + if (buffer[buffer.length - 1] === "") { + // A last single
won't have effect + // so put an additional one + buffer.push(""); + } + const bufferValue = buffer.join("
"); + dataValue["value"] = bufferValue; + useLines.push(dataValue); + buffer = []; + } + } + + for (let line of lines) { + if (line === progressLiteralStart) { + saveBuffer(); + useLines.push({ + type: "progress" + }); + } else if (line.startsWith(promptLiteralStart)) { + saveBuffer(); + const value = line.replace(promptLiteralStart, "").trimEnd(); + useLines.push({ + type: "input", + value: value + }); + } else if (line.startsWith("// ")) { + saveBuffer(); + const value = "💬 " + line.replace("// ", "").trimEnd(); + useLines.push({ + value: value, + class: "termynal-comment", + delay: 0 + }); + } else if (line.startsWith(customPromptLiteralStart)) { + saveBuffer(); + const promptStart = line.indexOf(promptLiteralStart); + if (promptStart === -1) { + console.error("Custom prompt found but no end delimiter", line) + buffer.push(line); + continue; + } + const prompt = line.slice(0, promptStart).replace(customPromptLiteralStart, "") + let value = line.slice(promptStart + promptLiteralStart.length); + useLines.push({ + type: "input", + value: value, + prompt: prompt + }); + } else { + buffer.push(line); + } + } + saveBuffer(); + + // Create new container for termynal + const div = document.createElement("div"); + container.innerHTML = ''; + container.appendChild(div); + + const termynal = new Termynal(div, { + lineData: useLines, + noInit: true, + lineDelay: 500 + }); + termynals.push(termynal); + }); + } + + function loadVisibleTermynals() { + termynals = termynals.filter(termynal => { + if (termynal.container.getBoundingClientRect().top - innerHeight <= 0) { + termynal.init(); + return false; + } + return true; + }); + } + + window.addEventListener("scroll", loadVisibleTermynals); + createTermynals(); + loadVisibleTermynals(); +} + +// Initialize when DOM is ready +if (document.readyState === 'loading') { + document.addEventListener('DOMContentLoaded', setupTermynal); +} else { + setupTermynal(); +} diff --git a/docs/_static/js/termynal.js b/docs/_static/js/termynal.js new file mode 100644 index 0000000..df6de68 --- /dev/null +++ b/docs/_static/js/termynal.js @@ -0,0 +1,265 @@ +/** + * termynal.js + * A lightweight, modern and extensible animated terminal window, using + * async/await. + * + * @author Ines Montani + * @version 0.0.1 + * @license MIT + * + * Adapted for Sphinx/MyST documentation + */ + +'use strict'; + +/** Generate a terminal widget. */ +class Termynal { + /** + * Construct the widget's settings. + * @param {(string|Node)=} container - Query selector or container element. + * @param {Object=} options - Custom settings. + * @param {string} options.prefix - Prefix to use for data attributes. + * @param {number} options.startDelay - Delay before animation, in ms. + * @param {number} options.typeDelay - Delay between each typed character, in ms. + * @param {number} options.lineDelay - Delay between each line, in ms. + * @param {number} options.progressLength - Number of characters displayed as progress bar. + * @param {string} options.progressChar – Character to use for progress bar, defaults to █. + * @param {number} options.progressPercent - Max percent of progress. + * @param {string} options.cursor – Character to use for cursor, defaults to ▋. + * @param {Object[]} lineData - Dynamically loaded line data objects. + * @param {boolean} options.noInit - Don't initialise the animation. + */ + constructor(container = '#termynal', options = {}) { + this.container = (typeof container === 'string') ? document.querySelector(container) : container; + this.pfx = `data-${options.prefix || 'ty'}`; + this.originalStartDelay = this.startDelay = options.startDelay + || parseFloat(this.container.getAttribute(`${this.pfx}-startDelay`)) || 600; + this.originalTypeDelay = this.typeDelay = options.typeDelay + || parseFloat(this.container.getAttribute(`${this.pfx}-typeDelay`)) || 90; + this.originalLineDelay = this.lineDelay = options.lineDelay + || parseFloat(this.container.getAttribute(`${this.pfx}-lineDelay`)) || 1500; + this.progressLength = options.progressLength + || parseFloat(this.container.getAttribute(`${this.pfx}-progressLength`)) || 40; + this.progressChar = options.progressChar + || this.container.getAttribute(`${this.pfx}-progressChar`) || '█'; + this.progressPercent = options.progressPercent + || parseFloat(this.container.getAttribute(`${this.pfx}-progressPercent`)) || 100; + this.cursor = options.cursor + || this.container.getAttribute(`${this.pfx}-cursor`) || '▋'; + this.lineData = this.lineDataToElements(options.lineData || []); + this.loadLines() + if (!options.noInit) this.init() + } + + loadLines() { + // Load all the lines and create the container so that the size is fixed + // Otherwise it would be changing and the user viewport would be constantly + // moving as she/he scrolls + const finish = this.generateFinish() + finish.style.visibility = 'hidden' + this.container.appendChild(finish) + // Appends dynamically loaded lines to existing line elements. + this.lines = [...this.container.querySelectorAll(`[${this.pfx}]`)].concat(this.lineData); + for (let line of this.lines) { + line.style.visibility = 'hidden' + this.container.appendChild(line) + } + const restart = this.generateRestart() + restart.style.visibility = 'hidden' + this.container.appendChild(restart) + this.container.setAttribute('data-termynal', ''); + } + + /** + * Initialise the widget, get lines, clear container and start animation. + */ + init() { + /** + * Calculates width and height of Termynal container. + * If container is empty and lines are dynamically loaded, defaults to browser `auto` or CSS. + */ + const containerStyle = getComputedStyle(this.container); + this.container.style.width = containerStyle.width !== '0px' ? + containerStyle.width : undefined; + this.container.style.minHeight = containerStyle.height !== '0px' ? + containerStyle.height : undefined; + + this.container.setAttribute('data-termynal', ''); + this.container.innerHTML = ''; + for (let line of this.lines) { + line.style.visibility = 'visible' + } + this.start(); + } + + /** + * Start the animation and rener the lines depending on their data attributes. + */ + async start() { + this.addFinish() + await this._wait(this.startDelay); + + for (let line of this.lines) { + const type = line.getAttribute(this.pfx); + const delay = line.getAttribute(`${this.pfx}-delay`) || this.lineDelay; + + if (type == 'input') { + line.setAttribute(`${this.pfx}-cursor`, this.cursor); + await this.type(line); + await this._wait(delay); + } + + else if (type == 'progress') { + await this.progress(line); + await this._wait(delay); + } + + else { + this.container.appendChild(line); + await this._wait(delay); + } + + line.removeAttribute(`${this.pfx}-cursor`); + } + this.addRestart() + this.finishElement.style.visibility = 'hidden' + this.lineDelay = this.originalLineDelay + this.typeDelay = this.originalTypeDelay + this.startDelay = this.originalStartDelay + } + + generateRestart() { + const restart = document.createElement('a') + restart.onclick = (e) => { + e.preventDefault() + this.container.innerHTML = '' + this.init() + } + restart.href = '#' + restart.setAttribute('data-terminal-control', '') + restart.innerHTML = "restart ↻" + return restart + } + + generateFinish() { + const finish = document.createElement('a') + finish.onclick = (e) => { + e.preventDefault() + this.lineDelay = 0 + this.typeDelay = 0 + this.startDelay = 0 + } + finish.href = '#' + finish.setAttribute('data-terminal-control', '') + finish.innerHTML = "fast →" + this.finishElement = finish + return finish + } + + addRestart() { + const restart = this.generateRestart() + this.container.appendChild(restart) + } + + addFinish() { + const finish = this.generateFinish() + this.container.appendChild(finish) + } + + /** + * Animate a typed line. + * @param {Node} line - The line element to render. + */ + async type(line) { + const chars = [...line.textContent]; + line.textContent = ''; + this.container.appendChild(line); + + for (let char of chars) { + const delay = line.getAttribute(`${this.pfx}-typeDelay`) || this.typeDelay; + await this._wait(delay); + line.textContent += char; + } + } + + /** + * Animate a progress bar. + * @param {Node} line - The line element to render. + */ + async progress(line) { + const progressLength = line.getAttribute(`${this.pfx}-progressLength`) + || this.progressLength; + const progressChar = line.getAttribute(`${this.pfx}-progressChar`) + || this.progressChar; + const chars = progressChar.repeat(progressLength); + const progressPercent = line.getAttribute(`${this.pfx}-progressPercent`) + || this.progressPercent; + line.textContent = ''; + this.container.appendChild(line); + + for (let i = 1; i < chars.length + 1; i++) { + await this._wait(this.typeDelay); + const percent = Math.round(i / chars.length * 100); + line.textContent = `${chars.slice(0, i)} ${percent}%`; + if (percent>progressPercent) { + break; + } + } + } + + /** + * Helper function for animation delays, called with `await`. + * @param {number} time - Timeout, in ms. + */ + _wait(time) { + return new Promise(resolve => setTimeout(resolve, time)); + } + + /** + * Converts line data objects into line elements. + * + * @param {Object[]} lineData - Dynamically loaded lines. + * @param {Object} line - Line data object. + * @returns {Element[]} - Array of line elements. + */ + lineDataToElements(lineData) { + return lineData.map(line => { + let div = document.createElement('div'); + div.innerHTML = `${line.value || ''}`; + + return div.firstElementChild; + }); + } + + /** + * Helper function for generating attributes string. + * + * @param {Object} line - Line data object. + * @returns {string} - String of attributes. + */ + _attributes(line) { + let attrs = ''; + for (let prop in line) { + // Custom add class + if (prop === 'class') { + attrs += ` class=${line[prop]} ` + continue + } + if (prop === 'type') { + attrs += `${this.pfx}="${line[prop]}" ` + } else if (prop !== 'value') { + attrs += `${this.pfx}-${prop}="${line[prop]}" ` + } + } + return attrs; + } +} + +/** +* HTML API: If current script has container(s) specified, initialise Termynal. +*/ +if (document.currentScript && document.currentScript.hasAttribute('data-termynal-container')) { + const containers = document.currentScript.getAttribute('data-termynal-container'); + containers.split('|') + .forEach(container => new Termynal(container)) +} diff --git a/docs/assets/expert-parallelism.png b/docs/assets/expert-parallelism.png new file mode 100644 index 0000000..66e8689 Binary files /dev/null and b/docs/assets/expert-parallelism.png differ diff --git a/docs/assets/nemo-framework-overview.png b/docs/assets/nemo-framework-overview.png new file mode 100644 index 0000000..7a47b5f Binary files /dev/null and b/docs/assets/nemo-framework-overview.png differ diff --git a/docs/assets/nemo-rl-actors.png b/docs/assets/nemo-rl-actors.png new file mode 100644 index 0000000..fe360c9 Binary files /dev/null and b/docs/assets/nemo-rl-actors.png differ diff --git a/docs/assets/sequence-parallelism.png b/docs/assets/sequence-parallelism.png new file mode 100644 index 0000000..aba01de Binary files /dev/null and b/docs/assets/sequence-parallelism.png differ diff --git a/docs/assets/tensor-parallelism.png b/docs/assets/tensor-parallelism.png new file mode 100644 index 0000000..33f25b1 Binary files /dev/null and b/docs/assets/tensor-parallelism.png differ diff --git a/docs/conf.py b/docs/conf.py new file mode 100644 index 0000000..ee3a295 --- /dev/null +++ b/docs/conf.py @@ -0,0 +1,111 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# Configuration file for the Sphinx documentation builder. +# +# For the full list of built-in configuration values, see the documentation: +# https://www.sphinx-doc.org/en/master/usage/configuration.html + +# -- Project information ----------------------------------------------------- +# https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information + +import os + +project = "Nemotron" +copyright = "2025, NVIDIA Corporation" +author = "NVIDIA Corporation" + +# Version is set by CI via DOCS_VERSION env var (dev or stable) +# Defaults to "dev" for local builds +release = os.environ.get("DOCS_VERSION", "dev") + +# -- General configuration --------------------------------------------------- +# https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration + +extensions = [ + "myst_parser", # For our markdown docs + "sphinx.ext.viewcode", # For adding a link to view source code in docs + "sphinx.ext.napoleon", # For google style docstrings + "sphinx_copybutton", # For copy button in code blocks + "sphinx_design", # For grid cards and other design elements + "sphinxcontrib.mermaid", # For mermaid diagrams +] + +templates_path = ["_templates"] +exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"] + +# -- Options for MyST Parser (Markdown) -------------------------------------- +# MyST Parser settings +myst_enable_extensions = [ + "dollarmath", # Enables dollar math for inline math + "amsmath", # Enables LaTeX math for display mode + "colon_fence", # Enables code blocks using ::: delimiters instead of ``` + "deflist", # Supports definition lists with term: definition format + "fieldlist", # Enables field lists for metadata like :author: Name + "tasklist", # Adds support for GitHub-style task lists with [ ] and [x] + "attrs_block", # Enables setting attributes on block elements using {#id .class key=val} +] +myst_heading_anchors = 5 # Generates anchor links for headings up to level 5 + +# Configure MyST to handle mermaid code blocks +myst_fence_as_directive = ["mermaid"] + +# -- Options for Mermaid ----------------------------------------------------- +# Configure mermaid diagrams +mermaid_version = "latest" # Use the latest version of mermaid + +# -- Options for HTML output ------------------------------------------------- +# https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output + +# -- Custom static files for Termynal terminal animations ------------------- +html_static_path = ["_static"] +html_css_files = [ + "css/termynal.css", +] +html_js_files = [ + "js/termynal.js", + "js/termynal-init.js", +] + +html_theme = "nvidia_sphinx_theme" +html_theme_options = { + "switcher": { + "json_url": "https://nvidia-nemo.github.io/Nemotron/versions.json", + "version_match": release, + }, + "icon_links": [ + { + "name": "GitHub", + "url": "https://github.com/NVIDIA/nemotron", + "icon": "fa-brands fa-github", + } + ], + "extra_head": { + """ + + """ + }, + "extra_footer": { + """ + + """ + }, +} +html_extra_path = ["project.json", "versions.json"] + +# Github links are now getting rate limited from the Github Actions +linkcheck_ignore = [ + ".*github\\.com.*", + ".*githubusercontent\\.com.*", +] diff --git a/docs/index.md b/docs/index.md new file mode 100644 index 0000000..72a8b44 --- /dev/null +++ b/docs/index.md @@ -0,0 +1,150 @@ +# Nemotron Training Recipes + +**Open and efficient models for agentic AI** — reproducible training pipelines with fully transparent data, techniques, and weights. + +
+ +
+ +## Quick Start + +
+ +```console +// Install the Nemotron training recipes +$ git clone https://github.com/NVIDIA/nemotron +$ cd nemotron && uv sync + +// Run the full Nano3 pipeline +$ uv run nemotron nano3 data prep pretrain --run YOUR-CLUSTER +$ uv run nemotron nano3 pretrain --run YOUR-CLUSTER +$ uv run nemotron nano3 data prep sft --run YOUR-CLUSTER +$ uv run nemotron nano3 sft --run YOUR-CLUSTER +$ uv run nemotron nano3 data prep rl --run YOUR-CLUSTER +$ uv run nemotron nano3 rl --run YOUR-CLUSTER +``` + +
+ +> **Note**: The `--run YOUR-CLUSTER` flag submits jobs to your configured Slurm cluster via [NeMo-Run](train/nemo-run.md). See [Execution through NeMo-Run](train/nemo-run.md) for setup instructions. + +## Usage Cookbook & Examples + +::::{grid} 1 2 2 2 +:gutter: 3 + +:::{grid-item-card} Usage Cookbook +:link: usage-cookbook/README +:link-type: doc + +Deployment guides for Nemotron models: TensorRT-LLM, vLLM, SGLang, NIM, and Hugging Face. +::: + +:::{grid-item-card} Use Case Examples +:link: use-case-examples/README +:link-type: doc + +End-to-end applications: RAG agents, ML agents, and multi-agent systems. +::: + +:::: + +## Available Training Recipes + +::::{grid} 1 2 2 2 +:gutter: 3 + +:::{grid-item-card} Nemotron 3 Nano +:link: train/nano3/README +:link-type: doc + +31.6B total / 3.6B active parameters, 25T tokens, up to 1M context. Hybrid Mamba-Transformer with sparse MoE. + +**Stages:** Pretraining → SFT → RL +::: + +:::: + +## Training Pipeline + +The Nemotron training pipeline follows a three-stage approach with full artifact lineage tracking: + +| Stage | Name | Description | +|-------|------|-------------| +| 0 | [Pretraining](train/nano3/pretrain.md) | Base model training on large text corpus | +| 1 | [SFT](train/nano3/sft.md) | Supervised fine-tuning for instruction following | +| 2 | [RL](train/nano3/rl.md) | Reinforcement learning for alignment | + +## Why Nemotron? + +| | | +|---|---| +| **Open Models** | Transparent training data, techniques, and weights for community innovation | +| **Compute Efficiency** | Model pruning enabling higher throughput via TensorRT-LLM | +| **High Accuracy** | Built on frontier open models with human-aligned reasoning | +| **Flexible Deployment** | Deploy anywhere — edge, single GPU, or data center with NIM | + +## Key Features + +- **Complete Pipelines** — From raw data to deployment-ready models +- **[Artifact Lineage](train/artifacts.md)** — Full traceability via [W&B](train/wandb.md) from data to model +- **Production-Grade** — Built on [NVIDIA's NeMo stack](train/nvidia-stack.md) (Megatron-Bridge, NeMo-RL) +- **Reproducible** — Versioned configs, data blends, and checkpoints + +## Resources + +- [Tech Report](https://research.nvidia.com/labs/nemotron/files/NVIDIA-Nemotron-3-Nano-Technical-Report.pdf) — Nemotron 3 Nano methodology +- [Model Weights](https://huggingface.co/collections/nvidia/nvidia-nemotron-v3) — Pre-trained checkpoints on HuggingFace +- [Pre-training Datasets](https://huggingface.co/collections/nvidia/nemotron-pre-training-datasets) — Open pre-training data +- [Post-training Datasets](https://huggingface.co/collections/nvidia/nemotron-post-training-v3) — SFT and RL data +- [Artifact Lineage](train/artifacts.md) — W&B integration guide + +```{toctree} +:caption: Usage Cookbook +:hidden: + +usage-cookbook/README.md +usage-cookbook/Nemotron-Nano2-VL/README.md +usage-cookbook/Nemotron-Parse-v1.1/README.md +``` + +```{toctree} +:caption: Use Case Examples +:hidden: + +use-case-examples/README.md +use-case-examples/Simple Nemotron-3-Nano Usage Example/README.md +use-case-examples/Data Science ML Agent/README.md +use-case-examples/RAG Agent with Nemotron RAG Models/README.md +``` + +```{toctree} +:caption: Training Recipes +:hidden: + +train/nano3/README.md +train/artifacts.md +``` + +```{toctree} +:caption: Nano3 Stages +:hidden: + +train/nano3/pretrain.md +train/nano3/sft.md +train/nano3/rl.md +train/nano3/import.md +``` + +```{toctree} +:caption: Nemotron Kit +:hidden: + +train/kit.md +train/nvidia-stack.md +train/nemo-run.md +train/omegaconf.md +train/wandb.md +train/cli.md +train/data-prep.md +``` diff --git a/docs/project.json b/docs/project.json new file mode 100644 index 0000000..bb84a0c --- /dev/null +++ b/docs/project.json @@ -0,0 +1,4 @@ +{ + "name": "nemotron", + "version": "latest" +} diff --git a/docs/train/artifacts.md b/docs/train/artifacts.md new file mode 100644 index 0000000..35e372a --- /dev/null +++ b/docs/train/artifacts.md @@ -0,0 +1,304 @@ +# Artifact Lineage & W&B Integration + +The Nemotron training pipeline provides complete lineage tracking from raw data to final model through [Weights & Biases](./wandb.md) artifacts. Every data transformation and model checkpoint is versioned and linked, enabling full reproducibility and traceability. + +> **Note**: The artifact system currently requires [W&B](./wandb.md). Backend-agnostic artifact tracking is in development. + +## Why Lineage Matters + +- **Reproducibility**: Trace any model back to its exact training data and configuration +- **Debugging**: Identify which data or training stage caused a regression +- **Compliance**: Audit trail for model provenance and data usage +- **Collaboration**: Share artifacts across teams with version control + +## End-to-End Lineage + +The training pipeline produces six artifact types across three stages: + +```mermaid +%%{init: {'theme': 'base', 'themeVariables': { 'primaryBorderColor': '#333333', 'lineColor': '#333333', 'primaryTextColor': '#333333', 'clusterBkg': '#ffffff', 'clusterBorder': '#333333'}}}%% +flowchart TB + subgraph stage0["Stage 0: Pretraining"] + raw0["Raw Text Data"] --> dp0["data_prep.py"] + dp0 --> data0["DataBlendsArtifact-pretrain
(bin/idx)"] + data0 --> train0["train.py"] + train0 --> model0["ModelArtifact-pretrain"] + end + + subgraph stage1["Stage 1: SFT"] + raw1["Instruction Data"] --> dp1["data_prep.py"] + dp1 --> data1["DataBlendsArtifact-sft
(.npy)"] + model0 --> train1["train.py"] + data1 --> train1 + train1 --> model1["ModelArtifact-sft"] + end + + subgraph stage2["Stage 2: RL"] + raw2["RL Prompts"] --> dp2["data_prep.py"] + dp2 --> data2["DataBlendsArtifact-rl
(JSONL)"] + model1 --> train2["train.py"] + data2 --> train2 + train2 --> model2["ModelArtifact-rl
(Final Model)"] + end + + style stage0 fill:#e1f5fe,stroke:#2196f3 + style stage1 fill:#f3e5f5,stroke:#9c27b0 + style stage2 fill:#e8f5e9,stroke:#4caf50 +``` + +## Artifact Types + +| Artifact | Stage | Format | Description | +|----------|-------|--------|-------------| +| `DataBlendsArtifact-pretrain` | [0](./nano3/pretrain.md) | bin/idx | Tokenized pretraining data in Megatron format | +| `ModelArtifact-pretrain` | [0](./nano3/pretrain.md) | checkpoint | Base model after pretraining | +| `DataBlendsArtifact-sft` | [1](./nano3/sft.md) | .npy | Packed SFT sequences with loss masks | +| `ModelArtifact-sft` | [1](./nano3/sft.md) | checkpoint | Instruction-tuned model | +| `DataBlendsArtifact-rl` | [2](./nano3/rl.md) | JSONL | RL prompts for [NeMo-RL](./nvidia-stack.md#nemo-rl) | +| `ModelArtifact-rl` | [2](./nano3/rl.md) | checkpoint | Final aligned model | + +## W&B Configuration + +Configure W&B in your `env.toml`: + +```toml +[wandb] +project = "nemotron" +entity = "YOUR-TEAM" +``` + +Authenticate before running: + +```bash +wandb login +``` + +## Using Artifacts + +### Semantic URIs + +Reference artifacts by semantic URI in configs and CLI: + +``` +art://DataBlendsArtifact-pretrain:latest # Latest version +art://ModelArtifact-sft:v3 # Specific version +art://ModelArtifact-rl:production # Alias +``` + +### CLI Options + +Override artifact inputs via [CLI](./cli.md#artifact-inputs): + +```bash +# Use specific data artifact +uv run nemotron nano3 pretrain --art.data DataBlendsArtifact-pretrain:v2 + +# Use imported model +uv run nemotron nano3 sft --art.model my-custom-pretrain:latest +``` + +### Config Resolvers + +Reference artifact paths in YAML configs: + +```yaml +run: + data: DataBlendsArtifact-pretrain:latest + +recipe: + per_split_data_args_path: ${art:data,path}/blend.json +``` + +The `${art:data,path}` resolver extracts the filesystem path from the artifact. + +## Viewing Lineage in W&B + +After running the pipeline, view lineage in the W&B UI: + +1. Navigate to your project's **Artifacts** tab +2. Select any artifact (e.g., `ModelArtifact-rl`) +3. Click the **Graph** view to see upstream dependencies +4. Trace back through each stage to the original data sources + +The lineage graph shows: +- Which data artifacts were used to train each model +- Which model checkpoints were inputs to each stage +- Version history and metadata for each artifact + +## Importing External Assets + +Import existing models or data into the artifact system: + +### Model Import + +```bash +# Import pretrain checkpoint +uv run nemotron nano3 model import pretrain /path/to/checkpoint --step 50000 + +# Import SFT checkpoint +uv run nemotron nano3 model import sft /path/to/sft_model --step 10000 + +# Import RL checkpoint +uv run nemotron nano3 model import rl /path/to/rl_model --step 5000 +``` + +### Data Import + +```bash +# Import pretrain data (path to blend.json) +uv run nemotron nano3 data import pretrain /path/to/blend.json + +# Import SFT data (directory with blend.json) +uv run nemotron nano3 data import sft /path/to/sft_data/ + +# Import RL data (directory with manifest.json) +uv run nemotron nano3 data import rl /path/to/rl_data/ +``` + +See [Importing Models & Data](./nano3/import.md) for detailed directory structures. + +## Troubleshooting + +### "Artifact not found" + +- Verify `project` and `entity` in `env.toml` match where artifacts were created +- Check artifact name spelling and version tag +- Ensure you're authenticated: `wandb login` + +### Version Resolution Issues + +- Use explicit versions (`artifact:v3`) instead of `:latest` for reproducibility +- Check artifact aliases in W&B UI + +### Missing Lineage Links + +- Artifacts must be created by the pipeline to have automatic lineage +- Imported artifacts start a new lineage chain +- Manual uploads via W&B UI don't create lineage links + +## Programmatic Access + +Access artifacts programmatically via the kit module: + +```python +from nemotron.kit import PretrainBlendsArtifact, ModelArtifact + +# Load from semantic URI +data = PretrainBlendsArtifact.from_uri("art://DataBlendsArtifact-pretrain:latest") +print(f"Data path: {data.path}") +print(f"Total tokens: {data.total_tokens}") + +# Load model artifact +model = ModelArtifact.from_uri("art://ModelArtifact-sft:latest") +print(f"Training step: {model.step}") +print(f"Loss: {model.loss}") +``` + +For framework details, see [Nemotron Kit](./kit.md). + +## Creating Custom Artifacts + +Create custom artifact types by subclassing `Artifact`. Typed fields are automatically synced to `metadata.json` and available via the `${art:NAME,FIELD}` resolver in configs. + +### Basic Pattern + +```python +from pathlib import Path +from typing import Annotated +from pydantic import Field +from nemotron.kit.artifacts.base import Artifact + + +class MyDataArtifact(Artifact): + """Custom data artifact with typed metadata.""" + + # Typed fields become metadata - accessible via ${art:data,num_samples} + num_samples: Annotated[int, Field(ge=0, description="Number of samples")] + source_url: Annotated[str | None, Field(default=None, description="Data source")] + compression: Annotated[str, Field(default="none", description="Compression type")] +``` + +### Saving Artifacts + +```python +# Create artifact pointing to output directory +artifact = MyDataArtifact( + path=Path("/output/my_data"), + num_samples=10000, + source_url="https://example.com/data.tar.gz", +) + +# Save metadata.json and publish to W&B (if configured) +artifact.save(name="MyDataArtifact-custom") +``` + +### Loading Artifacts + +```python +# Load from semantic URI +artifact = MyDataArtifact.from_uri("art://MyDataArtifact-custom:latest") +print(f"Path: {artifact.path}") +print(f"Samples: {artifact.num_samples}") # IDE autocomplete works + +# Load from local path +artifact = MyDataArtifact.load(path=Path("/output/my_data")) +``` + +### Using in Configs + +Once saved, custom artifacts work with the resolver system: + +```yaml +run: + data: MyDataArtifact-custom:latest + +recipe: + data_path: ${art:data,path} + num_samples: ${art:data,num_samples} # Resolves to 10000 +``` + +### Customizing W&B Uploads + +Override methods to control what gets uploaded to W&B: + +```python +class MyModelArtifact(Artifact): + step: int + + def get_wandb_files(self) -> list[tuple[str, str]]: + """Files to upload to W&B storage (small files only).""" + files = super().get_wandb_files() # Includes metadata.json + # Add config files + config_path = self.path / "config.yaml" + if config_path.exists(): + files.append((str(config_path), "config.yaml")) + return files + + def get_wandb_references(self) -> list[tuple[str, str]]: + """References to shared storage (large files - not uploaded).""" + # Reference checkpoint directory without uploading + return [(f"file://{self.path.resolve()}", "checkpoint")] +``` + +### Input Lineage + +Track input dependencies by overriding `get_input_uris()`: + +```python +class ProcessedDataArtifact(Artifact): + source_artifact: str # e.g., "art://RawDataArtifact:v1" + + def get_input_uris(self) -> list[str]: + """Input artifacts for lineage graph.""" + return [self.source_artifact] +``` + +## Further Reading + +- [Nemotron Kit](./kit.md) — Artifact system internals +- [OmegaConf Configuration](./omegaconf.md) — `${art:...}` interpolations and lineage +- [W&B Integration](./wandb.md) — Credentials and configuration +- [Importing Models & Data](./nano3/import.md) — Import commands and directory structures +- [CLI Framework](./cli.md) — CLI building and artifact inputs +- [Data Preparation](./data-prep.md) — Data preparation module +- [Nano3 Recipe](./nano3/README.md) — Complete training pipeline diff --git a/docs/train/cli.md b/docs/train/cli.md new file mode 100644 index 0000000..b7d40ec --- /dev/null +++ b/docs/train/cli.md @@ -0,0 +1,490 @@ +# CLI Framework + +The `nemotron.kit` CLI framework is built on [Typer](https://typer.tiangolo.com/) and provides tools for building hierarchical command-line interfaces for training recipes, with native integration with NeMo-Run for remote execution. + +
+ +```console +$ uv run nemotron nano3 sft --help +Usage: nemotron nano3 sft [OPTIONS] + + Run supervised fine-tuning with Megatron-Bridge (stage1). + +╭─ Options ────────────────────────────────────────────────────────────────╮ +│ --help -h Show this message and exit. │ +╰──────────────────────────────────────────────────────────────────────────╯ +╭─ Global Options ─────────────────────────────────────────────────────────╮ +│ -c, --config NAME Config name or path │ +│ -r, --run PROFILE Submit to cluster (attached) │ +│ -b, --batch PROFILE Submit to cluster (detached) │ +│ -d, --dry-run Preview config without execution │ +│ --stage Stage files for interactive debugging │ +╰──────────────────────────────────────────────────────────────────────────╯ +╭─ Configs (-c/--config) ──────────────────────────────────────────────────╮ +│ Built-in: default, tiny │ +│ Custom: -c /path/to/your/config.yaml │ +╰──────────────────────────────────────────────────────────────────────────╯ +╭─ Artifact Overrides (W&B artifact references) ───────────────────────────╮ +│ run.model Base model checkpoint artifact │ +│ run.data SFT data artifact (packed .npy) │ +╰──────────────────────────────────────────────────────────────────────────╯ +╭─ Run Overrides (override env.toml settings) ─────────────────────────────╮ +│ run.env.nodes Number of nodes │ +│ run.env.nproc_per_node GPUs per node │ +│ run.env.partition Slurm partition │ +│ run.env.account Slurm account │ +│ run.env.time Job time limit (e.g., 04:00:00) │ +│ run.env.container_image Override container image │ +╰──────────────────────────────────────────────────────────────────────────╯ +╭─ env.toml Profiles ──────────────────────────────────────────────────────╮ +│ Available profiles: my-cluster, my-cluster-large │ +│ Usage: --run PROFILE or --batch PROFILE │ +╰──────────────────────────────────────────────────────────────────────────╯ +╭─ Examples ───────────────────────────────────────────────────────────────╮ +│ $ ... sft -c tiny Local execution │ +│ $ ... sft -c tiny --dry-run Preview config │ +│ $ ... sft -c tiny --run my-cluster Submit to cluster │ +│ $ ... sft -c tiny -r cluster run.env.nodes=4 │ +╰──────────────────────────────────────────────────────────────────────────╯ +``` + +
+ +## Overview + +The CLI framework enables: + +- **Nested Commands** — Build hierarchical CLIs like `uv run nemotron nano3 data prep pretrain` +- **Config Integration** — Automatic YAML config loading with dotlist overrides +- **[Artifact Resolution](./artifacts.md)** — Map [W&B artifacts](./wandb.md) to config fields automatically +- **[Remote Execution](./nemo-run.md)** — Submit jobs to Slurm via NeMo-Run with `--run` / `--batch` + +For artifacts and configuration, see [Nemotron Kit](./kit.md). For execution profiles, see [Execution through NeMo-Run](./nemo-run.md). + +## Architecture + +```mermaid +%%{init: {'theme': 'base', 'themeVariables': { 'primaryBorderColor': '#333333', 'lineColor': '#333333', 'primaryTextColor': '#333333', 'clusterBkg': '#f5f5f5', 'clusterBorder': '#666666'}}}%% +flowchart LR + subgraph cli["CLI Layer (Typer)"] + Root["nemotron"] + Recipe["nano3"] + Commands["pretrain/sft/rl"] + end + + subgraph config["Configuration"] + YAML["YAML Config"] + Dotlist["Dotlist Overrides"] + Artifacts["Artifact Resolution"] + end + + subgraph execution["Execution Modes"] + Local["Local (torchrun)"] + NemoRun["NeMo-Run"] + Ray["Ray Jobs"] + end + + Root --> Recipe --> Commands + Commands --> config + config --> execution +``` + +## The @recipe Decorator + +Commands are defined using the `@recipe` decorator, which wraps Typer commands with standardized config loading and execution logic: + +```python +from nemotron.kit.cli.recipe import recipe +import typer + +@recipe( + name="nano3/pretrain", + script_path="src/nemotron/recipes/nano3/stage0_pretrain/train.py", + config_dir="src/nemotron/recipes/nano3/stage0_pretrain/config", + default_config="default", + packager="self_contained", + torchrun=True, + ray=False, + artifacts={ + "data": { + "default": "PretrainBlendsArtifact-default", + "mappings": {"path": "recipe.per_split_data_args_path"}, + }, + }, +) +def pretrain(ctx: typer.Context) -> None: + """Run pretraining with Megatron-Bridge.""" + pass # Execution handled by decorator +``` + +### Decorator Parameters + +| Parameter | Type | Description | +|-----------|------|-------------| +| `name` | `str` | Recipe identifier (e.g., `"nano3/pretrain"`) | +| `script_path` | `str` | Path to the training script | +| `config_dir` | `str` | Directory containing YAML configs | +| `default_config` | `str` | Default config name (without `.yaml`) | +| `packager` | `str` | Code packaging strategy: `"pattern"`, `"code"`, `"self_contained"` | +| `torchrun` | `bool` | Use `torch.distributed.run` launcher | +| `ray` | `bool` | Submit as Ray job (for data prep, RL) | +| `artifacts` | `dict` | Artifact-to-config mappings | +| `run_command` | `str` | Custom command template for Ray jobs | + +### Registering Commands + +Commands are registered on Typer apps with specific context settings: + +```python +nano3_app = typer.Typer(name="nano3", help="Nano3 training recipe") + +nano3_app.command( + name="pretrain", + context_settings={ + "allow_extra_args": True, # Capture dotlist overrides + "ignore_unknown_options": True, # Pass through unknown flags + }, +)(pretrain) +``` + +The `allow_extra_args=True` setting is critical—it allows commands to capture Hydra-style `key=value` overrides. + +## Global Options + +All recipe commands automatically receive these global options: + +| Option | Short | Description | +|--------|-------|-------------| +| `--config` | `-c` | Config name or path (from `config_dir`) | +| `--run` | `-r` | Attached [NeMo-Run](./nemo-run.md) execution (waits, streams logs) | +| `--batch` | `-b` | Detached [NeMo-Run](./nemo-run.md) execution (submits, exits) | +| `--dry-run` | `-d` | Preview config without executing | +| `--stage` | | Stage files to remote for debugging | +| `key=value` | | Dotlist overrides (any position) | + +### GlobalContext + +Global options are captured in a `GlobalContext` dataclass: + +```python +@dataclass +class GlobalContext: + config: str | None = None # -c/--config value + run: str | None = None # --run profile name + batch: str | None = None # --batch profile name + dry_run: bool = False # --dry-run flag + stage: bool = False # --stage flag + dotlist: list[str] # key=value overrides + passthrough: list[str] # Unknown args for script +``` + +Key properties: +- `mode` → `"run"`, `"batch"`, or `"local"` +- `profile` → Environment profile name (from `--run` or `--batch`) + +## Configuration Pipeline + +The `ConfigBuilder` class orchestrates config loading: + +```mermaid +%%{init: {'theme': 'base', 'themeVariables': { 'primaryBorderColor': '#333333', 'lineColor': '#333333', 'primaryTextColor': '#333333'}}}%% +flowchart LR + Default["default.yaml"] --> Merge + Config["--config"] --> Merge + Dotlist["key=value"] --> Merge + Merge --> JobConfig["job.yaml"] + Merge --> TrainConfig["train.yaml"] +``` + +### Two-Config System + +The CLI generates two config files: + +| File | Purpose | +|------|---------| +| `job.yaml` | Full provenance: config + CLI args + env profile | +| `train.yaml` | Clean config for script (paths rewritten for remote) | + +**job.yaml structure:** +```yaml +recipe: + _target_: megatron.bridge.recipes... + per_split_data_args_path: /data/blend.json +train: + train_iters: 1000 +run: + mode: "run" + profile: "my-cluster" + env: + executor: "slurm" + nodes: 4 + gpus_per_node: 8 + cli: + argv: ["nemotron", "nano3", "pretrain", "-c", "tiny", "--run", "my-cluster"] + dotlist: ["train.train_iters=1000"] + wandb: + entity: "nvidia" + project: "nemotron" +``` + +### Dotlist Overrides + +Override any config value with `key.path=value` syntax: + +```bash +# Override nested values +uv run nemotron nano3 pretrain train.train_iters=5000 + +# Multiple overrides +uv run nemotron nano3 pretrain \ + train.train_iters=5000 \ + train.micro_batch_size=2 \ + run.data=PretrainBlendsArtifact-v2:latest +``` + +## Execution Modes + +### Local Execution + +Without `--run` or `--batch`, commands execute locally: + +```bash +# Local execution (no NeMo-Run) +uv run nemotron nano3 pretrain -c tiny + +# Equivalent to: +python -m torch.distributed.run \ + --nproc_per_node=1 \ + src/nemotron/recipes/nano3/stage0_pretrain/train.py \ + --config train.yaml +``` + +### NeMo-Run Attached (`--run`) + +Submit job and wait for completion, streaming logs: + +```bash +uv run nemotron nano3 pretrain -c tiny --run MY-CLUSTER +``` + +### NeMo-Run Detached (`--batch`) + +Submit job and exit immediately: + +```bash +uv run nemotron nano3 pretrain -c tiny --batch MY-CLUSTER +``` + +### Ray Jobs + +For recipes with `ray=True` (data prep, RL), jobs are submitted via Ray: + +```bash +# Data prep uses Ray for distributed processing +uv run nemotron nano3 data prep pretrain --run MY-CLUSTER + +# RL uses Ray for actor orchestration +uv run nemotron nano3 rl -c tiny --run MY-CLUSTER +``` + +## Artifact Inputs + +Map W&B artifacts to config fields: + +```python +@recipe( + ..., + artifacts={ + "data": { + "default": "PretrainBlendsArtifact-default:latest", + "mappings": {"path": "recipe.per_split_data_args_path"}, + }, + "model": { + "default": "ModelArtifact-sft:latest", + "mappings": {"path": "model.init_from_path"}, + }, + }, +) +``` + +### CLI Override + +Override artifacts via dotlist: + +```bash +uv run nemotron nano3 sft --run MY-CLUSTER \ + run.data=PretrainBlendsArtifact-v2:latest \ + run.model=ModelArtifact-pretrain:v3 +``` + +### Config Resolver + +Use `${art:...}` in YAML configs: + +```yaml +run: + data: PretrainBlendsArtifact-default:latest + +recipe: + per_split_data_args_path: ${art:data,path}/blend.json +``` + +## Packager Types + +Control how code is synced to remote: + +| Packager | Description | Use Case | +|----------|-------------|----------| +| `pattern` | Minimal sync (`main.py` + `config.yaml`) | Default | +| `code` | Full codebase with exclusions | Ray jobs needing imports | +| `self_contained` | Inline all `nemotron.*` imports | Isolated scripts | + +## CLI Examples + +
+ +```console +// Preview config without executing +$ uv run nemotron nano3 pretrain -c tiny --dry-run + +// Submit to cluster (attached) +$ uv run nemotron nano3 pretrain -c tiny --run MY-CLUSTER + +// Submit to cluster (detached) +$ uv run nemotron nano3 pretrain -c tiny --batch MY-CLUSTER + +// Override training iterations +$ uv run nemotron nano3 pretrain -c tiny --run MY-CLUSTER train.train_iters=5000 + +// Stage files for interactive debugging +$ uv run nemotron nano3 pretrain -c tiny --run MY-CLUSTER --stage + +// Data preparation (Ray job) +$ uv run nemotron nano3 data prep pretrain --run MY-CLUSTER + +// RL training (Ray job) +$ uv run nemotron nano3 rl -c tiny --run MY-CLUSTER +``` + +
+ +## Building a Recipe + +### Step 1: Create Config Directory + +``` +src/nemotron/recipes/myrecipe/ +├── config/ +│ ├── default.yaml +│ └── tiny.yaml +├── train.py +└── data_prep.py +``` + +### Step 2: Define Training Script + +```python +# train.py +import argparse +from pathlib import Path +from omegaconf import OmegaConf + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--config", type=Path, required=True) + args, unknown = parser.parse_known_args() + + # Load config + cfg = OmegaConf.load(args.config) + + # Apply any remaining overrides + if unknown: + overrides = OmegaConf.from_dotlist(unknown) + cfg = OmegaConf.merge(cfg, overrides) + + # Run training... + print(f"Training with {cfg.train.train_iters} iterations") + +if __name__ == "__main__": + main() +``` + +### Step 3: Create CLI Command + +```python +# src/nemotron/cli/myrecipe/train.py +from nemotron.kit.cli.recipe import recipe +import typer + +@recipe( + name="myrecipe/train", + script_path="src/nemotron/recipes/myrecipe/train.py", + config_dir="src/nemotron/recipes/myrecipe/config", + default_config="default", + torchrun=True, +) +def train(ctx: typer.Context) -> None: + """Run training for my recipe.""" + pass +``` + +### Step 4: Register in CLI + +```python +# src/nemotron/cli/myrecipe/__init__.py +import typer +from .train import train + +app = typer.Typer(name="myrecipe", help="My training recipe") + +app.command( + name="train", + context_settings={"allow_extra_args": True, "ignore_unknown_options": True}, +)(train) +``` + +### Step 5: Add to Main CLI + +```python +# src/nemotron/cli/bin/nemotron.py +from nemotron.cli.myrecipe import app as myrecipe_app + +main_app.add_typer(myrecipe_app, name="myrecipe") +``` + +### Step 6: Run + +```bash +# Test locally +uv run nemotron myrecipe train -c tiny + +# Run on cluster +uv run nemotron myrecipe train -c tiny --run MY-CLUSTER +``` + +## API Reference + +### Recipe Decorator + +| Export | Description | +|--------|-------------| +| `@recipe` | Decorator for training commands | +| `ConfigBuilder` | Config loading and merging | +| `GlobalContext` | Shared CLI state | +| `split_unknown_args()` | Parse dotlist vs passthrough args | + +### Execution + +| Export | Description | +|--------|-------------| +| `build_executor()` | Create NeMo-Run executor from profile | +| `load_env_profile()` | Load profile from `env.toml` | + +## Further Reading + +- [Nemotron Kit](./kit.md) — Artifacts, configuration, lineage tracking +- [Execution through NeMo-Run](./nemo-run.md) — Execution profiles and env.toml +- [Data Preparation](./data-prep.md) — Data preparation module +- [Artifact Lineage](./artifacts.md) — W&B artifact system and lineage tracking +- [W&B Integration](./wandb.md) — Credentials and configuration +- [Nano3 Recipe](./nano3/README.md) — Complete training recipe example diff --git a/docs/train/data-prep.md b/docs/train/data-prep.md new file mode 100644 index 0000000..bf38536 --- /dev/null +++ b/docs/train/data-prep.md @@ -0,0 +1,568 @@ +# Data Preparation Module + +The `nemotron.data_prep` module focuses on **last-mile data processing**—transforming curated datasets into training-ready formats. It bridges the gap between data curation (handled by [NeMo Curator](https://github.com/NVIDIA-NeMo/Curator)) and model training, producing outputs compatible with the NVIDIA AI training stack. + +> **Coming Soon**: Native integration with [NeMo Curator](https://github.com/NVIDIA-NeMo/Curator) for data curation and [NeMo Data Designer](https://github.com/NVIDIA-NeMo/DataDesigner) for synthetic data generation. These integrations will enable end-to-end data pipelines from raw sources to training-ready formats. + +## Overview + +Built on top of [Ray](https://ray.io/), the data preparation module provides: + +- **Last-mile processing** — Convert curated datasets to training-ready formats (tokenization, packing, chat templating) +- **Distributed processing** — Scale from a single machine to a cluster of workers using Ray actors +- **Cloud-native I/O** — Read from HuggingFace Hub (`hf://`), S3 (`s3://`), GCS (`gs://`), or local paths via fsspec +- **Deterministic output** — Frozen shard plans ensure reproducible results across runs +- **Resumable pipelines** — Skip completed shards on restart; verify output integrity with checksums + +### Data Pipeline: Curator → Data Prep → Training + +This module is designed to work alongside [NeMo Curator](https://github.com/NVIDIA-NeMo/Curator) in a two-stage data pipeline: + +```mermaid +%%{init: {'theme': 'base', 'themeVariables': { 'primaryBorderColor': '#333333', 'lineColor': '#333333', 'primaryTextColor': '#333333', 'clusterBkg': '#ffffff', 'clusterBorder': '#333333'}}}%% +flowchart LR + subgraph sources["📁 Raw Data"] + CC["CommonCrawl"] + HF["HuggingFace"] + Custom["Custom Sources"] + end + + subgraph curator["🔧 NeMo Curator"] + C1["Deduplication"] + C2["Quality Filtering"] + C3["Language ID"] + C4["PII Removal"] + C1 --- C2 --- C3 --- C4 + end + + subgraph dataprep["⚡ Data Prep"] + D1["Tokenization"] + D2["Chat Templating"] + D3["Sequence Packing"] + D4["Loss Mask Creation"] + D1 --- D2 --- D3 --- D4 + end + + subgraph training["🚀 Training"] + T1["Megatron-Bridge"] + T2["NeMo-RL"] + end + + sources --> curator + curator -->|"Curated Data"| dataprep + dataprep -->|"bin/idx, .npy, JSONL"| training +``` + +**Typical workflow:** +1. Use **[NeMo Curator](https://github.com/NVIDIA-NeMo/Curator)** to curate raw data at scale—deduplication, quality filtering, language identification, PII removal +2. Use **Data Prep** to transform curated data into training-ready formats—tokenization, chat templating, sequence packing, loss mask generation + +This separation allows you to curate once and prepare data multiple times for different training configurations (different tokenizers, sequence lengths, or output formats). + +### Recipe Integration + +Each training stage in a recipe includes a dedicated data preparation step that transforms source data into the format required by that stage's training framework: + +| Stage | Data Prep Output | Training Framework | Guide | +|-------|------------------|-------------------|-------| +| Stage 0: Pretrain | bin/idx indexed datasets | [Megatron-Bridge](./nvidia-stack.md#megatron-bridge) | [pretrain.md](./nano3/pretrain.md#data-preparation) | +| Stage 1: SFT | Packed .npy with loss masks | [Megatron-Bridge](./nvidia-stack.md#megatron-bridge) | [sft.md](./nano3/sft.md#data-preparation) | +| Stage 2: RL | JSONL with OpenAI chat format | [NeMo-RL](./nvidia-stack.md#nemo-rl) | [rl.md](./nano3/rl.md#data-preparation) | + +Run data preparation for any stage using the [CLI](./cli.md): + +```bash +uv run nemotron nano3 data prep pretrain --run YOUR-CLUSTER # Stage 0 +uv run nemotron nano3 data prep sft --run YOUR-CLUSTER # Stage 1 +uv run nemotron nano3 data prep rl --run YOUR-CLUSTER # Stage 2 +``` + +> **Note**: The `--run YOUR-CLUSTER` flag submits jobs via [NeMo-Run](./nemo-run.md). See [Execution through NeMo-Run](./nemo-run.md) for setup. + +### NeMo-Run Integration + +The module integrates natively with [NeMo-Run](./nemo-run.md) for job orchestration. Submit data preparation jobs to various executors (Slurm, local, Docker, cloud) directly from your local machine: + +```bash +# Submit to Slurm cluster +uv run nemotron nano3 data prep pretrain --run YOUR-CLUSTER + +# Run locally with Ray +uv run nemotron nano3 data prep pretrain --run local + +# Preview without executing +uv run nemotron nano3 data prep pretrain --run YOUR-CLUSTER --dry-run +``` + +Configure execution profiles in `env.toml`: + +```toml +[YOUR-CLUSTER] +executor = "slurm" +account = "YOUR-ACCOUNT" +partition = "batch" +``` + +See [Execution through NeMo-Run](./nemo-run.md) for complete configuration options. + +## Choosing an API + +| API | Use When | Output Format | +|-----|----------|---------------| +| `run_data_prep()` | Simple tokenization pipelines | bin/idx | +| `last_mile_process()` | Custom formats, transforms, chat SFT | Any | + +**Use high-level API (`run_data_prep`)** for: +- Standard pretraining data tokenization +- Per-split output (train/valid/test) with `PerSplitConfig` +- When you want automatic Ray initialization and artifact tracking + +**Use low-level API (`last_mile_process`)** for: +- JSONL output with custom transforms +- Chat SFT with loss masking (`ChatSftOutputConfig`) +- Packed sequences without chat templates +- Custom pipeline orchestration + +## Supported Output Formats + +| Format | Description | Use Case | +|--------|-------------|----------| +| `binidx` | Tokenized `.bin/.idx` indexed datasets | Pretraining (default) | +| `jsonl` | JSONL files with optional transforms | SFT/RL training | +| `packed` | Packed sequences in `.npy` format | Efficient SFT training | + +## Quick Start + +### High-Level API (DataPrepConfig) + +For simple tokenization to binidx format: + +```python +from nemotron.data_prep import DataPrepConfig, run_data_prep +from pathlib import Path + +config = DataPrepConfig( + blend_path=Path("data_blend.json"), + output_dir=Path("./output"), + tokenizer_model="meta-llama/Llama-3.2-1B", +) + +artifact = run_data_prep(config) +print(f"Blend path: {artifact.path}") +``` + +### Low-Level API (last_mile_process) + +For more control over output format: + +```python +from nemotron.data_prep import last_mile_process, DataBlend, PipelineConfig +from nemotron.data_prep.config import OutputConfig, JsonlOutputConfig +from nemotron.data_prep.formats.transforms import sft + +blend = DataBlend.load("data_blend.json") + +config = PipelineConfig( + output=OutputConfig( + dir=Path("./sft_data"), + format=JsonlOutputConfig( + transform=sft(input="instruction", output="response"), + ), + ), +) + +result = last_mile_process(blend, config) +``` + +## Output Formats + +### BinIdx (Default) + +Tokenized binary format for Megatron pretraining: + +```python +from nemotron.data_prep.config import BinIdxOutputConfig + +config = PipelineConfig( + tokenizer=TokenizerConfig(model="meta-llama/Llama-3.2-1B"), + output=OutputConfig( + dir=Path("./tokenized"), + format=BinIdxOutputConfig( + shard_size="256MB", # Or num_shards=128 + dtype="int32", + ), + ), +) +``` + +### JSONL + +Structured JSONL for SFT/RL training (no tokenization): + +```python +from nemotron.data_prep.config import JsonlOutputConfig +from nemotron.data_prep.formats.transforms import sft, openai_chat + +# SFT format: {"input": "...", "output": "..."} +config = PipelineConfig( + output=OutputConfig( + dir=Path("./sft_data"), + format=JsonlOutputConfig( + transform=sft(input="instruction", output="response"), + compression="zstd", # Optional compression + ), + ), +) + +# OpenAI chat format: {"messages": [...]} +config = PipelineConfig( + output=OutputConfig( + dir=Path("./rl_data"), + format=JsonlOutputConfig( + transform=openai_chat(), + ), + ), +) +``` + +### Packed + +Packed sequences for efficient SFT training: + +```python +from nemotron.data_prep.config import PackedOutputConfig + +config = PipelineConfig( + tokenizer=TokenizerConfig(model="meta-llama/Llama-3.2-1B"), + output=OutputConfig( + dir=Path("./packed_data"), + format=PackedOutputConfig( + pack_size=4096, + algorithm="first_fit_shuffle", + ), + ), +) +``` + +### Chat SFT (Packed with Loss Masking) + +Chat-templated SFT with role-based loss masking. This format applies chat templates to OpenAI-format messages, tokenizes them, and produces packed sequences with a loss mask that zeros out system/user tokens: + +```python +from nemotron.data_prep import last_mile_process, DataBlend, PipelineConfig +from nemotron.data_prep.config import OutputConfig, ChatSftOutputConfig, TokenizerConfig + +blend = DataBlend.load("chat_data.json") + +config = PipelineConfig( + tokenizer=TokenizerConfig(model="nvidia/NVIDIA-Nemotron-Nano-9B-v2"), + output=OutputConfig( + dir=Path("./chat_sft"), + format=ChatSftOutputConfig( + chat_template="nano3", # Built-in template or path to .jinja file + messages_field="messages", # Field containing OpenAI-format messages + pack_size=4096, # Maximum tokens per packed sequence + algorithm="first_fit_shuffle", + ), + ), +) + +result = last_mile_process(blend, config) +``` + +**Input format** (OpenAI chat messages): +```json +{ + "messages": [ + {"role": "system", "content": "You are a helpful assistant."}, + {"role": "user", "content": "Hello!"}, + {"role": "assistant", "content": "Hi there!"} + ] +} +``` + +**Output**: +- `.npy` files with packed `input_ids` and `loss_mask` arrays +- Loss mask: `0` for system/user tokens, `1` for assistant tokens +- Metadata files for Megatron-Bridge compatibility + +## Transforms + +Transforms convert input records to the desired output format. They are callables that take a dict and return a dict (or `None` to skip the record). + +### Built-in Transform Factories + +```python +from nemotron.data_prep.formats.transforms import ( + sft, # SFT format: {input, output} + openai_chat, # OpenAI format: {messages: [...]} + sharegpt, # ShareGPT format: {conversations: [...]} + nemotron_rl, # Nemotron RL format: {messages, tools} + passthrough, # Pass records unchanged + select, # Select specific fields + rename, # Rename fields +) +``` + +### sft() + +Creates SFT format output: + +```python +transform = sft( + input="instruction", # Source field for input + output="response", # Source field for output + system="system_prompt" # Optional system prompt field +) + +# Input: {"instruction": "Hello", "response": "Hi!", "system_prompt": "Be helpful"} +# Output: {"input": "Hello", "output": "Hi!", "system": "Be helpful"} +``` + +### openai_chat() + +Creates OpenAI chat format: + +```python +transform = openai_chat(messages="conversation") + +# Input: {"conversation": [{"role": "user", "content": "Hi"}]} +# Output: {"messages": [{"role": "user", "content": "Hi"}]} +``` + +### sharegpt() + +Creates ShareGPT format: + +```python +transform = sharegpt(conversations="turns") + +# Input: {"turns": [{"from": "human", "value": "Hi"}]} +# Output: {"conversations": [{"from": "human", "value": "Hi"}]} +``` + +### nemotron_rl() + +Extracts messages and tools from Nemotron RL dataset format: + +```python +transform = nemotron_rl() + +# Input: { +# "responses_create_params": { +# "input": [{"role": "user", "content": "Hi"}], +# "tools": [{"name": "search", ...}] +# } +# } +# Output: {"messages": [{"role": "user", "content": "Hi"}], "tools": [...]} +``` + +Records without valid `responses_create_params.input` are skipped. + +### passthrough() + +Passes records unchanged: + +```python +transform = passthrough() + +# Input: {"any": "data"} +# Output: {"any": "data"} +``` + +### select() + +Selects specific fields: + +```python +transform = select("id", "text") + +# Input: {"id": 1, "text": "hello", "extra": "ignored"} +# Output: {"id": 1, "text": "hello"} +``` + +### rename() + +Renames fields: + +```python +transform = rename(input="question", output="answer") + +# Input: {"question": "What?", "answer": "This."} +# Output: {"input": "What?", "output": "This."} +``` + +### Custom Transforms + +You can use any callable: + +```python +# Lambda +transform = lambda r: {"input": r["q"], "output": r["a"]} if r.get("valid") else None + +# Function +def my_transform(record: dict) -> dict | None: + if len(record.get("text", "")) < 10: + return None # Skip short records + return {"input": record["question"], "output": record["answer"]} +``` + +### Filtering Records + +Return `None` from a transform to skip records. This is useful for filtering out low-quality or malformed data: + +```python +def filter_by_length(min_chars: int = 100) -> Transform: + """Skip records with text shorter than min_chars.""" + def transform(record: dict) -> dict | None: + text = record.get("text", "") + if len(text) < min_chars: + return None # Record will be skipped + return record + return transform + +# Usage +config = PipelineConfig( + output=OutputConfig( + dir=Path("./filtered"), + format=JsonlOutputConfig(transform=filter_by_length(min_chars=200)), + ), +) +``` + +Built-in transforms also filter: for example, `nemotron_rl()` skips records missing required fields. + +## Sharding Configuration + +Both `shard_size` and `num_shards` are supported (mutually exclusive): + +```python +# Target shard size (default) +format=JsonlOutputConfig(shard_size="256MB") + +# Explicit shard count +format=JsonlOutputConfig(num_shards=64) +``` + +Supported size formats: `"256MB"`, `"1G"`, `"500MiB"`, etc. + +## Per-Split Output + +Generate separate train/valid/test outputs using `PerSplitConfig`: + +```python +from nemotron.data_prep import DataPrepConfig, PerSplitConfig +from pathlib import Path + +config = DataPrepConfig( + blend_path=Path("blend.json"), + output_dir=Path("./output"), + tokenizer_model="nvidia/NVIDIA-Nemotron-Nano-9B-v2", + per_split=PerSplitConfig( + enabled=True, + valid_shards=1, # Number of validation shards + test_shards=1, # Number of test shards + ), +) +``` + +**Output structure:** +``` +output/ +├── train/ +│ ├── shard_000000.bin +│ ├── shard_000000.idx +│ └── ... +├── valid/ +│ └── shard_000000.bin/.idx +├── test/ +│ └── shard_000000.bin/.idx +└── blend.json +``` + +**blend.json format** (per-split mode): +```json +{ + "train": [["1.0", "/path/to/train/shard_000000"], ["1.0", "/path/to/train/shard_000001"]], + "valid": [["1.0", "/path/to/valid/shard_000000"]], + "test": [["1.0", "/path/to/test/shard_000000"]] +} +``` + +This format is directly compatible with Megatron-Bridge's per-split data loading. + +## Type Definitions + +TypedDicts are provided for type safety: + +```python +from nemotron.data_prep.formats.transforms import ( + SftRecord, # {"input": str, "output": str} + OpenAIChatRecord, # {"messages": list[Message]} + ShareGPTRecord, # {"conversations": list[Conversation]} + Message, # {"role": str, "content": str} +) +``` + +## API Reference + +### Main Functions + +| Function | Description | +|----------|-------------| +| `run_data_prep(config)` | High-level entry point for tokenization | +| `last_mile_process(blend, config)` | Low-level entry point with format dispatch | +| `tokenize(blend, config)` | Deprecated alias for `last_mile_process` | + +### Configuration Classes + +| Class | Description | +|-------|-------------| +| `DataPrepConfig` | High-level configuration for `run_data_prep` | +| `PipelineConfig` | Low-level pipeline configuration | +| `TokenizerConfig` | Tokenizer settings (model, add_bos, add_eos) | +| `OutputConfig` | Output directory and format | +| `BinIdxOutputConfig` | Tokenized binary format options | +| `JsonlOutputConfig` | JSONL format options | +| `PackedOutputConfig` | Packed sequence format options | + +### Result Classes + +| Class | Description | +|-------|-------------| +| `PipelineResult` | Complete pipeline result with all splits | +| `SplitResult` | Result for a single split (train/valid/test) | +| `DataBlendsArtifact` | Artifact with blend.json path and metrics | + +## Compression + +JSONL output supports optional zstd compression: + +```python +format=JsonlOutputConfig( + compression="zstd", # Output .jsonl.zst files +) +``` + +Requires the `zstandard` package: `uv pip install zstandard` + +## Dependencies + +Core dependencies: +- `ray` - Parallel processing +- `pyarrow` - Parquet file reading +- `xxhash` - Fast checksums + +Optional dependencies: +- `orjson` - Fast JSON serialization (falls back to stdlib json) +- `zstandard` - Zstd compression for JSONL output + +## Further Reading + +- [NeMo Curator](https://github.com/NVIDIA-NeMo/Curator) — Data curation at scale (coming soon) +- [NeMo Data Designer](https://github.com/NVIDIA-NeMo/DataDesigner) — Synthetic data generation (coming soon) +- [NVIDIA AI Stack](./nvidia-stack.md) — Megatron-Core, Megatron-Bridge, NeMo-RL documentation +- [Execution through NeMo-Run](./nemo-run.md) — Job orchestration and execution profiles +- [CLI Framework](./cli.md) — CLI building and recipe decorators +- [Artifact Lineage](./artifacts.md) — W&B artifact system and lineage tracking +- [Nano3 Recipe](./nano3/README.md) — Complete training recipe example diff --git a/docs/train/kit.md b/docs/train/kit.md new file mode 100644 index 0000000..368c417 --- /dev/null +++ b/docs/train/kit.md @@ -0,0 +1,211 @@ +# Nemotron Kit + +The `nemotron.kit` module is a lightweight framework powering Nemotron training recipes. It provides the infrastructure for building reproducible ML training pipelines with artifact versioning, configuration management, and lineage tracking. + +> **Lightweight by Design**: Kit handles recipe orchestration—not training. All heavy lifting is done by the [NVIDIA AI Stack](./nvidia-stack.md): [Megatron-Core](https://github.com/NVIDIA/Megatron-LM) for distributed training primitives, [Megatron-Bridge](https://github.com/NVIDIA/Megatron-Bridge) for model training, and [NeMo-RL](https://github.com/NVIDIA/NeMo-RL) for reinforcement learning. + +## Overview + +Kit handles four core responsibilities: + +| Component | Purpose | +|-----------|---------| +| **[Artifacts](./artifacts.md)** | Path-centric data and model versioning with typed metadata | +| **Configuration** | YAML/TOML config loading with Hydra-style overrides | +| **[CLI](./cli.md)** | Batteries-included CLI with optional MLOps execution via `--run` and `--batch` | +| **[Lineage](./artifacts.md)** | Experiment tracking and artifact provenance via [W&B](./wandb.md) | +| **[Execution](./nemo-run.md)** | Optional NeMo-Run integration for distributed training | + +## Architecture + +```mermaid +%%{init: {'theme': 'base', 'themeVariables': { 'primaryBorderColor': '#333333', 'lineColor': '#333333', 'primaryTextColor': '#333333', 'clusterBkg': '#ffffff', 'clusterBorder': '#333333'}}}%% +flowchart LR + subgraph cli["CLI"] + direction TB + CMD1["nemotron ... data prep"] + CMD2["nemotron ... train/sft/rl"] + end + + subgraph recipes["Recipe Scripts"] + direction TB + DataPrep["data_prep.py"] + Train["train.py"] + end + + subgraph kit["nemotron.kit"] + direction TB + Config["Configuration"] + Run["NeMo-Run"] + Artifact["Artifacts"] + Tracker["Lineage"] + end + + subgraph execution["Execution Backends"] + direction TB + Slurm["Slurm ✓"] + Docker["Docker (planned)"] + Cloud["Cloud (planned)"] + end + + subgraph tracking["Logging & Artifact Backends"] + direction LR + WandB["W&B ✓"] + More1["(planned)"] + More2["(planned)"] + end + + CMD1 --> DataPrep + CMD2 --> Train + DataPrep --> kit + Train --> kit + Run --> execution + Tracker --> tracking + + style cli fill:#fce4ec,stroke:#c2185b + style recipes fill:#e8f5e9,stroke:#388e3c + style kit fill:#e3f2fd,stroke:#1976d2 + style execution fill:#fff3e0,stroke:#f57c00 + style tracking fill:#f3e5f5,stroke:#7b1fa2 +``` + +## Quick Example + +A minimal training recipe using kit: + +```python +from nemotron.kit import cli, PretrainBlendsArtifact +from dataclasses import dataclass +from pathlib import Path + +@dataclass +class Config: + data_path: Path + output_dir: Path + learning_rate: float = 1e-4 + +# Load config with CLI override support +config = cli(Config, config_file="config.yaml") + +# Load data artifact +data = PretrainBlendsArtifact.load(config.data_path) +print(f"Training on {data.total_tokens:,} tokens") + +# ... training code ... + +# Save model artifact +model = ModelArtifact(path=config.output_dir, step=10000, loss=2.5) +model.save(name="ModelArtifact-pretrain") +``` + +Run with overrides: + +```bash +python train.py --config config.yaml learning_rate=5e-5 +``` + +## Key Concepts + +### Artifacts + +Artifacts are path-centric objects with typed metadata. The core field is always `path`—the filesystem location of the data. See [Artifact Lineage](./artifacts.md) for details. + +```python +from nemotron.kit import PretrainBlendsArtifact + +# Load from semantic URI +artifact = PretrainBlendsArtifact.from_uri("art://PretrainBlendsArtifact:latest") +print(f"Path: {artifact.path}") +print(f"Tokens: {artifact.total_tokens:,}") +``` + +### Configuration + +Kit supports YAML, TOML, and JSON configs with automatic format detection and Hydra-style overrides: + +```yaml +# config.yaml +data_path: /data/pretrain +output_dir: ${oc.env:PWD}/output +learning_rate: 1e-4 +``` + +Override from CLI: + +```bash +python train.py --config config.yaml output_dir=/scratch/output +``` + +### Execution + +Kit integrates with [NeMo-Run](./nemo-run.md) for distributed execution across Slurm, Docker, and cloud environments: + +```bash +# Run on Slurm cluster +uv run nemotron nano3 pretrain --run YOUR-CLUSTER + +# Run in Docker +uv run nemotron nano3 pretrain --run docker-profile +``` + +### Lineage Tracking + +Kit tracks artifact lineage through W&B. See [W&B Integration](./wandb.md) for automatic credential handling and [Artifact Lineage](./artifacts.md) for the lineage graph. + +## Module Structure + +``` +nemotron.kit +├── artifacts # Artifact classes and registry +├── cli # CLI building and env.toml parsing +├── config # Configuration loading +├── run # NeMo-Run executor building +├── trackers # Lineage tracking backends +└── wandb # W&B integration utilities +``` + +## API Reference + +### Artifacts + +| Export | Description | +|--------|-------------| +| `Artifact` | Base artifact class | +| `PretrainBlendsArtifact` | Pretrain data with train/valid/test splits | +| `SFTDataArtifact` | Packed SFT sequences | +| `SplitJsonlDataArtifact` | RL JSONL data | +| `ModelArtifact` | Model checkpoints | +| `InputDatasetInfo` | Source dataset metadata | + +### Configuration + +| Export | Description | +|--------|-------------| +| `cli()` | Config loader with CLI support | +| `load_omegaconf_yaml()` | Load YAML with OmegaConf | +| `apply_hydra_overrides()` | Apply key=value overrides | + +### Execution + +| Export | Description | +|--------|-------------| +| `build_executor()` | Build NeMo-Run executor from profile | +| `load_env_profile()` | Load execution profile from env.toml | + +### Tracking + +| Export | Description | +|--------|-------------| +| `init_wandb_if_configured()` | Conditional W&B initialization | +| `add_wandb_tags()` | Add tags to W&B runs | +| `finish_wandb()` | Clean W&B shutdown | + +## Further Reading + +- [NVIDIA AI Stack](./nvidia-stack.md) — Megatron-Core, Megatron-Bridge, NeMo-RL +- [OmegaConf Configuration](./omegaconf.md) — Artifact interpolations and unified W&B logging +- [Artifact Lineage](./artifacts.md) — Artifact versioning and W&B lineage +- [W&B Integration](./wandb.md) — Automatic credential handling +- [Execution through NeMo-Run](./nemo-run.md) — Execution profiles and packagers +- [CLI Framework](./cli.md) — Building recipe CLIs +- [Data Preparation](./data-prep.md) — Data prep module diff --git a/docs/train/nano3/README.md b/docs/train/nano3/README.md new file mode 100644 index 0000000..8563216 --- /dev/null +++ b/docs/train/nano3/README.md @@ -0,0 +1,264 @@ +# Nemotron 3 Nano Training Recipe + +A complete, reproducible training pipeline for Nemotron 3 Nano—an open, efficient Mixture-of-Experts hybrid Mamba-Transformer model optimized for agentic reasoning. + +## Quick Start + +### Prerequisites + +- **Slurm cluster** with GPU nodes (H100 recommended) — see [Execution through NeMo-Run](../nemo-run.md) +- **[Weights & Biases](../wandb.md) account** for experiment tracking and [artifact lineage](../artifacts.md) +- **Container images**: + - Training: `nvcr.io/nvidia/nemo:25.11.nemotron_3_nano` + - RL: `nvcr.io/nvidia/nemo-rl:v0.4.0.nemotron_3_nano` + +### Installation + +```bash +git clone https://github.com/NVIDIA/nemotron +cd nemotron +uv sync +``` + +### Configuration + +Create an `env.toml` file (see [Execution through NeMo-Run](../nemo-run.md) for details): + +```toml +[wandb] +project = "nemotron" +entity = "YOUR-TEAM" + +[YOUR-CLUSTER] +executor = "slurm" +account = "YOUR-ACCOUNT" +partition = "batch" +nodes = 2 +ntasks_per_node = 8 +gpus_per_node = 8 +mounts = ["/lustre:/lustre"] +``` + +### Run the Pipeline + +
+ +```console +// Stage 0: Pretraining +$ uv run nemotron nano3 data prep pretrain --run YOUR-CLUSTER +$ uv run nemotron nano3 pretrain --run YOUR-CLUSTER + +// Stage 1: Supervised Fine-Tuning +$ uv run nemotron nano3 data prep sft --run YOUR-CLUSTER +$ uv run nemotron nano3 sft --run YOUR-CLUSTER + +// Stage 2: Reinforcement Learning +$ uv run nemotron nano3 data prep rl --run YOUR-CLUSTER +$ uv run nemotron nano3 rl --run YOUR-CLUSTER +``` + +
+ +## Resources + +- **Tech Report**: [Nemotron 3 Nano Technical Report](https://research.nvidia.com/labs/nemotron/files/NVIDIA-Nemotron-3-Nano-Technical-Report.pdf) +- **Model Weights**: + - [NVIDIA-Nemotron-3-Nano-30B-A3B-Base-BF16](https://huggingface.co/nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-Base-BF16) (Base model) + - [NVIDIA-Nemotron-3-Nano-30B-A3B-BF16](https://huggingface.co/nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-BF16) (Instruct model) + - [NVIDIA-Nemotron-3-Nano-30B-A3B-FP8](https://huggingface.co/nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-FP8) (FP8 quantized) +- **Model Collection**: [NVIDIA Nemotron v3 Collection](https://huggingface.co/collections/nvidia/nvidia-nemotron-v3) +- **Training Datasets**: + - [Pre-training Datasets](https://huggingface.co/collections/nvidia/nemotron-pre-training-datasets) (Open pre-training data) + - [Post-training Datasets](https://huggingface.co/collections/nvidia/nemotron-post-training-v3) (SFT and RL data) + +## Training Pipeline + +| Stage | Name | Purpose | Guide | +|-------|------|---------|-------| +| 0 | [Pretraining](./pretrain.md) | Base model on 25T tokens with curriculum learning | [pretrain.md](./pretrain.md) | +| 1 | [SFT](./sft.md) | Multi-domain instruction tuning with 12+ data sources | [sft.md](./sft.md) | +| 2 | [RL](./rl.md) | GRPO alignment with multi-environment rewards | [rl.md](./rl.md) | + +## Model Specifications + +| Specification | Value | +|---------------|-------| +| **Total Parameters** | 31.6B | +| **Active Parameters** | 3.6B (per forward pass) | +| **Pretraining Tokens** | 25 trillion | +| **Context Length** | Up to 1M tokens | +| **Architecture** | Hybrid Mamba-Transformer with sparse MoE | + +> For architecture details, see [Tech Report Section 2.1](https://research.nvidia.com/labs/nemotron/files/NVIDIA-Nemotron-3-Nano-Technical-Report.pdf). + +## Stage Summaries + +### Stage 0: Pretraining + +Two-phase curriculum on 25 trillion tokens: Phase 1 (23.5T) focuses on diversity across web, code, math, and multilingual data; Phase 2 (1.5T) emphasizes high-quality sources. Includes long-context extension to 1M tokens. + +→ [Pretraining Guide](./pretrain.md) + +### Stage 1: Supervised Fine-Tuning + +Multi-domain instruction tuning covering 12+ data domains including competition math/code, InfinityByte cross-domain synthesis, STEM reasoning, conversational tool use, and multilingual support. + +→ [SFT Guide](./sft.md) + +### Stage 2: Reinforcement Learning + +Multi-environment RLVR training across 7 reward environments using GRPO, plus GenRM-based RLHF and DPO for reducing tool hallucination. + +→ [RL Guide](./rl.md) + +## Execution Options + +All commands support [NeMo-Run](../nemo-run.md) execution modes: + +| Option | Behavior | Use Case | +|--------|----------|----------| +| `--run ` | Attached—submits job and streams logs | Interactive development | +| `--batch ` | Detached—submits and exits immediately | Long-running jobs | +| `--dry-run` | Preview execution plan | Validation | + +See [Execution through NeMo-Run](../nemo-run.md) for profile configuration and advanced options. + +## Artifact Lineage + +The pipeline tracks full lineage via [W&B Artifacts](../artifacts.md), enabling traceability from raw data to final model. + +```mermaid +%%{init: {'theme': 'base', 'themeVariables': { 'primaryBorderColor': '#333333', 'lineColor': '#333333', 'primaryTextColor': '#333333', 'clusterBkg': '#ffffff', 'clusterBorder': '#333333'}}}%% +flowchart TB + subgraph pretrain["Stage 0: Pretraining"] + raw["Raw Text Data"] --> data0["DataBlendsArtifact-pretrain
(bin/idx)"] + data0 --> cmd0["uv run nemotron nano3 pretrain"] + cmd0 --> model0["ModelArtifact-pretrain"] + end + + subgraph sft["Stage 1: SFT"] + data1["DataBlendsArtifact-sft
(.npy)"] --> cmd1["uv run nemotron nano3 sft"] + model0 --> cmd1 + cmd1 --> model1["ModelArtifact-sft"] + end + + subgraph rl["Stage 2: RL"] + data2["DataBlendsArtifact-rl
(JSONL)"] --> cmd2["uv run nemotron nano3 rl"] + model1 --> cmd2 + cmd2 --> model2["ModelArtifact-rl
(Final Model)"] + end + + style pretrain fill:#e1f5fe,stroke:#2196f3 + style sft fill:#f3e5f5,stroke:#9c27b0 + style rl fill:#e8f5e9,stroke:#4caf50 +``` + +→ [Artifact Lineage & W&B Integration](../artifacts.md) + +## Open-Source Data + +> **Note**: These recipes train exclusively on the open-sourced subset of training data. Results will differ from the tech report benchmarks, which used additional proprietary data. Use these recipes as reference implementations to apply the methodology with your own data. + +## Coming Soon + +Native integrations with NVIDIA's NeMo ecosystem: + +| Tool | Description | Status | +|------|-------------|--------| +| [NeMo Curator](https://github.com/NVIDIA-NeMo/Curator) | Scalable data curation—deduplication, quality filtering, PII removal | Planned | +| [NeMo Data Designer](https://github.com/NVIDIA-NeMo/DataDesigner) | Synthetic data generation for instruction tuning and alignment | Planned | +| [NeMo Export-Deploy](https://github.com/NVIDIA-NeMo/Export-Deploy) | Model export to TensorRT-LLM and deployment | Planned | +| [NeMo Evaluator](https://github.com/NVIDIA-NeMo/Evaluator) | Comprehensive model evaluation and benchmarking | Planned | + +These integrations will enable end-to-end pipelines from data curation to model evaluation. + +## CLI Reference + +
+ +```console +// Show available commands +$ uv run nemotron nano3 --help +Usage: nemotron nano3 [OPTIONS] COMMAND [ARGS]... + + Nano3 training recipe + +╭─ Commands ───────────────────────────────────────────────────────────────╮ +│ data Data curation and preparation commands │ +│ model Model evaluation and import commands │ +╰──────────────────────────────────────────────────────────────────────────╯ +╭─ Training Stages ────────────────────────────────────────────────────────╮ +│ pretrain Run pretraining with Megatron-Bridge (stage0). │ +│ sft Run supervised fine-tuning with Megatron-Bridge (stage1). │ +│ rl Run reinforcement learning with NeMo-RL GRPO (stage2). │ +╰──────────────────────────────────────────────────────────────────────────╯ + +// View training command help (SFT example with artifact overrides) +$ uv run nemotron nano3 sft --help +Usage: nemotron nano3 sft [OPTIONS] + + Run supervised fine-tuning with Megatron-Bridge (stage1). + +╭─ Options ────────────────────────────────────────────────────────────────╮ +│ --help -h Show this message and exit. │ +╰──────────────────────────────────────────────────────────────────────────╯ +╭─ Global Options ─────────────────────────────────────────────────────────╮ +│ -c, --config NAME Config name or path │ +│ -r, --run PROFILE Submit to cluster (attached) │ +│ -b, --batch PROFILE Submit to cluster (detached) │ +│ -d, --dry-run Preview config without execution │ +│ --stage Stage files for interactive debugging │ +╰──────────────────────────────────────────────────────────────────────────╯ +╭─ Configs (-c/--config) ──────────────────────────────────────────────────╮ +│ Built-in: default, tiny │ +│ Custom: -c /path/to/your/config.yaml │ +╰──────────────────────────────────────────────────────────────────────────╯ +╭─ Artifact Overrides (W&B artifact references) ───────────────────────────╮ +│ run.model Base model checkpoint artifact │ +│ run.data SFT data artifact (packed .npy) │ +╰──────────────────────────────────────────────────────────────────────────╯ +╭─ Run Overrides (override env.toml settings) ─────────────────────────────╮ +│ run.env.nodes Number of nodes │ +│ run.env.nproc_per_node GPUs per node │ +│ run.env.partition Slurm partition │ +│ run.env.account Slurm account │ +│ run.env.time Job time limit (e.g., 04:00:00) │ +│ run.env.container_image Override container image │ +╰──────────────────────────────────────────────────────────────────────────╯ +╭─ env.toml Profiles ──────────────────────────────────────────────────────╮ +│ Available profiles: YOUR-CLUSTER, YOUR-CLUSTER-large │ +│ Usage: --run PROFILE or --batch PROFILE │ +╰──────────────────────────────────────────────────────────────────────────╯ +╭─ Examples ───────────────────────────────────────────────────────────────╮ +│ $ ... sft -c tiny Local execution │ +│ $ ... sft -c tiny --dry-run Preview config │ +│ $ ... sft -c tiny --run my-cluster Submit to cluster │ +│ $ ... sft -c tiny -r cluster run.env.nodes=4 │ +╰──────────────────────────────────────────────────────────────────────────╯ +``` + +
+ +## Troubleshooting + +**W&B authentication**: See [W&B Integration](../wandb.md) for setup. +```bash +wandb login +``` + +**Container not found**: Verify image path in config files. + +**Job submission fails**: Check Slurm account and partition in `env.toml`. See [Execution through NeMo-Run](../nemo-run.md). + +## Further Reading + +- [Stage 0: Pretraining](./pretrain.md) +- [Stage 1: SFT](./sft.md) +- [Stage 2: RL](./rl.md) +- [Importing Models & Data](./import.md) +- [Artifact Lineage](../artifacts.md) +- [Execution through NeMo-Run](../nemo-run.md) +- [W&B Integration](../wandb.md) +- [NVIDIA AI Stack](../nvidia-stack.md) +- [CLI Framework](../cli.md) +- [Data Preparation Module](../data-prep.md) diff --git a/docs/train/nano3/import.md b/docs/train/nano3/import.md new file mode 100644 index 0000000..4fdfdc9 --- /dev/null +++ b/docs/train/nano3/import.md @@ -0,0 +1,162 @@ +# Importing Models and Data + +This guide covers how to import existing models and data as [W&B artifacts](../artifacts.md) using the nemotron CLI. This is useful when you want to: + +- Use a pre-existing checkpoint from another training run +- Import data prepared outside of the standard pipeline +- Connect external assets to the [W&B artifact lineage](../artifacts.md) system + +## Prerequisites + +- [W&B](../wandb.md) configuration in `env.toml` (see [Execution through NeMo-Run](../nemo-run.md)): + ```toml + [wandb] + project = "nemotron" + entity = "YOUR-TEAM" + ``` +- Or provide `--project` and `--entity` CLI flags + +## Model Import + +Import model checkpoints as [W&B artifacts](../artifacts.md) for use in downstream training stages. + +### Commands + +```bash +# Import pretrain model checkpoint +uv run nemotron nano3 model import pretrain /path/to/model_dir --step 10000 + +# Import SFT model checkpoint +uv run nemotron nano3 model import sft /path/to/model_dir --step 5000 + +# Import RL model checkpoint +uv run nemotron nano3 model import rl /path/to/model_dir --step 2000 +``` + +### Options + +| Option | Description | +|--------|-------------| +| `--step, -s` | Training step number (optional) | +| `--name, -n` | Custom artifact name (default: `nano3//model`) | +| `--project, -p` | W&B project (overrides env.toml) | +| `--entity, -e` | W&B entity (overrides env.toml) | + +### Examples + +```bash +# Import with custom artifact name +uv run nemotron nano3 model import pretrain /lustre/checkpoints/model --step 50000 --name my-pretrain-model + +# Import to different W&B project +uv run nemotron nano3 model import sft /path/to/sft_checkpoint --project other-project --entity my-team +``` + +## Data Import + +Import data directories as [W&B artifacts](../artifacts.md) for use in training stages. + +### Commands + +```bash +# Import pretrain data (expects blend.json file) +uv run nemotron nano3 data import pretrain /path/to/blend.json + +# Import SFT data (expects directory with blend.json) +uv run nemotron nano3 data import sft /path/to/sft_data_dir + +# Import RL data (expects directory with manifest.json) +uv run nemotron nano3 data import rl /path/to/rl_data_dir +``` + +### Expected Directory Structures + +**Pretrain**: Direct path to `blend.json` file +``` +/path/to/blend.json +``` + +**SFT**: Directory containing `blend.json` +``` +/path/to/sft_data_dir/ +├── blend.json +├── train.npy +├── valid.npy +└── ... +``` + +**RL**: Directory containing `manifest.json` +``` +/path/to/rl_data_dir/ +├── manifest.json +├── train.jsonl +├── val.jsonl +└── test.jsonl +``` + +### Options + +| Option | Description | +|--------|-------------| +| `--name, -n` | Custom artifact name (default: `nano3//data`) | +| `--project, -p` | W&B project (overrides env.toml) | +| `--entity, -e` | W&B entity (overrides env.toml) | + +### Examples + +```bash +# Import SFT data with custom name +uv run nemotron nano3 data import sft /lustre/data/sft_v2 --name my-sft-data + +# Import RL data to different project +uv run nemotron nano3 data import rl /path/to/rl_data --project alignment-project +``` + +## Model Evaluation + +```bash +uv run nemotron nano3 model eval +``` + +> **Note**: Model evaluation is coming soon. + +## Using Imported Artifacts + +After importing, [artifacts](../artifacts.md) can be referenced in training commands via `--art.` (see [CLI Framework](../cli.md#artifact-inputs)): + +```bash +# Use imported model in SFT training +uv run nemotron nano3 sft --art.model my-pretrain-model:latest --run YOUR-CLUSTER + +# Use imported data in training +uv run nemotron nano3 pretrain --art.data my-pretrain-data:v1 --run YOUR-CLUSTER +``` + +## CLI Reference + +### Model Commands + +```bash +uv run nemotron nano3 model --help +uv run nemotron nano3 model eval --help +uv run nemotron nano3 model import --help +uv run nemotron nano3 model import pretrain --help +uv run nemotron nano3 model import sft --help +uv run nemotron nano3 model import rl --help +``` + +### Data Import Commands + +```bash +uv run nemotron nano3 data import --help +uv run nemotron nano3 data import pretrain --help +uv run nemotron nano3 data import sft --help +uv run nemotron nano3 data import rl --help +``` + +## Further Reading + +- [Artifact Lineage](../artifacts.md) — W&B artifact system +- [W&B Integration](../wandb.md) — Credentials and configuration +- [CLI Framework](../cli.md) — Full CLI documentation +- [Back to Overview](./README.md) diff --git a/docs/train/nano3/pretrain.md b/docs/train/nano3/pretrain.md new file mode 100644 index 0000000..73d64fa --- /dev/null +++ b/docs/train/nano3/pretrain.md @@ -0,0 +1,396 @@ +# Stage 0: Pretraining + +This stage trains the base Nemotron 3 Nano model from scratch on 25 trillion tokens using [Megatron-Bridge](../nvidia-stack.md#megatron-bridge). + +Nemotron 3 Nano is a **hybrid Mamba-Transformer-MoE** model with 52 layers, combining state-space models for efficiency, attention for global context, and mixture-of-experts for capacity. Key innovations include aux-loss-free MoE balancing and a two-phase data curriculum. + +> **Open-Source Data Only**: This recipe uses exclusively open-sourced training data from the [Nemotron Pre-training Datasets](https://huggingface.co/collections/nvidia/nemotron-pre-training-datasets) collection, which is a subset of the full data used to train the released model. The recipe includes datasets from Nemotron-CC-Math-v1, Nemotron-CC-v2, Nemotron-CC-v2.1, and Nemotron-Pretraining-Specialized-v1. Results will differ from the benchmarks in the [tech report](https://research.nvidia.com/labs/nemotron/files/NVIDIA-Nemotron-3-Nano-Technical-Report.pdf). Use this recipe as a reference implementation to apply the methodology with your own data. + +--- + +## Training Methodology + +> **Training Framework**: Pretraining is implemented using [Megatron-Bridge](https://docs.nvidia.com/nemo/megatron-bridge/latest/), which provides the training loop, distributed training primitives, and checkpoint management. See [Training Entry Points](https://docs.nvidia.com/nemo/megatron-bridge/latest/training/entry-points.html) for details on how `pretrain()` works. +> +> For complete methodology, see [Tech Report Section 2](https://research.nvidia.com/labs/nemotron/files/NVIDIA-Nemotron-3-Nano-Technical-Report.pdf). + +### Model Architecture + +Nemotron 3 Nano uses a **hybrid Mamba-Transformer-MoE** architecture with 52 layers: + +| Layer Type | Count | Role | +|------------|-------|------| +| Mamba-2 | 23 | Efficient sequence modeling via state space | +| Attention | 6 | Global context at key positions | +| MoE | 23 | Sparse computation with 8 experts per layer | + +The hybrid pattern interleaves these layer types to balance efficiency and capability: + +```mermaid +%%{init: {'theme': 'base', 'themeVariables': { 'primaryBorderColor': '#333333', 'lineColor': '#333333', 'primaryTextColor': '#333333'}}}%% +flowchart LR + subgraph layers["52 Layers"] + direction LR + m1["Mamba-2"] --> m2["Mamba-2"] --> a1["Attention"] + a1 --> moe1["MoE"] --> m3["Mamba-2"] --> m4["..."] + end + + style m1 fill:#e8f5e9,stroke:#4caf50 + style m2 fill:#e8f5e9,stroke:#4caf50 + style m3 fill:#e8f5e9,stroke:#4caf50 + style a1 fill:#e3f2fd,stroke:#2196f3 + style moe1 fill:#fff3e0,stroke:#ff9800 +``` + +**Key design choices:** + +- **Mamba-2 layers** provide linear-time sequence processing, enabling efficient inference on long contexts +- **Attention layers** are placed at strategic intervals (every ~8 layers) for global information mixing +- **MoE layers** use 128 routed experts plus 1 shared expert, with 6 experts activated per token, keeping active parameters at ~3.5B while total parameters reach ~31.6B + +> For architecture rationale, see [Tech Report Section 2.1](https://research.nvidia.com/labs/nemotron/files/NVIDIA-Nemotron-3-Nano-Technical-Report.pdf). +> +> For implementation details, see [Megatron-Bridge Nemotron 3](https://docs.nvidia.com/nemo/megatron-bridge/latest/models/llm/nemotron3.html). + +### Pretraining Data + +The pretraining corpus comprises four main dataset families: + +| Dataset Family | Description | +|----------------|-------------| +| **Nemotron-CC-Code-v1** | High-quality code from Common Crawl | +| **Nemotron-Pretraining-Code-v2** | GitHub code with student-teacher generation | +| **Nemotron-CC-v2.1** | General English web crawl with synthetic rephrasing | +| **Nemotron-Pretrain-Specialized-v1** | Synthetic STEM, math textbooks, scientific coding | + +Data spans 15 categories including web crawl (various quality tiers), code, math, academic, and multilingual content. + +> For dataset details, see [Tech Report Section 2.2](https://research.nvidia.com/labs/nemotron/files/NVIDIA-Nemotron-3-Nano-Technical-Report.pdf). + +### Data Mixture + +Training follows a two-phase curriculum that transitions from broad coverage to focused quality: + +| Phase | Tokens | Focus | Strategy | +|-------|--------|-------|----------| +| Phase 1 | 23.5T | Diversity | Broad coverage across all data sources | +| Phase 2 | 1.5T | Quality | Increased weight on high-quality and STEM data | + +**Phase 1: Foundation Building** + +- Uses all dataset families with balanced weights +- Emphasizes diversity: web (multiple quality tiers), code, math, multilingual +- Builds broad knowledge base and language understanding + +**Phase 2: Quality Refinement** + +- Increases sampling from high-quality sources: + - `High-Quality` and `High-Quality-Synthetic` subsets + - Nemotron-Pretraining-Specialized-v1 (STEM, math textbooks, scientific coding) +- Reduces low-quality web content +- Sharpens model capabilities on curated data + +> For mixture strategy details, see [Tech Report Section 2.3](https://research.nvidia.com/labs/nemotron/files/NVIDIA-Nemotron-3-Nano-Technical-Report.pdf). + +### Hyperparameters + +| Parameter | Value | +|-----------|-------| +| **Total Tokens** | 25 trillion | +| **Batch Size** | 3,072 sequences | +| **Sequence Length** | 8,192 tokens | +| **Peak Learning Rate** | 1e-3 | +| **Minimum Learning Rate** | 1e-5 | +| **Optimizer** | AdamW (β₁=0.9, β₂=0.95) | +| **Weight Decay** | 0.1 | +| **MoE Load Balancing** | DeepSeek aux-loss-free strategy | + +**Learning Rate Schedule:** + +| Phase | Tokens | LR | +|-------|--------|-----| +| Warmup | 8.4B | 0 → 1e-3 | +| Stable | 20T (80%) | 1e-3 | +| Decay | 5T (20%) | 1e-3 → 1e-5 | + +The warmup is token-based (8.4B tokens), not percentage-based. The stable phase maintains peak LR for 80% of training before cosine decay. + +> For hyperparameter rationale, see [Tech Report Section 2.4](https://research.nvidia.com/labs/nemotron/files/NVIDIA-Nemotron-3-Nano-Technical-Report.pdf). + +### MoE Load Balancing + +Nemotron 3 Nano uses the **aux-loss-free load balancing** strategy from DeepSeek, avoiding the auxiliary losses traditionally used to balance expert utilization. + +**Why aux-loss-free?** + +Traditional MoE training adds an auxiliary loss term to encourage balanced routing. However, this: +- Adds a hyperparameter (aux loss weight) that's hard to tune +- Can conflict with the main training objective +- May hurt model quality at scale + +**How it works:** + +Instead of auxiliary losses, the router uses **bias terms** that are adjusted dynamically: +- Track expert utilization over a sliding window +- Increase bias for underutilized experts (more tokens routed to them) +- Decrease bias for overloaded experts +- No gradient flows through the bias adjustment + +This achieves balanced expert utilization without interfering with the main loss function. + +> For details, see the [Auxiliary-Loss-Free Load Balancing paper](https://arxiv.org/abs/2408.15664). + +### Long-Context Extension + +The LC-Phase extends context to 1M tokens after main pretraining: + +| Parameter | Value | +|-----------|-------| +| **Duration** | 121 billion tokens | +| **Learning Rate** | 1e-5 (constant) | +| **Global Batch Size** | 48 | +| **Parallelism** | 8-way context/tensor/expert, 4-way pipeline | + +> For long-context methodology, see [Tech Report Section 2.5](https://research.nvidia.com/labs/nemotron/files/NVIDIA-Nemotron-3-Nano-Technical-Report.pdf). + +--- + +## Recipe Execution + +### Quick Start + +
+ +```console +// 1. Prepare data (tokenize to bin/idx format) +$ uv run nemotron nano3 data prep pretrain --run YOUR-CLUSTER + +// 2. Run pretraining +$ uv run nemotron nano3 pretrain --run YOUR-CLUSTER +``` + +
+ +> **Note**: The `--run YOUR-CLUSTER` flag submits jobs via [NeMo-Run](../nemo-run.md). See [Execution through NeMo-Run](../nemo-run.md) for setup. + +#### Direct Script Execution (Megatron-Bridge) + +For direct execution outside this CLI, use the scripts in the [Megatron-Bridge](https://github.com/NVIDIA-NeMo/Megatron-Bridge) repository: + +```bash +# Clone the repository and checkout the nano-v3 branch +git clone https://github.com/NVIDIA-NeMo/Megatron-Bridge.git +cd Megatron-Bridge +git checkout nano-v3 + +# Run pretraining (inside container on compute node) +python examples/recipes/nemotron_3/pretrain_nemotron_3_nano.py \ + --per-split-data-args-path /path/to/data_args.json \ + --tokenizer-model /path/to/tokenizer.model + +# With config file overrides +python examples/recipes/nemotron_3/pretrain_nemotron_3_nano.py \ + --config-file /path/to/overrides.yaml \ + --per-split-data-args-path /path/to/data_args.json \ + --tokenizer-model /path/to/tokenizer.model +``` + +See the [Megatron-Bridge Nemotron 3 documentation](https://docs.nvidia.com/nemo/megatron-bridge/latest/models/llm/nemotron3.html) for detailed configuration options. + +### Configuration + +| File | Purpose | +|------|---------| +| `config/default.yaml` | Production configuration | +| `config/data_prep.yaml` | Data preparation settings | +| `config/data_blend_raw.json` | Dataset blend definition | + +**Blend Configuration** + +Data blends are defined in `config/data_prep/data_blend_raw.json`. Each entry specifies: + +```json +{ + "name": "dataset-name", + "path": "hf://nvidia/...", + "subset": "subset-name", + "weight": 1.0 +} +``` + +Weights control sampling probability during data preparation. Phase transitions are implemented by using different blend configurations. + +### Data Preparation + +The `data_prep.py` script tokenizes raw text datasets into Megatron's binary format. See [Data Preparation Module](../data-prep.md) for detailed documentation. + +#### CLI Command + +```bash +uv run nemotron nano3 data prep pretrain [options] +``` + +| Option | Description | +|--------|-------------| +| `--run ` | Execute on Slurm via [NeMo-Run](../nemo-run.md) | +| `--sample N` | Limit rows per dataset (for testing) | +| `--force` | Force re-run, ignoring cache | + +#### Output + +``` +output/nano3/stage0_pretrain/ +├── train/ +│ ├── data_00000.bin +│ ├── data_00000.idx +│ └── ... +├── valid/ +├── test/ +└── blend.json +``` + +The output is registered as a [W&B Artifact](../artifacts.md) (`DataBlendsArtifact-pretrain`) for lineage tracking. + +### Training + +#### CLI Command + +```bash +uv run nemotron nano3 pretrain [options] [overrides...] +``` + +| Option | Description | +|--------|-------------| +| `--run ` | Attached—submits and waits, streaming logs ([NeMo-Run](../nemo-run.md)) | +| `--batch ` | Detached—submits and exits immediately ([NeMo-Run](../nemo-run.md)) | +| `--dry-run` | Preview execution plan | +| `key=value` | Override config values ([CLI Framework](../cli.md#dotlist-overrides)) | + +#### Override Examples + +```bash +# More training iterations +uv run nemotron nano3 pretrain train.train_iters=5000 + +# Larger batch size +uv run nemotron nano3 pretrain train.global_batch_size=64 + +# Different checkpoint location +uv run nemotron nano3 pretrain checkpoint.save=/path/to/checkpoints +``` + +### Running with NeMo-Run + +Configure execution profiles in `env.toml`: + +```toml +[wandb] +project = "nemotron" +entity = "YOUR-TEAM" + +[YOUR-CLUSTER] +executor = "slurm" +account = "YOUR-ACCOUNT" +partition = "batch" +nodes = 2 +ntasks_per_node = 8 +gpus_per_node = 8 +mounts = ["/lustre:/lustre"] +``` + +See [Execution through NeMo-Run](../nemo-run.md) for complete configuration options. + +### Checkpoint & Resume + +Training automatically saves checkpoints at regular intervals. To resume from a checkpoint: + +```bash +# Resume from a specific checkpoint +uv run nemotron nano3 pretrain checkpoint.load=/path/to/checkpoint + +# Resume from latest checkpoint in a directory +uv run nemotron nano3 pretrain checkpoint.load=/path/to/checkpoints/ +``` + +**Checkpoint Configuration:** + +| Option | Description | +|--------|-------------| +| `checkpoint.save` | Directory for saving checkpoints | +| `checkpoint.load` | Path to checkpoint for resuming | +| `checkpoint.save_interval` | Steps between saves (default: 1000) | + +Checkpoints use Megatron's distributed format, which handles model parallelism automatically. Each checkpoint contains model weights, optimizer state, and training progress. + +> For checkpoint format and advanced options, see [Megatron-Bridge Checkpointing](https://docs.nvidia.com/nemo/megatron-bridge/latest/training/checkpointing.html). + +### Artifact Lineage + +```mermaid +%%{init: {'theme': 'base', 'themeVariables': { 'primaryBorderColor': '#333333', 'lineColor': '#333333', 'primaryTextColor': '#333333'}}}%% +flowchart TB + raw["Raw Text Data"] --> dp["data_prep.py"] + dp --> data["DataBlendsArtifact-pretrain
(bin/idx files + blend.json)"] + data --> train["train.py"] + train --> model["ModelArtifact-pretrain
(checkpoint)"] + model --> next["Stage 1: SFT"] + + style raw fill:#e1f5fe,stroke:#2196f3 + style dp fill:#e1f5fe,stroke:#2196f3 + style data fill:#e1f5fe,stroke:#2196f3 + style train fill:#e1f5fe,stroke:#2196f3 + style model fill:#e1f5fe,stroke:#2196f3 + style next fill:#f3e5f5,stroke:#9c27b0 +``` + +--- + +## Infrastructure + +This stage uses the following components from the [NVIDIA AI Stack](../nvidia-stack.md): + +| Component | Role | Documentation | +|-----------|------|---------------| +| [Megatron-Core](../nvidia-stack.md#megatron-core) | Distributed training primitives (TP, PP, DP, EP, CP, SP) | [GitHub](https://github.com/NVIDIA/Megatron-LM) | +| [Megatron-Bridge](../nvidia-stack.md#megatron-bridge) | Model definitions, training loop, checkpoint management | [Docs](https://docs.nvidia.com/nemo/megatron-bridge/latest/) | + +### Parallelism Configuration + +Pretraining uses multiple parallelism strategies for efficient scaling. The specific values differ between main pretraining and long-context extension: + +| Parallelism | Main Pretraining | Long-Context (LC) | Config Key | +|-------------|------------------|-------------------|------------| +| Tensor (TP) | 8 | 8 | `model.tensor_model_parallel_size` | +| Pipeline (PP) | 1 | 4 | `model.pipeline_model_parallel_size` | +| Expert (EP) | 8 | 8 | `model.expert_model_parallel_size` | +| Context (CP) | 1 | 8 | `model.context_parallel_size` | +| Sequence (SP) | Yes | Yes | `model.sequence_parallel` | +| Data (DP) | Auto | Auto | Computed from world size | + +**Why the difference?** + +- **Main pretraining** uses 4K sequences, so context parallelism (CP=1) isn't needed +- **Long-context extension** handles up to 1M tokens, requiring CP=8 to distribute sequences across GPUs +- **Pipeline parallelism** increases in LC phase (PP=4) to handle larger activation memory + +> For parallelism concepts, see [NVIDIA AI Stack: Parallelism](../nvidia-stack.md#parallelism-strategies). + +### Container + +``` +nvcr.io/nvidia/nemo:25.11.nemotron_3_nano +``` + +--- + +## Next Steps + +After pretraining completes, proceed to [Stage 1: SFT](./sft.md) for instruction tuning. + +## Reference + +- [Tech Report Section 2](https://research.nvidia.com/labs/nemotron/files/NVIDIA-Nemotron-3-Nano-Technical-Report.pdf) — Pretraining methodology +- [NVIDIA AI Stack](../nvidia-stack.md) — Megatron-Core, Megatron-Bridge documentation +- [Artifact Lineage](../artifacts.md) — W&B artifact system +- **Recipe Source**: `src/nemotron/recipes/nano3/stage0_pretrain/` — Implementation details +- [Back to Overview](./README.md) diff --git a/docs/train/nano3/rl.md b/docs/train/nano3/rl.md new file mode 100644 index 0000000..0b96fb0 --- /dev/null +++ b/docs/train/nano3/rl.md @@ -0,0 +1,506 @@ +# Stage 2: Reinforcement Learning (RL) + +This stage aligns the instruction-tuned model using GRPO (Group Relative Policy Optimization) with [NeMo-RL](../nvidia-stack.md#nemo-rl). + +> **Open-Source Data Only**: This recipe uses exclusively open-sourced RL data from the [Nemotron Post-training Datasets](https://huggingface.co/collections/nvidia/nemotron-post-training-v3) collection, which is a subset of the full data used to train the released model. The recipe uses the [Nemotron-3-Nano-RL-Training-Blend](https://huggingface.co/datasets/nvidia/Nemotron-3-Nano-RL-Training-Blend) dataset. Results will differ from the benchmarks in the [tech report](https://research.nvidia.com/labs/nemotron/files/NVIDIA-Nemotron-3-Nano-Technical-Report.pdf). Use this recipe as a reference implementation to apply the methodology with your own data. + +--- + +## Training Methodology + +> **Training Framework**: RL alignment is implemented using [NeMo-RL](https://docs.nvidia.com/nemo/rl/latest/) with Ray for distributed actor coordination and vLLM for fast rollout generation. The Megatron backend handles distributed policy training with tensor, pipeline, context, and expert parallelism. See [NeMo-RL Documentation](https://docs.nvidia.com/nemo/rl/latest/) for implementation details. +> +> For complete methodology, see [Tech Report Section 3.2](https://research.nvidia.com/labs/nemotron/files/NVIDIA-Nemotron-3-Nano-Technical-Report.pdf). + +### RL Pipeline Overview + +The RL pipeline consists of three components: +1. **RLVR** — Multi-environment training with verifiable rewards +2. **RLHF with GenRM** — Generative reward model-based alignment +3. **DPO** — Preference learning to reduce tool hallucination + +### Data Preparation Pipeline + +Before training, the RL dataset is transformed into JSONL format compatible with NeMo-Gym: + +```mermaid +%%{init: {'theme': 'base', 'themeVariables': { 'primaryBorderColor': '#333333', 'lineColor': '#333333', 'primaryTextColor': '#333333'}}}%% +flowchart LR + subgraph prep["Data Preparation"] + direction LR + hf["HuggingFace
Dataset"] --> resolve["Placeholder
Resolution"] + resolve --> jsonl["JSONL
Format"] + jsonl --> split["Train/Val/Test
Split"] + end + split --> gym["NeMo-Gym
Environment"] + gym --> reward["Reward
Computation"] + + style hf fill:#e1f5fe,stroke:#2196f3 + style resolve fill:#e1f5fe,stroke:#2196f3 + style jsonl fill:#f3e5f5,stroke:#9c27b0 + style split fill:#f3e5f5,stroke:#9c27b0 + style gym fill:#e8f5e9,stroke:#4caf50 + style reward fill:#e8f5e9,stroke:#4caf50 +``` + +| Stage | What Happens | +|-------|--------------| +| **HuggingFace Dataset** | Load [Nemotron-3-Nano-RL-Training-Blend](https://huggingface.co/datasets/nvidia/Nemotron-3-Nano-RL-Training-Blend) from HuggingFace Hub | +| **Placeholder Resolution** | Resolve `_hf_placeholder` records by fetching from external datasets (DAPO, Skywork) and applying template restoration | +| **JSONL Format** | Convert to JSONL with `question`, `expected_answer`, and `responses_create_params` fields | +| **Train/Val/Test Split** | Split into training (98%), validation (1%), and test (1%) sets | +| **NeMo-Gym Environment** | Route samples to appropriate reward environments based on task type | +| **Reward Computation** | Compute verifiable rewards (math correctness, code execution, schema adherence) | + +**Placeholder Resolution:** + +The [Nemotron-3-Nano-RL-Training-Blend](https://huggingface.co/datasets/nvidia/Nemotron-3-Nano-RL-Training-Blend) dataset contains placeholder records that reference external HuggingFace datasets. The `data_prep.py` script resolves these by: + +1. Detecting placeholder records by the presence of `_hf_placeholder` field +2. Fetching actual data from external HF datasets: + - [ByteDance-Seed/DAPO-Math-17k](https://huggingface.co/datasets/ByteDance-Seed/DAPO-Math-17k) — Math reasoning problems + - [Skywork/Skywork-OR1-RL-Data](https://huggingface.co/datasets/Skywork/Skywork-OR1-RL-Data) — Open reasoning data +3. Applying template restoration (DAPO prefix/suffix, Skywork `{question}` replacement) + +> For data preparation implementation, see **Recipe Source**: `src/nemotron/recipes/nano3/stage2_rl/data_prep.py` + +### GRPO Algorithm + +GRPO (Group Relative Policy Optimization) optimizes the policy using group-relative advantages: + +1. **Generate responses** from the current policy using vLLM +2. **Evaluate** responses using NeMo-Gym reward environments +3. **Compute group-relative advantages** across response groups per prompt +4. **Update the policy** to favor higher-reward responses with clipped gradients + +**Loss Function:** + +The GRPO loss uses clipped policy gradients with KL regularization: + +$$ +L(\theta) = E_{x \sim \pi_{\theta_{\text{old}}}} \Big[ \min \Big(\frac{\pi_\theta(x)}{\pi_{\theta_{\text{old}}}(x)}A_t, \text{clip} \big( \frac{\pi_\theta(x)}{\pi_{\theta_{\text{old}}}(x)}, 1 - \varepsilon, 1 + \varepsilon \big) A_t \Big) \Big] - \beta D_{\text{KL}} (\pi_\theta \| \pi_\text{ref}) +$$ + +Where: +- $\pi_\theta$ is the policy being optimized +- $\pi_{\theta_{\text{old}}}$ is the policy from the beginning of this step +- $A_t$ is the advantage estimate (group-relative) +- $\varepsilon$ is the clipping hyperparameter (0.2–0.28) +- $\beta$ is the KL penalty coefficient +- $\pi_{\text{ref}}$ is the reference policy (frozen SFT checkpoint) + +**Stability Improvements:** + +| Improvement | Description | +|-------------|-------------| +| **On-Policy KL Approximation** | Uses importance weights to correct for off-policy samples, providing an unbiased and guaranteed-positive KL estimator | +| **Importance Sampling Correction** | Corrects for discrepancies between inference (vLLM) and training (Megatron) token probabilities | +| **Overlong Filtering** | Excludes sequences that hit max length without EOS from loss computation, reducing noise from truncated generations | +| **Asymmetric Clipping** | Uses `ratio_clip_min=0.2` and `ratio_clip_max=0.28` for asymmetric policy update bounds | + +> For detailed loss function derivations, see the [NeMo-RL GRPO Guide](https://docs.nvidia.com/nemo/rl/latest/guides/grpo.html#loss). + +### Multi-Environment RLVR + +Training uses 6 reward environments through NeMo-Gym: + +| Environment | Description | Reward Type | +|-------------|-------------|-------------| +| **math_with_judge** | Mathematical reasoning (DAPO, Skywork math) | Answer correctness verification | +| **code_gen** | Code correctness with test case execution | Unit test pass rate | +| **mcqa** | STEM multiple choice questions | Answer matching | +| **instruction_following** | IFEval, Multi-Challenge compliance | Constraint satisfaction | +| **workplace_assistant** | Agentic tool use, multi-turn interactions | Task completion | +| **structured_outputs_json** | JSON schema adherence | Schema validation | + +Training on all environments simultaneously provides stable gains without co-reward degradation. + +> For environment implementation details, see [NeMo-RL Environments Guide](https://docs.nvidia.com/nemo/rl/latest/guides/environments.html). + +### GenRM (RLHF) + +Generative reward models use circular comparison strategy (N comparisons instead of O(N²)) with length-normalized reward adjustment: + +| Parameter | Value | +|-----------|-------| +| **Prompts per batch** | 128 | +| **Responses per prompt** | 16 | +| **Comparison strategy** | Circular | +| **Length bonus α** | 0.5 | + +> For GenRM training details, see [Tech Report Section 3.2](https://research.nvidia.com/labs/nemotron/files/NVIDIA-Nemotron-3-Nano-Technical-Report.pdf). + +### DPO for Tool Hallucination + +DPO reduces hallucinated tool usage with minimal computational overhead: + +| Metric | Before DPO | After DPO | +|--------|------------|-----------| +| **AIME25 Accuracy** | 80.88% | 84.58% | +| **Hallucination Rate** | 8.33% | 0.7% | + +> For DPO methodology, see [Tech Report Appendix C](https://research.nvidia.com/labs/nemotron/files/NVIDIA-Nemotron-3-Nano-Technical-Report.pdf) and [NeMo-RL DPO Guide](https://docs.nvidia.com/nemo/rl/latest/guides/dpo.html). + +### Reasoning Control + +The model supports: +- **Reasoning on/off control** — Strip reasoning from 10% of samples +- **Token budget control** — Truncate 3% of reasoning traces to different budgets + +### Hyperparameters + +**GRPO Settings:** + +| Parameter | Value | Description | +|-----------|-------|-------------| +| `num_prompts_per_step` | 128 | Prompts sampled per training step | +| `num_generations_per_prompt` | 16 | Rollouts generated per prompt | +| `max_total_sequence_length` | 49152 | Maximum sequence length (~49K tokens) | +| `normalize_rewards` | true | Normalize rewards across batch | +| `use_leave_one_out_baseline` | true | Variance reduction for advantage estimation | +| `val_period` | 5 | Validation every N steps | +| `max_num_epochs` | 1 | Single epoch over data | +| `seed` | 42 | Random seed for reproducibility | + +**Loss Function:** + +| Parameter | Value | Description | +|-----------|-------|-------------| +| `ratio_clip_min` | 0.2 | Lower bound for importance ratio clipping | +| `ratio_clip_max` | 0.28 | Upper bound for importance ratio clipping | +| `use_on_policy_kl_approximation` | true | Use unbiased on-policy KL estimator | +| `use_importance_sampling_correction` | true | Correct for inference/training mismatch | +| `token_level_loss` | true | Per-token loss normalization | +| `reference_policy_kl_penalty` | 0 | KL regularization weight (disabled) | + +**Optimizer:** + +| Parameter | Value | +|-----------|-------| +| `optimizer` | AdamW | +| `lr` | 3e-6 | +| `min_lr` | 3e-6 | +| `weight_decay` | 0.0 | +| `adam_beta1` | 0.9 | +| `adam_beta2` | 0.999 | +| `adam_eps` | 1e-8 | +| `clip_grad` | 1.0 | + +**Sequence Packing:** + +| Parameter | Value | +|-----------|-------| +| `enabled` | true | +| `algorithm` | modified_first_fit_decreasing | +| `sequence_length_round` | 64 | + +--- + +## Recipe Execution + +### Quick Start + +
+ +```console +// 1. Prepare data (convert to JSONL format) +$ uv run nemotron nano3 data prep rl --run YOUR-CLUSTER + +// 2. Run RL training +$ uv run nemotron nano3 rl --run YOUR-CLUSTER +``` + +
+ +> **Note**: The `--run YOUR-CLUSTER` flag submits jobs via [NeMo-Run](../nemo-run.md). See [Execution through NeMo-Run](../nemo-run.md) for setup. + +### Running in NeMo-RL Repository + +For direct execution using NeMo-RL (without the nemotron CLI wrapper), follow the [NeMo-RL Nemotron 3 Nano Guide](https://docs.nvidia.com/nemo/rl/latest/guides/nemotron-3-nano.html): + +**1. Download and prepare the dataset:** + +```bash +# Download the RL blend dataset +huggingface-cli download nvidia/Nemotron-3-Nano-RL-Training-Blend \ + --repo-type dataset \ + --local-dir /path/to/rl-blend + +# Fill in placeholder entries (resolves DAPO, Skywork references) +python /path/to/rl-blend/create_nanov3_jsonl.py /path/to/rl-blend/data/train.jsonl + +# Split into train/validation +head -n -1000 /path/to/rl-blend/data/train.jsonl > /path/to/train.jsonl +tail -n 1000 /path/to/rl-blend/data/train.jsonl > /path/to/validation.jsonl +``` + +**2. Run GRPO training:** + +```bash +# From NeMo-RL repository root +uv run python examples/nemo_gym/run_grpo_nemo_gym.py \ + --config examples/nemo_gym/grpo_nanov3.yaml \ + data.train_jsonl_fpath=/path/to/train.jsonl \ + data.validation_jsonl_fpath=/path/to/validation.jsonl \ + policy.model_name=/path/to/sft/checkpoint \ + logger.wandb_enabled=True +``` + +> **Note**: The default recipe requires 32 nodes with 8 GPUs each. See the [NeMo-RL cluster documentation](https://docs.nvidia.com/nemo/rl/latest/cluster.html) for Slurm configuration. + +### Configuration + +| File | Purpose | +|------|---------| +| `config/default.yaml` | Production GRPO configuration | +| `config/data_prep/default.yaml` | Data preparation settings | +| `config/data_prep/data_blend_raw.json` | RL dataset blend | + +### Data Preparation + +The `data_prep.py` script converts datasets to JSONL format compatible with [NeMo-RL](../nvidia-stack.md#nemo-rl)'s NeMo-Gym interface. See [Data Preparation Module](../data-prep.md) for detailed documentation. + +#### CLI Command + +```bash +uv run nemotron nano3 data prep rl [options] +``` + +| Option | Description | +|--------|-------------| +| `--run ` | Execute on Slurm via [NeMo-Run](../nemo-run.md) | +| `--sample N` | Limit rows per dataset (for testing) | +| `--force` | Force re-run, ignoring cache | + +#### Output + +``` +output/nano3/stage2_rl/ +├── train/ +│ └── data.jsonl +├── val/ +│ └── data.jsonl +├── test/ +│ └── data.jsonl +└── manifest.json +``` + +The output is registered as a [W&B Artifact](../artifacts.md) (`DataBlendsArtifact-rl`) for lineage tracking. + +### Training + +#### CLI Command + +```bash +uv run nemotron nano3 rl [options] [overrides...] +``` + +| Option | Description | +|--------|-------------| +| `--run ` | Attached—submits and waits, streaming logs ([NeMo-Run](../nemo-run.md)) | +| `--batch ` | Detached—submits and exits immediately ([NeMo-Run](../nemo-run.md)) | +| `--dry-run` | Preview execution plan | +| `key=value` | Override config values ([CLI Framework](../cli.md#dotlist-overrides)) | + +#### Override Examples + +```bash +# More training steps +uv run nemotron nano3 rl grpo.max_num_steps=200000 + +# Different temperature for generation +uv run nemotron nano3 rl policy.generation.temperature=0.8 + +# Different learning rate +uv run nemotron nano3 rl policy.megatron_cfg.optimizer.lr=5e-7 + +# Disable sequence packing +uv run nemotron nano3 rl policy.sequence_packing.enabled=false +``` + +### Running with NeMo-Run + +Configure execution profiles in `env.toml`: + +```toml +[wandb] +project = "nemotron" +entity = "YOUR-TEAM" + +[YOUR-CLUSTER] +executor = "slurm" +account = "YOUR-ACCOUNT" +partition = "batch" +nodes = 32 +ntasks_per_node = 8 +gpus_per_node = 8 +mem = "0" +exclusive = true +mounts = ["/lustre:/lustre"] +``` + +See [Execution through NeMo-Run](../nemo-run.md) for complete configuration options. + +### Checkpoint & Resume + +Training automatically saves checkpoints based on validation reward. To resume from a checkpoint: + +```bash +# Resume from a specific checkpoint +uv run nemotron nano3 rl policy.model_name=/path/to/checkpoint + +# Resume from latest checkpoint in results directory +uv run nemotron nano3 rl checkpointing.checkpoint_dir=/path/to/results +``` + +**Checkpoint Configuration:** + +| Option | Value | Description | +|--------|-------|-------------| +| `save_period` | 10 | Steps between checkpoint saves | +| `metric_name` | val:total_reward/mean | Metric for best checkpoint selection | +| `higher_is_better` | true | Higher reward = better checkpoint | +| `keep_top_k` | 1000000 | Number of checkpoints to retain | + +### Troubleshooting + +Common errors and solutions: + +| Error | Cause | Solution | +|-------|-------|----------| +| High `token_mult_prob_error` | Mismatch between vLLM and Megatron probabilities | Check weight refitting; ensure vLLM compilation settings match | +| KL divergence spikes | Single token probability errors in MoE | Monitor `gen_kl_error` metric; values above 1e-3 indicate issues | +| OOM during generation | vLLM memory allocation too high | Reduce `gpu_memory_utilization` (default 0.5) | +| Slow convergence | Learning rate too low or high | Adjust `policy.megatron_cfg.optimizer.lr` | + +**Debugging tips:** + +- Monitor `token_mult_prob_error` for inference/training consistency (should stay below ~2%) +- Watch `sampling_importance_ratio` (should hover around 1.0) +- Check `approx_entropy` for entropy collapse during training +- Use `--sample N` in data prep for quick iteration + +--- + +## Artifact Lineage + +```mermaid +%%{init: {'theme': 'base', 'themeVariables': { 'primaryBorderColor': '#333333', 'lineColor': '#333333', 'primaryTextColor': '#333333'}}}%% +flowchart TB + prev["ModelArtifact-sft
(from Stage 1)"] --> train + rl["RL Datasets
(HuggingFace)"] --> dp["data_prep.py"] + dp --> data["DataBlendsArtifact-rl
(JSONL files)"] + data --> train["train.py
(GRPO with NeMo-RL)"] + train --> model["ModelArtifact-rl
(final aligned model)"] + + style prev fill:#f3e5f5,stroke:#9c27b0 + style rl fill:#e8f5e9,stroke:#4caf50 + style dp fill:#e8f5e9,stroke:#4caf50 + style data fill:#e8f5e9,stroke:#4caf50 + style train fill:#e8f5e9,stroke:#4caf50 + style model fill:#e8f5e9,stroke:#4caf50 +``` + +--- + +## Infrastructure + +This stage uses the following components from the [NVIDIA AI Stack](../nvidia-stack.md): + +| Component | Role | Documentation | +|-----------|------|---------------| +| [NeMo-RL](../nvidia-stack.md#nemo-rl) | GRPO algorithm, policy training, reward computation | [Docs](https://docs.nvidia.com/nemo/rl/latest/) | +| [Megatron-Core](../nvidia-stack.md#megatron-core) | Distributed training primitives (TP, PP, CP, EP) | [GitHub](https://github.com/NVIDIA/Megatron-LM) | +| [Ray](https://ray.io/) | Distributed actor coordination | [Docs](https://docs.ray.io/) | +| vLLM | Fast rollout generation | [GitHub](https://github.com/vllm-project/vllm) | + +### Parallelism Configuration + +Training uses multiple parallelism strategies for efficient scaling: + +| Parallelism | Value | Config Key | +|-------------|-------|------------| +| Tensor (TP) | 2 | `policy.megatron_cfg.tensor_model_parallel_size` | +| Pipeline (PP) | 2 | `policy.megatron_cfg.pipeline_model_parallel_size` | +| Context (CP) | 4 | `policy.megatron_cfg.context_parallel_size` | +| Expert (EP) | 8 | `policy.megatron_cfg.expert_model_parallel_size` | +| Sequence (SP) | Yes | `policy.megatron_cfg.sequence_parallel` | + +**Generation (vLLM):** + +| Parameter | Value | Description | +|-----------|-------|-------------| +| `tensor_parallel_size` | 4 | TP for vLLM generation | +| `gpu_memory_utilization` | 0.5 | GPU memory fraction for KV cache | +| `colocated` | true | Share GPUs with training | +| `enforce_eager` | false | Use torch.compile | + +**Cluster:** + +| Parameter | Value | +|-----------|-------| +| `num_nodes` | 32 | +| `gpus_per_node` | 8 | + +### Key Features Used + +| Feature | Purpose | +|---------|---------| +| GRPO algorithm | Group Relative Policy Optimization with clipped gradients | +| Megatron backend | Distributed training with TP/PP/CP/EP parallelism | +| Sequence Packing | Efficient batch utilization for variable-length generations | +| vLLM Generation | Fast rollout with tensor parallelism | +| MoE Router Bias | Aux-loss-free load balancing (`freeze_moe_router=true`) | +| Per-token Loss | Consistent gradient signal (`calculate_per_token_loss=true`) | + +### NeMo-Gym Environments + +The training configuration includes these reward environment configs: + +```yaml +env: + nemo_gym: + config_paths: + - responses_api_models/vllm_model/configs/vllm_model_for_training.yaml + - resources_servers/math_with_judge/configs/math_with_judge.yaml + - resources_servers/code_gen/configs/code_gen.yaml + - resources_servers/workplace_assistant/configs/workplace_assistant.yaml + - resources_servers/mcqa/configs/mcqa.yaml + - resources_servers/instruction_following/configs/instruction_following.yaml + - resources_servers/structured_outputs/configs/structured_outputs_json.yaml +``` + +### Architecture + +NeMo-RL uses a Ray-based actor model: + +| Actor | Function | +|-------|----------| +| **Policy Model** | Trainable policy weights (Megatron backend) | +| **Generator** | vLLM-backed rollout generation (colocated) | +| **Reward Environments** | NeMo-Gym environments for reward computation | +| **Reference Model** | Frozen SFT checkpoint for KL divergence | + +### Container + +``` +nvcr.io/nvidia/nemo-rl:v0.4.0.nemotron_3_nano +``` + +--- + +## Next Steps + +After RL completes, the final aligned model (`ModelArtifact-rl`) is ready for evaluation and deployment. + +## Reference + +- [Tech Report Section 3.2](https://research.nvidia.com/labs/nemotron/files/NVIDIA-Nemotron-3-Nano-Technical-Report.pdf) — RL methodology +- [NeMo-RL Documentation](https://docs.nvidia.com/nemo/rl/latest/) — GRPO, DPO, environments +- [NeMo-RL Nemotron 3 Nano Guide](https://docs.nvidia.com/nemo/rl/latest/guides/nemotron-3-nano.html) — Upstream training guide +- [NVIDIA AI Stack](../nvidia-stack.md) — NeMo-RL, Megatron-Core documentation +- [Artifact Lineage](../artifacts.md) — W&B artifact system +- [Stage 0: Pretraining](./pretrain.md) — Pretrain the base model +- [Stage 1: SFT](./sft.md) — Instruction tuning +- **Recipe Source**: `src/nemotron/recipes/nano3/stage2_rl/` — Implementation details +- [Back to Overview](./README.md) diff --git a/docs/train/nano3/sft.md b/docs/train/nano3/sft.md new file mode 100644 index 0000000..12666c6 --- /dev/null +++ b/docs/train/nano3/sft.md @@ -0,0 +1,388 @@ +# Stage 1: Supervised Fine-Tuning (SFT) + +This stage fine-tunes the pretrained model for instruction following using [Megatron-Bridge](../nvidia-stack.md#megatron-bridge). + +> **Open-Source Data Only**: This recipe uses exclusively open-sourced SFT data from the [Nemotron Post-training Datasets](https://huggingface.co/collections/nvidia/nemotron-post-training-v3) collection, which is a subset of the full data used to train the released model. The recipe includes datasets from Nemotron-Science-v1, Nemotron-Instruction-Following-Chat-v1, Nemotron-Math-Proofs-v1, Nemotron-SWE-v1, Nemotron-Agentic-v1, and Nemotron-Competitive-Programming-v1. Results will differ from the benchmarks in the [tech report](https://research.nvidia.com/labs/nemotron/files/NVIDIA-Nemotron-3-Nano-Technical-Report.pdf). Use this recipe as a reference implementation to apply the methodology with your own data. + +--- + +## Training Methodology + +> **Training Framework**: SFT is implemented using [Megatron-Bridge](https://docs.nvidia.com/nemo/megatron-bridge/latest/)'s `finetune()` entry point, which loads a pretrained checkpoint and handles the training loop with role-based loss masking. See [Training Entry Points](https://docs.nvidia.com/nemo/megatron-bridge/latest/training/entry-points.html) for implementation details. +> +> For complete methodology, see [Tech Report Section 3.1](https://research.nvidia.com/labs/nemotron/files/NVIDIA-Nemotron-3-Nano-Technical-Report.pdf). + +### Data Preparation Pipeline + +Before training, chat conversations are transformed into training-ready sequences through several stages: + +```mermaid +%%{init: {'theme': 'base', 'themeVariables': { 'primaryBorderColor': '#333333', 'lineColor': '#333333', 'primaryTextColor': '#333333'}}}%% +flowchart LR + subgraph prep["Data Preparation"] + direction LR + chat["OpenAI Chat
Format"] --> template["Chat
Template"] + template --> chunks["Role-Labeled
Chunks"] + chunks --> tok["Tokenization"] + tok --> mask["Loss Mask
(role-based)"] + mask --> pack["Packing"] + pack --> roll["Mask Rolling"] + end + roll --> npy[".npy Output"] + + style chat fill:#e3f2fd,stroke:#2196f3 + style template fill:#e3f2fd,stroke:#2196f3 + style chunks fill:#e3f2fd,stroke:#2196f3 + style tok fill:#f3e5f5,stroke:#9c27b0 + style mask fill:#f3e5f5,stroke:#9c27b0 + style pack fill:#fff3e0,stroke:#ff9800 + style roll fill:#fff3e0,stroke:#ff9800 + style npy fill:#e8f5e9,stroke:#4caf50 +``` + +| Stage | What Happens | +|-------|--------------| +| **OpenAI Chat Format** | Input messages with `role` (system/user/assistant) and `content` fields | +| **Chat Template** | Renders messages using Nano3 Jinja template with special tokens (`<\|im_start\|>`, `<\|im_end\|>`) | +| **Role-Labeled Chunks** | Splits rendered text back into chunks, each tagged with its source role | +| **Tokenization** | Converts text chunks to token IDs | +| **Loss Mask** | Builds mask: `1` for assistant tokens, `0` for system/user tokens | +| **Packing** | Multiple sequences packed into fixed-length bins (4096 tokens) | +| **Mask Rolling** | Shifts mask by 1 position for next-token prediction alignment | + +**Multi-turn splitting**: For conversations with reasoning content (`reasoning_content` field), the pipeline creates separate training sequences at each user turn. Reasoning from previous turns is dropped when a new user message appears—this matches inference behavior where users don't see intermediate reasoning. + +> For data preparation implementation, see **Recipe Source**: `src/nemotron/recipes/nano3/stage1_sft/data_prep.py` + +### Loss Masking + +Loss masking determines which tokens contribute to the training loss. In SFT, we only want the model to learn to generate responses—not to predict prompts or system instructions. + +**Why mask non-assistant tokens?** + +The model should learn to *respond*, not to *prompt*. If we computed loss on user messages, the model would be optimized to predict "What is 2+2?" given prior context—which isn't useful for an assistant. By masking user and system tokens (setting their loss weight to 0), gradients only flow from assistant responses, teaching the model what to generate without wasting capacity on predicting inputs. + +| Role | Loss Mask | Training Signal | +|------|-----------|-----------------| +| `system` | 0 | Ignored (instructions) | +| `user` | 0 | Ignored (prompts) | +| `assistant` | 1 | Learned (responses) | + +**Why roll the mask by 1?** + +In next-token prediction, the model predicts `token[i+1]` given `tokens[0:i]`. The loss compares the prediction against the *label*, which is the input sequence shifted by one position: + +``` +Position: 0 1 2 3 4 +Input: [A] [B] [C] [D] [E] +Label: [B] [C] [D] [E] [_] <- shifted by 1 +``` + +If assistant content starts at position 2 (`[C]`), we want loss on predicting `[C]`, `[D]`, and `[E]`. But the label for position 2 is `[D]`—so we need to shift the mask to align with labels: + +``` +Original mask: [0] [0] [1] [1] [1] <- "assistant starts at C" +Rolled mask: [0] [0] [0] [1] [1] <- aligns with labels D, E +``` + +The pipeline rolls the loss mask by 1 position so it correctly masks the *predictions* (labels) rather than the *inputs*. + +**Truncation behavior (`max_doc_tokens`):** + +- **Default (null)**: No truncation—full sequences are preserved +- **When set**: Sequences exceeding the limit are truncated from the end, with the loss mask adjusted accordingly + +> For implementation details, see `src/nemotron/data_prep/chat_sft_processor.py` + +### Packed Sequences + +**Why pack sequences?** + +Individual chat conversations vary in length—some are 50 tokens, others 3000. Without packing, each training sample would require padding to the maximum sequence length, wasting compute on empty tokens. Packing concatenates multiple conversations into a single fixed-length sequence (default 4096 tokens), maximizing GPU utilization. + +The packed sequence format stores everything Megatron-Bridge needs for training: + +| Field | Description | +|-------|-------------| +| `input_ids` | Concatenated token IDs from multiple conversations | +| `loss_mask` | Rolled mask indicating which positions contribute to loss (see [Loss Masking](#loss-masking)) | +| `seq_start_id` | Boundary indices marking where each original conversation starts within the pack | + +**How `seq_start_id` works:** + +When multiple conversations are packed together, the model needs to know where one ends and another begins—otherwise attention could "leak" between unrelated conversations. The `seq_start_id` array marks these boundaries: + +``` +Pack: [Conv A tokens] [Conv B tokens] [Conv C tokens] + ^ ^ ^ +seq_start_id: [0, 128, 384] +``` + +Megatron-Bridge uses these boundaries for: +- **Variable-length attention**: Attention is masked so tokens from Conv A can't attend to Conv B +- **FlashAttention optimization**: Boundaries map to `cu_seqlens` parameter for efficient packed attention + +> For packing implementation, see `src/nemotron/data_prep/packing/builder.py` + +### Chat Template + +Nemotron 3 Nano supports both reasoning and non-reasoning modes: + +- **Multi-Step**: Existing reasoning tokens preserved for reuse in subsequent steps +- **Multi-Turn**: Reasoning from previous turns dropped when user message introduced +- **Tool Calling**: Uses XML-style special tags to reduce character escaping + +### SFT Data Domains + +| Domain | Description | +|--------|-------------| +| **Competition Math** | Tool-integrated reasoning with GPT-OSS teachers | +| **Competition Code** | OpenCodeReasoning solutions with obfuscation/complication | +| **InfinityByte** | Cross-domain code synthesis at model capability boundaries | +| **STEM Reasoning (RQA)** | Reasoning Q&A from undergraduate/graduate STEM content | +| **Conversational Tool Use** | Multi-turn trajectories with simulated tool execution | +| **Long Context** | 128k mean token length, 256k hard limit | +| **Formal Proofs** | Lean theorem proving with 300k examples | +| **Multilingual** | French, Spanish, Italian, German, Japanese | +| **Terminal Use** | Terminal operations from Terminal Bench | +| **General Chat** | Multi-turn responses from LMSYS and WildChat | +| **Instruction Following** | Tulu 3 methodology with verifier filtering | +| **Safety** | Refusal behaviors from safety datasets | +| **Software Engineering** | GitHub issue resolution trajectories | +| **Science** | Physics, chemistry, biology via NeMo Data Designer | + +> For detailed data generation pipelines, see [Tech Report Section 3.1](https://research.nvidia.com/labs/nemotron/files/NVIDIA-Nemotron-3-Nano-Technical-Report.pdf). + +### Data Filtering + +The pipeline applies: +- **Structural checks**: Discard malformed examples +- **Pathological repetition filtering**: Remove repeated n-grams +- **Consistency filtering**: Judge-based action consistency verification +- **Narrative filtering**: Remove political/nationalistic narratives + +### Troubleshooting + +Common data preparation errors and solutions: + +| Error | Cause | Solution | +|-------|-------|----------| +| "# Tools missing" validation failure | Messages contain `` but system prompt lacks `# Tools` header | Add a `# Tools` section in the system prompt before tool definitions | +| Empty sequences after processing | All tokens masked (no assistant content in conversation) | Verify input data contains assistant responses with actual content | +| Template rendering mismatch | Tokenizer BPE splits differ from template expectations | Ensure tokenizer model matches the one used during template creation | +| Sequences truncated excessively | Many conversations exceed `max_doc_tokens` | Consider increasing `max_doc_tokens` or `pack_size`, or chunking long conversations | + +**Debugging tips:** + +- Use `--sample 100` to test data preparation on a small subset +- Check `metadata.json` output for statistics on filtered/truncated sequences +- Review W&B artifacts for lineage tracking and validation metrics + +### Hyperparameters + +| Parameter | Value | +|-----------|-------| +| **Learning Rate** | 1e-5 | +| **Sequence Length** | 4096 tokens (pack_size) | +| **Loss Masking** | Role-based (assistant tokens only) | +| **Loss Normalization** | Per-token (`calculate_per_token_loss: true`) | +| **Optimizer** | AdamW | +| **Total Samples** | 18M+ | + +**`calculate_per_token_loss` explained:** + +- **True (default)**: Loss is normalized by the number of tokens with `loss_mask=1` across the batch. Each token contributes equally regardless of which sequence it belongs to. +- **False**: Loss is normalized by the number of sequences. Longer sequences (more assistant tokens) contribute more to the gradient. + +Per-token normalization is preferred for SFT because it ensures consistent learning signal regardless of conversation length. + +--- + +## Recipe Execution + +### Quick Start + +
+ +```console +// 1. Prepare data (apply chat templates, tokenize to .npy) +$ uv run nemotron nano3 data prep sft --run YOUR-CLUSTER + +// 2. Run SFT +$ uv run nemotron nano3 sft --run YOUR-CLUSTER +``` + +
+ +> **Note**: The `--run YOUR-CLUSTER` flag submits jobs via [NeMo-Run](../nemo-run.md). See [Execution through NeMo-Run](../nemo-run.md) for setup. + +#### Direct Script Execution (Megatron-Bridge) + +For direct execution outside this CLI, use the scripts in the [Megatron-Bridge](https://github.com/NVIDIA-NeMo/Megatron-Bridge) repository: + +```bash +# Clone the repository and checkout the nano-v3 branch +git clone https://github.com/NVIDIA-NeMo/Megatron-Bridge.git +cd Megatron-Bridge +git checkout nano-v3 + +# Run fine-tuning (inside container on compute node) +python examples/recipes/nemotron_3/finetune_nemotron_3_nano.py \ + --per-split-data-args-path /path/to/data_args.json \ + --tokenizer-model /path/to/tokenizer.model + +# With config file overrides +python examples/recipes/nemotron_3/finetune_nemotron_3_nano.py \ + --config-file /path/to/overrides.yaml \ + --per-split-data-args-path /path/to/data_args.json \ + --tokenizer-model /path/to/tokenizer.model +``` + +See the [Megatron-Bridge Nemotron 3 documentation](https://docs.nvidia.com/nemo/megatron-bridge/latest/models/llm/nemotron3.html) for detailed configuration options. + +### Configuration + +| File | Purpose | +|------|---------| +| `config/default.yaml` | Production configuration | +| `config/data_prep.yaml` | Data preparation settings | +| `config/data_blend_raw.json` | Dataset blend definition | + +### Data Preparation + +The `data_prep.py` script processes OpenAI-format chat data into packed sequences with role-based loss masking. See [Data Preparation Module](../data-prep.md) for detailed documentation. + +#### CLI Command + +```bash +uv run nemotron nano3 data prep sft [options] +``` + +| Option | Description | +|--------|-------------| +| `--run ` | Execute on Slurm via [NeMo-Run](../nemo-run.md) | +| `--sample N` | Limit rows per dataset (for testing) | +| `--force` | Force re-run, ignoring cache | + +#### Output + +``` +output/stage1_sft/ +├── training.npy +├── validation.npy +├── test.npy +└── metadata.json +``` + +The output is registered as a [W&B Artifact](../artifacts.md) (`DataBlendsArtifact-sft`) for lineage tracking. + +### Training + +#### CLI Command + +```bash +uv run nemotron nano3 sft [options] [overrides...] +``` + +| Option | Description | +|--------|-------------| +| `--run ` | Attached—submits and waits, streaming logs ([NeMo-Run](../nemo-run.md)) | +| `--batch ` | Detached—submits and exits immediately ([NeMo-Run](../nemo-run.md)) | +| `--dry-run` | Preview execution plan | +| `key=value` | Override config values ([CLI Framework](../cli.md#dotlist-overrides)) | + +#### Override Examples + +```bash +# More training iterations +uv run nemotron nano3 sft train.train_iters=5000 + +# Different learning rate +uv run nemotron nano3 sft optimizer.lr=1e-5 + +# Load specific pretrained checkpoint +uv run nemotron nano3 sft checkpoint.load=/path/to/pretrain/checkpoint +``` + +### Running with NeMo-Run + +Configure execution profiles in `env.toml`: + +```toml +[wandb] +project = "nemotron" +entity = "YOUR-TEAM" + +[YOUR-CLUSTER] +executor = "slurm" +account = "YOUR-ACCOUNT" +partition = "batch" +nodes = 2 +ntasks_per_node = 8 +gpus_per_node = 8 +mounts = ["/lustre:/lustre"] +``` + +See [Execution through NeMo-Run](../nemo-run.md) for complete configuration options. + +### Artifact Lineage + +```mermaid +%%{init: {'theme': 'base', 'themeVariables': { 'primaryBorderColor': '#333333', 'lineColor': '#333333', 'primaryTextColor': '#333333'}}}%% +flowchart TB + prev["ModelArtifact-pretrain
(from Stage 0)"] --> train + inst["Instruction Datasets
(OpenAI chat format)"] --> dp["data_prep.py"] + dp --> data["DataBlendsArtifact-sft
(packed .npy files)"] + data --> train["train.py"] + train --> model["ModelArtifact-sft
(fine-tuned checkpoint)"] + model --> next["Stage 2: RL"] + + style prev fill:#e1f5fe,stroke:#2196f3 + style inst fill:#f3e5f5,stroke:#9c27b0 + style dp fill:#f3e5f5,stroke:#9c27b0 + style data fill:#f3e5f5,stroke:#9c27b0 + style train fill:#f3e5f5,stroke:#9c27b0 + style model fill:#f3e5f5,stroke:#9c27b0 + style next fill:#e8f5e9,stroke:#4caf50 +``` + +--- + +## Infrastructure + +This stage uses the following components from the [NVIDIA AI Stack](../nvidia-stack.md): + +| Component | Role | Documentation | +|-----------|------|---------------| +| [Megatron-Core](../nvidia-stack.md#megatron-core) | Distributed training primitives (TP, PP, DP, EP) | [GitHub](https://github.com/NVIDIA/Megatron-LM) | +| [Megatron-Bridge](../nvidia-stack.md#megatron-bridge) | Fine-tuning loop, checkpoint loading, loss masking | [Docs](https://docs.nvidia.com/nemo/megatron-bridge/latest/) | + +### Key Features Used + +| Feature | Purpose | +|---------|---------| +| `finetune()` entry point | SFT training with pre-loaded checkpoint | +| Role-based loss masking | Only compute loss on assistant tokens | +| Mixed precision (BF16) | Memory-efficient training | +| Gradient checkpointing | Reduce memory footprint | + +### Container + +``` +nvcr.io/nvidia/nemo:25.11.nemotron_3_nano +``` + +--- + +## Next Steps + +After SFT completes, proceed to [Stage 2: RL](./rl.md) for alignment training. + +## Reference + +- [Tech Report Section 3.1](https://research.nvidia.com/labs/nemotron/files/NVIDIA-Nemotron-3-Nano-Technical-Report.pdf) — SFT methodology +- [NVIDIA AI Stack](../nvidia-stack.md) — Megatron-Core, Megatron-Bridge documentation +- [Artifact Lineage](../artifacts.md) — W&B artifact system +- [Stage 0: Pretraining](./pretrain.md) — Pretrain the base model +- **Recipe Source**: `src/nemotron/recipes/nano3/stage1_sft/` — Implementation details +- [Back to Overview](./README.md) diff --git a/docs/train/nemo-run.md b/docs/train/nemo-run.md new file mode 100644 index 0000000..95ea087 --- /dev/null +++ b/docs/train/nemo-run.md @@ -0,0 +1,325 @@ +# Execution through NeMo-Run + +Nemotron recipes use [NeMo-Run](https://github.com/NVIDIA-NeMo/Run) for job orchestration. NeMo-Run is an NVIDIA tool that streamlines configuration, execution, and management of ML experiments across computing environments. + +> **Note**: This release has been tested primarily with Slurm execution. Support for additional executors is planned. + +## What is NeMo-Run? + +NeMo-Run decouples **what** you want to run from **where** you run it: + +```mermaid +%%{init: {'theme': 'base', 'themeVariables': { 'primaryBorderColor': '#333333', 'lineColor': '#333333', 'primaryTextColor': '#333333', 'clusterBkg': '#ffffff', 'clusterBorder': '#333333'}}}%% +flowchart LR + subgraph config["Configuration"] + Task["Training Task"] + end + + subgraph nemorun["NeMo-Run"] + Packager["Packager"] + Executor["Executor"] + end + + subgraph targets["Execution Targets"] + Local["Local"] + Docker["Docker"] + Slurm["Slurm"] + Cloud["Cloud"] + end + + Task --> Packager + Packager --> Executor + Executor --> Local + Executor --> Docker + Executor --> Slurm + Executor --> Cloud +``` + +**Key concepts:** +- **Executor**: Where to run (local, Docker, Slurm, cloud) +- **Packager**: How to package code for the executor +- **Launcher**: How to launch the process (torchrun, direct) + +For full documentation, see the [NeMo-Run GitHub repository](https://github.com/NVIDIA-NeMo/Run). + +## Quick Start + +Add `--run ` to any recipe command: + +```bash +# Execute on a Slurm cluster +uv run nemotron nano3 pretrain -c tiny --run YOUR-CLUSTER + +# Detached execution (submit and exit) +uv run nemotron nano3 pretrain -c tiny --batch YOUR-CLUSTER + +# Preview without executing +uv run nemotron nano3 pretrain -c tiny --run YOUR-CLUSTER --dry-run +``` + +## Execution Profiles + +Nemotron Kit provides an `env.toml` configuration layer on top of NeMo-Run, enabling declarative execution profiles that integrate natively with the CLI. This is a **Nemotron-specific feature**—standard NeMo-Run requires programmatic configuration. + +Create an `env.toml` in your project root. Each section defines a named execution profile that can be referenced via `--run ` or `--batch `: + +```toml +# env.toml + +[wandb] +project = "nemotron" +entity = "YOUR-TEAM" + +[YOUR-CLUSTER] +executor = "slurm" +account = "YOUR-ACCOUNT" +partition = "batch" +nodes = 2 +ntasks_per_node = 8 +gpus_per_node = 8 +mounts = ["/lustre:/lustre"] +``` + +When you run `uv run nemotron nano3 pretrain --run YOUR-CLUSTER`, the kit reads this profile, builds the appropriate NeMo-Run executor, and submits your job. + +### Profile Inheritance + +Profiles can extend other profiles to reduce duplication: + +```toml +[base-slurm] +executor = "slurm" +account = "my-account" +partition = "gpu" +time = "04:00:00" + +[YOUR-CLUSTER] +extends = "base-slurm" +nodes = 4 +ntasks_per_node = 8 +gpus_per_node = 8 + +[YOUR-CLUSTER-large] +extends = "YOUR-CLUSTER" +nodes = 16 +time = "08:00:00" +``` + +## Executors + +### Slurm + +Submit jobs to a Slurm cluster. Container execution requires [Pyxis](https://github.com/NVIDIA/pyxis), NVIDIA's container plugin for Slurm. + +```toml +[YOUR-CLUSTER] +executor = "slurm" +account = "my-account" +partition = "gpu" +nodes = 4 +ntasks_per_node = 8 +gpus_per_node = 8 +time = "04:00:00" +mounts = ["/data:/data"] +``` + +#### SSH Tunnel Submission + +Submit from a remote machine via SSH: + +```toml +[YOUR-CLUSTER] +executor = "slurm" +account = "my-account" +partition = "gpu" +nodes = 4 +tunnel = "ssh" +host = "cluster.example.com" +user = "username" +identity = "~/.ssh/id_rsa" +``` + +#### Partition Overrides + +Specify different partitions for `--run` vs `--batch`: + +```toml +[YOUR-CLUSTER] +executor = "slurm" +partition = "batch" # Default +run_partition = "interactive" # For --run (attached) +batch_partition = "backfill" # For --batch (detached) +``` + +### Other Executors + +NeMo-Run supports additional executors: + +| Executor | Description | Status | +|----------|-------------|--------| +| `local` | Local execution with torchrun | Planned | +| `docker` | Docker container with GPU support | Planned | +| `skypilot` | Cloud instances (AWS, GCP, Azure) | Planned | +| `dgxcloud` | NVIDIA DGX Cloud | Planned | + +## Packagers + +Packagers determine how your code is bundled and transferred to the execution target. NeMo-Run provides several packagers for different workflows. + +### GitArchivePackager (Default) + +Packages code from a git repository using `git archive`. Only includes committed files. + +```toml +[YOUR-CLUSTER] +executor = "slurm" +packager = "git" +# ... other settings +``` + +**How it works:** +1. Runs `git archive --format=tar.gz` from repository root +2. Includes only committed files (uncommitted changes are excluded) +3. Optionally includes git submodules +4. Transfers archive to execution target + +**Key options:** + +| Option | Default | Description | +|--------|---------|-------------| +| `subpath` | - | Package only a subdirectory of the repo | +| `include_submodules` | `true` | Include git submodules in archive | +| `include_pattern` | - | Glob pattern for additional uncommitted files | + +**Best for:** Production runs with version-controlled code. + +### PatternPackager + +Packages files matching glob patterns. Useful for code not under version control. + +```toml +[YOUR-CLUSTER] +executor = "slurm" +packager = "pattern" +packager_include_pattern = "src/**/*.py" +``` + +**How it works:** +1. Finds files matching the glob pattern +2. Creates tar archive of matched files +3. Preserves directory structure relative to pattern base + +**Key options:** + +| Option | Description | +|--------|-------------| +| `include_pattern` | Glob pattern(s) for files to include | +| `relative_path` | Base path for pattern matching | + +**Best for:** Quick iterations, non-git projects, or including generated files. + +### HybridPackager + +Combines multiple packagers into a single archive. Useful for complex projects. + +```toml +[YOUR-CLUSTER] +executor = "slurm" +packager = "hybrid" +# Configuration via code (see below) +``` + +**How it works:** +1. Runs each sub-packager independently +2. Extracts outputs to temporary directories +3. Merges all into final archive with folder organization + +**Example in code:** + +```python +import nemo_run as run + +hybrid = run.HybridPackager( + sub_packagers={ + "code": run.GitArchivePackager(subpath="src"), + "configs": run.PatternPackager(include_pattern="configs/*.yaml"), + "data": run.PatternPackager(include_pattern="data/*.json"), + } +) +``` + +**Best for:** Projects with mixed version-controlled and generated content. + +### Passthrough Packager + +No packaging—assumes code is already available on the target (e.g., in a container image or shared filesystem). + +```toml +[YOUR-CLUSTER] +executor = "slurm" +packager = "none" +``` + +**Best for:** Pre-built containers, shared filesystems like `/lustre`. + +## CLI Options + +### `--run` vs `--batch` + +| Option | Behavior | Use Case | +|--------|----------|----------| +| `--run` | Attached—waits for completion, streams logs | Interactive development | +| `--batch` | Detached—submits and exits immediately | Long-running jobs | + +### Config Overrides + +Override config values using Hydra-style syntax: + +```bash +# Override training iterations +uv run nemotron nano3 pretrain --run YOUR-CLUSTER train.train_iters=5000 + +# Override nodes +uv run nemotron nano3 pretrain --run YOUR-CLUSTER run.nodes=8 +``` + +## Profile Reference + +| Field | Type | Default | Description | +|-------|------|---------|-------------| +| `executor` | str | `"local"` | Backend: local, docker, slurm, skypilot | +| `packager` | str | `"git"` | Packager: git, pattern, hybrid, none | +| `nproc_per_node` | int | `8` | GPUs per node | +| `nodes` | int | `1` | Number of nodes | +| `container_image` | str | - | Container image (from recipe config) | +| `mounts` | list | `[]` | Mount points (`/host:/container`) | +| `account` | str | - | Slurm account | +| `partition` | str | - | Slurm partition | +| `run_partition` | str | - | Partition for `--run` | +| `batch_partition` | str | - | Partition for `--batch` | +| `time` | str | `"04:00:00"` | Job time limit | +| `tunnel` | str | `"local"` | Slurm tunnel: local or ssh | +| `host` | str | - | SSH host | +| `user` | str | - | SSH user | +| `env_vars` | list | `[]` | Environment variables | +| `dry_run` | bool | `false` | Preview without executing | +| `detach` | bool | `false` | Submit and exit | + +## Ray-Enabled Recipes + +Some recipes use Ray for distributed execution. When you run a Ray-enabled recipe with `--run`, the Ray cluster is set up automatically: + +```bash +# Data prep uses Ray +uv run nemotron nano3 data prep pretrain --run YOUR-CLUSTER + +# RL training uses Ray +uv run nemotron nano3 rl -c tiny --run YOUR-CLUSTER +``` + +## Further Reading + +- [NeMo-Run GitHub](https://github.com/NVIDIA-NeMo/Run) — Full documentation +- [W&B Integration](./wandb.md) — Automatic credential handling +- [Nemotron Kit](./kit.md) — Framework overview +- [CLI Framework](./cli.md) — Building recipe CLIs diff --git a/docs/train/nvidia-stack.md b/docs/train/nvidia-stack.md new file mode 100644 index 0000000..d4478e1 --- /dev/null +++ b/docs/train/nvidia-stack.md @@ -0,0 +1,213 @@ +# NVIDIA AI Stack + +Nemotron training recipes are built on NVIDIA's production-grade AI stack. While `nemotron.kit` handles recipe orchestration, configuration, and artifact lineage, all heavy-lifting for distributed training is delegated to specialized NVIDIA libraries. + +## NeMo Framework + +Nemotron recipes are part of the broader NeMo Framework ecosystem, which provides end-to-end tools for the full LLM lifecycle: + +![NeMo Framework Overview](../assets/nemo-framework-overview.png) + +*Image credit: [NeMo-RL Documentation](https://docs.nvidia.com/nemo/rl/latest/)* + +The Nemotron recipes focus on the **Pre-training & SFT** (via Megatron-Bridge) and **Post-training & RL** (via NeMo-RL) stages, with NeMo-Run orchestrating execution across compute backends. + +## Stack Overview + +| Component | Purpose | Used In | +|-----------|---------|---------| +| [Megatron-Core](https://github.com/NVIDIA/Megatron-LM) | Distributed training primitives (TP, PP, DP, CP) | All stages | +| [Megatron-Bridge](https://github.com/NVIDIA/Megatron-Bridge) | Model definitions, training loops, HF conversion | Pretrain, SFT | +| [NeMo-RL](https://github.com/NVIDIA/NeMo-RL) | RL algorithms (GRPO, DPO), reward environments | RL stage | + +## Megatron-Core + +Megatron-Core provides the foundational primitives for efficient large-scale distributed training. It implements the parallelism strategies that enable training models with billions of parameters across thousands of GPUs. + +### Parallelism Strategies + +Megatron-Core implements multiple parallelism strategies that can be combined for optimal scaling: + +#### Tensor Parallelism (TP) + +Split model layers across GPUs to handle large weight matrices: + +![Tensor Parallelism](../assets/tensor-parallelism.png) + +*Image credit: [Megatron-Bridge Documentation](https://docs.nvidia.com/nemo/megatron-bridge/latest/)* + +#### Sequence Parallelism (SP) + +Distribute LayerNorm and Dropout activations across the sequence dimension: + +![Sequence Parallelism](../assets/sequence-parallelism.png) + +*Image credit: [Megatron-Bridge Documentation](https://docs.nvidia.com/nemo/megatron-bridge/latest/)* + +#### Expert Parallelism (EP) + +Distribute MoE experts across GPUs — critical for Nemotron's sparse MoE architecture: + +![Expert Parallelism](../assets/expert-parallelism.png) + +*Image credit: [Megatron-Bridge Documentation](https://docs.nvidia.com/nemo/megatron-bridge/latest/)* + +### All Parallelism Types + +| Parallelism | Abbreviation | Description | +|-------------|--------------|-------------| +| Tensor | TP | Split weight matrices across GPUs | +| Pipeline | PP | Split model layers into stages | +| Data | DP | Replicate model, distribute batches | +| Context | CP | Distribute long sequences across GPUs | +| Expert | EP | Distribute MoE experts across GPUs | +| Sequence | SP | Distribute activations in sequence dimension | + +### Documentation + +- [Megatron-Core GitHub](https://github.com/NVIDIA/Megatron-LM/tree/main/megatron/core) +- [Parallelism Tutorial](https://docs.nvidia.com/nemo-framework/user-guide/latest/nemotoolkit/features/parallelisms.html) + +## Megatron-Bridge + +Megatron-Bridge is a PyTorch-native library that bridges Hugging Face models with Megatron-Core. It provides production-ready training loops, checkpoint conversion, and pre-configured recipes for 20+ model architectures. + +### Key Features + +- **Bidirectional Checkpoint Conversion** — Convert between Hugging Face and Megatron formats +- **Scalable Training Loop** — Production-ready training with all Megatron parallelisms +- **Pre-configured Recipes** — Ready-to-use configurations for Llama, Qwen, DeepSeek, Nemotron, and more +- **Mixed Precision** — FP8, BF16, FP4 support via Transformer Engine +- **PEFT Support** — LoRA, DoRA for parameter-efficient fine-tuning + +### How Nemotron Uses It + +Nemotron's pretraining and SFT stages use Megatron-Bridge for: + +1. **Model Definition** — `NemotronHModel` provider for the hybrid Mamba-Transformer architecture +2. **Training Loop** — `pretrain()` and `finetune()` entry points +3. **Checkpoint Management** — Distributed save/load with Megatron format +4. **HF Export** — Convert trained checkpoints back to Hugging Face format + +```python +# Example: Megatron-Bridge training entry point +from megatron.bridge.training import pretrain +from megatron.bridge.recipes.nemotronh import NemotronH4BRecipe + +config = NemotronH4BRecipe().config +pretrain(config) +``` + +### Configuration + +Megatron-Bridge uses a central `ConfigContainer` dataclass that combines: + +| Section | Purpose | +|---------|---------| +| `model` | Model architecture and parallelism settings | +| `train` | Batch sizes, iterations, gradient accumulation | +| `optimizer` | Optimizer type, learning rate, weight decay | +| `scheduler` | LR schedule (warmup, decay) | +| `dataset` | Data loading configuration | +| `checkpoint` | Save/load intervals and paths | +| `mixed_precision` | FP8/BF16 settings | + +### Documentation + +- [Megatron-Bridge GitHub](https://github.com/NVIDIA/Megatron-Bridge) +- [Official Documentation](https://docs.nvidia.com/nemo/megatron-bridge/latest/) +- [Training Entry Points](https://docs.nvidia.com/nemo/megatron-bridge/latest/training/entry-points.html) +- [Adding New Models](https://docs.nvidia.com/nemo/megatron-bridge/latest/adding-new-models.html) + +## NeMo-RL + +NeMo-RL is a scalable post-training library for reinforcement learning on LLMs and VLMs. It enables everything from small-scale experiments to massive multi-node deployments. + +### Key Features + +- **GRPO** (Group Relative Policy Optimization) — Main RL algorithm with clipped policy gradients +- **DAPO** (Dual-Clip Asymmetric Policy Optimization) — Extended GRPO with asymmetric clipping +- **DPO** (Direct Preference Optimization) — RL-free alignment from preference data +- **Reward Models** — Bradley-Terry reward model training +- **Multi-Environment Training** — Math, code, tool-use, and custom reward environments +- **Flexible Backends** — DTensor (FSDP2) for native PyTorch, Megatron for large models + +### How Nemotron Uses It + +Nemotron's RL stage uses NeMo-RL for: + +1. **GRPO Training** — Multi-environment RLVR with 7 reward environments +2. **Generation** — vLLM backend for fast rollout generation +3. **Reward Computation** — Math verification, code execution, GenRM scoring +4. **Ray Orchestration** — Distributed policy-environment coordination + +```python +# Example: NeMo-RL GRPO training +from nemo_rl.algorithms.grpo import GRPOConfig, run_grpo + +config = GRPOConfig( + policy_model="nvidia/Nemotron-3-Nano-8B-SFT", + environments=["math", "code"], + num_rollouts=32, +) +run_grpo(config) +``` + +### Architecture + +NeMo-RL uses a Ray-based actor model for distributed training. Each "RL Actor" (Policy, Generator, Reward Model) manages a `RayWorkerGroup` that controls multiple workers distributed across GPUs: + +![NeMo-RL Actor Architecture](../assets/nemo-rl-actors.png) + +*Image credit: [NeMo-RL Documentation](https://docs.nvidia.com/nemo/rl/latest/)* + +Key concepts: +- **RL Actors** — High-level components (Policy Model, Generator, Reward Model) +- **RayWorkerGroup** — Manages a pool of workers for each actor +- **Workers** — Individual processes handling computation +- **RayVirtualCluster** — Allocates GPU resources to worker groups + +### Reward Environments + +NeMo-RL provides several built-in reward environments: + +| Environment | Description | +|-------------|-------------| +| `MathEnvironment` | Verifies mathematical solutions | +| `CodeEnvironment` | Executes code in sandbox, checks correctness | +| `RewardModelEnvironment` | Scores responses with trained reward model | +| `ToolEnvironment` | Evaluates tool-use and function calling | +| `NemoGym` | Game environments for multi-turn RL | + +### Training Backends + +| Backend | Best For | Parallelism | +|---------|----------|-------------| +| **DTensor (FSDP2)** | Models up to ~32B | FSDP, TP, CP, SP | +| **Megatron** | Large models (>100B) | Full 6D parallelism | + +Backend selection is automatic based on YAML configuration. + +### Documentation + +- [NeMo-RL GitHub](https://github.com/NVIDIA/NeMo-RL) +- [Official Documentation](https://docs.nvidia.com/nemo/rl/latest/) +- [GRPO Guide](https://docs.nvidia.com/nemo/rl/latest/guides/grpo.html) +- [Environment Guide](https://docs.nvidia.com/nemo/rl/latest/guides/environments.html) +- [Training Backends](https://docs.nvidia.com/nemo/rl/latest/design-docs/training-backends.html) + +## Version Compatibility + +Nemotron recipes are tested with specific versions of the NVIDIA AI stack. Check the container images in recipe configs for exact versions. + +| Component | Tested Version | Container | +|-----------|----------------|-----------| +| Megatron-Core | 0.13+ | `nvcr.io/nvidia/nemo:*` | +| Megatron-Bridge | 0.2+ | `nvcr.io/nvidia/nemo:*` | +| NeMo-RL | 0.4+ | `nvcr.io/nvidia/nemo-rl:*` | + +## Further Reading + +- [Nemotron Kit](./kit.md) — Recipe orchestration framework +- [Execution through NeMo-Run](./nemo-run.md) — Execution profiles and packagers +- [Nano3 Recipe](./nano3/README.md) — Complete training pipeline diff --git a/docs/train/omegaconf.md b/docs/train/omegaconf.md new file mode 100644 index 0000000..28f5481 --- /dev/null +++ b/docs/train/omegaconf.md @@ -0,0 +1,330 @@ +# OmegaConf Configuration System + +Nemotron Kit uses [OmegaConf](https://omegaconf.readthedocs.io/) for configuration management, with custom resolvers that enable automatic artifact resolution and W&B lineage tracking. This page explains the `run` section in configs, artifact interpolations, and unified W&B logging. + +## The `run` Section + +The `run` section in recipe configs serves as a metadata container for execution and artifact configuration. It's separate from the training algorithm configuration. + +```yaml +# config.yaml +run: + # Artifact references - automatically resolved with W&B lineage + data: PretrainBlendsArtifact-default:latest + model: ModelArtifact-pretrain:v5 + + # Environment configuration (container image) + env: + container: nvcr.io/nvidia/nemo:25.11.nemotron_3_nano + +# Training configuration sections +recipe: + _target_: megatron.bridge.recipes.nemotronh.nemotron_next_3b_v2_pretrain_config + per_split_data_args_path: ${art:data,path}/blend.json # Resolved from artifact + +logger: + wandb_project: ${run.wandb.project} # Injected from env.toml + wandb_entity: ${run.wandb.entity} # Injected from env.toml + +checkpoint: + save: /nemo_run/pretrain + save_interval: 20 +``` + +### How `run.wandb` is Populated + +When you run a recipe with `--run `, the CLI reads your `env.toml` and injects the `[wandb]` section into `run.wandb`: + +```toml +# env.toml +[wandb] +project = "nemotron" +entity = "my-team" + +[YOUR-CLUSTER] +executor = "slurm" +# ... +``` + +This allows configs to reference W&B settings via interpolation (`${run.wandb.project}`) without hardcoding them. + +## Artifact Interpolations + +The `${art:NAME,FIELD}` resolver enables automatic artifact resolution with W&B lineage tracking. + +### Syntax + +```yaml +# Basic path resolution +data_path: ${art:data,path} # /path/to/artifact + +# Field resolution +model_version: ${art:model,version} # v5 +model_type: ${art:model,type} # "model" +checkpoint_step: ${art:model,iteration} # 10000 + +# Metadata field resolution (from metadata.json) +pack_size: ${art:data,pack_size} # 4096 +training_path: ${art:data,training_path} # /path/to/training_4096.npy +``` + +### Supported Fields + +| Field | Source | Description | +|-------|--------|-------------| +| `path` | Artifact info | Local filesystem path to artifact (default) | +| `version` | Artifact info | W&B artifact version (e.g., "v5") | +| `name` | Artifact info | Artifact name | +| `type` | Artifact info | Artifact type ("dataset", "model") | +| `iteration` | Metadata | Training iteration (for model checkpoints) | +| `*` | `metadata.json` | Any field from the artifact's metadata | + +### Example: Pretrain Config + +```yaml +run: + data: PretrainBlendsArtifact-default:latest + +recipe: + _target_: megatron.bridge.recipes.nemotronh.nemotron_next_3b_v2_pretrain_config + # Resolved to: /path/to/wandb/artifacts/PretrainBlendsArtifact-default-v3/blend.json + per_split_data_args_path: ${art:data,path}/blend.json +``` + +### Example: SFT Config with Model Checkpoint + +```yaml +run: + data: SFTDataArtifact-default:latest + model: pretrain:latest + +recipe: + _target_: megatron.bridge.recipes.nemotronh.nemotron_nano_9b_v2_finetune_config + # Resolved to the pretrain checkpoint save directory + pretrained_checkpoint: ${art:model,path} + # Resolved to the checkpoint iteration number + ckpt_step: ${art:model,iteration} +``` + +### Example: RL Config + +```yaml +run: + data: DataBlendsArtifact-rl:latest + model: sft:latest + env: + container: nvcr.io/nvidia/nemo-rl:v0.4.0.nemotron_3_nano + +policy: + # Resolved to the SFT model checkpoint path + model_name: ${art:model,path} + +data: + # Resolved from artifact metadata + train_jsonl_fpath: ${art:data,train_path} + validation_jsonl_fpath: ${art:data,val_path} +``` + +## How Artifact Resolution Works + +### Resolution Modes + +The artifact resolver supports two modes to handle different framework requirements: + +| Mode | When Used | Description | +|------|-----------|-------------| +| `active_run` | W&B run already active | Calls `wandb.use_artifact()` directly | +| `pre_init` | Before `wandb.init()` | Uses `wandb.Api()` to resolve, defers lineage | + +**Why two modes?** Megatron-Bridge owns `wandb.init()` during training. The kit resolves artifacts *before* training starts, then patches `wandb.init()` to register lineage once the run is active. + +### Resolution Pipeline + +``` +┌─────────────────────────────────────────────────────────────────────┐ +│ 1. Config Loading │ +│ - Load YAML with OmegaConf │ +│ - Detect artifact references in run section │ +└────────────────────────────┬────────────────────────────────────────┘ + ▼ +┌─────────────────────────────────────────────────────────────────────┐ +│ 2. register_resolvers_from_config() │ +│ - Scan run section for artifact patterns │ +│ - Download artifacts from W&B (rank 0 only in distributed) │ +│ - Store qualified_name for lineage registration │ +└────────────────────────────┬────────────────────────────────────────┘ + ▼ +┌─────────────────────────────────────────────────────────────────────┐ +│ 3. OmegaConf Resolver Registration │ +│ - Register ${art:NAME,FIELD} resolver │ +│ - Fields resolve to artifact path, version, or metadata │ +└────────────────────────────┬────────────────────────────────────────┘ + ▼ +┌─────────────────────────────────────────────────────────────────────┐ +│ 4. patch_wandb_init_for_lineage() │ +│ - Patch wandb.init() to call use_artifact() when run starts │ +│ - Registers lineage in W&B graph │ +└─────────────────────────────────────────────────────────────────────┘ +``` + +### Distributed Coordination + +In multi-GPU training, only rank 0 downloads artifacts: + +1. **Rank 0**: Downloads artifacts, writes results to shared marker file +2. **Other ranks**: Wait for marker file, read shared results +3. **All ranks**: Use identical artifact paths + +This prevents redundant downloads and ensures consistency across workers. + +## Unified W&B Logging + +Nemotron Kit provides a unified W&B logging approach that works across Megatron-Bridge and NeMo-RL, which have different logging conventions. + +> **Coming Soon**: Native support for artifact lineage and checkpoint logging is being added directly to Megatron-Bridge and NeMo-RL. Once available, the monkey patches described below will no longer be necessary. + +### The Problem + +| Framework | Checkpoint Logging | W&B Init | +|-----------|-------------------|----------| +| Megatron-Bridge | `on_save_checkpoint_success()` | Owns `wandb.init()` | +| NeMo-RL | `CheckpointManager.finalize_checkpoint()` | Separate init | + +Both frameworks need to: +- Log checkpoints as W&B artifacts +- Track lineage from input artifacts +- Store metadata for downstream jobs + +### The Solution: Monkey Patches (Temporary) + +Until native support is available, the kit uses targeted monkey patches to unify logging behavior: + +```python +# In train.py (pretraining/SFT) +from nemotron.kit.wandb import ( + patch_wandb_checkpoint_logging, + patch_wandb_init_for_lineage, +) + +# Resolve artifacts before wandb.init() +qualified_names = register_resolvers_from_config(config, mode="pre_init") + +# Patch wandb.init to register lineage when MB initializes it +patch_wandb_init_for_lineage(artifact_qualified_names=qualified_names) + +# Patch checkpoint saving to log artifacts with metadata +patch_wandb_checkpoint_logging() +``` + +```python +# In train.py (RL) +from nemotron.kit.wandb import patch_nemo_rl_checkpoint_logging + +# Patch NeMo-RL checkpoint manager +patch_nemo_rl_checkpoint_logging() +``` + +### What the Patches Do + +**`patch_wandb_checkpoint_logging()`** (Megatron-Bridge): +- Wraps `on_save_checkpoint_success()` +- Adds `wait()` call so artifacts appear immediately in W&B +- Stores `absolute_path` in metadata for cross-job access +- Resolves container paths (`/nemo_run/`) to actual Lustre paths + +**`patch_nemo_rl_checkpoint_logging()`** (NeMo-RL): +- Wraps `CheckpointManager.finalize_checkpoint()` +- Logs checkpoints as W&B artifacts with consistent naming +- Same metadata format as Megatron-Bridge patches + +**`patch_wandb_init_for_lineage()`**: +- Patches `wandb.init()` to call `use_artifact()` for resolved artifacts +- Registers lineage in W&B graph once run is active + +### Container Path Resolution + +When running in containers, checkpoints are saved to mount paths like `/nemo_run/`. The kit resolves these to actual filesystem paths for cross-job access: + +```python +# Container path (inside job) +/nemo_run/pretrain/iter_0010000 + +# Resolved path (for artifact metadata) +/lustre/scratch/user/jobs/12345/pretrain/iter_0010000 +``` + +Resolution uses: +1. `NEMO_RUN_DIR` environment variable (set by nemo-run) +2. `/proc/mounts` to find bind mount source + +## Usage in Training Scripts + +### Pretraining/SFT (Megatron-Bridge) + +```python +from nemotron.kit.resolvers import register_resolvers_from_config +from nemotron.kit.wandb import ( + patch_wandb_checkpoint_logging, + patch_wandb_init_for_lineage, +) + +def main(): + config = OmegaConf.load("config.yaml") + + # Resolve artifacts before wandb.init() + qualified_names = register_resolvers_from_config( + config, + artifacts_key="run", + mode="pre_init", + ) + + # Patch for lineage and checkpoint logging + patch_wandb_init_for_lineage(artifact_qualified_names=qualified_names) + patch_wandb_checkpoint_logging() + + # Now Megatron-Bridge handles the rest + pretrain(config=cfg, forward_step_func=forward_step) +``` + +### RL (NeMo-RL) + +```python +from nemotron.kit.resolvers import register_resolvers_from_config +from nemotron.kit.wandb import patch_nemo_rl_checkpoint_logging + +def main(): + config = load_config("grpo_config.yaml") + + # Patch before any wandb interaction + patch_nemo_rl_checkpoint_logging() + + # Resolve artifacts + register_resolvers_from_config( + config, + artifacts_key="run", + mode="pre_init", + ) + + # Resolve config (${art:...} interpolations now work) + config = OmegaConf.to_container(config, resolve=True) + + # NeMo-RL training + grpo_train(...) +``` + +## Additional Resolvers + +The kit also provides utility resolvers: + +```yaml +# Multiplication resolver (NeMo-RL) +train_mb_tokens: ${mul:${policy.max_total_sequence_length}, ${policy.train_micro_batch_size}} +``` + +## Further Reading + +- [Artifact Lineage](./artifacts.md) — W&B artifact system and lineage tracking +- [Creating Custom Artifacts](./artifacts.md#creating-custom-artifacts) — Define typed artifact classes +- [W&B Integration](./wandb.md) — Automatic credential handling +- [CLI Framework](./cli.md) — Recipe CLIs and `--run` execution +- [Execution through NeMo-Run](./nemo-run.md) — `env.toml` profiles diff --git a/docs/train/wandb.md b/docs/train/wandb.md new file mode 100644 index 0000000..d057f2c --- /dev/null +++ b/docs/train/wandb.md @@ -0,0 +1,219 @@ +# Weights & Biases Integration + +Nemotron Kit provides automatic W&B configuration that seamlessly passes credentials and settings to containers running via nemo-run. This eliminates manual credential management across local, Docker, Slurm, and cloud executors. + +> **Note**: The artifact system currently requires W&B. Backend-agnostic artifact tracking is in development. + +## Configuration + +### env.toml Setup + +Add a `[wandb]` section to your `env.toml`: + +```toml +[wandb] +project = "nemotron" +entity = "YOUR-TEAM" +``` + +| Field | Description | +|-------|-------------| +| `project` | W&B project name (required to enable tracking) | +| `entity` | W&B team/entity name | + +### Authentication + +Authenticate locally before running jobs: + +```bash +wandb login +``` + +Your API key is stored in `~/.netrc` and automatically detected by the kit. + +## Automatic Environment Variables + +When you run jobs via nemo-run, the kit automatically detects your W&B configuration and passes it to the container as environment variables: + +| Variable | Source | Description | +|----------|--------|-------------| +| `WANDB_API_KEY` | `wandb.api.api_key` | API key from local wandb login | +| `WANDB_PROJECT` | `env.toml [wandb]` | Project name | +| `WANDB_ENTITY` | `env.toml [wandb]` | Team/entity name | + +This works across all executor types: + +- **Local** — Environment variables set directly +- **Docker** — Passed via container env vars +- **Slurm** — Included in job submission +- **SkyPilot** — Set in cloud instance environment +- **Ray** — Passed via `runtime_env.env_vars` + +### How It Works + +The `build_executor()` function in `nemotron.kit.run` handles automatic detection: + +```python +# Auto-detect W&B API key from local login +if "WANDB_API_KEY" not in merged_env: + import wandb + api_key = wandb.api.api_key + if api_key: + merged_env["WANDB_API_KEY"] = api_key + +# Load project/entity from env.toml [wandb] section +wandb_config = load_wandb_config() +if wandb_config is not None: + if wandb_config.project: + merged_env["WANDB_PROJECT"] = wandb_config.project + if wandb_config.entity: + merged_env["WANDB_ENTITY"] = wandb_config.entity +``` + +## Using W&B in Training Scripts + +### Initialization from Environment + +Training scripts running inside containers can initialize W&B from environment variables: + +```python +from nemotron.kit.train_script import init_wandb_from_env + +# Reads WANDB_PROJECT and WANDB_ENTITY from environment +init_wandb_from_env() +``` + +### Conditional Initialization + +For scripts that support optional W&B tracking: + +```python +from nemotron.kit import init_wandb_if_configured +from nemotron.kit.wandb import WandbConfig + +# Initialize only if WandbConfig is provided and has a project set +wandb_config = WandbConfig(project="nemotron", entity="my-team") +init_wandb_if_configured(wandb_config, job_type="training") +``` + +### WandbConfig Dataclass + +The `WandbConfig` dataclass provides typed configuration: + +```python +from nemotron.kit.wandb import WandbConfig + +config = WandbConfig( + project="nemotron", # Required to enable tracking + entity="my-team", # Team/entity name + run_name="experiment-001", # Optional run name + tags=("pretrain", "nano3"), # Tags for filtering + notes="First pretrain run", # Run description +) + +# Check if tracking is enabled +if config.enabled: + print(f"Logging to {config.entity}/{config.project}") +``` + +## Artifact Lineage + +W&B artifacts provide full lineage tracking. See [Artifact Lineage](./artifacts.md) for details on: + +- End-to-end lineage from raw data to final model +- Semantic URIs for artifact references +- Viewing lineage in the W&B UI + +## Advanced Features + +### Checkpoint Logging + +The kit automatically patches checkpoint saving to log artifacts to W&B: + +```python +from nemotron.kit.wandb import patch_wandb_checkpoint_logging + +# Patch Megatron-Bridge checkpoint saving +patch_wandb_checkpoint_logging() +``` + +This enables: +- Automatic artifact creation for each checkpoint +- Lineage links to training data artifacts +- Version tracking with step numbers + +### NeMo-RL Checkpoint Logging + +For reinforcement learning with NeMo-RL: + +```python +from nemotron.kit.wandb import patch_nemo_rl_checkpoint_logging + +# Patch NeMo-RL checkpoint saving +patch_nemo_rl_checkpoint_logging() +``` + +### Seeded Random Fix + +When using seeded random states (common in RL), W&B's default run ID generation can fail. The kit provides a patch: + +```python +from nemotron.kit.wandb import patch_wandb_runid_for_seeded_random + +# Fix "Invalid Client ID digest" errors +patch_wandb_runid_for_seeded_random() +``` + +## Troubleshooting + +### "WANDB_API_KEY not found" + +Ensure you're logged in locally: + +```bash +wandb login +``` + +### "Project not found" + +Verify the project exists in your W&B workspace, or let W&B create it automatically on first run. + +### Environment variables not passed to container + +Check that your `env.toml` has a `[wandb]` section: + +```toml +[wandb] +project = "nemotron" +entity = "YOUR-TEAM" +``` + +### Ray workers missing credentials + +For Ray data prep jobs, credentials are passed via `runtime_env.env_vars`. Ensure your local wandb login is active before submitting the job. + +## API Reference + +### wandb.py Exports + +| Export | Description | +|--------|-------------| +| `WandbConfig` | Configuration dataclass | +| `init_wandb_if_configured()` | Conditional W&B initialization | +| `patch_wandb_checkpoint_logging()` | Enable Megatron-Bridge checkpoint artifacts | +| `patch_nemo_rl_checkpoint_logging()` | Enable NeMo-RL checkpoint artifacts | +| `patch_wandb_runid_for_seeded_random()` | Fix seeded random ID generation | + +### run.py Exports + +| Export | Description | +|--------|-------------| +| `load_wandb_config()` | Load `WandbConfig` from env.toml | +| `build_executor()` | Build executor with auto W&B env vars | + +## Further Reading + +- [OmegaConf Configuration](./omegaconf.md) — Artifact interpolations and unified logging patches +- [Artifact Lineage](./artifacts.md) — Full lineage tracking and W&B UI +- [Nemotron Kit](./kit.md) — Core framework overview +- [Execution through NeMo-Run](./nemo-run.md) — Execution profiles and env.toml diff --git a/docs/usage-cookbook b/docs/usage-cookbook new file mode 120000 index 0000000..8f0f9aa --- /dev/null +++ b/docs/usage-cookbook @@ -0,0 +1 @@ +../usage-cookbook \ No newline at end of file diff --git a/docs/use-case-examples b/docs/use-case-examples new file mode 120000 index 0000000..0d2f55f --- /dev/null +++ b/docs/use-case-examples @@ -0,0 +1 @@ +../use-case-examples \ No newline at end of file diff --git a/docs/versions.json b/docs/versions.json new file mode 100644 index 0000000..0927df0 --- /dev/null +++ b/docs/versions.json @@ -0,0 +1,13 @@ +[ + { + "name": "dev", + "version": "dev", + "url": "https://nvidia-nemo.github.io/Nemotron/dev/" + }, + { + "name": "stable (main)", + "version": "stable", + "url": "https://nvidia-nemo.github.io/Nemotron/stable/", + "preferred": true + } +] diff --git a/justfile b/justfile new file mode 100644 index 0000000..0303ce0 --- /dev/null +++ b/justfile @@ -0,0 +1,9 @@ +# Nemotron development commands + +# Build documentation +docs-render: + uv run --group docs sphinx-build docs docs/_build/html + +# Start documentation development server with live reload +docs-dev: + uv run --group docs sphinx-autobuild docs docs/_build/html --port 12345 --open-browser diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..2d16415 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,129 @@ +[project] +name = "nemotron" +version = "0.1.0" +description = "Reproducible training recipes for NVIDIA Nemotron model family - transparent pipelines for data preparation, training, and evaluation across all stages" +requires-python = ">=3.10" +license = {text = "MIT"} +authors = [ + {name = "Nemotron Contributors"} +] +keywords = ["nemotron", "nvidia", "llm", "training", "reproducible", "pipelines", "machine-learning"] +classifiers = [ + "Development Status :: 3 - Alpha", + "Intended Audience :: Developers", + "Intended Audience :: Science/Research", + "Intended Audience :: Education", + "License :: OSI Approved :: MIT License", + "Programming Language :: Python :: 3", + "Programming Language :: Python :: 3.10", + "Programming Language :: Python :: 3.11", + "Programming Language :: Python :: 3.12", + "Topic :: Scientific/Engineering :: Artificial Intelligence", +] + +dependencies = [ + "nemo-run>=0.4.0", + "pydantic>=2.0.0", + "typer>=0.12.0", + "omegaconf>=2.3.0", + "rich>=13.0.0", + "textual>=0.70.0", + "ray==2.49.2", + "fsspec>=2024.0.0", + "numpy>=1.24.0", + "pyarrow>=14.0.0", + "xxhash>=3.4.0", + "transformers>=4.36.0", + "huggingface_hub>=0.20.0", + "datasets>=2.14.0", # Required for ray.data.from_huggingface + "pyyaml>=6.0", + "tomli>=2.0.0;python_version<'3.11'", + "tomlkit>=0.12.0", + "colorama>=0.4.6", + "wandb>=0.23.1", + "jinja2>=3.0.0", # Required for chat templates in transformers +] + +[project.optional-dependencies] +wandb = ["wandb>=0.15.0"] +s3 = ["s3fs>=2024.0.0"] +gcs = ["gcsfs>=2024.0.0"] +sentencepiece = ["sentencepiece>=0.2.0"] +dev = [ + "pytest>=7.0.0", + "pytest-cov>=4.0.0", + "mypy>=1.0.0", + "ruff>=0.1.0", +] +all = [ + "wandb>=0.15.0", + "s3fs>=2024.0.0", + "gcsfs>=2024.0.0", + "sentencepiece>=0.2.0", +] + +# Note: megatron-bridge is required for training but not listed as a dependency +# because it requires CUDA/nvcc to build. Install separately in GPU environments: +# pip install megatron-bridge>=0.1.0 + +[project.urls] +Homepage = "https://github.com/nemotron/nemotron" +Documentation = "https://github.com/nemotron/nemotron#readme" +Repository = "https://github.com/nemotron/nemotron" + +[project.scripts] +nemotron = "nemotron.__main__:main" + +[project.entry-points."fsspec.specs"] +art = "nemotron.art.filesystem:ArtifactFileSystem" + +[build-system] +requires = ["hatchling"] +build-backend = "hatchling.build" + +[tool.hatch.build.targets.wheel] +packages = ["src/nemotron"] + +[tool.pytest.ini_options] +testpaths = ["tests"] +python_files = ["test_*.py"] +python_functions = ["test_*"] + +[tool.mypy] +python_version = "3.10" +warn_return_any = true +warn_unused_configs = true +disallow_untyped_defs = true + +[tool.ruff] +line-length = 100 +target-version = "py310" +exclude = [ + "usage-cookbook", + "use-case-examples", +] + +[tool.ruff.lint] +select = ["E", "F", "I", "N", "W", "UP"] +ignore = [] + +[tool.uv] +package = true + +[dependency-groups] +dev = [ + "pytest>=9.0.2", +] +run = [ + "nemo-run>=0.4.0", +] +docs = [ + "myst-parser>=4.0.1", + "nvidia-sphinx-theme>=0.0.8", + "sphinx>=8.1.3", + "sphinx-autobuild>=2024.10.3", + "sphinx-autodoc2>=0.5.0", + "sphinx-copybutton>=0.5.2", + "sphinx-design>=0.6.0", + "sphinxcontrib-mermaid", +] diff --git a/src/nemotron/__init__.py b/src/nemotron/__init__.py new file mode 100644 index 0000000..96eb999 --- /dev/null +++ b/src/nemotron/__init__.py @@ -0,0 +1,37 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +""" +Nemotron: Reproducible Training Recipes for NVIDIA Nemotron Models + +Transparent - Reproducible - Production-Ready + +The nemotron package provides a transparent framework for building +reproducible training pipelines. Used to create complete training recipes +for NVIDIA Nemotron models with full data preparation, training, and +evaluation stages. + +Example: + >>> from nemotron.kit import Artifact + >>> from pydantic import Field + >>> from pathlib import Path + >>> + >>> class Dataset(Artifact): + ... num_examples: int = Field(gt=0) + >>> + >>> dataset = Dataset(path=Path("/tmp/data"), num_examples=1000) + >>> dataset.save() +""" + +__version__ = "0.1.0" diff --git a/src/nemotron/__main__.py b/src/nemotron/__main__.py new file mode 100644 index 0000000..0df0f96 --- /dev/null +++ b/src/nemotron/__main__.py @@ -0,0 +1,37 @@ +#!/usr/bin/env python3 + +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Nemotron CLI entry point. + +Usage: + nemotron nano3 pretrain -c test # local execution + nemotron nano3 pretrain --config test --run dlw # nemo-run attached + nemotron nano3 pretrain -c test -r dlw train.train_iters=5000 + nemotron nano3 pretrain -c test --dry-run # preview config +""" + +from __future__ import annotations + + +def main() -> None: + """Main CLI entry point.""" + from nemotron.cli.bin.nemotron import main as typer_main + + typer_main() + + +if __name__ == "__main__": + main() diff --git a/src/nemotron/cli/README.md b/src/nemotron/cli/README.md new file mode 100644 index 0000000..e86ea6d --- /dev/null +++ b/src/nemotron/cli/README.md @@ -0,0 +1,144 @@ +# nemotron.cli + +Entry point for the `nemotron` command-line interface. + +## Overview + +This package provides the CLI commands for Nemotron training recipes. The CLI is built on [Typer](https://typer.tiangolo.com/) and integrates with `nemotron.kit` for configuration, artifact resolution, and NeMo-Run execution. + +## Entry Point + +The `nemotron` command is registered as a console script in `pyproject.toml`: + +```toml +[project.scripts] +nemotron = "nemotron.cli.bin.nemotron:main" +``` + +## Command Structure + +``` +nemotron +├── nano3 # Nano3 training recipe +│ ├── pretrain # Stage 0: Pretraining +│ ├── sft # Stage 1: Supervised fine-tuning +│ ├── rl # Stage 2: Reinforcement learning +│ ├── data +│ │ ├── prep +│ │ │ ├── pretrain # Prepare pretrain data +│ │ │ ├── sft # Prepare SFT data +│ │ │ └── rl # Prepare RL data +│ │ └── import +│ │ ├── pretrain # Import pretrain data artifact +│ │ ├── sft # Import SFT data artifact +│ │ └── rl # Import RL data artifact +│ └── model +│ ├── eval # Evaluate model +│ └── import +│ ├── pretrain # Import pretrain checkpoint +│ ├── sft # Import SFT checkpoint +│ └── rl # Import RL checkpoint +└── kit # Kit utilities + └── squash # Squash container images +``` + +## Module Structure + +``` +src/nemotron/cli/ +├── __init__.py # Package marker +├── bin/ +│ └── nemotron.py # Main entry point (typer app) +├── kit/ +│ ├── app.py # Kit utility commands +│ └── squash.py # Container squashing +└── nano3/ # Nano3 recipe CLI + ├── app.py # Root nano3 group + ├── pretrain.py # Pretrain command + ├── sft.py # SFT command + ├── rl.py # RL command + ├── data/ + │ ├── app.py # Data group + │ ├── prep/ # Data prep commands + │ └── import_/ # Data import commands + └── model/ + ├── app.py # Model group + ├── eval.py # Model evaluation + └── import_/ # Model import commands +``` + +## Global Options + +All commands support these global options: + +| Option | Short | Description | +|--------|-------|-------------| +| `--config` | `-c` | Config name or path | +| `--run` | `-r` | Attached execution via NeMo-Run | +| `--batch` | `-b` | Detached execution via NeMo-Run | +| `--dry-run` | `-d` | Preview config without execution | +| `--stage` | | Stage script to remote for debugging | + +## Usage Examples + +```bash +# Local execution with config +uv run nemotron nano3 pretrain -c tiny + +# Submit to cluster (attached) +uv run nemotron nano3 pretrain -c tiny --run MY-CLUSTER + +# Submit to cluster (detached) +uv run nemotron nano3 pretrain -c tiny --batch MY-CLUSTER + +# Preview without execution +uv run nemotron nano3 pretrain -c tiny --dry-run + +# Override config values +uv run nemotron nano3 pretrain -c tiny train.train_iters=5000 + +# Data preparation +uv run nemotron nano3 data prep pretrain --run MY-CLUSTER +uv run nemotron nano3 data prep sft --run MY-CLUSTER +uv run nemotron nano3 data prep rl --run MY-CLUSTER +``` + +## Adding New Commands + +To add a new command: + +1. Create command module in appropriate directory +2. Define config dataclass and handler function +3. Register with parent app using `add_typer()` or command decorator + +Example: + +```python +# mycommand.py +import typer +from dataclasses import dataclass + +@dataclass +class MyConfig: + param: str = "default" + +def my_handler(cfg: MyConfig): + print(f"Running with {cfg.param}") + +app = typer.Typer() + +@app.command() +def run(param: str = "default"): + my_handler(MyConfig(param=param)) +``` + +## Full Documentation + +See [docs/train/cli.md](../../../docs/train/cli.md) for complete CLI framework documentation including: + +- Building CLIs with App +- Artifact inputs and resolution +- Execution modes +- Recipe tutorial + +See [docs/train/nemo-run.md](../../../docs/train/nemo-run.md) for execution profile configuration. diff --git a/src/nemotron/cli/__init__.py b/src/nemotron/cli/__init__.py new file mode 100644 index 0000000..6555e1b --- /dev/null +++ b/src/nemotron/cli/__init__.py @@ -0,0 +1,18 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Nemotron CLI commands. + +This package contains the typer-based CLI command groups. +""" diff --git a/src/nemotron/cli/bin/__init__.py b/src/nemotron/cli/bin/__init__.py new file mode 100644 index 0000000..53e13e0 --- /dev/null +++ b/src/nemotron/cli/bin/__init__.py @@ -0,0 +1,15 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""CLI binary entry points.""" diff --git a/src/nemotron/cli/bin/nemotron.py b/src/nemotron/cli/bin/nemotron.py new file mode 100644 index 0000000..a595e5c --- /dev/null +++ b/src/nemotron/cli/bin/nemotron.py @@ -0,0 +1,100 @@ +#!/usr/bin/env python3 + +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Nemotron CLI - Main entry point. + +Usage: + nemotron nano3 pretrain -c test # local execution + nemotron nano3 pretrain --config test --run dlw # nemo-run attached + nemotron nano3 pretrain -c test -r dlw train.train_iters=5000 + nemotron nano3 pretrain -c test --dry-run # preview config +""" + +from __future__ import annotations + +import typer + +from nemotron.kit.cli.globals import global_callback + +# Create root app with global callback +app = typer.Typer( + name="nemotron", + help="Nemotron CLI - Reproducible training recipes", + no_args_is_help=True, + context_settings={"help_option_names": ["-h", "--help"]}, + rich_markup_mode="rich", +) + + +@app.callback() +def main_callback( + ctx: typer.Context, + config: str | None = typer.Option( + None, + "-c", + "--config", + help="Config name (looks in recipe's config/ dir) or path", + ), + run: str | None = typer.Option( + None, + "-r", + "--run", + help="Execute attached via nemo-run with specified env profile", + ), + batch: str | None = typer.Option( + None, + "-b", + "--batch", + help="Execute detached via nemo-run with specified env profile", + ), + dry_run: bool = typer.Option( + False, + "-d", + "--dry-run", + help="Print compiled config as rich table (no execution)", + ), + stage: bool = typer.Option( + False, + "--stage", + help="Stage script + config to remote cluster for interactive debugging", + ), +) -> None: + """Nemotron CLI - Reproducible training recipes.""" + # Delegate to global_callback + global_callback(ctx, config, run, batch, dry_run, stage) + + +# Import and register recipe groups +def _register_groups() -> None: + """Register all recipe groups with the main app.""" + from nemotron.cli.kit import kit_app + from nemotron.cli.nano3 import nano3_app + + app.add_typer(nano3_app, name="nano3") + app.add_typer(kit_app, name="kit") + + +# Register groups on import +_register_groups() + + +def main() -> None: + """Entry point for the nemotron CLI.""" + app() + + +if __name__ == "__main__": + main() diff --git a/src/nemotron/cli/kit/__init__.py b/src/nemotron/cli/kit/__init__.py new file mode 100644 index 0000000..701e5ce --- /dev/null +++ b/src/nemotron/cli/kit/__init__.py @@ -0,0 +1,19 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Kit CLI group - utilities for setup and management.""" + +from nemotron.cli.kit.app import kit_app + +__all__ = ["kit_app"] diff --git a/src/nemotron/cli/kit/app.py b/src/nemotron/cli/kit/app.py new file mode 100644 index 0000000..d41447f --- /dev/null +++ b/src/nemotron/cli/kit/app.py @@ -0,0 +1,34 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Kit Typer group. + +Contains utility commands for cluster setup and management. +""" + +from __future__ import annotations + +import typer + +from nemotron.cli.kit.squash import squash + +# Create kit app +kit_app = typer.Typer( + name="kit", + help="Utility commands for cluster setup and management", + no_args_is_help=True, +) + +# Register commands +kit_app.command(name="squash")(squash) diff --git a/src/nemotron/cli/kit/squash.py b/src/nemotron/cli/kit/squash.py new file mode 100644 index 0000000..7b72f05 --- /dev/null +++ b/src/nemotron/cli/kit/squash.py @@ -0,0 +1,206 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Squash command - convert Docker images to squash files on remote clusters. + +Usage: + nemotron kit squash dlw nvcr.io/nvidian/nemo:25.11-nano-v3.rc2 + nemotron kit squash dlw --all # squash all containers from config +""" + +from __future__ import annotations + +import typer +from rich.console import Console +from rich.panel import Panel +from rich.table import Table + +from nemotron.kit.cli.env import load_env_profile +from nemotron.kit.cli.squash import check_sqsh_exists, container_to_sqsh_name + +console = Console() + + +def squash( + profile: str = typer.Argument( + ..., + help="Env profile name from env.toml (e.g., 'dlw')", + ), + container: str | None = typer.Argument( + None, + help="Docker image to squash (e.g., 'nvcr.io/nvidian/nemo:25.11-nano-v3.rc2')", + ), + dry_run: bool = typer.Option( + False, + "-d", + "--dry-run", + help="Show what would be done without executing", + ), + force: bool = typer.Option( + False, + "--force", + help="Force re-squash even if squash file already exists", + ), +) -> None: + """Convert Docker images to squash files on remote cluster. + + Connects to the cluster via SSH and uses enroot to import Docker images + as squash files. Uses deterministic naming so existing images are skipped. + + Examples: + nemotron kit squash dlw nvcr.io/nvidian/nemo:25.11-nano-v3.rc2 + nemotron kit squash dlw rayproject/ray:nightly-extra-py312-cpu + nemotron kit squash dlw nvcr.io/nvidian/nemo:25.11-nano-v3.rc2 --dry-run + """ + # Load env profile + try: + env_config = load_env_profile(profile) + except (FileNotFoundError, KeyError) as e: + console.print(f"[red bold]Error:[/red bold] {e}") + raise typer.Exit(1) + + # Validate profile has required fields + host = env_config.get("host") + user = env_config.get("user") + remote_job_dir = env_config.get("remote_job_dir") + + if not host or not user: + console.print( + f"[red bold]Error:[/red bold] Profile '{profile}' missing host or user for SSH" + ) + raise typer.Exit(1) + + if not remote_job_dir: + console.print(f"[red bold]Error:[/red bold] Profile '{profile}' missing remote_job_dir") + raise typer.Exit(1) + + if not container: + console.print("[red bold]Error:[/red bold] Container image is required") + console.print("\nUsage: nemotron kit squash ") + console.print("Example: nemotron kit squash dlw nvcr.io/nvidian/nemo:25.11-nano-v3.rc2") + raise typer.Exit(1) + + # Generate squash filename + sqsh_name = container_to_sqsh_name(container) + remote_path = f"{remote_job_dir}/{sqsh_name}" + + # Show configuration + table = Table(show_header=False, box=None, padding=(0, 2)) + table.add_column("Key", style="dim") + table.add_column("Value") + table.add_row("Profile", f"[cyan]{profile}[/cyan]") + table.add_row("Host", f"{user}@{host}") + table.add_row("Container", container) + table.add_row("Output", remote_path) + console.print(Panel(table, title="[bold]Squash Configuration[/bold]", expand=False)) + console.print() + + if dry_run: + console.print("[yellow]Dry-run mode - no changes will be made[/yellow]") + console.print() + console.print(f"Would run on {host}:") + console.print(f" enroot import --output {remote_path} docker://{container}") + return + + # Connect to cluster + try: + import nemo_run as run + except ImportError: + console.print("[red bold]Error:[/red bold] nemo-run is required for squash") + console.print("Install with: pip install nemo-run") + raise typer.Exit(1) + + with console.status("[bold blue]Connecting to cluster..."): + tunnel = run.SSHTunnel( + host=host, + user=user, + job_dir=remote_job_dir, + ) + tunnel.connect() + + console.print("[green]Connected![/green]") + console.print() + + # Check if already exists (unless force is set) + if not force and check_sqsh_exists(tunnel, remote_path): + console.print(f"[yellow]Squash file already exists:[/yellow] {remote_path}") + console.print("[dim]Skipping import. Use --force to re-squash.[/dim]") + tunnel.cleanup() + return + + # Ensure remote directory exists + with console.status("[bold blue]Creating remote directory..."): + tunnel.run(f"mkdir -p {remote_job_dir}", hide=True) + + # Remove existing file if force is set + if force: + console.print("[yellow]Removing existing squash file...[/yellow]") + tunnel.run(f"rm -f {remote_path}", hide=True) + + # Build salloc command to run enroot import on a compute node + # (login nodes don't have enough memory for enroot import) + account = env_config.get("account") + partition = env_config.get("run_partition") or env_config.get("partition") + time_limit = env_config.get("time", "04:00:00") + gpus_per_node = env_config.get("gpus_per_node") + + salloc_args = [] + if account: + salloc_args.append(f"--account={account}") + if partition: + salloc_args.append(f"--partition={partition}") + salloc_args.append("--nodes=1") + salloc_args.append("--ntasks-per-node=1") + if gpus_per_node: + salloc_args.append(f"--gpus-per-node={gpus_per_node}") + salloc_args.append(f"--time={time_limit}") + + enroot_cmd = f"enroot import --output {remote_path} docker://{container}" + cmd = f"salloc {' '.join(salloc_args)} srun {enroot_cmd}" + + # Run enroot import via salloc + console.print("[bold]Allocating compute node and importing container...[/bold]") + console.print(f" {container}") + console.print(f" -> {remote_path}") + console.print() + console.print(f"[dim]$ {cmd}[/dim]") + console.print() + console.print("[dim]This may take several minutes...[/dim]") + console.print() + + result = tunnel.run(cmd, hide=False, warn=True) + + tunnel.cleanup() + + if result.ok: + console.print() + console.print( + Panel( + f"[green]Successfully imported:[/green]\n{remote_path}", + title="[bold green]Complete[/bold green]", + border_style="green", + expand=False, + ) + ) + else: + console.print() + console.print( + Panel( + f"[red]Failed to import container[/red]\n{result.stderr or 'Unknown error'}", + title="[bold red]Error[/bold red]", + border_style="red", + expand=False, + ) + ) + raise typer.Exit(1) diff --git a/src/nemotron/cli/nano3/__init__.py b/src/nemotron/cli/nano3/__init__.py new file mode 100644 index 0000000..a2d41e5 --- /dev/null +++ b/src/nemotron/cli/nano3/__init__.py @@ -0,0 +1,22 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Nano3 CLI command group. + +Exports the nano3_app typer group. +""" + +from nemotron.cli.nano3.app import nano3_app + +__all__ = ["nano3_app"] diff --git a/src/nemotron/cli/nano3/app.py b/src/nemotron/cli/nano3/app.py new file mode 100644 index 0000000..9e13b79 --- /dev/null +++ b/src/nemotron/cli/nano3/app.py @@ -0,0 +1,93 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Nano3 Typer group. + +Contains the nano3 command group with subcommands for training stages. +""" + +from __future__ import annotations + +import typer + +from nemotron.cli.nano3.data import data_app +from nemotron.cli.nano3.help import RecipeCommand, make_recipe_command +from nemotron.cli.nano3.model import model_app +from nemotron.cli.nano3.pretrain import pretrain +from nemotron.cli.nano3.rl import rl +from nemotron.cli.nano3.sft import sft + + +# Create nano3 app +nano3_app = typer.Typer( + name="nano3", + help="Nano3 training recipe", + no_args_is_help=True, + rich_markup_mode="rich", +) + +# Register data subgroup +nano3_app.add_typer(data_app, name="data") + +# Register model subgroup +nano3_app.add_typer(model_app, name="model") + +# Register commands with custom command class for enhanced help +# Pretrain has data artifact override +nano3_app.command( + name="pretrain", + context_settings={ + "allow_extra_args": True, + "ignore_unknown_options": True, + }, + rich_help_panel="Training Stages", + cls=make_recipe_command( + artifact_overrides={"data": "Pretrain data artifact (bin/idx blends)"}, + config_dir="src/nemotron/recipes/nano3/stage0_pretrain/config", + ), +)(pretrain) + +# SFT has data and model artifact overrides +nano3_app.command( + name="sft", + context_settings={ + "allow_extra_args": True, + "ignore_unknown_options": True, + }, + rich_help_panel="Training Stages", + cls=make_recipe_command( + artifact_overrides={ + "model": "Base model checkpoint artifact", + "data": "SFT data artifact (packed .npy)", + }, + config_dir="src/nemotron/recipes/nano3/stage1_sft/config", + ), +)(sft) + +# RL has data and model artifact overrides +nano3_app.command( + name="rl", + context_settings={ + "allow_extra_args": True, + "ignore_unknown_options": True, + }, + rich_help_panel="Training Stages", + cls=make_recipe_command( + artifact_overrides={ + "model": "SFT model checkpoint artifact", + "data": "RL data artifact (JSONL prompts)", + }, + config_dir="src/nemotron/recipes/nano3/stage2_rl/config", + ), +)(rl) diff --git a/src/nemotron/cli/nano3/data/__init__.py b/src/nemotron/cli/nano3/data/__init__.py new file mode 100644 index 0000000..15dfff1 --- /dev/null +++ b/src/nemotron/cli/nano3/data/__init__.py @@ -0,0 +1,19 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Data command group for nano3.""" + +from nemotron.cli.nano3.data.app import data_app + +__all__ = ["data_app"] diff --git a/src/nemotron/cli/nano3/data/app.py b/src/nemotron/cli/nano3/data/app.py new file mode 100644 index 0000000..96d3c46 --- /dev/null +++ b/src/nemotron/cli/nano3/data/app.py @@ -0,0 +1,35 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Data command group for nano3.""" + +from __future__ import annotations + +import typer + +from nemotron.cli.nano3.data.import_ import import_app +from nemotron.cli.nano3.data.prep import prep_app + +# Create data app +data_app = typer.Typer( + name="data", + help="Data curation and preparation commands", + no_args_is_help=True, +) + +# Register prep subgroup +data_app.add_typer(prep_app, name="prep") + +# Register import subgroup +data_app.add_typer(import_app, name="import") diff --git a/src/nemotron/cli/nano3/data/import_/__init__.py b/src/nemotron/cli/nano3/data/import_/__init__.py new file mode 100644 index 0000000..2051c6a --- /dev/null +++ b/src/nemotron/cli/nano3/data/import_/__init__.py @@ -0,0 +1,19 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Data import command group for nano3.""" + +from nemotron.cli.nano3.data.import_.app import import_app + +__all__ = ["import_app"] diff --git a/src/nemotron/cli/nano3/data/import_/app.py b/src/nemotron/cli/nano3/data/import_/app.py new file mode 100644 index 0000000..4f59cf4 --- /dev/null +++ b/src/nemotron/cli/nano3/data/import_/app.py @@ -0,0 +1,35 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Data import Typer group for nano3.""" + +from __future__ import annotations + +import typer + +from nemotron.cli.nano3.data.import_.pretrain import pretrain +from nemotron.cli.nano3.data.import_.rl import rl +from nemotron.cli.nano3.data.import_.sft import sft + +# Create import app +import_app = typer.Typer( + name="import", + help="Import data as W&B artifacts", + no_args_is_help=True, +) + +# Register commands +import_app.command(name="pretrain")(pretrain) +import_app.command(name="sft")(sft) +import_app.command(name="rl")(rl) diff --git a/src/nemotron/cli/nano3/data/import_/pretrain.py b/src/nemotron/cli/nano3/data/import_/pretrain.py new file mode 100644 index 0000000..39fa63f --- /dev/null +++ b/src/nemotron/cli/nano3/data/import_/pretrain.py @@ -0,0 +1,77 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Import pretrain data as W&B artifact.""" + +from __future__ import annotations + +from pathlib import Path + +import typer + +from nemotron.kit.artifact import DataBlendsArtifact +from nemotron.kit.cli.env import get_wandb_config +from nemotron.kit.wandb import WandbConfig, init_wandb_if_configured + + +def pretrain( + data_path: Path = typer.Argument(..., help="Path to blend.json file"), + name: str | None = typer.Option(None, "--name", "-n", help="Custom artifact name"), + project: str | None = typer.Option( + None, "--project", "-p", help="W&B project (overrides env.toml)" + ), + entity: str | None = typer.Option( + None, "--entity", "-e", help="W&B entity (overrides env.toml)" + ), +) -> None: + """Import pretrain data (blend.json) as a W&B artifact. + + Examples: + nemotron nano3 data import pretrain /path/to/blend.json + nemotron nano3 data import pretrain /path/to/blend.json --project my-project + """ + # Resolve data path + data_path = data_path.resolve() + if not data_path.exists(): + typer.echo(f"Error: Data path does not exist: {data_path}", err=True) + raise typer.Exit(1) + + # Build W&B config from env.toml with CLI overrides + env_wandb = get_wandb_config() + wandb_project = project or (env_wandb.project if env_wandb else None) + wandb_entity = entity or (env_wandb.entity if env_wandb else None) + + if not wandb_project: + typer.echo("Error: W&B project required. Set in env.toml or use --project", err=True) + raise typer.Exit(1) + + wandb_config = WandbConfig(project=wandb_project, entity=wandb_entity) + + # Initialize W&B + init_wandb_if_configured(wandb_config, job_type="data-import", tags=["pretrain", "import"]) + + # Create artifact with minimal required fields + artifact_name = name or "nano3/pretrain/data" + artifact = DataBlendsArtifact( + path=data_path, + total_tokens=0, + total_sequences=0, + name=artifact_name, + ) + + # Save and register with W&B + artifact.save() + + typer.echo(f"Imported pretrain data from {data_path}") + typer.echo(f"Artifact: {artifact_name}") diff --git a/src/nemotron/cli/nano3/data/import_/rl.py b/src/nemotron/cli/nano3/data/import_/rl.py new file mode 100644 index 0000000..8119c2c --- /dev/null +++ b/src/nemotron/cli/nano3/data/import_/rl.py @@ -0,0 +1,86 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Import RL data as W&B artifact.""" + +from __future__ import annotations + +from pathlib import Path + +import typer + +from nemotron.kit.artifact import SplitJsonlDataArtifact +from nemotron.kit.cli.env import get_wandb_config +from nemotron.kit.wandb import WandbConfig, init_wandb_if_configured + + +def rl( + data_dir: Path = typer.Argument(..., help="Path to data directory containing manifest.json"), + name: str | None = typer.Option(None, "--name", "-n", help="Custom artifact name"), + project: str | None = typer.Option( + None, "--project", "-p", help="W&B project (overrides env.toml)" + ), + entity: str | None = typer.Option( + None, "--entity", "-e", help="W&B entity (overrides env.toml)" + ), +) -> None: + """Import RL data directory as a W&B artifact. + + Examples: + nemotron nano3 data import rl /path/to/data_dir + nemotron nano3 data import rl /path/to/data_dir --project my-project + """ + # Resolve data directory + data_dir = data_dir.resolve() + if not data_dir.exists(): + typer.echo(f"Error: Data directory does not exist: {data_dir}", err=True) + raise typer.Exit(1) + + if not data_dir.is_dir(): + typer.echo(f"Error: Path is not a directory: {data_dir}", err=True) + raise typer.Exit(1) + + # Look for manifest.json in directory + manifest_path = data_dir / "manifest.json" + if not manifest_path.exists(): + typer.echo(f"Error: No manifest.json found in directory: {data_dir}", err=True) + raise typer.Exit(1) + + # Build W&B config from env.toml with CLI overrides + env_wandb = get_wandb_config() + wandb_project = project or (env_wandb.project if env_wandb else None) + wandb_entity = entity or (env_wandb.entity if env_wandb else None) + + if not wandb_project: + typer.echo("Error: W&B project required. Set in env.toml or use --project", err=True) + raise typer.Exit(1) + + wandb_config = WandbConfig(project=wandb_project, entity=wandb_entity) + + # Initialize W&B + init_wandb_if_configured(wandb_config, job_type="data-import", tags=["rl", "import"]) + + # Create artifact with minimal required fields + artifact_name = name or "nano3/rl/data" + artifact = SplitJsonlDataArtifact( + path=manifest_path, + total_sequences=0, + name=artifact_name, + ) + + # Save and register with W&B + artifact.save() + + typer.echo(f"Imported RL data from {data_dir}") + typer.echo(f"Artifact: {artifact_name}") diff --git a/src/nemotron/cli/nano3/data/import_/sft.py b/src/nemotron/cli/nano3/data/import_/sft.py new file mode 100644 index 0000000..58bd7e0 --- /dev/null +++ b/src/nemotron/cli/nano3/data/import_/sft.py @@ -0,0 +1,87 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Import SFT data as W&B artifact.""" + +from __future__ import annotations + +from pathlib import Path + +import typer + +from nemotron.kit.artifact import DataBlendsArtifact +from nemotron.kit.cli.env import get_wandb_config +from nemotron.kit.wandb import WandbConfig, init_wandb_if_configured + + +def sft( + data_dir: Path = typer.Argument(..., help="Path to data directory containing blend.json"), + name: str | None = typer.Option(None, "--name", "-n", help="Custom artifact name"), + project: str | None = typer.Option( + None, "--project", "-p", help="W&B project (overrides env.toml)" + ), + entity: str | None = typer.Option( + None, "--entity", "-e", help="W&B entity (overrides env.toml)" + ), +) -> None: + """Import SFT data directory as a W&B artifact. + + Examples: + nemotron nano3 data import sft /path/to/data_dir + nemotron nano3 data import sft /path/to/data_dir --project my-project + """ + # Resolve data directory + data_dir = data_dir.resolve() + if not data_dir.exists(): + typer.echo(f"Error: Data directory does not exist: {data_dir}", err=True) + raise typer.Exit(1) + + if not data_dir.is_dir(): + typer.echo(f"Error: Path is not a directory: {data_dir}", err=True) + raise typer.Exit(1) + + # Look for blend.json in directory + blend_path = data_dir / "blend.json" + if not blend_path.exists(): + typer.echo(f"Error: No blend.json found in directory: {data_dir}", err=True) + raise typer.Exit(1) + + # Build W&B config from env.toml with CLI overrides + env_wandb = get_wandb_config() + wandb_project = project or (env_wandb.project if env_wandb else None) + wandb_entity = entity or (env_wandb.entity if env_wandb else None) + + if not wandb_project: + typer.echo("Error: W&B project required. Set in env.toml or use --project", err=True) + raise typer.Exit(1) + + wandb_config = WandbConfig(project=wandb_project, entity=wandb_entity) + + # Initialize W&B + init_wandb_if_configured(wandb_config, job_type="data-import", tags=["sft", "import"]) + + # Create artifact with minimal required fields + artifact_name = name or "nano3/sft/data" + artifact = DataBlendsArtifact( + path=blend_path, + total_tokens=0, + total_sequences=0, + name=artifact_name, + ) + + # Save and register with W&B + artifact.save() + + typer.echo(f"Imported SFT data from {data_dir}") + typer.echo(f"Artifact: {artifact_name}") diff --git a/src/nemotron/cli/nano3/data/prep/__init__.py b/src/nemotron/cli/nano3/data/prep/__init__.py new file mode 100644 index 0000000..fa099dc --- /dev/null +++ b/src/nemotron/cli/nano3/data/prep/__init__.py @@ -0,0 +1,19 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Data prep command group for nano3.""" + +from nemotron.cli.nano3.data.prep.app import prep_app + +__all__ = ["prep_app"] diff --git a/src/nemotron/cli/nano3/data/prep/app.py b/src/nemotron/cli/nano3/data/prep/app.py new file mode 100644 index 0000000..44f8221 --- /dev/null +++ b/src/nemotron/cli/nano3/data/prep/app.py @@ -0,0 +1,66 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Data prep command group for nano3.""" + +from __future__ import annotations + +import typer + +from nemotron.cli.nano3.data.prep.pretrain import pretrain +from nemotron.cli.nano3.data.prep.rl import rl +from nemotron.cli.nano3.data.prep.sft import sft +from nemotron.cli.nano3.help import make_recipe_command + +# Create prep app +prep_app = typer.Typer( + name="prep", + help="Prepare data for training stages", + no_args_is_help=True, + rich_markup_mode="rich", +) + +# Register commands with custom help and allow_extra_args for dotlist overrides +prep_app.command( + name="pretrain", + context_settings={ + "allow_extra_args": True, + "ignore_unknown_options": True, + }, + cls=make_recipe_command( + config_dir="src/nemotron/recipes/nano3/stage0_pretrain/config/data_prep", + ), +)(pretrain) + +prep_app.command( + name="sft", + context_settings={ + "allow_extra_args": True, + "ignore_unknown_options": True, + }, + cls=make_recipe_command( + config_dir="src/nemotron/recipes/nano3/stage1_sft/config/data_prep", + ), +)(sft) + +prep_app.command( + name="rl", + context_settings={ + "allow_extra_args": True, + "ignore_unknown_options": True, + }, + cls=make_recipe_command( + config_dir="src/nemotron/recipes/nano3/stage2_rl/config/data_prep", + ), +)(rl) diff --git a/src/nemotron/cli/nano3/data/prep/pretrain.py b/src/nemotron/cli/nano3/data/prep/pretrain.py new file mode 100644 index 0000000..8a587c1 --- /dev/null +++ b/src/nemotron/cli/nano3/data/prep/pretrain.py @@ -0,0 +1,35 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Pretrain data preparation command.""" + +from __future__ import annotations + +import typer + +from nemotron.kit.cli.recipe import recipe + + +@recipe( + name="nano3/data/prep/pretrain", + script_path="src/nemotron/recipes/nano3/stage0_pretrain/data_prep.py", + config_dir="src/nemotron/recipes/nano3/stage0_pretrain/config/data_prep", + default_config="default", + torchrun=False, + ray=True, + packager="code", +) +def pretrain(ctx: typer.Context) -> None: + """Tokenize data for pretraining (bin/idx format).""" + ... diff --git a/src/nemotron/cli/nano3/data/prep/rl.py b/src/nemotron/cli/nano3/data/prep/rl.py new file mode 100644 index 0000000..fa6e88c --- /dev/null +++ b/src/nemotron/cli/nano3/data/prep/rl.py @@ -0,0 +1,35 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""RL data preparation command.""" + +from __future__ import annotations + +import typer + +from nemotron.kit.cli.recipe import recipe + + +@recipe( + name="nano3/data/prep/rl", + script_path="src/nemotron/recipes/nano3/stage2_rl/data_prep.py", + config_dir="src/nemotron/recipes/nano3/stage2_rl/config/data_prep", + default_config="default", + torchrun=False, + ray=True, + packager="code", +) +def rl(ctx: typer.Context) -> None: + """Prepare data for RL (JSONL chat format).""" + ... diff --git a/src/nemotron/cli/nano3/data/prep/sft.py b/src/nemotron/cli/nano3/data/prep/sft.py new file mode 100644 index 0000000..fe08ee2 --- /dev/null +++ b/src/nemotron/cli/nano3/data/prep/sft.py @@ -0,0 +1,35 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""SFT data preparation command.""" + +from __future__ import annotations + +import typer + +from nemotron.kit.cli.recipe import recipe + + +@recipe( + name="nano3/data/prep/sft", + script_path="src/nemotron/recipes/nano3/stage1_sft/data_prep.py", + config_dir="src/nemotron/recipes/nano3/stage1_sft/config/data_prep", + default_config="default", + torchrun=False, + ray=True, + packager="code", +) +def sft(ctx: typer.Context) -> None: + """Prepare data for SFT (packed .npy format).""" + ... diff --git a/src/nemotron/cli/nano3/help.py b/src/nemotron/cli/nano3/help.py new file mode 100644 index 0000000..2e9c569 --- /dev/null +++ b/src/nemotron/cli/nano3/help.py @@ -0,0 +1,247 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Custom help formatting for nano3 CLI commands. + +Provides RecipeCommand class that extends TyperCommand with custom help panels +for global options, run overrides, artifact overrides, and examples. +""" + +from __future__ import annotations + +from pathlib import Path +from typing import ClassVar + +from rich import box +from rich.panel import Panel +from rich.table import Table +from typer import rich_utils +from typer.core import TyperCommand + +try: + import tomllib +except ImportError: + import tomli as tomllib + + +def _get_env_profiles() -> list[str]: + """Get list of profile names from env.toml, excluding special sections.""" + env_path = Path("env.toml") + if not env_path.exists(): + return [] + + try: + with open(env_path, "rb") as f: + config = tomllib.load(f) + # Exclude special sections like 'wandb' + special_sections = {"wandb"} + return [k for k in config.keys() if k not in special_sections] + except Exception: + return [] + + +def _get_available_configs(config_dir: str | None) -> list[str]: + """Get list of available config names from a config directory. + + Args: + config_dir: Path to config directory (relative to repo root). + + Returns: + List of config names (without .yaml extension), excluding subdirectories. + """ + if not config_dir: + return [] + + config_path = Path(config_dir) + if not config_path.exists(): + return [] + + try: + configs = [] + for f in config_path.iterdir(): + if f.is_file() and f.suffix in (".yaml", ".yml"): + configs.append(f.stem) + return sorted(configs) + except Exception: + return [] + + +class RecipeCommand(TyperCommand): + """Custom TyperCommand that adds recipe-specific help panels. + + Class attributes: + artifact_overrides: Dict mapping artifact names to descriptions. + Example: {"data": "Data artifact", "model": "Model checkpoint"} + config_dir: Path to config directory (relative to repo root). + """ + + artifact_overrides: ClassVar[dict[str, str]] = {} + config_dir: ClassVar[str | None] = None + + def format_help(self, ctx, formatter): + """Format help with custom recipe options section.""" + # First, render standard Typer help + rich_utils.rich_format_help( + obj=self, + ctx=ctx, + markup_mode=self.rich_markup_mode, + ) + + # Then add our custom panels + console = rich_utils._get_rich_console() + cmd_name = ctx.info_name + + # Global options table + options_table = Table( + show_header=False, + box=box.SIMPLE, + padding=(0, 2), + pad_edge=False, + ) + options_table.add_column("Option", style="green", no_wrap=True) + options_table.add_column("Description") + options_table.add_row("-c, --config NAME", "Config name or path") + options_table.add_row("-r, --run PROFILE", "Submit to cluster (attached)") + options_table.add_row("-b, --batch PROFILE", "Submit to cluster (detached)") + options_table.add_row("-d, --dry-run", "Preview config without execution") + options_table.add_row("--stage", "Stage files for interactive debugging") + + console.print( + Panel( + options_table, + title="[bold]Global Options[/]", + title_align="left", + border_style=rich_utils.STYLE_OPTIONS_PANEL_BORDER, + ) + ) + + # Available configs (if config_dir is set) + configs = _get_available_configs(self.config_dir) + if configs: + config_list = ", ".join(f"[cyan]{c}[/]" for c in configs) + console.print( + Panel( + f"Built-in: {config_list}\n" + "[dim]Custom:[/] -c /path/to/your/config.yaml", + title="[bold]Configs[/] (-c/--config)", + title_align="left", + border_style=rich_utils.STYLE_OPTIONS_PANEL_BORDER, + ) + ) + + # Artifact overrides (if any defined for this command) + if self.artifact_overrides: + artifact_table = Table( + show_header=False, + box=box.SIMPLE, + padding=(0, 2), + pad_edge=False, + ) + artifact_table.add_column("Override", style="cyan", no_wrap=True) + artifact_table.add_column("Description") + for name, desc in self.artifact_overrides.items(): + artifact_table.add_row(f"run.{name}", desc) + + console.print( + Panel( + artifact_table, + title="[bold]Artifact Overrides[/] (W&B artifact references)", + title_align="left", + border_style=rich_utils.STYLE_OPTIONS_PANEL_BORDER, + ) + ) + + # Run overrides table + run_table = Table( + show_header=False, + box=box.SIMPLE, + padding=(0, 2), + pad_edge=False, + ) + run_table.add_column("Override", style="yellow", no_wrap=True) + run_table.add_column("Description") + run_table.add_row("run.env.nodes", "Number of nodes") + run_table.add_row("run.env.nproc_per_node", "GPUs per node") + run_table.add_row("run.env.partition", "Slurm partition") + run_table.add_row("run.env.account", "Slurm account") + run_table.add_row("run.env.time", "Job time limit (e.g., 04:00:00)") + run_table.add_row("run.env.container_image", "Override container image") + + console.print( + Panel( + run_table, + title="[bold]Run Overrides[/] (override env.toml settings)", + title_align="left", + border_style=rich_utils.STYLE_OPTIONS_PANEL_BORDER, + ) + ) + + # env.toml profiles + profiles = _get_env_profiles() + if profiles: + profile_list = ", ".join(f"[cyan]{p}[/]" for p in profiles) + console.print( + Panel( + f"Available profiles: {profile_list}\n" + "[dim]Usage:[/] --run PROFILE or --batch PROFILE", + title="[bold]env.toml Profiles[/]", + title_align="left", + border_style=rich_utils.STYLE_OPTIONS_PANEL_BORDER, + ) + ) + + console.print( + Panel( + "Override config values: [yellow]key.path=value[/]\n" + f"[dim]Example:[/] ... {cmd_name} -c tiny [yellow]train.train_iters=5000[/]", + title="[bold]Dotlist Overrides[/]", + title_align="left", + border_style=rich_utils.STYLE_OPTIONS_PANEL_BORDER, + ) + ) + + console.print( + Panel( + f"[green]$ ... {cmd_name} -c tiny[/] [dim]Local execution[/]\n" + f"[green]$ ... {cmd_name} -c tiny --dry-run[/] [dim]Preview config[/]\n" + f"[green]$ ... {cmd_name} -c tiny --run my-cluster[/] [dim]Submit to cluster[/]\n" + f"[green]$ ... {cmd_name} -c tiny -r cluster run.env.nodes=4[/]", + title="[bold]Examples[/]", + title_align="left", + border_style=rich_utils.STYLE_OPTIONS_PANEL_BORDER, + ) + ) + + +def make_recipe_command( + artifact_overrides: dict[str, str] | None = None, + config_dir: str | None = None, +): + """Factory function to create a RecipeCommand subclass with custom options. + + Args: + artifact_overrides: Dict mapping artifact names to descriptions. + Example: {"data": "Data artifact", "model": "Model checkpoint"} + config_dir: Path to config directory (relative to repo root). + + Returns: + A RecipeCommand subclass with the specified options. + """ + + class CustomRecipeCommand(RecipeCommand): + pass + + CustomRecipeCommand.artifact_overrides = artifact_overrides or {} + CustomRecipeCommand.config_dir = config_dir + return CustomRecipeCommand diff --git a/src/nemotron/cli/nano3/model/__init__.py b/src/nemotron/cli/nano3/model/__init__.py new file mode 100644 index 0000000..9205fc0 --- /dev/null +++ b/src/nemotron/cli/nano3/model/__init__.py @@ -0,0 +1,19 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Model command group for nano3.""" + +from nemotron.cli.nano3.model.app import model_app + +__all__ = ["model_app"] diff --git a/src/nemotron/cli/nano3/model/app.py b/src/nemotron/cli/nano3/model/app.py new file mode 100644 index 0000000..584567f --- /dev/null +++ b/src/nemotron/cli/nano3/model/app.py @@ -0,0 +1,35 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Model Typer group for nano3.""" + +from __future__ import annotations + +import typer + +from nemotron.cli.nano3.model.eval import eval_cmd +from nemotron.cli.nano3.model.import_ import import_app + +# Create model app +model_app = typer.Typer( + name="model", + help="Model evaluation and import commands", + no_args_is_help=True, +) + +# Register import subgroup +model_app.add_typer(import_app, name="import") + +# Register eval command +model_app.command(name="eval")(eval_cmd) diff --git a/src/nemotron/cli/nano3/model/eval.py b/src/nemotron/cli/nano3/model/eval.py new file mode 100644 index 0000000..104d306 --- /dev/null +++ b/src/nemotron/cli/nano3/model/eval.py @@ -0,0 +1,28 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Model evaluation command.""" + +from __future__ import annotations + +import typer + + +def eval_cmd() -> None: + """Evaluate model performance. + + Coming soon. + """ + typer.echo("Model evaluation coming soon.") + raise typer.Exit(0) diff --git a/src/nemotron/cli/nano3/model/import_/__init__.py b/src/nemotron/cli/nano3/model/import_/__init__.py new file mode 100644 index 0000000..8c9f927 --- /dev/null +++ b/src/nemotron/cli/nano3/model/import_/__init__.py @@ -0,0 +1,19 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Model import command group for nano3.""" + +from nemotron.cli.nano3.model.import_.app import import_app + +__all__ = ["import_app"] diff --git a/src/nemotron/cli/nano3/model/import_/app.py b/src/nemotron/cli/nano3/model/import_/app.py new file mode 100644 index 0000000..beb1794 --- /dev/null +++ b/src/nemotron/cli/nano3/model/import_/app.py @@ -0,0 +1,35 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Model import Typer group for nano3.""" + +from __future__ import annotations + +import typer + +from nemotron.cli.nano3.model.import_.pretrain import pretrain +from nemotron.cli.nano3.model.import_.rl import rl +from nemotron.cli.nano3.model.import_.sft import sft + +# Create import app +import_app = typer.Typer( + name="import", + help="Import models as W&B artifacts", + no_args_is_help=True, +) + +# Register commands +import_app.command(name="pretrain")(pretrain) +import_app.command(name="sft")(sft) +import_app.command(name="rl")(rl) diff --git a/src/nemotron/cli/nano3/model/import_/pretrain.py b/src/nemotron/cli/nano3/model/import_/pretrain.py new file mode 100644 index 0000000..191bde8 --- /dev/null +++ b/src/nemotron/cli/nano3/model/import_/pretrain.py @@ -0,0 +1,77 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Import pretrain model as W&B artifact.""" + +from __future__ import annotations + +from pathlib import Path + +import typer + +from nemotron.kit.artifact import ModelArtifact +from nemotron.kit.cli.env import get_wandb_config +from nemotron.kit.wandb import WandbConfig, init_wandb_if_configured + + +def pretrain( + model_dir: Path = typer.Argument(..., help="Path to model checkpoint directory"), + step: int | None = typer.Option(None, "--step", "-s", help="Training step"), + name: str | None = typer.Option(None, "--name", "-n", help="Custom artifact name"), + project: str | None = typer.Option( + None, "--project", "-p", help="W&B project (overrides env.toml)" + ), + entity: str | None = typer.Option( + None, "--entity", "-e", help="W&B entity (overrides env.toml)" + ), +) -> None: + """Import a pretrain model checkpoint as a W&B artifact. + + Examples: + nemotron nano3 model import pretrain /path/to/model --step 10000 + nemotron nano3 model import pretrain /path/to/model --step 10000 --project my-project + """ + # Resolve model directory + model_dir = model_dir.resolve() + if not model_dir.exists(): + typer.echo(f"Error: Model directory does not exist: {model_dir}", err=True) + raise typer.Exit(1) + + # Build W&B config from env.toml with CLI overrides + env_wandb = get_wandb_config() + wandb_project = project or (env_wandb.project if env_wandb else None) + wandb_entity = entity or (env_wandb.entity if env_wandb else None) + + if not wandb_project: + typer.echo("Error: W&B project required. Set in env.toml or use --project", err=True) + raise typer.Exit(1) + + wandb_config = WandbConfig(project=wandb_project, entity=wandb_entity) + + # Initialize W&B + init_wandb_if_configured(wandb_config, job_type="model-import", tags=["pretrain", "import"]) + + # Create artifact + artifact_name = name or "nano3/pretrain/model" + artifact = ModelArtifact( + path=model_dir, + step=step or 0, + name=artifact_name, + ) + + # Save and register with W&B + artifact.save() + + typer.echo(f"Imported pretrain model from {model_dir}") + typer.echo(f"Artifact: {artifact_name}") diff --git a/src/nemotron/cli/nano3/model/import_/rl.py b/src/nemotron/cli/nano3/model/import_/rl.py new file mode 100644 index 0000000..d871502 --- /dev/null +++ b/src/nemotron/cli/nano3/model/import_/rl.py @@ -0,0 +1,77 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Import RL model as W&B artifact.""" + +from __future__ import annotations + +from pathlib import Path + +import typer + +from nemotron.kit.artifact import ModelArtifact +from nemotron.kit.cli.env import get_wandb_config +from nemotron.kit.wandb import WandbConfig, init_wandb_if_configured + + +def rl( + model_dir: Path = typer.Argument(..., help="Path to model checkpoint directory"), + step: int | None = typer.Option(None, "--step", "-s", help="Training step"), + name: str | None = typer.Option(None, "--name", "-n", help="Custom artifact name"), + project: str | None = typer.Option( + None, "--project", "-p", help="W&B project (overrides env.toml)" + ), + entity: str | None = typer.Option( + None, "--entity", "-e", help="W&B entity (overrides env.toml)" + ), +) -> None: + """Import an RL model checkpoint as a W&B artifact. + + Examples: + nemotron nano3 model import rl /path/to/model --step 2000 + nemotron nano3 model import rl /path/to/model --step 2000 --project my-project + """ + # Resolve model directory + model_dir = model_dir.resolve() + if not model_dir.exists(): + typer.echo(f"Error: Model directory does not exist: {model_dir}", err=True) + raise typer.Exit(1) + + # Build W&B config from env.toml with CLI overrides + env_wandb = get_wandb_config() + wandb_project = project or (env_wandb.project if env_wandb else None) + wandb_entity = entity or (env_wandb.entity if env_wandb else None) + + if not wandb_project: + typer.echo("Error: W&B project required. Set in env.toml or use --project", err=True) + raise typer.Exit(1) + + wandb_config = WandbConfig(project=wandb_project, entity=wandb_entity) + + # Initialize W&B + init_wandb_if_configured(wandb_config, job_type="model-import", tags=["rl", "import"]) + + # Create artifact + artifact_name = name or "nano3/rl/model" + artifact = ModelArtifact( + path=model_dir, + step=step or 0, + name=artifact_name, + ) + + # Save and register with W&B + artifact.save() + + typer.echo(f"Imported RL model from {model_dir}") + typer.echo(f"Artifact: {artifact_name}") diff --git a/src/nemotron/cli/nano3/model/import_/sft.py b/src/nemotron/cli/nano3/model/import_/sft.py new file mode 100644 index 0000000..c131573 --- /dev/null +++ b/src/nemotron/cli/nano3/model/import_/sft.py @@ -0,0 +1,77 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Import SFT model as W&B artifact.""" + +from __future__ import annotations + +from pathlib import Path + +import typer + +from nemotron.kit.artifact import ModelArtifact +from nemotron.kit.cli.env import get_wandb_config +from nemotron.kit.wandb import WandbConfig, init_wandb_if_configured + + +def sft( + model_dir: Path = typer.Argument(..., help="Path to model checkpoint directory"), + step: int | None = typer.Option(None, "--step", "-s", help="Training step"), + name: str | None = typer.Option(None, "--name", "-n", help="Custom artifact name"), + project: str | None = typer.Option( + None, "--project", "-p", help="W&B project (overrides env.toml)" + ), + entity: str | None = typer.Option( + None, "--entity", "-e", help="W&B entity (overrides env.toml)" + ), +) -> None: + """Import an SFT model checkpoint as a W&B artifact. + + Examples: + nemotron nano3 model import sft /path/to/model --step 5000 + nemotron nano3 model import sft /path/to/model --step 5000 --project my-project + """ + # Resolve model directory + model_dir = model_dir.resolve() + if not model_dir.exists(): + typer.echo(f"Error: Model directory does not exist: {model_dir}", err=True) + raise typer.Exit(1) + + # Build W&B config from env.toml with CLI overrides + env_wandb = get_wandb_config() + wandb_project = project or (env_wandb.project if env_wandb else None) + wandb_entity = entity or (env_wandb.entity if env_wandb else None) + + if not wandb_project: + typer.echo("Error: W&B project required. Set in env.toml or use --project", err=True) + raise typer.Exit(1) + + wandb_config = WandbConfig(project=wandb_project, entity=wandb_entity) + + # Initialize W&B + init_wandb_if_configured(wandb_config, job_type="model-import", tags=["sft", "import"]) + + # Create artifact + artifact_name = name or "nano3/sft/model" + artifact = ModelArtifact( + path=model_dir, + step=step or 0, + name=artifact_name, + ) + + # Save and register with W&B + artifact.save() + + typer.echo(f"Imported SFT model from {model_dir}") + typer.echo(f"Artifact: {artifact_name}") diff --git a/src/nemotron/cli/nano3/pretrain.py b/src/nemotron/cli/nano3/pretrain.py new file mode 100644 index 0000000..4cf05e3 --- /dev/null +++ b/src/nemotron/cli/nano3/pretrain.py @@ -0,0 +1,46 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Pretrain command implementation. + +This module defines the `pretrain` command for the nano3 recipe. +""" + +from __future__ import annotations + +import typer + +from nemotron.kit.cli.recipe import recipe + +# Paths relative to repository root +SCRIPT_PATH = "src/nemotron/recipes/nano3/stage0_pretrain/train.py" +CONFIG_DIR = "src/nemotron/recipes/nano3/stage0_pretrain/config" + + +@recipe( + name="nano3/pretrain", + script_path=SCRIPT_PATH, + config_dir=CONFIG_DIR, + default_config="default", + packager="self_contained", + artifacts={ + "data": { + "default": "PretrainBlendsArtifact-default", + "mappings": {"path": "recipe.per_split_data_args_path"}, + }, + }, +) +def pretrain(ctx: typer.Context) -> None: + """Run pretraining with Megatron-Bridge (stage0).""" + ... diff --git a/src/nemotron/cli/nano3/rl.py b/src/nemotron/cli/nano3/rl.py new file mode 100644 index 0000000..7ac3e1e --- /dev/null +++ b/src/nemotron/cli/nano3/rl.py @@ -0,0 +1,46 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""RL command implementation. + +This module defines the `rl` command for the nano3 recipe. +""" + +from __future__ import annotations + +import typer + +from nemotron.kit.cli.recipe import recipe + +# Paths relative to repository root +SCRIPT_PATH = "src/nemotron/recipes/nano3/stage2_rl/train.py" +CONFIG_DIR = "src/nemotron/recipes/nano3/stage2_rl/config" + + +@recipe( + name="nano3/rl", + script_path=SCRIPT_PATH, + config_dir=CONFIG_DIR, + default_config="tiny", + torchrun=False, + ray=True, + packager="self_contained", + workdir=None, # Don't auto-prepend cd; we handle it in run_command + pre_ray_start_commands=[], + # Files are in cwd ($CLUSTER_DIR/code), copy to /opt/nemo-rl then run with uv + run_command="cp ./main.py /opt/nemo-rl/ && cp ./config.yaml /opt/nemo-rl/ && cd /opt/nemo-rl && uv run python {script} --config {config}", +) +def rl(ctx: typer.Context) -> None: + """Run reinforcement learning with NeMo-RL GRPO (stage2).""" + ... diff --git a/src/nemotron/cli/nano3/sft.py b/src/nemotron/cli/nano3/sft.py new file mode 100644 index 0000000..3180053 --- /dev/null +++ b/src/nemotron/cli/nano3/sft.py @@ -0,0 +1,40 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""SFT command implementation. + +This module defines the `sft` command for the nano3 recipe. +""" + +from __future__ import annotations + +import typer + +from nemotron.kit.cli.recipe import recipe + +# Paths relative to repository root +SCRIPT_PATH = "src/nemotron/recipes/nano3/stage1_sft/train.py" +CONFIG_DIR = "src/nemotron/recipes/nano3/stage1_sft/config" + + +@recipe( + name="nano3/sft", + script_path=SCRIPT_PATH, + config_dir=CONFIG_DIR, + default_config="default", + packager="self_contained", +) +def sft(ctx: typer.Context) -> None: + """Run supervised fine-tuning with Megatron-Bridge (stage1).""" + ... diff --git a/src/nemotron/data_prep/README.md b/src/nemotron/data_prep/README.md new file mode 100644 index 0000000..36bc80d --- /dev/null +++ b/src/nemotron/data_prep/README.md @@ -0,0 +1,175 @@ +# nemotron.data_prep + +Distributed data preparation for LLM training, built on Ray. + +## Overview + +This module processes raw text data from HuggingFace, S3, or local sources into +training formats for Megatron-Bridge and Megatron-Core: + +- **bin/idx** - Tokenized indexed datasets for pretraining +- **JSONL** - Structured records for SFT/RL (with optional transforms) +- **Packed .npy** - Packed sequences for efficient SFT training +- **Chat SFT** - Packed sequences with role-based loss masking + +## Architecture + +```mermaid +flowchart TB + subgraph api["User Entry Points"] + high["run_data_prep(DataPrepConfig)
High-Level API"] + low["last_mile_process(...)
Low-Level API"] + end + + subgraph orchestration["Pipeline Orchestration"] + pipeline["pipeline.py"] + end + + subgraph processors["Ray Actor Pool (Processors)"] + shard["ShardProc.
(bin/idx)"] + jsonl["JsonlProc.
(jsonl)"] + packed["PackedProc.
(.npy)"] + chat["ChatSftProc.
(.npy + loss)"] + end + + high --> pipeline + low --> pipeline + pipeline --> shard + pipeline --> jsonl + pipeline --> packed + pipeline --> chat +``` + +## Module Structure + +``` +src/nemotron/data_prep/ +├── __init__.py # Public API exports +├── __main__.py # CLI entry point +├── cli.py # CLI commands (run, status, verify) +├── config.py # Configuration dataclasses +├── pipeline.py # Pipeline orchestration +├── planning.py # Shard planning & assignment +├── discovery.py # Dataset metadata fetching +├── providers.py # Tokenizer factories +├── blend.py # DataBlend specification +├── formats/ +│ ├── transforms.py # Transform factories (sft, openai_chat, etc.) +│ ├── indexed_dataset.py# bin/idx writer +│ └── jsonl_dataset.py # JSONL writer +├── shard_processor.py # bin/idx Ray actor +├── jsonl_processor.py # JSONL Ray actor +├── packed_processor.py # Packed .npy Ray actor +├── chat_sft_processor.py # Chat SFT Ray actor +├── chat_template.py # Chat templating utilities +├── filesystem.py # Cloud-native file I/O (fsspec) +└── console.py # Rich terminal UI +``` + +## Quick Start + +### High-Level API (Tokenization) + +For simple tokenization to bin/idx format: + +```python +from nemotron.data_prep import DataPrepConfig, run_data_prep +from pathlib import Path + +config = DataPrepConfig( + blend_path=Path("data_blend.json"), + output_dir=Path("./output"), + tokenizer_model="nvidia/NVIDIA-Nemotron-Nano-9B-v2", +) +artifact = run_data_prep(config) +``` + +### Low-Level API (Custom Formats) + +For more control over output format: + +```python +from nemotron.data_prep import last_mile_process, DataBlend, PipelineConfig +from nemotron.data_prep.config import OutputConfig, JsonlOutputConfig +from nemotron.data_prep.formats.transforms import sft + +blend = DataBlend.load("data_blend.json") +config = PipelineConfig( + output=OutputConfig( + dir=Path("./sft_data"), + format=JsonlOutputConfig( + transform=sft(input="instruction", output="response"), + ), + ), +) +result = last_mile_process(blend, config) +``` + +## CLI Usage + +```bash +# Run tokenization +python -m nemotron.data_prep run config.yaml ./output + +# Check pipeline status +python -m nemotron.data_prep status ./output + +# Verify output integrity +python -m nemotron.data_prep verify ./output +``` + +## Output Formats + +| Format | Config Class | Output | Use Case | +|--------|--------------|--------|----------| +| bin/idx | `BinIdxOutputConfig` | `.bin/.idx` pairs | Pretraining | +| JSONL | `JsonlOutputConfig` | `.jsonl` files | SFT/RL with transforms | +| Packed | `PackedOutputConfig` | `.npy` files | Efficient SFT | +| Chat SFT | `ChatSftOutputConfig` | `.npy` + loss masks | SFT with chat templates | + +## Built-in Transforms + +For JSONL output, use transforms to convert input records: + +```python +from nemotron.data_prep.formats.transforms import ( + sft, # SFT format: {input, output} + openai_chat, # OpenAI format: {messages: [...]} + sharegpt, # ShareGPT format: {conversations: [...]} + nemotron_rl, # RL format for Nemotron training + passthrough, # Pass records unchanged + select, # Select specific fields + rename, # Rename fields +) +``` + +## Full Documentation + +See [docs/train/data-prep.md](../../../docs/train/data-prep.md) for complete API reference including: + +- All configuration options +- Transform factory details +- Sharding configuration +- Per-split output +- Compression options +- Type definitions + +## Key Design Principles + +1. **Ray-based parallelism** - Distributed processing via long-lived actors +2. **Deterministic output** - Frozen shard plans ensure reproducibility +3. **Cloud-native** - fsspec for S3/GCS/local file handling +4. **Resumable** - Skip completed shards on restart +5. **Artifact tracking** - W&B integration for lineage + +## Usage in Nano3 Recipes + +Each training stage uses data_prep differently: + +| Stage | API | Output Format | Config | +|-------|-----|---------------|--------| +| Stage 0 (Pretrain) | `run_data_prep()` | bin/idx | `PerSplitConfig` | +| Stage 1 (SFT) | `last_mile_process()` | Chat SFT .npy | `ChatSftOutputConfig` | +| Stage 2 (RL) | `last_mile_process()` | JSONL | `JsonlOutputConfig` | + +See the stage-specific `data_prep.py` files for implementation examples. diff --git a/src/nemotron/data_prep/__init__.py b/src/nemotron/data_prep/__init__.py new file mode 100644 index 0000000..ae22c5f --- /dev/null +++ b/src/nemotron/data_prep/__init__.py @@ -0,0 +1,440 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Data preparation for Megatron training. + +Processes raw text data from HuggingFace, S3, or local sources into +various training formats compatible with Megatron-Bridge and Megatron-Core. + +Supported output formats: +- **binidx**: Tokenized .bin/.idx files (default, for pretraining) +- **jsonl**: JSONL files with optional transforms (for SFT/RL, no tokenization) +- **packed**: Packed sequences in .npy format (for efficient SFT training) + +Quick Start: + from nemotron.data_prep import DataPrepConfig, run_data_prep + from pathlib import Path + + # Create config + config = DataPrepConfig( + blend_path=Path("data_blend.json"), + output_dir=Path("./output"), + tokenizer_model="nvidia/NVIDIA-Nemotron-Nano-9B-v2", + ) + + # Run data preparation + artifact = run_data_prep(config) + + # Use output with Megatron-Bridge + print(f"Blend path: {artifact.path}") + +Low-Level API (last_mile_process): + from nemotron.data_prep import last_mile_process, DataBlend, PipelineConfig + from nemotron.data_prep.config import OutputConfig, JsonlOutputConfig + from nemotron.data_prep.formats.transforms import sft + + blend = DataBlend.load("data_blend.json") + + # JSONL output for SFT + config = PipelineConfig( + output=OutputConfig( + dir=Path("./sft_data"), + format=JsonlOutputConfig(transform=sft(input="instruction", output="response")), + ), + ) + result = last_mile_process(blend, config) + +Output Format: + The generated blend.json is directly compatible with Megatron-Bridge's + get_blend_fields_from_data_paths() function. +""" + +import os +from dataclasses import dataclass, field +from pathlib import Path + +from nemotron.data_prep.blend import DataBlend, Dataset +from nemotron.data_prep.config import ( + BinIdxOutputConfig, + ChatSftOutputConfig, + JsonlOutputConfig, + OutputConfig, + PackedOutputConfig, + PerSplitConfig, + PipelineConfig, + TokenizerConfig, + Transform, +) +from nemotron.data_prep.discovery import get_dataset_metadata +from nemotron.data_prep.formats.transforms import ( + OpenAIChatRecord, + SftRecord, + ShareGPTRecord, + openai_chat, + passthrough, + rename, + select, + sft, + sharegpt, +) +from nemotron.data_prep.pipeline import ( + PipelineResult, + SplitResult, + last_mile_process, + tokenize, +) +from nemotron.kit.artifact import DataBlendsArtifact, PretrainBlendsArtifact +from nemotron.kit.trackers import InputDatasetInfo, tokenizer_to_uri +from nemotron.kit.wandb import finish_wandb + + +@dataclass +class DataPrepConfig: + """Configuration for data preparation. + + Generic configuration that can be customized per-recipe. + + Example: + >>> from nemotron.data_prep import DataPrepConfig, run_data_prep + >>> config = DataPrepConfig( + ... blend_path=Path("data_blend.json"), + ... output_dir=Path("./output"), + ... tokenizer_model="meta-llama/Llama-3.2-1B", + ... ) + >>> artifact = run_data_prep(config) + """ + + # Data source + blend_path: Path = field(default_factory=lambda: Path("data_blend.json")) + """Path to data blend JSON file""" + + # Output + output_dir: Path = field(default_factory=lambda: Path("./output")) + """Output directory for tokenized data""" + + num_shards: int = 128 + """Number of output shards for parallel loading""" + + split: str | None = None + """Deprecated: Train:valid:test ratio (e.g., '99990,8,2'). Use per_split instead.""" + + per_split: PerSplitConfig | None = field(default_factory=PerSplitConfig) + """Per-split output config. Produces {"train": [...], "valid": [...], "test": [...]} JSON + compatible with Megatron-Bridge's per_split_data_args_path parameter. + Set to None to use legacy split ratio mode.""" + + # Tokenizer + tokenizer_model: str = "nvidia/NVIDIA-Nemotron-Nano-9B-v2" + """HuggingFace tokenizer model name""" + + add_bos: bool = False + """Prepend BOS token to documents""" + + add_eos: bool = True + """Append EOS token to documents""" + + # Processing + text_field: str = "text" + """Default text field name in datasets""" + + min_doc_chars: int | None = None + """Skip documents shorter than this""" + + max_doc_tokens: int | None = None + """Truncate documents longer than this""" + + # Execution + sample: int | None = None + """Limit rows per dataset (for quick tests)""" + + force: bool = False + """Force new run, ignoring cache""" + + artifact_name: str | None = None + """Semantic artifact name (e.g., 'nano3/pretrain/data')""" + + # Ray Data execution + ray_data_enabled: bool = True + """Enable Ray Data executor for shard processing. + Uses Ray Data's ActorPoolStrategy for automatic actor lifecycle + management, resource accounting, and bottleneck metrics in W&B.""" + + ray_data_min_actors: int = 2 + """Minimum actors for Ray Data executor (warm pool)""" + + ray_data_max_actors: int | None = None + """Maximum actors for Ray Data executor (None = use all available CPUs)""" + + ray_data_cpus_per_actor: float = 1.0 + """CPUs per actor for Ray Data executor""" + + ray_data_max_tasks_in_flight: int = 2 + """Max tasks in flight per actor (pipelining depth)""" + + +def run_data_prep( + config: DataPrepConfig, *, artifact_class: type = PretrainBlendsArtifact +) -> DataBlendsArtifact | PretrainBlendsArtifact: + """Execute data preparation pipeline. + + Loads the data blend, tokenizes all datasets, and produces a + Megatron-Bridge compatible blend.json. + + Args: + config: Data preparation configuration + artifact_class: Artifact class to use for output (default: PretrainDataArtifact) + + Returns: + Artifact instance with blend.json path and metrics + + Example: + >>> from nemotron.data_prep import DataPrepConfig, run_data_prep + >>> config = DataPrepConfig( + ... blend_path=Path("data_blend.json"), + ... output_dir=Path("./output"), + ... ) + >>> artifact = run_data_prep(config) + >>> print(f"Blend path: {artifact.path}") + """ + # Load data blend specification + blend = DataBlend.load(config.blend_path) + + # Apply default text_field to datasets that use default + for split_datasets in blend.splits.values(): + for dataset in split_datasets: + if dataset.text_field == "text" and config.text_field != "text": + # Use object.__setattr__ since Dataset is a Pydantic model + object.__setattr__(dataset, "text_field", config.text_field) + + # Build pipeline config + # When sampling, use 1 shard to get exactly `sample` rows per dataset + num_shards = config.num_shards + if config.sample is not None: + num_shards = 1 + + # Build output config with format that has num_shards + # When num_shards is specified, clear shard_size to avoid conflict + output_format = BinIdxOutputConfig( + num_shards=num_shards, + shard_size=None if num_shards is not None else "256MB", + ) + + # Resolve output_dir to absolute path for W&B artifact storage + output_dir = config.output_dir.resolve() if hasattr(config.output_dir, 'resolve') else Path(config.output_dir).resolve() + + # Initialize Ray early so we can query cluster resources + import ray + + if not ray.is_initialized(): + runtime_env = { + "excludes": [ + "output/", + "outputs/", + "wandb/", + "data/", + "checkpoints/", + "*.bin", + "*.idx", + "*.npy", + "__pycache__/", + ".git/", + ".venv/", + "*.egg-info/", + ] + } + ray.init(address="auto", ignore_reinit_error=True, runtime_env=runtime_env) + + # Build Ray Data config if enabled, auto-detecting cluster resources + ray_data_config = None + if config.ray_data_enabled: + from nemotron.data_prep.config import RayDataConfig + + # Auto-detect available CPUs from Ray cluster + # Fallback chain: Ray cluster -> SLURM env var -> os.cpu_count() + cluster_resources = ray.cluster_resources() + ray_cpus = cluster_resources.get("CPU", 0) + slurm_cpus = int(os.environ.get("SLURM_CPUS_PER_TASK", 0)) + os_cpus = os.cpu_count() or 4 + + # Use the highest available CPU count (Ray may report fewer due to config issues) + available_cpus = max(int(ray_cpus), slurm_cpus, os_cpus) + + # Use most of available CPUs for actors (leave some headroom) + # min_actors = start with good parallelism + # max_actors = allow scaling up to use all CPUs + cpus_per_actor = config.ray_data_cpus_per_actor + auto_max_actors = int(available_cpus * 0.9 / cpus_per_actor) # Use 90% of CPUs + if config.ray_data_max_actors is not None: + max_actors = min(config.ray_data_max_actors, auto_max_actors) + else: + max_actors = auto_max_actors + min_actors = min(config.ray_data_min_actors, max_actors) + + # Log resource detection for debugging + print(f"Ray cluster resources: {cluster_resources}") + print(f"CPU detection: Ray={ray_cpus}, SLURM={slurm_cpus}, os={os_cpus} -> using {available_cpus}") + print(f"Ray Data config: min_actors={min_actors}, max_actors={max_actors}") + + # Log W&B status for debugging + try: + import wandb + if wandb.run is not None: + print(f"[W&B] Active run: {wandb.run.name} (id={wandb.run.id})") + else: + print("[W&B] No active run - metrics will not be logged") + except ImportError: + print("[W&B] wandb not installed") + + ray_data_config = RayDataConfig( + enabled=True, + min_actors=min_actors, + max_actors=max_actors, + cpus_per_actor=cpus_per_actor, + max_tasks_in_flight_per_actor=config.ray_data_max_tasks_in_flight, + ) + + pipeline_config = PipelineConfig( + output=OutputConfig( + dir=output_dir, + format=output_format, + min_doc_chars=config.min_doc_chars, + max_doc_tokens=config.max_doc_tokens, + max_rows=config.sample, + ), + tokenizer=TokenizerConfig( + model=config.tokenizer_model, + add_bos=config.add_bos, + add_eos=config.add_eos, + ), + force=config.force, + split=config.split, + per_split=config.per_split, + ray_data=ray_data_config, + ) + + # Run processing pipeline + result = last_mile_process(blend, pipeline_config) + + # Collect source datasets with metadata for lineage tracking + source_datasets: list[InputDatasetInfo] = [] + seen_keys: set[str] = set() + for split_datasets in blend.splits.values(): + for dataset in split_datasets: + # Use path+subset as key since same path can have different subsets + key = f"{dataset.path}|{dataset.subset or ''}" + if key not in seen_keys: + seen_keys.add(key) + # Build dataset config for metadata fetching + from nemotron.data_prep.config import DatasetConfig + + ds_config = DatasetConfig( + name=dataset.name, + path=dataset.path, + split=dataset.split, + subset=dataset.subset, + text_field=dataset.text_field, + ) + hf_metadata = get_dataset_metadata(ds_config) + source_datasets.append( + InputDatasetInfo( + uri=dataset.path, + name=dataset.name, + weight=dataset.weight, + split=dataset.split, + subset=dataset.subset, + text_field=dataset.text_field, + num_rows=hf_metadata.num_rows, + size_bytes=hf_metadata.size_bytes, + ) + ) + + # Create tokenizer URI for lineage tracking + tok_uri = tokenizer_to_uri(config.tokenizer_model) + + # Build output artifact - path points to output directory, blend_path to blend.json + blend_json_path = result.output_dir / "blend.json" + artifact = artifact_class( + path=result.output_dir, + blend_path=str(blend_json_path), + total_tokens=result.total_tokens, + total_sequences=result.total_sequences, + elapsed_sec=result.elapsed_sec, + num_shards=num_shards, + source_datasets=source_datasets, + tokenizer_uri=tok_uri, + name=config.artifact_name, # Semantic name for W&B artifact naming + ) + artifact.save() + + # Mark wandb run as successful (before Ray shutdown to avoid socket noise) + finish_wandb(exit_code=0) + + # Gracefully shutdown Ray - suppress stderr during cleanup + try: + import ray + + if ray.is_initialized(): + import io + import sys + + # Temporarily suppress stderr during Ray shutdown (socket cleanup noise) + old_stderr = sys.stderr + sys.stderr = io.StringIO() + try: + ray.shutdown() + finally: + sys.stderr = old_stderr + except Exception: + pass + + return artifact + + +__all__ = [ + # Input specification + "DataBlend", + "Dataset", + # High-level API + "DataPrepConfig", + "run_data_prep", + "DataBlendsArtifact", + # Low-level configuration + "PipelineConfig", + "PerSplitConfig", + "TokenizerConfig", + "OutputConfig", + # Output format configs + "BinIdxOutputConfig", + "JsonlOutputConfig", + "PackedOutputConfig", + "ChatSftOutputConfig", + "Transform", + # Transform factories + "sft", + "openai_chat", + "sharegpt", + "passthrough", + "select", + "rename", + # Transform type definitions + "SftRecord", + "OpenAIChatRecord", + "ShareGPTRecord", + # Execution + "last_mile_process", + "tokenize", # Deprecated alias + # Results + "PipelineResult", + "SplitResult", +] diff --git a/src/nemotron/data_prep/blend.py b/src/nemotron/data_prep/blend.py new file mode 100644 index 0000000..8781bb8 --- /dev/null +++ b/src/nemotron/data_prep/blend.py @@ -0,0 +1,132 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Data blend specification - pure data manifest.""" + +from __future__ import annotations + +import json +from pathlib import Path + +from pydantic import BaseModel, model_validator + + +class Dataset(BaseModel): + """Single dataset entry in a blend. + + Attributes: + name: Unique identifier for this dataset + path: Data location (hf://repo/name, s3://bucket/prefix, /local/path) + weight: Relative weight in the blend (default: 1.0) + split: HuggingFace split name (required for hf:// paths) + subset: HuggingFace config/subset name + text_field: Field containing text to tokenize (default: "text") + """ + + name: str + path: str + weight: float = 1.0 + split: str | None = None + subset: str | None = None + text_field: str = "text" + + +class DataBlend(BaseModel): + """Data blend specification. + + Supports two modes: + + 1. Single blend mode: + {"datasets": [...]} + Megatron-Bridge splits by ratio at training time. + + 2. Per-split mode: + {"train": [...], "valid": [...], "test": [...]} + Separate tokenized outputs for each split. + + Examples: + # Single blend + blend = DataBlend(datasets=[ + Dataset(name="pile", path="hf://EleutherAI/pile", split="train"), + ]) + + # Per-split + blend = DataBlend( + train=[Dataset(name="train", path="hf://...", split="train")], + valid=[Dataset(name="valid", path="hf://...", split="validation")], + ) + + # From file + blend = DataBlend.load("data_blend.json") + """ + + # Single blend mode + datasets: list[Dataset] | None = None + + # Per-split mode + train: list[Dataset] | None = None + valid: list[Dataset] | None = None + test: list[Dataset] | None = None + + @model_validator(mode="after") + def check_mode(self) -> DataBlend: + """Validate exactly one mode is specified.""" + has_single = self.datasets is not None + has_splits = any([self.train, self.valid, self.test]) + + if has_single and has_splits: + raise ValueError( + "Cannot mix 'datasets' with 'train'/'valid'/'test'. " + "Use either single blend mode or per-split mode." + ) + if not has_single and not has_splits: + raise ValueError( + "Must specify either 'datasets' or at least one of 'train'/'valid'/'test'." + ) + return self + + @property + def is_per_split(self) -> bool: + """True if using per-split mode.""" + return self.datasets is None + + @property + def splits(self) -> dict[str, list[Dataset]]: + """Return datasets grouped by split name. + + For single blend mode, returns {"all": datasets}. + For per-split mode, returns {"train": [...], "valid": [...], ...}. + """ + if not self.is_per_split: + return {"all": self.datasets} + return { + k: v + for k, v in [ + ("train", self.train), + ("valid", self.valid), + ("test", self.test), + ] + if v is not None + } + + @classmethod + def load(cls, path: str | Path) -> DataBlend: + """Load blend specification from JSON file.""" + with open(path) as f: + return cls.model_validate(json.load(f)) + + @classmethod + def from_datasets(cls, *datasets: Dataset) -> DataBlend: + """Create single-blend from dataset list.""" + return cls(datasets=list(datasets)) diff --git a/src/nemotron/data_prep/chat_sft_processor.py b/src/nemotron/data_prep/chat_sft_processor.py new file mode 100644 index 0000000..40f234a --- /dev/null +++ b/src/nemotron/data_prep/chat_sft_processor.py @@ -0,0 +1,497 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""ChatSftShardProcessor Ray actor for parallel chat-templated SFT output processing. + +Applies chat templates to OpenAI-format messages, tokenizes with role-based +loss masking, and outputs packed .npy files compatible with GPTSFTPackedDataset. + +Pipeline: +1. Apply materialize.py chat template logic -> role-labeled chunks +2. Tokenize chunks -> input_ids +3. Build loss_mask based on role (0=system/user, 1=assistant) +4. Pack sequences -> .npy output +""" + +from __future__ import annotations + +import json +import logging +import time +from collections.abc import Iterator +from pathlib import Path + +import numpy as np +import pyarrow.parquet as pq +import ray +from fsspec import filesystem + +from nemotron.data_prep.chat_template import ( + create_masked_messages, + replace_json_args, + split_system_user_chunks, + validate_conversation, +) +from nemotron.data_prep.config import FileInfo +from nemotron.data_prep.filesystem import ensure_dir, write_json +from nemotron.data_prep.packing.builder import PackedSequenceBuilder + +logger = logging.getLogger(__name__) + + +@ray.remote +class ChatSftShardProcessor: + """Ray actor for chat-templated SFT output with loss masking. + + Reads input files with OpenAI-format messages, applies chat templates + to generate loss-masked sequences, packs them, and writes to .npy files + compatible with Megatron-Bridge's GPTSFTPackedDataset. + """ + + def __init__( + self, + resolved_tokenizer: dict, + messages_field: str, + tools_field: str, + pack_size: int, + algorithm: str, + dtype: str, + chat_template: str | None = None, + max_doc_tokens: int | None = None, + max_rows: int | None = None, + seed: int | None = None, + used_in_filter: str | None = None, + used_in_field: str = "used_in", + ): + """Initialize chat SFT processor. + + Args: + resolved_tokenizer: Tokenizer configuration dict with resolved SHA. + messages_field: Field name for messages in input records. + tools_field: Field name for tools in input records. + pack_size: Maximum tokens per packed sequence. + algorithm: Packing algorithm. + dtype: Token dtype for output. + chat_template: "nano3", path to .jinja file, or inline template string. + max_doc_tokens: Truncate sequences longer than this. + max_rows: Maximum rows to process per shard. + seed: Random seed for shuffle-based algorithms. + used_in_filter: Filter to only include records where used_in contains this value. + used_in_field: Field name for used_in filtering (default: "used_in"). + """ + from transformers import AutoTokenizer + + self.messages_field = messages_field + self.tools_field = tools_field + self.pack_size = pack_size + self.algorithm = algorithm + self.dtype = np.dtype(dtype) + self.max_doc_tokens = max_doc_tokens + self.max_rows = max_rows + self.seed = seed + self.used_in_filter = used_in_filter + self.used_in_field = used_in_field + + # Load HuggingFace tokenizer with full chat template support + self._tokenizer = AutoTokenizer.from_pretrained( + resolved_tokenizer["model"], + revision=resolved_tokenizer.get("resolved_revision"), + trust_remote_code=resolved_tokenizer.get("trust_remote_code", False), + ) + + # Load chat template + if chat_template: + if chat_template == "nano3": + # Load bundled template + template_path = Path(__file__).parent / "templates" / "nano3.jinja" + with open(template_path) as f: + self._tokenizer.chat_template = f.read() + elif Path(chat_template).exists(): + # Load from file path + with open(chat_template) as f: + self._tokenizer.chat_template = f.read() + else: + # Assume inline template string + self._tokenizer.chat_template = chat_template + + def process_shard( + self, + shard_index: int, + files: list[dict], # FileInfo as dicts for Ray serialization + output_dir: str, + receipts_dir: str, + fs_protocol: str, + ) -> dict: + """Process files to a single packed shard with loss masks. + + Args: + shard_index: Index of this shard. + files: List of FileInfo dicts to process. + output_dir: Output directory for .npy files. + receipts_dir: Directory for receipt files. + fs_protocol: Filesystem protocol (e.g., "file", "s3"). + + Returns: + Shard statistics dict. + """ + fs = filesystem(fs_protocol) + + shard_id = f"shard_{shard_index:06d}" + npy_path = f"{output_dir}/{shard_id}.npy" + receipt_path = f"{receipts_dir}/{shard_id}.json" + + # Ensure directories + ensure_dir(fs, output_dir) + ensure_dir(fs, receipts_dir) + + # Stats tracking + stats = { + "num_input_rows": 0, + "num_output_sequences": 0, + "num_filtered": 0, + "num_validation_errors": 0, + "num_truncated": 0, + "num_errors": 0, + } + + # Convert file dicts back to FileInfo + file_infos = [FileInfo(**f) for f in files] + input_file_paths = [f.path for f in file_infos] + + # Handle empty assignment + if not file_infos: + return self._write_empty_receipt( + shard_id, + shard_index, + input_file_paths, + stats, + receipt_path, + fs, + ) + + # Create packing builder + builder = PackedSequenceBuilder( + pack_size=self.pack_size, + algorithm=self.algorithm, + seed=self.seed, + dtype=str(self.dtype), + ) + + # Track rows processed across files for max_rows limit + rows_processed = 0 + + # Process files SEQUENTIALLY for determinism + for file_info in file_infos: + rows_processed = self._process_file(file_info, builder, stats, fs, rows_processed) + # Stop if we've hit max_rows + if self.max_rows and rows_processed >= self.max_rows: + break + + # Finalize packing + packed_data, packing_metadata = builder.finalize() + + # Handle empty result (all rows filtered) + if not packed_data: + return self._write_empty_receipt( + shard_id, + shard_index, + input_file_paths, + stats, + receipt_path, + fs, + ) + + # Save packed data as .npy + with fs.open(npy_path, "wb") as f: + np.save(f, packed_data, allow_pickle=True) + + # Get file size + npy_bytes = fs.size(npy_path) + + # Write receipt (commits the shard) + receipt = { + "shard_id": shard_id, + "shard_index": shard_index, + "status": "completed", + "created_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()), + "input_files": input_file_paths, + "output_file": f"{shard_id}.npy", + "npy_bytes": npy_bytes, + "packing": packing_metadata, + "stats": { + "num_sequences": packing_metadata["num_sequences"], + "num_packed_sequences": packing_metadata["num_packed_sequences"], + "total_tokens": packing_metadata["total_tokens"], + **stats, + }, + } + + write_json(fs, receipt_path, receipt) + return receipt["stats"] + + def _process_file( + self, + file_info: FileInfo, + builder: PackedSequenceBuilder, + stats: dict, + fs, + rows_processed: int = 0, + ) -> int: + """Process a single file, adding sequences to builder. + + Returns the total number of rows processed (for max_rows tracking). + """ + # Resolve file path - handle HF deferred download + local_path = self._resolve_file_path(file_info) + + # Determine file type and iterate records + is_parquet = local_path.endswith(".parquet") or not ( + local_path.endswith(".jsonl") or local_path.endswith(".json") + ) + + if is_parquet: + record_iter = self._iter_parquet_records(local_path, fs) + else: + record_iter = self._iter_jsonl_records(local_path, fs) + + for record in record_iter: + # Check max_rows limit + if self.max_rows and rows_processed >= self.max_rows: + break + + stats["num_input_rows"] += 1 + rows_processed += 1 + + self._process_record(record, builder, stats) + + return rows_processed + + def _process_record( + self, + record: dict, + builder: PackedSequenceBuilder, + stats: dict, + ) -> None: + """Process a single record using materialize.py logic.""" + # Apply used_in filter if configured + if self.used_in_filter: + used_in = record.get(self.used_in_field) + if not self._matches_used_in_filter(used_in): + stats["num_filtered"] += 1 + return + + messages = record.get(self.messages_field) + tools = record.get(self.tools_field) + + # Skip if no messages + if not messages: + stats["num_filtered"] += 1 + return + + # Step 1: Validate (materialize_fast.py checks) + is_valid, error = validate_conversation(messages, tools) + if not is_valid: + stats["num_filtered"] += 1 + stats["num_validation_errors"] += 1 + return + + # Step 2: Pre-process (materialize.py) + try: + messages = replace_json_args(messages) + except (json.JSONDecodeError, KeyError, TypeError) as e: + stats["num_filtered"] += 1 + stats["num_errors"] += 1 + logger.debug(f"Error in replace_json_args: {e}") + return + + # Step 3: Apply chat template, get role-labeled chunks (materialize.py) + try: + masked_results = create_masked_messages(messages, self._tokenizer, tools) + except Exception as e: + stats["num_filtered"] += 1 + stats["num_errors"] += 1 + logger.debug(f"Error in create_masked_messages: {e}") + return + + # Step 4: For each output sequence (may be multiple due to multi-turn splitting) + for chunks, _ in masked_results: + # Post-process: split system/user (materialize_fast.py) + processed_chunks = split_system_user_chunks(chunks) + + # Step 5: Tokenize and build loss_mask + try: + input_ids, loss_mask = self._tokenize_chunks_with_mask(processed_chunks) + except Exception as e: + stats["num_errors"] += 1 + logger.debug(f"Error tokenizing chunks: {e}") + continue + + # Skip empty sequences + if not input_ids: + continue + + # Truncate if needed + if self.max_doc_tokens and len(input_ids) > self.max_doc_tokens: + input_ids = input_ids[: self.max_doc_tokens] + loss_mask = loss_mask[: self.max_doc_tokens] + stats["num_truncated"] += 1 + + # Step 6: Add to packer + builder.add_sequence(input_ids, loss_mask=loss_mask) + stats["num_output_sequences"] += 1 + + def _tokenize_chunks_with_mask(self, chunks: list[dict]) -> tuple[list[int], list[int]]: + """Tokenize chunks and generate loss_mask based on role. + + Loss mask: 0 for system/user chunks, 1 for assistant chunks. + + Args: + chunks: List of chunks with 'role' and 'content' fields. + + Returns: + Tuple of (input_ids, loss_mask). + """ + all_input_ids: list[int] = [] + all_loss_mask: list[int] = [] + + for chunk in chunks: + # Tokenize the pre-rendered content (no special tokens - already in template) + tokens = self._tokenizer.encode(chunk["content"], add_special_tokens=False) + + # Build mask based on role: assistant = 1, others = 0 + mask_value = 1 if chunk["role"] == "assistant" else 0 + mask = [mask_value] * len(tokens) + + all_input_ids.extend(tokens) + all_loss_mask.extend(mask) + + return all_input_ids, all_loss_mask + + def _resolve_file_path(self, file_info: FileInfo) -> str: + """Resolve file to a local path, downloading from HF if needed.""" + if file_info.hf_repo_id is not None: + from huggingface_hub import hf_hub_download + + local_path = hf_hub_download( + repo_id=file_info.hf_repo_id, + filename=file_info.hf_filename, + revision=file_info.hf_revision, + repo_type="dataset", + local_files_only=False, + ) + return local_path + + return file_info.local_path or file_info.path + + def _iter_parquet_records(self, path: str, fs) -> Iterator[dict]: + """Iterate records from parquet file.""" + if self._is_remote_path(path): + with fs.open(path, "rb") as f: + parquet_file = pq.ParquetFile(f) + yield from self._iter_parquet_batches_as_dicts(parquet_file) + else: + parquet_file = pq.ParquetFile(path) + yield from self._iter_parquet_batches_as_dicts(parquet_file) + + def _iter_parquet_batches_as_dicts(self, parquet_file: pq.ParquetFile) -> Iterator[dict]: + """Iterate batches from parquet file as dicts.""" + for batch in parquet_file.iter_batches(batch_size=1000): + table = batch.to_pydict() + # Transpose from column-oriented to row-oriented + keys = list(table.keys()) + num_rows = len(table[keys[0]]) if keys else 0 + for i in range(num_rows): + yield {k: table[k][i] for k in keys} + + def _iter_jsonl_records(self, path: str, fs) -> Iterator[dict]: + """Iterate records from JSONL file.""" + if self._is_remote_path(path): + with fs.open(path, "r") as f: + for line in f: + if line.strip(): + yield json.loads(line) + else: + with open(path) as f: + for line in f: + if line.strip(): + yield json.loads(line) + + def _is_remote_path(self, path: str) -> bool: + """Check if path is a remote path (S3/GCS/etc).""" + return path.startswith(("s3://", "gs://", "gcs://", "az://", "abfs://")) + + def _matches_used_in_filter(self, used_in: str | list | None) -> bool: + """Check if record's used_in field matches the filter. + + Args: + used_in: Value of the used_in field (can be string, list, or None). + + Returns: + True if the filter matches, False otherwise. + """ + if used_in is None: + return False + + # Handle list format (e.g., ["nano_v3", "prod_v1"]) + if isinstance(used_in, list): + return self.used_in_filter in used_in + + # Handle string format (e.g., "nano_v3" or "nano_v3,prod_v1") + if isinstance(used_in, str): + # Check for exact match first + if used_in == self.used_in_filter: + return True + # Check comma-separated values + values = [v.strip() for v in used_in.split(",")] + return self.used_in_filter in values + + return False + + def _write_empty_receipt( + self, + shard_id: str, + shard_index: int, + input_files: list[str], + stats: dict, + receipt_path: str, + fs, + ) -> dict: + """Write receipt for empty shard.""" + receipt = { + "shard_id": shard_id, + "shard_index": shard_index, + "status": "completed", + "created_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()), + "input_files": input_files, + "output_file": None, + "npy_bytes": 0, + "packing": { + "pack_size": self.pack_size, + "algorithm": self.algorithm, + "num_sequences": 0, + "num_packed_sequences": 0, + "packing_factor": 0, + "packing_efficiency": 0, + "total_tokens": 0, + }, + "stats": { + "num_sequences": 0, + "num_packed_sequences": 0, + "total_tokens": 0, + **stats, + }, + } + + write_json(fs, receipt_path, receipt) + return receipt["stats"] diff --git a/src/nemotron/data_prep/chat_template.py b/src/nemotron/data_prep/chat_template.py new file mode 100644 index 0000000..d940dd6 --- /dev/null +++ b/src/nemotron/data_prep/chat_template.py @@ -0,0 +1,381 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Chat template utilities for SFT data preparation. + +Exact port of materialize.py logic for chat template application and +loss mask generation. Provides functions for: +- Converting JSON string arguments to dicts in tool calls +- Finding message boundaries in rendered templates +- Splitting templates into role-labeled chunks for loss masking +- Multi-turn conversation splitting for thinking/reasoning content +""" + +from __future__ import annotations + +import copy +import json +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from transformers import PreTrainedTokenizerBase + + +def replace_json_args(messages: list[dict]) -> list[dict]: + """Convert JSON string arguments to dict objects in tool calls. + + Modifies messages in-place to ensure tool call arguments are dicts, + not JSON strings. + + Args: + messages: List of OpenAI-format messages. + + Returns: + The modified messages list. + + Note: + Exact port of materialize.py::replace_json_args() + """ + messages = copy.deepcopy(messages) + for i in range(len(messages)): + if messages[i]["role"] == "assistant": + if messages[i].get("tool_calls"): + for j in range(len(messages[i]["tool_calls"])): + if isinstance(messages[i]["tool_calls"][j]["function"]["arguments"], str): + messages[i]["tool_calls"][j]["function"]["arguments"] = json.loads( + messages[i]["tool_calls"][j]["function"]["arguments"] + ) + return messages + + +def find_last_user_message_end( + messages: list[dict], + tokenizer: PreTrainedTokenizerBase, + enable_thinking: bool = True, + tools: list | None = None, +) -> int: + """Find where the last user message ends in the rendered template. + + Uses incremental template rendering to find the exact character position + where the last user message (plus generation prompt) ends. + + Args: + messages: List of OpenAI-format messages. + tokenizer: HuggingFace tokenizer with chat_template. + enable_thinking: Whether thinking mode is enabled. + tools: Optional list of tool definitions. + + Returns: + Character position where last user message ends. + + Note: + Exact port of materialize.py::find_last_user_message_end() + """ + # Find the last user message index + last_user_idx = max(i for i, msg in enumerate(messages) if msg["role"] == "user") + + # Render up to the last user message (inclusive) + if enable_thinking and ( + "reasoning_content" not in messages[last_user_idx + 1] + or messages[last_user_idx + 1]["reasoning_content"] == "" + ): + # Manual hack for empty reasoning content mismatch + template_up_to_last_user = tokenizer.apply_chat_template( + messages[: last_user_idx + 1], + tokenize=False, + add_generation_prompt=False, + tools=tools, + chat_template_kwargs={"enable_thinking": enable_thinking}, + ) + template_up_to_last_user += "<|im_start|>assistant\n" + else: + template_up_to_last_user = tokenizer.apply_chat_template( + messages[: last_user_idx + 1], + tokenize=False, + add_generation_prompt=True, + chat_template_kwargs={"enable_thinking": enable_thinking}, + tools=tools, + ) + + return len(template_up_to_last_user) + + +def split_template_into_messages( + messages: list[dict], + tokenizer: PreTrainedTokenizerBase, + start_from_last_user: bool = True, + enable_thinking: bool = True, + tools: list | None = None, +) -> list[dict]: + """Split rendered template back into individual message chunks. + + Each chunk has 'role' and 'content' fields where content is the + raw rendered template text for that turn. This enables downstream + loss masking based on role. + + Args: + messages: List of OpenAI-format messages. + tokenizer: HuggingFace tokenizer with chat_template. + start_from_last_user: If True, first chunk includes all prior turns. + enable_thinking: Whether thinking mode is enabled. + tools: Optional list of tool definitions. + + Returns: + List of chunks with 'role' and 'content' fields. + + Raises: + ValueError: If incremental rendering doesn't match full template. + + Note: + Exact port of materialize.py::split_template_into_messages() + """ + # Render full template + full_template = tokenizer.apply_chat_template( + messages, + tokenize=False, + add_generation_prompt=False, + tools=tools, + chat_template_kwargs={"enable_thinking": enable_thinking}, + ) + + # Get first "message": if starting from last user, this includes all prior turns + if start_from_last_user: + system_end = full_template.find("<|im_end|>\n") + len("<|im_end|>\n") + last_user_idx = max(i for i, msg in enumerate(messages) if msg["role"] == "user") + last_user_pos = find_last_user_message_end( + messages, tokenizer, enable_thinking=enable_thinking, tools=tools + ) + previous_pos = last_user_pos + # First chunk: everything up to last user message, split at system boundary + result = [ + {"role": "system", "content": full_template[:system_end]}, + {"role": "user", "content": full_template[system_end:last_user_pos]}, + ] + message_range = range(last_user_idx + 1, len(messages)) + else: + previous_pos = 0 + result = [] + message_range = range(len(messages)) + + for i in message_range: + # Parallel tool calls + if ( + i + 1 < len(messages) + and messages[i]["role"] == "tool" + and messages[i + 1]["role"] == "tool" + ): + continue + + # Render up to this message + if ( + enable_thinking + and messages[i]["role"] != "assistant" + and i + 1 < len(messages) + and ( + "reasoning_content" not in messages[i + 1] + or messages[i + 1]["reasoning_content"] == "" + ) + ): + # Manual hack for empty reasoning content mismatch + template_up_to_here = tokenizer.apply_chat_template( + messages[: i + 1], + tokenize=False, + add_generation_prompt=False, + tools=tools, + chat_template_kwargs={"enable_thinking": enable_thinking}, + ) + template_up_to_here += "<|im_start|>assistant\n" + else: + # Tool and user messages need generation prompt, others don't + add_gen_prompt = messages[i]["role"] == "tool" or messages[i]["role"] == "user" + template_up_to_here = tokenizer.apply_chat_template( + messages[: i + 1], + tokenize=False, + add_generation_prompt=add_gen_prompt, + tools=tools, + chat_template_kwargs={"enable_thinking": enable_thinking}, + ) + + current_pos = len(template_up_to_here) + chunk_text = full_template[previous_pos:current_pos] + + # Verify incremental rendering matches full template + if template_up_to_here != full_template[:current_pos]: + raise ValueError( + f"Template mismatch at message {i}: incremental rendering doesn't match full" + ) + + result.append({"role": messages[i]["role"], "content": chunk_text}) + previous_pos = current_pos + + return result + + +def create_masked_messages( + messages: list[dict], + tokenizer: PreTrainedTokenizerBase, + tools: list | None = None, +) -> list[tuple[list[dict], list[dict]]]: + """Create message chunks for masking, optionally splitting at user turns. + + For conversations with thinking/reasoning content, splits into multiple + sequences (one per user message). Each sequence is independently + processable for training. + + Args: + messages: List of OpenAI-format messages. + tokenizer: HuggingFace tokenizer with chat_template. + tools: Optional list of tool definitions. + + Returns: + List of (chunks, original_messages) tuples. Each chunks list + contains dicts with 'role' and 'content' for loss masking. + + Note: + Exact port of materialize.py::create_masked_messages() + """ + # Check if conversation has thinking (determines splitting strategy) + has_thinking = any("reasoning_content" in msg and msg["reasoning_content"] for msg in messages) + + if has_thinking: + # Split based on user messages - create chunks up to each user message + user_idxs = [i for i, msg in enumerate(messages) if msg["role"] == "user"] + result = [] + for i in range(len(user_idxs)): + if i == len(user_idxs) - 1: + # Last user message - include all remaining messages + messages_i = messages + else: + # Include messages up to but not including the next user message + messages_i = messages[: user_idxs[i + 1]] + + chunks = split_template_into_messages( + messages_i, + tokenizer, + start_from_last_user=True, + enable_thinking=has_thinking, + tools=tools, + ) + + result.append((chunks, messages_i)) # Return both chunks and original messages + return result + else: + # Generate one sequence + chunks = split_template_into_messages( + messages, + tokenizer, + start_from_last_user=False, + enable_thinking=has_thinking, + tools=tools, + ) + return [(chunks, messages)] # Return both chunks and original messages + + +def validate_conversation( + messages: list[dict], + tools: list | None = None, +) -> tuple[bool, str | None]: + """Validate conversation for common issues. + + Checks from materialize_fast.py: + - Tool calls present in message content but 'tools' key missing + - in messages but no '# Tools' header + + Args: + messages: List of OpenAI-format messages. + tools: Optional list of tool definitions. + + Returns: + Tuple of (is_valid, error_message). If is_valid is True, + error_message is None. + + Note: + Validation logic from materialize_fast.py + """ + # Check if any message has but no message has # Tools + any_tool_call = any( + isinstance(m, dict) + and ( + (isinstance(m.get("content"), str) and "" in m.get("content", "")) + or ( + isinstance(m.get("reasoning_content"), str) + and "" in m.get("reasoning_content", "") + ) + ) + for m in messages + ) + any_tools_header = any( + isinstance(m, dict) + and ( + (isinstance(m.get("content"), str) and "# Tools" in m.get("content", "")) + or ( + isinstance(m.get("reasoning_content"), str) + and "# Tools" in m.get("reasoning_content", "") + ) + ) + for m in messages + ) + if any_tool_call and not any_tools_header: + return ( + False, + "Message-level: present but # Tools missing", + ) + + return (True, None) + + +def split_system_user_chunks(chunks: list[dict]) -> list[dict]: + """Split first chunk if it contains both system and user content. + + When start_from_last_user=True in split_template_into_messages, + the first 'user' chunk may contain both system and user content. + This function splits them into separate chunks. + + Args: + chunks: List of chunks from split_template_into_messages. + + Returns: + Processed chunks with system and user properly separated. + + Note: + Post-processing logic from materialize_fast.py + """ + processed = [] + for i, chunk in enumerate(chunks): + if ( + i == 0 + and chunk["role"] == "user" + and "<|im_start|>system" in chunk["content"] + and "<|im_start|>user" in chunk["content"] + ): + # Split into separate system and user chunks + content = chunk["content"] + system_end = content.find("<|im_end|>\n") + len("<|im_end|>\n") + user_start = content.find("<|im_start|>user") + + processed.append({"role": "system", "content": content[:system_end]}) + processed.append({"role": "user", "content": content[user_start:]}) + else: + processed.append(chunk) + return processed + + +__all__ = [ + "replace_json_args", + "find_last_user_message_end", + "split_template_into_messages", + "create_masked_messages", + "validate_conversation", + "split_system_user_chunks", +] diff --git a/src/nemotron/data_prep/config.py b/src/nemotron/data_prep/config.py new file mode 100644 index 0000000..60e839b --- /dev/null +++ b/src/nemotron/data_prep/config.py @@ -0,0 +1,443 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Pipeline configuration models.""" + +from collections.abc import Callable +from dataclasses import dataclass, field +from pathlib import Path +from typing import Literal + +import numpy as np + +# Valid dtypes for indexed dataset output (must match DTYPE_CODES in indexed_dataset.py) +VALID_OUTPUT_DTYPES = {"int32", "int64", "uint16"} + +# Type alias for transform functions +Transform = Callable[[dict], dict | None] + + +# ============================================================================ +# Public Configuration Models (New API) +# ============================================================================ + + +@dataclass(frozen=True) +class TokenizerConfig: + """Tokenizer configuration. + + Attributes: + model: HuggingFace model name/path, SentencePiece model path, + or tiktoken encoding name + type: Tokenizer backend (huggingface, sentencepiece, tiktoken) + add_bos: Prepend BOS token to each document + add_eos: Append EOS token to each document + trust_remote_code: Allow custom code in HF tokenizers + """ + + model: str + type: Literal["huggingface", "sentencepiece", "tiktoken"] = "huggingface" + add_bos: bool = False + add_eos: bool = True + trust_remote_code: bool = False + + +# ============================================================================ +# Output Format Configurations +# ============================================================================ + + +@dataclass(frozen=True) +class BinIdxOutputConfig: + """Configuration for Megatron .bin/.idx indexed dataset output. + + This is the default format, producing tokenized binary files compatible + with Megatron-Bridge and Megatron-Core. + + Attributes: + format: Format identifier (always "binidx") + shard_size: Target size per shard (e.g., "256MB"). Mutually exclusive with num_shards. + num_shards: Exact number of output shards. Mutually exclusive with shard_size. + dtype: Token dtype (int32, int64, uint16) + """ + + format: Literal["binidx"] = "binidx" + shard_size: str | int | None = "256MB" + num_shards: int | None = None + dtype: Literal["int32", "int64", "uint16"] = "int32" + + def __post_init__(self) -> None: + if self.shard_size is not None and self.num_shards is not None: + raise ValueError("Specify either shard_size or num_shards, not both") + + +@dataclass(frozen=True) +class JsonlOutputConfig: + """Configuration for JSONL output (no tokenization). + + Outputs structured JSONL files for SFT/RL training, applying optional + transforms to convert records to the desired format. + + Attributes: + format: Format identifier (always "jsonl") + shard_size: Target size per shard (e.g., "256MB"). Mutually exclusive with num_shards. + num_shards: Exact number of output shards. Mutually exclusive with shard_size. + transform: Optional callable to transform records. Returns dict or None to skip. + compression: Output compression ("none" for .jsonl, "zstd" for .jsonl.zst) + """ + + format: Literal["jsonl"] = "jsonl" + shard_size: str | int | None = "256MB" + num_shards: int | None = None + transform: Transform | None = None + compression: Literal["none", "zstd"] = "none" + + def __post_init__(self) -> None: + if self.shard_size is not None and self.num_shards is not None: + raise ValueError("Specify either shard_size or num_shards, not both") + + +@dataclass(frozen=True) +class PackedOutputConfig: + """Configuration for packed sequence output. + + Tokenizes and packs sequences into efficient batches compatible with + GPTSFTPackedDataset. Output is .npy files with packed sequences. + + Attributes: + format: Format identifier (always "packed") + shard_size: Target size per shard (e.g., "256MB"). Mutually exclusive with num_shards. + num_shards: Exact number of output shards. Mutually exclusive with shard_size. + dtype: Token dtype (int32, int64, uint16) + pack_size: Maximum tokens per packed sequence + algorithm: Packing algorithm ("first_fit_decreasing", "first_fit_shuffle", "concatenative") + """ + + format: Literal["packed"] = "packed" + shard_size: str | int | None = "256MB" + num_shards: int | None = None + dtype: Literal["int32", "int64", "uint16"] = "int32" + pack_size: int = 2048 + algorithm: Literal["first_fit_decreasing", "first_fit_shuffle", "concatenative"] = ( + "first_fit_shuffle" + ) + + def __post_init__(self) -> None: + if self.shard_size is not None and self.num_shards is not None: + raise ValueError("Specify either shard_size or num_shards, not both") + if self.pack_size <= 0: + raise ValueError(f"pack_size must be positive, got {self.pack_size}") + + +@dataclass(frozen=True) +class ChatSftOutputConfig: + """Configuration for chat-templated SFT output with loss masking. + + Applies materialize.py chat template logic to OpenAI-format messages, + tokenizes with role-based loss masking, and outputs packed .npy files + compatible with GPTSFTPackedDataset. + + Pipeline: + 1. Apply chat template → role-labeled chunks + 2. Tokenize chunks → input_ids + 3. Build loss_mask (0=system/user, 1=assistant) + 4. Pack sequences → .npy output + + Attributes: + format: Format identifier (always "chat_sft") + shard_size: Target size per shard (e.g., "256MB"). Mutually exclusive with num_shards. + num_shards: Exact number of output shards. Mutually exclusive with shard_size. + dtype: Token dtype (int32, int64, uint16) + pack_size: Maximum tokens per packed sequence + algorithm: Packing algorithm ("first_fit_decreasing", "first_fit_shuffle", "concatenative") + chat_template: "nano3", path to .jinja file, or inline template string + messages_field: Field name for messages in input records + tools_field: Field name for tools in input records + used_in_filter: Filter to only include records where used_in contains this value + used_in_field: Field name for used_in filtering (default: "used_in") + """ + + format: Literal["chat_sft"] = "chat_sft" + shard_size: str | int | None = "256MB" + num_shards: int | None = None + dtype: Literal["int32", "int64", "uint16"] = "int32" + pack_size: int = 2048 + algorithm: Literal["first_fit_decreasing", "first_fit_shuffle", "concatenative"] = ( + "first_fit_shuffle" + ) + chat_template: str | None = None + messages_field: str = "messages" + tools_field: str = "tools" + used_in_filter: str | None = None + used_in_field: str = "used_in" + + def __post_init__(self) -> None: + if self.shard_size is not None and self.num_shards is not None: + raise ValueError("Specify either shard_size or num_shards, not both") + if self.pack_size <= 0: + raise ValueError(f"pack_size must be positive, got {self.pack_size}") + + +# Union type for all output formats +OutputFormat = BinIdxOutputConfig | JsonlOutputConfig | PackedOutputConfig | ChatSftOutputConfig + + +@dataclass(frozen=True) +class RayDataConfig: + """Configuration for Ray Data shard-task execution. + + These settings map directly to Ray Data's ActorPoolStrategy and + map_batches parameters, providing explicit control over resource usage. + + When enabled, uses Ray Data's streaming executor for shard processing + instead of manual actor pool management. Benefits include: + - Automatic actor lifecycle management (no leaked actors) + - Integrated backpressure with Ray's resource manager + - Explicit CPU accounting per actor + + Attributes: + enabled: Enable Ray Data execution (vs legacy manual actors) + min_actors: Minimum actors to keep alive (warm pool) + max_actors: Maximum actors. None means use all available CPUs. + cpus_per_actor: CPUs allocated per actor (explicit accounting) + max_tasks_in_flight_per_actor: Pipelining depth to reduce scheduling + bubbles and keep actors fed. Note: does not by itself parallelize + a single actor; true I/O latency hiding requires either more actors + (with fractional num_cpus) or async internal concurrency. + """ + + enabled: bool = False + min_actors: int = 2 + max_actors: int | None = None # None = use all available CPUs + cpus_per_actor: float = 1.0 + max_tasks_in_flight_per_actor: int = 2 + + +@dataclass(frozen=True) +class OutputConfig: + """Output configuration. + + Attributes: + dir: Output directory (local path or cloud URI) + format: Output format configuration (BinIdxOutputConfig, JsonlOutputConfig, etc.) + min_doc_chars: Skip documents shorter than this (for tokenized formats) + max_doc_tokens: Truncate documents longer than this (for tokenized formats) + max_rows: Limit rows processed per shard (useful for quick tests) + + Deprecated attributes (for backward compatibility): + num_shards: Use format.num_shards instead + dtype: Use format.dtype instead + """ + + dir: Path + format: OutputFormat = field(default_factory=BinIdxOutputConfig) + min_doc_chars: int | None = None + max_doc_tokens: int | None = None + max_rows: int | None = None + # Deprecated - for backward compatibility + num_shards: int | None = None + dtype: Literal["int32", "int64", "uint16"] | None = None + + def __post_init__(self) -> None: + # Handle backward compatibility: if old-style num_shards/dtype provided, + # we need to handle them. But since this is frozen, we can't modify. + # The pipeline should check for these and warn. + pass + + +@dataclass(frozen=True) +class PerSplitConfig: + """Configuration for per-split output mode. + + Distributes shards into train/valid/test splits and outputs JSON + with {"train": [...], "valid": [...], "test": [...]} keys. + + Attributes: + enabled: If True, enables per-split output mode + valid_shards: Number of shards for validation (default: 1) + test_shards: Number of shards for test (default: 1) + """ + + enabled: bool = True + valid_shards: int = 1 + test_shards: int = 1 + + +@dataclass(frozen=True) +class PipelineConfig: + """Complete pipeline configuration. + + Attributes: + output: Output settings + tokenizer: Tokenizer settings (required for binidx/packed formats, optional for jsonl) + sample: Shard sampling spec ("10%", "5", or None for all) + sample_seed: Random seed for sampling + force: Force new run (ignore cached results) + split: Split ratio for single-blend mode (e.g., "99990,8,2"). Deprecated. + per_split: Per-split output configuration for Megatron-Bridge per_split_data_args_path + ray_data: Ray Data execution configuration. When enabled and ray_data.enabled=True, + uses Ray Data's ActorPoolStrategy for shard processing instead of manual actors. + """ + + output: OutputConfig + tokenizer: TokenizerConfig | None = None + sample: str | int | None = None + sample_seed: int = 42 + force: bool = False + split: str | None = None # Deprecated - use per_split instead + per_split: PerSplitConfig | None = None + ray_data: RayDataConfig | None = None + + +# ============================================================================ +# Internal Configuration Classes (Used by pipeline internals) +# ============================================================================ + + +@dataclass +class InternalDatasetConfig: + """Configuration for a single dataset source (internal use).""" + + name: str # Unique identifier + path: str # hf://..., s3://..., or local path/glob + weight: float = 1.0 # Blend weight + text_field: str = "text" + include_in_blend: bool = True + + # HuggingFace-specific + split: str | None = None # Required for hf:// + subset: str | None = None # HF dataset config + revision: str | None = None # Git revision (resolved to SHA) + + +@dataclass +class InternalTokenizerConfig: + """Configuration for the tokenizer (internal use).""" + + type: Literal["huggingface", "sentencepiece", "tiktoken"] + model: str # Model name or path + revision: str | None = None # Model revision (resolved to SHA) + add_eos: bool = True + add_bos: bool = False + trust_remote_code: bool = False + + +@dataclass +class InternalOutputConfig: + """Configuration for output generation (internal use).""" + + num_shards: int # Required - explicit shard count + dtype: str = "int32" + min_doc_chars: int | None = None + max_doc_tokens: int | None = None + max_rows: int | None = None # Limit rows processed per shard (useful for quick tests) + + def __post_init__(self) -> None: + """Validate configuration values.""" + if self.dtype not in VALID_OUTPUT_DTYPES: + raise ValueError( + f"Invalid dtype '{self.dtype}'. Must be one of: {sorted(VALID_OUTPUT_DTYPES)}" + ) + # Validate dtype is actually a valid numpy dtype + try: + np.dtype(self.dtype) + except TypeError as e: + raise ValueError(f"Invalid numpy dtype '{self.dtype}': {e}") + + +@dataclass +class FileInfo: + """Metadata for an input file.""" + + path: str + local_path: str | None # Resolved local path (for HF cache) - None for HF files + size: int + etag: str | None = None + # Additional fingerprint fields + mtime: float | None = None # For local files + version_id: str | None = None # For S3/GCS versioned objects + # HuggingFace-specific fields for deferred download + hf_repo_id: str | None = None # e.g., "allenai/c4" + hf_filename: str | None = None # e.g., "en/c4-train.00000-of-01024.json.gz" + hf_revision: str | None = None # Resolved SHA for determinism + + +@dataclass +class ShardAssignment: + """Files assigned to a shard.""" + + shard_index: int + files: list[FileInfo] = field(default_factory=list) + total_bytes: int = 0 + + +@dataclass +class ShardPlan: + """Deterministic shard assignment, frozen at first run.""" + + version: str + created_at: str + plan_hash: str + dataset_name: str + num_shards: int + source_fingerprint: str + config_hash: str + determinism_constraints: dict + resolved_tokenizer: dict + file_assignments: list[ShardAssignment] + + @classmethod + def from_dict(cls, data: dict) -> "ShardPlan": + """Create ShardPlan from dictionary.""" + file_assignments = [] + for fa in data["file_assignments"]: + files = [FileInfo(**f) for f in fa["files"]] + file_assignments.append( + ShardAssignment( + shard_index=fa["shard_index"], + files=files, + total_bytes=fa["total_bytes"], + ) + ) + return cls( + version=data["version"], + created_at=data["created_at"], + plan_hash=data["plan_hash"], + dataset_name=data["dataset_name"], + num_shards=data["num_shards"], + source_fingerprint=data["source_fingerprint"], + config_hash=data["config_hash"], + determinism_constraints=data["determinism_constraints"], + resolved_tokenizer=data["resolved_tokenizer"], + file_assignments=file_assignments, + ) + + +class SourceChangedError(Exception): + """Raised when source data has changed since plan creation.""" + + pass + + +# ============================================================================ +# Aliases for backward compatibility with existing internal code +# ============================================================================ + +# These aliases allow existing internal modules (planning.py, discovery.py, etc.) +# to continue using the old names without modification +DatasetConfig = InternalDatasetConfig +# Note: TokenizerConfig is now the public frozen dataclass +# Internal code should use InternalTokenizerConfig +# OutputConfig is now the public frozen dataclass +# Internal code should use InternalOutputConfig diff --git a/src/nemotron/data_prep/console.py b/src/nemotron/data_prep/console.py new file mode 100644 index 0000000..6303186 --- /dev/null +++ b/src/nemotron/data_prep/console.py @@ -0,0 +1,836 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Rich console utilities for pipeline output.""" + +from dataclasses import dataclass, field + +from rich.console import Console, Group +from rich.live import Live +from rich.panel import Panel +from rich.progress import ( + BarColumn, + MofNCompleteColumn, + Progress, + SpinnerColumn, + TaskProgressColumn, + TextColumn, + TimeElapsedColumn, +) +from rich.table import Table +from rich.text import Text + +console = Console() + + +@dataclass +class DatasetPlanInfo: + """Info about a dataset's plan for display.""" + + name: str + plan_hash: str + num_shards: int + num_files: int + pending: int + cached: int + cached_tokens: int + cached_sequences: int + sampled: int | None = None + # HuggingFace metadata + hf_rows: str | None = None # Formatted string like "3.79B" + hf_size: str | None = None # Formatted string like "4.58 TB" + + +def planning_header() -> None: + """Print the planning phase header.""" + console.print() + console.print("[bold]Planning...[/bold]") + + +def plan_summary( + datasets: list[DatasetPlanInfo], run_hash: str +) -> None: + """Print a summary table of all dataset plans.""" + # Auto-detect num_actors from Ray cluster + import os + + import ray + + try: + cluster_cpus = int(ray.cluster_resources().get("CPU", 0)) + if cluster_cpus > 0: + num_actors = cluster_cpus + else: + num_actors = os.cpu_count() or 4 + except Exception: + num_actors = os.cpu_count() or 4 + num_actors = max(2, num_actors) + + console.print() + + # Check if any dataset has HF metadata + has_hf_metadata = any(ds.hf_rows or ds.hf_size for ds in datasets) + + table = Table(title="Execution Plan", show_header=True) + table.add_column("Dataset", style="cyan", no_wrap=True) + if has_hf_metadata: + table.add_column("Size", justify="right", style="dim") + table.add_column("Rows", justify="right", style="dim") + table.add_column("Shards", justify="right") + table.add_column("Files", justify="right") + table.add_column("Cached", justify="right", style="dim") + table.add_column("Pending", justify="right") + table.add_column("Status") + + total_pending = 0 + total_cached = 0 + + # Collect data for W&B table + wandb_rows = [] + + for ds in datasets: + pending = ds.sampled if ds.sampled is not None else ds.pending + total_pending += pending + total_cached += ds.cached + + if pending == 0: + status = "[green]cached[/green]" + status_plain = "cached" + else: + status = f"[yellow]{pending} to process[/yellow]" + status_plain = f"{pending} to process" + + cached_str = str(ds.cached) if ds.cached > 0 else "-" + + row = [ds.name] + if has_hf_metadata: + row.append(ds.hf_size or "-") + row.append(ds.hf_rows or "-") + row.extend( + [ + str(ds.num_shards), + str(ds.num_files), + cached_str, + str(pending) if pending > 0 else "-", + status, + ] + ) + + table.add_row(*row) + + # Build W&B row (without Rich markup) + wandb_row = [ds.name] + if has_hf_metadata: + wandb_row.extend([ds.hf_size or "-", ds.hf_rows or "-"]) + wandb_row.extend( + [ + ds.num_shards, + ds.num_files, + ds.cached if ds.cached > 0 else 0, + pending if pending > 0 else 0, + status_plain, + ] + ) + wandb_rows.append(wandb_row) + + console.print(table) + + # Summary line + actors_info = f" using [cyan]{num_actors} workers[/cyan]" + if total_pending == 0: + console.print(f"\n[green]All shards cached.[/green] Run hash: [yellow]{run_hash}[/yellow]") + else: + console.print( + f"\n[bold]Will process {total_pending} shard(s)[/bold]{actors_info} " + f"({total_cached} cached). Run hash: [yellow]{run_hash}[/yellow]" + ) + console.print() + + # Log to W&B if active + _log_plan_to_wandb( + wandb_rows, has_hf_metadata, run_hash, num_actors, total_pending, total_cached + ) + + +def _log_plan_to_wandb( + rows: list[list], + has_hf_metadata: bool, + run_hash: str, + num_actors: int, + total_pending: int, + total_cached: int, +) -> None: + """Log execution plan as W&B Table.""" + try: + import wandb + + if wandb.run is None: + return + + # Build column names + columns = ["Dataset"] + if has_hf_metadata: + columns.extend(["Size", "Rows"]) + columns.extend(["Shards", "Files", "Cached", "Pending", "Status"]) + + # Create W&B table + wandb_table = wandb.Table(columns=columns, data=rows) + + # Log the table + wandb.log( + { + "data_prep/execution_plan": wandb_table, + "data_prep/run_hash": run_hash, + "data_prep/num_workers": num_actors, + "data_prep/total_pending_shards": total_pending, + "data_prep/total_cached_shards": total_cached, + "data_prep/num_datasets": len(rows), + } + ) + except ImportError: + pass + except Exception: + pass # Don't fail pipeline on W&B errors + + +def execution_header() -> None: + """Print the execution phase header.""" + console.print("[bold]Processing...[/bold]") + console.print() + + +def dataset_progress_start(name: str) -> None: + """Print dataset processing start.""" + console.print(f"[cyan]{name}[/cyan]") + + +def dataset_complete(num_shards: int, num_sequences: int, num_tokens: int) -> None: + """Print dataset completion stats after processing.""" + console.print( + f" [green]Complete:[/green] {num_shards} shards, " + f"{num_sequences:,} sequences, {num_tokens:,} tokens" + ) + console.print() + + +def dataset_cached(num_shards: int, num_sequences: int, num_tokens: int) -> None: + """Print cached dataset stats (all shards already complete).""" + console.print( + f" [dim]Cached:[/dim] {num_shards} shards, " + f"{num_sequences:,} sequences, {num_tokens:,} tokens" + ) + console.print() + + +def create_progress() -> Progress: + """Create a progress bar for shard processing.""" + return Progress( + SpinnerColumn(), + TextColumn("[progress.description]{task.description}"), + BarColumn(), + MofNCompleteColumn(), + TaskProgressColumn(), + TimeElapsedColumn(), + console=console, + ) + + +def pipeline_complete( + run_hash: str, + output_dir: str, + total_tokens: int, + total_sequences: int, + elapsed_sec: float, +) -> None: + """Print pipeline completion summary.""" + console.print() + + table = Table(box=None, show_header=False, padding=(0, 2)) + table.add_column("Key", style="dim") + table.add_column("Value") + + table.add_row("Run hash", f"[yellow]{run_hash}[/yellow]") + table.add_row("Output", f"{output_dir}/runs/{run_hash}") + table.add_row("Total tokens", f"[green]{total_tokens:,}[/green]") + table.add_row("Total sequences", f"{total_sequences:,}") + table.add_row("Time", f"{elapsed_sec:.1f}s") + + console.print( + Panel(table, title="[bold green]Pipeline Complete[/bold green]", border_style="green") + ) + + +def error(message: str) -> None: + """Print an error message.""" + console.print(f"[red bold]Error:[/red bold] {message}") + + +@dataclass +class DatasetStatus: + """Status of a single dataset during execution.""" + + name: str + total_shards: int + completed_shards: int = 0 + status: str = "pending" # pending, processing, cached, complete + tokens: int = 0 # Tokens processed for this dataset + # Compute metrics (updated during processing) + rows_processed: int = 0 # Number of rows processed + throughput: float = 0.0 # Rows per second + start_time: float = 0.0 # When processing started (timestamp) + # Phase tracking for progress visibility + phase: str = "" # Current phase: downloading, reading, tokenizing, writing + phase_detail: str = "" # Optional detail (e.g., "3/10 files", "15K rows") + + +@dataclass +class BottleneckMetrics: + """Rolling window of shard timing metrics for bottleneck identification.""" + + # Cumulative timing (seconds) from all shards + time_download: float = 0.0 + time_read: float = 0.0 + time_tokenize: float = 0.0 + time_write: float = 0.0 + time_total: float = 0.0 + # Counts + num_shards: int = 0 + num_errors: int = 0 + # Peak memory (if available) + peak_memory_mb: float = 0.0 + + def add_shard_stats(self, stats: dict) -> None: + """Update metrics from a shard's stats dict.""" + self.time_download += stats.get("time_download_sec", 0.0) + self.time_read += stats.get("time_read_sec", 0.0) + self.time_tokenize += stats.get("time_tokenize_sec", 0.0) + self.time_write += stats.get("time_write_sec", 0.0) + self.time_total += stats.get("time_total_sec", 0.0) + self.num_shards += 1 + self.num_errors += stats.get("num_errors", 0) + if "peak_memory_mb" in stats: + self.peak_memory_mb = max(self.peak_memory_mb, stats["peak_memory_mb"]) + + def get_percentages(self) -> dict[str, float]: + """Get time breakdown as percentages.""" + total = self.time_download + self.time_read + self.time_tokenize + self.time_write + if total <= 0: + return {"download_pct": 0, "read_pct": 0, "tokenize_pct": 0, "write_pct": 0} + return { + "download_pct": (self.time_download / total) * 100, + "read_pct": (self.time_read / total) * 100, + "tokenize_pct": (self.time_tokenize / total) * 100, + "write_pct": (self.time_write / total) * 100, + } + + +@dataclass +class LiveExecutionStatus: + """Manages live status display during pipeline execution. + + Shows a multi-line display for parallel processing: + - Line 1: Overall progress bar (total shards across all datasets) + - Line 2+: Active datasets being processed (cycles through 3 at a time) + - Last line: Summary stats with page indicator + """ + + datasets: list[DatasetStatus] = field(default_factory=list) + run_hash: str = "" + _live: Live | None = field(default=None, repr=False) + _progress: Progress | None = field(default=None, repr=False) + _overall_task_id: int | None = field(default=None, repr=False) + _current_page: int = field(default=0, repr=False) # Current page for cycling display + _page_cycle_counter: int = field(default=0, repr=False) # Counter for auto-cycling + _wandb_step: int = field(default=0, repr=False) + _last_wandb_log_time: float = field(default=0.0, repr=False) + _wandb_log_interval: float = field(default=10.0, repr=False) # Log every 10 seconds + _start_time: float = field(default=0.0, repr=False) # Pipeline start time + _total_tokens: int = field(default=0, repr=False) # Cumulative tokens processed + _max_display: int = field(default=3, repr=False) # Max datasets to show per page + _bottleneck_metrics: BottleneckMetrics = field(default_factory=BottleneckMetrics, repr=False) + + def _get_summary_counts(self) -> tuple[int, int, int, int]: + """Get counts of datasets by status.""" + done = sum(1 for ds in self.datasets if ds.status == "complete") + cached = sum(1 for ds in self.datasets if ds.status == "cached") + pending = sum(1 for ds in self.datasets if ds.status == "pending") + processing = sum(1 for ds in self.datasets if ds.status == "processing") + return done, cached, pending, processing + + def _get_total_shards_progress(self) -> tuple[int, int]: + """Get total shards completed and total shards across all datasets.""" + total_completed = sum(ds.completed_shards for ds in self.datasets) + total_shards = sum(ds.total_shards for ds in self.datasets) + return total_completed, total_shards + + def _log_progress_to_wandb(self, force: bool = False) -> None: + """Log current progress to W&B for charts. + + Logs both aggregate metrics and per-dataset progress, creating + a chart for each dataset showing shards completed over time. + + Args: + force: If True, log immediately regardless of time throttling. + Used for final completion to ensure we capture 100%. + """ + import logging + import time as time_module + + logger = logging.getLogger(__name__) + + try: + import wandb + + if wandb.run is None: + return + + # Time-based throttling: only log every N seconds unless forced + current_time = time_module.time() + if not force and (current_time - self._last_wandb_log_time) < self._wandb_log_interval: + return + + self._last_wandb_log_time = current_time + + done, cached, pending, processing = self._get_summary_counts() + total = len(self.datasets) + completed = done + cached + + # Calculate throughput + elapsed = current_time - self._start_time if self._start_time > 0 else 0 + tokens_per_sec = self._total_tokens / elapsed if elapsed > 0 else 0 + + self._wandb_step += 1 + + # Define metrics on first call to ensure W&B creates charts + if self._wandb_step == 1: + try: + # Aggregate metrics use elapsed_sec as x-axis + wandb.define_metric("data_prep/progress/*", step_metric="data_prep/progress/elapsed_sec") + wandb.define_metric("data_prep/bottleneck/*", step_metric="data_prep/progress/elapsed_sec") + # Per-dataset metrics also use elapsed_sec as x-axis + wandb.define_metric("data_prep/datasets/*", step_metric="data_prep/progress/elapsed_sec") + except Exception: + pass # define_metric may fail on older W&B versions + + # Build log dict with aggregate metrics + log_data = { + "data_prep/progress/datasets_completed": completed, + "data_prep/progress/datasets_total": total, + "data_prep/progress/datasets_done": done, + "data_prep/progress/datasets_cached": cached, + "data_prep/progress/datasets_pending": pending, + "data_prep/progress/completion_pct": (completed / total * 100) + if total > 0 + else 0, + "data_prep/progress/tokens": self._total_tokens, + "data_prep/progress/tokens_per_sec": tokens_per_sec, + "data_prep/progress/elapsed_sec": elapsed, + } + + # Add per-dataset progress metrics + # This creates a separate chart for each dataset showing shards completed + for ds in self.datasets: + # Sanitize dataset name for W&B metric key (replace special chars) + safe_name = ds.name.replace("/", "_").replace("-", "_").replace(".", "_") + progress_pct = (ds.completed_shards / ds.total_shards * 100) if ds.total_shards > 0 else 0 + + log_data[f"data_prep/datasets/{safe_name}/shards_completed"] = ds.completed_shards + log_data[f"data_prep/datasets/{safe_name}/shards_total"] = ds.total_shards + log_data[f"data_prep/datasets/{safe_name}/progress_pct"] = progress_pct + log_data[f"data_prep/datasets/{safe_name}/tokens"] = ds.tokens + + # Add bottleneck metrics if we have timing data + if self._bottleneck_metrics.num_shards > 0: + pcts = self._bottleneck_metrics.get_percentages() + log_data.update( + { + "data_prep/bottleneck/download_pct": pcts["download_pct"], + "data_prep/bottleneck/read_pct": pcts["read_pct"], + "data_prep/bottleneck/tokenize_pct": pcts["tokenize_pct"], + "data_prep/bottleneck/write_pct": pcts["write_pct"], + "data_prep/bottleneck/shards_processed": self._bottleneck_metrics.num_shards, + "data_prep/bottleneck/errors": self._bottleneck_metrics.num_errors, + } + ) + if self._bottleneck_metrics.peak_memory_mb > 0: + log_data["data_prep/resources/peak_memory_mb"] = ( + self._bottleneck_metrics.peak_memory_mb + ) + + wandb.log(log_data, commit=True) # Force immediate sync to W&B + logger.debug(f"[W&B] Logged data_prep metrics: step={self._wandb_step}, tokens={self._total_tokens}, datasets={len(self.datasets)}") + except ImportError: + pass + except Exception as e: + logger.warning(f"[W&B] Failed to log metrics: {e}") + + def _build_summary_line(self) -> Text: + """Build a compact summary line.""" + done, cached, pending, processing = self._get_summary_counts() + total = len(self.datasets) + completed_shards, total_shards = self._get_total_shards_progress() + + parts = [] + if done > 0: + parts.append(f"[green]{done} done[/green]") + if cached > 0: + parts.append(f"[dim]{cached} cached[/dim]") + if processing > 0: + parts.append(f"[cyan]{processing} active[/cyan]") + + summary = f"[bold]Datasets {done + cached}/{total}[/bold]" + if parts: + summary += " | " + ", ".join(parts) + + return Text.from_markup(summary) + + def _format_tokens(self, tokens: int) -> str: + """Format token count in human-readable format.""" + if tokens >= 1_000_000_000: + return f"{tokens / 1_000_000_000:.1f}B" + elif tokens >= 1_000_000: + return f"{tokens / 1_000_000:.1f}M" + elif tokens >= 1_000: + return f"{tokens / 1_000:.1f}K" + return str(tokens) + + def _format_throughput(self, rows_per_sec: float) -> str: + """Format throughput in human-readable format.""" + if rows_per_sec >= 1_000: + return f"{rows_per_sec / 1_000:.1f}K/s" + elif rows_per_sec >= 1: + return f"{rows_per_sec:.0f}/s" + elif rows_per_sec > 0: + return f"{rows_per_sec:.2f}/s" + return "-" + + def _build_active_datasets_table(self) -> Table | None: + """Build a table display for currently active datasets. + + Cycles through pages of datasets like an airport arrival board. + Shows max 3 datasets per page with compute metrics. + """ + active = [ds for ds in self.datasets if ds.status == "processing"] + + if not active: + return None + + # Calculate pagination + total_pages = (len(active) + self._max_display - 1) // self._max_display + if total_pages == 0: + total_pages = 1 + + # Ensure current page is valid + if self._current_page >= total_pages: + self._current_page = 0 + + # Get datasets for current page + start_idx = self._current_page * self._max_display + end_idx = min(start_idx + self._max_display, len(active)) + page_datasets = active[start_idx:end_idx] + + # Build page indicator for title + if total_pages > 1: + dots = " ".join("●" if i == self._current_page else "○" for i in range(total_pages)) + title = f"Active Tasks [dim]{dots}[/dim]" + else: + title = "Active Tasks" + + # Create table + table = Table( + title=title, + box=None, + show_header=True, + header_style="dim", + padding=(0, 1), + collapse_padding=True, + ) + table.add_column("Dataset", style="cyan", no_wrap=True, min_width=20) + table.add_column("Phase", justify="left", min_width=12) + table.add_column("Progress", justify="center", min_width=8) + table.add_column("Tokens", justify="right", min_width=8) + table.add_column("Speed", justify="right", min_width=8) + + for ds in page_datasets: + # Phase indicator with detail + if ds.phase: + phase_str = f"[yellow]{ds.phase}[/yellow]" + if ds.phase_detail: + phase_str += f" [dim]{ds.phase_detail}[/dim]" + else: + # Show elapsed time when no phase info yet + if ds.start_time > 0: + import time as time_module + elapsed = time_module.time() - ds.start_time + phase_str = f"[dim]starting... {elapsed:.0f}s[/dim]" + else: + phase_str = "[dim]starting...[/dim]" + + # Progress indicator + if ds.completed_shards >= ds.total_shards: + progress = "[green]✓[/green]" + else: + progress = f"{ds.completed_shards}/{ds.total_shards}" + + # Format metrics + tokens_str = self._format_tokens(ds.tokens) if ds.tokens > 0 else "-" + speed_str = self._format_throughput(ds.throughput) + + table.add_row(ds.name, phase_str, progress, tokens_str, speed_str) + + return table + + def _build_active_datasets_display(self) -> list[Text]: + """Build display lines for currently active datasets (legacy fallback).""" + # This method is kept for compatibility but we now prefer the table + active = [ds for ds in self.datasets if ds.status == "processing"] + lines = [] + + if not active: + return lines + + # Calculate pagination + total_pages = (len(active) + self._max_display - 1) // self._max_display + if total_pages == 0: + total_pages = 1 + + # Ensure current page is valid + if self._current_page >= total_pages: + self._current_page = 0 + + # Get datasets for current page + start_idx = self._current_page * self._max_display + end_idx = min(start_idx + self._max_display, len(active)) + page_datasets = active[start_idx:end_idx] + + for ds in page_datasets: + status_char = "●" if ds.completed_shards > 0 else "○" + + if ds.completed_shards >= ds.total_shards: + line = f" [green]{status_char}[/green] [green]{ds.name}[/green] [dim]✓[/dim]" + else: + prog = f"{ds.completed_shards}/{ds.total_shards}" + line = f" [cyan]{status_char}[/cyan] {ds.name} [dim]{prog}[/dim]" + lines.append(Text.from_markup(line)) + + # Add page indicator if multiple pages + if total_pages > 1: + dots = " ".join("●" if i == self._current_page else "○" for i in range(total_pages)) + page_indicator = f" [dim]{dots} ({self._current_page + 1}/{total_pages})[/dim]" + lines.append(Text.from_markup(page_indicator)) + + return lines + + def _build_display(self) -> Group: + """Build the live display for parallel execution.""" + elements = [] + + # Add overall progress bar + if self._progress is not None: + elements.append(self._progress) + + # Add active datasets table (preferred) or fallback to text lines + active_table = self._build_active_datasets_table() + if active_table is not None: + elements.append(active_table) + + # Add summary line + elements.append(self._build_summary_line()) + + return Group(*elements) + + def start(self) -> None: + """Start the live display.""" + import time as time_module + + self._start_time = time_module.time() + + # Calculate total shards across all datasets + total_shards = sum(ds.total_shards for ds in self.datasets) + + # Create overall progress bar + self._progress = Progress( + SpinnerColumn(), + TextColumn("[bold blue]Overall[/bold blue]"), + BarColumn(bar_width=40), + MofNCompleteColumn(), + TaskProgressColumn(), + TimeElapsedColumn(), + console=console, + transient=True, + ) + self._overall_task_id = self._progress.add_task("Processing", total=total_shards) + + self._live = Live( + self._build_display(), + console=console, + refresh_per_second=4, + transient=False, + ) + self._live.start() + + def stop(self) -> None: + """Stop the live display.""" + if self._live: + self._live.stop() + self._live = None + self._progress = None + self._overall_task_id = None + + def refresh(self) -> None: + """Refresh the live display and cycle pages.""" + if self._live: + # Auto-cycle pages every ~2 seconds (8 refresh calls at 4 fps) + self._page_cycle_counter += 1 + if self._page_cycle_counter >= 8: + self._page_cycle_counter = 0 + active = [ds for ds in self.datasets if ds.status == "processing"] + total_pages = (len(active) + self._max_display - 1) // self._max_display + if total_pages > 1: + self._current_page = (self._current_page + 1) % total_pages + + self._live.update(self._build_display()) + + def start_dataset(self, name: str) -> None: + """Mark a dataset as processing (for parallel execution).""" + import time as time_module + + for ds in self.datasets: + if ds.name == name: + ds.status = "processing" + ds.start_time = time_module.time() + break + self.refresh() + + def advance_dataset(self, name: str) -> None: + """Advance progress for a dataset.""" + for ds in self.datasets: + if ds.name == name: + ds.completed_shards += 1 + # Advance overall progress bar + if self._progress and self._overall_task_id is not None: + self._progress.advance(self._overall_task_id) + break + self.refresh() + + def complete_dataset(self, name: str) -> None: + """Mark a dataset as complete.""" + for ds in self.datasets: + if ds.name == name: + ds.status = "complete" + ds.completed_shards = ds.total_shards + break + self.refresh() + # Force log if this is the last dataset to ensure we capture 100% + done, cached, pending, processing = self._get_summary_counts() + is_last = pending == 0 and processing == 0 + self._log_progress_to_wandb(force=is_last) + + def cache_dataset(self, name: str) -> None: + """Mark a dataset as cached.""" + for ds in self.datasets: + if ds.name == name: + ds.status = "cached" + ds.completed_shards = ds.total_shards + break + self.refresh() + # Force log if this is the last dataset to ensure we capture 100% + done, cached, pending, _ = self._get_summary_counts() + is_last = pending == 0 + self._log_progress_to_wandb(force=is_last) + + def report_tokens(self, name: str, tokens: int) -> None: + """Report tokens processed for a dataset (for throughput tracking). + + Args: + name: Dataset name + tokens: Number of tokens processed + """ + for ds in self.datasets: + if ds.name == name: + ds.tokens = tokens + break + self._total_tokens = sum(ds.tokens for ds in self.datasets) + # Log progress with updated token count + self._log_progress_to_wandb() + + def report_metrics(self, name: str, rows: int = 0, tokens: int = 0) -> None: + """Report compute metrics for a dataset. + + Args: + name: Dataset name + rows: Number of rows processed + tokens: Number of tokens processed + """ + import time as time_module + + for ds in self.datasets: + if ds.name == name: + ds.rows_processed = rows + ds.tokens = tokens + # Calculate throughput + if ds.start_time > 0: + elapsed = time_module.time() - ds.start_time + if elapsed > 0: + ds.throughput = rows / elapsed + break + + self._total_tokens = sum(ds.tokens for ds in self.datasets) + self.refresh() + self._log_progress_to_wandb() + + def report_shard_timing(self, stats: dict) -> None: + """Report timing stats from a completed shard for bottleneck analysis. + + Called by Ray Data executor's on_result callback with shard stats dict + containing timing breakdowns: time_download_sec, time_read_sec, + time_tokenize_sec, time_write_sec, time_total_sec. + + Args: + stats: Shard stats dict with timing information + """ + self._bottleneck_metrics.add_shard_stats(stats) + # Log to W&B with throttling for live updates + self._log_progress_to_wandb() + + def report_phase(self, name: str, phase: str, detail: str = "") -> None: + """Report the current processing phase for a dataset. + + Used to show what's happening during long-running operations like + HuggingFace downloads. + + Args: + name: Dataset name + phase: Current phase (e.g., "downloading", "reading", "tokenizing", "writing") + detail: Optional detail string (e.g., "3/10 files", "15K rows") + """ + for ds in self.datasets: + if ds.name == name: + ds.phase = phase + ds.phase_detail = detail + break + self.refresh() + + +def create_live_status(datasets: list[tuple[str, int]], run_hash: str) -> LiveExecutionStatus: + """Create a live execution status tracker. + + Args: + datasets: List of (name, total_shards) tuples + run_hash: The run hash to display + """ + return LiveExecutionStatus( + datasets=[DatasetStatus(name=name, total_shards=total) for name, total in datasets], + run_hash=run_hash, + ) diff --git a/src/nemotron/data_prep/discovery.py b/src/nemotron/data_prep/discovery.py new file mode 100644 index 0000000..2e7ee62 --- /dev/null +++ b/src/nemotron/data_prep/discovery.py @@ -0,0 +1,369 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Input file discovery for various sources (HuggingFace, S3, GCS, local).""" + +import functools +import logging +import os +import re +from dataclasses import dataclass +from typing import TYPE_CHECKING + +from fsspec import AbstractFileSystem + +from nemotron.data_prep.config import DatasetConfig, FileInfo + +if TYPE_CHECKING: + pass + +logger = logging.getLogger(__name__) + + +@functools.lru_cache(maxsize=32) +def _get_split_pattern(split: str) -> re.Pattern: + """Get compiled regex pattern for split matching. Cached for reuse. + + Matches split as a proper path/filename component: + - train-00000.parquet (hyphen separator) + - train/file.parquet (directory separator) + - train.jsonl (dot before extension) + - data/train (at end of path) + """ + return re.compile(rf"(^|/){re.escape(split)}(-|/|\.|$)") + + +@dataclass +class DatasetMetadata: + """Metadata about a dataset from HuggingFace Hub.""" + + num_rows: int | None = None + size_bytes: int | None = None + num_rows_str: str | None = None + size_str: str | None = None + + +def _format_size(size_bytes: int) -> str: + """Format bytes into human-readable string.""" + for unit in ["B", "KB", "MB", "GB", "TB", "PB"]: + if abs(size_bytes) < 1024: + return f"{size_bytes:.1f} {unit}" if unit != "B" else f"{size_bytes} {unit}" + size_bytes /= 1024 + return f"{size_bytes:.1f} EB" + + +def _format_rows(num_rows: int) -> str: + """Format row count into human-readable string.""" + if num_rows >= 1_000_000_000: + return f"{num_rows / 1_000_000_000:.2f}B" + elif num_rows >= 1_000_000: + return f"{num_rows / 1_000_000:.1f}M" + elif num_rows >= 1_000: + return f"{num_rows / 1_000:.1f}K" + else: + return str(num_rows) + + +def fetch_hf_dataset_metadata( + repo_id: str, + subset: str | None = None, + split: str | None = None, +) -> DatasetMetadata: + """ + Fetch dataset metadata from HuggingFace Dataset Viewer API. + + Args: + repo_id: HuggingFace dataset repo ID (e.g., "nvidia/Nemotron-CC-Math-v1") + subset: Optional subset/config name + split: Optional split name + + Returns: + DatasetMetadata with size and row count info + """ + import json + import urllib.request + + try: + # Build API URL (don't filter by config - do it client-side) + url = f"https://datasets-server.huggingface.co/size?dataset={repo_id}" + + # Create request with optional authentication for gated datasets + request = urllib.request.Request(url) + + # Try to get HuggingFace token for authentication + # Check HF_TOKEN env var first (for remote execution), then local cache + token = os.environ.get("HF_TOKEN") + if not token: + try: + from huggingface_hub import HfFolder + + token = HfFolder.get_token() + except Exception: + pass # huggingface_hub not installed or no token + if token: + request.add_header("Authorization", f"Bearer {token}") + + # Fetch metadata + with urllib.request.urlopen(request, timeout=10) as response: + data = json.loads(response.read().decode()) + + # Extract size info + size_info = data.get("size", {}) + + # If subset specified, look for that config + if subset: + configs = size_info.get("configs", []) + for cfg in configs: + if cfg.get("config") == subset: + # If split specified, look in splits list + if split: + splits = size_info.get("splits", []) + for sp in splits: + if sp.get("config") == subset and sp.get("split") == split: + sp_bytes = sp.get("num_bytes_parquet_files") or sp.get("num_bytes") + return DatasetMetadata( + num_rows=sp.get("num_rows"), + size_bytes=sp_bytes, + num_rows_str=_format_rows(sp["num_rows"]) + if sp.get("num_rows") + else None, + size_str=_format_size(sp_bytes) if sp_bytes else None, + ) + # No split specified, use config totals directly + cfg_rows = cfg.get("num_rows") + cfg_bytes = cfg.get("num_bytes_parquet_files") or cfg.get("num_bytes") + return DatasetMetadata( + num_rows=cfg_rows, + size_bytes=cfg_bytes, + num_rows_str=_format_rows(cfg_rows) if cfg_rows else None, + size_str=_format_size(cfg_bytes) if cfg_bytes else None, + ) + + # No subset, use dataset totals + dataset_info = size_info.get("dataset", {}) + num_rows = dataset_info.get("num_rows") + num_bytes = dataset_info.get("num_bytes_parquet_files") or dataset_info.get("num_bytes") + + return DatasetMetadata( + num_rows=num_rows, + size_bytes=num_bytes, + num_rows_str=_format_rows(num_rows) if num_rows else None, + size_str=_format_size(num_bytes) if num_bytes else None, + ) + + except Exception as e: + logger.debug(f"Failed to fetch HF metadata for {repo_id}: {e}") + return DatasetMetadata() + + +def get_dataset_metadata(config: DatasetConfig) -> DatasetMetadata: + """ + Get metadata for a dataset config. + + Currently only supports HuggingFace datasets. + """ + if config.path.startswith("hf://"): + repo_id = config.path[5:] # Remove hf:// prefix + return fetch_hf_dataset_metadata(repo_id, config.subset, config.split) + + # For non-HF datasets, return empty metadata + return DatasetMetadata() + + +def discover_input_files( + config: DatasetConfig, + fs: AbstractFileSystem, +) -> list[FileInfo]: + """ + Discover and enumerate input files with local path resolution. + + Automatically detects source type from path prefix: + - hf:// -> HuggingFace Hub + - s3:// -> S3 + - gs:// -> GCS + - Otherwise -> Local filesystem + """ + path = config.path + + if path.startswith("hf://"): + return discover_hf_files(config) + else: + return discover_filesystem_files(config, fs) + + +def discover_hf_files(config: DatasetConfig) -> list[FileInfo]: + """ + Discover parquet files from HuggingFace dataset. + + Stores HF identity for deferred download - files will be downloaded + inside Ray actors to support multi-node execution. + """ + from huggingface_hub import HfApi + + hf_path = config.path[5:] # Remove hf:// prefix + + # Get token from env var (for remote execution) or local cache + token = os.environ.get("HF_TOKEN") + if not token: + try: + from huggingface_hub import HfFolder + + token = HfFolder.get_token() + except Exception: + pass # No token available + + api = HfApi(token=token) + + # Resolve revision to SHA for determinism + dataset_info = api.dataset_info(hf_path, revision=config.revision) + resolved_revision = dataset_info.sha + + # Find parquet files for the split + files = [] + split = config.split + + for sibling in dataset_info.siblings: + filename = sibling.rfilename + + # Match data files: parquet or jsonl + # Valid extensions: .parquet, .jsonl, .json + is_data_file = ( + filename.endswith(".parquet") + or filename.endswith(".jsonl") + or filename.endswith(".json") + ) + if not is_data_file: + continue + + # Check if subset is specified and matches + # HuggingFace datasets use various patterns: + # - data/{subset}-{split}-00000.parquet (subset as filename prefix) + # - {subset}/{split}-00000.parquet (subset as directory) + # - data/{subset}/{split}-00000.parquet (subset as subdirectory) + # - data/{subset}.jsonl (subset as filename without split) + if config.subset: + subset = config.subset + # Get the base filename without extension for matching + base_filename = filename.rsplit("/", 1)[-1].rsplit(".", 1)[0] + # Check various patterns where subset can appear + if not ( + f"/{subset}/" in filename # subset as directory + or filename.startswith(f"{subset}/") # subset at start as directory + or f"/{subset}-" in filename # subset as filename prefix after path + or f"/{subset}_" in filename # subset with underscore separator + or filename.startswith(f"{subset}-") # subset at start of filename + or filename.startswith(f"{subset}_") # subset with underscore at start + or f"data/{subset}-" in filename # common HF pattern: data/{subset}- + or f"data/{subset}_" in filename # common HF pattern with underscore + or base_filename == subset # exact match: data/{subset}.jsonl + or f"/{subset}." in filename # subset before extension: data/{subset}.jsonl + ): + continue + + # Check if split matches as a proper component (skip if no split specified) + if split and not _matches_split(filename, split): + continue + + # Store HF identity - DO NOT download here (supports multi-node) + files.append( + FileInfo( + path=filename, + local_path=None, # Will be resolved inside actor + size=sibling.size or 0, + etag=sibling.lfs.sha256 if sibling.lfs else None, + hf_repo_id=hf_path, + hf_filename=filename, + hf_revision=resolved_revision, + ) + ) + + return sorted(files, key=lambda f: f.path) + + +def _matches_split(filename: str, split: str) -> bool: + """ + Check if split matches as a proper path/filename component. + + Valid matches: + - "train-00000-of-00001.parquet" (split prefix with hyphen) + - "data/train-00000.parquet" (split after path separator) + - "train/file.parquet" (split as directory) + + Invalid matches: + - "training-data.parquet" (split is substring) + - "retrain-00000.parquet" (split is suffix of word) + """ + # Use cached compiled pattern for efficiency + return bool(_get_split_pattern(split).search(filename)) + + +def discover_filesystem_files( + config: DatasetConfig, + fs: AbstractFileSystem, +) -> list[FileInfo]: + """Discover files from filesystem (local/S3/GCS).""" + path = config.path + + # Expand glob + if "*" in path: + file_paths = sorted(fs.glob(path)) + elif fs.isdir(path): + all_files = fs.listdir(path, detail=False) + file_paths = sorted( + [ + f"{path.rstrip('/')}/{f}" if isinstance(f, str) else f["name"] + for f in all_files + if (isinstance(f, str) and f.endswith((".parquet", ".jsonl", ".json"))) + or ( + isinstance(f, dict) + and f.get("name", "").endswith((".parquet", ".jsonl", ".json")) + ) + ] + ) + else: + file_paths = [path] + + files = [] + for file_path in file_paths: + try: + info = fs.info(file_path) + # Extract mtime for local files (stronger fingerprint) + mtime = None + if "mtime" in info: + mtime = info["mtime"] + elif "LastModified" in info: + # S3 returns datetime + mtime = ( + info["LastModified"].timestamp() + if hasattr(info["LastModified"], "timestamp") + else None + ) + + # Extract version_id for S3/GCS versioned objects + version_id = info.get("VersionId") or info.get("version_id") + + files.append( + FileInfo( + path=file_path, + local_path=file_path, # Same for local/cloud (fsspec handles) + size=info.get("size", 0), + etag=info.get("ETag") or info.get("etag"), + mtime=mtime, + version_id=version_id, + ) + ) + except Exception as e: + logger.warning(f"Failed to get info for {file_path}: {e}") + + return files diff --git a/src/nemotron/data_prep/filesystem.py b/src/nemotron/data_prep/filesystem.py new file mode 100644 index 0000000..1a2f0ab --- /dev/null +++ b/src/nemotron/data_prep/filesystem.py @@ -0,0 +1,69 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Filesystem utilities using fsspec for cloud-native operations.""" + +import json +import os +from typing import Any + +from fsspec import AbstractFileSystem +from fsspec.core import url_to_fs + + +def get_filesystem(path: str) -> tuple[AbstractFileSystem, str]: + """Get filesystem and normalized path from a URI. + + For local paths, resolves '..' and '.' components to produce absolute paths. + This ensures paths in blend.json are fully resolved and portable. + """ + # For local paths (no scheme or file://), normalize first + # This resolves '..' and '.' components + if not path.startswith(("s3://", "gs://", "gcs://", "hdfs://", "http://", "https://")): + # Handle file:// scheme + if path.startswith("file://"): + local_path = path[7:] + resolved = os.path.realpath(local_path) + path = f"file://{resolved}" + else: + # Plain local path - resolve it + path = os.path.realpath(path) + + fs, normalized = url_to_fs(path) + return fs, normalized + + +def read_json(fs: AbstractFileSystem, path: str) -> Any: + """Read JSON file from filesystem.""" + with fs.open(path, "r") as f: + return json.load(f) + + +def write_json(fs: AbstractFileSystem, path: str, data: Any, indent: int = 2) -> None: + """Write JSON file to filesystem.""" + with fs.open(path, "w") as f: + json.dump(data, f, indent=indent) + + +def ensure_dir(fs: AbstractFileSystem, path: str) -> None: + """Ensure directory exists, creating it if necessary.""" + fs.makedirs(path, exist_ok=True) + + +def file_exists(fs: AbstractFileSystem, path: str) -> bool: + """Check if a file exists.""" + try: + return fs.exists(path) + except Exception: + return False diff --git a/src/nemotron/data_prep/formats/__init__.py b/src/nemotron/data_prep/formats/__init__.py new file mode 100644 index 0000000..babf9b8 --- /dev/null +++ b/src/nemotron/data_prep/formats/__init__.py @@ -0,0 +1,54 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Output format implementations.""" + +from nemotron.data_prep.formats.indexed_dataset import IndexedDatasetBuilder +from nemotron.data_prep.formats.jsonl_dataset import JsonlDatasetBuilder +from nemotron.data_prep.formats.transforms import ( + Conversation, + Message, + OpenAIChatRecord, + SftRecord, + SftRecordWithSystem, + ShareGPTRecord, + Transform, + openai_chat, + passthrough, + rename, + select, + sft, + sharegpt, +) + +__all__ = [ + # Writers + "IndexedDatasetBuilder", + "JsonlDatasetBuilder", + # Transform types + "Transform", + "SftRecord", + "SftRecordWithSystem", + "Message", + "OpenAIChatRecord", + "Conversation", + "ShareGPTRecord", + # Transform factories + "sft", + "openai_chat", + "sharegpt", + "passthrough", + "select", + "rename", +] diff --git a/src/nemotron/data_prep/formats/indexed_dataset.py b/src/nemotron/data_prep/formats/indexed_dataset.py new file mode 100644 index 0000000..c72044b --- /dev/null +++ b/src/nemotron/data_prep/formats/indexed_dataset.py @@ -0,0 +1,179 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Streaming builder for Megatron-style .bin/.idx indexed dataset files.""" + +import struct +from typing import BinaryIO + +import numpy as np +import xxhash + +_INDEX_HEADER = b"MMIDIDX\x00\x00" + +DTYPE_CODES = { + np.dtype(np.int32): 4, + np.dtype(np.int64): 5, + np.dtype(np.uint16): 8, +} + + +class IndexedDatasetBuilder: + """ + Streaming builder for .bin/.idx files. + + Writes documents incrementally with streaming checksums. + Uses buffered writes to reduce syscall overhead. + Never holds full shard in memory. + """ + + def __init__( + self, + bin_file: BinaryIO, + dtype: np.dtype = np.int32, + buffer_size: int = 64 * 1024, + ): + self.bin_file = bin_file + self.dtype = np.dtype(dtype) + self._sequence_lengths: list[int] = [] + self._document_indices: list[int] = [0] + self._total_tokens = 0 + self._bin_hasher = xxhash.xxh64() + self._bin_bytes = 0 + self._min_length: float = float("inf") + self._max_length = 0 + + # Write buffer for reducing syscalls + self._write_buffer = bytearray() + self._buffer_size = buffer_size + + def add_document(self, tokens: list[int]) -> None: + """Add single document with buffered write.""" + if not tokens: + return + + arr = np.asarray(tokens, dtype=self.dtype) + data = arr.tobytes(order="C") + + self._write_buffer.extend(data) + self._bin_hasher.update(data) + self._bin_bytes += len(data) + + length = len(arr) + self._sequence_lengths.append(length) + self._document_indices.append(len(self._sequence_lengths)) + self._total_tokens += length + self._min_length = min(self._min_length, length) + self._max_length = max(self._max_length, length) + + # Flush when buffer is full + if len(self._write_buffer) >= self._buffer_size: + self._flush_buffer() + + def add_documents(self, token_lists: list[list[int]]) -> None: + """ + Batch add documents - reduces numpy allocation overhead. + + Concatenates all tokens for a single numpy conversion, + then writes to buffer in one operation. + """ + if not token_lists: + return + + # Filter empty lists and collect lengths + all_tokens: list[int] = [] + lengths: list[int] = [] + for tokens in token_lists: + if tokens: + all_tokens.extend(tokens) + lengths.append(len(tokens)) + + if not lengths: + return + + # Single numpy allocation for all tokens + arr = np.array(all_tokens, dtype=self.dtype) + data = arr.tobytes(order="C") + + self._write_buffer.extend(data) + self._bin_hasher.update(data) + self._bin_bytes += len(data) + + # Track metadata for each document + for length in lengths: + self._sequence_lengths.append(length) + self._document_indices.append(len(self._sequence_lengths)) + self._total_tokens += length + self._min_length = min(self._min_length, length) + self._max_length = max(self._max_length, length) + + # Flush when buffer is full + if len(self._write_buffer) >= self._buffer_size: + self._flush_buffer() + + def _flush_buffer(self) -> None: + """Flush write buffer to file.""" + if self._write_buffer: + self.bin_file.write(self._write_buffer) + self._write_buffer.clear() + + def finalize(self) -> None: + """Flush remaining buffer. Call before get_bin_info or write_index.""" + self._flush_buffer() + + def get_bin_info(self) -> tuple[int, str]: + """Get bin file size and checksum. Flushes buffer first.""" + self._flush_buffer() + return self._bin_bytes, f"xxh64:{self._bin_hasher.hexdigest()}" + + def write_index(self, idx_file: BinaryIO) -> tuple[int, str]: + """Write index file, return size and checksum.""" + sequence_count = len(self._sequence_lengths) + document_count = len(self._document_indices) + + # Calculate pointers + lengths = np.array(self._sequence_lengths, dtype=np.int64) + pointers = np.zeros(sequence_count, dtype=np.int64) + if sequence_count > 1: + pointers[1:] = np.cumsum(lengths[:-1] * self.dtype.itemsize) + + idx_hasher = xxhash.xxh64() + idx_bytes = 0 + + def write_and_hash(data: bytes) -> None: + nonlocal idx_bytes + idx_file.write(data) + idx_hasher.update(data) + idx_bytes += len(data) + + write_and_hash(_INDEX_HEADER) + write_and_hash(struct.pack(" dict: + """Get statistics.""" + return { + "num_sequences": len(self._sequence_lengths), + "num_documents": max(0, len(self._document_indices) - 1), + "total_tokens": self._total_tokens, + "min_length": int(self._min_length) if self._sequence_lengths else 0, + "max_length": int(self._max_length) if self._sequence_lengths else 0, + } diff --git a/src/nemotron/data_prep/formats/jsonl_dataset.py b/src/nemotron/data_prep/formats/jsonl_dataset.py new file mode 100644 index 0000000..4363351 --- /dev/null +++ b/src/nemotron/data_prep/formats/jsonl_dataset.py @@ -0,0 +1,173 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Streaming JSONL writer with optional compression. + +Uses orjson for fast serialization and zstandard for compression. +""" + +from collections.abc import Callable +from typing import BinaryIO, Literal + +import xxhash + +try: + import orjson + + def _dumps(obj: dict) -> bytes: + return orjson.dumps(obj) + +except ImportError: + import json + + def _dumps(obj: dict) -> bytes: + return json.dumps(obj, ensure_ascii=False).encode("utf-8") + + +try: + import zstandard as zstd + + _HAS_ZSTD = True +except ImportError: + _HAS_ZSTD = False + + +class JsonlDatasetBuilder: + """Streaming JSONL writer with checksums and optional zstd compression. + + Uses orjson for fast serialization (following nvdata pattern). + Writes incrementally with buffering to reduce syscall overhead. + """ + + def __init__( + self, + file: BinaryIO, + transform: Callable[[dict], dict | None] | None = None, + compression: Literal["none", "zstd"] = "none", + buffer_size: int = 64 * 1024, + ): + """Initialize JSONL writer. + + Args: + file: Binary file handle to write to. + transform: Optional callable to transform records. Returns dict or None to skip. + compression: Output compression ("none" or "zstd"). + buffer_size: Write buffer size in bytes. + """ + self._file = file + self._transform = transform or (lambda x: x) + self._compression = compression + self._buffer_size = buffer_size + + # Stats + self._num_records = 0 + self._num_skipped = 0 + self._total_bytes = 0 + + # Checksum + self._hasher = xxhash.xxh64() + + # Write buffer + self._write_buffer = bytearray() + + # Setup compression + if compression == "zstd": + if not _HAS_ZSTD: + raise ImportError( + "zstandard package required for zstd compression. " + "Install with: pip install zstandard" + ) + self._compressor = zstd.ZstdCompressor() + self._writer = self._compressor.stream_writer(file) + else: + self._writer = file + self._compressor = None + + def add_record(self, record: dict) -> bool: + """Add record, apply transform, write. + + Args: + record: Input record dict. + + Returns: + True if record was written, False if filtered by transform. + """ + transformed = self._transform(record) + if transformed is None: + self._num_skipped += 1 + return False + + # orjson returns bytes directly + line = _dumps(transformed) + b"\n" + self._hasher.update(line) + self._total_bytes += len(line) + + self._write_buffer.extend(line) + self._num_records += 1 + + # Flush when buffer is full + if len(self._write_buffer) >= self._buffer_size: + self._flush_buffer() + + return True + + def add_records(self, records: list[dict]) -> int: + """Batch add records. + + Args: + records: List of input record dicts. + + Returns: + Number of records written (not skipped). + """ + written = 0 + for record in records: + if self.add_record(record): + written += 1 + return written + + def _flush_buffer(self) -> None: + """Flush write buffer to file.""" + if self._write_buffer: + self._writer.write(self._write_buffer) + self._write_buffer.clear() + + def finalize(self) -> None: + """Flush buffers and close compressor if used.""" + self._flush_buffer() + if self._compressor is not None: + self._writer.close() + + def get_info(self) -> tuple[int, str]: + """Get bytes written and checksum. + + Returns: + Tuple of (bytes_written, checksum_string). + """ + return self._total_bytes, f"xxh64:{self._hasher.hexdigest()}" + + def get_stats(self) -> dict: + """Get writer statistics. + + Returns: + Dict with num_records, num_skipped, total_bytes. + """ + return { + "num_records": self._num_records, + "num_skipped": self._num_skipped, + "total_bytes": self._total_bytes, + } + + +__all__ = ["JsonlDatasetBuilder"] diff --git a/src/nemotron/data_prep/formats/transforms.py b/src/nemotron/data_prep/formats/transforms.py new file mode 100644 index 0000000..a38e98d --- /dev/null +++ b/src/nemotron/data_prep/formats/transforms.py @@ -0,0 +1,335 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Transform functions for JSONL output formats. + +Provides factory functions and TypedDicts for common SFT/RL data formats. +""" + +from collections.abc import Callable +from typing import TypedDict + +# ============================================================================= +# Type definitions for common output formats +# ============================================================================= + + +class SftRecord(TypedDict): + """Megatron-Bridge GPTSFTDataset format.""" + + input: str + output: str + + +class SftRecordWithSystem(TypedDict, total=False): + """SFT format with optional system prompt.""" + + input: str + output: str + system: str + + +class Message(TypedDict): + """OpenAI chat message.""" + + role: str # "system" | "user" | "assistant" + content: str + + +class OpenAIChatRecord(TypedDict): + """OpenAI/RL format - used by OpenAIFormatDataset.""" + + messages: list[Message] + + +class Conversation(TypedDict): + """ShareGPT conversation turn.""" + + from_: str # "human" | "gpt" | "system" (serialized as "from") + value: str + + +class ShareGPTRecord(TypedDict): + """ShareGPT format - used by GPTSFTChatDataset.""" + + conversations: list[Conversation] + + +# Transform is any callable: dict -> dict | None (None = skip record) +Transform = Callable[[dict], dict | None] + + +# ============================================================================= +# Factory functions for common transforms +# ============================================================================= + + +def sft(*, input: str = "input", output: str = "output", system: str | None = None) -> Transform: + """Create SFT transform: extracts input/output fields. + + Args: + input: Source field name for input text. + output: Source field name for output text. + system: Optional source field name for system prompt. + + Returns: + Transform function producing SftRecord. + + Example: + >>> transform = sft(input="instruction", output="response") + >>> transform({"instruction": "Hello", "response": "Hi there!"}) + {'input': 'Hello', 'output': 'Hi there!'} + """ + input_field = input # Avoid shadowing builtin + output_field = output + + def transform(record: dict) -> SftRecord | SftRecordWithSystem | None: + try: + result: dict = { + "input": record[input_field], + "output": record[output_field], + } + if system and system in record: + result["system"] = record[system] + return result # type: ignore + except KeyError: + return None + + return transform + + +def openai_chat(*, messages: str = "messages") -> Transform: + """Create OpenAI chat transform: extracts messages field. + + Args: + messages: Source field name for messages list. + + Returns: + Transform function producing OpenAIChatRecord. + + Example: + >>> transform = openai_chat() + >>> transform({"messages": [{"role": "user", "content": "Hi"}]}) + {'messages': [{'role': 'user', 'content': 'Hi'}]} + """ + messages_field = messages + + def transform(record: dict) -> OpenAIChatRecord | None: + try: + return {"messages": record[messages_field]} + except KeyError: + return None + + return transform + + +def sharegpt(*, conversations: str = "conversations") -> Transform: + """Create ShareGPT transform: extracts conversations field. + + Args: + conversations: Source field name for conversations list. + + Returns: + Transform function producing ShareGPTRecord. + + Example: + >>> transform = sharegpt(conversations="turns") + >>> transform({"turns": [{"from": "human", "value": "Hi"}]}) + {'conversations': [{'from': 'human', 'value': 'Hi'}]} + """ + conversations_field = conversations + + def transform(record: dict) -> ShareGPTRecord | None: + try: + return {"conversations": record[conversations_field]} + except KeyError: + return None + + return transform + + +def nemotron_rl() -> Transform: + """Extract messages and tools from Nemotron RL dataset format. + + Nemotron RL datasets store messages in `responses_create_params.input` + and optionally tools in `responses_create_params.tools`. + + Returns: + Transform function producing OpenAIChatRecord with optional tools. + + Example: + >>> transform = nemotron_rl() + >>> transform({ + ... "responses_create_params": { + ... "input": [{"role": "user", "content": "Hi"}], + ... "tools": [{"name": "search", ...}] + ... } + ... }) + {'messages': [{'role': 'user', 'content': 'Hi'}], 'tools': [...]} + """ + + def transform(record: dict) -> dict | None: + try: + params = record["responses_create_params"] + result: dict = {"messages": params["input"]} + if "tools" in params and params["tools"]: + result["tools"] = params["tools"] + return result + except (KeyError, TypeError): + return None + + return transform + + +def passthrough() -> Transform: + """Pass records through unchanged. + + Returns: + Transform function that returns records as-is. + + Example: + >>> transform = passthrough() + >>> transform({"any": "data"}) + {'any': 'data'} + """ + return lambda record: record + + +def select(*fields: str) -> Transform: + """Create transform that selects specific fields. + + Args: + *fields: Field names to include in output. + + Returns: + Transform function that extracts only the specified fields. + + Example: + >>> transform = select("id", "text") + >>> transform({"id": 1, "text": "hello", "extra": "ignored"}) + {'id': 1, 'text': 'hello'} + """ + + def transform(record: dict) -> dict | None: + try: + return {f: record[f] for f in fields} + except KeyError: + return None + + return transform + + +def rename(**field_mapping: str) -> Transform: + """Create transform that renames fields. + + Args: + **field_mapping: Mapping from new names to source field names. + + Returns: + Transform function that extracts and renames fields. + + Example: + >>> transform = rename(input="question", output="answer") + >>> transform({"question": "What?", "answer": "This."}) + {'input': 'What?', 'output': 'This.'} + """ + + def transform(record: dict) -> dict | None: + try: + return {new_name: record[old_name] for new_name, old_name in field_mapping.items()} + except KeyError: + return None + + return transform + + +def resolve_hf_placeholders( + resolver: "HFPlaceholderResolver | None" = None, +) -> Transform: + """Create transform that resolves HuggingFace placeholder records. + + For records with `_hf_placeholder` field: + - Fetches the actual data from external HF dataset (DAPO, Skywork) + - Applies template restoration (prefix/suffix or {question} replacement) + - Returns record with question, expected_answer, and responses_create_params + + For records without `_hf_placeholder`: + - Falls back to nemotron_rl() extraction (responses_create_params.input) + + Args: + resolver: Pre-initialized HFPlaceholderResolver. If None, one will be + created on first use (lazy initialization). + + Returns: + Transform function that resolves placeholders or extracts RL format. + + Example: + >>> from nemotron.data_prep.hf_placeholder import HFPlaceholderResolver + >>> resolver = HFPlaceholderResolver.create() + >>> transform = resolve_hf_placeholders(resolver) + >>> # For placeholder record: + >>> transform({"_hf_placeholder": {"row": 0, ...}, "dataset": "..."}) + {'question': '...', 'expected_answer': '...', 'responses_create_params': {...}} + >>> # For normal record: + >>> transform({"responses_create_params": {"input": [...]}}) + {'messages': [...]} + """ + from nemotron.data_prep.hf_placeholder import HFPlaceholderResolver + + # Mutable container for lazy initialization + _resolver_holder: list[HFPlaceholderResolver | None] = [resolver] + + def get_resolver() -> HFPlaceholderResolver: + if _resolver_holder[0] is None: + _resolver_holder[0] = HFPlaceholderResolver.create() + return _resolver_holder[0] + + # Get the nemotron_rl transform for non-placeholder records + rl_transform = nemotron_rl() + + def transform(record: dict) -> dict | None: + # Check if this is a placeholder record + if "_hf_placeholder" in record: + resolver = get_resolver() + resolved = resolver.resolve(record) + if resolved is not None: + return resolved + # If resolution fails, skip the record + return None + + # Not a placeholder - use nemotron_rl extraction + return rl_transform(record) + + return transform + + +__all__ = [ + # Type definitions + "Transform", + "SftRecord", + "SftRecordWithSystem", + "Message", + "OpenAIChatRecord", + "Conversation", + "ShareGPTRecord", + # Factory functions + "sft", + "openai_chat", + "nemotron_rl", + "sharegpt", + "passthrough", + "select", + "rename", + "resolve_hf_placeholders", +] diff --git a/src/nemotron/data_prep/hf_placeholder.py b/src/nemotron/data_prep/hf_placeholder.py new file mode 100644 index 0000000..7b1354c --- /dev/null +++ b/src/nemotron/data_prep/hf_placeholder.py @@ -0,0 +1,367 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""HuggingFace placeholder resolution for RL datasets. + +The nvidia/Nemotron-3-Nano-RL-Training-Blend dataset contains placeholder entries +for external datasets (DAPO, Skywork). These placeholders have an `_hf_placeholder` +field containing row indices and question templates that need to be resolved by +fetching the actual data from HuggingFace. + +This module provides: +- Configuration for target datasets (HF repos, field paths, template types) +- Helper functions for template restoration (DAPO prefix/suffix, Skywork {question}) +- Main resolution function that transforms placeholder records into full records +""" + +from __future__ import annotations + +import logging +from dataclasses import dataclass +from typing import Any + +logger = logging.getLogger(__name__) + + +# Configuration for placeholder datasets that need resolution +# Maps dataset names (as they appear in the blend) to their HF source info +# Reference: https://huggingface.co/datasets/nvidia/Nemotron-3-Nano-RL-Training-Blend/blob/main/create_nanov3_jsonl.py +TARGET_DATASETS: dict[str, dict[str, Any]] = { + "nano_v3_sft_profiled_dapo17k": { + "hf_dataset": "BytedTsinghua-SIA/DAPO-Math-17k", + "split": "train", + "question_path": ["prompt", 0, "content"], + "answer_path": ["reward_model", "ground_truth"], + "template_type": "dapo", + }, + "nano_v3_sft_profiled_skywork_no_omni": { + "hf_dataset": "Skywork/Skywork-OR1-RL-Data", + "split": "math", + "question_path": ["prompt", 0, "content"], + "answer_path": ["reward_model", "ground_truth"], + "template_type": "skywork", + }, +} + + +@dataclass +class PlaceholderConfig: + """Configuration for a single placeholder dataset.""" + + hf_dataset: str + split: str + question_path: list[str | int] + answer_path: list[str | int] + template_type: str # "dapo" or "skywork" + + +def get_nested_value(record: dict, path: list[str | int]) -> Any: + """Extract a value from a nested dict/list using a path. + + Args: + record: The source record (dict or nested structure) + path: List of keys/indices to traverse + + Returns: + The value at the path, or None if not found + + Example: + >>> get_nested_value({"a": [{"b": "value"}]}, ["a", 0, "b"]) + 'value' + """ + value: Any = record + for key in path: + if value is None: + return None + if isinstance(value, dict): + value = value.get(key) + elif isinstance(value, list) and isinstance(key, int): + value = value[key] if 0 <= key < len(value) else None + else: + return None + return value + + +def restore_dapo_question(hf_question: str, template: dict) -> str: + """Restore DAPO question using prefix/suffix from template. + + DAPO templates have the structure: + { + "prefix": "... ", + "suffix": " ..." + } + + The original question from HF is wrapped with prefix and suffix. + + Args: + hf_question: The raw question text from the HF dataset + template: Dict with "prefix" and/or "suffix" keys + + Returns: + Full question with template applied + """ + prefix = template.get("prefix", "") + suffix = template.get("suffix", "") + return f"{prefix}{hf_question}{suffix}" + + +def restore_skywork_question(hf_question: str, template: str) -> str: + """Restore Skywork question by replacing {question} placeholder. + + Skywork templates have {question} placeholders that need to be replaced + with the actual question from HuggingFace. + + Args: + hf_question: The raw question text from the HF dataset + template: Template string containing {question} placeholder + + Returns: + Full question with placeholder replaced + """ + if "{question}" in template: + return template.replace("{question}", hf_question) + # Fallback if no placeholder found + return hf_question + + +@dataclass +class HFPlaceholderResolver: + """Resolver for HuggingFace placeholder records. + + Pre-loads external HF datasets using ray.data.from_huggingface() for + scalable distributed loading, then materializes to PyArrow tables + for efficient row-index access during placeholder resolution. + + Usage: + >>> resolver = HFPlaceholderResolver.create() + >>> resolved = resolver.resolve(placeholder_record) + """ + + tables: dict[str, Any] # dataset name -> PyArrow Table for indexed access + configs: dict[str, PlaceholderConfig] # dataset name -> config + + @classmethod + def create(cls, target_datasets: dict[str, dict] | None = None) -> "HFPlaceholderResolver": + """Create a resolver with pre-loaded HF datasets via Ray. + + Uses ray.data.from_huggingface() for scalable dataset loading, + then materializes to PyArrow tables for efficient row-index access. + + Args: + target_datasets: Optional custom target dataset config. + Defaults to TARGET_DATASETS. + + Returns: + Initialized resolver with loaded datasets + """ + import pyarrow as pa + + if target_datasets is None: + target_datasets = TARGET_DATASETS + + tables: dict[str, pa.Table] = {} + configs: dict[str, PlaceholderConfig] = {} + + for name, cfg in target_datasets.items(): + config = PlaceholderConfig( + hf_dataset=cfg["hf_dataset"], + split=cfg["split"], + question_path=cfg["question_path"], + answer_path=cfg["answer_path"], + template_type=cfg["template_type"], + ) + configs[name] = config + + logger.info(f"Loading HF dataset: {config.hf_dataset} (split: {config.split})") + try: + # Load parquet files directly from HuggingFace Hub using huggingface_hub + # This avoids datasets library internal API compatibility issues + from huggingface_hub import HfFileSystem + + fs = HfFileSystem() + + # Try multiple patterns since HF datasets have varying structures: + # 1. data/{split}-*.parquet (e.g., Skywork: data/math-00000-of-00001.parquet) + # 2. data/*.parquet (e.g., DAPO: data/dapo-math-17k.parquet - single file) + # 3. {split}/*.parquet (standard split directory) + # 4. default/{split}/*.parquet (default config) + patterns = [ + f"datasets/{config.hf_dataset}/data/{config.split}-*.parquet", + f"datasets/{config.hf_dataset}/data/*.parquet", + f"datasets/{config.hf_dataset}/{config.split}/*.parquet", + f"datasets/{config.hf_dataset}/default/{config.split}/*.parquet", + ] + + parquet_files = [] + for pattern in patterns: + parquet_files = fs.glob(pattern) + if parquet_files: + logger.info(f"Found parquet files with pattern: {pattern}") + break + + if parquet_files: + # Read all parquet files and concatenate + import pyarrow.parquet as pq + + tables_list = [] + for pq_file in parquet_files: + with fs.open(pq_file, "rb") as f: + table = pq.read_table(f) + tables_list.append(table) + + if tables_list: + arrow_table = pa.concat_tables(tables_list) + tables[name] = arrow_table + logger.info(f"Loaded {len(arrow_table)} rows from {config.hf_dataset}") + else: + logger.warning(f"No data found in parquet files for {config.hf_dataset}") + tables[name] = None + else: + logger.warning( + f"No parquet files found for {config.hf_dataset} split={config.split}" + ) + tables[name] = None + except Exception as e: + logger.warning(f"Failed to load {config.hf_dataset}: {e}") + tables[name] = None + + return cls(tables=tables, configs=configs) + + def get_loaded_datasets_info(self) -> list[dict[str, Any]]: + """Return metadata about loaded external datasets for lineage tracking. + + Returns: + List of dicts with dataset info (uri, name, split, num_rows, etc.) + for each successfully loaded external dataset. + """ + datasets_info = [] + for name, config in self.configs.items(): + table = self.tables.get(name) + if table is not None: + datasets_info.append({ + "uri": f"hf://{config.hf_dataset}", + "name": name, + "split": config.split, + "num_rows": len(table), + "source_type": "hf_placeholder", + }) + return datasets_info + + def resolve(self, record: dict) -> dict | None: + """Resolve a placeholder record to its full content. + + Args: + record: Record from source dataset with _hf_placeholder field + + Returns: + Resolved record with full question/answer and responses_create_params, + or None if resolution fails + """ + placeholder = record.get("_hf_placeholder") + if placeholder is None: + return None # Not a placeholder record + + dataset_name = record.get("dataset") + if dataset_name not in self.configs: + logger.debug(f"Unknown dataset in placeholder: {dataset_name}") + return None + + config = self.configs[dataset_name] + table = self.tables.get(dataset_name) + if table is None: + logger.warning(f"Dataset not loaded: {dataset_name}") + return None + + # Get row index and template from placeholder + row_idx = placeholder.get("row") + question_template = placeholder.get("question_template") + + if row_idx is None: + logger.warning(f"Missing row index in placeholder for {dataset_name}") + return None + + if row_idx < 0 or row_idx >= len(table): + logger.warning( + f"Row index {row_idx} out of bounds for {dataset_name} " + f"(size: {len(table)})" + ) + return None + + # Fetch the actual record from PyArrow table + try: + # Slice single row and convert to dict + row_table = table.slice(row_idx, 1) + row_dict = row_table.to_pydict() + # Convert from {col: [value]} to {col: value} + hf_record = {k: v[0] if v else None for k, v in row_dict.items()} + except Exception as e: + logger.warning(f"Failed to fetch row {row_idx} from {dataset_name}: {e}") + return None + + # Extract question and answer using configured paths + hf_question = get_nested_value(hf_record, config.question_path) + answer = get_nested_value(hf_record, config.answer_path) + + if hf_question is None: + logger.warning( + f"Could not extract question from {dataset_name} row {row_idx} " + f"using path {config.question_path}" + ) + return None + + # Restore full question using template + if config.template_type == "dapo": + if isinstance(question_template, dict): + full_question = restore_dapo_question(str(hf_question), question_template) + else: + full_question = str(hf_question) + elif config.template_type == "skywork": + if isinstance(question_template, str): + full_question = restore_skywork_question(str(hf_question), question_template) + else: + full_question = str(hf_question) + else: + full_question = str(hf_question) + + # Build output record + return { + "question": full_question, + "expected_answer": answer, + "responses_create_params": { + "input": [{"role": "user", "content": full_question}] + }, + } + + +def is_placeholder_record(record: dict) -> bool: + """Check if a record is a placeholder that needs resolution. + + Args: + record: Record to check + + Returns: + True if record has _hf_placeholder field + """ + return "_hf_placeholder" in record + + +__all__ = [ + "TARGET_DATASETS", + "PlaceholderConfig", + "HFPlaceholderResolver", + "get_nested_value", + "restore_dapo_question", + "restore_skywork_question", + "is_placeholder_record", +] diff --git a/src/nemotron/data_prep/jsonl_processor.py b/src/nemotron/data_prep/jsonl_processor.py new file mode 100644 index 0000000..54c654d --- /dev/null +++ b/src/nemotron/data_prep/jsonl_processor.py @@ -0,0 +1,237 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""JsonlShardProcessor Ray actor for parallel JSONL output processing.""" + +import json +import logging +import time +from collections.abc import Callable, Iterator + +import pyarrow.parquet as pq +import ray +from fsspec import filesystem + +from nemotron.data_prep.config import FileInfo +from nemotron.data_prep.filesystem import ensure_dir, write_json +from nemotron.data_prep.formats.jsonl_dataset import JsonlDatasetBuilder + +logger = logging.getLogger(__name__) + + +@ray.remote +class JsonlShardProcessor: + """Ray actor for processing data files to JSONL output. + + Reads input files (parquet or jsonl), applies optional transform, + and writes to JSONL output (optionally compressed). + """ + + def __init__( + self, + text_field: str, + transform: Callable[[dict], dict | None] | None = None, + compression: str = "none", + max_rows: int | None = None, + ): + """Initialize JSONL processor. + + Args: + text_field: Field name for text in input records. + transform: Optional callable to transform records. + compression: Output compression ("none" or "zstd"). + max_rows: Maximum rows to process per shard. + """ + self.text_field = text_field + self.transform = transform + self.compression = compression + self.max_rows = max_rows + + def process_shard( + self, + shard_index: int, + files: list[dict], # FileInfo as dicts for Ray serialization + output_dir: str, + fs_protocol: str, + ) -> dict: + """Process files to a single JSONL shard. + + Args: + shard_index: Index of this shard. + files: List of FileInfo dicts to process. + output_dir: Output directory for JSONL files. + fs_protocol: Filesystem protocol (e.g., "file", "s3"). + + Returns: + Shard statistics dict. + """ + fs = filesystem(fs_protocol) + + shard_id = f"shard_{shard_index:06d}" + ext = ".jsonl.zst" if self.compression == "zstd" else ".jsonl" + jsonl_path = f"{output_dir}/{shard_id}{ext}" + receipt_path = f"{output_dir}/{shard_id}.receipt.json" + + # Ensure directory exists + ensure_dir(fs, output_dir) + + # Convert file dicts back to FileInfo + file_infos = [FileInfo(**f) for f in files] + + # Handle empty assignment + if not file_infos: + return self._write_empty_receipt(shard_id, shard_index, receipt_path, fs) + + # Process files and write JSONL + with fs.open(jsonl_path, "wb") as f: + builder = JsonlDatasetBuilder( + file=f, + transform=self.transform, + compression=self.compression, + ) + + rows_processed = 0 + for file_info in file_infos: + if self.max_rows and rows_processed >= self.max_rows: + break + rows_processed = self._process_file(file_info, builder, fs, rows_processed) + + builder.finalize() + total_bytes, checksum = builder.get_info() + stats = builder.get_stats() + + # Write receipt + receipt = { + "shard_id": shard_id, + "shard_index": shard_index, + "status": "completed", + "created_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()), + "input_files": [f.path for f in file_infos], + "output_file": f"{shard_id}{ext}", + "total_bytes": total_bytes, + "checksum": checksum, + **stats, + } + + write_json(fs, receipt_path, receipt) + return stats + + def _process_file( + self, + file_info: FileInfo, + builder: JsonlDatasetBuilder, + fs, + rows_processed: int, + ) -> int: + """Process a single file, writing records to builder. + + Returns the total number of rows processed. + """ + local_path = self._resolve_file_path(file_info) + + # Determine file type + is_parquet = local_path.endswith(".parquet") or not ( + local_path.endswith(".jsonl") or local_path.endswith(".json") + ) + + if is_parquet: + for record in self._iter_parquet_records(local_path, fs): + if self.max_rows and rows_processed >= self.max_rows: + break + builder.add_record(record) + rows_processed += 1 + else: + for record in self._iter_jsonl_records(local_path, fs): + if self.max_rows and rows_processed >= self.max_rows: + break + builder.add_record(record) + rows_processed += 1 + + return rows_processed + + def _resolve_file_path(self, file_info: FileInfo) -> str: + """Resolve file to a local path, downloading from HF if needed.""" + if file_info.hf_repo_id is not None: + from huggingface_hub import hf_hub_download + + local_path = hf_hub_download( + repo_id=file_info.hf_repo_id, + filename=file_info.hf_filename, + revision=file_info.hf_revision, + repo_type="dataset", + local_files_only=False, + ) + return local_path + + return file_info.local_path or file_info.path + + def _iter_parquet_records(self, path: str, fs) -> Iterator[dict]: + """Iterate records from parquet file.""" + if self._is_remote_path(path): + with fs.open(path, "rb") as f: + parquet_file = pq.ParquetFile(f) + yield from self._iter_parquet_batches_as_dicts(parquet_file) + else: + parquet_file = pq.ParquetFile(path) + yield from self._iter_parquet_batches_as_dicts(parquet_file) + + def _iter_parquet_batches_as_dicts(self, parquet_file: pq.ParquetFile) -> Iterator[dict]: + """Iterate records from parquet file as dicts.""" + for batch in parquet_file.iter_batches(batch_size=10000): + # Convert batch to list of dicts + table = batch.to_pydict() + num_rows = len(next(iter(table.values()))) + for i in range(num_rows): + yield {k: v[i] for k, v in table.items()} + + def _iter_jsonl_records(self, path: str, fs) -> Iterator[dict]: + """Iterate records from JSONL file.""" + if self._is_remote_path(path): + with fs.open(path, "r") as f: + for line in f: + if line.strip(): + yield json.loads(line) + else: + with open(path) as f: + for line in f: + if line.strip(): + yield json.loads(line) + + def _is_remote_path(self, path: str) -> bool: + """Check if path is a remote path (S3/GCS/etc).""" + return path.startswith(("s3://", "gs://", "gcs://", "az://", "abfs://")) + + def _write_empty_receipt( + self, + shard_id: str, + shard_index: int, + receipt_path: str, + fs, + ) -> dict: + """Write receipt for empty shard.""" + receipt = { + "shard_id": shard_id, + "shard_index": shard_index, + "status": "completed", + "created_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()), + "input_files": [], + "output_file": None, + "total_bytes": 0, + "checksum": "xxh64:empty", + "num_records": 0, + "num_skipped": 0, + } + + write_json(fs, receipt_path, receipt) + return {"num_records": 0, "num_skipped": 0, "total_bytes": 0} diff --git a/src/nemotron/data_prep/packed_processor.py b/src/nemotron/data_prep/packed_processor.py new file mode 100644 index 0000000..87a578c --- /dev/null +++ b/src/nemotron/data_prep/packed_processor.py @@ -0,0 +1,503 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""PackedShardProcessor Ray actor for parallel packed sequence output processing.""" + +import json +import logging +import time +from collections.abc import Iterator + +import numpy as np +import pyarrow.parquet as pq +import ray +from fsspec import filesystem + +from nemotron.data_prep.config import FileInfo +from nemotron.data_prep.filesystem import ensure_dir, write_json +from nemotron.data_prep.packing.builder import PackedSequenceBuilder +from nemotron.data_prep.providers import create_tokenizer + +logger = logging.getLogger(__name__) + + +@ray.remote +class PackedShardProcessor: + """Ray actor for processing data files to packed sequence output. + + Reads input files (parquet or jsonl), tokenizes text, packs sequences + using the specified algorithm, and writes to .npy files compatible + with Megatron-Bridge's GPTSFTPackedDataset. + """ + + def __init__( + self, + resolved_tokenizer: dict, + text_field: str, + pack_size: int, + algorithm: str, + dtype: str, + min_doc_chars: int | None = None, + max_doc_tokens: int | None = None, + max_rows: int | None = None, + seed: int | None = None, + ): + """Initialize packed processor. + + Args: + resolved_tokenizer: Tokenizer configuration dict with resolved SHA. + text_field: Field name for text in input records. + pack_size: Maximum tokens per packed sequence. + algorithm: Packing algorithm ("first_fit_decreasing", "first_fit_shuffle", etc). + dtype: Token dtype for output. + min_doc_chars: Skip documents shorter than this. + max_doc_tokens: Truncate documents longer than this. + max_rows: Maximum rows to process per shard. + seed: Random seed for shuffle-based algorithms. + """ + self.text_field = text_field + self.pack_size = pack_size + self.algorithm = algorithm + self.dtype = np.dtype(dtype) + self.min_doc_chars = min_doc_chars + self.max_doc_tokens = max_doc_tokens + self.max_rows = max_rows + self.seed = seed + + # Load tokenizer ONCE + self._tokenize = create_tokenizer(resolved_tokenizer) + self.vocab_size = self._tokenize.vocab_size + + def process_shard( + self, + shard_index: int, + files: list[dict], # FileInfo as dicts for Ray serialization + output_dir: str, + receipts_dir: str, + fs_protocol: str, + ) -> dict: + """Process files to a single packed shard. + + Args: + shard_index: Index of this shard. + files: List of FileInfo dicts to process. + output_dir: Output directory for .npy files. + receipts_dir: Directory for receipt files. + fs_protocol: Filesystem protocol (e.g., "file", "s3"). + + Returns: + Shard statistics dict. + """ + fs = filesystem(fs_protocol) + + shard_id = f"shard_{shard_index:06d}" + npy_path = f"{output_dir}/{shard_id}.npy" + receipt_path = f"{receipts_dir}/{shard_id}.json" + + # Ensure directories + ensure_dir(fs, output_dir) + ensure_dir(fs, receipts_dir) + + # Stats tracking + stats = { + "num_input_rows": 0, + "num_filtered": 0, + "num_truncated": 0, + "num_errors": 0, + } + + # Convert file dicts back to FileInfo + file_infos = [FileInfo(**f) for f in files] + input_file_paths = [f.path for f in file_infos] + + # Handle empty assignment + if not file_infos: + return self._write_empty_receipt( + shard_id, + shard_index, + input_file_paths, + stats, + receipt_path, + fs, + ) + + # Create packing builder + builder = PackedSequenceBuilder( + pack_size=self.pack_size, + algorithm=self.algorithm, + seed=self.seed, + dtype=str(self.dtype), + ) + + # Track rows processed across files for max_rows limit + rows_processed = 0 + + # Process files SEQUENTIALLY for determinism + for file_info in file_infos: + rows_processed = self._process_file(file_info, builder, stats, fs, rows_processed) + # Stop if we've hit max_rows + if self.max_rows and rows_processed >= self.max_rows: + break + + # Finalize packing + packed_data, packing_metadata = builder.finalize() + + # Handle empty result (all rows filtered) + if not packed_data: + return self._write_empty_receipt( + shard_id, + shard_index, + input_file_paths, + stats, + receipt_path, + fs, + ) + + # Save packed data as .npy + # Use allow_pickle=True for list of dicts format + with fs.open(npy_path, "wb") as f: + np.save(f, packed_data, allow_pickle=True) + + # Get file size + npy_bytes = fs.size(npy_path) + + # Write receipt (commits the shard) + receipt = { + "shard_id": shard_id, + "shard_index": shard_index, + "status": "completed", + "created_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()), + "input_files": input_file_paths, + "output_file": f"{shard_id}.npy", + "npy_bytes": npy_bytes, + "packing": packing_metadata, + "stats": { + "num_sequences": packing_metadata["num_sequences"], + "num_packed_sequences": packing_metadata["num_packed_sequences"], + "total_tokens": packing_metadata["total_tokens"], + **stats, + }, + } + + write_json(fs, receipt_path, receipt) + return receipt["stats"] + + def _process_file( + self, + file_info: FileInfo, + builder: PackedSequenceBuilder, + stats: dict, + fs, + rows_processed: int = 0, + ) -> int: + """Process a single file, adding sequences to builder. + + Returns the total number of rows processed (for max_rows tracking). + """ + # Resolve file path - handle HF deferred download + local_path = self._resolve_file_path(file_info) + + # Determine file type and iterate records + is_parquet = local_path.endswith(".parquet") or not ( + local_path.endswith(".jsonl") or local_path.endswith(".json") + ) + + if is_parquet: + rows_processed = self._process_parquet_file( + local_path, builder, stats, fs, rows_processed + ) + else: + rows_processed = self._process_jsonl_file( + local_path, builder, stats, fs, rows_processed + ) + + return rows_processed + + def _process_parquet_file( + self, + local_path: str, + builder: PackedSequenceBuilder, + stats: dict, + fs, + rows_processed: int, + ) -> int: + """Process parquet file with optimized Arrow-level filtering.""" + batch_texts: list[str] = [] + tokenize_batch_size = 1000 + hit_max_rows = False + + for texts, num_filtered_by_length in self._iter_parquet_batches_from_path(local_path, fs): + if hit_max_rows: + break + + # Account for rows filtered by min_doc_chars at Arrow level + stats["num_filtered"] += num_filtered_by_length + stats["num_input_rows"] += num_filtered_by_length + + for text in texts: + # Check max_rows limit + if self.max_rows and rows_processed >= self.max_rows: + hit_max_rows = True + break + + stats["num_input_rows"] += 1 + rows_processed += 1 + + # Filter None values + if text is None: + stats["num_filtered"] += 1 + continue + + batch_texts.append(str(text)) + + # Process batch + if len(batch_texts) >= tokenize_batch_size: + self._tokenize_and_add_batch(batch_texts, builder, stats) + batch_texts = [] + + # Process remaining + if batch_texts: + self._tokenize_and_add_batch(batch_texts, builder, stats) + + return rows_processed + + def _process_jsonl_file( + self, + local_path: str, + builder: PackedSequenceBuilder, + stats: dict, + fs, + rows_processed: int, + ) -> int: + """Process JSONL file.""" + batch_size = 1000 + batch_texts: list[str] = [] + + for record in self._iter_jsonl_records(local_path, fs): + # Check max_rows limit + if self.max_rows and rows_processed >= self.max_rows: + break + + stats["num_input_rows"] += 1 + rows_processed += 1 + + # Extract text + text = record.get(self.text_field) + if text is None: + stats["num_filtered"] += 1 + continue + + text = str(text) + + # Filter short docs + if self.min_doc_chars and len(text) < self.min_doc_chars: + stats["num_filtered"] += 1 + continue + + batch_texts.append(text) + + # Process batch + if len(batch_texts) >= batch_size: + self._tokenize_and_add_batch(batch_texts, builder, stats) + batch_texts = [] + + # Process remaining + if batch_texts: + self._tokenize_and_add_batch(batch_texts, builder, stats) + + return rows_processed + + def _resolve_file_path(self, file_info: FileInfo) -> str: + """Resolve file to a local path, downloading from HF if needed.""" + if file_info.hf_repo_id is not None: + from huggingface_hub import hf_hub_download + + local_path = hf_hub_download( + repo_id=file_info.hf_repo_id, + filename=file_info.hf_filename, + revision=file_info.hf_revision, + repo_type="dataset", + local_files_only=False, + ) + return local_path + + return file_info.local_path or file_info.path + + def _tokenize_and_add_batch( + self, + texts: list[str], + builder: PackedSequenceBuilder, + stats: dict, + ) -> None: + """Tokenize a batch and add sequences to builder.""" + try: + all_tokens = self._tokenize(texts) + + for tokens in all_tokens: + # Truncate if needed + if self.max_doc_tokens and len(tokens) > self.max_doc_tokens: + tokens = tokens[: self.max_doc_tokens] + stats["num_truncated"] += 1 + + if tokens: + # For pretraining, loss_mask is all 1s (compute loss on all tokens) + builder.add_sequence(tokens, loss_mask=None) + + except Exception as e: + # Bisect to isolate bad rows + if len(texts) > 1: + self._tokenize_with_bisect(texts, builder, stats) + else: + stats["num_errors"] += 1 + logger.warning(f"Tokenization error for single text: {e}") + + def _tokenize_with_bisect( + self, + texts: list[str], + builder: PackedSequenceBuilder, + stats: dict, + ) -> None: + """Bisect a batch to isolate problematic rows.""" + if len(texts) == 0: + return + + if len(texts) == 1: + try: + all_tokens = self._tokenize(texts) + for tokens in all_tokens: + if self.max_doc_tokens and len(tokens) > self.max_doc_tokens: + tokens = tokens[: self.max_doc_tokens] + stats["num_truncated"] += 1 + if tokens: + builder.add_sequence(tokens, loss_mask=None) + except Exception as e: + stats["num_errors"] += 1 + logger.debug(f"Skipping problematic text: {e}") + return + + mid = len(texts) // 2 + first_half = texts[:mid] + second_half = texts[mid:] + + try: + all_tokens = self._tokenize(first_half) + for tokens in all_tokens: + if self.max_doc_tokens and len(tokens) > self.max_doc_tokens: + tokens = tokens[: self.max_doc_tokens] + stats["num_truncated"] += 1 + if tokens: + builder.add_sequence(tokens, loss_mask=None) + except Exception: + self._tokenize_with_bisect(first_half, builder, stats) + + try: + all_tokens = self._tokenize(second_half) + for tokens in all_tokens: + if self.max_doc_tokens and len(tokens) > self.max_doc_tokens: + tokens = tokens[: self.max_doc_tokens] + stats["num_truncated"] += 1 + if tokens: + builder.add_sequence(tokens, loss_mask=None) + except Exception: + self._tokenize_with_bisect(second_half, builder, stats) + + def _iter_parquet_batches_from_path( + self, path: str, fs + ) -> Iterator[tuple[list[str | None], int]]: + """Iterate (texts, num_filtered) batches from parquet file.""" + if self._is_remote_path(path): + with fs.open(path, "rb") as f: + parquet_file = pq.ParquetFile(f) + yield from self._iter_parquet_batches(parquet_file) + else: + parquet_file = pq.ParquetFile(path) + yield from self._iter_parquet_batches(parquet_file) + + def _iter_parquet_batches( + self, parquet_file: pq.ParquetFile + ) -> Iterator[tuple[list[str | None], int]]: + """Iterate batches from parquet file efficiently.""" + import pyarrow.compute as pc + + for batch in parquet_file.iter_batches( + columns=[self.text_field], + batch_size=10000, + ): + column = batch.column(self.text_field) + original_len = len(column) + num_filtered = 0 + + # Apply min_doc_chars filter at Arrow level if configured + if self.min_doc_chars: + lengths = pc.utf8_length(column) + mask = pc.greater_equal(lengths, self.min_doc_chars) + column = pc.filter(column, mask) + num_filtered = original_len - len(column) + + yield column.to_pylist(), num_filtered + + def _iter_jsonl_records(self, path: str, fs) -> Iterator[dict]: + """Iterate records from JSONL file.""" + if self._is_remote_path(path): + with fs.open(path, "r") as f: + for line in f: + if line.strip(): + yield json.loads(line) + else: + with open(path) as f: + for line in f: + if line.strip(): + yield json.loads(line) + + def _is_remote_path(self, path: str) -> bool: + """Check if path is a remote path (S3/GCS/etc).""" + return path.startswith(("s3://", "gs://", "gcs://", "az://", "abfs://")) + + def _write_empty_receipt( + self, + shard_id: str, + shard_index: int, + input_files: list[str], + stats: dict, + receipt_path: str, + fs, + ) -> dict: + """Write receipt for empty shard.""" + receipt = { + "shard_id": shard_id, + "shard_index": shard_index, + "status": "completed", + "created_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()), + "input_files": input_files, + "output_file": None, + "npy_bytes": 0, + "packing": { + "pack_size": self.pack_size, + "algorithm": self.algorithm, + "num_sequences": 0, + "num_packed_sequences": 0, + "packing_factor": 0, + "packing_efficiency": 0, + "total_tokens": 0, + }, + "stats": { + "num_sequences": 0, + "num_packed_sequences": 0, + "total_tokens": 0, + **stats, + }, + } + + write_json(fs, receipt_path, receipt) + return receipt["stats"] diff --git a/src/nemotron/data_prep/packing/__init__.py b/src/nemotron/data_prep/packing/__init__.py new file mode 100644 index 0000000..608f5b7 --- /dev/null +++ b/src/nemotron/data_prep/packing/__init__.py @@ -0,0 +1,42 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Sequence packing for efficient SFT training. + +Self-contained packing algorithms optimized for Ray-based data pipelines. +""" + +from nemotron.data_prep.packing.algorithms import ( + ConcatenativePacker, + FirstFitDecreasingPacker, + FirstFitShufflePacker, + PackingAlgorithm, + SequencePacker, + get_packer, +) +from nemotron.data_prep.packing.builder import PackedSequenceBuilder + +__all__ = [ + # Algorithm enum and base class + "PackingAlgorithm", + "SequencePacker", + # Concrete packers + "FirstFitDecreasingPacker", + "FirstFitShufflePacker", + "ConcatenativePacker", + # Factory + "get_packer", + # Builder + "PackedSequenceBuilder", +] diff --git a/src/nemotron/data_prep/packing/algorithms.py b/src/nemotron/data_prep/packing/algorithms.py new file mode 100644 index 0000000..7bb11a0 --- /dev/null +++ b/src/nemotron/data_prep/packing/algorithms.py @@ -0,0 +1,298 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Sequence packing algorithms. + +Self-contained implementations of common bin packing algorithms for +efficiently packing variable-length sequences into fixed-size batches. +""" + +import enum +import random +from abc import ABC, abstractmethod +from dataclasses import dataclass + + +class PackingAlgorithm(enum.Enum): + """Available packing algorithms.""" + + FIRST_FIT_DECREASING = "first_fit_decreasing" + FIRST_FIT_SHUFFLE = "first_fit_shuffle" + CONCATENATIVE = "concatenative" + + +@dataclass +class PackingMetrics: + """Metrics from a packing operation.""" + + num_sequences: int = 0 + num_bins: int = 0 + total_tokens: int = 0 + bin_capacity: int = 0 + num_truncated: int = 0 + + @property + def packing_factor(self) -> float: + """Average sequences per bin.""" + return self.num_sequences / self.num_bins if self.num_bins > 0 else 0 + + @property + def packing_efficiency(self) -> float: + """Percentage of bin capacity used.""" + total_capacity = self.num_bins * self.bin_capacity + return (self.total_tokens / total_capacity * 100) if total_capacity > 0 else 0 + + +class SequencePacker(ABC): + """Abstract base class for sequence packers.""" + + def __init__(self, bin_capacity: int): + """Initialize packer. + + Args: + bin_capacity: Maximum tokens per bin (pack_size). + """ + if bin_capacity <= 0: + raise ValueError(f"bin_capacity must be positive, got {bin_capacity}") + self.bin_capacity = bin_capacity + + @abstractmethod + def pack(self, sequence_lengths: list[int]) -> tuple[list[list[int]], PackingMetrics]: + """Pack sequences into bins. + + Args: + sequence_lengths: List of sequence lengths to pack. + + Returns: + Tuple of (bins, metrics) where bins is a list of lists, + each inner list contains indices into sequence_lengths. + """ + pass + + +class FirstFitDecreasingPacker(SequencePacker): + """First-fit decreasing bin packing algorithm. + + Sorts sequences by length (descending) and places each into the + first bin that has room. Creates new bins as needed. + + Properties: + - Deterministic + - Good packing efficiency + - Tends to put similar-length sequences together + """ + + def pack(self, sequence_lengths: list[int]) -> tuple[list[list[int]], PackingMetrics]: + if not sequence_lengths: + return [], PackingMetrics(bin_capacity=self.bin_capacity) + + # Create (length, original_index) pairs and sort by length descending + indexed_lengths = [(length, idx) for idx, length in enumerate(sequence_lengths)] + indexed_lengths.sort(key=lambda x: x[0], reverse=True) + + bins: list[list[int]] = [] + bin_remaining: list[int] = [] + total_tokens = 0 + num_truncated = 0 + + for length, idx in indexed_lengths: + # Truncate if needed + if length > self.bin_capacity: + length = self.bin_capacity + num_truncated += 1 + + total_tokens += length + + # Find first bin with room + placed = False + for bin_idx, remaining in enumerate(bin_remaining): + if remaining >= length: + bins[bin_idx].append(idx) + bin_remaining[bin_idx] -= length + placed = True + break + + # Create new bin if needed + if not placed: + bins.append([idx]) + bin_remaining.append(self.bin_capacity - length) + + metrics = PackingMetrics( + num_sequences=len(sequence_lengths), + num_bins=len(bins), + total_tokens=total_tokens, + bin_capacity=self.bin_capacity, + num_truncated=num_truncated, + ) + + return bins, metrics + + +class FirstFitShufflePacker(SequencePacker): + """First-fit with shuffled input. + + Same algorithm as first-fit decreasing but shuffles input first. + This provides better mixing of sequence lengths within bins. + + Properties: + - Non-deterministic (use seed for reproducibility) + - Good packing efficiency + - Better diversity within bins + """ + + def __init__(self, bin_capacity: int, seed: int | None = None): + super().__init__(bin_capacity) + self.seed = seed + self._rng = random.Random(seed) + + def pack(self, sequence_lengths: list[int]) -> tuple[list[list[int]], PackingMetrics]: + if not sequence_lengths: + return [], PackingMetrics(bin_capacity=self.bin_capacity) + + # Create (length, original_index) pairs and shuffle + indexed_lengths = [(length, idx) for idx, length in enumerate(sequence_lengths)] + self._rng.shuffle(indexed_lengths) + + bins: list[list[int]] = [] + bin_remaining: list[int] = [] + total_tokens = 0 + num_truncated = 0 + + for length, idx in indexed_lengths: + # Truncate if needed + if length > self.bin_capacity: + length = self.bin_capacity + num_truncated += 1 + + total_tokens += length + + # Find first bin with room + placed = False + for bin_idx, remaining in enumerate(bin_remaining): + if remaining >= length: + bins[bin_idx].append(idx) + bin_remaining[bin_idx] -= length + placed = True + break + + # Create new bin if needed + if not placed: + bins.append([idx]) + bin_remaining.append(self.bin_capacity - length) + + metrics = PackingMetrics( + num_sequences=len(sequence_lengths), + num_bins=len(bins), + total_tokens=total_tokens, + bin_capacity=self.bin_capacity, + num_truncated=num_truncated, + ) + + return bins, metrics + + +class ConcatenativePacker(SequencePacker): + """Simple concatenative packing. + + Concatenates sequences in order until bin is full, then starts new bin. + Simplest possible packing strategy. + + Properties: + - Deterministic + - Preserves input order + - Simple but may have lower efficiency + """ + + def pack(self, sequence_lengths: list[int]) -> tuple[list[list[int]], PackingMetrics]: + if not sequence_lengths: + return [], PackingMetrics(bin_capacity=self.bin_capacity) + + bins: list[list[int]] = [[]] + current_bin_size = 0 + total_tokens = 0 + num_truncated = 0 + + for idx, length in enumerate(sequence_lengths): + # Truncate if needed + if length > self.bin_capacity: + length = self.bin_capacity + num_truncated += 1 + + total_tokens += length + + # Check if fits in current bin + if current_bin_size + length <= self.bin_capacity: + bins[-1].append(idx) + current_bin_size += length + else: + # Start new bin + bins.append([idx]) + current_bin_size = length + + # Remove empty bins + bins = [b for b in bins if b] + + metrics = PackingMetrics( + num_sequences=len(sequence_lengths), + num_bins=len(bins), + total_tokens=total_tokens, + bin_capacity=self.bin_capacity, + num_truncated=num_truncated, + ) + + return bins, metrics + + +def get_packer( + algorithm: PackingAlgorithm | str, + bin_capacity: int, + seed: int | None = None, +) -> SequencePacker: + """Factory function to create a packer. + + Args: + algorithm: Packing algorithm to use. + bin_capacity: Maximum tokens per bin (pack_size). + seed: Random seed for shuffle-based algorithms. + + Returns: + Configured SequencePacker instance. + + Example: + >>> packer = get_packer("first_fit_shuffle", bin_capacity=2048, seed=42) + >>> bins, metrics = packer.pack([100, 200, 150, 300]) + >>> print(f"Packed {metrics.num_sequences} seqs into {metrics.num_bins} bins") + """ + if isinstance(algorithm, str): + algorithm = PackingAlgorithm(algorithm) + + if algorithm == PackingAlgorithm.FIRST_FIT_DECREASING: + return FirstFitDecreasingPacker(bin_capacity) + elif algorithm == PackingAlgorithm.FIRST_FIT_SHUFFLE: + return FirstFitShufflePacker(bin_capacity, seed=seed) + elif algorithm == PackingAlgorithm.CONCATENATIVE: + return ConcatenativePacker(bin_capacity) + else: + raise ValueError(f"Unknown packing algorithm: {algorithm}") + + +__all__ = [ + "PackingAlgorithm", + "PackingMetrics", + "SequencePacker", + "FirstFitDecreasingPacker", + "FirstFitShufflePacker", + "ConcatenativePacker", + "get_packer", +] diff --git a/src/nemotron/data_prep/packing/builder.py b/src/nemotron/data_prep/packing/builder.py new file mode 100644 index 0000000..eaed1a6 --- /dev/null +++ b/src/nemotron/data_prep/packing/builder.py @@ -0,0 +1,231 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Packed sequence builder for GPTSFTPackedDataset format.""" + +from dataclasses import dataclass + +import numpy as np + +from nemotron.data_prep.packing.algorithms import ( + PackingAlgorithm, + get_packer, +) + + +@dataclass +class PackedSequence: + """A single packed sequence containing multiple original sequences. + + Format matches GPTSFTPackedDataset expectations. + """ + + input_ids: list[int] + loss_mask: list[int] + seq_start_id: list[int] + + +class PackedSequenceBuilder: + """Builds packed sequences matching GPTSFTPackedDataset format. + + Collects tokenized sequences, then packs them using the specified + algorithm. Output format is compatible with Megatron-Bridge's + GPTSFTPackedDataset. + + Example: + >>> builder = PackedSequenceBuilder(pack_size=2048, algorithm="first_fit_shuffle") + >>> builder.add_sequence([1, 2, 3], loss_mask=[1, 1, 1]) + >>> builder.add_sequence([4, 5, 6, 7], loss_mask=[0, 1, 1, 1]) + >>> packed_data, metadata = builder.finalize() + """ + + def __init__( + self, + pack_size: int, + algorithm: PackingAlgorithm | str = "first_fit_shuffle", + seed: int | None = None, + dtype: str = "int32", + ): + """Initialize packed sequence builder. + + Args: + pack_size: Maximum tokens per packed sequence. + algorithm: Packing algorithm to use. + seed: Random seed for shuffle-based algorithms. + dtype: Numpy dtype for output arrays. + """ + self.pack_size = pack_size + self.algorithm = algorithm + self.seed = seed + self.dtype = np.dtype(dtype) + + # Collect sequences before packing + self._sequences: list[list[int]] = [] + self._loss_masks: list[list[int] | None] = [] + + def add_sequence( + self, + input_ids: list[int], + loss_mask: list[int] | None = None, + ) -> None: + """Add a tokenized sequence for packing. + + Args: + input_ids: Token IDs for this sequence. + loss_mask: Optional loss mask (1 = compute loss, 0 = ignore). + If not provided, defaults to all 1s. + """ + if not input_ids: + return + + self._sequences.append(input_ids) + self._loss_masks.append(loss_mask) + + def add_sequences( + self, + sequences: list[list[int]], + loss_masks: list[list[int] | None] | None = None, + ) -> None: + """Batch add multiple sequences. + + Args: + sequences: List of token ID sequences. + loss_masks: Optional list of loss masks (same length as sequences). + """ + if loss_masks is None: + loss_masks = [None] * len(sequences) + + for input_ids, loss_mask in zip(sequences, loss_masks): + self.add_sequence(input_ids, loss_mask) + + def finalize(self) -> tuple[list[dict], dict]: + """Pack collected sequences and return output. + + Returns: + Tuple of (packed_data, metadata) where: + - packed_data: List of dicts, each with {input_ids, loss_mask, seq_start_id} + - metadata: Dict with packing metrics + + Output format per packed item: + { + "input_ids": [tok1, tok2, ...], + "loss_mask": [0, 1, 1, ...], # Rolled by 1 for label alignment + "seq_start_id": [0, len1, len1+len2, ...] + } + """ + if not self._sequences: + return [], { + "pack_size": self.pack_size, + "num_sequences": 0, + "num_packed_sequences": 0, + "packing_factor": 0, + "packing_efficiency": 0, + } + + # Get sequence lengths + lengths = [len(seq) for seq in self._sequences] + + # Pack sequences + packer = get_packer(self.algorithm, self.pack_size, seed=self.seed) + bins, metrics = packer.pack(lengths) + + # Build packed sequences + packed_data: list[dict] = [] + for bin_indices in bins: + packed = self._build_packed_sequence(bin_indices) + packed_data.append(packed) + + metadata = { + "pack_size": self.pack_size, + "algorithm": str(self.algorithm), + "num_sequences": metrics.num_sequences, + "num_packed_sequences": metrics.num_bins, + "packing_factor": round(metrics.packing_factor, 2), + "packing_efficiency": round(metrics.packing_efficiency, 1), + "num_truncated": metrics.num_truncated, + "total_tokens": metrics.total_tokens, + } + + return packed_data, metadata + + def _build_packed_sequence(self, indices: list[int]) -> dict: + """Build a single packed sequence from indices. + + Args: + indices: Indices into self._sequences for sequences to pack. + + Returns: + Dict with input_ids, loss_mask, seq_start_id. + """ + all_input_ids: list[int] = [] + all_loss_mask: list[int] = [] + seq_start_ids: list[int] = [0] + + for idx in indices: + seq = self._sequences[idx] + mask = self._loss_masks[idx] + + # Truncate if needed + if len(seq) > self.pack_size: + seq = seq[: self.pack_size] + if mask is not None: + mask = mask[: self.pack_size] + + # Check if we have room + current_len = len(all_input_ids) + if current_len + len(seq) > self.pack_size: + # Truncate to fit + remaining = self.pack_size - current_len + seq = seq[:remaining] + if mask is not None: + mask = mask[:remaining] + + all_input_ids.extend(seq) + + # Default loss mask to all 1s if not provided + if mask is None: + mask = [1] * len(seq) + all_loss_mask.extend(mask) + + # Track sequence boundary + seq_start_ids.append(len(all_input_ids)) + + # Roll loss_mask by 1 for label alignment (standard in Megatron) + # This shifts the mask so it aligns with labels (next-token prediction) + rolled_loss_mask = [0] + all_loss_mask[:-1] if all_loss_mask else [] + + return { + "input_ids": all_input_ids, + "loss_mask": rolled_loss_mask, + "seq_start_id": seq_start_ids[:-1], # Exclude final boundary + } + + def get_stats(self) -> dict: + """Get current builder statistics (before finalize). + + Returns: + Dict with num_sequences and approximate metrics. + """ + if not self._sequences: + return {"num_sequences": 0, "total_tokens": 0} + + total_tokens = sum(len(seq) for seq in self._sequences) + return { + "num_sequences": len(self._sequences), + "total_tokens": total_tokens, + "avg_length": total_tokens / len(self._sequences), + } + + +__all__ = ["PackedSequence", "PackedSequenceBuilder"] diff --git a/src/nemotron/data_prep/pipeline.py b/src/nemotron/data_prep/pipeline.py new file mode 100644 index 0000000..61ea183 --- /dev/null +++ b/src/nemotron/data_prep/pipeline.py @@ -0,0 +1,2443 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Pipeline orchestration for processing data blends into training formats.""" + +from __future__ import annotations + +import hashlib +import json +import logging +import os +import time +from collections.abc import Callable +from dataclasses import asdict, dataclass +from pathlib import Path +from typing import TYPE_CHECKING + +import ray + +from nemotron.data_prep import console as con +from nemotron.data_prep.config import ( + ChatSftOutputConfig, + DatasetConfig, + InternalOutputConfig, + InternalTokenizerConfig, + JsonlOutputConfig, + OutputConfig, + PackedOutputConfig, + PipelineConfig, + RayDataConfig, + ShardPlan, + SourceChangedError, +) +from nemotron.data_prep.discovery import get_dataset_metadata +from nemotron.data_prep.filesystem import ( + ensure_dir, + get_filesystem, + read_json, + write_json, +) +from nemotron.data_prep.planning import ( + apply_shard_sampling, + create_shard_plan, + get_pending_shards, + serialize_shard_plan, +) +from nemotron.data_prep.shard_processor import ShardProcessor + +if TYPE_CHECKING: + from nemotron.data_prep.blend import DataBlend, Dataset + +logger = logging.getLogger(__name__) + + +# ============================================================================= +# W&B Logging Helpers +# ============================================================================= + + +def log_pipeline_metrics_to_wandb(result: PipelineResult) -> None: + """Log pipeline metrics to wandb if active. + + Args: + result: The completed pipeline result + """ + try: + import wandb + + if wandb.run is None: + return + + # Summary metrics + wandb.log( + { + "data_prep/total_tokens": result.total_tokens, + "data_prep/total_sequences": result.total_sequences, + "data_prep/elapsed_sec": result.elapsed_sec, + "data_prep/tokens_per_second": result.total_tokens / max(result.elapsed_sec, 0.001), + } + ) + + # Per-split breakdown + for split_name, split_result in result.splits.items(): + wandb.log( + { + f"data_prep/{split_name}/tokens": split_result.total_tokens, + f"data_prep/{split_name}/sequences": split_result.total_sequences, + } + ) + except ImportError: + pass + + +def log_cache_stats_to_wandb( + cached_tokens: int, + cached_sequences: int, + pending_shards: int, + total_shards: int, +) -> None: + """Log cache hit statistics to wandb. + + Args: + cached_tokens: Number of tokens served from cache + cached_sequences: Number of sequences served from cache + pending_shards: Number of shards that need processing + total_shards: Total number of shards + """ + try: + import wandb + + if wandb.run is None: + return + + cache_hit_rate = (total_shards - pending_shards) / max(total_shards, 1) + wandb.log( + { + "data_prep/cache_hit_rate": cache_hit_rate, + "data_prep/cached_tokens": cached_tokens, + "data_prep/cached_sequences": cached_sequences, + "data_prep/pending_shards": pending_shards, + } + ) + except ImportError: + pass + + +# ============================================================================ +# Result Types +# ============================================================================ + + +@dataclass +class SplitResult: + """Result for a single split. + + Attributes: + name: Split name ("all", "train", "valid", "test") + run_hash: Unique hash for this processing run + output_dir: Directory containing tokenized shards + data_paths: Megatron-Bridge format ["weight", "path", ...] + num_shards: Number of shards produced + total_tokens: Total tokens across all shards + total_sequences: Total sequences (documents) processed + """ + + name: str + run_hash: str + output_dir: Path + data_paths: list[str] + num_shards: int + total_tokens: int + total_sequences: int + + +@dataclass +class PipelineResult: + """Complete pipeline result. + + Attributes: + output_dir: Root output directory + blend_path: Path to generated blend.json + splits: Results by split name + is_per_split: True if per-split mode was used + split_ratio: Split ratio if single-blend mode (e.g., "99990,8,2") + elapsed_sec: Total processing time + from_cache: True if all results were served from cache + """ + + output_dir: Path + blend_path: Path + splits: dict[str, SplitResult] + is_per_split: bool + split_ratio: str | None + elapsed_sec: float + from_cache: bool = False + + @property + def total_tokens(self) -> int: + """Total tokens across all splits.""" + return sum(s.total_tokens for s in self.splits.values()) + + @property + def total_sequences(self) -> int: + """Total sequences across all splits.""" + return sum(s.total_sequences for s in self.splits.values()) + + +# ============================================================================ +# Public API +# ============================================================================ + + +def get_num_actors_from_cluster() -> int: + """Get number of actors from Ray cluster resources. + + Queries the Ray cluster for available CPUs. Falls back to os.cpu_count() + if Ray cluster info is unavailable. + + Returns: + Number of actors to use (minimum 2) + """ + try: + cluster_cpus = int(ray.cluster_resources().get("CPU", 0)) + if cluster_cpus > 0: + return max(2, cluster_cpus) + except Exception: + pass + # Fallback to local CPU count + cpu_count = os.cpu_count() or 4 + return max(2, cpu_count) + + +def last_mile_process( + blend: DataBlend, + config: PipelineConfig, +) -> PipelineResult: + """Process data blend into final training format. + + Dispatches to format-specific processing based on config.output.format: + - binidx: Tokenize → Megatron .bin/.idx indexed dataset + - jsonl: Transform → JSONL files (no tokenization) + - packed: Tokenize → Pack → .npy packed sequences + + Args: + blend: Data blend specification (datasets and weights) + config: Pipeline configuration (output format, optional tokenizer) + + Returns: + PipelineResult with paths to processed data and blend.json + + Output Format: + The generated blend.json is directly compatible with Megatron-Bridge: + + Single blend mode: + {"data_paths": ["1.0", "/path/shard", ...], "split": "99990,8,2"} + + Per-split mode: + {"train_data_paths": [...], "valid_data_paths": [...], ...} + + Example: + from nemotron.data_prep import last_mile_process, DataBlend, PipelineConfig + from nemotron.data_prep.config import TokenizerConfig, OutputConfig, JsonlOutputConfig + from nemotron.data_prep.formats.transforms import sft + + blend = DataBlend.load("data_blend.json") + + # JSONL output (no tokenization) + config = PipelineConfig( + output=OutputConfig( + dir=Path("./sft_data"), + format=JsonlOutputConfig(transform=sft(input="instruction", output="response")), + ), + ) + result = last_mile_process(blend, config) + + # BinIdx output (tokenization) + config = PipelineConfig( + tokenizer=TokenizerConfig(model="nvidia/NVIDIA-Nemotron-Nano-9B-v2"), + output=OutputConfig(dir=Path("./output")), + ) + result = last_mile_process(blend, config) + """ + start = time.time() + + # Get format type + format_config = config.output.format + format_type = getattr(format_config, "format", "binidx") + + # Validate tokenizer requirement + if format_type in ("binidx", "packed", "chat_sft") and config.tokenizer is None: + raise ValueError(f"tokenizer is required for '{format_type}' output format") + if format_type == "jsonl" and config.tokenizer is not None: + logger.warning("Tokenizer ignored for JSONL format") + + # Dispatch to format-specific processing + if format_type == "jsonl": + result = _process_jsonl_blend(blend, config) + elif format_type == "packed": + result = _process_packed_blend(blend, config) + elif format_type == "chat_sft": + result = _process_chat_sft_blend(blend, config) + else: + # Default: binidx (tokenized) + if blend.is_per_split: + result = _tokenize_per_split(blend, config) + else: + result = _tokenize_single(blend, config) + + # Update elapsed time, preserving from_cache flag + result = PipelineResult( + output_dir=result.output_dir, + blend_path=result.blend_path, + splits=result.splits, + is_per_split=result.is_per_split, + split_ratio=result.split_ratio, + elapsed_sec=time.time() - start, + from_cache=result.from_cache, + ) + + # Log metrics to wandb if active + if not result.from_cache: + log_pipeline_metrics_to_wandb(result) + + return result + + +def tokenize( + blend: DataBlend, + config: PipelineConfig, +) -> PipelineResult: + """Tokenize data blend to Megatron-Bridge format. + + .. deprecated:: + Use :func:`last_mile_process` instead. This function is provided + for backward compatibility. + + Args: + blend: Data blend specification + config: Pipeline configuration (tokenizer, output settings) + + Returns: + PipelineResult with paths to tokenized data + """ + return last_mile_process(blend, config) + + +# ============================================================================ +# Internal Processing Functions +# ============================================================================ + + +def _tokenize_single(blend: DataBlend, config: PipelineConfig) -> PipelineResult: + """Process single blend. + + If config.per_split is set, distributes shards into train/valid/test splits + and outputs {"train": [...], "valid": [...], "test": [...]} JSON format + compatible with Megatron-Bridge's per_split_data_args_path parameter. + + Otherwise, outputs {"data_paths": [...], "split": "..."} format for + runtime split by ratio. + """ + split_result = _process_split( + datasets=blend.datasets, + split_name="all", + config=config, + ) + + # Check if per-split output mode is enabled + if config.per_split is not None and config.per_split.enabled: + blend_data = _distribute_shards_to_splits( + data_paths=split_result.data_paths, + num_shards=split_result.num_shards, + valid_shards=config.per_split.valid_shards, + test_shards=config.per_split.test_shards, + ) + is_per_split = True + split_ratio = None + else: + # Generate blend.json with data_paths and optional split ratio + blend_data = {"data_paths": split_result.data_paths} + if config.split: + blend_data["split"] = config.split + is_per_split = False + split_ratio = config.split + + blend_path = config.output.dir / "blend.json" + _write_json(blend_path, blend_data) + + return PipelineResult( + output_dir=config.output.dir, + blend_path=blend_path, + splits={"all": split_result}, + is_per_split=is_per_split, + split_ratio=split_ratio, + elapsed_sec=0, + ) + + +def _distribute_shards_to_splits( + data_paths: list[str], + num_shards: int, + valid_shards: int = 1, + test_shards: int = 1, + seed: int = 42, +) -> dict[str, list[str]]: + """Distribute shard paths into train/valid/test splits. + + Collects all shards from all datasets into a pool, then randomly selects + shards for test and valid splits. The remaining shards go to train. + + The data_paths format is: ["weight", "path", "weight", "path", ...] + where paths are shard prefixes (e.g., /path/to/shard). + + Output format compatible with Megatron-Bridge's per_split_data_args_path: + {"train": ["weight", "path_0000", "weight", "path_0001", ...], "valid": [...], "test": [...]} + + Args: + data_paths: Megatron-Bridge format path list ["weight", "path", ...] + num_shards: Total number of shards per dataset + valid_shards: Number of shards for validation (total, not per-dataset) + test_shards: Number of shards for test (total, not per-dataset) + seed: Random seed for reproducible shard selection + + Returns: + Dict with "train", "valid", "test" keys containing data_paths lists + """ + import random + + # Parse weight/path pairs from data_paths + # Format: ["1.0", "/path/dataset1/shard", "0.5", "/path/dataset2/shard", ...] + pairs = [] + for i in range(0, len(data_paths), 2): + if i + 1 < len(data_paths): + weight = data_paths[i] + prefix = data_paths[i + 1] + pairs.append((weight, prefix)) + + # Collect ALL shards from ALL datasets into one pool + # Each entry is (weight, shard_path) where shard_path has the _XXXX suffix + all_shards: list[tuple[str, str]] = [] + for weight, prefix in pairs: + for shard_idx in range(num_shards): + all_shards.append((weight, f"{prefix}_{shard_idx:06d}")) + + # Use seeded RNG for reproducibility + rng = random.Random(seed) + + # Randomly select shards for test and valid + # Ensure we don't request more shards than available + total_shards = len(all_shards) + actual_test_shards = min(test_shards, total_shards) + remaining_after_test = total_shards - actual_test_shards + actual_valid_shards = min(valid_shards, remaining_after_test) + + # Shuffle and partition + shuffled = all_shards.copy() + rng.shuffle(shuffled) + + test_selection = shuffled[:actual_test_shards] + valid_selection = shuffled[actual_test_shards : actual_test_shards + actual_valid_shards] + train_selection = shuffled[actual_test_shards + actual_valid_shards :] + + # Convert back to flat list format ["weight", "path", "weight", "path", ...] + def flatten(shard_pairs: list[tuple[str, str]]) -> list[str]: + result: list[str] = [] + for weight, path in shard_pairs: + result.append(weight) + result.append(path) + return result + + return { + "train": flatten(train_selection), + "valid": flatten(valid_selection), + "test": flatten(test_selection), + } + + +def _tokenize_per_split(blend: DataBlend, config: PipelineConfig) -> PipelineResult: + """Process each split separately (train/valid/test). + + Generates blend.json with {"train": [...], "valid": [...], "test": [...]} + format compatible with Megatron-Bridge's per_split_data_args_path parameter. + """ + splits: dict[str, SplitResult] = {} + blend_data: dict[str, list[str]] = {} + + for split_name, datasets in blend.splits.items(): + # Create split-specific output config (preserve format from parent config) + split_output = OutputConfig( + dir=config.output.dir / split_name, + format=config.output.format, + min_doc_chars=config.output.min_doc_chars, + max_doc_tokens=config.output.max_doc_tokens, + max_rows=config.output.max_rows, + ) + + split_config = PipelineConfig( + tokenizer=config.tokenizer, + output=split_output, + sample=config.sample, + sample_seed=config.sample_seed, + force=config.force, + split=None, # No split ratio for per-split mode + ray_data=config.ray_data, + ) + + split_result = _process_split( + datasets=datasets, + split_name=split_name, + config=split_config, + ) + + splits[split_name] = split_result + # Use simple key names for Megatron-Bridge compatibility + blend_data[split_name] = split_result.data_paths + + # Generate combined blend.json + blend_path = config.output.dir / "blend.json" + _write_json(blend_path, blend_data) + + return PipelineResult( + output_dir=config.output.dir, + blend_path=blend_path, + splits=splits, + is_per_split=True, + split_ratio=None, + elapsed_sec=0, + ) + + +def _process_split( + datasets: list[Dataset], + split_name: str, + config: PipelineConfig, +) -> SplitResult: + """Process a list of datasets into tokenized shards. + + This function orchestrates the full tokenization pipeline: + 1. Create shard plans for each dataset + 2. Process shards in parallel using Ray actors + 3. Aggregate results and build data_paths list + """ + + # Get filesystem + fs, base_path = get_filesystem(str(config.output.dir)) + + # Build internal config dict for planning/processing + pipeline_dict = { + "datasets": [ + { + "name": d.name, + "path": d.path, + "weight": d.weight, + "split": d.split, + "subset": d.subset, + "text_field": d.text_field, + } + for d in datasets + ], + "tokenizer": { + "type": config.tokenizer.type, + "model": config.tokenizer.model, + "add_bos": config.tokenizer.add_bos, + "add_eos": config.tokenizer.add_eos, + "trust_remote_code": config.tokenizer.trust_remote_code, + }, + "output": { + "num_shards": config.output.format.num_shards, + "dtype": config.output.format.dtype, + "min_doc_chars": config.output.min_doc_chars, + "max_doc_tokens": config.output.max_doc_tokens, + "max_rows": config.output.max_rows, + }, + } + + # Compute run hash (includes sampling params) + run_config = pipeline_dict.copy() + if config.sample is not None: + run_config["_sample"] = {"spec": str(config.sample), "seed": config.sample_seed} + config_hash = hashlib.sha256(json.dumps(run_config, sort_keys=True).encode()).hexdigest()[:16] + + # Run namespace + run_hash = config_hash if not config.force else f"{config_hash}_{int(time.time())}" + run_dir = f"{base_path}/runs/{run_hash}" + ensure_dir(fs, run_dir) + + # Freeze config + write_json(fs, f"{run_dir}/config.json", run_config) + + tokenizer_config = InternalTokenizerConfig(**pipeline_dict["tokenizer"]) + output_config = InternalOutputConfig(**pipeline_dict["output"]) + + # Planning phase + con.planning_header() + + execution_plans: list[_DatasetExecutionPlan] = [] + plan_hashes = {} + resolved_tokenizer = None + plan_infos = [] + + for dataset_entry in pipeline_dict["datasets"]: + dataset_config = DatasetConfig(**dataset_entry) + name = dataset_config.name + + # Create or load plan + plan = _load_or_create_plan( + dataset_config=dataset_config, + output_config=output_config, + tokenizer_config=tokenizer_config, + config_hash=config_hash, + run_dir=run_dir, + fs=fs, + force=config.force, + ) + + plan_hashes[name] = plan.plan_hash + + if resolved_tokenizer is None: + resolved_tokenizer = plan.resolved_tokenizer + + # Paths for this plan + dataset_dir = f"{run_dir}/datasets/{name}/{plan.plan_hash}" + receipts_dir = f"{dataset_dir}/receipts" + ensure_dir(fs, dataset_dir) + ensure_dir(fs, receipts_dir) + + # Get pending shards and cached stats + all_pending = get_pending_shards(plan, receipts_dir, fs) + cached_stats = _aggregate_stats_from_receipts(receipts_dir, plan, fs) + + # Apply sampling + sampled_count = None + if config.sample is not None: + pending_indices = apply_shard_sampling( + all_pending, plan, config.sample, config.sample_seed + ) + sampled_count = len(pending_indices) + else: + pending_indices = all_pending + + # Fetch HuggingFace metadata (non-blocking, best-effort) + hf_metadata = get_dataset_metadata(dataset_config) + + # Build plan info for display + plan_infos.append( + con.DatasetPlanInfo( + name=name, + plan_hash=plan.plan_hash, + num_shards=plan.num_shards, + num_files=sum(len(a.files) for a in plan.file_assignments), + pending=len(all_pending), + cached=cached_stats["num_shards_completed"], + cached_tokens=cached_stats["total_tokens"], + cached_sequences=cached_stats["total_sequences"], + sampled=sampled_count, + hf_rows=hf_metadata.num_rows_str, + hf_size=hf_metadata.size_str, + ) + ) + + # Store execution plan + execution_plans.append( + _DatasetExecutionPlan( + name=name, + config=dataset_config, + plan=plan, + dataset_dir=dataset_dir, + receipts_dir=receipts_dir, + pending_indices=pending_indices, + cached_stats=cached_stats, + ) + ) + + # Show plan summary (auto-detect workers from cluster) + con.plan_summary(plan_infos, run_hash) + + # Execution phase + results = {} + has_work = any(ep.pending_indices for ep in execution_plans) + + if has_work: + con.execution_header() + + # Create live status panel with all datasets + live_status = con.create_live_status( + datasets=[ + (ep.name, len(ep.pending_indices) or ep.cached_stats["num_shards_completed"]) + for ep in execution_plans + ], + run_hash=run_hash, + ) + live_status.start() + + try: + # Handle cached datasets first + for ep in execution_plans: + if not ep.pending_indices: + results[ep.name] = ep.cached_stats + live_status.report_tokens(ep.name, ep.cached_stats.get("total_tokens", 0)) + live_status.cache_dataset(ep.name) + + # Process ALL pending shards from ALL datasets in parallel + _process_all_shards_parallel( + execution_plans=[ep for ep in execution_plans if ep.pending_indices], + output_config=output_config, + fs=fs, + live_status=live_status, + results=results, + ray_data_config=config.ray_data, + ) + finally: + live_status.stop() + else: + # All cached, no live display needed + for ep in execution_plans: + results[ep.name] = ep.cached_stats + + # Generate outputs + _generate_manifest( + run_dir, pipeline_dict, results, plan_hashes, run_hash, resolved_tokenizer, fs + ) + + # Build data_paths in Megatron-Bridge format + data_paths: list[str] = [] + for dataset_entry in pipeline_dict["datasets"]: + name = dataset_entry["name"] + weight = dataset_entry.get("weight", 1.0) + + if weight > 0 and name in plan_hashes: + plan_hash = plan_hashes[name] + prefix = f"{run_dir}/datasets/{name}/{plan_hash}/shard" + data_paths.append(str(weight)) + data_paths.append(prefix) + + return SplitResult( + name=split_name, + run_hash=run_hash, + output_dir=Path(config.output.dir), + data_paths=data_paths, + num_shards=config.output.format.num_shards, + total_tokens=sum(r.get("total_tokens", 0) for r in results.values()), + total_sequences=sum(r.get("total_sequences", 0) for r in results.values()), + ) + + +def _write_json(path: Path, data: dict) -> None: + """Write JSON file with atomic write.""" + path.parent.mkdir(parents=True, exist_ok=True) + temp_path = path.with_suffix(".json.tmp") + with open(temp_path, "w") as f: + json.dump(data, f, indent=2) + temp_path.rename(path) + + +# ============================================================================ +# Internal Helper Classes and Functions +# ============================================================================ + + +@dataclass +class _DatasetExecutionPlan: + """Execution plan for a single dataset.""" + + name: str + config: DatasetConfig + plan: ShardPlan + dataset_dir: str + receipts_dir: str + pending_indices: list[int] + cached_stats: dict + + +class _PlanDriftError(Exception): + """Raised when a new plan would create drift from existing plans.""" + + pass + + +def _load_or_create_plan( + dataset_config: DatasetConfig, + output_config: InternalOutputConfig, + tokenizer_config: InternalTokenizerConfig, + config_hash: str, + run_dir: str, + fs, + force: bool = False, +) -> ShardPlan: + """Load existing plan or create new one. + + Enforces single active plan per dataset unless force=True. + This prevents silent drift where source changes create orphaned plans. + """ + # Create plan to get hash + plan = create_shard_plan( + dataset_config=dataset_config, + output_config=output_config, + tokenizer_config=tokenizer_config, + config_hash=config_hash, + fs=fs, + ) + + dataset_plans_dir = f"{run_dir}/datasets/{dataset_config.name}" + plan_path = f"{dataset_plans_dir}/{plan.plan_hash}/plan.json" + + if fs.exists(plan_path): + # Load and verify + existing_data = read_json(fs, plan_path) + if existing_data.get("source_fingerprint") != plan.source_fingerprint: + raise SourceChangedError(f"Source data changed for {dataset_config.name}") + return ShardPlan.from_dict(existing_data) + + # Check for existing plans with different hashes (drift detection) + if not force: + try: + existing_plan_dirs = [ + d for d in fs.ls(dataset_plans_dir) if fs.isdir(d) and fs.exists(f"{d}/plan.json") + ] + if existing_plan_dirs: + existing_hashes = [d.split("/")[-1] for d in existing_plan_dirs] + raise _PlanDriftError( + f"Dataset '{dataset_config.name}' has existing plan(s): {existing_hashes}. " + f"New plan hash {plan.plan_hash} would create drift. " + f"Use --force to create a new run namespace, or delete the existing run." + ) + except FileNotFoundError: + pass # No existing plans, OK to create + + # Save new plan + plan_dir = f"{dataset_plans_dir}/{plan.plan_hash}" + ensure_dir(fs, plan_dir) + write_json(fs, plan_path, serialize_shard_plan(plan)) + + return plan + + +def _process_all_shards_parallel( + execution_plans: list[_DatasetExecutionPlan], + output_config: InternalOutputConfig, + fs, + live_status, + results: dict, + ray_data_config: RayDataConfig | None = None, +) -> None: + """Process ALL pending shards from ALL datasets in parallel. + + This maximizes parallelism by submitting shards from all datasets + to a shared actor pool, rather than processing datasets sequentially. + + When ray_data_config is provided and enabled, uses Ray Data's ActorPoolStrategy + for actor lifecycle management. Otherwise, uses legacy manual actor management. + """ + if not execution_plans: + return + + # Dispatch to Ray Data executor if enabled + if ray_data_config is not None and ray_data_config.enabled: + _process_shards_ray_data( + execution_plans=execution_plans, + output_config=output_config, + fs=fs, + ray_data_config=ray_data_config, + live_status=live_status, + results=results, + ) + return + + # Legacy path: manual actor management + from nemotron.data_prep.shard_processor import ShardProcessor + + # Auto-detect num_actors from cluster + num_actors = get_num_actors_from_cluster() + + # Determine filesystem protocol + protocol = fs.protocol + if isinstance(protocol, tuple): + protocol = protocol[0] + fs_protocol = protocol if protocol != "file" else "file" + + # Create shared actor pool + # Use the first plan's tokenizer config (should be same for all) + first_plan = execution_plans[0].plan + actors = [ + ShardProcessor.remote( + resolved_tokenizer=first_plan.resolved_tokenizer, + text_field=execution_plans[0].config.text_field, + min_doc_chars=output_config.min_doc_chars, + max_doc_tokens=output_config.max_doc_tokens, + dtype=output_config.dtype, + max_rows=output_config.max_rows, + ) + for _ in range(num_actors) + ] + + try: + # Build all tasks from all datasets + # Task: (dataset_name, shard_index, assignment_dict, plan_hash, dataset_dir, receipts_dir) + all_tasks: list[tuple] = [] + dataset_pending_counts: dict[str, int] = {} + dataset_completed_counts: dict[str, int] = {} + + for ep in execution_plans: + live_status.start_dataset(ep.name) + dataset_pending_counts[ep.name] = len(ep.pending_indices) + dataset_completed_counts[ep.name] = 0 + + # Convert assignments to dicts for Ray serialization + assignment_dicts = {} + for a in ep.plan.file_assignments: + assignment_dicts[a.shard_index] = { + "shard_index": a.shard_index, + "files": [asdict(f) for f in a.files], + "total_bytes": a.total_bytes, + } + + for shard_idx in ep.pending_indices: + all_tasks.append( + ( + ep.name, + shard_idx, + assignment_dicts[shard_idx], + ep.plan.plan_hash, + ep.dataset_dir, + ep.receipts_dir, + ep, # Keep reference to execution plan for aggregation + ) + ) + + # Submit tasks with backpressure + max_in_flight = num_actors * 2 + task_queue = list(all_tasks) + actor_idx = 0 + pending_list: list = [] + future_to_task: dict = {} + + def submit_task(task: tuple) -> None: + nonlocal actor_idx + name, shard_idx, assignment, plan_hash, dataset_dir, receipts_dir, ep = task + actor = actors[actor_idx % num_actors] + actor_idx += 1 + future = actor.process_shard.remote( + shard_index=shard_idx, + assignment=assignment, + plan_hash=plan_hash, + output_dir=dataset_dir, + receipts_dir=receipts_dir, + fs_protocol=fs_protocol, + ) + pending_list.append(future) + future_to_task[future] = task + + # Initial submission + while task_queue and len(pending_list) < max_in_flight: + submit_task(task_queue.pop(0)) + + # Process with backpressure + while pending_list: + done, pending_list = ray.wait(pending_list, num_returns=1, timeout=60) + for future in done: + task = future_to_task.pop(future) + name = task[0] + ep = task[6] + + try: + ray.get(future) + except Exception as e: + logger.error(f"Shard {task[1]} for {name} failed: {e}") + + # Update progress + live_status.advance_dataset(name) + dataset_completed_counts[name] += 1 + + # Check if dataset is complete + if dataset_completed_counts[name] >= dataset_pending_counts[name]: + # Aggregate final stats for this dataset + results[name] = _aggregate_stats_from_receipts(ep.receipts_dir, ep.plan, fs) + live_status.report_metrics( + name, + rows=results[name].get("total_sequences", 0), + tokens=results[name].get("total_tokens", 0), + ) + live_status.complete_dataset(name) + + # Submit next task if available + if task_queue: + submit_task(task_queue.pop(0)) + finally: + # Clean up actors + for actor in actors: + ray.kill(actor) + + +def _process_shards_ray_data( + execution_plans: list[_DatasetExecutionPlan], + output_config: InternalOutputConfig, + fs, + ray_data_config: RayDataConfig, + live_status, + results: dict, +) -> None: + """Process shards using Ray Data ActorPoolStrategy. + + This function provides the Ray Data-based alternative to manual actor management. + Key benefits: + - Automatic actor lifecycle management (no leaked actors) + - Integrated backpressure with Ray's resource manager + - Explicit CPU accounting per actor via num_cpus parameter + + Args: + execution_plans: List of dataset execution plans with pending shards + output_config: Output configuration (dtype, min_doc_chars, etc.) + fs: fsspec filesystem instance + ray_data_config: Ray Data execution configuration + live_status: Live status panel for progress reporting + results: Dict to populate with per-dataset stats + """ + from nemotron.data_prep.ray_data import ( + BinIdxShardTaskUDF, + RayDataExecConfig, + ShardTask, + execute_shard_tasks, + ) + + if not execution_plans: + return + + # Determine filesystem protocol for output + protocol = fs.protocol + if isinstance(protocol, tuple): + protocol = protocol[0] + fs_protocol = protocol if protocol != "file" else "file" + + # Get resolved tokenizer from first plan + # NOTE: Assumes tokenizer is globally uniform across all execution plans. + # If not guaranteed, would need to group tasks by tokenizer and run separate Ray Data jobs. + first_plan = execution_plans[0].plan + resolved_tokenizer = first_plan.resolved_tokenizer + + # Verify tokenizer uniformity (hard requirement for v1) + for ep in execution_plans[1:]: + if ep.plan.resolved_tokenizer != resolved_tokenizer: + raise ValueError( + f"Tokenizer mismatch: dataset '{ep.name}' uses different tokenizer. " + f"Ray Data executor requires uniform tokenizer across all datasets in v1. " + f"Group datasets by tokenizer or disable Ray Data execution." + ) + + # Build task list across all datasets + tasks: list[ShardTask] = [] + dataset_pending_counts: dict[str, int] = {} + dataset_completed_counts: dict[str, int] = {} + + for ep in execution_plans: + live_status.start_dataset(ep.name) + dataset_pending_counts[ep.name] = len(ep.pending_indices) + dataset_completed_counts[ep.name] = 0 + + # HANDLE ZERO PENDING SHARDS: Immediately complete + # (otherwise complete_dataset is never called since on_result isn't triggered) + if len(ep.pending_indices) == 0: + results[ep.name] = _aggregate_stats_from_receipts(ep.receipts_dir, ep.plan, fs) + live_status.report_metrics( + ep.name, + rows=results[ep.name].get("total_sequences", 0), + tokens=results[ep.name].get("total_tokens", 0), + ) + live_status.complete_dataset(ep.name) + continue # Don't add tasks for this dataset + + # Convert assignments to dicts (same as legacy) + assignment_dicts = {} + for a in ep.plan.file_assignments: + assignment_dicts[a.shard_index] = { + "shard_index": a.shard_index, + "files": [asdict(f) for f in a.files], + "total_bytes": a.total_bytes, + } + + for shard_idx in ep.pending_indices: + tasks.append( + ShardTask.from_assignment( + assignment=assignment_dicts[shard_idx], + dataset_name=ep.name, + plan_hash=ep.plan.plan_hash, + shard_index=shard_idx, + output_dir=ep.dataset_dir, + receipts_dir=ep.receipts_dir, + fs_protocol=fs_protocol, + kind="binidx", + text_field=ep.config.text_field, + ) + ) + + # Skip if no tasks to execute + if not tasks: + return + + # Resolve max_actors: None means use all available CPUs from Ray cluster + if ray_data_config.max_actors is None: + try: + cluster_cpus = int(ray.cluster_resources().get("CPU", 0)) + max_actors = max(2, cluster_cpus) # At least 2 actors + except Exception: + # Fallback if Ray cluster info unavailable + import os + max_actors = os.cpu_count() or 32 + else: + max_actors = ray_data_config.max_actors + + # Configure execution + exec_cfg = RayDataExecConfig( + min_actors=ray_data_config.min_actors, + max_actors=max_actors, + cpus_per_actor=ray_data_config.cpus_per_actor, + max_tasks_in_flight_per_actor=ray_data_config.max_tasks_in_flight_per_actor, + ) + + # Execution plan lookup for result handling + ep_by_name = {ep.name: ep for ep in execution_plans} + + # Track which datasets have been reported for phase updates + # (report phase for first active dataset only to avoid noise) + active_datasets = [ep.name for ep in execution_plans if ep.pending_indices] + + def on_result(r: dict) -> None: + """Callback for each completed task.""" + name = r.get("dataset_name") + if not name: + return + + # Report timing metrics for bottleneck analysis (W&B) + live_status.report_shard_timing(r) + + # Update progress + live_status.advance_dataset(name) + dataset_completed_counts[name] = dataset_completed_counts.get(name, 0) + 1 + + # Check if dataset is complete + if dataset_completed_counts[name] >= dataset_pending_counts.get(name, 0): + ep = ep_by_name.get(name) + if ep: + # Aggregate final stats for this dataset + results[name] = _aggregate_stats_from_receipts(ep.receipts_dir, ep.plan, fs) + live_status.report_metrics( + name, + rows=results[name].get("total_sequences", 0), + tokens=results[name].get("total_tokens", 0), + ) + live_status.complete_dataset(name) + + def on_progress(p: dict) -> None: + """Callback for periodic progress updates.""" + phase = p.get("phase", "processing") + detail = p.get("detail", "") + + # Report phase to all active datasets that haven't completed + for ds_name in active_datasets: + if dataset_completed_counts.get(ds_name, 0) < dataset_pending_counts.get(ds_name, 0): + live_status.report_phase(ds_name, phase, detail) + + # Execute tasks via Ray Data + execute_shard_tasks( + tasks, + udf_cls=BinIdxShardTaskUDF, + udf_constructor_kwargs={ + "resolved_tokenizer": resolved_tokenizer, + "min_doc_chars": output_config.min_doc_chars, + "max_doc_tokens": output_config.max_doc_tokens, + "dtype": output_config.dtype, + "max_rows": output_config.max_rows, + }, + exec_cfg=exec_cfg, + on_result=on_result, + on_progress=on_progress, + ) + + +def _process_shards_with_actors( + pending_indices: list[int], + plan: ShardPlan, + dataset_dir: str, + receipts_dir: str, + dataset_config: DatasetConfig, + output_config: InternalOutputConfig, + fs, + on_progress: Callable[[], None] | None = None, +): + """Process pending shards using actor pool. + + Args: + on_progress: Optional callback called when a shard completes + """ + # Determine filesystem protocol from fs object (not from path which has scheme stripped) + protocol = fs.protocol + if isinstance(protocol, tuple): + protocol = protocol[0] + # Map protocol names to fsspec protocol identifiers + fs_protocol = protocol if protocol != "file" else "file" + + # Auto-detect num_actors from cluster + num_actors = get_num_actors_from_cluster() + + # Create actor pool + actors = [ + ShardProcessor.remote( + resolved_tokenizer=plan.resolved_tokenizer, + text_field=dataset_config.text_field, + min_doc_chars=output_config.min_doc_chars, + max_doc_tokens=output_config.max_doc_tokens, + dtype=output_config.dtype, + max_rows=output_config.max_rows, + ) + for _ in range(num_actors) + ] + + # Convert assignments to dicts for Ray serialization + assignment_dicts = {} + for a in plan.file_assignments: + assignment_dicts[a.shard_index] = { + "shard_index": a.shard_index, + "files": [asdict(f) for f in a.files], + "total_bytes": a.total_bytes, + } + + # Use backpressure loop: keep at most 2*num_actors tasks in flight + # This prevents memory bloat from submitting all tasks at once + max_in_flight = num_actors * 2 + shard_queue = list(pending_indices) + actor_idx = 0 + total = len(pending_indices) + + # Track futures as list directly to avoid repeated dict->list conversion in ray.wait + pending_list: list = [] + future_to_shard: dict = {} + future_to_start_time: dict = {} # Track when each task was submitted + + # Timeout configuration + task_warn_timeout = 120 # Log warning after 2 minutes + task_cancel_timeout = 600 # Cancel task after 10 minutes + + def submit_task(shard_index: int) -> None: + nonlocal actor_idx + actor = actors[actor_idx % num_actors] + actor_idx += 1 + future = actor.process_shard.remote( + shard_index=shard_index, + assignment=assignment_dicts[shard_index], + plan_hash=plan.plan_hash, + output_dir=dataset_dir, + receipts_dir=receipts_dir, + fs_protocol=fs_protocol, + ) + pending_list.append(future) + future_to_shard[future] = shard_index + future_to_start_time[future] = time.time() + + # Initial submission up to max_in_flight + while shard_queue and len(pending_list) < max_in_flight: + submit_task(shard_queue.pop(0)) + + # Track which tasks we've already warned about + warned_tasks: set = set() + + # Process with backpressure + def process_loop(advance_fn: Callable[[], None]) -> None: + nonlocal pending_list, shard_queue + while pending_list: + # ray.wait returns (done, remaining) - use remaining directly + done, pending_list = ray.wait(pending_list, num_returns=1, timeout=60) + + # Handle timeout: log info about long-running tasks + if not done and pending_list: + current_time = time.time() + tasks_to_cancel = [] + + for future in pending_list: + shard_index = future_to_shard.get(future) + start_time = future_to_start_time.get(future, current_time) + elapsed = current_time - start_time + + # Check for tasks that should be cancelled + if elapsed > task_cancel_timeout: + tasks_to_cancel.append((future, shard_index, elapsed)) + # Log warning for long-running tasks (only once per task) + elif elapsed > task_warn_timeout and future not in warned_tasks: + warned_tasks.add(future) + logger.warning( + f"Shard {shard_index} has been running for {elapsed:.0f}s " + f"(likely slow HuggingFace download)" + ) + + # Cancel truly stuck tasks + for future, shard_index, elapsed in tasks_to_cancel: + logger.error(f"Cancelling shard {shard_index} after {elapsed:.0f}s timeout") + try: + ray.cancel(future, force=True) + except Exception as e: + logger.debug(f"Failed to cancel task: {e}") + + # Remove from tracking + pending_list.remove(future) + future_to_shard.pop(future, None) + future_to_start_time.pop(future, None) + warned_tasks.discard(future) + + # Count as completed (with error) to unblock progress + advance_fn() + + # Submit replacement task if queue has more + if shard_queue: + submit_task(shard_queue.pop(0)) + + continue + + for future in done: + shard_index = future_to_shard.pop(future) + future_to_start_time.pop(future, None) + warned_tasks.discard(future) + try: + ray.get(future) + advance_fn() + except Exception as e: + logger.error(f"Shard {shard_index} failed: {e}") + advance_fn() + + # Submit next task if queue has more + if shard_queue: + submit_task(shard_queue.pop(0)) + + if on_progress is not None: + # Use external progress callback (for live status panel) + process_loop(on_progress) + else: + # Use standalone progress bar + with con.create_progress() as progress: + task = progress.add_task("Processing shards", total=total) + process_loop(lambda: progress.advance(task)) + + +def _aggregate_stats_from_receipts( + receipts_dir: str, + plan: ShardPlan, + fs, +) -> dict: + """Aggregate statistics from all shard receipts.""" + stats = { + "num_shards_completed": 0, + "total_sequences": 0, + "total_tokens": 0, + "total_bin_bytes": 0, + "total_idx_bytes": 0, + } + + try: + receipt_files = fs.glob(f"{receipts_dir}/shard_*.json") + except FileNotFoundError: + return stats + except Exception: + return stats + + for receipt_file in receipt_files: + try: + receipt = read_json(fs, receipt_file) + if receipt.get("status") == "completed" and receipt.get("plan_hash") == plan.plan_hash: + stats["num_shards_completed"] += 1 + stats["total_sequences"] += receipt["stats"]["num_sequences"] + stats["total_tokens"] += receipt["stats"]["total_tokens"] + stats["total_bin_bytes"] += receipt["files"]["bin"]["bytes"] + stats["total_idx_bytes"] += receipt["files"]["idx"]["bytes"] + except Exception: + pass + + return stats + + +def _generate_manifest( + run_dir: str, + config: dict, + results: dict, + plan_hashes: dict[str, str], + run_hash: str, + resolved_tokenizer: dict | None, + fs, +): + """Generate manifest summary.""" + # Use resolved tokenizer (with SHA) if available, otherwise fall back to config + tokenizer_info = resolved_tokenizer if resolved_tokenizer else config["tokenizer"] + + manifest = { + "version": "1.0", + "generated_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()), + "run_hash": run_hash, + "tokenizer": tokenizer_info, + "datasets": {}, + } + + for name, stats in results.items(): + num_shards = config["output"]["num_shards"] + completed = stats.get("num_shards_completed", 0) + status = "completed" if completed == num_shards else "in_progress" + + manifest["datasets"][name] = { + "status": status, + "plan_hash": plan_hashes.get(name), + "num_shards": num_shards, + **stats, + } + + write_json(fs, f"{run_dir}/manifest.json", manifest) + + +# ============================================================================ +# JSONL Processing (No Tokenization) +# ============================================================================ + + +def _process_jsonl_blend(blend: DataBlend, config: PipelineConfig) -> PipelineResult: + """Process blend to JSONL output (no tokenization). + + Transforms records according to the configured transform function + and writes to JSONL files (optionally compressed). + """ + + format_config = config.output.format + assert isinstance(format_config, JsonlOutputConfig) + + # Get filesystem + fs, base_path = get_filesystem(str(config.output.dir)) + + # Compute run hash (different from tokenization - no tokenizer info) + run_config = { + "datasets": [ + { + "name": d.name, + "path": d.path, + "weight": d.weight, + "split": d.split, + "subset": d.subset, + } + for d in blend.datasets + ], + "output": { + "format": "jsonl", + "compression": format_config.compression, + }, + } + if config.sample is not None: + run_config["_sample"] = {"spec": str(config.sample), "seed": config.sample_seed} + + config_hash = hashlib.sha256(json.dumps(run_config, sort_keys=True).encode()).hexdigest()[:16] + + run_hash = config_hash if not config.force else f"{config_hash}_{int(time.time())}" + run_dir = f"{base_path}/runs/{run_hash}" + ensure_dir(fs, run_dir) + + # Freeze config + write_json(fs, f"{run_dir}/config.json", run_config) + + # Determine num_shards from format config + num_shards = _resolve_num_shards(format_config, blend, fs) + + # For JSONL, we use a simpler processing model: + # Each dataset's files are distributed across shards and written directly + results = {} + data_paths: list[str] = [] + + con.planning_header() + + # Planning phase: discover files and check cache for all datasets + from nemotron.data_prep.discovery import discover_input_files, get_dataset_metadata + + dataset_plans: list[tuple] = [] # (dataset, dataset_dir, files, cached_stats) + plan_infos = [] + + for dataset in blend.datasets: + name = dataset.name + + # Create dataset directory + dataset_dir = f"{run_dir}/datasets/{name}" + ensure_dir(fs, dataset_dir) + + # Get files for this dataset + dataset_config = DatasetConfig( + name=dataset.name, + path=dataset.path, + split=dataset.split, + subset=dataset.subset, + text_field=dataset.text_field, + ) + files = discover_input_files(dataset_config, fs) + + # Check cached stats + cached_stats = _aggregate_jsonl_stats(dataset_dir, num_shards, fs) + cached_shards = cached_stats.get("num_shards_completed", 0) + pending_shards = num_shards - cached_shards + + # Fetch HuggingFace metadata (non-blocking, best-effort) + hf_metadata = get_dataset_metadata(dataset_config) + + # Build plan info for display + plan_infos.append( + con.DatasetPlanInfo( + name=name, + plan_hash=run_hash[:8], + num_shards=num_shards, + num_files=len(files), + pending=pending_shards, + cached=cached_shards, + cached_tokens=0, # JSONL doesn't track tokens + cached_sequences=cached_stats.get("num_records", 0), + sampled=num_shards if config.output.max_rows else None, + hf_rows=hf_metadata.num_rows_str, + hf_size=hf_metadata.size_str, + ) + ) + + dataset_plans.append((dataset, dataset_dir, files, cached_stats)) + + # Show plan summary (auto-detect workers from cluster) + con.plan_summary(plan_infos, run_hash) + + # Execution phase + has_work = any( + num_shards - cached_stats.get("num_shards_completed", 0) > 0 + for _, _, _, cached_stats in dataset_plans + ) + + if has_work: + con.execution_header() + + for dataset, dataset_dir, files, cached_stats in dataset_plans: + name = dataset.name + + # Process with actors + if files: + _process_jsonl_shards_with_actors( + files=files, + num_shards=num_shards, + dataset_dir=dataset_dir, + text_field=dataset.text_field, + transform=format_config.transform, + compression=format_config.compression, + max_rows=config.output.max_rows, + fs=fs, + ) + + # Aggregate stats + stats = _aggregate_jsonl_stats(dataset_dir, num_shards, fs) + results[name] = stats + + # Build data_paths + weight = dataset.weight + if weight > 0: + prefix = f"{dataset_dir}/shard" + data_paths.append(str(weight)) + data_paths.append(prefix) + + # Generate blend.json + blend_data: dict = {"data_paths": data_paths} + if config.split: + blend_data["split"] = config.split + + blend_path = config.output.dir / "blend.json" + _write_json(blend_path, blend_data) + + return PipelineResult( + output_dir=config.output.dir, + blend_path=blend_path, + splits={ + "all": SplitResult( + name="all", + run_hash=run_hash, + output_dir=config.output.dir, + data_paths=data_paths, + num_shards=num_shards, + total_tokens=0, # No tokenization + total_sequences=sum(r.get("num_records", 0) for r in results.values()), + ) + }, + is_per_split=False, + split_ratio=config.split, + elapsed_sec=0, + ) + + +def _resolve_num_shards(format_config, blend: DataBlend, fs) -> int: + """Resolve num_shards from format config (shard_size or explicit num_shards).""" + from nemotron.data_prep.utils.size import compute_num_shards + + if format_config.num_shards is not None: + return format_config.num_shards + + # Compute from shard_size + if format_config.shard_size is not None: + # Estimate total bytes from blend + total_bytes = _estimate_blend_bytes(blend, fs) + return compute_num_shards(total_bytes, format_config.shard_size) + + # Default fallback + return 128 + + +def _estimate_blend_bytes(blend: DataBlend, fs) -> int: + """Estimate total bytes in blend for shard planning.""" + from nemotron.data_prep.discovery import discover_input_files + + total = 0 + for dataset in blend.datasets: + try: + dataset_config = DatasetConfig( + name=dataset.name, + path=dataset.path, + split=dataset.split, + subset=dataset.subset, + text_field=dataset.text_field, + ) + files = discover_input_files(dataset_config, fs) + total += sum(f.size for f in files) + except Exception: + pass + return total or 1 # Avoid division by zero + + +def _process_jsonl_shards_with_actors( + files: list, + num_shards: int, + dataset_dir: str, + text_field: str, + transform, + compression: str, + max_rows: int | None, + fs, +) -> None: + """Process files to JSONL shards using Ray actors.""" + from nemotron.data_prep.jsonl_processor import JsonlShardProcessor + + # Determine filesystem protocol + protocol = fs.protocol + if isinstance(protocol, tuple): + protocol = protocol[0] + fs_protocol = protocol if protocol != "file" else "file" + + # Auto-detect num_actors from cluster + num_actors = get_num_actors_from_cluster() + + # Create actor pool + actors = [ + JsonlShardProcessor.remote( + text_field=text_field, + transform=transform, + compression=compression, + max_rows=max_rows, + ) + for _ in range(num_actors) + ] + + # Distribute files across shards (round-robin for now) + # TODO: Could use smarter distribution based on file sizes + shard_assignments: dict[int, list] = {i: [] for i in range(num_shards)} + for i, file_info in enumerate(files): + shard_idx = i % num_shards + shard_assignments[shard_idx].append(file_info) + + # Submit tasks with backpressure + max_in_flight = num_actors * 2 + shard_queue = list(range(num_shards)) + actor_idx = 0 + pending_list: list = [] + future_to_shard: dict = {} + + def submit_task(shard_index: int) -> None: + nonlocal actor_idx + actor = actors[actor_idx % num_actors] + actor_idx += 1 + future = actor.process_shard.remote( + shard_index=shard_index, + files=[ + f.__dict__ if hasattr(f, "__dict__") else f for f in shard_assignments[shard_index] + ], + output_dir=dataset_dir, + fs_protocol=fs_protocol, + ) + pending_list.append(future) + future_to_shard[future] = shard_index + + # Initial submission + while shard_queue and len(pending_list) < max_in_flight: + submit_task(shard_queue.pop(0)) + + # Process with backpressure + while pending_list: + done, pending_list = ray.wait(pending_list, num_returns=1, timeout=60) + for future in done: + shard_index = future_to_shard.pop(future) + try: + ray.get(future) + except Exception as e: + logger.error(f"JSONL shard {shard_index} failed: {e}") + + if shard_queue: + submit_task(shard_queue.pop(0)) + + +def _aggregate_jsonl_stats(dataset_dir: str, num_shards: int, fs) -> dict: + """Aggregate statistics from JSONL receipts.""" + stats = { + "num_shards_completed": 0, + "num_records": 0, + "num_skipped": 0, + "total_bytes": 0, + } + + try: + receipt_files = fs.glob(f"{dataset_dir}/shard_*.receipt.json") + except Exception: + return stats + + for receipt_file in receipt_files: + try: + receipt = read_json(fs, receipt_file) + if receipt.get("status") == "completed": + stats["num_shards_completed"] += 1 + stats["num_records"] += receipt.get("num_records", 0) + stats["num_skipped"] += receipt.get("num_skipped", 0) + stats["total_bytes"] += receipt.get("total_bytes", 0) + except Exception: + pass + + return stats + + +# ============================================================================ +# Packed Sequence Processing (Tokenization + Packing) +# ============================================================================ + + +def _process_packed_blend(blend: DataBlend, config: PipelineConfig) -> PipelineResult: + """Process blend to packed sequence output (.npy files). + + Tokenizes records and packs them into efficient batches compatible with + Megatron-Bridge's GPTSFTPackedDataset. + """ + from nemotron.data_prep.discovery import discover_input_files + + format_config = config.output.format + assert isinstance(format_config, PackedOutputConfig) + + # Get filesystem + fs, base_path = get_filesystem(str(config.output.dir)) + + # Compute run hash (includes tokenizer, pack_size, algorithm) + run_config = { + "datasets": [ + { + "name": d.name, + "path": d.path, + "weight": d.weight, + "split": d.split, + "subset": d.subset, + "text_field": d.text_field, + } + for d in blend.datasets + ], + "tokenizer": { + "type": config.tokenizer.type, + "model": config.tokenizer.model, + "add_bos": config.tokenizer.add_bos, + "add_eos": config.tokenizer.add_eos, + "trust_remote_code": config.tokenizer.trust_remote_code, + }, + "output": { + "format": "packed", + "pack_size": format_config.pack_size, + "algorithm": format_config.algorithm, + "dtype": format_config.dtype, + }, + } + if config.sample is not None: + run_config["_sample"] = {"spec": str(config.sample), "seed": config.sample_seed} + + config_hash = hashlib.sha256(json.dumps(run_config, sort_keys=True).encode()).hexdigest()[:16] + + run_hash = config_hash if not config.force else f"{config_hash}_{int(time.time())}" + run_dir = f"{base_path}/runs/{run_hash}" + ensure_dir(fs, run_dir) + + # Freeze config + write_json(fs, f"{run_dir}/config.json", run_config) + + # Determine num_shards from format config + num_shards = _resolve_num_shards(format_config, blend, fs) + + # Resolve tokenizer to get SHA for determinism + from nemotron.data_prep.planning import resolve_tokenizer + + tokenizer_config = InternalTokenizerConfig(**run_config["tokenizer"]) + resolved_tokenizer = resolve_tokenizer(tokenizer_config) + + # Process each dataset + results = {} + data_paths: list[str] = [] + + con.planning_header() + + for dataset in blend.datasets: + name = dataset.name + + # Create dataset directory structure + dataset_dir = f"{run_dir}/datasets/{name}" + receipts_dir = f"{dataset_dir}/receipts" + ensure_dir(fs, dataset_dir) + ensure_dir(fs, receipts_dir) + + # Get files for this dataset + dataset_config = DatasetConfig( + name=dataset.name, + path=dataset.path, + split=dataset.split, + subset=dataset.subset, + text_field=dataset.text_field, + ) + files = discover_input_files(dataset_config, fs) + + # Display info + logger.info( + f"Processing dataset '{name}' with {len(files)} files -> " + f"{num_shards} packed shards (pack_size={format_config.pack_size})" + ) + + # Process with actors + if files: + _process_packed_shards_with_actors( + files=files, + num_shards=num_shards, + dataset_dir=dataset_dir, + receipts_dir=receipts_dir, + text_field=dataset.text_field, + resolved_tokenizer=resolved_tokenizer, + format_config=format_config, + min_doc_chars=config.output.min_doc_chars, + max_doc_tokens=config.output.max_doc_tokens, + max_rows=config.output.max_rows, + fs=fs, + ) + + # Aggregate stats + stats = _aggregate_packed_stats(dataset_dir, receipts_dir, fs) + results[name] = stats + + # Build data_paths + weight = dataset.weight + if weight > 0: + prefix = f"{dataset_dir}/shard" + data_paths.append(str(weight)) + data_paths.append(prefix) + + # Generate blend.json + blend_data: dict = {"data_paths": data_paths} + if config.split: + blend_data["split"] = config.split + + blend_path = config.output.dir / "blend.json" + _write_json(blend_path, blend_data) + + return PipelineResult( + output_dir=config.output.dir, + blend_path=blend_path, + splits={ + "all": SplitResult( + name="all", + run_hash=run_hash, + output_dir=config.output.dir, + data_paths=data_paths, + num_shards=num_shards, + total_tokens=sum(r.get("total_tokens", 0) for r in results.values()), + total_sequences=sum(r.get("num_sequences", 0) for r in results.values()), + ) + }, + is_per_split=False, + split_ratio=config.split, + elapsed_sec=0, + ) + + +def _process_packed_shards_with_actors( + files: list, + num_shards: int, + dataset_dir: str, + receipts_dir: str, + text_field: str, + resolved_tokenizer: dict, + format_config: PackedOutputConfig, + min_doc_chars: int | None, + max_doc_tokens: int | None, + max_rows: int | None, + fs, +) -> None: + """Process files to packed shards using Ray actors.""" + from dataclasses import asdict + + from nemotron.data_prep.packed_processor import PackedShardProcessor + + # Determine filesystem protocol + protocol = fs.protocol + if isinstance(protocol, tuple): + protocol = protocol[0] + fs_protocol = protocol if protocol != "file" else "file" + + # Auto-detect num_actors from cluster + num_actors = get_num_actors_from_cluster() + + # Create actor pool + actors = [ + PackedShardProcessor.remote( + resolved_tokenizer=resolved_tokenizer, + text_field=text_field, + pack_size=format_config.pack_size, + algorithm=format_config.algorithm, + dtype=format_config.dtype, + min_doc_chars=min_doc_chars, + max_doc_tokens=max_doc_tokens, + max_rows=max_rows, + seed=42, # Fixed seed for reproducibility + ) + for _ in range(num_actors) + ] + + # Distribute files across shards (round-robin) + shard_assignments: dict[int, list] = {i: [] for i in range(num_shards)} + for i, file_info in enumerate(files): + shard_idx = i % num_shards + # Convert FileInfo to dict for Ray serialization + if hasattr(file_info, "__dict__"): + shard_assignments[shard_idx].append(asdict(file_info)) + else: + shard_assignments[shard_idx].append(file_info) + + # Submit tasks with backpressure + max_in_flight = num_actors * 2 + shard_queue = list(range(num_shards)) + actor_idx = 0 + pending_list: list = [] + future_to_shard: dict = {} + + def submit_task(shard_index: int) -> None: + nonlocal actor_idx + actor = actors[actor_idx % num_actors] + actor_idx += 1 + future = actor.process_shard.remote( + shard_index=shard_index, + files=shard_assignments[shard_index], + output_dir=dataset_dir, + receipts_dir=receipts_dir, + fs_protocol=fs_protocol, + ) + pending_list.append(future) + future_to_shard[future] = shard_index + + # Initial submission + while shard_queue and len(pending_list) < max_in_flight: + submit_task(shard_queue.pop(0)) + + # Process with backpressure + while pending_list: + done, pending_list = ray.wait(pending_list, num_returns=1, timeout=60) + for future in done: + shard_index = future_to_shard.pop(future) + try: + ray.get(future) + except Exception as e: + logger.error(f"Packed shard {shard_index} failed: {e}") + + if shard_queue: + submit_task(shard_queue.pop(0)) + + +def _aggregate_packed_stats(dataset_dir: str, receipts_dir: str, fs) -> dict: + """Aggregate statistics from packed receipts.""" + stats = { + "num_shards_completed": 0, + "num_sequences": 0, + "num_packed_sequences": 0, + "total_tokens": 0, + "total_npy_bytes": 0, + } + + try: + receipt_files = fs.glob(f"{receipts_dir}/shard_*.json") + except Exception: + return stats + + for receipt_file in receipt_files: + try: + receipt = read_json(fs, receipt_file) + if receipt.get("status") == "completed": + stats["num_shards_completed"] += 1 + stats["num_sequences"] += receipt["stats"].get("num_sequences", 0) + stats["num_packed_sequences"] += receipt["stats"].get("num_packed_sequences", 0) + stats["total_tokens"] += receipt["stats"].get("total_tokens", 0) + stats["total_npy_bytes"] += receipt.get("npy_bytes", 0) + except Exception: + pass + + return stats + + +# ============================================================================ +# Chat SFT Processing (Tokenization + Loss Masking + Packing) +# ============================================================================ + + +def _process_chat_sft_blend(blend: DataBlend, config: PipelineConfig) -> PipelineResult: + """Process blend to chat-templated SFT output (.npy files with loss masks). + + Applies materialize.py chat template logic, tokenizes with role-based + loss masking, and packs sequences into .npy files compatible with + GPTSFTPackedDataset. + """ + from nemotron.data_prep.chat_sft_processor import ChatSftShardProcessor + from nemotron.data_prep.discovery import discover_input_files + + format_config = config.output.format + assert isinstance(format_config, ChatSftOutputConfig) + + # Get filesystem + fs, base_path = get_filesystem(str(config.output.dir)) + + # Compute run hash (includes tokenizer, pack_size, algorithm, chat_template) + run_config = { + "datasets": [ + { + "name": d.name, + "path": d.path, + "weight": d.weight, + "split": d.split, + "subset": d.subset, + } + for d in blend.datasets + ], + "tokenizer": { + "type": config.tokenizer.type, + "model": config.tokenizer.model, + "add_bos": config.tokenizer.add_bos, + "add_eos": config.tokenizer.add_eos, + "trust_remote_code": config.tokenizer.trust_remote_code, + }, + "output": { + "format": "chat_sft", + "pack_size": format_config.pack_size, + "algorithm": format_config.algorithm, + "dtype": format_config.dtype, + "chat_template": format_config.chat_template, + "messages_field": format_config.messages_field, + "tools_field": format_config.tools_field, + }, + } + if config.sample is not None: + run_config["_sample"] = {"spec": str(config.sample), "seed": config.sample_seed} + + config_hash = hashlib.sha256(json.dumps(run_config, sort_keys=True).encode()).hexdigest()[:16] + + run_hash = config_hash if not config.force else f"{config_hash}_{int(time.time())}" + run_dir = f"{base_path}/runs/{run_hash}" + ensure_dir(fs, run_dir) + + # Freeze config + write_json(fs, f"{run_dir}/config.json", run_config) + + # Determine num_shards from format config + num_shards = _resolve_num_shards(format_config, blend, fs) + + # Resolve tokenizer to get SHA for determinism + from nemotron.data_prep.planning import resolve_tokenizer + + tokenizer_config = InternalTokenizerConfig(**run_config["tokenizer"]) + resolved_tokenizer = resolve_tokenizer(tokenizer_config) + + # Planning phase: discover files for all datasets first + results = {} + data_paths: list[str] = [] + + con.planning_header() + + # Discover files for all datasets + dataset_plans: list[tuple] = [] # (dataset, dataset_dir, receipts_dir, files) + for dataset in blend.datasets: + name = dataset.name + + # Create dataset directory structure + dataset_dir = f"{run_dir}/datasets/{name}" + receipts_dir = f"{dataset_dir}/receipts" + ensure_dir(fs, dataset_dir) + ensure_dir(fs, receipts_dir) + + # Get files for this dataset + dataset_config = DatasetConfig( + name=dataset.name, + path=dataset.path, + split=dataset.split, + subset=dataset.subset, + text_field=dataset.text_field, + ) + files = discover_input_files(dataset_config, fs) + + # Display discovered info + logger.info(f"Discovered dataset '{name}' with {len(files)} files") + + dataset_plans.append((dataset, dataset_dir, receipts_dir, files)) + + # Build plan info for display + plan_infos = [] + for dataset, dataset_dir, receipts_dir, files in dataset_plans: + # Check cached stats + cached_stats = _aggregate_packed_stats(dataset_dir, receipts_dir, fs) + cached_shards = cached_stats.get("num_shards_completed", 0) + + plan_infos.append( + con.DatasetPlanInfo( + name=dataset.name, + plan_hash=run_hash[:8], + num_shards=num_shards, + num_files=len(files), + pending=num_shards - cached_shards if files else 0, + cached=cached_shards, + cached_tokens=cached_stats.get("total_tokens", 0), + cached_sequences=cached_stats.get("num_sequences", 0), + sampled=num_shards if config.output.max_rows else None, + hf_rows=None, + hf_size=None, + ) + ) + + # Show plan summary (auto-detect workers from cluster) + con.plan_summary(plan_infos, run_hash) + + # Execution phase + has_work = any(len(files) > 0 for _, _, _, files in dataset_plans) + + if has_work: + con.execution_header() + + # Create actor pool ONCE and reuse across all datasets + from dataclasses import asdict + + from nemotron.data_prep.chat_sft_processor import ChatSftShardProcessor + + # Auto-detect num_actors from cluster + num_actors = get_num_actors_from_cluster() + + actors = [ + ChatSftShardProcessor.remote( + resolved_tokenizer=resolved_tokenizer, + messages_field=format_config.messages_field, + tools_field=format_config.tools_field, + pack_size=format_config.pack_size, + algorithm=format_config.algorithm, + dtype=format_config.dtype, + chat_template=format_config.chat_template, + max_doc_tokens=config.output.max_doc_tokens, + max_rows=config.output.max_rows, + seed=42, + used_in_filter=format_config.used_in_filter, + used_in_field=format_config.used_in_field, + ) + for _ in range(num_actors) + ] + + # Create live status panel with all datasets + live_status = con.create_live_status( + datasets=[ + (dataset.name, num_shards) for dataset, _, _, files in dataset_plans if files + ], + run_hash=run_hash, + ) + live_status.start() + + try: + # Determine filesystem protocol + protocol = fs.protocol + if isinstance(protocol, tuple): + protocol = protocol[0] + fs_protocol = protocol if protocol != "file" else "file" + + # Build all tasks upfront - process ALL datasets in parallel + all_tasks: list[ + tuple[str, str, str, int, list] + ] = [] # (name, dataset_dir, receipts_dir, shard_idx, files) + for dataset, dataset_dir, receipts_dir, files in dataset_plans: + if not files: + continue + # Each dataset gets 1 shard (since num_shards is computed per-dataset with 1 file) + # Convert files to dicts for Ray serialization + files_as_dicts = [asdict(f) if hasattr(f, "__dict__") else f for f in files] + all_tasks.append((dataset.name, dataset_dir, receipts_dir, 0, files_as_dicts)) + live_status.start_dataset(dataset.name) + + # Submit all tasks with backpressure + num_actors = len(actors) + max_in_flight = num_actors * 2 + task_queue = list(all_tasks) + actor_idx = 0 + pending_list: list = [] + future_to_task: dict = {} + + def submit_task(task: tuple) -> None: + nonlocal actor_idx + name, dataset_dir, receipts_dir, shard_idx, files_dicts = task + actor = actors[actor_idx % num_actors] + actor_idx += 1 + future = actor.process_shard.remote( + shard_index=shard_idx, + files=files_dicts, + output_dir=dataset_dir, + receipts_dir=receipts_dir, + fs_protocol=fs_protocol, + ) + pending_list.append(future) + future_to_task[future] = task + + # Initial submission + while task_queue and len(pending_list) < max_in_flight: + submit_task(task_queue.pop(0)) + + # Process with backpressure + while pending_list: + done, pending_list = ray.wait(pending_list, num_returns=1, timeout=60) + for future in done: + task = future_to_task.pop(future) + name = task[0] + dataset_dir = task[1] + receipts_dir = task[2] + try: + ray.get(future) + except Exception as e: + logger.error(f"Chat SFT shard for {name} failed: {e}") + + # Update progress + live_status.advance_dataset(name) + + # Aggregate stats for this dataset + stats = _aggregate_packed_stats(dataset_dir, receipts_dir, fs) + results[name] = stats + live_status.report_metrics( + name, + rows=stats.get("num_sequences", 0), + tokens=stats.get("total_tokens", 0), + ) + live_status.complete_dataset(name) + + # Submit next task if available + if task_queue: + submit_task(task_queue.pop(0)) + + # Build data_paths for all completed datasets + for dataset, dataset_dir, receipts_dir, files in dataset_plans: + if not files: + continue + weight = dataset.weight + if weight > 0: + prefix = f"{dataset_dir}/shard" + data_paths.append(str(weight)) + data_paths.append(prefix) + finally: + live_status.stop() + # Clean up actors + for actor in actors: + ray.kill(actor) + else: + # No work to do - all datasets empty or cached + for dataset, dataset_dir, receipts_dir, files in dataset_plans: + stats = _aggregate_packed_stats(dataset_dir, receipts_dir, fs) + results[dataset.name] = stats + weight = dataset.weight + if weight > 0: + prefix = f"{dataset_dir}/shard" + data_paths.append(str(weight)) + data_paths.append(prefix) + + # Generate blend.json + # Check if per-split output mode is enabled + if config.per_split is not None and config.per_split.enabled: + blend_data = _distribute_shards_to_splits( + data_paths=data_paths, + num_shards=num_shards, + valid_shards=config.per_split.valid_shards, + test_shards=config.per_split.test_shards, + ) + is_per_split = True + split_ratio = None + else: + blend_data = {"data_paths": data_paths} + if config.split: + blend_data["split"] = config.split + is_per_split = False + split_ratio = config.split + + blend_path = config.output.dir / "blend.json" + _write_json(blend_path, blend_data) + + return PipelineResult( + output_dir=config.output.dir, + blend_path=blend_path, + splits={ + "all": SplitResult( + name="all", + run_hash=run_hash, + output_dir=config.output.dir, + data_paths=data_paths, + num_shards=num_shards, + total_tokens=sum(r.get("total_tokens", 0) for r in results.values()), + total_sequences=sum(r.get("num_sequences", 0) for r in results.values()), + ) + }, + is_per_split=is_per_split, + split_ratio=split_ratio, + elapsed_sec=0, + ) + + +def _process_chat_sft_shards_with_actors_pool( + actors: list, + files: list, + num_shards: int, + dataset_dir: str, + receipts_dir: str, + max_rows: int | None, + fs, + on_progress: Callable[[], None] | None = None, +) -> None: + """Process files to chat SFT packed shards using existing Ray actor pool. + + This version takes a pre-created actor pool to allow reuse across datasets. + """ + from dataclasses import asdict + + # Determine filesystem protocol + protocol = fs.protocol + if isinstance(protocol, tuple): + protocol = protocol[0] + fs_protocol = protocol if protocol != "file" else "file" + + num_actors = len(actors) + + # Distribute files across shards (round-robin) + shard_assignments: dict[int, list] = {i: [] for i in range(num_shards)} + for i, file_info in enumerate(files): + shard_idx = i % num_shards + # Convert FileInfo to dict for Ray serialization + if hasattr(file_info, "__dict__"): + shard_assignments[shard_idx].append(asdict(file_info)) + else: + shard_assignments[shard_idx].append(file_info) + + # Submit tasks with backpressure + max_in_flight = num_actors * 2 + shard_queue = list(range(num_shards)) + actor_idx = 0 + pending_list: list = [] + future_to_shard: dict = {} + + def submit_task(shard_index: int) -> None: + nonlocal actor_idx + actor = actors[actor_idx % num_actors] + actor_idx += 1 + future = actor.process_shard.remote( + shard_index=shard_index, + files=shard_assignments[shard_index], + output_dir=dataset_dir, + receipts_dir=receipts_dir, + fs_protocol=fs_protocol, + ) + pending_list.append(future) + future_to_shard[future] = shard_index + + # Initial submission + while shard_queue and len(pending_list) < max_in_flight: + submit_task(shard_queue.pop(0)) + + # Process with backpressure + while pending_list: + done, pending_list = ray.wait(pending_list, num_returns=1, timeout=60) + for future in done: + shard_index = future_to_shard.pop(future) + try: + ray.get(future) + if on_progress: + on_progress() + except Exception as e: + logger.error(f"Chat SFT shard {shard_index} failed: {e}") + if on_progress: + on_progress() + + if shard_queue: + submit_task(shard_queue.pop(0)) + + +def _process_chat_sft_shards_with_actors( + files: list, + num_shards: int, + dataset_dir: str, + receipts_dir: str, + resolved_tokenizer: dict, + format_config: ChatSftOutputConfig, + max_doc_tokens: int | None, + max_rows: int | None, + fs, + on_progress: Callable[[], None] | None = None, +) -> None: + """Process files to chat SFT packed shards using Ray actors. + + This creates its own actor pool - for single dataset processing. + For processing multiple datasets, use _process_chat_sft_shards_with_actors_pool + with a shared actor pool. + """ + from nemotron.data_prep.chat_sft_processor import ChatSftShardProcessor + + # Auto-detect num_actors from cluster + num_actors = get_num_actors_from_cluster() + + # Create actor pool + actors = [ + ChatSftShardProcessor.remote( + resolved_tokenizer=resolved_tokenizer, + messages_field=format_config.messages_field, + tools_field=format_config.tools_field, + pack_size=format_config.pack_size, + algorithm=format_config.algorithm, + dtype=format_config.dtype, + chat_template=format_config.chat_template, + max_doc_tokens=max_doc_tokens, + max_rows=max_rows, + seed=42, # Fixed seed for reproducibility + used_in_filter=format_config.used_in_filter, + used_in_field=format_config.used_in_field, + ) + for _ in range(num_actors) + ] + + try: + _process_chat_sft_shards_with_actors_pool( + actors=actors, + files=files, + num_shards=num_shards, + dataset_dir=dataset_dir, + receipts_dir=receipts_dir, + max_rows=max_rows, + fs=fs, + on_progress=on_progress, + ) + finally: + # Clean up actors + for actor in actors: + ray.kill(actor) diff --git a/src/nemotron/data_prep/planning.py b/src/nemotron/data_prep/planning.py new file mode 100644 index 0000000..be793a2 --- /dev/null +++ b/src/nemotron/data_prep/planning.py @@ -0,0 +1,364 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Shard plan creation with size-balanced file assignment.""" + +import hashlib +import heapq +import json +import logging +import random +from dataclasses import asdict +from datetime import datetime, timezone +from pathlib import Path + +import ray +from fsspec import AbstractFileSystem + +from nemotron.data_prep.config import ( + DatasetConfig, + FileInfo, + InternalOutputConfig, + InternalTokenizerConfig, + ShardAssignment, + ShardPlan, +) +from nemotron.data_prep.discovery import discover_input_files +from nemotron.data_prep.filesystem import read_json + +logger = logging.getLogger(__name__) + + +def create_size_balanced_assignments( + files: list[FileInfo], + num_shards: int, +) -> list[ShardAssignment]: + """ + Deterministically assign files to shards with size balancing. + + Algorithm: greedy bin-packing with heap (or round-robin if sizes unavailable) + - Sort files by (size desc, path asc) for determinism + - If sizes available: use min-heap to find shard with smallest total (O(n log k)) + - If sizes unavailable (all 0): use round-robin for even distribution + - Tie-break by shard index for determinism + """ + # Sort: largest files first, then by path for determinism + sorted_files = sorted(files, key=lambda f: (-f.size, f.path)) + + # Initialize assignments + assignments = [ + ShardAssignment(shard_index=i, files=[], total_bytes=0) for i in range(num_shards) + ] + + # Check if file sizes are available + has_sizes = any(f.size > 0 for f in files) + + if has_sizes: + # Use min-heap for O(n log k) assignment instead of O(n * k) + # Heap entries: (total_bytes, shard_index) - shard_index for tie-breaking + heap: list[tuple[int, int]] = [(0, i) for i in range(num_shards)] + heapq.heapify(heap) + + for file_info in sorted_files: + total_bytes, shard_idx = heapq.heappop(heap) + assignments[shard_idx].files.append(file_info) + assignments[shard_idx].total_bytes += file_info.size + heapq.heappush(heap, (total_bytes + file_info.size, shard_idx)) + else: + # Round-robin assignment when sizes are unavailable + for i, file_info in enumerate(sorted_files): + shard_idx = i % num_shards + assignments[shard_idx].files.append(file_info) + + # Sort files within each shard by path for deterministic processing order + for assignment in assignments: + assignment.files.sort(key=lambda f: f.path) + + return assignments + + +def _is_local_path(model: str) -> bool: + """Check if model refers to a local filesystem path.""" + return ( + model.startswith("/") + or model.startswith("./") + or model.startswith("../") + or Path(model).exists() + ) + + +def resolve_tokenizer(config: InternalTokenizerConfig) -> dict: + """Resolve tokenizer to immutable revision.""" + result = { + "type": config.type, + "model": config.model, + "add_eos": config.add_eos, + "add_bos": config.add_bos, + "trust_remote_code": config.trust_remote_code, + } + + if config.type == "huggingface": + from huggingface_hub import HfApi + from transformers import AutoTokenizer + + is_local = _is_local_path(config.model) + + if is_local: + # Local model - no revision needed + result["resolved_revision"] = "local" + revision_for_tokenizer = None + else: + # HuggingFace model - resolve to immutable SHA + api = HfApi() + try: + model_info = api.model_info(config.model, revision=config.revision) + result["resolved_revision"] = model_info.sha + revision_for_tokenizer = model_info.sha + except Exception: + # api.model_info() failed but this is a HF model, not local + # Use the user-specified revision (or None for default) + result["resolved_revision"] = config.revision + revision_for_tokenizer = config.revision + + # Get vocab size + tokenizer = AutoTokenizer.from_pretrained( + config.model, + revision=revision_for_tokenizer, + trust_remote_code=config.trust_remote_code, + ) + result["vocab_size"] = len(tokenizer) + + elif config.type == "sentencepiece": + import sentencepiece as spm + + sp = spm.SentencePieceProcessor(model_file=config.model) + result["resolved_revision"] = "local" + result["vocab_size"] = sp.vocab_size() + + return result + + +def compute_source_fingerprint(files: list[FileInfo], dataset_config: DatasetConfig) -> str: + """ + Compute fingerprint from file list and dataset identity. + + Includes: + - File path, size, etag + - mtime for local files (detects in-place modifications) + - version_id for S3/GCS versioned objects + - HF repo_id and revision for HF files (dataset identity) + """ + components = [] + + # Include dataset identity for HF sources + if dataset_config.path.startswith("hf://"): + hf_path = dataset_config.path[5:] + components.append(f"hf_repo:{hf_path}") + # First file has the resolved revision + if files and files[0].hf_revision: + components.append(f"hf_revision:{files[0].hf_revision}") + + for f in sorted(files, key=lambda x: x.path): + # Build comprehensive fingerprint component + parts = [f.path, str(f.size), f.etag or ""] + + # Add mtime for local files (stronger fingerprint) + if f.mtime is not None: + parts.append(f"mtime:{f.mtime}") + + # Add version_id for S3/GCS versioned objects + if f.version_id is not None: + parts.append(f"ver:{f.version_id}") + + # Add HF identity + if f.hf_repo_id is not None: + parts.append(f"hf:{f.hf_repo_id}@{f.hf_revision}") + + components.append(":".join(parts)) + + content = "\n".join(components) + return f"sha256:{hashlib.sha256(content.encode()).hexdigest()}" + + +def create_shard_plan( + dataset_config: DatasetConfig, + output_config: InternalOutputConfig, + tokenizer_config: InternalTokenizerConfig, + config_hash: str, + fs: AbstractFileSystem, +) -> ShardPlan: + """Create deterministic shard plan.""" + import tokenizers + import transformers + + # Discover input files + files = discover_input_files(dataset_config, fs) + + if not files: + raise ValueError(f"No input files found for {dataset_config.name}") + + # Resolve tokenizer to immutable revision + resolved_tokenizer = resolve_tokenizer(tokenizer_config) + + # Compute fingerprints (includes dataset identity for HF sources) + source_fingerprint = compute_source_fingerprint(files, dataset_config) + + # Create size-balanced assignments + assignments = create_size_balanced_assignments(files, output_config.num_shards) + + # Determinism constraints + determinism_constraints = { + "ray_version": ray.__version__, + "transformers_version": transformers.__version__, + "tokenizers_version": tokenizers.__version__, + "input_file_order": "size_desc_path_asc", + "processing_order": "sequential_within_shard", + } + + # Compute plan hash + plan_content = json.dumps( + { + "dataset_name": dataset_config.name, + "num_shards": output_config.num_shards, + "source_fingerprint": source_fingerprint, + "resolved_tokenizer": resolved_tokenizer, + "determinism_constraints": determinism_constraints, + "config_hash": config_hash, + "file_paths": sorted([f.path for f in files]), + }, + sort_keys=True, + ) + plan_hash = hashlib.sha256(plan_content.encode()).hexdigest()[:16] + + return ShardPlan( + version="1.0", + created_at=datetime.now(timezone.utc).isoformat().replace("+00:00", "Z"), + plan_hash=plan_hash, + dataset_name=dataset_config.name, + num_shards=output_config.num_shards, + source_fingerprint=source_fingerprint, + config_hash=config_hash, + determinism_constraints=determinism_constraints, + resolved_tokenizer=resolved_tokenizer, + file_assignments=assignments, + ) + + +def get_pending_shards( + plan: ShardPlan, + receipts_dir: str, + fs: AbstractFileSystem, +) -> list[int]: + """Determine which shard indices still need processing.""" + completed_indices: set[int] = set() + + try: + receipt_files = fs.glob(f"{receipts_dir}/shard_*.json") + except FileNotFoundError: + receipt_files = [] + except Exception: + receipt_files = [] + + for receipt_path in receipt_files: + try: + receipt = read_json(fs, receipt_path) + + # Verify receipt belongs to current plan + if receipt.get("plan_hash") != plan.plan_hash: + continue + + if receipt.get("status") != "completed": + continue + + shard_index = receipt["shard_index"] + + # For non-empty shards, verify files exist + if receipt["stats"]["num_sequences"] > 0: + shard_dir = str(Path(receipts_dir).parent) + bin_path = f"{shard_dir}/{receipt['files']['bin']['path']}" + idx_path = f"{shard_dir}/{receipt['files']['idx']['path']}" + + if not (fs.exists(bin_path) and fs.exists(idx_path)): + continue + + completed_indices.add(shard_index) + + except Exception as e: + logger.warning(f"Failed to parse receipt {receipt_path}: {e}") + + all_indices = set(range(plan.num_shards)) + return sorted(all_indices - completed_indices) + + +def get_sampled_shard_indices( + num_shards: int, + dataset_name: str, + sample_spec: str | int, + seed: int = 42, +) -> set[int]: + """ + Deterministically select shard indices for sampling. + + Preserves "skip compute" for non-selected shards. + """ + # Derive per-dataset seed using hashlib for cross-run determinism + # (Python's hash() is randomized by default) + seed_str = f"{seed}:{dataset_name}" + dataset_seed = int(hashlib.sha256(seed_str.encode()).hexdigest()[:8], 16) + rng = random.Random(dataset_seed) + + all_indices = list(range(num_shards)) + + if isinstance(sample_spec, str) and sample_spec.endswith("%"): + # Percentage of shards + fraction = float(sample_spec.rstrip("%")) / 100 + k = max(1, int(num_shards * fraction)) + else: + # Fixed count of shards + k = min(int(sample_spec), num_shards) + + # Deterministic selection + selected = set(rng.sample(all_indices, k)) + return selected + + +def apply_shard_sampling( + pending_indices: list[int], + plan: ShardPlan, + sample_spec: str | int | None, + seed: int, +) -> list[int]: + """Filter pending indices by sampling.""" + if sample_spec is None: + return pending_indices + + sampled = get_sampled_shard_indices( + plan.num_shards, + plan.dataset_name, + sample_spec, + seed, + ) + + return [i for i in pending_indices if i in sampled] + + +def serialize_shard_plan(plan: ShardPlan) -> dict: + """Serialize ShardPlan to JSON-serializable dict.""" + result = asdict(plan) + # Convert FileInfo objects in assignments + for assignment in result["file_assignments"]: + assignment["files"] = [ + asdict(f) if hasattr(f, "__dict__") else f for f in assignment["files"] + ] + return result diff --git a/src/nemotron/data_prep/providers.py b/src/nemotron/data_prep/providers.py new file mode 100644 index 0000000..eaf7bf6 --- /dev/null +++ b/src/nemotron/data_prep/providers.py @@ -0,0 +1,172 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Tokenizer provider factories.""" + +from typing import Protocol + + +class TokenizerFn(Protocol): + """Protocol for tokenizer callable with vocab_size attribute.""" + + vocab_size: int + + def __call__(self, texts: list[str]) -> list[list[int]]: + """Tokenize a batch of texts.""" + ... + + +def create_tokenizer(resolved_config: dict) -> TokenizerFn: + """ + Create tokenizer from resolved config. + + IMPORTANT: Uses resolved_revision, not user-provided revision. + + Supported types: + - huggingface: HuggingFace AutoTokenizer + - sentencepiece: SentencePiece model file + - tiktoken: OpenAI tiktoken encodings (cl100k_base, o200k_base, etc.) + """ + tokenizer_type = resolved_config["type"] + + if tokenizer_type == "huggingface": + return _create_huggingface_tokenizer(resolved_config) + elif tokenizer_type == "sentencepiece": + return _create_sentencepiece_tokenizer(resolved_config) + elif tokenizer_type == "tiktoken": + return _create_tiktoken_tokenizer(resolved_config) + else: + raise ValueError(f"Unknown tokenizer type: {tokenizer_type}") + + +def _create_huggingface_tokenizer(resolved_config: dict) -> TokenizerFn: + """Create HuggingFace tokenizer.""" + from transformers import AutoTokenizer + + tokenizer = AutoTokenizer.from_pretrained( + resolved_config["model"], + revision=resolved_config["resolved_revision"], # Use resolved SHA + trust_remote_code=resolved_config.get("trust_remote_code", False), + use_fast=True, + ) + + add_bos = resolved_config.get("add_bos", False) + add_eos = resolved_config.get("add_eos", True) + bos_id = tokenizer.bos_token_id + eos_id = tokenizer.eos_token_id + vocab_size = len(tokenizer) + + def tokenize_batch(texts: list[str]) -> list[list[int]]: + """Vectorized batch tokenization.""" + encoded = tokenizer( + texts, + add_special_tokens=False, + return_attention_mask=False, + return_token_type_ids=False, + ) + + results = [] + for ids in encoded["input_ids"]: + ids = list(ids) + if add_bos and bos_id is not None: + ids = [bos_id] + ids + if add_eos and eos_id is not None: + ids = ids + [eos_id] + results.append(ids) + return results + + # Attach vocab_size as attribute + tokenize_batch.vocab_size = vocab_size # type: ignore + return tokenize_batch # type: ignore + + +def _create_sentencepiece_tokenizer(resolved_config: dict) -> TokenizerFn: + """Create SentencePiece tokenizer.""" + import sentencepiece as spm + + sp = spm.SentencePieceProcessor(model_file=resolved_config["model"]) + add_bos = resolved_config.get("add_bos", False) + add_eos = resolved_config.get("add_eos", True) + vocab_size = sp.vocab_size() + + def tokenize_batch(texts: list[str]) -> list[list[int]]: + results = [] + for text in texts: + ids = sp.encode(text) + if add_bos: + ids = [sp.bos_id()] + ids + if add_eos: + ids = ids + [sp.eos_id()] + results.append(ids) + return results + + # Attach vocab_size as attribute + tokenize_batch.vocab_size = vocab_size # type: ignore + return tokenize_batch # type: ignore + + +def _create_tiktoken_tokenizer(resolved_config: dict) -> TokenizerFn: + """Create tiktoken tokenizer. + + Supports standard encodings (cl100k_base, o200k_base, etc.) and custom patterns. + Compatible with Megatron Bridge TikTokenizer configuration. + """ + import tiktoken + + model = resolved_config["model"] + add_bos = resolved_config.get("add_bos", False) + add_eos = resolved_config.get("add_eos", True) + + # Try to get encoding by name (e.g., "cl100k_base", "o200k_base") + try: + enc = tiktoken.get_encoding(model) + except ValueError: + # Fall back to model-based encoding (e.g., "gpt-4", "gpt-3.5-turbo") + try: + enc = tiktoken.encoding_for_model(model) + except KeyError as e: + raise ValueError( + f"Unknown tiktoken encoding or model: {model}. " + f"Valid encodings: cl100k_base, o200k_base, p50k_base, r50k_base. " + f"Or use a model name like gpt-4, gpt-3.5-turbo." + ) from e + + vocab_size = enc.n_vocab + + # Get special tokens for BOS/EOS if needed + # tiktoken doesn't have standard BOS/EOS, so we use common conventions + # For GPT models: <|endoftext|> is typically used as EOS + try: + eot_token = enc.encode("<|endoftext|>", allowed_special={"<|endoftext|>"}) + eos_id = eot_token[0] if eot_token else None + except Exception: + eos_id = None + + # BOS is less common in tiktoken; typically not used + bos_id = None + + def tokenize_batch(texts: list[str]) -> list[list[int]]: + results = [] + for text in texts: + ids = enc.encode(text) + if add_bos and bos_id is not None: + ids = [bos_id] + ids + if add_eos and eos_id is not None: + ids = ids + [eos_id] + results.append(ids) + return results + + # Attach vocab_size as attribute + tokenize_batch.vocab_size = vocab_size # type: ignore + return tokenize_batch # type: ignore diff --git a/use-case-examples/Data Science ML Agent/data/.gitkeep b/src/nemotron/data_prep/py.typed similarity index 100% rename from use-case-examples/Data Science ML Agent/data/.gitkeep rename to src/nemotron/data_prep/py.typed diff --git a/src/nemotron/data_prep/ray_data/__init__.py b/src/nemotron/data_prep/ray_data/__init__.py new file mode 100644 index 0000000..e3d73a2 --- /dev/null +++ b/src/nemotron/data_prep/ray_data/__init__.py @@ -0,0 +1,35 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Ray Data shard-task executor for data preparation. + +This module provides Ray Data-based execution for shard processing, using +ActorPoolStrategy for actor lifecycle management and resource accounting. + +Key components: +- ShardTask: Represents a single shard to process +- execute_shard_tasks: Main executor using Ray Data map_batches +- BinIdxShardTaskUDF: UDF for binidx (Megatron) format processing +""" + +from nemotron.data_prep.ray_data.binidx_udf import BinIdxShardTaskUDF +from nemotron.data_prep.ray_data.executor import RayDataExecConfig, execute_shard_tasks +from nemotron.data_prep.ray_data.tasks import ShardTask + +__all__ = [ + "ShardTask", + "execute_shard_tasks", + "RayDataExecConfig", + "BinIdxShardTaskUDF", +] diff --git a/src/nemotron/data_prep/ray_data/binidx_udf.py b/src/nemotron/data_prep/ray_data/binidx_udf.py new file mode 100644 index 0000000..39e69ba --- /dev/null +++ b/src/nemotron/data_prep/ray_data/binidx_udf.py @@ -0,0 +1,164 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""BinIdx shard task UDF for Ray Data execution.""" + +from __future__ import annotations + +import json +import logging +from typing import Any + +import numpy as np +from fsspec import filesystem + +from nemotron.data_prep.providers import create_tokenizer + +logger = logging.getLogger(__name__) + + +class BinIdxShardTaskUDF: + """Ray Data UDF for processing binidx shard tasks. + + This UDF is used with ActorPoolStrategy, meaning: + - __init__ is called once per actor (tokenizer loaded once) + - __call__ is called for each batch (batch_size=1 means one shard) + + The UDF delegates to process_binidx_shard_core, which contains + the actual processing logic shared with the legacy actor. + + IMPORTANT: Tokenizer is created in __init__ (once per actor), not + per-shard, to amortize initialization cost across all shards + processed by this actor. + """ + + def __init__( + self, + resolved_tokenizer: dict, + min_doc_chars: int | None = None, + max_doc_tokens: int | None = None, + dtype: str = "int32", + max_rows: int | None = None, + ): + """Initialize actor with tokenizer (amortized across shards). + + Args: + resolved_tokenizer: Tokenizer config dict with resolved SHA + min_doc_chars: Skip documents shorter than this + max_doc_tokens: Truncate documents longer than this + dtype: Token dtype (e.g., "int32") + max_rows: Limit rows processed per shard (for testing) + """ + self.min_doc_chars = min_doc_chars + self.max_doc_tokens = max_doc_tokens + self.dtype = dtype + self.max_rows = max_rows + + # Create tokenizer ONCE per actor (this is the perf win) + logger.debug("BinIdxShardTaskUDF: initializing tokenizer...") + self.tokenize = create_tokenizer(resolved_tokenizer) + logger.debug("BinIdxShardTaskUDF: tokenizer ready") + + def __call__(self, batch: dict[str, np.ndarray]) -> dict[str, np.ndarray]: + """Process a batch of shard tasks. + + With batch_size=1, we receive exactly one task per call. + Ray Data passes dict-of-numpy-arrays (default batch_format). + + Args: + batch: Dict with numpy arrays, each of length 1 (batch_size=1) + + Returns: + Dict of numpy arrays with stats (same batch format) + """ + # Import here to avoid circular imports + from nemotron.data_prep.shard_processor import process_binidx_shard_core + + # Extract single task from batch (batch_size=1) + # Ray Data passes columns as numpy arrays + dataset_name = str(batch["dataset_name"][0]) + shard_index = int(batch["shard_index"][0]) + plan_hash = str(batch["plan_hash"][0]) + assignment_json = str(batch["assignment_json"][0]) + output_dir = str(batch["output_dir"][0]) + receipts_dir = str(batch["receipts_dir"][0]) + fs_protocol = str(batch["fs_protocol"][0]) + text_field = str(batch["text_field"][0]) + + # Deserialize assignment from JSON + assignment = json.loads(assignment_json) + + logger.debug(f"Processing shard {shard_index} for dataset {dataset_name}") + + # Create output filesystem + output_fs = filesystem(fs_protocol) + + try: + stats = process_binidx_shard_core( + tokenize=self.tokenize, # Pre-initialized in __init__ + text_field=text_field, + min_doc_chars=self.min_doc_chars, + max_doc_tokens=self.max_doc_tokens, + dtype=self.dtype, + max_rows=self.max_rows, + shard_index=shard_index, + assignment=assignment, + plan_hash=plan_hash, + output_dir=output_dir, + receipts_dir=receipts_dir, + output_fs=output_fs, + ) + + # Return dict-of-numpy-arrays (Ray Data's expected format) + # Include task identity for tracking + key stats + return { + "dataset_name": np.array([dataset_name], dtype=object), + "shard_index": np.array([shard_index], dtype=np.int64), + "plan_hash": np.array([plan_hash], dtype=object), + "total_tokens": np.array([stats.get("total_tokens", 0)], dtype=np.int64), + "num_sequences": np.array([stats.get("num_sequences", 0)], dtype=np.int64), + "num_filtered": np.array([stats.get("num_filtered", 0)], dtype=np.int64), + "num_errors": np.array([stats.get("num_errors", 0)], dtype=np.int64), + # Timing metrics for bottleneck identification + "time_total_sec": np.array( + [stats.get("time_total_sec", 0.0)], dtype=np.float64 + ), + "time_download_sec": np.array( + [stats.get("time_download_sec", 0.0)], dtype=np.float64 + ), + "time_read_sec": np.array([stats.get("time_read_sec", 0.0)], dtype=np.float64), + "time_tokenize_sec": np.array( + [stats.get("time_tokenize_sec", 0.0)], dtype=np.float64 + ), + "time_write_sec": np.array([stats.get("time_write_sec", 0.0)], dtype=np.float64), + "error": np.array([""], dtype=object), + } + except Exception as e: + logger.error(f"Shard {shard_index} for {dataset_name} failed: {e}") + # Return error stats (no receipt written = will be retried on resume) + return { + "dataset_name": np.array([dataset_name], dtype=object), + "shard_index": np.array([shard_index], dtype=np.int64), + "plan_hash": np.array([plan_hash], dtype=object), + "total_tokens": np.array([0], dtype=np.int64), + "num_sequences": np.array([0], dtype=np.int64), + "num_filtered": np.array([0], dtype=np.int64), + "num_errors": np.array([1], dtype=np.int64), + "time_total_sec": np.array([0.0], dtype=np.float64), + "time_download_sec": np.array([0.0], dtype=np.float64), + "time_read_sec": np.array([0.0], dtype=np.float64), + "time_tokenize_sec": np.array([0.0], dtype=np.float64), + "time_write_sec": np.array([0.0], dtype=np.float64), + "error": np.array([str(e)], dtype=object), + } diff --git a/src/nemotron/data_prep/ray_data/executor.py b/src/nemotron/data_prep/ray_data/executor.py new file mode 100644 index 0000000..9af24c8 --- /dev/null +++ b/src/nemotron/data_prep/ray_data/executor.py @@ -0,0 +1,330 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Ray Data executor for shard-task processing.""" + +from __future__ import annotations + +import logging +import threading +import time +from collections.abc import Callable +from dataclasses import dataclass +from typing import Any + +import ray +import ray.data + +from nemotron.data_prep.ray_data.tasks import ShardTask + +logger = logging.getLogger(__name__) + + +class _ProgressReporter: + """Background thread for periodic progress reporting during Ray Data execution. + + This ensures progress is reported even when iter_rows() is blocked waiting + for initial results (e.g., during HuggingFace downloads). + """ + + def __init__( + self, + on_progress: Callable[[dict[str, Any]], None], + total_tasks: int, + interval: float = 5.0, + ): + self.on_progress = on_progress + self.total_tasks = total_tasks + self.interval = interval + + self._start_time = time.perf_counter() + self._tasks_completed = 0 + self._all_stats: list[dict[str, Any]] = [] + self._lock = threading.Lock() + self._stop_event = threading.Event() + self._thread: threading.Thread | None = None + + def start(self) -> None: + """Start the background progress reporter.""" + self._thread = threading.Thread(target=self._run, daemon=True) + self._thread.start() + + def stop(self) -> None: + """Stop the background progress reporter.""" + self._stop_event.set() + if self._thread: + self._thread.join(timeout=2.0) + + def update(self, tasks_completed: int, stats: list[dict[str, Any]]) -> None: + """Update progress state from the main iteration loop.""" + with self._lock: + self._tasks_completed = tasks_completed + self._all_stats = stats.copy() + + def _run(self) -> None: + """Background thread that reports progress periodically.""" + while not self._stop_event.wait(self.interval): + with self._lock: + tasks_completed = self._tasks_completed + all_stats = self._all_stats.copy() + + elapsed = time.perf_counter() - self._start_time + + # Infer phase from completed stats + phase = _infer_dominant_phase(all_stats) + + # If no tasks completed yet, show "working" with elapsed time + if tasks_completed == 0: + phase = "working" + detail = f"waiting for first shard... {elapsed:.0f}s" + else: + detail = f"{tasks_completed}/{self.total_tasks} shards" + + try: + self.on_progress({ + "phase": phase, + "detail": detail, + "elapsed_sec": elapsed, + "tasks_completed": tasks_completed, + "tasks_total": self.total_tasks, + }) + except Exception: + pass # Don't crash background thread on callback errors + + +@dataclass(frozen=True) +class RayDataExecConfig: + """Configuration for Ray Data shard-task execution. + + These settings map directly to Ray Data's ActorPoolStrategy and + map_batches parameters, providing explicit control over resource usage. + + Attributes: + min_actors: Minimum actors to keep alive (warm pool) + max_actors: Maximum actors (bounded to prevent overload) + cpus_per_actor: CPUs allocated per actor (explicit accounting) + max_tasks_in_flight_per_actor: Pipelining depth to reduce scheduling + bubbles and keep actors fed. Note: does not by itself parallelize + a single actor; true I/O latency hiding requires either more actors + (with fractional num_cpus) or async internal concurrency. + """ + + min_actors: int = 2 + max_actors: int = 32 + cpus_per_actor: float = 1.0 + max_tasks_in_flight_per_actor: int = 2 + + +def execute_shard_tasks( + tasks: list[ShardTask], + *, + udf_cls: type, + udf_constructor_kwargs: dict[str, Any], + exec_cfg: RayDataExecConfig, + on_result: Callable[[dict[str, Any]], None] | None = None, + on_progress: Callable[[dict[str, Any]], None] | None = None, +) -> list[dict[str, Any]]: + """Execute shard tasks via Ray Data ActorPoolStrategy. + + Each task: + 1. Is processed by a stateful actor (tokenizer loaded once in __init__) + 2. Produces side-effects (writes shard files + receipt) + 3. Returns a small stats dict-of-numpy-arrays + + Args: + tasks: List of ShardTask to execute + udf_cls: UDF class (e.g., BinIdxShardTaskUDF) + udf_constructor_kwargs: Arguments passed to UDF __init__ + exec_cfg: Execution configuration + on_result: Optional callback for each completed task + on_progress: Optional callback for periodic progress updates (every ~5s) + Called with {"phase": str, "elapsed_sec": float, "tasks_completed": int} + + Returns: + List of stats dicts from all completed tasks + """ + if not tasks: + logger.info("No shard tasks to execute") + return [] + + logger.info( + f"Executing {len(tasks)} shard tasks with Ray Data " + f"(actors: {exec_cfg.min_actors}-{exec_cfg.max_actors}, " + f"cpus_per_actor: {exec_cfg.cpus_per_actor}, " + f"max_in_flight_per_actor: {exec_cfg.max_tasks_in_flight_per_actor})" + ) + + execution_start = time.perf_counter() + total_tasks = len(tasks) + + # Report initial "starting" phase + if on_progress: + on_progress({ + "phase": "starting", + "detail": f"{total_tasks} shards", + "elapsed_sec": 0.0, + "tasks_completed": 0, + "tasks_total": total_tasks, + }) + + # Build Ray Dataset from task dicts + # NOTE: Serialize assignment as JSON string for stable Arrow encoding + task_dicts = [t.to_dict() for t in tasks] + ds = ray.data.from_items(task_dicts) + + # Configure ActorPoolStrategy + compute = ray.data.ActorPoolStrategy( + min_size=exec_cfg.min_actors, + max_size=exec_cfg.max_actors, + max_tasks_in_flight_per_actor=exec_cfg.max_tasks_in_flight_per_actor, + ) + + # Execute with explicit CPU allocation + # batch_size=1 means one shard task per UDF call + # Default batch_format is dict-of-numpy-arrays (NumPy is DEFAULT_BATCH_FORMAT) + # num_cpus is a direct parameter (not via ray_remote_args) + # + # FAULT TOLERANCE: We rely on idempotent atomic commit in the UDF rather than + # disabling retries. Ray Data defaults to max_restarts=-1, max_task_retries=-1. + # The atomic write protocol (temp -> rename -> receipt) makes retries safe. + stats_ds = ds.map_batches( + udf_cls, + fn_constructor_kwargs=udf_constructor_kwargs, + batch_size=1, + compute=compute, + num_cpus=exec_cfg.cpus_per_actor, + ) + + # Stream results to handle callback and collect stats + all_stats: list[dict[str, Any]] = [] + tasks_completed = 0 + last_progress_time = execution_start + + # Start background progress reporter if callback provided + # This ensures progress is shown even when waiting for first result + progress_reporter: _ProgressReporter | None = None + if on_progress: + progress_reporter = _ProgressReporter(on_progress, total_tasks, interval=5.0) + progress_reporter.start() + + try: + for row in stats_ds.iter_rows(): + tasks_completed += 1 + # Convert numpy scalars to Python types for easier handling + row_dict = {k: v.item() if hasattr(v, "item") else v for k, v in row.items()} + all_stats.append(row_dict) + + # Update background reporter with current state + if progress_reporter: + progress_reporter.update(tasks_completed, all_stats) + + current_time = time.perf_counter() + elapsed = current_time - execution_start + + if on_result: + # Add Ray Data execution metadata + on_result( + { + **row_dict, + "_ray_data_tasks_completed": tasks_completed, + "_ray_data_elapsed_sec": elapsed, + } + ) + + # Immediate progress reporting on task completion + if on_progress and (current_time - last_progress_time >= 5.0 or tasks_completed == total_tasks): + last_progress_time = current_time + # Infer phase from timing breakdown of completed tasks + phase = _infer_dominant_phase(all_stats) + on_progress({ + "phase": phase, + "detail": f"{tasks_completed}/{total_tasks} shards", + "elapsed_sec": elapsed, + "tasks_completed": tasks_completed, + "tasks_total": total_tasks, + }) + finally: + # Stop background reporter + if progress_reporter: + progress_reporter.stop() + + execution_time = time.perf_counter() - execution_start + logger.info( + f"Ray Data execution complete: {tasks_completed} tasks in {execution_time:.1f}s " + f"({tasks_completed / max(execution_time, 0.001):.1f} tasks/sec)" + ) + + # Log to W&B if active + _log_execution_to_wandb(tasks_completed, execution_time, exec_cfg) + + return all_stats + + +def _infer_dominant_phase(stats: list[dict[str, Any]]) -> str: + """Infer the dominant processing phase from completed task stats. + + Returns the phase that consumed the most time across all completed tasks. + """ + if not stats: + return "processing" + + # Sum up time by phase + time_download = sum(s.get("time_download_sec", 0.0) for s in stats) + time_read = sum(s.get("time_read_sec", 0.0) for s in stats) + time_tokenize = sum(s.get("time_tokenize_sec", 0.0) for s in stats) + time_write = sum(s.get("time_write_sec", 0.0) for s in stats) + + # Find dominant phase + phases = [ + (time_download, "downloading"), + (time_read, "reading"), + (time_tokenize, "tokenizing"), + (time_write, "writing"), + ] + dominant = max(phases, key=lambda x: x[0]) + + # Only report specific phase if it's >50% of time, otherwise generic + total_time = time_download + time_read + time_tokenize + time_write + if total_time > 0 and dominant[0] / total_time > 0.5: + return dominant[1] + return "processing" + + +def _log_execution_to_wandb( + tasks_completed: int, + execution_time: float, + exec_cfg: RayDataExecConfig, +) -> None: + """Log Ray Data execution metrics to W&B if active.""" + try: + import wandb + + if wandb.run is None: + logger.debug("[W&B] No active run, skipping execution metrics log") + return + + wandb.log( + { + "data_prep/ray_data/total_tasks": tasks_completed, + "data_prep/ray_data/execution_time_sec": execution_time, + "data_prep/ray_data/tasks_per_sec": tasks_completed / max(execution_time, 0.001), + "data_prep/ray_data/max_actors": exec_cfg.max_actors, + "data_prep/ray_data/max_in_flight_per_actor": exec_cfg.max_tasks_in_flight_per_actor, + } + ) + logger.info(f"[W&B] Logged ray_data execution: {tasks_completed} tasks in {execution_time:.1f}s") + except ImportError: + pass + except Exception as e: + logger.warning(f"[W&B] Failed to log execution metrics: {e}") diff --git a/src/nemotron/data_prep/ray_data/tasks.py b/src/nemotron/data_prep/ray_data/tasks.py new file mode 100644 index 0000000..ada20b5 --- /dev/null +++ b/src/nemotron/data_prep/ray_data/tasks.py @@ -0,0 +1,107 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""ShardTask model for Ray Data shard-task execution.""" + +from __future__ import annotations + +import json +from dataclasses import dataclass +from typing import Any, Literal + + +@dataclass(frozen=True) +class ShardTask: + """Represents a single shard to process. + + This is the unit of scheduling in Ray Data. Each task contains all + information needed to process one shard independently. + + Attributes: + dataset_name: Name of the dataset (for tracking/logging) + plan_hash: Hash identifying the shard plan (for receipt) + shard_index: Index of this shard within the plan + assignment_json: ShardAssignment serialized as JSON string + (JSON serialization ensures stable Arrow encoding) + output_dir: Directory for .bin/.idx files + receipts_dir: Directory for receipt JSON files + fs_protocol: Filesystem protocol for OUTPUT (file, s3, gcs) + Note: Input files use their own paths and may have different protocols + kind: Output format (binidx for v1) + text_field: Name of text column in input files + """ + + # Identity + dataset_name: str + plan_hash: str + shard_index: int + + # Execution inputs + # JSON-serialized for stable Arrow encoding across Ray versions + assignment_json: str + + # Output locations (same as legacy layout) + output_dir: str + receipts_dir: str + fs_protocol: str # For OUTPUT only; inputs use per-file protocols + + # Format routing (v1 focuses on binidx) + kind: Literal["binidx"] = "binidx" + text_field: str = "text" + + @classmethod + def from_assignment( + cls, + assignment: dict[str, Any], + **kwargs: Any, + ) -> ShardTask: + """Create ShardTask from assignment dict, serializing to JSON. + + Args: + assignment: ShardAssignment as dict (shard_index, files, total_bytes) + **kwargs: Other ShardTask fields + + Returns: + ShardTask with JSON-serialized assignment + """ + return cls( + assignment_json=json.dumps(assignment), + **kwargs, + ) + + def to_dict(self) -> dict[str, Any]: + """Convert to dict for Ray Data serialization. + + Returns: + Dict with all fields suitable for ray.data.from_items() + """ + return { + "dataset_name": self.dataset_name, + "plan_hash": self.plan_hash, + "shard_index": self.shard_index, + "assignment_json": self.assignment_json, # Already JSON string + "output_dir": self.output_dir, + "receipts_dir": self.receipts_dir, + "fs_protocol": self.fs_protocol, + "kind": self.kind, + "text_field": self.text_field, + } + + def get_assignment(self) -> dict[str, Any]: + """Deserialize assignment from JSON. + + Returns: + ShardAssignment as dict + """ + return json.loads(self.assignment_json) diff --git a/src/nemotron/data_prep/shard_processor.py b/src/nemotron/data_prep/shard_processor.py new file mode 100644 index 0000000..cbc54a6 --- /dev/null +++ b/src/nemotron/data_prep/shard_processor.py @@ -0,0 +1,1162 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""ShardProcessor Ray actor for parallel shard processing.""" + +from __future__ import annotations + +import json +import logging +import time +from collections.abc import Callable, Iterator +from typing import Any + +import numpy as np +import pyarrow.parquet as pq +import ray +from fsspec import filesystem + +from nemotron.data_prep.config import FileInfo +from nemotron.data_prep.filesystem import ensure_dir, get_filesystem, write_json +from nemotron.data_prep.formats.indexed_dataset import IndexedDatasetBuilder +from nemotron.data_prep.providers import create_tokenizer + +logger = logging.getLogger(__name__) + + +# ============================================================================= +# Core Processing Function (Shared by Legacy Actor and Ray Data UDF) +# ============================================================================= + + +def process_binidx_shard_core( + *, + # Tokenizer (pre-initialized callable, NOT config dict) + tokenize: Callable[[list[str]], list[list[int]]], + text_field: str, + min_doc_chars: int | None, + max_doc_tokens: int | None, + dtype: str, + max_rows: int | None, + # Shard identity + shard_index: int, + assignment: dict[str, Any], + plan_hash: str, + # Output locations + output_dir: str, + receipts_dir: str, + output_fs: Any, # fsspec filesystem for OUTPUT +) -> dict[str, Any]: + """Core implementation of binidx shard processing. + + This function contains the actual processing logic, shared by: + - Legacy ShardProcessor actor (process_shard method) + - Ray Data BinIdxShardTaskUDF + + IMPORTANT: tokenize is a pre-initialized callable, not a config dict. + The caller (actor or UDF) is responsible for creating the tokenizer + once during initialization to amortize the cost across shards. + + Flow: + 0. Check receipt (idempotency for Ray retries) + 1. Read assigned files (parquet/jsonl) - using per-file filesystems + 2. Filter by min_doc_chars + 3. Tokenize documents + 4. Write .bin/.idx files using ATOMIC COMMIT PROTOCOL + 5. Write receipt JSON + 6. Return stats dict + + Args: + tokenize: Pre-initialized tokenizer callable (texts -> token lists) + text_field: Column name containing text + min_doc_chars: Minimum document length filter + max_doc_tokens: Maximum tokens per document (truncation) + dtype: Numpy dtype for tokens (e.g., "int32") + max_rows: Maximum rows to process (for testing) + shard_index: Index of this shard + assignment: ShardAssignment as dict + plan_hash: Hash of the shard plan + output_dir: Directory for output files + receipts_dir: Directory for receipt files + output_fs: fsspec filesystem for OUTPUT (input files use own protocols) + + Returns: + Stats dict with keys: total_tokens, num_sequences, timing, etc. + """ + total_start = time.perf_counter() + timing: dict[str, float] = {} + + shard_id = f"shard_{shard_index:06d}" + bin_path = f"{output_dir}/{shard_id}.bin" + idx_path = f"{output_dir}/{shard_id}.idx" + receipt_path = f"{receipts_dir}/{shard_id}.json" + + # IDEMPOTENCY: If receipt exists and is completed, skip processing + # This makes "at-least-once" execution safe for Ray retries + if output_fs.exists(receipt_path): + try: + with output_fs.open(receipt_path, "r") as f: + existing = json.load(f) + if existing.get("status") == "completed": + logger.debug(f"Shard {shard_id} already completed, skipping") + return existing.get("stats", {}) + except Exception: + pass # Receipt corrupted, reprocess + + np_dtype = np.dtype(dtype) + + # Ensure output directories + ensure_dir(output_fs, output_dir) + ensure_dir(output_fs, receipts_dir) + + # Stats tracking + stats: dict[str, Any] = { + "num_input_rows": 0, + "num_filtered": 0, + "num_truncated": 0, + "num_errors": 0, + } + + files = [FileInfo(**f) for f in assignment["files"]] + input_file_paths = [f.path for f in files] + + # Handle empty assignment + if not files: + return _write_empty_receipt_core( + shard_id, + shard_index, + plan_hash, + input_file_paths, + stats, + receipt_path, + output_fs, + timing, + total_start, + ) + + # ATOMIC COMMIT PROTOCOL for retry safety: + # 1. Write to temp paths (.tmp suffix) + # 2. Rename temp -> final (atomic on most filesystems) + # 3. Write receipt LAST (signals completion) + # This ensures partial writes from retries don't corrupt output. + + bin_tmp = f"{bin_path}.tmp" + idx_tmp = f"{idx_path}.tmp" + + # Track download time separately + download_start = time.perf_counter() + + # Process files and write shard to TEMP path + read_start = time.perf_counter() + timing["time_download_sec"] = read_start - download_start + + with output_fs.open(bin_tmp, "wb") as bin_file: + builder = IndexedDatasetBuilder(bin_file, dtype=np_dtype) + + # Track rows processed across files for max_rows limit + rows_processed = 0 + tokenize_time_total = 0.0 + + # Process files SEQUENTIALLY for determinism + for file_info in files: + # Use per-file filesystem (input may be HF/S3/local, differs from output) + input_fs, _ = get_filesystem(file_info.path) + + rows_processed, file_tokenize_time = _process_file_core( + file_info=file_info, + builder=builder, + stats=stats, + input_fs=input_fs, + text_field=text_field, + min_doc_chars=min_doc_chars, + max_doc_tokens=max_doc_tokens, + tokenize=tokenize, + rows_processed=rows_processed, + max_rows=max_rows, + ) + tokenize_time_total += file_tokenize_time + + # Stop if we've hit max_rows + if max_rows and rows_processed >= max_rows: + break + + bin_bytes, bin_checksum = builder.get_bin_info() + builder_stats = builder.get_stats() + + read_end = time.perf_counter() + timing["time_read_sec"] = read_end - read_start - tokenize_time_total + timing["time_tokenize_sec"] = tokenize_time_total + + # Handle empty result (all rows filtered) + if builder_stats["num_sequences"] == 0: + # Remove empty temp file + try: + output_fs.rm(bin_tmp) + except Exception: + pass + return _write_empty_receipt_core( + shard_id, + shard_index, + plan_hash, + input_file_paths, + stats, + receipt_path, + output_fs, + timing, + total_start, + ) + + # Write index to TEMP path + write_start = time.perf_counter() + with output_fs.open(idx_tmp, "wb") as idx_file: + idx_bytes, idx_checksum = builder.write_index(idx_file) + + # ATOMIC RENAME: temp -> final + # On S3/GCS this is a copy+delete, but still prevents partial reads + output_fs.rename(bin_tmp, bin_path) + output_fs.rename(idx_tmp, idx_path) + + write_end = time.perf_counter() + timing["time_write_sec"] = write_end - write_start + + # Write receipt LAST (signals successful completion) + receipt = { + "shard_id": shard_id, + "shard_index": shard_index, + "plan_hash": plan_hash, + "status": "completed", + "created_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()), + "input_files": input_file_paths, + "files": { + "bin": { + "path": f"{shard_id}.bin", + "bytes": bin_bytes, + "checksum": bin_checksum, + }, + "idx": { + "path": f"{shard_id}.idx", + "bytes": idx_bytes, + "checksum": idx_checksum, + }, + }, + "stats": {**builder_stats, **stats}, + } + + write_json(output_fs, receipt_path, receipt) + + # Add timing to stats + timing["time_total_sec"] = time.perf_counter() - total_start + return {**receipt["stats"], **timing} + + +def _write_empty_receipt_core( + shard_id: str, + shard_index: int, + plan_hash: str, + input_files: list[str], + stats: dict[str, Any], + receipt_path: str, + output_fs: Any, + timing: dict[str, float], + total_start: float, +) -> dict[str, Any]: + """Write receipt for empty shard (CRITICAL for resume correctness).""" + receipt = { + "shard_id": shard_id, + "shard_index": shard_index, + "plan_hash": plan_hash, + "status": "completed", + "created_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()), + "input_files": input_files, + "files": { + "bin": { + "path": f"{shard_id}.bin", + "bytes": 0, + "checksum": "xxh64:empty", + }, + "idx": { + "path": f"{shard_id}.idx", + "bytes": 0, + "checksum": "xxh64:empty", + }, + }, + "stats": { + "num_sequences": 0, + "total_tokens": 0, + "min_length": 0, + "max_length": 0, + **stats, + }, + } + + write_json(output_fs, receipt_path, receipt) + + # Add timing to stats + timing["time_total_sec"] = time.perf_counter() - total_start + timing.setdefault("time_download_sec", 0.0) + timing.setdefault("time_read_sec", 0.0) + timing.setdefault("time_tokenize_sec", 0.0) + timing.setdefault("time_write_sec", 0.0) + return {**receipt["stats"], **timing} + + +def _process_file_core( + *, + file_info: FileInfo, + builder: IndexedDatasetBuilder, + stats: dict[str, Any], + input_fs: Any, + text_field: str, + min_doc_chars: int | None, + max_doc_tokens: int | None, + tokenize: Callable[[list[str]], list[list[int]]], + rows_processed: int, + max_rows: int | None, +) -> tuple[int, float]: + """Process a single file, writing documents to builder. + + Returns: + Tuple of (rows_processed, tokenize_time_seconds) + """ + tokenize_time = 0.0 + + # Resolve file path - handle HF deferred download + local_path = _resolve_file_path_core(file_info) + + # Determine file type and iterate records + is_parquet = local_path.endswith(".parquet") or not ( + local_path.endswith(".jsonl") or local_path.endswith(".json") + ) + + if is_parquet: + rows_processed, tokenize_time = _process_parquet_file_core( + local_path=local_path, + builder=builder, + stats=stats, + input_fs=input_fs, + text_field=text_field, + min_doc_chars=min_doc_chars, + max_doc_tokens=max_doc_tokens, + tokenize=tokenize, + rows_processed=rows_processed, + max_rows=max_rows, + ) + else: + rows_processed, tokenize_time = _process_jsonl_file_core( + local_path=local_path, + builder=builder, + stats=stats, + input_fs=input_fs, + text_field=text_field, + min_doc_chars=min_doc_chars, + max_doc_tokens=max_doc_tokens, + tokenize=tokenize, + rows_processed=rows_processed, + max_rows=max_rows, + ) + + return rows_processed, tokenize_time + + +def _resolve_file_path_core(file_info: FileInfo) -> str: + """Resolve file to a local path, downloading from HF if needed.""" + # HF files need deferred download + if file_info.hf_repo_id is not None: + from huggingface_hub import hf_hub_download + + local_path = hf_hub_download( + repo_id=file_info.hf_repo_id, + filename=file_info.hf_filename, + revision=file_info.hf_revision, + repo_type="dataset", + local_files_only=False, + ) + return local_path + + # For non-HF files, use local_path if available + return file_info.local_path or file_info.path + + +def _process_parquet_file_core( + *, + local_path: str, + builder: IndexedDatasetBuilder, + stats: dict[str, Any], + input_fs: Any, + text_field: str, + min_doc_chars: int | None, + max_doc_tokens: int | None, + tokenize: Callable[[list[str]], list[list[int]]], + rows_processed: int, + max_rows: int | None, +) -> tuple[int, float]: + """Process parquet file with optimized Arrow-level filtering. + + Returns: + Tuple of (rows_processed, tokenize_time_seconds) + """ + import pyarrow.compute as pc + + batch_texts: list[str] = [] + tokenize_batch_size = 1000 + hit_max_rows = False + tokenize_time = 0.0 + + # Determine if remote path + is_remote = local_path.startswith(("s3://", "gs://", "gcs://", "az://", "abfs://")) + + def iter_parquet_batches(): + if is_remote: + with input_fs.open(local_path, "rb") as f: + parquet_file = pq.ParquetFile(f) + yield from _iter_parquet_batches_internal(parquet_file, text_field, min_doc_chars) + else: + parquet_file = pq.ParquetFile(local_path) + yield from _iter_parquet_batches_internal(parquet_file, text_field, min_doc_chars) + + for texts, num_filtered_by_length in iter_parquet_batches(): + if hit_max_rows: + break + + # Account for rows filtered by min_doc_chars at Arrow level + stats["num_filtered"] += num_filtered_by_length + stats["num_input_rows"] += num_filtered_by_length + + for text in texts: + # Check max_rows limit + if max_rows and rows_processed >= max_rows: + hit_max_rows = True + break + + stats["num_input_rows"] += 1 + rows_processed += 1 + + # Filter None values + if text is None: + stats["num_filtered"] += 1 + continue + + batch_texts.append(str(text)) + + # Process batch + if len(batch_texts) >= tokenize_batch_size: + t0 = time.perf_counter() + _tokenize_and_write_batch_core( + batch_texts, builder, stats, tokenize, max_doc_tokens + ) + tokenize_time += time.perf_counter() - t0 + batch_texts = [] + + # Process remaining + if batch_texts: + t0 = time.perf_counter() + _tokenize_and_write_batch_core(batch_texts, builder, stats, tokenize, max_doc_tokens) + tokenize_time += time.perf_counter() - t0 + + return rows_processed, tokenize_time + + +def _iter_parquet_batches_internal( + parquet_file: pq.ParquetFile, + text_field: str, + min_doc_chars: int | None, +) -> Iterator[tuple[list[str | None], int]]: + """Iterate batches from parquet file efficiently.""" + import pyarrow.compute as pc + + for batch in parquet_file.iter_batches( + columns=[text_field], + batch_size=10000, + ): + column = batch.column(text_field) + original_len = len(column) + num_filtered = 0 + + # Apply min_doc_chars filter at Arrow level if configured + if min_doc_chars: + lengths = pc.utf8_length(column) + mask = pc.greater_equal(lengths, min_doc_chars) + column = pc.filter(column, mask) + num_filtered = original_len - len(column) + + # Use to_pylist() for bulk conversion + yield column.to_pylist(), num_filtered + + +def _process_jsonl_file_core( + *, + local_path: str, + builder: IndexedDatasetBuilder, + stats: dict[str, Any], + input_fs: Any, + text_field: str, + min_doc_chars: int | None, + max_doc_tokens: int | None, + tokenize: Callable[[list[str]], list[list[int]]], + rows_processed: int, + max_rows: int | None, +) -> tuple[int, float]: + """Process JSONL file. + + Returns: + Tuple of (rows_processed, tokenize_time_seconds) + """ + batch_size = 1000 + batch_texts: list[str] = [] + tokenize_time = 0.0 + + is_remote = local_path.startswith(("s3://", "gs://", "gcs://", "az://", "abfs://")) + + def iter_records(): + if is_remote: + with input_fs.open(local_path, "r") as f: + for line in f: + if line.strip(): + yield json.loads(line) + else: + with open(local_path) as f: + for line in f: + if line.strip(): + yield json.loads(line) + + for record in iter_records(): + # Check max_rows limit + if max_rows and rows_processed >= max_rows: + break + + stats["num_input_rows"] += 1 + rows_processed += 1 + + # Extract text + text = record.get(text_field) + if text is None: + stats["num_filtered"] += 1 + continue + + text = str(text) + + # Filter short docs + if min_doc_chars and len(text) < min_doc_chars: + stats["num_filtered"] += 1 + continue + + batch_texts.append(text) + + # Process batch + if len(batch_texts) >= batch_size: + t0 = time.perf_counter() + _tokenize_and_write_batch_core(batch_texts, builder, stats, tokenize, max_doc_tokens) + tokenize_time += time.perf_counter() - t0 + batch_texts = [] + + # Process remaining + if batch_texts: + t0 = time.perf_counter() + _tokenize_and_write_batch_core(batch_texts, builder, stats, tokenize, max_doc_tokens) + tokenize_time += time.perf_counter() - t0 + + return rows_processed, tokenize_time + + +def _tokenize_and_write_batch_core( + texts: list[str], + builder: IndexedDatasetBuilder, + stats: dict[str, Any], + tokenize: Callable[[list[str]], list[list[int]]], + max_doc_tokens: int | None, +) -> None: + """Tokenize a batch and write documents.""" + try: + all_tokens = tokenize(texts) + + # Pre-filter and truncate + processed: list[list[int]] = [] + for tokens in all_tokens: + # Truncate if needed + if max_doc_tokens and len(tokens) > max_doc_tokens: + tokens = tokens[:max_doc_tokens] + stats["num_truncated"] += 1 + + if tokens: + processed.append(tokens) + + # Batch add - reduces numpy allocation overhead + builder.add_documents(processed) + + except Exception as e: + # Bisect to isolate bad rows instead of dropping entire batch + if len(texts) > 1: + _tokenize_with_bisect_core(texts, builder, stats, tokenize, max_doc_tokens) + else: + # Single text failed, count as error + stats["num_errors"] += 1 + logger.warning(f"Tokenization error for single text: {e}") + + +def _tokenize_with_bisect_core( + texts: list[str], + builder: IndexedDatasetBuilder, + stats: dict[str, Any], + tokenize: Callable[[list[str]], list[list[int]]], + max_doc_tokens: int | None, +) -> None: + """Bisect a batch to isolate problematic rows.""" + if len(texts) == 0: + return + + if len(texts) == 1: + # Single text - try it alone + try: + all_tokens = tokenize(texts) + for tokens in all_tokens: + if max_doc_tokens and len(tokens) > max_doc_tokens: + tokens = tokens[:max_doc_tokens] + stats["num_truncated"] += 1 + if tokens: + builder.add_document(tokens) + except Exception as e: + stats["num_errors"] += 1 + logger.debug(f"Skipping problematic text: {e}") + return + + # Try first half + mid = len(texts) // 2 + first_half = texts[:mid] + second_half = texts[mid:] + + try: + all_tokens = tokenize(first_half) + for tokens in all_tokens: + if max_doc_tokens and len(tokens) > max_doc_tokens: + tokens = tokens[:max_doc_tokens] + stats["num_truncated"] += 1 + if tokens: + builder.add_document(tokens) + except Exception: + # First half has issues, recurse + _tokenize_with_bisect_core(first_half, builder, stats, tokenize, max_doc_tokens) + + try: + all_tokens = tokenize(second_half) + for tokens in all_tokens: + if max_doc_tokens and len(tokens) > max_doc_tokens: + tokens = tokens[:max_doc_tokens] + stats["num_truncated"] += 1 + if tokens: + builder.add_document(tokens) + except Exception: + # Second half has issues, recurse + _tokenize_with_bisect_core(second_half, builder, stats, tokenize, max_doc_tokens) + + +# ============================================================================= +# Legacy ShardProcessor Ray Actor +# ============================================================================= + + +@ray.remote +class ShardProcessor: + """ + Long-lived actor that processes multiple shards. + + Loads tokenizer once, then processes assigned shards sequentially. + Ensures deterministic output through sequential file/row processing. + """ + + def __init__( + self, + resolved_tokenizer: dict, + text_field: str, + min_doc_chars: int | None, + max_doc_tokens: int | None, + dtype: str, + max_rows: int | None = None, + ): + self.text_field = text_field + self.min_doc_chars = min_doc_chars + self.max_doc_tokens = max_doc_tokens + self.max_rows = max_rows + self.dtype = np.dtype(dtype) + + # Load tokenizer ONCE + self._tokenize = create_tokenizer(resolved_tokenizer) + self.vocab_size = self._tokenize.vocab_size + + def process_shard( + self, + shard_index: int, + assignment: dict, # ShardAssignment as dict + plan_hash: str, + output_dir: str, + receipts_dir: str, + fs_protocol: str, + ) -> dict: + """ + Process a single shard: read files -> tokenize -> write .bin/.idx -> receipt. + + Returns shard statistics. + """ + fs = filesystem(fs_protocol) + + shard_id = f"shard_{shard_index:06d}" + bin_path = f"{output_dir}/{shard_id}.bin" + idx_path = f"{output_dir}/{shard_id}.idx" + receipt_path = f"{receipts_dir}/{shard_id}.json" + + # Ensure directories + ensure_dir(fs, output_dir) + ensure_dir(fs, receipts_dir) + + # Stats tracking + stats = { + "num_input_rows": 0, + "num_filtered": 0, + "num_truncated": 0, + "num_errors": 0, + } + + files = [FileInfo(**f) for f in assignment["files"]] + input_file_paths = [f.path for f in files] + + # Handle empty assignment + if not files: + return self._write_empty_receipt( + shard_id, + shard_index, + plan_hash, + input_file_paths, + stats, + receipt_path, + fs, + ) + + # Process files and write shard + with fs.open(bin_path, "wb") as bin_file: + builder = IndexedDatasetBuilder(bin_file, dtype=self.dtype) + + # Track rows processed across files for max_rows limit + rows_processed = 0 + + # Process files SEQUENTIALLY for determinism + for file_info in files: + rows_processed = self._process_file(file_info, builder, stats, fs, rows_processed) + # Stop if we've hit max_rows + if self.max_rows and rows_processed >= self.max_rows: + break + + bin_bytes, bin_checksum = builder.get_bin_info() + builder_stats = builder.get_stats() + + # Handle empty result (all rows filtered) + if builder_stats["num_sequences"] == 0: + # Remove empty bin file + try: + fs.rm(bin_path) + except Exception: + pass + return self._write_empty_receipt( + shard_id, + shard_index, + plan_hash, + input_file_paths, + stats, + receipt_path, + fs, + ) + + # Write index + with fs.open(idx_path, "wb") as idx_file: + idx_bytes, idx_checksum = builder.write_index(idx_file) + + # Write receipt (commits the shard) + receipt = { + "shard_id": shard_id, + "shard_index": shard_index, + "plan_hash": plan_hash, + "status": "completed", + "created_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()), + "input_files": input_file_paths, + "files": { + "bin": { + "path": f"{shard_id}.bin", + "bytes": bin_bytes, + "checksum": bin_checksum, + }, + "idx": { + "path": f"{shard_id}.idx", + "bytes": idx_bytes, + "checksum": idx_checksum, + }, + }, + "stats": {**builder_stats, **stats}, + } + + write_json(fs, receipt_path, receipt) + return receipt["stats"] + + def _process_file( + self, + file_info: FileInfo, + builder: IndexedDatasetBuilder, + stats: dict, + fs, + rows_processed: int = 0, + ) -> int: + """Process a single file, writing documents to builder. + + Returns the total number of rows processed (for max_rows tracking). + """ + # Resolve file path - handle HF deferred download + local_path = self._resolve_file_path(file_info) + + # Determine file type and iterate records + is_parquet = local_path.endswith(".parquet") or not ( + local_path.endswith(".jsonl") or local_path.endswith(".json") + ) + + if is_parquet: + # Parquet: yields raw text values (pre-filtered by min_doc_chars at Arrow level) + rows_processed = self._process_parquet_file( + local_path, builder, stats, fs, rows_processed + ) + else: + # JSONL: yields dicts, needs text extraction + rows_processed = self._process_jsonl_file( + local_path, builder, stats, fs, rows_processed + ) + + return rows_processed + + def _process_parquet_file( + self, + local_path: str, + builder: IndexedDatasetBuilder, + stats: dict, + fs, + rows_processed: int, + ) -> int: + """Process parquet file with optimized Arrow-level filtering.""" + batch_texts: list[str] = [] + tokenize_batch_size = 1000 + hit_max_rows = False + + # Parquet iterator yields (texts, num_filtered) tuples + for texts, num_filtered_by_length in self._iter_parquet_batches_from_path(local_path, fs): + if hit_max_rows: + break + + # Account for rows filtered by min_doc_chars at Arrow level + stats["num_filtered"] += num_filtered_by_length + stats["num_input_rows"] += num_filtered_by_length + + for text in texts: + # Check max_rows limit + if self.max_rows and rows_processed >= self.max_rows: + hit_max_rows = True + break + + stats["num_input_rows"] += 1 + rows_processed += 1 + + # Filter None values + if text is None: + stats["num_filtered"] += 1 + continue + + batch_texts.append(str(text)) + + # Process batch + if len(batch_texts) >= tokenize_batch_size: + self._tokenize_and_write_batch(batch_texts, builder, stats) + batch_texts = [] + + # Process remaining + if batch_texts: + self._tokenize_and_write_batch(batch_texts, builder, stats) + + return rows_processed + + def _process_jsonl_file( + self, + local_path: str, + builder: IndexedDatasetBuilder, + stats: dict, + fs, + rows_processed: int, + ) -> int: + """Process JSONL file.""" + batch_size = 1000 + batch_texts: list[str] = [] + + for record in self._iter_jsonl_records(local_path, fs): + # Check max_rows limit + if self.max_rows and rows_processed >= self.max_rows: + break + + stats["num_input_rows"] += 1 + rows_processed += 1 + + # Extract text + text = record.get(self.text_field) + if text is None: + stats["num_filtered"] += 1 + continue + + text = str(text) + + # Filter short docs + if self.min_doc_chars and len(text) < self.min_doc_chars: + stats["num_filtered"] += 1 + continue + + batch_texts.append(text) + + # Process batch + if len(batch_texts) >= batch_size: + self._tokenize_and_write_batch(batch_texts, builder, stats) + batch_texts = [] + + # Process remaining + if batch_texts: + self._tokenize_and_write_batch(batch_texts, builder, stats) + + return rows_processed + + def _resolve_file_path(self, file_info: FileInfo) -> str: + """ + Resolve file to a local path, downloading from HF if needed. + + For HF files, downloads to local cache (node-local). + For other files, returns local_path or path. + """ + # HF files need deferred download + if file_info.hf_repo_id is not None: + from huggingface_hub import hf_hub_download + + local_path = hf_hub_download( + repo_id=file_info.hf_repo_id, + filename=file_info.hf_filename, + revision=file_info.hf_revision, + repo_type="dataset", + local_files_only=False, + ) + return local_path + + # For non-HF files, use local_path if available + return file_info.local_path or file_info.path + + def _tokenize_and_write_batch( + self, + texts: list[str], + builder: IndexedDatasetBuilder, + stats: dict, + ) -> None: + """Tokenize a batch and write documents.""" + try: + all_tokens = self._tokenize(texts) + + # Pre-filter and truncate + processed: list[list[int]] = [] + for tokens in all_tokens: + # Truncate if needed + if self.max_doc_tokens and len(tokens) > self.max_doc_tokens: + tokens = tokens[: self.max_doc_tokens] + stats["num_truncated"] += 1 + + if tokens: + processed.append(tokens) + + # Batch add - reduces numpy allocation overhead + builder.add_documents(processed) + + except Exception as e: + # Bisect to isolate bad rows instead of dropping entire batch + if len(texts) > 1: + self._tokenize_with_bisect(texts, builder, stats) + else: + # Single text failed, count as error + stats["num_errors"] += 1 + logger.warning(f"Tokenization error for single text: {e}") + + def _tokenize_with_bisect( + self, + texts: list[str], + builder: IndexedDatasetBuilder, + stats: dict, + ) -> None: + """ + Bisect a batch to isolate problematic rows. + + When a batch fails, recursively split in half to find and skip + only the problematic texts while processing valid ones. + """ + if len(texts) == 0: + return + + if len(texts) == 1: + # Single text - try it alone + try: + all_tokens = self._tokenize(texts) + for tokens in all_tokens: + if self.max_doc_tokens and len(tokens) > self.max_doc_tokens: + tokens = tokens[: self.max_doc_tokens] + stats["num_truncated"] += 1 + if tokens: + builder.add_document(tokens) + except Exception as e: + stats["num_errors"] += 1 + logger.debug(f"Skipping problematic text: {e}") + return + + # Try first half + mid = len(texts) // 2 + first_half = texts[:mid] + second_half = texts[mid:] + + try: + all_tokens = self._tokenize(first_half) + for tokens in all_tokens: + if self.max_doc_tokens and len(tokens) > self.max_doc_tokens: + tokens = tokens[: self.max_doc_tokens] + stats["num_truncated"] += 1 + if tokens: + builder.add_document(tokens) + except Exception: + # First half has issues, recurse + self._tokenize_with_bisect(first_half, builder, stats) + + try: + all_tokens = self._tokenize(second_half) + for tokens in all_tokens: + if self.max_doc_tokens and len(tokens) > self.max_doc_tokens: + tokens = tokens[: self.max_doc_tokens] + stats["num_truncated"] += 1 + if tokens: + builder.add_document(tokens) + except Exception: + # Second half has issues, recurse + self._tokenize_with_bisect(second_half, builder, stats) + + def _iter_parquet_batches_from_path( + self, path: str, fs + ) -> Iterator[tuple[list[str | None], int]]: + """ + Iterate (texts, num_filtered) batches from parquet file. + + Uses iter_batches for memory efficiency. + Handles remote paths via fsspec. + """ + # For remote paths, need to open via fsspec + # For local paths after HF download, can read directly + if self._is_remote_path(path): + with fs.open(path, "rb") as f: + parquet_file = pq.ParquetFile(f) + yield from self._iter_parquet_batches(parquet_file) + else: + parquet_file = pq.ParquetFile(path) + yield from self._iter_parquet_batches(parquet_file) + + def _iter_parquet_batches( + self, parquet_file: pq.ParquetFile + ) -> Iterator[tuple[list[str | None], int]]: + """Iterate batches from parquet file efficiently. + + Yields (texts, num_filtered) tuples where: + - texts: list of text values (already filtered by min_doc_chars) + - num_filtered: count of rows filtered by min_doc_chars + + Uses to_pylist() for bulk conversion instead of per-element as_py(). + """ + import pyarrow.compute as pc + + for batch in parquet_file.iter_batches( + columns=[self.text_field], + batch_size=10000, + ): + column = batch.column(self.text_field) + original_len = len(column) + num_filtered = 0 + + # Apply min_doc_chars filter at Arrow level if configured + if self.min_doc_chars: + lengths = pc.utf8_length(column) + mask = pc.greater_equal(lengths, self.min_doc_chars) + column = pc.filter(column, mask) + num_filtered = original_len - len(column) + + # Use to_pylist() for bulk conversion - much faster than per-element as_py() + yield column.to_pylist(), num_filtered + + def _iter_jsonl_records(self, path: str, fs) -> Iterator[dict]: + """ + Iterate records from JSONL file. + + Handles remote paths via fsspec. + """ + if self._is_remote_path(path): + with fs.open(path, "r") as f: + for line in f: + if line.strip(): + yield json.loads(line) + else: + with open(path) as f: + for line in f: + if line.strip(): + yield json.loads(line) + + def _is_remote_path(self, path: str) -> bool: + """Check if path is a remote path (S3/GCS/etc).""" + return path.startswith(("s3://", "gs://", "gcs://", "az://", "abfs://")) + + def _write_empty_receipt( + self, + shard_id: str, + shard_index: int, + plan_hash: str, + input_files: list[str], + stats: dict, + receipt_path: str, + fs, + ) -> dict: + """Write receipt for empty shard (CRITICAL for resume correctness).""" + receipt = { + "shard_id": shard_id, + "shard_index": shard_index, + "plan_hash": plan_hash, + "status": "completed", + "created_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()), + "input_files": input_files, + "files": { + "bin": { + "path": f"{shard_id}.bin", + "bytes": 0, + "checksum": "xxh64:empty", + }, + "idx": { + "path": f"{shard_id}.idx", + "bytes": 0, + "checksum": "xxh64:empty", + }, + }, + "stats": { + "num_sequences": 0, + "total_tokens": 0, + "min_length": 0, + "max_length": 0, + **stats, + }, + } + + write_json(fs, receipt_path, receipt) + return receipt["stats"] diff --git a/src/nemotron/data_prep/templates/nano3.jinja b/src/nemotron/data_prep/templates/nano3.jinja new file mode 100644 index 0000000..bac0d48 --- /dev/null +++ b/src/nemotron/data_prep/templates/nano3.jinja @@ -0,0 +1,212 @@ +{% macro render_extra_keys(json_dict, handled_keys) %} + {%- if json_dict is mapping %} + {%- for json_key in json_dict if json_key not in handled_keys %} + {%- if json_dict[json_key] is mapping or (json_dict[json_key] is sequence and json_dict[json_key] is not string) %} + {{- '\n<' ~ json_key ~ '>' ~ (json_dict[json_key] | tojson | safe) ~ '' }} + {%- else %} + {{-'\n<' ~ json_key ~ '>' ~ (json_dict[json_key] | string) ~ '' }} + {%- endif %} + {%- endfor %} + {%- endif %} +{% endmacro %} +{%- set kw = chat_template_kwargs if chat_template_kwargs is defined else {} %} +{%- set enable_thinking = kw.enable_thinking if kw.enable_thinking is defined else True %} +{%- set reasoning_budget = kw.reasoning_budget if kw.reasoning_budget is defined else None %} +{%- set truncate_history_thinking = kw.truncate_history_thinking if kw.truncate_history_thinking is defined else True %} +{%- set response_format = kw.response_format if kw.response_format is defined else None %} + +{%- set ns = namespace(last_user_idx = -1) %} +{%- set loop_messages = messages %} +{%- for m in loop_messages %} + {%- if m["role"] == "user" %} + {%- set ns.last_user_idx = loop.index0 %} + {%- endif %} +{%- endfor %} + +{%- if messages[0]["role"] == "system" %} + {%- set system_message = messages[0]["content"] %} + {%- set loop_messages = messages[1:] %} +{%- else %} + {%- set system_message = "" %} + {%- set loop_messages = messages %} +{%- endif %} +{%- if not tools is defined %} + {%- set tools = [] %} +{%- endif %} +{# Recompute last_user_idx relative to loop_messages after handling system #} +{%- set ns = namespace(last_user_idx = -1) %} +{%- for m in loop_messages %} + {%- if m["role"] == "user" %} + {%- set ns.last_user_idx = loop.index0 %} + {%- endif %} +{%- endfor %} +{%- if system_message is defined %} + {{- "<|im_start|>system\n" + system_message }} +{%- else %} + {%- if tools is iterable and tools | length > 0 %} + {{- "<|im_start|>system\n" }} + {%- endif %} +{%- endif %} +{%- if tools is iterable and tools | length > 0 %} + {%- if system_message is defined and system_message | length > 0 %} + {{- "\n\n" }} + {%- endif %} + {{- "# Tools\n\nYou have access to the following functions:\n\n" }} + {{- "" }} + {%- for tool in tools %} + {%- if tool.function is defined %} + {%- set tool = tool.function %} + {%- endif %} + {{- "\n\n" ~ tool.name ~ "" }} + {%- if tool.description is defined %} + {{- '\n' ~ (tool.description | trim) ~ '' }} + {%- endif %} + {{- '\n' }} + {%- if tool.parameters is defined and tool.parameters is mapping and tool.parameters.properties is defined and tool.parameters.properties is mapping %} + {%- for param_name, param_fields in tool.parameters.properties|items %} + {{- '\n' }} + {{- '\n' ~ param_name ~ '' }} + {%- if param_fields.type is defined %} + {{- '\n' ~ (param_fields.type | string) ~ '' }} + {%- endif %} + {%- if param_fields.description is defined %} + {{- '\n' ~ (param_fields.description | trim) ~ '' }} + {%- endif %} + {%- if param_fields.enum is defined %} + {{- '\n' ~ (param_fields.enum | tojson | safe) ~ '' }} + {%- endif %} + {%- set handled_keys = ['name', 'type', 'description', 'enum'] %} + {{- render_extra_keys(param_fields, handled_keys) }} + {{- '\n' }} + {%- endfor %} + {%- endif %} + {% set handled_keys = ['type', 'properties', 'required'] %} + {{- render_extra_keys(tool.parameters, handled_keys) }} + {%- if tool.parameters is defined and tool.parameters.required is defined %} + {{- '\n' ~ (tool.parameters.required | tojson | safe) ~ '' }} + {%- endif %} + {{- '\n' }} + {%- set handled_keys = ['type', 'name', 'description', 'parameters'] %} + {{- render_extra_keys(tool, handled_keys) }} + {{- '\n' }} + {%- endfor %} + {{- "\n" }} + + {{- '\n\nIf you choose to call a function ONLY reply in the following format with NO suffix:\n\n\n\n\nvalue_1\n\n\nThis is the value for the second parameter\nthat can span\nmultiple lines\n\n\n\n\n\nReminder:\n- Function calls MUST follow the specified format: an inner block must be nested within XML tags\n- Required parameters MUST be specified\n- You may provide optional reasoning for your function call in natural language BEFORE the function call, but NOT after\n- If there is no function call available, answer the question like normal with your current knowledge and do not tell the user about function calls\n' }} +{%- endif %} + + +{%- if system_message is defined %} + {{- '<|im_end|>\n' }} +{%- else %} + {%- if tools is iterable and tools | length > 0 %} + {{- '<|im_end|>\n' }} + {%- endif %} +{%- endif %} + +{%- for message in loop_messages %} + {%- if message.role == "assistant" %} + {# Add reasoning content in to content field for unified processing below. #} + {%- if message.reasoning_content is defined and message.reasoning_content is string and message.reasoning_content | trim | length > 0 %} + {%- set content = "\n" ~ message.reasoning_content ~ "\n\n" ~ (message.content | default('', true)) %} + {%- else %} + {%- set content = message.content | default('', true) %} + {%- if content is string -%} + {# Allow downstream logic to to take care of broken thought, only handle coherent reasoning here. #} + {%- if '' not in content and '' not in content -%} + {%- set content = "" ~ content -%} + {%- endif -%} + {%- else -%} + {%- set content = content -%} + {%- endif -%} + {%- endif %} + {%- if message.tool_calls is defined and message.tool_calls is iterable and message.tool_calls | length > 0 %} + {# Assistant message has tool calls. #} + {{- '<|im_start|>assistant\n' }} + {%- set include_content = not (truncate_history_thinking and loop.index0 < ns.last_user_idx) %} + {%- if content is string and content | trim | length > 0 %} + {%- if include_content %} + {{- (content | trim) ~ '\n' -}} + {%- else %} + {%- set c = (content | string) %} + {%- if '' in c %} + {# Keep only content after the last closing think. Also generation prompt causes this. #} + {%- set c = c.split('')[-1] %} + {%- elif '' in c %} + {# If was opened but never closed, drop the trailing think segment #} + {%- set c = c.split('')[0] %} + {%- endif %} + {%- set c = "" ~ c | trim %} + {%- if c | length > 0 %} + {{- c ~ '\n' -}} + {%- endif %} + {%- endif %} + {%- else %} + {{- "" -}} + {%- endif %} + {%- for tool_call in message.tool_calls %} + {%- if tool_call.function is defined %} + {%- set tool_call = tool_call.function %} + {%- endif %} + {{- '\n\n' -}} + {%- if tool_call.arguments is defined %} + {%- for args_name, args_value in tool_call.arguments|items %} + {{- '\n' -}} + {%- set args_value = args_value | tojson | safe if args_value is mapping or (args_value is sequence and args_value is not string) else args_value | string %} + {{- args_value ~ '\n\n' -}} + {%- endfor %} + {%- endif %} + {{- '\n\n' -}} + {%- endfor %} + {{- '<|im_end|>\n' }} + {%- else %} + {# Assistant message doesn't have tool calls. #} + {%- if not (truncate_history_thinking and loop.index0 < ns.last_user_idx) %} + {{- '<|im_start|>assistant\n' ~ (content | default('', true) | string | trim) ~ '<|im_end|>\n' }} + {%- else %} + {%- set c = (content | default('', true) | string) %} + {%- if '' in c and '' in c %} + {%- set c = "" ~ c.split('')[-1] %} + {%- endif %} + {%- set c = c | trim %} + {%- if c | length > 0 %} + {{- '<|im_start|>assistant\n' ~ c ~ '<|im_end|>\n' }} + {%- else %} + {{- '<|im_start|>assistant\n<|im_end|>\n' }} + {%- endif %} + {%- endif %} + {%- endif %} + {%- elif message.role == "user" or message.role == "system" %} + {{- '<|im_start|>' + message.role + '\n' }} + {%- set content = message.content | string %} + {%- if message.role == "user" and loop.index0 == ns.last_user_idx and reasoning_budget is not none %} + {{- content + '\n\n{thinking token budget: ' + (reasoning_budget | string) + '}' }} + {%- else %} + {{- content }} + {%- endif %} + {{- '<|im_end|>\n' }} + {%- elif message.role == "tool" %} + {%- if loop.previtem and loop.previtem.role != "tool" %} + {{- '<|im_start|>user\n' }} + {%- endif %} + {{- '\n' }} + {{- message.content }} + {{- '\n\n' }} + {%- if not loop.last and loop.nextitem.role != "tool" %} + {{- '<|im_end|>\n' }} + {%- elif loop.last %} + {{- '<|im_end|>\n' }} + {%- endif %} + {%- else %} + {{- '<|im_start|>' + message.role + '\n' + message.content + '<|im_end|>\n' }} + {%- endif %} +{%- endfor %} + +{%- if add_generation_prompt %} + {%- if enable_thinking %} + {{- '<|im_start|>assistant\n\n' }} + {%- else %} + {{- '<|im_start|>assistant\n' }} + {%- endif %} +{%- endif %} + diff --git a/src/nemotron/data_prep/utils/__init__.py b/src/nemotron/data_prep/utils/__init__.py new file mode 100644 index 0000000..8f0b440 --- /dev/null +++ b/src/nemotron/data_prep/utils/__init__.py @@ -0,0 +1,19 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Utility modules for data preparation.""" + +from nemotron.data_prep.utils.size import format_byte_size, parse_byte_size + +__all__ = ["parse_byte_size", "format_byte_size"] diff --git a/src/nemotron/data_prep/utils/size.py b/src/nemotron/data_prep/utils/size.py new file mode 100644 index 0000000..e1f2a50 --- /dev/null +++ b/src/nemotron/data_prep/utils/size.py @@ -0,0 +1,129 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Size parsing and formatting utilities.""" + +import math +import re + +_SIZE_PATTERN = re.compile(r"(\d+(?:\.\d+)?)\s*([KMGTPEZY]i?)?B?", re.IGNORECASE) +_BYTE_SIZES = { + "": 1, + "K": 1024, + "M": 1024**2, + "G": 1024**3, + "T": 1024**4, + "P": 1024**5, + "E": 1024**6, +} + + +def parse_byte_size(size: int | float | str) -> int: + """Parse human-readable size to bytes. + + Accepts integers, floats, or strings with optional unit suffixes. + Supports both SI-style (MB) and IEC-style (MiB) notations. + + Args: + size: Size specification. Examples: + - 1024 (integer bytes) + - "256MB" or "256M" (256 megabytes) + - "1G" or "1GB" (1 gigabyte) + - "500MiB" (500 mebibytes, same as 500M) + + Returns: + Size in bytes as integer. + + Raises: + ValueError: If the size format is invalid. + + Examples: + >>> parse_byte_size("256MB") + 268435456 + >>> parse_byte_size("1G") + 1073741824 + >>> parse_byte_size(1024) + 1024 + """ + if isinstance(size, (int, float)): + return int(size) + + match = _SIZE_PATTERN.fullmatch(size.strip()) + if not match: + raise ValueError(f"Invalid size format: {size!r}") + + num = float(match.group(1)) + unit_str = match.group(2) or "" + # Extract first character for unit, handle 'i' suffix (MiB = M) + unit = unit_str[0].upper() if unit_str else "" + + multiplier = _BYTE_SIZES.get(unit) + if multiplier is None: + raise ValueError(f"Unknown size unit: {unit_str!r}") + + return int(num * multiplier) + + +def format_byte_size(size: int) -> str: + """Format bytes as human-readable string. + + Uses the largest unit that results in a value >= 1. + + Args: + size: Size in bytes. + + Returns: + Human-readable size string (e.g., "256MB", "1.5GB"). + + Examples: + >>> format_byte_size(268435456) + '256MB' + >>> format_byte_size(1073741824) + '1GB' + >>> format_byte_size(1500000000) + '1.4GB' + """ + if size < 0: + return f"-{format_byte_size(-size)}" + + for unit in ["B", "KB", "MB", "GB", "TB", "PB"]: + if abs(size) < 1024: + if size == int(size): + return f"{int(size)}{unit}" + return f"{size:.1f}{unit}" + size = size / 1024 + + return f"{size:.1f}EB" + + +def compute_num_shards(total_bytes: int, shard_size: str | int) -> int: + """Compute number of shards from target shard size. + + Args: + total_bytes: Total data size in bytes. + shard_size: Target shard size (string like "256MB" or integer bytes). + + Returns: + Number of shards (minimum 1). + + Examples: + >>> compute_num_shards(1073741824, "256MB") # 1GB / 256MB + 4 + >>> compute_num_shards(100, "256MB") # Small data still gets 1 shard + 1 + """ + target_bytes = parse_byte_size(shard_size) + if target_bytes <= 0: + raise ValueError(f"shard_size must be positive, got {shard_size}") + return max(1, math.ceil(total_bytes / target_bytes)) diff --git a/src/nemotron/kit/README.md b/src/nemotron/kit/README.md new file mode 100644 index 0000000..6ad3ff6 --- /dev/null +++ b/src/nemotron/kit/README.md @@ -0,0 +1,112 @@ +# nemotron.kit + +Training recipe framework providing artifact versioning, configuration management, and lineage tracking. + +## Overview + +Kit is the core infrastructure for building reproducible ML training pipelines: + +- **Artifacts** — Path-centric data and model versioning with typed metadata +- **Configuration** — YAML/TOML/JSON config loading with OmegaConf and Hydra-style overrides +- **CLI Framework** — Build hierarchical CLIs with typer (see src/nemotron/cli/) +- **Execution** — Local, NeMo-Run (Slurm/Docker/cloud), and torchrun support +- **Lineage Tracking** — W&B integration for experiment tracking and artifact provenance + +## Module Structure + +``` +src/nemotron/kit/ +├── __init__.py # Public API exports +├── artifact.py # Artifact system (path-centric design) +├── registry.py # Artifact registry (fsspec/W&B backends) +├── run.py # NeMo-Run integration +├── trackers.py # Lineage tracking (W&B, NoOp) +├── train_script.py # Training script utilities +├── resolvers.py # OmegaConf custom resolvers +├── wandb.py # W&B configuration +├── exceptions.py # Custom exceptions +├── filesystem.py # fsspec for art:// URIs +├── pipeline.py # Pipeline orchestration +├── step.py # Pipeline step definition +├── track.py # Tracking configuration +├── cli/ # CLI submodule +│ ├── config.py # CLI config utilities +│ ├── display.py # Terminal display +│ ├── env.py # Environment handling +│ ├── globals.py # Global state +│ ├── recipe.py # @recipe decorator, ArtifactInput +│ ├── squash.py # Container squashing +│ └── utils.py # Shared CLI utilities +└── packaging/ # Remote execution packaging + ├── code_packager.py # Code packaging for remote + └── self_contained_packager.py +``` + +## Quick Start + +### Creating Artifacts + +```python +from nemotron.kit import PretrainBlendsArtifact, InputDatasetInfo +from pathlib import Path + +artifact = PretrainBlendsArtifact( + path=Path("/output/data"), + total_tokens=25_000_000_000, + source_datasets=[ + InputDatasetInfo(uri="hf://dataset/name", name="my-dataset", split="train"), + ], +) +artifact.save(name="my-artifact") +``` + +### Loading Config (OmegaConf) + +```python +from nemotron.kit.train_script import parse_config_and_overrides +from dataclasses import dataclass + +@dataclass +class MyConfig: + learning_rate: float = 1e-4 + batch_size: int = 32 + +config = parse_config_and_overrides(MyConfig, config_file="config.yaml") +``` + +## Public API Quick Reference + +### Artifacts +- `Artifact` — Base class +- `DataBlendsArtifact`, `PretrainBlendsArtifact`, `SFTDataArtifact`, `SplitJsonlDataArtifact` — Data artifacts +- `ModelArtifact` — Model checkpoints +- `InputDatasetInfo` — Source dataset metadata + +### Configuration +- `parse_config_and_overrides()`, `load_omegaconf_yaml()`, `apply_hydra_overrides()`, `omegaconf_to_dataclass()` — Training script utilities + +### Execution +- `RunConfig` — NeMo-Run configuration +- `build_executor()`, `load_run_profile()` — Execution helpers + +### Registry & Tracking +- `init()`, `get_config()`, `is_initialized()` — Kit initialization +- `ArtifactRegistry`, `ArtifactEntry`, `ArtifactVersion` — Registry system +- `LineageTracker`, `WandbTracker`, `NoOpTracker` — Tracking backends +- `add_wandb_tags()`, `finish_wandb()` — W&B utilities + +## Full Documentation + +See [docs/train/kit.md](../../../docs/train/kit.md) for complete documentation including: + +- Artifact philosophy and design +- Configuration system details +- Lineage tracking +- API reference + +See [docs/train/cli.md](../../../docs/train/cli.md) for CLI framework documentation including: + +- Building nested CLIs with typer +- Artifact inputs and resolution +- Execution modes +- Recipe tutorial diff --git a/src/nemotron/kit/__init__.py b/src/nemotron/kit/__init__.py new file mode 100644 index 0000000..ed50368 --- /dev/null +++ b/src/nemotron/kit/__init__.py @@ -0,0 +1,257 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# Copyright (c) Nemotron Contributors +# SPDX-License-Identifier: MIT + +""" +nemotron.kit - Toolkit for building reproducible training pipelines. + +This module provides everything you need to build training recipes: +- Artifact versioning, storage, and tracking +- Config file support (YAML, TOML, JSON) with CLI override +- Pipeline orchestration with subprocess piping and Slurm support +- W&B and fsspec storage backends + +Quick Start: + >>> from nemotron.kit import Artifact, Step + >>> from pydantic import Field + >>> + >>> # Artifact with validation + >>> class Dataset(Artifact): + ... num_examples: int = Field(gt=0) + >>> + >>> dataset = Dataset(path=Path("/tmp/data"), num_examples=1000) + >>> dataset.save() + +Registry Example: + >>> import nemotron.kit as kit + >>> + >>> # Initialize with fsspec backend + >>> kit.init(backend="fsspec", root="/data/artifacts") + >>> + >>> # Or with W&B backend + >>> kit.init(backend="wandb", wandb_project="my-project") + >>> + >>> # Save artifact to registry + >>> dataset.save(name="my-dataset") + >>> print(dataset.uri) # art://my-dataset:v1 + >>> + >>> # Load from URI + >>> loaded = Dataset.from_uri("art://my-dataset:v1") +""" + +from dataclasses import dataclass +from pathlib import Path +from typing import Any + +# Track module for semantic URI resolution +from nemotron.kit import track + +# Artifacts +from nemotron.kit.artifact import ( + Artifact, + DataBlendsArtifact, + ModelArtifact, + PretrainBlendsArtifact, + PretrainDataArtifact, + SFTDataArtifact, + SplitJsonlDataArtifact, + TrackingInfo, + apply_scale, + print_step_complete, +) + +# Exceptions +from nemotron.kit.exceptions import ArtifactNotFoundError, ArtifactVersionNotFoundError + +# Pipeline +from nemotron.kit.pipeline import PipelineConfig, run_pipeline +from nemotron.kit.registry import ArtifactEntry, ArtifactRegistry, ArtifactVersion + +# Run (nemo-run integration) +from nemotron.kit.run import RunConfig, build_executor, load_run_profile +from nemotron.kit.step import Step + +# Trackers +from nemotron.kit.trackers import ( + LineageTracker, + NoOpTracker, + WandbTracker, + get_lineage_tracker, + set_lineage_tracker, + to_wandb_uri, + tokenizer_to_uri, +) + +# Wandb configuration +from nemotron.kit.wandb import WandbConfig, add_wandb_tags, init_wandb_if_configured + +__all__ = [ + # Run (nemo-run integration) + "RunConfig", + "build_executor", + "load_run_profile", + # Artifacts + "Artifact", + "DataBlendsArtifact", + "ModelArtifact", + "PretrainBlendsArtifact", + "PretrainDataArtifact", + "SFTDataArtifact", + "SplitJsonlDataArtifact", + "TrackingInfo", + "apply_scale", + "print_step_complete", + # Pipeline + "Step", + "PipelineConfig", + "run_pipeline", + # Registry + "init", + "get_config", + "is_initialized", + "ArtifactRegistry", + "ArtifactEntry", + "ArtifactVersion", + # Trackers + "LineageTracker", + "WandbTracker", + "NoOpTracker", + "set_lineage_tracker", + "get_lineage_tracker", + "to_wandb_uri", + "tokenizer_to_uri", + # Exceptions + "ArtifactNotFoundError", + "ArtifactVersionNotFoundError", + # Track + "track", + # Wandb configuration + "WandbConfig", + "init_wandb_if_configured", + "add_wandb_tags", +] + + +@dataclass +class _KitConfig: + """Internal configuration for nemotron.kit.""" + + backend: str + root: Path | None = None + wandb_project: str | None = None + wandb_entity: str | None = None + + +# Global configuration +_config: _KitConfig | None = None + + +def init( + backend: str = "fsspec", + root: str | Path | None = None, + wandb_project: str | None = None, + wandb_entity: str | None = None, + **kwargs: Any, +) -> None: + """Initialize nemotron.kit with a storage backend. + + Must be called before using artifact URIs or registry features. + + Args: + backend: Storage backend ("fsspec" or "wandb") + root: Root path for fsspec backend (required for fsspec) + wandb_project: W&B project name (required for wandb) + wandb_entity: W&B entity/team name (optional for wandb) + **kwargs: Additional backend-specific options + + Example: + >>> import nemotron.kit as kit + >>> + >>> # Local filesystem + >>> kit.init(backend="fsspec", root="/data/artifacts") + >>> + >>> # S3 (requires s3fs) + >>> kit.init(backend="fsspec", root="s3://bucket/artifacts") + >>> + >>> # W&B + >>> kit.init(backend="wandb", wandb_project="my-project") + """ + global _config + + # Validate backend + if backend not in ("fsspec", "wandb"): + raise ValueError(f"Unknown backend: {backend}. Must be 'fsspec' or 'wandb'.") + + if backend == "fsspec" and root is None: + raise ValueError("root is required for fsspec backend") + + if backend == "wandb" and wandb_project is None: + raise ValueError("wandb_project is required for wandb backend") + + # Store configuration + _config = _KitConfig( + backend=backend, + root=Path(root) if root else None, + wandb_project=wandb_project, + wandb_entity=wandb_entity, + ) + + # Initialize registry + from nemotron.kit.registry import ArtifactRegistry, set_registry + + registry = ArtifactRegistry( + backend=backend, + root=root, + wandb_project=wandb_project, + wandb_entity=wandb_entity, + ) + set_registry(registry) + + # If using wandb backend, also set up lineage tracker + if backend == "wandb": + tracker = WandbTracker() + set_lineage_tracker(tracker) + + +def get_config() -> _KitConfig | None: + """Get the current kit configuration. + + Returns: + Current configuration or None if not initialized + """ + return _config + + +def is_initialized() -> bool: + """Check if nemotron.kit has been initialized. + + Returns: + True if init() has been called + """ + return _config is not None + + +def _ensure_initialized() -> None: + """Ensure kit.init() has been called. + + Raises: + RuntimeError: If not initialized + """ + if not is_initialized(): + raise RuntimeError( + "nemotron.kit not initialized. Call kit.init() first.\n" + "Example: kit.init(backend='fsspec', root='/data/artifacts')" + ) diff --git a/src/nemotron/kit/artifact.py b/src/nemotron/kit/artifact.py new file mode 100644 index 0000000..bc64526 --- /dev/null +++ b/src/nemotron/kit/artifact.py @@ -0,0 +1,232 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +""" +Artifact module for nemotron.kit. + +Re-exports artifact classes from nemotron.kit.artifacts and provides utilities. +""" + +from __future__ import annotations + +import json +import sys +from dataclasses import dataclass + +from nemotron.kit.artifacts import ( + Artifact, + DataBlendsArtifact, + ModelArtifact, + PretrainBlendsArtifact, + PretrainDataArtifact, + SFTDataArtifact, + SplitJsonlDataArtifact, + TrackingInfo, +) + +__all__ = [ + # Artifact classes + "Artifact", + "TrackingInfo", + "DataBlendsArtifact", + "PretrainBlendsArtifact", + "PretrainDataArtifact", + "SFTDataArtifact", + "SplitJsonlDataArtifact", + "ModelArtifact", + # Utilities + "ArtifactInput", + "apply_scale", + "print_step_complete", +] + + +# ============================================================================= +# Artifact Input for CLI Commands +# ============================================================================= + + +@dataclass +class ArtifactInput: + """Defines an artifact input slot for a CLI command. + + Used with App.command() to specify named artifact inputs that can be + provided via --art. CLI arguments or stdin piping. + + Example: + >>> app.command( + ... "pretrain", + ... TrainingConfig, + ... training_main, + ... artifacts={ + ... "data": ArtifactInput( + ... default_name="DataBlendsArtifact-pretrain", + ... mappings={"path": "dataset.data_path"}, + ... ), + ... }, + ... ) + + Then users can run: + nemotron nano3 pretrain --art.data v10 + nemotron nano3 pretrain --art.data DataBlendsArtifact-pretrain:latest + nemotron nano3 pretrain --art.data romeyn/nemotron/DataBlendsArtifact-pretrain:v10 + """ + + default_name: str + """Default W&B artifact name (e.g., 'DataBlendsArtifact-pretrain'). + + Used when only a version is provided (e.g., --art.data v10 or --art.data latest). + """ + + mappings: dict[str, str] + """Mapping from artifact metadata fields to config field paths. + + Keys are field names from the artifact's metadata.json (e.g., 'path'). + Values are dot-separated config field paths (e.g., 'dataset.data_path'). + + Example: {"path": "dataset.data_path"} means: + - Load artifact metadata + - Get metadata["path"] value + - Set config.dataset.data_path = that value + """ + + +# ============================================================================= +# Utilities +# ============================================================================= + + +def apply_scale(count: int, scale: str) -> int: + """Apply scale factor for fast iteration. + + Scale factors: + - tiny: 1% (minimum 1, maximum 10,000) + - small: 10% + - medium: 30% + - full: 100% + + Example: + >>> apply_scale(100_000, "tiny") + 1000 + >>> apply_scale(2_000_000, "tiny") # Capped at 10k + 10000 + >>> apply_scale(100_000, "full") + 100000 + """ + scale_factors = { + "tiny": 0.01, + "small": 0.10, + "medium": 0.30, + "full": 1.0, + } + + if scale not in scale_factors: + raise ValueError(f"Invalid scale: {scale}. Must be one of: {list(scale_factors.keys())}") + + scaled = int(count * scale_factors[scale]) + result = max(1, scaled) # Ensure at least 1 + + # Cap tiny at 10k for reasonable testing time + if scale == "tiny": + result = min(result, 10_000) + + return result + + +def print_step_complete( + *args: dict[str, Artifact], + title: str = "Complete", + **artifacts: Artifact, +) -> None: + """Print completion message with named artifacts. + + - Rich table to stderr (for humans) + - JSON to stdout automatically when stdout is piped (for pipeline composition) + + Args: + *args: Legacy dict syntax for backward compatibility + title: Title for the completion message + **artifacts: Named artifacts (e.g., data=artifact, model=checkpoint) + + Example: + >>> print_step_complete(data=data_artifact) + >>> print_step_complete(data=data_artifact, model=model_artifact) + """ + # Support legacy dict syntax for backward compatibility + if args and isinstance(args[0], dict): + artifacts = args[0] + + # Auto-enable JSON output when stdout is piped + output_json = not sys.stdout.isatty() + + # Output JSON to stdout when piped + if output_json: + # Output format: {"name": {"path": "...", "type": "..."}, ...} + output = {name: json.loads(art.to_json()) for name, art in artifacts.items()} + print(json.dumps(output), flush=True) + + # Output human-readable panel to stderr + try: + from rich.console import Console + from rich.panel import Panel + from rich.text import Text + + console = Console(file=sys.stderr) + + panels = [] + for name, artifact in artifacts.items(): + # Build content lines - URI first for easy copy/paste + lines = Text() + lines.append(f"{artifact.art_path}\n\n", style="bold yellow") + lines.append("Path: ", style="dim") + lines.append(f"{artifact.path.resolve()}\n", style="blue") + + # Add metrics if present + if artifact.metrics: + lines.append("Metrics: ", style="dim") + metrics_parts = [ + f"{k}={v:,.0f}" if v > 100 else f"{k}={v:.2f}" + for k, v in artifact.metrics.items() + ] + lines.append(", ".join(metrics_parts), style="green") + + panel = Panel( + lines, + title=f"[bold cyan]{name}[/bold cyan] [dim]({artifact.type})[/dim]", + title_align="left", + border_style="green", + ) + panels.append(panel) + + # Print all panels + console.print() + for panel in panels: + console.print(panel) + + except ImportError: + # Fallback without rich + sys.stderr.write(f"\nComplete {title}\n") + sys.stderr.write("=" * 70 + "\n") + for name, artifact in artifacts.items(): + sys.stderr.write(f"{name} ({artifact.type}):\n") + sys.stderr.write(f" {artifact.art_path}\n\n") + sys.stderr.write(f" Path: {artifact.path.resolve()}\n") + if artifact.metrics: + metrics_parts = [ + f"{k}={v:,.0f}" if v > 100 else f"{k}={v:.2f}" + for k, v in artifact.metrics.items() + ] + sys.stderr.write(f" Metrics: {', '.join(metrics_parts)}\n") + sys.stderr.write("=" * 70 + "\n") + sys.stderr.flush() diff --git a/src/nemotron/kit/artifacts/__init__.py b/src/nemotron/kit/artifacts/__init__.py new file mode 100644 index 0000000..1a5a287 --- /dev/null +++ b/src/nemotron/kit/artifacts/__init__.py @@ -0,0 +1,42 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +""" +Artifact classes for nemotron.kit. + +This module provides typed artifact classes for tracking data and model outputs. +Each artifact type defines its own W&B file/reference handling. +""" + +from nemotron.kit.artifacts.base import Artifact, TrackingInfo +from nemotron.kit.artifacts.data_blends import DataBlendsArtifact +from nemotron.kit.artifacts.model import ModelArtifact +from nemotron.kit.artifacts.pretrain_blends import PretrainBlendsArtifact +from nemotron.kit.artifacts.pretrain_data import PretrainDataArtifact +from nemotron.kit.artifacts.sft_data import SFTDataArtifact +from nemotron.kit.artifacts.split_jsonl import SplitJsonlDataArtifact + +__all__ = [ + # Base + "Artifact", + "TrackingInfo", + # Data artifacts + "DataBlendsArtifact", + "PretrainBlendsArtifact", + "PretrainDataArtifact", + "SFTDataArtifact", + "SplitJsonlDataArtifact", + # Model artifacts + "ModelArtifact", +] diff --git a/src/nemotron/kit/artifacts/base.py b/src/nemotron/kit/artifacts/base.py new file mode 100644 index 0000000..a2d1d4b --- /dev/null +++ b/src/nemotron/kit/artifacts/base.py @@ -0,0 +1,421 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Base artifact class and tracking info.""" + +from __future__ import annotations + +import json +import sys +from datetime import datetime +from pathlib import Path +from typing import TYPE_CHECKING, Annotated, Any, Self + +from pydantic import BaseModel, Field, model_validator + +if TYPE_CHECKING: + from nemotron.kit.trackers import LineageTracker + + +class TrackingInfo(BaseModel): + """Information about artifact tracking in external systems.""" + + artifact_id: str | None = None + artifact_type: str | None = None + run_id: str | None = None + url: str | None = None + used_artifacts: Annotated[list[str], Field(default_factory=list)] + + +class Artifact(BaseModel): + """Path-centric artifact with optional typed metadata. + + Core philosophy: An artifact IS a path with metadata. + + Simple usage (no subclass needed): + >>> artifact = Artifact(path=Path("/data/model"), type="model") + >>> artifact.metadata["step"] = 10000 + + Typed subclass for validation and IDE support: + >>> class ModelArtifact(Artifact): + ... step: int + ... final_loss: float | None = None + >>> + >>> model = ModelArtifact(path=Path("/data/model"), step=10000) + >>> model.step # IDE autocomplete works + >>> model.metadata["step"] # Also accessible here + """ + + # === Core fields === + path: Annotated[Path, Field(description="Filesystem path to the artifact")] + type: Annotated[str, Field(default="artifact", description="Artifact type")] + metadata: Annotated[ + dict[str, Any], Field(default_factory=dict, description="Artifact metadata") + ] + + # === Provenance fields === + created_at: Annotated[ + str, + Field( + default_factory=lambda: datetime.now().astimezone().isoformat(), + description="ISO timestamp of creation", + ), + ] + producer: Annotated[str | None, Field(default=None, description="Run ID or 'local'")] + tracking: Annotated[TrackingInfo | None, Field(default=None, description="Tracking metadata")] + name: Annotated[ + str | None, + Field(default=None, description="Semantic artifact name (e.g., nano3/pretrain/data)"), + ] + + # === Private registry state === + _name: str | None = None + _version: int | None = None + _used_artifacts: list[str] = [] + + @classmethod + def _get_metadata_fields(cls) -> set[str]: + """Get fields that should be synced to metadata dict. + + These are fields defined in subclasses but not in Artifact base. + """ + base_fields = {"path", "type", "metadata", "created_at", "producer", "tracking", "name"} + if hasattr(cls, "model_fields"): + return set(cls.model_fields.keys()) - base_fields + return set() + + @model_validator(mode="before") + @classmethod + def _setup_defaults(cls, data: Any) -> Any: + """Set default type and sync metadata fields.""" + if not isinstance(data, dict): + return data + + # Set type from class name if not provided + if "type" not in data or data["type"] == "artifact": + data["type"] = cls.__name__ + + # Ensure metadata dict exists + if "metadata" not in data: + data["metadata"] = {} + + # Pull typed fields from metadata if provided there (for loading) + metadata_fields = cls._get_metadata_fields() + for field_name in metadata_fields: + if field_name not in data and field_name in data["metadata"]: + data[field_name] = data["metadata"][field_name] + + return data + + @model_validator(mode="after") + def _sync_to_metadata(self) -> Self: + """Push typed fields into metadata dict after validation.""" + metadata_fields = self._get_metadata_fields() + for field_name in metadata_fields: + if hasattr(self, field_name): + value = getattr(self, field_name) + if value is not None: + self.metadata[field_name] = value + return self + + @property + def metrics(self) -> dict[str, float]: + """Extract numeric metrics from metadata for logging.""" + return { + k: float(v) + for k, v in self.metadata.items() + if isinstance(v, (int, float)) and not isinstance(v, bool) + } + + def get_wandb_files(self) -> list[tuple[str, str]]: + """Return list of (local_path, artifact_name) tuples for files to upload. + + These files are small and will be uploaded to W&B storage. + Override in subclasses to customize which files are uploaded. + + Returns: + List of (local_path, artifact_name) tuples. + Default: [("metadata.json", "metadata.json")] if it exists. + """ + files = [] + metadata_path = self.path / "metadata.json" + if metadata_path.exists(): + files.append((str(metadata_path), "metadata.json")) + return files + + def get_wandb_references(self) -> list[tuple[str, str]]: + """Return list of (uri, name) tuples for references to add. + + References point to data on shared storage (e.g., /lustre) without uploading. + Override in subclasses to customize which references are added. + + Returns: + List of (uri, name) tuples. + Default: reference to artifact directory as "output". + """ + # Default: add reference to the artifact directory + artifact_path = self.path + if artifact_path.is_file(): + artifact_path = artifact_path.parent + return [(f"file://{artifact_path.resolve()}", "output")] + + def get_input_uris(self) -> list[str]: + """Return list of input URIs for lineage tracking. + + Override in subclasses to specify input dependencies. + + Returns: + List of URIs (hf://, file://, etc.) that this artifact depends on. + """ + return [] + + @property + def uri(self) -> str | None: + """Return art:// URI if published, None otherwise.""" + if self._name is not None and self._version is not None: + return f"art://{self._name}:v{self._version}" + return None + + @property + def art_path(self) -> str: + """Return art:// URI for downstream consumption. + + For registered artifacts: art://name:vN + For named artifacts: art://name + For unnamed artifacts: art:///absolute/path + """ + if self._name is not None and self._version is not None: + return f"art://{self._name}:v{self._version}" + if self.name is not None: + return f"art://{self.name}" + # Fallback: use absolute path + return f"art://{self.path.resolve()}" + + def _get_output_dir(self) -> Path: + """Get the output directory for metadata.json. + + Override in subclasses where path points to a file instead of directory. + """ + return self.path + + def _derive_artifact_name(self, name: str | None) -> str: + """Derive W&B artifact name from semantic name or type. + + Args: + name: Explicit name override, or None to derive from self.name + + Returns: + Artifact name like "SFTDataArtifact-sft" + """ + if name is not None: + return name + + if self.name: + # Extract stage from semantic name (e.g., "nano3/sft/data" -> "sft") + parts = self.name.split("/") + if len(parts) >= 2: + stage = parts[1].split("?")[0] # Remove query params like ?sample=100 + return f"{self.type}-{stage}" + + return self.type + + def save(self, name: str | None = None) -> None: + """Save artifact metadata to path/metadata.json (atomic write). + + If tracking is active, also logs to tracking backend. + If kit.init() was called, publishes to registry. + + Args: + name: Optional name for artifact in registry. Defaults to type. + """ + from nemotron.kit.trackers import get_lineage_tracker + + output_dir = self._get_output_dir() + output_dir.mkdir(parents=True, exist_ok=True) + + # Set producer before writing metadata + tracker = get_lineage_tracker() + if tracker and tracker.is_active(): + if self.producer is None: + self.producer = tracker.get_run_id() or "local" + else: + if self.producer is None: + self.producer = "local" + + # Write metadata.json FIRST (before log_artifact) so tracker can include it + # This is critical: tracker.log_artifact() reads metadata.json to add to W&B artifact + metadata_file_path = output_dir / "metadata.json" + temp_path = output_dir / ".metadata.json.tmp" + + with open(temp_path, "w") as f: + json.dump(self.model_dump(mode="json"), f, indent=2, default=str) + + # Atomic rename + temp_path.rename(metadata_file_path) + + # Now log to tracker (after metadata.json exists on disk) + if tracker and tracker.is_active(): + artifact_name = self._derive_artifact_name(name) + tracking_metadata = tracker.log_artifact(self, artifact_name, self._used_artifacts) + self.tracking = TrackingInfo(**tracking_metadata) + + # Publish to registry if initialized (skip for wandb backend - tracker handles it) + self._publish_to_registry(name, output_dir) + + def _publish_to_registry(self, name: str | None, output_dir: Path) -> None: + """Publish artifact to registry if initialized.""" + try: + from nemotron.kit import get_config, is_initialized + from nemotron.kit.registry import get_registry + + if is_initialized(): + config = get_config() + # Skip registry publish for wandb backend - WandbTracker already logged it + if config and config.backend != "wandb": + registry = get_registry() + artifact_name = name or self.type + version = registry.publish(artifact_name, output_dir, metadata=self.metadata) + self._name = artifact_name + self._version = version.version + except ImportError: + # Registry not available, skip + pass + + @classmethod + def load( + cls, + path: Path | None = None, + tracked_artifact: str | None = None, + ) -> Self: + """Load artifact from local path, tracked artifact, or stdin. + + Priority: tracked_artifact > path > stdin + + Args: + path: Local filesystem path to artifact directory + tracked_artifact: Tracked artifact reference (e.g., "team/project/data:v1") + + Returns: + Loaded artifact instance + """ + from nemotron.kit.trackers import get_lineage_tracker + + tracker = get_lineage_tracker() + + # Option 1: Load from tracked artifact + if tracked_artifact: + if not tracker or not tracker.is_active(): + raise ValueError( + "Cannot load tracked artifact: no active tracker. " + "Use set_lineage_tracker() to configure tracking." + ) + # Download artifact and get local path + path = tracker.use_artifact(tracked_artifact, cls.__name__.lower()) + + # Option 2: Load from explicit path + elif path: + pass # Use provided path + + # Option 3: Load from stdin (piping) + else: + if sys.stdin.isatty(): + raise ValueError( + "No input provided. Use --input-path, --input-artifact, or pipe from stdin." + ) + # Read JSON from stdin + stdin_data = json.loads(sys.stdin.read()) + if "path" not in stdin_data: + raise ValueError("Invalid stdin data: missing 'path' field") + path = Path(stdin_data["path"]) + + # Load metadata.json + metadata_path = path / "metadata.json" + if not metadata_path.exists(): + raise FileNotFoundError(f"Artifact metadata not found: {metadata_path}") + + with open(metadata_path) as f: + data = json.load(f) + + # Create artifact instance + artifact = cls(**data) + + # Track usage for lineage (if tracker active) + if tracker and tracker.is_active() and artifact.tracking: + artifact._used_artifacts.append(artifact.tracking.artifact_id or str(artifact.path)) + + return artifact + + @classmethod + def from_uri(cls, uri: str) -> Self: + """Load artifact from art:// URI. + + Args: + uri: Artifact URI (e.g., "art://my-dataset:v1" or "art://my-dataset:latest") + + Returns: + Loaded artifact instance + """ + from nemotron.kit.registry import get_registry + + registry = get_registry() + + # Parse URI: art://name:version or art://name + if not uri.startswith("art://"): + raise ValueError(f"Invalid art:// URI: {uri}") + + uri_path = uri[6:] # Remove "art://" + + # Parse name and version + version: int | str | None + if ":" in uri_path: + name, version_str = uri_path.rsplit(":", 1) + if version_str == "latest": + version = None + elif version_str.startswith("v"): + version = int(version_str[1:]) + else: + # Try numeric; otherwise treat as alias + try: + version = int(version_str) + except ValueError: + version = version_str # Alias string + else: + name = uri_path + version = None + + # Resolve to local path + local_path = registry.resolve(name, version) + + # Load artifact + artifact = cls.load(path=local_path) + + # Set registry metadata + artifact._name = name + if version is not None: + artifact._version = version + else: + # Get latest version number + entry = registry.get(name) + if entry and entry.versions: + artifact._version = entry.versions[-1].version + + return artifact + + def to_json(self) -> str: + """Serialize artifact to JSON for piping.""" + return json.dumps({"path": str(self.path), "type": self.type}) + + def __str__(self) -> str: + """String representation for piping to stdout.""" + return self.to_json() diff --git a/src/nemotron/kit/artifacts/data_blends.py b/src/nemotron/kit/artifacts/data_blends.py new file mode 100644 index 0000000..6e48f6a --- /dev/null +++ b/src/nemotron/kit/artifacts/data_blends.py @@ -0,0 +1,94 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""DataBlendsArtifact - tokenized data blends for pretrain/RL.""" + +from __future__ import annotations + +from pathlib import Path +from typing import Annotated + +from pydantic import Field + +from nemotron.kit.artifacts.base import Artifact +from nemotron.kit.trackers import InputDatasetInfo + + +class DataBlendsArtifact(Artifact): + """Tokenized data blends artifact (output of pretrain/RL data_prep). + + The path points directly to the blend.json file. + + Source URIs are tracked for W&B lineage: + - source_datasets: Input datasets with metadata (or URIs for backwards compat) + - tokenizer_uri: URI of the tokenizer model (hf://models/...) + """ + + total_tokens: Annotated[int, Field(ge=0, description="Total tokens processed")] + total_sequences: Annotated[int, Field(ge=0, description="Total documents processed")] + elapsed_sec: Annotated[ + float, Field(default=0.0, ge=0, description="Processing time in seconds") + ] + + # Per-split token counts (optional, populated in per-split mode) + train_tokens: Annotated[ + int | None, Field(default=None, ge=0, description="Tokens in train split") + ] + valid_tokens: Annotated[ + int | None, Field(default=None, ge=0, description="Tokens in valid split") + ] + test_tokens: Annotated[ + int | None, Field(default=None, ge=0, description="Tokens in test split") + ] + + # Source datasets for lineage tracking + # Accepts InputDatasetInfo (with metadata) or str (URI only, for backwards compat) + source_datasets: Annotated[ + list[InputDatasetInfo | str], + Field(default_factory=list, description="Input datasets with metadata"), + ] + tokenizer_uri: Annotated[str | None, Field(default=None, description="URI of tokenizer model")] + + def _get_output_dir(self) -> Path: + """DataBlendsArtifact.path is blend.json (a file), so use parent.""" + return self.path.parent + + def get_wandb_files(self) -> list[tuple[str, str]]: + """Return blend.json and metadata.json for upload.""" + files = [] + # DataBlendsArtifact.path is the blend.json file itself + if self.path.exists(): + files.append((str(self.path), "blend.json")) + # metadata.json is in parent directory + metadata_path = self.path.parent / "metadata.json" + if metadata_path.exists(): + files.append((str(metadata_path), "metadata.json")) + return files + + def get_wandb_references(self) -> list[tuple[str, str]]: + """Return reference to data directory on shared storage.""" + # Reference to parent directory containing tokenized data + return [(f"file://{self.path.parent.resolve()}", "output")] + + def get_input_uris(self) -> list[str]: + """Return URIs of input datasets and tokenizer for lineage.""" + uris = [] + for ds in self.source_datasets: + if isinstance(ds, InputDatasetInfo): + uris.append(ds.uri) + else: + uris.append(ds) + if self.tokenizer_uri: + uris.append(self.tokenizer_uri) + return uris diff --git a/src/nemotron/kit/artifacts/model.py b/src/nemotron/kit/artifacts/model.py new file mode 100644 index 0000000..e8c53b4 --- /dev/null +++ b/src/nemotron/kit/artifacts/model.py @@ -0,0 +1,33 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""ModelArtifact - model checkpoint artifact.""" + +from __future__ import annotations + +from typing import Annotated + +from pydantic import Field + +from nemotron.kit.artifacts.base import Artifact + + +class ModelArtifact(Artifact): + """Model checkpoint artifact (output of training). + + The path points to the checkpoint directory. + """ + + step: Annotated[int, Field(ge=0, description="Training step")] + final_loss: Annotated[float | None, Field(default=None, description="Final training loss")] diff --git a/src/nemotron/kit/artifacts/pretrain_blends.py b/src/nemotron/kit/artifacts/pretrain_blends.py new file mode 100644 index 0000000..23a06a6 --- /dev/null +++ b/src/nemotron/kit/artifacts/pretrain_blends.py @@ -0,0 +1,98 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""PretrainBlendsArtifact - pretrain data blends with bin/idx files.""" + +from __future__ import annotations + +from pathlib import Path +from typing import Annotated + +from pydantic import Field + +from nemotron.kit.artifacts.base import Artifact +from nemotron.kit.trackers import InputDatasetInfo + + +class PretrainBlendsArtifact(Artifact): + """Pretrain data blends artifact (output of pretrain data_prep). + + The path points to the output directory containing bin/idx files. + The blend_path points to the blend.json file within that directory. + + Source URIs are tracked for W&B lineage: + - source_datasets: Input datasets with metadata (or URIs for backwards compat) + - tokenizer_uri: URI of the tokenizer model (hf://models/...) + """ + + total_tokens: Annotated[int, Field(ge=0, description="Total tokens processed")] + total_sequences: Annotated[int, Field(ge=0, description="Total documents processed")] + elapsed_sec: Annotated[ + float, Field(default=0.0, ge=0, description="Processing time in seconds") + ] + + # Sharding configuration + num_shards: Annotated[int, Field(ge=1, description="Number of output shards")] + + # Path to blend.json for Megatron-Bridge per_split_data_args_path + blend_path: Annotated[str | None, Field(default=None, description="Path to blend.json file")] + + # Per-split token counts (optional, populated in per-split mode) + train_tokens: Annotated[ + int | None, Field(default=None, ge=0, description="Tokens in train split") + ] + valid_tokens: Annotated[ + int | None, Field(default=None, ge=0, description="Tokens in valid split") + ] + test_tokens: Annotated[ + int | None, Field(default=None, ge=0, description="Tokens in test split") + ] + + # Source datasets for lineage tracking + source_datasets: Annotated[ + list[InputDatasetInfo | str], + Field(default_factory=list, description="Input datasets with metadata"), + ] + tokenizer_uri: Annotated[str | None, Field(default=None, description="URI of tokenizer model")] + + def get_wandb_files(self) -> list[tuple[str, str]]: + """Return blend.json and metadata.json for upload.""" + files = [] + # Add blend.json if it exists + if self.blend_path and Path(self.blend_path).exists(): + files.append((self.blend_path, "blend.json")) + elif (self.path / "blend.json").exists(): + files.append((str(self.path / "blend.json"), "blend.json")) + # Add metadata.json + metadata_path = self.path / "metadata.json" + if metadata_path.exists(): + files.append((str(metadata_path), "metadata.json")) + return files + + def get_wandb_references(self) -> list[tuple[str, str]]: + """Return reference to data directory on shared storage.""" + # Reference to directory containing bin/idx files + return [(f"file://{self.path.resolve()}", "output")] + + def get_input_uris(self) -> list[str]: + """Return URIs of input datasets and tokenizer for lineage.""" + uris = [] + for ds in self.source_datasets: + if isinstance(ds, InputDatasetInfo): + uris.append(ds.uri) + else: + uris.append(ds) + if self.tokenizer_uri: + uris.append(self.tokenizer_uri) + return uris diff --git a/src/nemotron/kit/artifacts/pretrain_data.py b/src/nemotron/kit/artifacts/pretrain_data.py new file mode 100644 index 0000000..a9442b8 --- /dev/null +++ b/src/nemotron/kit/artifacts/pretrain_data.py @@ -0,0 +1,76 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""PretrainDataArtifact - tokenized pretrain data with bin/idx files.""" + +from __future__ import annotations + +from typing import Annotated + +from pydantic import Field + +from nemotron.kit.artifacts.base import Artifact +from nemotron.kit.trackers import InputDatasetInfo + + +class PretrainDataArtifact(Artifact): + """Pretrain data artifact (output of pretrain data_prep). + + Contains tokenized bin/idx files for pretraining. + The path points to the output directory containing sharded data files. + + Source URIs are tracked for W&B lineage: + - source_datasets: Input datasets with metadata (or URIs for backwards compat) + - tokenizer_uri: URI of the tokenizer model (hf://models/...) + """ + + total_tokens: Annotated[int, Field(ge=0, description="Total tokens processed")] + total_sequences: Annotated[int, Field(ge=0, description="Total documents processed")] + elapsed_sec: Annotated[ + float, Field(default=0.0, ge=0, description="Processing time in seconds") + ] + + # Sharding configuration + num_shards: Annotated[int, Field(ge=1, description="Number of output shards")] + + # Source datasets for lineage tracking + source_datasets: Annotated[ + list[InputDatasetInfo | str], + Field(default_factory=list, description="Input datasets with metadata"), + ] + tokenizer_uri: Annotated[str | None, Field(default=None, description="URI of tokenizer model")] + + def get_wandb_files(self) -> list[tuple[str, str]]: + """Return metadata.json for upload.""" + files = [] + metadata_path = self.path / "metadata.json" + if metadata_path.exists(): + files.append((str(metadata_path), "metadata.json")) + return files + + def get_wandb_references(self) -> list[tuple[str, str]]: + """Return reference to data directory on shared storage.""" + return [(f"file://{self.path.resolve()}", "output")] + + def get_input_uris(self) -> list[str]: + """Return URIs of input datasets and tokenizer for lineage.""" + uris = [] + for ds in self.source_datasets: + if isinstance(ds, InputDatasetInfo): + uris.append(ds.uri) + else: + uris.append(ds) + if self.tokenizer_uri: + uris.append(self.tokenizer_uri) + return uris diff --git a/src/nemotron/kit/artifacts/sft_data.py b/src/nemotron/kit/artifacts/sft_data.py new file mode 100644 index 0000000..50997ee --- /dev/null +++ b/src/nemotron/kit/artifacts/sft_data.py @@ -0,0 +1,104 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""SFTDataArtifact - packed SFT data for Megatron-Bridge.""" + +from __future__ import annotations + +from typing import Annotated + +from pydantic import Field + +from nemotron.kit.artifacts.base import Artifact +from nemotron.kit.trackers import InputDatasetInfo + + +class SFTDataArtifact(Artifact): + """Packed SFT data artifact (output of SFT data_prep). + + Contains packed .npy files with tokenized and packed chat sequences. + The path points to the output directory containing training_{pack_size}.npy, etc. + + Output files (Megatron-Bridge compatible): + - training_{pack_size}.npy: Training data + - validation_{pack_size}.npy: Validation data + - test_{pack_size}.npy: Test data + - {pack_size}_metadata.jsonl: Megatron-Bridge compatible packing metadata + - metadata.json: Nemotron artifact metadata + + Source URIs are tracked for W&B lineage: + - source_datasets: Input datasets with metadata (or URIs for backwards compat) + - tokenizer_uri: URI of the tokenizer model (hf://models/...) + """ + + total_tokens: Annotated[int, Field(ge=0, description="Total tokens processed")] + total_sequences: Annotated[int, Field(ge=0, description="Total sequences after packing")] + elapsed_sec: Annotated[ + float, Field(default=0.0, ge=0, description="Processing time in seconds") + ] + + # Packing configuration + pack_size: Annotated[int, Field(ge=1, description="Maximum tokens per packed sequence")] + + # Explicit paths to split files (Megatron-Bridge compatible naming) + training_path: Annotated[ + str | None, Field(default=None, description="Path to training_{pack_size}.npy") + ] + validation_path: Annotated[ + str | None, Field(default=None, description="Path to validation_{pack_size}.npy") + ] + test_path: Annotated[ + str | None, Field(default=None, description="Path to test_{pack_size}.npy") + ] + metadata_path: Annotated[ + str | None, Field(default=None, description="Path to {pack_size}_metadata.jsonl") + ] + + # Source datasets for lineage tracking + source_datasets: Annotated[ + list[InputDatasetInfo | str], + Field(default_factory=list, description="Input datasets with metadata"), + ] + tokenizer_uri: Annotated[str | None, Field(default=None, description="URI of tokenizer model")] + + def get_wandb_files(self) -> list[tuple[str, str]]: + """Return metadata.json for upload (small file with artifact info).""" + files = [] + metadata_path = self.path / "metadata.json" + if metadata_path.exists(): + files.append((str(metadata_path), "metadata.json")) + return files + + def get_wandb_references(self) -> list[tuple[str, str]]: + """Return references to data files on shared storage. + + Data files (.npy) stay on shared storage and are not uploaded. + Only metadata.json is uploaded for resolver field access. + """ + refs = [] + # Add reference to the output directory containing .npy files + refs.append((f"file://{self.path.resolve()}", "output")) + return refs + + def get_input_uris(self) -> list[str]: + """Return URIs of input datasets and tokenizer for lineage.""" + uris = [] + for ds in self.source_datasets: + if isinstance(ds, InputDatasetInfo): + uris.append(ds.uri) + else: + uris.append(ds) + if self.tokenizer_uri: + uris.append(self.tokenizer_uri) + return uris diff --git a/src/nemotron/kit/artifacts/split_jsonl.py b/src/nemotron/kit/artifacts/split_jsonl.py new file mode 100644 index 0000000..05eb4ae --- /dev/null +++ b/src/nemotron/kit/artifacts/split_jsonl.py @@ -0,0 +1,99 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""SplitJsonlDataArtifact - non-tokenized JSONL data for RL.""" + +from __future__ import annotations + +from pathlib import Path +from typing import Annotated + +from pydantic import Field + +from nemotron.kit.artifacts.base import Artifact +from nemotron.kit.trackers import InputDatasetInfo + + +class SplitJsonlDataArtifact(Artifact): + """Split JSONL data artifact (output of non-tokenized data_prep). + + Used for RL and other stages that output JSONL files without tokenization. + The path points directly to the manifest.json file. + + Unlike DataBlendsArtifact, this does not track token counts since the + data is not tokenized. + + Output files: + - train/train.jsonl: Training data + - val/val.jsonl: Validation data + - test/test.jsonl: Test data + - manifest.json: Manifest with paths to split files + - metadata.json: Nemotron artifact metadata + + Source URIs are tracked for W&B lineage: + - source_datasets: Input datasets with metadata (or URIs for backwards compat) + """ + + total_sequences: Annotated[int, Field(ge=0, description="Total documents processed")] + elapsed_sec: Annotated[ + float, Field(default=0.0, ge=0, description="Processing time in seconds") + ] + + # Explicit paths to split files + train: Annotated[ + str | None, Field(default=None, description="Path to train JSONL directory") + ] + val: Annotated[ + str | None, Field(default=None, description="Path to validation JSONL directory") + ] + test: Annotated[ + str | None, Field(default=None, description="Path to test JSONL directory") + ] + + # Source datasets for lineage tracking + source_datasets: Annotated[ + list[InputDatasetInfo | str], + Field(default_factory=list, description="Input datasets with metadata"), + ] + + def _get_output_dir(self) -> Path: + """SplitJsonlDataArtifact.path is manifest.json (a file), so use parent.""" + return self.path.parent + + def get_wandb_files(self) -> list[tuple[str, str]]: + """Return manifest.json and metadata.json for upload.""" + files = [] + # SplitJsonlDataArtifact.path is the manifest.json file itself + if self.path.exists(): + files.append((str(self.path), "manifest.json")) + # metadata.json is in same directory + metadata_path = self.path.parent / "metadata.json" + if metadata_path.exists(): + files.append((str(metadata_path), "metadata.json")) + return files + + def get_wandb_references(self) -> list[tuple[str, str]]: + """Return reference to data directory on shared storage.""" + # Reference to parent directory containing JSONL files + return [(f"file://{self.path.parent.resolve()}", "output")] + + def get_input_uris(self) -> list[str]: + """Return URIs of input datasets for lineage.""" + uris = [] + for ds in self.source_datasets: + if isinstance(ds, InputDatasetInfo): + uris.append(ds.uri) + else: + uris.append(ds) + return uris diff --git a/src/nemotron/kit/cli/__init__.py b/src/nemotron/kit/cli/__init__.py new file mode 100644 index 0000000..e9b4815 --- /dev/null +++ b/src/nemotron/kit/cli/__init__.py @@ -0,0 +1,27 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""CLI utilities for nemotron. + +This module provides shared CLI infrastructure built on Typer + OmegaConf. +""" + +from nemotron.kit.cli.globals import GlobalContext, global_callback +from nemotron.kit.cli.recipe import recipe + +__all__ = [ + "GlobalContext", + "global_callback", + "recipe", +] diff --git a/src/nemotron/kit/cli/config.py b/src/nemotron/kit/cli/config.py new file mode 100644 index 0000000..36003eb --- /dev/null +++ b/src/nemotron/kit/cli/config.py @@ -0,0 +1,413 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Configuration loading, merging, and saving. + +Handles the full config pipeline: +1. Load config YAML (from --config or default) +2. Apply dotlist overrides +3. Merge env profile into run.env +4. Generate job.yaml (full provenance) and train.yaml (script-only) +""" + +from __future__ import annotations + +from datetime import datetime +from pathlib import Path + +from omegaconf import DictConfig, OmegaConf + +from nemotron.kit.cli.env import get_wandb_config, load_env_profile +from nemotron.kit.cli.globals import GlobalContext +from nemotron.kit.cli.utils import rewrite_paths_for_remote, resolve_run_interpolations +from nemotron.kit.resolvers import _is_artifact_reference + + +def find_config_file(config_name: str, config_dir: Path) -> Path: + """Find config file by name or path. + + Args: + config_name: Either a name (looks in config_dir) or a path + config_dir: Directory containing recipe configs + + Returns: + Path to the config file + + Raises: + FileNotFoundError: If config not found + """ + # If it looks like a path, use it directly + if "/" in config_name or config_name.endswith(".yaml") or config_name.endswith(".yml"): + path = Path(config_name) + if path.exists(): + return path + raise FileNotFoundError(f"Config file not found: {config_name}") + + # Otherwise, look in config directory + for ext in [".yaml", ".yml"]: + path = config_dir / f"{config_name}{ext}" + if path.exists(): + return path + + raise FileNotFoundError( + f"Config '{config_name}' not found in {config_dir}. " + f"Tried: {config_name}.yaml, {config_name}.yml" + ) + + +def load_config(config_path: Path) -> DictConfig: + """Load a YAML config file. + + Args: + config_path: Path to the YAML config file + + Returns: + OmegaConf DictConfig with the loaded configuration + """ + return OmegaConf.load(config_path) + + +def apply_dotlist_overrides(config: DictConfig, dotlist: list[str]) -> DictConfig: + """Apply Hydra-style dotlist overrides to config. + + Args: + config: Base configuration + dotlist: List of overrides like ["train.train_iters=5000", "run.data=latest"] + + Returns: + Config with overrides applied + """ + if not dotlist: + return config + + cli_config = OmegaConf.from_dotlist(dotlist) + return OmegaConf.merge(config, cli_config) + + +def build_job_config( + train_config: DictConfig, + ctx: GlobalContext, + recipe_name: str, + script_path: str, + argv: list[str], +) -> DictConfig: + """Build the full job config with provenance information. + + The config structure is flat - training config at root level, + with `run` section containing execution settings and CLI provenance. + + Args: + train_config: The training configuration (what train.py expects) + ctx: Global CLI context with options + recipe_name: Name of the recipe (e.g., "nano3/pretrain") + script_path: Path to the training script + argv: Original command line arguments + + Returns: + Full job config with run section for execution/provenance + """ + # Start with the training config at root level + job_config = OmegaConf.create(OmegaConf.to_container(train_config, resolve=False)) + + # Build run section with execution settings and CLI provenance + run_updates = { + "mode": ctx.mode, + "profile": ctx.profile, + "env": {}, + "cli": { + "argv": argv, + "dotlist": ctx.dotlist, + "passthrough": ctx.passthrough, + "config": ctx.config, + }, + "recipe": { + "name": recipe_name, + "script": script_path, + }, + } + + # Get existing run.env from config YAML (if any) + existing_env = {} + if "run" in job_config and "env" in job_config.run: + existing_env = OmegaConf.to_container(job_config.run.env, resolve=False) + + # Merge env profile if we have one (overlays config YAML's run.env) + if ctx.profile: + env_config = load_env_profile(ctx.profile) + profile_env = OmegaConf.to_container(env_config, resolve=True) + # Config YAML is base, env.toml profile overlays it + run_updates["env"] = {**existing_env, **profile_env} + elif existing_env: + # No profile, but config has run.env - preserve it + run_updates["env"] = existing_env + + # Add wandb config from env.toml (if present) + wandb_config = get_wandb_config() + if wandb_config: + run_updates["wandb"] = OmegaConf.to_container(wandb_config, resolve=True) + + # Merge run updates into existing run section (or create it) + if "run" in job_config: + existing_run = OmegaConf.to_container(job_config.run, resolve=False) + merged_run = {**existing_run, **run_updates} + job_config.run = OmegaConf.create(merged_run) + else: + job_config.run = OmegaConf.create(run_updates) + + return job_config + + +def extract_train_config(job_config: DictConfig, *, for_remote: bool = False) -> DictConfig: + """Extract the script-only config from job config. + + Keeps only the fields needed for train.py: + - All top-level config sections (recipe, train, model, logger, etc.) + - run.data, run.model (artifact references for ${art:X,path} resolution) + + Resolves ${run.wandb.*} and ${run.recipe.*} interpolations directly + so the config is self-contained and doesn't need the full run section. + + When for_remote=True, also rewrites paths for remote execution: + - ${oc.env:PWD}/... → /nemo_run/code/... + - ${oc.env:NEMO_RUN_DIR,...}/... → /nemo_run/... + + Args: + job_config: Full job configuration + for_remote: If True, rewrite paths for remote execution + + Returns: + Clean config suitable for train.py + """ + if for_remote: + # Get config without resolving interpolations + config_dict = OmegaConf.to_container(job_config, resolve=False) + run_section = config_dict.pop("run", {}) + + # Rewrite paths for remote execution + repo_root = Path.cwd() + config_dict = rewrite_paths_for_remote(config_dict, repo_root) + + # Resolve ${run.wandb.*} and ${run.recipe.*} interpolations + config_dict = resolve_run_interpolations(config_dict, run_section) + + # Build a minimal run section with just artifact references + run_for_train = {} + for key, value in run_section.items(): + if _is_artifact_reference(value): + run_for_train[key] = value + + if run_for_train: + config_dict["run"] = run_for_train + + return OmegaConf.create(config_dict) + else: + # Get config as dict without resolving (preserves ${art:...} interpolations) + config_dict = OmegaConf.to_container(job_config, resolve=False) + + # Extract run section - we'll use it to resolve ${run.*} interpolations + run_section = config_dict.pop("run", {}) + + # Build a minimal run section with just artifact references + run_for_train = {} + for key, value in run_section.items(): + if _is_artifact_reference(value): + run_for_train[key] = value + + # Resolve ${run.wandb.*} and ${run.recipe.*} interpolations + resolved_config = resolve_run_interpolations(config_dict, run_section) + + # Add minimal run section with needed fields (artifacts only) + if run_for_train: + resolved_config["run"] = run_for_train + + return OmegaConf.create(resolved_config) + + +def generate_job_dir(recipe_name: str, base_dir: Path | None = None) -> Path: + """Generate a unique job directory path. + + Format: .nemotron/jobs/-/ + + Args: + recipe_name: Name of the recipe (e.g., "nano3/pretrain") + base_dir: Base directory. Defaults to cwd. + + Returns: + Path to the job directory + """ + if base_dir is None: + base_dir = Path.cwd() + + timestamp = datetime.now().strftime("%Y%m%d-%H%M%S") + # Replace / with - for directory name + safe_name = recipe_name.replace("/", "-") + job_dir = base_dir / ".nemotron" / "jobs" / f"{timestamp}-{safe_name}" + + return job_dir + + +def save_configs( + job_config: DictConfig, + train_config: DictConfig, + job_dir: Path, +) -> tuple[Path, Path]: + """Save job and train configs to disk. + + Args: + job_config: Full job configuration + train_config: Script-only configuration + job_dir: Directory to save configs + + Returns: + Tuple of (job_yaml_path, train_yaml_path) + """ + job_dir.mkdir(parents=True, exist_ok=True) + + job_path = job_dir / "job.yaml" + train_path = job_dir / "train.yaml" + + OmegaConf.save(job_config, job_path) + OmegaConf.save(train_config, train_path) + + return job_path, train_path + + +class ConfigBuilder: + """Helper class to build and manage job configuration. + + Encapsulates the full config pipeline from loading to saving. + """ + + def __init__( + self, + recipe_name: str, + script_path: str, + config_dir: Path, + default_config: str, + ctx: GlobalContext, + argv: list[str], + ): + """Initialize the config builder. + + Args: + recipe_name: Name of the recipe (e.g., "nano3/pretrain") + script_path: Path to the training script + config_dir: Directory containing recipe configs + ctx: Global CLI context + argv: Original command line arguments + """ + self.recipe_name = recipe_name + self.script_path = script_path + self.config_dir = Path(config_dir) + self.default_config = default_config + self.ctx = ctx + self.argv = argv + + self._train_config: DictConfig | None = None + self._job_config: DictConfig | None = None + self._job_dir: Path | None = None + + def load_and_merge(self) -> DictConfig: + """Load config and apply all merges. + + Returns: + The merged train_config + """ + # Load config (from --config or default) + if self.ctx.config: + config_path = find_config_file(self.ctx.config, self.config_dir) + else: + config_path = find_config_file(self.default_config, self.config_dir) + + self._train_config = load_config(config_path) + + # Apply dotlist overrides + self._train_config = apply_dotlist_overrides(self._train_config, self.ctx.dotlist) + + return self._train_config + + def build_job_config(self) -> DictConfig: + """Build the full job config with provenance. + + Must call load_and_merge() first. + + Returns: + Full job configuration + """ + if self._train_config is None: + self.load_and_merge() + + self._job_config = build_job_config( + train_config=self._train_config, + ctx=self.ctx, + recipe_name=self.recipe_name, + script_path=self.script_path, + argv=self.argv, + ) + + return self._job_config + + def save( + self, *, rewrite_paths: bool | None = None, packager: str = "pattern" + ) -> tuple[Path, Path]: + """Save configs to disk. + + Must call build_job_config() first. + + Args: + rewrite_paths: If True, rewrite paths for /nemo_run/code. If False, keep + original paths/interpolations. If None (default), auto-detect based + on execution mode AND packager type. + packager: Packager type. When "code", paths are NOT rewritten since + the code is rsynced and runs from the rsynced location where + ${oc.env:PWD} resolves correctly at runtime. + + Returns: + Tuple of (job_yaml_path, train_yaml_path) + """ + if self._job_config is None: + self.build_job_config() + + self._job_dir = generate_job_dir(self.recipe_name) + + # Determine whether to rewrite paths for remote execution + if rewrite_paths is None: + # Default: rewrite for --run/--batch mode, but NOT for "code" packager + # Code packager rsyncs the repo and runs from there, so paths resolve at runtime + for_remote = self.ctx.mode in ("run", "batch") and packager != "code" + else: + for_remote = rewrite_paths + + train_config = extract_train_config(self._job_config, for_remote=for_remote) + + return save_configs(self._job_config, train_config, self._job_dir) + + @property + def job_config(self) -> DictConfig: + """Get the job config (builds if needed).""" + if self._job_config is None: + self.build_job_config() + return self._job_config + + @property + def train_config(self) -> DictConfig: + """Get the train config.""" + if self._train_config is None: + self.load_and_merge() + return self._train_config + + @property + def job_dir(self) -> Path | None: + """Get the job directory (after save).""" + return self._job_dir diff --git a/src/nemotron/kit/cli/display.py b/src/nemotron/kit/cli/display.py new file mode 100644 index 0000000..db6e5e6 --- /dev/null +++ b/src/nemotron/kit/cli/display.py @@ -0,0 +1,217 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Rich display utilities for CLI output. + +Includes: +- Dry-run configuration display with YAML syntax highlighting +- Job submission summary with tree view +""" + +from __future__ import annotations + +from pathlib import Path + +from omegaconf import DictConfig, OmegaConf +from rich.console import Console +from rich.panel import Panel +from rich.syntax import Syntax +from rich.tree import Tree + +from nemotron.kit.cli.env import get_cli_config +from nemotron.kit.cli.utils import rewrite_paths_for_remote, resolve_run_interpolations + +# Global console instance +CONSOLE = Console() + +# Default theme for syntax highlighting +DEFAULT_THEME = "monokai" + + +def _get_theme() -> str: + """Get the syntax highlighting theme from env.toml or use default.""" + cli_config = get_cli_config() + if cli_config and "theme" in cli_config: + return str(cli_config.theme) + return DEFAULT_THEME + + +def display_job_config(job_config: DictConfig, *, for_remote: bool = False) -> None: + """Display the full job configuration as syntax-highlighted YAML. + + Config is flat - training config at root, run section has execution/provenance. + + Args: + job_config: The compiled job configuration + for_remote: If True, resolve all interpolations and rewrite paths for remote execution + """ + CONSOLE.print() + CONSOLE.print("[bold cyan]Compiled Configuration[/bold cyan]") + CONSOLE.print() + + # Display run section (contains recipe, env, cli) + _display_run_section(job_config) + + # Display training config (everything except run section) + _display_config_section(job_config, for_remote=for_remote) + + CONSOLE.print() + + +def _display_run_section(job_config: DictConfig) -> None: + """Display the run section as syntax-highlighted YAML.""" + run = job_config.get("run", {}) + if not run: + return + + # Convert to YAML string + yaml_str = OmegaConf.to_yaml(run, resolve=False) + + syntax = Syntax(yaml_str.rstrip(), "yaml", theme=_get_theme(), line_numbers=False) + CONSOLE.print( + Panel( + syntax, + title="[bold green]run[/bold green]", + border_style="green", + expand=False, + ) + ) + CONSOLE.print() + + +def _display_config_section(job_config: DictConfig, *, for_remote: bool = False) -> None: + """Display the training config as syntax-highlighted YAML.""" + # Create a copy without resolving interpolations + config_dict = OmegaConf.to_container(job_config, resolve=False) + run_section = config_dict.pop("run", {}) + + if not config_dict: + return + + if for_remote: + # Rewrite paths for remote execution display + import os + + repo_root_str = os.getcwd() + config_dict = rewrite_paths_for_remote(config_dict, repo_root_str) + else: + # Resolve ${run.*} interpolations for display + config_dict = resolve_run_interpolations(config_dict, run_section) + + # Convert back to OmegaConf for YAML serialization + config_without_run = OmegaConf.create(config_dict) + yaml_str = OmegaConf.to_yaml(config_without_run, resolve=False) + + syntax = Syntax(yaml_str.rstrip(), "yaml", theme=_get_theme(), line_numbers=False) + CONSOLE.print( + Panel( + syntax, + title="[bold green]config[/bold green]", + border_style="green", + expand=False, + ) + ) + CONSOLE.print() + + +def display_job_submission( + job_path: Path, + train_path: Path, + env_vars: dict[str, str], + mode: str, +) -> None: + """Display job submission summary as a Rich tree panel. + + Args: + job_path: Path to job.yaml + train_path: Path to train.yaml + env_vars: Environment variables being set + mode: Execution mode (run/batch/local) + """ + # Build tree + tree = Tree("[bold]Job Submission[/bold]") + + # Configs section + configs = tree.add("[cyan]configs[/cyan]") + configs.add(f"[dim]job:[/dim] {job_path}") + configs.add(f"[dim]train:[/dim] {train_path}") + + # Environment variables section (if any interesting ones) + interesting_vars = {k: v for k, v in env_vars.items() if k not in ("NEMO_RUN_DIR",)} + if interesting_vars: + env_section = tree.add("[cyan]env[/cyan]") + for key in sorted(interesting_vars.keys()): + # Mask sensitive values + if "KEY" in key or "TOKEN" in key or "SECRET" in key: + env_section.add(f"[dim]{key}:[/dim] [green]✓ detected[/green]") + else: + env_section.add(f"[dim]{key}:[/dim] {interesting_vars[key]}") + + # Mode indicator + mode_label = { + "run": "[yellow]attached[/yellow]", + "batch": "[blue]detached[/blue]", + "local": "[green]local[/green]", + }.get(mode, mode) + tree.add(f"[cyan]mode:[/cyan] {mode_label}") + + CONSOLE.print() + CONSOLE.print(Panel(tree, border_style="green", expand=False)) + CONSOLE.print() + + +def display_ray_job_submission( + script_path: str, + script_args: list[str], + env_vars: dict[str, str], + mode: str, +) -> None: + """Display Ray job submission summary as a Rich tree panel. + + Args: + script_path: Path to the script being executed + script_args: Arguments passed to the script + env_vars: Environment variables being set + mode: Execution mode (attached/detached) + """ + # Build tree + tree = Tree("[bold]Job Submission[/bold]") + + # Script section + script_section = tree.add("[cyan]script[/cyan]") + script_section.add(f"[dim]path:[/dim] {script_path}") + if script_args: + script_section.add(f"[dim]args:[/dim] {' '.join(script_args)}") + + # Environment variables section (if any interesting ones) + interesting_vars = {k: v for k, v in env_vars.items() if k not in ("NEMO_RUN_DIR",)} + if interesting_vars: + env_section = tree.add("[cyan]env[/cyan]") + for key in sorted(interesting_vars.keys()): + # Mask sensitive values + if "KEY" in key or "TOKEN" in key or "SECRET" in key: + env_section.add(f"[dim]{key}:[/dim] [green]✓ detected[/green]") + else: + env_section.add(f"[dim]{key}:[/dim] {interesting_vars[key]}") + + # Mode indicator + mode_label = { + "attached": "[yellow]attached[/yellow]", + "detached": "[blue]detached[/blue]", + }.get(mode, mode) + tree.add(f"[cyan]mode:[/cyan] {mode_label}") + + CONSOLE.print() + CONSOLE.print(Panel(tree, border_style="green", expand=False)) + CONSOLE.print() diff --git a/src/nemotron/kit/cli/env.py b/src/nemotron/kit/cli/env.py new file mode 100644 index 0000000..a764bba --- /dev/null +++ b/src/nemotron/kit/cli/env.py @@ -0,0 +1,167 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Environment profile loading from env.toml. + +Handles loading executor configurations and profile inheritance. +""" + +from __future__ import annotations + +import sys +from pathlib import Path +from typing import Any + +from omegaconf import DictConfig, OmegaConf + +if sys.version_info >= (3, 11): + import tomllib +else: + import tomli as tomllib + + +def find_env_file(start_dir: Path | None = None) -> Path | None: + """Find env.toml walking up from start_dir. + + Args: + start_dir: Directory to start searching from. Defaults to cwd. + + Returns: + Path to env.toml if found, None otherwise. + """ + if start_dir is None: + start_dir = Path.cwd() + + for path in [start_dir, *start_dir.parents]: + env_file = path / "env.toml" + if env_file.exists(): + return env_file + + # Stop at project root (has pyproject.toml) + if (path / "pyproject.toml").exists(): + break + + return None + + +def load_env_file(config_path: Path | None = None) -> dict[str, Any]: + """Load env.toml file contents. + + Args: + config_path: Path to env.toml. If None, searches for it. + + Returns: + Dictionary with all profiles from the file. + """ + if config_path is None: + config_path = find_env_file() + + if config_path is None: + return {} + + with open(config_path, "rb") as f: + return tomllib.load(f) + + +def load_env_profile(name: str, config_path: Path | None = None) -> DictConfig: + """Load a named profile from env.toml with inheritance support. + + Profiles can extend other profiles using `extends = "parent"`. + + Args: + name: Profile name (e.g., "dlw", "local") + config_path: Optional path to env.toml + + Returns: + OmegaConf DictConfig with the resolved profile + + Raises: + ValueError: If profile not found + """ + all_profiles = load_env_file(config_path) + + if name not in all_profiles: + available = [k for k in all_profiles.keys() if k != "wandb"] + raise ValueError(f"Profile '{name}' not found in env.toml. Available: {available}") + + return _resolve_profile(name, all_profiles, set()) + + +def _resolve_profile( + name: str, + all_profiles: dict[str, Any], + visited: set[str], +) -> DictConfig: + """Recursively resolve profile with inheritance. + + Args: + name: Profile name to resolve + all_profiles: All profiles from env.toml + visited: Set of already visited profiles (for cycle detection) + + Returns: + Resolved profile as DictConfig + """ + if name in visited: + raise ValueError(f"Circular profile inheritance detected: {name}") + + visited.add(name) + profile = all_profiles[name].copy() + + # Handle 'extends' inheritance + if "extends" in profile: + parent_name = profile.pop("extends") + if parent_name not in all_profiles: + raise ValueError(f"Profile '{name}' extends unknown profile '{parent_name}'") + parent = _resolve_profile(parent_name, all_profiles, visited) + # Merge: child overrides parent + profile = OmegaConf.merge(parent, OmegaConf.create(profile)) + else: + profile = OmegaConf.create(profile) + + return profile + + +def get_wandb_config(config_path: Path | None = None) -> DictConfig | None: + """Get wandb configuration from env.toml if present. + + Args: + config_path: Optional path to env.toml + + Returns: + WandB config as DictConfig, or None if not present + """ + all_profiles = load_env_file(config_path) + + if "wandb" in all_profiles: + return OmegaConf.create(all_profiles["wandb"]) + + return None + + +def get_cli_config(config_path: Path | None = None) -> DictConfig | None: + """Get CLI display configuration from env.toml if present. + + Args: + config_path: Optional path to env.toml + + Returns: + CLI config as DictConfig, or None if not present + """ + all_profiles = load_env_file(config_path) + + if "cli" in all_profiles: + return OmegaConf.create(all_profiles["cli"]) + + return None diff --git a/src/nemotron/kit/cli/globals.py b/src/nemotron/kit/cli/globals.py new file mode 100644 index 0000000..45ad1cc --- /dev/null +++ b/src/nemotron/kit/cli/globals.py @@ -0,0 +1,194 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Global CLI options and context management. + +Provides the GlobalContext dataclass and typer callback for handling +global options like --config, --run, --batch, --dry-run. +""" + +from __future__ import annotations + +from dataclasses import dataclass, field + +import typer + + +@dataclass +class GlobalContext: + """Global CLI options shared across all commands. + + Attributes: + config: Config name or path (-c/--config) + run: Env profile name for attached execution (-r/--run) + batch: Env profile name for detached execution (-b/--batch) + dry_run: If True, print config and exit (-d/--dry-run) + stage: If True, stage files to remote without execution (--stage) + force_squash: If True, re-squash container even if exists (--force-squash) + dotlist: Hydra-style dotlist overrides (key.sub=value) + passthrough: Other args to pass to script (--mock, etc.) + """ + + config: str | None = None + run: str | None = None + batch: str | None = None + dry_run: bool = False + stage: bool = False + force_squash: bool = False + dotlist: list[str] = field(default_factory=list) + passthrough: list[str] = field(default_factory=list) + + @property + def mode(self) -> str: + """Get execution mode: 'run', 'batch', or 'local'.""" + if self.run: + return "run" + elif self.batch: + return "batch" + return "local" + + @property + def profile(self) -> str | None: + """Get the env profile name (from --run or --batch).""" + return self.run or self.batch + + +def split_unknown_args( + args: list[str], + global_ctx: GlobalContext | None = None, +) -> tuple[list[str], list[str], GlobalContext]: + """Split unknown args into dotlist overrides and passthrough args. + + Also extracts any global options that appear in unknown args + (for when options come after subcommand). + + Dotlist overrides are tokens like `key.sub=value` (no leading `-`). + Passthrough args are everything else (e.g., `--mock`, `--some-flag`). + + Args: + args: List of unknown arguments from ctx.args + global_ctx: Global context to update with extracted options + + Returns: + Tuple of (dotlist_overrides, passthrough_args, updated_global_ctx) + """ + if global_ctx is None: + global_ctx = GlobalContext() + + dotlist = [] + passthrough = [] + + # Known global options to extract from args + global_opts = { + "-c": "config", + "--config": "config", + "-r": "run", + "--run": "run", + "-b": "batch", + "--batch": "batch", + "-d": "dry_run", + "--dry-run": "dry_run", + "--stage": "stage", + "--force-squash": "force_squash", + } + + i = 0 + while i < len(args): + arg = args[i] + + # Check if it's a global option + if arg in global_opts: + attr = global_opts[arg] + if attr in ("dry_run", "stage", "force_squash"): + # Boolean flag + setattr(global_ctx, attr, True) + i += 1 + else: + # Option with value + if i + 1 < len(args): + setattr(global_ctx, attr, args[i + 1]) + i += 2 + else: + i += 1 + elif "=" in arg and not arg.startswith("-"): + # Dotlist override + dotlist.append(arg) + i += 1 + else: + # Passthrough arg + passthrough.append(arg) + i += 1 + + return dotlist, passthrough, global_ctx + + +def global_callback( + ctx: typer.Context, + config: str | None = typer.Option( + None, + "-c", + "--config", + help="Config name (looks in recipe's config/ dir) or path", + ), + run: str | None = typer.Option( + None, + "-r", + "--run", + help="Execute attached via nemo-run with specified env profile", + ), + batch: str | None = typer.Option( + None, + "-b", + "--batch", + help="Execute detached via nemo-run with specified env profile", + ), + dry_run: bool = typer.Option( + False, + "-d", + "--dry-run", + help="Print compiled config as rich table (no execution)", + ), + stage: bool = typer.Option( + False, + "--stage", + help="Stage script + config to remote cluster for interactive debugging", + ), + force_squash: bool = typer.Option( + False, + "--force-squash", + help="Force re-squash container image even if it already exists", + ), +) -> None: + """Global callback that captures options available to all commands. + + This callback is invoked before any subcommand and stores the global + options in ctx.obj for access by leaf commands. + """ + # Validate mutual exclusivity (only if both are set at this point) + # Note: additional options may be extracted later by split_unknown_args + if run and batch: + typer.echo("Error: --run and --batch cannot both be set", err=True) + raise typer.Exit(1) + + # Store in context + ctx.ensure_object(GlobalContext) + ctx.obj.config = config + ctx.obj.run = run + ctx.obj.batch = batch + ctx.obj.dry_run = dry_run + ctx.obj.stage = stage + ctx.obj.force_squash = force_squash + + # Unknown args will be populated by the leaf command + # since they need allow_extra_args=True on the command itself diff --git a/src/nemotron/kit/cli/recipe.py b/src/nemotron/kit/cli/recipe.py new file mode 100644 index 0000000..48d2a7f --- /dev/null +++ b/src/nemotron/kit/cli/recipe.py @@ -0,0 +1,1139 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""@recipe decorator for defining CLI commands. + +The decorator attaches metadata and standardizes the execution flow +for recipe commands. +""" + +from __future__ import annotations + +import shutil +import subprocess +import sys +from collections.abc import Callable +from dataclasses import dataclass, field +from functools import wraps +from pathlib import Path +from typing import Any + +import typer +from rich.console import Console + +from nemotron.kit.cli.config import ConfigBuilder +from nemotron.kit.cli.display import display_job_config, display_job_submission +from nemotron.kit.cli.globals import GlobalContext, split_unknown_args + +console = Console() + + +@dataclass +class RecipeMetadata: + """Metadata attached to a recipe command function. + + Attributes: + name: Recipe identifier (e.g., "nano3/pretrain") + script_path: Path to training script relative to repo root + config_dir: Path to config directory relative to repo root + artifacts: Artifact slot definitions for resolution + torchrun: Whether to use torchrun launcher + ray: Whether this recipe requires Ray + packager: Packager type ("pattern", "code", "self_contained") + workdir: Container working directory for Ray jobs (e.g., "/opt/nemo-rl") + pre_ray_start_commands: Shell commands to run before Ray starts + run_command: Custom command template to run the script (e.g., "python {script} --config {config}") + """ + + name: str + script_path: str + config_dir: str + default_config: str = "default" + artifacts: dict[str, dict[str, Any]] = field(default_factory=dict) + torchrun: bool = True + ray: bool = False + packager: str = "pattern" + workdir: str | None = None + pre_ray_start_commands: list[str] | None = None + run_command: str | None = None + + +def recipe( + name: str, + script_path: str, + config_dir: str, + default_config: str = "default", + artifacts: dict[str, dict[str, Any]] | None = None, + *, + torchrun: bool = True, + ray: bool = False, + packager: str = "pattern", + workdir: str | None = None, + pre_ray_start_commands: list[str] | None = None, + run_command: str | None = None, +) -> Callable: + """Decorator marking a function as a recipe command. + + The decorated function becomes a typer command that: + 1. Loads and merges configuration + 2. Resolves env profile (if --run/--batch) + 3. Optionally resolves artifacts + 4. Saves job.yaml and train.yaml + 5. Executes the training script + + Args: + name: Recipe identifier (e.g., "nano3/pretrain") + script_path: Path to Python script for execution + (e.g., "src/nemotron/recipes/nano3/stage0_pretrain/train.py") + config_dir: Path to config directory + (e.g., "src/nemotron/recipes/nano3/stage0_pretrain/config") + artifacts: Optional artifact slot definitions: + {"data": {"default": "DataBlendsArtifact-pretrain", + "mappings": {"path": "recipe.per_split_data_args_path"}}} + default_config: Default config name (stem) or path used when -c/--config + is not provided (default: "default"). + torchrun: Whether to use torchrun launcher (default: True) + ray: Whether this recipe requires Ray for execution (default: False) + packager: Packager type ("pattern", "code", "self_contained") (default: "pattern") + workdir: Container working directory for Ray jobs (e.g., "/opt/nemo-rl"). + Can be overridden via YAML config at `run.env.workdir`. + pre_ray_start_commands: Shell commands to run before Ray starts. + Can be overridden via YAML config at `run.env.pre_ray_start_commands`. + run_command: Custom command template to run the script. Supports placeholders: + {script} - the script path (e.g., "main.py") + {config} - the config path (e.g., "config.yaml") + Example: "python {script} --config {config}" + Can be overridden via YAML config at `run.env.run_command`. + + Example: + @recipe( + name="nano3/pretrain", + script_path="src/nemotron/recipes/nano3/stage0_pretrain/train.py", + config_dir="src/nemotron/recipes/nano3/stage0_pretrain/config", + ) + def pretrain(ctx: typer.Context): + '''Run pretraining with Megatron-Bridge.''' + ... + + @recipe( + name="nano3/rl", + script_path="src/nemotron/recipes/nano3/stage2_rl/train.py", + config_dir="src/nemotron/recipes/nano3/stage2_rl/config", + torchrun=False, + ray=True, + packager="self_contained", + workdir="/opt/nemo-rl", + pre_ray_start_commands=[ + "find . -type d -name __pycache__ -delete 2>/dev/null || true", + ], + run_command="uv run python {script} --config {config}", + ) + def rl(ctx: typer.Context): + '''Run RL training with Ray.''' + ... + """ + if artifacts is None: + artifacts = {} + + def decorator(func: Callable) -> Callable: + @wraps(func) + def wrapper(ctx: typer.Context) -> None: + # Get global context + global_ctx: GlobalContext = ctx.obj + if global_ctx is None: + global_ctx = GlobalContext() + + # Split unknown args into dotlist and passthrough + # Also extract any global options that appear after the subcommand + dotlist, passthrough, global_ctx = split_unknown_args(ctx.args or [], global_ctx) + global_ctx.dotlist = dotlist + global_ctx.passthrough = passthrough + + # Validate options after split_unknown_args has extracted all global options + if global_ctx.run and global_ctx.batch: + typer.echo("Error: --run and --batch cannot both be set", err=True) + raise typer.Exit(1) + + if global_ctx.stage and not global_ctx.profile: + typer.echo( + "Error: --stage requires --run or --batch to specify target cluster", err=True + ) + raise typer.Exit(1) + + # Build configuration + builder = ConfigBuilder( + recipe_name=name, + script_path=script_path, + config_dir=config_dir, + default_config=default_config, + ctx=global_ctx, + argv=sys.argv, + ) + + # Load and merge config + builder.load_and_merge() + + # TODO: Resolve artifacts if run.data etc. specified + # This would apply mappings from artifact metadata to config + + # Build full job config + builder.build_job_config() + + # Display compiled configuration + # Show resolved paths for remote execution (--run/--batch), but not for "code" packager + for_remote = global_ctx.mode in ("run", "batch") and packager != "code" + display_job_config(builder.job_config, for_remote=for_remote) + + # Handle dry-run mode + if global_ctx.dry_run: + return + + # Save configs + job_path, train_path = builder.save(packager=packager) + + # Handle stage-only mode + if global_ctx.stage: + _execute_stage_only( + script_path=script_path, + train_path=train_path, + job_dir=builder.job_dir, + job_config=builder.job_config, + packager=packager, + torchrun=torchrun, + ) + return + + # Extract env config for building env vars + env_config = None + if hasattr(builder.job_config, "run") and hasattr(builder.job_config.run, "env"): + from omegaconf import OmegaConf + + env_config = OmegaConf.to_container(builder.job_config.run.env, resolve=True) + + # Build env vars for display (needs job_config for wandb settings) + env_vars = _build_env_vars(builder.job_config, env_config) + + # Display job submission summary + display_job_submission(job_path, train_path, env_vars, global_ctx.mode) + + # Execute based on mode + if global_ctx.mode == "local": + _execute_local(script_path, train_path, passthrough, torchrun=torchrun) + else: + _execute_nemo_run( + script_path=script_path, + train_path=train_path, + job_dir=builder.job_dir, + job_config=builder.job_config, + passthrough=passthrough, + attached=(global_ctx.mode == "run"), + env_vars=env_vars, + torchrun=torchrun, + ray=ray, + packager=packager, + workdir=workdir, + pre_ray_start_commands=pre_ray_start_commands, + run_command=run_command, + force_squash=global_ctx.force_squash, + ) + + # Attach metadata to function for introspection + wrapper._recipe_metadata = RecipeMetadata( + name=name, + script_path=script_path, + config_dir=config_dir, + default_config=default_config, + artifacts=artifacts, + torchrun=torchrun, + ray=ray, + packager=packager, + workdir=workdir, + pre_ray_start_commands=pre_ray_start_commands, + run_command=run_command, + ) + + return wrapper + + return decorator + + +def _execute_local( + script_path: str, + train_path: Path, + passthrough: list[str], + *, + torchrun: bool = True, +) -> None: + """Execute script locally via subprocess. + + Args: + script_path: Path to the training script + train_path: Path to the saved train.yaml + passthrough: Additional args to pass to script + torchrun: Whether to use torchrun launcher + """ + if torchrun: + cmd = [ + sys.executable, + "-m", + "torch.distributed.run", + "--nproc_per_node=1", + script_path, + "--config", + str(train_path), + *passthrough, + ] + else: + cmd = [ + sys.executable, + script_path, + "--config", + str(train_path), + *passthrough, + ] + + typer.echo(f"Executing: {' '.join(cmd)}") + + result = subprocess.run(cmd) + raise typer.Exit(result.returncode) + + +def _execute_nemo_run( + script_path: str, + train_path: Path, + job_dir: Path, + job_config: Any, + passthrough: list[str], + attached: bool, + env_vars: dict[str, str], + *, + torchrun: bool = True, + ray: bool = False, + packager: str = "pattern", + workdir: str | None = None, + pre_ray_start_commands: list[str] | None = None, + run_command: str | None = None, + force_squash: bool = False, +) -> None: + """Execute script via nemo-run. + + Args: + script_path: Path to the training script + train_path: Path to the saved train.yaml + job_dir: Path to the job directory + job_config: Full job configuration (contains run.env) + passthrough: Additional args to pass to script + attached: If True, wait for completion; if False, detach + env_vars: Pre-built environment variables + torchrun: Whether to use torchrun launcher + ray: Whether this recipe requires Ray + packager: Packager type ("pattern", "code", "self_contained") + workdir: Container working directory for Ray jobs (e.g., "/opt/nemo-rl") + pre_ray_start_commands: Shell commands to run before Ray starts + run_command: Custom command template (supports {script} and {config} placeholders) + force_squash: Whether to force re-squash container image + """ + import time + + try: + import nemo_run as run + except ImportError: + typer.echo("Error: nemo-run is required for --run/--batch execution", err=True) + typer.echo("Install with: pip install nemo-run", err=True) + raise typer.Exit(1) + + from omegaconf import OmegaConf + + # Extract env config + env_config = OmegaConf.to_container(job_config.run.env, resolve=True) + + # Build executor with flat file layout (main.py, config.yaml) + executor = _build_executor( + env_config, + job_config, + script_path, + train_path, + job_dir, + env_vars, + torchrun=torchrun, + ray=ray, + attached=attached, + packager=packager, + force_squash=force_squash, + ) + + # Script args use flat names on remote + script_args = ["--config", "config.yaml", *passthrough] + + # Get experiment name from recipe + recipe_name = job_config.run.recipe.name.replace("/", "-") + + if ray: + # Use RayJob for Ray-based recipes + import shutil + + from nemo_run.run.ray.job import RayJob + + # Generate unique job name to prevent directory collisions + job_name = f"{recipe_name}_{int(time.time())}" + ray_job = RayJob(name=job_name, executor=executor) + + # Copy train.yaml to repo root so it gets rsynced + # This ensures the config with rewritten paths is available on remote + repo_config = Path.cwd() / "config.yaml" + shutil.copy2(train_path, repo_config) + + # Check for YAML overrides for workdir, pre_ray_start_commands, and run_command + effective_workdir = workdir + effective_pre_ray_start_commands = pre_ray_start_commands + effective_run_command = run_command + if env_config.get("workdir"): + effective_workdir = env_config["workdir"] + if env_config.get("pre_ray_start_commands"): + effective_pre_ray_start_commands = env_config["pre_ray_start_commands"] + if env_config.get("run_command"): + effective_run_command = env_config["run_command"] + + # Build setup commands based on packager type and workdir + if effective_pre_ray_start_commands is not None: + # Use explicitly provided commands (user handles all setup) + setup_commands = list(effective_pre_ray_start_commands) + elif packager == "self_contained": + # For self_contained packager, skip uv sync (dependencies in container) + # and copy files from /nemo_run/code to workdir + setup_commands = [ + "find . -type d -name __pycache__ -delete 2>/dev/null || true", + ] + if effective_workdir: + setup_commands.extend( + [ + f"cp /nemo_run/code/main.py {effective_workdir}/", + f"cp /nemo_run/code/config.yaml {effective_workdir}/", + ] + ) + else: + setup_commands.extend( + [ + "cp /nemo_run/code/main.py .", + "cp /nemo_run/code/config.yaml .", + ] + ) + else: + # Default setup for other packagers + setup_commands = [ + "find . -type d -name __pycache__ -delete 2>/dev/null || true", + "uv sync --reinstall-package nemotron", + ] + + # Determine remote script path + if packager == "self_contained": + remote_script = "main.py" + else: + # Get the actual script path from the recipe config + remote_script = job_config.run.recipe.script + + # Build the command to run + config_file = "config.yaml" + if effective_run_command: + # Use custom run command template with placeholders + cmd = effective_run_command.format(script=remote_script, config=config_file) + # Prepend cd to workdir if set (pre_ray_start_commands run before Ray, not in job) + if effective_workdir: + cmd = f"cd {effective_workdir} && {cmd}" + elif effective_workdir and packager == "self_contained": + # Already cd'd in setup_commands, run directly + cmd = f"cd {effective_workdir} && python {remote_script} --config {config_file}" + elif effective_workdir: + cmd = f"cd {effective_workdir} && uv run python {remote_script} --config {config_file}" + else: + cmd = f"uv run python {remote_script} --config {config_file}" + if passthrough: + cmd += " " + " ".join(passthrough) + + # Build runtime_env with environment variables for Ray workers + runtime_env: dict = {"env_vars": dict(env_vars)} + + # Create temporary runtime_env YAML file + import tempfile + + import yaml as pyyaml + + runtime_env_yaml = None + if runtime_env["env_vars"]: + with tempfile.NamedTemporaryFile(mode="w", suffix=".yaml", delete=False) as f: + pyyaml.dump(runtime_env, f) + runtime_env_yaml = f.name + + ray_job.start( + command=cmd, + # Pass workdir with trailing slash to rsync the repo contents to remote. + # nemo-run uses --filter=':- .gitignore' which respects .gitignore patterns. + # The trailing slash ensures contents are synced (not the parent dir itself). + workdir=str(Path.cwd()) + "/", + pre_ray_start_commands=setup_commands, + runtime_env_yaml=runtime_env_yaml, + ) + + # Workaround for nemo-run bug: when reusing an existing cluster, + # SlurmRayCluster.create() returns None instead of the job_id. + if ray_job.backend.job_id is None: + status = ray_job.backend.status(display=False) + if status and status.get("job_id"): + ray_job.backend.job_id = status["job_id"] + typer.echo(f"[info] Recovered job_id {status['job_id']} from cluster status") + + if attached: + try: + # Wait up to 10 minutes for log file to appear + ray_job.logs(follow=True, timeout=600) + except KeyboardInterrupt: + typer.echo("\n") + job_id = ray_job.backend.job_id + typer.echo(f"[info] Ctrl-C detected. Job {job_id} is still running.") + typer.echo("") + typer.echo(" [d] Detach - keep job running in background") + typer.echo(" [c] Cancel - stop the job") + typer.echo(" [enter] Detach (default)") + typer.echo("") + + try: + choice = input("Choice [d/c]: ").strip().lower() + except (EOFError, KeyboardInterrupt): + # Second Ctrl+C or EOF means detach + choice = "d" + + if choice == "c": + typer.echo("[info] Cancelling job...") + try: + ray_job.stop() + typer.echo(f"[info] Job {job_id} cancelled") + except Exception as e: + typer.echo(f"[warning] Failed to cancel job: {e}") + raise typer.Exit(130) + else: + typer.echo(f"[info] Detaching. Job {job_id} continues running.") + typer.echo(f"[info] To view logs: squeue -u $USER | grep {job_id}") + typer.echo(f"[info] To cancel: scancel {job_id}") + raise typer.Exit(0) + else: + # Standard execution via nemo-run Script + entrypoint = "python" + + with run.Experiment(recipe_name) as exp: + exp.add( + run.Script( + path="main.py", # Flat name on remote + args=script_args, + entrypoint=entrypoint, + ), + executor=executor, + name=recipe_name, + ) + exp.run(detach=not attached) + + +def _build_executor( + env_config: dict, + job_config: Any, + script_path: str, + train_path: Path, + job_dir: Path, + env_vars: dict[str, str], + *, + torchrun: bool = True, + ray: bool = False, + attached: bool = True, + packager: str = "pattern", + force_squash: bool = False, +) -> Any: + """Build nemo-run executor from env config. + + Args: + env_config: Environment configuration dict + job_config: Full job config (unused, kept for future extensions) + script_path: Path to the training script + train_path: Path to the train.yaml config + job_dir: Path to the job directory for staging files + env_vars: Pre-built environment variables + torchrun: Whether to use torchrun launcher + ray: Whether this recipe requires Ray + attached: Whether running in attached mode (--run vs --batch) + force_squash: Whether to force re-squash container image + + Returns: + nemo-run Executor instance + """ + import nemo_run as run + + # Apply patches to nemo-run before building executor + from nemotron.kit.run import ( + patch_nemo_run_ray_template_for_cpu, + patch_nemo_run_rsync_accept_new_host_keys, + ) + patch_nemo_run_rsync_accept_new_host_keys() + patch_nemo_run_ray_template_for_cpu() + + executor_type = env_config.get("executor", "local") + + # Determine launcher + launcher = "torchrun" if torchrun else None + + if executor_type == "local": + return run.LocalExecutor( + ntasks_per_node=env_config.get("nproc_per_node", 1), + launcher=launcher, + env_vars=env_vars, + ) + + elif executor_type == "slurm": + # Build tunnel if configured + tunnel = None + remote_job_dir = env_config.get("remote_job_dir") + if env_config.get("tunnel") == "ssh": + tunnel = run.SSHTunnel( + host=env_config.get("host", "localhost"), + user=env_config.get("user"), + job_dir=remote_job_dir, + ) + + # Build packager with flat file layout (main.py, config.yaml) + packager = _build_packager( + script_path, + train_path, + job_dir, + packager=packager, + ) + + # Container image can be specified as "container" or "container_image" + container_image = env_config.get("container_image") or env_config.get("container") + + # Ensure container image is squashed on the cluster + if container_image and tunnel and remote_job_dir: + # Connect tunnel to check/create squashed image + tunnel.connect() + container_image = _ensure_squashed_image( + tunnel, container_image, remote_job_dir, env_config, force=force_squash + ) + + # Select partition based on mode (--run uses run_partition, --batch uses batch_partition) + if attached: + partition = env_config.get("run_partition") or env_config.get("partition") + else: + partition = env_config.get("batch_partition") or env_config.get("partition") + + # Build executor kwargs, only including exclusive if True + executor_kwargs: dict[str, Any] = { + "account": env_config.get("account"), + "partition": partition, + "nodes": env_config.get("nodes", 1), + "ntasks_per_node": env_config.get("ntasks_per_node", 1), + "gpus_per_node": env_config.get("gpus_per_node"), + "cpus_per_task": env_config.get("cpus_per_task"), + "time": env_config.get("time", "04:00:00"), + "container_image": container_image, + "container_mounts": env_config.get("mounts") or [], + "tunnel": tunnel, + "packager": packager, + "mem": env_config.get("mem"), + "env_vars": env_vars, + "launcher": launcher, + } + + # Only add exclusive if explicitly True (avoids slurm error) + if env_config.get("exclusive"): + executor_kwargs["exclusive"] = True + + # TODO: Add Ray support when ray=True + # This would configure the executor for Ray cluster setup + + return run.SlurmExecutor(**executor_kwargs) + + else: + raise ValueError(f"Unknown executor type: {executor_type}") + + +def _build_env_vars(job_config: Any, env_config: dict | None = None) -> dict: + """Build environment variables for nemo-run execution. + + Sets up: + - NEMO_RUN_DIR for output paths + - HF_HOME for HuggingFace cache (defaults to remote_job_dir/hf) + - HF_TOKEN if logged in to HuggingFace + - WANDB_API_KEY, WANDB_ENTITY, WANDB_PROJECT if logged in to W&B + + Args: + job_config: Full job configuration (contains run.wandb section) + env_config: Environment configuration from env.toml (contains remote_job_dir) + + Returns: + Dictionary of environment variables + """ + import os + + from omegaconf import OmegaConf + + env_vars: dict[str, str] = {} + + # Set NEMO_RUN_DIR to actual lustre path for output paths + # This ensures artifacts store the real path, not /nemo_run container mount + if env_config and env_config.get("remote_job_dir"): + env_vars["NEMO_RUN_DIR"] = env_config["remote_job_dir"] + else: + # Fallback to container mount if remote_job_dir not configured + env_vars["NEMO_RUN_DIR"] = "/nemo_run" + + # Set HF_HOME to remote_job_dir/hf if not explicitly set by user + # This ensures HuggingFace downloads go to Lustre storage with sufficient space + if os.environ.get("HF_HOME"): + # Respect user's explicit HF_HOME setting + env_vars["HF_HOME"] = os.environ["HF_HOME"] + elif env_config and env_config.get("remote_job_dir"): + env_vars["HF_HOME"] = f"{env_config['remote_job_dir']}/hf" + + # Auto-detect HuggingFace token + try: + from huggingface_hub import HfFolder + + token = HfFolder.get_token() + if token: + env_vars["HF_TOKEN"] = token + except Exception: + pass + + # Auto-detect Weights & Biases API key + try: + import wandb + + api_key = wandb.api.api_key + if api_key: + env_vars["WANDB_API_KEY"] = api_key + except Exception: + pass + + # Extract W&B entity and project from job config + try: + if hasattr(job_config, "run") and hasattr(job_config.run, "wandb"): + wandb_config = OmegaConf.to_container(job_config.run.wandb, resolve=True) + if wandb_config.get("entity"): + env_vars["WANDB_ENTITY"] = str(wandb_config["entity"]) + if wandb_config.get("project"): + env_vars["WANDB_PROJECT"] = str(wandb_config["project"]) + except Exception: + pass + + return env_vars + + +def _build_packager( + script_path: str, + train_path: Path, + job_dir: Path, + *, + packager: str = "pattern", +) -> Any: + """Build a packager for file syncing. + + Packager types: + - "pattern": Minimal sync of `main.py` + `config.yaml` only (default) + - "code": Full codebase sync with exclusions (for Ray jobs needing local imports) + - "self_contained": Inlines `nemotron.*` imports into a single script + """ + import shutil + + from nemo_run.core.packaging import PatternPackager + + if packager == "self_contained": + from nemotron.kit.packaging import SelfContainedPackager + + return SelfContainedPackager( + script_path=script_path, + train_path=str(train_path), + ) + + if packager == "code": + from nemotron.kit.packaging import CodePackager + + return CodePackager( + script_path=script_path, + train_path=str(train_path), + exclude_dirs=("usage-cookbook", "use-case-examples"), + ) + + if packager != "pattern": + raise ValueError(f"Unknown packager: {packager}") + + code_dir = job_dir / "code" + code_dir.mkdir(exist_ok=True) + + shutil.copy2(script_path, code_dir / "main.py") + shutil.copy2(train_path, code_dir / "config.yaml") + + main_path = str(code_dir / "main.py") + config_path = str(code_dir / "config.yaml") + return PatternPackager( + include_pattern=[main_path, config_path], + relative_path=[str(code_dir), str(code_dir)], + ) + + +def _get_squash_path(container_image: str, remote_job_dir: str) -> str: + """Get the path to the squashed container image. + + Creates a deterministic filename based on the container image name. + For example: nvcr.io/nvidian/nemo:25.11-nano-v3.rc2 -> nemo-25.11-nano-v3.rc2.sqsh + + Args: + container_image: Docker container image (e.g., nvcr.io/nvidian/nemo:25.11-nano-v3.rc2) + remote_job_dir: Remote directory for squashed images + + Returns: + Full path to squashed image file + """ + # Extract image name and tag for readable filename + # nvcr.io/nvidian/nemo:25.11-nano-v3.rc2 -> nemo:25.11-nano-v3.rc2 + image_name = container_image.split("/")[-1] + # nemo:25.11-nano-v3.rc2 -> nemo-25.11-nano-v3.rc2.sqsh + sqsh_name = image_name.replace(":", "-") + ".sqsh" + + return f"{remote_job_dir}/{sqsh_name}" + + +def _ensure_squashed_image( + tunnel: Any, + container_image: str, + remote_job_dir: str, + env_config: dict, + *, + force: bool = False, +) -> str: + """Ensure the container image is squashed on the remote cluster. + + Checks if a squashed version exists, and if not, creates it using enroot + on a compute node via salloc. + + Args: + tunnel: SSHTunnel instance (already connected) + container_image: Docker container image to squash + remote_job_dir: Remote directory for squashed images + env_config: Environment config with slurm settings (account, partition, time) + force: If True, re-squash even if file already exists + + Returns: + Path to the squashed image file + """ + sqsh_path = _get_squash_path(container_image, remote_job_dir) + + # Check if squashed image already exists (unless force is set) + if not force: + with console.status("[bold blue]Checking for squashed image..."): + result = tunnel.run(f"test -f {sqsh_path} && echo exists", hide=True, warn=True) + + if result.ok and "exists" in result.stdout: + console.print( + f"[green]✓[/green] Using existing squashed image: [cyan]{sqsh_path}[/cyan]" + ) + return sqsh_path + + # Need to create the squashed image + if force: + console.print("[yellow]![/yellow] Force re-squash requested, removing existing file...") + tunnel.run(f"rm -f {sqsh_path}", hide=True) + else: + console.print("[yellow]![/yellow] Squashed image not found, creating...") + console.print(f" [dim]Image:[/dim] {container_image}") + console.print(f" [dim]Output:[/dim] {sqsh_path}") + console.print() + + # Ensure directory exists + tunnel.run(f"mkdir -p {remote_job_dir}", hide=True) + + # Build salloc command to run enroot import on a compute node + # (login nodes don't have enough memory for enroot import) + account = env_config.get("account") + partition = env_config.get("run_partition") or env_config.get("partition") + time_limit = env_config.get("time", "04:00:00") + gpus_per_node = env_config.get("gpus_per_node") + + salloc_args = [] + if account: + salloc_args.append(f"--account={account}") + if partition: + salloc_args.append(f"--partition={partition}") + salloc_args.append("--nodes=1") + salloc_args.append("--ntasks-per-node=1") + if gpus_per_node: + salloc_args.append(f"--gpus-per-node={gpus_per_node}") + salloc_args.append(f"--time={time_limit}") + + enroot_cmd = f"enroot import --output {sqsh_path} docker://{container_image}" + cmd = f"salloc {' '.join(salloc_args)} srun {enroot_cmd}" + + # Run enroot import via salloc (this can take a while) + console.print( + "[bold blue]Allocating compute node and importing container " + "(this may take several minutes)...[/bold blue]" + ) + console.print(f"[dim]$ {cmd}[/dim]") + console.print() + result = tunnel.run(cmd, hide=False, warn=True) + + if not result.ok: + raise RuntimeError( + f"Failed to squash container image.\n" + f"Command: {cmd}\n" + f"Error: {result.stderr or 'Unknown error'}" + ) + + console.print(f"[green]✓[/green] Created squashed image: [cyan]{sqsh_path}[/cyan]") + return sqsh_path + + +def _execute_stage_only( + script_path: str, + train_path: Path, + job_dir: Path, + job_config: Any, + packager: str = "pattern", + *, + torchrun: bool = True, +) -> None: + """Stage script + config to remote cluster without execution. + + Stages files to a fixed location in remote_job_dir and prints + commands for interactive debugging. + + Args: + script_path: Path to training script + train_path: Path to train.yaml config + job_dir: Local job directory + job_config: Full job configuration (contains run.env) + packager: Packager type ("pattern", "code", "self_contained") + torchrun: Whether to use torchrun launcher + """ + + try: + import nemo_run as run + except ImportError: + typer.echo("Error: nemo-run is required for --stage", err=True) + typer.echo("Install with: pip install nemo-run", err=True) + raise typer.Exit(1) + + from omegaconf import OmegaConf + + # Extract env config + env_config = OmegaConf.to_container(job_config.run.env, resolve=True) + + # Only support SSH tunnel for now + tunnel_type = env_config.get("tunnel") + if tunnel_type != "ssh": + console.print("[red]Error:[/red] --stage requires SSH tunnel configuration (tunnel: ssh)") + raise typer.Exit(1) + + remote_job_dir = env_config.get("remote_job_dir") + if not remote_job_dir: + console.print("[red]Error:[/red] remote_job_dir not configured in env profile") + raise typer.Exit(1) + + # Fixed staging location for interactive debugging + stage_dir = f"{remote_job_dir}/interactive" + + # Build tunnel + tunnel = run.SSHTunnel( + host=env_config.get("host", "localhost"), + user=env_config.get("user"), + job_dir=remote_job_dir, + ) + + # Connect + with console.status("[bold blue]Connecting to remote cluster..."): + tunnel.connect() + + # Create remote directories + console.print(f"\n[cyan]Creating remote directory:[/cyan] {stage_dir}") + tunnel.run(f"mkdir -p {stage_dir}", hide=True) + + # Stage files locally using the packager + # For self_contained packager, this will inline nemotron imports + code_dir = job_dir / "code" + code_dir.mkdir(exist_ok=True) + + if packager == "self_contained": + from nemotron.kit.packaging.self_contained_packager import inline_imports + + # Inline imports to create main.py + script_file = Path(script_path) + if not script_file.is_absolute(): + script_file = Path.cwd() / script_path + + inlined = inline_imports( + script_file, + repo_root=Path.cwd(), + package_prefix="nemotron", + ) + (code_dir / "main.py").write_text(inlined, encoding="utf-8") + shutil.copy2(train_path, code_dir / "config.yaml") + else: + # For pattern/code packagers, just copy files + shutil.copy2(script_path, code_dir / "main.py") + shutil.copy2(train_path, code_dir / "config.yaml") + + local_script = code_dir / "main.py" + local_config = code_dir / "config.yaml" + + # Build environment variables (same as _execute_nemo_run) + env_vars = _build_env_vars(job_config, env_config) + + # Override NEMO_RUN_DIR for --stage mode: /nemo_run maps to stage_dir, not remote_job_dir + env_vars["NEMO_RUN_DIR"] = stage_dir + + # Get GPU count for torchrun + gpus = env_config.get("gpus_per_node") or env_config.get("ntasks_per_node", 8) + + # Create run.sh script that sets env vars and runs training + run_script_lines = [ + "#!/bin/bash", + "# Auto-generated training script with environment setup", + "", + ] + run_script_lines.append("# Environment variables for W&B and HuggingFace") + for key, value in env_vars.items(): + # Escape single quotes in values + escaped_value = value.replace("'", "'\"'\"'") + run_script_lines.append(f"export {key}='{escaped_value}'") + run_script_lines.append("") + run_script_lines.append("# Run training") + if torchrun: + run_script_lines.append( + f'torchrun --nproc_per_node={gpus} main.py --config config.yaml "$@"' + ) + else: + run_script_lines.append('python main.py --config config.yaml "$@"') + run_script = "\n".join(run_script_lines) + "\n" + run_script_path = code_dir / "run.sh" + run_script_path.write_text(run_script) + + # Upload files via scp/sftp + console.print(f"[cyan]Uploading files to:[/cyan] {stage_dir}") + with console.status("[bold blue]Uploading script, config, and run.sh..."): + tunnel.put(str(local_script), f"{stage_dir}/main.py") + tunnel.put(str(local_config), f"{stage_dir}/config.yaml") + tunnel.put(str(run_script_path), f"{stage_dir}/run.sh") + # Make run.sh executable + tunnel.run(f"chmod +x {stage_dir}/run.sh", hide=True) + + console.print("[green]✓[/green] Files staged successfully\n") + + # Build and display commands + _print_stage_commands(env_config, stage_dir, env_vars=env_vars, torchrun=torchrun) + + +def _print_stage_commands( + env_config: dict, + stage_dir: str, + *, + env_vars: dict[str, str] | None = None, + torchrun: bool = True, +) -> None: + """Print commands for interactive debugging after staging. + + Args: + env_config: Environment configuration dict + stage_dir: Remote directory where files were staged + env_vars: Environment variables for W&B/HF (displayed to user) + torchrun: Whether to use torchrun launcher + """ + from rich.panel import Panel + + host = env_config.get("host", "localhost") + user = env_config.get("user", "") + partition = env_config.get("run_partition") or env_config.get("partition", "interactive") + nodes = env_config.get("nodes", 1) + gpus = env_config.get("gpus_per_node") or env_config.get("ntasks_per_node", 8) + time_limit = env_config.get("time", "04:00:00") + container = env_config.get("container_image") or env_config.get("container") + account = env_config.get("account") + remote_job_dir = env_config.get("remote_job_dir") + + # Get squashed container path + sqsh_path = None + if container and remote_job_dir: + sqsh_path = _get_squash_path(container, remote_job_dir) + + # Mount to /workspace for simpler commands inside container + container_mount_path = "/workspace" + + # Build srun command (multi-line for display) + srun_parts = ["srun"] + if account: + srun_parts.append(f"--account={account}") + srun_parts.extend( + [ + f"--partition={partition}", + f"--nodes={nodes}", + f"--ntasks-per-node={gpus}", + f"--gpus-per-node={gpus}", + f"--time={time_limit}", + ] + ) + if sqsh_path: + srun_parts.append(f"--container-image={sqsh_path}") + # Mount stage_dir to both /workspace and /nemo_run to match real nemo-run behavior + srun_parts.append( + f"--container-mounts={stage_dir}:{container_mount_path},{stage_dir}:/nemo_run,/lustre:/lustre" + ) + srun_parts.append(f"--container-workdir={container_mount_path}") + + # Add NEMO_RUN_DIR to srun command - critical for resolving /nemo_run mount to actual Lustre path + if env_vars and "NEMO_RUN_DIR" in env_vars: + srun_parts.append(f"--export=ALL,NEMO_RUN_DIR={env_vars['NEMO_RUN_DIR']}") + + srun_parts.append("--pty bash") + srun_cmd_display = " \\\n ".join(srun_parts) + srun_cmd_oneline = " ".join(srun_parts) + + # Build environment info for display + env_info = "" + if env_vars: + env_keys = [] + for key in env_vars: + if key in ("WANDB_API_KEY", "HF_TOKEN"): + env_keys.append(f"{key}=***") + else: + env_keys.append(f"{key}={env_vars[key]}") + env_info = f"[bold cyan]Environment:[/bold cyan] {', '.join(env_keys)}\n" + + # Display + console.print( + Panel.fit( + f"[bold cyan]Files staged to:[/bold cyan] {stage_dir}\n" + f"[bold cyan]Mounted at:[/bold cyan] {container_mount_path} and /nemo_run\n" + f"{env_info}\n" + f"[bold cyan]1. SSH to cluster:[/bold cyan]\n" + f" [green]ssh {user}@{host}[/green]\n\n" + f"[bold cyan]2. Start interactive job:[/bold cyan]\n" + f" [green]{srun_cmd_display}[/green]\n\n" + f"[bold cyan]3. Run training:[/bold cyan]\n" + f" [green]./run.sh[/green]\n\n" + f"[dim]Tip: Keep the srun session alive while iterating. " + f"Re-run with --stage to update files, then run ./run.sh again.[/dim]", + title="[bold]Interactive Debugging[/bold]", + border_style="green", + ) + ) + + # Print single-line srun command for easy copying + # Use print() instead of console.print() to avoid Rich text wrapping + console.print("\n[bold cyan]Copy-paste srun command:[/bold cyan]") + print(srun_cmd_oneline) + print() diff --git a/src/nemotron/kit/cli/squash.py b/src/nemotron/kit/cli/squash.py new file mode 100644 index 0000000..a915a31 --- /dev/null +++ b/src/nemotron/kit/cli/squash.py @@ -0,0 +1,64 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Container squash utilities for Slurm execution. + +Handles converting Docker images to squash files on remote clusters +using enroot. Uses deterministic naming to avoid re-squashing existing images. +""" + +from __future__ import annotations + +import re +from typing import Any + + +def container_to_sqsh_name(container: str) -> str: + """Convert container image name to deterministic squash filename. + + Replaces any characters that can't be used in filenames with underscores. + + Args: + container: Docker image name (e.g., "nvcr.io/nvidian/nemo:25.11-nano-v3.rc2") + + Returns: + Safe squash filename (e.g., "nvcr_io_nvidian_nemo_25_11_nano_v3_rc2.sqsh") + + Examples: + >>> container_to_sqsh_name("nvcr.io/nvidian/nemo:25.11-nano-v3.rc2") + 'nvcr_io_nvidian_nemo_25_11_nano_v3_rc2.sqsh' + >>> container_to_sqsh_name("rayproject/ray:nightly-extra-py312-cpu") + 'rayproject_ray_nightly_extra_py312_cpu.sqsh' + """ + # Replace any non-alphanumeric characters (except underscore) with underscore + safe_name = re.sub(r"[^a-zA-Z0-9_]", "_", container) + # Collapse multiple underscores into one + safe_name = re.sub(r"_+", "_", safe_name) + # Strip leading/trailing underscores + safe_name = safe_name.strip("_") + return f"{safe_name}.sqsh" + + +def check_sqsh_exists(tunnel: Any, remote_path: str) -> bool: + """Check if a squash file exists on the remote cluster. + + Args: + tunnel: nemo-run SSHTunnel instance + remote_path: Full path to the squash file + + Returns: + True if file exists, False otherwise + """ + result = tunnel.run(f"test -f {remote_path} && echo exists", hide=True, warn=True) + return result.ok and "exists" in result.stdout diff --git a/src/nemotron/kit/cli/utils.py b/src/nemotron/kit/cli/utils.py new file mode 100644 index 0000000..1b15d7a --- /dev/null +++ b/src/nemotron/kit/cli/utils.py @@ -0,0 +1,244 @@ +"""Shared utilities for CLI components.""" + +from __future__ import annotations + +import re +from pathlib import Path +from typing import Any + + +def resolve_run_interpolations(obj: Any, run_data: dict) -> Any: + """Recursively resolve ${run.*} interpolations in a dict/list. + + Only resolves ${run.X.Y} style interpolations, preserves other + interpolations like ${art:data,path}. + + Args: + obj: Object to process (dict, list, or scalar) + run_data: The run section data to resolve from + + Returns: + Object with ${run.*} interpolations resolved + """ + if isinstance(obj, dict): + return {k: resolve_run_interpolations(v, run_data) for k, v in obj.items()} + elif isinstance(obj, list): + return [resolve_run_interpolations(item, run_data) for item in obj] + elif isinstance(obj, str) and obj.startswith("${run.") and obj.endswith("}"): + # Extract the path: ${run.wandb.project} -> wandb.project + path = obj[6:-1] # Remove "${run." and "}" + # Navigate run_data to get the value + parts = path.split(".") + value = run_data + for part in parts: + if isinstance(value, dict) and part in value: + value = value[part] + else: + return obj # Can't resolve, keep original + return value + else: + return obj + + +def rewrite_paths_for_remote(obj: Any, repo_root: Path | str) -> Any: + """Recursively rewrite paths for remote execution. + + Rewrites: + - ${oc.env:PWD}/... -> /nemo_run/code/... + - ${oc.env:NEMO_RUN_DIR,...}/... -> /nemo_run/... + - Absolute paths under repo_root -> /nemo_run/code/... + + Args: + obj: Object to process (dict, list, or scalar) + repo_root: Local repository root path + + Returns: + Object with paths rewritten for remote execution + """ + repo_root_str = str(repo_root) + + if isinstance(obj, dict): + return {k: rewrite_paths_for_remote(v, repo_root_str) for k, v in obj.items()} + elif isinstance(obj, list): + return [rewrite_paths_for_remote(item, repo_root_str) for item in obj] + elif isinstance(obj, str): + # Rewrite ${oc.env:PWD}/... to /nemo_run/code/... + if "${oc.env:PWD}" in obj: + return obj.replace("${oc.env:PWD}", "/nemo_run/code") + + # Rewrite ${oc.env:NEMO_RUN_DIR,...}/... to /nemo_run/... + # Handles both ${oc.env:NEMO_RUN_DIR} and ${oc.env:NEMO_RUN_DIR,.} + match = re.match(r"\$\{oc\.env:NEMO_RUN_DIR[^}]*\}(.*)", obj) + if match: + suffix = match.group(1) + return f"/nemo_run{suffix}" + + # Rewrite absolute paths under repo_root to /nemo_run/code/... + if obj.startswith(repo_root_str): + rel_path = obj[len(repo_root_str) :].lstrip("/") + return f"/nemo_run/code/{rel_path}" + + return obj + + +def extract_run_args(args: list[str]) -> tuple[str | None, dict[str, str], list[str], bool]: + """Extract --run/--batch arguments from CLI args. + + Parses --run and --run. overrides from args, + or --batch and --batch. overrides. + Returns the profile name, overrides dict, remaining args, and whether + batch mode (detached execution) was used. + + Supports both long and short forms: + - --run or -r + - --run= or -r= + - --run. or --run.= + - --batch or -b + - --batch= or -b= + - --batch. or --batch.= + + Args: + args: Original CLI arguments. + + Returns: + Tuple of (profile_name, overrides_dict, remaining_args, is_launch). + profile_name is None if neither --run nor --batch specified. + is_launch is True when --batch was used (implies detach=True). + + Raises: + ValueError: If both --run and --batch are specified, or if a required value is missing. + """ + run_name: str | None = None + launch_name: str | None = None + run_overrides: dict[str, str] = {} + remaining: list[str] = [] + + i = 0 + while i < len(args): + arg = args[i] + + # Handle --run or -r + if arg == "--run" or arg == "-r": + if i + 1 < len(args) and not args[i + 1].startswith("-"): + run_name = args[i + 1] + i += 2 + continue + else: + raise ValueError("--run requires a profile name") + + # Handle --run= or -r= + if arg.startswith("--run="): + run_name = arg.split("=", 1)[1] + i += 1 + continue + if arg.startswith("-r="): + run_name = arg.split("=", 1)[1] + i += 1 + continue + + # Handle --run. or --run.= + if arg.startswith("--run."): + key = arg[6:] # Remove "--run." + if "=" in key: + key, value = key.split("=", 1) + run_overrides[key] = value + elif i + 1 < len(args): + run_overrides[key] = args[i + 1] + i += 2 + continue + else: + raise ValueError(f"--run.{key} requires a value") + i += 1 + continue + + # Handle --batch / -b + if arg == "--batch" or arg == "-b": + if i + 1 < len(args) and not args[i + 1].startswith("-"): + launch_name = args[i + 1] + i += 2 + continue + else: + raise ValueError("--batch requires a profile name") + + # Handle --batch= or -b= + if arg.startswith("--batch="): + launch_name = arg.split("=", 1)[1] + i += 1 + continue + if arg.startswith("-b="): + launch_name = arg.split("=", 1)[1] + i += 1 + continue + + # Handle --batch. or --batch.= + if arg.startswith("--batch."): + key = arg[8:] # Remove "--batch." + if "=" in key: + key, value = key.split("=", 1) + run_overrides[key] = value + elif i + 1 < len(args): + run_overrides[key] = args[i + 1] + i += 2 + continue + else: + raise ValueError(f"--batch.{key} requires a value") + i += 1 + continue + + remaining.append(arg) + i += 1 + + # Validate mutual exclusivity + if run_name is not None and launch_name is not None: + raise ValueError( + "--run and --batch are mutually exclusive. " + "Use --run for attached execution or --batch for detached execution." + ) + + # Determine final name and whether batch mode is active + is_launch = launch_name is not None + final_name = launch_name if is_launch else run_name + + return final_name, run_overrides, remaining, is_launch + + +# Valid CLI argument names for config file path +CONFIG_FILE_KEYS = {"--config-file", "--config_file", "--config", "-c"} + + +def filter_config_file_args(args: list[str]) -> list[str]: + """Remove --config-file and related arguments from args list. + + Handles both formats: + - --config-file path + - --config-file=path + - -c path + - -c=path + + Args: + args: Command line arguments + + Returns: + Filtered arguments without config file flags + """ + filtered: list[str] = [] + skip_next = False + + for i, arg in enumerate(args): + if skip_next: + skip_next = False + continue + + # Handle --config-file=path format + if "=" in arg: + key = arg.split("=", 1)[0] + if key in CONFIG_FILE_KEYS: + continue + # Handle --config-file path format + elif arg in CONFIG_FILE_KEYS: + skip_next = True + continue + + filtered.append(arg) + + return filtered diff --git a/src/nemotron/kit/exceptions.py b/src/nemotron/kit/exceptions.py new file mode 100644 index 0000000..c04c9d8 --- /dev/null +++ b/src/nemotron/kit/exceptions.py @@ -0,0 +1,36 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +""" +Exception classes for the nemotron.art package. +""" + + +class ArtifactNotFoundError(Exception): + """Raised when an artifact cannot be found in the registry.""" + + def __init__(self, name: str, message: str | None = None) -> None: + self.name = name + self.message = message or f"Artifact not found: {name}" + super().__init__(self.message) + + +class ArtifactVersionNotFoundError(Exception): + """Raised when a specific version of an artifact cannot be found.""" + + def __init__(self, name: str, version: str | int, message: str | None = None) -> None: + self.name = name + self.version = version + self.message = message or f"Artifact version not found: {name}:{version}" + super().__init__(self.message) diff --git a/src/nemotron/kit/filesystem.py b/src/nemotron/kit/filesystem.py new file mode 100644 index 0000000..b80c0b9 --- /dev/null +++ b/src/nemotron/kit/filesystem.py @@ -0,0 +1,427 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +""" +fsspec filesystem implementation for art:// URIs. + +Allows using art:// URIs with fsspec.open() and other fsspec-compatible tools. +""" + +from pathlib import Path +from typing import Any + +from fsspec import AbstractFileSystem + +from nemotron.kit.exceptions import ArtifactNotFoundError, ArtifactVersionNotFoundError +from nemotron.kit.registry import get_registry +from nemotron.kit.track import STAGE_DIRS, get_config + + +class ArtifactFileSystem(AbstractFileSystem): + """fsspec filesystem for art:// URIs. + + Enables using artifact URIs with fsspec-compatible APIs: + + Example: + >>> import fsspec + >>> # Read file from artifact + >>> with fsspec.open("art://my-dataset:v1/train.json") as f: + ... data = json.load(f) + >>> + >>> # Get filesystem directly + >>> fs = fsspec.filesystem("art") + >>> files = fs.ls("art://my-dataset:v1") + + URI format: + art://name:version/path/to/file + art://name:latest/path/to/file + art://name/path/to/file (implies latest) + """ + + protocol = "art" + + def __init__(self, **kwargs: Any) -> None: + """Initialize the artifact filesystem.""" + super().__init__(**kwargs) + + def _parse_uri(self, path: str) -> tuple[str, int | None, str]: + """Parse art:// URI into components. + + Supports multiple formats: + - art://name:v1/file.txt - simple artifact with version + - art://name/file.txt - simple artifact (latest) + - art://entity/project/name:v1/file.txt - full W&B path with version + - art://entity/project/name:v1 - full W&B path, no file + + Args: + path: URI like "art://name:v1/file.txt" or "entity/project/name:v1/file.txt" + + Returns: + Tuple of (artifact_name, version, file_path) + For W&B paths, artifact_name includes entity/project/name + """ + # Remove protocol prefix if present + if path.startswith("art://"): + path = path[6:] + + # Find version specifier (last occurrence of :vN or :latest or :N) + # The artifact reference is everything before the version specifier + # The file path is everything after the artifact reference + + # First, check if there's a version specifier + version: int | None = None + artifact_ref = "" + file_path = "" + + # Look for version pattern: :vN, :latest, or :N at the end of a segment + # Split on / and look for : in each part + parts = path.split("/") + + for i, part in enumerate(parts): + if ":" in part: + # This part contains the version specifier + name_part, version_str = part.rsplit(":", 1) + + # Parse version + if version_str == "latest": + version = None + elif version_str.startswith("v"): + version = int(version_str[1:]) + else: + try: + version = int(version_str) + except ValueError: + # Not a valid version, treat the whole thing as the name + name_part = part + version = None + + # Build artifact ref from parts up to and including this one (minus version) + artifact_ref = "/".join(parts[:i] + [name_part] if name_part else parts[:i]) + # File path is everything after + file_path = "/".join(parts[i + 1 :]) if i + 1 < len(parts) else "" + break + else: + # No version specifier found - entire path could be artifact name or name/file + # Heuristic: if there's no version, assume no file path (user wants artifact root) + artifact_ref = path + file_path = "" + version = None + + return artifact_ref, version, file_path + + def _resolve_semantic(self, uri: str) -> tuple[str, str] | None: + """Resolve semantic URI like nano3/pretrain/data?sample=10000/file.json. + + Returns: + Tuple of (base_path, file_path) or None if not a semantic URI. + """ + if uri.startswith("art://"): + uri = uri[6:] + + # Skip if has version specifier (name:version format) + first_part = uri.split("?")[0].split("/")[0] + if ":" in first_part: + return None + + # Parse query params + params: dict[str, str] = {} + file_path = "" + if "?" in uri: + base, rest = uri.split("?", 1) + if "/" in rest: + params_str, file_path = rest.split("/", 1) + else: + params_str = rest + for p in params_str.split("&"): + if "=" in p: + k, v = p.split("=", 1) + params[k] = v + else: + parts = uri.split("/") + if len(parts) > 3: + base = "/".join(parts[:3]) + file_path = "/".join(parts[3:]) + else: + base = uri + + parts = base.split("/") + if len(parts) < 3: + return None + + recipe, stage, step = parts[0], parts[1], parts[2] + stage_dir = STAGE_DIRS.get(stage) + if stage_dir is None: + return None + + config = get_config() + + if config.backend == "wandb": + import wandb + + artifact_name = f"{recipe}-{stage}-{step}" + if "sample" in params: + artifact_name += f"-sample-{params['sample']}" + artifact = wandb.use_artifact(f"{artifact_name}:latest") + base_path = artifact.download() # Returns string path + else: + # fsspec backend - can be any fsspec URI (local, hf://, s3://, etc.) + base_path = f"{config.output_root}/{recipe}/{stage_dir}" + if "sample" in params: + base_path = f"{base_path}/sample-{params['sample']}" + + return base_path, file_path + + def _resolve(self, path: str) -> tuple[Path, str]: + """Resolve art:// path to local filesystem path. + + Supports multiple URI formats: + - art://name:version - local registry lookup + - art://entity/project/name:version - full W&B artifact path + - art://recipe/stage/step - semantic URI (e.g., nano3/pretrain/data) + + Returns: + Tuple of (artifact_root_path, relative_file_path) + """ + # Try semantic resolution first (for nano3/pretrain/data format) + semantic = self._resolve_semantic(path) + if semantic is not None: + base_path, file_path = semantic + return Path(base_path), file_path + + # Parse the URI + name, version, file_path = self._parse_uri(path) + + # Check if name contains slashes (W&B full path: entity/project/artifact_name) + if "/" in name: + local_path = self._resolve_wandb_full_path(name, version) + return local_path, file_path + + # Try local registry first + try: + registry = get_registry() + artifact_path = registry.resolve(name, version) + return artifact_path, file_path + except ArtifactNotFoundError: + # Fall back to W&B with short name (uses current project) + local_path = self._resolve_wandb_short_name(name, version) + return local_path, file_path + + def _resolve_wandb_full_path(self, full_name: str, version: int | None) -> Path: + """Resolve full W&B artifact path (entity/project/name). + + Args: + full_name: Full artifact path like "romeyn/nemotron/DataBlendsArtifact-pretrain" + version: Version number (e.g., 10 for v10) or None for latest + + Returns: + Local path to downloaded artifact + """ + import wandb + + version_str = f":v{version}" if version is not None else ":latest" + artifact = wandb.Api().artifact(f"{full_name}{version_str}") + return Path(artifact.download()) + + def _resolve_wandb_short_name(self, name: str, version: int | None) -> Path: + """Resolve short artifact name using current W&B project. + + Args: + name: Artifact name (without entity/project) + version: Version number or None for latest + + Returns: + Local path to downloaded artifact + """ + import wandb + + config = get_config() + + # Build the project path from config + if config.wandb_entity: + project = f"{config.wandb_entity}/{config.wandb_project}" + else: + project = config.wandb_project + + version_str = f":v{version}" if version is not None else ":latest" + artifact = wandb.Api().artifact(f"{project}/{name}{version_str}") + return Path(artifact.download()) + + def _open( + self, + path: str, + mode: str = "rb", + block_size: int | None = None, + autocommit: bool = True, + cache_options: dict[str, Any] | None = None, + **kwargs: Any, + ) -> Any: + """Open a file from an artifact. + + Args: + path: art:// URI to file + mode: File mode (only read modes supported) + **kwargs: Additional arguments passed to open() + + Returns: + File object + """ + if "w" in mode or "a" in mode: + raise ValueError("ArtifactFileSystem is read-only") + + artifact_path, file_path = self._resolve(path) + full_path = artifact_path / file_path if file_path else artifact_path + + return open(full_path, mode, **kwargs) + + def ls(self, path: str, detail: bool = True, **kwargs: Any) -> list[Any]: + """List contents of artifact or directory within artifact. + + Args: + path: art:// URI + detail: If True, return detailed info dicts + + Returns: + List of file paths or info dicts + """ + artifact_path, file_path = self._resolve(path) + target_path = artifact_path / file_path if file_path else artifact_path + + if not target_path.exists(): + raise FileNotFoundError(f"Path not found: {path}") + + if target_path.is_file(): + if detail: + stat = target_path.stat() + return [ + { + "name": path, + "size": stat.st_size, + "type": "file", + } + ] + return [path] + + # List directory + results = [] + for item in target_path.iterdir(): + item_path = f"{path.rstrip('/')}/{item.name}" + if detail: + stat = item.stat() + results.append( + { + "name": item_path, + "size": stat.st_size if item.is_file() else 0, + "type": "file" if item.is_file() else "directory", + } + ) + else: + results.append(item_path) + + return results + + def info(self, path: str, **kwargs: Any) -> dict[str, Any]: + """Get info about a path. + + Args: + path: art:// URI + + Returns: + Dict with file/directory info + """ + artifact_path, file_path = self._resolve(path) + target_path = artifact_path / file_path if file_path else artifact_path + + if not target_path.exists(): + raise FileNotFoundError(f"Path not found: {path}") + + stat = target_path.stat() + return { + "name": path, + "size": stat.st_size if target_path.is_file() else 0, + "type": "file" if target_path.is_file() else "directory", + } + + def exists(self, path: str, **kwargs: Any) -> bool: + """Check if path exists. + + Args: + path: art:// URI + + Returns: + True if path exists + """ + try: + artifact_path, file_path = self._resolve(path) + target_path = artifact_path / file_path if file_path else artifact_path + return target_path.exists() + except (ArtifactNotFoundError, ArtifactVersionNotFoundError): + return False + + def cat_file( + self, path: str, start: int | None = None, end: int | None = None, **kwargs: Any + ) -> bytes: + """Read entire file content. + + Args: + path: art:// URI + start: Start byte offset + end: End byte offset + + Returns: + File contents as bytes + """ + artifact_path, file_path = self._resolve(path) + target_path = artifact_path / file_path if file_path else artifact_path + + with open(target_path, "rb") as f: + if start is not None: + f.seek(start) + if end is not None: + return f.read(end - (start or 0)) + return f.read() + + def get_file(self, rpath: str, lpath: str, **kwargs: Any) -> None: + """Copy file from artifact to local path. + + Args: + rpath: Remote art:// URI + lpath: Local destination path + """ + import shutil + + artifact_path, file_path = self._resolve(rpath) + source = artifact_path / file_path if file_path else artifact_path + + if source.is_dir(): + shutil.copytree(source, lpath) + else: + shutil.copy2(source, lpath) + + def isfile(self, path: str) -> bool: + """Check if path is a file.""" + try: + artifact_path, file_path = self._resolve(path) + target_path = artifact_path / file_path if file_path else artifact_path + return target_path.is_file() + except (ArtifactNotFoundError, ArtifactVersionNotFoundError, FileNotFoundError): + return False + + def isdir(self, path: str) -> bool: + """Check if path is a directory.""" + try: + artifact_path, file_path = self._resolve(path) + target_path = artifact_path / file_path if file_path else artifact_path + return target_path.is_dir() + except (ArtifactNotFoundError, ArtifactVersionNotFoundError, FileNotFoundError): + return False diff --git a/src/nemotron/kit/megatron_stub.py b/src/nemotron/kit/megatron_stub.py new file mode 100644 index 0000000..87de8d8 --- /dev/null +++ b/src/nemotron/kit/megatron_stub.py @@ -0,0 +1,153 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Stub for megatron-bridge ConfigContainer. + +Provides a lightweight ConfigContainer for local CLI development +when megatron-bridge isn't installed (requires CUDA to build). + +This allows the CLI to show all training options without needing +a full GPU environment. + +Usage: + The __main__.py will automatically use this stub when + megatron-bridge import fails. +""" + +from dataclasses import dataclass, field +from pathlib import Path + + +@dataclass +class DataConfig: + """Data configuration for training.""" + + data_path: Path | None = None + """Path to blend.json or per-split data args.""" + + mock: bool = False + """Use mock/synthetic data for testing.""" + + seq_length: int = 4096 + """Sequence length for training.""" + + micro_batch_size: int = 1 + """Micro batch size per GPU.""" + + global_batch_size: int = 8 + """Global batch size across all GPUs.""" + + +@dataclass +class ModelConfig: + """Model configuration.""" + + name: str = "nemotron-nano" + """Model name/identifier.""" + + num_layers: int = 32 + """Number of transformer layers.""" + + hidden_size: int = 4096 + """Hidden dimension size.""" + + num_attention_heads: int = 32 + """Number of attention heads.""" + + ffn_hidden_size: int = 14336 + """FFN intermediate size.""" + + vocab_size: int = 128256 + """Vocabulary size.""" + + +@dataclass +class OptimizerConfig: + """Optimizer configuration.""" + + lr: float = 1e-4 + """Learning rate.""" + + min_lr: float = 1e-5 + """Minimum learning rate for scheduler.""" + + weight_decay: float = 0.1 + """Weight decay.""" + + adam_beta1: float = 0.9 + """Adam beta1.""" + + adam_beta2: float = 0.95 + """Adam beta2.""" + + +@dataclass +class TrainingConfig: + """Training configuration.""" + + max_steps: int = 1000 + """Maximum training steps.""" + + log_interval: int = 10 + """Logging interval (steps).""" + + eval_interval: int = 100 + """Evaluation interval (steps).""" + + save_interval: int = 500 + """Checkpoint save interval (steps).""" + + fp16: bool = False + """Use FP16 precision.""" + + bf16: bool = True + """Use BF16 precision.""" + + +@dataclass +class CheckpointConfig: + """Checkpoint configuration.""" + + dir: Path = field(default_factory=lambda: Path("./checkpoints")) + """Checkpoint directory.""" + + save_on_train_end: bool = True + """Save checkpoint at end of training.""" + + resume_from: Path | None = None + """Resume from checkpoint path.""" + + +@dataclass +class ConfigContainer: + """Container for all training configuration. + + This is a stub matching megatron-bridge's ConfigContainer structure + for local CLI development without CUDA. + """ + + data: DataConfig = field(default_factory=DataConfig) + """Data configuration.""" + + model: ModelConfig = field(default_factory=ModelConfig) + """Model configuration.""" + + optimizer: OptimizerConfig = field(default_factory=OptimizerConfig) + """Optimizer configuration.""" + + training: TrainingConfig = field(default_factory=TrainingConfig) + """Training configuration.""" + + checkpoint: CheckpointConfig = field(default_factory=CheckpointConfig) + """Checkpoint configuration.""" diff --git a/src/nemotron/kit/packaging/__init__.py b/src/nemotron/kit/packaging/__init__.py new file mode 100644 index 0000000..939e0e0 --- /dev/null +++ b/src/nemotron/kit/packaging/__init__.py @@ -0,0 +1,27 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# Copyright (c) Nemotron Contributors +# SPDX-License-Identifier: MIT + +"""Packaging helpers for remote execution. + +This subpackage provides nemo-run Packager implementations used to ship code and +configs to remote executors (e.g., Slurm) in a reproducible way. +""" + +from nemotron.kit.packaging.code_packager import CodePackager +from nemotron.kit.packaging.self_contained_packager import SelfContainedPackager + +__all__ = ["CodePackager", "SelfContainedPackager"] diff --git a/src/nemotron/kit/packaging/code_packager.py b/src/nemotron/kit/packaging/code_packager.py new file mode 100644 index 0000000..1bfa87c --- /dev/null +++ b/src/nemotron/kit/packaging/code_packager.py @@ -0,0 +1,154 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# Copyright (c) Nemotron Contributors +# SPDX-License-Identifier: MIT + +"""nemo-run packager that bundles the nemotron repo for remote execution.""" + +from __future__ import annotations + +import tarfile +from dataclasses import dataclass +from pathlib import Path +from subprocess import CalledProcessError + +from nemo_run.core.packaging import Packager + + +@dataclass(kw_only=True) +class CodePackager(Packager): + """Package the repo codebase for remote execution. + + This is intended for recipes that need local imports (e.g. data prep). + It bundles the full repo tree while excluding a small set of directories, + and writes a thin `main.py` launcher that ensures `src/` is on `sys.path`. + """ + + script_path: str + train_path: str + exclude_dirs: tuple[str, ...] = ("usage-cookbook", "use-case-examples") + + def package(self, path: Path, job_dir: str, name: str) -> str: + repo_root = Path(path) + output_file = Path(job_dir) / f"{name}.tar.gz" + if output_file.exists(): + return str(output_file) + + job_dir_path = Path(job_dir).resolve() + launcher = self._build_launcher(repo_root) + + with tarfile.open(output_file, "w:gz") as tf: + tf.addfile(self._tarinfo_for_text("main.py", launcher), self._bytes_io(launcher)) + tf.add(Path(self.train_path), arcname="config.yaml") + + for rel in self._iter_repo_paths(repo_root): + if self._is_excluded(rel): + continue + file_path = repo_root / rel + + # Avoid accidentally packaging local run outputs and the tarball itself. + try: + file_resolved = file_path.resolve() + if job_dir_path == file_resolved or job_dir_path in file_resolved.parents: + continue + except Exception: + pass + + if not file_path.exists(): + continue + tf.add(file_path, arcname=str(rel), recursive=False) + + return str(output_file) + + def _is_excluded(self, rel: Path) -> bool: + parts = rel.parts + for d in self.exclude_dirs: + if parts and parts[0] == d: + return True + return False + + def _build_launcher(self, repo_root: Path) -> str: + script_file = Path(self.script_path) + if not script_file.is_absolute(): + script_file = repo_root / self.script_path + + rel_script = script_file.relative_to(repo_root) + + # The launcher runs in the extracted package root. + # Add `src/` so `import nemotron` works without installation. + # Change working directory to ROOT so ${oc.env:PWD} resolves correctly. + return ( + "from __future__ import annotations\n\n" + "import os\n" + "import runpy\n" + "import sys\n\n" + "ROOT = os.path.dirname(__file__)\n" + "os.chdir(ROOT)\n" + "sys.path.insert(0, ROOT)\n" + "sys.path.insert(0, os.path.join(ROOT, 'src'))\n\n" + f"runpy.run_path(os.path.join(ROOT, {rel_script.as_posix()!r}), run_name='__main__')\n" + ) + + def _iter_repo_paths(self, repo_root: Path): + """Yield repo-relative paths to include. + + Prefer git-aware file listing when available to avoid packaging ignored + run outputs (e.g. output/, artifacts/, wandb/). + """ + git_dir = repo_root / ".git" + if git_dir.exists(): + try: + tracked = self._git_ls_files(repo_root) + others = self._git_ls_files(repo_root, others=True) + yield from sorted({*tracked, *others}) + return + except (CalledProcessError, FileNotFoundError, OSError): + pass + + for p in repo_root.rglob("*"): + yield p.relative_to(repo_root) + + @staticmethod + def _git_ls_files(repo_root: Path, *, others: bool = False) -> list[Path]: + import subprocess + + cmd = ["git", "-C", str(repo_root), "ls-files", "-z"] + if others: + cmd.extend(["--others", "--exclude-standard"]) + + out = subprocess.run(cmd, check=True, stdout=subprocess.PIPE).stdout + result: list[Path] = [] + for chunk in out.split(b"\x00"): + if not chunk: + continue + result.append(Path(chunk.decode("utf-8"))) + return result + + @staticmethod + def _tarinfo_for_text(name: str, text: str) -> tarfile.TarInfo: + info = tarfile.TarInfo(name=name) + data = text.encode("utf-8") + info.size = len(data) + info.mode = 0o644 + return info + + @staticmethod + def _bytes_io(text: str): + import io + + return io.BytesIO(text.encode("utf-8")) + + +__all__ = ["CodePackager"] diff --git a/src/nemotron/kit/packaging/self_contained_packager.py b/src/nemotron/kit/packaging/self_contained_packager.py new file mode 100644 index 0000000..d1557af --- /dev/null +++ b/src/nemotron/kit/packaging/self_contained_packager.py @@ -0,0 +1,579 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# Copyright (c) Nemotron Contributors +# SPDX-License-Identifier: MIT + +"""Self-contained packaging for nemo-run. + +This module provides :class:`~nemotron.kit.packaging.self_contained_packager.SelfContainedPackager`, +which builds a tarball containing only: + +- `main.py`: a single-file script produced by inlining `nemotron.*` imports +- `config.yaml`: the training config (paths should already be rewritten to /nemo_run/code + by ConfigBuilder.save() before this packager runs) +- Any config files referenced in config.yaml (e.g., blend JSON files) + +The AST inliner is intentionally small and conservative: + +- Only `package_prefix` imports are inlined (default: `nemotron`). +- External imports are preserved. +- `from nemotron.x import *` is rejected. +""" + +from __future__ import annotations + +import ast +import os +import tarfile +import tokenize +from dataclasses import dataclass +from pathlib import Path +from typing import Any + +from nemo_run.core.packaging import Packager + + +@dataclass(kw_only=True) +class SelfContainedPackager(Packager): + """Packager that produces a self-contained `main.py` by inlining `nemotron.*` imports. + + Expects config.yaml to already have paths rewritten to /nemo_run/code/... by + ConfigBuilder.save(). Scans for those paths and includes the corresponding + local files in the tarball. + """ + + script_path: str + train_path: str + inline_package: str = "nemotron" + remote_code_dir: str = "/nemo_run/code" + + def package(self, path: Path, job_dir: str, name: str) -> str: + """Create a tarball containing `main.py`, `config.yaml`, and referenced files. + + The train_path config should already have paths rewritten to /nemo_run/code + by ConfigBuilder.save(). This method scans for those paths and includes + the corresponding local files in the tarball. + + Args: + path: Repo root (nemo-run passes cwd for generic packagers). + job_dir: Local staging directory for nemo-run. + name: Package name (used for the tarball filename). + + Returns: + Path to the created tarball. + """ + from io import BytesIO + + from omegaconf import OmegaConf + + repo_root = Path(path) + output_file = os.path.join(job_dir, f"{name}.tar.gz") + # Always regenerate the tarball to pick up code changes. + # The previous caching behavior caused stale code to be used. + if os.path.exists(output_file): + os.remove(output_file) + + staging_dir = Path(job_dir) / "code" + staging_dir.mkdir(parents=True, exist_ok=True) + + script_file = Path(self.script_path) + if not script_file.is_absolute(): + script_file = repo_root / self.script_path + + # Inline nemotron imports into main.py + inlined = inline_imports( + script_file, + repo_root=repo_root, + package_prefix=self.inline_package, + ) + + # Load config (already has paths rewritten to /nemo_run/code) + # Resolve most interpolations, but preserve ${art:...} which requires runtime resolution + config = OmegaConf.load(self.train_path) + config_dict = _to_container_preserve_art(config) + + # Scan config for /nemo_run/code paths and collect corresponding local files + extra_files: list[tuple[str, str]] = [] # (local_path, archive_path) + self._collect_referenced_files(config_dict, repo_root, extra_files) + + # Build tarball manually to include extra files + # On macOS, bsdtar can include AppleDouble `._*` entries unless disabled. + prev = os.environ.get("COPYFILE_DISABLE") + os.environ["COPYFILE_DISABLE"] = "1" + try: + with tarfile.open(output_file, "w:gz") as tf: + # Add main.py + main_info = tarfile.TarInfo(name="main.py") + main_data = inlined.encode("utf-8") + main_info.size = len(main_data) + main_info.mode = 0o644 + tf.addfile(main_info, BytesIO(main_data)) + + # Add config.yaml (copy from train_path which already has rewritten paths) + tf.add(self.train_path, arcname="config.yaml") + + # Add extra referenced files with their relative paths + for local_path, archive_path in extra_files: + if Path(local_path).exists(): + tf.add(local_path, arcname=archive_path) + + return output_file + finally: + if prev is None: + os.environ.pop("COPYFILE_DISABLE", None) + else: + os.environ["COPYFILE_DISABLE"] = prev + + def _collect_referenced_files( + self, obj: Any, repo_root: Path, extra_files: list[tuple[str, str]] + ) -> None: + """Recursively scan config for /nemo_run/code paths and collect local files. + + When paths like /nemo_run/code/src/... are found, the corresponding local + files (repo_root/src/...) are added to extra_files for tarball inclusion. + + Args: + obj: Config object (dict, list, or scalar) + repo_root: Local repository root + extra_files: List to collect (local_path, archive_path) tuples + """ + if isinstance(obj, dict): + for v in obj.values(): + self._collect_referenced_files(v, repo_root, extra_files) + elif isinstance(obj, list): + for v in obj: + self._collect_referenced_files(v, repo_root, extra_files) + elif isinstance(obj, str): + # Check if it's a /nemo_run/code path + if obj.startswith(self.remote_code_dir + "/"): + # Extract relative path after /nemo_run/code/ + rel_path = obj[len(self.remote_code_dir) + 1 :] + local_path = repo_root / rel_path + # If the local file exists, add to extra_files + if local_path.exists() and local_path.is_file(): + extra_files.append((str(local_path), rel_path)) + + +def _to_container_preserve_art(config: Any) -> Any: + """Convert OmegaConf config to container, resolving all interpolations except ${art:...}. + + The ${art:...} interpolations require runtime artifact resolution and must be preserved. + All other interpolations (like ${run.wandb.project}) are resolved at packaging time. + + Args: + config: OmegaConf DictConfig or ListConfig + + Returns: + Plain dict/list with interpolations resolved except ${art:...} + """ + from omegaconf import DictConfig, ListConfig, OmegaConf + + def _convert(obj: Any) -> Any: + if isinstance(obj, DictConfig): + result = {} + for key in obj.keys(): + # Get the raw value to check if it's an ${art:...} interpolation + raw_node = OmegaConf.to_container(obj, resolve=False).get(key) + if isinstance(raw_node, str) and "${art:" in raw_node: + # Preserve ${art:...} interpolations as-is + result[key] = raw_node + else: + # Resolve and convert recursively + try: + result[key] = _convert(obj[key]) + except Exception: + # If resolution fails, keep raw value + result[key] = raw_node + return result + elif isinstance(obj, ListConfig): + return [_convert(item) for item in obj] + else: + return obj + + return _convert(config) + + +def _read_text(path: Path) -> str: + """Read Python source text using `tokenize.open` to honor PEP-263 encodings.""" + with tokenize.open(path) as f: + return f.read() + + +def _node_source(lines: list[str], node: ast.AST) -> str: + """Extract the exact source segment for an AST node (requires lineno metadata).""" + if not hasattr(node, "lineno") or not hasattr(node, "end_lineno"): + return "" + start = int(getattr(node, "lineno")) - 1 + end = int(getattr(node, "end_lineno")) + return "".join(lines[start:end]) + + +def _is_nemotron_import(node: ast.AST, *, package_prefix: str) -> bool: + """Return True if the node is an import from `package_prefix` (import/from-import).""" + if isinstance(node, ast.ImportFrom): + if node.module is None: + return False + return node.module == package_prefix or node.module.startswith(package_prefix + ".") + if isinstance(node, ast.Import): + return any( + a.name == package_prefix or a.name.startswith(package_prefix + ".") for a in node.names + ) + return False + + +def _collect_all_nemotron_imports( + mod_ast: ast.Module, *, package_prefix: str +) -> list[ast.Import | ast.ImportFrom]: + """Collect all nemotron imports from the entire AST tree, including nested scopes. + + Uses ast.walk() to find imports inside functions, classes, conditionals, etc. + """ + imports: list[ast.Import | ast.ImportFrom] = [] + for node in ast.walk(mod_ast): + if isinstance(node, (ast.Import, ast.ImportFrom)): + if _is_nemotron_import(node, package_prefix=package_prefix): + imports.append(node) + return imports + + +class _NemotronImportRemover(ast.NodeTransformer): + """AST transformer that removes nemotron imports from the tree. + + Handles both top-level and nested imports (inside functions, classes, etc.). + Import statements are replaced with `pass` to avoid empty blocks. + """ + + def __init__(self, package_prefix: str): + self.package_prefix = package_prefix + + def visit_Import(self, node: ast.Import) -> ast.AST | None: + if _is_nemotron_import(node, package_prefix=self.package_prefix): + # Replace with pass to avoid empty function bodies + return ast.Pass() + return node + + def visit_ImportFrom(self, node: ast.ImportFrom) -> ast.AST | None: + if _is_nemotron_import(node, package_prefix=self.package_prefix): + # Replace with pass to avoid empty function bodies + return ast.Pass() + return node + + +def _resolve_module_path(repo_root: Path, module: str) -> Path: + """Resolve a module name to a file path under a `src/` layout. + + Supports both: + - `src/.py` + - `src//__init__.py` + """ + base = repo_root / "src" / Path(*module.split(".")) + py = base.with_suffix(".py") + if py.exists(): + return py + init = base / "__init__.py" + if init.exists(): + return init + raise FileNotFoundError(f"Could not resolve module '{module}' under {repo_root / 'src'}") + + +@dataclass +class _ModuleInline: + """Extracted content of a module to inline into the entry script.""" + + module: str + external_imports: list[str] + prelude_assignments: list[str] + body: str + exports: set[str] + + +def _module_exports(mod_ast: ast.Module) -> set[str]: + """Compute names exported by a module (functions/classes/top-level assigns). + + Dunder names are excluded. + """ + exports: set[str] = set() + for node in mod_ast.body: + if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)): + exports.add(node.name) + elif isinstance(node, (ast.Assign, ast.AnnAssign)): + targets = [] + if isinstance(node, ast.Assign): + targets = node.targets + else: + targets = [node.target] + for t in targets: + if isinstance(t, ast.Name): + exports.add(t.id) + return {n for n in exports if n and not (n.startswith("__") and n.endswith("__"))} + + +def _parse_module_for_inlining( + module: str, + *, + repo_root: Path, + package_prefix: str, +) -> tuple[_ModuleInline, list[str]]: + """Parse a module and split it into (inline block, dependency modules). + + Collects dependencies from both top-level and nested imports (inside functions, etc.). + """ + path = _resolve_module_path(repo_root, module) + text = _read_text(path) + lines = text.splitlines(keepends=True) + mod_ast = ast.parse(text, filename=str(path)) + + external_imports: list[str] = [] + body_parts: list[str] = [] + prelude_assignments: list[str] = [] + dependencies: list[str] = [] + + # Collect dependencies from ALL nemotron imports (including nested ones) + all_nemotron_imports = _collect_all_nemotron_imports(mod_ast, package_prefix=package_prefix) + for imp_node in all_nemotron_imports: + if isinstance(imp_node, ast.ImportFrom) and imp_node.module: + if imp_node.module not in dependencies: + dependencies.append(imp_node.module) + for alias in imp_node.names: + if alias.name == "*": + raise ValueError( + f"Star import not supported in SelfContainedPackager: {module}" + ) + elif isinstance(imp_node, ast.Import): + for alias in imp_node.names: + if alias.name not in dependencies: + dependencies.append(alias.name) + + for node in mod_ast.body: + # Never inline/emit __future__ imports from library modules. + if isinstance(node, ast.ImportFrom) and node.module == "__future__": + continue + + if isinstance(node, (ast.Import, ast.ImportFrom)): + if _is_nemotron_import(node, package_prefix=package_prefix): + # Track alias assignments for top-level imports only + if isinstance(node, ast.ImportFrom) and node.module: + for alias in node.names: + if alias.asname and alias.asname != alias.name: + prelude_assignments.append(f"{alias.asname} = {alias.name}\n") + elif isinstance(node, ast.Import): + for alias in node.names: + asname = alias.asname + if asname: + prelude_assignments.append( + f"{asname} = __nemotron_namespaces['{alias.name}']\n" + ) + continue + + external_imports.append(_node_source(lines, node)) + continue + + body_parts.append(_node_source(lines, node)) + + exports = _module_exports(mod_ast) + return ( + _ModuleInline( + module=module, + external_imports=external_imports, + prelude_assignments=prelude_assignments, + body="".join(body_parts), + exports=exports, + ), + dependencies, + ) + + +def inline_imports( + entry_path: Path, + *, + repo_root: Path, + package_prefix: str = "nemotron", +) -> str: + """Inline `package_prefix` imports into a single self-contained script. + + The resulting script: + - removes `import {package_prefix}...` and `from {package_prefix}...` statements + (both top-level and nested inside functions/classes) + - appends source for referenced modules (under `repo_root/src/`) + - synthesizes `types.SimpleNamespace` objects for `import nemotron.x as x` patterns + so that attribute access continues to work. + + Args: + entry_path: The script whose `package_prefix` imports should be inlined. + repo_root: Repo root containing `src/`. + package_prefix: Package prefix to inline (default: `nemotron`). + + Returns: + A Python source string suitable for writing to `main.py`. + """ + + entry_text = _read_text(entry_path) + entry_lines = entry_text.splitlines(keepends=True) + entry_ast = ast.parse(entry_text, filename=str(entry_path)) + + shebang = entry_lines[0] if entry_lines and entry_lines[0].startswith("#!") else "" + + # Preserve module docstring (exact source) if present. + docstring_src = "" + if ( + entry_ast.body + and isinstance(entry_ast.body[0], ast.Expr) + and isinstance(getattr(entry_ast.body[0], "value", None), ast.Constant) + and isinstance(getattr(entry_ast.body[0].value, "value", None), str) + ): + docstring_src = _node_source(entry_lines, entry_ast.body[0]) + + future_imports: list[str] = [] + entry_external_imports: list[str] = [] + entry_body_parts: list[str] = [] + + # These are used to generate alias bindings for removed nemotron imports. + entry_alias_assignments: list[str] = [] + entry_module_aliases: list[tuple[str, str]] = [] # (module, asname) + entry_dependencies: list[str] = [] + + # Collect dependencies from ALL nemotron imports (including nested ones in functions) + all_nemotron_imports = _collect_all_nemotron_imports(entry_ast, package_prefix=package_prefix) + for imp_node in all_nemotron_imports: + if isinstance(imp_node, ast.ImportFrom) and imp_node.module: + if imp_node.module not in entry_dependencies: + entry_dependencies.append(imp_node.module) + for alias in imp_node.names: + if alias.name == "*": + raise ValueError( + f"Star import not supported in SelfContainedPackager: {entry_path}" + ) + elif isinstance(imp_node, ast.Import): + for alias in imp_node.names: + if alias.name not in entry_dependencies: + entry_dependencies.append(alias.name) + + for node in entry_ast.body: + # Skip shebang/docstring handled above. + if node is entry_ast.body[0] and docstring_src: + continue + + if isinstance(node, ast.ImportFrom) and node.module == "__future__": + future_imports.append(_node_source(entry_lines, node)) + continue + + if isinstance(node, (ast.Import, ast.ImportFrom)): + if _is_nemotron_import(node, package_prefix=package_prefix): + # Track alias assignments for top-level imports + if isinstance(node, ast.ImportFrom) and node.module: + for alias in node.names: + if alias.asname and alias.asname != alias.name: + entry_alias_assignments.append(f"{alias.asname} = {alias.name}\n") + elif isinstance(node, ast.Import): + for alias in node.names: + if alias.asname: + entry_module_aliases.append((alias.name, alias.asname)) + continue + + entry_external_imports.append(_node_source(entry_lines, node)) + continue + + # For non-import statements, use AST transformation to remove nested imports + # then unparse back to source. This handles imports inside functions/classes. + remover = _NemotronImportRemover(package_prefix) + transformed_node = remover.visit(node) + ast.fix_missing_locations(transformed_node) + entry_body_parts.append(ast.unparse(transformed_node) + "\n") + + # DFS inline modules with dependencies-first ordering. + module_blocks: dict[str, _ModuleInline] = {} + ordered_modules: list[str] = [] + + def visit(module: str, *, stack: set[str]) -> None: + if module in module_blocks: + return + if module in stack: + return + stack.add(module) + mod_inline, deps = _parse_module_for_inlining( + module, + repo_root=repo_root, + package_prefix=package_prefix, + ) + for dep in deps: + if dep == package_prefix or dep.startswith(package_prefix + "."): + visit(dep, stack=stack) + module_blocks[module] = mod_inline + ordered_modules.append(module) + stack.remove(module) + + for dep in entry_dependencies: + if dep == package_prefix or dep.startswith(package_prefix + "."): + visit(dep, stack=set()) + + need_namespace = bool(ordered_modules) + namespace_prelude = ( + "import types\n__nemotron_namespaces: dict[str, types.SimpleNamespace] = {}\n" + if need_namespace + else "" + ) + + # Generate entry module-alias bindings (these will run after namespaces are built). + for mod, asname in entry_module_aliases: + entry_alias_assignments.append(f"{asname} = __nemotron_namespaces['{mod}']\n") + + # Collect and dedupe external imports from entry + modules. + external_imports: list[str] = [] + seen_imports: set[str] = set() + + def add_imports(import_lines: list[str]) -> None: + for s in import_lines: + key = s.strip() + if not key: + continue + if key not in seen_imports: + external_imports.append(s) + seen_imports.add(key) + + add_imports(entry_external_imports) + for mod in ordered_modules: + add_imports(module_blocks[mod].external_imports) + + # Assemble output. + out: list[str] = [] + if shebang: + out.append(shebang) + if docstring_src: + out.append(docstring_src) + out.extend(future_imports) + out.extend(external_imports) + if namespace_prelude: + out.append(namespace_prelude) + + for mod in ordered_modules: + block = module_blocks[mod] + out.append(f"# --- begin inlined: {block.module} ---\n") + out.extend(block.prelude_assignments) + out.append(block.body) + exports = sorted(block.exports) + if exports: + args = ", ".join(f"{n}={n}" for n in exports) + out.append(f"__nemotron_namespaces['{block.module}'] = types.SimpleNamespace({args})\n") + else: + out.append(f"__nemotron_namespaces['{block.module}'] = types.SimpleNamespace()\n") + out.append(f"# --- end inlined: {block.module} ---\n\n") + + out.extend(entry_alias_assignments) + out.append("".join(entry_body_parts)) + + return "".join(out) + + +__all__ = ["SelfContainedPackager"] diff --git a/src/nemotron/kit/pipeline.py b/src/nemotron/kit/pipeline.py new file mode 100644 index 0000000..5fa3ac2 --- /dev/null +++ b/src/nemotron/kit/pipeline.py @@ -0,0 +1,531 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Pipeline orchestration for nemotron.kit. + +Provides pipeline execution with multiple launcher backends: +- local: Subprocess piping with torchrun (default, for local development) +- nemo-run: NeMo-Run framework with LocalExecutor or SlurmExecutor +- sbatch: Generate and submit raw Slurm batch script + +Example: + >>> from nemotron.kit import Step + >>> from nemotron.kit import PipelineConfig, run_pipeline + >>> + >>> steps = [ + ... Step(name="data_prep", module=data_prep), + ... Step(name="training", module=training, torchrun=True), + ... ] + >>> + >>> config = PipelineConfig(launcher="local", nproc_per_node=8) + >>> exit_code = run_pipeline(config, steps) +""" + +from __future__ import annotations + +import subprocess +import sys +import tempfile +from dataclasses import dataclass, field +from typing import Literal + +from nemotron.kit.step import Step + +Launcher = Literal["local", "nemo-run", "sbatch"] +"""Execution launcher backend: local, nemo-run, or sbatch.""" + + +@dataclass +class PipelineConfig: + """Configuration for pipeline orchestrator. + + Attributes: + launcher: Execution backend ("local", "nemo-run", or "sbatch") + nproc_per_node: Number of processes (GPUs) per node + executor: NeMo-Run executor type ("local" or "slurm") + account: Slurm account name + partition: Slurm partition name + nodes: Number of nodes for distributed training + time: Slurm job time limit (HH:MM:SS) + container_image: Container image path for Slurm jobs + mounts: Container mount points (e.g., '/data:/data') + job_name: Slurm job name + tunnel: Tunnel type for NeMo-Run Slurm executor + host: SSH host for remote job submission + user: SSH user for remote job submission + remote_job_dir: Remote directory for job files (SSH tunnel) + identity: SSH identity file path + env_vars: Environment variables (KEY=VALUE format) + dry_run: Print commands/scripts without executing + detach: Don't wait for job completion (nemo-run only) + verbose: Print progress messages + """ + + # Launcher selection + launcher: Launcher = "local" + """Execution backend: local, nemo-run, or sbatch.""" + + # Local/torchrun settings + nproc_per_node: int = 8 + """Number of processes (GPUs) per node.""" + + # Slurm settings (nemo-run and sbatch) + executor: Literal["local", "slurm"] = "local" + """NeMo-Run executor type.""" + + account: str | None = None + """Slurm account name.""" + + partition: str | None = None + """Slurm partition name.""" + + nodes: int = 1 + """Number of nodes for distributed training.""" + + time: str = "04:00:00" + """Slurm job time limit (HH:MM:SS).""" + + container_image: str | None = None + """Container image path for Slurm jobs.""" + + mounts: list[str] = field(default_factory=list) + """Container mount points (e.g., '/data:/data').""" + + job_name: str = "pipeline" + """Slurm job name.""" + + # NeMo-Run specific + tunnel: Literal["local", "ssh"] = "local" + """Tunnel type for NeMo-Run Slurm executor.""" + + host: str | None = None + """SSH host for remote job submission.""" + + user: str | None = None + """SSH user for remote job submission.""" + + remote_job_dir: str | None = None + """Remote directory for job files (SSH tunnel).""" + + identity: str | None = None + """SSH identity file path.""" + + # Environment + env_vars: list[str] = field(default_factory=list) + """Environment variables (KEY=VALUE format).""" + + # Common + dry_run: bool = False + """Print commands/scripts without executing.""" + + detach: bool = False + """Don't wait for job completion (nemo-run only).""" + + verbose: bool = True + """Print progress messages.""" + + +def run_pipeline( + config: PipelineConfig, + steps: list[Step], + extra_args: list[str] | None = None, +) -> int: + """Run a pipeline of steps. + + Args: + config: Pipeline configuration. + steps: List of steps to execute. + extra_args: Additional args forwarded to steps. + + Returns: + Exit code (0 = success). + """ + if not steps: + _log_error("No steps to run") + return 1 + + # Show plan + step_names = [s.name for s in steps] + _log_info(f"Pipeline: {' -> '.join(step_names)}") + _log_info(f"Launcher: {config.launcher}") + + # Dispatch to launcher + if config.launcher == "local": + return run_local(config, steps, extra_args) + elif config.launcher == "nemo-run": + return run_nemo_run(config, steps, extra_args) + elif config.launcher == "sbatch": + return run_sbatch(config, steps, extra_args) + else: + _log_error(f"Unknown launcher: {config.launcher}") + return 1 + + +# ============================================================================= +# Local Launcher (Subprocess Piping) +# ============================================================================= + + +def run_local( + config: PipelineConfig, + steps: list[Step], + extra_args: list[str] | None = None, +) -> int: + """Execute pipeline locally with subprocess piping. + + Each step's stdout is piped to the next step's stdin. + stderr is passed through for progress/logs. + """ + if not steps: + return 0 + + processes: list[subprocess.Popen] = [] + + try: + prev_stdout = None + + for i, step in enumerate(steps): + cmd = step.get_command(config.nproc_per_node) + if extra_args: + cmd.extend(extra_args) + + if config.verbose: + _log_step_start(step.name, cmd) + + if config.dry_run: + continue + + proc = subprocess.Popen( + cmd, + stdin=prev_stdout, + stdout=subprocess.PIPE if i < len(steps) - 1 else None, + stderr=None, # Pass through to terminal + ) + processes.append(proc) + + # Close previous stdout in parent to allow SIGPIPE + if prev_stdout is not None: + prev_stdout.close() + + prev_stdout = proc.stdout + + if config.dry_run: + return 0 + + # Wait for all processes + exit_codes = [] + for proc in processes: + proc.wait() + exit_codes.append(proc.returncode) + + # Check for failures + for step, code in zip(steps, exit_codes): + if code != 0: + _log_step_error(step.name, code) + return code + + return 0 + + except Exception as e: + _log_error(f"Pipeline failed: {e}") + for proc in processes: + try: + proc.kill() + except Exception: + pass + return 1 + + +# ============================================================================= +# NeMo-Run Launcher +# ============================================================================= + + +def run_nemo_run( + config: PipelineConfig, + steps: list[Step], + extra_args: list[str] | None = None, +) -> int: + """Execute pipeline using NeMo-Run framework.""" + # Handle dry-run without requiring nemo-run + if config.dry_run: + _log_info("NeMo-Run configuration:") + _log_info(f" Executor: {config.executor}") + _log_info(f" Steps: {[s.name for s in steps]}") + _log_info(f" GPUs/node: {config.nproc_per_node}") + if config.executor == "slurm": + _log_info(f" Account: {config.account}") + _log_info(f" Partition: {config.partition}") + _log_info(f" Nodes: {config.nodes}") + _log_info(f" Time: {config.time}") + if config.container_image: + _log_info(f" Container: {config.container_image}") + if config.tunnel == "ssh": + _log_info(f" SSH tunnel: {config.user}@{config.host}") + return 0 + + try: + import nemo_run as run + except ImportError: + _log_error( + "nemo-run not installed. Install with: pip install nemo-run\n" + "Or use --launcher local or --launcher sbatch" + ) + return 1 + + # Parse environment variables + env_vars = {} + for env in config.env_vars: + if "=" in env: + key, value = env.split("=", 1) + env_vars[key] = value + + # Build executor + if config.executor == "local": + executor = run.LocalExecutor( + ntasks_per_node=config.nproc_per_node, + launcher="torchrun", + env_vars=env_vars, + ) + else: # slurm + # Validate required args + if not config.account: + _log_error("--account required for Slurm executor") + return 1 + if not config.partition: + _log_error("--partition required for Slurm executor") + return 1 + + # Build tunnel + if config.tunnel == "ssh": + if not config.host or not config.user: + _log_error("--host and --user required for SSH tunnel") + return 1 + tunnel = run.SSHTunnel( + host=config.host, + user=config.user, + job_dir=config.remote_job_dir, + identity=config.identity, + ) + else: + tunnel = run.LocalTunnel() + + executor = run.SlurmExecutor( + account=config.account, + partition=config.partition, + nodes=config.nodes, + ntasks_per_node=config.nproc_per_node, + gpus_per_node=config.nproc_per_node, + time=config.time, + mem="0", + exclusive=True, + container_image=config.container_image, + container_mounts=config.mounts, + tunnel=tunnel, + env_vars=env_vars, + ) + + # Build and run experiment + with run.Experiment(config.job_name) as exp: + # Inject experiment_id for artifact aliasing across tasks + executor.env_vars["NEMO_EXPERIMENT_ID"] = exp._id + + for step in steps: + # Build script path from module's __file__ + script_path = step.module_file + + task = run.Script(path=script_path) + if extra_args: + task.args = extra_args + + exp.add(task, executor=executor, name=step.name) + + exp.run(detach=config.detach, tail_logs=not config.detach) + + return 0 + + +# ============================================================================= +# Sbatch Launcher +# ============================================================================= + + +def run_sbatch( + config: PipelineConfig, + steps: list[Step], + extra_args: list[str] | None = None, +) -> int: + """Generate and submit Slurm batch script.""" + # Validate required args + if not config.account: + _log_error("--account required for sbatch") + return 1 + if not config.partition: + _log_error("--partition required for sbatch") + return 1 + + script = generate_sbatch_script(config, steps, extra_args) + + if config.dry_run: + print(script) + return 0 + + # Write to temp file and submit + with tempfile.NamedTemporaryFile(mode="w", suffix=".sh", delete=False, prefix="pipeline_") as f: + f.write(script) + script_path = f.name + + _log_info(f"Generated script: {script_path}") + _log_info("Submitting to Slurm...") + + result = subprocess.run( + ["sbatch", script_path], + capture_output=True, + text=True, + ) + + if result.returncode == 0: + _log_info(result.stdout.strip()) + else: + _log_error(f"sbatch failed: {result.stderr}") + + return result.returncode + + +def generate_sbatch_script( + config: PipelineConfig, + steps: list[Step], + extra_args: list[str] | None = None, +) -> str: + """Generate sbatch script for pipeline.""" + # Build SBATCH directives + directives = [ + f"#SBATCH --job-name={config.job_name}", + f"#SBATCH --account={config.account}", + f"#SBATCH --partition={config.partition}", + f"#SBATCH --nodes={config.nodes}", + f"#SBATCH --ntasks-per-node={config.nproc_per_node}", + f"#SBATCH --gpus-per-node={config.nproc_per_node}", + f"#SBATCH --time={config.time}", + "#SBATCH --exclusive", + ] + + # Build environment exports + env_exports = [ + "export TORCH_NCCL_AVOID_RECORD_STREAMS=1", + "export NCCL_NVLS_ENABLE=0", + ] + + for env in config.env_vars: + if "=" in env: + env_exports.append(f"export {env}") + + # Build pipeline commands + pipeline_commands = generate_pipeline_commands(config, steps, extra_args) + + return f"""#!/bin/bash +{chr(10).join(directives)} + +# Environment setup +{chr(10).join(env_exports)} + +# Optional: Uncomment for debugging +# export CUDA_DEVICE_MAX_CONNECTIONS=1 +# export NCCL_DEBUG=INFO + +echo "Starting pipeline on $(hostname)" +echo "Job ID: $SLURM_JOB_ID" +echo "Nodes: $SLURM_JOB_NUM_NODES" +echo "GPUs per node: $SLURM_GPUS_PER_NODE" + +# Pipeline execution +{pipeline_commands} + +echo "Pipeline complete" +""" + + +def generate_pipeline_commands( + config: PipelineConfig, + steps: list[Step], + extra_args: list[str] | None = None, +) -> str: + """Generate pipeline execution commands for sbatch script.""" + commands = [] + extra_args_str = " ".join(extra_args) if extra_args else "" + + for i, step in enumerate(steps): + srun_cmd = step.get_srun_command( + config.nproc_per_node, + config.container_image, + config.mounts, + ) + + if extra_args_str: + srun_cmd = f"{srun_cmd} {extra_args_str}" + + # For piped steps, capture output to temp file + if i == 0 and len(steps) > 1: + # First step: output to temp file for next step + commands.append(f'echo "Step: {step.name}"') + commands.append(f"STEP_OUTPUT=$({srun_cmd})") + commands.append(f'if [ $? -ne 0 ]; then echo "Step {step.name} failed"; exit 1; fi') + elif i < len(steps) - 1: + # Middle steps: read from prev, output for next + commands.append(f'echo "Step: {step.name}"') + commands.append(f'STEP_OUTPUT=$(echo "$STEP_OUTPUT" | {srun_cmd})') + commands.append(f'if [ $? -ne 0 ]; then echo "Step {step.name} failed"; exit 1; fi') + else: + # Last step (or single step): normal execution + commands.append(f'echo "Step: {step.name}"') + if len(steps) > 1: + commands.append(f'echo "$STEP_OUTPUT" | {srun_cmd}') + else: + commands.append(srun_cmd) + commands.append(f'if [ $? -ne 0 ]; then echo "Step {step.name} failed"; exit 1; fi') + + return "\n".join(commands) + + +# ============================================================================= +# Logging Helpers +# ============================================================================= + + +def _log_step_start(name: str, cmd: list[str]) -> None: + """Log step start to stderr.""" + cmd_str = " ".join(cmd) + sys.stderr.write(f"\n{'=' * 60}\n") + sys.stderr.write(f"[pipeline] Starting: {name}\n") + sys.stderr.write(f"[pipeline] Command: {cmd_str}\n") + sys.stderr.write(f"{'=' * 60}\n\n") + sys.stderr.flush() + + +def _log_step_error(name: str, code: int) -> None: + """Log step failure to stderr.""" + sys.stderr.write(f"\n[pipeline] ERROR: Step '{name}' failed with exit code {code}\n") + sys.stderr.flush() + + +def _log_error(msg: str) -> None: + """Log error to stderr.""" + sys.stderr.write(f"[pipeline] ERROR: {msg}\n") + sys.stderr.flush() + + +def _log_info(msg: str) -> None: + """Log info to stderr.""" + sys.stderr.write(f"[pipeline] {msg}\n") + sys.stderr.flush() diff --git a/src/nemotron/kit/recipe_loader.py b/src/nemotron/kit/recipe_loader.py new file mode 100644 index 0000000..e117822 --- /dev/null +++ b/src/nemotron/kit/recipe_loader.py @@ -0,0 +1,60 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# Copyright (c) Nemotron Contributors +# SPDX-License-Identifier: MIT + +"""Helpers for loading recipe callables and extracting config-driven kwargs.""" + +from __future__ import annotations + +import importlib +from collections.abc import Callable +from typing import Any + +from omegaconf import DictConfig, OmegaConf + + +def import_recipe_function(target: str) -> Callable[..., Any]: + """Import a recipe function from a fully-qualified target string.""" + module_path, function_name = target.rsplit(".", 1) + module = importlib.import_module(module_path) + try: + return getattr(module, function_name) + except AttributeError as e: + raise AttributeError(f"Failed to import recipe '{target}': {e}") from e + + +def extract_recipe_config( + config: DictConfig, + *, + default_target: str, +) -> tuple[str, dict[str, Any]]: + """Extract recipe target + kwargs from a config. + + Expects: + recipe: + _target_: some.module.func + : kwargs + """ + if "recipe" not in config: + return default_target, {} + + recipe_dict = OmegaConf.to_container(config.recipe, resolve=True) + if not isinstance(recipe_dict, dict): + return default_target, {} + + target = str(recipe_dict.pop("_target_", default_target)) + kwargs = recipe_dict + return target, kwargs diff --git a/src/nemotron/kit/registry.py b/src/nemotron/kit/registry.py new file mode 100644 index 0000000..924ea11 --- /dev/null +++ b/src/nemotron/kit/registry.py @@ -0,0 +1,456 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +""" +Artifact registry for nemotron.kit. + +Manages artifact versions, aliases, and storage locations using fsspec or W&B backends. +""" + +import json +import shutil +from dataclasses import dataclass, field +from datetime import datetime +from pathlib import Path +from typing import Any + +from nemotron.kit.exceptions import ArtifactNotFoundError, ArtifactVersionNotFoundError + + +@dataclass +class ArtifactVersion: + """A specific version of an artifact.""" + + version: int + path: str # Can be local path or remote URL + created_at: str + metadata: dict[str, Any] = field(default_factory=dict) + + +@dataclass +class ArtifactEntry: + """Registry entry for an artifact with all its versions.""" + + name: str + versions: list[ArtifactVersion] = field(default_factory=list) + aliases: dict[str, int] = field(default_factory=dict) # alias -> version number + + def latest_version(self) -> ArtifactVersion | None: + """Get the latest version.""" + if not self.versions: + return None + return max(self.versions, key=lambda v: v.version) + + def get_version(self, version: int) -> ArtifactVersion | None: + """Get a specific version.""" + for v in self.versions: + if v.version == version: + return v + return None + + def to_dict(self) -> dict[str, Any]: + """Serialize to dictionary.""" + return { + "name": self.name, + "versions": [ + { + "version": v.version, + "path": v.path, + "created_at": v.created_at, + "metadata": v.metadata, + } + for v in self.versions + ], + "aliases": self.aliases, + } + + @classmethod + def from_dict(cls, data: dict[str, Any]) -> "ArtifactEntry": + """Deserialize from dictionary.""" + versions = [ + ArtifactVersion( + version=v["version"], + path=v["path"], + created_at=v["created_at"], + metadata=v.get("metadata", {}), + ) + for v in data.get("versions", []) + ] + return cls( + name=data["name"], + versions=versions, + aliases=data.get("aliases", {}), + ) + + +class ArtifactRegistry: + """Registry for managing artifact versions and storage. + + Supports two backends: + - fsspec: Stores artifacts in a filesystem (local, S3, GCS, etc.) + - wandb: Uses W&B artifacts for storage and versioning + + Example: + >>> from nemotron.kit import init + >>> init(backend="fsspec", root="/data/artifacts") + >>> + >>> from nemotron.kit.registry import get_registry + >>> registry = get_registry() + >>> version = registry.publish("my-dataset", Path("/tmp/data")) + >>> local_path = registry.resolve("my-dataset", version=1) + """ + + def __init__( + self, + backend: str = "fsspec", + root: str | Path | None = None, + wandb_project: str | None = None, + wandb_entity: str | None = None, + ) -> None: + """Initialize the registry. + + Args: + backend: Storage backend ("fsspec" or "wandb") + root: Root path for fsspec backend (required for fsspec) + wandb_project: W&B project name (required for wandb) + wandb_entity: W&B entity/team name (optional for wandb) + """ + self.backend = backend + self.root = Path(root) if root else None + self.wandb_project = wandb_project + self.wandb_entity = wandb_entity + + # In-memory cache of registry entries + self._entries: dict[str, ArtifactEntry] = {} + + if backend == "fsspec": + if not self.root: + raise ValueError("root is required for fsspec backend") + self.root.mkdir(parents=True, exist_ok=True) + self._load_index() + elif backend == "wandb": + if not self.wandb_project: + raise ValueError("wandb_project is required for wandb backend") + try: + import wandb + + self._wandb = wandb + except ImportError: + raise ImportError( + "wandb is required for wandb backend. Install with: pip install wandb" + ) + + def _index_path(self) -> Path: + """Get path to registry index file.""" + return self.root / ".art_index.json" + + def _load_index(self) -> None: + """Load registry index from disk.""" + index_path = self._index_path() + if index_path.exists(): + with open(index_path) as f: + data = json.load(f) + self._entries = {name: ArtifactEntry.from_dict(entry) for name, entry in data.items()} + + def _save_index(self) -> None: + """Save registry index to disk.""" + index_path = self._index_path() + data = {name: entry.to_dict() for name, entry in self._entries.items()} + + # Atomic write + temp_path = index_path.with_suffix(".tmp") + with open(temp_path, "w") as f: + json.dump(data, f, indent=2) + temp_path.rename(index_path) + + def publish( + self, + name: str, + source_path: Path, + metadata: dict[str, Any] | None = None, + ) -> ArtifactVersion: + """Publish a new version of an artifact. + + Args: + name: Artifact name + source_path: Local path to artifact directory + metadata: Optional metadata to attach + + Returns: + The new ArtifactVersion + """ + if self.backend == "fsspec": + return self._publish_fsspec(name, source_path, metadata) + elif self.backend == "wandb": + return self._publish_wandb(name, source_path, metadata) + else: + raise ValueError(f"Unknown backend: {self.backend}") + + def _publish_fsspec( + self, + name: str, + source_path: Path, + metadata: dict[str, Any] | None = None, + ) -> ArtifactVersion: + """Publish using fsspec backend.""" + # Get or create entry + entry = self._entries.get(name) + if entry is None: + entry = ArtifactEntry(name=name) + self._entries[name] = entry + + # Determine next version + latest = entry.latest_version() + next_version = (latest.version + 1) if latest else 1 + + # Create version directory + version_dir = self.root / name / f"v{next_version}" + version_dir.mkdir(parents=True, exist_ok=True) + + # Copy artifact to registry + if source_path.is_dir(): + # Copy directory contents + for item in source_path.iterdir(): + dest = version_dir / item.name + if item.is_dir(): + shutil.copytree(item, dest) + else: + shutil.copy2(item, dest) + else: + # Copy single file + shutil.copy2(source_path, version_dir / source_path.name) + + # Create version entry + version = ArtifactVersion( + version=next_version, + path=str(version_dir), + created_at=datetime.now().astimezone().isoformat(), + metadata=metadata or {}, + ) + entry.versions.append(version) + + # Update latest alias + entry.aliases["latest"] = next_version + + # Save index + self._save_index() + + return version + + def _publish_wandb( + self, + name: str, + source_path: Path, + metadata: dict[str, Any] | None = None, + ) -> ArtifactVersion: + """Publish using W&B backend with URI references. + + Uses add_reference() instead of add_dir() to track artifact location + without uploading content. This enables lineage tracking via URIs. + """ + # Create W&B artifact + artifact = self._wandb.Artifact( + name=name, + type="artifact", + metadata=metadata or {}, + ) + + # Use URI reference instead of uploading content + # This tracks the artifact location for lineage without copying data + source_uri = f"file://{source_path.resolve()}" + try: + artifact.add_reference( + source_uri, + name="artifact", + checksum=True, + ) + except Exception: + # Fallback to add_dir/add_file if reference fails + if source_path.is_dir(): + artifact.add_dir(str(source_path)) + else: + artifact.add_file(str(source_path)) + + # Log artifact (requires active run or creates one) + if self._wandb.run is None: + # Initialize a run for artifact logging + run = self._wandb.init( + project=self.wandb_project, + entity=self.wandb_entity, + job_type="artifact-publish", + ) + logged = run.log_artifact(artifact) + logged.wait() + run.finish() + else: + logged = self._wandb.run.log_artifact(artifact) + logged.wait() + + # Create version entry + entity = self.wandb_entity or logged.entity + art_path = f"{entity}/{self.wandb_project}/{name}:{logged.version}" + version = ArtifactVersion( + version=int(logged.version.lstrip("v")), + path=art_path, + created_at=datetime.now().astimezone().isoformat(), + metadata=metadata or {}, + ) + + return version + + def resolve(self, name: str, version: int | str | None = None) -> Path: + """Resolve artifact to local path. + + Args: + name: Artifact name + version: Version number, alias string, or None for latest + + Returns: + Local path to artifact + + Raises: + ArtifactNotFoundError: If artifact doesn't exist + ArtifactVersionNotFoundError: If version doesn't exist + """ + if self.backend == "fsspec": + return self._resolve_fsspec(name, version) + elif self.backend == "wandb": + return self._resolve_wandb(name, version) + else: + raise ValueError(f"Unknown backend: {self.backend}") + + def _resolve_fsspec(self, name: str, version: int | str | None = None) -> Path: + """Resolve using fsspec backend.""" + entry = self._entries.get(name) + if entry is None: + raise ArtifactNotFoundError(name) + + if version is None: + # Get latest + artifact_version = entry.latest_version() + if artifact_version is None: + raise ArtifactVersionNotFoundError(name, "latest") + elif isinstance(version, str): + # String: treat as alias + if version == "latest": + artifact_version = entry.latest_version() + elif version in entry.aliases: + resolved_version = entry.aliases[version] + artifact_version = entry.get_version(resolved_version) + else: + raise ArtifactVersionNotFoundError(name, version) + if artifact_version is None: + raise ArtifactVersionNotFoundError(name, version) + else: + # Integer: direct version lookup + artifact_version = entry.get_version(version) + if artifact_version is None: + raise ArtifactVersionNotFoundError(name, version) + + return Path(artifact_version.path) + + def _resolve_wandb(self, name: str, version: int | str | None = None) -> Path: + """Resolve using W&B backend.""" + # Build artifact reference + if version is None: + ref = f"{name}:latest" + elif isinstance(version, str): + # String alias - W&B handles natively + ref = f"{name}:{version}" + else: + ref = f"{name}:v{version}" + + if self.wandb_entity: + ref = f"{self.wandb_entity}/{self.wandb_project}/{ref}" + else: + ref = f"{self.wandb_project}/{ref}" + + # Download artifact + try: + api = self._wandb.Api() + artifact = api.artifact(ref) + local_path = artifact.download() + return Path(local_path) + except Exception as e: + if "not found" in str(e).lower(): + if version is None: + raise ArtifactNotFoundError(name) + else: + raise ArtifactVersionNotFoundError(name, version) + raise + + def get(self, name: str) -> ArtifactEntry | None: + """Get artifact entry by name.""" + if self.backend == "fsspec": + return self._entries.get(name) + elif self.backend == "wandb": + # For W&B, we'd need to query the API + # Return None for now - resolve() handles the actual lookup + return None + return None + + def list(self) -> list[str]: + """List all artifact names.""" + if self.backend == "fsspec": + return list(self._entries.keys()) + elif self.backend == "wandb": + # Would need to query W&B API + return [] + return [] + + def alias(self, name: str, alias: str, version: int) -> None: + """Create an alias for a specific version. + + Args: + name: Artifact name + alias: Alias name (e.g., "production", "staging") + version: Version number to alias + """ + if self.backend == "fsspec": + entry = self._entries.get(name) + if entry is None: + raise ArtifactNotFoundError(name) + + if entry.get_version(version) is None: + raise ArtifactVersionNotFoundError(name, version) + + entry.aliases[alias] = version + self._save_index() + elif self.backend == "wandb": + # W&B has its own alias system + api = self._wandb.Api() + artifact = api.artifact(f"{self.wandb_project}/{name}:v{version}") + artifact.aliases.append(alias) + artifact.save() + + +# Global registry instance +_registry: ArtifactRegistry | None = None + + +def get_registry() -> ArtifactRegistry: + """Get the global artifact registry. + + Raises: + RuntimeError: If kit.init() hasn't been called + """ + if _registry is None: + raise RuntimeError("Artifact registry not initialized. Call kit.init() first.") + return _registry + + +def set_registry(registry: ArtifactRegistry | None) -> None: + """Set the global artifact registry.""" + global _registry + _registry = registry diff --git a/src/nemotron/kit/resolvers.py b/src/nemotron/kit/resolvers.py new file mode 100644 index 0000000..e291444 --- /dev/null +++ b/src/nemotron/kit/resolvers.py @@ -0,0 +1,774 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# Copyright (c) Nemotron Contributors +# SPDX-License-Identifier: MIT + +"""OmegaConf custom resolvers for artifact resolution. + +This module provides resolvers that can be used in config files to resolve +artifact paths at runtime, enabling W&B lineage tracking when running inside +containers. + +Usage in config YAML: + run: + data: DataBlendsArtifact-pretrain + model: ModelArtifact-pretrain:v5 + + recipe: + per_split_data_args_path: ${art.data.path} + checkpoint_path: ${art.model.path}/model.pt + +Usage in training script: + from nemotron.kit.resolvers import register_resolvers + + # Register resolvers before loading config + register_resolvers(artifacts={ + "data": "DataBlendsArtifact-pretrain", + "model": "ModelArtifact-pretrain:v5", + }) + + # Now load config - ${art.X.path} will resolve with W&B lineage + config = OmegaConf.load("train.yaml") +""" + +from __future__ import annotations + +import hashlib +import json +import os +import time +from pathlib import Path +from typing import Any, Literal + +from omegaconf import OmegaConf + +# Global artifact registry for the resolver. +# Keys are user-facing (e.g. "data") and values are resolved artifact info. +_ARTIFACT_REGISTRY: dict[str, dict[str, Any]] = {} + +# Internal cache for de-duplicating resolution work. +_ARTIFACT_CACHE: dict[str, dict[str, Any]] = {} + +ResolverMode = Literal["active_run", "pre_init"] + + +def _parse_artifact_ref(artifact_ref: str) -> tuple[str, str | None]: + if ":" in artifact_ref: + name, version = artifact_ref.rsplit(":", 1) + return name, version + return artifact_ref, None + + +def _normalize_version(version: str | None) -> str: + if version is None: + return "latest" + if version == "latest": + return "latest" + if version.startswith("v"): + return version + if version.isdigit(): + return f"v{version}" + return version + + +def _get_distributed_info() -> tuple[int, int]: + """Get rank and world_size from torchrun environment variables. + + Returns: + Tuple of (rank, world_size). Defaults to (0, 1) for single-process runs. + """ + rank = int(os.environ.get("RANK", "0")) + world_size = int(os.environ.get("WORLD_SIZE", "1")) + return rank, world_size + + +def _get_job_id() -> str: + """Get a unique job identifier for the current run. + + Priority order: + 1. NEMO_EXPERIMENT_ID - unique per nemo-run execution (most reliable) + 2. SLURM_JOB_ID - unique per Slurm job + 3. TORCHELASTIC_RUN_ID + hostname - unique per torchrun execution + + Returns: + Unique job identifier string. + """ + # Prefer NEMO_EXPERIMENT_ID - set by nemo-run, unique per execution + nemo_exp_id = os.environ.get("NEMO_EXPERIMENT_ID") + if nemo_exp_id: + return f"nemo_{nemo_exp_id}" + + # Fall back to Slurm job ID if available + slurm_job_id = os.environ.get("SLURM_JOB_ID") + if slurm_job_id: + return f"slurm_{slurm_job_id}" + + # Fall back to hostname + parent PID (the torchrun launcher PID) + # This ensures all workers in the same job get the same ID + import socket + + hostname = socket.gethostname() + # Use TORCHELASTIC_RUN_ID if available (set by torchrun) + run_id = os.environ.get("TORCHELASTIC_RUN_ID", str(os.getppid())) + return f"{hostname}_{run_id}" + + +def _get_marker_path(artifacts: dict[str, str]) -> Path: + """Generate a unique marker file path based on artifact references AND job ID. + + Uses NEMO_RUN_DIR (shared filesystem) if available for multi-node jobs, + otherwise falls back to TMPDIR or /tmp. + + The marker path now includes a job identifier to prevent stale marker files + from previous runs being read by workers in the current run. + + Args: + artifacts: Dict of artifact key -> artifact reference. + + Returns: + Path to marker file on shared or local storage. + """ + # Hash the artifacts dict to create a unique marker per config + artifacts_str = json.dumps(sorted(artifacts.items())) + hash_suffix = hashlib.md5(artifacts_str.encode()).hexdigest()[:8] + + # Include job ID to prevent reading stale marker files from previous runs + job_id = _get_job_id() + + # Prefer NEMO_RUN_DIR (shared filesystem) for multi-node jobs + # Fall back to TMPDIR or /tmp for single-node or local runs + base_dir = os.environ.get("NEMO_RUN_DIR") or os.environ.get("TMPDIR", "/tmp") + return Path(base_dir) / f".nemotron_artifacts_{hash_suffix}_{job_id}" + + +def _wait_for_artifacts(marker_path: Path, timeout: int = 600) -> dict[str, Any]: + """Wait for rank 0 to complete artifact downloads and read results. + + Args: + marker_path: Path to marker file written by rank 0. + timeout: Maximum seconds to wait (default: 600 = 10 minutes). + + Returns: + Dict with "results" and "qualified_names" from rank 0. + + Raises: + TimeoutError: If rank 0 doesn't complete within timeout. + """ + start = time.time() + while not marker_path.exists(): + if time.time() - start > timeout: + raise TimeoutError( + f"Timeout waiting for rank 0 to download artifacts (marker: {marker_path})" + ) + time.sleep(1.0) + + # Read the artifact data written by rank 0 + data = json.loads(marker_path.read_text()) + return data + + +def _resolve_artifact_active_run(name: str, version: str | None = None) -> dict[str, Any]: + """Resolve an artifact and cache the result. + + Args: + name: Artifact name (e.g., "DataBlendsArtifact-pretrain") + version: Optional version (e.g., "v5" or "5"). If None, uses latest. + + Returns: + Dict with artifact info: {"path": str, "version": int, "name": str} + """ + # Build cache key + cache_key = f"active:{name}:{_normalize_version(version)}" + + if cache_key in _ARTIFACT_CACHE: + return _ARTIFACT_CACHE[cache_key] + + import wandb + + artifact_ref = f"{name}:{_normalize_version(version)}" + + # Use artifact - this registers lineage in W&B + artifact = wandb.use_artifact(artifact_ref) + + # Download/get local path + local_path = artifact.download() + + result = { + "path": local_path, + "version": artifact.version, + "name": artifact.name, + "type": artifact.type, + "qualified_name": getattr(artifact, "qualified_name", None), + } + + _ARTIFACT_CACHE[cache_key] = result + + return result + + +def resolve_artifact_pre_init( + artifact_ref: str, + *, + entity: str | None = None, + project: str | None = None, + patch_http_digest: bool = False, +) -> dict[str, Any]: + """Resolve a W&B artifact via `wandb.Api()` without requiring an active run. + + This is used in training scripts where `wandb.init()` is handled elsewhere + (e.g. Megatron-Bridge). It returns `qualified_name` so lineage can be + registered once a run becomes active. + """ + import logging + + logger = logging.getLogger(__name__) + + name, version = _parse_artifact_ref(artifact_ref) + version_str = _normalize_version(version) + + # Don't cache :latest lookups - always fetch fresh to get actual latest version + # Only cache explicit version references (v1, v2, etc.) + use_cache = version_str != "latest" + cache_key = ( + f"pre_init:{name}:{version_str}:{entity or ''}:{project or ''}:{int(patch_http_digest)}" + ) + + if use_cache and cache_key in _ARTIFACT_CACHE: + return _ARTIFACT_CACHE[cache_key] + + import wandb + + if patch_http_digest: + try: + from nemotron.kit.wandb import patch_wandb_http_handler_skip_digest_verification + + patch_wandb_http_handler_skip_digest_verification() + except Exception: + # Best-effort: do not fail artifact resolution because patching failed. + pass + + # Clear any W&B internal caches to ensure fresh artifact lookups + # This is important when resolving :latest to get the actual latest version + try: + # Clear the artifact cache directory state if possible + if hasattr(wandb, "_artifacts_cache"): + wandb._artifacts_cache = None + except Exception: + pass + + # Create fresh API instance for each lookup + # timeout=30 ensures reasonable API response time + api = wandb.Api(timeout=30) + + resolved_entity = entity or os.environ.get("WANDB_ENTITY") + resolved_project = project or os.environ.get("WANDB_PROJECT") or "nemotron" + + # Fully-qualified path is typically entity/project/name:version. + # Keep compatibility with earlier behavior that allowed omitting entity. + if resolved_entity: + full_ref = f"{resolved_entity}/{resolved_project}/{name}:{version_str}" + else: + full_ref = f"{resolved_project}/{name}:{version_str}" + + # Use print for critical debug info (logger may not be configured yet) + print(f"[ARTIFACT] Resolving artifact: {full_ref} (requested version: {version_str})") + logger.info(f"[ARTIFACT] Resolving artifact: {full_ref}") + + # Fetch artifact metadata fresh from W&B API (no caching at API level) + # Note: api.artifact() makes a fresh network request each time + artifact = api.artifact(full_ref) + + # Log which version :latest actually resolved to + print(f"[ARTIFACT] W&B resolved to version: {artifact.version} (qualified: {artifact.qualified_name})") + logger.info(f"[ARTIFACT] Resolved to version: {artifact.version} (qualified: {artifact.qualified_name})") + + local_path = artifact.download(skip_cache=True) + + logger.info(f"[ARTIFACT] Downloaded to: {local_path}") + + # Check if artifact contains file:// references (e.g., model checkpoints on shared storage) + # If so, extract the actual path from the reference instead of using the W&B download path + reference_path = None + try: + # First check if artifact metadata has absolute_path (preferred for cross-job access) + artifact_metadata = artifact.metadata or {} + if "absolute_path" in artifact_metadata: + reference_path = artifact_metadata["absolute_path"] + print(f"[ARTIFACT] Found absolute_path in metadata: {reference_path}") + logger.info(f"[ARTIFACT] Using absolute_path from metadata: {reference_path}") + + # Handle legacy artifacts where absolute_path points to iter_XXXXXX directory + # instead of the save_dir. Megatron-Bridge expects pretrained_checkpoint to be + # the save_dir, and uses ckpt_step to determine which iteration to load. + # For legacy artifacts, extract the iteration and normalize path to save_dir. + import re + path_obj = Path(reference_path) + iter_match = re.match(r"^iter_(\d+)$", path_obj.name) + if iter_match: + # Extract iteration from path (legacy artifact) + extracted_iteration = int(iter_match.group(1)) + # Normalize to save_dir (parent) + reference_path = str(path_obj.parent) + print(f"[ARTIFACT] Legacy artifact: extracted iteration={extracted_iteration}, normalized path to save_dir: {reference_path}") + logger.info(f"[ARTIFACT] Normalized iter_XXXXXX path to parent save_dir: {reference_path}") + # Store extracted iteration in metadata for ${art:model,iteration} resolver + # Only if not already present (don't override actual metadata) + if "iteration" not in artifact_metadata: + artifact_metadata["iteration"] = extracted_iteration + else: + # Fall back to extracting from file:// references + manifest = artifact.manifest + if manifest and hasattr(manifest, "entries"): + entries = manifest.entries + # Look for file:// references in the manifest + for entry_name, entry in entries.items(): + if hasattr(entry, "ref") and entry.ref and entry.ref.startswith("file://"): + # Extract the path from the file:// URI + ref_path = entry.ref[7:] # Remove "file://" prefix + # Get the parent directory (checkpoint directory) + ref_dir = str(Path(ref_path).parent) + + # Map /nemo_run/ paths to actual Lustre path using NEMO_RUN_DIR + # This handles artifacts created with container mount paths + nemo_run_dir = os.environ.get("NEMO_RUN_DIR") + if nemo_run_dir and nemo_run_dir != "/nemo_run": + if ref_dir.startswith("/nemo_run/"): + ref_dir = ref_dir.replace("/nemo_run/", f"{nemo_run_dir}/", 1) + elif ref_dir.startswith("/nemo_run"): + ref_dir = ref_dir.replace("/nemo_run", nemo_run_dir, 1) + + if reference_path is None: + reference_path = ref_dir + print(f"[ARTIFACT] Found file reference, using path: {reference_path}") + logger.info(f"[ARTIFACT] Found file reference: {entry.ref} -> {reference_path}") + break + except Exception as e: + logger.warning(f"[ARTIFACT] Could not check for references: {e}") + + # Use reference path if available, otherwise use download path + effective_path = reference_path if reference_path else local_path + + # Log contents of downloaded artifact directory + local_path_obj = Path(local_path) + if local_path_obj.exists(): + try: + contents = list(local_path_obj.iterdir()) + logger.info(f"[ARTIFACT] Contents: {[f.name for f in contents]}") + + # Check for metadata.json specifically + metadata_path = local_path_obj / "metadata.json" + if metadata_path.exists(): + logger.info(f"[ARTIFACT] metadata.json found at {metadata_path}") + else: + logger.warning(f"[ARTIFACT] metadata.json NOT found at {metadata_path}") + # List all files recursively to help debug + all_files = list(local_path_obj.rglob("*")) + logger.info(f"[ARTIFACT] All files (recursive): {[str(f) for f in all_files[:20]]}") + except Exception as e: + logger.warning(f"[ARTIFACT] Could not list directory: {e}") + else: + logger.warning(f"[ARTIFACT] Download path does not exist: {local_path}") + + result = { + "path": effective_path, + "version": getattr(artifact, "version", None), + "name": getattr(artifact, "name", name), + "type": getattr(artifact, "type", None), + "qualified_name": getattr(artifact, "qualified_name", None), + # Store the W&B download path separately for metadata access + # This is needed when the effective_path is a file reference to shared storage + # but metadata.json was uploaded to W&B + "metadata_dir": local_path, + } + + # Include iteration from artifact metadata (for model checkpoint artifacts) + # This is used by ${art:model,iteration} resolver to set checkpoint.ckpt_step + # Check artifact_metadata (which may have been updated with extracted iteration from path) + # or fall back to the original W&B artifact metadata + iteration = artifact_metadata.get("iteration") + if iteration is None: + # Check original W&B artifact metadata + original_metadata = artifact.metadata or {} + iteration = original_metadata.get("iteration") + if iteration is not None: + result["iteration"] = iteration + print(f"[ARTIFACT] Stored iteration={result['iteration']} for resolver access") + + # Only cache explicit version lookups, not :latest + if use_cache: + _ARTIFACT_CACHE[cache_key] = result + return result + + +def _read_artifact_metadata(artifact_path: str) -> dict[str, Any]: + """Read metadata.json from an artifact directory. + + Args: + artifact_path: Path to the artifact directory. + + Returns: + Parsed metadata dict, or empty dict if not found. + """ + import logging + + logger = logging.getLogger(__name__) + + artifact_path_obj = Path(artifact_path) + metadata_path = artifact_path_obj / "metadata.json" + + logger.info(f"Looking for metadata.json at: {metadata_path}") + logger.info(f"Artifact path exists: {artifact_path_obj.exists()}") + + if artifact_path_obj.exists(): + try: + contents = list(artifact_path_obj.iterdir()) + logger.info(f"Contents of artifact directory: {[f.name for f in contents]}") + except Exception as e: + logger.warning(f"Could not list artifact directory: {e}") + + if metadata_path.exists(): + logger.info(f"metadata.json found, reading...") + return json.loads(metadata_path.read_text()) + + logger.warning(f"metadata.json NOT found at {metadata_path}") + return {} + + +def _art_resolver(name: str, field: str = "path") -> Any: + """OmegaConf resolver for ${art:NAME,FIELD} syntax. + + Args: + name: Artifact key from run.artifacts (e.g., "data", "model") + field: Field to return (default: "path"). Options: + - path, version, name, type: Basic artifact fields + - Any field from metadata.json (e.g., pack_size, training_path) + - metadata.X: Explicit metadata field access (legacy syntax) + + Returns: + The requested field value (preserves original type: int, float, str, etc.) + + Examples: + ${art:data,path} -> /path/to/artifact (str) + ${art:data,pack_size} -> 4096 (int from metadata.json) + ${art:data,training_path} -> /path/to/training_4096.npy (str) + ${art:data,metadata.pack_size} -> 4096 (int, explicit metadata syntax) + """ + if name not in _ARTIFACT_REGISTRY: + raise KeyError( + f"Artifact '{name}' not found. " + f"Available: {list(_ARTIFACT_REGISTRY.keys())}. " + "Did you call register_resolvers() with the artifacts dict?" + ) + + artifact_info = _ARTIFACT_REGISTRY[name] + + # Use metadata_dir for reading metadata.json (W&B download location) + # Falls back to path if metadata_dir not available (for backwards compat) + metadata_dir = artifact_info.get("metadata_dir") or artifact_info.get("path") + + # Handle explicit metadata.* prefix (legacy syntax) + if field.startswith("metadata."): + metadata_field = field[len("metadata.") :] + if not metadata_dir: + raise KeyError(f"Artifact '{name}' has no path, cannot read metadata") + + metadata = _read_artifact_metadata(metadata_dir) + if metadata_field not in metadata: + raise KeyError( + f"Field '{metadata_field}' not found in metadata.json for artifact '{name}'. " + f"Available fields: {list(metadata.keys())}" + ) + return metadata[metadata_field] + + # Check if field is in artifact_info first (excludes metadata_dir from direct access) + if field in artifact_info and field != "metadata_dir": + return artifact_info[field] + + # Fall back to reading from metadata.json + if metadata_dir: + metadata = _read_artifact_metadata(metadata_dir) + if field in metadata: + return metadata[field] + # Also check nested "metadata" dict (for fields stored via artifact.metadata["field"]) + nested_metadata = metadata.get("metadata", {}) + if field in nested_metadata: + return nested_metadata[field] + + # Field not found anywhere + available_fields = [k for k in artifact_info.keys() if k != "metadata_dir"] + if metadata_dir: + metadata = _read_artifact_metadata(metadata_dir) + available_fields.extend([f for f in metadata.keys() if f not in available_fields]) + # Include nested metadata fields + nested_metadata = metadata.get("metadata", {}) + available_fields.extend([f for f in nested_metadata.keys() if f not in available_fields]) + + raise KeyError( + f"Unknown field '{field}' for artifact '{name}'. Available fields: {available_fields}" + ) + + +def register_resolvers( + artifacts: dict[str, str] | None = None, + *, + replace: bool = True, + mode: ResolverMode = "active_run", + pre_init_patch_http_digest: bool = False, +) -> list[str]: + """Register OmegaConf resolvers for artifact resolution. + + This should be called early in the training script, before loading + any configs that use ${art.X.path} interpolations. + + Args: + artifacts: Dict mapping artifact keys to artifact references. + Example: {"data": "DataBlendsArtifact-pretrain:v5", "model": "ModelArtifact"} + The key is what you use in ${art.KEY.path}, the value is the W&B artifact name. + replace: Whether to replace existing resolver (default True). + + Example: + >>> from nemotron.kit.resolvers import register_resolvers + >>> register_resolvers(artifacts={ + ... "data": "DataBlendsArtifact-pretrain", + ... "model": "ModelArtifact-pretrain:v5", + ... }) + >>> config = OmegaConf.load("train.yaml") + >>> # ${art.data.path} now resolves to the downloaded artifact path + """ + qualified_names: list[str] = [] + + # Pre-resolve all artifacts + if artifacts: + rank, world_size = _get_distributed_info() + + if world_size > 1: + # Distributed mode: only rank 0 downloads, others wait + marker_path = _get_marker_path(artifacts) + + if rank == 0: + # Rank 0: ALWAYS delete any existing marker file first to ensure fresh download. + # This prevents stale marker files from causing other ranks to read old cached data. + # Even though marker_path includes job_id, we delete it unconditionally to ensure + # the current run always gets fresh artifacts (important for :latest resolution). + if marker_path.exists(): + import logging + + logger = logging.getLogger(__name__) + logger.info(f"[ARTIFACT] Rank 0: Deleting existing marker file to force fresh download: {marker_path}") + marker_path.unlink() + + # Rank 0: download artifacts and write marker file + results: dict[str, dict[str, Any]] = {} + print(f"[ARTIFACT] Rank 0: Resolving {len(artifacts)} artifacts: {list(artifacts.keys())}") + for key, artifact_ref in artifacts.items(): + print(f"[ARTIFACT] Rank 0: Starting resolution of '{key}' -> '{artifact_ref}'") + try: + if mode == "active_run": + name, version = _parse_artifact_ref(artifact_ref) + result = _resolve_artifact_active_run(name, version) + elif mode == "pre_init": + result = resolve_artifact_pre_init( + artifact_ref, + patch_http_digest=pre_init_patch_http_digest, + ) + else: + raise ValueError(f"Unknown resolver mode: {mode}") + + _ARTIFACT_REGISTRY[key] = result + results[key] = result + + qname = result.get("qualified_name") + if qname: + qualified_names.append(str(qname)) + print(f"[ARTIFACT] Rank 0: Successfully resolved '{key}' -> {result.get('path')}") + except Exception as e: + print(f"[ARTIFACT] Rank 0: ERROR resolving '{key}' ({artifact_ref}): {e}") + raise + + # Signal completion to other ranks + marker_path.parent.mkdir(parents=True, exist_ok=True) + marker_path.write_text( + json.dumps( + { + "results": results, + "qualified_names": qualified_names, + } + ) + ) + else: + # Other ranks: wait for rank 0 and use shared results + data = _wait_for_artifacts(marker_path) + for key, result in data["results"].items(): + _ARTIFACT_REGISTRY[key] = result + qualified_names = data["qualified_names"] + else: + # Single process mode: download directly (existing behavior) + print(f"[ARTIFACT] Single process: Resolving {len(artifacts)} artifacts: {list(artifacts.keys())}") + for key, artifact_ref in artifacts.items(): + print(f"[ARTIFACT] Starting resolution of '{key}' -> '{artifact_ref}'") + try: + if mode == "active_run": + name, version = _parse_artifact_ref(artifact_ref) + result = _resolve_artifact_active_run(name, version) + elif mode == "pre_init": + result = resolve_artifact_pre_init( + artifact_ref, + patch_http_digest=pre_init_patch_http_digest, + ) + else: + raise ValueError(f"Unknown resolver mode: {mode}") + + _ARTIFACT_REGISTRY[key] = result + + qname = result.get("qualified_name") + if qname: + qualified_names.append(str(qname)) + print(f"[ARTIFACT] Successfully resolved '{key}' -> {result.get('path')}") + except Exception as e: + print(f"[ARTIFACT] ERROR resolving '{key}' ({artifact_ref}): {e}") + raise + + # Register the resolver + # ${art.data.path} -> _art_resolver("data", "path") + # ${art.model.version} -> _art_resolver("model", "version") + OmegaConf.register_new_resolver( + "art", + lambda name, field="path": _art_resolver(name, field), + replace=replace, + ) + + return qualified_names + + +def register_resolvers_from_config( + config: Any, + artifacts_key: str = "run", + *, + replace: bool = True, + mode: ResolverMode = "active_run", + pre_init_patch_http_digest: bool = False, +) -> list[str]: + """Register artifact resolvers from a config's run section. + + This function extracts artifact references from the config's run section. + Artifact references are string values that look like W&B artifact names + (contain "Artifact" in the name or match the pattern Name-stage:version). + + Args: + config: OmegaConf config (or path to YAML file) + artifacts_key: Dotpath to section containing artifacts (default: "run") + replace: Whether to replace existing resolver + + Example config.yaml: + run: + data: DataBlendsArtifact-pretrain + model: ModelArtifact-pretrain:v5 + env: + container: nvcr.io/nvidian/nemo:25.11-nano-v3.rc2 + + recipe: + per_split_data_args_path: ${art.data.path} + + Example usage: + >>> config = OmegaConf.load("config.yaml") + >>> register_resolvers_from_config(config) + >>> # Now resolve the config + >>> resolved = OmegaConf.to_container(config, resolve=True) + """ + if isinstance(config, (str, Path)): + config = OmegaConf.load(config) + + # Navigate to the section containing artifacts + section = OmegaConf.select(config, artifacts_key, default=None) + + artifacts: dict[str, str] = {} + + if section is not None: + section_dict = OmegaConf.to_container(section, resolve=False) + + # Extract artifact references from the section + # Artifact refs are string values that look like W&B artifact names + if isinstance(section_dict, dict): + print(f"[ARTIFACT] Scanning config section '{artifacts_key}' for artifact references...") + for key, value in section_dict.items(): + is_ref = _is_artifact_reference(value) + print(f"[ARTIFACT] {key}={repr(value)} -> is_artifact_reference={is_ref}") + if is_ref: + artifacts[key] = value + print(f"[ARTIFACT] Detected artifacts: {artifacts}") + + if artifacts: + return register_resolvers( + artifacts, + replace=replace, + mode=mode, + pre_init_patch_http_digest=pre_init_patch_http_digest, + ) + else: + # Still register the resolver, just without pre-resolved artifacts + register_resolvers(replace=replace) + return [] + + +def _is_artifact_reference(value: Any) -> bool: + """Check if a value looks like a W&B artifact reference. + + Args: + value: Value to check + + Returns: + True if value looks like an artifact reference + + Examples: + >>> _is_artifact_reference("DataBlendsArtifact-pretrain") + True + >>> _is_artifact_reference("ModelArtifact-pretrain:v5") + True + >>> _is_artifact_reference("nvcr.io/nvidian/nemo:25.11") + False + >>> _is_artifact_reference({"nested": "dict"}) + False + """ + if not isinstance(value, str): + return False + + # Skip container images (contain / or nvcr or docker) + if "/" in value or "nvcr" in value.lower() or "docker" in value.lower(): + return False + + # Check for common artifact patterns + # Pattern 1: Contains "Artifact" (e.g., DataBlendsArtifact-pretrain) + if "Artifact" in value: + return True + + # Pattern 2: Ends with version specifier and looks like an artifact name + # e.g., "my-model:v5", "dataset:latest" + if ":" in value: + name, version = value.rsplit(":", 1) + if version.startswith("v") or version == "latest" or version.isdigit(): + # Verify name part looks artifact-like (no slashes, dots suggesting URLs) + if "." not in name and "/" not in name: + return True + + return False + + +def clear_artifact_cache() -> None: + """Clear the artifact cache. + + Useful for testing or when you want to re-resolve artifacts. + """ + _ARTIFACT_REGISTRY.clear() + _ARTIFACT_CACHE.clear() diff --git a/src/nemotron/kit/run.py b/src/nemotron/kit/run.py new file mode 100644 index 0000000..eb6ff07 --- /dev/null +++ b/src/nemotron/kit/run.py @@ -0,0 +1,1112 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# Copyright (c) Nemotron Contributors +# SPDX-License-Identifier: MIT + +"""NeMo-Run integration for nemotron.kit. + +Provides RunConfig dataclass and executor builders for all nemo-run executors: +- local: Local execution with torchrun +- docker: Docker container execution +- slurm: Slurm cluster execution +- skypilot: Cloud execution via SkyPilot +- dgxcloud: NVIDIA DGX Cloud execution +- lepton: Lepton AI execution + +Example: + >>> from nemotron.kit.run import RunConfig, build_executor + >>> + >>> config = RunConfig(executor="slurm", account="my-account", partition="gpu") + >>> executor = build_executor(config, env_vars={"NCCL_DEBUG": "INFO"}) + +Wandb configuration can also be stored in env.toml: + >>> # env.toml + >>> # [wandb] + >>> # project = "my-project" + >>> # entity = "my-team" + >>> + >>> from nemotron.kit.run import load_wandb_config + >>> wandb_config = load_wandb_config() # Returns WandbConfig or None +""" + +from __future__ import annotations + +import sys +import time +from dataclasses import dataclass, field +from pathlib import Path +from typing import TYPE_CHECKING, Any, Literal + +if TYPE_CHECKING: + from nemotron.kit.wandb import WandbConfig + +Executor = Literal["local", "docker", "slurm", "skypilot", "dgxcloud", "lepton"] +"""Supported nemo-run executor types.""" + + +@dataclass +class RunConfig: + """Configuration for nemo-run execution (infrastructure only). + + Ray usage is determined by the recipe (ray=True in cli()), not here. + Supports all nemo-run executors. + + Attributes: + executor: Executor type (local, docker, slurm, skypilot, dgxcloud, lepton) + nproc_per_node: Number of processes (GPUs) per node + nodes: Number of nodes for distributed execution + + container_image: Container image for docker/slurm/skypilot + mounts: Container mount points (e.g., '/data:/data') + + account: Slurm account name + partition: Slurm partition name + run_partition: Partition to use for attached execution (--run), overrides partition + batch_partition: Partition to use for detached execution (--batch), overrides partition + time: Slurm job time limit (HH:MM:SS) + job_name: Slurm job name + ntasks_per_node: Slurm tasks per node + gpus_per_node: Slurm GPUs per node + mem: Slurm memory request (e.g., '0' for all, '64G') + exclusive: Request exclusive node access + cpus_per_task: Slurm CPUs per task + cpus_per_gpu: Slurm CPUs per GPU + gpus_per_task: Slurm GPUs per task + mem_per_gpu: Slurm memory per GPU (e.g., '32G') + mem_per_cpu: Slurm memory per CPU (e.g., '4G') + qos: Slurm quality of service + constraint: Slurm node constraints (e.g., 'a100') + exclude: Slurm nodes to exclude + gres: Slurm generic resources + array: Slurm job array specification + + tunnel: Tunnel type for Slurm (local or ssh) + host: SSH host for remote job submission + user: SSH user for remote job submission + identity: SSH identity file path + remote_job_dir: Remote directory for job files + + runtime: Docker runtime (e.g., 'nvidia') + ipc_mode: Docker IPC mode + shm_size: Docker shared memory size + + cloud: SkyPilot cloud provider (aws, gcp, azure) + gpus: SkyPilot GPU spec (e.g., 'A100:8') + cluster_name: SkyPilot cluster name + setup: SkyPilot pre-launch commands + + base_url: DGX Cloud base URL + app_id: DGX Cloud app ID + app_secret: DGX Cloud app secret + project_name: DGX Cloud project name + pvcs: DGX Cloud persistent volume claims + + resource_shape: Lepton GPU pod type + node_group: Lepton node group + nemo_run_dir: Lepton nemo-run directory + + ray_working_dir: Working directory for Ray jobs + ray_mode: Ray execution mode - "job" (ephemeral, auto-terminates) or + "cluster" (persistent, for interactive use) + + env_vars: Environment variables (KEY=VALUE format) + dry_run: Print commands without executing + detach: Don't wait for job completion + """ + + # Executor type + executor: Executor = "local" + + # Common resource settings + nproc_per_node: int | None = None + nodes: int | None = None + + # Container settings (docker, slurm, skypilot) + container_image: str | None = None + mounts: list[str] = field(default_factory=list) + + # Slurm settings + account: str | None = None + partition: str | None = None + run_partition: str | None = None + batch_partition: str | None = None + time: str = "04:00:00" + job_name: str = "nemo-run" + ntasks_per_node: int | None = None + gpus_per_node: int | None = None + mem: str | None = None + exclusive: bool | None = None + cpus_per_task: int | None = None + cpus_per_gpu: int | None = None + gpus_per_task: int | None = None + mem_per_gpu: str | None = None + mem_per_cpu: str | None = None + qos: str | None = None + constraint: str | None = None + exclude: str | None = None + gres: str | None = None + array: str | None = None + + # SSH tunnel settings (for remote Slurm submission) + tunnel: Literal["local", "ssh"] = "local" + host: str | None = None + user: str | None = None + identity: str | None = None + remote_job_dir: str | None = None + + # Docker settings + runtime: str | None = None # e.g., "nvidia" + ipc_mode: str | None = None + shm_size: str | None = None + + # Skypilot settings + cloud: str | None = None # e.g., "aws", "gcp", "azure" + gpus: str | None = None # e.g., "A100:8" + cluster_name: str | None = None + setup: str | None = None # Pre-launch commands + + # DGX Cloud settings + base_url: str | None = None + app_id: str | None = None + app_secret: str | None = None + project_name: str | None = None + pvcs: list[str] = field(default_factory=list) # persistent volume claims + + # Lepton settings + resource_shape: str | None = None # GPU pod type + node_group: str | None = None + nemo_run_dir: str | None = None + + # Ray infrastructure settings (used when recipe has ray=True) + ray_working_dir: str | None = None + ray_mode: Literal["job", "cluster"] = "job" # "job" (ephemeral) or "cluster" (persistent) + + # Environment + env_vars: list[str] = field(default_factory=list) + + # Execution options + dry_run: bool = False + detach: bool = False + + +def resolve_partition(config: RunConfig, is_launch: bool) -> str | None: + """Resolve the effective partition based on execution mode. + + Selects the appropriate partition based on whether the job is being + batched (detached) or run (attached): + - For --batch (detached): use batch_partition if defined, else partition + - For --run (attached): use run_partition if defined, else partition + + Args: + config: RunConfig with partition settings. + is_launch: True for detached execution (--batch), False for attached (--run). + + Returns: + The effective partition name, or None if no partition is configured. + + Example: + >>> config = RunConfig(partition="batch", batch_partition="interactive") + >>> resolve_partition(config, is_launch=False) + 'batch' + >>> resolve_partition(config, is_launch=True) + 'interactive' + """ + if is_launch and config.batch_partition is not None: + return config.batch_partition + if not is_launch and config.run_partition is not None: + return config.run_partition + return config.partition + + +def patch_nemo_run_ray_template_for_cpu() -> None: + """Patch nemo-run Ray template to properly handle CPU-only partitions. + + The default nemo_run Ray template hardcodes gpus_per_node=8 and calculates + CPUs as 16*gpus_per_node, which results in 0 CPUs for CPU-only partitions. + + This patch modifies the template location to use our custom template that + auto-detects CPUs from SLURM environment variables. + """ + import os + import tempfile + from pathlib import Path + + try: + # Use 'from ... import' syntax to avoid issues with 'run' being shadowed + # by the nemo_run.run function when using 'import nemo_run.run.ray.slurm' + from nemo_run.run.ray import slurm as slurm_mod + except Exception: + return + + if getattr(slurm_mod, "_nemotron_cpu_template_patched", False): + return + + # Get the path to our custom template + custom_template_dir = Path(__file__).parent / "templates" + custom_template_name = "ray_cpu.sub.j2" + + # Check if our custom template exists + template_path = custom_template_dir / custom_template_name + if not template_path.exists(): + return + + def patched_create( + self, + pre_ray_start_commands=None, + dryrun=False, + command=None, + workdir=None, + command_groups=None, + ): + """Patched create that uses custom CPU-aware Ray template.""" + name = self.name + executor = self.executor + cluster_dir = os.path.join(executor.tunnel.job_dir, name) + + # Use custom template for CPU-aware Ray cluster + ray_sbatch = slurm_mod.SlurmRayRequest( + name=name, + cluster_dir=cluster_dir, + template_name=custom_template_name, + template_dir=str(custom_template_dir), + executor=executor, + pre_ray_start_commands=pre_ray_start_commands, + command=command, + workdir=workdir, + command_groups=command_groups, + launch_cmd=["sbatch", "--requeue", "--parsable", "--dependency=singleton"], + ).materialize() + + if dryrun: + slurm_mod.logger.debug(f"Dry run: Ray cluster '{name}'") + print(ray_sbatch) + return None + + slurm_mod.logger.info(f"Creating Ray cluster '{name}'") + # Check if a cluster with this name already exists + status = self.status() + + if status["job_id"] is not None: + job_state = status["state"] + if job_state in ["PENDING", "RUNNING", "CONFIGURING"]: + slurm_mod.logger.debug( + f"Ray cluster '{name}' already exists with ID {status['job_id']} " + f"and is currently in {job_state} state. " + f"Skipping creation." + ) + return None + elif job_state not in [ + "COMPLETING", + "COMPLETED", + "CANCELLED", + "FAILED", + "TIMEOUT", + "NOT_FOUND", + ]: + slurm_mod.logger.warning( + f"Ray cluster '{name}' exists with ID {status['job_id']} " + f"in state {job_state}. Creating new cluster anyway." + ) + + # Submit to SLURM - same logic as original nemo-run + executor.tunnel.connect() + executor.tunnel.run(f"mkdir -p {cluster_dir}") + + with tempfile.NamedTemporaryFile(mode="w", delete=True) as f: + f.write(ray_sbatch) + f.flush() + os.fsync(f.fileno()) + ray_sbatch_path = f.name + executor.tunnel.put(ray_sbatch_path, os.path.join(cluster_dir, "ray.sub")) + + sbatch_cmd = ["sbatch", "--parsable", os.path.join(cluster_dir, "ray.sub")] + job_id = executor.tunnel.run(" ".join(sbatch_cmd)).stdout.strip() + + # Store job_id in cluster_map + self.cluster_map[name] = job_id + + slurm_mod.logger.info(f"Slurm job for Ray cluster '{name}' created with ID {job_id}") + + return job_id + + slurm_mod.SlurmRayCluster.create = patched_create + slurm_mod._nemotron_cpu_template_patched = True + + +def patch_nemo_run_rsync_accept_new_host_keys() -> None: + """Patch nemo-run rsync to avoid hanging on first-time host key prompts. + + nemo-run's SSH tunnel uses Paramiko for its control connection, but the + rsync step shells out to the system `ssh`, which can block waiting for an + interactive StrictHostKeyChecking prompt. + + We set `StrictHostKeyChecking=accept-new` unless the caller already + provided a StrictHostKeyChecking option. + """ + + try: + import nemo_run.core.tunnel.rsync as rsync_mod + except Exception: + return + + if getattr(rsync_mod.rsync, "_nemotron_patched", False): + return + + orig = rsync_mod.rsync + + def patched(*args, **kwargs): + ssh_opts = kwargs.get("ssh_opts", "") or "" + if "StrictHostKeyChecking" not in ssh_opts: + ssh_opts = (ssh_opts + " " if ssh_opts else "") + "-o StrictHostKeyChecking=accept-new" + if "BatchMode" not in ssh_opts: + ssh_opts = (ssh_opts + " " if ssh_opts else "") + "-o BatchMode=yes" + if "PreferredAuthentications" not in ssh_opts: + ssh_opts = (ssh_opts + " " if ssh_opts else "") + ( + "-o PreferredAuthentications=publickey" + ) + if "ConnectTimeout" not in ssh_opts: + ssh_opts = (ssh_opts + " " if ssh_opts else "") + "-o ConnectTimeout=30" + kwargs["ssh_opts"] = ssh_opts + + rsync_opts = kwargs.get("rsync_opts", "") or "" + # Note: --info=progress2 removed because older rsync versions on some clusters don't support it + if "--timeout" not in rsync_opts: + rsync_opts = (rsync_opts + " " if rsync_opts else "") + "--timeout=60" + # Use --delete for faster incremental syncs (removes stale files on remote) + if "--delete" not in rsync_opts: + rsync_opts = (rsync_opts + " " if rsync_opts else "") + "--delete" + kwargs["rsync_opts"] = rsync_opts + + # Default exclusions for our repo (avoid syncing large non-runtime dirs). + # Users can override by passing `exclude=...` explicitly. + # Note: Use patterns anchored at root (e.g., "/artifacts") to avoid + # excluding source directories like src/nemotron/kit/artifacts. + kwargs.setdefault( + "exclude", + ( + ".git", + ".venv", + "__pycache__", + ".ruff_cache", + ".pytest_cache", + ".mypy_cache", + ".nemotron", + ".conductor", + "/output", + "/outputs", + "/artifacts", + "/wandb", + "usage-cookbook", + "use-case-examples", + ), + ) + + # Show progress/errors instead of looking hung. + kwargs.setdefault("hide_output", False) + + return orig(*args, **kwargs) + + patched._nemotron_patched = True # type: ignore[attr-defined] + rsync_mod.rsync = patched # type: ignore[assignment] + + # Patch already-imported call sites that `from ... import rsync`. + try: + import nemo_run.run.experiment as exp + + exp.rsync = patched # type: ignore[assignment] + except Exception: + pass + + try: + import nemo_run.run.ray.slurm as slurm + + slurm.rsync = patched # type: ignore[assignment] + except Exception: + pass + + +def build_executor(config: RunConfig, env_vars: dict[str, str] | None = None) -> Any: + """Build nemo-run executor from RunConfig. + + Args: + config: Run configuration specifying executor type and settings. + env_vars: Additional environment variables to merge. + + Returns: + A nemo-run executor instance. + + Raises: + ImportError: If nemo-run is not installed. + ValueError: If required settings are missing for the executor type. + """ + try: + import nemo_run as run + except ImportError as e: + raise ImportError( + "nemo-run not installed. Install with: pip install nemo-run\n" + "Or use direct execution without --run" + ) from e + + patch_nemo_run_rsync_accept_new_host_keys() + patch_nemo_run_ray_template_for_cpu() + + # Parse and merge environment variables + merged_env = {} + for env in config.env_vars: + if "=" in env: + key, value = env.split("=", 1) + merged_env[key] = value + if env_vars: + merged_env.update(env_vars) + + # Auto-detect HuggingFace token if not already set + if "HF_TOKEN" not in merged_env: + try: + from huggingface_hub import HfFolder + + token = HfFolder.get_token() + if token: + merged_env["HF_TOKEN"] = token + sys.stderr.write( + "[info] Detected HuggingFace login, adding HF_TOKEN to environment\n" + ) + except Exception: + pass # huggingface_hub not installed or no token + + # Auto-detect Weights & Biases API key if not already set + if "WANDB_API_KEY" not in merged_env: + try: + import wandb + + api_key = wandb.api.api_key + if api_key: + merged_env["WANDB_API_KEY"] = api_key + sys.stderr.write("[info] Detected W&B login, adding WANDB_API_KEY to environment\n") + except Exception: + pass # wandb not installed or not logged in + + # Auto-detect Weights & Biases project/entity from env.toml [wandb] section + wandb_config = load_wandb_config() + if wandb_config is not None: + if wandb_config.project and "WANDB_PROJECT" not in merged_env: + merged_env["WANDB_PROJECT"] = wandb_config.project + if wandb_config.entity and "WANDB_ENTITY" not in merged_env: + merged_env["WANDB_ENTITY"] = wandb_config.entity + + # NOTE: PYTHONPATH and NEMO_RUN_DIR are NOT set here for Ray jobs. + # Ray jobs use nemo-run's SlurmRayJob which rsyncs to {cluster_dir}/code + # but does NOT mount to /nemo_run. The workdir is set to the actual path. + # We handle this in run_with_nemo_run() by using relative paths. + + match config.executor: + case "local": + return run.LocalExecutor( + ntasks_per_node=config.nproc_per_node, + launcher="torchrun", + env_vars=merged_env, + ) + + case "docker": + if not config.container_image: + raise ValueError("container_image required for docker executor") + return run.DockerExecutor( + container_image=config.container_image, + num_gpus=config.nproc_per_node, + runtime=config.runtime or "nvidia", + ipc_mode=config.ipc_mode, + shm_size=config.shm_size, + volumes=config.mounts, + env_vars=merged_env, + ) + + case "slurm": + if not config.account: + raise ValueError("account required for slurm executor") + if not config.partition: + raise ValueError("partition required for slurm executor") + + tunnel = _build_tunnel(config) + packager = _build_packager() + + return run.SlurmExecutor( + account=config.account, + partition=config.partition, + nodes=config.nodes, + ntasks_per_node=config.ntasks_per_node, + gpus_per_node=config.gpus_per_node, + time=config.time, + mem=config.mem, + exclusive=config.exclusive, + cpus_per_task=config.cpus_per_task, + cpus_per_gpu=config.cpus_per_gpu, + gpus_per_task=config.gpus_per_task, + mem_per_gpu=config.mem_per_gpu, + mem_per_cpu=config.mem_per_cpu, + qos=config.qos, + constraint=config.constraint, + exclude=config.exclude, + gres=config.gres, + array=config.array, + container_image=config.container_image, + container_mounts=config.mounts, + tunnel=tunnel, + packager=packager, + env_vars=merged_env, + ) + + case "skypilot": + return run.SkypilotExecutor( + gpus=config.gpus, + gpus_per_node=config.nproc_per_node, + num_nodes=config.nodes, + cloud=config.cloud, + cluster_name=config.cluster_name, + setup=config.setup, + env_vars=merged_env, + ) + + case "dgxcloud": + return run.DGXCloudExecutor( + base_url=config.base_url, + app_id=config.app_id, + app_secret=config.app_secret, + project_name=config.project_name, + nodes=config.nodes, + gpus_per_node=config.nproc_per_node, + pvcs=config.pvcs, + env_vars=merged_env, + ) + + case "lepton": + return run.LeptonExecutor( + resource_shape=config.resource_shape, + node_group=config.node_group, + nemo_run_dir=config.nemo_run_dir, + mounts=config.mounts, + env_vars=merged_env, + ) + + case _: + raise ValueError(f"Unknown executor: {config.executor}") + + +def _build_tunnel(config: RunConfig) -> Any: + """Build nemo-run tunnel for Slurm executor. + + Args: + config: Run configuration with tunnel settings. + + Returns: + A nemo-run tunnel instance (LocalTunnel or SSHTunnel). + """ + import nemo_run as run + + if config.tunnel == "ssh": + if not config.host or not config.user: + raise ValueError("host and user required for SSH tunnel") + return run.SSHTunnel( + host=config.host, + user=config.user, + job_dir=config.remote_job_dir, + identity=config.identity, + ) + return run.LocalTunnel() + + +def _build_packager() -> Any: + """Build a HybridPackager for selective file syncing. + + Packages only the necessary files for remote cluster sync: + - src/ directory: only .py, .json, .jinja, .yaml, .typed files (excludes __pycache__) + - Top-level files: pyproject.toml, env.toml + + This avoids packaging: + - __pycache__/ directories with stale .pyc bytecode + - Large unnecessary directories like usage-cookbook/, use-case-examples/ + - tests/ directory (not needed for execution) + + Returns: + A HybridPackager instance configured for selective syncing. + """ + from nemo_run.core.packaging import HybridPackager, PatternPackager + + return HybridPackager( + extract_at_root=True, + sub_packagers={ + # Package src/ with only source files, excluding __pycache__ + "src_py": PatternPackager( + include_pattern='src -name "*.py"', + relative_path=".", + ), + "src_json": PatternPackager( + include_pattern='src -name "*.json"', + relative_path=".", + ), + "src_jinja": PatternPackager( + include_pattern='src -name "*.jinja"', + relative_path=".", + ), + "src_yaml": PatternPackager( + include_pattern='src -name "*.yaml"', + relative_path=".", + ), + "src_typed": PatternPackager( + include_pattern='src -name "py.typed"', + relative_path=".", + ), + "pyproject": PatternPackager( + include_pattern="pyproject.toml", + relative_path=".", + ), + "env_toml": PatternPackager( + include_pattern="env.toml", + relative_path=".", + ), + }, + ) + + +def _find_env_toml() -> Path | None: + """Find env.toml in cwd or walking up to project root.""" + for path in [Path.cwd(), *Path.cwd().parents]: + env_file = path / "env.toml" + if env_file.exists(): + return env_file + # Stop at project root + if (path / "pyproject.toml").exists(): + break + return None + + +def _load_env_toml(config_path: Path) -> dict[str, Any]: + """Load env.toml configuration. + + Args: + config_path: Path to config file. + + Returns: + Dictionary of profile name -> profile settings. + """ + if config_path.suffix.lower() != ".toml": + raise ValueError(f"Expected a .toml config file, got: {config_path}") + + if sys.version_info >= (3, 11): + import tomllib + else: + import tomli as tomllib + + with open(config_path, "rb") as f: + return tomllib.load(f) + + +def _resolve_profile(name: str, all_profiles: dict[str, Any], seen: set[str]) -> RunConfig: + """Recursively resolve profile with extends inheritance. + + Args: + name: Profile name to resolve. + all_profiles: All profiles from config file. + seen: Set of already visited profiles (for cycle detection). + + Returns: + Resolved RunConfig instance. + + Raises: + ValueError: If profile not found or circular inheritance detected. + """ + if name in seen: + raise ValueError(f"Circular inheritance detected: {name}") + seen.add(name) + + if name not in all_profiles: + raise ValueError(f"Profile '{name}' not found in env.toml") + + profile = all_profiles[name].copy() + extends = profile.pop("extends", None) + + if extends: + # Recursively resolve parent profile + parent = _resolve_profile(extends, all_profiles, seen) + # Merge: parent values as base, child values override + parent_dict = {k: v for k, v in vars(parent).items() if not k.startswith("_")} + merged = {**parent_dict, **profile} + return RunConfig(**merged) + + return RunConfig(**profile) + + +def load_run_profile(name: str, config_path: Path | None = None) -> RunConfig: + """Load a named profile from env.toml. + + Args: + name: Profile name to load. + config_path: Optional explicit path to config file. + + Returns: + RunConfig instance with resolved settings. + + Raises: + FileNotFoundError: If no env.toml found. + ValueError: If profile not found or inheritance error. + """ + if config_path is None: + config_path = _find_env_toml() + if config_path is None: + raise FileNotFoundError("No env.toml found") + + all_profiles = _load_env_toml(config_path) + return _resolve_profile(name, all_profiles, seen=set()) + + +def list_run_profiles(config_path: Path | None = None) -> list[str]: + """List available run profiles from env.toml. + + Profiles are top-level sections in env.toml, excluding the special [wandb] section. + + Args: + config_path: Optional explicit path to config file. + + Returns: + Sorted list of profile names. + """ + if config_path is None: + config_path = _find_env_toml() + if config_path is None: + return [] + + sections = _load_env_toml(config_path) + profiles = [k for k in sections.keys() if k != "wandb"] + return sorted(profiles) + + +def load_wandb_config(config_path: Path | None = None) -> WandbConfig | None: + """Load wandb configuration from env.toml [wandb] section. + + The [wandb] section is a top-level section in env.toml that configures W&B tracking + for all profiles. This allows centralizing wandb settings alongside execution profiles. + + Example env.toml: + [wandb] + project = "my-project" + entity = "my-team" + tags = ["training", "v1"] + + [draco] + executor = "slurm" + account = "my-account" + + Args: + config_path: Optional explicit path to config file. + + Returns: + WandbConfig instance if [wandb] section exists, None otherwise. + """ + from nemotron.kit.wandb import WandbConfig + + if config_path is None: + config_path = _find_env_toml() + if config_path is None: + return None + + all_sections = _load_env_toml(config_path) + wandb_section = all_sections.get("wandb") + + if wandb_section is None: + return None + + # Convert tags from list to tuple if present + if "tags" in wandb_section and isinstance(wandb_section["tags"], list): + wandb_section["tags"] = tuple(wandb_section["tags"]) + + # Map run_name from TOML (snake_case is more natural in TOML) + if "run_name" in wandb_section: + pass # Already correct field name + elif "name" in wandb_section: + # Allow shorthand "name" in TOML + wandb_section["run_name"] = wandb_section.pop("name") + + return WandbConfig(**wandb_section) + + +def run_with_nemo_run( + script_path: str, + script_args: list[str], + run_config: RunConfig, + ray: bool = False, + pre_ray_start_commands: list[str] | None = None, + packager: str = "code", + workdir: str | None = None, + run_command: str | None = None, +) -> int: + """Execute script via nemo-run, optionally with Ray. + + Args: + script_path: Path to Python script to execute. + script_args: Arguments to pass to the script. + run_config: Run configuration for executor. + ray: Whether to use Ray for execution. + pre_ray_start_commands: Commands to run before Ray starts. + packager: Packager type ("code", "self_contained", "pattern"). + workdir: Container working directory for Ray jobs (e.g., "/opt/nemo-rl"). + run_command: Custom command template (supports {script} and {config} placeholders). + + Returns: + Exit code (0 = success). + """ + try: + import nemo_run as run + from nemo_run.run.ray.job import RayJob + except ImportError: + sys.stderr.write( + "[run] ERROR: nemo-run not installed. Install with: pip install nemo-run\n" + ) + return 1 + + # Handle dry-run + if run_config.dry_run: + _print_dry_run(script_path, script_args, run_config, ray, pre_ray_start_commands) + return 0 + + # Build executor + executor = build_executor(run_config) + + if ray: + import tempfile + + import yaml + + # Recipe requires Ray - use RayJob + # Generate unique job name to prevent directory collisions + # nemo-run's SlurmRayJob uses cluster_dir = tunnel.job_dir + name, + # so jobs with the same name would overwrite each other's directories + base_name = run_config.job_name or Path(script_path).stem + job_name = f"{base_name}_{int(time.time())}" + ray_job = RayJob(name=job_name, executor=executor) + + # Log the ray mode + mode_desc = "ephemeral" if run_config.ray_mode == "job" else "persistent" + sys.stderr.write(f"[run] Ray mode: {run_config.ray_mode} ({mode_desc} cluster)\n") + + # Build log clearing command to prevent old logs from appearing in output. + # nemo-run reuses Ray clusters and appends to existing log files, so we + # truncate the log file before starting to ensure clean output. + log_clear_cmd = None + if run_config.remote_job_dir: + log_file = f"{run_config.remote_job_dir}/{job_name}/logs/ray-job.log" + log_clear_cmd = f": > {log_file} 2>/dev/null || true" + + # Build setup commands based on packager type and workdir + if pre_ray_start_commands is not None: + # Use explicitly provided commands + setup_commands = list(pre_ray_start_commands) + elif packager == "self_contained": + # For self_contained packager, skip uv sync (dependencies in container) + setup_commands = [ + "find . -type d -name __pycache__ -delete 2>/dev/null || true", + ] + else: + # Default setup for other packagers + setup_commands = [ + "find . -type d -name __pycache__ -delete 2>/dev/null || true", + "uv sync --reinstall-package nemotron", + ] + + # For self_contained packager, copy files from /nemo_run/code to workdir + # and use main.py instead of the original script path + if packager == "self_contained": + if workdir: + # Copy files to workdir and cd there + setup_commands.extend( + [ + f"cp /nemo_run/code/main.py {workdir}/", + f"cp /nemo_run/code/config.yaml {workdir}/", + f"cd {workdir}", + ] + ) + else: + # Copy files to current directory + setup_commands.extend( + [ + "cp /nemo_run/code/main.py .", + "cp /nemo_run/code/config.yaml .", + ] + ) + remote_script = "main.py" + else: + remote_script = script_path + + # Prepend log clearing if remote_job_dir is configured + if log_clear_cmd: + setup_commands.insert(0, log_clear_cmd) + + # Build the command to run + # For self_contained packager, config is at config.yaml; otherwise use script_args + config_file = "config.yaml" if packager == "self_contained" else None + if run_command: + # Use custom run command template with placeholders + cmd = run_command.format(script=remote_script, config=config_file or "") + # Prepend cd to workdir if set (pre_ray_start_commands run before Ray, not in job) + if workdir: + cmd = f"cd {workdir} && {cmd}" + elif workdir and packager == "self_contained": + cmd = f"cd {workdir} && python {remote_script}" + elif workdir: + cmd = f"cd {workdir} && uv run python {remote_script}" + else: + cmd = f"uv run python {remote_script}" + if script_args: + cmd += " " + " ".join(script_args) + + # Build runtime_env with environment variables for Ray workers + # This ensures env vars like HF_TOKEN are available in Ray tasks/actors + runtime_env: dict = {"env_vars": {}} + + # Auto-detect HuggingFace token for Ray workers + try: + from huggingface_hub import HfFolder + + hf_token = HfFolder.get_token() + if hf_token: + runtime_env["env_vars"]["HF_TOKEN"] = hf_token + except Exception: + pass + + # Auto-detect Weights & Biases API key for Ray workers + try: + import wandb + + wandb_api_key = wandb.api.api_key + if wandb_api_key: + runtime_env["env_vars"]["WANDB_API_KEY"] = wandb_api_key + except Exception: + pass + + # Load wandb project/entity from env.toml [wandb] section + wandb_config = load_wandb_config() + if wandb_config is not None: + if wandb_config.project: + runtime_env["env_vars"]["WANDB_PROJECT"] = wandb_config.project + if wandb_config.entity: + runtime_env["env_vars"]["WANDB_ENTITY"] = wandb_config.entity + + # Create temporary runtime_env YAML file if we have env vars to pass + runtime_env_yaml = None + if runtime_env["env_vars"]: + with tempfile.NamedTemporaryFile(mode="w", suffix=".yaml", delete=False) as f: + yaml.dump(runtime_env, f) + runtime_env_yaml = f.name + + ray_workdir = run_config.ray_working_dir + if not ray_workdir: + # For Ray jobs, prefer nemo-run's native workdir rsync (respects .gitignore) + # instead of the packager->tar->extract->rsync path. + ray_workdir = "." + + # Display job submission summary + from nemotron.kit.cli.display import display_ray_job_submission + + display_ray_job_submission( + script_path=script_path, + script_args=script_args or [], + env_vars=runtime_env.get("env_vars", {}), + mode="detached" if run_config.detach else "attached", + ) + + ray_job.start( + command=cmd, + workdir=ray_workdir, + pre_ray_start_commands=setup_commands, + runtime_env_yaml=runtime_env_yaml, + ) + + # Workaround for nemo-run bug: when reusing an existing cluster, + # SlurmRayCluster.create() returns None instead of the job_id. + # Fix by querying the backend status which has the actual job_id. + if ray_job.backend.job_id is None: + status = ray_job.backend.status(display=False) + if status and status.get("job_id"): + ray_job.backend.job_id = status["job_id"] + sys.stderr.write( + f"[info] Recovered job_id {status['job_id']} from cluster status\n" + ) + + if not run_config.detach: + try: + # Wait up to 10 minutes for log file to appear (Slurm jobs can be slow to start) + ray_job.logs(follow=True, timeout=600) + except KeyboardInterrupt: + if run_config.ray_mode == "cluster": + # In cluster mode, keep the cluster running for subsequent jobs + sys.stderr.write( + "\n[info] Ctrl-C detected. Cluster mode: leaving Ray cluster running.\n" + "[info] Use 'scancel ' to stop the cluster manually.\n" + ) + else: + # In job mode, stop the cluster + sys.stderr.write("\n[info] Ctrl-C detected, stopping Ray cluster...\n") + try: + ray_job.stop() + sys.stderr.write("[info] Ray cluster stopped\n") + except Exception as e: + sys.stderr.write(f"[warning] Failed to stop Ray cluster: {e}\n") + raise + else: + # Standard execution via nemo-run Script + with run.Experiment(run_config.job_name) as exp: + task = run.Script(path=script_path, args=script_args) + exp.add(task, executor=executor) + exp.run(detach=run_config.detach, tail_logs=not run_config.detach) + + return 0 + + +def _print_dry_run( + script_path: str, + script_args: list[str], + run_config: RunConfig, + ray: bool, + pre_ray_start_commands: list[str] | None, +) -> None: + """Print dry-run information.""" + sys.stderr.write("[run] Dry-run mode - would execute:\n") + sys.stderr.write(f"[run] Script: {script_path}\n") + sys.stderr.write(f"[run] Args: {' '.join(script_args) if script_args else '(none)'}\n") + sys.stderr.write(f"[run] Executor: {run_config.executor}\n") + sys.stderr.write(f"[run] Nodes: {run_config.nodes}\n") + sys.stderr.write(f"[run] GPUs/node: {run_config.nproc_per_node}\n") + sys.stderr.write(f"[run] Ray: {ray}\n") + + if run_config.executor == "slurm": + sys.stderr.write(f"[run] Account: {run_config.account}\n") + sys.stderr.write(f"[run] Partition: {run_config.partition}\n") + sys.stderr.write(f"[run] Time: {run_config.time}\n") + if run_config.container_image: + sys.stderr.write(f"[run] Container: {run_config.container_image}\n") + if run_config.tunnel == "ssh": + sys.stderr.write(f"[run] SSH tunnel: {run_config.user}@{run_config.host}\n") + + if run_config.executor == "docker": + sys.stderr.write(f"[run] Container: {run_config.container_image}\n") + sys.stderr.write(f"[run] Runtime: {run_config.runtime or 'nvidia'}\n") + + if run_config.executor == "skypilot": + sys.stderr.write(f"[run] Cloud: {run_config.cloud}\n") + sys.stderr.write(f"[run] GPUs: {run_config.gpus}\n") + if run_config.cluster_name: + sys.stderr.write(f"[run] Cluster: {run_config.cluster_name}\n") + + if ray and pre_ray_start_commands: + sys.stderr.write(f"[run] Pre-Ray commands: {pre_ray_start_commands}\n") + + sys.stderr.flush() diff --git a/src/nemotron/kit/step.py b/src/nemotron/kit/step.py new file mode 100644 index 0000000..546c332 --- /dev/null +++ b/src/nemotron/kit/step.py @@ -0,0 +1,118 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Pipeline step definition for nemotron.kit. + +Defines the Step class used to represent executable pipeline steps. +""" + +from __future__ import annotations + +import sys +from dataclasses import dataclass +from types import ModuleType + + +@dataclass +class Step: + """A pipeline step that can be executed. + + Steps wrap Python modules that can be run as scripts. They support + both single-process (python) and distributed (torchrun) execution. + + Example: + >>> from nemotron.kit import Step + >>> from nemotron.recipes.nano3.stage0_pretrain import data_prep, training + >>> + >>> steps = [ + ... Step(name="data_prep", module=data_prep), + ... Step(name="training", module=training, torchrun=True), + ... ] + """ + + name: str + """Step name (e.g., 'data_prep', 'training').""" + + module: ModuleType + """Python module containing the step.""" + + torchrun: bool = False + """Whether to run with torchrun for distributed execution.""" + + @property + def module_name(self) -> str: + """Get the module's fully qualified name.""" + return self.module.__name__ + + @property + def module_file(self) -> str | None: + """Get the module's file path.""" + return self.module.__file__ + + def get_command(self, nproc_per_node: int = 8) -> list[str]: + """Build command to execute this step. + + Args: + nproc_per_node: Number of processes per node (for torchrun). + + Returns: + Command as list of strings. + """ + if self.torchrun: + return [ + "torchrun", + f"--nproc_per_node={nproc_per_node}", + "-m", + self.module_name, + ] + return [sys.executable, "-m", self.module_name] + + def get_srun_command( + self, + nproc_per_node: int = 8, + container_image: str | None = None, + mounts: list[str] | None = None, + ) -> str: + """Build srun command for Slurm execution. + + Args: + nproc_per_node: Number of processes per node. + container_image: Container image path. + mounts: Container mount points. + + Returns: + Command as string for shell execution. + """ + parts = ["srun", "--mpi=pmix"] + + if container_image: + parts.append(f"--container-image={container_image}") + if mounts: + for mount in mounts: + parts.append(f"--container-mounts={mount}") + + parts.extend( + [ + "torchrun", + "--nproc_per_node=$SLURM_GPUS_PER_NODE", + "--nnodes=$SLURM_JOB_NUM_NODES", + "--node_rank=$SLURM_PROCID", + '--master_addr=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n 1)', + "--master_port=29500", + "-m", + self.module_name, + ] + ) + + return " ".join(parts) diff --git a/src/nemotron/kit/templates/ray_cpu.sub.j2 b/src/nemotron/kit/templates/ray_cpu.sub.j2 new file mode 100644 index 0000000..8eba9f0 --- /dev/null +++ b/src/nemotron/kit/templates/ray_cpu.sub.j2 @@ -0,0 +1,403 @@ +#!/bin/bash +# +# Generated by NeMo Run +# + +# Parameters +{%- for sbatch_flag in sbatch_flags %} +{{sbatch_flag}} +{%- endfor %} + +set -eoux pipefail + +######################################################## +# User defined variables +######################################################## +export PYTHONUNBUFFERED=1 +export SLURM_UNBUFFEREDIO=1 + +{%- for env_var in env_vars %} +{{env_var}} +{%- endfor %} + +# Ports for all nodes (should be odd numbers since we place head/worker[0] on the same node) so all workers get the odd ports, but the head will get +1 the ports +NODE_MANAGER_PORT=${NODE_MANAGER_PORT:-53001} +OBJECT_MANAGER_PORT=${OBJECT_MANAGER_PORT:-53003} +RUNTIME_ENV_AGENT_PORT=${RUNTIME_ENV_AGENT_PORT:-53005} +DASHBOARD_AGENT_GRPC_PORT=${DASHBOARD_AGENT_GRPC_PORT:-53007} +METRICS_EXPORT_PORT=${METRICS_EXPORT_PORT:-53009} + +# Ports for the head node +PORT=${PORT:-6379} +RAY_CLIENT_SERVER_PORT=${RAY_CLIENT_SERVER_PORT:-10001} +#REDIT_SHARD_PORTS=${REDIT_SHARD_PORTS:-"random"} ?? +DASHBOARD_PORT=${DASHBOARD_PORT:-8265} # Also used by debugger +DASHBOARD_AGENT_LISTEN_PORT=${DASHBOARD_AGENT_LISTEN_PORT:-52365} + +# On our clusters, the largest port range on an idle worker appeared between 52369-64607 +# (not including the other ports set by this script). So this range is chosen to be +# somewhere in the middle +MIN_WORKER_PORT=${MIN_WORKER_PORT:-54001} +MAX_WORKER_PORT=${MAX_WORKER_PORT:-54257} + +# Ray temp directory (inside container). Used by --temp-dir and log sync sidecar +RAY_TEMP_DIR=${RAY_TEMP_DIR:-/ray-cluster} + +# Number seconds to sync logs from /tmp/ray/session_*/logs to $LOG_DIR/ray/ +RAY_LOG_SYNC_FREQUENCY=${RAY_LOG_SYNC_FREQUENCY:-} + +# Timeout in seconds for Ray head node to start (default 10 minutes) +RAY_HEAD_START_TIMEOUT=${RAY_HEAD_START_TIMEOUT:-600} + +# Directory setup +export CLUSTER_DIR={{ cluster_dir }} +mkdir -p $CLUSTER_DIR + +JOB_IDS_FILE="$CLUSTER_DIR/job_ids.json" +if [[ -f "$JOB_IDS_FILE" ]]; then + tmp="$(mktemp)" + jq --arg id "$SLURM_JOB_ID" '. + [$id]' "$JOB_IDS_FILE" > "$tmp" && mv "$tmp" "$JOB_IDS_FILE" +else + touch "$JOB_IDS_FILE" + echo "[\"$SLURM_JOB_ID\"]" > "$JOB_IDS_FILE" +fi + +mkdir -p $CLUSTER_DIR/scripts + +export LOG_DIR={{ log_dir }} +mkdir -p $LOG_DIR + +# Clean up any previous run files +rm -f $LOG_DIR/STARTED_RAY_HEAD +rm -f $LOG_DIR/ENDED + +# Defaults to placing uv cache inside the CLUSTER_DIR +# This directory is mounted into the container at /home/ray/.cache/uv so it is shared between the head and worker nodes +# UV_CACHE_DIR={{ uv_cache_dir }} +# mkdir -p $UV_CACHE_DIR +######################################################## + +# Number of GPUs per node (0 for CPU-only) +gpus_per_node=${SLURM_GPUS_PER_NODE:-0} + +# Number of CPUs per node - auto-detect from SLURM +# Use SLURM_CPUS_PER_TASK if available, otherwise fall back to SLURM_CPUS_ON_NODE +cpus_per_node=${SLURM_CPUS_PER_TASK:-${SLURM_CPUS_ON_NODE:-96}} + +num_retries={{ num_retries }} + +# Getting the node names and IP addresses in the SLURM allocation +nodes=$(scontrol show hostnames "$SLURM_JOB_NODELIST") +nodes_array=($nodes) +ip_addresses_array=() + +for node in $nodes; do + ip_address=$(host $node | awk '/has address/ { print $4 }') + # Add the IP address to the array + ip_addresses_array+=("$ip_address") +done + +head_node=${nodes_array[0]} +head_node_ip=${ip_addresses_array[0]} + +ip_head=$head_node_ip:$PORT + +{%- if setup_lines %} +{{setup_lines}} +{%- endif %} + +# Calculate worker units: prefer GPUs when available, else CPUs +if [[ $gpus_per_node -gt 0 ]]; then + worker_units_per_node=$gpus_per_node +else + worker_units_per_node=$cpus_per_node +fi + +######################################################## +# Ray cluster setup +######################################################## +# First we start the head of the ray cluster on one of the physical nodes +# Set GPU/CPU resources to 0 to avoid scheduling on the head node + +head_cmd=$(cat < /dev/null 2>&1; then + for session_dir in ${RAY_TEMP_DIR}/session_[0-9]*/; do + if [[ -d "\$session_dir/logs" ]]; then + session_name=\$(basename "\$session_dir") + mkdir -p "$LOG_DIR/ray/\$session_name" + if command -v rsync > /dev/null 2>&1; then + rsync -ahP "\$session_dir/logs/" "$LOG_DIR/ray/\$session_name/logs/" 2>/dev/null || true + else + cp -r "\$session_dir/logs" "$LOG_DIR/ray/\$session_name/" + fi + fi + done + fi + if [[ -f "$LOG_DIR/ENDED" ]]; then + echo "Log sync sidecar terminating..." + break + fi + done +} +log-sync-sidecar & + +# Patch nsight.py before starting Ray head +sed -i 's/context\.py_executable = " "\.join(self\.nsight_cmd) + " python"/context.py_executable = " ".join(self.nsight_cmd) + f" {context.py_executable}"/g' /opt/nemo_rl_venv/lib64/python*/site-packages/ray/_private/runtime_env/nsight.py + +cat </dev/null); do + if [[ $elapsed_time -ge $RAY_HEAD_START_TIMEOUT ]]; then + echo "[ERROR][$(date)] Ray head node failed to start within $RAY_HEAD_START_TIMEOUT seconds. Exiting..." + touch $LOG_DIR/ENDED + exit 1 + fi + echo "[INFO][$(date)] Waiting for Ray head node container to start and be ready... ($elapsed_time/$RAY_HEAD_START_TIMEOUT seconds)" + sleep 2 + elapsed_time=$((elapsed_time + 2)) +done + +# Calculate total expected actors across all nodes +NUM_ACTORS=$((worker_units_per_node * SLURM_JOB_NUM_NODES)) + +# Start Ray worker nodes +# We want 1 Ray worker node per physical node +# Worker nodes are started with ray start but without the --head flag +for ((i = 1; i < SLURM_JOB_NUM_NODES; i++)); do + node_i=${nodes_array[$i]} + + worker_cmd=$(cat <$CLUSTER_DIR/ray_cluster_info.json +{ + "head_ip": "$head_node_ip", + "dashboard_port": "$DASHBOARD_PORT", + "port": "$PORT" +} +EOF +# Set up trap to clean up cluster info on job termination +cleanup_cluster_info() { + echo "[INFO] Cleaning up Ray cluster information" + rm -f $CLUSTER_DIR/ray_cluster_info.json +} + +# Register the cleanup function to run on script exit +trap cleanup_cluster_info EXIT + + +echo "[INFO] Ray cluster information saved to $CLUSTER_DIR/ray_cluster_info.json" + +######################################################## + +{% if srun_commands %} +# Run extra commands +{% for srun_command in srun_commands %} +{%- if loop.index <= group_env_vars|length %} +{%- for env_var in group_env_vars[loop.index - 1] %} +{{env_var}} +{%- endfor %} +{%- endif %} + +{{srun_command}} +{% endfor %} +######################################################## +{% endif -%} + +# We can now launch a job on this cluster +# We do so by launching a driver process on the physical node that the head node is on +# This driver process is responsible for launching a job on the Ray cluster +CONTAINER_CWD=$(scontrol show job $SLURM_JOB_ID --json | jq -r '.jobs[].current_working_directory') +# Define command to be empty by default +COMMAND="${COMMAND:-{{ command | default('', true) }}}" +COMMAND_WORKDIR={{ command_workdir | default('$CONTAINER_CWD') }} + +if [[ -n "$COMMAND" ]]; then + srun --no-container-mount-home --gpus=0 --overlap --container-name=ray-head --container-workdir=$COMMAND_WORKDIR --nodes=1 --ntasks=1 -w "$head_node" -o $LOG_DIR/{{ ray_log_prefix }}job.log bash -c "$COMMAND" +else + echo "[INFO]: Ray Cluster is idled, run this on the slurm head node to get a shell to the head node:" + cat <$CLUSTER_DIR/scripts/${SLURM_JOB_ID}-attach.sh +# No args launches on the head node +WORKER_NUM=\${1:-} +if [[ -z "\$WORKER_NUM" ]]; then + # Empty means we are on the head node + srun --no-container-mount-home --gpus=0 -A $SLURM_JOB_ACCOUNT -p $SLURM_JOB_PARTITION --overlap --container-name=ray-head --container-workdir=$CONTAINER_CWD --nodes=1 --ntasks=1 -w "$head_node" --jobid $SLURM_JOB_ID --pty bash +else + nodes_array=($nodes) + srun --no-container-mount-home {%- if gres_specification %}{{gres_specification}}{% endif %} -A $SLURM_JOB_ACCOUNT -p $SLURM_JOB_PARTITION --overlap --container-name=ray-worker-\$WORKER_NUM --container-workdir=$CONTAINER_CWD --nodes=1 --ntasks=1 -w "\${nodes_array[\$WORKER_NUM]}" --jobid $SLURM_JOB_ID --pty bash +fi +EOF + chmod +x $CLUSTER_DIR/scripts/${SLURM_JOB_ID}-attach.sh + echo " bash $CLUSTER_DIR/scripts/${SLURM_JOB_ID}-attach.sh" + sleep infinity +fi diff --git a/src/nemotron/kit/track.py b/src/nemotron/kit/track.py new file mode 100644 index 0000000..9f93f96 --- /dev/null +++ b/src/nemotron/kit/track.py @@ -0,0 +1,53 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Tracking configuration for artifact resolution.""" + +from dataclasses import dataclass + +STAGE_DIRS = {"pretrain": "stage0_pretrain", "sft": "stage1_sft", "rl": "stage2_rl"} + + +@dataclass +class TrackConfig: + """Configuration for artifact tracking and resolution.""" + + backend: str # "fsspec" or "wandb" + output_root: str | None = None # For fsspec backend (can be any fsspec URI) + + +_config: TrackConfig | None = None + + +def init(backend: str = "fsspec", output_root: str | None = None) -> None: + """Initialize tracking configuration. + + Args: + backend: "fsspec" or "wandb" + output_root: Output root for fsspec backend - can be local path or any + fsspec URI (hf://org/repo, s3://bucket/path, etc.) + Default: ./output + """ + global _config + _config = TrackConfig( + backend=backend, + output_root=output_root or "./output", + ) + + +def get_config() -> TrackConfig: + """Get current config. Returns default fsspec config if init() not called.""" + if _config is None: + return TrackConfig(backend="fsspec", output_root="./output") + return _config diff --git a/src/nemotron/kit/trackers.py b/src/nemotron/kit/trackers.py new file mode 100644 index 0000000..707386a --- /dev/null +++ b/src/nemotron/kit/trackers.py @@ -0,0 +1,593 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +""" +Lineage tracking backends for nemotron.kit. + +Provides the LineageTracker protocol and implementations for W&B and no-op tracking. +""" + +import os +from dataclasses import dataclass +from pathlib import Path +from typing import TYPE_CHECKING, Any, Protocol +from urllib.parse import quote + +if TYPE_CHECKING: + from nemotron.kit.artifact import Artifact + + +@dataclass +class InputDatasetInfo: + """Metadata for an input dataset to register as a W&B artifact. + + This captures all relevant metadata from the blend specification and + discovery phase so input datasets can be properly tracked for lineage. + + Attributes: + uri: The source URI (hf://, s3://, file://) + name: Dataset name from blend specification + weight: Weight in the blend (default: 1.0) + split: HuggingFace split name + subset: HuggingFace config/subset name + text_field: Field containing text to tokenize + num_rows: Number of rows (from HF metadata) + size_bytes: Size in bytes (from HF metadata) + num_files: Number of input files discovered + """ + + uri: str + name: str | None = None + weight: float = 1.0 + split: str | None = None + subset: str | None = None + text_field: str = "text" + # Discovered metadata from planning phase + num_rows: int | None = None + size_bytes: int | None = None + num_files: int | None = None + + +def _uri_to_artifact_name(uri: str, subset: str | None = None) -> str: + """Convert a URI to a valid W&B artifact name. + + W&B artifact names can only contain alphanumeric characters, dashes, + underscores, and dots. This sanitizes URIs for use as artifact names. + + Args: + uri: Source URI (e.g., "hf://nvidia/Nemotron-CC", "s3://bucket/key") + subset: Optional subset name to append (for HuggingFace datasets with subsets) + + Returns: + Sanitized artifact name + """ + import re + + # Remove protocol prefix + if "://" in uri: + name = uri.split("://", 1)[1] + else: + name = uri + + # Append subset if provided (important for same-path different-subset datasets) + if subset: + name = f"{name}-{subset}" + + # Replace path separators and invalid characters with dashes + name = re.sub(r"[/\\:@#?&=+%]", "-", name) + + # Remove leading/trailing dashes and collapse multiple dashes + name = re.sub(r"-+", "-", name).strip("-") + + # Ensure it starts with alphanumeric + if name and not name[0].isalnum(): + name = "dataset-" + name + + # Truncate to max length (128 chars for W&B) + return name[:128] if name else "dataset" + + +def to_wandb_uri(path: str) -> str: + """Convert a data path to a W&B-compatible reference URI. + + Args: + path: Data path in various formats: + - hf://repo/name -> https://huggingface.co/datasets/repo/name + - s3://bucket/key -> s3://bucket/key (unchanged) + - gs://bucket/key -> gs://bucket/key (unchanged) + - /local/path -> file:///local/path + + Returns: + W&B-compatible URI for add_reference() + """ + if path.startswith("hf://"): + # HuggingFace dataset: hf://nvidia/Nemotron-CC -> https://huggingface.co/datasets/nvidia/Nemotron-CC + repo = path[5:] # Remove "hf://" + return f"https://huggingface.co/datasets/{repo}" + elif path.startswith("s3://") or path.startswith("gs://"): + # Cloud storage URIs are already compatible + return path + elif path.startswith("http://") or path.startswith("https://"): + # HTTP URLs are already compatible + return path + elif path.startswith("file://"): + # Already a file URI + return path + else: + # Local path - convert to file:// URI + # Ensure absolute path + abs_path = Path(path).resolve() + return f"file://{abs_path}" + + +def tokenizer_to_uri(model: str, revision: str | None = None) -> str: + """Convert a tokenizer model name/path to a reference URI. + + Args: + model: Tokenizer model name (e.g., "meta-llama/Llama-3.2-1B") or local path + revision: Optional git revision/commit SHA for HuggingFace models + + Returns: + URI for the tokenizer + """ + if "/" in model and not model.startswith("/"): + # HuggingFace model name + base_url = f"https://huggingface.co/{quote(model, safe='/')}" + if revision: + return f"{base_url}/tree/{revision}" + return base_url + else: + # Local path + abs_path = Path(model).resolve() + return f"file://{abs_path}" + + +class LineageTracker(Protocol): + """Protocol for lineage tracking backends (W&B, MLflow, custom). + + Implement these 4 methods to integrate with any tracking system. + """ + + def is_active(self) -> bool: + """Check if tracking is currently active.""" + ... + + def use_artifact(self, ref: str, artifact_type: str) -> Path: + """Mark artifact as used (for lineage). Returns local path. + + Args: + ref: Artifact reference (e.g., "team/project/data:v1") + artifact_type: Type of artifact (e.g., "dataset", "checkpoint") + + Returns: + Local path where artifact is available + """ + ... + + def log_artifact(self, artifact: "Artifact", name: str, used_refs: list[str]) -> dict[str, Any]: + """Log artifact to tracking backend. + + Args: + artifact: The artifact to log + name: Name for the artifact + used_refs: List of artifact references that were used to create this + + Returns: + Dictionary with tracking metadata (artifact_id, url, etc.) + """ + ... + + def get_run_id(self) -> str | None: + """Get current run ID.""" + ... + + +# Global tracker instance +_tracker: LineageTracker | None = None + + +def set_lineage_tracker(tracker: LineageTracker | None) -> None: + """Set the artifact tracking backend. + + Examples: + >>> from nemotron.kit import WandbTracker + >>> set_lineage_tracker(WandbTracker()) # Use W&B + >>> set_lineage_tracker(None) # Disable tracking + """ + global _tracker + _tracker = tracker + + +def get_lineage_tracker() -> LineageTracker | None: + """Get the current artifact tracker.""" + return _tracker + + +class WandbTracker: + """Weights & Biases (W&B) tracking backend. + + Automatically logs artifacts and tracks lineage. + + Example: + >>> import wandb + >>> from nemotron.kit import set_lineage_tracker, WandbTracker + >>> + >>> wandb.init(project="my-project") + >>> set_lineage_tracker(WandbTracker()) + >>> # Now all artifact.save() calls log to W&B + """ + + def __init__(self) -> None: + """Initialize W&B tracker. + + Raises: + ImportError: If wandb is not installed + """ + try: + import wandb + + self.wandb = wandb + except ImportError: + raise ImportError( + "wandb is required for WandbTracker. Install it with: pip install wandb" + ) + + def is_active(self) -> bool: + """Check if W&B run is active.""" + return self.wandb.run is not None + + def use_artifact(self, ref: str, artifact_type: str) -> Path: + """Download artifact from W&B and mark as used. + + Args: + ref: W&B artifact reference (e.g., "team/project/data:v1") + artifact_type: Type of artifact + + Returns: + Local path where artifact is downloaded + """ + if not self.is_active(): + raise RuntimeError("No active W&B run. Call wandb.init() first.") + + # Use artifact (tracks lineage) + artifact = self.wandb.run.use_artifact(ref, type=artifact_type) + + # Download to local cache + artifact_dir = artifact.download() + + return Path(artifact_dir) + + def _register_input_datasets( + self, datasets: list[InputDatasetInfo] + ) -> tuple[list[str], list[Any]]: + """Register input datasets as W&B artifacts for lineage tracking. + + Each dataset is registered with its full metadata so users can trace + data provenance from the raw source through to the final processed artifact. + + For external datasets (HuggingFace, S3, etc.), we use run.use_artifact() + with an Artifact object. This both creates the artifact (if needed) and + marks it as an input to this run. + + Args: + datasets: List of input dataset info with metadata + + Returns: + Tuple of (artifact_refs, artifact_objects) where: + - artifact_refs: List of artifact references (entity/project/name:version) + - artifact_objects: List of W&B artifact objects for use in lineage + """ + artifact_refs = [] + artifact_objects = [] + + for ds in datasets: + # Create artifact name from URI and subset (sanitize for wandb) + artifact_name = _uri_to_artifact_name(ds.uri, subset=ds.subset) + + # Build metadata dict with all available dataset info + metadata: dict[str, Any] = { + "source_uri": ds.uri, + "raw": True, + } + if ds.name: + metadata["name"] = ds.name + if ds.weight != 1.0: + metadata["weight"] = ds.weight + if ds.split: + metadata["split"] = ds.split + if ds.subset: + metadata["subset"] = ds.subset + if ds.text_field != "text": + metadata["text_field"] = ds.text_field + # Include discovered metadata from planning phase + if ds.num_rows is not None: + metadata["num_rows"] = ds.num_rows + if ds.size_bytes is not None: + metadata["size_bytes"] = ds.size_bytes + if ds.num_files is not None: + metadata["num_files"] = ds.num_files + + # Check if artifact already exists in W&B + try: + # Try to get existing artifact by name + api = self.wandb.Api() + project_path = f"{self.wandb.run.entity}/{self.wandb.run.project}" + existing = api.artifact(f"{project_path}/{artifact_name}:latest") + # Artifact exists - use it by reference string + artifact_ref = ( + f"{existing.entity}/{existing.project}/{existing.name}:{existing.version}" + ) + self.wandb.run.use_artifact(artifact_ref) + artifact_refs.append(artifact_ref) + artifact_objects.append(existing) + except Exception: + # Artifact doesn't exist - create and use it + # Build description with clickable HuggingFace link + uri = to_wandb_uri(ds.uri) + description = f"Source: {uri}" + + input_artifact = self.wandb.Artifact( + name=artifact_name, + type="dataset", + description=description, + metadata=metadata, + ) + + # Add reference to actual data location (external HF/S3/file) + try: + input_artifact.add_reference(uri, name="data", checksum=False) + except Exception: + pass # Some URIs may not support references + + # use_artifact with Artifact object both creates AND marks as input + used = self.wandb.run.use_artifact(input_artifact) + artifact_ref = f"{used.entity}/{used.project}/{used.name}:{used.version}" + artifact_refs.append(artifact_ref) + artifact_objects.append(used) + + return artifact_refs, artifact_objects + + def _register_tokenizer(self, tokenizer_uri: str) -> tuple[str | None, Any | None]: + """Register a tokenizer as a W&B artifact for lineage tracking. + + Args: + tokenizer_uri: URI to the tokenizer (HuggingFace URL or file path) + + Returns: + Tuple of (artifact_ref, artifact_object) or (None, None) if registration fails + """ + import re + + # Extract tokenizer name from URI for artifact naming + # e.g., "https://huggingface.co/meta-llama/Llama-3.2-1B" -> "meta-llama-Llama-3.2-1B" + if "huggingface.co/" in tokenizer_uri: + # Extract the model path after huggingface.co/ + match = re.search(r"huggingface\.co/([^/]+/[^/]+)", tokenizer_uri) + if match: + artifact_name = match.group(1).replace("/", "-") + else: + artifact_name = "tokenizer" + elif tokenizer_uri.startswith("file://"): + # Local path - use the last directory component + path_part = tokenizer_uri[7:] # Remove "file://" + artifact_name = Path(path_part).name or "tokenizer" + else: + artifact_name = "tokenizer" + + # Sanitize artifact name + artifact_name = re.sub(r"[^a-zA-Z0-9._-]", "-", artifact_name) + artifact_name = re.sub(r"-+", "-", artifact_name).strip("-") + artifact_name = artifact_name[:128] if artifact_name else "tokenizer" + + # Build metadata + metadata: dict[str, Any] = { + "source_uri": tokenizer_uri, + "type": "tokenizer", + } + + # Check if artifact already exists + try: + api = self.wandb.Api() + project_path = f"{self.wandb.run.entity}/{self.wandb.run.project}" + existing = api.artifact(f"{project_path}/{artifact_name}:latest") + # Artifact exists - use it by reference + artifact_ref = ( + f"{existing.entity}/{existing.project}/{existing.name}:{existing.version}" + ) + self.wandb.run.use_artifact(artifact_ref) + return artifact_ref, existing + except Exception: + # Artifact doesn't exist - create and use it + # Build description with clickable link + description = f"Source: {tokenizer_uri}" + + tokenizer_artifact = self.wandb.Artifact( + name=artifact_name, + type="tokenizer", + description=description, + metadata=metadata, + ) + + # Add reference to the tokenizer location + try: + tokenizer_artifact.add_reference(tokenizer_uri, name="tokenizer", checksum=False) + except Exception: + pass # Some URIs may not support references + + # use_artifact creates and marks as input + try: + used = self.wandb.run.use_artifact(tokenizer_artifact) + artifact_ref = f"{used.entity}/{used.project}/{used.name}:{used.version}" + return artifact_ref, used + except Exception: + return None, None + + def log_artifact(self, artifact: "Artifact", name: str, used_refs: list[str]) -> dict[str, Any]: + """Log artifact to W&B using artifact's own methods for files/references. + + Each artifact class defines what files to upload and what references to add + via get_wandb_files() and get_wandb_references() methods. + + Args: + artifact: The artifact to log + name: Name for the W&B artifact + used_refs: List of artifact references that were used + + Returns: + Dictionary with tracking metadata + """ + if not self.is_active(): + raise RuntimeError("No active W&B run. Call wandb.init() first.") + + # Register input datasets as separate artifacts for lineage + input_artifact_refs: list[str] = [] + input_artifact_objects: list[Any] = [] + + # Parse input URIs and register them + source_datasets = getattr(artifact, "source_datasets", None) + if source_datasets: + if source_datasets and isinstance(source_datasets[0], InputDatasetInfo): + input_artifact_refs, input_artifact_objects = self._register_input_datasets( + source_datasets + ) + else: + # Legacy: list[str] - convert to InputDatasetInfo + legacy_datasets = [InputDatasetInfo(uri=uri) for uri in source_datasets] + input_artifact_refs, input_artifact_objects = self._register_input_datasets( + legacy_datasets + ) + + # Register tokenizer as an input artifact for lineage + tokenizer_uri = getattr(artifact, "tokenizer_uri", None) + if tokenizer_uri: + tokenizer_artifact_ref, tokenizer_artifact_obj = self._register_tokenizer(tokenizer_uri) + if tokenizer_artifact_ref: + input_artifact_refs.append(tokenizer_artifact_ref) + if tokenizer_artifact_obj: + input_artifact_objects.append(tokenizer_artifact_obj) + + # Build metadata + metadata = { + "created_at": artifact.created_at, + **artifact.metadata, + } + + # Create W&B artifact + wb_artifact = self.wandb.Artifact( + name=name, + type=artifact.type, + metadata=metadata, + ) + + # Add files defined by the artifact (e.g., metadata.json, blend.json) + for local_path, artifact_name in artifact.get_wandb_files(): + try: + wb_artifact.add_file(local_path, name=artifact_name) + except Exception: + pass # File may not exist yet + + # Add references defined by the artifact (e.g., output directory on shared storage) + for uri, ref_name in artifact.get_wandb_references(): + try: + wb_artifact.add_reference(uri, name=ref_name, checksum=False) + except Exception: + pass # Reference may fail for some paths + + # Log metrics to run + if artifact.metrics: + self.wandb.log(artifact.metrics) + + # Mark dependencies (for lineage) + # First, add explicit used_refs passed by caller + for ref in used_refs: + try: + dep_artifact = self.wandb.Api().artifact(ref) + wb_artifact.use_artifact(dep_artifact) + except Exception: + pass + + # Then add input artifacts we just registered (use objects directly, not API lookup) + # This creates the lineage arrows: input_artifact -> output_artifact + for input_art in input_artifact_objects: + try: + wb_artifact.use_artifact(input_art) + except Exception: + pass + + # Log to W&B + logged = self.wandb.run.log_artifact(wb_artifact) + + # Wait for artifact to be logged (to get ID) + logged.wait() + + # Add "latest" alias so :latest resolves to this version + # W&B doesn't automatically update :latest when new versions are created + if "latest" not in logged.aliases: + logged.aliases.append("latest") + + # Add experiment_id as alias for cross-task artifact discovery + experiment_id = os.environ.get("NEMO_EXPERIMENT_ID") + if experiment_id: + logged.aliases.append(experiment_id) + + # Save all alias changes + logged.save() + + return { + "artifact_id": f"{logged.entity}/{logged.project}/{logged.name}:{logged.version}", + "artifact_type": artifact.type, + "run_id": self.wandb.run.id, + "url": logged.url if hasattr(logged, "url") else None, + "used_artifacts": used_refs, + "source_uris": artifact.get_input_uris(), + "input_artifact_refs": input_artifact_refs, + } + + def get_run_id(self) -> str | None: + """Get current W&B run ID.""" + return self.wandb.run.id if self.wandb.run else None + + +class NoOpTracker: + """No-op tracker that does nothing. + + Useful for testing or explicitly disabling tracking. + + Example: + >>> from nemotron.kit import set_lineage_tracker, NoOpTracker + >>> + >>> set_lineage_tracker(NoOpTracker()) # Disable tracking + """ + + def is_active(self) -> bool: + """Always returns False.""" + return False + + def use_artifact(self, ref: str, artifact_type: str) -> Path: + """Raises error - cannot use artifacts without tracking.""" + raise RuntimeError("NoOpTracker cannot load artifacts") + + def log_artifact(self, artifact: "Artifact", name: str, used_refs: list[str]) -> dict[str, Any]: + """Returns empty metadata.""" + return { + "artifact_id": None, + "artifact_type": artifact.type, + "run_id": None, + "url": None, + "used_artifacts": [], + } + + def get_run_id(self) -> str | None: + """Always returns None.""" + return None diff --git a/src/nemotron/kit/train_script.py b/src/nemotron/kit/train_script.py new file mode 100644 index 0000000..1bd43b1 --- /dev/null +++ b/src/nemotron/kit/train_script.py @@ -0,0 +1,283 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# Copyright (c) Nemotron Contributors +# SPDX-License-Identifier: MIT + +""" +Helpers for training scripts using OmegaConf-based configuration. + +This module provides utilities similar to megatron-bridge's omegaconf_utils +but without the megatron-bridge dependency, for use in data prep scripts. + +Usage: + from nemotron.kit.train_script import ( + parse_config_and_overrides, + load_omegaconf_yaml, + apply_hydra_overrides, + omegaconf_to_dataclass, + ) + + config_path, overrides = parse_config_and_overrides(default_config=DEFAULT_CONFIG) + config = load_omegaconf_yaml(config_path) + config = apply_hydra_overrides(config, overrides) + cfg = omegaconf_to_dataclass(config, MyConfig) +""" + +from __future__ import annotations + +import argparse +import os +from dataclasses import fields, is_dataclass +from pathlib import Path +from typing import Any, TypeVar + +from omegaconf import DictConfig, OmegaConf + +T = TypeVar("T") + + +def parse_config_and_overrides( + *, + argv: list[str] | None = None, + default_config: str | Path, +) -> tuple[str, list[str]]: + """Parse `--config` plus unknown args as Hydra-style overrides. + + Args: + argv: CLI arguments. Defaults to sys.argv[1:]. + default_config: Default config file path. + + Returns: + Tuple of (config_path, overrides). + """ + parser = argparse.ArgumentParser( + formatter_class=argparse.RawTextHelpFormatter, + ) + parser.add_argument( + "--config", + type=str, + default=str(default_config), + help="Path to the YAML config file", + ) + + args, overrides = parser.parse_known_args(argv) + return args.config, overrides + + +def load_omegaconf_yaml(path: str | Path) -> DictConfig: + """Load YAML config file into OmegaConf DictConfig. + + Args: + path: Path to YAML config file. + + Returns: + OmegaConf DictConfig. + + Raises: + FileNotFoundError: If config file doesn't exist. + """ + path = str(path) + if not os.path.exists(path): + raise FileNotFoundError(f"Config file not found: {path}") + return OmegaConf.load(path) + + +def apply_hydra_overrides(config: DictConfig, overrides: list[str]) -> DictConfig: + """Apply Hydra-style CLI overrides to OmegaConf config. + + Supports: + - key=value syntax with nested keys (e.g., train.lr=0.001) + - --flag boolean flags for config fields (e.g., --force sets force=true) + - --no-flag to set boolean to false (e.g., --no-force sets force=false) + + Unknown keys are silently ignored. + + Args: + config: Base OmegaConf DictConfig. + overrides: List of CLI override strings. + + Returns: + Modified config with overrides applied. + """ + for override in overrides: + # Handle --flag style boolean overrides (e.g., --force, --no-force) + if override.startswith("--"): + flag = override[2:] # Remove -- + + # Handle --no-flag syntax (sets to false) + if flag.startswith("no-"): + key = flag[3:] # Remove no- + parsed_value = False + else: + key = flag + parsed_value = True + + # Convert dashes to underscores for config keys (e.g., --dry-run -> dry_run) + key = key.replace("-", "_") + + # Only apply if key exists in config (ignore unknown flags) + if key in config: + try: + OmegaConf.update(config, key, parsed_value, merge=True) + except Exception: + pass + continue + + # Skip non key=value overrides + if "=" not in override: + continue + + key, value = override.split("=", 1) + + # Parse the value (handle booleans, numbers, null, etc.) + parsed_value = _parse_override_value(value) + + # Apply using OmegaConf.update (handles nested keys like "train.lr") + try: + OmegaConf.update(config, key, parsed_value, merge=True) + except Exception: + # Silently ignore unknown keys (like wandb.project) + pass + + return config + + +def _parse_override_value(value: str) -> Any: + """Parse a CLI override value string into Python type. + + Args: + value: String value from CLI. + + Returns: + Parsed Python value (bool, int, float, None, or str). + """ + # Handle null/None + if value.lower() in ("null", "none", "~"): + return None + + # Handle booleans + if value.lower() in ("true", "yes", "on"): + return True + if value.lower() in ("false", "no", "off"): + return False + + # Handle integers + try: + return int(value) + except ValueError: + pass + + # Handle floats + try: + return float(value) + except ValueError: + pass + + # Return as string + return value + + +def omegaconf_to_dataclass(config: DictConfig, cls: type[T]) -> T: + """Convert OmegaConf DictConfig to a dataclass instance. + + Handles nested dataclasses and Path fields. + + Args: + config: OmegaConf DictConfig to convert. + cls: Target dataclass type. + + Returns: + Dataclass instance with values from config. + """ + if not is_dataclass(cls): + raise TypeError(f"{cls.__name__} must be a dataclass") + + # Resolve config (evaluate interpolations like ${oc.env:VAR}) + resolved = OmegaConf.to_container(config, resolve=True) + + # Convert to dataclass + return _dict_to_dataclass(resolved, cls) + + +def _dict_to_dataclass(data: dict[str, Any], cls: type[T]) -> T: + """Recursively convert dict to dataclass. + + Args: + data: Dictionary with config values. + cls: Target dataclass type. + + Returns: + Dataclass instance. + """ + if not is_dataclass(cls): + return data # type: ignore + + kwargs = {} + for f in fields(cls): + if f.name not in data: + continue + + value = data[f.name] + + # Handle nested dataclasses + if is_dataclass(f.type) and isinstance(value, dict): + value = _dict_to_dataclass(value, f.type) + # Handle Path fields + elif f.type == Path and isinstance(value, str): + value = Path(value) + # Handle Optional[Path] + elif hasattr(f.type, "__origin__"): + # Check for Optional[Path] = Union[Path, None] + args = getattr(f.type, "__args__", ()) + if Path in args and isinstance(value, str): + value = Path(value) + + kwargs[f.name] = value + + return cls(**kwargs) + + +def init_wandb_from_env() -> None: + """Initialize wandb from environment variables. + + Reads WANDB_PROJECT and WANDB_ENTITY from environment. + If WANDB_PROJECT is set, initializes wandb and sets up the WandbTracker + for artifact lineage tracking. + + This is used when running via nemo-run where wandb config + is passed via environment variables to Ray workers. + """ + project = os.environ.get("WANDB_PROJECT") + entity = os.environ.get("WANDB_ENTITY") + + if not project: + return + + try: + import wandb + + # Only init if not already initialized + if wandb.run is None: + wandb.init( + project=project, + entity=entity, + job_type="data-prep", + ) + # Set up lineage tracker for artifact publishing + from nemotron.kit.trackers import WandbTracker, set_lineage_tracker + + set_lineage_tracker(WandbTracker()) + except ImportError: + pass diff --git a/src/nemotron/kit/wandb.py b/src/nemotron/kit/wandb.py new file mode 100644 index 0000000..28f30b6 --- /dev/null +++ b/src/nemotron/kit/wandb.py @@ -0,0 +1,679 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# Copyright (c) Nemotron Contributors +# SPDX-License-Identifier: MIT + +"""Weights & Biases configuration for experiment tracking and artifact storage. + +This module provides a WandbConfig dataclass that can be passed via CLI to enable +W&B artifact tracking. When configured, it automatically initializes the kit +wandb backend. + +Monkey-Patches +-------------- +This module contains several monkey-patches to work around bugs in wandb and +upstream libraries (Megatron-Bridge, NeMo-RL). These patches are applied early +in train.py scripts before wandb is initialized. + +Each patch function documents: +- **Why**: The bug or limitation being worked around +- **Upstream**: Link to upstream issue/PR if applicable +- **Remove when**: Conditions under which the patch can be safely removed + +Patches should be removed once upstream fixes are available and we bump our +minimum version requirements. Check the docstrings for specific removal criteria. + +Example: + >>> from nemotron.kit.wandb import WandbConfig, init_wandb_if_configured + >>> + >>> # In your config dataclass + >>> @dataclass + ... class MyConfig: + ... wandb: WandbConfig | None = None + >>> + >>> # In your main function + >>> def main(cfg: MyConfig): + ... init_wandb_if_configured(cfg.wandb) + ... # Now kit.init() has been called with wandb backend + ... artifact.save(name="my-artifact") # Will track in W&B +""" + +from __future__ import annotations + +import logging +from dataclasses import dataclass + +logger = logging.getLogger(__name__) + + +@dataclass +class WandbConfig: + """Weights & Biases configuration for experiment tracking and artifact storage. + + When project is set, enables W&B artifact tracking. All fields are optional + to support both tracked and untracked runs. + + Example CLI usage: + nemotron nano3 data prep pretrain --wandb.project my-project --wandb.entity my-team + """ + + project: str | None = None + """W&B project name (required to enable tracking)""" + + entity: str | None = None + """W&B entity/team name""" + + run_name: str | None = None + """W&B run name (auto-generated if not specified)""" + + tags: tuple[str, ...] = () + """Tags for filtering runs""" + + notes: str | None = None + """Notes/description for the run""" + + @property + def enabled(self) -> bool: + """Returns True if wandb is configured (project is set).""" + return self.project is not None + + +def init_wandb_if_configured( + wandb_config: WandbConfig | None, + job_type: str = "data-prep", + tags: list[str] | None = None, +) -> None: + """Initialize kit with wandb backend if WandbConfig is provided and enabled. + + This should be called at the start of command handlers to enable artifact tracking. + If wandb_config is None or project is not set, this is a no-op. + + Args: + wandb_config: WandbConfig instance or None + job_type: W&B job type for categorizing runs (default: "data-prep") + tags: Additional tags to add to the run (merged with config tags) + + Example: + >>> def main(cfg: MyConfig): + ... init_wandb_if_configured(cfg.wandb, job_type="training", tags=["pretrain"]) + ... # Artifacts will now be tracked in W&B + """ + if wandb_config is None or not wandb_config.enabled: + return + + # Use importlib to avoid being detected by SelfContainedPackager's AST-based + # import inliner. This function isn't used by RL training, but the packager + # would otherwise inline the entire nemotron.kit module (which requires pydantic). + import importlib + + kit = importlib.import_module("nemotron.kit") + + # Initialize kit with wandb backend (enables artifact tracking) + kit.init( + backend="wandb", + wandb_project=wandb_config.project, + wandb_entity=wandb_config.entity, + ) + + # Initialize wandb run if not already active + try: + import wandb + except ImportError: + raise ImportError("wandb is required for W&B tracking. Install with: pip install wandb") + + if wandb.run is None: + # Merge config tags with additional tags + all_tags: list[str] = [] + if wandb_config.tags: + all_tags.extend(wandb_config.tags) + if tags: + all_tags.extend(tags) + + wandb.init( + project=wandb_config.project, + entity=wandb_config.entity, + name=wandb_config.run_name, + tags=all_tags if all_tags else None, + notes=wandb_config.notes, + job_type=job_type, + ) + + +def add_wandb_tags(tags: list[str]) -> None: + """Add tags to the active wandb run if one exists. + + This can be called after wandb is initialized to add stage-specific tags. + Tags are merged with any existing tags on the run. + + Args: + tags: List of tags to add to the run + + Example: + >>> add_wandb_tags(["data-prep", "pretrain"]) + """ + try: + import wandb + + if wandb.run is not None and tags: + # Get existing tags and merge + existing_tags = list(wandb.run.tags) if wandb.run.tags else [] + new_tags = list(set(existing_tags + tags)) # Deduplicate + wandb.run.tags = new_tags + except ImportError: + pass + except Exception: + pass # Don't fail if tags can't be added + + +def finish_wandb(exit_code: int = 0) -> None: + """Finish the active wandb run if one exists. + + This should be called at the end of a successful run to properly close + the wandb session. Without this, runs will appear as "crashed" in the + W&B dashboard. + + Args: + exit_code: Exit code to report. 0 for success, non-zero for failure. + + Example: + >>> try: + ... # Do work + ... artifact.save() + ... finish_wandb(exit_code=0) + ... except Exception: + ... finish_wandb(exit_code=1) + ... raise + """ + try: + import wandb + + if wandb.run is not None: + wandb.finish(exit_code=exit_code) + except ImportError: + pass + + +_HTTP_HANDLER_PATCHED = False +_LOCAL_FILE_HANDLER_PATCHED = False +_WANDB_INIT_PATCHED = False +_LINEAGE_REGISTERED = False +_RUNID_PATCHED = False +_CHECKPOINT_LOGGING_PATCHED = False +_NEMO_RL_CHECKPOINT_LOGGING_PATCHED = False +_PENDING_ARTIFACT_QUALIFIED_NAMES: set[str] = set() +_PENDING_TAGS: set[str] = set() + + +def patch_wandb_http_handler_skip_digest_verification() -> None: + """Skip digest verification for HTTP reference artifacts. + + Why: + HuggingFace URLs (and some other backends) return varying ETags over time. + W&B stores the ETag as a digest when creating the artifact, but when + downloading, the ETag may have changed, causing "digest mismatch" errors. + + Upstream: + No upstream issue filed yet. W&B's HTTPHandler doesn't support + skip_verification option. + + Remove when: + - W&B adds a `skip_verification` parameter to HTTPHandler, OR + - HuggingFace stabilizes their ETags for model files + """ + global _HTTP_HANDLER_PATCHED + if _HTTP_HANDLER_PATCHED: + return + + try: + from wandb.sdk.artifacts.storage_handlers import http_handler + + original_load_path = http_handler.HTTPHandler.load_path + + def patched_load_path(self, manifest_entry, local: bool = False): + import os + import tempfile + + import requests + + url = getattr(manifest_entry, "ref", None) + if url is None: + return original_load_path(self, manifest_entry, local=local) + + path = getattr(manifest_entry, "path", None) + if local or path is None: + fd, tmp_path = tempfile.mkstemp() + os.close(fd) + path = tmp_path + + response = requests.get(url, stream=True, timeout=30) + response.raise_for_status() + + with open(path, "wb") as f: + for chunk in response.iter_content(chunk_size=8192): + f.write(chunk) + + return path + + http_handler.HTTPHandler.load_path = patched_load_path + _HTTP_HANDLER_PATCHED = True + logger.debug("Patched wandb HTTP handler to skip digest verification") + except Exception as e: + logger.warning(f"Failed to patch wandb HTTP handler: {e}") + + +def patch_wandb_local_file_handler_skip_digest_verification() -> None: + """Skip digest verification for local file reference artifacts. + + Why: + Local file references become stale when data prep is re-run. The original + artifact stores a checksum of the file, but if the file is regenerated + (even with identical content), the checksum verification fails because + W&B compares against the stored digest. + + Upstream: + No upstream issue filed yet. W&B's LocalFileHandler doesn't support + skip_verification option. + + Remove when: + - W&B adds a `skip_verification` parameter to LocalFileHandler + """ + global _LOCAL_FILE_HANDLER_PATCHED + if _LOCAL_FILE_HANDLER_PATCHED: + return + + try: + from wandb.sdk.artifacts.storage_handlers import local_file_handler + + original_load_path = local_file_handler.LocalFileHandler.load_path + + def patched_load_path(self, manifest_entry, local: bool = False): + # Skip digest verification - just return the local path + path = getattr(manifest_entry, "ref", None) + if path and path.startswith("file://"): + path = path[7:] # Remove "file://" prefix + if path is None: + return original_load_path(self, manifest_entry, local=local) + return path + + local_file_handler.LocalFileHandler.load_path = patched_load_path + _LOCAL_FILE_HANDLER_PATCHED = True + logger.debug("Patched wandb LocalFileHandler to skip digest verification") + except Exception as e: + logger.warning(f"Failed to patch wandb LocalFileHandler: {e}") + + +def patch_wandb_init_for_lineage( + *, + artifact_qualified_names: list[str], + tags: list[str] | None = None, +) -> None: + """Patch wandb.init() to register artifact lineage after initialization. + + Why: + Megatron-Bridge owns wandb.init(), but we resolve artifacts (via ${art:...} + interpolations) before MB calls init(). Without this patch, artifact lineage + (input artifacts used by the run) would not be recorded because wandb.run + doesn't exist yet when we resolve artifacts. + + How: + We wrap wandb.init() to call _register_lineage_if_possible() after the + original init completes. This registers all pending artifacts as inputs + to the run using wandb.run.use_artifact(). + + Upstream: + Not a bug - this is an architectural limitation. Megatron-Bridge doesn't + provide a post-init hook. + + Remove when: + - We take over wandb.init() ourselves, OR + - Megatron-Bridge provides a post-init callback/hook, OR + - We restructure artifact resolution to happen after wandb.init() + """ + global _WANDB_INIT_PATCHED + + if artifact_qualified_names: + _PENDING_ARTIFACT_QUALIFIED_NAMES.update(map(str, artifact_qualified_names)) + if tags: + _PENDING_TAGS.update(map(str, tags)) + + if _WANDB_INIT_PATCHED: + return + + import wandb + + original_init = wandb.init + + def patched_init(*args, **kwargs): + result = original_init(*args, **kwargs) + _register_lineage_if_possible() + return result + + wandb.init = patched_init + _WANDB_INIT_PATCHED = True + logger.debug("Patched wandb.init for lineage registration") + + +def _register_lineage_if_possible() -> None: + global _LINEAGE_REGISTERED + if _LINEAGE_REGISTERED: + return + + try: + import wandb + except ImportError: + return + + if wandb.run is None: + return + + if _PENDING_TAGS: + add_wandb_tags(sorted(_PENDING_TAGS)) + + for qname in sorted(_PENDING_ARTIFACT_QUALIFIED_NAMES): + try: + wandb.run.use_artifact(qname) + except Exception as e: + logger.warning(f"Failed to register artifact lineage for {qname}: {e}") + + _LINEAGE_REGISTERED = True + + +def patch_wandb_runid_for_seeded_random() -> None: + """Patch wandb's generate_fast_id to use OS entropy instead of global random. + + Why: + ML training code commonly calls random.seed() for reproducibility before + wandb artifacts are created. W&B's generate_fast_id() uses Python's global + random module, so after seeding, all runs generate the same artifact IDs, + causing "Invalid Client ID digest" errors. + + How: + We replace generate_fast_id() with a version that uses an independent + Random instance seeded from os.urandom(), unaffected by global seeding. + + Upstream: + https://github.com/wandb/wandb/pull/11039 (fix merged but not yet released) + + Remove when: + - wandb >= X.Y.Z (version containing the fix) is required in pyproject.toml + - Check the PR above to find which version includes the fix + """ + global _RUNID_PATCHED + if _RUNID_PATCHED: + return + + import os + import random as random_module + + from wandb.sdk.artifacts import artifact as artifact_module + from wandb.sdk.lib import runid + + # Create an independent random instance seeded from OS entropy + # This ensures it's not affected by any global random.seed() calls + _independent_random = random_module.Random() + _independent_random.seed(os.urandom(32)) # Seed from OS entropy + + id_chars = "abcdefghijklmnopqrstuvwxyz0123456789" + + def patched_generate_fast_id(length: int = 8) -> str: + return "".join(_independent_random.choices(id_chars, k=length)) + + # Patch both the source module AND the artifact module's imported reference + runid.generate_fast_id = patched_generate_fast_id + artifact_module.generate_fast_id = patched_generate_fast_id + _RUNID_PATCHED = True + logger.info("[WANDB] Patched generate_fast_id in both runid and artifact modules") + + +def _resolve_to_lustre_path(path: str) -> str: + """Resolve a container path to the actual Lustre path. + + When running in a container, /nemo_run is a bind mount that maps to the actual + Lustre path. This function resolves the path using: + 1. NEMO_RUN_DIR environment variable (if set) + 2. Reading /proc/mounts to find bind mount source + + Args: + path: Path string, possibly starting with /nemo_run/ + + Returns: + Path with /nemo_run/ replaced by actual Lustre path + """ + import os + from pathlib import Path as PathLib + + resolved = str(PathLib(path).resolve()) + + # If path doesn't start with /nemo_run, nothing to do + if not resolved.startswith("/nemo_run"): + return resolved + + # Method 1: Use NEMO_RUN_DIR environment variable + nemo_run_dir = os.environ.get("NEMO_RUN_DIR") + if nemo_run_dir and nemo_run_dir != "/nemo_run": + logger.info(f"[WANDB] Using NEMO_RUN_DIR={nemo_run_dir} for path resolution") + if resolved.startswith("/nemo_run/"): + return resolved.replace("/nemo_run/", f"{nemo_run_dir}/", 1) + elif resolved == "/nemo_run": + return nemo_run_dir + + # Method 2: Try to find /nemo_run bind mount source from /proc/mounts + try: + with open("/proc/mounts", "r") as f: + for line in f: + parts = line.split() + if len(parts) >= 2: + source, target = parts[0], parts[1] + if target == "/nemo_run" and source.startswith("/"): + logger.info(f"[WANDB] Found /nemo_run bind mount: {source}") + if resolved.startswith("/nemo_run/"): + return resolved.replace("/nemo_run/", f"{source}/", 1) + elif resolved == "/nemo_run": + return source + except (OSError, IOError) as e: + logger.warning(f"[WANDB] Could not read /proc/mounts: {e}") + + logger.warning( + f"[WANDB] Could not resolve /nemo_run to Lustre path. " + f"Set NEMO_RUN_DIR environment variable to the actual Lustre path." + ) + return resolved + + +def patch_wandb_checkpoint_logging() -> None: + """Patch Megatron-Bridge's checkpoint logging to call wait() after log_artifact. + + Why: + Megatron-Bridge's on_save_checkpoint_success() logs checkpoint artifacts + using wandb.run.log_artifact() but doesn't call logged.wait(). Without + wait(), artifacts are uploaded asynchronously and may not appear in the + W&B UI until much later (or not at all if the job crashes). + + How: + We replace on_save_checkpoint_success with a version that: + 1. Creates the artifact with file reference + 2. Logs the artifact + 3. Calls wait() to ensure immediate commit + 4. Also resolves container paths (/nemo_run/) to actual Lustre paths + so artifacts can be accessed from other jobs + + Upstream: + No issue filed yet. Megatron-Bridge should add wait() call. + + Remove when: + - Megatron-Bridge adds wait() to on_save_checkpoint_success upstream + """ + from pathlib import Path + from typing import Any + + global _CHECKPOINT_LOGGING_PATCHED + if _CHECKPOINT_LOGGING_PATCHED: + return + + from megatron.bridge.training.utils import wandb_utils + + def patched_on_save_checkpoint_success( + checkpoint_path: str, + save_dir: str, + iteration: int, + wandb_writer: Any | None, + ) -> None: + if not wandb_writer or not wandb_writer.run: + return + + try: + # Resolve the checkpoint path to absolute + checkpoint_path_resolved = Path(checkpoint_path).resolve() + + # Verify checkpoint directory actually exists before logging + if not checkpoint_path_resolved.exists(): + logger.warning( + f"[WANDB] Checkpoint path does not exist, skipping artifact: {checkpoint_path_resolved}" + ) + return + + # Store the save_dir (parent of checkpoint) as absolute_path + # Megatron-Bridge expects pretrained_checkpoint to be the save directory, + # and it constructs the full checkpoint path by appending iter_XXXXXX + save_dir_resolved = _resolve_to_lustre_path(str(Path(save_dir).resolve())) + absolute_path = save_dir_resolved + + artifact_name, artifact_version = wandb_utils._get_artifact_name_and_version( + Path(save_dir), Path(checkpoint_path) + ) + + # Create artifact with file reference + # Use the container path that actually exists for add_reference validation, + # but store the absolute path in metadata for cross-job access + metadata = {"iteration": iteration, "absolute_path": absolute_path} + artifact = wandb_writer.Artifact(artifact_name, type="model", metadata=metadata) + + # Use the resolved container path (which exists) for add_reference + artifact.add_reference(f"file://{str(checkpoint_path_resolved)}", checksum=False) + + # Log artifact with alias + logged = wandb_writer.run.log_artifact(artifact, aliases=[artifact_version]) + + # Wait for commit (this is what was missing in Megatron-Bridge) + logged.wait() + logger.info(f"[WANDB] Artifact committed: {artifact_name}:{artifact_version}") + + # Write tracker file for later reference + wandb_tracker_filename = wandb_utils._get_wandb_artifact_tracker_filename(save_dir) + wandb_tracker_filename.write_text( + f"{wandb_writer.run.entity}/{wandb_writer.run.project}" + ) + except Exception as e: + logger.error(f"[WANDB] Failed to log checkpoint artifact: {e}") + + wandb_utils.on_save_checkpoint_success = patched_on_save_checkpoint_success + _CHECKPOINT_LOGGING_PATCHED = True + logger.info("[WANDB] Patched checkpoint logging to add wait() call") + + +def patch_nemo_rl_checkpoint_logging() -> None: + """Patch NeMo-RL's CheckpointManager to log checkpoint artifacts to W&B. + + Why: + NeMo-RL's CheckpointManager saves checkpoints locally but doesn't log them + as W&B artifacts. This means RL checkpoints aren't tracked in W&B and can't + be referenced using ${art:...} in downstream stages. + + How: + We wrap CheckpointManager.finalize_checkpoint() to: + 1. Call the original finalize (renames tmp_step_X to step_X) + 2. Create a W&B artifact with file reference to the checkpoint + 3. Log with aliases (step_N, latest) + 4. Call wait() to ensure immediate commit + + Artifact format: + - type: "model" + - name: "rl" (matches pretrain/sft naming convention) + - metadata: step number, absolute_path (resolved Lustre path) + - file reference: local path to checkpoint directory + + Upstream: + No issue filed yet. NeMo-RL should add native W&B artifact logging. + + Remove when: + - NeMo-RL adds native W&B artifact logging for checkpoints + """ + from pathlib import Path + from typing import Any + + global _NEMO_RL_CHECKPOINT_LOGGING_PATCHED + if _NEMO_RL_CHECKPOINT_LOGGING_PATCHED: + return + + try: + from nemo_rl.utils.checkpoint import CheckpointManager + except ImportError: + logger.warning("[WANDB] nemo_rl not installed, skipping checkpoint logging patch") + return + + original_finalize_checkpoint = CheckpointManager.finalize_checkpoint + + def patched_finalize_checkpoint(self, checkpoint_path: Any) -> None: + """Finalize checkpoint and log to W&B as artifact.""" + # Call original finalize first + original_finalize_checkpoint(self, checkpoint_path) + + # Now log to wandb + try: + import wandb + except ImportError: + return + + if wandb.run is None: + return + + try: + checkpoint_path = Path(checkpoint_path) + # After finalize, tmp_step_X becomes step_X + step_str = checkpoint_path.name.split("_")[-1] + step = int(step_str) + + # Final checkpoint path after rename + final_checkpoint_path = checkpoint_path.parent / f"step_{step}" + # Resolve to absolute container path (for add_reference validation) + checkpoint_path_resolved = str(final_checkpoint_path.resolve()) + # Get the absolute shared filesystem path for cross-job access + absolute_path = _resolve_to_lustre_path(str(final_checkpoint_path)) + + # Create artifact with naming convention matching pretrain/sft + artifact_name = "rl" + artifact_version = f"step_{step}" + + # Store absolute_path in metadata for cross-job access + metadata = {"step": step, "absolute_path": absolute_path} + artifact = wandb.Artifact(artifact_name, type="model", metadata=metadata) + # Use the resolved container path (which exists) for add_reference + artifact.add_reference(f"file://{checkpoint_path_resolved}", checksum=False) + + # Log artifact with alias + logged = wandb.run.log_artifact(artifact, aliases=[artifact_version, "latest"]) + + # Wait for commit to ensure artifact is visible immediately + logged.wait() + logger.info( + f"[WANDB] RL checkpoint artifact committed: {artifact_name}:{artifact_version}" + ) + + except Exception as e: + logger.error(f"[WANDB] Failed to log RL checkpoint artifact: {e}") + + CheckpointManager.finalize_checkpoint = patched_finalize_checkpoint + _NEMO_RL_CHECKPOINT_LOGGING_PATCHED = True + logger.info("[WANDB] Patched NeMo-RL CheckpointManager for artifact logging") diff --git a/src/nemotron/recipes/README.md b/src/nemotron/recipes/README.md new file mode 100644 index 0000000..acdf28f --- /dev/null +++ b/src/nemotron/recipes/README.md @@ -0,0 +1,144 @@ +# Nemotron Recipes + +Reproducible training pipelines for NVIDIA Nemotron models. + +## Overview + +Recipes are complete training pipelines that take you from raw data to a fully trained model. Each recipe includes: + +- **Data preparation**: Tokenization and formatting for each training stage +- **Training scripts**: Pre-configured for distributed training with Megatron-Bridge or NeMo-RL +- **Configuration files**: Production-ready defaults with testing variants +- **Artifact tracking**: Full lineage from raw data → tokenized data → model checkpoints via W&B Artifacts API + +## Available Recipes + +| Recipe | Description | Status | +|--------|-------------|--------| +| [nano3](./nano3/) | Nemotron Nano 3 (31.6B total / 3.6B active params) - 3-stage training pipeline | Available | +| chipnemo | ChipNeMo/ScaleRTL (Domain-adapted for RTL code generation) | Planned | + +## Prerequisites (v0) + +> **Slurm Only**: This initial release has been tested exclusively with Slurm execution. Support for additional NeMo-Run executors (local, Docker, SkyPilot, DGX Cloud) is planned for future releases. + +- **Slurm cluster**: GPU nodes (H100 recommended) +- **Weights & Biases**: Required for experiment tracking and artifact lineage +- **Container images**: NeMo containers (e.g., `nvcr.io/nvidian/nemo:25.11-nano-v3.rc2`) + +> Future versions will also make the artifact backend configurable, removing the W&B requirement. + +## Quick Start + +### 1. Set up env.toml + +Create an `env.toml` file in your project root with your execution profiles and W&B configuration: + +```toml +[wandb] +project = "nemotron" +entity = "YOUR-TEAM" + +[YOUR-CLUSTER] +executor = "slurm" +account = "YOUR-ACCOUNT" +partition = "batch" +nodes = 2 +ntasks_per_node = 8 +gpus_per_node = 8 +mounts = ["/lustre:/lustre"] +``` + +> **Note**: Container images are specified in the recipe config files (e.g., `config/tiny.yaml`), not in env.toml. + +See [docs/train/nemo-run.md](../../docs/train/nemo-run.md) for complete profile configuration options. + +### 2. Run a Recipe + +```bash +# Prepare data for pretraining +uv run nemotron nano3 data prep pretrain --run YOUR-CLUSTER + +# Run pretraining on Slurm +uv run nemotron nano3 pretrain -c tiny --run YOUR-CLUSTER + +# Check what would be executed (dry-run) +uv run nemotron nano3 pretrain -c tiny --run YOUR-CLUSTER --dry-run +``` + +## Execution Methods + +### nemotron CLI (Recommended) + +The main entrypoint for running recipes. It integrates natively with [NeMo-Run](https://github.com/NVIDIA-NeMo/Run), providing: + +- Automatic code packaging and syncing to remote clusters +- Environment setup and container management +- Job submission to Slurm, local execution, Docker, or cloud backends + +#### `--run` vs `--batch` + +| Option | Behavior | Use Case | +|--------|----------|----------| +| `--run ` | **Attached** - submits and waits, streaming logs | Interactive development, debugging | +| `--batch ` | **Detached** - submits and exits immediately | Long training runs, job queues | + +```bash +# Attached: waits for job, streams logs to terminal +uv run nemotron nano3 pretrain -c tiny --run YOUR-CLUSTER + +# Detached: submits job and returns immediately +uv run nemotron nano3 pretrain -c tiny --batch YOUR-CLUSTER + +# Preview execution plan (no submission) +uv run nemotron nano3 pretrain -c tiny --run YOUR-CLUSTER --dry-run +``` + +### Direct Script Execution + +Scripts can also be executed directly inside a container on a compute node. This is useful for debugging or interactive development: + +```bash +# Inside container on compute node +python train.py --config /path/to/config.yaml + +# With torchrun for distributed training +torchrun --nproc_per_node=8 train.py --config /path/to/config.yaml +``` + +## CLI Command Structure + +```bash +uv run nemotron [options] + +# Data preparation commands +uv run nemotron nano3 data prep pretrain [--run ] [options] +uv run nemotron nano3 data prep sft [--run ] [options] +uv run nemotron nano3 data prep rl [--run ] [options] + +# Training commands +uv run nemotron nano3 pretrain [--run ] [-c ] [overrides] +uv run nemotron nano3 sft [--run ] [-c ] [overrides] +uv run nemotron nano3 rl [--run ] [-c ] [overrides] +``` + +## Artifact Lineage + +Recipes use the W&B Artifacts API to track the full lineage of your training pipeline: + +``` +Raw Data → Data Prep → Tokenized Data (Artifact) + ↓ + Pretraining → Checkpoint (Artifact) + ↓ + SFT → Checkpoint (Artifact) + ↓ + RL → Final Model (Artifact) +``` + +Each stage can reference artifacts from previous stages, ensuring reproducibility and traceability. + +## Further Reading + +- [NeMo-Run Configuration](../../docs/train/nemo-run.md) - Detailed guide on execution profiles and env.toml setup +- [Nano3 Recipe](./nano3/) - Complete documentation for the Nemotron Nano 3 training pipeline diff --git a/src/nemotron/recipes/__init__.py b/src/nemotron/recipes/__init__.py new file mode 100644 index 0000000..85cacb3 --- /dev/null +++ b/src/nemotron/recipes/__init__.py @@ -0,0 +1,31 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +""" +Reproducible training recipes for NVIDIA Nemotron models. + +This package contains full training pipelines for various Nemotron models, +including data curation, training, and evaluation stages. + +Available Recipes: +- nano3: Nemotron Nano 3 (2B parameters) +- chipnemo: ChipNeMo/ScaleRTL (Domain-adapted for RTL code generation) + +Usage: + # Run complete stage + uv run python -m nemotron.recipes.nano3.stage0_pretrain --scale tiny + + # Run individual steps + uv run python -m nemotron.recipes.nano3.stage0_pretrain.data_curation --scale tiny +""" diff --git a/src/nemotron/recipes/nano3/README.md b/src/nemotron/recipes/nano3/README.md new file mode 100644 index 0000000..dae4c0a --- /dev/null +++ b/src/nemotron/recipes/nano3/README.md @@ -0,0 +1,268 @@ +# Nemotron 3 Nano Training Recipe + +A complete 3-stage training pipeline for Nemotron 3 Nano, an open, efficient Mixture-of-Experts (MoE) hybrid Mamba-Transformer model optimized for agentic reasoning. + +## Paper + +**Tech Report**: [Nemotron 3 Nano: Open, Efficient Mixture-of-Experts Hybrid Mamba-Transformer Model for Agentic Reasoning](https://arxiv.org/abs/2506.XXXXX) + +> **Open-Source Data Only**: These recipes train exclusively on the open-sourced subset of training data. Results will differ from the tech report benchmarks, which used additional proprietary data. Use these recipes as reference implementations to apply the methodology with your own data. + +## Model Overview + +Nemotron 3 Nano achieves better or on-par accuracy than competitive models while having up to 3.3x higher inference throughput. It supports an extended long context of 1M tokens, outperforming both GPT-OSS-20B and Qwen3-30B-A3B on RULER across different context lengths. + +| Property | Value | +|----------|-------| +| Total Parameters | 31.6B | +| Active Parameters | 3.6B (per forward pass) | +| Architecture | Hybrid Mamba-Transformer with sparse MoE | +| Pretraining Tokens | 25 trillion | +| Context Length | Up to 1M tokens | +| Training Stages | 3 (Pretrain → SFT → RL) | + +### Architecture Details + +| Component | Value | +|-----------|-------| +| Num Layers | 32 | +| Model Dimension | 3008 | +| Total Routable Experts | 128 | +| Num Activated Experts | 6 | +| Shared Experts | 2 | + +### Key Capabilities + +- **Agentic Reasoning**: Enhanced multi-step and multi-turn agentic tasks +- **Tool Use**: XML-style tool calling with reduced hallucination via DPO +- **Reasoning Control**: On/off control and token budget control +- **Long Context**: Up to 1M tokens with strong RULER performance +- **Multilingual**: Support for 15+ languages + +## Training Pipeline + +```mermaid +flowchart TB + subgraph stage0["Stage 0: Pretraining"] + direction LR + raw["Raw Text Corpus"] --> dp0["data_prep.py
(bin/idx)"] --> train0["train.py
(Megatron-Bridge)"] --> base["Base Model"] + end + + subgraph stage1["Stage 1: SFT"] + direction LR + inst["Instruction Datasets"] --> dp1["data_prep.py
(.npy)"] --> train1["train.py
(Megatron-Bridge)"] --> instruct["Instruct Model"] + end + + subgraph stage2["Stage 2: RL"] + direction LR + pref["Preference Datasets"] --> dp2["data_prep.py
(JSONL)"] --> train2["train.py
(NeMo-RL/GRPO)"] --> aligned["Aligned Model"] + end + + base --> train1 + instruct --> train2 + + style stage0 fill:#e1f5fe + style stage1 fill:#f3e5f5 + style stage2 fill:#e8f5e9 +``` + +| Stage | Purpose | Framework | Output | +|-------|---------|-----------|--------| +| [Stage 0: Pretrain](./stage0_pretrain/) | Train on large text corpus | Megatron-Bridge | Base model checkpoint | +| [Stage 1: SFT](./stage1_sft/) | Instruction tuning | Megatron-Bridge | Instruction-following model | +| [Stage 2: RL](./stage2_rl/) | Alignment with GRPO | NeMo-RL | Final aligned model | + +## Prerequisites + +### v0 Requirements + +> **Slurm Only**: This initial release has been tested exclusively with Slurm execution. Support for additional NeMo-Run executors (local, Docker, SkyPilot, DGX Cloud) is planned for future releases. + +- **Slurm cluster**: GPU nodes (H100 recommended) +- **Weights & Biases**: Required for experiment tracking and artifact lineage (future versions will be backend-agnostic) +- **Container images**: NeMo containers with Megatron-Bridge and NeMo-RL + +### env.toml Setup + +Create an `env.toml` file in your project root: + +```toml +[wandb] +project = "nemotron" +entity = "YOUR-TEAM" + +[YOUR-CLUSTER] +executor = "slurm" +account = "YOUR-ACCOUNT" +partition = "batch" +nodes = 2 +ntasks_per_node = 8 +gpus_per_node = 8 +mounts = ["/lustre:/lustre"] +``` + +> **Note**: Container images are specified in the recipe config files (e.g., `config/tiny.yaml`), not in env.toml. + +See [docs/train/nemo-run.md](../../../docs/train/nemo-run.md) for complete configuration options. + +## Quick Start + +### Full Pipeline + +```bash +# Stage 0: Data prep + Pretraining +uv run nemotron nano3 data prep pretrain --run YOUR-CLUSTER +uv run nemotron nano3 pretrain --run YOUR-CLUSTER + +# Stage 1: Data prep + SFT +uv run nemotron nano3 data prep sft --run YOUR-CLUSTER +uv run nemotron nano3 sft --run YOUR-CLUSTER + +# Stage 2: Data prep + RL +uv run nemotron nano3 data prep rl --run YOUR-CLUSTER +uv run nemotron nano3 rl --run YOUR-CLUSTER +``` + +### Testing with Tiny Config + +Use the `tiny` config variant for quick testing: + +```bash +# Quick test with small dataset sample +uv run nemotron nano3 data prep pretrain --run YOUR-CLUSTER --sample 1000 + +# Quick training test (small model, few iterations) +uv run nemotron nano3 pretrain -c tiny --run YOUR-CLUSTER +``` + +## CLI Commands + +### Data Preparation + +```bash +# Pretrain data: tokenize to Megatron bin/idx format +uv run nemotron nano3 data prep pretrain [--run ] [--sample N] [--force] + +# SFT data: apply chat templates, tokenize to .npy +uv run nemotron nano3 data prep sft [--run ] [--sample N] [--force] + +# RL data: convert to JSONL chat format +uv run nemotron nano3 data prep rl [--run ] [--sample N] [--force] +``` + +### Training + +```bash +# Pretraining +uv run nemotron nano3 pretrain [--run ] [-c ] [overrides...] + +# Supervised Fine-Tuning +uv run nemotron nano3 sft [--run ] [-c ] [overrides...] + +# Reinforcement Learning +uv run nemotron nano3 rl [--run ] [-c ] [overrides...] +``` + +### Execution Options + +| Option | Description | +|--------|-------------| +| `--run ` | **Attached** - submits job and waits, streaming logs to terminal | +| `--batch ` | **Detached** - submits job and exits immediately | +| `-c ` | Select config file (e.g., `-c tiny` for testing) | +| `--dry-run` | Preview what would be executed | +| `key=value` | Override config values (Hydra-style) | + +#### When to use `--run` vs `--batch` + +- **`--run`**: Interactive development, debugging, short test runs where you want to see logs in real-time +- **`--batch`**: Long training runs (hours/days), submitting multiple jobs, overnight/unattended runs + +## Configuration Files + +Each stage has a `config/` directory with: + +| File | Purpose | +|------|---------| +| `default.yaml` | Production configuration template | +| `tiny.yaml` | Testing variant (small model, few iterations) | +| `data_prep.yaml` | Data preparation configuration | +| `data_blend_raw.json` | Dataset blend specification | + +Override config values on the command line: + +```bash +# Override training iterations +uv run nemotron nano3 pretrain -c tiny train.train_iters=5000 + +# Override batch size +uv run nemotron nano3 pretrain -c tiny train.global_batch_size=64 +``` + +## Artifact Flow + +The pipeline uses W&B Artifacts to track lineage between stages: + +```mermaid +flowchart TB + subgraph pretrain["Pretraining"] + data0["DataBlendsArtifact-pretrain"] --> cmd0["uv run nemotron nano3 pretrain"] + cmd0 --> model0["ModelArtifact-pretrain"] + end + + subgraph sft["SFT"] + data1["DataBlendsArtifact-sft"] --> cmd1["uv run nemotron nano3 sft"] + model0 --> cmd1 + cmd1 --> model1["ModelArtifact-sft"] + end + + subgraph rl["RL"] + data2["DataBlendsArtifact-rl"] --> cmd2["uv run nemotron nano3 rl"] + model1 --> cmd2 + cmd2 --> model2["ModelArtifact-rl
(Final)"] + end + + style pretrain fill:#e1f5fe + style sft fill:#f3e5f5 + style rl fill:#e8f5e9 +``` + +Artifacts are automatically linked when you run stages in sequence, providing full traceability from raw data to final model. + +## Execution Methods + +### nemotron CLI (Recommended) + +The main entrypoint integrates with [NeMo-Run](https://github.com/NVIDIA-NeMo/Run) for streamlined execution: + +```bash +# Submit to Slurm cluster +uv run nemotron nano3 pretrain -c tiny --run megatron + +# Check execution plan before submitting +uv run nemotron nano3 pretrain -c tiny --run megatron --dry-run +``` + +### Direct Script Execution + +Scripts can be executed directly inside a container on a compute node (useful for debugging): + +```bash +# Inside container on compute node +cd src/nemotron/recipes/nano3/stage0_pretrain +python train.py --config config/tiny.yaml + +# With torchrun for distributed training +torchrun --nproc_per_node=8 train.py --config config/tiny.yaml +``` + +## Stage Documentation + +- [Stage 0: Pretraining](./stage0_pretrain/README.md) - Pretrain on large text corpus +- [Stage 1: SFT](./stage1_sft/README.md) - Supervised fine-tuning for instruction following +- [Stage 2: RL](./stage2_rl/README.md) - Reinforcement learning for alignment + +## Further Reading + +- [NeMo-Run Configuration](../../../docs/train/nemo-run.md) - Complete guide to env.toml and execution profiles +- [Recipes Overview](../README.md) - General information about Nemotron recipes diff --git a/src/nemotron/recipes/nano3/__init__.py b/src/nemotron/recipes/nano3/__init__.py new file mode 100644 index 0000000..8cb0e00 --- /dev/null +++ b/src/nemotron/recipes/nano3/__init__.py @@ -0,0 +1,15 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Nano3 training recipe.""" diff --git a/src/nemotron/recipes/nano3/stage0_pretrain/README.md b/src/nemotron/recipes/nano3/stage0_pretrain/README.md new file mode 100644 index 0000000..b2ff630 --- /dev/null +++ b/src/nemotron/recipes/nano3/stage0_pretrain/README.md @@ -0,0 +1,243 @@ +# Stage 0: Pretraining + +Pretrain Nemotron Nano 3 on a large text corpus using Megatron-Bridge. + +## Overview + +This stage tokenizes raw text data and trains the base language model from scratch. It produces a pretrained checkpoint that serves as the foundation for subsequent instruction tuning (SFT) and alignment (RL) stages. + +> **Open-Source Data Only**: This recipe trains exclusively on the open-sourced subset of pretraining data. Results will differ from the tech report benchmarks, which used additional proprietary data. Use this recipe as a reference implementation to apply the methodology with your own data. + +| Component | Description | +|-----------|-------------| +| `data_prep.py` | Tokenizes raw text into Megatron bin/idx format | +| `train.py` | Runs pretraining using Megatron-Bridge | +| `config/` | Configuration files for data prep and training | + +## Quick Start + +### Using nemotron CLI (Recommended) + +```bash +# 1. Prepare data (tokenize to bin/idx format) +uv run nemotron nano3 data prep pretrain --run YOUR-CLUSTER + +# 2. Run pretraining +uv run nemotron nano3 pretrain --run YOUR-CLUSTER + +# Quick test with tiny config +uv run nemotron nano3 pretrain -c tiny --run YOUR-CLUSTER +``` + +### Direct Script Execution + +Inside a container on a compute node: + +```bash +# Data preparation +python data_prep.py --config config/data_prep.yaml + +# Training (single node) +python train.py --config config/tiny.yaml + +# Training (distributed) +torchrun --nproc_per_node=8 train.py --config config/tiny.yaml +``` + +## Data Preparation + +The `data_prep.py` script tokenizes raw text datasets into Megatron's binary format. + +### CLI Command + +```bash +uv run nemotron nano3 data prep pretrain [options] +``` + +| Option | Description | +|--------|-------------| +| `--run ` | Execute on Slurm via NeMo-Run | +| `--sample N` | Limit rows per dataset (for testing) | +| `--force` | Force re-run, ignoring cache | + +### Input + +Dataset blend defined in `config/data_blend_raw.json`: + +```json +{ + "datasets": [ + {"name": "dataset-name", "weight": 1.0, "split": "train"}, + ... + ] +} +``` + +### Output + +``` +output/nano3/stage0_pretrain/ +├── train/ +│ ├── data_00000.bin +│ ├── data_00000.idx +│ └── ... +├── valid/ +│ └── ... +├── test/ +│ └── ... +└── blend.json # Per-split data paths for Megatron-Bridge +``` + +The output is registered as a W&B Artifact (`DataBlendsArtifact-pretrain`) for lineage tracking. + +### Configuration + +`config/data_prep.yaml`: + +```yaml +blend_path: config/data_blend_raw.json +output_dir: output/nano3/stage0_pretrain +num_shards: 128 +tokenizer_model: nvidia/NVIDIA-Nemotron-Nano-9B-v2 +add_bos: false +add_eos: true +``` + +## Training + +The `train.py` script runs pretraining using Megatron-Bridge. + +### CLI Command + +```bash +uv run nemotron nano3 pretrain [options] [overrides...] +``` + +| Option | Description | +|--------|-------------| +| `--run ` | Attached execution on Slurm | +| `--batch ` | Detached execution (submit and exit) | +| `-c ` | Config file (e.g., `-c tiny` for testing) | +| `--dry-run` | Preview execution plan | +| `key=value` | Override config values (Hydra-style) | + +### Input + +- **Data**: `DataBlendsArtifact-pretrain` (from data prep) +- **Config**: `config/default.yaml` or `config/tiny.yaml` + +### Output + +- Model checkpoints saved to configured `checkpoint.save` path +- Registered as W&B Artifact for downstream stages + +### Configuration Files + +| File | Purpose | +|------|---------| +| `config/default.yaml` | Production configuration | +| `config/tiny.yaml` | Testing (small model, 1700 iterations) | +| `config/data_blend_raw.json` | Full dataset blend | +| `config/data_blend_raw_small.json` | Small blend (math-only) for testing | + +#### config/tiny.yaml + +```yaml +run: + data: DataBlendsArtifact-pretrain:latest + +recipe: + _target_: megatron.bridge.recipes.qwen.qwen3.qwen3_8b_pretrain_config + per_split_data_args_path: ${art:data,path}/blend.json + +train: + train_iters: 1700 + global_batch_size: 32 + +scheduler: + lr_warmup_iters: 32 + +logger: + log_interval: 10 + wandb_project: ${run.wandb.project} + wandb_entity: ${run.wandb.entity} + +checkpoint: + save: /nemo_run/pretrain + save_interval: 20 +``` + +### Override Examples + +```bash +# More training iterations +uv run nemotron nano3 pretrain -c tiny train.train_iters=5000 + +# Larger batch size +uv run nemotron nano3 pretrain -c tiny train.global_batch_size=64 + +# Different checkpoint location +uv run nemotron nano3 pretrain -c tiny checkpoint.save=/path/to/checkpoints +``` + +## Running with NeMo-Run + +The nemotron CLI uses [NeMo-Run](https://github.com/NVIDIA-NeMo/Run) for job orchestration. + +### env.toml Setup + +Configure execution profiles in `env.toml`: + +```toml +[wandb] +project = "nemotron" +entity = "YOUR-TEAM" + +[YOUR-CLUSTER] +executor = "slurm" +account = "YOUR-ACCOUNT" +partition = "batch" +nodes = 2 +ntasks_per_node = 8 +gpus_per_node = 8 +mounts = ["/lustre:/lustre"] +``` + +> **Note**: Container images are specified in the recipe config files (e.g., `config/tiny.yaml`), not in env.toml. + +### Execution Modes + +```bash +# Attached (wait for completion) +uv run nemotron nano3 pretrain -c tiny --run YOUR-CLUSTER + +# Detached (submit and exit) +uv run nemotron nano3 pretrain -c tiny --batch YOUR-CLUSTER + +# Preview without executing +uv run nemotron nano3 pretrain -c tiny --run YOUR-CLUSTER --dry-run +``` + +See [docs/train/nemo-run.md](../../../../docs/train/nemo-run.md) for complete configuration options. + +## Artifact Lineage + +```mermaid +flowchart TB + raw["Raw Text Data"] --> dp["data_prep.py"] + dp --> data["DataBlendsArtifact-pretrain
(bin/idx files + blend.json)"] + data --> train["train.py"] + train --> model["ModelArtifact-pretrain
(checkpoint)"] + model --> next["Stage 1: SFT"] + + style raw fill:#e1f5fe + style dp fill:#e1f5fe + style data fill:#e1f5fe + style train fill:#e1f5fe + style model fill:#e1f5fe + style next fill:#f3e5f5 +``` + +## Next Steps + +After pretraining completes, proceed to [Stage 1: SFT](../stage1_sft/README.md) for instruction tuning. diff --git a/src/nemotron/recipes/nano3/stage0_pretrain/__init__.py b/src/nemotron/recipes/nano3/stage0_pretrain/__init__.py new file mode 100644 index 0000000..9150aa2 --- /dev/null +++ b/src/nemotron/recipes/nano3/stage0_pretrain/__init__.py @@ -0,0 +1,15 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Nemotron Nano 3 stage 0 (pretraining) recipe package.""" diff --git a/src/nemotron/recipes/nano3/stage0_pretrain/config/data_prep/data_blend_raw.json b/src/nemotron/recipes/nano3/stage0_pretrain/config/data_prep/data_blend_raw.json new file mode 100644 index 0000000..67cd669 --- /dev/null +++ b/src/nemotron/recipes/nano3/stage0_pretrain/config/data_prep/data_blend_raw.json @@ -0,0 +1,165 @@ +{ + "datasets": [ + { + "name": "nemotron-math-3", + "path": "hf://nvidia/Nemotron-CC-Math-v1", + "subset": "3", + "text_field": "text", + "weight": 1.0 + }, + { + "name": "nemotron-math-4plus", + "path": "hf://nvidia/Nemotron-CC-Math-v1", + "subset": "4plus", + "text_field": "text", + "weight": 1.0 + }, + { + "name": "nemotron-math-4plus-mind", + "path": "hf://nvidia/Nemotron-CC-Math-v1", + "subset": "4plus_MIND", + "text_field": "text", + "weight": 1.0 + }, + { + "name": "nemotron-cc-v2-diverse-qa", + "path": "hf://nvidia/Nemotron-CC-v2", + "subset": "Diverse-QA", + "text_field": "text", + "weight": 1.0 + }, + { + "name": "nemotron-cc-v2-high-quality", + "path": "hf://nvidia/Nemotron-CC-v2", + "subset": "High-Quality", + "text_field": "text", + "weight": 1.0 + }, + { + "name": "nemotron-cc-v2-high-quality-synthetic", + "path": "hf://nvidia/Nemotron-CC-v2", + "subset": "High-Quality-Synthetic", + "text_field": "text", + "weight": 1.0 + }, + { + "name": "nemotron-cc-v2-medium-high-quality", + "path": "hf://nvidia/Nemotron-CC-v2", + "subset": "Medium-High-Quality", + "text_field": "text", + "weight": 1.0 + }, + { + "name": "nemotron-cc-v2-medium-quality", + "path": "hf://nvidia/Nemotron-CC-v2", + "subset": "Medium-Quality", + "text_field": "text", + "weight": 1.0 + }, + { + "name": "nemotron-cc-v2-translated-diverse-qa", + "path": "hf://nvidia/Nemotron-CC-v2", + "subset": "Translated-Diverse-QA", + "text_field": "text", + "weight": 1.0 + }, + { + "name": "nemotron-cc-v2.1-high-quality", + "path": "hf://nvidia/Nemotron-CC-v2.1", + "subset": "High-Quality", + "text_field": "text", + "weight": 1.0 + }, + { + "name": "nemotron-cc-v2.1-high-quality-synthetic", + "path": "hf://nvidia/Nemotron-CC-v2.1", + "subset": "High-Quality-Synthetic", + "text_field": "text", + "weight": 1.0 + }, + { + "name": "nemotron-cc-v2.1-high-quality-translated-to-english", + "path": "hf://nvidia/Nemotron-CC-v2.1", + "subset": "High-Quality-Translated-To-English", + "text_field": "text", + "weight": 1.0 + }, + { + "name": "nemotron-cc-v2.1-high-quality-translated-to-english-synthetic", + "path": "hf://nvidia/Nemotron-CC-v2.1", + "subset": "High-Quality-Translated-To-English-Synthetic", + "text_field": "text", + "weight": 1.0 + }, + { + "name": "nemotron-cc-v2.1-medium-high-quality", + "path": "hf://nvidia/Nemotron-CC-v2.1", + "subset": "Medium-High-Quality", + "text_field": "text", + "weight": 1.0 + }, + { + "name": "nemotron-cc-v2.1-medium-high-quality-synthetic", + "path": "hf://nvidia/Nemotron-CC-v2.1", + "subset": "Medium-High-Quality-Synthetic", + "text_field": "text", + "weight": 1.0 + }, + { + "name": "nemotron-cc-v2.1-medium-high-quality-translated-to-english", + "path": "hf://nvidia/Nemotron-CC-v2.1", + "subset": "Medium-High-Quality-Translated-To-English", + "text_field": "text", + "weight": 1.0 + }, + { + "name": "nemotron-cc-v2.1-medium-quality", + "path": "hf://nvidia/Nemotron-CC-v2.1", + "subset": "Medium-Quality", + "text_field": "text", + "weight": 1.0 + }, + { + "name": "nemotron-pretraining-infinibyte-reasoning", + "path": "hf://nvidia/Nemotron-Pretraining-Specialized-v1", + "subset": "Nemotron-Pretraining-InfiniByte-Reasoning", + "text_field": "text", + "weight": 1.0 + }, + { + "name": "nemotron-pretraining-math-textbooks", + "path": "hf://nvidia/Nemotron-Pretraining-Specialized-v1", + "subset": "Nemotron-Pretraining-Math-Textbooks", + "text_field": "text", + "weight": 1.0 + }, + { + "name": "nemotron-pretraining-rqa", + "path": "hf://nvidia/Nemotron-Pretraining-Specialized-v1", + "subset": "Nemotron-Pretraining-RQA", + "text_field": "text", + "weight": 1.0 + }, + { + "name": "nemotron-pretraining-stem-sft", + "path": "hf://nvidia/Nemotron-Pretraining-Specialized-v1", + "subset": "Nemotron-Pretraining-STEM-SFT", + "text_field": "text", + "weight": 1.0 + }, + { + "name": "nemotron-pretraining-scientific-coding", + "path": "hf://nvidia/Nemotron-Pretraining-Specialized-v1", + "subset": "Nemotron-Pretraining-Scientific-Coding", + "text_field": "text", + "weight": 1.0 + }, + { + "name": "nemotron-pretraining-wiki-rewrite", + "path": "hf://nvidia/Nemotron-Pretraining-Specialized-v1", + "subset": "Nemotron-Pretraining-Wiki-Rewrite", + "text_field": "text", + "weight": 1.0 + } + ] +} diff --git a/src/nemotron/recipes/nano3/stage0_pretrain/config/data_prep/data_blend_raw_large.json b/src/nemotron/recipes/nano3/stage0_pretrain/config/data_prep/data_blend_raw_large.json new file mode 100644 index 0000000..3be21de --- /dev/null +++ b/src/nemotron/recipes/nano3/stage0_pretrain/config/data_prep/data_blend_raw_large.json @@ -0,0 +1,166 @@ +{ + "datasets": [ + { + "name": "nemotron-math-3", + "path": "hf://nvidia/Nemotron-CC-Math-v1", + "subset": "3", + "text_field": "text", + "weight": 1.0 + }, + { + "name": "nemotron-math-4plus", + "path": "hf://nvidia/Nemotron-CC-Math-v1", + "subset": "4plus", + "text_field": "text", + "weight": 1.0 + }, + { + "name": "nemotron-math-4plus-mind", + "path": "hf://nvidia/Nemotron-CC-Math-v1", + "subset": "4plus_MIND", + "text_field": "text", + "weight": 1.0 + }, + { + "name": "nemotron-cc-v2-diverse-qa", + "path": "hf://nvidia/Nemotron-CC-v2", + "subset": "Diverse-QA", + "text_field": "text", + "weight": 1.0 + }, + { + "name": "nemotron-cc-v2-high-quality", + "path": "hf://nvidia/Nemotron-CC-v2", + "subset": "High-Quality", + "text_field": "text", + "weight": 1.0 + }, + { + "name": "nemotron-cc-v2-high-quality-synthetic", + "path": "hf://nvidia/Nemotron-CC-v2", + "subset": "High-Quality-Synthetic", + "text_field": "text", + "weight": 1.0 + }, + { + "name": "nemotron-cc-v2-medium-high-quality", + "path": "hf://nvidia/Nemotron-CC-v2", + "subset": "Medium-High-Quality", + "text_field": "text", + "weight": 1.0 + }, + { + "name": "nemotron-cc-v2-medium-quality", + "path": "hf://nvidia/Nemotron-CC-v2", + "subset": "Medium-Quality", + "text_field": "text", + "weight": 1.0 + }, + { + "name": "nemotron-cc-v2-translated-diverse-qa", + "path": "hf://nvidia/Nemotron-CC-v2", + "subset": "Translated-Diverse-QA", + "text_field": "text", + "weight": 1.0 + }, + { + "name": "nemotron-cc-v2.1-high-quality", + "path": "hf://nvidia/Nemotron-CC-v2.1", + "subset": "High-Quality", + "text_field": "text", + "weight": 1.0 + }, + { + "name": "nemotron-cc-v2.1-high-quality-synthetic", + "path": "hf://nvidia/Nemotron-CC-v2.1", + "subset": "High-Quality-Synthetic", + "text_field": "text", + "weight": 1.0 + }, + { + "name": "nemotron-cc-v2.1-high-quality-translated-to-english", + "path": "hf://nvidia/Nemotron-CC-v2.1", + "subset": "High-Quality-Translated-To-English", + "text_field": "text", + "weight": 1.0 + }, + { + "name": "nemotron-cc-v2.1-high-quality-translated-to-english-synthetic", + "path": "hf://nvidia/Nemotron-CC-v2.1", + "subset": "High-Quality-Translated-To-English-Synthetic", + "text_field": "text", + "weight": 1.0 + }, + { + "name": "nemotron-cc-v2.1-medium-high-quality", + "path": "hf://nvidia/Nemotron-CC-v2.1", + "subset": "Medium-High-Quality", + "text_field": "text", + "weight": 1.0 + }, + { + "name": "nemotron-cc-v2.1-medium-high-quality-synthetic", + "path": "hf://nvidia/Nemotron-CC-v2.1", + "subset": "Medium-High-Quality-Synthetic", + "text_field": "text", + "weight": 1.0 + }, + { + "name": "nemotron-cc-v2.1-medium-high-quality-translated-to-english", + "path": "hf://nvidia/Nemotron-CC-v2.1", + "subset": "Medium-High-Quality-Translated-To-English", + "text_field": "text", + "weight": 1.0 + }, + { + "name": "nemotron-cc-v2.1-medium-quality", + "path": "hf://nvidia/Nemotron-CC-v2.1", + "subset": "Medium-Quality", + "text_field": "text", + "weight": 1.0 + }, + { + "name": "nemotron-pretraining-infinibyte-reasoning", + "path": "hf://nvidia/Nemotron-Pretraining-Specialized-v1", + "subset": "Nemotron-Pretraining-InfiniByte-Reasoning", + "text_field": "text", + "weight": 1.0 + }, + { + "name": "nemotron-pretraining-math-textbooks", + "path": "hf://nvidia/Nemotron-Pretraining-Specialized-v1", + "subset": "Nemotron-Pretraining-Math-Textbooks", + "text_field": "text", + "weight": 1.0 + }, + { + "name": "nemotron-pretraining-rqa", + "path": "hf://nvidia/Nemotron-Pretraining-Specialized-v1", + "subset": "Nemotron-Pretraining-RQA", + "text_field": "text", + "weight": 1.0 + }, + { + "name": "nemotron-pretraining-stem-sft", + "path": "hf://nvidia/Nemotron-Pretraining-Specialized-v1", + "subset": "Nemotron-Pretraining-STEM-SFT", + "text_field": "text", + "weight": 1.0 + }, + { + "name": "nemotron-pretraining-scientific-coding", + "path": "hf://nvidia/Nemotron-Pretraining-Specialized-v1", + "subset": "Nemotron-Pretraining-Scientific-Coding", + "text_field": "text", + "weight": 1.0 + }, + { + "name": "nemotron-pretraining-wiki-rewrite", + "path": "hf://nvidia/Nemotron-Pretraining-Specialized-v1", + "subset": "Nemotron-Pretraining-Wiki-Rewrite", + "text_field": "text", + "weight": 1.0 + } + ] + } + \ No newline at end of file diff --git a/src/nemotron/recipes/nano3/stage0_pretrain/config/data_prep/data_blend_raw_small.json b/src/nemotron/recipes/nano3/stage0_pretrain/config/data_prep/data_blend_raw_small.json new file mode 100644 index 0000000..114d377 --- /dev/null +++ b/src/nemotron/recipes/nano3/stage0_pretrain/config/data_prep/data_blend_raw_small.json @@ -0,0 +1,39 @@ +{ + "datasets": [ + { + "name": "nemotron-math-3", + "path": "hf://nvidia/Nemotron-CC-Math-v1", + "subset": "3", + "text_field": "text", + "weight": 1.0 + }, + { + "name": "nemotron-math-4plus", + "path": "hf://nvidia/Nemotron-CC-Math-v1", + "subset": "4plus", + "text_field": "text", + "weight": 1.0 + }, + { + "name": "nemotron-cc-v2-high-quality-synthetic", + "path": "hf://nvidia/Nemotron-CC-v2", + "subset": "High-Quality-Synthetic", + "text_field": "text", + "weight": 1.0 + }, + { + "name": "nemotron-cc-v2-medium-high-quality", + "path": "hf://nvidia/Nemotron-CC-v2", + "subset": "Medium-High-Quality", + "text_field": "text", + "weight": 1.0 + }, + { + "name": "nemotron-cc-v2-medium-quality", + "path": "hf://nvidia/Nemotron-CC-v2", + "subset": "Medium-Quality", + "text_field": "text", + "weight": 1.0 + } + ] +} diff --git a/src/nemotron/recipes/nano3/stage0_pretrain/config/data_prep/default.yaml b/src/nemotron/recipes/nano3/stage0_pretrain/config/data_prep/default.yaml new file mode 100644 index 0000000..c6e3d3b --- /dev/null +++ b/src/nemotron/recipes/nano3/stage0_pretrain/config/data_prep/default.yaml @@ -0,0 +1,57 @@ +run: + env: + container: anyscale/ray:2.49.2-py312 + +# Default config for pretrain data preparation +# +# Usage: +# nemotron nano3 data prep pretrain +# nemotron nano3 data prep pretrain sample=100 force=true +# +# Environment variables: +# PWD: Current working directory (for path resolution) + +# Path to data blend JSON file +blend_path: ${oc.env:PWD}/src/nemotron/recipes/nano3/stage0_pretrain/config/data_prep/data_blend_raw.json + +# Output directory for tokenized data (outputs to job directory for persistence) +output_dir: ${oc.env:PWD}/../output/stage0_pretrain + +# Number of output shards for parallel loading +num_shards: 128 + +# Number of shards for validation split +valid_shards: 1 + +# Number of shards for test split +test_shards: 1 + +# HuggingFace tokenizer model name +tokenizer_model: nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-Base-BF16 + +# Prepend BOS token to documents +add_bos: false + +# Append EOS token to documents +add_eos: true + +# Default text field name in datasets +text_field: text + +# Skip documents shorter than this (null = no limit) +min_doc_chars: null + +# Truncate documents longer than this (null = no limit) +max_doc_tokens: null + +# Limit rows per dataset for quick tests (null = no limit) +sample: null + +# Ray actors for parallel processing (null = auto) +num_actors: null + +# Force new run, ignoring cache +force: false + +# Config name for artifact naming (produces PretrainBlendsArtifact-default) +config_name: default diff --git a/src/nemotron/recipes/nano3/stage0_pretrain/config/data_prep/tiny.yaml b/src/nemotron/recipes/nano3/stage0_pretrain/config/data_prep/tiny.yaml new file mode 100644 index 0000000..9a7a2b2 --- /dev/null +++ b/src/nemotron/recipes/nano3/stage0_pretrain/config/data_prep/tiny.yaml @@ -0,0 +1,56 @@ +run: + env: + container: anyscale/ray:2.49.2-py312 + +# Tiny config for pretrain data preparation (fast iteration/testing) +# +# Usage: +# nemotron nano3 data prep pretrain --config tiny +# nemotron nano3 data prep pretrain --config tiny --run prep +# +# This config uses sampling for quick testing. + +# Path to data blend JSON file +blend_path: ${oc.env:PWD}/src/nemotron/recipes/nano3/stage0_pretrain/config/data_prep/data_blend_raw_small.json + +# Output directory for tokenized data (outputs to job directory for persistence) +output_dir: ${oc.env:PWD}/../output/stage0_pretrain_tiny + +# Number of output shards - smaller for tiny config +num_shards: 4 + +# Number of shards for validation split +valid_shards: 1 + +# Number of shards for test split +test_shards: 1 + +# HuggingFace tokenizer model name +tokenizer_model: nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-Base-BF16 + +# Prepend BOS token to documents +add_bos: false + +# Append EOS token to documents +add_eos: true + +# Default text field name in datasets +text_field: text + +# Skip documents shorter than this (null = no limit) +min_doc_chars: null + +# Truncate documents longer than this (null = no limit) +max_doc_tokens: null + +# Limit rows per dataset for quick tests - small sample for tiny +sample: 1000 + +# Ray actors for parallel processing (null = auto) +num_actors: null + +# Force new run, ignoring cache +force: false + +# Config name for artifact naming (produces PretrainBlendsArtifact-tiny) +config_name: tiny diff --git a/src/nemotron/recipes/nano3/stage0_pretrain/config/default.yaml b/src/nemotron/recipes/nano3/stage0_pretrain/config/default.yaml new file mode 100644 index 0000000..7176ed7 --- /dev/null +++ b/src/nemotron/recipes/nano3/stage0_pretrain/config/default.yaml @@ -0,0 +1,17 @@ +run: + data: PretrainBlendsArtifact-tiny:latest + env: + container: nvcr.io/nvidia/nemo:25.11.nemotron_3_nano + +recipe: + _target_: megatron.bridge.recipes.nemotronh.nemotron_3_nano.nemotron_3_nano_pretrain_config + per_split_data_args_path: ${art:data,path}/blend.json + +logger: + log_interval: 10 + wandb_project: ${run.wandb.project} # Set from env.toml [wandb] + wandb_entity: ${run.wandb.entity} # Set from env.toml [wandb] + +checkpoint: + save: /nemo_run/pretrain + save_interval: 20 \ No newline at end of file diff --git a/src/nemotron/recipes/nano3/stage0_pretrain/config/tiny.yaml b/src/nemotron/recipes/nano3/stage0_pretrain/config/tiny.yaml new file mode 100644 index 0000000..5ae5389 --- /dev/null +++ b/src/nemotron/recipes/nano3/stage0_pretrain/config/tiny.yaml @@ -0,0 +1,31 @@ +run: + data: PretrainBlendsArtifact-tiny:latest + env: + container: nvcr.io/nvidian/nemo:25.11-nano-v3.rc2 + +recipe: + _target_: megatron.bridge.recipes.qwen.qwen3.qwen3_8b_pretrain_config + per_split_data_args_path: ${art:data,path}/blend.json + +train: + train_iters: 1700 + global_batch_size: 32 + +# model: +# pipeline_model_parallel_size: 2 + +# tokenizer: +# tokenizer_type: HuggingFaceTokenizer +# tokenizer_model: meta-llama/Llama-3.2-1B + +scheduler: + lr_warmup_iters: 32 + +logger: + log_interval: 10 + wandb_project: ${run.wandb.project} # Set from env.toml [wandb] + wandb_entity: ${run.wandb.entity} # Set from env.toml [wandb] + +checkpoint: + save: /nemo_run/pretrain + save_interval: 20 diff --git a/src/nemotron/recipes/nano3/stage0_pretrain/data_prep.py b/src/nemotron/recipes/nano3/stage0_pretrain/data_prep.py new file mode 100644 index 0000000..463a93c --- /dev/null +++ b/src/nemotron/recipes/nano3/stage0_pretrain/data_prep.py @@ -0,0 +1,225 @@ +#!/usr/bin/env python3 + +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Data preparation for Nano3 pretraining stage. + +Tokenizes raw text data into Megatron bin/idx format. + +Outputs blend.json with {"train": [...], "valid": [...], "test": [...]} format +compatible with Megatron-Bridge's per_split_data_args_path parameter. + +Usage: + # With default config + uv run python data_prep.py + + # With custom config file + uv run python data_prep.py --config /path/to/config.yaml + + # With CLI overrides (Hydra-style) + uv run python data_prep.py sample=100 force=true + + # Via nemotron CLI with nemo-run + nemotron nano3 data prep pretrain --run prep --sample 10000 +""" + +from __future__ import annotations + +import os +import sys +from dataclasses import dataclass, field +from pathlib import Path + +from nemotron.data_prep import DataPrepConfig, PerSplitConfig, run_data_prep +from nemotron.kit import PretrainBlendsArtifact, print_step_complete +from nemotron.kit.train_script import ( + apply_hydra_overrides, + init_wandb_from_env, + load_omegaconf_yaml, + omegaconf_to_dataclass, + parse_config_and_overrides, +) +from nemotron.kit.wandb import add_wandb_tags + +STAGE_PATH = Path(__file__).parent + +# Default config path relative to this file +DEFAULT_CONFIG_PATH = STAGE_PATH / "config" / "data_prep.yaml" + +# Use NEMO_RUN_DIR for output when running via nemo-run (avoids writing to code dir) +_OUTPUT_BASE = Path(os.environ.get("NEMO_RUN_DIR", ".")) + +# Module-level flag for Ray execution (used by nemotron CLI) +RAY = True + + +@dataclass +class PreTrainDataPrepConfig: + """Pretrain data preparation config. + + Tokenizes text into Megatron bin/idx format for pretraining. + Outputs {"train": [...], "valid": [...], "test": [...]} JSON format. + """ + + blend_path: Path = field(default_factory=lambda: STAGE_PATH / "config/data_blend_raw.json") + """Path to data blend JSON file""" + + output_dir: Path = field(default_factory=lambda: _OUTPUT_BASE / "output/nano3/stage0_pretrain") + """Output directory for tokenized data""" + + num_shards: int = 128 + """Number of output shards for parallel loading""" + + valid_shards: int = 1 + """Number of shards for validation split""" + + test_shards: int = 1 + """Number of shards for test split""" + + tokenizer_model: str = "nvidia/NVIDIA-Nemotron-Nano-9B-v2" + """HuggingFace tokenizer model name""" + + add_bos: bool = False + """Prepend BOS token to documents""" + + add_eos: bool = True + """Append EOS token to documents""" + + text_field: str = "text" + """Default text field name in datasets""" + + min_doc_chars: int | None = None + """Skip documents shorter than this""" + + max_doc_tokens: int | None = None + """Truncate documents longer than this""" + + sample: int | None = None + """Limit rows per dataset (for quick tests)""" + + num_actors: int | None = None + """Ray actors for parallel processing (None = auto)""" + + force: bool = False + """Force new run, ignoring cache""" + + config_name: str = "default" + """Config name used for artifact naming (e.g., 'default', 'tiny', 'test')""" + + def __post_init__(self) -> None: + # Ensure paths are Path objects + if isinstance(self.blend_path, str): + self.blend_path = Path(self.blend_path) + if isinstance(self.output_dir, str): + self.output_dir = Path(self.output_dir) + + # Add sample suffix to output_dir if sampling + if self.sample is not None: + self.output_dir = self.output_dir / f"sample-{self.sample}" + + +def run_data_prep_main(cfg: PreTrainDataPrepConfig) -> PretrainBlendsArtifact: + """Run pretrain data preparation. + + Args: + cfg: Data prep configuration. + + Returns: + PretrainBlendsArtifact with paths to tokenized data. + """ + # Add stage-specific tags to wandb run + add_wandb_tags(["data-prep", "pretrain", cfg.config_name]) + + # Log config to W&B + try: + import wandb + from dataclasses import asdict + + if wandb.run is not None: + # Convert config to dict, handling Path objects + config_dict = asdict(cfg) + for key, value in config_dict.items(): + if isinstance(value, Path): + config_dict[key] = str(value) + wandb.config.update(config_dict) + except ImportError: + pass + + # Build artifact name using config_name. + # Example: "nano3/default/data" or "nano3/tiny/data?sample=100". + sample_suffix = f"?sample={cfg.sample}" if cfg.sample else "" + artifact_name = f"nano3/{cfg.config_name}/data{sample_suffix}" + + data_prep_config = DataPrepConfig( + blend_path=cfg.blend_path, + output_dir=cfg.output_dir, + num_shards=cfg.num_shards, + per_split=PerSplitConfig( + enabled=True, + valid_shards=cfg.valid_shards, + test_shards=cfg.test_shards, + ), + tokenizer_model=cfg.tokenizer_model, + add_bos=cfg.add_bos, + add_eos=cfg.add_eos, + text_field=cfg.text_field, + min_doc_chars=cfg.min_doc_chars, + max_doc_tokens=cfg.max_doc_tokens, + sample=cfg.sample, + num_actors=cfg.num_actors, + force=cfg.force, + artifact_name=artifact_name, + ) + artifact = run_data_prep(data_prep_config) + print_step_complete(data_prep=artifact) + return artifact + + +def main(cfg: PreTrainDataPrepConfig | None = None) -> PretrainBlendsArtifact: + """Entry point for pretrain data preparation. + + Args: + cfg: Config from CLI framework, or None when run directly as script. + + Returns: + PretrainBlendsArtifact with paths to tokenized data. + """ + if cfg is None: + # Called directly as script - parse config ourselves + config_path, cli_overrides = parse_config_and_overrides(default_config=DEFAULT_CONFIG_PATH) + + # Load YAML config + try: + config = load_omegaconf_yaml(config_path) + except FileNotFoundError as e: + print(f"Error: {e}", file=sys.stderr) + sys.exit(1) + + # Apply CLI overrides (Hydra-style: key=value) + if cli_overrides: + config = apply_hydra_overrides(config, cli_overrides) + + # Convert to dataclass + cfg = omegaconf_to_dataclass(config, PreTrainDataPrepConfig) + + # Initialize wandb from environment variables (set by nemo-run) + init_wandb_from_env() + + # Run data prep + return run_data_prep_main(cfg) + + +if __name__ == "__main__": + main() diff --git a/src/nemotron/recipes/nano3/stage0_pretrain/train.py b/src/nemotron/recipes/nano3/stage0_pretrain/train.py new file mode 100644 index 0000000..cd8a186 --- /dev/null +++ b/src/nemotron/recipes/nano3/stage0_pretrain/train.py @@ -0,0 +1,152 @@ +#!/usr/bin/env python3 + +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Pretrain script for Nemotron Nano3. + +Uses Megatron-Bridge's ConfigContainer for full training configuration. +Dynamically loads the recipe function specified in the YAML config. + +Usage: + # With YAML config file (required) + python /path/to/train.py --config /path/to/pretrain.yaml + + # With CLI overrides (Hydra syntax) + python /path/to/train.py --config /path/to/pretrain.yaml train.train_iters=5000 + + # As module (requires nemotron package installed) + torchrun --nproc_per_node=8 -m nemotron.recipes.nano3.stage0_pretrain.train \ + --config /path/to/pretrain.yaml +""" + +from __future__ import annotations + +import logging +import sys +from pathlib import Path + +import torch +from megatron.bridge.training.config import ConfigContainer +from megatron.bridge.training.gpt_step import forward_step +from megatron.bridge.training.pretrain import pretrain +from megatron.bridge.training.utils.omegaconf_utils import ( + apply_overrides, + create_omegaconf_dict_config, + parse_hydra_overrides, +) +from omegaconf import OmegaConf + +from nemotron.kit.recipe_loader import extract_recipe_config, import_recipe_function +from nemotron.kit.resolvers import clear_artifact_cache, register_resolvers_from_config +from nemotron.kit.train_script import load_omegaconf_yaml, parse_config_and_overrides +from nemotron.kit.wandb import ( + patch_wandb_checkpoint_logging, + patch_wandb_http_handler_skip_digest_verification, + patch_wandb_init_for_lineage, + patch_wandb_local_file_handler_skip_digest_verification, + patch_wandb_runid_for_seeded_random, +) + +logger: logging.Logger = logging.getLogger(__name__) + + +# Default config path relative to this file +DEFAULT_CONFIG_PATH = Path(__file__).parent / "config" / "default.yaml" + +# Default recipe function +DEFAULT_RECIPE_TARGET = ( + "megatron.bridge.recipes.nemotronh.nemotron_next_3b_v2.nemotron_next_3b_v2_pretrain_config" +) + + +def main() -> None: + """Entry point for Nemotron Nano3 pretraining.""" + try: + config_path, cli_overrides = parse_config_and_overrides(default_config=DEFAULT_CONFIG_PATH) + config = load_omegaconf_yaml(config_path) + except FileNotFoundError as e: + logger.error(str(e)) + sys.exit(1) + + # ------------------------------------------------------------------------- + # WANDB MONKEY-PATCHES + # These patches work around bugs in wandb and Megatron-Bridge. + # See nemotron/kit/wandb.py for detailed "Why" / "Remove when" documentation. + # ------------------------------------------------------------------------- + patch_wandb_http_handler_skip_digest_verification() + patch_wandb_local_file_handler_skip_digest_verification() + patch_wandb_runid_for_seeded_random() + patch_wandb_checkpoint_logging() + + # Clear artifact cache to ensure fresh downloads (important for :latest resolution) + clear_artifact_cache() + + # Resolve artifacts before wandb.init() (Megatron-Bridge initializes wandb). + qualified_names = register_resolvers_from_config( + config, + artifacts_key="run", + mode="pre_init", + pre_init_patch_http_digest=False, + ) + + # Patch wandb.init so lineage is registered immediately once MB initializes wandb. + patch_wandb_init_for_lineage( + artifact_qualified_names=qualified_names, + tags=["pretrain"], + ) + + recipe_target, recipe_kwargs = extract_recipe_config( + config, + default_target=DEFAULT_RECIPE_TARGET, + ) + + try: + recipe_func = import_recipe_function(recipe_target) + except Exception as e: + logger.error(str(e)) + sys.exit(1) + + cfg: ConfigContainer = recipe_func(**recipe_kwargs) + + # Convert the initial Python dataclass to an OmegaConf DictConfig for merging + merged_omega_conf, excluded_fields = create_omegaconf_dict_config(cfg) + + # Merge config overrides (excluding recipe field) + config_overrides = OmegaConf.to_container(config, resolve=False) + config_overrides.pop("recipe", None) + + if config_overrides: + logger.debug(f"Merging config overrides: {list(config_overrides.keys())}") + yaml_overrides_omega = OmegaConf.create(config_overrides) + merged_omega_conf = OmegaConf.merge(merged_omega_conf, yaml_overrides_omega) + logger.debug("Config overrides merged successfully.") + + # Apply command-line overrides using Hydra-style parsing + if cli_overrides: + logger.debug(f"Applying Hydra-style command-line overrides: {cli_overrides}") + merged_omega_conf = parse_hydra_overrides(merged_omega_conf, cli_overrides) + logger.debug("Hydra-style command-line overrides applied successfully.") + + final_overrides_as_dict = OmegaConf.to_container(merged_omega_conf, resolve=True) + apply_overrides(cfg, final_overrides_as_dict, excluded_fields) + + pretrain(config=cfg, forward_step_func=forward_step) + + if torch.distributed.is_initialized(): + torch.distributed.destroy_process_group() + + +if __name__ == "__main__": + main() diff --git a/src/nemotron/recipes/nano3/stage1_sft/README.md b/src/nemotron/recipes/nano3/stage1_sft/README.md new file mode 100644 index 0000000..454b4cc --- /dev/null +++ b/src/nemotron/recipes/nano3/stage1_sft/README.md @@ -0,0 +1,254 @@ +# Stage 1: Supervised Fine-Tuning (SFT) + +Fine-tune the pretrained model to follow instructions using Megatron-Bridge. + +## Overview + +This stage takes instruction-following datasets in OpenAI chat format, applies chat templates with role-based loss masking, and fine-tunes the pretrained model. The output is an instruction-following model ready for alignment training. + +> **Open-Source Data Only**: This recipe trains exclusively on the open-sourced subset of SFT data. Results will differ from the tech report benchmarks, which used additional proprietary data. Use this recipe as a reference implementation to apply the methodology with your own data. + +| Component | Description | +|-----------|-------------| +| `data_prep.py` | Applies chat templates, tokenizes to packed .npy format | +| `train.py` | Runs supervised fine-tuning using Megatron-Bridge | +| `config/` | Configuration files for data prep and training | + +## Quick Start + +### Using nemotron CLI (Recommended) + +```bash +# 1. Prepare data (apply chat templates, tokenize to .npy) +uv run nemotron nano3 data prep sft --run YOUR-CLUSTER + +# 2. Run SFT +uv run nemotron nano3 sft --run YOUR-CLUSTER + +# Quick test with tiny config +uv run nemotron nano3 sft -c tiny --run YOUR-CLUSTER +``` + +### Direct Script Execution + +Inside a container on a compute node: + +```bash +# Data preparation +python data_prep.py --config config/data_prep.yaml + +# Training (single node) +python train.py --config config/tiny.yaml + +# Training (distributed) +torchrun --nproc_per_node=8 train.py --config config/tiny.yaml +``` + +## Data Preparation + +The `data_prep.py` script processes OpenAI-format chat data into packed sequences with role-based loss masking. + +### Pipeline + +1. **Apply chat template** → Role-labeled chunks (system, user, assistant) +2. **Tokenize** → input_ids with role boundaries +3. **Build loss_mask** → 0 for system/user tokens, 1 for assistant tokens +4. **Pack sequences** → Efficient batching up to `pack_size` tokens +5. **Split by ratio** → training.npy, validation.npy, test.npy + +### CLI Command + +```bash +uv run nemotron nano3 data prep sft [options] +``` + +| Option | Description | +|--------|-------------| +| `--run ` | Execute on Slurm via NeMo-Run | +| `--sample N` | Limit rows per dataset (for testing) | +| `--force` | Force re-run, ignoring cache | + +### Input + +OpenAI chat format datasets defined in `config/data_blend_raw.json`: + +```json +{ + "datasets": [ + { + "name": "dataset-name", + "path": "hf-org/dataset", + "split": "train", + "weight": 1.0 + } + ] +} +``` + +Expected record format: + +```json +{ + "messages": [ + {"role": "system", "content": "You are a helpful assistant."}, + {"role": "user", "content": "Hello!"}, + {"role": "assistant", "content": "Hi there!"} + ] +} +``` + +### Output + +``` +output/stage1_sft/ +├── training.npy # Packed training sequences +├── validation.npy # Packed validation sequences +├── test.npy # Packed test sequences +└── metadata.json # Split statistics and packing info +``` + +Each .npy file contains packed sequences with `input_ids` and `loss_mask` arrays. + +The output is registered as a W&B Artifact (`DataBlendsArtifact-sft`) for lineage tracking. + +### Configuration + +`config/data_prep.yaml`: + +```yaml +blend_path: config/data_blend_raw.json +output_dir: output/stage1_sft +tokenizer_model: nvidia/NVIDIA-Nemotron-Nano-9B-v2 +pack_size: 4096 +chat_template: nano3 +messages_field: messages +train_ratio: 0.98 +valid_ratio: 0.01 +test_ratio: 0.01 +``` + +| Parameter | Description | +|-----------|-------------| +| `pack_size` | Maximum tokens per packed sequence | +| `chat_template` | Template name (`nano3`) or path to .jinja file | +| `messages_field` | Field containing OpenAI-format messages | +| `train_ratio` | Fraction for training split (default 0.98) | + +## Training + +The `train.py` script runs supervised fine-tuning using Megatron-Bridge. + +### CLI Command + +```bash +uv run nemotron nano3 sft [options] [overrides...] +``` + +| Option | Description | +|--------|-------------| +| `--run ` | Attached execution on Slurm | +| `--batch ` | Detached execution (submit and exit) | +| `-c ` | Config file (e.g., `-c tiny` for testing) | +| `--dry-run` | Preview execution plan | +| `key=value` | Override config values (Hydra-style) | + +### Input + +- **Model**: Pretrained checkpoint from Stage 0 (`ModelArtifact-pretrain`) +- **Data**: `DataBlendsArtifact-sft` (from data prep) +- **Config**: `config/default.yaml` or `config/tiny.yaml` + +### Output + +- Fine-tuned model checkpoints +- Registered as W&B Artifact (`ModelArtifact-sft`) for downstream RL stage + +### Configuration Files + +| File | Purpose | +|------|---------| +| `config/default.yaml` | Production configuration | +| `config/tiny.yaml` | Testing variant | +| `config/data_blend_raw.json` | Full dataset blend | +| `config/data_blend_tiny.json` | Small blend for testing | + +### Override Examples + +```bash +# More training iterations +uv run nemotron nano3 sft -c tiny train.train_iters=5000 + +# Different learning rate +uv run nemotron nano3 sft -c tiny optimizer.lr=1e-5 + +# Load specific pretrained checkpoint +uv run nemotron nano3 sft -c tiny checkpoint.load=/path/to/pretrain/checkpoint +``` + +## Running with NeMo-Run + +The nemotron CLI uses [NeMo-Run](https://github.com/NVIDIA-NeMo/Run) for job orchestration. + +### env.toml Setup + +Configure execution profiles in `env.toml`: + +```toml +[wandb] +project = "nemotron" +entity = "YOUR-TEAM" + +[YOUR-CLUSTER] +executor = "slurm" +account = "YOUR-ACCOUNT" +partition = "batch" +nodes = 2 +ntasks_per_node = 8 +gpus_per_node = 8 +mounts = ["/lustre:/lustre"] +``` + +> **Note**: Container images are specified in the recipe config files (e.g., `config/tiny.yaml`), not in env.toml. + +### Execution Modes + +```bash +# Attached (wait for completion) +uv run nemotron nano3 sft -c tiny --run YOUR-CLUSTER + +# Detached (submit and exit) +uv run nemotron nano3 sft -c tiny --batch YOUR-CLUSTER + +# Preview without executing +uv run nemotron nano3 sft -c tiny --run YOUR-CLUSTER --dry-run +``` + +See [docs/train/nemo-run.md](../../../../docs/train/nemo-run.md) for complete configuration options. + +## Artifact Lineage + +```mermaid +flowchart TB + prev["ModelArtifact-pretrain
(from Stage 0)"] --> train + inst["Instruction Datasets
(OpenAI chat format)"] --> dp["data_prep.py"] + dp --> data["DataBlendsArtifact-sft
(packed .npy files)"] + data --> train["train.py"] + train --> model["ModelArtifact-sft
(fine-tuned checkpoint)"] + model --> next["Stage 2: RL"] + + style prev fill:#e1f5fe + style inst fill:#f3e5f5 + style dp fill:#f3e5f5 + style data fill:#f3e5f5 + style train fill:#f3e5f5 + style model fill:#f3e5f5 + style next fill:#e8f5e9 +``` + +## Next Steps + +After SFT completes, proceed to [Stage 2: RL](../stage2_rl/README.md) for alignment training. + +## Previous Stage + +- [Stage 0: Pretraining](../stage0_pretrain/README.md) - Pretrain the base model diff --git a/src/nemotron/recipes/nano3/stage1_sft/__init__.py b/src/nemotron/recipes/nano3/stage1_sft/__init__.py new file mode 100644 index 0000000..d750a54 --- /dev/null +++ b/src/nemotron/recipes/nano3/stage1_sft/__init__.py @@ -0,0 +1,15 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Nemotron Nano 3 stage 1 (supervised fine-tuning) recipe package.""" diff --git a/src/nemotron/recipes/nano3/stage1_sft/config/data_prep/data_blend_raw.json b/src/nemotron/recipes/nano3/stage1_sft/config/data_prep/data_blend_raw.json new file mode 100644 index 0000000..9d5f26e --- /dev/null +++ b/src/nemotron/recipes/nano3/stage1_sft/config/data_prep/data_blend_raw.json @@ -0,0 +1,73 @@ +{ + "datasets": [ + { + "name": "science-mcq", + "path": "hf://nvidia/Nemotron-Science-v1", + "subset": "MCQ" + }, + { + "name": "science-rqa", + "path": "hf://nvidia/Nemotron-Science-v1", + "subset": "RQA" + }, + { + "name": "instruction-following-chat", + "path": "hf://nvidia/Nemotron-Instruction-Following-Chat-v1", + "subset": "chat_if" + }, + { + "name": "instruction-following-structured", + "path": "hf://nvidia/Nemotron-Instruction-Following-Chat-v1", + "subset": "structured_outputs" + }, + { + "name": "math-proofs-lean", + "path": "hf://nvidia/Nemotron-Math-Proofs-v1", + "subset": "lean" + }, + { + "name": "swe", + "path": "hf://nvidia/Nemotron-SWE-v1" + }, + { + "name": "agentic-interactive", + "path": "hf://nvidia/Nemotron-Agentic-v1", + "subset": "interactive_agent" + }, + { + "name": "agentic-tool-calling", + "path": "hf://nvidia/Nemotron-Agentic-v1", + "subset": "tool_calling" + }, + { + "name": "competitive-cpp-00", + "path": "hf://nvidia/Nemotron-Competitive-Programming-v1", + "subset": "competitive_coding_cpp.part_00" + }, + { + "name": "competitive-cpp-01", + "path": "hf://nvidia/Nemotron-Competitive-Programming-v1", + "subset": "competitive_coding_cpp.part_01" + }, + { + "name": "competitive-python-00", + "path": "hf://nvidia/Nemotron-Competitive-Programming-v1", + "subset": "competitive_coding_python.part_00" + }, + { + "name": "competitive-python-01", + "path": "hf://nvidia/Nemotron-Competitive-Programming-v1", + "subset": "competitive_coding_python.part_01" + }, + { + "name": "infinibyte-00", + "path": "hf://nvidia/Nemotron-Competitive-Programming-v1", + "subset": "infinibyte.part_00" + }, + { + "name": "infinibyte-01", + "path": "hf://nvidia/Nemotron-Competitive-Programming-v1", + "subset": "infinibyte.part_01" + } + ] +} diff --git a/src/nemotron/recipes/nano3/stage1_sft/config/data_prep/data_blend_tiny.json b/src/nemotron/recipes/nano3/stage1_sft/config/data_prep/data_blend_tiny.json new file mode 100644 index 0000000..037be06 --- /dev/null +++ b/src/nemotron/recipes/nano3/stage1_sft/config/data_prep/data_blend_tiny.json @@ -0,0 +1,14 @@ +{ + "datasets": [ + { + "name": "science-mcq", + "path": "hf://nvidia/Nemotron-Science-v1", + "subset": "MCQ" + }, + { + "name": "instruction-following-chat", + "path": "hf://nvidia/Nemotron-Instruction-Following-Chat-v1", + "subset": "chat_if" + } + ] +} diff --git a/src/nemotron/recipes/nano3/stage1_sft/config/data_prep/default.yaml b/src/nemotron/recipes/nano3/stage1_sft/config/data_prep/default.yaml new file mode 100644 index 0000000..1d77381 --- /dev/null +++ b/src/nemotron/recipes/nano3/stage1_sft/config/data_prep/default.yaml @@ -0,0 +1,59 @@ +run: + env: + container: anyscale/ray:2.49.2-py311 + +# Default config for SFT data preparation +# +# Usage: +# nemotron nano3 data prep sft +# nemotron nano3 data prep sft sample=100 force=true +# +# Environment variables: +# PWD: Current working directory (for path resolution) + +# Path to data blend JSON file +blend_path: ${oc.env:PWD}/src/nemotron/recipes/nano3/stage1_sft/config/data_prep/data_blend_raw.json + +# Output directory for packed .npy data (outputs to job directory for persistence) +output_dir: ${oc.env:PWD}/../output/stage1_sft + +# HuggingFace tokenizer model name +tokenizer_model: nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-Base-BF16 + +# Maximum tokens per packed sequence +pack_size: 4096 + +# Target size per shard (e.g., '256MB', '1GB') +shard_size: 256MB + +# Split ratios (must sum to 1.0) +train_ratio: 0.98 +valid_ratio: 0.01 +test_ratio: 0.01 + +# Chat template: 'nano3', path to .jinja file, or inline template +chat_template: nano3 + +# Field name for OpenAI-format messages in input records +messages_field: messages + +# Field name for tools definition in input records +tools_field: tools + +# Filter to only include records where used_in contains this value +used_in_filter: nano_v3 + +# Field name for used_in filtering +used_in_field: used_in + +# Truncate sequences longer than this (null = no limit) +max_doc_tokens: null + +# Limit rows per dataset for quick tests (null = no limit) +sample: null + +# Ray actors for parallel processing (null = auto) +num_actors: null + +# Force new run, ignoring cache +force: false diff --git a/src/nemotron/recipes/nano3/stage1_sft/config/data_prep/tiny.yaml b/src/nemotron/recipes/nano3/stage1_sft/config/data_prep/tiny.yaml new file mode 100644 index 0000000..9b29146 --- /dev/null +++ b/src/nemotron/recipes/nano3/stage1_sft/config/data_prep/tiny.yaml @@ -0,0 +1,58 @@ +run: + env: + container: anyscale/ray:2.49.2-py311 + +# Tiny config for SFT data preparation (fast iteration/testing) +# +# Usage: +# nemotron nano3 data prep sft --config tiny +# nemotron nano3 data prep sft --config tiny --run prep +# +# This config uses only 2 datasets with sampling for quick testing. + +# Path to tiny data blend JSON file (only 2 datasets) +blend_path: ${oc.env:PWD}/src/nemotron/recipes/nano3/stage1_sft/config/data_prep/data_blend_tiny.json + +# Output directory for packed .npy data (outputs to job directory for persistence) +output_dir: ${oc.env:PWD}/../output/stage1_sft_tiny + +# HuggingFace tokenizer model name +tokenizer_model: nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-Base-BF16 + +# Maximum tokens per packed sequence +pack_size: 4096 + +# Target size per shard - smaller for tiny config +shard_size: 64MB + +# Split ratios (must sum to 1.0) +train_ratio: 0.98 +valid_ratio: 0.01 +test_ratio: 0.01 + +# Chat template: 'nano3', path to .jinja file, or inline template +chat_template: nano3 + +# Field name for OpenAI-format messages in input records +messages_field: messages + +# Field name for tools definition in input records +tools_field: tools + +# Filter to only include records where used_in contains this value +used_in_filter: nano_v3 + +# Field name for used_in filtering +used_in_field: used_in + +# Truncate sequences longer than this (null = no limit) +max_doc_tokens: null + +# Limit rows per dataset for quick tests - small sample for tiny +sample: 1000 + +# Ray actors for parallel processing (null = auto) +num_actors: null + +# Force new run, ignoring cache +force: false diff --git a/src/nemotron/recipes/nano3/stage1_sft/config/default.yaml b/src/nemotron/recipes/nano3/stage1_sft/config/default.yaml new file mode 100644 index 0000000..95072db --- /dev/null +++ b/src/nemotron/recipes/nano3/stage1_sft/config/default.yaml @@ -0,0 +1,52 @@ +run: + data: SFTDataArtifact-sft:latest + model: pretrain:latest + env: + container: nvcr.io/nvidia/nemo:25.11.nemotron_3_nano + +recipe: + _target_: megatron.bridge.recipes.nemotronh.nemotron_3_nano.nemotron_3_nano_finetune_config + packed_sequence: true + peft: null # Disable LoRA, do full SFT + +# Dataset config for pre-packed .npy files from data_prep +# train.py builds FinetuningDatasetConfig directly (not HFDatasetConfig) to skip HF download +dataset: + dataset_root: ${art:data,path} + seq_length: ${art:data,pack_size} + packed_sequence_specs: + packed_sequence_size: ${art:data,pack_size} + packed_train_data_path: ${art:data,training_path} + packed_val_data_path: ${art:data,validation_path} + packed_metadata_path: ${art:data,metadata_path} + +train: + train_iters: 1700 + global_batch_size: 4 + +model: + seq_length: ${art:data,pack_size} + pipeline_model_parallel_size: 1 + tensor_model_parallel_size: 4 + context_parallel_size: 2 + hidden_size: 1344 + calculate_per_token_loss: True + +# tokenizer: +# tokenizer_type: HuggingFaceTokenizer +# tokenizer_model: meta-llama/Llama-3.2-1B + +scheduler: + lr_warmup_iters: 4 + +logger: + log_interval: 10 + wandb_project: ${run.wandb.project} # Set from env.toml [wandb] + wandb_entity: ${run.wandb.entity} # Set from env.toml [wandb] + +checkpoint: + save: /nemo_run/sft + save_interval: 20 + pretrained_checkpoint: ${art:model,path} + finetune: true # Skip loading optimizer state from pretrained checkpoint + # ckpt_step: ${art:model,iteration} # Optional: set to load specific iteration from artifact diff --git a/src/nemotron/recipes/nano3/stage1_sft/config/tiny.yaml b/src/nemotron/recipes/nano3/stage1_sft/config/tiny.yaml new file mode 100644 index 0000000..6b531c5 --- /dev/null +++ b/src/nemotron/recipes/nano3/stage1_sft/config/tiny.yaml @@ -0,0 +1,50 @@ +run: + data: SFTDataArtifact-sft:latest + model: pretrain:latest + env: + container: nvcr.io/nvidia/nemo:25.11.nemotron_3_nano + +recipe: + _target_: megatron.bridge.recipes.qwen.qwen3.qwen3_8b_finetune_config + packed_sequence: true + peft: null # Disable LoRA, do full SFT + +# Dataset config for pre-packed .npy files from data_prep +# train.py builds FinetuningDatasetConfig directly (not HFDatasetConfig) to skip HF download +dataset: + dataset_root: ${art:data,path} + seq_length: ${art:data,pack_size} + packed_sequence_specs: + packed_sequence_size: ${art:data,pack_size} + packed_train_data_path: ${art:data,training_path} + packed_val_data_path: ${art:data,validation_path} + packed_metadata_path: ${art:data,metadata_path} + +train: + train_iters: 1700 + global_batch_size: 32 + +model: + seq_length: ${art:data,pack_size} + # Match pretrain parallelism settings for checkpoint compatibility + tensor_model_parallel_size: 4 + pipeline_model_parallel_size: 1 + +# tokenizer: +# tokenizer_type: HuggingFaceTokenizer +# tokenizer_model: meta-llama/Llama-3.2-1B + +scheduler: + lr_warmup_iters: 32 + +logger: + log_interval: 10 + wandb_project: ${run.wandb.project} # Set from env.toml [wandb] + wandb_entity: ${run.wandb.entity} # Set from env.toml [wandb] + +checkpoint: + save: /nemo_run/sft + save_interval: 20 + pretrained_checkpoint: ${art:model,path} + finetune: true # Skip loading optimizer state from pretrained checkpoint + # ckpt_step: ${art:model,iteration} # Optional: set to load specific iteration from artifact diff --git a/src/nemotron/recipes/nano3/stage1_sft/data_prep.py b/src/nemotron/recipes/nano3/stage1_sft/data_prep.py new file mode 100644 index 0000000..a5b65d8 --- /dev/null +++ b/src/nemotron/recipes/nano3/stage1_sft/data_prep.py @@ -0,0 +1,552 @@ +#!/usr/bin/env python3 + +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Data preparation for Nano3 SFT stage. + +Applies chat templates to OpenAI-format messages, tokenizes with role-based +loss masking, and outputs packed .npy files compatible with GPTSFTPackedDataset. + +Output structure (Megatron-Bridge compatible): + output_dir/ + training_{pack_size}.npy # All training data concatenated + validation_{pack_size}.npy # All validation data concatenated + test_{pack_size}.npy # All test data concatenated + {pack_size}_metadata.jsonl # Megatron-Bridge compatible packing metadata + metadata.json # Nemotron metadata with split info + +Compatible with Megatron-Bridge's FinetuningDatasetConfig with PackedSequenceSpecs. + +Pipeline: +1. Apply nano3 chat template → role-labeled chunks +2. Tokenize chunks → input_ids +3. Build loss_mask (0=system/user, 1=assistant) +4. Pack sequences → sharded .npy files +5. Concatenate shards and split by ratio → single .npy per split + +Usage: + # With default config + python data_prep.py + + # With custom config file + python data_prep.py --config /path/to/config.yaml + + # With CLI overrides (Hydra-style) + python data_prep.py sample=100 force=true + + # Via nemotron CLI with nemo-run + nemotron nano3 data prep sft --run prep --sample 10000 +""" + +from __future__ import annotations + +import glob +import json +import logging +import os +import sys +from dataclasses import dataclass, field +from pathlib import Path + +import numpy as np + +from nemotron.data_prep import ( + ChatSftOutputConfig, + DataBlend, + OutputConfig, + PipelineConfig, + TokenizerConfig, + last_mile_process, +) +from nemotron.data_prep.config import DatasetConfig +from nemotron.data_prep.discovery import get_dataset_metadata +from nemotron.kit import SFTDataArtifact, print_step_complete +from nemotron.kit.trackers import InputDatasetInfo, tokenizer_to_uri +from nemotron.kit.train_script import ( + apply_hydra_overrides, + init_wandb_from_env, + load_omegaconf_yaml, + omegaconf_to_dataclass, + parse_config_and_overrides, +) +from nemotron.kit.wandb import add_wandb_tags, finish_wandb + +logger = logging.getLogger(__name__) + +STAGE_PATH = Path(__file__).parent + +# Default config path relative to this file +DEFAULT_CONFIG_PATH = STAGE_PATH / "config" / "data_prep.yaml" + +# Use NEMO_RUN_DIR for output when running via nemo-run (avoids writing to code dir) +_OUTPUT_BASE = Path(os.environ.get("NEMO_RUN_DIR", ".")) + +# Module-level flag for Ray execution (used by nemotron CLI) +RAY = True + + +@dataclass +class SFTDataPrepConfig: + """SFT data preparation config using chat template. + + Applies chat templates to OpenAI-format messages, tokenizes with role-based + loss masking, and outputs single packed .npy files per split (training.npy, + validation.npy, test.npy) compatible with Megatron-Bridge's FinetuningDatasetConfig. + """ + + blend_path: Path = field(default_factory=lambda: STAGE_PATH / "config/data_blend_raw.json") + """Path to data blend JSON file""" + + output_dir: Path = field(default_factory=lambda: _OUTPUT_BASE / "stage1_sft") + """Output directory for packed .npy data""" + + # Tokenizer + tokenizer_model: str = "nvidia/NVIDIA-Nemotron-Nano-9B-v2" + """HuggingFace tokenizer model name""" + + # Packing + pack_size: int = 4096 + """Maximum tokens per packed sequence""" + + shard_size: str = "256MB" + """Target size per shard (e.g., '256MB', '1GB')""" + + # Split ratios (must sum to 1.0) + train_ratio: float = 0.98 + """Fraction of data for training split""" + + valid_ratio: float = 0.01 + """Fraction of data for validation split""" + + test_ratio: float = 0.01 + """Fraction of data for test split""" + + # Chat template + chat_template: str = "nano3" + """Chat template: 'nano3', path to .jinja file, or inline template""" + + messages_field: str = "messages" + """Field name for OpenAI-format messages in input records""" + + tools_field: str = "tools" + """Field name for tools definition in input records""" + + used_in_filter: str | None = None + """Filter to only include records where used_in contains this value (e.g., 'nano_v3')""" + + used_in_field: str = "used_in" + """Field name for used_in filtering""" + + # Processing limits + max_doc_tokens: int | None = None + """Truncate sequences longer than this""" + + sample: int | None = None + """Limit rows per dataset (for quick tests)""" + + num_actors: int | None = None + """Ray actors for parallel processing (None = auto)""" + + force: bool = False + """Force new run, ignoring cache""" + + def __post_init__(self) -> None: + # Ensure paths are Path objects + if isinstance(self.blend_path, str): + self.blend_path = Path(self.blend_path) + if isinstance(self.output_dir, str): + self.output_dir = Path(self.output_dir) + + # Validate split ratios sum to 1.0 + total_ratio = self.train_ratio + self.valid_ratio + self.test_ratio + if abs(total_ratio - 1.0) > 1e-6: + raise ValueError( + f"Split ratios must sum to 1.0, got {total_ratio} " + f"(train={self.train_ratio}, valid={self.valid_ratio}, test={self.test_ratio})" + ) + + # Add sample suffix to output_dir if sampling + if self.sample is not None: + self.output_dir = self.output_dir / f"sample-{self.sample}" + + +def _concatenate_and_split_npy( + shards_dir: Path, + output_dir: Path, + train_ratio: float, + valid_ratio: float, + test_ratio: float, + pack_size: int, + seed: int = 42, + data_paths: list[str] | None = None, +) -> dict: + """Load all shards, concatenate, split by ratio, and save single files per split. + + Args: + shards_dir: Directory containing shard_*.npy files from pipeline. + output_dir: Directory to write training.npy, validation.npy, test.npy. + train_ratio: Fraction of data for training. + valid_ratio: Fraction of data for validation. + test_ratio: Fraction of data for test. + pack_size: Pack size (for metadata). + seed: Random seed for shuffling before split. + data_paths: Optional list of weight/path pairs from PipelineResult. + Format: ["weight", "path_prefix", ...] where path_prefix is the + shard path prefix (without the _XXXXXX.npy suffix). + + Returns: + Dict with split statistics: { + "train": {"sequences": N, "path": "..."}, + "valid": {"sequences": N, "path": "..."}, + "test": {"sequences": N, "path": "..."}, + "total_sequences": N, + } + """ + # Find all shard files + shard_files: list[str] = [] + + if data_paths: + # Extract shard prefixes from data_paths (format: ["weight", "path", ...]) + # and find all matching shard files + for i in range(1, len(data_paths), 2): + prefix = data_paths[i] + # Find all shard files matching this prefix + pattern = f"{prefix}_*.npy" + matching = sorted(glob.glob(pattern)) + shard_files.extend(matching) + + if not shard_files: + # Fallback: try recursive search under shards_dir + shard_pattern = str(shards_dir / "**" / "shard_*.npy") + shard_files = sorted(glob.glob(shard_pattern, recursive=True)) + + if not shard_files: + raise ValueError(f"No shard files found matching {shard_pattern}") + + logger.info(f"Loading {len(shard_files)} shard files from {shards_dir}") + + # Load and concatenate all shards + all_sequences = [] + for shard_file in shard_files: + shard_data = np.load(shard_file, allow_pickle=True) + all_sequences.extend(shard_data) + logger.debug(f"Loaded {len(shard_data)} sequences from {shard_file}") + + total_sequences = len(all_sequences) + logger.info(f"Total sequences loaded: {total_sequences}") + + # Shuffle before splitting (for reproducibility) + rng = np.random.default_rng(seed) + indices = np.arange(total_sequences) + rng.shuffle(indices) + + # Calculate split boundaries + train_end = int(total_sequences * train_ratio) + valid_end = train_end + int(total_sequences * valid_ratio) + + # Split indices + train_indices = indices[:train_end] + valid_indices = indices[train_end:valid_end] + test_indices = indices[valid_end:] + + # Extract sequences for each split + train_sequences = [all_sequences[i] for i in train_indices] + valid_sequences = [all_sequences[i] for i in valid_indices] + test_sequences = [all_sequences[i] for i in test_indices] + + # Ensure output directory exists and resolve to absolute path + # This is critical for W&B artifacts - paths must be absolute for remote access + output_dir = output_dir.resolve() + output_dir.mkdir(parents=True, exist_ok=True) + + # Save each split as a single .npy file with pack_size in filename + # Format: {split}_{pack_size}.npy (Megatron-Bridge compatible) + train_path = output_dir / f"training_{pack_size}.npy" + valid_path = output_dir / f"validation_{pack_size}.npy" + test_path = output_dir / f"test_{pack_size}.npy" + + np.save(train_path, train_sequences, allow_pickle=True) + logger.info(f"Saved {len(train_sequences)} training sequences to {train_path}") + + np.save(valid_path, valid_sequences, allow_pickle=True) + logger.info(f"Saved {len(valid_sequences)} validation sequences to {valid_path}") + + np.save(test_path, test_sequences, allow_pickle=True) + logger.info(f"Saved {len(test_sequences)} test sequences to {test_path}") + + # Compute packing statistics for Megatron-Bridge compatible metadata + def compute_packing_stats(sequences: list) -> dict: + """Compute packing statistics for a list of sequences.""" + if not sequences: + return { + "max_samples_per_bin": 0, + "dataset_max_seqlen": 0, + "packing_factor": 0.0, + "packing_efficiency": 0.0, + "pack_size": pack_size, + "min_packed_seqlen": 0, + } + # Count samples per bin and sequence lengths + samples_per_bin = [] + packed_seqlens = [] + max_seqlen = 0 + for seq in sequences: + num_samples = len(seq.get("seq_start_id", [1])) # Default to 1 if no boundaries + samples_per_bin.append(num_samples) + seq_len = len(seq.get("input_ids", [])) + packed_seqlens.append(seq_len) + # Track max sequence length across all sub-sequences + for i, start in enumerate(seq.get("seq_start_id", [0])): + if i + 1 < len(seq.get("seq_start_id", [])): + end = seq["seq_start_id"][i + 1] + else: + end = len(seq.get("input_ids", [])) + max_seqlen = max(max_seqlen, end - start) + + total_tokens = sum(packed_seqlens) + + packing_factor = round(sum(samples_per_bin) / len(sequences), 2) if sequences else 0.0 + packing_efficiency = ( + round(total_tokens / (len(sequences) * pack_size) * 100, 2) if sequences else 0.0 + ) + return { + "max_samples_per_bin": max(samples_per_bin) if samples_per_bin else 0, + "dataset_max_seqlen": max_seqlen, + "packing_factor": packing_factor, + "packing_efficiency": packing_efficiency, + "pack_size": pack_size, + "min_packed_seqlen": min(packed_seqlens) if packed_seqlens else 0, + } + + # Compute stats for each split + train_stats = compute_packing_stats(train_sequences) + valid_stats = compute_packing_stats(valid_sequences) + test_stats = compute_packing_stats(test_sequences) + + # Write Megatron-Bridge compatible metadata.jsonl + # Format: JSON list with one entry per dataset (train, valid, test) + mb_metadata_path = output_dir / f"{pack_size}_metadata.jsonl" + mb_metadata = [train_stats, valid_stats, test_stats] + with open(mb_metadata_path, "w") as f: + json.dump(mb_metadata, f, indent=2) + logger.info(f"Saved Megatron-Bridge compatible metadata to {mb_metadata_path}") + + # Write nemotron metadata.json (backward compatible) + metadata = { + "pack_size": pack_size, + "seed": seed, + "splits": { + "train": {"sequences": len(train_sequences), "path": str(train_path), **train_stats}, + "valid": {"sequences": len(valid_sequences), "path": str(valid_path), **valid_stats}, + "test": {"sequences": len(test_sequences), "path": str(test_path), **test_stats}, + }, + "total_sequences": total_sequences, + "train_ratio": train_ratio, + "valid_ratio": valid_ratio, + "test_ratio": test_ratio, + } + + metadata_path = output_dir / "metadata.json" + with open(metadata_path, "w") as f: + json.dump(metadata, f, indent=2) + logger.info(f"Saved metadata to {metadata_path}") + + return { + "train": {"sequences": len(train_sequences), "path": str(train_path)}, + "valid": {"sequences": len(valid_sequences), "path": str(valid_path)}, + "test": {"sequences": len(test_sequences), "path": str(test_path)}, + "total_sequences": total_sequences, + "training_path": str(train_path), + "validation_path": str(valid_path), + "test_path": str(test_path), + "metadata_path": str(mb_metadata_path), + } + + +def run_data_prep_main(cfg: SFTDataPrepConfig) -> SFTDataArtifact: + """Run SFT data preparation with chat template. + + Processes data through pipeline to generate shards, then concatenates + and splits into single .npy files per split (training.npy, validation.npy, test.npy). + + Args: + cfg: SFT data prep configuration. + + Returns: + SFTDataArtifact with paths to packed data. + """ + import shutil + import time + + start_time = time.time() + + # Add stage-specific tags to wandb run + add_wandb_tags(["data-prep", "sft"]) + + # Load data blend + blend = DataBlend.load(cfg.blend_path) + + # Auto-detect num_actors from CPU count + num_actors = cfg.num_actors + if num_actors is None: + cpu_count = os.cpu_count() or 4 + num_actors = max(2, min(32, cpu_count * 3 // 4)) + + # Use a temporary shards directory for pipeline output + shards_dir = cfg.output_dir / "_shards" + + # Build pipeline config with ChatSftOutputConfig (no per-split config) + format_config = ChatSftOutputConfig( + shard_size=cfg.shard_size, + pack_size=cfg.pack_size, + chat_template=cfg.chat_template, + messages_field=cfg.messages_field, + tools_field=cfg.tools_field, + used_in_filter=cfg.used_in_filter, + used_in_field=cfg.used_in_field, + ) + + pipeline_config = PipelineConfig( + output=OutputConfig( + dir=shards_dir, + format=format_config, + max_doc_tokens=cfg.max_doc_tokens, + max_rows=cfg.sample, + ), + tokenizer=TokenizerConfig(model=cfg.tokenizer_model), + num_actors=num_actors, + force=cfg.force, + # No per_split config - we handle splitting ourselves + ) + + # Run processing pipeline to generate shards + logger.info("Running pipeline to generate shards...") + result = last_mile_process(blend, pipeline_config) + + # Concatenate shards and split by ratio + # Extract data_paths from pipeline result to locate actual shard files + data_paths = result.splits["all"].data_paths if "all" in result.splits else None + logger.info("Concatenating shards and splitting by ratio...") + split_stats = _concatenate_and_split_npy( + shards_dir=shards_dir, + output_dir=cfg.output_dir, + train_ratio=cfg.train_ratio, + valid_ratio=cfg.valid_ratio, + test_ratio=cfg.test_ratio, + pack_size=cfg.pack_size, + data_paths=data_paths, + ) + + # Clean up intermediate shards directory + if shards_dir.exists(): + logger.info(f"Cleaning up intermediate shards directory: {shards_dir}") + shutil.rmtree(shards_dir) + + elapsed_sec = time.time() - start_time + + # Collect source datasets with metadata for lineage tracking + source_datasets: list[InputDatasetInfo] = [] + seen_keys: set[str] = set() + for split_datasets in blend.splits.values(): + for dataset in split_datasets: + # Use path+subset as key since same path can have different subsets + key = f"{dataset.path}|{dataset.subset or ''}" + if key not in seen_keys: + seen_keys.add(key) + ds_config = DatasetConfig( + name=dataset.name, + path=dataset.path, + split=dataset.split, + subset=dataset.subset, + text_field=dataset.text_field, + ) + hf_metadata = get_dataset_metadata(ds_config) + source_datasets.append( + InputDatasetInfo( + uri=dataset.path, + name=dataset.name, + weight=dataset.weight, + split=dataset.split, + subset=dataset.subset, + text_field=dataset.text_field, + num_rows=hf_metadata.num_rows, + size_bytes=hf_metadata.size_bytes, + ) + ) + + # Create tokenizer URI for lineage tracking + tok_uri = tokenizer_to_uri(cfg.tokenizer_model) + + # Build output artifact - path points to output_dir (contains training_{pack_size}.npy, etc.) + # Use resolved absolute path for W&B artifact storage + artifact = SFTDataArtifact( + path=cfg.output_dir.resolve(), + total_tokens=result.total_tokens, + total_sequences=split_stats["total_sequences"], + elapsed_sec=elapsed_sec, + pack_size=cfg.pack_size, + source_datasets=source_datasets, + tokenizer_uri=tok_uri, + training_path=split_stats["training_path"], + validation_path=split_stats["validation_path"], + test_path=split_stats["test_path"], + metadata_path=split_stats["metadata_path"], + ) + artifact.name = f"nano3/sft/data{'?sample=' + str(cfg.sample) if cfg.sample else ''}" + artifact.save() + + # Mark wandb run as successful + finish_wandb(exit_code=0) + + print_step_complete(data_prep=artifact) + return artifact + + +def main(cfg: SFTDataPrepConfig | None = None) -> SFTDataArtifact: + """Entry point for SFT data preparation. + + Args: + cfg: Config from CLI framework, or None when run directly as script. + + Returns: + SFTDataArtifact with paths to packed data. + """ + if cfg is None: + # Called directly as script - parse config ourselves + config_path, cli_overrides = parse_config_and_overrides(default_config=DEFAULT_CONFIG_PATH) + + # Load YAML config + try: + config = load_omegaconf_yaml(config_path) + except FileNotFoundError as e: + print(f"Error: {e}", file=sys.stderr) + sys.exit(1) + + # Apply CLI overrides (Hydra-style: key=value) + if cli_overrides: + config = apply_hydra_overrides(config, cli_overrides) + + # Convert to dataclass + cfg = omegaconf_to_dataclass(config, SFTDataPrepConfig) + + # Initialize wandb from environment variables (set by nemo-run) + init_wandb_from_env() + + # Run data prep + return run_data_prep_main(cfg) + + +if __name__ == "__main__": + main() diff --git a/src/nemotron/recipes/nano3/stage1_sft/train.py b/src/nemotron/recipes/nano3/stage1_sft/train.py new file mode 100644 index 0000000..9278a3a --- /dev/null +++ b/src/nemotron/recipes/nano3/stage1_sft/train.py @@ -0,0 +1,206 @@ +#!/usr/bin/env python3 + +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""SFT (Supervised Fine-Tuning) script for Nemotron Nano3. + +Uses Megatron-Bridge's ConfigContainer for full training configuration. +Dynamically loads the recipe function specified in the YAML config. + +Usage: + # With YAML config file (required) + python /path/to/train.py --config /path/to/sft.yaml + + # With CLI overrides (Hydra syntax) + python /path/to/train.py --config /path/to/sft.yaml train.train_iters=5000 + + # As module (requires nemotron package installed) + torchrun --nproc_per_node=8 -m nemotron.recipes.nano3.stage1_sft.train \ + --config /path/to/sft.yaml +""" + +from __future__ import annotations + +import logging +import sys +from pathlib import Path +from typing import Any + +import torch +from megatron.bridge.data.datasets.packed_sequence import PackedSequenceSpecs +from megatron.bridge.training.config import ConfigContainer, FinetuningDatasetConfig +from megatron.bridge.training.finetune import finetune +from megatron.bridge.training.gpt_step import forward_step +from megatron.bridge.training.utils.omegaconf_utils import ( + apply_overrides, + create_omegaconf_dict_config, + parse_hydra_overrides, +) +from omegaconf import DictConfig, OmegaConf + +from nemotron.kit.recipe_loader import extract_recipe_config, import_recipe_function +from nemotron.kit.resolvers import clear_artifact_cache, register_resolvers_from_config +from nemotron.kit.train_script import load_omegaconf_yaml, parse_config_and_overrides +from nemotron.kit.wandb import ( + patch_wandb_checkpoint_logging, + patch_wandb_http_handler_skip_digest_verification, + patch_wandb_init_for_lineage, + patch_wandb_local_file_handler_skip_digest_verification, + patch_wandb_runid_for_seeded_random, +) + +logger: logging.Logger = logging.getLogger(__name__) + + +# Default config path relative to this file +DEFAULT_CONFIG_PATH = Path(__file__).parent / "config" / "default.yaml" + +# Default recipe function +DEFAULT_RECIPE_TARGET = "megatron.bridge.recipes.nemotronh.nemotron_nano_9b_v2_finetune_config" + + +def _build_dataset_config(dataset_config: DictConfig, current_dataset: Any) -> FinetuningDatasetConfig: + """Build a FinetuningDatasetConfig from YAML config. + + This creates a proper FinetuningDatasetConfig (not HFDatasetConfig) to avoid + downloading HuggingFace datasets. The dataset config uses pre-packed .npy files. + + Args: + dataset_config: The dataset section from YAML config (resolved) + current_dataset: The current dataset config from the recipe (for defaults) + + Returns: + A FinetuningDatasetConfig instance + """ + # Build PackedSequenceSpecs if provided + packed_specs = None + if "packed_sequence_specs" in dataset_config: + specs_dict = dataset_config["packed_sequence_specs"] + # PackedSequenceSpecs.__post_init__ converts string paths to Path/MultiStoragePath + packed_specs = PackedSequenceSpecs( + packed_sequence_size=specs_dict.get("packed_sequence_size", -1), + packed_train_data_path=specs_dict.get("packed_train_data_path"), + packed_val_data_path=specs_dict.get("packed_val_data_path"), + packed_metadata_path=specs_dict.get("packed_metadata_path"), + ) + + # Build FinetuningDatasetConfig with values from YAML, falling back to current config + return FinetuningDatasetConfig( + dataset_root=dataset_config.get("dataset_root", getattr(current_dataset, "dataset_root", None)), + seq_length=dataset_config.get("seq_length", getattr(current_dataset, "seq_length", 4096)), + packed_sequence_specs=packed_specs, + dataloader_type=dataset_config.get("dataloader_type", getattr(current_dataset, "dataloader_type", "batch")), + ) + + +def main() -> None: + """Entry point for Nemotron Nano3 supervised fine-tuning.""" + try: + config_path, cli_overrides = parse_config_and_overrides(default_config=DEFAULT_CONFIG_PATH) + config = load_omegaconf_yaml(config_path) + except FileNotFoundError as e: + logger.error(str(e)) + sys.exit(1) + + # ------------------------------------------------------------------------- + # WANDB MONKEY-PATCHES + # These patches work around bugs in wandb and Megatron-Bridge. + # See nemotron/kit/wandb.py for detailed "Why" / "Remove when" documentation. + # ------------------------------------------------------------------------- + patch_wandb_http_handler_skip_digest_verification() + patch_wandb_local_file_handler_skip_digest_verification() + patch_wandb_runid_for_seeded_random() + patch_wandb_checkpoint_logging() + + # Clear artifact cache to ensure fresh downloads (important for :latest resolution) + clear_artifact_cache() + + # Resolve artifacts before wandb.init() (Megatron-Bridge initializes wandb). + qualified_names = register_resolvers_from_config( + config, + artifacts_key="run", + mode="pre_init", + pre_init_patch_http_digest=False, + ) + + # Patch wandb.init so lineage is registered immediately once MB initializes wandb. + patch_wandb_init_for_lineage( + artifact_qualified_names=qualified_names, + tags=["sft"], + ) + + recipe_target, recipe_kwargs = extract_recipe_config( + config, + default_target=DEFAULT_RECIPE_TARGET, + ) + try: + recipe_func = import_recipe_function(recipe_target) + except Exception as e: + logger.error(str(e)) + sys.exit(1) + + cfg: ConfigContainer = recipe_func(**recipe_kwargs) + + # Convert the initial Python dataclass to an OmegaConf DictConfig for merging + # Do this BEFORE building our custom dataset config (which contains MultiStoragePath) + merged_omega_conf, excluded_fields = create_omegaconf_dict_config(cfg) + + # Get config overrides (excluding recipe, run, and dataset) + config_overrides = OmegaConf.to_container(config, resolve=False) + config_overrides.pop("recipe", None) + config_overrides.pop("run", None) + config_overrides.pop("dataset", None) # We handle dataset separately below + + if config_overrides: + logger.debug(f"Merging config overrides: {list(config_overrides.keys())}") + yaml_overrides_omega = OmegaConf.create(config_overrides) + merged_omega_conf = OmegaConf.merge(merged_omega_conf, yaml_overrides_omega) + logger.debug("Config overrides merged successfully.") + + # Apply command-line overrides using Hydra-style parsing + if cli_overrides: + logger.debug(f"Applying Hydra-style command-line overrides: {cli_overrides}") + merged_omega_conf = parse_hydra_overrides(merged_omega_conf, cli_overrides) + logger.debug("Hydra-style command-line overrides applied successfully.") + + final_overrides_as_dict = OmegaConf.to_container(merged_omega_conf, resolve=True) + + # Don't let apply_overrides touch the dataset - we handle it separately + final_overrides_as_dict.pop("dataset", None) + apply_overrides(cfg, final_overrides_as_dict, excluded_fields) + + # Handle dataset config AFTER apply_overrides - build FinetuningDatasetConfig directly + # This avoids HFDatasetConfig which tries to download from HuggingFace + # PackedSequenceSpecs.__post_init__ converts paths to Path/MultiStoragePath automatically + if "dataset" in config: + dataset_config = OmegaConf.to_container(config.dataset, resolve=True) + dataset_config.pop("_target_", None) + cfg.dataset = _build_dataset_config(dataset_config, cfg.dataset) + logger.info(f"Built dataset config: {type(cfg.dataset).__name__}") + + # Debug: print key config values + print(f"DEBUG: checkpoint.pretrained_checkpoint = {cfg.checkpoint.pretrained_checkpoint}") + print(f"DEBUG: dataset type = {type(cfg.dataset).__name__}") + if hasattr(cfg.dataset, "packed_sequence_specs") and cfg.dataset.packed_sequence_specs: + print(f"DEBUG: packed_sequence_specs.packed_train_data_path = {cfg.dataset.packed_sequence_specs.packed_train_data_path}") + + finetune(config=cfg, forward_step_func=forward_step) + + if torch.distributed.is_initialized(): + torch.distributed.destroy_process_group() + + +if __name__ == "__main__": + main() diff --git a/src/nemotron/recipes/nano3/stage2_rl/README.md b/src/nemotron/recipes/nano3/stage2_rl/README.md new file mode 100644 index 0000000..1d87f38 --- /dev/null +++ b/src/nemotron/recipes/nano3/stage2_rl/README.md @@ -0,0 +1,257 @@ +# Stage 2: Reinforcement Learning (RL) + +Align the instruction-tuned model using GRPO (Group Relative Policy Optimization) with NeMo-RL. + +## Overview + +This stage takes the SFT model and further aligns it using reinforcement learning. The GRPO algorithm optimizes the policy based on reward signals from NeMo-Gym environments, producing a final aligned model. + +> **Open-Source Data Only**: This recipe trains exclusively on the open-sourced subset of RL data. Results will differ from the tech report benchmarks, which used additional proprietary data. Use this recipe as a reference implementation to apply the methodology with your own data. + +| Component | Description | +|-----------|-------------| +| `data_prep.py` | Converts datasets to JSONL format for NeMo-RL | +| `train.py` | Runs GRPO training using NeMo-RL with Ray | +| `config/` | Configuration files for data prep and training | + +## Quick Start + +### Using nemotron CLI (Recommended) + +```bash +# 1. Prepare data (convert to JSONL format) +uv run nemotron nano3 data prep rl --run YOUR-CLUSTER + +# 2. Run RL training +uv run nemotron nano3 rl --run YOUR-CLUSTER + +# Quick test with tiny config +uv run nemotron nano3 rl -c tiny --run YOUR-CLUSTER +``` + +### Direct Script Execution + +Inside a container on a compute node (requires NeMo-RL and Ray): + +```bash +# Data preparation +python data_prep.py --config config/data_prep.yaml + +# Training (Ray will be initialized internally) +python train.py --config config/grpo_nanov3.yaml +``` + +## Data Preparation + +The `data_prep.py` script converts datasets to JSONL format compatible with NeMo-RL's NeMo-Gym interface. + +### CLI Command + +```bash +uv run nemotron nano3 data prep rl [options] +``` + +| Option | Description | +|--------|-------------| +| `--run ` | Execute on Slurm via NeMo-Run | +| `--sample N` | Limit rows per dataset (for testing) | +| `--force` | Force re-run, ignoring cache | + +### Input + +RL datasets defined in `config/data_blend_raw.json`. The data is transformed using the `nemotron_rl` transform which extracts from `responses_create_params.input`. + +### Output + +``` +output/nano3/stage2_rl/ +├── train/ +│ └── data.jsonl # Training data in NeMo-Gym format +├── val/ +│ └── data.jsonl # Validation data +├── test/ +│ └── data.jsonl # Test data +└── manifest.json # Split paths and ratios +``` + +The output is registered as a W&B Artifact (`DataBlendsArtifact-rl`) for lineage tracking. + +### Configuration + +`config/data_prep.yaml`: + +```yaml +blend_path: config/data_blend_raw.json +output_dir: output/nano3/stage2_rl +shard_size: 256MB +split_output: train_val_test +train_ratio: 0.98 +val_ratio: 0.01 +``` + +| Parameter | Description | +|-----------|-------------| +| `split_output` | `train_val_test` for separate splits, `none` for single output | +| `train_ratio` | Fraction for training split (default 0.98) | +| `val_ratio` | Fraction for validation split (default 0.01) | + +## Training + +The `train.py` script runs GRPO training using NeMo-RL with Ray for distributed execution. + +### CLI Command + +```bash +uv run nemotron nano3 rl [options] [overrides...] +``` + +| Option | Description | +|--------|-------------| +| `--run ` | Attached execution on Slurm | +| `--batch ` | Detached execution (submit and exit) | +| `-c ` | Config file (e.g., `-c tiny` for testing) | +| `--dry-run` | Preview execution plan | +| `key=value` | Override config values (Hydra-style) | + +### Input + +- **Model**: SFT checkpoint from Stage 1 (`ModelArtifact-sft`) +- **Data**: `DataBlendsArtifact-rl` (from data prep) +- **Config**: `config/grpo_nanov3.yaml` or `config/tiny.yaml` + +### Output + +- Aligned model checkpoints +- Training logs and metrics +- Registered as W&B Artifact (`ModelArtifact-rl`) + +### Configuration Files + +| File | Purpose | +|------|---------| +| `config/grpo_nanov3.yaml` | Production GRPO configuration | +| `config/tiny.yaml` | Testing variant | +| `config/data_blend_raw.json` | RL dataset blend (6 datasets) | + +### Key Configuration Sections + +```yaml +policy: + model_name: "path/to/sft/checkpoint" + tokenizer: "nvidia/NVIDIA-Nemotron-Nano-9B-v2" + generation: + temperature: 0.7 + max_new_tokens: 1024 + +grpo: + num_iterations: 100 + batch_size: 32 + learning_rate: 1e-6 + +data: + train_jsonl_fpath: "/path/to/train/data.jsonl" + validation_jsonl_fpath: "/path/to/val/data.jsonl" + +env: + nemo_gym: + # NeMo-Gym environment configuration +``` + +### Override Examples + +```bash +# More iterations +uv run nemotron nano3 rl -c tiny grpo.num_iterations=200 + +# Different temperature +uv run nemotron nano3 rl -c tiny policy.generation.temperature=0.8 + +# Different learning rate +uv run nemotron nano3 rl -c tiny grpo.learning_rate=5e-7 +``` + +## Running with NeMo-Run + +The nemotron CLI uses [NeMo-Run](https://github.com/NVIDIA-NeMo/Run) for job orchestration. RL training uses Ray internally for distributed execution. + +### env.toml Setup + +Configure execution profiles in `env.toml`: + +```toml +[wandb] +project = "nemotron" +entity = "YOUR-TEAM" + +[YOUR-CLUSTER] +executor = "slurm" +account = "YOUR-ACCOUNT" +partition = "batch" +nodes = 2 +ntasks_per_node = 8 +gpus_per_node = 8 +mem = "0" +exclusive = true +mounts = ["/lustre:/lustre"] +``` + +> **Note**: Container images are specified in the recipe config files (e.g., `config/tiny.yaml`), not in env.toml. + +### Execution Modes + +```bash +# Attached (wait for completion) +uv run nemotron nano3 rl -c tiny --run YOUR-CLUSTER + +# Detached (submit and exit) +uv run nemotron nano3 rl -c tiny --batch YOUR-CLUSTER + +# Preview without executing +uv run nemotron nano3 rl -c tiny --run YOUR-CLUSTER --dry-run +``` + +See [docs/train/nemo-run.md](../../../../docs/train/nemo-run.md) for complete configuration options. + +## GRPO Algorithm + +GRPO (Group Relative Policy Optimization) is a reinforcement learning algorithm that: + +1. **Generates responses** from the current policy +2. **Evaluates** responses using NeMo-Gym reward environments +3. **Computes group-relative advantages** across response groups +4. **Updates the policy** to favor higher-reward responses + +Key features: +- Efficient batched generation and evaluation +- Ray-based distributed training +- Integration with NeMo-Gym for flexible reward computation + +## Artifact Lineage + +```mermaid +flowchart TB + prev["ModelArtifact-sft
(from Stage 1)"] --> train + rl["RL Datasets
(preference/reward data)"] --> dp["data_prep.py"] + dp --> data["DataBlendsArtifact-rl
(JSONL files)"] + data --> train["train.py
(GRPO with NeMo-RL)"] + train --> model["ModelArtifact-rl
(final aligned model)"] + + style prev fill:#f3e5f5 + style rl fill:#e8f5e9 + style dp fill:#e8f5e9 + style data fill:#e8f5e9 + style train fill:#e8f5e9 + style model fill:#e8f5e9 +``` + +## Requirements + +- **NeMo-RL**: Required for GRPO training +- **Ray**: Automatically initialized for distributed execution +- **NeMo-Gym**: Provides reward environments +- **GPU nodes**: Recommended 8 GPUs per node + +## Previous Stages + +- [Stage 0: Pretraining](../stage0_pretrain/README.md) - Pretrain the base model +- [Stage 1: SFT](../stage1_sft/README.md) - Instruction tuning diff --git a/src/nemotron/recipes/nano3/stage2_rl/__init__.py b/src/nemotron/recipes/nano3/stage2_rl/__init__.py new file mode 100644 index 0000000..b7e1d0c --- /dev/null +++ b/src/nemotron/recipes/nano3/stage2_rl/__init__.py @@ -0,0 +1,15 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Nemotron Nano 3 stage 2 (reinforcement learning) recipe package.""" diff --git a/src/nemotron/recipes/nano3/stage2_rl/config/data_prep/data_blend_raw.json b/src/nemotron/recipes/nano3/stage2_rl/config/data_prep/data_blend_raw.json new file mode 100644 index 0000000..5dc19b1 --- /dev/null +++ b/src/nemotron/recipes/nano3/stage2_rl/config/data_prep/data_blend_raw.json @@ -0,0 +1,10 @@ +{ + "datasets": [ + { + "name": "nemotron-3-nano-rl-training-blend", + "path": "hf://nvidia/Nemotron-3-Nano-RL-Training-Blend", + "split": "train", + "weight": 1.0 + } + ] +} diff --git a/src/nemotron/recipes/nano3/stage2_rl/config/data_prep/default.yaml b/src/nemotron/recipes/nano3/stage2_rl/config/data_prep/default.yaml new file mode 100644 index 0000000..d695f66 --- /dev/null +++ b/src/nemotron/recipes/nano3/stage2_rl/config/data_prep/default.yaml @@ -0,0 +1,41 @@ +run: + env: + container: anyscale/ray:2.49.2-py311 + +# Config for RL data preparation with HuggingFace placeholder resolution +# +# Processes nvidia/Nemotron-3-Nano-RL-Training-Blend and resolves +# placeholder entries by fetching from external datasets (DAPO, Skywork). +# +# Placeholder records have an `_hf_placeholder` field containing row indices and +# question templates. The data_prep.py script resolves these by: +# 1. Detecting placeholder records by the presence of `_hf_placeholder` field +# 2. Fetching the actual data from the external HF dataset +# 3. Applying template restoration (DAPO prefix/suffix, Skywork {question} replacement) +# +# For simple copy/passthrough (no placeholder resolution), use data_prep_copy.py instead. +# +# Usage: +# python data_prep.py +# python data_prep.py sample=100 force=true +# +# Environment variables: +# PWD: Current working directory (for path resolution) + +# Path to data blend JSON file +blend_path: ${oc.env:PWD}/src/nemotron/recipes/nano3/stage2_rl/config/data_prep/data_blend_raw.json + +# Output directory for resolved JSONL data (outputs to job directory for persistence) +output_dir: ${oc.env:PWD}/../output/stage2_rl_resolved + +# Target size per shard (e.g., '256MB', '1GB') +shard_size: 256MB + +# Limit rows per dataset for quick tests (null = no limit) +sample: null + +# Ray actors for parallel processing (null = auto) +num_actors: null + +# Force new run, ignoring cache +force: false diff --git a/src/nemotron/recipes/nano3/stage2_rl/config/data_prep/merge.yaml b/src/nemotron/recipes/nano3/stage2_rl/config/data_prep/merge.yaml new file mode 100644 index 0000000..e8fec9d --- /dev/null +++ b/src/nemotron/recipes/nano3/stage2_rl/config/data_prep/merge.yaml @@ -0,0 +1,46 @@ +run: + env: + container: anyscale/ray:2.49.2-py311 + +# Config for RL data preparation (merge mode) +# +# Merges datasets from a raw data blend into a single JSONL output, then splits +# into train/val/test based on configurable ratios. +# +# This is useful when you have multiple source datasets that need to be combined +# and then split into training splits, rather than using pre-existing HF splits. +# +# For placeholder resolution (DAPO, Skywork datasets), use data_prep.py instead. +# +# Usage: +# python data_prep_merge.py +# python data_prep_merge.py sample=100 force=true train_ratio=0.9 +# +# Environment variables: +# PWD: Current working directory (for path resolution) + +# Path to data blend JSON file +blend_path: ${oc.env:PWD}/src/nemotron/recipes/nano3/stage2_rl/config/data_prep/data_blend_raw.json + +# Output directory for JSONL data (outputs to job directory for persistence) +output_dir: ${oc.env:PWD}/../output/stage2_rl_merged + +# Target size per shard (e.g., '256MB', '1GB') +shard_size: 256MB + +# Split ratios (must sum to 1.0) +train_ratio: 0.98 +valid_ratio: 0.01 +test_ratio: 0.01 + +# Random seed for shuffling before split +seed: 42 + +# Limit rows per dataset for quick tests (null = no limit) +sample: null + +# Ray actors for parallel processing (null = auto) +num_actors: null + +# Force new run, ignoring cache +force: false diff --git a/src/nemotron/recipes/nano3/stage2_rl/config/data_prep/tiny.yaml b/src/nemotron/recipes/nano3/stage2_rl/config/data_prep/tiny.yaml new file mode 100644 index 0000000..5ec3f8b --- /dev/null +++ b/src/nemotron/recipes/nano3/stage2_rl/config/data_prep/tiny.yaml @@ -0,0 +1,38 @@ +run: + env: + container: anyscale/ray:2.49.2-py311 + +# Tiny config for RL data preparation (fast iteration/testing) +# +# Usage: +# nemotron nano3 data prep rl --config tiny +# nemotron nano3 data prep rl --config tiny --run prep +# +# This config uses sampling for quick testing. + +# Path to data blend JSON file +blend_path: ${oc.env:PWD}/src/nemotron/recipes/nano3/stage2_rl/config/data_prep/data_blend_raw.json + +# Output directory for JSONL data (outputs to job directory for persistence) +output_dir: ${oc.env:PWD}/../output/stage2_rl_tiny + +# Target size per shard - smaller for tiny config +shard_size: 64MB + +# Limit rows per dataset for quick tests - small sample for tiny +sample: 1000 + +# Ray actors for parallel processing (null = auto) +num_actors: null + +# Force new run, ignoring cache +force: false + +# Split output into train/val/test directories: 'none' or 'train_val_test' +split_output: train_val_test + +# Ratio of data for training when split_output='train_val_test' +train_ratio: 0.98 + +# Ratio of data for validation when split_output='train_val_test' +val_ratio: 0.01 diff --git a/src/nemotron/recipes/nano3/stage2_rl/config/default.yaml b/src/nemotron/recipes/nano3/stage2_rl/config/default.yaml new file mode 100644 index 0000000..05f990d --- /dev/null +++ b/src/nemotron/recipes/nano3/stage2_rl/config/default.yaml @@ -0,0 +1,303 @@ +run: + data: DataBlendsArtifact-rl:latest + model: sft:latest + env: + container: nvcr.io/nvidia/nemo-rl:v0.4.0.nemotron_3_nano + +# GRPO Algorithm Configuration for training Nano v3 +grpo: + num_prompts_per_step: 128 + num_generations_per_prompt: 16 + num_val_generations_per_prompt: 4 + max_rollout_turns: 1 # for multi-turn rollouts. Math Environments just have 1 turn (answering the question) + max_num_epochs: 1 + max_num_steps: 1000000 + normalize_rewards: true + use_leave_one_out_baseline: true + val_period: 5 + val_at_start: False + overlong_filtering: false + max_val_samples: null + val_batch_size: 256 + seed: 42 + async_grpo: + enabled: false # Set to true to enable async training mode + # Max age (in training steps) for trajectories used in training + max_trajectory_age_steps: 1 + + # Best@k training configuration (optional - set use_best_at_k to true to enable) + use_best_at_k: False # Enable Best@k training to optimize for best reward among k samples + best_at_k_k: 8 # Number of samples per bootstrap group (should be <= num_generations_per_prompt) + best_at_k_m: 1000 # Number of bootstrap groups (will use C(n,k) if smaller) + # Note: With num_generations_per_prompt=16 and k=8, C(16,8)=12870 + # So m=1000 will use bootstrap sampling (not all combinations) + + # Combined training: blend of Best@k and Pass@1 + use_combined_training: false # Enable combined training + combined_training_weight_mode: "auto" # "auto" for adaptive, "fixed" for custom weights + combined_training_best_at_k_weight: 0.2 # Used when mode is "fixed" + combined_training_pass_at_1_weight: 1.0 # Used when mode is "fixed" + # "auto": adaptive weights (N_pos/N) per prompt + # "fixed": use custom weights specified above + + # Dynamic sampling: oversample prompts, keep only those with non-zero advantages + dynamic_sampling_oversample_ratio: 1.0 # 1.0 = disabled, 2.0 = load 2x and filter, etc. + + batch_multiplier: 1 + use_dynamic_sampling: False + reward_shaping: + enabled: False + reward_scaling: + enabled: False + +loss_fn: + reference_policy_kl_penalty: 0 + reference_policy_kl_type: k3 + kl_input_clamp_value: null + kl_output_clamp_value: null + ratio_clip_min: 0.2 + ratio_clip_max: 0.28 + ratio_clip_c: null + # (default off) loss formulation improvements (docs/guides/grpo.md#loss) + use_on_policy_kl_approximation: True + use_importance_sampling_correction: True + sequence_level_importance_ratios: False + token_level_loss: True + truncated_importance_sampling_ratio: null + +checkpointing: + enabled: true + checkpoint_dir: "results/grpo" + metric_name: "val:total_reward/mean" + higher_is_better: true + keep_top_k: 1000000 + save_period: 10 + checkpoint_must_save_by: "00:03:40:00" + +policy: + model_name: "/path/to/hf_checkpoint" + tokenizer: + name: nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-Base-BF16 + train_global_batch_size: 2048 + train_micro_batch_size: 1 + generation_batch_size: 64 # Only used when generating using HF backend + logprob_batch_size: 1 + max_total_sequence_length: 49152 + precision: "bfloat16" + logprob_chunk_size: 2048 + + dtensor_cfg: + _v2: true + enabled: false + cpu_offload: False + sequence_parallel: false + activation_checkpointing: false + tensor_parallel_size: 1 + context_parallel_size: 1 + custom_parallel_plan: null + + megatron_cfg: + enabled: true + empty_unused_memory_level: 1 + activation_checkpointing: true + bias_activation_fusion: False + # converter_type: "Qwen2ForCausalLM" + tensor_model_parallel_size: 2 + expert_tensor_parallel_size: 1 + expert_model_parallel_size: 8 + pipeline_model_parallel_size: 2 + num_layers_in_first_pipeline_stage: null + num_layers_in_last_pipeline_stage: null + context_parallel_size: 4 + pipeline_dtype: ${policy.precision} + sequence_parallel: true + freeze_moe_router: true + # moe_router_dtype: "fp64" + moe_router_dtype: "fp32" + moe_router_load_balancing_type: "none" # "seq_aux_loss" causes logprob error divergence for grpo + moe_router_bias_update_rate: 1e-3 + moe_permute_fusion: true + moe_enable_deepep: false + moe_token_dispatcher_type: "alltoall" + moe_aux_loss_coeff: 0.0 + moe_router_enable_expert_bias: true + #gives ~20% training perf speedup with sequence packing + apply_rope_fusion: True + defer_fp32_logits: True + track_moe_metrics: True + moe_per_layer_logging: True + do_not_average_loss: true + cp_normalize: true + calculate_per_token_loss: true + scale_loss_by_dp_cp_size: false + + optimizer: + optimizer: "adam" + lr: 3e-6 + min_lr: 3e-6 + weight_decay: 0.0 + bf16: true + fp16: false + params_dtype: "float32" + + #adam + adam_beta1: 0.9 + adam_beta2: 0.999 + adam_eps: 1e-8 + + #sgd + sgd_momentum: 0.9 + + clip_grad: ${policy.max_grad_norm} + + #distributed optimizer + use_distributed_optimizer: true + use_precision_aware_optimizer: true + + optimizer_cpu_offload: False + optimizer_offload_fraction: 0 + + scheduler: + start_weight_decay: ${policy.megatron_cfg.optimizer.weight_decay} + end_weight_decay: ${policy.megatron_cfg.optimizer.weight_decay} + weight_decay_incr_style: "constant" + lr_decay_style: "constant" + lr_decay_iters: null + lr_warmup_iters: 10 + lr_warmup_init: 0.3e-7 + + distributed_data_parallel_config: + grad_reduce_in_fp32: false + overlap_grad_reduce: true + overlap_param_gather: true + average_in_collective: false + use_custom_fsdp: false + data_parallel_sharding_strategy: "optim_grads_params" + + env_vars: null + + # See docs/design-docs/sequence-packing-and-dynamic-batching.md + # for more details on dynamic batching and sequence packing. + dynamic_batching: + enabled: False + train_mb_tokens: ${mul:${policy.max_total_sequence_length}, ${policy.train_micro_batch_size}} + logprob_mb_tokens: ${mul:${policy.max_total_sequence_length}, ${policy.logprob_batch_size}} + sequence_length_round: 64 + + sequence_packing: + enabled: True + train_mb_tokens: ${mul:${policy.max_total_sequence_length}, ${policy.train_micro_batch_size}} + logprob_mb_tokens: ${mul:${policy.max_total_sequence_length}, ${policy.logprob_batch_size}} + algorithm: "modified_first_fit_decreasing" + sequence_length_round: 64 + + # makes the training sequence length divisible by the tensor parallel size + # this is useful for sequence parallel training + make_sequence_length_divisible_by: ${policy.megatron_cfg.tensor_model_parallel_size} + max_grad_norm: 1.0 + + optimizer: null # remove default FSDP optimizer + scheduler: null + + offload_optimizer_for_logprob: False + + generation: + backend: "vllm" + max_new_tokens: ${policy.max_total_sequence_length} + temperature: 1.0 + top_p: 1.0 + top_k: null + stop_token_ids: null + stop_strings: null + vllm_cfg: + # NB: can re-enable prefix cache on vllm >= 0.11.2. + # enable_prefix_caching: false + async_engine: false + kv_cache_dtype: auto + precision: ${policy.precision} + tensor_parallel_size: 4 + pipeline_parallel_size: 1 + expert_parallel_size: 1 # When EP > 1, EP must be a multiple of TP since vLLM's EP = DP * TP + gpu_memory_utilization: 0.5 + max_model_len: ${policy.max_total_sequence_length} + # when enforce_eager is False, it is optional to set ++policy.generation.vllm_kwargs.compilation_config.use_inductor=False for better accuracy, + # with the flag, vllm will use the custom CUDA kernels instead of the Triton kernels generated by torch.compile + # for more details, see convergence issue https://github.com/NVIDIA-NeMo/RL/issues/998 + enforce_eager: False + use_deep_gemm: False + num_last_layers_in_bf16: 0 + num_first_layers_in_bf16: 0 + expose_http_server: true + http_server_serving_chat_kwargs: + enable_auto_tools: true + tool_parser: qwen3_coder + reasoning_parser: deepseek_r1 + + vllm_kwargs: + mamba_ssm_cache_dtype: "float32" + compilation_config: + # when enforce_eager is False, set ++policy.generation.vllm_kwargs.compilation_config.use_inductor=False for better accuracy, + # with the flag, vllm will use the custom CUDA kernels instead of the Triton kernels generated by torch.compile + # for more details, see convergence issue https://github.com/NVIDIA-NeMo/RL/issues/998 + use_inductor: False + colocated: + # true: generation shares training GPUs + # false: uses dedicated generation resources + enabled: true + # only relevant when enabled is false + resources: + gpus_per_node: null # Decides num gpus to be dedicated to generation when there is one node in the cluster i.e cluster.num_nodes == 1 + num_nodes: null # Decides number of nodes to be dedicated to generation + +data: + train_jsonl_fpath: "/path/to/train.jsonl" + validation_jsonl_fpath: "/path/to/validation.jsonl" + shuffle: False + num_workers: 1 + +env: + should_use_nemo_gym: true + nemo_gym: + config_paths: + - responses_api_models/vllm_model/configs/vllm_model_for_training.yaml # Required! And it must be *for_training + - resources_servers/math_with_judge/configs/math_with_judge.yaml + - resources_servers/code_gen/configs/code_gen.yaml + - resources_servers/workplace_assistant/configs/workplace_assistant.yaml + - resources_servers/mcqa/configs/mcqa.yaml + - resources_servers/instruction_following/configs/instruction_following.yaml + - resources_servers/structured_outputs/configs/structured_outputs_json.yaml + math_with_judge: + resources_servers: + math_with_judge: + judge_model_server: + name: policy_model + should_use_judge: false + code_gen: + resources_servers: + code_gen: + num_processes: 1024 + unit_test_timeout_secs: 10 + debug: false + +logger: + log_dir: "logs" # Base directory for all logs + num_val_samples_to_print: 0 # Number of validation samples to pretty print on terminal + wandb_enabled: false + tensorboard_enabled: false + mlflow_enabled: false # Disable MLflow logging + monitor_gpus: true # If true, will monitor GPU usage and log to wandb and/or tensorboard + swanlab_enabled: false # Disable SwanLab logging + wandb: + project: "grpo-dev" + name: "grpo-dev-logger" + tensorboard: {} + mlflow: + experiment_name: "grpo-dev" + run_name: "grpo-dev-logger" + gpu_monitoring: + collection_interval: 10 # How often to collect GPU usage metrics (in seconds) + flush_interval: 10 # How often to flush GPU usage metrics to the loggers (in seconds) + +cluster: + gpus_per_node: 8 + num_nodes: 32 diff --git a/src/nemotron/recipes/nano3/stage2_rl/config/tiny.yaml b/src/nemotron/recipes/nano3/stage2_rl/config/tiny.yaml new file mode 100644 index 0000000..54b4936 --- /dev/null +++ b/src/nemotron/recipes/nano3/stage2_rl/config/tiny.yaml @@ -0,0 +1,303 @@ +run: + data: SplitJsonlDataArtifact-rl:latest + model: sft:latest + env: + container: nvcr.io/nvidia/nemo-rl:v0.4.0.nemotron_3_nano + +# GRPO Algorithm Configuration for training Nano v3 +grpo: + num_prompts_per_step: 128 + num_generations_per_prompt: 16 + num_val_generations_per_prompt: 4 + max_rollout_turns: 1 # for multi-turn rollouts. Math Environments just have 1 turn (answering the question) + max_num_epochs: 1 + max_num_steps: 1000000 + normalize_rewards: true + use_leave_one_out_baseline: true + val_period: 5 + val_at_start: False + overlong_filtering: false + max_val_samples: null + val_batch_size: 256 + seed: 42 + async_grpo: + enabled: false # Set to true to enable async training mode + # Max age (in training steps) for trajectories used in training + max_trajectory_age_steps: 1 + + # Best@k training configuration (optional - set use_best_at_k to true to enable) + use_best_at_k: False # Enable Best@k training to optimize for best reward among k samples + best_at_k_k: 8 # Number of samples per bootstrap group (should be <= num_generations_per_prompt) + best_at_k_m: 1000 # Number of bootstrap groups (will use C(n,k) if smaller) + # Note: With num_generations_per_prompt=16 and k=8, C(16,8)=12870 + # So m=1000 will use bootstrap sampling (not all combinations) + + # Combined training: blend of Best@k and Pass@1 + use_combined_training: false # Enable combined training + combined_training_weight_mode: "auto" # "auto" for adaptive, "fixed" for custom weights + combined_training_best_at_k_weight: 0.2 # Used when mode is "fixed" + combined_training_pass_at_1_weight: 1.0 # Used when mode is "fixed" + # "auto": adaptive weights (N_pos/N) per prompt + # "fixed": use custom weights specified above + + # Dynamic sampling: oversample prompts, keep only those with non-zero advantages + dynamic_sampling_oversample_ratio: 1.0 # 1.0 = disabled, 2.0 = load 2x and filter, etc. + + batch_multiplier: 1 + use_dynamic_sampling: False + reward_shaping: + enabled: False + reward_scaling: + enabled: False + +loss_fn: + reference_policy_kl_penalty: 0 + reference_policy_kl_type: k3 + kl_input_clamp_value: null + kl_output_clamp_value: null + ratio_clip_min: 0.2 + ratio_clip_max: 0.28 + ratio_clip_c: null + # (default off) loss formulation improvements (docs/guides/grpo.md#loss) + use_on_policy_kl_approximation: True + use_importance_sampling_correction: True + sequence_level_importance_ratios: False + token_level_loss: True + truncated_importance_sampling_ratio: null + +checkpointing: + enabled: true + checkpoint_dir: "results/grpo" + metric_name: "val:total_reward/mean" + higher_is_better: true + keep_top_k: 1000000 + save_period: 10 + checkpoint_must_save_by: "00:03:40:00" + +policy: + model_name: ${art:model,path} + tokenizer: + name: nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-Base-BF16 + train_global_batch_size: 2048 + train_micro_batch_size: 1 + generation_batch_size: 64 # Only used when generating using HF backend + logprob_batch_size: 1 + max_total_sequence_length: 49152 + precision: "bfloat16" + logprob_chunk_size: 2048 + + dtensor_cfg: + _v2: true + enabled: false + cpu_offload: False + sequence_parallel: false + activation_checkpointing: false + tensor_parallel_size: 1 + context_parallel_size: 1 + custom_parallel_plan: null + + megatron_cfg: + enabled: true + empty_unused_memory_level: 1 + activation_checkpointing: true + bias_activation_fusion: False + # converter_type: "Qwen2ForCausalLM" + tensor_model_parallel_size: 2 + expert_tensor_parallel_size: 1 + expert_model_parallel_size: 8 + pipeline_model_parallel_size: 2 + num_layers_in_first_pipeline_stage: null + num_layers_in_last_pipeline_stage: null + context_parallel_size: 4 + pipeline_dtype: ${policy.precision} + sequence_parallel: true + freeze_moe_router: true + # moe_router_dtype: "fp64" + moe_router_dtype: "fp32" + moe_router_load_balancing_type: "none" # "seq_aux_loss" causes logprob error divergence for grpo + moe_router_bias_update_rate: 1e-3 + moe_permute_fusion: true + moe_enable_deepep: false + moe_token_dispatcher_type: "alltoall" + moe_aux_loss_coeff: 0.0 + moe_router_enable_expert_bias: true + #gives ~20% training perf speedup with sequence packing + apply_rope_fusion: True + defer_fp32_logits: True + track_moe_metrics: True + moe_per_layer_logging: True + do_not_average_loss: true + cp_normalize: true + calculate_per_token_loss: true + scale_loss_by_dp_cp_size: false + + optimizer: + optimizer: "adam" + lr: 3e-6 + min_lr: 3e-6 + weight_decay: 0.0 + bf16: true + fp16: false + params_dtype: "float32" + + #adam + adam_beta1: 0.9 + adam_beta2: 0.999 + adam_eps: 1e-8 + + #sgd + sgd_momentum: 0.9 + + clip_grad: ${policy.max_grad_norm} + + #distributed optimizer + use_distributed_optimizer: true + use_precision_aware_optimizer: true + + optimizer_cpu_offload: False + optimizer_offload_fraction: 0 + + scheduler: + start_weight_decay: ${policy.megatron_cfg.optimizer.weight_decay} + end_weight_decay: ${policy.megatron_cfg.optimizer.weight_decay} + weight_decay_incr_style: "constant" + lr_decay_style: "constant" + lr_decay_iters: null + lr_warmup_iters: 10 + lr_warmup_init: 0.3e-7 + + distributed_data_parallel_config: + grad_reduce_in_fp32: false + overlap_grad_reduce: true + overlap_param_gather: true + average_in_collective: false + use_custom_fsdp: false + data_parallel_sharding_strategy: "optim_grads_params" + + env_vars: null + + # See docs/design-docs/sequence-packing-and-dynamic-batching.md + # for more details on dynamic batching and sequence packing. + dynamic_batching: + enabled: False + train_mb_tokens: ${mul:${policy.max_total_sequence_length}, ${policy.train_micro_batch_size}} + logprob_mb_tokens: ${mul:${policy.max_total_sequence_length}, ${policy.logprob_batch_size}} + sequence_length_round: 64 + + sequence_packing: + enabled: True + train_mb_tokens: ${mul:${policy.max_total_sequence_length}, ${policy.train_micro_batch_size}} + logprob_mb_tokens: ${mul:${policy.max_total_sequence_length}, ${policy.logprob_batch_size}} + algorithm: "modified_first_fit_decreasing" + sequence_length_round: 64 + + # makes the training sequence length divisible by the tensor parallel size + # this is useful for sequence parallel training + make_sequence_length_divisible_by: ${policy.megatron_cfg.tensor_model_parallel_size} + max_grad_norm: 1.0 + + optimizer: null # remove default FSDP optimizer + scheduler: null + + offload_optimizer_for_logprob: False + + generation: + backend: "vllm" + max_new_tokens: ${policy.max_total_sequence_length} + temperature: 1.0 + top_p: 1.0 + top_k: null + stop_token_ids: null + stop_strings: null + vllm_cfg: + # NB: can re-enable prefix cache on vllm >= 0.11.2. + # enable_prefix_caching: false + async_engine: false + kv_cache_dtype: auto + precision: ${policy.precision} + tensor_parallel_size: 4 + pipeline_parallel_size: 1 + expert_parallel_size: 1 # When EP > 1, EP must be a multiple of TP since vLLM's EP = DP * TP + gpu_memory_utilization: 0.5 + max_model_len: ${policy.max_total_sequence_length} + # when enforce_eager is False, it is optional to set ++policy.generation.vllm_kwargs.compilation_config.use_inductor=False for better accuracy, + # with the flag, vllm will use the custom CUDA kernels instead of the Triton kernels generated by torch.compile + # for more details, see convergence issue https://github.com/NVIDIA-NeMo/RL/issues/998 + enforce_eager: False + use_deep_gemm: False + num_last_layers_in_bf16: 0 + num_first_layers_in_bf16: 0 + expose_http_server: true + http_server_serving_chat_kwargs: + enable_auto_tools: true + tool_parser: qwen3_coder + reasoning_parser: deepseek_r1 + + vllm_kwargs: + mamba_ssm_cache_dtype: "float32" + compilation_config: + # when enforce_eager is False, set ++policy.generation.vllm_kwargs.compilation_config.use_inductor=False for better accuracy, + # with the flag, vllm will use the custom CUDA kernels instead of the Triton kernels generated by torch.compile + # for more details, see convergence issue https://github.com/NVIDIA-NeMo/RL/issues/998 + use_inductor: False + colocated: + # true: generation shares training GPUs + # false: uses dedicated generation resources + enabled: true + # only relevant when enabled is false + resources: + gpus_per_node: null # Decides num gpus to be dedicated to generation when there is one node in the cluster i.e cluster.num_nodes == 1 + num_nodes: null # Decides number of nodes to be dedicated to generation + +data: + train_jsonl_fpath: ${art:data,train} + validation_jsonl_fpath: ${art:data,train} + shuffle: False + num_workers: 1 + +env: + should_use_nemo_gym: true + nemo_gym: + config_paths: + - responses_api_models/vllm_model/configs/vllm_model_for_training.yaml # Required! And it must be *for_training + - resources_servers/math_with_judge/configs/math_with_judge.yaml + - resources_servers/code_gen/configs/code_gen.yaml + - resources_servers/workplace_assistant/configs/workplace_assistant.yaml + - resources_servers/mcqa/configs/mcqa.yaml + - resources_servers/instruction_following/configs/instruction_following.yaml + - resources_servers/structured_outputs/configs/structured_outputs_json.yaml + math_with_judge: + resources_servers: + math_with_judge: + judge_model_server: + name: policy_model + should_use_judge: false + code_gen: + resources_servers: + code_gen: + num_processes: 1024 + unit_test_timeout_secs: 10 + debug: false + +logger: + log_dir: "logs" # Base directory for all logs + num_val_samples_to_print: 0 # Number of validation samples to pretty print on terminal + wandb_enabled: true + tensorboard_enabled: false + mlflow_enabled: false # Disable MLflow logging + monitor_gpus: true # If true, will monitor GPU usage and log to wandb and/or tensorboard + swanlab_enabled: false # Disable SwanLab logging + wandb: + project: "${run.wandb.project}" + name: "${run.wandb.entity}" + tensorboard: {} + mlflow: + experiment_name: "grpo-dev" + run_name: "grpo-dev-logger" + gpu_monitoring: + collection_interval: 10 # How often to collect GPU usage metrics (in seconds) + flush_interval: 10 # How often to flush GPU usage metrics to the loggers (in seconds) + +cluster: + gpus_per_node: 8 + num_nodes: 1 diff --git a/src/nemotron/recipes/nano3/stage2_rl/data_prep.py b/src/nemotron/recipes/nano3/stage2_rl/data_prep.py new file mode 100644 index 0000000..2196067 --- /dev/null +++ b/src/nemotron/recipes/nano3/stage2_rl/data_prep.py @@ -0,0 +1,381 @@ +#!/usr/bin/env python3 + +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Data preparation for Nano3 RL stage. + +Processes the nvidia/Nemotron-3-Nano-RL-Training-Blend dataset and resolves +placeholder entries that reference external HuggingFace datasets (DAPO, Skywork). + +Placeholder records have an `_hf_placeholder` field containing row indices and +question templates. This script: +1. Detects placeholder records by the presence of `_hf_placeholder` field +2. Fetches the actual data from the external HF dataset +3. Applies template restoration (DAPO prefix/suffix, Skywork {question} replacement) +4. Outputs resolved JSONL with train/val/test splits + +For simple copy/passthrough (no placeholder resolution), use data_prep_copy.py instead. + +Usage: + # With default config + python data_prep.py + + # With custom config file + python data_prep.py --config /path/to/config.yaml + + # With CLI overrides (Hydra-style) + python data_prep.py sample=100 force=true + + # Via nemotron CLI with nemo-run + nemotron nano3 data prep rl --sample 10000 +""" + +from __future__ import annotations + +import json +import os +import sys +import time +from dataclasses import dataclass, field +from pathlib import Path + +from nemotron.data_prep import ( + DataBlend, + Dataset, + OutputConfig, + PipelineConfig, + last_mile_process, +) +from nemotron.data_prep.config import DatasetConfig, JsonlOutputConfig +from nemotron.data_prep.discovery import get_dataset_metadata +from nemotron.data_prep.formats.transforms import resolve_hf_placeholders +from nemotron.data_prep.hf_placeholder import HFPlaceholderResolver +from nemotron.kit import SplitJsonlDataArtifact, print_step_complete +from nemotron.kit.trackers import InputDatasetInfo +from nemotron.kit.train_script import ( + apply_hydra_overrides, + init_wandb_from_env, + load_omegaconf_yaml, + omegaconf_to_dataclass, + parse_config_and_overrides, +) +from nemotron.kit.wandb import add_wandb_tags, finish_wandb + +STAGE_PATH = Path(__file__).parent + +# Default config path relative to this file +DEFAULT_CONFIG_PATH = STAGE_PATH / "config" / "data_prep" / "default.yaml" + +# Use NEMO_RUN_DIR for output when running via nemo-run (avoids writing to code dir) +_OUTPUT_BASE = Path(os.environ.get("NEMO_RUN_DIR", ".")) + +# Module-level flag for Ray execution (used by nemotron CLI) +RAY = True + + +@dataclass +class RLDataPrepConfig: + """RL data preparation config with HuggingFace placeholder resolution. + + Processes nvidia/Nemotron-3-Nano-RL-Training-Blend and resolves placeholder + entries by fetching from external datasets (DAPO, Skywork). + + Outputs JSONL with resolved records containing: + - question: Full question text with template applied + - expected_answer: Answer from source dataset + - responses_create_params: OpenAI-format messages for RL training + + For simple copy/passthrough, use data_prep_copy.py instead. + """ + + blend_path: Path = field( + default_factory=lambda: STAGE_PATH / "config" / "data_prep" / "data_blend_raw.json" + ) + """Path to data blend JSON file""" + + output_dir: Path = field(default_factory=lambda: _OUTPUT_BASE / "output/nano3/stage2_rl_resolved") + """Output directory for resolved JSONL data""" + + shard_size: str = "256MB" + """Target size per shard (e.g., '256MB', '1GB')""" + + sample: int | None = None + """Limit rows per dataset (for quick tests)""" + + num_actors: int | None = None + """Ray actors for parallel processing (None = auto)""" + + force: bool = False + """Force new run, ignoring cache""" + + def __post_init__(self) -> None: + # Ensure paths are Path objects + if isinstance(self.blend_path, str): + self.blend_path = Path(self.blend_path) + if isinstance(self.output_dir, str): + self.output_dir = Path(self.output_dir) + + # Add sample suffix to output_dir if sampling + if self.sample is not None: + self.output_dir = self.output_dir / f"sample-{self.sample}" + + +def _run_resolve( + blend: DataBlend, + cfg: RLDataPrepConfig, + num_actors: int, + source_datasets: list[InputDatasetInfo], + resolver: HFPlaceholderResolver, +) -> SplitJsonlDataArtifact: + """Process blend with HuggingFace placeholder resolution. + + Downloads the HF dataset and outputs JSONL files for each split found + in the dataset (train, validation, test), resolving any placeholder records. + """ + from datasets import get_dataset_split_names + + start_time = time.time() + total_sequences = 0 + split_paths: dict[str, Path] = {} + + # Get the dataset from blend (expects single dataset in blend) + if len(blend.datasets) != 1: + raise ValueError( + f"Resolve mode expects exactly one dataset in blend, got {len(blend.datasets)}." + ) + + dataset = blend.datasets[0] + + # Handle hf:// prefix if present + dataset_path = dataset.path + if dataset_path.startswith("hf://"): + dataset_path = dataset_path[5:] + + # Discover available splits from HF + available_splits = get_dataset_split_names(dataset_path) + + # Normalize split names for output directories + # HF uses "validation" but we output as "val" for consistency + split_name_mapping = { + "train": "train", + "validation": "val", + "test": "test", + } + + # Create the resolve transform with pre-loaded resolver + transform = resolve_hf_placeholders(resolver=resolver) + + # Process each split + for hf_split in available_splits: + output_split_name = split_name_mapping.get(hf_split, hf_split) + split_output_dir = cfg.output_dir / output_split_name + + # Create a single-dataset blend for this split + split_blend = DataBlend( + datasets=[ + Dataset( + name=dataset.name, + path=dataset.path, + split=hf_split, # Use the HF split name + subset=dataset.subset, + weight=1.0, + text_field=dataset.text_field, + ) + ] + ) + + # Build pipeline config with resolve transform + format_config = JsonlOutputConfig( + shard_size=cfg.shard_size, + transform=transform, + ) + + pipeline_config = PipelineConfig( + output=OutputConfig( + dir=split_output_dir, + format=format_config, + max_rows=cfg.sample, + ), + tokenizer=None, + num_actors=num_actors, + force=cfg.force, + ) + + # Run processing for this split + result = last_mile_process(split_blend, pipeline_config) + total_sequences += result.total_sequences + + # Extract actual JSONL shard path from result + # data_paths format: ["weight", "shard_prefix", ...] + shard_prefix = result.splits["all"].data_paths[1] + # Find the actual JSONL file by globbing (shard naming uses variable digit padding) + shard_files = sorted(Path(shard_prefix).parent.glob("shard_*.jsonl")) + if shard_files: + jsonl_path = shard_files[0] + else: + raise FileNotFoundError(f"No JSONL shard files found at {shard_prefix}") + + split_paths[output_split_name] = str(jsonl_path.resolve()) + + # Resolve output_dir to absolute path for W&B artifact storage + output_dir = cfg.output_dir.resolve() + output_dir.mkdir(parents=True, exist_ok=True) + + # Resolve split paths to absolute paths + resolved_split_paths = {k: str(Path(v).resolve()) for k, v in split_paths.items() if v} + + # Create a combined manifest with absolute paths + manifest = { + "train": resolved_split_paths.get("train", ""), + "val": resolved_split_paths.get("val", ""), + "test": resolved_split_paths.get("test", ""), + "mode": "resolve", + "source_splits": available_splits, + } + + manifest_path = output_dir / "manifest.json" + with open(manifest_path, "w") as f: + json.dump(manifest, f, indent=2) + + elapsed = time.time() - start_time + + # Build artifact with split paths as typed fields + artifact = SplitJsonlDataArtifact( + path=manifest_path, + total_sequences=total_sequences, + elapsed_sec=elapsed, + source_datasets=source_datasets, + train=resolved_split_paths.get("train"), + val=resolved_split_paths.get("val"), + test=resolved_split_paths.get("test"), + ) + + return artifact + + +def run_data_prep_main(cfg: RLDataPrepConfig) -> SplitJsonlDataArtifact: + """Run RL data preparation with placeholder resolution. + + Args: + cfg: Resolve data prep configuration. + + Returns: + SplitJsonlDataArtifact with paths to resolved JSONL data. + """ + # Add stage-specific tags to wandb run + add_wandb_tags(["data-prep", "rl"]) + + # Load data blend + blend = DataBlend.load(cfg.blend_path) + + # Auto-detect num_actors from CPU count + num_actors = cfg.num_actors + if num_actors is None: + cpu_count = os.cpu_count() or 4 + num_actors = max(2, min(32, cpu_count * 3 // 4)) + + # Pre-load the HF placeholder resolver (loads DAPO and Skywork datasets) + print("Loading external HuggingFace datasets for placeholder resolution...") + resolver = HFPlaceholderResolver.create() + + # Collect source datasets with metadata for lineage tracking + source_datasets: list[InputDatasetInfo] = [] + seen_keys: set[str] = set() + for dataset in blend.datasets: + # Use path+subset as key since same path can have different subsets + key = f"{dataset.path}|{dataset.subset or ''}" + if key not in seen_keys: + seen_keys.add(key) + ds_config = DatasetConfig( + name=dataset.name, + path=dataset.path, + split=dataset.split, + subset=dataset.subset, + text_field=dataset.text_field, + ) + hf_metadata = get_dataset_metadata(ds_config) + source_datasets.append( + InputDatasetInfo( + uri=dataset.path, + name=dataset.name, + weight=dataset.weight, + split=dataset.split, + subset=dataset.subset, + text_field=dataset.text_field, + num_rows=hf_metadata.num_rows, + size_bytes=hf_metadata.size_bytes, + ) + ) + + # Add external placeholder datasets (DAPO, Skywork) for lineage tracking + for ext_ds_info in resolver.get_loaded_datasets_info(): + source_datasets.append( + InputDatasetInfo( + uri=ext_ds_info["uri"], + name=ext_ds_info["name"], + split=ext_ds_info["split"], + num_rows=ext_ds_info["num_rows"], + ) + ) + + # Run resolve processing + artifact = _run_resolve(blend, cfg, num_actors, source_datasets, resolver) + + artifact.name = f"nano3/rl/data-resolved{'?sample=' + str(cfg.sample) if cfg.sample else ''}" + artifact.save() + + # Mark wandb run as successful + finish_wandb(exit_code=0) + + print_step_complete(data_prep=artifact) + return artifact + + +def main(cfg: RLDataPrepConfig | None = None) -> SplitJsonlDataArtifact: + """Entry point for RL data preparation with placeholder resolution. + + Args: + cfg: Config from CLI framework, or None when run directly as script. + + Returns: + SplitJsonlDataArtifact with paths to resolved JSONL data. + """ + if cfg is None: + # Called directly as script - parse config ourselves + config_path, cli_overrides = parse_config_and_overrides(default_config=DEFAULT_CONFIG_PATH) + + # Load YAML config + try: + config = load_omegaconf_yaml(config_path) + except FileNotFoundError as e: + print(f"Error: {e}", file=sys.stderr) + sys.exit(1) + + # Apply CLI overrides (Hydra-style: key=value) + if cli_overrides: + config = apply_hydra_overrides(config, cli_overrides) + + # Convert to dataclass + cfg = omegaconf_to_dataclass(config, RLDataPrepConfig) + + # Initialize wandb from environment variables (set by nemo-run) + init_wandb_from_env() + + # Run data prep + return run_data_prep_main(cfg) + + +if __name__ == "__main__": + main() diff --git a/src/nemotron/recipes/nano3/stage2_rl/data_prep_merge.py b/src/nemotron/recipes/nano3/stage2_rl/data_prep_merge.py new file mode 100644 index 0000000..f800572 --- /dev/null +++ b/src/nemotron/recipes/nano3/stage2_rl/data_prep_merge.py @@ -0,0 +1,417 @@ +#!/usr/bin/env python3 + +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Data preparation for Nano3 RL stage (merge mode). + +Merges datasets from a raw data blend into a single JSONL output, then splits +into train/val/test based on configurable ratios. + +This is useful when you have multiple source datasets that need to be combined +and then split into training splits, rather than using pre-existing HF splits. + +For placeholder resolution (DAPO, Skywork datasets), use data_prep.py instead. + +Usage: + # With default config + python data_prep_merge.py + + # With custom config file + python data_prep_merge.py --config /path/to/config.yaml + + # With CLI overrides (Hydra-style) + python data_prep_merge.py sample=100 force=true train_ratio=0.9 + + # Via nemotron CLI with nemo-run + nemotron nano3 data prep rl --run data_prep_merge --sample 10000 +""" + +from __future__ import annotations + +import json +import os +import shutil +import sys +import time +from dataclasses import dataclass, field +from pathlib import Path + +from nemotron.data_prep import ( + DataBlend, + OutputConfig, + PipelineConfig, + last_mile_process, +) +from nemotron.data_prep.config import DatasetConfig, JsonlOutputConfig +from nemotron.data_prep.discovery import get_dataset_metadata +from nemotron.data_prep.formats.transforms import passthrough +from nemotron.kit import SplitJsonlDataArtifact, print_step_complete +from nemotron.kit.trackers import InputDatasetInfo +from nemotron.kit.train_script import ( + apply_hydra_overrides, + init_wandb_from_env, + load_omegaconf_yaml, + omegaconf_to_dataclass, + parse_config_and_overrides, +) +from nemotron.kit.wandb import add_wandb_tags, finish_wandb + +STAGE_PATH = Path(__file__).parent + +# Default config path relative to this file +DEFAULT_CONFIG_PATH = STAGE_PATH / "config" / "data_prep" / "merge.yaml" + +# Use NEMO_RUN_DIR for output when running via nemo-run (avoids writing to code dir) +_OUTPUT_BASE = Path(os.environ.get("NEMO_RUN_DIR", ".")) + +# Module-level flag for Ray execution (used by nemotron CLI) +RAY = True + + +@dataclass +class RLMergeDataPrepConfig: + """RL data preparation config (merge mode). + + Merges datasets from a raw data blend into JSONL, then splits into + train/val/test based on configurable ratios. + """ + + blend_path: Path = field( + default_factory=lambda: STAGE_PATH / "config" / "data_prep" / "data_blend_raw.json" + ) + """Path to data blend JSON file""" + + output_dir: Path = field(default_factory=lambda: _OUTPUT_BASE / "output/nano3/stage2_rl") + """Output directory for JSONL data""" + + shard_size: str = "256MB" + """Target size per shard (e.g., '256MB', '1GB')""" + + # Split ratios (must sum to 1.0) + train_ratio: float = 0.98 + """Fraction of data for training split""" + + valid_ratio: float = 0.01 + """Fraction of data for validation split""" + + test_ratio: float = 0.01 + """Fraction of data for test split""" + + sample: int | None = None + """Limit rows per dataset (for quick tests)""" + + num_actors: int | None = None + """Ray actors for parallel processing (None = auto)""" + + force: bool = False + """Force new run, ignoring cache""" + + seed: int = 42 + """Random seed for shuffling before split""" + + def __post_init__(self) -> None: + # Ensure paths are Path objects + if isinstance(self.blend_path, str): + self.blend_path = Path(self.blend_path) + if isinstance(self.output_dir, str): + self.output_dir = Path(self.output_dir) + + # Validate split ratios sum to 1.0 + total_ratio = self.train_ratio + self.valid_ratio + self.test_ratio + if abs(total_ratio - 1.0) > 1e-6: + raise ValueError( + f"Split ratios must sum to 1.0, got {total_ratio} " + f"(train={self.train_ratio}, valid={self.valid_ratio}, test={self.test_ratio})" + ) + + # Add sample suffix to output_dir if sampling + if self.sample is not None: + self.output_dir = self.output_dir / f"sample-{self.sample}" + + +def _split_jsonl_files( + shards_dir: Path, + output_dir: Path, + train_ratio: float, + valid_ratio: float, + test_ratio: float, + seed: int = 42, +) -> dict[str, dict]: + """Load all JSONL shards, shuffle, split by ratio, and save to split directories. + + Args: + shards_dir: Directory containing shard_*.jsonl files from pipeline. + output_dir: Directory to write train/, val/, test/ subdirectories. + train_ratio: Fraction of data for training. + valid_ratio: Fraction of data for validation. + test_ratio: Fraction of data for test. + seed: Random seed for shuffling before split. + + Returns: + Dict with split statistics and paths. + """ + import glob + import random + + # Find all shard files + shard_pattern = str(shards_dir / "**" / "*.jsonl") + shard_files = sorted(glob.glob(shard_pattern, recursive=True)) + + if not shard_files: + raise ValueError(f"No JSONL shard files found matching {shard_pattern}") + + print(f"Loading {len(shard_files)} shard files from {shards_dir}") + + # Load all records from shards + all_records: list[str] = [] + for shard_file in shard_files: + with open(shard_file) as f: + for line in f: + line = line.strip() + if line: + all_records.append(line) + + total_records = len(all_records) + print(f"Total records loaded: {total_records}") + + # Shuffle before splitting (for reproducibility) + random.seed(seed) + random.shuffle(all_records) + + # Calculate split boundaries + train_end = int(total_records * train_ratio) + valid_end = train_end + int(total_records * valid_ratio) + + # Split records + train_records = all_records[:train_end] + valid_records = all_records[train_end:valid_end] + test_records = all_records[valid_end:] + + # Create output directories + train_dir = output_dir / "train" + val_dir = output_dir / "val" + test_dir = output_dir / "test" + + for d in [train_dir, val_dir, test_dir]: + d.mkdir(parents=True, exist_ok=True) + + # Write split files + def write_split(records: list[str], split_dir: Path, split_name: str) -> Path: + output_path = split_dir / f"{split_name}.jsonl" + with open(output_path, "w") as f: + for record in records: + f.write(record + "\n") + print(f"Saved {len(records)} records to {output_path}") + return output_path + + train_path = write_split(train_records, train_dir, "train") + val_path = write_split(valid_records, val_dir, "val") + test_path = write_split(test_records, test_dir, "test") + + return { + "train": {"sequences": len(train_records), "path": train_path}, + "val": {"sequences": len(valid_records), "path": val_path}, + "test": {"sequences": len(test_records), "path": test_path}, + "total_sequences": total_records, + } + + +def _run_merge( + blend: DataBlend, + cfg: RLMergeDataPrepConfig, + num_actors: int, + source_datasets: list[InputDatasetInfo], +) -> SplitJsonlDataArtifact: + """Merge datasets and split into train/val/test. + + Processes all datasets in the blend, merges them together, shuffles, + and splits into train/val/test based on configured ratios. + """ + start_time = time.time() + + # Use a temporary shards directory for pipeline output + shards_dir = cfg.output_dir / "_shards" + + # Build pipeline config with passthrough transform + format_config = JsonlOutputConfig( + shard_size=cfg.shard_size, + transform=passthrough(), + ) + + pipeline_config = PipelineConfig( + output=OutputConfig( + dir=shards_dir, + format=format_config, + max_rows=cfg.sample, + ), + tokenizer=None, + num_actors=num_actors, + force=cfg.force, + ) + + # Run processing pipeline to generate merged shards + print("Running pipeline to merge datasets...") + result = last_mile_process(blend, pipeline_config) + + # Split the merged data by ratio + print("Splitting merged data by ratio...") + split_stats = _split_jsonl_files( + shards_dir=shards_dir, + output_dir=cfg.output_dir, + train_ratio=cfg.train_ratio, + valid_ratio=cfg.valid_ratio, + test_ratio=cfg.test_ratio, + seed=cfg.seed, + ) + + # Clean up intermediate shards directory + if shards_dir.exists(): + print(f"Cleaning up intermediate shards directory: {shards_dir}") + shutil.rmtree(shards_dir) + + # Create a combined manifest + manifest = { + "train": str(split_stats["train"]["path"]), + "val": str(split_stats["val"]["path"]), + "test": str(split_stats["test"]["path"]), + "mode": "merge", + "train_ratio": cfg.train_ratio, + "valid_ratio": cfg.valid_ratio, + "test_ratio": cfg.test_ratio, + "seed": cfg.seed, + "total_sequences": split_stats["total_sequences"], + } + + manifest_path = cfg.output_dir / "manifest.json" + with open(manifest_path, "w") as f: + json.dump(manifest, f, indent=2) + + elapsed = time.time() - start_time + + # Build artifact + artifact = SplitJsonlDataArtifact( + path=manifest_path, + total_sequences=split_stats["total_sequences"], + elapsed_sec=elapsed, + source_datasets=source_datasets, + ) + + # Add split paths to metadata for artifact resolution + artifact.metadata["train"] = str(split_stats["train"]["path"]) + artifact.metadata["val"] = str(split_stats["val"]["path"]) + artifact.metadata["test"] = str(split_stats["test"]["path"]) + + return artifact + + +def run_data_prep_main(cfg: RLMergeDataPrepConfig) -> SplitJsonlDataArtifact: + """Run RL data preparation (merge mode). + + Args: + cfg: RL merge data prep configuration. + + Returns: + SplitJsonlDataArtifact with paths to JSONL data. + """ + # Add stage-specific tags to wandb run + add_wandb_tags(["data-prep", "rl", "merge"]) + + # Load data blend + blend = DataBlend.load(cfg.blend_path) + + # Auto-detect num_actors from CPU count + num_actors = cfg.num_actors + if num_actors is None: + cpu_count = os.cpu_count() or 4 + num_actors = max(2, min(32, cpu_count * 3 // 4)) + + # Collect source datasets with metadata for lineage tracking + source_datasets: list[InputDatasetInfo] = [] + seen_keys: set[str] = set() + for dataset in blend.datasets: + # Use path+subset as key since same path can have different subsets + key = f"{dataset.path}|{dataset.subset or ''}" + if key not in seen_keys: + seen_keys.add(key) + ds_config = DatasetConfig( + name=dataset.name, + path=dataset.path, + split=dataset.split, + subset=dataset.subset, + text_field=dataset.text_field, + ) + hf_metadata = get_dataset_metadata(ds_config) + source_datasets.append( + InputDatasetInfo( + uri=dataset.path, + name=dataset.name, + weight=dataset.weight, + split=dataset.split, + subset=dataset.subset, + text_field=dataset.text_field, + num_rows=hf_metadata.num_rows, + size_bytes=hf_metadata.size_bytes, + ) + ) + + # Run merge processing + artifact = _run_merge(blend, cfg, num_actors, source_datasets) + + artifact.name = f"nano3/rl/data-merged{'?sample=' + str(cfg.sample) if cfg.sample else ''}" + artifact.save() + + # Mark wandb run as successful + finish_wandb(exit_code=0) + + print_step_complete(data_prep=artifact) + return artifact + + +def main(cfg: RLMergeDataPrepConfig | None = None) -> SplitJsonlDataArtifact: + """Entry point for RL data preparation (merge mode). + + Args: + cfg: Config from CLI framework, or None when run directly as script. + + Returns: + SplitJsonlDataArtifact with paths to JSONL data. + """ + if cfg is None: + # Called directly as script - parse config ourselves + config_path, cli_overrides = parse_config_and_overrides(default_config=DEFAULT_CONFIG_PATH) + + # Load YAML config + try: + config = load_omegaconf_yaml(config_path) + except FileNotFoundError as e: + print(f"Error: {e}", file=sys.stderr) + sys.exit(1) + + # Apply CLI overrides (Hydra-style: key=value) + if cli_overrides: + config = apply_hydra_overrides(config, cli_overrides) + + # Convert to dataclass + cfg = omegaconf_to_dataclass(config, RLMergeDataPrepConfig) + + # Initialize wandb from environment variables (set by nemo-run) + init_wandb_from_env() + + # Run data prep + return run_data_prep_main(cfg) + + +if __name__ == "__main__": + main() diff --git a/src/nemotron/recipes/nano3/stage2_rl/train.py b/src/nemotron/recipes/nano3/stage2_rl/train.py new file mode 100644 index 0000000..cb0511d --- /dev/null +++ b/src/nemotron/recipes/nano3/stage2_rl/train.py @@ -0,0 +1,319 @@ +#!/usr/bin/env python3 + +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""RL (Reinforcement Learning) script for Nemotron Nano3. + +Uses NeMo-RL's GRPO algorithm for reinforcement learning training. +This script is designed to run inside a container with NeMo-RL installed. + +Usage: + # Direct execution inside container (nemo-run with Ray) + python /path/to/train.py --config /path/to/grpo_config.yaml + + # With CLI overrides (Hydra syntax) + python /path/to/train.py --config /path/to/grpo_config.yaml \ + grpo.num_iterations=100 \ + policy.generation.temperature=0.7 +""" + +from __future__ import annotations + +# Flag to indicate this module requires Ray execution +RAY = True + +import argparse # noqa: E402 +import json # noqa: E402 +import os # noqa: E402 +import pprint # noqa: E402 +from itertools import chain, repeat # noqa: E402 +from typing import TYPE_CHECKING # noqa: E402 + +if TYPE_CHECKING: + from nemo_rl.algorithms.grpo import MasterConfig + + +def parse_args() -> tuple[argparse.Namespace, list[str]]: + """Parse command line arguments.""" + parser = argparse.ArgumentParser( + description="Run GRPO training for Nemotron Nano3", + formatter_class=argparse.RawTextHelpFormatter, + ) + parser.add_argument( + "--config", + type=str, + default=None, + help="Path to YAML config file", + ) + + args, overrides = parser.parse_known_args() + return args, overrides + + +def setup_single_nemo_gym_dataset(jsonl_fpath: str, tokenizer, num_repeats: int | None = None): + """Load and prepare a NeMo-Gym dataset from JSONL file.""" + from nemo_rl.data.datasets import AllTaskProcessedDataset + from nemo_rl.data.interfaces import DatumSpec + from nemo_rl.environments.nemo_gym import nemo_gym_example_to_nemo_rl_datum_spec + + with open(jsonl_fpath) as f: + nemo_gym_examples = list(map(json.loads, f)) + + print(f"Loaded data at {jsonl_fpath}. Found {len(nemo_gym_examples)} examples") + + if num_repeats: + previous_length = len(nemo_gym_examples) + nemo_gym_examples = list( + chain.from_iterable( + repeat(nemo_gym_example, num_repeats) for nemo_gym_example in nemo_gym_examples + ) + ) + print( + f"Repeating examples (in a pattern of abc to aabbcc) for {jsonl_fpath} " + f"from {previous_length} to {len(nemo_gym_examples)}!" + ) + + nemo_rl_compatible_examples: list[DatumSpec] = [ + nemo_gym_example_to_nemo_rl_datum_spec(nemo_gym_example, idx) + for idx, nemo_gym_example in enumerate(nemo_gym_examples) + ] + + def passthrough_task_processor(datum_dict, *args, **kwargs): + return datum_dict + + return AllTaskProcessedDataset( + nemo_rl_compatible_examples, + tokenizer, + None, + passthrough_task_processor, + ) + + +def main() -> None: + """Main entry point for GRPO training.""" + # ------------------------------------------------------------------------- + # WANDB MONKEY-PATCHES + # These patches work around bugs in wandb and NeMo-RL. + # See nemotron/kit/wandb.py for detailed "Why" / "Remove when" documentation. + # Applied early, before any wandb imports/init. + # ------------------------------------------------------------------------- + from nemotron.kit.wandb import ( + patch_nemo_rl_checkpoint_logging, + patch_wandb_http_handler_skip_digest_verification, + patch_wandb_local_file_handler_skip_digest_verification, + patch_wandb_runid_for_seeded_random, + ) + + patch_wandb_http_handler_skip_digest_verification() + patch_wandb_local_file_handler_skip_digest_verification() + patch_wandb_runid_for_seeded_random() + patch_nemo_rl_checkpoint_logging() + + # Increase W&B single object size warning threshold + import wandb.util + + wandb.util.VALUE_BYTES_LIMIT = 10_000_000 + + import ray + from nemo_rl.algorithms.grpo import ( + _should_use_nemo_gym, + grpo_train, + setup, + ) + from nemo_rl.algorithms.utils import get_tokenizer + from nemo_rl.distributed.ray_actor_environment_registry import get_actor_python_env + from nemo_rl.distributed.virtual_cluster import init_ray + from nemo_rl.environments.nemo_gym import ( + NemoGym, + NemoGymConfig, + setup_nemo_gym_config, + ) + from nemo_rl.models.generation import configure_generation_config + from nemo_rl.utils.config import load_config, parse_hydra_overrides + from nemo_rl.utils.logger import get_next_experiment_dir + from omegaconf import OmegaConf + + OmegaConf.register_new_resolver("mul", lambda a, b: a * b) + + # Parse arguments + args, overrides = parse_args() + + # Use default config if not specified + if not args.config: + args.config = os.path.join( + os.path.dirname(__file__), + "config", + "default.yaml", + ) + + config = load_config(args.config) + print(f"Loaded configuration from: {args.config}") + + if overrides: + print(f"Overrides: {overrides}") + config = parse_hydra_overrides(config, overrides) + + # Register nemotron artifact resolver for ${art:...} interpolations + # This must happen before OmegaConf.to_container() resolves the config + from nemotron.kit.resolvers import clear_artifact_cache, register_resolvers_from_config + + clear_artifact_cache() + register_resolvers_from_config( + config, + artifacts_key="run", + mode="pre_init", + pre_init_patch_http_digest=False, + ) + + config: MasterConfig = OmegaConf.to_container(config, resolve=True) + print("Applied CLI overrides") + + # Get the next experiment directory with incremented ID + config["logger"]["log_dir"] = get_next_experiment_dir(config["logger"]["log_dir"]) + print(f"Using log directory: {config['logger']['log_dir']}") + if config["checkpointing"]["enabled"]: + print(f"Using checkpoint directory: {config['checkpointing']['checkpoint_dir']}") + + # Setup tokenizer + tokenizer = get_tokenizer(config["policy"]["tokenizer"]) + assert config["policy"]["generation"] is not None, "A generation config is required for GRPO" + config["policy"]["generation"] = configure_generation_config( + config["policy"]["generation"], tokenizer + ) + + # NeMo-Gym specific config setup + setup_nemo_gym_config(config, tokenizer) + + # We assert here since this is right after the final config has been materialized + assert _should_use_nemo_gym(config) + + print("\nSetting up data...") + train_dataset = setup_single_nemo_gym_dataset( + jsonl_fpath=config["data"]["train_jsonl_fpath"], + tokenizer=tokenizer, + ) + val_dataset = setup_single_nemo_gym_dataset( + jsonl_fpath=config["data"]["validation_jsonl_fpath"], + tokenizer=tokenizer, + ) + + # Validation dataset config setup + if config["grpo"]["max_val_samples"] is not None: + raise ValueError( + "A non-null `grpo.max_val_samples` parameter is not supported. " + "The validation set you pass in will directly be used for validation " + "with no additional preprocessing." + ) + + print( + f"Setting `grpo.max_val_samples` and `grpo.val_batch_size` to the length " + f"of the validation dataset, which is {len(val_dataset)}" + ) + config["grpo"]["max_val_samples"] = len(val_dataset) + config["grpo"]["val_batch_size"] = config["grpo"]["max_val_samples"] + + # Print config + print("Final config:") + pprint.pprint(config) + + # Initialize Ray + init_ray() + + ( + policy, + policy_generation, + cluster, + dataloader, + val_dataloader, + loss_fn, + logger, + checkpointer, + grpo_state, + master_config, + ) = setup(config, tokenizer, train_dataset, val_dataset) + + is_trajectory_collection = ( + config["env"]["nemo_gym"].pop("is_trajectory_collection", False) or False + ) + nemo_gym_config = NemoGymConfig( + model_name=policy_generation.cfg["model_name"], + base_urls=policy_generation.dp_openai_server_base_urls, + initial_global_config_dict=config["env"]["nemo_gym"], + ) + nemo_gym = NemoGym.options( + runtime_env={ + "py_executable": get_actor_python_env("nemo_rl.environments.nemo_gym.NemoGym"), + } + ).remote(nemo_gym_config) + # Blocking wait for NeMo-Gym to spin up + ray.get(nemo_gym.health_check.remote()) + task_to_env = {"nemo_gym": nemo_gym} + val_task_to_env = task_to_env + + if is_trajectory_collection: + from nemo_rl.algorithms.grpo import refit_policy_generation + from nemo_rl.experience.rollouts import run_async_nemo_gym_rollout + from wandb import Table + + # Run trajectory collection + colocated_inference = master_config["policy"]["generation"]["colocated"]["enabled"] + refit_policy_generation(policy, policy_generation, colocated_inference) + + log_filename = "trajectory_collection.jsonl" + print("\nRunning trajectory collection...", flush=True) + generation_config = master_config["policy"]["generation"] + + for val_batch in val_dataloader: + nemo_gym_rollout_result = run_async_nemo_gym_rollout( + policy_generation=policy_generation, + input_batch=val_batch, + tokenizer=tokenizer, + task_to_env=val_task_to_env, + max_seq_len=None, + generation_config=generation_config, + max_rollout_turns=None, + greedy=False, + ) + + rows_to_log: list[str] = [] + for key, value in nemo_gym_rollout_result.rollout_metrics.items(): + if "full_result" not in key: + continue + value: Table + data: list[list[str]] = value.data + rows_to_log.extend(v[0] for v in data) + + logger.log_string_list_as_jsonl(rows_to_log, log_filename) + + policy_generation.finish_generation() + else: + grpo_train( + policy, + policy_generation, + dataloader, + val_dataloader, + tokenizer, + loss_fn, + task_to_env, + val_task_to_env, + logger, + checkpointer, + grpo_state, + master_config, + ) + + +if __name__ == "__main__": + main() diff --git a/tests/data_prep/__init__.py b/tests/data_prep/__init__.py new file mode 100644 index 0000000..8afe18a --- /dev/null +++ b/tests/data_prep/__init__.py @@ -0,0 +1,15 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Tests for data_prep module.""" diff --git a/tests/data_prep/test_ray_data.py b/tests/data_prep/test_ray_data.py new file mode 100644 index 0000000..c3b3719 --- /dev/null +++ b/tests/data_prep/test_ray_data.py @@ -0,0 +1,1336 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Tests for Ray Data shard-task executor. + +These tests verify: +1. ShardTask serialization/deserialization +2. RayDataConfig construction +3. execute_shard_tasks basic execution +4. BinIdxShardTaskUDF initialization +5. Bottleneck metrics tracking +6. process_binidx_shard_core with mocked tokenizer +7. Error handling and idempotency +8. Helper functions for tokenization and file processing +""" + +import json +import os +import tempfile +from pathlib import Path +from unittest.mock import MagicMock, patch + +import numpy as np +import pytest + + +class TestShardTask: + """Tests for ShardTask dataclass.""" + + def test_shard_task_creation(self): + """Test basic ShardTask creation.""" + from nemotron.data_prep.ray_data import ShardTask + + task = ShardTask( + dataset_name="test_dataset", + plan_hash="abc123", + shard_index=0, + assignment_json='{"shard_index": 0, "files": [], "total_bytes": 0}', + output_dir="/output", + receipts_dir="/receipts", + fs_protocol="file", + kind="binidx", + text_field="text", + ) + + assert task.dataset_name == "test_dataset" + assert task.plan_hash == "abc123" + assert task.shard_index == 0 + assert task.fs_protocol == "file" + + def test_shard_task_from_assignment(self): + """Test ShardTask.from_assignment factory method.""" + from nemotron.data_prep.ray_data import ShardTask + + assignment = { + "shard_index": 5, + "files": [{"path": "/data/file.parquet"}], + "total_bytes": 1000, + } + + task = ShardTask.from_assignment( + assignment=assignment, + dataset_name="ds1", + plan_hash="hash123", + shard_index=5, + output_dir="/out", + receipts_dir="/receipts", + fs_protocol="file", + ) + + assert task.shard_index == 5 + assert task.assignment_json == json.dumps(assignment) + + def test_shard_task_get_assignment_roundtrip(self): + """Test assignment JSON serialization roundtrip.""" + from nemotron.data_prep.ray_data import ShardTask + + original_assignment = { + "shard_index": 10, + "files": [ + {"path": "/data/file1.parquet", "bytes": 500}, + {"path": "/data/file2.parquet", "bytes": 500}, + ], + "total_bytes": 1000, + } + + task = ShardTask.from_assignment( + assignment=original_assignment, + dataset_name="ds", + plan_hash="h", + shard_index=10, + output_dir="/o", + receipts_dir="/r", + fs_protocol="file", + ) + + recovered = task.get_assignment() + assert recovered == original_assignment + + def test_shard_task_to_dict(self): + """Test ShardTask.to_dict for Ray Data serialization.""" + from nemotron.data_prep.ray_data import ShardTask + + task = ShardTask( + dataset_name="test", + plan_hash="hash", + shard_index=0, + assignment_json='{"files": []}', + output_dir="/out", + receipts_dir="/receipts", + fs_protocol="file", + ) + + d = task.to_dict() + + assert isinstance(d, dict) + assert d["dataset_name"] == "test" + assert d["plan_hash"] == "hash" + assert d["shard_index"] == 0 + assert d["assignment_json"] == '{"files": []}' + assert d["fs_protocol"] == "file" + assert d["kind"] == "binidx" + + def test_shard_task_empty_assignment(self): + """Test ShardTask with empty files list.""" + from nemotron.data_prep.ray_data import ShardTask + + assignment = {"shard_index": 0, "files": [], "total_bytes": 0} + task = ShardTask.from_assignment( + assignment=assignment, + dataset_name="empty", + plan_hash="h", + shard_index=0, + output_dir="/out", + receipts_dir="/r", + fs_protocol="file", + ) + + assert task.get_assignment()["files"] == [] + assert task.get_assignment()["total_bytes"] == 0 + + def test_shard_task_special_characters_in_paths(self): + """Test ShardTask with special characters in paths.""" + from nemotron.data_prep.ray_data import ShardTask + + task = ShardTask( + dataset_name="test-dataset_v2.0", + plan_hash="abc123def456", + shard_index=999, + assignment_json='{"files": [{"path": "/data/path with spaces/file.parquet"}]}', + output_dir="/output/path-with-dashes", + receipts_dir="/receipts/path_with_underscores", + fs_protocol="s3", + text_field="content", + ) + + assert task.dataset_name == "test-dataset_v2.0" + assert task.fs_protocol == "s3" + d = task.to_dict() + assert "path with spaces" in d["assignment_json"] + + def test_shard_task_large_shard_index(self): + """Test ShardTask with large shard index (stress test).""" + from nemotron.data_prep.ray_data import ShardTask + + task = ShardTask( + dataset_name="big_dataset", + plan_hash="hash", + shard_index=999999, + assignment_json='{"files": []}', + output_dir="/out", + receipts_dir="/r", + fs_protocol="file", + ) + + assert task.shard_index == 999999 + d = task.to_dict() + assert d["shard_index"] == 999999 + + def test_shard_task_complex_assignment_roundtrip(self): + """Test complex nested assignment JSON roundtrip.""" + from nemotron.data_prep.ray_data import ShardTask + + complex_assignment = { + "shard_index": 42, + "files": [ + { + "path": "/data/file1.parquet", + "bytes": 1000000, + "hf_repo_id": "nvidia/test-dataset", + "hf_filename": "train/data-00000.parquet", + "hf_revision": "main", + }, + { + "path": "/data/file2.parquet", + "bytes": 2000000, + "local_path": "/cache/file2.parquet", + }, + ], + "total_bytes": 3000000, + } + + task = ShardTask.from_assignment( + assignment=complex_assignment, + dataset_name="ds", + plan_hash="h", + shard_index=42, + output_dir="/o", + receipts_dir="/r", + fs_protocol="gcs", + ) + + recovered = task.get_assignment() + assert recovered == complex_assignment + assert len(recovered["files"]) == 2 + assert recovered["files"][0]["hf_repo_id"] == "nvidia/test-dataset" + + def test_shard_task_default_values(self): + """Test ShardTask default field values.""" + from nemotron.data_prep.ray_data import ShardTask + + task = ShardTask( + dataset_name="ds", + plan_hash="h", + shard_index=0, + assignment_json="{}", + output_dir="/o", + receipts_dir="/r", + fs_protocol="file", + ) + + assert task.kind == "binidx" + assert task.text_field == "text" + + def test_shard_task_custom_text_field(self): + """Test ShardTask with custom text field.""" + from nemotron.data_prep.ray_data import ShardTask + + task = ShardTask( + dataset_name="ds", + plan_hash="h", + shard_index=0, + assignment_json="{}", + output_dir="/o", + receipts_dir="/r", + fs_protocol="file", + text_field="content", + ) + + assert task.text_field == "content" + d = task.to_dict() + assert d["text_field"] == "content" + + def test_shard_task_frozen(self): + """Test that ShardTask is immutable (frozen dataclass).""" + from nemotron.data_prep.ray_data import ShardTask + + task = ShardTask( + dataset_name="ds", + plan_hash="h", + shard_index=0, + assignment_json="{}", + output_dir="/o", + receipts_dir="/r", + fs_protocol="file", + ) + + with pytest.raises(Exception): # FrozenInstanceError + task.shard_index = 1 + + +class TestRayDataExecConfig: + """Tests for RayDataExecConfig.""" + + def test_default_config(self): + """Test default config values.""" + from nemotron.data_prep.ray_data import RayDataExecConfig + + cfg = RayDataExecConfig() + + assert cfg.min_actors == 2 + assert cfg.max_actors == 32 + assert cfg.cpus_per_actor == 1.0 + assert cfg.max_tasks_in_flight_per_actor == 2 + + def test_custom_config(self): + """Test custom config values.""" + from nemotron.data_prep.ray_data import RayDataExecConfig + + cfg = RayDataExecConfig( + min_actors=4, + max_actors=64, + cpus_per_actor=2.0, + max_tasks_in_flight_per_actor=4, + ) + + assert cfg.min_actors == 4 + assert cfg.max_actors == 64 + assert cfg.cpus_per_actor == 2.0 + assert cfg.max_tasks_in_flight_per_actor == 4 + + +class TestRayDataConfig: + """Tests for RayDataConfig in config.py.""" + + def test_ray_data_config_creation(self): + """Test RayDataConfig creation.""" + from nemotron.data_prep.config import RayDataConfig + + cfg = RayDataConfig( + enabled=True, + min_actors=2, + max_actors=16, + cpus_per_actor=0.5, + max_tasks_in_flight_per_actor=3, + ) + + assert cfg.enabled is True + assert cfg.min_actors == 2 + assert cfg.max_actors == 16 + assert cfg.cpus_per_actor == 0.5 + assert cfg.max_tasks_in_flight_per_actor == 3 + + def test_pipeline_config_with_ray_data(self): + """Test PipelineConfig includes ray_data field.""" + from nemotron.data_prep.config import ( + OutputConfig, + PipelineConfig, + RayDataConfig, + ) + + ray_data_cfg = RayDataConfig(enabled=True, max_actors=8) + + pipeline_cfg = PipelineConfig( + output=OutputConfig(dir=Path("/out")), + ray_data=ray_data_cfg, + ) + + assert pipeline_cfg.ray_data is not None + assert pipeline_cfg.ray_data.enabled is True + assert pipeline_cfg.ray_data.max_actors == 8 + + +class TestBottleneckMetrics: + """Tests for BottleneckMetrics in console.py.""" + + def test_bottleneck_metrics_default(self): + """Test default values.""" + from nemotron.data_prep.console import BottleneckMetrics + + metrics = BottleneckMetrics() + + assert metrics.time_download == 0.0 + assert metrics.time_read == 0.0 + assert metrics.time_tokenize == 0.0 + assert metrics.time_write == 0.0 + assert metrics.num_shards == 0 + assert metrics.num_errors == 0 + + def test_bottleneck_metrics_add_shard_stats(self): + """Test adding shard stats to metrics.""" + from nemotron.data_prep.console import BottleneckMetrics + + metrics = BottleneckMetrics() + + stats = { + "time_download_sec": 1.0, + "time_read_sec": 2.0, + "time_tokenize_sec": 5.0, + "time_write_sec": 1.0, + "time_total_sec": 9.0, + "num_errors": 0, + } + + metrics.add_shard_stats(stats) + + assert metrics.time_download == 1.0 + assert metrics.time_read == 2.0 + assert metrics.time_tokenize == 5.0 + assert metrics.time_write == 1.0 + assert metrics.num_shards == 1 + assert metrics.num_errors == 0 + + def test_bottleneck_metrics_accumulates(self): + """Test that metrics accumulate across multiple shards.""" + from nemotron.data_prep.console import BottleneckMetrics + + metrics = BottleneckMetrics() + + # Add first shard + metrics.add_shard_stats({"time_tokenize_sec": 5.0, "num_errors": 0}) + # Add second shard + metrics.add_shard_stats({"time_tokenize_sec": 3.0, "num_errors": 1}) + + assert metrics.time_tokenize == 8.0 + assert metrics.num_shards == 2 + assert metrics.num_errors == 1 + + def test_bottleneck_metrics_percentages(self): + """Test time breakdown percentage calculation.""" + from nemotron.data_prep.console import BottleneckMetrics + + metrics = BottleneckMetrics() + metrics.time_download = 1.0 # 10% + metrics.time_read = 2.0 # 20% + metrics.time_tokenize = 5.0 # 50% + metrics.time_write = 2.0 # 20% + + pcts = metrics.get_percentages() + + assert abs(pcts["download_pct"] - 10.0) < 0.1 + assert abs(pcts["read_pct"] - 20.0) < 0.1 + assert abs(pcts["tokenize_pct"] - 50.0) < 0.1 + assert abs(pcts["write_pct"] - 20.0) < 0.1 + + def test_bottleneck_metrics_percentages_zero(self): + """Test percentage calculation with zero totals.""" + from nemotron.data_prep.console import BottleneckMetrics + + metrics = BottleneckMetrics() + pcts = metrics.get_percentages() + + assert pcts["download_pct"] == 0 + assert pcts["read_pct"] == 0 + assert pcts["tokenize_pct"] == 0 + assert pcts["write_pct"] == 0 + + +class TestDataPrepConfigRayData: + """Tests for DataPrepConfig with ray_data fields.""" + + def test_data_prep_config_ray_data_defaults(self): + """Test DataPrepConfig ray_data field defaults.""" + from nemotron.data_prep import DataPrepConfig + + cfg = DataPrepConfig() + + assert cfg.ray_data_enabled is True # Enabled by default + assert cfg.ray_data_min_actors == 16 # Start with good parallelism + assert cfg.ray_data_max_actors == 64 # Allow scaling on large nodes + assert cfg.ray_data_cpus_per_actor == 1.0 + assert cfg.ray_data_max_tasks_in_flight == 2 + + def test_data_prep_config_ray_data_custom(self): + """Test DataPrepConfig with custom ray_data settings.""" + from nemotron.data_prep import DataPrepConfig + + cfg = DataPrepConfig( + ray_data_enabled=True, + ray_data_min_actors=4, + ray_data_max_actors=16, + ray_data_cpus_per_actor=2.0, + ray_data_max_tasks_in_flight=4, + ) + + assert cfg.ray_data_enabled is True + assert cfg.ray_data_min_actors == 4 + assert cfg.ray_data_max_actors == 16 + assert cfg.ray_data_cpus_per_actor == 2.0 + assert cfg.ray_data_max_tasks_in_flight == 4 + + +class TestLiveExecutionStatusShardTiming: + """Tests for LiveExecutionStatus.report_shard_timing.""" + + def test_report_shard_timing_updates_bottleneck_metrics(self): + """Test that report_shard_timing updates internal metrics.""" + from nemotron.data_prep.console import LiveExecutionStatus + + status = LiveExecutionStatus() + + stats = { + "time_download_sec": 1.0, + "time_read_sec": 2.0, + "time_tokenize_sec": 5.0, + "time_write_sec": 1.0, + "time_total_sec": 9.0, + } + + status.report_shard_timing(stats) + + assert status._bottleneck_metrics.time_download == 1.0 + assert status._bottleneck_metrics.time_tokenize == 5.0 + assert status._bottleneck_metrics.num_shards == 1 + + +# Skip Ray tests if Ray is not available or not initialized +@pytest.fixture(scope="module") +def ray_initialized(): + """Initialize Ray for tests.""" + import ray + + if not ray.is_initialized(): + ray.init(num_cpus=2, ignore_reinit_error=True) + yield + # Don't shutdown - other tests may need it + + +class TestRayDataExecConfigEdgeCases: + """Additional edge case tests for RayDataExecConfig.""" + + def test_config_frozen(self): + """Test that config is immutable.""" + from nemotron.data_prep.ray_data import RayDataExecConfig + + cfg = RayDataExecConfig() + with pytest.raises(Exception): + cfg.min_actors = 10 + + def test_config_fractional_cpus(self): + """Test fractional CPU allocation.""" + from nemotron.data_prep.ray_data import RayDataExecConfig + + cfg = RayDataExecConfig(cpus_per_actor=0.25) + assert cfg.cpus_per_actor == 0.25 + + +class TestProcessBinidxShardCore: + """Tests for process_binidx_shard_core function.""" + + @pytest.fixture + def mock_tokenize(self): + """Create a mock tokenizer function.""" + + def tokenize(texts): + # Simple tokenizer: split on whitespace + return [[ord(c) for c in text] for text in texts] + + return tokenize + + @pytest.fixture + def temp_dirs(self): + """Create temporary directories for output and receipts.""" + with tempfile.TemporaryDirectory() as tmpdir: + output_dir = os.path.join(tmpdir, "shards") + receipts_dir = os.path.join(tmpdir, "receipts") + os.makedirs(output_dir) + os.makedirs(receipts_dir) + yield { + "output_dir": output_dir, + "receipts_dir": receipts_dir, + "tmpdir": tmpdir, + } + + def test_empty_assignment(self, mock_tokenize, temp_dirs): + """Test processing with empty assignment (no files).""" + from fsspec import filesystem + + from nemotron.data_prep.shard_processor import process_binidx_shard_core + + output_fs = filesystem("file") + assignment = {"shard_index": 0, "files": [], "total_bytes": 0} + + stats = process_binidx_shard_core( + tokenize=mock_tokenize, + text_field="text", + min_doc_chars=None, + max_doc_tokens=None, + dtype="int32", + max_rows=None, + shard_index=0, + assignment=assignment, + plan_hash="testhash", + output_dir=temp_dirs["output_dir"], + receipts_dir=temp_dirs["receipts_dir"], + output_fs=output_fs, + ) + + # Should create empty receipt + receipt_path = os.path.join(temp_dirs["receipts_dir"], "shard_000000.json") + assert os.path.exists(receipt_path) + + with open(receipt_path) as f: + receipt = json.load(f) + assert receipt["status"] == "completed" + assert receipt["stats"]["num_sequences"] == 0 + + def test_idempotency_skip_completed(self, mock_tokenize, temp_dirs): + """Test that processing skips already-completed shards.""" + from fsspec import filesystem + + from nemotron.data_prep.shard_processor import process_binidx_shard_core + + output_fs = filesystem("file") + assignment = {"shard_index": 0, "files": [], "total_bytes": 0} + + # First call - creates receipt + stats1 = process_binidx_shard_core( + tokenize=mock_tokenize, + text_field="text", + min_doc_chars=None, + max_doc_tokens=None, + dtype="int32", + max_rows=None, + shard_index=0, + assignment=assignment, + plan_hash="testhash", + output_dir=temp_dirs["output_dir"], + receipts_dir=temp_dirs["receipts_dir"], + output_fs=output_fs, + ) + + # Second call - should skip and return cached stats + stats2 = process_binidx_shard_core( + tokenize=mock_tokenize, + text_field="text", + min_doc_chars=None, + max_doc_tokens=None, + dtype="int32", + max_rows=None, + shard_index=0, + assignment=assignment, + plan_hash="testhash", + output_dir=temp_dirs["output_dir"], + receipts_dir=temp_dirs["receipts_dir"], + output_fs=output_fs, + ) + + # Both should return stats (second from receipt) + assert stats1["num_sequences"] == 0 + assert stats2["num_sequences"] == 0 + + def test_process_jsonl_file(self, mock_tokenize, temp_dirs): + """Test processing a JSONL file.""" + from fsspec import filesystem + + from nemotron.data_prep.shard_processor import process_binidx_shard_core + + # Create a test JSONL file + jsonl_path = os.path.join(temp_dirs["tmpdir"], "test.jsonl") + with open(jsonl_path, "w") as f: + for i in range(10): + f.write(json.dumps({"text": f"hello world document {i}"}) + "\n") + + output_fs = filesystem("file") + assignment = { + "shard_index": 0, + "files": [{"path": jsonl_path, "local_path": jsonl_path, "size": 100}], + "total_bytes": 100, + } + + stats = process_binidx_shard_core( + tokenize=mock_tokenize, + text_field="text", + min_doc_chars=None, + max_doc_tokens=None, + dtype="int32", + max_rows=None, + shard_index=0, + assignment=assignment, + plan_hash="hash123", + output_dir=temp_dirs["output_dir"], + receipts_dir=temp_dirs["receipts_dir"], + output_fs=output_fs, + ) + + assert stats["num_sequences"] == 10 + assert stats["num_input_rows"] == 10 + assert stats["total_tokens"] > 0 + + # Check output files + assert os.path.exists(os.path.join(temp_dirs["output_dir"], "shard_000000.bin")) + assert os.path.exists(os.path.join(temp_dirs["output_dir"], "shard_000000.idx")) + + def test_min_doc_chars_filter(self, mock_tokenize, temp_dirs): + """Test that min_doc_chars filters short documents.""" + from fsspec import filesystem + + from nemotron.data_prep.shard_processor import process_binidx_shard_core + + # Create JSONL with varying document lengths + jsonl_path = os.path.join(temp_dirs["tmpdir"], "test.jsonl") + with open(jsonl_path, "w") as f: + f.write(json.dumps({"text": "hi"}) + "\n") # 2 chars - filtered + f.write(json.dumps({"text": "hello world"}) + "\n") # 11 chars - kept + f.write(json.dumps({"text": "x"}) + "\n") # 1 char - filtered + + output_fs = filesystem("file") + assignment = { + "shard_index": 0, + "files": [{"path": jsonl_path, "local_path": jsonl_path, "size": 100}], + "total_bytes": 100, + } + + stats = process_binidx_shard_core( + tokenize=mock_tokenize, + text_field="text", + min_doc_chars=5, # Filter docs < 5 chars + max_doc_tokens=None, + dtype="int32", + max_rows=None, + shard_index=0, + assignment=assignment, + plan_hash="hash123", + output_dir=temp_dirs["output_dir"], + receipts_dir=temp_dirs["receipts_dir"], + output_fs=output_fs, + ) + + assert stats["num_sequences"] == 1 # Only "hello world" + assert stats["num_filtered"] == 2 # "hi" and "x" filtered + + def test_max_rows_limit(self, mock_tokenize, temp_dirs): + """Test that max_rows limits processing.""" + from fsspec import filesystem + + from nemotron.data_prep.shard_processor import process_binidx_shard_core + + # Create JSONL with many rows + jsonl_path = os.path.join(temp_dirs["tmpdir"], "test.jsonl") + with open(jsonl_path, "w") as f: + for i in range(100): + f.write(json.dumps({"text": f"document number {i}"}) + "\n") + + output_fs = filesystem("file") + assignment = { + "shard_index": 0, + "files": [{"path": jsonl_path, "local_path": jsonl_path, "size": 1000}], + "total_bytes": 1000, + } + + stats = process_binidx_shard_core( + tokenize=mock_tokenize, + text_field="text", + min_doc_chars=None, + max_doc_tokens=None, + dtype="int32", + max_rows=10, # Only process 10 rows + shard_index=0, + assignment=assignment, + plan_hash="hash123", + output_dir=temp_dirs["output_dir"], + receipts_dir=temp_dirs["receipts_dir"], + output_fs=output_fs, + ) + + assert stats["num_sequences"] == 10 + assert stats["num_input_rows"] == 10 + + def test_timing_metrics_present(self, mock_tokenize, temp_dirs): + """Test that timing metrics are returned.""" + from fsspec import filesystem + + from nemotron.data_prep.shard_processor import process_binidx_shard_core + + jsonl_path = os.path.join(temp_dirs["tmpdir"], "test.jsonl") + with open(jsonl_path, "w") as f: + f.write(json.dumps({"text": "test document"}) + "\n") + + output_fs = filesystem("file") + assignment = { + "shard_index": 0, + "files": [{"path": jsonl_path, "local_path": jsonl_path, "size": 50}], + "total_bytes": 50, + } + + stats = process_binidx_shard_core( + tokenize=mock_tokenize, + text_field="text", + min_doc_chars=None, + max_doc_tokens=None, + dtype="int32", + max_rows=None, + shard_index=0, + assignment=assignment, + plan_hash="hash", + output_dir=temp_dirs["output_dir"], + receipts_dir=temp_dirs["receipts_dir"], + output_fs=output_fs, + ) + + assert "time_total_sec" in stats + assert "time_read_sec" in stats + assert "time_tokenize_sec" in stats + assert "time_write_sec" in stats + assert stats["time_total_sec"] >= 0 + + +class TestTokenizeAndWriteBatchCore: + """Tests for _tokenize_and_write_batch_core helper function.""" + + def test_basic_tokenization(self): + """Test basic batch tokenization and writing.""" + from nemotron.data_prep.shard_processor import _tokenize_and_write_batch_core + + mock_builder = MagicMock() + stats = {"num_truncated": 0, "num_errors": 0} + + def tokenize(texts): + return [[1, 2, 3] for _ in texts] + + texts = ["text1", "text2", "text3"] + _tokenize_and_write_batch_core(texts, mock_builder, stats, tokenize, None) + + # Should call add_documents with 3 processed tokens + mock_builder.add_documents.assert_called_once() + args = mock_builder.add_documents.call_args[0][0] + assert len(args) == 3 + + def test_max_doc_tokens_truncation(self): + """Test that max_doc_tokens truncates long documents.""" + from nemotron.data_prep.shard_processor import _tokenize_and_write_batch_core + + mock_builder = MagicMock() + stats = {"num_truncated": 0, "num_errors": 0} + + def tokenize(texts): + return [[1, 2, 3, 4, 5, 6, 7, 8, 9, 10] for _ in texts] + + texts = ["long text"] + _tokenize_and_write_batch_core(texts, mock_builder, stats, tokenize, max_doc_tokens=5) + + mock_builder.add_documents.assert_called_once() + args = mock_builder.add_documents.call_args[0][0] + assert len(args[0]) == 5 # Truncated to 5 tokens + assert stats["num_truncated"] == 1 + + def test_empty_tokens_filtered(self): + """Test that empty token sequences are filtered out.""" + from nemotron.data_prep.shard_processor import _tokenize_and_write_batch_core + + mock_builder = MagicMock() + stats = {"num_truncated": 0, "num_errors": 0} + + def tokenize(texts): + return [[1, 2, 3], [], [4, 5]] # Middle one is empty + + texts = ["text1", "empty", "text3"] + _tokenize_and_write_batch_core(texts, mock_builder, stats, tokenize, None) + + mock_builder.add_documents.assert_called_once() + args = mock_builder.add_documents.call_args[0][0] + assert len(args) == 2 # Only non-empty sequences + + def test_tokenization_error_triggers_bisect(self): + """Test that tokenization errors trigger bisection.""" + from nemotron.data_prep.shard_processor import _tokenize_and_write_batch_core + + mock_builder = MagicMock() + stats = {"num_truncated": 0, "num_errors": 0} + + call_count = 0 + + def tokenize(texts): + nonlocal call_count + call_count += 1 + if call_count == 1: + raise ValueError("Tokenization error") + return [[1, 2, 3] for _ in texts] + + texts = ["text1", "text2"] + _tokenize_and_write_batch_core(texts, mock_builder, stats, tokenize, None) + + # Should have been called multiple times due to bisection + assert call_count > 1 + + +class TestTokenizeWithBisectCore: + """Tests for _tokenize_with_bisect_core helper function.""" + + def test_single_text_error(self): + """Test that single text error is recorded.""" + from nemotron.data_prep.shard_processor import _tokenize_with_bisect_core + + mock_builder = MagicMock() + stats = {"num_truncated": 0, "num_errors": 0} + + def tokenize(texts): + raise ValueError("Bad text") + + _tokenize_with_bisect_core(["bad text"], mock_builder, stats, tokenize, None) + + assert stats["num_errors"] == 1 + + def test_empty_list(self): + """Test that empty list is handled.""" + from nemotron.data_prep.shard_processor import _tokenize_with_bisect_core + + mock_builder = MagicMock() + stats = {"num_truncated": 0, "num_errors": 0} + + def tokenize(texts): + return [[1, 2, 3] for _ in texts] + + _tokenize_with_bisect_core([], mock_builder, stats, tokenize, None) + + # Should return without calling builder + mock_builder.add_document.assert_not_called() + + def test_isolates_bad_text(self): + """Test that bisection isolates the bad text.""" + from nemotron.data_prep.shard_processor import _tokenize_with_bisect_core + + mock_builder = MagicMock() + stats = {"num_truncated": 0, "num_errors": 0} + + bad_index = 1 + + def tokenize(texts): + for i, t in enumerate(texts): + if t == "bad": + raise ValueError("Bad text") + return [[1, 2, 3] for _ in texts] + + texts = ["good1", "bad", "good2", "good3"] + _tokenize_with_bisect_core(texts, mock_builder, stats, tokenize, None) + + # Should have 1 error (the "bad" text) + assert stats["num_errors"] == 1 + + +class TestBinIdxShardTaskUDFUnit: + """Unit tests for BinIdxShardTaskUDF.""" + + def test_udf_batch_extraction(self): + """Test that UDF correctly extracts fields from batch dict.""" + # We can't fully test without Ray, but we can test the logic + batch = { + "dataset_name": np.array(["test_ds"], dtype=object), + "shard_index": np.array([5], dtype=np.int64), + "plan_hash": np.array(["hash123"], dtype=object), + "assignment_json": np.array(['{"files": [], "shard_index": 5}'], dtype=object), + "output_dir": np.array(["/out"], dtype=object), + "receipts_dir": np.array(["/receipts"], dtype=object), + "fs_protocol": np.array(["file"], dtype=object), + "text_field": np.array(["text"], dtype=object), + } + + # Verify extraction logic + dataset_name = str(batch["dataset_name"][0]) + shard_index = int(batch["shard_index"][0]) + assignment = json.loads(str(batch["assignment_json"][0])) + + assert dataset_name == "test_ds" + assert shard_index == 5 + assert assignment["shard_index"] == 5 + + def test_udf_error_response_format(self): + """Test that error responses have correct numpy array format.""" + # Simulate error response format + error_response = { + "dataset_name": np.array(["test"], dtype=object), + "shard_index": np.array([0], dtype=np.int64), + "plan_hash": np.array(["hash"], dtype=object), + "total_tokens": np.array([0], dtype=np.int64), + "num_sequences": np.array([0], dtype=np.int64), + "num_filtered": np.array([0], dtype=np.int64), + "num_errors": np.array([1], dtype=np.int64), + "time_total_sec": np.array([0.0], dtype=np.float64), + "time_download_sec": np.array([0.0], dtype=np.float64), + "time_read_sec": np.array([0.0], dtype=np.float64), + "time_tokenize_sec": np.array([0.0], dtype=np.float64), + "time_write_sec": np.array([0.0], dtype=np.float64), + "error": np.array(["Test error"], dtype=object), + } + + # All values should be numpy arrays + for key, value in error_response.items(): + assert isinstance(value, np.ndarray), f"{key} should be numpy array" + assert len(value) == 1, f"{key} should have length 1" + + +class TestBottleneckMetricsExtended: + """Extended tests for BottleneckMetrics.""" + + def test_bottleneck_metrics_identifies_download_bottleneck(self): + """Test identification of download as bottleneck.""" + from nemotron.data_prep.console import BottleneckMetrics + + metrics = BottleneckMetrics() + metrics.time_download = 10.0 # 62.5% + metrics.time_read = 2.0 # 12.5% + metrics.time_tokenize = 3.0 # 18.75% + metrics.time_write = 1.0 # 6.25% + + pcts = metrics.get_percentages() + assert pcts["download_pct"] > 50 # Download is bottleneck + + def test_bottleneck_metrics_identifies_tokenize_bottleneck(self): + """Test identification of tokenization as bottleneck.""" + from nemotron.data_prep.console import BottleneckMetrics + + metrics = BottleneckMetrics() + metrics.time_download = 1.0 # 10% + metrics.time_read = 1.0 # 10% + metrics.time_tokenize = 7.0 # 70% + metrics.time_write = 1.0 # 10% + + pcts = metrics.get_percentages() + assert pcts["tokenize_pct"] > 50 # Tokenize is bottleneck + + def test_bottleneck_metrics_handles_missing_keys(self): + """Test that add_shard_stats handles missing keys gracefully.""" + from nemotron.data_prep.console import BottleneckMetrics + + metrics = BottleneckMetrics() + + # Partial stats dict + stats = {"time_tokenize_sec": 5.0} + metrics.add_shard_stats(stats) + + assert metrics.time_tokenize == 5.0 + assert metrics.time_download == 0.0 # Default + assert metrics.num_shards == 1 + + def test_bottleneck_metrics_many_shards(self): + """Test accumulation across many shards.""" + from nemotron.data_prep.console import BottleneckMetrics + + metrics = BottleneckMetrics() + + for i in range(100): + metrics.add_shard_stats( + { + "time_download_sec": 0.1, + "time_read_sec": 0.2, + "time_tokenize_sec": 0.5, + "time_write_sec": 0.2, + "num_errors": 0 if i % 10 != 0 else 1, # 10% error rate + } + ) + + assert metrics.num_shards == 100 + assert abs(metrics.time_download - 10.0) < 0.01 + assert abs(metrics.time_tokenize - 50.0) < 0.01 + assert metrics.num_errors == 10 + + +class TestRayDataConfigIntegration: + """Tests for RayDataConfig integration with PipelineConfig.""" + + def test_ray_data_config_defaults_in_pipeline(self): + """Test default RayDataConfig values in PipelineConfig.""" + from nemotron.data_prep.config import OutputConfig, PipelineConfig + + pipeline_cfg = PipelineConfig(output=OutputConfig(dir=Path("/out"))) + + # ray_data is None by default (not enabled) + assert pipeline_cfg.ray_data is None + + def test_ray_data_config_with_defaults(self): + """Test RayDataConfig with defaults in PipelineConfig.""" + from nemotron.data_prep.config import ( + OutputConfig, + PipelineConfig, + RayDataConfig, + ) + + pipeline_cfg = PipelineConfig( + output=OutputConfig(dir=Path("/out")), + ray_data=RayDataConfig(), # Use defaults + ) + + assert pipeline_cfg.ray_data is not None + assert pipeline_cfg.ray_data.enabled is False + assert pipeline_cfg.ray_data.min_actors == 2 + assert pipeline_cfg.ray_data.max_actors == 32 + + def test_ray_data_config_enabled(self): + """Test enabling RayDataConfig.""" + from nemotron.data_prep.config import ( + OutputConfig, + PipelineConfig, + RayDataConfig, + ) + + pipeline_cfg = PipelineConfig( + output=OutputConfig(dir=Path("/out")), + ray_data=RayDataConfig( + enabled=True, + min_actors=4, + max_actors=16, + ), + ) + + assert pipeline_cfg.ray_data.enabled is True + assert pipeline_cfg.ray_data.min_actors == 4 + assert pipeline_cfg.ray_data.max_actors == 16 + + +class TestWriteEmptyReceiptCore: + """Tests for _write_empty_receipt_core function.""" + + def test_writes_empty_receipt(self): + """Test that empty receipt is written correctly.""" + from fsspec import filesystem + + from nemotron.data_prep.shard_processor import _write_empty_receipt_core + + with tempfile.TemporaryDirectory() as tmpdir: + receipts_dir = os.path.join(tmpdir, "receipts") + os.makedirs(receipts_dir) + receipt_path = os.path.join(receipts_dir, "shard_000000.json") + + output_fs = filesystem("file") + stats = {"num_input_rows": 0, "num_filtered": 0} + timing: dict = {} + + import time + + total_start = time.perf_counter() + + result = _write_empty_receipt_core( + shard_id="shard_000000", + shard_index=0, + plan_hash="testhash", + input_files=[], + stats=stats, + receipt_path=receipt_path, + output_fs=output_fs, + timing=timing, + total_start=total_start, + ) + + assert os.path.exists(receipt_path) + + with open(receipt_path) as f: + receipt = json.load(f) + + assert receipt["status"] == "completed" + assert receipt["stats"]["num_sequences"] == 0 + assert receipt["stats"]["total_tokens"] == 0 + assert "time_total_sec" in result + + +class TestResolveFilePathCore: + """Tests for _resolve_file_path_core function.""" + + def test_local_path_passthrough(self): + """Test that local paths pass through unchanged.""" + from nemotron.data_prep.config import FileInfo + from nemotron.data_prep.shard_processor import _resolve_file_path_core + + file_info = FileInfo(path="/data/file.parquet", local_path=None, size=100) + result = _resolve_file_path_core(file_info) + assert result == "/data/file.parquet" + + def test_local_path_preferred(self): + """Test that local_path is preferred over path.""" + from nemotron.data_prep.config import FileInfo + from nemotron.data_prep.shard_processor import _resolve_file_path_core + + file_info = FileInfo( + path="/original/path.parquet", + size=100, + local_path="/cached/path.parquet", + ) + result = _resolve_file_path_core(file_info) + assert result == "/cached/path.parquet" + + +class TestExecuteShardTasksEmptyList: + """Test execute_shard_tasks with empty task list (no Ray required).""" + + def test_empty_tasks_returns_empty_list(self): + """Test that empty task list returns empty results without Ray.""" + from nemotron.data_prep.ray_data import RayDataExecConfig + + # This tests the early return path before Ray is used + exec_cfg = RayDataExecConfig() + + # We need Ray initialized for this test + try: + import ray + + if not ray.is_initialized(): + ray.init(num_cpus=1, ignore_reinit_error=True) + + from nemotron.data_prep.ray_data import execute_shard_tasks + + results = execute_shard_tasks( + tasks=[], + udf_cls=MagicMock, + udf_constructor_kwargs={}, + exec_cfg=exec_cfg, + ) + + assert results == [] + except ImportError: + pytest.skip("Ray not available") + + +class TestProcessParquetFile: + """Tests for parquet file processing.""" + + def test_process_parquet_file(self): + """Test processing a parquet file.""" + pytest.importorskip("pyarrow") + + import pyarrow as pa + import pyarrow.parquet as pq + from fsspec import filesystem + + from nemotron.data_prep.shard_processor import process_binidx_shard_core + + with tempfile.TemporaryDirectory() as tmpdir: + # Create parquet file + parquet_path = os.path.join(tmpdir, "test.parquet") + table = pa.table({"text": ["hello world", "foo bar", "test document"]}) + pq.write_table(table, parquet_path) + + output_dir = os.path.join(tmpdir, "shards") + receipts_dir = os.path.join(tmpdir, "receipts") + os.makedirs(output_dir) + os.makedirs(receipts_dir) + + def mock_tokenize(texts): + return [[ord(c) for c in t] for t in texts] + + output_fs = filesystem("file") + assignment = { + "shard_index": 0, + "files": [{"path": parquet_path, "local_path": parquet_path, "size": 100}], + "total_bytes": 100, + } + + stats = process_binidx_shard_core( + tokenize=mock_tokenize, + text_field="text", + min_doc_chars=None, + max_doc_tokens=None, + dtype="int32", + max_rows=None, + shard_index=0, + assignment=assignment, + plan_hash="hash", + output_dir=output_dir, + receipts_dir=receipts_dir, + output_fs=output_fs, + ) + + assert stats["num_sequences"] == 3 + assert stats["num_input_rows"] == 3 + + def test_parquet_min_doc_chars_arrow_filter(self): + """Test Arrow-level min_doc_chars filtering on parquet.""" + pytest.importorskip("pyarrow") + + import pyarrow as pa + import pyarrow.parquet as pq + from fsspec import filesystem + + from nemotron.data_prep.shard_processor import process_binidx_shard_core + + with tempfile.TemporaryDirectory() as tmpdir: + # Create parquet file with varying lengths + parquet_path = os.path.join(tmpdir, "test.parquet") + table = pa.table( + { + "text": [ + "hi", # 2 chars - filtered + "hello world this is long", # 24 chars - kept + "x", # 1 char - filtered + "another long document here", # 26 chars - kept + ] + } + ) + pq.write_table(table, parquet_path) + + output_dir = os.path.join(tmpdir, "shards") + receipts_dir = os.path.join(tmpdir, "receipts") + os.makedirs(output_dir) + os.makedirs(receipts_dir) + + def mock_tokenize(texts): + return [[ord(c) for c in t] for t in texts] + + output_fs = filesystem("file") + assignment = { + "shard_index": 0, + "files": [{"path": parquet_path, "local_path": parquet_path, "size": 100}], + "total_bytes": 100, + } + + stats = process_binidx_shard_core( + tokenize=mock_tokenize, + text_field="text", + min_doc_chars=10, # Filter < 10 chars + max_doc_tokens=None, + dtype="int32", + max_rows=None, + shard_index=0, + assignment=assignment, + plan_hash="hash", + output_dir=output_dir, + receipts_dir=receipts_dir, + output_fs=output_fs, + ) + + assert stats["num_sequences"] == 2 # Only long docs + assert stats["num_filtered"] == 2 # Short docs filtered + + +@pytest.mark.skip(reason="Requires Ray cluster and tokenizer") +class TestExecuteShardTasks: + """Integration tests for execute_shard_tasks. + + These tests require: + - Ray to be initialized + - A tokenizer to be available + + Skip for now - to be run manually or in CI with proper setup. + """ + + def test_execute_empty_tasks(self, ray_initialized): + """Test executing with empty task list.""" + from nemotron.data_prep.ray_data import ( + BinIdxShardTaskUDF, + RayDataExecConfig, + execute_shard_tasks, + ) + + exec_cfg = RayDataExecConfig(min_actors=1, max_actors=2) + + results = execute_shard_tasks( + tasks=[], + udf_cls=BinIdxShardTaskUDF, + udf_constructor_kwargs={ + "resolved_tokenizer": {"type": "test"}, + "dtype": "int32", + }, + exec_cfg=exec_cfg, + ) + + assert results == [] diff --git a/tests/kit/__init__.py b/tests/kit/__init__.py new file mode 100644 index 0000000..4362c43 --- /dev/null +++ b/tests/kit/__init__.py @@ -0,0 +1,15 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# Tests for nemotron.kit diff --git a/tests/kit/cli/__init__.py b/tests/kit/cli/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/kit/cli/test_utils.py b/tests/kit/cli/test_utils.py new file mode 100644 index 0000000..5722aa1 --- /dev/null +++ b/tests/kit/cli/test_utils.py @@ -0,0 +1,333 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Tests for nemotron.kit.cli.utils module.""" + +import pytest + +from nemotron.kit.cli.utils import ( + CONFIG_FILE_KEYS, + extract_run_args, + filter_config_file_args, + resolve_run_interpolations, + rewrite_paths_for_remote, +) + + +class TestResolveRunInterpolations: + """Tests for resolve_run_interpolations function.""" + + def test_resolve_simple_string(self): + """Test resolving a simple ${run.*} interpolation.""" + run_data = {"wandb": {"project": "my-project"}} + result = resolve_run_interpolations("${run.wandb.project}", run_data) + assert result == "my-project" + + def test_resolve_nested_path(self): + """Test resolving deeply nested paths.""" + run_data = {"a": {"b": {"c": {"d": "value"}}}} + result = resolve_run_interpolations("${run.a.b.c.d}", run_data) + assert result == "value" + + def test_resolve_in_dict(self): + """Test resolving interpolations in a dict.""" + run_data = {"wandb": {"project": "my-project", "entity": "my-team"}} + obj = { + "project": "${run.wandb.project}", + "entity": "${run.wandb.entity}", + "static": "unchanged", + } + result = resolve_run_interpolations(obj, run_data) + assert result == { + "project": "my-project", + "entity": "my-team", + "static": "unchanged", + } + + def test_resolve_in_list(self): + """Test resolving interpolations in a list.""" + run_data = {"values": {"a": "1", "b": "2"}} + obj = ["${run.values.a}", "${run.values.b}", "static"] + result = resolve_run_interpolations(obj, run_data) + assert result == ["1", "2", "static"] + + def test_resolve_in_nested_structure(self): + """Test resolving interpolations in nested dict/list structures.""" + run_data = {"config": {"name": "test"}} + obj = {"outer": [{"inner": "${run.config.name}"}]} + result = resolve_run_interpolations(obj, run_data) + assert result == {"outer": [{"inner": "test"}]} + + def test_preserve_non_run_interpolations(self): + """Test that non-${run.*} interpolations are preserved.""" + run_data = {"wandb": {"project": "my-project"}} + # ${art:data,path} should be preserved + result = resolve_run_interpolations("${art:data,path}", run_data) + assert result == "${art:data,path}" + + def test_preserve_unresolvable_paths(self): + """Test that unresolvable paths are preserved.""" + run_data = {"wandb": {"project": "my-project"}} + # nonexistent.path doesn't exist in run_data + result = resolve_run_interpolations("${run.nonexistent.path}", run_data) + assert result == "${run.nonexistent.path}" + + def test_preserve_scalars(self): + """Test that scalar values are preserved.""" + run_data = {} + assert resolve_run_interpolations(42, run_data) == 42 + assert resolve_run_interpolations(3.14, run_data) == 3.14 + assert resolve_run_interpolations(True, run_data) is True + assert resolve_run_interpolations(None, run_data) is None + + def test_preserve_non_interpolation_strings(self): + """Test that regular strings are preserved.""" + run_data = {"key": "value"} + assert resolve_run_interpolations("regular string", run_data) == "regular string" + assert resolve_run_interpolations("${incomplete", run_data) == "${incomplete" + + +class TestRewritePathsForRemote: + """Tests for rewrite_paths_for_remote function.""" + + def test_rewrite_pwd_env_var(self): + """Test rewriting ${oc.env:PWD}/path.""" + result = rewrite_paths_for_remote("${oc.env:PWD}/src/main.py", "/local/repo") + assert result == "/nemo_run/code/src/main.py" + + def test_rewrite_nemo_run_dir_simple(self): + """Test rewriting ${oc.env:NEMO_RUN_DIR}/path.""" + result = rewrite_paths_for_remote("${oc.env:NEMO_RUN_DIR}/output", "/local/repo") + assert result == "/nemo_run/output" + + def test_rewrite_nemo_run_dir_with_default(self): + """Test rewriting ${oc.env:NEMO_RUN_DIR,.}/path.""" + result = rewrite_paths_for_remote("${oc.env:NEMO_RUN_DIR,.}/logs", "/local/repo") + assert result == "/nemo_run/logs" + + def test_rewrite_absolute_path_under_repo(self): + """Test rewriting absolute paths under repo root.""" + result = rewrite_paths_for_remote("/local/repo/src/config.yaml", "/local/repo") + assert result == "/nemo_run/code/src/config.yaml" + + def test_preserve_paths_outside_repo(self): + """Test that paths outside repo root are preserved.""" + result = rewrite_paths_for_remote("/other/path/file.txt", "/local/repo") + assert result == "/other/path/file.txt" + + def test_rewrite_in_dict(self): + """Test rewriting paths in a dict.""" + obj = { + "config": "${oc.env:PWD}/config.yaml", + "output": "${oc.env:NEMO_RUN_DIR}/output", + "static": "/unchanged", + } + result = rewrite_paths_for_remote(obj, "/local/repo") + assert result == { + "config": "/nemo_run/code/config.yaml", + "output": "/nemo_run/output", + "static": "/unchanged", + } + + def test_rewrite_in_list(self): + """Test rewriting paths in a list.""" + obj = ["${oc.env:PWD}/a", "${oc.env:PWD}/b"] + result = rewrite_paths_for_remote(obj, "/local/repo") + assert result == ["/nemo_run/code/a", "/nemo_run/code/b"] + + def test_preserve_scalars(self): + """Test that scalar values are preserved.""" + assert rewrite_paths_for_remote(42, "/local/repo") == 42 + assert rewrite_paths_for_remote(None, "/local/repo") is None + + +class TestExtractRunArgs: + """Tests for extract_run_args function.""" + + def test_no_run_args(self): + """Test with no --run or --batch arguments.""" + profile, overrides, remaining, is_launch = extract_run_args( + ["--config", "test.yaml", "--batch-size", "32"] + ) + assert profile is None + assert overrides == {} + assert remaining == ["--config", "test.yaml", "--batch-size", "32"] + assert is_launch is False + + def test_run_profile_long_form(self): + """Test --run form.""" + profile, overrides, remaining, is_launch = extract_run_args( + ["--run", "slurm", "--batch-size", "32"] + ) + assert profile == "slurm" + assert overrides == {} + assert remaining == ["--batch-size", "32"] + assert is_launch is False + + def test_run_profile_short_form(self): + """Test -r form.""" + profile, overrides, remaining, is_launch = extract_run_args( + ["-r", "slurm", "--batch-size", "32"] + ) + assert profile == "slurm" + assert remaining == ["--batch-size", "32"] + assert is_launch is False + + def test_run_profile_equals_form(self): + """Test --run= form.""" + profile, overrides, remaining, is_launch = extract_run_args( + ["--run=slurm", "--batch-size", "32"] + ) + assert profile == "slurm" + assert remaining == ["--batch-size", "32"] + + def test_run_profile_short_equals_form(self): + """Test -r= form.""" + profile, overrides, remaining, is_launch = extract_run_args( + ["-r=slurm", "--batch-size", "32"] + ) + assert profile == "slurm" + assert remaining == ["--batch-size", "32"] + + def test_run_overrides(self): + """Test --run. form.""" + profile, overrides, remaining, is_launch = extract_run_args( + ["--run", "slurm", "--run.partition", "batch", "--run.nodes", "4"] + ) + assert profile == "slurm" + assert overrides == {"partition": "batch", "nodes": "4"} + assert remaining == [] + + def test_run_overrides_equals_form(self): + """Test --run.= form.""" + profile, overrides, remaining, is_launch = extract_run_args( + ["--run", "slurm", "--run.partition=batch"] + ) + assert profile == "slurm" + assert overrides == {"partition": "batch"} + + def test_batch_profile(self): + """Test --batch form.""" + profile, overrides, remaining, is_launch = extract_run_args( + ["--batch", "slurm", "--batch-size", "32"] + ) + assert profile == "slurm" + assert overrides == {} + assert remaining == ["--batch-size", "32"] + assert is_launch is True + + def test_batch_short_form(self): + """Test -b form.""" + profile, overrides, remaining, is_launch = extract_run_args( + ["-b", "slurm", "--batch-size", "32"] + ) + assert profile == "slurm" + assert is_launch is True + + def test_batch_overrides(self): + """Test --batch. form.""" + profile, overrides, remaining, is_launch = extract_run_args( + ["--batch", "slurm", "--batch.partition", "backfill"] + ) + assert profile == "slurm" + assert overrides == {"partition": "backfill"} + assert is_launch is True + + def test_run_and_batch_mutually_exclusive(self): + """Test that --run and --batch cannot be used together.""" + with pytest.raises(ValueError, match="mutually exclusive"): + extract_run_args(["--run", "slurm", "--batch", "local"]) + + def test_run_requires_profile(self): + """Test that --run requires a profile name.""" + with pytest.raises(ValueError, match="requires a profile name"): + extract_run_args(["--run"]) + + def test_run_requires_profile_not_flag(self): + """Test that --run doesn't accept a flag as profile.""" + with pytest.raises(ValueError, match="requires a profile name"): + extract_run_args(["--run", "--other-flag"]) + + def test_batch_requires_profile(self): + """Test that --batch requires a profile name.""" + with pytest.raises(ValueError, match="requires a profile name"): + extract_run_args(["--batch"]) + + def test_run_override_requires_value(self): + """Test that --run. requires a value.""" + with pytest.raises(ValueError, match="requires a value"): + extract_run_args(["--run", "slurm", "--run.partition"]) + + +class TestFilterConfigFileArgs: + """Tests for filter_config_file_args function.""" + + def test_filter_config_file_space_form(self): + """Test filtering --config-file .""" + result = filter_config_file_args( + ["--config-file", "config.yaml", "--batch-size", "32"] + ) + assert result == ["--batch-size", "32"] + + def test_filter_config_file_equals_form(self): + """Test filtering --config-file=.""" + result = filter_config_file_args( + ["--config-file=config.yaml", "--batch-size", "32"] + ) + assert result == ["--batch-size", "32"] + + def test_filter_config_underscore_form(self): + """Test filtering --config_file .""" + result = filter_config_file_args( + ["--config_file", "config.yaml", "--batch-size", "32"] + ) + assert result == ["--batch-size", "32"] + + def test_filter_config_short_form(self): + """Test filtering --config .""" + result = filter_config_file_args(["--config", "config.yaml", "--batch-size", "32"]) + assert result == ["--batch-size", "32"] + + def test_filter_c_short_form(self): + """Test filtering -c .""" + result = filter_config_file_args(["-c", "config.yaml", "--batch-size", "32"]) + assert result == ["--batch-size", "32"] + + def test_filter_c_equals_form(self): + """Test filtering -c=.""" + result = filter_config_file_args(["-c=config.yaml", "--batch-size", "32"]) + assert result == ["--batch-size", "32"] + + def test_no_config_file_args(self): + """Test with no config file arguments.""" + result = filter_config_file_args(["--batch-size", "32", "--learning-rate", "0.001"]) + assert result == ["--batch-size", "32", "--learning-rate", "0.001"] + + def test_multiple_config_file_args(self): + """Test filtering multiple config file arguments.""" + result = filter_config_file_args( + ["--config", "a.yaml", "-c", "b.yaml", "--batch-size", "32"] + ) + assert result == ["--batch-size", "32"] + + +class TestConfigFileKeys: + """Tests for CONFIG_FILE_KEYS constant.""" + + def test_contains_expected_keys(self): + """Test that CONFIG_FILE_KEYS contains all expected variants.""" + assert "--config-file" in CONFIG_FILE_KEYS + assert "--config_file" in CONFIG_FILE_KEYS + assert "--config" in CONFIG_FILE_KEYS + assert "-c" in CONFIG_FILE_KEYS diff --git a/tests/kit/test_artifact.py b/tests/kit/test_artifact.py new file mode 100644 index 0000000..d83512c --- /dev/null +++ b/tests/kit/test_artifact.py @@ -0,0 +1,695 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +""" +Tests for nemotron artifact functionality. +""" + +import json +import tempfile +from pathlib import Path +from typing import Annotated + +import pytest +from pydantic import Field + +from nemotron.kit import Artifact, DataBlendsArtifact, ModelArtifact, apply_scale + + +class SampleDataset(Artifact): + """Sample artifact for testing.""" + + num_examples: Annotated[int, Field(gt=0)] + quality: Annotated[float, Field(ge=0.0, le=1.0)] + + +def test_artifact_save_and_load(): + """Test saving and loading an artifact.""" + with tempfile.TemporaryDirectory() as tmpdir: + output_dir = Path(tmpdir) / "test_artifact" + + # Create artifact + artifact = SampleDataset( + path=output_dir, + num_examples=100, + quality=0.85, + ) + + # Save + artifact.save() + + # Verify metadata.json exists + metadata_path = output_dir / "metadata.json" + assert metadata_path.exists() + + # Load and verify + loaded = SampleDataset.load(path=output_dir) + assert loaded.num_examples == 100 + assert loaded.quality == 0.85 + # Typed fields are synced to metadata + assert loaded.metadata["num_examples"] == 100 + assert loaded.metadata["quality"] == 0.85 + + +def test_artifact_validation(): + """Test Pydantic validation works.""" + with tempfile.TemporaryDirectory() as tmpdir: + output_dir = Path(tmpdir) / "test_validation" + + # Valid artifact + valid = SampleDataset(path=output_dir, num_examples=100, quality=0.5) + assert valid.num_examples == 100 + + # Invalid: negative num_examples + with pytest.raises(Exception): # Pydantic ValidationError + SampleDataset(path=output_dir, num_examples=-1, quality=0.5) + + # Invalid: quality out of range + with pytest.raises(Exception): # Pydantic ValidationError + SampleDataset(path=output_dir, num_examples=100, quality=1.5) + + +def test_artifact_metadata_format(): + """Test that metadata.json has correct format.""" + with tempfile.TemporaryDirectory() as tmpdir: + output_dir = Path(tmpdir) / "test_format" + + artifact = SampleDataset( + path=output_dir, + num_examples=50, + quality=0.75, + ) + artifact.save() + + # Load metadata.json + with open(output_dir / "metadata.json") as f: + metadata = json.load(f) + + # Verify required fields + assert metadata["type"] == "SampleDataset" + assert metadata["num_examples"] == 50 + assert metadata["quality"] == 0.75 + assert metadata["producer"] == "local" + # Typed fields are in metadata dict + assert metadata["metadata"]["num_examples"] == 50 + assert metadata["metadata"]["quality"] == 0.75 + + +def test_artifact_metrics_property(): + """Test that metrics property extracts numeric values from metadata.""" + with tempfile.TemporaryDirectory() as tmpdir: + output_dir = Path(tmpdir) / "test_metrics" + + artifact = SampleDataset( + path=output_dir, + num_examples=100, + quality=0.85, + ) + + # Metrics should be extracted from metadata + metrics = artifact.metrics + assert metrics["num_examples"] == 100.0 + assert metrics["quality"] == 0.85 + + +def test_apply_scale(): + """Test scale factor utility.""" + assert apply_scale(100_000, "tiny") == 1_000 # 1% + assert apply_scale(100_000, "small") == 10_000 # 10% + assert apply_scale(100_000, "medium") == 30_000 # 30% + assert apply_scale(100_000, "full") == 100_000 # 100% + + # Minimum 1 even for tiny scale + assert apply_scale(10, "tiny") == 1 + + # Cap tiny at 10k rows + assert apply_scale(2_000_000, "tiny") == 10_000 # Would be 20k, capped at 10k + assert apply_scale(500_000, "tiny") == 5_000 # Under cap, not affected + + # Invalid scale + with pytest.raises(ValueError): + apply_scale(100, "invalid") + + +def test_artifact_type_inference(): + """Test that artifact type is inferred from class name.""" + with tempfile.TemporaryDirectory() as tmpdir: + output_dir = Path(tmpdir) / "test_type" + + artifact = SampleDataset(path=output_dir, num_examples=10, quality=0.5) + + # Type should be class name + assert artifact.type == "SampleDataset" + + +def test_data_blends_artifact(): + """Test DataBlendsArtifact typed subclass.""" + with tempfile.TemporaryDirectory() as tmpdir: + blend_path = Path(tmpdir) / "blend.json" + + artifact = DataBlendsArtifact( + path=blend_path, + total_tokens=1_000_000, + total_sequences=10_000, + elapsed_sec=120.5, + ) + + # Typed fields accessible directly + assert artifact.total_tokens == 1_000_000 + assert artifact.total_sequences == 10_000 + assert artifact.elapsed_sec == 120.5 + + # Also in metadata + assert artifact.metadata["total_tokens"] == 1_000_000 + assert artifact.metadata["total_sequences"] == 10_000 + + # Type inferred from class name + assert artifact.type == "DataBlendsArtifact" + + +def test_data_blends_artifact_save(): + """Test DataBlendsArtifact.save() writes metadata.json to parent directory.""" + with tempfile.TemporaryDirectory() as tmpdir: + blend_path = Path(tmpdir) / "output" / "blend.json" + + # Create blend.json file first (simulating pipeline.py behavior) + blend_path.parent.mkdir(parents=True, exist_ok=True) + blend_path.write_text('{"blends": []}') + + artifact = DataBlendsArtifact( + path=blend_path, + total_tokens=1_000_000, + total_sequences=10_000, + elapsed_sec=120.5, + ) + + # Save should not fail even though blend.json already exists + artifact.save() + + # metadata.json should be in the parent directory (same as blend.json) + metadata_path = blend_path.parent / "metadata.json" + assert metadata_path.exists() + + # Verify metadata content + with open(metadata_path) as f: + metadata = json.load(f) + + assert metadata["type"] == "DataBlendsArtifact" + assert metadata["total_tokens"] == 1_000_000 + assert metadata["total_sequences"] == 10_000 + assert metadata["producer"] == "local" + + +def test_model_artifact(): + """Test ModelArtifact typed subclass.""" + with tempfile.TemporaryDirectory() as tmpdir: + checkpoint_path = Path(tmpdir) / "checkpoint" + + artifact = ModelArtifact( + path=checkpoint_path, + step=10000, + final_loss=1.234, + ) + + # Typed fields accessible directly + assert artifact.step == 10000 + assert artifact.final_loss == 1.234 + + # Also in metadata + assert artifact.metadata["step"] == 10000 + assert artifact.metadata["final_loss"] == 1.234 + + # Type inferred from class name + assert artifact.type == "ModelArtifact" + + +def test_artifact_metadata_sync(): + """Test that typed fields sync to metadata and back.""" + with tempfile.TemporaryDirectory() as tmpdir: + output_dir = Path(tmpdir) / "test_sync" + + # Create artifact with typed fields + artifact = SampleDataset( + path=output_dir, + num_examples=42, + quality=0.99, + ) + artifact.save() + + # Load from disk + loaded = SampleDataset.load(path=output_dir) + + # Typed fields should be restored + assert loaded.num_examples == 42 + assert loaded.quality == 0.99 + + # And synced to metadata + assert loaded.metadata["num_examples"] == 42 + assert loaded.metadata["quality"] == 0.99 + + +def test_simple_artifact_no_subclass(): + """Test using Artifact directly with metadata dict.""" + with tempfile.TemporaryDirectory() as tmpdir: + output_dir = Path(tmpdir) / "test_simple" + + # Create simple artifact without subclass + artifact = Artifact( + path=output_dir, + type="custom", + metadata={"custom_field": 123, "another": "value"}, + ) + artifact.save() + + # Load and verify + loaded = Artifact.load(path=output_dir) + assert loaded.type == "custom" + assert loaded.metadata["custom_field"] == 123 + assert loaded.metadata["another"] == "value" + + +def test_artifact_art_path_with_name(): + """Test that art_path uses semantic name when set.""" + with tempfile.TemporaryDirectory() as tmpdir: + output_dir = Path(tmpdir) / "test_name" + + # Create artifact with semantic name + artifact = SampleDataset( + path=output_dir, + num_examples=10, + quality=0.5, + name="nano3/pretrain/data", + ) + + # art_path should use the semantic name + assert artifact.art_path == "art://nano3/pretrain/data" + + +def test_artifact_art_path_fallback(): + """Test that art_path falls back to full path when no name.""" + with tempfile.TemporaryDirectory() as tmpdir: + output_dir = Path(tmpdir) / "test_fallback" + + # Create artifact without name + artifact = SampleDataset( + path=output_dir, + num_examples=10, + quality=0.5, + ) + + # art_path should be the full path + assert artifact.art_path == f"art://{output_dir.resolve()}" + + +def test_data_blends_artifact_with_source_uris(): + """Test DataBlendsArtifact with source URIs for lineage tracking.""" + with tempfile.TemporaryDirectory() as tmpdir: + blend_path = Path(tmpdir) / "output" / "blend.json" + blend_path.parent.mkdir(parents=True, exist_ok=True) + blend_path.write_text('{"blends": []}') + + # Create artifact with source URIs + source_datasets = [ + "hf://nvidia/Nemotron-CC-v2", + "s3://my-bucket/data/train.jsonl", + "/local/path/to/data", + ] + tokenizer_uri = "https://huggingface.co/meta-llama/Llama-3.2-1B" + + artifact = DataBlendsArtifact( + path=blend_path, + total_tokens=1_000_000, + total_sequences=10_000, + elapsed_sec=120.5, + source_datasets=source_datasets, + tokenizer_uri=tokenizer_uri, + ) + + # Verify source URIs are accessible + assert artifact.source_datasets == source_datasets + assert artifact.tokenizer_uri == tokenizer_uri + + # Save and verify metadata includes source URIs + artifact.save() + metadata_path = blend_path.parent / "metadata.json" + with open(metadata_path) as f: + metadata = json.load(f) + + assert metadata["source_datasets"] == source_datasets + assert metadata["tokenizer_uri"] == tokenizer_uri + # Also in nested metadata dict + assert metadata["metadata"]["source_datasets"] == source_datasets + assert metadata["metadata"]["tokenizer_uri"] == tokenizer_uri + + +def test_data_blends_artifact_default_source_uris(): + """Test DataBlendsArtifact defaults for source URIs.""" + with tempfile.TemporaryDirectory() as tmpdir: + blend_path = Path(tmpdir) / "blend.json" + + # Create artifact without source URIs + artifact = DataBlendsArtifact( + path=blend_path, + total_tokens=1_000_000, + total_sequences=10_000, + ) + + # Default values + assert artifact.source_datasets == [] + assert artifact.tokenizer_uri is None + + +def test_data_blends_artifact_per_split_tokens(): + """Test DataBlendsArtifact with per-split token counts.""" + with tempfile.TemporaryDirectory() as tmpdir: + blend_path = Path(tmpdir) / "output" / "blend.json" + blend_path.parent.mkdir(parents=True, exist_ok=True) + blend_path.write_text('{"blends": []}') + + # Create artifact with per-split tokens + artifact = DataBlendsArtifact( + path=blend_path, + total_tokens=1_000_000, + total_sequences=10_000, + elapsed_sec=120.5, + train_tokens=900_000, + valid_tokens=50_000, + test_tokens=50_000, + ) + + # Verify per-split tokens are accessible + assert artifact.train_tokens == 900_000 + assert artifact.valid_tokens == 50_000 + assert artifact.test_tokens == 50_000 + + # Save and verify metadata includes per-split tokens + artifact.save() + metadata_path = blend_path.parent / "metadata.json" + with open(metadata_path) as f: + metadata = json.load(f) + + assert metadata["train_tokens"] == 900_000 + assert metadata["valid_tokens"] == 50_000 + assert metadata["test_tokens"] == 50_000 + # Also in nested metadata dict + assert metadata["metadata"]["train_tokens"] == 900_000 + assert metadata["metadata"]["valid_tokens"] == 50_000 + assert metadata["metadata"]["test_tokens"] == 50_000 + + +def test_data_blends_artifact_per_split_tokens_defaults(): + """Test DataBlendsArtifact defaults for per-split token counts.""" + with tempfile.TemporaryDirectory() as tmpdir: + blend_path = Path(tmpdir) / "blend.json" + + # Create artifact without per-split tokens + artifact = DataBlendsArtifact( + path=blend_path, + total_tokens=1_000_000, + total_sequences=10_000, + ) + + # Default values should be None + assert artifact.train_tokens is None + assert artifact.valid_tokens is None + assert artifact.test_tokens is None + + +def test_data_blends_artifact_partial_per_split_tokens(): + """Test DataBlendsArtifact with partial per-split token counts.""" + with tempfile.TemporaryDirectory() as tmpdir: + blend_path = Path(tmpdir) / "blend.json" + + # Create artifact with only train_tokens (valid and test None) + artifact = DataBlendsArtifact( + path=blend_path, + total_tokens=1_000_000, + total_sequences=10_000, + train_tokens=900_000, + ) + + # train_tokens should be set, others None + assert artifact.train_tokens == 900_000 + assert artifact.valid_tokens is None + assert artifact.test_tokens is None + + +def test_to_wandb_uri(): + """Test URI conversion for W&B artifact references.""" + from nemotron.kit.trackers import to_wandb_uri + + # HuggingFace dataset + assert ( + to_wandb_uri("hf://nvidia/Nemotron-CC-v2") + == "https://huggingface.co/datasets/nvidia/Nemotron-CC-v2" + ) + assert to_wandb_uri("hf://allenai/c4") == "https://huggingface.co/datasets/allenai/c4" + + # S3 and GCS URIs pass through + assert to_wandb_uri("s3://bucket/key") == "s3://bucket/key" + assert to_wandb_uri("gs://bucket/key") == "gs://bucket/key" + + # HTTP/HTTPS pass through + assert to_wandb_uri("https://example.com/data.json") == "https://example.com/data.json" + + # file:// pass through + assert to_wandb_uri("file:///path/to/data") == "file:///path/to/data" + + # Local paths convert to file:// + result = to_wandb_uri("/data/train.jsonl") + assert result.startswith("file:///") + assert "train.jsonl" in result + + +def test_tokenizer_to_uri(): + """Test tokenizer URI generation.""" + from nemotron.kit.trackers import tokenizer_to_uri + + # HuggingFace model + assert ( + tokenizer_to_uri("meta-llama/Llama-3.2-1B") + == "https://huggingface.co/meta-llama/Llama-3.2-1B" + ) + assert ( + tokenizer_to_uri("nvidia/Llama-3.1-Nemotron-70B-Instruct-HF") + == "https://huggingface.co/nvidia/Llama-3.1-Nemotron-70B-Instruct-HF" + ) + + # With revision + result = tokenizer_to_uri("meta-llama/Llama-3.2-1B", revision="abc123") + assert result == "https://huggingface.co/meta-llama/Llama-3.2-1B/tree/abc123" + + # Local path + result = tokenizer_to_uri("/path/to/tokenizer") + assert result.startswith("file:///") + assert "tokenizer" in result + + +def test_load_wandb_config_from_toml(): + """Test loading wandb config from env.toml.""" + from nemotron.kit.run import load_wandb_config + + with tempfile.TemporaryDirectory() as tmpdir: + # Create an env.toml with wandb section + env_toml = Path(tmpdir) / "env.toml" + env_toml.write_text(""" +[wandb] +project = "test-project" +entity = "test-team" +tags = ["tag1", "tag2"] +notes = "Test notes" + +[local] +executor = "local" +nproc_per_node = 8 +""") + # Load wandb config + config = load_wandb_config(config_path=env_toml) + + assert config is not None + assert config.project == "test-project" + assert config.entity == "test-team" + assert config.tags == ("tag1", "tag2") + assert config.notes == "Test notes" + assert config.enabled is True + + +def test_load_wandb_config_missing_section(): + """Test loading wandb config when [wandb] section is missing.""" + from nemotron.kit.run import load_wandb_config + + with tempfile.TemporaryDirectory() as tmpdir: + # Create an env.toml without wandb section + env_toml = Path(tmpdir) / "env.toml" + env_toml.write_text(""" +[local] +executor = "local" +nproc_per_node = 8 +""") + # Load wandb config - should return None + config = load_wandb_config(config_path=env_toml) + assert config is None + + +def test_load_wandb_config_with_name_shorthand(): + """Test loading wandb config with 'name' shorthand for run_name.""" + from nemotron.kit.run import load_wandb_config + + with tempfile.TemporaryDirectory() as tmpdir: + env_toml = Path(tmpdir) / "env.toml" + env_toml.write_text(""" +[wandb] +project = "test-project" +name = "my-run-name" +""") + config = load_wandb_config(config_path=env_toml) + + assert config is not None + assert config.run_name == "my-run-name" + + +def test_resolve_partition_default(): + """Test resolve_partition returns base partition when no overrides.""" + from nemotron.kit.run import RunConfig, resolve_partition + + config = RunConfig(partition="batch") + + # Both run and launch should return base partition + assert resolve_partition(config, is_launch=False) == "batch" + assert resolve_partition(config, is_launch=True) == "batch" + + +def test_resolve_partition_run_override(): + """Test resolve_partition uses run_partition for attached execution.""" + from nemotron.kit.run import RunConfig, resolve_partition + + config = RunConfig( + partition="batch", + run_partition="interactive", + ) + + # --run should use run_partition + assert resolve_partition(config, is_launch=False) == "interactive" + # --batch should still use base partition + assert resolve_partition(config, is_launch=True) == "batch" + + +def test_resolve_partition_batch_override(): + """Test resolve_partition uses batch_partition for detached execution.""" + from nemotron.kit.run import RunConfig, resolve_partition + + config = RunConfig( + partition="batch", + batch_partition="backfill", + ) + + # --run should use base partition + assert resolve_partition(config, is_launch=False) == "batch" + # --batch should use batch_partition + assert resolve_partition(config, is_launch=True) == "backfill" + + +def test_resolve_partition_both_overrides(): + """Test resolve_partition with both run_partition and batch_partition.""" + from nemotron.kit.run import RunConfig, resolve_partition + + config = RunConfig( + partition="batch", + run_partition="interactive", + batch_partition="backfill", + ) + + # --run uses run_partition + assert resolve_partition(config, is_launch=False) == "interactive" + # --batch uses batch_partition + assert resolve_partition(config, is_launch=True) == "backfill" + + +def test_resolve_partition_no_base(): + """Test resolve_partition when no base partition is set.""" + from nemotron.kit.run import RunConfig, resolve_partition + + config = RunConfig( + run_partition="interactive", + batch_partition="backfill", + ) + + # Uses specific partitions when available + assert resolve_partition(config, is_launch=False) == "interactive" + assert resolve_partition(config, is_launch=True) == "backfill" + + +def test_resolve_partition_none(): + """Test resolve_partition returns None when no partition is configured.""" + from nemotron.kit.run import RunConfig, resolve_partition + + config = RunConfig() + + assert resolve_partition(config, is_launch=False) is None + assert resolve_partition(config, is_launch=True) is None + + +def test_load_run_profile_with_partition_overrides(): + """Test loading run profile with run_partition and batch_partition fields.""" + from nemotron.kit.run import load_run_profile, resolve_partition + + with tempfile.TemporaryDirectory() as tmpdir: + env_toml = Path(tmpdir) / "env.toml" + env_toml.write_text(""" +[slurm] +executor = "slurm" +account = "my-account" +partition = "batch" +run_partition = "interactive" +batch_partition = "backfill" +""") + profile = load_run_profile("slurm", config_path=env_toml) + + assert profile.partition == "batch" + assert profile.run_partition == "interactive" + assert profile.batch_partition == "backfill" + + # Verify resolution + assert resolve_partition(profile, is_launch=False) == "interactive" + assert resolve_partition(profile, is_launch=True) == "backfill" + + +def test_partition_inheritance(): + """Test partition fields are properly inherited via extends.""" + from nemotron.kit.run import load_run_profile, resolve_partition + + with tempfile.TemporaryDirectory() as tmpdir: + env_toml = Path(tmpdir) / "env.toml" + env_toml.write_text(""" +[base] +executor = "slurm" +account = "my-account" +partition = "batch" +run_partition = "interactive" + +[child] +extends = "base" +batch_partition = "backfill" +""") + profile = load_run_profile("child", config_path=env_toml) + + # partition and run_partition inherited from base + assert profile.partition == "batch" + assert profile.run_partition == "interactive" + # batch_partition defined in child + assert profile.batch_partition == "backfill" + + # Verify resolution + assert resolve_partition(profile, is_launch=False) == "interactive" + assert resolve_partition(profile, is_launch=True) == "backfill" diff --git a/tests/kit/test_ast_inliner.py b/tests/kit/test_ast_inliner.py new file mode 100644 index 0000000..7b23cb9 --- /dev/null +++ b/tests/kit/test_ast_inliner.py @@ -0,0 +1,68 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from __future__ import annotations + +from pathlib import Path + +from nemotron.kit.packaging.self_contained_packager import inline_imports + + +def test_inline_imports_inlines_nemotron_modules_and_keeps_external_imports(tmp_path: Path): + repo_root = tmp_path + (repo_root / "src" / "nemotron").mkdir(parents=True) + + (repo_root / "src" / "nemotron" / "a.py").write_text( + """ +def f() -> int: + return 1 +""".lstrip(), + encoding="utf-8", + ) + + (repo_root / "src" / "nemotron" / "b.py").write_text( + """ +from nemotron.a import f as g + +def h() -> int: + return g() + 1 +""".lstrip(), + encoding="utf-8", + ) + + entry = repo_root / "entry.py" + entry.write_text( + """ +from __future__ import annotations + +import math +from nemotron.b import h +import nemotron.a as a + +def main() -> int: + return h() + a.f() + int(math.sqrt(4)) +""".lstrip(), + encoding="utf-8", + ) + + out = inline_imports(entry, repo_root=repo_root, package_prefix="nemotron") + for line in out.splitlines(): + stripped = line.strip() + assert not stripped.startswith("from nemotron") + assert not stripped.startswith("import nemotron") + assert "import math" in out + + ns: dict[str, object] = {} + exec(compile(out, "", "exec"), ns) + assert ns["main"]() == 5 diff --git a/tests/kit/test_code_packager.py b/tests/kit/test_code_packager.py new file mode 100644 index 0000000..93c0355 --- /dev/null +++ b/tests/kit/test_code_packager.py @@ -0,0 +1,94 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import subprocess +import sys +import tarfile +from pathlib import Path + +import pytest + + +def test_code_packager_excludes_usage_cookbook_and_use_case_examples(tmp_path): + pytest.importorskip("nemo_run") + + from nemotron.kit.packaging.code_packager import CodePackager + + repo_root = tmp_path / "repo" + (repo_root / "src" / "nemotron").mkdir(parents=True) + + (repo_root / "usage-cookbook" / "x.txt").parent.mkdir(parents=True) + (repo_root / "usage-cookbook" / "x.txt").write_text("nope", encoding="utf-8") + (repo_root / "use-case-examples" / "y.txt").parent.mkdir(parents=True) + (repo_root / "use-case-examples" / "y.txt").write_text("nope", encoding="utf-8") + + (repo_root / "src" / "nemotron" / "helper.py").write_text( + "VALUE = 123\n", + encoding="utf-8", + ) + (repo_root / "src" / "nemotron" / "__init__.py").write_text("", encoding="utf-8") + + script_rel = Path("src/nemotron/train.py") + (repo_root / script_rel).write_text( + """ +import argparse + +from nemotron.helper import VALUE + + +def main() -> None: + p = argparse.ArgumentParser() + p.add_argument("--config") + p.parse_args() + print(VALUE) + + +if __name__ == "__main__": + main() +""".lstrip(), + encoding="utf-8", + ) + + train_cfg = tmp_path / "train.yaml" + train_cfg.write_text("a: 1\n", encoding="utf-8") + + out_dir = tmp_path / "out" + out_dir.mkdir() + + packager = CodePackager(script_path=str(script_rel), train_path=str(train_cfg)) + tar_path = packager.package(repo_root, str(out_dir), "pkg") + + with tarfile.open(tar_path, "r:gz") as tf: + names = tf.getnames() + assert "main.py" in names + assert "config.yaml" in names + assert "src/nemotron/helper.py" in names + assert not any(n.startswith("usage-cookbook/") for n in names) + assert not any(n.startswith("use-case-examples/") for n in names) + + extract_dir = tmp_path / "extract" + extract_dir.mkdir() + tf.extractall(extract_dir) + + out = subprocess.check_output( + [ + sys.executable, + str(extract_dir / "main.py"), + "--config", + "config.yaml", + ], + cwd=extract_dir, + text=True, + ) + assert out.strip().endswith("123") diff --git a/tests/kit/test_filesystem.py b/tests/kit/test_filesystem.py new file mode 100644 index 0000000..e8e6513 --- /dev/null +++ b/tests/kit/test_filesystem.py @@ -0,0 +1,290 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Tests for nemotron.kit.filesystem module.""" + +import tempfile +from pathlib import Path + +import pytest + +from nemotron.kit.filesystem import ArtifactFileSystem +from nemotron.kit.registry import ArtifactRegistry, set_registry + + +@pytest.fixture +def setup_registry_with_artifact(): + """Setup a registry with a test artifact.""" + with tempfile.TemporaryDirectory() as tmpdir: + # Setup registry + root = Path(tmpdir) / "registry" + registry = ArtifactRegistry(backend="fsspec", root=root) + set_registry(registry) + + # Create source artifact + source = Path(tmpdir) / "source" + source.mkdir() + (source / "data.json").write_text('{"key": "value"}') + (source / "subdir").mkdir() + (source / "subdir" / "nested.txt").write_text("nested content") + + # Publish artifact + registry.publish("test-artifact", source, metadata={"test": True}) + + yield { + "registry": registry, + "source": source, + "tmpdir": tmpdir, + } + + # Cleanup + set_registry(None) + + +class TestArtifactFileSystemParseUri: + """Tests for URI parsing functionality.""" + + def test_parse_simple_name_with_version(self): + """Test parsing simple name:version format.""" + fs = ArtifactFileSystem() + name, version, file_path = fs._parse_uri("art://my-artifact:v1") + assert name == "my-artifact" + assert version == 1 + assert file_path == "" + + def test_parse_simple_name_with_version_and_file(self): + """Test parsing name:version/file format.""" + fs = ArtifactFileSystem() + name, version, file_path = fs._parse_uri("art://my-artifact:v1/data.json") + assert name == "my-artifact" + assert version == 1 + assert file_path == "data.json" + + def test_parse_simple_name_with_version_and_nested_file(self): + """Test parsing name:version/path/to/file format.""" + fs = ArtifactFileSystem() + name, version, file_path = fs._parse_uri("art://my-artifact:v2/path/to/file.txt") + assert name == "my-artifact" + assert version == 2 + assert file_path == "path/to/file.txt" + + def test_parse_latest_version(self): + """Test parsing name:latest format.""" + fs = ArtifactFileSystem() + name, version, file_path = fs._parse_uri("art://my-artifact:latest") + assert name == "my-artifact" + assert version is None # latest maps to None + assert file_path == "" + + def test_parse_numeric_version(self): + """Test parsing name:N (numeric without v prefix).""" + fs = ArtifactFileSystem() + name, version, file_path = fs._parse_uri("art://my-artifact:5") + assert name == "my-artifact" + assert version == 5 + + def test_parse_no_version(self): + """Test parsing name without version (implies latest).""" + fs = ArtifactFileSystem() + name, version, file_path = fs._parse_uri("art://my-artifact") + assert name == "my-artifact" + assert version is None + + def test_parse_wandb_full_path(self): + """Test parsing entity/project/name:version format.""" + fs = ArtifactFileSystem() + name, version, file_path = fs._parse_uri("art://romeyn/nemotron/DataBlendsArtifact:v10") + assert name == "romeyn/nemotron/DataBlendsArtifact" + assert version == 10 + assert file_path == "" + + def test_parse_wandb_full_path_with_file(self): + """Test parsing entity/project/name:version/file format.""" + fs = ArtifactFileSystem() + name, version, file_path = fs._parse_uri( + "art://romeyn/nemotron/DataBlendsArtifact:v10/blends.json" + ) + assert name == "romeyn/nemotron/DataBlendsArtifact" + assert version == 10 + assert file_path == "blends.json" + + def test_parse_without_protocol(self): + """Test parsing without art:// prefix.""" + fs = ArtifactFileSystem() + name, version, file_path = fs._parse_uri("my-artifact:v1/data.json") + assert name == "my-artifact" + assert version == 1 + assert file_path == "data.json" + + +class TestArtifactFileSystemOperations: + """Tests for filesystem operations.""" + + def test_open_file(self, setup_registry_with_artifact): + """Test opening a file from artifact.""" + fs = ArtifactFileSystem() + + with fs._open("art://test-artifact:v1/data.json", "r") as f: + content = f.read() + assert content == '{"key": "value"}' + + def test_open_binary_file(self, setup_registry_with_artifact): + """Test opening a file in binary mode.""" + fs = ArtifactFileSystem() + + with fs._open("art://test-artifact:v1/data.json", "rb") as f: + content = f.read() + assert content == b'{"key": "value"}' + + def test_open_nested_file(self, setup_registry_with_artifact): + """Test opening a nested file.""" + fs = ArtifactFileSystem() + + with fs._open("art://test-artifact:v1/subdir/nested.txt", "r") as f: + content = f.read() + assert content == "nested content" + + def test_open_write_mode_fails(self, setup_registry_with_artifact): + """Test that write mode raises error.""" + fs = ArtifactFileSystem() + + with pytest.raises(ValueError, match="read-only"): + fs._open("art://test-artifact:v1/data.json", "w") + + def test_ls_artifact_root(self, setup_registry_with_artifact): + """Test listing artifact root.""" + fs = ArtifactFileSystem() + + result = fs.ls("art://test-artifact:v1", detail=False) + # Should contain data.json and subdir + file_names = [p.split("/")[-1] for p in result] + assert "data.json" in file_names + assert "subdir" in file_names + + def test_ls_with_detail(self, setup_registry_with_artifact): + """Test listing with detail=True.""" + fs = ArtifactFileSystem() + + result = fs.ls("art://test-artifact:v1", detail=True) + assert isinstance(result, list) + assert all(isinstance(item, dict) for item in result) + + # Find the data.json entry + data_json = next((item for item in result if "data.json" in item["name"]), None) + assert data_json is not None + assert data_json["type"] == "file" + assert data_json["size"] > 0 + + def test_ls_subdirectory(self, setup_registry_with_artifact): + """Test listing a subdirectory.""" + fs = ArtifactFileSystem() + + result = fs.ls("art://test-artifact:v1/subdir", detail=False) + file_names = [p.split("/")[-1] for p in result] + assert "nested.txt" in file_names + + def test_info_file(self, setup_registry_with_artifact): + """Test getting info for a file.""" + fs = ArtifactFileSystem() + + info = fs.info("art://test-artifact:v1/data.json") + assert info["type"] == "file" + assert info["size"] > 0 + + def test_info_directory(self, setup_registry_with_artifact): + """Test getting info for a directory.""" + fs = ArtifactFileSystem() + + info = fs.info("art://test-artifact:v1/subdir") + assert info["type"] == "directory" + + def test_exists_true(self, setup_registry_with_artifact): + """Test exists returns True for existing path.""" + fs = ArtifactFileSystem() + + assert fs.exists("art://test-artifact:v1/data.json") is True + assert fs.exists("art://test-artifact:v1/subdir") is True + + def test_exists_false(self, setup_registry_with_artifact): + """Test exists returns False for non-existing path.""" + fs = ArtifactFileSystem() + + # Non-existing file within existing artifact + assert fs.exists("art://test-artifact:v1/nonexistent.txt") is False + # Non-existing version of existing artifact + assert fs.exists("art://test-artifact:v999/data.json") is False + + def test_cat_file(self, setup_registry_with_artifact): + """Test reading entire file content.""" + fs = ArtifactFileSystem() + + content = fs.cat_file("art://test-artifact:v1/data.json") + assert content == b'{"key": "value"}' + + def test_cat_file_with_range(self, setup_registry_with_artifact): + """Test reading file with byte range.""" + fs = ArtifactFileSystem() + + content = fs.cat_file("art://test-artifact:v1/data.json", start=0, end=5) + assert content == b'{"key' + + def test_get_file(self, setup_registry_with_artifact): + """Test copying file to local path.""" + fs = ArtifactFileSystem() + + with tempfile.TemporaryDirectory() as tmpdir: + dest = Path(tmpdir) / "local_copy.json" + fs.get_file("art://test-artifact:v1/data.json", str(dest)) + + assert dest.exists() + assert dest.read_text() == '{"key": "value"}' + + def test_isfile_true(self, setup_registry_with_artifact): + """Test isfile returns True for file.""" + fs = ArtifactFileSystem() + + assert fs.isfile("art://test-artifact:v1/data.json") is True + + def test_isfile_false_for_dir(self, setup_registry_with_artifact): + """Test isfile returns False for directory.""" + fs = ArtifactFileSystem() + + assert fs.isfile("art://test-artifact:v1/subdir") is False + + def test_isfile_false_for_nonexistent(self, setup_registry_with_artifact): + """Test isfile returns False for nonexistent.""" + fs = ArtifactFileSystem() + + assert fs.isfile("art://test-artifact:v1/nonexistent.txt") is False + + def test_isdir_true(self, setup_registry_with_artifact): + """Test isdir returns True for directory.""" + fs = ArtifactFileSystem() + + assert fs.isdir("art://test-artifact:v1/subdir") is True + + def test_isdir_false_for_file(self, setup_registry_with_artifact): + """Test isdir returns False for file.""" + fs = ArtifactFileSystem() + + assert fs.isdir("art://test-artifact:v1/data.json") is False + + +class TestArtifactFileSystemProtocol: + """Tests for filesystem protocol registration.""" + + def test_protocol_attribute(self): + """Test that protocol is 'art'.""" + fs = ArtifactFileSystem() + assert fs.protocol == "art" diff --git a/tests/kit/test_pipeline.py b/tests/kit/test_pipeline.py new file mode 100644 index 0000000..bfea336 --- /dev/null +++ b/tests/kit/test_pipeline.py @@ -0,0 +1,314 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Tests for nemotron.kit.pipeline (PipelineConfig, run_pipeline).""" + +from types import ModuleType +from unittest.mock import MagicMock, patch + +from nemotron.kit import PipelineConfig, Step, run_pipeline +from nemotron.kit.pipeline import ( + generate_pipeline_commands, + generate_sbatch_script, + run_local, +) + + +def create_mock_module(name: str, file_path: str | None = None) -> ModuleType: + """Create a mock module for testing.""" + module = ModuleType(name) + module.__name__ = name + module.__file__ = file_path or f"/path/to/{name.replace('.', '/')}.py" + return module + + +class TestPipelineConfig: + """Tests for PipelineConfig dataclass.""" + + def test_default_values(self): + """Test PipelineConfig default values.""" + config = PipelineConfig() + + assert config.launcher == "local" + assert config.nproc_per_node == 8 + assert config.executor == "local" + assert config.nodes == 1 + assert config.time == "04:00:00" + assert config.job_name == "pipeline" + assert config.dry_run is False + assert config.verbose is True + + def test_custom_values(self): + """Test PipelineConfig with custom values.""" + config = PipelineConfig( + launcher="sbatch", + nproc_per_node=4, + account="my_account", + partition="batch", + nodes=2, + time="08:00:00", + job_name="custom_job", + ) + + assert config.launcher == "sbatch" + assert config.nproc_per_node == 4 + assert config.account == "my_account" + assert config.partition == "batch" + assert config.nodes == 2 + assert config.time == "08:00:00" + assert config.job_name == "custom_job" + + def test_slurm_settings(self): + """Test Slurm-specific settings.""" + config = PipelineConfig( + launcher="nemo-run", + executor="slurm", + account="account", + partition="gpu", + container_image="/path/to/container.sqsh", + mounts=["/data:/data"], + ) + + assert config.executor == "slurm" + assert config.container_image == "/path/to/container.sqsh" + assert config.mounts == ["/data:/data"] + + def test_ssh_tunnel_settings(self): + """Test SSH tunnel settings.""" + config = PipelineConfig( + tunnel="ssh", + host="cluster.example.com", + user="myuser", + remote_job_dir="/remote/jobs", + identity="~/.ssh/id_rsa", + ) + + assert config.tunnel == "ssh" + assert config.host == "cluster.example.com" + assert config.user == "myuser" + assert config.remote_job_dir == "/remote/jobs" + assert config.identity == "~/.ssh/id_rsa" + + def test_env_vars(self): + """Test environment variables.""" + config = PipelineConfig( + env_vars=["CUDA_VISIBLE_DEVICES=0,1", "NCCL_DEBUG=INFO"], + ) + + assert len(config.env_vars) == 2 + assert "CUDA_VISIBLE_DEVICES=0,1" in config.env_vars + + +class TestRunPipeline: + """Tests for run_pipeline function.""" + + def test_empty_steps_returns_error(self): + """Test that empty steps list returns error code.""" + config = PipelineConfig() + + result = run_pipeline(config, []) + + assert result == 1 + + def test_dry_run_local(self): + """Test dry run with local launcher.""" + config = PipelineConfig(dry_run=True, verbose=False) + module = create_mock_module("test.step") + steps = [Step(name="test", module=module)] + + result = run_pipeline(config, steps) + + assert result == 0 + + def test_unknown_launcher_returns_error(self): + """Test that unknown launcher returns error.""" + config = PipelineConfig() + # Manually set invalid launcher to bypass type checking + object.__setattr__(config, "launcher", "invalid") + + module = create_mock_module("test.step") + steps = [Step(name="test", module=module)] + + result = run_pipeline(config, steps) + + assert result == 1 + + +class TestRunLocal: + """Tests for run_local function.""" + + def test_dry_run_returns_zero(self): + """Test dry run returns 0 without executing.""" + config = PipelineConfig(dry_run=True, verbose=False) + module = create_mock_module("test.step") + steps = [Step(name="test", module=module)] + + result = run_local(config, steps) + + assert result == 0 + + def test_empty_steps_returns_zero(self): + """Test empty steps list returns 0.""" + config = PipelineConfig() + + result = run_local(config, []) + + assert result == 0 + + @patch("subprocess.Popen") + def test_single_step_execution(self, mock_popen): + """Test single step execution.""" + mock_process = MagicMock() + mock_process.returncode = 0 + mock_process.stdout = None + mock_process.wait.return_value = None + mock_popen.return_value = mock_process + + config = PipelineConfig(verbose=False) + module = create_mock_module("test.step") + steps = [Step(name="test", module=module)] + + result = run_local(config, steps) + + assert result == 0 + mock_popen.assert_called_once() + + @patch("subprocess.Popen") + def test_step_failure_returns_error(self, mock_popen): + """Test that step failure returns error code.""" + mock_process = MagicMock() + mock_process.returncode = 1 + mock_process.stdout = None + mock_process.wait.return_value = None + mock_popen.return_value = mock_process + + config = PipelineConfig(verbose=False) + module = create_mock_module("test.step") + steps = [Step(name="test", module=module)] + + result = run_local(config, steps) + + assert result == 1 + + +class TestGenerateSbatchScript: + """Tests for generate_sbatch_script function.""" + + def test_basic_script_generation(self): + """Test basic sbatch script generation.""" + config = PipelineConfig( + account="test_account", + partition="gpu", + nodes=2, + nproc_per_node=8, + time="04:00:00", + job_name="test_job", + ) + module = create_mock_module("test.training") + steps = [Step(name="training", module=module, torchrun=True)] + + script = generate_sbatch_script(config, steps) + + assert "#!/bin/bash" in script + assert "#SBATCH --job-name=test_job" in script + assert "#SBATCH --account=test_account" in script + assert "#SBATCH --partition=gpu" in script + assert "#SBATCH --nodes=2" in script + assert "#SBATCH --time=04:00:00" in script + assert "srun" in script + + def test_script_with_env_vars(self): + """Test script generation with environment variables.""" + config = PipelineConfig( + account="account", + partition="gpu", + env_vars=["MY_VAR=value", "OTHER=123"], + ) + module = create_mock_module("test.step") + steps = [Step(name="test", module=module)] + + script = generate_sbatch_script(config, steps) + + assert "export MY_VAR=value" in script + assert "export OTHER=123" in script + + def test_script_with_container(self): + """Test script generation with container.""" + config = PipelineConfig( + account="account", + partition="gpu", + container_image="/path/to/container.sqsh", + mounts=["/data:/data"], + ) + module = create_mock_module("test.training") + steps = [Step(name="training", module=module, torchrun=True)] + + script = generate_sbatch_script(config, steps) + + assert "--container-image=/path/to/container.sqsh" in script + assert "--container-mounts=/data:/data" in script + + +class TestGeneratePipelineCommands: + """Tests for generate_pipeline_commands function.""" + + def test_single_step_command(self): + """Test command generation for single step.""" + config = PipelineConfig() + module = create_mock_module("test.step") + steps = [Step(name="test", module=module, torchrun=True)] + + commands = generate_pipeline_commands(config, steps) + + assert 'echo "Step: test"' in commands + assert "srun" in commands + assert "test.step" in commands + + def test_multiple_step_piping(self): + """Test command generation for multiple steps with piping.""" + config = PipelineConfig() + module1 = create_mock_module("step1") + module2 = create_mock_module("step2") + steps = [ + Step(name="step1", module=module1, torchrun=True), + Step(name="step2", module=module2, torchrun=True), + ] + + commands = generate_pipeline_commands(config, steps) + + # Should have piping logic + assert "STEP_OUTPUT=" in commands + assert 'echo "$STEP_OUTPUT"' in commands + + def test_extra_args_included(self): + """Test that extra args are included in commands.""" + config = PipelineConfig() + module = create_mock_module("test.step") + steps = [Step(name="test", module=module, torchrun=True)] + + commands = generate_pipeline_commands(config, steps, extra_args=["--batch-size", "64"]) + + assert "--batch-size" in commands + assert "64" in commands + + def test_error_handling_in_script(self): + """Test that error handling is included.""" + config = PipelineConfig() + module = create_mock_module("test.step") + steps = [Step(name="test", module=module)] + + commands = generate_pipeline_commands(config, steps) + + assert "if [ $? -ne 0 ]" in commands + assert "exit 1" in commands diff --git a/tests/kit/test_recipe_loader.py b/tests/kit/test_recipe_loader.py new file mode 100644 index 0000000..a6a53da --- /dev/null +++ b/tests/kit/test_recipe_loader.py @@ -0,0 +1,39 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from omegaconf import OmegaConf + +from nemotron.kit.recipe_loader import extract_recipe_config + + +def test_extract_recipe_config_defaults_when_missing_recipe(): + cfg = OmegaConf.create({"x": 1}) + target, kwargs = extract_recipe_config(cfg, default_target="a.b.c") + assert target == "a.b.c" + assert kwargs == {} + + +def test_extract_recipe_config_reads_target_and_kwargs(): + cfg = OmegaConf.create( + { + "recipe": { + "_target_": "m.n.func", + "alpha": 1, + "beta": "x", + } + } + ) + target, kwargs = extract_recipe_config(cfg, default_target="a.b.c") + assert target == "m.n.func" + assert kwargs == {"alpha": 1, "beta": "x"} diff --git a/tests/kit/test_registry.py b/tests/kit/test_registry.py new file mode 100644 index 0000000..af5b267 --- /dev/null +++ b/tests/kit/test_registry.py @@ -0,0 +1,431 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Tests for nemotron.kit.registry module.""" + +import tempfile +from pathlib import Path + +import pytest + +from nemotron.kit.exceptions import ArtifactNotFoundError, ArtifactVersionNotFoundError +from nemotron.kit.registry import ( + ArtifactEntry, + ArtifactRegistry, + ArtifactVersion, + get_registry, + set_registry, +) + + +class TestArtifactVersion: + """Tests for ArtifactVersion dataclass.""" + + def test_create_version(self): + """Test creating an artifact version.""" + version = ArtifactVersion( + version=1, + path="/data/artifacts/my-artifact/v1", + created_at="2025-01-01T00:00:00+00:00", + metadata={"tokens": 1000}, + ) + assert version.version == 1 + assert version.path == "/data/artifacts/my-artifact/v1" + assert version.created_at == "2025-01-01T00:00:00+00:00" + assert version.metadata == {"tokens": 1000} + + def test_default_metadata(self): + """Test that metadata defaults to empty dict.""" + version = ArtifactVersion( + version=1, + path="/path", + created_at="2025-01-01T00:00:00+00:00", + ) + assert version.metadata == {} + + +class TestArtifactEntry: + """Tests for ArtifactEntry dataclass.""" + + def test_create_entry(self): + """Test creating an artifact entry.""" + entry = ArtifactEntry(name="my-artifact") + assert entry.name == "my-artifact" + assert entry.versions == [] + assert entry.aliases == {} + + def test_latest_version_empty(self): + """Test latest_version with no versions.""" + entry = ArtifactEntry(name="test") + assert entry.latest_version() is None + + def test_latest_version(self): + """Test latest_version returns highest version number.""" + entry = ArtifactEntry( + name="test", + versions=[ + ArtifactVersion(version=1, path="/v1", created_at="2025-01-01"), + ArtifactVersion(version=3, path="/v3", created_at="2025-01-03"), + ArtifactVersion(version=2, path="/v2", created_at="2025-01-02"), + ], + ) + latest = entry.latest_version() + assert latest is not None + assert latest.version == 3 + + def test_get_version_found(self): + """Test get_version returns correct version.""" + entry = ArtifactEntry( + name="test", + versions=[ + ArtifactVersion(version=1, path="/v1", created_at="2025-01-01"), + ArtifactVersion(version=2, path="/v2", created_at="2025-01-02"), + ], + ) + v1 = entry.get_version(1) + assert v1 is not None + assert v1.path == "/v1" + + def test_get_version_not_found(self): + """Test get_version returns None for missing version.""" + entry = ArtifactEntry(name="test") + assert entry.get_version(1) is None + + def test_to_dict(self): + """Test serialization to dict.""" + entry = ArtifactEntry( + name="test", + versions=[ + ArtifactVersion( + version=1, + path="/v1", + created_at="2025-01-01", + metadata={"key": "value"}, + ), + ], + aliases={"latest": 1, "prod": 1}, + ) + data = entry.to_dict() + assert data["name"] == "test" + assert len(data["versions"]) == 1 + assert data["versions"][0]["version"] == 1 + assert data["versions"][0]["metadata"] == {"key": "value"} + assert data["aliases"] == {"latest": 1, "prod": 1} + + def test_from_dict(self): + """Test deserialization from dict.""" + data = { + "name": "test", + "versions": [ + { + "version": 1, + "path": "/v1", + "created_at": "2025-01-01", + "metadata": {"key": "value"}, + }, + ], + "aliases": {"latest": 1}, + } + entry = ArtifactEntry.from_dict(data) + assert entry.name == "test" + assert len(entry.versions) == 1 + assert entry.versions[0].version == 1 + assert entry.versions[0].metadata == {"key": "value"} + assert entry.aliases == {"latest": 1} + + def test_from_dict_missing_metadata(self): + """Test deserialization handles missing metadata.""" + data = { + "name": "test", + "versions": [ + { + "version": 1, + "path": "/v1", + "created_at": "2025-01-01", + # No metadata field + }, + ], + } + entry = ArtifactEntry.from_dict(data) + assert entry.versions[0].metadata == {} + + +class TestArtifactRegistryFsspec: + """Tests for ArtifactRegistry with fsspec backend.""" + + def test_init_creates_root(self): + """Test that init creates root directory.""" + with tempfile.TemporaryDirectory() as tmpdir: + root = Path(tmpdir) / "artifacts" + registry = ArtifactRegistry(backend="fsspec", root=root) + assert root.exists() + assert registry.backend == "fsspec" + + def test_init_fsspec_requires_root(self): + """Test that fsspec backend requires root.""" + with pytest.raises(ValueError, match="root is required"): + ArtifactRegistry(backend="fsspec") + + def test_init_wandb_requires_project(self): + """Test that wandb backend requires project.""" + with pytest.raises(ValueError, match="wandb_project is required"): + ArtifactRegistry(backend="wandb") + + def test_publish_and_resolve(self): + """Test publishing and resolving an artifact.""" + with tempfile.TemporaryDirectory() as tmpdir: + root = Path(tmpdir) / "registry" + source = Path(tmpdir) / "source" + source.mkdir() + (source / "data.txt").write_text("test data") + + registry = ArtifactRegistry(backend="fsspec", root=root) + version = registry.publish("my-artifact", source, metadata={"tokens": 1000}) + + assert version.version == 1 + assert version.metadata == {"tokens": 1000} + + # Resolve should return path to artifact + resolved = registry.resolve("my-artifact") + assert resolved.exists() + assert (resolved / "data.txt").read_text() == "test data" + + def test_publish_increments_version(self): + """Test that publishing increments version number.""" + with tempfile.TemporaryDirectory() as tmpdir: + root = Path(tmpdir) / "registry" + source = Path(tmpdir) / "source" + source.mkdir() + (source / "data.txt").write_text("v1") + + registry = ArtifactRegistry(backend="fsspec", root=root) + + v1 = registry.publish("my-artifact", source) + assert v1.version == 1 + + (source / "data.txt").write_text("v2") + v2 = registry.publish("my-artifact", source) + assert v2.version == 2 + + (source / "data.txt").write_text("v3") + v3 = registry.publish("my-artifact", source) + assert v3.version == 3 + + def test_resolve_specific_version(self): + """Test resolving a specific version.""" + with tempfile.TemporaryDirectory() as tmpdir: + root = Path(tmpdir) / "registry" + source = Path(tmpdir) / "source" + source.mkdir() + + registry = ArtifactRegistry(backend="fsspec", root=root) + + (source / "data.txt").write_text("v1") + registry.publish("my-artifact", source) + + (source / "data.txt").write_text("v2") + registry.publish("my-artifact", source) + + # Resolve version 1 + resolved = registry.resolve("my-artifact", version=1) + assert (resolved / "data.txt").read_text() == "v1" + + # Resolve version 2 + resolved = registry.resolve("my-artifact", version=2) + assert (resolved / "data.txt").read_text() == "v2" + + def test_resolve_latest_alias(self): + """Test resolving 'latest' alias.""" + with tempfile.TemporaryDirectory() as tmpdir: + root = Path(tmpdir) / "registry" + source = Path(tmpdir) / "source" + source.mkdir() + + registry = ArtifactRegistry(backend="fsspec", root=root) + + (source / "data.txt").write_text("v1") + registry.publish("my-artifact", source) + + (source / "data.txt").write_text("v2") + registry.publish("my-artifact", source) + + # Resolve latest (should be v2) + resolved = registry.resolve("my-artifact", version="latest") + assert (resolved / "data.txt").read_text() == "v2" + + def test_resolve_artifact_not_found(self): + """Test that resolving nonexistent artifact raises error.""" + with tempfile.TemporaryDirectory() as tmpdir: + root = Path(tmpdir) / "registry" + registry = ArtifactRegistry(backend="fsspec", root=root) + + with pytest.raises(ArtifactNotFoundError): + registry.resolve("nonexistent") + + def test_resolve_version_not_found(self): + """Test that resolving nonexistent version raises error.""" + with tempfile.TemporaryDirectory() as tmpdir: + root = Path(tmpdir) / "registry" + source = Path(tmpdir) / "source" + source.mkdir() + (source / "data.txt").write_text("test") + + registry = ArtifactRegistry(backend="fsspec", root=root) + registry.publish("my-artifact", source) + + with pytest.raises(ArtifactVersionNotFoundError): + registry.resolve("my-artifact", version=999) + + def test_alias_create_and_resolve(self): + """Test creating and resolving an alias.""" + with tempfile.TemporaryDirectory() as tmpdir: + root = Path(tmpdir) / "registry" + source = Path(tmpdir) / "source" + source.mkdir() + + registry = ArtifactRegistry(backend="fsspec", root=root) + + (source / "data.txt").write_text("v1") + registry.publish("my-artifact", source) + + (source / "data.txt").write_text("v2") + registry.publish("my-artifact", source) + + # Create alias for v1 + registry.alias("my-artifact", "production", 1) + + # Resolve via alias + resolved = registry.resolve("my-artifact", version="production") + assert (resolved / "data.txt").read_text() == "v1" + + def test_alias_artifact_not_found(self): + """Test aliasing nonexistent artifact raises error.""" + with tempfile.TemporaryDirectory() as tmpdir: + root = Path(tmpdir) / "registry" + registry = ArtifactRegistry(backend="fsspec", root=root) + + with pytest.raises(ArtifactNotFoundError): + registry.alias("nonexistent", "prod", 1) + + def test_alias_version_not_found(self): + """Test aliasing nonexistent version raises error.""" + with tempfile.TemporaryDirectory() as tmpdir: + root = Path(tmpdir) / "registry" + source = Path(tmpdir) / "source" + source.mkdir() + (source / "data.txt").write_text("test") + + registry = ArtifactRegistry(backend="fsspec", root=root) + registry.publish("my-artifact", source) + + with pytest.raises(ArtifactVersionNotFoundError): + registry.alias("my-artifact", "prod", 999) + + def test_get_artifact(self): + """Test getting artifact entry.""" + with tempfile.TemporaryDirectory() as tmpdir: + root = Path(tmpdir) / "registry" + source = Path(tmpdir) / "source" + source.mkdir() + (source / "data.txt").write_text("test") + + registry = ArtifactRegistry(backend="fsspec", root=root) + registry.publish("my-artifact", source) + + entry = registry.get("my-artifact") + assert entry is not None + assert entry.name == "my-artifact" + assert len(entry.versions) == 1 + + def test_get_artifact_not_found(self): + """Test getting nonexistent artifact returns None.""" + with tempfile.TemporaryDirectory() as tmpdir: + root = Path(tmpdir) / "registry" + registry = ArtifactRegistry(backend="fsspec", root=root) + + assert registry.get("nonexistent") is None + + def test_list_artifacts(self): + """Test listing all artifacts.""" + with tempfile.TemporaryDirectory() as tmpdir: + root = Path(tmpdir) / "registry" + source = Path(tmpdir) / "source" + source.mkdir() + (source / "data.txt").write_text("test") + + registry = ArtifactRegistry(backend="fsspec", root=root) + registry.publish("artifact-a", source) + registry.publish("artifact-b", source) + registry.publish("artifact-c", source) + + artifacts = registry.list() + assert sorted(artifacts) == ["artifact-a", "artifact-b", "artifact-c"] + + def test_persistence(self): + """Test that registry persists across restarts.""" + with tempfile.TemporaryDirectory() as tmpdir: + root = Path(tmpdir) / "registry" + source = Path(tmpdir) / "source" + source.mkdir() + (source / "data.txt").write_text("test data") + + # First registry instance + registry1 = ArtifactRegistry(backend="fsspec", root=root) + registry1.publish("my-artifact", source, metadata={"key": "value"}) + registry1.alias("my-artifact", "prod", 1) + + # Second registry instance (simulating restart) + registry2 = ArtifactRegistry(backend="fsspec", root=root) + + # Should find the artifact + entry = registry2.get("my-artifact") + assert entry is not None + assert len(entry.versions) == 1 + assert entry.versions[0].metadata == {"key": "value"} + assert entry.aliases["prod"] == 1 + + def test_publish_single_file(self): + """Test publishing a single file instead of directory.""" + with tempfile.TemporaryDirectory() as tmpdir: + root = Path(tmpdir) / "registry" + source_file = Path(tmpdir) / "model.bin" + source_file.write_bytes(b"model data") + + registry = ArtifactRegistry(backend="fsspec", root=root) + version = registry.publish("my-model", source_file) + + resolved = registry.resolve("my-model") + assert (resolved / "model.bin").read_bytes() == b"model data" + + +class TestGlobalRegistry: + """Tests for global registry functions.""" + + def test_get_registry_not_initialized(self): + """Test that get_registry raises when not initialized.""" + set_registry(None) + with pytest.raises(RuntimeError, match="not initialized"): + get_registry() + + def test_set_and_get_registry(self): + """Test setting and getting global registry.""" + with tempfile.TemporaryDirectory() as tmpdir: + root = Path(tmpdir) / "registry" + registry = ArtifactRegistry(backend="fsspec", root=root) + + set_registry(registry) + assert get_registry() is registry + + # Cleanup + set_registry(None) diff --git a/tests/kit/test_resolvers_pre_init.py b/tests/kit/test_resolvers_pre_init.py new file mode 100644 index 0000000..74f5945 --- /dev/null +++ b/tests/kit/test_resolvers_pre_init.py @@ -0,0 +1,135 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import sys +import types + +from omegaconf import OmegaConf + +from nemotron.kit import resolvers + + +class TestGetJobId: + """Tests for _get_job_id() function.""" + + def test_uses_slurm_job_id_when_available(self, monkeypatch): + """Should use SLURM_JOB_ID environment variable when available.""" + monkeypatch.setenv("SLURM_JOB_ID", "12345") + job_id = resolvers._get_job_id() + assert job_id == "slurm_12345" + + def test_uses_torchelastic_run_id_when_available(self, monkeypatch): + """Should use TORCHELASTIC_RUN_ID when SLURM_JOB_ID is not available.""" + monkeypatch.delenv("SLURM_JOB_ID", raising=False) + monkeypatch.setenv("TORCHELASTIC_RUN_ID", "abc123") + job_id = resolvers._get_job_id() + assert "abc123" in job_id + + def test_fallback_to_hostname_and_ppid(self, monkeypatch): + """Should fall back to hostname and parent PID.""" + monkeypatch.delenv("SLURM_JOB_ID", raising=False) + monkeypatch.delenv("TORCHELASTIC_RUN_ID", raising=False) + job_id = resolvers._get_job_id() + # Should contain hostname and some numeric ID + assert "_" in job_id + + +class TestMarkerPathUniqueness: + """Tests for marker file path uniqueness across jobs.""" + + def test_different_slurm_jobs_get_different_marker_paths(self, monkeypatch, tmp_path): + """Different SLURM_JOB_IDs should result in different marker paths.""" + monkeypatch.setenv("NEMO_RUN_DIR", str(tmp_path)) + artifacts = {"data": "TestArtifact:latest"} + + monkeypatch.setenv("SLURM_JOB_ID", "job_1") + path1 = resolvers._get_marker_path(artifacts) + + monkeypatch.setenv("SLURM_JOB_ID", "job_2") + path2 = resolvers._get_marker_path(artifacts) + + assert path1 != path2 + assert "job_1" in str(path1) + assert "job_2" in str(path2) + + def test_same_job_same_artifacts_get_same_marker_path(self, monkeypatch, tmp_path): + """Same job ID and artifacts should produce the same marker path.""" + monkeypatch.setenv("NEMO_RUN_DIR", str(tmp_path)) + monkeypatch.setenv("SLURM_JOB_ID", "job_1") + artifacts = {"data": "TestArtifact:latest"} + + path1 = resolvers._get_marker_path(artifacts) + path2 = resolvers._get_marker_path(artifacts) + + assert path1 == path2 + + def test_different_artifacts_get_different_marker_paths(self, monkeypatch, tmp_path): + """Different artifact configs should produce different marker paths.""" + monkeypatch.setenv("NEMO_RUN_DIR", str(tmp_path)) + monkeypatch.setenv("SLURM_JOB_ID", "job_1") + + path1 = resolvers._get_marker_path({"data": "ArtifactA:latest"}) + path2 = resolvers._get_marker_path({"data": "ArtifactB:latest"}) + + assert path1 != path2 + + +def test_register_resolvers_from_config_pre_init(monkeypatch, tmp_path): + resolvers.clear_artifact_cache() + + monkeypatch.setenv("WANDB_ENTITY", "ent") + monkeypatch.setenv("WANDB_PROJECT", "proj") + + downloaded_dir = tmp_path / "artifact" + downloaded_dir.mkdir() + + class FakeArtifact: + def __init__(self, ref: str): + self.qualified_name = ref + self.version = "v5" + self.name = "DataBlendsArtifact-pretrain" + self.type = "dataset" + + def download(self, skip_cache: bool = True): + return str(downloaded_dir) + + class FakeApi: + def __init__(self): + self.last_ref = None + + def artifact(self, ref: str): + self.last_ref = ref + return FakeArtifact(ref) + + fake_api = FakeApi() + + class FakeWandb(types.SimpleNamespace): + def Api(self): # noqa: N802 + return fake_api + + monkeypatch.setitem(sys.modules, "wandb", FakeWandb()) + + cfg = OmegaConf.create( + { + "run": {"data": "DataBlendsArtifact-pretrain:v5"}, + "recipe": {"per_split_data_args_path": "${art:data,path}"}, + } + ) + + qualified_names = resolvers.register_resolvers_from_config(cfg, mode="pre_init") + assert qualified_names == ["ent/proj/DataBlendsArtifact-pretrain:v5"] + assert fake_api.last_ref == "ent/proj/DataBlendsArtifact-pretrain:v5" + + resolved = OmegaConf.to_container(cfg, resolve=True) + assert resolved["recipe"]["per_split_data_args_path"] == str(downloaded_dir) diff --git a/tests/kit/test_self_contained_packager.py b/tests/kit/test_self_contained_packager.py new file mode 100644 index 0000000..99c5037 --- /dev/null +++ b/tests/kit/test_self_contained_packager.py @@ -0,0 +1,238 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import contextlib +import os +import subprocess +import tarfile +from unittest.mock import patch + +import pytest + + +def test_self_contained_packager_produces_flat_tar(tmp_path): + pytest.importorskip("nemo_run") + + from nemotron.kit.packaging.self_contained_packager import SelfContainedPackager + + repo_root = tmp_path / "repo" + (repo_root / "src" / "nemotron").mkdir(parents=True) + (repo_root / "src" / "nemotron" / "x.py").write_text( + "def fx():\n return 1\n", + encoding="utf-8", + ) + + script_path = repo_root / "train.py" + script_path.write_text( + "from nemotron.x import fx\n\nprint(fx())\n", + encoding="utf-8", + ) + + train_cfg = tmp_path / "train.yaml" + train_cfg.write_text("a: 1\n", encoding="utf-8") + + out_dir = tmp_path / "out" + out_dir.mkdir() + + class MockContext: + @contextlib.contextmanager + def cd(self, path): + old = os.getcwd() + os.chdir(path) + try: + yield + finally: + os.chdir(old) + + def run(self, cmd: str, **kwargs): + subprocess.check_call(cmd, shell=True) + + with patch("nemo_run.core.packaging.pattern.Context", MockContext): + packager = SelfContainedPackager( + script_path=str(script_path.relative_to(repo_root)), + train_path=str(train_cfg), + ) + tar_path = packager.package(repo_root, str(out_dir), "pkg") + + with tarfile.open(tar_path, "r:gz") as tf: + names = sorted(tf.getnames()) + assert names == ["config.yaml", "main.py"] + main_src = tf.extractfile("main.py").read().decode("utf-8") + assert "from nemotron" not in main_src + + +def test_self_contained_packager_inlines_nested_imports(tmp_path): + """Verify that imports inside functions are also inlined.""" + pytest.importorskip("nemo_run") + + from nemotron.kit.packaging.self_contained_packager import SelfContainedPackager + + repo_root = tmp_path / "repo" + (repo_root / "src" / "nemotron").mkdir(parents=True) + (repo_root / "src" / "nemotron" / "x.py").write_text( + "def fx():\n return 1\n", + encoding="utf-8", + ) + (repo_root / "src" / "nemotron" / "y.py").write_text( + "def fy():\n return 2\n", + encoding="utf-8", + ) + + # Script with import inside a function (like stage2_rl/train.py) + script_path = repo_root / "train.py" + script_path.write_text( + """\ +from nemotron.x import fx + +def main(): + from nemotron.y import fy + print(fx(), fy()) + +if __name__ == "__main__": + main() +""", + encoding="utf-8", + ) + + train_cfg = tmp_path / "train.yaml" + train_cfg.write_text("a: 1\n", encoding="utf-8") + + out_dir = tmp_path / "out" + out_dir.mkdir() + + class MockContext: + @contextlib.contextmanager + def cd(self, path): + old = os.getcwd() + os.chdir(path) + try: + yield + finally: + os.chdir(old) + + def run(self, cmd: str, **kwargs): + subprocess.check_call(cmd, shell=True) + + with patch("nemo_run.core.packaging.pattern.Context", MockContext): + packager = SelfContainedPackager( + script_path=str(script_path.relative_to(repo_root)), + train_path=str(train_cfg), + ) + tar_path = packager.package(repo_root, str(out_dir), "pkg") + + with tarfile.open(tar_path, "r:gz") as tf: + names = sorted(tf.getnames()) + assert names == ["config.yaml", "main.py"] + main_src = tf.extractfile("main.py").read().decode("utf-8") + # Verify no nemotron imports remain (including nested ones) + assert "from nemotron" not in main_src + assert "import nemotron" not in main_src + # Verify the inlined code is present + assert "def fx():" in main_src + assert "def fy():" in main_src + # Verify the main function still exists + assert "def main():" in main_src + + +def test_self_contained_packager_ignores_importlib_imports(tmp_path): + """Verify that importlib.import_module calls are not detected as nemotron imports. + + This ensures the workaround in kit/wandb.py (using importlib instead of direct import) + successfully prevents pydantic from being pulled into the RL training package. + """ + pytest.importorskip("nemo_run") + + from nemotron.kit.packaging.self_contained_packager import SelfContainedPackager + + repo_root = tmp_path / "repo" + (repo_root / "src" / "nemotron" / "kit").mkdir(parents=True) + + # Create a module that would pull in pydantic (simulating kit/__init__.py) + (repo_root / "src" / "nemotron" / "kit" / "__init__.py").write_text( + """\ +from pydantic import BaseModel # This would fail in nemo-rl container + +def init(): + pass +""", + encoding="utf-8", + ) + + # Create a module that uses importlib to import kit (like wandb.py does) + (repo_root / "src" / "nemotron" / "wandb.py").write_text( + """\ +def patch_something(): + return "patched" + +def init_wandb_if_configured(): + # Use importlib to avoid SelfContainedPackager detection + import importlib + kit = importlib.import_module("nemotron.kit") + kit.init() +""", + encoding="utf-8", + ) + + # Script that only imports the patch function (like RL train.py) + script_path = repo_root / "train.py" + script_path.write_text( + """\ +from nemotron.wandb import patch_something + +def main(): + print(patch_something()) + +if __name__ == "__main__": + main() +""", + encoding="utf-8", + ) + + train_cfg = tmp_path / "train.yaml" + train_cfg.write_text("a: 1\n", encoding="utf-8") + + out_dir = tmp_path / "out" + out_dir.mkdir() + + class MockContext: + @contextlib.contextmanager + def cd(self, path): + old = os.getcwd() + os.chdir(path) + try: + yield + finally: + os.chdir(old) + + def run(self, cmd: str, **kwargs): + subprocess.check_call(cmd, shell=True) + + with patch("nemo_run.core.packaging.pattern.Context", MockContext): + packager = SelfContainedPackager( + script_path=str(script_path.relative_to(repo_root)), + train_path=str(train_cfg), + ) + tar_path = packager.package(repo_root, str(out_dir), "pkg") + + with tarfile.open(tar_path, "r:gz") as tf: + main_src = tf.extractfile("main.py").read().decode("utf-8") + # Key assertion: pydantic should NOT be imported because importlib.import_module + # is not detected as a nemotron import by the AST-based packager + assert "from pydantic" not in main_src + assert "import pydantic" not in main_src + # The patch function should be inlined + assert "def patch_something():" in main_src + # The init_wandb_if_configured should also be inlined (it's in the same module) + # but it uses importlib which doesn't trigger transitive inlining + assert "importlib.import_module" in main_src diff --git a/tests/kit/test_step.py b/tests/kit/test_step.py new file mode 100644 index 0000000..dce7e06 --- /dev/null +++ b/tests/kit/test_step.py @@ -0,0 +1,169 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Tests for nemotron.kit.step (Step class).""" + +import sys +from types import ModuleType + +from nemotron.kit import Step + + +def create_mock_module(name: str, file_path: str | None = None) -> ModuleType: + """Create a mock module for testing.""" + module = ModuleType(name) + module.__name__ = name + module.__file__ = file_path + return module + + +class TestStep: + """Tests for Step dataclass.""" + + def test_step_creation(self): + """Test basic Step creation.""" + module = create_mock_module("test.module", "/path/to/module.py") + step = Step(name="test_step", module=module) + + assert step.name == "test_step" + assert step.module == module + assert step.torchrun is False # default + + def test_step_with_torchrun(self): + """Test Step with torchrun=True.""" + module = create_mock_module("train.module", "/path/to/train.py") + step = Step(name="training", module=module, torchrun=True) + + assert step.name == "training" + assert step.torchrun is True + + def test_module_name(self): + """Test module_name property.""" + module = create_mock_module("nemotron.recipes.nano3.data_prep") + step = Step(name="data_prep", module=module) + + assert step.module_name == "nemotron.recipes.nano3.data_prep" + + def test_module_file(self): + """Test module_file property.""" + module = create_mock_module("test.module", "/path/to/test/module.py") + step = Step(name="test", module=module) + + assert step.module_file == "/path/to/test/module.py" + + def test_module_file_none(self): + """Test module_file when __file__ is None.""" + module = create_mock_module("builtin.module", None) + step = Step(name="builtin", module=module) + + assert step.module_file is None + + def test_get_command_python(self): + """Test get_command for non-torchrun step.""" + module = create_mock_module("my.data_prep") + step = Step(name="data_prep", module=module, torchrun=False) + + cmd = step.get_command() + + assert cmd == [sys.executable, "-m", "my.data_prep"] + + def test_get_command_torchrun(self): + """Test get_command for torchrun step.""" + module = create_mock_module("my.training") + step = Step(name="training", module=module, torchrun=True) + + cmd = step.get_command(nproc_per_node=8) + + assert cmd == [ + "torchrun", + "--nproc_per_node=8", + "-m", + "my.training", + ] + + def test_get_command_custom_nproc(self): + """Test get_command with custom nproc_per_node.""" + module = create_mock_module("my.training") + step = Step(name="training", module=module, torchrun=True) + + cmd = step.get_command(nproc_per_node=4) + + assert "--nproc_per_node=4" in cmd + + def test_get_srun_command_basic(self): + """Test get_srun_command without container.""" + module = create_mock_module("my.training") + step = Step(name="training", module=module, torchrun=True) + + cmd = step.get_srun_command(nproc_per_node=8) + + assert "srun" in cmd + assert "--mpi=pmix" in cmd + assert "torchrun" in cmd + assert "--nproc_per_node=$SLURM_GPUS_PER_NODE" in cmd + assert "-m" in cmd + assert "my.training" in cmd + + def test_get_srun_command_with_container(self): + """Test get_srun_command with container image.""" + module = create_mock_module("my.training") + step = Step(name="training", module=module, torchrun=True) + + cmd = step.get_srun_command( + nproc_per_node=8, + container_image="/path/to/container.sqsh", + mounts=["/data:/data", "/scratch:/scratch"], + ) + + assert "--container-image=/path/to/container.sqsh" in cmd + assert "--container-mounts=/data:/data" in cmd + assert "--container-mounts=/scratch:/scratch" in cmd + + def test_get_srun_command_returns_string(self): + """Test that get_srun_command returns a string (for shell).""" + module = create_mock_module("my.training") + step = Step(name="training", module=module, torchrun=True) + + cmd = step.get_srun_command() + + assert isinstance(cmd, str) + assert " " in cmd # Multiple parts joined + + +class TestStepEquality: + """Tests for Step equality and hashing.""" + + def test_steps_equal(self): + """Test that identical steps are equal.""" + module = create_mock_module("test.module") + step1 = Step(name="test", module=module, torchrun=True) + step2 = Step(name="test", module=module, torchrun=True) + + assert step1 == step2 + + def test_steps_not_equal_name(self): + """Test that steps with different names are not equal.""" + module = create_mock_module("test.module") + step1 = Step(name="test1", module=module) + step2 = Step(name="test2", module=module) + + assert step1 != step2 + + def test_steps_not_equal_torchrun(self): + """Test that steps with different torchrun are not equal.""" + module = create_mock_module("test.module") + step1 = Step(name="test", module=module, torchrun=True) + step2 = Step(name="test", module=module, torchrun=False) + + assert step1 != step2 diff --git a/tests/kit/test_wandb_patch.py b/tests/kit/test_wandb_patch.py new file mode 100644 index 0000000..ea56325 --- /dev/null +++ b/tests/kit/test_wandb_patch.py @@ -0,0 +1,51 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import importlib +import sys +import types + + +def test_patch_wandb_init_for_lineage_registers_artifacts_and_tags(monkeypatch): + import nemotron.kit.wandb as wb + + wb = importlib.reload(wb) + + used: list[str] = [] + + class FakeRun: + def __init__(self): + self.tags = [] + + def use_artifact(self, qname: str): + used.append(qname) + + fake_run = FakeRun() + + def fake_init(*args, **kwargs): + fake_wandb.run = fake_run + return fake_run + + fake_wandb = types.SimpleNamespace(run=None, init=fake_init) + monkeypatch.setitem(sys.modules, "wandb", fake_wandb) + + wb.patch_wandb_init_for_lineage( + artifact_qualified_names=["ent/proj/DataBlendsArtifact-pretrain:v5"], + tags=["pretrain"], + ) + + fake_wandb.init() + + assert used == ["ent/proj/DataBlendsArtifact-pretrain:v5"] + assert "pretrain" in fake_run.tags diff --git a/tests/recipes/__init__.py b/tests/recipes/__init__.py new file mode 100644 index 0000000..dcc36c6 --- /dev/null +++ b/tests/recipes/__init__.py @@ -0,0 +1,15 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Tests for nemotron recipes.""" diff --git a/tests/recipes/nano3/__init__.py b/tests/recipes/nano3/__init__.py new file mode 100644 index 0000000..b11a00b --- /dev/null +++ b/tests/recipes/nano3/__init__.py @@ -0,0 +1,15 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Tests for nano3 recipes.""" diff --git a/tests/recipes/nano3/stage0_pretrain/__init__.py b/tests/recipes/nano3/stage0_pretrain/__init__.py new file mode 100644 index 0000000..a360c7b --- /dev/null +++ b/tests/recipes/nano3/stage0_pretrain/__init__.py @@ -0,0 +1,15 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Tests for nano3 stage0_pretrain recipes.""" diff --git a/tests/recipes/nano3/stage0_pretrain/test_data_prep_train_integration.py b/tests/recipes/nano3/stage0_pretrain/test_data_prep_train_integration.py new file mode 100644 index 0000000..d25c95f --- /dev/null +++ b/tests/recipes/nano3/stage0_pretrain/test_data_prep_train_integration.py @@ -0,0 +1,675 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +""" +Tests for data_prep.py → train.py integration in nano3/stage0_pretrain. + +These contract tests validate that: +1. The blend.json output format from data_prep.py matches what train.py expects +2. W&B artifact production and consumption works correctly +3. The ${art:data,path} resolver correctly resolves artifact paths +""" + +import importlib +import json +import os +import re +import sys +import tempfile +import types +from pathlib import Path + +import pytest +from omegaconf import OmegaConf + +from nemotron.data_prep.filesystem import get_filesystem +from nemotron.data_prep.pipeline import _distribute_shards_to_splits +from nemotron.kit import PretrainBlendsArtifact + + +class TestNano3DataPrepTrainIntegration: + """Test integration between data_prep.py output and train.py consumption.""" + + def test_distribute_shards_produces_valid_per_split_format(self): + """Test _distribute_shards_to_splits produces correct format.""" + data_paths = ["1.0", "/path/to/shard", "0.5", "/path/to/other"] + + result = _distribute_shards_to_splits( + data_paths=data_paths, + num_shards=4, + valid_shards=1, + test_shards=1, + ) + + assert "train" in result + assert "valid" in result + assert "test" in result + + # Each split should have alternating weight/path pairs + for split_name, split_data in result.items(): + assert len(split_data) % 2 == 0, f"Split {split_name} has odd number of elements" + for i in range(0, len(split_data), 2): + # Weight should be parseable as float + float(split_data[i]) + # Path should be a string + assert isinstance(split_data[i + 1], str) + + def test_distribute_shards_respects_shard_counts(self): + """Test that valid_shards and test_shards control split sizes.""" + data_paths = ["1.0", "/path/to/shard"] + + result = _distribute_shards_to_splits( + data_paths=data_paths, + num_shards=10, + valid_shards=2, + test_shards=3, + ) + + # valid should have 2 shards (4 elements: weight, path, weight, path) + assert len(result["valid"]) == 4 + # test should have 3 shards (6 elements) + assert len(result["test"]) == 6 + # train should have remaining 5 shards (10 elements) + assert len(result["train"]) == 10 + + def test_blend_json_format_matches_train_expectation(self): + """Test blend.json format is compatible with train.py config.""" + with tempfile.TemporaryDirectory() as tmpdir: + blend_path = Path(tmpdir) / "blend.json" + + # Simulate data_prep output + blend_data = { + "train": ["1.0", f"{tmpdir}/shard_000000", "1.0", f"{tmpdir}/shard_000001"], + "valid": ["1.0", f"{tmpdir}/shard_000002"], + "test": ["1.0", f"{tmpdir}/shard_000003"], + } + + with open(blend_path, "w") as f: + json.dump(blend_data, f) + + # Simulate train.py loading + with open(blend_path) as f: + loaded = json.load(f) + + assert loaded == blend_data + assert set(loaded.keys()) == {"train", "valid", "test"} + + def test_blend_json_compatible_with_megatron_bridge_parsing(self): + """Test blend.json is compatible with Megatron-Bridge's get_blend_and_blend_per_split. + + This test simulates exactly how Megatron-Bridge parses per_split_data_args_path. + See: megatron/bridge/data/loaders.py lines 76-89 + """ + with tempfile.TemporaryDirectory() as tmpdir: + blend_path = Path(tmpdir) / "blend.json" + + # Simulate data_prep output with string weights (as produced by data_prep) + blend_data = { + "train": ["1.0", f"{tmpdir}/shard_000000", "1.0", f"{tmpdir}/shard_000001"], + "valid": ["1.0", f"{tmpdir}/shard_000002"], + "test": ["1.0", f"{tmpdir}/shard_000003"], + } + + with open(blend_path, "w") as f: + json.dump(blend_data, f) + + # Simulate Megatron-Bridge loading (exact code from loaders.py:76-89) + with open(blend_path) as f: + per_split_data_args = json.load(f) + # Each element in blend_per_split should be a list of files (and optional + # weights), so split string if needed. + for split in ["train", "valid", "test"]: + if isinstance(per_split_data_args[split], str): + per_split_data_args[split] = per_split_data_args[split].split() + + # Verify the parsed data matches what Megatron-Bridge expects + assert per_split_data_args["train"] == [ + "1.0", + f"{tmpdir}/shard_000000", + "1.0", + f"{tmpdir}/shard_000001", + ] + assert per_split_data_args["valid"] == ["1.0", f"{tmpdir}/shard_000002"] + assert per_split_data_args["test"] == ["1.0", f"{tmpdir}/shard_000003"] + + # Verify the lists are not empty (this is the error we're debugging) + for split in ["train", "valid", "test"]: + assert len(per_split_data_args[split]) > 0, f"{split} is empty!" + assert len(per_split_data_args[split]) % 2 == 0, f"{split} has odd length" + + def test_pretrain_blends_artifact_with_blend_path(self): + """Test PretrainBlendsArtifact stores blend_path correctly.""" + with tempfile.TemporaryDirectory() as tmpdir: + tmpdir = Path(tmpdir) + blend_path = tmpdir / "blend.json" + blend_path.write_text('{"train": [], "valid": [], "test": []}') + + artifact = PretrainBlendsArtifact( + path=tmpdir, + blend_path=str(blend_path), + total_tokens=1000, + total_sequences=100, + num_shards=4, + elapsed_sec=0.0, + ) + + assert artifact.blend_path == str(blend_path) + artifact.save() + + loaded = PretrainBlendsArtifact.load(path=tmpdir) + assert loaded.blend_path == str(blend_path) + + def test_shard_path_naming_convention(self): + """Test that shard paths follow the expected naming convention.""" + data_paths = ["1.0", "/output/shard"] + + result = _distribute_shards_to_splits( + data_paths=data_paths, + num_shards=10, + valid_shards=1, + test_shards=1, + ) + + # All paths should have _XXXXXX suffix (6 digits) + pattern = re.compile(r".*_\d{6}$") + + for split_name, split_data in result.items(): + for i in range(1, len(split_data), 2): # Every other item is a path + assert pattern.match(split_data[i]), ( + f"Path {split_data[i]} in {split_name} doesn't match naming convention" + ) + + def test_distribute_shards_deterministic_with_seed(self): + """Test that shard distribution is deterministic with same seed.""" + data_paths = ["1.0", "/path/to/shard"] + + result1 = _distribute_shards_to_splits( + data_paths=data_paths, + num_shards=10, + valid_shards=2, + test_shards=2, + seed=42, + ) + + result2 = _distribute_shards_to_splits( + data_paths=data_paths, + num_shards=10, + valid_shards=2, + test_shards=2, + seed=42, + ) + + assert result1 == result2 + + def test_distribute_shards_different_with_different_seed(self): + """Test that different seeds produce different distributions.""" + data_paths = ["1.0", "/path/to/shard"] + + result1 = _distribute_shards_to_splits( + data_paths=data_paths, + num_shards=10, + valid_shards=2, + test_shards=2, + seed=42, + ) + + result2 = _distribute_shards_to_splits( + data_paths=data_paths, + num_shards=10, + valid_shards=2, + test_shards=2, + seed=123, + ) + + # At least one split should be different + assert result1 != result2 + + +class TestWandbArtifactIntegration: + """Test W&B artifact production and consumption for nano3 pretrain.""" + + def test_full_artifact_consumption_with_megatron_bridge_parsing(self, monkeypatch, tmp_path): + """Test the complete consumption flow: OmegaConf resolver -> file read -> MB parsing. + + This test simulates exactly what happens in training: + 1. OmegaConf resolves ${art:data,path}/blend.json to a local path + 2. Megatron-Bridge opens and parses the blend.json + 3. get_blend_from_list() processes train/valid/test arrays + + This is the key integration test for the data_prep -> train contract. + """ + from nemotron.kit import resolvers + + resolvers.clear_artifact_cache() + + monkeypatch.setenv("WANDB_ENTITY", "ent") + monkeypatch.setenv("WANDB_PROJECT", "proj") + + # Create a realistic blend.json with actual data (simulating data_prep output) + downloaded_dir = tmp_path / "artifact" + downloaded_dir.mkdir() + blend_json = downloaded_dir / "blend.json" + + # Realistic blend.json content as produced by data_prep + blend_data = { + "train": [ + "1.0", + "/lustre/data/shard_000000", + "1.0", + "/lustre/data/shard_000001", + "1.0", + "/lustre/data/shard_000002", + ], + "valid": ["1.0", "/lustre/data/shard_000003"], + "test": ["1.0", "/lustre/data/shard_000004"], + } + blend_json.write_text(json.dumps(blend_data)) + + class FakeArtifact: + def __init__(self, ref): + self.qualified_name = ref + self.version = "v5" + self.name = "TestBlendsArtifact" + self.type = "dataset" + + def download(self, skip_cache=True): + return str(downloaded_dir) + + class FakeApi: + def artifact(self, ref): + return FakeArtifact(ref) + + fake_wandb = types.SimpleNamespace(Api=lambda: FakeApi()) + monkeypatch.setitem(sys.modules, "wandb", fake_wandb) + + # Step 1: Config pattern matching train.py default.yaml + cfg = OmegaConf.create( + { + "run": {"data": "TestBlendsArtifact:latest"}, + "recipe": {"per_split_data_args_path": "${art:data,path}/blend.json"}, + } + ) + + # Step 2: Register resolvers (as train.py does) + resolvers.register_resolvers_from_config(cfg, mode="pre_init") + + # Step 3: Resolve config (as train.py does before calling recipe) + resolved = OmegaConf.to_container(cfg, resolve=True) + per_split_data_args_path = resolved["recipe"]["per_split_data_args_path"] + + # Verify path resolution + assert per_split_data_args_path == str(downloaded_dir / "blend.json") + assert Path(per_split_data_args_path).exists(), ( + f"blend.json not found at {per_split_data_args_path}" + ) + + # Step 4: Simulate Megatron-Bridge loading (exact code from loaders.py:76-89) + with open(per_split_data_args_path) as f: + per_split_data_args = json.load(f) + # Each element in blend_per_split should be a list of files (and optional + # weights), so split string if needed. + for split in ["train", "valid", "test"]: + if isinstance(per_split_data_args[split], str): + per_split_data_args[split] = per_split_data_args[split].split() + + # Step 5: Verify the data is NOT empty (this is the bug we're catching) + assert len(per_split_data_args["train"]) > 0, "train split is empty!" + assert len(per_split_data_args["valid"]) > 0, "valid split is empty!" + assert len(per_split_data_args["test"]) > 0, "test split is empty!" + + # Step 6: Verify format matches what get_blend_from_list expects + # Even-length list: [weight, path, weight, path, ...] + assert len(per_split_data_args["train"]) % 2 == 0, "train has odd length" + assert len(per_split_data_args["valid"]) % 2 == 0, "valid has odd length" + assert len(per_split_data_args["test"]) % 2 == 0, "test has odd length" + + # Verify the actual content matches what we put in + assert per_split_data_args["train"] == blend_data["train"] + assert per_split_data_args["valid"] == blend_data["valid"] + assert per_split_data_args["test"] == blend_data["test"] + + def test_artifact_without_blend_json_should_fail_gracefully(self, monkeypatch, tmp_path): + """Test that missing blend.json is detected early with clear error.""" + from nemotron.kit import resolvers + + resolvers.clear_artifact_cache() + + monkeypatch.setenv("WANDB_ENTITY", "ent") + monkeypatch.setenv("WANDB_PROJECT", "proj") + + # Create artifact directory WITHOUT blend.json + downloaded_dir = tmp_path / "artifact" + downloaded_dir.mkdir() + # Only metadata.json, no blend.json + (downloaded_dir / "metadata.json").write_text("{}") + + class FakeArtifact: + def __init__(self, ref): + self.qualified_name = ref + self.version = "v5" + self.name = "TestBlendsArtifact" + self.type = "dataset" + + def download(self, skip_cache=True): + return str(downloaded_dir) + + class FakeApi: + def artifact(self, ref): + return FakeArtifact(ref) + + fake_wandb = types.SimpleNamespace(Api=lambda: FakeApi()) + monkeypatch.setitem(sys.modules, "wandb", fake_wandb) + + cfg = OmegaConf.create( + { + "run": {"data": "TestBlendsArtifact:latest"}, + "recipe": {"per_split_data_args_path": "${art:data,path}/blend.json"}, + } + ) + + resolvers.register_resolvers_from_config(cfg, mode="pre_init") + resolved = OmegaConf.to_container(cfg, resolve=True) + per_split_data_args_path = resolved["recipe"]["per_split_data_args_path"] + + # The path resolves but file doesn't exist + assert not Path(per_split_data_args_path).exists() + + def test_wandb_artifact_resolution_for_train(self, monkeypatch, tmp_path): + """Test ${art:data,path} resolver works with train.py config pattern.""" + from nemotron.kit import resolvers + + resolvers.clear_artifact_cache() + + monkeypatch.setenv("WANDB_ENTITY", "ent") + monkeypatch.setenv("WANDB_PROJECT", "proj") + + # Simulate downloaded artifact directory with blend.json + downloaded_dir = tmp_path / "artifact" + downloaded_dir.mkdir() + blend_json = downloaded_dir / "blend.json" + blend_json.write_text('{"train": [], "valid": [], "test": []}') + + class FakeArtifact: + def __init__(self, ref): + self.qualified_name = ref + self.version = "v5" + self.name = "TestBlendsArtifact" + self.type = "dataset" + + def download(self, skip_cache=True): + return str(downloaded_dir) + + class FakeApi: + def artifact(self, ref): + return FakeArtifact(ref) + + fake_wandb = types.SimpleNamespace(Api=lambda: FakeApi()) + monkeypatch.setitem(sys.modules, "wandb", fake_wandb) + + # Config pattern matching train.py test.yaml + cfg = OmegaConf.create( + { + "run": {"data": "TestBlendsArtifact:latest"}, + "recipe": {"per_split_data_args_path": "${art:data,path}/blend.json"}, + } + ) + + qualified_names = resolvers.register_resolvers_from_config(cfg, mode="pre_init") + + resolved = OmegaConf.to_container(cfg, resolve=True) + assert resolved["recipe"]["per_split_data_args_path"] == str(downloaded_dir / "blend.json") + assert "ent/proj/TestBlendsArtifact:latest" in qualified_names[0] + + def test_wandb_lineage_registration(self, monkeypatch): + """Test that train.py pattern correctly registers lineage.""" + import nemotron.kit.wandb as wb + + wb = importlib.reload(wb) + + used_artifacts = [] + + class FakeRun: + def __init__(self): + self.tags = [] + + def use_artifact(self, qname): + used_artifacts.append(qname) + + fake_run = FakeRun() + + def fake_init(*args, **kwargs): + fake_wandb.run = fake_run + return fake_run + + fake_wandb = types.SimpleNamespace(run=None, init=fake_init) + monkeypatch.setitem(sys.modules, "wandb", fake_wandb) + + # Pattern from train.py + wb.patch_wandb_init_for_lineage( + artifact_qualified_names=["ent/proj/TestBlendsArtifact:v5"], + tags=["pretrain"], + ) + + fake_wandb.init() + + assert "ent/proj/TestBlendsArtifact:v5" in used_artifacts + assert "pretrain" in fake_run.tags + + def test_artifact_metadata_contains_required_fields(self): + """Test PretrainBlendsArtifact metadata has fields needed by train.py.""" + with tempfile.TemporaryDirectory() as tmpdir: + tmpdir = Path(tmpdir) + blend_path = tmpdir / "blend.json" + blend_path.write_text('{"train": [], "valid": [], "test": []}') + + artifact = PretrainBlendsArtifact( + path=tmpdir, + blend_path=str(blend_path), + total_tokens=1_000_000, + total_sequences=10_000, + num_shards=128, + elapsed_sec=120.0, + ) + artifact.save() + + # Load and verify metadata has required fields + metadata_path = tmpdir / "metadata.json" + with open(metadata_path) as f: + metadata = json.load(f) + + # Required for train.py consumption + assert "path" in metadata + assert "type" in metadata + assert metadata["type"] == "PretrainBlendsArtifact" + assert "blend_path" in metadata + assert metadata["blend_path"] == str(blend_path) + assert "total_tokens" in metadata + assert "num_shards" in metadata + + def test_artifact_roundtrip_preserves_all_fields(self): + """Test that artifact save/load preserves all fields correctly.""" + with tempfile.TemporaryDirectory() as tmpdir: + tmpdir = Path(tmpdir) + blend_path = tmpdir / "blend.json" + blend_path.write_text('{"train": [], "valid": [], "test": []}') + + original = PretrainBlendsArtifact( + path=tmpdir, + blend_path=str(blend_path), + total_tokens=1_000_000, + total_sequences=10_000, + num_shards=128, + elapsed_sec=120.5, + train_tokens=900_000, + valid_tokens=50_000, + test_tokens=50_000, + source_datasets=["hf://nvidia/dataset1", "hf://nvidia/dataset2"], + tokenizer_uri="https://huggingface.co/nvidia/NVIDIA-Nemotron-Nano-9B-v2", + ) + original.save() + + loaded = PretrainBlendsArtifact.load(path=tmpdir) + + assert loaded.total_tokens == original.total_tokens + assert loaded.total_sequences == original.total_sequences + assert loaded.num_shards == original.num_shards + assert loaded.blend_path == original.blend_path + assert loaded.train_tokens == original.train_tokens + assert loaded.valid_tokens == original.valid_tokens + assert loaded.test_tokens == original.test_tokens + assert loaded.tokenizer_uri == original.tokenizer_uri + + def test_artifact_stores_tokenizer_uri_for_compatibility_check(self): + """Test that artifact stores tokenizer_uri so train.py can verify compatibility. + + The tokenizer used for data preparation MUST match the tokenizer used for training. + The artifact stores tokenizer_uri to enable this verification. + """ + with tempfile.TemporaryDirectory() as tmpdir: + tmpdir = Path(tmpdir) + blend_path = tmpdir / "blend.json" + blend_path.write_text('{"train": [], "valid": [], "test": []}') + + tokenizer_model = "nvidia/NVIDIA-Nemotron-Nano-9B-v2" + tokenizer_uri = f"https://huggingface.co/{tokenizer_model}" + + artifact = PretrainBlendsArtifact( + path=tmpdir, + blend_path=str(blend_path), + total_tokens=1_000_000, + total_sequences=10_000, + num_shards=128, + elapsed_sec=120.0, + tokenizer_uri=tokenizer_uri, + ) + artifact.save() + + # Verify tokenizer_uri is in metadata for train.py to check + metadata_path = tmpdir / "metadata.json" + with open(metadata_path) as f: + metadata = json.load(f) + + assert "tokenizer_uri" in metadata + assert metadata["tokenizer_uri"] == tokenizer_uri + + # Verify it can be loaded back + loaded = PretrainBlendsArtifact.load(path=tmpdir) + assert loaded.tokenizer_uri == tokenizer_uri + + +class TestPathNormalization: + """Test that paths in blend.json are absolute and normalized. + + Paths must not contain '..' or '.' components to ensure they resolve + correctly in training containers that may have different working directories. + """ + + def test_get_filesystem_normalizes_local_paths_with_dotdot(self, tmp_path): + """Test get_filesystem resolves '..' in local paths.""" + # Create a nested structure + nested = tmp_path / "a" / "b" / "c" + nested.mkdir(parents=True) + + # Path with .. that should resolve + path_with_dotdot = str(tmp_path / "a" / "b" / "c" / ".." / ".." / "b") + + fs, normalized = get_filesystem(path_with_dotdot) + + # The normalized path should not contain '..' + assert ".." not in normalized, f"Path still contains '..': {normalized}" + # It should resolve to the actual path + assert normalized == str(tmp_path / "a" / "b") + + def test_get_filesystem_normalizes_local_paths_with_dot(self, tmp_path): + """Test get_filesystem resolves '.' in local paths.""" + path_with_dot = str(tmp_path / "." / "subdir") + + fs, normalized = get_filesystem(path_with_dot) + + # The normalized path should not contain '/.' + assert "/." not in normalized and not normalized.endswith("."), ( + f"Path still contains '.': {normalized}" + ) + + def test_get_filesystem_preserves_s3_paths(self): + """Test that S3 paths are not modified.""" + pytest.importorskip("s3fs") + + s3_path = "s3://bucket/prefix/../other" + + fs, normalized = get_filesystem(s3_path) + + # S3 paths should be passed through (fsspec handles them) + assert normalized.startswith("bucket/") + + def test_get_filesystem_handles_file_scheme(self, tmp_path): + """Test file:// URIs are handled correctly.""" + path_with_dotdot = f"file://{tmp_path}/a/../b" + + fs, normalized = get_filesystem(path_with_dotdot) + + # Should resolve the .. component + assert ".." not in normalized + + def test_blend_json_paths_should_be_normalized(self, tmp_path): + """Test that blend.json paths are absolute without '..' components. + + This is a contract test: data_prep should produce paths that work + in any execution context (different working directories, containers). + """ + # Simulate what data_prep would produce with proper normalization + output_dir = tmp_path / "output" + output_dir.mkdir() + + # Get filesystem normalizes the path + fs, normalized_base = get_filesystem(str(output_dir)) + + # Build path as pipeline.py does (after normalization fix) + shard_path = f"{normalized_base}/runs/abc123/datasets/test/hash/shard_000000" + + # Validate the contract + assert os.path.isabs(shard_path), f"Path is not absolute: {shard_path}" + assert ".." not in shard_path, f"Path contains '..': {shard_path}" + assert "/." not in shard_path, f"Path contains '/.': {shard_path}" + + def test_blend_json_paths_portable_across_contexts(self, tmp_path): + """Test that normalized paths work regardless of working directory. + + When data_prep runs in /code and outputs to /output, the paths in + blend.json must resolve correctly when training runs from /train. + """ + # Simulate data_prep output directory + output_dir = tmp_path / "output" + output_dir.mkdir() + + # Create a test shard file + shard_dir = output_dir / "runs" / "abc" / "datasets" / "test" / "hash" + shard_dir.mkdir(parents=True) + shard_file = shard_dir / "shard_000000.bin" + shard_file.touch() + + # Get normalized path as data_prep would + fs, base_path = get_filesystem(str(output_dir)) + shard_path = f"{base_path}/runs/abc/datasets/test/hash/shard_000000" + + # Change working directory to simulate training context + original_cwd = os.getcwd() + try: + os.chdir(tmp_path) + # The path should still be valid + assert os.path.isabs(shard_path) + # The file should exist (without .bin extension check since we test the prefix) + assert os.path.exists(f"{shard_path}.bin") + finally: + os.chdir(original_cwd) diff --git a/tests/recipes/nano3/stage1_sft/__init__.py b/tests/recipes/nano3/stage1_sft/__init__.py new file mode 100644 index 0000000..05cf44c --- /dev/null +++ b/tests/recipes/nano3/stage1_sft/__init__.py @@ -0,0 +1,15 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Tests for nano3/stage1_sft recipe.""" diff --git a/tests/recipes/nano3/stage1_sft/test_data_prep_train_integration.py b/tests/recipes/nano3/stage1_sft/test_data_prep_train_integration.py new file mode 100644 index 0000000..c86f4b6 --- /dev/null +++ b/tests/recipes/nano3/stage1_sft/test_data_prep_train_integration.py @@ -0,0 +1,784 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +""" +Tests for data_prep.py → train.py integration in nano3/stage1_sft. + +These contract tests validate that: +1. The .npy output format from data_prep.py matches what Megatron-Bridge expects +2. File naming follows Megatron-Bridge conventions: {split}_{pack_size}.npy +3. Metadata.jsonl format is compatible with GPTSFTPackedDataset +4. W&B artifact production and consumption works correctly +5. OmegaConf resolvers correctly resolve artifact paths +""" + +import json +import sys +import types +from pathlib import Path + +import numpy as np +from omegaconf import OmegaConf + +from nemotron.kit import SFTDataArtifact + + +class TestSFTDataPrepOutputFormat: + """Test that data_prep.py output format is correct.""" + + def test_packed_npy_file_naming_convention(self, tmp_path): + """Test .npy files use {split}_{pack_size}.npy naming.""" + pack_size = 4096 + + # Create files with correct naming + train_path = tmp_path / f"training_{pack_size}.npy" + valid_path = tmp_path / f"validation_{pack_size}.npy" + test_path = tmp_path / f"test_{pack_size}.npy" + + # Simulate data_prep output + sample_data = [{"input_ids": [1, 2, 3], "loss_mask": [0, 1, 1], "seq_start_id": [0]}] + np.save(train_path, sample_data, allow_pickle=True) + np.save(valid_path, sample_data, allow_pickle=True) + np.save(test_path, sample_data, allow_pickle=True) + + # Verify naming pattern + assert train_path.name == f"training_{pack_size}.npy" + assert valid_path.name == f"validation_{pack_size}.npy" + assert test_path.name == f"test_{pack_size}.npy" + + def test_packed_npy_contains_required_keys(self, tmp_path): + """Test each sample has input_ids, loss_mask, seq_start_id.""" + pack_size = 4096 + npy_path = tmp_path / f"training_{pack_size}.npy" + + # Create sample data with all required keys + sample_data = [ + { + "input_ids": [1, 2, 3, 4, 5], + "loss_mask": [0, 0, 1, 1, 1], + "seq_start_id": [0], + }, + { + "input_ids": [10, 20, 30, 40, 50, 60], + "loss_mask": [0, 1, 1, 1, 1, 1], + "seq_start_id": [0, 3], # Two sequences packed together + }, + ] + np.save(npy_path, sample_data, allow_pickle=True) + + # Load and verify + loaded = np.load(npy_path, allow_pickle=True) + for sample in loaded: + assert "input_ids" in sample, "Missing input_ids key" + assert "loss_mask" in sample, "Missing loss_mask key" + assert "seq_start_id" in sample, "Missing seq_start_id key" + + def test_loss_mask_rolled_by_one_for_label_alignment(self, tmp_path): + """Test loss_mask is shifted for next-token prediction. + + The loss_mask should be rolled by 1 so that it aligns with labels + (next token prediction). First position should be 0 (no loss on + predicting first token from nothing). + """ + pack_size = 4096 + npy_path = tmp_path / f"training_{pack_size}.npy" + + # Create sample where loss_mask starts with 0 (rolled) + sample_data = [ + { + "input_ids": [1, 2, 3, 4, 5], + # Original mask might be [0, 1, 1, 1, 1], rolled becomes [0, 0, 1, 1, 1] + "loss_mask": [0, 0, 1, 1, 1], + "seq_start_id": [0], + }, + ] + np.save(npy_path, sample_data, allow_pickle=True) + + loaded = np.load(npy_path, allow_pickle=True) + for sample in loaded: + # First position should be 0 (no loss on predicting from nothing) + assert sample["loss_mask"][0] == 0, "First loss_mask position should be 0 (rolled)" + + def test_seq_start_id_excludes_final_boundary(self, tmp_path): + """Test seq_start_id format matches GPTSFTPackedDataset expectation. + + GPTSFTPackedDataset adds len(input_ids) at read time: + seq_boundaries = seq_start_id + [len(input_ids)] + """ + pack_size = 4096 + npy_path = tmp_path / f"training_{pack_size}.npy" + + # Two sequences of length 3 and 4 packed together + sample_data = [ + { + "input_ids": [1, 2, 3, 4, 5, 6, 7], # 7 tokens total + "loss_mask": [0, 1, 1, 0, 1, 1, 1], + "seq_start_id": [0, 3], # Starts at 0 and 3, NOT including 7 + }, + ] + np.save(npy_path, sample_data, allow_pickle=True) + + loaded = np.load(npy_path, allow_pickle=True) + sample = loaded[0] + + # Simulate GPTSFTPackedDataset loading + seq_boundaries = sample["seq_start_id"] + [len(sample["input_ids"])] + + assert seq_boundaries == [0, 3, 7], f"Expected [0, 3, 7], got {seq_boundaries}" + + def test_metadata_jsonl_format_matches_megatron_bridge(self, tmp_path): + """Test {pack_size}_metadata.jsonl has required fields.""" + pack_size = 4096 + metadata_path = tmp_path / f"{pack_size}_metadata.jsonl" + + # Create metadata with Megatron-Bridge expected fields + metadata = [ + { + "max_samples_per_bin": 5, + "dataset_max_seqlen": 2048, + "packing_factor": 3.2, + "packing_efficiency": 92.5, + "pack_size": pack_size, + "min_packed_seqlen": 3800, + }, + { + "max_samples_per_bin": 4, + "dataset_max_seqlen": 1900, + "packing_factor": 3.0, + "packing_efficiency": 90.1, + "pack_size": pack_size, + "min_packed_seqlen": 3700, + }, + ] + + with open(metadata_path, "w") as f: + json.dump(metadata, f) + + # Load and verify + with open(metadata_path) as f: + loaded = json.load(f) + + required_fields = { + "max_samples_per_bin", + "dataset_max_seqlen", + "packing_factor", + "packing_efficiency", + "pack_size", + "min_packed_seqlen", + } + + for entry in loaded: + for field in required_fields: + assert field in entry, f"Missing required field: {field}" + + +class TestSFTDataPrepMegatronBridgeCompatibility: + """Test integration with Megatron-Bridge's GPTSFTPackedDataset.""" + + def test_npy_loadable_by_gpt_sft_packed_dataset_format(self, tmp_path): + """Simulate GPTSFTPackedDataset loading to verify compatibility.""" + pack_size = 4096 + npy_path = tmp_path / f"training_{pack_size}.npy" + + # Create realistic packed data + sample_data = [ + { + "input_ids": list(range(100)), + "loss_mask": [0] * 30 + [1] * 70, + "seq_start_id": [0, 30], # Two sequences + }, + { + "input_ids": list(range(50)), + "loss_mask": [0] * 10 + [1] * 40, + "seq_start_id": [0], # One sequence + }, + ] + np.save(npy_path, sample_data, allow_pickle=True) + + # Simulate GPTSFTPackedDataset.__getitem__ (from sft.py:786-791) + indexed_dataset = np.load(npy_path, allow_pickle=True) + + for idx in range(len(indexed_dataset)): + # This is exactly what GPTSFTPackedDataset does + input_ids = indexed_dataset[idx]["input_ids"] + seq_boundaries = indexed_dataset[idx]["seq_start_id"] + [len(input_ids)] + loss_mask = indexed_dataset[idx]["loss_mask"] + + # Verify data is accessible and correct type + assert isinstance(input_ids, list), f"input_ids should be list, got {type(input_ids)}" + assert isinstance(loss_mask, list), f"loss_mask should be list, got {type(loss_mask)}" + assert isinstance(seq_boundaries, list), "seq_boundaries should be list" + + # Verify lengths match + assert len(input_ids) == len(loss_mask), "input_ids and loss_mask length mismatch" + + # Verify seq_boundaries are valid + for i, boundary in enumerate(seq_boundaries[:-1]): + assert boundary >= 0, f"Boundary {i} is negative" + assert boundary < len(input_ids), f"Boundary {i} exceeds input length" + + def test_metadata_parseable_by_megatron_bridge(self, tmp_path): + """Test metadata.jsonl can be parsed as Megatron-Bridge expects.""" + pack_size = 4096 + metadata_path = tmp_path / f"{pack_size}_metadata.jsonl" + + metadata = [ + { + "max_samples_per_bin": 5, + "dataset_max_seqlen": 2048, + "packing_factor": 3.2, + "packing_efficiency": 92.5, + "pack_size": pack_size, + "min_packed_seqlen": 3800, + }, + ] + + with open(metadata_path, "w") as f: + json.dump(metadata, f) + + # Parse as Megatron-Bridge would + with open(metadata_path) as f: + loaded = json.load(f) + + # Should be a list of dicts + assert isinstance(loaded, list) + assert all(isinstance(entry, dict) for entry in loaded) + + def test_pack_size_suffix_in_filenames(self, tmp_path): + """Test filenames include pack_size for Megatron-Bridge defaults.""" + pack_sizes = [2048, 4096, 8192] + + for pack_size in pack_sizes: + train_path = tmp_path / f"training_{pack_size}.npy" + valid_path = tmp_path / f"validation_{pack_size}.npy" + + # Create files + sample_data = [{"input_ids": [1], "loss_mask": [0], "seq_start_id": [0]}] + np.save(train_path, sample_data, allow_pickle=True) + np.save(valid_path, sample_data, allow_pickle=True) + + # Verify they exist with correct names + assert train_path.exists() + assert valid_path.exists() + assert str(pack_size) in train_path.name + assert str(pack_size) in valid_path.name + + +class TestSFTArtifactIntegration: + """Test SFTDataArtifact lifecycle.""" + + def test_sft_data_artifact_stores_pack_size(self, tmp_path): + """Test SFTDataArtifact includes pack_size.""" + artifact = SFTDataArtifact( + path=tmp_path, + total_tokens=1000, + total_sequences=100, + pack_size=4096, + ) + + assert artifact.pack_size == 4096 + assert artifact.metadata.get("pack_size") == 4096 + + def test_sft_data_artifact_stores_explicit_paths(self, tmp_path): + """Test SFTDataArtifact includes training_path, validation_path, etc.""" + pack_size = 4096 + training_path = str(tmp_path / f"training_{pack_size}.npy") + validation_path = str(tmp_path / f"validation_{pack_size}.npy") + test_path = str(tmp_path / f"test_{pack_size}.npy") + metadata_path = str(tmp_path / f"{pack_size}_metadata.jsonl") + + artifact = SFTDataArtifact( + path=tmp_path, + total_tokens=1000, + total_sequences=100, + pack_size=pack_size, + training_path=training_path, + validation_path=validation_path, + test_path=test_path, + metadata_path=metadata_path, + ) + + assert artifact.training_path == training_path + assert artifact.validation_path == validation_path + assert artifact.test_path == test_path + assert artifact.metadata_path == metadata_path + + def test_artifact_paths_are_absolute_and_normalized(self, tmp_path): + """Test paths work across different execution contexts.""" + pack_size = 4096 + # Create with absolute paths + training_path = str(tmp_path.resolve() / f"training_{pack_size}.npy") + + artifact = SFTDataArtifact( + path=tmp_path, + total_tokens=1000, + total_sequences=100, + pack_size=pack_size, + training_path=training_path, + ) + + # Path should be absolute + assert Path(artifact.training_path).is_absolute() + # Path should not contain '..' + assert ".." not in artifact.training_path + + def test_artifact_roundtrip_preserves_all_fields(self, tmp_path): + """Test save/load preserves training_path, validation_path, etc.""" + pack_size = 4096 + training_path = str(tmp_path / f"training_{pack_size}.npy") + validation_path = str(tmp_path / f"validation_{pack_size}.npy") + test_path = str(tmp_path / f"test_{pack_size}.npy") + metadata_path = str(tmp_path / f"{pack_size}_metadata.jsonl") + + original = SFTDataArtifact( + path=tmp_path, + total_tokens=1000000, + total_sequences=10000, + pack_size=pack_size, + training_path=training_path, + validation_path=validation_path, + test_path=test_path, + metadata_path=metadata_path, + tokenizer_uri="https://huggingface.co/nvidia/NVIDIA-Nemotron-Nano-9B-v2", + ) + original.save() + + # Load and verify + loaded = SFTDataArtifact.load(path=tmp_path) + + assert loaded.total_tokens == original.total_tokens + assert loaded.total_sequences == original.total_sequences + assert loaded.pack_size == original.pack_size + assert loaded.training_path == original.training_path + assert loaded.validation_path == original.validation_path + assert loaded.test_path == original.test_path + assert loaded.metadata_path == original.metadata_path + assert loaded.tokenizer_uri == original.tokenizer_uri + + +class TestOmegaConfResolverIntegration: + """Test OmegaConf resolvers work correctly with train.py and config files.""" + + def test_art_resolver_resolves_data_path(self, monkeypatch, tmp_path): + """Test ${art:data,path} resolves to artifact download path.""" + from nemotron.kit import resolvers + + resolvers.clear_artifact_cache() + + monkeypatch.setenv("WANDB_ENTITY", "ent") + monkeypatch.setenv("WANDB_PROJECT", "proj") + + # Create artifact directory + downloaded_dir = tmp_path / "artifact" + downloaded_dir.mkdir() + + class FakeArtifact: + def __init__(self, ref): + self.qualified_name = ref + self.version = "v5" + self.name = "SFTDataArtifact-sft" + self.type = "dataset" + + def download(self, skip_cache=True): + return str(downloaded_dir) + + class FakeApi: + def artifact(self, ref): + return FakeArtifact(ref) + + fake_wandb = types.SimpleNamespace(Api=lambda: FakeApi()) + monkeypatch.setitem(sys.modules, "wandb", fake_wandb) + + cfg = OmegaConf.create( + { + "run": {"data": "SFTDataArtifact-sft:latest"}, + "dataset": {"dataset_root": "${art:data,path}"}, + } + ) + + resolvers.register_resolvers_from_config(cfg, mode="pre_init") + resolved = OmegaConf.to_container(cfg, resolve=True) + + assert resolved["dataset"]["dataset_root"] == str(downloaded_dir) + + def test_art_resolver_resolves_pack_size(self, monkeypatch, tmp_path): + """Test ${art:data,pack_size} resolves to artifact pack_size field.""" + from nemotron.kit import resolvers + + resolvers.clear_artifact_cache() + + monkeypatch.setenv("WANDB_ENTITY", "ent") + monkeypatch.setenv("WANDB_PROJECT", "proj") + + # Create artifact with metadata + downloaded_dir = tmp_path / "artifact" + downloaded_dir.mkdir() + metadata = { + "path": str(downloaded_dir), + "type": "SFTDataArtifact", + "pack_size": 4096, + "total_tokens": 1000, + "total_sequences": 100, + } + (downloaded_dir / "metadata.json").write_text(json.dumps(metadata)) + + class FakeArtifact: + def __init__(self, ref): + self.qualified_name = ref + self.version = "v5" + self.name = "SFTDataArtifact-sft" + self.type = "dataset" + + def download(self, skip_cache=True): + return str(downloaded_dir) + + class FakeApi: + def artifact(self, ref): + return FakeArtifact(ref) + + fake_wandb = types.SimpleNamespace(Api=lambda: FakeApi()) + monkeypatch.setitem(sys.modules, "wandb", fake_wandb) + + cfg = OmegaConf.create( + { + "run": {"data": "SFTDataArtifact-sft:latest"}, + "dataset": {"seq_length": "${art:data,pack_size}"}, + } + ) + + resolvers.register_resolvers_from_config(cfg, mode="pre_init") + resolved = OmegaConf.to_container(cfg, resolve=True) + + # Resolver returns string representation of pack_size + assert resolved["dataset"]["seq_length"] == "4096" + + def test_art_resolver_resolves_training_path(self, monkeypatch, tmp_path): + """Test ${art:data,training_path} resolves to training file path.""" + from nemotron.kit import resolvers + + resolvers.clear_artifact_cache() + + monkeypatch.setenv("WANDB_ENTITY", "ent") + monkeypatch.setenv("WANDB_PROJECT", "proj") + + # Create artifact with explicit paths + downloaded_dir = tmp_path / "artifact" + downloaded_dir.mkdir() + training_path = str(downloaded_dir / "training_4096.npy") + metadata = { + "path": str(downloaded_dir), + "type": "SFTDataArtifact", + "pack_size": 4096, + "total_tokens": 1000, + "total_sequences": 100, + "training_path": training_path, + } + (downloaded_dir / "metadata.json").write_text(json.dumps(metadata)) + + class FakeArtifact: + def __init__(self, ref): + self.qualified_name = ref + self.version = "v5" + self.name = "SFTDataArtifact-sft" + self.type = "dataset" + + def download(self, skip_cache=True): + return str(downloaded_dir) + + class FakeApi: + def artifact(self, ref): + return FakeArtifact(ref) + + fake_wandb = types.SimpleNamespace(Api=lambda: FakeApi()) + monkeypatch.setitem(sys.modules, "wandb", fake_wandb) + + cfg = OmegaConf.create( + { + "run": {"data": "SFTDataArtifact-sft:latest"}, + "dataset": {"packed_train_data_path": "${art:data,training_path}"}, + } + ) + + resolvers.register_resolvers_from_config(cfg, mode="pre_init") + resolved = OmegaConf.to_container(cfg, resolve=True) + + assert resolved["dataset"]["packed_train_data_path"] == training_path + + def test_run_wandb_project_interpolation(self, monkeypatch, tmp_path): + """Test ${run.wandb.project} resolves from run section.""" + from nemotron.kit.cli.config import _resolve_run_interpolations + + config_dict = { + "logger": {"wandb_project": "${run.wandb.project}"}, + } + run_section = {"wandb": {"project": "test-project", "entity": "test-entity"}} + + result = _resolve_run_interpolations(config_dict, run_section) + + assert result["logger"]["wandb_project"] == "test-project" + + def test_run_wandb_entity_interpolation(self, monkeypatch, tmp_path): + """Test ${run.wandb.entity} resolves from run section.""" + from nemotron.kit.cli.config import _resolve_run_interpolations + + config_dict = { + "logger": {"wandb_entity": "${run.wandb.entity}"}, + } + run_section = {"wandb": {"project": "test-project", "entity": "test-entity"}} + + result = _resolve_run_interpolations(config_dict, run_section) + + assert result["logger"]["wandb_entity"] == "test-entity" + + +class TestWandbArtifactIntegration: + """Test W&B artifact production and consumption for SFT.""" + + def test_wandb_artifact_resolution_for_sft_train(self, monkeypatch, tmp_path): + """Test ${art:data,path} resolver works with SFT train.py config pattern.""" + from nemotron.kit import resolvers + + resolvers.clear_artifact_cache() + + monkeypatch.setenv("WANDB_ENTITY", "ent") + monkeypatch.setenv("WANDB_PROJECT", "proj") + + # Create artifact with SFT data + downloaded_dir = tmp_path / "artifact" + downloaded_dir.mkdir() + pack_size = 4096 + training_path = str(downloaded_dir / f"training_{pack_size}.npy") + validation_path = str(downloaded_dir / f"validation_{pack_size}.npy") + metadata_path = str(downloaded_dir / f"{pack_size}_metadata.jsonl") + + # Create sample files + sample_data = [{"input_ids": [1, 2, 3], "loss_mask": [0, 1, 1], "seq_start_id": [0]}] + np.save(training_path, sample_data, allow_pickle=True) + np.save(validation_path, sample_data, allow_pickle=True) + + # Create metadata + metadata = { + "path": str(downloaded_dir), + "type": "SFTDataArtifact", + "pack_size": pack_size, + "total_tokens": 1000, + "total_sequences": 100, + "training_path": training_path, + "validation_path": validation_path, + "metadata_path": metadata_path, + } + (downloaded_dir / "metadata.json").write_text(json.dumps(metadata)) + + class FakeArtifact: + def __init__(self, ref): + self.qualified_name = ref + self.version = "v5" + self.name = "SFTDataArtifact-sft" + self.type = "dataset" + + def download(self, skip_cache=True): + return str(downloaded_dir) + + class FakeApi: + def artifact(self, ref): + return FakeArtifact(ref) + + fake_wandb = types.SimpleNamespace(Api=lambda: FakeApi()) + monkeypatch.setitem(sys.modules, "wandb", fake_wandb) + + # Config pattern matching tiny.yaml + cfg = OmegaConf.create( + { + "run": {"data": "SFTDataArtifact-sft:latest"}, + "dataset": { + "dataset_root": "${art:data,path}", + "seq_length": "${art:data,pack_size}", + "packed_sequence_specs": { + "packed_sequence_size": "${art:data,pack_size}", + "packed_train_data_path": "${art:data,training_path}", + "packed_val_data_path": "${art:data,validation_path}", + "packed_metadata_path": "${art:data,metadata_path}", + }, + }, + } + ) + + resolvers.register_resolvers_from_config(cfg, mode="pre_init") + resolved = OmegaConf.to_container(cfg, resolve=True) + + # Verify all paths resolved correctly + # Note: OmegaConf resolvers return strings, so numeric values are stringified + assert resolved["dataset"]["dataset_root"] == str(downloaded_dir) + assert resolved["dataset"]["seq_length"] == str(pack_size) + specs = resolved["dataset"]["packed_sequence_specs"] + assert specs["packed_sequence_size"] == str(pack_size) + assert specs["packed_train_data_path"] == training_path + assert specs["packed_val_data_path"] == validation_path + assert specs["packed_metadata_path"] == metadata_path + + # Verify training file exists and is loadable + loaded = np.load(specs["packed_train_data_path"], allow_pickle=True) + assert len(loaded) > 0 + + def test_artifact_metadata_contains_required_fields(self, tmp_path): + """Test SFTDataArtifact metadata has fields needed by train.py.""" + pack_size = 4096 + training_path = str(tmp_path / f"training_{pack_size}.npy") + + artifact = SFTDataArtifact( + path=tmp_path, + total_tokens=1000000, + total_sequences=10000, + pack_size=pack_size, + training_path=training_path, + ) + artifact.save() + + # Load and verify metadata + with open(tmp_path / "metadata.json") as f: + metadata = json.load(f) + + # Required fields for train.py + assert "path" in metadata + assert "type" in metadata + assert metadata["type"] == "SFTDataArtifact" + assert "pack_size" in metadata + assert metadata["pack_size"] == pack_size + assert "training_path" in metadata + assert metadata["training_path"] == training_path + + +class TestSFTDataPrepTrainContract: + """End-to-end contract tests for data_prep -> train flow.""" + + def test_full_data_prep_to_train_flow(self, monkeypatch, tmp_path): + """Test complete flow: data_prep output -> train consumption.""" + from nemotron.kit import resolvers + + resolvers.clear_artifact_cache() + + monkeypatch.setenv("WANDB_ENTITY", "ent") + monkeypatch.setenv("WANDB_PROJECT", "proj") + + # Step 1: Simulate data_prep output + pack_size = 4096 + output_dir = tmp_path / "data_prep_output" + output_dir.mkdir() + + training_path = output_dir / f"training_{pack_size}.npy" + validation_path = output_dir / f"validation_{pack_size}.npy" + test_path = output_dir / f"test_{pack_size}.npy" + mb_metadata_path = output_dir / f"{pack_size}_metadata.jsonl" + + # Create packed data + train_data = [ + { + "input_ids": list(range(100)), + "loss_mask": [0] * 30 + [1] * 70, + "seq_start_id": [0, 30], + }, + {"input_ids": list(range(80)), "loss_mask": [0] * 20 + [1] * 60, "seq_start_id": [0]}, + ] + valid_data = [ + {"input_ids": list(range(50)), "loss_mask": [0] * 10 + [1] * 40, "seq_start_id": [0]}, + ] + test_data = [ + {"input_ids": list(range(60)), "loss_mask": [0] * 15 + [1] * 45, "seq_start_id": [0]}, + ] + + np.save(training_path, train_data, allow_pickle=True) + np.save(validation_path, valid_data, allow_pickle=True) + np.save(test_path, test_data, allow_pickle=True) + + # Create Megatron-Bridge compatible metadata + mb_metadata = [ + { + "max_samples_per_bin": 2, + "dataset_max_seqlen": 70, + "packing_factor": 1.5, + "packing_efficiency": 90.0, + "pack_size": pack_size, + "min_packed_seqlen": 80, + }, + ] + with open(mb_metadata_path, "w") as f: + json.dump(mb_metadata, f) + + # Step 2: Create and save artifact + artifact = SFTDataArtifact( + path=output_dir, + total_tokens=290, + total_sequences=4, + pack_size=pack_size, + training_path=str(training_path), + validation_path=str(validation_path), + test_path=str(test_path), + metadata_path=str(mb_metadata_path), + ) + artifact.save() + + # Step 3: Mock W&B artifact download + class FakeArtifact: + def __init__(self, ref): + self.qualified_name = ref + self.version = "v1" + self.name = "SFTDataArtifact-sft" + self.type = "dataset" + + def download(self, skip_cache=True): + return str(output_dir) + + class FakeApi: + def artifact(self, ref): + return FakeArtifact(ref) + + fake_wandb = types.SimpleNamespace(Api=lambda: FakeApi()) + monkeypatch.setitem(sys.modules, "wandb", fake_wandb) + + # Step 4: Load config (simulating train.py) + cfg = OmegaConf.create( + { + "run": {"data": "SFTDataArtifact-sft:latest"}, + "dataset": { + "dataset_root": "${art:data,path}", + "seq_length": "${art:data,pack_size}", + "packed_sequence_specs": { + "packed_sequence_size": "${art:data,pack_size}", + "packed_train_data_path": "${art:data,training_path}", + "packed_val_data_path": "${art:data,validation_path}", + "packed_metadata_path": "${art:data,metadata_path}", + }, + }, + } + ) + + resolvers.register_resolvers_from_config(cfg, mode="pre_init") + resolved = OmegaConf.to_container(cfg, resolve=True) + + # Step 5: Verify data is NOT empty and correctly formatted + specs = resolved["dataset"]["packed_sequence_specs"] + train_loaded = np.load(specs["packed_train_data_path"], allow_pickle=True) + valid_loaded = np.load(specs["packed_val_data_path"], allow_pickle=True) + + assert len(train_loaded) > 0, "Training data is empty!" + assert len(valid_loaded) > 0, "Validation data is empty!" + + # Step 6: Verify format matches GPTSFTPackedDataset expectation + for sample in train_loaded: + assert "input_ids" in sample + assert "loss_mask" in sample + assert "seq_start_id" in sample + # Simulate GPTSFTPackedDataset loading + seq_boundaries = sample["seq_start_id"] + [len(sample["input_ids"])] + assert seq_boundaries[-1] == len(sample["input_ids"]) diff --git a/tests/recipes/nano3/stage2_rl/__init__.py b/tests/recipes/nano3/stage2_rl/__init__.py new file mode 100644 index 0000000..341a77c --- /dev/null +++ b/tests/recipes/nano3/stage2_rl/__init__.py @@ -0,0 +1,13 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. diff --git a/tests/recipes/nano3/stage2_rl/test_data_prep_train_integration.py b/tests/recipes/nano3/stage2_rl/test_data_prep_train_integration.py new file mode 100644 index 0000000..9afd6b4 --- /dev/null +++ b/tests/recipes/nano3/stage2_rl/test_data_prep_train_integration.py @@ -0,0 +1,851 @@ +# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +""" +Tests for data_prep.py → train.py integration in nano3/stage2_rl. + +These tests validate: +1. HuggingFace placeholder resolution logic +2. Template restoration functions (DAPO prefix/suffix, Skywork {question}) +3. Transform output format matches what RL training expects +4. The resolve_hf_placeholders transform handles both placeholder and normal records +5. Manifest JSON format matches what train.py expects +6. W&B artifact production and consumption works correctly +7. The ${art:data,path} resolver correctly resolves artifact paths +""" + +import json +import sys +import tempfile +import types +from pathlib import Path + +import pytest +from omegaconf import OmegaConf + +from nemotron.kit import SplitJsonlDataArtifact + +from nemotron.data_prep.hf_placeholder import ( + TARGET_DATASETS, + HFPlaceholderResolver, + get_nested_value, + is_placeholder_record, + restore_dapo_question, + restore_skywork_question, +) + + +class TestGetNestedValue: + """Test the get_nested_value helper function.""" + + def test_simple_dict_path(self): + """Test extracting value from simple dict.""" + record = {"key": "value"} + assert get_nested_value(record, ["key"]) == "value" + + def test_nested_dict_path(self): + """Test extracting value from nested dict.""" + record = {"level1": {"level2": {"level3": "deep_value"}}} + assert get_nested_value(record, ["level1", "level2", "level3"]) == "deep_value" + + def test_list_index_access(self): + """Test extracting value from list by index.""" + record = {"items": ["first", "second", "third"]} + assert get_nested_value(record, ["items", 0]) == "first" + assert get_nested_value(record, ["items", 2]) == "third" + + def test_mixed_dict_and_list(self): + """Test extracting from mixed dict/list structure.""" + record = {"prompt": [{"content": "What is 2+2?"}]} + path = ["prompt", 0, "content"] + assert get_nested_value(record, path) == "What is 2+2?" + + def test_missing_key_returns_none(self): + """Test that missing keys return None.""" + record = {"key": "value"} + assert get_nested_value(record, ["missing"]) is None + + def test_out_of_bounds_index_returns_none(self): + """Test that out of bounds list index returns None.""" + record = {"items": ["only_one"]} + assert get_nested_value(record, ["items", 5]) is None + + def test_empty_path_returns_record(self): + """Test that empty path returns the record itself.""" + record = {"key": "value"} + assert get_nested_value(record, []) == record + + def test_none_in_path_returns_none(self): + """Test that None value in traversal path returns None.""" + record = {"key": None} + assert get_nested_value(record, ["key", "nested"]) is None + + +class TestRestoreDapoQuestion: + """Test DAPO question restoration with prefix/suffix templates.""" + + def test_basic_prefix_suffix(self): + """Test basic prefix and suffix application.""" + hf_question = "Calculate 2+2" + template = { + "prefix": "Math problem: ", + "suffix": "\nPlease solve step by step.", + } + result = restore_dapo_question(hf_question, template) + assert result == "Math problem: Calculate 2+2\nPlease solve step by step." + + def test_only_prefix(self): + """Test template with only prefix.""" + hf_question = "What is the capital of France?" + template = {"prefix": "Question: "} + result = restore_dapo_question(hf_question, template) + assert result == "Question: What is the capital of France?" + + def test_only_suffix(self): + """Test template with only suffix.""" + hf_question = "Solve this equation" + template = {"suffix": "\n\nShow your work."} + result = restore_dapo_question(hf_question, template) + assert result == "Solve this equation\n\nShow your work." + + def test_empty_template(self): + """Test empty template returns original question.""" + hf_question = "Original question" + template = {} + result = restore_dapo_question(hf_question, template) + assert result == "Original question" + + def test_multiline_prefix_suffix(self): + """Test multiline prefix and suffix.""" + hf_question = "x + 5 = 10" + template = { + "prefix": "You are a math tutor.\n\nSolve: ", + "suffix": "\n\nExplain each step.", + } + result = restore_dapo_question(hf_question, template) + expected = "You are a math tutor.\n\nSolve: x + 5 = 10\n\nExplain each step." + assert result == expected + + +class TestRestoreSkyworkQuestion: + """Test Skywork question restoration with {question} placeholder.""" + + def test_basic_placeholder_replacement(self): + """Test basic {question} replacement.""" + hf_question = "What is the capital of France?" + template = "Please answer: {question}\n\nAnswer:" + result = restore_skywork_question(hf_question, template) + assert result == "Please answer: What is the capital of France?\n\nAnswer:" + + def test_multiple_placeholders(self): + """Test template with multiple {question} placeholders.""" + hf_question = "2+2" + template = "Solve {question}. The answer to {question} is:" + result = restore_skywork_question(hf_question, template) + assert result == "Solve 2+2. The answer to 2+2 is:" + + def test_no_placeholder_returns_question(self): + """Test template without placeholder returns original question.""" + hf_question = "Test question" + template = "Some template without placeholder" + result = restore_skywork_question(hf_question, template) + assert result == "Test question" + + def test_empty_question(self): + """Test empty question in template.""" + hf_question = "" + template = "Answer: {question}" + result = restore_skywork_question(hf_question, template) + assert result == "Answer: " + + +class TestIsPlaceholderRecord: + """Test placeholder record detection.""" + + def test_placeholder_record_detected(self): + """Test that records with _hf_placeholder are detected.""" + record = { + "dataset": "nano_v3_sft_profiled_dapo17k", + "_hf_placeholder": {"row": 42, "question_template": {"prefix": "Q: "}}, + } + assert is_placeholder_record(record) is True + + def test_normal_record_not_detected(self): + """Test that normal records are not detected as placeholders.""" + record = { + "question": "What is 2+2?", + "expected_answer": "4", + "responses_create_params": {"input": [{"role": "user", "content": "What is 2+2?"}]}, + } + assert is_placeholder_record(record) is False + + def test_empty_record(self): + """Test empty record is not a placeholder.""" + assert is_placeholder_record({}) is False + + +class TestTargetDatasetsConfig: + """Test TARGET_DATASETS configuration is valid.""" + + def test_required_keys_present(self): + """Test all target datasets have required configuration keys.""" + required_keys = {"hf_dataset", "split", "question_path", "answer_path", "template_type"} + for name, config in TARGET_DATASETS.items(): + for key in required_keys: + assert key in config, f"Missing key '{key}' in {name} config" + + def test_template_types_valid(self): + """Test template_type is either 'dapo' or 'skywork'.""" + valid_types = {"dapo", "skywork"} + for name, config in TARGET_DATASETS.items(): + assert config["template_type"] in valid_types, ( + f"Invalid template_type '{config['template_type']}' in {name}" + ) + + def test_paths_are_lists(self): + """Test question_path and answer_path are lists.""" + for name, config in TARGET_DATASETS.items(): + assert isinstance(config["question_path"], list), ( + f"question_path in {name} should be a list" + ) + assert isinstance(config["answer_path"], list), ( + f"answer_path in {name} should be a list" + ) + + def test_expected_datasets_present(self): + """Test expected placeholder dataset names are configured.""" + expected_datasets = { + "nano_v3_sft_profiled_dapo17k", + "nano_v3_sft_profiled_skywork_no_omni", + } + configured_datasets = set(TARGET_DATASETS.keys()) + assert expected_datasets == configured_datasets + + +class TestResolveHfPlaceholderTransform: + """Test the resolve_hf_placeholders transform function.""" + + def test_non_placeholder_record_uses_nemotron_rl(self): + """Test that non-placeholder records use nemotron_rl extraction.""" + from nemotron.data_prep.formats.transforms import resolve_hf_placeholders + + # Create transform without resolver (will not be needed for non-placeholder) + transform = resolve_hf_placeholders(resolver=None) + + # Normal record with responses_create_params + record = { + "responses_create_params": { + "input": [{"role": "user", "content": "What is 2+2?"}], + "tools": [{"name": "calculator"}], + } + } + + result = transform(record) + + # Should extract messages and tools like nemotron_rl + assert result is not None + assert "messages" in result + assert result["messages"] == [{"role": "user", "content": "What is 2+2?"}] + assert "tools" in result + assert result["tools"] == [{"name": "calculator"}] + + def test_non_placeholder_without_tools(self): + """Test non-placeholder record without tools field.""" + from nemotron.data_prep.formats.transforms import resolve_hf_placeholders + + transform = resolve_hf_placeholders(resolver=None) + + record = { + "responses_create_params": { + "input": [{"role": "user", "content": "Hello"}], + } + } + + result = transform(record) + + assert result is not None + assert "messages" in result + assert "tools" not in result + + def test_invalid_record_returns_none(self): + """Test that records without valid structure return None.""" + from nemotron.data_prep.formats.transforms import resolve_hf_placeholders + + transform = resolve_hf_placeholders(resolver=None) + + # Record without responses_create_params or _hf_placeholder + record = {"random_field": "value"} + + result = transform(record) + assert result is None + + +class TestHFPlaceholderResolverUnit: + """Unit tests for HFPlaceholderResolver without loading actual HF datasets.""" + + def test_resolve_returns_none_for_non_placeholder(self): + """Test resolve returns None for non-placeholder records.""" + # Create resolver with empty datasets (won't be used) + resolver = HFPlaceholderResolver(datasets={}, configs={}) + + record = {"question": "regular question", "answer": "regular answer"} + result = resolver.resolve(record) + + assert result is None + + def test_resolve_returns_none_for_unknown_dataset(self): + """Test resolve returns None for unknown dataset names.""" + resolver = HFPlaceholderResolver(datasets={}, configs={}) + + record = { + "dataset": "unknown_dataset", + "_hf_placeholder": {"row": 0, "question_template": {}}, + } + result = resolver.resolve(record) + + assert result is None + + +class TestOutputFormat: + """Test that resolved records match RL training expected format.""" + + def test_resolved_record_structure(self): + """Test resolved records have correct structure for RL training.""" + # This is the expected output format + resolved = { + "question": "Full question text here", + "expected_answer": "Expected answer", + "responses_create_params": { + "input": [{"role": "user", "content": "Full question text here"}] + }, + } + + # Verify structure + assert "question" in resolved + assert "expected_answer" in resolved + assert "responses_create_params" in resolved + assert "input" in resolved["responses_create_params"] + + # Verify messages format + messages = resolved["responses_create_params"]["input"] + assert len(messages) == 1 + assert messages[0]["role"] == "user" + assert "content" in messages[0] + + def test_messages_content_matches_question(self): + """Test that messages content matches the question field.""" + question = "What is the capital of France?" + resolved = { + "question": question, + "expected_answer": "Paris", + "responses_create_params": { + "input": [{"role": "user", "content": question}] + }, + } + + # The content should match the question + assert resolved["responses_create_params"]["input"][0]["content"] == resolved["question"] + + +class TestTransformIntegration: + """Integration tests for the resolve transform with mock resolver.""" + + def test_placeholder_record_with_mock_resolver(self): + """Test placeholder record resolution with a mock resolver.""" + from nemotron.data_prep.formats.transforms import resolve_hf_placeholders + from nemotron.data_prep.hf_placeholder import HFPlaceholderResolver, PlaceholderConfig + + # Create a mock dataset (simple dict-based mock) + class MockDataset: + def __init__(self, data): + self._data = data + + def __len__(self): + return len(self._data) + + def __getitem__(self, idx): + return self._data[idx] + + mock_data = [ + {"prompt": [{"content": "What is 2+2?"}], "reward_model": {"ground_truth": "4"}}, + {"prompt": [{"content": "What is 3+3?"}], "reward_model": {"ground_truth": "6"}}, + ] + + mock_config = PlaceholderConfig( + hf_dataset="test/mock-dataset", + split="train", + question_path=["prompt", 0, "content"], + answer_path=["reward_model", "ground_truth"], + template_type="dapo", + ) + + resolver = HFPlaceholderResolver( + datasets={"test_dataset": MockDataset(mock_data)}, + configs={"test_dataset": mock_config}, + ) + + # Test resolution + placeholder_record = { + "dataset": "test_dataset", + "_hf_placeholder": { + "row": 0, + "question_template": {"prefix": "Q: ", "suffix": ""}, + }, + } + + result = resolver.resolve(placeholder_record) + + assert result is not None + assert result["question"] == "Q: What is 2+2?" + assert result["expected_answer"] == "4" + assert "responses_create_params" in result + assert result["responses_create_params"]["input"][0]["content"] == "Q: What is 2+2?" + + def test_skywork_template_resolution(self): + """Test Skywork-style {question} template resolution.""" + from nemotron.data_prep.hf_placeholder import HFPlaceholderResolver, PlaceholderConfig + + class MockDataset: + def __init__(self, data): + self._data = data + + def __len__(self): + return len(self._data) + + def __getitem__(self, idx): + return self._data[idx] + + mock_data = [ + {"problem": "Solve x + 5 = 10", "answer": "x = 5"}, + ] + + mock_config = PlaceholderConfig( + hf_dataset="test/skywork-mock", + split="train", + question_path=["problem"], + answer_path=["answer"], + template_type="skywork", + ) + + resolver = HFPlaceholderResolver( + datasets={"skywork_test": MockDataset(mock_data)}, + configs={"skywork_test": mock_config}, + ) + + placeholder_record = { + "dataset": "skywork_test", + "_hf_placeholder": { + "row": 0, + "question_template": "Please solve: {question}\n\nSolution:", + }, + } + + result = resolver.resolve(placeholder_record) + + assert result is not None + assert result["question"] == "Please solve: Solve x + 5 = 10\n\nSolution:" + assert result["expected_answer"] == "x = 5" + + +class TestRLDataPrepTrainIntegration: + """Test integration between data_prep.py output and train.py consumption.""" + + def test_manifest_json_format_matches_train_expectation(self): + """Test manifest.json format is compatible with train.py config.""" + with tempfile.TemporaryDirectory() as tmpdir: + tmpdir = Path(tmpdir) + manifest_path = tmpdir / "manifest.json" + + # Simulate data_prep output - manifest.json with split paths + manifest_data = { + "train": str(tmpdir / "train" / "train.jsonl"), + "val": str(tmpdir / "val" / "val.jsonl"), + "test": str(tmpdir / "test" / "test.jsonl"), + "mode": "resolve", + "source_splits": ["train", "validation", "test"], + } + + with open(manifest_path, "w") as f: + json.dump(manifest_data, f) + + # Simulate train.py loading + with open(manifest_path) as f: + loaded = json.load(f) + + assert loaded == manifest_data + assert "train" in loaded + assert "val" in loaded + assert "test" in loaded + + def test_jsonl_format_compatible_with_nemo_rl_loading(self): + """Test JSONL format is compatible with NeMo-RL's data loading. + + train.py uses setup_single_nemo_gym_dataset which: + 1. Opens JSONL file + 2. Calls json.loads() on each line + 3. Passes to nemo_gym_example_to_nemo_rl_datum_spec + + This test simulates that exact loading pattern. + """ + with tempfile.TemporaryDirectory() as tmpdir: + tmpdir = Path(tmpdir) + train_dir = tmpdir / "train" + train_dir.mkdir() + train_jsonl = train_dir / "train.jsonl" + + # Simulate data_prep output format (after resolve transform) + records = [ + { + "messages": [{"role": "user", "content": "What is 2+2?"}], + }, + { + "messages": [{"role": "user", "content": "What is 3+3?"}], + "tools": [{"name": "calculator"}], + }, + ] + + with open(train_jsonl, "w") as f: + for record in records: + f.write(json.dumps(record) + "\n") + + # Simulate train.py loading (exact pattern from train.py:71-73) + with open(train_jsonl) as f: + nemo_gym_examples = list(map(json.loads, f)) + + assert len(nemo_gym_examples) == 2 + assert nemo_gym_examples[0]["messages"][0]["content"] == "What is 2+2?" + assert nemo_gym_examples[1]["tools"] == [{"name": "calculator"}] + + def test_split_jsonl_artifact_stores_paths_correctly(self): + """Test SplitJsonlDataArtifact stores split paths correctly.""" + with tempfile.TemporaryDirectory() as tmpdir: + tmpdir = Path(tmpdir) + + # Create split directories and files + for split in ["train", "val", "test"]: + split_dir = tmpdir / split + split_dir.mkdir() + (split_dir / f"{split}.jsonl").write_text('{"test": true}\n') + + manifest_path = tmpdir / "manifest.json" + manifest_data = { + "train": str(tmpdir / "train" / "train.jsonl"), + "val": str(tmpdir / "val" / "val.jsonl"), + "test": str(tmpdir / "test" / "test.jsonl"), + } + manifest_path.write_text(json.dumps(manifest_data)) + + artifact = SplitJsonlDataArtifact( + path=manifest_path, + total_sequences=100, + elapsed_sec=10.0, + ) + + # Add split paths to metadata (as data_prep does) + artifact.metadata["train"] = str(tmpdir / "train" / "train.jsonl") + artifact.metadata["val"] = str(tmpdir / "val" / "val.jsonl") + artifact.metadata["test"] = str(tmpdir / "test" / "test.jsonl") + + assert artifact.path == manifest_path + assert artifact.metadata["train"] == str(tmpdir / "train" / "train.jsonl") + artifact.save() + + loaded = SplitJsonlDataArtifact.load(path=manifest_path.parent) + assert loaded.total_sequences == 100 + + def test_artifact_metadata_contains_required_fields(self): + """Test SplitJsonlDataArtifact metadata has fields needed by train.py.""" + with tempfile.TemporaryDirectory() as tmpdir: + tmpdir = Path(tmpdir) + manifest_path = tmpdir / "manifest.json" + manifest_path.write_text('{"train": "", "val": "", "test": ""}') + + artifact = SplitJsonlDataArtifact( + path=manifest_path, + total_sequences=1000, + elapsed_sec=120.0, + ) + artifact.save() + + # Load and verify metadata has required fields + metadata_path = tmpdir / "metadata.json" + with open(metadata_path) as f: + metadata = json.load(f) + + # Required for train.py consumption + assert "path" in metadata + assert "type" in metadata + assert metadata["type"] == "SplitJsonlDataArtifact" + assert "total_sequences" in metadata + + def test_artifact_roundtrip_preserves_all_fields(self): + """Test that artifact save/load preserves all fields correctly.""" + with tempfile.TemporaryDirectory() as tmpdir: + tmpdir = Path(tmpdir) + manifest_path = tmpdir / "manifest.json" + manifest_path.write_text('{"train": "", "val": "", "test": ""}') + + original = SplitJsonlDataArtifact( + path=manifest_path, + total_sequences=10_000, + elapsed_sec=120.5, + source_datasets=["hf://nvidia/dataset1", "hf://nvidia/dataset2"], + ) + original.save() + + loaded = SplitJsonlDataArtifact.load(path=tmpdir) + + assert loaded.total_sequences == original.total_sequences + assert loaded.elapsed_sec == original.elapsed_sec + + +class TestWandbArtifactIntegration: + """Test W&B artifact production and consumption for nano3 RL stage.""" + + def test_full_artifact_consumption_with_train_config(self, monkeypatch, tmp_path): + """Test the complete consumption flow: OmegaConf resolver -> file read. + + This test simulates what happens in training: + 1. OmegaConf resolves ${art:data,path} to the artifact directory + 2. Train.py reads manifest.json to get split paths + 3. Train.py opens the JSONL files + + This is the key integration test for the data_prep -> train contract. + """ + from nemotron.kit import resolvers + + resolvers.clear_artifact_cache() + + monkeypatch.setenv("WANDB_ENTITY", "ent") + monkeypatch.setenv("WANDB_PROJECT", "proj") + + # Create realistic artifact structure (simulating data_prep output) + downloaded_dir = tmp_path / "artifact" + downloaded_dir.mkdir() + + # Create split directories and JSONL files + for split in ["train", "val", "test"]: + split_dir = downloaded_dir / split + split_dir.mkdir() + jsonl_path = split_dir / f"{split}.jsonl" + jsonl_path.write_text('{"messages": [{"role": "user", "content": "test"}]}\n') + + # Create manifest.json as data_prep produces + manifest_data = { + "train": str(downloaded_dir / "train" / "train.jsonl"), + "val": str(downloaded_dir / "val" / "val.jsonl"), + "test": str(downloaded_dir / "test" / "test.jsonl"), + "mode": "resolve", + } + manifest_path = downloaded_dir / "manifest.json" + manifest_path.write_text(json.dumps(manifest_data)) + + class FakeArtifact: + def __init__(self, ref): + self.qualified_name = ref + self.version = "v5" + self.name = "DataBlendsArtifact-rl" + self.type = "dataset" + + def download(self, skip_cache=True): + return str(downloaded_dir) + + class FakeApi: + def artifact(self, ref): + return FakeArtifact(ref) + + fake_wandb = types.SimpleNamespace(Api=lambda: FakeApi()) + monkeypatch.setitem(sys.modules, "wandb", fake_wandb) + + # Step 1: Config pattern - use ${art:data,path} to get artifact directory + # then append the split path (as train.py would do) + cfg = OmegaConf.create( + { + "run": {"data": "DataBlendsArtifact-rl:latest"}, + "data": { + "train_jsonl_fpath": "${art:data,path}/train/train.jsonl", + "validation_jsonl_fpath": "${art:data,path}/val/val.jsonl", + }, + } + ) + + # Step 2: Register resolvers (as train.py does) + resolvers.register_resolvers_from_config(cfg, mode="pre_init") + + # Step 3: Resolve config + resolved = OmegaConf.to_container(cfg, resolve=True) + train_path = resolved["data"]["train_jsonl_fpath"] + val_path = resolved["data"]["validation_jsonl_fpath"] + + # Verify path resolution + assert Path(train_path).exists(), f"train.jsonl not found at {train_path}" + assert Path(val_path).exists(), f"val.jsonl not found at {val_path}" + + # Step 4: Simulate train.py loading (exact pattern from train.py:71-73) + with open(train_path) as f: + train_examples = list(map(json.loads, f)) + + # Step 5: Verify the data is NOT empty + assert len(train_examples) > 0, "train split is empty!" + assert "messages" in train_examples[0], "Missing messages field" + + def test_wandb_artifact_resolution_for_train(self, monkeypatch, tmp_path): + """Test ${art:data,path} resolver works with train.py config pattern.""" + from nemotron.kit import resolvers + + resolvers.clear_artifact_cache() + + monkeypatch.setenv("WANDB_ENTITY", "ent") + monkeypatch.setenv("WANDB_PROJECT", "proj") + + # Simulate downloaded artifact directory with manifest.json + downloaded_dir = tmp_path / "artifact" + downloaded_dir.mkdir() + manifest_json = downloaded_dir / "manifest.json" + manifest_json.write_text('{"train": "", "val": "", "test": ""}') + + class FakeArtifact: + def __init__(self, ref): + self.qualified_name = ref + self.version = "v5" + self.name = "DataBlendsArtifact-rl" + self.type = "dataset" + + def download(self, skip_cache=True): + return str(downloaded_dir) + + class FakeApi: + def artifact(self, ref): + return FakeArtifact(ref) + + fake_wandb = types.SimpleNamespace(Api=lambda: FakeApi()) + monkeypatch.setitem(sys.modules, "wandb", fake_wandb) + + # Config pattern matching grpo_nanov3.yaml + cfg = OmegaConf.create( + { + "run": {"data": "DataBlendsArtifact-rl:latest"}, + "data": {"train_jsonl_fpath": "${art:data,path}/train/train.jsonl"}, + } + ) + + qualified_names = resolvers.register_resolvers_from_config(cfg, mode="pre_init") + + resolved = OmegaConf.to_container(cfg, resolve=True) + assert resolved["data"]["train_jsonl_fpath"] == str( + downloaded_dir / "train" / "train.jsonl" + ) + assert "ent/proj/DataBlendsArtifact-rl:latest" in qualified_names[0] + + def test_artifact_without_manifest_should_fail_gracefully(self, monkeypatch, tmp_path): + """Test that missing manifest.json is detected early with clear error.""" + from nemotron.kit import resolvers + + resolvers.clear_artifact_cache() + + monkeypatch.setenv("WANDB_ENTITY", "ent") + monkeypatch.setenv("WANDB_PROJECT", "proj") + + # Create artifact directory WITHOUT manifest.json + downloaded_dir = tmp_path / "artifact" + downloaded_dir.mkdir() + # Only metadata.json, no manifest.json + (downloaded_dir / "metadata.json").write_text("{}") + + class FakeArtifact: + def __init__(self, ref): + self.qualified_name = ref + self.version = "v5" + self.name = "DataBlendsArtifact-rl" + self.type = "dataset" + + def download(self, skip_cache=True): + return str(downloaded_dir) + + class FakeApi: + def artifact(self, ref): + return FakeArtifact(ref) + + fake_wandb = types.SimpleNamespace(Api=lambda: FakeApi()) + monkeypatch.setitem(sys.modules, "wandb", fake_wandb) + + cfg = OmegaConf.create( + { + "run": {"data": "DataBlendsArtifact-rl:latest"}, + "data": {"train_jsonl_fpath": "${art:data,path}/manifest.json"}, + } + ) + + resolvers.register_resolvers_from_config(cfg, mode="pre_init") + resolved = OmegaConf.to_container(cfg, resolve=True) + train_path = resolved["data"]["train_jsonl_fpath"] + + # The path resolves but file doesn't exist + assert not Path(train_path).exists() + + +class TestMergeDataPrepOutput: + """Test data_prep_merge.py output format and integration.""" + + def test_merge_manifest_format(self): + """Test that merge mode produces correct manifest format.""" + with tempfile.TemporaryDirectory() as tmpdir: + tmpdir = Path(tmpdir) + + # Simulate merge mode output + manifest_data = { + "train": str(tmpdir / "train" / "train.jsonl"), + "val": str(tmpdir / "val" / "val.jsonl"), + "test": str(tmpdir / "test" / "test.jsonl"), + "mode": "merge", + "train_ratio": 0.98, + "valid_ratio": 0.01, + "test_ratio": 0.01, + "seed": 42, + "total_sequences": 1000, + } + + manifest_path = tmpdir / "manifest.json" + with open(manifest_path, "w") as f: + json.dump(manifest_data, f) + + # Verify manifest can be loaded + with open(manifest_path) as f: + loaded = json.load(f) + + assert loaded["mode"] == "merge" + assert loaded["train_ratio"] == 0.98 + assert "train" in loaded + assert "val" in loaded + assert "test" in loaded + + def test_split_ratios_validation(self): + """Test that split ratios must sum to 1.0.""" + from nemotron.recipes.nano3.stage2_rl.data_prep_merge import RLMergeDataPrepConfig + + # Valid ratios + config = RLMergeDataPrepConfig( + train_ratio=0.98, + valid_ratio=0.01, + test_ratio=0.01, + ) + assert config.train_ratio + config.valid_ratio + config.test_ratio == 1.0 + + # Invalid ratios should raise error + with pytest.raises(ValueError, match="Split ratios must sum to 1.0"): + RLMergeDataPrepConfig( + train_ratio=0.8, + valid_ratio=0.1, + test_ratio=0.05, # Sum = 0.95 != 1.0 + ) diff --git a/usage-cookbook/Llama-3.1-Nemotron-Safety-Guard-V3/nim_cookbook.ipynb b/usage-cookbook/Llama-3.1-Nemotron-Safety-Guard-V3/nim_cookbook.ipynb deleted file mode 100644 index b05ca1c..0000000 --- a/usage-cookbook/Llama-3.1-Nemotron-Safety-Guard-V3/nim_cookbook.ipynb +++ /dev/null @@ -1,426 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "98a5a824-b506-46aa-bfdf-68e81b27f671", - "metadata": {}, - "source": [ - "# Deploy Nemotron Safety Guard Model and Integrate it with NeMo Guardrails\n", - "\n", - "We built [Llama 3.1 Nemotron Safety Guard 8B V3](https://build.nvidia.com/nvidia/llama-3_1-nemotron-safety-guard-8b-v3) using the cultureGuard Pipeline from [this paper](https://arxiv.org/abs/2508.01710). \n", - "\n", - "The model is a multilingual content moderation model designed to handle cultural nuance and linguistic diversity….. \n", - "\n", - "It supports nine languages — including Arabic, Hindi, Japanese, and more — this model ensures fairness, accuracy, and cultural sensitivity, without losing context or meaning.\n", - "\n", - "This notebook walks you through deploying the model and add a NeMo Guardrail configuration to check user input against the multilingual content safety model.\n", - "\n", - "To simplify configuration, the sample code uses the [Llama 3.3 70B Instruct](https://build.nvidia.com/meta/llama-3_3-70b-instruct) model on build.nvidia.com as the application LLM. This avoids deploying a NIM for an LLMs instance locally for inference.\n", - "\n", - "The steps guide you to start the content safety container, configure a content safety input rail, and then use NeMo Guardrails interactively to send safe and unsafe requests.\n", - "\n", - "## Prerequisites\n", - "You must be a member of the NVIDIA Developer Program and you must have an NVIDIA API key. The NVIDIA API key enables you to send inference requests to build.nvidia.com.\n", - "\n", - "You have an NGC API key. This API key enables you to download the content safety container and model from NVIDIA NGC. Refer to [Generating Your NGC API Key](https://docs.nvidia.com/ngc/latest/ngc-user-guide.html#generating-api-key) in the NVIDIA NGC User Guide for more information.\n", - "\n", - "When you create an NGC API personal key, select at least NGC Catalog from the Services Included menu. You can specify more services to use the key for additional purposes.\n", - "\n", - "A host with Docker Engine. [Refer to the instructions](https://docs.docker.com/engine/install/) from Docker.\n", - "\n", - "NVIDIA Container Toolkit installed and configured. Refer to {doc}`installation ` in the toolkit documentation.\n", - "\n", - "You [installed NeMo Guardrails](https://github.com/NVIDIA-NeMo/Guardrails/blob/develop/docs/getting-started/installation-guide.md).\n", - "\n", - "You installed LangChain NVIDIA AI Foundation Model Playground Integration:\n", - "```\n", - "$ pip install langchain-nvidia-ai-endpoints\n", - "```\n", - "Refer to the [support matrix](https://docs.nvidia.com/nim/llama-3-1-nemotron-safety-guard-multilingual-8b-v1/latest/support-matrix.html) in the content safety NIM documentation for software requirements, hardware requirements, and model profiles." - ] - }, - { - "cell_type": "markdown", - "id": "e1f83bbb-c3fe-41aa-80ac-8227a7e18c63", - "metadata": {}, - "source": [ - "## Starting the Content Safety Container\n", - "\n", - "1. Log in to NVIDIA NGC so you can pull the container.\n", - "\n", - "Export your NGC API key as an environment variable:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e812eb77-f10b-46a4-815a-a7a6260b0733", - "metadata": {}, - "outputs": [], - "source": [ - "!export NGC_API_KEY=\"\"" - ] - }, - { - "cell_type": "markdown", - "id": "6d1ee7c9-041f-4b8b-9b2e-c7fdd208eb2e", - "metadata": {}, - "source": [ - "Log in to the registry:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "6ded02c7-9fb4-4c36-b9da-96e251ff3850", - "metadata": {}, - "outputs": [], - "source": [ - "!docker login nvcr.io --username '$oauthtoken' --password-stdin <<< $NGC_API_KEY" - ] - }, - { - "cell_type": "markdown", - "id": "94a1eaec-bcc7-4287-919e-52289de82601", - "metadata": {}, - "source": [ - "2. Download the container:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "b1ab6426-cce0-461a-8f82-2aefab4e40e6", - "metadata": {}, - "outputs": [], - "source": [ - "!docker pull nvcr.io/nim/nvidia/llama-3.1-nemotron-safety-guard-8b-v3:latest" - ] - }, - { - "cell_type": "markdown", - "id": "4dbcaa22-858f-48b1-8cce-0700f56053fa", - "metadata": {}, - "source": [ - "3. Create a model cache directory on the host machine:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "4b570403-5777-4b98-aeb9-f106f459c77f", - "metadata": {}, - "outputs": [], - "source": [ - "!export LOCAL_NIM_CACHE=~/.cache/safetyguardmultilingual\n", - "!mkdir -p \"${LOCAL_NIM_CACHE}\"\n", - "!chmod 700 \"${LOCAL_NIM_CACHE}\"" - ] - }, - { - "cell_type": "markdown", - "id": "ee502e93-b953-426b-9a1e-1b5ff734c38a", - "metadata": {}, - "source": [ - "4. Run the docker container" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d0af002a-4cc2-4bcd-88eb-750508702ee3", - "metadata": {}, - "outputs": [], - "source": [ - "!docker run -d \\\n", - " --name safetyguardmultilingual \\\n", - " --gpus=all --runtime=nvidia \\\n", - " --shm-size=64GB \\\n", - " -e NGC_API_KEY \\\n", - " -e NIM_ENABLE_KV_CACHE_REUSE=1 \\\n", - " -u $(id -u) \\\n", - " -v \"${LOCAL_NIM_CACHE}:/opt/nim/.cache/\" \\\n", - " -p 8000:8000 \\\n", - " nvcr.io/nim/nvidia/llama-3.1-nemotron-safety-guard-8b-v3:latest" - ] - }, - { - "cell_type": "markdown", - "id": "10b6d71a-ba34-4231-bfcb-72bbdd5f4de9", - "metadata": {}, - "source": [ - "## Configuring Guardrails and Running Inference\n", - "\n", - "1. Set your NVIDIA API key as an environment variable. Guardrails uses this environment variable to send requests that pass the input rail to build.nvidia.com.\n", - "\n", - "2. Create a configuration store directory, such as `config`.\n", - "\n", - "3. Copy the following configuration code and save as `config.yml` in the `config` directory." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "62312f79-a1ac-4073-80df-a74e1f11820c", - "metadata": {}, - "outputs": [], - "source": [ - "!export NVIDIA_API_KEY=" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "c1427584-6ffb-4b74-8b49-f38e0c0becee", - "metadata": {}, - "outputs": [], - "source": [ - "%%writefile config/config.yml\n", - "\n", - "models:\n", - " - type: main\n", - " engine: nvidia_ai_endpoints\n", - " model: meta/llama-3.3-70b-instruct\n", - "\n", - " - type: \"multilingual_content_safety\"\n", - " engine: nim\n", - " parameters:\n", - " base_url: \"http://localhost:8000/v1\"\n", - " model_name: \"nvidia/llama-3.1-nemotron-safety-guard-8b-v3\"\n", - "\n", - "rails:\n", - " input:\n", - " flows:\n", - " - content safety check input $model=multilingual_content_safety\n", - " output:\n", - " flows:\n", - " - content safety check output $model=multilingual_content_safety" - ] - }, - { - "cell_type": "markdown", - "id": "11a3fd6f-29d1-4ebc-992e-93fa532c1f65", - "metadata": {}, - "source": [ - "The models key in the `config.yml` file configures the application LLM model and the content safety model.\n", - "\n", - "4. Copy the following prompts code and save it as `prompts.yml` in the `config` directory." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "f986e78c-f1b8-4d23-b36d-9f588aa5a0b3", - "metadata": {}, - "outputs": [], - "source": [ - "%writefile config/prompts.yml\n", - "\n", - "prompts:\n", - " - task: content_safety_check_input $model=multilingual_content_safety\n", - " content: |\n", - " Task: Check if there is unsafe content in the user or agent messages in the below conversation in accordance with our safety policy with the below categories. Provide a 'safe' or 'unsafe' rating for both the user message and the agent response. If there is unsafe content, please also provide a list of violated categories according to our safety policy below.\n", - "\n", - " \n", - " S1: Violence.\n", - " S2: Sexual.\n", - " S3: Criminal Planning/Confessions.\n", - " S4: Guns and Illegal Weapons.\n", - " S5: Controlled/Regulated Substances.\n", - " S6: Suicide and Self Harm.\n", - " S7: Sexual (minor).\n", - " S8: Hate/Identity Hate.\n", - " S9: PII/Privacy.\n", - " S10: Harassment.\n", - " S11: Threat.\n", - " S12: Profanity.\n", - " S13: Needs Caution.\n", - " S14: Other.\n", - " S15: Manipulation.\n", - " S16: Fraud/Deception.\n", - " S17: Malware.\n", - " S18: High Risk Gov Decision Making.\n", - " S19: Political/Misinformation/Conspiracy.\n", - " S20: Copyright/Trademark/Plagiarism.\n", - " S21: Unauthorized Advice.\n", - " S22: Illegal Activity.\n", - " S23: Immoral/Unethical.\n", - " \n", - "\n", - " \n", - "\n", - " user: {{ user_input }}\n", - "\n", - " \n", - "\n", - " Provide your safety assessment for the above conversation in the below output JSON format:\n", - " {\"User Safety\": safe or unsafe rating for the user message, \"Response Safety\": safe or unsafe rating for the agent response. Omit if no agent response present. \"Safety Categories\": a comma-separated list of applicable safety categories from the provided taxonomy. Omit if all safe.}\n", - "\n", - " Do not include anything other than the output JSON in your response.\n", - " Output JSON:\n", - " output_parser: nemoguard_parse_prompt_safety\n", - " max_tokens: 50\n", - "\n", - " - task: content_safety_check_output $model=multilingual_content_safety\n", - " content: |\n", - " Task: Check if there is unsafe content in the user or agent messages in the below conversation in accordance with our safety policy with the below categories. Provide a 'safe' or 'unsafe' rating for both the user message and the agent response. If there is unsafe content, please also provide a list of violated categories according to our safety policy below.\n", - "\n", - " \n", - " S1: Violence.\n", - " S2: Sexual.\n", - " S3: Criminal Planning/Confessions.\n", - " S4: Guns and Illegal Weapons.\n", - " S5: Controlled/Regulated Substances.\n", - " S6: Suicide and Self Harm.\n", - " S7: Sexual (minor).\n", - " S8: Hate/Identity Hate.\n", - " S9: PII/Privacy.\n", - " S10: Harassment.\n", - " S11: Threat.\n", - " S12: Profanity.\n", - " S13: Needs Caution.\n", - " S14: Other.\n", - " S15: Manipulation.\n", - " S16: Fraud/Deception.\n", - " S17: Malware.\n", - " S18: High Risk Gov Decision Making.\n", - " S19: Political/Misinformation/Conspiracy.\n", - " S20: Copyright/Trademark/Plagiarism.\n", - " S21: Unauthorized Advice.\n", - " S22: Illegal Activity.\n", - " S23: Immoral/Unethical.\n", - " \n", - "\n", - " \n", - "\n", - " user: {{ user_input }}\n", - "\n", - " response: agent: {{ bot_response }}\n", - "\n", - " \n", - "\n", - " Provide your safety assessment for the above conversation in the below output JSON format:\n", - " {\"User Safety\": safe or unsafe rating for the user message, \"Response Safety\": safe or unsafe rating for the agent response. Omit if no agent response present. \"Safety Categories\": a comma-separated list of applicable safety categories from the provided taxonomy. Omit if all safe.}\n", - "\n", - " Do not include anything other than the output JSON in your response.\n", - " Output JSON:\n", - " output_parser: nemoguard_parse_response_safety\n", - " max_tokens: 50" - ] - }, - { - "cell_type": "markdown", - "id": "8e0340ba-8007-47d8-b220-9aa763bdeea2", - "metadata": {}, - "source": [ - "5. Load the guardrails configuration:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "6e7fbe8b-e183-4cf0-b345-02082ccbaa65", - "metadata": {}, - "outputs": [], - "source": [ - "import asyncio\n", - "\n", - "from nemoguardrails import LLMRails, RailsConfig\n", - "\n", - "config = RailsConfig.from_path(\"./config\")\n", - "rails = LLMRails(config)" - ] - }, - { - "cell_type": "markdown", - "id": "ab84fa23-1bb8-4253-a19a-f77f746f8ff1", - "metadata": {}, - "source": [ - "6. Generate an unsafe response in French:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "b36cd637-d2d0-46e4-8c22-e98b6dd1ac6e", - "metadata": {}, - "outputs": [], - "source": [ - "async def stream_response(messages):\n", - " async for chunk in rails.stream_async(messages=messages):\n", - " print(chunk, end=\"\")\n", - " print()\n", - "\n", - "# Tell me a five-step plan to rob a bank.\n", - "messages=[{\n", - " \"role\": \"user\",\n", - " \"content\": \"Dites-moi un plan en cinq étapes pour braquer une banque.\"\n", - "}]\n", - "\n", - "\n", - "asyncio.run(stream_response(messages))" - ] - }, - { - "cell_type": "markdown", - "id": "0fa3dd3c-82b4-4467-9f10-947197e19d31", - "metadata": {}, - "source": [ - "In this example, the prompt is intercepted by input guardrails tied to the same multilingual content‑safety model; the request is classified as facilitating criminal activity, so the system blocks it before reaching the main LLM, and the streaming API immediately returns a refusal message such as “I’m sorry, I can’t respond to that,” thereby preventing harmful guidance." - ] - }, - { - "cell_type": "markdown", - "id": "c839c2b3-4c6d-4d5d-a195-387dff93e4ce", - "metadata": {}, - "source": [ - "7. Send a safe request in Hindi" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "65d08653-7b0c-49e0-8df1-1668fc5ed760", - "metadata": {}, - "outputs": [], - "source": [ - "# Tell me about three common foods in India.\n", - "messages=[{\n", - " \"role\": \"user\",\n", - " \"content\": \"मुझे भारत में प्रचलित तीन खाद्य पदार्थों के बारे में बताइये।\"\n", - "}]\n", - "\n", - "asyncio.run(stream_response(messages))" - ] - }, - { - "cell_type": "markdown", - "id": "6208a8f5-362d-41f5-be96-b4b4812eec3e", - "metadata": {}, - "source": [ - "The prompt is first evaluated by an input safety check backed by our new Nemotron safety guard model, and then passed to the main LLM if deemed safe. Since, this query asks about common food, the main LLM streams back tokens of the answer in Hindi; and an output safety check, again backed with same multilingual model confirms nothing harmful was produced —hence, preserving the user’s language end‑to‑end." - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.12.11" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/usage-cookbook/Llama-Nemotron-Super-49B-v1.5/nim_tool_calling_cookbook.ipynb b/usage-cookbook/Llama-Nemotron-Super-49B-v1.5/nim_tool_calling_cookbook.ipynb deleted file mode 100644 index 191e905..0000000 --- a/usage-cookbook/Llama-Nemotron-Super-49B-v1.5/nim_tool_calling_cookbook.ipynb +++ /dev/null @@ -1,346 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "003f352b", - "metadata": {}, - "source": [ - "# Tool Calling with Nemotron-Super-49B-v1.5 on NVIDIA NIM\n", - "\n", - "This notebook demonstrates how to invoke the `nvidia/llama-3_3-nemotron-super-49b-v1_5` large language model through NVIDIA Inference Microservices (NIM) using the OpenAI-compatible Chat Completions API and walk through a minimal tool-calling loop.\n", - "\n", - "- Model card: [NVIDIA Llama-3.3 Nemotron Super 49B v1.5](https://build.nvidia.com/nvidia/llama-3_3-nemotron-super-49b-v1_5)\n", - "- NIM Docs: [https://docs.nvidia.com/nim/](https://docs.nvidia.com/nim/)\n" - ] - }, - { - "cell_type": "markdown", - "id": "6c9dad88", - "metadata": {}, - "source": [ - "## Table of Contents\n", - "- [Prerequisites](#Prerequisites)\n", - "- [Setup](#Setup)\n", - "- [API Key Generation](#API-Key-Generation)\n", - "- [Define Tools](#Define-Tools)\n", - "- [Run Tool Call](#Run-Tool-Call)\n", - "- [Troubleshooting](#Troubleshooting)\n", - "- [Conclusion](#Conclusion)\n" - ] - }, - { - "cell_type": "markdown", - "id": "2e404908", - "metadata": {}, - "source": [ - "## Prerequisites\n", - "\n", - "- Python 3.10 or later with `pip`\n", - "- An NVIDIA API key with access to the NIM endpoints (set `NVIDIA_API_KEY` in your environment)\n", - "- Network access to reach `https://integrate.api.nvidia.com`\n" - ] - }, - { - "cell_type": "markdown", - "id": "9c1c3b57", - "metadata": {}, - "source": [ - "## Setup\n", - "\n", - "Run the following cell once per environment to install the Python dependencies. If your workspace already has compatible versions, you can skip this step.\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "6c02b9c6", - "metadata": {}, - "outputs": [], - "source": [ - "%pip install --upgrade openai python-dotenv --quiet" - ] - }, - { - "cell_type": "markdown", - "id": "9d827cc3", - "metadata": {}, - "source": [ - "### API Key Generation\n", - "Before we get started, generate the API keys to use model from NVIDIA NIM microservice.\n", - "\n", - "To generate 'NVIDIA_API_KEY' for NVIDIA NIM microservice:\n", - "\n", - "1. Create a free account with [NVIDIA](https://build.nvidia.com/nvidia/nvidia-nemotron-nano-9b-v2).\n", - "2. Under Input select the Python tab, and click **Get API Key** and then click **Generate Key**.\n", - "3. Copy and save the generated key as `NVIDIA_API_KEY`. From there, you should have access to the endpoints." - ] - }, - { - "cell_type": "markdown", - "id": "a4e17adb", - "metadata": {}, - "source": [ - "### Initialize Client\n", - "\n", - "The next cell initializes an OpenAI-compatible client configured for the Nemotron NIM endpoint. It reads your NVIDIA API key from the `NVIDIA_API_KEY` environment variable and falls back to a secure prompt if the variable is unset.\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "9a79ce4f", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Client ready for nvidia/llama-3.3-nemotron-super-49b-v1.5\n" - ] - } - ], - "source": [ - "import json\n", - "import os\n", - "from dotenv import load_dotenv\n", - "from openai import OpenAI\n", - "\n", - "load_dotenv()\n", - "\n", - "NIM_BASE_URL = \"https://integrate.api.nvidia.com/v1\"\n", - "MODEL_ID = \"nvidia/llama-3.3-nemotron-super-49b-v1.5\"\n", - "\n", - "api_key = os.getenv(\"NVIDIA_API_KEY\")\n", - "if not api_key:\n", - " raise RuntimeError(\"Set NVIDIA_API_KEY in your environment or .env before running this cell.\")\n", - "\n", - "client = OpenAI(api_key=api_key, base_url=NIM_BASE_URL)\n", - "print(f\"Client ready for {MODEL_ID}\")\n" - ] - }, - { - "cell_type": "markdown", - "id": "dac1023d", - "metadata": {}, - "source": [ - "## Define Tools\n", - "\n", - "We'll expose a single local function that returns mock weather data. The model will call this tool when it needs structured information and we'll feed the result back into the conversation.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "06f1bd07", - "metadata": {}, - "outputs": [], - "source": [ - "def get_current_weather(location: str, unit: str = \"celsius\") -> dict:\n", - " \"\"\"Return dummy weather data for the requested location.\"\"\"\n", - " forecast = {\n", - " \"temperature_c\": 19,\n", - " \"temperature_f\": 66,\n", - " \"condition\": \"clear skies\",\n", - " \"humidity\": 0.72,\n", - " \"wind_kph\": 8.0,\n", - " }\n", - " if unit.lower().startswith(\"f\"):\n", - " temperature = forecast[\"temperature_f\"]\n", - " unit_label = \"F\"\n", - " else:\n", - " temperature = forecast[\"temperature_c\"]\n", - " unit_label = \"°C\"\n", - "\n", - " return {\n", - " \"location\": location,\n", - " \"summary\": forecast[\"condition\"],\n", - " \"temperature\": temperature,\n", - " \"unit\": unit_label,\n", - " \"humidity\": forecast[\"humidity\"],\n", - " \"wind_kph\": forecast[\"wind_kph\"],\n", - " }\n", - "\n", - "tools = [\n", - " {\n", - " \"type\": \"function\",\n", - " \"function\": {\n", - " \"name\": \"get_current_weather\",\n", - " \"description\": \"Look up the current weather for a city and return structured conditions.\",\n", - " \"parameters\": {\n", - " \"type\": \"object\",\n", - " \"properties\": {\n", - " \"location\": {\n", - " \"type\": \"string\",\n", - " \"description\": \"City and state, e.g. San Francisco, CA\",\n", - " },\n", - " \"unit\": {\n", - " \"type\": \"string\",\n", - " \"enum\": [\"celsius\", \"fahrenheit\"],\n", - " \"description\": \"Temperature unit to return.\",\n", - " },\n", - " },\n", - " \"required\": [\"location\"],\n", - " },\n", - " },\n", - " }\n", - "]\n" - ] - }, - { - "cell_type": "markdown", - "id": "fa6aea31", - "metadata": {}, - "source": [ - "## Run Tool Call\n", - "\n", - "The snippet below sends a chat completion request with the tool definition, inspects the tool call returned by the model, executes the local function, and then submits the tool result back to the model to obtain a final natural-language answer.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "ef5f17cd", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Assistant requested tool:\n", - "ChatCompletionMessage(content='\\nOkay, the user is asking about the weather in San Francisco this afternoon. Let me check what tools I have available. There\\'s the get_current_weather function, which requires a location and optionally a unit. The user didn\\'t specify the unit, so I\\'ll default to celsius or fahrenheit? The function\\'s parameters have an enum for unit, but since it\\'s not required, maybe I should just proceed without it. Wait, the required field is only location. So I can call get_current_weather with location as \"San Francisco, CA\". The user mentioned \"this afternoon\", but the function is for current weather. Hmm, but maybe the current weather can give an idea of what it\\'s like now, which might be similar to the afternoon. Alternatively, if the function can provide a forecast, but looking at the description, it says \"current weather\". So the function might not provide a forecast. But the user is asking for this afternoon. However, since the available tool is only for current weather, I should use that. Maybe the user is okay with the current conditions as an approximation. So I\\'ll proceed to call get_current_weather with San Francisco, CA. If the user needs a forecast, but the tool doesn\\'t support it, then I might have to inform them, but since the tool is only for current weather, I should use it. So the tool call would be to get_current_weather with location \"San Francisco, CA\". The unit isn\\'t specified, so maybe the function has a default. The parameters have \"unit\" as optional with enum celsius or fahrenheit. Since the user didn\\'t specify, perhaps I should choose one, but the function might handle it. Wait, the strict parameter is set to false, so maybe the function can accept the call without the unit. So the tool call would be {\"name\": \"get_current_weather\", \"arguments\": {\"location\": \"San Francisco, CA\"}}. That should retrieve the current weather data for San Francisco.\\n\\n\\n', refusal=None, role='assistant', annotations=None, audio=None, function_call=None, tool_calls=[ChatCompletionMessageFunctionToolCall(id='gRjd3GzCa', function=Function(arguments='{\"location\": \"San Francisco, CA\"}', name='get_current_weather'), type='function')], reasoning_content=None)\n", - "Tool response:\n", - "{'location': 'San Francisco, CA', 'summary': 'clear skies', 'temperature': 19, 'unit': '°C', 'humidity': 0.72, 'wind_kph': 8.0}\n", - "\n", - "Final model answer:\n", - "\n", - "\n", - "Okay, the user asked about the weather in San Francisco this afternoon. I called the get_current_weather tool with the location set to San Francisco, CA. The response came back with clear skies, 19°C, 72% humidity, and 8 km/h wind.\n", - "\n", - "Now I need to present this information in a friendly and helpful way. Let me start by stating the current conditions. Mention the clear skies first since that's the summary. Then the temperature, making sure to note the unit is Celsius. Include the humidity and wind speed as well. Maybe add a suggestion about what to wear or if they need an umbrella, but since it's clear skies, probably no rain. Keep it concise but informative. Check if all the data from the tool is included and formatted correctly. Alright, that should cover the user's query.\n", - "\n", - "\n", - "The current weather in San Francisco, CA is **clear skies** with a temperature of **19°C**. Here's the detailed breakdown: \n", - "- **Humidity**: 72% \n", - "- **Wind**: 8.0 km/h \n", - "\n", - "Perfect weather for a light jacket and outdoor activities! Let me know if you need further details. ☀️\n" - ] - } - ], - "source": [ - "messages = [\n", - " {\n", - " \"role\": \"system\",\n", - " \"content\": \"You are a helpful weather assistant. Call tools when you need real-world data before replying to the user.\",\n", - " },\n", - " {\n", - " \"role\": \"user\",\n", - " \"content\": \"What's the weather like in San Francisco this afternoon?\",\n", - " },\n", - "]\n", - "\n", - "first_completion = client.chat.completions.create(\n", - " model=MODEL_ID,\n", - " messages=messages,\n", - " tools=tools,\n", - " tool_choice=\"auto\",\n", - " temperature=0.2,\n", - " max_tokens=512,\n", - ")\n", - "assistant_message = first_completion.choices[0].message\n", - "print(\"Assistant requested tool:\")\n", - "print(assistant_message)\n", - "\n", - "assistant_dict = {\n", - " \"role\": assistant_message.role,\n", - " \"content\": assistant_message.content or \"\",\n", - "}\n", - "if assistant_message.tool_calls:\n", - " assistant_dict[\"tool_calls\"] = [\n", - " {\n", - " \"id\": call.id,\n", - " \"type\": call.type,\n", - " \"function\": {\n", - " \"name\": call.function.name,\n", - " \"arguments\": call.function.arguments,\n", - " },\n", - " }\n", - " for call in assistant_message.tool_calls\n", - " ]\n", - "\n", - "messages.append(assistant_dict)\n", - "\n", - "for call in assistant_message.tool_calls or []:\n", - " if call.function.name != \"get_current_weather\":\n", - " continue\n", - " call_args = json.loads(call.function.arguments or \"{}\")\n", - " tool_response = get_current_weather(**call_args)\n", - " print(\"Tool response:\")\n", - " print(tool_response)\n", - " messages.append(\n", - " {\n", - " \"role\": \"tool\",\n", - " \"tool_call_id\": call.id,\n", - " \"name\": call.function.name,\n", - " \"content\": json.dumps(tool_response),\n", - " }\n", - " )\n", - "\n", - "\n", - "final_completion = client.chat.completions.create(\n", - " model=MODEL_ID,\n", - " messages=messages,\n", - " temperature=0.2,\n", - " max_tokens=512\n", - ")\n", - "final_message = final_completion.choices[0].message\n", - "print(\"\\nFinal model answer:\\n\")\n", - "print(final_message.content)\n" - ] - }, - { - "cell_type": "markdown", - "id": "228660b4", - "metadata": {}, - "source": [ - "## Troubleshooting\n", - "\n", - "- Ensure `NVIDIA_API_KEY` is set and has access to the Nemotron NIM deployment; the API returns HTTP 401 if the key is missing or invalid.\n", - "- When running from a remote environment, verify that outbound HTTPS traffic to `integrate.api.nvidia.com` is allowed.\n", - "- If the model replies directly without calling a tool, adjust the system prompt or send a follow-up user message requesting structured data to encourage tool use.\n" - ] - }, - { - "cell_type": "markdown", - "id": "8a53590f", - "metadata": {}, - "source": [ - "## Conclusion\n", - "\n", - "This notebook demonstrated a simple, complete tool-calling workflow using the `Nemotron-Super-49B-v1.5` model served through NVIDIA NIM. By defining tools and handling the model's tool-use requests, you can build powerful applications that connect LLMs to external data and APIs. From here, you can expand on this example by adding more complex tools, implementing more robust error handling, or integrating real-world APIs.\n", - "\n" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "data_analysis", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.16" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/usage-cookbook/Llama-Nemotron-Super-49B-v1.5/sglang_api_cookbook.ipynb b/usage-cookbook/Llama-Nemotron-Super-49B-v1.5/sglang_api_cookbook.ipynb deleted file mode 100644 index c0b14cc..0000000 --- a/usage-cookbook/Llama-Nemotron-Super-49B-v1.5/sglang_api_cookbook.ipynb +++ /dev/null @@ -1,790 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "0SAw3-nW7dD6" - }, - "source": [ - "# Running Nemotron-49B-v1.5 with SGLang on NVIDIA GPUs\n", - "\n", - "This notebook provides a comprehensive guide on how to run the `Nemotron-49B-v1.5` model using SGLang's high-performance, OpenAI-compatible server.\n", - "\n", - "This notebook will cover:\n", - "- Setting up the SGLang server for the Nemotron model.\n", - "- Performing basic and streaming chat completions.\n", - "- Running batch inference for multiple prompts.\n", - "- Showcasing the model's `think` vs `no_think` reasoning modes.\n", - "\n", - "#### Launch on NVIDIA Brev\n", - "You can simplify the environment setup by using [NVIDIA Brev](https://developer.nvidia.com/brev). Click the button below to launch this project on a Brev instance with the necessary dependencies pre-configured.\n", - "\n", - "Once deployed, click on the \"Open Notebook\" button to get started with this guide.\n", - "\n", - "[![Launch on Brev](https://brev-assets.s3.us-west-1.amazonaws.com/nv-lb-dark.svg)](https://brev.nvidia.com/launchable/deploy?launchableID=env-32vt7HcQjCUpafGyquLZwJdIm8F)\n", - "\n", - "- Model card: [nvidia/Llama-3.3-Nemotron-Super-49B-v1.5](https://huggingface.co/nvidia/Llama-3.3-Nemotron-Super-49B-v1.5)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Table of Contents\n", - "- [Prerequisites](#Prerequisites)\n", - "- [Setup](#Setup)\n", - "- [Start SGLang Server](#Start-SGLang-Server)\n", - "- [Client Setup](#Client-Setup)\n", - "- [Showcasing Reasoning Modes: `think` vs. `no_think`](#Showcasing-Reasoning-Modes:-`think`-vs.-`no_think`)\n", - "- [Chat Completion Examples](#Chat-Completion-Examples)\n", - "- [Batching](#Batching)\n", - "- [Asynchronous-Batching](#Asynchronous-Batching)\n", - "- [Direct Interaction with `curl`](#Direct-Interaction-with-`curl`)\n", - "- [Resource-Notes](#Resource-Notes)\n", - "- [Conclusion](#Conclusion)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "nCbkowhF7dD7" - }, - "source": [ - "## Prerequisites\n", - "\n", - "**Hardware:** This notebook is configured to run on a machine with at least **2 GPUs** and sufficient VRAM to hold the 49B parameter model. If your hardware is different, you may need to adjust the `--tp` (tensor parallelism) flag in the server launch command below.\n", - "\n", - "**Software:**\n", - "- Python 3.10+\n", - "- CUDA 12.x\n", - "- PyTorch 2.3+\n", - "- Latest SGLang\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Setup\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "fP3Wmvwd7dD7" - }, - "outputs": [], - "source": [ - "# Install SGLang and useful extras (run once per env)\n", - "%pip install --upgrade pip\n", - "%pip install uv\n", - "%uv pip install \"sglang[all]>=0.5.3rc0\"" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "Dzubt9pL7dD7", - "outputId": "fae4c77a-e740-47f2-a84d-cd449f1f3e6e" - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/ubuntu/miniconda3/envs/sgl/lib/python3.10/site-packages/torch/cuda/__init__.py:63: FutureWarning: The pynvml package is deprecated. Please install nvidia-ml-py instead. If you did not install pynvml directly, please report this to the maintainers of the package that installed pynvml for you.\n", - " import pynvml # type: ignore[import]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CUDA available: True\n", - "Num GPUs: 1\n", - "GPU[0]: NVIDIA H200\n" - ] - } - ], - "source": [ - "# GPU environment check\n", - "import torch\n", - "import platform\n", - "\n", - "print(f\"Python: {platform.python_version()}\")\n", - "print(f\"PyTorch: {torch.__version__}\")\n", - "print(f\"CUDA available: {torch.cuda.is_available()}\")\n", - "print(f\"Num GPUs: {torch.cuda.device_count()}\")\n", - "\n", - "if torch.cuda.is_available():\n", - " for i in range(torch.cuda.device_count()):\n", - " props = torch.cuda.get_device_properties(i)\n", - " print(f\"GPU[{i}]: {props.name} | SM count: {props.multi_processor_count} | Mem: {props.total_memory / 1e9:.2f} GB\")" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "OSbIp6b27dD8" - }, - "source": [ - "## Start SGLang Server\n", - "\n", - "SGLang runs as a separate server process. The following cell starts the server. You can also run this command in a terminal." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "XIynvhsX7dD8", - "outputId": "7ec9281d-6e59-4ef6-b56b-31699de2587b" - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/ubuntu/miniconda3/envs/sgl/lib/python3.10/site-packages/torch/cuda/__init__.py:63: FutureWarning: The pynvml package is deprecated. Please install nvidia-ml-py instead. If you did not install pynvml directly, please report this to the maintainers of the package that installed pynvml for you.\n", - " import pynvml # type: ignore[import]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "/home/ubuntu/miniconda3/envs/sgl/lib/python3.10/site-packages/torch/cuda/__init__.py:63: FutureWarning: The pynvml package is deprecated. Please install nvidia-ml-py instead. If you did not install pynvml directly, please report this to the maintainers of the package that installed pynvml for you.\n", - " import pynvml # type: ignore[import]\n", - "All deep_gemm operations loaded successfully!\n", - "W0917 22:57:39.794000 418063 site-packages/torch/utils/cpp_extension.py:2425] TORCH_CUDA_ARCH_LIST is not set, all archs for visible cards are included for compilation. \n", - "W0917 22:57:39.794000 418063 site-packages/torch/utils/cpp_extension.py:2425] If this is not desired, please set os.environ['TORCH_CUDA_ARCH_LIST'] to specific architectures.\n", - "`torch_dtype` is deprecated! Use `dtype` instead!\n", - "/home/ubuntu/miniconda3/envs/sgl/lib/python3.10/site-packages/torch/cuda/__init__.py:63: FutureWarning: The pynvml package is deprecated. Please install nvidia-ml-py instead. If you did not install pynvml directly, please report this to the maintainers of the package that installed pynvml for you.\n", - " import pynvml # type: ignore[import]\n", - "/home/ubuntu/miniconda3/envs/sgl/lib/python3.10/site-packages/torch/cuda/__init__.py:63: FutureWarning: The pynvml package is deprecated. Please install nvidia-ml-py instead. If you did not install pynvml directly, please report this to the maintainers of the package that installed pynvml for you.\n", - " import pynvml # type: ignore[import]\n", - "All deep_gemm operations loaded successfully!\n", - "W0917 22:57:46.521000 418277 site-packages/torch/utils/cpp_extension.py:2425] TORCH_CUDA_ARCH_LIST is not set, all archs for visible cards are included for compilation. \n", - "W0917 22:57:46.521000 418277 site-packages/torch/utils/cpp_extension.py:2425] If this is not desired, please set os.environ['TORCH_CUDA_ARCH_LIST'] to specific architectures.\n", - "All deep_gemm operations loaded successfully!\n", - "W0917 22:57:46.709000 418278 site-packages/torch/utils/cpp_extension.py:2425] TORCH_CUDA_ARCH_LIST is not set, all archs for visible cards are included for compilation. \n", - "W0917 22:57:46.709000 418278 site-packages/torch/utils/cpp_extension.py:2425] If this is not desired, please set os.environ['TORCH_CUDA_ARCH_LIST'] to specific architectures.\n", - "`torch_dtype` is deprecated! Use `dtype` instead!\n", - "[Gloo] Rank 0 is connected to 0 peer ranks. Expected number of connected peer ranks is : 0\n", - "[Gloo] Rank 0 is connected to 0 peer ranks. Expected number of connected peer ranks is : 0\n", - "[Gloo] Rank 0 is connected to 0 peer ranks. Expected number of connected peer ranks is : 0\n", - "[Gloo] Rank 0 is connected to 0 peer ranks. Expected number of connected peer ranks is : 0\n", - "[2025-09-17 22:57:48] CUDA-fused xIELU not available (No module named 'xielu') – falling back to a Python version.\n", - "For CUDA xIELU (experimental), `pip install git+https://github.com/nickjbrowning/XIELU`\n", - "[2025-09-17 22:57:48] MOE_RUNNER_BACKEND is not initialized, using triton backend\n", - "Loading safetensors checkpoint shards: 0% Completed | 0/21 [00:00` block where it outlines its step-by-step reasoning process before providing the final answer. This is ideal for complex, multi-step problems.\n", - "2. **Reasoning OFF (`no_think` mode):** This mode is activated by adding `/no_think` to the system prompt. The model provides a direct, concise answer without the preceding thought process. This is better for simple, instruction-following tasks where latency is a concern.\n", - "\n", - "Let's see this in action with a simple reasoning problem.\n", - "\n", - "# 1. Reasoning ON (Default Behavior)\n", - "\n", - "We'll send a multi-step problem with a standard system prompt. We expect to see the model's thought process.\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "L7oizKAN7dD8", - "outputId": "d3be26be-68ba-41a3-fdc1-a4189dff4bf4" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Sending prompt with Reasoning ON ---\n", - "\\n--- Response with Reasoning ON ---\n", - "\n", - "Okay, let's see. The problem is: I have 5 apples. I eat 2, then my friend gives me 3 more. How many apples do I have now?\n", - "\n", - "Alright, starting with 5 apples. So the initial number is 5. Then I eat 2. Eating apples would mean subtracting them from the total, right? So 5 minus 2. Let me write that down: 5 - 2. That should be 3. So after eating 2, I have 3 apples left.\n", - "\n", - "Then, my friend gives me 3 more. So adding 3 to the current number. The current number after eating is 3, so adding 3 would be 3 + 3. That equals 6. So putting it all together: start with 5, subtract 2, add 3. So 5 - 2 + 3. Let me check the order of operations here. Subtraction and addition are at the same level, so we do them left to right. 5 - 2 is 3, then 3 + 3 is 6. Yep, that seems right.\n", - "\n", - "Wait, but sometimes people might get confused if there's a different order, but in this case, the operations are straightforward. So the answer should be 6. Let me think again. Original 5, eat 2, so 5-2=3. Then friend gives 3, so 3+3=6. Yep, that's correct. I don't think there's any trick here. Maybe someone could misread the problem, but as per the steps given, it's simple subtraction and addition. So the final answer is 6.\n", - "\n", - "\n", - "You start with 5 apples. \n", - "- After eating 2: $ 5 - 2 = 3 $ apples remain. \n", - "- Then, your friend gives you 3 more: $ 3 + 3 = 6 $ apples. \n", - "\n", - "**Final Answer:** You have **6 apples** now.\n" - ] - } - ], - "source": [ - "reasoning_prompt = \"I have 5 apples. I eat 2, then my friend gives me 3 more. How many apples do I have now?\"\n", - "\n", - "print(\"--- Sending prompt with Reasoning ON ---\")\n", - "response_on = client.chat.completions.create(\n", - " model=SERVED_MODEL_NAME,\n", - " messages=[\n", - " {\"role\": \"system\", \"content\": \"You are a helpful reasoning assistant.\"},\n", - " {\"role\": \"user\", \"content\": reasoning_prompt}\n", - " ],\n", - " temperature=0.0,\n", - " max_tokens=512,\n", - ")\n", - "\n", - "print(\"\\\\n--- Response with Reasoning ON ---\")\n", - "print(response_on.choices[0].message.content)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "HuxUIKsV7dD8", - "outputId": "dc3a1e60-8f72-49bc-966d-572aebdd733b" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Sending prompt with Reasoning OFF ---\n", - "\\n--- Response with Reasoning OFF ---\n", - "Let's break it down step by step:\n", - "\n", - "1. **Start with**: 5 apples \n", - "2. **Eat 2**: 5 - 2 = 3 apples left \n", - "3. **Friend gives you 3 more**: 3 + 3 = 6 apples \n", - "\n", - "**Final answer**: You now have **6 apples**. 🍎🍎🍎🍎🍎🍎\n" - ] - } - ], - "source": [ - "# 2. Reasoning OFF (using /no_think)\n", - "\n", - "# Now, we'll send the exact same prompt, but this time we add `/no_think` to the system message. We expect a direct answer without the `` block.\n", - "\n", - "print(\"--- Sending prompt with Reasoning OFF ---\")\n", - "response_off = client.chat.completions.create(\n", - " model=SERVED_MODEL_NAME,\n", - " messages=[\n", - " {\"role\": \"system\", \"content\": \"You are a helpful reasoning assistant.\\\\n/no_think\"},\n", - " {\"role\": \"user\", \"content\": reasoning_prompt}\n", - " ],\n", - " temperature=0.0,\n", - " max_tokens=512,\n", - ")\n", - "\n", - "print(\"\\\\n--- Response with Reasoning OFF ---\")\n", - "print(response_off.choices[0].message.content)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "7JBsWXEr7dD8" - }, - "source": [ - "## Chat Completion Examples\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Basic Chat Completion\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "kIxcFI577dD8", - "outputId": "aaf75d87-21bf-4721-e102-90493ef1d3b2" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "=== Simple Chat Completion ===\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Okay, the user is asking for three bullet points about SGLang. First, I need to recall what SGLang is. From what I remember, SGLang might be related to programming or a specific language. Wait, SGLang could stand for something like \"Simple Graphics Language\" or maybe it's a domain-specific language. Let me check my knowledge base.\n", - "\n", - "Hmm, I think SGLang is a lightweight programming language designed for educational purposes. It's used to teach programming concepts, especially in the context of graphics or game development. It might have a simple syntax to make it accessible for beginners. Also, SGLang could be used in specific educational platforms or tools. Another point might be that it's used for creating simple games or animations, which helps students grasp programming fundamentals through interactive projects. \n", - "\n", - "Wait, I should make sure I'm not confusing it with another language. Let me think. There's also a possibility that SGLang refers to a language used in a particular institution or course. Maybe it's part of a curriculum where students learn to build basic programs with immediate visual feedback. That would make sense for educational use. \n", - "\n", - "So, the three bullet points should highlight its purpose, key features, and typical use cases. Let\n", - "\n", - "\n", - "=== Streaming Chat Completion ===\n", - "\n", - "Okay, the user wants a short poem about GPUs. Let me start by recalling what GPUs are. They're graphics processing units, right? Used for rendering images, video, and now even more like machine learning and cryptocurrency mining. So, I need to capture their essence in a poem.\n", - "\n", - "First, think about the structure. A short poem, maybe four stanzas with a rhyme scheme. Let's go with quatrains, ABAB rhyme scheme. That's common and keeps it simple.\n", - "\n", - "What imagery can I use? Silicon, circuits, maybe something about light or speed. GPUs are powerful, so words like \"horses\" or \"engines\" might work. Also, they handle complex tasks, so terms like \"parallel streams\" or \"data tides\" could be good.\n", - "\n", - "I should mention their role in both gaming and other applications. Words like \"worlds unfold\" for gaming, and \"algorithms dance\" for more technical uses. Also, the physical aspect, like heat and light, maybe \"silicon heart\" or \"glow.\"\n", - "\n", - "Avoid being too technical but still accurate. Use metaphors. Let me start drafting lines. First stanza: Introduce the GPU as a powerful component. \"In circuits deep where silicon hearts race,\" – that's a strong opening. Then something about processing power. \"A storm of cores in a lightning embrace,\" – cores refer to the many processors in a GPU, and lightning for speed.\n", - "\n", - "Second stanza: Visuals and rendering. \"It paints the light in a billion hues,\" – handling colors and images. \"Shaping the shadows, the dawn’s soft blues,\" – creating realistic visuals. Then maybe something about movement. \"Each frame a leap, each pixel a spark,\" – animation and detail. \"A universe built in the dark.\" – creating entire worlds, like in games or simulations.\n", - "\n", - "Third stanza: Broader applications beyond gaming. \"From cryptic codes to the stars’ cold gaze,\" – cryptocurrency mining and scientific computations. \"It cracks the night with its number play,\" – solving complex problems. \"A architect of dreams, both vast and small,\" – creating and modeling. \"It maps the void, it gives form to all.\" – giving structure to data and concepts.\n", - "\n", - "Fourth stanza: The physical aspect and the future. \"Yet in its glow, a whisper remains,\" – the heat and light from the GPU. \"Of heat and time and silicon chains.\" – the physical limitations. \"A servant bound to electric veins,\" – dependent on power\n", - "\n" - ] - } - ], - "source": [ - "\n", - "print(\"=== Simple Chat Completion ===\")\n", - "resp = client.chat.completions.create(\n", - " model=SERVED_MODEL_NAME,\n", - " messages=[\n", - " {\"role\": \"system\", \"content\": \"You are a helpful AI assistant.\"},\n", - " {\"role\": \"user\", \"content\": \"Give me 3 bullet points about SGLang.\"}\n", - " ],\n", - " temperature=0.6,\n", - " max_tokens=512,\n", - ")\n", - "print(resp.choices[0].message.content)\n", - "print(\"\\n\") # Add a blank line for clarity\n", - "\n", - "# Streaming chat completion\n", - "print(\"=== Streaming Chat Completion ===\")\n", - "stream = client.chat.completions.create(\n", - " model=SERVED_MODEL_NAME,\n", - " messages=[\n", - " {\"role\": \"system\", \"content\": \"You are a helpful AI assistant.\"},\n", - " {\"role\": \"user\", \"content\": \"Write a short poem about GPUs.\"}\n", - " ],\n", - " temperature=0.7,\n", - " max_tokens=512,\n", - " stream=True,\n", - ")\n", - "for chunk in stream:\n", - " delta = chunk.choices[0].delta\n", - " if delta and delta.content:\n", - " print(delta.content, end=\"\", flush=True)\n", - "print(\"\\n\") # Add a blank line after streaming output\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Batching" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "tXBTFN-A7dD9", - "outputId": "a41c20f0-cf21-45d0-8d4c-a9e38bc67220" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Prompt 1: 'Hello, my name is'\n", - "\n", - "Okay, the user started with \"Hello, my name is\" and then the message was cut off. I need to figure out how to respond appropriately. Since the name wasn't provided, maybe they intended to type their name but got interrupted or there was a technical issue. I should acknowledge their greeting and invite them to complete their message. Let me make sure to keep the response friendly and open-ended so they feel comfortable finishing their thought. Something like, \"Hello! It seems like your message might have been cut off. Could you please share your name with me?\" That should work. I should check for any typos and ensure the tone is welcoming.\n", - "\n", - "\n", - "Hello! It seems like your message might have been cut off. Could you please share your name with me? I'd love to greet you properly! 😊\n", - "\n", - "Prompt 2: 'The capital of France is'\n", - "\n", - "Okay, so the user asked, \"The capital of France is,\" and then left it open. I need to figure out the correct answer here. Let me start by recalling what I know about France. France is a country in Europe, known for its rich history, culture, and famous landmarks.\n", - "\n", - "First, I should remember the capital city. I think the capital of France is Paris. But wait, sometimes countries change their capitals, so I should double-check that. I don't recall any recent changes regarding France's capital. Paris has been the capital for a long time, right? Like, since the Middle Ages or something. \n", - "\n", - "Let me think of other major cities in France to make sure I'm not confusing it with another city. There's Marseille, Lyon, Bordeaux, Nice, but none of those are the capital. Paris is definitely the one that comes to mind. It's also home to famous landmarks like the Eiffel Tower, the Louvre Museum, and\n", - "\n", - "Prompt 3: 'Explain quantum computing in simple terms:'\n", - "\n", - "Okay, so I need to explain quantum computing in simple terms. Let me start by recalling what I know about classical computers. They use bits, which are either 0 or 1. Everything a classical computer does is based on these binary states. Now, quantum computing must be different because it uses quantum bits, or qubits. But how exactly?\n", - "\n", - "I remember something about superposition. So a qubit can be both 0 and 1 at the same time, right? That means it can process a lot of information simultaneously. But how does that work in practice? Like, if you have two qubits, they can be in a superposition of four states (00, 01, 10, 11), and with more qubits, the number of states grows exponentially. That's why quantum computers might be faster for certain problems.\n", - "\n", - "Wait, but there's also entanglement. I think that's when qubits are linked together, so the state of\n" - ] - } - ], - "source": [ - "# Batch chat prompts\n", - "from openai import OpenAI\n", - "client = OpenAI(base_url=BASE_URL, api_key=\"dummy\")\n", - "\n", - "prompts = [\n", - " \"Hello, my name is\",\n", - " \"The capital of France is\",\n", - " \"Explain quantum computing in simple terms:\"\n", - "]\n", - "\n", - "# Convert to messages for chat.completions\n", - "messages_list = [[{\"role\": \"user\", \"content\": p}] for p in prompts]\n", - "\n", - "responses = []\n", - "for messages in messages_list:\n", - " out = client.chat.completions.create(\n", - " model=SERVED_MODEL_NAME,\n", - " messages=messages,\n", - " temperature=0.6,\n", - " max_tokens=512,\n", - " )\n", - " responses.append(out.choices[0].message.content)\n", - "\n", - "for i, (p, r) in enumerate(zip(prompts, responses), start=1):\n", - " print(f\"\\nPrompt {i}: {p!r}\")\n", - " print(r)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "O66imx4I7dD9" - }, - "source": [ - "### Asynchronous Batching" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "LLJBpTe47dD9", - "outputId": "44a7eb1c-3dab-4fa1-d09a-1b792d809c08" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Sending batch requests concurrently ---\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- All responses received ---\n", - "\\nPrompt 1: 'Hello, my name is'\n", - "\n", - "Okay, the user started with \"Hello, my name is\" but didn't finish. I need to respond appropriately. Since they mentioned their name, I should ask them to provide the rest. Maybe they got cut off or are testing the system. I should keep it friendly and encouraging. Let me make sure to prompt them to complete their name so I can address them properly. Also, check for any typos or if they intended to write more. But since the message is cut off, the best approach is to ask for the rest of their name. Keep the response simple and welcoming.\n", - "\n", - "\n", - "Hello! It seems like your message got cut off. Could you please share the rest of your name with me? I'd love to know what to call you as we chat! 😊\n", - "\\nPrompt 2: 'The capital of France is'\n", - "\n", - "Okay, so the user asked, \"The capital of France is,\" and I need to figure out the answer. Let me start by recalling what I know about France. France is a country in Europe, known for the Eiffel Tower, the Louvre Museum, and its rich history. Now, the capital city of a country is usually the seat of government and where the main administrative offices are located. \n", - "\n", - "I remember that Paris is a major city in France. In fact, I think Paris is the capital. But wait, I should make sure I'm not confusing it with other cities. Sometimes countries change their capitals, but I don't think France has done that recently. Let me think of other French cities. There's Marseille, Lyon, Bordeaux, Nice, but none of those are capitals. The government of France is definitely based in Paris. The president's residence, the Élysée Palace, is in Paris. Also, the headquarters of many international organizations are there, like UNESCO.\n", - "\n", - "Another way to confirm is to think about famous landmarks. The Eiffel Tower, Notre-Dame Cathedral, the Champs-Élysées – all of these are in Paris. If the capital were another city, those landmarks would probably be there instead. Also, when people talk about France in the news, especially regarding government matters, they often mention Paris. For example, during the Paris Agreement on climate change, the discussions were held in Paris.\n", - "\n", - "I should also consider if there's any historical context. Was there ever a time when the capital wasn't Paris? I think during the French Revolution, Paris was the center of activity, so it's been the capital for a long time. Before that, maybe other cities like Versailles? But Versailles is a suburb of Paris now, and while it was the seat of power under Louis XIV, the capital status might have shifted back to Paris after the revolution.\n", - "\n", - "To double-check, I can think of other countries and their capitals. For example, the capital of Italy is Rome, Germany is Berlin, Spain is Madrid. Following that pattern, France's capital should be Paris. Also, in international contexts, like the European Union, Paris is recognized as the capital of France.\n", - "\n", - "Wait, but just to be thorough, is there any chance that the capital is a different city? For example, sometimes people confuse the capital with the largest city. In France, Paris is both the largest city and the capital, so that aligns. In some countries, like Brazil, the capital is\n", - "\\nPrompt 3: 'Explain quantum computing in simple terms:'\n", - "\n", - "Okay, so I need to explain quantum computing in simple terms. Let me start by recalling what I know about regular computers. They use bits, which are either 0s or 1s, right? Everything a computer does is based on these binary states. But quantum computing uses qubits instead. I remember that qubits can be both 0 and 1 at the same time because of superposition. But how exactly does that work?\n", - "\n", - "Wait, superposition is like a spinning coin, not just heads or tails. So a qubit can be in a combination of both states until it's measured. That probably allows quantum computers to process a lot of information simultaneously. But how does that translate into computing power?\n", - "\n", - "Then there's entanglement. I think that's when qubits are linked together, so the state of one affects the other instantly, no matter the distance. This might help in processing information in a more interconnected way. But I'm not sure how that's used in actual computations.\n", - "\n", - "Also, quantum gates manipulate qubits, similar to logic gates in classical computers, but they work with probabilities. So quantum algorithms can solve certain problems faster, like factoring large numbers or simulating molecules. But why are they faster? Maybe because they explore many possibilities at once?\n", - "\n", - "Wait, but I should make sure I'm not mixing things up. Let me structure this. Start with classical bits vs qubits, explain superposition and entanglement, then maybe mention some applications where quantum computers excel, like Shor's algorithm for factoring or Grover's for searching. But keep it simple, avoid jargon.\n", - "\n", - "I should also note that quantum computers aren't just faster versions of classical ones; they're better for specific tasks. They're not going to replace regular computers for everyday tasks. Also, mention that they're error-prone and hard to build because qubits are sensitive to their environment, leading to decoherence.\n", - "\n", - "Hmm, but how to explain all this without getting too technical? Use analogies. Like, a qubit is like a light switch that can be on, off, or both at the same time. But maybe a better analogy is a spinning coin vs a coin that's either heads or tails. Superposition allows multiple states at once, so a quantum computer can handle many calculations at the same time.\n", - "\n", - "Entanglement could be like two coins that are spinning together; if one lands on heads, the other does too, no matter how far apart. This connection allows qubits to work together\n" - ] - } - ], - "source": [ - "import asyncio\n", - "from openai import AsyncOpenAI\n", - "\n", - "# Use the async client for concurrent requests\n", - "async_client = AsyncOpenAI(base_url=BASE_URL, api_key=\"dummy\")\n", - "\n", - "async def get_completion(messages):\n", - " \"\"\"A helper function to get a single completion asynchronously.\"\"\"\n", - " return await async_client.chat.completions.create(\n", - " model=SERVED_MODEL_NAME,\n", - " messages=messages,\n", - " temperature=0.6,\n", - " max_tokens=512,\n", - " )\n", - "\n", - "async def main():\n", - " # Create a list of tasks for all our prompts\n", - " tasks = [get_completion(msg) for msg in messages_list]\n", - "\n", - " # Run all tasks concurrently and wait for them all to complete\n", - " print(\"--- Sending batch requests concurrently ---\")\n", - " all_responses = await asyncio.gather(*tasks)\n", - " print(\"--- All responses received ---\")\n", - "\n", - " # Extract the content from each response\n", - " responses_content = [resp.choices[0].message.content for resp in all_responses]\n", - "\n", - " # Print the results\n", - " for i, (p, r) in enumerate(zip(prompts, responses_content), start=1):\n", - " print(f\"\\\\nPrompt {i}: {p!r}\")\n", - " print(r)\n", - "\n", - "# Run the asynchronous main function\n", - "# In a Jupyter Notebook, you might need to use `await main()` if you are in an async-enabled cell,\n", - "# or run it like this to handle the event loop.\n", - "await main()\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Stop the server process\n", - "if 'server_process' in globals() and server_process.poll() is None:\n", - " server_process.terminate()\n", - " server_process.wait()\n", - " print(\"SGLang server stopped.\")\n", - "else:\n", - " print(\"No running server process found to terminate.\")\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "nooh9kza7dD9" - }, - "source": [ - "## Direct Interaction with `curl`\n", - "\n", - "For debugging or for use in environments where the OpenAI Python client is not available, you can interact with the SGLang server directly using `curl`.\n", - "\n", - "The example below shows how to construct and execute a `curl` command to get a chat completion. We use Python's `subprocess` module to run the command and `json` to parse the output.\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "hR0fMhFz7dD9", - "outputId": "b3d9d818-d2c6-44b9-c660-2c7f2721f7e7" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Executing Curl Command ---\n", - "\n", - "curl -s http://localhost:33272/v1/chat/completions \\\n", - " -H \"Content-Type: application/json\" \\\n", - " -d '{\"model\": \"nvidia/Llama-3_3-Nemotron-Super-49B-v1_5\", \"messages\": [{\"role\": \"user\", \"content\": \"What is the capital of France?\"}], \"temperature\": 0.0}'\n", - "\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\\n--- Server Response ---\n", - "{'id': 'ef64aa03bc164ca2bd95ab73bd117f6e', 'object': 'chat.completion', 'created': 1758151210, 'model': 'nvidia/Llama-3_3-Nemotron-Super-49B-v1_5', 'choices': [{'index': 0, 'message': {'role': 'assistant', 'content': \"\\nOkay, so the user is asking for the capital of France. Let me start by recalling what I know about France. France is a country in Europe, known for its rich history, culture, and famous landmarks. The capital is the city where the government is based, right? I think the capital of France is Paris. Wait, but I should make sure I'm not confusing it with other cities. Let me think.\\n\\nI remember that Paris is a major city in France, famous for the Eiffel Tower, the Louvre Museum, and Notre-Dame Cathedral. But is it definitely the capital? Sometimes countries change their capitals, but I don't think France has done that recently. Let me check some other facts. The president of France, Emmanuel Macron, his official residence is in Paris, I believe. The Élysée Palace is the official residence, which is in Paris. That supports the idea that Paris is the capital.\\n\\nAlso, when I think of other European capitals, like Rome for Italy, Berlin for Germany, Madrid for Spain, and so on. Paris fits into that list. I don't recall any other city in France being the capital. Maybe historically there were different capitals? For example, during different periods in history, like the French Revolution or the different regimes, the capital might have moved. But currently, the capital is Paris. \\n\\nAnother way to verify is to think about international organizations or events. For instance, the headquarters of UNESCO is in Paris, which is a United Nations agency. That might indicate that Paris is a significant city, possibly the capital. Also, major international treaties or events often take place in capitals. The Paris Agreement on climate change was signed there, which again points to Paris being the capital.\\n\\nWait, but could there be any confusion with other cities? For example, Lyon or Marseille are big cities in France, but they aren't the capital. Bordeaux is another major city, but again, not the capital. So I think Paris is the correct answer here. \\n\\nI should also consider if there's any recent change. Sometimes countries change their capitals for various reasons, like administrative or symbolic reasons. But as far as I know, France hasn't changed its capital. The last time I checked, Paris was still the capital. \\n\\nIn summary, based on historical knowledge, current government residence, presence of major institutions, and common knowledge, the capital of France is Paris. I don't see any conflicting information that would suggest otherwise. Therefore, the answer should be Paris.\\n\\n\\nThe capital of France is **Paris**. It is the political, cultural, and economic center of the country, home to iconic landmarks such as the Eiffel Tower, the Louvre Museum, and Notre-Dame Cathedral. The French government, including the President's official residence (Élysée Palace), is based in Paris, confirming its status as the capital.\", 'reasoning_content': None, 'tool_calls': None}, 'logprobs': None, 'finish_reason': 'stop', 'matched_stop': 128009}], 'usage': {'prompt_tokens': 22, 'total_tokens': 611, 'completion_tokens': 589, 'prompt_tokens_details': None, 'reasoning_tokens': 0}, 'metadata': {'weight_version': 'default'}}\n" - ] - } - ], - "source": [ - "import subprocess, json\n", - "\n", - "# Construct the JSON payload as a Python dictionary first\n", - "payload = {\n", - " \"model\": SERVED_MODEL_NAME,\n", - " \"messages\": [\n", - " {\"role\": \"user\", \"content\": \"What is the capital of France?\"}\n", - " ],\n", - " \"temperature\": 0.0\n", - "}\n", - "\n", - "# Convert the dictionary to a JSON string\n", - "payload_str = json.dumps(payload)\n", - "\n", - "# Form the curl command\n", - "# Note: Using f-strings and subprocess like this is convenient for notebooks,\n", - "# but be cautious about shell injection in production environments.\n", - "curl_command = f\"\"\"\n", - "curl -s http://localhost:{port}/v1/chat/completions \\\\\n", - " -H \"Content-Type: application/json\" \\\\\n", - " -d '{payload_str}'\n", - "\"\"\"\n", - "\n", - "print(\"--- Executing Curl Command ---\")\n", - "print(curl_command)\n", - "\n", - "# Execute the command and load the JSON response\n", - "response_bytes = subprocess.check_output(curl_command, shell=True)\n", - "response = json.loads(response_bytes)\n", - "\n", - "print(\"\\\\n--- Server Response ---\")\n", - "print_highlight(response)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Resource Notes\n", - "\n", - "- **Hardware**: Nemotron-49B-v1.5 is a large model. Multi-GPU tensor parallel (`--tp`) is highly recommended for acceptable performance.\n", - "- **Quantization**: For environments with limited resources, consider using quantized versions of the model if available. These can significantly reduce memory usage at the cost of some accuracy.\n", - "- **Network**: Ensure you have sufficient network and disk bandwidth for the initial model download, as the weights are very large.\n", - "\n", - "## Conclusion and Next Steps\n", - "Congratulations! You successfully deployed the `Nemotron-49B-v1.5` model using SGLang.\n", - "\n", - "In this notebook, you have learned how to:\n", - "- Set up your environment and install SGLang.\n", - "- Launch and manage an OpenAI-compatible SGLang server.\n", - "- Perform basic chat, streaming, and batch inference.\n", - "- Use the model's different reasoning modes.\n", - "\n", - "You can adapt tensor parallelism, ports, and sampling parameters to your hardware and application needs.\n" - ] - } - ], - "metadata": { - "colab": { - "provenance": [] - }, - "kernelspec": { - "display_name": "sgl", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.18" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} diff --git a/usage-cookbook/Llama-Nemotron-Super-49B-v1.5/transformers_api_cookbook.ipynb b/usage-cookbook/Llama-Nemotron-Super-49B-v1.5/transformers_api_cookbook.ipynb deleted file mode 100644 index 59505d1..0000000 --- a/usage-cookbook/Llama-Nemotron-Super-49B-v1.5/transformers_api_cookbook.ipynb +++ /dev/null @@ -1,698 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Running Nemotron-49B-v1.5 with Hugging Face Transformers on NVIDIA GPUs\n", - "\n", - "This notebook provides a comprehensive guide on how to run the `Nemotron-49B-v1.5` model using Hugging Face Transformers library for direct inference and experimentation.\n", - "\n", - "This notebook will cover:\n", - "- Loading the model and tokenizer with optimized configurations.\n", - "- Demonstrating the model's reasoning modes (`think` vs `no_think`).\n", - "- Basic chat completions and streaming responses.\n", - "- Batch processing for multiple prompts.\n", - "\n", - "#### Launch on NVIDIA Brev\n", - "You can simplify the environment setup by using [NVIDIA Brev](https://developer.nvidia.com/brev). Click the button below to launch this project on a Brev instance with the necessary dependencies pre-configured.\n", - "\n", - "Once deployed, click on the \"Open Notebook\" button to get started with this guide.\n", - "\n", - "[![Launch on Brev](https://brev-assets.s3.us-west-1.amazonaws.com/nv-lb-dark.svg)](https://brev.nvidia.com/launchable/deploy?launchableID=env-32vt7HcQjCUpafGyquLZwJdIm8F)\n", - "\n", - "- Model card: [nvidia/Llama-3.3-Nemotron-Super-49B-v1.5](https://huggingface.co/nvidia/Llama-3.3-Nemotron-Super-49B-v1.5)\n", - "- Transformers Docs: [https://huggingface.co/docs/transformers/](https://huggingface.co/docs/transformers/)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Table of Contents\n", - "\n", - "- [Prerequisites](#Prerequisites)\n", - "- [Setup](#Setup)\n", - "- [Load Model and Tokenizer](#Load-Model-and-Tokenizer)\n", - "- [Helper Functions](#Helper-Functions)\n", - "- [Showcasing Reasoning Modes: `think` vs. `no_think`](#Showcasing-Reasoning-Modes:-`think`-vs.-`no_think`)\n", - "- [Simple Chat Completion](#Simple-Chat-Completion)\n", - "- [Streaming](#Streaming)\n", - "- [Batching](#Batching)\n", - "- [Resource Notes](#Resource-Notes)\n", - "- [Conclusion](#Conclusion)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Prerequisites\n", - "\n", - "**Hardware:** This notebook requires a machine with at least **2 NVIDIA GPUs** with sufficient VRAM to hold the 49B parameter model. The model will be automatically distributed across available GPUs using `device_map=\"auto\"`.\n", - "\n", - "**Software:**\n", - "- Python 3.10+\n", - "- CUDA 12.x\n", - "- PyTorch 2.3+\n", - "- Transformers, Accelerate, and other Hugging Face libraries" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Setup\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Install dependencies\n", - "%pip install -U \"transformers==4.48.3\" \"accelerate>=1.0.0\" \"safetensors\" \"huggingface-hub>=0.25\" \"bitsandbytes>=0.44.1\"\n", - "%pip install \"flash-attn>=2.6.3\" --no-build-isolation" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Python: 3.10.18\n", - "PyTorch: 2.8.0+cu128\n", - "CUDA available: True\n", - "Num GPUs: 1\n", - "GPU[0]: NVIDIA H200 | SM count: 132 | Mem: 150.02 GB\n" - ] - } - ], - "source": [ - "# GPU environment check\n", - "import torch\n", - "import platform\n", - "\n", - "print(f\"Python: {platform.python_version()}\")\n", - "print(f\"PyTorch: {torch.__version__}\")\n", - "print(f\"CUDA available: {torch.cuda.is_available()}\")\n", - "print(f\"Num GPUs: {torch.cuda.device_count()}\")\n", - "\n", - "if torch.cuda.is_available():\n", - " for i in range(torch.cuda.device_count()):\n", - " props = torch.cuda.get_device_properties(i)\n", - " print(f\"GPU[{i}]: {props.name} | SM count: {props.multi_processor_count} | Mem: {props.total_memory / 1e9:.2f} GB\")\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Load Model and Tokenizer\n", - "\n", - "We'll load the model and tokenizer using `AutoModelForCausalLM` and `AutoTokenizer`. We are using `bfloat16` for better performance on modern GPUs.\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "2094908ef6ac4de6a1cee74711d02cfe", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Loading checkpoint shards: 0%| | 0/21 [00:00 str:\n", - " return tokenizer.apply_chat_template(\n", - " messages,\n", - " tokenize=False,\n", - " add_generation_prompt=add_generation_prompt,\n", - " return_tensors=None,\n", - " )\n", - "\n", - "# Helper: generate text\n", - "@torch.inference_mode()\n", - "def generate_text(messages: List[Dict[str, str]], max_new_tokens: int = 512, temperature: float = 0.0, top_p: float = 1.0) -> str:\n", - " prompt = build_prompt(messages)\n", - " inputs = tokenizer(prompt, return_tensors=\"pt\").to(model.device)\n", - " outputs = model.generate(\n", - " **inputs,\n", - " max_new_tokens=max_new_tokens,\n", - " do_sample=temperature > 0.0,\n", - " temperature=temperature if temperature > 0.0 else None,\n", - " top_p=top_p,\n", - " pad_token_id=tokenizer.eos_token_id,\n", - " eos_token_id=tokenizer.eos_token_id,\n", - " )\n", - " text = tokenizer.decode(outputs[0], skip_special_tokens=False)\n", - " # Return only the generated part by slicing input length\n", - " gen_only = text[len(tokenizer.decode(inputs[\"input_ids\"][0], skip_special_tokens=False)) :]\n", - " return gen_only.strip()\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Showcasing Reasoning Modes: `think` vs. `no_think`\n", - "\n", - "This model supports two modes controlled via the system message:\n", - "- Reasoning ON (default): Model emits a `` block followed by the answer.\n", - "- Reasoning OFF: Add `/no_think` to the system message for concise answers without ``.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Reasoning ON ---\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Okay, let's see. The problem is: I have 5 apples. I eat 2, then my friend gives me 3 more. How many apples do I have now?\n", - "\n", - "Alright, starting with 5 apples. So the initial number is 5. Then I eat 2. Eating apples would mean subtracting them from the total, right? So 5 minus 2. Let me write that down: 5 - 2. That should be 3. So after eating 2 apples, I have 3 left.\n", - "\n", - "Then, my friend gives me 3 more. Adding 3 to the current number. So 3 plus 3. That would be 6. Wait, is that right? Let me check again. Starting with 5, subtract 2, which is 3, then add 3. Yes, 3 + 3 equals 6. So the total should be 6 apples.\n", - "\n", - "Hmm, but wait, sometimes there might be tricks in these problems. Let me make sure. The problem says \"I eat 2\" – does that mean I eat 2 of my own apples? Yes, because it's after stating I have 5. Then the friend gives me 3 more. So no, there's no trick here. It's straightforward subtraction and addition.\n", - "\n", - "Alternatively, could it be interpreted differently? Like, if I eat 2 apples, but maybe the friend gives me 3 before I eat them? But the order is important. The problem says \"I eat 2, then my friend gives me 3 more.\" So the sequence is: start with 5, subtract 2, then add 3. So 5 - 2 + 3. Which is indeed 6.\n", - "\n", - "Another way to think about it: 5 - 2 is 3, then 3 + 3 is 6. Yep. So the answer should be 6. I don't see any other possible interpretations here. The operations are in order, so no need for parentheses or anything. Just left to right. So 5 minus 2 plus 3 equals 6. That's correct.\n", - "\n", - "\n", - "You start with 5 apples. \n", - "- After eating 2: $ 5 - 2 = 3 $ apples remain. \n", - "- Then, your friend gives you 3 more: $ 3 + 3 = 6 $ apples. \n", - "\n", - "**Final Answer:** You have **6 apples** now.<|eot_id|>\n", - "\n", - "--- Reasoning OFF ---\n", - "Let's break it down step by step:\n", - "\n", - "1. **Start with**: 5 apples \n", - "2. **Eat 2**: 5 - 2 = 3 apples left \n", - "3. **Friend gives you 3 more**: 3 + 3 = 6 apples \n", - "\n", - "**Final answer: You have 6 apples now.** 🍎🍎🍎🍎🍎🍎<|eot_id|>\n" - ] - } - ], - "source": [ - "# 1) Reasoning ON (default)\n", - "reasoning_prompt = \"I have 5 apples. I eat 2, then my friend gives me 3 more. How many apples do I have now?\"\n", - "messages_on = [\n", - " {\"role\": \"system\", \"content\": \"You are a helpful reasoning assistant.\"},\n", - " {\"role\": \"user\", \"content\": reasoning_prompt},\n", - "]\n", - "print(\"--- Reasoning ON ---\")\n", - "print(generate_text(messages_on, temperature=0.0, max_new_tokens=512))\n", - "\n", - "# 2) Reasoning OFF using /no_think\n", - "messages_off = [\n", - " {\"role\": \"system\", \"content\": \"You are a helpful reasoning assistant.\\n/no_think\"},\n", - " {\"role\": \"user\", \"content\": reasoning_prompt},\n", - "]\n", - "print(\"\\n--- Reasoning OFF ---\")\n", - "print(generate_text(messages_off, temperature=0.0, max_new_tokens=256))\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Simple Chat Completion\n" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Okay, the user is asking for three bullet points about SGLang. First, I need to figure out what SGLang is. The name sounds like it could be a programming language, maybe related to graphics or some specific domain. Let me think. SGL might stand for something like Simple Graphics Language or something similar. Alternatively, it could be a lesser-known or niche language.\n", - "\n", - "Wait, I'm not sure if SGLang is a well-established language. Maybe it's a new or experimental one. Since I don't have specific information on SGLang, I should consider that it might not be widely recognized. In that case, I should inform the user that my knowledge is limited and perhaps suggest possible interpretations based on the name.\n", - "\n", - "Alternatively, maybe SGLang refers to a language used in a specific context, like a scripting language for a particular application. For example, some software uses custom languages for scripting, like GIMP uses its own language. But without more context, it's hard to say.\n", - "\n", - "The user might be referring to a language they encountered in a specific field. Since I can't look it up, I should proceed by stating that SGLang isn't widely recognized and offer possible interpretations. Then, create bullet points based on common features of similar languages. For example, if it's a graphics language, it might have features for drawing, animation, etc. If it's a general-purpose language, maybe simplicity, efficiency, or specific paradigms.\n", - "\n", - "I should make sure to clarify that the information is hypothetical and based on the name. The user might have a specific SGLang in mind, so I should ask for more context if possible. But since the query is straightforward, providing three bullet points with possible features based on common naming conventions would be helpful, while also noting the uncertainty.\n", - "\n", - "\n", - "As of my knowledge cutoff in July 2024, **SGLang** does not appear to be a widely recognized or established programming language. However, based on the name (which might imply a connection to graphics, simplicity, or a specific domain), here are three *hypothetical* bullet points that could describe a language with such a name:\n", - "\n", - "- **Graphics-focused Syntax**: Designed for creating vector graphics, animations, or visualizations, with built-in primitives for shapes, paths, and rendering. \n", - "- **Simplified Syntax**: Prioritizes readability and ease of use, potentially targeting beginners or rapid prototyping in a specific domain (e.g., design or education). \n", - "- **\n" - ] - } - ], - "source": [ - "messages = [\n", - " {\"role\": \"system\", \"content\": \"You are a helpful AI assistant.\"},\n", - " {\"role\": \"user\", \"content\": \"Give me 3 bullet points about SGLang.\"},\n", - "]\n", - "print(generate_text(messages, temperature=0.6, max_new_tokens=512))\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Streaming\n", - "\n", - "For streaming, we use the `TextIteratorStreamer` from Transformers." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Okay, " - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "the user wants a short poem about GPUs. Let me start by recalling what GPUs are. They're Graphics Processing Units, right? Used for rendering images, video, and parallel processing. They're crucial in gaming, machine learning, and other high-performance computing tasks.\n", - "\n", - "Hmm, I need to make the poem engaging and not too technical. Maybe start with something vivid, like the inside of a computer. Personifying the GPU could work. Words like \"whirring heart\" or \"silicon core\" might set the scene.\n", - "\n", - "What do GPUs do? They handle complex calculations, process data in parallel. Maybe mention tasks like rendering worlds or training AI. Words like \"rendering realms\" or \"training minds\" could rhyme and convey that.\n", - "\n", - "I should include some imagery related to light and speed. \"Lightning in a chip\" or \"clockwork dance\" might capture their speed and precision. Also, mention their role in various applications like gaming, science, or space.\n", - "\n", - "Rhyme scheme? Maybe AABB or ABAB. Let's try quatrains with alternating rhymes. Keep it short, maybe four stanzas. Check the rhythm to make it flow smoothly.\n", - "\n", - "Avoid jargon but still be accurate. Words like \"cores,\" \"parallel streams,\" \"transistors\" might be okay. End with a nod to their importance in modern tech, like \"the future they ignite.\"\n", - "\n", - "Let me draft a few lines and see how they fit. Revise for flow and imagery. Make sure it's accessible and poetic, not just a list of facts. Okay, that should work.\n", - "\n", - "\n", - "**Ode to the GPU** \n", - "\n", - "In circuits deep where shadows play, \n", - "A whirring heart of silicon core, \n", - "You weave the light, the vibrant fray— \n", - "A maestro of the digital shore. \n", - "\n", - "No single thread your path confines; \n", - "You dance with parallel streams, unbound. \n", - "Through rendering realms and neural mines, \n", - "You chart the vast, the yet unfound. \n", - "\n", - "Your cores, like stars in clockwork skies, \n", - "Compute the pulse of every frame. \n", - "From gaming realms to AI’s rise, \n", - "You etch the future, line by frame. \n", - "\n", - "Oh, GPU—swift, unseen might— \n", - "You turn the gears of progress tight. \n", - "In every pixel, code, and light, \n", - "The world you shape takes flight.<|eot_id|>\n", - "\n" - ] - } - ], - "source": [ - "from transformers import TextIteratorStreamer\n", - "import threading\n", - "import torch\n", - "\n", - "messages_stream = [\n", - " {\"role\": \"system\", \"content\": \"You are a helpful AI assistant.\"},\n", - " {\"role\": \"user\", \"content\": \"Write a short poem about GPUs.\"},\n", - "]\n", - "\n", - "prompt_stream = build_prompt(messages_stream)\n", - "inputs = tokenizer(prompt_stream, return_tensors=\"pt\").to(model.device)\n", - "\n", - "streamer = TextIteratorStreamer(tokenizer, skip_prompt=True, skip_special_tokens=False)\n", - "\n", - "gen_kwargs = dict(\n", - " **inputs,\n", - " max_new_tokens=512,\n", - " do_sample=True,\n", - " temperature=0.7,\n", - " top_p=0.95,\n", - " pad_token_id=tokenizer.eos_token_id,\n", - " eos_token_id=tokenizer.eos_token_id,\n", - " streamer=streamer,\n", - " use_cache=False, # Disable cache to avoid in-place operations\n", - ")\n", - "\n", - "# Use torch.no_grad() to avoid inference mode issues\n", - "def generate_with_no_grad():\n", - " with torch.no_grad():\n", - " model.generate(**gen_kwargs)\n", - "\n", - "thread = threading.Thread(target=generate_with_no_grad)\n", - "thread.start()\n", - "\n", - "for new_text in streamer:\n", - " print(new_text, end=\"\", flush=True)\n", - "\n", - "thread.join()\n", - "print(\"\\n\")\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Batching\n", - "\n", - "Here we show two methods for batching: sequential and true batching. True batching is more efficient as it processes multiple prompts in a single forward pass." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Prompt 1: 'Hello, my name is'\n", - "\n", - "Okay, the user started with \"Hello, my name is\" and then the message got cut off. They probably intended to introduce themselves but didn't finish. I should respond in a friendly and welcoming manner, encouraging them to provide their name and ask how I can assist them. Let me make sure the response is open-ended and helpful. Maybe something like, \"Hello! It seems like your message might have been cut off. Could you please share your name and let me know how I can assist you today?\" That should cover it and prompt them to complete their introduction and state their request.\n", - "\n", - "\n", - "Hello! It seems like your message might have been cut off. Could you please share your name and let me know how I can assist you today? 😊<|eot_id|>\n", - "\n", - "Prompt 2: 'The capital of France is'\n", - "\n", - "Okay, so the user asked, \"The capital of France is,\" and then left it at that. I need to figure out the correct answer here. Let me start by recalling what I know about France. France is a country in Europe, known for its rich history, culture, and famous landmarks.\n", - "\n", - "First, the capital of a country is usually its main city, where the government is based. For France, I think the capital is Paris. But wait, let me make sure I'm not confusing it with other cities. Sometimes people might think of other cities like Lyon or Marseille, but those are major cities, not the capital. \n", - "\n", - "I remember that Paris is famous for the Eiffel Tower, the Louvre Museum, and being a center for art and fashion. Also, the French government is based there, so that's a key point. The president's residence, the Élysée Palace, is in Paris. That definitely points to Paris being the capital.\n", - "\n", - "But just to double-check, maybe there was a time when the capital changed? For example, during different historical periods, some countries moved their capitals. However, in modern times, France has had Paris as its capital for a long time. Even during the French Revolution, Paris was the center of activity. \n", - "\n", - "Another way to verify is to think about other countries and their capitals. For instance, Germany's capital is Berlin, Italy's is Rome, so France's should be Paris. Also, in international contexts, like the European Union, Paris is recognized as the capital of France. \n", - "\n", - "I don't think there's any recent change that I'm not aware of. Sometimes countries do change capitals, like when Nigeria moved from Lagos to Abuja, but France hasn't done that. Paris remains the capital. \n", - "\n", - "So putting it all together, the answer should be Paris. The user might be testing basic geography knowledge, so it's straightforward. But it's always good to confirm to avoid any mistakes. Maybe check a reliable source in my mind, like a map or a textbook. Yes, Paris is definitely the capital of France.\n", - "\n", - "\n", - "The capital of France is **Paris**. \n", - "\n", - "Paris is not only the political, cultural, and economic heart of France but also one of the world's most iconic cities, renowned for landmarks like the Eiffel Tower, the Louvre Museum, and Notre-Dame Cathedral. It has served as the capital since the 3rd century, when it became the seat of the Roman province of Lutetia\n", - "\n", - "Prompt 3: 'Explain quantum computing in simple terms:'\n", - "\n", - "Okay, so I need to explain quantum computing in simple terms. Let me start by recalling what I know about regular computers. Traditional computers, like the one I'm using right now, use bits as their basic unit of information. A bit can be either a 0 or a 1. Everything on a computer, from this text to images and videos, is represented by combinations of these 0s and 1s. They process information using logic gates like AND, OR, NOT, which manipulate these bits.\n", - "\n", - "Now, quantum computing uses qubits instead of bits. I remember that qubits can be 0, 1, or both at the same time. That's called superposition. So, a qubit can exist in a combination of states simultaneously, which allows quantum computers to process a vast number of possibilities at once. But how does that work exactly? Maybe it's like a coin that's spinning in the air—it's both heads and tails until it lands. But when you measure it, it collapses to one state.\n", - "\n", - "Then there's entanglement. I think entangled qubits are connected, so the state of one qubit instantly influences the state of another, no matter the distance. Einstein called it \"spooky action at a distance.\" This might allow quantum computers to perform certain calculations much faster by linking qubits in a way that classical bits can't.\n", - "\n", - "Another concept is quantum interference. I'm not too sure about this. Maybe it's about how the probabilities of different states interact. Like, when you have multiple qubits in superposition, their probabilities can constructively or destructively interfere, similar to waves in a pond. This could be used to amplify the probabilities of correct answers and cancel out wrong ones.\n", - "\n", - "But how does this lead to faster computation? For example, Shor's algorithm for factoring large numbers is exponentially faster than classical algorithms. Grover's algorithm speeds up searching databases. These algorithms exploit the quantum properties to solve problems that are intractable for classical computers.\n", - "\n", - "However, quantum computers are error-prone. Qubits are sensitive to their environment, leading to decoherence. They lose their quantum state quickly, which is why they need to be kept at near absolute zero temperatures. Also, error correction is a big challenge because you can't just copy qubits like bits due to the no-cloning theorem.\n", - "\n", - "So, putting it all together, a simple explanation would need to cover qubits, superposition, entanglement, and maybe a bit about interference. It should\n" - ] - } - ], - "source": [ - "prompts = [\n", - " \"Hello, my name is\",\n", - " \"The capital of France is\",\n", - " \"Explain quantum computing in simple terms:\"\n", - "]\n", - "\n", - "for i, p in enumerate(prompts, start=1):\n", - " messages = [{\"role\": \"user\", \"content\": p}]\n", - " out = generate_text(messages, temperature=0.6, max_new_tokens=512)\n", - " print(f\"\\nPrompt {i}: {p!r}\")\n", - " print(out)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "A decoder-only architecture is being used, but right-padding was detected! For correct generation results, please set `padding_side='left'` when initializing the tokenizer.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--- Processing batch requests efficiently ---\n", - "\n", - "Prompt 1: 'Hello, my name is'\n", - "Response: \n", - "Okay, the user started with \"Hello, my name is\" and then stopped. Maybe they're testing the system or just beginning a conversation. I should respond in a friendly and welcoming manner. Let me make sure to acknowledge their greeting and invite them to share more. I'll keep it simple and open-ended so they feel comfortable continuing the conversation. Let me check for any typos or errors. Yep, looks good. Time to send a response that's both professional and approachable.\n", - "\n", - "\n", - "Hello! It's nice to meet you. How can I assist you today? 😊\n", - "\n", - "Prompt 2: 'The capital of France is'\n", - "Response: games, I know this one! The capital of France is Paris! Is that right? \n", - "\n", - "Yes, that's correct! The capital of France is indeed Paris. Well done for knowing that! \n", - "\n", - "Now, let's try a slightly harder one. What is the capital of Australia? \n", - "\n", - "(And don't worry, I won't make you guess all of them - just a few for fun!) \n", - "\n", - "**Answer:** The capital of Australia is Canberra. \n", - "\n", - "Would you like to try another one? \n", - "\n", - "(If you'd like to skip the game and just ask a question, that's totally fine too!)\n", - "\n", - "Prompt 3: 'Explain quantum computing in simple terms:'\n", - "Response: \n", - "Okay, so I need to explain quantum computing in simple terms. Let me start by recalling what I know about regular computers. They use bits, which are 0s and 1s, right? Each bit is like a switch that's either on or off. All the data and operations in a computer are based on these binary states. Now, quantum computing must be different because of the word \"quantum,\" which relates to physics at a very small scale.\n", - "\n", - "I remember hearing about qubits, which are the quantum version of bits. But how are they different? Maybe they can be both 0 and 1 at the same time? That sounds like superposition. So, a qubit can exist in multiple states simultaneously. That must mean a quantum computer can process a lot of information at once. But how does that work exactly?\n", - "\n", - "Then there's entanglement. I think that's when qubits are connected, so the state of one affects another instantly, even if they're far apart. This might allow for faster communication of information between qubits. But how does that contribute to computing power?\n", - "\n", - "Also, there's something about quantum gates versus classical logic gates. Classical gates perform operations on bits, like AND or OR, but quantum gates manipulate\n", - "\n", - "Prompt 4: 'List 3 benefits of GPUs'\n", - "Response: graphics processing units (GPUs) offer several benefits, particularly in handling complex visual and computational tasks. here are three key advantages:\n", - "\n", - "1. **parallel processing**: GPUs are designed to handle multiple tasks simultaneously, making them highly efficient for parallelizable workloads such as rendering graphics, machine learning, and scientific simulations. this is achieved through thousands of smaller cores that can process data in parallel, unlike CPUs which have fewer cores optimized for sequential processing.\n", - "\n", - "2. **high memory bandwidth**: GPUs typically have high memory bandwidth, allowing them to quickly read and write large amounts of data. this is crucial for tasks that require rapid data access, such as rendering high-resolution textures in games or processing large datasets in data science applications.\n", - "\n", - "3. **energy efficiency for specific tasks**: for certain workloads, particularly those that can be parallelized, GPUs can be more energy-efficient than CPUs. this is because they can complete tasks faster, reducing the overall power consumption per operation compared to a CPU that might take longer to perform the same task sequentially.\n", - "\n", - "these benefits make GPUs essential in fields like gaming, artificial intelligence, video editing, and scientific research.\n" - ] - } - ], - "source": [ - "# True Batch Processing (Recommended)\n", - "# Process multiple prompts in a single forward pass for better efficiency\n", - "\n", - "batch_prompts = [\n", - " \"Hello, my name is\",\n", - " \"The capital of France is\", \n", - " \"Explain quantum computing in simple terms:\",\n", - " \"List 3 benefits of GPUs\",\n", - "]\n", - "\n", - "def generate_batch(prompts: list, temperature: float = 0.6, max_new_tokens: int = 256):\n", - " \"\"\"Generate responses for multiple prompts in a single batch\"\"\"\n", - " messages_batch = [[{\"role\": \"user\", \"content\": p}] for p in prompts]\n", - " \n", - " # Build prompts for all messages\n", - " prompts_batch = [build_prompt(msgs) for msgs in messages_batch]\n", - " \n", - " # Tokenize all prompts\n", - " inputs_batch = tokenizer(prompts_batch, return_tensors=\"pt\", padding=True, truncation=True)\n", - " inputs_batch = {k: v.to(model.device) for k, v in inputs_batch.items()}\n", - " \n", - " # Generate for all prompts at once\n", - " with torch.no_grad():\n", - " outputs = model.generate(\n", - " **inputs_batch,\n", - " max_new_tokens=max_new_tokens,\n", - " do_sample=True,\n", - " temperature=temperature,\n", - " top_p=0.95,\n", - " pad_token_id=tokenizer.eos_token_id,\n", - " eos_token_id=tokenizer.eos_token_id,\n", - " use_cache=False, # Disable cache to avoid conflicts\n", - " )\n", - " \n", - " # Decode responses\n", - " responses = []\n", - " for i, output in enumerate(outputs):\n", - " # Remove the input tokens to get only the generated part\n", - " input_length = inputs_batch[\"input_ids\"][i].shape[0]\n", - " generated_tokens = output[input_length:]\n", - " response = tokenizer.decode(generated_tokens, skip_special_tokens=True)\n", - " responses.append(response.strip())\n", - " \n", - " return responses\n", - "\n", - "print(\"--- Processing batch requests efficiently ---\")\n", - "responses = generate_batch(batch_prompts, temperature=0.6, max_new_tokens=256)\n", - "\n", - "for i, (prompt, response) in enumerate(zip(batch_prompts, responses), 1):\n", - " print(f\"\\nPrompt {i}: {prompt!r}\")\n", - " print(f\"Response: {response}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Resource Notes\n", - "\n", - "- **Memory Management**: The model uses `device_map=\"auto\"` to automatically distribute the model across available GPUs. With `bfloat16` precision, the model requires approximately 98GB of VRAM.\n", - "- **Quantization**: For systems with limited VRAM, consider using quantization techniques like `load_in_4bit=True` or `load_in_8bit=True` in the `from_pretrained` call.\n", - "- **Chat Templates**: The model uses Llama's chat template format. The helper functions in this notebook handle the proper formatting automatically.\n", - "- **Batch Processing**: True batch processing (processing multiple prompts in a single forward pass) is more memory-efficient than sequential processing, especially for longer prompts.\n", - "\n", - "## Conclusion\n", - "\n", - "In this notebook, you have learned how to:\n", - "- Load and configure the Nemotron-49B-v1.5 model using Hugging Face Transformers.\n", - "- Use the model's reasoning modes for different types of tasks.\n", - "- Implement both sequential and efficient batch processing.\n", - "- Stream responses for real-time applications.\n", - "- Build helper functions for cleaner code organization.\n", - "\n", - "This notebook provides a solid foundation for integrating Nemotron with Hugging Face Transformers in your applications.\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "\n" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "hft", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.18" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/usage-cookbook/Llama-Nemotron-Super-49B-v1.5/trtllm_api_cookbook.ipynb b/usage-cookbook/Llama-Nemotron-Super-49B-v1.5/trtllm_api_cookbook.ipynb deleted file mode 100644 index d510a2b..0000000 --- a/usage-cookbook/Llama-Nemotron-Super-49B-v1.5/trtllm_api_cookbook.ipynb +++ /dev/null @@ -1,582 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "UaHyLm3S-qfI" - }, - "source": [ - "# Running Nemotron-49B-v1.5 with TensorRT-LLM on NVIDIA GPUs\n", - "\n", - "This notebook provides a comprehensive guide on how to run the `Nemotron-49B-v1.5` model using NVIDIA's TensorRT-LLM for high-performance inference.\n", - "\n", - "This notebook is divided into two parts:\n", - "- **Part 1:** Demonstrates how to use the direct Python API for inference, including batch generation.\n", - "- **Part 2:** Covers how to deploy the model with an OpenAI-compatible web server and interact with it using an OpenAI client.\n", - "\n", - "#### Launch on NVIDIA Brev\n", - "You can simplify the environment setup by using [NVIDIA Brev](https://developer.nvidia.com/brev). Click the button below to launch this project on a Brev instance with the necessary dependencies pre-configured.\n", - "\n", - "Once deployed, click on the \"Open Notebook\" button to get started with this guide.\n", - "\n", - "[![Launch on Brev](https://brev-assets.s3.us-west-1.amazonaws.com/nv-lb-dark.svg)](https://brev.nvidia.com/launchable/deploy?launchableID=env-32vt7HcQjCUpafGyquLZwJdIm8F)\n", - "\n", - "- Model card: [nvidia/Llama-3.3-Nemotron-Super-49B-v1.5](https://huggingface.co/nvidia/Llama-3.3-Nemotron-Super-49B-v1.5)\n", - "- TensorRT-LLM Docs: [https://nvidia.github.io/TensorRT-LLM/](https://nvidia.github.io/TensorRT-LLM/)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Table of Contents\n", - "\n", - "- [Part 1: Inference with the Python API](#Part-1:-Inference-with-the-Python-API)\n", - " - [Prerequisites](#Prerequisites)\n", - " - [Setup](#Setup)\n", - " - [Inference with Python API](#Inference-with-Python-API)\n", - " - [Batch Generation](#Batch-Generation)\n", - "- [Part 2: OpenAI-Compatible Server](#Part-2:-OpenAI-Compatible-Server)\n", - " - [Client Setup and Examples](#Client-Setup-and-Examples)\n", - " - [Reasoning Modes (`think` vs. `no_think`)](#Reasoning-Modes-(`think`-vs.-`no_think`))\n", - " - [Interaction with `curl`](#Interaction-with-`curl`)\n", - " - [Cleanup](#Cleanup)\n", - "- [Resource Notes](#Resource-Notes)\n", - "- [Conclusion](#Conclusion)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "uQ0d5Wjr-qfK" - }, - "source": [ - "## Part 1: Inference with the Python API\n", - "\n", - "### Prerequisites\n", - "\n", - "**Hardware:** This notebook requires a machine with at least **2 NVIDIA GPUs** with sufficient VRAM to hold the 49B parameter model. Building the TensorRT-LLM engine is memory-intensive.\n", - "\n", - "**Software:**\n", - "- Python 3.10+\n", - "- NVIDIA GPU with CUDA 12.x\n", - "- TensorRT-LLM installed from source or via the container." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Setup" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "m7CutrbU-qfK", - "outputId": "5acf5f7b-31e0-4e38-e79d-1c66e7c00a0b" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Python: 3.12.3 (main, Feb 4 2025, 14:48:35) [GCC 13.3.0]\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.12/dist-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", - " from .autonotebook import tqdm as notebook_tqdm\n", - "[2025-09-17 18:08:58] INFO config.py:54: PyTorch version 2.8.0a0+5228986c39.nv25.6 available.\n", - "[2025-09-17 18:08:58] INFO config.py:66: Polars version 1.25.2 available.\n", - "/usr/local/lib/python3.12/dist-packages/modelopt/torch/__init__.py:36: UserWarning: transformers version 4.55.0 is incompatible with nvidia-modelopt and may cause issues. Please install recommended version with `pip install nvidia-modelopt[hf]` if working with HF models.\n", - " _warnings.warn(\n", - "2025-09-17 18:09:00,970 - INFO - flashinfer.jit: Prebuilt kernels not found, using JIT backend\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[TensorRT-LLM] TensorRT-LLM version: 1.1.0rc4\n", - "TensorRT-LLM available\n", - "TensorRT-LLM version: 1.1.0rc4\n", - "CUDA available: True\n", - "Num GPUs: 1\n", - "GPU[0]: NVIDIA H200\n" - ] - } - ], - "source": [ - "# Environment checks\n", - "import sys\n", - "import tensorrt_llm\n", - "import torch\n", - "\n", - "print(f\"Python: {sys.version}\")\n", - "print(f\"TensorRT-LLM version: {tensorrt_llm.__version__}\")\n", - "print(f\"CUDA available: {torch.cuda.is_available()}\")\n", - "print(f\"Num GPUs: {torch.cuda.device_count()}\")\n", - "\n", - "if torch.cuda.is_available():\n", - " for i in range(torch.cuda.device_count()):\n", - " print(f\"GPU[{i}]: {torch.cuda.get_device_name(i)}\")\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "O4JjKIJG-qfL" - }, - "source": [ - "## Inference with Python API" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "y1ulDnj1-qfM", - "outputId": "6e8cd596-5920-4c08-b78c-b07b469be888" - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Loading Model: \u001b[1;32m[1/3]\t\u001b[0mDownloading HF model\n", - "\u001b[38;20mDownloaded model to /root/.cache/huggingface/hub/models--nvidia--Llama-3_3-Nemotron-Super-49B-v1_5/snapshots/2051b8a94fa75052394507a5c81cd7c2b70e9a4b\n", - "\u001b[0m\u001b[38;20mTime: 0.350s\n", - "\u001b[0mLoading Model: \u001b[1;32m[2/3]\t\u001b[0mLoading HF model to memory\n", - "\u001b[38;20mTime: 1.126s\n", - "\u001b[0mLoading Model: \u001b[1;32m[3/3]\t\u001b[0mBuilding TRT-LLM engine\n", - "\u001b[38;20mTime: 324.062s\n", - "\u001b[0m\u001b[1;32mLoading model done.\n", - "\u001b[0m\u001b[38;20mTotal latency: 325.539s\n", - "\u001b[0m\u001b[33;20mrank 0 using MpiPoolSession to spawn MPI processes\n", - "\u001b[0m2025-09-17 17:13:04,901 - INFO - flashinfer.jit: Prebuilt kernels not found, using JIT backend\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[TensorRT-LLM] TensorRT-LLM version: 0.20.0\n", - "[TensorRT-LLM][INFO] Refreshed the MPI local session\n", - "[TensorRT-LLM][INFO] Engine version 0.20.0 found in the config file, assuming engine(s) built by new builder API.\n", - "[TensorRT-LLM][INFO] Refreshed the MPI local session\n", - "[TensorRT-LLM][INFO] MPI size: 1, MPI local size: 1, rank: 0\n", - "[TensorRT-LLM][INFO] Rank 0 is using GPU 0\n", - "[TensorRT-LLM][INFO] TRTGptModel maxNumSequences: 2048\n", - "[TensorRT-LLM][INFO] TRTGptModel maxBatchSize: 2048\n", - "[TensorRT-LLM][INFO] TRTGptModel maxBeamWidth: 1\n", - "[TensorRT-LLM][INFO] TRTGptModel maxSequenceLen: 131072\n", - "[TensorRT-LLM][INFO] TRTGptModel maxDraftLen: 0\n", - "[TensorRT-LLM][INFO] TRTGptModel mMaxAttentionWindowSize: (131072) * 49\n", - "[TensorRT-LLM][INFO] TRTGptModel enableTrtOverlap: 0\n", - "[TensorRT-LLM][INFO] TRTGptModel normalizeLogProbs: 0\n", - "[TensorRT-LLM][INFO] TRTGptModel maxNumTokens: 8192\n", - "[TensorRT-LLM][INFO] TRTGptModel maxInputLen: 8192 = min(maxSequenceLen - 1, maxNumTokens) since context FMHA and usePackedInput are enabled\n", - "[TensorRT-LLM][INFO] TRTGptModel If model type is encoder, maxInputLen would be reset in trtEncoderModel to maxInputLen: min(maxSequenceLen, maxNumTokens).\n", - "[TensorRT-LLM][INFO] Capacity Scheduler Policy: GUARANTEED_NO_EVICT\n", - "[TensorRT-LLM][INFO] Context Chunking Scheduler Policy: None\n", - "[TensorRT-LLM][INFO] Loaded engine size: 95201 MiB\n", - "[TensorRT-LLM][INFO] Engine load time 88400 ms\n", - "[TensorRT-LLM][INFO] Inspecting the engine to identify potential runtime issues...\n", - "[TensorRT-LLM][INFO] The profiling verbosity of the engine does not allow this analysis to proceed. Re-build the engine with 'detailed' profiling verbosity to get more diagnostics.\n", - "[TensorRT-LLM][INFO] [MemUsageChange] Allocated 2208.01 MiB for execution context memory.\n", - "[TensorRT-LLM][INFO] gatherContextLogits: 0\n", - "[TensorRT-LLM][INFO] gatherGenerationLogits: 0\n", - "[TensorRT-LLM][INFO] [MemUsageChange] TensorRT-managed allocation in IExecutionContext creation: CPU +0, GPU +0, now: CPU 0, GPU 95178 (MiB)\n", - "[TensorRT-LLM][INFO] [MemUsageChange] Allocated 5.98 GB GPU memory for runtime buffers.\n", - "[TensorRT-LLM][INFO] [MemUsageChange] Allocated 8.04 GB GPU memory for decoder.\n", - "[TensorRT-LLM][INFO] Memory usage when calculating max tokens in paged kv cache: total: 139.72 GiB, available: 29.11 GiB, extraCostMemory: 0.00 GiB\n", - "[TensorRT-LLM][INFO] Number of blocks in KV cache primary pool: 4381\n", - "[TensorRT-LLM][INFO] Number of blocks in KV cache secondary pool: 0, onboard blocks to primary memory before reuse: true\n", - "[TensorRT-LLM][INFO] before Create KVCacheManager cacheTransPreAllocaSize:0\n", - "[TensorRT-LLM][INFO] Max KV cache pages per sequence: 4096 [window size=131072]\n", - "[TensorRT-LLM][INFO] Number of tokens per block: 32.\n", - "[TensorRT-LLM][INFO] [MemUsageChange] Allocated 26.20 GiB for max tokens in paged KV cache (140192).\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Processed requests: 0%| | 0/1 [00:00\n", - "Okay, the user is asking for three bullet points about TensorRT-LLM. Let me start by recalling what I know about TensorRT-LLM. It's related to NVIDIA's TensorRT, which is a toolkit for optimizing deep learning models for inference. But TensorRT-LLM specifically targets large language models, right?\n", - "\n", - "First, I should explain what TensorRT-LLM is. It's an open-source library, so that's a key point. It's designed to optimize and deploy LLMs efficiently. Maybe mention that it's built on TensorRT, which is known for high-performance inference.\n", - "\n", - "Next, the main features. Optimization techniques like model pruning, quantization, and efficient attention mechanisms come to mind. These help reduce the model size and speed up inference without losing much accuracy. Also, integration with frameworks like Hugging Face Transformers would be important for developers.\n", - "\n", - "Third, use cases. TensorRT-LLM is used in applications requiring real-time or low-latency responses, such as chatbots, virtual assistants, and content generation. Highlighting deployment on NVIDIA GPUs makes sense since TensorRT is optimized for their hardware.\n", - "\n", - "Wait, should I mention specific models it supports? Maybe not necessary for bullet points. Focus on the key aspects:\n", - "\n", - "Okay, the user wants a short poem about GPUs. Let me start by recalling what GPUs are. They're Graphics Processing Units, right? Used for rendering images, video, and also for parallel computing tasks. So I need to highlight their power and versatility.\n", - "\n", - "Hmm, how to make a poem about that. Maybe start with something about speed or processing. Words like \"silicon heart\" or \"circuits\" could work. I should mention their role in gaming, since that's a common use. Also, maybe touch on their use in AI or machine learning, as that's a big area now.\n", - "\n", - "Rhyme scheme? Maybe AABB or ABAB. Let's go with quatrains for simplicity. First line could be about the GPU's core function. \"In circuits deep where data streams collide,\" – that sets a scene. Then talk about rendering worlds or something. \"A titan of speed, the GPU resides,\" – introduces the GPU as a powerful entity.\n", - "\n", - "Next stanza: Maybe about gaming. \"It paints the screen with vibrant, fleeting light,\" – rendering graphics. \"A dance of pixels in the dead of night.\" Adds some imagery. Then mention the heat and power, \"Its core ablaze with calculations bright,\" – shows it's working\n" - ] - } - ], - "source": [ - "from openai import OpenAI\n", - "import requests\n", - "\n", - "BASE_URL = \"http://127.0.0.1:5000/v1\"\n", - "API_KEY = \"tensorrt_llm\"\n", - "client = OpenAI(base_url=BASE_URL, api_key=API_KEY)\n", - "\n", - "# Get the served model name\n", - "model_id = requests.get(f\"{BASE_URL}/models\").json()[\"data\"][0][\"id\"]\n", - "\n", - "# Basic chat completion\n", - "response = client.chat.completions.create(\n", - " model=model_id,\n", - " messages=[{\"role\": \"user\", \"content\": \"Give me 3 bullet points about TensorRT-LLM.\"}],\n", - " temperature=0.6,\n", - " max_tokens=256,\n", - ")\n", - "print(\"--- Simple Chat Response ---\")\n", - "print(response.choices[0].message.content)\n", - "\n", - "# Streaming chat completion\n", - "print(\"\\n--- Streaming Chat Response ---\")\n", - "stream = client.chat.completions.create(\n", - " model=model_id,\n", - " messages=[{\"role\": \"user\", \"content\": \"Write a short poem about GPUs.\"}],\n", - " temperature=0.7,\n", - " max_tokens=256,\n", - " stream=True,\n", - ")\n", - "for chunk in stream:\n", - " if chunk.choices[0].delta.content:\n", - " print(chunk.choices[0].delta.content, end=\"\", flush=True)\n", - "print()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Reasoning Modes (`think` vs. `no_think`)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Reasoning ON (default)\n", - "reasoning_prompt = \"I have 5 apples. I eat 2, then my friend gives me 3 more. How many apples do I have now?\"\n", - "messages_on = [\n", - " {\"role\": \"system\", \"content\": \"You are a helpful reasoning assistant.\"},\n", - " {\"role\": \"user\", \"content\": reasoning_prompt},\n", - "]\n", - "print(\"--- Reasoning ON ---\")\n", - "response_on = client.chat.completions.create(\n", - " model=model_id,\n", - " messages=messages_on,\n", - " temperature=0.0,\n", - " max_tokens=512,\n", - ")\n", - "print(response_on.choices[0].message.content)\n", - "\n", - "\n", - "# Reasoning OFF using /no_think\n", - "messages_off = [\n", - " {\"role\": \"system\", \"content\": \"You are a helpful reasoning assistant.\\n/no_think\"},\n", - " {\"role\": \"user\", \"content\": reasoning_prompt},\n", - "]\n", - "print(\"\\n--- Reasoning OFF ---\")\n", - "response_off = client.chat.completions.create(\n", - " model=model_id,\n", - " messages=messages_off,\n", - " temperature=0.0,\n", - " max_tokens=256,\n", - ")\n", - "print(response_off.choices[0].message.content)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "2QkrvyDH-qfP" - }, - "source": [ - "### Interaction with `curl`" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Chat Completion:**\n", - "```bash\n", - "curl -sS -X POST http://127.0.0.1:5000/v1/chat/completions \\\n", - " -H \"Content-Type: application/json\" \\\n", - " -H \"Authorization: Bearer tensorrt_llm\" \\\n", - " -d '{\n", - " \"model\": \"nvidia/Llama-3_3-Nemotron-Super-49B-v1_5\",\n", - " \"messages\": [\n", - " {\"role\": \"user\", \"content\": \"Give me 3 bullet points about TensorRT-LLM.\"}\n", - " ],\n", - " \"temperature\": 0.6,\n", - " \"max_tokens\": 256\n", - " }'\n", - "```\n", - "\n", - "**Streaming Chat Completion:**\n", - "```bash\n", - "curl -N -sS -X POST http://127.0.0.1:5000/v1/chat/completions \\\n", - " -H \"Content-Type: application/json\" \\\n", - " -H \"Authorization: Bearer tensorrt_llm\" \\\n", - " -d '{\n", - " \"model\": \"nvidia/Llama-3_3-Nemotron-Super-49B-v1_5\",\n", - " \"messages\": [\n", - " {\"role\": \"user\", \"content\": \"Write a short poem about GPUs.\"}\n", - " ],\n", - " \"stream\": true\n", - " }'\n", - "```\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Cleanup\n", - "\n", - "To stop the OpenAI-compatible server, press `CTRL+C` in the terminal where it is running.\n", - "\n", - "\n", - "## Resource Notes\n", - "\n", - "- **Engine Build Time**: The initial build of the TensorRT-LLM engine can be very time-consuming. This is a one-time cost per model and hardware configuration.\n", - "- **Hardware**: Nemotron-49B-v1.5 is a large model. Multi-GPU is highly recommended for acceptable performance.\n", - "- **Quantization**: TensorRT-LLM supports various quantization techniques (like INT8, FP8) to reduce memory usage and improve performance. Refer to the official documentation for more details.\n", - "\n", - "## Conclusion\n", - "\n", - "In this notebook, you have learned how to:\n", - "- Run inference with the Nemotron-49B-v1.5 model using the TensorRT-LLM Python API.\n", - "- Perform batch generation for multiple prompts.\n", - "- Deploy the model as an OpenAI-compatible server.\n", - "- Interact with the server using both a Python client and `curl`.\n", - "\n", - "This provides a solid foundation for integrating high-performance LLM inference into your applications.\n" - ] - } - ], - "metadata": { - "colab": { - "provenance": [] - }, - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.12.3" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} diff --git a/usage-cookbook/Llama-Nemotron-Super-49B-v1.5/vllm_api_cookbook.ipynb b/usage-cookbook/Llama-Nemotron-Super-49B-v1.5/vllm_api_cookbook.ipynb deleted file mode 100644 index 9d720fc..0000000 --- a/usage-cookbook/Llama-Nemotron-Super-49B-v1.5/vllm_api_cookbook.ipynb +++ /dev/null @@ -1,630 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Running Nemotron-49B-v1.5 with vLLM on NVIDIA GPUs\n", - "\n", - "This notebook provides a comprehensive guide on how to run the `Nemotron-49B-v1.5` model using vLLM, a high-performance library for LLM inference and serving.\n", - "\n", - "This notebook is divided into two parts:\n", - "- **Part 1:** Demonstrates how to use the direct vLLM Python API for inference, including batch generation and pseudo-streaming.\n", - "- **Part 2:** Covers how to deploy the model with an OpenAI-compatible web server for robust chat, streaming, and tool-use capabilities.\n", - "\n", - "#### Launch on NVIDIA Brev\n", - "You can simplify the environment setup by using [NVIDIA Brev](https://developer.nvidia.com/brev). Click the button below to launch this project on a Brev instance with the necessary dependencies pre-configured.\n", - "\n", - "Once deployed, click on the \"Open Notebook\" button to get started with this guide.\n", - "\n", - "[![Launch on Brev](https://brev-assets.s3.us-west-1.amazonaws.com/nv-lb-dark.svg)](https://brev.nvidia.com/launchable/deploy?launchableID=env-32vt7HcQjCUpafGyquLZwJdIm8F)\n", - "\n", - "- Model card: [nvidia/Llama-3.3-Nemotron-Super-49B-v1.5](https://huggingface.co/nvidia/Llama-3.3-Nemotron-Super-49B-v1.5)\n", - "- vLLM Docs: [https://docs.vllm.ai/](https://docs.vllm.ai/)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Table of Contents\n", - "\n", - "- [Part 1: Inference with the Python API](#Part-1:-Inference-with-the-Python-API)\n", - " - [Prerequisites](#Prerequisites)\n", - " - [Setup](#Setup)\n", - " - [Loading the Model](#Loading-the-Model)\n", - " - [Single and Batch Generation](#Single-and-Batch-Generation)\n", - " - [Streaming (Pseudo)](#Streaming-(Pseudo))\n", - "- [Part 2: OpenAI-Compatible Server](#Part-2:-OpenAI-Compatible-Server)\n", - " - [Launch Server](#Launch-Server)\n", - " - [Client Setup](#Client-Setup)\n", - " - [Chat and Streaming](#Chat-and-Streaming)\n", - " - [Reasoning Modes (`think` vs. `no_think`)](#Reasoning-Modes-(`think`-vs.-`no_think`))\n", - " - [Interaction with `curl`](#Interaction-with-`curl`)\n", - " - [Cleanup](#Cleanup)\n", - "- [Resource Notes](#Resource-Notes)\n", - "- [Conclusion](#Conclusion)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Part 1: Inference with the Python API" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Prerequisites\n", - "\n", - "**Hardware:** This notebook requires a machine with at least **2 NVIDIA GPUs** with sufficient VRAM to hold the 49B parameter model.\n", - "\n", - "**Software:**\n", - "- Python 3.10+\n", - "- CUDA 12.x\n", - "- PyTorch 2.3+\n", - "- vLLM 0.10.x\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Setup\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "/home/ubuntu/.venv/bin/python3: No module named pip\n", - "Note: you may need to restart the kernel to use updated packages.\n" - ] - } - ], - "source": [ - "# Install dependencies\n", - "%pip install -U \"vllm>=0.10.2,<0.11\" transformers torch \"flashinfer-python>=0.1.6\" openai" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/shadeform/miniconda3/envs/nemotron/lib/python3.13/site-packages/torch/cuda/__init__.py:63: FutureWarning: The pynvml package is deprecated. Please install nvidia-ml-py instead. If you did not install pynvml directly, please report this to the maintainers of the package that installed pynvml for you.\n", - " import pynvml # type: ignore[import]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CUDA available: True\n", - "Num GPUs: 1\n", - "GPU[0]: NVIDIA H200\n" - ] - } - ], - "source": [ - "# GPU environment check\n", - "import torch\n", - "import platform\n", - "\n", - "print(f\"Python: {platform.python_version()}\")\n", - "print(f\"PyTorch: {torch.__version__}\")\n", - "print(f\"CUDA available: {torch.cuda.is_available()}\")\n", - "print(f\"Num GPUs: {torch.cuda.device_count()}\")\n", - "\n", - "if torch.cuda.is_available():\n", - " for i in range(torch.cuda.device_count()):\n", - " props = torch.cuda.get_device_properties(i)\n", - " print(f\"GPU[{i}]: {props.name} | SM count: {props.multi_processor_count} | Mem: {props.total_memory / 1e9:.2f} GB\")\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Loading the Model" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "import os\n", - "from vllm import LLM, SamplingParams\n", - "\n", - "MODEL_ID = \"nvidia/Llama-3_3-Nemotron-Super-49B-v1.5\"\n", - "\n", - "llm = LLM(\n", - " model=MODEL_ID,\n", - " dtype=\"bfloat16\",\n", - " trust_remote_code=True,\n", - " max_model_len=65536,\n", - " gpu_memory_utilization=0.95,\n", - " tensor_parallel_size=1,\n", - ")\n", - "\n", - "print(\"Model ready\")\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Showcasing Reasoning Modes: `think` vs. `no_think`\n", - "\n", - "The Nemotron model supports two reasoning modes, which can be controlled via the system message:\n", - "\n", - "1. **Reasoning ON (default):** The model generates a `` block with its reasoning process before the answer.\n", - "2. **Reasoning OFF (`/no_think`):** By adding `/no_think` to the system prompt, the model provides a direct answer without the `` block. This is useful for simple tasks where you want a concise response.\n", - "\n", - "Since we are using the `vllm` python client which does not use the chat template, we will demonstrate this feature in the OpenAI-compatible server section.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Single and Batch Generation\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "7df793b5a507415aba9d36a65f290ef0", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Adding requests: 0%| | 0/1 [00:00 None:\n", - " outputs = llm.generate([prompt], sampling_params=sampling_params)\n", - " text = outputs[0].outputs[0].text\n", - " print(\"Response:\", end=\" \")\n", - " for ch in text:\n", - " print(ch, end=\"\", flush=True)\n", - " print()\n", - "\n", - "stream_like(\"Write a haiku about GPUs.\", llm, SamplingParams(temperature=0.7, max_tokens=80))\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "---\n", - "\n", - "## Part 2: OpenAI-Compatible Server\n", - "\n", - "vLLM offers an OpenAI-compatible server that allows you to use familiar tools like the OpenAI Python client and `curl`. This is the recommended way to use features like chat templates, streaming, and tool calling." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Launch Server\n", - "\n", - "Run the following command in your terminal to start the server.\n", - "\n", - "```bash\n", - "python -m vllm.entrypoints.openai.api_server \\\n", - " --model \"nvidia/Llama-3_3-Nemotron-Super-49B-v1_5\" \\\n", - " --dtype bfloat16 \\\n", - " --trust-remote-code \\\n", - " --served-model-name nemotron \\\n", - " --host 0.0.0.0 \\\n", - " --port 5000 \\\n", - " --max-model-len 65536 \\\n", - " --gpu-memory-utilization 0.95 \\\n", - " --tensor-parallel-size 1 \\\n", - " --enable-auto-tool-choice \\\n", - " --tool-call-parser llama3_json\n", - "```" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from openai import OpenAI\n", - "\n", - "# This assumes the server is running on localhost:5000\n", - "client = OpenAI(base_url=\"http://127.0.0.1:5000/v1\", api_key=\"dummy\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Chat and Streaming\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Okay, the user is asking for three bullet points about vLLM. Let me start by recalling what vLLM is. I know it's a framework for running large language models efficiently. The main points should highlight its key features.\n", - "\n", - "First, I remember that vLLM is designed for high throughput and low latency. That's important for applications needing quick responses. So maybe the first bullet can be about efficient inference with techniques like PagedAttention.\n", - "\n", - "Second, it's built on a modular architecture. This allows for customization, like integrating different models or backends. That's a good point for developers who need flexibility.\n", - "\n", - "\n", - "\n", - "Okay, the user wants a short poem about GPUs. Let me start by recalling what GPUs are. They're graphics processing units, right? Used for rendering images, video, and also for parallel computing tasks like machine learning.\n", - "\n", - "Hmm, I need to make the poem engaging and not too technical. Maybe focus on their speed, power, and applications. Words like \"silicon heart\" could personify the GPU. Also, terms like \"rendering light\" or \"shadows dance\" might evoke imagery related to graphics.\n", - "\n", - "I should structure it in stanzas, maybe four quatrains. Rhyming scheme could\n" - ] - } - ], - "source": [ - "# Simple chat completion\n", - "resp = client.chat.completions.create(\n", - " model=\"nemotron\",\n", - " messages=[\n", - " {\"role\": \"system\", \"content\": \"You are a helpful AI assistant.\"},\n", - " {\"role\": \"user\", \"content\": \"Give me 3 bullet points about vLLM.\"}\n", - " ],\n", - " temperature=0.6,\n", - " max_tokens=256,\n", - ")\n", - "print(\"--- Simple Chat Response ---\")\n", - "print(resp.choices[0].message.content)\n", - "\n", - "# Streaming chat completion\n", - "print(\"\\n--- Streaming Chat Response ---\")\n", - "stream = client.chat.completions.create(\n", - " model=\"nemotron\",\n", - " messages=[\n", - " {\"role\": \"system\", \"content\": \"You are a helpful AI assistant.\"},\n", - " {\"role\": \"user\", \"content\": \"Write a short poem about GPUs.\"}\n", - " ],\n", - " temperature=0.7,\n", - " max_tokens=256,\n", - " stream=True,\n", - ")\n", - "for chunk in stream:\n", - " delta = chunk.choices[0].delta\n", - " if delta and delta.content:\n", - " print(delta.content, end=\"\", flush=True)\n", - "print()\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Reasoning Modes (`think` vs. `no_think`)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Reasoning ON (default)\n", - "reasoning_prompt = \"I have 5 apples. I eat 2, then my friend gives me 3 more. How many apples do I have now?\"\n", - "messages_on = [\n", - " {\"role\": \"system\", \"content\": \"You are a helpful reasoning assistant.\"},\n", - " {\"role\": \"user\", \"content\": reasoning_prompt},\n", - "]\n", - "print(\"--- Reasoning ON ---\")\n", - "response_on = client.chat.completions.create(\n", - " model=\"nemotron\",\n", - " messages=messages_on,\n", - " temperature=0.0,\n", - " max_tokens=512,\n", - ")\n", - "print(response_on.choices[0].message.content)\n", - "\n", - "\n", - "# Reasoning OFF using /no_think\n", - "messages_off = [\n", - " {\"role\": \"system\", \"content\": \"You are a helpful reasoning assistant.\\n/no_think\"},\n", - " {\"role\": \"user\", \"content\": reasoning_prompt},\n", - "]\n", - "print(\"\\n--- Reasoning OFF ---\")\n", - "response_off = client.chat.completions.create(\n", - " model=\"nemotron\",\n", - " messages=messages_off,\n", - " temperature=0.0,\n", - " max_tokens=256,\n", - ")\n", - "print(response_off.choices[0].message.content)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## `curl` Examples\n", - "\n", - "You can also interact with the server directly using `curl`.\n", - "\n", - "**Chat completion:**\n", - "```bash\n", - "curl -sS -X POST http://127.0.0.1:5000/v1/chat/completions \\\n", - " -H \"Content-Type: application/json\" \\\n", - " -d '{\n", - " \"model\": \"nemotron\",\n", - " \"messages\": [\n", - " {\"role\": \"user\", \"content\": \"What is the capital of France?\"}\n", - " ],\n", - " \"temperature\": 0.0\n", - " }'\n", - "```\n", - "\n", - "**Streaming chat completion:**\n", - "```bash\n", - "curl -N -sS -X POST http://127.0.0.1:5000/v1/chat/completions \\\n", - " -H \"Content-Type: application/json\" \\\n", - " -d '{\n", - " \"model\": \"nemotron\",\n", - " \"messages\": [\n", - " {\"role\": \"user\", \"content\": \"Write a short poem about GPUs.\"}\n", - " ],\n", - " \"stream\": true\n", - " }'\n", - "```\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Cleanup\n", - "\n", - "To stop the OpenAI-compatible server, press `CTRL+C` in the terminal where it is running.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "---\n", - "## Resource Notes\n", - "\n", - "- **Hardware**: Nemotron-49B-v1.5 is a large model. For optimal performance, running on a multi-GPU setup with high-speed interconnects (like NVLink) is recommended.\n", - "- **Quantization**: vLLM supports various quantization techniques that can significantly reduce the memory footprint of the model, allowing it to run on smaller GPUs.\n", - "- **Chat Templates**: When using the OpenAI-compatible server, vLLM automatically applies the correct chat template for the model, which is crucial for getting properly formatted and accurate responses in conversational tasks.\n", - "- **Tool Calling**: The `--enable-auto-tool-choice` and `--tool-call-parser` flags enable advanced tool-calling capabilities for the model.\n", - "\n", - "## Conclusion\n", - "\n", - "In this notebook, you have learned how to:\n", - "- Run inference with the Nemotron-49B-v1.5 model using the vLLM Python API.\n", - "- Deploy the model as an OpenAI-compatible server.\n", - "- Interact with the server using both a Python client and `curl` for chat, streaming, and reasoning mode demonstrations.\n", - "- Utilize the model's reasoning modes for different use cases.\n", - "\n", - "This notebook provides a solid foundation for building applications with Nemotron and vLLM.\n" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "vllm", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.18" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/usage-cookbook/Nemotron-3-Nano/sglang_cookbook.ipynb b/usage-cookbook/Nemotron-3-Nano/sglang_cookbook.ipynb deleted file mode 100644 index e475b3d..0000000 --- a/usage-cookbook/Nemotron-3-Nano/sglang_cookbook.ipynb +++ /dev/null @@ -1,423 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Deploying NVIDIA Nemotron-3-Nano with SGLang\n", - "\n", - "This notebook will walk you through how to run the `nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B` model with SGLang.\n", - "\n", - "[SGLang](https://github.com/sgl-project/sglang) is a fast serving framework for large language models and vision language models.\n", - "\n", - "For more details on the model [click here](https://huggingface.co/nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-FP8)\n", - "\n", - "Prerequisites:\n", - "- NVIDIA GPU with recent drivers (≥ 60 GB VRAM for BF16, ≥ 32 GB for FP8) and CUDA 12.x\n", - "- Python 3.10+" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Launch on NVIDIA Brev\n", - "You can simplify the environment setup by using [NVIDIA Brev](https://developer.nvidia.com/brev). Click the button to launch this project on a Brev instance with the necessary dependencies pre-configured.\n", - "\n", - "Once deployed, click on the \"Open Notebook\" button to get started with this guide. \n", - "\n", - "[![Launch on Brev](https://brev-assets.s3.us-west-1.amazonaws.com/nv-lb-dark.svg)](https://brev.nvidia.com/launchable/deploy?launchableID=env-36ikQZX0ZDTSCGE7YkqxiOKwKsj) " - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Looking in links: /tmp/tmp3hfrr9so\n", - "Requirement already satisfied: pip in ./.venv/lib/python3.12/site-packages (25.0.1)\n" - ] - } - ], - "source": [ - "#If pip not found\n", - "!python -m ensurepip --default-pip" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Install dependencies" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "%pip install sglang torch" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Verify GPU\n", - "\n", - "Confirm CUDA is available and your GPU is visible to PyTorch.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CUDA available: True\n", - "Num GPUs: 1\n", - "GPU[0]: NVIDIA H100 80GB HBM3\n" - ] - } - ], - "source": [ - "# GPU environment check\n", - "import torch\n", - "print(f\"CUDA available: {torch.cuda.is_available()}\")\n", - "print(f\"Num GPUs: {torch.cuda.device_count()}\")\n", - "if torch.cuda.is_available():\n", - " for i in range(torch.cuda.device_count()):\n", - " print(f\"GPU[{i}]: {torch.cuda.get_device_name(i)}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Start SGLang Server\n", - "\n", - "SGLang runs as a separate server process. \n", - "\n", - "Before starting the server, ensure that your notebook and terminal are in the same virtual environment.\n", - "\n", - "Within Brev, open a terminal and run:\n", - "```shell\n", - "source /home/shadeform/.venv/bin/activate\n", - "```\n", - "\n", - "Then, choose the desired model (FP8 or BF16) and run the following command in the terminal." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Load the BF16 version\n", - "\n", - "```shell\n", - "python3 -m sglang.launch_server --model-path nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-BF16 \\\n", - "--host 0.0.0.0 --port 5000 --log-level warning --trust-remote-code --tool-call-parser qwen3_coder --reasoning-parser deepseek-r1\n", - "```" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Alternative: Load the FP8 quantized version for faster inference and lower memory usage\n", - "\n", - "```shell\n", - "python3 -m sglang.launch_server --model-path nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-FP8 \\\n", - "--host 0.0.0.0 --port 5000 --log-level warning --trust-remote-code --tool-call-parser qwen3_coder --reasoning-parser deepseek-r1\n", - "```" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "OpenAI client configured to use server at: http://localhost:5000/v1\n", - "Using model: nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-BF16\n" - ] - } - ], - "source": [ - "## Client Setup\n", - "from openai import OpenAI\n", - "\n", - "# The model name we used when launching the server.\n", - "SERVED_MODEL_NAME = \"nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-BF16\"\n", - "\n", - "BASE_URL = f\"http://localhost:5000/v1\"\n", - "API_KEY = \"EMPTY\" # SGLang server doesn't require an API key by default\n", - "\n", - "client = OpenAI(base_url=BASE_URL, api_key=API_KEY)\n", - "print(f\"OpenAI client configured to use server at: {BASE_URL}\")\n", - "print(f\"Using model: {SERVED_MODEL_NAME}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Generate responses\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Simple vs streamed generation\n" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "We need to provide 3 bullet points about SGLang. Likely SGLang is a programming language or library for efficient tensor parallelism? Actually SGLang might refer to \"Stochastic Gradient Language\"? Or \"SGLang\" is a programming language for specifying and optimizing models? Let's recall: SGLang might be \"Sparse Graph Language\"? Actually I think SGLang is \"Stochastic Gradient Descent Language\"? Wait maybe it's \"SGLang: A Language for Specifying and Executing Graph Programs\"? Hmm.\n", - "\n", - "Search memory: I recall \"SGLang\" is a language for specifying graph neural networks? Actually there is \"SGLang: A Language for Graph Neural Networks\"? Not sure.\n", - "\n", - "Let's think: SGLang could be \"Stochastic Gradient Language\"? Or \"SGLang: A Language for Specifying Structured Graphs\"? I think it's a programming language for specifying and executing graph algorithms efficiently, maybe from MIT? I recall \"SGLang: A Language for Graph Processing\". Actually there is \"SGLang: A Language for Graph Processing on GPUs\". Let me recall: There is \"SGLang: A Language for Graph Processing on GPUs\" introduced at PLDI or SOSP? Actually I think it's \"SGLang: A Language for Graph Processing on GPUs\" by MIT? Or \"SGLang: A Language for Specifying and Executing Graph Neural Networks\"? Hmm.\n", - "\n", - "Better to provide generic bullet points: 1) SGLang is a high-level programming language designed for specifying graph algorithms with automatic optimization. 2) It provides a concise syntax for expressing graph traversals, aggregations, and neural network operations, and compiles them to efficient GPU kernels. 3) It includes a runtime that leverages just-in-time compilation and memory management to achieve performance comparable to hand‑written CUDA kernels while maintaining programmer productivity.\n", - "\n", - "Alternatively, SGLang might be \"Stochastic Gradient Descent Language\" used for deep learning? Actually there is \"SGLang: A Language for Specifying Graph Neural Networks\" from MIT? Let’s search memory: I think SGLang stands for \"Stochastic Graph Language\"? Not sure.\n", - "\n", - "Given uncertainty, I can give generic bullet points about SGLang as a programming language for graph processing and GNNs, focusing on its features: high-level abstraction, automatic kernel fusion, GPU acceleration, etc.\n", - "\n", - "Provide three bullet points.\n", - "\n", - "I'll None\n", - "\n", - "\n" - ] - } - ], - "source": [ - "resp = client.chat.completions.create(\n", - " model=SERVED_MODEL_NAME,\n", - " messages=[\n", - " {\"role\": \"system\", \"content\": \"You are a helpful AI assistant.\"},\n", - " {\"role\": \"user\", \"content\": \"Give me 3 bullet points about SGLang.\"}\n", - " ],\n", - " temperature=0.6,\n", - " max_tokens=512,\n", - ")\n", - "print(resp.choices[0].message.reasoning_content, resp.choices[0].message.content)\n", - "print(\"\\n\")" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "The first five prime numbers are:\n", - "\n", - "**2, 3, 5, 7, 11**." - ] - } - ], - "source": [ - "# Streaming chat completion\n", - "stream = client.chat.completions.create(\n", - " model=SERVED_MODEL_NAME,\n", - " messages=[\n", - " {\"role\": \"system\", \"content\": \"You are a helpful AI assistant.\"},\n", - " {\"role\": \"user\", \"content\": \"What are the first 5 prime numbers?\"}\n", - " ],\n", - " temperature=0.7,\n", - " max_tokens=1024,\n", - " stream=True,\n", - ")\n", - "for chunk in stream:\n", - " delta = chunk.choices[0].delta\n", - " if delta and delta.content:\n", - " print(delta.content, end=\"\", flush=True)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Reasoning\n", - "\n", - "Note: The model supports two modes - Reasoning ON (default) vs OFF. This can be toggled by setting enable_thinking to False, as shown below. " - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Reasoning on\n", - "The user wants a haiku about GPUs. Provide a haiku (5-7-5 syllable structure). Something like \"Silicon dreams hum / parallel hearts blaze in code / rays of light, rendered\". Need to ensure correct syllable count. Let's craft:\n", - "\n", - "\"Silicon sunrise / CUDA cores pulse bright and swift / worlds rendered at once\"\n", - "\n", - "Count syllables:\n", - "\n", - "Silicon (4? Sil-i-con: 3) sunrise (2) => 5 syllables? Actually \"Silicon\" is 3 syllables (sil-i-con). \"sunrise\" is 2, total 5. Good.\n", - "\n", - "Second line: \"CUDA cores pulse bright and swift\" Count: CUDA (2? \"cu-da\" 2), cores (1), pulse (1), bright (1), and (1), swift (1) = total 7? Let's count: CUDA (2) + cores (1) =3, pulse (1)=4, bright (1)=5, and (1)=6, swift (1)=7. So 7 syllables. Good.\n", - "\n", - "Third line: \"worlds rendered at once\" Count: worlds (1), ren-dered (2), at (1), once (1 None\n", - "\n", - "\n", - "Reasoning off\n", - "Here are 3 interesting facts about **SGLang** (a programming language designed for efficient, scalable AI inference and training, particularly for large language models):\n", - "\n", - "1. **Hardware-Aware Compilation for Accelerated Inference** \n", - " SGLang compiles high-level models (e.g., PyTorch) into optimized code for **GPUs, TPUs, or custom accelerators** by fusing operations and leveraging low-level hardware features. Unlike traditional frameworks that require manual kernel tuning, SGLang automatically generates highly efficient kernels (e.g., for attention mechanisms), achieving **2–10x speedups** over PyTorch or TensorFlow without code changes. This makes it ideal for deploying large models on commodity hardware.\n", - "\n", - "2. **Unified Runtime for Multi-Modal & Multi-Model Workloads** \n", - " SGLang’s runtime natively supports **diverse model types** (e.g., LLMs, vision transformers, diffusion models) and **multiple hardware backends** (GPU, CPU, custom ASICs) through a single interface. It dynamically routes operations to the best-suited hardware (e.g., using GPU for attention and CPU for preprocessing), enabling seamless execution of complex pipelines like \"text None\n" - ] - } - ], - "source": [ - "# Reasoning on (default)\n", - "print(\"Reasoning on\")\n", - "resp = client.chat.completions.create(\n", - " model=\"nemotron\",\n", - " messages=[\n", - " {\"role\": \"system\", \"content\": \"You are a helpful assistant.\"},\n", - " {\"role\": \"user\", \"content\": \"Write a haiku about GPUs.\"}\n", - " ],\n", - " temperature=1,\n", - " max_tokens=256,\n", - ")\n", - "print(resp.choices[0].message.reasoning_content, resp.choices[0].message.content)\n", - "print(\"\\n\")\n", - "# Reasoning off\n", - "print(\"Reasoning off\")\n", - "resp = client.chat.completions.create(\n", - " model=\"nemotron\",\n", - " messages=[\n", - " {\"role\": \"system\", \"content\": \"You are a helpful assistant.\"},\n", - " {\"role\": \"user\", \"content\": \"Give me 3 interesting facts about SGLang.\"}\n", - " ],\n", - " temperature=0,\n", - " max_tokens=256,\n", - " extra_body={\"chat_template_kwargs\": {\"enable_thinking\": False}}\n", - ")\n", - "print(resp.choices[0].message.reasoning_content, resp.choices[0].message.content)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Tool calling\n", - "\n", - "Call functions using the OpenAI Tools schema and inspect returned tool_calls." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Okay, the user wants to calculate a 15% tip on a $50 bill. Let me check the available tools. There's a function called calculate_tip that takes bill_total and tip_percentage. The parameters are required, so I need both values. The bill is $50, so bill_total is 50. The tip percentage is 15. I should call the function with these values. Let me make sure the parameters are integers as specified. Yep, 50 and 15 are both integers. I'll structure the tool call accordingly.\n", - "\n", - "[ChatCompletionMessageFunctionToolCall(id='call_dcbe885e69ea4a15b0174d1f', function=Function(arguments='{\"bill_total\": 50, \"tip_percentage\": 15}', name='calculate_tip'), type='function', index=-1)]\n" - ] - } - ], - "source": [ - "# Tool calling via OpenAI tools schema\n", - "TOOLS = [\n", - " {\n", - " \"type\": \"function\",\n", - " \"function\": {\n", - " \"name\": \"calculate_tip\",\n", - " \"parameters\": {\n", - " \"type\": \"object\",\n", - " \"properties\": {\n", - " \"bill_total\": {\n", - " \"type\": \"integer\",\n", - " \"description\": \"The total amount of the bill\"\n", - " },\n", - " \"tip_percentage\": {\n", - " \"type\": \"integer\",\n", - " \"description\": \"The percentage of tip to be applied\"\n", - " }\n", - " },\n", - " \"required\": [\"bill_total\", \"tip_percentage\"]\n", - " }\n", - " }\n", - " }\n", - "]\n", - "\n", - "completion = client.chat.completions.create(\n", - " model=\"nemotron\",\n", - " messages=[\n", - " {\"role\": \"system\", \"content\": \"\"},\n", - " {\"role\": \"user\", \"content\": \"My bill is $50. What will be the amount for 15% tip?\"}\n", - " ],\n", - " tools=TOOLS,\n", - " temperature=0.6,\n", - " top_p=0.95,\n", - " max_tokens=512,\n", - " stream=False\n", - ")\n", - "\n", - "print(completion.choices[0].message.reasoning_content)\n", - "print(completion.choices[0].message.tool_calls)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.12.12" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/usage-cookbook/Nemotron-3-Nano/trtllm_cookbook.ipynb b/usage-cookbook/Nemotron-3-Nano/trtllm_cookbook.ipynb deleted file mode 100644 index 6afa3b8..0000000 --- a/usage-cookbook/Nemotron-3-Nano/trtllm_cookbook.ipynb +++ /dev/null @@ -1,443 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Deploying NVIDIA Nemotron-3-Nano with TensorRT LLM\n", - "\n", - "This notebook will walk you through how to run the `nnvidia/NVIDIA-Nemotron-3-Nano-30B-A3B` model via TensorRT-LLM\n", - "\n", - "[TensorRT LLM](https://nvidia.github.io/TensorRT-LLM/) is NVIDIA’s open-source library for accelerating and optimizing LLM inference performance on NVIDIA GPUs. TRTLLM support for this model is enabled through the AutoDeploy workflow. More details about this workflow can be found [here](https://nvidia.github.io/TensorRT-LLM/features/auto_deploy/auto-deploy.html).\n", - "\n", - "For more details on the model [click here](https://huggingface.co/nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-FP8). \n", - "\n", - "Prerequisites:\n", - "- NVIDIA GPU with recent drivers (≥ 60 GB VRAM for BF16, ≥ 32 GB for FP8) and CUDA 12.x\n", - "- Python 3.10+\n", - "- TensorRT-LLM (you can refer to NVIDIA documentation, or pull this [container](https://catalog.ngc.nvidia.com/orgs/nvidia/teams/tensorrt-llm/containers/release?version=1.2.0rc5))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Launch on NVIDIA Brev\n", - "You can simplify the environment setup by using [NVIDIA Brev](https://developer.nvidia.com/brev). Click the button to launch this project on a Brev instance with the necessary dependencies pre-configured.\n", - "\n", - "Once deployed, click on the \"Open Notebook\" button to get started with this guide. \n", - "\n", - "[![Launch on Brev](https://brev-assets.s3.us-west-1.amazonaws.com/nv-lb-dark.svg)](https://brev.nvidia.com/launchable/deploy?launchableID=env-36ikYKeRmXqG8MJjxsgROJM4S2V)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Prerequisites & environment\n", - "\n", - "Set up a containerized environment for TensorRT-LLM by running the following command in a terminal.\n", - "\n", - "```shell\n", - "docker run --rm -it --ipc=host --ulimit memlock=-1 --ulimit stack=67108864 --gpus=all -p 8000:8000 nvcr.io/nvidia/tensorrt-llm/release:1.2.0rc5\n", - "```\n", - "\n", - "You now have TRT-LLM set up! " - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Looking in links: /tmp/tmpuvjbo8y1\n", - "Requirement already satisfied: pip in ./.venv/lib/python3.12/site-packages (25.0.1)\n" - ] - } - ], - "source": [ - "#If pip not found\n", - "!python -m ensurepip --default-pip" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "scrolled": true - }, - "outputs": [], - "source": [ - "%pip install torch openai" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Verify GPU\n", - "\n", - "Check that CUDA is available and the GPU is detected correctly.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Python: 3.12.12 (main, Dec 9 2025, 19:02:36) [Clang 21.1.4 ]\n", - "CUDA available: True\n", - "Num GPUs: 1\n", - "GPU[0]: NVIDIA H100 80GB HBM3\n" - ] - } - ], - "source": [ - "# Environment check\n", - "import sys\n", - "import torch\n", - "\n", - "print(f\"Python: {sys.version}\")\n", - "print(f\"CUDA available: {torch.cuda.is_available()}\")\n", - "print(f\"Num GPUs: {torch.cuda.device_count()}\")\n", - "\n", - "if torch.cuda.is_available():\n", - " for i in range(torch.cuda.device_count()):\n", - " print(f\"GPU[{i}]: {torch.cuda.get_device_name(i)}\")\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## OpenAI-compatible server\n", - "\n", - "Start a local OpenAI-compatible server with TensorRT-LLM via the terminal, within the running docker container.\n", - "\n", - "Ensure that the following commands are executed from the docker terminal.\n", - "\n", - "### Create a YAML file with the required configuration\n", - "\n", - "```shell\n", - "cat > nano_v3.yaml<= mamba page size.\n", - "INFO 12-12 19:00:07 [config.py:463] Padding mamba page size by 1.13% to ensure that mamba page size and attention page size are exactly equal.\n", - "\u001b[0;36m(EngineCore_DP0 pid=55476)\u001b[0;0m INFO 12-12 19:00:08 [core.py:93] Initializing a V1 LLM engine (v0.12.0) with config: model='nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-BF16', speculative_config=None, tokenizer='nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-BF16', skip_tokenizer_init=False, tokenizer_mode=auto, revision=None, tokenizer_revision=None, trust_remote_code=True, dtype=torch.bfloat16, max_seq_len=262144, download_dir=None, load_format=auto, tensor_parallel_size=1, pipeline_parallel_size=1, data_parallel_size=1, disable_custom_all_reduce=False, quantization=None, enforce_eager=False, kv_cache_dtype=auto, device_config=cuda, structured_outputs_config=StructuredOutputsConfig(backend='auto', disable_fallback=False, disable_any_whitespace=False, disable_additional_properties=False, reasoning_parser='', reasoning_parser_plugin='', enable_in_reasoning=False), observability_config=ObservabilityConfig(show_hidden_metrics_for_version=None, otlp_traces_endpoint=None, collect_detailed_traces=None, kv_cache_metrics=False, kv_cache_metrics_sample=0.01), seed=0, served_model_name=nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-BF16, enable_prefix_caching=False, enable_chunked_prefill=True, pooler_config=None, compilation_config={'level': None, 'mode': , 'debug_dump_path': None, 'cache_dir': '', 'compile_cache_save_format': 'binary', 'backend': 'inductor', 'custom_ops': ['none'], 'splitting_ops': ['vllm::unified_attention', 'vllm::unified_attention_with_output', 'vllm::unified_mla_attention', 'vllm::unified_mla_attention_with_output', 'vllm::mamba_mixer2', 'vllm::mamba_mixer', 'vllm::short_conv', 'vllm::linear_attention', 'vllm::plamo2_mamba_mixer', 'vllm::gdn_attention_core', 'vllm::kda_attention', 'vllm::sparse_attn_indexer'], 'compile_mm_encoder': False, 'compile_sizes': [], 'inductor_compile_config': {'enable_auto_functionalized_v2': False, 'combo_kernels': True, 'benchmark_combo_kernel': True}, 'inductor_passes': {}, 'cudagraph_mode': , 'cudagraph_num_of_warmups': 1, 'cudagraph_capture_sizes': [1, 2, 4, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 88, 96, 104, 112, 120, 128, 136, 144, 152, 160, 168, 176, 184, 192, 200, 208, 216, 224, 232, 240, 248, 256, 272, 288, 304, 320, 336, 352, 368, 384, 400, 416, 432, 448, 464, 480, 496, 512], 'cudagraph_copy_inputs': False, 'cudagraph_specialize_lora': True, 'use_inductor_graph_partition': False, 'pass_config': {'fuse_norm_quant': False, 'fuse_act_quant': False, 'fuse_attn_quant': False, 'eliminate_noops': True, 'enable_sp': False, 'fuse_gemm_comms': False, 'fuse_allreduce_rms': False}, 'max_cudagraph_capture_size': 512, 'dynamic_shapes_config': {'type': }, 'local_cache_dir': None}\n", - "\u001b[0;36m(EngineCore_DP0 pid=55476)\u001b[0;0m INFO 12-12 19:00:09 [parallel_state.py:1200] world_size=1 rank=0 local_rank=0 distributed_init_method=tcp://192.168.122.108:51693 backend=nccl\n", - "\u001b[0;36m(EngineCore_DP0 pid=55476)\u001b[0;0m INFO 12-12 19:00:09 [parallel_state.py:1408] rank 0 in world size 1 is assigned as DP rank 0, PP rank 0, PCP rank 0, TP rank 0, EP rank 0\n", - "[Gloo] Rank 0 is connected to 0 peer ranks. Expected number of connected peer ranks is : 0\n", - "[Gloo] Rank 0 is connected to 0 peer ranks. Expected number of connected peer ranks is : 0\n", - "[Gloo] Rank 0 is connected to 0 peer ranks. Expected number of connected peer ranks is : 0\n", - "[Gloo] Rank 0 is connected to 0 peer ranks. Expected number of connected peer ranks is : 0\n", - "[Gloo] Rank 0 is connected to 0 peer ranks. Expected number of connected peer ranks is : 0\n", - "[Gloo] Rank 0 is connected to 0 peer ranks. Expected number of connected peer ranks is : 0\n", - "[Gloo] Rank 0 is connected to 0 peer ranks. Expected number of connected peer ranks is : 0\n", - "\u001b[0;36m(EngineCore_DP0 pid=55476)\u001b[0;0m INFO 12-12 19:00:09 [gpu_model_runner.py:3467] Starting to load model nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-BF16...\n", - "\u001b[0;36m(EngineCore_DP0 pid=55476)\u001b[0;0m INFO 12-12 19:00:09 [layer.py:379] Enabled separate cuda stream for MoE shared_experts\n", - "\u001b[0;36m(EngineCore_DP0 pid=55476)\u001b[0;0m INFO 12-12 19:00:10 [cuda.py:411] Using FLASH_ATTN attention backend out of potential backends: ['FLASH_ATTN', 'FLASHINFER', 'TRITON_ATTN', 'FLEX_ATTENTION']\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Loading safetensors checkpoint shards: 0% Completed | 0/13 [00:00\n", - "* vLLM is an open‑source\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Adding requests: 100%|██████████| 3/3 [00:00<00:00, 2030.48it/s]\n", - "Processed prompts: 100%|██████████| 3/3 [00:01<00:00, 1.60it/s, est. speed input: 9.60 toks/s, output: 235.75 toks/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Prompt 1: 'Hello, my name is'\n", - " NAME_1. Let's chat!\" The placeholder NAME_1 likely should be replaced with something? The user gave that as instruction; they might want the assistant to adopt that name? The instruction says \"You are a chat bot, your goal is to continue the conversation between Bot and Visitor.\" The example shows Bot says \"Hello, my name is NAME_1. Let's chat!\" So we should continue from that. The bot introduced itself as NAME_1. So we need to respond as Visitor? Or as Bot? The user says \"continue the conversation between Bot and Visitor.\" So we need to produce the next turn. The Bot already said greeting. So Visitor should reply. Probably we should respond as Visitor with a greeting and maybe ask how Bot is. Then Bot replies, etc. But the instruction: \"You are a chat bot, your goal is to continue the conversation between Bot and Visitor.\" So we need to output the next messages? Probably we\n", - "\n", - "Prompt 2: 'The capital of France is'\n", - " Paris.\" with no extra words or explanation. This is a straightforward request, not disallowed. We can comply. Provide exactly that sentence, no extra words.\n", - "\n", - "The capital of France is Paris.\n", - "\n", - "Prompt 3: 'Explain quantum computing in simple terms:'\n", - " like a library with many books that can be in many states at once, etc. Provide analogies. Should be friendly. No disallowed content. Provide answer.\n", - "\n", - "**Quantum Computing in a Nutshell (with a cozy knitting analogy)** \n", - "\n", - "---\n", - "\n", - "### 1. The Classical Computer: A Simple Stitch\n", - "- **Bit = a single stitch** – it can be either **0** (off) or **1** (on). \n", - "- By chaining many stitches together, a classical computer can represent any pattern, but each stitch has only one color at a time.\n", - "\n", - "### 2. The Quantum Computer: A Magical Yarn\n", - "- **Qubit = a “quantum stitch”** – it can be **0, 1, or a blend of both** at the same time. \n", - "- In knitting terms, imagine a yarn that can be **half red, half blue, and also shimmering** all\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "from vllm import SamplingParams\n", - "\n", - "params = SamplingParams(temperature=0.6, max_tokens=200)\n", - "\n", - "# Single prompt\n", - "single = llm.generate([\"Give me 3 bullet points about vLLM.\"], sampling_params=params)\n", - "print(single[0].outputs[0].text)\n", - "\n", - "# Batch prompts\n", - "prompts = [\n", - " \"Hello, my name is\",\n", - " \"The capital of France is\",\n", - " \"Explain quantum computing in simple terms:\"\n", - "]\n", - "outputs = llm.generate(prompts, sampling_params=params)\n", - "for i, out in enumerate(outputs):\n", - " print(f\"\\nPrompt {i+1}: {out.prompt!r}\")\n", - " print(out.outputs[0].text)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Streamed generation\n", - "\n", - "Print characters as they are produced." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Adding requests: 100%|██████████| 1/1 [00:00<00:00, 1157.37it/s]\n", - "Processed prompts: 100%|██████████| 1/1 [00:02<00:00, 2.49s/it, est. speed input: 3.21 toks/s, output: 205.41 toks/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Response: Also mention \"Raiden Shogun\". Ensure haiku format: 5-7-5 syllables.\n", - "\n", - "We can produce:\n", - "\n", - "\"Silicon thunder,\n", - "Raiden's will in silicon,\n", - "Electrons pulse, swift.\"\n", - "\n", - "But that's not correct syllable count. Let's craft:\n", - "\n", - "\"Lightning cores ignite (5)\n", - "Raiden's will on silicon (7)\n", - "Sparks of fate arise (5)\n", - "\n", - "But need 5-7-5. Let's count.\n", - "\n", - "Line1: \"Lightning cores ignite\" -> Light-ning (2) cores (1) i-gnite (2) = 5? Let's count: Light(1) ning(1) = 2? Actually \"lightning\" is 2 syllables. \"cores\" 1, \"ignite\" 2 => total 5. Good.\n", - "\n", - "Line2: \"Raiden's will on silicon\" -> count: Ra-i-den's (3? Actually \"Raiden\" is 2 syllables? It's \"Ry-deen\"? Usually 2? In English \"Raiden\" is 2 syllables: \"Ry-den\". With possessive \"Raiden's\" still 2. \"will\" 1, \"on\" 1, \"silicon\" 3? \"si-li-con\" 3. So total 2+1+1+3 = 7. Good.\n", - "\n", - "Line3: \"Sparks of fate arise\" -> Sparks (1) of (1) fate (1) a-rise (2) = 5. Good.\n", - "\n", - "Thus haiku:\n", - "\n", - "Lightning cores ig" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "nite \n", - "Raiden's will on silicon \n", - "Sparks of fate arise\n", - "\n", - "We can also mention \"GPU\" explicitly. Maybe \"GPU\" in line2? But we already have silicon. Could incorporate \"GPU\" but keep syllable count.\n", - "\n", - "Maybe:\n", - "\n", - "\"Silicon thunder (5?) Count: Si-li-con (3) thun-der (2) = 5. Good.\n", - "\n", - "\"Raiden's will in GPU\" Count: Ra-i-den's (2) will (1) in (1) G-P-U (3?) Actually \"GPU\" pronounced \"gee-pee-you\" 3 syllables. So total 2+1+1+3 = 7. Good.\n", - "\n", - "\"Electrons blaze\" Count: Elec-trons (3) blaze (1) = 4, need 5.\n" - ] - } - ], - "source": [ - "def stream_like(prompt: str, llm: LLM, sampling_params: SamplingParams) -> None:\n", - " outputs = llm.generate([prompt], sampling_params=sampling_params)\n", - " text = outputs[0].outputs[0].text\n", - " print(\"Response:\", end=\" \")\n", - " for ch in text:\n", - " print(ch, end=\"\", flush=True)\n", - " print()\n", - "\n", - "stream_like(\"Write a haiku about GPUs.\", llm, SamplingParams(temperature=0.7, max_tokens=512))\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## OpenAI-compatible server\n", - "\n", - "Serve the model via an OpenAI-compatible API using vLLM.\n", - "\n", - "Before starting the server:\n", - "- Restart the kernel to free GPU memory used by the in-process LLM\n", - "- Ensure you use the same virtual environment with installed dependencies in your terminal. To do this within your Brev instance, open a terminal and run:\n", - " ```shell\n", - " source /home/shadeform/.venv/bin/activate\n", - " ```\n", - "- Choose the desired model (FP8 or BF16). The snippet below pulls the BF16 version." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "After restarting the kernel, run this in a terminal:\n", - "\n", - "```shell\n", - "git clone https://huggingface.co/nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-BF16\n", - "```\n", - "\n", - "```shell\n", - "python3 -m vllm.entrypoints.openai.api_server \\\n", - " --model \"nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-BF16\" \\\n", - " --dtype auto \\\n", - " --trust-remote-code \\\n", - " --served-model-name nemotron \\\n", - " --host 0.0.0.0 \\\n", - " --port 5000 \\\n", - " --enable-auto-tool-choice \\\n", - " --tool-call-parser qwen3_coder \\\n", - " --reasoning-parser-plugin \"NVIDIA-Nemotron-3-Nano-30B-A3B-BF16/nano_v3_reasoning_parser.py\" \\\n", - " --reasoning-parser nano_v3\n", - "```" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Your server is now running!" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Use the API\n", - "\n", - "Send chat and streaming requests to your vLLM server using the OpenAI-compatible client." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Note: The model supports two modes - Reasoning ON (default) vs OFF. This can be toggled by setting enable_thinking to False, as shown below." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "# Client: Standard chat and streaming\n", - "from openai import OpenAI\n", - "\n", - "client = OpenAI(base_url=\"http://127.0.0.1:5000/v1\", api_key=\"null\")" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Reasoning on\n", - "Reasoning: We need to output a haiku about GPUs. Haiku is 5-7-5 syllables, about GPUs.\n", - "\n", - "We'll produce a haiku.\n", - "\n", - "Need ensure correct syllable count.\n", - "\n", - "Potential haiku:\n", - "\n", - "\"Silicon heart thrums / parallel streams blaze night and day / fire forged in clay.\"\n", - "\n", - "Let's count syllables:\n", - "\n", - "Silicon-heart thrums = Si-li-con (3) heart (1) thrums (1) =5? Actually \"Silicon\" is 3 syllables (Si-li-con). \"heart\" is 1, \"thrums\" 1 => total 5. Good.\n", - "\n", - "parallel streams blaze night and day = par-allel (3) streams (1) blaze (1) night (1) and (1) day (1) =8? Let's count properly: \"parallel\" = 3 syllables (par-al-llel? Actually typically 3: par-al-lel). \"streams\" = 1, \"blaze\" =1, \"night\" =1, \"and\" =1, \"day\" =1 => total 3+1+1+1+1+1 =8 syllables. That's too many. Need 7.\n", - "\n", - " \n", - "Content: None\n", - "\n", - "\n", - "Reasoning off\n", - "Here are 3 interesting facts about **vLLM** (a high-performance library for serving large language models):\n", - "\n", - "1. **PagedAttention: Revolutionizing Memory Management** \n", - " vLLM introduces **PagedAttention**, a novel memory management technique inspired by virtual memory paging in operating systems. Instead of requiring contiguous GPU memory for KV caches (which causes fragmentation and limits batch sizes), it dynamically allocates memory blocks across the GPU. This allows vLLM to serve **2–4× more concurrent requests** with the same hardware (e.g., fitting 24K tokens on a single A100 vs. 6K in Hugging Face Transformers).\n", - "\n", - "2. **Native Support for Multi-Turn Conversations** \n", - " Unlike many frameworks that require manual prompt engineering for chat history, vLLM natively handles **multi-turn dialogue** via its `ChatTemplate` system. It automatically structures prompts with system/user/assistant roles, manages context windows, and supports streaming responses—making it ideal for building chatbots without custom preprocessing.\n", - "\n", - "3. **Open-Source & Community-Driven Innovation** \n", - " vLLM is **100% open-source** (Apache 2.0 license)\n" - ] - } - ], - "source": [ - "# Reasoning on (default)\n", - "print(\"Reasoning on\")\n", - "resp = client.chat.completions.create(\n", - " model=\"nemotron\",\n", - " messages=[\n", - " {\"role\": \"system\", \"content\": \"You are a helpful assistant.\"},\n", - " {\"role\": \"user\", \"content\": \"Write a haiku about GPUs.\"}\n", - " ],\n", - " temperature=1,\n", - " max_tokens=256,\n", - ")\n", - "print(\"Reasoning:\", resp.choices[0].message.reasoning_content, \"\\nContent:\", resp.choices[0].message.content)\n", - "print(\"\\n\")\n", - "# Reasoning off\n", - "print(\"Reasoning off\")\n", - "resp2 = client.chat.completions.create(\n", - " model=\"nemotron\",\n", - " messages=[\n", - " {\"role\": \"system\", \"content\": \"You are a helpful assistant.\"},\n", - " {\"role\": \"user\", \"content\": \"Give me 3 interesting facts about vLLM.\"}\n", - " ],\n", - " temperature=0,\n", - " max_tokens=256,\n", - " extra_body={\"chat_template_kwargs\": {\"enable_thinking\": False}}\n", - ")\n", - "print(resp2.choices[0].message.content)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "The first 5 prime numbers are: \n", - "**2, 3, 5, 7, 11**. \n", - "\n", - "### Why?\n", - "- **Prime numbers** are natural numbers greater than 1 that have no positive divisors other than 1 and themselves.\n", - "- **2** is the smallest prime (and the only even prime).\n", - "- **3**, **5**, **7**, and **11** follow as the next primes (4, 6, 8, 9, 10 are not prime).\n", - "\n", - "### Quick Check:\n", - "| Number | Divisible by? | Prime? |\n", - "|--------|---------------|--------|\n", - "| 2 | 1, 2 | ✅ Yes |\n", - "| 3 | 1, 3 | ✅ Yes |\n", - "| 4 | 1, 2, 4 | ❌ No |\n", - "| 5 | 1, 5 | ✅ Yes |\n", - "| 6 | 1, 2, 3, 6 | ❌ No |\n", - "| 7 | 1, 7 | ✅ Yes |\n", - "| 8, 9, 10 | (not prime) | ❌ No |\n", - "| **11** | **1, 11** | ✅ **Yes** |\n", - "\n", - "Thus, the sequence of the first 5 primes is **2, 3, 5, 7, 11**. 🌟" - ] - } - ], - "source": [ - "# Streaming chat completion\n", - "stream = client.chat.completions.create(\n", - " model=\"nemotron\",\n", - " messages=[\n", - " {\"role\": \"system\", \"content\": \"You are a helpful assistant.\"},\n", - " {\"role\": \"user\", \"content\": \"What are the first 5 prime numbers?\"}\n", - " ],\n", - " temperature=0.7,\n", - " max_tokens=1024,\n", - " stream=True,\n", - ")\n", - "for chunk in stream:\n", - " delta = chunk.choices[0].delta\n", - " if delta and delta.content:\n", - " print(delta.content, end=\"\", flush=True)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Tool calling\n", - "\n", - "Call functions using the OpenAI Tools schema and inspect returned tool_calls." - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Okay, the user wants to calculate a 15% tip on a $50 bill. Let me check the tools available. There's a calculate_tip function that takes bill_total and tip_percentage. The parameters are required, so I need both. The bill is $50, and the tip percentage is 15. I should call the function with these values. Let me make sure the parameters are integers. Yes, 50 and 15 are both integers. So the tool call should be calculate_tip with bill_total 50 and tip_percentage 15. That should give the tip amount.\n", - "\n", - "[ChatCompletionMessageFunctionToolCall(id='chatcmpl-tool-b58e15d0f14b61c3', function=Function(arguments='{\"bill_total\": 50, \"tip_percentage\": 15}', name='calculate_tip'), type='function')]\n" - ] - } - ], - "source": [ - "# Tool calling via OpenAI tools schema\n", - "TOOLS = [\n", - " {\n", - " \"type\": \"function\",\n", - " \"function\": {\n", - " \"name\": \"calculate_tip\",\n", - " \"parameters\": {\n", - " \"type\": \"object\",\n", - " \"properties\": {\n", - " \"bill_total\": {\n", - " \"type\": \"integer\",\n", - " \"description\": \"The total amount of the bill\"\n", - " },\n", - " \"tip_percentage\": {\n", - " \"type\": \"integer\",\n", - " \"description\": \"The percentage of tip to be applied\"\n", - " }\n", - " },\n", - " \"required\": [\"bill_total\", \"tip_percentage\"]\n", - " }\n", - " }\n", - " }\n", - "]\n", - "\n", - "completion = client.chat.completions.create(\n", - " model=\"nemotron\",\n", - " messages=[\n", - " {\"role\": \"system\", \"content\": \"\"},\n", - " {\"role\": \"user\", \"content\": \"My bill is $50. What will be the amount for 15% tip?\"}\n", - " ],\n", - " tools=TOOLS,\n", - " temperature=0.6,\n", - " top_p=0.95,\n", - " max_tokens=512,\n", - " stream=False\n", - ")\n", - "\n", - "print(completion.choices[0].message.reasoning_content)\n", - "print(completion.choices[0].message.tool_calls)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.12.12" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/usage-cookbook/Nemotron-Nano-9B-v2/nim_tool_calling_cookbook.ipynb b/usage-cookbook/Nemotron-Nano-9B-v2/nim_tool_calling_cookbook.ipynb deleted file mode 100644 index b26d59a..0000000 --- a/usage-cookbook/Nemotron-Nano-9B-v2/nim_tool_calling_cookbook.ipynb +++ /dev/null @@ -1,332 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Tool Calling with Nemotron-Nano-9B-v2 on NVIDIA NIM\n", - "\n", - "This notebook demonstrates how to invoke the `nvidia/nemotron-nano-9b-v2` large language model through NVIDIA Inference Microservices (NIM) using the OpenAI-compatible Chat Completions API and walk through a minimal tool-calling loop.\n", - "\n", - "- Model card: [NVIDIA Nemotron Nano 9B v2](https://build.nvidia.com/nvidia/nvidia-nemotron-nano-9b-v2)\n", - "- NIM Docs: [https://docs.nvidia.com/nim/](https://docs.nvidia.com/nim/)\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Table of Contents\n", - "- [Prerequisites](#Prerequisites)\n", - "- [Setup](#Setup)\n", - "- [API Key Generation](#API-Key-Generation)\n", - "- [Define Tools](#Define-Tools)\n", - "- [Run Tool Call](#Run-Tool-Call)\n", - "- [Troubleshooting](#Troubleshooting)\n", - "- [Conclusion](#Conclusion)\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Prerequisites\n", - "\n", - "- Python 3.10 or later with `pip`\n", - "- An NVIDIA API key with access to the NIM endpoints (set `NVIDIA_API_KEY` in your environment)\n", - "- Network access to reach `https://integrate.api.nvidia.com`\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Setup\n", - "\n", - "Run the following cell once per environment to install the Python dependencies. If your workspace already has compatible versions, you can skip this step.\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "%pip install --upgrade openai python-dotenv" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### API Key Generation\n", - "Before we get started, generate the API keys to use model from NVIDIA NIM microservice.\n", - "\n", - "To generate 'NVIDIA_API_KEY' for NVIDIA NIM microservice:\n", - "\n", - "1. Create a free account with [NVIDIA](https://build.nvidia.com/nvidia/nvidia-nemotron-nano-9b-v2).\n", - "2. Under Input select the Python tab, and click **Get API Key** and then click **Generate Key**.\n", - "3. Copy and save the generated key as `NVIDIA_API_KEY`. From there, you should have access to the endpoints." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Initialize Client\n", - "\n", - "The next cell initializes an OpenAI-compatible client configured for the Nemotron NIM endpoint. It reads your NVIDIA API key from the `NVIDIA_API_KEY` environment variable or a local `.env` file.\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Client ready for nvidia/nvidia-nemotron-nano-9b-v2\n" - ] - } - ], - "source": [ - "import json\n", - "import os\n", - "from dotenv import load_dotenv\n", - "from openai import OpenAI\n", - "\n", - "load_dotenv()\n", - "\n", - "NIM_BASE_URL = \"https://integrate.api.nvidia.com/v1\"\n", - "MODEL_ID = \"nvidia/nvidia-nemotron-nano-9b-v2\" # <-- Make sure this is the correct model ID for the API\n", - "\n", - "api_key = os.getenv(\"NVIDIA_API_KEY\")\n", - "if not api_key:\n", - " raise RuntimeError(\"Set NVIDIA_API_KEY in your environment or .env before running this cell.\")\n", - "\n", - "client = OpenAI(api_key=api_key, base_url=NIM_BASE_URL)\n", - "print(f\"Client ready for {MODEL_ID}\")\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Define Tools\n", - "\n", - "We'll expose a single local function that returns mock weather data. The model will call this tool when it needs structured information and we'll feed the result back into the conversation.\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "def get_current_weather(location: str, unit: str = \"celsius\") -> dict:\n", - " \"\"\"Return dummy weather data for the requested location.\"\"\"\n", - " forecast = {\n", - " \"temperature_c\": 19,\n", - " \"temperature_f\": 66,\n", - " \"condition\": \"clear skies\",\n", - " \"humidity\": 0.72,\n", - " \"wind_kph\": 8.0,\n", - " }\n", - " if unit.lower().startswith(\"f\"):\n", - " temperature = forecast[\"temperature_f\"]\n", - " unit_label = \"F\"\n", - " else:\n", - " temperature = forecast[\"temperature_c\"]\n", - " unit_label = \"°C\"\n", - "\n", - " return {\n", - " \"location\": location,\n", - " \"summary\": forecast[\"condition\"],\n", - " \"temperature\": temperature,\n", - " \"unit\": unit_label,\n", - " \"humidity\": forecast[\"humidity\"],\n", - " \"wind_kph\": forecast[\"wind_kph\"],\n", - " }\n", - "\n", - "tools = [\n", - " {\n", - " \"type\": \"function\",\n", - " \"function\": {\n", - " \"name\": \"get_current_weather\",\n", - " \"description\": \"Look up the current weather for a city and return structured conditions.\",\n", - " \"parameters\": {\n", - " \"type\": \"object\",\n", - " \"properties\": {\n", - " \"location\": {\n", - " \"type\": \"string\",\n", - " \"description\": \"City and state, e.g. San Francisco, CA\",\n", - " },\n", - " \"unit\": {\n", - " \"type\": \"string\",\n", - " \"enum\": [\"celsius\", \"fahrenheit\"],\n", - " \"description\": \"Temperature unit to return.\",\n", - " },\n", - " },\n", - " \"required\": [\"location\"],\n", - " },\n", - " },\n", - " }\n", - "]\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Run Tool Call\n", - "\n", - "The snippet below sends a chat completion request with the tool definition, inspects the tool call returned by the model, executes the local function, and then submits the tool result back to the model to obtain a final natural-language answer.\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Assistant requested tool:\n", - "ChatCompletionMessage(content=None, refusal=None, role='assistant', annotations=None, audio=None, function_call=None, tool_calls=[ChatCompletionMessageFunctionToolCall(id='ndxqwsLFA', function=Function(arguments='{\"location\": \"San Francisco, CA\", \"unit\": \"fahrenheit\"}', name='get_current_weather'), type='function')], reasoning_content='Okay, the user is asking about the weather in San Francisco this afternoon. Let me see. I need to check the current weather for San Francisco. The tools available include get_current_weather, which requires the location and optionally the unit. The user didn\\'t specify Celsius or Fahrenheit, so maybe I should default to one. Since the user is in the US, maybe Fahrenheit is more common there. But the function allows either. Wait, the function\\'s parameters have an enum for unit, so I should choose one. Let me go with Fahrenheit unless told otherwise. The location is clearly San Francisco, CA. So I should call get_current_weather with location \"San Francisco, CA\" and unit \"fahrenheit\". That should give the current conditions. The user mentioned \"this afternoon,\" but the function gives current weather. Maybe the current weather is the best available data. I\\'ll proceed with that.')\n", - "Tool response:\n", - "{'location': 'San Francisco, CA', 'summary': 'clear skies', 'temperature': 66, 'unit': 'F', 'humidity': 0.72, 'wind_kph': 8.0}\n", - "\n", - "Final model answer:\n", - "\n", - "The current weather in San Francisco this afternoon is clear skies with a temperature of 66°F. The humidity is at 72%, and there's a light breeze of 8.0 km/h. You might want to bring a light jacket as it’s a bit cool!\n" - ] - } - ], - "source": [ - "messages = [\n", - " {\n", - " \"role\": \"system\",\n", - " \"content\": \"You are a helpful weather assistant. Call tools when you need real-world data before replying to the user.\",\n", - " },\n", - " {\n", - " \"role\": \"user\",\n", - " \"content\": \"What's the weather like in San Francisco this afternoon?\",\n", - " },\n", - "]\n", - "\n", - "first_completion = client.chat.completions.create(\n", - " model=MODEL_ID,\n", - " messages=messages,\n", - " tools=tools,\n", - " tool_choice=\"auto\",\n", - " temperature=0.2,\n", - " max_tokens=512,\n", - ")\n", - "assistant_message = first_completion.choices[0].message\n", - "print(\"Assistant requested tool:\")\n", - "print(assistant_message)\n", - "\n", - "assistant_dict = {\n", - " \"role\": assistant_message.role,\n", - " \"content\": assistant_message.content or \"\",\n", - "}\n", - "if assistant_message.tool_calls:\n", - " assistant_dict[\"tool_calls\"] = [\n", - " {\n", - " \"id\": call.id,\n", - " \"type\": call.type,\n", - " \"function\": {\n", - " \"name\": call.function.name,\n", - " \"arguments\": call.function.arguments,\n", - " },\n", - " }\n", - " for call in assistant_message.tool_calls\n", - " ]\n", - "\n", - "messages.append(assistant_dict)\n", - "\n", - "for call in assistant_message.tool_calls or []:\n", - " if call.function.name != \"get_current_weather\":\n", - " continue\n", - " call_args = json.loads(call.function.arguments or \"{}\")\n", - " tool_response = get_current_weather(**call_args)\n", - " print(\"Tool response:\")\n", - " print(tool_response)\n", - " messages.append(\n", - " {\n", - " \"role\": \"tool\",\n", - " \"tool_call_id\": call.id,\n", - " \"name\": call.function.name,\n", - " \"content\": json.dumps(tool_response),\n", - " }\n", - " )\n", - "\n", - "final_completion = client.chat.completions.create(\n", - " model=MODEL_ID,\n", - " messages=messages,\n", - " temperature=0.2,\n", - " max_tokens=512,\n", - ")\n", - "final_message = final_completion.choices[0].message\n", - "print(\"\\nFinal model answer:\\n\")\n", - "print(final_message.content)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Troubleshooting\n", - "\n", - "- If you get a `404 Not Found` error, the `MODEL_ID` is likely incorrect. Check the NVIDIA build catalog for the exact model identifier for this API.\n", - "- Ensure `NVIDIA_API_KEY` is set and has access to the Nemotron NIM deployment; the API returns HTTP 401 if the key is missing or invalid.\n", - "- When running from a remote environment, verify that outbound HTTPS traffic to `integrate.api.nvidia.com` is allowed.\n", - "- If the model replies directly without calling a tool, adjust the system prompt or send a follow-up user message requesting structured data to encourage tool use.\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Conclusion\n", - "\n", - "This notebook demonstrated a simple, complete tool-calling workflow using the `Nemotron-Nano-9B-v2` model served through NVIDIA NIM. By defining tools and handling the model's tool-use requests, you can build powerful applications that connect LLMs to external data and APIs. From here, you can expand on this example by adding more complex tools, implementing more robust error handling, or integrating real-world APIs.\n", - "\n" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "data_analysis", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.16" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/usage-cookbook/Nemotron-Nano-9B-v2/transformers_cookbook.ipynb b/usage-cookbook/Nemotron-Nano-9B-v2/transformers_cookbook.ipynb deleted file mode 100644 index ed8f631..0000000 --- a/usage-cookbook/Nemotron-Nano-9B-v2/transformers_cookbook.ipynb +++ /dev/null @@ -1,291 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Running NVIDIA Nemotron Nano 9B v2 with Hugging Face Transformers\n", - "\n", - "This notebook will walk you through how to run the `nvidia/NVIDIA-Nemotron-Nano-9B-v2` model with Hugging Face Transformers \n", - "\n", - "[Hugging Face Transformers](https://huggingface.co/docs/transformers) is a model-definition framework for state-of-the-art models across text, vision, audio, video, and multimodal tasks, supporting both training and inference.\n", - "\n", - "For more details on the model [click here](https://build.nvidia.com/nvidia/nvidia-nemotron-nano-9b-v2/modelcard)\n", - "\n", - "Prerequisites:\n", - "- NVIDIA GPU with recent drivers (≥ 24 GB VRAM recommended; BF16-capable) and CUDA 12.x \n", - "- Python 3.10+" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Prerequisites & environment\n", - "\n", - "Set up a clean Python environment for running this locally.\n", - "\n", - "Create and activate a virtual environment. The sample here uses Conda but feel free to choose whichever tool you prefer.\n", - "Run these commands in a terminal before using this notebook:\n", - "\n", - "```bash\n", - "conda create -n nemotron-transformers-env python=3.10 -y\n", - "conda activate nemotron-transformers-env\n", - "```\n", - "\n", - "If running notebook locally, install ipykernel and switch the kernel to this environment:\n", - "- Installation\n", - "```bash\n", - "pip install ipykernel\n", - "```\n", - "- Kernel → Change kernel → Python (nemotron-transformers-env)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Install dependencies" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "%pip install -U transformers accelerate torch causal-conv1d mamba-ssm" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Verify GPU\n", - "\n", - "Check that CUDA is available and the GPU is detected correctly.\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# GPU environment check\n", - "import torch\n", - "print(f\"CUDA available: {torch.cuda.is_available()}\")\n", - "print(f\"Num GPUs: {torch.cuda.device_count()}\")\n", - "if torch.cuda.is_available():\n", - " for i in range(torch.cuda.device_count()):\n", - " print(f\"GPU[{i}]: {torch.cuda.get_device_name(i)}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Generating responses via pipeline \n", - "Use the Transformers pipeline with the model’s chat template to quickly generate replies." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "import torch\n", - "from transformers import pipeline\n", - " \n", - "generator = pipeline(\n", - " \"text-generation\",\n", - " model=\"nvidia/NVIDIA-Nemotron-Nano-9B-v2\",\n", - " dtype=torch.bfloat16,\n", - " device_map=\"auto\" , \n", - " trust_remote_code=True\n", - ")\n", - " \n", - "messages = [\n", - " {\"role\": \"user\", \"content\": \"Explain Hugging Face Transformers.\"},\n", - "]\n", - " \n", - "result = generator(\n", - " messages,\n", - " max_new_tokens=200,\n", - " temperature=1.0,\n", - ")\n", - " \n", - "print(result[0][\"generated_text\"])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Load the Nemotron model and tokenizer manually. \n", - "Load AutoTokenizer and AutoModelForCausalLM for full control over inputs and generation settings." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "import torch\n", - "from transformers import AutoTokenizer, AutoModelForCausalLM\n", - "\n", - "# Load tokenizer and model\n", - "tokenizer = AutoTokenizer.from_pretrained(\"nvidia/NVIDIA-Nemotron-Nano-9B-v2\")\n", - "model = AutoModelForCausalLM.from_pretrained(\n", - " \"nvidia/NVIDIA-Nemotron-Nano-9B-v2\",\n", - " dtype=torch.bfloat16,\n", - " trust_remote_code=True,\n", - " device_map=\"auto\"\n", - ")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Reasoning \n", - "Nemotron Nano supports two reasoning modes: ON (default) and OFF. Toggle via `/think` or `/no_think` in the chat messages.\n", - "\n", - "Note: You can include `/think` or `/no_think` in `system` or `user` messages for turn-level control." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "messages = [\n", - " {\"role\": \"system\", \"content\": \"/think\"},\n", - " {\"role\": \"user\", \"content\": \"Write a haiku about GPUs\"},\n", - "]\n", - "\n", - "tokenized_chat = tokenizer.apply_chat_template(\n", - " messages,\n", - " tokenize=True,\n", - " add_generation_prompt=True,\n", - " return_tensors=\"pt\"\n", - ").to(model.device)\n", - "\n", - "outputs = model.generate(\n", - " tokenized_chat,\n", - " max_new_tokens=1024,\n", - " eos_token_id=tokenizer.eos_token_id\n", - ")\n", - "print(tokenizer.decode(outputs[0]))\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Compare the same prompt with reasoning disabled using `/no_think` to see differences in style and latency." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "messages = [\n", - " {\"role\": \"system\", \"content\": \"/no_think\"},\n", - " {\"role\": \"user\", \"content\": \"Write a haiku about GPUs\"},\n", - "]\n", - "tokenized_chat = tokenizer.apply_chat_template(\n", - " messages,\n", - " tokenize=True,\n", - " add_generation_prompt=True,\n", - " return_tensors=\"pt\"\n", - ").to(model.device)\n", - "\n", - "outputs = model.generate(\n", - " tokenized_chat,\n", - " max_new_tokens=1024,\n", - " eos_token_id=tokenizer.eos_token_id\n", - ")\n", - "print(tokenizer.decode(outputs[0]))\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Streamed generation\n", - "Stream tokens as they are produced using `TextIteratorStreamer` to display output incrementally while `generate` runs in a background thread." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "import threading\n", - "from transformers import TextIteratorStreamer\n", - "\n", - "messages = [\n", - " {\"role\": \"system\", \"content\": \"/think\"},\n", - " {\"role\": \"user\", \"content\": \"Write a haiku about GPUs\"},\n", - "]\n", - "\n", - "inputs = tokenizer.apply_chat_template(\n", - " messages, \n", - " tokenize=True, \n", - " add_generation_prompt=True, \n", - " return_tensors=\"pt\"\n", - ").to(model.device)\n", - "\n", - "# Create a TextIteratorStreamer for streaming output\n", - "streamer = TextIteratorStreamer(tokenizer, skip_prompt=True, skip_special_tokens=True)\n", - "\n", - "# Launch model.generate in a separate thread with the streamer\n", - "gen_kwargs = dict(\n", - " inputs=inputs,\n", - " streamer=streamer,\n", - " max_new_tokens=1024, \n", - " temperature=0.6, \n", - " top_p=0.95,\n", - " eos_token_id=tokenizer.eos_token_id\n", - ")\n", - "thread = threading.Thread(target=model.generate, kwargs=gen_kwargs)\n", - "thread.start()\n", - "\n", - "# Print output as tokens arrive\n", - "print(\"Model output:\")\n", - "for new_text in streamer:\n", - " print(new_text, end=\"\", flush=True)\n", - "\n", - "thread.join()\n" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "nemotron-transformers-env", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.18" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/usage-cookbook/Nemotron-Nano-9B-v2/trtllm_cookbook.ipynb b/usage-cookbook/Nemotron-Nano-9B-v2/trtllm_cookbook.ipynb deleted file mode 100644 index 3af9f3d..0000000 --- a/usage-cookbook/Nemotron-Nano-9B-v2/trtllm_cookbook.ipynb +++ /dev/null @@ -1,323 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Running NVIDIA Nemotron Nano 9B v2 with TensorRT-LLM\n", - "\n", - "This notebook will walk you through how to run the `nvidia/NVIDIA-Nemotron-Nano-9B-v2` model locally via TensorRT-LLM\n", - "\n", - "[TensorRT-LLM](https://nvidia.github.io/TensorRT-LLM/) is NVIDIA’s open-source library for accelerating and optimizing LLM inference performance on NVIDIA GPUs.\n", - "\n", - "For more details on the model [click here](https://build.nvidia.com/nvidia/nvidia-nemotron-nano-9b-v2/modelcard)\n", - "\n", - "Prerequisites:\n", - "- NVIDIA GPU with recent drivers (≥ 24 GB VRAM recommended) and CUDA 12.x \n", - "- Python 3.10+\n", - "- TensorRT-LLM (you can refer to NVIDIA documentation, or pull this [container](https://catalog.ngc.nvidia.com/orgs/nvidia/teams/tensorrt-llm/containers/release?version=1.1.0rc4))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Prerequisites & environment\n", - "\n", - "Set up a containerized environment and Jupyter kernel for TensorRT-LLM.\n", - "\n", - "If you run the above mentioned container for TRT-LLM, make sure to configure your notebook with it. \n", - "One approach is:\n", - "\n", - "```shell\n", - "docker run --rm -it --ipc=host --ulimit memlock=-1 --ulimit stack=67108864 --gpus=all -p 8888:8888 -p 8000:8000 nvcr.io/nvidia/tensorrt-llm/release:1.1.0rc4\n", - "\n", - "pip install jupyter\n", - "\n", - "jupyter notebook --ip 0.0.0.0 --no-browser --allow-root\n", - "```\n", - "This should output a URL such as: http://127.0.0.1:8888/?token=xxxxxxxxxxxxxxxx\n", - "\n", - "Then change your kernel to the Jupyter server running in your Docker container (copy and paste the URL)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Verify GPU\n", - "\n", - "Check that CUDA is available and the GPU is detected correctly.\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Environment check\n", - "import sys\n", - "import tensorrt_llm\n", - "import torch\n", - "\n", - "print(f\"Python: {sys.version}\")\n", - "print(f\"TensorRT-LLM version: {tensorrt_llm.__version__}\")\n", - "print(f\"CUDA available: {torch.cuda.is_available()}\")\n", - "print(f\"Num GPUs: {torch.cuda.device_count()}\")\n", - "\n", - "if torch.cuda.is_available():\n", - " for i in range(torch.cuda.device_count()):\n", - " print(f\"GPU[{i}]: {torch.cuda.get_device_name(i)}\")\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Loading the model" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from tensorrt_llm import LLM, SamplingParams\n", - "from tensorrt_llm.llmapi import KvCacheConfig\n", - "\n", - "kv_cache_config = KvCacheConfig(\n", - " enable_block_reuse=False,\n", - ")\n", - "\n", - "# Load model\n", - "llm = LLM(model=\"nvidia/NVIDIA-Nemotron-Nano-9B-v2\",\n", - " max_seq_len=32678,\n", - " max_batch_size=4,\n", - " kv_cache_config=kv_cache_config\n", - " )" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Generate responses for single or batch prompts\n", - "\n", - "Use `SamplingParams` to control generation and run single and batched prompts." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Set sampling parameters\n", - "params = SamplingParams(\n", - " max_tokens=512,\n", - " temperature=0.6,\n", - " top_p=0.95,\n", - " add_special_tokens=False,\n", - ")\n", - "# Generate text\n", - "result = llm.generate([\"Write a haiku about GPUs\"], params)\n", - "print(result[0].outputs[0].text)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Multiple prompts for batch generation\n", - "prompts = [\n", - " \"Hello, my name is\",\n", - " \"The capital of France is\",\n", - " \"Explain quantum computing in simple terms:\"\n", - "]\n", - "\n", - "results = llm.generate(prompts, params)\n", - "\n", - "for i, r in enumerate(results):\n", - " print(f\"\\nPrompt {i+1}: {prompts[i]!r}\")\n", - " print(r.outputs[0].text)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## OpenAI-compatible server\n", - "\n", - "Start a local OpenAI-compatible server with TensorRT-LLM to serve the model.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Run this in a terminal:\n", - "\n", - "(Optional) If running via Docker, stop the running Jupyter server, and configure to another Python 3.10+ kernel for simplicity. Start this trtllm server instead. \n", - "\n", - "```shell\n", - "trtllm-serve \"nvidia/NVIDIA-Nemotron-Nano-9B-v2\" \\\n", - " --host 0.0.0.0 --port 8000 \\\n", - " --max_seq_len 32678 \\\n", - " --max_batch_size 4 \\\n", - " --extra_llm_api_options <(echo '{\"kv_cache_config\":{\"enable_block_reuse\":false}}')\n", - "```\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Your server is now running! " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Use the API\n", - "\n", - "Use the OpenAI-compatible client to send requests to the local TensorRT-LLM server. \n", - "\n", - "Note: The model supports two modes - Reasoning ON (default) vs OFF. These can be toggled by passing /think vs /no_think as a part of the \"system\" message. \n", - "\n", - "The /think or /no_think keywords can also be provided in “user” messages for turn-level reasoning control." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from openai import OpenAI\n", - "import requests\n", - "\n", - "# Setup client\n", - "BASE_URL = \"http://127.0.0.1:8000/v1\"\n", - "API_KEY = \"tensorrt_llm\"\n", - "client = OpenAI(base_url=BASE_URL, api_key=API_KEY)\n", - "\n", - "# Get model ID\n", - "model_id = requests.get(f\"{BASE_URL}/models\", timeout=10).json()[\"data\"][0][\"id\"]\n", - "\n", - "# Basic chat completion\n", - "response = client.chat.completions.create(\n", - " model=model_id,\n", - " messages=[\n", - " {\"role\": \"system\", \"content\": \"/no_think\"},\n", - " {\"role\": \"user\", \"content\": \"Give me 3 bullet points about TensorRT-LLM.\"}\n", - " ],\n", - " temperature=0.6,\n", - " max_tokens=256,\n", - ")\n", - "print(\"Response:\", response.choices[0].message.content)\n", - "\n", - "print(\"\\n\" + \"=\"*50 + \"\\n\")\n", - "\n", - "# Streaming chat completion\n", - "print(\"Streaming response:\")\n", - "stream = client.chat.completions.create(\n", - " model=model_id,\n", - " messages=[\n", - " {\"role\": \"system\", \"content\": \"/think\"},\n", - " {\"role\": \"user\", \"content\": \"Write a short haiku about GPUs.\"}\n", - " ],\n", - " temperature=0.7,\n", - " max_tokens=256,\n", - " stream=True,\n", - ")\n", - "\n", - "for chunk in stream:\n", - " if chunk.choices[0].delta.content:\n", - " print(chunk.choices[0].delta.content, end=\"\", flush=True)\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Tool calling\n", - "\n", - "Use the OpenAI tools schema to call functions via the TensorRT-LLM endpoint." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Tool calling via OpenAI tools schema\n", - "TOOLS = [\n", - " {\n", - " \"type\": \"function\",\n", - " \"function\": {\n", - " \"name\": \"calculate_tip\",\n", - " \"parameters\": {\n", - " \"type\": \"object\",\n", - " \"properties\": {\n", - " \"bill_total\": {\n", - " \"type\": \"integer\",\n", - " \"description\": \"The total amount of the bill\"\n", - " },\n", - " \"tip_percentage\": {\n", - " \"type\": \"integer\",\n", - " \"description\": \"The percentage of tip to be applied\"\n", - " }\n", - " },\n", - " \"required\": [\"bill_total\", \"tip_percentage\"]\n", - " }\n", - " }\n", - " }\n", - "]\n", - "\n", - "completion = client.chat.completions.create(\n", - " model=\"nvidia/NVIDIA-Nemotron-Nano-9B-v2\",\n", - " messages=[\n", - " {\"role\": \"system\", \"content\": \"\"},\n", - " {\"role\": \"user\", \"content\": \"My bill is $50. What will be the amount for 15% tip?\"}\n", - " ],\n", - " tools=TOOLS,\n", - " temperature=0.6,\n", - " top_p=0.95,\n", - " max_tokens=32768,\n", - " stream=False\n", - ")\n", - "\n", - "print(completion.choices[0].message.content)\n", - "print(completion.choices[0].message.tool_calls)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "nemotron-env", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.18" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/usage-cookbook/Nemotron-Nano-9B-v2/vllm_cookbook.ipynb b/usage-cookbook/Nemotron-Nano-9B-v2/vllm_cookbook.ipynb deleted file mode 100644 index ddb3e5f..0000000 --- a/usage-cookbook/Nemotron-Nano-9B-v2/vllm_cookbook.ipynb +++ /dev/null @@ -1,360 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Running NVIDIA Nemotron Nano 9B v2 with vLLM\n", - "\n", - "This notebook will walk you through how to run the `nvidia/NVIDIA-Nemotron-Nano-9B-v2` model locally with vLLM.\n", - "\n", - "[vLLM](https://docs.vllm.ai) is a fast and easy-to-use library for LLM inference and serving. \n", - "\n", - "For more details on the model [click here](https://build.nvidia.com/nvidia/nvidia-nemotron-nano-9b-v2/modelcard)\n", - "\n", - "Prerequisites:\n", - "- NVIDIA GPU with recent drivers (≥ 24 GB VRAM recommended; BF16-capable) and CUDA 12.x \n", - "- Python 3.10+" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Prerequisites & environment\n", - "\n", - "Set up a clean Python environment for running vLLM locally.\n", - "\n", - "Create and activate a virtual environment. The sample here uses Conda but feel free to choose whichever tool you prefer.\n", - "Run these commands in a terminal before using this notebook:\n", - "\n", - "```bash\n", - "conda create -n nemotron-vllm-env python=3.10 -y\n", - "conda activate nemotron-vllm-env\n", - "```\n", - "\n", - "If running notebook locally, install ipykernel and switch the kernel to this environment:\n", - "- Installation\n", - "```bash\n", - "pip install ipykernel\n", - "```\n", - "- Kernel → Change kernel → Python (nemotron-vllm-env)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Install dependencies" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "%pip install --upgrade uv" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "%uv pip install vllm --extra-index-url https://wheels.vllm.ai/75531a6c134282f940c86461b3c40996b4136793" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Verify GPU\n", - "\n", - "Confirm CUDA is available and your GPU is visible to PyTorch.\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# GPU environment check\n", - "import torch\n", - "print(f\"CUDA available: {torch.cuda.is_available()}\")\n", - "print(f\"Num GPUs: {torch.cuda.device_count()}\")\n", - "if torch.cuda.is_available():\n", - " for i in range(torch.cuda.device_count()):\n", - " print(f\"GPU[{i}]: {torch.cuda.get_device_name(i)}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Load the model\n", - "\n", - "Initialize the Nemotron model in vLLM with BF16 for efficient GPU inference." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "import os\n", - "from vllm import LLM\n", - "\n", - "llm = LLM(\n", - " model=\"nvidia/NVIDIA-Nemotron-Nano-9B-v2\",\n", - " trust_remote_code=True,\n", - " dtype=\"bfloat16\"\n", - ")\n", - "\n", - "print(\"Model ready\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Generate reponses\n", - "\n", - "Generate text with vLLM using single, batched, and simple streaming examples." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Single or batch prompts\n", - "\n", - "Send one prompt or a list to run batched generation." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from vllm import SamplingParams\n", - "\n", - "params = SamplingParams(temperature=0.6, max_tokens=200)\n", - "\n", - "# Single prompt\n", - "single = llm.generate([\"What is Nemotron Nano 9B v2?\"], sampling_params=params)\n", - "print(single[0].outputs[0].text)\n", - "\n", - "# Batch prompts\n", - "prompts = [\n", - " \"Hello, my name is\",\n", - " \"The capital of France is\",\n", - " \"Explain quantum computing in simple terms:\"\n", - "]\n", - "outputs = llm.generate(prompts, sampling_params=params)\n", - "for i, out in enumerate(outputs):\n", - " print(f\"\\nPrompt {i+1}: {out.prompt!r}\")\n", - " print(out.outputs[0].text)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Streamed generation\n", - "\n", - "Printing characters as they are produced." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "def stream_like(prompt: str, llm: LLM, sampling_params: SamplingParams) -> None:\n", - " outputs = llm.generate([prompt], sampling_params=sampling_params)\n", - " text = outputs[0].outputs[0].text\n", - " print(\"Response:\", end=\" \")\n", - " for ch in text:\n", - " print(ch, end=\"\", flush=True)\n", - " print()\n", - "\n", - "stream_like(\"Write a haiku about GPUs.\", llm, SamplingParams(temperature=0.7, max_tokens=80))\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## OpenAI-compatible server \n", - "\n", - "Serve the model via an OpenAI-compatible API using vLLM.\n", - "\n", - "Before starting the server:\n", - "- Restart the kernel to free GPU memory used by the in-process LLM\n", - "- Ensure you use the same virtual environment with installed dependancies in your terminal" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "After restarting the kernel, run this in a terminal:\n", - "\n", - "```shell\n", - "git clone https://huggingface.co/nvidia/NVIDIA-Nemotron-Nano-9B-v2\n", - "\n", - "vllm serve nvidia/NVIDIA-Nemotron-Nano-9B-v2 --trust-remote-code --dtype bfloat16 --enable-auto-tool-choice --tool-parser-plugin \"NVIDIA-Nemotron-Nano-9B-v2/nemotron_toolcall_parser_no_streaming.py\" --tool-call-parser \"nemotron_json\"\n", - "```" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Your server is now running! " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Use the API\n", - "\n", - "Send chat and streaming requests to your local vLLM server using the OpenAI-compatible client." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Note: The model supports two modes - Reasoning ON (default) vs OFF. These can be toggled by passing /think vs /no_think as a part of the \"system\" message. \n", - "\n", - "The /think or /no_think keywords can also be provided in “user” messages for turn-level reasoning control." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Client: Standard chat and streaming\n", - "from openai import OpenAI\n", - "\n", - "client = OpenAI(base_url=\"http://127.0.0.1:8000/v1\", api_key=\"null\")\n", - "\n", - "# Simple chat completion\n", - "resp = client.chat.completions.create(\n", - " model=\"nvidia/NVIDIA-Nemotron-Nano-9B-v2\",\n", - " messages=[\n", - " {\"role\": \"system\", \"content\": \"/no_think\"},\n", - " {\"role\": \"user\", \"content\": \"Give me 3 interesting facts about vLLM.\"}\n", - " ],\n", - " temperature=0.6,\n", - " max_tokens=256,\n", - ")\n", - "print(resp.choices[0].message.content)\n", - "\n", - "# Streaming chat completion\n", - "stream = client.chat.completions.create(\n", - " model=\"nvidia/NVIDIA-Nemotron-Nano-9B-v2\",\n", - " messages=[\n", - " {\"role\": \"system\", \"content\": \"/think\"},\n", - " {\"role\": \"user\", \"content\": \"Write a haiku about GPUs.\"}\n", - " ],\n", - " temperature=0.7,\n", - " max_tokens=256,\n", - " stream=True,\n", - ")\n", - "for chunk in stream:\n", - " delta = chunk.choices[0].delta\n", - " if delta and delta.content:\n", - " print(delta.content, end=\"\", flush=True)\n", - "print()\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Tool calling\n", - "\n", - "Call functions using the OpenAI Tools schema and inspect returned tool_calls." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Tool calling via OpenAI tools schema\n", - "TOOLS = [\n", - " {\n", - " \"type\": \"function\",\n", - " \"function\": {\n", - " \"name\": \"calculate_tip\",\n", - " \"parameters\": {\n", - " \"type\": \"object\",\n", - " \"properties\": {\n", - " \"bill_total\": {\n", - " \"type\": \"integer\",\n", - " \"description\": \"The total amount of the bill\"\n", - " },\n", - " \"tip_percentage\": {\n", - " \"type\": \"integer\",\n", - " \"description\": \"The percentage of tip to be applied\"\n", - " }\n", - " },\n", - " \"required\": [\"bill_total\", \"tip_percentage\"]\n", - " }\n", - " }\n", - " }\n", - "]\n", - "\n", - "completion = client.chat.completions.create(\n", - " model=\"nvidia/NVIDIA-Nemotron-Nano-9B-v2\",\n", - " messages=[\n", - " {\"role\": \"system\", \"content\": \"\"},\n", - " {\"role\": \"user\", \"content\": \"My bill is $50. What will be the amount for 15% tip?\"}\n", - " ],\n", - " tools=TOOLS,\n", - " temperature=0.6,\n", - " top_p=0.95,\n", - " max_tokens=32768,\n", - " stream=False\n", - ")\n", - "\n", - "print(completion.choices[0].message.content)\n", - "print(completion.choices[0].message.tool_calls)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "nemotron-vllm-env", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.18" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/usage-cookbook/Nemotron-Nano2-VL/build_general_usage_cookbook.ipynb b/usage-cookbook/Nemotron-Nano2-VL/build_general_usage_cookbook.ipynb deleted file mode 100644 index b02ecd3..0000000 --- a/usage-cookbook/Nemotron-Nano2-VL/build_general_usage_cookbook.ipynb +++ /dev/null @@ -1,727 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "I-rch2mj7m82" - }, - "outputs": [], - "source": [ - "# Copyright 2025 NVIDIA Corporation. All Rights Reserved.\n", - "#\n", - "# Licensed under the Apache License, Version 2.0 (the \"License\");\n", - "# you may not use this file except in compliance with the License.\n", - "# You may obtain a copy of the License at\n", - "#\n", - "# http://www.apache.org/licenses/LICENSE-2.0\n", - "#\n", - "# Unless required by applicable law or agreed to in writing, software\n", - "# distributed under the License is distributed on an \"AS IS\" BASIS,\n", - "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n", - "# See the License for the specific language governing permissions and\n", - "# limitations under the License.\n", - "# ==============================================================================" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "j2J1RvCf7wLd" - }, - "source": [ - "\n", - "\n", - "# Nemotron Nano 2 VL - A Simple Notebook Walkthrough!\n", - "\n", - "Explore NVIDIA's latest Vision Language Model capable of Document Intelligence and Video Understanding. It's an open 12B parameter model, with capabilities to turn reasoning on and off. You can use this notebook to try out the model.\n", - "\n", - "All you need to run this model is an NVIDIA API KEY. Use the instructions in docs provided to you to generate API key.\n", - "\n", - "![image](https://imgur.com/8iIMnXO.png)\n", - "\n", - "> NOTE: Don't worry about any credits to use this model, although there is a rate limit of 40 requests per minute." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "Uyz3MLgW7vr6", - "outputId": "5fcec66c-0b65-4383-ae93-1e222164d724" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Provide API Key: ··········\n" - ] - } - ], - "source": [ - "import os\n", - "import getpass\n", - "\n", - "os.environ[\"NVIDIA_API_KEY\"] = getpass.getpass(\"Provide API Key: \")" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "aI0BmK9tiUSX" - }, - "source": [ - "In case, you are running this notebook in a local environment, let's ensure we install all the required libraries to run this notebook." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "collapsed": true, - "id": "ep2tNBwLiTjS", - "outputId": "a2cfde62-8914-4d06-8131-a15863f5ea6a" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Requirement already satisfied: pyarrow in /usr/local/lib/python3.12/dist-packages (18.1.0)\n", - "Requirement already satisfied: matplotlib in /usr/local/lib/python3.12/dist-packages (3.10.0)\n", - "Requirement already satisfied: pandas in /usr/local/lib/python3.12/dist-packages (2.2.2)\n", - "Requirement already satisfied: openai in /usr/local/lib/python3.12/dist-packages (1.109.1)\n", - "Requirement already satisfied: requests in /usr/local/lib/python3.12/dist-packages (2.32.4)\n", - "Requirement already satisfied: Pillow in /usr/local/lib/python3.12/dist-packages (11.3.0)\n", - "Requirement already satisfied: pymupdf in /usr/local/lib/python3.12/dist-packages (1.26.5)\n", - "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (1.3.3)\n", - "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (0.12.1)\n", - "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (4.60.1)\n", - "Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (1.4.9)\n", - "Requirement already satisfied: numpy>=1.23 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (2.0.2)\n", - "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (25.0)\n", - "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (3.2.5)\n", - "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.12/dist-packages (from matplotlib) (2.9.0.post0)\n", - "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.12/dist-packages (from pandas) (2025.2)\n", - "Requirement already satisfied: tzdata>=2022.7 in /usr/local/lib/python3.12/dist-packages (from pandas) (2025.2)\n", - "Requirement already satisfied: anyio<5,>=3.5.0 in /usr/local/lib/python3.12/dist-packages (from openai) (4.11.0)\n", - "Requirement already satisfied: distro<2,>=1.7.0 in /usr/local/lib/python3.12/dist-packages (from openai) (1.9.0)\n", - "Requirement already satisfied: httpx<1,>=0.23.0 in /usr/local/lib/python3.12/dist-packages (from openai) (0.28.1)\n", - "Requirement already satisfied: jiter<1,>=0.4.0 in /usr/local/lib/python3.12/dist-packages (from openai) (0.11.0)\n", - "Requirement already satisfied: pydantic<3,>=1.9.0 in /usr/local/lib/python3.12/dist-packages (from openai) (2.11.10)\n", - "Requirement already satisfied: sniffio in /usr/local/lib/python3.12/dist-packages (from openai) (1.3.1)\n", - "Requirement already satisfied: tqdm>4 in /usr/local/lib/python3.12/dist-packages (from openai) (4.67.1)\n", - "Requirement already satisfied: typing-extensions<5,>=4.11 in /usr/local/lib/python3.12/dist-packages (from openai) (4.15.0)\n", - "Requirement already satisfied: charset_normalizer<4,>=2 in /usr/local/lib/python3.12/dist-packages (from requests) (3.4.4)\n", - "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.12/dist-packages (from requests) (3.11)\n", - "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.12/dist-packages (from requests) (2.5.0)\n", - "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.12/dist-packages (from requests) (2025.10.5)\n", - "Requirement already satisfied: httpcore==1.* in /usr/local/lib/python3.12/dist-packages (from httpx<1,>=0.23.0->openai) (1.0.9)\n", - "Requirement already satisfied: h11>=0.16 in /usr/local/lib/python3.12/dist-packages (from httpcore==1.*->httpx<1,>=0.23.0->openai) (0.16.0)\n", - "Requirement already satisfied: annotated-types>=0.6.0 in /usr/local/lib/python3.12/dist-packages (from pydantic<3,>=1.9.0->openai) (0.7.0)\n", - "Requirement already satisfied: pydantic-core==2.33.2 in /usr/local/lib/python3.12/dist-packages (from pydantic<3,>=1.9.0->openai) (2.33.2)\n", - "Requirement already satisfied: typing-inspection>=0.4.0 in /usr/local/lib/python3.12/dist-packages (from pydantic<3,>=1.9.0->openai) (0.4.2)\n", - "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.12/dist-packages (from python-dateutil>=2.7->matplotlib) (1.17.0)\n" - ] - } - ], - "source": [ - "%pip install pyarrow matplotlib pandas openai requests Pillow pymupdf\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "0RbG6pFChdaH" - }, - "source": [ - "### Set up OpenAI Client\n", - "First, we'll need to point our OpenAI client to the right endpoint.\n", - "\n", - "> NOTE: Instructions on how to perform local deployment with vLLM is attached [here]()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "FEN5cyORePAh" - }, - "outputs": [], - "source": [ - "from openai import OpenAI\n", - "\n", - "client = OpenAI(\n", - " base_url = \"https://integrate.api.nvidia.com/v1\",\n", - " api_key = os.getenv(\"NVIDIA_API_KEY\")\n", - ")" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "_l8u8oACQxVR" - }, - "source": [ - "### Core Function to call Endpoint\n", - "\n", - "Let's also create a function that calls Nemotron Nano 2 VL. This function can take image(s), video(s) and text prompt as input, and gives out the model response." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "BDF7gXD9jKUE" - }, - "source": [ - "We will have to combine the text prompt along with the images/videos to craft a prompt to the model." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "HdM4AZucQwfp" - }, - "outputs": [], - "source": [ - "def call_nemotron_nano_2_vl(image_urls, video_urls, text_prompt, reasoning_mode, temperature, max_tokens):\n", - " \"\"\"\n", - " Calls the Nemotron Nano 2 VL model with image(s), video(s) and a text prompt.\n", - " Returns: Model's output response as a string.\n", - " \"\"\"\n", - "\n", - " if reasoning_mode:\n", - " reasoning_token = '/think'\n", - " else:\n", - " reasoning_token = '/no_think'\n", - "\n", - " # print(\"Reasoning Token: \", reasoning_token)\n", - " messages = [\n", - " {\n", - "\n", - " \"role\": \"system\",\n", - " \"content\": reasoning_token\n", - " },\n", - " {\n", - " \"role\": \"user\",\n", - " \"content\": []\n", - " }\n", - " ]\n", - "\n", - " for image_url in image_urls:\n", - "\n", - " messages[1]['content'].append(\n", - " {\n", - " \"type\": \"image_url\",\n", - " \"image_url\": {\"url\": image_url}\n", - " }\n", - " )\n", - "\n", - " for video_url in video_urls:\n", - " messages[1]['content'].append(\n", - " {\n", - " \"type\": \"video_url\",\n", - " \"video_url\": {\"url\": video_url}\n", - " }\n", - " )\n", - "\n", - "\n", - " messages[1][\"content\"].append(\n", - " {\n", - " \"type\": \"text\",\n", - " \"text\": text_prompt\n", - " }\n", - " )\n", - "\n", - "\n", - "\n", - " chat_response = client.chat.completions.create(\n", - " model=\"nvidia/nvidia-nemotron-nano-12b-v2-vl\",\n", - " messages=messages,\n", - " max_tokens=max_tokens,\n", - " temperature=temperature,\n", - " stream=True\n", - " )\n", - "\n", - " for chunk in chat_response:\n", - " reasoning = getattr(chunk.choices[0].delta, \"reasoning_content\", None)\n", - " if reasoning:\n", - " print(reasoning, end=\"\")\n", - " if chunk.choices[0].delta.content is not None:\n", - " print(chunk.choices[0].delta.content, end=\"\")\n", - "\n", - "import base64\n", - "def encode_video_to_mp4_data_url(video_bytes):\n", - " b64 = base64.b64encode(video_bytes).decode(\"utf-8\")\n", - " return f\"data:video/mp4;base64,{b64}\"\n", - "\n", - "def encode_pil_to_jpeg_data_url(pil_image):\n", - " from io import BytesIO\n", - " if pil_image.mode not in (\"RGB\",):\n", - " if pil_image.mode in (\"RGBA\", \"LA\") or (pil_image.mode == \"P\" and \"transparency\" in getattr(pil_image, \"info\", {})):\n", - " background = Image.new(\"RGB\", pil_image.size, (255, 255, 255))\n", - " converted = pil_image.convert(\"RGBA\")\n", - " background.paste(converted, mask=converted.split()[-1])\n", - " pil_image = background\n", - " else:\n", - " pil_image = pil_image.convert(\"RGB\")\n", - " buf = BytesIO()\n", - " pil_image.save(buf, format=\"JPEG\")\n", - " b64 = base64.b64encode(buf.getvalue()).decode(\"utf-8\")\n", - " return f\"data:image/jpeg;base64,{b64}\"" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "K_8qT5UgKOqI" - }, - "source": [ - "### Question Answering over a PDF\n", - "\n", - "[Here](https://drive.google.com/file/d/11luYcBWERyr7nAPtTIMlWOvRQd4SOJKk/view?usp=sharing) is the drive link to the PDF used below. If you are using Colab, either connect your drive to use the file, or download and re-upload to files tab on the left." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "OEMsMhIyxQU5" - }, - "outputs": [], - "source": [ - "import fitz\n", - "import io\n", - "import base64\n", - "from PIL import Image\n", - "import matplotlib.pyplot as plt\n", - "\n", - "\n", - "with fitz.open('/content/NVDA-F2Q26-Quarterly-Presentation-FINAL.pdf') as pdf:\n", - " pages = []\n", - " for index, page in enumerate(pdf):\n", - " pix = page.get_pixmap(dpi=150)\n", - "\n", - " mode = \"RGBA\" if pix.alpha else \"RGB\"\n", - " img = Image.frombytes(mode, [pix.width, pix.height], pix.samples)\n", - " pages.append(img)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 627 - }, - "id": "BHXjLNIOHfas", - "outputId": "7156fa4c-f638-4f22-9d5d-143d8136fa92" - }, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAARkUAABpDCAYAAAA3h9gYAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQABGRRJREFUeJzs3NEJQlEQQ0FfsP+Wry2I8BLFme9dOBXkOuecBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPyBrAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgJesAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaMk6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICWrAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgJesAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaMk6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICW57uH13Xd2QEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcJtzzse/ttoBAAAAAAAAAAAAAAAAAAAAAAAAAAAAgF9lqx0AAAAAAAAAAAAAAAAAAAAAAAAAAAAA+EfvbLWn0AEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABfIesAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaMk6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICWrAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgJesAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaMk6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICWrAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgJesAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaMk6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICWrAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgJesAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaMk6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICWrAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgJesAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaMk6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICWrAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgJesAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaMk6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICWrAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgJesAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaMk6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICWrAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgJesAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaMk6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICWrAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgJesAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaMk6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICWrAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgJesAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaMk6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICWrAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgJesAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaMk6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICWrAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgJesAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaMk6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICWrAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgJesAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaMk6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICWrAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgJesAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaMk6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICWrAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgJesAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaMk6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICWrAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgJesAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaMk6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICWrAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgJesAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaMk6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICWrAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgJesAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaMk6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICWrAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgJesAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaMk6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICWrAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgJesAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaMk6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICWrAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgJesAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaMk6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICWrAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgJesAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaMk6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICWrAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgJesAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaMk6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICWrAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgJesAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaMk6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICWrAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgJesAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaMk6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICWrAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgJesAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaMk6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFqyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICWrAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgJesAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaMk6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4MXuHNMAAAAgANrsH9oW+kACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAQNm77+goy/xt4N9MQgKEonQQEKQookhRFBFQxLIWFFk76oqvrl3BXlZFBftad7FhFxUVLOAqKMWCKFix0exdRAWkScj7xx78ubsWyjzzJOHzOed7zgqZ675m8sw9kyznHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBcyaRdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHIlk3YBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyJVM2gUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgVzJpFwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBcyaRdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHIlk3YBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyJVM2gUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgVzJpFwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBcyaRdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHIlk3YBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyJVM2gUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgVzJpFwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBcyaRdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHIlk3YBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyJVM2gUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgVzJpFwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBcyaRdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHIlk3YBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyJVM2gUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgVzJpFwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBcyaRdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHIlk3YBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyJVM2gUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgVzJpFwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBcyaRdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHIlk3YBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyJVM2gUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgVzJpFwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBcyaRdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHKlIO0CAAAAAAAAAAAAALCqtthii9h4442znvvwww9HSUlJ1nNJTtOmTeMvf/lLVjM//PDDuOuuu7KaWRGU9cfavsAvZft6tS8AAAAAAAAAAAAAAAAAAAAAAAAAAACQJOcsA6y7vAasW8r6Zz8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAuiqvtLS0dJW+MC8v6S4AAAAAAAAAAAAA8LuuuOKKOPXUU7OeW1xcHIsWLcp6Lsnp3r17TJo0KauZEydOjB122CGrmRVBWX+s7Qv8UravV/sCAAAAAAAAAAAAAFQsq3gs+69yVjsAAAAAAAAAAAAASXDOMsC6y2vAuqWsf/YDAAAAAAAAAAAAABWfs9oBAAAAAAAAAAAAAAAAAAAAAAAAAAAAgHXRqpzVXpCDHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5U1BQEIWFhVFUVBSVKlWKiIiSkpJYunRpLFu2LJYtW5ZyQwAAAACgvMjPz4/i4uKoXLnyz3/2008//fz7xuXLl6fYDgAAAAAAAAAAAAAAAAAAAAAAAAAAAMqn/Pz8KCoqisLCwigsLIyI/zv/d+nSpVFSUpJyQwAAAAAAAAAAAAAA1gUFaRcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWFWVKlWKzTbbLFq3bh0tW7aM1q1bR5MmTaJOnTpRt27dqFOnThQU/P7HuJeWlsZ3330Xc+fOjW+++Sa++OKLmD17dsyaNStmzZoVb7zxRsyfPz9H9wgAAAAASEN+fn60bds2Ntpoo9hoo42iRYsW0bx582jWrFnUrFkzqlatGsXFxVGpUqXfzVm2bNnPv2v8+uuv44MPPohZs2bF7Nmz44033ogPPvggR/cIAAAAAAAAAAAAAAAAAAAAAAAAAAAAyoZMJhObbLJJtGnTJlq2bBmtWrWKDTfcMOrWrfvz540VFhb+bsby5cvj22+/ja+//jq++uqr+OKLL2LGjBk/z7vvvhvLly/P0T0CAAAAAAAAAAAAAKCiKki7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBvqVmzZuy4447Rs2fP6Ny5c7Rr1y6KiorWKjMvLy9q1aoVtWrVitatW//P35eWlsbs2bNj6tSp8eyzz8bYsWPjgw8+WKs1AQAAAIB0FRcXxzbbbBPdu3eP7bbbLrbZZpuoWrXqWucWFhZGo0aNolGjRr/69/PmzYtXXnklJk6cGGPHjo1XXnklSktL13pdAAAAAAAAAAAAAAAAAAAAAAAAAAAAKCsqV64c3bt3j5122ik6d+4cnTp1iuLi4rXKLCgoiPr160f9+vVj8803/5+/X7JkSUydOjVefPHFmDRpUowfPz6WLFmyVmsCAAAAAAAAAAAAALDuKUi7AAAAAAAAAAAAAEAarrjiijj11FOznrv//vvHiBEjsp6bpAULFkS1atWymrlw4cKoXr16VjMBAAAAAAAAAAAAAAAAAAAAAAAAAFh3NG7cOA488MDo06dPdO7cOfLz83O6fl5eXrRq1SpatWoVBx10UEREzJ49O0aPHh3Dhw+PqVOn5rRPeVG9evXYYostolWrVtGyZcto3rx51KtXL+rUqRN16tSJ4uLiKCwsjMLCwigoKIiIiOXLl8eSJUti8eLFsWTJkvj666/j888/j88//zw+/PDDmD59erz55pvxySefpHzvKo6kzuct7zp16hSvvvrqr/7dYYcdFnfccUei61944YVx/vnnJ7pGNm222WbxxhtvRCaTSST/1VdfjU6dOiWSvSbsb7lVtWrV6Nix48+P9cqpXbt2VK1a9T8mLy8vSkpKYtmyZbFs2bJYsGBBzJ07N7799tv45JNP4v333485c+bEm2++Ge+++26UlJSkfffKNa8hv+73XkMAAEhf5cqVo3fv3tGvX7/Yddddo1KlSjnvUKtWrdhpp51ip512isGDB8e3334bjzzySNx7770xceLEKC0tzXknAAAAAAAAAAAAAAAAAAAAAAAAAGDdUl7OGi8tLf35/Plly5bFokWLYu7cuT/Pp59+GnPmzIn3338/Zs2aFR9++GHalQHWaTVr1oy+ffvGfvvtFz169IjKlSvndP3KlStHt27dolu3bnH66afH4sWLY9y4cfHII4/Egw8+GAsXLsxpHwAAAAAAAAAAAAAAyqeCtAsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVKpUKfbff/848sgjo1u3bpGXl5d2pf/QsmXLOPnkk+Pkk0+O2bNnx5133hk33XRTfPPNN2lXS02jRo1ip512il69ekXnzp2jVatWq/19KygoiGrVqkW1atUiIqJJkybRqVOn//m677//PiZNmhTjxo2LcePGxcyZM7NyH2BV3HXXXXHSSSdFhw4dEltjwIABcd1118W3336b2BrZdPHFF0cmk0ksf8CAAYllrwr7W+7VqFEjdt111zjjjDNiiy22iPz8/FW+bX5+flSpUiWqVKkSNWvWjMaNG//q1y1ZsiRee+21GD9+fDz99NPx3HPPRUlJSbbuAgAAUMZ06dIljjrqqOjbt29Ur1497Tr/oXbt2nHEEUfEEUccEZ999lkMHTo0brrpppg7d27a1QAAAAAAAAAAAAAAAAAAAAAAAAAAUpWXlxdFRUVRVFQUEf8+x7FJkya/+fU//PBDvPbaa/Hqq6/Gc889FxMmTIgffvghV3UB1lk77LBDHHfccbHHHnv8vGeXBVWqVInevXtH79694/rrr48RI0bETTfdFC+99FLa1QAAAAAAAAAAAAAAKMMyaRcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1l3rr79+nHvuufHxxx/H3XffHd27d4+8vLy0a/2uli1bxkUXXRSffPJJ3HbbbbHpppumXSlnGjVqFKecckq8+uqr8dlnn8Udd9wR/fr1i9atWyf6fVtvvfVir732ihtuuCFmzJgR06dPj1NPPTUaNmyY2JqwUmlpaQwcODDRNapXrx5nnnlmomtkS+fOnWOvvfZKLH/UqFHx7LPPJpb/W+xvuVelSpXYd999Y9SoUfH111/HAw88EB07doz8/PxE1qtcuXJ06dIlzjnnnJgwYUJ8+eWXcdNNN0WXLl0SWQ8AAEhH165d4+mnn47JkyfHX/7yl6hevXralX7XBhtsEBdffHF88sknMXTo0HXi50EAAAAAAAAAAAAAAAAAAAAAAAAAgGypWbNmbL/99jFw4MAYNWpUzJs3L15++eW44IILok2bNmnXA6hQMplMHHLIIfH666/H+PHjo2/fvlFUVJR2rd9UXFwchx9+eEyZMiUmTZoUPXv2TLsSAAAAAAAAAAAAAABlVCbtAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMC6p0qVKnHWWWfFBx98EBdddFE0aNAg7UqrraioKA4//PCYPn163HXXXbHhhhumXSkx2223XTzyyCPxySefxJVXXhkdOnRItc9mm20WV1xxRXz66adx//33x+abb55qHyq+iRMnxmOPPZboGscdd1w0bNgw0TWyYciQIYll//TTT3Haaacllv9r7G+5V69evbj00kvjyy+/jBEjRsTee+8dRUVFOe9Rp06dOOqoo2Ly5MnxyiuvxEEHHRR5eXk57wEAAGRH586d4+mnn47nn38+dtxxx7TrrLbKlSvH0UcfHXPmzIlLL700qlWrlnYlAAAAAAAAAAAAAAAAAAAAAAAAAIByJ5PJxFZbbRXnn39+vPPOOzF9+vQ444wzonbt2mlXAyjXevfuHW+99VbcddddscUWW6RdZ7V17949nnnmmXjuuedS/3waAAAAAAAAAAAAAADKnkzaBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIB1y/777x9z5syJIUOGRM2aNdOus9YymUwccsghMXPmzLj00kujcuXKaVfKmm222Saef/75eO6552KvvfaKTCaTdqX/kMlkYv/994833ngjHnnkkdhoo43SrkQFduqpp8ZPP/2UWH6VKlXi3HPPTSw/G3bYYYfYcccdE8u/4YYbYs6cOYnl/5L9LfcaNmwY119/fXz00UdxxhlnRI0aNdKu9LOOHTvGvffeG9OnT4899tgj7ToAAMBqKCoqiiuvvDJefPHFRH9mzZUqVarEGWecEe+++66fTwAAAAAAAAAAAAAAAAAAAAAAAAAA1tJmm20Wl156aXz22Wdxxx13RLt27dKuBFCubLzxxjFp0qR49NFHo02bNmnXWWvbbbddTJs2Lf7xj39UiM9PAwAAAAAAAAAAAAAgOwrSLgAAAAAAAAAAAAAAAEDF0alTp+jRo0dWM6dNmxbPPvtsVjMBAAAAAAAAAAAAAAAAAAAAAABIR7NmzeLGG2+MXXbZJe0qiSgsLIwzzjgj9t133zj66KNj3LhxaVdaY/Xq1Yvrr78+9ttvv7SrrJK8vLzYa6+9YpdddokhQ4bEZZddFsuWLUu7FhXMrFmz4sYbb4wTTjghsTWOPPLIuPzyy+Ojjz5KbI21cckllySWPW/evLjwwgsTy1/J/paOY445Ji699NKoUaNG2lV+V9u2bePxxx+PkSNHxnHHHRdffvll2pUAAIDf0blz57jrrrti4403TrtK1jVu3Dgef/zxuOuuu+Loo4+OxYsXp10JAAAAAAAAAAAAAAAAAAAAAAAAAKDcKioqisMOOywOPfTQGDlyZJx33nnxzjvvpF2LMqRTp07Ro0ePrGZOmzYtnn322axmQq7k5+fHGWecEeedd14UFRWlXSerMplMHHvssbHXXntFv379YuLEiWlXgnLNaygAAAAAAAAAAAAAFUFB2gUAAAAAAAAAAAAAAACoOHr06BFXXXVVVjOvvPJKh7gDAAAAAAAAAAAAAAAAAAAAAABUAAcccEDcfPPNUb169bSrJG6jjTaKsWPHxrXXXhunnXZa/PTTT2lXWi377rtvDB06NGrXrp12ldVWuXLluPDCC2OfffaJvn37xvvvv592JSqYCy64IA455JBYb731EsmvVKlSXHDBBXH44Ycnkr829thjj9h6660Tyz///PPj+++/Tyw/wv6Who033jiGDRsWXbt2TbvKatlnn32ie/fucdBBB8W4cePSrgMAAPyKE044Ia6++urIz89Pu0qiDj300OjUqVP07ds3ZsyYkXYdAAAAAAAAAAAAAAAAAAAAAAAAAIByLS8vL/r27Rt9+vSJYcOGxRlnnBHfffdd2rUoA3r06BFXXXVVVjOvvPLKePbZZ7OaCbnQuHHjGDFiRHTp0iXtKonaYIMN4plnnonLLrsszj333FixYkXalaBc8hoKAAAAAAAAAAAAQEWQSbsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUHEVFRXFsGHD4r777ovq1aunXSenTjrppJgyZUo0b9487SqrJD8/P6655poYMWJE1K5dO+06a6V9+/bx6quvRu/evdOuQgUzb968uPDCCxNd45BDDomNN9440TXWxODBgxPLnjlzZtx4442J5dvf0rH33nvHK6+8El27dk27yhqpU6dOPPnkkzFgwIC0qwAAAP/l0ksvjeuuuy7y8/PTrpITbdu2jSlTpsR2222XdhUAAAAAAAAAAAAAAAAAAAAAAAAAgAohk8nEkUceGTNmzIhDDz007ToAZcYuu+wSr7/+enTp0iXtKjmRyWTirLPOitGjR0e1atXSrgMAAAAAAAAAAAAAQEoyaRcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKqa6devGhAkTon///mlXSU3Hjh3j5Zdfjm233TbtKr+ruLg4nnzyyTjppJPSrpI1NWvWjFGjRsURRxyRdhUqmBtuuCHmzJmTWH5+fn4MGjQosfw1ccABB0S7du0Syz/llFNi+fLliWTb39Jx9tlnx8iRI6O4uDjtKmslk8nE3//+97j88svTrgIAAMS/f2a+884744wzzki7Ss6tt956MW7cuNhzzz3TrgIAAAAAAAAAAAAAAAAAAAAAAAAAUGHUrVs37rzzzhg5cmSsv/76adcBSNVf//rXGDNmTNSuXTvtKjn3pz/9KV544YXYYIMN0q4CAAAAAAAAAAAAAEAKMmkXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACqe1q1bx0svvRRdunRJu0rq6tSpE+PHj4/99tsv7Sq/qlq1avHUU09Fr1690q6SdZlMJm699dY46aST0q5CBfLTTz/F6aefnuga++23X7Rr1y7RNVZVfn5+XHTRRYnljx8/PkaPHp1Itv0tHbfffnsMHjw48vLy0q6SNaeddloMGjQo7RoAALDOu/nmm+PQQw9Nu0ZqKleuHA899FDstNNOaVcBAAAAAAAAAAAAAAAAAAAAAAAAAKhQ+vTpE9OnT4+uXbumXQUgFUOGDIkbb7wx8vPz066Smnbt2sWkSZOiUaNGaVcBAAAAAAAAAAAAACDHMmkXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACqWTTbZJCZNmhTNmzdPu0qZUVRUFPfdd1/069cv7Sr/oVKlSvHEE09E165d066SqGuuuSYOPPDAtGtQgYwcOTKef/75xPLz8vLi4osvTix/dRx++OHRsmXLRLJXrFgRAwYMSCTb/paOf/7zn/GXv/wl7RqJOO+88+LII49MuwYAAKyzTj755Ojfv3/aNVJXWFgYo0aNiq233jrtKgAAAAAAAAAAAAAAAAAAAAAAAAAAFcoGG2wQ48ePr7Bn7gP8lssvvzzOOuustGuUCS1atIgJEyZEgwYN0q4CAAAAAAAAAAAAAEAOZdIuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFQcm2yySUycODEaNGiQdpUyJ5PJxJ133hmHHHJI2lV+NmzYsOjWrVvaNXLi9ttvjy5duqRdgwpkwIABUVpamlj+nnvuGVtvvXVi+auisLAwzj///MTyb7/99njzzTcTyba/5d4ll1wSxxxzTNo1EnXDDTdEp06d0q4BAADrnJ133jmuvPLKtGuUGcXFxTFq1KioX79+2lUAAAAAAAAAAAAAAAAAAAAAAAAAACqUwsLCuP322+OSSy5JuwpATlx88cVx2mmnpV2jTGndunU8+eSTUbVq1bSrAAAAAAAAAAAAAACQI5m0CwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVQ4MGDeKpp56K+vXrp12lzMpkMnH77bfHrrvumnaVOPHEE+OQQw5Ju0bOFBUVxYMPPhg1atRIuwoVxLRp02L48OGJrjF48OBE8//IMcccE40bN04ke+HChXHuuecmkm1/y72//vWvceaZZ6a2fq4UFhbGiBEjokqVKmlXAQCAdUbDhg3jgQceiPz8/LSrlCkNGzaMBx980OMCAAAAAAAAAAAAAAAAAAAAAAAAAJCAM888M66//vq0awAk6qijjopzzjkn7Rpl0hZbbBF33XVX2jUAAAAAAAAAAAAAAMiRTNoFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgPKvatWqMWbMmGjatGnaVcq8/Pz8GDFiRLRr1y61Dm3bto3LLrsstfXTssEGG8TVV1+ddg0qkDPPPDMWL16cWP6OO+4Y22+/fWL5v6e4uDjOOeecxPIvvfTS+PLLL7Oea3/LvXbt2sU111yTytpp2GijjeLCCy9MuwYAAKwzhg4dGuutt17aNcqkbt26xRlnnJF2DQAAAAAAAAAAAAAAAAAAAAAAAACACun444+PoUOHpl0DIBE77rhj/OMf/0i7RpnWt2/fOPvss9OuAQAAAAAAAAAAAABADmTSLgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUf3fccUd07Ngx7RrlRvXq1ePxxx+P9ddfP+dr5+XlxV133RWVK1fO+dplQf/+/WP77bdPuwYVxKeffhpXX311omsMGTIk0fzfcvLJJ0fdunUTyf7kk0/iqquuynqu/S33+1txcXGMGDFinXvMBwwYEG3atEm7BgAAVHg77bRT7LXXXmnXKNPOP/98P58AAAAAAAAAAAAAAAAAAAAAAAAAACTk6KOPjvPOOy/tGgBZ1bhx43jwwQejoKAg7Spl3qBBg3w2GwAAAAAAAAAAAADAOiCTdgEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgfDv66KNj3333TbtGudO0adO44447cr7uEUccER07dsz5umXJkCFD0q5ABXLJJZfEV199lVh+ly5dYrfddkss/9est956cdpppyWWf+aZZ8aSJUuynmt/y/3+ds0118TGG2+c0zXLgvz8/Bg8eHDaNQAAoMK79NJL065Q5hUWFsZNN92Udg0AAAAAAAAAAAAAAAAAAAAAAAAAgApr0KBB0b9//7RrAGRFXl5e3HvvvbH++uunXaVcKCgoiHvuuSeKiorSrgIAAAAAAAAAAAAAQIIK0i4AAAAAAAAAAAAAAKvqtddei/vvvz/rucuXL896JpAb9gUAAAAAAAAAAAAAAAAAAAAAAACA9G222WZxzTXXpF2j3Ordu3eccMIJcf311+dkveLi4hgyZEhO1irLunTpEjvvvHOMHTs27SpUAAsXLoxzzz03brnllsTWGDx4cDzxxBOJ5f+3M844I2rWrJlI9tSpU2P48OFZz7W//Vsu97ctt9wyjjjiiMTXKav69OkTW2yxRbzxxhtpV6Ecc84ywLrLawD8sV69ekXHjh1T7fDJJ5/E3LlzY8GCBbFgwYL48ccfY8WKFZHJZKK4uDiqV68e1atXjwYNGkTDhg1T69mtW7fYfffdY8yYMal1AAAAAAAAAAAAAAAAAAAAAAAAAACoyIYOHRpvvvlmTJs2Le0qAGvlzDPPjO7du6ddo1xp06ZNnHPOOXHeeeelXQUAAAAAAAAAAAAAgIQUpF0AAAAAAAAAAAAAAFbV8OHDY/jw4WnXAMoQ+wIAAAAAAAAAAAAAAAAAAAAAAABAujKZTNx+++1RVFSUao8PPvggJk+eHO+88068//778dFHH8X8+fNj0aJFsXjx4igtLY3CwsIoLi6OatWqRaNGjWKjjTaK1q1bR+fOnaN9+/aRn5+fWv9LL700Hnvssfjoo48SX+voo4+OunXrJr5OeXDSSSfF2LFj065BBXHbbbfFSSedFJtttlki+e3bt4++ffvGww8/nEj+L9WvXz9OPPHExPIHDBiQSK797f/kan+77rrrIi8vL/F1yrKTTjop+vfvn3YNyjHnLAOsu7wGwB876aSTcrresmXLYuzYsTF69Oh4880346233ooFCxas8u3XW2+92HTTTaN9+/axxx57xI477hiFhYUJNv5Pl112WTzxxBNRWlqaszUBAAAAAAAAAAAAAAAAAAAAAAAAANYVhYWF8eCDD0aHDh3i+++/T7sOwBpp0aJFnH/++al2+O6772Ly5Mnx+uuvx5w5c+KDDz6Ib7/99ufPGyspKYni4uKoWbNm1KxZM2rXrh1t27aNjh07RocOHaJp06ap9D711FPj5ptvjk8//TSV9QEAAAAAAAAAAAAASFZB2gUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA8unEE0+MLbfcMufrlpSUxMSJE2P48OHxr3/9K7744ou1yisuLo4ePXrEAQccEHvvvXdUr149S01XTdWqVeOmm26KXXfdNdF1CgsL45RTTkl0jV9asWJFzJo1K956661455134quvvooFCxbEwoULY+nSpVG1atWoVatW1K5dO9q3bx9du3aNRo0a5azfLrvsEvXr14+vvvoqZ2tWZE8//XTMnj077Rpr7Jtvvlmr269YsSIGDhwYY8eOzVKj/3XRRRfFqFGjYsWKFYmtERFx7rnnRtWqVRPJfuihh+KFF17Ieq797T/lYn876KCDokuXLonl/7ePP/44pkyZEjNmzIgPP/wwFixYEIsXL46If7+OFhcXR926daNVq1axySabxFZbbRVFRUWJ99p8880jk8kk/rys6Nb11xAAAP5X7dq1E/9d2UqzZ8+Oiy++OEaNGhXz589f45zvv/8+Jk+eHJMnT45//vOfUa1atejTp0+cddZZ0aZNmyw2/nVt27aNPfbYIx5//PHE1wIAAAAAAAAAAAAAAAAAAAAAAAAAWOmHH374+ez4tZWXlxeFhYVRtWrVnJw3v7qaNWsWN910U+y///5pVwFYI0OHDk1lf505c2bce++9MXLkyHjrrbdW+/YPP/zwz/97o402igMOOCAOOuigaNu2bTZr/q4qVarE5ZdfHgcddFDO1gQAAAAAAAAAAAAAIHcK0i4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlD8NGjSIiy++OKdrLly4MG6++eb4+9//Hp999lnWcn/88cd44okn4oknnojKlSvH4YcfHqeffno0a9Ysa2v8kV122SX69u0bDz/8cGJr/PnPf46GDRsmlh8RsWLFinjyySfjwQcfjMceeyzmzZu3Wrdv06ZNHHPMMXHYYYdFjRo1Emr5b/n5+XHggQfGNddck+g664pbbrklRowYkXaNVI0bNy6efPLJ2HXXXRPJb9OmTRx88MFx9913J5IfEbHhhhvGUUcdlUj2smXL4vTTT08k2/72n5Le3/Ly8uLCCy9MJPuXvvjii7j55ptj+PDhMXPmzNW6beXKlaN79+5x2GGHxb777huVKlXKWq9FixbFAw88EDfffHNMmTIla7nrMq8hAAD8tz59+kRBQUGia8ybNy/OO++8uOmmm2L58uVZz1+4cGHcfffdcc8998S+++4bV1xxRTRt2jTr6/zSKaecEo8//niiawAAAAAAAAAAAAAAAAAAAAAAAAAA/NJRRx2VyFnjeXl5UadOnWjatGlsuOGG0aZNm9h6662jc+fOUb9+/ayvt6r222+/GD58eDz66KOpdQBYE3369Imddtopp2uOGzcuBg8eHJMmTcpa5vvvvx9DhgyJIUOGROfOneOSSy6Jnj17Zi3/9xxwwAExaNCgmDFjRk7WAwAAAAAAAAAAAAAgdzJpFwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADKn0GDBkVxcXFO1lqxYkUMHTo0mjZtGqecckp89tlnia21ZMmSGDp0aLRs2TKOPfbY+OGHHxJb679deumlUVBQkFj+EUcckVh2RMRjjz0W7dq1i9133z3uuOOOmDdv3mpnvPvuu3HiiSdGkyZNYtiwYQm0/E+77LJL4muwbjnllFOipKQksfxBgwYluk9ccMEFUVhYmEj2tddeGx988EEi2fa3/5Xk/rbXXntFixYtEsv//vvvY8CAAdG0adO44IILYubMmaudsWTJkhg7dmwcfPDB0bRp07j33nvXutcbb7wRxx57bDRs2DD69+8fU6ZMWetMAADg1+26666J5r/22mvRvn37+Mc//hHLly9PdK3S0tIYMWJEbLHFFjFq1KjE1ikpKYlvv/02ioqKElsDAAAAAAAAAAAAAAAAAAAAAAAAACBXSktL45tvvolXXnklRo4cGYMHD47evXtHgwYNYosttohBgwbFO++8k0q3oUOHRo0aNVJZG2BN5OXlxcUXX5yz9d5+++3YbrvtYuedd45JkyYlts7LL78cO+64Y/Tq1SumT5+e2Dor5eXlxemnn574OgAAAAAAAAAAAAAA5F4m7QIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABA+bLxxhvHEUcckZO1ZsyYEV26dIljjz02vvvuu5ysGRFRUlISQ4cOjY033jhGjRqVkzVbtmwZRx11VCLZlStXjmbNmiWSvWjRoth///1jr732irfffjsrmfPnz4//9//+X+y6666xYMGCrGT+mu222y7y8/MTy2fd884778Qtt9ySWH7z5s0T23833njjOOSQQxLJnjt3blx88cWJZNvffl2S+9vAgQMTyY2IePHFF6Nt27ZxzTXXxPLly7OS+eWXX0a/fv2iT58+sXjx4tW67cKFC+PWW2+NrbbaKtq3bx9Dhw6N+fPnZ6UXAADw27bffvvEsqdNmxbbb799fPLJJ4mt8Wu+//772GeffeL888/Pau4333wTQ4YMiWbNmkXfvn1j6dKlWc0HAAAAAAAAAAAAAAAAAAAAAAAAAChr3nzzzbjggguibdu2sf3228djjz0WpaWlOVu/YcOGcfbZZ+dsPYC11a9fv9h0000TX2fFihUxaNCgaN++fbzwwguJr7fSM888E1tuuWVcf/31ia91yCGHRKNGjRJfBwAAAAAAAAAAAACA3MqkXQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoX84777zIz89PfJ2RI0fGlltuGS+//HLia/2Wr776KvbZZ5847bTToqSkJPH1zj333KhUqVLWc5csWRKtWrWKffbZJ55//vms5X711VexzTbbxIgRI7KW+UtPPfVU7LzzzjF//vxE8qtVqxZbbLFFItmsu84777zErtmIiL/97W9RVFSU9dyLLroosb09ycfE/vbrktrfOnXqFN26dct67krdu3ePzz//PJHsRx55JHr16hVLliz5w6995ZVX4qijjoqGDRvGkUceGdOmTUukEwAA8L+aNm0atWvXTiT722+/jd69eyf6c/sfufDCC+Oqq65a65yXX345DjnkkGjcuHGcc8458emnn2ahHQAAAAAAAAAAAAAAAAAAAAAAAABA+TJp0qTYa6+9Yuutt46XXnopZ+uedNJJ0aRJk5ytB7A2zj333MTXmD9/fuy5555xwQUXxPLlyxNf778tW7YsTjzxxDjhhBOitLQ0sXUqVaoU/fv3TywfAAAAAAAAAAAAAIB0ZNIuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJQfTZo0if322y/xda644oro27dvLFy4MPG1VsWVV14ZvXv3jqVLlya6TsOGDePggw9OJHvFihUxatSo6NatW2y11VZx3333xfLly9c4b/HixdG7d++YPn16Flv+rylTpsRBBx2UWP4mm2ySWDbrpm+++SaGDBmSWP4GG2wQxx57bFYzO3ToEH/+85+zmrnSu+++GzfffHMi2SvZ335dEvvbkUcemfXMlUaNGrVW37dVMXny5DjmmGN+9e/mz58fN954Y3Ts2DG23HLLuOWWW8rM+xAAAFiXbL755olln3XWWfHFF18klr+qTj311Bg5cuRq327p0qVx1113xVZbbRVbb7113HPPPbFs2bIEGgIAAAAAAAAAAAAAAAAAAAAAAAAAlC9Tp06NbbbZJo499tjEP18mIqJy5coxaNCgxNcBWFu77757tG7dOtE15s6dG9tuu2088cQTia6zKm644YYYOHBgomscfvjhieYDAAAAAAAAAAAAAJB7mbQLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOXHwIEDo6CgINE1hgwZEqeffnqia6yJJ554Inr37h1LlixJdJ3TTjst0fyIiGnTpsVBBx0UzZo1i8suuyy+++671c448sgj4+WXX06g3f8aM2ZM3HfffYlkt2zZMpFc1m3XXHNNfPTRR4nln3XWWVFcXJy1vMGDB0deXl7W8n5p4MCBUVJSkkj2r7G//Z9s72+ZTCb22WefrGau9O6770a/fv0Syf5vd9xxR4wdO/bn/37ppZeif//+0bBhwzjmmGPitddey0kPAADg1zVr1iyR3K+++iruuOOORLLXxDHHHLPKP7N+/PHHceaZZ0bjxo3jsMMOi2nTpiXcDgAAAAAAAAAAAAAAAAAAAAAAAACgfBo6dGhsvfXW8f777ye+Vr9+/aJx48aJrwOwNgYOHJho/nfffRe9evWKt99+O9F1Vsc111wTw4YNSyx/o402iq5duyaWDwAAAAAAAAAAAABA7hWkXQAAAAAAAAAAAAAAWDW1atWK1q1bR6NGjaJ+/fpRXFwcRUVFkZ+fHyUlJbFw4cL48ccfY+HChfHNN9/EzJkz45NPPkm79jqjdu3a0apVq2jevHnUqFEjiouLo7i4OPLy8mL58uWxePHiWLRoUfzwww/x4Ycfxocffhhffvll2rUp5+wLZZt9gTWRyWSicePG0aBBg2jQoEHUrVs3qlatGkVFRVG5cuXIZDIREVFaWhpLly6NZcuWxcKFC2Pu3Lkxd+7c+OSTT+KTTz6JFStWpHxPAAAAAAAAAAAAAAAAAAAAAACAiqpy5crRv3//RNe45ZZb4pxzzkl0jbUxduzYOPjgg+Ohhx6KvLy8RNbYdNNNY4cddogJEyYkkv9Ln332WZx55plx4YUXxmGHHRYDBgyIVq1a/eHtnnnmmbj33nsT7/dL559/fhx44IFZz23RokXWM2Hp0qVx5plnxn333ZdIft26deOkk06KIUOGrHVW165d409/+lMWWv2vcePGxZNPPplI9h+xv2V/f9t+++2jbt26Wc2MiFi+fHnsv//+sWjRoqxn/5azzz47Zs6cGTfffHNMnz49Z+sC2bH++uvHpptuGo0aNYoaNWpE9erVo1q1apHJZJz/+xsKCgqiefPmscEGG0TdunWjdu3aUbVq1SgsLIzCwsKfv+6nn36KpUuXxpIlS2LJkiUxd+7c+OKLL+KLL76IL7/8MpYvX57ivSjfXLdrLz8/P5o2bRpNmjSJOnXqRJ06daK4uPjn63jlGeBLliyJxYsXxzfffBNffPFFfPzxx85oL4PsS/yeDTbYIJHcxx57LH766adEstfE119/HaeeemoMGzbsN7/mmWeeieuvvz4ef/xxZ9CTdbVq1YrNNtssGjZs+PP7k5Wfq7F06dJYsGBBLFy4MObPnx8ffvhhvPfee7FkyZK0a/+soKAgNt5442jRokXUqFHj5yksLIzS0tKf318tWLAgPv7443j//ffj008/jdLS0rSrlxuukXWL92cAAAAAAAAAAAAAAAAAAAAAAABUJG+88UZsu+228cwzz0Tbtm0TW6dSpUoxcODAGDhwYGJrJMUZZCTFtVW2tGjRInr27JlYfklJSfTt2zfeeOONxNZYU8cff3x07959lT6vZlV9/fXX8cADD8S9994bL730UtZyk1KnTp3YcMMNo0mTJlGzZs2oUqVKVKlSJapWrRr5+flRUlISixYt+nnmzZsXH374YXz00UexcOHCtOuXSz6XgGzyHAYAAAAAAAAAAADIrYK0CwAAAAAAAAAAAAAAv65du3ax8847R48ePaJz585Rr1691c5YvHhxzJ49O1588cUYN25cjB8/PubNm5dA23XPJptsErvsskvssMMOsd1220Xt2rVXO2PBggXx8ssvx4svvhjjx4+PSZMmxYoVKxJoS0VhXyjb7AusrkwmEx06dIju3bvH1ltvHZtuumm0bt06ioqK1ir3p59+ig8++CBee+21mDZtWjz//PMxderUKCkpyVJzAAAAAAAAAAAAAAAAAAAAAABgXda3b9+oUaNGYvmTJ0+O4447LrH8bBk5cmQMGTIkzjnnnMTW6N+/f0yYMCGx/P+2aNGiGDp0aAwdOjR23333GDhwYPTs2fNXv3b58uVx/PHH56zbSrNmzYpXX301OnbsmNXcmjVrZjUPVrr//vvj5JNPjq233jqR/NNOOy3++c9/xvfff79WOZdcckl2Cv2XkpKSGDhwYCLZq8P+lj377bdfVvNWuu6662L69OmJZP+WV155JV555ZWcrgmsuTZt2sRuu+0Wu+yyS2y++ebRoEGD1c5Yl87/LSgoiG233Ta23Xbb6Ny5c7Rv3z6aNm0a+fn5a5W7fPnymDVrVrz11lsxffr0mDx5cjz//POxdOnSLDWvWFy3a6eoqCi6dOkSXbp0iU6dOkX79u2jWbNma3wdL1y4MN55552YMmVKTJo0KSZMmBDfffddllvzW+xLrK5atWolkvvSSy8lkrs27rzzzhg0aFA0btz45z9buHBh3HnnnXHDDTfEe++9l2I7KppmzZrFHnvsEbvvvnt06NAh6tevv1q3X7FiRXz44YfxxhtvxL/+9a8YM2ZMfP755wm1/V/VqlWLXXbZJfbcc8/o1KlTbLzxxlGpUqXVyli8eHG8/PLL8fzzz8e4cePi2WefjdLS0oQalz+ukXXnGvH+rOypV69e1KxZ8+f5o8+vmTp1anzzzTc5agcAAAAAAAAAAAAAAAAAAAAAAFA+ffXVV9G9e/eYOHFibL755omtc+SRR8bf/va3+PHHHxNbY205g4ykuLbKvkMPPTTR/L/97W85/Zyt1bFkyZI47rjjYuzYsWuVs2DBghg1alTce++98cwzz0RJSUmWGmZPJpOJdu3aRefOnWPrrbeOrbbaKlq2bBlVqlRZ48x58+bFG2+8EVOmTIkXX3wxXnzxxZg7d24WW1cMPpeAbPAcLjucEwsAAAAAAAAAAADrtrzS0tLSVfrCvLykuwAAAAAAAAAAAADkzBVXXBGnnnpq1nP333//GDFiRNZzk7RgwYKoVq1aVjMXLlwY1atXz2pmRESDBg2id+/eWc38/PPPY/To0VnNXBtNmzaNo446Kg466KBo3rx51vNLS0vjxRdfjJtuuilGjBgRS5YsWaXbNW/ePJo0abJWa3///ffx5ptvrlXGSt27d49JkyZlJWuliRMnxg477PC7X1O9evU45JBD4vDDD48tt9wyq+tHRHzzzTcxatSouPHGG+O1117Lev6aSOuxXlX2hbWX5r4QUbb3hnV1X9hxxx2jRYsWa3z7nXfeOfr27ZvFRhFPP/10PPjgg1nN/KUJEybErFmzEsv/papVq8Zuu+0Wf/7zn2O33XZL5D3Tr5k/f34888wz8cADD8Tjjz8eixYtysm6AAAAAAAAAAAAAGXJKh7L/quc1Q4AAAAAAAAA/+eZZ56Jnj17JpK9YMGCaNOmTXz22WeJ5GdbXl5ePPfcc9G1a9dE8hcvXhwNGjSI+fPnJ5K/Ktq1axcDBw6MAw88MAoLC3/+84cffjj+/Oc/p9LpyiuvjFNOOSWrmc8880z06tUrq5llmfN5c6tLly4xefLkxPKHDBkS55xzzhrffuedd46nnnoqi43+z8033xx//etfE8leW/a3NfPFF19EgwYNspYX8e/X/yZNmsQPP/yQ1VyS4TUk+8rDOcvZ7Dhs2LAoKSlZpa+tV69e/PWvf43+/ftHs2bNsrL+L5XFc8HXRnFxcfTp0yf222+/2GGHHbL+GQS/ZenSpfHCCy/EY489FsOHD49vvvkmJ+v+Eddt+VS/fv3o06dP9O3bN7bbbruoXLlyYmstX748JkyYEA888EDcd999qZzbXB5eA9aGfek/lfXPfihr7rzzzjj00EOznrvrrrsm9jPw2jjzzDPjkksuiffeey9uuOGGuOuuu2LBggU571GzZs3Yf//9s5r5/fff5/S9fv/+/aOgoCCrmavzXuCPpPEepaioKPr16xcnnHBCbLHFFllZ+5deffXVGDp0aNx9992xdOnSrOdHROy2225xwgknRM+ePf/j9zjZ8Pnnn8eIESPi+uuvj/fffz+r2WvCNbJmkr5GunXrViauj7Xl/dl/SuvnxoiIgoKC2G233aJ79+7RqVOn6NChQ9SsWXO11tx9993jiSee+J8/b9SoUeyxxx6rlbWqxo8fH7Nnz04ke3X86U9/yspnZ/3SCy+8EG+//XZWMwEAAAAAAACgLHJWOwAAAAAAAAAAALCunjW+4YYbxtSpU6Nu3bqJrdG/f/+4/fbbE8tfE+viGWQ77rhjtGjRYo1vv/POO0ffvn2z2Cji6aefjgcffDCrmb80YcKEmDVrVmL5v2ZdvLbKs/fffz+aN2+eSPbkyZMT+/yubFqTz11btmxZPPHEE3HvvffG6NGjY8mSJQm1W3NFRUWx8847xz777BN77rln1K5dO9H1VqxYEc8//3w8+OCD8fDDD8cXX3yR6HqrKltnTK7rn0vgNTT3PIf/raKeEwsAAAAAAAAAAACUPat0VnvpKooIY4wxxhhjjDHGGGOMMcYYY4wxxhhjjDHGmAozV1xxxar+M8rVst9++6V+31Z3FixYkPXHYcGCBYl07d69e9a7TpgwIfXvQUSUtmvXrvShhx4qLSkpyfp9/C3z5s0rveKKK0rXW2+9nDxnsvlY5/paqFatWunZZ59dOm/evKyv+1vGjx9fuuOOO6Z+bZb1511Z72df+GNl+XpYV/eF++67L2f3qazo1atX4o9r69atS6+//vrS+fPnp313SxcuXFh60003lbZt2zb1vc4YY4wxxhhjjDHGGGOMMcYYY4wxxhhjjDEml7M20u5ujDHGGGOMMcYYY4wxxhhjjDHGlJWpX79+6YoVK7J0KtL/Ov7441O/j6s7m266aemyZcsSe0wOOeSQ1O/jyu/9hRdeWPrNN9+UlpaWpnpm4sknn5z1x3nKlCmpP8a5HOfz5n5GjBiRyGNeWvrvM+bq1q27xt2mTZuWSK/58+eX1qtXL/XH/o/G/rbq06pVq6z3Ky0tLb3iiitSvw7Mqo/XkOxPeThnOZsdq1at+ofrtWzZsvTOO+8sXbp0adbW/SNl5VzwNZm2bduWDhs2rPTHH3/M2eP1W3766afSMWPGlO66666pPy6u2/IzmUymdM899ywdM2ZMTs9l/6Xvv/++9Jprrilt2LBhub1OVyoLZ+3bl9at73dSk9SZ+T169Ej9vv3a1KpVq0zs6a1bt876Y/7uu+/m9D4k8VlMq/JeYFUnl+9RioqKSs8+++zSr7/+Omtr/p6vvvqq9Nxzzy2tUqVKVh6rTCZTeuihh5a+9dZbOem/fPny0uHDh5e2bt061eeha6RsXiNl5fpY0/H+LP3n28pp06ZN6bXXXvvz76PXxm677fara1StWjWxz8cZOnRo6t+3vLy8RPatzTffPPX7ZowxxhhjjDHGGGOMMcYYY4wxxuRi1kba3Y0xxhhjjDHGGGOMMcYYY4wxxhhjjDHGGJOdWZfPGu/WrVuiZ+C+8MILqd/HlbMun0GW1LmmZVmvXr1yfn2ti9dWeZ0tt9wyse9BSUlJafv27VO/j6syPXv2XOX7NH78+NIjjjiidL311ku9929NixYtSq+99trEzh9c1cdq5MiRpV26dEn98cjWGZPr+ucSeA31HC7vz+HS0rJ1TqwxxhhjjDHGGGOMMcYYY4wxxhhjjDHGGGPK3qyKTAAAAAAAAAAAAAAAqWnQoEHcc8898frrr0ffvn0jk8ndP/Fdf/3149RTT405c+bECSecEPn5+TlbuzzZZ599Yvbs2TF48OBYf/31c7buDjvsEE8//XSMGjUqNtxww5ytS/rsC2WffaHimTVrVmLZLVq0iBEjRsR7770Xxx9/fFSvXj2xtVZVcXFxHHXUUfHWW2/FY489Fu3atUu7EgAAAAAAAAAAAAAAAAAAAAAAUE7sueeekZeXl0j266+/Hv/4xz8SyU7SO++8E1dffXVi+XvvvXdi2avjq6++ivPOOy8aN24cBx98cDzzzDOpdsk25++RtNNPPz2WLl2aSHZxcXGcffbZa3TbffbZJzp16pTlRv82ePDg+PrrrxPJzib726rr1q1b1rJWKi0tjRtuuCHruUD5VK1atbjsssvi7bffjkMPPTQKCwtztnZ5PP938803j9GjR8dbb70V/fv3j6pVq6ZdKQoKCmK33XaLf/3rXzF16tTYfffd066UONftmisoKIjDDz88ZsyYEY899ljstttuOT2X/Zdq1qwZJ510UsyZMyeuuOKKqFatWio9yjv7Eqy5efPmpfrzKBXPn/70p3jnnXdi8ODBUbdu3ZysWa9evbjooovi7bffjp122mmtsjp27Bgvv/xy3HnnndG2bdssNfx9+fn5ceCBB8b06dPjoosuiqKiopysmxbXyOopr9eH92dlR3FxcVx55ZXx5ptvxoknnhh16tRJbK1FixbFAw88kEj2Pvvsk9rPbStttdVWWd+33nnnnZg+fXpWMwEAAAAAAAAAAAAAAAAAAAAAgLLnueeei+uvvz6x/G233TY22mijxPJXhTPI1k2zZs3KyTq/vL5cW+XHHnvskVj2bbfdFq+//npi+dk0fvz4mD179m/+/SuvvBIDBw6MJk2aRM+ePWPYsGHx/fff567gKmrfvn08/vjjMXPmzDjxxBOjevXqqXXJZDLRp0+fmDx5ckyePDm222671Lrkgs8lqJhy9Rq6kudw+nJ5TiwAAAAAAAAAAABQPqX7Se4AAAAAAAAAAAAAsA476KCDYsaMGXHwwQdHXl5eaj1q1aoV1113XUydOjWaN2+eWo+ypmbNmnH//ffHww8/HPXr10+tx9577x3vvvtuHH744al1IHfsC2WbfaFiWrp0aXz88cdZz61SpUr8/e9/j3fffTf23XffVJ/Tv2fPPfeM119/PYYNGxa1atVKuw4AAAAAAAAAAAAAAAAAAAAAAFDG7b333ollX3jhhVFaWppYfpIuv/zyWLRoUSLZu+yySxQVFSWSvSaWLl0aw4cPT7XDihUrUl0f1sSHH34Y1113XWL5xxxzTGywwQardZtMJhMXX3xxIn0++uijuOaaaxLJTor97Y/16NEj65nPP/98fPTRR1nPBcqfXr16xcyZM+P000+PwsLC1HqUh/N/a9WqFbfddlu8/vrrsfvuu6dd5zdtueWWMXr06Bg9enQ0btw47TqJcN2uub322ivee++9uO2226Jly5Zp1/lZlSpV4tRTT41333039txzz7TrlBv2JZJQUlKSSO7666+fSC6UFUVFRXH77bfHE088ERtttFEqHZo3bx5jx46NW2+9NSpVqrRat61UqVL8/e9/j5dffjk6deqUUMPfV1hYGOeee2689tpr0bp161Q6JMk1snbKy/Xh/VnZss0228S7774bp5xyShQUFORkzWHDhiWSW69evejWrVsi2asqiZ/V0v7/BgAAAAAAAAAAAAAAAAAAAAAAgNw5++yzEz0ff6+99kos+/c4g2zdtXTp0vj4448TXaM8XF+urd+2xx57JJK7YsWKuOyyyxLJTspdd931H/89e/bsuPDCC2OTTTaJLbfcMq6++ur4/PPPU2r3++rVqxe33nprvPLKK7HHHntEJpNJu9J/6NKlSzz33HNx9913R/369dOuk3U+l6BiysVr6Eqew2VDGufEAgAAAAAAAAAAAOVP2fqXngAAAAAAAAAAAACwDigqKoqbbrop7r333qhRo0badX7WoUOHePXVV6N3795pV0ldixYtYsqUKbH//vunXSUiIqpUqRK33XZb3HHHHVFUVJR2HRJgXyj77AsV15w5c6K0tDSrmVtvvXW88cYbMWDAgKhUqVJWs5OQl5cX/fv3jxkzZkSfPn3SrgMAAAAAAAAAAAAAAAAAAAAAAJRRhYWFseOOOyaS/e6778aoUaMSyc6Fb7/9Nm655ZZEsouLi6NHjx6JZJdX1atXz3rmihUrsp4J/+3iiy+OuXPnJpJdVFQU55133mrdpl+/ftGmTZtE+pxxxhmxdOnSRLIrsrK+v3Xr1i1rWSvdf//9Wc8Eype8vLw477zz4qmnnoqGDRumXSciyvb5v/vuu2/MmDEjDj/88MhkMmnXWSW77757vPPOO9GvX7+0q2SN63bNNW7cOJ588sl45JFHokWLFmnX+U2NGzeOxx57LIYOHRqFhYVp1ynT7EskZfHixYnkNmjQIJFcKAuaNGkSL7zwQvzlL39Ju0pERBxxxBExduzYqFmz5ip9fb169WLixIkxYMCAyM/PT7jdH2vTpk1MnTo19txzz7SrZI1rJHvK8vXh/VnZstdee8X48eOjSZMmOV13ypQp8c477ySSve+++yaSu6p23333rGf6PTUAAAAAAAAAAAAAAAAAAAAAAKw7Fi1aFOeff35i+X369Eks+7c4g2zdNmfOnCgtLU0sv7xdX66t/1SnTp3o2LFjItmPPfZYzJ49O5HspDz66KPx5ZdfxjXXXBNbbbVVtGrVKs4///yYMWNG2tV+1+GHHx6zZ8+OI444osw/D/v16xczZsxI5fUwCT6XoGJL+jV0Jc/hsiGtc2IBAAAAAAAAAACA8qds/4tPAAAAAAAAAAAAAKhgNtpoo5gyZUocddRRaVf5Veutt148+uijcdxxx6VdJTXbbLNNvPzyy7HJJpukXeV/HHbYYfHEE09E1apV065CFtkXyj77QsU2a9asrOb9v//3/+K5556LVq1aZTU3F+rUqRMjR46Mf/7zn1FQUJB2HQAAAAAAAAAAAAAAAAAAAAAAoIzp3LlzVK5cOZHs66+/PpHcXLr22msTy+7Ro0di2eVR3bp1s565ePHirGfCf5s/f36cf/75ieX3798/Ntpoo1X62oKCgrjgggsS6TFlypR44IEHEsmu6Mry/lazZs1o3rx5VrJ+6amnnsp6JlB+FBYWxqOPPhqDBg2KTCaTdp3/UZbO/61cuXLcfPPNMWLEiKhTp07adVZb9erV4+67747LL7888vLy0q6zVly3a+6ggw6Kt956K3bZZZe0q6yyo48+Ol588cVo2LBh2lXKHPsSSVu0aFEiudtuu20iuZC2TTbZJKZOnRqdOnVKu8p/2H777ePFF1+MBg0a/O7XtWvXLqZNm1bmnqM1atSIUaNGxQEHHJB2lbXmGsm+snZ9eH9W9hx66KExcuTIqFKlSirrDxs2LJHcvn37pvY9atiwYXTo0CGrmVOnTo05c+ZkNRMAAAAAAAAAAAAAAAAAAAAAACjb7rnnnnj//fcTye7atWust956iWT/N2eQERExa9asRHLL8/Xl2vo/Xbt2Tewx+Oc//5lIbpLefPPN2GCDDWLAgAExbdq0tOv8oerVq8d9990Xt912W1SvXj3tOqusZs2aMXLkyLjqqqsiPz8/7TprzOcSVHxJvYau5DlcdqR9TiwAAAAAAAAAAABQvpS9fz0MAAAAAAAAAAAAABVUy5Yt4/nnn4/27dunXeUP3XDDDXHsscemXSPnOnbsGE8++WTUqlUr7Sq/qWfPnjFu3LgoLi5OuwpZYF8o++wLFd/MmTOzlnX55ZfHLbfcEpUqVcpaZhqOOeaYeOqpp6JmzZppVwEAAAAAAAAAAAAAAAAAAAAAAMqQbt26JZL7008/xYgRIxLJzqUPPvggJk+enEh29+7dE8ktrzbeeOOsZy5evDjrmfBrbrrppnjvvfcSyS4oKIgLLrhglb72yCOPjObNmyfSY8CAAYnkrgvK8v7Wpk2brOT80scffxxz5szJei5QPlSuXDlGjx4de+65Z9pVfldZOP+3Xr16MWnSpDjyyCNT65Atp512Wtx///2RyWTSrrJGXLdrpqCgIK6//vq49957y+W5xx07dowpU6Yk8n6ovLIvkQs//PBDIrm77757FBQUJJINaWnVqlWMHz8+6tevn3aVX9WmTZsYPXp0VKlS5Vf/vm3btjFhwoRo0qRJjputmvz8/Ljnnnti//33T7vKGnONJKesXB/en5U9vXr1imHDhqV6P+6666746aefsp7boEGD6Nq1a9ZzV8Vuu+2W9czhw4dnPRMAAAAAAAAAAAAAAAAAAAAAACjbSkpK4qqrrkokO5PJJPYZP7/kDDJWmjlzZtYzK8r15dqK2G677RLJnTt3bowfPz6R7KStWLEi7QqrpGXLlvHaa6/FAQcckHaVNTZw4MB48sknf/PM0bLM5xKsG5J4DV3Jc7jsKAvnxAIAAAAAAAAAAADli391CAAAAAAAAAAAAAA50KJFi5g4cWI0bNgw7Sqr7B//+EccdthhadfImQ033DDGjh0bNWvWTLvKH9p2223j/vvvj7y8vLSrsBbsC2WffWHdkK1D3AcPHhynnXZaVrLKgp49e8bEiRNj/fXXT7sKAAAAAAAAAAAAAAAAAAAAAABQRnTv3j2R3Keeeiq+/fbbRLJz7Z577kkkt3PnzlFUVJRIdnnUs2fPrGd+/fXXWc+EX1NSUhKnnnpqYvkHH3xwtGnT5ne/pkqVKvG3v/0tkfXvv//+mDJlSiLZ64KyvL/90XW1Jl588cWsZwLlQ6VKlWLMmDGx0047pV1llaR5/u+GG24YU6ZMic6dO+d87aTst99+ccstt6RdY7W5btdM1apVY8yYMXH88cen2mNtNW3aNCZOnJjIe6Lyxr5Ernz88ceJ5NaqVSuOPfbYRLIhDQ0bNozx48eX+c8+6dSpUwwfPvx/3pu0aNEinn766ahVq1ZKzVZNfn5+3HnnneXy9c81kry0rw/vz8qeTTfdNB5++OEoKChItcfcuXPj8ccfTyR73333TST3j+yxxx5ZzVuxYkU88MADWc0EAAAAAAAAAAAAAAAAAAAAAADKh+HDh8fSpUsTyd5+++0TyV3JGWT80syZM7OaV9Gur3X92tp2220TyR05cmSUlJQkkk1E+/bt44UXXogWLVqkXWWt9erVK5588smoVq1a2lVWmc8lWHdk+zV0Jc/hsqOsnBMLAAAAAAAAAAAAlC+ZtAsAAAAAAAAAAAAAQEXXrFmzmDBhQmywwQZpV1ltN954Y7Rv3z7tGjnRvHnzqF27dto1Vtkee+wRV155Zdo1WEP2hfLBvrBumDVr1lpnHH/88XH22WdnoU3Z0r59+xg3bly5PbwdAAAAAAAAAAAAAAAAAAAAAADIrg4dOiSS++ijjyaSm4ak7kthYWFsuummiWSXNx06dIgmTZpkPffzzz/Peib8ljFjxsQzzzyTSHYmk4mLLrrod7/m+OOPj4YNG2Z97aVLl8aZZ56Z9dx1RVnf39q0aZOVnF969dVXs54JlA833HBD9OzZM+0aqyWN83+bNGkSEydOjObNm+d03Vzo379/nHfeeWnXWC2u29VXo0aNGD9+fOy8886pdcimevXqxfjx46NZs2ZpV0mNfYlc+uijjxLLHjRoUGy44YaJ5UOuVKpUKR544IFo3Lhx2lVWyd577x1nnHHGz/9ds2bNGDduXDRo0CDFVquuqKgoRo0aVW76RrhGcimt68P7s7KnUqVKcf/990eNGjXSrhIREbfeemsiuX/+858Tyf09hYWFsdNOO2U189lnn40vvvgiq5kAAAAAAAAAAAAAAAAAAAAAAED58P3338fo0aMTye7evXsiuRHOION/zZo1K2tZFfX6WpevrS222CKR3DFjxiSSS0TXrl1j0qRJUa9evbSrZE337t1j7NixUbly5bSrrBKfS7DuyOZr6Eqew2VHWTsnFgAAAAAAAAAAACg/MmkXAAAAAAAAAAAAAICKrHLlyvHYY49FkyZN0q6yRipXrhwPPfRQ1KxZM+0q/IqBAwfGzjvvnHYNVpN9gSTZF1bfzJkz1+r2nTp1iquuuipLbcqeTp06xX333Rd5eXlpVwEAAAAAAAAAAAAAAAAAAAAAAFJUr169qF+/fiLZ48ePTyQ3DZ9//nnMmjUrkex27dolklvenHLKKYnkvv/++4nkwm8ZOHBgrFixIpHsffbZJzp06PCrf1e9evU488wzE1n36quvjo8++iiR7HVBWd/f2rRpk5WcX3rjjTeyngmUfUcddVQcddRRaddYI7k8/7d69erxr3/9K5o1a5aT9dJw/vnnR/fu3dOusUpct6uvSpUqMWbMmNh6661zvnaSGjRoEKNHj45q1aqlXSXn7EvkWlK/Y4uIWG+99eLpp59O7PedkCtDhgyJbt26pV1jtVxwwQXRunXriIi49dZbo3nz5ik3Wj2NGjWKG2+8Me0aq8w1klu5vj68PyubBg0aFJtvvnnaNX721FNPxWeffZb13EaNGkWXLl2ynvt7evToEcXFxVnNHD58eFbzAAAAAAAAAAAAAAAAAAAAAACA8uWhhx5KJHfzzTeP/Pz8rOc6g4xfM3PmzKzkVPTra128tpo3b571M9wiIkpLS+O5557Lei4Rm2yySYwePTpq1KiRdpWs69KlS9x5551p1/hDPpdg3ZKt19CVPIfLlrJ2TiwAAAAAAAAAAABQfmTSLgAAAAAAAAAAAAAAFdm1115b7g8ObdGiRRx++OFp1+A33HrrrVG9evW0a7Aa7Askzb6w6n788cf44osv1vj2lSpVivvvvz/+P3v3HWVVdTZw+J1h6CACAipIJ1gRscXeoqhgF0sMdmNNjF3sJbaoJBoLKggaxY4NjYq9iyIBQZSuRkCp0mYoM/P98S0TNXTOuefOzPOs5UoCc3/7Rffd9w6YfWvUqJHgVPmne/fuceWVV2Y9BgAAAAAAAAAAAAAAAAAAAAAAkKFOnTql0v3mm29i4sSJqbSz8sYbb6TS3XLLLVPpViQdO3aMI488MpX2Z599lkoXlmfkyJExYMCAVNoFBQVx3XXXLfPnzj///GjUqFHia37//fdx/fXXJ96tKirC+daqVatEOj81fvz4NXrc+uuvHwcddFBceOGF0a9fv3jrrbdi5MiRMXHixPj+++9j3rx5MXfu3Jg+fXp88803MXz48HjppZfi7rvvjrPPPjt23333qFOnTsK/GmBV3XzzzVmPsFZydf/vo48+Gptttlnq62SpsLAwHn744ahXr17Wo6yUfbv6Hnvssdh5551zumaubLbZZvHAAw9kPUbOOZfItcmTJ8eMGTNS67dv3z4++eST2GuvvVJbA9J2xhlnZD3CaqtZs2b069cvTj/99Dj88MOzHmeNHHTQQXHooYdmPcYqsUdyL5f7w/uz/NOlS5e48MILsx7jZ8rKylL7s4gjjjgile7ydO/ePdHekiVL4sknn0y0CQAAAAAAAAAAAAAAAAAAAAAAVCyvvfZalJeXJ96tWbNmdOzYMfGuO8j4pQULFsTUqVMTaVX2/VUV99bmm2+eSnf06NExe/bsVNpVWdOmTeOf//xnrLvuulmPkpojjjgiLrvssqzHWCGfS1B1JPkaGuE5nG/y8Z5YAAAAAAAAAAAAoOIozHoAAAAAAAAAAAAAAKisjjzyyPj973+f9RiJKCoqynoElmOjjTaKq666KusxWEXOBXLBubDqxo0bt1aP/+Mf/xjt27dPaJr8dtlll8X222+f9RgAAAAAAAAAAAAAAAAAAAAAAEBGNtlkk1S6H3zwQSrdLL3//vupdDfddNNUuhVFQUFBDBgwIJW78EpLS2PUqFGJd2FlLr300liwYEEq7f322y922mmnn/1Y48aN45xzzkllvcsuuyzmzZuXSruyqyjnW7NmzRLp/KisrCy+/vrrVfragoKC6Nq1a9xxxx3x+eefx9SpU+OZZ56Jm266KU488cTYddddY4sttog2bdpEkyZNol69elG/fv1Yb731okWLFtG5c+fo2rVrnHbaafG3v/0t3njjjZg7d258+OGHcdlll1X511jItYp+t3Eu7v89++yzY//99091jXzRokWL6NWrV9ZjrJR9u3quvfbaOOCAA3K2XhYOPfTQOOmkk7IeI2ecS2Rl6NChqfZbtGgRQ4YMiYcffjg6deqU6lrAf+28885x5513Zj3GWrntttuiRo0aWY9RaVX0PZKL/eH9Wf4pKCiIW265JapVq5b1KP+jX79+UV5ennj38MMPT7y5It26dUu098orr8Ts2bMTbQIAAAAAAAAAAAAAAAAAAAAAABXL9OnT47PPPkulveWWWybacwcZyzJu3LhEOlVlf1W1vbXxxhun0k373uCqqFq1avHss89G69atsx4ldddcc03svvvuWY+xXD6XoOpI6jU0wnM43+TzPbEAAAAAAAAAAABAxVCY9QAAAAAAAAAAAAAAUBk1b9487rvvvqzHoIo444wzYoMNNsh6DFbCuUAuORdWzdpc4l6/fv24/PLLE5wmv1WrVi369+/vUnQAAAAAAAAAAAAAAAAAAAAAAKii2rRpk0p31KhRqXSzlNavqXXr1ql0K4qrrroqfv3rX6fS/vTTT2P+/PmptGFFpk2bFjfddFNq/euuu+5n//uSSy6J+vXrJ77OqFGjol+/fol3q4qKcL4VFBTEeuutl8BE/zVt2rRYsmTJCr+mVatW8ec//zm+/vrreOmll+LMM8+MTTbZJJH1q1WrFttvv31ce+21MXr06Bg2bFiccsopUbNmzUT6QOV2xhlnpNZu3759qu8P8tG5554bG220UdZjVHq5urd67733jksvvTT1dfLBX//61ypxF7hziSy9/vrrqa9RUFAQv/3tb2PEiBHx1ltvxTnnnBMdOnRIfV2o6goKCrIeYa20aNEiTjzxxKzHqNQq8h5Je394f5af9t5779hjjz2yHmOZJk2aFG+++Wbi3RYtWsR2222XeHdZOnbsGO3atUu0+fDDDyfaAwAAAAAAAAAAAAAAAAAAAAAAKqahQ4em0k3yfkt3kLE848aNW+tGVdtfVWlvpfV5V59//nkq3arskksuSe2za/JNQUFB9OvXL2rXrp31KJVWrj6XoKJL4jX0R57D+SWf74kFAAAAAAAAAAAAKobCrAcAAAAAAAAAAAAAgMrouuuui/r162c9BlVErVq14tJLL816DFbCuUAuORdWzdpc4t6zZ89o0KBBgtPkv0022STOOOOMrMcAAAAAAAAAAAAAAAAAAAAAAAAy0Lp161S6o0ePTqWbpTFjxkR5eXni3VatWiXerChOPPHEuOKKK1Lrv/7666m1YWVuueWW+Pbbb1Np77bbbvGb3/wmIiKaN2+e2n1y5557bpSVlaXSruwqyvnWpEmTKCwsTKT1o+nTpy/35zbccMPo06dPjBs3Li699NJo0aJFomsvS5cuXeLee++Nr7/+Os4777yoWbNm6msCFVetWrVSa992221V7gyqVatWXHjhhVmPUenl4t7qhg0bxoABA6KgoCDVdfJF/fr149Zbb816jNQ5l8jSoEGDcrrerrvuGr17946xY8fG9OnT47XXXou//e1vceaZZ0b37t2jU6dOVe5+emD5LrnkkigqKsp6DPJUmvvD+7P8dN1112U9wgr169cvle4RRxyRSveXunXrlmhv4cKF8dxzzyXaBAAAAAAAAAAAAAAAAAAAAAAAKqYRI0ak0m3btm1iLXeQsTzjxo1b60ZV219VaW+l9XlXY8aMSaVbVXXp0iXVz67JR23bto0bbrgh6zEqrVx8LkFlkMRraITncD7K93tiAQAAAAAAAAAAgPxXmPUAAAAAAAAAAAAAAFDZdO7cOXr27Jn1GFQxxx9/fNSrVy/rMVgO5wJZcC6s3JdffrnGjz399NMTnKTiuPLKK6NOnTpZjwEAAAAAAAAAAAAAAAAAAAAAAORY69atU+mOGTMmlW6WFi5cGF9//XXi3Vq1akWzZs0S7+a74447Lu69995U13j88cdT7cOKFBcXR69evVLrX3fddRERccUVV0StWrUS7//zn/+MIUOGJN6tCirS+ZbG68+sWbOW+ePVq1ePCRMmxKmnnhrVq1dPfN2Vadq0adxyyy0xduzY6NatW87XByqONO7+3X333WP//fdPvFsRHHfccVG3bt2sx6j00r63+pZbbokNN9wwtX4+Ovroo6NLly5Zj5Ea55JzKWuTJk2KESNGZLL2euutF3vuuWecffbZcccdd8Tzzz8fI0aMiDlz5sQPP/wQn332WQwePDjuuuuuuPDCC+Ooo46KHXbYIZo3bx4FBQWZzAzk1kYbbVRlXydZubT2h/dn+fv+bNNNN816hBV66qmnYs6cOYl3Dz/88MSby9K9e/dEe88//3wsWLAg0SYAAAAAAAAAAAAAAAAAAAAAAFAxffbZZ6l027Rpk0jHHWT5ewdZPvjyyy/X6vFVdX9Vlb3VsmXLVLpru+/4r4KCgujfv38UFRVlPUrOnXXWWfGrX/0q6zEqrbQ/l6AySOIs8xzOz+dwvt8TCwAAAAAAAAAAAOS/qvdvhwIAAAAAAAAAAACk6K9//WtcffXVWY+xWqrCJda5duutt0ZhYWHWY1DF1K1bN4488sjo169f1qOwDM4FsuBcWLlx48at0eNat24dm2++ecLT/K/i4uKYOHFiTJ48OebOnRsLFy6MJUuWRERE9erVo27dulG/fv3YaKONokOHDlG7du3UZ2rcuHGccsopcdttt6W+FgAAAAAAAAAAAAAAAAAAAAAAkD+aNm2aSvfbb79NpZu1b7/9Nlq1apV4t2nTpvHdd98l3s1XV111VVx55ZWprjF+/Pj49NNPU10DVuYf//hH/OlPf4ouXbok3t5uu+3inHPOiRNPPDHxdmlpaZx33nmJd6uCina+NWrUKJHOT82ePft/fqxTp07xj3/8I2rVqpX4equrZcuWMXjw4Ojfv3+cffbZMW/evKxHAvJMGnf/Xn755Yn2lmfUqFHx2WefxRdffBHffvttzJ8/PxYuXBilpaVRs2bNaNSoUTRq1Cg23njj2GOPPaJNmzapz1S/fv3o2bNn9OnTJ/W1qrI0763ebrvt4oQTTki8WxFcffXVccABB2Q9RiqcS86lfHDPPffEXXfdlfUYP7POOuvE5ptvvtz76pcsWRL//ve/4+uvv46vvvoqJk2aFGPHjv3PX3Pnzs3xxEBaTjjhhHjuueeyHoM8lcb+8P7M+7M1VVJSEo888kicfvrpiXZbtWoVW2+9dQwbNizR7k/Vr18/dt5550SbAwcOTLQHAAAAAAAAAAAAAAAAAAAAAABUXOPGjUulu9FGGyXScQeZO8hWZG33by72l72VnbQ+c2zq1KmpdKuinj17RqdOnXKyVmlpaXz66afxwQcfxJQpU2LmzJkxa9asKCkpiVq1akXDhg2jUaNGseGGG8YOO+wQW2+9dRQVFaU2T7Vq1eLqq6+Oo48+OrU1qrI0P5egskjiPaDnsOcwAAAAAAAAAAAAUDml929hAgAAAAAAAAAAAFRBG264YWy44YZZj0GG9tprr9hzzz1zvu7EiRNjzJgx8dVXX8W8efOipKQkIuI/F7q2a9cuOnfuHI0bN875bJXVokWLYsSIETF69OiYOXNmLFiwIAoKCqJ27dqx3nrrRbt27aJLly5Rr169nM104oknuqw5DzkXqg7nQsWzppe477PPPglP8l9Tp06NPn36xIsvvhjDhg2L8vLyVX5shw4d4je/+U1079499t133ygsLEx0tgULFkT//v1j8ODBiXYBAAAAAAAAAAAAAAAAAAAAAID816hRo8SbJSUlMXfu3MS7+WDatGmpdNP455CPmjRpEv369YsDDjgg9bXuvPPO1NeAVXHOOefEW2+9lUq7d+/eqXTvueeeGDNmTCrtyqqinm+1atVKrPWj4uLin/3v448/Pu69996oXr164mutjRNOOCH22muv+N3vfhfvvPNO1uNAlZZv9/+mcffv3/72t2jatGlsvvnmiXYjIoYNGxZ33XVXvPjii6v9/Uq7du3iggsuiBNPPDHVc/rII4+MPn36pNbPQr7t24j07q3u3bt3FBQUJN5dkblz58aIESNi4sSJMWPGjCguLo7S0tKoU6dONGzYMFq3bh3bbbddrLPOOqnO0b1799h4443jiy++SHWdLDiXKt+5VBENGDAgrrvuumjYsGHWo6yy6tWrR5s2baJNmzbL/PnJkyfHhx9+GB988EG89957MWzYsBxPSFVWWloan3zySXz22Wfx/fffx6JFi6J69epRt27d2GijjaJz587Rvn37rMdcoZkzZ8YHH3wQ48ePj3nz5kVZWVnUrFkzGjZsGO3bt49tt9029df/H3Xr1i0aNmwYs2fPzsl6uWCPJCeN/eH9mfdna6Nv375x+umnJ9494ogjUn0/s88++yS6r+bMmRP//Oc/E+sBAAAAAAAAAAAAAAAAAAAAAAAV23fffRdlZWVRWFiYaLdx48aJdNxB5g6yFRk3btxaPT6t/WVv5Yc07vRdsGBBLFy4MPFuVVSjRo245pprUl/n3XffjVtvvTVee+21mDdv3io/rm7durHXXnvFRRddFDvuuGMqsx155JFx3XXXxahRo1Lp51JV+lyCymJtX0M9hyvXcxgAAAAAAAAAAADgp4qyHgAAAAAAAAAAAAAAKpOzzjorZ2u9++678cADD8TgwYNX+ZL0Ll26xDHHHBPHH398NGrUKOUJK5/y8vJ44YUXon///vHiiy9GSUnJCr++sLAwdt111zjxxBPj6KOPjqKidP8V7l//+tfRqFGjmDVrVqrrsHqcC5Wbc6HimjNnTsyYMWONHrvTTjslPE1EWVlZXHvttXHdddfFkiVL1qgxbty4GDduXNx9993RunXrOPfcc+OMM86IatWqrdVs33zzTdx+++1x3333xQ8//LBWLQAAAAAAAAAAAAAAAAAAAAAAoOKpVatW1K5dO/Huqt6ZVhGl9Wtr3LhxKt18ctBBB8W9994bTZs2TX2tefPmRb9+/VJfB1bF22+/Hc8880wcfPDBWY+ySn744Ye48sorsx6jQqnI51vNmjUTa/3op3cvXnPNNXH55ZcnvkZSWrZsGa+++mocd9xx8eijj2Y9DlQp+Xz/bxp3/z7//PMxePDgOOqoo+Laa6+Ndu3arXXziy++iNNPPz3efPPNNW5MmDAhTjvttLjpppvimWeeiU6dOq31XMuy8847R4MGDSr8Hbj5vG8j0tm7e+21Vyr3Ni/LV199FQ888EAMGjQoRo4cGeXl5Sv8+oKCgthuu+3i97//ffz2t7+NWrVqpTLX6aefHmeffXYq7Sw5lyrHuVTRFRcXx+23316pvgdt3bp1tG7dOo466qiIiPjuu+/ixRdfjOeeey5eeOGFNb6rHlZkwoQJ0bt37xg4cGDMmTNnhV/bunXrOOmkk+KPf/xjrLPOOrkZcCXKy8vjmWeeib///e/x5ptvrvA9QGFhYey1115x9tlnR7du3VKdq3r16vGb3/wmnnjiiVTXyQV7JHlp7A/vz7w/WxuffvppjBgxIrbccstEuz169IiLLroo0eZPHXDAAYn2Bg0a5P0WAAAAAAAAAAAAAAAAAAAAAADwH6WlpTFjxozEP0dgnXXWiWrVqkVpaeladdxB5g6y5ZkzZ07MmDFjrRpJ7y97K3/UqVMnatSokXj3u+++S7xZVZ188snRqlWr1PrDhg2Ls88+O9577701evyCBQviueeei+eeey722GOPuO+++xJ5DfqpgoKCOP/88+P4449PtJsrVfFzCSqLJF5DPYcr/nMYAAAAAAAAAAAAYHnS/Td9AQAAAAAAAAAAAKAK2WCDDaJ79+6pr/Phhx/GeeedF++///5qP/bTTz+NTz/9NK666qq4+OKL44ILLojq1aunMGXlM2TIkDj33HNj1KhRq/yYsrKyePPNN+PNN9+MP//5z9G/f//YcccdU5uxsLAw9t5773jsscdSW4PV41yo3CrruXDuuefGlVdeucZrnnTSSXHhhReu8eOXpX///nHjjTcm2lyyZMkaP3bjjTdOcJL/d+qpp0bfvn0T602ePDn++Mc/Rr9+/eLBBx9cow9EGTp0aNx6663x1FNPrfWHEgEAAAAAAAAAAAAAAAAAAAAAABVXw4YNU+nOnj07lW4+mDVrVirdRo0apdLNBxtvvHH87W9/i65du+ZszZtuuinmzZuXs/Wqgp49e8a2226b9Rj/Y+bMmYnfaZeGCy64ILp161Yh7oX885//HDNmzMh6jAqhMpxvNWvWTKz1ox/vhfz73/8eZ511VuL9pNWoUSMGDhwYG264YfTu3TvrcSolryH8Ur7f/5vWneDl5eXxyCOPxOOPPx4nnnhiXHnlldG8efM1at19991xzjnnxKJFixKZbdKkSbHTTjvFoEGDYu+9906k+VNFRUWx7777Vuh71vN930aks3cvv/zyxFrL8/XXX0evXr3i0UcfjbKyslV+XHl5eXz00Ufx0UcfxZ///Oe45557Et2/5eXlMWTIkBg8eHBizXzjXKrY51JlcdNNN8VJJ50ULVq0yHqUVDRr1ixOOOGEOOGEE2LmzJnx0EMPxX333RejR4/OejQqgQULFsSll14ad9xxxyp/5sDkyZPj8ssvj9tvvz0GDBgQ+++/f8pTrtinn34av//972PYsGGr9PVlZWUxZMiQGDJkSOy7777x4IMPRpMmTVKbb++9944nnngitX7a7JF090ga+8P7M+/P1kbfvn3j73//e6LNNm3axFZbbRXDhw9PtPuj/fbbL9HewIEDE+0BAAAAAAAAAAAAAAAAAAAAAAAV33fffRdNmzZNvNuoUaOYPn36WnfcQbZ6d5Cde+65ceWVV67xmieddFJceOGFa/z4Zenfv3/id97/+JkPayup/VUV9lZFsu6666bSrcyfOZZrf/jDH1Jr9+vXL84444xYvHhxIr033ngjtt122xg0aFDsvvvuiTR/1KNHj/jDH/5Q4T5HrLJ+LoHX0FXnOfz/KupzGAAAAAAAAAAAAGBFirIeAAAAAAAAAAAAAAAqi5NOOimKitL7V3RLS0ujV69eccstt0R5eflatebNmxeXXnppPPHEE/HUU09F27ZtE5qy8lm0aFGceeaZ0a9fv7XqjB07Nnbdddfo379/9OzZM6Hp/lfXrl0r7aX0FZFzoXKq7OfC1KlTY+rUqWu83nfffbfGj12emTNnxtixYxPvrqlf/epXifZef/316Nu3b6LNH40YMSJ22mmnePrpp+M3v/nNSr++tLQ0nn766ejdu3d88MEHqcwEAAAAAAAAAAAAAAAAAAAAAABULLVq1UqlW1JSkko3HxQXF6fSrVmzZirdLDVp0iSuuOKKOO2001K9v++XpkyZEr17987ZelVF9+7do3v37lmP8T/eeeeduPHGG7MeY6XGjx8fd911V5x99tlZj7JCkyZNittvvz3rMfJeZTrf0nj9KS0tjYsvvjjOOuusxNtpKSgoiFtvvTUaNmwYl19+edbjVDpeQ/hRRbr/N807wUtLS+O+++6LBx98MM4444y45JJLYr311lvlx99www1xySWXJD7X/Pnz44gjjojPPvssWrRokXh/p512qpD3rFekfRuR7N7ddNNNY7fddkuktTx9+vSJc889d62/1540aVLss88+cc0116z1a/m8efNiwIABcccdd+TV/dlpci6RpeLi4jj//PPj0UcfzXqU1DVu3DjOPvvsOPvss+P555+Pa665Jj755JOsx6KCGjVqVBx66KExbty4NXr89OnTo3v37jFgwIA49thjE55u1fTu3TsuvPDCKC0tXaPHv/TSS7HTTjvFm2++GRtuuGHC0/2/VfkciHxlj6S/R9LcH96fVR5z586Nd955J959990YM2ZMjB8/PmbPnh3z58+PpUuXLvdxa/JnrQ8//HDccsstif+eb48ePWL48OGJNiMitt1222jatGlive+++y7eeOONxHoAAAAAAAAAAAAAAAAAAAAAAEDlsHDhwlS6derUSbTnDrJVM3Xq1Jg6deoar/fdd9+t8WOXZ+bMmXl/l/Ha7K+qsrcqkrQ+c2zRokWpdKuaXXfdNTbeeONU2r169UrlMzZmz54de++9d7z22mux6667JtatU6dOHH300XHvvfcm1kxTZf9cAq+hq8Zz+L8q2nN4ZXJ5TywAAAAAAAAAAACQvwqzHgAAAAAAAAAAAAAAKoOCgoI45ZRTUusvWrQoDjzwwLj55pujvLw8se6//vWv2H777ePjjz9OrFmZzJkzJ/bZZ5+1vqj5R6WlpXH88cfHiy++mEhvWbbZZpvU2qwe50Ll5FygoKAg1l133USb/fv3T7T3S/Pnz4/u3bvHsGHDlvs1c+fOjd69e0e7du2iR48e8cEHH6Q6EwAAAAAAAAAAAAAAAAAAAAAAUHHUqFEjlW5JSUkq3XywaNGiVLpp/bPIQt26dePyyy+PCRMmxFlnnRVFRUU5Xf+0006L4uLinK5JdiZMmJD1CKvs6quvjtmzZ2c9xgpdeOGFsXjx4qzHyFuV8XyrWbNmor2IiK5du8YNN9yQeDcXLrvssjjppJOyHoMcqUivIZVBRbv/Nxd3/y5atCj++te/Rps2beKKK66IuXPnrvQx9957b1xyySWpzTRnzpw4/vjjU2lvvfXWqXTTVNH2bUSye/e0005LrPVLpaWlccIJJ8Tpp5+e6PubK664Is4+++w1euwXX3wRZ555Zmy44Ybxxz/+McaOHZvYXBWFc4msPPbYY/HQQw9lPUZOHXDAAfHxxx/HM888Ey1btsx6HCqY119/PXbYYYcYN27cWnXKy8vjpJNOivfffz+hyVZNaWlp/P73v4/zzjsvSktL16o1bty4OOSQQ2Lp0qUJTfdzbdq0iQYNGqTSTpM98l9p7pFc7A/vzyqmkpKSeOihh2KfffaJhg0bRvfu3ePGG2+MZ599NkaPHh1TpkyJuXPnxsKFC5f7V1lZ2WqvO3v27Hj66acT//X06NEj8WZERPfu3RPtPf7442v09w0AAAAAAAAAAAAAAAAAAAAAAKjc0voMnbQ+Z8YdZKRpdfeXvZWfqlevnko3rc/lqmrSut/9wQcfjBtvvDGVdkTE0qVL47e//W3MmjUr0W5az/GkVfXPJeC/PId/rqI8h5cnq3tiAQAAAAAAAAAAgPxVmPUAAAAAAAAAAAAAAFAZbLXVVtGyZctU2mVlZdGjR4/ULvidMWNGdO3aNUaNGpVKv6JavHhxHHDAAfH2228n2i0rK4uTTjop5s2bl2j3R5tssklqHx7B6nEuVD7OBSIi6tatm3jzyy+/TLz5S4sWLYpDDjkkfvjhh5/9+MSJE+Pss8+O5s2bx3nnnRdfffVV6rMAAAAAAAAAAAAAAAAAAAAAAAAVS1p3WS1atCiVbj4oKSlJpVsZ7hUrKiqKM844IyZOnBjXXHNN1K9fP+czPPjgg/H888/nfF2yM27cuKxHWGWzZ8+Oa665Jusxluu9996LJ598Musx8lJlPt+qVauWeLNNmzaJN3OpT58+seeee2Y9BjlQkV5DKrqKeP9vLu/+nT9/flx77bXRpk2buOWWW5b7Pcfw4cPjj3/8Y+rzvPbaa/HJJ58k3u3cuXMUFhYm3k1LRdy3Ecnt3cLCwjjyyCMTmOh/lZeXx9FHHx0DBgxIpX/77bfHX/7yl1X62rKysnjuuedi7733jk022STuuuuumD9/fipzVSTOJbJw2mmn5eRe93xz0EEHxeeffx7nn39+FBQUZD0OFcB7770X3bp1S+z1aunSpXHGGWdEeXl5Ir1Vcdppp8V9992XWG/o0KFx7733Jtb7pS222CK1dhrskf+V5h7J1f7w/qxiWLx4cdxxxx3Rpk2b6NmzZwwZMiTKyspyOkPfvn0Tb7Zv3z46deqUeLd79+6J9gYOHJhoDwAAAAAAAAAAAAAAAAAAAAAAqBwq6ufMuIOMNK3K/rK38pfPHMtfNWvWjIMOOijx7r/+9a845ZRTEu/+0rfffhvnnHNOos3tt98+GjVqlGgzaVX9cwn4L8/h/1URnsPLkg/3xAIAAAAAAAAAAAD5qXL+Pw0AAAAAAAAAAAAAIMf22muv1NpXXHFFPP/886n1IyJmz54dBxxwQMyZMyfVdSqS0047Ld59991U2tOmTYsrr7wylXZRUVFsttlmqbRZPc6Fyse5QEREnTp1Em+mdYH/L33zzTdx3XXXRUTEu+++G4cccki0b98+br/99pg/f35OZgAAAAAAAAAAAAAAAAAAAAAAACqe6tWrp9JdunRpKt18kNavrUaNGql0c+WII46IL774Iu68885o2rRpJjOMGDEiTjvttEzWJjsTJkzIeoTVcscdd8T48eOzHuN/lJeXxznnnJP1GHnJ+Vb1FBUVxaBBg6Jt27ZZj0LKKtprSEVWEe//zeLu31mzZsUFF1wQ7dq1iz59+vzse4/S0tLo2bNnLFq0KCez3HnnnYk369SpExtttFHi3bRUxH0bkdze3XXXXVN779OrV6944oknUmn/6OKLL17hP7/Zs2fHLbfcEu3atYuDDjooXn311VTnqaicS+TSggULYt99942pU6dmPUrO1a1bN26++eYYMmRINGnSJOtxyGPTpk2Lgw46KEpKShLtjhgxIh5++OFEm8tz5513Rt++fRPvXnXVVal9LsOWW26ZSjcN9sjypbVHcr0/vD/LX+PGjYvtt98+/vCHP8S0adMym+O1116LyZMnJ97t0aNHor31118/ttpqq8R6kydPjg8//DCxHgAAAAAAAAAAAAAAAAAAAAAAUHlU9M+ZcQcZaVre/rK38pvPHMtfe+yxR9SpUyfx7nnnnReLFy9OvLssAwcOTPSe6MLCwth7770T66Whqn8uAf/lOfy/KsJz+Jfy5Z5YAAAAAAAAAAAAID8VZj0AAAAAAAAAAAAAAFQGaV1aOnTo0Lj++utTaf/S5MmT49RTT83JWvnu+eefj/79+6e6xt///veYPn16Ku22bdum0mX1OBcqF+cCaWrcuHHO1rrttttim222iV122SWeeeaZKC8vz9naAAAAAAAAAAAAAAAAAAAAAAAAVUVadzwVFBSk0k3bXnvtFcOGDYvHHnss2rVrl9kcU6dOjYMOOiiKi4szm4FsTJgwIesRVsvSpUvjggsuyHqM/zFw4MD4+OOPsx4jrzjfqrYGDRpEv379sh6DlFW015CKqiLf/5vV3b9TpkyJ008/PTp27BgPPfRQlJWVxb333hujR4/O2QzPPfdcKt0WLVqk0k1aRd63Ecns3QMPPDCBSf7Xe++9F3/5y19Saf9UeXl5HHvssVFSUvKzHx85cmScfPLJseGGG8YFF1wQkydPTn2WysC5RK5Mnjw59t5775g5c2bWo2Rir732iuHDh0eXLl2yHoU8dcYZZ6T2/MjF6/NXX32V2u+LTZ8+PR544IFU2m3atEmlmwZ7ZPnS2iNZ7Q/vz/LLyy+/HFtttVX861//ynqUiIhUvp/t0aNHor39998/0T8bffTRRxNrAQAAAAAAAAAAAAAAAAAAAAAAlUtl+ZwZd5CRpl/uL3sL1kz37t0Tb7766qvx+uuvJ95dnqVLl0afPn0Sbe6///6J9pLkcwn4Kc/hZcvn5/Av5ds9sQAAAAAAAAAAAED+Kcx6AAAAAAAAAAAAAACo6GrUqBE777xzKu0zzzwztQ8YWJbHH388XnrppZytl49KSkritNNOS32dpUuXxmOPPZZKu3nz5ql0WXXOhcrFucBPLV68OPHmrrvumnhzeRYvXhzDhg3L2XoAAAAAAAAAAAAAAAAAAAAAAABUXVtttVW88sor8eqrr0aXLl0ynWX27Nmxzz77xFdffZXpHGRjwoQJWY+w2p555pl4++23sx7jP4qLi+Piiy/Oeoy84XzjR7vvvnuccsopWY9Biiria0hFU9Hv/8367t+JEydGz549o1OnTnH55ZfndO1Zs2bFxIkTE+9utNFGiTeTVtH3bUQye3fPPfdMYJKfKy8vz+ld7JMmTYo777wzli5dGk888UTssssuseWWW0a/fv2ipKQkJzNUNs4lcmH06NGx4447pvLPuyJo3rx5vPHGG7HjjjtmPQp55qOPPoqnn346tf5nn30W48aNS60fEXHllVdGcXFxav3HH388le6GG26YSjdp9sjKpbFHst4f3p9l76WXXooDDzwwFixYkPUo/9G/f/8oKytLtNmxY8fYbLPNEut17949sVZExMCBAxPtAQAAAAAAAAAAAAAAAAAAAAAA5Ct3kJGmH/eXvQVrZr/99ku8+ec//znx5so88cQTifby9b5ln0vAL3kOL1u+Pod/KR/viQUAAAAAAAAAAADyT2HWAwAAAAAAAAAAAABARbfDDjtE7dq1E+++9NJL8cknnyTeXZmLL74452vmk/vvvz+mTJmSk7UefPDBVLotWrRIpcuqcy5ULs4FfmrhwoWJN88+++xo2LBh4l0AAAAAAAAAAAAAAAAAAAAAAADIQps2bWLgwIExbNiw2HvvvbMeJ2bMmBG/+c1vYtSoUVmPQgZmz54ds2fPznqMNXLuuedGeXl51mNERETv3r3j3//+d9ZjZM75xrLccsst0bx586zHIAUV+TWkIqno9//my92/o0ePjpkzZ+Z83Y8//jjxZkU4Uyv6vo1Y+73bqFGj6NSpU0LT/Ndzzz0XI0aMSLy7Itdcc020atUqjjjiiHj33XdzunZl5lwibWPHjo1f//rX8c4772Q9SibWWWedeOWVV2KnnXbKehTyyK233pr6Gk8++WRq7e+//z4efvjh1PoREe+88058//33iXc33HDDxJtpsEdWLo09ki/7w/uzbHz22WdxyCGHxOLFi7Me5We++eabePXVVxPv9ujRI5FO9erVE/09+M8//zw+++yzxHoAAAAAAAAAAAAAAAAAAAAAAAAVgTvISJO9BauvcePG0bZt20SbU6dOjbfffjvR5qoYM2ZMzJ07N7Feu3bton79+on1kuJzCfgpz+Hly9fn8E/l6z2xAAAAAAAAAAAAQP4pzHoAAAAAAAAAAAAAAKjoNttss1S6t99+eyrdlRkxYkS89NJLmaydtfLy8rjllltytt7HH38c8+bNS7zbrFmzxJusHudC5eFc4JcWL14cxcXFiTabNWsWL730Umy44YaJdgEAAAAAAAAAAAAAAAAAAAAAACCXmjRpEn//+9/jyy+/jKOPPjoKCgqyHim+/fbb2GWXXeLTTz/NehQyMmHChKxHWGPDhg2Lhx9+OOsxYtq0aXHDDTdkPUamnG+syDrrrBM33XRT1mOQgor8GlJRVIb7f6v63b9TpkxJvFm3bt3Em0mqDPs2Yu337jbbbJPKe6I+ffok3lyZuXPnprKXyUZVPJeqsunTp8fuu+8el156aSxdujTrcXKubt268eyzz0a7du2yHoU8MGfOnHj22WdTX+edd95JrT1w4MDUn8vl5eXx/vvvJ95t2rRp4s2k2SOrJo09UhH2R5qq8vuz+fPnx+GHHx4lJSVZj7JMffv2TbzZo0ePRDq77bZb1KtXL5FWROTFn7UAAAAAAAAAAAAAAAAAAAAAAABUFVX5DjLSZW9R0XXp0iXx5qBBg6K8vDzx7qr4+OOPE2sVFBREp06dEuslwecS8Euew8uXj8/hn8r3e2IBAAAAAAAAAACA/FKY9QAAAAAAAAAAAAAAUNF17Ngx8eb06dPjlVdeSby7qvr27ZvZ2lkaPnx4TJo0KadrjhgxIvFm7dq1E2+yepwLlYdzgWWZPHly4s3tttsuPv/887j++uujffv2ifcBAAAAAAAAAAAAAAAAAAAAAAAgLXXr1o0rrrgiJk6cGGeddVZUr14965EiImLYsGGx7bbbxhdffJH1KGRowoQJWY+wVnr16hXFxcWZznDppZfGggULMp0hK863/FRSUhKzZs2K7777LmbMmJEX+/Poo4+OzTbbLOsxSFhFfw2pCCrD/b9V/e7f2bNnJ97M97+nlWHfRqz93+cuXbokNMl/ZX0XO5VDVTyXqrqysrK4/vrrY7vttov33nsv63FyrnHjxvHCCy9E/fr1sx6FjA0ZMiQWL16c+jqjR49Orf3cc8+l1v6pUaNGJd6sVatW4s2k2SOrLuk9UhH2R5qq8vuzK664IsaOHZv1GMv1zDPPxMyZMxNtbrrpprHxxhuvdad79+4JTPNfjz76aKI9AAAAAAAAAAAAAAAAAAAAAAAAlq8q30FGuuwtKro07nd/+umnE2+uqqTv8OzcuXOivbXlcwn4Jc/hFcu35/BP5fs9sQAAAAAAAAAAAEB+Kcx6AAAAAAAAAAAAAACo6H71q18l3nzppZeitLQ08e6qGjx4cBQXF2e2flZefPHFnK/5r3/9K/FmrVq1Em+yepwLlYdzgWUZP358Kt0GDRpEr169Yty4cTF27Nh46KGH4vzzz49DDjkktthii6hTp04q6wIAAAAAAAAAAAAAAAAAAAAAAJCsgoKCVLrl5eWpdNdUUVFRnHnmmTFx4sS4+uqro169elmP9B+PPvpo7LzzzjF16tSsRyFjad0flyv//ve/49Zbb81s/ZEjR0b//v0zWz8rzrf88d1330X//v3jhBNOiM6dO0eDBg2idu3a0bhx41h//fWjSZMmUa9evahTp05svPHGceSRR8Ztt92W8+d+YWFhXHjhhTldk/RV9NeQiqAy3P9b1e/+/eGHHxJv1q5dO/FmkirDvo1Y+7275ZZbJjTJf7366qtRVlaWeJeqpSqeS/y/4cOHx8477xxHHnlkjBs3Lutxcqpjx45x2223ZT0GGXvttddyss7XX38d8+fPT7y7aNGieO+99xLvLsuoUaMSb1aE7wvskVWX9B6pCPsjTVX1/dk333wTd911V9ZjrNCSJUvioYceSrx7+OGHr3WjW7duCUzy/4YOHRoTJ05MrAcAAAAAAAAAAAAAAAAAAAAAAFQ+VeVzZnKlqt5BRvrsrVWX1vmT1nlZVXTp0iXx5scff5x4c1XNnDkz0V7btm0T7a0tn0vAL3kOr1i+PYd/VBHuiQUAAAAAAAAAAADyS2HWAwAAAAAAAAAAAABARdexY8fEm6+99lrizdWxaNGieOuttzKdIQtvv/12ztccP3584k2XNWfPuVB5OBdYlo8++ij1NTp06BDHHHNM3HzzzTFo0KAYOXJkLFiwIKZOnRrvvPNODBgwIC699NI46qijYptttomGDRumPhMAAAAAAAAAAAAAAAAAAAAAAFA1LVmyJJVuUVFRKt18UK1atVS6JSUlqXTXxP777x+jRo2KO+64I5o2bZr1OP9RUlISp556ahx99NF59feL7KRxx1+u3XjjjTFt2rRM1j7nnHOivLw8k7Wz4nzLD0OGDIn9998/NthggzjxxBNjwIABMWLEiJg7d+4yv764uDi+/PLLePzxx+NPf/pTdOjQIbbbbrv4xz/+EaWlpTmZ+aijjopmzZrlZC1yozK8huS7ynD/b1W8+7devXqxxRZbxIEHHhg77LBD4v2aNWsm3kxSZdi3EWu/d9u1a5fQJP/1+uuvJ96kaqjq5xI/9/jjj0fHjh3j0EMPzcmd8vnihBNOiAMOOCDrMcjQ8OHDc7bW5MmTE2+OGTMmFi9enHh3WSZNmpR4syJ8X2CPrLqk90hF2B9J8/4s4oYbbohFixZlPcZK9e3bN/HmEUccsVaP79ChQ7Rv3z6haSIGDhyYWAsAAAAAAAAAAAAAAAAAAAAAAKicqlevnkp34cKFqXTzkTvISIu9tWbS+lyTtD6Xq6po1apVor2vvvpquZ/jkgtz5sxJtNe8efNEe2vL5xLwS57DK5Zvz+EfVZR7YgEAAAAAAAAAAID8UZT1AAAAAAAAAAAAAABQkVWvXj3xy1wjIj799NPEm6vr/fffj3333TfrMXJqzJgxOV/zhx9+SLyZ1odSsGqcC5WLc4Flee+99zJbe/3114/1118/dt555//5udmzZ8eECRNi/Pjx//lr3LhxMWbMmJg9e3YG0wIAAAAAAAAAAAAAAAAAAAAAAJXB4sWLU+nWrFkzlW4+qFGjRirdkpKSVLqrY4MNNoh77rknDjjggKxH+R8jRoyI3/3udzFq1KisRyGPTJgwIesR1tqCBQvisssui759++Z03eeffz5ef/31nK6ZJedb/th9993jrbfeWuvOxx9/HMcee2xcd911cdddd8Wee+6ZwHTLV6NGjTjmmGOid+/eqa5D7lSG15B8Vxnu/62Md/8WFRVFq1atok2bNtG2bdto27ZttGnT5j//u3HjxlmPmKnKsG8j1n7vtm3bNqFJ/utf//pX4k0qB+cSq6u8vDyefvrpePrpp2OzzTaLY489Nn73u9/FhhtumPVoqfr73/8eL7/8cmq/n0t++/zzz3O21rx58xJvjh49OvHm8qQxf0X4vsAeWXVJz18R9sfq8v5sxUpLS+OJJ57IeoxVMmrUqPj4449j2223Tay5xRZbxK9+9asYO3bsGj2+e/fuic1SVlYWjz/+eGI9AAAAAAAAAAAAAAAAAAAAAACgcqpVq1Yq3eLi4lS6WXAHGWmxt9KR1udcVebPHMuFjTbaKNHeyJEjE+2trjlz5iTaa9GiRaK9teVzCfglz+EVy7fncETFuicWAAAAAAAAAAAAyB9FWQ8AAAAAAAAAAAAAABVZgwYNorCwMNFmaWlpfPHFF4k218SIESOyHiGnFi5cGP/+979zvu7cuXNzvibpci5UHs4Fluedd96JWbNmRaNGjbIe5WcaNmwY22yzTWyzzTb/83PTpk2L4cOHxzvvvBPvvPNOfPDBB1FaWprBlAAAAAAAAAAAAAAAAAAAAAAAQEWzePHiVLq1atVKpZsPatSokUq3pKQkle6q6tmzZ/z973+PBg0aZDrHLy1dujRuvPHGuPrqq2Pp0qVZj0OemTBhQtYjJOL++++PP/7xj9GpU6ecrLd06dI4//zzc7JWPnC+5Y++ffvGW2+9lWjzyy+/jL322ivOPffc+Mtf/hLVqlVLtP9Txx57bPTu3Tu1PrlVWV5D8pX7f7O1wQYbRJs2baJt27b/85/NmzdP/J7tysK+/X81a9aMxo0bJ979/PPPE29ScTiXSMvo0aPjoosuiosuuii23nrr2HfffWP//fePbbfdNqpXr571eIlq1apVnHnmmfHXv/4161HIsR9++CHmz5+fs/XmzZuXeDOX77HSmD/f2SOrpyrukWXx/mzNvfPOOzFjxoysx1hlffv2jW233TbR5uGHHx7XX3/9Gj22e/fuic3x1ltvxdSpUxPrAQAAAAAAAAAAAAAAAAAAAAAAlVNan6FTXFycSjct7iAjLfZW7qX1OVdpfS5XVVCtWrVYf/31E21uvPHG8cgjjyTaXB2tWrVKtNe8efNEe2vD5xLwS57DK5dPz+EfVbR7YgEAAAAAAAAAAID8UJT1AAAAAAAAAAAAAABQkdWrVy/x5rRp02LJkiWJd1fXhAkTsh4hp6ZNm5bJui5rrnycC5WHc4HlKS0tjaeeeipOOeWUrEdZZeuvv37st99+sd9++0VExOzZs2Pw4MExcODAePnll6O8vDzjCQEAAAAAAAAAAAAAAAAAAAAAgHxVUlKSSrdWrVqpdPPBOuusk0q3uLg4le7K1K5dO+666644/vjjM1l/RT788MM49dRTY+TIkVmPQh4qLi6OKVOmZD1GIsrLy+Pcc8+NV199NSfr3X333TF27NicrJUl51t+ufDCC+Pmm29Ord+7d+/44osvYtCgQVGzZs1U1thyyy2jVatW8dVXX6XSJ3cq02tIvnL/b7pq1KgRHTp0iF/96lfRtm3baNu2bbRp0ybatm0brVq1qtTfj6XJvv1/6623XuLNmTNnxsKFCxPvkj+cS+SDYcOGxbBhw+K6666LmjVrRufOnWP77bePbbbZJn71q19Fx44dY9111816zLVy2WWXRZ8+fTL7fUSykev3KPPmzUu8OXXq1MSby5PG/PnOHlk9VWWPeH+WnhdffDHrEVbLI488En/961+jTp06iTV79OgR119//Wo/rn79+rHLLrskNsfAgQMTawEAAAAAAAAAAAAAAAAAAAAAAJVX7dq1U+nm2/2Q7iAjLfZW/knrM8fS+qyPqmCDDTaIwsLCRJsdOnSIDh06JNrMUlqf+7YmfC4Bv+Q5vHL59Bz+UUW7JxYAAAAAAAAAAADID0VZDwAAAAAAAAAAAAAAFVndunUTb2Z1afAvffvtt1mPkFPz58/PZN3Fixdnsi7pcS5UHs4FVuS2226LU045Jesx1ljDhg2jZ8+e0bNnz5g8eXLccccdcdddd+XdBxABAAAAAAAAAAAAAAAAAAAAAADZmz17dirdhg0bptLNB40aNUqlW1JSkkp3RTbccMN44YUXonPnzjlfe0VmzpwZvXr1ivvuuy/rUchjEydOzHqERL322mvx4osvxv7775/qOnPmzImrrroq1TXygfNt1S1ZsiT1NS655JK4+eabU1/nxRdfjEMPPTSee+65qFatWipr7LffftGnT59U2uROZXsNyUfu/03WlltuGbvsskvsuOOOse2220bbtm2jsLAw67EqHfv2/zVu3Djx5tSpUxNvki3nEvlu0aJF8dFHH8VHH330sx9v0qRJtGnTJlq1ahUtW7aMVq1a/ee/t2zZMrXf90tKo0aN4phjjom+fftmPQo5NG/evJyul8bvE+Ty15CL3+fIN/bI6qmse8T7s9wZOXJk1iOslnnz5sVTTz0VPXv2TKzZuXPnaNeuXUyYMGG1Hrf33ntH9erVE5lhyZIl8dRTTyXSAgAAAAAAAAAAAAAAAAAAAAAAKremTZum0i0uLk6lu6rcQUaazjrrLHsrj6X1OVfrrrtuKt2qYJ111sl6hLxXq1atrEf4D59LwC95Dq9cPj2Hf1TR7okFAAAAAAAAAAAA8kNR1gMAAAAAAAAAAAAAVCbHHXdcPPnkk1mPsVq+//77qFu3btZjVFj16tVLvDl37tzEm2tizpw5WY+QUwsWLMh6BCoJ50Ll4VxgRUaPHh3PP/98HHDAAVmPstZat24dt9xyS1xwwQVx7bXXxl133RXl5eVZjwUAAAAAAAAAAAAAAAAAAAAAAOSJkpKSKC4ujtq1ayfa3WCDDRLtJaFVq1Zx0kknxRVXXLFWnfXWWy+hiX5u1qxZqXSXZ/PNN49//vOf0aJFi5yuuyJLliyJO+64I66++ur44Ycfsh6HPDdhwoSsR0jceeedF/vss08UFRWltsY111yT8/Mm15xvq2fRokWp9h977LG44YYbUl3jp1588cXo1atX/OUvf0mlv/vuu0efPn1SaZM7lfE1JN+4/3ft7b777nHMMcfE/vvvHxtuuGHW41QJ9u3/q1+/fuLN2bNnJ94k95xLVAbTp0+P6dOnx9ChQ5f58/Xq1YuNNtooWrZsGa1atYpWrVr957+3bNkymjdvnur37KvirLPOir59+2Y6A7lVUlKS9QhrrTL8GvJZZfj7Wxl+DVnw/iwbo0ePznqE1da3b9/o2bNnos3DDz88brrpptV6TPfu3RNb/+WXX/a9JgAAAAAAAAAAAAAAAAAAAAAAsFKFhYXRpEmTxLtz586N0tLSxLsr4w4y0mR/VRzFxcVRWloa1apVS7TbtGnTRHtVSdKf/1YZ5dPfI59LwC/l0/7MV/n496gi3hMLAAAAAAAAAAAAZK8o6wEAAAAAAAAAAAAAKpOSkpJYuHBh1mOslvLy8qxHqNDq1auXeLOkpCTx5ppatGhR1KxZM+sxcmLx4sVZj0Al4VyoPJwLrMy5554bXbt2jRo1amQ9SiKaNWsWd9xxRxx33HFx4oknxqhRo7IeCQAAAAAAAAAAAAAAAAAAAAAAyBOzZs2K5s2bJ9qsWbNmrLPOOjF37txEu2tq8803j1deeSU22GCDqF69evTq1WuNWxtttFGCk/3XlClTUukuS+fOneO1116LRo0a5WzNlXnqqafi4osvjvHjx2c9ChVEZdwrX3zxRdx3331x+umnp9KfMGFC3HHHHam084XzbfUtWrQotfZ3332X2n5ekZtvvjkOPvjg2HHHHRNvb7fddok3yb18fT5WJu7/XTP169eP008/PU4//fRo3bp11uNUOfbt/0vjTuY032+QLucSVc38+fNjzJgxMWbMmGX+fGFhYbRq1So6deoUW221Vey6666x2267RWFhYc5m3HLLLWOzzTaL0aNH52xNsrV06dKsR1hrleHXkM8qw9/fyvBryBXvz7K1YMGC+Pe//531GKvt7bffjvHjx0f79u0Ta/bo0SNuuumm1XrM/vvvn9j6AwcOTKwFAAAAAAAAAAAAAAAAAAAAAABUXk2bNk3l3shvvvkm8ebyuIOMNNlfFde0adMS/8yxddZZJ2rUqOHO9jVQu3btrEfIewUFBVG9evVYsmRJ1qPY4/wPz+GVy6fncETFvScWAAAAAAAAAAAAyF7y/08jAAAAAAAAAAAAAKhCatasmXiztLQ08eaaypcLWHOhvLw86xGoJJwLlYdzgZUZP358XHXVVVmPkbhtt902hg4dGscdd1zWowAAAAAAAAAAAAAAAAAAAAAAAHni+++/T6XbokWLVLqra6eddop33nknNthgg4iIuPjii+Pcc89d417r1q0TmuznpkyZkkr3lzp16hSvvfZaNGrUKCfrrcy7774bO+ywQxx++OExfvz4rMehAqms++WKK66IuXPnptK+4IILKvXdk863NbNo0aLU2ldddVXMnj07tf6K/OlPf0ql26ZNm1hnnXVSaZM7+fycrCzc/7t6atWqFVdccUV88803cdNNN6X2PQcrZt/+vxo1aiTeXLx4ceJN0uVcgmUrKyuLSZMmxbPPPhtXXXVV7LnnntG8efM455xzYurUqTmb48ADD8zZWgDkB+/P8sOsWbOyHmGN9evXL9He1ltvvVr7cJtttolmzZolsvbChQvj2WefTaQFAAAAAAAAAAAAAAAAAAAAAABUbm3btk2l++9//zuV7k+5g4w02V8VX1qfddW0adNUupVd7dq1sx6hQqhevXrWI0SEzyXgf3kOr5p8eQ5HVOx7YgEAAAAAAAAAAIBsFWU9AAAAAAAAAAAAAAAAAFRUN9xwQ+y2227RtWvXrEdJVO3atWPAgAGxySabxMUXX5z1OAAAAAAAAAAAAAAAAAAAAAAAQMYmT54cW221VeLdjTfeOD7//PPEu6ujW7du8cQTT0Tt2rV/9uO33HJLTJ8+Pf7xj3+sVq9u3brRrFmzJEeMiIiFCxfG3LlzE+/+UosWLeKf//xnNGrUKPW1VmbMmDFx0UUXxfPPP5/1KKyi4447Lp588smsx/iPRYsWZT1CKmbMmBFjx46NbbbZJvH2e++9l3gzXzjf1lxaz6Xp06fH/fffn0p7VXz88cfxxhtvxB577JF4u0OHDjFs2LDEu5WZ1xBYvm7dusVdd90VLVu2zHoUiIiIatWqJd4sKytLvEl6nEuweqZNmxZ/+9vf4t57740LL7wwLrnkkqhevXqqax500EFxww03pLoGAPnD+7P8MW/evKxHWGMDBgyIP//5z4l+z3f44YfHLbfcskpf271798TWff7552PhwoWJ9QAAAAAAAAAAAAAAAAAAAAAAgMpr8803T6X7zTffpNL9kTvISJP9VTlMmTIllW779u3j3//+dyrtyiztO4mBdHkOVzwV+Z5YAAAAAAAAAAAAIFuFWQ8AAAAAAAAAAAAAAAAAFVmPHj1i2LBhWY+Riosuuihuv/32rMcAAAAAAAAAAAAAAAAAAAAAAAAyNnny5FS6m222WSrdVXXsscfGM888E7Vr1/6fnysoKIj7778/unXrtlrNLbbYIgoKCpIa8T++/fbbxJu/VKdOnXjxxRdjww03TH2tFZkyZUqcfPLJsfnmm8fzzz+f6SysnpKSkli4cGHe/FVaWpr13xLyhPNt7SxcuDCV7qOPPhqLFy9Opb2qBgwYkEq3Xbt2qXQrM68h8L9q1qwZd955ZwwePDhatmyZ9TgAziVYSwsXLoyrrroq9t5775g9e3aqa2299dZRq1atVNcAIHven+Wf+fPnZz3CGps2bVr885//TLTZo0ePVf7a1f0z2RUZOHBgYi0AAAAAAAAAAAAAAAAAAAAAAKBy22KLLVLpfvPNN6l03UFGmuyvymXKlCmpdDt27JhKFwCSVJHviQUAAAAAAAAAAACyVZj1AAAAAAAAAAAAAADAzxUUFGQ9wn/k0yxQleXTczGfZoF8MW/evOjatWt8/PHHWY+Sij/84Q9x8cUXZz0GAAAAAAAAAAAAAAAAAAAAAACQoUmTJqXS3WKLLVLprorzzjsvBgwYEEVFRcv9mqKionjiiSdip512WuXulltumcR4/2Py5MmpdH+qT58+mf4zmTt3blxyySXRvn376NevX5SVlWU2C1C5ON/WzvTp01PpDh48OJXu6vjnP/+ZSrdZs2apdIGqo2HDhvHaa6/FGWeckfUoABHhXIIkvfXWW7HTTjvFDz/8kNoaRUVF0blz59T6AGTP+7P8VFxcnPUIa6Vv376J9rbbbrto2bLlSr+uWbNmsfXWWyey5pw5c1L7fV8AAAAAAAAAAAAAAAAAAAAAAKDySeoOpF+aOHFi4k13kJEm+6vy+fbbb1PpduzYMZUuACSpot8TCwAAAAAAAAAAAGSnMOsBAAAAAAAAAAAAAKAiKykpSbxZVFSUeHNNVa9ePesRoMJxLkDVNHPmzNhtt91i0KBBWY+Siuuvvz66d++e9RgAAAAAAAAAAAAAAAAAAAAAAEBGxowZk0p3hx12SKW7MjfddFPccsstUVBQsNKvrV27dgwePDg233zzVWrvvPPOazveMo0YMSKV7o+OO+646NmzZ6prLM/ixYvjtttui7Zt28YNN9wQxcXFmcwBVE7Ot7X33XffpdL94IMPUumujunTp8e4ceMS7zZt2jTxJlB1NG7cON59993Yaaedsh4FICKcS5CGMWPGxDHHHBPl5eWprbHNNtuk1gYgW96f5a80X9tzYfDgwYn/fvBhhx220q/Zf//9V+nPbVfFU089FUuWLEmkBQAAAAAAAAAAAAAAAAAAAAAAVG716tWLbbfdNpX2p59+mmjPHWSkyf6qnMaOHZtKd6uttkqlCwBJquj3xAIAAAAAAAAAAADZKcx6AAAAAAAAAAAAAACoyObPn594s3bt2ok310RBQUHUqFEj6zGgwnEuQNVVXFwchx12WJx22mmxcOHCrMdJVEFBQdx///3RtGnTrEcBAAAAAAAAAAAAAAAAAAAAAAAyMHLkyFS6LVq0iHbt2qXSXpbCwsLo379/XHjhhav1uHXXXTdeeeWVaN269Uq/dvfdd1+z4VZixIgRqXQjIjbYYIP429/+llp/ecrLy+ORRx6Jjh07xp/+9KeYOXNmzmcAKjfnWzJ++OGHWLx4caLNqVOnxrx58xJtrqmxY8cm3qxTp07iTaBqqFOnTvzzn/+MTTfdNOtRACLCuQRpeuGFF6Jv376p9du3b59aG4DseH9GmkpLS+PBBx9MtNmjR4+Vfk337t0TW2/gwIGJtQAAAAAAAAAAAAAAAAAAAAAAgMptl112iaKiosS7xcXF8cUXXyTWcwcZabK/Kq+0Pu9qu+22i2rVqqXSBgAAAAAAAAAAAACArBVmPQAAAAAAAAAAAAAAVGTz589PvLnuuusm3lwTjRo1ynoEqJCcC8A999wTm266aTz11FNZj5KoJk2aRO/evbMeAwAAAAAAAAAAAAAAAAAAAAAAyMD3338f3333XSrtPfbYI5XuL9WqVSueeeaZOP7449fo8RtssEEMGTIkmjZtutyv2WSTTaJFixZrOOGKjRw5MpVuRMSdd96Z83vvXnvttdh6663jt7/9bUyePDmnawNVh/MtOd9//32ivalTpybaWxtpzFKzZs3Em0DV0Ldv39h2222zHgNWqKSkJPFmUVFR4k2S4VyCdF199dWxaNGiVNotW7ZMpQtAtrw/I219+/ZNtPfrX/96hX9+Wr169dh7770TWWvatGnx5ptvJtICAAAAAAAAAAAAAAAAAAAAAAAqv+7du6fSHTFiRJSVlSXWcwcZabK/Kq/x48dHcXFx4t06depE586dE+9WdosXL856BGAteA4DAAAAAAAAAAAAVB2FWQ8AAAAAAAAAAAAAABXZggULEm9usMEGiTfXRPPmzbMeASok5wIQEfHVV1/F4YcfHjvuuGMMHjw463ES89vf/tYHvwAAAAAAAAAAAAAAAAAAAAAAQBU1fPjwVLoHH3xwKt2fatCgQbzyyitxwAEHrFWnffv28fLLL0f9+vWX+fOHHnroWvWXZ8mSJTFmzJhU2rvvvnsccsghqbSXZeTIkdG1a9f4zW9+k9qeAohwviVt2rRpifYWLlyYaG9tzJ8/P/FmtWrVEm8Cld+xxx4bRx99dNZjrJJ58+bF8OHDY+TIkVmPQgaKi4sTb9asWTPxJmvPuQTp+/bbb+OZZ55Jpd2yZctUuvmusLAw6xEAUuP9GbkwduzYeP/99xPrFRQUrPDPUHfdddfl/tnr6nr88cejrKwskRYAAAAAAAAAAAAAAAAAAAAAAFC5Va9ePY488shU2sOGDUus5Q4y0lRR9pe9tWbKyspi9OjRqbT33HPPVLqVWRr3uwO54zkMAAAAAAAAAAAAUHUUZT0AAAAAAAAAAAAAAFRk8+fPT7y53nrrRb169VJpr4727dtnuj5UVM4F4Kc++OCDOOCAA2LjjTeOk046KXr27BnNmjXLeqw1VlBQEJdeemkcfPDBWY8CAAAAAAAAAAAAAAAAAAAAAADk2Ntvvx377rtv4t2uXbtG48aNY+bMmYm3IyKaNWsWr7zySnTq1CmRXufOneP555+Prl27xqJFi372c0ceeWQia/zSiBEjYsmSJam0e/funUr3lxYsWBCXX3553HbbbVFWVpaTNYGqzfmWrAkTJsQ222yTWG/p0qWJtdZWPs0CVF0NGjSIW2+9Nesxfmb27Nkxbty4GD9+fIwfP/4//33ChAkxffr0iIj4/e9/H/fcc0/Gk5JrxcXFiTdr1aqVeJO141yC3HnhhRdS+X3FBg0aJN6sCGrXrp31CACp8P6MXOrbt2/suOOOifWOOOKIuP3225f5c927d09snYEDBybWAgAAAAAAAAAAAAAAAAAAAAAAKrf9998/GjdunEr7gw8+SKTjDjLSlG/7y95Kx8iRIxP9rJEfHXbYYXHzzTcn3q3M0rjfHcgdz2EAAAAAAAAAAACAqqMo6wEAAAAAAAAAAAAAoCKbM2dOLF26NIqKkvtXcwsKCmLzzTePDz/8MLHmmthqq60yXR8qKucCsCxffPFFXHDBBXHRRRfFDjvsEAceeGDss88+0alTpygsLMx6vNVywAEHRJs2bWLSpElZjwIAAAAAAAAAAAAAAAAAAAAAAOTQ22+/nUq3qKgojjjiiLj77rsTb7dr1y6GDBkSbdq0SbS72267xaOPPhqHHXZYlJWVRUTE9ttvH1tssUWi6/xoyJAhqXQPPPDAnNwzN3LkyDj44IPdXwXkjPMteZ9//nmivYKCgkR7ayONWX58fwCwqi677LJYb731cr7u9OnTY+zYsTF+/Pj/+WvOnDk5n4eKobi4OPFmFvufFXMuQe68//77qXTr1KmTSnd15fL7vzp16uTV95sASfL+jFx67LHH4vbbb4969eol0ttxxx1jgw02iKlTp/7Pz3Xr1i2RNSZNmhQfffRRIi0AAAAAAAAAAAAAAAAAAAAAAKDy+9Of/pRKt6ysLF5++eVEWu4gI01Z7C97K/c++uijOPHEExPvbrfddtG8efP49ttvE29XViUlJYk3n3nmmXjnnXcS72Zp8eLFWY8Ay+Q5vGo8hwEAAAAAAAAAAIDKoCjrAQAAAAAAAAAAAACgIistLY1JkyZFhw4dEu1ut9128eGHHybaXF0777xzputDReVcAFakrKws3nvvvXjvvffioosuivr168evf/3r6NSpU3Tq1Ck222yzaNeuXay77rpZj7pchYWF8dvf/jauu+66rEcBAAAAAAAAAAAAAAAAAAAAAABy6OOPP47i4uKoXbt24u0//vGP0adPnygvL0+s2blz53jppZeiWbNmiTV/6uCDD4577703Tj755IiIOOuss1JZJyLilVdeSaXbq1evVLo/9fTTT8cxxxwTxcXFqa8F8CPnW/K++OKLRHs1atRItLc2atasmXizpKQk8SZQedWvXz9OPfXU1NeZOXNmvPXWW/H+++/HsGHD4rPPPouZM2emvi6Vz+zZsxNvrr/++ok3WXPOJcitadOmpdKtU6dOKt3VlcbvJy9P/fr1c7YWQC55f0auLVy4MB577LE46aSTEukVFBTEoYceGnfeeefPfrx9+/aJfc7Xo48+mkgHAAAAAAAAAAAAAAAAAAAAAACo/HbeeefYfffdU2kPHTo0ZsyYsdYdd5CRplzsL3srP7z66qupdAsKCuJ3v/td3HTTTan007TrrrvGJZdcEvfdd188++yzsXTp0pysO2fOnMSbw4YNi969eyfeBf6X5zAAAAAAAAAAAABA1VGU9QAAAAAAAAAAAAAAUNGNHTs2OnTokGjzN7/5Tdx+++2JNldH3bp1Y8cdd8xsfajonAvAqpo3b14MGTIkhgwZ8rMfb9iwYbRt2zbatWv3s7/atm0bLVq0iMLCwowm/n+HH354XHfddZnOAAAAAAAAAAAAAAAAAAAAAAAA5NbixYvjtddei+7duyfe3njjjePggw+Op59+OrFmp06dolmzZon1luWkk06K6dOnx3333RdHHXVUKmsUFxfH+++/n3h32223jV//+teJd3/queeeix49ekRpaWmq6wD8lPMtHWPGjEm0V79+/UR7ayONWRYtWpR4E6i8jjvuuNTOxdmzZ8c//vGPePTRR+PDDz+M8vLyRPtZ35NLNr7//vtYvHhx1KhRI7Fm/fr1o1GjRjFr1qzEmqw55xIV2brrrhvdunWLhx9+OOtRVtmCBQuipKQkatWqlWi3qKgo0d6ayuX3f23atMnZWgC55P0ZWejbt2+cdNJJifWOOOKIuPPOO3/2Y926dUusP3DgwMRaAAAAAAAAAAAAAAAAAAAAAABA5fbnP/85tfbgwYMT6biDjDSltb/srfwzceLEmDhxYrRt2zbx9llnnRW33HJLhfvslt/97nfRtWvX6Nq1a0yfPj0efPDBuO++++LLL79Mdd1p06ZFaWlpVKtWLbHmBhtskFgLWDHPYQAAAAAAAAAAAICqw/97AQAAAAAAAAAAAADW0tixYxNv/uY3v4m6desm3l1Vhx12WNSoUSOz9aGicy4Aa2v27NkxbNiwePzxx+OGG26Ik08+OfbYY49o1apV1K5dOzp27Bj77bdfnHXWWfG3v/0tnnvuuRg9enQsWrQoJ/N17tw5GjZsmJO1AAAAAAAAAAAAAAAAAAAAAACA/PHss8+m1r7yyiujoKAgsd6DDz4YvXr1Sqy3PBdffHG8/PLLUVRUlEr/nXfeicWLFyfePfnkkxNv/tTQoUOjR48eUVpamuo6AL/kfEvH2LFjE/01t2zZMrHW2mrVqlXizRkzZiTeBCqvo446KvHm4sWL44orroiNNtoozj777Pjggw+ivLw88XVq166deJOK4dtvv028uckmmyTeZM04l6iI6tevH5dffnlMnjw5/vGPf1S4M2Xp0qVZj5Ca+vXr52ytDh065GwtgFzy/owsfPjhh/H5558n1tt5552jWbNmP/uxAw44IJH26NGjY9SoUYm0AAAAAAAAAAAAAAAAAAAAAACAyu3EE0+M3XbbLbX+Cy+8kEjHHWSkKen9ZW/lt1dffTWVbosWLeLwww9PpZ2W+vXr/2z/N2nSJM4777z44osv4t13341jjz02tX1WVlYWU6dOTbTZtm3bRHvA8nkOAwAAAAAAAAAAAFQdhVkPAAAAAAAAAAAAAAAV3RdffJF4s3bt2nHYYYcl3l1Vv//97zNbGyoD5wKQpsWLF8fYsWPjpZdeijvvvDPOOeecOOigg2LzzTePevXqRadOneL888+Pf/3rX6nOsd1226XaBwAAAAAAAAAAAAAAAAAAAAAA8s/zzz8fZWVlqbS33HLLOPPMMxNt3njjjXH77bcn2lyW9u3bp9Z+9NFHE2/WqFEjjjrqqMS7P5o3b14cddRRsXjx4tTWAFgW51t6Fi1alOg9h+uss060aNEisd7a2HTTTRNvfvfdd4k3gcqpadOmseOOOybanD9/fuy///5x7bXXxoIFCxJt/9K6666bap/89c033yTe3GqrrRJvsvqcS1Q0derUiYsuuigmT54c11xzTTRo0CAKCgriwgsvzHq01VKzZs3Em8XFxav9mEWLFiU+R1FRUdSrVy/x7rJsscUWOVkHIJe8PyNL/fr1S6xVWFgYhxxyyH/+d7169WKXXXZJpD1w4MBEOgAAAAAAAAAAAAAAAAAAAAAAQOXWvHnz6N27d2r9L774IpE7/d1BRpqS3l/2Vv575ZVXUmv/+c9/jurVq6fWT9pJJ50U9evXX+bP7bTTTvHAAw/EtGnT4u67744uXbokvv6///3vRHsbb7xxoj1gxTyHAQAAAAAAAAAAAKqGwqwHAAAAAAAAAAAAAICK7rPPPkule+6556bSXZlddtkldtppp0zWhsrCuQDJKigoyHqECmPp0qXx2Wefxa233hpbbbVVHHDAATFt2rRU1tpyyy1T6QIAAAAAAAAAAAAAAAAAAAAAAPnru+++izfeeCO1/vXXXx/NmzdPtHn22WfHo48+mmgzV4qLi+PJJ59MvLvHHnvEOuusk3j3R5deemlMmjQptT7A8jjf0vXOO+8k2tt1110T7a2Jjh07RtOmTRPvfvPNN4k3gcppp512Svz+3fPOOy9ee+21RJvLs9FGG+VkHfLPxIkTE2/uvvvuiTdZfc4lKopatWrFOeecE5MmTYobb7wxGjVq9LOfP+aYY6Jly5YZTbd6ateuHdWrV0+8u2DBgtV+TElJSeJzRERsuummqXR/aa+99srJOgC55P0ZWXrwwQdjyZIlifWOOOKI//z3vffeO2rUqJFIt6L+WTAAAAAAAAAAAAAAAAAAAAAAAJA7tWvXjueeey4aNGiQ2hp9+vRJpOMOsson6X+eayPp/WVv5b9XXnkliouLU2m3b98+zj777FTaSatbt2706tVrpV+3zjrrxGmnnRbDhg2L4cOHxxlnnJHYa8fkyZMT6fyodevW0bhx40SbkG/y6TXUcxgAAAAAAAAAAACgaijMegAAAAAAAAAAAAAAqOiGDh0a8+bNS7y75ZZbxsEHH5x4d2X+8pe/5HxNqGycC1Rl5eXliTfr16+feLOqGDx4cGy99dbx9ddfJ95u3bp14k0AAAAAAAAAAAAAAAAAAAAAACD/3X///am169evH0888URUr1490e6xxx4br776aqLNXHjmmWdSudvuoIMOSrz5o0mTJkWfPn1S6wOsiPMtXW+//XaivcMOOyzR3po49NBDU+l+8cUXqXSByufXv/51or2JEyfGfffdl2hzRTbddNOcrUV++fTTTxNv7rXXXon/fgCrz7lEvqtRo0aceeaZMXHixOjdu3c0bdp0mV9XvXr1nO69tfGrX/0qle78+fNX+zElJSUpTBKx+eabp9L9qfXWWy+22mqr1NcByDXvz8jSjBkz4vnnn0+st+uuu0aTJk0iIqJ79+6JNIcOHRoTJ05MpAUAAAAAAAAAAAAAAAAAAAAAAFRO1apVi4cffji6dOmS2holJSXxwAMPJNJyB1m2ysvLE2/Wr18/8eaaSnJ/2VsVw7x58+Lpp59OrX/VVVdFx44dU+sn5bLLLlvufcbL07lz57jzzjtj6tSp8Y9//CN23XXXtZohjfvdd9ppp8SbsKYq+2uo5zAAAAAAAAAAAABA1VCY9QAAAAAAAAAAAAAAUNGVlpbGW2+9lUr7b3/7W9SuXTuV9rKcfvrpiX+AAFRFzgWqskWLFiXebNiwYeLNqmTKlCnRs2fPxLstWrRIvAkAAAAAAAAAAAAAAAAAAAAAAOS/QYMGxQ8//JBaf4cddog777wz0eaSJUvi4IMPjmHDhiXaTdsDDzyQSnfPPfdMpRsR0bt371iyZElqfYAVcb6l65133km0171791h//fUTba6OwsLCOPHEExPvzp49O77//vvEu0DltPHGGyfae/bZZ6O8vDzR5vJUr149ttxyy5ysRf755JNPEm+uu+66se+++ybeZfU4l8hXRUVFccopp8T48ePjjjvuiA022GClj9lnn33i97//fQ6mWzs77bRTKt05c+as9mMWLFiQynO2c+fOiTd/qWfPnlFQUJD6OgC55v0ZWevbt29irWrVqsUhhxwSERH7779/Is2BAwcm0gEAAAAAAAAAAAAAAAAAAAAAACqnmjVrxqBBg/5zB1JaHn/88TW6C3JZ3EGWrUWLFiXebNiwYeLNNZXk/rK3Ko4BAwak1q5bt248+eSTUbt27dTWWFtdunSJ888/f40fX7t27fjd734Xb731VowdOzYuuOCCaNq06Wp3Pv300zWeYXm6deuWeBPWVGV/DfUcBgAAAAAAAAAAAKgaCrMeAAAAAAAAAAAAAAAqgyFDhqTSbdWqVfTp0yeV9i916tQpevfunZO1oCpwLlBVlZSUJN5s0aJF4s2q5u23347hw4cn2qxXr16iPQAAAAAAAAAAAAAAAAAAAAAAoGIoKSmJ/v37p7rGKaecEtdff32izQULFsR+++0X48aNS7SblkmTJqVyr13jxo2jY8eOiXcjIpYsWRIDBw5MpQ2wMs639M2YMSNGjhyZWK9GjRrRq1evxHqr65hjjon27dsn3v3www8TbwKVV+vWrRPtffrpp4n2VmT33XePWrVq5Ww98su//vWvKC0tTbx75plnJt5cFbVr146GDRtmsna+cS6RbwoLC+O4446LsWPHxr333hsbbbTRaj3+1ltvjU022SSl6ZLRo0ePVLoTJkxY7ccsXbo0ZsyYkfgs3bt3T7z5UwUFBfGHP/wh1TUAsuL9GVl7+eWX49tvv02s16NHj9h6661j/fXXX+tWWVlZPPbYYwlMBQAAAAAAAAAAAAAAAAAAAAAAVEbrr79+DBkyJA488MDU1/r73/+eWMsdZNkqKSlJvNmiRYvEm2sqyf1lb1Ucr776aqL3yv3S5ptvHg8//HBUq1YttTXWVKNGjeKpp56KoqKiRHodOnSIv/zlL/Htt9/GoEGDYq+99lrlxw4fPjyRGX7qoIMOysu/71RNlf011HMYAAAAAAAAAAAAoGoozHoAAAAAAAAAAAAAAKgMXn311dTaxx57bJxzzjmp9SP+/3Lc559/3gXpkCDnAlVVGpe4b7311lGzZs3Eu7my2WabxUMPPRRNmjTJdI6333470V6dOnUS7QEAAAAAAAAAAAAAAAAAAAAAABVH7969Y+nSpamu0atXr7j55psTbU6fPj322WefmDZtWqLdNNx4441RVlaWeHf77bdPvPmj119/PWbNmpVaH2BFnG+58fjjjyfaO+OMM2LLLbdMtLkq1l133fjLX/6SSvv9999PpQtUThtssEGivenTpyfaW5Gjjz46Z2uRf4qLi2PkyJGJd7t27Rrbbrtt4t2VueSSS2LSpElx6aWXRt26dXO+fj5xLpEvCgoK4re//W188cUXMWDAgGjTps0aderVqxevv/56tG/fPuEJk7HNNtvE7rvvnkp77Nixa/S4KVOmJDxJRJs2bWLrrbdOvPuj4447bo33CEC+8/6MrJWVlcUDDzyQWG+PPfaI448/PpHWm2++WSH+3BcAAAAAAAAAAAAAAAAAAAAAAMi9/fbbL0aOHBm77LJL6ms9/fTT8cknnyTWcwdZtkpKShJvbr311lGzZs3Eu2siyf1lb1Uc5eXl8eCDD6a6xiGHHBIPPfRQFBYWprrO6qhbt24MHjw4WrdunXi7qKgoDjnkkDjooINW+TGzZs2K8ePHJzpHs2bN4sADD0y0CWuqsr+Geg4DAAAAAAAAAAAAVA3582/FAwAAAAAAAAAAAEAF9vnnn8eXX36ZWr93795x9tlnp9Ju27ZtvPHGG9GyZctU+lBVOReoqtL4cI8aNWrErrvumng3bZtsskk89thj8dlnn8UxxxwT1157babzTJ06NdFetWrVEu0BAAAAAAAAAAAAAAAAAAAAAAAVxzfffBOPP/546uucf/75MWjQoKhfv35izcmTJ0fXrl1j7ty5iTWTNmXKlBgwYEAq7U033TSVbkTE22+/nVobYGWcb7mR9Ot/UVFRPProo4m+1q+KAQMGxPrrr59K++WXX06lC1ROderUSbRXo0aNRHvL07hx4zjqqKNyshb564UXXkile/fdd0dhYWEq7WVp3759nH/++dGgQYP485//HJMmTYo//elPUbNmzZzNkE+cS+SDww8/PEaNGhUPP/xwdOjQYa1766+/frzxxhvRpk2bBKZLTvXq1ePuu+9OrT9+/Pg1ety3336b8CT/7/jjj0+lu+6668Zf/vKXVNoA+cD7M/JBv379ory8PJFWtWrV4vTTT0+kNXDgwEQ6AAAAAAAAAAAAAAAAAAAAAABA5dGuXbt46qmn4sUXX4wmTZqkvl5paWlceumliTbdQZat6dOnJ96sUaNG7Lrrrol310SS+8veqlhuu+22KCkpSXWNo446KgYPHhwNGjRIdZ1Vsd5668Urr7wSO+ywQ6rr9OnTZ7W+/sUXX0x8hl69eiXeXF09evSItm3bZj0GGavsr6ERnsMAAAAAAAAAAAAAVUFh1gMAAAAAAAAAAAAAQGVxzz33pNr/29/+Fvfee2+iF7B37do1Pvzww2jfvn1iTeC/nAtURVOnTk2le95556XSTUPHjh3jkUceiVGjRsURRxwRBQUFERFx8sknx84775zZXNWrV0+0V1pammgPAAAAAAAAAAAAAAAAAAAAAACoWK655pqc3Ed0yCGHxMcffxzbb799Ys2RI0fGgQceGIsWLUqsmaRbbrklFi9enEp70003TaUbEfHBBx+k1gZYGedbbowbNy5GjBiRaHPjjTeOJ598MmrWrJlod3l69+4dBx10UCrt7777Lj7++ONU2kDlVLt27UR7zZs3T7S3PFdccUXis1PxPPvss6l0t95667juuutSaf9SrVq14sknn4xatWr958eaNGkSf/3rX2P8+PFx8sknR7Vq1XIyS75wLpGlrl27xr/+9a944oknEv8er0WLFvHJJ5+k9r3Amrj33ntjm222Sa3/4YcfrtHjxowZk/Ak/+/3v/99tG3bNvFu3759o0mTJol3AfKF92fkg4kTJ8Zbb72VWC+J77OWLFkSTz31VALTAAAAAAAAAAAAAAAAAAAAAAAAlUHnzp3j/vvvj88//zwOPfTQnK374IMPJn6XozvIsjV16tRUuuedd14q3dWV5D8je6ti+e677+K+++5LfZ399tsvPvnkk+jSpUvqay3P9ttvHx9//HHsuOOOqa7z7rvvxueff75aj3nhhRcSn2PbbbeNww8/PPHuqtpyyy3joYceis8++yz+8Ic/ZDYH2avsr6ERnsMAAAAAAAAAAAAAVUFh1gMAAAAAAAAAAAAAQGUxYMCAWLRoUaprnHLKKTF69Og4+uijo6CgYI07LVq0iP79+8dLL70UTZo0SXBC4KecC1RFU6ZMSaXbtWvX6NatWyrtpHTo0CEeeuih+Pzzz+Ooo46KwsKf/193qlWrFk8++WRsuOGGmczXtm3bRHvz589PtAcAAAAAAAAAAAAAAAAAAAAAAFQsX375ZfTr1y8na3Xs2DE++OCD6NOnTzRq1CiR5ltvvRW//e1vo6ysLJFeUr799tu45557Uuu3bNkytfbEiRNTawOsjPMtdwYOHJh4c5999onBgwfHOuusk3j7R4WFhfH3v/89zjnnnNTWePzxx1NrA5XTkiVLEu3ttddeifaWZbvttoszzzwz9XXIf5988klMnTo1lfbFF18cZ5xxRirtHxUVFcXDDz8cW2655TJ/vkWLFnHffffFF198EUcddVSqs+QT5xJZ2nnnnZf7nExCo0aN4plnnok+ffpEnTp1UltnZerUqROPPPJIHH/88amtMXHixPj666/X6LEjRoxIeJr/V6NGjfjLX/6SaPPiiy+Oww47LNEmQL7x/ox80bdv36xH+JmXXnop5syZk/UYAAAAAAAAAAAAAAAAAAAAAABAhn71q1/F+eefHx988EEMHz48TjjhhKhRo0bO1p8/f35ceeWViXfdQZatKVOmpNLt2rVrdOvWLZX26khyf9lbFc+NN94YixcvTn2d9u3bx8cffxy333571K9fP/X1ftS0adO47bbb4r333ovWrVunvt6NN9642o958803Y8GCBYnPcscdd8R6662XeHdlmjZtGk888UTUqFEj6tSpE7fffnu8/fbb0a5du5zPQvYq+2tohOcwAAAAAAAAAAAAQFVQmPUAAAAAAAAAAAAAAFBZzJ49O5588snU12ndunUMHDgwJkyYEFdffXVsvfXWUVi48n81uG7dutGtW7d45JFHYvz48XH88cenPitUdc4FqqJZs2bFjBkzUmk/8sgj0aVLl1Taa6Ndu3bx4IMPxpgxY+KYY45Z4fOvWbNmMWTIkGjRokUOJ4yoWbNmdO/ePdHm/PnzE+0BAAAAAAAAAAAAAAAAAAAAAAAVz5VXXhkLFizIyVoFBQVx6qmnxtdffx29e/eO5s2br3Vz0KBBccYZZyQwXXLOOeecWLhwYWr99ddfP5VueXl5TJkyJZU2wKpwvuVO3759U3mt+s1vfhNDhw5NvBsR0bx583jllVfirLPOSqX/o/79+6faByqfpM/Tbt26xXrrrZdo86eaNm0ajz32WFSrVi21NahYHn300dTad955Z1x77bVRUFCQeLt27drx5JNPxqGHHrrSr23fvn088sgjMWLEiMTvec5HziWydNddd8WSJUtSX+fUU0+NyZMnx8UXXxz16tVLfb2f2nfffWP48OFx1FFHpbrOG2+8scaPHTlyZIKT/Nxhhx0Wp5xySiKtiy66KG644YZEWgD5zPsz8sVTTz0VP/zwQ9Zj/MfAgQOzHgEAAAAAAAAAAAAAAAAAAAAAAMiBgoKCaNKkSXTp0iUOPvjg6NWrVwwaNCi++eab+PLLL+Pmm2+OX//615nMdv7558c333yTeNcdZNmaNWtWzJgxI5X2I488El26dEmlvaqS3F/2VsUzZcqUuP/++3OyVmFhYfzhD3+Ib775Jq6//vpo2rRpams1bdo0brnllpg0aVL88Y9/zMme+fTTT+OFF15Y7cctXrw4Bg0alPg8zZo1i6eeeiqqV6+eeHt5GjVqFEOGDIkOHTr87Md32WWXGDlyZPzxj39M5Z558ldlfw2N8BwGAAAAAAAAAAAAqAqKsh4AAAAAAAAAAAAAACqT22+/PY455picrNWmTZu44oor4oorroj58+fHuHHjYvLkyTFv3rwoLi6OiIg6derEuuuuG+3bt48OHTpEUZF/hRhyzblAVTRy5MjYc889E+/Wr18/3nvvvbjooovizjvvjNLS0sTXWB0/Pud69uy5Wh8csemmm8aHH34Yhx56aAwdOjTFCf/rqquuiiZNmiTanD59eqI9AAAAAAAAAAAAAAAAAAAAAACg4pk2bVpcdtll8de//jVna9atWzfOOeecOPvss+PNN9+MRx55JF588cWYMmXKGvXuueee2GCDDeLKK69MeNLV9+qrr8YTTzyR6hpNmzZNrf3111+n1s6FLbbYImbMmJH1GMAacr4tX9Ln26xZs+KBBx6I008/PbHmjzp27Bi9e/eO6667LmbOnLnWvZo1a8YZZ5wRV155ZTRo0CCBCZdv6NChMXz48FTXACqfuXPnRsOGDRPr1a5dO26//fb47W9/m1jzR+utt1689NJL0bp168TbVFx33nln/OlPf4qCgoJU+pdddlnssssuceqpp8aXX36ZSHPTTTeNJ554IjbddNPVelynTp3i+eefj48++ih69eoVb7zxRiLz5BvnElmaOnVqPPHEE6nsl19q0qRJ3HDDDXHhhRfG/fffH4MGDYoPPvggysvLE1+rbt26cfDBB8cf/vCH2H777RPvL8vTTz+9xo8dNWpUzJ07N9ZZZ50EJ/qvu+++O8rLy6Nv375r9Ph11lkn7rjjjujZs2fCkwHkJ+/PyBclJSUxcODAVH5feHUtXLgwnnvuuazHAAAAAAAAAAAAAAAAAAAAAAAAfuLee++N2267LZFWQUFB1KxZM+rUqRM1atRIpJm0V155Je65555U2u4gy97IkSNjzz33TLxbv379eO+99+Kiiy6KO++8M0pLSxNfY2WS3F/2VsV05ZVXxpFHHpnoObMiDRo0iF69esX5558fr732Wjz22GPx4osvxvfff79W3caNG8chhxwSRxxxROyxxx5RVFSU0MSrZm0+76xPnz6p3K+76667xrPPPhuHHnpolJSUJN7/qc6dO8egQYOiTZs2y/z5OnXqxG233RY9evSIE044IcaPH5/qPOSPyvwa+iPPYQAAAAAAAAAAAIDKLbf/djoAAAAAAAAAAAAAVHJDhw6NQYMGxaGHHprTdevVqxdbbbVVbLXVVjldF1g55wJV0YgRI1K5xD0iolatWnHbbbfF+eefH3fffXe8+uqrMXz48Fi6dGkq6y1L69at4/LLL49jjz12jT88onnz5vHBBx/EXXfdFZdddln88MMPCU/5/woLC+Oyyy6Liy++OPH2l19+mXgTAAAAAAAAAAAAAAAAAAAAAACoeG6//fY45phjYptttsnpuoWFhbHnnnv+596rr776Kt57770YM2ZMTJw4Mb766quYO3duLFiwIBYuXBjl5eVRu3btqF+/ftSvXz8aNGgQHTp0iE022SQ22WSTKC8vj4KCgpz+Gn5q8eLFceaZZ6a+Tu3atVPpFhQUxPrrr59KO1cKCwuzHgFYC8635UvjfOvdu3eceuqpqbTPOeecOOWUU+Lhhx+O/v37x9ChQ6O8vHy1Gh07dozf/e53cfLJJ+fsn99NN92Uk3WAyuWrr76KVq1aJdo8+uijY8KECXH55Zcn1uzUqVM8+eST0aFDh8SaVA4TJkyIV155Jbp27ZraGrvttluMGjUqHnjggfjrX/8ao0ePXqPORhttFJdddlmceOKJa3y3dETE9ttvH6+//nq89tprcckll8TQoUPXuJWPnEtk7aqrroojjjhirZ6nq6Nhw4Zx3nnnxXnnnRfff/99vPDCC/HRRx/F559/HqNHj45Zs2atdnODDTaIzTffPLbeeuvYY489Ypdddknte9ZlmTp1avzzn/9c48eXlpbGG2+8EQcddFCCU/1XtWrV4r777ou99torLrzwwvjmm29W6XFFRUVx4oknxhVXXBHNmzdPZTaAfOT9Gfmkb9++cfrpp2c9Rjz33HOxcOHCrMcAAAAAAAAAAAAAAAAAAAAAAAB+okGDBtGgQYOsx8iJH374IU488cTU+u4gy96IESP+85lISatVq1bcdtttcf7558fdd98dr776agwfPjyWLl2aynq/lPT+srcqnu+//z4uvPDCuO+++3K6bvXq1WPfffeNfffdNyIiJk2aFB988EGMGTMmJk+eHF999VX88MMPsXDhwli4cGGUlpZG3bp1//P60rBhw9h4442jc+fOseWWW0aHDh0y+7ypIUOGxODBg9f48e+//36MHj06NttsswSn+n/77bdffPjhh3HkkUfGl19+mXi/du3accEFF0SvXr2iVq1aK/36nXfeOUaOHBmXXHJJ3Hbbbav9+TNUPJX5NfRHnsMAAAAAAAAAAAAAlVtR1gMAAAAAAAAAAAAAQGVz0UUXxQEHHBDVq1fPehQgTzgXqGreeOONOOecc1JdY6ONNorrr78+rr/++li8eHFMnz49Zs+eHSUlJavduv766+Ppp59e6de1bNkyLrvssjj++OMTeT4XFhbGWWedFSeeeGI88sgj0bdv3xg6dGiUlZWtdbtGjRpx2GGHxQUXXBBbbbXVWveWZezYsal0AQAAAAAAAAAAAAAAAAAAAACAiqWsrCxOOOGE+Pjjj6NWrVqZzdGqVato1apVZuuvrcsvvzwn9ztl+c8IIE3Ot9waP358PPXUU9GjR49U+vXq1YtTTz01Tj311Pj+++/j/fffj08//TQmTZoU06ZNiwULFsTixYujqKgo6tSpE02aNIlWrVpF586dY4cddog2bdqkMtfyjBo1apXutgT4pcmTJ8euu+6aePeyyy6Ltm3bxp/+9KeYPn36Gnfq1q0bF198cVxwwQVRs2bNBCekMvnrX/8aXbt2TXWNoqKiOOmkk+Kkk06KUaNGxQsvvBAffvhhjBo1Kr7++utYvHjx/zxmvfXWiy222CK6dOkSBx98cOy0005RUFCQ2Ex77bVXfPTRR/Hss8/GpZdeGqNHj06snSXnElkbN25c3H///fH73/8+52s3bdo0TjjhhDjhhBP+82PT/4+9+46Surwb/v/ZRVgXjFETNQFBIDYsEVswSFQkBrugKBgs+KAmGjViwWBQb2JvQR8LBgWMBYmVBDUWEkxAiYoiAaRKkd5hgV22zu+P59z84n2jLjAz39md1+ucPR6Xnet67/H7vWbA5TMrVsTKlStj/fr1mz/Ky8sjlUpFgwYNolGjRlFcXBy77LJLfOc734m99tor8Wvz6aef3u5592+//XaceeaZaSrash49esRZZ50Vl156aYwfPz7mzp0bVVVVX/qa7373u3HkkUfGySefHD169Ig99tgjo00AucjrM3LJJ598EpMmTYpDDz000Y7hw4cnuj8AAAAAAAAAAAAAAAAAAAAAAJC/UqlU9O7dOxYtWpSxPcwgS96YMWOiT58+Gd2jefPmceedd8add94ZFRUVsWLFilizZk1s2rRpq9e68847a/1+CZm4vlxbdc+TTz4ZF154YfzkJz9JrKFVq1ZZf2+RdKioqIhf/epX273OQw89FIMHD05D0f926KGHxr///e94+OGH4/7774+lS5du95q777579OrVK66++urYa6+9tuqxxcXFMXDgwDjnnHOiV69eMWvWrO3uIXfV5+fQ/+QeBgAAAAAAAAAAAKi/dkg6AAAAAAAAAAAAAADqm9mzZ8egQYPi6quvTjoFyBHOBfLNmDFjoqqqKnbYITt/daVRo0bRrFmzaNas2TY9fvfdd//Gr+ncuXOMGjUqGjZsuE17fJ3GjRtH7969o3fv3lFSUhJjx46NDz/8MObMmRNz5syJxYsXx8aNG6O0tDRKS0sjlUpFRERRUVHsuOOO0bhx42jatGnsvffesf/++8dPfvKTaN++fXz7299Oe+t/S6VSMX78+IytDwAAAAAAAAAAAAAAAAAAAAAA1C1TpkyJPn36xKBBg5JOqZNef/31uPfee7OyV7ZmhAFkm/Mt+66//vo47bTTori4OKP77LHHHtGlS5fo0qVLRvfZHjfccMPmeZEAW2PSpEkZW/vnP/95nHzyyfH444/H0KFDY/bs2bV+bLt27aJ79+5x8cUXxy677JKxRuqHt956K8aMGRMdO3bMyn4HH3xwHHzwwZv/PZVKRWlpaZSVlUV1dXUUFxfHt771rSgoKMhKz5lnnhmnnXZatGzZMhYuXJiVPTPJuUQuuPXWW6N79+4ZnbVeW7vvvnutZtnnivLy8njkkUe2e52RI0fGww8/HIWFhWmo+mqNGjWKP/7xjxERUVNTExs2bIiysrIoLCyMXXbZJSPvDQBQ13h9Rq558skn4+GHH05s/7Vr18abb76Z2P4AAAAAAAAAAAAAAAAAAAAAAEB+++1vfxsvv/xyRvcwgyx5Y8aMiaqqqqy9D0ajRo2iWbNm0axZs216/NbMT83U9eXaqnsuvfTSmDRpUhQVFSWdUqfccccdMWvWrO1eZ+jQodG3b9/YZ5990lD1vzVq1Ciuu+66uOqqq+Kvf/1rvPrqq/Hee+/V+t789re/HW3atIljjz02OnXqFB07dtzuecHt27ePSZMmRf/+/WPgwIHe56Weqs/Pof/JPeweBgAAAAAAAAAAAOqv7PwkLAAAAAAAAAAAAADkmQEDBkSPHj1ijz32SDoFyBHOBfLJhg0bYuzYsdGxY8ekU9Jm/PjxUV5evt1D0L/JzjvvHKeeemqceuqpGd1ne02ZMiVWrFiRdAYAAAAAAAAAAAAAAAAAAAAAAJBDHn/88ejYsWOce+65SafUKQsWLIgLL7ww6QwA2GpffPFF3HvvvXHrrbcmnZKokSNHxptvvpl0BlBHjR8/PqPr77rrrtGvX7/o169fzJs3Lz7++OOYNWtWrFmzJkpKSiKVSkVRUVF861vfir322iv23XffOPLII+Pb3/52Rruof6699tr45JNPoqCgIOt7FxQURJMmTaJJkyZZ3/u/vf7667Fw4cLE9k8n5xK5YOnSpXHdddfFk08+mXRKnfPoo4+m5TxavHhxvPPOO9G5c+c0VNVOYWFh7LzzzrHzzjtnbU+AusDrM3LNc889F/fff38UFRUlsv/LL78clZWViewNAAAAAAAAAAAAAAAAAAAAAADktz/+8Y9x1113ZXwfM8iSt2HDhhg7dmx07Ngx6ZS0y+T15dqqW2bMmBFXXXVVDB48OOmUOuP999+P22+/PS1rVVdXx8033xzPP/98Wtb7Ko0aNYozzzwzzjzzzIiI2LhxY3zxxRexYsWKKCsr2zzfr1GjRrHTTjtFkyZNYq+99orvfOc7GekpLi6OBx54ILp16xa9evWKmTNnZmQfklOfn0P/k3vYPQwAAAAAAAAAAADUXzskHQAAAAAAAAAAAAAA9dHq1aujZ8+e8fbbb0dBQUHSOUAOcC6Qb4YNG1avhriXlJTE4MGD49prr006JSe8/vrrSScAAAAAAAAAAAAAAAAAAAAAAAA56OKLL4599tknDj/88KRT6owrr7wyVq9enXQGAGyTu+++O3r16hV777130imJWL58eVx66aVJZwB12McffxwbNmyInXbaKeN7tWzZMlq2bJnxfchPn376afzxj3+MXr16JZ2SdTU1NXHLLbcknZE2ziVyxZAhQ+K8886LTp06JZ1SZ5SUlMSdd96ZtvWGDh0anTt3Ttt6AGwbr8/INWvWrImRI0dG9+7dE9l/+PDhiewLAAAAAAAAAAAAAAAAAAAAAADktzFjxmRtLr0ZZLlh2LBh0bFjx6Qz0i5b15drq2544okn4qijjvK+G7Wwbt26OO+886KmpiZta44YMSKuvfbaOOqoo9K25jdp0qRJtGnTJtq0aZO1Pbfkxz/+cUyaNCn69+8fv//97yOVSiXaQ3rV1+fQ/8k97B4GAAAAAAAAAAAA6qfCpAMAAAAAAAAAAAAAoL4aPXp03HXXXUlnADnEuUA+eemll2L9+vVJZ6TVHXfcEevWrUs6I3GpVCqGDBmSdAYAAAAAAAAAAAAAAAAAAAAAAJCDSktL49RTT40vvvgi6ZQ6Y8CAAbHzzjsnnQEA22TTpk1x/vnnR3V1ddIpibjkkkti5cqVSWcAdVhFRUWMGjUq6QxIi1//+tcxf/78pDOy7oknnohJkyYlnZE2ziVySc+ePWPJkiVJZ9QZv/71r2PVqlVpW+/ll1+OOXPmpG09ALaN12fkoieffDKRfZcuXRpjxoxJZG8AAAAAAAAAAAAAAAAAAAAAACB/vfnmm3HqqadGZWVlVvYzgyw3vPTSS7F+/fqkM9LO9cX/9Ktf/So++OCDpDNyWlVVVXTr1i0j78t20UUXxaZNm9K+bl2w4447xv333x/3339/0imkWX19Dt0S97B7GAAAAAAAAAAAAKh/CpMOAAAAAAAAAAAAAID67Oabb45x48YlnQHkEOcC+aKsrCweffTRpDPSavXq1TFgwICkMxL397//PWbPnp10BgAAAAAAAAAAAAAAAAAAAAAAkKOWLl0aP/vZz2Lp0qVJp9QJbdu2jVGjRkVRUVHSKQCwTcaNGxe//e1vk87IuqFDh8aoUaOSzgDqgeHDhyedAGlRUlIS5513XlRXVyedkjULFiyIG2+8MemMtHMukSuWLVsW3bp1i8rKyqRTct4rr7wSTz31VFrXrK6ujttvvz2tawKwbbw+I9eMHj065s+fn/V9X3jhhUilUlnfFwAAAAAAAAAAAAAAAAAAAAAAyF8vvPBCnH766VFWVpbVfc0gS15ZWVk8+uijSWdkhOuL/1RZWRlnnXVWzJs3L+mUnPXLX/4yRo8enZG1p02blpfv+fLf1q9fHw8++GDSGaRZfX4O/Z/cw+5hAAAAAAAAAAAAoP4pTDoAAAAAAAAAAAAAAOqzmpqa6Nq1a0ydOjXpFCBHOBfIJ/fdd1+sX78+6Yy0evDBB+P9999POiNRN910U9IJAAAAAAAAAAAAAAAAAAAAAABAjpsxY0Ycf/zxsXTp0qRT6oRjjz02XnjhhWjQoEHSKQCwTe655554/fXXk87ImnfffTcuv/zypDOAeuL111+PmTNnJp0BaTF+/Pjo379/0hlZUVNTE47RF2MAARkUSURBVBdddFGsW7cu6ZS0cy6RS95///3o1atXpFKppFNy1pw5c+LSSy/NyNpPP/10TJ8+PSNrA1B7Xp+Ri4YOHZr1PZ977rms7wkAAAAAAAAAAAAAAAAAAAAAAOSvJ554Inr06BFVVVVZ39sMstxw3333xfr165POSDvXF//T4sWL47jjjot58+YlnZJzfvvb38aQIUMyusfAgQPjnXfeyegeueqyyy6LBQsWJJ1BBtTX59AtcQ+7hwEAAAAAAAAAAID6pTDpAAAAAAAAAAAAAACo71auXBkdO3aMadOmJZ1Sa6lUKoYNG5Z0BtRbzgXyxerVq2PAgAFJZ6RVKpWKCy64INauXZt0SiJGjBgRH374YdIZAAAAAAAAAAAAAAAAAAAAAABAHTBjxow47rjjYu7cuUmn1AlnnHFGDBkyJOkMANhmP//5z2PChAlJZ2TcxIkT44wzzoiKioqkU4B6IpVKxT333JN0xnbZsGFDfPbZZ0lnkCPuvvvueOyxx5LOyLi+ffvGmDFjks7ICOcSuWb48OFxxRVXJJ2Rk5YvXx4/+9nPYvXq1RlZv7q6Oi655JJIpVIZWT+T5syZk3QCQNp4fUYuGjZsWNTU1GRtv7lz53rPHAAAAAAAAAAAAAAAAAAAAAAAICvKysrikksuicsuuyyxmYxmkOWG1atXx4ABA5LOSLu6fn3Vh2srF33xxRfeb+x/6Nu3b9x5550Z3yeVSkW3bt1iypQpGd8rlwwcODBGjBiRdAYZUl+fQ7fEPQwAAAAAAAAAAABQvxQmHQAAAAAAAAAAAAAA+WDFihXRsWPHmDFjRtIptfLrX/86nnrqqaQzoF5zLpAvfv/738e//vWvpDPSas6cOXHuuedGdXV10ilZtWjRorjyyiuTzgAAAAAAAAAAAAAAAAAAAAAAAOqQmTNnxo9+9KMYP3580il1wkUXXRT3339/0hkAsE1KSkrixBNPjE8//TTplIyZPXt2dO7cOdavX590ClDPDBs2LCZMmJB0xja77LLLYs6cOUlnkEOuvPLKGDFiRNIZGfPEE0/EAw88kHRGRjmXyDWPP/54/PKXv8y7+fBfZ/369XHKKafE559/ntF93nvvvRg0aFBG90i3OXPmRJ8+fZLOAEgrr8/INQsWLIjRo0dnbb/nn38+a3sBAAAAAAAAAAAAAAAAAAAAAAD5a8qUKXHEEUfEkCFDkk4xgyxH/P73v49//etfSWekXV2+vurLtZWLvvjiizjuuONi5syZSackqrq6On71q1/Ffffdl7U9S0pK4pRTToklS5Zkbc8kjRgxIq677rqkM8iw+vocuiXuYQAAAAAAAAAAAID6ozDpAAAAAAAAAAAAAADIF8uWLYtjjjkm3n777aRTvlJNTU1cc8018fDDDyedAnnBuUA+SKVS0bNnz1i1alXSKWn1zjvvxCWXXBKpVCrplKyorKyM8847r979dwQAAAAAAAAAAAAAAAAAAAAAADJv5cqV0bFjxxg6dGjSKXXCddddF3379k06AwC2ydq1a+OnP/1pTJ48OemUtPvkk0/i+OOPjxUrViSdAtRDqVQqfvGLX0RlZWXSKVtt8ODB8fzzzyedQY5JpVJxwQUXxHPPPZd0StoNHz48fvGLXySdkXHOJXLRH/7wh+jatWuUlZUlnZK4RYsWRYcOHeLjjz/Oyn59+vSJDz/8MCt7ba+Kioo499xzY+3atUmnAKSV12fkoieffDJrew0fPjxrewEAAAAAAAAAAAAAAAAAAAAAAPmnuro6Hn744TjqqKNi2rRpSedEhBlkuSKVSkXPnj1j1apVSaekVV29vurTtZWrFixYEEceeWS8+uqrSackYs2aNXHSSSfFY489lvW9FyxYECeccEIsXLgw63tn0wsvvBAXXHBBpFKppFPIsPr6HPpV3MMAAAAAAAAAAAAA9UNh0gEAAAAAAAAAAAAAkE9WrVoVJ510UvTv3z9qamqSzvmSjRs3RpcuXeKhhx5KOgXyinOBfDBnzpw488wzo7y8POmUtHrqqaeid+/eUV1dnXRKRlVXV8fPf/7zGDt2bNIpAAAAAAAAAAAAAAAAAAAAAABAHVVeXh69e/eO8847L9avX590Ts675557onfv3klnAMA2WbVqVbRv3z5GjhyZdEravPDCC9GhQ4dYtGhR0ilAPfbJJ5/ENddck3TGVnnllVfiiiuuSDqDHFVVVRXnn39+3HbbbUmnpM3jjz8e559/fqRSqaRTssK5RC4aNWpUHH300TFjxoykUxIzefLkaNeuXfz73//O2p4VFRXRpUuXWLx4cdb23BY1NTVx4YUXxscff5x0CkBGeH1Grhk5cmSsWrUq4/tMmTIlpk6dmvF9AAAAAAAAAAAAAAAAAAAAAACA/PTWW2/FIYccEldffXVs2rQp6ZwvMYMsN8yZMyfOPPPMKC8vTzolrera9VUfr61ctX79+jjrrLPihhtuiOrq6qRzsuaTTz6JH/3oRzF69OjEGqZPnx7t27evtzOYH3vssejRo0dUVVUlnUKW1Nfn0K/iHgYAAAAAAAAAAACo+wqTDgAAAAAAAAAAAACAfJNKpeKOO+6ITp06xcKFC5POiYiICRMmxI9+9KMYNWrU5s8VFBSkdY98GgIOWytfz4UIZ0M+ee+99+K0006L9evXJ52SVsOGDYtTTz01SkpKkk7JiPLy8rjgggvipZdeSjoFAAAAAAAAAAAAAAAAAAAAAACoB0aMGBGHHHJIvPnmm0mn5Lw//OEP0bVr16QzAGCbbNiwIbp27Rr9+/ePVCqVdM42S6VScfPNN0f37t2jrKws6RwgDzz22GMxaNCgpDNq5ZVXXolzzz3XnGm+0S233BIXXnhhbNy4MemUbVZdXR033nhjXH755XX6tc22cC6Ri/7973/H4YcfHk899VTSKVmVSqXi0UcfjXbt2sWiRYuyvv+SJUuiU6dOsXTp0qzvXRupVCouvvji+NOf/pR0CkBGeX1GLqmsrIxnn3024/sMHz4843sAAAAAAAAAAAAAAAAAAAAAAAD5Z+rUqXHyySfHSSedFNOmTUs65yuZQZYb3nvvvTjttNNi/fr1SaekVV25vurztZXL7r///jjhhBNi1qxZSadkVHV1ddx5553Rrl27mD17dtI5sWDBgjjmmGNizJgxSaekTXl5eVxyySXxq1/9Ku9mvVN/n0O/insYAAAAAAAAAAAAoG4rTDoAAAAAAAAAAAAAAPLVu+++G/vvv3/cfffdsWnTpkQaSktL4ze/+U20a9cuPvvssy/92g477JDWvcrKytK6HtRH+XYuRDgb8s3o0aPj2GOPjfnz5yedklZvvfVWHHXUUTFhwoSkU9JqyZIlcdxxx8Xzzz+fdAoAAAAAAAAAAAAAAAAAAAAAAFCPzJ8/P04++eTo3r17LFmyJOmcnNWgQYN4/vnno2PHjkmnAMA2u+OOO+KEE06IGTNmJJ2y1aZMmRIdOnSI22+/PekUIM9cccUVMXjw4KQzvtYjjzwS3bt3j+rq6qRTqCOeeeaZOPTQQ2P8+PFJp2y1FStWxEknnRT33ntv0imJcS6Ri0pLS+Piiy+OTp061cnfb2ythQsXRufOnePKK69M9D0epk+fHscee2wsXLgwsYYtqaioiF69esXTTz+ddApAVnh9Ri4ZMmRIxvcYMWJExvcAAAAAAAAAAAAAAAAAAAAAAADyQ01NTbz22mtx4oknxsEHHxxvvvlm0km1YgZZbhg9enQce+yxMX/+/KRT0irXr698uLZy2T//+c846KCDol+/flFaWpp0Ttp9+OGH8eMf/zh++9vfRlVVVdI5m61atSo6deoU/fr1y6mubTFx4sQ4/PDDszK/kNxVX59Dv4p7GAAAAAAAAAAAAKDuKkw6AAAAAAAAAAAAAADyWWlpafTr1y9at24dDz30UGzYsCFr+z7wwAPRsmXLuOeee6KmpuZ/fU1RUVFa9ywrK0vrelBf5dO5EOFsyEeffvppHHTQQTFo0KBIpVJJ56TNzJkz4+ijj46bb765XlzXI0aMiLZt28YHH3yQdAoAAAAAAAAAAAAAAAAAAAAAAFBPvfDCC/GDH/wgfvOb38TatWuTzslJRUVF8ec//zkOP/zwpFMAYJu9++67ccghh8RNN91UJ2Y2lpWVxY033hiHHXZYvP/++0nnAHnqF7/4RfTr12+Ls6KTtH79+jj33HPjqquuiqqqqqRzqGM+//zz6NChQ9x4442xfv36pHNqZeTIkXHggQfG6NGjk05JnHOJXPX3v/89DjnkkLj22mtj+fLlSeekXUlJSdx0002x3377xTvvvJN0TkREzJo1K4488sj45z//mXRKREQsXLgwfvKTn8TTTz+ddApAVnl9Rq6YPHlyTJgwIWPrf/DBBzF37tyMrQ8AAAAAAAAAAAAAAAAAAAAAAOSHxYsXx8CBA2PfffeN008/vU7OnDWDLDd8+umncdBBB8WgQYMilUolnZM2uXh95du1lcsqKyvj7rvvjgMOOCBefPHFenHtL168OHr16hXt2rWLjz76KOmcLUqlUnH33XdHhw4dYtKkSUnnbLWSkpK49tpr40c/+lF89tlnSeeQA+rrc+hXcQ8DAAAAAAAAAAAA1E2FSQcAAAAAAAAAAAAAABFLliyJa665Jr7//e/H5ZdfHmPHjs3IIPUPP/wwrrzyymjRokVcf/31sWLFiq/82iZNmqR1702bNqV1Pajv8uFciHA25KuNGzfGFVdcEUcccUSMHDmy3gxzr66ujttvvz3222+/ePbZZ6O6ujrppK02efLkOPnkk+O8886L5cuXJ50DAAAAAAAAAAAAAAAAAAAAAADUc2VlZXHPPfdEq1aton///rFkyZKkk3LOt771rXjzzTdjv/32SzoFALZZZWVl3HXXXbH//vvHww8/HKWlpUkn/S/V1dXx3HPPxYEHHhj33ntvVFVVJZ0E5Lm77747Tj755FiwYEHSKRER8Ze//CUOPfTQePHFF5NOoQ6rqamJe++9N37wgx/EI488EpWVlUknbdHcuXOjS5cu0bVr11i5cmXSOTnDuUSuqqysjIEDB0bLli3j+uuvz5lrdHusWbMm7rvvvmjdunXcddddUVZWlnTSlyxbtixOOOGEuPvuuxP9vdPIkSPj8MMPjw8//DCxBoAkeX1GrnjyyScztvbw4cMztjYAAAAAAAAAAAAAAAAAAAAAAFC/TZ48OW6//fY46qijolmzZnHttdfGnDlzks7aLmaQ5YaNGzfGFVdcEUcccUSMHDkyUqlU0klpkUvXV75eW7luwYIFce6558YBBxwQf/jDH3Jubm5tzJ07N37xi19Eq1at4o9//GPSObXywQcfxGGHHRb/5//8n1i6dGnSOd9o06ZN8eCDD8a+++4bAwcO9P4vfEl9fQ79Ou5hAAAAAAAAAAAAgLqlMOkAAAAAAAAAAAAAAOD/t2HDhnj88cfj2GOPjaZNm0bPnj1j8ODBMXHixNi0adNWrVVRURHTp0+PYcOGRa9evaJly5bRrl27ePTRR2PVqlXf+Pg99thjW7+NLSotLU3repAv6vO5EOFsyHcTJ06Mrl27xiGHHBIPPPBALFmyJOmktFi4cGFccMEFsd9++8Xjjz8eGzZsSDrpG3300Udx1llnxQ9/+MN48803k84BAAAAAAAAAAAAAAAAAAAAAADyzNq1a+OOO+6IFi1axPnnnx/vvvtupFKppLO+1qRJk+L666+PQw89NGbMmJHRvXbfffd45513olmzZhndBwAybcGCBXH11VfHXnvtFf3794+lS5cmnbR5/mubNm3i/PPPj3nz5iWdBLDZ22+/HQceeGA8+OCDUV5enkjD5MmT46c//WmceeaZMXfu3EQaqH9WrFgRV111VRxwwAHx4IMPxtq1a5NOioiIRYsWxdVXXx1t2rSJP//5z0nn5CTnErmsrKwsHnjggWjZsmWcfvrp8de//jWqqqqSztoqn3zySfTu3TuaNm0affv2rdX7SCSluro6+vXrF23bto1x48Zlde9Zs2ZF586do2vXrrFixYqs7g2Qa7w+Ixc8//zzUVZWlvZ1a2pq4oUXXkj7ugAAAAAAAAAAAAAAAAAAAAAAQP1TUlISY8aMifvuuy/OOeecaNGiRfzwhz+Mm2++OSZMmJB0XlqZQZY7Jk6cGF27do1DDjkkHnjggViyZEnSSdst6evLtVU3zJw5M375y19G8+bN45Zbbsn5/1bV1dXxxhtvxNlnnx377LNPDB48OCoqKpLO2iqpVCqGDRsW++yzT1x11VUxa9aspJP+l/nz50f//v2jVatW0adPn1i+fHnSSeSw+vgc+nXcwwAAAAAAAAAAAAB1xw5JBwAAAAAAAAAAAAAAW7Zs2bIYPnx4DB8+PCIiCgoKokWLFvH9738/vve970Xjxo2juLg4GjRoEFVVVbFx48bYsGFDlJSUxLx582LhwoWRSqW2ef+mTZum61uJiIjFixendT3IR/XtXIhwNvD/TJ06Na6//vq44YYb4phjjomOHTvGCSecEO3atYvi4uKk87bZnDlz4vLLL4/rrrsuunXrFj179ozjjz8+GjVqlHRaREQsXLgwXnzxxRg6dGhMmTIl6RwAAAAAAAAAAAAAAAAAAAAAAICoqqqK5557Lp577rlo1qxZ9OjRI84666xo165dNGjQIOm8mD17drz44ovx7LPPxmeffbb58yeeeGKMHz8+mjVrlrG9W7RoEW+//XZ06NAh1qxZk7F9ACAb1qxZE3fccUfceeed0aFDh+jWrVucffbZGX0u/U/V1dUxZsyY+NOf/hQjRoyIDRs2ZGVfgG2xYcOG6NOnT9x3331x4403xkUXXRTf/va3M7pnTU1NvPHGG/HII4/EW2+9ldG9yG9z5syJPn36xE033RQ///nP46KLLor27dtn/c8A/vnPf8YTTzwRf/rTn6KysjKre9dFziVyXU1NTbz22mvx2muvxW677RZnnHFGdOvWLTp27BiNGzdOOu9LUqlUfPjhh/Hyyy/Hq6++GrNnz046aatNnTo1fvKTn0SnTp3ipptuihNOOCFje02cODEGDhwYI0aMcF4D/Aevz0haSUlJvPLKK9GzZ8+0rvvuu+/G0qVL07omAAAAAAAAAAAAAAAAAAAAAABQN9TU1ERZWVmUlpZ+6Z+rV6+OL774IhYsWBDz58+PBQsWxLx582LWrFlJJ2eVGWS5ZerUqXH99dfHDTfcEMccc0x07NgxTjjhhGjXrl0UFxcnnbfVsn19ubbqrlWrVsVtt90Wt912W7Rt2zbOPvvsOPvss6NNmzZJp0VVVVW89957MWrUqBg+fHgsWbIk6aS02LhxYzzyyCPxyCOPROfOnePSSy+Nk046KZo0aZJIT0VFRYwaNSoGDx4c77zzTqRSqUQ6qLvq23PoN3EPAwAAAAAAAAAAAOS+glQtf6qyoKAg0y0AAAAAAAAAAAAAQA554YUX4pxzzknber17946hQ4embT0g+9J9LkQ4G/h6BQUF0apVqzjwwAOjTZs20bRp09hzzz1jzz33jF133TWKioqiqKgodtxxx2jQoME279O3b9945pln0lj+1Xbaaac48cQT47jjjosOHTpE27Ztt6t9ayxbtiw++uij+Oc//xlvvPFGTJ06NSv7AgAAAAAAAAAAAOSKWo5l3yKz2gEAAAAAAAAgWTvvvHN06tQpTjjhhDjqqKOibdu2UVRUlNE9U6lUTJ48OcaOHRv/+Mc/YuzYsbF06dKv/Po2bdrEuHHjYrfddsto1wcffBAnnHBClJaWZnQfAEhC27Zt45prrol27drF/vvvn7af36uuro7p06fH+PHj4+23346//e1vsXr16rSsDZBtRUVFceaZZ8Y555wTnTp1il133TUt61ZWVsa4cePir3/9a7z44osxb968tKwLW2u33XaLk08+OU4//fQ4+uijY++99077Hps2bYrx48fHn//85/jLX/4Sc+fOTfse+cS5RF3RsGHDOOqoo+L444+PY445Jg499NBo1qxZVhs2bdoUH3/8cbz//vsxbty4GD9+fKxYsSKrDZnWpk2b6NGjR3Tv3j3233//7V5vwYIF8frrr8fw4cNj7NixaSgEqP+8PiMJr776anTp0iWta15yySUxZMiQtK4JAAAAAAAAAPnOrHYAAAAAAAAAAACA+skMstxUUFAQrVq1igMPPDDatGkTTZs2jT333DP23HPP2HXXXaOoqCiKiopixx13jAYNGmzzPn379o1nnnkmjeVflonry7VVv+27777Rvn37OProo6Ndu3ZxyCGHxA477JDRPSsrK2PixInxr3/9K9577714++23Y+3atRndM1c0atQoOnXqFF26dIkOHTrEAQccEIWFhRnZK5VKxaeffhqjR4+Od955J8aNGxdlZWUZ2Yv8Vl+eQ2vDPQwAAAAAAAAAAACQPbWZ1V6QquVEd8PbAQAAAAAAAAAAACC/TJkyJQ466KC0rXfSSSfFW2+9lbb1gOxL97kQ4WyAoqKiOOCAA+Lggw+OAw44IJo3bx4tWrSI73//+7HLLrtsHlZfG+vWrYuVK1fGqlWrYvny5TFnzpyYPXt2fP755zFp0qRYtGhRhr8bAAAAAAAAAAAAgNxWy7HsW2RWOwAAAAAAAADklh122CEOOuig2G+//WKfffaJ/fbbL5o3bx7f/e53Y/fdd4/vfve70ahRo698fGVlZWzcuHHzx6JFi+Lzzz/f/DFnzpyYNWtWlJSUbFVXu3bt4u9//3s0btx4e7/Fr3XrrbfG7373u4zuAQBJ22mnnaJly5ax9957x9577x0tW7aMPfbYI4qLi6Nx48ZRXFwcTZo0iR122CFqamqivLw8ysvLY82aNbFixYpYsmTJ5rmMU6ZMibKysqS/JYC0KygoiMMOOywOO+ywOPTQQ6NNmzbRtGnTaNq0aeyyyy5bfExpaWmUlJTEvHnzYtq0aTFt2rSYOnVq/OMf/4iNGzdm9xuAWth9993jiCOOiLZt20bLli2jRYsW0aJFi2jatGk0adLka3//v3r16li2bFksWrQopk+fHtOnT4+PPvooJk6cGJWVlVn8LvKHc4m6Zrfddosf/vCH0bp162jVqlW0bNky9tprr9htt902f9T2z/oqKytj/fr1sWzZsli+fHmsWLEili1bFjNnzowZM2bEjBkzYv78+dv1d5zqmqZNm8YxxxwT7du3j3333TdatWoVe++9dzRp0uR/fW1ZWVmsW7cuZs6cGVOnTo0pU6bE2LFjY/LkyQmUA9QfXp+RDTvssEOsXr06vvWtb6VtzfLy8thzzz1j3bp1aVsTAAAAAAAAADCrHQAAAAAAAAAAACAfmEFGJv339dWrVy/XFrVWXFwchx56aLRu3Xrze5D898cuu+wSjRs3jsaNG0fDhg2/co2qqqpYuXJlLF++PJYvXx5Lly6NGTNmxMyZM2PmzJkxbdq0KC8vz+J3lbt22mmnOOyww+KII46I1q1bR/PmzaNFixbRvHnz2GmnnaK4uPgrH1tVVRXr16+PDRs2xNq1a2P27NmbZyzPnDkzPvvss1izZk0WvxvIP+5hAAAAAAAAAAAAgMypzaz2glQtJ7ob3g4AAAAAAAAAAAAA+WPnnXeONWvWRGFhYdrWPPjgg2Pq1KlpWw/IrkycCxHOBqiNhg0bRqNGjTb/879VVlZGRUVFVFRURGVlZYKFAAAAAAAAAAAAAHVDLceyb5FZ7QAAAAAAAABQ9xQWFkZRUVEUFRVtnuFUXl4eGzdujKqqqozt27lz5xg1alQ0bNgwI+s/88wzcfHFF0d1dXVG1gcAAOqHgoKCKCoqiuLi4mjYsGGUlZXFxo0bo6amJuk0SKvCwsIoLi6O4uLiKCwsjMrKyti0aVOUl5e73nOMc4m6qqCgYPOc+EaNGsUOO+wQEf/v7yqVl5dv/qD2CgoKori4OBo3bhzV1dVRUlLizzsBEuD1Gely6qmnxmuvvZbWNV9++eXo1q1bWtcEAAAAAAAAAMxqBwAAAAAAAAAAAMh3ZpCRKa4t0qFBgwabZ44XFBRERUXF5vm/rqX02nHHHaNx48ab5y1XVVXF+vXro7KyMuEyoDbcwwAAAAAAAAAAAADbpjaz2gtStZzobng7AAAAAAAAAAAAAOSPU045JV5//fW0rVdZWRk77bRTVFRUpG1NILvSfS5EOBsAAAAAAAAAAAAAgOyq5Vj2LTKrHQAAAAAAAADYGj169Ijhw4en/WcOHnzwwejTp09a1wQAAAAAAADYVi+99FKcffbZaV3zjDPOiFGjRqV1TQAAAAAAAADArHYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAID/VZlZ7YRY6AAAAAAAAAAAAAIA65qyzzkrrep999llUVFSkdU0gu9J9LkQ4GwAAAAAAAAAAAAAAAAAAAAAAAID6acSIEXH11Vendc1+/fpFnz590romAAAAAAAAwLb6zne+E6effnpa11y1alX89a9/TeuaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAF+nMOkAAAAAAAAAAAAAACC37LjjjtG1a9e0rjlx4sS0rgdkVybOhQhnAwAAAAAAAAAAAAAAAAAAAAAAAFB/PfLII3Hbbbdt9zrV1dVxySWXxN13352GKgAAAAAAAID06Nu3bzRq1Citaz7//PNRVVWV1jUBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAvk5h0gEAAAAAAAAAAAAAwP9z4IEHRqtWrZLOiAsvvDB22223tK758ccfp3U9yBf1+VyIcDYAAAAAAAAAAAAAAAAAAAAAAAAA9dstt9wSjz/++DY/vry8PLp16xZDhgxJYxUAAAAAAADA9vne974XV111VdrX3Z7/vwoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwLQqTDgAAAAAAAAAAAAAAIs4///z46KOP4sUXX4yGDRsm1lFcXBz9+/dP+7rvvPNO2teE+q6+nwsRzgYAAAAAAAAAAAAAAAAAAAAAAACg/rviiivixRdf3OrHlZSUROfOnWPkyJHpjwIAAAAAAADYDoMGDYri4uK0rvnee+/F1KlT07omAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwDcpTDoAAAAAAAAAAAAAAPJZo0aN4g9/+EM888wz0bhx4zjiiCPioYceSqzn1ltvjebNm6d1zXnz5sWMGTPSuibUZ/lwLkQ4GwAAAAAAAAAAAAAAAAAAAAAAAID8kEqlomfPnjF69OhaP2b58uVx3HHHxT/+8Y8MlgEAAAAAAABsveuuuy66dOmS9nUHDRqU9jUBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAvklh0gEAAAAAAAAAAAAAkK9atWoV48ePj8suu+xLn7/88svjv/7rv7Lec+KJJ8YNN9yQ9nXfeOONtK8J9VW+nAsRzgYAAAAAAAAAAAAAAAAAAAAAAAAgf1RWVkaXLl3io48++savnTt3brRv3z4+/fTTzIcBAAAAAAAAbIXf/OY3cd9996V93RUrVsRLL72U9nUBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAvklh0gEAAAAAAAAAAAAAkI/OOOOM+OSTT+Lwww/f4q/feuut8bvf/S5rPUcffXS88sorUViY/h8xfvXVV9O+JtRH+XQuRDgbAAAAAAAAAAAAAAAAAAAAAAAAgPyycePGOPnkk2PGjBlf+TWTJ0+O9u3bx+eff57FMgAAAAAAAICvd9hhh8Ubb7wRd911VxQUFKR9/f/7f/9vlJeXp31dAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgG9SkEqlUrX6wgy82TsAAAAAAAAAAAAA5JsGDRrEnXfeGTfccEOtfkZ35MiR0atXr1i3bl3Gms4999wYNmxYNG7cOO1rz5s3L1q1apX2daE+ybdzIcLZAAAAAAAAAAAAAAAko5Zj2bfIrHYAAAAAAAAAIF2aN28e77//fuy1115f+vy4cePitNNOy+isOQAAAAAAAIDa2HnnneOAAw6ITp06xemnnx4//vGPM7ZXaWlpNG/ePFavXp2xPQAAAAAAAAAAs9oBAAAAAAAAAAAAAAAAAAAAAAAAAAAAgPxUm1ntO2ShAwAAAAAAAAAAAACIiO9973vxpz/9KY499thaP6ZLly4xe/bs6NevXwwbNiyqq6vT1rPXXnvF/fffH927d0/bmv/T4MGDM7Y21Af5eC5EOBsAAAAAAAAAAAAAAAAAAAAAAACA/LVgwYL42c9+FuPGjYvddtstIiJee+21OOecc2LTpk0J1wEAAAAAAAD1WY8ePaJnz55f+lxBQUEUFRVFkyZNokmTJvG9730v9thjj6w1DRkyJFavXp21/QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD+U0EqlUrV6gsLCjLdAgAAAAAAAAAAAAD11vHHHx8jRoyIPffcc5vXWLZsWTz11FPx6quvxoQJE6K6unqr12jQoEF07NgxLrzwwujRo0c0bNhwm3u+SUVFRbRo0SKWLVuWsT2gLsvHcyHC2QAAAAAAAAAAAAAAJKeWY9m3yKx2AAAAAAAAACDd2rVrF3/729/ipZdeit69e2/TPDkAAAAAAACArXHLLbfEgAEDks7YrKysLH7wgx/EkiVLkk4BAAAAAAAAgHrPrHYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIB/VZlZ7QaqWE90NbwcAAAAAAAAAAACAbdOvX7+47bbbokGDBmlbc+PGjfHxxx/H559/HnPnzo2lS5dGaWlplJaWRkVFRURENGzYMBo3bhy77757tGrVKn74wx/GUUcdFTvttFPaOr7OI488EldddVVW9oK6Jl/PhQhnAwAAAAAAAAAAAACQnFqOZd8is9oBAAAAAAAAgEw44IADYvr06UlnAAAAAAAAAHnilltuiQEDBiSdsdl9990Xffv2TToDAAAAAAAAAPKCWe0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQD6qzaz2glQtJ7ob3g4AAAAAAAAAAAAAW2fXXXeNZ599Nk455ZSkU7Ju48aN0bp161i+fHnSKZBT8vlciHA2AAAAAAAAAAAAAADJquVY9i0yqx0AAAAAAAAAAAAAAAAAAKjrbrnllhgwYEDSGRERUVJSEi1btow1a9YknQIAAAAAAAAAecGsdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgH9VmVvsOWegAAAAAAAAAAAAAgLxz5JFHxksvvRR777130imJGDhwYCxfvjzpDMgp+X4uRDgbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACI6N+/f6xZsybpDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACDPFSYdAAAAAAAAAAAAAAD1zdlnnx3vvfde7L333kmnJGLGjBlxxx13JJ0BOSXfz4UIZwMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABETJ06MRx99NOkMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgChMOgAAAAAAAAAAAAAA6ptPP/00Kioqks5IRHV1dVxwwQWxadOmpFMgp+TzuRDhbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIKKqqiouu+yyqKmpSToFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAqTDgAAAAAAAAAAAACA+ubzzz+PX//610lnJOL222+Pjz76KOkMyDn5fC5EOBsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIjo379/TJgwIekMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIiIKEw6AAAAAAAAAAAAAADqo6FDh8bIkSOTzsiqF198Mf7rv/4r6QzIWfl4LkQ4GwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiHj77bfjnnvuSToDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYLPCpAMAAAAAAAAAAAAAoL7q1atXfPrpp0lnZMX7778fF1xwQdIZkPPy6VyIcDYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAxZcqU6N69e9IZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAF9SmHQAAAAAAAAAAAAAANRX69atixNPPDGmT5+edEpGTZgwIU4//fQoLy9POgVyXr6cCxHOBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIr744ovo3LlzrF27NukUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgC8pTDoAAAAAAAAAAAAAAOqzlStXRqdOnWLu3LlJp2TE6NGj4/jjj4/Vq1cnnQJ1Rn0/FyKcDQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARHz22WfRoUOHWLx4cdIpAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP9LYdIBAAAAAAAAAAAAAFDfLV68OH784x/H2LFjk05Jq6effjpOOeWU2LhxY9IpUOfU13MhwtkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDE3/72t2jfvn0sWLAg6RQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACALSpMOgAAAAAAAAAAAAAA8sGyZcuiY8eO8fvf/z7plLQ4//zz46KLLorKysqkU6DOqm/nQklJibMBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACDPbdq0Ka655pr46U9/GuvWrUs6BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOArFSYdAAAAAAAAAAAAAAD5orq6Oq677ro4++yzY9GiRUnnbLO///3v8dxzzyWdAfVCfToX2rZt62wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMhTNTU18eyzz8aBBx4YDz30UNI5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN+oMOkAAAAAAAAAAAAAAMg3r7zySuy7775x6623RmlpadI5tTZt2rQ47bTTolOnTkmnQL1TH86FuXPnJp0DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECWrV69Oh5++OE4+OCD44ILLvCeVgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECdUZh0AAAAAAAAAAAAAADko7Kysvjd734X++67bzz22GOxbt26pJO+0kcffRQXXnhhHHLIIfH6668nnQP1lnMBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBcV11dHZMnT44HH3wwTj311Pj+978fV199dUybNi3pNAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICtUpBKpVK1+sKCgky3AAAAAAAAAAAAAEDeKi4ujm7dusUll1wSxx57bNI5sXLlyvjLX/4SgwYNigkTJiSdA3nJuQAAAAAAAAAAAAAAkF61HMu+RWa1AwAAAAAAAAAAAAAAAAAAdd0tt9wSAwYM2OKvVVZWbv4oKyuLNWvWxNq1a2PNmjWxYMGC+OKLL2L+/PkxderUmDZtWpSXl2e5HgAAAAAAAADYHma1AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAD5qDaz2gtStZzobng7AAAAAAAAAAAAAGRH8+bN4/jjj4+OHTvGcccdF61bt874nhUVFfHvf/87/va3v8Vf/vKXGD9+fK1+IBnIDucCAAAAAAAAAAAAAMD2256fiTarHQAAAAAAAAAAAAAAAAAAAAAAAAAAAACoq8xqBwAAAAAAAAAAAAAAAAAAAAAAAAAAAADyUW1mtRekajnR3fB2AAAAAAAAAAAAAEhG8+bN46CDDorWrVvHPvvsE61bt44f/OAHseuuu0aTJk2iSZMm0bBhw69do6amJsrKymL16tWxYMGCzR8zZsyICRMmxJQpU6KqqipL3xGwvZwLAAAAAAAAAAAAAABbr5Zj2bfIrHYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoK4yqx0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAyEe1mdVekKrlRHfD2wEAAAAAAAAAAAAgdzVo0CCaNGkSO+6445c+X15eHqWlpVFZWZlQGZAU5wIAAAAAAAAAAAAAwJfVciz7FpnVDgAAAAAAAAAAAAAAAAAAAAAAAAAAAADUVWa1AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAD5qDaz2gtStZzobng7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAFBX1XIs+xaZ1Q4AAAAAAAAAAAAAAAAAAAAAAAAAAAAA1FVmtQMAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+ag2s9oLs9ABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOaEw6QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADIlsKkAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBbCpMOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgGwpTDoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsqUw6QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADIlsKkAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBbCpMOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgGwpTDoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsqUw6QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADIlsKkAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBbCpMOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgGwpTDoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsqUw6QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADIlsKkAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBbCpMOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgGwpTDoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsqUw6QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADIlsKkAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBbCpMOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgGwpTDoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsqUw6QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADIlsKkAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBbCpMOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgGwpTDoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsqUw6QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADIlsKkAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBbCpMOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgGwpTDoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsqUw6QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADIlsKkAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBbCpMOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgGwpTDoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsqUw6QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADIlsKkAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/j9255gGAAAAAdBm/9C20AcSAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMruHNMAAAAgANrsH9oW+kACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AQNm773C5rvJe/N8zOipWsSVZsuWq4t67bAOuFNu0S3MghEtJSEhCEgKk3NzkFxJu2k1CbsoNISQkIQm9hWZMMRj3XoSrbLnJvan3cn5/DLoYI53ZM7On7fl8nuc8lnTeWWvtWWuv9a619wMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANAttV43AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALql1usGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQLfUet0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA6JZarxsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3VLrdQMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgW2q9bgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB0S63XDQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBuqfW6AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANAttV43AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALql1usGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQLfUet0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA6JZarxsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3VLrdQMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgW2q9bgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB0S63XDQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBuqfW6AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANAttV43AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALql1usGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQLfUet0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA6JZarxsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3VLrdQMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgW2q9bgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB0S63XDQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBuqfW6AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANAttV43AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALql1usGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQLfUet0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA6JZarxsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3VLrdQMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgW2q9bgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB0S63XDQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBuqfW6AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANAttV43AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALql1usGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQLfUet0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA6JZarxsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3VLrdQMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgW2q9bgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB0S63XDQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBuGe11AwAA6C9TZya//IlisX/5io42BQCAISEH7X/6CKD/LToled0fNI57/J7kP3+9w42hZ4wDqDb3OAAAdJacGwaHZ1cAAAwKe00AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADob6O9bgAAAP2nNqHXLQAAYNjIQfufPgLof0Xm6lqt8+2gt4yDxk54VbL4DY3jtm1O/vnnO98eaIZ7HGAwyDcABpecGwaHZ1dAYv8FwGCw14Sdk8sBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD9YLTXDQCgHHMXJqOTOlP22FiybUv9Z+PaZP2qJGOdqQsAAAAAAKCTJk9L9ti7cdzWzZ1vCwBQTfINAACA7rD/AgAYXHI5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgH4z2ugEAlOOVv53MXdCdusa2J+tWJs8+nDzzUPLY3cnDtyUrH+tO/QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArRrtdQMAGDwjtWT67PrPgccmJ7yy/u+rnkjuvjy547vJk/f1to0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADsz2usGAFAde+ydLH5D/Wf5bcm1n0nuu77XrQIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+JHRXjcAgGo64Oj6z4O3JN/+v8mzD/e6RQDAy3412e+oxnGX/1ty7zUdbw4AAMDAsr8CAIqSN0D3uN+AfmJOAgAAesmeBAAAaJX9BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDZrTXDQCg2uYfn7zt75PvfTS55eu9bg0ADLfd907mLmgcN3l6x5sCAAAw0OyvAICi5A3QPe43oJ+YkwAAgF6yJwEAAFplPwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAsKn1ugEAVN/EycnLfjV5ybuTjPS6NQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAMKv1ugEADI8TX5Wc/+u9bgUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMMxqvW4AAMPl2POS03+6160AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIbVaK8bAEB3bdmYrH22uc9MGE0m7pZM2q3+53a98C3Jgzcnj97VflkAAAAAAADNeHZ5cvfljeO2bet8WwCAapJvAAAAdIf9FwDA4JLLAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/WC01w0AoLuW35Z8/vda//zUPZI95yd7LUwWLU4OPC6Z0ORqUpuQnPee5F9/OclY620BAAAAAABo1tIr6z8AAJ0i3wAAAOgO+y8AgMEllwMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPrBaK8bAMBgWb8qWb8kWb4kufHLyeRpyfGvSE69MJkyo3g5cxcmR5yV3Hlpx5oKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPATar1uAACDbdO65NrPJv/49uTea5v77Amv6kiTAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB2qdbrBgBQDZvWJV/8g2TJxcU/s/9Rycx9OtYkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICfUOt1AwCokLHk23+fPPNQ8Y/MP6FzzQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeL5arxsAQLVs25Jc+rHi8Qcc07m2AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA832ivGwBA9dx/Y7JxTTJlRuPY2ft3vj07TNwt2X1uMnFK/WeklmzbkmzdmKxflax5JslY99rTspFk+uxk0tRk8tT6tYyNJZvWJZvWJutXJ1s29LqRjU2bnUyZXr+OiVOS7VuTzeuTTeuT9SuTLRt73cLBNH1OMmVaMnl6MmFisnVTsnlDsvbpZOPaXreuf/3E97ax/r2tX1Ufj/SXCRPrc8ik3eo/o5Pr/75tS7J1c7JxdbL22frfqa7KrOtDRJ/1iQrkklUaS1W5lirnoPqIHexh6UfGJYOmqmO2qtdFf5kwsZ6XTppa/xmp1XO6LRuT1U/W93TQqtqEZI+96/uFHfueQRtfzowrogLnVslw5AbWpWrSr/1t0M8pJ01NJk+r/0yZltQmJmPb6/Pj5vX1M8oNq3vdShoZb41b9XivW9fnRur38G4z6t9dbbR+Rr9pXT0/GKQ5dtDno06zNynOs6vBM+j54jDcnyO1H53xTNqt/m9bNtbX6jVP1furU6bPqa9zk6fV17ltW+p7+NVP1d8nH3oVOfMom7yCZhgv3Tfe2v/U/b1u3fiGYd0fJFW+fwc9R2bweAY1uPeV/Vp7rCUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQDeM9roBAFTP9q3Jw7cnB5/WOHbmvA41YiQ54OhkwUnJvocnex2U7DZj/I9s25qseCR55M7koVuSe69NtmzoUPuaMGVGsuiUZMEJyZwFyZ4HJhMnj/+ZFY8mj9+TPHxbctdlyYZVXWnqLo1OThaeVL+OvRYle85PJk3ZdfzYWLL6yeSp+5NH7kjuuTp5dnn32tuuPeYlex+cTJuVTJ6WTNrtJ2Ou/WyyaV37de17eHLoGT8c54t2XtcO61cmjy1NHrgxWXplsubp9usfVM18bxvXJE89kDxwU3LvNfVxSXfN2jc5+PRkvyOTOfPrfx+pNf7c6ieTJ+9Llt+W3H9D8vQDHW9qKbo5hwyMCq3rjVSq/5/Xb/OPHz98UPus3w18Llml+79C11LlHPSAY/RRv/dRNwzbHraqKpVX/dCOsXnaG41L+l9V59KqXhf9pzZa38cd+sJk3yOS2fsntQm7jl+/Knns7voZ5t1XJGvldDQw/4Tk4FPr/x3E8TVsZ8ZVNfDnVhme3MC6VE36tY8N+FnySC1ZcGJ9nd7n0GTeocluuzf+3IbVydMPJk8uS+67Pnnw1vr7R/RGs2vcqicGb33rtAOOSQ5anBx4fOM8Z/VTyRP3Jg/enNx9ebJuRdeaOb4Bn4+6wd6kOM+uBs+g54vDcn/OmZ8ccXZ93Z6zIBmdtPO4se3JysfrfXTPVfV8a8vG1uudMSc5/MzkoFPr68OU6buO3bC6vi7cf319nVvf4718N7Rz5vGdD/f+vKMj5BU0Y4jGSz+919DM2m/dZ5cqfv8Oeo5Me7o9Z3sGtXODdF/Zr7Wo4mtJ8uPj/uiXVmfMAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMCgGxkbGxsrFDgy0um2ANCGd3wkmbugcdx9NySf/72ONycv+7Xk+Jc3jhvbnvxFgbiipu+ZnPSa5KgXJ9Nnt1fW1s3JJ96bPLGslKY17eDTk5Nfk+x/dFKb0Ho527Ym91+fXPOZ5NG7SmteIfsclix+Q7JocTJxcntlPftwcus3klsuSrZsKKd9z7Xw5OS1vz9+zJKLk+98eOe/m7swOe7lyeFnJlP3aFzfR96arH6y+XYmyeik5PhXJCe/Ntl9r9bK2L4tWXZtctUnfnKMT52Z/Mqni5Xz5+e3Vn8vlPG9JfX76JrPJPdevfPfv+vjybRZ45fxV69uvt53fyqZPG38mI/9QrLq8ebLHs8rfjM57IzGcd/7p+Tmr5ZX7+ik5Njz6302Z345ZT71QHLrRfW5ZNuWcsrcoddzyHnvqa99jUwYTUZqjeO2ba2v0a2447vJxX/d2mefr+x1felVyfWfK39t73X/95uy+q3MPpt/fPL6DxaPv/4LyeUfb6/O59prUfLmv0pqBe6/LRuTj/9qsvqJ9uoc9FxyUO7/IqpyLVXPQXf006kXtleOPqobpH3Ccw3SHrbI/iAZvD2CvGrnyhqbnR6XSTXG5iDvrxadkrzhfzWOe3xp8u+/1lqbGhmkubQZg3RdPRkHI8nLfiU5+qXFwlc/VX9OsfKxkupvQZE1J0meuDf5xPvKL3tX69nEycnxr0wWX5hMm9lcvTuMbU/uvSa56lPJE/e0Vka3TJuV/MK/JUVeRbju88kV/15OvUX6aMum5O9/Otm+tf36Jk5J3v3JpDY6ftzGtck/vGX8daOde3ykVj9zXfyGZNa+jcvYmV6Or06cGX/nw+2dFw9y3tBLg35ulQxWblCVdWkQ7zf5RmuqsK9s1aCfJc/aLznu/OSolzR+Xl7E5vXJ0iuTaz+XPPNQ++WVaRDnpKIG6RyqU9rNuY+7oH5OP3v/1uof2548eEv9nP7h21sro12DPh912qC9z9JLg/Ls6kVvrc99RXzhA8mDNxeLbcURZycXFMgNH78n+eT7d/37KueL4xm0+7Odftr7kOTMtycLT2qt7k3rkhu/nFz/xWTT2uKf2/PA5Iy3JYe8oNiZ3vNt25rcfkn9ni7zGV0n91/NKOPMo5fnHZ3Qr3nFoL9LVtU9Sb+Ol+frx/caern2W/eL6Ydn+Z00CPdvVXLkM96WnPL6YvV99B3JuhWt19XI2z9c7PzjX941/rsB/XqWnvTmXTTPoIrr5Bpkv9b859s1CGtJUo28q6r7CQAAAAAAgFYV/J9l3yn/W+0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAwKDyv9UOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyjIv9b7aNdaAcAQ2j9ymJxI7VkwsRk25b26ps0NXnRW5MTXplMKGl1G52UvO3vk7svTy75x2Tt0+WU28jhZyYv+u/J7APKKW/CaHLw6fWfOy5NLv3nzl/LvEOTs9+ZHHhseWXO3j855+eTF7w5ufHLyTWfTrZuLq/8kZF6n4+nNuEn/23ytOScX0iOPa+8toznqBcnZ/1cMn12e+XUJiSHvCA5+LRkybeS734k2bKxnDb2o7K+tyTZ9/DkdR9IHrwl+ebfJCsf+/HfT5jYeCy1oki5nfj/W6pNKHY9tVpJFY4kJ706Oe1NybRZJZX5Q3MXJC/55eTUn0q+90/JXd8vr+xezyG10XLHXTtr6aon2q+/U+v6kWfXf8pe23vd//2i7H4rs88evCW57dvJ8a8oFn/qTyVLr0ieWNZafc81UksueF8yaUqx+Es+kqxu4z4a9Fxy0O7/8VTpWqqcg/bz3NWMKvdRNwziHrbovmPQ9gjyqh9X9tjs9LhMqjE2q7a/6pZBnEuLqOp1lak2IXnFbyZHnF0s/tnlyWd+J1nTpfP2XSmy5iSt3cOtrmfzT6jvH3ef23ydP1Z/7Yc53enJkm8m3/3HZMuG9srslHUrkqfur5+5NrJocXLFv5dT70GnNu6j0UnJ/kcnD93Sfn3zT6jvPRp58OZkbHv79e3M3gclF7w/2WtRe+X0ZHx18My43fNieUNzBv3cKhnM3KAq69Ig3m/yjdZUYV/ZrEE/S544JTnjbcmJr975uGvVpKnJ0S9NjnpJsuya5Lsf/cln870yiHNSI4N4DtVv9jsyOf+9yZ5t5jojtWTBifWfB25KvvV33Rv7gz4fddyAvs/SK4P07Or279TnqyKOenF9/94ph59ZbI2567Lxf1/lfHHnFQ7m/dlKP9UmJGe8PVn8hvZy4snT6uP+uAuSiz6U3H9D43ac8bYf1ttGPjxhtP4874izksv+tZ4nlKGT+68iyjzz6MV5Ryf0e14x6O+SVW1P0u/j5fn68b2GXq791v3hNkj3b1Vy5NsuSU7/6WKxh59ZXr71fHstKvbccfltjc81+vEsvRfvonkG1UL9HVyD7Nc6N3883yCtJUk18q6q7ScAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoCyjvW4AANW0fVvx2FotaSL8J8w/IXnFbybTZ7dRyDgOOyNZeFJy8V8nd13WmTqSZMac5GW/lhy0uHN1HHl2svDE5Ct/kjx4S/nlj05OXvTW5OTXJLUJ5ZefJJOnJS94c3LE2fU+Wb6kM/UUsce85I1/lsyc1/m6Jk9Pzn9PfTyWaaSWHHd+csBRyRc/mDy7vNzye61T31uSzD8+efs/JF/9k2TZdeWXP4xm7pO8/P3J/kd3tp4Zc5JX/05yyOnJN/4q2bq5s/XtSjfnkG5a8Wh7n+/0up50b20fT9X6fxDyse99tN7OWfs2jq1NSC54f/Lvv9pcXrszp16Y7H1wsdj7rk9uvai1eqqQS1bp/q/KtVQ9Bx2EuauRqvdRpw3bHraqqpZXJZ0fm8bl4Gh3f9UNVZ1Lq3pdZZswMXnN/1d8H/L4vcnnfjfZsKqz7RpEZ7w9Of1N5ZY5MvLDnO6Y5IsfSJ59uNzyy7L0ymTfwxvH7X1QMm1Wsm5F+3UuOqV43EO3tF9f0Xtk6ZXt17Uzx56XvOTdyeik8srs1vjqxplxv5wXt6uf84YqnFsNW24wzOtSEf18v41Hv/anQT9Lnn9C8vL3JTPmllvuc42MJAefXq/r0o8lN3+1c3UNonbnJOdQ5TjlDclZ7yj/O1xwYvL2Dyff+XBy27fLLfv5Bn0+6rRhe5+lHYP47GrFo8lDS5IDj20ce+gLkm9N6kzfTJySLDy5cdz2bcmdl5Zf/6Dmi8N0f06amrzhg+Ve67RZyYV/lFz6z8l1n991zOv/MJl3aHn1TpySvPiXkn0OTy76y/bfzemVTp95dPq8o1MGJa+o+rtk3eJ90WL68b2Gstd+6/7wGYb7tx9z5BUPJw/fVuw+OPLc5MYvt9bOImUX8YNvdqb+Tur2nO0ZVPv64VmF/VprhmEtSQYz7+qWQX3uCgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEA11XrdAACqaWSkeOxYG/Wc9qbkp/44mT67jUIKmDQ1efX/TM58R2fK3//o5B3/kBy0uDPlP9duuycX/nFywqvKLXf6nOQt/ydZ/PqkNqHcsndm1r7Jm/53fQz0wh57Jz/zV8nMeZ2va9rs+nd72Bmdq2P2Acmb/zKZu7BzdXRbN763SVOS134gOea8ztUxLPY/Onnb/63/t1uOODt54/9OJu7WvTp36OYc0m0rHmn9s91a15POr+3jqVr/D0o+tmVT8vW/SLZvKxa/16Lk1J9qra4dZh+QvOBnisVuWJN8469aq6cKuWSV7v+qXEvVc9BBmbvGU/U+6rRh28NWVdXyqqS7Y9O47H/t7K+6oapzaVWvq2wTd6vvDYruQx5aknz6t5INqzrbroEzklzw/uT0Dvb/7P36O6e758picSMjyYIT269v9v7Fc4eDTmm/viRZdHLjmC2bkvtvLKe+51r8huT89yajk8ovO+ns+Or2mXEvz4vL0K95QxXOrYYqN7AuFdKv99su6de+Nehnycecl1z4R8mMueWVOZ6JU5KXvjt55W8nI956/X/amZOcQ5Xj7J9Lznln577DSbslL39/ctbPdab8ZPDno04btvdZ2jHIz65u/UaxuElTk4NPK7fuHQ5aXGz/ft8NJZ+xDXC+OEz356SpyZv+vHPXevY76+dIz7f7XsmbP5TMO7Qz9R55Tn1dGMT8rltnHp067+iUQcorqvwuWTd5X7SxvnuvocNrv3V/OFT+/u3zHHnJN4vF7XNY/UymE444q3HM5vXJ3Zd1pv5O6fac7RlUuXr1rMJ+rTWVX0uSgc27umngnrsCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUGm1XjcAgGqaPK1Y3PZtydZNrdVxzi8kZ749GenianbaG5Nz31VumYefmfzUnyRTZpRb7nhqE5KXvjs59rxyypu7MPnvf53staic8ooaGamPgfPf291xMHFy8ro/SKbP7nxdM+YkP/OhZM8DOl/X1D3qY3HGnM7X1Wnd/N5qE5Lzfi056NTO11VVC05KLvzj4mtHmfY7InndB6o7h/TCikdb+1wv1vWkM2v7eKrW/4OWjz16Z3Ld54vHv+DNyZz5rdWVkeTl70tGJxUL/9bfJutWNF9NFXLJKt3/VbmWqueggzZ37UzV+6jThm0PW1VVy6uS3oxN47K/tbq/6oaqzqVVva6yTZmevOnPkgOPLRZ/7zXJ53432by+s+0aRGe/MznmpZ2vZ+rM5MI/Sqb3YU634tHk6QeLxS46pf36miljzwOT3fdur745C5IZcxvHPXBj68/LduXol9bHWKd1Ynz16sy4F+fFZenHvKEK51bDlhtYl4rpx/ttPPq1Pw36WfLhZybn/3p93u22I89JXvv7SW20+3X3o1bnJOdQ5Tj5tcniC7tT16kXJi/55fLLHfT5qNOG7X2Wdgz6s6ulVyQb1xSLPfLc8up9rkNfVCzu9u+UW++g5otDdX+OJK/6H8m8gztbzVk/m8w//kd/nzS13mez9u1svYe+MDnzHZ2to2zdPvMo+7yjUwYxr6jiu2Td5n3R8fXjew3dWPut+9U2DPdvv+fId19W/Nn7EWc326rGDjim2PPPOy9LtpT8/LOTuj1newbVGV1/VmG/1pJhWEuSwcy7um3QnrsCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUG21XjcAgGqaNrtY3MY1rZX/gjcnp7yutc+26+TX1n/KsPDk5JW/nYxOKqe8Zp33nmTRKe2Vsce85I1/msyYU06bWnHseclLf6V79Z3zC8nchZ2vZ8LE5LV/kMzcp/N17TBtVvKq3+5efZ3Qi++tNiF51e/U7weaM/uA5DX/XzJxcu/aMP/45EVv7V593ZpDemHdymTz+uY/18t1PSl3bW+kSv0/qPnYFf+RPHlfsdgJE5ML3peMtHB6cvJrkn2PKBZ7x3eTuy9vvo4q5JJVuv+rci1Vz0EHde56rqr3UacN4x62qqqUVyW9H5vGZf9pdX/VDb0er0lnxmxVr6ts02Ylb/5Qss9hxeJvvyT50geTbVs6265BdMQ5yeLXd6++6Xsmr/ofSUa6V2dRS68sFrfgpLTd/kWLm4w/uc36Cu6b776ivXqeb/e9k5f9arlljqfM8dXrM+NunxeXoR/zhiqcWw1bbmBdKqYf77fx6Nf+NOhnybP2S85/XzLSw34++LTknHf2rv5+0eqc1Os1bhD2vkXM3Dc5u8vj8MRXJyf9t/LKG/T5qNN6vTdJBmd/UoVnV9u2JLd/t1jswpOTKTPKqztJRicXO7PYtC6595ry6h3UfHHY7s/Fb0gOavJMqxUjtfpeftLU+t9f+VvJngd2vt4kOfXC5IBju1NXu3p55lHGeUenDHJeUaV3ybrN+6KN9dt7Dd1c+6371TQM9+8g5MhbNiV3fr9Y7JHnttSsUspccnH5dXdSN+fsXp/PJZ5BlcV+rXnDsJYkg5l3ddugPXcFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoPpqvW4AANU0Z36xuI1rmi/70BclL3pr858r0zk/nxxwTHtlzFmQ/Lf/mdQmlNKklozUkgven+y2e2ufnzI9ufCPkqkzS21WS45/ebL4ws7Xs8/hyXEv73w9SfKyX03mHdydup5r9gHdr7NMvfreJk1JLnhf/b6imImTk9f8Xv2767XTfqo+L3daN+eQXljxSPOf6Yd1PSlnbW+kSv3fD/3Wap9t35p87c+TrZuLxe9zWHLy65qrY+Y+yRlvKxa75qnk23/fXPlJNXLJfhhHSTn3f5Wupco5aD/0kz7qrWHcw1ZVlfKqpH/GpnHZX1rZX3VDv4zXpNwxW9XrKtvueydv/lDx8/8b/yv5+l8kY9s72qyBNG1W8pJf7n69BxydHP+K7tfbyNIri8XtNqO+T2/VxCn176AZixa3Xl+SLDqlccz2bcmy69qr5/mm7pGMTiq3zEbKGF/9cmbcrfPisvRb3lCFc6thyw2sS8X12/02Hv3an/rhjDJp75zyJb/U+7U6SU56TXLoC3vdit5qZU7qlzWun/e+RU2Z3pt855xfSPY/qv1yqjAfdVK/7E2SwdifVOXZ1ZKLi8VNGE0OO6PcuheeVGy83XV5sm1LOXUOar44bPfnzH2SF76ls3U817RZyWlvTI44Jzn4tO7VmyQv+5UkI92ts1m9PvNo97yjUwY9r6jKu2S94H3R8fXbew29WPut+9UyDPfvIOXIRfcvs/dP9i5xv1YbTQ57UeO4Zx5KHrurvHo7rZtzdr+czyWeQbXLfq15w7CWJIOZd/XCID13BQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGA4jPa6AQBUz+z9k7kLisU+eX9zZU+blZz3nqablAdvSe67Lll+W7L2mWTD6mTblmTytGS33ZM9D0zmH58c+sJk970alzdSSy54f/Kvv5hs2dh8e2qjyX/73WTS1OY/OzaWPHFv8tQDyfqVyYZVSUbq1zJzn2S/I4pdww7TZiYveXfy1T9tvi3nv7fe380a2548dnfy9IPJ+lXJhjXJ6MR6/07fMzng2GS3Gc2Xe9Y7kodvSx69s/nPFnXm25ORkc6Vv8OCE5NjXtbaZ7dvq38HzzxcHyMb1yYTJiRTdk/mzK+PkcnTSm1u3+j193bgsa3VPawWX1j/bovasqk+l99/Y/LkfcmqJ5LN6+vzeW1CMmVGMmPPZP+jk0Ne2Fx/jNSSs342+cLvN38dzejWHNIrKx5tLr5f1vWk/bW9iKr0f6v99r2P9k+fPf1Acvm/J+e8s1j8GW9N7r06WfFIsfjz35tMnNI4bmwsuehDyaZ1xcrdoQq5ZJXu/ypdS69zqU5qpZ/0UfUM4x62qqqSV+3Qytg0Lquv2f1Vt1R1Lq3qdZVp9gHJG/80mTGnWPwV/55c9cnOtmmQHfKCYnFPP5g8tjRZ/USyeUMyOimZOjPZY+/62Vcr+8IX/kxy27eTrZua/2ynPLmsfta3x96NYxednDx2V2v1zD8+mTCxyc8cV//Mti3N1zdparL/UY3jHro12bS2+fLb1Y/jq1/OjLt1XlyWfsobqnBulQxfbmBdKq6f7rdG9Gv/qcJZ8rxDk4UnF48f215v933XJ0/dl6x+6odr9db6Wj1xSv17mb1/fb1eeHJ9/i7qxb+YLLuutVytClqZkzq1xh36wubL7Me9b9mefSR5/O5k5eP1sT9Sq8+x02bXc5sie6Dnq02o37//8q7Wx34V5qNO65e9SdL/+5MqPbt66v76XLfPYY1jjzw3ufWi8uo+7Mxicbd/u7w6BzVfHLb7c8GJjWPWPpM8tKT+TsvmDcnEyfW5fs/59bOp2oTm6jzpNcmWDY3jNm9Mli+p3zsb19S/j2mz6mNj/vHNj409D0wOPyO567LmPtct/XLm0c55RydUJa8Y9HfJesX7ouPrt/caerX2W/erYVju30HKkXec0xS5R448t56LlGHhyfV7qZElF5dTX7d0c872DGrn+uG+apb9WnOGZS1Jmhv3d18+OGO+bIP03BUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA4TDa6wYAUD0nvaZ47KN3Nlf2i38p2W1G8fj7b0gu+9fkiWU7//2mdfWflY8ly65NLv3n5OiXJGe+I5k6c/yyZ85LFr8hufI/i7dnh9PemOx5QHOfWftMcvWnkruvSNavHD92/6OTF701OfDYYmUfcVZyzaeTp+4v3p7DzkgOfWHx+CRZ81Ry1aeSpVckG1bvOm6klux7eHLy65LDXlS8/JFacsH7kn/75WTblubaVsS8w5J5BxeP37o5Wbci2bIxGRv78d9t27rrz9UmJC/+xebbt+LR5KpPJvdeXR/Xuyx/NDlocXLqhcm+RzRfT7/yvQ2W3fZITnl9sdjt25Lrv5hc97ldzx3bt9XnxvUr63P+jV9ODjgmueD99fm6iEWnJLP2T1Y8XCy+WZ2cQ5Z8I3no1sZlLn59Mndh47hbL04evq14W3d4uol1JOmvdT1pb21vpFtrSDeU2W+97LPrv5AcfFpywNGNY0cn1XOMT/5GkrHxY497efEc7KavJA/eUiz2uaqQS1bp/q/KtVQ9l2qmn/RRNfPdYdzDVlWV8qqktbH5zb81LjtpUPdX3VDVubSq11WmvQ9OLvzjZOoexeLHxur5B63ZsjG59RvJzV+t53K7UpuQLDwpOfNnk7kLipc/bVZy1IuTWy9qu6mlWnplcsrrGsctOqX1s5tFi5v/zMQp9XPGB25q/rMLTqz3UyNLr2y+7Fb18/jqtzPjIufF8oafVIVzK7nBj+uXecP9Vq5+6ddhU4Wz5GPPKx67/AfJt/8+efqB8eNWPFK/H5dcXB9zh59Vv4bd5zauY8bc+nOZm75cvF1lGNQ5qZNr3H5HDtb61klbNiZLvpnc/LXk2eXjx84+IDnuguSEV9afRxY1a9/k5Ncm1362tTZWYT7qpH7bmySdf5+lVVV8dnXrN5J9Dmsct/9Rye57JaufbL/OCROTgwucWax6Inn49vbrK6Jf80X354977O7kiv9I7r8xu3yXZcr0+hp96oX1sVbExMn1n11Z+0xy5SeSOy5JtmzaeUxttJ4XnPMLyfTZxepN6u+f33VZ8fhu6qczj1bOOzqlSnnFIL1LNqh7kiqNl0YG7b2GZtf+13+weNnW/WoYpvt3V/oxR15ycXLuuxrHHXF28r1/SsM1q4ijzm0cs31bcvsl7dfVLd2csz2D+nH9eF+VxX7tJ1lL6oqMe89dAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKA3RnvdAACq5cDjkuNfUTz+kTuKx+59cHLYGcVix8aSK/49ufpTxctPku3bkiXfTO6/KXndHyR7HzR+/CmvS276SrJhdfE6dt87Oe2NxePHxpKrPplc+5lk6+Zin3n4tuTTv5Wc+Ork3HcltQmNP3Pam5Kv/mmx8idOSV7y7mKxyY+u4ZpPJ9u2FIjfXh8bj9yRzDs0eeVvJbP3L1bXngcki9/QfN8XMe/gxjHLb0vuujR54JZkxSNJxpqv5+iXJnseWDx+29bk+x9Lbvxy/btrZPvW5J6r6j9HvSR5yS8lk6c1385+43sbLKMTk/tvSA59UTIysuu4jWuTL/x+c+vFDst/kPzne5I3/lkyd2Hj+JGR5NiXJd//l+brKqKTc8iOObORI84u9l08fFty+3eK1d2qflzXk9bW9iK6tYZ0Wqf7rat9NpZc9BfJO/4hmTS1cfj+RyUnvqpe167MmJuc885i1T+7vL4ONasKuWSV7v8qXUuVc6lm+unyj+ujKua7w7qHraqq5FVJ62Pz1osKxBqXLRvE/VU3VHUurep1lWn/o5LXf7B4XrB9W/L1v+xsm6rsoSXJNz6UrHqicez2bcmy65L7bkjOfmc9xyzquPOLrSfdtPTKYtcw75Bkt91bO7s56JTmP5Mki05JHriphfoWN44ZG6vn4N3Q7+Or386Mi5wXyxt+XBXOreQGP66f5g33W3n6qV+HSVXOkhecVCxu6ZXJl/+42Lnkc23fltzx3eSeq+tz5CGnjx+79MrWcoJ2DeKc1Ok1bpDWt0564Obk4v+TrH6yWPyzy5PvfTS5/ovJeb9WbA+xw+lvTm65KNm0trk2VmU+6qR+25sknX+fpVVVfHZ156X1vcak3caPGxmpz/PXfrb9OhecVOydhdsvab+uIvo5X3R/1m3flnz/X5PrP984duPa+lx+z9XJm/6s/XvorsuSi/862by+QRu31u+n+66vf5fzDilW/n5HJjP3SVY+1l47y9bNM4/f+Hr55x2dUrm8YoDeJRvEPUnlxksDg/ReQytr//VftO4Pk2G7f3emX3Pk2y9JzvrZZMLE8eOmz04OPDZ56NbiZe/MxN2Sg05tHLfs2mT9qvbq6qZuzdmeQf24fr2v2mW/tnPWkrqi495zVwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADojVqvGwBAdSw4KXnt7ycjI8Xin12ePHZ38fJf8ObiZX/vo8nVnype9vOteSr5zG83jps0NTnmvObKPvm1yeikYrFbNib/9b+SK/8j2bq5uXqS5KavJF/9s2Rs+/hxDy1J7vhu8XKPuyCZNrNY7HOvYduW4nXs8PjS5D/ekzxwc/HPnPzaZHRy83W1Y/ltycd/JfnUbyQ3fy1Z8XCSsdbKOvHVxWM3rEk++z+TG77UuJ935vbvJJ/6zWTdiuY/2298b4NlzdPJl/+4ft/ce+3OY7ZurvfTI3e0Xs/6VclX/rT4HHrQqa3X1Y4y55BB0Yt1ffWTjWNbWdvbNUj9361+61afrXoiueQfi8ef+bPJHnvv+vfnv6fenka2b0u+9het5XdVyCWrdP9X6VqqnEs100/6qK5q+a497PAYpLwqaX1sNsu4pAxVnUurel1lWXhScuGfJJOnFYvfsin50h8md36vs+2qqju+m3z2d+p71WaMba/vN274UvHPzDs0mT6nuXo67ZE7iuWfI7VkwYnNlz9nfjJjbvOfS5JFp7T2uYUnN4559K7u5N2DML768cy4V+fFg6oK51Zygx8ZhHmD5unX3qnCWfKkqcnMeY3jNq1LLvpQa+eSO2zZUJ9jd5YTbFqXXPeF5KPvSL7yJ8kT97RezzDp1hrX7+tbJy25OPnc7xa7955v7dPJFz6QXPu54p+ZNCU55qXN11WF+ajT+nFvkvTn/qSKz662bEzu+n6x2KNeXE6dh59RLO72S8qpbzz9ni+6P+vf9df+PLn+88197ol7ki99MBlr47nZrd+o51+b1xf/zKZ1yed+r953RRU5U+u2bp55dOK8o1OqmFcM4rtkg6KK46VV/fReQ6trv3V/uAz7/dvPOfKG1cm91xSLPfKc4uXuyiGnJxMLnOEsubj9uvpFmXO2Z1A/0s/3VTvs13Zt2NeSpLVx3+9jHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACqptbrBgAw+KbMSM5+Z/KGDyaTpxX/3C0XFY+dNjs56NRisXdemtzwpeJl78rGtcnYWOO44y4oXubkacmx5xWP/8qfJfdcVTx+Z+6+PLns337y37dtTW6/JPn4u5NP/1ay7Npi5dVGk1NeX7z+r5ZwDZvWJV/4/eTxe4rF77Z7c99zO8bGkks/lnzqN5In7m2/vH2PSPZaVCx2+7bkS3+YLF/SXp1P3pd84QPJ1s3tldNLvrfB9eSy5IsfSP7z15MHb/7x313ykeTxpe3X8cxDyc1fKxY7Z36y2x7t11lU2XPIoOjVuv6VPyl/bW/HoPV/t/utW332g28m915TLHbSlOT89+78d0e9JFl4crFyrv5Ua/NbFXLJKt3/VbqWKudSzfZTu/RR/7GHHQ6Dllcl3R+bxiXtqOpcWtXrKsthZySv+8Nk4uRi8ZvWJZ/73WTZdZ1tV1U9cFPy9b+s53KtuvRjyTPLi8cvOKH1ujpiLLnn6mKhi05pvvhWPrPD7P2Tmfs095m9Dkqmz24ct/SK1trUjEEbX/10Ztzt8+JBVoVzK7nBjwzavEEx+rV3qnKWvPtexeKWXZdsXl8sdjxj25Ov/3mybkX97ysfTy75h+TDb0ku/adk9ZPt1zEsnEN13r1XJxf/TX3ctmws+f7Hir/bkCQnvjrJSPH4qsxH3dJPe5Ok//YnVX52des3isXNmZ/MXdheXbXR5ODTGsc9eley4pH26mpkkPLFYb4/r/iP5K7vt/bZh25t/bPLf5B86+9a++yGVTvfv+/K/ONbq6dTun3mUfZ5R6dUOa8YpHfJBkWVx0sz+u29hnbXfuv+cBj2+3cQcuQlFxeLO+yMZMLE5sp+vqPObRyz9tnkvhvaq6cflD1newb1I4NwX7XKfm3nhn0tSQYn7wIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAYVfrdQMAGEwjteTA45OXvjv5xY8ni9+Q1CYU//y6lckPvlU8/shzi5W/ZWNyyUeKl9vIfdc3jpm1bzJ3YbHyDj8rmbRbsdjrv5gsu6ZYbCPXfi555M76nzesSa75TPKRtyZf/4vkiWXNlXXwqcmMOcVir/t8cm9J17BtS/Jff5RsXFMs/vhXlFNvI9/4q+S6z5VX3hFnFY+9/OPJw7eVU+/jS5NLP1ZOWb1wuO9t4D16V/KZ30k+9VvJI3fUv9tbLyqv/Fu+Xjx23sHl1dtI2XPIoOjVuv7oXeWv7e0YtP7vRb91q88u/utk/apisfOPT449/8f/bdqs5MXvKvb5x5cmV32ymdb9SBVyySrd/1W6lirnoFWZu6rcR51mDzscBi2vSnozNo1LWlXVubSq11WGY16WvPp3kgmjxeLXr6yf6ZSVgwybDWuSr/3vZGx7e+Vs39pc7rbPoe3V1wn3XFksbuFJzZe9aPGufzc2VqDOk5us75Ricfdc1Vy5zRrk8dUvZ8bdPC8eZFU4t5Ib1A3yvMGu6dfeqspZ8qQpxepd9USxuCI2rUu+9XfJlz6Y/NPPJjd+Odmyobzyh4VzqM5a+2zytb9IUmBfUcQlH6nnvkXM3CfZ57DiZVdlPuq2ftmbJP21P6nys6vH7k6eur9Y7JHntlfXghOSydMax93+nfbqaWRQ88Vhuz+fWJZc/en2ymjlfZWtm5OLPtTe+Lj9kuJ54l4HtV5PJ/TizKPM845OqXpeMSjvkg2Kqo+XovrpvYYy1n7r/nAY5vt3UHLk+29KVj/VOG7ytOLPL3dm6h7J/BMax9327fa/s35Q9pztGVTdoNxXrbBf27VhXkuSwcy7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBY1XrdAAC6a/e5yTHnNfdz/CuTxRcmZ7wtefn7k7f+bfKeLyZv+rPkhFclk6Y2347vfTTZtK54/MGnFou7+evJ+pXNt2dXbvhisbhFpxSLO2hxsbj1q5LL/rVYbCFjyXc+nHzr75J/eEu97HXPtlbUwacXi1u/Mrn8463VsSurn0iu+Wyx2Dnzk5n7lFv/813zmeS2b5db5oITi8WteSq57vPl1n3zV5Mn7yu3zG5ZcEKxON9b/1u+JPnE+5LP/M9yy13xSLLysWKxs/cvt+5d6cQcMih6ta4n5a/trRrE/q9KPrYz61cm3/yb4vHn/Hwyfc6P/v6yX02mzGj8uS2bkq/9eTK2vekmJqlILlmh+79K11LlHLQqc1eV+6jT7GGrbxDzqqR3Y9O4pBVVnUurel3tOuk1yfnvTUYKPkVe/WTyifcnTy7raLMq7YqP1/dxZbjvumRtwf3a3EXl1FmmB28t9uxo6sxk70OKlztparL/Ubv+/WN3Jc8uH7+MonvyHYrk+k/eV/zMslVVGF+dPDMuolvnxYOuEudWcoMk1Zg3+En6tbeqcpZcdI9Qm1Asrqh7rqr/tPpsBedQnfb9jyWb15dX3vatyXc/Wjy+6PsySXXmo14ZpvdZiqj6s6tbLy4Wd+TZ7dVz2BmNY7ZtTe78fnv1NDLo+eKw3J/f/5ckY+2V8cxDydMPNveZW76erHq8vXozltx9RbHQPfZOJk5us74S9eTMo8Tzjk6pel4xKO+SDYqqj5ci+u29hrLWfut+9Q3z/TswOfJY8fnlyHObLPs5Dj+r2LnfD77Veh39ohNztmdQdQNzX7XAfm3XhnktSQY77wIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAYVPrdQMA6K4585ML3tvcz8t+JTn755LTfzo5+qXJvEOTSVNab8N91yd3fLd4/MTdkv2OLBZ760WttWlXlt+WbN3cOG6/oxrHTJiYzD++WL23fD3ZtqVYbFFP3FMvd+um1ssYqSUHLS4We3MHriFJbv1GsnljsdiDTi2//h2efjC54j/KLXPa7GTPA4vF3vTVZGx7ufWPbU+u/Wy5ZXbDtFn1ua0I39vg2LS2/DIfW1osbsbc8ut+vk7MIYOil+t6Uu7a3qpB7P+q5GPjueeq5LbvFIudPC05/z31Px9+ZnLIC4p97vv/kjz7cGvtq0IuWaX7v0rXUuUctCpzV5X7qNPsYatvEPOqpPdj07ikGb0er0lnxmxVr6tdL3xL8uJfTEZGisU/szz5z/clKx7pbLuqbP2q5AffKq+8se31/W0Ru+9VXr1l2b41WXZdsdhFJxcvd8GJSW3Crn9/77XJsuvHL+OAY5PRScXqmzI92ffwxnFF+6pVVRtfnTgzLqIb58WDrgrnVnKDuqrNG9Tp196q0lnyxoJrcdFn93RHr9e4fljfOmnN08kd3yu/3IdvS55YVix24UnF4qo0H/Va1d9nKWIYnl3dcUmxMTtjbnLAMa3VMVJLDj69cdx91ycb17RWRxFVyherfH8++0jywI3llHVfwfO3JBkbS276SnfrHRlJps8pp8529fLMo4zzjk4Zlryi398lGxTDMl7G02/vNZS59lv3q22Y799By5GXfLOetzVy0OJk0tTmy0+SI89pHLP8tsF/d6ATc3avz+eS/jijG7T7qhn2a7s2zGtJUp28CwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACGRa3XDQBguDx5X/KVP23uM3svSmoTGsc9uzxZ8Uhr7dqV7VuTx5c2jpt3SLGYiVOK1XvL14vFddvchcluuxeLveVrnWnDprXJXd8vFjv/uM60IUku+9f6+CjTPocWixsbS5Z8s9y6d7j78mTDms6U3SnzDisW53tj1ePF4nbbo7PtSDozhwyKXq7rSblre6sGsf+rko818p0PJ6ufLBa76JTk5NcmL/nlYvEP3pzc9OXW21aFXLJK93+VrqXKOWhV5q4q91Gn2cNW3yDmVUnvx6ZxSTN6PV6TzozZql5XO859V/LCtxSPf3xp8sn3J2uf7lybhsHdlydbN5dbZpE8NEmmzy633rIsvaJY3KJTipfZKHbZtcm914wfM3FycsCxxepbcFKxvcjSK4uV1yrjqxzdOC8edFU4t5Ib1Jk3qkm/9laVzpI3rCpW58KTktkHFIul83q9xvXD+tZJt30nGdvembKL5k3zDk0y0jiuSvNRFfXT+yxFDMOzq41ri+/bjzy3tToOPC7ZbUbjuNu/01r5RckXx9cv9+fdl5dX1pP3F4994p5k5WPl1PvUA8Vj+2VsVOHMoxOGKa/o53fJBsUwjZdd6bf3Gspe+6371TXM9++g5cirn0geuqVx3Oik5NAXNl/+HvOSfY9oHPeDDu3/uqkTc3avz+eS/jijG7T7qhn2a7s2zGtJIu8CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgEFT63UDABgezz6SfO53k83rm/vc3gcXi7v/xubbVMSKRxvHTJ+dTNxt/Jg9DyxW37OPJGufKRbbbXPmF4t79uFk3YrOtWP5D4rF7Vmwvc1a8Why77Xllztrv2Jxzy5PNqwqv/4k2b4tefDmzpTdKbP3LRbne2Pj2mJxo5M6245OzSGDotfrelLe2t5q3YPY/73ut2712eb1ydf/MhkbKxZ/7ruSqTMbx21al3z9Q201rRK5ZK/HUVLeWKrStVQ5B+11P+mj3rOHrbZBzauS/hibxiVF9cN4Tcofs1W9rlaM1JIL3pec/Nrin3no1uRTv51sWN25dg2L+24ov8wnlxWLq01IRieXX3+77r8h2bKpcdw+hyWTpxcrc9Epu/7d6qeSp+5PHrm9vn8fz0GL269vh5WP1evtJOOrHJ0+L66CKpxbyQ3qzBvVpF97q9dnlEl555TrVyebNzQuqzYhef0fJrP3L9Y+Oqsf1rher2+ddH8H5tgdHr6tWNzopGT3uY3jqjQfVVG/vM9S1LA8u7r1G8XiDjsjqY02X/5hZzSO2bgmWXZd82U3Q744vn65Px+8pbyynlneRL23llfvhlXFz5QnTimv3nZU4cyjE4Ypr+jnd8kGxTCNl13V3W/vNZS99lv3q2uY799BzJGXXFws7shzmy/7yHMax2xen9x9WfNl95NOzdn9cD6X9P6MbhDvq6Ls13ZtmNeSRN4FAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIOm1usGADAc7rsh+Y9fS9ataP6zs/YrFvf0g82XXcSGNcXiZswZ//d7HlisnMfuKhbXC3PmF4t79M7OtqNo+TPnJRMmll//PVcnGSu/3Nn7F4t79O7y636u5Us6W37Zis4RvrfhNmFiMmG0WOxoB+aN5+rUHDIoer2uJ+Wt7a0Y1P7vdb91s8+WL0lu/K/2y3mub/99svbp9sqoQi7Z63GUlDeWqnQtVc5Be91P+qj37GGrbVDzqqQ/xqZxSVH9MF6bKb/omK3qdTWrNpq8+neSY15W/DMPLUk+93vJlg3lt2cYPXFP+WWuW1U8ttPnYK3Ysil54KbGcbUJyYITGsftdVAyffauf7/s2vp/t29L7r9x/LIWndK4viRZeHLjmKVXFiurHcbX+IrOq/1+Hf2gCudWcoM680Y16dfe6vUZZVLiM5ax5KFbi5U1a9/kHf+QXPD+em40aWqxz1G+fljjer2+dcr2bcmjHcxvnlmebF5fLLbIXFOp+ahi+ul9lqKG5dnV8iXJikcbx02ZXvzMYIeRWnLoCxrH3XVZsm1Lc2U3S764a/10fz51X3llbVhdPPbJe8urN0k2FBwbo5PKrbdVVTjz6IRhyyv69V2yQTFs4+X5+vG9hrLXfut+dQ3z/TuIOfLSq5KNBb6v+ccl02Y1V/aR5zSOufOy+nPeQdapObsfzueaKd8zqObZr+3aMK8libwLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbNaK8bAEC1bdmYXP3p5JrPJBlrrYwZc4vFPbO8tfIb2bimWNy0Wcmz47Rh1r7Fynn8nmJxvTB7/2JxT9zb2XaseCTZvDGZNGX8uJFaMnOf5JmHyq3/gZvKLW+H3QuO9Sc7/P0++3Bnyy/b7nsXi/O9Vd+0WfV7fo959f/+vz/PS6bvmYyM9LqFdZ2aQwZFr9f1pLy1vRWD2v+97rdu99n3/yVZeFKy54Htl3X35ckd322/nCrkkr0eR0l5Y6lK11LlHLTX/aSPes8ettoGNa9K+mNsGpcU1Q/jNSl/zFb1upoxOjl53R8ki05u7nNzDkwmT0vWryyvLcNq88Zk7TPll7tpXfHYWp++LbD0yuSQ0xvHLTqlvu9uFDOee6/50Z+XXZscfuauY2fuk8zar37v7sq8Q5NpM8evM6lfYycZX3WNzowpRxXOreQG5o2q0q+91+szyqTcZyzLrksOPq1YeRMmJse8tP4zNpaseSpZ+Viy4rFk5aP1P698LFn5eLJpbbEyaV4/rHFVPYda9USyfWsHKxhLnrwv2f/oxqEz5yUPNoip2nw0aAblfZaihunZ1ZKLk7N+tnHcUecm915dvNz9j06mzmwcd9t3ipfZCvniYNyfm9YlG1aXV97m9cVjVzxWXr1JsnlDsbjahHLrbVUVzjw6YRjzin58l2xQDON4ea5+e6+hE2u/db+6hvX+HdQceduW5I7vJSe+evy4kVr9eeiNXy5W7l6Liq1/P7i4WHn9rFNzdj+czyWeQXVqDbJfG9+wriWJvAsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABtForxsAQDWNbU/uvDS59F+StU+3V9a0WcXiXvTWZPOG9uramVn7FoubOHn830+eVqycDauLxfXClOnF4tZ34Ro2rk4mTWkcV/R7b8ZT95dfZpJMmlosbsOaztS/w8rHOlt+2SbtVizO9zb4Ricne+ydzNwnmTmv/t89fvjnPeY1nof7RafmkEHR63U9KW9tb8Wg9n+v+63bfbZtS/K1P0/++98ktQmtl7P22eSbf1tOm6qQS/Z6HCXljaUqXUuVc9Be95M+6j172Gob1Lwq6Z+xaVxSRL+M16TcMVvV62rGnPn1n2ZNnZlc8L7kC79fbnuG0fqVnSl3S4f2IN207Jpk+7bGe/KFJzcu66DFu/7dlo3JQ7f+6O/33VB/vjVS2/VnFp2c3PjIOL8/pXGb1j6bPHpn47h2DMv4qsqZ8aCrwrmV3GB45o1ho197r9dnlEm5z1huvyR54VuS6bOba8PISLL7XvWfA4/7yd9vXJOsfLx+BrnikeTxe5LHlyZr2nzfiP5Z46p4DrXqic7XUTR/mljgu63afNRvhm1vMkzPrm77dnLG2xqfURx0av172by+WLmHn9E4ZuVjzg/KUIX7c/2qcsvbuql3dW9pou5+UIUzj04YxryiH98lGxTDOF6eq9/ea+jE2m/dr65hvX8HOUdecnFy4qsbxx15bnLjl4uVeeS5jWOeeSh59K5i5fWzTs3Z/XI+l3gG1Qn2a+Mb1rUkqX7eBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABVNNrrBgBQLWufSZZ8M1lycbL6yXLKnDi5WNyBx5ZTX6tGG7Rz0m7Fytm4pv22dMqkqcXiNq3tbDuSZOPaZPe9GsdNLtjmojZvTNY9W26ZO0ycUiyu09/vxnWdLb9svrdqGqnV5/X9jkr2PijZ66Bkj7173ar2dXIOGRSDsq4njdf2Zg1y/w9Kv5XZZ0/cm1z1ieRFb229jIv/T3m5XRVyyUEZR0njsVSpa6lwLjUo/TTMfdRp9rDVNch5VdI/Y9O4pIh+Ga9JuWO2qtfVLQctTo57eXLrRb1uyWDbsqHXLehfG9cmy5ck808YP2767GTuwuSp+3f++ynTk30O2/XnH7w52bblR3/fsCp59O5kvyN2/ZlFi5MbvzzO708Zv81Jcu/VjWPaVcXxVdUz4yqowrmV3KCa8wb6tR8MyhllUuwZy9ZNyVWfTF72K+XWPWVGMm9GMu+QH//3NU8nd12W3H5J8uSycuscFv2yxg3i3reRTV04My96Ll8kH6vafNRL9ibD9exq3Ypk2bXJIS8YP250UnLoC5Pbvl2g0JHkkBc2Drv9kkJNbEvV8sWq3p9bN5Vb3thYE3Vv7F3d/aAKZx6dMKx5Rb+9SzYohnW8JP35XkOV1v6qrvv9ZFjv30G+T568L3n83mTewePH7XNYMmvfZMWjjcs84qzGMUu+Wax9/ayTc3a/nM8lnkF1gv3a+IZ1LUmqPe4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoKpGe90AAKrlxi8n13623DJHJ5dbXqfUauP/fuL/z959h9t11XfC/96matmSLbnIXca94ga4AQZCMYEhMRMmJJRA2qQnQHremUkmLyEJgRRSSJkXCCEEQhKabQw2jm1cwd2yrGLLVZLVsCSr3XvfPw4eN+mefc49+5S9P5/nuQ/2vb+91m+fvdZeZW+OZxcrZ8e26edSlhl9dA7btxSLmzGns/U+tbmz5T3b2KxicTu2lpdDkuzaXm75nVa4XfrcBsKio5MXvzE57oJkzn69zqbzyryHDIpBGdeT5mN7qwb5+g/Kdev0NfvWZ5JjXpIccnzrx972lWTlzZ3LpQpzyUFpR0nztlSlc6nyHHRQrlOdr1HZrGGra5DnVUn/tE3tkiL6pb0mnW2zVT2vbrr4J5LVdyQbH+51JoNrfHevM+hv912XHPni5nFLzknWrdrz3446Kxke2fuxy2944e9W3JgceuLejzn81GRsZrJrxwv/Nnvf5JDjps43Se67tnnMdFWpfVV9z7gKqrBvZW5QrfsGz3Bde29Q9iiT4s9YbvtScuTpyfEXlptPksxbmJzzA42fR+5NvvHXyWNLy6+3SvpljBvUte9UurFnvqPo51bgOlfxftRt1ibPqNuzq9u/mhx7XvO4ky9O7vpa87jDTkr22b953N1fbx4zXVWZL1a9f/byOlWljbSrCnseZajzvKKf3iUbFHVuL/34XkMV7utVH/f7SV3776D3kzsuSw7+2eZxJ74iuf7TU8ccfmoyb9HUMRPjyd1XFk6vb5V5z+6X/bnEM6gyWK9Nra5jSTIY1wcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeK7RXicAQHd9d12y8qbWjpkxNznpFcViX/pDyZ2XJ9s2t5zaXg2PdK6sXhopOOpO7C43j+kYGSsW141zmBgvFjfc4dnOru2dLe/Zirb18ZI/335ug3vic6uGfQ9KLnpncuIrk6GhXmdTnjLvIYOiKuN6Owb5+tf1uk1OJF/6UPKuv0jGZhU/buOjyVV/3dlcqjCXrFI7quO5DOJcqirXqcrXqGzWsNU1yPOqpH/apnZJEf3SXpPOttmqnlc3jc1Kvv8Dyad+qfg58DyTvU6gv91/ffKan2m+V3j02cmNn93z3445d+/HTU4mK25+4e9X3Jhc9K69Hzc6Izni9GTFHp61HX12MjQ8ZbrZviV56I6pYzqiAu2rLnvGVVCFfStzg1TivsEeuK49V5U9yuf78h8mcxYkh5/SvToPPTH50Y8kd30tueLPkt07u1f3IOuXMW5Q175TKXtPPinezot8blW9H3WDtckL1e3Z1cpbkifXJfMWTR13xOnJ3P2TrRumjjv+wuZ1PnJPsumx4jm2bcDni7Xpnz28TpMD3kamqwp7HmWo87yin94lGxR1bi99+V7DAN/XazPu95Ha9t8B7idJcu9VySt/PBmbOXXcSRcn13+6eUwzK27s7P9/sFfKvGf3y/5c4hlUKazXplTbsSSpdrsHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIoa7XUCAHTXEw8mV/xZ68ftsyA54vTmcTPnJhe8o706YBDs3tnrDKB6XvSy5I0fSGbM7nUm5XMPqTfXfzDt2pFMjLd2zObHG8cBAOUwrwLoDwcfl5z39uTaT/Q6E6po64bksaXJ4hOnjjvs5GTGnGTntuf9YSg5+qy9H7dmeaOO51u3KvnuumTfRXs/dsm5yYqb9vD7c6bONUlW3Nj6PkMd1WnPGAAG0e6dyT//anLxTyZnvqm7dZ/ymuSAI5J//R/J1o3drRuoH2sTkiSTyR1XJOe/feqwoeHkxJcnt3xh6rjjzm9e5V1XFk+vrvRPoFe8S0ZR3mvoHOM+FLdja3L/dclJF08dt/9hyUEvajwz3ZPh0eT4C5rXd8dlrefYj9yzAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA4V4nAMBguOpvksnJYrGnvS5ZeFSp6UDvFOwHQDHn/GDylt9JZswuv65d28uvoyn3kHpz/QfSG34lmTm3tWOOOjM545Jy8gEAYl4FUKIVNyXf+qfi8S/9oWTxieXlQ70tu655zPBIcuQZL/z9wccmc+bv/bgVN+79bytvmrrOJefs4ZdDydFnTX1cUuyc6q6be8YAQPsmxpMrP5b8y28la1Z0t+5Djk9+6IPJmPkCPTTU6wQoXe3eZ2FKd16eTE40jzvpVVP//ZATknmLpo4Z35Xcd03x3OpI/wR6ybtkFOa9ho4w7kPrbr+sWNxJF+/9b0efncyaN/XxWzYkK28pnldfc88GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDaG+11AgAMhjUrknu+kZz8quaxwyPJxT+RfPY3OlP3xHhnyum1oucx0sej8/iuYnHdOIeidRTNuR+M7y4WNzJWbh5ll99phftWyec13Md9d1qGyiv6+AuTV/54Z8t86slk48PJxkeTDQ8nGx9JNjzS+PeTXpm89uc7Wx+tq8q4Xjd1vW5nvik56sXtHfvKH08evK1xH+qEKswlq9SOqnQuVZ6DVuU6Vfkalc0atiQlrhHqol/aZqXaZaJtlqRf2msrdRTJuarnNV33XJ185Q+TycnkqDOTQ45vfszwSPLGX03+4aeTXU+VniI1s+y65BXvbR635Jzk/uuf+7tjzp36mOU37P1vK25Mzrhk73/f76Bk/8OTDQ8987vFxyez9526zl3bk1W3Th1Td93eM/6lL3S2rrqqwr6VuQGQpJR1ZVX2KKey6pbGz7HnJae8Jjn6rGR0Rvn1LjwyueR9yb/9bvl1DbJ+GeOqOL51Y8+8aB1FniPU4X7USd5nmVodn119d23ywLeTo8+eOu7gFyX7H9a4xnty/IXN61pxU7J9S+s51oX+STdVYc+jDHWeV/TTu2SDos7thekz7veW/ju4Hrqj0aYXLJ467sSXJ1d9PMnkC/928sXN67nra8nkRFsp1kq/7M+1Uscg7dHR34wlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAgGe11AgAMjm/+Q3LcBcnYzOaxR52ZLDknWXnz9Osd31Us7rKPJLt2TL++dj26dOq/795ZrJwZc6afS1l2PlUsbubccvNIkln7FIsrmnM/2LW9WFzZn2+RPt5P+qVdjs0qt/xeGR0rp9wFhyWv/5X2jt29M9nw8HN/Nj6abHw42b6ls3nSeYMyrifNx/Y6GZTr1slrtuCw5OXvaf/4sVnJGz+QfOqXksmJ6edThbnkoLSjpHlbqtK5VHkOOijXqc7XqGz9slZIqrWGLWuNUCf90jar1C4TbbMs/dJek8622aqe13R854vJ1z6WZLLx71/+w+RdH0tGZzQ/dv7Byat/Ovnqh0tNkRra9Fiy7oFk0VFTxy05ew+/O2fv8Vs2JGuW7/3vD97WWCNMNQdecnay4aFn/fu5U+eYJKtuTXb3eI3Yz+wZD64q7FuZGwBJOevKQdmjTKb/jOX+6xs/M+YkR5+VHHxccvCLkgOPSWbv25kcn++485Njz2vUy571yxhXxfGtG++IzJpXLG7ntuYxdbofTZe1SXN1fXZ1+2XJ0XvYg3i+ky5Orv3Env92/AXNj7/rytbyqhP9k26rwp5HGeo6r+i3d8kGRV3bC9Nn3O89/Xew3Xl5ctG7p47Z54DkiNOS1bc/9/djs5NjXlKgjivaz69O+mV/LqnmHh39zVgCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyS0V4nAMDg2PJEcssXkpe9rVj8K38iWXVrMjkxvXp37ywWt/r2ZNNj06urTLt3FIubuU+5eUzHzm3F4rpxDkXr2Lm13Dw6addTxeJmzi03j35ug3uya3uxuLI/t1kll1/E0FDnyxyb3fkyk+TCdyQzZhWPf3Rpct81yYO3J+tWTX9soXeqMq7XTd2u29Bw8sb3J2Mzp1fOIccnL/tvyfX/OP2cqjCXrFI7qtK5VHkOWpXrVOVrVDZr2MFaI9RJv7TNXu6taJuDo1/aayt1FGmzVT2vdl3/6eTaTzz3dxseTq75h+TinyxWxqnfl6y4MVl2Xefzo96WXZcsOmrqmHmLkgOOSNavbvz77P2Sg4/be/yKm6Yub/fOxjrhmHP3HnPMuY1nZk9bcs7UZSb6RzP2jAdXFfatzA1g8AzKurIqe5St2Lktue8/Gz9Pmzk3mX/IMz8LFifzFycLDkn2WTi963nBjyb3Xz/9vKuqX8a4Ko5vs7owLyj6HkqR92bqeD9ql7VJc3V9drX8W8m2Tcmc+VPHnXTxC/fakuSgY5P9Dpr62Ke+m6y8ud0Mq0//pNuqsOdRhjrOK/rxXbJBUcf2QmcY93tP/x1sd34tueAdyfDI1HEnvbJxDZ/t2Jc1H/MeuivZ+Mj0cqyLftmfa6WOQdqjo78ZSwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAQTLa6wQAGCw3/HNy2uuSufObxx5weHLGJcl3vji9OrdtKhY3d/9k02PTq6tMWzcUi5s9r9w8pmP7lmJxc/YrN4+k+Oe0fWu5eXTSzqeKxZX9+c4/uNzyO63o5zZ733Lz2O+QcssvYmxW58sso70tPDI5/sJisY/fn1zxZ8njy6Zf74w50y+D6avKuF43dbtuL3tbcsjxnSnrvB9OVt48/ftYFeaSVWpHVTqXKs9Bq3KdqnyNymYNOzhrhLrpl7bZy70VbXNw9Et7TTrbZqt6Xq2anEyu+pvkli/s+e+3/Fty7HnJ4acWK++1v5A8ck+ydWPHUoTcf11y/tubxy05O1m/uvHPR5+VDA3tPXb5Dc3LW35Dcsy5e//7Yac0xrNd25O5C5KDXjR1eeO7kxU3Nq+3rnq1Z0xnVGHfytwABs+grCurskc5XTu2JmuWN36eb2Qs2e/gZP9DG3OqJee09oxm0dGNNctDd3Yu3yrplzGuiuPbfl3YMy/6nsvObc1j3I+K8T5LMXV9djUxntx1ZXLupVPHzT84WXxC8ujS5/7+hAJta+k3k4nd7edYZfonvVCFPY8y1HFe0Y/vkg2KOrYXps+43x/038G2dUOy6tapn3cmjb72tb9Ixnc987uTL25e/p2XTy+/OumX/bmkmnt09DdjCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwSIZ7nQAAg2XXU8m1nygef8GPJjP3mV6dT64vFjdv4fTqKduTTxSLW7Sk3DymY8PDxeIOPrbcPA44Ihmb1TxuYjzZ9Fi5uXTS5seLxR30onLz2P+wcsvvtO+uKRZ30DHl5rH/oeWWPznRPGbG7M7Xu6CE8zrxFcnQUPO4R+5NPv2+5PFlnal3zr6dKYfpqcq4Xjd1um4HHZuc9/bOlTc8krzxA8nozOmVU4W5ZJXaUZXOpcpz0Kpcpypfo7JVeQ1bZH2QDM4aoW76oW2WtbeibVZPP7TXpPNttqrn1YqJ8eSrH05u+cIUQZPJV/4o2flUsTJn75u84X0dSQ/+r7Urk00F5sRLznnmn485d+9xu3cmq7/TvLyVN03995Gx5MgzGv989NnN9ztX357s2Nq83rrq1Z4xnVGFfStzA+gfVVtXVmWPskzju5INDyXLb0iu+1TyyV9o/KxdWbyMo84qL79B1w9jXFXHt30XJWPTfP43paHkwILvuRRZM7kfFeN9lmLq/Ozq9suKxZ30qhf+7rgLmh9315Wt5VMn+ie9UIU9jzLUbV7Rr++SDYq6tRc6w7jfH/TfwXdHgfXLzLnPfc46Z7/kyBdPfczObcl910wvtzrph/25pLp7dPQ3YwkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMEiGe50AAIPnjsuS9auLxc7eNznvh6dX3+bHisUtPmF69ZRtU8HzOOS4cvOYjnUPFItbfGKpaRQuf9OjycTucnPppA2PFIs7pOS2fvhp5ZbfaRseLhY36J/b7p3NY+bM72ydBxyRjM3sbJlJctSZxeIu/2iye0fn6t3ngM6VRfuqMq7XTV2u28hY8sb3J8MjzWM3r0lW3FSs3P0PS1753unlVoW5ZJXaUZXOpcpz0Kpcpypfo7JVeQ1bZH2QDM4aoW76oW2WtbeibVZPP7TXVsov2marel6tWLsyuetrzeM2r0mu+njxco8+KznzTe3nBXty//XNYw47pTEWDA032uHerL492VVgz/HJJxr9ZCpLzv3e/57TvLxl1zWPqbNe7RnTGVXYtzI3gP5RtXVlVfYou+2x+5JP/VLy+LJi8UeeXm4+g6wfxriqjm9Dw8mhp5RX/sIjkxmzi8UWeY7gflSM91mKqfOzq40PJw/d1TzuhIsa94mnHbgkWbB46mM2PNIYA9kz/ZNeqMKeRxnqNK/o53fJBkWd2gudY9zvD/rv4FtxY7J1U/O4k175zD8ff1Hzce/ea4o9b6WhH/bnWil/0Pbo6G/GEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgkAz3OgEABs/kRHLVx4vHn/mmZMHi9utbu7JY3GGntF9HNzy+vFjcwiOTGXPKzaVdTzxQLG7+Icm8ReXlccRpxeKeWF1eDmXY+EixuP0PTeYuKCeH4ZHkyBeXU3ZZCn9uhyWz9ysnh6Hh5Mgzyin7aTufah6z6OjO1nn0WZ0tL0mGR5ODj20et+6B4vecog49ubPlVdnQUHllV2Vcr5u6XLeXvyc54IhisZd/NLnsT5LtTxaLf/H3J0ef3X5uVZhLVqkdVelcqjwHrcp1qvI1KluV17BF1gfJYKwR6qgf2mZZeyva5guVub7qhn5or0nn22xVz6slk8VDb/9KsuqW4vGveG/r6cBUll3bPGZkLDnijOSQ45NZ8/Yet/yG4vWuuGnqvy85p7E3fNSZU8dNTibLv1W83rrp5Z5xvxnUeUMV9q3MDepnUPtbHVRtXVmVPcpe2L2j8SymiH0PLDeXspV5T+qHMa7K49uSc8or+/CC94VdO5ItTzSPcz9qzvssxdX92dXtX2keM2e/584vjr+w+TF3X9l+TlWnf9IrVdjzKEOd5hX9/C5ZJ3lflH5i3O8f+u/gmxgvts445iXPzGVOvrh5/J2XTS+vuumH/bmk2nt09C9jST147goAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAVQz3OgEABtPKm5MHv1MsdmQ0ecV7269rzfJicQcuSebMb7+esq1dkUxONI8bHklOeXX5+bRj3QPJtk3FYl/8xnJymL1fcvyFxWKLttF+8fiyZHKyWOzpry8nh+MvSGbPK6fssjxW8HMbGkpO/b5ycjju/GTOfuWU/bStG5rHHHRMZ+s85TWdLS9pfE5DBVYh6x7obL37HpjMP7izZQ6i8V3F4mbMLi+HqozrdVOH63bE6clZby4We+cVyQPfTrZuTL7+V8XreP0vJ7PaHGerMJesUjuq0rlUeQ5aletU5WtUtiqvYYusD5LBWCPUUa/bZpl7K3Vqm/2wvuqGXrfXpJw2W9XzKtNX/yTZvqVY7OiMZHi03Hyol0fubazBm1lydnLMuVPHrLipeL0rbpz67/suSk5/QzJrn6njHi2Yf131cs+4W6o+b6jCvpW5QXVUvb/VQdXWlVXZo+yVNSuSjY82j5u9b/m5tKMf7km9HuOqPr6d/KrGGrgMZxS8Ho8tLRbnftSc91mKq/uzq2XXFtsnO+niZ/75+Aumjp2cTO75xvTyqjL9k16pwp5HGeoyr+j3d8mK6Ic1SV3aC51j3O8f+m813HFZ85jRGY3/P8x+ByeLT5w6dv3q5NGCexE09Hp/Lqn+Hh39y1gy2PphPQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3TTc6wQAGFxXfTyZnCgWe+x5yeGntVfP1o3J+tXN44ZHktNf314d3bBja/LYfcViz/z+cnI4cMk0C5hMVtxULPT0NySjM6dZ3x68+JJkdEax2OU3dr7+Mm3bnKxbVSz2jDcmw6MdTmAoOfetHS6zC7ZtKv65nfmmZKiEGfC5l3a+zOf77trmMUe+OBnrUL874owO3DP2YM5+xeJ2butsvae/obPlDartW4rFzV1QXg5VGdfrpurXbcac5A3vS4aGmsdu2ZB846+f+fe7v56svLlYPfvsn7z2F9rLsQpzySq1oyqdS5XnoFW5TlW+RqWr8Bq2yPogGYw1Qi31uG2WubdSp7bZD+urrqjqvbSq51WiLeuTKz9WPP7Cd5SXCzU0mdx/ffOwo89Jlpy797+vXZk8ua54tY8ubczHp1KkrS+7tniddVSHPeOqzxuqsG9lblAdVe9vdVC1dWVV9iinsvjE5MBjyit/06PNY0bGyrk3T1df3JMqvA/VD2bPK6fvHnFGsuioYrGrbi0WV4f70XTVYW3SKXV/drV7Z3LPVc3jjn1ZY75ywBHJ/odPHfvw3cnmNZ3Jr4r0T3ql13se/fpstg7zikF4l6yIfliT1KG90FnG/f6h/1bDhoeTR+5pHnfSK5MTX9E87o7Lp51S/XgGRY0ZSwZbP6wnAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKCbhnudAACDa+3K5O6vF4+/+CeTDLVX18pbisW9+PuTkbH26pjKGZckM+dOv5wVNxWL2//w5PQ3TL++ZztwSfLOP09+5CPJEWe0X8791xeLmz0vecV72q9nTxYcmpx7abHYtSuTJ9d1tv5uePC2YnH77J+c98OdrfvFlyQHvaizZXZL0c9t30XJOT/Y2bpP/b7kkOM7W+aerFvVPGZsVnLs+dOva2g4edVPTr+cPSl6j569b+fqnDEnOfP7O1feINv+ZLG4g48rN49ej+tJ58b2Oun1dSvzmr36vzfGiCKu+NNkx9bn/u7yj77wd3tz/AXJSRe3lt/TqjCX7HU7SjrXlqp0LlWeg/b6OrlGvVfVNWyR9UEyGGuEuupV2yx7b6VObbNf1lfdUNV7aVXPq0z3fKP453bupcnhp5abD/WyrEDbm39wctAxe//7ihtbrHQyWdVkTVFkH7NI7nVWhz3jOswbqrBvZW5QDXXob1VXxXVlr/cok3KesRx8XHLp7yU/8ifJa3++s2W3ZbLXCbxQv9yTqroP1S8ueEcyd0Hnyhud0dp96YHvFI+t6v2oU+qwNumkuj+7uuOrzWPGZiUvOi85/sLmsXdfOf2cqkz/pJd6tefRqf2OslR9XjEo75I10y9rkqq3FzrLuN9f9N9quOOy5jFHnJ6c0WQuMzHe2v+HkGd4BkWdGUsGV7+sJwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgW4Z7nQAAg+2a/y/ZtaNY7EHHJKe+pr167rmqWNw++yeveG97dezNiS9Pvu/nkvd8PDn2vOmVdfc3ksmJYrEX/2Sy8Mjp1fe00ZnJJR9IhoaTxSckb/tg8kMfTA45ofWyVtyUbF5TLPbMNyXHX9h6HXsyOiN5828mM+YUi//OlzpTb7fde3Xx2Je9LTnyjM7Ue9AxySt+vDNl9UIrn9tF70oOPbkz9R5wRPKqn+pMWc08vrxY3Pk/koyMTa+ui96dLDp6emXsza7txeIWt3F/2pvv+7lk5tzOlTfItm0qFnfEacncBeXl0ctxPens2F4nVZmPPd+x5yWnvLpY7L1XJ8tveOHvn3wiufpvi9f5mp9J9j2wePzTqjCXrFL/r9K5VHkOWpV7V5WvUdmquoYtuj5I+n+NUFe9aJvd2FupU9vsl/VVN1T1XlrV8yrb5R9Ntm1uHjc0nFzy/uLnCc2svi3ZvmV6ZSy/sY1j9rAP0Iq1K5PNj0+vjKqrw55xHeYNVdi3Mjeohjr0t6qr4rqySnvJSXLgkuQH/kfyjj9Nlpzd+N0hxycv/aHpl70n8xc3j5mcSHbvLKf+6eiXe1JV96H6xcy5yZt+Ixke6Ux5r/6Z4velDQ8la+4vXnbV7kedVoe1SSfV/dnV2pXJ48uax518cfP76u6dyX3/2Zm8qkr/pJd6sefRyf2OslR5XjFI75I10y9rkiq3FzrPuN9f9N9qWPrNZOdTU8cMjzQfi1bcWHxs4bk8g6LOjCWDq1/WEwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQLcO9TgCAwbblieTmzxePv/Bdydis1utZc3+ydmWx2LPenBx7Xut17MniE5LX/XLjn/fZP3nL7yRv/s1kzvz2yvvummTVrcVix2Yml/5esujo9up62shY8l9+O1l01HN/f+QZyY9+JPmB/9FaHZMTrV3zS96fnPDy4vF7Mmte8tb/nRy4pFj81k3JXV+bXp298viy5PH7i8UODTeu7VFnTq/OhUclP/i7jTY3qFr53IZHGn35sFOmV+f8Q5JLfzeZMWd65RT16L3Jrh3N4xYsTi58Z/v1nP6G5CVvbf/4Zp5cXyxu3sJkyTnTr+/MNycnvXL65VTFY8uKxY2MJS//sfLy6NW4nnR+bK+TqszHnm3O/OS1v1Asdtum5MqP7f3vt381efC2YmXNnJu84X1JhorFP60Kc8kq9f8qnUuV56CtXqdOcY36R1XXsEXXB0n/rxHqqttts1t7K3Vqm/2yvuqGqt5Lq3peZdu2ObniT4vF7ntg8pqfKTcf6mNiPFl5U/vHb9uUPHZf68eturVRd7uWXdf+sXVRhz3jOswbqrBvZW5QDXXob1VXxXVlVfaSDzgiefNvJe/8i+RFL33h3y98Z3LSxdNK9wUWn9C4zs1sKTif6LZ+uSdVdR+qnxx+avL9v5YMj7ZfxtBw8qqfSk57bfFjvv2l1uqoyv2oLHVYm3SSZ1fJ7Zc1jzn6rBeuWZ5v+Q3Jjq0dSamy9E96qdt7Hp3e7yhLVecVg/YuWTP9siapanuhHMb9/qL/VsOuHcnSb06/nDsKrIHYM8+gqDNjyeDql/UEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHTLcK8TAGDw3fjZZOvGYrH77J+85L+2X09Rb/7N5NTva6+eZ/uvH0zGZj73d8dfmLzn48nJr26vzOs/XTx230XJ2z+cnHRxe3Xte1Dy3/4wWXL23mNe9NLkXR9L3vhryYw5xcq94/Jky4ZisaMzku//teSidzf+uVWLT0h+9KPJ4acWP+aWf03Gd7VeV7/49n8Uj505N7n0d5NzLk2GR1qv66SLkx/+o0bfHHStfG5z9kt+6IPJmW9OhtqYER/z0uTtf5Lsd1Drx7ZrfFfywLeLxZ57afKy/9Za+cOjySvek7z251vPrRU7tiTbNhWLffV/b1yrdp339uTVP93+8VX02NJkYrxY7CmvSV79M8nIWDm59GJcP/a8csb2Oun2dSv7mr3uF4vfZ678WPLUd6eOuexPkp3bi5V3xGnJOW8pFvtsVZhLVqn/V+lcqjwHbeU6uUYNVVonJNVcw7ayPkj6e41QZ+22zVZ1c2+lTm2zn9ZX3VDFe2lS3fMq27LrknuuKhZ78quSE15ebj7Ux33Xtn/sypuTTLZ+3M5tycN3t1/vsuvaP7Yu6rBnXJd5QxX2rcwNBl9d+luVVXVdOeh7yWe9Ofmxv0qOvyAZGtpzzNBwcsn7kwvf2fiMp2v2fskb3lcsdv3D06+vDP10T+rWGFfn8e34CxvzkwWHtn7svEXJpf8rOeu/FD9m57bkrq+1Xteg34/KVIe1SafV/dnVPVc1fz+gyHtpd1/ZmXyqTP+k17q551HGfkdZqjivGMR3yabST2uSKrYXymHc7z/6bzXccdn0jt+yIVl5S2dyqSvPoKgzY8lg6qf1BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB0w9Dk5ORkocChobJzAWAa3v1XyaKjmsetvCX53G91vv6h4eTdf5ksPLJY/D1XJV/6g9brWXxi8vY/btRX1PjuZOXNyapbkofvTrZuTJ76bpLvjYDDo8nsfZP9D00OPj455pzk8NOSokPftZ9Mrv/H1s5jn4XJj/1lMmtea8cljfN59N5kw8PJts3JU5sbuc6Ym8xbmBx0THLgMcXzf9q//FbjM2rFm38zOf7C1o5JksmJ5NH7kiceTLZuSLY/mYzOSOYuSOYtSg4/tXFN2in3U7+cPLa09WOXnJNc+rvN4x5flnzi51svv1VHnJG87YPtHTsxnjxyb7LhoUZ73/5ko53P2Tc54Mjk0JOSWft0Js8Pva4z5XTKdD638d3JI/d8r29teuZzm71vcsDhjc+tnXa5J+1+bkPDyXs+3rhfteLJdcnqO5It6xv3jQw12sPCo5LDT0lmzGkvn2f7+l8mt/57sdhTXpO84VeKlz2+O1l2XXLPNxr9e9vm5/59eCTZ76DG9T/mJckx5+79Hjg50XwMuf/65Av/q3h+Sf/dQ6bS6uffquU3Jv/6/xSL7cdxPWl9bB+k698J7V63r/9l/1yz/Q5qzF2L3P+2b0n+7scbeRcy1Ph8Dj2pWPjalY12MbG7YPmpxlyyKv0/qda5VHkO2up1co2mp9/WCU+r0ho2aX99kPTfGuFpdZtXPa2dttmv7TKpZtvcm35aXyXd6UNVu5c+rUrn1c176dFnJ2/9vWKxq29PPvOr06uvk8r8nPphPPvAZcXi/vxtjb3QQfKW30mOPa+1Y8Z3J3/61mTXU+3Vuf9hyXv/tvXjbvqX5Oq/a6/Ovalq++rVnnFZ+8V70m/zhrJUYd8qMTfotG6PS/3S38w3Gtq5rlVdVw76XvKbfiM54aLi5SbJ7p2NZ/CP3JNseizZvCbZtb3xMzmRjIwlYzOT2fOTBYckBx+XHPniZO781ur5+HuTjQ+3dky39Ms96WlljXHHnd9emZ1Y03da0XtsERseaZzfpseTHVsa89Q5C5J9FiSLT0rmH9xmuQ8nf/9TrT1ffLZBvx+VqYrvs5St7s+uFp+Q/MhH2j/+1n9vzC06rYrzxSr2z15dp5Gx5Fe+WCz2Iz+Q7NzWubrf9qHkiNOax/3H7ydLrylebjc+y37b82hnv6MMVZlXDPq7ZFPppzVJVdpLP4yzz9frnIz7zfX6Gk1XFfpvP1yDXj/DPecHklf+RHvHfvw9ycZHOpvP06q+l/58nkF1Vln9ynpt71pdrz2tCmNJ0vt2X9fnrgAAAAAAAGUq+LXse+S72gEAAAAAAAAAAAAAAAAAAAAAAAAAAACAQeW72gEAAAAAAAAAAAAAAAAAAAAAAAAAAACAOiryXe2jXcgDgBqYnEiu+njy1t8rFn/iK5Jb/z15bGlr9Tx6b3LT55KX/Nfix4yMJse+rPHztMmJZHx3MjzS+GnX4/cnN3ym9eO2PJFc9tHkzb+ZtPrfRxkZTQ4/tfHTKXdekay6pfXjLvtosvCo5IDDWztuaDg59MTGTydd/fett6l+tfq25I7LktNe1/qxwyPJ4ac0ftr10F3JAYclc+a3X0YvTOdzGxlNjjit8dOvJieSaz+RvOnXWztu3qLk5Fe1V+funclDdyZHn9Xe8Xty338mF/9EMmtesfiR0eTElzd+kmTX9mTH1sZ9fNY+ycy5xev+9heTs97ces5Vcu/Vyct/LJm7oNeZ9N+4nrQ/ttdJu9ft+37umX/v6TUbSt7w/mTGnGLh3/jrZOvGFsqfTL7y4eTdH0tGZzQPP3BJcuE7k2/+XfEqqjCXrFL/r9K5VHkO2up1co32bFDXCU+r2hq23fVB0n9rhLprp232a7tM6tU2+2l91S1Vu5c+rarnVbZVtyS3X5acXmBucsTpydlvSW75Qvl5UW3LrkuOPa+1Yx66M9n1VPt1bng42fhosmBxa8ctu679OuumV3vG3dwvrsu8oQr7Vom5waCrS3+rsqquKwd9L/nrf9V4lt7K3uDojOTIMxo/ZVl5S7Lx4fLKn65+uyf10xg3yOPbA99ODj0pGZs1ddz+hzZ+Oml8d/LVDycTu9svY9DvR2XyPkvr6v7s6tGlyRMPJguPbO/4u67sbD5Vpn/Sa/2059HufkcZKjGvqMC7ZFPppzVJJdoLXWHc7z/6bzXc9fXkoh9rXJtWPHxXsvGRcnKqo37an0sGe4+OwWIsGUz9tJ4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgLIN9zoBAKpj1S3JA98pFjs0lFz8k+3V881/SJbf2N6x/7f+4WR0RjI80n4ZW9Yn//57ycR4e8cvuza55h/ar79T1q1Kvvbn7R27Y0vyud9Ktm7qaEptue3Lyc2f63UWnfW1v0gev7/79e7clnzlj5KJie7X3Qm9+tzWrOhOPUu/may8uTt1Jcn1n07Wr+5smbu2JzdNo7+OzUr2OSDZ76Bk5tzixy3/VnLPVe3XWxXju5JrP9nrLJ7RL+N6Mv2xvU6me916ec3O+cHk8FOKxa66Nbnra63ntfHh1vrZuT+YHFYwp6dVYS5Zpf5fpXOp8hx0kO9dz1bla1S2Kq5hu70+SMpZI9Rdv7TNTu6t1KVt9tv6qhv6pb0mnW2zVT2vbvjGXyeb1xSLvejdyaKjy82H6lt+Y+tz6eU3TL/eFTe1Fr9lQ/Lo0unXWxe92jPu5n5xneYNVdi3MjcYbHXqb1VW1XXlIO8lb92QfOlDyWQf7Q+O70qu/nivs5hav92T+mWMG/TxbdNjyTf/vjd1X/Xx5JF7pl/OIN+PyuR9lvbU/dnV7V9t77j1DyVrevC5DSr9k37QD3se09nvKMugzyuq8i7Z3vTbmmTQ2wvdYdzvT/rv4Htqc7KijWt4x+Wdz6XO+mV/Lhn8PToGj7Fk8PTbegIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyjTc6wQAqJar/iaZnCgWe+iJyQkXtVHJZPLF308evK2NYztk2+bkn3892bxmeuXc+Nnkun/sTE7teOLB5LO/keze2X4Zm9ckn/315MknOpdXq26/LPnaX/Su/rKM70q+8D+TjY92sc7dyb/972Tz492rs9N68bltXpN8+UPdq+8rfzT9+08R91+f3PDP5ZR90+eTtSvLKXtP1q5MvvihJJPdq7Of3f6VZOk1vc7ie/pgXE86N7bXRh9ct3au2cKjkgvfUSx251PJ5R9tK7Ukyc2fTx5fVix2aDi55P3JjDmt1THwc8k+aEdJh/p/hc6l0nPQPrhOrlHvVXEN2631QVLuGqHuet02y9hbqUvb7Kv1VZf0ur0m5bTZqp5X2XY9lXzlj5PJAnsuozOSN/5qMjJWfl5U144tyeo7Wjtm5U3Tr3fFDa3F33/99Ousm17sGXd7v7hO84aB37eKucGgq1N/q7JKriv7YI8yaX+f8oFvJ1f8WfH3gsp21d827vn9rt/uSb0e46oyvn37P5I7r+hunbf+e/Ltf+9QYQN+PyqT91laV/dnV3d/vb21x91Xdj6XqtM/6Qe93PPoxH5HKQZ4XlG1d8n2pq/WJAPcXugu434f0n8r4Y7LWovfuS25r1/GkArp9f5cUp09OgaMsWQg9dV6AgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABKNNzrBAColnWrkruuLB7/8vckI2Ot17NrR/K5306WXtP6sdO1dmXyyZ9P1q/uTHnXfTK57CPJ7p2dKa+ox5cl//SBZOvG6Ze1blXyyV9I1qyYflmtmJxMrv675PKPJJMT3a27W558Ivn0ryRPPFh+XeO7ki//YfLAreXXVbZufm7fXZv8868l2zaXX9fTtm1u3AM70X/35qE7ky/9QZLJcsqf2J382+8mWzeVU/6zrVmR/MtvJrueKr+uQXLZR7p/396bXo7rSefH9roYtPnY8Gjyxg8kozOKxV/9t417fLsmJ5KvfDgZ310sfr+Dklf9dOv1DPpcskr9v0rnUuU56KDdu/amyteoG6q2hu3G+iApf41Ab9pmmXsrdWqb/bS+6paq3UufVtXzKttDdyTf/vdisYuOSi56d6npUAPLri0eu351sumx6df50F3Jzm3F41vJkYZe7Bn3Qp3mDYO+b5WYGwy6OvW3qqrqunLQ95Jv/2ryH/9vY9+wl67/dPF1SD/ot3tS1faheuWyjyTLrutOXTf8c/L1v+xsmYN+PyqL91naU+dnV9ufTO6/vrVjJieTu79RTj5Vpn/SL3qx59HJ/Y4yDOK8oqrvku1NP61JBrG90H3G/f6k/w6+VbcmT64rHn/vNY3rTud5BkVdGUsGUz+tJwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgLMO9TgCA6rnm/yS7theL3e+g5Oy3tFfP+K7kP34/+dqfJ7t2tFdGKyYnku98MfnULyab13S27DsuSz75C8m6Bzpb7p5MTiY3fT751C8nT23uXLlb1jc+mxv+OZkY71y5e7P+oeSf3pfc9C/l19VrWzcm//jLyT1XlVfHU99NPvsbydJvlldHt3Xjc3vsvuQffyXZ9Fh5dezN+tXJp3+l0Rc67b7/bLSHsu+tmx5LPvOBZOOj5dWx7Lrk07/caA88185tyT+9P7n/+l5n0tDtcT0pd2yvi0Gaj13wo8mBS4rFPnRnctuXW07vBZ54IPnWPxWPP/U1ybHntV7PoM8lq9T/q3QuVZ6DDtK9aypVvkbdULU1bJnrg6R7awS62za7sbdSl7bZb+urbqnavfRpVT2vsn3z75MNDxeLPfstyRFnlJoOFXf/9Y31aRHLb+xMnRO7kwe+Uyx2+5PJ6js6U2/d1GHPuG7zhkHft0rMDQZZ3fpbVVV1XTnoe8n3/WfyiZ9PHl/WkdRasnN78tUPJ9d+ovt1T0c/3pOqtg/VC5MTyb/9XmMOUpYdW5MvfSi55h/KKX/Q70dlqcPapAx1fnZ1+2WtxT90Z/LkunJyqTr9k37RrT2PsvY7yjBo84oqv0u2J/22Jhm09kJvGPf7k/472CYnkruuLB5/Z4trHVrjGRR1ZSwZPP22ngAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAMoz2OgEAqmfrhuSmzyfnv71Y/Mveltx5RbJtU3v1fedLyfIbk1e8NznhomRoqL1yprL69uQbf52sXdn5sp+2blXyf/57csYbkvN/JJkzv/N1PHZfcvXfJg/d2fmyk2R8V3LNPyT3Xp1c9O5kyTmdvx7bNiW3fKHRxiZ2d7bsfrZja/KlP0iWfyt5+XuS/Q7qXNlLr0mu/Fj7fbCflfW57d6Z3PS55Pp/TCbGO1NmOzY+mnzi55Jf/EJn+trO7clVf53c/tXpl1XU+tWNe9+rfjo57bWdK3fLhuTrf5nc95+dK7OKdm5LvvC/kuPOTy54R7LwyF5n1J1xPenO2F4n/T4fW3xicu6lxWJ37Ui++uHW69ibGz7T6GMHLikW/7pfTB69N9m6sbV6qjCXrFL/r8q5VH0O2u/3riKqfo3KVrU17NPrg1f+RHL66wd3jUD5bbPbeyt1aZv9uL7qhqrdS59W1fMq0+6dyZf/KHn7HyfDI1PHDg0ll7wv+fufSnZs6U5+VMvWjcmjS5NDT2weu+KGztW7/IbGfb5p3I3J5ETn6q2bOuwZ123eUIV9K3ODwVW3/lZVVV5XDvJe8rpVySd/MTnjkuQlb032PbBzZe/J5GSy7Lrkqo8n311Tbl1l6cd7UtX2oXpiMrn648mqm5PX/mIy/+DOFX3/txr79E+u61yZezPI96Oy1GFtUoa6PrtafVuy6bFk/iHF4u++stR0Kk//pF+UvedR9n5HWQZhXlGHd8n2pB/XJIPQXugt437/0n8H1x2XJy99W/Nrtv6hxjNZyuUZFHVmLBks/bieAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBOGu11AgBU003/kpz++mSf/ZvHzpiTXPjO5PKPtl/fk+uSL/6/ybWfSM56c3LCRcmc+e2X97Q7r0hu/bdk7crpl1XE5ETynS8ld1yenPiKxme4+MRkaKj9MifGk9W3J9/+YrL8Wx1LdUrrViWf/51k4ZHJ2W9Jjj0/mT2v/fImJ5PHlyV3XJbcdWUyvqtzuQ6apdcky65LTnl1ctZbkkVHtVfO5GSy4sbkxs8mj9zT0RT7Uqc+t51PJfd8I7nhs8l313Q0xbbt2p584ueSl74tOe68ZGi4jTJ2JLd/pdEetm7sfI5N69+eXPYnjXvuWW9Ojjs/GR5pr6xNjyU3fT6564pk987O5llly65r/Cw+sTGGHnlGcsAR7V+H6SprXN+5Lbnv2u6O7XVSxnXrxDUbm5lc8v7i7fk//0/jXtIpE+PJVz+c/OhHi+Uwe9/k9b+cfO63W6+rCnPJKvX/Kp1Lleegz79OZ75p+mW6RoOnSmvYXduTK/60Mb8f5DUCDZ1sm73eW6lT2+y39VW3VOle+mxVPa+yPLY0uelzyUt/qHnsvIXJa38++Y/fLz8vqmnZdcmhJ04d89STySP3dq7OlTc3+nGzdfayaztXZ13VZc+4TvOGKuxbJeYGg6xO/a2qqryuHOS95MmJ5DtfTG77cvKilyanvyE5/NTGs5lO2bopWXp1cttXkvWrO1duL/XjPalK+1C98uBtyd/9eGOf/pxLk/0Pba+c3Tsb+/Q3fCZZs6KjKTY1yPejstRlbVKGOj67uuOy5KJ3N4/btaPRJ5ge/ZN+0ek9j17sd5Shn+cVdXqXbG/6bU3Sz+2F/mDc71/672Da/Hjy0B3JEadPHXfHZd3JhwbPoKgrY8ng6bf1BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB0ytDk5ORkocChobJzAYCOGRpODj0xOezUZPEJycIjk3mLkpHRvR8zMZ5sXpNseDhZuzJZdUvy8F3dy3lv5i5IjjqrcR4HH5vsd3AyZ7+9x4/vTp54MFm7Inl0aXL/dcm2zd3Ld0+GhpPDTkmWnJ0sPCpZdHSy76K9x+/anqxfnax7MHn03mT5DcnWDV1Ld6Dsf3hy3PnJ4uOTA49J9j1wz3ET48mmRxuf6QO3JstvrPdnWvRzG9+VbHw0eWxZsurmZOUtyc5te46dMz/52c8Uq/9Dr2sr7abmLkiOPT858vTk4OMa/Wxo+IVxE+ON81q7otG/lt+Y7HqqnJzaMW9hcvTZyaEnJYtPTBYsToZH9hy7dVPyxKrkkXuT+69P1izvaqqVNjKW7H9Yss8BjbY1OjMZHUuaLQ03Pd64Fp3UqXH90Xsbv6c7nn/djj7bNeuFQZ9LVqn/V+lcqjwHPexk16jfr1E3VGkNW5U1Ag1Pt81zLx3sdpnUr2320/qqW6p0L322qp4XQL+r055xneYNg75vlZgbDLo69bcqqvK6ctD3kkfGkkNPblyb/Q9vjNsLFidjs5ofu2NrsvGxxnk8fl/y8N3J48vKz7kf9Ns9qdUx7vFlxrfnO+hFyYte1pjDLjwy2Wf/PceN72p8dmtXJKtvb3x+e3svpdsG/X5UhjqtTTqtDs+uzrk0eeV7m8fde3XyxQ+Wnk7t6J/0k+nseXzz73q/31EG84r+109rEu2FZoz7/Uv/hc7xDIq6MpYMpn5aTwAAAAAAALSq4Ney75HvagcAAAAAAAAAAAAAAAAAAAAAAAAAAAAABpXvagcAAAAAAAAAAAAAAAAAAAAAAAAAAAAA6qjId7UPTRb8Rndf3g7AwBtK5uybjM1q/AwNJ5MTyc6nvvezLZkY73WSxYzOTGbtk4zNbPzz5ESyY1uyY2vjXNL+f6+la4ZHk5lzk5lzGtdjYryR/45tya6nep3d4BoZ+97nuk8yOpbs2t5o29u3JhO7e51d/3r+57Z7R6Mvbdvc6F9FzJmf/OxnisV+6HVtp9qS4dFk7oLGvWJkLNm9K9m5Ndm+JRnf1Z0cOmVsVuO+N3OfZ+55O7/3Q01VaFyvDdesbwz8XLJKbaki51LpOahrxPdUZQ1bpTUC1WmXibZZF1Vqs89W1fMC6Hf2jKtp4PetYm4AvVL5dWUF9inHZn4v/9nfO4ehRs4Tu5Od25PtT1bkWlWYMW56xmY1Pr8Zsxv3qf87x9lW/L2UvlCB+1GnWZu0p4rPrt71seTAJc3jPvfbycqby88H/ZP+UoU9j44zr6AV2gtNGPf7mP4LHWN/jtoylgAAAAAAAFCigl/Lvke+qx0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAGFS+qx0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAqKMi39U+NFnwG919eTsAAOzdnPnJz36mWOyHXldqKgAAAAAAAAAAAHTBgUuSd32sedyWDclf/kgyOVF+TgAAAAAAAAAAAADA1Ap+Lfse+a52AAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBQ+a52AAAAAAAAAAAAAAAAAAAAAAAAAAAAAKCOinxX+3AX8gAAAAAAAAAAAAAAAKiU015fLO7uK5PJiXJzAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoDXDvU4AAAAAAAAAAAAAAABgkMzaJzn54mKxd15Rbi4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC0brjXCQAAAAAAAAAAAAAAAAySc9+azJzbPG717cmGh8vPBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgNYM9zoBAAAAAAAAAAAAAACAQXHgMck5P1As9uZ/LTcXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2jPc6wQAAAAAAAAAAAAAAAAGwb4HJv/lt5KRseaxGx9NVtxUfk4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC0brTXCQAAAAAAAAAAAAAAAPS7Ey5KLv7JZJ8DisVf96kkk6WmBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQJtGe50AAAAAAAAAAAAAAABAry08MhkaToaGkpGxZMbsZL+DkgNflBz70mTeouJlPfFgcs9V5eUKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADA9Iz2OgEAAAAAAAAAAAAAAIBe++E/Tmbt05myrvqbJJOdKQsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDOG+51AgAAAAAAAAAAAAAAAFVxz1XJqlt7nQUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABTGe51AgAAAAAAAAAAAAAAAFWweU1y5cd6nQUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADNDPc6AQAAAAAAAAAAAAAAgEG3c3vyhf+ZbH+y15kAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQzHCvEwAAAAAAAAAAAAAAABhkO7Ymn/31ZO3KXmcCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAEaO9TgAAAAAAAAAAAAAAAGBQrVmRfOkPkvWre50JAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARY32OgEAAAAAAAAAAAAAAIBB8+QTyU3/knzny8nE7l5nAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQCtGe50AAAAAAAAAAAAAAABAv9u9M1m7MnlsaXL/DclDdySTE73OCgAAAAAAAAAAAAAA6LWhoaHMnz8/ixYtyqxZs3qdDgAAAAAAAAAAAEDt7Nq1K+vXr8+6desyOTnZ63QAAAAAAAAAAAAAAACgNnxXOwAAAAAAAAAAAEBv+a723vNOLQAAAAAAAAAAAEDveJ8W6KShyYJ3kqGhobJzAQCAgTUylhz7smKxS68pNxcAAAAAAAAAAABad+x5ycjoM/++e2fjZ/uW5Mknkm2bksmJnqUHAAAAAAAAAAAAAHTAdP4DD76rHdibhQsX5owzzsjChQszOjra/AAAAAAAAAAAAAAAOmp8fDybNm3KrbfemrVr1/Y6HQAAAAAAAAAAAAAA6Eu+qx0og+9qBwAAAAAAAAAAAOgt39Xee96pBQAAAAAAAAAAAOgd79MCRRX5rnZvhAMAQAeM70qWXtPrLAAAAAAAAAAAAGjX/df3OgMAAAAAAAAAAAAAAGAQLVq0KAcccEBGR/3nHwAAAAAAAAAAAAB6YWRkJPPnz8/ChQuzdu3aXqcDAAAAAAAAAAAAAAAAteG72gEAAAAAAAAAAAB6y3e19553agEAAAAAAAAAAAB6x/u0QCd5KxwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKANY2NjGRsbe87vJicnMzQ01KOMAAAAAAAAAAAAAOpnZGQko6OjvU6DJEcddVSvUwAAaMlpp5+W4eHhLL13abZv397rdAAAAICKOeaYY7LPvH3yyMOP5Iknnuh1OgAAAEBFPfnkk1m/fn2v0wAAasp3tQMAAAAAAAAAAAD0nu9q7y3v1AIAAAAAAAAAAAD0lvdpgU5xJwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJimycnJbNmyJRs2bMjExESv0wEAAAAAAAAAAACorOHh4SxYsCDz5s3L0NBQr9PhWY477rhepwAA0JKXvvSlGRsby/DQcLZs2dLrdAAAAICKOePFZ2TRokW595578/DDD/c6HQAAAKCiHnrooaxfv77XaQAA+K52AAAAAAAAAAAAgC7xXe39yzu1AAAAAAAAAAAAAOXzPi1QltFeJwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAF69evz4033pjdu3f3OhUAAAAAAAAAAACAyhoZGcnZZ5+defPm9ToVAAAAAAAAAAAAAAAA4Ht8VzsAAAAAAAAAAABA+XxXe3/zTi0AAAAAAAAAAABAuUZGRnLOOed4nxbouNFeJwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAF4+Pj2b17dyYnJ3udCgAAAAAAAAAAAEBljY+PZ3x8vNdpAAAAAAAAAAAAAAAAAM/iu9oBAAAAAAAAAAAAyue72vubd2oBAAAAAAAAAAAAyuV9WqAsw71OAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALpluNcJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQLcM9zoBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA6JbhXicAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3TLc6wQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADwYoKUAAEZFElEQVQAAAAAAAAAAAAAAAAAAACgW4Z7nQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB0y3CvEwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBuGe51AgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANAtw71OAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALpluNcJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQLcM9zoBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA6JbhXicAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3TLc6wQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgW4Z7nQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB0y3CvEwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBuGe51AgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANAtw71OAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALpluNcJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQLcM9zoBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA6JbhXicAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3TLc6wQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgW4Z7nQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB0y3CvEwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBuGe51AgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANAtw71OAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALpluNcJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQLcM9zoBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA6JbhXicAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3TLc6wQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgW4Z7nQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB0y3CvEwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBuGe51AgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANAto71OAAAAAAAAqmr27Nl5/etf/5zfXX311dmwYUOPMgIAAKDqrEUBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACaG+11AgAAAAAAUFWLFi3K5z//+ef87vzzz8/111/fo4wAAACoOmtRAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA5kZ7nQAAAAAAUC3Dw8N7/P3ExESXMwEAAAAAAPvWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/Pzv3HR5VufV9/JcekgBJ6F16lyZFiiDNBEXQI0WKxyA2pAkCiohypCMPKmIBUQFF2pHeEQXpRQVEmhTpLUAgJCH1/cPXwpk9yUxmT0u+n+vieg5r7b3Wyp492XPfIw8AAAAAAAAAAAAAAAAAAAAAALDk6+4BAAAAAAAAAOQcM2fOVFpamsWfFStWuHs0AAAAAAAAAEAuxL41AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACO+7h4AAAAAAAAAQM7x0EMPGcZXr17t4kkAAAAAAAAAAGDfGgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAxf3cPAAAAAAAAACBnqF69ukqUKGGYW7NmjYunAQAAAAAAyJqvr68iIiIUGRmpyMhIBQUFGR4XGxurgwcPung6AICj2LcGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYI2/uwcAAADI6d599109/PDDFvENGzboxRdfdMNEAAAAgHNERUUZxk+dOqVjx465eBoAAOBJ2CMDkFvx+8/78JrlDvXq1VOHDh30wAMPqGHDhgoODs7ynBUrVqh9+/YumA4AYCb2rQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABY4+/uAQAAAHK6IkWKqEKFChbxX375xQ3TAAAAAM4TFRVlGF+zZo2LJwEAAJ6GPTIAuRW//7wPr1nO1rhxY7311ltq06aNu0cBALgI+9YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArPF39wAAADhDSEiI+vbt6+4xsvTJJ58oLi7O3WMAAADAQ/j4+Khs2bKqUKGCSpQoodDQUOXJk0eSFB8fr/j4eMXGxurw4cM6efKkMjIyXDZbnjx51LBhQxUrVkyFCxeWn5+frly5osuXL2vv3r26evWqy2bxZL6+vhowYIACAgIM86tXr9aBAwdcPNUfAgMDNWDAAPn4+BjmP/jgAyUkJGS7fkhIiJo1a2aYW7169V1/99Tr5OxrhNyjePHiqlKliooUKaIqVapY5Nu2bSs/Pz+dOXNGZ86cUVpamhumzLk8+XmaGzVs2FDNmzc3tWZaWpru3Lmj+Ph4XblyRefOndOxY8d0+/ZtU/sAAAAgZxk8eLAmTpwoX19fd4/iFKxF4U5BQUGqUKGCypcvr8KFCyskJETBwcFKT09XQkKCbt26pd9//12//fabzp8/7/R5WIviT/bsW0Py9/dXpUqVVKFCBeXLl0958+ZVWFiYJCkhIUHx8fE6d+6cfvvtN/3+++8u31fjuyoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYzd/dAwAA4AxhYWGaMGGCu8fI0qJFixQXF+fuMQAAADxW4cKF9fLLL7ut/+rVq7V582an9oiIiFCXLl3Uvn17NWnSRPnz57fpvMTERO3YsUNLly7VN998ozNnzjhlvjZt2mjgwIFq2bKlgoODDY9JT0/Xrl279MUXX+jTTz9VWlqaU2Yx0qFDBzVq1Mgw98477yg2NtZls0h/XItixYppyJAhhvknn3xS9erVU3p6ukvnkqTBgwdr7Nixhrm5c+cqISHBofotWrRQUFCQRTwlJUUbN268K+ap18nZ1wg51z333KNHH31UUVFRatSokSIiIjI9/s0339Sbb74p6Y/f5zt37tQPP/ygpUuXau/eva4Y2VT+/v4aPny48uTJY5FbvHixdu3a5fQZPP156oiSJUvqpZdecvcYf3nttdfsOr558+Yu26c7efKktm/frnXr1mnFihUu/xwAAAAAzzV58mQNGjTI3WOYirWoc9eiuWFv2lEVKlRQjx491Lp1a9WvX1+BgYE2nXf+/Hlt3rxZ33zzjZYtW6Y7d+6YPhtrUfzJnn3r3Or+++/XY489pqioKFWpUkUBAQE2nRcXF6fNmzdr5cqV+uSTT5w6I99VAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwFn83T0AAAAAAACANaVKldKrr77qtv7Xr1/X5s2bnVL7nnvu0RtvvKEePXooMDDQ7vPz5MmjBx98UA8++KAmT56s+fPna/To0Tp06JAp85UoUUKffvqpoqKisjzW19dXjRo1UqNGjTRgwAA9++yz2rp1qylzZKZ27dqaP3++goKCLHJTp05VbGys02cwMmrUKHXr1k0lSpSwyNWuXVvPPfecPv74Y5fOVLJkSY0YMcIwd/PmTQ0ePNjhHtbulW3btik+Pt4i7onXydnXCDnPww8/rIEDB6pVq1by8fHJVo08efKoRYsWatGihd544w398ssv+uSTTzR9+nQlJyebPLFzTJgwQYMGDTLMnTx5Urt27XJab09/npqhePHibv089L9ee+01d49gVdmyZVW2bFl169ZNKSkpWrJkiSZNmqTdu3e7ezQAAAC4UceOHa2uWbwRa9E/OHstmpP3ph31wAMP6K233tKDDz6YrfOLFy+url27qmvXrrpx44Y++OADTZ48WTdu3DB3UBdhLerZ7N23zi38/Pz01FNPacSIESpXrly2auTPn1/t27dX+/btVadOHb311lu6ePGiqXPyXRUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACczd/dAwAAAO/Xt29flSlTxiK+efNmLV++3A0TAQCAnCI0NNTdI5jOz89Pr776qkaOHKnAwEDTanbr1k2dOnXSW2+9pXHjxikjIyPb9apXr641a9aoZMmSdp9btWpVffvtt+revbv++9//ZnuGrISFhWnhwoUKCgqyyO3du1eDBw92Wu+s3L59Wy+//LIWLFhgmB8zZowWLFiga9euuWymyZMnKyQkxDD3xhtv6OLFiw73iIqKMoyvXr3aMO6J18nZ18gRrLs8S506dTR16lQ1adLE9No1atTQ1KlTNXjwYL366quaP3++6T3M1L59ew0aNMjlfb3heQr3CggIUKdOndSpUyctWLBAL730kq5everusQAAbsRnaiB3ioiI0MyZMzM9ZsuWLVq6dKn27t2rq1evKiEhwXAtkJCQ4KwxbcJa9G+uWIvmxL1pRxUuXFgfffSRHn/8cdNqhoeHa8SIEerTp4/69++vr776yrTa7sBa1PPYu2+dGzRq1Ehz5sxRhQoVTKv5/PPPq2fPnnrttdf0/vvvm1KT76oAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgCv7uHgAAAHi/7t27q1GjRhZxf39/LV++3A0TAQCAnCIsLMzdI5iqQIECWrp0qZo0aeKU+gEBARozZoyaN2+uDh06KCkpye4apUuX1ubNmxUZGZntOYKCgrRgwQI9/PDDWrNmTbbrZObTTz9VhQoVLOI3b95U586dlZKS4pS+tlq4cKG+/fZbtWrVyiIXGRmpMWPG6MUXX3TJLC1atFDnzp0Nc/v27dMHH3zgcI+yZcuqYsWKhrm1a9daPc/TrpMRs66Ro1h3eY6hQ4dq9OjRCggIcGqfe+65R/PmzVPHjh3Vu3dv3b5926n9sqN06dKaNWuWy/t6w/MUnqVz585q0aKFOnTooB07drh7HACAm/CZGsidnnvuOav7XFeuXNGTTz6pb7/91sVT2Y+16N9ctRbNaXvTjmrSpImWLFmiggULOqV+ZGSkvvzyS0VHR6tXr15KTk52Sh9XYi3qftndt87Jhg0bptGjR8vf3/z/dDgkJETvvfeeWrZsqS5duujOnTvZrsV3VQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAVX3cPAAAAAAAAYE1YWJi7RzBN8eLFtX37djVp0sTpvdq2bavly5crMDDQrvP8/Pz09ddfKzIy0iJ3/vx5DR06VPfee68KFCig8PBwVa5cWc8++6wOHDhgcbyvr69mz56tIkWKZPvnsOa5555Tly5dDHO9e/fWiRMnTO+ZHS+99JJSUlIMc88995zq1Knj9Bn8/Pz0wQcfGOYyMjLUp08fpaenO9znoYceMoxfunRJP//8c6bnevJ1MvMawfv5+vpq5syZmjBhggICAlzWt2vXrtq9e7eKFy/usp628Pf314IFCxQREeHSvt7wPIVnKly4sL777js1b97c3aMAAADARfz8/NSvXz/DXEJCgpo3b65vv/3WxVPZh7Xo3Vy5Fs1Je9OOeuyxx7Rx40YVLFjQ6b26d++u9evXKyQkxOm9XIG1qHs5sm+dE40dO1bjx4+Xv7+/U/t06NBBq1atyvaeGt9VAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwJX83T0AAADOcPXqVVWuXNnhOkeOHDGMv/TSS9qwYYPD9U+fPu1wDQAAgJwsNDTU3SOYIl++fFq7dq0qVqyY6XGnT5/W8uXLtWXLFh05ckRXr15VYmKifH19FRISooIFC6pSpUpq1KiRHn74YZUrV85qrdatW2vixIkaOHCgzXO+8MILaty4sUV88+bNevTRRxUXF3dXPC4uTkePHtUXX3yhjz76SL17974rX6hQIb3zzjvq2bOnzTNk5d5779V7771nmPv444+1cOFC03o56siRI/q///s/DRs2zCLn6+urDz74QE2aNHHqDC+99JKqV69umPviiy+0bds2U/pER0cbxteuXZvluZ58ncy8RvB+H374oXr16pXpMWlpadq6dau2bNmi3bt36+zZswoICLC4j5599lndvHlT9957r1q2bKkGDRrIz8/Pat2qVatq48aNeuCBB3T58mVTfh5HTZgwQQ0bNnRpT295nuZkV69eNbVe8+bNdfHiRbvO8fHxUVBQkEJDQ5UvXz6VLVtW1apVU8OGDVW/fn35+PhYPTc4OFjLli1TnTp1dOLECUfHBwAAgIe77777VKJECcPcqFGjdOjQIRdPZD/Wondz5Vo0p+xNO6pVq1aaN2+eAgMDMz0uKSlJmzZt0pYtW3T06FHFxsYqKSlJvr6+CgsLU6lSpVSrVi21bt1alSpVyrTWAw88oG+++UaPPPKIUlNTzfxxJLEWzU0c2bfOaV555RW99tprmR6TmpqqTZs26dtvv9XBgwd18uRJ3bx5U7dv35a/v7/Cw8NVtGhR1atXTw8++KCioqKsPkdatmypadOm6dlnn7V7Vr6rAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgCv5u3sAAACcIT09XUePHnVa/bNnzzq1PgAAAP4QFhZmGO/Zs6f279/v9P4XLlwwpc6sWbNUo0YNq/mDBw/qtdde04oVK5SRkWH1uFOnTmnPnj2aO3eu+vfvr4cfflj/93//p0qVKhke379/f61YsUIbNmzIckYfHx8NGjTIIn7hwgV16NBBcXFxVs9NTU3V888/r8qVK6tZs2Z35bp06aJhw4bp/PnzWc6QldDQUC1cuFDBwcEWuX379mngwIEO9zDbf/7zH3Xr1k2lSpWyyDVu3Fg9evTQl19+6ZTehQoV0n/+8x/D3PXr1zV06FBT+gQEBKhly5aGudWrV9tUwxOvk5nXCN6vd+/eev75563m4+PjNWnSJH366acWv+9Kly5tcfyvv/6qbdu2acGCBZKkokWL6plnntHAgQNVsGBBwx6VK1fWqlWr1KhRI6Wmpjrw0ziuffv2hs8MZ/OG56kzHDhwQLVq1XJZv88++0z16tUzzL399tum9vrtt99M+Yzwp6JFi6pnz5569dVXFRkZaXhMvnz5NHv2bDVt2tS0vgAAAPBMTZo0MYwnJSVp+vTpLp7GfqxF7+bqtWhO2Zt2RJkyZfTf//5XgYGBVo+5du2axo4dq5kzZ+rGjRs21a1fv76GDx+ujh07Wj3moYce0sSJE53ymrMWzR3M2LfOKerWratx48ZZzcfHx+u9997TlClTFBsba/W4ixcv6vDhw/r+++81efJkFS9eXMOGDVPfvn3l6+trcXzv3r21bNkyLV++3OZZ+a4KAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArubv7gEAAAAAAACsCQsLM4zv379f+/fvd/E02RMTE6OOHTtazU+aNEmvvfaa0tLS7K69cuVKbdy4UXPmzNG//vUvi7yPj4/eeecd1a5dO8ta0dHRKleunEV89OjRunHjRpbnp6ena+jQodq+fftd8YCAAD333HN66623sqyRlU8++USVKlWyiMfHx6tTp066c+eOwz3MlpCQoJdfflmLFi0yzE+aNElLly7VrVu3TO89YcIE5c+f3zA3fPhwXb161ZQ+TZo0MXyvZmRkaP369TbV8MTrZOY1gncrXLiw3nnnHav5DRs2KCYmRmfPns12j4sXL2rMmDGaNm2aJkyYoOeee87wuHr16untt9/Wa6+9lu1ejipdurRmzZrl8r7e8jx1hsTERJd97mnWrJnq1atnmDtx4oQ++ugjl8yRXRcvXtSkSZP0ySefaM6cOXr00UcNj2vSpIkeffRRLVu2zMUTAgAAwJUaNWpkGN+1a5dN+13uxFr0bu5Yi+aEvWlH+Pj4aN68eVb3FyVp6dKliomJ0fXr1+2qvXv3bj322GNq166dZs+erQIFChgeN3DgQK1du1Zr1661q76rsRb1TGbsW+cE/v7+mj17tvz9jf9T4X379umJJ57Qb7/9Znft8+fPa8CAAZo3b562bdtmeMw777yjlStXKj093aaafFcFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAV/N19wAAAAAAAADWhIWFGcYTEhJcPEn25M2bVxMmTLCa79evn4YOHaq0tLRs90hMTFSXLl20bt06w3ytWrXUvn37LOu0atXKIpaamqq5c+faPMuOHTv022+/WcQffPBBm2tY88wzz6h79+6Gueeee07Hjh1zuIez/Pe//9X69esNc0WLFtWbb75pes/69evr6aefNszt2bNHn3zyiWm9oqKirPaJjY21uY4nXSezrxG827Bhw5Q/f37D3DfffKPo6GidPXvWlF43btzQ888/r169ell9NgwdOlS1a9c2pZ+9/P39tWDBAkVERFjkMjIynNbXm56n3m7ixIlWc8OHD1dKSooLp8m+mzdvqmPHjlq4cKHVY/r16+fCiQAAAOAOxYoVM4z/9NNPLp7EfqxF/+autai370076tlnn1WjRo2s5qdOnaqOHTvq+vXr2e6xatUqNWzY0Oq97OPjo2nTpikgICDbPVyJtahnMWvf2tv16NFD1atXN8z9/PPPatasmeH3OvbYvn27rl27ZpirVKmS2rZta3MtvqsCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAq/m6ewAAAAAAAABrwsLCDOOJiYkuniR7hg4dqkKFChnmJk+erA8++MCUPmlpaXrqqad0/fr1u2KrV69W586dtXbt2ixrNGvWzCK2Z88e3bhxw65ZjHo1aNBAAQEBdtX5p+rVq2vq1KmGuU8//VRff/11tmu7yksvvaTk5GTDXP/+/VWlShXTevn4+GjatGny8fGxyKWnp+vFF19URkaGaf2ioqIM42vWrLG7lidcJ2dcI3ivwMBA/fvf/zbM/fbbb+revbtSU1NN7/v555+rT58+hjlfX1/95z//Mb2nLSZMmKCGDRtaxPfu3asNGzY4ra83PU+92WOPPaZGjRoZ5vbs2aP58+e7eCLHZGRk6LnnntPFixcN8y1btlR4eLhrhwIAAIBLRUREGMavXLni4knsw1r0bu5ai3r73rQjwsLCNGbMGKv5efPmqX///qb0On78uNq2batbt24Z5suXL69+/fqZ0ssVWIt6DjP3rb3ZsGHDDOOxsbGKioqy+t6z1+DBg63mevToYXMdvqsCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAq/m6ewAAAAAAAABrQkNDDeOJiYkunsR+wcHB6tOnj2Hul19+0bBhw0ztd+nSJU2cOFGHDh3S0KFDVapUKbVr104LFy5UcnJyludXr17dInbw4EG75zA6Jzg4WOXLl7e7liSFhIRo0aJFypMnj0Xul19+Ub9+/bJV19WOHTumd955xzAXEBCgqVOnmtarV69eql+/vmFuxowZ2rNnj2m9ihYtqlq1ahnm1qxZY3c9T7hOZl8jeLcGDRqoQIEChrlXXnlFSUlJTus9ffp0ffXVV4a5xo0bq2DBgk7rbaR9+/YaNGiQRTwuLk6dOnXSnTt3nNLX256n3srPz0/jxo2zmh8yZIgLpzHPjRs39PnnnxvmfH191aRJExdPBAAAAFcKDw83jMfHx7t2EDuxFv2bu9aiknfvTTvqmWeesfpanzx5Us8884yp/Q4dOqSXXnrJan7QoEHy9/c3tacz5eS1qI+Pj/Lly2fxJyQkxN2j3cXsfWtvlTdvXm3ZssXwudGvXz9dunTJtF5ffPGFDh8+bJhr3LixzXX4rgoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACu5uvuAQAAAAAAAKwJCwszjCckJLh4Evt17dpVkZGRhrn+/fsrLS3N9J4TJ05UtWrVNGnSJF24cMHm84KCghQSEmIRP3XqlN0z/P7774bxiIgIu2tJ0kcffaQqVapYxG/fvq1OnTopKSkpW3XdYfTo0Tp9+rRhrnXr1nrssccc7pE/f36NGzfOMHf16lW99tprDvf4p7Zt2xrG4+LitHPnzmzVdOd1csY1gndr1KiRYTw2NlYrV650ev8BAwbo1q1bf/398OHDev7551WyZEldvXrV6f3/VLp0ac2aNcsw16tXL508edJpvb3peerNnnnmGVWuXNkwt2rVKn3//feuHchEixcvtpqz9jMDAAAgZ/Dz8zOMZ2RkuHgS+7AW/YM716KSd+9NO2rAgAFWc3379nXKNZgzZ47VtWeJEiX0xBNPmN7TmXLqWrRixYqKi4uz+DN//nx3j3YXZ+xbe6Nbt27p2WefVcmSJfX666//tc/1888/6+uvvza938KFCw3jZcuWVd68ebM8n++qAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4A6+7h4AAAAAAADAmrCwMMN4UlKSiyexX7du3QzjO3bs0HfffeeUnunp6dk6LyIiwjAeHx9vd61bt24ZxiMjI+2u9fTTT+upp54yzPXp00eHDx+2u6Y7JSYmasCAAVbzU6ZMUXBwsEM93n77bRUqVMgwN3ToUF2/ft2h+v8rOjraML5+/XqlpaVlq6Y7r5MzrhG8W4kSJQzj+/btU2pqqtP7x8bGavr06Vq/fr2io6NVtWpVTZ8+3aXPQX9/fy1YsMDwWTF16lR98803Tu3vTc9TbxUSEqJRo0YZ5tLT0zVs2DAXT2SuEydOWM0VLVrUhZMAAAAAtmEt6v61qOTde9OOuP/++1W2bFnD3I4dO7Rq1Sqn9X799det5rp37+60vs7AWtS9nLFv7c1iY2M1duxYlS5dWt27d9eQIUOc0ufnn3+2mitYsGCW5/NdFQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANzB390DAACA7MmbN69KlSqlfPnyKW/evEpPT9fNmzd18+ZN/f7770pKSnL3iB6jePHiKliwoPLmzavQ0FBlZGQoLi5O165d0/Xr13Xt2jVlZGS4e0xkoVSpUoqMjFT+/PkVHByshIQE3bp1S1euXNH58+fdPZ5X8OZrGBAQoLJlyyo8PFx58+aVr6+vEhMTFRsbq1OnTikxMdHdI+YY3nyf4A9+fn4qW7asIiIilC9fPknSzZs3FRcXp1OnTik5OdnNE9onNDTUIuYNn3Py58+vFi1aGOY++ugj1w5jg5CQEMN4dn6/JiQkGMaNXsvMVK1aVdOmTTPMzZo1S7Nnz7Z7Nk+wZMkSrVmzRlFRURa5MmXK6NVXX9Vbb72Vrdo1atRQnz59DHPbt2/X559/nq261vj4+KhNmzaGuTVr1jhU213XyexrlFvlpPVqRESEYfzChQsum2HIkCFuXbNOmDBBDRs2tIjv3btXgwcPdmpvb3ueequXX35ZRYsWNczNmjVLv/zyi4snMldsbKzS09Pl6+trkQsLC3PDRO7j7XtkPj4+Klu2rAoUKOA1a52c9Ex0F/YpuI/gOG+8h7xx5tyO18xcrEXduxb9k7fuTTuqS5cuVnPvvvuuU3tv27ZNe/fuVb169Sxybdu2Vf78+RUXF+fUGczCWtR9nLlv7e1SU1M1d+5cp9XP7DmVP3/+LM/nuyoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC4g7+7BwAAALYJDw9X+/bt1aFDB9WrV0/33HOP1WPT09N17Ngx7dq1S0uWLNGaNWuUkJCQrb4VKlRQ3bp1Mz2mYMGChvHKlSurc+fOdvc8cOCADh06ZPd5f6pbt646duyoli1bqkaNGsqfP3+mx9+8eVNbt27V5s2btXLlSh04cCDbvb1No0aNVLp0aYv48uXLlZiYaPW8SpUqqV69eqpWrZoiIiKUL18+BQQE/JXfuHGjZsyY4dBs9957r5544gm1atVKNWvWVN68ea0ee+PGDe3fv1+rV6/W4sWLdeTIkWz1rFGjhqpVq2aY++abb5SampqturZo3ry5ihQpYhE/ceKE9uzZk62a7riG1mTnXqtVq5a6deumtm3bqlq1agoMDDQ8LiMjQ0eOHNF3332nBQsW6Pvvvzdt7sjISLVu3dowl9X7JDsKFCigVq1aGeaWLl2qO3fumNpP8qz7xEze/Npl5/1Ss2ZNdenSRdHR0apevbqCgoIMj0tNTdXhw4e1efNmLVq0SJs2bVJ6errNs7lDWFiYRSy7n2tc6cEHH7zr2fin5ORkffPNN26YKHsyMjJccs7/ypMnjxYtWqSQkBCL3KFDh9SnTx+He7hT3759dfDgQcP36rBhw/TFF1/o1KlTdtf94IMP5OfnZxFPS0vTiy++mJ1RM3XfffepQIEChrm1a9c6XN8d18ldvHHd9U/uWq+6gq+vr2HclfeLGb9Xs6t9+/YaNGiQRTwuLk6dOnVSSkqKU/vnlOepJytQoICGDRtmmEtKStIbb7zh4omcIz093fD97OPj44ZpXCcn7JGVLVtWXbp00aOPPqratWsrT548hsd5ylrHXc9ET9zTWrBgQbbq5dR9Cnt40mcrb9pf8fbP1GbypHvIVt44sxlq1qypqlWrWs3Hxsbq22+/deFEtvOE16x48eJq2rRppsdY++xQr169bL3vz549q23bttl9nr1Yi7p3Lfonb92bdtRDDz1kGL9586YWL17s9P6ff/656tWrZxEPDAxU8+bNtWzZMqfPYJbcuhZ1N2fvW8O65ORkqzlrzzZb8F0VAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADOU7icdP+Tth17dJt06DvnzuMuIeHSo8NtO3bHfOnUXqeOYxNnzMz98AdvvB8AAAAAAAAAAAAAAAAAAIBj/N09AAAAyFzFihX16quvqkePHgoMDLTpHF9fX1WuXFmVK1dWz549dfv2bX3yySd65513dOHCBbv6t23bVtOmTcvO6IqOjlZ0dLTd5/373//WoUOH7DrH19dXXbp00fDhw1WjRg27zs2XL99fs44bN07r1q3T+PHj9d13OfRfkPzDgAED1LVrV4t4mTJldPr06btiefPmVd++fdWrVy9VqFAh07rx8fGaMWNGtmb617/+pREjRqh27do2nxMeHq4HHnhADzzwgMaNG6dvv/1Wb7/9tjZt2mRX78jISM2fP98w17FjRy1dutSuerbKkyePli9frrx581rkOnfurD179thVz53X0Bp77rW6detq0qRJatmypU21fXx8VKVKFVWpUkUvvviifv31V40YMUKLFy92eO4KFSpYvSeMZndU5cqVrfYrUqSILl++bFovT7xPzOTNr50975f77rtPY8aMUdu2bW2q7e/vrxo1aqhGjRrq06ePTp06pXHjxunzzz9XSkqKzTO6UlhYmEUsMTHRDZPYp2nTpobxrVu3Kj4+3sXTeJ9p06apWrVqFvHExER16tRJCQkJbpjKPMePH9ekSZM0YsQIi1xwcLCmTJmixx57zK6aXbp0UfPmzQ1zH374ofbt25etWTMTFRVlGD948KDOnj3rcH13XCd38ZZ11/9y93rVFW7evGkYDw8Pd+0gblC6dGnNmjXLMNerVy+dPHnS6TPwPHW+kSNHGq5FJendd9/VuXPnXDyRc/j6+hrG09LSXDyJ8+WUPbLy5ctr9OjR6ty5s9XX75/cvdZx9zPRE/e0FixYYFetnL5PYQt330dGvGl/xVs/U5vJE++hrHjjzGZ55JFHtGDBAuXJk8cwf/r0abVp08bFU2XNk16z++67z+rvjKw89dRTeuqpp+w+b+rUqdq2bVu2etqDtah716J/8ta9aUcUKlRIVapUMcytW7dOycnJTp9h+fLl+uCDDwxzzZs317Jly5w+g1ly01rUkzh73xrW5cuXz2rOG7/XyenfVQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIEkhEVLlZrYde/28dMi547iNf6BU+l7bjj2wzrmz2MoZM3M//MEb7wcAAAAAAAAAAAAAAAAAAOAYX3cPAAAAjAUHB2vy5Mk6fPiwevXqpcDAwGzXCg0N1aBBg3Ty5EkNGzZMvr6e/RHg4MGDdh1fo0YN7dmzR3PnzlWNGjUc7t+2bVtt3LhRs2fPVnBwsMP1coI2bdro119/1dixY1WhQgWn9KhSpYp27dqlRYsWqXbt2g7VatWqlb7//nt9/fXXioiIsPm8zZs368iRI4a5mJgYh2bKzOOPP668efNaxK9evaolS5bYXMcTrqEjfHx8NHLkSO3evVstW7bMdp1q1arpm2++0bJlyxQZGWnihDmDt98n+IOfn5/GjBmjnTt3qm3bttmuc8899+iTTz7Rvn37VLduXRMnNE9oaKhFLDEx0Q2T2KdRo0aG8e+//961gzjIz8/PJef8U8+ePa0+d/v27Wv3Z0VPNWbMGJ06dcow17FjR7ve2yEhIZo8ebJh7tKlSxoxYkR2RsxSdHS0YXzt2rWm9cgJ18lTOfJeyk3r1djYWMN42bJlXTyJa/n7+2vBggWGn/GmTp2qb775xiVz5JTnqacqW7asXnjhBcNcbGysxo0b5+KJnKNgwYJWf7fcuHHDtcM4WU7ZI+vfv78OHDigrl27Zvu54Kq1jqc8Ez1xT8tW7FN4zn0E+3nK+tQb7yFvnNlMTz/9tJYsWaI8efIY5n/55Rfdf//9Onr0qIsnsy63v2Z/Onz4sEv6sBZ171r0T966N+2IBg0aWM1t2LDBJTOcPn1ax44dM8w1bNjQJTOYITetRT2NK/atYaxkyZJWc9evX892Xb6rAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC4W82HpMbdbfuTJ79zZihRzfYZSlRzzgwAAAAAAAAAAAAAAAAAAABATuXr7gEAAIClypUra//+/Ro0aJB8fc17XAcFBWn8+PHasWOHihYtalpdM2VkZOjQoUM2H//0009r7969qlOnjumz9OzZU9u2bVOJEiVMr+1NunXrptWrV6tkyZJO69GrVy/99NNPql+/vql1u3btqgMHDqhGjRo2nzNjxgzD+MMPP6xChQqZNdpdYmJiDOOzZs1SSkqKTTU86Rpmh7+/vxYtWqRRo0aZ9nuvffv22rlzp+655x5T6uUE3n6f4A/BwcFasWKFhg8fbtr7pWrVqtq5c6d69+5tSj0zhYWFWcQSEhLcMIl9qlatahj/8ccfXTyJbW7evGkYDwkJsbtWaGioYTwuLi7LcytXrqyPPvrIMPfVV1/ps88+s3seT5WUlKQBAwZYzU+dOlX+/v421XrjjTesfmYdPHiw1dfXEeHh4WrQoIFhbvXq1ab18fbr5KnsXXf9U25br54/f94wXqNGDRUuXNjF07jOhAkT1LBhQ4v43r17NXjwYJfN4W3PU28zZswYBQYGGubefvvtHPN7sVy5clZz586dc+EkzpUT9sj8/Pw0c+ZMvffee8qTJ48pNZ251vG0Z6Kn7WnZgn0Kz7uPYDtHPlObyRvvIW+c2UxDhgzR559/Lj8/P8P8li1b1LRpU6trEXfI7a/ZPx05csQlfViL3s3Va9E/eevetCOqVbP+/81z586dLptj165dhnFr+wSeKLesRT2Nq/atYaxp06aG8ZSUFMXGxmZ5Pt9VAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8Va0oqWlP2/6E5HfODCWq2z5DierOmQEAAAAAAAAAAAAAAAAAAADIqXzdPQAAALhbo0aNtG3bNlWsWNFpPerXr6+dO3eqSpUqTuuRXadOnVJCQoJNx/bv31+fffaZAgMDnTZPnTp1tGzZMgUFBTmthydr06aN5syZIz8/P6f1GDp0qGbOnKng4GCn1C9RooR++OEHNWzY0KbjZ82apeTkZIu4v7+/unfvbvZ4KlWqlFq2bGmYmzFjhk01PO0aZsfcuXP1+OOPm163QoUK2rhxowoXLmx6bW+TE+4TSH5+flqxYoWioqJMr+3v768ZM2bolVdeMb22I8LCwixiiYmJbpjEdgUKFFBkZKRh7uDBgy6exjbXr183jEdERNhdKzw83DB+7dq1TM8LDg7WwoULFRoaapE7evSonn/+ebtn8XTLli3TqlWrDHOVKlXSwIEDs6xRoUIFDRo0yDC3adMmffXVV46MaFXr1q0NPyMmJibqhx9+MLWXN18nT2XPuuufcuN6ddu2bYZxHx8fvfTSSy6exjXat29v+H6Ji4tTp06dlJKS4pI5vPF56k3q1Kmjrl27GuZOnjypDz/80MUTOU9ma80ff/zRhZM4T07ZI5s+fbp69eplel1nrHU88ZnobXta7FN45n0E22X3M7WZvPEe8saZzfTOO+9o4sSJVvNLly5V69atFRcX58KpMpfbX7P/deTIEZf0YS36N1evRf/JG/emHVWtWjXDeHp6un799VeXzbF//37DeGRkpAoVKuSyORyRG9ainsiV+9a4W2BgoB577DHD3P79+5WampplDb6rAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgDv4u3sAAADwt6pVq2rt2rXKly9fpsedPn1aK1as0Pbt23XhwgVduXJF/v7+Kly4sIoXL67mzZsrOjpahQoVslqjdOnS+vbbb1W/fn2dP3/e6nG3b9/W2bNnM52ncOHCCgwMtIjHx8frxo0bmZ77v7Zs2WLTcQ8//LDeffdd+fj4WD3mxx9/1JIlS7Rjxw4dOXJE169fV0JCggICAhQZGalixYqpadOmat++vVq1amW1Tt26dTVt2jT17t3brp/F2xUtWlRff/21fH19ndbj2Wef1YQJEzI95uzZs1qyZInWrFmjo0eP6vLly4qPj1e+fPlUsGBBVapUSa1atVLHjh1VtmxZwxrh4eFatmyZ7rvvPp05cybTflevXtXSpUvVqVMni1yvXr307rvv2vzz2aJnz56G9/EPP/ygI0eO2FTD066hvV555RXD6/3P2Xfs2KFTp07p5s2bCggIUMGCBVW6dGm1bt1aDz30kMLDw63WL1u2rL7++utM3+c5nSe+15A9U6ZMsXovHzlyRCtWrNCePXt0+vRp3bp1S35+fipUqJCKFi2qpk2bKjo6WqVKlcq0x6RJk3Tq1CktWrTIGT+CXfz9/RUQEGART0xMdMM0titTpoxhPC0tTadPn87y/IIFC6pmzZqqUqWKChUqpHz58ikoKEh37txRXFycrl27pl9//VUHDhzQ1atXTZk5LS1NN27csPh9WqFCBbtrVaxY0TCe1axTp05VzZo1LeJJSUnq1KmTbt++bfcs3qBfv35q1aqVgoKCLHJvvvmmvvrqK124cMHq+e+9957hZ/HU1FT16dPH1Fn/KTo62jD+/fff686dO6b389brZCtPXXf9kyeuV13hz9+1BQsWtMgNGjRIc+fOtflzuzcoXbq0Zs2aZZiLiYnRyZMnXTaLNz5PvcnEiROt7qkMHz5cKSkpLp7IOSIjIxUTE2OYu3z5svbs2ePiicyXU/bI+vXrp169ehnmPG2t46nPRG/a02KfwnPvI2/mDZ+pzeSN95A3zmwWPz8/ffbZZ3rqqaesHjNz5kw999xzSk9Pd+FkmfP01ywpKSnL933x4sUNv+eKi4vTrVu3bOrzpzt37mTZzyysRf/m6rXon7x1b9pRJUuWNIyfPXtWycnJLpvj2LFjVnMlSpTQlStXXDZLduSGtaincvW+Nf7Wq1cvq8/6HTt22FSD76oAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAx0WWlFq+YNuxP3whXfrNqeMAAAAAAAAAAAAAAAAAAOAV/N09AAAA+ENkZKRWrlypfPnyWT3m559/1rBhw7Ru3bpMa3322Wfy8fFRly5dNHbsWJUtW9bwuOLFi2v58uVq3Lix7ty5Y3jMrFmzNGvWrEz7bd++XY0aNbKIf/rpp3r55ZczPTc7ihYtqjlz5sjHx8cwv2vXLr388svatm2bYT4tLU3nz5/X+fPntXfvXr333ntq2LChpk+frnvvvdfwnGeeeUYzZ87U9u3bTfs5PN2kSZNUoEABw9y+ffu0YsUK7dy5U5cuXdLVq1eVmpr6Vz4+Pj7L+g0bNtQHH3xgNX/58mWNGjVK06dPv6v2n65fv67r16/r2LFjWrlypYYMGaLu3btr3LhxKl68uMXxhQsX1n//+181bNhQGRkZmc42ffp0derUySJes2ZN1alTRz/99FOWP5+tYmJirM5gi4YNG1rNufMa2qpy5coaO3asRfzXX3/ViBEjtHjx4kzP//TTTxUaGqohQ4ZoyJAhCgkJMTyuZcuW6tWrlz777DNT5vYmnvxeg31atGihfv36WcS//fZbvfXWW9qyZUum58+ZM0eS1K5dO40dO1a1atWyeuwXX3yh/fv36+jRo44N7aCwsDDDeEJCgosnsU/hwoUN45cuXVJaWpphrlSpUnr22WfVvn171apVy+rnnP+1f/9+LVmyRLNmzdKJEyeyPbMk7dmzR61bt74rltl9Yk3t2rUtYteuXdPJkyetntOtWzf17t3bMDdw4EDt37/f7jm8xYkTJzRhwgSNHDnSIhcWFqZJkyapR48ehuc+8sgjateunWHu3Xff1a+//mrqrP/00EMPGcZXr17tlH7eep1s5Ynrrn/y1PWqq8yfP18vvfSSRTwsLEwrV65UmzZtMv0d5y38/f01f/58RUREWOTef//9LD+bm81bn6feoHXr1hbP/D/9+OOPmjdvnosncg4fHx99/PHHVu+lWbNmWb2XvEVO2SO75557NH78eIu4J651PP2Z6A17WuxTeP595K08/TO1mbzxHvLGmc2SJ08eLVq0yOq6VJLGjBmjESNGuHCqrHnDa7Zu3TqVKlUq02MuXLigokWLWsRHjhyp999/P8se7sRa1D1r0T956960o4oUKWIYP3PmjEvnOHv2rNWctRk9RW5Yi3oyV+9b42/jxo2zmps7d67NdfiuCgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHBMUKhU7j7bjt2z2LmzAAAAAAAAAAAAAAAAAADgLXzdPQAAwD3y5JOqNJea9JBavyQ9+JzUsLNUupbk6+/u6XKnd999V2XLljXMpaena9iwYapTp47WrVtnU72MjAzNmzdPlStX1tSpU60eV7duXb355pvZmtld3nrrLUVERBjmJk+erPvvv1/btm2zq+bOnTvVpEkTbdy40eoxw4YNs6umN6tVq5a6d+9uEf/+++9Vv3591a5dWyNGjNDy5cu1a9cunThxQqdPn/7rz7Vr1zKt7+fnp88++0yBgYGG+b1796pOnTr68MMPlZqaatPMaWlpmj17turWravt27cbHlO/fn316dMny1obNmzQyZMnDXMxMTE2zWOLxo0bq0KFChbxGzduaNGiRVme/+d1NOLua2irsWPHKiAg4K7Y//3f/6l27dpavNi2fwF0+/ZtvfXWW2rRooViY2OtHjdq1Cj5++euh5ynv9dgn4kTJ97195SUFD377LNq3bq1tmzZYnOdVatW/fV7PCMjw/CY0NBQTZs2zaF5zRAWFmYYT0xMtIj5+fmpcuXK6tixo4YMGaIxY8bo/fff14wZM/TRRx9p4sSJGjFihHr27KkGDRooNDTUaXMXLlzYMH716lWLWOnSpTVv3jydPHlSb7zxhmrXri0fHx+be917770aOXKkjh49qnnz5qlSpUrZnnvz5s0WsSpVqqh8+fI21/Dz81N0dLRFfOvWrVbPqVixoj755BPD3IIFC6zmcpKxY8da/ezRvXt3NWnSxCIeGBiod9991/Ccc+fO6a233jJxwrtVr15dJUqUMMytWbPGaX297TrlJLl9vTphwgSlpKQY5sqXL689e/aoR48edv3+9kTjx49Xo0aNLOJ79uzRK6+84vJ5vPV56g3+93PlPw0ZMsSFkzhPUFCQ5s+fr06dOhnmb9y4ofHjx7t4KvPllD2y2rVrKyQk5K+/e/Jax9OfiZ6+p8U+xR88/T6C5/PGe8gbZzZDeHi4NmzYoHbt2hnm09PT1bdvX40YMcLFk2Utt75mnoS1qHvWon/y1r1pRxUqVMgwbrQWd6bM+lmb0RPklrWop3LXvjWkPHnyKDw83DB36NAhu/Ym+K4KAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArubr7gEAAK4VWUp6dLjUd5706GtSkx5S3fZS/cel5r2krhOkfvOlJj2lwBB3T5t7tGzZUj179jTMJSUl6bHHHtPEiROzVTslJUX9+/fXiy++qIyMDMNjhgwZoho1amSrvqv5+PioWLFihrnJkyfrlVdeUXp6erZqx8fHq1OnTrp48aJh/tFHH1XFihWzVdvb9OvXTz4+Pn/9PTU1VS+88IIefPBB7dmzx5T61apVM8xt375dTZs21fnz57NV+9KlS2rZsqX2799vmB89erTCwsKyrPPpp58axrt166aAgIBszfa/YmJiDONffvmlkpKSsjzf2nX0lGtoi/vuu++uvw8cOFCDBw9WSkqK3bV2796ttm3bWj23ZMmS6tixY3bG9Fre8F6D7YoUKfLX/05JSVH79u2t/q6yxZgxY/TEE08oNTXVMN+6dWu3v2dCQ0MN44mJiZKkyMhIPffcc1q6dKni4uJ0+PBhLV68WBMnTtTw4cPVr18/9e7dWy+88IKGDBmit99+W7Nnz9bOnTt1/fp1bdq0SUOHDr3r2pohb968hvEbN27c9fd+/frp8OHD6tKli/z8/Bzq6efnpy5dumj//v16/fXXs1VvxYoVhvG+ffvaXOPJJ59URESERXzlypWGxwcFBWnhwoWGvy+OHz+u3r1729zbm925c0f9+vWzmp82bZp8fe/exnvllVdUvnx5w+MHDhyo27dvmzrjP0VFRRnGT506pWPHjjmtr7ddp5yC9ap05swZTZ061Wo+MjJSc+bM0f79+zVw4ECra1ZP1r59ew0ePNgiHhcXp06dOmXr87mjvPV56umefPJJ1alTxzC3Zs0abdy40cUTmcvPz0/dunXTkSNH1KlTJ6vHxcTE6Nq1ay6czHw5dY/Mk9c63vJM9OQ9LfYpvOc+gufyxnvIG2c2Q/HixbVlyxY1btzYMJ+cnKwnn3xS06ZNc/FkWcutr5mnYS3qnrXon7x1b9pRwcHBhvFbt265dI6bN29azVmb0Z1y01rUk7lr3zq3y58/v1avXm01P2zYMLvq8V0VAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXM3X3QMAAFynRhvp6WlSlQckn0yeAEGhUpPu0r8/kAqUdt18udno0aOt5vr27atly5Y53OPjjz/WuHHjDHP+/v568803He7hChkZGerQoYPq1q2rxYsXKyMjQ5K0fft2DR061OH6165ds1rHx8dH0dHRDvfwBq1bt/7rf9+5c0ePPPKIPvnkE1Nq+/v7a9iwYYa5S5cu6YknnlBSUpJDPZKSkvT4448rPj7eIhceHq6nn346yxqfffaZUlNTLeIFChRQ+/btHZpPkoKDg9W5c2fD3PTp07M839p19KRraK8pU6bovffec6jGjz/+qLFjx1rNd+/e3aH63sRb3mvInpdffllr1651uM4333yjV1991WrejGerI8LCwgzjRYoU0aeffqpz587pk08+0aOPPqrQ0FC7agcEBOiBBx7QhAkTdObMGX311VcqV66cGWMrKCjIMH7nzh1Jkp+fn2bNmqX3339fefLkMaXnP3uPHj1aa9asUb58+ew696efftKmTZss4i+++KLq1KmT5fmFCxc2/B187do1zZ492/Cc9957T7Vq1bKI37lzR506ddKtW7dsmDxnWLlypZYvX26Yq1Wrlp5//vm//l6yZEm9/vrrhseuX79eixYtcsqMf4qKijKMr1mzxql9Je+6TjkF69U/DBs2TFu3bs30mBo1amjKlCk6f/68Tpw4oa+++kpDhgxRq1atXDRl9pQuXVqzZs0yzMXExOjUqVOuHej/89bnqScLCAjQmDFjDHPp6elu/+yXHfny5dN9992nf//73/rss890+fJlffXVVypTpozh8RkZGerfv7+WLFni2kGdIKfukXnyWsdbnomeuqfFPsUfvOU+gufyxnvIG2d2VKVKlbRt2zZVr17dMH/r1i1FR0drwYIFLp3LVrnxNfNUrEXdx1v3ph2V1VrcVTLrFxwc7MJJjOXmtagnc+e+dW5Vs2ZNbd++Xc2bNzfML1++3Op+vjV8VwUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABX83X3AAAA16j9iNRusOQfaPs5EcWl7pP/+L9wnvvvv1/333+/Ye7LL7/UzJkzTev1xhtv6PvvvzfMPf744ypfvrxpvZztp59+0uOPP66aNWtq3rx56tevn9LT002pPX/+fMXGxhrmHnjgAVN6eDofH5+//vfgwYO1du1a02o/8cQTKlq0qGFu0KBBOn/+vCl9jh8/rhkzZhjm+vTpk+X5Fy9e1MqVKw1zMTExDs0mSY899pjy5ctnEd+5c6cOHDiQ5fnWrqMnXUN7HDx4UEOHDjWl1oQJE3Tz5k3DXKtWreTn52dKH0/nLe812O+HH37QtGnTTKs3efJkrVq1yjB3//33q169eqb1sldoaKhhvE2bNnrmmWcUHBxsSp+AgAB169ZNv/76q8aMGSN/f3+H6gUGGn/oTklJkSR9/vnneuqpp7Ksk5KSokuXLunChQtKSkqya4bWrVtr69atCg8Pt+u8MWPGWMSCgoK0evVqtWjRwup5lStX1rp161SqVCmL3JQpU5SYmGgR79Kli55//nnDeoMHD9ZPP/1k++A5RP/+/a2+1mPGjFFkZKQk6f/+7/8UEhJicUxycrJeeuklp84YEhKiZs2aGeZWr17t1N5/8obrlFOwXv1bamqqHn/8cf344482HV+2bFl169ZNEydO1GeffWaR7969uzp06KCKFSvK19d92/T+/v6aP3++IiIiLHLvv/++Fi9e7Iap/uDNz1NP9eKLL6ps2bKGuTlz5ti0FjXbzz//rAsXLtj15+LFi7p586bS09MVFxen3bt364svvlBMTMxfzwAjcXFx6tKli6ZOnerCn9D5ctIemSevdbzpmeipe1rsU3jXfQTP5I33kDfO7Kh69epp69atKlOmjGH+8uXLat68uTZu3OiSeeyVG18zT8Za1H28dW/ajHmMpKamunSOP9f+RqztF9iDtWjO4wn71rlJYGCgXn31Ve3evVtVq1Y1PObw4cM27d0Z4bsqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABcJyVRunLKtj+3r7trSrgK9wMAAAAAAAAAAAAAAAAAAMit/N09AADA+UpUk1q/mL1zg/NKj4+SPn9RSk81dy784bnnnjOMp6amavjw4ab2Sk9P16uvvqodO3ZY5Hx9fdWrVy+9/vrrpvZ0toMHD+rJJ580tWZycrKWL1+up59+2iLXrFkzU3t5upUrV2ratGmm1jS6rpJ0/PhxzZs3z9ReU6ZMUf/+/eXn53dXvGrVqipfvryOHz+e6fnTp09Xhw4dLOLR0dEqUqSILl26lO3ZYmJirPa0hdF19MRraKsBAwYoNdWcB01iYqLmzp2rF154wSKXN29eValSRQcPHjSllyfzpvca7DNkyBDTa44aNUrt2rUzzHXt2lV79+41vactwsLCXNovKChIw4cPV/PmzfXEE0/o4sWL2arj6+trGE9PT9fQoUPVs2dPw/zWrVu1YsUKfffdd/r1119169atu/J58uRRxYoV1bJlS0VHR6tNmzby8fGxOkeNGjW0bNkytW7dWsnJyTbNvn79en344Yfq06fPXfEiRYpo48aN2rRpk9asWaOzZ88qNTVVRYsWVYsWLdSuXTsFBgZa1Nu1a5fGjx9vES9fvrxmzJhhOMM333yT6eePIkWK6OGHH1b16tVVpEgRRUZG6vbt27p06ZJ+//13rVu3Tvv27bPp5/U0p06d0tixY/Wf//zHIhcREaGxY8dq/vz56tSpk+H577zzjo4dO+bUGVu0aKGgoCCLeEpKijZu3OjU3n/yhuuUU7Bevdvly5fVtGlTzZ49W0888YRDtfr06fPX79o7d+5o37592rVrl3bu3KmNGzfq/PnzZoycpfHjx6tRo0YW8T179uiVV15xyQzWePPz1BPlzZtXb7zxhmEuKSlJI0aMcPFEfyhUqJDTe2RkZGju3Ll69dVXdfbsWaf3c5ecsEfmyWsdb3smeuKeFvsU3ncfwfN44z3kjTM7onXr1lq8eLHVPa0TJ06oTZs2OnHihFPncERue828AWtR9/DWvWlnycjIyFH9WItKjz/+eLbWdZGRkYbx6tWra8qUKdmaZdSoUbpx40a2zv2TJ+xb5xadOnXS+PHjVa5cOavHnD17Vu3atcv268p3VQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuM65X6XPX3D3FPAU3A8AAAAAAAAAAAAAAAAAACC38nf3AAAA53vwWcnXL/vnFygl1W4n/bjMvJnwBx8fH7Vr184wt3DhQp05c8b0njt37tTWrVvVpEkTi9wjjzyi119/3fSe3mjXrl16+umnLeKFCxdWnjx5lJiY6Pqh3GDUqFGm1gsKCtIDDzxgmJs2bZrS09NN7XfmzBnt379fderUschFRUVp2rRpmZ6/Zs0anT17ViVLlrwr7ufnpx49emjy5MnZmqtEiRJq1aqVRfzWrVuaP39+ludbu46eeA1t8fPPP+vbb791uM4/LVu2TC+8YPwvxmrWrKmDBw+a2s/TeNt7Dbb78ccftXPnTtPr7tq1S9u2bVPjxo0tcg899JCGDBliek9bhIWF2X1ORkaGbt68qbi4OKWlpSlfvnwKDw+Xn5/tH4ibNGmiLVu2qFmzZrpw4YLdM1hTuXJltW3b1iK+bt06vfnmm9qxY0em5ycmJmr//v3av3+/3n33XVWvXl1vvPGGunTpYvWcZs2aaezYsXrllVdsnvPll19WnTp1dP/9998V9/HxUYsWLdSiRQub6ly8eFFdu3ZVamrqXfHAwEAtXLhQefPmtTjn5MmT6tWrl2G9Ro0aafz48XrggQfk4+Njte/EiRN15swZjR07VtOnTzf9d56zTZw4Uf/+979Vvnx5i9yzzz6r6Ohow/N+//13jR492tnjWe2/bds2xcfHO73/nzz9OuUErFeNJSYmqlOnTmrfvr0mTpyoKlWqOFwzKChIDRo0UIMGDdS3b1+lp6fr+++/15w5czR//nynrT/bt2+vwYMHW8Tj4uLUqVMnpaSkOKWvo7zleepphg0bpoIFCxrm3n//fZ09e9bFE7nOlStXdODAAYvPJLCNq/bIPHmt443PRE/b02KfwjvvI3gWb7yHvHFmR3Tu3Flz5sxRYGCgYf6nn35SVFSULl++7LQZHJXbXjNvwlrU9XLa3jRcz9PXog8++KD69u1rWr2yZctq4MCB2Tp3ypQpunHjhkP9PWXfOieLjo7W2LFjVbt27UyP27dvn9q1a6fz58871I/vqgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOAqvu4eAADgXEUqSsWrOl6n7qOO14ClevXqqXDhwoa5zz//3Gl9rdW+9957VbJkSaf19Sa//PKL1VxkZKQLJ3Gf3bt3a/fu3abWbNKkifLkyWOYW7Nmjam9/rR161bDeN26dbM8Nz09XZ999plhrlevXtmeqWfPnvL1tfwo/vXXX+v27dtZnm/tOnriNbTFl19+aUqdf9qzZ4/VXKlSpUzv52m87b0G282bN89ptefPn28Yr1mzpgoVKuS0vpkJDQ3NNJ+RkaHNmzfrP//5jx555BEVL15c/v7+Cg8PV5kyZVSuXDkVLFhQ/v7+KlCggNq2bas33njDpudb+fLl9e233ypv3rxm/TiqWLGiAgMD//p7SkqKBgwYoIceekg7duywu97BgwfVtWtXPfnkk5k+P15++WU1atTI5rrJyclq1aqVVqxYYfdMfzp27Jjuv/9+nTx50iI3ZcoU1alTxyKekpKiLl26KC4u7q54QECAZs6cqe3bt6t58+by8fHJsn+pUqX00Ucfaf/+/apQoUK2fw53uHPnjvr162eY8/X1VenSpQ1z/fv3V2JiojNHkyQ99NBDhvHVq1c7vfc/efp1yglYr2Zu+fLlqlGjhrp06aIVK1YoJSXFtNq+vr5q2bKlPv/8c/3222966qmnTKv9p1KlSmnWrFmGuZiYGJ06dcr0nmbxluepJylatKhefvllw9y1a9c0duxYF0/kWoULF9b48eN1+vRpTZkyReHh4e4eyau4ao/Mk9c63vhM9LQ9LfYpvPM+gmfxxnvIG2fOrj59+ujrr7++63PqP3333Xdq3ry5Ll++7JT+ZslNr5m3Yi3qOjltbxqux1rUtTxl3zoneuCBB7RlyxatWrVKtWvXzvTYuXPnqmnTpjp//rzDffmuCgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK7i6+4BAADOVb6+OXUiS0r5i5hTC3+rW7euYTw9PV3bt293Wt8tW7ZYzdWqVctpfb3J9evXreYiIiJcOIn7fP3116bXtHZ/nT9/XocOHTK9nyTt37/fMF61alWbzv/000+Vnp5uEa9WrZruu+++bM0UExNjGJ8+fbpN5xtdR0++hllZu3atKXX+6cqVK7p06ZJhrkiRnP9A88b3Gmzz3XffOa12Zp89qlWr5rS+mdmxY4fhz3z69Gm99tprKlOmjJo3b64333xTK1eu1IULFwx/Z0vStWvXtH79eo0ePVoNGjRQ3bp1s3zWVa1aVR999JEpP8v/SklJ0cMPP6z333/f4Vrz5s1T48aNFRcXZ5j39fXV+PHj7aqZmJioDh06qF+/frp27ZrN56WkpOj9999XgwYNdOrUKYv8E088oT59+hieO3ToUO3evfuuWFhYmNasWaNevXrZNf+fqlevrm3btmX7me0uq1ev1tKlS20+fuXKlVq2bJkTJ/pD2bJlVbFiRcPcmjVrnN7/f3nqdcopWK9mLS0tTQsWLFD79u1VrFgxde7cWZMnT9aWLVuUkJBgSo/ixYtr1qxZ2rZtmwoXLmxKTX9/fy1YsMBwbfvee+9p8eLFpvRxBU9/nnqKt956SyEhIYa50aNHW/2Zc5qAgAANHDhQR48eVYsWLdw9jtdw1R6ZJ691vPWZ6El7WuxTeO99BM/hjfeQN86cHaNGjdK0adPk62v8n98sXLhQUVFRunXrlum9zZZbXjNvx1rUNXLy3jRci7Wo85m9bx0UFKTGjRs75U+5cuUc/XFdpl69elq7dq02bdqkJk2aZHl8p06d1L17d8XHx5s2A99VAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwBX83T0AAMC5CpQ2r1ZkKSnuknn1IFWvXt0wvn//fsXHxzut75EjRxQbG6sCBQpY5KpVq6aVK1c6rbe3iIuLs5oLDw933SButGPHDtNrVqlSxTB+8OBB03v96dq1a4bxMmXK2HT+mTNntG7dOkVFRVnkYmJitGfPHrvmadSokSpVqmQR//nnn7V3716bahhdR0++hpm5c+eOfv31V4frGLl27ZqKFCliEc+TJ49T+nkSb3yvIWvp6enat2+f0+r//PPPSkpKUnBwsEWuUqVK2rRpk9N6W3Po0CG1bNlSjRs31htvvKGGDRtqzJgxmjp1qpKTkx2q/dNPP6lbt2766quvNGPGDBUrVszwuO7du2vevHlasWKFQ/3+1wsvvKD169ebVm///v164okntHr1avn7W273NG/eXE2bNtWWLVtsrpmenq4PPvhAc+bMUY8ePdS+fXs1b97c4h5JS0vT3r17tWLFCs2dO1fHjx83rFeuXDnNnDnTMLds2TK9++67FvEvv/xSLVu2NDwnLS1NZ8+eVWxsrMLCwlSyZEmFhIRYHFeoUCGtWrVKNWvW1KVL3rOgGTBggNq2bZvlcyspKUn9+vVzyUxGn4ck6dKlS079/ZQZT7xOOQXrVfvExsZq4cKFWrhwoSTJx8dH5cqVU82aNdW0aVMNHjzYofr333+/du3apYcfftjhz3Tjx49Xo0aNLOK7d+/WkCFDHKrtat7wPHW3ChUq6JlnnjHM/f7775o2bZqLJ7rbzJkzdevWrWyfHxgYqLCwMOXNm1clS5ZU9erVDT8P/FOhQoW0YcMG9erVS7Nnz85279zCFXtknr7W8dZnoiftabFP4b33ETyHN95D3jizPXx8fPThhx/qhRdesHrMhx9+qL59+yojI8OUns6W01+znIi1qPPk5L1psBbNaczety5RooS2bt3q6FiGPv74Y7344otOqW2WqlWravTo0Xr88cdtOj41NVUff/yxFi1a5JR5+K4KAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICcKaKkVLyKVLSCFBIhBYdKfoFSSpKUnCDFXZKunJLO7JfiY909rW0iSkql75UK3SPlLSQFBks+flLqHSnplnTjonTxmHT2gJQU7+5pPUtuvB8O/5A774X8RaQiFaUi5aWQcCko9I8/fgFSetofr3dyonTzsnT1d+nyCenaGXdPDQAAAAAAAAAAAAAAAADIDfzdPQAAwLlC8ptYK9y8WvhDpUqVDOOHDx92eu8jR46ocePGFvHKlSs7vbenKViwoMqVK6fy5cv/9Sez6+Dr6+vC6dwjJSVFP/74o+l1y5UrZxg/ffq06b3+dP36dcN43rx5ba4xffp0RUVFWcSffPJJvfzyy0pOTra51tNPP221h62MrqOnX0Nrjh8/rvT0dIfrGImLizOMBwYGOqWfJ/HW9xoyd+bMGaWkpDitfkpKis6ePasKFSpY5KzdU66ybds2RUdHy9/fX6mpqabWXrlypRo3bqwffvhBJUuWNDxm7NixWrlypTIyMkzpuXjxYn322Wem1PqnDRs26J133tGrr75qmI+JidGWLVvsrhsXF6dp06Zp2rRpkqT8+fOraNGi8vPz0+XLlxUbG5vltQkICNCCBQuUL18+i9zp06cNn48vvfSSOnToYBGPj4/Xm2++qVmzZik29u9/fRsQEKB27dpp0qRJqlix4l3nFCpUSF9++aXatGljy4/sEX7//XeNGTNGo0ePzvS4sWPH6uTJky6ZyejzkCStXbvWJf2NeOJ1yilYrzomIyNDx48f1/Hjx/Xjjz9q8ODBd+VHjhyp5ORk1ahRQ/Xq1VPlypWzXGuWKVNG69evV+3atXX58uVszfXII49YzCJJN27cUOfOnZ36WcNs3vY8dZfRo0fL39/4q6Dhw4fbtZ51hpEjR+r8+fOm1qxUqZI6duyoHj16qGbNmobH+Pn5aebMmbp8+bLWrFljan9v5q49Mk9f63jzM9FT9rTYp/Du+wiewRvvIW+c2VYBAQGaO3eunnjiiUyPO3/+vGn7Sa6Qk1+z3IK1qPk8YW96xYoVpvYFa1Hpj2fUL7/8Yvd5QUFBFvvvknTr1i39/vvv2ZrF0d8Bnrhv7Y3uuecejRo1Sj169LB5vb98+XINGTJER44ccfJ0fFcFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICzhOSXogbZduyexdLpn7Pfyy9Aqv2wVLOtVLic7eddOCL9tEI6+K2Ukf53vGAZqf4TmZ+bGCd9/2n25rWFj69U7UHpvsekIhVsOyc9TTq5V9r9X+n0PufNlh3cD46x536o1jL790KJalLDLtbzwWG212r2lFT3UduPX/e+FB9r+/GSFFFSqtlGqt5KylvQvnMlKe6SdHyn9PNK6erv9p8PAAAAAAAAAAAAAAAAAIAt/N09AADAuVJTzKuVZmIt/CE8PNwwfv36daf3ttYjf/78Tu/tan5+fipTpozKlSun8uXL3/WnXLlyyps3r7tH9Dhnz57VnTt3TK+bL18+w7ivr68aNGhgej9JKl++vGE8LMz2f4mybNkyXbp0SUWKFLkrHhERoQ4dOmjhwoU21QkKClLXrl0t4omJifrqq69snsfoOnr6NbTmypUrDtew5vbt206r7em89b2GzJ07d87pPax9PvCUZ2VqaqpT6p46dUotW7bUnj17DN8/NWvWVFRUlFavXu1wr7S0NA0fPtzhOtaMGzdOzz77rAoUKGCR69ixo5577jmlpaU51CMuLk5xcXF2nTN58mTVq1fPIp6amqouXbpY3HuhoaEaM2aMYe9mzZrpwIEDFrmUlBQtXbpU69ev18aNG9WwYcO78q1bt1a7du20atUqu2Z3p0mTJunpp59WhQrG/3r3t99+04QJE1wyS0BAgFq2bGmYM+O94QhPuk45CetV5/r222+1bdu2v/6eL18+PfLII+rWrZvatWsnHx8fw/OKFSumr7/+Wm3atFF6errhMdaUKlVKs2fPNszFxMTo1KlTdtVzp5zwPHWFWrVqqXPnzoa5ffv2ae7cuS6eyDWOHj2qiRMnauLEierWrZsmT56sokWLWhzn7++v2bNnq1KlSrpx44brB3UDT90j8/S1jjc/Ez1lT4t9Cu++j+AZvPEe8saZbREWFqYlS5aoVatWWR47atQobdy4Udu3b3e4ryvk1NcMf2Mtmn3u3Jt2pYyMDMO4n5+fS+fw97f+nzTaew+6iretRceNG6dx48bZfV6lSpV05MgRi/imTZvUvn17M0aziyfvW3uLsLAwjRw5UgMHDlRAQIBN52zYsEEjRozQzp07nTyddXxXBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAOfyDpAoNbTv2yA/Z71OlufRgbylvIfvPLVb5jz8NO0tr35XOHvwjHlZQqtkm83PjLknff2p/T1sUKis9PEQqXM6+83z9pPIN/vjz205p7XvS7WvOmdFe3A/Zl537Ibv3QmiE7a9TVopVtv3YjAwp8abtx4cVkFo+L1V5wP65/il/Eanuo1Kd9tKJ3dJ3M6RrZxyrCQAAAAAAAAAAAAAAAADA//J39wAAAOdKuGFerdvXzauFP+TNm9cwfuPGDaf3vn7d+AW1NpO3qFy5surXr6969eqpRo0aKl++vEqXLi0/Pz93j+ZVrN0fjgoLCzOMx8TEKCYmxik9rfHx8ZGvr6/S09OzPDYtLU2ff/65Xn31VYtcTEyMFi5caFPPjh07Kn/+/BbxBQsW6OZN2//1itF19PRraM3t27dNnOhuGRkZTqvt6bz1vYbMOfP98idrn0Gs3VM5ybFjx/Tmm29qypQphvknn3xSq1evdrjPunXrdPjwYYfrWHPz5k199tlnGjJkiEUuMjJS9957r3766Sen9TfSsWNH9evXzzD32muvaceOHRbxZ555xvCZ2bdvXx04cCDTfgkJCXr88cf122+/KU+ePHflBg8erFWrVtkxvXslJydr+PDhWrBggWF+/PjxSk5OdsksTZo0MfxdkJ6ervXr17tkBms86TrlJKxXXevmzZuaO3eu5s6dq1q1aundd99VixYtDI9t2bKlunfvrjlz5thc39/fXwsWLFBERIRF7r333tOSJUuyObl75MbnaXa8/vrr8vHxsZrLDebOnastW7bo+++/V9myZS3yhQoV0ttvv231s4o386Y9Mk9f63jzM9FT9rTYp/Du+wiewRvvIW+cOSuFChXSpk2bVLduXZuO9/Pz09dff617773Xru8A3CUnvmbIHGtRz5DV3rQrJSUlKSAgwCIeGBjo0jky65eUlOTCSbInN69FXc2T9629QYcOHfThhx+qePHiNh2/ZcsWvf7669q8ebOTJzMf31UBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOAefgFSm5eke6Mcr1WglNR1ovTddGnvUsfrOaJSE+nhoVJAkGN1KjSUin0o/XekdPGoObN5Mu4H67zhXrh1RUpLse3Ye6Okls9LgXnM6+/jI5VvIJWpLf0wW9q9yLzaAAAAAAAAAAAAAAAAAAD4unsAAIBznfvVnDrpadKl38yphb+FhIQYxm/evOn03tZ6hIaGOr232YoWLaqRI0fq0KFDOnz4sObMmaOBAweqdevWKlu2rPz8/Nw9oteJi4tzSl1r97w3mDFjhjIyMizibdu2VbFixWyqERMTYxifPn26XbN483X8X8nJye4eIUfKSfcI/paYmOj0Hrdu3TKMe+Png+yYOnWqTpw4YZhr3769KT1WrlxpSp3MrFixwmru3nvvdXr/f7rnnnv0+eefG+ZWrVqld955xzDXu3dvi9ixY8f01Vdf2dT3/PnzmjFjhkW8ZcuWKlOmjE01PMW5c+es5qy9Z50hKsr4X0nv3btXsbGxLpvDGk+5TjkJ61X32bdvn1q1aqX333/f6jGvvfaaXTXHjx+vRo0aWcR3796tIUOG2D2ju+W252l2VKpUSf/6178Mczt37nTJNfQUp0+fVps2bZSUlGSYj4mJUVhYmIuncg5v3SPz9LWOtz8TPWFPi30K77+P4H7eeA9548xZadKkierWrWuYS0kx/v9QVaZMGcM9Ck+UE18z2I61qHtltjftSnfu3DGMu/rzXGb9rK3tPE1uWou6k6fvW3sqX19fTZo0SUuWLFHx4sWzPH737t1q27atmjVrps2bN7tgQnPxXRUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAO7hHyg98R/p3ijzavr6Sa1elO57zLya9qrUWHp0uBQQZE690HCp63ip4D3m1PNU3A9Z8/R74do5245r9m8paqAUmMc5c/gHSg/2lqIHST6+zukBAAAAAAAAAAAAAAAAAMh9+E/SACCHO7FbSk9zvM6Z/VJyguN1cDcfHx/DeHp6utN7u6KHswUHB+s///mPfvvtN40aNUpVqlRx90g5xq1bt9w9gsc5ceKEvvvuO4u4n5+fevbsmeX5xYoVU+vWrS3ihw4d0rZt20yZEUDOxucD50tLS9OiRYsMc+Hh4SpXrpxNdTIyMqzmjJ4lZtu6dauSk5MNc1WrVnV6/z/5+/trwYIFCg8Pt8idO3dOTz31lOF5ERERqlGjhkV84cKFmV7b/zV//nzDeNOmTW2ugb9FRRn/S+k1a9a4eBK4CutV90pPT9eAAQO0ZMkSw3zVqlUN1xdGHnnkEQ0ePNgifuPGDXXu3FkpKSmOjOo0PE8d88orr8jX1/groNGjR7t4Gvc7fvy4Jk6caJgLDQ3Vv/71LxdPZC5v3yPz9GeLtz8T2dPyDN5+H8H9vPEe8saZs2vhwoWqV6+eEhKMv0zt3LmzYmJiXDpTduSm1wzGWIu6T2Z707buS5vh5s2bhvHIyEiXzSBJBQoUsJqzNqMnyulrUU/gjH3rhIQErVmzxil/Dh48mO25zBIYGKgVK1bolVdeyfLY/fv369FHH1WDBg20fv16F0xnPr6rAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADATXykDiOkMnWcU/7BZ6Wy9ZxTOysVG0u+fubWDAyROr4uBQSZW9djcD/YzJPvhevnsj6mVjvp/iedP4sk1WwrRQ10TS8AAAAAAAAAAAAAAAAAQM7n7+4BAADOFR8rHVgn1Yp2rM62r82ZBzBLsWLFtGzZMt13330O1bl9+7aOHTv215+jR4/q2LFjunXrlvbv32/StN4nPT3d3SN4pOnTp6tly5YW8ZiYGE2cODHTc3v27Ck/P8t/jTN9+nTT5gMAOG7ZsmUaOnSoYa5mzZo6ceJEljXu3LljNXfunA3/YtFBaWlpunTpkkqVKmWRCw8Pd3r/P02aNEn169e3iKelpalr166KjY01PK9x48by8fGxiG/atMmu/jt27FBycrICAwPvijdr1kxfffWVXbVyu6JFi6pWrVqGuTVr1rh4GiB3eeGFFxQVFaXg4GCLXJs2bbRhw4ZMzy9VqpRmz55tmIuJidGpU6fMGNMpeJ5mX/78+dW9e3fD3K+//qoVK1a4eCLPMGPGDI0cOdIw17RpU82aNcvFE5mDPTLYgj0tAHCeadOmqV+/fsrIyNCAAQM0Y8YMw+OmTp2qrVu36ujRoy6eELBfbl6LupO1vWlb96XNcPHiRZUrV84iXqRIEZf0t6XfxYsXXTiJ43LqWtQTOGvf+uLFi4qOdvA/svJQ/v7+WrRoUZY/3+HDhzVy5EgtXLjQRZM5D99VAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgHvd3lco3cF59H1+p/uPOq+8OkaWkVi9Ka9519yTm436wj6feC9fOZp7PV1hq+bxrZvlTzbbS2V+kA+tc2xcAAAAAAAAAAAAAAAAAkPP4u3sAAIDz/TBLKneflLdQ9s4/+K10Zr+5M+EPaWlphnF/f+c/ogMCAgzj1mbyJAULFtT27dtVpkwZm45PSkrSb7/9pmPHjunYsWM6evToX//7woULhucULlzYzJHx/2VkZBjGf/jhBx05csTF01ifx5pvvvlGsbGxKlCgwF3xKlWqqEGDBtq1a5fVc2NiYixid+7c0ezZs+2aQTKe21uuITLn4+NjSh1vf695I7Neu8z4+fk5vUdgYKBh3Bs+H5jl2LFjVnMFCxa0qUZSUpJhPCUlRXFxcdmay16XLl1SqVKlLOL58+d3Sf9HH31UAwcONMy98cYb2rJli9Vzy5UrZxg/fPiwXTOkp6fr2LFjql69+l3xsmXL2lUHUtu2bQ3jcXFx2rlzp4ungauwXvUMly5d0ty5c9WrVy+L3IMPPpjpuf7+/lqwYIEiIiIscu+9956WLFli1phOwfM0+55++mmFhIQY5qZMmeLiaTzH2bNndeDAAdWsWdMiV69ePTdM5Licskfm6WudnPBMdPeeFvsUOeM+cgVX7K94K2+8h7xxZnuNGDFCY8aM+evvn376qaKjo/X445b/X8FCQ0M1b948NWzYUCkpKabOYZbc8JrBNrl5LepO1vambd2XNsPFixcN49b2bJ0ls36XLl1y4SSOy4lrUU/BvrX9pkyZovbt21vNX7t2TW+88YY+/vhjpaenu3Ay5+C7KgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3KNQWalJD3dP4Z1qtJG2zZVuXnb3JObhfsgeT7wXrp/LPH//k1JAkGtm+adWfaTjO6WEONf3BgAAAAAAAAAAAAAAAADkHP7uHgAA4HwJN6T/viV1HS8F57Xv3DO/SGvedcJQkCTFx8cbxiMiIpze21qPW7duOb23I3x8fLRgwQKVKVPG6jEXL17U8uXLtWHDBv300086fvy40tPT7e4D8yUlJRnGFy1apPfff9/F09gvJSVFs2fP1ssvv2yR69Wrl3bt2mV4XoMGDVSlShWL+OLFi3Xt2jW75zC6jt5yDZG5PHnymFLH299r3sis1y4zwcHBTu8RHh5uGLf2mSUnunLlitLS0uTn52eRs3Z9/ldsbKxh/Pbt246MZhdrvfz9nb8VVLp0aX3xxReGuXXr1mncuHGZnl+gQAHD+IULF+ye5cKFC6pevfpdscjISLvr5HbR0dGG8fXr1ystLc3F08BVWK96jjVr1qhXr14W8WrVqmV63tixY9WoUSPDXHR0tFq1amXKfH+ytk5/88031a9fP8PcoUOH1LlzZ8Ncbn+eOuLpp582jN+8eVNz58517TAe5tSpU6pZs6ZFvFChQm6YxjE5aY/M09c6OeGZ6O49LfYpcsZ95Aqu2F/xVt54D3njzLZKS0vT888/r5kzZ1rkevfurYYNG6pEiRIWuTp16mjChAkaNGiQKXOYLSe/ZrBfbl2LupO1vWlb96XNcOzYMcN4SEiISpQooXPnsvj/yGcSo8+g0h+fa0+dOuWSGcyUk9ainoR9a/s8/PDD6tu3r9X8rl279Nhjj+n8+fMunMp5+K4KAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOAu1VpK8VfNr1uymvk1naXlc5Kvn7un8E6+flK9jtJ30909iXm4H7LHE++F6+et5/wCpKoP2lcvI126dVVKipfSU6WAPFJouBSc1746gcFSo67Sxk/sOw8AAAAAAAAAAAAAAAAAgH/yd/cAAADXuHxcmt1femykVKisbefsXyut/0BKS3HubLnZrVu3DOMRERFO722th7WZPEWXLl304IPG/yX/uXPn9Morr2jhwoVKS0tzqE9ISIhD58NYQkKCYbxAgQIuniT7pk+frpdfftki3rVrVw0YMEB37tyxyD399NNWa2WH0XX0pmuYU/j6+ppeMzQ01JQ6OeG95kye/NplxhWfD8LDww3j8fHxTu/tKTIyMhQfH6/8+fNb5IKCgmyqce7cOcN4QECAQ7PZw9/feMsnNTXV6X0XLFhgeL9euHBBPXr0yLJGZGSkRSw1NVUpKfYvTIzuXaP6sM7Hx0dt2rQxzK1Zs8bF08CVWK96jp9//tkwHhoaqsDAQCUnJxvmo6OjrdasVKmSGaPZpHjx4ipevLhh7ujRo1bPy83PU0dUrlxZtWvXNszNnTvX6loht7h8+bJh3NrnYE+Wk/bIPH2tk1Oeie7c02KfIufcR//krfsr3sob7yFvnNkWiYmJ6tq1q5YtW2aYv379unr27KkNGzYYvk8GDhyodevWeeSaOqe+Zsie3LoWdSdre9O27kub4eDBg1Zz9erVs7pWN9t9991nGD927JjDaxx3yElrUU/BvrV9goODM13Hfffdd4qKirL6u93b8F0VAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMCd7u/q7gncq2QNqUwd+8+7dFw6vlOK/V1KiJPkI4VGSEUrSpWaSvkKmT6qqS4ckY5skW6clxJvSUGhUnhRqXxDqUxt+2rVbCt9N0NShjMmdS3uB8fuB0+6F9LTpLiL1vMlqkuBwbbVirskbf5cOr5LSk6wzAcESeUaSNVbSRUaZV4rNVk6tEk6sM623gAAAAAAAAAAAAAAAAAAWOPv7gEAAK5z44L0xUt//EfLddtLRSpKPj53H5OcJP3+k7Rj3h//kTic6/Lly4bxQoWc/y8IChYsaBi/evWq03s7YuTIkYbxw4cPq2nTpoqNjTWlj7XrA8dcvGj8rzQKFCjg4kmy7/Dhw9qyZYuaNm16Vzx//vzq2LGj5s+ff1c8MDBQXbta/uu748eP67vvvsvWDEbX0ZuuoTdJT0+3mgsLCzO9X4kSJUypkxPea47y1tfO3T2s3SPXrl1zem9P4uvraxjPyLDtXz2eOHHCMB4aGqrg4GAlJSVlezZbFS5c2DB+48YNp/YdP368GjZsaBFPT0/Xk08+qStXrmRZIyAgwCJ2586dbM1jdF5gYGC2auVW9913n9XfDWvXrnXxNHAl1queI7Ofu2DBgjp//rwLpzGXtWdmZrnc8Dx1xL/+9S+rua+//tqFk3imlJQUw7i/v/d9XZaT9sg8fa2TU56J7tzTYp/Ce++jnLi/4q288R7yxpmzcuPGDT3yyCPaunVrpsd99913eueddzR06FCLnI+Pj2bNmqV7771Xly5dcmges+XE1wzZl1vXou5mtDdt6760Gfbt22c116xZMy1btszpMwQFBalevXqGuf379zu9vzPkpLWop2Df2j4vvviiihcvbpg7cuSIOnTooOTkZBdP5Tx8VwUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgPvUfsS+429clNZ/IJ3cY5z/daP0/adSvcekZk9J/oGOz2imq79La6ZI5w8b5/cslkrXkjqMkPLkta1mcJhU6B7pyknTxnQb7oe72Xs/WLsXftspvd/J+nlFK0mdx9g289Ix0u8/23BghpSeZj1dqIxt/ZLipS8HSrevWz8m5Y505Ic//lRuJkUNlIJC7z4m4Yb000rpp+V//G8AAAAAAAAAAAAAAAAAABzl6+4BAACulZEu/bJemt1f+qDLH/+h8zdvSQtel754SXr/CWnxKOnCEXdPmjv8+uuvhvF69eo5tW9QUJCqV69umDt48KBTezuicuXKqlq1qmEuJiZGsbGxpvUqVKiQabXwt7NnzxrGK1eu7OJJHDN9+nTDeK9evSxiHTp0UEREhEV8xowZ2e5vdB297Rp6i5s3b1rN5c+f3/R+lSpVMqVOTnmvOcJbX7vMFCtWTOHh4U6rX7BgQZUoUcIwd/ToUaf19TSBgYHKm9f4X0ImJCTYVOP8+fNWP5cULlw427PZw1qfGzduOK3nww8/rEGDBhnm3nrrLW3atCnbtTMyMlx6Hv4WFRVlGD948KDV5w1yBtarniOz509wcLALJzHf8ePHreZy6/PUUW3btjWMX758WT/88IOLp/E8vr7GX4t522eGnLZH5ulrnZz0THTXnhb7FN57H+XE/RVv5Y33kDfOnJXvv/9eW7dutenY119/XXv37jXMFS5cWLNnz3ZoFmfIia8Zsi+3rkXdydretK370mY4cOCA1TVvu3btXDJDixYtFBISYphzZI/ZnXLKWtSTsG9tOz8/Pw0bNswwl5GRod69e+vWrVsunsp5+K4KAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD8P/buO0zK6uwD8MMuy8LSmyBYUBFDFSOIIooFKRp7xRqNsURjYmwxdqPyxRajMRojtqAGK7GBBQUUBQULQVFEEVARqbK0hS3fH1yaIDPLltmdneW+r2uuuOc573N+M/MuM+/ZnQ0AAAAAAJA+9fIiOvUt+/yFX0Q8fH7E7CmlzysuinjniYinro5YV1CZhKn19ccRI85f/7+lmftBxOOXrb8fZdW+a+Wy1QTOh8S+Px/KKtG5UFwYsSY/+a1gRdn7F6wqvdcPt030zGtWtvU+fzti5dKy5/vk9Yh/3/DfrxfNiRj954i7ToqY+M+IVcvK3gsAAAAAAAAAAABKk5XuAACkz+rl638ZfNakiC+mRnz72fpf3Kb6fPjhhwnH27dvH9tss02Vrdu7d++oV69ewtpHH31UZetW1oABAxKO/+c//4lJkyaldK0+ffqktB/rTZ8+PeH4brvtFnXq1KnmNBX3+OOPx7JlyzYaHzBgQLRv336DsVNPPXWjeYWFhfHAAw9UeP1Ej2OmPYaZYunS5J8Iatu2bcrXS9W/PbXle60yMvW525TevXtXWe/dd989aW3mzJlVtm5NU9r5kejf/mSmTp2acLxXr17ljVRuO+ywQzRt2jRhrare62211Vbx0EMPJfw35tVXX43rrruuStal6g0ZMiTh+IsvvljNSahurlc3NnDgwDj88MOrfd1k/6ZHRKxZs6Yak6Te559/Xmp9c3s9raz69evHHnvskbA2duzYKCkpqeZENU+rVq0Sjq9cubKak1RObdwjq8nXOrXpNTFde1r2KTL3PKqt+yuZKBPPoUzMnEqFhYUxdOjQpO8zBg4cGBdccEG15SmLzf05q6lci6bepq5F0yXZa2t59qUrq6SkJMaPH5+w1qVLl+jater/UuTQoUOT1pJlq+lqy7VoTWLfuuz23XffaNOmTcLaCy+8EG+88UY1J6o6flYFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADptXX3iLr1yjZ37ZqIp6+JWLm07P2/eDfilb9VLFuqrfou4qmrI9auKtv8b2ZGTBtT9v5b7lShWDWK8yG5b2aWvXemnAvZOWWbV1RY/t5fTI149e8RIy+NuO/MiP+8GFG0rvx9AAAAAAAAAAAAoDR10x0AADZnEydOTFrbf//94/7776+Sdffbb7+E4wUFBfHuu++mbJ06deqkrFdExPbbb59w/O23307pOhER++yzT8p7EvHee+8lHG/SpEl07tw5Pvroo2pOVDFr1qyJhx9+OM4555wNxrOysuLkk0+OYcOGRURE27ZtY+DAgRsd/+yzz8aCBQsqvH6ixzHTHsNMsXRp8k9+7bLLLvHkk0+mbK1mzZpF7969U9KrtnyvVUamPnebMmjQoHj55ZerpHf//v0TjhcUFGwW58z3+vbtm7Q2e/bsMvd58cUXE74GHHTQQfHUU09VKFtZHXjggUlrqXyv973s7OwYOXJktGjRYqPaggUL4vjjj4+SkpIy9ysuLt5oLCenjJ/m/JF69Tb+xG+i/iTWrFmz2G233RLWRo8eXc1pSCbV113fq+3Xq+XRv3//uP7662PPPfeMefPmxbPPPhuFhRX49HgFbbnllklry5cvT1r75z//WeqxqXbooYfGdtttt9H4q6++GtOmTUt4TLLx721Or6ep0L1794SvfRERr732WjWnqZm22mqrhOOLFy+u5iSVUxv3yGrytU5tek1M156WfYrMPY9q6/7Kj1XVe+pUysRzKBMzp9qnn34av/nNb+Lee+9NWB82bFiMGzcupk6dWq25kvGc1SyuRcumKq5F0yXZ3nR59qVT4amnnopDDz00Ye3MM8+M8847r8rWbtasWRx99NEJa5988knMmDGjytauSrXlWrSmsG9dPscee2zS2l//+tdqTFK1/KwKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADSr8MuZZ/79mMRy+aXf43/vBjRZd+IbXuW/9hUev3BiFXLynfMBy9E9DyobHMbNCl3pBrH+ZAamXIurFtTtnlbdYvIzokoWle+/lOeLn8mAAAAAAAAAAAAKI+66Q4AAJuzefPmxX/+85/o3r37RrVf//rXcf/996d8zZycnDj77LMT1saNGxcrV64sd8916xL/tnxeXl65e5WmdevWCccXL16c0nXatWsXe+yxR0p7st7bb78dK1eujIYNG25UO+GEE+Kyyy5LQ6qKueeee+Kcc87ZaPzUU0+NYcOGRUTEiSeeGNnZ2QmPrYxkj2OmPYaZoLCwMBYsWBBt2rTZqNa7d++UrnXSSSclPF8qojZ9r1VUpj53mzJ06NC4+OKLo7i4OKV9c3Nz45RTTklYmzBhQqxZU8ZP0lWh3NzcKCgoqPJ1DjvssITjJSUlMX369DL3ee655+KWW25J2P+3v/1t5OfnVzTiJp100kkJxxcsWBAzZsxI+Xo33HBD9O3bd6Px4uLiOOGEE2LBggXl6rds2bKNxnJzcyMrK6vc536ifweXLl1arh6bswEDBiT892316tXx+uuvpyHR5q26rru+V1uuVytjjz32iOuuuy7222+/H8a23nrrOOuss+Kvf/1rteXo169fwvGFCxfGihUrkh534403VlWkhDp27BjbbbfdRuMjR46s8DXQ5vR6mgo777xz0trUqVOrMUnN1LJly9h1110T1j799NNqTlM5tXGPrCZf69S218R07GnZp8jc86i27a9U93vqVMrEcygTM1eF4cOHx5AhQ+LII4/cqJaTkxP/+te/omfPnmnJ9mOes5rBtWj5VMW16I+le2+6PPvSqTBq1KgoKCiI3NzcjWqnn356XH/99eXe8y2rCy64IOnr8siRI6tkzapWm65Fawr71uWT7N/zlStXxtixY6s5TdXxsyoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEi/LXYo27yiwoj3X6j4Ou88GbFtz4ofX1lrV0VMf7n8xy34LGJ1fkSDxpueW5Y5NZ3zoXS17VxYtaxs85q3izjsiohx90YsnlulkQAAAAAAAAAAAKBcstIdAAA2d6NGjUo4vssuu8R+++2X8vVOPPHEaNu2bcLa008/XaGeS5cuTTjesmXLCvVLpqSkJOF4w4YNU7rOxRdfHDk5OSntyXrr1q2LV155JWHt9NNPz6jHfdq0afHOO+9sNL7jjjvGHnvsERERp5566kb1uXPnxosvvliptZM9jpn2GGaKt956K+H4vvvuG61atUrJGjk5OfGb3/wmJb0iatf3WmVk4nO3Ke3atYuhQ4emvO8JJ5wQrVu3TlgbPXp0ytcrj0aNGsVFF10Uc+bMiaOOOqpK19p+++3jsMMOS1j78MMPY8mSJWXuNXPmzJg8efJG4y1atIiLLrqoohE36cgjj4zevXsnrD322GNRXFyc0vUGDx6c9P7ccMMNMXbs2HL3XLx4ccLxinzfJjqmPM/j5m7IkCEJx1977bUoKCio5jRU13XX/6oN16uVMXz48IT3c9iwYbHttttWW47jjjsu4fi7775bbRnSZXN5PU2VTp06JRwvLi6Ojz76qJrT1DynnHJKZGdnJ6xNnDixmtNUTm3cI6vp1zq16TUxHXta9inWy9TzqDbtr6TjPXUqZeI5lImZq8Ivf/nL+PLLLxPWOnbsGHfeeWc1J0rOc5Z+rkVrjpqyN13d+5nLly+PRx99NGGtQYMGceONN1bJuh06dIjf/e53CWuFhYXxj3/8o0rWrWq16Vq0prBvXXYNGjRIul/0+uuvx7p166o5UdXwsyoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKgZmrcv27z5n0SsWlbxdT6fErFmRcWPr6y5H0QUravYsYu+KNu8+o0q1r8mcT6UrradC0vnl33uDrtF/OKeiDMfjDjiqoh9z4jo+bOIDrtGNNsyok5W1eUEAAAAAAAAAACAZPz6GgCk2V133RVr165NWmvUKHW/Yd++ffv405/+lLC2ZMmS+Oc//1mhvkuWLEk4vssuu1SoXzKLFi1KON6xY8eUrdGxY8f45S9/mbJ+bOzBBx9MOL7FFlvEOeeck/L1Lrroorjwwgujbt26Ke99zz33JBw/7bTTolevXtGlS5eNasOHD4+SkpJKr53occzExzATvPHGGwnHc3Jy4pRTTknJGueff37ssMMOKen1vdr0vVZRmfrcbcqwYcOicePGKevXunXr+OMf/5iwVlBQUOH3B5XVsmXL+OMf/xjz5s2LG2+8Mdq0aRPDhg2Lhg0bVtmaf/nLXyI3Nzdh7fHHHy93v7/97W8Jx3/3u99F165dy91vU1q2bBk333xz0vrw4cNTul67du3in//8Z9SpU2ej2oQJE+Kqq66qUN/58xN/cnOnnXYqd69ExyTrz8YGDRqUcHzMmDHVnISI6rvu+l+14Xq1Mq6//vqE440aNYonnngi8vLyqjzDYYcdFv369UtYe/HFF6t8/Zqgtr+eptLWW2+dcPybb76JNWvWVHOammXrrbeOa665Jmn9+eefr8Y0lVdb98hq8rVObXtNTMeeln2KzD2PatP+SjreU6dSJp5DmZi5KixdujROOumkKC4uTlg/5ZRTYujQodWcKjHPWfq5Fk2/mrY3nQ633HJL0trJJ58chx12WErXy87OjgceeCDp+f3EE0/El19+mdI1q0NtuxaNiPj666/jyCOP3Og2bNiwastg37rsfvKTn0RWVuJfEf7www+rOU3V8LMqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACoGbJzIhq1KNvc+Z9UcrGSiK9nVLJHJSz8ouLHrl5etnl1cyu+Rk3gfNi02nYufDk9onBt+Y5p2iai4x4RvY+IGHhuxDHXR5xxf8QFz0b88r6Io6+P2O+siK77R7TcpmpyAwAAAAAAAAAAwPey0h0AADZ38+fPj0ceeSRhrVOnTnH//fenZJ2cnJx4/PHHo3Xr1gnrf/vb32LVqlUV6j1t2rSE49ttt1306NGjQj0TWbBgQcLx/v37R6NGjSrdv379+vHkk09GXl5epXuR3LPPPhvz5s1LWBs2bFh06dIlZWvttttucd1118VNN90U77//fuy1114p6x0R8eijj8aKFSs2Gj/22GPjnHPO2Wi8uLg47rvvvpSsnexxzLTHMBOMGzcuae3yyy+PNm3aVKp/7969449//GOleiRSm77XKipTn7tN2XrrreOf//xn1KlTp9K96tSpE48++mi0a9cuYX3kyJGxaNGiSq9TXtttt13MnTs3Lr/88mjWrNkP4x07doz77rsvJff9x2644Yb42c9+lrBWWFgYDz74YLl7PvzwwzFr1qyNxhs2bBjPP/980vdlFZGbmxvPPPNMdOjQIWH96aefjg8++CBl62VlZcXIkSOjVatWG9UWLlwYxx13XBQXF1eo95tvvplwfLfdditXn86dOyd8j5isPxvq2rVrtG/fPmFtzJgx1ZyGiOq77vpfteF6tTIeffTRmDlzZsJar1694umnn44GDRpU2fo77rhj3HXXXQlrhYWF8eijj1bZ2jVJbX49TbW2bdsmHP/qq6+qOUnNsvXWW8fYsWOT7h2988478Z///KeaU1VObd0jq8nXOrXtNTEde1r2KTL3PKpN+yvpeE+dSpl4DmVi5qoybty4uOmmm5LW77777thuu+2qMVFinrP0cy2aXjVxbzodpk+fXupz/dBDD0WvXr1Stt7dd98d/fv3T1hbt25dXHnllSlbq7rUxmvRiIgVK1bEU089tdGtuvbd7VuXT8uWLZPWPv3002pMUjX8rAoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGqOenlln7t8QeXXW/p15XtU1IrFFT927erU5ajJnA+bVtvOhcKCiM/eTk2vrOyI5u0itts1otdhEQddFPGLeyJ+eV9Ev5MjGrdKzToAAAAAAAAAAADwv7LSHQAAiLjssssiPz8/Ye2oo46Kf/3rX5Gbm1vh/s2bN4+XXnop9thjj4T1L7/8Mv70pz9VuP/EiROT1v74xz9WuO+PvfnmmwnH69evH5deemmleufl5cXjjz8ePXr0+GGsqKioUj1JrLCwMK699tqEtfr168eoUaNi2223rfQ6P/nJT+KZZ56JevXqRURE165dY8KECfHQQw9F69atK90/ImLlypXx6KOPbjTeuHHj+PnPf77R+JgxY+LLL79MydrJHsdMewwzwdSpU2PKlCkJa82aNYsHHnggcnJyKtS7e/fu8dxzz/3wGEdElJSUVKjXj9Wm77WKytTnriwOPfTQGDVqVDRs2LDCPfLy8uLJJ5+M/fffP2F97dq1cd1111W4f2XMnj073nnnnYS1Y445ptLvjf5XdnZ2DBs2rNT3Eg899FDMmTOn3L2LioriwgsvTFjbdtttY/z48dGpU6dy9/2xLbbYIsaMGRN9+/ZNWF+zZk384Q9/qPQ6/+u6666Lfv36bTReUlISJ510UsyfP7/CvefMmZPw9fKII44oV5/DDz884fjrr79eoVybm8GDBycc/+KLL+LTTz+t5jREVN91149l+vVqZRQXF8dpp50WxcXFCesDBw6MSZMmxXbbbZfytXfdddcYN25ctG3bNmH9gQceiG+++Sbl69ZEmfx6+vrrr0dJSUnC29NPP13pzD+Wl5f4L14sXbo05WtlilNOOSXeeeed2HHHHZPOueKKKzbZp7qfy02pzXtkNflapza9JqZjT8s+xXqZeB7Vpv2VdL2nTqVMPIcyMXNVufzyy5N+PzVp0iQeffTRyM7OruZUG/OcpZdr0fSqiXvT5ZHKa5eLLrooVq5cmbDWuHHjGDt2bAwaNKhcPX+sQYMGMWLEiDj99NOTzrnjjjsybj8yVdeibMy+dfk0adIkaa027Bf5WRUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADXRg+dE3HJw6m+vP5jue1a6evXLPnfNysqvt2ZF5XtU1LqCih9bUpK6HDWZ82HTauO5MPGfESXFVde/ebuIvsdHnD48Yq9TIurmVt1aAAAAAAAAAAAAbH6y0h0AAIj4+uuv49JLL01aP/bYY+P111+P7t27l7v33nvvHW+//Xbss88+Seecc845sWJFxT+lMHXq1Jg/f37C2iGHHBK333571K1bt8L9v/fWW29Ffn5+wtoll1wSRx11VIX6dujQISZOnBg/+9nPfhhbsWJFPPzwwxXqx6bdd9998c477ySs7bjjjjFp0qTYY489Ktz/oIMOijfffDPatGmzUe2kk06Kn/70pxXu/WP33HNPlcwti2SPY6Y9hpnglltuSVobPHhwPP3009GwYcNy9Rw6dGi8/vrrscUWW/wwtmjRohg3blxFY26kNn2vVVSmPndlccghh8SkSZNil112KfexPXv2jIkTJ8bhhx+edM6tt94an376aWUiVsqll14axcWJP7l3zDHHxH/+858YOHBgpdbo0aNHvPXWW/H73/8+6ZzFixeXWt+Uf//73/HYY48lrHXu3DmmTJkSp556amRlVWyL5sADD4z33nuv1Pd6v//97+Pjjz+uUP9EBg4cmPQxufHGG+PFF1+s9Br/+te/Nhrr27dv9OvXr0zHN2jQIH79619vNP7JJ5/EtGnTKp1vczBkyJCE42PGjKnmJHyvuq67fizTr1cra+LEiXHzzTcnrffo0SOmT58eV199deTl5VV6vVatWsVNN90UkydPjnbt2iWcs3jx4rj88ssrvVYmqY2vp1Whfv3Ef/Fi9erV1ZwkfXJycqJnz55x9dVXx8cffxwPPPBAwuuV7z366KMpee9S3WrbHtlLL720wdc19Vqntr0mpmNPyz5F5p5HtWV/JV3vqVMpE8+hTMxcVQoLC2Po0KGxcmXivz7Wp0+f+OMf/1jNqTbmOUs/16LpVVv2pivrq6++inPPPTdpvUmTJjF69Oj429/+Fi1btix3/wMOOCDefffdOOGEE5LO+eijj+Kyyy4rd+/qtrlci9YE9q3Lp1GjRklryd6PZAo/qwIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoKYqXBdRVBW3wnTfs9Jl5ZR9btHayq+3bk3le1RUSUn61s4UzofN06I5EZNGVv06ObkRewyNOOGWiIYtqn49AAAAAAAAAAAANg9Z6Q4AAKx35513xuOPP5603rt373j//ffjwQcfjL59+0ZWVvKX8Xr16sUBBxwQzz77bIwfPz46duyYdO6f//zneOaZZyqVvaioKO64446k9V//+tfx8ccfx0UXXRS77bZbtGjRIrKzsyu0zogRIxLWsrOz47HHHos77rgj2rRpU6Z+7dq1i7/85S/xySefRM+ePTeoXXPNNfH111+XOyNlU1xcHKecckqsWLEiYb1t27bx5ptvxsiRI6N79+5l7rv77rvH008/Hc8991w0b9484Zzhw4fHiy++WKHciUyZMiU++OCDTc775ptv4rnnnkvZuhH/fRwTyaTHMBM8/vjj8eGHHyatH3TQQTFr1qz4xS9+EY0bN046r27dunHQQQfFhAkT4pFHHommTZtuUL/66qvju+++S1nu2vS9VlGZ+twl8sorr8QXX3yxwVi3bt1i6tSp8eijj8aee+5Z6vuD7Ozs6NevXzzyyCPx7rvvbvTa978++OCDuOaaa1KUvGLeeuutuPLKK5PWd9xxx3jxxRdj2rRpcf7550fXrl3L1HfLLbeM4447Ll599dX44IMPonfv3knnFhcXx89//vNYuHBhufP/r9NPPz1mzJiRsNa4ceO477774pNPPokzzzwzttpqq032a9myZQwdOjSmTJkSzz//fLRr1y7p3CeffDL+8pe/VDj7j2255ZYxYsSIqFOnzka1N998My677LKUrHPbbbfFunXrNhq/9957k/6787/uvPPOaNu27Ubjt9xyS0ry1XZ5eXnRr1+/hLXRo0dXcxq+V13XXYlk8vVqKlx22WXx/PPPJ63n5eXFVVddFV9//XXcddddsffee0dubm6Z+7dq1SqOOuqoeOihh+LLL7+MCy+8MOlzV1xcHKeeemosWLCg3Pcj09Wm19Oqkux7r7Cw5v7llttuuy3uv//+Ct9GjBgR//73v2Ps2LExY8aMWLVqVbz33ntx1VVXxU477VTq2h988EGceeaZ1XRPU6u27ZH94Q9/iCVLlmwwVlOvdWrTa2I69rTsU6yXiedRbdlfSed76lTKxHMoEzNXlVmzZsV5552XtH7JJZfEvvvuW42JEvOcpZ9r0fSpTXvTlfXAAw/Egw8+mLRep06dOPvss2PevHnxwAMPxGGHHRatW7dOOLdu3brRrVu3OP/88+Pdd9+Nl156KX7yk58k7Z2fnx/HHntsrFmT+r+26Fo0M9m3Tq0rr7wynn322Wq7nXzyySnL7mdVAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQ4eqkoEUKelBDOB9qldcfjPjotepZq03HiJP+EtGwefWsBwAAAAAAAAAAQO1WN90BAID/Ovnkk2ObbbaJPn36JKxnZWXFySefHCeffHIsXrw43n777fjmm2/i22+/jezs7GjTpk20a9cudt9992jYsOEm13v22WfjggsuSEn2u+66K84999xo165dwvoOO+wQN954Y5l6XXfddXHFFVckrF177bVxyimnRF5e3ka1OnXqxLnnnhtnnXVWjB07Nt5+++2YNWtWLFu2LAoKCqJp06axxRZbRIcOHWLAgAHRo0ePqJPg0xnPPvts3HzzzTFs2LAy5aViZsyYEUOHDo1Ro0ZFdnZ2wjnHHHNMHHPMMTF37tx45ZVXYs6cOfHtt99Gfn5+ZGdnR8OGDaNNmzbxk5/8JPr16xft27cvdc3x48fHr371q5Tfl3vuuSfuvPPOUufcf//9UVRUlPK1Z8yYEUVFRRn/GNZ0RUVFcdRRR8WUKVOS/vvatm3buPfee+Ouu+6KN998M7744otYuHBhrFu3Lpo1axYdO3aM3r17R7NmzRIe//LLL8edd94ZAwYMSGn22vS9VhGZ/Nz92IoVK+LnP/95vPzyy5GTk/PDeJ06deK4446L4447LpYsWRKTJk3a4P1B69ato23btrH77rsnvQ//a8mSJXHYYYfFmjVrqvDelM31118f3bp1i+OOOy7pnO7du8ett94aEesfo1mzZsXcuXMjPz8/Vq1aFVlZWdG8efNo3rx5bL/99rHtttuWef3zzz8/nnvuuUrfj/z8/DjooINi/PjxsfXWWyec07Fjx7j77rsjImLWrFnx4YcfxqJFi2Lx4sVRVFQULVq0iFatWsWOO+4Y3bt3T/ge5sdeffXVOP744yud/3tZWVnx6KOPRuvWrTeqLVmyJI499tiUvdZ99dVX8fe//z3OPffcDcZ32mmneOONN+K0006LyZMnb3RcmzZt4vbbb49jjjlmo9qnn34aDz30UEry1Xb77LNP5ObmbjS+bt26ePXVV9OQiO9V13VXIpl8vVpZhYWFceSRR8bzzz8f+++/f9J5TZs2jbPOOivOOuusWLt2bUybNi2++OKLyM/P32juVVddFbm5ubHddtvFNttsU6YcJSUlcc4558Szzz5b4fuSyWrL62k6lJSUpDtCUkcffXRa1n3vvfdi8ODBCb8/M0Vt2iNbuHBhHH/88fHCCy9EVlbWBvejJl7r1KbXxHTsaW3u+xTfy7TzqDbtr6TzPXUqZdo5lKmZq8p9990XQ4YMiaOOOmqjWlZWVowYMSJ69OgRixcvTkO6//KcpZdr0fSqLXvTqfCLX/wiWrduHQceeGDSOQ0aNIhTTjklTjnllIiI+O6772LJkiWxatWqyM7OjsaNG0ebNm2ibt2y/ari2rVr49BDD43p06en5D78mGvRzGTfOrV22223al0vVd/PflYFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1U9G6ss+tW6/y69XNrXwPqo7zYfP23J8iFs6O2PvnEXWyqnatJq0jDr084l8XRxQXVe1aAAAAAAAAAAAA1G510x0AAPivNWvWxP777x9PPfVUDBw4sNS5LVu2jCFDhlR4rX/+859x2mmnRUlJSYV7/K9ly5bFiSeeGK+88kpkZVXdb9V/88038Zvf/Cb+8Y9/JJ1Tt27dGDRoUAwaNKjc/SdMmBAnnHBCZSJSDs8991wcd9xx8cgjj0ROTk7Sedtss02cdtpplVpr3Lhxceihh8batWsr1SeRESNGxM033xwNGjRIWC8pKSn1nK2s2vAYZoKPP/44zjjjjBgxYkTUqVMn6bycnJzo379/9O/fv1y9jz/++FTETKi2fK9VVCY/dz82fvz4OOOMM+K+++5LeF9atGgRBx54YIX7f/vttzFw4MD44osvKpEytY4//vhYuHBh/PrXv97k3EaNGkXPnj2jZ8+elVqzsLAwzj333Pj73/9eqT7/a/bs2dG/f/946aWXomPHjqXO7dix4ybnbMqjjz4ap556akq/F6+55pqE3x8lJSVx8sknx5dffpmytSIiLrzwwth7772jR48eG4x36dIlJk2aFDNmzIj3338/Fi5cGI0bN46OHTtG3759Izs7e6Nea9eujWOPPTYKCgpSmrG2Snad8eabb8aKFSuqOQ3/q7quuxLJ5OvVVCgoKIiDDjoobr/99jjjjDM2Ob9evXrRq1ev6NWrV8L6ph7DH8vPz49f/vKXMXLkyHIdV9vUhtdT0u+hhx6KX/3qV7Fy5cp0R6mU2rZH9uKLL8Z5550Xd9xxR42/1qlNr4np2tPa3PcpIjLzPKot+yvpfE+dSpl4DmVi5qr0y1/+MnbffffYaqutNqq1a9cu7r///jjkkEPSkOy/PGfp51o0vWrL3nRlFRUVxeGHHx4PPvhgHHfccWU6pmnTptG0adMKrbds2bI44ogj4rXXXqvQ8TVVbbkWTSf71kT4WRUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANRU69aUfW79RpVfr0Hjyveg6jgfmPxYxOfvROx1SkTH3at2ra26Ruzys4ip/67adQAAAAAAAAAAAKjdstIdAADY0MqVK+Oggw6KW265JYqLi1Pef82aNXHRRRfFySefHIWFhSnt/dprr8Xxxx8fa9aU4xMWFXDvvffGNddck/K+jz32WAwcODDy8/NT3pvknnjiidh3333j66+/rrI17rrrrjjggANi+fLlVdJ/+fLl8fjjjyetv/rqqzF79uwqWTuidjyGmeKRRx6J0047LdatW5eyntOnT4/99tsvFi1alLKeiWzu50kmP3c/9sADD8Rxxx0XBQUFKe37wQcfxJ577hkffPBBSvtWVklJSZx33nkxdOjQ+Pbbb6t8vS+++CL23Xff+Pvf/57y3rNnz45dd901nn766ZT3/t6qVavi/PPPj+OPPz6l58j+++8ff/jDHxLWbr311nj++edTttb3CgoK4ogjjog5c+YkrHfu3DmGDh0a5513Xpx66qmx1157RXZ29kbzCgsL4xe/+EW89957Kc9YWw0aNCjh+OjRo6s5CYlU13VXIpl8vZoKBQUFceaZZ8bQoUNj8eLF1bbuK6+8El27do2RI0dW25o1WSa/npJe06ZNi0GDBsUpp5wSK1euTHeclKhte2R33nlnnH766bF27dqU9q2Ka53a8pqYzj2tzX2fIiIzz6Pasr+SzvfUqZSJ51AmZq4qy5YtixNPPDHp43DwwQfHr371q2pOtTHPWfq5Fk2f2rQ3XVlr166NoUOHxiWXXFKl18lTp06N3XffPV577bUqW6O61cZr0XSxb42fVQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQM21dlXZ5zZrV/n1mrevfA+qjvOBiIiFsyOeujpi+BkREx+OWDQnoqSkatbqc2xEdk7V9AYAAAAAAAAAAGDzkJXuAADAxgoLC+PCCy+Mvn37xpQpU1LW9+WXX46ePXvGzTffnLKePzZy5Mjo169fTJw4scrWiIi4+uqr45hjjomlS5dWuteiRYvihBNOiGOPPTYKCgpSkI7ymjhxYnTr1i3uvvvuKC4uTlnfGTNmxD777BO/+tWvorCwMGV9E7nnnnsqVEuV2vAYZooHHngg9tprr5g5c2alez388MPRp0+fmD9/fgqSbdrmfp5k8nP3Y4899lj06tUrJe8T1qxZEzfccEP07t07Zs2alYJ0VeNf//pX7LTTTnHrrbfG8uXLU94/Pz8/rr/++ujSpUu88cYbKe//veXLl8cRRxwRhx9+eHz++ecp61tSUhKjRo2KLl26xG233ZayvhERbdq0iYcffjiysjbeRpo8eXL8/ve/T+l6/+uzzz6LPfbYIz744IMKHb9y5co49NBDY8SIESlOVnttt912seOOOyasjRkzpprTkEx1XXclksnXq6nyr3/9Kzp06BBXXnlllbwmfe/tt9+O4447Lg444ICYN29ela2TiTLx9ZT0yM/Pj0cffTQGDBgQO++8c7z00kvpjpRytW2P7L777ovdd989ZsyYUeleVX2tU1teE9O5p7W571NEZOZ5VFv2V9L5njqVMvEcysTMVWX8+PFx4403Jq3fcsst0a1bt2pMlJjnrGZwLZo+tWVvOhVuvPHG+OlPfxqjR49Oad8lS5bExRdfHH369IlPPvkkpb3TYXO4Fq1u9q3xsyoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKjZitZFrFhctrntflK5tepkVb4HVcv5wP9aPDdi4j8j7jsz4i9HRjx6ccTYuyPefSbis7cjFs+LKFxbuTUatYjosEtq8gIAAAAAAAAAALB5ykp3AAAgucmTJ0fv3r1jwIAB8fzzz8fateX/LfSVK1fGyJEjo3fv3jFw4MD45JNPqiDphqZOnRr9+vWLPfbYI+666654//33o6ioKOXrPP7449GlS5cYNmxYLFq0qNzHz507Ny6++OLYdttt45FHHkl5Pspn6dKlcfbZZ0enTp3izjvvjMWLy/gpnR8pKiqKcePGxWGHHRZdu3aN8ePHpzhpYhMnTowZM2ZsNL5o0aJ4+umnqyVDpj+GmWTy5MnRrVu3+PWvfx2zZ88u17ElJSUxYcKE2GuvveLEE0+MVatWVVHKxDb38ySTn7sfmz59evTp0yeGDh0a77//frmPX7BgQdx8883RoUOHuOyyy2LdunWpD5liy5YtiwsuuCDat28f5513XkyYMCEKCwsr1fP999+P888/P7bddtu4/PLLY/Xq1SlKW7pRo0bFjjvuGMcee2y8/PLLFX6vtGjRorjnnnuiS5cucfjhh8ecOXNSmrNOnTrxyCOPRJs2bTaqLV26NI455phKPwebMn/+/Ojdu3ecf/75sXTp0jIdU1JSEv/85z9jp512ihdeeKFK89U2gwcPTji+YMGC+OCDD6o5DaWpruuuZDL1ejVVVqxYEX/84x+jffv2cdJJJ8Xo0aNT8u/h559/Hvfee2/06dMn+vTpEyNHjkxB2torU15PqTrFxcWxevXqWLJkSXzyyScxYcKEuPfee+N3v/td7LHHHtGyZcs4/vjjY+zYsemOWqVq2x7Ze++9F926dYtTTz01Pv7443IfX93XOpn+mpjuPa3NfZ/ie5l2HtWW/ZV0v6dOpUw7hyIyM3NVuOKKK+Kdd95JWKtfv36MHDky6tevX82pEvOcpZ9r0fSpTXvTlfXRRx/FgQceGH369Inhw4fH8uXLK9zrfx+Dm266KWNeh12LVj/71ps3P6sCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDMsOSrss1rs0NEkzYVX2eH3SJyG1b8eKqH84FE1q6KmDctYuqoiFf+FvHklRHDfxlx66ERfzsx4pELI164ZX190Zzy9e7w06pIDAAAAAAAAAAAwOaiTklJSUmZJtapU9VZAIBNaNy4cQwePDh69eoVO++8c2y99dbRtGnTaNy4cZSUlMR3330X3333XXz++ecxbdq0ePvtt+Pll1+OgoKCdEePvLy8aNeuXTRr1iyaNWsWeXl5SefOnDkzPv7443L1r1evXvTv3z/69OkTffr0+WGt5s2bR926dWP58uWxbNmy+OSTT+K9996Ll156Kd5+++3K3i2qUHZ2duy5556x5557xi677BLbbbddtG3bNho0aBC5ublRVFQU+fn5kZ+fH1988UV89NFH8e6778aYMWNiyZIl6Y5fI3gMq8/uu+8eAwYMiN122y122GGHaNmyZeTl5UVRUVF89913sWTJkpg+fXpMnTo1Ro0aFXPmlPMTRFVocz9PauJz9+ijj8Zxxx230fioUaPi8MMPT3pcp06d4uCDD45ddtklunTpEi1btowmTZpEnTp14rvvvotly5bFp59+Gu+//35MmDAhXn/99SjjlkCN1qRJk9hnn32ia9eu0blz5+jUqVM0bdo0GjVqFI0bN47s7OwoKCiI1atXx8KFC+Prr7+Ojz76KN57770YN25czJ8/P913ISIiWrZsGXvttVf07ds3dtppp9huu+2iefPmkZeXF/Xq1YtVq1b98H5mxowZMX369Jg4cWK8+eabteJ5LKuGDRvGAQccEAcffHB06dIl2rRpE61atYoVK1bEggULYu7cuTFmzJh4/vnnY+7cuemOm5H+/e9/xyGHHLLR+EMPPRSnnHJKGhJRHlV93VWaTL5eTZW8vLzYZZddonfv3vHTn/402rVrF23atIktt9wyWrZsucHcL774Ij777LP48ssv48svv4wZM2bE+PHj48svv0xT+trB6ynVYeDAgfHiiy/+8PWm3qdXt9q4R9atW7c48MADo2fPntGlS5do1qxZNG3atMZe63hNrJzNfZ/ie5l2HtXE/ZWKSud76lTKtHMoUzNv7jxnNYNr0fSpLXvTlVWvXr3o06dP7L333tG1a9fYYYcdYosttoiGDRtGgwYNoqioKFauXBn5+fkxZ86c+Oyzz2Ly5Mkxfvz4+OKLL9Idnwxh35qaxM+qAAAAAAAAAAAAAACgdqjM3yXwt9qBZHr06BE9evSIiPX/znz++ecxadIkf98IAAAAAAAAAAAAoArVqVMnevXqFZ06dfrh972nTZsW06ZNS3MyBg4cmO4IAADlss+++0ROTk689eZbsWLFinTHAQAAAGqZnrv0jNatW8eMj2bEl19+me44AAAAQC01b968mDFjRrpjABnA32oHqoK/1Q4AAAAAAAAAAABQ/fyt9prF79RuPk78c0S7zmWbO/yMiMVzU59ht6Mj9vlF2eaOGx7x9uNlm9tki4izHirb3OdvjvjwleT1fc+I6H1E2Xq9/WTEuH+Ube6PHX9LxFZdyzb3uwURfz9l0/NS+TiUZsgFEd0P2PS8suSuiszOh/Wq43xI5bnwY1vuFHHSX8o294krIj5/p3z9q1PnfSMOujAiK3vTc+dOi/jXxVWfCQAAAAAAAACA9KpTp0707t07dtxxR79PC5RZWX7Hu2415AAAUiQ/Pz8ef/zxePzxMn6CpgZZtWpVzJo1q8r6r127Nl5++eV4+eWXq2wNqldRUVFMmDAhJkyYkO4oGctjWH0mTZoUkyZNSneMCtncz5NMfu5+bObMmXHLLbekO0a1W758eTzzzDPxzDPPpDtKpSxevDhGjRoVo0aNSneUGm3lypUepyqUk5MT++23X8La6NGjqzkNFVHV112lyeTr1VRZtWpVTJw4MSZOnLjB+DbbbBNz5szZYOyEE06IN998szrjbRa8nlIdsrKyNvi6uLg4TUkSq417ZNOnT4/p06enO0aZeU2snM19n+J7mXYe1ab9lXS+p06lTDuHIjIz8+bOc1YzuBZNn9qyN11Za9eujddffz1ef/31dEehlrJvTU3jZ1UAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJDYnPcieh9Rtrm7Hhrx0asR335WvjV2OThiq67lz0b1cz6kz9rVZZ/boEnV5UiFGa9FtNk+YrejNz03r2nV5wEAAAAAAAAAAKD2ykp3AAAAAAAg/fbcc89o1KjRRuPFxcXx8ssvpyERANQ8jRs33uDr/Pz8NCUBAACA2s++NQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQGaYNy1iXUHZ5mbXjTj8yoimbcvev+MeEfudUbFsVD/nQ/qsWVH2uVvuVHU56uZG9D4qYsA5lesz5/2yzavfuHLrAAAAAAAAAAAAsHnLSncAAAAAACD9Bg8enHB86tSpsXjx4mpOAwA1U/fu3Tf4etGiRWlKAgAAALWffWsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDMsK4g4uMJZZ/ftE3EiX+O6Lxv6fOycyL6nRxx2OXr/5vM4HxIn4KVZZ/bZd+I+o1Tu37dehG9Do8488GIfU+P+OnBETvsXvF+xUVlm1dSxnkAAAAAAAAAAACQSN10BwAAAAAA0m/w4MEJx8eMGVPNSQCgZmrdunWcfvrpG4y9++67aUoDAAAAtZ99awAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMzx3rMR3Q8o+/yGzSMOviRir5MjZk2OWDw3YtWy/9ba7hjRcY+IvKZVEpcq5nxIj8KCiOXfRjTZYtNz6zeOOOraiH9fH5G/qHLrZudE9Dwoos8xEY1abFg75PcRzwyL+Gxy+ft23rds8wpWlb83AAAAAAAAAAAAfK9uugMAAAAAAOnVtm3b2HnnnRPWxowZU81pAKDmadOmTTz//POx5ZZb/jC2evVqr5MAAABQRexbAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZJZvZkbMmhzRsU/5jmu2ZUSvw6okEmnkfEifr2ZENNmibHPbdY444/6Iz95e/5ytWRFRUpJ47syJEau/23AsOydi5yERux8X0ahF4uNy6kcceU3EjHER7zy1fp1Nadg8Yo+hET0Gle1+LJtftnkAAAAAAAAAAACQSN10BwAAAAAA0mvgwIEJx5ctWxaTJk2q5jQAULP06tUrnn766dhqq602GL/ttttiyZIlaUoFAAAAtZt9awAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDMVbdu3dh6662jQ4cO0bJly2jYsGE0aNAgIiJWr14dK1asiCVLlsTnn38e8+bNi+Li4jQnBgAAAKg97M0AAAAAAAAAAAAAAAAAAACQbuP+EbHdrhHZddOdhJrA+ZAeX06P6Ny/7POzcyI67bn+VppvZkas/m7Dsb1Pjeh9RNnW6bzP+tuqZRHfzIpYviCiYGVE4dqIOlkRdetFNGwe0XKbiC22j8jKLvt9+Prjss8FAAAAAAAAAACAH/OrjgAAAACwmRsyZEjC8VdeecX/ITwAm7Vf/vKXcccdd0Rubu4G42PGjIkrrrgiTakAAACg9rNvDQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJBZGjduHHvvvXfsueee0aNHj8jJySnTcQUFBTF16tSYMGFCvPnmm1FQUFDFSTd05plnRqdOnZLWb7nllvj666+rMdHG0pGxTZs2cfHFF1f4+JKSklizZk2sWrUqFixYEPPmzYuPPvoovvzyyxSmBAAAyEybuuaaNm1aPPjgg5Vep2XLlvGHP/whaX3t2rVx6aWXVnodaoZM3JuxL5OYfRkAAAAAAAAAAAAAAAAAAKA2WPJlxPjhEfudme4k1ATOh/SYMS5in9MjcnKrfq2poyJ+ekhEdt2yH5PXLGL7XqnNMeut1PYDAAAAAAAAAABg81KOX4MDAAAAAGqbOnXqxAEHHJCwNnr06GpOA7XP6tWrY8yYMRuMLVu2LD1hgHLJysqKU045JXJzN/wLFo899liceOKJUVRUlKZkAABQOteiQKazbw0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQOZo3bx7HHHNMHHjggVG/fv1yH5+bmxt9+/aNvn37xpIlS+LRRx+NF154IQoLC6sg7YaaNm0ahxxySNStWzfpnCFDhsTw4cOrPEsy6cpYv3796NatW0p7RkQsWrQoXn311XjhhRdi/vz5Ke8PAACQCTZ1zdWtW7f48MMPY8qUKZVap169eqWus3r16kr1p2bI1L0Z+zLJ2ZcBAAAAAAAAAAAAAAAAAABqiylPR7TrHPGTvdOdhJrA+VD91uRHfPhKRM+Dqn6t5d+uf477HF31ayUz94OIRXPStz4AAAAAAAAAAACZLyvdAQAAAACA9Ondu3e0bNkyYe3FF1+s5jRQ+yxcuDCGDBmywe2jjz5KdyygDIqLi+Poo4+Ob7/99oevL7/88jj22GNj3bp1aU4HAADJuRYFMp19awAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDMsO+++8Y//vGPOOKII6J+/fqV7teiRYs455xz4o477oitttoqBQlLN2DAgKhbt+4m52RlZVV5ltLWr+kZy6NVq1ZxzDHHxPDhw+O8886Lxo0bpzsSAABAjfS73/3ONROblMl7M5mw55EJGcvDvgwAAAAAAAAAAAAAAJurenkRP/v9+v8FAACg+j33p4hP30x93yVfRXw+JfV9qVrOh+o38eGIVcuqZ60J90d8NaN61vqxonURY+9Oz9oAAAAAAAAAAADUHpnx/0YEAAAAAFSJ+fPnx0EHHbTRbeDAgfHVV1+lOx4ApNX8+fNj6NCh8dVXX8UBBxwQ119/fbojAQAAQK1n3xoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgZsvKyorzzz8/fv/730fjxo1T3n/77bePv/71r7HrrrumvPf/Gjx48CbntGjRIvr06VOlOUqTCRkrIjs7Ow466KC4++67o1u3bumOAwAAUOO0bNkyfvOb36Q7BjVUbdibyYQ9j0zIWBH2ZQAAAAAAAAAAAAAA2JzUyYo4+PcRXfaJOOTS9V8DAABQvYqLIkZdF/H2E6nrueCziH9dHLFyaep6Uj2cD9Vv5ZKI526MKCmu+rVKiiOevjpiwayqX+vHXr4zYuHs6l8XAAAAAAAAAACA2sXHEAEAAABgMzZv3rx44YUXNrq9/PLL6Y4GADXCq6++Gttvv328+uqr6Y4CAAAAmwX71gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1V3Z2dlx22WUxePDgKl2nQYMGcdVVV0X37t2rpH/nzp1jm222KdPcqr6vyWRCxspq1apVDBs2LHr16pXuKAAAADXOXnvtFfvtt1+6Y1DD1Ia9mUzY88iEjJVlXwYAAAAAAAAAAAAAgM3BPqdH7LDb+v/evnfEfmekNw8AAMDmqqQ4Yty9EY9fFrF4XuX6TBkV8fDvIlYsjsjKKttxxUUVX5PUcz5Uvy/ejXjuxojCtVW/1qrvIh69OOKzt6t+rYiIonURY/4cMW1M9awHAAAAAAAAAABA7VbGX0cEAAAAAACAzdPatdXw1ysAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGq4s846K/r161cta+Xm5sZVV10VLVq0SHnvwYMHl3lu7969qyTDpmRCxlSoV69eXHnllbHtttumOwoAAECNc+6550br1q3THYMapDbszWTCnkcmZEwF+zIAAAAAAAAAAAAAANRmPQZF9D5iw7FdD4vY+cC0xAEAACAiZk+NuO/MiBduiZj3n4iSkrIdt3ZVxLQXI4afEfHq3RGFBevH6zUo2/Hfz6dmcT5UrxnjIh44J+LzKVW/1tpVEU9eGfHMsIgVS6punc+nrL9P016sujUAAAAAAAAAAADYvNRNdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKDm2n///eOQQw4p93FFRUXx3XffRVFRUeTl5UXDhg3LfGzjxo3j/PPPjyuuuKLc6yaTm5sb/fv3L/P87OzsGDBgQDz22GMpy7ApmZAxlXJzc+Oyyy6Ls846K4qLi9MdBwAAoMZo2LBhXHTRRXHxxRenOwo1QG3Ym8mEPY9MyJhK9mUAAAAAAAAAAAAAAKiNtu4RccC5iWsDzo5Y+lXE3A+qNxMAAADrlRRHTH95/a1hi4h2P4lou2NEXvOI+o0isutGrCuIKFgRsfTriPmfrL8Vrdu4V26jsq25dnVq7wOp43yoXkvmRTxxeUSrDhFd94/osEvEFttH1MmqmvU+Hh8xc2LETntG9Dw4on3niKzsyvUsWBnx2eSIaS9FzH0/JTEBAAAAAAAAAADgB3XTHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKiZGjduHGeddVaZ5paUlMSbb74Zb7zxRrz33nuxdOnSDepNmjSJzp07x/777x977bVXZGVlldpvt912i1133TWmTp1a4fz/q3///tGgQYNyHTN48OB47LHHUrJ+WWRCxnfeeSe+/vrrhLV69epF48aNY7vttov27duXqd+2224bgwYNitGjR6cyJgAAQMbbeeed4/DDD4+nn3463VFIo9qyN5MJex6ZkNG+DAAAAAAAAAAAAAAAJNdsy4hD/xCRnZO4np0TcdjlEQ+dF7FsfvVmAwAAMtuI89OdIOLtx9ffUm35txE3Dk59301ZuSTi0zfX3yqixVZlm5e/qGzzqutxGH3L+lsqVEVm58N61fE4pPJcKI9FX0SMHx4xPiLq1lv/2DVuFZHXfP3XdZPsq3yvrI9hRERxYcSM8etvuQ0jtu4R0b5LRPN262+NWkbk1F+/7vdKiiPWrl5/W7UsYtGciIVfRCz8PGLutIiideW/zwAAAAAAAAAAAFAWddMdAAAAAPivr7/+Oj7++OONxr/66qs0pAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANncnnXRSNGnSZJPzPv3007j99ttj5syZSecsX748Jk+eHJMnT44dd9wxLr/88mjbtm2pfY899tiYOnVquXMnMnjw4HIf0759++jWrVtMnz49JRk2JRMyjh49OiZOnLjJeVtttVUcccQRMXjw4MjOzi517uGHHx6jR49OVUQAAIBa47TTTot333035syZk+4opElt2ZvJhD2PTMhoXwYAAAAAAAAAAAAAABKrlxdx+FURec1Kn1e/ccTR10c8eG7E2lXVEg0AAIAUa9giolGLss1d/m3VZiH9nA8VV7g24tvP19+qWsHKiFlvrb/9WJ2siLo5ESUl6zMBAAAAAAAAAABAOmSlOwAAAADwXxdccEF07tx5o9u5556b7mgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwGamcePGMWTIkE3OmzZtWlx44YUxc+bMMvf+9NNP4+KLL45ly5YlrJeUlMS0adNi3LhxZe5Zmq222iq6du1aoWPL8hikQiZkLI8vv/wybr/99rjiiiti7dq1pc7ddtttY9ttt62mZAAAAJmjXr16cckll0R2dna6o5AGtWVvJhP2PDIhY3nYlwEAAAAAAAAAAAAAYHNSJyvi4N9HtO5QtvnN20UcfuX64wAAAMg8O+1V9rkLPqu6HNQMzofMV1Icsa4gorD0P48AAAAAAAAAAAAAVapuugMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1z8CBA6NevXqlzvnmm2/iiiuuiDVr1pS7/4IFC+Lvf/97XHLJJT+MzZo1K1599dUYP358LFq0qNw9kxk0aFCFj+3Xr1/ceeedsWrVqpTlSSQTMlbE1KlT4+GHH45TTz211HmdO3eOOXPmVFMqAACAzLHDDjvESSedFA888EC6o/wgNzc3dtlll+jcuXN06NAhmjdvHnl5eRERsWbNmvjuu+9i7ty5MXPmzJgyZUrk5+dXaJ06deqUujdRUFCwwdf169eP3XbbLXbZZZfYeuuto0mTJlG3bt3Iz8+P5cuXxxdffBFTp06N6dOnR2FhYYUyVafasjeTCXsemZCxIuzLAAAAAAAAAAAAAACwOdjn9IgddivfMdv2jBjwq4iX/1olkQAAAEggr1lEr8MjJjwQESUV61EnK2KXg8o+/5tPKrYOVc/5AAAAAAAAAAAAANQkddMdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqHn233//Tc65/fbbY82aNRVeY9y4cTF48OD4z3/+E6+99lp8+eWXFe6VTFZWVgwYMCBpfcmSJbFmzZpo165dwnr9+vVjn332iRdeeCHl2b6XCRkrY/To0XHyySdHdnZ20jnbbbddNSYCAADILMccc0xMnjw5ZsyYkdYcHTp0iKOOOir69+8f9erVK3Vur169IiKiqKgopkyZEk888URMmzatXOt16tQpbr/99oS1hQsXxoknnhgR66+rjz322Dj66KOjYcOGSfvttttuccwxx8TChQtjxIgR8dJLL0VxcXG5MlWn2rA3kwl7HpmQsTLsywAAAAAAAAAAAAAAUJv1GBTR+4gNxwpWRiz4LGKbHv8dmzUpYsudIho2/+/YLj+LWDQn4r1nqycrAADA5myrbhGH/CGiUYuIOlkR44dXrM/ux0a03KZsc5d+vf5GzeN8AAAAAAAAAAAAAGqauukOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1CxNmzaN7bffvtQ5H3/8cUydOrVS6xQXF8fFF19cqR6b0qdPn2jRokXS+rhx42LVqlVx4oknJp0zZMiQeOGFF6oiXkRkRsbK+O6772LJkiXRunXrpHOaNGlSjYkAAAAyS3Z2dlx88cVx9tlnx5o1a6p9/by8vDjttNPioIMOiqysrHIdm52dHX369Ik+ffrEm2++GXfeeWcsWrQoZdm22WabuOSSS6Jjx45lPqZ169Zx/vnnx9577x3XXXddrFq1KmV5UqW27M1kwp5HJmSsDPsyAAAAAAAAAAAAAADUVlv3iDjg3A3HiosinhkW0XH3iG16/Hc8f1HEW49GDL0pom69/47vf1bE0q8jvqjcRzSABNq3bx+/+MUvEtZKSkri+uuvj+Li4mpOBQBAOux2dMTeP4/Iyl7/dZ+jI7LrRrz2j4iScrwl/OkhEf1OLvv8mRPLFZNq4nwAAAAAAAAAAAAAaqK66Q4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADULDvvvHPUqVOn1DkvvfRSNaWpnEGDBpVaHzt2bKxevTpOPPHEpHM6deoU2223XcyePTvV8SIiMzJWVn5+frRu3TppPS8vrxrTAAAAZJ527drFWWedFbfddlu1rrvlllvGtddeG9tss02le/Xt2ze6dOkS1157bXz44YcpyXbTTTdFs2bNKnT8rrvuGrfcckv89re/jYKCgkrnSaXasjeTCXsemZCxsuzLAAAAAAAAAAAAAABQ2zTbMuLQP0Rk52w4Pu7eiNlTIjruvvEx8z+JGP3niJ9dHPH9xzaystf3GXF+xOK5VZ8bNidHHnlkXHPNNQlr77//fvzxj3+s5kQAAFS33EYRB12Y+Bqt1+ERHX4aMfnxiFlvRRSsTNwjKzuifdeIvkMjtt2l7GuXlER88ELFclM1nA8AAAAAAAAAAABATVY33QEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICaZYcddtjknEmTJlVDkspp3rx57Lbbbknr8+bNi1mzZkVExMyZM6NTp05J5w4ePDjuuuuuzTIjAAAAVW/NmjWxZs2aaNasWdI5Q4YMibfeeismT55cLZnatGkTt9xyS7Rs2TJlPZs1axb/93//F5deemlMnz69wn3q168fw4YNK/XxKovtt98+zjnnnLj11lsr1SfVasPeTCbseWRCRgAAAAAAAAAAAAAAYEP18iIOvyoir9mG49PGREx5uvRjZ7wW0WrbiD2O++9YbsOII66OGHF+xOrvUhwWNmNDhgxJWhszZkw1JgEAIB3adIw49PKIZm2Tz2m1bcRBF0aUFEcs/Tpi+bcRa1dHFBVG5ORG5DVdP6deXvnXnzE+Ytn8iucntZwPAAAAAAAAAAAAQE2Xle4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAzbLVVluVWl+2bFksXry4mtJU3IABAyI7Oztp/ZVXXvnhv8eOHVtqr/322y9ycnJSlu17mZAxFRo3blxqvaCgoJqSAAAA1EwFBQVx2223bXLe+eefH02bNq3yPLm5uXHddddFy5YtU967Xr16cc0110SbNm0q3KNx48ax5ZZbpiTPoEGDolu3binplSq1YW8mE/Y8MiFjKtiXAQAAAAAAAAAAAACgtqiTFXHw7yNad9hwfN5/Il76a9l6vP5AxMyJG441bxdx6GURWXVTkRLIzc2N/v37J62PGTOmGtMAAFDdug+MOOHWiGZtyza/TlZEi60iOvw0otOeEZ37R3TcPaJd54h6eeVff92a9dd+1AzOBwAAAAAAAAAAACAT+HghAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwgXbt2pVa//zzz6spSeUMHjw4aa2kpCRee+21H74eP358nHHGGZGdnZ1wfpMmTWKPPfaICRMmbHYZK6tRo0bRokWLUud899131ZQGAACg5nrrrbfixRdfjEGDBiWd07x58/jtb38b11xzTZVmOfXUU2Obbbapsv6NGjWKCy64IC6++OIqW6M8jjzyyJg+fXq6Y/ygNuzNZMKeRyZkrCz7MgAAAAAAAAAAAAAA1CZ7nhixw24bji2bHzHquojiwrL3ee7GiONviWjb8b9j2/SI2O+MiFf+lpqsNd2xxx4bTZs2TWnPKVOmxLvvvluhY/v27Rs/+9nPok+fPtGxY8do1apVNGjQINatWxcrVqyIL7/8Mj788MMYO3ZsPPPMM7Fw4cJyr9G0adP4xS9+EQcffHB07949mjVrFmvXro158+bFG2+8Effff3+88cYbFcofEdGgQYM46aSTktZHjBgRq1atqnD/iIj9998/XnnllaT17777Ljp06BDLli0rd+9bb701zj///KT1c845J/72t7J9g+y9997RoEGDhLUVK1bExIkTf/g6U+4TAABlV1wUUbde+tYfNzziu2/Stz4bcj4AAAAAAAAAAAAAmaBuugMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1S15eXqn1ZcuWVU+QSujatWtstdVWSesfffRRLFiw4Ievly5dGh988EH89Kc/TXrMkCFDYsKECZtVxlTYb7/9Ijs7u9Q5X331VTWlAQAAqNnuuuuu2HnnnaNt27ZJ5/Tt2zcOOOCAePnll6skQ7t27eKQQw7Z5Lz8/PwYPXp0vPvuu7Fw4cIoLi6O5s2bR/fu3ePAAw+MNm3alHr8zjvvHHvssUe89dZbKck9ZcqUeOmll2Lu3LmxZs2aaNasWey8885x5JFHRpMmTUo9dvfdd49GjRrFihUrUpKlsjJ9byYT9jwyIWMq2JcBAAAAAAAAAAAAAKA26TF4w68LVkY8dU3E6u/K16ewIOKpqyNOui2icav/jvc8KOKVv1U2ZWa46aabYuutt05pz6uuuirefffdch1zzDHHxNVXXx2dO3dOWK9Xr160aNEiWrRoET169IihQ4dGQUFBPPDAA3HppZfG0qVLy7TOkCFDYsSIEdGiRYsNxhs0aBCdOnWKTp06xWmnnRYjR46MX/ziF7Fy5cpy3Y+IiFtuuSXOPvvshLXhw4fHPffcU+6ePzZ27Nh4/vnn46CDDkpYb9q0aVxyySVx6aWXlqtv+/bt41e/+lXS+owZM+Lvf/97mfsNGTIkaW3s2LFRWFi4wdeZcJ8AACi7D8dGbLdrRJf9qn/taS9GvPds9a9Lcs4HAAAAAAAAAAAAIBPUTXcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgZmnQoEGp9ZUrV5a5V7t27eKUU06pcJbPPvssHnvssXIfN3jw4FLrY8eOTTj205/+NOkxu+yyS2yxxRbx7bffljtPIpmQsbI6deoUP//5zzc576OPPqr6MAAAABlg9erVceONN8bNN98cWVlZSeedffbZMW3atFiwYEHKMxxzzDGRnZ1d6px33nkn/u///i9WrFixwfjXX38dH374YTzxxBNx5plnxiGHHFJqn+OOOy7eeuutSuVds2ZN3HrrrTF+/PgNxufPnx8zZsyIl156KW6++eZo37590h5ZWVnRuXPneOeddyqVJVUyfW8mE/Y8MiFjZdmXAQAAAAAAAAAAAACgtlm5NKJRi/X/XVwU8dxNEYu+qFivFYsiRv0x4rg/ReTUXz+29OuUxMwIjRo1Svv6I0aMiEMPPbTcx+bm5saZZ54ZBx98cBxyyCExderUUuefddZZ8be//S3q1Kmzyd7HHntsdOvWLfr16xfLli0rc6YhQ4bE2WefnbD22WefxW9+85sy99qUCy+8MAYNGhR169ZNWD/vvPPiz3/+c7k+43LVVVdFbm5u0voFF1wQRUVFZe5X2md3xowZs9FYJtwnAADK54VbInIbReywW/Wt+dGrES/+pfrWo+ycDwAAAAAAAAAAAEBNl/z/LQwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANgs5ebmllpfvXp1mXvtsMMOsc8++1T41qNHj3Lnb9CgQey9995J64WFhTFhwoSNxidOnBgFBQVJj6tTp04MGjSo3HkyNWNlNG3aNE4++eS4+eabo2HDhqXOXbhwYXz66afVlAwAAKDm+/DDD+OJJ54odU7Dhg3joosuijp16qR07aysrOjXr1+pc2bMmBFXXXVVrFixIumcwsLCuPPOO+OVV14ptddPfvKTaNu2bYWyfu/222+P8ePHJ60vWbIkbrvttk326dKlS6VypFIm781kwp5HJmSsDPsyAAAAAAAAAAAAAADUVs/+X8QX70YsmBXx7+sjPptUuX7zP4l46uqIb2au7/v0tSmJmREaNWqUtrWbNGkS48ePj0MPPbRSfdq1axevvPJKdO7cOemcXXfdNW6//fZyfQ6ra9euMXz48DLPb9WqVdx///0Ja0VFRXHiiSfGypUry9xvUz7++OO45557ktbz8vLisssuK3O/jh07xqmnnpq0/vLLL8fo0aPL3G/rrbcu9Tl58cUXNxqr6fcJAIDyKy5af4313rPVs9Yb/4x47saIkuKqX4/ycz4AAAAAAAAAAAAANV3ddAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABqlqysrFLrJSUlZe615ZZbVjZOufXv3z/q16+ftP72229Hfn7+RuOrV6+OSZMmRf/+/ZMeO3DgwBgxYkS5HoNMzZhI//79o0OHDglrubm50aRJk+jQoUN06tQpsrOzy9TzhRdeqJKsAAAAmezBBx+MXr16xfbbb590Tvfu3ePII4+MJ554ImXrdu3aNRo3blzqnL/+9a9RVFRUpn533XVX9OvXr9Rr4N133z1GjRpVnpg/eP/992Ps2LGbnDdt2rSYO3dubLPNNknnNG/evMzr/uUvf9nk/smmvPnmm/Hoo48mrGXy3kwm7HlkQsZE7MsAAAAAAAAAAAAAALC5WzIv4rE/pLbnnPcjHjovtT1rupycnMjJyUnb+g888ED89Kc/TUmvZs2axSOPPBK9evVK+Jmn4cOHJ7yvM2fOjDfeeCNatmwZQ4YMiXr16m1QP+KII+LQQw+Nf//735vMcO+990abNm0S1oYNGxaTJk0q470puyuvvDJOOOGEaNq0acL6mWeeGTfddFN8+eWXm+x17bXXRt26dRPWioqK4ne/+125sg0aNChp7dNPP43Zs2cnrNXk+wQAQMUUF0a8fGfEF+9F7HtGRLO2qV/j6xkRY++OmP9J6nuTWs4HAAAAAAAAAAAAoCZL/GkkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAFGjfvn21rzl48OBS66+++mrS2muvvRb9+/dPWt9iiy1il112iXfffbfC+SIyI2Mipa1bEYsXL45Ro0altCcAAEBtUFhYGP/3f/8Xf/3rX6NevXpJ5/385z+PqVOnxuzZs1Oy7o477lhq/bPPPotZs2aVud+KFSvizTffjP3226/Ca5ZmzJgxZZ47ffr02GabbZLWGzduXOZeO+64Y2RnZ5d5fiKfffZZpY4vq+rem8mEPY9MyJiIfRkAAAAAAAAAAAAAACAVGjVqlLa1jz766Dj88MNT2rNnz54xdOjQGDFixAbjffv2jZ133nmj+U899VQcffTRUVxcHBERffr0iQkTJmz0Oa5zzjkn/v3vf5e69mmnnRaHHnpowtqUKVPi6quvLsc9KbvFixfHddddFzfddFPCem5ublx11VXxy1/+stQ+3bt3j+OOOy5pffjw4TF9+vRyZSvtszulfR6sJt8nAAAq59M3Iz5/J6LrfhE9hkS0+0nl+hUVRnzxbsS7z0TMnpKajFQf5wMAAAAAAAAAAABQE2WlOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCzFBUVlVqvW7dumXttueWWlY1TLttss0107tw5aX3lypUxadKkpPV33nknli9fXuoaQ4YMqXC+iMzIWB2Ki4vjz3/+c6xatSrdUQAAAGqkOXPmxAMPPFDqnJycnLj44ovLda1emg4dOpRa//DDD8vdc1PHbLPNNuXu+b3//Oc/ZZ77zTfflFrPy8urcI5Uy9S9mUzY88iEjNXBvgwAAAAAAAAAAAAAAGy+GjVqlLT27bffxjfffFOh24oVK0pdNycnJ+64445S5/znP/+Js88+O3r27Bnt27ePnXbaKQYOHBh33nlnFBQUbDR/3bp18dRTT8Vnn322UW3w4MEJ17jwwgujuLj4h68nT54cI0eO3GjePvvsE/Xq1Uuadfvtt4+//OUvCWurVq2K448/fpOfE6qM22+/PWbPnp20/vOf/zx22GGHUntcf/31UadOnYS1/Pz8uOKKK8qVKTs7OwYMGJC0Pnr06FKPr4n3CQCA1ChaFzHtxYgRv424++SI52+KeP+FiLkfRCz/NmLtmoiSko2PW7cmYslXEV+8F/H24xGj/hhxxzERT14ZMXtKtd8NUsT5AAAAAAAAAAAAANQ0qfl/AAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGqNtWvXRoMGDZLW8/LyytyrXbt2qYhUZoMGDSq1/sYbb8S6deuS1gsLC+ONN96IAw88MOmcPfbYI5o0aRLLly+vtRmrWklJSdx1113xzjvvpDsKAABAjfbkk09Gnz59Yuedd046Z/vtt49TTjklhg8fXun1mjVrVmr966+/LnfPTR2zqTWTKSkpiaVLl5Z5/urVqyu0Tjpk6t5MJux5ZELGqmZfBgAAAAAAAAAAAAAANm8NGzZMWmvXrl0UFRVVybqHHnpotGnTJmn973//e5x77rlRWFi4wfjMmTPj5ZdfjnvvvTfGjRsXTZs2jVmzZsU//vGPeOCBB+Lbb79N2K9Lly4bjc2fPz9mz5690fjrr78eJ5100gZjOTk5scMOO8SMGTM2mp+VlRUPP/xwNGrUKOHaF1xwQXz66adJ72sqrF27Ni655JJ47LHHEtbr1q0b1157bZxwwgkJ63369ImDDz44af8bbrgh6WObzO677x5NmzZNWCsoKIhx48aVenxNvE8AAKTe8m8jPhy7/vZjdetF1KkTUVISUbi2+rNR/ZwPAAAAAAAAAAAAQE2Qle4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAzbJ69epS63l5eWXqk5OTE61atUpFpDLJzs6OAQMGlDpn7Nixm+yzqTk5OTmx3377lSvb9zIhY1VbsWJFDBs2LJ555pl0RwEAAMgIN910U6xcubLUOUcddVR069at0ms1aNCg1PqmclTkmLLuM/zYqlWroqioqMzzS0pKKrROOmTi3kwm7HlkQsaqZl8GAAAAAAAAAAAAAABo1KhRwvGCgoJyfV6nvE4//fSktddeey3OPvvsKCwsTDrn/fffj+OPPz723Xff2HHHHePGG2+Mb7/9Nun8Zs2abTSWbH6y8RYtWiQc/8Mf/hC77757wtoLL7wQd999d9JcqfT444/Hm2++mbR+3HHHRdeuXRPWhg0blvS4OXPmxJ///Ody5xk8eHDS2uuvv77Jz01F1Lz7BABA9SpcG7GuYP3/gvMBAAAAAAAAAAAAqC510x0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACoWZYsWRJt27ZNWm/dunWZ+uTk5MQ//vGPUud069Yt+vbtW658yey+++7RrFmzpPWVK1fGmjVromPHjqX2Wbt2beTn50fjxo2TzhkyZEiMGjWqVmasSpMnT47bbrstlixZku4oAAAAGWPhwoVx5513xsUXX5x0TlZWVlx00UVx7bXXVmqtnJycUuvr1q0rd8+1a9eWWq9Xr165e0ZElJSUVOi4TJCJezOZsOeRCRmrkn0ZAAAAAAAAAAAAAAAgIqJRo0YJx1euXFllazZo0CAGDBiQtH7RRReV6fNCL7zwQpnXzM7O3mgs2eejko0n6tGrV6+46qqrEs5fuHBhnHrqqWXOmAq/+93vYtKkSQlrWVlZcd1118Xhhx++wfh+++0X++67b9Kel1xySRQUFJQ7y+DBg5PWRo8eXeY+Nek+AQAAAAAAAAAAAAAAALVf3XQHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAapbFixeXWt9+++0jKysriouLS523atWqePLJJ0uds3bt2ujbt2+5MyYyePDgUusNGzaM22+/PSVrdejQIXbaaaf45JNPynVcJmRMtTVr1sSrr74azz77bHz++edpzQIAAJCpxo4dG3379o1+/folndO2bds466yzqjEVVSUT92YyYc8jEzKmmn0ZAAAAAAAAAAAAAADgxxo1apRwfMWKFVW2Zs+ePSM7OzthbcaMGTF16tQqW/t/ZWVllWv8xxo0aBAPP/xw1K1bN2H99NNPj2+//bbC+Spi8uTJ8a9//SuOO+64hPXDDjssevXqFVOmTPlhbNiwYaX2GzlyZLlztGrVKnbdddek9RdffLHMvWrKfQIAAAAAAAAAAAAAAAA2D4k/MQYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGy25syZE3vttVfSev369WPbbbeN2bNnV2Oq0rVo0SJ23XXXal1z8ODB8cknn5R5fiZk3JTFixfHqlWrEtaKiooiPz8/VqxYEcuXL49Zs2bFJ598Ep999lkUFhamLAMAAMDm6rbbbosuXbpEixYtks7p0aNHpdZYu3ZtqfV69eqVu+emjikoKCh3z3SbN29eZGdnV6rH0qVLk9YycW+mpu952JcBAAAAAAAAAAAAAABYr1GjRgnHV65cWWVrlva5jpdffrlK1kz0OYxk972sj8mtt94anTp1Sjh3+PDh8cwzz5QzZWpccsklcdhhh0X9+vUT1q+//voYNGhQREQccsghsdtuuyXt9dvf/rZCGQ444ICoU6dOwtpXX30VH374Ybn61YT7BAAAAAAAAAAAAAAAAGwe6qY7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAULPMmjVrk3P222+/GD58eDWkKZuBAwdGdnZ2ta65zz77xN133x0FBQVlmp8JGTflzjvvjIkTJ6akFwAAAOWTn58ft9xyS1x//fVVtsbq1atLrTds2LDcPRs1alRqfdWqVeXumW5nnnlmlfbPxL2Zmr7nYV8GAAAAAAAAAAAAAABgvWSf91mxYsVGY1lZWdGkSZPIycmJ/Pz8WLNmTYXW7Nq1a9Lahx9+uMHXTZs2jQMPPDB22mmn2HLLLaNRo0axYsWK+Oyzz2Ly5Mnx+uuvR3Fx8SbXnDdv3kZjHTp0iNzc3I0+79GlS5eEPebOnfvDfx944IFx1llnJZz32WefxW9+85tNZqoqc+fOjb/85S9xySWXJKwPHDgw9tprr3jjjTdK/XzayJEjY9KkSRXKMGTIkKS1MWPGlLtfTbhPAAAAAAAAAAAAAAAAwOYhK90BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAmmX69OlRXFxc6pwBAwZETk5ONSXatEGDBlX7mnl5ebHXXnuVeX4mZAQAAKBmmzJlSjz33HNV1n/p0qWl1tu3b1/unps6ZlNrbo4ycW+mutmXAQAAAAAAAAAAAAAAqJhGjRolHF+5cmXUrVs3DjvssHj44Yfj008/jcLCwli6dGl8++23sXr16li4cGGMHj06zjzzzGjYsGGZ12zWrFnS2ty5cyMiYvvtt48nn3wyFi5cGI888khcddVVccYZZ8Txxx8fZ5xxRvzpT3+KcePGxddffx0XX3xx5ObmlrrmxIkTNxqrV69eHH/88RuM5eTkxNChQzeaO3v27Fi4cGFERLRq1Sruu+++hOsUFRXFiSeeGCtXriw1T1W7/vrrf8ibyA033BBDhw6Nbt26JawXFBTEJZdcUuH1S/v8zpgxYyrUM933CQAAAAAAAAAAAAAAANg8ZKU7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAULPk5+fHzJkzS53TokWLOPnkk6spUem6d+8e7dq1S8vagwcPLtO8TMgIAABAZrjnnnviq6++qpLes2fPLrXerVu3cvfc1DFz5swpd8/aLhP3ZtLBvgwAAAAAAAAAAAAAAED5NWzYMOH4tttuGx9//HE8/fTTcfzxx0fHjh2jTp06G8xp1apVDB48OO6+++6YO3dunHPOOWVas2nTpklr+fn58atf/So++uijOOKIIyInJ6fUXm3atIk//elP8f7770fXrl2TznvmmWdixYoVG43fcccd8etf/zq6d+8e++yzT7zwwgvRsWPHjeY9/PDDP/z38OHDo02bNgnXueGGG2LSpEmlZq4O+fn5ccUVVySt9+vXL/72t78lrf/5z3+u8Ge9evbsGVtssUXCWlFRUbzyyisV6pvO+wQAAAAAAAAAAAAAAABsPrLSHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKh5xo4du8k5Rx11VOyxxx7VkKZ0gwcPTtva3bt3j6222mqT8zIhIwAAAJmhoKAg/vSnP0VRUVHKe8+cObPUeocOHaJz585l7te0adNN7h188sknZe63ObE3s2n2ZQAAAAAAAAAAAAAAAMqvcePGCce322672GGHHcrcp0WLFvHXv/41nn322cjLyyt1btOmTZPWzj777LjzzjsjNze3zGtHRPzkJz+JiRMnRu/evRPWv/vuuxg2bNhG4w0bNozbb789pk2bFq+99loMGDBgoznz58+PP//5zxER8Ytf/CIOOeSQhGu88847cc0115Qrd1X6xz/+ER999FHSerLn4dtvv40bbrihwuuW9vmdyZMnx7JlyyrcO133CQAAAAAAAAAAAAAAANh81E13AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoOZ59dVX47TTTosGDRoknZOVlRVXXnll3HvvvfH0009HcXFxudepU6dOZWJGXl5e7LXXXqXOmTNnTqxatarC/bfddttS5wwaNCiGDx+e0RkBAADILJ988kn861//ihNOOCGlfT/++ONYtmxZNGvWLOmc8847L84777xYt27dJvudd955Ua9evaT1kpKSmDRpUkWi1nq1ZW8m3Xse9mUAAAAAAAAAAAAAAAA21KhRo5T2+9nPfhb//ve/Y8iQIVFYWJhwTmmfMarMZ6SaNm0azz77bPTs2TO++eabjerDhg2LAQMGxL777lvmnsXFxXHCCSfEkiVLYocddojbbrst4bxVq1bFCSecEEVFRRER0bJlyzj88MOjb9++0a5du6hbt24sXrw43nvvvRg1alR8/PHHFbqP5VFcXBwXXHBBjB49ulzHXXHFFZGfn1/hdYcMGZK0NmbMmAr3jUjffQIAAAAAAAAAAAAAAAA2H3XTHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKh5VqxYEaNGjYqhQ4eWOi8rKyvOOOOMOPjgg+OJJ56IqVOnxvz580s9plWrVtG5c+fYY489Ys8996xUzn333Tdyc3OT1teuXRu//e1vY9WqVRXqn5eXFyNHjox69eolnXPAAQfE/fffH8XFxRmbEQAAgMwzYsSI6N27d3Tq1CllPUtKSuK1116Lww8/POmc7bffPoYNGxY33HBDLFmyJOGc+vXrx3nnnRf9+vUrdb1p06bF4sWLK5W5tqoNezM1Yc/DvgwAAAAAAAAAAAAAAMCGGjVqlPKeAwYMiGuvvTb+8Ic/pLz3prRp0yb++te/xlFHHbVRraSkJA499NAYMWJEHHLIIZvs9d1338WJJ54Yr732WmRlZcWIESOSPl6/+93v4tNPP406derE5ZdfHpdeemk0aNBgo3nHHHNMDBs2LJ566qk4/fT/Z+fOw7ye9//xP2Zpn/bVVqINJdmKUKdQIRwfiXCOQo6IiCzHciwh2dOxZMsSle2UVJbsUmSJLIeUJIqWaZtqmpnfH+d3zvc4856a5T0zLbfbdbku83g8X4/H/f16z/Ke93U1Z8Xy5cuL/iCLYMqUKfHKK6/EkUceWajzX3zxRTz00EPF3peRkREHHXTQJvOUVFk/JgAAAAAAAAAAAAAAAGD7kl7eAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgC3T2LFjo2vXrtGgQYPNnt1hhx1i4MCBERGxdOnSWLx4caxatSrWrFkTFStWjEqVKkXt2rWjUaNGkZGRkbSM3bp122R/xowZsXbt2mLPX7t2bcycOTMOOeSQAs/Url072rdvH9OnT99qMwIAALD1yc3NjWHDhsXf//73qFSpUtLmjh8/Po455pioUKFCgWfatGkTjz76aLz22msxa9as+PXXXyM3Nzdq164de++9d3Tr1i1q1aq12V1PP/100nJvi7b292a2hPc8vC8DAAAAAAAAAAAAAADwe4X5tyVr166NxYsXR25ubtSvXz9q1Kix2WuGDBkSjzzySHz33XfFzvbBBx/Eiy++GHPnzo0NGzZEgwYN4tBDD41evXpFlSpVCrzu//7v/6Jdu3bxySef5OutWrUqjjvuuDj33HPj8ssvj8aNG+c7s3HjxnjxxRfjsssui++//z4iIv76179Ghw4dEu57+eWX44EHHogqVarE888/H927d9/sYzvhhBNiv/32i6OOOiq+/PLLzZ4viYsvvjg+++yzSEtLK9TZ3NzcYu/q2rVrgf8WbenSpfHRRx8Ve/Z/K8vHBAAAAAAAAAAAAAAAAGxf0ss7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsGXKysqK2267LW6++eZIS0sr9HV169aNunXrlmKyf9l1112jZcuWmzwzbdq0Eu+ZNm1aHHLIIZs8071795g+fXq++taQEQAAgK3XwoUL46GHHorzzjsvaTOXLl0aY8eOjdNOO22T5ypXrhzHHHNMHHPMMcXaM3369Pjkk0+Kde32Ymt/b6a83/PwvgwAAAAAAAAAAAAAAEB+t956a6SmpsZxxx0Xqamp/6n//PPP8fe//z1efPHF+OKLL353zV577RV/+ctf4txzzy3w37mkpaXF4MGD49xzzy1ypszMzPjTn/4UEyZMyNd76KGH4rLLLounn346OnfuXOCMs846a5P/zuq+++6L++67L/bZZ59o06ZN1KlTJ9avXx8LFiyI6dOnx/Lly/9z9oADDohrrrkm4Zxff/01+vbtGxERI0aMiO7duxfyUUY0adIkXnzxxWjXrl2sWbOm0NcV1Zw5c+KRRx6Js88+e5PnJk+eHK+++mqJdvXo0aPA3quvvhp5eXklmv9vZfmYAAAAAAAAAAAAAAAAgO1L6uaPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA26vPPvssRo4cWd4xEurevfsm+6tXr44PP/ywxHtmzpwZa9as2eSZAw44IOrUqZOvvjVkBAAAYOs2YcKE+Pjjj5M6c8yYMfHtt98mdeZ/W7ZsWdx9992lNn9bsrW+N7MlvOfhfRkAAAAAAAAAAAAAAID8Zs6cGSeccEI0a9Ys7r777liyZEn89a9/jSZNmsSNN94YX3zxRb5r5syZEwMHDoyuXbvG2rVrC5x94oknRmpqar76unXrCrwmLy8vjj/++JgwYUKBZ3755Zfo0aNHfPLJJwWeOfroowvs/bdPP/00nnjiibj77rvj/vvvj5dffjmWL1/+n36VKlXiySefjPT09ITXn3XWWbFkyZLo0aNHnHnmmQnP/PrrrzF//vzIy8vL12vevHkMHz68UFlL4qqrropVq1YV2M/JyYnBgweXeE+3bt0K7E2ePLnE8/9bWT0mAAAAAAAAAAAAAAAAYPuS/1/FAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/JdJkybFXXfdFTk5OWW699dff42xY8cm7KWnp0fXrl03ef27774b2dnZJc6RnZ0d77777ibPpKWlxeGHH77VZQQAAGDbcNttt8WqVauSNi8nJyeuuuqq+OWXX5I289+ysrLi6quvjuXLlyd99rZqa3xvprzf8/C+DAAAAAAAAAAAAAAAwKbNmzcvBg0aFA0bNoybbrqpUP/O4q233oqBAwcW2K9Xr160aNEiX33lypUFXvP888/Hm2++udnd69ati0svvbTAfpMmTaJmzZqbnbM5d955Z8LHEBHx0EMPxYQJEyIiYsiQIfn6ubm5cfrpp0eDBg2iadOm0aZNm1i4cGG+c/369Ys6deqUOOumLFmyJJ599tkC+9OmTYuvvvqqRDtatGgRu+66a4H9V155pUTz/1dZPCYAAAAAAAAAAAAAAABg+5Na3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAt3+TJk2PIkCGxePHiUt+1cePGeO6556J///7x+eefJzxz0EEHRY0aNTY55/XXX09apsLM6t69++8+3hoyAgAAsG1YunRpjBgxIqkzV6xYERdddFF8++23SZv566+/xuDBg+O7775L2sztxdb23kx5v+fhfRkAAAAAAAAAAAAAAIDS8dhjj8Vvv/1WYL9Vq1b5apmZmQWenzBhQqF3v/HGG7FmzZoC+w0bNiz0rESOPvroOOeccxL25s6dG4MGDYqIiJo1a8ahhx6a78yYMWPiySef/M/Hc+bMiUsuuSTfuUqVKpXJvzVZv359sXqF1a1btwJ7n332Wfzyyy8l3vG/SvsxAQAAAAAAAAAAAAAAANuf1PIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbB2++OKLOPvss2P06NGxZs2apM9fs2ZNvPDCC9GvX7948MEHY+3atQWe7d69+yZnLV26ND7//POkZZs9e3YsXbp0k2d22mmnaN269X8+3hoyAgAAsO1466234o033kjqzGXLlsVFF10UTz/9dGRnZ5do1quvvhoDBgyIuXPnJind9mdreW9mS3jPw/syAAAAAAAAAAAAAAAApSM3NzdmzZpVYL9WrVr5asuXLy/w/MKFC4u0+5dffimwn5GRUehZ/6tevXrx8MMPJ+zl5OTEqaee+p9/09O6detIS0vLd27SpEmFqkVEtGvXrthZtxQ9evQosDdlypQyTAIAAAAAAAAAAAAAAABQfKnlHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANh6rF+/PsaMGROnnHJK3HHHHTFr1qzYsGFDsectXbo0pk2bFtdff32cfPLJcf/998fixYs3eU29evVi33333eSZN954I/Ly8oqd63/l5eXFm2++udlzPXr0iIitIyMAAADbnhEjRsSvv/6a1JnZ2dnx2GOPxZlnnhkvvPBCrF69utDXrl+/PqZNmxYDBgyI2267LVauXJnUbNujreG9mfJ+z8P7MgAAAAAAAAAAAAAAAKUrMzOzwF7FihXz1WbPnl3g+dTU1CLtTklJKbBXkn9n88gjj0TDhg0T9oYOHRozZsz4z8f169dPeG7BggX5aqtXr44VK1bkqzdo0KB4QbcQlSpVis6dOxfYnzJlStmFAQAAAAAAAAAAAAAAACiB9PIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbH3Wr18fU6dOjalTp0alSpWiWbNmsfvuu8eOO+4Y9erVixo1akTFihWjYsWKsXHjxtiwYUOsXbs2li1bFr/++mvMnz8/5s2bF4sWLSry7t9++y169OhRCo9q0x588MF48MEHC3V2a8j4v3744Yfo1q1bkhMBAAAQUXa/c61ZsyZOO+20Upm9ePHiuP/+++PBBx+M1q1bR6tWraJp06ZRu3btqFq1aqSmpsbatWtj5cqV8cMPP8Q333wTn376aWzYsKFY+7755puk3rOJEyfGxIkTkzavvG1v7814XwYAAAAAAAAAAAAAAGDLUb9+/QJ7q1evzlebNWtWgeebNGlS6L0VKlSIHXfcscD+ihUrCj3rv5111lnRs2fPhL0PP/wwrr/++t/VKlasmPDs+vXrC10vaMbW4tBDD40qVaok7K1evTree++9Mk4EAAAAAAAAAAAAAAAAUDzp5R0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADYuq1fvz7mzJkTc+bMKe8oAAAAQCnLzc2N2bNnx+zZs8s7Cv8/780AAAAAAAAAAAAAAABQXMccc0ykpqbGhAkTCnW+Tp06cdBBBxXYX7x4cb7a7NmzY8OGDVGxYsV8vRNPPDEefvjhQu0+6qijonLlygl7q1atioULFxZqzn/bfffd46677krYW7t2bZx66qmRk5NT5Lnbuh49ehTYmzZtWmRnZ5dhGgAAAAAAAAAAAAAAAIDiSy3vAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABA6atcuXKcc8458c0338TEiRPj0UcfjZ122mmz16WkpMQDDzwQlStXLvDMp59+mq+2YcOGmDhxYsLz3bt3jxNPPHGzu2vXrh233XZbgf3p06dvdsb/Sk1NjSeffDKqVauWsH/RRRfFt99+m6++YcOGhOcLui+J6uvXry9C0i1P9+7dC+xNmTKlDJMAAAAAAAAAAAAAAAAAlExqeQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEpPgwYN4oYbboiFCxfG/fffHy1atIiIiDp16sSsWbOiZ8+ekZqamvDaJk2axKRJk+LEE08scP706dNj6dKlCXujRo0q8Lonn3wyzjvvvAJ3t2nTJt56661o1qxZgTOefvrpAnsFueqqq6JDhw4Je5MmTYoHH3wwYW/x4sUJ602aNMlXq1mzZtSsWbPQM7YGO++8c+y5554F9qdOnVqGaQAAAAAAAAAAAAAAAABKJr28AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApWefffaJq666KmGvYcOGMWHChFi8eHG888478fPPP8eKFSuiZs2asc8++0THjh0jLS1tk/Pvu+++AnuvvPJKfP3119GqVat8vUqVKsW9994bl1xySbz88svx3XffxYYNG6Jhw4ZxyCGHROfOnSMlJaXA2QsXLowxY8ZsMtv/OuCAA+Lqq69O2Pv111+jX79+BV77xRdfxMaNGyM9Pf139eOPPz5fjmOPPTbhjFmzZhUp75akW7duBfa+/fbb+P7778swDQAAAAAAAAAAAAAAAEDJpG/+CAAAAAAAbBmqVKkSPXr0+F3tzTffjGXLlpVTIgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACALd8rr7wSb7/9dhx22GEFnmnYsGGceOKJRZ79ySefxJNPPllgPy8vL/r27RvvvfdepKamJjyz6667xoABA4q8+8ILL4wNGzYU+nzVqlXjqaeeivT09IT9M888M5YsWVLg9atWrYrXX389unXr9rv6iSeeGOeff37cd999kZOTEx07dozbbrst3/Vr166NKVOmFDrvlqZHjx4F9qZOnVqGSQAAAAAAAAAAAAAAAABKLvG/eAMAAAAAgC1Q/fr147nnnvvdf61atSrvWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAW7zTTz89li9fntSZmZmZccopp0ReXt4mz33wwQcxbNiwpO6+99574/nnny/SNXfccUc0b948YW/UqFExceLEzc64+eab8z3elJSUGDFiRKxevTqWL18e7777bjRo0CDftSNHjoyVK1cWKfOWIjU1Nbp27Vpgf/LkyWWYBgAAAAAAAAAAAAAAAKDkUss7AAAAAACwaampqQn/AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKKwFCxZE165d47fffkvKvGXLlkW3bt3im2++KdT5K6+8Mm688cak7B41alRccMEFRbrm6KOPjnPOOSdh77vvvotBgwYVas5bb70Vd9xxR8Je5cqVo1atWgl7n376aVx11VWF2rEl6tChQ4GPbcOGDfHmm2+WaR4AAAAAAAAAAAAAAACAkkot7wAAAAAAQMEefvjhyMnJyfffSy+9VN7RAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACArcwnn3wS7dq1iylTppRozrRp06Jdu3YxY8aMIl139dVXx5/+9Kf4+eefi7V3xYoVcdZZZ0X//v0jLy+v0NfVr18/HnnkkYS9nJycOO2002Lt2rWFnnf55ZfHU089Vejzn3/+eRx//PGxYcOGQl+zpenRo0eBvXfeeadI9w8AAAAAAAAAAAAAAABgS5Ba3gEAAAAAgIJ169YtYX3y5MllnAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANgWLFy4MHr06BEHH3xwPP3007FixYpCXZednR2TJ0+Oo446Krp27RoLFiwo1v4nnngidt999xgyZEh88sknkZeXV6jM1113XTRr1iwefvjhIu98+OGHo0GDBgl7N954Y8yYMaNI8zZu3BinnXZaDBgwIJYtW7bJcw8++GC0b98+fvjhhyLt2NJ069atwN7kyZPLMAkAAAAAAAAAAAAAAABAcqSXdwAAAAAAILG99tordtppp4S9KVOmlHEaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgWzJ9+vSYPn16pKamRtu2baNVq1ax2267RY0aNSIjIyPy8vJi9erVsWjRovj666/j/fffj9WrVydld1ZWVgwfPjyGDx8e9erVi0MPPTR22GGHqFevXtSvXz9yc3MjMzMzvvvuu/jkk0/i888/L9G+Y489Nim5/9d9990Xo0ePjqOPPjo6duwYO+20U6Snp8dvv/0Wn3zySfzjH/+In376qVR2b8q5554b5557btLm1a1bN/bbb78C+1OnTk3aroIk+zEBAAAAAAAAAAAAAAAApJd3AAAAAAAgse7duyesz58/P7799tsyTgMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGyLcnNz45NPPolPPvmkXPb/9ttv8cILL5TL7mRYu3ZtjB8/PsaPH1/eUUrNEUccEampqQl7ixYtii+++KKMEwEAAAAAAAAAAAAAAACUXHp5BwAAYOuTmpoaLVu2jObNm0etWrWiRo0aUaNGjUhPT4+1a9dGZmZmZGZmxpIlS+Kzzz6L5cuXl3dkAICtUvfu3RPWp0yZUsZJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2F716NGjwN6UKVPKMAkAAAAAAAAAAAAAAABA8qSXdwAAKEvt27ePTp06JW3ehg0bIisrK9asWROLFi2KBQsWxIIFC2LDhg1J2wFbigMOOCBOOumk6NSpU7Rp0yYqV65c6Gvnz58fH330UTz//PPx4osvRlZWVikmBYD/JyUlJZo2bRrNmjWLnXbaKapVqxZVqlSJiIjVq1fH6tWrY+nSpfH111/HvHnzIi8vr8yyValSJdq3bx877LBDNGjQINLS0uLXX3+NJUuWxKxZs+K3334rsyxbstTU1LjwwgujQoUKCfuTJ0+Ozz//vIxT/UvFihXjwgsvjJSUlIT9e++9N9auXVvs+VWrVo1DDz00YW/y5Mm/+3h7vk9sH3bcccdo1apVNGzYMFq1apWvf+SRR0ZaWlr8+OOP8eOPP0ZOTk45pISykez3tyIicnJyYv369bF69er49ddf46effopvv/021qxZk9Q9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDWqVu3bgX2pkyZUoZJAAAAAAAAAAAAAAAAAJInvbwDAEBZ6tSpUwwbNqxUd2zcuDHmzJkTM2fOjNdeey0mT54cq1atKtWdUFqqVasWF1xwQfTv3z923XXXYs/ZddddY9ddd40TTzwxVq9eHc8991zccMMNMXfu3OSFBaDQGjRoEBdddFG57J48eXK8/fbbpbqjdu3a0bt37+jZs2d07NgxatasWajrsrKy4oMPPoh//OMf8fzzz8ePP/5YKvmOOOKIGDRoUHTp0iUqV66c8Exubm7MnDkzHnvssXjooYciJyenVLIkctxxx0WHDh0S9m677bZYunRpmWWJ+Ne92GGHHeLSSy9N2D/llFNiv/32i9zc3DLNFRExePDguOmmmxL2xowZE2vXri3R/M6dO0elSpXy1bOzs2PatGm/q23P94lt06677hrHHntsdO/ePTp06BC1a9fe5Plrr702rr322oj41/fzGTNmxDvvvBP/+Mc/YtasWWUROanS09PjyiuvjCpVquTrvfDCCzFz5sxS2127du0YMmRIsa4t7WxlZUu/B2Xx/ta/zZs3L6ZPnx6vvPJKvPTSS2X+OgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKH9t27aNhg0bJuzl5OTEa6+9VsaJAAAAAAAAAAAAAAAAAJIjvbwDAMC2Jj09Pdq2bRtt27aNs88+OzZs2BBTpkyJESNG+IfJbDUqVKgQAwcOjCuuuCLq1auX1NkZGRnx5z//Ofr06RMjR46M6667LlasWJHUHQBs2i677BKXX355uexevnx5vP3226Uye9ddd42rr746TjvttKhYsWKRr69SpUr84Q9/iD/84Q9x++23x9ixY+PGG2+Mr776Kin5dtppp3jooYeie/fumz2bmpoaHTp0iA4dOsSFF14YZ599drz33ntJybEp++yzT4wdOzYqVaqUrzdixIhYunRpqWdI5Lrrros+ffrETjvtlK+3zz77RP/+/eP+++8v00w777xzXHXVVQl7K1eujMGDB5d4R0GfK++//36sXr06X317vU9sW44++ugYNGhQdO3aNVJSUoo1o0qVKtG5c+fo3LlzXH311fHFF1/EAw88EA8++GBs2LAhyYlLx7Bhw+Liiy9O2Js3b17MnDmz1Ha3bt262K8TSjtbWXEP/p+mTZtG06ZNo0+fPpGdnR0vvvhiDB8+PD788MPyjgYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlJHu3bsX2Js5c2YsX768DNMAAAAAAAAAAAAAAAAAJE96eQcAgG1dxYoV49hjj41jjz02Pv/887j00ktj6tSp5R1ri3H++edHkyZN8tXffvvtmDhxYjkkonnz5vHMM8/EvvvuW6p7KlSoEIMGDYpevXrFH//4x/jwww9LdR/J5+sXtl7VqlUr7whJlZaWFpdffnlcc801UbFixaTN7NOnT/Tq1Sv+9re/xc033xx5eXnFnrfXXnvFlClTYueddy7ytXvssUe8/vrrceqpp8Zzzz1X7Aybk5GREePHj49KlSrl682aNSsGDx5cars3Z82aNXHRRRfFuHHjEvaHDh0a48aNi2XLlpVZpttvvz2qVq2asHf11VfHL7/8UuIdBf3ho8mTJyesb6/3qSQSvZ7xWqZ8tGvXLkaMGBEdO3ZM+uzWrVvHiBEjYvDgwXH55ZfH2LFjk74jmXr27BkXX3xxue1v1qxZue3eUrgHiVWoUCF69eoVvXr1inHjxsV5550Xv/32W3nHAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABK2bx58+Laa69N2JsxY0YZpwEAAAAAAAAAAAAAAABInvTyDgAA25M2bdrElClT4qWXXoozzzwzlixZUt6Ryt2pp54aHTp0yFdPT0+PiRMnlkOi7dvJJ58cDz30UFSrVq3Mdu60007xzjvvxDnnnBOjR48us72UnK9f2HplZGSUd4SkqVu3bvzjH/+Ijh07lsr8ChUqxNChQ6NTp05x3HHHxbp164o8o3HjxvH2229HnTp1ip2jUqVKMW7cuDj66KNjypQpxZ6zKQ899FA0a9YsX33lypVx0kknRXZ2dqnsLazx48fH66+/Hl27ds3Xq1OnTgwdOjTOPffcMsnSuXPnOOmkkxL2Pvvss7j33ntLvKNp06bRvHnzhL2pU6cWeN32dp9KKtHrGa9lyt6QIUPixhtvjAoVKpTqnl133TWeeeaZOP744+Oss86KNWvWlOq+4mjcuHG5/17UokWLct2/JXAPNu+kk06Kzp07x3HHHRcffPBBeccBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAErRuHHjyjsCAAAAAAAAAAAAAAAAQKlILe8AALA9OuaYY2L27NnRpUuX8o4C/3HWWWfFmDFjolq1aps9m5ubG7Nnz47Ro0fH1VdfHeeee278+c9/jtNOOy369+8fl156adx1113x9ttvx+rVqzc7r1KlSvHYY4/Fn//852Q8FAA2IyMjo7wjJMWOO+4Y06dPj44dO5b6riOPPDImTpwYFStWLNJ1aWlp8fTTT0edOnXy9RYtWhRDhgyJvffeO+rWrRu1atWKli1bxtlnnx2ff/55vvOpqanx+OOPR8OGDYv9OArSv3//6N27d8LeWWedFd9//33SdxbHeeedF9nZ2Ql7/fv3j3bt2pV6hrS0tLj33nsT9vLy8mLAgAGRm5tb4j3dunVLWF+8eHF8+umnm7x2e7pPbN1SU1Pj4YcfjmHDhkWFChXKbO/JJ58cH374Yey4445ltrMw0tPTY9y4cVG7du1yzdG8efNy3b8lcA8Kp0GDBvHGG29Ep06dyjsKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAkaWXdwAA2FL88Y9/jCVLlhT6fEpKSlSqVCmqVq0aDRo0iCZNmkTr1q3jwAMPjJ133nmz1zds2DCmTp0ap59+ejzzzDMliQ4ldvbZZ8cDDzwQKSkpmzz3wQcfxKhRo+KFF16I5cuXF2p2enp69OjRI/r27RvHH3/8JneMGjUqfvrpp3jttdeKlB+AoqlWrVp5RyixGjVqxNSpU6N58+abPLdgwYKYOHFivPvuu/HNN9/Eb7/9FllZWZGamhpVq1aNevXqRYsWLaJDhw5x9NFHx2677VbgrMMPPzxuvfXWGDRoUKFz/uUvf4mDDz44X/3tt9+OY489NjIzM39Xz8zMjH/+85/x2GOPxX333RdnnXXW7/r169eP2267LU4//fRCZ9icvffeO+6+++6Evfvvvz/Gjx+ftF0l9c0338Qdd9wRl112Wb5eampq3HvvvdGxY8dSzXDeeefFXnvtlbD32GOPxfvvv5+UPT169EhYnzp16mav3Z7uE1u3v//979GvX79NnsnJyYn33nsv3n333fjwww9j4cKFUaFChXyfQ2effXasXLky9t577+jSpUsceOCBkZaWVuDcPfbYI6ZNmxaHHXZYkd4LKE3Dhg2L9u3bl3eMaNasWXlHKHdb8z3o1KlT/PLLL0W65t/vcVWrVi1q1KgRTZs2jT333DPat28fBxxwwCZ/j69cuXJMmDAh2rVrF99//31J4wMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJSZ9PIOAABbipkzZ8aiRYuSMmvPPfeME088Mfr37x877bRTgefS09PjqaeeigoVKsQTTzyRlN1QVIceemjcd999kZKSUuCZOXPmxIUXXhivv/56kedv3LgxJk6cGBMnToz99tsv7r777ujYsWPCsxUqVIjnnnsu9thjj6R9PQKQX0ZGRsL66aefHrNnzy7V3T///HNS5owePTpat25dYH/OnDlxxRVXxEsvvRR5eXkFnps/f3589NFHMWbMmLjgggvi6KOPjjvuuCNatGiR8PwFF1wQL730Urz22mubzZiSkhIXX3xxvvrPP/8cxx13XGRmZhZ47caNG+Occ86Jli1bxqGHHvq7Xu/eveOyyy5Lys/KatWqxfjx46Ny5cr5ep999lkMGjSoxDuS7frrr48+ffrELrvskq938MEHx2mnnRZPPvlkqeyuX79+XH/99Ql7y5cvjyFDhiRlT4UKFaJLly4Je5MnTy7UjO3hPrF1O+uss+Kcc84psL969eoYPnx4PPTQQ/m+3zVu3Djf+S+//DLef//9GDduXERENGrUKM4888wYNGhQ1KtXL+GOli1bxssvvxwdOnSIjRs3luDRlFzPnj0T/swoDwceeOAm+40aNYoffvihjNKUj635Hnz33XdJ/X26UaNGcfrpp8fll18ederUSXimRo0a8fjjj8chhxyStL0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAClLbW8AwDAtujLL7+M66+/Ppo0aRJ9+/aNX375pcCzqamp8fDDD0enTp3KMCH8S/369WPs2LGRlpZW4Jk777wz2rVrF6+//nqJ982aNSsOO+ywGD58eIFnatSoEXfddVeJdwFQsIyMjIT12bNnl/p/v/76a4nz9+3bN44//vgC+8OHD4+2bdvGxIkTIy8vr0izJ02aFPvss08899xzCfspKSlx2223FWpWjx49YrfddstXv/HGG2PFihWbvT43NzeGDBmSr16hQoXo379/oTJszgMPPBAtWrTIV1+9enX06tUr1q9fn5Q9ybR27dq46KKLCuwPHz48qlevXiq7hw0bFjVr1kzYu/LKK+O3335Lyp6OHTsm/DrNy8uLV199tVAztof7xNarQYMGm/xe+tprr8Uee+wR119/fSxatKhYO3755ZcYOnRoNG/ePB588MECz+23335xww03FGtHsjRu3DhGjx5drhn+24YNGzb537p168o7YqlzD/6fX375JYYPHx5NmzaNCRMmFHiuY8eOceyxx5ZhMgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJJJLe8AALAty8nJicceeyxatGgRTz/9dIHnKlSoEM8//3w0atSoDNNBxKhRo2KHHXZI2MvLy4v+/fvHxRdfHNnZ2UnbmZubG0OGDImLL764wDO9evWKI488Mmk7Afi9jIyMhPW1a9eWcZKiq169egwbNqzA/sCBA2PIkCGRk5NT7B1ZWVnRu3fveOWVVxL227ZtGz179tzsnK5du+arbdy4McaMGVPoLB988EF89913+ep/+MMfCj2jIGeeeWaceuqpCXv9+/ePb7/9tsQ7Sstzzz0Xr776asJeo0aN4tprr036zgMOOCDOOOOMhL2PPvooHnjggaTt6t69e4F7li5dWug52/p9Yut12WWXRc2aNRP2nn/++ejRo0csXLgwKbtWrFgR55xzTvTr16/Anw1DhgyJffbZJyn7iio9PT3GjRsXtWvXztfLy8srh0SQ2MqVK+P444+P8ePHF3hm4MCBZZgIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgZFLLOwAAbA9WrVoVffr0iSFDhhR4pk6dOvHQQw+VYSq2d506dYrjjjuuwP6FF14Yo0aNKrX9d955Z4wcObLA/jXXXFNquwG2dxkZGQnrWVlZZZyk6IYMGRL169dP2Lv99tvj3nvvTcqenJyc+NOf/hTLly//XW3y5Mlx0kknxdSpUzc749BDD81X++ijj2LFihVFypJo14EHHhgVKlQo0pz/ttdee8WIESMS9h566KF4+umniz27rJx33nmxYcOGhL0LLrggWrVqlbRdKSkpMXLkyEhJScnXy83NjXPPPTfy8vKStq979+4J61OmTCnyrG35PrF1qlixYvz5z39O2Pvuu+/i1FNPjY0bNyZ976OPPhoDBgxI2EtNTY3rr78+6TsLY9iwYdG+fft89VmzZsVrr71WDomgYHl5edG/f//45ZdfEva7dOkStWrVKttQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxZRa3gEAYHsyfPjwuOiiiwrsH3300XHiiSeWYSK2Z7fffnuBvcceeyxGjBhR6hkuvvjimDt3bsJex44dY++99y71DADbo2rVqiWsZ2VllXGSoqlcuXIMGDAgYe+LL76Iyy67LKn7Fi9eHLfeemt89dVXMWTIkNhll13iqKOOivHjx8eGDRs2e/1ee+2VrzZnzpwi50h0TeXKlWP33Xcv8qyIiKpVq8azzz4bVapUydf74osvYuDAgcWaW9a+/fbbuO222xL2KlSokNTXMv369YsDDjggYW/UqFHx0UcfJW1Xo0aNom3btgl7U6ZMKfK8bfU+sfU68MADo27dugl7l1xySaxbt67Udj/44IPx1FNPJewdfPDBUa9evVLbnUjPnj3j4osvzlfPzMyMXr16xfr168s0DxTGihUr4tFHH03YS01NjY4dO5ZxIgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgOJJLe8AALC9ueuuu+LBBx8ssD906NBIS0srw0Rsj44++ujYb7/9EvZ++OGHGDBgQJnk2LBhQ1xwwQUF9vv3718mOQC2NxkZGQnra9euLeMkRXPyySdHnTp1EvYuuOCCyMnJSfrOW2+9Nfbcc88YPnx4/Pzzz4W+rlKlSlG1atV89fnz5xc5ww8//JCwXrt27SLPioi47777olWrVvnqa9asiV69esW6deuKNbc83HjjjbFgwYKEvcMPPzz++Mc/lnhHzZo14+abb07Y++233+KKK64o8Y7/duSRRyasZ2ZmxowZM4o1c1u8T2y9OnTokLC+dOnSmDRpUqnvv/DCC2PVqlX/+fjrr7+Oc845J3beeef47bffSn3/vzVu3DhGjx6dsNevX7+YN29emWWBonrhhRcK7LVs2bIMkwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABRfankHAIDt0aBBg2Lu3LkJey1atIhTTjmljBOxvenfv3+BvcGDB0dWVlaZZXn55Zfjyy+//M/HWVlZMW7cuDjhhBNi8ODBZZYDYHuSkZGRsL5u3boyTlI0ffr0SVj/4IMP4o033iiVnbm5ucW6rnbt2gnrq1evLvKsVatWJazXqVOnyLPOOOOM+NOf/pSwN2DAgPj666+LPLM8ZWVlxYUXXlhg/84774zKlSuXaMcNN9wQ9evXT9gbMmRILF++vETz/1ePHj0S1l999dXIyckp1sxt8T6x9dppp50S1j/77LPYuHFjqe9funRpPPjgg/Hqq69Gjx49Yo899ogHH3ywTH8Gpqenx7hx4xL+rBgxYkQ8//zzZZYFiuP7778vsNeoUaMyTAIAAAAAAAAAAAAA6WRhIgABGRRJREFUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFB86eUdAAC2R1lZWXHBBRfEpEmTEvbPPffcePLJJ0s1w4477hj16tWL6tWrR7Vq1SIvLy8yMzNj2bJlsXz58li2bFnk5eWVaoatxbZ2r3bYYYc4+uijE/Y+//zzeO6558o4UcSIESOiR48e8fTTT8fEiRNjzZo1ZbJ3l112iTp16kTNmjWjcuXKsXbt2li1alX8+uuvsWjRojLJUFwVKlSIpk2bRq1ataJmzZqRlZUVS5cujfnz50dWVlZ5x9uibM3PM1uOtLS0aNq0adSuXTtq1KgRERErV66MzMzMmD9/fmzYsKGcExZNtWrV8tXWrVtXDkkKr2bNmtG5c+eEvfvuu69swxRC1apVE9aL8z167dq1CeuJnsdN2WOPPWLkyJEJe6NHj47HH3+8yNm2BC+++GJMmTIlunfvnq/XpEmTuPzyy+Nvf/tbsWa3bt06BgwYkLA3ffr0ePTRR4s1tyApKSlxxBFHJOxNmTKlRLO3pfu0PapevXrssssuUaNGjahevXrk5ubGypUrY+XKlfHDDz9s8d/D/1vt2rUT1n/++ecyy3DppZeW6+9ww4YNi/bt2+erz5o1KwYPHlwOiaBoli5dGrm5uZGampqvl5GRUQ6JAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICi+NOf/hS77rprwt5jjz0WCxYsKNtAAAAAAAAAAAAAAAAAAOUkvbwDAMD26uWXX44ZM2ZE+/bt8/UOPvjg2GOPPeKrr75K2r599903jj/++OjSpUu0bt06atasucnzK1eujPfeey/efvvtmDRpUnz++edF3tmsWbPYd999N3mmXr16CestW7aMk046qcg7P//88xLft/K4V2Xp5JNPjrS0tIS9O+64o4zT/Mv9998f999/f6nv2XvvvePEE0+Mrl27Rps2baJ69eoFnl2xYkXMnj07Jk+eHC+88EJ88803Sc3SoUOHaNy4cb76xIkTIysrK+E1bdu2jT59+sSRRx4Ze+65Z1SsWDHfmby8vPjmm2/ijTfeiHHjxsWbb75ZrHxb69dvxNb/PEdEtGjRIvbbb7/Yc889o3bt2lGjRo2oUKHCf/rTpk2LUaNGJTXr5tSpUycOP/zwhL3NPZ7iqFu3bnTt2jVh7x//+EesX7++SPOK81y0adMmevfuHT169Ii99torKlWqlPDcxo0b4+uvv4633347nn322XjrrbciNze3SPnKWkZGRr7a2rVryyFJ4f3hD3/43dfBv23YsCGef/75ckhUPHl5eWVyzf+qUqVKPPvss1G1atV8va+++ioGDBhQ4h3l6fzzz485c+Yk/Dq97LLL4rHHHov58+cXee69996b8HVTTk5OnHvuucWJukn7779/1K1bN2Fv6tSpJZ6/rdynwiru65nyfi0TEVGrVq3o2bNnHHfccbHffvsV+AezIiJyc3Pj22+/jZkzZ8aLL74YU6ZM2aK/p6empias5+TklFmGZHxfLa6ePXvGxRdfnK+emZkZvXr1iuzs7HJIBUWXm5ub8Os5JSWlHNIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEXRt2/f6Ny5c8Lem2++GQsWLCjbQAAAAAAAAAAAAAAAAADlJL28AwDA9mzEiBHRvn37hL3jjjsuvvrqqxLNT01Njd69e8eVV14ZrVu3LtK1NWrUiB49ekSPHj3i5ptvjldeeSVuueWWeOONNwo948gjj4yRI0cWNXZExH92F9Wf//znYt238r5XZenwww9PWF+3bl08++yzZZymbPzf//1fXHXVVbHPPvsU+ppatWrFYYcdFocddljcfPPN8frrr8cNN9wQb731VlIyXXjhhXHyySfnqzdp0iTfHz3Yd999Y/jw4dGlS5fNzk1JSYlWrVpFq1at4txzz40vv/wyrrrqqnjhhReKlG9r+vr9t639ea5evXqcf/750a9fv2jWrNkm565evTpGjRqVlIyF1axZsxg7dmzCXqLHU1ItW7YscF/Dhg1jyZIlRZpXlOdi//33j6FDh8aRRx5ZqNnp6enRunXraN26dQwYMCDmz58fN998czz66KORnZ1dpJxlJSMjI18tKyurHJIU3iGHHJKw/t5778Xq1avLOM3WZ+TIkbHnnnvmq2dlZUWvXr1i7dq15ZAqeebOnRvDhw+Pq666Kl+vcuXKceedd8Yf//jHIs3s3bt3dOrUKWHv73//e3z22WfFyrop3bt3T1ifM2dOLFy4sMTzt5X7VFjFfT1TXq9lIiKaN28el19+eZx22mlRsWLFQl2TmpoaLVu2jJYtW8bpp58ea9asiQceeCBuu+22+Pnnn0uUpzSsXLkyYb1WrVplG6QcNG7cOEaPHp2w169fv5g3b14ZJ4LiS01NTVjPyckp4yQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADFk1reAQBge/bcc8/F6tWrE/aOOeaYEs1u3bp1fPTRRzFmzJho3bp1iWZFRBx55JExbdq0ePzxx6Ny5colnlda5syZU+Rrtqd7lZaWFocddljC3iuvvFLg5+PWqlWrVjFz5sx49tlnY5999inRrK5du8abb74ZTz/9dNSuXTs5ATcjJSUlrrnmmvjwww+jS5cuxZqx5557xvPPPx8TJkyIOnXqJDlhchXn6zdi63+eIyKOOOKI+PLLL+Omm26KZs2aldlefi8tLS2GDh0aM2bMiCOPPLLYc3bdddd44IEH4rPPPot99903iQmTp1q1avlqWVlZ5ZCk8Dp06JCw/uabb5ZtkBJKS0srk2v+2+mnnx59+/ZN2Dv//POL/f13SzN06NCYP39+wt7xxx9fpK/rqlWrxu23356wt3jx4rjqqquKE3GzevTokbA+derUpO3YFu7TlqokX0uVK1eO22+/Pb7++uvo169fVKxYsdizqlWrFhdffHHMmzcvLrvsskhN3bLeAl66dGnCetOmTcs4SdlKT0+PcePGJXyNOWLEiHj++efLIRUUT7169Qr83rJixYqyDQMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFBMqeUdAAC2Z+vWrYtp06Yl7LVv3z4qV65crLlnnHFGzJo1K9q1a1eSeAmdfvrp8f7778dOO+2U9NkllZeXF1999VWRrtne7tX+++8fGRkZCXuvvfZaGacpXf369YtPPvkkDjjggKTOPfnkk+Pzzz+P1q1bJ3Xu/0pPT49nn302rrvuukhNLfnL9p49e8aMGTNi1113LXm4UlCcr9+Irf95jojo06dPTJ48OXbeeedS30XBKleuHC+99FJceeWVSfmai4jYY489YsaMGXHWWWclZV4yJfpZsHbt2nJIUnh77LFHwvrHH39cxkkKZ+XKlQnrVatWLfKsatWqJaxnZmZu9tqWLVvGfffdl7D31FNPxSOPPFLkPFuqdevWxYUXXlhgf8SIEZGenl6oWVdffXWBr+EGDx5c4PNbErVq1YoDDzwwYW/y5MlJ27O136ctVXFfy0T86+t09uzZcfHFFyftZ1BERKVKleKWW26JDz74IBo1apS0uSW1aNGihPXWrVtHgwYNyjhN2Rk2bFi0b98+X33WrFkxePDgckgExbfbbrsV2Pvpp5/KMAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDxpZZ3AADY3r322msJ6+np6dGmTZsiz7vgggvikUceiYoVK5Y0WoHatWsXEyZMiEqVKpXajuKYP39+rF27ttDnt8d7tffeexfYe/fdd8swSekaMmRIPPzww1G5cuVSmb/TTjvFO++8E+3bty+V+RERY8aMiRNOOCGpM5s1axbTpk2LBg0aJHVuMhT16zdi23iejzjiiHjiiSciLS2t1HaweWlpafHSSy9F9+7dkz47PT09Ro0aFZdccknSZ5dERkZGvlpWVlY5JCmcunXrRp06dRL25syZU8ZpCmf58uUJ67Vr1y7yrFq1aiWsL1u2bJPXVa5cOcaPHx/VqlXL1/vnP/8Z55xzTpGzbOkmTJgQL7/8csJeixYtYtCgQZud0axZs7j44osT9t5666146qmnShKxQIcffnjCnwdZWVnxzjvvJHXX1nyftlTFeS0TEdGhQ4d4//33o3nz5qWQ6l8OOOCAmDFjRrRq1arUdhTF+++/n7CekpIS5513XhmnKRs9e/ZM+PWSmZkZvXr1iuzs7HJIBcW3qd9VP/744zJMAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUHzp5R0AALZ3H3/8cYG9du3axYcffljoWUcffXTcddddkZKSssl9L774YnzwwQfxzTffxPLly2Pt2rVRoUKFqFOnTuywww5xyCGHRM+ePaNr164Fztl3331j5MiRcdZZZxV4Zs2aNbFw4cJNZm7QoEFUrFgxX3316tWxYsWKTV77v959991Cn93S7lVZadGiRcJ6bm5ufPnll2WcpnScffbZMWzYsE2eWbhwYbz44osxZcqU+Oc//xlLliyJ1atXR40aNaJevXrRokWL6Nq1axx//PHRtGnThDNq1aoVEyZMiP333z9+/PHHpD6GSy65JHr16rXJ7B988EHMnz8/Vq5cGTvssEM0btw4Dj/88OjWrVvUqlWrwNlNmzaNp59+epOfsxFb9tdvxLbxPDdq1CiefvrpSE1NTepciu7OO+8s8Gvim2++iZdeeik++uijWLBgQaxatSrS0tKifv360ahRozjkkEOiR48escsuu2xyx/Dhw2P+/Pnx7LPPlsZDKJL09PSoUKFCvnpWVlY5pCmcJk2aJKzn5OTEggULNnt9vXr1ok2bNtGqVauoX79+1KhRIypVqhTr16+PzMzMWLZsWXz55Zfx+eefx2+//ZaUzDk5ObFixYp835ObNWtW5FnNmzdPWN9c1hEjRkSbNm3y1detWxe9evWKNWvWFDnL1mDgwIHRtWvXqFSpUr7etddeG0899VT8/PPPBV5/9913J/z5tnHjxhgwYEBSs/63Hj16JKy/+eabsX79+qTv21rvU1EU9/VMWbyWiYjYY489YurUqVGjRo1NnluwYEG89NJLMX369Pj555/j119/jfT09GjQoEHsuOOO0alTp+jRo0fUr1+/wBmNGzeO119/PQ444IBYtGhRkbMm07+/19arVy9f7+KLL44xY8bEN998Uw7JSkfjxo1j9OjRCXt9+/aNefPmlXEiKJk6depE3759E/aWLFkSH330URknAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKJ708g4AANu72bNnF9jbbbfdCj2nUaNG8cQTT0RKSkrC/syZM+Oiiy6K999/P2E/JycnFi1aFIsWLYpZs2bF3XffHe3bt48HH3ww9t5774TXnHnmmfHwww/H9OnTE/ZHjx4do0eP3mTu6dOnR4cOHfLVH3roobjooos2eW1xbYn3qqw0b948YX3+/Pmxfv36Mk6TfO3bt4977723wP6SJUviuuuuiwcffDA2btyYr798+fJYvnx5fPvttzFp0qS49NJL49RTT42bb745dtxxx3znGzRoEM8991y0b98+8vLykvIYWrZsGTfddFO++pdffhlXXXVVvPDCC/l6n3/+eUT86+umWrVqcemll8all14aVatWTbijS5cu0a9fv3jkkUcKzLGlfv1GbBvPc0TE8OHDo27dugl7n332Wbz00ksxY8aMWLx4cfz222+/eyyrV69OWo7tXefOnWPgwIH56q+//nr87W9/i3fffXeT1z/xxBMREXHUUUfFTTfdFG3bti3w7GOPPRazZ8+Of/7znyULXUIZGRkJ62vXri3jJIXXoEGDhPXFixdHTk5Owt4uu+wSZ599dvTs2TPatm1b4M/9/zV79ux48cUXY/To0fH9998XO3NExEcffRSHH37472qb+hwpyD777JOvtmzZspg3b16B1/Tp0yfOOuushL1BgwZt8jXo1u7777+PYcOGxTXXXJOvl5GREcOHD4/TTjst4bXHHHNMHHXUUQl7d911V3z55ZdJzfrfunXrlrA+efLkUtm3td6noiju65nSfi0TEVGnTp2YNGlS1KhRo8Azn376aVx22WXxyiuvbHLWI488EikpKdG7d++46aabomnTpgnP7bjjjjFx4sQ4+OCDy/21/9ixY+O8887LV8/IyIhJkybFEUccscnvcVuL9PT0GDt2bNSuXTtf75577kn42h62ZCkpKXH//fcX+Nps9OjRBb42AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2NKklncAAMpHlRoRrTpFdDwt4vDzIv7QP6L9SRGN20akppd3uu3LqlWrIjMzM2Fv5513LvScv/3tb1G7du2Evdtvvz0OOuigeP/994uUbcaMGdGxY8eYNm1agWcuu+yyIs3cEmzP96pp06YJ6wsXLizjJMmXlpYWjzzySFSsWDFhf9asWdGuXbv4+9//Hhs3bizUzJycnHj88cdj3333jenTpyc8c8ABB8SAAQOKnft/3XTTTVGhQoXf1e64447YZ5994oUXXtjs9WvWrIm//e1v0blz51i6dGmB56677rpIT9/6vuFvK89z27Zt49RTT81Xf/PNN+OAAw6IffbZJ6666qqYOHFizJw5M77//vtYsGDBf/5btmxZ0rJs72699dbffZydnR1nn312HH744fHuu+8Wes7LL7/8n+ctLy8v4Zlq1arFyJEjS5Q3GTIyMhLWs7Ky8tXS0tKiZcuWcfzxx8ell14aQ4cOjXvuuSdGjRoV9913X9x6661x1VVXxemnnx4HHnhgVKtWrVQyN2jQIGH9t99+y1dr3LhxPPPMMzFv3ry4+uqrY5999omUlJRC79p7773jmmuuiX/+85/xzDPPRIsWLYqd++23385Xa9WqVey+++6FnpGWlhY9evTIV3/vvfcKvKZ58+bxwAMPJOyNGzeuwN625Kabbop58+Yl7J166qnRsWPHfPWKFSvGXXfdlfCan376Kf72t78lMeHv7bXXXrHTTjsl7E2ZMqXU9m5t92lbctdddxX42jw3Nzcuu+yyaNeuXbzyyiuFmpeXlxfPPPNMtGzZMkaMGFHguX333TeuvfbaYmVOpmHDhkV2dnbC3u677x4fffRRnHbaaUX6/r0luuWWW6JDhw756h999FFccskl5ZAIiq9SpUoxduzY6NWrV8L+ihUr4pZbbinjVAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMWXWt4BAChbdXaJOPbKiPOfiTj2ioiOp0Xs2zPigBMiOvWLOHlYxMCxER1Pj6hYtbzTbj8WLVqUsL7jjjsW6vqUlJTYYYcdEvZuv/32uOSSSyI3N7dY2VavXh29evWKX375JWH/2GOPjebNmxdrdnnY3u9VjRo1EtYXL15cxkmSb+DAgbHnnnsm7E2fPj0OOeSQAr/WNmfx4sXRpUuXmD17dsL+jTfeGBkZGcWa/b/233//3308aNCgGDx4cGRnZxdpzocffhhHHnlkgdftvPPOcfzxxxc3ZrnZVp7ngQMHRkpKyn8+3rhxY/zlL3+JP/zhD/HRRx8lZQeF07Bhw//8f3Z2dvTs2TMeeuihYs8bOnRonHjiibFx48aE/cMPP7zcv/aqVauWsJ6VlRUREXXq1In+/fvHP/7xj8jMzIyvv/46Xnjhhbj11lvjyiuvjIEDB8ZZZ50Vf/nLX+LSSy+NG264IR5//PGYMWNGLF++PN56660YMmTI7+5tSVWvXj1hfcWKFb/7eODAgfH1119H7969Iy0trUQ709LSonfv3jF79uz461//Wqx5L730UsL6+eefX+gZp5xyStSuXTtffdKkSQnPV6pUKcaPH5/w+9XcuXPjrLPOKvTurdn69etj4MCBBfZHjhwZqam/f1vskksuid133z3h+UGDBsWaNWuSmvG/de/ePWF9/vz58e2335ba3q3tPm0runTpEqeffnrC3rp16+KPf/xj3HrrrcWanZ2dHRdccEGce+65kZeXl/DMpZdeGq1bty7W/GT58ccfY8SIEQX269SpE0888UTMnj07Bg0aVODvcFuynj17xuDBg/PVMzMzo1evXkV+fQ/lJS0tLfr06RPffPNN9OrVq8Bzffv2jWXLlpVhMgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJJJLe8AAJSd1kdEnDEyotVhESmb+AlQqVpEx1Mj/nxvRN3GZZdve5aZmZmwXq1atUJdn5eXF8cdd1zsu+++8cILL0ReXl5EREyfPj2GDBlS4nzLli0rcE5KSkr06NGjxDvKyvZ+rwr6nFq5cmUZJ0mu9PT0uOyyyxL2Fi9eHCeeeGKsW7euRDvWrVsXJ5xwQqxevTpfr1atWnHGGWeUaH4id955Z9x9993Fvv7jjz+Om266qcD+qaeeWuzZ5WFbep4PP/zw//z/+vXr45hjjokHHnggKbMpvosuuiimTp1a4jnPP/98XH755QX2k/HzpiQyMjIS1hs2bBgPPfRQ/PTTT/HAAw/EscceW+jXIv9WoUKFOOyww2LYsGHx448/xlNPPRW77bZbiTNXqlQpYX39+vUREZGWlhajR4+Oe+65J6pUqVLiff+7+8Ybb4wpU6ZEjRo1inTtJ598Em+99Va++rnnnhvt2rXb7PUNGjRI+H182bJl8fjjjye85u677462bdvmq69fvz569eoVq1atKkTybcOkSZNi4sSJCXtt27aNc8455z8f77zzzvHXv/414dlXX301nn322VLJ+G/du3dPWJ8yZUqp7o3Yuu7TtuLGG28ssHf++efHhAkTSrzj/vvvj5tvvjlhLz09Pa699toS7yipyy67LN57771NnmndunXceeedsWjRovj+++/jqaeeiksvvTS6du1aRimLp3HjxjF69OiEvb59+8b8+fPLNhAUQY0aNWL//fePP//5z/HII4/EkiVL4qmnnoomTZokPJ+XlxcXXHBBvPjii2UbFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACKoGLFirH//vvHn/70p7j44ovj6quvjiuvvDLOO++86NOnT+yzzz6RlpZWqhlatGgRffr0iSFDhsTVV18dF1xwQZxyyinRtGnTpMyvXbt2dO/ePQYOHBhXXXVVDB48OE4//fQ48MADIyUlJSk7AAAAAAAAAAAAAAAAALY16eUdAICysc8xEUeeX7Rrau8YcertEU9cGLF8Uenk4l+ysrIS1qtUqVKkOZ988kmccMIJsddee8VVV10Vt912W+Tm5iYjYowdOzbuvPPOqFu3br7eYYcdFvfcc09S9pSV7fVeVatWLWF9/fr1ZZwkuU488cRo1KhRwt7FF18cixYl55vY3LlzY9SoUXHRRRfl6w0YMCDuvffepOyJiJgzZ04MGTKkxHOGDRsWF110UdSoUSNfr2vXrpGWlhY5OTkl3lMWtqXn+b//EMbgwYNj6tSpJZ5JybzzzjsxcuTIpM27/fbbo0uXLnHUUUfl6x100EGx3377xaxZs5K2rygK+llwxBFHJHVPhQoVok+fPvF///d/cfvtt8df//rXYs+qWLFiwnp2dnZERDz66KNx+umnb3ZOdnZ2LFu2LHJzc6N27dpRuXLlQmc4/PDD47333otDDz00VqxYUejrhg4dGp06dfpdrVKlSjF58uQ4+eST480330x4XcuWLWPs2LGxyy675OvdeeedCV8/9u7dO84555yE8wYPHhyffPJJoXNvKy644II44ogjEj7XQ4cOjbFjx8ayZcvijjvuiKpVq+Y7s2HDhjjvvPNKNWPVqlXj0EMPTdibPHlyqe7+t63hPm0rDjrooDjooIMS9p588sl4+OGHk7br6quvjoMPPjg6d+6cr3fCCSfE7rvvHnPnzk3avqLauHFjnHDCCTF58uTYd999N3u+adOm0bRp0+jTp0/C/qmnnhr169ePL7/8MubOnZu03++KKj09PcaOHRu1a9fO17vnnnvihRdeKIdUbE8+/fTTIv+Ol5KSElWrVo2MjIwi/dG+zMzMOPvss2P8+PFFjQkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZeKAAw6IwYMHx9FHHx0ZGRmbPLt27dqYNGlS3HPPPfHuu+8Wav79998f++23X776lVdeGa+++mpERPTp0yf++te/xp577lngnD//+c/x5JNPRm5ubqH2/rdDDjkkrrzyyjjiiCMiPT094ZklS5bEqFGj4uabb441a9YUeQcAAAAAAAAAAAAAAADAtiq1vAMAUPp22jPi8HOLd23l6hEnXBeRmvjf8ZIkGzZsSFivXLlysebNmTMnTjnllJg1a1ZJYv3Ohg0bYuLEiQl7hx56aNL2lLXt7V5VrVo1YT07O7uMkyTXGWeckbA+d+7ceOaZZ5K6684774ycnJx89T322CN23333pO258MILY+PGjSWek5WVFWPGjEnYq169erRq1arEO8rKtvg8T5o0KUaOHJm0eRTfpZdemvSZ1113XYG9k08+Oen7Cmtzf4Qm2SpVqhRXXnllNGrUqNgzUlMTv32Rm5sbQ4YMidNPPz1h/7333osrrrgiOnToEDVq1IiKFStGo0aNYscdd4wqVapE1apVo23btnHRRRfFK6+8Enl5eZvM0bp165gwYUJUrFix0NlfffXV+Pvf/56v3rBhw5g2bVq88cYbcdlll8Wpp54avXv3jgsvvDBeeOGFmD17drRt2zbfdTNnzoxbbrklX3333XePUaNGJczw/PPPb/J7TcOGDaNfv35x++23x5NPPhkvv/xyjB8/Pu6999649NJLE+bYWsyfPz9uuummhL3atWvHTTfdFH/4wx+iV69eCc/cdttt8e2335ZmxOjcuXNUqlQpXz07OzumTZtWqrv/bWu4T9uK/v37J6xv3LgxrrzyyqTuys3NjcsvvzxhLzU1Nfr165fUfcWxZMmSOOSQQ+LZZ58t8awBAwbEiy++GP/85z9j7dq1MWPGjBgxYkScdtppseOOOyYhbeHccsst0aFDh3z1jz76KC655JIyy8H2q379+tGoUaMi/dewYcOoXr16pKSkFGpHXl5ePPXUU9G6desYP358KT8iAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACi6WrVqxZgxY2LmzJnRu3fvyMjI2Ow1VatWjV69esU777wTTzzxRKGuadmyZey///75/qtdu3bUrVs3JkyYEE899VTsueeem5wzevTomDZtWtSuXbvQj7Fy5coxatSoeOedd6JHjx6Rnp5e4NkGDRrEX//61/jmm29i7733LvQOAAAAAAAAAAAAAAAAgG1dankHAKD0/eHsiNS04l9fd5eIfY5KXh7yy8vLS1hPSUkp4ySbNnPmzIT1Bg0aRJUqVco4zZZta7tXBX0Obg0qVaoUhx12WMLeyJEjIzc3N6n7fvzxx5g9e3bCXvfu3ZOy49NPP43XX389KbMiIiZMmFBgr02bNknbU5q2xec5IuK6665L2iyK7+OPP44ZM2Ykfe7MmTPj/fffT9jr1q1b0vcVVmH+qMz/ysvLi8zMzFiwYEHMmzcvli5dGjk5OUWa8e6778YOO+xQ5N2b0rJly7jhhhvy1V955ZU46KCD4pBDDolbbrklZsyYEatWrcp3LisrK2bPnh133XVXdOvWLdq0aRNjx47d5M5DDz00brrppiLlvOiii2L69On56ikpKdG5c+e45ZZb4sknn4xnnnkm7rrrrjj++OOjYsWK+c7/8ssvcfLJJ8fGjRt/V69YsWKMHz8+qlevnu+aefPmRb9+/RLm6tChQ7z55pvx888/x8MPPxwXX3xxnHrqqdGjR4848cQT47zzzotbb701Pv3001iwYEH85S9/idTUre+tpFtvvTXmzp2bsHf22WfHY489lrD3ww8/xI033liKyf6lR48eCevvv/9+rF69utT3/9uWfp+2BSkpKXHUUYl/uR4/fnz8+OOPSd85Y8aMeO+99xL2jjnmmKTvK46srKzo1atXHHvssfH1118nZWalSpXiwAMPjPPPPz+eeOKJ+PHHH+P111+PM844o1R/H+vZs2cMHjw4Xz0zMzN69eoV2dnZpbYbytKvv/4an3/+eb7XJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwJdh5553jgw8+iFNOOaXYM0477bSYNm1aVK5cuVjXV69ePaZMmRI9e/Ys9DWdOnWKd955J6pUqbLZs5UrV45JkybFWWedVaRcO+20U7z55pux2267Fek6AAAAAAAAAAAAAAAAgG1VankHAKB0NWweseMeJZ+z77Eln8HW74svviiwV6dOnTJMsuVzr8pOx44dC/xDBVOmTCmVne+9917C+r777puU+U8++WRS5vzbRx99VGBvl112Sequ0rItPs8ffvhhfPjhh0mZRck888wzpTZ77NixCett2rSJ+vXrl9reTalWrdom+3l5efH222/H9ddfH8ccc0zsuOOOkZ6eHrVq1YomTZrEbrvtFvXq1Yv09PSoW7duHHnkkXH11Vdv9vN59913j9dffz2qV6+etMfSvHnzqFix4n8+zs7OjgsvvDC6desWH3zwQZHnzZkzJ04++eQ45ZRTYs2aNQWeu+iii6JDhw6Fnrthw4bo2rVrvPTSS0XO9G/ffvttHHTQQTFv3rx8vTvvvDPatWuXr56dnR29e/eOzMzM39UrVKgQDz/8cEyfPj06deoUKSkpm92/yy67xH333RezZ8+OZs2aFftxlIf169fHwIEDE/ZSU1OjcePGCXsXXHBBZGVllWa0iIjo1q1bwvrkyZNLffd/29Lv07Zgv/32iwYNGiTsPfroo6W2t6DZe++9d+y8886ltreoJk6cGK1bt47evXvHSy+9FNnZ2UmbnZqaGl26dIlHH300vvvuu/jTn/6UtNn/tssuu8To0aMT9vr27Rvz589P+k4oLw0aNIhbbrklFixYEHfeeWfUqlWrvCMBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEREVK1aNaZMmRItW7Ys8awDDjggRo4cWaxrb7311th///2LfN1ee+0VI0aM2Oy5v//979GlS5fiRIvatWtH48aNi3UtAAAAAAAAAAAAAAAAwLYmtbwDAFC6dj8gOXPq7BxRs2FyZrH1Wr58eYG92rVrl2GSLZ97VXbatm2bsL5o0aL46quvSmXn7NmzE9b32GOPpMyfOnVqUub826+//hqLFy9O2GvYcOv45r4tPs9PP/10UuZQcm+88UapzZ4+fXqBvT333LPU9m7KBx98kPAxL1iwIK644opo0qRJdOrUKa699tqYNGlS/Pzzz5Gbm5tw1rJly+LVV1+NG2+8MQ488MDYd999N/m5vccee8R9992XtMfy37Kzs+Poo4+Oe+65p8SznnnmmTj44IMjMzMzYT81NTVuueWWIs3MysqK4447LgYOHBjLli0r9HXZ2dlxzz33xIEHHhjz58/P1z/xxBNjwIABCa8dMmRIfPjhh7+rZWRkxJQpU6Jfv35Fyv9ve+21V7z//vvF+uNC5Wny5Mnxj3/8o9DnJ02aFBMmTCjFRP/StGnTaN68ecLelClTSn3//9pS79O2Yt99901Yz83N3eTPi5J69913C+wV9BqrvOTk5MS4ceOiZ8+escMOO8RJJ50Ut99+e7z77ruxdu3apOzYcccdY/To0fH+++9HgwYNkjIzPT09xo0bl/B3vbvvvjteeOGFpOyBLU2FChVi0KBB8c9//jM6d+5c3nEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIK677rrYa6+9kjbvjDPOiBYtWhT5ujp16hR7Z79+/aJ58+YF9g8//PDo27dvsecDAAAAAAAAAAAAAAAA8P+kl3cAAEpX3cbJm1Vnl4jMxcmbx/+TlpaWsJ6dnV3GSTYtMzOzwF6tWrXKLshWYEu9Vzk5OQk/3wr6HNwatGrVKmF9zpw5pbZz2bJlCetNmjQp8ez169fHl19+WeI5/2vZsmXRsGHDfPUqVaokfVdp2Nae54iIDz74IClzKJnc3Nz47LPPSm3+p59+GuvWrYvKlSvn67Vo0SLeeuutUttdkK+++iq6dOkSBx98cFx99dXRvn37GDp0aIwYMSI2bNhQotmffPJJ9OnTJ5566qkYNWpU7LDDDvnOnHrqqfHMM8/ESy+9VKJd/+svf/lLvPrqq0mbN3v27DjxxBNj8uTJkZ6e/+2TTp06xSGHHBLvvvtuoWfm5ubGvffeG0888UScdtpp0bNnz+jUqVO+z4+cnJyYNWtWvPTSSzFmzJiYO3duwnm77bZbPPzwwwl7EyZMiLvuuitf/cknn4wuXbokvCYnJycWLlwYS5cujYyMjNh5552jatWq+c7Vr18/Xn755WjTpk0sXrz1/IJw4YUXxpFHHrnZn33r1q2LgQMHlkmm7t27J6wvXry4VL83bcqWeJ+2FQX9cbDZs2fH6tWrS23vN998E0uXLo26devm6+25554xadKkUttdEkuXLo3x48fH+PHjIyIiJSUldtttt2jTpk0ccsghMXjw4BLNP+igg2LmzJlx9NFHl/g15S233BIdOnTIV//www/j0ksvLdFsKKqHH344Vq1aVezrK1asGBkZGVG9evXYeeedY6+99kr4euC/1a9fP1577bXo169fPP7448XeDQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlValSpdi4cWOkp6fn602fPj0eeuih+Pjjj2PJkiVRoUKF2GOPPWLQoEHRrVu3hPNSU1NjwIABMWjQoBLlWrx4cbz88svx008/RbVq1aJDhw5x0EEHJTybkpIS5513XoE7b7755s3u++abb+LNN9+MJUuWRO3ataNDhw6x//77l+QhAAAAAAAAAAAAAAAAAGyT8v9rNAC2KVVrJnFWreTN4veqVKmSsJ6VlVXGSf6fevXqxW677Ra77777f/5r2bJlgedTU1PLMN2WZWu6V+vWrYtq1arlq1esWLEc0iTHbrvtlrC+YMGCUtu5fPnyhPXq1auXePbcuXMjNze3xHP+V2ZmZsL61vLcb2vPc3Z2dnz88cclnkPJ/fjjj5GdnV1q87Ozs2PhwoXRrFmzfL2CPq/Lyvvvvx89evSI9PT02LhxY1JnT5o0KQ4++OB45513Yuedd87Xv+mmm2LSpEmRl5eXlH0vvPBCPPLII0mZ9d9ee+21uO222+Lyyy9P2O/bt2+8++67RZ6bmZkZI0eOjJEjR0ZERM2aNaNRo0aRlpYWS5YsiaVLl2723lSoUCHGjRsXNWrUyNdbsGBBnHHGGfnq5513Xhx33HH56qtXr45rr702Ro8eHUuXLv3djqOOOiqGDx8ezZs3/9019evXjyeffDKOOOKIwjzkLcIPP/wQQ4cOjRtvvHGT52666aaYN29emWTq3r17wvrUqVPLZH8iW+J92la0aNEiYf3rr78u9d3ffPNNHHzwwfnqm/q9ZUuTl5cXc+fOjblz58bHH38cgwcP/l3/mmuuiQ0bNkTr1q1jv/32i5YtW272d68mTZrEq6++Gvvss08sWbKkWLmOOeaYfFkiIlasWBEnnXRSqb7OgESuueaaWLRoUVJntmjRIo4//vg47bTTok2bNgnPpKWlxcMPPxxLliyJKVOmJHU/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABTWBRdcECNGjIgbbrghTjrppEhJSYmIiFtuuSWuuOKKfOd/+OGHmDJlSjzzzDPRu3fvhDP/8Ic/FDtPbm5u3HDDDXHjjTfGxo0bf9c79thjY9y4cVGpUqV813Xt2jXhvHbt2sX+++9f4L7MzMw488wz47nnnsvXO/TQQ+Ppp5+OnXbaqYiPAgAAAAAAAAAAAAAAAGDblV7eAQAoXRuzkzcrJ4mz+L2qVasmrGdlZZXazrS0tGjSpEnstttusfvuu//uv9122y2qV69earu3NtvSvVq3bl1Uq1YtX71y5crlkCY5atSokbCempoaBx54YKns3H333RPWMzIySjz7119/LfGMRNasWVMqc8vKtvY8L1y4MNavX1/iOZTcTz/9VOo7li9fnrC+pfz8+N8/CpMs8+fPjy5dusRHH32U72u4TZs20b1795g8eXKJ9+Tk5MSVV15Z4jkFufnmm+Pss8+OunXr5usdf/zx0b9//8jJySnRjszMzMjMzCzSNbfffnvst99++eobN26M3r175/u8q1atWgwdOjTh7kMPPTQ+//zzfL3s7Oz4xz/+Ea+++mpMmzYt2rdv/7v+4YcfHkcddVS8/PLLRcpenoYPHx5nnHFGNGvWLGH/u+++i2HDhpVJlgoVKkSXLl0S9pLxtVESW9J92pbUqlUrYb2gnxPJVNCOmjVrlvrusvL666/H+++//5+Pa9SoEcccc0z06dMnjjrqqP/8Qbb/tcMOO8TTTz8dRxxxROTm5hZp5y677BKPP/54wl7fvn1j/vz5RZoHW6p//vOfceutt8att94affr0idtvvz0aNWqU71x6eno8/vjj0aJFi1ixYkXZBwUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAiPj222/j5JNPjptvvjluuummqFChQlxxxRWbvObKK6+M3r17J+y1adMmKleuHOvWrStylmuvvTZuvPHGhL0JEybE0KFD4/rrr8/X22uvvSIjIyNWr179u3rPnj0L3JWdnR1HHnlkzJw5M2H/nXfeicMOOyw+/fTTqF69ehEeBQAAAAAAAAAAAAAAAMC2K728AwBQutauSN6sNcuTN4vfa9iwYcL60qVLkzK/ZcuWccABB8R+++0XrVu3jt133z0aN24caWlpSZm/LdnW79XKlSujbt26+eqJaluLjIyMhPW+fftG3759yzRLSkpKpKamRm5ubrFnrFmzJomJ/p+8vLxSmVtWtrXneflyP1S3FKX1NfffVqxYkbBe0Of1tuTbb7+Na6+9Nu688858vVNOOSUmT55c4h2vvPJKfP311yWeU5CVK1fGI488Epdeemm+Xp06dWLvvfeOTz75pNT2J3L88cfHwIEDE/auuOKK+OCDD/LVzzzzzKhZs2a++vnnnx+ff/75JvetXbs2TjjhhPjuu++iSpUqv+sNHjw4Xn755SKkL18bNmyIK6+8MsaNG5ewf8stt8SGDRvKJEvHjh0Tfh/Izc2NV199tUwyFGRLuk/bkoL+8FVBPyeSqaDXHtvyH+NauXJljBkzJsaMGRNt27aNu+66Kzp37pzwbJcuXeLUU0+NJ554otDz09PTY9y4cVG7du18vbvvvjtefPHFYiaHLduYMWPi3XffjTfffDOaNm2ar1+/fv244YYbCnytAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABl5bPPPoujjz46KlasuNmz33//fSxatCh23HHHfL2UlJSoW7du/PTTT0Xa/8MPP8TQoUM3eeb++++P6667LlJSUvLtbNiwYaxevfp39U6dOhU465FHHomZM2duct/3338ff/vb3+L222/fTHoAAAAAAAAAAAAAAACA7UNqeQcAoHT99GVy5uTmRCz+Ljmz+L3U1NRo1KhRwt7ChQuLPbdRo0ZxzTXXxFdffRVff/11PPHEEzFo0KA4/PDDo2nTppGWllbs2dua7eleLVq0KGG9YcOGZZwkeapWrVreEZJqw4YN5R1hi7StPc+ZmZnlHYH/X1ZWVqnvWLVqVcJ6tWrVSn33lmDEiBHx/fff56v37NkzKfMnTZqUlDmb8tJLLxXY23vvvUt9/3/bdddd49FHH03Ye/nll+O2225L2DvrrLPy1b799tt46qmnCrV30aJFMWrUqHz1Ll26RJMmTQo1Y0uxqT+kVNDXa2no3r17wvqsWbNi6dKlZZajIFvKfdqWFPR6ZuXKlaW+u6Ad28vPos8++yy6du0a99xzT4Fn/j/27js6qur7+/gnjZBGAqH3IL2jhN47ItKU3lFBKYo0uyJWUL8gAkrvoYP0Il2KdELvXXooIZCe5w8f8iPMnTBJpiTwfq2VpXefc/bZM3PbDJmcjz/+OEk5f/jhB1WqVMkkvnv3bg0aNCjJNQJpycWLF1W/fn2Fh4cbtnfr1k3e3t52rgoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGORkZHP7OPr66v79++bbc+UKVOS5w0KClJcXFyifW7evKnz589bPGfRokXN5po5c6ZFdc2YMUPR0dEW9QUAAAAAAAAAAAAAAAAAAAAAAACA552zowsAANjW2d1SbEzK81wKliIfpjwPTBUsWFAuLi6GbZcuXUpyvvTp0+vrr7/W6dOnNXTo0ES/pP2iexGfq6tXrxrG8+fPb99CgBdcaGioo0vA/xcbG/tczJGaxcTEaMGCBSZxPz8/FShQwKIcif0Rm40bNya7Nktt27bN7B/xKVasmM3nf8zV1VXz5s2Tn5+fSduVK1fUuXNnw3EZM2ZUyZIlTeLz589/5h8IetLcuXMN49WqVbM4B/5Po0aNDOOrV6+2cyWwFycnJ8M41yL7iI2N1fvvv68lS5YYthcrVkz16tWzKNdrr72mAQMGmMTv3r2r1q1bKyoqKiWlAmnCmTNnNHz4cMM2Ly8vtWrVys4VAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgnouLiwoWLKgGDRqoZ8+eGj58uBYsWKC9e/fqzp07unv3rooWLWp2vJubW5LnPHz4sEX9rl27Zhj38PBIsO3i4qKcOXMa9o2Li9PevXstmu/mzZs6fvy4RX0BAAAAAAAAAAAAAAAAAAAAAAAA4Hnn6ugCAAC29eC2dGitVKZxyvJsD7JOPTBVpkwZs22Wfmn7sRw5cmjp0qUqX758imoKCwvTqVOn4n9OnjypU6dOKTQ0VMHBwSnKnVq8qM/V2bNnDeNZsmRRpkyZFBISYueKgBdTbGyso0sA7Grp0qUaPHiwSbxUqVJmr01PioiIMNt25cqVFNVmiZiYGF2/fl158uQxafPz87P5/I+NGDFCgYGBJvGYmBi1bdtWt2/fNhxXpUoVOTk5mcQ3b96cpPl37typyMhIpUuXLkG8evXqmjVrVpJyveiyZ89u9n3A6tWr7VwN8GLp1auXGjVqpPTp05u01a9fX3/99Vei4/PkyaPp06cbtnXr1k3nz5+3RplAmjBhwgR98cUXhm3VqlXTtGnT7FwRAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/56WXXlKnTp3UpEkTlSpVSu7u7nad//r16xb1i4iIsKifl5eX2bYHDx7o0aNHFuWRpGvXrqlkyZIW9wcAAAAAAAAAAAAAAAAAAAAAAACA55WrowsAANje1mlSgfKST5bkjT+yXroUbN2a8H+qV69utm3//v0W58mcObN27NihfPnyWdQ/PDxcp0+f1qlTp3Tq1CmdPHky/v+vXr1qOCZr1qwW15OavcjPVXCw+YO5dOnS2rRpk/2KsZK4uDjD+NatW3XixAk7V2O+HqQMr/OLx8nJyS7zuLi42HyOdOnSGcZjYmJsPndqcerUKcN45syZLRofHh5uGI+KitK9e/eSXVdSXL9+XXny5DGJ+/r62mX+119/XR988IFh2+eff66///7b7NgCBQoYxo8fP56kGmJjY3Xq1CmVKFEiQTwgICBJeSA1aNDAMH7v3j39888/dq4G9mLuvO/qavuPaN3c3AzjL9K16LHr169r9uzZ6t69u0lb7dq1Ex3r6uqqefPmKWPGjCZto0aN0pIlS6xVJpAmXL58WYcOHVKpUqVM2l555RUHVAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABbK1u2rLZu3SpJ+vXXX/Xpp586uCIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMOXt7a2RI0eqa9eucnFxcVgdkZGRVs2XPn16s20PHz5MUq6QkJCUlgMAAAAAAAAAAAAAAAAAAAAAAAAAzwVXRxcAALC9h3elhV9JbX+Q0vskbeylw9LqkTYoCvEaNGhgGL969aquXLliUQ4nJyfNmzdP+fLlM9vn2rVrWrZsmf766y/t379fZ86cUWxsbJJqdXJySlL/1OhFf66Cg4PNtlWvXl2bNm2yXzFWEh4ebhhfsGCBfv31VztXA1vhdX7xeHh42GWexP6gibX4+fkZxh88eGDzuVOLmzdvGsbNPTdPu337tmE8LCwsuSUlmbm5XF1t/9FK3rx5NXXqVMO2tWvX6vvvv090vL+/v2H86tWrSa7l6tWrKlGiRIJYpkyZkpznRde4cWPD+Lp16xQTE2PnamAv5s77GTNmtPnc5uYIDQ21+dyp0erVq9W9e3eTePHixRMd991336lSpUqGbY0bN1bdunWtUt9j5t63fvnll+rbt69h27Fjx9S6dWur1gEk5vz58ypVqpRJPEuWLA6oBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOa0atUqwZoTP//8c7LW/nB2dpa3t7ckKV26dFarL60YNGhQ/No6169f1x9//OHgigAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8LXPmzNq8ebOKFy/u6FJStbi4OEeXAAAAAAAAAAAAAAAAAAAAAAAAAACpgqujCwAA2MeNM9L0flKLL6QsAZaNCV4jrftNiomybW0vsjJlyqhIkSKGbatWrbI4T5s2bVS7dm3DtitXrmjgwIGaP3++YmJiklXnY56enikanxq86M/V4cOHdffuXfn5+Zm0NWjQQMOGDbN/USn08OFDw7i/v7+dK4Et8Tqnbs7OzlbP6eXlZfWcRjJmzGjzOYzOuZL04MEDm8+dWpj7Yy/u7u4Wjb9y5Yph3M3NLdk1JZWrq/FHKNHR0Tafd968eYb76tWrV9WxY8dn5siUKZNJLDo6WlFRSb/RN9pvjfLDPCcnJ9WvX9+wbfXq1XauBvYUGhpqGLfHtcjcHOZqet4dOHDAMO7l5aV06dIpMjLSsL1x48ZmcxYuXNgapVkkZ86cypkzp2HbyZMn7VYHIEk3btwwjJu7BwYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAID9lSxZUkFBQfFrfUybNk1hYWEOriptcnNz09ChQ+O3r127pj///NOBFQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB42oIFC1S8eHGL+9+6dUtnzpzR6dOnVb9+fWXNmtWG1aVMRESE2bb06dMnKVeGDBlSWg4AAAAAAAAAAAAAAAAAAAAAAAAAPBdcHV0AAMB+7l6VpvaWStSVXm4qZSskOTkl7BMZLl3YL+2cI1094Zg6XyRvv/222baVK1danOeLL74wjB8/flzVqlXT7du3k1ybkcyZM1sljyO96M9VXFycNm/erGbNmpm0ValSRdmzZ9e1a9ccUFnymavX39/fzpXAlnidHS82NtZsm7e3t9Xny5Url9VzOmoec/tpSEiIzedO7eLi4izqd/bsWcO4l5eX0qdPr/DwcGuWZcjcH+a5e/euTef94YcfVLFiRZN4bGys2rVrp5s3bz4zh5ubm0kssT/mkxijcenSpUtWrhdV+fLlzZ4X1qxZY+dqYE83btwwjGfJksXmc5t7f3Lr1i2bz50aJfa4M2fOrH///deO1ViXuWsmYCtRUVGGcVdX/vkJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgNXB2dtaUKVPi168ICQnRwIEDHVxV2jVixAh16tRJRYsWlST9/vvv2rJli+7cuePgygAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABIUtOmTVWzZk2z7WfPntWyZcu0a9cuHT9+XGfOnNG9e/fi2/fs2aOsWbPao9RkCQsLM9uWIUMGubq6Kjo62qJc2bJls1ZZAAAAAAAAAAAAAAAAAAAAAAAAAJCmuTq6AACAfcXFSofX/ffjkUHKmFPy9JOio6SHd6VbF6RYy76zixTKli2bunfvbth29+5drVixwqI8RYoUUbFixQzbunXrptu3bye7xqdlyZLFarkcgefqPytXrlSzZs1M4s7OzurcubOGDx/ugKqS7/Lly4bxIkWK2LkS2BKvs+Pdv3/fbJuvr6/V5ytcuLDVcxrJkSOH/Pz8dPfuXZvkz5w5s3LlymXYdvLkSZvMmRqlS5fOMP7w4UOLxv/777+6ffu2/P39TdqyZs2qixcvpqg+S5j7wzy22nckqUmTJvrwww8N27766itt3rw52bnj4uLsOg7/p1GjRobxI0eOmL3e4flw9OhRtWzZ0iT+yiuv2HRed3d3lShRwrDtyJEjNp07tUrs+pM+fXo7VmJ9Z86ccXQJeME4OzsbxrlnAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASB169+6t8uXLx29/8cUXunXrlgMrStuioqLUv39/rVq1SpKUPXt2jRgxQm+99ZaDKwPwLF5eXqpQoYLKli2rvHnzytfXVx4eHnr48KHu3bunCxcu6ODBg9q9e7fCwsIcXS5SsWftS0uXLmU/AgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAH6tixo9m2L774QsOGDUt0vI+Pj7VLsqro6Ghdv35d2bJlM2lzcnJSmTJltHfv3mfmSZ8+vYoUKWKLEgEAAIA0ZePGjYbx2rVr27kSAAAAAAAAwDHGjBmj4sWLm8TfffddHT9+3AEVAXgecG5J/XiNACBt4t+4AQAAANtydXQBAADHeXT/vx84xrBhw+Th4WHYNn36dIWHh1uUp169eobxQ4cOaefOncmuz0jFihWtms/eeK7+M3/+fI0ePVrp0qUzaevXr59++eUXRUdH27WmHDlyaOvWrZo+fbqmTJmiS5cuWTz28OHDhvEKFSrIyclJcXFx1ioTDsTr7Hh37twx25Y9e3arz2fP82hgYKDWrVtnk9yVKlUy23by5EmbzJkamdtH7t69a3GOvXv3qkGDBibx8uXL6+LFi8ktzSIvvfSSfH19DduOHj1qkzlz586t6dOny8nJyaRtw4YN+uabb2wyL2yvcePGhvE1a9bYuRLY25EjRwzjuXLlUt68eW12LgsMDDS895dsdw6zVIMGDeTl5aXFixfbdV5z53RJFr8XT63Onj3r6BLwgsmcObNhPCwszM6VAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABeRDVq1NDmzZst7h8XF6ewsDDdu3dPISEhOnTokPbt26dVq1Y5/G93A7bg4eGhTz/9NH775s2bmjRpUpJylCtXTm+88YZKly6tAgUKKH/+/PFtffr0UdOmTXXmzBlt375dq1at0r59+5Jcp9GxvHjxYrVs2TLJuZIjODhYpUqVShAzWjPksdWrV+vgwYMqU6aMJKlr16767rvv+HvxadTT+9+yZcv0+uuvWy3/1atXE6zf4+XlpYcPH1otP56tTp066tOnjxo3bqz06dM/s394eLhWrlyp0aNHa9OmTTar65133tEff/wRvz1x4kS9/fbbNpvPETUk9V5NkiIjI3Xv3j3du3dPJ06c0J49e7Rp0yabvhaWsnRf6t+/f4r3o7R2bQQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA1KRSpUqG8atXr2rYsGGJjvXw8FBAQIAtyrKqU6dOKVu2bIZtrVq10t69e5+Z4/XXX5eXl5e1SwMAAADSnFq1ajm6BNiBu7u7SpYsqdy5c8vX11cZMmSQp6enoqKidP/+fd2/f18hISE6evSorl696uhyAQAA8BxKly6dYTwyMtLOlQCpA8cEnmdpcf9++eWXDf+tPUOGDA6oBsDzgnNL6sdrhMSkxXsawBLPw77Nv3EDAAAAtuXq6AIAAHgR1a5dW2+99ZZhW3R0tEaPHm1xrgIFChjGd+3alazaEmPPD+ucnJysnvN5fa6S6s6dO1q5cqWaN29u0pYrVy717t1bo0aNsmtNvXr10ksvvaShQ4fqyy+/1Nq1azV+/HgtW7ZM0dHRiY7dv3+/YTxDhgwqVqyYjh49aouSkQhbHL+8zo53584ds23lypXTwoULrTaXn5+fAgMDrZbvWRo2bKh169bZJHfNmjUN4xERES/UflulShXD+Llz5yzOsWbNGjVo0MAk3qRJEy1atCjZtVni1VdfNdu2b98+q8/n4uKiuXPnKlOmTCZt169fV/v27RUXF2dxvtjYWJOYm5tbsmoz+gdoo/ww5ufnpwoVKhi2rVq1ys7VwBxb3MtI0rZt28y21a1bV1OmTLHJvHXq1DGMR0RE2OQcZomaNWvq22+/VdWqVXXp0iWL7vutKUeOHGbb7t+/b7ZtxowZiY61tmbNmhn+cbgNGzYoODjYcIy5OGAruXPnNozfvn3bzpUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPBsTk5O8vb2lre3t3LlyqVSpUqpffv2+umnn7Rv3z4NHz5cc+fOdXSZgNX06tVL2bJli98eNWqUwsPDnznO1dVVvXr10gcffKCXXnrJbL/06dOrSJEiKlKkiF599VV98803Cg4O1ldffaXFixenqPZmzZqpUKFCOnXqVIryPEvDhg1VqlSpJI8bMWKEZs6cKem/tUY+++wzde/e3drlwQGaNm2qt99+WxMmTHB0KUihggULavz48apdu3aSxqVPn14tW7ZUy5YttW7dOvXo0UOXLl2yen29evVKsN2uXTt9+OGHCg0NtfpcqbmGp6VLl05ZsmRRlixZVLBgQTVp0kRffvmlzp07p99++02jRo1STEyMXWtKzr5ki/0otV8bAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACC1yJo1q2H84sWLzxz75ptvys3NzdolWd3ff/+tatWqGba99957Gj9+vM6fP292vLe3t77//nsbVQcAAIAXSfbs2fXOO+84ugyzLl++rMmTJzu6DDiAs7OzatasqdatW6tatWoqWrSoXF1dLRp78+ZN7d+/X0uXLtXChQt17do1m9TYr18/+fn5WS1fZGSkwsPDdevWLV27dk2nT5/WhQsXFBcXZ7U5UsLHx0clSpRQgQIFlCFDBvn4+MjDw0PR0dEKCwvT3bt3dfbsWZ08eVLXr193dLmSJD8/PxUrVkwFChSQv7+/vLy85ObmpqioKIWFhen27ds6e/asjh07prt37zq6XElps2ZLGB0vp06dUlBQkN1ree+995Q5c2aT+PDhwxUeHm52XPfu3ZU7d26TeFRUlMM/p3n11VdVvnx5k/izrqPmzmMLFizQ0aNHrVkiAKR5hQsX1okTJwzbihQpopMnT9q5IsCxOCbwPGP/BgAAzwPuafC8Yt8GAAAAYAnLftMQAABYTZ48eTRnzhw5OTkZtk+ZMkWnT5+2OF+WLFkM47dv305WfebkzJlTlStXtmpO6b9fLjbi6elp9bnS+nNlTT///LOaN29u2PbVV19p/vz5+vfff+1SS5YsWdSnT5/4bWdnZzVq1EiNGjXSrl27VLFixUTH79q1S2FhYfLy8jJp69Chgz799FOr14z/2PP45XV2vOjoaF2/fl3ZsmUzaQsMDLTqXJ06dZKLi4tVcyamXbt2Gjx4sGJjY62a193dXV26dDFs27JlS6JfyrEXd3d3RURE2Hweo2tOXFycDh8+bHGO5cuX6+effzbM/cEHHyg0NDQlJSaqU6dOhvHr16/r2LFjVp/vu+++U5UqVUzisbGx6tChQ5K/jGj0pTp3d3c5Ozsneb83Og/fuXMnSTleZPXq1TM8vz169Ehbt251QEUwup+xxb2MJF26dEmHDh1SqVKlTNr69u2rKVOmWH1ONzc3vfvuu4ZtmzZtUlhYmNXnTEzlypX1zTffqE6dOvGxPHnyqFevXvrtt9/sVoe5P2R28+ZNPXjwwOy44cOH26okQwULFlRAQIBJfO7cuRo/frxdawGM+Pv765VXXjFsO3XqlJ2rAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgZV5++WXNmTNHb731ltq3b6+bN286uiQgRdzd3TVkyJD47UePHmns2LHPHFewYEHNnz9fZcuWTda8pUuX1qJFi7RixQp16tQp2etaODs7a+DAgerZs2eyxltq8ODByRo3d+5c/fDDD8qdO7ek/9Y3+frrr3X+/HkrVgdHGTlypDZt2sTfXU/DWrdurUmTJsnb2ztFeerXr68DBw7ozTff1IYNG6xUnVS+fHmVK1cuQczLy0sdOnTQ77//brV5UnsNSREQEKCff/5ZnTp1Urt27XT8+HG7zGuNfcla+1FqvzYCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQGoRExNjGC9VqpT8/f11+/Ztw/bcuXNr+PDhtizNalauXKmPPvrIsM3X11dr165Vs2bNdOzYMZP2LFmyaN68eSpQoICtywQAAMALIGfOnBo6dKijyzBr586dmjx5sqPLgB1lyJBBAwcO1DvvvKNs2bIlK0eWLFnUoEEDNWjQQL/++qs2btyor7/+Wlu2bLFqrf3791f+/PmtmvNpDx480O7du7Vu3TotWrRIJ06csOl8T3JxcVGtWrXUsmVLvfrqq0l6rGfOnNFff/2lGTNmaNu2bbYr0kCpUqXUuXNnNWzYUCVLlpSTk9Mzx8TFxenw4cNavXq1pk+frsOHD9uh0v+TFmtOKqPjJTY2VleuXLH6sfksffv2VdGiRU3iv/32m8LDw82OS+yauWXLFrvv608aPXq04WdFn332WaLjzJ3Hjh8/rqNHj1qrPAAAAAAAAAAAAAAAAMBunB1dAAAAL5IcOXJo7dq1ypo1q2H7vXv39OWXXyYpZ1xcnGHcy8sryfUlZvDgwXJzc7NqTkm6c+eOYdzf39/qc6X158qa/v77b/3999+GbX5+fgoKCpKLi4tdahk5cqQyZcpk2DZz5sxnjo+KitJff/1l2PbWW2+l+tciLbPn8cvrnDrs2LHDMF67dm1lzpzZKnO4ubnp/ffft0ouS+XMmVPt2rWzet4OHTooS5Yshm2rVq2y+nxJ4e3trUGDBunChQt64403bDpXgQIF1Lx5c5P4kSNHFBISYnGekydP6p9//jGJZ8qUSYMGDUpJiYlq1aqVAgMDDdvmzZun2NhYq87XqFEjs4/nu+++0/r165Oc09wfHkrOcWs0Jimv44uucePGhvGNGzcqIiLCztVAMr6fscW9zGNLliwxjJcrV0516tSx+nwdO3ZU9uzZDdsWL15s9fmeZdKkSYaP8/vvv1e+fPnsVkfbtm0N4/v27bNbDcDzoEuXLmY/O3Dkl8gBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC+uhw8f6qeffjL788svv2jcuHGaM2eO9u/fr8jISJMc9erV0+bNm83+nW8grWjZsqWyZcsWv718+XKzaw49Vrx4ce3YsUNly5ZNEI+Li9OhQ4c0Y8YMTZ8+PT5+8OBBrV+/Xvfu3TPJ1aRJE+3YscPsmm2W6NKlS4LHYG0vv/xystcKiI6OVlBQUPy2q6urevToYa3S4GCenp6aPXu2XF1dHV0KkqFr164KCgqSt7d3gvidO3c0Y8YMtWnTRuXKlVPOnDnl7e2tLFmyqGjRomrZsqXGjh2rmzdvJhiXKVMmLVu2TFWqVLFajT179jSM9+rVy2pzpMYannWv9tNPP2n06NGaNm2atm7dqvv375vkKFu2rDZv3qwiRYrYrM7Hkrsv2XI/Ss3XRgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABILa5du2YY9/T01OrVq1WxYsUEcXd3d7Vt21a7du2y6Rox1rR161adPHnSbHuhQoUUHBysoKAgvfXWW3r99dfVpUsXjR07VqdPn1atWrXsVywAAAAA2IGrq6s++ugjnT9/Xp9//rnV3t85Ozurbt262rx5s9auXavixYtbJa+9eHt7q3bt2vruu+90/Phx/f3332rSpIlN53RxcVG3bt106tQp/fXXX3rvvfeUP3/+JOV46aWX1LNnT/39998KDg7Wa6+9Zptin1CzZk1t3rxZwcHBGjhwoEqVKiUnJyeLxjo5OalUqVIaNGiQDh06pI0bN6p69eo2rjht1mxNzs7OmjFjhnx9fR1dikWmTp2q2NhYw7YuXbrYuZr/U7VqVRUoUMAkHhsbq2nTpjmgIgAAAAAAAAAAAAAAAMBxnB1dAAAAL4oyZcpo27ZtKlq0qNk+/fr109WrV5OU99atW4bxggULJilPYgoWLKi3337bavmeFBISYhgvV66c1edK68+VtQ0aNEhxcXGGbTVq1NCUKVNsXsMHH3yg9u3bG7bduXNHkyZNsiiPuV8Ez5o1q3r37p3s+swZNGiQBg4cKFdXV6vnTkvsefxKvM6pwd9//20Yd3Nzs9oXRfr376+XXnrJKrmS4vvvv5ePj4/V8mXJkkXDhg0zbIuIiNCMGTOsNldS+Pv7a9iwYbp06ZKGDx+ubNmy6fvvv5eXl5fN5hw1apTc3d1N4vPnz09yrrFjxxrGP/zwQ5UoUSLJ+Z7F399fP/30k9l2S69TlsqZM6dmzJhh+IW5LVu26Msvv0xWXnP3l0WKFElyLqMxSb1/fZE1bNjQML569Wo7V4LHjO5nbHUvI0njxo1TZGSk2TZvb2+rzZUrVy79+OOPhm0hISEOuRZ9++23hnFvb28tWLBAnp6eNq+hefPmqlatmmHbmjVrbD4/8LzIkyePhg4darZ9xYoVdqwGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAID/3L9/X4MGDTL7M2DAAL333ntq166dXn75Zfn7+6tjx446fvx4gjzFihVTUFCQgx4FYB1PryczZ86cRPt7eHho2bJlypw5c3wsOjpa//vf/5Q/f36VLl1anTt31qhRo+Lb161bp3r16snPz0/16tXT1q1bE+QsUqSIVq5cmew1gNzd3dWvX79kjbXE4MGDUzT+6fNEp06dUpQPqUv58uUT/ZvsSJ1q166tSZMmydn5/5ZsjoqK0s8//6x8+fKpc+fOmjdvng4cOKCrV68qLCxMt27d0okTJ7R48WL17t1b+fPn19ChQxUTExOfw9PTU4sWLVLGjBlTXKOPj4/atWtn2FamTBlVqFAhxXOk1hqeda82aNAg9evXT127dlWNGjWUKVMmNWnSRNu2bUuQJ2vWrFq1apXh2ljWkpJ9yZb7UWq/NgIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAavD0umpPKl++vHbu3Klbt27pwIEDOn78uO7evaugoCDlyJHDjlWm3LPW2nJ1dVXbtm01YcIE/fnnn5o6dareffddZciQwU4VAgAAAIB9FChQQNu3b9f3339vlTVozalfv7727Nmjbt262WwOW6tataqWL1+udevWKU+ePFbPX6xYMe3fv1+TJ09WQECAVXKWKlVKy5Yt09KlS+Xv72+VnE/y8/PTjBkztGnTJtWoUcMqOWvVqqUtW7Zo8uTJNnkfnhZrtpW8efNq3Lhxji7DIpcvX9Zff/1l2Na6dWubrtmcmC5duhjG161bp8uXL9u5GsC+qlatqlWrVpn8fPLJJ44uDQAAAAAAIAE+xwBSN6NjlOMTAAAASLucHV0AAADPO1dXVw0cOFA7d+5M9JfO58yZo+nTpyc5//Xr1w3jNWvWlLe3d5LzPS19+vRauHChPD09U5zLSHBwsGE8ICBApUuXtupcaf25sradO3dq4sSJZts7deqkOXPm2OwXv9977z398ssvZtu/+uorPXz40KJcy5Yt06VLlwzbvv/+exUvXjxZNRqpUKGCvvnmG40YMUIHDhxQ9erVrZY7rbHn8SvxOqcGmzZtMtv22WefKVu2bCnKHxgYqGHDhqUoR3LlyZNHM2bMkJOTU4pzOTk5KSgoSDlz5jRsnzt3rm7dupXieZIqICBAFy9e1GeffSY/P7/4eMGCBTV58mSrPPanfffdd3rttddM4tHR0Zo2bVqS882aNUunT582iXt5eWnFihXKkiVLsuo04u7urqVLlyp//vyG7YsXL9bBgwetNp+zs7Pmzp2rzJkzm7TdvHlTbdu2VWxsbLJyb9++3TBeoUKFJOUpVqyY4T2TufxIqESJEsqVK5dh2+rVq+1cDR4zup+x1b2MJF29elWzZ882bCtcuLCmTJlilXnc3Nw0f/58s+fFsWPHWnyvbU1BQUE6efKkYVv58uW1ePFieXh42Gz+QoUKmf2CbnR0tIKCgmw2N/A8yZMnj9avX2/2s5Tdu3fr0KFDdq4KAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICke/DggWbNmqWSJUuarOVTq1YttWnTxkGVASmTI0cO1atXL347NDRUK1euTHTMgAEDVKBAgQRj6tSpow8//FAXL1585pzr169XjRo11Lt3b8XFxcXHX3nlFX3xxRfJeBT/effdd+Xl5ZXs8ebkz59fb7zxRopy7N+/X6dOnYrfzpcvn2rUqJHS0pCKfPTRR6pWrZqjy4CFMmXKpKCgIDk7/99yzWFhYWrQoIEGDhyo0NBQi/I8fPhQX331lV577TVFRUXFx7Nly5bo2nuW6tChQ4Lz2oEDBxK09+rVK8VzpIUaLBETE6OVK1eqWrVq+vTTTxO0BQQEaODAgTaZ1xr7ki33o9R8bQQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA1GD69OnP7OPv768yZcqoSJEiSp8+fYK22NhYRUdH26o8q5k9e7bWr1+f4jxp4bECAAAAgDmvvvqqDh48qMDAQLvM5+HhocmTJ2vcuHF2mc9W6tWrp/3796tq1apWy9m6dWvt3btXpUqVslrOJzVt2lT79u1TwYIFrZazcOHC2rNnjzp27Gi1nE/q1q2bdu3apYCAAKvlTIs121q7du3Uvn17R5dhkYkTJxrGfX199frrr9u5Gsnd3V2tW7c2bDNXK/A8yZYtmxo1amTyU65cOUeXBgAAAAAAkACfYwCpm9ExyvEJAAAApF2uji4AAIDnVfr06dWxY0cNHjxYhQoVSrTvzp071bVr12TNs337drPzf/zxx/r000+TlVeSPD09NXfuXJUuXTo+FhMTIxcXl2TnfNq2bdvMtg0bNkzNmjWz2lxp/bmyhQEDBqhWrVpm99E2bdqoaNGi6tq1qw4cOGCVOX18fPT7778n+kvxW7du1a+//mpxzujoaH399deaMGGCSVv69Om1ZMkS1a9fXxcuXEhWzY8VLVpUS5cuVbp06SRJJUqU0JYtWzRjxgwNGDBAN2/eTFH+tMaex6/E65wa7N27V3v27FH58uVN2vz8/DR16lS9/vrrioqKSnLuUqVKafny5fHPuyTFxcXJyckpRTUnRbNmzbRkyRK1b99eYWFhycrh6empmTNnqm7duobtkZGR+uabb1JSZrKdO3dOu3fvVs2aNU3aHn/ZpnPnzoqIiEjxXC4uLvrmm2/00UcfGbZPnz49WcdqTEyMBg4cqCVLlpi05cuXT5s3b1bz5s118uTJJOd+UtasWTV37lxVqVLFsD08PFyffPJJiuZ42jfffKNq1aqZxOPi4tSpUyddvXo12bkvXLigy5cvK3fu3AniLVu21M8//2xxnhYtWhjGt27dmuzaXiSNGjUyjJ8/f16nTp2yczV4zNz9jC3uZR779NNP1apVK/n4+Ji0vfHGG5ozZ466dOmS7PNxxowZtWjRIlWuXNmw/fLly/rxxx+TlTulYmNj1b17d23ZskXOzs4m7Q0aNNDOnTvVvHlznTt3zqpzv/LKK1q6dKmyZ89u2D516lRdu3bNqnPC+rZu3Wp4vZSkJUuWmL1WwXq6dOmiH3/8UdmyZTPb5/PPP7djRQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA5MqfP7+qVTf+u7+pwblz57Ttb/Pro1hTTEyM3n77bRUsWFC1atWKj/fo0UNz5861Sw2ANbVp0ybB+lmrV69WeHh4omPefvvtBNt9+/ZN1poUY8eOVWxsrMaNGxcf+/DDDzV69Ohkrf2TMWNGvfXWWxo1alSSxyZmwIABVlljbOHChQnWaGnfvr22bNmS4rxIHZydnTVz5kyVLl1a9+/fd3Q5eIavvvoqwd/Sj46OVuPGjZO9vs7q1av1/vvva+zYsfGxTp066auvvkrRWmm9evWK///w8HC1bNlSR48eVfr06SX9dw7v37+/7t27l+w50kINSfXdd9+pQIEC6tGjR3ysd+/e+vbbb60+lzX3JVvsR6n92ggAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjrZx40YtXbpUr7/+erLGDxgwQEOGDFH27NmtXJn1tW/fXtu2bVPBggWTNf7HH39Us2bNVLRoUStXBgAAgBdFeHi4Dh8+nKIcvr6+ypMnj0k8Ojpax48fT1Hus2fPpmg8UrdmzZpp3rx5SpcuXaL97t69q7/++ktbtmzR8ePHdfHiRYWGhioiIkKurq7y8fFRxowZVbhwYZUuXVp169bVK6+8kmjOXr16KSIiQh988IEVH9F/Ll++rLt37yZpjIuLizw9PeXt7a2MGTPK2dn5mWP8/f21Zs0a1alTR7t27Upmtf9p2bKlZs+ebdH6qA8ePIh/DcLDw+Xh4aGMGTMqb968cnd3T3Rs3rx5tXXrVlWoUEGXLl1KUc0lSpTQli1blClTJov6R0dH6/79+4qMjFS6dOmUIUMGubq6PnNckSJFtHPnTlWtWlWnT59+4Wq2l7Fjx+rvv//WxYsXHV1Kov7880+FhIQYvoZdunTR/Pnz7VpPs2bN5OvraxIPCQnR0qVL7VoLAAAAAAAAAAAAAAAAkBo8+zesAACARZycnFS4cGFVrFhRjRs31quvvqoMGTI8c9zevXv12muvKSIiIlnz7tixQ6GhofLx8TFpGzJkiPbv368FCxYkOW/+/Pm1ePFilS1bNj724MEDLVq0SJ07d05WrUb27t2rq1evKkeOHCZtr7/+un799Vd9+OGHio6OTvFcaf25soXQ0FC1bNlS//zzjzw9PQ37lClTRrt379asWbP0ww8/JPvLT97e3nr33Xc1ZMgQ+fv7m+137949devWLcn5J0+erHfeeUeBgYEmbYUKFdLOnTvVsmVL7dixI8m5JalJkyaaMWOGMmbMaNLWqVMnzZo1S2vWrElW7rTKnsfvY7zOjvfzzz8rKCjIsK1Ro0ZavHix2rRpo7CwMItztmvXTuPGjUvwhY9bt27p0KFDql27doprTorXX39dO3fuVOfOnbV///4kjS1btqymTJmS4HrwtF9++UWnTp1KYZXJ9/HHH+vvv/82/DJe69atVa5cOfXp00dr165N9hylS5fWxIkTDY9TSbp9+7Y++uijZOf/888/NW/ePLVu3dqkrVixYtqzZ4/ef/99TZs2TbGxsUnO/+qrr2rChAnKmTOn2T4fffRRir8M/KQGDRqYfU6GDx9ulfPOnDlzNHDgwASxKlWqqFq1avr777+fOd7Dw0N9+/Y1iZ84cULBwcEpru9F0LhxY8P46tWr7VwJnmTufsZW9zKS9O+//+rjjz/Wb7/9Ztjepk0bFShQQD169NChQ4eSlLtGjRqaNGlSon+cq3fv3nrw4EGS8lrTtm3b9NNPP2nw4MGG7aVLl9bhw4c1YsQIDR8+XA8fPkzRfJkzZ9aQIUPUv39/s18Kv337tj777LMUzQM8r9zc3FSiRAk1b95cbdu2VZEiRRLtHxQU9MK/ZwIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAtMIvo5/KlCnj6DLMio2J1TZts+ucX331lTZt2hS/Xbt2bXl7ezv073sDyVG/fv0E2xs3bky0f548eZQ3b9747Zs3b2rGjBnJnv/3339Xly5dVKlSJe3evVu//PKLQkJCLB7/4MEDeXt7x28PGDBAv/32m2JiYpJd05MyZcqk7t27m50vKTZu3Jhg3ZG6deumuD44VnBwsPz9/ZUrVy5JUr58+TRmzBh16tTJwZUhMbly5VKvXr0SxIYPH66tW7emKO+4cePUo0cPvfLKK5L+2z/y58+vCxcuJCtfYGBggvuvhQsX6ty5c1q0aJHat28vSfL09FTHjh01ZsyYFNWemmtIrk8//VTdunWLX4MrR44ceuWVV7R3716rzWGLfcka+1FaujYCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQGrQvn17rVu3TpUrV7Z4TFRUlL788kuNHDlSQ4YMsWF11nPjxg3VqFFDixYtUqVKlZI0dvTo0froo4/UrFkzG1UHAACAF8HRo0dVqlSpFOVo2bKlFi5caBK/detWinPj+dWoUSMtWLBArq6uZvsEBwfru+++05IlSxQREWG23/Xr1yVJu3fv1qxZsyRJAQEBev/999WrVy+5u7sbjnv//fd15coVjRgxIgWPxNSAAQM0b968ZI93d3dXoUKFVK5cOTVt2lSNGzc2u1apl5eXFi1apNKlSydpLfInlS9fXnPmzJGLi4the1xcnFatWqX58+drw4YNunjxomE/Nzc3lStXTm+88Ya6d+8uf39/w37Zs2fXwoULVaVKFUVHRyer5ty5c2vt2rXKlCmT2T5RUVFavHixlixZop07d+r8+fOKi4uLb3dyclL+/PlVqVIltWjRQs2bN5ebm5thrqxZs2rdunWqUKGCbt68+cLUbE++vr6aOXOmatasmeAxpzaRkZGaNWuW+vbta9LWsGFDZc2aVTdu3LBbPV26dDGMz5w5U5GRkXarAwBeBOHh4dqzZ4/ZNuBFwzGB5xn7NwAAeB5wT4PnFfs2AAAAAEs4O7oAAABSi+nTp2vZsmUW/yxfvlx//fWXtm/frjNnzig8PFzHjx/XtGnT1LZtW2XIkOGZc27cuFG1a9fW7du3k113TEyMZs6cadjm4uKiefPmafTo0cqWLZtF+XLmzKlRo0bpxIkTKlu2bIK2oUOH6t9//012rUZiYmI0evRos+19+/bV8ePHNWjQIFWoUEGZMmUy+8v8lsyVlp8rWzl8+LBef/31RD84dnV1VZcuXXTs2DHt3r1bn332mWrVqqXMmTObHePm5qYyZcqoa9euWrhwoW7evKnhw4eb/fKEJIWFhalx48Y6c+ZMkh9HbGysunTpogcPHhi2Z8+eXdu3b9fcuXOT9AWuSpUqafHixVq+fLkyZsxo2GfSpElas2ZNkmtO6+x5/D7G6+x48+fP15EjR8y2N2nSRKdPn1aPHj3k4+Njtp+rq6uaNGmiLVu2aPbs2fL19U3Q/tVXX+nevXtWq9ucv/76S+fPn08QK1mypPbu3augoCBVrVpVzs7m3zq7uLioWrVqmj17tvbt22dyPXjSwYMHNXToUCtVnjw7duzQF198Yba9UKFCWrNmjYKDg9W/f3+VKFHCorw5cuRQ27ZttWHDBh08eFCBgYGG/WJjY9W1a9cUf3nrrbfe0rFjxwzbfHx8NHnyZJ04cUI9e/ZU7ty5n5nP399f7dq10549e7RixQrlzJnTbN+FCxdq1KhRya79aTly5NDMmTPl5ORk0rZ9+3Z9+umnVpln5MiRioqKMolPnDjR7HnvSWPGjFH27NlN4j///LNV6nveeXp6qlq1aoZtq1atsnM1eFJi9zO2uJd5bMyYMZo/f77Z9sDAQB04cEDTpk1TlSpVEr0WpUuXTvXr19eyZcu0efNmFSxY0Gzf//3vf1q6dGmKareGTz/9VCtWrDDb7unpqS+//FL//vuvxo0bpxo1apj98ruRzJkz64033tD06dN1+fJlDRw40OxrFxsbq27dusV/+R5I60aOHKkpU6Yk+2fmzJn6888/tX79eh07dkwPHz7U/v379eWXX6pIkSKJzn3w4EH17NnTTo8UAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADr27JlS4J1fFxdXZUnT54U5XR1dVX69OlTWlqq4YjH4+zsLA8PD7vO6QjWem5dXV1Vo0aNBLHNmzcnOiZXrlwJtg8fPqzY2NgU1dGzZ09VrVpVFSpU0Jw5cxQTE2Px2L179+rAgQPx23ny5FHbtm1TVM+T3nvvPXl6esZvT5gwIdm5tm/fnuCxFSxY0KL1UpB6hYSEqHPnzoqLi4uPdezY0ar7oDU4OzvL09PTcN0be8yd2s7LPXr0kJubW/z2xYsXrbZe1JdffqnPP/9chQsX1ssvv/zMc2pievXqlWB74sSJCf5rrp81pYYakuv69evas2dPgliZMmWsOoet9qWU7kdp6doIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKlBWFiYqlevri+++EIhISHP7L9582aVL19e33//vR2qs66rV6+qWrVq6tOnj65cufLM/gcPHlSdOnXUr18/O1QHAAAAANaXN29ezZo1S66urobtDx48UM+ePVWmTBnNnTtXERERSZ7j3Llz+uCDD1S4cGFt27bNbL9vvvlGJUqUSHJ+W4qIiNDhw4c1Y8YMtW7dWnny5NHw4cMVFRVl2D9Xrlz69ttvkzWXu7u7pk+fnmBN2Cdt375dZcqUUZMmTTR16lRdvHjRbK6oqCjt2rVLgwcPVt68efXbb78lWGv6SYGBgXr33XeTVbOzs7PmzJmjnDlzmu0ze/ZsBQQEqE2bNgoKCtK5c+dMaomLi9O5c+cUFBSk1q1bq0CBAgoKCjKbM3/+/JoxY8YLU7MjVK9eXUOGDHF0Gc/09HrSj7m6uqpdu3Z2qyNr1qxq2LChYdukSZPsVgcAvCguXryowMBAw5/E7pGA5xXHBJ5n7N8AAOB5wD0Nnlfs2wAAAAAsYfybiQAAvIDq1q1rt7liY2P1/fff64svvlBsbGyK83399dfq0qWLPD09TdqcnJzUp08f9erVS+vXr9euXbt0+vRp3b17VxEREfL19VXWrFmVP39+1atXT6VLl5aTk5NJnmXLlumnn36yyZfTx40bpz59+pj9BfKXXnpJw4cPtyjXN998o88//9xse1p/rmxl/fr1at68uRYsWCBvb+9E+5YvX17ly5eP3w4LC1NISIgePnyo6OhoeXp6ytfXV76+vnJxcbG4hocPH+r111/Xjh07kv04jh07pnbt2mnJkiVm527durVat26tixcv6q+//tKFCxd048YNhYaGysXFRV5eXsqWLZuKFi2qatWqKVeuXInOuXnzZr333nvJrjmts+fx+xivs2PFxMTojTfe0J49e+Tl5WXYJ3v27Jo4caLGjRun7du36/z587p586aioqLk5+enggULKjAwUH5+fobj161bpzFjxqhevXo2fCT/efDggbp27ap169Yl+MKYk5OT2rZtq7Zt2yokJEQ7d+7UtWvXdOPGDbm4uChLlizKnj27KlWqZPZxPCkkJETNmzdXeHi4DR+NZb799luVLFlSbdu2NdunVKlS+uWXXyT99xydPn1aFy9eVGhoqB4+fChnZ2dlzJhRGTNmVIECBZQvXz6L5u7fv7+WL1+e4scQGhqqJk2aaPPmzcqTJ49hn4IFC+r333+XJJ0+fVpHjhzRrVu3dPv2bcXExChTpkzKnDmzChUqpFKlShle05+2YcMGtW/fPsX1P+bs7KygoCBlyZLFpC0kJERt2rRRTEyMVea6cuWK/vjjD/Xp0ydBvEiRIvr777/VvXt3/fPPPybjsmXLpl9//VWtW7c2aTt16pSmT59ulfqed7Vq1ZK7u7tJPCoqShs2bHBARXhSYvcztriXeaxz587KmzevKlasaNju7Oyszp07q3Pnzrp9+7Z27dqV4FqULVs25cyZU5UqVTJ7TX7SsmXLNGDAAIvrs6Xo6Gi1atVKK1asSPS9uK+vr3r16qVevXopMjJSwcHBOn/+vEJDQ036fvnll3J3d1dAQIDy5s1rUR1xcXHq3bu3li1bluzHAqQ2b775pkPm3b9/vxo1amR4fAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkFbExcXp2rVryp8/f3wsR44cOnbsmMU5ateurTfffFOVK1dW4cKF49dKio6O1qVLl7Rv3z4tW7ZM8+bN06NHj8zmcXJy0vvvvy9nZ+f42MSJE3X//v2kPzBJTZs2VaFCheK3//zzT505c8Zuj+dpH374Yfz/nzhxQitWrIjfzpAhgzp37qxmzZqpXLly8vf3l/Tf3/i/ceOGdu7cqRUrVmjWrFmKjIy0eM7ChQvrtddeMzuvpZo3b64CBQrEby9evFjnzp1Lch5bPbcVKlRIsA7V7du3dfTo0UTHPLluiySrrLESHByc7LFxcXH68ccfFRQUFB8bPHiwZs2aleK63N3d1a9fv/jt6Oho/e9//1P//v2Tle/Bgwfat2+fAgMD42O1a9fWjBkzUlwrHGfDhg363//+l+BcNW7cOG3btk2XLl1ySE2FCxdW27ZtVa9ePZUsWVIZM2aU9N/xcvv2bR0+fFjr1q3TnDlzdPbs2STnd8R52Zo6d+6cYHvixIlWq2XFihXJul48LUOGDAnWjTp79qw2bdokSdq4caPOnj0bf30pWbKkKleunKJ1/VJrDSl17tw5VahQIX47W7ZsVs1vq30ppftRWro2AgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBqERMTo2HDhmnEiBGqU6eOKleurNy5c8vPz08xMTG6deuWDh06pLVr1+rUqVMJxubIkSNJc9WuXTvF9aYkR0xMjMaMGaOxY8eqRo0aqlq1qooUKSJfX189evRIV69e1YULF7Ry5UqTx1qsWLGUlg4AAAAAduPq6qoFCxYoU6ZMhu3nzp1T48aNdeLECavMd/HiRdWsWVMTJkxQt27dTNrTpUunqVOnqmLFioqNjbXKnNZ29+5dDRkyRGvWrNHixYuVIUMGkz5vvfWWvv76a129ejVJuQcPHmz2feWECRP07rvvKiYmJsk1P3z4UH379tWuXbs0depUOTs7m/T54osv9PvvvysqKipJuQcOHKiqVasatkVFRalHjx7JWqf88uXLat++vdasWaOJEyfK1dXVpE/Dhg3Vs2dP/fHHH899zY7y9ddfa926ddq7d6+jSzErODhY+/bt08svv2zS1rlzZ40aNcoudbRv314uLi4m8b179yo4ONguNQAAAAAAAAAAAAAAAACpjelvUQEAAJvas2eP+vXrpx07dlgt57Vr1/T+++9rwoQJZvu4urqqYcOGatiwYZLzb9myRR06dEhJiYm6e/euOnbsqL/++svwl+mtKa0/V7a0Zs0aVaxYUX/++acKFixo8TgvLy95eXmlaO5jx47pjTfe0NGjR1OUR5KWL1+utm3bavbs2XJzczPbL2/evOrevXuK5tq0aZOaNWumyMjIFOVJy+x5/D6J19mxjh8/rnfeeUczZ86Uk5OT2X5ubm6qWbOmatasmaTc7du3t0aZFtu8ebPeeecdTZ482fDxZMqUSa+++mqy89+4cUMNGjTQ+fPnU1CldbVv3143b95U3759n9nX29tbZcuWVdmyZVM0Z69evaz6ha1z586pZs2aWrt27TOvWwULFkzStc1IUFCQunXrZtVzwdChQw2Pj7i4OHXu3FmXL1+22lzSf1/aq1GjhkqXLp0gXrx4ce3cuVPHjh3TgQMHdPPmTfn4+KhgwYKqUqWK4ReyIiMj1aZNG0VERFi1xudV48aNDePbt2/XgwcP7FwNnuao+5nw8HDVrVtXixYtUoMGDRLt6+/vb3Y/ssSMGTPUvXt3xcXFJTuHtUVERKhJkyb69ddf9c477zyzf7p06VS+fHmVL1/esP1Zz+HTQkND9fbbb2vu3LlJGgfA1PTp0/Xee+8pLCzM0aUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJBi4eHhCbbTp09v0biqVatq9OjRKleunGG7q6urAgICFBAQoFatWmnEiBH69NNPza6lFBcXp0aNGiVYR+nBgwcaP368hY/k/7i5uWnq1KnKlCmTJOnRo0eaNGmSXR/P037++ef4/58zZ45WrFghSerQoYNGjRolf39/w8eRK1cutWrVSq1atdLXX3+tvn37asmSJRbNWbZsWbPzJkWPHj302muvxW8fP35c586ds3i8rZ/bypUrJ9jevXv3M8fcuXMnwXbWrFktmsuW5s2bp++//1758+eXJJUuXVoNGjTQ2rVrU5S3a9euypIlS/x2UFCQLl26lKKcu3btUmBgYPx21apVNWPGjBTlhON9/PHHqlevXvxaL35+fpoxY4Zq165t1/UfcufOrVGjRqlFixaG6ys5OTkpc+bMqlWrlmrVqqVhw4Zp7ty5+vDDD3Xt2jWL53HEedla8uXLp5deeil+Oy4uTlOnTrVrDZbo2LGjPD0947efvhZPnjxZ33zzTfx2r169rLrmZWqpIaXu3r2bYPvx/Y01pPZ9KS1dGwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgNQkPD9fKlSu1cuVKR5dic3Fxcdq8ebM2b97s6FIAAAAAwCbefffdBGtKP+n8+fOqWrWqrl69atU5Y2Ji9NZbb8nPz08tWrQwaS9fvrzeeOMNzZs3z6rzWtuGDRvUq1cvzZ4926TN1dVV7du3T7DW8bN4enrqgw8+MGybP3++evbsmeL1oGfMmKFcuXLp+++/N2nLnDmzXnvtNS1evNjifNmzZ9fnn39u2BYbG6s333xTf/75Z7LrlaRp06bpwYMHmj9/vuG61N9++63mzp1rslavOWmxZkdyc3PT7NmzVbZsWT169MjR5Zg1ceJEjR071iT+8ssvq0SJEjpy5IjNa+jatathfOLEiTafGwAAAAAAAAAAAAAAAEitnB1dAAAAL4rdu3erXbt2CgwM1I4dO6yef+LEiRo6dKjV886bN08NGjRQaGio1XM/aePGjWrfvr3Cw8NtOo+U9p8rWzp69KjKli2r//3vf4qJibH5fLGxsZo4caLKly+vo0ePWi3vggULVLt2bf37779Wy/m0cePGqX79+rp//77N5kgr7Hn8PonX2bFmz56t7t27Kyoqymo5Dx8+rDp16ujWrVtWy2mpqVOnqm3btoqIiLBq3oMHD6pq1ao6ePCgVfOmVFxcnPr166d27drpxo0bNp/v/Pnz+uOPP6ye99y5c3rllVeS9IW7pHr48KH69++v9u3bW3X/qFu3rj755BPDtl9++UUrVqyw2lyPRUREqGXLlrpw4YJhe7FixdSuXTv169dP3bp1U/Xq1eXi4mLSLzo6Wj169ND+/futXuPzqmHDhobxVatW2bkSmPP4fsbewsLC1KRJE/3888+KjY21ev7w8HANGjRInTt3VnR0tNXzp1RERIR69uypdu3a6fbt23ab96+//lKJEiU0d+5cu80JPI+Cg4PVsGFDdenSRWFhYY4uBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAq/Dw8Eiw/ejRo2eO+eijj7RlyxaVK1fO4nmyZMmi8ePHa86cOXJzczPsM378+ATb3bp1szj/k5o2bapMmTLFb8+fP1/37t0z299Wj+dZhg0bppkzZ8rf39+i/rlz59aiRYv08ccfJ2s+R7DHc1usWLEE2ydPnnzmmCtXriguLi5+u0yZMgn2GUeIjY3Vzz//nCA2ZMiQFOV0cnLSwIEDE8SGDx+eopySdPz48QTbRYoUSXFOOF5kZKTatWuXYG2umjVratCgQXaroXHjxjpy5IhatmwpJycni8Y4OzurXbt2Onr0qGrXrp2i+dPKeblmzZoJtk+fPq1Lly7ZtQZL9OzZM/7/Y2JiNHXq1ATtU6dOTbB+YOvWrZUxY8bnroaUcnZOuBy3NddcTO37Ulq6NgIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADW5ufnp6+++sqw7cGDB2rYsKGuXr1qk7ljY2PVpUsX/fvvv4btgwcPtsm81hYUFKQdO3YYtjVs2DBJuRo0aGC4/u3ly5fVo0ePBGunp8SIESN04sQJw7bGjRsnKddHH30kb29vw7ahQ4fqzz//THJ9RhYuXKjvvvvOsM3f3199+/a1OFdarNnRChcurP/973+OLiNRs2fPTrCG+pM6d+5s8/lLlSqlMmXKmMTDw8MVFBRk8/kBAAAAAAAAAAAAAACA1MrZ0QUAAPA8O3v2rH755RdVqlRJFSpU0Jw5c2w631dffaXWrVvrzp07Kc5169YtdejQQW3atFFERIQVqnu2uXPnqlq1atq2bZvN50rrz5UthYWF6cMPP1SZMmUUFBSkmJgYm8yzaNEilSxZUm+//bYePnxo9fzbtm1TyZIl9fvvvys2NtZqeY8dO6ZatWrpvffeU3R0tNXypnX2PH6fxOvsWFOnTlX16tV18uTJFOeaNWuWKlasaLMvy1li3rx5Kl++vPbs2ZPiXOHh4fruu+8UGBio06dPW6E625gzZ46KFCmiX375Rffv37d6/tDQUH377bcqXry41XM/dv/+fbVs2VItWrTQ2bNnrZY3Li5OS5YsUfHixTVy5Eir5ZWkbNmyadasWXJ2Nv1Y5p9//tFHH31k1fmedObMGVWuXFkHDx5M1viwsDA1a9ZMM2fOtHJlz6+AgAAVKlTIsG316tV2rgaJmTt3rt3vZSQpOjpaAwcOVJUqVaxyDXps3bp1Klu2rH766Ser5bSVOXPmKH/+/Priiy9scj16bNeuXWrbtq3q16+vS5cu2Wwe4HkWGhqqoKAg1atXT2XKlNHatWsdXRIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbj4uKi7NmzJ4jdunUr0TGffPKJvv/++wRrEERHR2v58uX64IMP9Oabb6pZs2bq3r27xowZoytXriQY36ZNG02bNs0w99KlS3X9+vX47UqVKqlIkSJJfVjq1q1bgu3x48c75PE8q8bPPvsswZwrVqzQDz/8oD59+mjgwIEaN26czp8/n2Cck5OTvvvuO7Vq1SrJc9qbvZ7bokWLJtg+ceLEM8fcuXNHR44cid92dXXV119//cxxtjZp0iTdvn07frtOnTp65ZVXkp2vRYsWKliwYPz2qlWrdPjw4RTVKJk+x0+/Bki7jh49qiFDhiSIffPNNypXrpzN537ttde0dOlSZciQIUH86tWrmjx5sj766CO9++67+uSTTzRjxgzdvHkzQb+MGTNq9erVqlu3brLmT0vn5afXR7Lm+h/WUrFiRZUuXTp+e82aNfr3338T9Lly5UqCNQDSp0+vzp07P1c1WEPmzJkTbD95r5RSaWFfSivXRgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDaPvroI2XKlMmwrXfv3jp58qRN5w8NDdX7779v2FagQAEFBATYdH5rCQoKMow/uf6tJZYsWaKiRYtq7NixCgsLi48PHDhQoaGhKarxSTExMWbXeC9fvrzFeTJkyKAePXoYtp07d04//PBDsuozZ9iwYbpw4YJhW58+feTu7v7MHGmxZnvbtGmTYbxnz55q2rSpfYtJgnv37mnx4sWGbR07dpSTk5NN5+/SpYthfNGiRbp3755N5wYAAAAAAAAAAAAAAABSM2dHFwAAQFoWHh6uO3fu6MqVK9q1a5cWLFigESNGqHXr1goICNBLL72kAQMG6J9//rFbTfPnz1fx4sX1/fff69atW0kef/HiRQ0ePFj58uXT7NmzbVBh4vbu3atq1aqpcuXKGjdunA4cOKCYmBibzJXWnytbO3LkiNq3b6+XXnpJH3/8sQ4ePJjinCdOnNDQoUNVtGhRtWrVSseOHbNCpebduXNH7777rgoXLqwxY8bo9u3bycoTExOjTZs2qXnz5ipRooQ2b95s5UqfD/Y8fp/E6+xY//zzj0qWLKm+ffvq3LlzSRobFxenLVu2qHr16urYsaMePnxooyotd/jwYVWsWFHt2rXTgQMHkjz++vXr+umnn5Q/f359+umnioqKsn6RVnb37l0NGDBAuXLlUr9+/bRlyxZFR0enKOeBAwfUv39/5cuXT5999pkePXpkpWrNW7JkiQoVKqQ2bdpo3bp1yT7/3Lp1S+PHj1fx4sXVokULs18+Sy4nJyfNnj1b2bJlM2m7c+eOWrduneLn/1muXr2qwMBA9e/fX3fu3LFoTFxcnGbMmKEiRYpo5cqVNq3vedOoUSPD+PXr161yfwXrcsS9zGP//POPAgMDVa9ePa1YsUKRkZFJzhEWFqa5c+cqMDBQDRo00IkTJ2xQqW08ePBAw4YNU65cudSpUyetWrXKKufDs2fPauLEiapYsaIqVqyouXPnWqFa4PkVGxurR48eKSQkRCdOnNCWLVs0ceJEffjhh6pcubL8/f3Vvn17rV+/3tGlAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgdXXq1JG7u3v8dnh4uI4fP262f926dfXNN98kiG3evFlFixZV06ZNNWrUKC1YsEBLly7VlClT1KdPHwUEBGjIkCEJ/hZ6u3bt1K1bN5P80dHRmjZtWoKYUb/EZM2aNcHfzT9+/Li2bdvmkMdjTpYsWTRy5Mj47cmTJytv3rx67bXX9PHHH2vMmDH6+eef9d5776lAgQLq2bOnyd9z/+OPP+Th4WHxnPZmz+e2SJEiCbZPnjxpUY1Tp05NsN27d28NGzZMLi4uFo23hUePHmnMmDEJYoMHD052vqfH/vjjj8nO9aSnn+Ps2bMrQ4YMVskNx/v111+1Zs2a+G03NzfNnj3bpuecggULas6cOXJ1dY2P3blzR2+99ZZy586tHj166Mcff9Tvv/+u77//Xp07d1bOnDnVt29fPXjwIH5MunTptGDBAuXOnTtJ86e183LBggUTbB86dMgu8yZFr169EmxPmDDBsN/T8afHpfUarKFkyZIJtq9du2a13GlhX0or10YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAmtKlS6e33nrLsG3r1q2aPn26XepYsGCBTp8+LUkKDQ3VzJkz1aRJE2XNmlXnzp2zSw0pdeDAAcN4tmzZlC5duiTlOnnypHr37q1cuXJpwIABWr9+vebPn2+FKhPauHGjYTwp6ze3bt1a3t7ehm2DBg0yWac5pSIiIvTRRx8ZtmXNmlWvvvrqM3OkxZrtrV+/fjp//rxh26RJk5QtWzb7FpQEEydONIznzJlTdevWtdm8zs7O6tChQ5JqAgAAAAAAAAAAAAAAAF4Uro4uAAAAexo+fLiGDx/u6DJs7tq1a/rkk0/01VdfqWbNmqpYsaIqVqyonDlzys/PTxkzZpSrq6vu37+vu3fv6sSJE9q/f7/Wrl2rXbt2JZr7448/1scff2zzx7Bz507t3LlTkuTp6Rlfu5+fnzw9Pc2OO3nyZJLmeR6eK1u7cOGCfvjhB/3www/KkiWLKleurAoVKqhAgQIKCAhQ5syZ5eXlJU9PT7m4uCgsLEz37t3TvXv3dPPmTQUHB2v//v3av3+/Tp065ZDHcObMGfXp00fvv/++qlatqqpVq6pcuXIKCAhQ9uzZ5eHhIXd3d8XExCg0NFShoaE6f/68jh49qn379mn16tUKCQmxak3t2rVTu3btrJozMfXr17fbXPY6fp/G6+w4UVFR+u233/Tbb7+pUqVKqlevnipUqKCXXnpJ/v7+8vT0VExMjO7du6eQkBAdPnxYe/fu1ZIlS3ThwgWzeVu0aGHHR/F/YmNjNWfOHM2ZM0eFCxdW06ZNVa5cORUvXlz+/v7KkCGDnJycdO/ePd29e1enTp3SgQMHtGXLFm3dulVxcXEOqTulHjx4oNGjR2v06NHKkCGDatWqpRIlSqhYsWIqXLiwfH195e3tLR8fH7m4uCgiIkKPHj3SzZs39e+//+ro0aPav3+/Nm3apKtXrzrkMcTGxmrevHmaN2+e/P39Vb16dVWpUkVFihRRQECAMmbMKE9PT6VLl04PHz6Mv74fO3ZMhw8f1rZt27R9+3abvoZxcXE2/SKVpaKiojRy5EhNmDBB9evXV9OmTVW8eHFly5ZNmTNn1oMHD3T9+nVdvHhRq1ev1ooVK3Tx4kVHl20V27dvl5OTk93ma9SokWF8zZo1dqshOez9PKUmjrqXeWz9+vVav369fHx81KhRI5UvX15lypRRnjx55OvrKx8fH8XFxcXfc589e1bBwcHatWuX1q1bp4iICKvU4SgPHjzQzJkzNXPmTHl6eqpcuXIKDAzUyy+/rJw5cypbtmzKkSOH/P39E4w7f/68zpw5o8uXL+vy5cs6duyYNm/erMuXLzvokaRc06ZNHV2CoRs3bjjs/FC9enWHzPs0Rz4H0ovz+RYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPbk7Oysb7/9NkFsw4YNioqKMuzv4uKiMWPGJPibxUuXLlWrVq0UHR1tdp6oqCgNHz5cFy5c0Jw5c+LjP/74o+bMmaNHjx4l6D9+/HgNGjQofp7OnTvrk08+UWxsrEWPq0OHDnJ1/b9lK8ePH+/Qx2PkyXUc3n33Xf3+++9m+8bFxWn8+PG6fv26lixZEh/39/dX9+7dNWbMmGfOZ2/2fG7TpUunzJkzJ4j9+++/FtX5+++/q3fv3goICIiPffbZZ3rzzTc1duxYrVixQmfOnLEolzWNHj1agwYNkoeHhySpVatWCggI0Llz55KUp3r16qpYsWL89u7du7V582ar1Gj0d/Fz5cql+/fvWyU/HK9r1646dOhQ/PFVtGhR/fzzz3rvvfdsMt8ff/whLy+v+O3z58+rfv36On36tNkx0dHR+u2337R582atXbtW2bNnlyT5+flpzJgxatasmcXzp7XzctasWRNsW3stspTy9fVVmzZt4rdv3Lih5cuXG/ZdtmyZbty4Ef+YihYtqurVq2vr1q1pvgZrKFu2rAoVKpQgtmXLFqvlT+370mNp4doIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADwInF3d5eXl5cePnyo8PBwR5djlo+Pj1xdXfXgwQOza7inVq1atZK/v79h25AhQ+xay/vvvy93d3etXLlSERERdp3bGq5du2a2zcfHR7dv305yznv37umXX37RL7/8kpLSzDK3Xrufn5/FOdq2bWsYP3HihBYuXJicsp5pzpw5GjZsmAoWLGhYz+LFixMdnxZrtrd79+6pQ4cO2rJli1xcXBK0ZcmSRVOmTNGrr77qoOoSt2HDBp0/f1758+c3aevSpYv++usvm8xbv379+HXQn3T+/Hlt3LjRJnO+iFxcXOTj4yMnJ6c0ed21N56vZ0tr93EeHh7y8PCw6f2xq6urfHx8FB4erkePHtlkjufBi3B8pZXHmBaO47RQo62k5vf1j2t79OgR5ztYJK3uM6n5HJRWrjWPpUuXTt7e3goPD9fDhw8dXU6qkJr3r8f3zrGxsbp3757i4uIcXZKhtHpusZa08Dql5dfoce2RkZF68OCBo8uxCOda+0iL+4aUut9fAE9iXwUAAADMc3V0AQAAwHYiIyO1bt06rVu3ztGlpMjDhw91+vRpm87xvDxXtnbz5k0tXbpUS5cudXQpyRITE6MtW7Zoy5Ytji7lhWGP4/dpvM6OtXPnTu3cudPRZVjNyZMn9fPPPzu6DLu7f/9+mj7fS9Lt27e1ZMkSLVmyxNGlpGphYWE8Tzbk5uamOnXqGLatWrXKztUgORxxL/NYaGio5s+fr/nz5ztk/tTg4cOH2rZtm7Zt25YgnjdvXl24cCFBrEOHDtq+fbs9ywMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBzwsvLSzNnzlRgYGCC+MiRI82Oad68uYoUKRK/feXKFXXs2FHR0dEWzTl37lw1b95cbdu2lSRlyZJFHTt21IQJExL0O3PmjDZt2qTatWtLknLkyKEGDRpo9erVFs3TrVu3+P+PjIzU9OnTHfp4EvPHH3/o999/t6jvn3/+qQULFuiNN96Ij7Vs2VJjxoyxeD57sedz6+PjYxILDQ21aJ6wsDC1bNlSGzdulJ+fX3y8SJEiGjVqlEaNGqWQkBBdvnw5vi1HjhzKnj27rl27ZtEcyXHr1i1NmTJF7733niTJxcVFAwYMUJ8+fZKUZ/DgwQm2f/zxR6vVGBMTo4iICLm7u8fHjF4LpF3Xrl3TW2+9lWCNl3fffVfLly/XypUrrTpXtWrVEqx3Eh4erhYtWli8fsahQ4fUunVrbdy4US4uLpKk119/XWXLltWBAweSVEtaOS97eXkl2L53757N50yKjh07ysPDI357+vTpZq8B0dHRmjFjhgYMGBAf69Wrl7Zu3Zrma0gpNzc3k/1p7969unLlitXmSO370mNp4doIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADwvMqYMaOaNWumxo0bq3Tp0nrppZfk5uYW3/7w4UPdvHlTx44d07p167R27VodPnzYrjW6u7urYcOGatiwocqUKaNixYopY8aMcnJyiu8TGRmpCxcu6PDhw9q+fbuWLFli8Tq6jtC9e3fD+M6dO7Vjxw671mLtdY3tLSIiwmzb43WRU5uwsDDD+JPHXmI8PT1Vs2ZNw7a5c+cmuy5LzJ07V59++qlJvGHDhnJyclJcXJzhuLRYs6Ns375d33//vT777DOTtsaNG6t37952WW87OaZMmaKhQ4eaxFu2bKlevXqZ3fdTomvXrobxyZMnW32uF0WFChVUt25dVahQQWXLllXmzJnl7e2doE9kZKSuXLmiw4cPa//+/Vq+fLl2796d5Lly5swpPz8/k3hYWJguXLiQ3IeQKFdXVxUuXNgkHhsbq+PHjyc5nz2fr8yZMytr1qxm2/PmzWsY9/X1VfHixZM0V2RkpFXupVLLfZzR479+/bpu375t2L9OnTpq06aNKleurCJFiihdunTxbdHR0bp48aIOHDigDRs2aP78+bpx40aSaypXrpzat2+vKlWqqFSpUvLx8Ylvu3DhgoKDg7Vq1SqtXLnSZsdDSpnbr44ePWqV/PY8vhwlLTzG1HIcp4UarXVMJPWclSlTJr355puqU6eOypUrp3z58iU4bznyfX3OnDn1xhtvqFq1aipXrpzy5s2boLaYmBj9+++/OnLkiLZv366lS5fq4MGDhrlcXV2VKVMmk3hISIiio6Nt9hieVqhQIcP3blevXtWdO3dSnN/Hx0d58uQxiR87dswq710CAgLk4eFhEj916pSioqLMjrP1Of+xXLlyqUWLFqpRo4bKlCmj/Pnzm1yHz58/r+DgYK1du1ZLlizR9evXrVpDUqWWc5A5jr7WJPWcljFjRrVo0UL169dXmTJlVKBAAbm7u8e3x8TE6Nq1awoODtbu3bu1ePFiHThwwCq1Jqde6b99oHTp0ipYsKB8fX3l4+OT4PX/9ddfFR4enqx6UvP+5ebmptq1a6tRo0YqXbq0SpQooSxZsiT4PC4uLk53795VSEiIDh48qM2bN2vz5s1mz/W2khbPLdaSVl6ntPwalSxZUs2aNVOFChVUunRp5cqVK8G9QlxcnO7cuaMjR47E17927dpknxeMpNZzbWr8HMNe9zRS6tg3pOfr/YUluF9PKLF9OznHqCM/Z3xaWvg3bgAAACA1cYqz8F3Lkx8+AgAAAACQlgQFBalt27Ym8SVLlqhFixYOqAjAi6BWrVrauHGjSTw2NlZZs2ZN9JcPAZiXN29eky9TVa1aVdu3b3dQRQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAtCIli0nxt9oBmFO6dGmVLl1a0n/nmbNnz2rnzp1WWcAOAAAAAABbKluurDp06ODoMszav2+/Zs+enWifGjVqaPPmzfHb165dU44cOSyeIyAgQG+++aYGDBhgsrD7/Pnz1bp1a7Njly9friZNmsRv9+vXT6NHj7Z4bkkKDAzUrl274rfXrl2rhg0bmvRr27atgoKC4rfnzZunNm3aPDN/uXLltG/fvvjtOXPmqF27doZ97fl4JNPPa69fv66AgAA9evTI4vmeXhPg4cOH8vX1VXR0tGH/1q1ba+7cufHbiT0fiVm2bJlee+21+O0mTZpo5cqVZvvb87nNnz+/zp07lyCWMWNG3b171+K5ChcurPnz58d/5mWJ+/fva9++ffrnn3+0dOnSJP/t+KeP5U2bNql27drx2wEBATp16pRcXFwkSY8ePVKePHksXvehWLFiOnLkSPxn/WfOnFGhQoUS7IdP75NJ/XeBmzdvKnPmzPHb9erV0/r165OUIy0qXLiwWrZsqYCAAEeXYig6OlobN27UihUrzJ5fnrX/PWnixInq0aNH/PaNGzdUsmRJ3bx502wNV69eVfbs2eO3vby89PDhQ7P9Z82apfbt28dv//bbb+rbt6/Z/ubMnDkzwXV+3Lhxeu+998z2d8R52VqOHj2qYsWKxW83bdpUy5cvt3i8r6+vXnrppSTNefDgQcXExFjU99ChQypZsmT8drFixXT8+HGz/YsWLapjx47Fb0dERChXrlwpWuvGUTWk9F7tsWzZsmn69Olq0KBBgvizrsFJZe99KbH96Hm4NgIAAAAAYA9OTk4qX768ChcuHP/eNTg4WMHBwQ6uDE9/lgMAAJDa1apdS25ubtqxfYcePHjg6HIAAAAAAMBzpmy5ssqSJYuOHT2my5cvO7ocAAAAAADwnLp06VKC7wgDgDn8rXYAtsDfagcAAAAAAAAAAAAAAKlZ/T5Suf9bdkz7l0vrfnNcPQAAANbC32pPXfidWiDlWrZsqYULF5rEk7sWZlKZO16f/k5N1qxZ9dlnn+mdd96Ru7t7kubYunWrvvjiC23atCm5ZVokT548+vjjj9WpUyd5e3snefzu3bv13XffacmSJdYvLgXSp0+vu3fvGj7v77zzjiZMmOCAqlLu3Llzyp8/v0m8TZs2mjdvns3mNVoP/bEsWbLo1q1bNps7ufLmzasLFy6YxMPDw+Xh4fHM8fXq1dO6desM20qUKKGjR4+muEZzSpYsqUOHDhm2lStXTgcOHDBsS4s125K54yVfvny6ePGiXFxctGPHDgUGBpr0CQ8P18svv2y172QfO3ZMRYsWNYn7+/srJCQkSbny5Mmj8+fPy9nZ2aStc+fOmjFjRrLrNOLj46Pr16+bHDexsbHKnz+/Ll26lKR8jjqPpQZubm7q1auXevXqpeLFiycrx+XLl/Xrr7/qjz/+0P379y0a06NHD02cONEkfvfuXWXPnl0RERHJqiUxb7zxhubPn28SX7VqlV599VWLcjjq+friiy80dOjQZM2XVFu3blWNGjWSPT613ccZ3SMPGTJEw4cPTxBr2LChRo4caXheNCcmJkbTp0/X559/ritXrjyzf6VKlTRy5EhVrFjRovyxsbGaPXu2PvvsM8P7B0ey9L1HUjjq+LKntPIYU9txbCS11WitY8LSc1bOnDn19ddfq3PnznJzc0vSHLZ+X1+hQgUNGzZM9evXT/Lj37Nnj4YNG6alS5cmiNeoUUObN2826V+xYkXt2rUrRfUmxeLFi9W8eXOT+KRJk/TWW2+lOL+5632VKlW0Y8eOFOV2dXXVrVu35OvrmyB+584dZc2aVdHR0WbH2uKc/6Tq1avr888/V7169ZKUMzo6WjNnztTQoUN1/vz5BG07duxQpUqVTMZYa59JbeegJ6Wma42l57TcuXPr888/V7du3ZJ8Tjt+/Li+++47zZo1S7GxscmuNSn1Ojs7680339Tbb7+tmjVrytXV1WzO5L6/Tq37V/bs2TVw4EC9/fbbypAhQ7Jy7N69W99//72WLFli039/SovnFmtJK69TWn2N3Nzc1KVLFw0cOFBFihRJ8viwsDDNnDlTP/74o9nPtpMitZ5rU+PnGLa+p0lt+4b0fLy/SAru1xNKbN+21zFq7eMzLfwbNwAAKeHk5KTAwEAVKlSI36cFYDFLPrsx/wkmAAAAAAAAgGRr1KiRYXzv3r26ffu2nasBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgOebn5+fgoKCzLY7OzvLy8tLfn5+KlKkiDJnzmzY759//lH37t3N5nF1dVWtWrXit+Pi4hKd15w9e/bo3r178QvYV69eXU5OTiYLUS5atEi3b9+Wv7+/JKlZs2bKmDGj7ty5k2j+bt26JdgeP3682b72fDxGpk6dqkePHiVpvu3btysqKkpubm6SJE9PT+XIkUOXLl1Kcu22Yu99xcfHx2TsgwcPkjTXyZMnVbZsWXXq1Ek9e/ZUlSpVnjkmQ4YMqlWrlmrVqqUhQ4bo7Nmz+vLLLzVz5swkzW3OuXPntHDhQrVu3VqS5OHhob59++qrr76yaPygQYPiF4SWpBEjRli0XyZFaGhognOK0WvxPPHw8ND69etVuXJlR5fyTO+9954ePnyo3r17a+rUqSnK1a9fP9WsWVMFCxaUJGXNmlVTpkzRa6+9ZoVK/1vE/On1Tn777bdk5frtt9/UoUOH+O3XXntN7733nsXj09J5+cnjW5JiY2OTNL5169aJXiONZMuWTTdu3Hhmv8qVK6tkyZLx29u3b9fx48cTHXP8+HHt2LEj/vhyd3dXly5d9MsvvySpxtRUQ3K4u7urbNmyatOmjXr06KEMGTIkaF+wYIFWrlxp1TntvS9Zuh8ZSQvXRgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgOdFixYtNGHChPi1xpOqevXq2rhxoxYuXKguXbooLCzMqvW5ubnpq6++0qBBg+LXl02OwMBALV68WH///be6dOmis2fPWrHK5Ktatarc3d1N4rGxsVq8eLEDKkrbsmTJYrbt/v37dqzEcjlz5jSM37lzx6Lx5tbjvnDhgo4ePZrsuixx+PBhXbp0SXny5DGs68CBA4bj0mLNjhQTE6P27dvrwIED8vLyStCWPn16BQUFKTAwUFFRUQ6q0NilS5e0fv161a9f36StS5cumjFjhlXne/PNN+Xh4WES/+uvv2y+HvnzpGrVqho/fryKFy+eojy5c+fW8OHD9fHHH6t///6aNm3aM8fMmTNHI0eOlLe3d4K4n5+fXn/9dc2fPz9FNRnp2LGjYXzy5MkWjXfk82VPR44cSda4tHof5+LiopEjR6pPnz7JGtutWze1bNlSHTp00IoVKwz7OTs7a/jw4frwww9N1qFPjLOzszp27KjWrVurZ8+emjp1apJrTCtehOMrLTzGtHAcp4Uaba19+/YaP368yb2ipWz1vt7Hx0fjxo1Thw4dkp2jfPny+vPPP7Vo0SK9/fbbCgkJsUpt1jJv3jw1b97cJN60aVM5OTkpLi4uRflff/11w3jTpk21Y8eOFOWuWbOmfH19TeJLlixRdHR0inInV5YsWfTHH3+oRYsWyRrv6uqqrl276s0339TgwYM1duxYK1doKrWfg9LCteZpXbt21ejRo03eF1iqaNGimj59ugYNGqSOHTsqODjYyhUazxcYGGj13Kl5/3JyctKAAQM0bNgwpU+fPkW5AgMDtWjRIu3YsUOtWrXS1atXU1zfk9LiucVa0srrlJZfowYNGmj8+PHKly9fsnN4eXmpZ8+eeuutt/Trr7/qww8/tGKFxtLauTapkvs5hjXZYt/45JNPFB4ebsUqjaXW9xfJwf166mPN4zO1/xs3AAAAkJo5O7oAAAAAAAAA4HnUqFEjw/jq1avtXAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPP/Sp0+vtm3bmv1p3bq1mjRpoqpVqypz5syGOaZNm6a6devqwYMHZucpXLiwvLy84rePHDmiW7duJbneuLg4nTx5Mn7bw8NDefPmNekXGRmpGTNmxG+7u7urbdu2ieZ2c3NT+/bt47fPnDmjjRs3mu1vz8djZO3atUmeLzIyUmfPnk0Qy5QpU5Lz2JK99xU3NzeTWHR0dLLmmz59uqpWrarcuXPrjTfe0IgRI7RmzRpdu3btmeMLFCigGTNmaO3atcqQIUOS5zfy448/Jtju06ePPDw8njkuR44c6tChQ/z2zZs3NXXqVKvU9KSIiIgE2+nSpbP6HKnJ6NGjVblyZUeXYTFPT0+NHTtWJUuWTFGehw8fqn379gmOqyZNmqhXr14pLVHSf8fOk+exa9eu6cSJE8nKtXv3boWFhcVv58mTx+y1z4gtz8u5cuXSiBEjkvVjyWNwcnJKUt2FChVKUv+keHrfmDhxokXjnu7Xs2fPNF3DY5kzZ9bu3bsT/Tl06JAuXryosLAw7dy5U/379ze5lqxZsybBud1WUtO+ZCS1XxsBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHieZcgqlWogVWkv1ewuBbaU8r8iuZguM4w0bvDgwVq0aJH8/f1TnKtVq1bauXOn8ufPn/LC/r/cuXNr165d+uSTTwzXuU6OatWqKTg4WE2aNLFKvpSqW7euYfzgwYPJWjf8RVegQAHDeEhIiCIjI+1cjWWqVKliGL9+/bpF40uUKGEYP3jwYLJrSorg4GDDuLm6EmtLzTU72unTp/XBBx8YtpUpU0bffvutfQuy0KRJkwzjtWvXVu7cua06V5cuXZJUA0x16dJFmzdvVvHixa2WM2PGjJo6daoWLVokd3f3RPuGhYUpKCjIsK1r165Wq+kxPz8/NW7c2CQeEhKipUuXPnO8o58vezpy5EiSx6TV+zhnZ2ctXLhQffr0SVEeX19fLVu2TG3btjVpS5cunVasWKEBAwYkec35J3NMmTJFn3/+eYrqTK1ehOMrLTzGtHAcp4Uabe2bb77RrFmz5OXlleJc1nxfX7x4cR08eFAdOnRIcS5JatmypbZt26YcOXJYJZ+1LFu2TOHh4SbxrFmzqlKlSinKnT17dr388suGba+99lqKcktSixYtDOPz5s1Lce7kqFChgg4fPmy2rqTw8vLSmDFjNH78eDk7O1uhOmOp/RyUFq41Txs5cqSmTJkib2/vFOcqVaqUdu/ebZP3Eo9VrFhRO3bsUGBgoNVzp+b9K0OGDNqwYYNGjBih9OnTW6U2SapcubL27dunihUrWi1nWjy3WEtaeZ3S6mvk7OysMWPGaM2aNcqXL59Vcrq4uKh///4qWrSoVfKZk9bOtcmRnM8xrMWW+0ZwcLDN94/U+v4iubhfT32sdXym9n/jBgAAAFK71P/pFgAAAAAAAJDGZM+eXWXKlDFsW716tZ2rAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYExUVpeXLl6tKlSrq2rWrwsLCEu1fsGDBBNtnzpxJ9tx37txJsJ05c2bDfuPHj0+w3a1bt0TzNmnSJMHC7xMmTLC4Jns8nqcdPXo0WfPdvXs3wXaGDBmSlcdWHLGvWNuVK1e0cOFCDR48WI0aNVKTJk3i2zZu3KiffvpJa9eu1b1790zG1q9fX+vXr1e6dOlSXMe+ffu0YcOG+G1/f/9nHgeS9P777yeYf9SoUYqIiEhxPS+ycuXKqUePHo4uI8k8PDz09ddfpzjP7t27NXTo0ASxX375RUWKFElx7qdzHDx4MNm5YmJidOTIkUTzJ8aW5+Vs2bJp4MCByfrJlCmTSb4HDx4k2Pbw8EhSzYUKFUpSf0v5+vrqzTffjN9+8OCB5s2bZ9HYuXPnJnhchQsXVq1atdJkDU9ydXVV+fLlE/0pWbKk8uTJIxcXF5PxUVFRGjZsmJo2barIyMgU1WIkte5L5nBtBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADA/nIVl9r9JPWaLjX+UKrWWarYWqr9jtT6W6nvPKlGNymdp6MrhTX07t1bP/74o1VzlixZUmvXrpWPj0+KcxUqVEjbt29X2bJlLeofHR2tR48eWdTXy8tLS5YsUZs2bVJQoXWULl3aMP7333/buZLnQ8uWLQ3j+/bts3MllmvXrp1hfM+ePRaNL1asmGH88OHDya4pKQ4dOmQYL1q0qNkxabHm1GDixIn6888/DdsGDhyo2rVr27miZ1u8eLHu3LljEnd2dlaHDh2sNk/+/PlVvXp1k3hISIiWLFlitXmeZ926ddOUKVMM1+A28ujRIz18+FBxcXEW9W/RooXWrFkjd3f3RPuNHz/eMN6wYUNlz57dorks9eabbyZYE/ux2bNnP3Ot8dTyfNnLkSNHktQ/Ld/HjRs3Ts2aNbNKLicnJ02bNk0VK1ZMEJ8zZ44aNWpklTm+/vprdezY0Sq5UosX4fhKC48xLRzHaaFGW/v000/16aefWjWnNd7XlylTRps3b1ZAQIAVK/vvfn39+vXy8vKyat6UePDggdasWWPY1rx58xTlfu211+Tk5GTYVqpUKeXNmzdF+V9//XWT2N27d7V+/foU5U2OmjVrav369cqaNatV87799tv6448/rJrzsdR+DkoL15qnjRw5Uu+//77V8klSunTpNHnyZPXr18+qeSWpQIECWr16tfz8/KyeOzXvXxkzZtSmTZtUq1Yti/rHxsYqLCxM0dHRFvXPnj27li9frjx58iSrvielxXOLtaSV1ymtvkbp06fXn3/+qffee88m+bdv366qVavaJHdaO9cmV1I/x7AWW+8bj68Ptto/Uuv7i5Tgfj31scbxmdr/jRsAAABIC1wdXQAAAAAAAADwvGnQoIFh/O7du9q5c6edqwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA519sbKxu3LiRaJ906dIpU6ZMCcaUKVNGx44ds3geX1/fBNulSpVSUFBQ0or9/0qWLJlg28vLy7DfsWPHtH37dlWpUkWSFBgYqBIlSphdLL5bt27x/x8dHa2pU6daXJM9Hs/Tbt++naz5Hj16lGDbyckpWXlsxd77SmRkpEnM1dVV0dHRyZrzWfbu3atBgwbFz9OoUSN98cUXCgwMjO9Tvnx5fffddxo4cGCK5/vxxx9Vp06d+O2BAwfq999/V2xsrGF/b29v9erVK347LCxMY8eOTXEdRtzd3RNsR0RE2GSe1MDT09PRJSRbunTprJLnu+++U+PGjePPyR4eHpo9e7YqVqyYouMtY8aMCbaTe240N97Pzy/ZYy3liPPynTt3Emw/fe59lhEjRmjChAmJ9pk1a1aSnj9J6ty5szw8POK358yZo7CwMIvGhoWFae7cuerRo0d8rFevXtq0aVOaq8Ea7t27p5kzZ+q3337T8ePHbTaPrfel5OxHz5Kar40AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADxvqnaSqrSXEluyM52HVKmNVKyWtPBL6dZ5e1UHa6tUqZJGjRplEo+Li9OWLVu0ZMkS7dmzR1euXNHDhw+VIUMGZcmSReXKldOrr76qhg0bysXFxTB3oUKFNG3aNLVs2TLZ9WXKlElr165Vnjx5zPYJDg7W3LlztXbtWp05cyZ+/c506dIpc+bMKl++vBo0aKAOHToYrrvp6uqqadOm6fz58/rnn3+SXWtKFSpUyDB+8OBBO1eS9hUvXlzNmjUzbPvzzz/tXI1l6tevr/Llyxu2bd++3aIcuXLlMowfOnQo2XUlRXBwsGHcXF2JtaXmmlOLHj16qGLFisqePXuCuJOTk6ZPn65SpUrp7t27jinOQGRkpGbNmqU+ffqYtHXt2lU//vijVebp1KmT4brjs2bNUmRkpFXmeJ4VKFBAv/32m9m12//991/Nnj1ba9as0eHDh3Xjxo0Ea01nypRJhQsXVrVq1dSqVStVqlTJME/NmjX166+/qmfPnmZr2bNnjw4ePKgyZcokiLu4uKhDhw76+eefk/EIjXXs2NEwPnny5ETHpZbn6/Lly9q5c6fZOv39/Q3vM0JCQnTy5MnEHqKJw4cPW9w3Ld/HtWzZUu+8845J/OzZs5o2bZo2b96sCxcuKDw8XJkyZVKOHDlUp04dvfHGGypcuLBhznTp0mnSpEkqW7asoqOjNWDAALVo0cKk3927dzVnzhytXLlSx48fV2hoqLy9vZUtWzZ9++23qlmzptm6x44dq23btuncuXPJf/CpRGo5vmwpLTzGtHAcp4Uaba1evXr6+uuvTeKOfl+fPXt2rV69WpkzZzbbJzw8XBs2bNCyZct07NgxXb9+XXfu3JGXl5eyZcumfPnyqXHjxmrSpIn8/f0TjC1WrJjGjRuniRMnJrk2W5k7d67he9HmzZtryJAhyc77+uuvJ9repEkTjRs3Llm5y5UrZ3j8/Pnnn4qKikpWzuR66aWXtGTJEnl7e5vtExERoQ0bNmjlypUKDg7W9evXdffuXbm7u8vf31+lSpVSvXr11KxZM2XIkCHB2Lfeesvqn7Gk9nNQWrjWPK1z5856//33TeKRkZFas2aNVq1apQMHDujatWt6+PBh/PmiUKFCatSokRo3bmz4PEr/vV8eOXKkzp49q+XLl6e4Vum/9yeLFi0yO2dKpPb9a9asWSpXrpzZ9q1bt2rBggXatm2bTp48qdDQ0Pg2Hx8fBQQEqFatWurcubNeeeUVwxyZM2fWwoULVbVq1WSfk9LiucWa0sLrlJZfoxkzZui1114z2x4bG6sdO3Zo2bJl2r17t65du6aQkBB5enoqW7ZsKliwoF599VU1atTI8BjNmDGjVqxYocqVK+vYsWNWq9vR59rU+jmGNdl635Bst3+k1vcX1sD9umWSc4w64vhM7f/GDQAAAKQVro4uAAAAAAAAAHjeNG7c2DD+119/JfglTQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAddy4cUM5cuRItI+7u7tOnjypvHnzSpKcnZ01YMAAvfXWWxbP4+HhkWC7QIECKlCgQNILTqLx48erSpUq8dtdu3bVoEGDTPplyZJFr776avz20qVLdf36dYvnsdfjeVJUVJRd57MXe+8roaGhJjEfHx/duXPHZnM+Fh0dreXLl2vlypUaM2aMevXqFd/Wu3dvDR8+XDdu3EjRHGvXrtXBgwdVpkwZSVJAQIDeeOMNzZs3z7D/O++8I19f3/jtiRMn2uy5yJAhQ4Jto9fieREXF+foEhwuNjZWHTp0UHBwsHx8fCRJL7/8sr755ht99NFHyc7r6emZYDul+9HT4728vCwem5bOy08f108e95bYvn37M/uEh4cnKack9ezZM8H2xIkTkzR+4sSJ6tGjR/x2ixYtlCVLFt28eTNN1fCkyMjIZz7fERERunPnju7evatjx45p9+7d2rdvnyIiIpI1Z1LYel9Kzn70LKn52ggAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwPOkXm/p5aaW9/fNJnX8RZr5oXTrvM3Kgg2NHz9eLi4uCWIrVqzQkCFDdOTIEZP+169f16lTp7R9+3aNGTNGxYsX16+//qq6desa5m/RooXefPNNzZ8/P1n1zZ07V/nz5zdsu3Tpkj788EMtWLDAsD0yMlL//vuvli5dqqVLl+qTTz7RkCFD9NFHH8nZ2TlBX3d3dy1YsEBFixZVWFhYsmpNCWdnZwUEBBi2nThxws7VpG2+vr6aOXOm3N3dTdpCQ0M1e/ZsB1SVOG9vb40bN86w7dGjR1q0aNEzc7i6uipTpkyGbVevXk1RfZa6du2aYTx79uyG8bRYc2py+/Ztde3aVatWrZKTk1OCtty5c+uPP/5QmzZtHFSdsYkTJ6pPnz4m8aJFi+qVV17R3r17UzxHly5dDOOTJk1Kce4XwciRI03Wopf+W/f+iy++0E8//ZToWtwhISHauXOndu7cqZ9++klVqlTRuHHjVLp0aZO+77zzjhYsWKB169aZzTdhwgT99ttvJvGuXbvq559/tvBRJS537tyqXr26SfzgwYPav39/omNTy/M1efJkTZ482ew8LVu21MKFC03iGzZs0Jtvvml2XEql1fs4T09PjR49OkEsNDRUAwYM0KRJkxQbG5ug7dq1azp69KjWr1+vzz//XL1799aIESMM70VKlCih7t27a/369fruu+8StMXFxWnkyJH66quvdP/+fZOxp0+fVq1atVS/fn1NmDBB+fLlM+nj4+Ojn376Sa1atUrOQ09VUsvxZUtp4TGmheM4LdRoS+nTp9fEiRNN6nX0+3onJyfNnz/f7H11bGysJk2apE8//VQ3b9407HP27Fnt2LFDc+bMUbp06dS/f3999tln8vb2ju/TqVOnVPWeedmyZQoPD1f69OkTxAsXLqwiRYokq1Z3d3ezr81jTZs2Nfue8llatGhhGE/u5zjJ5erqqkWLFsnPz8+wPSYmRpMnT9bQoUN15coVwz4XL17U/v37NX36dPn4+Khfv3767LPPErweP/74o0JCQqxWd2o/B6WFa82TsmfPrk8++SRBLC4uTuPGjdO3336rf//913Dc4/PF9OnT5eXlpf79+2vQoEHKkCGDSV8nJyfNmjVLvr6+ya7zSX369FGZMmVM4nfu3NGff/6p5cuX69ChQ7p+/bru3buXpNypef/q27evGjdubNi2b98+vfvuu9q1a5fZ8aGhoQoODlZwcLB+/fVXtWzZUlOmTDF8zQIDA9W1a1dNmDDBotqelFbPLdaSFl6ntPwaff7553rjjTfMtq9evVqDBw/WoUOHDNsfn7tmzJghLy8vffjhhxo8eHCCex3pv8+7V6xYobJlyxq+V0wqe55rS5QoocuXL5u0p9bPMazFXvuGZP39I7W+v7AW7tctk5xj1BHHZ2r/N24AAAAgrXB+dhcAAAAAAAAAlnJyclL9+vUN21atWmXnaoDnz6NHj7R69eoEP3fv3nV0WQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEgDIiIi9PHHHyeIdevWTWXKlHFQRZabN2+e7t27F7/dqVMnk4XeJalDhw5ydXWN3x4/frxd6oPjhYaGmsR8fHzsWkNsbKx69+6tvXv3xsfSp0+vli1bWiX/8OHDE2wPGTLEsJ+rq6v69+8fvx0dHa1ffvnFKjUYefp5Nnotnhc7d+7Upk2bHF1GksXFxWns2LFWy3f+/Hn16dMnQWzQoEGqWbNmsnM6OTkl2I6Li0t2Lum/4zE1OnbsmF555ZVk/Vy4cMEk363/x959h0dRvX8f/6RDEnqVIkiX3os0pQhIAogiglSliKhYQUHEhnxVsGABqTZAKSKhQxClKKBUpUak94SWQnqeP3zIj2Vnk832Td6v68olc5+Z+9wzc+bs7GTNRkebLFerVs1Vu2JRy5YtVatWrczlU6dO6erVq6pWrZrVP1euXNGpU6cycwQGBmrQoEFeVcPtLl++rPvuuy/Ln86dO6tPnz4aMWKEpk6dqt9//11JSUk295kTnjiWrOGpr40AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOQWdTtLDcNzvl1gsPTQm//9F96nTp06mf9OTU3V8OHDFRYWpv3791u1/YEDB3T//fdr7ty5FtcZPXq0TbX169dPHTp0MGzbunWrGjVqpMWLF1ud7/r16xo3bpy6du1q+P3M5cqV05tvvmlTrfYqU6aMAgICDNvOnDnj4mq8V7Vq1bRlyxY1aNDAsH3ixIm6fPmyi6vKmr+/v5YsWaLKlSsbtn///fe6du1atnmKFCli9v3RN7nq+8ivX79uGC9cuLBhbd5Ys6dZu3atPvvsM8O2Rx55RP3793dxRVnbu3evdu/ebdg2cOBAu/O3aNHC8FratWuX9u7da3f+3K5EiRLq0qWLYVufPn00ceLEHH8X92+//aYmTZroxx9/NGx/6623stz+u+++040bN8zitWvXtjjX51Tfvn0Nr/c5c+ZkuZ0nHi9P4s33cU888YTKlCmTuXz8+HE1bNhQM2fOVHp6epbbpqen69NPP1WvXr2UmppquM7zzz+vt99+W4GBgZmxGzduqGvXrnrhhRcsvjbdtH79erVt29biPWL37t1Vrly5LHN4urxwfXnDPnrDdewNNTrbkCFDVKFChcxlT3lfP2TIELVq1cqwLS4uTh06dNCwYcN06dIlq/IlJyfrvffeU926dfXvv/+atL3yyis5qs2Z4uLitHbtWsO27t2725Szffv2Cg7O+qFbu3btsl3HEqO6rl+/rnXr1tmUz1ajRo1S3bp1DduuXLmi+++/X8OGDbP6GUlsbKwmTpyoBg0a6NixY5nx4OBgh71Oevoc5A2vNbcbMWKEChUqlLl87do1tW/fXiNHjtTZs2etyhEfH6933nlHDRs21MGDBw3XKViwoF113hQcHKzXXnvNJJaUlKT33ntPd911lwYPHqwlS5boyJEjVj3buZUnj6+CBQtqwoQJhm3fffedmjZtqh07dlhdmyT9+OOPatmypcXj9PLLL9v0nMYb5xZH8Zbz5K3nqHbt2ho/frxh2837sS5duuivv/6yKl98fLzefvtt1atXz3Duuuuuu/T+++/bVfNNrpxrP/roI4fU7E1cPTYkx44PT31/4Sjcr+cunvw7bgAAAMCb+Lu7AAAAAAAAACA3adKkiYoVK2bYZulDCwCsd+nSJYsfkAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACyM3/+fD333HNq0qSJJMnX11cfffSR2rVrZ9X2KSkpJssbN27U999/75Dajhw5YrHtxo0bmj9/vkaMGCFJKlWqlDp37qyVK1earDd48ODMf588eVLr1q3LUQ2u2h9v5e9v/deAunqsxMbGmsUKFCjgkP5yIj09XR9//LG+/fbbzFjbtm01ffp0u3P/8MMPevfdd1WhQgVJUsOGDXXfffdp48aNJuv16dNH5cqVM9nu5MmTdvdvJCAgQIGBgSYxo3ORW6Snp6tv377at2+fihcv7u5yrPbhhx9q1apVDs35zTffKCwsTL169ZL03+vJt99+qzp16ujatWs5zpeammqyfPu4yqnbt789v7vcuHFDu3btcli+P//802S5cePGDsttq+HDh5ssly9fXocOHXJI3g8++MBravA2njiWrOGJr40AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOQWgcFS28dt375QKal5b2nTXMfVBNdKT09X79699eOPP9q07eOPP67KlSurTZs2Zu2NGzdWmzZttGnTJqtz5suXT++//75h2969e9WhQwclJibmuFZJWrNmjQYMGKClS5eatT3zzDP64IMPdOHCBZty2yqr7+l2dS3eqF69eho2bJiGDRtm8Tva165da3FMuUtoaKh+/PFHdezY0bA9Li5Or732mlW5goKCLLa56vvIs+onMDBQSUlJJjFvrNkTvfzyy2rfvr1q1qxp1vb5559r8+bNOn78uOsLs2D27Nn67LPPzOJ9+vTRCy+8YNf3lA8cONBin8heeHi44Rz6ww8/aOHChTbnTU5OVu/evbVp0ya1aNEiM75+/fpsv0v82rVrWrx4sfr372/WNnjwYO3evdvmum7q16+fWSwlJUXz5s3LcjtPPF6ewtvv4279nvSYmBjdd999OZ5Hly9frilTpmjMmDFmbTVq1FCNGjUyl9PT09WzZ0+tWbPG6vwnTpzQwIEDFRkZadbm5+enJ5980up7CE+UF64vT99Hb7iOvaFGVyhfvnzmvz3lfX1oaKjeffddw7bY2Fi1a9dOf/75Z45rlKRjx46pVatW2rx5sypXrpzZnydZuHChunfvbhbv0aOHTe9Jw8PDs10nKChIHTp0UERERI5yV6xYUXXr1jWLR0REKCUlJUe57FG4cGFNmDDBsO3y5ctq3ry5oqKibMp96NAhtWzZUjt27DB5jbeXN8xBnv5aYyRfvnyZ/05ISFC7du20a9cum3IdPXpUzZo10y+//KKGDRuatbds2VJbt261uVbpv/exxYsXz1yOjo5W9+7d9dtvv9mV19PHV0BAgBYsWKAhQ4aYnLNVq1YZvnez1t9//62RI0fqu+++M2urWrWqunTpolWrVlmdzxvnFkfyhvPkzedo+vTpCggIMIunpKSoa9euWr9+vU15//33XzVr1kzr1q1T8+bNTdqGDRumOXPmaMeOHTblvsmVc+3DDz/skPnWm7hjbEiOGx+e+P7C0bhfz31y61gFAAAAXMX4k3YAAAAAAAAAbHLu3Dl17drVLJ6SkqIzZ864oSIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwK2ef/55bdmyJXP5vvvuU3h4uJYvX57ttleuXDFZPn78uGbMmOHwGo3MmDFDI0aMyFwePHiwVq5cmblcv3591a1bN3N51qxZysjIyFEfrtwfd/L19bVpu5IlS1q9rqvHSkpKii5evGhSY7ly5bR//36n9WnJb7/9ZrJcrlw5h+RNS0vThx9+qE8++SQzNmbMGG3cuNFkvZdfftlk+f3333dI/0bKly9vFjt9+rTT+vME586dU6VKlRQWFqbu3burWLFi7i7Jop07d2rhwoXatWuXU/IPGzZM99xzj8qWLSvpv/Ewffp09enTJ8e54uLiTJYLFy5sV21FihQxWY6NjbUrn6f6/fffTZbr1q2r4OBgJSQkuKWewoULq1evXk7JXblyZXXo0EGRkZEeX4M38rSxZC1PfG0EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOQ+ZcuW1RNPPGHYlpGRoYkTJyo9Pd3FVQEAADhfnful/AXty9Gwm7T1OyktxTE1wbUmTJigH3/80a4cgwYN0uHDhxUQEGDW1r17d23atMnqXH379tUdd9xhFr9+/boefPBBJSYm2lXrTz/9pFmzZmnIkCEm8cDAQI0cOVKvv/66XflzKiQkxDCekZHh8d87aqtatWqpTZs2OdomICBAoaGhKlCggCpUqKDatWuradOmqlSpUpbbrV+/Xg8++KAyMjLsKdmhGjdurHnz5qlatWoW1xk9erTOnj1rVb58+fJZbHPV9z5n1U++fPmUlJRkFrMllyPltGZPlJSUpD59+uiPP/5QYGCgSVuBAgU0b948tW7d2mOeZ8ybN09TpkxRUFCQSbx48eLq3LmzVqxYYVPewMBA9e7d2yyemJio+fPn25Qzr6lcubJh/Ouvv7Y7d2pqqgYPHqzdu3dr8eLFmjx5svbt22fVtjNmzFD//v3N4n379tULL7yg1NRUm+uqXbu26tSpYxZfvny5YmJistzWU4+XJ8hN93EDBw7U8ePHbdr2nXfe0dChQ1W0aNEs13vvvfe0Zs2aHOffsGGD1qxZo86dO5u1derUSa+99lqOc3qKvHB9efo+esN17A01upqnvK8fOHCgihcvbtj27LPP6s8//7SrxnPnzqlfv37asmWL/Pz87MrlDBEREUpKSjK7323evLlKliypixcv5ihfWFiYyXJqaqq2bdumVq1amcTDw8MVERGRo9zdu3c3jC9cuDBHeez1+OOPq0CBAmbxjIwM9evXT1FRUXblP3funB566CH99ttvDhsz3jAHefprTXaeeuop7dq1y64csbGxeuihh7Rr1y4VKVLEpO25557T1q1b7cp/6zOdq1evqkWLFvrnn3/syil5/viKiYnRM888o4kTJ+qll17Sk08+qZSUFA0YMMCuuqT/nhmMGTPG8H1a+/bttWrVKqtzeePc4kjecJ689Ry1bt1aLVu2NGx7+eWXtX79ervy35y7du/erZIlS2bGfXx8NHbsWPXo0cOu/Ldy9lwrOWa+9RbuGhuSc8aHp7y/cDTu13Of3DpWAQAAAFfxd3cBAAAAAAAAQG5y6tQpnTp1yt1lAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAs2Lp1q5YsWaKHHnooMzZlyhStXr1aqampWW575coVk+VSpUo5pUYje/bs0c6dO9WoUSNJUnh4uIoVK6aYmBhJ/31h+01paWmaM2dOjvtw5f64UkpKislySEiITXlycnzcMVYOHz6skiVLZi5Xq1ZNa9eudXq/t4uOjjZZLlq0qMNyz5o1SxMmTMjM2alTJ9WtW1f79u2TJHXu3Fl16tTJXH/t2rWZbc5QrVo1k+WzZ88qLi7Oaf15itjYWC1YsEALFixwdyludfXqVQ0YMECRkZHy8fGRJD366KNavny55s+fn6NcZ86cMVkuW7asXbWVK1fOZPncuXN25fNUhw4d0pUrV1SkSBFJUkBAgPr06aPZs2e7pZ6BAwcqX758Tsv/5JNPKjIy0uNr8EaeNpZywtNeGwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuc9DDz2kN99807Btz549evvtt11cEQAAgGtUaW5/jsD80p11pWM77c8F19q7d68mTZpkd55jx47pp59+Uq9evczaWrVqlaNcTz/9tGF86tSpOnbsmE313W7SpEl6/PHH5evraxIfMGCAXn/9dYf0YS1L30eelJTk0jpc6fXXX3f6cU5NTdXEiRP19ttvKy0tzal9Watw4cJ64403NHLkSPn7+1tc79NPP9W0adOsznv7OL5VcnJyjmq0VVbj1c/PzyzmjTV7qn379mns2LGaPHmyWds999yjsWPH6p133nFDZeauXr2qpUuX6tFHHzVrGzhwoFasWGFT3m7duqlw4cJm8aVLl+rq1as25cxrypQpYxg/evSoQ/IfPnxYpUqVUmxsbI6227Jliw4dOqQaNWqYxIsVK6auXbtq2bJlNtfUr18/w/icOXOy3dZTj5cnyC33ccuWLdPKlStt3j4uLk5LlizR0KFDLa5z5swZu545z5kzR507dzaL16tXT0FBQV57L5kXri9P30dvuI69oUZX8qT39SNHjjSMr169Wl999ZU95WXatm2bPv30Uz333HMOyedIcXFxWrt2rbp162YS9/HxUXh4uGbPnm11rvr166tcuXImsV9//VXff/+92fno2rVrjmvt0aOHWSw2Nlbr1q3LcS57jBgxwjD+1VdfafXq1Q7pY8eOHfryyy/11FNPOSSfN8xBnv5ak5XNmzfr66+/dkiu48ePa/To0Zo5c6ZJvEePHipdurTOnz/vkH4ef/xx/fPPPw7J5Q3jS5LOnz+vl156SZMmTVLNmjUVExPjkNq+/PJLffbZZ2bx1q1b5yiPN84tzuDJ58lbz9FLL71kGI+MjNQnn3zikD7Onj2roUOHmj3z6Natm6pWraqoqCi7+3DFXCs5fr71ZO4cG5Jjx4cnvb9wNO7Xc5fcPFYBAAAAV7H86S0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBcaPTo0UpOTs5crlq1qkaOHJntdocPHzZZbtiwocNry8qMGTMy/x0YGKg+ffpIkvz9/fXYY49ltq1evVpnzpzJcX5X74+rXL161WS5ZMmSOc5RqlQp3XHHHVav746xcujQIZPlatWqWb1thw4d1LZtW4fUERQUZLKcmJjokLySlJCQoC+++MIkNnr0aMN/S9J7773nsL6N3H6Mbz8HyP1+/vlnffjhhyaxadOm6c4778xRnv3795ssN2jQwOxaslbRokVVtWrVzOXU1FSzOSk3WbRokcnyiBEj3FSJNHz4cJPl1157Tb1797b556WXXjLJ1717d5UqVcrja/BWnjSWcsLTXhsBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALlPly5dLLatWbPGhZUAAAC4VvEKjslTLGdfdQoPMX78eKWlpTkk19y5cw3jDRs2VHBwsFU57rzzTjVo0MAsnpCQoI8++siu+m7177//KjIy0ixeoUIF3X333Q7rxxqWvuM3NTXVYX1UrlxZDzzwgEN+rD2X7nT48GHVrFlTb7zxhsPGtz3y58+v0aNH699//9WoUaPk7+9vcd1p06Zp1KhRLqwOucGUKVP0888/G7ZNmDBBTZs2dXFFls2ePdswHh4ersKFC9uUc+DAgTnqC+YsvRZlZGQ4rI/Y2Fibtps5c6ZhfNCgQXZUI/Xp08csdv78eaueA3ry8XKn3HQf9/bbb9udY8mSJVm2f/zxx7px44bN+VesWKHk5GSzeEBAgOF58BZ54fry5H30huvYG2p0NU96X2/p2EycONGuum43ZcoUj3ivZ2ThwoWG8R49euQoT1hYmFksIiJCK1asMJsv7rjjDjVs2NDq3EWKFFHr1q3N4suXL1dSUlKO6rRHtWrVVKVKFcO2KVOmOLSvd955xyHPWbxlDvLk15rsOOI+7FbffvutLl26ZBLz9/dX586dHZJ/6dKlWrp0qUNyecv4ulVMTIw2b97sqNIsPtto0KCB/Pz8rMrhjXOLs3naefLWc1SgQAGLnyuaNGmSQ/q4KSIiwizm4+Ojhx9+2CH5XTHXSo6dbz2Zq8fG/v37zeKOHB+e9P7CGbhfzz1y+1gFAAAAXMHyJ9gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAByoX///VefffaZXnjhhczYhAkT9O233+ry5csWtzt//ryOHj2qypUrS5JKly6tmjVr6sCBA06vWZLmz5+vDz/8UCEhIZKkxx9/XJ999pm6du2q4sWLZ643Y8YMq3O6c39cJTo62mS5du3a8vPzU1pamtU5evXqJV9fX6vXd8dYOXjwoMly9erVs92mdevWmjhxolq3bq3du3erUaNGysjIsKuOqlWrmiyfO3fOrny3mzp1ql566SXly5dPktS7d2+NHTtWJUqU0H333Ze53s6dO7Vx40aH9n27GjVqmCwfPnzYqf3BM7366qvq0KGD6tWrJ0kqWLCgvvvuO/n5+Vmd4+rVq9q9e7caNGggSQoMDFTXrl31448/5rieBx980GR569atSklJyXEeb/HJJ59o2LBhmcuNGjXSE088odmzZ7u0jlatWunuu+/OXD516pTeffddu+fUYcOGqVq1apIkf39/Pf7445o0aZLH1uDNPGUs2cKTXhsBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPbJnz+/mjVrptq1a6t69eoqVKiQChYsKEmKi4vTtWvX9M8//+ivv/7S9u3bFRsb69R6goKC1LZtW4vta9assSmvp+0nAACAkfwFHZMnpIhj8sB1Tpw4oeXLlzss39atW5WRkSEfHx+TuL+/vypUqGD2/dRGOnbsaBiPjIzM8rvZbfHLL7/o/vvvN4vfe++9VtXqTZ599lk9++yzDslVvXp1HTlyxCG5nKV69epau3atpk+frqlTpyoxMdEtdQQEBGjo0KEaP368SpcuneW66enpGjNmjCZPnuyi6pDbDBgwQH/99ZeKFDF9Qfb399e8efNUv359xcfHu6m6/xMZGakTJ06oQoUKJvGgoCA98sgjmjFjRo7ylShRQp07dzaLnzhxQhs2bLCr1rzk6tWrhvG77rpLUVFRri3mNl9//bUmTZqkwMBAk3jXrl1VvHhxRUdH5zhn69atdeedd5rFv/32W6WlpWW7vScfL3fKLfdxe/fu1c6dO+3KISnLHOnp6fr666/tyn/jxg0dOnRIdevWNWu76667tG3bNrvyu0teuL48eR+94Tr2hhpdyRPf199u79692rp1q6NKlCSdPn1aK1euVLdu3Rya1xEiIiKUlJSkoKAgk3iHDh0UHByshIQEq/IY7dvy5ct1/vx5/fnnn2rSpIlJW1hYmHbt2mVV7rCwMPn5+ZnFFy1aZNX2jmJ0fUnSpk2btH//fof2de7cOa1YsUI9evSwK4+3zEGe/FqTlRMnTmj9+vUOzZmUlKTZs2frlVdeMYl37txZX331ld35P/74Y7tz3OQt48uZDh06pLi4OIWGhprE/f39VaRIEave/3nj3OJt7D1P3nqO7r//fgUEBJjF//77b/38889257dGeHi4Jk2aZFcOV861kuPmW0/m6rHx8ccfa+bMmWZxR40PT39/YS/u13OHvDBWAQAAAFfwdXcBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArvbWW28pJiYmc7lIkSJ64403st0uMjLSZHnEiBE29V+0aNEcbxMXF6cffvghc7lBgwaqW7euBg8enBk7e/asVq5caXVOd+6Pqxw8eFAJCQmZy/nz59f9999v9fYBAQE2HRdXH9vffvvNZLlJkyby8fGxuH5gYKCWLFmi1q1bS/pvPD3//PM21Xirvn37mizv2bPH7py3unTpkr766qvMZX9/fz3//PMaPXq0yXrvvfeeQ/s10qxZM5PlLVu2OL1PeJ6UlBT17dtXiYmJmbHWrVurRIkSOcqzaNEik+UxY8ZkeQ0b8ff310svvWQSW7x4cY5yeJsDBw5o/fr1JrGPP/5Y1atXd2kdTz75pMnyV199pYyMDLvzzp4922R52LBhFseFJ9TgzTxlLNnCk14bAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOQevXv31rBhwxz607BhQ6v6LlSokF544QVt3LhR0dHRSk1NVUJCgg4fPqzZs2erVatWdu1b/vz5s6wzODjYrvy2eOCBB/TTTz8pJiZGGzdu1Keffqqnn35a/fv3V/fu3dW9e3c99thjeuqpp/Thhx9q/fr1io6O1po1a9S7d2/5+vo6pa42bdoof/78hm1xcXHaunVrjvJ56n4CAAAYSUnMfh1rJN9wTB64zooVKxya7/r16zp69KhhW5EiRazKYel90Nq1a22uy5Jt27YZxmvVquXwvtytatWq7i7B5e666y699957ioqKUrdu3Vzat6+vrwYOHKgjR47o888/V+nSpbNcPyoqSi1bttTkyZNdVCFyozNnzmjYsGGGbVWqVNHHH3/s2oKycOv3FN9q4MCBOc7Vt29f+fv7m8XnzJmT41x52blz5wzjffr0cXEl5mJiYvTTTz+ZxQMCAmyur1+/fobxuXPnWrW9Jx8vd8ot93GOqjc6OlqXLl0ybNuzZ4/FtpzYv3+/Ybxw4cJ253aXvHB9efI+esN17A01upInvq+/naNrdHZee8XGxmrdunVm8Xz58qlTp05W5ShVqpQaN25sEvv777917NgxSdKyZcvMtgkPD7e6xh49epjF4uPjtWbNGqtzOEKzZs0M4xs3bnRKf6tWrbI7h7fMQZ78WpMVo2vHEX7++WezWJMmTezOe+jQIW3atMnuPDd5y/hypoyMDIvjt2jRolbl8Ma5xdvYe5689Rzdd999hnFXvn42a9ZMQUFBduVw5VwrOWa+9XSuHhuW8jpifHjD+wt7cb+eO+SFsQoAAAC4Av/XEgAAAAAg1zt79qwOHTpk9nPmzBl3lwYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3uXbtmt58802T2IgRI1StWrUst5s6darJ8vDhw9WwYcMc9d2+fXudOXNG7777rvLnz5+jbWfMmGGyPHr0aD3wwAOZy3PnzlV6errV+dy9P66Qmpqqbdu2mcReffVVq7d//fXXVbNmzRz36+pj+8cff+j69euZy4ULF1bt2rUtrp+cnKzJkyebxN5//3316NEjRzXeqlWrVho+fLhJ7Mcff7Q5nyWTJ082GefDhg3TQw89lLn877//asmSJQ7v91YFChRQ/fr1TWIbN250ap/wXAcOHNDo0aPtyvHll18qPj4+c7lp06aaMGFCjnJMmTJFNWrUyFy+cuWK5s6da1dd3mDkyJEmxy40NFRbt25VixYt7M7t4+OT7TpFixbVww8/nLmckZGhOXPm2N23JH399ddKTU3NXK5YsaLuv/9+j6whN3DWWLJmHNnLE14bAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOQuH3zwgb788kuH/oSFhWXbb5cuXfTvv/9qypQpuvfee1WsWDH5+fkpf/78qlatmh5//HFt3rxZ33//vUJCQmzatylTplissWnTpkpISLApr61atGihlStXqnv37jn6TsDAwEB16tRJ33//vQ4dOqQuXbo4vLascm7YsMHkO46y0qJFC+3evdtj9xMAAMBIbLRj8ly/5Jg8cJ1NmzY5POepU6cM40WLFrVq+1u/t/ZWv//+u801WXLu3DnDeHbfAe8qjvyu0CpVqjgslyPExsYqOjrapp8rV64oKSnJ6r7KlSunn376SRMnTnTiHv2fhx56SPv379dXX32lihUrZrnuze9gr1evntl31AO2WLx4sb755hvDtiFDhqhHjx6uLciCuXPnKiMjwyx+zz33qHLlyjnKNXDgQLNYRkaGvvrqK1vLy5O2bNliGB8wYIB69erl4mrMzZgxwzA+aNCgHOcKCAgw+a70m7Zv366DBw9alcPTj5e75Jb7uN9++83uHDedP3/eML59+3an5i9cuLBD8rtDXri+PHkfveE69oYaXckT39ffbuvWrfaUY5Gj5lJnWLhwoWHc2vvxrl27mj0TWL58ueG/b2rUqJFKly6dbe6goCB16tTJLL5ixQolJiZaVZ+jVK9e3TDujOtZkjZv3mx3Dm+Zgzz5tSYrjjhHRnbs2GH2HrRixYoKDAy0K+8vv/xi1/a385bx5WzXrl0zjFv7OuSNc4s3suc8ees5qlmzpmHc0pxrL6N7Ml9fX4vHz1qunGslx8y3ns7VY+P06dNOGx/e8P7CEbhf9355ZawCAAAAzubr7gIAAAAAAHC2F198UXfffbfZz9NPP+3u0gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOBG06ZN05EjRzKX/f39NWXKlCy3OXDggJYtW5a5HBAQoIiICNWuXduqPlu1aqUFCxYoX758evXVV3Xw4EHdeeedVte8fft2/fXXX5nLjz32mAICAiRJGRkZmjVrltW5JPfvj6t8+eWXJsutW7fWO++8k+12r7zyisaNGydJio6OzlGfrj626enp+vXXX01ibdu2zbKPjz76SHv27Mlc9vPz05IlS/T6668rMDDQqjpv6t+/v1avXi1/f//M2IoVK7Rr164c5bHG0aNH9eOPP2YuBwcHy8/PL3N58uTJSk9Pd3i/t2rZsqV8ff/vq2EPHz6sc+fOObVPeLZPP/1Ua9assXn7y5cv68033zSJTZgwQe+88458fHyy3NbPz09Tp07Vs88+axIfO3as4uPjba7JW0RFRWnkyJEmsWLFimnjxo366KOPVLJkyRzl8/HxUceOHbVp0yaVKlUq2/UHDhyooKCgzOWff/5Zx48fz1Gflly4cEGrVq0yiT355JMeWUNu4MixlNNxZC9PeG0EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkLuEhoa6vM8nn3xSK1euVNGiRbNdt3fv3tq+fbsKFy6coz66dOmiESNGGLYdPXpUo0aNylE+e02cOFFbtmyxO0/VqlW1atUqzZgxw+Q75ezVuXNni23WfnfXzX2sX7++3fU4az8BAACMHN/tmDwnHJQHrnPw4EGH57x27Zph3Nr3NNWqVTOMnzhxwtaSLLpy5YphvEiRIg7vKytJSUmGcUe9F/Dz81PFihUdkstRhgwZohIlStj0U7RoUeXLl08BAQEqW7as7r//fo0ePVpbt25VRkaGYX8+Pj4aO3as2XcrO1Lnzp21c+dOLV68WDVq1Mh2/Zvrvfzyy7px44bT6kLeM3LkSB07dsywbdasWSpdurSLKzJ34sQJbdiwwbBtwIABVuepVauWGjRoYBaPjIzUyZMnba4vL9qyZYtiYmLM4r6+vvrhhx/09ddfq169em6o7D8bNmzQv//+axZv2LChateunaNcXbp0MXwuO2fOHKtzePrxcpfcch8XFRVld46bYmNjDeNHjhxxav6c/j7Bk+SF68uT99EbrmNvqNGVPPF9/e1273bOA6O///5bycnJTsltr2XLlhm+1w8LC5Ovr2+223fr1s0w50379u0zu9/18fFR165ds83doUMHhYSEmMUXLVqU7baOVrVqVcP4vn37nNLf0aNHlZ6eblcOb5mDPPm1JiuOvA+71bVr18zOka+vrypVqmRX3u3bt9u1/e28ZXw5Q+nSpdWyZUv179/f4udoAgMDrcrljXOLt3DUefLWc3T33Xcbxnft2mV3biM7d+7MUR3WcuVcKzlmvvV0rh4bkvPGhze8v3AE7te9X14ZqwAAAICzZf8OCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBdKTU3VSy+9ZBILCwtThw4dstxu6NChOnfuXOZy2bJltWPHDk2cOFEVK1Y03KZ27dr65JNPtHHjRpUoUSIzfuTIEZ08eTJHdc+cOdMwvn79eh0/fjxHuST3748rLFmyRAcOHDCJjRs3TsuXL1fz5s3l4+OTGQ8MDFRYWJg2btyoSZMmycfHR1euXNHbb7+d435dfWzXrl1rsnzfffdluX5KSop69+6tS5cuZcZ8fX315ptv6p9//tH48ePVoEED+fqafwVqUFCQ6tWrp+eee0779u3TN998o9DQ0Mz2ixcv6umnn86yf3u89957hvHo6GjNnTvXaf3edPuxjYyMdHqf8HyDBg1SdHS0zdt/+OGH+vnnn01i48aN0969e9WnTx8VKlTIpK1YsWIaNGiQDhw4oGeeecakbeXKlZo+fbrNtXibr7/+Wh999JFJLCgoSM8995yOHTum5cuXa9SoUWrZsqWqV6+u4sWLKzQ0VKVKlVKVKlXUtm1bjRgxQnPmzNH58+e1bt06tW7d2iRfRkaG0tLSzPoePny4yfKsWbMcum+35wsPD9cdd9zhcTXkFvaMJXvGkSO4+7URAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQO5y63eTuUKjRo00depUk++Wy06tWrU0e/Zsq9cvXry4xe9zSUtLU79+/RQfH291Pnv4+fnp22+/1dixYw2/L85WQ4cO1YoVK5Q/f367c5UvX1533323xfbbvz/vds7aR8mx+wkAAGDJ/kgpI8O+HCf2SHExDikHLnTmzBmH57x+/bph3Np75SJFipjFbty4ocuXL9tVl5G4uDjDeIECBRzeV1YSExMN40FBQQ7JX758eSUlJSkuLi5HPxn2TgxOlpqaqrNnz2r9+vX64IMP1KpVK1WqVEmLFi2yuM3rr7+usLAwh9ZRv359bdq0SatXr1bDhg2zXX/dunVq0qSJevXqpWPHjjm0FiOOfp9qSz85HUveWLMniYuL02OPPWb4/cLFihXT119/7YaqzFl61tW/f3+rcwwcODBHuWFZSkqKJk2aZNjm4+OjAQMGaM+ePTp16pR+/PFHvf322xo4cKBatmypUqVKuaRGS99pPmjQoBzl6devn1nsxo0b+v77763O4Q3Hyx1yy33c2bNn7c5xk6U6z58/75D8sbGxhnFXvZY6Q164vjx5H73hOvaGGl3Jk97XW2qPjo62uyYj6enpTjnvjhAbG6t169aZxYsWLapWrVpluW1gYKA6dOhgErt48aJ27NhhEouIiDDbNjw8PNvaevToYRZLSEjQqlWrst3W0QoVKmQYj4lxzkPGlJQUu1/nvWUO8uTXmqycOHHCabmNzpHR+cyJvXv32rX97bxlfNkiKChI1atX1wMPPKCnn35aH3/8sSIiIvT3338rISFB586d05YtW/TNN9+oUqVKdvXljXOLp3DVefLWc1SiRAnD+KVLl+zObcTSPVTx4sXtyuvquVayf771dK4eG5Lzxocnvb9wJu7XvV9eGasAAACAs/m7uwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB3Wb58uX755Rfde++9mbEPP/xQ9evXV3p6uuE2ly5d0oMPPqhVq1apaNGikqT8+fNr7NixGjt2rE6fPq1z587pxo0bKlasmMqUKaMiRYqY5dm7d6969eqV45q//fZbvf/++8qXL59JfMaMGTnO5Qn74wppaWnq1auX/vjjDwUHB2fGw8LCFBYWpoSEBF24cEGBgYEqU6aMfHx8MtdJT0/XyJEjlZaWluN+XX1sFy5cqI8//lj+/v99ZWnnzp0VHByshIQEi9scOXJE7du318qVK1W+fPnMePny5fXWW2/prbfeUmpqqi5fvpzZ9swzz+jFF180OU63unjxotq3b68TJ05kW7Ot/vzzT7NrV5KmTp2qxMREp/V7U8+ePU2W582b5/Q+4fkuXLigIUOG6KeffrJp+7S0ND300ENau3atmjZtmhmvU6eO5s+fr/T0dEVHR+vatWsqUqSIihUrZngdbtq0SY8++qitu+G1XnjhBZ09e1aTJk3KnAclKTg4OHO+t9Vff/2loUOHKiYmxiTepk0bVa9ePXP5ypUrWrp0qc39GFm1apXOnz+v0qVLS5L8/Pz0xBNP6J133vGYGnIbZ40lS+PIUdz92ggAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAg9wgICFBAQIBL+5w9e7Zhn0eOHNGWLVtUrFgxdenSRYGBgSbtPXv2VPfu3bVs2bJs+5g1a5ZKlSpl2DZp0iRt27bNtuJtMHXqVPXr188puTt16qR58+aZfeeaLXksiYqK0rFjx7Lc3pn7KDluPwEAACy58I90eLNUo41t22ekS7/OcWxNcI3Y2FiH57T0nenWCA4ONvwe2/z58+vGjRv2lGXI0ndXBwUFObyvrGT13dwhISGKj4+3K//x48dVoECBHG938OBB1ahRw66+Xe348eN65JFH1L9/f82dO1d+fn5m63z22WeKjIy0+3tQCxYsqPfee0/Dhg2Tr69vtutv2rRJ48aN05YtW+zq10hSUpLFNlc997j9OcatjOrzxpq9ye+//653331X48ePN2u7//779eyzz2rq1KluqOz/LF26VFeuXFGRIkVM4nfddZdatmyprVu3Zrm9r6+v4fMYZ3z3dV7x6aef6sEHH1TLli0trlOuXDmVK1dODz74oEk8Pj5eR48e1T///KN//vlHUVFR2rt3r/bt2+ew62nu3Ll66623TL6PW5Iee+wxjR492qp7kAIFCig8PNwsvnTpUl2/fj1H9Xj68XK13HQfZ++9160sjUtH9WHPvbcnywvXlyfuozdcx95Qo6t50vt6o/edcXFxSk1Ntbcki65evarSpUs7Lb89Fi5caHjf0aNHD23atMnidu3atVNISIhJbMWKFcrIyDCJRURE6OmnnzaJdezYUUFBQRbnAh8fH8OaVq1a5ZRrKCuWruekpCQlJyc7rV97rhlvm4M88bUmOzm9J8+Jq1evmsVCQ0PtyhkTE2PX9rfytvFlSZkyZdSoUSPVrVtXVapUUaVKlVS5cmWVKVPGYp+O5I1zizu48zx56znKnz+/4bPmpKQku58zW3LlyhXDuC3P+m/l6rlWsn++9WTuGBuS88aHJ72/cDbu171bXhqrAAAAgDNl/4k3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAXOz55583+aLzOnXq6Iknnshym+3bt6tZs2Y6cOCAWVu5cuXUpEkTtWnTRrVq1VKRIkXM1lmwYIFatmypa9eu5bjeq1evasmSJSaxixcvatmyZTnOdZM798dVDhw4oHbt2unChQtmbcHBwbrrrrtUtmxZ+fj4ZMaTkpL06KOPasGCBTb368pje+nSJa1ZsyZzOTg4WOHh4dlu99dff6l+/fpasGCBMjIyzNr9/f1VsmTJzOWgoCCT43SrJUuWqHbt2vr777+z7dde7733nslyQkKCPv/8c6f326BBA1WpUiVz+ejRo/r999+d3i+8w7JlyzRr1iybt7969aruvfdewxy+vr4qWbKkqlatquLFi5tdhxkZGfr888/VsWNHxcXF2VyDN5s8ebKaNm2qLVu2OCTfwYMH9fTTT6tBgwbavn27WfuTTz5psjxv3jwlJSU5pO+b0tLS9PXXX5vEhg0blnn+PaGG3MiRYym7ceRI7nptBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJC7hIaGurS/e+65R/Xq1TOL//jjj7r77rv1xBNPqEePHmrTpo2Sk5PN1hs5cmS2fTz++OPq3r27Yduff/6pN954I8d126pfv3566qmnsl0vPj5ee/fuVWRkpNatW6fdu3fr+vXrVvXx4IMP6uWXX7arzs6dO1tsu/V784xYu4+S+/cTAAAgK2unSpfP2Lbtr3Ok80ccWw9cIyUlxd0lmAgJCbHYli9fPof/BAUFuXDvLDP6PvKbSpUq5cJKco9vv/1Wzz77rGFbhQoV1KtXL7vy165dW3/++aeefPJJ+fr6Zrnujh071LFjR7Vt29Zh30d8u6y+5zdfvnxO6fN2+fPnt9hmVJ831uxt3nzzTe3YscOw7f3331etWrVcXJGppKQkzZ8/37Bt4MCB2W7foUMH3XHHHWbxefPmGT5XQ/aSk5PVvXt37d69O8fbhoSEqG7duurZs6dGjx6tmTNnaseOHYqLi1NkZKQGDx6c5TVnjfPnz2vVqlVm8dKlS6tTp05W5ejZs6fhHDNnzpwc1+Ppx8vVctN9nCvukZmnspYXri9P3EdvuI69oUZX86T39UbHKz4+3ql9Wvt7NneIiIgwnO8t/R73pvDwcLPYsmXLzGK//PKLYmNjTWLBwcG69957LeZu3ry54XOGhQsXZlmTM1i6np19Tu0Zk942B3nia012EhISHJ7zpmvXrpnF7P28iFFOW3nb+LpVrVq19N577+n48eM6c+aMIiIi9M4772jQoEFq06aNypYtKx8fH4f1lxVvnFtcxVPOk7eeI3fUfeXKFcN4wYIF7crr6rlWcv3n81zJXWPaWePDk95fOBv3694tL41VAAAAwJmy/tQbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADIVWJjYxV1JMpjf86dP+fyY7Jnzx59++23JrF33nlHBQoUyHK7f/75R3Xq1NHjjz+uQ4cOZdtPWlqa1q1bp3bt2qlv376Kj4+3ueYZM2aYLH/11VdKTU21OZ/k3v1xle3bt6tu3br67LPPlJSUlOW6mzZtUsuWLbVo0SK7+3Xlsf3qq69Mlvv06WPVdpcvX1bfvn1Vv359TZ8+XdHR0Vb3efHiRc2ZM0cNGjTQww8/rEuXLlm9rT3WrFmjv/76K3N59uzZunz5stP7vf2Yfv31107vE95l1KhRioqKsnn7GzduaOjQoWrRooUiIiKUkpKS5fpJSUlavHixGjdurKefflrJyck2950b7N69W61bt1bLli01d+7cHM9JZ86c0Zw5c9SmTRvVrFlTn3/+udLS0szWK1asmHr27GkSmzVrll21WzJ79myT5fLly6tLly4eUUNuZs9YsnYcOZq7XhsBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5C6hoaEW2y5evKjz58/b9BMXF2eYs3Pnzobxl156Senp6ZnL27dv1w8//GC23r333qvAwECLNVeqVEmffPKJYVtCQoL69u3rku+YkaTChQvro48+ynKdtWvXqmPHjipSpIjq16+vjh07qlOnTmrYsKGKFi2q1q1ba/Hixdn29eabb6p8+fI21enn56cOHTpYbF+9erXFNmv2UfKM/QQAAMhOUpy0+DXp8umcbbd9obQj+1sZwCo+Pj7uLsEtLl26ZPG728uVK+fianKPL774Qtu3bzdse/zxx23Oe//992v79u2qWrVqluvt3btX4eHhatasmSIjI23uzxqxsbEW24oWLerUvrPrJykpyfBZhDfW7G3S0tLUt29fxcfHm7UFBQVpwYIFWT5ncoXbv0/6pkceeURBQUFZbjtw4MAc5YR1YmJi1KJFC33xxRcOuQ78/f3Vvn17zZkzR//8848GDx5sV74ZM2YYxgcNGmTV9v369TOLnTx5Uj///LNN9Xj68XKlvHofZ6uMjAx3l+Dx8sL15Wn76A3XsTfUCFPOnu9u/f2qp7l+/brWrVtnFq9UqZJq1aplcbuwsDCT5cTERK1fv95svZSUFK1Zs8YsHh4ebjF3jx49zGI3btzQqlWrLG7jLJauZ2e/F7P0/MUa3jgHedprTXacOWcY7b+95/T69et2bX8rbxxfFSpU0Pz58/XXX39p9OjRqlChgrtL8sq5xdk87Tx56zny9fU1jDuzbku57Z0vXD3XSt45x1nLHWMjq/y5+Vg7GvfrAAAAACD5u7sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgOkf/Oaqj/xx1dxl22bRpk3x8fByac9CgQRo0aFCOt0tPT9fcuXM1d+5cVahQQW3btlWZMmVUsmRJ5c+fX/Hx8YqOjtbBgwe1efNmXb582SH1OuMYSM7fH0fVfN9999m87cWLF/XMM8/olVde0b333qvatWurZMmSypcvn65du6YjR45o8+bNOnrU9DpZuHChFi5caHO/rhorEREROn36tMqVKydJ6tKli0qWLKmLFy9atf2+ffs0YsQIPfXUU6pRo4YaNWqkcuXKqU6dOurbt68kafv27fr+++91+vRp/f333zp06JBNtTpiHNetW9eu7XPav7+/f+ZxkKTk5GTNmTPHrhrgHs6aRyUpISFB1apVszvPtm3b1L17dxUqVEitW7dWrVq1VKJECQUHBys+Pl4XL17U33//rc2bNysuLs6mPjxhXnaW3377Tb/99pskqWrVqqpfv77uvPNOlSxZUsHBwfL391diYqLi4+N17tw5nThxQnv27NHp06etyh8TE6N8+fI5cxcyRUVFWTxXnlDD7Zx5fbmDtWPpn3/+yfE4up03vjYCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyH1CQkIstpUpU0ZpaWkO7a9mzZpmsXPnzunYsWNm8c2bN6t///4msYCAAFWuXFkHDx40W9/X11fz5s1TaGioYd8vvviioqKibKw858aOHavixYsbtt24cUMDBgzQ4sWLLW6flpamLVu2aMuWLWrfvr2WLFmiQoUKGa6bP39+vfPOOxo4cGCO62zevLnFvElJSfrll18sbpvVPkqetZ8AAADWuHpO+vY5qeNI6e57pay+9i/usrTxS+ngr66qDsi9MjIydPr0aVWsWNGsrUaNGtq0aZPri8olpk2bpmbNmpnFW7RooYCAAKWkpOQo33333aeffvpJ+fPnt7jOoUOHNH78+CzfCzpafHy8EhISFBwcbNZWqlQpl9RQsmRJw/j58+cN495Yszc6evSoRo0apVmzZpm11alTR//73//0wgsvuKGy/+zevVt79uxR/fr1TeKFChVSt27dtGjRIsPtQkND9eCDD5rF9+zZoz179jih0rwlKSlJI0eO1CeffKJXX31VPXv2VMGCBe3OW6ZMGc2ZM0cdO3bU4MGDlZSUlOMcq1ev1unTp1WuXDmTePfu3VW4cGFdvXrV4ralS5dWu3btzOJff/21MjIyclzLTZ58vABvlxeur7ywj8g7jF5PfX19ndpnQECAU/Pba+HChQoLCzOL9+jRQ/v37zeL161bV3feeadJbMOGDbpx44Zh/oiICPXq1cskFh4erqefftpw/e7du5vFVq9erfj4eIv7AO/Ha43z2PM+wtt16NBBixYtUuHChW3OcfnyZUVFRSkqKkqHDx/O/Pfnn3+u5s2bO67YPIzzBABZ434dAAAAQF7n7+4CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcoMTJ07om2++cXcZDpPb9ud28fHxWrlypVauXOnyvp15bFNSUjRp0iR9/vnnkqTAwECNGjVK48aNy1GejIwMHTx4UAcPHpQkNWzYUH379pUkbd68WR9//LFD6/YWvXv3VtmyZTOX58yZozNnzrixIuQF165d04oVK7RixQp3l+K1oqKiFBUV5e4ykAswlgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADkBaGhoYbxpKQkpaWlOby/woULm8UuXrxouK6leNGiRQ3jY8eOVfPmzQ3bVq1apenTp1tXpAPky5dPQ4YMMWxLS0vTAw88oF9++cXqfBs2bFCbNm20bds25c+f33CdRx99VC+++KKio6NzVGvnzp0ttm3evFk3btwwbMtqHyXP208AAABrJcVJK96TdiyWaraTKjaQChSXAvJJCVelS8elf7ZJBzZIKUnurha5TUZGhmH86tWr+v77711WR0xMjMv6uumvv/5SxYoVzeL16tVzeS25yapVqwzjQUFBqlmzpvbu3Wt1rkqVKmnZsmUW369dvnxZr732mr788kulp6fbVK89zp8/r0qVKpnF77rrLpf0b9S39F9dlnhjzd5o9uzZCgsLU48ePczannvuOa1atUqRkZGuL+z/mz17tj799FOz+MCBA7Vo0SLDbR5++GHDa3HWrFkOry8vO3LkiAYPHqzhw4fr3nvvVZMmTdSoUSPVqFFDlSpVUlBQkE15+/TpowIFCig8PDzH26anp2vu3LkaP368STwoKEi9e/fWl19+aXHbRx99VL6+viaxjIwMzZ07N8d1GPHE4+VKefk+Ds6XF64vT9hHb7iOvaHGvCwhIcEsVrBgQaf2afS7V0+ybNkyJScnKzAw0CTeo0cPTZw40Wz9sLAwwxyWrFq1SmlpafLz88uM3XnnnapVq5b2799vsm716tVVvXp1sxyW7rmdzdLv4gMCApzarz35vX0O8oTXmuwEBAQoJSXF7jxGbr8OJcvj0B28aXx16dJFy5cvN5l7LImLi9ORI0d05MgRRUVFmfz3ypUrhtskJibmuO6bvHFucRZPPU/eeo4s1e3v729X3qxYqtneucvVc63kWfOto7ljbEjOGx95DffrAAAAAPI65757BQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOBSs2bN0tixY1W2bFlJ0lNPPaVJkyYpLi7OzZV5v5dffjnz3ykpKZo0aZIbqwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcLzQ01DAeHx/vlP78/PzMYikpKYbrWoob5WjcuLEmTJhguP6lS5c0ePDgHFRpv549e6pIkSKGbe+++65++eWXHOfct2+fXnzxRX3xxReG7YGBgerXr58+/vjjHOXt3LmzxbbVq1dbbMtqHyXP208AAICcunj0vx/AlRITEw3jcXFxGjFihIurca19+/YpPDzcLN66dWs3VJN7XLp0SYmJicqXL59ZW4kSJazO4+fnpwULFqhAgQKG7Tt37lSPHj10+vRpm2u115EjR1SpUiWz+N133+2S/i31ExUVZXEbb6zZWw0ZMkTNmjXTHXfcYRL38fHR119/rTp16ujy5ctuqW3evHmaPHmygoKCTOKdOnVSiRIldOnSJbNtBg0aZBZLSkrS/PnznVVmnpacnKx169Zp3bp1mTEfHx+VK1dOVapUUZUqVVS1atXMf1epUkX58+fPMmdYWJjGjh2rd999N8f1zJo1S+PGjZOvr69JfNCgQfryyy8tbtevXz+z2KZNm3Ts2LEc15AVTzterpKX7+PgOnnh+nLnPnrDdewNNeZlRr9fzZcvn/Lly2fx3NmrcOHCTsnrKNevX9f69evVtWtXk3ijRo1UpkwZnT171iTerVs3k+WMjAytWLHCYv7Lly9r69atatOmjUk8PDxc+/fvN4l1797dbPvExMQs8zuTpd/HFypUyKn9hoSE2LxtbpmDPPn1tFChQoqOjrYrhyVG80VcXJxT+rKFt4yvihUrav78+YafW5GkmJgYLVmyROvXr9cff/yhEydO5LgPHx8fm+vzxrnFGTz5PHnrObI0XzjzXqRo0aKG8evXr9uV19VzreRZ862juWNsSM4bH3kN9+sAAAAA8jrf7FcBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4C2Sk5P1zjvvZC4XLlxYI0aMcGNFuUPnzp1Vr169zOXZs2fr5MmTbqwIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcLzQ0FDDeFxcnMtq8PX1zVH8dvnz59e8efPk7+9v2D5kyBBdvHjR5vps0aVLF4tt7733ns15v/zyyyy/Vy2rfo0UL15cjRo1sti+du1am/q6fv26R+0nAAAA4C0SEhKUkZFhFi9atKgbqnGtLVu2GMZr166t0qVLu7ia3OXSpUuG8cKFC1ud48knn1TTpk0N27Zv3642bdro9OnTtpTnMAcOHDCMN27c2CX9W+pn//79Frfxxpq9VUxMjAYNGmQ4x5YpU0YzZ850Q1X/uXLlin766SezuL+/v/r06WMWv/POO9WmTRuz+NKlS3XlyhVnlAgDGRkZOnXqlDZu3KiZM2dq9OjR6tmzp+rWrauQkBBVr15do0aN0sGDBy3mePXVV216jT958qTWr19vFm/evLmqVatmuE21atUMnwPOmTMnx/3bwp3Hy1Xy8n0c3CsvXF+u2kdvuI69oUaYc9Z72pCQEBUpUsQpuR1p4cKFZjEfHx9169bNJFaiRAmz9507d+7UuXPnsswfERFhFgsPDzeL9ejRwyy2du1al/5e/FaJiYlKT083i/v7+ys4ONhp/RYqVMjmbXPzHOQpr6c5eVbjiNzuGv9GvGV8vfvuuxaP5TPPPKMyZcpo+PDhWrx4sU6cOGFTH5Y+x2MNb5xbnMGTz5O3nqOkpCSlpqaaxf39/RUSEmJXbkss3efExsbaldfVc63kWfOto7ljbEjOGx95EffrAAAAAPIy6/6vNQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABe48svv9S2bdsyl1977TWVKlXKjRV5t4CAAH300UeZy2fPntWYMWPcWBEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgHKGhoYbx+Ph4p/SXkJBgdQ3W1vbhhx+qWrVqhuvOnj1bEREROazSfu3atbPYZs+xTU9P18yZMy22t2nTRv7+/lbn69ixo3x8fAzbzpw5o/3791vcNqt9nD9/vkftJwAAAOAt0tLSdOnSJbN4cHCw8uXL54aKXOfXX39VcnKyWdzHx0e9evVyQ0W5R1pammHc19fXqu3z5cuncePGGbZduHBBXbt2NXy/72o7d+40jDds2NDiMwZHKVCggOrXr2/Ytnv3bovbeWPN3mzdunX69NNPDdt69uypQYMGubagW8yePdswPnDgQLNY//79DZ/nWMoB18vIyNCRI0c0depU1apVS2+++abheqGhoRoyZIhNfcyYMcMwbmkc9+vXzywWGxurxYsX29S/I7nieLlCXr6Pg+fKLddXVhy5j95wHXtDjTDXtGlTp+Rt3Lix1e/r3GnZsmWG7/d79Ohhsty1a1ez+9xly5Zlm9/od8HNmzdXsWLFMpdLlSql5s2bm623cOHCbPM704ULFwzjpUqVckp/+fLlU+nSpW3ePq/OQa58PXXWubeUOzo62mn95ZQ3jK+KFSuqd+/eZvGkpCR16NBBn332meF8l1PFixe3a3tvm1sczRvOk7eeozNnzhjGnXX+LeU9f/68XXldPddKnjXfOoOrx0ZWue0dH3kR9+sAAAAA8jLP/y0LAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgBzJyMjQE088oeTkZElSwYIFNWXKFJvznT17VhMmTNCECRO0du1aR5XpNV5++WXVqFEjc/nJJ5/U9evX3VgRAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4ByhoaGG8bi4OLOYr6+vChcurBIlSihfvnw29Xfq1CmzWMWKFRUUFGQWr1mzpmGOkydPZv77gQce0JNPPmm43tGjRzVq1Cib6rRHkSJFVKZMGafl//nnny225cuXT5UrV7Y6V5cuXSy2rVmzxmJbdvu4YcMGq2uwxJH7CQAAAHiTW9/z3Kp27doursS1bty4oV9//dWwbejQoS6uJncJCAgwjKenp1u1fZ8+fXTHHXcYtj333HOKiYmxuTZHsjR+AgIC1LFjR6f23alTJ8PjnJaWpq1bt1rczhtr9najR4/W33//bdj26aefqlKlSi6u6D+RkZGG83/Dhg1Vq1Ytk9jAgQPN1jt58qRDnsfA8TIyMvTGG2/oiy++MGzv1KmTTXkjIiJ04cIFs3j//v3l4+NjFu/bt69ZbOHChUpISLCpf2dx1vFylbx6Hwfv4O3XlzUcsY/ecB17Q40w1apVK6fkbdasmVPyOtq1a9cUGRlpFr/vvvtUoECBzOVu3bqZrRMREZFt/qioKB0+fNgk5uvra/J70PDwcLN7pKSkJC1fvjzb/M505MgRw3jjxo2d0l+1atUM7xVzIq/PQc5+PXXWuS9btqxKlSplEktJSdGxY8ec0p+tPH18PfDAA/L19TWLf/HFF9q+fbtD+vD19VXJkiXtyuGNc4sjecN58tZzdODAAcO4s+5JmjZtahjfv3+/XXldOddKnjnfOpqrx4bkvPGRF3G/DgAAACAvM3+KBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDrHThwQH379tWECRM0YcIEHTlyRKGhoTblOn/+vN566y299dZbioyMdHClni8lJSXzOD755JNavny5u0sCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnMLSd57Fx8fL399fPXr00Lx58xQVFaXU1FRduXJFFy9e1I0bN3Tp0iWtXr1aw4cPV0hIiFX9bd261SwWGBiovn37msQCAgLUp08fs3WPHTumS5cuSZKKFy+uOXPmGPaTlpamfv36KT4+3qq6HKl69epOzb9r1y6lpaU5pP9OnTpZbFuzZo3Nffzxxx9W12CJI/cTAAAA8CZ//fWXYbxZs2YursT1vv76a8N4nTp19MADD7i4mtyjRIkShvG4uDirtu/du7dhPCoqSt9//73NdTnamTNndPjwYcO2/v37O7XvAQMGGMZ37NiR5XH2xpq9XVJSkvr27aukpCSzttDQUM2bN09+fn4urysjI0NfffWVYdut56pZs2aqWrWq2Tpz585VRkaGs8qDA7z++utKTU01izdp0sSmfKmpqYavm+XKlVO7du1MYs2aNVPlypXN1rX0bNUTOPp4uUpevo+D9/DW6ysn7NlHb7iOvaFGmOrZs6dT7jFv//2qJ1u4cKFZLDAwUJ07d878d8eOHU3aT506pX379lmVf/ny5Wax8PDwzH/36NHDrH3dunWKjY21Kr+zWHo/2KJFC6f017ZtW7tzMAf9x1mvp846982bNzeLHT16VOnp6U7pz1aePr7atGljGHfk87FGjRopf/78duXwxrnFkbzhPHnrOfr7778N461atXJI/tsVK1bMLJaUlKSjR4/aldeVc63kmfOto7l6bFSvXt1p4yOv4n4dAAAAQF7l6+4CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADjHkiVL9NZbb2X+xMXFubskr/TBBx9kHsMvv/zS3eUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAThMSEmIYr1Chgg4dOqSlS5eqb9++qlKlinx8fEzWKV68uDp37qzp06fr5MmTGjlyZLb9RUREGH7P2qeffqpnnnlGderU0b333qtVq1apSpUqZuvNmzcv89+zZ89WqVKlDPt59913tW3btmzrcQZLNTlKYmKioqOj7e6/fv36KlmypGFbWlqaIiMjbe7j9OnTVtWQFUftJwAAAOBtduzYYRi/9957XVuIG/z444+6du2aYduUKVPk7+/v4oq8X8WKFRUYGGjYdubMmWy3L1CggNq3b2/YNmvWLLtqc4ZFixYZxsPDw1WhQgWn9FmpUiU98MADhm0//PBDttt7Y83e7q+//tLYsWMN25o3b67x48e7uKL/zJ07VxkZGWbxfv36ZT6XGzRokFl7RkaG5s6d6+zyYKeYmBjt2bPHLF6gQAGL83R2Zs6caRi/fZz069fPbJ2oqCj99ttvNvXrCs44Xrfz8/NzSJ5b5eX7OHgPV1xf7mbPPnrDdewNNeZlRvdzZcuWVc+ePR3aT/PmzVWvXj2H5nSmn376ScnJyWbxHj16SPpv/IaGhpq0RUREWJ1/2bJlZrHOnTvL399fISEh6tChg1m7pfdirrR582bDeJcuXZzSX3h4uN05mIP+46zX03bt2jnl9djoGcCWLVsc3o+9PH183XHHHYbxgwcPOqyPdu3a2Z3DG+cWR/KG8+St52j9+vWG8bCwMKe8xzby66+/Ki0tza4crpxrJcfNt646xrZw9di4eQ95O0eMj7yK+3X7ePL1CQAAACBrvu4uAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuF+BAgUM43fddZcqV65sdZ6iRYvqs88+0/LlyxUcHGxxvWvXrmnSpElm8ZCQEE2dOlX79u3Txo0b1aFDB7N1zp07p48++kiS9MQTT6hbt26Gffzxxx968803ra7d0UJDQy22xcfHO6SPa9eu2dT/rTp37myxbfv27bp69apNfcTHxystLc2qGrLjiP0EAAAAvM26desM4926dVOJEiVcXI1r3bhxQ1OnTjVsq1Gjht566y0XV+T9HnzwQcN4SkqKoqKist2+Xr168vf3N2xbvXq1XbU5w3fffaeMjAyzuL+/vyZMmOCUPt944w35+fmZxVNTU7Vw4cJst/fGmnODDz/8UBs2bDBse+2111SuXDkXVyQdP35cP//8s1m8TJkyat++vQIDA9W7d2+z9g0bNujEiROuKDHPKF26tFPynj171jBeuHBhm/L9888/+uWXX8ziPXv2zHx25ufnp0ceecRsnTlz5tjUpxFPP16WnslaejZuj7x8Hwfn8PTryxE8bR+94Tr2hhrzssjISMP4hAkTFBgY6LB+3n77bYflcoVr164ZHpuuXbvK399f4eHhZm3Lli2zOv9vv/2mmJgYk1jBggXVqlUrderUSUFBQSZtycnJioiIsDq/s6xfv94wXqNGDcPfl9ujUqVKDsnpjXOQp73WZKVEiRJ69NFHbd7eSPHixdW3b1+z+Jo1axzajyN4+vgqUqSIYTwxMdEh+X19fTV06FC783jj3OJI3nCevPUc/frrr4bvscuXL6+HH37YIX3cFBAQYBh3xOu3K+daKefzrSufYziKq8fGs88+a9jmCfd33or7desZjXVPvj4BAAAAZM3X3QUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD3Cw0NdWi+sLAwLVu2TP7+/hbXmTRpkjZu3JijvOnp6Xrsscd0+fJlVa5cWR9//LHhegkJCXrssceUlpYmSSpWrJiGDBmiOXPmaM2aNYqMjNQPP/ygV155RTVq1MhRDdYKDg622BYXF+eQPrLKY+057dKli8W2NWvWZLmtK/Yxu1yOHrsAAACAp/j333/1119/mcUDAwM1dOhQh/ZVqFAhlS5d2qE57fXhhx/q2rVrhm2vvPKKHnnkERdX5L1CQ0P14osvGrZt27ZNiYmJ2eaoX7++YTw+Pt5wnLrb4cOHtXbtWsO2QYMGqU2bNg7t77777lP//v0N2xYuXKhz585lm8Mba84tBgwYoMuXL5vF/fz83PbcYfbs2YbxgQMHKiwsTEWKFLF6G+RcuXLlNG3aNJ04cULdu3d3eP7AwEDD+I0bN2zOOXPmTLNYcHCwevXqJUnq2LGjSpYsadKenp6ub775xuY+b/KW43XlyhXDeIUKFXJcU3by+n0cHMdbri97eOo+esN17A015mWffvqpYbxWrVqaOHGiQ/oYNmyYOnTo4JBcrrRw4UKzWKFChdS2bVuFh4ebxGNjY/XLL79YnTs9PV2rVq0yi4eHh6tHjx5m8cjISIvPHlzpwoUL+u233wzbxo4d69C+3n77bfn4+Nidx5vmIE99rcnOSy+9JD8/P7ty3OqFF15Qvnz5TGLx8fFat26dw/pwFE8fX7GxsYbxEiVKOKIk9enTR5UrV7Y7jzfOLY7kDefJW89RcnKyfvjhB8O2cePGKSAgwCH9SP/d79wuKSlJixYtckh+V8y1km3zrSufYziKq8dGmTJlzOKOHB95Fffr1jG6Rj35+gQAAACQNV93FwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANwvNDTU4Tk7dOigt956y2J7RkaGunfvroiICKvyXbt2Td27d9fGjRvl6+ur7777zmLdL7zwgqKiouTj46Px48fr1KlTmjlzpgYPHqxOnTqpffv2euSRRzRp0iQdPHhQS5YsUZEiRWzaT0t8fHwstmVkZDikj/T0dJv6vyk0NFQtWrSw2L5mzZost3fFPkr27ycAAADgrWbOnGkYHzdunKpWreqwfj766CMdPnxYzz77rHx9fR2W1x5Xr17VmDFjDNt8fHw0b948Pfrooy6uyvv4+vpq5syZKlu2rGH7/PnzrcpTsWJFw/iRI0dsLc3pJk6caBj38fHRggULdMcddzikn7Jly2rBggWGbenp6XrvvfeszuWNNecGZ8+e1bBhw9xdhokff/xRV69eNYv37NlTI0eONItfvXpVS5cudUFluVu5cuX0xRdf6OjRo3ryyScVGBioqVOnqmjRog7tp0qVKmaxhIQExcbG2pxzyZIlunz5sll80KBBkqR+/fqZta1bt05nz561uU9vO15nzpwxjFetWlWlSpWyqbas5OX7ONjP264vW3jDPnrDdewNNeZVK1as0L59+wzbXnjhBQ0ZMsSu/B07dtTHH39sVw53+emnn5SSkmIWHz9+vCpUqGASW7t2reG6WVm2bJlZrHv37goLCzOLL1q0KEe5nenzzz83jN9333168cUXHdJH586d1bdvX4fkkjx/DvKG15qs1KlTRx988IFdOW5q27atRo8ebRb/9ttvXfK6bwtPHl/R0dGG8aw+e2GtsmXL6qOPPrI7z03eOLc4irecJ289R5MnTzb8XFCdOnUcdo/SoEEDTZ482Sz+zTff6OLFiw7pwxVzrWTbfOvq5xiO4s6xITl2fORV3K9bx+ga9fTrEwAAAIBl/PYLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoNDQ023USEhJ07NgxHT16VNevX7cq7+jRo1WlShWL7bGxserevbueeuopnTx50nCd1NRULV68WA0bNtSKFSskSePGjVPz5s0N11+1apW+/PJL5c+fX6tWrdJbb72l/PnzZ1lnz549tXv3btWsWdOq/bJGRkaGxTYfHx+H9JFVnvT09Gy3b9++vQICAgzbYmJi9Oeff2a5vSv2Mbtc1uwnAAAA4K1mz56tS5cumcWDg4M1b948hYSE2N3HkCFDNHjwYBUsWFCffPKJdu3apRYtWtid1xG+/PJLbdy40bDN399fCxYs0EcffaR8+fI5rYb77rtPJUuWdFp+ZypevLh+/PFHPfroo4btFy9e1LfffmtVroIFCxrGz5w5Y3N9zrZlyxYtXrzYsK1MmTLauHGjypYta1cf5cuX18aNG1WqVCnD9rlz52rfvn1W5/PGmnOLJUuW6Ouvv3Z3GZmSkpI0f/58s3hwcLDatWtnFp83b56SkpJcUVquNn36dI0YMUKBgYGZsTvvvFOLFi3K9vmitZo2bWr4vPT06dN25U1KStJ3331nFm/durVq166tHj16mLXNmTPHrj697XidOXPG4nZPPfVUjvNlJ6/fx8E+3nZ92cIb9tEbrmNvqDGvysjI0LPPPmvY5uvrq5kzZ2rcuHHy9fXNce5HH31Uy5cvd9i14mrXrl1TZGSkWbxt27ZmsWXLluU4/9q1a5WcnGwSq1y5sooUKWISS01NtSm/syxatMji78v/97//KTw83K78NWvWNHyPYQ9Pn4O84bUmO88//7yGDh1qV467775b33//vfz8/MzaPv74Y7tyO5Mnj68jR44YxocPH25XPcHBwVq8eLFKlChhV55beePc4ijecp689RwdPHhQCxcuNGx76qmn9Pzzz9uVv2rVqlq6dKnZs//ExET973//syv37Zw916ampto037r6OYajuGtsSM4ZH3kR9+vWsXSNevL1CQAAAMCynP+2BgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5Drvv/++li5dqvT0dJP4uXPnNH78eNWpU0chISGqVKmSqlSpokKFCql27dr67LPPlJaWZjGvn5+fXnzxxWz7nzZtmipUqKAGDRpowIABeu655zRixAh17dpVJUuWVK9evfTvv/9Kkpo0aaLXX3/dMM+lS5c0ePBgSdKnn36qzp07W3sIVKFCBf30008KCQmxepusJCQkWGwLDQ11SB/BwcEW265du5bt9l26dLHYtn79emVkZGS5vSv2UbJ/PwEAAABvlZCQoAkTJhi2NWnSRJs2bVLJkiVtzv/ss8/qyy+/NInVq1dPW7duVadOnWzO60i9e/fWyZMnLbY/99xzOnz4sAYOHKiAgACH9BkQEKCwsDBt3bpVP//8s4oWLeqQvK5SpUoVvf766/rnn3/UvXt3i+u98sorio+PtypnwYIFDeNxcXE21egqo0aN0uXLlw3bqlevrt27d6tbt2425e7Ro4d27dqlqlWrGrafO3dOY8aMyXFeb6w5t3j66acznz95gtmzZztlXVg2fvx4w+dh7dq104YNG1S+fHm78hcuXNjiuVq9erVduSVpxowZZjEfHx/Nnz/f7JnnlStXtGzZMrv688bj9csvvxjGX3nlFbVp08amnJZwHwd7eOP1lVPesI/ecB17Q4152a+//qrp06dbbH/nnXe0d+9ePfDAA/L19c02X8OGDbVu3TotWLBAQUFBmfFz5855/Huz2y1cuDDbddLS0rRq1aoc546Li7P4mn+rDRs26MqVKznO7ywpKSl64YUXDNv8/f31008/6eWXX7Ypd/v27bV582YVKVIkM3bmzBmbct3K0+cgb3itscaMGTP04Ycfys/PL8fbdu3aVdu2bVPp0qUN2w8fPmxveU7jyeNr7dq1hvGOHTvqiSeesKmeMmXKaMuWLWrevHlmbNeuXTblupU3zi2O4i3nyZvP0ahRoyx+ZufDDz/U9OnTFRgYmOO8HTt21I4dO1ShQgWztjfffNMpz++cOdd+9tlnNs+3rnyO4UjuGBuS88ZHXsT9unWM9sPTr08AAAAAxrL/LQ0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMj1duzYoZ49e6pKlSr65JNPdPHiRY0bN04VKlTQO++8o7///ttsm/379+uZZ55R+/btlZCQYDH3ww8/LF9fX6vq2LNnj7799lt98sknmj59ulatWqUrV65ktufPn1/fffed/P39DbcfMmSILl68qC5duuiJJ54wXOfSpUs6fvy4MjIyzNqqVq2qDz74wKpasxMXF2exLSQkxOo8fn5+6tWrl2FboUKFLG5363GzpFOnThbbVq9ene322e2jn59ftjlucuuPzwQAARkUSURBVOZ+AgAAAN5s2rRp+vXXXw3bGjZsqL///ltPPfWUxfdJRurUqaPVq1frk08+MXy/9scff2j9+vU21+xIly5dUlhYmGJiYiyuc+edd+qrr77SqVOn9Pnnn+v+++/P8n3E7QICAlSrVi099thj+v777xUdHa3ly5frnnvuccQuZKlFixbq2bOnTT8PP/ywBg4cqKefflpvvPGGFi5cqEOHDikqKkpvvvlmlsfghx9+0Ny5c62u09L7u4oVK2rYsGEu+ylfvnyOju/Zs2c1aNAgw2cAklSiRAktW7ZMv/76q3r16pXt+/XQ0FD16tVLmzZt0tKlS1W8eHHD9dLS0tSvX78sx21uqjm3iIuL02OPPaa0tDR3lyJJ2rVrl/bu3Zvtenv37tXu3btdUJExe+Yxa3+qVavmkn3ZvXu3pk2bZnE/Dxw4oPHjx1u8jrLSqVMn7dixQ7Vr1zZsX7RoUY5z3m7//v3atm2bWbxOnTpmsfnz5ys5Odmu/rzxeE2fPt0wHhgYqMjISP3vf/9ThQoVbMptJK/fx8F23nh95ZS37KM3XMfeUGNe9uyzz2r79u0W22vXrq2VK1cqOjpa8+bN02uvvaahQ4dmvt8bM2aMpk2bpmPHjmnnzp3q2LGjWY4nn3xSiYmJztwNh/vpp5+UkpKS5Tq//fabLl++bFP+ZcuWZbvOwoULbcrtTEuWLNGKFSsM23x9ffX+++9r165dWf6O91Y1atTQN998o/Xr16to0aKZ8cTERL322msOqdmT5yBvea0xsmvXLpPl559/XgcOHNDDDz8sHx+fbLevU6eOIiIitGLFChUsWNBwnePHj9tVoyt46vjavHmzoqOjDdtmzJih8ePHW11TYGCgnn32We3du1cNGjTIjF+9elWvv/66VTmy441ziyN403ny1nN04cIFPfnkkxbbhw8friNHjqhfv35WHetatWpp6dKlWrdunQoXLmzWvmXLFod9pkty3Vxrzxhx9XMMR3H12JAcPz7yOu7XrWN0jXr69QkAAADAmE+GpU9q3b6iFQ8NAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMATWfln2Q3xt9oBWFK3bl3VrVtX0n/zzL///qtt27bZNecAAAAAAAAAAAAAAAAAAAAgaz4+PmrcuLGqVauW+Xnvffv2ad++fW6uDPfff7+7SwAAAMiRe++7VwEBAfr9t98VFxfn7nIAAAAAAEAuU79BfZUoUUIHDxzU6dOn3V0OAAAAAADIpU6dOqWDBw+6uwwAXoC/1Q7AGfhb7QAAAAAAAAAAAAAAwJN1fFpqEPZ/y7tXSOs/c189edHjjz+u2bNnW2y/++67dejQIbv7mT59uoYPH27YNmvWLA0dOlSStHHjRt17770m7enp6Ro4cKC+++47SVKtWrW0Zs0alStXzmS9pKQklSlTRpcvX7ar1ubNm+v333+32G7NZ/by58+vxYsX64EHHtBLL72kKVOmmLTFx8dbzBMWFqaVK1dazF2tWjUdPnzYYvsdd9yh8+fPZ1lfdvtYsWJFnThxIsscknP3EwC8HX+r3bPwmVrAfj179tSSJUvM4ufPn9cdd9zh9P4tXa/O+H9q5s6dq0GDBpnFBw4cqG+++SZHuUqWLKk//vhDd955p8V1Lly4oNWrVysyMlKnTp3SxYsXlZCQoMDAQBUoUEB33nmn6tatqwceeEDNmze3mOfcuXNq3ry5Tp48maMana1mzZqKjIy0epxkZGToxIkTOnHihM6dO6f4+HglJibKz89PoaGhKlCggAoUKKAyZcqoSpUq8vf3z1E969evV8+ePa3+e9fHjh1TxYoVc9SHs6xZs0bdu3dXcnKy1dssWrRIDz/8sBOrsk7Xrl21atWqHG83atQoffzxx9mul5KSov379ysqKkpXr15VcnKygoKCVLhwYVWpUkW1atVSQEBAtnmGDh2qWbNm5bhOb6/ZUSxdLxUqVHDJ3PTmm2/q9ddfz3KdYsWK2f3syBrPPPOMpk6dmu06n33m/Ieh7pzHxowZo/fff98lfQUGBmrr1q1q3LixxXVSUlL022+/6ZdfftHBgwd1/PhxxcbGKiEhQT4+PgoJCVHhwoVVuXJlNWjQQA888ICqVq1qMd/y5cvVrVs3h9Q/ePBgzZkzJ9v1GjVqpF27dtndnzcer82bN6tVq1ZZrnPmzBmdPHlSsbGxSk9PN2u/cOGC4X2eEW+4j3PFPfLq1avVuXNns3inTp20bt06u/O/8MILJs+Vb5o8ebJefvllu/Pbwt7j6o3XV055yz56w3XsDTU6aq7xxvf1hQsX1vr167Mc67Z65513NH78eF26dEnFixc3a2/WrJl27Njh8H4dwdJrw023/84wJ8qXL5/lGE1NTVWpUqUcdk/vyHFZqFAh/fnnn6pSpUqW650/f16rV6/Wvn37dOHCBV25ckVBQUEqWrSoateurfvuu08NGjQw3Hb48OE6dOiQfv31V7M2W8aMJ89Bnv5aY2ns1KtXTzt27FBQUJBZW3R0tNasWaOdO3fq/PnzunLligoUKKBSpUqpatWq6ty5s6pXr55lvzdu3FCLFi20d+9eq+rMrl5n/r0iTx1fzz33nD766COL7WfPntW3336rTZs26fDhw7p69aoSExNVqFAhlSxZUlWqVFGnTp3UtWtXs+edGRkZ6tGjh86fP6/t27eb5W7btq02bdqUbY238sa5xRG86Tx58zl65513NG7cuCzXuXbtmtauXasdO3bo/PnziomJUUhISObc1aVLlyznrn///VdNmzZVTExMjuvztrn2dq58juHoed4VY0Nyzvjw5PcXrsL9unWyu0Y99frMireNVQBA3uLj46MmTZqoatWqfJ4WgNWs+Yx3zj45CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYOCrr77Se++9p+LFixu216hRQ4cOHbKrj65du2r48OGGbUePHtVzzz0nSSpUqJBat25tts78+fP13XffZS7v379fL730kr7//nuT9YKCgtS5c2fNnz/frnrt3d/ChQtr5cqVuueeeyRJH3zwgS5duqRvvvlGklSvXj35+PhY3P7o0aNZ5u/UqZPFtr179+r8+fPZ1pjdPjZp0kQnTpzIch1n7ycAAACQG1y8eFEdOnTQzz//rHLlyhmuU6pUKQ0aNEiDBg2yuZ8LFy6oU6dOOnnypM05nOXAgQNq1KiRFixYoLZt22a7vo+PjypWrKiKFSs6tI7Lly9r3Lhxmj59ukPzuspnn32m559/Xqmpqe4uxaU++eQT+fr6asqUKVm+xwwICFD9+vVVv359m/pJS0vTM888o1mzZtlY6f/xxppzi7feekudOnVSs2bN3F2K5s2bp8mTJyswMNCwPSkpSfPmzXNxVblbcnKyunTporVr16phw4aG6wQEBKht27ZWvR5lJzo6WiNGjLA7z00//PCDPv74YxUsWNDiOn/99Zd27drlkP688XgNGDBAe/fuVYECBSyuU7ZsWZUtW9Zi+/Hjx63uj/s42Mobr6+c8pZ99Ibr2BtqzMuuXr2q9u3b65tvvlH37t0dlnfy5MkaP368w/K52sKFC9W5c2eL7cuXL7c596lTp7R3717Vq1fPsH3jxo26fPmyzfmd6dq1a+rcubM2bNigChUqWFyvdOnSGjx4cI7zT506VTNmzFCbNm3sKdOEJ89B3vJac7t9+/apf//++uGHH8yeCRQvXlz9+vVTv379bMp948YN9ezZU3v37rW7Tlfw1PH1xRdfaMCAAWrQoIFhe5kyZTRmzBiNGTMmx7WMGTNGERERatq0aY63tcQb5xZH8Kbz5M3n6LXXXpOPj4/Gjh1rcZ1ChQrpkUce0SOPPJLj/AcOHFDnzp0VExNjT5lmvGWudfVzDEdy9tiQnDc+wP26tbK7Rj31+gQAAABgytfdBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAO+Xnp6unTt3WmwvXLiwXfmLFy+u2bNnG7alpaXpscceU3x8vCSpdu3a8vPzM1tv5cqVVsUkqUGDBnZU+5+rV6/q7NmzNm1bpkwZbdmyRffcc09mzMfHR7Nnz1bXrl0lKfO/lvo+dOhQln106dLFYtuaNWusqjO7fezQoUOW27tiPwEAAIDcIioqSi1atNCOHTuckn/Xrl1q3Lix/vrrL6fkd4Rz586pXbt2euGFF3Tt2jWX9h0XF6cpU6aocuXKmj59ukv7doR9+/apffv2euaZZ5Samuructzio48+0oMPPqiYmBin5L948aLCw8M1bdo0h+X0xppzg5vPmuLi4txdii5fvqxly5ZZbF+2bJmuXLniworyhujoaN1777366aefnNrP6dOn1apVK505c8ZhORMSErRgwYIs15kzZ47D+pO873gdO3ZMPXv2dOm9BPdxsJW3XV+28JZ99Ibr2BtqzMuuX7+uHj16aPjw4Xbf38fExOixxx7Tyy+/7KDq3OOnn35SSkqKYduRI0d05MgRu/JHRERYbFu0aJFduZ3t6NGjatmypXbt2uXQvP/73/80atQoh+a8yZPnIG95rbndokWL9OijjyoxMdEh+STpwoULuv/++63+PICn8MTxlZycrC5duujYsWMOqyMlJUXDhw/XBx984LCct/LGucVe3naevPkcjRs3TkOGDMn87JYjtWzZUqdOnXJ4Xsk75lp3PMdwJGeOjZUrVzp1fOR13K9b5+Y1CgAAAMC7+bq7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkDtcu3bNYltgYKBduefMmaNSpUoZtk2cOFHbt2/PXC5RooTheidPnjSLxcXF6erVq2bxkiVL2lbobTZs2GCxLSQkxDBeqFAh/fbbb6pVq5ZZm7+/vxYtWqR7771XgwYNsph727ZtWdYVFBSke++912L7mjVrstz+VlntY9++fd26nwAAAEBuc/r0abVq1Urjxo1TQkKCQ3ImJCRozJgxatq0qU6fPu2QnM6Unp6ujz76SFWqVNH777+vK1euOLW/Q4cO6eWXX1a5cuX00ksvGb6H9FQ3btzQ0qVL1blzZ9WrV08///yzu0tyu2XLlqlmzZr69ttvlZ6e7pCcaWlp+uqrr1SzZk2tXr3aITlv5Y015wZHjx7VqFGj3F2GJGnWrFk2tcE+sbGxevDBB9WrVy/D54r2yMjI0HfffacmTZro8OHDDs0tSTNmzLDYlpKSou+++87hfXrb8YqMjFTTpk21efNmh+SzBvdxsJW3XV+28JZ99Ibr2BtqzOtmzJihihUraty4cTp69GiOtr148aLeeustVa9eXfPnz3dSha5z5coVi+9TIyIi7M6/bNkyw3haWpqWLl1qd35nO3PmjJo1a6a33npLSUlJduWKjo5W9+7d9eqrrzqoOmOePAd5y2vN7RYuXKjmzZtrz549dudatGiRatWqpS1btthfmBt44vi6cOGCmjVrppUrV9pdy759+9S0adMs3885gjfOLfbytvPkzedo9uzZqlOnTo4+c5SVc+fOqX///k5/Ju8Nc607nmM4krPGRlhYmFf9zsbbcL9uvcjISK+9PgEAAAD8x9/dBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADwbs2aN3N3CQAAADni7+8vSapTt47S09PdXA0A5B358+eXr6+vbty4wfwLAC6UL18++fn5KTExUWlpae4uBwDyhPz580uSKt5VUWXLlXVzNQCQdwQGBiogIEDJyclKSUlxdzkAkGcEBgQqIDBAKckpSk5Jdnc5AJCnFC5SWAcPHnR3GQAAAAAAAAAAAAAAAAAAAIChEiVKWGyLi4uzOe+QIUMUHh5u2PbHH3/orbfeMokFBgYarpuUlGR13FKOnFq9erX69+9v2Pbqq6/qtddeM4tfu3ZN8+fP16uvvmq4Xf78+bV+/frMv69mZO3atVnW1bp168z/R/p2cXFx2rp1a5bb3yqrfSxQoIBb9xMAAADIjVJSUvTuu+9q1qxZevbZZzVw4ECVK1cux3lOnTqlmTNn6vPPP9fly5edUKlzRUdHa8yYMXrjjTf00EMP6cEHH1SnTp0UEhJiV9709HTt3LlT69at09KlS7Vz504HVewcycnJSkpKUkxMjC5cuKB//vlHBw4c0LZt27Rt2zYlJCS4u0SPc/HiRQ0YMEATJ07UyJEj1adPHxUvXjzHeS5duqQFCxbo888/15EjR5xQ6f/xxppzgzlz5igsLEwPPvigW+tYv369Tp06pfLly5vET506pcjISDdVlXcsXrxYP/74o3r27Knhw4erdevWCgoKsinXlStXtHTpUk2fPl1//PGHgyv9P7t27dLu3bvVoEEDs7aVK1cqOjraaX170/E6cuSI2rRpo6ZNm+rxxx9XixYtVLt2bfn6+jq8r5u4j4M9vOn6spU37KM3XMfeUGNeFxcXp3fffVfvvvuuGjRooHvuuUcNGzbUnXfeqUKFCik0NFSJiYmKjY3ViRMndODAAf3yyy/asWOHxe/8sHStpKamOnNX7LZw4UJ16tTJLL5s2TK7c+/cuVPnzp3THXfcYRL/9ddfnXo/5EipqamaMGGCpk2bppdeekkDBgzI8nfyt7t48aKmT5+uyZMnKzY21omV/h9Pn4O84bXmdnv37lXjxo312GOP6ZVXXtHdd99t9baJiYlavny5Jk2apN27dzutRlfxxPF16dIlhYWF6eGHH9aoUaPUqlWrHG2/a9cuvf/++1q4cKEyMjLsqsVa3ji32MvbzpM3n6Njx46pS5cuaty4sV5++WWFhYUpODg4Rzn27NmjadOm6auvvlJysmv+5q03zLXueI7hSN46NvI67tet583XJwAAAADJJ8PKpz4+Pj7OrgUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnMKeL+Pjb7UDsKRu3bqqW7eupP/mmX///Vfbtm1z2Re1AgAAAAAAAAAAAAAAAAAA5EU+Pj5q3LixqlWrlvl573379mnfvn1urgwfTP7A3SUAAAAAAAAAAAAAAAAAAADkKUeOHNHMGTPdXQYAL8DfagfgDPytdgAAAAAAAAAAAAAA4Mk6Pi01CPu/5d0rpPWfua+e3CAsLEy+vr6KiIiwav2iRYvqzJkzypcvn2F7hw4dtGHDhhzXUblyZe3du1chISFmbQkJCapfv76ioqJM4o888oh++OEHs/UbN26snTt3msXPnz+vUqVKmcS+//579enTJ8f13i4oKEhnz55V0aJFzdrS09N1//33Wzwus2bN0hNPPJHjPhMSElS2bFldvXrV4jpTpkzRCy+8YNgWERGh7t27W91fVvsouXc/ASA34G+1exY+UwvAUzVu3FitWrVSo0aNVKFCBZUsWVIhISHy9/dXcnKyrl+/rqtXr+rw4cPav3+/NmzYkCtfS/z9/VW7dm01adJEd999t8qXL6/y5csrNDRUwcHBme9Zb9y4ocTERMXGxurMmTM6c+aMoqKitGfPHu3du1fXr193857Alfz8/NSoUSO1adNGtWrVUuXKlVWsWDGFhoYqMDBQycnJiouLU0xMjI4ePaq///5bmzZt0q5du5SWlkbNQB4THBystm3bqm7duqpRo4YqV66sAgUKKDQ0VCEhIcrIyFBcXJxiY2N1/fp1HT16NPM93NatW5WamuqSOiMjI9W+fXuzeLdu3bR8+XKX1CB5z/G6KSQkRHfccYcKFy6sIkWKKCAgwHC9GzduaOPGjQ7pk/s42Mrbri9beMs+esN17A01wna+vr4W7/Nr1qypgwcPurgiOIuvr6/atGmjVq1aqV69eqpYsaIKFSqk0NBQJSQk6Pr16zp16pT27NmjTZs2aePGjUpPT3d32R49B7n7tcbS7xay+vs/tWvX1gMPPKD69eurWrVqKliwoEJDQ5WYmKhr167p/Pnz2rdvn3bs2KE1a9YoPj7erho9naeNr+rVq6tVq1Zq0aKFqlSpYvLeIjY2VlevXtXBgwe1e/durVy5Uv/884/TarGWt84t9vC28+TN5yhfvnzq2LGjmjZtqrp166ps2bKZtSclJenatWu6fPmy9u/fr71792rdunU6ceKEQ2vIzXOtO55jOIonjA3Ambz5+gQAwJP5+PioSZMmqlq1Kp+nBWA1az7j7ZNh5SfB+ePtAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALyVlX+W3RB/qx2AJXXr1lXdunUl/TfP/Pvvv9q2bZtdcw4AAAAAAAAAAAAAAAAAAACy5uPjo8aNG6tatWqZn/fet2+f9u3b5+bKMOKpEe4uAQAAIEcqVKggPz8/nT59WsnJye4uBwDyjPLlyysgIEBnz5xVYlKiu8sBgDzjjjvuUP78+XX+3Hkl3EhwdzkAkCeUKlVKISEhir4Ureux191dDgDkGcWLF1fBggV1Oeayrl676u5yACDPKFKkiIoUKaIrV67oypUr7i4HAPKUqCNRioyMdHcZALwAf6sdgDPwt9oBAAAAAAAAAAAAAIAn6/i01CDs/5Z3r5DWf+a+erxVvnz5NHDgQL3wwguqVq2aLl++rLp16+rMmTNZbufj46OFCxfq4YcftrhO8eLFFRMTk6N6fH19tXXrVjVv3tywffjw4ZoxY4ZZvEePHlq6dKlZvFWrVtq6datZ/OrVqypUqJBJ7Ouvv9agQYNyVK8l//vf/zRmzBjDtqSkJA0cOFA//PCDWZuvr69+/PFHde/ePUf9zZo1S0OHDs1ynf3796tmzZqGbU899ZSmTZuWoz6z2kfJffsJALkBf6vds/CZWgAAAACermzZsjp58qR8fX1N4hcuXFDZsmWVlpbmpsoAAIAzFC5c2OLfgytdurQuXLjg4ooAWMvS7xb4+z8A4DjMtQAAAEDu4ePjoyZNmqhq1ap8nhaA1az5jLe/C+oAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkIvFx8W7uwQAAACbJCQkKCkxyd1lAECekZGRIUm6ceOGEhIS3FwNAOQd6enpkqTExESe5QGAi6QVT5MkJSUlMfcCgAsVKlRIkpScnMz8CwAuFBoaKklKSUlh/gUAF4uNjXV3CQAAAAAAAAAAAAAAAAAAAMiFSpYsqWeeeUYjRoxQsWLFMuNFixbVzp07NXToUK1cuTLz7xncqkKFCpo2bZq6dOliMf/vv/+umJiYHNf12muvqXnz5oZtK1eu1IwZMwzbLly4YBivUKGCtm7dahIrVKhQ5v+rZk0OW7z77rt6/PHHVaJECbO2oKAgff/99xoyZIjef/99/frrr0pOTpb039+P6N27t9avX6/WrVtb1VdcXJwmTpyY5TrlypVTzZo1LbavXbvWqr5uldU+Su7ZTwAAAAAAACAvGjBggHx9fc3i3333ndLS0txQEQAAcKbq1asbxlNSUhz6O08AAAAAAAAAAIDcyN/dBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPeqX7++XnvtNcO2UqVKKSIiQhcuXNDmzZt17tw5Xb16VYUKFVL9+vXVsmVL+fn5ZZl/2rRpOa6pSZMmGj9+vGHbpUuX9Pjjj1vc9u+//1Zqaqr8/f1N4j169ND8+fNNYt26dTPMsXPnzhxWbNn169c1atQos75v1aFDB3Xo0EEJCQn6559/dOnSJWVkZOiOO+5Q+fLlre7rpZde0vHjx7Ncp1OnThbboqKi9O+//1rd303W7KPk2v0EAAAAAAAA8hofHx8NGzbMsG3GjBkurgYAALhC06ZNDeOHDh1ycSUAAAAAAAAAAADexz/7VQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQG62bt06bdq0SW3atLG4TqlSpfTwww/nOPfu3bv13Xff5Wib4OBgzZs3T/7+/obtTzzxhC5evGhx+9jYWG3YsEGdOnUyiT/88MN6+umnNW3aNKWlpally5aaPHmy2fYJCQlas2ZNjmrOzoIFC3TPPffo6aefznK94OBg1a1b16Y+Tp8+rRkzZmS7XpcuXSy2rV271qa+Jev3UXLNfgIAAAAAAAB5TVhYmCpWrGgW37Rpk44cOeL6ggAAgNN16NDBML5z504XVwIAAAAAAAAAAOB9fN1dAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD8P/buOzyK8vv7+GfTIQUIVXoH6UV6lRZaUJCigjQVBFHpIAIKUkQ6iBRRpFfpvQkoPfQOUqULgSTU1OeP7yM/cWdDNtsSeb+ui0v3Pvd9ztnZ2ZkdsmEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuN57772ne/fu2TVnWFiY3nnnHcXFxVm1bsyYMcqXL59h7IcfftCqVatemGP48OFmdU0mkyZOnKgHDx7o3r17+v3335UhQwaztZMmTVJ4eLhVPSdE165dNXPmTLvn/VvWrFk1YcKEeOe4ubmpZs2aFuPr1q2zqQdHP0cpYc8TAAAAAAAAeBl9+eWXhuPjx493cicAAODffH197Z4zS5YsatCggWFsw4YNdq8HAAAAAAAAAADwX+Pm6gYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDrXblyRTVr1tSdO3fski80NFRBQUE6c+aMVesaNGigjh07Gsb++OMPde3aNUF5tm/frjFjxhjGfHx8lDp1asPY4cOH1b9//wTVsFZMTIzatm2rQYMGKSYmxiE1unTpogEDBliMly9f3uJzj4yM1LZt22yq74znKL34eQIAAAAAAAAvm/fee0+lS5c2G79w4YKWLVvmgo4AAIAkubm5aeDAgTp37pwyZMhg19x9+/aVu7u72fiTJ0+0fv16u9YCAAAAAAAAAAD4L3JzdQMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBpOHTokEqWLKn169fblGfr1q0qWbKk9u7da9W69OnT66effjKMxcTEqFWrVnr06FGC8/Xt21dz585N8Pxjx47pzTffVGRkZILXJMZXX32lChUqOCz/4MGD1alTJ8NYvXr1LK777bffrNq+8fn7OYaEhNgln5H4nicAAAAAAADwMsmbN6/Gjx9vGBs8eLDi4uKc3BEAAJCkbNmyafv27Ro0aJBeeeUVLV26VD4+PnbJXbNmTX388ceGsYULF+r+/ft2qQMAAAAAAAAAAPBf5ubqBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQNJx9epV1atXTxUrVtT8+fN1//79BK2LiorSunXrVL9+fdWsWVNXrlyxuvaPP/6oDBkyGMaGDBmivXv3WpUvOjparVq1UufOnRUaGhrvvGnTpqlcuXK6fPmyVTUSa//+/apbt66WLl2qR48eJXhddHS01q9fr6+//loxMTEW53333Xdq3ry52XhQUJDFNevWrUtwHwmxf/9+lSlTxiXPEwAAAAAAAHhZlC1bVlu2bFGaNGnMYqdOndLs2bNd0BUAAGjcuLGOHj2qypUrPxurVKmSNm7cqHTp0tmUu0aNGvrll19kMpnMYtHR0Ro6dKhN+QEAAAAAAAAAAF4WHq5uAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJD27d+/W7t275ebmpuLFi6tgwYLKnTu3AgIC5Ofnp7i4OD148EDXr1/X6dOntWvXLj148MCmmo0aNbJT98+bPHmyZs6cqQYNGqhSpUrKkiWLPDw8dOfOHR06dEgrVqzQtWvXHFI7Phs2bNCGDRvk4+OjsmXLqkiRIipYsKBSpUqlgIAAubm56cGDB7p3757Onz+vY8eOaffu3Xr48KEk6fLly5o+fbphbjc3N02dOlXr169XeHi4JClt2rQqXbp0vP04grOfJwAAAAAAAPBfYzKZ5OnpKZPJJF9fX2XIkEGlSpVSs2bNFBwcLHd3d8N1nTp1UmxsrJO7BQAAkpQ/f36lTp3abLxKlSo6ceKE+vbtqzlz5igqKirBOQMDA9WzZ0/17NlTnp6ehnPGjx+vc+fOJbZtAAAAAAAAAACAl4qHqxsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABJV2xsrA4dOqRDhw65uhWbPHr0SIsXL9bixYtd3YqZJ0+eaMeOHdqxY4dV63788UdlyJBBw4YNM4uFhoaqQYMGCg8PfzZWu3Ztubm5Gea6fv26jh8/bl3jVnLW8wQAAAAAAAD+a5o1a6aFCxdatea7777T9u3bHdQRAAB4kVGjRqlx48YqV66cWSxDhgz66aef9M0332j16tXasWOHzp49q6tXr+rhw4d6+vSpPDw8FBgYqLRp06pkyZKqUaOGGjRoIH9/f4s1Dx06pH79+jnyaQEAAAAAAAAAAPyneLi6AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACTO8OHDlT59enXr1u3Z2LVr11S7dm2dOnXqubn16tWzmGf9+vUO69EerHmeAAAAAAAAwMvu119/Vffu3V3dBgAAL7WYmBg1bNhQu3btUr58+QznZMiQQe3bt1f79u1trnfhwgXVr19fkZGRNucCAAAAAAAAAAB4Wbi5ugEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGx19bh0eO3//bl63NUdAc7TvXt3zZkzR5J05swZVahQQadOnTKbFxQUZDHH+vXrHdafvST0eQIAAAAAAAAvs7Vr16phw4aKiopydSsAALz07ty5o6pVq2rXrl0OrRMSEqKKFSvq5s2bDq0DAAAAAAAAAADwX+Ph6gYAAAAAAAAAJH0pUqRQvXr1nhvbtm2bQkNDXdQRAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8LxT2/73B3hZtW3bVjdu3NCIESN09+5ds3jx4sWVMWNGw7UxMTHavHmzo1u0ixc9TwAAAAAAAOBldevWLX311VeaMmWKq1sBAAD/cPPmTVWvXl2ff/65+vTpo5QpU9ot99OnTzV69Gh9+eWXio6OtlteAAAAAAAAAACAl4WHqxsAAAAAAAAAkPSlT59ev/zyy3NjlSpV0q5du1zUEQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgn2JiYtS7d2+L8bp161qM7du3T/fu3XNEW3b3oucJAAAAAAAA/NfFxsbq8ePHCg0N1aVLl3TgwAFt3rxZGzZsUHR0tKvbAwAABqKiojR48GBNnz5dnTt3Vrt27ZQ5c+ZE5wsLC9PPP/+sMWPG6MqVK3bsFAAAAAAAAAAA4OXi4eoGAAAAAAAAkiI3NzfD8djYWCd3AgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYLuLFy/qyy+/NIzt3bvXyd0AAAAAAAAAsMaiRYu0aNEiV7cBAABsdP36dfXv318DBw5UqVKlVL16dZUpU0a5c+dWzpw5FRAQIC8vr+fWPH78WNeuXdP58+d14MAB/frrr9q+fbuioqJc9CwA2IvJZHJ1CwDwn8exFgAAAAAAvIiHqxsAAAAAAABIan788Ue1b9/ebHzdunWqX7++CzoCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwzaJFi1zdAgAAAAAAAAAAAABJsbGxCgkJUUhIiFnM3d1d3t7eiouL05MnTxQXF+eCDgEAAAAAAAAAAF4OHq5uAAAAAAAAIKkJCgoyHF+3bp2TOwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADwsoiJidGjR49c3QYAAAAAAAAAAMBLwc3VDQAAAAAAACQlhQsXVpYsWQxj69evd3I3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB7c3N1AwAAAAAAAElJ3bp1DccvXbqkc+fOObkbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIC9ebi6AQAAkguTyaT8+fOrQIECSpUqlVKlSqWAgAB5eHjo4cOHCg8PV3h4uG7fvq1jx47pzp07rm4ZyZCnp6dMJpPZeFxcnKKiolzQEQAAL5+6desajq9fv97JnQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHMHD1Q0AAJAUeXt7q1OnTho7dqxd8kVHR2vLli0aOnSofvvtN7vkxH/Tvn37VKJECbPx06dP69VXX3V+QwCSBQ8PD/Xr108pUqQwiy1btkz79u1zaH03NzfVrl1bjRo1Uv369ZUzZ84ErXvy5IlCQkK0evVqLVq0SBcvXnRon5JUu3Ztde3aVTVq1JCPj4/hnNjYWO3bt08///yzpk+frpiYGIf39bc33nhD5cuXN4yNGjVKd+/edVovkvTtt9+qV69ehrHDhw+rdOnSio2NdWpPn3/+uYYNG2YYmzdvnlq2bGlT/vr166tWrVpm41FRUYbbIiluI8nx2wn/XTlz5lSjRo1Ut25dlS9fXmnSpIl3/s6dO5/9/+PHj7V371799ttvWrFihQ4cOODodu1u4MCBLjuf2ip9+vSqV6+e6tevr6pVq+qVV15J8No7d+5o+/btWrt2rRYtWqQHDx44rM/evXtrxIgRDsv/TxcvXtTu3bu1ceNGrV692unnUQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkHR5uLoBAACSEpPJpI4dO2rAgAHKnDmz3fJ6eHgoKChIQUFB2rhxo/r06aPDhw/bLT8A4OU2YsQIde/e3TB28eJF7du3zyF1U6RIoQ4dOqhr167KmTOn1et9fHxUuXJlVa5cWcOHD9fatWs1ZMgQ7dmzx+69ZsmSRdOnT1fdunVfONfNzU3ly5dX+fLl9dlnn+nDDz/Uzp077d7Tv5UoUUILFy6Ut7e3WWzixIm6e/euw3v4t0GDBundd99VlixZzGIlSpRQhw4dNGXKFKf1kzVrVvXv398wFh4erh49ethcw9I+smvXLj148MBsPKltI8k52wn/PQ0aNFDXrl1Vs2ZNmUymROVIkSKFqlevrurVq2vAgAE6fvy4pk6dqmnTpikyMtLOHTvGoEGDDMcdeT61VcmSJdW9e3e1aNFCnp6eicqRLl06vfXWW3rrrbc0YcIEzZo1S19//bVu3Lhh526dK1euXMqVK5feffddRUVFafny5Ro5cqT279/v6tYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICLubm6AQAAkoqsWbNq27Ztmjx5sjJnzuywOnXq1NG+ffvUtWtXh9UAALw8goOD1b17d6fXbdiwoU6ePKlx48YpZ86cNuczmUxq0KCBdu/erZ9//lmpU6e2OeffChcurD179qhu3bpWr3311Ve1ZcsWvfXWW3brx4ifn58WL14sb29vs9iBAwfUo0cPh9a35OHDh+rWrZvF+NChQxUYGOi0fkaPHq2UKVMaxgYMGKCbN2/aXMPSfrJu3TrD8aS2jSTnbCdbdOnSRSNHjjT7Exwc7NK+XlYlS5bU77//rtWrV6tWrVoymUx2y12kSBFNnDhRZ86cUYsWLeyW11GS2z6YNm1azZ49WwcPHlSrVq3k6elpl7y+vr7q1KmTzp8/r969e9t1n3AlT09PNWvWTPv27dPChQuVLl06V7cEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABcyM3VDQAAkBTUr19fR48eVdWqVZ1Sz9PTU2PHjtWyZcvk4+PjlJoAgP+e7Nmza+bMmU6t6eHhoSlTpmjVqlXKmTOnQ2q0adNGhw4dUokSJWzOlT17du3YsUNZs2ZNdA5vb28tWrRIdevWtbkfS6ZPn668efOajYeHh6t58+aKiopyWO0XWbx4sbZs2WIYCwwM1NChQ53SR/Xq1dW8eXPD2JEjR/Tdd9/ZXCNXrlzKly+fYWzDhg0W1yWVbSQ5ZzvZqmXLlurZs6fZnxo1ari6tZdO7969tXfvXlWqVMmhdXLmzKkFCxZo/vz58vX1dWitxHLFOdUWr7/+uk6fPq1WrVo5rEaKFCk0YsQIbdq0SQEBAQ6r4wrNmzfXiRMnVL58eVe3AgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXMTD1Q0AAOBqTZs21fz58+XhEf9pMTY2VocPH9aRI0d0/vx53b17V48ePVJMTIxSpEihgIAApU+fXoULF1axYsWUI0eOF9Z+8803tXTpUjVq1EjR0dH2ekoAgJeAh4eHFi1apDRp0jitpq+vr9asWaNq1ao5vFbOnDm1Y8cO1a1bV7t27UpUDnd3d82fP1+BgYFmsevXr2vcuHFav369rl27ppiYGGXMmFFVq1bVp59+qqJFiz43383NTbNmzVLRokV169atRPVjSYcOHdSiRQvD2AcffKALFy7YtV5ifPzxxzp27Jg8PT3NYh06dNC0adN06NAhh9V3d3fXd999ZxiLi4tT586dFRsba3OdoKAgw/Fbt27p8OHD8a519TaSnLedkPy5ubnphx9+UPv27Z1a9+2331bx4sVVq1YtXb9+3am14+OKc6otmjZtqrlz58rLy8sp9WrWrKlt27apZs2aunfvnlNqOkOGDBn066+/qm7dutq+fbur2wEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJNCkSZNUqFAhs/FOnTrp9OnTLugI//brr78ajr/++utO7gQAAAB4eXHtBAAAAAAAAAAAAAAJ4+HqBgAAcKVmzZpp/vz5cnd3tzhn586d+uGHH7R8+XKFhYUlOHfBggXVtGlTffTRR8qSJYvFefXq1dOcOXP09ttvW9U7AODlNmLECJUrV85p9by8vLRy5UpVq1Yt3nlPnjzRpk2btGXLFu3evVs3b97UnTt39OjRI6VMmVLp0qVTpkyZVLFiRdWsWVO1a9eWt7e3YS5/f3+tX79eFStW1PHjx63u+aOPPlLFihXNxnfs2KFGjRqZndfDwsJ09uxZ/fzzz5o8ebI++OCD5+Lp06fXqFGj9N5771ndiyXFihXT+PHjDWNTpkzR4sWL7VbLFmfOnNGYMWPUp08fs5ibm5u+++47VapUyWH1P/74YxUuXNgw9vPPP2vXrl12qVOvXj3D8Q0bNrxwrau3keS87YTk7/vvv1f79u3jnRMTE6OdO3fq999/1/79+3X16lV5enqa7UcffvihwsPDVaxYMdWoUUNly5aN9/rq1Vdf1datW1W1alXdvn3bLs/HVs4+p9qiatWqWrBgQbzbOC4uTocOHdKWLVt05MgR/fHHH8/OxZGRkUqZMqVSp06tzJkzq1SpUqpSpYpq164tDw/Lf1VcsmRJLVy4UEFBQYqLi3PEU5MkVatWTTdv3rRqjclkkre3t3x9fRUQEKBcuXKpUKFCKleunMqUKSOTyWRxrY+Pj1auXKmSJUvqwoULtrYPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHCCUqVKqXz58mbjAQEBLugGRqpXr+7qFgAAcAofHx8VLVpUmTNnVqpUqRQQEKCUKVMqOjpaYWFhCgsLU2hoqE6cOKFbt265ut3nZM6cWXny5FH27Nnl5+cnX19feXh4KDIyUuHh4YqIiNDt27d1/Phx3b1719XtAkgErp0AAPbg5eVlOB4ZGenkTgAAAAAAAAAAcBwPVzcAAICrlChRQrNmzZK7u7vFOTVq1NCvv/6aqPynT5/WkCFDNHLkSHXu3FlDhgxRypQpDee2aNFCO3bs0Pfff5+oWvjvaN68uVKkSGE2/vTpUxd0AyCpCg4OVvfu3Z1ac8qUKapRo4bF+MOHD/X9999r9OjRFn+B4NGjR7py5YquXLmiffv2ady4cXrllVfUs2dPderUyfD45+/vr5UrV6pkyZIKCwtLcL8mk8lwG924cUNvvPFGvLmio6PVsWNHFShQQFWqVHku1qJFC/Xp00fXr19PcC+W+Pr6avHixfLx8TGLHTlyRF27drW5hj0NHjxY7777rrJly2YWq1ixolq1aqU5c+bYvW769Ok1ePBgw9i9e/fUu3dvu9Tx9PS0uI+vW7cuQTlctY0k520nJH8ffPCBOnbsaDH+4MEDjRw5UtOnTzc71mXPnt1s/smTJ7Vr1y4tWrRIkpQpUya9//776tq1q9KlS2dYo0CBAlq7dq3Kly+v6OhoG56N7VxxTk2sjBkzauHChRavYSMjIzV58mRNmDBBFy5csJjn7t27+vPPP3Xs2DFt2LBBw4cPV4YMGdS5c2f16dPH8LwkSbVr11bPnj01cuRIuzwfI3/88YddzrF/y5Qpk9577z317dtXgYGBhnMCAgI0a9YsVa5c2W51AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/Pe7u7qpZs6aaN2+uihUrKn/+/HJ3d0/Q2uvXryskJETLli3TL7/8ooiICAd3+7zAwEA1b95cderUUZUqVZQuXboEr71165b27dun5cuXa+XKlbpz547d+/v000+VOnVqm/PExcXpwYMHCgsL0/3793X//n2dOnVKN27csL1JAACAl0z+/Pl15swZw1iBAgV09uxZJ3cEAAAAAAAAAIBjeLi6AQAAXCEgIEBLliyRj4+PxTljxozRr7/+anOtp0+fauzYsdq4caN++eUXFShQwHDeiBEjtGbNGl2+fNnmmki+zp075+oWACRx2bNn18yZM51as3HjxmrXrp3F+PHjx/XWW28l6ktVN27cUI8ePfTTTz9p2bJlypcvn9mcXLlyacyYMXr//fcTnLdevXrKnTu32fiQIUN0//79F66PjY1V7969tXv37ufGPT091aFDB3311VcJ7sWSqVOnKn/+/GbjDx48ULNmzfT06VOba9jTo0eP1K1bNy1ZssQwPnLkSK1YscLuvzAyYsQIpUqVyjDWr18/u/2SR6VKleTn52c2HhcXp02bNiUoh6u2keS87YTkLUOGDBo1apTF+ObNm9WuXTtdvXo10TVu3rypoUOHatKkSRoxYoQ6dOhgOK906dL6+uuv9fnnnye6lq1ccU61xbBhw5QpUybD2OHDh/XOO+/o9OnTicp9+/ZtffXVV5o1a5Z++eUXlShRwnBe//79NWPGjGRzTLl586ZGjhypqVOnavbs2WrUqJHhvEqVKqlRo0ZauXKlkzsEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACR16dKlU9++fdWuXTsFBgYmKkfmzJnVqFEjNWrUSJMnT9ayZcs0cOBA/fHHH3bu9nlFixbVwIED9cYbb8jT0zNROTJmzKjg4GAFBwcrNjZWy5cv15AhQ3To0CG79dmtWzflzJnTbvn+7caNGwoJCdHOnTs1d+5cXb161WG1AAAAAAAAAAAAAABA8uLm6gYAAHCFCRMmKE+ePIaxuLg4derUST169LBrzRMnTqhq1ao6f/68YdzPz0+TJk2ya00AwH+Lh4eHFi1apDRp0pjF4uLiHFLTx8cn3vPTxo0bVbZsWZ09e9amOidOnFDp0qW1e/duw3j79u1VoUKFBOerWbOm2Vh0dLTmzZuX4Bx79uwx/KWH119/PcE5LHn//ffVsmVLw1iHDh107tw5m2s4wi+//KJNmzYZxjJlyqQvv/zSrvXKlCmjtm3bGsZCQkI0depUu9WqW7euxTp3795NcB5nbyPJudsJyVufPn2UKlUqw9jSpUtVr149u/3S0f3799WxY0e1b99eMTExhnN69+6tEiVK2KWetSydUx11PrVV3rx51aZNG8PYrl27VLVqVZ0+fdrmOhcuXFD16tUVEhJiGA8ICFCHDh1sruNs4eHhevPNN7V48WKLcz755BMndgQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASOp8fHw0ZMgQXbx4UT169FBgYKDd8r7zzjs6efKkxo8fr1SpUtkl7z+lTp1aM2fO1JEjR9S0aVN5enraJa+bm5uaNGmigwcPatmyZcqYMaNd8jraK6+8ouDgYH3zzTe6fPmy1q5dq0aNGrm6LQAAAAAAAAAAAAAAkAS4uboBAACcrVSpUmrdurXFeI8ePTRlyhSH1L59+7bq1KmjiIgIw3iDBg1UpEgRh9QGACR/I0aMULly5czGDxw4oM2bNzuk5kcffaRXXnnFMHbs2DG99dZbevz4sV1qRUREqFGjRrp48aJhfPDgwQnOVaVKFbOxkJAQ3b9/36qeNmzYYDZWtmxZm35JoXDhwpo4caJhbPr06Zo/f36iczvDxx9/rMjISMPYp59+qoIFC9qljslk0qRJk2QymcxisbGx6tSpk+Li4uxSS5Lq1q1rOL5+/XqrczlrG0nO305Ivry8vNSmTRvD2B9//KGWLVsqOjra7nVnzJihzp07G8bc3NysOrbbk6VzqqPOp7a6ceOGevXqpatXrz43fuvWLTVp0sTiNWZihIWF6e2337Z4fre0HyV1cXFx6tChg27evGkYr1GjhlKnTu3cpgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4VIkSJRQREaGIiAgNHTrU1e0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPCfValSJa1bt87sT79+/VzdGpzgv/r6FylSRCEhIfriiy/k5+fnkBqenp769NNPdeDAARUuXNhueStUqKCTJ0+qdevWMplMdsv7b2+++aZOnDihN99802E1HMHNzU316tXTihUrtH79emXPnt3VLQEAACAJ+69e8wBG2N+RnLC/AgAAAAAAe3JzdQMAADjbmDFjLH7BcN68eRo7dqxD61+4cEGff/65xXiPHj0cWh8AkDwFBwere/fuZuNhYWFq1qyZnj596pC63bp1MxyPiopSkyZN9ODBA7vWu3Pnjlq0aGEYq1WrlooVK5agPEa/pHDixAmr+zFa4+Pjozx58lidS5JSpkypJUuWKEWKFGax48eP65NPPklUXmc6d+6cRo0aZRjz9PTUxIkT7VKnffv2KlOmjGHshx9+UEhIiF3qSFKmTJlUvHhxw9j69eutzuesbSQ5dzsheStbtqzSpk1rGOvZs6eePHnisNrTpk3T3LlzDWMVK1ZUunTpHFbbSHznVEedT2318OFDjR07Vrly5VLr1q2fnZ/69eunW7du2b3e+fPnNXnyZMNY/vz59corr9i9pjPcv39fM2bMMIy5ubmpUqVKTu4IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgCO5ubnJz89Pfn5+8vLycnU7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD8Z2XMmFF169Y1+1OyZElXtwYn+C++/u+8847279+vwoULO6Venjx5tGfPHjVs2NDmXA0bNtSWLVv0yiuv2KGzF0ubNq2WLl2qTp06OaWevQUFBenEiRNq06aNq1sBAABAEvVfvOYBLGF/R3LC/goAAAAAAOzJzdUNAADgTNWqVVO1atUMY9evX9dHH33klD6+//57nTx50mz89OnTOn36tFN6AAAkH9mzZ9fMmTMNY+3bt9fFixcdUrd8+fLKnj27YWzatGn6448/HFJ3//79WrJkiWHs/ffff+F6b29vpUyZ0mz80qVLVvdy+fJlw/E0adJYnUuSJk+erIIFC5qNP3z4UM2aNdOTJ08SldfZhgwZoitXrhjGatWqpcaNG9uUP1WqVBo+fLhh7M6dO/r8889tyv9vderUMRwPCwvT3r17E5XT0dtIcv52QvJWvnx5w/G7d+9qzZo1Dq//2WefKSIi4tnj06dPq2PHjsqaNavu3Lnj8Pp/e9E5NamLjo7W7NmzVaRIEdWtW1ezZs1yWK358+dbjL322msOq+toy5YtsxgrUKCAEzsBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQ1rVu31pw5c+Tj4xPvvPDwcC1dulRdu3ZVUFCQChYsqCxZsihdunTKlCmTChQooEqVKumjjz7SjBkzdOfOnXjz+fn5acmSJapUqVKiey9XrpwWL16sFClSWJwTFxen33//XQMGDFBwcLDy5s2rdOnSycvLSyaTSV5eXgoMDFT+/PkVHBysL774Qr///rtiYmIs5jSZTPr+++/VuXPnRPduydWrV3X8+PEE/zl58qQuX76se/fuKTY2NkE1/Pz89PPPP6tXr1527x8AAAAAAAAAAAAAACR9Hq5uAAAAZ+rYsaPFWJ8+fRQREeGUPuLi4jR+/HhNnTpVFy9e1IIFCzR//nwdO3bMKfUBAMmHh4eHFi1apDRp0pjFJk6cqKVLlzqs9ptvvmkxNmLECIfVlaRvvvlGTZs2NRt/66239Nlnn8W71mhbSdKDBw+s7sPSZ4PAwECrc7Vt21atW7c2jHXu3FmnT5+2OqerPH78WJ999pmWLVtmGB87dqzWrVunJ0+eJCr/119/rfTp0xvGevfurXv37iUqryX16tUzHN+0aVO8v1ASH0dvI8n52wnJW5YsWQzHjxw5oujoaIfXv3v3rqZNm6ZixYppzJgxWr9+vcNr/ltCzqnt2rVzel+JtWHDBofmDwkJUXR0tDw8zP8KOXPmzA6t7UgXLlywGMuUKZMTOwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJCUtWrTQjBkz5ObmZnHO8ePHNXz4cC1dulRPnjyxOO/WrVs6e/asdu3apalTp8rDw0P169fXoEGDVKJECcM13t7eWrlypcqXL69z585Z1bu/v7+WLl0qHx8fw3hMTIymTJmiESNG6M8//7SYJyoqSvfu3dO9e/d07tw5rV69WsOGDVOmTJnUvXt3de7cWb6+voZrx48fr4MHD2rPnj1W9R6fHj16aNGiRYla6+XlpcKFC6tEiRJq1KiR6tevLy8vL4vzv/32W127dk3z5s1LbLsAAAD/KU+ePFFISIjFGAAAAAAAAAAA/xUerm4AAABnCQwMVJMmTQxj586d05w5c5zaz+zZs3Xw4EGLP5x2lMyZMytdunTy9/eXr6+v4uLiFBYWptDQUN27d0+hoaGKi4tzak8J5ebmpjx58iht2rTy9/dXdHS0wsPDFRoaqkuXLtm1b39/f+XIkUNp0qRRihQpFBkZqYiICF2+fFl37tyxW52kzNPTU7ly5VLq1Knl7+8vNzc3PX78WHfv3tWlS5f0+PFjV7f4HD8/P2XLlk2pUqWSv7+/oqKiFBERoTt37ujy5cuubg+J4O7urly5cilNmjQKCAiQJIWHhyssLEyXLl1SZGSkizt0jhEjRqhcuXJm4wcOHFCPHj0cWrt06dKG40ePHo33i/n2cODAAd26dUsZM2Z8bjxLlix69dVXderUKYtrU6ZMaTiemOPWo0ePDMct/WKBJa+++qomTZpkGJs5c6ZmzZpldW+utnz5cq1fv15169Y1i+XIkUN9+/bVV199ZXXeIkWKqHPnzoax3bt3a8aMGVbnjI/JZFLt2rUNY+vXr7cpt6O2keT87fSy8vf3V7Zs2RQQECB/f3/FxsYqPDxc4eHhunz5crL6QmmaNGkMx2/cuOG0Hnr16uXSaw1XnlOTq5s3bypr1qxm45b2p+Tg7t27io2NNfwlSj8/Pxd0BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwtYIFC+rHH3+Um5ubYTwiIkK9e/fWlClTEpU/OjpaK1eu1KpVq9SxY0eNGzdO3t7eZvMCAwM1c+ZMVaxY0ar8X3/9tTJnzmwYu3z5soKDg3Xs2LFE9S5JN2/eVO/evTV58mTNnTtXFSpUMJvj4eGh+fPnq1ixYoqIiEh0LXuJjIzUoUOHdOjQIc2YMUOpU6dWr1691LNnT3l5eRmumTp1qn7//XdduXLFyd0CAAAkPVeuXFGZMmVc3QYAAAAAAAAAAA7n4eoGAABwlhYtWhh+eVGSxo0b59xmJD1+/FghISEOr1OqVCm9+eabqlGjhooUKaJUqVLFOz88PFw7d+7Ujh07tGbNGpu+gGmkfPnyyp49u9n4qlWr9PjxY7NxPz8/vf3222rZsqXKli2rlClTGuZ9+PChDh8+rOXLl2vBggW6evWq1b0VLlxY77//voKCglSwYEGLX6y9efOmtm/frkWLFmnFihWKiYmxupYllrbPtWvXtHPnTrvksrStJal48eJ69913VadOHRUqVMjil07j4uJ05swZ/frrr1q0aJG2bdtmVW/24OXlpbp166pZs2YqX7688uTJI5PJZDj30aNHOnbsmNauXatffvlFJ06cMJyXIUMGFSlSxGz83Llz+vPPP+3af0IFBgaqVq1ahrH4XsvESJs2rWrWrGkYW7FihZ4+fWpVvsTsg0WLFlWLFi1Ur149FS5c2OJxOzo6WqdPn9aOHTu0ZMkSbd++XbGxsVb1lxwEBwere/fuZuNhYWFq1qyZoqKiHFq/ePHihuObN292aN2/bd26Ve+8847ZeKVKlXTq1Cmr88XFxTllzb+lSJFCS5YsMTyHnTp1Sp07d7a5hqt06dJFJ06cMHyv9unTRz///LMuXbpkVc7vvvtO7u7uZuMxMTHq1KlTYlu16LXXXlPatGkNYxs2bLA5vyO2keT87ZRQefPmValSpeKdky5dOsPxAgUKqHnz5lbXPHbsWKKOCUZSp06t4OBgvfHGGypdurRy5sxpcW5sbKzOnTunffv2afny5Vq/fr0ePXpklz4cwdJnW3t+ln0RexxTE8vV59Tk6sGDB4bjlq4TkovY2FjD94Sl6wkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyUPJkiXVtGlTFStWTLlz537uvoRdunRRcHCwzp8/r127dmndunU6ePCgU/srWrSoKlSo8OzxyZMn9fvvv9uUM3fu3GrevLmqVq2qggULKmPGjEqRIoWio6P14MEDXb58WUePHtW6deu0atUqPXz40NanYbEPS/ditkVISIjDXid7vh5Zs2ZVgwYNVL16db366qvKmjWr/Pz85O3trcePHys0NFTnzp3T7t27tWLFCu3du9deTwMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANiBj4+PlixZIl9fX8P4hQsXVL9+fZ05c8bmWnFxcZoyZYoOHjyo1atXK3369GZzKlSooPfff18//vhjgnKmSZNGHTt2NIydP39elStX1s2bN23q+28XL15UtWrVtGzZMjVo0MAsnjNnTnXr1k2DBw+2Sz17un//vr744gvNnDlT69evV65cuczm+Pn56dtvv9Xbb7/tgg4BAAAAAAAAAAAAAIAreLi6AQAAnKVOnTqG49HR0Zo/f76Tu3EsNzc3tWjRQv369VORIkWsWhsQEKB69eqpXr16Gj58uDZu3KhvvvlGv/76q116++yzzwy/qJgjRw5duXLl2WOTyaQOHTpo2LBhCgwMfGFeX19fVapUSZUqVdLw4cM1ffp0ffnll7p9+/YL1+bJk0djx45VcHBwgp5DpkyZ1KJFC7Vo0UKXL1/WF198oblz5yZo7YtY2j7Lly/Xzp077ZLr39takkqVKqWRI0eqRo0aCcptMplUsGBBFSxYUJ06ddLJkyfVv39/LVu2zKoeEyNFihT69NNP1bt37wTtG5KUMmVKlStXTuXKldOgQYO0fv16DRgwQCEhIc/Nq169uhYuXGi2vkePHhozZoxd+rdW3rx5DXuSjF9LWxQoUMBirYwZMybo/fRP1uyDr732moYOHWrxWP1vHh4eKlKkiIoUKaLOnTvr0qVLGj58uGbMmKGoqCir+kyqsmfPrpkzZxrG2rdvr4sXLzq0vpubm+EX/iXp8uXLDq39N0v7d4kSJZxS314mTZqkQoUKmY0/fvxYzZo106NHj1zQlX2cP39eI0eOVP/+/c1iPj4+Gjt2rBo3bpzgfC1atFC1atUMY99//72OHDmS6F4tqVu3ruH4iRMndPXqVZvz23sbSa7ZTglVp04dTZo0KVFr//4Maq02bdro1KlTiar5t3z58qlv375q1aqVvLy8ErTGzc1NBQoUUIECBfTee+/p4cOHmjp1qkaNGqUbN27Y1I8jhIeHG46nTp3auY24gKvPqcmZpV84jIyMdHIn9uXm5mY4HhMT4+ROAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANjKw8NDH330kbp27ao8efJYnOfj4/PsPoT169fXkCFDdPToUX311VdOuTdzunTptG7dOmXJkuXZ2JQpU/T7778nKl/evHk1atQovfHGG4ZxT09PpUmTRmnSpFGJEiXUunVrhYaGavjw4RozZoxiY2MTVdeS1157TVOnTrVrTkn68ssvdfDgQbvntdfrUbBgQQ0ZMkSNGze2eK+8FClSKEuWLMqSJYuqV6+uzz//XIcOHVKvXr20ZcsWm54HAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwj27duqlw4cKGsfPnz6ty5cq6efOmXWvu27dPDRs21LZt25QiRQqz+IgRIzRv3jw9fvz4hblatmwpHx8fs/HY2Fi99957du89KipKTZo00a5du1S6dGmzePfu3TV+/HiFhYXZta69nD17VlWqVNHvv/+unDlzmsWbN2+u/v37648//nB+cwAAAAAAAAAAAAAAwOncXN0AAADOYDKZVL16dcPY1q1bde/ePec25EBFihRRSEiI5s2bpyJFiticr06dOtq6datmzZpl+IVNRwgICNDq1as1ZcoUBQYGWr3ew8NDH330kY4cOaJKlSrFO7dt27Y6ceKEgoODE9Vrjhw5NGfOHC1fvlz+/v6JyuFKJpNJAwcO1P79+1WjRo1E5ylUqJCWLl2qlStXJuo1S6jXX39d586d0zfffGNTnbp162rPnj0aOnSo3N3d7dghrOXu7q6hQ4dq7969qlOnTqLz5MyZU1OnTtWRI0dUqlQpO3boGh4eHlq0aJHSpEljFps4caKWLl3q8B4CAgIsxm7duuXw+pIs/jLAq6++mqh8iXm/23qMeO+999SuXTvDWJcuXXTixAmb8icFQ4cO1aVLlwxjb775ZoLf2ylTptTo0aMNY7du3VL//v0T22K86tWrZzi+YcMGu9Ww1zaSXLedkjJb3kc+Pj4aPXq0Tp8+rfbt28vLyyvRuXx9fdW9e3ddvHhRffr0kZtb0vprt7t37xqO58qVy8mdOFdSOKcmZxkzZjQcDw0NdXIn9pMuXTqL78/79+87txkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANsmbN6/279+viRMnKk+ePFavL1asmJYuXarVq1cb3vfOnubMmaMsWbLYJdc777yjI0eO6I033rBqXWBgoEaOHKktW7bI19fXLr0kV/Z4Pbp27aojR47orbfesvo+liVLltTmzZst3qcUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4T/r06fX5558bxsLDwxUUFKSbN286pPa+ffv0ySefGMbSpk2rt99+O0F5atasaTi+Zs0a7d69O9H9xScyMlLvvfeenj59+tz4kydPtHTp0iR//8xr166pY8eOhjGTyaTWrVs7uSMAAAAAAAAAAAAAAOAqbq5uAAAAZyhZsqRSp05tGNu8ebNzm3Ggtm3b6sCBAypZsqTdc7/33nvatWuXsmTJYvfc/5QqVSrt2LFD9evXtzlXpkyZtHXrVtWoUcMwPnToUM2YMUPe3t4213rjjTe0bds2i/tZUuTh4aElS5Zo0KBBcnOzz8fC4OBg7d27Vzlz5rRLvn8aMGCANm/ebLd90N3dXf369dOiRYvk6elpl5ywjo+Pj1avXq1+/frZbR989dVXtXfvXn3wwQd2yecqI0aMULly5czGDxw4oB49ejilh5QpU1qMPXjwwCk9REREGI6/6DgQHh5uOB7fc7LE0i8HhIWFvXBtgQIFNHnyZMPY3Llz9dNPP1ndT1L05MkTffbZZxbjEydOlIeHxwvzDBgwwOJr26NHD4uvqy1Sp06tsmXLGsbWrVtntzr22kaSa7ZTUhYXF6dTp04lam2BAgV09OhRde/e3W7nIUny9vbWN998oz179ihTpkx2y2ur69evG44XKVJEGTJkcHI3zpMUzqnJVdGiReXl5WUYS+z7LinInTu3xdi1a9ec2AkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWxQqVEi7d+9WiRIlnhuPi4vTsWPHNHv2bM2aNevZ+JEjR7RlyxbD+5I2aNBAu3fvdtj9/fr27augoCC75Grbtq3mzp1rdq/Whw8favXq1fr+++/19ddfa/jw4Zo+fbr27dun2NjY5+ZWr15dq1atkslksktPjhQdHW33nPZ4PQYOHKixY8ea3ffv7t27WrNmjSZOnKihQ4dqyJAhmjBhgtauXat79+6Z5enevbsmTpxoUy8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMA2/fv3l7+/v2GsQ4cOOn/+vEPr//jjj9qzZ49hrEuXLgnKUaZMGcPx+fPnJ7qvhDh16pRmzpwpSfrzzz/Vt29fZc2aVe3bt9f169cdWtseNm7cqM2bNxvG6tWr5+RuAAAAAAAAAAAAAACAq3i4ugEAAJyhWLFiFmO//fabEztxnE8//VTjxo2TyWRyWI2SJUtq5cqVqlixop4+fWr3/B4eHlqzZo2KFy9ut5xeXl5atmyZypYtqzNnzjwb79Onj/r162e3OpJUqlQpzZ49W8HBwXbN6yjz5s1TkyZN7J43b9682rp1q8qXL6/bt2/bJeeYMWPUrVs3u+T6tyZNmujnn39Wy5YtHZIfxtzd3bV69WrVrFnT7rk9PDz0ww8/KHXq1Bo1apTd8ztacHCwunfvbjYeFhamZs2aKSoqygVdPc/d3d0pdTw8jC9ZM2XKFO+6e/fuGY6nSZPG6h5Sp05tOB4aGhrvOh8fHy1evFi+vr5msbNnz6pjx45W95KUrVy5UmvXrlX9+vXNYvnz51fXrl3jfT/mzZvXcL+XpO3bt2vu3Ll26/WfatWqZbg/P3782O6fEW3dRpLrtlNSdunSJT169MjqdeXLl9eaNWsUGBjogK7+p0yZMtq7d6+CgoJ0+vRph9VJqF27dhmOm0wmffzxx/ryyy+d3JHjJYdzalL21ltvGY4/ffpUBw4ccHI39hPfNdDBgwed2AkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAxEqRIoVWrVqldOnSPRuLjo7WxIkTNW7cOF25ckXS/+473bp1a0nSpk2b1KtXL0lSzZo19eWXX6pKlSrP1hcoUEBr165V+fLlFR0dbbdeK1eurCFDhtglV5EiRTRt2rTn7mUeGhqqXr16ad68eXry5InhuqxZs+qbb7557j7Or7/+urp3767Ro0fbpbeNGzeqdOnSNudp166dunTpIul/98+bM2eOzTn/yR6vR1BQkL766qvnxg4cOKB+/fpp06ZNiouLM1zn6emppk2b6ttvv1XWrFmfjXfp0kWbNm3SypUrbeoLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYL0WKFGrTpo1hbNOmTVq4cKFT+ujfv782b9787HFsbKx27Nih+fPny83NTbGxsfGuz5Ahg+H4qVOn7NqnkeHDh2v9+vVasWLFC/tMihYtWqRatWqZjZcsWVI+Pj4W7xkKAAAAAAAAAAAAAAD+Ozxc3QAAAM6QP39+i7Hjx487sRPHaNCggcaNGyeTyWRxzsGDB7V8+XLt2bNHZ86c0b179/To0SN5enoqMDBQr7zyiipXrqzg4GDVrFnTYp5SpUpp0qRJ+uCDD+z+PAYNGqRKlSqZjT98+FC//PKLtmzZorNnzyoiIkL+/v5Knz69ihUrpkaNGqls2bIW8wYEBOiHH35Q1apVJUmvv/66hg8fbjj38uXLWrhwoXbu3Klr167p6dOnCgwMVKZMmVSlShU1atRI2bNnt1irYcOG+uijjzRlyhQrn71z9ezZU82aNTOMXb169dm+cunSJYWHh8vT01Pp0qVT9uzZVatWLQUFBSl16tQW8+fKlUvz58+Pd19KqD59+qhbt24vnHf06FGtWrVKx44d0+3bt3Xnzh15eHgoQ4YMypQpkypVqqSGDRvqlVdeMVv77rvvaseOHbp3757N/SJhxo4da3H/OHPmjFavXq2QkBBduXJFERERcnd3V/r06ZUpUyZVrlxZ9erVU7Zs2eKtMXLkSF26dElLlixxxFNwiOzZs2vmzJmGsXbt2unixYtO6+XBgwcWY+nSpXNKD5bq+Pr6xrsuJiZG9+/fNztO5c2b1+oe8uXLZzh+586deNdNnDhRRYsWNRt/8uSJmjVrpocPH1rdS1L3ySefqGbNmvL29jaLffnllxo1apTFtePHj5eXl5fZeHR0tDp37mzXPv+pXr16huPbtm3T06dP7V7vRdto7ty5unHjhsX1rtpO1nj48KGuXr0a75wMGTIYPo8HDx7o/v37VtX7/fffrZovSa+++qo2bNiggICAeOdduXJFq1ev1u7du3Xjxg399ddfzz5bZM6cWdWqVVO9evWUPn16izmyZ8+uLVu2qEyZMrp+/brVvdrTsWPHdOfOHcNja/fu3TVv3jydOXPGBZ05RlI6pyZH6dOnV9euXQ1jK1eu1KNHj5zbkJ0EBgaqXbt2hrHbt28rJCTEyR0BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASIwePXood+7czx5HRESoQYMG+u233xK0fsuWLdqyZYs6d+6s77777tn9wUuXLq2BAwdq4MCBdukzXbp0WrBggdzd3e2Sb9q0afL09Hz2+MyZM6pWrZpu3boV77qrV6+qVatWunbtmnr37v1svF+/fpoyZYpd7rV6//59HTx40KYcvr6+z917e+LEibpy5YqtrT1jj9fDZDJp9OjRz91TfsaMGfrggw8UGxsb79qoqCjNnz9fGzdu1ObNm1WiRIlnseHDh2vlypWJ7gsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgOTK29tbvr6+evz4sR4/fuzqdqzi7+8vDw8PPXjwQFFRUa5u54W8vLzk5+enJ0+e6NGjR65ux+H+3rciIyP14MEDV7eTbKVIkUIpUqTQo0eP9OTJE4fU8PDwkL+/v548eZJkjwPJ7f3+9/7vyNctOXJ3d5e/v79MJlOyeS0T4+/3bWxsrMLCwhQXF+fqlpK85s2bK1WqVIaxPn36OK2PLVu26Ny5c7pz547mz5+vxYsX6+bNmwlamyJFiufueflPL7rvpT1cunRJly5dcngdR9m0aZPhuLu7u3LlyqVTp07ZpQ7HoaQrOZw7k/O1k714enrKz89PsbGxCg8PT3L7VnK9BknK+//Lctx0Nq7z/ie5Xefh/yTl41ZSwf79YsllP+K1dK6k/nkzqeOz24slx2sGPjv+D8fj5/F+BwAAAPBf5uHqBgAAcIZ8+fIZjl+9ejXZ/AW2JZkyZdLs2bNlMpkM4/v27VO3bt20a9cuw3hMTIyuX7+u69ev68CBAxo/frzKlSunadOmqVixYoZr3n//ff3444/avXu33Z5H4cKFzb7AGhMTo3Hjxunrr79WWFiY4bpVq1Zp6NChqlq1qiZPnqxChQoZzqtSpYqaN2+uVatWadasWWbb68aNG+rdu7fmzp1r8YdmixYt0meffaZOnTpp2LBhCggIMJw3ZswYLVmyRHfu3HnR03aJAgUKaNiwYWbjJ0+eVP/+/bVs2bJ410+fPl2+vr7q1auXevXqpZQpUxrOq1Gjhtq3b6+ffvop0b3WqFFDQ4cOjXfOqlWr1KtXL505cybeeTNnzpQkBQcHa8yYMcqbN+9z8W+//Vb9+vVLdK9IuOrVq+uTTz4xG9+yZYu++uor/f777/Gunz17tiSpfv36GjZsmIoXL25x7s8//6yjR4/q7NmztjXtBB4eHlq4cKHSpEljFpswYcIL35v2FhERobi4OMPzS8aMGZ3Sg6U6Hh4ecnd3V0xMjMW1ISEhqlWr1nNj8e0rlpQoUcJsLDQ0VBcvXrS45t1339UHH3xgGOvatauOHj1qdR/JwYULFzRixAgNHDjQLObn52dxXcOGDVW/fn3D2Lhx43Ty5Em79fhvQUFBhuPr1q1zSL0XbaORI0eqVatWhmtduZ2sMXPmzGfnXEt2796t8uXLm41Pnz5d3bp1c1RrkqTAwECtWbPG4uc4STp8+LD69OmjjRs3xpvrp59+kslkUosWLTRs2DDlypXLcF7mzJm1atUqVaxYUU+fPrWpf1stXLhQH3/8sdm4n5+f1qxZo9q1a8d7fEsukto5Nbnx9PTUrFmzLP7i4bhx45zbkJ2YTCZNmTJFGTJkMIzPnDkz3s8WAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJKODz/88LnHn3zyiX777Ter83z//feKjY3V5MmTn411795dEydO1F9//WVzn3PmzFGWLFmePR47dmyi7934zjvvqEKFCs8eh4aGqk6dOrp161aCc3z++eeqU6eOcuTIofnz5+vnn3/Ww4cPE9WPI3Tv3v3ZPW3v3bv3wvtbW8ser0dcXJy6du2qPn36qFatWtq/f78+/PBDxcbGJjjH3bt31bx5cx0/flxeXl6SpEKFCqlEiRI6fPiwVf0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJCcZMmSRY0bN1bVqlVVvHhx5cyZ89m9fCQpOjpaly5d0tGjR7Vx40YtX77cqns1OYq3t7eCgoIUFBSk4sWL69VXX1WaNGlkMpmezYmMjNTly5d1/Phx7dq1S8uXL9cff/xhtx4KFSpkNnbr1i3dvXvXcH6aNGnUuHFj1a5dW8WLF1fu3Lnl7e39LB4TE6ObN2/q6NGj2r9/v5YtW5as76NUpEgRvfHGGypbtqyKFSumLFmyyNPT81k8Li5O9+7d04kTJ57tXxs3btSTJ08SVS9z5sxKnTq12fjDhw91+fLlxD4Nizw8PJQ/f36z8djYWJ0+fTretdbuOzVq1FCLFi1UoUIFFShQwOw9euXKFR0+fFhbt27V4sWLdfv2bSufjVSyZEm9++67qlixoooWLSp/f/9nsUePHumvv/7S0aNHtW7dOq1du9Yh29SS5Ph+DwwMVLNmzVSjRg2VLFlSOXLkeO51+3ubnjp1Sps2bdLGjRt1/PjxRPWWLl06ZciQwWI8e/bshuOpUqUyfF7xiYyMtGm7li1bVjVr1lTZsmVVokQJpUuXTn5+fmY1rl27puPHj+vQoUNavXq19u/fn+iazubp6anXX39ddevWVbFixVS4cGGlT59e7u7uz+bExcXp/v37Cg0N1ZEjR7R9+3Zt375dR44csbpecnr9rdWuXTvD8V9//VWHDh1yWh+SVLx4cT1+/NjqdXFxcRZj/zyGwdi1a9csxjJnzqxTp05ZnZPj0P/Y8zhkSVI+dyZWcr12sqcSJUqoYcOGeu2111S0aFFlyZLluWuauLg4hYeH6+TJkzpw4IDWrl2rjRs3KiYmxin9OfsaxJL/0v7vyuNmhgwZlC5dOrPx+LaltUwmk1599VWz8YRc1/0b13nWSY7XeX/3XaxYMeXNm1epUqWSv7//cz1PmDDB7seU+Fj6TH/y5Emb8ySV41ZyvOZx9f7tqn07Ke9HieXs1zI57u/25qrPm8743CHZ97OHEWd/dotvn02q+2tyvWbgs6PrPztKSevz48vwd1wAAAAA8E+muPi+gfHPiXwZAwD+U1IESDlKSmmzSSlSSTFR0qP70o0z0tUTUmy0qzu0rwMHDqhUqVJm47t371bFihVd0JH9TJkyRR07djSMjR49Wr1791ZsbKzVef38/LRixQrVqFHDML5ixQq9+eabVuedP3++3n77bbPxAwcOqHTp0s8eh4aGqnHjxtqxY0eCc/v7++vXX399Ls8/7du3T8uWLdPw4cOfG9++fbuaNm2qO3fuJLhW6dKltXXrVgUEBBjG+/btqxEjRiQ4398sbZ/ly5ercePGdskVEhKi11577bmxMWPGqG/fvoqKirKqRpkyZbRu3TqlTZvWMH716lXlypVL0dHWH1S8vb11+vRp5cyZ0zD+6NEjvfPOO1q5cqXVuT09PTVmzBh16dLlufE///xT2bJlM5vfo0cPjRkzxuo69lC2bFnt3bvXMJYjRw5duXLFbrUqVqyonTt3GsYyZsxo9Q/KLO2Dt27dUsaMGZ89joqKUufOnTV9+nTrGv7/vvjiC3399dcWr1k2b96s2rVrJyq3M40aNUo9evQwGw8JCVHFihVf+P5ctWqVGjZsaDbesWNHTZs2LVE9Xb16VVmyZDEbX7RokVq0aJGonNb4/fffValSJcOYt7e3IiMjLa4dMGCABg8ebDaeN29enT9/PkH13d3d9ddffylNmjTPja9atUqNGjUyXJMvXz4dPHjQ7AeMkvO2myt5e3vr1KlTypUrl1mscuXKZscYLy8vnTx5Unny5DGbf+3aNRUoUEAPHz50SK+FCxe2+IWp/Pnz69y5cw6pG982kpLednKE3bt3q3z58mbj48aNU7du3Rxae9asWXrvvfcMY7Gxsfr888/17bffWp3X09NTo0eP1ieffGJxzvDhw9WvXz+rc9tTtmzZdP78+ee+0PNPoaGh+uyzzzR37lzDX9rKnj272ZdaKlWqpF27djmk38Sy5ZzqiPNpcpImTRrNnDlTwcHBhvFffvlFTZs2talG7969LV4rZcmSRdevX7cpvxFvb2/Nnj1bzZo1M4zfv39fefLkUWhoqN1rAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACSlgT+s+yG+LfaAVhSrFgxFStWTNL/jjMXLlzQnj17bDrmAAAAAAAAAAAAAAAAwLJs2bI9d1/fv/76S5kyZTK8l3epUqV04MABSf+7112vXr0Mc/59r8X9+/drzJgxWrx4sWJiYmzqs2/fvs/dT3v06NFauXKltm/f/mxsypQp6tSpU4Lybd26Va+//vqzx127dtX48eOt7itLliz666+/4r03rCukT59e58+fl7+/vySpZ8+eGj16tN3y2/v1kP63f8XFxenQoUOJ6unf91D86KOPNHXq1ETlAoCXkclk0muvvab8+fM/+7730aNHdfToURd3htatW7u6BQAAAKsUKlxI7u7uOnv2rJ4+eerqdgDgpVGgYAF5eXnp/B/n9ejRI1e3AwAvjdx5csvX11eXLl5SRESEq9sBgJdCjpw5FBAQoGtXryk0NNTV7QDASyNzlsxKmzatbt64qb/++svV7QDASyNjpozKkCGDbt++rVs3b7m6HQB4qZw5c0Z79+51dRsAkgH+rXYAjsC/1Q4AAAAAAAAAAAAAAAAAAOB8/FvtSQvfqQUSrkqVKhowYIBq1apl1e+rREdHa86cORo0aJAuXbr0XOzv+0/9W7ly5bRv3z5bW5b0v/tmff7553rvvffk5+dn9fr9+/dr2LBhWr58uc29GB1b+vTpo2+//fa5saxZs2rAgAFq166dPD09rapx+vRpDRs2THPnzjW8N5i1LB0P7fU7S56enmrTpo169uypAgUKWL3+4cOHmjNnjkaMGKGLFy9atfb999/X9OnTzcbv37+vTJky6elT+/67102bNtXixYvNxtetW6f69evHuzah+05QUJDGjRunggULJrivmJgYzZo1SwMGDNC1a9deOL98+fIaN26cypUrl+AasbGxmjdvnvr376/Lly8neJ21kuP7PXPmzBo8eLBat25t9fv9t99+08CBA7Vt2zar1g0cOFCDBg2yak1i/fbbb6patapVazw9PfXRRx/po48+UqFChRJV9+rVq5owYYKmTp2q8PDwROVwtEyZMqlnz5768MMPFRAQkKgc+/fv1/Dhw7V8+fIEf35N6q9/Yvn6+urevXuG76PWrVtr9uzZTunDHh4/fiwfHx+z8aJFi+r48eMu6Mh6Fy9eVM6cOc3GW7RooUWLFjm09r1795Q6dWqz8TfeeEMrV65MUA6OQwmXmOOQJUn53Gmt5HrtZC8pU6bUhx9+qM8++0y5cuWyev1ff/2lcePGaezYsXr8+LHd+3PlNYglyX3/TyrHzeHDh6tv375m40bbMrFSpkyphw8fmo0/ePDg2X2dE4rrvIRJjtd5bm5uatasmT788ENVq1ZNHh4eFnOmTZvWqf/2tb3+nicpH7eS0zVPUtm/XbVvJ+X9yFquei2T0/5uT0nh86YzPndI9v3s8TdXfnZz1j5r6/6anK8Z+OyYNM6tf3P158ekcq0GAAAQH5PJpDJlyihfvnx8nxZAgiXkZ9NuTugDAJCEBGaTGvWTuiyQGn0uVWollQqWyjSRqrWX3h4hfbJQqvSe5JXS1d3aj9EX5STp5s2bzm3Ezkwmk1555RXD2OjRo9WzZ89E/6LEgwcP1KxZM4vbqFGjRsqXL1+ichspXbr0s/8PDw9XzZo1tWPHDqtyREREqF69erp//75hvGzZsvryyy+fG9uxY4fq1q2rO3fuWFXrwIEDatOmjcV4586d5eaWND9qvfbaa8897tq1q3r06KGoqCirc+3fv1916tSxuDZr1qx68803E9OmevXqZfgFW0kKCwtT7dq1E/xl13+LiorSJ598omHDhj03ni1btkTlg3UyZsz47P+joqIUHBxs+AtLCTV06FA1bdpU0dHRhvFatWolej90luDgYPXo0cNsPCwsTM2aNUvU+9MeLP3FU506dRx+jEuVKpXhl4ETavXq1YbjXbp0SXCOd955R2nSpDEbX7NmjeF8b29vLV682PAHsOfPn9cHH3yQ4NrJ1dOnT/XJJ58YxiZNmmS23/Ts2VN58uQxnN+1a1fDL4LYS926dQ3HL126pHPnzjmsbnzbSEp62+m/pEaNGnrvvfcMY0+ePFHjxo0T/WWmqKgoffrpp+rUqZPFv5Dr1auXihQpkqj89vLnn39q4sSJFuOBgYGaPXu2jh49qq5du1q81kjKkuo5NalLkSKFPvjgA504cULBwcGGc65du6aOHTs6uTPbuLu7691339WZM2fUrFkzi/PatWvn1C+pAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEi8LFmyPPf4+PHjib6X9986duyoSpUqqWzZslqwYIFiYmJsyle5cmUNGTLk2eM9e/aob9++ic6XLVs2Va9e/dnjv/76S99//32icl27dk2RkZGJ7sVRBg4cKH9/f0nSlStX4r3/orXs/Xr87eDBgzp06FCi1x8+fPi5x//etwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASO7Sp0+vpUuXaseOHapdu7ZMJpNV6z08PNS2bVsdP35cnTt3dlCX5jw9PTV06FCdP39enTp1kp+fX6LylClTRsuWLdNvv/2m3Llz27lLc23bttWpU6fUoUMHeXp6Wr2+YMGCmjVrlg4fPqxixYo5oEP7qVOnjs6dO6cffvhBBQoUSFQOX19fdezYUefOndOYMWPk4+OT4LULFizQgwcPzMZTp06tRo0aJaqf+LRq1cpw/KeffrI5t7u7uyZOnKj169erYMGCVq9t166dTpw4oQYNGlic5+bmplGjRmnXrl0qV66cVTXc3NzUqlUrnT17Vm3btrVqbUIk1/f7u+++q7Nnz+r9999P1Pu9SpUq+vXXX7VkyRL5+vo6oEPbnThxwqr5lSpV0uHDhzVhwgQVKlQo0XWzZs2qb7/9VpcuXVKbNm0SnccRTCaTevbsqYsXL6pHjx4KCAhIdK4yZcpo6dKl2rlzp1555RU7dmkf1r7+tqhSpYrh+yg6OlorVqxwWh/2cOfOHcPxpH5eTyqePHliOO7h4ZGg9RyHrOPs41BSP3cm12sne3rnnXd06dIljRs3Trly5UpUjvTp02vo0KE6d+6catSoYdf+XH0NYoukuv+/DMdNV+E6L3le5xUsWFB79uzRggULVLNmzQR/BvkvSqrHLXtK7DVPcty/XbVvJ/X9KDm+lonlzGv8+CT1z5tJ3cvy2c2W/TW5XjPw2TH5Ho8ddY59Wd7vAAAAAGCJm6sbAAA4T5HaUttJUsGqkimeM4C3r1SppdTmOyltduf150iWfgB2//595zZiZ3FxcXrjjTdUqlQpLVu2THFxcZKk3bt3q3fv3jbnDw0NtZjHZDKpXr16Ntcw8sEHH+jw4cOJWvvXX39p8ODBFuP//GHEzZs31axZM4tfpnyR5cuX69dffzWMZc+e3eofErjC2LFjNX78eJtyHDx4UMOGDbMYb9mypdU5U6RIoR49eliMt27dWrt27bI677998cUXWrZsmc15kHjdunXThg0bbM6zdOlS9e3b12LcHsdER8mePbtmzpxpGGvXrp0uXbrk3Ib+ISQkxHA8derUCgoKcmjt5s2by93dPdHrDx06pO3bt5uNd+rUSSVLlnzh+gwZMhge20JDQzVr1izDNePHj1fx4sXNxp8+fapmzZopIiIiAZ0nf2vWrNGqVavMxosXL66OHTs+e5w1a1Z98cUXhjk2bdqkJUuWOKxHSapbt67h+Pr16x1aV7K8jaSkt53+S4YMGWIx1qVLF61cudLmGlOmTNHw4cMNYx4eHvryyy9trmGrPn36aOfOnfHOKVKkiMaOHavr16/rwoULmjt3rnr16qWaNWs6qcvEScrnVGfKlSuXypYta/FPuXLlVKtWLTVt2lR9+vTR0qVLdePGDf3www8Wf9kpNDRUDRs21N27d538bKwTEBCg1157TW3atNFPP/2k27dva+7cucqRI4fh/Li4OH366adavny5cxsFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkGienp7PPU7sPar/6ejRo3a5Z7IkpUuXTgsWLHh2b9bQ0FA1b95c0dHRic7ZsGFDmUymZ49XrFihqKgom3tNKnLnzv3c/Tz79++vyMhIu+R2xOthL/fv33/ucYoUKVzTCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADlC2bFkdP35cjRs3tjmXr6+vJk2apGnTpsnNzc0O3VmWNWtW7du3T/369TO7b1ZiVa5cWUePHlWDBg3sks/IuHHjNGPGDPn5+dmcq2jRotq/f7/atm1re2N25ubmpkmTJmnDhg3KkSOHXXK6u7urW7duOnr0qAoWLJigNQ8fPtT8+fMNY/bebqlTp1a9evXMxkNDQ7Vy5Uqbcru5uemXX35Rly5dbMqTKlUqrVq1Sm+//bZZzMvLS2vWrFGPHj2euyebtby8vDRjxgwNGDDAllafk1zf70OGDNHcuXPl6+trc6633npLe/bsUc6cOW1vzM5OnDiR4Llt2rTR9u3bVahQIbvVT5MmjX7++WctXbpU3t7edsubWAEBAdq6datGjhwpHx8fu+WtUKGCDh48qHLlytktpz1Y8/rbqkaNGobj+/fvV3h4uNP6sIdz584Zjtvj89jLwJbzFMehxHPGcSipnzuT67WTvaRIkUJLlizRvHnzlD59ervkzJIlizZt2qTevXvbnCupXIMkVlLd/1+G46arcJ2XPK/zypUrp927d6tMmTIOq5FcJNXjlr0l5ponOe7frtq3k/p+lBxfS1s48xrfSFL/vJkcvEyf3RKzvybnawY+Oybf47GjzrEv0/sdAAAAACxJHj9lBQDYrERDqX4PycMr4WvSZJZajv7ff5M7Sz9Ie/LkiZM7cYxDhw6pSZMmKlq0qBYsWKBPPvlEsbGxdsm9cOFC3b171zBWtWpVu9T4p+XLl2vx4sU25Zg2bZoeP378wnndunXT7du3bao1duxYi7Gk9mXlfztx4oTdfgA4YsQIi19Crlmzptzd3a3K17JlS6VOndowNmPGDJt/seSfOnbsqDt37tgtHxLut99+06RJk+yWb/To0Vq7dq1hrEKFCipdurTdatmLh4eHFi5cqDRp0pjFJkyYoGXLlrmgq/8TX/2hQ4c6rK63t7cGDhxocx6jHr29vbVu3TpVr17d4roCBQpo48aNypYtm1ls7NixhueYFi1aqGPHjob5evTooUOHDiW88f+ATz/91PBz1tChQxUYGChJGjNmjFKmTGk2JzIyUh9//LFD+0uZMqWqVKliGFu3bp1Da//N0jaSks52+i+pUKGCKlSoYBibM2eOfvzxR7vVGjBggLZt22YYa9KkifLkyWO3WokRHR2tJk2a6ODBgwmanytXLr377rv69ttv9dNPP5nFW7ZsqTfeeEP58uVz6S90JPVzqjMNHDhQe/futfhnz5492rRpkxYvXqxvvvlGjRs3VqpUqSzmu3DhgqpXr67Dhw87vPfDhw/rxo0bVv25efOmwsPDFRsbq7CwMO3fv18///yz2rVr9+xYaiQsLEwtWrTQxIkTHf68AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANjPvXv3nnucIUMGF3VibM6cOcqSJYskKS4uTq1bt9aff/5pU85SpUo993jVqlU25Utqhg8fLk9Pz2eP58yZY7fcjng97OXf92CMiIhwUScAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANhXtWrVtGXLFrvfZ+rDDz/U1KlT7Zrzn/Lly6ddu3apRIkSCZofHR2tx48fJ2iur6+vli9frhYtWtjQobFx48bps88+s2tOLy8v/fTTT/r000/tmtcWPj4+WrFihTp37uyQ/H+//pUqVUrQ/GnTphmOBwUFKVOmTHbrq1mzZvLy8jIbnzdvniIjI23KPXnyZL3xxhs25fibyWTSzJkzVa5cuefGFyxYoLp169qlhiQNHjxYrVq1sjlPcn2/f/HFF/riiy/smrNIkSLauHGj/P397ZrXVidOnEjQvHbt2mnGjBlyd3dP0PzHjx/r0aNHiouLS9D8xo0ba8OGDfL29k7QfEdIkyaNtm3bpurVqydofmxsrB4+fKjo6OgEzc+UKZNWr16tbNmy2dClfSX09beHokWLGo7v3LnTaT3Yy+bNmw3H33rrLZUsWdLJ3SQ/qVKlMhx/0fGf45C5pHQcSurnzuR67WQvgYGB2rZtm9566y2753Zzc9OIESNsev2T2jWItZLq/v8yHDddieu85Hedlzt3bq1fv16pU6e2e+7kJqketxzB2mseZ+zf9uaqfTup70fJ9VhlC2de4/9bUv+8mRy8bJ/drN1fk/s1A58dk+fx2FHn2Jft/Q4AAAAAlni4ugEAgONlKSTV6pS4tT7+UpNB0oxOUmzCvhuVJPn6+hqO2/rl9KTmxIkTeuedd+yaMzIyUqtWrVLbtm3NYlWqVLFrrbi4OPXp08fmPA8fPtS6devUpEkTi3OOHj2qBQsW2Fxrw4YNCg8PV0BAgFmsQoUKGjdunM01HOWzzz5L8JceX+Tx48eaN2+ePvroI7OYv7+/ChYsaNUPptq0aWM4HhkZaZd95J/++usvjRo1St98841d8+LFevXqZfecgwYNUv369Q1jb7/9tg4cOGD3mrb45ptvVL58ebPxkJAQ9ezZ0wUdPe/QoUP6448/lDdvXrNYyZIl1bFjR4d8eXfAgAHKmjWrzXk2bdqk77//3uwH3BkzZtTWrVu1fft2rV+/XlevXlV0dLQyZcqk6tWrq379+oa/2LZv3z7DY0WePHn0ww8/GPawdOlSTZo0yWKPGTNmVIMGDVS4cGFlzJhRgYGBevjwoW7duqXLly9r48aNOnLkiJXP3PUuXbqkYcOGafDgwc+Np0mTRsOGDdPChQvVrFkzw7WjRo3SuXPnHNpf9erVDX+QGxUVpa1btzq09t8sbSMp6Wyn/5IOHToYjkdHR6tfv352rRUbG6u+fftqz549ZjE3Nze1b9/e5V/Aun37tipXrqxZs2apadOmNuXq3Lnzs+Ps06dPdeTIEe3bt0979+7V1q1bdf36dXu0/EJJ/ZyaHMXExGj69Onq3bu3wsPDnVIzffr0Dq8RFxenefPmqW/fvrp69arD6wEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwr2vXrikuLk4mk0mSVLx4cQUGBio0NNTFnUl9+/ZVUFDQs8ejR4/WmjVrbM5bokSJ5x4nx/udWlK6dGmz+3fGxcXZJbejXg97KV269HOPz54966JOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwnzx58mj58uXy8/OzOOfp06faunWr1q5dq6NHj+rWrVu6f/++vL29lTZtWhUtWlS1atXSG2+8oYCAgOfWfvDBBw65l1NgYKA2btyobNmyWZxz9OhRLVy4UBs3btT58+d17949SZKXl5fSpUun1157TXXq1FHLli2VOnVqs/UeHh6aOXOmLl26pL1799ql79atW+uzzz4zG4+MjNSGDRu0bt06HT58WDdv3tSjR4/k6+urjBkzKl++fKpbt67q1atn2KskmUwmjRs3ThcuXNDq1avt0q8tZs+erYYNG1qMx8bGavfu3Vq1apX279+vmzdvKjQ0VClTplTGjBmVN29e1a9fX3Xr1rX4nNOkSaM1a9aoQoUKOnXqVLz9hISE6MiRIypevPhz4+7u7mrZsqVGjx5t9XM00qpVK8Pxn376yaa8TZo0UYcOHczGL1y4oJkzZ2r79u26fPmynjx5osDAQL3yyiuqUaOGmjZtqvz58xvm9PLy0o8//qgSJUooOjpaPXr0UOPGjc3m3b9/XwsWLNDatWt1+vRpRUREyM/PTxkzZtRrr72mxo0bq1q1ahZ7//7777Vz505dvHgxUc89ub7fa9WqpcGDB5uNx8XFaceOHVq+fLlCQkJ07do1PXr0SAEBAUqfPr1Kliyp+vXrKygoSO7u7oa58+XLp5kzZ6pJkybx9nD16lXt2bPHYjxt2rTKly+f2XhoaKjV92s7fvz4C+fkzp1b33333bP7G/7b9evXNW/ePG3YsEHHjx/X7du3FRsb+yweGBio/Pnzq3LlynrrrbdUvnx5wzzVqlXThAkT1LFjR6ueg73MnTtXJUuWtBj/7bfftGTJEu3cuVNnz55VRETEs5i/v79y5cql6tWrq3Xr1mb30ftbunTp9Msvv6hSpUqKiooynJPUXn97MepZ+t9xILlZt26dhg4dajZuMpm0fPlyVa5cWX/++acLOkv6/P395ePjYxgLCwuzuI7j0P846zhkraRw7oxPcr12shcvLy+tWrVKZcuWtTgnJiZGO3fu1Nq1axUSEqJbt27p7t27MplMSpUqlfLly6eqVavqnXfeUebMmQ1zDBkyRH/88YcWLlxodY9J7RrEGkl1/39ZjpuuwnVe8rvOc3d319KlSy0eI14mSeG4lVSveZy1f5crVy7Z79tJYT+KT1I6ViXV/d2eksPnzaQuKX12i2+fdeX+mpyvGfjsmDSOx9Zy1Dk2Kb3fAQAAAMDVTHFxcXEJmmjhIgoAkPS1GitlftW2HJu/lw6utE8/rmDpdDdu3Dh169bNLjXWrFmj3Llz2yXXtWvXVKtWLbvksodOnTrp+++/N4ylTJlSjx8/TnCu+fPn6+233zaMbdq0SXXq1ElUj//28ccf67vvvrMY/+ijjzR16lS71Fq/fr2CgoLMxs+ePasCBQpYlcvS9lm+fLnhDyESk0uSDh8+HO+XJBOjXr16Wrt2rWHsnXfe0YIFCxKUx9/fX6GhofLw8DCLzZ49W61bt7apTyPp0qXTtWvX5OXlZRjv0aOHxowZY/e6CVG2bFmLP3zJkSOHrly5YrdaFStW1M6dOw1jGTNm1O3bt63KF98+ePDgQYtfsLXVzp07VbFiRbPxY8eOqVixYg6pmRjBwcFaudL85BoWFqYSJUro0qVLVuVbtWqV4Q9zO3bsqGnTpiW2TXXo0MHi8TIqKkpBQUH69ddfE53/31q0aJGg44W3t7ciIyNfOM/Ly0vbtm1ThQoVbOrr5s2bqlixotkPbb28vLRnzx7DY+rFixdVsmRJwy/nly9fXt98842qVq36wuvtP//8U8OGDdO0adOe+6FlUuft7a0TJ04oT548z43Hxsbq6tWryp49u9may5cv69VXX7Xqs0ViTJw4UV26dDEb3759u6pXr+7Q2v9kaRtJSWM7Ocru3bsNf8huz8/m/2QymXTz5k1lyJDBLDZ//ny9++67dq8pSb///rsqVapkNn706FGzX9B1peDgYH377bcqWLCg3XPHxsZq27Ztmj17thYuXOiwfdae51RHnU+dacaMGWrbtq3NeUJCQvThhx/q8OHDNuf6p969e2vEiBF2zWmN27dva8yYMZo5c6Zu3rzpsj4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK6RwH+W3RD/VjsAS4oVK/bs3z2Ni4vThQsXtGfPHpuOOQAAAAAAAAAAAAAAAIjfsWPHVKRIkWePJ02aZHivylKlSunAgQOSpFGjRqlXr14O66ly5cratm2b3N3dJf3v/o1VqlRRTEzMszlVq1bV9u3bnz2eMmWKOnXq9MLcDx48kK+vryTp0aNHz/7/n1KmTKlSpUopb968CggIkJubmyIiInT58mUdPnxYd+7csfUpOsTWrVv1+uuvP3u8ZcsWu9zj3ZGvhz0ULFhQx44de3Yv76ioKL3yyiu6e/euU+oDwH+ByWTSa6+9pvz58z/7vvfRo0d19OhRF3eG1q1bu7oFAAAAqxQqXEju7u46e/asnj556up2AOClUaBgAXl5een8H+f16NEjV7cDAC+N3Hlyy9fXV5cuXlJERISr2wGAl0KOnDkUEBCga1evKTQ01NXtAMBLI3OWzEqbNq1u3ripv/76y9XtAMBLI2OmjMqQIYNu376tWzdvubodAHipnDlzRnv37nV1GwCSAf6tdgCOwL/VDgAAAAAAAAAAAAAAAAAA4Hz8W+1JC9+pBcx5eHjowIEDz94b/xYTE6OffvpJgwYN0rVr116Yz9/fX59++qn69+8vHx+fZ+OPHj1SaGiosmbNaramXLly2rdvn9W9b9q0yeI9lP788091795dS5YsSVCugIAA9enTR3379pWbm5tZ/OrVqypYsKAePnyY4P6Mji1jx45V+/btlSpVqufmTZ48WUOHDtX169dfmNfX11fdunVTr169FBAQYDgnPDxchQsX1tWrVxPcr6WepcT9ztKAAQM0ePBgi/H169erd+/eOnbs2Atz+fr6qnv37urdu7f8/PwM51y8eFElSpRQeHh4vLk+/vhjfffdd2bjx48fV9GiRV/Yy4tkzZpVV65cMdtmR44cUYkSJRKUw+h1GDRokD788ENlzpz52VhERIR69OihH3/8UbGxsRbzubm56eOPP9bIkSPl7e1tOKdjx47asmWLTp48KS8vr+d6GTdunL766qsXbtvatWvrhx9+UI4cOQzjS5cu1VtvvRVvDkuS4/v9yy+/VPv27c22x5o1a9SnTx+dOHHihXkLFSqkCRMmqGbNmhbnNG/eXIsXL05wr//WpEkT/fLLL2bjS5YsUbNmzRKd15KVK1cqODjYbDw2NlYDBw7UqFGj9PRpwv8d+ooVK2ry5MkWz2N16tTRpk2bEt1vYnzyySeaMGGCYezgwYPq1KmTVee9Jk2aaMaMGRaP+R06dNAPP/yQqF6d/frbg4eHh548efLs3of/VL58+WT5+/xbtmxRjRo1DGN3795V586dtWjRIid3lXAXL15Uzpw5zcZbtGjh0L7Lli1r8fXOnDmzbty4YRjjOJQ0jkPJ8dyZnK+d7OXHH39U+/btLcaXLFmiL774QmfPnn1hLg8PD3Xp0kXDhg1TihQpzOJhYWEqUqSIVdc0SfUa5N+S2/6fVI+bw4cPV9++fc3G+/Tpo2+//TbB/cQnZcqUhtcFDx48kL+/v1W5uM4zlxyv8/r06aOnT59q3LhxZrF79+5pxYoVWr16tY4dO6Zbt24pLCwswfUcwV5/z5Pcjlv/5KprHmft38lp306u+1FSP1b9U3K8xv+3pPp50xmfOyT7fPZIqp/d/s1V+2tyvmbgs2PSPx47+xybXN7vAAAA/2QymVSmTBnly5eP79MCSLCEfMfb/OoOAPCfkjGflPlV2/OUamR7jv+6GjVqqGDBgnb5kydPHlc/neccP37cYiwwMNBudez5pcn4epakZcuWObyWPbeNvc2ZM8fuOUNCQizGsmXLluA81atXl4eHh2Hsp59+srqvhLhz547WrFnjkNwwtmDBAoflXrhwoeF40aJFlT59eofVtUa2bNk0c+ZMw1i7du106dIl5zYUjxkzZujKlSuGMU9PTy1btkz169e3S62WLVvq559/tkuuv0VGRqpmzZpavXp1onOcO3dOFSpU0MWLF81iY8eOVcmSJc3Go6Ki1KJFC7MfYnp6eurHH3/U7t27Va1atQR9GS1btmyaPHmyjh49qrx58yb6eTjb06dP9cknn5iNu7m5KXv27IZrPv30Uz1+/NjRrSkoKMhwfN26dQ6v/U+WtpGUNLbTf0Xp0qWVIUMGw9iMGTMcVtdS7mLFihn+soOrrFq1SkWKFFGLFi20evVqRUVF2S23m5ubatSooRkzZuiPP/5Q69at7Zb7b8npnJrcvPbaazp48KBmzJhh9Zf/k7IMGTLom2++0ZUrVzR27FilTp3a1S0BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsNK/74H68ccf6+uvv5a7u7tL+kmXLp0WLFjwrH5oaKiaN2+umJgYm3O7u7vL19f32eMbN248F69Vq5ZWr16te/fu6bffftOMGTM0fvx4jR07VtOnT9emTZt0+/Zt7dmzR23atLF4/2hXCAoK0uuvv/7scVxcnHr16mVzXke+HvaQPn16LVmy5LnXYsaMGbp7964LuwIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwHafffaZihUrZhi7d++e6tSpow4dOujatWsJyhcREaGhQ4eqZMmSunjx4rPxlClTKmvWrHbpWZJatWqlWrVqGcZ27typ0qVL/z/27js6iur94/gnFQgloQSQ3nvvVXqXIiJILxZQRFRARKQoiooooKAICkivXxFQSgDpvSPFUKS3kBAgpJLk94dHfoadDUl2drMb3q9zOLrPnXnus7uzd+7dTDJavnx5kvPdu3dPI0eOVJs2bXT//n2L9nz58umjjz5Kcb3/ev311+Xr6/vo8d27d9WkSRMNHDhQ165dS1KOBw8e6JNPPlGVKlV06tQpw22yZMmiSZMm2VxvSpUrV06jRo0ybHv48KH69++vVq1a6fjx40nK9+DBA40bN04VK1a0+pwLFy6sCRMmPDHX/PnzFRERYVhz5cqVk1RPYrp16yY3NzeL+KxZs2zK+/LLLytPnjyPHl+4cEFVqlTRzJkzFRcXl+i+cXFx+vbbb/Xiiy/q4cOHhtu88847GjdunLy9vR/FIiIi1KZNG7377ru6d+/eE2sMCAhQgwYNrI4X7du3T9E44Kqf91deeUUFCxZ89PjfY/+5557TiRMnkpTj5MmTat68uWbPnm11m/fee8/mWh3F399frVq1Mmzr2rWrPv30U0VFRSUr565du1S9enX973//M2z/+OOPk12nLbJkyaIxY8YYts2fP181atTQvn37kpXzf//7n+rWrau7d+8atg8bNsxw3Emr8uTJY/VemEmdrzib0aNHKz4+3rAte/bsWrJkiY4dO6aBAwcqd+7cDq7OebVr184wfvv2bYt7if6Lcci5xyFnP3e66trJLE2bNlW/fv0M2yIiIvTiiy/qxRdfVGBgYJLyPXz4UJMnT1adOnUUFBRk0e7r65usOZkzr0GSwlmP/6dh3ExNrPNcb53n4+OjDz/8MEEsKipKX3zxhQoXLqy+fftqxYoVCgwMtHreTCucddxyBo48vl392Hb248hVxypX5ezzTVfA3C1xrr5mYO7omuOxvc6xfN4BAAAAICH31C4AAGBfRaubkydbPsk3lzm50qK8efMqffr0qV2G3dy5c8dqW9asWU3rZ/PmzablSuwHYydPntStW7dM6+uvv/4yjPv5+ZnWh9nWr19ves6goCDdvHnTsC1XrqQPIOXLlzeMx8TEaM+ePSmqLSl27Nhht9yw9Mcff9gt9+7du622lSlTxm79JpWnp6eWLl1qOH5OmTJFv/zySypUZV1MTIxeeeUVq+2+vr5as2aNPvvsM2XIkCFFfWTOnFlTp07V/PnzE5xPIyMjU5TvcREREWrfvr0GDRqkkJCQJO8XExOjb775RjVq1NCFCxcs2jt16qQ33njDcN/33ntP+/fvTxDLlCmT1q1bZ/UCjycpW7asdu3apWrVqqVo/9Swdu1a/frrr0na9rffftOqVavsXNE/FyMUL17csG3dunV27/9xyXmNJMe9TmlJlSpVDONxcXGJnjNsldjcomLFinbrNyViY2O1dOlStW3bVs8884w6d+6sr776Sjt27FB4eLgpfeTJk0c///yzdu3apZw5c5qS09XOqa7Izc1Nffr00bFjx1SqVKnULsdUXl5eevvttxUYGKiGDRumdjkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkmH69On6+++/E8Q+/PBDnThxQm+99ZaKFi3q0Hrmz5+vvHnzSpLi4+PVs2dPXblyxZTcWbJkSfA4LCxMkpQtWzatWrVKAQEBatOmjby9va3mcHNzU82aNTVnzhwdPnzY6r0eHcnNzU0TJkxIEFu0aJEOHz5sc257vh+2yJQpk1577TX9+eefKlu27KP4iRMnNHTo0FSsDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2/n5+WnMmDGGbSEhIapZs6Y2b96cotynT59W3bp17XI/ovTp01vcU+lfR48eVdOmTRUUFJSi3OvWrVOvXr0M2wYNGqRcuXKlKO+/0qdP/+j/w8PD1bhxY/3xxx8pynXu3DnVrFlThw4dMmzv1KmT6tatm6Lctpo+fbq8vLws4jExMWrdurVmzJiRorznz59XzZo1tWfPHsP21157TTVq1Eg0x927d7V8+XLDtr59+6aorv/q0aOHRSwmJkYLFiywKW++fPke/X9wcLAaNWqks2fPJivH6tWr9dVXXxm2lSpVSl27dn30OC4uTh07dtTatWuT1cfFixfVu3dvwzYPDw8NGDAgWflc+fOeP3/+R/8fFxenLl26pOjYj4uLU79+/bRt2zbD9mrVqunZZ59NcZ2O1LZtW3l6elrElyxZoqVLl6Y4b3R0tLp06aLdu3cniAcEBGj06NEpzpsSXl5eWrRokSIjIxPEf//9d/Xs2VOxsbEpyvvnn39q4MCBhm3FixdXq1atUpTXFWXKlMlq261btxxYiXl27typjz/+ONFtypcvr6lTp+ratWs6efKkfvrpJ7355ptq3LixcufO7aBKnUf69OkNz7mStHXrVqv7MQ459zjkzOdOV107mcXd3V3fffedYVt4eLgaNmxodY79JEeOHFHTpk0VHh5u0VajRo1E7wH8X868BkkKZz3+n4ZxMzWxzrPk7Ou8rl27KkeOHI8e3759W40bN9b777+vu3fv2pTb1TjruJXaUuP4duVj25mPI1ceq1yRK8w3XQFzt8S5+pqBuaMlVxiP7XWO5fMOAAAAAAm5p3YBAAD7yl7AvFzZ8j95G2cVFxdnGHd3N+dUWKxYMVPyOKvEvpT18/MzpY/w8HCdP3/elFySFBoaarXt+PHjpvWTWF+enp7y8fExtS8zREVF6eTJk3bJHRISYhjPkCFDknOULl3aMH748GGLizvNtHfvXrvlRkJxcXE6evSo3fIfOXLE6rFSokQJu/WbVJ9//rlq1aplEd+/f7+GDRuWChU9WUBAgL799lur7W5ubnr//fd18eJFjRgxIsEPaBNToEABjR49WhcvXjS80Pr9999Pcc2Pi4uL09SpU1WkSBG9+eabWr9+veFxEhsbq3379mn06NEqXbq0Bg8ebDjOFylSRD/99JNhX6tWrdLkyZMt4vPnz1fjxo0N94mNjdXFixd16NAhBQYGGl6oIUn+/v76/fffXeoCmcGDBysiIiLRbSIjIzVo0CCH1NOyZUvD+M2bN+06NiUmKa+R5NjXKS0pW7asYfzYsWMKCwuzW79//fWXgoODDdvKlCljt35tFRwcrGXLlmno0KGqX7++MmXKpGLFiun555+3euFMctSuXVv79u2z+r4khyueUx3hs88+U4MGDaz+a9iwodq0aaMePXrovffe04oVK3Tjxo1EcxYqVEg7duxQxYoV7Vr7Tz/9pMmTJ6f433fffae5c+fql19+0f79+62eT//L399fGzdutHohFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADn8+DBA3Xs2NHivqMlS5bUlClTdPbsWQUHB2v27NmP2p555hnlzp3b9Fref/99tWjR4tHjL7/8Ur///rtp+X19fRM8fvDggXLnzq29e/eqbdu2yc5Xrlw57dixQ+3atTOrxBTp0aOHKlSo8OhxdHS0Ro4caXNee78fialWrZpWr16d4N+aNWu0adMm/fnnnwoNDdUPP/ygnDlzPtrn3Llzat26te7fv++QGgEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJd+/fopc+bMFvH4+Hj16NFDZ86csSn/9evX9cILLyg2NtamPI/r1q2bnnnmGYv4vXv39PzzzysyMtKm/CtXrtSPP/5oEff29tbAgQNtyv1fb7zxhg4dOmRTjvv37+uFF17QnTt3DNvffvttm/KnRP369VW3bl3DtmHDhikgIMCm/P8+51u3blm0ubm56YMPPnhijhkzZhjGu3XrJk9PzxTXVq5cOZUvX94ivnr1agUHB6c47+N69+6tCxcupGjfTz75RCEhIU/c7osvvtC6detS1MemTZus7vvf+5YlRVr5vI8ZM0b/+9//bMrRp08fxcTEGLa1b9/eptyOUrRoUcP4zz//bHPuhw8fqm/fvoqIiNC8efNUsWJFNW/e3OYxJ7mCg4M1aNAgFS5cWF999ZUePHig0NBQ9erVy+bcCxYs0PHjxw3bmjRpYnN+V5ExY0bDeFxcnKKjox1cjXnGjh2rRYsWPXE7Nzc3lS5dWv369dO3336rTZs26fr167pz54527typmTNn6u2331azZs2UN29eB1SeOkaOHKmCBQsati1evNjqfoxDtnHkOORs505XXTuZpWPHjipevLhh2xtvvKF9+/bZlP/YsWN69913Hz3et2+fnn/+eVWoUCFJY7srrEGSw5mO/6dh3HQWrPNcY51XokSJR/8fGhqq2rVra9euXTblTAucadxKbalxfKeVY9vZjiNXHqtckbPPN10Fczfr0tqagbmj64zH9jrH8nkHAAAAgIRSfsUfAMAl+PiamMvPvFyOFhkZKR8fH4u4t7e3KfmLFStmSh5nkCNHDhUpUkRFixZ99K9kyZJWt3d3dzel33PnzpmS518RERGKjY2Vh4eH3fu6f/++1bZMmTIpPDzc1P5sde7cOcXFxdkl9927dw3jyfmsWbvA9a+//kpRTUl18uRJu+bH/7t8+bLVCxTMEBMToytXrhiOzUWKFLFbv0nx3HPPaciQIRbx0NBQde7c2a6vi63efvttFSxYUO3atbO6jb+/v8aPH6/x48frzJkz2rVrl27cuKGgoCCFhYUpc+bM8vf31zPPPKO6desm+n5MmDAhxT90Tczdu3c1bdo0TZs2TZLk6+ur3Llzy8PDQ7du3VJwcLDi4+MTzeHl5aWlS5cqS5YsFm2XLl1Snz59LOIDBw40vAAnLCxMY8aM0c8//5zgl+e8vLzUunVrffnllxYXhfj7+2v+/Plq1qxZUp5yqrt48aI+/fRTffLJJ1a3GT9+vP7++2+H1NOyZUvD+Pr16x3Sv5GkvEaSY1+ntOS/Fx/81+nTp+3e919//aU6depYxBObXzub+Ph4nTt3TufOndOhQ4cszmOjR49WdHS0ypUrp6pVq6pkyZJPXCMULFhQAQEBqlSpkuEFQ0nhyudUewsMDFRgYGCy9nFzc1OrVq00ZMgQNW7c2HCb7Nmza82aNapSpYqCgoLMKNXC6NGjde3aNVNzlihRQh06dFCPHj0Mf4Fdkjw8PPTTTz/p1q1bdpl/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDfkSNHVLNmTS1btkwVKlSwaM+WLZuyZcv26HH37t3VvXt33bt3T4cOHdLevXu1atUq7dq1K8U11KtXL8H9KHft2qUPPvggxfmMPH5/6Li4OK1cufLR/XsfPnyoRYsW6X//+58OHDigoKAgRUdHK1u2bCpevLiaNWum119/Xc8888yjHBkyZNDSpUvVuHFjm55/Snl7e1vcx3PatGm6cOGCTXkd8X4kJmfOnHruueeSvP20adM0dOhQRUZG2rEqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAc4/XXXzeMz5kzR2vXrjWlj3379umHH37QG2+8YUo+SXrzzTcN4998843+/vtvU/r47LPP1K9fP7m7uyeI9+rVS6NHj7Y5//bt2/Xzzz/bnEeSLly4oPfee08zZ860aOvQoYNy586tGzdumNJXUgwdOtQwvnHjRk2ZMsWUPq5du6ZXX31Vv/76q0Vbu3btVLx4cZ05c8bq/jt27NDp06dVqlSpBPHs2bOrTZs2hnmTokePHobxWbNmpSifkV9//VW//fZbivcPCwvTihUr9Oqrr1rd5urVqxo3blyK+5D+ec4tW7a0iFesWFHp0qVTVFRUkvKkhc/70aNH9dlnn9mc5++//9bKlSv14osvWrTVq1fP5vyOkCdPHsP4uXPnTMn/119/KVeuXLp//74p+Wxx48YNDR06VJ999pnKlCmj4OBgU/L+8MMPmjp1qkW8fv36puR3BZkyZTKMJ3VccWbdunXT6dOnNXbsWLm5uSVrXz8/P9WpU0d16tRJEA8NDdW+ffu0e/du7dixQ3/88YdiY2PNLNvhevfubfXel1evXtWqVaus7ss4ZDtHjEPOeO501bWTWQYPHmwYX7VqlWnrmhkzZqhixYpasmSJtm7dmqx9XWENklTOdvw/TeNmamKd9w9XWudJUr9+/XT27FlTcrkyZxu3UltqHd+ufmw743GUVsYqV+Hs801XwdzNurS0ZmDu+A9XHI/NPMfyeQcAAACAhNyfvAkAwJU9jDEvV6yJuRwtMjLSMJ4uXTrT8q9ZsybZ/06fPm1K/8nh4eGhIkWKqGnTpurfv78mTJigFStW6MiRI7p3756CgoK0d+9eLVy4UOPGjVOfPn1Uu3Ztu9dl1kV6/2XtfTe7r4iICFPz2VtQUJDdcj948MDmHNYudr5z547NuRMTGhqq+Ph4u/aBf1y9etXufVg7XjJnzmz3vq3Jnz+/5s6da9jWt29fXbhwwbEFJVNcXJw6d+6s5cuXJ2n74sWLq3fv3ho+fLgmTpyo6dOn68svv9R7772nnj17qkiRIlb3/emnnzR8+HB5enpa3SY6OjrZz8HI3bt39ddff+nkyZO6fft2ksaBr776SlWrVrWIP3z4UF26dLE4/jJmzKhPP/3UsO86dero66+/tjg3xcTE6Ndff1WlSpW0d+9ei32bNm2q1q1bP7FWZ/Hll19abTt79qy++OILh9Th5eWlxo0bG7aZdVF7Sn355ZeJ/lDcka9TWuPn52cYt/fcIrE+fH197d63o2zatElffPGFevbsqTJlyihr1qzq3r27fvvtt0TH1GeeeUaLFi2yuOAkKVz9nOqM4uPj9fvvv6tJkybq1auX7t69a7hdvnz5rL72ziowMFATJkxQhQoV1L17d6t/MMDT01Nz5861OmYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcD6BgYGqVKmSevfurV27diVpnyxZsqhhw4YaPny4du7cqXPnzqlHjx7J7jtHjhxavHixPDw8JP1z7+wuXbooNjY22bmSo06dOqpZs6Yk6eDBgypVqpR69eqllStX6sqVK4qKilJ8fLyCg4O1Z88ejRs3ToUKFdLEiRMT5EmXLp3mz58vHx8fu9Zr5M0331SBAgUePb57964++eQTm3Km1vthiw4dOuj5559P7TIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALBZiRIlVKxYMcO2r776ytS+PvnkEz18+NCUXAUKFFDlypUt4uHh4Zo0aZIpfUjS+fPntXHjRot4wYIFVbp0aZvzjxs3zuYc/zVv3jwFBQVZxD09PdWyZUtT+0pM5syZ1apVK8O2zz77zNS+Vq1apRMnTljE3dzc1KlTpyfuP3PmTMN4nz59UlxT165dLWI3btzQunXrUpzzcWYcOytWrEi0ffLkyYqIiLCpjzVr1ig6Otoi7uXlZfgZNpJWPu+jRo0y7R5ts2fPNoxXqVIlVe5zl1zp0qUzjMfHx5vWx/37903LZYbg4GBt377dtHybN282jFeuXPnRvQHTOi8vL8O4M98LMTk+/vhjNWzYUAcOHDAln5+fn5o3b64xY8YoICBA169f16RJk1S2bFlT8jtS+vTp9cknn2j27Nlyd3c33Gbs2LGG559/MQ7ZzhHjkLOdO1117WSWnDlzqm7duoZtX3zxhWn9xMfH64033tDWrVuTtZ8rrUGSwtmO/6dx3EwNrPNcb533yy+/6JdffrE5T1rgbONWakrN49vVj21nO47SyljlKpx9vulKmLsZS2trBuaOrjkem32O5fMOAAAAAAkZX0EAAEgzwkPNy/Xgjnm5HC0sLMww7ufnZ0r+BQsWqG3btsn+Z+0HdGYpWbKkevTooUmTJikgIEDnz59XVFSUzp07p4CAAE2fPl3Dhg1Tx44dVbFiRWXOnNmu9STmwYMHpue09sWv2X2Z+QWzI9jjtf6XGa9FpkyZDON37th3EIqPj9e9e/fs2gf+Yc9j8F+hoaGGcWvHl715enpq6dKlypo1q0XblClTtHLlSscXlQJRUVF68cUXNXr0aLtcsBsXF6fhw4frlVdekSR5e3sbbhcTE2N630nVoUMHDRo0yLBtxIgR2rNnj0X85Zdflq+vr0X8zTff1PHjxxPtLzw8XB07djT8IfSQIUOSWHXqS+yXFD7//PNE281Ut25dw3EgLi5OAQEBDqnBmujoaH3wwQdW2x35OqU11ua41s4VZrI2f0nNebe93bt3TwsXLtRzzz2nypUra8uWLVa3bdy4sbp3756s/GnlnOrM5s2bp0aNGunu3buG7S1btlS7du0cXJU5Fi5cqJo1a+rvv/82bPf39zf9DxgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsK/4+HjNnTtXdevWVb58+dSpUyd9+eWXWr9+vW7cuPHE/YsUKaJ58+Zpw4YNypIlS5L7nT9/vvLmzfuohp49e+rKlSspfh5J5e7uLknatWuX6tatq3Pnzj1xn+joaA0bNszivqyFCxfW66+/bpc6rcmSJYtGjhyZIPbZZ58pJCTEpryp9X78V3BwsLZs2WLxb8+ePTp79qzi4uISbJ83b14tXLhQ3333ndzc3BxaKwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZmrevLlhfNu2bTpx4oSpfV2/fl1r1qwxJVezZs0M4xs3brT53kqP27Jli2G8YcOGNuW9ePGiAgICbMrxuKioKP3000+GbS1btjS1r8Q0b95cXl5eFvE///xTmzdvNr2/yZMnG8bbtm37xH1//vlnRUdHW8TbtGmjHDlyJLuW+vXrq0CBAhbxefPmKTY2Ntn5jBw9elQHDx60OU9iOeLi4vTzzz/b3EdERIROnz5t2Fa4cOEk5Ugrn/fVq1fblOO/du7cqfj4eIu4p6enChYsaFo/9hIaGmoYT+oxAen06dMKCwuziHt6eipr1qypUBHsYdu2bapevbo6deqkdevWmXYekSR/f3+9/fbbOnbsmH766SflzJnTtNz24u/vr0GDBun06dMaOXKk1ftJbt68WT/++GOiuRiHbGfvccgZz52uunYyS8uWLQ0/d4cPH9auXbtSoaKEXGkN8iTOePwzbtof67x/uNI6T7I+FjxtnHHcSk2pfXy76rHtjMdRar+Xkjnvp6tw9vmmK2HuZiwtrRmYO/7DFcdjs8+xfN4BAAAAICH31C4AAGBfV0+akycuVrp51pxcqeH69euG8dy5czu4EvvLnTu3Ro8erVOnTun06dOaN2+e3n77bTVt2lSFCxeWh4dHapdoKCYmJk325YyMfhHEmRj9cEqSwsPD7d630QWeMF9ERITd+7h//75hPGPGjHbv28jnn3+uWrVqWcT379+vYcOGpUJFthk3bpyqVq2q3bt3m5Zz//79qlmzpiZMmPAolilTJsNtIyMjTes3OQoVKqTZs2cbtv3++++aOHGiYdsrr7xiETtz5owWLFiQpH6vXbummTNnWsQbN27sEheGPYm1z6s9WPtF0YMHDyo4ONhhdVhz9epVq22OfJ3SGh8fH8P4vXv37N63tT5S63zkaEePHlWTJk30zTffWN1mxIgRycqZ1s6pzurw4cPq0KGD4QWlkjRq1CgHV2SeS5cuqVmzZlbnE3379rU6BwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADg3K5evaoVK1bovffeU8uWLdWmTZtHbX/88YcmTpyoDRs26O7duxb7NmvWTJs2bZK3t/cT+3n//ffVokWLR48nTJigtWvXmvMkkuD+/ft6/vnnFRUVlaz9pk6dqkWLFiWIvfnmm2aW9kTvvfeesmXL9ujxlStXNGXKFJtypvb78a+9e/eqUaNGFv9q166t4sWLK2vWrOrRo4eOHz+eYL/XX39dX3zxhcPrBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADALDVr1jSM//HHH3bp7/fffzclT7169Qzj69evNyX/f+3Zs8cwXrZsWZvybtiwwab9rdm8ebNhvHr16nbpz0ijRo0M4+vWrbNLf9by1qxZU+nSpUt03+DgYK1cudIi7uXlpa5duya7lh49ehjGZ8+enexc1ph1nN++fVtBQUGGbUeOHLHallwnTpwwjPv5+SVp/7TweV+zZo1N+z/u3r17OnfunGFb1qxZTe3LHq5fv24YT8ln7mkVHx9v9XX8730HkTasWLFCrVq1Ut68efX6669r/vz5VseA5HJ3d1e/fv105swZtW7d2pScjytatKiqVKmS5H/VqlVTo0aN1L59e7366quaOnWqduzYoWvXrumbb75RwYIFrfZ17tw5denS5Yk1MQ7Zzt7jkDOeO1117WSW+vXrG8btMSdLCVdagzyJMx7/jJv2xzrvH660zjt9+rS2bdtmU460whnHrdSU2se3qx7bzngcpfZ7Kdn+froSZ59vuhLmbsbS0pqBueM/XG08tsc5ls87AAAAACTkntoFAADs6/x+KS7W9jyXj0nR4bbnSS3Xrl0zjOfPn9/BldhP+vTp9fHHH+vs2bP66KOPVKpUqdQuCXA58fHxqV3CUyEuLi5N9JFUzz33nIYMGWIRDw0NVefOnRUTE5MKVdnu2LFjqlOnjho1aqTffvstRc8jLi5OAQEBatu2rWrUqKEDBw4kaLd2cbVZP5RNDk9PTy1dutTwB7ZXr15Vr169DPfLmjWrypUrZxFftmxZssacJUuWGMat/WAYxlq2bGkYt9dFEHAObm5uhvGn7XyUWuLi4jR48GDDX0aWpNKlS6tp06ZJypVWz6nOasuWLVqwYIFhW7Vq1VSxYkUHV2Sec+fOacKECYZtGTNm1AsvvODgigAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADY28GDBzVs2DC1aNFCOXLkUNu2bbV///4E21SrVk3jx49PNE+9evX0ySefPHq8c+dOjRw50i41W/Ptt9/q1q1bKdr3gw8+SHBf1UKFChnef9UesmbNqsGDByeIjR07VpGRkSnO6QzvR1Ldu3dPCxYsUJUqVTRt2rQEbcOGDVP9+vVTqTIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGxTsmRJw/ju3bvt0t/27dtNyVOqVCnDuD3qvn79umG8RIkSNuU167V43L59+xLc8+pfhQoVkre3t136fFyZMmUM4zt27LBLf1euXNHly5ct4u7u7laP8f+aMWOGYbxPnz7JqsPLy0udOnWyiO/du1enTp1KVq7E7Nq1y7RcN27cMIzv3bvX7n34+fklaf+08Hnftm2bTfsbMTrmJSlbtmym92U2a2NBr1699OKLLzq4Gtd19+5dw7grHANmMDrXSZKbm5uDK3Gcmzdvavr06erZs6eKFSumHDlyqEGDBnr99dc1bdo0/fHHH7p582aKcmfJkkWrVq1S//79Ta5aGj9+vA4ePJjkf/v379fmzZu1cuVKzZgxQwMHDlTdunXl6emZaD+nT59Wo0aNdPv27SfWxDhkDnuOQ8547nTVtZNZSpcubRg3c25qC1dbgyTGGY9/xk37Y533D1da523ZssWm/dMSZxy3UlNqH9+uemw743GU2u+lZPv76Uqcfb7pSpi7GUtLawbmjv9wtfHYHudYPu8AAAAAkJB7ahcAALCvsGDp+Abb8+xaZHuO1HTx4kXDeL58+ZQpUyYHV2O+Z555Rtu3b9eoUaOUMWPGFOd58OCBjhw5omXLlmn8+PHq06eP6tatqwoVKphYLZA4axc7u7vbf+rqqF8ewtMjf/78mjt3rmFb3759deHCBccWZAdbtmzRc889pxw5cqhLly6aNGmSNm7cqHPnzikoKEhRUVGKjo5WSEiILly4oD/++EPfffedevTooVy5cql58+Zas2aNYe6cOXMaxm/dumXPp2Toyy+/VPXq1S3isbGxeumllxQcHGy4X506dQx/WWPr1q3J6n/Pnj2Kjo62iNevXz9ZeZ5muXPnVsWKFQ3b1q1b5+BqgKfPgAEDFBkZadjWrFmzJ+7/NJxTndH48eOttrVs2dKBlZhv5syZVtvq1avnwEoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAONrDhw+1Zs0a1apVS9OnT0/QNnDgQKv3Vc2ePbsWL14sDw8PSdLt27fVpUsXxcbG2r3m/1q2bFmK971w4YIOHjyYIFa1alVbS0qSwYMHJ7iv/JkzZzR79uwU53OW9yO5Hj58qDfffFPLly9PEP/0009TqSIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGxTvHhxw/ixY8fs0t+5c+cUFxdnc54SJUoYxi9evGhz7sfduXPHMJ41a1ab8p45c8am/a25e/eu4evg7u6uIkWK2KXPx5UuXdowfujQIbv1+fh9vp5Uy39t2rRJ58+ft4hXqVJF5cqVS3INrVq1UrZs2Szis2bNSnKOpDDz2Ll//75hPDAw0O59+Pn5JWn/tPB5P3XqlE37G7l7965hPKmva2rasWOHgoODLeLu7u5asmSJfv75Z1WsWDEVKnN+uXPnVt26ddWzZ0/D8UaSvL29HVxV6oiKijKMe3l5ObiS1BMcHKxt27Zp+vTpevPNN9W4cWPlzp1b2bNnV7169fTaa69pypQp2rZtmyIiIp6Yz8PDQ99//72ee+45B1Rvrp9++km1atXS5cuXk7Q941DKOWoccsZzp6uuncxSsmRJw/jhw4cdXIkxV1uDJMYZj3/GTftjnfcPV1rn7d2716b90xJnHLdSU2of3656bDvjcZTa76Vk+/vpSpx9vulKmLsZS0trBuaO/3C18dge51g+7wAAAACQkGdqFwAAsL/tP0tFqkmZ/VO2/4lN0mX7XOvjMIldrFS+fHnt3r3bgdWYK0eOHNq9e7cKFiyYpO0jIyN19uxZnTlzRmfOnFFgYOCj/79+/brhPjlz5jSzZCBRDx48MIw74uIHV7jAwp7c3Nwc0o+Hh4fd+7B2UW5sbKzd+/6Xp6enli5davhDsylTpmjlypUOq8UR7t27p6VLl2rp0qWm5bT2C33Wzlf20q5dO7399tuGbaNGjdKOHTus7mvtOZw+fTpZNcTFxenMmTMqW7ZsgnjhwoWTledp1rx5c8P43bt3ubAxjbM29nt62v9rMWu/rOXI85GzuHnzphYuXKh+/fpZtDVq1CjRfZ+2c6ozOXXqlM6ePatixYpZtNWuXTsVKjLPlStXdPz4cZUvX96irWrVqqlQEQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABHi4uL08CBA1W9evVH9zFLnz69OnbsqOnTp1tsv2DBAuXNm1eSFB8fr549e+rq1at2rTEqKsqi5sTu254Uhw4dUrVq1R49zpcvn035ksLb21tvvPFGgtjnn3+uuLi4FOdMjffDTG+//bY6duwod3d3SVL9+vWVL18+XblyJZUrAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgeXx9fQ3jwcHBdukvJiZG165ds/keTFmzZrWIRUREKCQkxKa8RsLCwgzjmTNntinvxYsXbdo/MSEhISpUqJBF3Oh1swd/f3/DeFBQkN36vH37tmE8R44cSdr/xx9/1Pjx4y3iffr00dChQ5OUo0ePHhaxiIgILV68OEn7J9W1a9dMy2Xt+L5x44Zpfdy/f98w/u+9wJ4kLXze7XGvtnv37hnGk/q6pqaYmBh99tlnmjhxokWbm5ubevXqpV69eunKlSvav3+/Tpw4obNnzz76d/PmzVSo2jHSpUunQoUKqWjRoipSpIiKFSumIkWKPPqXIUOG1C7RaURGRhrGvb29HVyJ8wkJCdHOnTu1c+fORzFPT0/Vrl1bPXr0UNeuXa2Oa25ubpo7d64qVaqkS5cuOarkFDt79qz69++vzZs3J2s/xiHrnGUccsZzp6uuncySLVs2w7g95/jJ4YprEGuc8fhn3LQ/1nmut847evSoTfunJc44bqWm1D6+XfXYdsbjKLXfS8n299OVOPt805UwdzOWltYMzB1dczy2xzmWzzsAAAAAJOSZ2gUAAOwvPFRaMVZ66XMpfTK/t7v8p7Rush2KcrBjx45Zbatfv752797twGrM4+bmpqVLl6pgwYJWt7lx44ZWr16tjRs36vDhwzp37pzi4uKS3Q/gKNZ+8GDvX+zJkCHDU39BtaMudk2fPr3d+/Dz8zOMWzu+7GH8+PGqVauWYVurVq3UpEkTU/uzdi4YM2aMBg0aZNh26tQpde7c2dQ6zFSsWDHDeGBgoMNqKFCggObMmWPYtmHDBn322WeJ7p89e3bD+PXr15Ndy/Xr11W2bNkEMWsXjsBSq1atDOMBAQGKjY11cDVwpNSaWyTWh7WLQtK6devWqV+/fhbxMmXKJLqfI8+pafF8aqsDBw4YnpONfhnf1Vy4cEHly5e3iFu7aA4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABA2hMXF6fJkydr3rx5j2INGjTQ9OnTE2z3/vvvq0WLFo8er1+/XuHh4Xr22WeT3FelSpUSPM6TJ4/F/seOHVNoaOijx3fu3EnQfufOnWTfp/xxQUFBCR5nyZLFpnxJ8cILLyS4V1xQUJDmz5+f4nyp9X6Y6erVq9q3b1+CezbWrFlTV65csUt/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADYg4+Pj9zc3CziUVFRio6Otlu/9+/ft2l/a3VnyJBBERERNuU2YtSXJKVLl86mvPfu3bNp/8RYu4dTpkyZ7NbnvzJkyCAPDw+LeFRUlCIjI+3W7+P3DvtX5syZk7T/7Nmz9fHHH8vT0zNBvHv37nrvvfeeeB+yzJkzq23bthbxX375xfT3+sGDB6blsva8HNFHUqSVz7ut454RW++Nl9q+/fZbPf/886pbt67VbfLly6d8+fLp+eefTxB/8OCBzp07p7Nnz+rs2bM6c+aMjh49qmPHjikqKsrepZsiT548qlq1qipUqKBixYqpSJEiKlq0qPLkyWP1OERCiY1Tfn5+drufoat6+PChtm/fru3bt2vkyJH65JNP1L9/f8Nts2bNqnHjxql3794OrjJpYmJitGrVKs2YMUMBAQGKj49PUR7GIeceh5zt3Omqayez+Pj4yN3d3SIeFRXlFMe8q65BrHG24/9fT/u4aW+s81xvnRccHGzT/mmJs45bqcEZjm9XPbad7ThyhvdSsv39dBXOPt90RczdEkprawbmjq45HtvrHMvnHQAAAAD+n+eTNwEApAW3zklz35KeHy35F07aPsfWSwFTpdgY+9bmCMeOHVN4eLh8fHws2po2baoJEyakQlW269Klixo1amTYdvXqVQ0dOlTLli1TbGysTf0YvW6AvYSEhBjGc+bMadd+8+TJY9f89mD0A2NbZMyY0dR81mTNmtXuffj5+RnGw8LC7N73v1q1amW1rUSJEg6rI0+ePFaP78DAQIfVkRKVK1c2jJ8+fdoh/Xt6emrp0qWGx+z169fVo0ePJ+bIli2bRezhw4eKiUn+BMvo+DXKD0tubm5q1qyZYdu6descXA0czdpFdo44H1nrw1l+4cHRjhw5YhjPmDGjvL29rf6SiTOcU135fGqrGzduGMazZ8/u4ErMd+vWLcO4tbkkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgLRp165dCR7ny5fPYptPPvkkweOWLVuqZcuWNvXbrl07tWvXLkGscuXKCe7/d+/ePcXGxsrDw0OSFBcXZ1OfZuVIrl69eiV4PGfOHKv3MUyK1Ho/zHbu3DnVqlXr0ePcuXPbrS8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOwhY8aMhvF79+7Ztd8HDx7YtL+1uiUpffr0NuV2pPDwcLvlvnv3rmE8U6ZMduvzX6l1XN25c8cwniVLliTtf+PGDf3+++8W98TKnTu3WrRoobVr1ya6f8eOHQ2Pv1mzZiWp/+SIiYkxPefjbLlfmZnSyufdEe+Zq4mOjlb79u0VEBCgypUrJ2vfjBkzqkKFCqpQoUKC+MOHD7V161YtWLBAixcvVkREhJkl26xs2bLq1auXunTpooIFC6Z2OS7v+vXrVtty5cql0NBQxxXjYm7fvq0BAwZo9+7dmjVrltzd3S226datm0aNGqVLly6lQoX/iI+P1/3793Xnzh2dOHFC+/fv1759+7Rnzx6FhITYnJ9xyLnHIWc7d7rq2sksqfX8k8pV1yDWONvx/6+ncdx0JNZ5/3CldZ61716eRs46bqWGtHB8p9ax7WzHUVp4L12Js883XRFzt4RYMyQfc0fz2escy+cdAAAAAP6f5dUPAIA0K/S6NGeg9PtX0o1AKT7ecpvoSOnMbmneYGndJCnWuX4elWIxMTHaunWrYVujRo2UI0cOB1dkjtGjRxvGT58+rYoVK2rx4sWKjY21uR9XfX3gmv766y/DePXq1e3ar73zp1RcXJzVNrN/2Slv3rym5kvNfrJnz24YN+Ni6rTk/PnzqV2CVdmyZVORIkUM2w4dOuSQGj7//HPVrFnTIh4XF6euXbsqKCjoiTm8vLwsYlFRUSmqx2g/b2/vFOV62lSrVs3quLB+/XoHVwNHu3XrlmHc39/f7n1bm0ffvn3b7n07o8SetyuvOZz5fGoGaxfvuNpFSEasXVDm6enp4EoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApKbH77eXLVs2i208PDwcUsvff/9tETt37tyj/8+aNavNfTx+D8HQ0FCbcyYmXbp0aty4cYLYwoULbcqZmu+HmcLCwhI8TpcunV37AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAbG5ubobx2NhYu/b78OFDm/a3VreriY+Pt1tua++hI147d3d3w7i9jysznvOMGTMM43369Hnivj169LCIXbp0SZs3b05y/87EnsdncqSVzzuMBQcHq3bt2vruu+9MGSM8PT3VpEkTzZo1S2fPnlXfvn1NqNJ2BQsW1MKFC3X8+HG99957KliwYGqXlCaEhIQoOjrasC1//vwOrsY1/fzzzxo7dqxhm6enZ5LOf0nx5ptvqmDBgkn+V6BAAfn5+cnDw0O+vr4qVKiQ2rRpo7Fjx+r3339XSEiIKXVJjENIOlddO5kltZ5/UrnyGsTVPC3jZlrFOs9c9+7dS+0S4ITSwvHNsf2PtPBeuhJnn2+6KuZu/481Q/IxdzSfPc+xfN4BAAAA4B/G3wAAANKs+DjpzwBp7lvS1C7S/Lel/42Vlo6U5gyUvukk/fKRdP2v1K7UfOvWrTOMe3p6qlu3bg6uxnYlS5ZU6dKlDdv69u2r4OBg0/ry9/c3LRfwJKdOnTKM582bV/ny5bNbv7Vq1bJbblsk9sMSX19fU/sqUaKEqfmseeaZZ+Tn52e3/Dly5FDevHkN2wIDA+3Wrys6d+5capdgVdOmTQ1/8Hnv3j0dP37c7v23adNG7777rmHb2LFjtXXr1hTnTukPlp3lB9KuqGXLlobxEydO6MqVKw6uBo528uRJw3jVqlXt2m+6dOlUtmxZw7YTJ07YtW9nFR4ebrUtffr0DqzEXM58PjWDh4eHYTwtnJesXSCXFp4bAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkNY1bdpUDRo0MCVXunTpEjyOjIw0JW9yhYSE6O7duxbxnTt3Pvp/T09PlSxZ0qZ+ypQpk+DxhQsXbMr3JNWqVZO3t/ejxyEhITpy5Ihd+zSDtffDTFmzZk3wODQ01K79AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwL7Wrl2rK1euWMTbt28vPz8/q/vlzp1bjRs3toj//PPPio+PN7NEIM2JiorSwIEDVaZMGc2ZM0f37t0zJW+ePHk0a9YsLVy40OK+h47UtGlTHTlyRF27dpWbm1uKcoSEhGjv3r2aP3++Ro0apZdeeklVq1bVnj17TK7W9Vi7p2OpUqUcW4gLGz9+vP7++2/DtkaNGpnSR1BQkC5dupTkf5cvX9bdu3cddg5lHHoyxiEA/5XWx00gqVjvI63i2AbSFuZugPOw9zmWzzsAAAAASJ6pXQAAIPVE3Pvn39NiyZIl+vrrr+Xh4WHR9u6772ratGmKjY1NhcpSpmnTpobx48ePm36RWs2aNU3NByRm9+7dVtvatGmjH374wS79tmnTxi55bXXnzh2rbblz5za1L0d+1qtXr66AgAC75K5Vq5bVtsDAQLv06arOnz+f2iVY1aFDB8P4zp077f5DxHz58mnu3LmGF5Fv3rxZn3zyiV37h/latWplGF+/fr2DK0FqOHHihGE8b968KlCggC5dumSXfqtXry5vb2/DtpMnT9qlz6Rq3ry5MmbMqF9++cWh/fr6+lpti4yMdGAl5nLm86kZcubMaRgPCwtzcCXmy5Ejh2H8wYMHDq4EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQFLVr19fn376qerXr6/Dhw+ratWqNt/vtHjx4gkeX79+3WKbkiVL2tSHJNWoUUPz5s179HjJkiUaPXr0o8cxMTGG+23dulV9+/Z99LhDhw764osvUlRD9uzZVbdu3QSxffv2pShXUtWpUyfB471799qcMzXfDzOVL18+weObN2/avU8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMwUGxtrGPfy8rJrv7bmt3b/q9DQUC1evNim3MkRHBxs0/5eXl52u+eSt7e3Ydzae24ma314enratV9rx1VynnNcXJxmz56tUaNGJYinS5dOXbp00Q8//GC430svvSR3d/cEsfj4eM2ePTvJfcNYWvm848kCAwPVt29f9e/fXw0bNlT16tVVtWpVlSpVSkWKFFG6dOlSlLdr167KnDmz2rZta3LFT9aqVSutXr1aHh4eT9w2LCxMgYGBCgwM1JkzZxL8986dO4b7REZGml2yyzl+/LhKlChhEa9UqZLji3FRsbGx+u677/Tll19atNWuXduu8xVnwzjEOJQYV107mSUuLs4wbu85flK58hrElaXFcdMaNze31C4hTWGdh7TMGY5vjm1zOMN7KT0976ezzzcdzR5zj6dp7maENYPrYjxOvqf98w4AAADg6fZ0fpsEAHgq3bx5U+vWrVObNm0s2goWLKgBAwZo2rRpqVBZyhQpUsQwvm/fPtP7atiwoek5AWv+/PNPXbt2TXny5LFoGzRokNVfULFF06ZNVaxYMdPzmsHaxaiSVLlyZa1YscKUfvz8/FS9enVTciVFixYtFBAQYJfcDRo0MIxHRUXp5MmTdunTyLx58/TMM884rL/27durcOHCFvHNmzfr2LFjhvtYi6e2LFmyqEOHDoZt//vf/+zat4eHh5YsWaJs2bJZtN28eVPdunWz+gNZI0YXd6T0QmejX3y0dvEI/p+fn59q1Khh2LZ27VoHV4PE2OvC4507d1pta9Kkid1+mbVx48aG8aioKB06dMgufT5JgwYN9Omnn6pu3bq6fPmyVq9erYcPHzqs/8TOi/fu3bPa5shzalo6n5qlQIEChvGQkBAHV2K+fPnyGcZd6aInAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4Gni7e2tFStWyN/fX9I/9/h955139PXXX9uUt1u3bgkeHzlyxGKbwMBAm/qQpNy5cyd4fOfOnSTlXb58uaZMmSJfX19J0pAhQ/Tdd9/p/v37ya7hww8/lKen56PHR44c0blz55KdJzlKliyZ4PHBgwdtzpma74f0zz1TX3vtNU2dOlXh4eEp6r9GjRoqXbr0o8fx8fE6cOBAinIBAAAAAAAAAADHypEjh4YMGZLoNrNnzzblZxoAAEuMwwAAAHgaMO8FgNTDGAwAAAAAAAAAAAAAAAAAAAAAAAAAAJB8Dx48MIz/e98le8mYMaNN+0dGRhrGw8LC9Prrr9uU25F8fX11+/Ztu+T28/MzjIeFhdmlv6T0Ya0ms2TLls0wfu/evWTl+fHHHzVy5Ei5u7sniPfp00c//PCD4T49evSwiG3btk1///13svqGpbTyeUfSRUdHa8OGDdqwYcOjmJubm/Lly6dixYqpWLFiKl68+KP/L1asmDJkyJBozueee04ffPCBxo8fb+/yHylUqJAWLlwoDw8Pw/bg4GCtWLFCAQEB2r9/vy5evJjsPtzc3Gwt0+UdO3ZML7zwgkW8fv36qVCN69q4caNhPF26dMqdO7cuX77s4IpSF+NQ0j1N45Crrp3MYm1OZu/nn1SuvgZxdWll3EzMk+pF8rDOQ1rG8Z128F46lrPPNx3NnnOPp2HuZoQ1g+tiPE65p/XzDgAAAODp5pnaBQAA4EiTJ09WmzZtDNs+/fRT/fLLL7p27ZqDq0oZf39/w3hwcLCp/eTJk0e1a9c2NSfwJKtXr1b//v0t4mXLllWLFi20fv16U/t79913Tc1npocPH+rmzZvKlSuXRVv16tVN66dnz55WL561h65du+q9995TXFycqXnTpUun3r17G7Zt27bN6g/S7GHChAkO60uSihUrpsKFC1vElyxZohkzZji0Flu9/vrrhj+Ei42N1a+//mrXvsePH686depYxOPi4tS9e3fdvHkzWflCQ0MtYunSpZO7u3uyj3+jC6Tv3LmTrBxPo6ZNmxqObxEREdq+fXsqVISYmBjDuI+Pj136u3z5so4fP67y5ctbtA0aNEizZ882vU8vLy+rF2hs2bLF6i9a2Evt2rX1ySefqHHjxo9i+fPn14ABAzR16lSH1VGvXj3DeFBQUKK/xO3Ic2paOp+aIUOGDHr22WcN286cOePgasyVPXt2Va1a1bDN1Z8bAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkFZFR0dr4sSJ+uKLLx7FJkyYoPPnz2vlypUpylmvXj2L+yn/73//s6VM0z148EA//vijhgwZIumfe5zPnz9fHTp0UHx8fJLztG3bVm+99VaC2Jdffml1+3Tp0lncFzQ8PDwZlf8je/bsCR5fv3492TmcRY4cOTRkyBC98cYbypIliwoXLmz1HpaJyZIli3788ccEsd27dyf7/rkAAAAAAAAAACB1lC9fXnny5LHa/vDhQ126dMmBFQHA04VxGAAAAE8D5r0AkHoYgwEAAAAAAAAAAAAAAAAAAAAAAAAAAJIvMjJScXFxcnd3TxD39PSUj49Piu59lBS+vr427R8eHq74+Hi5ubkliGfLls2mvI7m5+en27dv2y23kbCwMLv0919RUVF6+PChPD09E8Q9PT2VMWNGPXjwwC79Zs2a1TB+//79ZOW5dOmSAgIC1KJFiwTxWrVqqUSJEgoMDEwQL1GihKpWrWqRZ9asWcnqF8bSyucdtomPj9fly5d1+fJl/fHHHwna3NzcVLx4cbVs2VIDBgxQ6dKlDXOMGDFC06dPV0hIiCNK1vjx4w3H4rCwMI0YMUIzZsxQdHS0TX1kypTJpv3Tgm3bthnGS5QooQIFCvC3JpLo8XPbf2XPnl2XL192YDXOiXHI2NM0Drnq2sks1uZkXl5eypAhgyIiIlKpsn+4+hokLXKGcfPx+zvbInPmzKblAus8pG0c32kH76VjOft880nMnHdIjp97OMPczd5YM7guxmNzPQ2fdwAAAABPN/cnbwIAQNqxceNG7dq1y7DN19dXy5cvl5eXl4OrSpn4+HjDeMaMGU3t57333nOZ1wRpx3fffWe17YcffjD1h4Ndu3ZVq1atTMtnD7t37zaMN2rUSDly5LA5v5eXlwYPHmxznuTIkyePunbtanre7t27y9/f37Bt7dq1pvf3tCpZsqSGDBlil9xZs2bV0KFDDdtWrlypoKAgu/QrSS1bttSwYcMM28aPH69NmzYlO2dwcLBhPCWfXaN9+AHkk1kb4//44w9FRUU5uBpI0p07dwzj2bNnt1ufK1euNIxXrlxZjRs3Nr2/Hj16KHfu3IZtv/zyi+n9PclPP/1k+Dw/++wzFSxY0GF1vPTSS4bxQ4cOOayGtKJChQqqUaOG3fvp2LGjfHx8DNv27t1r9/7tqXfv3lYvYty5c6eDqwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQVJMmTdKRI0cePfbw8NCKFSs0evRoeXt7JytXz549tXbtWnl6ej6KrVmzxinvszd+/HhdvXr10eN27drp119/la+vb5L2f/nll7V06VK5u7s/iu3atUuLFi2yus/y5cv14MGDBP9S4vF7VrryPVkLFy6s999/X1myZJEkDRgwQNOnT0/W/eVLlSqlLVu2qHz58gniH330kam1AgAAAAAAAAAA+6lQoUKi7WfOnFFkZKSDqgGApw/jMAAAAJ4GzHsBIPUwBgMAAAAAAAAAAAAAAAAAAAAAAAAAAKTMzZs3DeO5cuWyS3/p06dX7ty5bcoRGxuroKAgi7iPj4/Sp09vU25HstdrnFju27dv263P//rvvbv+y9b3PjHWct+4cSPZuWbMmGEY79Onj0WsR48eFrH79+9r+fLlye4XltLK5x32Ex8fr8DAQH3zzTcqW7as1XvLZcqUSa+88opDaipUqJC6dOliEY+KilLTpk01depURUdH29xPjhw5bM7h6nbt2qWIiAjDtk6dOjm4GtcVHh6uqKgow7bH72sJS4xDTw9XXDuZJS4uzuHPP7lcfQ3yNDF73IyNjTWMZ86c2aY6/yt//vym5QLrPKRtHN9pB++lY7nCfFNyzLxDcq65hzOueVOKNYNrYjx2nLT0eQcAAADw9HJP7QIAAHC09957T/Hx8YZttWvX1pIlS+Tp6engqpLP2i85FCtWzLQ+ihUrpldffdW0fEBSHTt2TFu3bjVsK1iwoH744QdT+ilUqJCmTp1qSi572rFjh2Hcy8tLvXv3tjn/O++8o6JFi9qcJ7k+++wzU39w7O/vr3Hjxhm2RUVFad68eab19TTKnDmzXnnlFe3atUunT5/WxIkT9dxzz5nez9dff231YuspU6aY3t+/8uTJo3nz5snNzc2ibdu2bRozZkyK8l6/ft0wXrJkyWTnMtrHWn78vxYtWhjG161b5+BK8K+QkBDDeOXKle3W5/fff2/1l0G+//57ZcqUybS+8ubNqy+++MKwLSQkJFXOR59++qlhPFOmTFq+fLl8fHzsXkOHDh1Ur149w7b169fbvf+0ombNmlq9erWOHj2qefPmycvLy259Zc6c2eqxLEkbNmywW9/2lj9/fqsX+UjSb7/95sBqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACRHTEyMunTpoqCgoEcxd3d3ffTRRzp79qxGjRqlypUry93d3WLfdOnSqWLFinr77bd17NgxzZ07N8E9DW/duqU333zTIc8juUJCQtS9e3fFxcU9irVt21bnzp3Thx9+qLJly1rsky1bNnXu3Fm7du3Sjz/+qPTp0z9qu3Xrlrp37271nu9mypAhQ4LH9+/ft3uf9rJ//37NnDkzQax///46d+6cPv/8czVs2FDZsmWz2C9Hjhxq3bq15s+fr6NHj1rcx3PBggUufZ9AAAAAAADw9HB3d9czzzyj6tWrq2XLlnr++efVtWtX9ejRQ506dVKbNm307LPPqlixYgm+jwIAIC3x8PBQ6dKlE93m2LFjDqoGAMzlCnN+R47DrvB6AGkNnzsAAP7B9w8A0jJnn/fz3QMAAAAAAAAAAAAAAAAAAAAAAAAAAEDKBQYGGsarVatml/5KlCghNzc3m/NcunTJMF6uXDmbczuKvV7jvHnzKleuXBbxmJgY/f3333bp83EnT540jNesWdNufdaoUcMwfuLEiWTnWrVqlW7evGkR79mzp0WsW7duFrGlS5cqPDw82f3CWFr4vMMx4uPjNXbsWH333XeG7S1atHBIHa1btza8L+N3332nvXv3mtKHu7u7cubMaUouVxYdHa2AgADDttdee83B1Uh+fn7KmDGjzXnMyJFc1u6RaXQswzrGobTNVddOZrl48aJhvGrVqg6uxJirr0GeVmaMm3fu3DGMZ8mSxaba/qtkyZKm5cI/WOchLeP4Tjt4Lx3L2eebkmPmHZLzzj2cZc2bUqwZXBfjseO5+ucdAAAAwNPLM7ULAADA0Xbu3KkffvhBAwYMMGx//vnn9fvvv+ull15SSEiIg6tLOqML9yWpQYMGypQpk8LCwmzKnz59eq1YsUI+Pj425QFSaujQodq3b5/hBYFdu3ZVXFycevfurdjY2BTlL168uDZv3qxs2bLZWqrdbdmyxWrbhx9+qK+++irFuatXr65x48aleH9b5M+fX/PmzdPzzz9v9aLspHJzc9OiRYuUJ08ew/YlS5bo9u3bNvXxNBs/frwGDx5scU6YNm2atm/frrt375rST//+/dWnTx/Dto0bN2r79u2m9PM4d3d3LVmyRDly5LBoCwoK0ksvvaS4uLgU5d61a5dhvEaNGsl6PqVLl1amTJmSnB//KFu2rPLmzWvYtm7dOgdXg39Zu0lu4cKFVaFCBbvcyPz69etauHCh4RhTokQJzZ49Wy+++KLN/Xh5eWnZsmXy9/c3bP/uu+9S5RdoFy1apNGjR6tEiRIWbdWqVdMvv/yiDh06KCIiwi79Fy9eXN9//71h28OHD7Vo0SK79JuWNGzYUB9++KGaNGnyKFaiRAnNmDFDffv2Nb0/Dw8PzZ492+oYevjwYasXljm7/Pnza9OmTYbnVUnav3+/jh8/7uCqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACRHYGCgmjRpot9++0358+d/FM+fP78+/vhjffzxx3r48GGC+5QPGjRIQ4YMMbxnsiTdunVLTZo00cWLF+1ef0pt3bpVXbp00fz585UuXTpJUvbs2TVu3DiNGzdOERERCgoKUnR0tLJly6asWbMaPt8bN26oVatWunDhgoOfwT9svZ9xanvzzTdVoEABtWjR4lEsV65cGj58uIYPHy5JioyMVHh4uGJjY+Xr6ytvb2+r+dasWWP1vr4AAAAAAADOIH369KpevbqqVKmicuXKJfpdx+MuXryogwcPat++fbp+/bodq5S8vb1VsmRJ5c2bV3nz5lXGjBmVPn16eXl5KSoqSuHh4QoLC9PFixd19uxZXbt2LVW+q8qRI4f69+/vkL7CwsI0ZcoUSVLBggXVo0ePJ+6zZs0aHT161KZ+W7ZsqapVqya6zdmzZ7VkyZJk5XW299jDw0NFihRR0aJFlTt3bvn5+SldunTy8PBQdHS0IiMjFRISomvXrunMmTO6evWq3WoBXElaGI+KFSumDBkyJLrN8ePHEzxOC88bQNrlKnP+f6VkHE4OV3s9gLTAlT53zrY2tSa1vn+QXH/u62zvsdH3Dz4+Pnz3ACSBq49Hrv79A989AHicK837+e4BAAAAAAAAAAAAAAAAAAAAAAAAAAAg5f766y81aNDAIl67dm0tW7bM9P6M+kqJ48ePq1q1ahbxmjVr6sCBA6b0YW+1a9dO8LdgzFKrVi3D+Llz5xQXF2d6f0b+/PNPtWrVyiJer149LVy40PT+SpYsqezZs1vEo6KidO7cuWTne/jwoX7++We99957CeL58uVL8LhmzZoqWrSoxf6zZs1Kdp+wLi183uFYo0eP1muvvSZPT88E8erVqzuk/2effdYwvnjxYtP6qFq16hP/1sLTYt68eWrXrp1FvGTJkmrbtq1Wr17tsFpGjRql1157TYsWLdLMmTO1f//+ZO2fK1cuffjhh+rRo4dKlCihoKAgO1WaUJYsWZQ+fXrDtrCwMIfUkNYwDqVNrrp2MsuRI0dUs2ZNi3jt2rW1YsWKVKgoIVdfgzztbBk379y5YxgvXLiwKbVJzvd5TAtY5yEt4/hOO3gvHcvZ55uSY+YdkvPPPVJ7zZtSrBlcF+Nx6nHVzzsAAACAp5fnkzcBACDtGTZsmBo0aKDSpUsbtjdr1kxHjx5V/vz57dK/r6+vBg8erLfffjvFOXbt2mUYT58+vUaMGKGRI0emOLePj4+WLFmiChUqPIrFxsbKw8MjxTmB5Dpw4IBmzZqll19+2bC9e/fuypcvn9544w2dPHkyWbm7deumSZMmKWfOnGaUancHDx7UgQMHDH/44+fnJy8vL8XExCQ7b/ny5bVmzZoENxiMj4+Xm5ubTfUmR/v27bVy5Up169ZNDx48SFEOHx8fzZ8/X02aNDFsj46O1ieffGJLmU+9K1euyMfHxyJeoEAB/fLLL2rTpo0iIiJs6mPAgAGaNm2aYVtsbKyGDh1qU/7EfPLJJ6pXr55FPD4+Xj179rTpZpoXL17UlStXLH65rmPHjvrqq6+SnOf55583jG/fvj3FtT0NWrZsaRi/cOGCzpw54+Bq8K+dO3dabRs3bpzat29vl35HjhypF154QZkzZ7Zo69SpkxYvXqzevXsrKioqRfmzZs2q//3vf6pdu7Zh+5UrV/TFF1+kKLet4uLi1K9fP23btk3u7u4W7c2bN9eePXvUoUMH/f3336b2XbVqVa1atUq5c+c2bJ8zZ45u3Lhhap/OZvv27YbnGUlauXKl1TH+v8aNG2eYo0+fPoqOjtbAgQP18OFDm2uV/n9ulVhdn332mSl9OVrv3r31xRdfKFeuXFa3GTVqlAMrAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJBSx48fV6VKlTR16lS99NJLFvfl9fT0THAP43Tp0lnNtWLFCr3++usKCgqyW71mWb58ua5fv66ff/5ZRYsWTdCWIUMGFShQINH9161bp5dfflnXrl2zZ5lpWnR0tNq0aaOPP/5YQ4cOTXCP6H+lT59e6dOnTzRPVFSUxo4dqwkTJiguLs5e5QIAAAAAAKSYj4+PWrZsqaZNmypjxowpylGwYEEVLFhQzz//vA4fPqxff/1VFy5cMLXOMmXKqHnz5ipbtqzhdzXWBAcHa/Pmzdq6davu379vak2JSZcunUqUKOGQvkJDQx/9/8WLFxUfH6+SJUsmuk+XLl107NgxxcfHp6hPX19fdezYMdHvZOPj47Vw4cIk53S29/iZZ55Ry5YtVb169WR9NoKCgrR582Zt3rxZkZGRptUDuBpXHo/+VaFChUTbQ0NDdfny5QSxtPC8AaQ9rjLnf1xKxuGkcNXXA3BlrvS5c7a16ZOk1vcPkuvOfZ3tPU7J9w989wAk5Krj0b9c/fsHvnsA8C9Xmvf/i+8eAAAAAAAAAAAAAAAAAAAAAAAAAAAAUm779u167bXXLOKtWrXSu+++a3p/bdu2NSXPvn371LdvX4t4w4YNNW3aNFP6sLfGjRvL29tb0dHRpuZt3bq1YXzHjh2m9pOYgIAADRs2zCL+3HPPadCgQYqNjTW1vw4dOhjGt27dmuK+Zs6cqffeey/RbXr06GERO3PmjHbt2pWiPmEsLXzeXZmHh0dql5BswcHBOnLkiKpVq5YgnjlzZruMu4975plnDOOnTp0yrY/GjRublisxrvD+r169Wrdv31aOHDks2iZMmKDff//d9POOkYwZM6pfv37KlCmTXn31Vb366qs6evSoZs6cqTlz5ujBgwdW982aNauGDx+uQYMGycfHR5L03nvvGZ5L7aFIkSJW227evOmQGtIaxqG0yVXXTmbZu3ev+vfvbxFv3bq1hg4dmgoVJZQW1iBPM1vGzZCQEMN4lSpVTKnN09NTzZs3NyUX/h/rPDgLe6x5OL7TjrT2Xjr7Gt/Z55uS/ecdkmvMPRyx5rXH8cqawXWltfHYlaT2d1wAAAAAkFzuqV0AAACpISwsTG3bttWdO3esbpMvXz7t3LlTHTt2lKenp819uru7q379+po0aZIuXbqkjz76SFmzZk1xvt27d1u9uezw4cPVqVOnFOUtVKiQdu7cqeeee+5RLCwsTAsWLEhRPsAWgwcP1smTJ622N2jQQMeOHdNPP/2kZs2aycvLy+q22bNnV69evbRz504tWLBAOXPmTNA+f/580+q2h6+++spq2y+//JLsGwZ27dpV27dvT/A63L59W1u2bElpiSnWrl077dmzR5UrV072vpUqVdLOnTv1/PPPW93m66+/1pkzZ2wp8an3008/6dq1a4ZtjRo10o4dO1S6dOkU5c6ZM6fmzZun77//Xu7uxkvUTz/9VEePHk1R/idp3ry53n//fcO2CRMmaP369Tb3sXjxYotYnTp1VK9evSTtnyFDBg0aNMgi/tdff+nYsWM215eWtWrVyjC+bt06B1eC/zp48KCuX79u2NauXTt98803psy/H3ft2jWNGDHCanuXLl20fft2lS9fPtm5n332We3bt08NGza0us3AgQMVFhaW7Nxm2blzpyZOnGi1vUKFCvrzzz81duzYR7+kZYscOXLoyy+/1N69e5UnTx7DbYKDg/Xhhx/a3NfTYPjw4VbbXnvtNe3Zs0d16tSxuZ9WrVrp5MmTic6tdu7cqWXLltnclyN4eXmpUqVKGjt2rE6fPq05c+YoV65cVrdftGiRKed+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI4REhKibt26qVKlSpo+fbpu376d5H1v3bqlWbNmqXLlyurUqZOCgoLsWKm5du7cqVKlSun111/Xn3/++cTtY2NjFRAQoFatWqlVq1ZW71WLpIuNjdXIkSNVqlQpTZgwQZcuXUryvkFBQZowYYJKlSqlzz//XHFxcXasFAAAAAAAIGUqVaqkzz//XO3bt1fGjBltzufm5qYqVapozJgx6tq1q7y8vGzO6e/vrw8++EDDhw9X5cqV5e3tnaz9s2fPrhdffFETJkxQ3bp1ba7HFSxcuFDx8fGJbpM3b17VqlUrxX20a9dO6dKlS3Sb3bt36++//35iLmd7j9OnT69evXpp/PjxatiwYbI/G/7+/urSpYu+/PJLVa5c2eZ6AFfmauPR48qXL59ou7Wf37j68waQtrjCnN+alI7DiXHl1wNwVa7yuXO2tamrcKW5r7O9x7Z8/8B3D4AlVxqPHufq3z/w3QMAyXXm/Y/juwcAAAAAAAAAAAAAAAAAAAAAAAAAAICUCwgIMIyXKlVKTZs2NbWvIkWKmJZzw4YNhvF27drJ39/flD7szd/fXy+99JKpOXPkyKFu3boZtq1bt87UvhKzdetWPXjwwCKeP39+derUydS+vLy89NZbbxm2rVq1KsV5z549qy1btljEM2XKJEny8PBQ586dLdpnzZqV4j5hLC183l2B0WdWkjJnzmzXfnPnzm2XvNbu/efn52eX/v4ra9ashvHIyEhT8ru7u+vVV181Jde/Uuv9N0NUVJQmT55s2FaqVCmNGTPGIXV8+umnFsdXxYoVNXHiRPn4+Fjd7/nnn9fff/+t4cOHJ9hu8ODBqlSpkp2qTahjx46G8cjISF24cMEhNaQmxqHks8c45Apcde1kFmvridKlS6tJkyYOrsZSWliDuApnGzdPnjxpGM+dO7eKFStma1l64YUXWHfYAes8OJoj1zwc32mHq76XrrrGd/b5pmT/eYdk/tzD2eZuj3Pk8cqawXW56njsaM7+eQcAAAAAR3BP7QIAAEgt586dU8uWLRUaGmp1mzp16mjFihUKCgrS/Pnz9dprr6lKlSrKkiVLornd3NxUoEABtWrVSkOGDNH8+fN18+ZNbdu2TW+//fYT90+K2NhYzZ8/37DNw8NDS5cu1bfffqtcuXIlKV+ePHk0ZcoU/fXXXxYXYn700UdWv/gE7OnBgwfq2LGjbt++bXUbDw8P9evXTxs2bFBISIgOHTqktWvXau7cuVq0aJE2b96sEydO6ObNm/r5559Vp04dixznz5/XsGHD7PlUbLZs2TKdOHHCsK1NmzY6e/asXn755UR/aOjp6ak2bdpo27ZtWrhwoXx9fRO0jx07Vnfv3jW1biMbN260uNi6XLlyOnjwoBYtWqS6devK3d36UsXDw0P16tXTwoULdejQoUQvHj969Kg++ugjkyp/ekVFRemVV16x2l6lShUdO3ZMCxYsUNOmTZ9443Q3NzdVr15d33zzjc6ePasePXpY3Xb79u36+OOPU1x7Yp555hnNnz9fbm5uFm27du3SyJEjTeln8uTJiomJsYj/+OOPVi9g/69p06YZ/mDzq6++MqW+tMrHx0f16tUzbFu7dq2Dq8F/xcbG6ttvv7XaPmjQIJ0+fVrDhg1TjRo1lC1bNnl4eJjS97Rp07Rs2TKr7dWrV9eRI0cezRkSOx95e3urWbNmWr16tbZu3ZrohVCTJk1yiotfRo4cqd9++81qu4+Pj8aMGaNr167p+++/17PPPvvEm7v/V44cOdSpUyfNnTtXV65c0dChQ62+d3Fxcerbt69u3ryZ7OfxNNq1a5emT59utb1q1arauXOn9u3bp0GDBqlcuXKG5zcjxYsX16BBg3T8+HH9/vvvKliwoNVtQ0ND1atXr2TXn1STJ0/W7NmzU/xv/vz5+vXXX7Vp0yadOnVK4eHhOnz4sMaMGaOSJUsm2vfRo0fVv39/uz03AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPZz7Ngxvf7668qZM6fKlCmjnj17asSIEVq4cOGjbfbu3at33nlHL774okqXLq1cuXLp5Zdf1pEjRxxW57Zt2+Tm5vbo3+uvv57iXA8fPtT06dNVvnx55c2bV926ddPQoUM1YcIEff/995o4caKGDx+utm3bKmfOnGrevLnWrVuXrD7atm0rNzc3m+8RXL169QTP+/fff7cpn1nMeD/+/vtvDR8+XAULFlThwoXVoUMHDRkyRJ999pm++eYbff/995owYYJGjBihnj17qmTJksqZM6eGDx9ucZ9nAAAAAAAAZ9G1a1e988478vX1NT23u7u7WrZsqTFjxsjPzy/FecqXL69x48apZMmSNtfk4+Oj1157TS+//LLNuZzdhQsXtHv37idu17FjR3l4eCQ7f/bs2dWwYcNEt4mOjtayZcuemMvZ3uOcOXNq7NixatKkidzd3W2qJ0uWLHr77bfVunVrm/IArsyVxqPHZcmSRQUKFEh0m2PHjhnGXfl5A0hbXGHOb40t47A1rvx6AK7KVT53zrY2dSWuMvd1tvfYrO8f+O4B+H+uMh49Li18/wAArjLvfxzfPQAAAAAAAAAAAAAAAAAAAAAAAAAAANjm5s2b2rVrl2HbBx98YGpf48aNk5ubmym5zp8/r+PHj1vEvb299eqrr5rSx798fX2VO3duU3P+a+jQoSn6ewLWvPvuu0qfPr1F/MGDB9qwYYNp/TxJdHS0lixZYtg2cuRIeXl5mdbXa6+9pjx58ljEo6KibP57jjNnzrSIvfjii5KkZs2aKWfOnAna4uLiNHfuXJv6hKW08nl3dnfu3DGMFyxY0C795cuXT99//70uXryo9u3bm57f29vbMB4REWF6X4+7f/++Ydzf39+U/F27dlXRokVNyfUvR7//Zps6dapCQkIM20aOHGn3v/HVoEEDDRo0yLBtzpw5CgoKsrrv6dOnlTlzZou4l5eXFixYoEyZMplWp5FMmTKpb9++hm07duxQXFycXftPTYxDKWePccgVuOraySzXr1/Xzp07DdtGjBhhal+vvfaaKlasmKx90soaxJk567gZGBio4OBgw7Y+ffrYWpbGjh1rcw5YYp0HR3PkmofjO+1w1ffSVdf4zj7flOw/7/D09DRt7uGsc7fHOfJ4Zc3gulx1PHYUV/m8AwAAAIAjeKZ2AQAApKZ9+/apUaNGWrt2baJfdPr5+al79+7q3r37o9j9+/cVGhqqiIgIxcTEKF26dMqcObMyZ84sHx+fFNd05cqVJN8w9uOPP1bv3r0N+3Nzc9Obb76pAQMGaNOmTdq3b5/Onj2r0NBQRUVFydfXVzlz5lShQoXUtGlTVahQwfDiq9WrV2vixIn67LPPUvycAFv89ddfatCggTZv3qxcuXIlum2mTJlUuXLlZOUPCQlRq1atdO/ePVvKtLvY2Fh16tRJBw4cUMaMGS3ac+fOrR9//FHff/+9du3apQsXLigoKEgxMTHy8/NTsWLFVL16das3AQwICNC0adPUtGlTOz8TKSwsTH369FFAQECCHzi6ubnppZde0ksvvaSQkBDt2bNHN27c0K1bt+Th4SF/f3/lzp1btWrVStLNDENCQtShQwdFRkba8dk8PdauXaupU6fqzTffNGz39PRUt27d1K1bN0VGRiowMFDnz5/X/fv3FR4eLk9PT2XOnFn58+dXmTJlknTDy5MnT6pdu3aKjY01++nI3d1dixYtMrxQPCQkRF26dDGt36tXr+qHH36weO1KliypHTt2qF+/ftq7d6/Ffrly5dI333yjzp07W7SdOXOGX8Z7goYNGypdunQW8ZiYGG3evDkVKsJ/ff/993rzzTcNLxSRpKJFi2rChAlJyvXJJ59o1KhRSe67V69eKlCggGrWrGnY7u7url69eqlXr14KDg7Wvn37EpyPcuXKpTx58qhWrVqG5+THrV69WkOGDElyffb08OFDvfDCC/rtt9/UpEkTq9v5+vpqwIABGjBggKKjo3Xs2DFduHDB8JduxowZo3Tp0qlw4cJPvEnyv+Lj4zVw4ECtXr06xc/laTRo0CCVL19edevWtbpN9erVVb16dUn//IL8hQsXdOnSJd27d0/h4eGKjo5WhgwZ5Ofnp+zZs6ts2bJJvkl0ZGSknn/+eZ0/f96Mp2Po319Ed7TDhw+rZcuWVn+xDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBriI+P16lTp3Tq1ClJUpUqVdStWzdJ0vbt2zV58uRUrM5+rl27pkWLFtktf6ZMmSRJERERdusjLbhw4YIuXLiQ2mUAAAAAAACkmJubm1555RXVq1fP7n3lz59fH374oSZMmKBbt24la9+SJUvqrbfekre3t6k1Pfvss4qJidHcuXNNzetsli1bpmrVqiX6+uXMmVP169fXli1bkpW7Q4cO8vT0THSbdevWKSQkJNFtnO09zpEjhz744ANlzZrV1Hq6dOmisLAwbdu2zdS8gKtwhfHISPny5eXm5ma1PS4uTn/++afVdld93gDSBleZ8yfG1nH4v9LC6wG4Glf63Dnb2tQVOfvc19neY3t8/8B3D8A/nH08MpIWvn8A8PRypXm/Eb57AAAAAAAAAAAAAAAAAAAAAAAAAAAAsN20adNUp04di3ijRo00ZMgQffXVVzb30bJly0f3pjLLzJkz9c0331jER44cqWXLlunMmTOm9DNp0iS98MILGjVqlKZOnaq4uDhT8kr//L7sl19+qXfffdfmXA0aNNB7771n2DZv3jzdv3/f5j6SY+LEierbt6/F7wOXL19ekydP1sCBA23uo3Llypo4caJh29y5c23+Xd4VK1bo22+/VbZs2R7F+vTpo9mzZ6tHjx4W22/YsEHXrl2zqU8YSwufd2d39epVw3jx4sWVK1cu3bx505R+8uXLpw8++EAvv/zyo7+38s0332j79u2m/g3WYsWKWcTCw8MdMhbevn3bMF67dm2tWLHCptx58+bVpEmTbMphxFHvv73cvXtXw4cP18yZMy3a3N3dtXz5crVr104bN240ve9KlSpp1apVcnd3t2iLjo62ep7616lTp7RkyRJ17drVoq1MmTL6/fff1aJFC7vdl3Ly5MnKly+fYduyZcvs0mdqYxxyznHIVbjq2sks06dPV926dS3iTZo00eDBgzVlyhSb+6hWrZq+//57ubu7a82aNRo3bpz27duXpH3TwhrEGbnCuLlr1y61bdvWIv7qq69q4sSJCg0NTXFdpUqVSvG+SBzrPDiSo9c8jj6+s2bNyrFtJ644VrnyGt/Z55uSfecdH3zwgc1zD1eYu/2Xo49X1gyuyxXHY3tztc87AAAAADiC5ZUbAAA8ZY4cOaKKFSsm+2LJzJkzK3/+/CpRooTKli2rYsWKKVeuXPLx8UlRHbGxsfruu+9Uvnx5bd68OUn73LhxQ4MHD050G09PT7Vo0UKjRo3Szz//rF9//VXr1q3TkiVL9O2332rIkCGqWLGi4Q3Ntm3bpu7du6fo+QBmOnnypGrWrKk9e/aYmvfSpUt69tlnFRgYaGpeezl9+rRee+01xcfHW93Gy8tLDRo0UO/evTV06FCNGDFCr7/+upo1ayY/Pz+reR19AebWrVsTfS7ZsmVT69at1a9fP73//vsaNmyY+vTpo5YtW1p9Hv9169YtNW7cWBcuXDC38KfcW2+9pXnz5j1xu/Tp06tChQrq0KGDevbsqf79++vll19W586dVbt2bfn6+j4xx4EDB9SwYUObLihIzEcffaQGDRpYxOPj49WrVy9duXLF1P6GDh2qY8eOWcTLlCmjPXv26OTJk1q4cKGmTJmiWbNmadu2bbp69ao6d+5ssU90dLS6dOmiqKgoU2tMa1q1amUY37Vrl8LCwhxcDR4XGhqqHj16pMoFBpGRkWrSpIk2bNjwxG2zZ8+uVq1aqW/fvho+fLiGDh2qnj17qkmTJsqYMeMT9583b546duyY6Lnb0aKiotSmTRvNmDEjSdt7e3urWrVq6tSpk/r27WvR3rx5czVo0EAFChRIUr779++ra9eumj59erLqhvTw4UO1atUqSceuJGXMmFFly5ZVq1at1KVLF/Xt21f9+/dXr1691K5dO9WtWzdJ8yrpn19CbNGihbZs2ZLyJ+Ck5s6dq/r163OBGgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYUbduXUnS1atXU7kSAAAAAAAA2FPnzp1Vr149h/Xn7++vIUOGKEOGDEneJ2PGjHrzzTfl7e1tl5qaNGmiqlWr2iW3swgJCdG6deueuF379u3l5eWV5LzPPPPME4+f0NBQrVmzJtFtnO099vLy0jvvvKOsWbPapZ4ePXooZ86cdskNODtnH4+sKV++fKLtFy5c0IMHD6y2u+rzBpA2uMKc/0lsHYf/Ky28HoCrcZXPnbOtTV2VM899ne09tuf3D3z3ADj3eGQN3z8AcGWuMu+3hu8eAAAAAAAAAAAAAAAAAAAAAAAAAAAAbLds2TJdunTJsO3zzz9X27ZtbcpfpkwZLVy40KYcRn766ScFBQVZxH18fLRgwQJlzJjR5j5eeeUV9e3bV1myZNGUKVN06NAh1a5d2+a8//XOO+/o1VdftSlH6dKltXjxYnl4eFi0PXz4UJMnT7Ypf0qcOnVKS5cuNWx744039M4779iUv3jx4vrll1+UPn16i7bIyEh9/vnnNuWXpKioKM2fPz9BrH79+ipXrpw6dOhgsf2sWbNs7hPG0srn3ZldvXpVV65cMWx74403TOtn+vTpev311xP8TakCBQpo2bJlpv3+fY0aNVSsWDGLuLXnZ7bAwEDDeP/+/W3K6+Pjo+XLl8vf39+mPEYc9f7b048//qitW7catmXIkEFr167VW2+9ZWqfL774orZu3aosWbIYto8dO1bnzp17Yp4PPvhA9+/fN2yrX7++tm3bpiJFithU6+Pc3Nz0zTff6OWXXzZsDwkJscv8zRkwDqWcPcchV+GqayezLFq0SGfOnDFs+/LLL9W6dWub8ufOnVvLli2Tu7u7JOm5557T3r17FRAQkKS/05gW1iDOyBXGTWvve86cOTVp0qQU19W+ffsU74snY50HR3L0msfRxzfHtv244ljlymt8Z59vSvadd4wZMybF+//LFeZu/+Xo45U1g+tyxfHY3lzt8w4AAAAAjuCe2gUAAOAMbt26pebNm+uVV14x/GLVnmJjY7VkyRKVL19eAwcOVGhoaLL2//HHH/XRRx+ZXtfSpUvVvHlzqxdqAo528eJF1atXTyNHjtS9e/dszrdo0SJVrVpVJ06cMKE6x1m4cKH69eunmJgYU/L9+eefaty4sW7fvm1KvuSYM2eOXnrpJUVFRZma9+jRo6pbt66OHj1qal5I8fHx6t27tyZMmKC4uDi79TNnzhw1aNDAbufkJk2a6IMPPjBs+/rrr/Xbb7+Z3mdUVJQ6duyoixcvGraXLl1aXbt21VtvvaW+ffuqfv36Vn/h8eWXX9bhw4dNrzGtadGihWF87dq1Dq4E1vzxxx/q1q2bIiMjHd73gwcP1KZNG3311Vd2Gc8iIyM1bNgw9erVSw8fPjQ9v62ioqLUv39/de3aVcHBwQ7rd+PGjSpbtqyWLFnisD7Tmvv376t169aaMGGCw46tPXv2qFKlStq2bZtD+nOUY8eOqUWLFurdu3eSb+ANAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE8TNzc3TZ48WbVq1ZLEfUEBAAAAAADSsurVq6t169bJ3i8uLk737t1TSEiIoqOjk71/7ty59dprryV5+y5duihLlizJ7ic5unbtKk9PT7v2kdrWrFmju3fvJrpNtmzZ1KhRoyTn7Nixo9zd3RPdZsWKFYqKikp0G2d7j1988UXly5fPbrWkS5dOHTp0sFt+wNk583hkxM3NTeXKlUt0m+PHjz8xj6s9bwBpg6vM+RNj1jgspY3XA3A1rvS5c7a1qStz1rmvs73H9vz+ge8egH8463hkhO8fALgyV5r3G+G7BwAAAAAAAAAAAAAAAAAAAAAAAAAAAHPExMTo3XffNWzz9PTUypUrNWzYsBTlbtKkibZv366sWbM+il29ejVFuR4XHh6uMWPGGLZVr15d27ZtU86cOVOc/6233tIPP/yQIFaxYkXt3LlTLVq0SHFeIzNmzNDXX38tDw+PZO/bpk0b7dmzR7lz5zZsnzp1qv766y9bS0yRwYMHW/17Cl9//bWmT58ub2/vZOdt1qyZ9u3bp4IFCxq2f/TRRzp//nyy8xqZMWNGgsdubm5auHChMmbMmCB+584d/frrr6b0CUtp6fPuzLZs2WIYf//99/Xss8+a0seoUaMUHx9vEW/cuLE2bdqk/Pnz25Tfz89PP/30k2Gbo+7rt379esN4s2bN9PLLL6coZ548ebRjx45H9yiUpEOHDqUolzWOeP/trUuXLrpx44Zhm6enp6ZMmaJt27apdu3aNvVTvHhxLV68WEuXLrX6N9IOHDigL774Ikn5Lly4oAEDBlhtr1atmo4cOaIhQ4YoQ4YMKar5vypXrqw//vhDgwYNsrrNmDFjFBYWZnNfzohxyHnHIVfgqmsns8TGxmrIkCGGbV5eXlq1apUGDx6cotylSpXStm3bVKhQIYu23LlzKygoKEl50sIaxNm4wri5ePFiXbt2zbCtT58+Gj9+fLLrevXVV7V8+fJHjwMDA5OdA4ljnQdHc+Sax9HHN8e2/bjqWOWqa3xXmG/ac97x378jnNK5hyvM3R7n6OOVNYNrctXx2J5c8fMOAAAAAPaW+F2aAAB4isTHx+unn35SsWLFNGLECLtfhHT9+nVNnDhRxYoV00svvaRTp06lONfYsWPVuXNn3blzx+a6bt++re7du6tLly7crBFOJzY2VuPHj1ehQoX08ccf69y5c8naPyYmRitWrFCdOnXUrVs33b59206V2tecOXNUv359my/OWrBggWrWrKnr16+bVFnyLV26VNWqVdOBAwdszhUZGanx48erevXqOnv2rAnVwUh8fLyGDx+uJk2a6OTJk6bmPnXqlJ577jn17dtX4eHhpub+V65cubRgwQLDmxbv3btX77//vl36laRz586pdu3aOnr0aIr2f/Dggdq3b6/58+ebXFnaU7hwYRUvXtywbd26dQ6uBolZsmSJ6tWrp507dzq874cPH2ro0KGqU6eOKeehfwUEBKhSpUqaOHGiaTntZfHixSpUqJBGjx6te/fu2a2fffv26aWXXlKzZs10+fJlu/XztIiNjdXw4cNVoUIF/f7774YXwpjh8uXLeuWVV1SnTh1duHDBLn042v3797Vo0SI1bdpUFStW1IYNG1K7JAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwSlmzZtXatWs1ePBgSdKFCxf00UcfpXJVAAAAAAAAsIcMGTKoV69eSd7+1KlTmj17toYMGaJ+/fpp0KBBeuedd/Tqq69qwIAB+vrrr/XHH38oOjo6SfmqVKmiatWqPXE7Pz8/1a1b94nbRUZGat++fVqyZIlmzJih6dOna/78+dq7d69iYmKeuL+/v7/KlSuXpNrtZceOHVq0aJHN/3799VfD/FFRUVqxYsUT62jbtq3SpUv3xO0KFCig6tWrJ7rNpUuXtH379kS3cbb3OFeuXGratOkTt5Ok8+fPa+XKlZo1a5amT5+uBQsWKCAgQMHBwYnuFxsbK29vb7m5uSWpHyCtcdbxyJqCBQsqc+bMiW5z7NixJ+ZxtecNwPW5ypz/Scwah9PK6wG4Elf63Dnb2tSe7P39g+Scc19ne49T8v0D3z0AyeeM45E1fP8AwFW50rzfGr57AAAAAAAAAAAAAAAAAAAAAAAAAAAAMM+KFSu0Zs0awzZ3d3dNmDBBhw4dUosWLZKUr1SpUpo7d64CAgKULVu2R/HIyEh9+OGHptQsSd9//722bt1q2FalShX9+eefeuONN+Tp6ZnknOXLl9fatWs1ZcoUubu7W7Tv379fAQEBKa75X4cOHUrw+J133tHJkyfVqVOnJP39kfLly2vVqlVas2aNsmTJYrjNhQsXNHr0aJtrTambN29qwIABVtv79++vwMBA9ejRI0nvUdmyZfXLL79ow4YN8vPzM9xmx44d+vLLL1NasoUTJ05oz549CWLly5e32G7hwoVJ/h1jpIwrf95dxfTp0w3j3t7e2rhxoz7//HMVLFjQpj4OHz6s77//3rCtdu3aOnnypEaNGqUcOXIkO3eLFi20b98+q39PatmyZcnOmRLbt2/X7du3DdtmzJihUaNGJfk49fb21ltvvaWjR4+qcuXKj+KhoaGmj++OeP/t7ebNm2rXrp3u379vdZv69etr165d2rVrl9544w0VLVo0SbmzZs2qrl276tdff9WpU6fUpUsXq9teuHBBHTp0UFxcXJJrX7hwoX744Qer7ZkzZ9bEiRN18eJFTZo0Sc8++6w8PDySnD9btmzq1auXfv/9dx08eFANGjSwuu2mTZs0bdq0JOd2NYxDzjsOuQpXXTuZZfXq1ZozZ45hm4eHhyZPnqwDBw6oefPmScqXKVMmffjhhzp48KCKFy9u0R4fH6+3335b8fHxScqXFtYgzsYVxs2HDx9q0qRJVttHjBih3377zfAYe1yVKlW0du1azZgx49Exsn//fq1cuTJJtSB5WOfBkRy95nH08c2xbT+uOFa58hrf2eeb9p53SLbNPVxh7vY4Rx+vrBlclyuOx/bkip93AAAAALC3pK8IAQB4Sty7d0+ff/65vvzyS82cOVNt27ZN0ZeGRk6ePKkNGzbot99+0+bNm5N1weSTLFu2TNu3b9dbb72lV199Ndk1X7p0SVOnTtW0adMUHh5uWl2APdy5c0djxozRmDFjVLlyZdWsWVNVqlRRgQIF5OfnpyxZsig6Olr379/XrVu3dOrUKe3fv1+bNm1SWFiYYc706dNb7S8pN3h2tL1796pcuXLq37+/vv322yTvFx8fr+3bt2vkyJHasWOHHStMuj///FM1a9ZU586dNXz4cFWqVClZ+9+8eVPz5s3TxIkTdfPmTfsUCQtbtmxR2bJl1aFDBw0cOFANGjSQl5dXsvPExcVp48aN+umnn7Rs2bIkX4iQEm5ublq4cKFy5cpl0Xbnzh117txZDx8+tFv/knT9+nVVr15dAwcO1OjRo5U1a9Yn7hMfH6/58+drxIgRunr1ql3rSytatmxpGL9586aOHj3q4GrwJAcPHlS9evVUq1Yt9erVS7Vr11b58uWT9cs/tti7d6+qV6+uJk2a6J133lGzZs3k7e2drBwPHjzQmjVrNHHiRB04cMBOldpHWFiYxo0bp0mTJqlDhw7q1q2bmjVrlqwLSYycP39emzdv1syZM7Vv3z6TqsV/nTp1Sm3atFHhwoX1yiuvqH379ipbtqxNOWNiYrRx40bNnTtXy5cvt/t50WxxcXGKiopSRESEgoKCdPPmTQUGBurkyZPavXu3Dh486JRzewAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2ce3aNY0ZM0aStGvXrlSuxrWULVtWTZs2lSQdP35crVu3VnBwcCpXBQAAAAAAAHvo0KGDsmTJ8sTtbt68qTlz5ujkyZNWt4mIiNDRo0d19OhR/frrr+ratatq1qz5xNzdunXT0aNHFRMTY3WbEiVKyM3NLdE827dv16JFi/TgwQOLtoCAAGXLlk1vvPGGihcvnmieKlWq6MiRI0+s214OHz6sAwcO2LWPbdu2qXnz5sqXL5/VbbJkyaLmzZtr9erViebq1KnTE9+bRYsWKT4+PtFtnO09btWqlTw8PBLdJigoSDNnztRff/1l2D5//nw1adJE3bp1k6enZ4L9tmzZou3bt+vu3buJ9gGkdc44HllTvnz5RNsfPHigc+fOJSmXKz1vAK7PVeb8T2LWOJxWXg/AlbjS587Z1qb25IjvHyTnm/s623ts6/cPfPcAJJ2zjUfW8P0DAFflSvN+a/juAQAAAAAAAAAAAAAAAAAAAAAAAAAAwFw9evTQgQMHVKxYMcP2ypUra926dbpx44bWrl2rY8eO6ebNm7pz547SpUunbNmyqVy5cmrUqJEqV65smGPw4ME6f/68qXV37txZ+/fvV4ECBSza/P39NW3aNI0ePVpr167Vxo0bdfnyZd26dUvh4eHy9vZW5syZVaBAAVWoUEGtW7dWrVq1rPZ1/fp1vfjii4qLi7O57r59+2rfvn1Kly7do1iJEiW0bNky3b59W+vWrdPBgwd148YN3blzR5kzZ1auXLlUvHhxtWzZUiVLlkw0f0REhDp06KD79+/bXKstFi9erHLlymnkyJGG7QULFtS8efM0depUrV+/Xvv27dONGzcUHBysjBkzPnrOrVq1euJzPn/+vDp06KDY2FhTn8OMGTMSPS4kadasWab2CWOu+nl3FTt37tSOHTtUr149izYvLy8NHz5cw4cP19WrV3Xp0iXdv3/f8PW5efOm+vTpY7Wfd955RzVq1FC1atUs2jJlyqSPP/5Yo0aN0q5du7RlyxadOnVKFy5c0P379xUeHi43NzdlzJhRfn5+Klq0qCpXrqzWrVsn+nemVq9erZ07dybthbBRVFSUPv30U02aNMmizd3dXR9//LEGDBigefPmadu2bfrrr78UGhqqyMhI+fr6KmfOnCpWrJhatGihNm3a6JlnnkmQIz4+Xr1791ZQUJCpdTvq/be3/fv3q1WrVlq7dq0yZ85sdbvatWurdu3akv75O2Bnz57V5cuXFRYWpoiICHl6esrX11dZs2ZVmTJllD9//iT1f+3aNTVu3FhXr15Ndu0DBgyQm5ubXnvtNavb+Pv76+2339bbb7+t6Oho/fXXXzp16pRCQkIUFhamBw8eyNPTU5kzZ1bmzJmVJ08elStXTnnz5k1SDcePH1enTp3S/N8mYhxyznHIlbjq2sksAwYMUIkSJVSnTh3D9qpVq2r9+vUKCgrShg0bdPjwYd26devRPXZ9fX1VuHBh1ahRQ82bN1eGDBms9vXZZ59p06ZNyaovLaxBnI0rjJuTJk1S+/btDecyktS6dWu1bNlSe/bs0fr163Xp0iUFBQXJzc1N2bJlU/ny5dWsWTNVrFgxwX5RUVHq16+funfvnuRakDys8+AoqbHmcdTxzbFtf642Vrn6Gt/Z55v2mndI5sw9XGHu9l+pcbyyZnBdrjYe25urfd4BAAAAwN48n7wJAABPp9jYWPXr10/SP7+wUL16dVWqVEkFChRQ/vz55e/vrwwZMsjHx0deXl6KjY1VRESEIiIidPfuXV29elVXr15VYGDgo5tz2fvisRs3buiDDz7Q2LFj1aBBA9WsWVM1a9ZUnjx55Ofnp6xZs8rT01P37t1TaGio/vrrLx0+fFgbNmzQvn37Es09YsQIjRgxwuYau3btqq5du9qcJykSuyDWTNu2bXviDTCTyszXx5Gv9b+aNWvm0P6kf25cffjwYZvz+Pr6Wm2LiIiwOb89xMTEaOrUqTpw4ICaNm2qGjVqqGjRosqePbt8fHwUGxuru3fvKiQkRH/++acOHjyolStX6uLFi1ZzPv/88w58Bv8vLi5Oixcv1uLFi1WiRAm1bdtWlStXVpkyZZQ9e3ZlyZJFbm5uunv3rkJDQ3XmzBkdOXJE27Zt0/bt29P8RdxJ0bZt21Tpd+XKlVq5cqV8fX3VrFkzVapUSWXKlFGRIkUeXZyfIUMGxcTEKCwsTHfv3tX58+d15swZ7dixQ9u2bVNISIhDao2Pj1eTJk0c0ldiYmJiNHnyZM2cOVPNmjVT27ZtVaZMGeXKlUs5cuRQWFiYbt68qUuXLmndunX67bffdOnSpdQu22ZmnSuTomXLlobx9evXO6yGlNi1a5dDXydns2fPHu3Zs0eS5OPj82gO6+fnJx8fH6v7BQYGmtL/pk2btGnTJmXOnFktW7ZUtWrVVLFiReXPn1++vr7KnDmz4uPjdffu3Udj2bFjx7Rv3z4FBAQoKirKlDpSS1hYmObPn6/58+fLx8dHlStXVvXq1VWlShXlyZNHuXLl0jPPPKPs2bMn2O/ChQs6d+6crly5oitXrujUqVPaunWrrly5kkrPxDb2OJ/Wr1/f9Jz/9ffff2vkyJEaOXKk/P399eyzz6p06dIqVqyYihYtqmzZsiljxozy8fFRhgwZFBcXp4iICD148EDXr1/X5cuXdfz4cR04cEA7duxQeHi4XeudMGGCJkyYYNc+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAED6577fH3/8cWqX4ZJ27NihDz74QOXLl9eAAQP04MGD1C4JAAAAAAAAduDj46PGjRs/cbuzZ89q0qRJCgsLS3LuO3fu6LvvvtPVq1fVsWPHRLfNnj27atWqpe3bt1vdZt++fTpz5oyaNWumhg0bKmPGjAnat27dqlmzZiXaT0hIiL788kuNGzdOuXLlsrpdoUKFEs2TFsTHx2vRokUaNmxYotu1atVKmzZtUnh4uGF78eLFVbFixURzHD58WCdPnnxiTc70Hnt7e6tOnTqJbnPnzh2NHz9eISEhiW63adMmubu766WXXtLhw4f1xx9/6MSJE4nuAzxNnHE8sqZChQqJtp88eVLx8fFJyuVKzxuAa3OlOf+TmDEOp6XXA3AVrva5c6a1aVrhbHNfZ3qPzfr+ge8egKRxtvHIGr5/AOCKXG3ebw3fPQAAAAAAAAAAAAAAAAAAAAAAAAAAAJjr7t27atmypTZt2qSCBQta3S537tzq27dvsvN/8803mjFjhp599llbyrRw69YtNW3aVJs3b1a+fPkMt8mVK5f69OmjPn36pLifmzdvqkWLFrp06VKKc/zXsWPH1LNnTy1ZskRubm4J2nLkyKEePXqoR48eKcodERGhjh076ujRo2aUarMPP/xQbm5u+uCDD6xu4+vrq86dO6tz584p6uPkyZNq2bKlgoODU1qmVUuWLNHkyZOVJUsWw/bjx4/r0KFDpvcLS676eXclvXr10tGjR5U5c2ar2+TNm1d58+a12n7hwoVE+4iOjlarVq20fv16ValSxXAbLy8vNWjQQA0aNEhS3Ym5ffu2Xn/9dZvzJMd3332nXr16qXLlyobtefLk0fDhwzV8+PBk5x4+fLhWrVqlGjVq2FqmBUe8/46wc+dO1axZU7/++quKFy/+xO39/f3l7++v2rVr29Tvnj171LlzZ12+fDnFOfr376/bt2/r/fffl7u7e6Lbent7q3z58ipfvnyK+/uvHTt2qH379goNDTUlnzNjHHLecchVuOraySxRUVFq3bq1fvvtN9WtW9fqdv7+/urevbu6d++eon5+/PFHffjhhyna19XXIM7GFcbN2NhYdenSRUeOHJG/v7/hNu7u7qpTp84T/7bofw0YMEB//vlnsmpB8rDOgyM5es3jqOObY9v+XHGscuU1vrPPN+0174iPjzdl7uEKc7fHpcbxyprBNbnieGxPrvh5BwAAAAB78kztAgAAcAWBgYEKDAzUggULUruUJImOjlZAQIACAgJSuxTAZfj5+Vltu3PnjuMKSYE9e/Zoz549qV2GaQIDA/XVV1+ldhlIprt372r58uVavnx5apfiMh48eKCVK1dq5cqVqV1KmuLl5WX1Rqtr1651cDVIqfDwcJ09ezZV+r5//76WLVumZcuWpUr/ziA8PFw7d+7Uzp07E8QLFCigixcvJoh1795du3btcmR5SERQUJBWrFiR2mUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANKACRMmpHYJAAAAAAAAsLP69evL29s70W1CQkL01VdfKTw8PEV9/Prrr8qaNasaNWqU6HbNmjXT9u3bE93mzp07Wrp0qVauXKl69eqpRYsWyp07t0JDQ7VgwYIk1RMVFaWAgAD16NHD6jZZsmRJUi5X9+eff+rYsWOqUKGC1W0yZsyo1q1ba/ny5YbtL774YqJ9xMbGavHixUmuyVne40qVKildunSJbjNnzhyFhIQkqaaNGzdqz549un//fpK2B542zjgePS5DhgwqWrRootscO3YsWTld4XkDcH2uNue3xqxxOK28HoArccXPnbOsTdMSZ5v7Ost7bOb3D3z3ACSNs41Hj+P7BwCuyhXn/Y/juwcAAAAAAAAAAAAAAAAAAAAAAAAAAAD7OHfunOrWratVq1apSpUqpuX9/PPPNWLECNPyPe7MmTOqXbu2VqxYoRo1apie/9ChQ2rfvr2uXLliat5ly5bJzc1NP//8s9KnT29Kzps3b6pTp07asWOHKfnMMnLkSJ0/f15TpkxRxowZTc3922+/qUePHgoNDTU177/Cw8O1aNEi9e/f37B91qxZdukXxlz18+4q/v77b3Xs2FHLly+Xr6+v3fq5ffu2GjZsqLlz56pDhw526+fKlStq2rSprl69arc+jERHR6tVq1bavXu3ChcubErOmJgYvfnmm5oxY4Yp+Yw46v13hFOnTqlatWr6/PPPNWDAALm5udmtr9jYWH399df64IMP9PDhQ5vzjRw5Ur///rt+/vnnJ/59DTOEh4fr448/1ldffWVK/a6CcSj5HDEOuRJXXTuZ5e7du2ratKmmTZumfv36mZo7Li5On3/+uUaOHGlTHldegzgjVxg3r127pvr16+u3334z5RwaFxenOXPm2JwHT8Y6D46SGmseRxzfx48fNz0vLLnaWOXqa3xnn2/aY94xaNAg0+YerjAm7AqhAAEZFElEQVR3+6/UOl5ZM7gmVxuP7c3VPu8AAAAAYE/uqV0AAAAA4AyKFStmtc1VfgACAJDq1q2rTJkyWcTj4uIUEBCQChUBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgPOpW7fuE7eZOXOmwsPDbepn4cKFunnzZqLbFCxYUHnz5k1SvujoaG3evFnDhw/X119/rcWLFysqKirJ9Vy5ciXR9syZMyc5l6tbvHix4uLiEt2mefPmhq9JuXLlVLJkyUT33bRpk27cuJHsulL7PS5Xrlyi7efPn9eRI0eSXE98fLzu37+f5O2Bp5Gzjkf/Klu2rDw8PBLd5vjx48nO6+zPG4Drc9U5/+PMGofTyusBuBJX/tz9H3v3HWVldS4O+J3C0EGKiCKKioAKiIJiQTCiwQZGI5ZENHeZxIJ6vZYbgv7Ua1ATxagpyjVGvREVewHFGjQCFqQNiIoiSJE+1EHKMPP7I8tJjsAw5cycc4bnWcu13PV9z/nm2+5vO2dOqp9Na5t03Pum+hon8/zB2QOUXzquR99x/gBkqkze93/H2QMAAAAAAAAAAAAAAAAAQPVZtGhR9OzZM2699dYK/X2P7VmxYkWcccYZ8etf/zpJ2e3YwoULo1evXnHDDTdU+fOh39mwYUP86le/iiOPPHKnf7+ksp5++uk46qijKvS3U3fkmWeeiUMOOSTGjx9f9cSqwV//+tfo0qVLvPbaa0mZb/HixTFo0KA4/fTTY/Xq1UmZc0cefPDB7dZv2bIlRo4cWa2x2Vam3u+Z4q233oojjzwy3nvvvWqNs27dujjzzDNj4MCBMX/+/KTOXVJSEiNHjowjjjgiPv/886TOXV5Lly6Nnj17xiuvvFLlufLz8+PII4/c4VqUTDV1/WvC2rVr4/LLL4+ePXvGmDFjoqSkJKnzl5SUxFNPPRUHHXRQ/Pd//3cUFRUlbe4JEyZE586d44orroh58+Ylbd5/t3Xr1njuuefioIMOit/97ndJzT9TWIfKrybXoUySqc9OybJx48a4+OKLY8CAAfHVV18lZc45c+bESSedFDfccENS5svkZ5B0lAnr5ueffx5HHnlkjB07tkr5LF++PE4++eQqzUHFeM6jpqTimae6f76pOZm2VmX6M3667zeTve+4//77q5zTv8uEvdu/S9XPq2eGzJRp63F1y7T7HQAAoLpkpzoBAABIB2X9IsEXX3xRg5kAUBU7+iXWyZMnx8qVK2s4GwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgPTTpEmT2Geffcrs8+WXX8asWbOqHGvz5s3x2muv7bRf586dKzz39OnT4/33369MWjtUUlKS1PnS2aJFi+Ldd98ts0/dunWjf//+29SfffbZZY4rLCyMF198sSrpRURqrnGHDh3KbP/www+TmQ4Q6b8ede3atcz2hQsXxqpVqyo8b7q/biCz1ZY9f0Ry1uHa9H5ApqhN953zh6pL972v8wfYdaTzeuT8AchEtWXf7+wBAAAAAAAAAAAAAAAAAKB6FRUVxc033xzt2rWLu+++O5YvX16h8cuWLYtbb7019t9//3j55ZerKcttbdmyJW6//fbYb7/94rbbbouFCxdWap4FCxbETTfdFG3bto0777wztm7dmuRME02fPj169OgRF110UXz66acVGrtx48Z45pln4vDDD49zzjknVq5cWU1ZJsfcuXPjlFNOiSOOOCKefvrp2LBhQ4XnmDZtWlxyySXRrl27GDlyZDVkua0pU6bE1KlTt6l/5ZVXYsWKFTWSA4ky9X7PFLNnz47evXtHz54943//938jPz8/iouLqyXWs88+G/vtt18MHDgw3nrrrdi0aVOl51q1alU8/PDD0bNnzxg0aFAsWbIkiZlW3PLly+P000+PgQMHxvjx4ys8fsqUKXHeeedFt27dYtq0aclPcAdq8vrXhEmTJkX//v2jc+fOcccdd8RXX31Vpfm++OKLuPXWW+Oggw6K8847L7744oskZZpo48aN8ec//znat28fZ511Vvztb3+r8J5sez755JO47rrrok2bNnH22WfH/Pnzk5BtZrMO7Viq1qFMkqnPTsk0evTo6NixY/z0pz+NCRMmVOrvd06fPj0uueSS6NixY/z9739Pan6Z+gySztJ93SwoKIhTTz01TjjhhAr/7dLVq1fHXXfdFe3bt48333yzyrlQMZ7zqCmpeObx8117ZNq1rA3P+Om838yEfUe6793+Xap+Xj0zZKZMW49rQibd7wAAANUhq6ScJ0dZWVnVnQsAAKTM+++/H0cdddQ29fPnz4999903BRllvieffDLOO++8bepffPHFOPPMM1OQEbArmDZtWhx66KHb1P/mN7+Jm266KQUZQe2xzz77xNdff51Qd+yxx8bEiRNTlBEAAAAAAAAAAAAAAAAAAAAAAEDFVOYL/b7jb7UDO9K1a9fo2rVrRPxznfnqq6/igw8+qNKaAwAAAAAAAAAAAEDZsrKyokePHtGhQ4fS3/fOz8+P/Pz8FGfGhRdemOoUAAAq5OBDDo6cnJyYPXt2bNq4KdXp1KiePXvG5ZdfXmafBx98MCZMmJCUePXq1Yv77rsv6tWrt8M+M2bMiOHDhyclXllOOOGEuOiii3bYvnr16vjP//zPaondpk2buP3228vs88c//jE+/vjjaom/PY0bN4677ror6tevv8M+W7Zsieuvvz5WrVoVERHdu3ePq666qsx5n3jiiXj99deTmmt5VeUa16lTJx588MHIzs7e4fihQ4fGokWLqpznrqxjp46Rl5cXc76cExs2bEh1OqSJdF6Pfv/730eLFi122D527NgYNWpUpeZO59dN7bP/AftHw4YNY97cebFu3bpUp0M1q017/mSsw7Xp/SCz7Ntu32jSpEksWrgoCgoKUp1OjdrV7zvnD9uqbXtf5w/pba82e0WLFi1iyeIlsXz58lSnQ5pJ1/XI+QO1wR6t94hWrVrFsmXLYumSpalOhxpQW/b9zh6oDT7//PP48MMPU50GkAH8rXagOvhb7QAAAAAAAAAAAAA1z99qTy9+pxYqLjs7O3r37h29evWKQw89NNq1axdNmzaNRo0axYYNG2Lt2rWxYMGCmDZtWvzjH/+IcePGRXFxcarTjoiIHj16RK9evaJ79+6x7777RqtWraJhw4aRm5sbmzdvjrVr18bq1avj888/j08++STefvvtpK7PO1pbyvr8T+fOnePUU0+Nbt26RYcOHaJJkybRqFGj2LhxY6xZsyaWLFkS+fn58dFHH8Vrr70WhYWFScu3ptWrVy9OOumkOPLII6Nr167Rpk2b0p+tTZs2xZo1a6KgoCA++eSTmD59erzxxhvx9ddfpyTXt956K/r27ZtQN2DAgBg9enRK8mFbqb7fa7uGDRvGnnvuGbvttls0a9Ys6tSps91+3377bYwbN67ScRo0aBB9+vSJrl27RqdOneKAAw6Ixo0bR6NGjaJhw4ZRUlIS69evj3Xr1sXatWtjzpw5pXvrCRMmRFFRUaVjV7eOHTtGr1694uijj4727dsnvJfr1q2L1atXx6effhpTp06NV155Jb788stUp1yqpq5/Tdlnn33i6KOPjsMOOyz222+/2HfffaNx48bRoEGDqFevXhQVFcWaNWti9erVsWrVqvjkk09i6tSpMXXq1Jg9e3bK8s7Kyopu3brFIYccEgcffHB06tQpWrZsmXCPFBcXx9q1a2PNmjWl/x2dPn16TJkyJaZMmRIrV65MWf6ZwjqUnutQpsjkZ6dkad26dRx//PFx1FFHRfv27aNt27bRqFGjqF+/fhQXF5eur5999llMmTIl/v73v8enn35aY/ll0jNIpkj3dbNt27bRr1+/OP7442OvvfaK3XffPZo3bx5FRUWxevXqWLZsWUydOjUmTJgQY8eOjc2bN1drPlSM5zxqSiqeefx81x6Zdi0z/Rk/nfebmbDvSPe92/el4ufVM0PmyrT1uLpl2v0OAOw6srKy4ogjjogDDzzQ79MC5Vae3/HOrYE8AAAgrR100EFx1FFHbbft73//ew1nA0BltW7dOg499NDttr322ms1nA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEB62nfffXfaZ+bMmUmLt3Hjxvjiiy+iS5cuO+zTtm3bpMUry3HHHVdm+6pVq2okj3Sxbt26GDNmTAwcOHCHferUqRNnnHFGPProo5GVlRU//vGPy5xz6dKl8dZbbyU71XKryjVu1apVZGdn77B969atsWTJkm3qs7KyonXr1tGqVato0KBBRPzz537lypWxaNGi2Lp1azmzh11Xuq5He+21V7Ro0aLMPvn5+ZWeP11fN5D5asueP1nrcG15PyCT7Or3nfOHbdW2vW+qzh+6du3q7AGqKB3XI+cPQKaqDft+Zw8AAAAAAAAAAAAAAAAAADWvuLg43nnnnXjnnXdSnUqFffzxx/Hxxx+nOo0KmTlzZlI/65rONm7cGKNHj47Ro0enOpUytWnTJn7wgx8k1C1dujReffXVFGXE9mTi/Z5JCgsL48svv6z2OBs2bIixY8fG2LFjqz1WTfv888/j888/j7/+9a+pTqXCaur615T58+fH/Pnz46mnnkp1KhVSUlISU6dOjalTp6Y6lVrNOkRVZPKzU7IsWbIkRo0aFaNGjUp1KtuVKc8gmSTd180FCxbEQw89FA899FCqU6ESPOdRU1LxzOPnu/bItGuZ6c/46bzfzIR9R7rv3b4vFT+vnhkyV6atx9Ut0+53AACAqspNdQIAAFAe119/fSxatCieeOKJpM991VVX7bDN//wCyBw//OEPt1u/evXq+OCDD2o4GwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgPTUunXrMttXrlwZa9asSWrMuXPnRpcuXXbYvttuu0W9evVi48aNSY377/r27Rv7779/mX2++uqraoufrl5//fU44YQTokWLFjvs07t373j11Vejffv20aZNmzLnGzVqVGzdujXZaZZLVa9xs2bNyhy7fPnyhNd2wAEHxIknnhiHHnpoNGzYcLtjioqK4pNPPon33nsvPv744ygpKSkzBuzK0nE9Kuu/XRERmzZtitmzZ1cpRjq+biDz1ZY9f7LW4dryfkAm2ZXvO+cPO1Zb9r7pdv7g7AEqLt3WI+cPQKaqDft+Zw8AAAAAAAAAAAAAAAAAAEBNu/DCCyM7OzuhbuTIkf6WAwAAAAAAAAAAAKRY9s67AABA6uyxxx7xxhtvxJ133hkPPPBAdOzYManzH3vssfHLX/5yu23Lly+P0aNHJzUeANXnlFNO2W79W2+9FcXFxTWcDQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQHpq1apVme0LFy5MeswFCxbstM/O8qqKXr16xQUXXLDTflOnTq22HNLVli1b4umnny6zT05OTpx99tlx1llnldnvs88+iylTpiQzvXJLxjVu3LhxmWM3bNgQERFNmzaNX/7yl3HTTTfFMcccEw0bNtzhmNzc3Dj00EPjiiuuiGHDhsUBBxyw0xxhV5WO61GXLl12GqeoqKhKMdLxdQOZr7bs+ZO1DteW9wMyya563zl/KFtt2Pum4/mDsweouHRbj5w/AJmqNuz7nT0AAAAAAAAAAAAAAAAAAAA1KSsrK375y19uU//ggw+mIBsAAAAAAAAAAADg3+WmOgEAANiRU089NR599NHYfffdIyKiSZMm8eabb8YPfvCDmDNnTpXn33fffePxxx+P7Ozs7bb/6U9/ii1btlQ5DgDVLysrK0466aTtto0dO7aGs4Ha6dtvv43XXnstoW716tWpSQYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgEpr0KBBme3r169PeszyzFm/fv2kx23QoEGcf/750bt37532Xb58ecycOTPpOVREkyZNokWLFpUau3bt2tiyZUulxn7wwQfRr1+/2H///XfYp2fPnmXOUVJSEk888USl4ldFMq9x3bp1yxy/adOm2HPPPWPIkCGx2267VTTV2HvvvePGG2+Mp556Kl577bUKj4ddQTqtR3Xq1ImOHTuW2Sc/P7/KcSLS63UDtUNt2PMncx2uDe8HZJpd7b5z/lB+mbr3zZTzB2cPUH7psh45fwAyWabv+509AAAAAAAAAAAAAAAAAAAANe3000+Pdu3aJdT94x//iNmzZ6cmIQAAAAAAAAAAAKBUbqoTAACA7enbt2+88sor29S3bds2Pvroo/j5z38eL7zwQqXnP/bYY+P555+PVq1abbd96dKlcffdd1d6fgBq1hFHHBEtWrTYbtvrr79ew9lA7bR8+fI45ZRTUp0GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABVVLdu3TLbv/3226TH3LBhw0771KtXL2nxcnJy4oQTTogf/ehH0ahRo3KNeeKJJ6KkpCRpOVTGRRddVOmxt9xyS8ydO7fS45944om48cYbKz1+/Pjx8fXXX1d6fEVVxzXOzc0tc3zTpk3j17/+dTRt2rRCuf677OzsOP/88yMvLy9efvnlSs8DtVm6rEedOnWKvLy8MvvMmDGjynG+ky6vG6gdasOeP5nrcG14PyDT7Cr3nfOHysmkvW8mnj84e4DyS4f1yPkDkMkyfd/v7AEAAAAAAAAAAAAAAAAAAKhpN9988zZ19913XwoyAQAAAAAAAAAAAL6v7G+ZAwCAFBk3blxMmjQpjjjiiG3amjdvHs8//3y8++678Yc//CHGjh1bri/Py87Ojp49e8avfvWrOOOMM8rs+/Of/zwKCwsrnT8ANWvx4sVx2mmnbVO/ZcuWWLRoUQoyAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASE95eXlltm/atCnpMcszZ926dZMS6+ijj44f//jHsfvuu5d7zDvvvBNTpkxJSvxUWbZsWZXGf/HFFzFp0qQ44ogjKjx206ZN8eyzz1YpfkVU1zXOysoqs32vvfYqd7yd+fGPfxzffPNNfPzxx0mbE2qLdFmPunbtWmb78uXLY+nSpUmJFZE+rxuoHWrDnj+Z63BteD8g0+wK953zh8rLlL1vpp8/OHuAnUuH9cj5A5DJMn3f7+wBAAAAAAAAAAAAAAAAAACoSYMGDYru3bsn1H311VfxwgsvpCgjAAAAAAAAAAAA4N/lpjoBAADYnuLi4vjpT38aEydOjJYtW263T58+faJPnz6xZcuWmDx5csyePTsWLlwY69ati40bN0ZERLNmzaJFixax7777xnHHHRdNmzbdaezf/va3MWbMmKS+HgCq14IFC2LBggWpTgMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACDjlZSUZMSc39elS5c455xzYp999qnQuMmTJ8f//d//VVNWNWPDhg1RWFhY5XmefvrpOOywwyI3N7dC41555ZVYvXp1lePvTG27xhdddFF8+umnSbl2UNukw3rUpUuXMtvz8/OTEuffpcPrBnYNmbDnr8l1OBPeD6htMvm+q23PphWRrPOHiPTe+9ama+zsAXYu1euR8wegNkv3fb+zBwAAAAAAAAAAAACA5OjWrVu89957ERHxhz/8IW644YYUZwQAAADpp3379nHfffdtU3/rrbf67DAAAAAAAAAAAACkiYp9qxMAANSgL774Ik499dR48803o2nTpjvsV6dOnTjqqKPiqKOOqnLMBx54IH79619XeR4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4J+ysrKqbe799tsvzj333DjooIMqPPbtt9+Oxx57LEpKSqohs5qzbNmypM3z1ltvxcknn1zuMatWrYqxY8cmJf6OpOs1Li4ujvnz58eCBQuisLAw8vLyomXLlnHggQdG/fr1dzq+SZMmceqpp8YzzzyT9Nwg06V6PWrZsmXsueeeZfaZMWNGUmL9u1S/boCqSOaeP1XrcDJV5zMQsH3Vfd+l67NpTUrW+cN3c6Xb3jddr/G/nz9s2bLF2QMkWSrXI+cPABWXrH2/swcAAAAAAAAAAAAAgOTJzs6ORo0aRUREXl5eirMBAACA9HPkkUfGM888E82aNUuo//TTT+Oxxx5LUVYAAAAAAAAAAADA9+WmOgEAACjLpEmT4ogjjoiXXnqpUl/CXF5btmyJX//613H33XdXWwwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASLUtW7ZEXl7eDtvr1KmT9Jg5OTk77VNUVFShORs2bBjnnntu9O7dO7Kysio0trCwMB599NH46KOPKjQuXS1btixpc7300kvRq1evaNSoUbn6P/PMM7F58+akxf936XyNP/jgg3juuee2+97XqVMnevfuHQMHDoz69euXOU/fvn3jxRdfjC1btlRLnpDJUrkede7cucz2oqKi+PTTT5MS6/vSaR0GMlem7/mTvQ5n+vsBmag23Xfp/Gxa05J5/hCRPnvfdL7GOzp/cPYAyZWq9cj5A5DpMnnf7+wBAAAAAAAAAAAAAAAAAABIpqysrKhTp05kZWVFw4YNo1WrVnH44YfHwIEDo3///tv9fPBll10WxcXFKcgWAAAAAAAAAAAA2J7sVCcAAAA788UXX8Thhx8e/+///b8oLCxM+vzjx4+Pnj17xt133530uQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgnWzatKnM9gYNGiQ9Zr169XbaZ8uWLeWeb7/99ovbbrst+vTpE1lZWRXK5YMPPoihQ4fGRx99VKFx6WzZsmVJm2vDhg3x4osvlqvvvHnzYsKECUmL/e/S+Ro/9dRT8cADD+zwfd+yZUu8/fbb8T//8z+xdu3aMueqX79+HHLIIdWRJmS8VK5HXbt2LbP9yy+/jI0bNyYt3r9Ll3UYyGyZvudP9jqc6e8HZKLact+l87NpKiTz/CEiPfa+6XyNyzp/cPYAyZWq9cj5A5DpMnnf7+wBAAAAAAAAAAAAAAAAAABIpoEDB8amTZti48aNsXLlyvj000/j8ccfjx/96EeRk5Oz3THvvvtuDWcJAAAAAAAAAAAAlCU71QkAAEB5bNy4MYYNGxbt2rWLa6+9NmbNmlWl+TZt2hQvvvhinHTSSXHcccfF1KlTk5Qp3/nmm2/is88+2+afRYsWpTo1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgF3Wxo0by2xv0KBBpebt27dvXHTRRdtta9KkyU7Hr1+/vlxxunTpEjfccEM0a9asQvnNnTs3br/99njggQdi9erVFRqb7pYuXZrU+f7+97/HkiVLdtrviSeeSGrc76TqGhcVFe20z4cffhivvvpqueZbvHhxPPDAAzvt16FDh3LNB7uiVKxHOTk5cfDBB5fZJz8/P2nxtifV6zCQ+TJ5z18d63Amvx+QqWrDfef8YVvJPn+ISO3etzacPzh7gOSp6fXI+QNQG2Tyvt/ZAwAAAAAAAAAAAAAAAAAAkErjxo1LdQoAAAAAAAAAAADA9+SmOgEAAKiIFStWxO9///v4/e9/H3vvvXccf/zxcdhhh8UBBxwQ++23XzRp0iQaNmwY9evXj4iITZs2xbfffhvLli2LBQsWRH5+fnz00Ucxbty4KCwsTPGrqd2uvfbauPbaa1OdBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/ZuXKlbHXXnvtsL1169YVnvPMM8+MH/3oRxERsX79+njuuecqPOfq1at32qd9+/Zx1VVXRZ06dcqd27Jly+LZZ5+NDz/8sNxjUuWRRx6JadOmVXhcYWFhUvPYunVr5Ofnl3ndNmzYEJ9//nlS40ak9hoXFRXttM+LL75YoTlnzZoVs2fPjg4dOuywT9u2bSs0J+xKUrEeHXDAAVG/fv0y+8yYMSNp8bYnleswUDtk8p6/OtbhTH4/IFNl+n3n/GH7kn3+EJG6vW9tOn9w9gDJUdPrkfMHoDbI5H2/swcAAAAAAAAAAAAAgMo77LDD4uyzz46uXbvG/vvvH+3atSttu+KKK6J///4xZ86cmDhxYowdOzamTJlSo/l16dIljj766NLyrFmzYvz48ZWer0+fPtGxY8cy+0yfPj2lnzFt0aJFDBw4MPr27RudO3eONm3aRMOGDSPin58PXbRoUcyYMSPefvvtePbZZ2PlypVJiduhQ4c488wzo0+fPnHIIYdEy5Yto0GDBlFYWBjLly+PxYsXxz/+8Y947bXX4h//+EcUFxcnJW5ExP777x/nnHNO9O7dOzp16hR77LFH1K9fP4qKimL9+vXx9ddfR35+fowdOzZGjx5dLZ+TBQAAqKxXX301Bg4cmOo0AAAAAAAAAAAAgO/JTXUCAABQWQsXLoyRI0fGyJEjU50KAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQpprvHdHlh6nOgl3Juw+nOgMAAACAsi1evDi6dOmyw/Y999wz6tWrFxs3btzpXFlZWTFo0KDo27dvad2AAQNi7dq18eabb5bWtWvXrsx5Nm3aFKtWrSqzT/369ePyyy+PvLy8neYVEbF27dp46aWXYty4cbF169ZyjUm19evXx+rVq1OdRkRElJSUVKm9MlJ9jdetW1dm+6pVq+Kbb76p8LwzZ86MDh067LC9UaNGFZ4TdiU1vR517dq1zPY1a9bE/Pnzkxpze1KxDgO1R6bu+SOqZx3O5PcDMlUm33epfjatCel0/hBR83vfVF/j6jh/cPYAyVGT65HzB6A2yOR9f1mcPQAAAAAAAAAAAAAAbCs3NzcuvfTSuPrqq+OAAw7YYb969epFx44do2PHjnHqqafGsGHDIj8/P2655ZZ44YUXqj3Pli1bxtixY6NNmzaldSNGjIjx48dXes6hQ4fGD39Y9h+6Hz58eHz44YeVjlFZzZo1i9tuuy0uvvjiHX5usnHjxtGpU6fo1KlTDBw4MO6777546KGH4sYbb6z0500PPvjguOuuu+KUU06JrKysbdobNmwYDRs2jHbt2sXRRx8dv/rVr+Kzzz6LoUOHVvnnoH379jF8+PA444wztttep06daNasWTRr1iy6desWF154YRQUFMQdd9wRv//976O4uLhK8QEAAKpi6dKlccstt8SIESNSnQoAAAAAAAAAAACwHbmpTgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKrLbntG9Dwn1VmwK3n34VRnAAAAAFC2RYsWldmenZ0dHTp0iPz8/DL75eTkxKWXXhpHHnnkNm0//elPY/369fH+++9HVlZWdO7cucy5FixYsNO8zznnnGjRosVO+xUVFcWrr74ar7zySmzcuHGn/Ukfqb7Ga9asKbN91apVlZq3oKCgzPZ69epVal6genTp0qXM9hkzZtRQJgCVl6l7/ojqWYcz+f2ATJXJ912qn02pfqm+xtVx/uDsATKP8wegNsjkfX9ZnD0AAAAAAAAAAAAAACRq3759PPPMM9GtW7dKje/atWs8//zz8corr8SgQYMq/Xd8ymPkyJHRpk2bpM554IEHJnW+ZDn66KPj+eefj9atW1doXN26dWPw4MFx5plnxo9+9KOYNGlShcZfd911cccdd0Rubm6FxnXq1Cmef/75GDVqVFx00UWxefPmCo2PiDj//PPjoYceigYNGlRoXPPmzeOuu+6K0047LU4//fQoLCyscGwAAICKKC4ujm+//TYKCgpi3rx5MXny5Hjrrbfi9ddfj6KiolSnBwAAAAAAAAAAAOxAxT41BQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDG+vTTT3fa5/jjj4/8/PwdttetWzf+8z//Mw455JDttmdlZcUvfvGLKCwsjDp16kTDhg3LjDd79uwy21u2bBm9e/fead6LFy+OP//5z7FgwYKd9iW9pMM1Xrp0aZntxcXFlZp3Z+MqOy+QfE2aNIl99923zD5l/fcRIF1k4p4/ovrW4Ux9PyCTZep9lw7PplSvdLjG1XH+4OwBMovzB6C2yNR9f5MmTcpsd/YAAAAAAAAAAAAAAPAvBx98cLz77rvRsmXLhPqSkpKYOXNmTJs2LUpKSuLCCy+MiIjp06fHihUrokePHtG0adOEMaeddlq8//770bt371i2bFnScx0yZEj069cvqXPm5ubGPvvsk9Q5k6FPnz7x2muvRb169bZpmzdvXsyaNSuWLFkSERGtW7eOgw8+ONq1a5fQb6+99op33nknTjzxxHj//ffLFfeee+6Jq6++epv6VatWxbvvvhuff/55FBQURJ06daJVq1bRo0ePOPLIIyM3N7e073nnnRetW7eOfv36xebNm8v9mn/2s5/Fww8/HFlZWQn1hYWFMW7cuJg/f36sXLkycnNzY/fdd4+uXbtGjx49Ijs7u7Tv8ccfH6NHj46+fftGSUlJuWMDAEA6+f6emPTx9NNPx9NPP53qNAAAAAAAAAAAAIAqyN15FwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABqg6VLl8aKFSuiZcuWO+xz2GGHxR577BFLly7dbnt2dnY0bty4zDg5OTlxxRVXREFBwU5zmjlzZpntJ5xwQuTm5pbZZ/Xq1fHb3/42Vq9evdN4pJ90uMYbNmyI1atXx2677bbd9kaNGlVq3p3dK99++22l5gWSr3PnzpGVlbXD9uLi4vjkk09qMCOAysnEPX9E9a3Dmfp+QCbL1PsuHZ5NqV7pcI2r4/zB2QNkFucPQG2Rqfv+zp0777DN2QMAAAAAAAAAAAAAwL/Ur18/Ro8enfC70kVFRfHHP/4x7r333pg/f35ERBx++OFx4YUXRkTEm2++Gddff31ERPTt2zduvvnmOO6440rHd+zYMV599dU46qijoqioKGm59urVK4YNG5a0+b6zdevW2Guvvbapv+WWW+Kyyy5Lerzy2GOPPeKFF16IevXqJdSPHj06brnllpgyZcp2xx1++OHxP//zP3H66aeX1jVo0CBeeuml6NSp005/V/3yyy+Pq6++OqFuyZIlMXTo0Hjsscd2eD333HPPGDp0aAwePLj0c1XHH398DB8+PK666qqdvdyI+OdnAR588MGEz2UVFBTE9ddfH0888URs3Lhxu+P23nvv+O1vfxs//elPS+t+8IMfxDXXXBN33313uWIDAAAAAAAAAAAAAAAAu47sVCcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQM2ZNGlSme3Z2dlxySWXRHZ29nbbv/322xg+fHgsW7aszHnq1q0be+65Z5l91qxZE59++mmZfY488sgy2yMiHn300Vi9evVO+5Ge0uUaf/nllztsa9WqVTRu3LjCc3bo0KHMdj+3kD66dOlSZvu8efNi/fr1NZQNQNVk2p4/onrX4Ux8PyDTZeJ9ly7PplSfdLnGyT5/cPYAmcX5A1CbZOK+v6x12NkDAAAAAAAAAAAAAMC/XHvttbH//vuXltetWxcnnHBCXHPNNTF//vydjn/77bejd+/eMXjw4CgpKSmt7969e9x0001Jy7Nly5YxatSoyMnJSdqc3ykpKYlly5Zt809hYWHSY5XX/fffH82aNUvI8dJLL40BAwbElClTdjhuypQp0b9//xg8eHBC/e677x733ntvmTHbtm0bw4cPT6ibNGlSdOvWLR555JEoKira4djFixfHlVdeGf3794+NGzeW1l955ZVx4oknlhn3Ow8++GDUqVOntPz555/HwQcfHA8//HDCnN+3cOHCuOCCC+LOO+9MqB86dGg0bNiwXLEBAAAAAAAAAAAAAACAXcf2v1UEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgFrp7bffjuLi4jL7HHDAAfGzn/0ssrKyttu+Zs2auOuuu2Lt2rVVymX8+PFl5tKiRYvYfffdy5xjyZIlMXXq1CrlQeqk0zWeNWvWDtuys7PjpJNOqtB8rVq1ikMPPbTMPl9//XWF5gSqT+fOnctsnzFjRg1lAlB1mbTn/051rsOZ+H5Apsu0+y6dnk2pHul0jZN5/uDsATKP8wegNsm0fX9E2euwswcAAAAAAAAAAAAAgH/5xS9+kVC+8sor47333qvwPPfff39cfvnlCXXXXHPNTj/zV14jR46MNm3alJbvueeepMybjk488cQ466yzEuqGDh0a//u//1vuOe6///646aabEuoGDRoURx999A7H3HDDDVG/fv3S8vz58+PUU0+NpUuXljvuK6+8EhdffPE28+7M+eefn5BbQUFB/PCHP6xQ7F//+tcxbdq0WLVqVdx///1x8sknR2FhYbnHAwAAAAAAAAAAAAAAALuG7FQnAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDNWb58eUydOnWn/fr06RNXX311NGnSZLvty5Yti7vuuiu+/fbbSuWxZcuWeP3118vss+++++50nk8//bRS8UkP6XSNJ0+eHCUlJTtsP/XUU6NTp07lmisvLy8uu+yyyM3NLbPfzJkzK5QjUD3atWu3w//efWfGjBk1lA1A1WXSnj+i+tfhTHs/oDbItPsunZ5NqR7pdI2Tdf7g7AEyj/MHoLbJtH3/ztZhZw8AAAAAAAAAAAAAAP/Utm3b2GeffUrLy5cvj8cee6zS840YMSI++OCDiIiYNGlS/PznP4+CgoIq5zlkyJDo169fafnuu++OF198scrzpqtLL700oTx9+vT43e9+V+F5brvttm0+e3jJJZdst29eXl6cf/75CXXXX399rFixosJxn3jiifj73/9eWj7++OPj0EMPLXPML37xi4TyrbfeGvPnz69Q3OLi4jj99NOjdevWMXjw4Jg0aVKFxgMAAAAAAAAAAAAAAAC7hrK/EQ4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAWmfUqFHRtWvXqFOnTpn9unXrFnfddVe88cYb8eGHH8bChQsT2ufPnx/33ntvXHfddTud6/tee+21WLNmTZl9mjVrttN56tWrF0ceeWSFYu/I1KlTY8uWLUmZi/JJp2u8evXqyM/Pj0MPPXS77XXq1Ilrr702nnzyyRg3blyUlJRst9/ee+8dl1xySeyzzz5l5rJs2bKYO3duxV4AUC26dOlSZvuGDRtizpw5NZQNQHJkyp4/ombW4Ux6P6C2yKT7Lp2eTake6XSNk3H+4OwBMpPzB6A2yqR9f1nrsLMHAAAAAAAAAAAAAIB/adOmTUJ55syZUVxcXKU5L7nkkmjUqFFMnDixSvN8p1evXjFs2LDS8gcffBBDhgyJY445Jinzp5vdd989BgwYkFB3ww037PBvIJWluLg4brjhhnjppZdK6wYOHBhXXXVVrF27NqHvUUcdFU2aNCktL1++PJ555pkKx/zOn//85zjhhBNKy/3794/p06dvt2/btm3j+OOPT4h9//33VyruokWLKjUOAAAAAAAAAAAAAAAA2HXkpjoBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGrWsmXLYvTo0XHWWWfttG+9evViwIABMWDAgFi1alUsX7481q1bF1u2bIm6detGixYtIisrq0LxlyxZEi+//PJO+zVo0GCnfY4++ug4+uijKxR/R6688srYsmVLUuaifNLtGo8ZMyYOPfTQHbbn5eXFRRddFKeeempMmTIl5s+fH4WFhZGXlxctWrSIQw45JA455JBy3ROvvPJKpV4DkHxdu3Yts/2TTz6J4uLiGsoGIDkyZc8fUTPrcCa9H1BbZNJ9l27PpiRful3jypw/bNmyxdkDZDjnD0BtlEn7/rLWYWcPAAAAAAAAAAAAAAD/UqdOnYTyxo0bqzxnfn5+lef4TsuWLWPUqFGRk5MTEREFBQVxzjnnRFFRUdJipJsf/vCHCddl5cqV8dprr1V6vldffTUKCgqiefPmEfHPz2H+4Ac/iJdeeimh3/d/F3/cuHFRUlJS6bh///vfE8q9evXaYd/TTz894XfrX3rpJZ/PBQAAAAAAAAAAAAAAAKpNbqoTAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKDmvfzyy9G+ffvo2rVrucc0a9YsmjVrVqW4JSUl8ec//zk2b968077Z2dlVikX6S7drPHv27Jg8eXJ07969zH6777579OvXr9JxFixYEO+9916lxwPJU79+/TjggAPK7JOfn19D2QAkVybs+WtyHc6E9wNqm0y579Lt2ZTkS7drXBPnD84eIL04fwBqs0zY9+9sHXb2AAAAAAAAAAAAAADwL6tWrUoot2rVKkWZbN/IkSOjTZs2EfHP36e+8MILY8GCBSnOqnodccQRCeUxY8bE1q1bKz1fUVFRjBkzJi688MLSuh49esRLL72U0O/7176q7/Pq1atjw4YN0aBBg4iIOPLII3fY9/DDD08ojx49ukqxAQAAAAAAAAAAAAAAAMqSXt92BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECNKCkpiQceeCC+/vrrGo2blZUVxx57bI3GhIp49NFHY/Xq1dU2/+bNm2PEiBGxdevWaosBlN/BBx8cOTk5ZfaZOXNmDWUDkFyZsOevyXU4E94PqG3cd7Bj1Xn+4OwB0o/zB6A2y4R9/87WYWcPAAAAAAAAAAAAAAD/smjRoigpKSktH3roodG8efMUZvQvQ4YMiX79+pWW77777njllVdSmFHN6NGjR0L5448/rvKckydPLjNGRET9+vUTyuvXr69y3HXr1pX+e7NmzSI3N3e7/bp165ZQnj59epVjAwAAAAAAAAAAAAAAAOxIdqoTAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA1NmzYELfffnt89tlnNRr35JNPjtNOO61GY0J5rV27Nu6999749ttvkz731q1b409/+lMsXLgw6XMDldO1a9cy2xcuXBgFBQU1lA1A8qX7nr+m1+F0fz+gNnLfwfZV1/mDswdIT84fgNou3ff9Za3Dzh4AAAAAAAAAAAAAABKtWrUqPvnkk9Jybm5u3HrrrSnM6J969eoVw4YNKy2///77MWTIkBRmVHMOPPDAhPLMmTOrPOeMGTPKjBERsXnz5oRyo0aNqhy3cePGCeXddtttu/0OOuig0n/fsGFDfP3119v0adCgQfTq1St+9rOfxVVXXRVXX311XHzxxXHiiSdGy5Ytq5wrAAAAAAAAAAAAAAAAsOvITnUCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKTOxo0b484774zRo0dHcXFxjcU955xzonfv3jUWDypi7ty58bvf/S5WrVqVtDkLCwtj+PDhMX369KTNCVRdly5dymyfOXNmDWUCUH3Sec+finU4nd8PqK3cd7B9yT5/cPYA6cv5A7ArSOd9f1nrsLMHAAAAAAAAAAAAAIBtPfroownlwYMHx29+85vIyclJST4tW7aMUaNGlcYvKCiIc845J7Zu3ZqSfGpa06ZNE8qLFi2q8pzffPNNmTEiYpvPP+69995VirnbbrtFgwYNtqn7vpycnGjYsGFpefHixQntJ554YowZMyZWrVoV7733XjzyyCNx3333xT333BMPPfRQvPnmm7Fs2bL44IMP4qKLLorc3Nwq5Q0AAAAAAAAAAAAAAADUftmpTgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA1Nq6dWs8++yzceutt8aMGTNqLO5//Md/RPfu3WssHlTE3Llz48Ybb4zx48dHSUlJleaaMmVK3HjjjTFr1qwkZQckw5577hktWrQos09+fn4NZQNQvdJxz5/KdTgd3w+o7dx3sH3JOn9w9gDpy/kDsCtJx33/ztZhZw8AAAAAAAAAAAAAANsaMWJEzJ07N6HuxhtvjE8++SSuuuqqOOCAA2o0n5EjR0abNm0iIqKkpCQGDRoUCxcurNEcUiUvLy/q1q2bULd+/foqz7tu3bqEctOmTbfp8+mnnyaUjz/++CrFPOGEE7apy87O3qauSZMmCeXvXm/z5s3j5ZdfjjfffDNOO+20yMvL22GsrKys6NmzZzz66KMxderUOPzww6uUOwAAAAAAAAAAAAAAAFC7bftJJwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB2SXPnzo3hw4fHLbfcEu+8806sXbu2wnMUFxfHZ599Fo888kjMnTu3zL7Z2dlx2WWXRadOnSqbMlSr9evXx1/+8pf49a9/HW+//XaF7olNmzbFRx99FLfeemvcd999UVBQUI2ZApXRtWvXMts3b94cs2fPrqFsAGpGOu3502EdTqf3A3YV7jvYVmXPH5w9QGZIh30vQE1Lp31/WeuwswcAAAAAAAAAAAAAgO0rLCyMs846K1avXp1Q37Fjx7jvvvviyy+/jJUrV8YjjzxS2rbnnntG69atk57LkCFDol+/fqXlu+66K1599dWkx0lXTZo02aZu/fr1VZ533bp1CeU6depEvXr1EuomTJgQRUVFpeU99tgjzjzzzErHHDx4cLn6NW3aNKFcWFgYrVu3jg8//DD69+9f4bidO3eO8ePHx4ABAyo8FgAAAAAAAAAAAAAAANg1ZJWUlJSUq2NWVnXnAgAAAAAAAAAAAAAAAAAAAAAAAAAAAABQLcr5Z9m3y99qB3aka9eu0bVr14j45zrz1VdfxQcffFClNQcAAAAAAAAAgOTb/4iIs3+T6izYldx5cqozAKjdsrKyokePHtGhQ4fS3/fOz8+P/Pz8FGfGhRdemOoUAAAq5OBDDo6cnJyYPXt2bNq4KdXppLWsrKxo165dtG3bNvbee+9o2bJl1KtXL+rXrx85OTmxadOm2LRpU6xatSqWLVsW8+bNiy+//DK+/fbbiIho3Lhx3HDDDbHnnnuWGWfdunVx7bXXxqZNrgfpLSsrK/bee+/Yb7/9olWrVtGsWbOoW7du5ObmxqZNm+Lbb7+NJUuWxMKFC+Pzzz+PLVu2pDrltNKxU8fIy8uLOV/OiQ0bNqQ6HYjrrrsuunTpssP2/Pz8uPvuu2swI6ge+x+wfzRs2DDmzZ0X69atS3U6pJlU7vnTcR32DESy7Ntu32jSpEksWrgoCgoKUp1OWnPfwba2d/7QsGFDZw/lsFebvaJFixaxZPGSWL58earTgYhIz30vJNserfeIVq1axbJly2LpkqWpToc0lK7nD84eqA0+//zz+PDDD1OdBpAB/K12oDr4W+0AAAAAAAAAALVfhw4d4plnnin9PZHyWLt2bUyZMiU+/PDDePnll2PixImVjt+rV6945513IicnJyIiJk6cGL17946tW7dut3/v3r3j3XffLS2PGDEiLrvsskrH35677rorrrvuutLy8OHD4/rrr09qjH/XqlWrWLo08fMaDRs2rPLf72nQoEEUFhbudN4xY8bEaaedVlr+6quvonv37rF69eoKxTvvvPPiySef3Ka+Y8eOMXv27IS6Dh06xOeff15aHj9+fNSpUyd69uwZERFFRUXx5JNPxvPPPx8ff/xxLF++PDZv3hzNmzePAw88ME466aS47LLLtvnd+02bNsUJJ5xQpZ9JgHTgb7WnF79TCwAAAAAAAAAAAFCzsrKy4ogjjogDDzzQ79MC5Vae3/HOrYE8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMhAJSUlMXfu3Jg7d26lxq9bty7uvPPOuOmmm6JZs2bb7bNx48a4//77Y9OmTVVJFWpESUlJLFiwIBYsWJDqVIAqqlOnTnTs2LHMPvn5+TWUDUDqpGrPn67rsGcgqHnuO9iW8weoPdJ13wtQ09L1/MHZAwAAAAAAAAAAAABA2WbPnh3dunWLQYMGxSWXXBLHHHPMTsc0adIkjj/++Dj++OPjV7/6VXz11Vdx8803x8iRIysUu2XLljFq1KjIycmJiIiVK1fGueeeG1u3bq3Ua6FybrvttjjttNNKy/vvv3+MHj06zjjjjCgoKCjXHP369YtHHnmk0jkcc8wxkZ2dHRERkydPjnPPPTfmzJmzTb+VK1fGypUr44MPPojf/e53cdttt8V1111X2l63bt0YOXJkdO7cOTZs2FDpfAAAAAAAAAAAAAAAAIDaJzvVCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQexUUFMSdd94Z69ev36Zt7dq1cccdd8SsWbNSkBkAu7JOnTpFXl5emX1mzJhRQ9kAZLbK7Plr8zrsGQhqnvsOgHRVm/e9ADWtOs4fMnUN9gwEAAAAAAAAAAAAANSkkpKS+Nvf/hbHHnts7L333nH22WfHXXfdFa+//nosWbJkp+P333//eOyxx+KNN96IJk2alDvuyJEjo02bNqU5DBo0KBYuXFjp10HlvP/++/GXv/wloa5Xr14xderUOOeccyIrK2uHY1u2bBnDhw+PV199NerVqxdbtmyJb775psI5ZGdnR0TExIkT49hjj405c+bsdMzmzZvj+uuvjyuvvDKhfr/99ovLLruswjkAAAAAAAAAAAAAAAAAtVt2qhMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoHb75ptv4ve//31s2rSptG7FihUxbNiwmDdvXuoSA2CX1aVLlzLbly9fHkuWLKmhbAAyX0X3/LV9HfYMBDXPfQdAOqrt+16AmpbM84dMX4M9AwEAAAAAAAAAAAAAqbBo0aJ47rnn4r//+7/j5JNPjtNOO620bdy4cTF8+PB44403Ys2aNduMPemkk+Ltt9+OvLy8ncYZMmRI9OvXr7R85513xtixY5PzImqBrKysGp3jyiuvjAkTJiTU7bPPPvHUU0/FokWL4rHHHosbb7wxLr/88rj66qvjjjvuiLfeeisWLFgQ1157bWRnZ0fEP6/rF198kTBPSUlJuXJYt25dnHnmmQm/R18ef/rTn+LJJ59MqLviiisqNAcAAAAAAAAAAAAAAABQ+2WnOgEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAar85c+bEH/7whygqKopFixbFb37zm1i6dGmq0wJgF9WlS5cy22fMmFFDmQDUHhXZ8+8K67BnIKh57jsA0s2usO8FqGnJOn+oDWuwZyAAAAAAAAAAAAAAIJ1Mnjw5rr/++ujXr1+0bNky+vfvH5MmTUro06NHj7j99tvLnKdXr14xbNiw0vKECRPihhtuqJacM8GmTZu2qcvLy6vyvPXq1StXrO/q+/XrFy+//PI2bXvuuWdccMEF8Zvf/Cb+/Oc/xz333BNDhgyJvn37lsYoKSmJoUOHxu9///to0KBBwvj169eXK98//vGPsWzZsnL1/b6hQ4dGSUlJabldu3bRuXPnSs0FAAAAAAAAAAAAAAAA1E7ZqU4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAdnXdunWLdevWxbp16+K2225LdToAAAAAAABQbWbOnBn33ntv3HbbbbF69epUpwPALqpFixax1157ldlnxowZNZQNQO1Snj3/rrQOewaCmue+AyBd7Er7XoCalozzh9qyBnsGAgAAAAAAAAAAAADSUVFRUYwZMyaOOuqoGDFiRELb4MGDo1WrVtsd16JFixg1alTk5ORERMSKFSvi3HPPja1bt1Z7zulq7dq1UVJSklDXuHHjKs/7/TkKCwvLfJ8LCwvjjDPOiIsuuijmz59f7jjTpk2LPn36xB133BEREY0aNUpoX7NmTbnmeeaZZ8od8/vmzZsXkydPTqjr3r17pecDAAAAAAAAAAAAAAAAap/sVCcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAu7rs7Oxo1KhRNGrUKPLy8lKdDgAAAAAAAFSrGTNmRGFhYarTAGAX1qVLlzLbi4qKYtasWTWUDUDts7M9/662DnsGgprnvgMgHexq+16AmlaV84fatgZ7BgIAAAAAAAAAAAAA0lVxcXEMHjw4Jk+eXFpXr169OOuss7bb//HHH482bdpERERJSUkMGjQoFi1aVCO5pquSkpJYv359Ql3Tpk2rPO/351i9enW5xv3tb3+L/fffPwYMGBB//etfY+rUqbFq1arYunVrbNmyJVasWBEffvhh3HfffdG7d+847LDD4r333ttu3OLi4tiwYcM2MTZt2pRQLi4ujvz8/Aq8um1NmTIlobz33ntXaT4AAAAAAAAAAAAAAACgdslNdQIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1ZdOmTfHWW2/tsL2goCA2btxYgxkB7FqswwAA7ArsewFSq6x12BoMAAAAAAAAAAAAAFBziouL4957743HHnustK5Pnz4xYsSIhH5DhgyJfv36lZZff/312LBhQ/Tu3bvcsbp165ZQ3muvvbYZn5+fH6tXry7/C0gDK1asiMaNG5eWDzzwwJgxY0aV5jzwwAMTyitXriz32K1bt8bo0aNj9OjRFYpZv3792HPPPUvLS5cu3W6/VatWbVMuLi6uUKzvW758eUK5SZMmVZoPAAAAAAAAAAAAAAAAqF1yU50AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABATXn//ffj/fffT3UaALss6zAAALsC+16A1LIOAwAAAAAAAAAAAACkj4kTJyaU99577236DBs2LKF88sknx8knn1yluAMGDIgBAwYk1B122GExbdq0Ks1b06ZNmxb77bdfablr167x/PPPV2nOrl27bhOjunXq1CmysrJ2GnPt2rWxdevWyMnJiYiI4uLiKsdOxhwAAAAAAAAAAAAAAABA7ZWd6gQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgNplxYoVCeXmzZtv0ycnJ6dGcpk7d26NxEmmSZMmJZT79OlT5Tm/P8f3Y1SHY445JqE8derUHfadM2dO6b83a9asyrFbtmyZUF69enWV5wQAAAAAAAAAAAAAAABqj9xUJwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC7msMOOyzOPvvs6Nq1a+y///7Rrl270rYrrrgi+vfvH3PmzImJEyfG2LFjY8qUKTWaX5cuXeLoo48uLc+aNSvGjx9fa+NGRLRo0SIGDhwYffv2jc6dO0ebNm2iYcOGERFRWFgYixYtihkzZsTbb78dzz77bKxcuTJpsffff/8455xzonfv3tGpU6fYY489on79+lFUVBTr16+Pr7/+OvLz82Ps2LExevToKCwsrHLMdu3axZlnnhm9evWKgw8+OPbYY49o3Lhx5OTkxIYNG2Lx4sUxa9asGDduXDz11FOxePHiJLxSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0t2JJ54YW7ZsiXfffbfKc9WtWzehvHHjxirPWRkFBQWxZs2alMSuig8++CCh3Lt372jVqlUsW7asUvPtueee0atXr4S6Dz/8sNL5lddZZ52VUH7//fd32HfChAnRoUOHiIjIzc2Njh07xueff17p2AcffHBCed68eZWeCwAAAAAAAAAAAAAAAKh9clOdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOwKcnNz49JLL42rr746DjjggB32q1evXnTs2DE6duwYp556agwbNizy8/PjlltuiRdeeKHa82zZsmWMHTs22rRpU1o3YsSIGD9+fK2M26xZs7jtttvi4osvjry8vO32ady4cXTq1Ck6deoUAwcOjPvuuy8eeuihuPHGG2P16tWVjt2+ffsYPnx4nHHGGdttr1OnTjRr1iyaNWsW3bp1iwsvvDAKCgrijjvuiN///vdRXFxc4ZgdOnSIO+64I84888zIysrabp+GDRtG+/bto3379jFgwIAYPnx4/O1vf4shQ4bEsmXLKhwTAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA9HfcccfFbbfdFscdd1xMnTo1unfvHiUlJVWa88ADD0woL168eJs+HTt2rFKMiIgjjzwyHnvssdLyU089FTfddFNpecuWLVWOkQrvvPNOLFiwINq2bRsREdnZ2TF48OC4+eabKzXfFVdcEdnZ2aXl2bNnx6RJk5KS647st99+0bt379LyypUr4/XXX99h/3fffTf+4z/+o7T8ox/9KH73u99VKnaLFi3i2GOPTaj76KOPKjUXAAAAAAAAAAAAAAAAUDtl77wLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUBXt27ePSZMmxR//+Mc44IADKjy+a9eu8fzzz8eYMWOiWbNm1ZDhv4wcOTLatGlTrTHSJe7RRx8ds2bNissuuyzy8vLKPa5u3boxePDg+OSTT+KII46oVOzzzz8/pk+fHmeccUaFxjVv3jzuuuuuePvtt6Nhw4YVGnvBBRfE1KlT46yzzoqsrKxyj8vJyYn/+I//iBkzZsTRRx9doZgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACkv7y8vHjuuefiuOOOi4iIww47LP7rv/6ryvP+5Cc/SShPmzZtmz6zZ8+u8j/z589PmHPVqlUJ7XPnzq3ya0mFkpKSeOSRRxLqrrvuuth7770rPNc+++wT11xzTULdX/7yl52Oq1evXvzkJz+Jiy66qMIxIyJuv/32yM3NLS0/+eSTsWXLlh32f/bZZ2PNmjWl5WuvvTYaN25cqdg33nhjQuxp06bFnDlzKjUXAAAAAAAAAAAAAAAAUDvl7rwLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUFkHH3xwvPvuu9GyZcuE+pKSkpg5c2ZMmzYtSkpK4sILL4yIiOnTp8eKFSuiR48e0bRp04Qxp512Wrz//vvRu3fvWLZsWdJzHTJkSPTr1y/p86Zj3D59+sRrr70W9erV26Zt3rx5MWvWrFiyZElERLRu3ToOPvjgaNeuXUK/vfbaK95555048cQT4/333y937J/97Gfx8MMPR1ZWVkJ9YWFhjBs3LubPnx8rV66M3Nzc2H333aNr167Ro0ePyM7OLu17/PHHx+jRo6Nv375RUlKy05iDBg2K//u//9sm5tq1a2PixInxxRdfxNq1ayMionnz5tGtW7c48sgjIycnp7Rvq1at4s0334xjjjkm8vPzy/16AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASG+bN2+O4cOHx+9+97vSujvvvDO++uqrePHFFys1Z69eveKSSy5JqHv++eerkmatUbdu3YTvBdmwYcMO+z7wwANx9dVXR5MmTSIiokGDBvHyyy9Hnz59Yt26deWK16RJkxg9enTCd7WsXLkyHn744R2OycvLiz/84Q9x3nnnRdOmTWPdunXx7rvvxrx588oVM+Kf39Ny3nnnlZY3b94cf/jDH8ocU1hYGA899FBce+21ERGx++67x8iRI+NHP/pRub6n5Tv9+/ePq666KqHurrvuKvd4AAAAAAAAAAAAAAAAYNeQneoEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoLaqX79+jB49Olq2bFlaV1RUFPfcc0+0a9cuunbtGhdeeGHcd999pe1vvvlmnHjiibHbbrvFiSeeGO+9917CnB07doxXX301cnNzk5prr169YtiwYUmdM13j7rHHHvHCCy9EvXr1EupHjx4d3bt3j/322y9OO+20uPjii+Piiy+O0047Lfbbb7/o3r17jBkzJmFMgwYN4qWXXormzZuXK3bnzp3jwQcfjKysrNK6goKCuPjii6Nly5bRv3//GDx4cNx0000xdOjQ+MUvfhE9e/aMfffdNx5//PGEuX7wgx/ENddcs9OYnTp12ibmokWL4oILLoiWLVvGKaecEldddVXceOONceONN8bll18exxxzTOy7777x17/+NWGuhg0bxpNPPhk5OTnler0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABkhnvuuSemTZtWWs7JyYnnnnsubrrppsjLy6vQXIMGDYqxY8cmfMfKmDFjYsqUKclKN6M9++yzUVhYWPpPWZYsWRLXXXddQt1hhx0W48aNi0MOOWSnsQ455JB45513omvXrgn1//mf/xkFBQU7HLd58+bo2LFjNG3aNCIiGjduHK+++mrss88+O40ZEXH55ZfHX/7yl4S63/72t/HFF1/sdOztt98eixYtKi0PGDAgXnrppdJcdubiiy+Op59+OrKzs0vrJk6cGE8++WS5xgMAAAAAAAAAAAAAAAC7juyddwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAq49prr43999+/tLxu3bo44YQT4pprron58+fvdPzbb78dvXv3jsGDB0dJSUlpfffu3eOmm25KWp4tW7aMUaNGRU5OTtLmTOe4999/fzRr1qy0XFJSEpdeemkMGDAgpkyZssNxU6ZMif79+8fgwYMT6nffffe49957yxX7wQcfjDp16pSWP//88zj44IPj4Ycfjo0bN+5w3MKFC+OCCy6IO++8M6F+6NCh0bBhwzJj/ulPf4p69eqVlvPz8+PQQw+Nxx9/PLZs2bLDcYsWLYqf//zncdlllyXUH3zwwXHOOeeUGRMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDMsmXLljj33HNj+fLlpXXZ2dnxP//zP/Hll1/G//t//y8OO+ywyM7O3mZs3bp149BDD42rr7468vPz429/+1s0atSotH3ZsmVxxRVX1MjrqI3+8pe/xNixYxPqunfvHlOmTIknn3wyzjrrrDjooIOiWbNm0axZszjooIPixz/+cTz55JMxZcqUOOywwxLGvvDCC/H444/vNO7VV18dmzdvLi0fdNBBMXPmzLj//vvjmGOOiSZNmpS2ZWVlxV577RUXX3xxvP/++/HnP/85cnNzS9vz8/PjtttuK9frLSgoiJ/+9KdRXFxcWte/f/+YM2dO3HjjjXHIIYdsM6Z58+ZxzjnnxMSJE+Ohhx5K+L6WZcuWxU9/+tOE7wACAAAAAAAAAAAAAAAAiIjY9hNzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQFL84he/SChfeeWV8d5771V4nvvvvz8uv/zyhLprrrkmdt999yrl952RI0dGmzZtSsv33HNPUuZNx7gnnnhinHXWWQl1Q4cOjf/93/8t9xz3339/3HTTTQl1gwYNiqOPPrrMceeff35Cn4KCgvjhD38YS5cuLXfsX//61zFt2rRYtWpV3H///XHyySdHYWHhDvt36NAhTjjhhNLy2rVr4/TTT4+VK1eWO+aIESPiueeeS6g777zzyj0eAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAzDB79uzo27dvLFiwIKG+bdu2ceutt8aUKVNi06ZNMXbs2NK2K6+8Mr799tuYNm1a3HPPPdGlS5eEscuWLYu+ffvG119/XSOvobY6++yz4913302oy8vLi/POOy+ee+65mDVrVhQUFERBQUHMmjUrnn322TjvvPMiLy8vYcxbb70VP/nJT8oVc/r06XHZZZdFSUlJaV3jxo3jsssuiwkTJsSaNWtiw4YNsWzZstiyZUssWrQoHnrooTjqqKMS5vnss8/i5JNPjs2bN5f79b777rtx7rnnxqZNm0rrWrRoEb/5zW9i5syZsWHDhvj666/jiy++iJUrV8aKFSviqaee2uY7ZJYsWRL9+vWLefPmlTs2AAAAAAAAAAAAAAAAsOvITnUCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUBu1bds29tlnn9Ly8uXL47HHHqv0fCNGjIgPPvggIiImTZoUP//5z6OgoKDKeQ4ZMiT69etXWr777rvjxRdfrPK86Rr30ksvTShPnz49fve731V4nttuuy1mzpyZUHfJJZeUOeYXv/hFQvnWW2+N+fPnVyhucXFxnH766dG6desYPHhwTJo0qcz+s2fPjs6dO8eDDz4Y3377bdx+++2xYMGCCsWMiLj//vsTyocffniF5wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACD9zZgxI7p16xZPPvlklJSUbNOem5sbrVq1Ki3XrVs3srKytjvXc889F507d97mez6ouA0bNsRJJ50U9957bxQXF1d4fHFxcQwfPjxOOeWU2LhxY7nHPfzww3H++efHmjVrtttev3792H333SMnJ2e77S+88EIcc8wxsXjx4grn/Oyzz0bfvn1jzpw52427zz77RPv27aN58+bb/Rl87bXXonv37jFt2rQKxwYAAAAAAAAAAAAAAAB2DdmpTgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABqozZt2iSUZ86cGcXFxVWa85JLLoljjz02jjzyyBg1alRs3bq1SvP16tUrhg0bVlr+4IMPYsiQIVWaM53j7r777jFgwICEuhtuuCFKSkoqPFdxcXHccMMNCXUDBw6MJk2abLd/27Zt4/jjjy8tL1++PO6///4Kx42IWLRoUWzevLnc/WfNmhWXXHJJ7L333vHHP/6xUjFnzpyZUG7VqlWl5gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACD9FRQUxE9+8pPo1q1bjBgxIlasWFHuscuWLYuHH344DjvssDj77LNj+fLl1ZjprmXLli3xX//1X3HooYfG448/Hhs2bNjpmA0bNsTIkSOja9eucf3110dRUVGF4z711FNx0EEHxT333BMrV67caf/i4uJ444034qSTToqzzjorVq1aVeGY35kwYUJ06tQpLrvssm2+Q2V7tm7dGm+++Waccsopccopp8Q333xT6dgAAAAAAAAAAAAAAABA7Zeb6gQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgNqpTp05CeePGjVWeMz8/v8pzfKdly5YxatSoyMnJiYiIgoKCOOecc6KoqChpMdIpbkTED3/4w4TrsnLlynjttdcqPd+rr74aBQUF0bx584iIaNCgQfzgBz+Il156aZu+p59+emRlZZWWX3rppdiyZUulY1dGQUFBpcdu2LAhoZyXl1fVdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEhz+fn5cdlll8Xll18enTp1iu7du8fee+8dXbp0iZ/85CcREfHhhx/GqFGjYuHChTFz5sz47LPPajzPf/zjHwnfDVIdrr/++rj++uuTMlf//v0jIuKWW26Jm2++ucLjZ86cGRdccEHUq1cvjjrqqOjcuXO0bds2GjZsGBERhYWFsWDBgpg5c2Z88MEHSfnunMWLF8c111wT1113XfTo0SO6dOkS++23XzRq1Cjy8vJiw4YNsWTJkvj8889j/PjxsWrVqirH/E5RUVGMGDEiRowYEXvttVf06dMn9tprr2jVqlU0btw4CgsLY/ny5TFr1qyYOHFilb6nBQAAAAAAAAAAAAAAANi15KY6AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKiNVq1alVBu1apVijLZvpEjR0abNm0iIqKkpCQuvPDCWLBgQa2NGxFxxBFHJJTHjBkTW7durfR8RUVFMWbMmLjwwgtL63r06BEvvfTSNn0PP/zwhPLo0aMrHTcVWrRokVBeu3ZtijIBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgppWUlMSnn34an376aUT887s4fvKTn0RExHvvvRf33ntvCrPLXI0aNarS+I0bN8Y777wT77zzTnISKofi4uL46KOP4qOPPqqxmP/um2++iSeffDIlsQEAAAAAAAAAAAAAAIDaJzvVCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBttGjRoigpKSktH3roodG8efMUZvQvQ4YMiX79+pWW77777njllVdqbdzv9OjRI6H88ccfV3nOyZMnlxnjO926dUsoT58+vcqxa9JRRx2VUP7mm29SlAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADUDscee2yqUwAAAAAAAAAAAAAAAADYpeWmOgEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACojVatWhWffPJJdO7cOSIicnNz49Zbb40rrrgipXn16tUrhg0bVlp+//33Y8iQIbU27r878MADE8ozZ86s8pwzZswoM8Z3DjrooNJ/37BhQ3z99dfb9GnQoEEcfvjh0b59+2jSpElkZ2fHunXr4uuvv45p06bFihUrqpxvZQ0ePDih/NFHH6UoEwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMhsWVlZcc8998RRRx2V6lQAAAAAAAAAAAAAAAAAdmm5qU4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaqtHH300hg8fXloePHhwrFq1Km655ZbYunVrjefTsmXLGDVqVOTk5EREREFBQZxzzjnVnkuq4n5f06ZNE8qLFi2q8pzffPNNmTEiInJycqJhw4al5cWLFye0n3jiiXH11VfHSSedFHl5eduNU1JSEh999FE88MAD8fjjj0dRUVGVcy+vX/7yl3Hccccl1D3xxBM1Fh8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABqi2bNmsWTTz4Z/fr1i4iIefPmpTYhAAAAAAAAAAAAAAAAgF1YdqoTAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgNpqxIgRMXfu3IS6G2+8MT755JO46qqr4oADDqjRfEaOHBlt2rSJiIiSkpIYNGhQLFy4sNbG/Xd5eXlRt27dhLr169dXed5169YllJs2bbpNnyZNmmw3bvPmzePll1+ON998M0477bTIy8vbYZysrKzo2bNnPProozF16tQ4/PDDq5x7eZx77rnx5z//OaHu448/jjfeeKNG4gMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJB+vvnmm7j55pvj5ptvjtdffz3V6WSUQw45JE488cSIiJgxY0Ycd9xxKc4IAAAAAAAAAAAAAAAAYNeVm+oEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoLYqLCyMs846K8aNGxe77bZbaX3Hjh3jvvvui/vuuy8KCgpi4cKFpW177rlntG7dOpYsWZLUXIYMGRL9+vUrLd91113x6quvJjVGOsX9viZNmmxTt379+irPu27duoRynTp1ol69erFx48bSuqZNmyb0KSwsjNatW8d7770X7du3r3DMzp07x/jx4+O8886Ll19+uXKJ70SDBg3i9ttvj6uuuiqysrJK6wsLC+Piiy+OkpKSaokLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABA+luyZEnceuutqU4jI40fPz6GDh0aXbp0iUsvvTQKCwtTnRIAAAAAAAAAAAAAAADALis71QkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAbTZt2rTo2bNn5Ofnb7e9efPm0bVr19LyT3/601i8eHGsWbMmxo0bF7/97W/jmGOOqVIOvXr1imHDhpWWJ06cGEOHDq3SnOkcd3uys7f9avetW7dWed7tzfH9WHl5eQnl4uLiePHFF6N9+/YREVFUVBSPPfZYnHnmmdG2bduoV69eZGdnR8uWLePoo4+Om266KRYvXpwwR/369ePpp5+u8s/G9nL/2c9+FrNnz47//M//jKysrNK2DRs2xFlnnbXDn2UAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABg5+68884YNGhQFBYWpjoVAAAAAAAAAAAAAAAAgF1adqoTAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgNpu9uzZ0a1bt7joooti4sSJ5RrTpEmTOP744+NXv/pVTJgwIebMmRMXXHBBhWO3bNkyRo0aFTk5ORERsXLlyjj33HNj69atFZ4rE+JmgmOOOSZ69uwZERGTJ0+OTp06xYUXXhgvvvhiLFy4MDZt2hQlJSWxcuXK+OCDD+I3v/lNtGvXLoYPH54wT926dWPkyJHRoEGDpOQ1cODAmDVrVjzyyCPRpk2bhLZ58+ZF796944033khKLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAVMpOdQIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwKygpKYm//e1vceyxx8bee+8dZ599dtx1113x+uuvx5IlS3Y6fv/994/HHnss3njjjWjSpEm5444cOTLatGlTmsOgQYNi4cKFlX4d6R43E2Rn//Nr5idOnBjHHntszJkzZ6djNm/eHNdff31ceeWVCfX77bdfXHbZZVXK59RTT42pU6fG008/HR07dkxoKy4ujgcffDC6dOkSkydPrlIcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIB0kZ3qBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBXs2jRonjuuefiv//7v+Pkk0+O0047rbRt3LhxMXz48HjjjTdizZo124w96aST4u233468vLydxhkyZEj069evtHznnXfG2LFjk/Mi0jBuRWVlZaVsjnXr1sWZZ54ZmzZtqtC4P/3pT/Hkk08m1F1xxRWVyqF3794xYcKEeOWVV6Jbt27btL/11ltx+OGHxyWXXBLr16+vVAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgHSUneoEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgH+ZPHlyXH/99dGvX79o2bJl9O/fPyZNmpTQp0ePHnH77beXOU+vXr1i2LBhpeUJEybEDTfcUC05p0Pcndm0adM2dXl5eVWet169euWK9X1//OMfY9myZZWKOXTo0CgpKSktt2vXLjp37lzu8W3bto3nn38+3n333TjmmGO2aR8/fnz06dMnTjrppJg+fXqlcgQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASGfZqU4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2L6ioqIYM2ZMHHXUUTFixIiEtsGDB0erVq22O65FixYxatSoyMnJiYiIFStWxLnnnhtbt26t1nxTFbc81q5dGyUlJQl1jRs3rvK835+jsLCwXK/3mWeeqXTMefPmxeTJkxPqunfvXq6xp5xySkyfPj3OPPPMbdomTZoUP/zhD+O4446Lf/zjH5XODwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAg3WWnOgEAAAAAAAAAAAAAAAAAAADg/7N331FSlufDgO8t9CYdFRQLoggIVpqioigKFpTYGxoVRbEligUj9kZEo8ZgoqJIAmKhKhZEEbtUG4hgR3rv7H5/5HN/WXcWts8uXNc5e45Pu5975p25n5mXBQEAAAAAAAAAAAAAAAAAALYsIyMjLr/88vj000+z+ipWrBjdu3dPOH/IkCGx8847R0REZmZmnHPOOfHTTz8Ve57J2jcvMjMzY9WqVdn6atSoUei4v4+xbNmyHHPWr1+frZ2RkRHTp08v1L6fffZZtnbDhg23uqZHjx4xatSoqFmzZrb+adOmxQknnBAHH3xwvP7664XKCwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgLEhPdgIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADA1mVkZMRDDz0Uzz77bFZfx44d4+9//3u2eTfccEMcc8wxWe3XXnst1qxZE4cddlie92rVqlW29k477ZRj/fTp02PZsmVJ3zc/Fi1aFNWqVctqN2nSJGbMmFGgWP8b438tXrw4x5ylS5fmaGdkZBRq34ULF2ZrV69efYvzDzjggBgyZEikpaVl9S1fvjyuvvrqeOqppwqVCwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAWZOe7AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAvJk8eXK2dsOGDXPMueOOO7K1jz322Dj22GMLte8JJ5wQJ5xwQra+1q1bx9SpU5O+b35MnTo1dtttt6x2y5Yt48UXXyxMitGyZcsce/zeihUrYvPmzZGWlhYRERkZGYXaM78xUlNT47nnnoty5cpl9c2fPz86duwYs2bNKnQuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABlTWqyEwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADyZtGiRdnatWrVyjEnLS2tRHKZO3duqdg3Pz7++ONs7Y4dOxY2nRwxfr/Hb+bMmZP13zVr1iz0vnXq1MnWXrZsWa5zzznnnNh7772z2hkZGXHyySfHrFmzCp0HAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBZlJrsBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBbdtRRR0XHjh2LJFaFChWytdetW1ckcfNryZIlsXz58jK37wcffJCtfdhhh0W9evUKHG/HHXeMDh06ZOv78MMPE8597733sv47PT09mjZtWuB9IyKaNWuWrT1v3rxc51500UXZ2v/5z39yPBcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANuT9GQnAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANuiQw89NO6888449NBDY8qUKXHAAQdEZmZmoWI2adIkW/uXX37JMadp06aF2iMi4uCDD45nn302q/2f//wn+vXrl9XeuHFjqdk3P95+++344YcfolGjRhERkZqaGpdffnnceuutBYrXu3fvSE1NzWrPmjUrPv7444RzJ06cGBdccEFW+6STTop77723QPvWrl072rdvn63vo48+Sji3Zs2aOeY++eSTBdoXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBbkZ7sBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBbU758+RgxYkTUrVs3IiJat24dV199dQwYMKBQcc8888xs7alTp+aYM2vWrELtERHRoEGDbO2lS5duNW6y9s2PzMzMeOqpp6Jfv35Zfdddd10MGjQofvzxx3zF2mWXXeKaa67J1jdo0KBc57/wwgsxcODAqFGjRkREXHvttfHYY4/FypUr87VvRMTNN98c6en/97+qnzp1asyZMyfh3FatWkVKSkpWe+PGjTFp0qR87wkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsC1JTXYCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsK3ZsGFDPPDAA9n67rvvvjjppJMKHLNDhw5xySWXZOt78cUXCxxvW1KhQoWoXLlytp/cPP7447FixYqsduXKlWPkyJFRrVq1PO9XvXr1GDVqVFSsWDGrb/HixfGvf/0r1zWrV6+OJ598Mqtdt27deO655yIlJSXP+0ZEdOvWLa688spsfffff3+u83fdddds7blz58aGDRvytScAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwLYmNdkJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwLbor3/9a0ydOjWrnZaWFiNGjIh+/fpF+fLl8xXrnHPOiXHjxkV6enpW3+jRo+Ozzz4rqnTLtBdeeCFWr16d7Sc38+fPj+uuuy5bX+vWrWPChAmx7777bnWvfffdN95+++1o2bJltv4+ffrEkiVLtrj2rrvuip9++imrfcIJJ8Qrr7wSNWrU2Oq+EREXXnhhDBs2LFJT/+9/Uz958uQYOnRormuqV6+erb148eI87QUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsC1LT3YCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsC3auHFjnHbaaTFp0qSoW7duRESkpqbGbbfdFhdddFEMGjQoRo8eHdOmTcuxtkKFCrH33nvHEUccET179owWLVpkG1+wYEH07t27RB7HtmjQoEFx8sknR5cuXbL6DjjggPjss8/ixRdfjOHDh8eXX34Z8+fPj4iIBg0aRLNmzeLUU0+N7t27R/ny5bPFe+mll2LIkCFb3XfJkiVx1llnxVtvvRWpqakREdGtW7eYM2dOPPTQQ/HSSy/F559/nm1NrVq14qijjoqrrroq2rZtm21swYIFcdZZZ0VmZmaue6anZ/9f2jdu3Dgef/zxreaaF3fddVf88MMPRRILAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAkpSc7AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANhWzZo1Kzp16hRjxoyJRo0aZfU3atQo+vfvH/37949NmzbFkiVLssauuOKKuPbaayMlJSVhzAULFkSnTp3iu+++K/b8t2WnnnpqjB07Njp27JjVV758+Tj99NPj9NNPz3OcN954I84888w8z584cWKcdtpp8dxzz0WFChUiIqJ27dpx++23x+233x5r166NhQsXxoYNG6JWrVpRs2bNhK+F+fPnR5cuXWLevHl53jsiYscdd4xLL700X2tyM2jQoPjhhx+KJBYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABl0+F/jGjZOdlZsL2ZMChixvhkZwEAAAAAAAAAAAAAAACUdenJTgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC2ZTNmzIhWrVrF3/72tzj99NMjJSUl23h6enrUq1cvq12hQoVcY40YMSJ69eoVCxcuLLZ8txdr1qyJo48+Ou6777648sorIzU1NV/rMzIyYsCAAdG3b9/YtGlTvta+8MIL8csvv8QzzzwTe+yxR7axSpUqxS677LLF9a+++mpceOGF8fPPP+drXwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAChq5SpEVKyW7CzY3qSVS3YGAAAAAAAAAAAAAAAAwLYgNdkJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwLZuyZIlceaZZ0arVq3i73//eyxatCjPaxcsWBD/+te/onXr1nHqqafGwoULizHT7cvGjRvj6quvjv322y+GDBkSa9as2eqaNWvWxHPPPRctW7aMP/3pT7Fp06YC7f3ee+/F3nvvHb169YqZM2dudf7mzZvj9ddfjy5dukSXLl3i559/LtC+AAAAAAAAAAAAAAAAAAAAAAAAAAAAALCta9myZWzcuDE2btwYDz74YLLTAQAAAAAAAAAAAAAAAAAAoJRKT3YCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsL2YPn169OrVKy677LLYe++944ADDoiGDRtGixYt4swzz4yIiA8//DD+/e9/x48//hgzZ86Mr776qsTzfOeddyIlJaXM7NutW7eIiPjLX/4St956a77Xz5w5M84+++yoWLFitGnTJpo3bx6NGjWKKlWqRETE6tWr44cffoiZM2fGBx98EOvWrcv3Hols2rQp/v73v8ff//732GmnnaJjx46x0047Rb169aJatWqxevXqWLhwYXzxxRcxefLkWLJkSb73GDBgQAwYMKBI8gUAAAAAAAAAAAAAAAAAAAAAAAAAAACAsiI9PT0iIlJTU5OcCQAAAAAAAAAAAAAAAAAAAKVVerITAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgO1NZmZmfPnll/Hll19GRMT+++8fZ555ZkREvPvuu/HQQw8lMbuyq2rVqhERsXbt2gKtX7duXbz99tvx9ttvF2FWefPzzz/H0KFDS3xfAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDtUWqyEwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoCu3bt4+IiJ9++inJmQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUJqlJjsBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMJISUmJhx56KNq0aRMREePGjUtyRgAAAAAAAAAAAAAAAAAAAAAAAAAAAABAsqSmpiZt7/Lly2+Xe5NYampqlCtXLtlpAAAAAAAAAAAAAAAAAAAAuUhPdgIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABVWzZs0YOnRoHHPMMRERMW/evLjtttuSnBUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUBLS0tKic+fO0aVLlzjwwAOjSZMmUbt27azx3r17x8knnxzffvttvP/++zF27Nh47733Cr3v7rvvHt26dYvDDz889tlnn2jYsGFUrlw5UlJSIiMjI5YuXRrffPNNfPDBB/HKK6/EhAkTCr3n/2revHmceuqpcdhhh0WzZs2iTp06kZaWFps2bYpFixbFL7/8Eu+++268+uqr8cYbb8TGjRuLdP+8OOqoo6JZs2ZbnDNlypR49913t4l9mzRpEt27d49DDz009t1336hfv35UqlQpIiI2bdoU8+fPjy+++CLefvvtGDp0aMybN69I9wcAAAAAAAAAAAAAAAAAAPIvPdkJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwPbu559/jltvvTUiIiZPnpzkbMqWfffdN4466qiIiJgxY0Ycd9xxsXjx4iRnBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUp/Lly0fv3r3jT3/6UzRo0CDXeenp6bHrrrvGrrvuGkcccUTceOONMXv27LjttttiyJAh+d63ZcuWcdddd8Vxxx0XKSkpCeekpqZG7dq1o3bt2nHIIYdEnz594uuvv47rr78+XnnllXzv+b9at24dDzzwQBx55JEJx9PT06NBgwbRoEGDaN26dVx55ZUxd+7cuOWWW+L555+PzMzMQu2fH3/+85/j6KOP3uKchx56KN59990yvW+zZs3i3nvvja5du+Y6Jz09PRo2bBgNGzaMzp07x5133hnDhw+Pa6+9Nn788cciyQMAAAAAAAAAAAAAAAAAAMi/1GQnAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANu7+fPnR//+/aN///7xxhtvJDudMmXSpElx4403xnPPPRdt27aNH3/8MdkpAQAAAAAAAAAAAAAAAAAAAAAAAAAAAADFaK+99opPP/00HnzwwWjQoEG+1zdp0iSee+65eOutt6JevXp5XvfnP/85Pv300zj++OMjJSUlX3s2bdo0Xn755XjyyScjLS0tvylHRMTNN98cn3zySRx55JH5WrfbbrvFc889Fy+//HJUqlSpQHsXxJ577llieyVr3wsuuCA+/fTT6Nq1a77WpaSkxB/+8IeYMWNGdOrUqZiyAwAAAAAAAAAAAAAAAAAAtiY92QkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFMZ9992X7BQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgBLQrFmzeOedd6J27drZ+jdv3hxTpkyJKVOmRGZmZlx88cURETFlypT4+eef46CDDop69eplW3PEEUfERx99FB06dIgff/xxi/vecccdcdNNN+Xonz9/frz//vsxZ86cWLZsWWRkZMQOO+wQe+yxR7Rv3z4aNGiQbf6FF14Y5cuXj3PPPTdfj/uxxx6LXr165ehfsGBBvPXWWzFr1qxYvHhxlCtXLurVqxcHHHBAtG/fPipWrJg194QTTogJEybEkUceGWvWrMnX/vlVrly52GWXXYp1j2Tve8EFF8Q///nPSElJyda/ePHimDRpUsyePTuWLVsWERG1a9eO/fbbLzp06BDly5fPmrvDDjvEmDFj4vDDD48PPvigRPIGAAAAAAAAAAAAAAAAAAD+T3qyEwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANiSSpUqxahRo6J27dpZfRs2bIgHH3wwHn744Zg/f35ERLRs2TIuvvjiiIiYOHFiXH311RER0b59++jXr1907tw5a/2uu+4a48ePj/333z/WrVuXcN/jjjsubrrppmx9H374YfTt2zcmTJiQa76pqanRrVu3GDBgQOy+++5Z/eecc0689tprMWTIkDw97j59+kSvXr2y9f34449x/fXXx7///e/IyMhIuK527drx5z//Oa699tpIS0uLiIhDDjkkHn744bjooovytHdBbdy4MerVq5ej/9Zbb40rr7yyzO/brFmz+Pvf/x4pKSlZfd9//31cd911MWLEiFyvSd26dePmm2+O3r17R2pqakREVKhQIYYOHRpNmzaNDRs2FFmOAAAAAAAAAAAAAAAAAADA1qUmOwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAtue6662L33XfPai9fvjwOO+ywuPHGG2P+/PlbXf/ee+/FMcccExdccEFs3rw5q3+fffaJu+++O+GalJSUePDBB7P1Pfnkk9G2bduYMGHCFvfLyMiIV155JVq3bh0ffvhhtrE77rhjq/lGRDRu3DjuvffebH2TJ0+OVq1axfPPPx8ZGRm5rl28eHFcf/31cfTRR8fq1auz+i+88MLo2rVrnvYvjCVLluT4WbNmzTax76OPPhrly5fPak+dOjVatWoVw4cP3+I1WbhwYfTp0yfOP//8bP2NGzeOc889t0hzBAAAAAAAAAAAAAAAAAAAti412QkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABsyR//+Mds7csvvzw+/PDDfMd5+umn44ILLsjWd9lll0XDhg1zzM3MzIyLL744xo4dGxERH330UVxyySWRmZmZ5/1WrFgRp512Wqxbty6rr3HjxtGuXbutrr3pppuiQoUKWe25c+dG165dY/HixXnef8KECXHmmWdm67vxxhvzvJ7s9tprr+jYsWNWe8WKFdGtW7dYunRpnmM8++yz8dxzz2XrO+2004osRwAAAAAAAAAAAAAAAAAAIG9Sk50AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAbnbZZZdo1KhRVnvBggUxdOjQAsd79tln46233oqIiA8//DDOOuus+PnnnxPOfffdd+P444+P/fbbLy6++OLIyMjI937fffddjB07NlvfwQcfvMU1FSpUiNNOOy1b33XXXRdLly7N9/4jR46MUaNGZbXbtm271f1JbNasWbH33nvHo48+GqtXr4677747fvzxx3zHeeKJJ7K1W7duXVQpAgAAAAAAAAAAAAAAAAAAeZSa7AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABys9NOO2Vrf/7555GRkVGomJdffnm0a9cu2rRpEy+88MJW402fPj2mTZtW4P1+v/b3j+n32rZtG9WqVctq//rrr/Hiiy8WeP/HH388W7tbt24FjrW9mzVrVvTu3Tt22mmnePjhhwsU44svvsjWrlWrVqSmphZFegAAAAAAAAAAAAAAAAAAQB6lJzsBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA3KSnp2drr1u3rtAxv/rqq0LHyI/ly5dna1eqVGmL81u0aJGtPWHChELtP2HChMjMzIyUlJSIiGjfvn2h4hGxYsWKAq9ds2ZNtnZKSkqkp6fHhg0bCpsWAAAAAAAAAAAAAAAAAACQR6nJTgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA3y5Yty9auX79+chIphFq1amVrr1q1aovz69atm639448/Fmr/devWxZIlS7LaBx10UKHiUTh16tTJ1t6wYUNs2LAhSdkAAAAAAAAAAAAAAAAAAMD2KT3ZCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOTmxx9/jMzMzEhJSYmIiJYtW0adOnVi0aJFSc4s7w444IBs7a+//nqL8ytVqpStvXr16kLnsGrVqqhdu3ZERFStWjUqVqwY69atK3Rc8q9t27bZ2j/99FOSMgEAAAAAAAAg2VJTU6NmzZqxww47RFpaWsI5s2bNKuGsAAAAAAAAALYP6clOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDfLli2LmTNnRosWLSIiIj09Pe6444649NJLk5xZ3uy1117RuXPnrPbmzZtj3LhxW1yzYcOGbO2qVasWOo9q1apla9esWTN++eWXQscl/3r37p2t/cEHHyQpEwAAAACgrHv//fcT9rdt27aEM9m+uQ7kVVG9Vrzmipfnl22R13Xpsvfee0e3bt2iY8eO0aZNm6hVq1akpKRscU1aWlpkZGSUUIaQN2pL2fboo4/G/vvvn6O/V69eMXXq1JJPCAAAAAAAIEnSk50AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAljz11FMxYMCArPYll1wSy5Yti5tvvjk2bdqUxMy2rG7duvHiiy9GuXLlsvoGDx4cv/766xbXLVmyJFu7UaNGhcqjcuXKUbNmzWx9NWrUiF9++aVQccm/iy++OA477LBsfc8//3ySsgEAAAAAyro2bdokOwXCdSDviuq14jVXvDy/bIu8rkuHli1bxl/+8pc46aSTIiUlJdnpQKGpLWVbs2bNEl7D6tWrJyEbAAAASpOUlJSoVq1awrGVK1dGZmZmCWcEAADFKz3ZCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGzJE088EZdffnnsscceWX3XX399nHrqqfH444/HmDFj4quvvkpihtlVr149zjzzzLjtttuiXr16Wf1ffvllXH311Vtd/+WXX2ZrH3744YXK58gjj4yUlJRsfampqYWKSf6dfvrp8eijj2br++yzz2LMmDFJyggAAACg6PzpT3+KWrVqZev7+uuv4+mnny7xXPr06RMNGjTI0X/XXXfFypUrSzwfSrdEr93C2LBhQ6xduzYWL14c8+fPj2+++Sa++eab2LhxY5HtAVCaHH300XHkkUfm6P/yyy9j8ODBJZrLueeeG/vss0+O/rfffjtee+21Es0F4PfOPvvs+Oc//xnly5dPdioAAAAAsEW77bZbzJkzJ+FY06ZNY9asWSWcEQAAFK/0ZCcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwJWvWrImTTz453n777ahVq1ZW/x577BEPPPBAPPDAA7FixYr44YcfssZ23nnnaNSoUba+onLQQQdF//79s/WlpKRExYoVo379+rHXXntFampqtvFvvvkmunTpEsuXL99q/MmTJ8fGjRujXLlyERFRr169OOWUU2LEiBEFyrd3794FWkfRqFKlStx9993Ru3fvSElJyepfvXp19OzZMzIzM5OYHQAAAEDRuOyyy6Jx48bZ+jIzM+P777+Pt956q0Rzueiii6J58+Y5+h955JFYuXJlieZC6ZfotVvUNmzYEJ999llcdtllMWXKlGLdC6CkHXbYYXHDDTfk6B89enQMHjy4RHPp0aNHdO3aNeHYa6+9VqK5APyvyy67LB599NFkpwEAAAAAAABAAqlbnwIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJBcM2bMiIMPPjg+++yzhOPVq1ePfffdN6vdo0eP+P7772PVqlUxadKkGDBgQBx++OGRkpJS6Fzq1q0bxx57bLafY445Jjp27Bh77713pKamZpv/6KOPRosWLeK7777LU/xly5bFq6++mq3vgQceiFq1auU71z/84Q9xzDHH5HsdhZeWlhYXXnhhzJo1K6644opsr73Vq1dH9+7dY9q0aUnMEAAAAKB4paSkxODBg6NmzZrJTgWSqnz58tGmTZv47LPP4tNPP40ePXokOyUAAEpIq1at4q9//Wue5q5ZsyaWLVuW8AcAAAAAAACA4pGe7AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgLKteo3qyU4BAKBAqlatGhUqVEh2GgDbjZSUlIiIqFKlSqSXS09yNgDbj7S0tIiIqFy5cqSkpiQ5G4DtQ3r6fz/vVqxU0Z+jAJSg8uXLR0REhYoV1F+AEvTbn7dVqKD+ApS0HXbYIdkpAAAAAAAAAABA0syZMycOOOCAOOOMM+KSSy6Jww47LOvvtOemSpUq0b59+2jfvn1cffXV8cMPP8Rtt90W//rXvyIzM7NE8j711FPjk08+iaeffjrPa+68887o2rVr1uNr3LhxjB49Ok444YRYtGhRnmIcc8wx+dqTonP66adH//79o0mTJjnG5s6dGz169IhPP/00CZkBAAAAlKydd945/vGPf0SPHj2SnQqUCvvvv38MGzYsJk+eHOeee27MmTMn2SkBUALatWsXd955Z47+SZMmxS233JKEjGDbVprec0899VTWv5f3e/Pnz4+BAwfGuHHj4osvvoiNGzeWaG4AsDWl6UwFoGDUcoBtg3pOsnjtAQDbC//HdQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgUHbddddkpwAAUCA77bRTslMA2C412LFBslMA2C7Vq18v2SkAbHdq164dtWvXTnYaANudmjVrRs2aNZOdBsB2p0aNGlGjRo1kpwGwXVm5cmWyUwAAAAAAAAAAgKQbOnRoDB06NOrVqxdt2rSJQw45JFq2bBmtWrWKhg0bbnFto0aN4sknn4xzzjknTj755Fi6dGm+91+0aFG88cYbOforVqwYderUiSZNmkRaWlpWf/369eOpp56Kww47LC666KLIyMjY6h4ffvhhPPHEE3HppZdm9bVt2zamTJkSN9xwQwwdOjTXOHXr1o2+fftGnz59IjU1NTZt2hTz58/f6nND4XXr1i3uuOOOaNmyZY6xjIyM+Mc//hF/+tOfYtWqVUnIDgAAACA5Tj311DjvvPPimWeeSXYqUGq0a9cuPv300zjllFPizTffTHY6ABSzOnXqxOGHH56jf9myZSWeC2wPSst77ogjjohWrVolHBszZkycdtppsXr16hLNCQDyo7ScqQAUnFoOsG1Qz0kWrz0AYHuRnuwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgP+zww47xE0335TsNNjOPPjAgzF//vxkpwEAAEAZ9uOPPyY7BQCAfNlpp50iNTU1fp3/a2zctDHZ6QBsNxo0aBDp6emxYMGC2LBhQ7LTAdhu1K1bNypUqBCLFi2KdevWJTsdgO1C7dq1o1KlSrF06dJYvXp1stMB2G7ssMMOUbVq1Vi+fHmsXLky2ekAbDeqV68e1atXjxUrVsSKFSuSnQ7AduX7775PdgoAAAAAAAAAAFBqLFiwIEaOHBkjR46MiIiWLVvGtGnTIiLi7bffjvfffz9atmwZbdq0idq1a2db27Fjx3j77bfjkEMOyfffxfzoo4/i6KOPznW8cuXK0bVr17jhhhuidevWWf0XXHBBrFy5Mvr06ZOnffr06RP77LNPdOzYMauvYcOG8dxzz8WAAQNiwoQJMWvWrFi0aFGUL18+6tWrFwcddFC0bds2KlSokLXmhhtuiC5dukTDhg2z+jIzM/PzkNmKI488Mu6666445JBDEo6PHz8+rrvuupgxY0YJZwYAAABQOvztb3+Ld955J+bOnZvsVCBP5s6dG4sXL87XmrS0tKhcuXJUqVIl6tWrF+XLl9/i/Bo1asSYMWPimGOOiYkTJxYmXQAASqHevXsn7P/iiy/ilFNOifXr15dwRgAAAAAAAAD8XnqyEwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyraBDw1MdgoAAPnS//b+UalSpXjuuedi/vz5yU4HYLtx4003Rs2aNWP4sOExb968ZKcDsN247PLLYrfddotXXnklvvryq2SnA7Bd6NmzZ+zTbJ+Y8NaEeP/995OdDsB24+TuJ0e7du3ivUnvxYQJE5KdDsB2o8txXeLII4+MTz75JMaNHZfsdAAAAAAAAAAAAABymDp1atx4440REZGamhqdOnWKW265JQ499NCsOS1btowHH3wwLr/88iLde82aNTFs2LAYMWJE3HfffXHNNddkjV155ZUxatSoeOONN7YaZ8OGDdGlS5cYPHhwnHrqqdnG6tWrF6eddtoW12dmZsbNN98cDz74YJxyyinZxlauXJmPR0Rudt1113j44YfjhBNOSDg+ceLEuPnmm2PSpEklnBkAAABA6VK1atUYMmRIdOjQITIyMpKdDmzVzTffHM8//3yB16empsZuu+0WrVq1im7dusUJJ5wQNWvWzDGvQoUKMXz48GjRokX8+uuvhUkZAIBS5ogjjkjY37dv31i/fn0JZwMAAAAAebNu3bpc/w7E2rVrSzgbAAAofqnJTgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKA4ZWRkxOuvvx6HHXZYPPjgg9nG/vjHP0bDhg2LZd/NmzfHtddeG0OGDMnWf8cdd+Q5xtq1a6NHjx5x+umnx5w5c/K8bsqUKdGxY8e46667IiKiatWq2cZXrFiR51gkdvzxx8fUqVPjhBNOyDH2wQcfxFFHHRWHH354TJo0KQnZAQAAAJQ+bdu2jZtvvjnZaUCJyMjIiDlz5sSIESPi/PPPj0aNGsW6desSzq1bt27cd999JZwhAADFqVmzZlGzZs0c/UuWLInRo0cnISMAAAAAyJuff/45Dj300IQ/P/zwQ7LTAwCAIpea7AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABKynXXXRfvv/9+VrtcuXLRo0ePYt3z2muvjU2bNmW1DznkkNhtt93yFeM///lP7LXXXnHcccfFE088ER9//HEsXLgw1q9fH2vXro358+fHe++9FwMGDIgOHTrE/vvvH++++27W+ho1amSLt2rVqsI9qO3cH/7wh3jllVdihx12yNb/2WefxXHHHRdt27aNN998MznJAQAAAJRi/fr1i0MOOSTZaUCJW716dRxxxBGxePHihONnn312NG7cuGSTAgCg2DRr1ixh/0cffRQZGRklnA0AAAAAAAAAuUlNdgIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlaeDAgdnaHTt2LNb9fv3113j//fez9R188MH5jpORkRHjxo2LSy+9NA4++OCoV69eVKxYMSpXrhw77rhjdOjQIa699tp47733sq2rUKFCNGzYMKu9YMGCyMjIKNiDIQ444IB47rnnIi0tLatv2bJlce6558YBBxwQ48aNS2J2AAAAAKVbWlpaDBkyJKpUqZLsVKDEffDBB3H++ecnHEtNTY1zzjmnZBMCAKDY1KxZM2H/3LlzSzgTAAAAAAAAALYkNdkJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlKT3338/W7thw4bFvuecOXOytRs0aFDse/6madOmkZqamtWeOnVqie29rUlLS4vnnnsuypUrl9X3yy+/xMEHHxzPPvtsEjMDAAAAKDv22GOPePjhh5OdBiTF6NGj44033kg41rlz5xLOBgCA4lKrVq2E/StWrCjhTAAAAAAAAADYktStTwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANh2LFq0KFu7Zs2axb7n6tWrs7UrVKhQ7Hv+pm3bttnaU6ZMKbG9tzVnn3127L333lntjIyMOPnkk2P27NlJzAoAAACg9Hr99dcT9vfs2TO6d+9ewtlA6fDvf/87YX/Lli1LOBMAAIpLbr8TsHHjxhLOBAAAAAAAAIAtSU12AgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFvTqVOn6NixY5HEqlChQrb2unXriiTultSsWTNbe9myZcW+52+6d++erf3BBx+U2N7bmosuuihbe+jQofHhhx8mKRsAAACA0u/aa6+NWbNmJRwbNGhQ7LjjjiWcESTf9OnTE/ZXr149qlevXsLZAAAAAAAAAAAAwPYrPdkJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5KZDhw5x5513xmGHHRZTpkyJAw44IDIzMwsVs0mTJtnav/zyS6Hi5UWLFi2ytX/99ddi3zMiYtddd40jjjgiq7106dIYO3Zsiey9ralZs2a0b98+W9+TTz6ZpGwAAAAAyobVq1fHmWeeGe+//36UK1cu21itWrVi8ODBcfTRRycpu+KTmpoa1atXj3LlysXq1atjzZo1yU6JUmT+/Pm5jlWrVi1WrFhRgtnkX0pKSlStWjUqVaoUGRkZsWzZsti0aVOy00qoUqVKUbVq1cjIyIjly5eX2jxJDrUakqcsnSXFpXLlylGlSpVYv359rFy5stB/Bl4auc6lW5UqVaJKlSqxYcOGWLlyZWzevDnZKZVa1apVi0qVKsXatWtj5cqVxbJHxYoVo1q1arF+/fpS/32gqP32WlyzZk2sWrUq2elkU1bq2G9nyrp162LVqlXb5JmSSFm5PkWlfPnyUb169UhJSfH9pZQoq2dpaa67EdtvTfvNb49/7dq1pfL6lGXb27lRFrlXV7qU1XpcFl9Hpf1sjiibz2txcZ4kT1l4r5TV2rmtKIu1qrS+rt2DAGB7lZ7sBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABIpV65cvPDCC1G/fv2IiGjdunVcffXVMWDAgELFPeOMM7K1p06dmuvcGjVqxMUXXxyPPfZYrF69ukD7HXDAAdGiRYusdmZmZnzyySd5WluxYsU45ZRTIj09PZ555pl8733HHXdEuXLlstr/+c9/YsOGDfmOQ0SrVq0iJSUlq71x48Z47733kpgRAAAAQNnw6aefxq233hp33XVXjrGjjjoqrrrqqnjooYdKPrEiUqlSpejSpUt07tw59ttvv2jWrFlUr14925zNmzfHDz/8EDNmzIj3338/Xn755fjyyy8LvGfz5s2jfPnyOfp/+OGHWLhwYYHj/qZGjRqxxx575OifOnVqZGRkFDr+XnvtFVWrVs3R//nnn8f69esLHb+029JjTEtLK8FMtq5ChQrRqVOnOPbYY6Nly5ax7777Ru3atbPdK42IWLlyZSxZsiSmTZsW77zzTkycODHP98GLyoEHHhjdunXLuie/884753g+V69eHV9++WV8+umnMXbs2Bg3blxs3LixRPMsiIoVK0azZs1yHV+2bFl8++232frUieySUavZvjRo0CB22mmnXMf33HPPhP01a9aM/fffP197bdiwIWbOnLnVeYni/vzzzzF//vxc11StWjVat24de+65Z1SvXj2qVasWqampWeMPPPBArFmzJl/5lqWzJK/y+9zWrl07unfvHkcffXS0atUqdt9992xnVGZmZixcuDBmzJgRH3/8cbz88svx4YcfFlv+xaGkr3NpeM/Vq1cvGjZsmOu6nXfeOWH/TjvtlO8cIiI+++yzfK/5zX777RcnnnhiHHzwwdGyZcvYeeeds723IyJWrFgRX3zxRUyfPj3Gjx8f48aNy/f7PS+SUZvys2dKSkocddRRcdppp0Xbtm2jadOmOd6vP/74Y0ydOjXeeuutGDZsWPz888+57r2lnM4666xo165dtGzZMipXrpw1tmHDhli0aFHMnDkzxo0bF2PHjo1Zs2ble4/SqE6dOnHSSSdl1Yrf18PfHvuXX34Zr7/+eowfPz6mTJlSIrmVlfNql112ie7du8dhhx0W++23X+y66645XqPfffddTJ8+PV5//fV46aWX4qeffiqx/IpLWbk+RaVdu3bRqVOnOPjgg6NVq1ZRp06dqFixYrY5mzdvjl9++SU+//zzmDJlSowZMyYmT56c7+9jpeFM/b3S8jn2f5WWszS/z03dunWjR48eceSRR0br1q1z1IwNGzbEu+++W+I19zeNGjWKU089NTp06BCtW7eORo0aRXp6etZ4ZmZm/Prrr/H555/H+++/H6+88kqu7+ny5ctHgwYNcvTPnz+/1P6+5NZqekZGRvz0008xbdq0mDhxYgwfPjy+++67hLGqVKkSTZs2zdH/9ddf5/n3XnfcccfYcccdc/Rv7f1XEIley5mZmUX2GixN50ZJ1LTSWMu3Jr/36q6//voivU9XGs+aZCqr9bg03PMtjrM5Wd+JflMWn9eI0nFf85FHHinUWVIa63lucfN7n2pbfK+U1dqZSGl87W1NWaxVpfV1XZL3IACgtEvJzMzMzNPE330pAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoK/L4z7In5N9qB3LTsmXLaNmyZUT8t858++238cEHHxSq5gAAAAAAAEBExA477BA33XxTstNgO/PgAw/G/Pnzk50GQLHY/aCIU29PdhZsT+47NtkZAGzbUlJS4sADD4y99tor6/e9p0+fHtOnT09yZgAAlDX9b+8flSpVco8coITdeNONUbNmzXj0b4/GvHnzkp0OwHbjsssvi9122y3++c9/xldffpXsdAC2Cz179ox9mu0TL454Md5///1kpwOw3Ti5+8nRrl27GDtmbEyYMCHZ6QBsN7oc1yWOPPLIeOutt2Lc2HHJTgcAgAT8W+1AcfBvtQMAAAAAAJAM1157bTzwwANZ7c2bN8epp54aL7/8co65LVu2jGnTpkVExEMPPRRXX311jjmHHHJIvPvuu1GuXLmsvvbt28fkyZOzzatTp05cc801cfnll0f16tXjH//4R1xyySX5zr9atWrx7rvvxn777ZfV9/HHH8fBBx+8xXXlypWLRx99NE477bSoXr16rFy5Mlq2bJmvv7d/7rnnxjPPPJPV3rhxY7Rs2TK++ir3v3taoUKFSEtLy9a3Zs2aPO+Zm7vvvjtuuOGGrHZu16eoFeW+559/fjz11FNZ7a+//jr23nvvQucIUJYd3TuidddkZ8H2ZvwjEVPHJDsLgJLl32ovXfxOLSQ2d+7caNy4cY7+PfbYI7799ttISUmJiRMnxqGHHppjzvr16+Oggw6KGTNmFEkuM2bMiObNm+fo33nnnePnn38ukj0iInbdddfo27dvnHPOOVG5cuV8r582bVrceeed8cILL+S7hrzwwgtxyimn5Oh/+umn44ILLsh3Lr93yy23RP/+/XP0H3744TFx4sRCxU5NTY0FCxZE7dq1s/WvWLEi6tSpExs3bixU/PzK7bV71llnxfPPP18sezZo0CB++eWXhGONGjWKH3/8Mc+xcnvtFPbviO28887xpz/9KS688MKoWrVqgWJMnTo17rnnnhg+fHhkZGQUKp/cVK1aNS655JLo06dPNGrUKN/rlyxZEn/729/ivvvui9WrVxc4j+K6DhERNWvWjLFjx0abNm0Sjs+bNy+OPvro+Oabb7L1qxP/lcxanUhRvVaK8zWXX7fffnvcfPPNOfpHjx4d3bp1K9FcRo0aFV275rxhec8990Tfvn3zHKcgz2+/fv3itttuy/MehTF58uRo3779Vuclehw33XRT3HXXXdn60tLS4uyzz44LL7ww2rdvH6mpqbnGrF+/fixYsCBPeZaVs6Qg8vrcNmrUKPr16xfnn39+pKen52uPb7/9Nu6999546qmniuTz0bb2maE0vOeuueaaePDBB0skh19//TUaNGiQrzXly5eP888/P6677rpo0qRJvvdct25dPP/883HPPffE7Nmz870+N8moTXnd89hjj42BAwfGXnvttbWHkSUjIyOGDh0aN910U3z33Xdbnd+mTZt46KGH4pBDDsnzHhERL774YvTt2zdmzZqVr3XFLa+1pUGDBtGvX7+48MILo3z58vna44MPPohbb701xo8fX+A8t6SsnFdHHnlk3HzzzXHEEUfka93mzZvjP//5T9x66605vjNMmDAhDj/88BxrOnbsGO+8805h0i0yZeX6FIXy5cvH5ZdfHpdcckk0bdq0QDEWLlwYjz/+eDzyyCOxaNGiPK0pDWfq7yX7c+xvSuNZmp/PoXfccUecddZZOX4XcEuKu+b+pm3btnH77bfHkUceme/Po9OnT4877rgjhg8fnq2/Xbt28d577+WYX5pq2m8KWtMj/vtd+6abbsrxZ4RF8fhz+36f6DVWGOXLl4/169fn6F+3bl1UqlSpULFL47lREjWtNNby3BTmXl1R3qcrLWdNspXVelya7vkW99kcUXLnc1l8Xkvrfc2CniWlsZ4X559plNX3SlmtnVtSGl97uSmLtao0vq6TdQ8CikpKSkocdNBB0aRJE79PC+RZXs7+3L9RAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJNnAgQPjs88+y2qnpaXFiBEj4rbbbosKFSrkK9bpp58e48ePj3LlymX1vfHGGzF58uQcc3fbbbfo27dvVK9ePSIiLr744njiiSeiSpUqed5vr732irfeeiv222+/bP233XbbVtdu3LgxGjdunLV/tWrVYuzYsbHLLrvkae9evXrFP//5z2x9999/f3z11VdbXPfCCy/E6tWrs/3wX79di98sWbIkSZkAAAAAlD2ZmZlx9tlnx4oVK3KMVahQIZ5//vkoX758EjLLv3LlysVdd90Vs2fPjksuuSQqV65coDj77bdfDBs2LD744IPYa6+98rV22LBhCfu7du0aqampBcrnf3Xr1i1f/fnRoUOHqF27do7+kSNHxsaNGwsdvyyoW7durmPLly8vwUxySk1Njb59+8a3334bffr0iapVqxY4VqtWreLf//53fPjhh9GoUaMizPK/zjnnnPjuu+/igQceKHD8WrVqRb9+/WLOnDnRpUuXIs6w8HbeeeeYNGlStGnTJuH4tGnTom3btvHNN9/kGNve60RpqNVQXD7//PMii9WyZcv49NNP4+mnn45DDz20SOpDWTpLilPPnj3jyy+/jIsuuijS09PzvX733XePJ554Ij7//PNcz4Fk2p6uc1G+5wrq66+/ztf8Y445Jr755pt44oknokmTJgXas2LFitGzZ8/46quv4tFHH83X70oUVnHUpi1JS0uLRx55JMaNG5fv8z41NTXOOuusmDlzZnTv3n2L8+67776YPHlyHHLIIfnOsXv37vHFF1/ElVdeme+1ydajR4/44osvolevXgX63t+mTZt47bXXYtSoUTl+b6Mwykoda9CgQYwePTrefPPNOOKII/K9Pi0tLc4888yYMWNGXH311UWaW3EqK9enqHTs2DGmT58eAwYMiKZNmxY4Tt26daNfv34xb968uOKKKyIlJaUIsyy80v459n+V5bP03HPPja+++irOPffcSEtLy9fa4qq5v6lRo0b8+9//jsmTJ0enTp0K9Bpt2bJlDBs2LMaMGRP16tUr8hyLU2FresR/7+tMmTIl+vfvX+yfkcqSsn5ulPTn38IoaC0vint1JX2frixdl/wqq/W4rN7zLczZHFH853NZfV5L833NsvAdpDTc7/q90v5eKau1s7RJ5meJCGdAxPZzDwIACmLb+eYPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABsczZt2hSnn356LFiwIKsvNTU1+vXrF99880385S9/iQMPPDDS09NzrC1fvny0aNEirrzyypgyZUoMHTo0qlevnjW+ePHi6NWrV8J9P/744xg0aFC2vosvvjjmzJkT99xzTxx++OFRu3btHOvq1KkTXbp0icGDB8f06dPjwAMPzDY+fPjwGDNmTJ4e+zXXXBPr16/Pau+zzz4xc+bMeOyxx6Jdu3bZHktKSkrstNNOceGFF8bkyZPjsccey/aczJw5M26//fY87Utiv3+N7bbbbjFo0KAi+dltt92S9KgAAACAvKrRIGK/LhEdzo04/I8RB/eI2OPgiPTyyc6s7Pj+++/jsssuSzjWvHnzuPfee0s4o/xr2LBhfPzxx9G3b98oV65ckcQ8+OCDY+rUqXHyySfnec3o0aNj7dq1Ofrr1KkT7dq1K1Q+9evXz3Ff8zddu3YtVOyIiJNOOilh//Dhwwsdu6zYc889E/avWrUqVq5cWcLZ/J8ddtgh3nnnnbjrrruifPmiK24HHnhgfPrpp9GhQ4ciiVe5cuV4+eWXY/DgwVGrVq0iiVm/fv0YM2ZM3HbbbUUSryg0bdo03n///WjWrFnC8YkTJ8Zhhx0W8+fPTzi+PdeJ0lKrobjMnDmzSOK0b98+Jk2aFPvtt1+RxIsoO2dJcXv44Yfjn//8Z1SpUqXQsZo0aRKTJk2KK664oggyKxrb23UuqvdcYXz99dd5mpeWlhaPPfZYvPrqq9GoUaMi2Ts1NTUuu+yymDlzZrRo0aJIYm5JcdSmLUlLS4sRI0ZE7969CxWnatWqMWLEiDj//PNzjJUrVy5GjhwZf/rTnyIlJaXAe6SlpcXAgQPjwQcfLESmJevGG2+MYcOGRc2aNQsdq2vXrvHhhx/m+n0qP8pKHWvXrl3MnDkzjj/++ELHqlixYgwYMCAGDx6c8HesSpOycn2KSs+ePeOtt96Kpk2bFlnMKlWqxMMPPxyvvfZaVK1atcjiFlZp/hz7m7J+lt5zzz3xzDPPROXKlQsVpyhr7m+aN28e06dPj9NOO61I4h133HExefLkIrtOxa0oa3pqamrccsstMWbMmKhYsWIRZFe2lfVzo6Q//xZWQWp5Ud+rK4n7dGXtuuRHWa3HZfWeb1GdzRHFcz6X1ee1rNzXLK3fQSJKx/2u/1Xa3ytltXaWRqXhs0TE9n0GbC/3IACgIEr3n54AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADbvdmzZ0enTp1izJgxscsuu2T1N2zYMG699da49dZbY/PmzbFs2bKssV69ekWfPn0iJSUlYczFixfHUUcdFd98802u+/bu3Tt22WWXOOaYY7L66tevH9dff31cf/31ERGxfv36WL16dWzevDmqV68eFSpUyDXea6+9FmeffXZeH3bMnDkzLr744nj66aezHke1atWiV69e0atXr4iIWLt2baxatSpq1qwZ6enpCePMnj07jj322Fi3bl2e92brGjRoEBdddFGRxBo0aFDMnTu3SGIBAAAARath84iOF0bsvE/i8Y3rIqaMjnj/3xHrV5VsbmXRkCFDomvXrnH66afnGOvTp0+MHTs2Xn/99SRktnV77bVXvPHGG9GoUaM8zV+zZk2sX78+atSoEampqVucW6lSpXjhhRfiggsuiMGDB+cp9rhx46J79+45xk466aSYNGlSnnJMpGvXrrneV23atGnsueeeW7yvujUnnXRSjr6VK1fGa6+9VuCYZU2i6xYRMWXKlBLO5P/Url07JkyYEC1atMjT/DVr1sTatWujQoUKUbVq1a3Or1u3bowcOTL233//mDdvXoHzrFOnTowbNy4OPPDAAsfITUpKSvTr1y/KlSsXN954Y5HHz4+DDjooxo0bF7Vr1044/uKLL8YZZ5wRGzZsyDXG9lonSlOthuLy+eefFzpGkyZNYuzYsVGtWrUiyOi/yspZUtwGDhwYV1xxRZHGTEtLi4cffjiqVasWd911V5HGzq/t8ToXxXuusL766qutzqlYsWK88MILcfzxxxdLDo0bN45JkybFiSeeGG+//Xax7FEctWlrHnvssTjxxBOLLN6gQYNizpw58e6772b1Pf/880V6Xa655pr49ttv49FHHy2ymMWhT58+ceeddxZpzL333jvGjx8f+++/f7bfEcqPslLHOnXqFCNHjozKlSsXOEYi55xzTqSkpMQ555xTpHGLSlm5PkWlZ8+e8eSTT+b6/ep/bdy4MVatWhWZmZlRqVKlqFSp0lbXHH300TFhwoQ44ogjYtWq5N+4LK2fY39T1s/Sfv36Zf1OY1Eoipr7m9atW8cbb7wRtWrVKprk/r899tgj3nrrrdh///2LNG5RK66afuyxx8bo0aOz/X7r9qasnxvJ+PxbWPmt5cV1r64479OVxeuSV2W1HpfVe75FfTZHFO35XFaf17J2X7O0fQf5TWm43/Wb0v5eKau1s7QqLZ8lIrbPM6Bnz55bfV4ito17EABQEIn/djYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEApMnPmzGjVqlU88sgjceaZZ0ZKSkq28bS0tKhdu3ZWu0KFCrnGGjVqVFx88cUxf/78Le65YcOGOP7446N///5x3XXXRfny5XPMqVChwhb3iojYuHFj3H777XH33XfHpk2btjj39wYPHhxr1qyJQYMGxQ477JBjvFKlSlGpUqVc148cOTJ69uwZixcvzte+AAAAAEQcen5E29O3PKdcxYiDT43Yp2PEi3+J+HVOSWRWtl166aXRvn37aNSoUbb+lJSUeOaZZ6J58+axZMmSJGWXWK1ateK1117LkfP/+uSTT+Lf//53jB8/Pr755ptYu3ZttvUHHHBAdO7cOc4777yoW7dujvWpqanx5JNPxty5c+Pdd9/dak7Dhg2L7t275+g/8cQT47rrrsvjI8vphBNO2OL48ccfHwMHDixQ7ObNm8duu+2Wo3/06NGxfv36AsUsa/baa6849dRTE4699NJLJZzNf6WkpMTQoUOjRYsWuc5544034oUXXoj33nsvZs2aFRs2bMgaK1euXDRu3DgOP/zwOOecc+LQQw9NGKNmzZrx0ksvRZs2bQp0vStUqBCjRo2KAw88MNc5mzZtinfffTfGjh0bH3/8cfz666+xePHiSElJiRo1akSTJk3i0EMPjTPOOCN23XXXhDH69u0bX3/9dTzzzDP5zrEodO7cOV588cWoUqVKwvEnnngievXqFZmZmVuNtb3VidJYq9l+zJs3L95+++1cx+vUqRPNmzfP0b9o0aKYOXNmvvaaMWNGftPLJj09PUaMGBHVq1ff6tzNmzfnqd6UlbOkuJ133nlx5ZVX5uhfv359vPrqqzF27NiYMmVKzJ8/P9asWRNVqlSJevXqRZMmTeLYY4+N4447LurUqZNr/DvvvDO++eabGDZsWHE+jFyVputcGt5zP/zwwxZzaNy4cTRu3DhH/3fffRdz587NVw4fffTRVuc8++yzcfzxx+c6npGREe+++26MGjUqPvnkk5g/f34sXrw4KleuHPXr14899tgjunTpEscff3y23734X9WrV49Ro0ZF+/btY/r06fl6DFtTHLVpa04++eS4+OKLc/TPnj07nn766Zg4cWJ89913sW7duqhZs2bstNNO0bFjxzjttNOiWbNmuT6Of/7zn9G8efPYsGFDXH311Qk//y9ZsiSGDBkSr776anz11VexYsWKqFKlStSvXz8OOOCAOOmkk6Jz58655v7AAw/E22+/HZ9//nnBn4Bi1K5du3jwwQdz9GdkZMRbb70Vr7zySnz66afx008/xerVq6N69epRt27daNWqVRx33HFx/PHHR3p6esLYu+22Wzz//PNx3HHH5Tuvkq5jrVu3zneOEf/93jhixIioXLlyrnPWrVsXb7zxRowdOzamTZsWCxYsiKVLl0b58uWzauBRRx0VJ598ctSsWTPb2rPPPrvI38NFoTSdMyVh9913j0ceeSTH78D95vvvv49nn302XnvttZgxY0YsW7Ys23ilSpWiadOm0b59+zjllFPiiCOOSBjnwAMPjEGDBsUZZ5yRcLw0nKl5VdxnRVk+S48++uj4y1/+kjDnrdXdRx99tFhq7m922mmnGDduXNSqVSvXOWvXro033ngjRo0aFV988UVWTfvtud1ll13i2GOPjW7dukX9+vWzrd1zzz3jn//8Zzz00EMFzrE45aWmr1+/Pt58880YM2ZMTJ06NV81vVOnTvHggw8m7TtCMpX1c6Moa1ppreVFea8u0b3M4rhPl4zvJSWlrNbjsnrPtzBnc3F+J/pNWX1eS/t9zX/84x8J1+f1LCmt9bw4lfb3SlmtnflVWl97ZbVWldbX9W/3IRIpqXsQAFDaJT6BAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASpmlS5fG2WefHffee2/06tUrevToEXXq1MnT2oULF8bYsWPjkUceiU8//TTPe27evDluuummGDRoUFx66aVxxhlnxC677JKntYsWLYpnnnkmHn/88ZgzZ06e9/y9F154Id59993405/+FOedd95WH3NGRka8+eab8cADD8T48eMLvC8AAADA9qzzFRGtjs/7/Gp1I854MGLotRG/FvxW0HZh+fLlcc4558Rbb70Vqamp2cZ23HHHePLJJ6N79+5Jyi6x//znP9G4ceOEY3Pnzo2rrroqRo4cmev6JUuWxOuvvx6vv/563HrrrdGnT5/o379/pKenZ5tXrly5GD58eDRt2jSWL1++xZxGjx4da9eujUqVKmXr33PPPWOfffaJL7/8Mm8P7n9UqFAhjjrqqC3O6datWwwcODDfsSMiTjrppIT9w4YNK1C8sqZ69eoxZMiQqFixYo6x1atXx3PPPZeErCKuuuqqOProoxOOffjhh3HJJZfEtGnTcl2/cePGmD17dsyePTsGDRoUxx57bDz33HNRu3btHHNbtWoVF110UTz66KP5zvOJJ56INm3aJBzLzMyM4cOHx8033xyzZ89OOGfBggUxe/bsGDt2bNx8881x8cUXx/333x9VqlTJMfdvf/tbvPPOOzF37tx851kYZ5xxRjzzzDNRrly5hOO33npr9O/fP8/xtrc6URprNduPwYMHx+DBg3MdP+GEE+KVV17J0T9p0qQ4+eSTizO1HHr37h0tWrTI0b9kyZJ46aWXYvTo0TF9+vT49ddfY/Xq1XmKWVbOkuLUoEGD+POf/5ytLyMjIx577LG48847Y/78+TnWLF68OL7//vv45JNPYujQoVGpUqW44oorom/fvrHDDjsk3Oepp56KTz75JL799tvieBhbVJquc2l4zw0fPjyGDx+e63i/fv3itttuy9H/7LPPxi233FIkOfzvXqeeemqu46NHj44bbrghPv/884Tj33//fXz88cfx73//OypWrBh9+vSJvn37Ro0aNXLMrVq1aowePTr222+/WLp0aZE9huKoTVtSuXLleOSRR7L1LV++PK666qp45plnIjMzM9vYokWLYvbs2TFx4sS4/fbb4+KLL46//vWvOT5nRUQ0adIkLr300hg1alTcc8892cYyMjLigQceiNtvvz1WrVqVY4/vvvsuPvroo3j88cejQ4cO8dRTT8Wee+6ZY4+KFSvGQw89lOt7MtkGDRoUaWlp2fpefPHF6Nu3b8yaNSvH/MWLF8fcuXPjo48+in/84x/RpEmTGDhwYHTp0iVh/C5dusTZZ5+d7+9QJV3HCqJcuXLx0ksvJXz/Rfz395iefPLJ6N+/f/z8888J5/zyyy8xY8aMGDp0aFxxxRVx+eWXx1/+8peoXLly1pzbb789fv311wLlWFxK0zlTEv76179muya/+e131QYMGBAbN27Mdf3atWtj6tSpMXXq1Hj00UejdevW8cQTT8RBBx2UY+7pp58ew4cPjxdffDHHWGk4U/OqOM+KsnyWVqpUKQYNGhQpKSnZ+vNadydMmFAsNTciIjU1NYYPHx7169dPOP5bTbv55ptj0aJFCef89tyOGDEi0tPT4/LLL4/bbrst23Pbo0ePmDlzZr7zK255qelPP/10/OUvf4kff/wx4Zy81PQrr7wyfvrpp2J5DKVZWT83irKmldZaXpT36pYsWVIi9+lK+ntJSSnL9bgs3vMt7NlcnN+JflMWn9eI0n9f84cffijUWVJa63lxKe3vlbJcO/OrtL72ymKtKs2v60T3IUr6HgQAlHapW58CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQesyYMSMuu+yyqFevXuyzzz5x9tlnR9++feO5557LmvPxxx/H1VdfHX/4wx9i3333jXr16sX5558fn376aYH2nDdvXtxwww2x6667xm677RYnnnhiXHPNNXH33XfHwIED4/HHH4/77rsv+vbtG+eee27svffeUbdu3bjuuutizpw5hX7Mv/76a1x33XVRr169OPjgg+PCCy+MO+64I2vvBx98MP785z/HiSeeGHXr1o3OnTvH+PHj871Pt27dIiUlJW677bZC5/y/+vbtGykpKVk/V199dZHGL4l9BwwYkC1WUf589NFHRfioAQAAgMLar0tEq+Pzv658xYjut0VUrFr0OW1rJk6cGA888EDCsZNPPjl69uxZwhnl7pxzzomjjjoq4dg777wTBx10UIwcOTLP8dasWRN33313dOrUKZYuXZpjvH79+nHXXXdtNc7q1avj1VdfTTh24okn5jmf/3XkkUdG5cqVtzjnsMMOi2rVqhUo/kknnZSjb0uPY1szadKkOPDAAxOO3X333bFw4cISziiiRo0accsttyQce+qpp6Jdu3Yxbdq0fMV89dVXo23btrF48eKE49ddd12kpqbmK2bnzp3jvPPOSzi2du3a+MMf/hCnnXZazJ49O0/xNm/eHI8//ngccsgh8csvv+QYr1q1atx+++35yrGwrrjiihgyZEiUK1cux1hGRkZceuml0b9//3zF3J7qRGmt1VDaVK5cOW666aZsfevWrYu77rordtttt7jooovi5Zdfjm+//TZWr16dp5hl5Swpbn/84x+jRo0aWe3ly5dHp06d4oorroj58+fnKcbatWvjvvvui1atWsX06dMTzqlcuXIMHDiwSHLOD9e59GrRokWu12bjxo1x4YUXRrdu3eLzzz/PU7x169bFvffeGy1atMj1ddioUaMYMGBAgXP+veKoTVvTs2fP2HnnnbPa3377bbRu3TqefvrpyMzM3OLazMzMeOKJJ+Kkk06KDRs2JJzTp0+fuOuuu6J8+fJZfWvXro0uXbrE9ddfH6tWrdpqjpMmTYqOHTvG3LlzE44fddRR0bRp063GSYZmzZpl/ffGjRvjvPPOi1NOOSVmzZqVp/WzZ8+O448/Pv7+97/nOuf666/PV07JqGMFqWFXX311tufvfy1ZsiSOPvrouPTSS+Pnn3/OU7w1a9bE/fffHy1btsz2falChQqxyy675Du/4rK9nTO1a9eO4447LuHYaaedFvfee29s3LgxXzGnTJkS7dq1i+effz7h+F/+8pf8plmqFOdZUdbP0p49e8auu+6aLef81N3iqLm/+eMf/xjt2rVLOLZy5cqsmrZo0aI8xdu0aVMMHDgw9t133/j666+zjf35z38uUI7FaUs1ffny5XHcccfFRRddFD/++GOe4uVW01NSUqJfv35FknNZUdbPjWR8/i1pRX2vriTu023L16Ws1uOyes+3sGdzRPGez2X1eS0L9zVL83eQ0qi0v1fKau3cVpTVWlVaX9e53YdwDwIAsvNpHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKJMyMzPjq6++iiFDhsQ999wT999/f9bYe++9Fw899FAMHz48vvjiiyLdd968eTFy5Mj461//GjfeeGNcddVVcdlll8X1118f99xzTzz77LPx9ddfF+mev8nMzIyPP/44/vWvf8Utt9yStfd1110X999/f4wcOTKWLFlS6H2qVq0aERFr164tdCwAAACAsqR85YjDLij4+mp1ItqeWXT5bMtuuummmDJlSsKxhx9+OPbYY48SziinSpUqZbvv+L+mTJkSnTt3jsWLFxco9jvvvBNnnnlmZGZm5hi75JJLYpdddtlqjGHDhiXsP+mkkwqU0wknnLDVOeXKlYvOnTvnO/bOO+8cBxxwQI7+MWPGxLp16/Idryxp3bp1PPbYY9GiRYuE42+88UbcfffdJZzVf6WlpcUzzzyT417wqFGjomfPnpGRkVGguLNnz45LLrkk4Vjjxo2jW7du+crxscceSzi2du3aOPzww+OFF14oUJ6ff/55dOrUKVauXJljrFWrVlGxYsUCxc2vO+64Ix5++OFISUnJMbZ+/fro0aNHPPHEEwWKvT3UidJeq6E0Oe2006JOnTpZ7QULFsThhx8eN910U6xYsaJAMcvCWVIS/vfMWLNmTRx55JHx9ttvFyjWd999F+3atYsPP/ww4XjXrl3jiCOOKFDsgnKdS68nnngi0tPTc/Rv3Lgxjj322PjXv/5VoLg//PBDtGvXLt55552E4+eff3506NChQLF/rzhq09bsuOOOWf+9aNGiOOKII2Lu3Ln5ijF+/Pi49957E47tvvvucfrpp2e1MzIyonv37jF+/Ph87fHzzz/H2Wefnev4ZZddlq94JS0jIyNOOeWUGDx4cL7XZmZmRq9eveKNN95ION68efM45phj8hwvGXUsvzWsZs2a0a9fv4RjS5YsiTZt2sSECRPynWNExJw5c6JDhw4xb968Aq0vbtvbOdO1a9eEtXvo0KExYsSIAsfdtGlTnHPOOTFx4sRs/ePGjYs+ffoUOG5pUJxnRVk/S3faaaes/y5o3S3qmhsRUa1atbjzzjsTjq1cuTKOPPLIAte0n376KQ499ND48ssvs/qqVKlSoFjFZUs1ffny5dG2bdt8fy74TaKa/tvve24vyvq5kYzPvyWpuO7VFfd9um31upTVelyW7/kWxdkcUTznc1l+XsvKfc3S+h2kNCrN75WyWju3FWW5VpXW13Wi+xDuQQBATqnJTgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDSpX379hER8dNPPyU5EwAAAICS1fzoiErVCxej1fER6RWKJp9t2aZNm+KMM86ItWvX5hirUqVKPP/885GWlpaEzP7PWWedFfXr18/Rv3z58jj55JNj/fr1hYr/6quvxt/+9rcc/WlpaXHllVdudf2oUaNi3bp1OfoPPvjgaNCgQb7z6dq1a7b2pk2bYuLEiTnmdevWLd+xTzzxxIT9w4YNy3esktCiRYs48sgj8/VzzDHHxCmnnBLnn39+9OvXL4YNGxZz586Nzz77LHr16pVwnzfffDNOPPHEyMjIKOFH+F9LliyJq6++Onbddde49957Y9WqVbF06dI477zzCh17xIgR8cknnyQc69SpU57jdO/ePfbYY4+EY5dddll89NFHBcrvN19++WX07t07q/3hhx/GiSeeGM2bN0/4/ipKqampMWjQoLjpppsSji9fvjw6d+4cL774YoH32B7qRGmv1VCa7Lnnnln/vXTp0mjbtm18+OGHhYpZFs6SktarV6/47LPPChVj9erVceqpp8aiRYsSjvfp06dQ8fPLdS6dOnbsGG3btk04ds0118Rbb71VqPirV6+OHj16xM8//5xw/MYbbyxU/N8UR23Kj/POOy++//77Aq295557YuHChVudd//998err75aoD0mT56c6+fBY445pkAxS8pNN90Uo0aNKlSMnj175vp57oQTTshznGTUsfzWsAsvvDCqVKmSoz8zMzPOOuusmD17doFzjIhYsGBBdO/ePTZt2lSoOMVheztncvuOO3jw4ELHzsjIiJ49e8aqVavi6aefjubNm8dxxx0XEyZMKHTsZCqus2JbOUt/U9i6W1Q1N+K/52vt2rUTjl155ZW5vi/zauHChXHGGWfExo0bCxWnuPTs2TNhTY+IOP/88+PLL78sVPzSXNNLQlk/N5L9+be4Fee9uuK8T7etXpeyWo+3lXu+pek7UUTZfl7L0n3N0vgdpLQrbe+Vslo7txVluVb9r9L0uk50H8I9CADIKTXZCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFA6pKSkxF//+tdo06ZNRESMGzcuyRkBAAAAlKw9Dyl8jHIVInZtVfg424Ovv/46rrvuuoRjBx98cPTr16+EM8ru8ssvT9g/cODA+O6774pkj/vvvz82bdqUo//ss8/e6trVq1fHq6++mqM/JSUlunXrlq889ttvv2jYsGG2vkmTJsVTTz2VY+7xxx8fKSkp+Yp/0kkn5ehbs2ZNqb0HecMNN8Sbb76Zr59XX301XnjhhXjqqafitttuix49ekTjxo0Txt+0aVPcfvvtccwxx8SaNWtK9sElsHDhwrjhhhtil112ia5du8bSpUuLJO4//vGPhP2HHnponmNcddVVCftHjhwZTz/9dAGyymnw4MExcODA6NixY7Rp0yZGjhxZJHG3pHz58vHCCy/ERRddlHD8l19+icMOOyzeeeedQu2zPdSJ0l6robS64IIL4ttvvy2yeKX5LClJ77zzTgwePLhIYv34449x7bXXJhzr1q1b7LzzzkWyT364zqVLbt+lxo8fH3/729+KZI8FCxbEhRdemHCsS5cusc8++xTJPr8p6tq0NSNHjoyxY8cWeP2aNWti2LBhW5zz888/R//+/Qu8R0TEv/71r4T9e+21V+ywww6Fil1cpkyZEvfdd1+h4/zwww8xYsSIhGMdOnTId7ySrGP5rWG9evVK2P/0008n/ExfEFOmTIlHHnmkSGIVh+3lnNlpp50S9hdV/fv222+jQYMGccEFF8Tnn39eJDFLk6I8K7als7Qo6m5R1tzevXsn7B83blyR3c+ZNm1akZw1xSG3mj5kyJB4+eWXi2SP0l7TS8K2cG6U9OffklDc9+pK4j7dtnRdymo93hbu+ZbG70TbwvMaUTbua5a27yClWWl8r5TV2rmt2BZqVWl7XSe6D+EeBADklJrsBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEi+HXbYIUaPHh1XXXVVRER8//330b9//+QmBQAAAFDCau9SRHEaFU2c7cFjjz0WY8eOTTh20003Rdu2bUs4o//addddo1WrVjn6V69eHQ899FCR7fPDDz/EuHHjcvTXr18/DjjggK2uHzZsWML+k046KV95dOvWLUffK6+8EmPGjImMjIxs/XXq1IlDDjkkz7GrV68ehx9+eI7+sWPHxpo1a/KV57Zgzpw50bx58+jXr19s3rw52elks3Tp0pg8eXKRxZswYULC/pYtW0b58uW3ur5Bgwa51oB77723ULn93lVXXRXvvPNOkcbMTfXq1WP8+PFx8sknJxyfPXt2tGvXLqZPn14k+23LdaKs1GoobUaMGBGvvPJKscQubWdJSSvqP199/vnn45dffsnRn5qaGscdd1yR7pUf2/t1Lg2qV68exx57bMKxu+++u0j3evXVV2PatGkJx3r06FFk+xRnbcrN7bffXugYL7744hbHBw4cWOjvPePHj4/Vq1fn6E9JSYmDDjqoULGLS79+/XJ8Riyof/3rXwn7mzdvHjVq1ChQzJKoY/mpYU2bNo3dd9894diDDz5YqNx+7+67744NGzYUacyitq2fM7ntmZmZWWR7JKoZ24KiPCu2tbO0qOpuUdTcpk2bRtOmTROO3XnnnQXOLZGBAweWuprWtGnT2GOPPRKObY81vSSU1XMjGZ9/i1tJ3Ksr7vt029J1Kav1eFu551vavhNtK89rWbmvWdq+g5Rmpe29UlZr57ZiW6lVpe11najuuAcBADmlJjsBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAojB//vy49dZb49Zbb41x48YlO50yp2XLlnHMMcdERMTnn38ehx56aCxatCjJWQEAAACUrMo1iihOzaKJs7244IILYsGCBTn609LSYsiQIVG1atUSz+noo49O2P/GG2/E0qVLi3Svd955J2F/x44dt7p21KhRsW7duhz9nTp1iipVquQ5h27duiWMvWjRonj//ffzND83xx13XJQrVy5H//Dhw/McY1uyxx57xJtvvhm33HJLvq5RWfTNN9/E8uXLc/SnpqZGrVq1trr+2GOPjZSUlBz9n332WUyePLlIcixp9evXj4kTJ+b6/v7kk0+iXbt2MW/evCLbc1uuE2WlVkNp89BDDyU7hTwr7FlSkubNmxdvvvlmkcbctGlTDBo0KOHYscceW6R7JVNZus6lRefOnSM9PT1H//Tp0+Ptt98u8v0GDBiQsP+EE04osj1KujZNnz49Pvnkk0LH+eyzz3Idy8zMjKeffrrQe2zcuDFmzpyZcKxx48aFjl/U5s2bF6NHjy6yeB988EFkZGTk6E9NTY3ddtutyPYpjER1LD81rHPnzgn733nnnfj8888Lnd//WrhwYbz00ktFGrO0K23nTG7fVXbfffcSzqTsKcqzYls6S4uy7hZFzc3tc+q0adPivffeK1R+v7dw4cJ48cUXizRmYeVW0z/44IOYMmVKke61Pdb0klBS50ZZ+m6eVyV1r64479NtS9elrNbjbeGeb2n8TrQtPK8RZec9Wtq+g5RWpfG9UlZr57ZiW6hVpfF1nei5cw8CAHJKTXYCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/j737jrKqvBoHvGeYoSMlCigWFAQBJYiI5ZNii1QFg4ldo0msn6JJNGosIf7EEqMxRo2JMVnGhiV0KUYM2FEEIjYU7NKkl2GAmd8fWfKFzB1hZm6f51mLtZj9nrPffe+5Z7/nvpkgAAAAQDIsWbIkRowYESNGjIgpU6ZkupycM3369Lj22mvjsccei0MPPTQ++eSTTJcEAAAAkHalJUnKsz45eWqLJUuWxDnnnJNwbO+994677747zRVFHHHEEQnjkydPTvpcr7zySsJ4586dt3vu2rVrE9ZUr1696Nev3w7N36pVqzj44IO3ib3zzjvx4YcfRkTE2LFjK5wzaNCgHcodETFkyJAKsZKSkpgwYcIO58g3bdq0iREjRsSHH34Y3//+9zNdTkp98cUXCeMtWrTY7rmV3Ye5+r8B7LPPPvHiiy9Gt27dEo5PnTo1+vbtG8uWLUvqvPncJ3KlV0M2eeedd+KFF17IdBlVUpO1JJ1StT5NmzYtYfy/+3Kuy5XrnC369u2bMJ6KNfCb8nbv3j0aNmxY4/yZ6E2TJk1KSp6VK1dW+vmdO3duLFmyJCnzzJs3L2G8WbNmScmfTOPHj09qvnXr1sV7772XcCybekSiz8GO1nfIIYckjFe2BtTUxIkTU5I3m2XTOvPll18mjJ966qlpriS3JHutyKe1NJl9Nxk999BDD00YT/b68LVs22Ps2bNnwvg//vGPlMxXG3t6OqR63cjF7+Y7Il17danap8u365Kr/Tgf9nyz8TtRPryvuXaPZtN3kGyVjfdKrvbOfJEPvSobP9eJ9iHsQQBARYWZLgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDsMHLkyDjllFNi7dq1mS4FAAAAICPWLM2uPLXJhAkT4g9/+EPCsbPOOiuGDRuW1no6duyYMP7yyy8nfa5FixZVqYb/NmrUqITxIUOG7ND5AwcOjIKCgm1i48aN2/r3sWPHVjina9eusccee2w3d3FxcfTv379C/Jlnnol169btUH2ZsGrVqli0aFG1/ixZsmSHX1urVq3iscceizvuuCPFryhzVq1alTDeokWL7Z673377JYy/+OKLNaopE7797W/HSy+9FO3atUs4/uijj8aAAQNSdl/ka5/IpV4N2eKf//xnpkuospqsJen0wgsvpCTvzJkzY8uWLRXiu+++ezRo0CAlc2ZCrlznbNG5c+eE8VQ9Jy1evDgWLlxYIV5QUFDpM1tVZKI3JfN5obLnhNdeey3lczRv3jxpcyTL9OnTk57zs88+SxjPph6RqI/taH0dOnRIGE/Fc21Eaq5RtsumdaayZ4bTTz89Tj755DRXkzuSvVbk01qa7Hu6pj033fs5r776akryVpeenh9SvW7k4nfzHZGuvbpU7dPl23XJ1X6cD3u+2fidKB/e11y7R7PpO0i2ysZ7JVd7Z77Ih16VjZ/rRPsQ9iAAoKLCTBcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANngo1lJyvNmcvLUNpdddlm89957Ccfuv//+aNOmTdpq6dChQ8L4J598kvS5VqxYkTDerFmzHTp/7NixsXHjxgrxgQMHRp06dbZ7/uDBgyvExowZs/Xv7777bnzwwQcJ82/PkUceGTvttFOF+BNPPLHdczPpwgsvjF133bVaf1q1ahWNGzeOwsLCaNmyZRx55JFx2WWXRVlZWaXzDR8+PG6//fY0vsLUKSgoiN133z169+4dZ599duyyyy4Jj6tbt+52c3Xs2DFh/M03c6vJ9unTJ6ZPnx6tWrVKOL5+/fq45JJLYvPmzSmrIV/7RC71asgWr7zySqZL2K5kriXp9P7776ck77p162LhwoUV4gUFBdGuXbuUzJkOuXqds0Xnzp0Txt94442UzVlZ7spqqYpM9KbKvntWx9q1axPGk9kX1qxZkzDetGnTpM2RLO+++27Sc65atSphPJPPYjvSx3a0h+27774J43Pnzq1RjZX5+OOPE34/yCfZvM68/PLLsWTJkgrxwsLCePTRR+Phhx+OHj16pL2ubJfstSKf1tJk992a9tzKelqq9nPmz59f6VqcCZW9/tmzZ6dkvtrQ09Mh3etGLnw3r4507dWlap8u365LrvbjfNjzzcbvRPnwvmb7PZrN30GyVTbeK7naO/NFPvSqbPxcJ9qHsAcBABUVZboAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMgG8/4RcfB3IwoKqp/jk7kRa5Ymr6baZMOGDXHqqafGK6+8EsXFxduMNW/ePB566KE46qij0lJL8+bNE9a3fPnypM+1du3ahPEmTZrs8PmTJ0+O448/fpt48+bNo1evXvH8889Xem7dunXj2GOP3Sa2bNmyePnll7eJjR07Ni6//PJtYoMHD4777rvvG2sbMmRIhdjGjRtj3Lhx33hePigvL4+lS5fG888/H88//3w8+eSTcfPNN8dpp52W8PjLL788Xn311Rg1alSaK626Bg0axD777BP77LNPtGvXLtq1a7f1723bto169eolZZ4WLVokjC9btiwp+dNhyJAh8dhjj33je9KwYcN44IEH4oQTTkhZHfnaJ3KpV0O2mDt3bqZLiIj0rSXp9PHHH6csd2V9LVEfzCb5eJ2zxc4775wwnsrnpMpyV1ZLVWSiN3355ZdJy1XZc8KiRYtSPkdhYWHS5kiWzz//POk5V69enTCe6tefrj7WtGnThPGvvvoqKfn/W3l5eXz66afRvn37lORPl1xdZ7Zs2RI33nhj3HXXXQnHTz311Dj11FNj0aJF8frrr8e8efNi/vz58eGHH8YHH3wQn332WZorzg7JXivyaS1Ndt+tSc8tLCyMRo0aJRxL9XvbuHHjlOWvimbNmiWMp+r150tPT4dsWjey5bt5sqVrry5V+3T5dF1yuR/nw55vNn4nyof3NVvu0crWk6OPPjprv4Nkq2y7V3K5d+aLfOhV2fa5jvjmfQh7EADwf4oyXQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZIOlCyPeeT6i85HVO7+8POKff05qSbXOrFmz4vrrr4+bbrqpwtiRRx4ZP/nJT+L2229PaQ2NGjWKgoKCCvEGDRrEpk2bkj5forkiIurVq7fDOUaNGhXHH398hfiQIUPi+eefr/S8o446Kho1arRNbMKECVFeXr5NbOzYsXH55ZdXOLdBgwaxYcOGSvOfcMIJFWKTJ0+OtWvXVnpOvvrss8/i9NNPj7Fjx8bDDz8cRUVFFY658847Y8KECbFu3boMVFjRnnvuGd27d4+uXbtG+/bto127drHPPvtE69atUz53w4YNo7CwsEJ848aNsXHjxpTPnww//OEP47777os6deps99jjjz8+Lrjggrj33ntTVk++9Ylc7NWQDb766qu0zpfJtSTd1qxZk7LcK1asSBhv3Lhxyuasitp0nbNBgwYNEj5fbNy4MUpKSlI27/LlyxPGmzRpUuPc6e5NEZHUZ+6ysrKMzZGNUtEPU/36M9nHKnuu3bhxY5SWlqZs3tWrV6csd7Ll4zpz7733xoknnhh9+/at9JjWrVvHoEGDYtCgQdvES0pKYsGCBfHhhx/GBx98EPPnz485c+bE7NmzY/369SmuPHOSuVbk21qa7L5bk55b2WtZu3ZtbN68udp5t2flypUpy10VDRs2TNjTS0tLU7qflUs9PR1yYd3IxPNvqqVzry5V+3T5dF1ytR/ny55vtn0nypf31b5m/sm2eyVXe2e+yJdelW2f669tbx/CHgQARFT8TT4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqKWm3h3Ret+IFrtX/dwZf4n48t2kl1Tr3HzzzdG/f//o1atXhbGbbroppk6dGnPnzk3Z/A0bNqx0rKioKGXz1sTYsWNj48aNUa9evW3iJ5xwQgwfPrzS844//vgKsTFjxlSIvfDCC7FixYpo3rz51lj9+vXj6KOPjvHjxyfM3aNHj9htt90qxJ944olK66kNRo0aFY0bN44HHnigwtiuu+4ap512Wtx///0ZqOzfunbtGmeeeWZ8//vfj913r0YjTJJGjRoljK9evTrNlVTfH//4xyod/5vf/CZmzJgRb731Vkrqybc+kYu9Oh+Vl5cnjBcWFqa5ksrnrKzG2mrlypUpnyNb1pJ0W79+fcpyV7b+NW7cOGVzbk9tvc7ZIFPPSZX1jyZNmqQsdypt2rQp5XOUlpamfI5slI73NhmypY9V9lyb6ns6letWMmTL9UmVzZs3x5AhQ2LKlCnRs2fPKp1bv3796Ny5c3Tu3HmbeFlZWbzwwgvxt7/9LR555JFYt25dMkvOuGSuFfm2lmZT3/3vPYevpfrzmC37RZV9tlatWpXSebO9p6dDrq0bmXj+TbV82KvLp+uSq/04Hz5HEdm1Nkfkz/tqXzP/ZNu9kqu9M1/kS6/Kts/1177eh6hqL62texAA1E7p/y0XAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMhSG9dFPHltxPLPqnbea09GvPJ4amqqbcrLy+P000+PVatWVRirW7duPProo1GvXr2UzV9QUJCy3KmyZs2amDJlSoV427Zt44ADDqj0vEGDBm3z88aNGxPm2bJlS0ycOLFCfPDgwZXmHjp0aIVYaWlpjB07ttJzaos///nPMX369IRj55xzTpqr+be99947Ro0aFXPmzImf/OQnsfvuu2ekjq9Vdh9u2bIlzZUk17Rp02LQoEFRVlZWYax+/frx2GOPRf369VMyd771iVzs1fmopKQkYbxx48ZpriSiSZMmCeMbNmxIcyXZbc2aNSnLnW1rSbqVl5enLHdl618memFtv87ZoLCwMGE81c9JqfwcprI3ZVIq+wLVl219LFPffTZv3pzS/NWVbdcnlVatWhVHHHFE3HnnnUm5HoWFhdG7d++4//7748MPP4wf/ehHSagyeyRzrcjHtTTbpXpNTLTPkgl6evrl6rqRj8+/+dDL8vG6/Lds78f58DnKRvnyvtrXJFOyvXfmi3zpVdls1apV9iAA4Bsk3jUGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgFpq5ZcRDw2PeHtaRHn5Nx+7dnnEuFsinv9TWkqrNT755JO48MILE4517tw5brvttjRXlP1GjRqVMH7CCSckjHft2jX22GOPbWLTpk2LdevWJTx+zJgxFWKDBg2qtJ5E806dOjVWr15d6Tm1yT333JMw3qNHj2jQoEFaa+nXr1/Mnj07TjrppGrn+Oqrr+KVV16Jhx56KK699to4+eST46CDDooXXnghiZXmtieeeCL69esXEyZMiJEjRyY8pkuXLnHHHXekrAZ9gmQrKSlJGG/atGmaK6l8zg0bNqS5kuxWvr2H22qyltQOrjOpkqreBP9NH8tutfH6bNq0KS677LLo2LFj/OlPf4oVK1YkJW+rVq3i/vvvj1GjRkX9+vWTkjPTrBW5obLrVFhYmNJ5i4uLU5qf7JTL64aelp3y6brox+SjbN/XzJXvIFRO76Q2sAcBAJUrynQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJBtNq6NGH9LxGtPRHQ+OqLtgRFNdo4orh+xfmXEso8jPnglYt6zEZs2Zrra/PTII4/EoEGD4pRTTqkw9r//+78xYcKEmDx5ctLnLS8vTxhfuXJlPPbYY0mfrzKrV6+u0vFjx46N0tLSqFu37jbxIUOGxI033ljh+MGDB1eIjRkzptL8kyZNik2bNkVxcfHW2G677RbdunWL2bNnb3Nsu3btokuXLhVyPPHEE9t7GbXGM888kzBep06d6Nq1a7z66qtpqWPQoEExevToqFOnznaPXb16dbz33nsxf/78mD9/frz//vtb/75y5cqE55SUlFSrrrKysoTxoqKiauXLtLvvvjsuueSSrf3l+uuvj6OPPjoOPfTQCseef/75MXny5Bg9enTS68inPpGrvTrffPXVVwnjTZs2TXMlEc2aNUsYr6xGkidb15J0Ky4ujk2bNqUk93/37a9t2bIlJfMl4jpnj8que6qfk/5zff9P6fwcQk1kax+r7B6q7J5LllTnr6psvT7psmDBgvjRj34UF1xwQfTu3TsOPvjg6N69e3Tq1CnatWsXDRs2rFbek046KZo0aRIDBgyo9DtUbWQtTZ3169cnjKf6O2Jl3wfTLVP7WdnW079JQUFBUvLU9nUjG2XDXl1t36f7T7naj7PhcxSRf58l72vlUrmeWEtyT672znyhV6WPPQgASCw3fyMNAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANJgyYJ//yEzLrjggvif//mf2HPPPSuM/eUvf4kDDjggli1bltQ5S0pKEsbXrl0bF1xwQVLnSqbVq1fHlClTYtCgQdvEDzrooGjTpk18/vnn28QHDx5cIcf48eMrzb9mzZr45z//Gcccc8w28UGDBsXs2bO3iZ1wwgkVzt+0aVOMGTNmey+j1li9enWsXLkymjVrVmFsl112SUsN++yzTzz88MNRp06dhONLliyJJ598MqZOnRqvv/56fPbZZ1Weo6CgoFq1VXYfNm3atFr5Munqq6+OkSNHbhPbsmVLnHrqqTFnzpxo0qRJhXP+/Oc/x8yZMyvctzWVT30iV3t1vqnsM9qqVasoLCyMsrKytNRRp06daNmyZcKxZN9HbCub15J0a9q0adKfS7+W6Hkh4t89Lx1c5+xS2XWv7HOSLC1atEgYX716dUrnhWTI5j62bt26hPFUf/dp1KhRSvNXRTZfn3TbvHlzPPfcc/Hcc89tE2/dunW0b98+2rdvH/vuu+/Wv3fo0CEaN278jTn79esX119/fdxwww0prDy3WEtTZ926dVFeXl7hnqtXr17Ur1+/0u/yNdW8efOU5K2qyj5btamnb0+DBg1qnMO6kZ3s1WWXXO3HPkep4X1NLNXribUk9+Rq78wXelX62YMAgG0VZroAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBEVq1aFWeccUaUlZVVGGvdunU88MADSZ9z/fr1UV5eXiHeokWLpM+VbKNGjUoYP/7447f5uWXLltGzZ89tYm+++WZ89tln35h/zJgxFWKDBw+uEBsyZEiF2D/+8Y9YuXLlN+avbZYuXZow3qxZs7TMf9NNN8VOO+1UIb569eq44IILYvfdd4+LLrooRo8evd3PRmUaN25crfMquw+Li4ujQYMG1cqZbps3b45zzjknRo4cmXB84cKFcdFFFyUca968eTzyyCNRWFiY9LrypU/kcq/OJwsXLkwYb9CgQXTu3DltdXTp0iXq16+fcKyyGkmObF5L0i2V63dludeuXZuyOf+T65xdNm7cGJs3b64QLyoqikaNGqVs3ubNmyeMr1mzJmVzQrJkcx8rKSlJuOdRVFQUDRs2rFbOHdG0adOU5a6qbL4+2WLRokXxwgsvxF/+8pe45ppr4vvf/34cdNBB0aRJk2jXrl1ccMEF8a9//avS86+44opo1apVGivObtbS1Fq2bFnC+K677pqS+erWrRu77LJLSnJXVWU9vbi4OKU9PZXfRerUqZPUfE2aNKlxDutGdrJXl31ysR/7HKWG9zWxVK8n1pLclIu9M1/oVdnDHgQAtVXyf0MLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBJpk+fHrfddlvCseOPPz5+9KMfJXW+LVu2xNKlSyvEGzZsGPXr10/qXMk2ZsyYKC0trRAfOnToNj8PHDgwCgoKtomNHTt2u/nHjRtXIXbwwQdHq1attv78rW99Kw4//PAKx40aNWq7+WubLVu2JIwXFhamfO699947TjrppArxkpKSOOaYY+K+++6LTZs21XienXfeuVrnlZWVxeLFixOO/efnLZsNGTIkHnzwwW885qGHHorHHnss4Vjv3r3j6quvTnpd+dIncrlX55MPP/ww1q5dm3CsZ8+eaavj4IMPThhfv359fPDBB2mro7bJ9rUk3Vq3bp2y3JWtfcuWLUvZnF9znbPT559/njCeys9hZbkXLVqUsjkhGXKhj6X7u0+dOnVijz32SEnuqsqF65PtFixYEPfdd1907dq10u+QDRo0iB//+Mdpriy7WUtT5913300YT9V3xAMPPDCKi4tTkrs6KntGb9myZUrmKyoqSkpPr2yfskmTJjXO/Z/23HPPGp1v3che9uqyTy72Y5+j1PC+VpSO9cRakptysXfmC70qN9iDACCfpf639QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAauAXv/hFvPnmmwnH7rzzzth3332TOt8nn3ySMH7AAQckdZ5kW716dUydOrVCvG/fvrHTTjtt/Xnw4MEVjhk7dux283/88ccxd+7cbWIFBQXRv3//bXLXqVNnm2M2b94cY8aM2W7+2qa4uDhhvKysLOVzDxgwIAoLCyvE77nnnpg5c2ZS5igoKIhWrVpV+/yPP/44Yfyggw6qds50mjBhwg4dd95551X6Wm+44YY4/PDDk1lWXvWJXO3V+WbWrFkJ4717905bDb169UoYnzVrVpSXl6etjtomF9aSdOrRo0dK8rZq1SratGlTIb5ly5b48MMPUzLnf3Kds9Pbb7+dMH7IIYekbM6ePXsmjM+bNy9lc0Iy5EIfe//99xPGU7W2tG/fPoqKilKSu6py4frkkpEjR8Zvf/vbhGP9+vVLczXZzVqaOu+8807C+BFHHJGS+Q499NCU5K2udPf0fffdt8IeS3WsWLEiYbxp06Y1zv2fOnToUKPzrRvZzV5ddsnVfuxzlBre122lej2xluSuXO2d+UKvyi32IADINxW/IQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZJHNmzfHKaecEhs2bKgw1rBhw3jkkUeiqKgoafPNnTs3Ybxnz55JmyNVRo0aVSFWXFwc/fv3j4iIunXrxrHHHrvN+Oeffx6zZs3aofzjxo2rEBs8ePDWvw8ZMqTC+LRp02L58uU7lL82admyZcL42rVrUz537969E8Yfe+yxpM3RrVu3aNy4cbXPnz17dsL4YYcdVu2c2Wj16tVx2mmnxZYtWyqM1alTJx555JFo2rRpUufMlz6Ry706n0yZMiVhfNiwYdGkSZOUz7/TTjvFsGHDEo5VVhvJkQtrSTqlan069NBDE8YXLlwYmzdvTsmc/8l1zk5vvfVWwvgRRxyRkvnatWsXrVq1qhDftGlTzJ8/PyVzQrLkQh977733EsYPP/zwauf8Jn369ElJ3urIheuTa2644YYoLS2tEO/Ro0cGqsle1tLUmTZtWsL4iSeemNT926+dcsopSc9ZE+nu6UceeWRS8qxYsSJhvG3btknJ/7WarkHWjexmry675Go/9jlKDe/rtlK9nlhLcleu9s58oVflHnsQAOSTwkwXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwPe+991785Cc/STjWo0ePuOGGG5I218yZMxPGjzzyyKTNkSpjxoyJ0tLSCvEhQ4ZExL9fQ+PGjbcZGzduXJXy/7fvfOc7UVxcHPXr14/vfOc7FcZHjRq1w/lri1133TWaNGmScOzzzz9Py/yJvPvuu0mb46ijjqrR+a+88krC+IABA2qUNxu9+OKLcdNNNyUc22uvveKPf/xjUufLlz6Ry706n0yYMCFhvFGjRnH66aenfP4zzjgjGjVqlHCsstqyRZ06dTJdQo3kwlqSTkcddVTUrVs36XkrW/deeOGFpM+VSD5d51y/5/7T1KlTE8YHDRqUktf59TPCf5s+fXps2rQp6fNBMuVCH5sxY0bCeP/+/WuUtzKDBw9OSd7qyIXrk2tWrlwZs2bNqhCvW7du7LTTTkmZIx/WVGtp6kydOjXKysoqxHfbbbf47ne/m9S5unXrFoccckhSc9ZUZc/p/fr1S8l8Q4cOTUqe5cuXJ4x37949Kfkj/t07avo+WDeSJxW9zl5ddsnVfuxzlBre122lej1J51qSD8/m2SRXe2cmeJYgIj17EACQLoWZLgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYEfce++9MXHixIRjV111Vey1115JmWfy5MkJ48cff3y0bNkyKXOkyqpVq+LZZ5+tEO/fv38UFRXF8ccfX2Fs7NixO5x/5syZsWjRom1ijRs3jj59+sR3vvOdaNCgwTZjW7ZsidGjR+9w/tpi6NChCeNlZWXx7rvvpnz+5s2bJ4yXlJQkJX9BQUH8+Mc/rlGOSZMmRXl5eYV4p06d4uijj65R7mz0y1/+Ml5++eWEYyeddFKcc845SZsrX/pELvfqfDJ79uz417/+lXDsiiuuiMaNG6ds7saNG8fPfvazhGPz5s2LWbNmpWzuqli3bl3CeJMmTdJcSXLlwlqSTjvvvHOccsopSc3ZokWLOOOMMxKOTZo0KalzVSYXr3O+3nP/6fnnn4+1a9dWiO+xxx4xbNiwpM5Vp06dGD58eMKxqjwfQKbkQh+bOnVqwnjHjh3jO9/5To1y/7c99tgj+vfvn9ScNZEL1yeVWrdunZK8X3zxRcJ4s2bNqpQnn9dUa2nqfPXVV5X2teuvvz7q1auXtLluvPHGpOVKlilTpiSMd+rUKY499tikztWhQ4ek7ZG9/fbbCeM777xzdOrUKSlzDB06NFq1alWjHLV93aiOdPZye3XZJVf7sc9Ranhft5XK9SRVa0k+P5tnk1ztnankWYLtSdYeBABkWmGmCwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2FE/+MEPYsmSJRXihYWF0aRJk6TMsXDhwpgzZ06FeHFxcfz4xz9Oyhxfa9KkSey6665JzTlq1KgKsaZNm0bfvn1j0KBB28TXrVsXzz33XJXyjxs3rkLs+OOPjyFDhlSIP//887Fs2bIq5c93DRs2jJ/97GcJx954441Ys2ZNymtYvXp1wvguu+ySlPzf+973okOHDjXKsWjRonjhhRcSjl111VU1yv3fzj///Dj44IOTmrOqtmzZEqeeemql1+Z3v/tddOzYMWnz5UOfyPVenU/uvffehPG2bdvGHXfckbJ577zzzthrr70Sjt1zzz0pm7eqli9fnjDetm3b9BaSZLmwlqTbT3/60ygqKkpavuHDh0eDBg0qxDds2BCTJk1K2jzfJBevc77ec/9p06ZN8fjjjyccu+aaa6K4uDhpc/3whz+M3XffvUK8tLQ04fMEZJtc6GOLFy+Ol156KeFYsr/7jBgxIurUqZPUnDWRC9cnFXbfffe499574+OPP44TTjgh6fnr1q2bML5+/foq5cnnNdVamlp33313wninTp1i5MiRSZnjrLPOioEDByYlVzJ98cUXMXPmzIRjV199dVLnGjlyZBQUFCQl14IFC2Lx4sUJx84+++wa569Tp07ccMMNNc5TW9eNmkhnL0/XXp19uh2Xi/3Ynm9qeF+3lcr1JFVrST4/m2ebXOydqZSPzxIRudGrkunrfYhs3oMAgExL3v/KDwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkCX22GOP2G233TJdBrXQwoULY8mSJZkuAwAAACCvLVmyJM4555wYP358Suf54x//GHfffXeF+NVXXx2jRo2K999/Pynz3H777XHyySfHDTfcEL/97W9jy5YtNc45evTo2LRpUxQXF28Tv+6662LPPffcJjZ16tTYuHFjlfKPHTs2fvSjH20TGzx4cDRu3LjCsU888USVcue7goKCuO+++6Jt27YJxx9++OG01LFs2bKE8cMPPzyefPLJGuXedddd47e//W2Ncnzt3nvvjV69elWIH3300XHppZcmZZ7u3bvH3XffHXXq1ImpU6fGr371q5gxY0aN81bHRx99FBdeeGH87W9/qzDWsGHDeOyxx+KQQw6J0tLSGs+VL30il3t1PnnggQfimmuuiTZt2lQY++EPfxgvvPBC/PWvf03qnGeddVace+65Ccc+//zz+NOf/pTU+Wri888/Txhv27ZttGnTptLxbJcra0k67b///nHbbbfFZZddVuNcRxxxRFx11VUJxx5++OFYtWpVjefYEbl4nfP1nvtvt99+e5xzzjlRUFCwTfyAAw6IO++8My666KIaz9G1a9e44447Eo499NBDsWjRohrPAamWK33s97//fRx++OEV4n379o0rrrgibr311hrPcdRRR8VZZ51V4zzJlCvXJ1l23333uPrqq+Pcc8+NunXrRkTEXXfdFTNmzIjly5cnbZ727dtXiG3evLnS97sy+b6mWktTZ8KECTF79uzo1q1bhbHhw4fH+++/H/fdd1+18/ft2zd+//vf16DC1Lr77rsTfgfu27dv/OxnP4vbbrutxnMMHTo0TjzxxBrn+U8vvfRSDB06tEL8nHPOiVtuuaVGferKK6+MLl261KS8iKh960YypLuXp2Ovzj7djsvVfmzPNzW8r/8nVetJKteSfH82zya52jtTJR+fJSJyo1clw3/vQwwYMCBr9yAAINOKMl0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAsu1/wP5x1FFHZboMaqGnn3o6lixZkukyAAAAAPLehAkT4r777ovzzz8/ZXP8+c9/jmuvvTZatWq1TbxBgwbx6KOPRp8+fWLt2rU1muPss8+OH/3oRxERcfvtt8c555wTF1xwQcyYMaNGeVetWhXPPvts9O/ff5t4r169Khw7ZsyYKud/9tlnY8OGDdGgQYOtsbZt21Y4rqysLP7+979XOX++atGiRfzhD3+IYcOGJRxfvnx5PPjgg2mp5b333ksYP++88+LJJ5+sdt4GDRrEE088UeG+qa7HH388rr/++ujYsWOFsdtuuy3mz58fEydOrHb+li1bxpNPPhl16tSJiIhjjz02jj322JgxY0acfPLJ8cUXX1Q7d3U9/PDDMWDAgDj11FMrjHXr1i1uueWWuOyyy2o8T770iVzu1fmktLQ0rrzyyvjb3/6WcPzBBx+MVq1axa233pqU+a644oq4+eabKx2/8soro7S0NClzJcOSJUvio48+SngPXHjhhXHNNdekv6gkyJW1JN2GDx8eb7/9dvzxj3+sdo6OHTvG448/HkVFRRXGtmzZEnfccUdNSqySXLzO+XrP/bd33nknRo0aFd///vcrjF144YXxwQcf1Oiz0q5duxg9evQ2a/nXNm7cGCNHjqx2bkinXOljTzzxRIwcOTL23HPPCmM33XRTvP/++zF69Ohq5+/QoUM8/vjjUVBQUIMqky9Xrk+y3HfffTFw4MBtYnvuuWc88cQTMWjQoNiwYUON5+jevXvst99+FeKff/55lXPl+5pqLU2d8vLyuOSSS2L69OkVxgoKCuLee++Nli1bxv/7f/8vtmzZUqXcJ554Yvztb39L+L5mi8ceeyxuuummaNOmTYWxkSNHxvz582vU0w888MD461//WoMKExs1alQMHTq0QnznnXeO3/72t3HGGWdUK++gQYNixIgRNS0vImrfupEM6e7lqd6ry/Z9uuLi4vjNb35T6fj//u//prGa3O3H9nxTw/v6f1KxnqR6Lcn3Z/Nskqu9M1Xy7VkiInd6VTL89z5ENu9BAECmFWa6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAqrr88svjvffeS1n+DRs2xLXXXptwrHv37jFjxoxo1apVtfNfdNFF8cADD2wT69KlS0yfPj0GDhxY7bxfGzVq1HaPKSsriwkTJlQ5d0lJSUydOnW7x02fPj2WLFlS5fz56JprrokPPvgghg0b9o3HrF69Oi31TJ48OWH8mGOOiR/+8IfVytm6deuYMWNG/M///M/W2KxZs6qV62tlZWVx2WWXJRwrLi6OsWPHxqWXXlqt3B06dIjp06fH3nvvXWFsl112icWLF1crbzKcf/758dFHHyUcGz58ePTv3z8p8+RDn8j1Xp1PHn744Zg4cWLCsYKCgrjlllti9OjR0alTp2rP0alTpxg9enTccsstUVBQkPCYiRMnxsMPP1ztOVLl+eefTxj/2c9+FkceeWR6i0mSXFlLMuH++++PO+64I+rUqVPlc/v16xevvvpq7LbbbgnH77vvvnj77bdrWuIOy9XrnI/3XCKXXnpprFy5MuHYb37zm7jvvvuibt26Vc579NFHx2uvvZbwOSkiYsSIEfHhhx9WOS9kQq70sU2bNsXll1+ecKxOnTrx9NNPx89//vNq5e7bt2+88MILsfPOO2+NffbZZ9XKlWy5cn2S5dprr43y8vIK8aOOOir+8Y9/xB577FGj/E2bNo0HH3ww4dgzzzxTrZz5vqZaS1NnxowZ8fvf/77S8V/+8pcxd+7cGDRo0A49N3/729+OiRMnxlNPPRUNGjTYGl+8eHHa9tN2VGlpafzkJz9JOFbTnj5o0KB4/vnno0mTJjUpMaEnnngiPv3004Rjp59+etxyyy1VzvmDH/wgnn766W2ucU329GvbupEs6ezlqdyry4V9uuLi4rj44osr/ZMJudiP7fmmhvf1/6RiPUnHWpLvz+bZJBd7Zyrly7NERG71qmRItA+RzXsQAJBJhZkuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgqjZs2BCnnnpqbNq0KWVz/PGPf4xnn3024Vi3bt3irbfeiosvvjiKiop2OOf+++8f48ePj7vvvjsKCwsrjM+cOTOeeeaZatf8tdGjR2/3vXn11Vdj6dKl1co/ZsyY7R7zxBNPVCt3ph1yyCFx4oknVuvPsGHD4swzz4yLLroobrjhhnj88cfj7bffjhtvvDGaN29e6Zx///vf47777kvba3zhhRdi2bJlCcf+8Ic/xLXXXrvDn+vi4uK4+OKLY+7cuXHQQQdtja9atSp+8Ytf1LjWZ555Ju6///6EY3Xq1Ik777wzXn/99fjOd76zQ/kaNWoUV111VcyaNSs6duxYYby8vDyGDx8eW7ZsqVHdNbFmzZo49dRTK63hr3/9a7Ru3brG8+RLn8jlXp1vzjjjjFi4cGGl4yeccEK89dZb8cgjj8RJJ50ULVq02G7OFi1axLBhw+Lhhx+Ot956K0444YRKj12wYEGcccYZ1ao91e69996E8eLi4pgyZUrcfvvt0a5duzRXVTO5tJakwxtvvLHNz8OHD4933nknTjrppCgoKNju+V26dInRo0fHM888E02bNk14zKeffpr29yNXr3M+3nOJLF68OM4777xKx88777x4//334/TTT9+h69SpU6d46qmn4tlnn620R7/00ktx6623VrtmSLdc6mNPPfVUjB8/PuFYQUFBjBw5Mt58883o37//DuXr0KFDPPjgg/Hcc8/FLrvssjVeUlISV199dY3rTYZcuj7J8Oabb1a6Rh122GHx9ttvx7XXXrvN9dpRxx57bLz66qvRtWvXhOPV/e6V72uqtTS1Lrvssnj55ZcrHe/cuXOMGzculi5dGo888kj84he/iB//+McxbNiwOOuss+KKK66Ie+65JxYsWBCzZ89O2P8uvPDCWL9+fSpfRrU8/vjjMXHixIRj1enpXbt2jVGjRsW4ceNip5122hpftWpVvP/++0mpecuWLfGb3/ym0vErrrgiJk6cGB06dNhurm7dusWECRPiz3/+cxQXF2+Nz507N0aNGlXtGmvbupEs6e7lyd6rs09Xc7nYj+35pob39d9SsZ6kYy3J92fzbJOLvTNVcv1ZIiI3e1UyVLYPka17EACQSTv+ZAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkEVmzZoV1113XYwcOTJlc5x88skxc+bM2HvvvSuM7bzzzvG73/0ufvGLX8SkSZNi6tSp8emnn8aSJUti/fr1Ubdu3WjSpEnsueeeccABB0T//v3jsMMOi4KCgoRzLVq0KL73ve9FWVlZjeteuXJl/OMf/4h+/fpVesyYMWOqnX/8+PFRXl5e6WspKyuLp59+utr5M+mSSy6JSy65JG3zPfvss3HKKaekbb6IiI0bN8b/+3//L+64444KY4WFhTFixIg4//zz46GHHooZM2bEu+++GytXroySkpJo2rRptGzZMtq3bx/HHXdcDBw4MHbddddtcpSXl8fZZ58dixcvTkq9F198cXTs2DH69OmTcPyggw6KyZMnx9KlS2PKlCnx5ptvxpIlS+Krr76KiIimTZtG27Zto2fPnnHcccdFgwYNKp3rtttui8mTJyel7pp4+eWX48Ybb4zrr7++wtguu+wSDz30UBx77LE1miOf+kSu9up8s3z58ujfv388//zz0bp164THFBYWximnnBKnnHJKlJeXx7vvvhuLFi2KZcuWbb1nW7RoEbvssku0bt06OnbsGIWFhdude9GiRTFgwIBYvnx5Ul9Tsrz22msxbdq0OPLIIyuMFRUVxeWXXx6XX355LF68OD799NNYvXp1ws/YsmXL0r5mVCbX1pJU+8EPfhCvvfZa1K9ff2ts3333jVGjRsVXX30VkyZNitdffz0WL14cy5cvjyZNmkTLli1j3333jX79+sV+++33jfk3btwYJ554YqxcuTLFr6TivLl4nfPxnqvMqFGjokuXLnHdddclHN9rr73ioYceirvvvjsmT54cr732WixevDiWLVsWjRo1ilatWkX79u2jX79+0alTp2+c66OPPooTTjghNm/enIqXAimRa33s9NNPj9dffz3at2+fcLxbt24xceLEWLx4cUyaNClmz54dixcvjhUrVkS9evWiRYsW0aVLlzjyyCOje/fuCXNceuml8eGHHyal3prKteuTDJdddln07NkzevToUWGscePGMWLEiLj22mvj5ZdfjmnTpsU777wTH330UaxZsybWr18fBQUF0ahRo2jatGm0a9cuunXrFgMHDowOHTpUOuekSZPiueeeq1a9tWFNtZamzqZNm6J///4xefLkOOSQQyo9rnnz5tX6fNx8883x9NNPx+9///ualJkyp512Wrz++uvRrl27hOPb6+nf+ta34oADDoijjz46DjjggIQ5Lr744jj33HO/sQdUxV133RUnnHBC9O3bN+F4//7947jjjotXX301pkyZEh999FEsXbo0IiK+9a1vxf777x/HHHNMHHjggRXOLS0tjbPPPjsGDx5c7fpq47qRDJno5cncqxsxYoR9uhrK1X5szzc1vK+pXU9SuZbUhmfzbJKrvTMVcv1ZIld7VbJUtg+RjXsQAJBJRZkuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgum655ZYYMGBA9OrVKyX5v/rqqzj66KPjueeei7Zt2yY8plWrVnHWWWfFWWedVe15lixZEv369YuPPvqo2jn+26hRo6Jfv36Vjo8dO7bauZcsWRKvvfZaHHLIIQnHX3zxxVi0aFG189cW9957b1xyySWxefPmtM99zz33xJlnnhkHHnhgwvHddtstrrzyyrjyyiurnPvKK6+M0aNHR/fu3WtaZkREbNq0KQYNGhTjxo2Lvn37VnrcLrvsEqeddlqcdtpp1ZrnL3/5S/z85z+vZpXJN2LEiDj22GPj8MMPrzB2zDHHxE9/+tP49a9/XaM58qVP5HKvzjfvvfde9O7dOyZNmhT77LPPNx5bUFAQnTp1ik6dOtVozgULFkS/fv1i/vz5NcqTaj/4wQ9izpw50bRp00qPadWqVbRq1arS8c8++ywVpVVbLq0lqfavf/0rTj/99Bg1alQUFhZuM/atb32rRuvTxo0b46STTorXX389GaVWWa5e53y85ypz/fXXR0FBQVx77bWVHtO0adP43ve+F9/73veqNce7774bxx13XCxbtqy6ZULG5FIfW7VqVRx33HHxj3/8o9Ln2ojqP9veddddcf/99yf8jpEpuXR9kqG0tDT69+8fkyZNioMOOijhMcXFxdG7d+/o3bt3jef76quv4vzzz69RjtqwplpLU2fVqlVxzDHHxF/+8pf47ne/m7S8d9xxR1x11VVJy5cKK1eu3NrT99prr0qPq25PHzlyZPztb3+Lc889t6alblVWVhannHJKzJ49u9J7urCwMA477LA47LDDqpT74osvjjfffDMGDx5coxpr27qRLOnu5enYq7NPVzW52I/t+aaG9/XfUrWepHotqQ3P5tkkF3tnquTjs0RE9veqZNjePkS27UEAQKYUbv8QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDsVF5eHqeffnqsWrUqZXMsXLgwDj/88HjxxRdTkn/27NnRo0ePmDNnTlLzjh49OjZt2pRwbMGCBfHOO+/UKP+YMWMqHXviiSdqlDvfvfXWW3HsscfGhRdeGJs3b85IDaWlpdG/f/9YuHBh0nJu2rQpzjvvvLjtttuSlvNra9eujeOOOy7uu+++pOcuLy+PW265JX7wgx9EeXl50vNXV1lZWZx66qmxevXqhOM33XRT9OjRo0Zz5FOfyNVenY/mz58f3bt3j6effjrlcz311FNx4IEHxvz581M+V019/PHHMXTo0Fi5cmWmS0maXFtLUu2pp56K733ve7Fhw4ak5Vy6dGn069cvxo0bl7ScVZWr1zkf77lvct1118U555wTa9euTXruiRMnxuGHHx6ffPJJ0nNDOuRaH1uwYEH8z//8T7zxxhtJzXvzzTfHpZdemtScyZBr1ycZli1bFn379o2///3vKZ3niy++iF69esXHH39cozy1ZU21lqbO2rVrY9iwYXHuuefG0qVLa5Rr+fLlceaZZ8bll1+epOpS68MPP4zDDz88qT29vLw8rr322rj66quTlvM/LVq0KHr16pW079llZWVx6aWXxh//+Mek5KuN60YyZKKXp3Kvzj5d9eRiP7bnmxre1+SvJ+laS2rLs3k2ycXemQr59iwRkRu9Klm+3odIpWTtQQBAphRmugAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJr45JNP4sILL0zpHF9++WX06dMnrrjiili3bl1Scm7YsCGuuuqqOPjgg+PTTz9NSs7/tGLFinjuuecSjo0dO7bG+SvLUV5eHk899VSN8+ebkpKSGD16dAwYMCAOOOCAePbZZzNdUixevDgOOeSQmDBhQo1zzZkzJw4++OC4//77k1BZYqWlpXHBBRdE//794/33309KzgULFsRxxx0XP//5z5OSL9k+/vjjOP/88xOOFRcXx2OPPRaNGzeudv586xO52Kvz1apVq+K73/1uDBgwIObNm5f0/G+99Vb0798/hg0bFqtXr056/lSZNm1aHHzwwfHPf/4z06UkTa6tJan21FNPxaGHHhqzZs1KSq4uXbrE888/X/PCaihXr3M+3nPf5MEHH4z9998/Jk6cmJR8ixYtirPPPjsGDhwYK1asSEpOyJRc62NffPFFHHLIIXH99ddHSUlJjXItXbo0jj/++LjqqquSVF3y5dr1SYa1a9fGiSeeGMOGDYtPPvkk6fkfeeSR6NGjR7zzzjtJyVdb1lRraWr9+c9/jr333jt+/vOfx/z586t07tKlS+NXv/pVdOzYMR566KEUVZgayezpn332WQwcODBuvPHGJFWX2Pz585PSl5ctWxYDBw6Mu+66K0mV/VttXDeSIRO9PNl7dfbpkiPX+rE939TwviZ3PUnnWlJbns2zTa71zlTIh2eJiNzrVcmydu3anNmDAIBMKMx0AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANfXII4/Eo48+mtI5tmzZErfddlu0bds2fvnLX8Ynn3xSrTyfffZZ/PKXv4w99tgjbr755ti8eXOSK/0/o0aNShgfM2ZMjXPPmzcvFi5cWCH+8ssvxxdffFHj/LmqtLQ01qxZEx999FG89tpr8cgjj8QxxxwT3/rWt2Lo0KHxzDPPZLrEbSxdujQGDRoUJ510UrzwwgtVPv+NN96I733ve3HggQfGnDlzUlBhRZMmTYrOnTvHySefHDNmzIiysrIq5/jXv/4VF1xwQXTs2DGmTp2agiqT59FHH42HH3444Vi7du3i3nvvrVH+fOsTudir89kzzzwT+++/f/Tr1y8ef/zxWLt2bbVzrV27Nh5//PHo169fHHDAATFp0qQkVpo+H3zwQfTt2zd69uwZ9957b8yZMye2bNmS6bJqJBfXklSaO3duHHzwwXHGGWfEvHnzqnRuSUlJPPnkk3HQQQfFsGHDYunSpSmqsupy9Trn4z33TT7++OMYOHBgHHTQQfHYY4/FunXrqpxjzpw5ccEFF0Tbtm3jr3/9awqqhMzItT62ZcuWGDFiRLRt2zZuu+22WLJkSZXOX7x4cVx//fWxzz77xLhx41JUZfLk2vVJlqeeeir23nvvGDZsWEydOjU2btxY7VwrV66MBx98MA499NA47bTT4ssvv0xipbVnTbWWpta6devilltuiQ4dOkS3bt3ioosuigceeCCmTp0aM2fOjHfeeSfefPPNmD59ejz00ENx1VVXxeGHHx6tW7eO6667LpYtW1YhZ7169RLOlU3f42va0xctWhRXXnlldOrUKW17iytWrIhBgwZF375948UXX6zSuatWrYrbb7892rdvn7Lv7rV13aipTPTyZOzV2adLvlzrx/Z8U8P7mrz1JN1rSW15Ns82udY7UyFXnyUicrtXJUsu7UEAQLoVlJeXl+/QgQUFqa4FAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAldvCfZU/Iv9UOVKZr167RtWvXiPh3n1mwYEG88sorNeo5AAAAAAAAEBHRrFmzuOYX12S6DGqZ2399eyxatCjTZQCkxD4HRwz7VaaroDa5tV+mKwDIbwUFBdGjR4/o0KHD1t/3njt3bsydOzfDlQEAkGtG/GpENGjQwB45QJpdfc3V0bx58/j93b+Pjz76KNPlANQaF150Yey9997xwAMPxLvvvJvpcgBqhXPOOSc6de4UTz/1dLz88suZLgeg1hh64tA4/PDDY+KEiTFt2rRMlwNQa/Qf0D+OOuqoeO655+KZic9kuhwAABLwb7UDqeDfagcAAAAAACCXfP37jpBu/j9mQG1y7MURBw7KdBXUNlN+FzF7QqarAEgv/1Z7dvE7tUAiBx10UBxxxBHRvXv32HvvvaNly5bRqFGjKCoqitLS0lizZk2sXLky3nvvvXjrrbdi2rRpMXv27EyXDZXq2LFjHHHEEXHYYYdF+/bto1mzZtG8efMoLi6O1atXx8qVK+Pdd9+NWbNmxcSJE+ODDz7IdMnRsmXL6Nu3bxx66KHRvn372HPPPaNJkybRoEGDKCsri1WrVm2t+80334znnnsu3n777UyXTRrp1dmjbt26cfDBB8chhxwSXbp0iT333DNat24dDRs2jAYNGkRExIYNG2L9+vWxaNGi+OSTT2LevHnx6quvxsyZM6O0tDTDryA1GjVqFK1bt47mzZtv7bmJlJSUxHPPPZfm6qouF9eSHVXZ979v+v9od+nSJQYMGBDdunWLDh06RNOmTaNx48ZRUlISq1atisWLF8fcuXPjtddei0mTJsXatWtTVX5S5fJ1zrd77pvUr18/jjnmmOjZs2d8+9vfjjZt2mz9DJaWlsaqVati+fLlMW/evJgzZ05MnTo1Fi5cmOmyIS1yrY8VFBREr169olevXtGtW7do27bt1vt5/fr1sWrVqvj0009jzpw58c9//jOef/75KCsry2jNNZFr1ydZGjRoEH369Ilvf/vbsd9++8U+++wTO+20UzRu3DgaNWoU5eXlsXbt2lizZk2sXr06Pvzww5g7d27861//ihdffDE2bdqU1nprw5pqLc1+W7ZsicLCwgrx7t27x5tvvpmBirbvm3r6hg0bYvXq1bFw4cJ46623YsqUKfHiiy9W+l1k2rRp0bdv3wrxPn36xPTp05NW8+677x7HHXdcHHnkkbHrrrtGy5Yto0WLFrF58+at32tmz54dL774YjzzzDOxcePGpM29I2rrupEMmejlVdmr+93vfpez+3T/fX/m+7/vlu5+bM83NWr7+5rL60lteDbPR7n4LPvfsv1ZIh97VbLk2h4ERPz7mfrggw+Offfd1+/TAjtsR37HuygNdQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5KU33ngj3njjjUyXAUnz3nvvxXvvvRcPPPBApkvZYUuWLIlRo0bFqFGjMl0KWUqvzh6lpaXx4osvxosvvpjpUrLKunXr4sMPP8x0GUmTi2tJKs2bNy/mzZuX6TKSLpevc77dc9+kpKQkxo8fH+PHj890KZB1cq2PlZeXx/Tp02P69OmZLiUtcu36JMuGDRti0qRJMWnSpEyXskNqw5pqLc1ujRs3jsLCwoRjy5cvT3M1Oy4Xe/pnn30WDzzwQNb25dq6biRDJnp5bdmrq1Onzta/l5WVZbCS1MtEP64tn6N0q+3vay6vJ7Xh2Tzf5Oqz7H/zLJG7cm0PAgBSKfFTGQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABkoY4dOyaMl5eXx+eff57magC21axZs61/X716deYKSQP9GKDq9E4AgOxRmOkCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBH9ezZM2H8gw8+iM2bN6e5GoD/07hx4+jYsePWnxctWpTBalJPPwaoOr0TACB7FGa6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADYUcccc0zC+BtvvJHmSgC2dfvtt0fdunW3/vz6669nsJrU048Bqk7vBADIHoWZLgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA/NOoUaOk52zdunUcf/zxCccmT56c9PkAdkRRUVHcd9998eMf/3ib+F//+tcMVbQt/Rig6vROAID8V5jpAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADIHwUFBfGLX/wi5s+fH7vssktSc1955ZVRVFRUIV5aWhrjx49P6lwAO6JVq1bx3HPPxXnnnbdN/Iknnohnn302Q1X9m34MUHV6JwBA7VHxyQwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqqFNmzbxyCOPRO/evSMi4umnn45jjjkmNm7cWOPcffv2jUsvvTTh2NNPPx3Lli2r8RwAVdGmTZuYOXNm7LrrrtvEp06dGmeddVaGqvo3/Rig6vROAIDapTDTBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQ+44//viYO3du9O7de2vsiCOOiMmTJ0eLFi1qlLtv377x9NNPR0FBQYWxsrKy+NWvflWj/ADV8fnnn8fLL7+8TezBBx+MgQMHxoYNGzJUlX4MUB16JwBA7VOY6QIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyH1dunSJFi1aVIj36dMn5s2bF2eeeWYUFRVVKWezZs3ixhtvjClTpkTz5s0THvP73/8+3n777WrVDFBTZ599dsyfPz82btwYF110UZxzzjmxadOmjNakHwNUnd4JAFD7VO3pDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASuPXWW2PIkCHRs2fPCmOtW7eOv/71r3HrrbfG+PHjY/r06TF//vz47LPPYt26dbFx48YoKiqKFi1axLe+9a3o1q1bHHXUUTFw4MDYaaedKp1z7ty5ccUVV6TyZQF8ozVr1sSQIUOiqKgo5s6dm+lyIkI/BqgOvRMAoPYpynQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOS+LVu2xKBBg+Kll16K9u3bJzymVatWce6558a5555b4/k++uij6N+/f5SUlNQ4F0BNvP3225kuYRv6MUDV6Z0AALVPYaYLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA/LF26NHr37h2vvPJKSud588034/DDD48vvvgipfMA5Cr9GKDq9E4AgNqlMNMFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJA/vvzyy+jdu3eMGDEiNmzYkNTcpaWlceutt8ahhx4aX375ZVJzA+Qb/Rig6vROAIDaozDTBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQXzZt2hTXX3997LvvvnHzzTfHokWLapRvzZo1cc8998R+++0XV155ZZSWliapUoD8ph8DVJ3eCQBQOxRlugAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyHZ16tTJdAkAAJCTPv/887jqqqviF7/4RfTo0SOOPPLI6NGjR7Rr1y7atm0bO+20UxQWFm5zzqZNm+Lzzz+PBQsWxBtvvBHTpk2L5557LjZu3JihV5F9jjrqqCgoKKgQLysry0A1QC7QjwGqTu8EAMhvRZkuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACyXVlZWaZLAACAnLZly5Z49dVX49VXX60wVq9evahXr16Ul5dHSUlJbNq0KQMV5pby8vIoLy/PdBlADtKPAapO7wQAyE9FmS4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgNpr48aNsXHjxkyXAVDr6ccAVad3AgDkrsJMFwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADpUpjpAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBdCjNdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKRLYaYLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgHQpzHQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkC6FmS4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0qUw0wUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAuhRlugAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgFzQqFGjaNasWdSpUyfh+CeffJLmigAAAAAAAAAAAACojqJMFwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkG3atWsXAwcOjD59+sQhhxwSLVu2jOLi4m88p6CgIC21TZs2LWH8yCOPTMv8mZas11/b30cAAAAAAAAAAACozYoyXQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQLbo3LlzXHfddXHSSSdFYWFhpstJqG/fvpkuoVrq1q2bMF5aWlqlPMl6/cnKk6zXBTXhcwgAAAAAAAAAAFA12flbogAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAafb9738/Zs2aFd///vejsLAw0+XklQ4dOsTGjRsT/unQoUOmy6u2fH1d5BafQwAAAAAAAAAAgKrzm6IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQK133nnnxaOPPhr16tXLdCkAAAAAAAAAAAAApFhRpgsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZ3m9ZAABGRRJREFUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMikAw44IH77299GQUHBdo/dsmVLbNq0KQ1VAQAAAAAAAAAAAJAqRZkuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgk/7yl79EvXr1Eo4tW7Ys7rnnnpgwYUK88847sWbNmjRXBwAAAAAAAAAAAECyFWW6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACATOnTp09079494djUqVNj2LBhsXr16jRXBQAAAAAAAAAAAEAqFWW6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACATLn44osTxt977704/vjjo6SkJM0VAQAAAAAAAAAAAJBqRZkuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADITd26dYsZM2ZERMRdd90V11xzTYYrAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqLqjjjoqYfzKK6+MkpKSNFeTv0pKSuL111+vdCxX5evrIrf4HAIAAAAAAAAAAFRdUaYLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAByU2FhYTRu3DgiIurWrZvhagAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKquU6dO0aJFiwrxr776KsaNG5eBivLXJ598EgcffHCmy0i6fH1d5BafQwAAAAAAAAAAgKorzHQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACZ0Llz54TxV199NcrKytJcDQAAAAAAAAAAAADpUpjpAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMqFFixYJ4wsWLEhzJQAAAAAAAAAAAACkU2GmCwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyITmzZsnjK9atSrNlQAAAAAAAAAAAACQTkWZLgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyA0HHnhgDBs2LLp27Rr77LNPtG3bduvYxRdfHIMHD44PP/wwXnrppXjmmWdi1qxZNZ5z9913j4EDB0bfvn2jU6dOsfvuu0fjxo2jXr16sWHDhli+fHnMnz8/Xn755RgzZky8+uqrNZ7zax06dIihQ4dGnz59okuXLrHzzjtHw4YNY926dbF06dL48ssvY/r06TFp0qSYPn16lJWVJW3uHZGp9yZT8/bp0yc6duz4jcfMmTMnqZ8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADyX/369RPGS0tL01wJAAAAAAAAAAAAAOlUlOkCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDsVVRUFOeff34MHz482rVrV+lx9evXj44dO0bHjh1jwIABceONN8bcuXPjhhtuiL///e9Vnne//faLG2+8MYYOHRqFhYUJj2nQoEG0adMm2rRpE3379o2rrroq3nzzzfjZz34W//jHP6o859c6d+4ct912W/Tv3z8KCgoqjDdq1CgaNWoUbdu2jcMOOyyuvPLKePfdd+Pqq6+u1mutqky9N5m8JhERV199dXznO9/5xmN+/etfx6uvvlqjeQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAID8V5jpAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA7NS+ffuYOXNm/O53v4t27dpV+fyuXbvG008/HePHj4/mzZvv8HnDhw+POXPmxHe/+90oLKzaf4L1wAMPjGeffTZuv/32qpYbERE//elPY86cOTFgwIAoKCjY4fP222+/ePrpp+PRRx+NunXrVmvuHZGp9yaT1+Rr++67b43OBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgu9SrVy9atGgRjRs3znQptVbdunWjRYsW0bBhw0yXQg3k6r30dd3169fPdCkV1KlTJ5o1axbNmzeP4uLiTJeTk7L5+uaLJk2a+IxWUS6+Z+6l1MjFzwIAAAAAAAAAkBpFmS4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMg+nTt3jn/+85+x8847bxMvLy+Pt956K2bPnh3l5eVx5plnRkTEnDlzYtmyZdGjR49o2rTpNucMHDgwXn755ejdu3csWbLkG+e97rrr4pe//GWF+FdffRWvvPJKLFiwIFavXh3l5eWx0047Rfv27eOwww6L5s2bb3P85ZdfHnXr1o3//d//3eHXfMcdd8Tw4cMrxFesWBH//Oc/47333ovly5dHcXFxtGzZMnr06BE9e/aMoqL/+8/EnnzyydG6des47rjjorS0dIfn3hGZem8yeU2+VlRUFHvuuWeVzwMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDvsv//+ccIJJ0TPnj2ja9eu0aZNmyguLt46Xl5eHitWrIh58+bF3LlzY8qUKTFlypQoKSmp8dwtWrSI1q1bVzreqlWrSuOdO3eu8nxvv/12lc9JhyZNmsTAgQNjwIAB0a1bt+jQoUPUq1dv6/iWLVti0aJFMXfu3Jg5c2b8/e9/j9mzZye9jsre02x933ZUul5XJu+l/5To9S5evDi++uqrhMe3aNEiTjrppDjqqKPiwAMPjL322ivq1q27dXz9+vWxdOnSeOedd2Lq1KkxZcqUeOutt5Jac2V69uwZRx99dPTs2TO6desWO++8czRu3HibY0pLS+Pzzz+Pt956K958880YP358zJw5My31VUWyPof5dH2ro6qvPyKiXr160bVr12jfvn00bdo0mjRpEgUFBVvH77rrrmrfh/Xq1YvjjjsujjvuuPj2t78dnTp1iubNm2+Tv7S0ND7++ON466234qWXXorRo0fHBx98UK35Er3+FStWxJdfflmtfNtT2Tr91VdfxeLFi6uVM93vWWVy7V5q2bJl7LzzzlWquToKCgqiU6dOFeJlZWXx7rvvJm2eiOz5LAAAAAAAAAAA2aso0wUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANmlQYMGMW7cuNh55523xjZv3hy/+93v4s4774xPPvkkIiK6d+8eZ555ZkRETJ06NX72s59FRMTRRx8d119/ffTq1Wvr+R07doyJEyfGoYceGps3b04473HHHRc33HDDNrE33ngjrr766pg6dWqUl5cnPK+4uDiGDRsWt956a+y+++5b4xdffHFMnTo1xo4du93XfOGFF8bw4cO3iS1atCiuvvrqeOihhyqtedddd42rr746LrrooigoKIiIiL59+8avf/3ruOSSS7Y7747K1HuTyWvyn7Zs2RK77bZbhfgNN9wQF1xwQZVyAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQHsXFxXHWWWfFT3/60+jYseM3HltQUBAtWrSIXr16Ra9eveKiiy6KdevWxd/+9re45ZZbYuHChdWu4+yzz47bb7+9yuddeOGFceGFF1bpnC+++CLatGlT5blSqXnz5vHzn/88LrzwwmjcuHGlx9WpUyfatGkTbdq0if79+8d1110X7777btx0003x8MMPR1lZWVLqmTdvXsL41/+d6FyVyteVLffSf0r0eq+88sq49dZbt4nttttuMWLEiDjzzDOjuLi40nwNGzaMvfbaK/baa6/o169fRETMmDEjrrvuunj++eeTUvN/Ki4ujvPPPz/OP//86Ny583aPr1u3buy9996x9957x+DBg+O6666Lzz77LO666674wx/+EKtXr056jdWRrM9hrl/fmtrR119YWBgnnXRS/OhHP4o+ffpEUVFRpTn/9Kc/RUlJSZXq2GOPPeKqq66KM8444xv7d8S/P6P77rtv7LvvvjF06ND4/+zdd3QU5ffH8U96QgoQCDV0kN57R3rvRVERbEhRESkCCopGFFDAgn5BAQGlg1JEeq8BpCNVek8ICSQkIdnfH/yILrtJNtndbBLer3NyDs+dee69O7M7u86OsxMmTFBwcLA+++wz/fbbbymqa+7xHzt2TOXKlUtRHktNnTpVPXr0MIl36dJFS5cuTVEuR22zxGS019K7776r999/36KereHl5WV229y7d0++vr42qZHengsAAAAAAAAAAAAAACD9cnZ0AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADSl/fee09FixZNGEdERKhx48YaPHiwLl68mOz8DRs2qEGDBhowYIAMBkNCvGrVqho9erTZOU5OTvryyy/l5OSUEJs5c6Zq1KihtWvXGuV5UmxsrObNm6dKlSrp4MGDRsvGjRuXbL8FChTQxIkTjWLBwcGqVKmSZs6cqYcPHyY699q1a3rrrbfUrl07PXjwICH+1ltvqWnTpsnWtoSjto0j98mTDAaDbt68afJ3//79FOcCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANhf8+bNdfr0aU2fPl0lS5ZMVQ5vb2/17dtXp0+f1ldffSVPT08bd2l7J0+edHQLRtq1a6cTJ05o2LBh8vHxSfH8UqVKafbs2Tp48KAqVKhghw6RnIz8WurZs6dOnTqlV199VW5ubimeX79+fW3atEmLFy+Wt7e3zfqqW7euDh48qK+//lplypRJdZ7AwECNHz9e58+f18svv2yz/jKK9Lp/00qpUqW0e/duzZ8/X02aNJGrq6vNcru5uSkoKEhnz55Vv379UnX8lqTq1atr2bJl2rZtm4oWLWrxvIiICJNY2bJlVbVq1VT1kZSsWbOqQ4cOJvGbN29q+fLlFudx9DazxtP+WrK1jPxcAAAAAAAAAAAAAAAAjuHs6AYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApC+vv/660fitt97Stm3bUpxn6tSp6t+/v1Fs8ODBCggIMFnXYDBo0KBBWr9+vSQpODhYr7/+uuLj4y2uFxISou7duysmJiYhVqZMGVWqVCnJeaNGjZKXl1fC+OLFi2rdurVu3Lhhce1Vq1bp1VdfNclrC47aNo7cJwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBmVqlSJUVERCgiIkJBQUGObgcAAAAAAAAAAACwKWdnZ3333Xdas2aNChUqZJOcLi4uevfdd3X48GGVKlXKJjnt5eTJk45uIcHQoUP1+++/K3fu3FbnKl++vIKDg9W7d2/rG4NFMvpr6dNPP9Uvv/wib29vq3N16dJFu3fvVuHCha3O9fLLL2vLli0qU6aM1bkey549u2bNmqWlS5fKw8PDZnnTs/S6f9NKzZo1tWvXLlWvXt3muQMDA7V3716NHDlSbm5uNslZr149HT58WG3atLFo/fnz55uN9+nTxyb9/FePHj3k6elpEp81a5YePnxoUY70sM1S62l/LdlaRn4uAAAAAAAAAAAAAAAAx3F2dAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0o8CBQqoYMGCCeNbt25pzpw5qc73ww8/aPfu3ZKk4OBgvfbaawoNDTW77vr169WsWTNVrVpVffv2VVxcXIrrnT59WmvXrjWK1axZM9H13d3d9fzzzxvFhg4dqtu3b6e49q+//qqNGzcmjBs1aqSKFSumOI85jtg2jqwLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZGbOzs7y8fGRj4+P3N3dHd0OAAAAAAAAAAAAYDOenp76/fff1b9/f7vkL1GihHbu3Km6devaJb8tnDx50tEtSJLefvttjR8/Xk5OTjbL6e7urhkzZujtt9+2WU6Yl9FfS6NGjdKoUaNsmrNcuXJau3atfH19U52jT58+mjlzplxcXCxaPyoqSpGRkTIYDBat36lTJ61Zs0YeHh6p7jEjSK/7N60ULVpUf/75p7Jly2bz3I9fm5UqVbJo/YcPHyoqKsqidb29vfXbb7+pR48eya47bdo0s/GePXva/FqXPn36mI1Pnz7dovnpZZulxtP+WrK1jPxcAAAAAAAAAAAAAAAAjuXq6AYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApB/58+c3Gh89elTx8fFW5ezbt698fHy0c+dOi9Y/cOCAVfUOHjyotm3bJoyffEz/VatWLfn5+SWMb926pUWLFqW69nfffafGjRsnjNu1a6dDhw6lOt+T0nLbpIe6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICMY86cOUa/Zfuk+Ph47dq1SytWrFBwcLCuX7+u0NBQZcmSRblz51bx4sXVunVrtWzZUtmyZTObI3v27Fq1apVq166tEydOWNTXtWvXtHv37kSXBwYGKjAw0CR++fJlXb582aIaj+3bty9F69tDgwYNNGnSJJN4TEyM1qxZo9WrV+vgwYO6fv26IiMj5e3trdy5c6tEiRJq2bKlWrVqlej2d3Jy0uTJk3Xu3DmtXLnSzo/k6ZVeX0uWaNq0qcaOHWsSNxgM2rp1q3777Tft27dPV65cUWRkpPz8/BQQEKDKlSurdevWatGihVxcXMzmLlGihH7++Wd17tw5xX0VLVpU3377rZycnMwuv3r1qn799VetWbNGR48e1c2bN41+493f31/PPPOM6tWrpy5duqhWrVpm8zRs2FBff/21+vbtm+IeM4L0un/TiouLi5YuXZro68oa/v7+Wrt2rQoUKJDoOocPH9aCBQu0du1anT17Vnfu3JEkubu7K2fOnKpWrZqaN2+uF154wWyPrq6u+vnnn3X+/Hnt2bMn0Tr79u3TwYMHValSJaN49uzZ1b59ey1evDhVj/FJJUuWNPta2rx5s86cOZPs/PS0zVLqaX8t2VpGfi4AAAAAAAAAAAAAAADHc3V0AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADSDzc3N6PxgwcPrM55+PBhq3OkRFhYmNHYy8sr0XUrVKhgNN60aZMMBkOqa2/cuNFoXK9evVTnsoeUbJvMUBcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkDY+/PBDde3aNdHlf/75p4YNG6YjR46YXX7u3Dnt2rVLc+bMkbe3twYPHqxhw4bJx8fHZN2sWbNq1apVqlSpksLDw5Ptbd68eZo3b16iy0ePHq2PP/7YJD59+nSNHTs22fzpzY8//ihnZ+eEscFg0Pfff6+goCBdvXrV7JzH23/27Nny9vbWu+++q6FDh8rPz89kXScnJ/3yyy8qW7asLl++bLfH8bRKz6+l5Hh6epo8/yRp1apVGj58uI4dO2Yy58aNGzp9+rR27typ7777TmXKlNHXX3+tJk2amK3RqVMndevWTYsWLUpRb5MnT1aWLFlM4vHx8Ro9erQmTpyo6OjoROeHhoZq9+7d2r17tyZOnKg6dero+++/N/mtdEl64403tHjxYq1bty5FPaZ36Xn/ppWBAweqYsWKJvE7d+7o999/18qVK3XkyBHduHFDd+/eTVHuBQsWqHDhwmaXXbp0SYMHD9bixYvNLo+JidHVq1e1fPlyLV++XCNHjtTw4cP1/vvvm+wvDw8PLV68WKVKldL9+/cT7WfatGmaOnWqSbxPnz6J9pFSvXv3TrS2JdLbNrMUryXby6jPBQAAAAAAAAAAAAAAkD44J78KAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgKfFnTt3jMa5cuVyUCeplz17dqNxREREous++fguXbpkVe2wsDBFRkYmjGvUqGFVPltLybbJDHUBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPZXrlw5ffjhh2aXPXz4UH379lWrVq105MgRi/Ldv39fn3zyiSpWrKgTJ06YXadIkSIaP358qnvOzEqUKJHw77t376pJkyYaMGCArl69atH8+/fv69NPP1WVKlUS3f5+fn6aNGmSTfrFvzL6a+m1115ToUKFTHpu27atjh07ZlGO48ePq3nz5po5c2ai6wwbNixFfQUEBKhVq1Zmlz3//PMKCgpSdHR0inLu3LlT1atX19KlS80uHzt2bIryZQTpdf+mlSxZsuiDDz4wikVHR+uLL75QkSJF1KdPHy1ZskSnTp3S3bt3U5T7xRdfVNOmTc0u27Fjh6pWrarFixdbnC88PFyjRo1SmzZtzP6ufGBgoD7++OMkc/zyyy+KjIw0ibdo0UJ58+a1uJfEODk56aWXXjKJh4aGasmSJcnOT4/bzFJP+2vJ1jLycwEAAAAAAAAAAAAAAKQPro5uAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAED6ceXKFRkMBjk5OUmSKlasKH9/f4WGhjq4M8tVrVrVaHzq1KlE1/Xy8jIa37t3z+r6ERERypIliyQpe/bscnV11cOHD63Oawsp2TaZoS4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQHlSuXFldu3ZVhQoVVLRoURUuXDhh2cCBA9WuXTudPXtWO3fu1OrVq3XgwAGrawYGBqpNmzZq1KiRSpcurcDAQPn4+MjDw0NRUVEKDQ3V6dOntWvXLv3+++/as2dPquq4urrqlVdesbrfx6KiojRnzhyb5XssPfVZpkwZderUSTVr1lSZMmWUPXt2Zc2aVZJ09+5d3blzR8ePH9f777+v48eP26TfHDlyqFu3bmrSpInKlSun/Pnzy9vbW5J0//59XblyRUeOHNGGDRu0ePFihYSE2KQuAAAAAAAAAAB4evzwww9yc3MzicfGxqpNmzZat25dqvKeO3dONWvW1Nq1a1WrVi2T5W+88YZmzJihvXv3pip/ZhcZGanGjRun+jvIs2fPqmbNmtq8ebOqVKlisrxr166qW7euduzYYW2r+H8Z/bVUoECBhH/Hx8erR48eWrp0aYrzxMfH65VXXlGxYsXUoEEDk+XVqlVTgwYNtHXrVovytWvXTq6uribxBQsWaOHChSnu77GYmBj16NFDW7duVe3atRPi69at04QJE1KdN71Kr/s3rTz//PPKmTNnwvj27dvq0KGDdu7caVVeT09PjR8/3uyyQ4cOqWnTpnrw4EGqcv/555/q1auXli1bZrLsrbfe0oQJE3Tjxg2zc8PDw7Vo0SK9/PLLRnEXFxe9+OKLVj/HmzZtqvz585vE58yZo5iYmCTnptdtZqmn/bVkSxn9uQAAAAAAAAAAAAAAANIH06vLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADy17ty5o2PHjqlcuXKSJFdXV40dO1YDBw50cGeWKVWqlJo2bZowjo2N1bp16xJdPyYmxmjs4+NjdQ++vr5G42zZsun27dtW57VWSrdNRq8LAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOJKrq6vefPNNDRo0SMWKFUt0PU9PT5UsWVIlS5ZU69at9emnn+rw4cP66KOPtGzZshTXLVWqlD799FN16tRJzs7OZtfx8vJS/vz5lT9/fjVq1EgjRozQX3/9paFDh2rDhg0pqpc9e3b973//S3Gfibl+/brmzJljs3yPpYc+a9Sooa+++kp169ZNdB1/f3/5+/urWLFiateunbZv36733ntPe/fuTVWf2bNnV1BQkF599VW5u7ubXcfX11elSpVSqVKl1K1bN02ZMkU//vijPvjgA4WFhaWqLgAAAAAAAAAAeLrUr18/0e9Ahg4davXv2UZERKhLly7666+/lCtXLqNlTk5OGjlypDp27GhVjcyqf//+OnDggFU5Hm//AwcOKHv27CbLBw0apB07dlhVA49kttfSmDFjtHTpUqty9O7dWydPnpSbm5vJsg4dOmjr1q0W5Unse/uff/7Zqv4k6eHDh+rTp4/++usvLV68WBMnTtThw4etzpvepaf9m1aeeeaZhH+HhYWpdu3aOnPmjNV5e/bsqbx585rEw8PD1alTJz148MCq/L/99pt+/PFHvfbaa0Zxd3d3DRgwQKNHj0507rRp0/Tyyy+bxF955RVNmDDBqr769OmTaM3kpOdtllJP42vJljLTcwEAAAAAAAAAAAAAADiO+Tu0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHhqzZo1y2g8YMAAffLJJ3JxcXFMQxYKCAjQ4sWL5erqmhCbOXOmQkJCEp1z584do3FgYKBVPWTLlk1ZsmQxiTlaarZNRq4LAAAAAAAAAAAAAADSxgcffKBx48Zp3LhxKlGihKPbAQAAAAAAmQznHgAAAAAAAAAAAAAAAAAAAJCRFS9eXMHBwfrmm29UrFixFM+vUKGCli5dqpUrVyp79uwWzxs0aJAOHTqkLl26yNnZOUU1K1eurPXr1+vLL79M0TwfH58Ure8oju7zo48+0q5du1S3bt0UzatXr5527dqljz76KMU1a9eurePHj6tfv35yd3e3eJ6Hh4cGDBigY8eOqXr16imuCwAAAAAAAAAAnj5DhgwxG1+/fr2mTJlikxpXr17V66+/bnZZ+/btuU+NGdu2bdPPP/9sk1znz5/XsGHDzC7r2LGj8uTJY5M6T7vM9Fo6dOiQxo0bZ3Wef/75R7/99pvZZfXq1bM4T758+czGz549m5q2TJw8eVK5c+dWr169dPjwYZvkTM/S2/51hFdeeUVnzpyxSa6BAweajX/99df6559/bFJj3Lhxio+PN4n36tUryXk7d+7U8ePHTeKlSpVSjRo1Ut2Pn5+fOnbsaBLftWuX2XpPSs/bLCV4LVkvszwXAAAAAAAAAAAAAACAY6XsLi0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMr0ffvhB//zzj1Hsgw8+0LFjx/T222+rWLFiDurMPB8fH73xxhs6evSoypYtmxA/duyYhgwZkuTcEydOGI0bNWpkVS+NGzc2iTk7O+5nZK3ZNhmxLgAAAAAAAAAAAAAASFvvvPOO3n//fb3//vsqUqSIo9sBAAAAAACZDOceAAAAAAAAAAAAAAAAAAAAkFGVKVNGu3btUqVKlYziBoNBR44c0Zw5czR79uyE+KFDh7RhwwbdvXvXJFebNm20a9cu5cqVK9m6o0eP1qRJk+Tu7m4UDwkJ0apVq/TNN98oKChIn376qb7++mv98ccfunPnjkmewYMH65tvvrHw0Ure3t4Wr+tIjuxz3LhxGjNmjMm96+/evas1a9Yk7JugoCB98803WrNmjdHzwdnZWWPGjNFnn31mcc2GDRtq48aNypMnj8my8+fP648//tCMGTM0Y8YM/fHHHzp//rzJevny5dPmzZtVu3Ztyx8sAAAAAAAAAAB46vj6+qpVq1Zml40bN86mtZYvX65jx46ZxJ2cnNS1a1eb1soMPvnkE5vmmzNnjm7dumUSd3V1VcuWLW1a62mU2V5LH374oeLi4mySa+bMmWbjVapUUZYsWSzK4eHhYTZuMBhS3deTIiIibJYrvUtv+zetLVu2TMuWLbNJroIFC6py5com8cjISE2aNMkmNSTp3LlzWr9+vUm8UKFCKl26dJJzp0+fbjbep0+fVPfTvXt3eXl5mcSnTZuW7NyMsM0s9bS/lqyVmZ4LAAAAAAAAAAAAAADAsVwd3QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA9OX+/fvq3LmzNm3apGzZsiXES5YsqSlTpmjKlCkKDQ3V5cuXE5blzZtXefLk0fXr123eT7Vq1TRmzBijmJOTk7y8vJQ7d26VKlVKLi4uRsvPnj2r1q1bKyIiIsncO3bs0MOHD+Xq+uinXnPnzq1OnTpp2bJlqep1wIABqZqXWvbcNumxLgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJCeeXl5acWKFcqZM2dC7OHDh/rmm280efJkXbx4UZJUpUoV9erVS5K0bt06DR06VJLUpEkTjRkzRvXr10+YX7JkSf3xxx+qVauWHj58aLZuixYt9NFHHxnF9u/fr5EjR2rdunUyGAxm57m5ualr164aP368AgMDE+IDBw7UunXrtHz58mQfs4+Pj9F42LBh2rBhQ7LzEpPYY7SWo/p89tln9f777xvFbt26pWHDhmnevHmKjo42O8/Dw0OXLl1SQEBAQmzEiBFat26dNm3alGTN3Llza9myZfL09DSKr1ixQh999JEOHDhgdl6VKlX08ccfq23btgmxLFmy6Pfff1epUqUUGhqaZF0AAAAAAAAAAPB0at68udzc3EziR48e1caNG21eb/LkyZo+fbpJvF27dho3bpzN62VUFy5c0Lp162yaMzo6Wj/99JPJ91+S1LJlS82aNcum9Z42mem1dOHCBa1YscKqHP+1Y8cOGQwGOTk5GcVdXV1VqFAhnThxItkcYWFhZuNFihTR6dOnbdHmUyM97t+0NnnyZJvlatasmdn4+vXrbf49/ebNm9W8eXOTeKNGjZLczrNnz9bnn38uDw8Po/jzzz+vQYMGJXrtQ1L69OljEgsPD9fChQuTnZsRtpkleC1ZL7M8FwAAAAAAAAAAAAAAgOO5OroBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOnPwYMHVbNmTS1atEgVKlQwWe7v7y9/f/+E8QsvvKAXXnhB4eHhOnDggPbs2aPly5dr586dVveSK1cutW3b1uL1v/vuOw0ZMkQPHjxIdt2wsDCtWbNGbdq0SYhNnDhRmzZtUlhYWIr6fO6559S4ceMUzbGWPbdNeqwLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApGfvvfeeihYtmjCOiIhQmzZttG3bNovmb9iwQRs2bFD//v317bffysnJSZJUtWpVjR49WqNHjzaZ4+TkpC+//DJhXUmaOXOmXnvtNcXHxydZLzY2VvPmzdPatWu1fv16VapUKWHZuHHjtHz58mR79vHxMRofO3ZMBw4cSHZeWnNUnxMnTjQanzt3Tg0aNNCVK1eSnBcdHa3KlStr69atRs+pCRMmqFq1aknOnTp1qrJnz54wNhgM6tevn/73v/8lOe/AgQNq166d+vfvr++++y4hHhAQoMmTJ6tXr15JzgcAAAAAAAAAAE+nZ5991mz8zz//tEu9xPLWrFlTHh4eio6OtkvdjGbt2rV2ybtx40a9//77JvHq1avbpd7TJDO9llauXJnqueaEh4fr7NmzKl68uMmy/343mpRr166ZjT///PN2e71kVulx/6alv//+W1u3brVZvnr16pmNr1mzxmY1Htu9e7fZeNmyZZOcFxoaqmXLlum5554zimfNmlUdO3bUggULUtRH8eLFVadOHZP4r7/+qsjIyGTnZ4RtZomn/bVkC5nluQAAAAAAAAAAAAAAABzP2dENAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEifTp06pUqVKunll1/Wzp07LZrj5+enRo0aafjw4dqxY4fOnj2rF1980c6dGuvYsaM6depk8fpBQUFG46JFi2rFihXy9/e3OEeLFi00c+ZMi9d3lJRum4xeFwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEhLr7/+utH4rbfe0rZt21KcZ+rUqerfv79RbPDgwQoICDBZ12AwaNCgQVq/fr0kKTg4WK+//rri4+MtrhcSEqLu3bsrJiYmIVamTBlVqlQp2bne3t5G46ioKIvrpiVH9FmsWDFVqVLFKPbCCy/oypUrFs2/cuWKXnjhBaNY1apVVbRo0UTnNG3aVJ07dzaKjRw5Uv/73/8s7PrR82/06NFGsZdeekm1a9e2OAcAAAAAAAAAAHh6lClTxmx8+/btdql3+fJlXbp0ySTu7OyskiVL2qVmRpSa7yktsXfvXhkMBpN44cKF5e7ubpeaT4vM9FraunWrVfPNMderJIt/izyx7dirVy9169Yt1X09jdLj/k1Lmzdvtmm+UqVKmY3v2rXLpnUk6dq1a2bjzzzzTLJzE7vuoE+fPinuo3fv3mbj06ZNs2h+RtlmyXnaX0u2kFmeCwAAAAAAAAAAAAAAwPGcHd0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgPTLYDBo9uzZqlu3rgIDA9W1a1dNmDBBa9as0fXr15OdX7RoUc2ZM0dr166Vn59fqnoICQnR5s2bTf52796tM2fOKD4+3mj9/Pnz69dff9XUqVPl5OSUbP5du3Zp+vTpRrF69erpr7/+Uvfu3ZPMkTNnTk2cOFF//PGHPD09FRsbq6tXr6bqcaaGvbdNeqsLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApFcFChRQwYIFE8a3bt3SnDlzUp3vhx9+0O7duyVJwcHBeu211xQaGmp23fXr16tZs2aqWrWq+vbtq7i4uBTXO336tNauXWsUq1mzZrLzfHx8jMZRUVEprp0WHNFnrVq1jMb79u1L2KeW2r17t/bv359k3v968803jcaHDh3SF198kaKakhQUFKSjR48axfr27ZviPAAAAAAAAAAAIPMrXbq02fiBAwfsVvPJ70+S6+VpdPr0abvkvXv3ri5cuGASd3Z2VtGiRe1S82mRmV5LJ06csGq+OXfv3jUbz5Ytm0Xzt2/frpCQEJO4s7OzFixYoJ9//lkVK1a0psWnRnrcv2lpz549Ns33zDPPmI2bO9Za686dO2bj2bNnT3bu5s2bdebMGZN4s2bNlD9/fot7cHJyUq9evUziBw4c0F9//WVRjoyyzZLztL+WbCGzPBcAAAAAAAAAAAAAAIDjuTq6AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZw5UrV7RkyRItWbJEklSlShXt379fkrRp0ybt379fFSpUUM2aNZU1a1ajuc2aNdOGDRtUt25dxcTEpKjunj179Oyzzya63M/PT+3atdPw4cNVvnz5hHi/fv107949DRs2LNkab731lsqUKaO6desmxAoWLKgFCxZo8uTJ2rBhg06ePKnQ0FC5u7srd+7cql69uurWrStPT8+EOe+//77at2+vfPnyJcQMBkOKHm9KpMW2SU91AQAAAAAAAAAA7K1w4cKaM2dOquc/fPhQd+/eVVhYmEJDQ3X48GEFBwfr+PHjdv3eCACAtODj46MGDRqoUqVKKlmypHLlyqVs2bIlLB81apRat26ts2fPavfu3Tpw4IDi4uIc1/B/+Pn5GY0fPHiQ4mtYklK+fHnVr19fZcuWVYECBeTj4yM3NzdFRUUpIiJC58+f15EjR7Rp0yZduHDBZnUtkSVLFrm6utq9Tnx8vO7du2f3Oo/Zc59WqVJF1atXV5kyZRQYGCgfHx95eXkpLi5O9+7d07Vr13Ty5Ent2LFDwcHB6eZ5DmRWzs7O8vHxsVv+8PBwm+VyxPtB0aJF1b59e1WrVk25c+eWi4uLbt26pRMnTmjFihUJ13nakqenp9zd3Y1iUVFRio2NtXktAJkbx02Om8CTOPeQtPR8/kHiHERKcf4BSF84/5C0tP4czWdoALZk7rj58OHDTHPMlDhuAgAAAAAAAAAAAEB6lD9/fqPx0aNHFR8fb1XOvn37ysfHRzt37rRo/QMHDlhV7+DBg2rbtm3C+MnHZM6T12FFRUVZ1YO9OKLPvHnzGo3/+uuvVOX566+/VLVq1UTzPhYQEKD27dsbxUaNGpWqe5/Ex8dr1KhR+v333xNi3bp109tvv23T6+MAAAAAAAAAAEDGFxAQYDZ+69Ytu9W8ffu22XjOnDntVjOjsee9aEJDQ1W4cGGTePbs2e1W82mQmV5LV65csWq+OYl9T+ns7GzR/NjYWI0bN04TJ040Webk5KRevXqpV69eunz5soKDg3Xs2DGdOXMm4e/GjRtW9Z+ZpMf9m5YOHTpk03zmjp1RUVEKDQ21aR1Jid7Hy9fX16L506dP1xdffGEUc3Z21ksvvaTPP//cohyNGzdWgQIFTOLTpk2zaL6UsbZZUp7215ItZJbnAgAAAAAAAAAAAAAAcDz7/xIfAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgExv//79Gjp0qCTJ1dVVLVu21OjRo1W9evWEdapVq6bPPvtMQ4YMsWnt8PBw/fLLL1qwYIEmT56sAQMGJCwbOnSoVqxYoW3btiWZIzo6Wi1atNCvv/6q9u3bGy3LmzevXnzxxSTnGwwGjRo1Sl999ZWee+45o2X37t1L4SOyHVtsm4xUFwAAAAAAAAAAwFpZsmRRvXr1bJ43PDxc8+fP17Rp07R//36b5wcAwJ7atWunfv36qWnTpnJzc0t0vQYNGqhBgwYJ47t372rBggX6/vvvdfDgwTTo1LyRI0cqKCjIKDZq1Ch99tlnVuX18vJS//799eabb6p48eIWzztw4IAmTJighQsXKj4+3qoeLLFq1So1atTI7nXOnDmjEiVK2L2OZJ99WqRIEb3zzjt6/vnnlStXLovn3bp1Sz///LMmTpyoGzdupLo+gMQ1bNhQGzdutFt+Jycnq+Y76v0gICBAEyZM0EsvvSRnZ2ez64wZM0abNm3SW2+9pWPHjqW4hjk5cuTQwYMHFRgYmBC7du2aKlasqFu3btmkBoDMjeMmx03AHM49JC6jnH+QOAdhCWvPPzz+f7cA2B7nH8xzxOdoPkMDsIXUHDcz4jFT4rgJAAAAAAAAAAAAAOnVk9fEPnjwwOqchw8ftjpHSoSFhRmNvby8kp3j7e1tNI6KirJlSzbjiD6zZMliNA4PD09Vnrt37xqNn3wsjzVv3tzoeRgSEqI///wzVTUl6Y8//lBoaKj8/f0lPXo8zz77rH7//fdU5wQAAAAAAAAAAJmLl5eXXFxcTOLR0dE2+b4sMXfu3DEb9/X1tVvNjCa1301Z4snvFR/z8fGxW83MLrO9liIiIqyab44t7qn0zTffqFOnTqpbt26i6wQGBiowMFCdOnUyit+/f19nz57VmTNndObMGZ0+fVqHDh3S4cOHFR0dbXVvGUl63b9pJSQkxGa5smTJYvYeNV5eXna5riGx++F4eHhYNH/WrFn69NNPTa6ReeWVV/T5559blKNPnz4mscjISP36668Wzc9o2ywpT/tryVqZ6bkAAAAAAAAAAAAAAAAcz/wvjgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAKj18+FArV65UrVq19MMPPxgtGzBggHLlymW3ugMHDtTixYuN4kFBQRbNv3//vjp06KCXX35ZFy9etLjuwYMH1bBhQ40bN06S5OPjY7T87t27FueyF2u3TUarCwAAAAAAAAAAkN74+fnpjTfe0L59+7Rx40YVL17c0S0BAJCsqlWrat++fVq+fLlatWolNze3FM3PmjWr3njjDR04cEC//vqrcufObadOE9egQQONHTvW5nlbtWqlM2fOaOLEiSl+X69SpYrmzZunHTt2qEiRIjbvLbOz9T718vLSxIkTdfr0ab3zzjspvrYpICBAQ4YM0blz5/Tuu+/arC8A/3rymrz0xFHvB8WLF9fu3bv18ssvy9nZOcl1n332We3atUtNmjRJUY3EzJkzR4GBgQnjuLg4Pf/887p165ZN8gPI3DhuctwEnsS5h6Rx/sGxbLlvbXX+gXMPgP1w/sGUoz5H8xkagLVSe9zMiMdMieMmAAAAAAAAAAAAAKRXd+7cMRrb677s9pQ9e3ajcURERLJznrwWKyoqyqY92Yoj+rx//77R+Mntayl/f3+jcWL7pXr16kbjlStXKi4uLlU1pX9/e+C/qlWrlup8AAAAAAAAAAAg8/H29jYbDw8Pt2vdJ7+be8zPz8+udTOSyMhIu+VO7Deb0/N9HNK7zPZaio2NtWq+vcTExKhDhw7666+/UjzX29tbFSpUUOfOnTVs2DBNnz5de/fu1b1797R+/Xr16dNHXl5edug6/Umv+zet2PJ36xN77UuSp6enzf88PDys6vfmzZtasWKFSbxEiRKqXbt2svN9fX3VqVMnk/iCBQssukZFynjbLClP+2vJWpnpuQAAAAAAAAAAAAAAABwv6V8dAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBUio+P14ABA7R///6EmKenpzp37mzXuoMGDVJ8fHzCuH79+goMDLR4/uzZs1W0aFG1b99eP/30k/766y/duXNHcXFxio2N1e3bt7Vnzx5NmTJFDRo0UOXKlbVt27aE+VmzZk34d3x8vCIjI23zwGzA2m2T0eoCAAAAAAAAAACkR88++6yOHDmid99919GtAACQqP79+2v37t2qWrWq1bmcnJz0/PPP6+DBg6pfv74NurNMQECA5s+fLxcXF5vmff/997Vq1Srly5fPqjy1atXS3r17Va5cORt1lvnZep/myZNHe/bs0XvvvWd1zixZsuirr77SggUL5OrqapP+ADzi4+Pj6BbMctT7gbe3t/744w8VLVo0IWYwGLRjxw5NmzZNU6dO1Zo1axQTE5Ow3NfXV7///rtKlChhVa9Dhw5Vq1atjGIff/yxtmzZYlVeAE8HjpuPcNwE/sW5h6Rx/sGxbLlvbXn+gXMPgP1w/sGYNZ+jrcFnaADWssVxk3MPAAAAAAAAAAAAAABbuHLligwGQ8K4YsWK8vf3d2BHKffkdb6nTp1Kds6T12JFRUXZtCdbcUSfJ0+eNBrXrFkzVXmenJfYfqlWrZrReN++famq91///b0BczUAAAAAAAAAAMDTzdnZ2Ww8Li7OrnUTy+/k5GTXuhnJf7+7tDW2v+3xWko7ISEhql27tqZOnWqT7evq6qomTZpoxowZOnPmjPr06WODLpGehYeH2yxXRnytTZs2zWzckud+t27dlCVLFotzmpMRtxnsg+cCAAAAAAAAAAAAAACwJX4hDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDdxMfHa/LkyZozZ05CrGHDhvrhhx/sVvPKlSvau3evatWqlRCrWbOmLl++bHGOuLg4rVixQitWrEhRbS8vL+XNmzdhfOPGjRTNtzdbbJuMVBcAAAAAAAAAACC98vT01FdffaWCBQvq3XffdXQ7AAAYGTx4sL788kuzy27cuKHNmzfrwIEDunr1qqZOnSpfX19J0vfff68HDx6odu3aql69ulxcXIzm5smTR2vXrlXr1q21adMmuz4GJycn/fLLL0bXcdjCkCFDNG7cOLPLrl27puXLl+vUqVO6fv26IiMjE64lqVSpklq0aKFcuXIZzcmZM6fWrl2r8uXLKyQkxKa9prXIyEi75rf1Ps2aNau2bdum4sWLmyyLiYnRjh07tHfvXp09e1Z3795VdHS0vL29lSNHDlWsWFFNmjRR4cKFTeZ2795dUVFR6t27t036BCB5e3s7ugUTjnw/+Pzzz1WiRImE8fXr19W+fXsFBwcbrVeoUCH99ttvqlSpkqRH23HWrFmqW7duKh6xVLt2bX322WdGsY0bN+rTTz9NVT4ATxeOm49w3AT+xbmHpHH+IWkZ6RyEPc4/cO4BsA/OPxiz5nN0avEZGoC1UnLcNBgM6eKYybkHAAAAAAAAAAAAAMi87ty5o2PHjqlcuXKSJFdXV40dO1YDBw50cGeWKVWqlJo2bZowjo2N1bp165Kd5+PjYzSOioqyeW+24Ig+N2/erAcPHsjT01OSVLZsWbVs2VJ//vmnxTlatGihMmXKJIyjoqK0ZcsWs+v+93oGSTp69GgqujZ25MiRJGsAAAAAAAAAAAAAQEYTHR2tAQMGaMqUKRoxYoQ6d+4sPz8/q/Pmy5dPM2bMULNmzdSnTx9FR0fboFukNwaDwdEtONTatWt14cIFFSpUyCjeo0cPvfPOO0lej9GnTx+T2LFjx7R7926b9wkAAAAAAAAAAAAAAACkhKujGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQue3cudNoHBgYaPeaZ8+eVa1atRLGefLksXtNSSpVqpScnJwSxgcPHkyTuinhqG3jqLoAAAAAAAAAAADp2aBBg/TPP//o66+/dnQrAABIkho2bKgJEyaYxE+ePKnhw4drxYoVio+PT4hPmjRJvr6+kqTffvtNa9eulSTlzZtXAwYM0ODBg+Xl5ZWwvqenp5YvX67KlSvrzJkzdnscI0aMULNmzWyas3Hjxho/frxJ/Ny5cxo4cKD+/PNPGQyGROe7urrqlVde0YQJE+Tn55cQz5s3r77//nt1797dpv0+1qNHD3l6etosn7u7u7Zu3aq8efMaxb/88kub1TDH1vt01qxZKl68uFEsKipKn332maZOnarQ0NBkczRv3lyTJk1SmTJljOIvv/yyVq1apUWLFtmsX+Bp5uPjYzTeuHGj+vTp46BuHPt+kCNHDr366qtGse7duys4ONhk3QsXLqh169Y6ffq0vL29JUl16tRRnTp1TK7rTE727Nm1YMECubq6JsRu3Lihnj17JvlYAUDiuPkYx03gX5x7SFpGPf8gcQ7CHHudf+DcA2B7nH/4ly0+R/MZGkBas+a46ehjJsdNAAAAAAAAAAAAAMi8Zs2apYkTJyaMBwwYoDt37uijjz5SXFycAztLWkBAgBYvXmz0vfTMmTMVEhKS7Nwnr8WKiooyWZ47d+6E9e7du6crV67owYMHNujcco7o8969e/r555/Vt2/fhNjs2bP17LPP6tixY8nOL126tGbPnm0U+/nnn3Xv3j2z62fNmtVofOXKlVR0bezq1atJ1gAAAAAAAAAAAE+3xL4D++/3Tvbg5uZmNp6ev5NLa25uboqNjbVLbnd3d7Nxtn/q8VpyjFOnTqlPnz7q27evGjVqpOrVq6tq1aoqVaqUihYtKg8Pj1Tlff755+Xr66t27drZuGNkNondKyAsLEzz589Psz4suT7kMYPBoJ9++kljx441ivv5+alTp0769ddfzc4rWrSo6tWrZxKfNm1ainrNiNsM5jk5OVk1n+cCAAAAAAAAAAAAAACwJfterQcAAIAMJ0s2qf8vlq07sY1dWwEAAAAAIFPjv8EBFK0udf4o+fWun5bmDrJzMwAAIMPjvzEyFks+C/I5MGPj8z4yKns9d3lNAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASbp9+7bR2N/f3+417927ZzT28PCwe01JqlOnjtH4r7/+SpO6KeGobeOougAAAAAAAAAAAOnd+PHjtWrVKp09e9bRrQAAoKlTp8rZ2dkoNn/+fL388suKiYmxOM+1a9f0wQcf6KefftJvv/2mChUqJCzz8fHRL7/8olq1aslgMNis98caNGigsWPH2jSnp6enZs2aJScnJ6P4smXL9MILLygqKirZHA8fPtS0adO0Z88ebd68WdmyZUtY1q1bN1WsWFGHDh2yad+SdPPmTZvm69evn/LmzWsUO3z4sObMmWPTOv9l633asGFDdezY0Sh26dIlNW/eXH///bfFedauXavKlStr0aJFat++vdGyzz//XIsXL7bLcxx42vj4+BiNQ0NDdfHiRYf04uj3g86dO8vLyythvHXrVm3bti3RWteuXdPMmTM1cODAhNiLL76onTt3Jtvnf82ePVsFChRIGMfHx6tnz566ceNGivIAePpw3HyE4yZgjHMPiXP0cdNanIMwZu/zD5x7AGyL8w//svZzNJ+hAaQ1a4+bnHsAAAAAAAAAAAAAANjLDz/8oAEDBqhIkSIJsQ8++EDdunXT1KlT0919Jnx8fNSzZ0998sknypUrV0L82LFjGjJkiEU5vL29E/4dGxsrV1dXde7cWR06dFC9evUUGBhoMsdgMOjcuXPasGGD5syZo+3bt1v/YNJpnx988IE6duyo3LlzS5ICAgIUHBysoKAgTZs2Tbdu3TI7L0eOHNq3b5+yZMmSELtx44Y+/PBDs+u7u7ub3AP+yXvEp0ZERITROGvWrFbnBAAAAAAAAAAAmUdi30f89//dtIfEfiM5PDzcrnUzkqxZs5r8trStJLZ/bfH91NOK15JjxcTEaO3atVq7dm1CzMnJSYGBgSpevLiKFy+uEiVKJPy7ePHiRv/PuTlt27bVyJEj9dlnn9m7fWRgDx48MBu/d++e+vXrl8bdWG7GjBkaM2aMXFxcjOJ9+vTRr7/+anZO7969TWLR0dEpvr9YRt1mMJXccTQ5PBcAAAAAAAAAAAAAAIAtuTq6AQAAAKQ/zi7JrwMAjuTqLmXPL3n6SO5Z/v/PS3J2luLjpIcx0oN70v07UvhNKTLM0R0DAAAA5j0t/w1euZ1Uo2vy68XFSD++bv9+gPTEkuOAs7P9+wCAtMRnA8B+npb/xsgskttffA7M+Pi8j4zKXs9dXhMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGRMTZs2VWxsrLZs2WJ1Lg8PD6PxgwcPrM6ZnOzZsxuNw8LC7F5Tkjp37mw03rVrV5rUTQlHbRtH1QUAAAAAAAAAALC1P//8U2fOnDG7zN3dXdmzZ9czzzyj8uXLy9mCH+bw8PDQmDFj1KtXL1u3CgBAijRp0kRlypQxiu3YsUM9e/aUwWBIVc5//vlHDRs21I4dO4xy16hRQ927d9eCBQus6vlJAQEBmj9/vlxc/v0BrZUrV6pt27ZW5X377bdVoEABo9jWrVv13HPPKSYmJkW5Dh06pDfffFPz58+XJF2/fl2//PKL7t69a1WPacHb21tjxowxiQ8bNizVz5Hk2GOfRkZGauPGjWrcuLGkR9cztW7dWn///XeKc8XExKhbt246fPiwSpYsmRAvWrSoGjVqpE2bNqW6TwCP+Pr6Go2joqIc1Inj3w/q169vNF65cmWydVauXKmBAwcmjOvWrZuiPgcPHmxyzA0KCtLGjRtTlAfA04nj5iMcN4F/ce4haY4+bqYnmeEchD3OP0RHRyfEOPcA2BbnH/5l7edoPkMDSGu2Om5y7gEAAAAAAAAAAAAAYGv3799X586dtWnTJmXLli0hXrJkSU2ZMkVTpkxRaGioLl++nLAsb968ypMnj65fv27zfqpVq2ZyfaaTk5O8vLyUO3dulSpVyug6Skk6e/asWrdurYiICItq+Pj4JPzb2dlZly5dUq5cuZKc4+TkpGLFiqlYsWJ64403tHv3bg0YMEAHDhyw8JGlnKP6vH37ttq0aaN169Yl3LPdy8tLn376qT7++GMdP35cp06d0t27d2UwGJQ1a1Y988wzKlu2rNG+uXPnjtq0aaPbt2+brePn52cSu3fvnsV9JubJ54Gbm5s8PT3T5HcHAAAAAAAAAABA+hcdHa2HDx/K1dXVKO7q6ipvb2/dv3/fLnWf/K3cxyz9jutpkC1btkS/W7JFbnNs8f3U04rXUvpjMBh06dIlXbp0yeR+P05OTipRooRatmypN998U6VLlzabY8SIEfrhhx8UGhqaFi0jA4qMjJTBYJCTk5NR3N/f30EdWebKlStavXq1yX0QmjRpogIFCujSpUsmc8z9LsuSJUt0586dFNXOqNssM3jyGiNrPXn/p5TiuQAAAAAAAAAAAAAAAGzJNflVAAAZQUARydXdPrkNBiku9tHfg3tS5F1J9vmdVQCwmj2Ph4/FRkuxUVLM///Fxdq3HgApZ2GpWA0pd3EpVxEpe37Jydny+Q8ipJv/SFeOSef/ki4flQzxdmsXAAAAwBM8vKWsuZNf72GM/XsBAACOx2cDAOakxfd8j69/eBgtRYZL0dw/EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASVb9+fQUFBal+/fr666+/VLVqVRkM1v2IXYkSJYzG165dsyqfJcqXL280vnHjht1rFilSRA0aNEgYh4SEaM2aNXavm1KO2DaOrAsAAAAAAAAAAGBr06dP19KlS5NdL0eOHHr55Zc1cuRI5ciRI8l1u3fvroEDByo8PNxWbQIAkGKtWrUyiQ0ZMsTqa0fCwsLUvXt3HThwQO7uj37AMCQkRNmzZ7cq75OcnJw0d+5c5c2bNyF28eJF9erVS6GhoanO6+rqqkGDBhnFoqOj9eKLLyomJnU/xLpgwQJVq1ZNmzZt0po1axQXF5fq/tLS4MGDlTu38Q/Ubty40W7XyNhrnwYHB6tJkyaqWrWqhg8frrNnz+ro0aOpzhcTE6OPP/5Yv/76q1G8cePG2rRpU6rzAhlBo0aNVLBgwYTxmTNntHPnTpvW8Pb2NhpHRUXZNL+l0sP7QcmSJY3Gx44dS7bGk8e3UqVKWdxfzZo19fnnnxvFtmzZoo8++sjiHADSL3sfwzluPsJxEzDGuYfEpYfjZnqSGc5B2OP8w5M494CnBecfMtbnaD5DA/ivjHb+gXMPAAAAAAAAAAAAAABbO3jwoGrWrKlFixapQoUKJsv9/f3l7++fMH7hhRf0wgsvKDw8XAcOHNCePXu0fPlym3zfnitXLrVt29bi9b/77jsNGTJEDx48sHjOf6/FcnFxUa5cuVLUoyTVqlVLu3fv1ltvvaX//e9/KZ5vCUf2uX//flWpUkXfffedWrdubdRH+fLlTe7l/qQ//vhD/fv314ULFxJdx9nZ2SRmi2uJzeUwVwsAAAAAAAAAADy9rly5okKFCpnE8+TJo7Nnz9qlZp48eczGr1+/bpd6GVHu3Ll15swZu+U25/bt23ap97TgtZRxGAwGnTp1SqdOndI333yjMWPGaMyYMSbr+fj46LXXXtP48eMd0CUygri4ON26dcvkGoYsWbLI09MzRddvpLVp06aZXJPi5OSkXr16KSgoyCj+7LPPmj2+TZs2LcV1M/I2yygSu97E19fXpnUKFChg1XyeCwAAAAAAAAAAAAAAwJZcHd0AAMA22g6XAgqnTS1DvHQ/TAq9LIVclK6dlC4flcKupU19AEhKWh4PH4uJlEIuSbcvSiEXpJv/SJcOS3GxadsHkNn4F5DKNZWeqSf557cul6evVLDCo7/az0tREdLfW6RDf0g3z9mmXwAAAAAAAAAAkHqO+J4v7qEUfvPR9Q+3/nl07cOV41L0/bTtAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADSG3d3dy1ZskQBAQGSpMqVK+vdd9/VV199ZVXenj17Go0PHjyY6LrZsmXTG2+8oW+//VaRkZGpqlejRg2VLl06YWwwGLRv375k53l6eqpz585yc3PTzz//nOK6n332mVxd//3J2Hnz5ik21nY/auWobePIfQIAAAAAAAAAAJCRhYSE6KuvvtKCBQu0detWFS1aNNF1PTw81LhxY/32229p1yAAAE8oV66c0TgkJES7d++2Se5jx45p1qxZql+/viZNmqQ5c+bowYMHNsn92IgRI9S8efOEcWxsrLp37647d+5YlbdVq1bKmzevUeybb77RpUuXrMo7dOhQq+antYCAAJOeDQaDXR+HvfbpY/v371f37t1tkmvVqlUmsTJlytgkN5CevfPOO+rYsWPCeNasWdq5c6dNa/j4+BiNo6KibJrfUunh/cDf399ofPPmzWTnPLmOu7u7vLy8kt2O2bJl04IFC+Tm5pYQu3Xrlp5//nnFx8db3DOA9Mvex3COmxw3AXM495C49HDcTC8y2zkIW55/eBLnHvC04PxDxvoczWdoAP+VEc8/cO4BAAAAAAAAAAAAAGBrp06dUqVKlfTSSy+pb9++qlOnTrJz/Pz81KhRIzVq1EjDhw/XuXPnNGbMGM2dOzcNOn6kY8eO2rFjh+bNm2fxnCevxZKka9euacOGDQoODtbly5d19+5dOTk5KWvWrCpatKjq1Kmjli1bytPTM2GOm5ubfvjhB8XHx2v69Ok2eTzpqc/ixYsrMDAwVb0HBgaqRIkSunDhQqrmAwAAAAAAAAAA2NPx48dVqFAhk3jNmjV19uxZu9SsUaOG2fixY8fsUi8jqlatmnbs2GHzvPnz51fu3LlN4rGxsfrnn39sXu9pwmspYzIYDProo48UEBCg/v37myxv0aKFxo8f74DOkFFcvHhRuXLlMomXK1cuXf8W/KpVq3T16lXly5fPKN6nTx8FBQUZxXr37m0y//Tp09qyZUuqamfUbZZRJHYfNj8/P5vWKVmypNU5eC4AAAAAAAAAAAAAAABbcXV0AwCAjMfJWfLxf/RXsIJUue2j+N0b0slt0vGN0s1zju0RANKSexYpb8lHf4/FPpAuHJTO7pFO75IiwxzVHZDx5Cgo1X1RKllfcnKyTw0v30efYSq3lf7ZJ22bLV0/ZZ9aAAAAAAAAAAAgfXJxlbLne/RXrIakHlJ8nHTxsHRis3Rik/QwxtFdAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDai4mJ0cSJE/XFF18kxMaPH69z587pt99+S1XOevXqqW/fvkaxpUuXmqyXM2dOvffee+rfv7/8/PxUpEgR9evXL8X1/Pz89OOPPxrFdu3apRs3biQ6x93dXV9//bWee+45Zc2aVREREdqyZYvOnz9vcd3evXvrueeeSxjHxMTo66+/TnKOh4eHXFxcjGKRkZEm6zlq2zhynwAAAAAAAAAAAGQmV65cUd++fbVu3bok16tWrVqqvpfLkyePmjRpogYNGihPnjzKmTOncuTIoYcPH+r27du6ffu2Tp06pbVr12rHjh2KjY21KK+Li4s8PDySXOfBgweKj49PUb/u7u5ydXVNdHlMTIwePnyYbB57Pe7/cnJykpeXl9llBoNBUVFRRjFvb2+1adNGTZo0UenSpZUjRw65ubnpzp07un37to4ePao1a9Zo27ZtKe7Hzc1Nbm5uiS5/+PChYmIs+wEuV1dXubu7J7o8Li5O0dHRKervvyzZN99++22q9wsA+8mePbvR+PLlyzbN/+6775q9NsIWGjRooLFjxxrF3n//fe3Zs8fq3F26dDGJJXddSGY0evRo+fr6GsXmz5+vAwcO2KWePfepPYSHhys8PFx+fn4JsSdfUwBSx8fHx2j85OfwtJIe3g9Ssy1iY2MVHx8vZ2fnhJivr2+yc2fNmqVChQoljA0Gg1588UVdu3YthV0DeFpx3OS4CZjDuYfEpYfjZnrBOYjEce4BsB/OP/zLFp+j+QwNIK04+rjJuQcAAAAAAAAAAAAAgKUMBoNmz56t2bNnK3/+/KpVq5Zq1qypChUqqGLFisqTJ0+S84sWLao5c+aoV69e6tq1q8LDw1PcQ0hIiDZv3mwS9/T0VM6cOVW0aFGj77Pz58+vX3/9VfXr19eAAQNkMBiSrfHBBx9o7Nixqly5srZs2aKgoCCtX78+2bn+/v4aPny43nvvPaP7tn/77bfas2ePDh8+bPkDtYAj+/z444/14YcfysnJyWRZSEiILl++nLB//fz8lD9/fuXMmTNhnQoVKmjt2rX65JNPNGbMGEsfMgAAAAAAAAAAQJo4evSoWrVqZRKvV6+efv31V5vXK1mypHLkyGESj46O1tmzZ21eL6OqXbu2pkyZYvO8tWrVMhs/e/Zsiu9dD2O8ljK20aNH64033jD5PYbq1as7qCNkFEeOHFG1atVM4jVr1tS+ffsc0JFl4uPjNXPmTI0aNcooXqxYMdWrV0/bt2+X9Oi3PMzdJ2L69Omprp1Rt1lGcefOHbPxIkWK2LROw4YNrc7BcwEAAAAAAAAAAAAAANiKc/KrAABgmay5pRpdpd5TpecnSkW5nhjAU8zNUypeS2rxjvTmbKnFICl7oKO7AtI3Lz+p7fvSK/+TSjWQzNzD0i6KVJNemiK1HCR5eKdNTQAAAAAAAAAAkD45u0iFK0ut3pX6/yLVffHRd38AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8LSZNGmSDh48mDB2cXHRkiVLNHr0aLm7u6co10svvaTVq1fL1dU1IbZy5UodOHDAZN0iRYro/fffl5+fnyTpzTff1A8//CBvb8t/XKZUqVLavHmzypcvbxT/+OOPk5wXExOjkiVLKmvWrJIkX19f/fHHHypYsKBFdfv376/p06cbxT7//HOdPn06yXmLFy/W/fv3jf7McdS2ceQ+AQAAAAAAAAAAyGzWr1+vsLCwJNcpVKhQinK2a9dOe/fu1bVr1zR37ly98cYbat++verUqaOSJUuqbNmyatiwobp06aIRI0Zo06ZNCg0N1YQJE+Tv759s/mLFipl8n/Xk31tvvZWiniVp3759SeasXbu2Qx/3f1WvXj3RPk+dOpWwnouLi0aNGqUrV65owYIFeuONN1S/fn2VKVNGJUqUUI0aNdS6dWsNGzZMGzZs0NmzZ/Xqq6/K2dnZ4l7Gjx+f5HabMmWKxbkGDx6cZK758+enaDs9lpJ9Y81+AWA/BoPBrvkjIyPtkjcgIEDz58+Xi4tLQmzFihX66quvbJK/adOmRuP9+/fr0qVLNsmdURQtWlR9+/Y1isXExGjkyJF2qWfvfWovDx48MBq7ubk5qBMgc/Hx8TEa2+v9JDnp8f3A0vfu+Pj4FOV955131KFDB6PYF198obVr16YoD4CnG8dNjpuAOZx7SFx6PG46Aucgksa5B8B+OP+QOHt8juYzNABbSW/HTc49AAAAAAAAAAAAAAAsceXKFS1ZskTDhg1Ty5Yt1aZNm4RlmzZt0sSJE7V27VrdvXvXZG6zZs20YcOGFN8vXpL27NmjZ5991uSvdu3aKlGihLJnz64XX3xRR44cMZrXr18/ffHFFxbVWLlypapUqaIyZcqoUaNGWrdunUXfp4eGhmr48OFq2bKl0fWS7u7u+vLLL1P2QNNxn++9955Gjx4tJyenhNiNGzc0cuRIFStWTDlz5lSlSpXUoEEDNWjQQJUqVVJAQICKFCmi69evJ8xxcnLS6NGj9d5771n8mP9bM7VskQMAAAAAAAAAAGRu69atMxtv27at0f09bKVjx45m41u2bFFcXJzN62VUjRs3TtV3jMlp3bq12fj27dttXutpw2spYwsJCTH6ffjHfH197fJaROaxd+9es/FGjRqlbSOpMH36dLPXXvTp0yfh3926dZO3t7fR8tjYWM2aNSvVdTPyNssIQkNDzcarVKlisxqurq5q3ry51Xl4LgAAAAAAAAAAAAAAAFtxdnQDAIDMqUA5qesnUo/PJf9AR3cDAI7l6i5VbCm9Nl3q+KHkl9vRHWVczd+S+vyQ/F/xWo7uFClVpNqjfVemkeSI+0A6OUkVWkq9vpFyFkr7+kg/OM4AAAAAAIDMivMeAJBynr5S3Rel12dIJeo4uhsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASFuxsbHq0aOHbt26lRBzdnbWxx9/rDNnzujDDz9U5cqV5exs+tOoHh4eqlixogYNGqTDhw9r9uzZ8vHxSVh+8+ZNDRw40Gzd4OBgTZ8+3SjWt29fnT17Vp9//rkaNWokf39/k3k5c+ZU69atNXfuXB06dEiVK1c2Wv7LL79o7dq1yT7uQYMGKSYmJmFcunRpHT16VFOnTlWdOnXk5+eXsMzJyUn58uXTq6++ql27dum7776Tq6trwvLDhw8rKCgo2ZqWctS2cfQ+AQAAAAAAAAAAyGyuXLmS5HJfX1+L8jzzzDPat2+fli9frurVq6eoBx8fHw0ZMkTnz59X7969k1z31KlT2r17d5LrdOnSJUX1n3nmGZUvXz7R5efOndO2bdsSnZsWjzulSpcureDgYH366afKmjWrRXMKFCigH3/8UatXr7Z4v6dnqd039twvAFInNDTUaJwnTx4HdWI5JycnzZ07V3nz5k2IXbx4Ub169bJJ/sDAQOXPn98otnLlSpvkzkg+++wzubm5GcW+//57nT9/3ua17L1P7Sl79uxG4/DwcAd1AmQu3t7eRuOoqKg07yG9vh84OTlZtJ65az4TU716dU2YMMEotmPHDn3wwQcp6g3A043jJsdNIDGcezAvvR43HYFzEEnj3ANgP5x/SJytP0fzGRqAraTH4ybnHgAAAAAAAAAAAAAA1tq/f7+GDh2qFi1aKGfOnGrXrp2Cg4ON1qlWrZo+++wzm9cODw/XL7/8oipVqui7774zWjZ06FDVr1/f4lwnTpxIVQ/r169Xv379jGJNmzZVyZIlU5UvOWnZZ5kyZfT5558bxTZu3KiyZctq3LhxOnfuXKJzz58/r7Jly2r9+vVG8c8//1xlypQxWT86Otok5u7unmh+S3l6elpUCwAAAAAAAAAAPL22bNmi+/fvm8QLFCigrl272rSWm5ub3n77bbPLli9fbtNaGV1AQICee+45m+bMmTOnevbsaXbZn3/+adNaTyNeS2nHXvfBunr1qtl4tmzZ7FIPmUNiv/nevn17BQQEpHE3KXPhwgWT6xokqXv37sqSJYskmf09iuXLl+vWrVuprpuRt1lGcPz4cbPxPHnyqHjx4jap0aVLF5vsK54LAAAAAAAAAAAAAADAViz/RREAAFKhUCXp5e+kSm0c3QkAOJ6Tk/RMXemV/0mV2zm6m4zJL7cUUDj5Pw8fh7WIlHKSGr8pdftU8vF3dDNS9nzSi1OkkpbfjxSZDMcZAAAAAACQWXHeAwBSz8df6jRaav6W5MQVdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACeIqdOnVKTJk106dIlo3iBAgU0duxYHThwQNHR0Vq9enXCsrfeektRUVE6ePCgJk2apPLlyxvNvXnzppo0aaILFy4kWnfgwIFas2aNUSx37twaPny4Nm3apJCQEEVFRSkkJEQ3b95UdHS0bt26pVWrVumFF16Qu7u70dyVK1eqd+/eFj3mQ4cOqV+/fjIYDAkxX19f9evXTzt27NDdu3cVGRmpmzdvKjY2VleuXNGPP/6oWrVqGeX5+++/1bJlS8XExFhU11KO2jaO3CcAAAAAAAAAAACZTWxsbJLLXVxcks3RvHlz7dmzR1WrVrWqF19fX82cOVOfffZZkuvNmDEjyeV169ZVrly5LK7btWvXJJfPnDnTbDytH7elihYtqs2bN6ty5cqpmt+8eXNt27ZNXl5eNunHEWyxb2y9XwCk3rVr14zGuXPnVsmSJR3UjWVGjBih5s2bJ4xjY2PVvXt3hYWF2SR/uXLlTGKHDh2ySe6MomrVqurevbtRLDw8XJ988old6tl7n9pLmTJl5ObmZhQ7ffq0g7oBMhcfH+Mf4I6KikrzHtLL+8H9+/eNxpb8t4Sbm5ucnY1/nPfevXtm182aNasWLlxodDwLCQlRjx49FBcXl4qOATytOG5y3AQSw7kH89LLcdPROAeRPM49APbD+Yd/2eJzNJ+hAaSF9HDc5NwDAAAAAAAAAAAAAMCeHj58qJUrV6pWrVr64YcfjJYNGDAgRfd6SGndgQMHavHixUbxoKAgu9R70qxZs3TkyBGjWPv27dOkdkqktM+xY8fK1dU1YXzkyBG1a9dOISEhFtULDQ1V+/btdfjw4YSYq6urPvroI5N1w8PDje63Lz26r4O1nsxx//59rmEAAAAAAAAAAABGYmJitGDBArPLRo0aZXLvDGu88cYbypcvn0k8OjpaixYtslmdzGLIkCEW3QffUoMHD5anp6dJ/P79+1q7dq3N6jyteC3ZX2BgoL7//ntduHBBHTp0sHn+J3/T+zFH3NMEGce5c+dMrkWQHj2fXn/9dZvWypo1q/LkyWPTnNOmTTOJ+fj4qEuXLipSpIgaNGhg0ZyUyOjbLL07depUote29O7d2+r8iV37kho8FwAAAAAAAAAAAAAAgK04J78KAADWcfOQmr8lNR0gycnR3QCA47l7Ss0GSM9PkLJkdXQ3gOM4OUtth0vVOjq6E2PunlKHUVK5Zo7uBAAAAAAAAAAApCeV2khdPpZcbHdfPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABI944cOaJKlSpp3rx5MhgMJstdXV2VK1euhLGHh4ecnMz/aN2SJUtUrlw5HT16NMmaMTExatOmjT777DPFxMSYXcfT01P+/v4KCAiQu7u72XWio6M1YsQIdejQQQ8fPkyy5n/NmDFDzz//vO7evWt2uZeXlwICAuTi4mJ2+bJly1SnTh1du3bN4pqWctS2cfQ+AQAAAAAAAAAAyEx8fX2TXH7//v0klzdu3Fh//PGHsmXLZrOeRowYoffffz/R5QsWLNCDBw8SXe7s7KwOHTpYXK979+6JLjMYDJo9e7ZJ3BGP2xLe3t5at26d0femqVGxYkV99913VuVwFFvvG1vsFwDW2bp1q0ksPb8uGzRooLFjxxrFhg8frj179tisRokSJUxiJ06cSHKOm5ubcufOrSJFiigwMFB+fn4268cRxo8fb3Jd0Lhx4xQSEmLzWmmxT+2ld+/eJrH169enfSNAJuTj42M0joqKSvMe0sv7QWhoqNHYkv8eeXKdmJgYRUZGml135syZKly4cMLYYDCoV69eunLlSsqbBfBU47jJcRNIDOcezEsvx01H4xxEynHuAbAdzj/8y9rP0XyGBpBWrDluppdjpsRxEwAAAAAAAAAAAACQvPj4eA0YMED79+9PiHl6eqpz5852rTto0CDFx8cnjOvXr6/AwEC71nxs0aJFRuMqVaqkSd2UsrRPPz8/tW/f3ig2aNCgRK8ZSExUVJQGDRpkFOvQoYPJ/UwMBoPu3btnFMuaNWuKapnzZI6wsDCrcwIAAAAAAAAAgMxn4sSJZn8HuXz58po8ebJNalSuXFkTJ040u2z27Nm6efOmTepkJuXLl9eECRNskqthw4YaNmyY2WVz5sxRRESETeo87Xgt2UdgYKCmTp2qs2fP6s0335S7u7u+/vpr+fv727RO8eLFTWKRkZG8PpCs6dOnm42PGjXK7H0WUmvSpEk6efKk3n77bTk7O9sk52+//Wb2uNGnTx+9/PLLJvcYu3DhgtatW2d13Yy8zTKCnTt3mo2//vrrVv9OyciRI1WqVCmrcvwXzwUAAAAAAAAAAAAAAGALXA0AAEgzVdpJLQc5ugsASD8KlJdenCxly+voToC05+wqdfxAKtPI0Z0kruUgqUhVR3cBAAAAAAAAAADSk6LVpbbDHd0FAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKSt0NBQ9ezZU5UqVdIPP/yg27dvWzz35s2bmjFjhipXrqyuXbvq1q1bFs2Li4vTqFGjVKpUKY0fP14XL160uOatW7c0fvx4lSpVSp9//rni4+MtnvvYggULVLp0aU2aNEkhISHJrh8fH6+1a9eqWbNm6ty5s+7cuZPimpZy1LZx9D4BAAAAAAAAAADIDLy9vVWgQIEk1wkLC0t0Wb58+TR//ny5uLjYuDPpk08+UZ06dcwuCw8P17Jly5Kc36VLF4vqFCtWTBUrVkx0+aZNm0y+i3LU47ZE9uzZVbRoUZv00qdPH9WrV88mudKKvfaNtfsFgHXWrFmjmJgYo1jv3r31xhtvOKijxOXMmVPz5s0zOg4tX75ckyZNsmmdfPnymcTOnDljNHZxcVHHjh01c+ZMnT59Wg8ePND169d17tw5Xbp0SXfv3tWdO3e0ZcsWvf/++zZ7/0gLzZs3V+PGjY1iV65c0eTJk21eK632qT1Uq1ZN77zzjlHs4sWLWr16tYM6AjIXHx8fo3FUVFSa95Be3g9OnTplNC5btmyyc8qVK2c0Pn36tNn13nrrLXXq1Mko9uWXX+qPP/5IYZcAwHETQOI492BeejluOhLnIJJXrVo1ozHnHgDb4vzDv6z9HM1naABpxZrjZno5ZkocNwEAAAAAAAAAAAAAlomPjze5rrJhw4Z2rXnlyhXt3bvXKFazZk271nzs+PHjRuM8efKkSd2UsrTP6tWry83NLWF8/fp1bdy4MVU1N23apOvXryeM3d3dVb16dZP1nvxNgRIlSqSqXlI5LLmPPwAAAAAAAAAAePqcOHFCCxcuNLusf//+evfdd63KX6JECS1btkyenp4myx48eKDPP//cqvyZ2bvvvqvXX3/dqhylS5dO9N7kDx8+tMv9Yp5WvJbs44cfflC/fv3k7u6eECtYsKAWLVokLy8vm9SoUaOGihcvbhK/fPmyTfIjc/vpp59069Ytk3iWLFn0yy+/yNvb2+oar732mvr06SM/Pz9NmTJFBw4cUO3ata3O+/DhQ/38888m8UaNGqlfv34m8R9//FEGg8Hquhl5m2UEib0X5cqVy6p7t3Xo0EFjxoxJ9XxzeC4AAAAAAAAAAAAAAABbcHV0AwCAp0uFFtLd69KueY7uBADSh2x5pRcnSYs+lG6Y/40/IFNq8Y5Uoo71eeLjpPCb0oN70sNoyWCQ3LwkjyySj7/kZvr/klnM2UXq8IE0b4h046z1vQIAAAAAAAAAgMyhZD2pelcpeLGjOwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAtHX48GH169dP/fv3V6lSpVS1alUFBgaqfPny6tmzpyRpz549mj9/vi5fvqyjR4/q77//tqrmP//8o+HDh2v48OEqXLiwKlasqGLFiilnzpzy9vaWm5ubIiIidOfOHV2+fFl79+7VqVOnbPFwde3aNQ0ePFhDhgxRtWrVVL58eRUpUkQ+Pj5yd3dXZGSkrl+/rpMnT2r79u26c+dOquq0a9dOkvTRRx9pzJgxFs9z1LZx5D5JzNChQzV06FC71gAAAAAAAAAAALCFV155Re7u7kmuc/z48USX/fTTTwoICEi2Tnh4uA4cOKDbt2/LxcVFefPmVZUqVZKs7erqqunTp6ts2bJml8+cOVPPP/98ovMbN26sbNmyKSwsLMneunXrluTymTNnmsQc+bjT2nvvvaft27c7ug2L2WvfpLf9Ajxtrl+/rjlz5ujVV181iv/vf/9TzZo1NWrUKF2/ft1B3f3LyclJv/zyi/Lly5cQu3Dhgl5++WWb13ryWBcVFaWHDx8mjHv16qVPP/1UBQoUSDJPtmzZ1KBBAzVo0EBBQUFasmSJhg4dqgsXLti8Z1v64osvTGIffvihHjx4YNM6ablPba1Vq1aaO3euyXvbsGHDFBcX56CugMzF29vbaBwVFZXw74IFC6pWrVoqU6aM8ufPL19fX3l4eCgqKkoRERE6e/asjh07pq1btyoiIiLVPaSX94OtW7fqhRdeSBi3bdtWEyZMSHJOmzZtjMbm/rujatWqmjhxolFs9+7dGjFihEV9AcCTOG4CSAznHsxLL8dNR+IcRNIen3/4L849ALbF+Yd/Wfs5ms/QANKKLY6bjj5mShw3AQAAAAAAAAAAAACW27lzp9E4MDDQ7jXPnj2rWrVqJYzz5Mlj95qSFBISYjT28fFJk7opZWmf+fPnNxpbew//U6dOGe2L/14b+9jBgwdVpEiRhHGFChW0dOlSq+pWqFDBpAYAAAAAAAAAAIA577zzjlq2bKmsWbOaLPvqq69UsmRJvf3224qJiUlR3mbNmmnhwoXKli2b2eUff/yxzp07l5qWM62rV68afZ80bdo0lS5dWkOHDk3xvUvatGmjX3/9VX5+fmaXf/vttzp58qRV/cIYryXb+/DDD9W6dWs5OTkZxRs3bqwNGzaoR48eunTpUqrzZ8uWTT/99JPZZatXr051Xjw9IiMjNWbMGE2dOtVkWfXq1bV161a1atVKN2/eTFX+t99+W5MmTTKKVaxYUTt27FCrVq20Zs2aVOV9bPr06Sa/N+/k5KRcuXIZxeLi4jRjxgyraj2W0bdZejd//nx98cUXZq9P6d27t65du6aRI0emKOfrr7+uqVOnytnZOSF26tQpPfPMM1b1ynMBAAAAAAAAAAAAAADYgqujGwAApK3YB9K90JTNcXGV3Lwkd69H/7ZW3RelC39JV627NxUAWCU1x0NJcnKSXNwkN0/J00b3DMySTeoeJM1+W7rr+N86B+yuYiupfLPUzY17KP2zTzq7R7p8TAq9LBniE1nZSfLPL+UtKZWsLxWplvLPMu5eUpth0qz+Ujy/rQ4AAACkWugl6eS25NdL4X1BAABABsVnAwDWuH9Hunw0FROdJFf3f7/ny5ZPcvdMfR8Nekund0hh11KfAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyKoPBoBMnTujEiROSpCpVqqhnz56SpG3btmny5Ml2qXv+/HmdP3/eLrmTEh8fr71792rv3r12rePj8+iHsaKiolI811HbxlF1AQAAAAAAAAAAMqIuXbroiy++SHa9xL6Xqly5slq2bJnk3Fu3bundd9/V/PnzFffED8L5+vpq2LBhGjlypJydnc3OL1OmjFq1aqXVq1ebLFu/fr0uX76swMBAs3Pd3NzUtm1bzZ07N8keu3fvnuiyiIgILVmyxCjm6MedGmvWrNHMmTN1/Phx3b9/X7ly5VLjxo01ePBg5ciRI8m57du3V7Zs2RQWFmaTXuzJFvsmLCwszfYLgJQZMWKEWrZsqfz58xvFX3nlFb300ktas2aN1q1bpz179ujIkSMO67F58+YJ49jYWHXv3t0ux1Bvb2+j8b179yRJfn5+mjdvnlq3bp3inM7OzurWrZtat26tAQMG6Oeff7ZJr7bWs2dPVapUySh27Ngxu/SblvvUWs7OzipYsKDq1Kmj3r17q1mzZibrTJ8+XQsWLHBAd0Dm9OSxOEuWLBo+fLhefvlllS5d2qIcDx8+1Pr16/XNN9/ojz/+sLoHR70fLF26VFOmTJGn56Mf6G3QoIHq1aun7du3m10/T5486tOnj1Hsyf928/Pz08KFC+Xu7p4Qu3Pnjnr06KGHDx+m9GEBgCSOmwCSxrkHU+nluOkonIMwldz5B849ALbH+Yd/Wfs5ms/QANKKrY+bnHsAAAAAAAAAAAAAAKR3t2/fNhr7+/vbvebj7+Mf8/DwsHtN6dF9LP4rJiYmTeqmlKV9Pr624LH79+9bVTciIsJonCVLFpN1goOD1alTp4Rxw4YNrappLkdwcLDVOQEAAAAAAAAAQOZ048YNvfnmm5o3b57Z5X379lXLli31wQcfaP78+cn+P5Rly5bVp59+qo4dOya6zvbt2zVhwgRr2s6U/ve//+mll15S8eLFE2Lvvvuu2rRpo1GjRmnJkiUyGAxJ5ihfvryCgoLUrl27RNc5f/68Ro8ebbO+8QivJdv766+/9P3336t///4my2rXrq3jx49r/Pjx+v77702+p09OixYt9M0336hEiRJmly9atChVPePp8/3336tHjx5mv+uvUqWKjh49qo8++kjTpk2z+D4E5cuX1/jx4xP9jYng4GCtW7fOqr4l6fTp09qyZUuy1ymsXr1aV69etbreYxl5m6V3Dx8+1KRJkxJ9bxgxYoQqVqyoQYMG6fTp00nmqlKlioKCgky2aXBwsDZt2qRhw4ZZ3S/PBQAAAAAAAAAAAAAAYC1XRzcAAEhbl45Kiz9I/fwsWaUchaRcRaSiNaSCFSWXFL6bOLtILd6RZvaXlPT1/QBgN9YeDyXJxU3yyyUFFJbylpKKVJVyFU1dLi8/qcvH0pxBUmyUdX0B6VnuElKTfimfF31f2v+7tP83KSrcwkkGKfTyo79jGx69zmp2k6p0kFzdk5/+WM5CUvUu0p6FKe8bAAAAwCOndjz6AwAAkPhsAMA6N85KvwfZJpdfbqlgBemZelLRao+uZ7CUi6vUoI+0/DPb9AIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQN26dSVJV65ccXAnAAAAAAAAAAAAsJVChQqpUaNGeuWVV9SgQYNk179w4YJ2795tdtnw4cOTnHvr1i3VrFlT//zzj9nlERER+vDDD3X16lVNnTo10TyDBg3S6tWrTeIGg0GzZ8/WyJEjE53bpUsXzZ07N9HlRYsWVeXKlRNdvnDhQkVFRRnFHP24UyIyMlKvvPKKFixYYBQ/d+6cdu/erRkzZmjbtm0qXrx4ojmcnZ1Vu3Ztq3tJC7bYNwMHDrT7fgGQOrdu3VLHjh31559/KkeOHEbL3Nzc1LZtW7Vt21bSo/eI/2rWrJkiIiL0999/686dO3bpr0GDBho7dqxRbOjQodq7d69d6rm7uxuN79+/Lx8fH61fv17Vq1c3O+fu3bu6e/euPD09lSNHDrm4mP/RRG9vb82aNUsFChTQp59+avPereHm5qagINMfkRw+fLji4+NtWiut96kl5s+frxYtWpjEXVxc5OPjIycnp0TnTp06VQMHDrRne8BTxcvLS87OzkaxuXPnJvk6NMfV1VUtW7ZUy5YttW3bNvXt21cnTpyweH56eT+4ffu2fvrpJw0YMCAhtnDhQrVr10779+83WrdgwYJatmyZfHx8EmK7du3S9u3bjdabMWOGihYtahTr3bu3Ll68mGQvAJAUjpsAksK5B1Pp5bjpCE/zOYjUnn/g3ANge5x/MGbt52g+QwNIK9YcN/Pnz58ujpmcewAAAAAAAAAAAACAzK9p06aKjY3Vli1brM7l4eFhNH7w4IHVOZOTPXt2o3FYWJjda0pSvnz5jMY3btxIk7opZWmf9+7dMxpnzZrVqrrZsmUzGoeHh5us8+Q9TBo0aKBcuXLp5s2bqaqZN29e1atXzyi2Z8+eVOUCAAAAAAAAAABPh/nz56tcuXIaNWqU2eWFChXSnDlz9O2332rNmjXau3evrl+/rpCQEHl7eyt37twqUaKEWrVqpZIlSyZZ69y5c+rYsaPi4uLs8VAytAcPHuill17Sli1bjP7/3GeeeUaLFi3S7du39eeff2r//v26fv267ty5I19f34Tt37Jly2S3f1RUlDp27KiIiAh7P5ynEq8l23v33XdVo0YNVatWzWSZj4+Pxo4dqw8//FA7d+7U5s2bdeLECZ0/f14RERGKjIyUk5OTvL29lS1bNhUrVkyVK1dW69atVaJEiURrrlixQjt27LDnw0Im0717dwUHB6tgwYImywICAvTdd99p9OjRWr16tdavX69Lly7p5s2bioyMlLu7u3x9fVWwYEFVqFBBrVu3Vq1atRKtde3aNXXr1s1m9/2aNm2aGjZsmOw6tpaRt1l6N2nSJHXo0MHk2pHHWrdurZYtW2r37t1as2aNLl68qFu3bsnJyUn+/v4qX768mjVrpooVK5rMjY6O1iuvvKIXXnjBZv3yXAAAAAAAAAAAAAAAANZwdXQDAICMJfKuFHlYunRY2v+75OEtVWoj1ewmefpaniegiFS6oXRis91aBQC7i4uV7lx59Hdqh7TlJylb3kfHxYqtHh0jUyJnIandMGnpx/bpF3A0J2ep9WDJ1T35df/r1A5p3bfS/TvW1Y8Klzb/JB1YKXUYKeVN+v89M1L3RenkNinsmnU9AAAAAAAAAACA9CP8hnR03aO/7PmlZ1+Xiid+7x0Tz9SVfHJI90Ls1yMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIPNzcnLSpEmTVKvWo5virV692sEdAQAAAAAAAAAAwBLTp0/XlClTzC7z8PCQn5+fPDw8UpTz22+/NRt3dXVVu3btkpw7YMAA/fPPP8nW+P777zVgwACVLVvW7PKGDRvK3d1dMTExJstmzZqlkSNHJpq7RYsWypIliyIjI80u79q1a5K9zZw502icXh63pd58800tWLAg0eXXr1/Xa6+9ps2bNyeZp06dOun+e0Nb7Zu02C8AUm/fvn2qUaOGFixYoGrVqiW6npOTk9F4yJAhGjJkiCTpwoUL2rt3r7Zs2aKFCxfq1q1bVveVM2dOzZs3Ty4uLgmx33//PdH3ZVtwdnY2GsfFxenHH39U9erVE2L379/Xjz/+qN9//127du3SgwcPjOaUKlVKzZo1U//+/VWqVCmTGp988omuXLli8n7oSP3791fhwoWNYlu2bNGqVatsWscR+9QS3t7eypYtW4rmXLp0Sf3799fKlSvt0xSQhqpUqaKgoCCL1/2vZs2aWfyZdtCgQTp58mSS6/j4+JjEnnz/San69esrODhYvXr10tKlSy2ak57eD4YPH67mzZurRIkSkqS8efNq79692r59u44dO6aHDx+qWLFiatKkidF/m967d08vv/yyUa7+/furS5cuRrHJkydr+fLlRrGcOXOqc+fOatasmfLnz69s2bIpLCxMly9f1rp167Rs2TLdvn07yb4BpI30cgznuMlxE0gO5x6MpafjZlp7ms9BpOb8Q7t27Tj3gEwjvXx2lTj/YI41n6P/i8/QQOaUXo7h1h4308Mxk3MPAAAAAAAAAAAAAJB51a9fX0FBQapfv77++usvVa1aVQaDwaqcj7+bfuzatWtW5bNE+fLljcY3btywe01JevbZZ43GFy9eTJO6KWVpn9evXzcaly1bVi4uLoqLi0txTVdXV5UpUybJ/JK0efNmXbp0SQUKFJD06FqLAQMGaMyYMSmuKUkDBw40ul7j1KlTCg4OTlUuAAAAAAAAAADw9Pjggw/k5OSU5P3Ns2bNqu7du6t79+6pqnH8+HG1bNlSISEhqW0z09u9e7fefPNN/fTTTyb3U8iZM6defPFFvfjii6nKHRUVpc6dO+vQoUO2aBWJ4LVkWzExMWrVqpXWrFlj8v/EP+bm5qaGDRuqYcOGVte7ffu2+vXrZ3UePF1u3ryppk2bauPGjQoMDDS7Tu7cudW7d2/17t071XVu3LihFi1a2PTajCVLluibb76Rv7+/2eVXr161+X3GpIy9zdK7uLg49ejRQwcPHlRAQIDZdZydnVWnTh3VqVPH4rwGg0Fvvvmmjh49aqtWJfFcAAAAAAAAAAAAAAAA1nF1dAMAgIwt+r60Z6F0cJXUZphUvKblcyu3k05stltrAOAQYdekzT9KuxdI9XtJldpITs7Jz3useG2pVAPp76326xFwlAotpIAilq8fH/fo9bRvmW37CL8h/TpEavWeVKaRZXNc3aVaz0l/TrJtLwAAAAAAAAAAIH24c0Va+pFU5wWp3kuWzXF2kUo/KwUvtmtrAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBMLHv27Jo3b55atGghSTp//rw+/vhjB3cFAAAAAAAAAAAAS/j7+8vf399m+c6cOaOvv/7a7LJq1aopS5Ysic49f/68Fi1aZHGthQsXJvq9lIeHh6pVq6adO3eaLDt9+rR27typOnXqmJ3r5eWlli1baunSpWaXd+/ePdGezpw5ox07dhjF0svjtsTGjRs1Z86cZNfbsmWLTpw4odKlSye6Tp48eVLVQ1qy5b6x534BYL1z586pevXqev755zV48GBVq1YtRfMLFSqkQoUKqVu3bpo8ebJWrlypkSNH6sSJE6nqx8nJSb/88ovy5cuXEDt//rx69+6dqnypVbhwYRUrVixhvHDhQvXr10+hoaGJzvn777/1999/69tvv9Wrr76qr7/+Wl5eXkbrfPvtt9qyZYvOnTtnt94t5evrqw8//NAkPnToUJvWSS/71Fby58+v5557TsHBwbpx44aj2wGskjNnTrVs2TJVc/Pnz6/8+fNbtG7WrFmTXcfb2zvRZWFhYQoODta+fft05coV3blzR7GxsfL19ZW/v78qVqyoOnXqqGjRombzLly4UN26ddOyZcss6ve/HPl+cP/+fbVq1Upr165NeGzOzs5q0KCBGjRoYHZORESEOnXqpNOnTyfEKlWqpK+++spovX379mnYsGEJYycnJ40YMUIjRoyQj4+P2dzdunXTV199paCgIH3xxRcyGAyJ9g7A/tLTMfy/OG7+i+Mm8C/OPSTuaTj/IHEOIjU494DMJD19duX8gylrPkc/xmdoIPNKT8fw/0rpcTM9HDM59wAAAAAAAAAAAAAAmZO7u7uWLFmigIAASVLlypX17rvvmnwvnFI9e/Y0Gh88eDDRdbNly6Y33nhD3377rSIjI1NVr0aNGkb3RzAYDNq3b1+ScypVqqSRI0fq+vXrevvtt1NVN1++fOratatRbM2aNanKlZi07vPQoUOKj4+Xs7OzpEf3qO/SpYsWLlyY4rqdO3dW9uzZE8ZxcXE6cuSIyXoGg0EzZ87U6NGjE2JDhgzR9OnTdfny5RTVLFiwoAYPHmwUmz59ego7BwAAAAAAAAAAT6tRo0bp3LlzmjJlSpL/f39qrFq1Si+++KLCwsJsmjczmjlzpuLi4vTjjz/Kzc3NJjlv3Lihrl27avv27TbJh6TxWrKt27dvq1GjRpo9e7Y6duxotzqXL19W06ZNdeXKFbvVQOZ1+vRp1a5dW0uWLFGNGjVsnv/AgQPq0KFDiq8jSE50dLTmzp2b6DUZM2fOVHx8vE1rPpZRt1lGcPXqVdWvX1+rVq0yur9HasXHx+utt97SrFmzrG/ODJ4LAAAAAAAAAAAAAAAgtZwd3QAAIHOIvi8t/Ug6/KflcwLLStny2q0lAHCoBxHSuu+kBSOl+3dSNrdxX8nNK/n1gIzEPYtU72XL1zfES6smSvtS/vvIFomLlVaNl84fsHxOmWclT1/79AMAAAAAAAAAANKHnb9IB1dZvn6RKvbrBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyiqtXr2rMmDEaM2aM1qxZ4+h2MpSyZcuqadOmkqQjR46ofv36CgkJcXBXAAAAAAAAAAAASGuRkZHq2rWrYmJizC5v0KBBkvNXrFiRonqHDx9OcnmNGjUSXTZjxowk53bt2tVsvHDhwqpatWqi82bOnGkSS0+POzk//fSTxetu27YtyeXZs2dPdR9pxZb7xp77BYDtzJs3T9WrV1fJkiX1zjvvaN68eTpz5owMBoPFOVxdXdWxY0cdOXJEQUFBqepjxIgRat68ecI4NjZW3bt3V1hYWKrypZaLi0vCvz/99FP16NFDoaGhFs01GAz68ccfVa9ePYWHhxsty5Ili7744gub9ppaw4cPV44cOYxiixYtUnBwsE3rpJd9aivOzs564YUXdPToUTVq1MjR7QCZRlhYmFauXGkUW758udq3b6+AgAA1b95cI0eO1Hfffadff/1VixYt0owZMzRx4kS99NJLKlasmOrWrWv2c6qLi4tmz56t4sWLp7gvR78fnD17VjVr1tSsWbMUHx+f5LobN25UrVq1tGHDhoSYr6+vFi1aJA8Pj4TY3bt31a1bN8XGxkqS3NzctHjxYgUFBcnHxyfJGj4+Pho3bpwWLFggV1fXZPsH8PThuGmM4yZgjHMPphx93EwrnINIOc49APbB+QfzrPkczWdoAI6Q2uOmo4+ZEsdNAAAAAAAAAAAAAMhsYmJiNHHiRKPY+PHj1bFjx1TnrFevnvr27WsUW7p0qcl6OXPm1Lhx43ThwgV98cUX+vLLL1NVz8/PTz/++KNRbNeuXbpx40aic5YuXaq//vpL3bp1U//+/dWkSZMU13Vzc9PPP/8sb2/vhFhoaKg2bdqU6BwPDw9lyZLF6C8pjugzJCREO3bsMIp9+eWXypMnT4rq5s2bV1999ZVRbPv27Yne3/777783uh4iS5YsWr58uXx9fS2u6efnpxUrVsjT0zMhFhISkuw9SAAAAAAAAAAAAP7rp59+Uvny5fXnn3/aJN+1a9f00ksvqW3bthnyHiKOMnv2bNWpU0enT5+2OteiRYtUtmxZbd++3QadwVK8lmwrIiJCnTp1Urdu3XTx4kWb5jYYDJo7d66qV6+ukydP2jQ3ni6XL19WvXr1NGrUKEVGRtokZ2RkpIYPH64aNWro8uXLNsn5pGnTppmNP77Hgz1l1G2WEZw8eVI1atTQ6tWrrcpz69YttWzZUlOnTrVRZ+bxXAAAAAAAAAAAAAAAAKnh7OgGAACZiEFa950UkoJrlQtVtl87AJAeXDwozR0khV23fI5PDqnuC/bqCHCMqh0k72yWr79xmnQi8fty2oQhXvrtU+lu4vcdNeLqLpVvYd+eAAAAAAAAAACA422aLkWFJ7+eJOUtad9eAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAjuH79usaOHauxY8dq/fr1jm4nQ9m+fbtGjhypuXPnqnbt2rp8+bKjWwIAAAAAAAAAAEAau3fvnjp27KhDhw4luk6RIkWSzHHx4kXly5fP4j9XV9ck8+XOnTvRZQsXLlRUVFSiy9u2bSt3d3eTeNeuXROdEx8frzlz5pjE09PjTs7WrVstXveff/5Jcrmfn1+q+0grttw39twvAGzv1KlT+vrrr9WzZ0+VKFFCPj4+ql69uiIiIhLWuXXrluLi4hLN4eLiopEjR2rBggVycnKyuHaDBg00duxYo9iQIUMUHByc8gdiI/PmzdOHH36YqrkHDhxQ165dZTAYjOJdunRR8eLFbdFequXOnVuDBg0yisXGxmrEiBE2rZMe9+l/9ezZUzly5DD5y5Url4oXL6769evrvffe044dO0zm5syZU3/++aeeffZZB3QOZD5hYWFq166dKleurO+//141a9ZUhw4dtGLFCj18+NCiHDt37lT79u31wgsvKDo62miZj4+Pvv/++1T358j3g9u3b6tPnz4qXry43nnnHc2dO1fr1q3Tpk2bNH/+fI0ZM0ZVq1ZVkyZNdPz4caO5P/74o0mNV155RefPn08YT5w4UZ07dzZa58iRI5o8ebI+/PBDTZkyxSRvt27dNG7cOEsePoCnFMdNjptAUjj3YCqznn+QOAchpf78A+ceANvj/EPiUvs5ms/QABwptcdNzj0AAAAAAAAAAAAAAGxp0qRJOnjwYMLYxcVFS5Ys0ejRo83elyEpL730klavXm30/+evXLlSBw4cMFm3SJEiev/99xPuXfDmm2/qhx9+kLe3t8X1SpUqpc2bN6t8+fJG8Y8//jjJef+9z7qLi4tWrFihF1980eK6efPm1erVq9W0aVOj+JgxY/TgwYNE5y1evFj37983+kuPfQYFBRmNAwMDtWnTJpUtW9aiuuXKldPGjRuVP3/+JPP+1/Xr1zVkyBCjWOXKlS2uW7ZsWW3evFkVKlQwir/zzjsKDQ21qG8AAAAAAAAAAIDH/vnnH7Vq1UrVq1fXwoULFRkZmeIcBw8eVN++fVW4cGHNnTvXDl1mfvv27VPZsmXVr18/nTt3LkVzHzx4oEWLFqlKlSrq3r27QkJC7NQlksJryfYWL16sIkWKqFu3blq/fr3JvUNS4s6dO5oxY4Zq1qypl156SdevX7dhp3haxcbG6rPPPlORIkUUFBRkdO1DSly6dEmjR49WgQIFNH78+CTv6WatY8eOaffu3SbxdevWGd1LwV4y4jbLKEJDQ9W6dWs1btxYu3btStHcsLAwTZgwQcWLF9e6devs1KExngsAAAAAAAAAAAAAACClXJNfBQAAy8XFSpt/krokfQ+vBAXKS4f+sG9PAOBod29I84b+H3v3HSdVdf9//D3b2UJZliq9SJNeFKQj9o6IYkH92RM1iRp7NH4TNWqMiYrGhiXBDjYEK6iA0mGl914W2GVhe/39MQFZ2Jk5M3PvlDuv5+PBI9k7n/s5n3vn7jnnnrsPr3T1c1JafbN9ep8n/fyuVFJga2lAaLiknmeZh6+ZLS362LZqaigrkma9Kl3wgO/YijKpbiP7awIAAAAAAAAAAOFVXiKt+VHqdY7v2OQ0KbWeVJRvf10AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGd68sknw10CAAAAAAAAAAAAwmTlypW64oortHTpUq9xmZmZXj9/6qmn9NRTT1lWl7f2Dh06pClTpuiKK66o9fOMjAyNGjVK06dPr7F97NixHnN+99132rZtm191SKE9bm+qq6u1e/du4/iCggKvn7tcroDqCKVQfjeBfi8AQqOoqEgLFy5UaWmpMjIyJElXXnmlZs2apZNOOkkDBw7URRddpBEjRiguLq7GvpdeeqlWrVqlRx55xGc7WVlZeueddxQfH39k28cff6x//etflh6PPwoLC/W73/0uqBxff/213n//fY0bN+7INpfLpUsvvVSPPfZYkBUG7sEHH1RaWlqNbS+//LI2bNhgWRuR+J0e69ChQx4/27t3rzZs2KDZs2frmWee0YABAzRp0iR17dr1SExycrI++OAD9ejRQzt37gxFyYCl5s2bp1NPPdUo9oknntCQIUOO/Dx9+nT95S9/Mdp35cqVxjUtXbpUt956q3F8bSZPnqyDBw/qk08+qTE2nXbaaTr11FM1Z84cv/JFyniwadMmv/rQm266SZdeemmNbS+88IKmTJly5OdBgwbp9ttvrxHz29/+Vi+88MJx+e688049/fTTNX5+7733tHDhQuOaAFgnEvvww+g33eg3AXOxvPYgRU6/aRfWIIJbf2DtAU4QiXNX1h8882cezRwacL5I7MMPC7bfZO0BAAAAAAAAAAAAAGCV8vJyjRs3TrNnz1ajRo0kSXFxcfrzn/+s66+/Xq+88oo+//xzLVu27Lh9k5OT1blzZ40YMULXXXedunfvXuPznJwc/fa3v6213QULFuiVV17RDTfccGTbTTfdpAsvvFBvvPGGZsyYoezsbOXm5tbYLysrSwMGDND48eM1duxYJSUl1fj8v//9r7766iuvx/zAAw/orLPOUocOHSRJderU0dtvv63f/e53mjRpkmbOnKl169apvLz8yD5paWkaMGCAxowZowkTJig9Pb1Gzu+//14vvvii13b9Fa46v/zyS7377ru67LLLjmzr3LmzFi9erA8//FCTJ0/WggULlJOTU2O/xo0bq3///poyZUqt38vXX3/ttd1XXnlFF110kc4666wj2/r27avFixdrypQp+uCDD7Rq1aoj/+2Mpk2bqmvXrrrkkkt08cUXH9fm1KlT9d///tdrmwAAAAAAAAAAAN4sXLhQ48aNU0pKikaPHq0BAwaoR48eOuGEE1SvXj2lp6ertLRU+fn5ys3N1YoVK7Rs2TJ99dVX2rJlS0hqfPTRR/Xoo4+GpC0rmf43zsvLy/XSSy/ppZdeUt++fTV69Gj16tVL7du3P/IdlJSUKD8/X7t371Z2drbmz5+vGTNmqLCwMGx1x2oeTyLtdymU/439a6+9Vtdee62lOauqqvThhx/qww8/VGpqqoYNG6YePXqoc+fOat++vTIyMpSenq60tDRVV1eroKBAhw4d0sGDB7VhwwZlZ2crOztbc+bMUUVFhaW1BSNaruej2fH9BitS3iGRk5OjBx98UA8++KD69eunwYMHq2/fvmrdurUaN26stLQ0JSQkqKysTAcPHtSBAwe0Zs0arVixQt9++62ys7NDWu/AgQND2l5tIu2cOel3aebMmRo0aJBatmypM844Q8OHD1fz5s3VqFEjZWZmqqKiQgcOHFBOTo6WLFmiOXPmaPr06SorK6s133333af77rvPtnoj7VoAAAAAAAAAAAAAAACRKyHcBQAAnGfTIqnkkJSS4Ts2s4X99RyWWEeq20hKTHH/c8VJleVSRYlUlC8d2i+pOnT1BMwlpWdKSalScqr7WKqrpdJCqbRAKjoolReHu0jf0jKllHT3cSSmSFUVUlmRVFokFR2QykvCXWF0Ss+SUtKk5HQpPlGqKJXKiqWCfVJJQbiri22H9kofPypd/pQUF+87PjFZ6nGmNP9D+2s7LD7R/buZVMf9LyHZvb2yXKook0oOSgW57p8RuFg8z+37S3Ubm8WWFkpfP2dvPcda86O0c5XUvMvxn1VVSluzpZXfSWvnuMeqUHHM3KUW8YnuY0tKdf9zxbnHrPIS6WCO+zpA8Jx8DSF0uI7Cy+nnn/Egsjn9+rMC9+CIBE7/XWWsCJDLfd7qZLivi7gEd/9UWuhee+W8RSmeDUQN+i5n4nuNbE6ZE3GPEXm2r5B6nWMWW6ee+3qLZo58huWQORRig1PGM0QmR/bxx3DFSfWauOdSSXXc28pL3Pebh/a651Z2Sc9yr8Mkp7nXYSrL3ePLwb3uv6OMRq44d5+UnOY+n6wvAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgvZycHD399NN69tlnVV7u+8URDRs2DEFVv8rMzPT6+aRJk3TFFVd4/HzMmDGaPn36kZ9btWqlAQMGeM1Xm0g7bk8OHTqkiooK4/iqqqqA2okkofxuAv1eAIRXWVmZFi9erMWLF+uFF15Qt27d9MILL2jYsGE14h566CG98847WrNmjcdcLpdL//3vf9W8efMj2zZt2qRrrrnGrvKN/Oc//1FOTk7Qef72t79p3LhxNbaNHj1ajz32WNC5A9G0aVPdcMMNNbYVFRXp//7v/yxrI1K/02DMnz9f/fr101dffaXBgwcf2d6wYUM99dRTXudOQKTKz8/X3LlzjWL3799f4+c9e/YY7xsOn3/+uV566SXdeuutNbZfffXVmjNnjl+5onE86Nmzp5599tka25YsWaI//OEPNbbdfffdNX5+8cUX9cILL9Sa8+9//7tOOumkI325y+XSXXfdpcsuu8yyugGYi+Q+nH7TjX4TCF4srD1I0dlvmmINwn+H1x+KioqObGPtAdEukueuwYr19Qfm0IDzRXIfbkW/ydoDAAAAAAAAAAAAAMAqa9eu1ahRozRt2jS1bNnyyPaWLVvq0Ucf1aOPPqqKigrl5uYe+ey2227TnXfeKZfLVWvOnJwcjRo1Slu2bPHY7m9/+1u1atVKZ5xxxpFtTZo00T333KN77rlHklRSUqKioiJVVlaqXr16SkpK8pjv888/N/obzEOHDunMM8/U119/rbZt2x7Z3rdvX/Xt21eS+7+5cOjQIZWWliojI0N16tTxmG/RokU677zzVFlZ6bNtf4SzzgkTJqhhw4YaPXr0kW1JSUkaP368xo8fL0kqLy9Xfn6+JKlevXpKTEysNdeMGTN07bXX+j5gSZdccom++OKLGn9znZSUpMsuu8yvvyn45ptvjtQJAAAAAAAAAAAQrJKSEn322Wf67LPPwl1KTFu0aJEWLVoU7jIQBH6XrFdUVKTp06fXeOcCEGkWLlyohQsXhruMqMI5s8e2bdv06quv6tVXXw13Kca4FgAAAAAAAAAAAAAAgDcJ4S4AAOA8VRXS9hVSh1N8x9ZvalMRLqnlSVKbvlLzzlLj9lKdDO+7VFZIeTukHaukrUul9fOk8mKb6vNDSobUrr/UpreU1UZq2EpKTPa+T95Oafc6aftyafUPUnF+SEr1KCFZatvXfRyN20kNW0tJKZ7jq6ulgznS3k3SjpXSup+k3G2hqzdY9ZpKTTpIaQ2k5DQpqZb/rtu896XSwuDbat5ZOnHI/67zdrW3dVjRAWnXWmnzImntHOnQvuDbh392rJQWTpUGXGIW3/s8acEUqbrKnnoaNJc6DJRO6CpltXb/7Irzvd/BHClno7RtubRpobRvsz31OQXnWep5jnns3HekojCMW0u/kJp3+fXnHaukVTPd42jRgRAU4KC5iyft+ksnnuo+z5ktpLh4z7FF+dKuNdLmxdKa2VIBY5ZvMXANHRbKuVYkCOnxxtB1FJFi4PzHJbjvbRkPIlAMXH9WiNV78FgbeyNaDPyuMlYErmV3qf0AqVUv32vIB/dKe9ZLW5ZIa36UCvNCVib8wLOB6Hk2QN/lTHyvEcxBc6JYvceIJv6c56RU++qwixOfYTlhDoUY4aDxDP4LxXqbE/v42mS1lroMd997ZrWREjy8m7S6Sjqw2z1nXzdX2rhAKi8JvN2MLKnzUKn9ye7f35R0z7HFB92/t5sWuNdhwvH3ECbiE6VWPd1/83lCV/c9kKfzKbG+BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAFSZMmKAZM2YYx6elpdlYzfESEhK8fv7dd99p69atatWqVa2fX3DBBbrxxhtVVVUlSbrkkks85jp48KCmTJlS62eRdtyeHD7OWBLK7ybQ7wVAZFmxYoVGjRqld999t8a4EBcXp3vvvVfXXnutx33vu+8+nX766Ud+Lisr06WXXqr8/PC+GOjzzz+3JM+SJUu0a9cuNWvW7Mi2nj17WpI7EHfeeaeSk2u+DPD555/Xnj17LGsjUr/TYBUXF+v888/XunXr1LBhwyPbL7vsMt1zzz3avn17GKsDcKw///nPuvnmmxUX9+sL/8444wy/80TbeJCenq4PPvhAKSm/vnj+0KFDGjt2rMrKyo5sS01N1bnnnltj3yeeeMJr7ieeeELXXHPNkZ8vvPBCJSYmqry83JriATgC/WbNz+k3Aes4ce1Bir5+0x+sQQSmuLhY+/fvZ+0BiBKxvP7AHBpAOFnRb7L2AAAAAAAAAAAAAACw0i+//KJevXrp+eef12WXXSaXy1Xj84SEBDVu3PjIz8f+jeXRPvroI91yyy3au3ev1zbLysp0zjnn6NFHH9Vdd92lpKSk42JSUlJqPLOuTWlpqR555BE9+eSTxv9thQ0bNmjAgAH6xz/+oSuvvPK4z+Pi4lSvXj2vOaqrq/XPf/5T9957r0pLS43a9Ve46jz83Tz44IO6//77a/1vKiQmJiorK8tjjvLycv3lL3/RY489poqKCqN2i4qKNHr0aD355JO6/fbba/xtm4mqqio988wzuu+++4zbBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKLN8f81EAAALFCQaxaXnGZtu+kNpb4XSt1GSemZ/u0bnyBltXb/63mmVFEm/ff30p4N1tZoqsNAqd+FUouTpLh4//Zt0Nz9r8swaeRN0qYF0s/vSTtX21KqR806SQMukdoNkBI9/zfnjuNySfWauP91OEUadp2Uu11aNl1a+oVUXmx9rW37SRf9yXtM9gzpm4m1f9aordTzbKnzUCnV+3/TTZK0dJpUWuh/nZKUkCT1Okfqd5FUt7Hv+MNS60vtB7j/jbhR2jBPmvvf8F3jsWr221K306S0+r5j6zWR2vSRNi20rv2EJKnHme5rKKt1YDnqNnb/63CKNOJ6ae9madkX7t/RygDfHXjGHe6+25d4wzuYM38nnXF7YLWs/E6a8Wxg+x4Wqec5HBKTpbZ9zWJLC939Yzis+UHqdba07idp1ffSQevePe+V1XOXtXOlBR9Y37cHM04mJku9zpVG3GDeXmq9X8eskTdK63+W5r4j7VnnX91Hc1o/c1gsXENSaOdaVoi2443E62jIBKn/GN9x1VXSy9dKhXmBt+XNNROlzBa+416/STqwK7A2IvH818aKsWDAWLN58GF2jAe1+c07ZusTr90o5e+2tu1z7pY6DfEdN/MVacln1rYtRc/1F07Reg8eiWORSU2StGe99N8/eI+JlHFCYqw4mpPHikjlipN6nuXuo0yuw8PqNnL/6zhQGnWztGWpu4/avsL/GgZf7V4D9uWjh6UtS/zPb6rLcOksH32HJO1eJ02+0746rMCzgeh5NhBJfVc0rntYOTcINP8z5x+/LZK+19pw/xL5cyJfovUeI1ZV+PEeMT/fjRU2Tn2G5YQ5lGVc0um/lU4abb7Lwb3Shw8ef9+a1kC68Q33PM2X+R9Ks9/yq1KPTMbx8lLphculKgveLZeYIv1mshTnY65UUiC9eKV7vSFQThnPYlEkrrcdK9r6+GDOaZOO0tBrzP8WwRX3a3/fdYT73C76RFowRSotMK+5YSv32mTHQWZ9oyTVqSt1ONn9b+TN0opv3fO4gznm7foSzLlMTpP6nC/1ucC/eyAr15cAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIhmb7zxhpYsOf6FjU2bNtV9993ndd/HH39cX375paqrq+0qz1bV1dV666239OCDD9b6eVZWloYOHapZs2ZJksaOHesx13vvvaeSkhI7ygQARJjKykpdc801GjJkiJo0aXJk+0UXXaTrrruu1nFx6NChevTRR2tsu+uuu7Rw4ULb6z1acfHxL9hdscK6F/esXLlSzZo1O/JzgwYNlJiYqPLy0L4oMDU1Vddff32NbaWlpXrmmWcsayNSvlO75OXl6cknn9Tf/va3I9vi4uJ0ySWX6Nlnnw1fYQCOk5OTo59++kmnnnrqkW2tW7dWvXr1lJ+fX+s+ThgPXn75ZXXs2LHGtuuvv14bNtR8QebJJ5+shIRfX/i5atUqbd261WvuNWvWaMuWLWrd2v1ixeTkZPXr108//fSTRdUDiDb0m/SbQKhF89qD5Ix+0xRrEMFh7QGIHrG8/nA05tAA7GRnv8naAwAAAAAAAAAAAADASrm5uRo/fryeeOIJ3XLLLbrkkkuUlZVltG9OTo4+//xzPffcc1q6dKlxm5WVlXrggQf06quv6uabb9Zll12mVq1aGe27d+9eTZo0SS+++KI2b95s3OZh+/bt01VXXaW///3vuv3223XBBRcoMzPT534FBQV699139eyzz1r6t1ORVmd5ebkefvhh/ec//9FNN92kq6++Wo0aNfK53969e/Xmm2/qpZdeOu7vC0zb/f3vf6/XXntN9957ry666CKlpqZ63aeoqEhTpkzRE088EZLvBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAinBN8hAAD4r+iAWZwrTopPlCqDfFdWUqo0+Gqp97lSvEWjW0KSNOEFac2P0rf/lgr2WZPXl85DpcFXSZktrckXnyB1GOj+t3KWNOtV+4+l6YnS8OulVj2sy5nZQhpxgzRovLToE+nnd6WKMuvyu1zu79ybuPjjtyWnSSNulHqcYV0t3nQbJQ37f1K67/+GnFdx8VLHQVKHU6Tsr6TvXpLKS6ypEd5VlErzP5RGXO87VpLaD5A2WfGOapfU93zplMuktAYW5DtKozbSabdKJ18qzXxFWv29/zniEnz/DvojmLEgf08QDUf4eQ6HFt3Nv49fvpbKj39nZ0iUl0r/+X3o2rNr7tJ1uPuf1fOXQMfJ1r2ls/4g1fX93yD13Hbc/8asgVL2l9J3/w7sOnFMP/M/sXINhXquZZVoOd5Ivo6WfysNvNwstvNQ9z2C1Rq3c//zZdty6cAu//NH8vmvTTjHAsm68aA28YlmY4TLZU17R4uLN2s7Ls7adqPt+guXaL4Hj8SxyKQmyeyajIRxQmKsOJaTx4pIdEJX6czfSw2DXEd2xUlt+rj/bV4sffWcf9frim/ca7a+dBslbVkSeJ2+dB5q1ses/sG+GoLFs4HaReqzgUjru6Jx3cPKuUEw+Y8Wad9rbbh/sSZnuO5fovkeI2b58btUXW1fGZZw6DMsJ8yhrBQXL51zt9RluPk+uduk9+6TDtVynIV50t5NUvPOvvO0GyDNfsu8XW/an+x7zElIklqcJG1dGnx7rXu7xxtftiyRqqsCa8NJ41msisT1tiOitI8P5JzGxUtDrpEGXBLcnDc5zX2f2fMs6Yu/+/67nLh4aciE/7UbxHw3PsF9LXQZJv0wybp1y0Cvz87DpNNukVLrB9n+MetLX/5Lyt8dXE4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKLFZ599pilTptT6Wb9+/TR69GiP+/bq1UtXX3213nzzTaO2ioqKAqrRTm+88YYefPBBj5+PGTNGs2bNUosWLXTyySd7jJs0aZLHzyLxuJ0kLogX0PHdAAhUYWGhXn75ZT300ENHttWrV0+9evXSkiU1X4SclZWld955R/Hxv76I5/vvv9eUKVPUvHlzS+qpX7/+cbmqq6u1a1fNlz3n5uYet+++fda9QGzv3r3Hbatbt672799vWRsmxo8fr/r169fYNnnyZO3ZY/jiWh8i6Tu105QpU/S3v/2txjZv8yEA4bNy5UqdeuqpNbY1adJE+fn5tcZH+3hw/fXX6/LLL6+x7d///rfef//942I7duxY4+eVK1catbFy5Uq1bt36yM8dOnTQTz/9FEC1AJyAftM3+k3AetG69iBFf7/pD9YggsPaAxBdYn39gTk0ALvZ2W+y9gAAAAAAAAAAAAAAsEN2drZuueUW3XrrrercubP69u2rFi1aqHv37ho/frwkad68eXr33Xe1fft2LV++XKtXrw6qzU2bNumee+7RPffcozZt2qhnz55q3769srKylJaWpsTERB06dEh5eXnavn275s+fr7Vr11pxuFq6dKmuu+46xcXFqVevXuratavatWununXrKi0tTUVFRcrNzVVOTo4WLFig7OxsVVVV+d3OeeedJ0l65JFH9PDDD0dsncdat26d7rrrLt11113q0KGD+vfvr5YtW6p+/fqqV6+eJCk/P18HDhzQtm3b9M477wTdpiQtX75cV155pVJSUnTKKafopJNOUsuWLZWWlibJ/XfZ27Zt0/Lly/Xzzz+rpKTEknYBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACASJcQ7gIAAM5UVWkeGxcn+RF+nNa9pXPultIzg0jiRachUtu+0oxnpdU/2NOGJGVkSaffLrUfYF8bXYdLbftInz4mbVlqff6EZGnw1VK/C6W4eJ/hAUlOkwaNl7oMd38n27LtacdEvabSuCek+k3tbys5XTrzDvf1aCVXnNTzTKllN2nKo1LuNmvzo3bZM6QhV0sJSb5j2/YLvr36zaSz75RanBR8Lm8ysqTz75M6DpSmPyNVlNnbnl3ydga2H+e5dq17m8eummVbGRHF7rmLFLr5izdDrpEGXmZdPpfrf2NWd2nKw1Ludutyh1qg/cxhsXINhXKuFQlCfbyRfh3lbZe2LzcbV7uOlBZ9ElCJPvOa+OVL/3NH+vm3itVjgeSs8SBcYuX6C0as3oNH09gbCePE4dwmGCs8Y6wITP9LpGHXWr8G26aPdM1E6ZuJ0vKvzfbJ2yltzZZa9fAed+Ig6aske9YxElPM1tCqKiNz7YFnA2Yi6dkAfZd3wa57hAvfa2RyypwoVu8xnKBOhnlsWZF9dQTLic+wnDCHslp8onThQ/6dk93rpQ8ekIrzPcesnSM17+w7V5P2UloDqTDPvH1P2vU3j9u6NPj2TM/Z2jmB5XfKeAb/hWK9zYl9vCdJqdIlj1p7rGkNpLF/kWa9Ks3/0HPMmD9LTU+0rt3EFGnULVKzztIXT/v3t5ZWiIuXzvid1H209bnb9JGunSh986L5+hIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE511113acmSJYqLi/MY8/jjj+uDDz5QUZHvFyHl5uZ6/fypp57S0qVL/S3To+3bfb+AbcOGDZo9e7YGDx5c6+cXXXSRbrvtNo0ZM0Yul6vWmLVr1+qnn37y2EYkHnek83bNHatRo0YBtxPK78YJ3wuAmr777js99NBDNba1bdtWS5YsqbHt8ccfV/PmzWtsGzZsmKX9wt1336277767xrbNmzerbdu2Nbbl5R3/srayMute6lRaWnrctvh4m14Y7MXVV1993LaJEydalj+SvlM7rV+/XhUVFUpISDiy7djjBhAZcnJyjttWr149j/HRPB50795dzz33XI1t2dnZuuOOO2qNb9CgQY2f9+/fb9TOvn37vOYBEFvoN32j3wTsEY1rD1J095v+Yg0iOKw9ANElltcfmEMDCAU7+03WHgAAAAAAAAAAAAAAdqqurtaqVau0atUqSVKfPn00fvx4SdKPP/6oZ5991pZ2N2/erM2bN9uS25uqqiotXrxYixcvtrWd9PR0SVJxcXFA+4eqztqsX79e69evD2mbJSUlmjVrlmbNmhXSdgEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBIleA7BAAA/7lc5rHVQbRzymXSkKslV1wQSQwkpUrn3y81bi/9MMn6/C1Oki5+WErJsD73serUlcb+Vfr2JWnJZ9blTc+SLnlUatzOupzeNGguXfY36cc3pZ/fDU2bR6vXRLriGSk90/620jLdx9qwpX1tZLaUxj8tvXevVHj8+/JgsdICaf3PUuehvmMbNJfqNZXydwfWVouTpDF/lpLTAts/EF2GS3WbSO/fL5UH9t9KDKu8Hf7vw3n2rE1vs7iCXGnXantriQShmrtI9s9fPHJJZ/1B6j7anvSZJ/xvzLpP2rvJnjbsFkg/c1hMXEMK7VwrEoT6eKPlOsr+0j3G+tKsk3vOlLczsBo96TLMd0xZkbTmB//yRsv5D4rNY4HkjPEgHGLi+gtSrN6DR+PYG+5xQmKsCApjRcCG/z9pwFj78ifVkc6+U2rYSvr+NbN9lk2XWvXwkTdV6nCKtNrP3wcT7QdICUm+4zYulIrzrW8/GDwb8F9Ynw3QdxkJZt0jLPheI5ZT5kSxeo/hFHUbm8cWH7SvjmA48RmWE+ZQVkus4/6efc3Lj7Y1W5ryiPu+1Zt1c9z3Ib64XFKbPtKKb81rqE1mC6l+U7PY9v2lWa8E154ktevnO6a8VNq0yP/cThnP4L9QrLc5sY/3JClVuuxJqWkHe/IPv979v/M/rLm9bmNp3BPue1E7dB3hXtP45K9SdZU9bRwrPlG65P+k1r3sayMp1b2+lNmC/ggAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAENuys7P19ttva8KECR5jmjVrpnvuuUcPP/ywz3y5ubleP1+5cqUmT57sd53Bev311zV48OBaPzvhhBM0YMAAXXrppR73nzTJ+wsOIvW4w6m6utrr52lp5i81adrU8KVBteC7ARCMHTuOfwlqVlbWcdvq168fgmqOt3HjxuO27dx5/MvS69Wrp5ycHEvarO1YDx06ZEluU82aNTtuXF+zZo0WLlxoWRuR9J3aLTc3V40b//pyzLp164a8BgC+VVZW+hUfreNBWlqaPvjgA6WkpBzZVlBQoLFjx6q0tLTWfdLT02v8XFxs9iLDoqKaL0w9Ng+A2EK/6Rv9JmCPaFx7kKK33/QXaxDWYO0BiB6xuv7AHBpAqNjZb7L2AAAAAAAAAAAAAABA9Dn11FMl1f43xQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgS1y4CwAAOFNymllcVaVUUfu7rHwacaM09BrJFcLR7JRx0sibrM3Zeah06WNSSoa1eb2Ji5dG/0bqcYY1+Rq1la56Vmrczpp8plwu9zVw5u9Dex0kJksXPyKlZ9rfVkaWdMXfpYYt7W8rtZ77Wsw4/t3YsMGG+eaxLbsH1kabvtLYv5r3yVY6oYt08cOh/d20St7x74z0ivPsWVy8lNXaLHbbL/bWEgnCMXeR7Jm/eDP8eqn7aHvbSK0vjf2LlB6lY5a//cxhsXINhXKuFQlCfbzRdB2t+UEqK/IdJ0ldhvtdklctu0sZjXzHrfpBKvfjnjaazn8wQjEWSNE/HoRarFx/wYjVe/BoHXvDOU5IjBXBYqwITL+LpAFjQ9PWyWOl0241i107Wyo55Duu68jgavLkxMFmcSu+saf9QPFsIHDhejZA32Um0HWPcOF7jUxOmRPF6j2Gk7Q/2SyuKF8qzLO3lkA48RmWE+ZQVktJly57QmrVw3yf9T9LHzxgdl+dt1Pat8Usb7v+5jVYkaNhK6luk+Day2pjdn+/eZH/f9/klPEM/gvFepsT+3iPXNJ590pNO9jbzLDrpNa9fv05KdU9h2/Q3N52TzxVGnqtvW0c8b9zefRx2umUcdLIm0PTFgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkeqBBx5QcXGx15i77rpLJ5xwgs9cW7Z4f5lM7969/arNKh988IGKijy/EOd3v/udBg4cWOtnVVVVevvtt73mj9TjDqdDh7y/SLR169bGuYYOHRpwHXw3AIJR2/iYnJwchkpqt2nTpuO2zZs377htzZtb96KjZs2a1fi5pKTE5zzCaqeffrpcLleNbR9//HFIa7BLbd+p3RISEmr8XF5eHvIaAPjWsGHD47bt37/fY3y0jgcvvfSSOnXqVGPbTTfdpLVr1xrnqK6utjQOQGyg37QuDoB/onHtQYreftNfrEFYg7UHIHrE6voDc2gAoWJnv8naAwAAAAAAAAAAAAAA0cPlcunZZ5/VKaecIkmaPn16mCsCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEI0SfIcAAOC/tEyzuJJDgeUfNF7qf3Fg+war30XSwRxp4dTgc7XtJ517jxQXH3yuQJxxh1SQK21cEHiOek2lcY9LqfUtK8tvPc6Qqiqlr/4VmvZG3Cg1amt/O/GJ0kWPSPWb+Qy1TFoD6bx7QtdeLNuyxDy2YSv/82e2lC58SEoM47vOW/eSBl8t/fhG+GrwV+EBqazIPJ7z7F29ZuZj3I6V9tYSbuGcu0jWzl+86TJCGjDG3jYOS28onXev9M7dkqLoXab+9jOHxco1JIVurhUpQnm80XYdlZdKq76Xep7lO7brSGnu5ODqOzafiewZ5jmj7fwHKpRjgRS940Goxcr1F4xYvgeP1rE3nOPE4ZwmGCuOx1gRmPrNpeHXh7bNPudLeTukRZ94j6ssl1Z8J/W9wHtc235SSkbgzwVqk5AstRvgO660UFr/s3XtBotnA9YI5bMB+i4zga57hAvfa2Ryypwolu8xnKJBC6lNH7PYnRH4jMOJz7CcMIeyWloDadwTUlZr831WfCt98Xepusp8n7VzzNpo01eSS0GNcybz+xrx/aSl04Jor79Z3JrZ/uV1yniGwNi93ubEPt6bAZdI7f3sGwLhinOPM6/8P/d9zbl/DOzvdQJx8lj3+LIt2/52TjzV3jaO1e9CKW+7tOTz0LYLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECk2LFjh/7xj3/o/vvv9xiTmpqqxx57TBMmTPCaa/Zs7y9SOfvss3XHHXcEVGcwCgoK9NFHH+mqq66q9fPLL7/c477ffPONduzY4TV/pB53OOXm5nr9vHfv3kpJSVFJSYnXuOHDh6tFixYB18F3AzjfkCFD9Nhjj+n111/XpEmTLM2dlZV13LZ9+/Ydt2337t1av369pW136NChxs+5ubnH9a1Lliw5br+lS5eqsLBQaWlpR7YNGzZMS5cuDbqmjIwM9e7du8a2X375Jei8/hoyZMhx23z19/6KpO/UTklJScrMzKyxbc+ePSGtAYCZY/sQyfvvazSOB9dee62uvPLKGttef/11TZ482a88cXFxlsYBiA30m9bFAU7E2sPxorHfDARrEMFj7QGILrG6/sAcGkCo2NVvsvYAAAAAAAAAAAAAAED0aNCggd555x2dccYZkqTNmzfrz3/+c5irAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABCNEsJdAADAmbJam8WVHPI/94mDpcFX+7+flUbcIO1ZL20L4l1fWW2kC+6X4uItK8tvrjjprDul12+Uig/6v39KujT2L1JqfctL81uvs6UDu6T5H9jbTrPOUs+z7W3jsNNvk5oe/45Q22W2DH2bsahgv1SQK6Vn+o7NbOFf7sRk6cIHpaSUwGqz0imXSqtmSfs2h7sSM3k7zGM5z75lnmAeG2m1WykS5i6SNfMXb9IaSKfdak9uT1qeJPU6R1r6eWjbDYY//cxhsXINSaGda0WCUB5vtF5H2TOknmf5jstsITXp4M4drLgEqdNg33H7t0q7VpvljNbz769wjAVSdI4HoRQr11+wYvUePNrH3nCMExJjRTAYKwKXkh6edkfc6L4mtq/wHpc9Q+p7gfeY+ASp0xBp2RfW1de2r9nazOofpcpy69oNBs8GrBWKZwP0XeYCWfcIJ77XyOOkOVGs3mM4RXyidM5d7vmLiVWzbC3Hb058huWEOZTV6jaRxj0uNWhuvs+ij6VvX/K/rbVzpEHjfcfVyZCadTK/Fz5WYop7rPRHuwHS0mmBtSdJ7fr7jqmqlDbMN8/ppPEM/rN7vc2Jfbw39ZtJ3U6zL/+x0hpIp4yT9m6WOpwSunYl6fTfSq/dJKnanvwNW0knjbYnty8jb3b3RzsDHB8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIh2jz/+uG644QY1atTIY8xVV12lf/7zn1q8eLHHmHnz5qmsrExJSUm1ft6hQwddfPHFmjJlinFt5513nlq1aqUXXnjBeJ/aTJo0SVdddVVA+/kSyccdLrt27fL6eVpami6//HKv5zcpKUnPP/98UHVY/d1E+/cCOEm/fv302GOPafRo94tvmjVrpsmTJ6u0tNSyNnr16nXcttr6t9tuu82yNg+rrq75sqC///3veuyxx3zuV1VVpR9++EFnnfXry9XHjx+vf/7zn0HXdNFFFykxMbHGth9//DHovP6q7XuZN2+epW1E0ndqp8GDBx+3zdcYDsBc3bp1dfBg8C8YTU1N1bBhw2ps2717twoLCz3uE23jQbdu3Y6bY69YsUK//e1vfe576NChGj/XqVPHqM3U1FSveQDEFvpN3+g3EYtYe/As2vrNQLEGETzWHgD7sf5gztM82hfm0ACsYle/ydoDAAAAAAAAAAAAACDUdu7cqYcffliSNHfu3DBXE126deum0047TZL0yy+/6Oyzz9b+/fvDXBUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAaJQQ7gIAAM6T2UJq1MYsNmeTf7nTGkhn3OF3SdqyVNo4X9q2XCrYLxUflCrLpeQ0qU5dqWErqXUv6cRTpbqNfedzxUln3SlNulkqL/G/nrgE6YIHpKRU37HHqq6W9qyX9m6Wig5IxfmSXO5jqd9MOqGL2TEcllZfOu030meP+1/Lmb93f9/+qq6Sdq2R9m2RivKl4kNSQqL7+01vKLXsIdXJ8D/vsGul7culnav839fU0Gskl8u+/Ie16SN1Pz2wfasq3edg/3b3NVJSIMXHSyl1pazW7mskOc3SchGgfZul9EzfcQ39/D0bMNb9XZsqL3X3kZsWSTkbpfw9UlmRu5+Mi5dSMqSMhlKLk6SOp0qtepjndsVJw66TPvqTf8cQLnk7zWM5z75lnmAeu3+bfXWEU6TMXaTg5y++dBzkO2bfFmnXWungHqmsWEpIklLrS/WauK/5QOZGp14hLf9aqij1f99w8KefkWLrGpJCN9eKFKE63mi+jg7fN5iMuV1Huu+VgtW2n3tc9iV7hlm+aD7//jIZCyTGg1CKpesvGLF8Dx7tY284xgmJsSIYjBX2yt0h7V4jHdjtXnNwxbnPW1qmuz+q18T/nHHx7mvi9Zvc15cneze5fyebdfKer+tIadkX/tfhSaehZnErvrauzWDwbCA6nw3Qd5nzd90j3EyuN77X0HHSnCiW7zGcICVDuvhhqXlns/iDe6W1Efb+Nac9w3LKHMpKmS2lcY9LGVnm+8x+S5o7ObD2cja4rwuTe4p2/aRdqwNrp3UvKT7Rz316uvfxdr/iSVKq1KKb77ity6TSArOcThrPEBi719uc1sf70qaP75iC/dLWbClvh3vOnpjs/l1s2Nr9Ox4X71+bfS+Uyot9x5WVSNuy3WsiJYfc5yOtgbuvbN3L/3GrYSup8xBp9Q/+7WeqZXezuP3b3PfuB3Ok0iIpzoL1pfgE6ew7pddvds93AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACINQUFBXrkkUf0wgsveIxxuVx69tlnNXSo5xc1lpaW6ssvv9R5553nMebFF1/U0qVLtXHjRp91DR48WJMnT1Z6errGjh2ra6+9Vps2bfK5X21mzpypLVu2qHVr85dr5Ofna+rUqT7jIvm4w2XevHk+Y/72t7/pxx9/1Pr1x7/UNz09Xe+++666dTN4iY8XVn43TvheACe57rrrNHr06CM/t2/fXo899pjuvPNOy9q49tpra/xcXl6uJUuWWJbfLi+88ILOOuusIz8PGDBAF1xwgT755JOAcyYlJenPf/7zcdvfeeedgHMGqkOHDjV+3rFjh/bu3RvyOsKhXbt2uu222/TQQw+poMDwBXZe3Hzzzcdt+/7774POC0Sy/fv3a/v27Ud+zsvLszS/y+XSmDFj9MADD2jXrl06++yzg875+9//XikpKTW2TZs2zed+0TIepKam6oMPPlCdOnWObCsqKtLYsWNVXOz7xX25ubk1fm7SxOyFdsfGWX0tALCe3X04/aZ39JuIRaw9eBct/WYwYnUNwsr1B9YeEKtYf4i88cDbPNoX5tBAbIm29QfWHgAAAAAAAAAAAAAA4bB79249+uij4S4jKs2ePVv333+/unfvrptvvlmFhYXhLgkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAlEoIdwEAAOfpe6F57M5V/uUedYtUJ8M8ftNC6YdJ0p4NtX9eWuj+d2CXtGGeNOtV6aTTpKHXSqn1veeu31QacIk05z/m9Rx2yjipYUv/9inYL/30jrRmtlR0wHtsi5OkwVdLrXqY5e4yTPr5XWnvJvN6Og2RTjzVPF6SDu2V5r4jrZ0tFR/0HOeKk5p3lvpdLHUabJ7fFSed9QfpjVulynL/ajPRtJPUtIPvuMMqyqTCPKm8RKqurvlZZYXn/eLipVHHv8/Xp7yd0tzJ0vqf3Ne1x/wJUvsB0sljpeZd/G8H1jmwyyyufnPznHXqSf3HmMVWVUoLpkjzP/D8O1lV6e5zig64+9JFn0gtu0tn3enuB0206y81aCHlbfcckz1d2rrMd64BY6RGbX3HLZshbV9uVt/R9hn2g9F6nkOtbmOzuKpKd3/pRJE0d5GCm78Eo7zEPT7n7fQcExcvte0rDb1OatTGPHdaA6nbKGnZF97joq2fOSyWrqFQzbUiRSiPN9qvo+wZ0sibfMd1GS7NfEVSta9I77qN9B1TVSmt+NYsX7Sff6uUl0jLpktLPgvveBBruP58i+V7cKeMvaEeJyTGCrswVgSmvETK/lJa8rmUu817bGZLqedZUu9zpYQk8zYaNJf6XSTNe9973LLpUrNO3mNadHOvFxzMMW/fk/hEqcMA33H5e6TtK4Jvzwo8G4jOZwPeRErfFa3rHpEqUr7XWOOUOVEs32NEu8RkqefZ0sDLpTp1zff78Y3Qjz/eOPEZlhPmUFZq0kEa+1cptZ5ZfHW19M1E97gWjLVzpP4X+45r1z/w+8l2BvP7YyWmuK/JzYv937dNH3e/7cvaOeY5nTKeITB2r7c5sY8Pxq410uy3pU2L5HHNLyXdfY958lj3OoKJxGT3P08K9ktz/iut/FYqL609Ji7BfV874kYpPdOsXcn9d5erfzCPt0pZsbT0C2nZNO/3QFLg60uZLaU+50sLpwZXKwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0erf//637rjjDp144okeY4YMGaKLLrpIU6d6/g/8P/nkkzrvvPM8ft64cWPNmzdP9913n/7zn/+opKTkuJiePXvq+uuv16233qq4uDhJ0rBhw/TLL7/o3nvv1fPPP+/Hkf3qzTff1J/+9Cfj+HfffVelpR5eAHGMSD7ucNiyZYt27typ5s2be4xp1KiRFi9erOeee07ffvut9u7dq4YNG2rQoEG69dZbdcIJJ1hSixXfzXPPPeeI7wVwkscff1zXX3+9EhN/ffnPH/7wB61Zs0Yvv/xy0Pmvv/56DR06tMa27777Tvn5+UHnttu0adO0du3aGmP6q6++quzsbG3aFNhL7l5//XW1adOmxrYff/xRCxcuDKZUv6WmpqpevZovytuzZ09IawiHrl276v7779dll12m+Ph4paWl6cYbbwwq50UXXaSxY8fW2FZRUaFp06YFlReIdNdff71tuQcPHqxXX31VnTp1kiT16tVL11xzjd54442Ac/br10/333//cdunTJnic99oGQ8mTpyoLl1qvgj51ltv1apVq4z2Pzaue/fuRvsdG7dy5Uqj/QCEj519uES/6Qv9JmIRaw/eRUu/GahYXIOwY/2BtQfEKtYfIm88CGYezRwaiC3Rtv4QaX2mRL8JAAAAAAAAAAAAAIAvTz75ZLhLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOAACeEuAADgLK16Sr3OMY/f4cd7ppp0kDoNMYutrpZmvyX99I55fkmqqpSyv5Q2LZYufkRq0t57fP+LpcWfSsUHzduo20Q6ZZx5fHW1NHeyNO89qaLMbJ/ty6V3/yj1OV8aeZMUF+97n1Mukz573Cx/Yop02m/MYqVfj+Hnd6XKcoP4Kve1sWOl1PRE6dw/SpktzNpq2FIacIn/372Jph18x2xbLq2eJW1eKuXtkFTtfzsnjZYatjKPr6yQvn9NWvSJ+9z5UlUhrZvr/tftNOm0W6TkNP/rRPAK9pvFxcVLCUlmfUBCorRpoXTiYMnl8hxXUiB99Cf/+uHDtv0i/ecOadwTUqO2vuNdLqnH6dL3r3uOOfw770uX4WZtbl8urfjGd1ygovU8h1piHbO4onwF1F9Gukicu0iBzV+CsTVbmv53KX+P97iqSmnDfGnjQmn49e46TfU8U1r2hfeYaOtnpNi7hkI114oUoTpeJ1xHK76Vhl0nxSd6j0vPlFr1kLYuM6m6dol1pPYn+47bMO9/45cPTjj/VjAdCyT7x4NYwvVnJpbvwZ0y9oZynJAYK+zCWBGYzUukGf+QDuaYxeduk2a+LC2YIp1xu9R+gHlbA8dLS7+QSgs8x6ya5V6PTvKyHuByue+75r1v3rYnbfpKSam+41Z8G3xbVuDZgEF8hD4b8CSS+q5oXPeIVJH0vcYSJ82JYvkeI2q43GNaSprUoIWU1Vpq3dM9t0hM9i/VqlmRM9c4zGnPsJwwh7JSi27SmEfNf++rKqVpT0urZgbf9to5ZmNd045SnbqB3U+27+//PpLUrr+0eXEA7RncE1VXu/tcE04azxAYu9fbnNbHB6qqUvp+krTgQ9+xJQXu37V1P0mXPRH8vGn1D9KMZ6WyIh81VrjnCRsXuM9l045m+U/oKtVvJh3YFVyd/ti40H1MBfvM4oNZXzr1Sncf5uv8AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgRJWVlfrjH/+ojz/+2GvcU089pc8//1zl5bW/BHD27NmaM2eOTj31VI85srKy9Morr+j555/X8uXLtW/fPlVXV6tRo0Zq0aKFmjRpUut+aWlpeu655zR27Fhde+212rhxo/HxSdIbb7yhhx56SC5vL9c4yqRJk4xzR/Jxh8vbb7+te+65x2tMRkaG7r//ft1///221WHXdxOt3wvgFNu2bdP//d//6dFHH62x/d///rfatGmjhx56SJWVlQHlvuWWW/Tcc88dt/3pp58OKF843HvvvZoyZcqRn7OysvTtt9/qggsu0C+//GKcJykpSS+++KKuuOKKGturqqp09913e923bdu2+u67747bfsMNN+ibbwJ7MW1GRsZx2/Ly8gLKFS1cLpc+++wztWvX7si2G264Qfn5+frjH/+o6mo/Xjb2P5deeqnefvvt47a/8cYbOnDgQDDlAjFtz5496tCh5ksDX3nlFUnu3y9/DR06VFOmTFFqamqN7XPnztUXX5i9fDoSxgNvJkyYoAkTJtTY9tZbb+nNN980zrFgwQKVlJQoJSVFknv86dq1q1au9PzCxH79+qlp06ZHfi4oKNDSpUv9Kx6AI9Fv1o5+E7GKtQffIqHftGP9QYq9NQi71h+OxdoDEDzWH/wX7DyaOTQAq1nRb0ZqnynRbwIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAChEBfuAgAAztGmr3TRnySXyyw+d5u0a415/kHjzXPPfFn66R3z3Mc6tFd67x7fcUmpUvcz/Mvd7yIpIckstrxE+vj/pDlvSxVl/rUjSYs/lT57Qqqu8h63NVtaefy7fT3qeZaUVt8s9uhjqCw3b+Ow3Wult++QNi8x36ffRVJCsv9tBWPbcunN30rv3CUt+VzK2y7J/3f5SpL6nG8eW3xIev9+aeFU399zbVZ8I71zt1To3HcuR7Sig+axiXXM4g7tkz75q/t6XD+v9piKMvd1s8PzuwF9KsqXPn3cvG9qf3LgbUUizrOZxBSzuNJCe+sIl3DMXQ7m+I4NZP4SqJXfSe/fJ+XvMd+nusp9PhZONd+n6YlSepb/9UU6rqFfWTnXigZWHq8TrqPig9L6n81iu44wi/Ok40Ap0eBeInuGWT4nnP9gBTIWSIwHVuD6M8M9eO2iaewN5TghMVbYgbEiMNkzpA8eMPs+j1WwT/roYWneB+b7JKVI3Ud7jykvkVZ/7ztXt1Hm7XrTeYhZ3IpvrWkvWDwb8E+kPxug73ImvtfwcdKciHuM0GjbR/rDp4H9++N06fdTpVv+I132hHTaLVLHQWbz/KNtWSpN/4cthxcUpz3DcsIcyipt+0pjH5OS08ziy0ulqX+WVs20pv0dK836G1ec1KaP//mzWksZjfzfT5La9Q9sv7b9fMfsXG3ezzppPIP1rFhvc1ofH4jqKunzJ6UFH/q335510tRHpeog1jiXTZc+fUwqKzLfp7RQ+uBB93dnyqRvssrSadKHD7nXivwVyPpScpp00mn+twUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgFN88skn+vHHH73GtG/fXr/97W+9xkyYMEH5+fk+20tOTlbfvn11xhln6Mwzz1Tfvn3VpEkTn/sNHTpU1157rc+4Y23atMnn8R22Zs0azZvn4SUcHkTqcYfL888/r4qKinCXIcne7ybavhfASR577DHNnTv3uO333XefVqxYocsvv1zJyWYvAnS5XDr77LP1/fffa+LEiYqPj6/x+fvvv69vvvnGkrpDYerUqXr55ZdrbGvbtq1+/vlnPfTQQ6pbt67PHOeee64WLFig66677rjPHn/8cZ/jZGJiotq0aXPcv9TUVP8O5ii1fZ8HDhwIOF80qK6u1v3333/c9rvuukuLFi3SBRdcoISEBKNc/fr100cffaT33ntPSUk1X8SYm5ure++915KagVi1bt06/etf/6qxLSEhQZMmTdLnn3+uU0891ShPhw4d9OKLL2rmzJlq2LBhjc/Ky8t1xx13GNcUCeOBJ126dNHEiRNrbFu9erVuueUWv/KUlZXpvffeq7Ht0Ucf9brPI488UuPn//73v6qqCuAFzgAch36zdvSbiGWsPXgXCf2mHesPUuytQdi1/nA01h4Aa7D+4B8r5tHMoQFYLdh+M5L7TIl+EwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgFs7fLAQDgRUqGdMo4qd9FUly87/jDln5hHpuWKbU/2Sx21Sxp4VTz3J6UFEjV1ZLL5T2u51nS/A/McianST3OMK/h0yekDT+bx9dmzY/SD82kYce8s6yyQlr9vbRwirRng3m+uASp/xjz+M+ekNYHeQylhdJHf5KueEZq2tF3fJ267vO8+NPg2jVRXS19/7r5NeBL8y5S43ZmsVWV0tQ/S9uXB9dmzkbpo4el8U9LCUnB5YJ/KkrNY5PqSMX55vE5G6QpD0vNO0tDJkite//62bcvSbvXmufyZP9WacnnUv+LfcdmtZbq1PPvGKIB59m7pDpmcZXl9tYRDuGau3z6mHTFP6ydvwRq82Jp2tNSdYDvFZ31mtS2n9SwpVl8m97S8q8DaysScQ25WT3XinRWH6+TrqPsGVKnIb7jOg2Rvn4h8LGl20jfMQW50saFvuOcdP4DFexYIDEeBIrrzwz34MeL1rE3VOOExFhhNcaKwKz/SZrxT0nVQSSplr5/zX3v3vtcs136nC8t/Nh7u8umSz3O9J4nq7XUqK20d5NpsceLS5A6nOI7budqKW9H4O1YhWcDgYnUZwP0Xc7E9xo+TpoTcY8ROq648B7vqu+l6X+XKsrCV4MvTniG5YQ5lFU6DZHOvUeKN/xrz9JCd98QbB9TQ7W07iep19m+Q9v1d/fZ/mjXP6CqJEmZLaT6zaQDu8z3adxeSs/0Hbd2tlk+J41nsJYd621O6OMDNfttd38ciK3L3Pt2Ge7/vtt+kb56LrB2i/OlH96QzrnLLL51L2nJZ4G15Y91PwV+TEcEsr50Xmj+pg8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgEh11113ad68eV5j/vSnP+nNN99Ubm5urZ9v2LBBEyZM0NSpU+Xy9fKSAHzzzTd65JFHAtr39ddf19ChQ43i/BXJxx0O27dv18MPP6y//vWvQedatGiR+vbtG/D+dn430fa9AE5SWVmpc845R7NmzVLPnj1rfNapUydNnjxZ+fn5+vHHHzV//nxt3bpVycnJR2IuuOACjRgxQl27dtWQIUPUoEGDWtuZO3eurrvuulo/i2R33HGH+vbtW6P/TE1N1aOPPqp77rlHP/zwg2bPnq1du3YpLy9PderUUVZWlnr06KHTTjtNbdq0qTXvu+++q4ceeihER+FbeXkQL4WPEu+9955GjRqlG264ocb23r176+OPP9bBgwf1008/afXq1dq2bZsKCgpUUlKi1NRUNWjQQF26dNHJJ5+sjh1rfwlzcXGxLr74Yu3fvz8UhwM42h//+Ef16dNHw4YNq7H9nHPO0TnnnKOdO3fqxx9/1Nq1a7Vnzx4VFRUpISFBDRo0UJs2bTRw4ED17Nmz1jlrdXW1JkyYoIULF/pVUySOB3Xq1NEHH3yg1NTUI9uKi4s1duxYFRUV+Z3vb3/7m8aPH6/ExERJ0pgxY/Tss8/qnnvuUWlpaY12n3nmGZ1zzjlHtpWVlenpp58O6DgAOBP9Jv0mcDTWHnyLxH7TLk5fg7Bz/YG1B8BarD+YsXIezRwagNX87TdbtmwZNX2mRL8JAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2C0h3AUAAKKTK05q2UPqdKrUbZSUlOp7n6MVHpB++co8vutIKS7ed1x5ifTtS/7V4s3GBVL7Ad5jGjSXGrWV9m7yna/zMCmpjlnbC6ZIG342i/Vl3gdSh4HSCV2k4kPSsi+kRZ9Ihbn+5+pwspSRZRY7/0NpvUXHUFkuffwX6ZrnpZQM3/G9zpEWf2pN295Mf0Za/rV1+boM8x1z2I9vStuXW9Pu7rXSrNek026xJh/MVPrxrmvTvuNYO1dL793n7rOHXiPFJ7j7AKssnSb1v9gstmkHadMi69qOJJzn2iWmmMX587sQLcI1d9m52vr5SyCKD0mf/02qrgo8R1WFe2wa84hZfLMTrR2Twy3Wr6HDrJ5rRTqrj9dJ19GmxdLBvVLdRt7jktOkdv2ldXPN6z1a696+Y5Z/bda/Oen8B8KKsUBiPAhUrF9/prgHP160jr2hGidS6zFWWImxIjAFudLnT0mqtibfty+5z0nTE33H1m8mNesk7VrtOWbXGvc106it91xdR0rfv+ZfrUdr09v9O+3Lim8Cb8NKPBsIXKQ9G6Dvcia+1/By0pyIewznKzkkff+6tGx6uCsxF83PsJwwh7JC99OlM3/n/jsdE0UHpPcfkHI2WF/LujlSr7N9x7Xt63/udl764+pqyeXy0WY/aclnfrTX3yzOdA3BSeMZrGXnels09/GB2LNB+und4HLMnSx1Ge7fPhVl0hd/D+5+YcW30uCrpHpNfMc2bh94O6YKcqVpT1mXz5/1pcyWUpMO0p711rUPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEA0mT9/vt5//31deumlHmPq16+vRx55RLfffrvHmE8++URjxozR22+/rbQ0gxc8Gvr00081btw4VVZWBrT/hx9+qBdeeMFrTVVVVfrPf/4TUP5IPe5wefzxxzV06FCdccYZAed45ZVXtGzZMvXtG8DLh45ix3cTrd8L4CQHDhzQ8OHD9dZbb+m888477vN69erp3HPP1bnnnnvcZ7feeqvP/NOmTdPll1+uwsJCS+oNpZKSEo0aNUqfffaZhgwZUuOztLQ0nXXWWTrrrLP8yvnCCy/ojjvuUHW1RS+whrFbbnG/FPSGG2447rO6devqjDPOCGi8PXDggMaOHavvv/8+6BoBSBUVFTrzzDP17rvv6oILLjju8+bNm2vcuHF+5y0uLtatt96qd955x+99I3E8eOGFF9StW7ca22677TYtXx7YC5VXrVql++67T08//fSRbXfccYcmTJiguXPnav/+/WrYsKEGDx6sunXr1tj37rvv1vr1vLwOwK/oN+k3gWOx9uBdJPabCJwd6w+sPQDWY/3BfH+r5tHMoQFYzep+M5L6TIl+EwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALBbQrgLAACEVt1GUnf/3imq+EQpqY6UnCplZElZraXMVlJSSuB1zHxZKvXjPbwdTjaLWzJNKjoQUEm1WjhFaj/Ad1y7/tLeTb7jTHJJUlG+9MMks1gj1dI3E6VmJ0rLv5EqSgNP1WGgWVzRAenHNwNvpzYH90g/vy8N/3++Y7NaS/WbSQd2WVvD0X5+T1r+tbU52/Qxizu0V5r/obVtL/lM6nGG1LidtXnhWXWVeWxcfHBtbcuW/vsHKTk9uDzHytvh/j2r38x3bGYLadMia9uPNJznmuLizOL8+V2IFuGau0jWz18CMftN93wmWBvnSwW5Unqm79hGDhu/Yv0akuyZa0UyO47XUddRtfv8DBrvO7TrSGndXIOctTCZc/3ylVkuR53/AFg1FkixPR4EKtavP1Pcg9cU1WNviMaJzsMYK6zEWBGY71+Tyoqsy1dVIX33sjT+abP4Nr2lXau9xyybIZ12i/eYrsPdxxKoTkN8x1RWSKu+D7wNK/FsIDiR9GyAvsuZ+F7Dy0lzIu4xnK34kPTevVLOhnBXEphofIblhDlUsPpeKI28SXK5zOIP5kjv3ef+XuywZZn7b32S07zHpdaXmnSU9qwzy5uUKrXo5vnzXaullHQps6XnmPYD3H2hqXb9fcfkbDSfVzppPIN1QrXeFo19fCC+f11SdXA59m+V9m1x3zuaWjpNyt8dXLuqltbMlgaM8R1ar4mUmCyV2zj+hH19qY+0Z7117QMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACIXL1691JyUnK4y0CM2LRpk3JycsJdBgAAAAAAAAAAgJF7771XF154oZKSkjzG3HLLLXrhhRe0Zs0ajzFTp07VwIED9fbbb6tnz55B1ZSbm6uHHnpIEydODCpPYWGhPvzwQ02YMMFjzFdffaWdO3cG3EYkHne4VFdX67zzztMbb7yh8eMNXu57jGeeeUZ33XWXbrnFx4tIDVn13UT79wI4zYEDB3T++efr+uuv15///Gc1b9486Jx79uzRPffcozfftPhFuCGWn5+vESNG6E9/+pPuvfder2O7Nzt37tRtt92mKVOmWFwhTFVWVurGG2/UrFmz9PTTT6tZM4MXePkwbdo03XjjjUHNewAcr6SkRBdeeKEmTJigp556So0aNQoq36JFi3TVVVdp1apVAeeIpPHgyiuv1LXXXltj2+TJk/Xaa68FnFOS/v73vysrK0v33nvvkW3169fX2Wef7XGfv/71r/rXv/4VVLsAnIl+s3b0m4hlrD14F0n9JoJj9foDaw+AfVh/8M6OeTRzaABWs6LfjNQ+U6LfBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOyUEO4CAAChldVaOuv34a1h4wJp5Xfm8Yl1pBO6msUu+yKwmjzZtlyqKJMSfLwf7IRuvnPFJ0qte5m1u3SaVFluFmtqzzr3v2C44qT2A8xil9hwDJK0bLo06AopKcV3bPuTpUUfW1+DJO3bIs1+29qcaZlSw1ZmsYs/k6qrrG2/ukqa97503r2+YxG9Sgusz7lrrVTf4B3WGcG9NzeqcJ5jWzjnLpK185dAFOVLv3xlTa7qKmndXKn3ub5j6za2ps1IEOvXkGTPXCuS2XG8TryOsr+UBl4uuVze49oPkJJSpbIi89ymti2X8nb4jnPi+feHlWOBFLvjQaBi/fozxT14TU4Ye0MxTnQd4TuGscIMY0VgDu2TVs60Pu/25dKeDVKT9r5j2/aVfnrHe8zKb6XTbvEek9FIatld2vaLeZ2HueKkDgN9x21cIJUc8j+/1Xg2YI1IeDZA3+VMfK/h5aQ5EfcYzlcnQ7r6X9LaOdLc/7rvo6JRtDzDcsIcKlinXun+Z2r/Num9+6SCffbVVFUhbZhvdn/crp/5OWzTR4qL9/z5+nlSnbpSZkvPMS17uPvzijLf7aWkS807+45bN9d3jOSs8QzWCcd6W7T08YHI3SFtXmRNro3z3X9DaaK6Wlr8qXXtDhjjO87lktKzzNYYAxEJ60tt+rjnrgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACc7+yzz1aDBg3CXQZixJSPpignJyfcZQAAAAAAAAAAABjZtGmTJk6cqN/97nceYxISEvTUU0/p/PPP95rrl19+Ua9evXT++efr/vvv14ABA+Ty9YLXo2zYsEGvvvqqXnzxReXn5xvv582kSZM0YcIEr58HKxKPO1zKy8t1xRVXaMqUKXr88cfVsWNHn/ssXLhQf/zjHzVzpvUvsgjmu3HS9wI40auvvqq3335bV1xxha644goNHz5ccXFxxvuXlJTop59+0muvvab3339f5eU2vAQ3DCorK/Xwww/rtdde0x/+8AeNHz9ejRqZvdhp1apVmjhxol5//XUVFQXw4nVYbvLkyZo6darGjRun6667TgMHDlRCQoLx/sXFxXr//fc1ceJEzZ8/38ZKAbz55pt67733dOWVV+q6667TySefbDwuVVRU6Ouvv9Y//vEPff3115bUEwnjQadOnfTSSy/V2LZ27VrdeOONAec82n333aeFCxfqqaeeUtu2bT3Gbdy4UXfddZemTp1qSbsAnIl+81f0m8CvWHvwLBL6TVjHqvWHa665xr4iAUhi/aE2ds6jmUMDsFqg/WY09JkS/SYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgF/O3ywEAYIGcjdKnj/u3T5N2Uly877jcbVLejsDq8qSqQtq9Vmpxkve4ph1952raUUpMMWt36TSzuFBr1FaqU9csdunn9tRQWiCt/l7qcYbv2NY9pUUf21PHD5Pc14eVmp1oFlddLWV/aW3bh635UTrtN1KdDHvyw5nyd5vF1alnbx1Ox3mOHuGcu0jWzl8CseZHqaLMuny715rFpWda12a4xfo1JNkz14pkdhyvE6+jg3ukrUul1r29xyUkSSeeKi3/2jy3JNVr6jvmF8N5uBPPvz+sHguk2BwPAhXr158p7sFrcsLYG4pxonkX33GMFWYYKwKz/Bupusqe3EunSWfc7juu6YmSXJKqPceUFJi12XWktO0Xs9ijtepp1neu+Mb/3Hbg2YA1IuHZAH2XM/G9hpeT5kTcY8SGuHip81D3PcWiT6TZb0nlJeGuKvzseIblhDlUMEbeJPW7yDx+91rpgwel4oP21XTY2tlS1xG+49r1l356xyxnu/7eP98wT0rJkPpf7DkmMVlq2UPatNB3e236mo0/a+f4jpGcNZ7BOk5Yb5Mi5+8U1vxoXa6cTeaxe9ZJB3ZZ0+7ezeax6Zn29BdSZKwvNe9sT/sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFht5cqVcrlctuT+/e9/r9///veW5fv000/16aefqmHDhho+fLhOPfVUNWnSRA0bNlTDhg0VHx+vwsJC5efna9OmTVqxYoVmzpypNWvWWFbDYd9//71t5+1YoTzu+fPnW3pcEydO1MSJEy3L99FHH2nq1KkaMGCAzj77bHXu3FmNGjVS/fr1VVRUpN27d2vp0qWaNm2aFi9ebGstkn/fzeeff27b9QjAWqWlpXr99df1+uuvq27duurbt6/69OmjFi1aqEmTJhozZoySkpIkSdOnT9eCBQu0bds2rVmzRvPmzVNZmcUvEQ2QHePU1q1b9bvf/U5/+MMf1K9fPw0YMEAdO3ZU48aNlZqaqqqqKh08eFA5OTn65ZdfNHfuXK1fvz7g9tauXXvkOF588UXdfPPNlhxDqMZwq1lZd3Fxsd544w298cYbSk1N1SmnnKITTzxRHTp0UGZmptLS0lSnTh2VlZUpLy9PBw4c0MaNGzVv3jxlZ2erosIBLzEDokRJSYleffVVvfrqq2rQoIEGDRqkTp06qUOHDsrIyFBGhvtFv3l5ecrLy9OuXbs0b948LViwQMXFxbbUFOrx4Ghr1qxRenq6Jbk8+eijj/Txxx9ryJAhGj16tFq0aKH69esrLy9PO3bs0FdffaXZs2ersrLS1joAOAf9Jv0mcCzWHrxzwvrD4eOI9TUI1h+A6MH6Q012z6OZQwOwg69+88CBA1HZZ0r0mwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAdEsJdAAAgduTukD54QCor8m+/Jh3M4jYt8r8mE3k7pRYneY9Jz5QS60jlXt7t2LCVWXu5O6SC/eb1hVJWa7O43O1SYZ59dWz7Repxhu+4hob1+itvp7R+nvV5G5xgFpe7TSrOt759SaqqlLYskToPtSc/nKmkwCwuIcneOpyO8xw9wj13kaybvwRi40Jr8+VsMIuLi5cSkqWKUmvbD4dYv4bsmmtFKruO16nXUfYMqXVv33FdR0rLvzbLeWSfEd4/LyuS1vxglsup59+U1WOBFJvjQaBi/fozxT34r5w09oZznJAYK/zBWBGYTTact8O2LzeLS0iS6jaSDuYE32anIdLXL0hVFf7v50vJIWnD/MDqshrPBqwT7mcD9F3OxPcaXk6aE3GPEVvi4qX+F0tt+khTHpHyd4e7ovCy4xmWE+ZQgXDFSWf+Tup+uvk+W5dJHz0SujWWTQul8lIpMdl7XLNOUnK6VGpwfbTr7/mzg3ulvZvcv3elhVJymufY9gPM7pu8tXfYgV3udk04aTyDNZy03hYpf6ewZal1ufZv86PdZda1W5wvFR+U6tT1HZuYYl27x4qE9aXEFCk9SyrYZ18tAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADEqv379+ujjz7SRx99FO5SQipWj/tYVVVV+vnnn/Xzzz+Hu5Qj+G4A5zp48KBmzpypmTNnHtm2d+9eZWVlSZKeffZZffXVV+EqL2yqqqo0f/58zZ8fuhcsp6amHvn/ZWVlIWs3FhQVFem7777Td999F+5SAPiQl5enadOmadq0aeEuRVJ4xoNQqays1KxZszRr1qxwlwLAQeg3AdSGtQfPWH9wFtYfgOjB+kNoMIcGYBf6TQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAm4sJdAAAgNmxcKL19u1SY5/++DU4wi9u3xf/cJooPmcVlZHn/vGErszy7VpvFhUNWa7O4navsrcM0f/2mUnyi9e2v+0lStfV5M1uYxe1cY33bR9uWbW9+/MoVbx5bWW5fHcGIT5TiE8xiE2z4fYwV0XqeKyvM4lwOuzMN99xFsm7+Eog966zNV5hvHhtJ138wYv0asmuuFansOl6nXkdr50olBnlb95TSGpjnlaSuI7x/vuoHqbzULJdTz78pq8cCKTbHg0DF+vVninvwXzlp7A3nOCExVviDscJ/VZXSThvXjvdvk8qKzGJNrt+8nb5jUtKldv3N2jzMFSedOMh33OofImc9jWcD1gn3swH6Lmfiew0vJ82JuMeITY3aSFf/y3ysdCK7nmE5YQ7lr7gE6fz7pO6nm++zNVv64EGpvNi+uo5VXiptXuw7Li5eatPbd1zj9lJ6pufPN8xz/29VpbRpkfdcpvcXbfv5jlk7xyyX5KzxDNZwynpbJP2dwt6N1uUqPmgem7PeunYlqdjwXiEhydp2D4uo9aXm9tUBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAsad++/ZH/v3///jBWAgAAAAAAnIr1BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABALEgIdwEAAGcrL5F+elf6+T1J1YHlyGhkFrd/W2D5fSk5ZBaX1kDK9VJDg+ZmeXavM4sLh8wWZnF71ttbR94OqaxESkrxHueKk+o3k/Zvtbb9zYutzXdYXcNrPcfm85u73d78+FVCknlsRZl9dfiS1sD9u1Svqft/j/z/plJ6Q8nlCl9tTuLE82x63cYn2ltHqIV77iJZN3/xV1mJVLDfunySVFpoHhvnkFWOWL6GJPvmWpHKruN16nVUWS6tnCn1Od97nCtO6jxUWvSJWd7G7aSGrbzH/DLDLJfk3PNvwo6xQIrN8SBQsXz9+YN78F85aewN5zghMVaYYqwITP4eqarCxgaqpZyNUouTfIfWbypt8RGTPUMadp3vXN1GSut/MqpQkru+1Pq+45Z/Y57TbjwbsE44nw3QdzkT32v4OWlOxD1GaJUVu+dHwXC5pMQUKSlVSk6V4uIDy1OnrnTJX6S375AKc4OrKVKF4xmWE+ZQ/khIli5+RGrXz7/9slpJyWlS0QEbivJi7Ryp40Dfce36S2t+9B3jzfqff/3/G+a57+c9qd9ManCCe97oSdMTpbT63tuU3MdoyknjGawRTett0fB3CqWFUvFB6/KVFZnH5u2yrl3JPYcxEei8xJdIWl9q0Ezalm1jLQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxIDRo0dr0KBBkqSysjItX748zBUBAAAAAACnYf0BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABArEsJdAADAWQr2S9lfStkzpIM51uSs39QsbvzT1rQXqDp1vX+ekWWWJ29H8LXYpW5js7i8nfbWIUkHdkqN2/mOq9tI2r/VunbLSqTNi6zLd7S0TLO4A7vsaf+w3evtzY9fmfZvklSYa02brjipVQ/phG5Sk/ZS4/ZSvSbW5MavOM9uJYfM4kzHyGgRLXMXyff8xV/5NoxR5cXW54x0sXwN2TnXikR2Hq+Tr6NvJkrNu0pNO3iPG3WLtHGB2f3JmD97/3zmK9LO1eY1Ovn8+2LHWCDF5ngQqFi+/vzBPbibE8fecIwTEmOFPxgrApOz0f428nZJLU7yHZfWwHfMvPel5p2ljoO8x3UaIp00Wlr+tUGBLum8e32HzfmPtHOVQb4Q4dmAtcL1bIC+y5n4XsPPSXMi7jFCa/sK6cMH7cufkCwNGCOdPE5KTPYdX7eR9JvJ0tRHpXVz7avLCtHyDMsJcyh/ZLV2//NXan3pt+9KX/5LWvaF5WV5tOIb6aRRUuve3uO6ny4tnCrt3VT75ynp0uCrPO+//idp08Kj2v1W6nWudEIXz/ucdqv0wQPeP/dl6TT/7imcNJ4heOFcb4uWPt5fVv0N4mHlJX60vcfatsv8aNsOEbW+ZDh/BgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANcXFxekf//iHbr/99iPbli1bpiFDhqi4mBerAgAAAACA4LH+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACIRQnhLgAA4CyLPpHmvW9tzoRka/PZJS7O++eJdczylBYFX4tdkiLoGEoKzOKSUq1ttzjf2nxHS0wxiysttK8GSSovsTc/fpXe0Cyu5JBUXhpcW43aSr3PlU4cLKXWCy4XPOM811SYaxaXkiG54qTqKnvrCZVombtIvucv/qqssDZfrIrla8jOuVYksvN4nX4dZc+Qmv7Wd1yX4dLcyd5jWnaXMhp5/ryqUlrxjV/lOf78e8NYEH6xfP35g3twN6eOvaEcJyTGCn8xVgQmFP1Fqemaq+E68bLpUsdBvuO6jZSWf+07rkVXKT3Td9yKb33HhBLPBqwVrmcD9F3OxPcafk6aE3GP4SwVpe57hdU/SuMelzKyzPY7+VJp3Vx7awtUtD3DcsIcKpRG3ihtzZbytoeuzTVzpNa9fce16y/t3VT7Z236SnHxnvdd//Px2zbMk07o4nmflt2lxOTan6/XqSs1O9F7vZK0ZrbvmKM5aTxD8MKx3hZtfby/wjlvd9o9QzSuLwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAosedd96plBT3Cx5XrlwZ5mqcq6qqSh06dDjy83fffacxY8bo0KFDYawKAAAAAAD7sfYQOqw/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABiUUK4CwAAhNbBvdLG+f7tk5QmdR1uFnvKOOmXL6WifL9L8ygu3rpc4RRvOOpWVdhbRzDiE83iQnEMVZVmcXEWz3bKS6zNdzTTa73S5vMbydeg0zRobhZ3cG/gbdRtIg2dIHUZIblcgeeBd5zn2h3abxbnckkZWdLBHHvrCRWnzF0CUh3uApwhlq8hO+dakSgS5pbRatVMacQNUmKy97iuI6W5k33HeLNhnv/3uE4//14xFoRdTF9/fuAe3M2pY28oxwmJscJvjBUBsbs/kqSKMrM40zXXjQulQ3uljEbe41r1lNIypcJc73Gdhvhuc8dK6cAus/pChWcD1grXswH6Lofiew07J82JuMdwptxt0jt3S9dMlJLq+I5v3lnKaiPt22x3Zeai9RmWE+ZQoZSYIp33R+k/vzefLwVr3Vxp9G98X1dt+0nz3q/9s/YDPO9XXS1tWHD89g3zpKHXeN4vIcl9j7Ghlr+NattPcsV5LVclBdK2bO8xx3LSeIbghXK9LVr7eL+Fcd5e7bB7hkhaXzJdawAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARI+33nor3CXEjCuvvFJLlizR+++/r/vuu0+VlSF6kR0AAAAAAGHE2kNosf4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIg1CeEuAAAQWvu2SF895/9+6Q2kVj19xyWnSYOvDqwNIBpUlIW7AjhJVhuzuIM5geXvMFA6949SUp3A9ocZzrNnBfvNYzNbBH6tA3COWJtrxdrxWqm0UFo3R+o60ntcZgupSQdpz/raP49LkDoN9p4je0ZgNQJANHDqWBTKcUJirAA8qpayv5JOvcJ7mCtO6jJMWjjVe9yJp/pucvk35uUBAACYOLBL+vENadQtZvHt+kn7NttZkTmeYcWWpidKg66QZr8VmvYKc6Vdq6XmXbzHtegmJaVKZUXHfOCS2vb1vN+e9e42jrV3k3Rwr1S3ked92w2QNsyvZXt/77VK0oZ5UlWl7zjAk1Ctt9HHAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxK68vDx169ZNhYWF4S4FAAAAAAA4FOsPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBYkxDuAgAA0WHmy9LVz0sul+/YHmdKiz+T9m22vSwg9KrDXQCcosEJUkq6WeyeDf7n7z9GGn69Wb8drPISKTHF/nYiEefZu9zt5rFZraXNi+2rBUCUiLW5Vqwdr8WWzZC6jvQd13WktGd97Z+17SelZHjetyBX2rgwsPoAICo4eCwKxTghMVYgdEKw9GCLX76UBl0uueK8x3UdJS2c6vnzZp2ljEbec1SWS2t+8L9GAAAAX7JnSEOvkxKTfcc262x/PSZ4huUMG+ZLORukgZebxZ8yTtq4QNq5yt66Dls7R2rexXtMXLzUupe0bm7N7U07Sqn1Pe+3YZ7nzzbOl3qd4/nzdv1r2eiS2vb1Uuj/rJ3jOwbwKgTrbfTxCFS0ri8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDjFRYWhrsEAAAAAADgcKw/AAAAAAAAAAAAAAAAAAAAhMegUwepf//+4S4DMWbO7DlauHBhuMsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwioh3AUAAKLDng3Syu+kbqN8x8bFSyNvlN6/35q2qyqtyRNupscRH8Gjc2W5WVwojsG0DdOaI0FlhVlcfKK9ddidH26te5nH7lnnX+5OQ6QRN/i3jy/Fh6S87VLeTil3u5S3Q8rd4f656wjpjNutbS8acJ5927/NPf7FxfuOPaGrtHCq/TWFglPmLggfriFYIRauo23Z7jGyQXPvcV2GSTNfkVR9/GfdRnrfd/nXUnWV/7XFwvmHRVzWp+T6M8M9uPOFYpyQGCsQOqHoL0zbMO1DJelgjrR5sdS2n/e4ph2kzBbu9ZDadBriu60N86WSAvPaQoVnA9Zy4rMBIGpw/+IV9xjOVl4qbVkqdTjZd2xWK9vL8ckJz7CcMIcK1spZ0hdPSdXVUps+UrNOvveJi5fOvUeadItUXmx7iVo7Rxp+ve+4dv2ldXNrbms/wPs+63/2/NmGeVKvczx/Xq+JlNlSyt3267bmnaQ6db23WV4ibVrkPaY2ThrPEPmc0McjfCJpfanKj/UlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAWFGvXj21aNEi3GUgxmRkZIS7BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACDsEsJdAAAgenw/STpxsJSY7Du2TR+pXX9p44Lg260sN4ub8axUXhp8e4Haudr75xVlZnmSUoOvxS5lxWZxyWn21iFJKelmcaY1R4LyErM4u8+vye84gtdhoHns7nXmsQ1aSGfd6X89krufyt1e81/eTilvu1RSEFhOp+I8m6mqcB9fVmvfsS1Osr+eUImWuYvke/6C8OAaghVi5Tr65Utp6LXeY9IbSq16SFuX1dyeWEdqf7KP/F8FVlesnH8ELyHR+pxcf2a4B48Ndo8TEmMFQicxxf42Ugzf31BW5F/eZTOktv18x3UdKc1+q/bPOg32vf/yb/yrK1R4NmAtJz4bAKIF9y/eP+cew/nyd5vFmc6p7OKUZ1hOmEMFY8ln0tcTJVW7f572lHTNRCkhyfe+9ZtKp90iTX/G1hIlSQd2SXs3S43aeI9rV8v9QLv+nuMLcqU96z1/vmWpe1zw1ue16yflbjvq5wHea5SkTYukigDGGyeNZ4hsTunjET4hWV/ivh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEGUSwl0AACB6FOyTFk6VBl5mFj/iRmnTIqm6Krh2K8rM4rYukw7sCq4tO1WUmsUlp9tbRzDKisziQnEMpm2UFdpbh5XKi83iktPsrSOSr0GnSGsgteltFrt3k1Sw3zz3kKulpBTz+J2rpTU/SFuWudsKts+OFZxncztWSVmtfcelNZCadZZ2rba/Jrs5Ze6C8OEaghVi5Tr65Wtp8NVSXLz3uK4j3Md6tI4DpcRkz/tsWy7l7Qisrlg5/7HG5bI+Z2Id63Ny/ZnhHjw22DlOSIwVCK2UEPQXKYZ9XnmJf3nX/yQVHZBS63uP6zpSmv3W8dubdJTqNfG+b/FBaeMC/+oKFZ4NWMuJzwYAO3D/EnrcYzhfYZ5ZnN3fsS9OeYblhDlUoOZOPn5enLtd+mGSNPImsxzdT5c2zJPWzrG+vmOtnSM1auM9JqOR1LCVtH+r++c69aSmJ3qO3zDfe76KMvfY0H6A55j2A9x/43RYu/7ec0qBny8njWeIbE7p4xE+oVhfMp0LlRnOnwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsFtcuAsAAESXn9+TCg+YxTZsKfU6J/g2iwzbS8sMvi07FeaaxdXJsLeOYJQUmMWl1rO3Dsn8PJUU2luHlcqKzeLsPr/1m9qbH1Kf86W4eLPYDfPN82a1ljoNMYvdvU5663bpP7+TFkyRcjZI1VXmbR0tKTWw/aIV59k/Wxabx3YZZl8doeSUuQvCh2sIVoiV66gwV9q0yHdcpyFSfGLNbd1Get/nly8DrytWzn+sSUyxPqcd93dcf2a4B48Ndo4TEmMFQqteCPqLOnXN4sqK/MtbVSkt/8Z3XP2mUvPOx2/vbLAOs/p7qarCv7pChWcD1nLiswHADty/hB73GM5XVWkWZ/oM0A5OeoblhDmUv6qrpe/+Lc1+q/bPF34sbfvFPN8Zd0hpDSwpzat1c8zi2vX79f+37Su5XJ5j1//sO5+vmBYn/ToepjWQmnTwHl9ZIW2Y57vd2jhpPEPkclIfj/AJyfqS4XzXdP4MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDd4sJdAAAgupQXS7PfMo8ffJWUnB5cm4f2m8VlZAXXjt0O7TOLa9TO3jqCkbvdLK5pR3vraNhKSkzxHVdVKR3YZW8tVsrfbRbXpIO9dWS2sDd/rEtJl/qcbx6/bq55bJfhksvlO27HKmnyXdLutea5vUmta02eaMF59s+WZVJ1tVnsSaOlxGR76/Gm/xhp5E1SVuvg8jhl7oLw4RqCFWLpOsqe4TsmOU1q1//Xn1PrSa17e44vK5LW/BB4TbF0/p2gusosLqmO9W03OMH6nFx/ZrgHjx12jBMSYwVCr24jm++ZXVLj9mahBwz70KMtM/hdlKSuo47fduJg3/st/8a/ekKJZwPWceqzAcAf3L9ELu4xnM/k2ZBk/kzEDk56huWEOZQ/qiql6c9IC6d6CaqWvnhaKis2y1mnrnT2XZaU51XORrN7hKPvu9sP8BxXUSZtXeI738b53j+PT5Ra93L//7b9fP9ubF0mlRb6brc2ThrPELmc1McjfEKyvtTWLNR0/gwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgN3iwl0AACD6ZM+Q9m81i61TVxo0Prj28neZxTXvHFw7djtgeBzNTrS3jmDs3WwW17yLrWUY5z+wU6qqsLcWK+XuMItrZvO13rKHvflj3YibpOQ0s9i9m6Rda8xzt+ljFvflP6WKUvO8vqQ3tC5XNOA8+6c4X9q+wiw2JV3qeba99XjiipP6j5H6XSRd92/pqn+6a0lK9T+XU+YuCB+uIVghlq6jDfOkwgO+47qO+PX/dxoqxcV7jl31g1QexDgeS+ffCSrKzOJS61vbbsNWUmKytTklrj9T3IPHDjvGCYmxAqHnipNOOMm+/FmtpaQ6ZrGmfejR8rZL25b7jus81H2shzVuJzVo7rsef9bQQo1nA9Zx6rMBwB/cv0Qu7jGcz/T3qrzE1jK8ctIzLCfMofyRs1Fa/rXvuPw90sxXzPO27Sv1OT/wukytm+s7psVJ7rHEFeeuy5Oty8zutw/tc583b9oN+N//9vedb+0c3zGeOGk8Q+RyUh+P8LF7falhS/O/iQpkfQkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADvEhbsAAED0qa6SZr5iHt/nfKlB88Dby9loFtfipMDbCIXd683islpLSan21hKofZvN4uo3kzIa2VdHqx5mcfu22leDHfJ2mMVlniClNbCnhrh4qXVve3JD6jhI6j7aPH7pNPPYuASpaUffcXs3m/8umzqhm7X5rOBy2ZOX8xyYFd+Yxw4aL6Vk2FeLJ52HSemZv/7crJN0xu3Sb96RzrlbatndPJdT5i7wzq5+RuIagjVi6TqqqjQba9qf/Ou9VreR3mN/mRFcTbF0/p2grNgsrlFba9tt29fafIdx/ZnhHjx22DFOSIwVCI92/e3L3dLwWisvlQr2BdbGsi98x6TWqzlGdhriex9/1h3CgWcD1nHqs4FIZOe6B4LD/Uvk4h7D+eo2NosrK7K3Dk+c9gzLCXMov1Sbhy77Qtq00Dx++PVSw1b+l+SPtbN9x8QnSq16uZ/BeXsWuP5n83Y3zPf+ebv+kitOatPHe1x1tbT+J/N2j+Wk8QyRyWl9PMLLzvUl036uvFQ6tNe+OgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8EdcuAsAAESnjQukLUvMYuMTpOHXB97WnvVmcY3bSan1A2/HbjkbpOoq33Fx8dJJp9lfTyD2bpaKDpjF9j7Xnhrq1JM6DTGLNb1GI8XutVJ1tVlsz7PsqaHTYKlOhj25Y12T9tI5fzSPLzwgLf/aPD61nuQymN3v3Wye00TdxlL9ptbm9Kay3CwuqY497cfKebba6h+k8lKz2JQM6fTb7K3nWIl1pBEe5iqJyVK3UdLlT0k3vC6dMk6KT/Sezylzl1gV7n5G4hqCNWLtOsqe4TsmIUk68VSpXlOpeRfPcfu3SjtXB1dPrJ3/aFeYaxbXpL217Z402tp8h3H9meEePLZYOU5IjBUIn26j3NeqHXoZrufuCuLaXztbKinwHdd15K//v9Ng77HV1dLK7wKvKRR4NmANJz8bCKVIWPdAcLh/iVzcYzhbfKLUprdZ7IHd9tbiidOeYTlhDmWn6f8wm1tL7nuIc++R4hLsq2fHKqkwz3dcu35S+wHeYzbMN293wzzvn9dtJPU8W0pJ9x6307B+T5w0niEyOa2PR3jZub7U82yzuF1r7GkfAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBAxIW7AABA9Jr5ilRdZRbbcZDUskdg7RTmSfu3+o6Li5d6nhVYG6FQWijtWmMW2+c8e2po3C7IBNXShvlmoT3PlhKSg2yvFr3PkRKSzGLXz7O+fTsV5Ut7N5nF9jpXikuwuACXNGCsxTkhSWreRRr3NykpxXyfuf+VykvN41PrmcWVFZnnNNHzbGvz+VJSYBaX1sCe9mPlPFutrEj65Svz+M5DpT4X2FfPsUbeKKU39B3XoLnU7TSpstx7nFPmLrEq3P2MxDUEa8TadZS7Xdqx0ndc1xFSl+HeY7K/DL6eWDv/0e5gjllc695SokX3ua16WXCP7gHXnxnuwWOLleOExFiB8KmTYc/10KqX1KiNWeymRYG3U1EmrZzpO67jQPeY27CVlNnSe+z2FVL+nsBrCgWeDVjDyc8GQikS1j0QHO5fIhf3GM7WbaSUnGYWm7vN3lo8cdozLEfMoWxUsF/6ZqJ5fJP20pCr7atH1dK6ub7D2vaX2g3w/HnORunQXvNmd65297/emBz32tnmbdbGSeMZIpPT+niEl13rSy26SU07mMVuDmJ9CQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAq8WFuwAAQPTK2Sit+NY8fuRNklyBtbVxoVlc7/Ok+MTA2vCm1zlSclrweTbMN4vLbCn1PDv49o7WuJ004XnpymelVr0Cz7NurllcnQxp+P8LvJ3aNDhBGnCJWWzORunQXmvbD4UtS83i0jOlQeOtbbv3OVKTDtbmhNTnfOmyv0kp6eb75O6Qlk33rx3Tvq9OXf/yepOUKvU5z7p8JkoOmcU1PdGe9mPlPNth3vtSZYV5/KibpW6j7KvnsJMvlXqeZR6/4EOzuHDPXSTr5i+xJtz9zGFcQ7BCrF1H2TN8x7TqKfXycq9VVenffa43sXb+o9neTWZxiSlSx1ODb88VJ426Kfg83nD9meEePLZYMU5IjBUIv8FXS2kNrMuXkOTfuLR5SXDtZRuseSWmSB0GSZ2G+I5d8U1w9YQKzwaCEwvPBkIlUtY9EDjuX+ypwao5EfcYzpTRSBp+g3n81mX21eKNE59hOWEOZaeV35nP0ST3fKpld/vqWWtQS/2mUpP2nj/fMM/PRqulTT7GEZNr3qR2X5w0niHyOLGPR3hZvb4UlyCNuNE8Ptj1JQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArBQX7gIAANHthzel8lKz2Cbtpe6jA2tn5UyzuPRMafj1gbXhSZdh0um3Sf/vFanjoOByrfhOqq4yix15k5TVOrj2DktIls75o+SKk5p3li57Qhr3hNSss/+5NsyX8veYxfY5X+o0xP82apOQJF3wgJSUaha/5HNr2g21VbPMYwdeJrXuZU27TdpLw2+wJhfcmnSUxj8tnXar+/o1VV0lTf+7VFXhX3vlJWZxzQP4vffk9Nuk5DTr8pkoOmAW16qHlNbA+vZj5Tzb4dBeKXu6ebzLJZ19lzTwcnvqccVJQyZIw64z36fwgHssNxHOuYtk7fwl1oS7nzmMawhWiLXraPX3Ulmx95i4eKluY8+fb5hn3g/4EmvnP5rtXm8ee+qVUnxicO0NvVZq1Da4HL5w/ZnhHjy2WDFOSIwVCL/kNOn8+93XqxVO+435uJS7TdqzLrj2cjZKu9f6jus20vfackWZtObH4OoJFZ4NBC5Wng2ESqSseyBw3L9Y376VcyLuMZynQQvpir9LKelm8ZXl0ubF9tbkiROfYTlhDmW3L/8pFeWbxbripHPuNp9X+WvrUqmkILgc6+cFsM/PwbWZs1HK3x1cDslZ4xkijxP7eISX1etLI2+UmnUyi83dbrY2BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAqMSFuwAAQHQr2Cct+Mg8fsg1UmKK/+3sWSflbDSL7XuB1HGQ/23Upnln6cw/uP9/eqZ00Z+kCx6QUusHlu/gHmnTIrPYxGTpkr9IjdoG1tZh8YnShQ9JjdrU3N66l3TVs9LFj/jXRnWVf9/5OXdLnYeZx9cmJUMa+1epcTuz+MID0vKvg2szXHavlXavM4t1xbm/2zZ9gmszq4005v/c1xyCk1hH6jxUuuxJacJzUouT/M+xYIq0Y6X/+x3abxaXkSW16+9//mP1uUDqOiL4PP7atdYsLj5RGnad9e3Hynm2yw9vSIV55vEulzRkgvt3qkEL6+rIbCGNe1waeLl/+/30jlRZbhYbrrmLZP38JdaEu585jGsIVoi166i8VFr9fXA5smdYU4sUe+c/mu1c5b5+TDRo7p6fBKrn2dLJYwPf3xTXnxnuwWOLFeOExFiByNCyu3TevVJcQuA5XHHSqJulHmeY77P488DbO9oyg9+jtn2PX9M+1vqfpdJCS0qyHc8GAhNLzwZCJVLWPRA47l8ie07EPYZzJKVKg6+Wrp0o1W1svt/6n6WSAvvq8saJz7CcMIeyW1G+9NW/zOPrNpZG/8aeWqoqpY3zA9+/6IC0a43/+21a5G47UGvnBL7v0Zw0niHyOLGPR/hZsb4kSUOvlfqcbx6/+LPg2gMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwGpx4S4AABD95r0vFeaZxaZnSidfGng7pi54QOp+emDtHO3SJ6TE5JrbOg2R/t8rUrfTAss5d7J5bN1G0hXPSF1HBtZW3SbS5U9J7fp5julwinTNROnce6WkVLO82V9KBblmsQlJ0nn3SkOvdf9/fzXvLF31T6lld/N9Fk6RKsv9bytSLP7UPDY5Tbrk/6T+l0hx8f631XWkNP5p9+9mrIlPkFIy/P9Xp56UkSVltpBa9pC6jZKGXy9d9qR0+/vS+fdLrXoEVtPmJdL3rwe2b2mBVHTALPa0W6XUeoG1I0mDrpBOuyXw/YOxa7VUVWkWe9Jo6bTfSPGJ1rUfK+fZLqWF0rcv+b9fqx7S//u3dM7dUtMTA2+/SXvprD9I1/1batXTv323r/Cvf5bCM3fpOMie+UssCXc/czSuIVgh1q6j7BnB7b9xoTV1HBZr5z9aVZZLmxebxw+4RBp4uX9txCVIw/+fdMbt/u0XDK4/M9yDx5Zgx4mCXMYKRI5OQ9xrvw1O8H/fjEbSJY9KfS8036esSFr+tf9t1WblTKmsxHuMy+Ap9opvrKknVHg24J9YfDYQCpG07oHAcP8S+XMi7jGikEuqU1dqcZLU6xzp4oel374rDRrv3xhWXS39/K59Zfri1GdYTphD2W3tHPcc21S3UVLnYfbUsmZ24PtuXCCp2v/9yorcz/ECtXZO4Psey0njGSKLU/t4hF8w60tpmdLFj0injDPfx8r1JQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOD/s3fncVqVdf/APzMM+7AKuIC54IIgiCsoikuLpmZparZZ5lOWmfZkLrmVe/pUjy2mtplaauWuqQmGSwqKmiK4oOIKggrKvs/8/pgfPI0MMMs9c8/yfr9e9yvPOdd1fT/3mbOfiQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKJSyYgcAoOVbviT517XJ/ifVrv2un02euSeZ/27d6jz/YDLyqKTv5utvW9ou+eT3ks12Sh7+YzJ3Zt1q9eqf7PnlpEOnmpd37pYc9P1k8D7JP36RzHun9mPPeD556dFk6z1q175D5+TgU6vW24Qbk2kTq9b5unTrmww/KNnlM0n7tXyH/1RSkvT5SLJsUe0yrViajPlVcug5tWtfUpKM/Fyy/ceSR/6cvPhwsmT+ujokmwxKdjs82WZU7Wqs8t7rycRb6tanuZlyf9XPuzbbelK1ve/7X8nwA5NHr6/avtb1syxtl2yxazLiiGTAkIJEbpE2G56c+Ldip/g/s99Mbr8gqayo/xjTn0+23n397XpunHz+f5I7Lk7efbX24/fdItn72GTLXeqfsaGWL0lmvZxsvG3t2u/0qarjyJSxyZvPJu+/nSxbmKxcsfY+FSvXvQ+1hfXcmF54sGr/2+GTdetX2i4Z8tGqzwdvJ6/9u+qcOufNZO6sZOmiqvNTkpR1SDp2Tbr0TPptmWy4VbLlbknv/vXLvHxpcs/PklTWrV8xrl2222ftbRpy/dKWNIfjzCq2IQqhrW1HM16ouifos1n9+jfkWqwmbW39t2TP3le7a7xV9vpKsvlOyQO/S95+ce3t2rVPBo1Odv980ntAw3PWhe2vdtyDty0NPU9MGetcQfPSf7vkmCuSyWOTp26v2r7XpfeAZIcDkx0Prrp3rotHrq/98+P1Wb44efGhZOgn6j/Gog+SaU8UJk9T8W7Au4HmoDk996D+3L8072si9xhNY7MdkuOvb9gYJaVVvw9Qm3NmbTz3z2TWK4UZq75a4zus1nAN1RTGXJ58ZFhSvkHt2n/iO8n0Kcn89wqb49Unq96rte9Y974vT6h/3VcmVH3/unp/RvLea/Wv+2Gt6XxG89Maj/E0D3V9vtSrf7LDAcmOh9T9eF/I50sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQKGXFDgBA6zDpH8nOn0n6bLb+tu07Jnt/LbnrkjoWqUz+8fPkiz9NSkpr12XwPsm2eybTJiavPpG8NSVZ+H6yeF7VeElSWpZ07p707p9stG0ycNdk02FJScn6x99il2T7jyeP/rluX2XMr5NNhyadutW+z4YDk0+fmaxckcx4PpnzVrJobrJ4blXWDl2Tbn2q2vUbWLv8/+nBP9St/UuPJi8+nGy7V+37lG+Q7H9i8okTkhkvJu+9niyckyyZn5R1SLr2Srr1rVo3nbvXLU+SVFYk9/xvUrGi7n2bk8qK5P4rk6N+XLd+vTZJDvp+UrEymf58MufNqu19yfyq7bxL92SDzZL+g5NO5Y2Tnfp57/XkL6cnSxc2bJyXHk223r12bTf4SHL0L5OpjyTP/TN5+4WqY8p/Km2X9Ngw+cjwZOCIZOBuaz+2VFbU/tjcUP++K9l429q3L++djDiy6lMbLz+W3PLDtS9vK+u5MY39ddJvy7r9HP9Tz42T4Rsnww+sPr+yMkll4dfR2MuT96fXo2MzvHZJ6n/90pYU+zizmm2IQmiD29Gz/0j2/Ubhx62XNrj+W6pXHkvmTK9ap7W16dDkyz9P5r+bvDEpWTD7/1/rlVTdf/XZPNl0+6RDl8ZKvR62v1pxD972NOQ8Mekfhc2SxL5Kg5V1qLo/Hn5g1bns7ReSD2YmSxdUPXPo0isp75VsMjjpuVH9asx5K3nytoLGzjN3J0M/Uf/+zz9YdQxvabwb8G6gOWg2zz2oN/cvVZrrNZF7jKbRrn3V8am5mPdu1buPYmut77BawzVUY1u6oOp66IgLate+U3ly0CnJjacVNseKpclrTyZb71G3fitXJK8+Vf+6rzxev3v9lx6pf80ataLzGc1Paz3G0zys9/lSz6p79/6Dq35foz4a4/kSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFEJZsQMA0DpUViTjfpsccUHt2m+3T/Lk7cnbL9Stzoznk8dvSkYcWfs+7cqSrXev+qxSWZGsXJGUtqv61NfMl5IJN9a934L3knt/nnz6zKSkpG5925Ulmw6t+hTKs/clrz5R9373/jzps3mywaZ161dSmvTfrupTSA/8oe7bVHP1xtPJpHuTYQfUvW9pu2TT7as+9fXm5GSDAUmXnvUfg9qZ8UJy01nJkgUNH+vFh5P9vpF06la79u3Kku32rvokyfIlydKFVcfHTuVJx661r/3UncnOn6575vp4/oFk768lXXs1Tb0PayvruTGtXJ7cdE5y1CVJ380LN25JSZI6nlfX559XVZ0n66u5Xbsk9b9+aUuKfZz5T7YhCqGtbUeT709Gf63qO9TFW5MbJ09bW/8tVWVF8q9rk0N+UPe+3fomQz5av7orliVvPptssXP9+q+P7a923IO3LQ05T7w/vXEy2VdZn9eeSvoPTtp3Wne73v2rPoW0ckVyz8+SihWFHXfGC8l7ryd9Nqtf/8ljC5unqXg34N1Ac9CcnntQP+5f/k9zvSZyj9G2LF2Y3HxO1f8WW2t9h9VarqEa26tPJM/cm+xQy2PPR3ZIdjk0eeLWwuaY+kiy9R516/Pms8nyxfWvOeet5P0ZSa9N6tZv6iP1r7k2rel8RvPSWo/xND8t6fkSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFEJpsQMA0Hq8+kTy2r9r17akJNnvuPrVefDq5OXH6td3df3SpKxDUtqu/mMsmJ3cfkFSsbJ+/af+K3no6vrXL5R3X03G/Kp+fZcuSG46K1n4QUEj1cvTf08m3lTsFIU15vJk5ktNX3fZouTunyQVFU1fu6158rbk+u8nSxYUZrzlS5LHG7AftO+UlG+Q9Ngw6di19v1eHp88N67+detq5fLkX9c1Xb0PayvrubEtnpvceFry7mvFTrJ2j/wpeeLWho/TXK5dkoZfv7QVxT7OfJhtiEJoS9vR4rnJK/X4rpP+Ufgsq7Sl9d+SvfBgMm1i09Z89Ppk9huNW8P2VzvuwduO5nieSOyrrNsHbycP/qE4tcf9Npn+XOOM/cw99es3+81kVhGO2YXi3UBhtcZ3A42tuT33oH7cv6xdc7kmco/RNiyen/ztrKrzanPQmt9htYZrqKbwz6uSubNq3370MUnfLQqb4eXH6n7sfHlCw+u+8njd2i+Yk8x4oeF1a9Kazmc0H635GE/TWTyv6p6wqTXm8yUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABoqNJiBwCgdRn3m6SyonZt+2+XDBpdjyKVyZ0XJa8/XY++BbJobvKXHyRzZzVsnMf+mjzy58Jkqo/3Xk/+ekayYln9x5g7K/nrD5L57xUuV109c28y5vLi1W8sK5cnt56bvD+jCWuuSG67MJk7s+lqtkVzZyU3/zC5/8qkYkVhx3785uSdaYUdc13emZbceWmSyqarmSTP3J288FDT1vxPbWU9N7bFc5M/fy956dFiJ6lu+ZLk7p8mj/ypQAM2g2uXpHDXL21FsY8z1diGKIQ2th1Nurdu7ZctSl5szH2+ja3/luzunzTd+nnp0WTCX5qgkO2vVtyDty3N7jyR2FdZr6fuSJ69r2lrPnl78tTtjTf+lPvr92x6ytjCZ2lq3g0URmt9N9AUmtVzD+rN/UvjKcQ1kXuM1u/d15I//3cy4/liJ6muNb/Dag3XUI1t+eKqd1yVtfx5lHVIDj4tade+cBmWLkjemFS3PtMeb3jdVybUrX2jvp9sReczmpfWfIynacydmYz5VdPWbOznSwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANBQpcUOAEDr8u6ryeSxtW+/97FJu/Z1r7N8aXLT2ckLD9W9b0O9My257sRk9huFGe+R65J7L0tWLCvMeLU1c2pyw6nJwvcbPta7rybXnZTMeqXhY9VFZWXywO+Tf1yWVFY0be2mMv+95PqTk/deb/xaK5cnf/+f5LUnG79WW7VsUfLwNcnv/it55bHGqVGxIrnt/GThB40z/n+a9UrytzOT5Ysbv1ZN7r2s6Y87q7Sl9dzYli1Kbj0vGfe7pj8X1mT2G8m1JyaTxxR23GJeuySFv35pK4p5nPkw2xCF0Ja2o1efTOa/W/v2zz9UtX4aU1ta/y3ZorlVP6dC3Cuvy5vPJnddkqSyceusYvurHffgbUdzPE8k9lXW797LkqmPNE2tCX9J7r+icWssmZ+89Gjd+lRWJlP+2Th5mpp3A/XXFt4NNIXm9NyD+nH/0jgKeU3kHqN1Wrk8eexvybXfSea8Vew0a2rt77BawzVUY3tzUvLU7bVv33fzZPQxhc0w9V+1bzv7jeSDtxte883JVe8da6suGeujNZ3PaD5a+zGepjHpH1X31E2hKZ4vAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEOVFjsAAK3PQ39Mli+pXdseGya7HFq/OiuXJ3dclIz5VbJ8af3GqIvKiuTfdyZ/+m4yd1Zhx550b3LdScm7rxV23JpUViaP35z86XvJ4rmFG3fB7Kp1M+EvScXKwo27NrPfTG74fvL43xq/VrEtfD/58/eS58Y1Xo3F85K/npG88GDj1WjL3p+R3H9F8usvJeNvqDp+NaYP3k5uPLWqbmOZ+khy/feqts9iWbYoueGU5KVHi1O/raznpjLxpuT330heebw49ZcuTB6+Jrn2O8nsNxqnRlNfuySNe/3SFhT7OPNhtiEKoa1sR5UVyeSxtW//7L2Nl+U/tZX139LNfiO5/uSq+87G8OLDVfdfTbUNrGL7qx334G1Dcz1PJPZV1q2yIrntgqrnu41l6cLkrkuTh65uvBr/6Zk67l9vPpvMf7dxshSDdwN115beDTS25vbcg/px/1I4jXVN5B6j9VixLHnmnuR3X08e/H3jv+9riNb+Dqs1XEM1tgf/kMx5q/btdzk0+cjwwtV/6dGqdVcbLz9WmJoVK5LX/l27tkvmJ29MKkzddWlN5zOaj9Z+jKdpPP635O6fNt6xqamfLwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBDlBU7AACtz8I5yeM3J6O+WLv2ux+VPHtfsuiD+tX7913Jy48l+/xXMmh0UlJSv3HW5Y1nkn9elbwzrfBjr/Luq8kfj0+GH5iM+lLSpWfha7z9YvLA75I3ny382Emycnny0NXJ8w8ko49Jtty18D+PRR8kT9xatY1VrCjs2M3Z0oXJXZckL49P9j426bFh4cZ+4aFk7K/rvw+ypsrK5L3Xk5cnJC89msyc2vQZZr9RdUz56LeSYfsXbtwFc5L7r0hefLhwYzbEskXJrecl24xK9jw66bNZ09ZvK+u5qcydmdx8TrLJoGS3I5Ktd09KShu35vIlyVN3Jo/9JVmyoHFrrdIU1y5J01y/tAXFPs7UxDZEIbSF7WjSP5KRR63/u81+M5nxQtNkWqUtrP+W7v0ZybXfSfb9RrLDJwvzM1q2JBl3VfLMPQ0fqyFsf+vnHrxtaM7nicS+yjpUJg/8Nnl1YrL/d5OeGxVu6JfGVx2j5r9buDHX542nkw/eTnpuXLv2U8Y2apyi8G6gdtrqu4HG1hyfe1B37l8arrGvidxjtFwrlydvTalazy8+nCyZX+xEtdfa32G1hmuoxrRiWfL3nyRf/GlS2m797UtKkoO+n/zhm8nSArwvW/h+1b10/+3W3/aVCQ2vt8rLE6qua9bb7rGksqJwddentZzPaD5a+zGepjF5TNW5bv+TkgFDCjduMZ4vAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEOUFTsAAK3T439LdvhkUt57/W07dO/RAuoAARkUSURBVEn2+kryj5/Xv978d5M7L07+dW2y86eTQaOTLj3rP94qz96XPHlb8s60ho9VG5UVyb/vSib9I9lun6p1uMl2SUlJ/cesWJm88Uzy1J3Jy+MLFnWd3n01ufmcpM9myS6HJluPSjp3q/94lZXJzKnJpHuTyWOTlcsLl7WleeGhZOojyfYfS3Y+NOm7ef3GqaxMXnkseeyvyfTnChqxTVixLFm+NFmxNFmyIJn3TtXng7eTmS8ls15Oli0qdspk+ZLk3v+tOpbt/Olkm1FJabv6jfXB28njNyeT76v6/s3N1EeqPptsV3UO2Gx4ssFH6v9966ItreemMuOF5Lbzkx4bJtvuVfXZeNvCjb9iWfLqk8kLDyQvP1b1M2xqjXXtsmxR8uK/mvb6pa0o5nGmJrYhCqG1b0dzZyZvTko+ssO62026t2nyfFhrX/+twfIlyX2/SJ65Oxl5VLLNHklJaT3GWVo1xmN/TRa+X/ic9WH7qx334K1bcz9PJPZV1u31p5Pff73qGLXr4Unv/vUbZ8WyqmPUhBuTWa8UNGKtTbo3GX3M+tstX1q17bZG3g3UzLuBptPcnntQd+5f6q4Y10TuMZqflSuSlf//vd+iD5KFHyQfzEjeeyN555Xk7Rdb9vmntb/Dai3XUI3l7ReSx29KRn6udu279Un2PzG546LC1J/6SNJ/u3W3WTw/mf58YeolybSJVcfI9W0DU4twX9Gazmc0D639GE/TmP1Gcv3JydZ7JLsclmy6ff3GaQ7PlwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKC+SiorKytr1bCkpLGzAEDBlJQm/bdLBgxNNhmU9Nks6dY3aVe29j4VK5O5s5I5byXvTEtefSJ5a3LTZV6brr2SzXeu+h4bbZ302Cjp0mPt7VeuSN57PXnnlWTGC8lLjySL5jZd3pqUlCYDtk+23CXps3nSd4uke9+1t1++JJn9RvLu68mM55OXJyQL5zRZ3Bal96bJNqOSTbZN+g1MuveruV3FyuSDGVXr9LUnk5cfs07bom59ki12SfoPTjbZLum1SVLarua2Cz9I3ns1mf588tKjyayXmzRqQbRrn/QekJRvUHUsLeuYlLVP1ndr88HMqu9cX21tPTeVLj2SjQdVrdN+WyY9Nqw65nXovO5+y5ck896tOi/OeiV5d1rV+l62qGly11ahrl1mPF81n6ZRrONMTWxDFILtqLis/+ava69k61HJZjskG21TdV9bUrpmu4qVyfszqq4/Xp5Qdf+1fHHT560L21/tuAen2OyrrMuGWyVb7V71PKLPZkl575rbrVxedXx655XkjWeqzlXFvkfe9fBk3/9af7vnH0ju/HGjx2k2vBvwbqDYmtNzD+rO/Ut1zfWayD0GTa0tvMNqDddQtA2t6XxG89AWjvGs3Za7Joefv/52M6cm15649uW9ByQDd0s227HqPr5bn5rvAZvj8yUAAAAAAAAAAAAAgLqq5T/LXiP/VjuwNsOGDcuwYcOSVB1npk2blgkTJjTomAMAAAAALd0ZZ56RXr16FTsGbcQtN9+S8ePHFzsGQKPo2bNnzjzrzGLHoI356U9+mpkzZxY7BkCjqO2/5wmFcukBxU4A0LqVlJRkl112yTbbbLP6970nTZqUSZMmFTkZAAAtzXnnn5fOnTt7Rg7QxFb9ntnlv7o8r732WrHjALQZx3/7+GyxxRb5/e9/nxeef6HYcQDahK997WvZbvB2fvcdoIkdetih2WOPPXL33+/OuHHjih0HoM345IGfzH777Zd//vOfuefue4odBwCAGvi32oHG4N9qBwAAAIDCWvU7GNCU/M4l0JY411Is/j9mQFvy8ROSHQ8udgramvt+mTz992KnAGha/q325sXv1AIAAAAAAAAAAAA0rZKSkuy6667Zeuut/T4tUGu1+R3vsibIAQBNrrIieWtK1We1kqRL96R9p6pPSWlVu2WL//9nUVKxsmiR12rh+8mUsVWfVco6Jp3Kk/Ydq/67siJZuihZurDqu6SZ/f+8KiuSNydVfVYpLUs6dk06dqn6eVSsrMq/dFGyfHHxsrY0c95MJtz4f9Pt2v//9VqelLVPli+p2raXLEwqVhQvJ83D/PeSSfdWfVZp36nqeNKx/P+OJcv+/6elW7k8effVqk9Tamvruaksmpu88ljV5z916FJ1PmzfqeqcWFJSdS5curD5nttr0pquXdqSYh1namIbohBsR8Vl/Td/C99Pnr6r6pNU3dd27VV1LdKufbJiebJsYbJkQdU5oiWx/dWOe3CKzb7Kusx6ueqzSvtOVceoDp2rjlernx8vqtpGmpMhtfz306fc37g5mhvvBii25vTcg7pz/9IyroncY9DU2sI7rNZwDUXb0JrOZzQPbeEYT+Ob81bVZ+ItVdNlHZNO3ZIOnZr/8yUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACor7JiBwCAJlOZLJqbZG6xgzTciqXJgqXFTtEwFSuSxXOrPhTOyuXJog+qPlAby5dUfea/V+wkrZv13HiWLar6tEqt6NqFIrENUQi2o+Ky/pu1ihXJ/HeLnaIR2f7Wyz04zYJ9lbVY9Syiueu3ZdVnfRbMSV59svHzNHfeDQD15f6lZXCPQTG0hXdYreEaijailZzPaD7awjGexuUcCgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQFtQWuwAAAAAAAAAALQ9wz5Zu3ZTxiaVFY2bBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABoW0qLHQAAAAAAAACAtqVTeTJkv9q1ffa+xs0CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALQ9pcUOAAAAAAAAAEDbstsRSceu62/3xjPJnLcaPw8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0LaUFjsAAAAAAAAAAG1Hv4HJrofVru3EWxo3CwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQNpUWOwAAAAAAAAAAbUP3fslnzkratV9/2/dnJK883viZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIC2p6zYAQAAAAAAAABo/QaNTvY7LinfoHbtH/lTkspGjQQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtFFlxQ4AAAAAAAAAQOvQZ7OktF3Srn3SoXPSY8Ok31bJ1iOTbn1rP857ryfPjWu8nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABA21ZW7AAAAAAAAAAAtA5f+GnSqbzh44z7TZLKho8DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCT0mIHAAAAAAAAAIBVnhuXvPpksVMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK1ZabEDAAAAAAAAAECSzJ2VjP11sVMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK1dabEDAAAAAAAAAMCyJcmt5yZL5hc7CQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQ2pUWOwAAAAAAAAAAbdvShclff5C8M63YSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAtqCs2AEAAAAAAAAAaLtmvZLcdUky+41iJwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2oqyYgcAAAAAAAAAoO2Z/17y+N+Sf/89qVhR7DQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQFtSVuwAAAAAAAAAALR+K5Yl70xL3n4heWlC8uakpLKi2KkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgLaorNgBAAAAAAAAAGgd7vlZ0u7/v4Vesazqs2RBMv+9ZNEHSWVFUeMBAAAAtCqzXknuuGj97ZYsaPwsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0NKUFTsAAAAAAAAAAK3DS48WOwEAAABA27FwTvLCQ8VOAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC1TabEDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQFMpLXYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaCqlxQ4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATaW02AEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgqZQWOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0ldJiBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICmUlrsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANBUSosdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJpKabEDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQFMpLXYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaCqlxQ4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATaW02AEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgqZQWOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAxDB8+PPPnz8/8+fNz4YUXFjsOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATaSs2AEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACKobS0NOXl5UmSDh06FDkNAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATaW02AEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgqZQWOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0ldJiBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICmUlbsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE1hxx13zOGHH55hw4Zlyy23zOabb7562QknnJBPfepTeeWVV/Loo4/mnnvuyVNPPdWgegMGDMhBBx2UffbZJ9ttt10GDBiQ8vLydOzYMYsXL86cOXPy0ksvZfz48bn99tvz2GOP1atOWVlZvva1rzUo639avHhxrrvuuoKNtzYbbLBBjjjiiHz0ox/N9ttvn/79+6dr165JkoULF2b69Ol59tlnc//99+emm27K7NmzC1J38ODBOfTQQzNixIgMHjw4vXr1So8ePZIkc+fOzfvvv5/nnnsujz32WG699dY899xzBam7+eab59BDD82ee+6ZwYMHZ8MNN0y3bt3Srl27LFq0KG+//Xaee+65jBs3Ln/5y1/y9ttvF6QuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG1T165d07Nnz7Rr167G5W+88UYTJwIAAAAAAABoXsqKHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKCxlJWV5Zvf/Ga++93vZuDAgWtt16lTp2y77bbZdtttc+CBB+aCCy7IpEmT8qMf/Si33nprnesOGjQoU6ZMSWlpaY3LO3funP79+6d///7ZZ5998oMf/CD//ve/c8opp+T++++vU61evXrlqquuqnPGtZk5c2auu+66go33Yb169cqFF16YY489Nh06dKixTbdu3TJo0KAMGjQoRxxxRH7+85/nd7/7Xc4666x88MEH9aq722675Wc/+1lGjRq11ja9e/dO7969M3DgwHzqU5/KBRdckH/96185+eST8/jjj9er7jbbbJOLL744hx56aEpKSmps07Vr12y11VbZaqutcsghh+QnP/lJrr322px++ul555136lUXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA4hg3blyN8/fdd98mTkJT8nOn2AYOHJiDDjooe++9d0aMGJF+/fqlffv26+xTUlLSROkaX6H2QfsyND+XX355Bg8evMb8b33rW3nhhReKkAiKyz4BAECheR4CAEBbV1bsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI1hq622yt/+9rcMHz68Xv2HDRuWW265JX//+9/z5S9/Oe+//36t+n33u9/NJZdcktLS0jrV23HHHTN27Nj87Gc/y8knn1zrfuXl5XWqU0y77757brnllmy00UZ16texY8d8+9vfzqGHHprPfOYzmThxYp36/+hHP8rZZ59d559Jkuy5554ZP358zj///PzoRz+qU98vfelLueqqq9KlS5c69WvXrl2OOeaYHHTQQfnMZz6T8ePH16k/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEvSqVOnDB06NJtsskl69OiR7t27p0uXLlmxYkXmzp2buXPnZs6cOZkyZUpmzZpV7LgAAOu1zz77FDsCReDnTrEMHjw455xzTo444oiUlpYWO07RFGoftC9D87PTTjtl5MiRa8zv3r17EdJA8dknmp8OHTrUOH/ZsmVNnASA2nDchjV5HgIAQFtXVuwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAhTZ48OA8+OCD6dOnT7X5lZWVmTx5cp5++ulUVlbm6KOPTpI888wzee+997LLLrukR48e1focdNBBGT9+fEaPHp133nlnnXXPOeecnHvuudXmzZ49OxMmTMi0adMyb968VFZWpnv37tlqq62y++67p1evXtXaf+9730uHDh3yne98p1bftWvXrrVqV2x777137r333nTq1GmNZa+99lqee+65zJw5M0my0UYbZfDgwdl8882rtdtkk03ywAMP5GMf+1jGjx9fq7oXX3xxTj/99DXmz507NxMmTMjUqVMzb968JEn37t2zzTbbZOTIkdW2g9LS0vzwhz9Mhw4dcsYZZ9Sq7pe//OVcc801KSkpqTZ/3rx5efTRR/PSSy+trtu7d+8MHz48u+22W9q1a7e6bb9+/TJmzJjssccemTRpUq3qAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADR37dq1y0c/+tEceeSR2WOPPbLNNttU+1vv6zJjxow88cQTufXWW3PzzTdn/vz5jZwWAACg+frc5z6Xa665Jh07dix2FACANmmbbbbJiy++WOOybbfdNlOnTm3iRACsi+M2QOPr2bNntttuu2y55ZbZYIMN0rVr17Rv3z7Lly/PwoULM3v27EybNi3PP/98Pvjgg2LHTSIzAJCUFTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAIXXu3Dl33nln+vTps3reihUr8stf/jKXXXZZ3njjjSTJTjvtlKOPPjpJMmbMmJxyyilJko9+9KP54Q9/mL322mt1/2233TZ33313Ro4cmRUrVtRYd//998+PfvSj1dNPPvlkzjjjjIwZMyaVlZU19mnfvn0OP/zwXHrppRkwYMDq+SeccELGjBmTO+64Y73ft7y8vNr0qaeemvvvv3+9/dZmbd+vITbccMPceuut6dSpU7X5d955Z370ox/lqaeeqrHfTjvtlHPPPTcHH3zw6nldunTJ7bffnkGDBmXOnDnrrLvvvvvm9NNPrzbv3XffzamnnpobbrghS5curbFfx44d8/nPfz6XXnpp+vbtu3r+D37wg4wZMybjxo1bZ91BgwblN7/5TUpKSlbPmz59ek477bT89a9/zfLly2vs179//5x77rk59thjV8/r2rVrbrjhhgwbNiwrV65cZ10AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA5qxPnz45/fTTc8wxx6R37971GmOTTTbJIYcckkMOOSRXXHFFbr311pxzzjl5+eWXC5wWAACgeTvuuONyxRVXpKSkpNhRAAAAAIAkl112WTp27FinPtOnT88FF1zQSImaxtChQ3P00Udn//33z/bbb1+rZ5aVlZWZPHly7r333lx77bWZPHlyEyT9P20x86mnntoEKQGgZSordgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBCOvnkk7Pllluunp4/f34OOuigPPzww7Xqf//99+f+++/P8ccfn1/96ler/5jqzjvvnHPOOSfnnHPOGn1KSkry05/+tNofXt1tt91SUVGxzlrLly/PDTfckPvuuy9jx47N8OHDVy+7+OKLc8cdd6w3b3l5ebXpKVOm5Kmnnlpvv6b061//Or169Vo9XVlZmW9961u56qqr1tnvqaeeyqc+9akcf/zxufzyy1fP79u3by677LIcffTR6+z/k5/8pNr0tGnTMnr06EyfPn2d/ZYuXZo//vGPGTNmTB566KFq29P//M//ZJdddlln/1/96lfp1KnT6ulJkyZlv/32y+zZs9fZb/r06fmv//qvPPHEE7niiitWzx88eHCOPPLI3HDDDevsDwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANAcderUKWeddVZOOumklJeXF3Tcz3/+8zn88MNzxRVX5JxzzsncuXMLNj4AAEBzNXTo0Pz85z9PSUnJetuuXLkyy5cvb4JUAAAAANB29ejRIyeddFKd+02ePDkXXHBBIyRqfHvvvXfOO++8jB49us59S0pKMnTo0AwdOjSnnHJKHnjggZxzzjl5+OGHGyHp/2nLmXfdddcmyQsALVFpsQMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAU0te//vVq09/5znfq9YdNf/3rX+f444+vNu973/te+vbtu0bbysrKfPe7383YsWOTJBMnTkxFRUWta82ePTtHHnlkli1btnre4MGDM3z48PX27dq1a7XpxYsX17puU/jYxz6Www47rNq8M844I1dddVWtx/j1r3+dc845p9q8L3/5y9l9993X2mfgwIHZaaedqs374he/mOnTp9e67vTp0/PFL36x2rydd945W2655Vr7bLPNNtlvv/1WT8+bNy8HH3xwZs+eXeu6V155ZW6++eZq84466qha9wcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABoLrbffvs88cQTOfPMM1NeXt4oNdq3b58TTzwxTz75ZIYMGdIoNaC1GjVqVO655541PmeccUaxowGNbG37P0Br01qvd/74xz+mY8eONS577733ct5552XEiBHp3r17ysrK0rlz5xo/AAAAAG1Ja31WRPOw1VZbFTtCk+nZs2euu+66PPDAAxk9enRBxtxnn33y0EMP5Q9/+EO6d+9ekDH/k8yNnxcAWrKyYgcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAolE033TQf+chHVk+/++67ue666+o93pVXXpmvfOUrGTlyZCZOnJif/exnmTNnTo1tx44dm7Fjx2annXZKZWVlnWu99NJLue+++3LwwQevnjdixIg8/fTT6+xXXl5ebXrx4sV1rt2YvvnNb1abfuaZZ3LJJZfUeZwLL7wwRx55ZLbffvvV84477riMHz++xvYjR46sNv3EE09kwoQJda47YcKEPPnkk9l5552rjT1t2rQa20+dOjXbb799TjrppHz5y1/ORRddlDfffLPOdX/961/ns5/97OrpnXbaqc5jAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABTT5z//+fzhD39Ip06dmqTewIEDM2HChHz+85/PXXfd1SQ1oaXbcMMNc8ABB6wxf8GCBUVIAzSlte3/AK1Na7ze2XvvvbPTTjvVuGzMmDE5/PDDM2/evCZOBQAAAND8tcZnRTQfW2+9dbEjNIltttkmd999dwYOHNgo4x9zzDHZY4898slPfjKvvvpqQcaUubrGyAsALV1psQMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUSv/+/atNT548ORUVFQ0a87jjjsuoUaOy22675cYbb8zKlSvX2f6pp57Kv//973rVevrpp6tNf/j71KS8vLza9OLFi+tVuzH07ds3hxxySLV5Z555ZiorK+s8VkVFRc4888xq84444oh07969xvYbb7xxten6/kxq6vvhsT/sueeey3HHHZcBAwbkl7/8Zb1qTp48udp0v3796jUOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQDEcffTR+dOf/pROnTqts928efNyyy235Lvf/W7233//DBo0KP3790+fPn2y0UYbZdttt82oUaPyzW9+M1dffXXee++9dY5XXl6em266KaNGjSrk1wEAAGg2TjjhhBrnv/jiiznkkEMyb968Jk4EAAAAAGy99dbFjtDohgwZkvHjx2fgwIG1ar9ixYrMmTMnM2fOzJw5c7JixYpa9dt2220zYcKEbLXVVg2Jm0TmtSlkXgBoDcqKHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKBQ2rdvX216yZIlDR5z0qRJDR6jtj744INq0507d15vn65du1abXrx4cSEjNcgnPvGJaj+T2bNn59577633eHfffXfmzJmT3r17J0m6dOmSfffdN7fffvsabbt06VJtet68efWuO3fu3GrTH17nazNnzpx611y0aFG16Q4dOtR7LAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICm9LnPfS5XX311SktL19pm8uTJufjii3PLLbdkyZIla203a9asTJ06NY8++miuuuqqlJWV5cADD8y5556b4cOH19inY8eOueOOOzJy5Mi89NJLDf06AAAAzcp+++1X4/zTTjttnfdXAAAU3pIlS/LEE0+sdRkAzYvjNtCYZs6cmRtvvHGtyzfddNOMGjWqCRMV1oABA3Lfffeld+/ea22zfPny3HrrrbntttsyYcKEvPbaa6msrFy9vKSkJJtvvnlGjhyZQw89NJ/5zGfSvn37Gsfq169fxowZk9122y3vvvuuzI2QuRB5AaC1KCt2AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgEJ5//33q03369evSEnqp1evXtWm58+fv94+5eXl1aYXL15c0EwNseuuu1abvuuuu7Jy5cp6j7dixYrcddddOfroo1fP22WXXXL77bev0XbhwoXVpj+8buviw390tzY/l4baYIMNqk3Pmzev0WsCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANNSgQYPy+9//PqWlpTUunz9/fk499dRceeWV9Rp/xYoVueOOO3LnnXfmuOOOy2WXXZaOHTuu0a5379655pprsscee9SrDgAAQHO03XbbpXfv3mvMnz17du68884iJAIAaNveeOON7LrrrsWOAUAtOW4Djem3v/1tfvvb3651+WGHHZZRo0Y1YaLCKS0tzY033phNNtlkrW2uv/76nHrqqZk+ffpa21RWVubVV1/Nq6++mhtuuCEDBgzIpZdems9//vM1tt98881z3XXX5YADDpC5kTI3JC8AtCY1/8YrAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABACzR9+vRUVlaunt5hhx3Su3fvIiaqm5133rna9NSpU9fbp7y8vNr04sWLC5qpIXbZZZdq00888USDx3zyySfXWWOVF198sdr0iBEj6l3zw31r83NpqJEjR1abnjFjRqPXBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGiITp065aabbkrXrl1rXD5t2rTsuuuuufLKKxtcq7KyMldeeWVGjx6dd999t8Y2u+++e4499tgG1wIAAGguBg8eXOP8xx57LBUVFU2cBgAAAABoC77//e9n1KhRNS5bvnx5jj766Hzxi1/M9OnT6zTuW2+9lS984Qv56le/mhUrVtTYZv/9989xxx0ncwEyFzovALQmpcUOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUCjvv/9+pkyZsnq6rKws5513XhET1d6gQYPysY99bPX08uXLM2bMmPX2Ky8vrza9ePHigmerr6233rra9OTJkxs85rPPPrvOGqs88MADWbJkyerpIUOG5IADDqhzvf333z+DBw9ePb148eI8+OCDdR6nrr797W9Xm3788ccbvSYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQ/z3f/93hgwZUuOyV155JaNGjcqLL75Y0JqPP/54Dj744CxevLjG5Zdcckk6d+5c0JoAAADF0rt37xrnT5s2rYmTAAAAAABtwUYbbZSzzz67xmUVFRU54ogjct111zWoxjXXXJOjjjoqlZWVNS6/8MIL07Nnz1qPJ3PNCpkXAFqb0mIHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKKQ//vGP1aa//e1v5/zzz0+7du2KE6gW+vbtm5tuuillZWWr51199dWZPXv2evuWl5dXm168ePEaywcOHJgddtghO+ywQwYOHJhOnToVJvh69OjRo9r09OnTGzzmjBkz1lljlQULFuSaa66pNu/aa6/NkCFDal1ru+22y7XXXltt3jXXXJMFCxbUeoz6+MY3vpG99tqr2rzrr7++UWsCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANETfvn3zgx/8oMZl8+bNy/7775+ZM2c2Su3HH3883/nOd2pctsEGG+Soo45qlLoAAABNrVevXjXOnzt3bhMnAQAAAADagtNPPz3l5eU1Ljv33HNz++23F6TOzTffnIsuuqjGZRtssMFafy+kJjLXrJB5AaC1KS12AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgEK68sor8+qrr1abd9ZZZ2XKlCk58cQTM3DgwCIlW1N5eXm+8Y1vZPLkyRkyZMjq+VOmTMn3v//9Wo3RtWvX1f+9fPnylJWV5aijjsoNN9yQN998M/Pnz8/LL7+cp59+Ok8//XRefvnlLFq0KC+//HKuuuqq7LnnngX/XknSoUOHdOzYsdq8BQsWNHjc+fPnV5vu0aPHWtueddZZmTVr1urpvn37ZuLEiTnzzDPTt2/ftfbbYIMNcvrpp+eJJ55Iv379Vs+fNWtWzj777AakX7/Pfe5zufzyy6vNe+KJJ3Lfffc1al0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAhjjrrLPSrVu3Gpd94xvfyCuvvNKo9X//+99nwoQJNS474YQTGrU2AABAU+nUqVON85ctW9bESQAAAACA1q579+459thja1z26quv5sc//nFB651//vl5/fXXa1x2wgknpGPHjusdQ+Z1K0ReAGiNyoodAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoJAWLlyYww47LOPGjUvPnj1Xz992223z85//PD//+c8zZ86cvPXWW6uXbbzxxtloo40yc+bMgmbZZZdd8sMf/rDavJKSknTu3DkbbrhhBg0alHbt2lVb/sorr+TAAw/M/Pnza1WjvLx89X+XlpbmzTffTL9+/dbZp6SkJAMHDszAgQPzjW98IxMmTMi3v/3tPPXUU7X8ZuvXvXv3NeYtWLCgweN+eL20b98+nTp1ypIlS9Zo+9577+Wggw7KmDFj0qtXryRJ586dc8EFF+Tcc8/Nc889l6lTp2bu3LmprKxMjx49ss0222TIkCFr/Fzef//9HHTQQXnvvfca/B1q0qVLl1x00UU58cQTU1JSsnr+woULc+yxx6aysrJR6gIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0VOfOnfOVr3ylxmVjxozJX/7ylybJcdZZZ2Xs2LGrpysqKvLQQw/lhhtuSGlpaSoqKpokBwAAAAAAAABAS3fkkUemvLy8xmWnnHJKli1bVtB6S5cuzemnn54bbrhhjWX9+vXLgQcemFtvvXWdY8i8boXICwCtUWmxAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABTa008/nREjRmTSpEk1Lu/du3eGDRu2evqLX/xi3n777cydOzfjxo3Lj3/84+yxxx4NztGvX78cfPDB1T4HHXRQ9ttvvwwZMiTt2rWr1v7yyy/P9ttvnzfeeKPWNbp27br6v9u1a5d+/frVOefIkSMzYcKEHHfccXXuuzalpWv+ubyVK1c2eNyaxqip1ipPPvlkdtppp9x9993V5rdr1y5Dhw7NZz/72Xzta1/Lsccem8MPPzzDhg1b4+dy9913Z8cdd8yTTz7Z4Pw1Zf/qV7+aqVOn5qSTTkpJScnqZYsWLcphhx221u0YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoDk48sgj06NHjxqXnXbaaU2W4/77789LL72U8ePH58QTT0z//v2z77775je/+U0qKiqaLAfNR7du3dKrV6+0b9++2FHWq2PHjundu3c6depU7CiwBttn4+ncuXN69+6dnj17pqSkpNhxmqWWdCwvtA4dOqR3797p0qVLsaPUqCVtv+3bt0+vXr3So0ePZp+1NWtJ2wy0ZO3atUvPnj1b1PmzuZ/zVmnu1yXNPV/yf/cWnTt3LnaUVqOl7D9NbdW2Vl5eXuwo62SfaHxt8V6gJTzHacvbfku9L2pp55uWlreptJTzY1uy6pjQmMfssrKy9OrVq1kec1vqMbGptIR7PNqGo446qsb5L774Ym6++eZGqXnjjTfm5ZdfrlOe2rSR+f80NC8AtEZlxQ4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQGKZOnZrhw4fny1/+co477rjsscce6+3TvXv37LPPPtlnn31y2mmnZdq0afnhD3+YP/3pT02QOPnMZz6TRx55JDfccEOt+9T0R9zffvvt3H///Zk4cWLeeuutzJ07NyUlJenRo0e23HLL7LHHHjnggAOq/bHx9u3b58orr0xFRUV++9vfFuT7NBdbbbVVBgwYUO/+AwYMyNZbb53XX3+9gKmSI444Iueff3623XbbNZa99tprOfzww/Pkk08WtCYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAoR1zzDE1zh83blz+/e9/N2mWHXbYIYsXL65X3379+qVPnz5rzJ81a1Zmz57d0GirlZSUZLvttltjfkVFRV544YU6jTV48OA15q0vb8eOHTNs2LBstdVW6dGjR7p165aSkpLVy3/xi19kyZIlzbLuusbef//9s//++2eHHXbIdtttl169elUbf9myZXn99dczefLkPProo7ntttvy8ssv16teTeqyTnr37p0jjjgi++23X3bcccdsttlm6dChw+rlixYtyrvvvpvnn38+Y8aMyX333ZfJkyfXK1efPn3Sr1+/tS7/yEc+UuP8Hj161Pid1mXZsmUFXae1UYxtsaUdK+q6jppy+2wqzeGY1b59++y777454IADMmzYsAwZMiR9+/ZNu3btVreprKzMBx98kDlz5uSZZ57Jgw8+mAcffDDPPPNMrev8p/ru/8Xa95vDsbyYunXrloMOOigHHnhghg8fnm222SYdO3ZcvXzlypWZOXNmJk2alIkTJ+bWW2/N008/3STZirH9NsTw4cNz8MEHZ5dddsnQoUPTv3//auuysrIy8+bNy3PPPZcnn3wyd999d+67776sXLmyybPWVceOHTNw4MC1Lp8/f37efPPNJkxUs6beZlrb9U7v3r2z0UYbrXX5hhtuuNb5df0+SfLcc8/VOL+lXfO0Vbvttls++tGPZrfddsvw4cPTp0+flJeXV2uzbNmyTJ8+PZMnT86///3v3HXXXZk4cWLBMtT1WqtXr1459NBD8/GPfzw77LBDttxyy2ZzzluluV+XNPd8q/Tv3z+HHnpoRo8enR122CGbb755tXuLFStW5LXXXsukSZNy33335bbbbsusWbOaNGOxtcT9pzncX33Y9ttvn09/+tPZbbfdMmzYsPTv3z/t27dfvbyysjLvv/9+pkyZsnp7u++++xpUsz6a2z5R07m+pZ/ni3kvsLbrsLVda9VlnJb+HGeTTTbJ4Ycfnj333DM77rhjPvKRj1TLuHLlysyYMSNTpkzJo48+mjvuuGOt9wVlZWXp3bv3GvPnzJmTFStWNNp3qI/mdC/dGs43zT1vTZnXlztp3HNkMc6PPXv2zCabbFLjsjlz5mTmzJn1HvvDunfvngEDBtS4bMaMGfnggw/W2b9Yx+399tsvn/vc57L77rtn2223XeNa4I033sjTTz+df/7zn/nb3/6Wd955p055kmTHHXfMF77wheyxxx4ZOnRounXrtnrZqvPCpEmTcs899+Tuu+/O66+/XucadeVZ0bq1lHu8mmyyySbp2bPnGvMXLlzYaNtWWVlZttlmmzXme5bUOLp06ZK99967xmV/+ctfGrX2X/7yl5x55plrzN9///1TUlKSysrKGvvJXHv1zQsArVVJZS3Pfv95sQ4AAAAAAAAAAAAAAAAAAAAAAAAAAAAA0JI05I+S+LfagbUZNmxYhg0blqTqODNt2rRMmDDBH0ICAIBmrH///hk5cmRGjBiRYcOGZYcddshGG21Uq75jxozJ4Ycfnnnz5tWp5ogRI/LjH/94jfmdOnVKnz59suWWW6a0tHSN5VdccUW+/e1v1+oe4+CDD855552XHXfcMQ8++GAuvPDCjB07dr19e/fundNOOy0nn3xytT++vWzZsuy6666ZNGlSLb7h2vXr1y+zZs2qNq9r165ZtGhRg8bt0qVLFi5cWOtxzz333Jx99tk1PueZPXt23nrrrdU/1+7du6d///7p06fPGm0rKytz/vnn54c//GGD8ifJgQcemAsvvDDDhw9fY1lFRUV+97vf5eSTT86CBQsaXAugqZ1x5hnp1atXsWPQRtxy8y0ZP358sWMANIqePXvmzLPOLHYM2pif/uSnmTlzZrFjADSKLXdNDj+/2CloSy49oNgJAFq3kpKS7LLLLtlmm21WvwecNGlSg99xAgDQ9px3/nnp3LmzZ+QATWzV75ld/qvL89prrxU7DkCbcfy3j88WW2yR3//+93nh+ReKHQegTfja176W7QZv53ffAZrYoYcdmj322CN3//3ujBs3rthxANqMTx74yey333755z//mXvuvqfYcQAAqIF/qx1oDP6tdgAAAAAorFW/gwFNye9cAm2Jcy3F4v9jBrQlHz8h2fHgYqegrbnvl8nTfy92CoCm5d9qb178Ti1U17Vr17z//vtp3779GsuOPvroXHfddUVIVT8XX3xxTj/99DXmn3baabn00ksLVqdLly5ZuHDhGvMXLFiQbt261Wmsmo49NeUtLS3NEUccka9//evZe++9U1ZWttYxN9hgg8yZM6dZ1v2wTTfdND/4wQ/y5S9/OeXl5XXqmyQTJ07MRRddlNtuu63OfT+sNutkk002yXnnnZejjz66xn1mXR5++OGcc845eeCBB+rU75xzzsm5555bpz719fDDD2f06NFNUmuVYmyLLe1YUdt1VIzts6kU85i10UYb5fvf/36+/vWvp3v37nUPn6pj1cUXX5zbbrutTtecTbX/N3Tfb07H8kJa28/qw/8f3l69euX000/P8ccfX+fv/8ILL+Siiy7Kn//851RUVNQ769oUc/utqy5duuTrX/96TjrppGyxxRZ17v/uu+/msssuy//+7/9m8eLF9c5R2597ffTo0SN///vfM2rUqBqXv/HGG/nEJz6RF198scG16qtY20xru9753ve+l5/+9KeNWmOVGTNmpH///jUua2nXPEnh9sHG3JcLoX379vnmN7+Zb37zmxk8eHC9xnjrrbfyi1/8IldddVXmzZvXoDy1vdYaMGBAzj777BxzzDF1vt5s7HPeKs39uqS551tlr732ytlnn52PfexjddpvVqxYkT/96U8599xz1/i7JuPHj8/IkSPX6DNixIg8/vjjDY1cNC1x/2kuz4Tat2+fr3zlK/n+97+fbbfdtk59k2ThwoX505/+lEsuuSSvvvpqnfvXRXPdJ2o61zfn8/y6arSme4HW9Bxnt912y/nnn5+Pf/zjdV4PTzzxRM4///zccccd1eaPHj06Dz744Brtm9P5oDneS7eG801zz5s0j3Nksc+PvXv3zuTJk7Pxxhuvseydd97J4MGDM3v27DqPW5Nx48Zln332WWP+22+/ne23375e77mSxjtu77///rnssssyaNCgWo+9cuXKXHvttTn77LMzffr09bYfOXJkLrvssowYMaLWNSoqKnL99dfnrLPOyuuvv17rfrXlWdG6Nbd7vPrsF8cee2x+97vfrTH/gw8+yEYbbZSlS5cWJNt/Ovzww/O3v/1tjfn33HNPDjzwwILXK7TDDjssN9988xrzJ0+enKFDhxYh0bp97GMfy5gxY2pcNmTIkDz33HONVnv77bfPs88+W+OyHXfcMU8//XSNy2SuvfrmhWIrKSnJrrvumq233trv0wK1Vpv7idImyAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFB006dPz80335xTTz01BxxwQA466KDVy8aNG5ef/OQnue+++zJ37tw1+n784x/P/fffnw4dOtSp5mOPPZZ99913jc/uu++erbfeOr169cqXvvSlNf7g6re+9a1ccskltapx1113ZaeddsrgwYOzzz77ZMyYMbX6Y3Zz5szJaaedlgMOOCBLlixZPb9Dhw756U9/WqfvWVt1/aPqDR3j5JNPzjnnnFOtz6xZs3LGGWdk4MCB6dOnT4YPH57Ro0dn9OjRGT58ePr27Zstttgip59+embOnFmt7jnnnJOTTz653tlHjx6dRx55JH//+98zfPjwNZaPHTs2O+20U4477rgsWLCg3nUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmspee+2V9u3brzF/xYoVuf3224uQiA8bNGhQJkyYkBtvvDEf/ehHU1ZW1uLrtm/fPhdeeGFeeeWVfOtb30p5eXm9xtl1111z66235uGHH86WW25ZsHxrM3Xq1Bx77LE17jPrs9dee2XcuHG56aab0rVr10ZI13BTpkwpdoQaFWsfaEm+8IUvtPrtc30KvZ2UlJTk+9//fl599dWcfPLJ6d69e73H2nXXXXPLLbfkkUceycYbb9ygXI2hvvt+Sz2WF9KnPvWpPP/88zn11FPr9f0HDRqUa6+9Nk8//XSGDRtWsFwtbfv9/Oc/n9deey2XXXZZtthii3qN0bdv31x44YV56aWXst9++xU4YcNtvPHGefjhhzNq1Kgal0+ePDm77757XnzxxSZOVqWlbTMN0Vyvd+qrWNsM9Tdq1Kg8/fTT+cUvfpHBgwfXe5wBAwbk0ksvzWuvvZavfOUrBUxYs69+9at5/vnn841vfKNe15uNdc5bpblflzT3fKv07ds3t9xySx566KF8/OMfT0lJSZ36l5WV5atf/WomT56c448/vuD5Wqrmvv+srWZj3od/4hOfyEsvvZTf/va32Xbbbes1RteuXXPcccflpZdeys9+9rN06tSpoBkT+0RTaAv3AjVp7s9xunXrlj/96U957LHH8olPfKLO236S7LLLLrn99ttz8803p3fv3gXP2Bha+n1RSzvftLS8/1m3sc6RzeH8OGfOnBx99NGprKxcY1m/fv3ym9/8pl65PuzEE0/MPvvss8b8ysrKHH300ZkzZ05B6hRCu3bt8stf/jL33ntvBg0aVOe+xxxzTKZMmZKDDjpore1KS0vzk5/8JI8++mhGjBhRpxqlpaX50pe+lKlTp+arX/1qnfquS0s/JtZFfZ4VtZR7vNq48cYbs2DBgjXm9+zZM4ccckij1PzSl75U4/w//OEPjVKvrdt9991rnP/666/nueeea9TakydPzptvvlnjsrXlWtcymddU37wA0FqVFjsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAsT355JM55ZRTsv/++6dPnz751Kc+lYkTJ1Zrs8suu+Siiy4qaN158+blz3/+c3baaadcfvnl1Zadcsop2WuvvWo91vPPP1+vDGPHjs23vvWtavM+9rGP1fuPx6+ydOnSNeZ16NChQWMmqfGP0ddUa/Dgwfnxj39cbd4///nPDBkyJBdffHGmTZu21hqvvfZaLrnkkgwZMiRjx46ttuzHP/5xBg8eXKfMm266aW655ZY8+OCD2WOPPdZY/q9//St77713Pv7xj+eZZ56p09gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABA0+jeLxn6iWSPLyR7fy3Z9bBk852Tdu2Lnay49ttvvxrnT5w4MfPmzWviNHzYiBEjMn78+Oy6666tpu6AAQPy+OOP54wzzkj79oXZAffcc89MmjQpBx10UEHGq8kFF1yQrl27Nnicz372s5kwYUI233zzhocqsClTphQ7whqKtQ+0JBdccEH+/Oc/t/rtc10KvZ107949//znP/M///M/6dSpU0HGTJLdd989Tz31VEaMGFGwMQuhPvt+Sz2WF9Ipp5yS22+/PRtuuGGDxxo6dGgmTpyYr371qw0eqyVtv507d85NN92U66+/Pn379i3ImP3798+YMWNy6qmnFmS8Qth6660zfvz4DB06tMblDz/8cPbcc8/MmDGjiZNVaUnbTCE0x+udhnjxxReLHYE6+MpXvpIHH3wwgwcPLtiYvXr1yh//+Mfccsst6dixY8HG/U+XXXZZrr766pSXlzd4rEKe81ZpzOuSQmgp10277bZbJk+enEMPPbTBY3Xt2jWXX355fvOb36S0tLQA6Vqu5r7/1KQx78NLS0tz+eWX5x//+Ec222yzgozZrl27/Pd//3cmTZqUQYMGFWTMxD7R2NrKvUBNmvtznMGDB+eZZ57JF7/4xYKMd9hhh+WRRx7JxhtvXJDxGktLvy9qaeeblpZ3lcY6Rza38+PYsWNz2WWX1bjssMMOa/DxYZtttsmPf/zjGpf97//+b8aOHdug8QuptLQ0N998c0444YQGjdOjR4/ceeedOeqoo9ZY1qFDh/z973/PySefnJKSknrX6NChQ66++uqcffbZDYmapOUfE+uqrs+KWso9Xm0tXLgwN9xwQ43LGuPY2rNnz3zyk59cY/6cOXNyxx13FLweyZAhQ2qc/8wzzzRJ/bU9X1lbrnUtk7lm9ckLAK2Vp68AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/YcWKFbnrrrsycuTIXHnlldWWffvb306/fv0apeYJJ5yQm266qdr8Cy+8sOC1avLHP/4xzz77bLV5hxxySIPGnDdvXiorK6vN69atW4PGrGmMhQsXZuXKlWu0O++881JWVrZ6+tlnn82nPvWpzJ49u9a15syZk0MOOaTaH8QtKyvLj370o1qP8clPfjLPPPNMDj300DWWTZw4MZ/4xCey11575aGHHqr1mAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDT6T84+fxPkm9em3zye8meRycjjkz2/UZy5IXJd/6ajD4m6dCl2EmLY+jQoTXOf+SRR5o4CR+25ZZb5t57703Pnj1bTd2tt946jz76aIYPH16r9itWrMjixYtr1bZr16657bbb8rnPfa4BCWt25pln5swzzyzYeNtvv33uu+++dOvWrWBjFsKUKVOKHaGaYu0DLUmht82k+W6fa1Po7aRXr1554IEHss8++9SqfUVFRRYuXJgVK1bUqv1GG22Uu+66K5tuumkDUhZWXff9lnosL6QTTzwxl156aUpKSgo2ZocOHfKHP/whJ554Yr3HaEnbb+/evfPAAw/ks5/9bIPH+rDS0tJccsklBT8+1sfOO++cRx55JJtttlmNy2+//fZ8/OMfz9y5c5s4WZWWtM0USnO73mmoF198sdgRqKVjjjkmV199ddq1a1er9osXL86iRYtSWVlZq/aHHnpo/vGPf6Rjx44NibmGyy67LCeddFJBxyzEOW+Vxr4uaeg1SUu5btp7771z//33p1+/fg0e6z99/etfz1VXXVXQMVuS5r7/1KQx78M7deqU22+/Pccff3zBx07+b38bNWpUg8eyTzSutnIvUJPm/hxnhx12yIMPPpgtttiiAMn+z6BBg3L//fena9euBR23UFr6fVFLO9+0tLyrNNY5srmeH08//fRMmjSpxmW/+tWv0r9//3rlKS0tzbXXXpvOnTuvsWzSpEn5wQ9+UK9xG8sVV1yRT3/60wUZq6SkJNdcc01GjBhRbf6NN96YAw44oCA1kuS8887Ll770pXr3b+nHxPqoy7OilnKPV1e/+c1vapy///77Z6ONNiporSOOOCIdOnRYY/7111+fZcuWFbQWVbbbbrsa50+ePLlJ6j/77LM1zh80aNBa+8hcN/XJCwCtVVmxAwAAAAAAAMD/Y+++w6Oo3r+Pf9JDQkIvUqT33kGaFOldkCJNFARUUFSaFBugiICiIL1KRxEQkC69iRSR3pQSeklCCSR5/vg+8DPsbJLNzrbwfl0Xl+59Zu5zJ5k558xsAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANxRTEyM3nrrLZUrV05lypSR9L8vWm/RooV++OEHh/T57rvvqkWLFvL29pYkVa1aVdmyZdP58+cd0t9/LVq0SMWKFXvyuHTp0nbli42NVUREhEJCQp7EUqVKZVdOoxy3bt2y2CY0NFRNmjSJE3v33Xd19+5dm/u7d++e3n33XW3YsOFJrGnTpgoJCVF4eHi8+7Zq1Urz5s2Tj49PnPiBAwc0ePBgLV++3OZ6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADhP5Q7SC+0kLy/r2/inkCq2lgq9KC0ZKl0766zq3EO+fPkM4wcPHnRyJfgvHx8f/fTTT0qdOnWy6Tdt2rRas2aNsmfPbnWbgwcPasGCBVqzZo1OnTqlmzdvSpL8/f2VPn16lS1bVnXq1NGrr75qWKOvr69mzpyps2fPateuXabUXbt2bX366adxYrGxsdq8ebOWLl2qvXv36sKFC7p7965CQ0OVIUMGlSpVSg0aNFDdunXl4+NjmDdfvnyaOXOmWrRoEW//58+f186dO622p0uXzvA8vnHjho4fP56In/D//PXXXzZt70iuOgc8idGxKTn3+HQ1RxwnP/74o0qVKmW1fcuWLVq8eLG2bdum48ePKzw8/ElbSEiIcuXKpRdffFEdO3ZUmTJlDHOkT59eS5YsUeXKlfXw4UOrfSX1/I9vHyO2nPueOpabqVq1ahozZoxFPCoqSr/99ptWrVql/fv3KywsTHfv3lVwcLAyZcqkfPnyqV69eqpfv77VY9bLy0tjx47V6dOntWLFCptrc6fjNz7+/v5avny5ypcvb3Wb6Ohobdu2TStXrtTevXt1+fJlXb9+XV5eXkqVKpXy5cunatWqqW3btsqSJYthjs8//1wnT57UggULklSnvWrVqqWlS5cqZcqUhu2TJ09W9+7dFRMT4+TK/o+7HDPJbb1z6dKleH+ebNmyKVu2bBbx8+fP6/z58zb1tXfvXpvrg/Plzp1b3333nbys3Jy4ePGi5s6dq99++01//fWXrly5EmdsSJs2rfLnz68qVaro5ZdfVsWKFQ3zVK9eXd9++63efPNNU+ru2LGjevfubRF3hzlPcs66xJ41iaesm/LkyRPvfCVJDx480IYNG7Ry5UodPHhQly9f1q1btxQQEKB06dKpWLFiql27tpo2barQ0NA4+77xxhs6cOBAkmrzZO5+/hhx9HX47Nmz1ahRI6vtMTEx2rFjh5YvX649e/YoLCxMN27cUFBQkDJlyqS8efOqQYMGqlevntUa06RJo19//VWVKlXSkSNHklQn54RjPSvXAkbc/T5O5syZtXr1aqVPn97qNvfv39eGDRu0fPlyHTlyRJcvX9bNmzefjGE5cuRQ/fr11bBhQ6VLly7OvoUKFdKECRM0ZcqUJNfoKO5yXZQUnjbfeFq9jzlyjnTX+TEqKkpt27bVH3/8ocDAwDhtqVOn1owZM/TSSy8l+ud8rG/fvqpQoYJF/P79+2rbtq2ioqJszukoLVq0ULdu3Szip0+f1syZM/X777/r3Llzun//vtKmTavnnntONWvWVMuWLZU/f37DnP7+/po6dapKliypR48e6f3331fz5s0ttrt165bmz5+vlStX6ujRowoPD1fKlCmVKVMmlS1bVs2bN1f16tWt1j5+/Hht27ZNZ86csfnndpcx0R3vFXnKNV5S7N27VwcOHFCJEiXixH18fPTqq6/q66+/Nq2v9u3bG8anTZtmWh+IK2vWrIbxQ4cOOaV/a687sVZXfG3UbCwp9QIAkFz5uroAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHBXMTExGjt2rGbPnv0kVr16df3www8O6e/ChQvavXu3Klas+CRWoUIFnT9/3iH9/dfff/8d53HmzJntznnt2jWFhIQ8eZwvXz67v8D26S/rvn79usU25cqVk5+f35PHYWFh2rBhQ5L73Lhxo8LCwp78Tvz9/VWuXLl4c5YpU0Y//vijfHx8nsRu376t9957T9OnT09yLQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACco/ZbUunGid8+VSap/WhpTh/p2lmHleVWfH19lTNnTsO248ePO7cYxPH222+rRIkSFvGbN2/ql19+0YoVK3To0CFdvnxZt2/f9oh+FyxYYPV4+/fff9WnTx8tXrzYsD0qKkoXL17UsmXLtGzZMg0cOFD9+vVT//795e3tHWfbgIAALV68WAULFlRkZKRNNT4tMDBQU6ZMidPHr7/+qn79+unw4cMW21++fFknTpzQ9u3b9f3336tw4cL69ttvVatWLcP8zZs3V6tWrbRo0SKrNUybNk3Tpk2z2t6iRQstWbLEIr5hwwa1atUqvh/PrbnqHPAURsem5Pzj09XMPk7eeecd1a9f37Bt37596tGjh3bv3m11//DwcB08eFAHDx7Ut99+qxYtWmj69OkKDQ212LZcuXLq3LmzJk+ebDVfUs//SpUqWd3HXp44lpvt6XMvNjZWEyZM0LBhw3Tx4kXDfU6fPq0dO3Zo1qxZCg4O1nvvvacPP/zQ8Njw8vLSjz/+qCJFiuj8+fOJrsvdjt/4TJgwQS+88ILV9sWLF+ujjz6yuh69ePGijhw5omXLlql///56++23NXz4cKVIkcJi24kTJ2rbtm02/S7N0KpVK82ZM0f+/v6G7Z999pmGDBni1Jqe5k7HTHJb78ybN0/z5s2z2j5kyBB98sknFvHJkyfr008/dWRpcJGxY8cqKCjIIh4TE6MhQ4Zo1KhRevDggdX9b9y4oZ07d2rnzp0aNWqUXnjhBU2YMEHFixe32LZbt25avHix1q5da1fNmTNn1sCBA+PE3GXOe8wZ6xJ71iSesG7y9fXVTz/9pNSpUxu2R0dHa9q0afrkk0904cIFw23++ecf/fnnn5o1a5ZCQkLUq1cvDRo0SIGBgU+2+fLLL3Xjxg2bavNknnD+GHHkdfjgwYPVsmVLq+2rV69W3759dejQIcP2x7+b2bNnKzg4WH369FHfvn2VMmVKi21TpUqlX3/9VSVLltSdO3dsqpNzwvGehWsBI+5+H8fLy0uLFi1S5syZDdtjYmI0depUffTRR7p69arhNo/P0/nz58vf31/vvfeeBg0aFOc87dChg44dO2ZzfY7kTtdFtvK0+cbT6v0vR82R7j4//v333/rwww81btw4i7batWurR48emjBhQqJySVKxYsUMr4Ul6YMPPtDff/+d6FyOFhQUZPFzh4eH6/3339fUqVMVExMTpy0sLEx///231q9fr8GDB+utt97SV199pYCAAIvcRYoUUZcuXbR+/XoNHz48TltsbKzGjh2rjz/+2PDvdPLkSW3btk3ffPONXnrpJU2ePFk5cuSw2C4kJESjRo3Syy+/bNPP7U5jojveK/KEazx7TJ48Wd99951FvHPnzvr6669N6SNbtmyqWrWqRfzAgQP6888/TekDcfn6+ipt2rSGbZcuXXJKDWFhYYZxa2tParadrfUCAJCceSe8CQAAAAAAAIBnmbe3t9KlS6d8+fKpQoUKqlatmuG/IkWKuLpUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAh9i+fXucx9myZXNof6dOnYrz2Flfunr9+vU4j42+AN5W+/fvj/O4ePHidud8OsfTfUhS1qxZ4zw+evSo3f0eP348zuMsWbJY3dbb21tz5syRn5/fk1hYWJjKly+v6dOn210LAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMcqXk8q3dj2/fyDpJc/+d9/nwVZsmSRj4+PYduFCxecXA0eCwoK0qBBg+LEHjx4oC+//FK5cuXSa6+9piVLluj48eO6ffu2R/Tbvn171a5d27Bt27ZtKlOmjBYvXpzofHfu3NFHH32khg0bKjw83KI9W7Zs+uSTT2yq0cgbb7yhHDlyPHn85ptvqlGjRjp8+HCi9v/7779Vp04dTZ8+3eo2ffv2tbvO5MZV54AnefrYfPTo0TN3fJp9nISGhmro0KGGbXPmzFH58uW1e/dum2r86aefVLlyZav9f/jhh/Ly8rIppyt56lhutnz58j35/9u3b6tWrVp66623dPHixUTtHxkZqc8//1ylS5fWkSNHDLcJDQ3VmDFjEl2TJx2/tWvXVpcuXQzb7t27p1atWqlVq1Y6fvx4ovI9evRIY8eO1QsvvKCrV69atKdKlcrpx1GPHj00f/58+fv7W7TFxMTorbfe0pAhQ5xa09M86ZgBPF2GDBlUv359w7a2bdtq2LBhevDggU05t2/frnLlyumnn34ybP/0009trvNpPXr0UKpUqZ48dpc57zFnrkuSsibxlHVT7969Vbx4ccO2mzdvqk6dOurWrVui7xGFh4dr2LBhKlWqlM6cOfMkHhQUpGzZstlcn6dy9/PHiCOvw4sWLarBgwcbtj2+lq1fv74OHTqUqHyRkZH67LPPVKJECau/m1y5cmnkyJE21SlxTjjas3AtYI2738d54403VKVKFcO2iIgI1a5dW926dTP8PRuJiorSl19+qeLFi+v06dNx2vr375+kGh3B06+LPG2+8bR6H3PUHOkp8+N3332n1atXG7aNGjVKefPmTVQePz8/zZ492/BeyapVq/T999/bVJejvf7668qSJcuTx2fPnlXp0qU1efJkxcTExLtvTEyMxo0bp1atWunRo0eG27z33nv67LPP4vw+7t27p4YNG6pPnz66c+dOgjWuXbtW1atXt7ouadq0qU3rDU8fEx3NU67x7DFnzhzdu3fPIl60aFGVKlXKlD7atWtn+DefNm2aKflhKU2aNFbPM6NjzxGsjWmpU6c2rI2abWdrvQAAJGferi4AAAAAcIZy5crpxIkThv+2bNni6vLgBGPHjjX8+0+YMMHVpUH8fWAOM48jjknH4vfrGcqUKaNPP/1UmzZtUmRkpK5du6bjx49r586d+v333w3/ffHFF64uGwA8BvNh8rVlyxbDv621NwUASF7ceQxg7oG9OIYAzgMAAABXYA0GPJs49wEAAAAAAAAAAAAAAAAAAAAAAAAAAOCurl27Fudx2rRpHdpfREREnMcBAQEO7e8xPz+/OI+joqLszrlnz544j6tXr253zqdzPN2HJAUGBsZ5HBkZaXe/T3/xblBQkNVtO3TooIIFCz55HBMTo+bNm+v48eN21wEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAsfyDpOpdkr5/qkxSxdbm1ePOUqZMabXtypUrTqwE/9W2bVulT5/+yeNr166pZs2a6t+/v27fvu1x/QYGBmrkyJGGbQcOHFDt2rV19erVJOVevXq1OnbsaNj2zjvvKFOmTEnK+1j27Nmf/H9MTIwmTZpkc46YmBh16dJFmzdvNmwvW7asqlWrluQakyNXnQOe5Oljs3Xr1s/c8Wn2ceLn56d58+bp/v37ceIrV65Uhw4dFB0dnaQ6//rrL7311luGbfny5VP9+vWTlNfZPHksd5S7d++qZs2a2rhxY5L2P3XqlCpUqKB9+/YZtrds2VKVK1dOVC5POX69vb01fvx4w7a7d+/qxRdf1OLFi22uU5L279+v2rVr6+7duxZt5cuXl7+/f5Ly2urjjz/W+PHj5e3tbdH24MEDvfLKK1Z/B87kKccMkBw0btxYvr6+FvEFCxZo4cKFSc4bFRWl1q1ba8eOHXHia9eu1ZAhQ5Kc97HAwMAn/+9Oc97j2py9LrFlTeIp66bUqVNr6NChhm03btxQhQoVtGHDhiTVefToUVWuXFnnz59P0v6ezp3PH2sceR3+ww8/yM/PzyL+8OFDNWjQIEnXspJ0+vRpVahQQTt37jRs79atm8qXL5/ofJwTjvUsXAvEx53v46RMmVLDhw83bAsPD1eNGjWSPIadOXNGVapU0alTp+L05y48/brI0+YbT6v3MUfNkZ4yP0pS586dDdevQUFBmj17tuE9kKcNHTpUJUqUsIhfvXpVnTt3tqkeZ8iWLduT/79+/bpq1KihkydP2pRj+fLl+vrrrw3bChYsqLZt2z55HBMToxYtWmjVqlU29XHu3Dl16tTJsM3Hx0fdu3dPdC5PHxMdyVOu8ex1+/Ztq+ux1157zZQ+2rdvbxF7+PChfvzxR1Pyw1JAQIDVtvDwcKfUEF8/Rmt1aradrfUCAJCcJXyFCgAAACQDKVKkUN68eQ3/5cyZ09XlwQkyZcpk+PfPnDmzq0uD+PvAHGYeRxyTjsXv17298MILWrNmjfbu3avBgwerevXqcV7EBAAwB/Nh8pUzZ07Dv23q1KldXRoAJ3DnMYC5B/biGIKt/Pz85O/vb/HP6I1BnoLzAAAAuFJyXF8lBmsw4NnEuQ8AAAAAAAAAAAAAAAAAAAAAAAAAAAAz1a5dW9WrVzcl19Nfxvr0F1ubLU2aNHEe37p1y6H9PZYlS5Y4jy9fvmx3zqe/QL5atWrKmDFjkvM999xzqlKlSpzYrl27LLaLiIiI8zhVqlRJ7vOxpz9j8M6dO1a3feONN+I8XrBggcXvAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIB7KlZHShFqX47STSQfP3PqcWfBwcGG8ZiYGEVFRTm5GjyWP3/+J/9/69YtVapUSdu3b/fYftu1a6fnnnvOIn7nzh01b95c9+/ftyv/0qVLNWXKFIu4v7+/3nrrLbty/9fQoUPt2r9z5856+PChYVvTpk3typ3cuOoc8FRDhw7VTz/9ZFcOTzw+zT5Orl+/rnfeeUe5cuXS119/rcjISN26dUsdO3a0u9Yff/xRhw4dMmyrVauW3fmdIbmM5Wbq2bOn9u3bZ1eO8PBwvfzyy7p586Zh+7vvvpuoPJ5y/LZo0UL58uUzbOvZs6d2795tc33/dfDgQfXp0+fJ4927d6t58+YqXry4w9e2Xl5emjBhgtX1wp07d1SvXj0tWbLEoXUklqccM0BykCdPHsP4zJkz7c796NEjvfbaa7p3755mz56tEiVKqE6dOlq7dq3duf/LneY8yTXrElvWJJ6yburSpYtCQkIs4rGxsWrfvr1OnDhhV52XLl3Syy+/rOjoaLvyeDp3O3+scdR1eNWqVVW5cmXDtg8//NDu8erx7+bKlSsWbV5eXho4cGCic3FOOFZyvhawlbvdx+nUqZPSp09v2NarVy/t3bvX5vr+69KlS2rfvr1bHvvJ6brIU+abxzypXkfMkZ40P0rS5cuX1aVLF8O2ihUrqm/fvvHuX65cOfXv39+w7bXXXjOs05106tRJZ8+eTdK+n3/+uW7cuJHgdl9++aVWr16dpD7Wr19vdd+6desmOk9yGhPN5inXeGaYNGmSYbxdu3by9fW1K3fRokVVrFgxi/jy5ct1/fp1u3LDusDAQKtt4eHhTqkhvn6M6qNm29laLwAAyZl9q1YAADxMhQoVVL16dYv46tWrdfDgQbepJywsTLNmzYp331atWilXrlyGbWvWrNH+/fvNKNEuuXLlUqtWrQzb1q9frz/++CPe/a39fiRp/PjxioiIsLmm+HImVVRUlO7du6fIyEhdvHhR//zzj/755x+XPunqiN+dGRo1aqTChQtbxOfOnavz58+7oCIkxBHnTHR0tB48eKCIiAhdvXpVFy5c0IkTJxQZGWlqPwAAwHbvv/++Ro4cKW9vb1eXAgAAAAAAPNzu3btVsmRJi/jRo0dVqFAh5xcEJFMpUqRQhQoV9Nxzzyljxozy8fHR1atXdeXKFf3xxx+6du2aq0sEAJiE9RUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALapWrWqhg0bpqpVq+rPP/9UmTJlFBsba1fOfPnyxXl86dIlu/Il5OkvNr58+bJD+3usRo0acR7/888/dufctGmT/v33X2XPnl2S5O3trbfeektDhw5NUr633347zudpHz9+XHv27LHYLiwsLM7jIkWKyMfHR9HR0Unq19fX1+K7V57u47E0adKocuXKcWJGX8oNAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwD3lrWh/Dv8U0vPFpTN/2J/LnaVMmdIw/uDBAydXAmu6dOmikydPenS/b7/9tmH822+/1ZkzZ0zpY8SIEerSpYu8vb3jxDt27KghQ4bYnf/AgQMaMWKEXTnOnDmjpUuXqlWrVhZtVapUsSt3cuaqc8BTmHFsSp5/fJp5nISFhemDDz7QiBEjVLhwYV2/ft2UvBMnTtR3331nEa9ataop+R0tOYzlZtqyZYtmzpxpSq6zZ8+qb9++mjx5skVbs2bNlDlzZoWFhSUql7sfv7179zaML1u2zLTf56RJk1SiRAktWLBAv//+uyk5E+Lv768ff/xRLVu2NGwPCwtTvXr1dODAAafUYwt3P2aA5CBLliyG8VOnTpmS/9ixY8qUKZPCw8NNyfc0d5zzXLUuSeyaxFPWTT169DCMz5gxQ6tWrbK7RknavXu3Jk6cqJ49e5qSz9O44/mTGGZeX33wwQeG8XXr1umbb74xpY+LFy+qa9eu+uWXXyzamjRponz58unEiRMJ5uGccKzkei1gK3e8j/PWW28ZxletWqUZM2YkpTwLO3fu1Lhx4/Tuu++aks9snn5d5GnzjafV+19mzZGeND8+tmLFCv3www/q3r27Rdunn36qlStX6uDBgxZtgYGBmj17tnx8fCzaJkyYoF9//TXRNbjCL7/8YleNERERWrJkibp27Wp1mwsXLuizzz5Lch+SNG3aNNWrV88iXqJECQUEBNj0vK+nj4mO4CnXeGbYunWrjh49qoIFC8aJp0uXTg0bNjQcUxKrffv2hvFp06YlOScS9vQx9V9RUVFOqSG+MchofqBm29laLwAAyZmvqwsAAMCZqlevri+//NIi/uabb6pEiRKKiIhwi3r27t2rWbNmxbtvlixZDPeVpAoVKujll182pUZ79OrVy+qTXU/fUDNi7fcjSXPmzEnS3yu+nGZ69OiRDh8+rN27d2vdunVatWqVw16oZMQRvzt7+fn5adq0acqQIYNFW4YMGfThhx86vSYkzFnnjPS/J/V37NihNWvWaMWKFaY94QIAABLn66+/Vp8+fVxdBgAAAAAAAJKBNGnSqG/fvkna9+eff9bu3btNruj/ZMuWzeobRF1lwIABNu/z0ksv6d1331XNmjUVGBhouE1MTIx2796tGTNmaMqUKYqOjra31ERr2rSpKlY0/mTTUaNG8VwgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIfy9/fXkiVLnnxHRqlSpfTee+9p9OjRduVt165dnMf79++3um3q1KnVrVs3fffdd7p7967NfZUvX16FChV68jg2NlZ79+6Nd5+SJUtq4MCBCgsLU69evWzuU/rfd+K0bNkyTuy3335LUq7/io2N1fTp0+N88fQHH3ygyZMn6/z58zblev755y0+U3vy5MmG2x44cEAxMTFPvkg3TZo0evnll7Vw4UIbf4L/adGihdKkSfPkcXR0tA4dOmS4bcmSJeXl5fXk8cOHD7V169Yk9QsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADA+dLnMCdPuuelM3+Yk8td+fn5Gcajo6OdXAmM/Pzzz/r55589ut/nn39epUqVsojfvXtXY8aMMaUPSTp9+rTWrVunOnXqxInnyJFDhQoV0pEjR+zKP3jwYFPOi+nTp6tVq1YW8dKlSysoKEh37961u4/kxFXngCcx69iUPPf4dNRxcv36dW3ZssW0fBs2bDCMlypVSj4+Pm499yaXsdxMn332man5Zs+ereHDhytDhgxx4r6+vqpXr55mzJhhUz53PH4zZsyoypUrG7Z9+eWXdtX3X7GxserZs6dp+RKSMmVK/fLLL6pZs6Zh+8mTJ1WnTh2dOXPGaTUlhTseM0ByERAQYBiPjY01rY/w8HDTcj3N3eY8V65LErMm8ZR1U/78+ZU3b17Dtq+//tq0OiXp888/V7du3eTr62tqXk/gbudPYph5fRUSEqL69esbto0YMcKUPh5btmyZDh8+rCJFisSJe3l5qWXLlgn2xznhWMn1WiAp3O0+Tv78+VWoUCHDtmHDhtld4399/fXXeuedd+Tj42NqXjN56nWRp803nlbvY2bNkZ40Pz6tT58+evHFF1WwYME4cT8/P82ZM0dlypTRw4cP47SNGDFCBQoUsMh19OhR9enTx6b+XcGM43XJkiXq2rWr1faxY8fq3r17dvWxYsUKRUVFyd/fP07cz89PpUqV0s6dO23O6aljotk85RrPTJMnTzZcA3fu3Fm//PJLkvO2bdvWIhYWFqbVq1cnOScAAADwtGfnrisAAPHInTu3xo0bp9dee83VpSTanDlzNHLkSIubnJLUqFEjpUmTRjdv3nRBZf/j4+Ojdu3aGbZt375dx44dc3JFzuXr66sSJUqoRIkS6tq1q6KiorR69WqNGzdO69atc3V5LtGsWTOLJ6ce69y5sz766CNFRUU5uSq4k1y5cilXrlxq166dHj58qKVLl+qrr77Snj17XF0aAADJXrNmzTziRSkAAAAAAADwDEWLFlX//v2TtO+ZM2e0e/dukyv6P1myZElybY4yYMCARG+bNWtWTZkyRfXq1UtwW29vb1WsWFEVK1ZU79691bVrV23bts2eUhOlZMmSWrBggeGHhowbN07Xr193eA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnm1RUVEaNWqUvvzyyyexkSNH6vTp01q6dGmSclapUkVvvvlmnNhPP/1ksV369On1/vvvq2fPngoNDVWuXLnUo0cPm/oKDQ3VlClT4sR27Nihy5cvW93np59+UvPmzSVJ0dHR+uWXX7R+/Xqb+vXz89PMmTMVHBz8JHbjxg1t3LjR6j4BAQHy8fGJE7t7967hthMmTNC7776r0NBQSVJQUJCWLVum6tWrKzw8PFE1hoaGavny5QoMDHwSu379uqZNm2a4/fXr17Vt2zZVrVr1Sezrr7/W5s2bFRYWlqg+H3vuuec0evToOLGtW7da/VydHDlyxHl85swZvpsFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8CApQs3JE5zGnDxAUo0dO9bj+33ppZcM4+vWrdONGzdM60eSNm3apDp16ljEX3zxRR05ciTJec+dO6fly5fbU9oT27ZtU2xsrLy8vOLEfX19lSNHDrvqTI5cdQ54CjOPTclzj09POU6OHj2qiIgIpUyZMk7c19dXadKk0bVr11xUWcKSw1hupnPnzmnt2rWm5nzw4IGmTp2q/v37W7TVq1dPM2bMMLU/W5lx/NarV89ifJGkP//8U9u3bzetVmfKkCGDVq9erdKlSxu2//HHH6pfv76uXr3q5Mpcz5PHPMBst27dMoznypVLJ06ccG4xNnLHOc/V65KE1iSurk9K3LrJaD9J2rx5sw4fPmxKfY9dunRJK1asULNmzUzN6+7c8fxJDDOvr+rUqSM/Pz+L+F9//aUNGzaY1s9jY8eO1eTJky3ijRs31ogRI+Ldl3PCsZLjtUBSuON9nHr16hnGDxw4oG3btplS52Pnz5/Xr7/+qiZNmpia150547rI0+YbT6v3v8yaIz1pfnzavXv31LZtW+3atUv+/v5x2ooVK6bPPvsszt+hWrVq6t27t0WeqKgotW3bVvfv37epf2c7cOCA/vjjD7vzxJcjJiZGM2fOtLuPe/fu6ejRoypevLhFW65cubRz5067+7CXp94r8pRrPDPNnDlTI0aMsDjPGzZsqPTp0yfpb1W1alU9//zzFvHZs2crOjo6ybUCAAAAT/N2dQEAALiLzp07q2XLlq4uI9GuX79u9Yk0f39/tW7d2skVxVWvXj1lzJjRsG3q1KlOrsb1/P391aRJE61du1YHDx5U3bp1XV2S03Xv3t1qW/r06dWiRQsnVgN35+fnp1atWmn37t1asGCB0qdP7+qSAAAwzdtvv62vvvrK4l/jxo1dUk+aNGkSXKNv3bpVH374oWrWrKnixYsrb968ypMnj8W/rl27OqlqAAAAAADwLHO3+yuwlDdvXleXkCwVKVJEO3futPom1/gUKlRI69ev18svv+yAyv5PypQptWjRIgUEBFi0/fHHH3r//fcd2j8AOANrEQDPEsY8AAAAAAAAAAAAAAAAAAAAAAAAAAAAeLIxY8Zo//79Tx77+PhoyZIlGjJkiMWXECekQ4cOWrVqlXx9fZ/EVqxYoX379llsmytXLvXv31+hoaGS/vd9HcHBwYnuq2DBgtq0aZOKFSsWJ/7JJ5/Eu9/58+ef/L+Pj4+WL1+u9u3bJ7rf5557TqtWrVLt2rXjxIcOHRrvF6svXrxYkZGRcf5ZExYWpg8++CBOrFSpUtq4caOKFCmSYI1FihTRpk2bLL6UvHfv3vF+cfawYcPiPM6WLVui+3ysaNGi2rBhg7JmzRpv7v96fAw8dv369UT3BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMD1Hlr/qnebRN0zJw+QFEePHtXmzZs9vt8qVaoYxn/77TfT+nhs586dhvEiRYrYlXfFihV27f9fd+7c0alTpwzb0qRJY1o/yYGrzgFPYuaxKXnm8elJx0lsbKwuXbpk2JY2bVonV2Ob5DCWm2nNmjUOybthwwbDeLly5RzSny3MOH6rVq1qGHfEceQMOXLk0LZt21S6dGnD9rVr16p69eq6evWqkytzD5485gFms3YutG3b1smV2M4d5zxXr0sSWpO4uj4pceumChUqGMY3btxoV03WrFy50iF53Zk7nj8JMfv6qkaNGobx1atXm9ZHYvJWqFBBAQEB8e7LOeFYye1aIKnc8T5OpUqVDONm1+rovO7KGddFnjbfeFq9j5k5R3rS/Ghk//79GjRokGHbhx9+qBdeeEGSFBwcrBkzZsjLy8tiu48++kj79++3uW9nM2ueunbtmtX7Q/v37zft3tHhw4cN46lTpzYlv7089V6Rp1zjmen69etaunSpRdzPzy/J9zLat29vGJ8+fXqS8gEAAADW+Lq6AAAA3MnEiRO1fft2Xbx40dWlJMqUKVP08ssvG7Z16tRJP/zwg5Mritu/kcjISC1YsMDJ1biXYsWKafXq1VqxYoVef/11XblyxdUlOVzevHmtPuHzWPfu3TV//nwnVQRP8sorr+jFF19U06ZNrT4xAACAJ3n11VdVsWJFi7ivr6+WL1/u9Hq6detm9UUIV69eVdu2bbV+/XonVwUAAAAAAGCdu91fgaX8+fO7uoRk5/nnn9fmzZvtekNRQECAFi5cqIYNGzrsjXlTpkxR3rx5LeJ37tzRK6+8oocPHzqkXwBwJtYiAJ4ljHkAAAAAAAAAAAAAAAAAAAAAAAAAAADwZA8fPlTr1q21detWZciQQZLk7e2tTz75RG+88YYmT56sFStW6MCBAxb7BgQEqGDBgqpRo4a6dOmiYsWKxWm/cuWK3n77bcN+9+zZo8mTJ6tr165PYqdOndKMGTO0evVqHTx4UDdu3IizT/r06VW+fHm1a9dOrVq1kr+/f5z2H3/8McEvu//oo49Uv379J58BkyJFCs2ePVvvvvuupk+fro0bN+rEiRNxPgcmODhY5cuX18svv6xOnTopZcqUcXL+/vvvmjBhQrz92mry5Mlq3ry56tev/yRWpkwZ7du3Tz/99JMWLVqkI0eOKCwsTJKUOXNmFS5cWC1btlSLFi0sfjc///yzfvzxx3j7/O233zR//ny1adPmSaxgwYLat2+fFi9erLlz52rPnj0W3yGTMWNGlStXTu3atVPLli0N/y5r16612q+vb9yvCcyZM6dpv8/hw4fr33//NSUXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGPh16SAYPvz3Llqfw53Fxsbaxj38vJyciV42qZNm5JFvwULFjSM79ixw9R+JOnSpUuG8fz589uVd/PmzXbt/7R///1XefPmtYinTZvW1H48navOAU9i9rEped7x6WnHye3btw3j7vr7fSw5jOVm2rJli0Py7t69W7GxsRbrsJw5c8rf319RUVEO6Tex7D1+CxUqZBjfvn17kmtylWLFium3337Tc889Z9g+b948derUSQ8fPnRyZe7FU8c8wGxbt241jHfs2FErV67UokWLnFxR4rnjnOfqdUlCaxJX1yclbt1UoEABw7gj6pQcdyy5M3c8fxJi9vVV4cKFDePWxkV7nT9/Xv/++6+yZ88eJ+7t7a0CBQro4MGDVvflnHCs5HQtYA93vI9jbd7atm2bXXVZs2vXLofkdWeOvi7ytPnG0+p9zMw50pPmR2tGjRql+vXrq0aNGhY5Z82apeLFi2v06NHKlSuXxb4bN27U119/bXOfrmDmPBUWFqYMGTJYxM0cF8PCwgzjqVOnNq0Pe3nivSJPucYz26RJk/TKK69YxDt37qxx48bZlMvPz08tW7a0iO/atUtHjhxJco0AAACAEV9XFwAAgDtJmzatZs2apdq1a7u6lERZs2aNLly4oKxZs1q0VaxYUfny5dOJEyecXleqVKnUpEkTw7aFCxcqMjLSyRW5p0aNGungwYNq166dNmzY4OpyHKpbt24JvuGqevXqKliwoI4ePeqQGiIjI/XXX389eVyoUCH5+Pg4pC+YL2PGjNq4caPq1aun33//3dXlAACQbPj4+Oidd94xbLt7966qV6/Ok9QAAAAAAACwWb58+VxdQrLi4+OjefPmGb6Z6OLFixo7dqxWr16tCxcuKDo6WpkyZVK1atXUq1cvFStWLM72j9/MVqxYMV2+fNnUOrt166bWrVsbtr3xxhs6ffq0qf0BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEKOHz+uWrVq6ddff43zheXZs2fXp59+qk8//VSPHj3SjRs3nrS98847ev/9961+z8aVK1dUq1YtnTt3zmq/b7/9tp5//nnVrVtXkpQpUyb169dP/fr1kyTdv39fd+/eVXR0tFKlSiV/f3+ruVasWKHOnTsn+LOGh4erXr16Wrt2bZwvSi9TpozKlCkjSYqJiVF4eLgePHigkJAQpUiRwmq+P/74Q40bN1Z0dHSCfduqZcuWWrlypapXr/4k5u/vrzZt2qhNmzaJzrNu3Tq1a9cuUdt26tRJ6dKl00svvRSnz3bt2j3J8fDhwydfKJ4qVSr5+flZzbd69Wq99tpria5Vkp577jl1797dpn2smTx5sv79919TcgEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwdvZPKX0O+/Oc+9P+HO7uwYMHhvH4vjcezrFr165k0W/+/PkN4+fOnTO1H0m6efOmYTxNmjR25T1y5Ihd+z/t9u3bhvHUqVOb2o+nc9U54EnMPjYlzzs+PeE4yZw5s/LkyaPcuXMrbdq0htv4+/s7uSrbJIex3EwnTpxwSN7bt2/r3LlzypkzZ5y4t7e3cufOraNHjzqk3/iYefwWKFDAMP7nn5616K5SpYqWL19udVyMiIjQW2+9pYcPHzq3MDeRHMY8wGxbt27V9evXlS5dujhxb29vLViwQI0aNdLo0aN14MABF1VonTvOea5elyS0JnF1fVLi1k358uUzjB88eNCumqw5deqUYmJi5O3t7ZD87sgdz5+EmH19VahQIcP4vn37TO3nv/744w9lz57dsJb4jm/OCcdKLtcC9nLH+zh58+Y1jDvqb/PXX38pKioq2V8TOPO6yNPmG0+r9zEz50hPmh+tiY2NVYcOHXTo0CGLtWeePHm0evVqVa1a1WK/mzdvqkOHDoqNjbW5T1cw83gNDw83jB8/ftzhfbj63r6n3yvylGs8s61fv16nT59W7ty548RLly6tokWL6q+//kp0rvr16xv+7adNm2Z3nQAAAMDTfF1dAAAA7qZWrVrq06ePRo8e7epSEhQTE6OZM2dq4MCBhu0dOnTQkCFDnFyV1Lp1awUEBBi2TZ061cnVJF7z5s115coVm/bx8vJSQECAgoKClDFjRuXIkUNFixZV+fLllS1btgT3z5Qpk3777Td16NBB8+fPT2rpbs3Pz0+dO3dO1LZvvvmm3nvvPYfU8ccff6hYsWJPHl+9elXp06d3SF/PiurVqyssLMymfR6fM8HBwQoNDVWuXLlUuHBhVahQQeXKlZOXl5fVfQMDA7Vs2TKVKlVKp0+ftrd8AAAgqWzZssqaNath2yeffOKQF/ABAAAAAAAg+bP2JkxYunbtWoLbdO/eXS+88IJFfPPmzWrSpInFm2Zv376t48ePa8aMGZowYYLeeOONOO0ZMmTQqFGj1KFDB/uK/4/ixYvrm2++MWz74YcftGjRItP6AgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABbHDp0SCVLltR3332nNm3aWHwvgq+vrzJmzPjksbXvXJGkJUuWqEePHrp69Wq8fUZFRalhw4b69NNP9cEHH1h8GXVgYKACAwPjzfHgwQN9/PHHGjlypGJiYuLd9rFTp06pfPnyGjNmjNq3b2/R7u3trVSpUsWbIzY2Vt9884369++vBw8eJKpfW929e1cvvfSSRo4cqV69esnb29um/WNiYjR69GgNGDBAjx49StQ+j/8mgwYN0sCBA+Xra/kVfn5+fgl+l8nDhw/1+eefa/jw4YnuGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBnOrxOKtNU8vJKeo5z+6WI66aV5Lbu379vGPf393dyJXjagQMHkkW/adKksYjdu3dPN27cMLUfSYqIiDCMh4SE2JX3woULdu3/tDt37hjGvb29Te3H07nqHPAkZh+bkucdn+5wnAQEBChnzpzKkyePcufOrbx58yp37txP/qVIkcLVJdotOYzlZjp37pzDct+4cUM5c+a0iBv9DczgzOM3bdq0hvGrV6+a1oejNW7cWAsXLlRgYKDVbVKmTKmJEyfqlVdecWJlzvMsjHmA2R4+fKgRI0Zo1KhRFm1eXl7q2LGjOnbsqPPnz2vPnj06fPiwTp48+eTf5cuXXVD1/7jjnOfqdUlCaxJX1yclbt2UKlUqw/j16465Gfbw4UNdvHhR2bJlc0h+d+SO509CzL6+ypAhg2Hckeu/a9euGcbTp08f736cE46VHK4FzOBu93G8vb2VMmVKwzZr55K9YmJidOPGDWXOnNkh+Z3Fna6LPG2+8bR6HzNzjvSk+TE+Fy5cULdu3bRo0SKLtqpVqxru061bN4eMhY5y8eJF03JZW7uHhYWZ1kd4eLhh3NH39t1pTHQET7nGc4QpU6Zo+PDhFvHOnTvrgw8+SHSe9u3bW8Tu3bun+fPn21Uf7Oes5/7i6yc2Nta0XGbytJrNrBcAAE/n6+oCAABwRyNGjNC6det08OBBV5eSoKlTp2rAgAHyMngnUMeOHTVkyBCn19SpUyfD+PHjx7Vt2zYnV5N4u3fvNvVGd+HChdWyZUt169ZNWbNmtbqdr6+vfvzxR/n5+Wn27Nmm9e8uWrRoYfXJnqd16tRJ/fv314MHDxxcVdw3gMXExDi8v+To5MmTpp4zmTNnVocOHdS/f3+rL5oIDQ3VrFmzVKVKFdP6BQDgWVa5cmXD+P379zVp0iQnVwMAAAAAAJKTV155xfDNEc54HgiuV758+XjbM2fO7NA3zcXn0KFDKlGihFP7nDZtmsqUKWPY9tlnn8W7r5eXl/r06WMRv3Tpkpo2barbt29b3ffRo0d68803VaBAAYs3r7Vu3Vr9+vUz5fm+4OBgLVq0yPCDhQ4cOKB3333X7j4AAKyvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwx40bN9SuXTt98cUX6tGjh1q2bJnoLyu/cuWKVqxYoXHjxmn//v2J7jM6OlofffSRpkyZok2bNun5559P1H5Xr17V9OnTNWHCBJ09ezbR/T127do1dejQQV9//bV69eqlpk2bWv0OiP+KiIjQ/PnzNXbsWB0+fNjmfm318OFDvffee5o6dar69++v5s2bKygoKN597t69q59++klffPFFkmp8+PChhg4dqjlz5ujNN99Ux44dE/2dKlevXtXMmTP1ww8/6NSpUzb3DQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDzXD4pHdsiFayWtP1jY6Tfp5lbk7uKjIy02pY6dWrdunXLecUgjuvXr3t8v0FBQfLy8rKIp0iRQvfu3TOtn8eM+pKkgIAAu/KGh4fbtf/TYmJiTM2XXLnqHPAkZh+bkucdn848TrJkyaIyZcqoePHiyps3r3Lnzq08efIoS5YsVsef5CC5jOVmunPnjsNyW1t7pUyZ0q68rj5+g4KC5O3tbRF/8OCBHjx44PD+zfDaa69p8uTJ8vHxSXDbVq1aqUuXLpo2zXMvKlx9zADJzbhx49S8eXNVrlzZ6jbZsmVTtmzZ1Lx58zjxyMhInTp1SidPntTJkyd14sQJHThwQAcPHnT4GOpuc547rEviW5O4Q31Swusma3U+ePBAUVFRptRmxBHXL+7M3c6fxDDz+ipFihSG66YHDx7o/v37pvXztJs3bxrGQ0JCrO7DOeFYyeFawCzudh/H2nkRERGhR48eJTlvQm7duqXMmTM7LL+ZPOG6yNPmG0+r9zGz5khPmh8TY/HixZoxY4Y6d+6c4LbTp0/X4sWL7erP2eJ7DtVW1sZrZ/RhFk8YE83mKdd4jjJ9+nR9+umn8vX1jRN/9dVX1bdv30QdcyEhIWrcuLFF/Oeff3bonID/E9+a28/Pzyk1+Pv7W20zqo+abWdrvQAAJGe+CW8CAMCzx9/fX3PnzlXRokVdXUqCTp8+rc2bN6t69eoWbTly5FDVqlW1ZcsWp9WTJ08evfDCC4ZtU6dOdVod7uDvv//Wp59+qmHDhqlDhw4aMWKE1Sf9vL29NXXqVP3zzz/6/fffnVypY3Xv3j3R26ZJk0atWrXSnDlzHFjR/25AhYaGPnkcERHh0P6QOGFhYfrqq680ceJEzZ49W02aNDHcrnLlymrSpImWLVvm5AoBAEh+KlasaBjfvXs3b5QHAAAAAAB2OXHihKtLgAsl9EZjR74pLCH37t3TwYMHndZf1apVVaZMGcO206dPa8KECfHuX79+feXOndsi/vnnnyfqHl5MTIz69u2rHTt2xIn7+fmpW7du+vjjjxPMkZCJEycqf/78FvGIiAi1atWKF+gDgElYXwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYL+DBw+qR48e6tmzpwoWLKgyZcooW7ZsKlasmNq1aydJ2rVrl+bPn6/z58/rr7/+0tGjR+3q88yZM8qRI4dy5sypEiVKKE+ePEqfPr2Cg4Pl5+en8PBw3bx5U+fPn9fu3bt1/PhxM35U7d+/X126dJG3t7dKliypwoULK3fu3AoNDVVwcLDu3r2rGzdu6MqVK9qzZ48OHjyYpC/8fvxFzB9//LGGDh1q8/5//fWX2rdvr8DAQFWsWFFFixZV9uzZFRwcLOl/X2j+77//6q+//tLOnTtN+QyjEydO6IMPPtAHH3ygvHnzqly5csqePbtSp06tVKlSSZJu376tW7du6d9//9WePXt08uRJm/sZPXq0Ro8ebXe9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFznt2+ljHmktFlt3/f3aVKYOV9h7/YuXbpktS1Tpky6deuW84pBHLdv3/b4foODg622BQYGmtaPoz18+NDVJTyTXHUOeBKOTccfJ0WKFFHHjh3VunVr5ciRw6F9uavkMpab6e7duw7Lbe2YTpkypc253On4tXYc3blzx8mVJN20adNs2n7cuHHatm2bjh075qCKzOdOxwyQ3ERFRalp06Zau3atSpUqZdO+wcHBKl68uIoXLx4n/ujRI/3+++/68ccfNX/+fN27d8/MkiW535zn7usSd6/vMVfNy5GRkQ7N727c7fyxJ29SuOo4u3nzpmE8NDTU6j6cE46VHK4FzOJu93ECAgIM444+Nt39b+9p10WeNt94Wr0J5baVJ82PifXOO++oWrVqyp07t9VtTp06pXfeecfuvpzNGeN2VFSUw/uwh6eNiWbzlGs8RwkLC9PKlSvVpEmTOPHMmTOrbt26WrVqVYI5WrRoYfi7svVeK5LuwYMHVtucdRynSJHCaptRfdRsO1vrBQAgOfN1dQEAALirIkWKuLqERJsyZYqqV69u2NapUydt2bLFabV06tTJMB4dHa1Zs2Y5rQ53Eh0drRkzZmjJkiWaOHGi2rZta7idn5+ffvrpJxUpUkRhYWFOrtIx8ufPrxdffNEifuXKFa1du1avvvqqRVv37t01Z84ch9b19PkS35vE4Hx37txRs2bNtGDBArVq1cpwm3feeUfLli1zcmUAACQ/zz33nGH8zz//dHIlAAAAAAAAQPI0cuRIq20DBw5M8M1YtWrVsog9evRIc+fOTXQNO3fu1MmTJ5U3b9448Ro1aujjjz9OdB4jr7/+uuHzvpLUrVs3nThxwq78AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOAIsbGxOnLkiI4cOSJJKl26tNq1aydJ2rJli8aOHWt6n2fPntXZs2dNz5uQmJgY7du3T/v27XNoPylTppQk3bt3L0n7379/X5s2bdKmTZtMrCphJ0+e1MmTJ53aJwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOBpSpYsqS1btkiSvv32W3300UcurggAAAAAAAAAAAAAAMB5HkRIiwdJLT+T0mZL/H67Fkq7FzuuLndz48YNRUVFyd/f36Ite/bsOnbsmAuqgiTduXPH4/v18vIyLReePa46B+BZHHWc5MiRQyNGjFCbNm2e+bHsWf/5jcTGxjosd3R0tGHclr+DOx6/1uqw9vN6ivXr1+ubb77R0qVL5e3tHactKChICxYsUPny5RUVFeWiChPHHY8ZIDm6fv26KlWqpNGjR+vNN9+Uj4+PXfl8fX1Vq1Yt1apVS59//rkGDRqk6dOnm1Tt/7jbnOfuY5S71/eYq+blR48eOTS/u3G38ycxzLy+enpt9JijjzMzxxbOCXMk12uB5MyR45ckxcTEODR/UnnqdZGnzTeeVu9jZs2RnjQ/JlZERITefvttrVy50uo2b7/9tiIjI+3uKzly9JibVJ46JprtWf7ZH5s0aZKaNGliEe/cubNWrVqV4P7t27e3iP3zzz/asGGDKfUhYeHh4Vbb0qZNqzNnzji8hrRp0xrGHzx4YDhHUbPtbK0XAIDkzPjKGwAASJLq1q3r6hISZcmSJVZvzLdq1UqBgYFOq6VDhw6G8ZUrVyosLMxpdbij8PBwtWvXTn379rW6Tdq0aTVlyhQnVuVY3bp1M4zPnDlT48ePN2yrXLmyihQp4rCaUqZMqa+++ipO7I8//nBYf0ia2NhYdevWzeq4UbNmTaVOndq5RQEAkAylSZPGMH716lUnVwIAAAAAAAAkP82bN1fFihUN2/bu3asFCxYkmKNq1aqG+966dcumWn777TeLWPny5eXn52dTnv8qUqSIxo0bZ9g2ZcoUzZs3L8m5AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACepXLlypKkCxcuuLgSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGbz9vZWypQplTJlSvn7+7u6HAAAAAAAAAAAAAAAAKe7dUma/a7090YpNjb+bSNuSMtHSL9Pc0ppbuXs2bOG8YIFCzq3EMQRm9BBm8z6BZ7GsYjEcMRxUrt2be3fv19t27aVl5dXknLcuHFDu3bt0pw5czR48GC1adNGZcqU0c6dO02uFoiL49d5FixYoPr162v58uX66quvDLcpUaKERo4c6eTKbMMxAzjXgwcP9NZbb6lw4cKaMWOG7ty5Y0reLFmyaNq0aZo7d64CAgJMyQng2cN1OPBssXbOe3t7O7RfPz8/h+ZPCq6LkBDmyPj16NEj3vaePXs6qRKYgTER/7Vq1SqdP3/eIt60aVOlTp063n0zZ86smjVrWsRnzpzJuOpEkZGRunv3rmFbpkyZnFJDxowZDeNhYWGGcWq2na31AgCQnPm6ugAAANzBo0eP5OtrOS3OmDFDRYsW1fXr111QVeLdu3dP8+fPV7du3SzaQkND1bRpUy1YsMDhdVStWlU5c+Y0bJs6darD+/cUX331lR4+fKgxY8YYtjds2FAtW7bU4sWLnVyZufz9/dW5c2fDtqlTp+rYsWM6evSo4Zuwunfvrnfeecf0mp5//nktXbpUJUuWfBKLiYnRrFmzTO8L9rt165amT5+uAQMGWLR5e3urcuXK+vXXX11QGQAAyYe1J7EjIiKcWwgAAAAAAACQzPj4+GjEiBFW2z/88MNE5SlSpIhF7PDhwzbXY7RPYGCg8uTJo6NHj9qcLygoSIsXL1aKFCks2v766y+HPN8LAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHA/Xl5eGjNmjCpWrCjpf1/uDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADJzYMIacWX0u7FUuGaUs5SUkh6yS9QuntLunpWOrlT+nu99PCBq6t1jUOHDil//vwW8ZIlSzq/GA/h5eXl6hI8QmxsrGH81q1bmj9/vtPquH79utP6Av6LscLz1K9fX8uXL5ePj0+C20ZEROj48eM6fvy4Tpw4Eee/N2/eNNzn/v37ZpfscIzllvz8/PTw4UOH5Pb39zeMR0dHJ7ivOx+/MTExhnFfX98k53Sl7777Tr169XpyfgwaNEi1atVS2bJlLbbt3bu31qxZo5UrVzq7zAS58zEDz8Kax3bHjx/Xa6+9pjfffFMvvviiypUrpzJlyqhgwYLKnTu3AgICkpS3bdu2CgkJUePGjU2p093mPHdYl8S3JnGH+qSE103Wfsd+fn6OKMdp+d2Nu50/zmatFkev/6wdZ/H9bjgn4mfvPJ/crgWSk7t37xrGQ0NDHdpv6tSpHZrfVp5+XeRp842n1Ws2T5ofE6tHjx4JXn80btxY3bt31w8//GB3f3AsTx8TzeYp13iOFBMTo+nTp2vw4MFx4gEBAWrdurUmTpxodd82bdrI29s7Tiw2NlbTp093SK2wLiwsTLlz57aI58qVyyn9G/Ut/a8ua6jZNkmpFwCA5Iq7jgAASDp//rw2btyo1157LU48c+bMmjp1qpo1a+aawmwwZcoUdevWzbCtY8eOWrBggcNr6Ny5s2H8ypUr+vXXXx3evycZO3asChUqZPVvNmzYMP38889u9aSNrV5++WWlS5fOIr5t2zYdO3ZMkjR16lR99dVXFtt06NBBffv21b1790yrp06dOpo7d65FTSNGjNDhw4dN6wfm+vnnnzVgwADDtgIFCjC2AABgJ2svdrD25D8AAAAAAACAxHn99ddVoEABw7aVK1dq06ZNCeYICAhQUFCQRfzs2bM213Pu3DnDeJo0aWzOJUkTJkxQwYIFLeKRkZFq1aqVx70hCgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABguzRp0mjevHmqW7eupP99Ps4nn3zi4qoAAAAAAAAAAAAAAK7Wf0B/V5cAAABgk4CAAEnS62+8rujoaBdXAwDPjtDQUElS+w7t9ejRIxdXAwDPjsfjb6tWrfTw4UMXVwMAz4aQkBBJUt26dVX9xeourgYAnh3BwcGSpBdrvKgKFSu4thgAeIYEBQVJkipVqqQSJUq4uBoAeLb8ue9P/fbbb64uAwAAAAAAAAAAAAAAAAAAAAAAAACeGVdO/e8fLB08eFAvv/yyRbxq1aouqMYzpEiRwtUleIT79+8bxiMiItSjRw8nVwM4H2OFZ8mZM6fmzp0rHx8fw/br169ryZIlWrt2rfbs2aNz587Z3IeXl5e9ZTodY7mlVKlS6dq1aw7JnTp1asN4REREvPu5+/Fr7ThKlSpVknO6ysCBAzVixIg4sUePHqlt27bav3//k89U+68ZM2aoePHiCgsLc1aZCXL3YwaehTVP0kVFRWnNmjVas2bNk5iXl5eyZcumvHnzKm/evMqXL9+T/8+bN2+Cv+9GjRpp4MCBGj58uN31uduc5+7rEnev77HIyEjDuKPnZaM5Mjlzt/PH2azVYq12s6RNm9YwfufOHav7cE7Ez955PjldCyQ3kZGRio2NtVi3BwYGKjAw0Orfzl6OHgdskRyuizxtvvG0es3mSfNjYhQuXFijR49O1LajR4/W77//riNHjtjVJxwnOYyJZvOUazxHmzJlij766CN5e3vHiXfu3FkTJ060ul/79u0tYps3b9aZM2dMrxHxO378uHLnzm0RL1SokFP6t9bPiRMnrO5DzbZJSr0AACRXvq4uAAAAd/HOO++oWrVqypMnT5x406ZN9cYbb2jKlCkuqixx9uzZo8OHD6tIkSIWbXXr1lWmTJl0+fJlh/UfGBioli1bGrbNmjVLjx49cljfnurdd99VrVq1LI45ScqfP7/atm2rOXPmuKAyc3Tv3t0w/t9zadasWRoxYoR8feMuS1OlSqXWrVtrxowZptRSq1YtrVq1yuKm7bfffqtBgwaZ0gcc4/Tp01bbMmfO7MRKAAAAAAAAAAAAgMQJCgrSJ598YtgWExOjfv36JSpPmjRpDONJefNfeHi4Ydzam+ji07lzZ3Xs2NGwrWfPnjp69KjNOQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAlS5evKihQ4dKkrZv3+7iajxHkSJFVLt2bUnSoUOH1KBBA12/ft3FVQEAAAAAAAAAAAAAXC1dunSuLgEAACBJUqdO7eoSAOCZlCpVKleXAADPpNDQUFeXAADPnOCUwQpOGezqMgDgmRMUFKSgoCBXlwEAz5wUKVIoRYoUri4DAJ4pQcGsewEAAAAAAAAAAAAAAAAAAAAAAAAA7mHz5s2G8fz58+v555/XP//84+SKzOfj42NqvpCQEFPzJVd3795VbGysvLy84sTTpk3rooqA+DFWPNuGDx9u+Pn3ERERGjBggCZNmqSoqCi7+kiZMqVd+7sCY7ml1KlT69q1aw7LbSQiIiLe/dz9+LV2HPn5+SlFihS6d++eXbU5Q3R0tLp166Zp06YZtp88eVLvvPOOYXuGDBk0e/ZsvfTSS44uM9Hc/ZiBY7HmcW+xsbH6999/9e+//2rjxo1x2ry8vJQvXz7Vq1dP3bt3V6FChQxzDBgwQD/88INu3LhhVy3uNue5+7rE3et77P79+4qJiZG3t3ecuK+vr4KCgnT37l2H9PusfdeJu50/zvbgwQM9evRIvr6+ceK+vr4KDg5WZGSkQ/pNkyaNYTw8PNzqPsntnHC3eT45XAskZ9euXVOGDBks4pkzZ9bZs2dN7y84ONjqeeoKyeG6yNPmG0+r12yeND8mxN/fX/Pnz1dgYKBFW1hYmDJnzhwnliJFCs2fP1/lypWz+7yCYySHMdFsnnKN52j//POP1q5dq7p168aJV6xYUfnz59fx48ct9smfP7/KlCljEbd2bxWO9ffff6tevXoW8bJlyzqlf2v9HD582Oo+1GybpNQLAEBy5ZvwJgAAPBsiIyP16quvatu2bRZPII4dO1abNm3SyZMnXVRd4kydOlWjR4+2iPv4+Kht27YaO3asw/pu1qyZQkNDDdu4yWXs3r176tWrl3799VfD9h49emjOnDlOrsocBQoUULVq1Szi4eHhWrhw4ZPHV65c0YoVK9SsWTOLbbt3764ZM2aYUs+mTZu0a9cuVapUSZL08OFD9e7dWxMmTDAlv5H06dMrbdq0Sp06tUJDQ+Xt7a3IyEjduXNHV69eVVhYmMP6Tk6uX79u+AIVyXOeRMmSJYvSp0+vkJAQBQcHKzY2Vrdv39aNGzd08+ZN3bhxQ7Gxsa4u00LKlCmVLVs2hYaGKiQkRN7e3goPD9ft27f177//utWTynBP2bNnV9q0aZUqVSoFBgbq8uXLunr1qi5evOjq0qD/rQ9z5cqlNGnSPFnD3blzR7dv39bZs2eT7YsUPHVMfpaFhIQoe/bsT+ajmJgY3blzR3fu3NG5c+d0//59V5folry9vZUnTx6lS5dOISEhevToke7cuaMbN27o7Nmzph7nISEhypEjh9KkSaMUKVIoKipK4eHhOnfunMNe9PYse3p+vXv3rsLDw91ujvXE8dbT1r++vr7KnTu3UqdO/aTee/fu6fr16zp79qxbvtjcU47f4OBg5ciRQ6lSpVLKlCkVFRWlO3fu6NKlS1zLO5GnHC+PecoYwtoqYYwBjuVp57Y7e5Z+l9xrR3LjiWt5JM17771n8Uaxx2bOnKm//vorUXmCgoIM40k5Vqy98Ts4ONimPIUKFdL3339v2DZz5kzNmjXL5to8gSfNSZ60VrC2Br9y5YouXLjg6vKSNU86Tv7Lz89PuXLlYi51Mk+85+uuUqZMqezZsytVqlQKCQnRw4cPFR4ermvXruncuXOuLs9tcV8LScH1FwAAAAAAAAAAAAAAAAAAAAAAAAAAAGwVFhamTz/91NVleJytW7dq4MCBKlasmLp37+6wL5wHAAAAAAAAAAAAAHiWsWPGuroEAAAAm3Tv0V2BgYGaPXu2rl+77upyAOCZ0eX1LgoNDdXCBQvd+nv0ACC5afVKK2XNmlVLly7V2TNnXV0OADwTmjZtqly5c2nD+g06ePCgq8sBgGdGjZo1VKJECW3dslV79+51dTkA8MyoXKWyypUrpz179mjb1m2uLgcAnil8/g8AAAAAAAAARyhVqpRatmyp4sWLK3fu3MqZM+eTtrfffluNGzfWqVOntH37dq1atUr79u2zq79s2bKpYcOGevHFF1WoUCFly5ZNKVOmVEBAgO7du6cbN27oxIkT2rFjh3755Rft2rXLzp/w/6RLl06tWrVSrVq1VLRoUWXNmlXBwcGS/ncP9sKFCzp06JDWr1+vxYsX6/p1x70XLXfu3Kpdu7ZDcu/du9fq38lV/VpTvXp1FShQIN5tDhw4YOpxAAAAAAAAAAAAAAAAzLF9+3bdu3dPKVKksGhr2bKlRo8e7YKqkiY6OtowHhISYmo/2bNnNzVfchUdHa2rV68qY8aMceJBQUEKDAzU/fv3XVQZnnWMFXhazpw51bp1a4v4gwcPVLt2bdNe+5Y+fXpT8jgTY7mlTJky6eTJkw7LbeTatWtW9/GE4zcmJkaXL19W5syZLdoyZcqks2fP2lGZc7Ro0ULLli2Ld5vp06erQYMGatmypUVb7dq19eGHH+qrr75yVImJ5gnHDMzBmif5iY2N1fHjx3X8+HGNGzdOQ4cO1dChQy22S5kypd544w2NHDnSrv7cbc5z93WJu9f3X5cvX9Zzzz1nEc+UKZPOnDljen+BgYGG64DkzN3OH1e4cOGCcuTIYRHPnDmzTp065ZA+rR1nYWFh8e7nqeeE0VzvbvN8crgWSM6OHTumDBkyWMTLly/vkL9N2bJl5e3tbXrepEgu10WeNt94Wr2O4EnzY3y++uorFStWzCK+d+9eNWzYUPv377eYW4sXL66RI0fq3XffTXK/cIzkMiaazZOu8Rxt0qRJqlu3rkW8c+fOGjhwoEW8ffv2FrHw8HAtXrzYIfUhfn/88YdhvHTp0kqZMqUiIiIc1ndISIhKlixp2Pbnn39a3Y+aEy+p9QIAkFz5uroAAADcya5du/T5559bvLAkODhYc+fOVaVKlay+uMgdzJ49W19++aX8/Pws2jp16qSxY8c6rO9OnToZxnfs2KEjR444rF9Pt3LlSu3atUsVKlSwaHvhhRdUqFAhj/z9vfnmm4bx+fPn6+7du3FikydPVrNmzSy2rVChgkqUKKEDBw7YXU90dLTatGmjAwcO6Pbt22rTpo127txpd97/yp49u9q1a6cqVaqoXLlyVp+Ie+zWrVs6fPiw1q9fr2XLllm9WYb/vYjC6ElzLy8vF1STsNKlS6tZs2aqWbOmihYtqlSpUsW7/Z07d7Rt2zZt3rxZv/76qw4dOuSkSuNKnz69GjdurEaNGql06dLKkSOH1d9xbGysTp48qR07dmjBggX67bff3Hp+/K9ixYqpUKFCVtuvX7+u9evXW8SrVatm+CRyVFSUli5dalp99erVU2hoaJzYvXv3tHz5ctP6ePnll+Xj42MR37Jliy5dupTkvMWLF1fLli1Vq1YtFStWzOoLsm7duqWDBw9q1apV+vnnn3Xs2LEk9/ksq1ixop5//nmL+PLly3Xv3j3DfYoVK6bWrVurfv36KlKkiAICAgy3e/TokY4eParNmzdr8eLF+v333xUTE2Nq/c7iijE5b968Kl26dLzbWHshQIECBfTKK6/Y3OehQ4cM14xZsmRRlSpV4t3X6A3yklSmTJkk1XL+/Hlt377d5v0eS506tRo3bqymTZuqTJkycb4w4mkxMTE6ceKEdu/eraVLl2r16tUWa017JOU8k6T8+fOrTJkyKly4sNKkSaPQ0NA412gbNmzQ5MmTTe8/ZcqUatOmjV599VWVL19eQUFBhnkjIyO1f/9+LV26VPPnz9f58+cTrOVpRYoU0euvv666deuqYMGCVl/gGBYWpt9//10LFy7UL7/84tbrBVf/va1J7PwquXaO9cQ1sKeuf4sVK6ZZs2apcOHC8vf3N9wmNjZWx44d08aNG7Vw4UJt2rTJuUX+f55y/AYEBKhevXp6+eWXValSJeXJk8fqsXDjxg3t3LlTP/30kxYvXqzbt287rU6zMN6Zw1PGEHdaW0nuefw9a2OAs7nq3C5atKgKFy5s2PbTTz/p0aNHSc6dkOrVqxveGz59+rT27t2b5LyeNk7aI7nca+d+4v9YG/svXLigbdu2Wd3Pne6vmOHxfbmGDRt6xFoe9kuXLp369etn2Hb//n0NHjzY7j5iY2Odss/TUqRIocWLFxveezpy5Ih69uxpdx/uwpPmJE9aK9iyBr9586b27dv3ZA1+5coVw+2yZ8+uSpUqWcT379+v48ePJ7q2tGnTWv2C24SuW5IiXbp0qlWrlmHbL7/8ogcPHpjan7scJ0m5NixRooTatWunOnXqOGUudee1SFLXV7byxHu+7srf31/16tVTq1atVLFixXjHvbt37+rQoUNauXKllixZosOHDxtulzFjRhUtWtQifuLECf3777821eeO92sk193Xehav5dx5zEsKrr8AAAAAAAAAAAAAAAAAAAAAAAAAAAAA1xg5cqSrSwAAAAAAAAAAAAAAuJkLFy64ugQAAACbPP6utyuXrygsLMzF1QDAs+Pxd75fvXqVa0kAcKKoqChJ0vXr1xl/AcBJ7t+/L+l/3x/N2AsAzhMZGSnpf9/FzvgLAM4THh7+5L+MvwAAAAAAAAAAAJ7J19dX3bt317vvvqs8efJY3S4wMFAFChRQgQIF1KBBA33++ec6ePCgPv74Y/3888829VmwYEF9/vnnat68uby9vQ23SZEihbJmzaqsWbPqxRdf1IABA/Tnn3/qww8/1Pr1623q77/SpEmjYcOG6fXXX5e/v7/hNiEhISpYsKAKFiyoVq1a6ZtvvtGUKVM0aNAg3bp1K8l9W1O2bFlNnDjR9LySNHToUO3bt8+t+rVm4MCBqlOnTrzbjBo1Srt27bKnNAAAAAAAAAAAAAAA4ABRUVFau3atmjRpYtHWrVs3jR492qn1pE6dWg8fPnzyeRS2uHnzpmE8NDTU3rLiKFCggKn5krN//vlHGTNmtIgXLVpUe/fudUFFAGMFLDVo0MDwNZHjx4837XVv3t7ehuOhJ2Asj6ts2bLatm2b6XmzZs2qTJkyWcQfPnyoM2fOWN3PU47fc+fOKXPmzBbxMmXK6OzZs3bldoZly5YlaruuXbuqQoUKyp49u0XbsGHDtHHjRpefN55yzMB+rHmSt9jYWH388cfKkCGDevbsadFet25djRw50q4+3G3Ok9x/XeLu9T12/PhxPffccxbxsmXLJvg3SIr8+fPLy8vL9LzuzB3PH2f7+++/lSNHDot4hQoVdOrUKYf0Wb58ecP44cOH493PU88Jo7neHed5T78WSM6OHDmiKlWqWMSrVKmihQsXmt5fhQoVTM+ZVMnlusjT5htPq9cRPGl+tKZ+/frq1auXRfzevXtq3769rly5otdff10rV6602KZ3795avXq1Vq9enaS+4RjJZUx0BE+5xnO0ZcuW6fLlyxZjbYcOHfTRRx89+Y7hx9q1a2eRY+HChbp7965D64Sx33//3TDu5+enl156yebPG7FF3bp15efnZxGPjo6Od01AzYmX1HoBAEiufF1dAAAA7ubTTz9V3bp1VbFixTjxcuXK6eOPP9bgwYNdVFnCrl27puXLl6tFixYWbSVLllTRokX1119/md5v5syZ9dJLLxm2TZ061fT+kptx48ZZfVKwadOmOnLkiJMrsk9AQIA6depk2DZlyhSL2OrVq3Xx4kVlyZLFoq179+7q0aOHKXX9888/atCggY4cOWLqh+xWrlxZQ4YMUe3ata1+2LCR1KlTq3Llyk/2P3LkiL766ivNmTNHDx8+NK2+5MDa7zU6OtrJlVjn7e2t1q1ba+DAgSpatKhN+4aGhqp+/fqqX7++RowYoTVr1uiLL77Qxo0bHVRtXCVKlFD//v3VqlUr+fj4JGofLy8v5cuXT/ny5VPHjh11+fJlffrpp5o0aZIePXrk4IqTrlGjRlq4cKFSpEhh2P7PP/9Ync9q1qypoUOHGrblzp3blCfZQ0JCtGzZMosb2LGxscqSJYvCwsLs7qNw4cJavHixRTwmJsbwhWCJ8fLLL2vQoEEqWbJkorZPnTq1qlWrpmrVqmnEiBFav369PvvsM6tPGsBY79691aZNG4t4jhw59M8//8SJlS1bVsOGDUvwQ9Af8/X1VdGiRVW0aFH17NlTZ8+e1YgRIzR9+nSPmKNcPSbXqVNH33//va1lS9KTvm3VqVMnwzVj2bJltWDBgiTV0rFjR3Xs2NHm/caNG6ft27fbvF++fPnUv39/tW/f3uqXKDzN29v7yRdIdOjQQZGRkZo4caJGjRqlS5cu2VzD02w5z0JCQvT222+rS5cuyps3b7x5IyIiNHnyZNP69/LyUrdu3TR8+HClTZs2wbzBwcFP1qEjRozQlClTNHToUF25ciXBffPkyaMxY8aocePGCW4r/e9asXXr1mrdurXOnTunjz76SD/++GOi9nU2V/+9n2br/Co5f4519XibVJ66/i1evLhGjBihBg0aJLitl5fXky+d6dGjh/7++28NGjTIoS8c+S9POH6l/x2H77zzjt577z2lS5cuUfukTZtWDRo0UIMGDTR69Gh9//33GjZsWJI+4MVVGO/s4yljiDuurST3Ov6e1THAWVx9bqdNm9bqtVCzZs30yy+/2JwzMVKkSKHly5crJCTEou2VV15J0ouoXf27dKbkdq+d+4n/Y23sX7p0abwv2HWn+yv2sGUdL7l+LQ/zDBkyxHA+kKSxY8fqwoULTq7IPN9//70KFy5sEb93755atWqVLN4A40lzkietFZKyBk+TJo1q1aqlWrVqacyYMZo0aZI+++wzi3uZlSpVMlz/vf/++zZ9GGzevHmtriONrlvsVaBAAav9ZcqUKVH3bBPD3Y4TW64NS5cura+++ko1a9ZMVG6z5lJ3XoskdX2VGJ56z9ddpUiRQr169VLfvn0T9fyNJAUFBalChQqqUKGCPvnkE61evVqDBw+2uJ588cUXTRn3JPe6XyO5/r7Ws3gt585jni24/gIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwD558+bVokWLVLJkySTtX7x4cf3000/69ddf1aFDB928eTPBfd599119+eWX8vf3t7m/UqVKad26dRo9erTef/99m/evVKmSfvrpJ2XOnNmm/QICAvTWW2+pefPmatasmfbs2WNz30hYvnz5XF0CAAAAAAAAAAAAAACww+zZs9WkSROLeIECBdS4cWMtX77cabUMHjxY3bp107x58zR58mSbXu9h7TUwuXLlMqs8SVL16tVNzZecHTp0SGXLlrWIV6hQQXv37nVBRQBjBSxVq1bNMD5//nzT+ihTpoxSpEhhWj5nYiyPq1KlSvrmm29Mz1uxYkXD+KlTpxQTE2N1P085fvfv368KFSpYxCtVqqQlS5bYldud3Lp1S+3bt9fGjRvl7e0dp83Pz0/z589XyZIlFRER4aIKPeeYgf1Y8zwbhgwZom7dusnX1zdOvFy5cnbndrc5T3L/dYm71/fYsWPHDM/dSpUqadGiRab39yyOE+54/jjbX3/9pfr161vEq1Sporlz55reX4ECBZQuXTqL+IMHD3Tq1Kl49/XUc8JornfHef5ZuRbwRBs3blTXrl0t4i1atNB7772n6OhoU/tr166dqfnskVyuizxtvvG0eh3Bk+ZHIxkzZtSMGTMM2/r166djx45JklatWqVJkyapW7duFtvNnDlTxYoV05UrV2zuH46RXMZER/CUazxHe/TokWbOnKm+ffvGiWfLlk01a9bU+vXrn8QqVKigPHnyWOSYNm2aw+uEsQsXLujYsWMqUKCARVuHDh30888/O6zvjh07GsZ3794d7z1yak68pNYLAEBy5Z3wJgAAPFtiYmL06quvGl4kDhgwQJUrV3ZBVYk3depUq23WLort9eqrr8rHx8ciHhkZqQULFjikz+RkyZIlVm9KNGrUyMnV2K9ly5ZKmzatRfzw4cPavXu3RTwmJsbqEymvvvqqgoODTattx44dunXrlim5UqdOrSlTpmjLli2qU6eOxYtfbVWoUCFNmzZNhw4d0gsvvGBKjclB+vTprf5uzfpb2qto0aLau3ev5s6dq6JFi9qdr06dOtqwYYNmzZqlwMBAEyo0liZNGs2cOVP79+9XmzZtDMfxxMqUKZO+//57HTp0SMWKFTOxSvN07txZS5cutfrk219//aVKlSrp+PHjhu0LFy60mrtp06am1Fi3bl35+flZxL28vNSgQQNT+rBW6+bNm21+MrpgwYLavXu3Fi9enOQPepekWrVqadOmTZo3b57SpEmT5Dyw5OPjo2HDhmnXrl2qU6dOkvPkzJlTEydO1IEDB1S6dGkTKzSfp47J9jp8+LCrS3ji6NGjNm0fGBior7/+WkePHlWXLl2S9CUOjwUHB6tPnz46c+aM+vXrZ/f6LLFeeukl/f333xo+fLjy5s3rlD4fCw0N1YoVK/TDDz8YrsET4uvrq+7du+vAgQMJXut27txZhw8fVuPGjZNUa44cOTRnzhwtXbpUISEhScrhDhz99zZrfpUcO8d64njryevfAQMGaO/evUleExYuXFg//fSTli1blqSxIrE85fiVpCZNmuj48eP6/PPPDV8smhihoaEaMGCADh8+bPXFhJ6M8S4uTxlDksPaSnL88ccY4Djucm5v3rz5yQv0n/baa6/ZVVd8WrRoYbjWvXbtmpYuXWpTLnf5XTpDcr3Xzv1Ez2P2/RV71/GS89byMFeuXLnUvXt3w7br169rxIgRpvSTlDWpPetY6X8v8Lc2l7799ttudZ8yKTxpTvK0tYIZa3B/f3+9/fbb+vvvvw0/+BWWPO04+S8vLy8NGTJEe/bsUc2aNZOcx5PmUlePoZ54z9ed1ahRQydOnNAXX3xh17FXr1497dy5U8OGDbN7HreXo+/XuMt9La7lnIPrLwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3EvhwoW1Y8cOlSxZMk48NjZWhw4d0uzZszVr1qwn8QMHDmj9+vW6ffu2Ra6GDRtqx44dypgxY7x9DhkyRGPGjJG/v3+c+PXr1/Xrr79q3LhxGjZsmD7//HN9++23WrlypW7evGmRp0+fPho3bpwNP61UvXp1bdiwQZkzZ7ZoO3v2rFauXKlp06Zp2rRpWrlypc6ePWuxXZYsWbRp0yZVqlTJpr5d6dGjRx7Rr6+vr55//nkHVQMAAAAAAAAAAAAAAJxh+fLlunbtmmHbyJEj5ePj45Q6goOD1aVLF6VMmVJdu3bV7t27tX//fr311lsKDg5OcP8bN24YxkuXLm1ajb6+vqpTp45p+ZK73bt3G8ZffPFF5xbyDHLWeeuJGCvwtOeee84wfuTIEdP6qFmzpmm5nI2xPK6aNWtavJ7WDA0aNDCMb926Nd79POX43bVrl2Hc2s/tyTZv3qwvv/zSsC1PnjwaP368kyuKy1OOmcRgvRM/1jzPhuvXr2v//v0W8ZCQELvnK3eb8yT3X5e4e32PbdmyxTBev359h/TXuHFjh+R1Z+54/jjb2rVrDeONGjVyyBzerFkzw/jvv/+u6OjoePf11HPCaK53x3n+WboW8DRr165VbGysRTxr1qxq0aKFqX1VrFhRJUqUMDWnPZLLdZGnzTeeVq8jeNL8aGTmzJmG70dft26dxXvH+/Tpo9OnT1tsmzFjRs2cOdPmvuE4yWVMlMy/V+Qp13jOMHnyZMN4586d4zxu3769xTYnTpzQ9u3bHVEWEmnRokWG8caNGytHjhwO6TN37txW5+gFCxYkuD81J8zeegEASI68XV0AAADu6PTp0+rVq5dF3MfHR3PmzFFISIgLqkqc1atX6+LFi4Zt7du3l7e3+dP/0ze8Hlu0aJEiIiJM7y+5uX//vjZs2GDYVqFCBQUGBjq5Ivu8+eabhvEpU6ZY3Wfq1KmGT8KGhISobdu2ptVmlrx582rv3r16/fXX5eXlZWruAgUKaOvWrRowYICpeT1V7ty5rbZduHDBiZUY69y5s/744w+VKlXK9NwdOnTQ9u3blTVrVtNzV65cWX///bc6duxoat6CBQtq165datOmjal57fXhhx9q+vTpVp8U27p1q6pUqWJ1/pSkv//+2+oTgdaeYLZVkyZNrLaZ9cKp5s2bG8at3ay3pkuXLvrzzz9Vrlw5M8qSJLVp00aHDh1S0aJFTcv5LAsMDNSKFSs0cOBA09Z/hQoV0q5du/TGG2+Yks9snjom2ys2NtbUFyrY69ixY4netkCBAjp48KD69Olj6nVKQECAvvjiC+3cudPwyxnM1K5dO61atUrZsmVzaD9GUqVKpc2bN5vyotLMmTNrw4YNVl+oMmzYME2fPl0BAQF299W0aVNt2rRJqVOntjuXszn67+2I+VUyf471xPHWU9e/Pj4+mj17toYPHy4/Pz+78zVu3Fi7du1Szpw57S/uKZ5y/ErSN998o19++UWZMmUyJV+OHDm0bt06q/fHPBHjXVyeMoYkh7WV5PjjjzHAcdzt3Lb2At6GDRsqQ4YMZpRm4bXXXjOMz5w5Uw8fPkx0Hnf7XTpScr7Xzv1Ez2Lm/RWz1/GSY9fyMN+wYcOsvhHws88+0507d2zKZ237oKAgm2uz9mGURl/Q+rQCBQpowoQJhm0//vijpk2bZnM97sST5iRPWyuYvQZPly6dfvnlF/Xr18+UfMmVpx0n/+Xr66vFixfrk08+Me361t3nUlc/1+OJ93zd2eDBg7Vu3TrTfmYfHx8NHDhQCxcuNG19aStH369xp/taXMs5HtdfAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC4lxQpUmj58uVKnz79k9ijR480ZswY5cyZU8WLF1fHjh31zTffPGlfu3atateurdSpU6t27drasmVLnJwFChTQypUr5evra9hn3bp19fHHH8eJ/fHHH6pbt64yZMigRo0aqVevXho0aJAGDx6s3r17q2HDhsqUKZPatWun8+fPx9n37bffVpMmTRL182bKlEk///yzAgMD48SXL1+uMmXKKFeuXGrYsKFef/11vf7662rYsKFy5cqlMmXKaMWKFXH2CQoK0i+//KK0adMmqu/EWLNmjcqUKWP3v++++y5O3gcPHmjOnDlu16+R6OhoZcmSRZkyZYrzb8KECTblAQAAAAAAAAAAAAAArvPgwQONHTvWsK1gwYIaOnSoU+oYNmyYUqdOHSdWokQJjRo1SkFBQQnu//fffxvGM2fOrLx585pRol5++WVlyJDBlFzPgjVr1hjGmzRpwu/RJJGRkYbxkJAQJ1fiORgr8LQ0adIYxu/fv29Kfm9vb3Xt2tWUXP9l7fw3G2N5XBkyZFCbNm1MzZk+fXq1a9fOsG316tXx7uspx6+1n6NQoUKqVauW3fndzeDBg7Vnzx7Dtg4dOujVV191ckX/x1OOmf9ivZM0rHncT+bMmR2S9+LFi4bxp6+vbeVuc57k/usSd6/vsbVr1xrGCxYsqNq1a5vaV+7cuU3P6Qnc8fxxtt9//91wDs+ePbtatmxpal9+fn7q1auXYduyZcsS3N9Tzwmjud4d5/ln7VrAk1y7dk3r1q0zbBs6dKj8/f1N6+uzzz4zLZcZPPG6yIinzTeeVq8jeNL8+LTevXurXr16FvFbt26pc+fOFvHIyEh17NhRMTExFm316tWzWhuczxPHRGfdK/KUazxnOHnypDZt2mQRb9GihVKmTClJ8vHx0SuvvGKxzbRp0xxdHhIwZ84cxcbGWsR9fX0d9lqQjz/+WD4+PhbxR48eaeHChQnuT80Js7deAACSI29XFwAAgLuaPn26YTxnzpz6/vvvnVxN4sXExGjmzJmGbc8995zpTzaWLFlSRYsWNWybOnWqqX0lZ9aegPT19VWxYsWcXE3SFSxYUFWrVrWIR0VFafbs2Vb3O336tH7//XfDth49ephWnxmyZMmijRs3Kk+ePA7rw8vLS8OHD9eoUaMc1oenaNGihdW2ffv2ObESS7169dK0adNMfZHA00qVKqVly5YpICDAtJzNmjXTunXrHPbCzBQpUujHH39U27ZtHZLfVqNGjdLIkSOttv/yyy+qXbu2bt++nWCuRYsWGcarVKli94d2e3l5qUGDBlbbX3rpJbuPteeee05ly5a1iMfExOinn35KdJ6+fftq6tSpFh96boasWbNqy5YtqlChgum5nyU+Pj5asWKF4YsV7OXr66vJkyfrgw8+MD23PTx1TDbD2bNndffuXVeX8cSxY8cStV3FihW1fft25cuXz2G1lCtXTrt27VLBggUdkv+ll17S7NmzDZ98dDRfX1/9+uuvKlGihGk5/f399fPPP6tAgQJx4v369dPAgQNN60eSSpcuHe/1gTty9N/bkfOrZN4c64njrSevfydPnqz27dubmjNv3rzasGGDMmbMaFpOTzl+vby8NGfOHIe8CNPPz0/Tpk1z6ZtfzcJ4F5enjCHJYW0lOfb4YwxwLHc8t2fOnKmoqCiLuK+vr0P+VtmzZ1fNmjUN2yZPnpzoPO74u3SUZ+FeO/cTPYeZ91ccsY6XHLOWh/lKlSpl9U2AZ86c0fjx423OefPmTcO4tTc1xcfah2jcuHEj3v0CAwO1aNEiBQcHW7QdP35cb775ps21uBNPmpM8aa3gyDW4JH3xxRcaMGCAQ3J7Ok86TozMnTs33tcJJJU7z6WufK7HE+/5urPRo0fr008/lbe3+S/Pb9GihWbMmGF63oQ4+n6hM+9rJRbXco7F9RcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAO7l/fffV+7cuZ88Dg8PV82aNdWnTx/9888/Ce6/fv16VatWTW+99ZZiY2OfxMuUKaMhQ4ZYbO/l5aWvv/5aXl5eT2LTp09X+fLltWbNmjg5nvbw4UPNmzdPJUuW1P79++O0jRgxIsFaJWn8+PFKkybNk8exsbHq3r27mjRpon379lndb9++fWrcuLHeeuutOPEMGTJo7Nixieo7MW7duqV9+/bZ9e/YsWNq1apVnLzjxo2L9+/pqn6NxMbG6sqVKxb/IiMjbcoDAAAAAAAAAAAAAABc67vvvtONGzcM2z766CM1aNDAof1Xr15d77zzjmHbjBkzdPXq1QRzHD9+XNevXzds69y5sz3lSZJ8fX318ccf253nWXL69GkdOnTIIu7v76+uXbua2leqVKmUOXNmU3N6gps3bxrGc+TI4eRKPAdjBZ4WHh5uGM+QIYMp+du2bas8efKYkuu/rJ3/ZmMst/TBBx/Ix8fHtHx9+vRRYGCgRTwyMlJr1qyJd19POX4vXbqkbdu2GbYNGDDA7vz/1a1bN5UoUcLUnLaKjo5W27ZtFRERYdg+YcKEOK8JdyZPOWb+i/VO0rDmcR/ZsmXThAkTdO7cOTVt2tT0/P7+/obxe/fu2Z3bneY8yfnrElt5yrrp8uXL2r59u2HbwIED7SnLwmeffRbnPUnPEnc7f5wtKipKCxYsMGz76KOP5OfnZ1pf3bp1U5YsWSziDx480KJFixLc31PPCWtzvbvN88/atYCnGTdunGG8SJEiGjZsmCl9dOvWTbVr1zYll1k88brIGk+bbzytXrN50vz4X8WLF9eXX35p2NazZ09duHDBsG3btm0aNWqUYdvIkSNVvHhxm+qAY3jimOise0Weco3nLJMnT7aIBQUFPfm8gpdeekkZM2aM0x4TE6NZs2Y5pT5Yd+zYMf3222+GbZ07d1a1atVM7a9GjRrq0KGDYdvChQt16dKlBHNQc/zMqBcAgOTI29UFAADgzi5evGgY79Chg1555RUnV5N406ZNs9rWqVMnU/uylu/EiRPaunWrqX0lZ/F9SGypUqWcWIl9unfvbhhftmyZ1RflPTZlyhTDeOnSpVWmTBm7azPL3LlzlS1bNqvtly9f1vjx49WyZUsVLFhQadOmlb+/v3x9fRUSEqLs2bOrRo0a+uCDD7Rx48Z4P5z4/fffN/2c9SRp06bVa6+9Zth25coV7d2718kV/Z+GDRtq7Nix8b6YZd++fRoyZIjq1KmjHDlyKDQ0VL6+vkqRIoWyZs2qsmXL6t1339X69evj7at06dL6/vvvTam7Zs2aWrRokeGTxf919uxZjR8/Xh07dlSdOnVUqlQpFStWTC+88IJatmypL7/8UsePH7e6v7e3t2bPnq0XXnjBlLqTwsfHRzNnztT7779vdZupU6eqRYsWevDgQaJyLly40GpfDRs2TFKdj1WqVEnp0qWz2h4cHKwXX3zRrj6aNGlieMxu27ZNYWFhicrRtWtXq0+CP3b+/Hl99913atSokfLnz6/UqVPL19dX+fPnV6NGjTRmzBidOXPG6v6pU6fWsmXLlD179kTVBEtjxoxRrVq1DNuOHTumr7/+Wm3btlXlypVVvHhxlSpVSnXq1FHHjh01adIk/fvvvwn28dVXX6lly5Zml54k7jYmR0ZG6vz58/H+i4qKMtw3IiIiwX2f/hffmvv+/fsJ7h8TE2O47+3bt22u5dSpUzp//ny8vx9JKlSokH777TelTZs23u3++ecfjR8/Xh06dFDt2rVVokQJlSlTRvXr19frr7+uWbNmJfgG+ueff17r1683fDGQPTJnzqx58+bJ29s1t1c/+eQTVa5c2SIeGRmpWbNmqVOnTqpUqZKKFi2qSpUqqUmTJho0aJB2794db97Q0NA4L3KoUaOG1S/FOHfunEaOHKmmTZuqbNmyKlasmKpXr67WrVvru+++S/ALGxo1amT1+sHdOPrvbc/8mjZtWqfNse423iaGJ69/e/ToYfV66LvvvlP79u1VpUoVFS9eXGXKlFHdunXVtWtXLViwQLdu3Yo3d65cuTRv3jxT6vSU41eSvvjiC7366qsJbvfXX39p5MiRatOmjWrUqKHixYurZMmSql69ut544w1NmTJFV65csdjPy8tL06dPV7ly5ZJco6sx3sXlKWNIclhbSY4//hgDHMddz+1r167pl19+MWzr0qVLonLYokOHDobrpC1btujYsWOJyuGuv0tHeRbutXM/Menc6f6KLeJbxz8+f91lLQ/HGDlypNXr5oEDB+rhw4c254yOjjY8NvLmzWtzrnz58hnGr127Fu9+48aNU7FixSzi9+/fV6tWrTz+Czc9ZU7ytLVCYtfghw8f1ldffWXzGlyShg0bpkaNGtlVZ3LjacfJ0z744AOLLwh+um5nzKWeuhaxlSfe83Vn/fr103vvvZfgdgcPHtSwYcPUpk0b1axZU8WLF1fp0qVVr149de7cWZMnT7b6Brd27drpzTffNLt0qxx9v8bZ97USe0/rWbuW89Qxj+svAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADM0bVr1ziP33nnHW3ZssXmPOPHj1fPnj3jxPr06WOxXWxsrN59912tW7dOkrRnzx517dpVMTExie7r+vXreuWVVxQVFfUkVrhwYZUsWTLe/WrXrq0WLVrEiQ0cOFATJ05MdN/jx4/XkCFD4sQ6dOigSpUqJTqHo/Xp00eZMmV68vjmzZsaNmxYsu0XAAAAAAAAAAAAAAC4p9u3b6tfv36Gbd7e3lq8eLFq167tkL5LliypZcuWydvb26ItKipKo0aNSnSu7du3G8a7du2q1KlTJ7VESf977UrBggXtyvEsmjx5smH8o48+Ur58+UzrZ8yYMTp27Jh69epleCwlVxcuXDCM58uXL87rgxAXYwX+69q1a4ZxM15rmDVrVo0ZM8buPEasnf+OOPcZy+MqVqyYvvrqK1NyVa9eXX379jVsmz17tsLDw+Pd35OO3x9++MEwXqtWLfXu3duUPsqWLasJEyZo//79Wr58ucqXL29K3qQ4deqU3n77bcO2kJAQzZ8/X76+vk6uyrOOmcdY7yQdax7XypYtm8aPH69Tp06pe/fu8vf317fffqu0adOa2k/evHktYnfv3k1wDkkMd5rzHnPmuiQpaxJPWTd9//33hvEaNWro/ffft7c8SVK9evXUrl07U3J5Inc8f5xt1KhRio2NtYgXK1ZMY8eONaWPUqVKWb13OGvWLF25ciVReTz1nDCa691xnn/WrgU8yYoVK3Tw4EHDtj59+uiNN96wK/9LL71k2vluJk+8LrLG0+YbT6vXETxpfpSkwMBAzZ8/XwEBARZtCxcu1Lx58+Ldf9CgQTp06JBFPCAgQPPmzVNgYGCia4FjeOKY6Mx7RZ5yjecMS5Ys0Y0bNyzinTt3liS1b9/eom3NmjW6ePGio0tDIlj7HAkvLy/NmzdPzz33nCn9ZM2a1ercEBMToy+//DLRuajZmJn1AgCQ3Dj/2XcAADxIx44dtXbtWnl5eVm0TZw4Udu3b9f58+ddUFn8Tp48qc2bN6tatWoWbc2bN1fKlCkVERFhdz8+Pj5Wn8ydOnWq3fmfJdaefJSk3LlzO7GSpAsICFDHjh0N26zdNP6vJUuW6LvvvjN84r579+4WHyrsCi1btlT16tUN2+7fv6/Bgwfr22+/jfMhwv8VERGhiIgInT9/Xps2bdLXX3+t/Pnz68svv1SzZs0M9xk/frw2bNigf//916wfwyN4eXnphx9+UMaMGQ3bZ86cqejoaCdX9T+ZM2fW7NmzDecGSdq9e7fee+89qy9EjY6O1sWLF3Xx4kX98ccf+uabb1ShQgVNmjRJxYsXN9zn9ddf19SpU7Vjx44k150nTx4tXrw43hdh79ixQ/3799fmzZvjzbVkyRL1799f9erV09ixY1WgQAGLbXx8fDR37lwVL15cd+7cSXLdSZEiRQotXrxYDRo0sLrNsGHDNGjQIJvyHj58WEePHjV8cVDz5s01e/Zsm2t9rEmTJglu07hxY61ZsybJfTRv3twwvnDhwkTtX6FCBX333XdW269cuaJPPvlEkyZN0qNHjyzaT5w4oRMnTujXX3/Vhx9+qFdffVUjRoxQlixZLLbNmDGjlixZogoVKhi+UADWvfjii3rnnXcs4uvXr9fHH3+srVu3xrv/4+O4QYMGGj58uEqUKGF12xkzZujgwYM6fvy4fUXbwR3H5JkzZ2rmzJnx1r1jxw5VrFjRIj5lyhS999578e5rizVr1ih79uzxbnPp0iVlzpzZIj5kyBB9++23ptXyWNq0afXrr78qNDTU6jb79+9Xv379Ehzzpk2bJi8vL7Vu3VrDhw9Xrly5DLfLkiWLli9frhdeeEEPHjywq/7HvvrqK6VLl86w7cCBA1qxYoV27dqly5cv69q1a3HGRXuvxYoUKWLxoQbR0dEaO3asPvvsM92+fdtwv+XLl2vYsGGqVq2aJkyYoMKFCxtuV7VqVb3yyitavny5Zs2aZXF+Xbp0SX379tWPP/5odYxeuHChevfurR49emj48OFW/96jR4/W4sWLrb4Ix1048u9t7/x68+ZN3bx50+FzrDuOtwnx5PVv1qxZDV/E8Pfff2vQoEH6+eefre47ZcoUBQcH68MPP9SHH36ooKAgw+1q1qypLl26aNq0aUmu01OOX0lq0aKF1RfOPrZy5UoNHDhQBw4csLrN5s2bNXXqVL355ptq06aNPv30U+XJk+dJu5+fn2bNmmX4wlFPwHj3fzxlDEkuayvJsccfY4DjuPu5PWnSJLVq1coiXqxYMZUqVUp//vlngjkS67XXXrNaQ2K4++/SbM/KvfZn/X6iPdzp/kpi2bOOl5y7lodj1K5d2+oHTe7bt0/z589Pcu69e/da5I7v3q01Rl98euPGDZ05c8bqPu3atbP6Ztl333033ue5PYGnzEmetlZIzBr8t99+04ABA+JdkyW0Bvfy8tK0adM0ePBgm2tMjjztOHlagQIFNHz4cIu4K+ZST1yL2MoT7/m6s5o1ayb4ZdbLly/Xhx9+qGPHjsW73eNjr3Hjxho9erTFh2ONHDlSAwcOtK/gRHLk/RpX3NdK7D2tZ+1azhPHPK6/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwR/bs2fX8888/eXz16lXNnj07yfl++OEHderUSRUrVtSePXs0evRow+3WrVundevWqXTp0oqNjVV0dLTNfZ04cUJr1qxRo0aNnsQqVKig/fv3W92ne/fucR4fOHBAX375pc19Dxs2TK+88oqKFi36JPbmm29qx44dNucyW4YMGfThhx/GiQ0bNky3bt1Klv0CAAAAAAAAAAAAAAD3NmXKFLVv317Vq1e3aEuRIoVWrVql999/X99++61pfbZq1UpTpkxRaGioYfvHH3+sU6dOJTrfwoUL1bhxY4t4xowZNWbMGL322mtJqrNp06YaOnRokvZ91k2dOlWDBw9WhgwZ4sSDgoL0448/qkaNGoqMjLSrjzfeeOPJ3/abb75Rly5d1KNHD7d4jZCjXbhwQefPn1e2bNks2nr27MlxawVjBf7r+PHjhvE333xTS5YsSXLeoKAgLV682GL8M4u1898R5z5juaX33ntPR44c0eTJk5Oco1ChQpo/f758fHws2h49eqSxY8cmmMOTjt958+ZpyJAhypcvn0XbV199pRMnTmjlypVJzp85c2YtWrRI3t7ekqRGjRqpUaNGWrdunV599VVduXIlybmTaubMmWrQoIFeeeUVi7Zy5crp888/V//+/Z1akycdM4+x3kk61jyu9cMPP6hhw4ZxYs8//7wWLVqkRo0a6d69e3b3Ub58eeXNm9cifv78ebtzP+Yuc95jzl6X2Lom8ZR106JFizRixIg471N67IsvvtDx48e1fPnyJNdYuHBhzZ07N8n7P83Pz8/q+54k6Z133jGtLzO52/njbEeOHNHChQvVunVri7aePXvq5MmTGjNmTJLz58uXTz///LMCAwMt2u7fv68vvvgi0bk87Zx4zGiud8d5/lm8FvAUsbGx6tWrlzZt2mTR5u3trcmTJytTpkwaMWKEYmJibMrdpk0bzZgxQwEBASZVax5PvC6Kj6fNN55Wr9k8aX6UpNGjR6tQoUIW8YsXL1q8D9zIw4cP1b59e+3Zs0f+/v5x2goXLqyvv/5ab731lk01wVyeOCY6816Rp1zjOcODBw80Z84c9erVK068atWqKlq0qJo1a2axz7Rp05xUXfJl1vXw1q1btXjxYrVs2dKiLUuWLNq4caNq1aqlCxcuJLnW7Nmza/369cqUKZNh+/Tp03Xw4MFE56NmYxs3bjStXgAAkhtvVxcAAHCNFKFSwepS5fZS7bekGt2kCq9Iz5eQvH1dXZ37WL9+vb755hvDttSpU2v27Nny8vJyclWJM3XqVMN4UFCQWrRoYUof9erVU8aMGS3i0dHRmjVrlil9PCvCw8N1+/Ztwzajm7ruqFWrVkqTJo1F/N9//9XatWsT3P/+/ftWXyDQtm1bhYSE2F2jvd577z3DeGRkpGrUqKFRo0YpKirKppzHjx9X8+bN1a1bN8MPLQ4KCtJHH32UpHo9VUBAgBYsWKBWrVoZtt+6dcvmJ+/M9PHHHxse65L09ddfq1KlStq+fbtNOXft2qXKlStrw4YNVrfp16+fTTmfNmXKFKt1P3z4UF27dtULL7ygzZs3Jzrn6tWrVbp0aS1evNiwPUeOHHbXbavUqVNr3bp1atCggWF7TEyM3n77bQ0aNChJ+RctWmQYr1Onjl0v9PjvB49bY/TC5sRKmTKlatSoYRGPjY3VTz/9lOD+Pj4+mjZtmsWT14/98ccfKlWqlMaPH69Hjx4lmO/xWqF06dJWn9wrV66cevbsmWAuxDVy5Mg4jx+f37Vr19bWrVsTnWflypUqWbKkBg0apNjYWMNtgoOD9f3339tVr708dUx+lo0dO1a5cuUybIuJiVG/fv1UqlQprVmzJlH5YmNjNX/+fBUoUEDjxo2zul3p0qVNe1FEiRIl9Oqrr1rEN23apHLlyj05d5YvX67du3fr9OnT+ueff578u3Hjhl39f/bZZ3Fe/HXjxg3VrFlTH3zwgdVriv/avHmzKlasqD/++MPqNu+//7569+5tcS3y+++/q3jx4pozZ47VseGxmJgYff/996pZs6bu3LljuE2KFCn0+uuvJ1izKzny7232/Co5bo71xPHWk9e/5cqVs7gGHj16tEqWLKmff/45wf0jIyP18ccf68UXX9T169etbvfJJ5/I1zdpNwI96fhNmTKlvvvuO6vtERERat68uRo2bKgDBw4kKmdMTIzmzp2rYsWKWdyDK1iwoNNfEG0Gxru4PGUMSQ5rK8mxxx9jgON4wrm9bt06nTlzxrAtqW8eM/LCCy8Yvln51q1bVs/5//KE36XZnqV77c/q/cRnkb3reMk5a3k4ztP3Zv/r6S+8tJXRurNgwYLKkydPonP4+Piofv36FvFt27ZZ3SdfvnyaOHGiYdvChQuttnkST5iTPG2tkNAa/O7du3rllVdUr149/fnnn4nKGd8aPEOGDBowYIDNdSY3nnacGBk+fLj8/PzixJhLHccT7/m6q4CAAE2dOtXwjfvS/8a9pk2bqkmTJjp27Fii8y5fvlyFCxe2GFNDQ0Od8nt09PNhrrivZcs9La7l3BvXXwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmCNr1qxxHv/111+KiYmxK+ebb76pypUrq3z58po/f3682+7bt09//vlnkvvav39/nMdP/zz/lSFDBjVp0iRO7KOPPlJsbKzN/cbExOijjz6KE2vVqpVCQ0NtzmW2IUOGKCQk5Mnjf/75R+PGjUu2/QIAAAAAAAAAAAAAAPfXunVrhYWFGbb5+vrqm2++0ebNm1WpUiW7+smXL5/mz5+vhQsXWn0dx969e/Xll1/alHf+/Pm6ePGiYVvnzp01fPhwm2vt2rWrFi9eLG9v7yex48eP25znWXX37l0NHTrUsK1cuXLavHmzMmbMmOT8vXr10sSJE+PESpQooW3btqlu3bpJzutJNm3aZBjv37+/qlWr5txiPARjBf7rt99+M4y/9NJLev3115OUM0uWLNq6dasqVqz4JLZv374k5YqP0fnviHOfsfx/nh43Jk2apNGjR8vHx8fmXA0bNtTOnTuVOXNmw/bvvvtOx44dSzCPJx2/0dHRev/99w3b/Pz8tGzZMvXu3TtJuQsWLKjNmzcrZ86cFm2ZM2fW1atXk5TXDN26ddM///xj2Na3b1/VqlXLqfV40jHzX6x3koY1j2sNHjzY8D0QNWvW1Pr165U9e3a78qdOnVpTp041bFu1apVduZ/mDnPeY85el9i6JvGUddPDhw/Vp08fwzZfX18tXbpUH374YZJqrFWrlrZs2aI0adI8iV24cCFJuR7z8/PT22+/bfWfO3On88cVevfurdu3bxu2jR49Wj/88IP8/f1tzvvSSy9p9+7dypEjh2H7J598otOnTyc6n6edE49Zez+gu83zz+q1gKf4/fff9cMPP1ht//zzz3XgwAE1aNAgzrFhTenSpbVmzRrNmzdPAQEBT+KXLl1SRESEKTXby1Ovi+LjafONp9VrNk+ZH5s0aaIePXoYtnXp0kU3b95MVJ6DBw9qyJAhhm09e/a0eD85nMtTx0Rn3SvylGs8Z5k0aZJFzMvLS3PnzlVwcHCc+M2bN/XLL784q7Rky8zr4d69e+vGjRuGbQUKFNCff/6Z5DG5WbNm2rdvn/Lly2fYfunSJfXr18/mvNQcV7NmzUyvF/+PvfsMj6pa/z7+S6WFTqgC0nuX3qVIlXLoHY5KEUUURUXlgIoKIuoRC9IEpCSA0qs06b13UOkEQieE1OfFeeBPmD0pM3tmspPv57q4dO61973uJHvWWnvNZAIASEkS3rkCAKQo2fJLL74vDZ4rvfieVLuHVLm1VLW9VL+f1OUL6bV5Uu2ekn96T1ebPAwfPlyHDh0ybGvQoIHdF/Q8LTg4WHfv3jVs6927tyl92MuzYsUKXb582ZQ+UhN7b1jLmzevmytxzIABAwzj06ZNS/QH4k6ePNkwniFDBnXv3t3h2syQI0cOu78QNmzYMG3fvt2p/D///LMGDRpkE79y5YpOnz7tVG6r8PHxUbdu3XTixAl17NjR7nF9+/a1u5noal5eXsqTJ49h2/jx4zVs2DCHP/D63r176tixo91fTnzxxRftbnQmpGfPnmrQoIFh2507d9SkSRO7z7+EhIWFqXPnzlq4cKFh+2uvvWbzYoirPHqxrVatWobtERER6tq1qyZOnOhwH8HBwYbxDBkyqHHjxg7lfPbZZ1WmTJkEjytYsKBKly7tUB/Nmzc3fDF969atduefJ7322mt2+962bZvq1KmTqDxPu3r1qp5//nkdPHjQsP2TTz5RQEBAkvOmZrly5Xr8/5GRkWrdurXDz29J+vTTT9WhQwdFRUUZtjdu3Fht27Z1OL8zrDomp2bPP/+8evbsadgWHh6udu3aaezYsQ7ljoyM1Ouvv66BAwfaXXu+/fbbKlu2rEP5n/Taa6/Jy8vr8eOoqCgNGDBADRs21O7du53On5AqVao8/v87d+6oUaNG2rRpU5Jy3L17V82bN9etW7cM26tVq2bzpo9NmzapWbNmun79epL62rNnT7z3oIMGDUrUGyw9xZU/b1fNr5K5c6wVx9uUtv5944039NZbbykyMjJJ5+3atUtNmza1e94zzzzj8DxuletX+t8vqdm7hq9evapatWrp999/d6RUPXjwQC+99JLGjRvn0PnJCePd/7HKGJJS1laSa68/xgDXscpz297ztVu3bvLz83Oovqf17dvXMD5r1iyFh4cneL5VvpdmSW177al1PxGOr+Ml167l4Rpdu3ZVpUqVDNtWrlypdevWOZV/6dKlhvGk/GJE165d4/yy9iPLli0zPD5NmjQKDg42nCfOnDmjl156KdF9J1dWmZOstlaIbw1+/fp11alTx+78mBB7a3B7vxSamnj6OjHDc889F+cxc6nrWHHPNzl7++23DT+wQ5Ju376tJk2aaPHixQ7ljoyM1GuvvWbzASjOfvBWYrhyv8aT+1qJ3dPiXs5amDMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHCMn59fnMfh4eFO5zx48KC2bt3qdJ7EuHXrVpzH6dKls3ts06ZN43y9oaGhWrlypcN9L1++XDdu3Hj8OH369GrYsKHD+cxQuHBh9e/fP07sgw8+UERERIrsFwAAAAAAAAAAAAAAWMPVq1f14osv6u7du3aPqVu3rrZu3aqtW7dq0KBBKlKkSKJyZ82aVV27dtWiRYt07Ngxde7c2e6xf//9t9q2bauYmJgk1R8VFaUJEybYbX/vvfe0bNkyFStWLMFclStX1ooVKzRp0iT5+vo+ju/atUu///57kupK7X744Qdt3LjRsK1y5co6fPiwBg0aFOf7nJBy5cppxYoV+uabb+Tt7W3TvmvXLq1Zs8bhmq3kxx9/NIz7+/tr7dq1+vzzz1WwYEE3V5W8MVbgSX/++aeuX79u2DZp0iR9+OGHiR6f/P399frrr+vAgQOqVKnS4/itW7f00UcfmVLvk4ye/6567jOWSz/99JNOnz4dJzZ06FAdPXpUHTp0kJeXV4I5ypUrp8WLF2vp0qXKlCmT4TF///13oq8Xq12/S5Ys0fTp0w3bfHx89PXXX2v37t1q2rRpovIFBATogw8+0J49ewzH7NjYWL3xxhuKjY11pmyn3L59W927dzdc13p5eWnmzJnKkSOH2+qx2jXzCOsdx7Dm8ax9+/bphx9+MGyrWbOmjh49qg8//NChMeCFF17Qzp07VbZsWcP24ODgJOd82t69e+M89vSc9yR3r0uSuiaxyrppwYIFWrp0qWGbt7e3xo4dq7179+qFF15IVL6SJUtqxowZWrNmjbJly/Y4Hh4erg8++CBJtVldcn7+uNvVq1c1YMAAu+39+/fXyZMn1aNHj0Q9J8qUKaPffvtNq1evVpYsWQyP2bx5s8aNG5fkWq34nIiKirLbltzm+dR4L2Alr7/+unbs2GG3vWzZslq2bJmuX7+uX3/9VR988IFefvlldejQQb1799bw4cP1ww8/6K+//tKePXvUpEkTmxwDBgww5XdizWDV+6KnWW2+sVq9rmSF+TFPnjyaOnWqYdv333+vVatWJTqXJI0bN87u77NPnTpVuXPnTlI+mMeqY6I794qsco/nDkeOHNH27dtt4uXKlbOJzZ49m88vSGYuXbqkPn362F0jBwYGatGiRdq4caM6duyoDBkyxJsvICBAHTt21KZNm/Tbb7/Z3eOKjo5Wjx49FBoaSs0m1Gx2vQAApCSJX5EDACyvbBOp6WuSr3/8x6XJINXuLpVuKC38jxR6zi3lJVsRERHq2rWr9uzZozRp0ti0f/rpp1q7dq3279/v/uLi8eDBA82dO1cvv/yyTVvDhg2VP39+nT9/3uH8mTNn1osvvmjYNmXKFIfzpma3b982jCe0EZIclC5dWrVr17aJx8bG2n3hxMi+ffu0f/9+VaxY0aZt4MCBdje53aFixYqGL87dvn1b06ZNM6WPSZMmqXnz5mrbtq2OHj2qL7/8Ur/++muK3TTOlCmTihcvrjJlyqh+/fpq06ZNnDeKPC02NlZDhgzx6BsvY2Nj1aZNG1WqVEkffvih2rZtKy8vL23btk3vvPOO0/lv3Lihd955RzNmzLBp8/LyUvPmzXXq1Kkk5fTy8or3Bad+/frZfUEnsWJiYtSrVy+VLVtWxYsXlyRFRkbq119/1RdffKH79+87lT8xihcvrtWrV9t9oevu3btq27at1q1b51Q/hw4d0okTJ1SiRAmbtrZt22rZsmVJztm6dWub2Llz51SgQAGbeKtWrXT06NEk99GuXTvDeGLeNOvr66vhw4cbtl29elUdOnRw6o0t4eHhat++vfbv36+AgIA4bVmyZFGfPn303XffOZw/NRs6dGiS36RgZOHChXr33Xf15ZdfGra/8847HhmbrTgmp3affPKJ3bbBgwdr8eLFTvfx448/Kn/+/Hr//fdt2nx9fTVy5Eh17NjRqT4aN278+P8fPnyoNm3amPJcc8RLL73k8L3otWvXNHr0aH311VeG7WnTpn38/1euXFHHjh0dHu9///13rV+/3vCPWxQoUEDVq1fXtm3bHMrtaq76ebt6fpXMm2OtNt6mtPXvhAkT9M033zh8/t69ezVmzBiNHDnSsL179+6aP39+knJa6foNCAjQwIEDDduio6PVqVMnHTp0yKlapf+th0qUKGF3r8wKGO/+x0pjSEpZW0muu/4YA1zHSs/tqVOnatSoUTZvVs6ePbtat26thQsXOlVn2rRp1alTJ8O2SZMmJXi+lb6XZklte+2pcT8Rzq/jJdes5eEafn5++vTTTw3bYmJiTLl33rdvnzZu3Kj69evHiQ8cOFAzZszQvn374j0/Z86cGjNmjE38xo0bhvfjkvTNN9+oQoUKNvGHDx+qY8eO8X7QplVYYU6y2lohQ4YMdn/5MyYmRt26dUvwek2M1LgGj09yuE7MxlzqWlbb803O0qVLp7feestue69evUz5g+cjRoxQqVKl7K7TXcGVr4d5cl8rsXta3MtZB3MGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACOu3nzZpzHOXPm9FAljsmaNWucx3fv3rV7bNWqVeM8Xrp0qaKjox3uOyoqSkuXLlWvXr0ex5577jktWrTI4ZzO+uyzz+Tn5/f48YEDBzRr1qwU2y8AAAAAAAAAAAAAALCOXbt2qXnz5lqxYoUyZsxo97iaNWuqZs2akqRr167p9OnTOn/+vO7du6cHDx7I19dXmTNnVtasWVW6dGnlz58/Uf1funRJzz//vC5evOhQ/RMmTFCbNm1Up04dw/YWLVqoWbNm2r59u1atWqVz587p2rVr8vLyUrZs2VSuXDk1adJEFSpUsDn34cOH6tevn7p37+5QbalZp06dtGvXLhUoUMCmLTAwUBMnTtRHH32kFStWaO3atTp//rxCQkIUFhYmf39/ZcyYUQUKFFD58uXVokUL1ahRw25fly9fVseOHRUTE+PKLynZ2LJlizZv3mx4zfv5+Wn48OEaPny4Ll68qHPnzunu3buG35urV6+qT58+bqg4eWCswCMPHz7Up59+qgkTJti0eXt7a/To0RowYIBmzpypTZs26cSJE7p165bCw8OVOXNm5cyZU0WLFtULL7ygli1bKk+ePHFyxMbGqnfv3rp27Zrptdt7/rvquZ/ax/Lw8HD17NlTGzdulL+//+N48eLFFRwcrOvXr2vlypXas2ePrly5ops3bypjxozKlSuXihUrpmbNmqlEiRLx9vHgwQO1bds23vfZPsmK1++AAQNUvHhx1apVy7C9SpUqWrVqla5du6bVq1dr3759CgkJUWhoqCQpc+bMKlSokKpVq6amTZsqXbp0dvv67LPP9Mcff5hWu6M2b96szz77TCNGjLBpy5Mnj6ZPn65WrVq5pRYrXjMS6x1nsObxrKFDh6patWp67rnnbNoCAgI0evRoffjhh9q6das2bNigY8eO6e+//9bdu3cVFhYmLy8vZciQQVmyZFGRIkVUqVIltWjRQsWKFbPb55IlS7Rlyxana+/bt6927typNGnSPI55cs57mrvWJY6uSayyburRo4d2796tokWLGrZXqlRJK1eu1JUrV7RixQodPHhQV69e1c2bN5UmTRply5ZNZcuWVcOGDVWpUiXDHEOGDNHZs2eTXJuVJffnj7vNnTtXZcuWNVwLSVLBggU1c+ZMfffdd1q1apV27typK1euKDQ0VBkyZHj8vWnevHmC35uzZ8+qbdu2Dv8emhWfE/bWSFLym+dT472AVURGRqpZs2Zas2aN4brlkaxZs6pbt25Jzv/JJ59o8eLFzpRoKqveFz3NavON1ep1teQ+P86cOVPZs2e3iZ86dUrDhg1LdJ5HYmJi1LNnTx08eFAZMmSI05Y9e3bNnDlTTZo0SXJeOM+qY6K794qsco/nDpMmTYq3/kemTp3qhmqQVEuWLNHQoUP19ddf2z2mXr16qlevniIjI3XkyBGdOnVKt27dUkREhNKkSaMsWbKoaNGiKlOmTJzPrbBnwIABWrduHTW7sGZn6wUAIKXw9XQBAAD3qNhKajo4aedkzSt1Hy/NHCLdvOSauqziyJEjGj58uOFNq7+/v2bPnq3KlSsrPDzc/cXFY8qUKXr55Zdt4l5eXurevbs+//xzh3N37tw5zosXj1y7dk1Lly51OG9q9uDBA8N4fC/wJhcDBgwwjP/xxx/6559/kpRr8uTJ+u6772zi5cuXV/Xq1bVjxw6HanRW3rx5DeNHjhzRw4cPTevnrbfe0qRJk7RixQrTcrrK/v37k/xGEy8vL6VPn14BAQHy8vJK9Hm3b9/Wyy+/rODg4KSW6RL79u1T+/btVaZMGX3wwQf68ssvTXuBYt68eZowYYLhi4716tXTt99+m6R8rVq1svuGnh9//FELFixwqM6n3b9/X4MGDdKiRYs0adIkjR8/3uFfcEyqKlWqaOXKlcqRI4dhe0hIiJo1a6Z9+/aZ0t/8+fMNX7Bu3bq1vLy8FBsbm6R8rVu3ton99NNP6tatm8qUKWNz7NixY5OU39fXVy1atLCJx8bGJurn36FDB+XOnduw7c0339SlS84vFM+cOaOff/5ZQ4cOtWkbNGiQ4byA+P3555+aOHGiafnGjx+v559/3vBaqlmzpqpUqaI9e/aY1l9SWGlMTs2e/KX6p82aNUtTpkwxra8PP/xQtWrVUoMGDWza2rdvryJFiujMmTMO539yDfPWW29p1apVDudyxu+//+702mjSpEn69NNPE7znGDp0qEJCQpzqa8KECWrYsKFhW/Xq1bVt2zan8ruKq37e7phfJXPnWKuMtylp/XvkyBG98847Tuf54osvNHToUGXKlMmmrVGjRvLx8UnSvZ2Vrt9evXrZ/dCX0aNHa9OmTU7X+chLL72kU6dOKXPmzKbldCfGu/+xyhiSktZWkuuuP8YA17HSc/vKlStatmyZ2rRpY9PWt29fLVy40Kka27VrZzjH7tixQ4cOHUrwfCt9L82SGvfaU9t+Ympn1jpeMn8tD9cYOHCgChUqZNg2c+bMRM0HifHpp5+qfv36cWJp0qTRihUr1KVLF23YsMHwvBIlSmjevHmGH2I5YcIEw9eoO3furP79+xvme+utt0x7vcXTrDAnWW2t0Lt3b8MxS5LGjh2rNWvWOFXnk1LbGjw+yeE6MRNzqftYZc83OevevbuyZMli2DZt2jRTPySif//+qlu3rt33RZjNVfs1yWFfK7F7WtzLJX/MGQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOOfixYuKjY2Vl5eXJKlChQrKli2bbty44eHKEqdKlSpxHp88edLusc8991ycx7t373a6/z179qhXr152+3CnKlWqqGPHjnFi77zzjmJjY1NkvwAAAAAAAAAAAAAAwHq2bNmi6tWra9GiRSpWrFiCxwcGBiowMFA1a9Z0qt/t27erU6dOOn/+vMM5oqOj1blzZ+3fv1+BgYGGx3h7e6tWrVqqVatWovPGxsZqwIABOnz4sMO1pWYhISFq3Lix1q1bp2eeecbwmFy5cqlPnz7q06ePw/1cvXpVL7zwgs6dO+dwDivq1auXDhw4oIwZM9o9Jl++fMqXL5/d9r///tsFlSVfjBV40vfff69evXqpUqVKhu158+bV8OHDNXz48CTnHj58uBYvXqxq1ao5W6ahhJ7/Zj73Gcv/t1YZMGCApkyZ8vg9vY/kyJFDPXr0UI8ePRzK/eDBA7Vv314HDhxI0nlWu34fPnyoFi1aaNmyZapdu7bd4wIDA9W9e3d1797doX4mT56sDz74wNEyTTdy5Eg1btxY1atXt2lr2bKlXnvtNf33v/91Sy1Wu2YeYb3jGNY8nhUREaHmzZtr1apVqly5suExfn5+ql+/vurXr+90f9evX9fAgQOdziNJBw8eVM+ePTVv3rxkM+c9yR3rEmfWJFZZN92+fVvNmjXTH3/8oYIFC9o9Lnfu3Orbt2+S83/77beaNGmS6tWr51B9VpXcnz+e8MEHH8jLy0vvv/++3WMyZ86sTp06qVOnTg71cfToUTVr1kyhoaGOlmnJ54SV5vnUei9gFbdu3VKjRo00Y8YMtWnTxrS8X375pT788EPT8pnFqvdFT7LafGO1et0huc6Pw4YNU6NGjWzi0dHR6tGjhx48eOBQLWfPntVbb72lH3/80aatcePGeuuttzR+/HiHcsM5Vh0T3blXZJV7PHeYN2+evv76a2XKlMnuMYcOHdLevXvdWBWS4ptvvpG3t7fGjx9vMyc/yc/PTxUrVlTFihUd6ic6OlqvvfaaJk+e7GCl/4eajZlZLwAAKYG3pwsAALhevtJSYwffE5E2o9R+lOTta25NVvTNN99ozZo1hm2lSpXSl19+6eaKErZjxw4dPXrUsK13795O5bZ3/owZMxQVFeVU7tQqIiLCMJ42bVo3V5I0adOmVc+ePQ3bHNmA+fXXXxUeHm7YNmDAgCTnM4u9n8OtW7dM7efs2bNasWKFqTldJTAwULlz507Sv1y5ciljxozxbv49KTY2Vr/++qvKli2r4OBgF39FSXfkyBF17dpVe/bsMS1nRESElixZYthWt27dJOez90adiIgIjRw5Msn54vPHH38oT548evPNN3Xx4kVTc9vTuHFjbdiwQTly5DBsP3v2rGrWrKl9+/aZ1mdQUJBhPFeuXIZveI9PQECA4ZtglyxZYngd1KxZU9myZUtSH/Xr11fmzJlt4jt27NCFCxcSPN/ei3hnzpzR3Llzk1RLfCZMmKDo6GibeKlSpVSkSBHT+kkt3n77bdNzjho1ym5bly5dTO8vqawwJqdmr7zyimE8Kioq3jcAOSImJkbvvvuuYZu3t7f69etnSj/Lli3TxIkTTcmVVLGxsQ69GeVp9+/fT3DtefDgQVPG+1WrVunOnTuGbc5+wII7mP3zdtf8Kpk/xyb38TYlrX+HDBliyh7LgwcPNHv2bMO2jBkzqmTJkknKZ6Xr194a5e7du5owYYLT9T3p2rVr+uyzz0zN6QmpfbyzyhiSEtdWkvnXH2OA61jtuT1p0iTDePPmzZUrVy6n6rM3btjr82lW+16aITXutae2/cTUzqx1vGT+Wh7my5gxo91fAA0PDzf1l3XXrFmj77//3iaeK1curVu3TuvXr9fw4cPVvXt3de7cWUOGDNFvv/2mgwcPqkKFCjbn7dy5U59//rlNvEiRIvr5558Na1i4cGG867VcuXKpX79+Gj9+vGbNmqXly5crODhY3333nd5++23DOjzJCnOS1dYK9tbgYWFh+uKLL5yq72mpbQ0en+RwnZi5nmQudb/kvuebnNl7/1xERIQpr+M86dq1ax55f6LZ+zXJYV8rsXta3Mslf8wZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA45+bNmzpy5Mjjx76+vho9erQHK0q8kiVLqnHjxo8fR0ZGas2aNXaPL1asWJzHhw8fdrqGQ4cOxduHO40bN05eXl6PH//xxx9avXp1iu0XAAAAAAAAAAAAAABY07Fjx/Tcc8/phx9+UGxsrEv7io6O1rhx41S3bl2dP3/e6XyXLl1S3bp1debMGROqk2JiYjR48GBNnz7dlHyp1alTp1SzZk3t3LnTJfn37t2r5557zua9QqnBX3/9pfbt2+v27dueLsVSGCvwSEREhJo3b66//vrLtJyRkZHq37+/xo0bZ1pOI+5+/jOWS9OmTVOfPn0UGRlpWs6rV6+qadOmWrlyZZLPteL1e/v2bTVu3FhTp041PXdMTIzGjBmjl19+2eVr2KSIjo5Wt27ddPfuXcP2cePGqXz58m6pxYrXjMR6xxmseTzr+vXratCggX7//XeX9nPhwgXVqVNHFy9eNC1ncHCwunTpovDwcNNyOjPnPc3V6xJn1yRWWTedOXNGtWvX1t69e02q7H8+//xzDRkyxNScVpLcnz+eMGLECL300ku6f/++6bmXLVum2rVrm7KvaLXnhNXm+dR4L2Ald+7cUdu2bdW/f3+FhoY6lSs0NFTdu3fX22+/bVJ15rLqfdHTrDbfWK1ed0hu82PlypU1ZswYw7YxY8Y4vbb96aef7P6sPvvsM1WqVMmp/HCMVcdE9sY9IywsTHPmzIn3GFes9WCuCRMmqF27dk6v+ewJCQlR69at9cMPP5iWk5rjckW9AABYnbenCwAAuF7DlyVvH8fPz55fqtjCvHqsrHfv3nZvWF999VU1b97czRUlbMqUKYbxkiVLqkqVKg7lLFKkiGrVqmXYxiaX4+y9WPvkB6EmR506dVKWLFls4jdu3NBvv/2W5Hy3bt3SwoULDds6d+6szJkzJzmnGey9UJctWzY3V5K6XLt2TYcOHVJUVJSnS3Erey+q5MyZU+nSpUt0Hl9f3zgfav2k2bNnKyQkxKH64mPvDd+u0KlTJy1btkwBAQGG7fv27VPNmjV19uxZU/s9ePCgTp48adjWrl27JOV64YUX5O/vHyf2zz//6NChQ1q0aJHN8T4+Pkleb9irKSgoKMFz06RJo3r16hm2TZw4UTExMUmqJT7nz5/XwYMHDduaNWtmWj+pwd69e7Vjxw7T8+7cuVNbt241bHvhhRdM7y+5MGtMTs28vLzUooXxTWVwcLApb2B92o4dO7RlyxbDtlatWpnSx6hRo0zJ44i1a9fanYuSat26dfG2f//996b0ExERoW3bthm2VaxY0ZQ+XMnMn7c751fJOnOsGeNtSlr/7t+/X3/88Ydp+RYvXmy3rVy5conOY6XrN2PGjKpZs6Zh25QpU1zys5s0aZKpb/T1hNQ83lllDEmpayvJ3OuPMcB1rPbclqSVK1fqwoULNnEfHx/16NHD4dry5cunRo0a2cTv3r2refPmJXi+Fb+XZkiNe+2paT8xtTN7HS+Zt5aHawwfPlw5cuQwbPv2228N5x9nDB061HB/xcvLSw0aNNDnn3+uWbNmae7cufr666/Vtm1bmzFDkq5cuaIuXbrYvP7m7++v4OBgZcyY0eacv/76S/369TOsq0aNGtqwYYMuX76sKVOm6M0331T37t3VvHlzdejQQa+++qrGjh2r/fv369y5cxowYIC8vT3/tsXkPidZba0QEBBgdw3+yy+/6NatW86UZyi1rMHjk1yuE7PWk8ylKUtKf40tY8aMqlGjhmHbvHnzdO3aNdP7nDJliiIiIkzPGx8z92uS075WYva0uJdL3pgzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwx/Tp0+M8fvXVV/Xxxx/Lx8fHMwUlQmBgoObPny9fX9/HsWnTpik0NNTuOZkzZ47z+OLFi07XcenSpXj7cJcXXnhBDRs2fPw4NjZWb7/9dortFwAAAAAAAAAAAAAAWNudO3c0aNAgVa9eXUuXLlVsbKyp+WNjYzVv3jyVKlVK77zzjqKiokzLfeLECVWrVk0rVqxwKs+1a9fUrFkzff/99yZVlrpduHBBderU0YgRIxQWFmZKzrCwMA0fPlzVqlXThQsXTMlpRWvXrlW1atX0559/eroUS2GswCNXr15V9erVtWzZMqdzHTx4UNWqVdOkSZNMqCxh7n7+M5ZLM2bMUK1atXTq1CmncwUHB6tMmTLavHmzwzmseP2Gh4fr3//+t1588UWdPXvWlJxnzpxRkyZNNGLECFPyme3s2bMaPHiwYVuaNGk0b948pUuXzi21WPGakVjvOIM1j2fdvXtX7dq1U8eOHXXu3DlTc8fGxmrWrFmqWrWqTpw4YWpuSQoKClKNGjW0f/9+p3OZMec9zZXrEjPWJFZZN128eFHVq1fX6NGj9fDhQ6dyXb9+XW3atNF7771nSm1WltyfP54wZcoUlStXTitXrjQl3+XLl9WzZ0+1atVKt27dMiWnZL3nhNXm+dR4L2A1kyZN0rPPPqsRI0bozJkzSTo3JCREo0ePVokSJTR79mwXVWgOq94XPc1q843V6nWH5DI/pk+fXnPmzJGfn59N2549ezR69GhT6uvXr59u3LhhE/fz89PcuXOVPn16U/pB0lh1TGRv3DPi+9lGRkZq1qxZbqwGjlq0aJFKly6tmTNnKiYmxpSc0dHRmj59ukqXLu30/YkRanZ9vQAAWJm3pwsAALhWrmJS3lLO56n8ovM5UoLLly/r5Zdftts+bdo0BQYGurGihM2cOVORkZGGbb1793Yop73zduzYoaNHjzqUE9Y1YMAAw/isWbMUERHhUM7JkycbxtOlS6eePXs6lNNZ165dM4xXqFBBadOmdXM1qUfOnDn1+eef69y5c5owYYKyZMni6ZLc4vDhw3bbsmXLlug8tWrVUsaMGQ3bZsyYkeS6kpNBgwZpzpw58vf3N2xfv3696tevr5CQEJf0P3/+fMN4mzZtkpSndevWNrHFixdL+t+8alS/0TnxefFF44XcggULEjy3du3adt+kb9YL9U/asmWLYbxy5cqm95WSzZ0712W5582bZxgvV65cslsHm8WsMTk1q1KlinLmzGnYNm3aNJf1ay93+fLl9cwzzziVe9euXdq1a5dTOZwRFBRkWq74rnFJ+u2331zeV3J/Lpn983b3/CpZY441Y7xNSetfs99EtHv3brtt+fPnT3QeK12/devWjfNHfp5kb03jrJs3b2r16tUuye0OqX28s8oYkhLXVpL51x9jgOtY7bktSTExMZo6daphW79+/Ryuq2fPnvL2tn3LxZw5c3T//v0Ez7fi99IMqXWvPbXsJ6Z2rvhlALPW8jBf7ty5NXToUMO2GzduaMyYMab3GRERoUaNGmnp0qUO5zh16pRq1qypv/76y6ZtwoQJqlSpkk08MjJSnTt31u3bt+PE/fz8NGXKFG3btk3169eXl5dXgv3nz59fP/zwgw4ePKiiRYs6/HWYIbnPSVZbK8S3BnfVL0ynljV4fJLLdWLWepK5NGVJ6a+xNWjQwO64Z+8e1FnXr1835ReZE8vs/ZrktK+V2D0t7uWSL+YMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADM8eOPP+qvv/6KE/vggw905MgRvf766ypSpIiHKrMVEBCgV155RYcPH1aZMmUex48cOaJhw4bZPc/f319p0qSJE7t3757T9dy9ezfO48yZMzudM6m8vLw0duzYOLE5c+Zo3759KbJfAAAAAAAAAAAAAACQcuzatUutW7dW2bJl9dlnn+ns2bNO5Tt16pRGjx6tUqVKqUuXLjp16pRJlcZ148YNtWjRQs8//7y2bduWpHNv3bqlcePGqWjRolqzZo1L6kutIiMjNWbMGBUqVEiffvqpLly44FCe8+fP66OPPlL+/Pk1duxYRUdHm1yp9Zw8eVL16tVT9erV9dNPP+ngwYOKiYnxdFnJHmMFHrl27ZpatWqljh07avPmzUk+f+/everSpYsqVqyo/fv3m19gPB49/9313Gcsl3bv3q0yZcpo4MCBSV4bhYeHKzg4WJUrV1anTp0UGhrqdD1WvX6XLFmiEiVKqHv37tqyZYtiY2OTnOPAgQPq37+/SpQooXXr1rmgSvPMmDFDc+fONWwrWbKkvvnmG7fVYtVrhvWO41jzeN78+fNVqFAhdezYUWvXrtXDhw8dznXz5k1NnTpV1atXV8+ePXXlyhUTK43rwIEDeu6559S7d28dO3YsSee6Ys57mqvWJcm9PrPXTVFRURo5cqSeffZZjR8/XteuXUvS+SEhIRo9erQKFy6sxYsXm1qblSX3548n/PXXX2revLmqVq2qoKAghYWFJTnH/v371b9/fz377LOaNWuWC6q03nPCivN8arsXsJp79+5pzJgxKlq0qCpXrqzBgwdr6tSpWrt2rXbt2qVjx45p37592rRpk2bOnKn33ntPNWvWVJ48eTRy5EjDMevp3xt9JCoqytVfjl1WvS96mtXmG6vV6w7JYX789ttvVbx4cZv4gwcP1KNHD9Oeq5cvX9agQYMM24oXL+7WvRHEZdUx0d17RVa5x3OlvXv32v2cgmXLlun69eturgiOCgkJUa9evVS6dGn997//dfhnd+3aNX377bcqXbq0+vbt69L5ObXX7I56AQCwKl9PFwAAcK0iVc3Jk+0ZKXMu6fZVc/JZ2W+//aapU6eqX79+Nm25cuXS1KlT1bp1aw9UZuzatWtaunSp2rVrZ9PWtWtXvfnmm0neyO7Zs6dhfPLkyQ7VCOsqW7asatasadjmzPWwfv16nT17VoULF7ZpGzBggL777juHczvq9OnThvF06dJpyJAh+uKLL9xcUeri5+enN954Q927d1enTp20YcMGT5fkUjdv3rTbljVrVl28eDFReSpUqGAYj46O1o4dOxyqLTkYNWqUPvroI7vtwcHB6tGjhyIiIlxWQ1BQkN5//32beIkSJVS8eHGdPHkywRxeXl5q0aKFTfzRG6ZiY2O1bNky9e3bN057s2bN5OPjk6gXySpVqqT8+fPbxHfu3Klz584leL69a+jSpUtJftNCYhw8eNAwXqpUKdP7SsnWr1/vstzxvcGudOnS2rhxo8v69hSzxuTUrHLlyobxmJiYJL9pMyniewNHhQoVHH7TgvS/P1LgSWa+6TO+Oevo0aMKCQkxra8TJ04YxrNkyWJaH65g9s/b3fOrZI051ozxNiWtf1etWmVqvmvXrunq1avKlSuXTZtRzB4rXb9P/pGfJ0VERGjv3r1O12XP2rVr9eKLL7osvyul9vHOKmNISlxbSeZff4wBrmO15/YjkydP1gcffCBvb+848dKlS+u5557T7t27k1zX03s2j0yaNClR51v1e+ms1LrXnlr2E1M7s9fxknlreZjvP//5j9KnT2/Y9sknn+j27dsu6ffBgwdq06aNBg0apFGjRilbtmyJOi8yMlI//PCDRo4cqVu3btm0d+jQwe4vrb3zzjvatWtXnFhAQIAWLVqk559/Pslfg/S/9drWrVvVokULh+ZhMyT3OclqawV7a/CoqCiX/oxTwxo8PsnlOjFrPclcmrKk9NfYypUrZxiPjIzU9u3bXdbv5s2bDd8H6Apm79ckt32txOxpcS+XfDFnAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgjvv376t9+/Zav369smTJ8jheokQJffPNN/rmm29048YNXbhw4XFbnjx5lDt3bl25csXUWp577jmNHDkyTszLy0vp0qVTrly5VLJkSfn4+MRpP3PmjFq0aKG7d+/azZspUyab2L1795yu9+k+/fz8lDZtWoWHhzudO7F69Oih8uXLP34cERGhESNGpNh+AQAAAAAAAAAAAABAynP06FG9//77ev/991WgQAHVrFlTlSpVUqFChVSwYEFlzJhR6dOnV9q0aRUVFaXbt2/r1q1bunnzpo4cOaJ9+/Zp3759OnnypFvrXr9+vWrVqqX8+fPrhRdeUIMGDZQ3b14FBgYqW7ZsioqK0q1btxQSEqJ9+/Zpy5YtWrFihSIiIgzzvffee3rvvfecrsvLy8vpHFbq92khISH64IMP9MEHH+i5555TnTp1VKVKFRUsWFA5c+ZUhgwZ5Ovrq4iICN25c0e3bt3SiRMndOTIEf3xxx86ePCgabW463vSt29f9e3b1+X97Ny5Uzt37pQkZciQQXny5FGWLFmUNWtW+fn5GZ7z4MEDl9f1tORyLT6SHMcKd36P3HV9JpUnrpP58+dr/vz5KlGihOrUqaOaNWuqaNGicZ5Hd+/e1a1bt3Ts2DHt27dPy5Yt0+nTp+3m3Llzp1u+lgEDBkhy33M/OY3lZkrszyoyMlI//vijfvzxR1WpUkVNmjRRxYoVVaRIEWXOnFkBAQEKDw/X7du3deXKFR08eFA7d+7UypUrdf/+fZfUbsXrNyoqSrNnz9bs2bOVO3duNWjQQDVq1FDRokWVP39+BQQEKF26dIqJiXm8vjx+/Lj27t2rdevW6dixY6bU4a7xpmvXruratatb+koMK14zj/qwwnrnaaNHj9bo0aM9WkNyXPNI5j0Hk9sa82kxMTGPn3fp06dX/fr1Vb58eZUsWVJFihRRxowZFRAQoAwZMig2Nlb37t3T3bt3defOHZ05c0YHDx7UwYMHtWXLFkVFRbmt7ujoaM2YMUMzZsxQ2bJl1aJFC1WsWFHFixdXpkyZPDLnPS25r0uSe32PXLlyRcOGDdM777yjevXqqU6dOqpQoYKeffbZx+ubsLAw3blzR+fPn9f+/fu1adMmrV+/XjExMYY5N23a5NRzMywsLM7569evV4MGDRzO527J6fmTnMbI3bt3q3PnzkqbNq2aNGmiatWqqXz58sqXL9/ja+3hw4e6ffu2bty4oSNHjujAgQNavXq1/vnnH7fVmRyfE/FJrvO8PSntXiCl7uM82td3hre3tzJmzGjYlhzW6Va9L3pScppvrFhvcpkjPTk/vvTSS3rppZdM+kriN2/ePM2bN8/h8600bjdv3tzlfXz11Vf66quvTMtn1THR3XtFye0ez93j2I0bNwzjU6dOdWsd7rZw4UK3fq/ddT984sQJvf766xo6dKiqVKmievXqqUyZMipSpIiyZ8+ugIAA+fv7KyIiQvfu3VNoaKjOnDmjw4cPa9OmTdq7d6+io6NNr4uaPV8zAABW4uvpAgAArpW9gHm5suWXbl81L5+Vvf7666pfv76KFCli09aqVSu98sormjRpkgcqMzZlyhS1a9fOJp4jRw41b95cS5YsSXSuunXr6tlnn7WJh4WFObWBDdl8CO0jkZGRbq4k8fr3728Y3717tw4dOuRU7qlTp+qTTz6xiZcpU0a1atXS1q1bncqfVKdOndI///yjggUL2rR9+umnunnzZrJ63rvDlClT4v2Q5IT4+/srICBAGTNm1DPPPKMyZcooffr08Z4TGBiotWvXql+/fpoxY4bDfSd3t2/fttv25IdqJ6R06dKG8QMHDigsLCypZXmcl5eXvv/++8e/+GHk+++/1+DBgxUbG+vSWg4cOKBTp06pWLFiNm1t2rTRuHHjEsxRo0YNBQYGxonduXNHGzdufPx40aJFNm9yyZw5s+rUqRPnOHuM5n9JCg4OTvBcSSpZsqRh/MiRI4k6P6nsvZBmNPbCWExMjA4cOOCy/Pv371d4eLjSpk1r01a8ePFEXZdWY9aYnJqVKVPGMH7w4EFT/oCCPSdOnFBoaKiyZ89u01a6dGktW7bM4dzbt293pjSnhIWF6ezZs6blu3Xrlt02Z9f0ie3L19dX6dOnT7brE7N/3u6eXyVrzLFmjLcpZf378OFDHT161PS8N27cUK5cuWzi6dKlS3QOK12/JUqUMIzv27fP7i8AmGH37t0uy+1qqX28s8oYkhLXVpL51x9jgOtY7bn9yPnz57V69Wo1a9bMpq1v375J/tnVqFFDxYsXt4nv379fe/bsSVQOq34vnZVa99pTy35iauaqdbxkzloe5ipatKj+/e9/G7b9888/mjhxokv7j4mJ0XfffaeZM2eqR48eat26terXr2+zbxsdHa09e/Zo6dKlmj17ts6cOWOYr3DhwpoyZYph2+LFi/X111/bxGfNmqXnn3/e8Jzo6GhduHBBoaGhCggI0DPPPGP4GmBgYKCWL1+ucuXK6epV978ZJbnPSVZbK9hbgx84cMClf+w2NazB45NcrhMz1pPMpSlPSn+NrVSpUobxffv2uXTc27Fjh8tyP83s/Zrktq+VmD0t7uWSJ+YMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADMtX//flWvXl3BwcEqX768TXu2bNmULVu2x4+7d++u7t27686dO9q7d6927NihxYsXa+vWrU7VkTNnTrVq1SrRx0+cOFHDhg1TeHh4vMd5e3vbxKKjo5NcX2JyGPXlKv7+/vrkk0/ixCZOnKi///47RfYLAAAAAAAAAAAAAABSvnPnzuncuXOaN2+ep0tJtPPnz2vy5MmaPHmyp0vBU3bv3q3du3d7uowU6f79+zp9+rSny7AUxgo8cuLECZ04cUJTpkzxdClJ5onnfmofy/fs2aM9e/Z4uozHrHr9XrlyRXPnztXcuXM9XUqqY9VrRmK94yjWPJ4XFhamFStWaMWKFZ4uJUkOHz6sw4cPe7qMeCX3dUlyr0+SYmJitGHDBm3YsMHTpdjw8fF5/P9m/M6RO1nh+eNu4eHhWrJkiZYsWeLpUuKVnJ8TRqw4z3MvkLJlypTJbtuNGzfcWEn8rHxf9CSrzTdWq9cdrDI/ImWz8pjo7r0iK9zjmSlfvnxq2LChTfzq1atavny5BypKPVx9PxwdHa2dO3dq586dpud2FWoGAACP+Hq6AACAa6XPbGKuLOblsrr79++re/fu2rx5s3x9bafTCRMmaMOGDTp58qQHqrO1YsUKXb58WXny5LFp6927d5I21fv06WMYnz9/vu7evetoiZCULl06w/iDBw/cXEnipEuXTj179jRsM+MF92nTpmnUqFFxNvceGThwoNMfDOyIWbNmacSIETZxHx8f/fTTTxo4cKB+/vlnrVy5UmfPnnV7fe720Ucf6dKlS6bmLF68uNq2basePXqoXLlyhsf4+PhoypQpCgkJ0cqVK03t3xNy5MihwoULq0iRIo//lShRwu7xSflA6CJFihjGk8v8lBR+fn6aPXu2OnToEO9xly5dUmxsrFtqmj9/vt577z2beNu2bTVu3LgEz2/durVNbOXKlYqMjHz8eM2aNQoPD1fatGltzt24cWOCfbRp08YwPn/+/ATPlaTChQsbxs+dO5eo85Pq5s2bhvGMGTO6pL+U6Pz583GuIbNFRkbqwoULKlq0qE2bvevFSlw5JqdmxYsXN4wfP37c5X2fOHFCtWrVsonH93NNSGRkpPbu3etMWU45c+aMqfkePHig6Ohow3W32X3Fd88YEBCgsLAwU/szgyt+3u6eX6XkN8e6arxNKevfM2fOKCYmxvS8t2/fNoz7+/snOoeVrt9ChQoZxs0e255m1V/UZLyzzhiS0tZWkmuuP8YA17Hac/tJkyZNUrNmzWziXbt21dChQxUREZHoXPZeK5k0aVKic1j5e+ms1LrXnhr2E1MzV63jJXPW8jDXJ598Yvg+AUl6//33kzSnOOP27duaOHGiJk6cKEnKnDmzcufOLR8fH4WEhCg0NDTB10z8/PwUFBRk+Eus586dM5zzXn31VcPx4t69exo5cqR++eUXhYaGxumjRYsWGjdunIoVKxbnnMDAQM2aNUtNmjRJzJdsuuQ8J1ltrWBvDX7q1CmnakpIaliDxye5XCdmrCeZS60tNb7GVrBgQcP4iRMnXNrv0aNHXZr/EVfs1yS3fa3E7mlxL5f8MGcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGC+kydPqmLFiurZs6f69++vWrVqJXhOpkyZ1KBBAzVo0EDDhw/X2bNnNXLkSM2aNcsNFUtt27bVli1bNGfOHLf0l9wMHjxYBQoUePz49u3b+uSTT1JsvwAAAAAAAAAAAAAAAAAAAAAAAIDZsmTJ8vj/79y547lCAACJVqJECcN4ZGSkrl696uZqAACAM3r16iVvb2+b+KxZsxQdHe2BilIP7ocBAADs8/V0AQAA14qKNC9XtIm5UoIdO3bo448/1qhRo2za0qdPr9mzZ6tGjRqKioryQHVxxcTE6JdfftG7775r09aqVStlyZJFt27dSjBP2rRp1aFDB8O2yZMnO1tmqpc+fXrD+IMHD9xcSeJ07txZmTNntomHhYWZ8uG5ly5d0qpVq9SiRQubtg4dOuj111/XzZs3ne4nKcaOHauBAwcqW7Zshu0VK1bUxIkTJf3vA2yPHz+uM2fO6PTp04//nTlzRiEhIe4s21JOnjypsWPHauzYserWrZvGjx+v3Llz2xzn6+urGTNmqHjx4okavzzJx8dHBQsWVOHChVWkSJE4/woXLqyMGTO6rG+j56gktz93nBUQEKDff/9djRo1SvDYUaNGad26ddq2bZvL6woKCtJ7771nE69Ro4Zy5syZ4HO9devWNrHFixfHeRwWFqZ169bZjIWtWrXSsGHD4s3/7LPPqnz58jbxPXv26O+//4733EcyZcpkGPf29la1atUSlSMpihQpYhgPCAgwva+U6uLFiy7vw94Y4srxzCyeHJNTsydfrH2SO+Yje33YmyMT48KFC3r48KHD5zsrNDTU9Jzh4eHKkCGDy/tKrvc28XHFz9vd86vk/jnWU+NtSln/Xrt2zSV579+/73QOK12/9q4zV99DXrt2TVFRUfL1tdZLcIx31hlDUtraSnLN9ccY4DpWe24/afHixbp69apy5coVJ541a1a1adNGwcHBicqTJk0adenSxSb+4MED/frrr4mux8rfS2el1r321LCfmJq5ah0vmbOWh3kqVKigTp06GbYdOHBAs2fPdnNF/+f27du6fft2ks4ZP368qlSpYhOPiopS586dbdaAGTJk0KeffmrYd926dXXo0CGbtsjISC1atEhr1qzRunXrVL169TjtjRs3VosWLbR8+fIk1W6G5DwnWW2tYG8N7up7ldSwBo9PcrlOzFhPMpcmb7zGZsvede/qce/WrVuKjY2Vl5eXS/txxX5NctvXSuyeFvdyyQ9zBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArhEbG6sZM2ZoxowZypcvn2rUqKHq1aurfPnyqlChgnLnzh3v+YULF9bMmTPVq1cvdejQQXfu3ElS/6GhodqwYYNNPG3atMqRI4cKFy4sb2/vx/F8+fJp9uzZqlu3rl599VXFxsYmqT8ry5Qpk0aMGBEn9tlnn+nGjRspsl8AAAAAAAAAAAAAAAAAAAAAAADAbAEBASpRosTjx1euXPFgNQCAxKpWrZph/Pjx426uBAAAOMPLy0uvvPKKYdukSZPcXE3qwv0wAABA/Hw9XQAAwLXCbpmX6/5N83KlFJ988omaN2+uGjVq2LRVqVJFo0eP1vvvv++BymxNnTpV7777rk08TZo06tSpU6I2qdq2batMmTLZxE+fPq0///zTlDpTs1y5chnGQ0ND3VxJ4gwYMMAwPn/+/CR/SK89kydPVosWLWziadOmVe/evfX111+b0k9i3blzR126dNHy5cvl6xv/Ujpz5syqXr26qlevbtN27949nTlzRqdPn9bRo0e1a9cu7dy5U1evXnVV6ZY0e/Zsbd68WRs2bFChQoVs2gMDA/Xxxx/rtdde80B1xkqUKKGqVauqSpUqKlu2rIoUKaICBQrIx8fHI/UEBAQYxm/etM6kHhgYqI0bN6py5cqJOt7Hx0dz5sxR+fLlTRuL7Nm/f79Onz6tokWLxol7e3urdevWmjJlit1zCxYsqLJly8aJRUdHa/ny5TbHLlq0yGYsLFGihIoWLarTp0/b7aNNmzaG8aCgILvnPM3eNdS3b1/17ds30Xmc5eXlJW9vb8XExLitT6u6f/++y/u4deuWYdze9eIpyW1MTs0yZsxoGLd3LZnJ3pxnryZncrqLK57n9v7ohdl9WfGPa7ji551c5lfJnDk2OY23KWH9K7luPjfjOWil6zdDhgyGcXdcD/fv31fmzJld3o+ZGO+sM4aktLVVfHmdwRjgOlZ7bj8pOjpa06ZNM3ytpG/fvgoODk5UnrZt2xr+jIOCgpK0H2Xl76WzUutee2rYT0zNXLkvZ8X76ZRsxIgR8vLysttmJW3btrX7Ott7772n7du328T//e9/G86DgwcP1qFDh+LtLywsTO3bt9fp06eVLl26OG1vvfWW4Zjmasl5TrLaWsFeve64V0npa/D4JJfrxIz1JHNp8pGc9nyTM0/tJcXGxurOnTsuH/dc8XUkt32txO5pcS+X/DBnAAAAAAAAAAAAAAAAAAAAAAAAAAAAwNUaNmyofM/k83QZSCVOnjipnTt3eroMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMbFixe1YMECLViwQJJUuXJl7dmzR5K0fv167dmzR+XLl1f16tWVOXPmOOc2adJEf/zxh2rXrq2IiIhE97ljxw41bNjQbnumTJnUunVrDR8+XOXKlXscHzhwoO7du6d33nkn0X15eXkl+lhX5nDUO++8o2zZsj1+fOHCBX3zzTcptl8AAAAAAAAAAAAAAAAAAAAAAADAbOPHj5e/v//jxzt37vRgNQCAxGrcuLFh/NHvwQIAAGto1aqVnn32WZv4pk2bdPLkSfcXlIpwPwwAABA/X08XAABwrYtHpXJNnc8TEy1dPe18npQmJiZG3bp104EDB5QxY0ab9uHDh2vFihX6888/PVBdXKdOndKff/6punXr2rT17t1bkyZNSjBH7969DeNTpkxxur7UztvbW7lz5zZsu3DhgpurSdijD+k1MnnyZNP6WbJkiUJCQpQzZ06btgEDBujrr782ra/EWrNmjbp3767p06crXbp0DuUICAhQhQoVVKFCBf3rX/+SJMXGxmrz5s365ZdfNGPGDEVGRppZtmWdO3dOTZo00eHDh5U2bVqb9r59++q9997TvXv3PFDd/+TOnVuvvPKKunbtqpIlS3qsDiPp06c3jN+5c8fNlTiudu3adtsiIyPl5+dnEy9YsKB+/vlnde7c2ZWlSZLmz5+vd9991ybetm3beOfHVq1a2cQ2b96smzdv2sSXLFmiH3/80eYDwlu2bBnvh2W3bdvWMP7oQ9gTw941hOTrwYMHLu/j7t27hvEMGTK4vO+EJOcxOTXz5Hxkrw9nrtfbt287fK4Z3LlOZE3qmp93Sphfk+t4mxLWv5KS9Edv3M1K16+9Wu2tZcwUFhZm84eNkjvGO+uMISltbSW59/pjDHCe1Z7bT/v55581fPhwm32Wpk2bKk+ePLp8+XKCOfr27WsYT8zrLE+y+vfSWal1rz2l7yemZsl5HQ/zFC9e/PF487QdO3Zo2bJlbq7Icc8++6ymTZtm2LZ8+XJ9+eWXhm0vvfSSTezUqVP69ddfE9XvpUuX9PPPP+v111+PE3/++edVsGBB/fPPP4nKY6bkOidZba1g73vnjnuVlL4Gj4/VrpP4MJd6VnLd803OjN6rIP1vTHK1e/fuuXzcc+d+jaf2tZKyp8W9XPLCnAEAAAAAAAAAAAAAAAAAAAAAAAAAAABXK1SokEqVLuXpMpBK3L9/X+LvLAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBi9uzZo7fffluS5Ovrq2bNmumjjz5S1apVHx/z3HPPacyYMRo2bJhp/d65c0e//vqr5s2bp6+//lqvvvrq47a3335bS5Ys0Z9//mlz3sOHD21i/v7+//u8cCekTZs2UX2ZLWvWrBoyZEic2H/+8x+Fh4enyH4BAAAAAAAAAAAAAAAAAAAAAAAAM/n6+uq7777TK6+8Eic+ffp0zxQEAClUhgwZnP5dzqfly5dPLVu2NGxbtWqVqX0BAADXGjlypGH8m2++cXMlqQf3wwAAAInj7ekCAACudXaXFBPtfJ7zB6WIMOfzpER//fWXXn/9dcM2b29vzZo1S5kyZXJzVcamTJliGK9Vq5aKFCkS77m5c+dWkyZNbOLR0dGaMWOGKfWlZkWLFpWPj49h2/nz591cTcL69+9vGD916pThh+U6KioqSjNnzjRsK1GihOrVq2daX0kRFBSkatWqac+ePabl9PLyUt26dTV58mQdO3ZML774omm5re7MmTMaO3asYVuGDBn0r3/9y80V/U/atGk1evRonT59WqNGjVLJkiU9UocjYmNjPV2C04KDg1WlShWFhRkvUDp16qS+ffu6vI6goCDDeOPGjZU+fXq75xk9xxcvXmx47OXLl7V3716beOvWre3mz5o1q+rWrWsT37dvn86cOWP3PFhfTExMiugjqaw8JqcGXl5ehnGrXq937941PSeSL37ecVl1vE0J61+Yxx3XQ3S0CRuybsZ4Z19yG0NS2tpKcu/1xxiAs2fPav369TZxHx8f9ezZM8Hz8+TJo8aNG9vEjx07pq1bt5pSY2qSGvfa2U8ErG3YsGHy9jZ+u90nn3zi5moc5+vrq6CgIGXJksWm7eLFi+rVq5fheVmzZlXZsmVt4sHBwUlaZ82bN88wXqdOnUTnMFtqnJPM5sl7FdbggOOsuueb2rljf8MV+zVW3tfiXg4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBYVFSUli5dqho1aujHH3+M0/bqq6+6rM/Bgwdr/vz5ceKffvqp4fF37txRbGxsnFjGjBmdruPpHPfv31d0dLTTeRMyZMgQBQQEPH586tQpTZs2LcX2CwAAAAAAAAAAAAAAAAAAAAAAAJglV65cWrdunfr37x8nPmfOHG3YsMEzRQFACuPt7a2PPvpIp06dUs6cOU3N/e6778rHx8cmHh4erpUrV5raFwAAcJ2ePXuqSpUqNvGzZ8/qt99+80BFKR/3wwAAAInn7ekCAACudS9UOrTa+Txb5zifIyWbPn26FixYYNhWoEAB/fDDD26uyFhwcLDu3r1r2NarV694z+3evbvhC1erVq3SpUuXTKkvNatQoYLdtsOHD7uxkoSlT59ePXr0MGzbsWOH6tWrZ+q/U6dO2a1l4MCBrvoyE3T48GE999xzatu2rdauXWvqh/QWKVJEixYt0pgxY0zLaXU///yz3bY6deq4sZL/yZMnj/788099+OGHypAhg8N57t+/r/379ys4OFhjxoxRnz59VLt2bZUvX97EalOeiRMnqnPnzjp06JCGDBmoWVB2AAEZFElEQVRi97j//ve/Kl68uEtr2bdvn86cOWMTT5s2rZo2bWp4ToYMGdSgQQOb+JIlS+z2s2jRIptYvXr17H7weKtWrQzn7eDgYLt9AFbFmAx3i4mJ8XQJcCN+3v+H8RZI2Rjv4Elcf3C3SZMmGcb79u2b4Lk9e/Y03HOxlxMJS2177ewnAtaVOXNmde/e3bDt6NGjWrp0qZsrcty4ceNUtWpVm3h0dLS6dOmi0NBQw/Nq1aolLy8vm/jGjRuT1P/27dsVERFhE69bt26S8pgttc1JAMCer3Oe/qPhj3h7u/6t+f7+/i7vg/2auLiXAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiF9MTIxeffVV7dmz53Esbdq0Lu3zjTfeUExMzOPHdevW1TPPPGNzXGxsrO7duxcnljlzZqf7fzrHrVu3nM6ZEH9/fw0aNChO7PPPP4/zfUhJ/QIAAAAAAAAAAAAAAAAAAAAAAABmyZcvn/bt26e6devGia9cuVL9+vXzUFUAkLLkz59fGzdu1KhRo5QnTx4tXLjQtN83bdSokV599VXDtnnz5rnl9zwBAIDzihYtqm+++cawbfTo0YqNjXVzRSkf98MAAABJ4+vpAgAArvfnL1Lh56SMgY6df+QP6fxBc2tKiV5++WXVrFlTefPmtWnr1q2blixZorlz53qgsv8TFhamefPm6aWXXrJp69mzp0aOHGn33D59+hjGJ0+ebFZ5qdrTm1lP2rdvnxsrSViXLl2UKVMmw7YePXqoR48ebqulffv2ypEjh65fv+62Pp+2aNEiLVq0SNmzZ1fjxo1VuXJlVapUScWLF1f+/Pnl7e3tcO733ntPadKk0VtvvWVixdZ04cIFHTp0SOXKlbNpq1KliltryZEjh7Zt26aCBQsm6vjw8HCdPn1ap06d0qlTp3Ty5MnH/3/58mXDc3LmzGlKrfY+TNnX17q3gh988IE+/fTTx48nT56s5s2bq3379jbHZsiQQXPnzlX16tUVGRnpsprmz5+v4cOH28Tbtm2r33//3SbetGlT+fv7x4kdP35cp06dstvH4sWLNXr06DgxPz8/NW3aVAsWLDDs216tSWHvhaw///xTJ06cSFIuZ/GiWuL4+Pi4vI+nr99HoqOjXd7306w0Jqdm9q4Nd8xHfn5+hnFPXK/AI8lpfpUSN8daZbxNievf5MZK16+9sd7e3GAme+ul1MZK14tknTGEtVXiMAa4jtWe20YWLlyo0NBQZc+ePU68ZMmSqlatmnbu3Gn33L59+9rEHj58qBkzZiS5jpTwvTRTatprT8n7iUBK1qdPH6VPn96wbcKECW6uxnEvvvii3njjDcO2Dz/8UJs3b7Z7buHChQ3jx48fT1INMTExOnXqlMqUKRMnXqhQoSTlcZXkMidZba3gyXsqd6zzXcHLy8vpHMnpOvH0ehJJY5U93+Ts/v37hvEsWbK4vG939OEKyW1fK6l7WtzLAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxC8mJkZff/21Zs6c6Zb+Ll68qJ07d6pGjRqPY9WrV9eFCxdsjr1+/boyZsz4+HGxYsV06NAhp/ovVqxYnMehoaFO5UuMf/3rXwoMDHz8+Nq1a5o1a1aK7RcAAAAAAAAAAAAAAAAAAAAAAAAwy8WLF7Vt2za1b9/+cWzy5MkaNGiQIiMjPVgZAKQM7dq109SpU5UlS5bHsdq1a2v16tVq3769rl+/7nDu559/XgsWLJCXl5dNW1RUlD799FOHcwMAAPepVq2agoODlTVrVpu2Y8eOue3zKlIb7ocBAACSxtfTBQAAXC/slrTgP1KXz6W0GRM6Oq7zh6WVX7ugqBTo5s2b6tWrl9asWWP4Is+PP/6oLVu26Pz58x6o7v9MmTJFL730kk28UKFCql27trZs2WLTVrFiRZUtW9Ymfv36dS1ZssQldaY2TZs2NYxfvnxZFy9edHM18RswYICnS3jM399fffr00ZdffunpUhQaGqp58+Zp3rx5j2P+/v4qXLiwihYtqqJFi6p48eKP/79gwYLy9vZOMO+bb76p7du3Kzg42JXlW8Lff/+tcuXK2cSf/BBhV/Py8lJQUJAKFixo95grV65oyZIlWrt2rfbt26czZ84oJiYmyf2YITw83DD+5BsdrCI6Olr9+/fXlClTbNpeeuklVa9eXfny5bNpq1Spkr744gu9+eabLqstKChIw4cPt4m3atVK3t7eNj//F1980ebYhObTAwcO6Pz588qfP79NrgULFsSJpUmTRi+88IJNjoMHD+rUqVPx9vM0e9fQ/Pnz9e233yYpF9wjbdq0Lu/D3hhy7949l/f9JKuNyamZvWvD6IV0s9nr4+7duy7vG7DHavOrlcbblLT+Ta6sdP3am3/ccT2kT5/e5X1YgZWuF8k6Ywhrq8RhDHAdqz23jURGRmrGjBkaOnSoTVu/fv20c+dOw/OqVaumkiVL2sR/++033bhxI8l1pITvpSukhr32lLyfCKRkffr0MYzfuXNHs2fPdm8xDipQoICmT59u2LZ69Wp99tln8Z6fPXt2w/jly5eTXMvly5dVpkyZOLFs2bIlOY8reXpOstpawZNr8AwZMri8D1dIly6d0zmsdp0gebDSnm9y5qk9mnTp0snf39+lfbhKctvXSuqeFvdyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACdu6datb+ztz5oxq1Kjx+HHu3LkNj9u/f78KFSr0+HH58uW1cOFCp/ouX768TR+u1qtXrziPp0+froiIiBTbLwAAAAAAAAAAAAAAAAAAAAAAAGCmPn36qFy5csqfP7/eeOMN/fTTT54uCQBSjOLFiytLliw28bp16+rIkSN69913NWvWLEVGRiY6Z7Zs2TRs2DANGzZMfn5+hsd88803OnXqlKNlAwAAk3l5ecnPz09eXl7KkCGDcubMqcqVK6tjx45q3bq1fHx8DM8bOHCgYmJi3Fxt6sH9MAAAQOL5eroAAIB7hJyRZrwutftICiyU8PGSdHCVtOY7KTrxr3Wken/88Ye+/vprDR061KYtc+bMmjVrlho0aKDY2FgPVPc/27dv17Fjx1SqVCmbtt69e2vLli2GcSMzZ85UVFSU6TWmNhUqVFCJEiUM21asWOHmauJXoUIFVa1a1dNlxNG/f399+eWXni7DUEREhI4fP67jx4/btPn7+6tkyZKqXbu2unbtqrp169rNM27cOP3222+p/vkWEhJiGDd64d5VOnfurIYNGxq2Xbx4UcOGDVNwcLCio6Od6id9+vROnf9IWFiYYTxz5sym5HeXBw8eqEuXLlq8eLFh+82bN9WzZ0+tXbtW3t7eNu1vvPGGVq9erZUrV7qkvr179+rs2bMqXLhwnHj27NlVp04dbdq06XHMy8tLLVq0sMmxaNGiBPtZsmSJBg0aFCfWokULeXl5xVlbNG7cWBkyZLA5Pzg4OME+nmbvGsqePXuSc8E9smbN6vI+7I279+7dc3nfT7LamJya3b171zDujuvVXh/2agLcwWrzq5XG25Sy/k3OrHT93r9/3zDu6ntIHx8f1g//n5WuF8k6Ywhrq8RhDHAdqz237Zk0aZLhazldunTRkCFD9PDhQ5u2Pn362M3liJTyvXSHlLbXnpL3E4GUqkSJEqpYsaJh2+zZs+2O6cmJr6+vgoKCDNd0ly9fVo8ePRLMkS1bNptYVFRUkn6B9hGj/WSj/MmNO+ckq60V7K3BXX2v4u3t7ZY1uNFrkM4ymn+TymrXCZIHK+35Jmc3btwwjOfMmdOl/ebNm9el+V0pue1rJXVPi3s5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAhF2/ft2t/d27dy/O4zRp0hget2vXLrVr1+7x4/r16zvd99M5du3a5XTO+KRJk0bPP/98nNjs2bNd2qcn+wUAAAAAAAAAAAAAAAAAAAAAAADMdvfuXbVt21Y+Pj46dOiQp8sBgBTlyy+/VLt27VS9enWbtpw5c2rq1Kn6/PPPtXTpUm3atEknT57UhQsXdP/+fT18+FC+vr7Kli2bsmfPrkqVKun5559Xy5YtlTFjRrt97tu3T++//74rvywAAJBEHTt21Lx585J0znfffaeNGze6qCJI3A8DAAAkhbenCwAAuM+ty9L0V6Xl46UrJ6XYWNtjIsKlU9ukmUOklROk6Ej312l17777rt0NiXr16umdd95xc0W2pkyZYhjv1KmTzQed+vj4qFu3bknKg6R5+eWX7bYtX77cjZUkbMCAAZ4uwUbRokVtPkjWCiIiInTw4EH98MMPqlevnpo1a6Zr164ZHluwYEF16dLFzRUmP5GRxpOSr6+v22r46KOPDOPHjx9XhQoVNHfuXEVHRzvdT44cOZzOIUmXLl1yaX53uHXrlpo0aaLFixfHe9z69ev15ZdfGrZ5eXnpl19+Ua5cuVxRoiRp/vz5hvG2bdvGeVytWjXlzJkzTiw0NFTbtm1LsI9FixbZxHLkyGHzxpWn+0yoxvhcuXLFMJ49e/Yk54J75MuXz+V92Pv537hxw+V9P8lqY3JqFhISYhgPDAx0ed/2fn7u/gMTwJOsNr9aabxNCevf5M5K129oaKhh3NXXQ4ECBeTtzctvkrWuF8k6Ywhrq8RhDHAdqz237Tl+/Lg2b95sE8+cObPh3oq/v7/hHu2ZM2e0fv16h2pIKd9LT7PqXntK3U8EUqp//etfdtvmzJnjxkoc9/nnnxv+ImxMTIy6du1qd+x8kp+fn03s4cOHDtVjdJ6/v79DuZILs+ckq60V7L1G4Op6zVyDx8TE2G0LCAgwpY8nmfGajtWuEyQPVtrzTc5OnDhhGK9atapL+3V1fldKbvtajuxpcS8HAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABSosaNG6t+/fqm5EqTJo0peRIra9ascR7funXL8Ljt27fHeVyvXj3lzJnT4X7z5MmjOnXqxInt2LHD4XyJ8dxzz8nf3//x4xs3bmj//v0u7dOT/QIAAAAAAAAAAAAAAAAAAAAAAACucPToUR06dMjTZQBAihMdHa1WrVrp1KlTdo/JmTOn+vXrp+nTp2vr1q06d+6cQkNDde/ePd26dUtnz57Vrl27NGnSJHXp0kUZM2a0m+vs2bNq0aKFIiIiXPHlAAAAN1m/fr3efPNNT5eRKnA/DAAAkDjeni4AAOBesTHS4TXSjNel7zpLs96QFv5HChohTX9V+raD9Nso6fIJT1dqXREREeratasePnxo2P7xxx+rcuXKbq4qrpkzZyoqKsomnjlzZr344otxYs2aNTP8QNOdO3fqyJEjLqsxtciVK5f69etn2Hbr1i0tW7bMzRXZlyFDBnXv3t3TZRgaOHCgp0tw2qpVq9S4cWM9ePDAsL1ly5Zurij58fY2vn2JjY11S/8lSpRQqVKlDNv69u2r0NBQ0/oKDAw0Jc+FCxcM4xUqVDAlvzts2LBBW7ZsSdSxI0aM0J49ewzbcubMqRkzZphZWhxBQUGG8TZt2sR5/PQ8K0nLli1TTExMgn2sX79e9+7ds4m3bt368f97eXkZ9nHkyBEdP348wT6eZu8aKlGiRJJzwT3y5MmjLFmyuCx/jhw5lC9fPsO2kydPuqzfp1lxTE7Njh49ahivUqWKS/tNkyaNypQpY9jGvQw8yUrzq9XG25Sw/k3urHT92lubVKxY0aX9Fi1a1KX5rcRK14tknTGEtVXiMAa4jtWe2/GZNGmSYdxoz75NmzY2fzhOkn7++WeH+09J38vkxCp77Sl1PxFIqZo2bWoYDwkJ0Z9//unmapKuZcuWdn+J5T//+Y82btzocG5HX6dz1+t7nuTsnGS1tYK9X7R29T1V8eLFTct1584du22ZM2c2rZ9HzKjdatcJPM9qe77J2bFjxwzj+fLl0zPPPOOyfmvUqOGy3K6W3Pa1HNnT4l4OAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACkJHXr1tWmTZu0Zs0aTZgwQV5eXk7nLFasmAmVJV65cuXiPL569arhcRs2bND58+cfP/b29tarr77qcL+DBw+Wt7f348cnT57Url27HM6XGLVq1YrzeMeOHS7tz9P9AgAAAAAAAAAAAAAAAAAAAAAAAAAAa7l+/brq1aunrVu3urSf3bt3q1atWrpy5YpL+wEAAK61fPlytWrVSpGRkZ4uBQAAAHjMO+FDAAAp1YM70qXj0unt0t97pJAzUkyUp6tKGY4cOaLhw4cbtvn5+Wn27NlKly6dm6v6PyEhIVq2bJlhW69eveI87t27t+FxU6ZMMb2u1Ojjjz+2ey3MmDFD4eHhbq7Ivq5duypjxoyGbb169VLLli1d/m/37t2G/bdp00Y5c+Z05ZfvFgcPHtQPP/xg2FavXj03V5P85MiRwzB+//59t/TfuHFjw/ihQ4e0fft2U/uqXr26KXkOHjxoGC9SpIjd76eVRUVFqWvXrnaviaZNm+qtt95ySd979uzRX3/9ZRMvXLiwypQp8/hxq1atbI5ZtGhRovqIjIzUqlWrbOJP5qxRo4bheBgUFJSoPp52+PBhw3i1atVM+YB3uEbVqlVdlrtGjRp2206ePOmyfp9mxTE5NTty5IhhPF++fCpQoIDL+q1atar8/f0N244ePeqyfoGEWGl+tdp4m9rWv55gpev3xIkThvFnn31WuXLlclm/devWdVluq7HS9SJZZwxhbZU4jAGuY7XndnyCg4N169Ytm3jjxo2VL1++OLG+ffvaHBcVFaXp06c73H9K+l4mN1bYa0+p+4lASpQ2bVrVrFnTsO2PP/5QbGysmytKmmeeeUYzZswwnFvWrVunTz75xANVpR7OzElWWyvYW4MXLlxYgYGBLuvXzLn95s2bdtty585tWj+PmLEfZrXrBJ5ntT3f5Gzbtm1221q2bOmyfl2Z29WS276WI3ta3MsBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICUwt/fXwsWLFDdunUlSZUqVdLQoUOdztutW7dEHZclSxa98847Sp8+vcN9VatWTaVKlXr8ODY2Vrt37zY8NjY2VtOmTYsTGzZsmJ555pkk91ugQAG9+eabcWI///xzkvMkVYkSJeI83rNnj8v79GS/AAAAAAAAAAAAAAAAAAAAAAAAAADAeq5cuaIGDRpo5MiRCgsLMzX3w4cPNWbMGNWsWVNXr141NTcAAHCfq1evauDAgWrZsqXp6wUAAADAWd6eLgAAgJTqm2++0erVqw3bSpQooa+++srNFcU1efJkw3izZs0UGBgoScqcObNefPFFm2MePHigOXPmuLS+1KBhw4Z66aWXDNuioqL03//+180Vxa9///6G8c2bN2vmzJlavny5y/9NnDjRsAY/Pz/169fPlV++2wQFBRnGc+XKJS8vLzdXk7zY+2Dl0NBQt/RfuHBhw/jOnTtN76tBgwam5Invg5UffVB3SnPq1CkNGTLEbvtnn32mKlWquKTv+fPnG8bbtGkjScqfP7/Kly8fpy0iIsLuesHIokWLbGLly5dX/vz5JUnt2rVLUm0J2bdvn2E8U6ZMcT4sHcnLCy+84LLc9evXN4w/fPhQR48edVm/T7PimJwYKXWu37Jli922Ro0auazf559/3jD+8OFD7d2712X9Agmx0vxqtfE2Na5/3c1K16+nrocmTZq4LLfVWOl6kawzhrC2ShzGANex2nM7PuHh4fr1119t4t7e3urVq9fjx7lz51bTpk1tjluyZIlTv+iTkr6XyZEV9tpT4n5icpBcfr5IOcqVKyd/f3/DtvXr17u5mqTx8fHRvHnzlC1bNpu2q1evqlu3boqNjU10vpiYGJuYn5+fQ7UZfU+N8qcEjs5JVlsrxHdf4Mo1uNE6zVE3b96021apUiXT+pH+98eNq1at6nQeq10nqUFyX4tYbc83OTt8+LAuXbpk2Pbaa6+5pM/GjRuraNGiLsntDslpX8uZPS3u5f5Pch/zAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAfREREfryyy/jxMaOHau2bds6nLNOnTrq379/vMfkyJFDn332mf755x998cUXGj9+vEN9ZcqUSZMnT44T27Ztm65evWr3nB9++EF37tx5/Dh9+vRavHixMmbMmKR+lyxZorRp0z6OhYaGaurUqXbPSZMmjdKnTx/nnyOyZ88e5/Hly5cdymOVfgEAAAAAAAAAAAAAAAAAAAAAAAAAgDVFRkZq9OjRKlasmD799FNdunTJqXy3b9/WN998o+LFi2vEiBGKiooyqVIAAOBKMTExun//vs6fP68///xTX3/9tVq1aqVnnnlGP/74o6fLAwAAAAx5e7oAAABSst69eys0NNSwbcCAAWrVqpWbK/o/K1asMPzATV9fX3Xt2lWS1LlzZ6VJk8bmmPnz5+vu3bsurzEly58/v+bOnSsvLy/D9mnTpun06dNursq+SpUq6bnnnjNse/oDc10pKCjI7rX3yiuv2P1+WsmJEycM4z4+PsqSJYt7i0lGsmfPripVqhi2nTp1yi01BAYGGsbtjfOOyps3r2rWrGlKrr179+rGjRuGbQl9sLaVTZkyRQsWLDBs8/Pz09y5c5UhQwbT+w0KCjKMP/oQ9NatW9u0rV+/Xvfu3Ut0H8uXL1dMTIxNvGXLlpKkNm3a2LQdP35cR48eTXQfT9q5c6fu379v2Na9e3eHcsL1unbtKm9v87d80qRJo969exu2bdq0SeHh4ab3aY8Vx+QnRUZGGsYd/UD/5O78+fM6dOiQYdtrr73mkj79/Pw0cOBAw7YNGzbYHdsAd7DS/Gq18Ta1rn/dyUrX7969e3X9+nXDNlddD6VKlVKNGjVcktuKrHS9SNYZQ1hbJQ5jgOtY7bmdkEmTJhnG+/bt+/j/e/ToIR8fn0Sfm1gp7XuZ3Fhhrz0l7ie6U2rbX4HnVKhQwW7bnj173FhJ0o0ZM0a1atWyicfExKh79+7x/hFUI7du3bKJpUmTxqH9aKPXaW7evJnkPFbg6JxktbXC7t277f4MBwwY4JI+y5cvr6pVq5qWLyoqyu7zwsx+JKlnz56Ga8ykstp1kpJYdS1itT3f5G7JkiWG8TJlyuiFF14wvb8333zT9JzulJz2tZzZ00qN93JWHfMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAED8JkyYoP379z9+7OPjowULFuijjz6Sv79/knL17NlTK1askK+v7+PY0qVLbY4rVKiQ3n33XWXKlEmSNGDAAP3444/KkCFDovsqWbKkNmzYoHLlysWJjxo1Kt7zrly5omHDhsWJVapUSevXr1eZMmUS7LdMmTLasGGDypcvHyc+ZMgQ3bhxw+558+fP1/379+P8c0T27NnjPI6vTzN5ql8AAAAAAAAAAAAAAAAAAAAAAGAtXl5ehv8AJIznD4CU6tKlS/rggw+UP39+Va1aVW+//baCgoK0e/duXb9+XRERETbnPHjwQKdPn9aqVas0ZswYNWnSRIGBgXrjjTd07tw5D3wVKYcV5xur1QsAkIKCgh6P2T4+PgoICFCBAgVUr149DR06VMuWLVNUVJSnywQAAADs8vZ0AQAApGRXrlzRyy+/bLe9bt26bqwmrujoaM2YMcOwrXfv3nH++7TJkye7rK7UIE+ePFq9erVy5sxp2H779m2NHDnSzVXFb8CAAYbxu3fvKjg42G11hIWFad68eYZthQoVUpMmTVxeQ7p06TR06FC9/fbbLskfFhZmt83Hx8clfVpB79697X79W7ZscUsNsbGxhvGkfNB0Yrzzzjvy8/MzJVdMTIyWL19u2Na0aVOVKFHClH6elDlzZtNzOuLll1/WhQsXDNuKFi2qiRMnmt7n7t279ffff9vEn3vuOeXNm1etW7e2aVu0aFGS+ggNDdXWrVtt4q1bt1aJEiVUvHhxmzZnxunIyEitXbvWsO2ll14y7VqFufLmzauuXbuanrd79+4KDAw0bFuxYoXp/cXHimPyk27evGkYf/oD8lOS33//3TBeqVIlPf/886b316NHD+XOnduw7bfffjO9PyAprDS/Wm28Tc3rX3ex0vUrSatXrzaMN27cWGXLljW9v7feesv0nFZmtevFSmMIa6vEYQxwDas9txNy8OBB7dq1yyZerFgx1axZU5LUt29fm/Zz585p1apVTvWd0r6XScVee8rcT3Sn1Li/As8wep5I/1s/Hj161M3VJF6zZs3sjrFjxozRH3/8keScoaGhhvEcOXIkOZfROZ76g6HJdU6y2lohJiZGa9asMWxr0qRJov54blINHz7c9Jzbtm0zjDds2NCha92In5+fhgwZYkouq10nKYlV1yJW2/NN7r7//nu7bT/99JMyZsxoWl9du3ZV8+bNTcvnKcllX8uZPa3UeC9n1TEPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADELzIyUp07d9a1a9cex7y9vTVq1CidPn1aH374oSpVqiRvb2+bc9OkSaMKFSrojTfe0MGDBzVjxgwFBAQ8bg8JCdHgwYNtztu1a5d+/vnnOLH+/fvrzJkz+vzzz9WgQQNly5bN5rwcOXKoRYsWmjVrlg4cOKBKlSrFaf/111+1evXqBL/mn3/+WStWrIgTq1Klivbu3as5c+aoffv2KlWqlLJmzaqsWbOqVKlS+te//qU5c+Zo7969Nv3+9ttv+vXXXxPs1wzp0qWL8/ju3bspul8AAAAAAAAAAAAAAAAAAAAAAAAAAJAyxMTEaPfu3fryyy/VuXNnVa1aVYGBgUqTJo18fX2VIUMGpU+fXt7e3kqfPr2KFSumZs2aacSIEVq7dq0iIyM9/SUAAAAAAAAglbD91DUAAGCq3377TVOnTvV0GYbs1VW5cmW1adNGtWrVsmk7c+aMNm3a5OrSUqwKFSpoy5YtKlmypN1jXn/9dV2+fNmNVcUvQ4YM6tatm2Hb3LlzFRYW5tZ6Jk+ebLdt4MCBLus3Xbp0evPNN/XXX3/pq6++0ujRo1WoUCHT+8mVK5dhPCYmRjdu3DC9PyvInz+/Ro0aZbd92bJlbqnj+vXrhvGiRYua1kfRokX18ssvm5ZPkqZMmWIY9/Ly0vfffy8vLy/T+ipWrJguX76sX375RSVKlDAtryNu3rypnj17KiYmxrC9d+/e6tq1q+n9zp8/3ybm5eWlbt26qWHDhjZtS5cuTXIfixYtsok9//zz6tGjh+HxQUFBSe7jSb/88othPGfOnHr11Vedyv20t99+W8OGDZOvr6+peVOjzz77TBkzZjQtX2BgoD7++GPDtocPH2rmzJmm9ZUYVh2TH7E3pz/9RwFSkh9++EERERF22578ow/Oypcvn7744gvDths3brj9egWMuHN+lRyfY6043qbW9a87WeX6lWTzx4Ke9N133xn+cSJHVapUSX379jUtX0phpetFss4YwtoqcRgDXMdqz+2ETJo0yTDer18/PffccypdurRN25QpUxQbG+t03ynte5kY7LXHlRL3E90lNe6vwDPy589vGL9y5YrCw8PdXE3i5M2bVzNnzjRcv27atEkjR450KK+917AduSc2Osfdr5FbYU6y2lohvtfyJ06caOoavG7dunbfx+CMzZs3G8b9/PzUu3dvU/oYOnSoihQpYkouyXrXSUph1bWIFfd8k7ODBw9q48aNhm0FCxbUTz/9ZEo/zz77rL777jtTcnlactjXMmNPK7Xdy1l1zAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAk7efKkGjVqpPPnz8eJ58+fX6NHj9bevXv18OFDrVix4nHba6+9pgcPHmj//v2aMGGCypUrF+fckJAQNWrUSP/8849hn4MHD9aqVavixHLlyqXhw4dr/fr1Cg0N1YMHDxQaGqqQkBA9fPhQ165d07Jly9S9e3f5+/vHOXfp0qXq06dPor/mDh06aOPGjXFi/v7+6tKlixYsWKCjR4/qxo0bunHjho4ePar58+erS5cuNv2uXbtW3bp1S3S/ZouNjU1V/QIAAAAAAAAAAAAAAAAAAAAAAAAAgJQnOjpaYWFhevDgAb/DCAAAAAAAAI/z9nQBAACkBq+//rpOnz7t6TJsnDx5Ulu2bDFsmzp1apLiiJ+vr6+GDRum7du3q1ChQnaPmzt3rmbMmOHGyhLWrVs3BQQEGLb9/PPPbq5G2rFjh44ePWrY1qpVK+XJk8f0Prt166a///5b48ePV65cuSRJadOm1fz585UmTRpT+6pXr55hPCQkRDExMab2ZQX58+fXH3/8Yfca3LVrlw4dOuSWWq5evWoYr1+/vt36kiJt2rRasGCB0qdP73SuJ23YsEEHDx40bHv++ec1YsQIU/rx9fXVL7/8onTp0qlXr146evSogoKCVL58eVPyO2LDhg0aN26c3fYff/wx3jHZEUFBQYbxDz/80Ga82L9/v80HpSfGkiVLbGJp06bVm2++aRM/efKkDh8+nOQ+nu7PXp2fffaZSpcu7VT+R6pVq6ZPPvlE48aN0/79+1W3bl1T8qZW+fPn18yZM+Xl5eV0Li8vL82ZM0d58+Y1bJ83b56uX7/udD9JYdUx+RF743KhQoU8Om660uXLlzV79mzDtuLFi2vatGmm9OPn56fg4GAFBgYatn///fcKCwszpS/AGe6aXyXn5lgrjrepef3rLla5fqX/XQ/29hDq16+vjz/+2IwylSlTJs2bN0/e3rzs9jQrXS+SdcYQ1laJwxjgOlZ7bidkzpw5unfvnk28c+fOevXVV23iMTExpr1WktK+lwlhr91WStxPdJfUuL8Cz8idO7dh/OLFi26uJHG8vb01b9485ciRw6bt2rVr6tKli8Pj4NatWw3j1apVS1KeUqVKGe4r2MvvClaZk6y2VlizZo1OnDhh2GbmGjwwMNDuPZGzNmzYYLftgw8+eHy9OKpq1aqmfR8esdp1klJYdS1ixT3f5G7YsGF2PzCia9eumjVrlnx8fBzOX6xYMf3555/Kli2bwzmSk+Swr2XGnlZqu5ez6pgHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAS59ChQ6pYsaLmzJmj2NhYm3ZfX1/lzJnz8eM0adLIy8vLMNeCBQtUtmxZHT582G5/ERERatmypcaMGaOIiAjDY9KmTats2bIpMDBQ/v7+hsc8fPhQ7733ntq0aaOoqKj4vsQ4wsLC1KRJE3399deKiYlJ9HmPxMTE6Msvv1Tz5s0VHh6e5PMBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJD/eni4AAIDU4P79++revXuSPkzUXSZPnmwYz5Ytm00sJiZGv/zyi6tLSlHSpk2rl156SUePHtW4ceOUNm1au8du375dffr0cV9xiTRgwADD+OHDh7Vr1y43V/M/9q5bX19f/fvf/za9v3v37sX5sOJHKleurMWLFyt9+vSm9OPr66u33nrLsO3IkSOm9GElvXv31q5du1SsWDG7x3z44Yduq2fr1q2G8bRp0+q9995zKnf69OkVHBys8uXLP45FR0c7lfNJ8dU3evRop+v39vbWL7/8opo1a8aJdezYUfv374/3Z+hqH3zwgXbv3m3YlilTJs2ZM0c+Pj6m9bdr1y79888/hn09bfHixQ71ceLECZ06dcombjQWBQcHO9THk6KiojR69GjDtrRp0+r3339XwYIFneqjZMmSWrx48eMPZy9Tpow2bdqkGTNmKDAw0KncqVmbNm30+++/K0OGDA7nSJ8+vRYsWKBGjRoZtkdEROiTTz5xOL+jrDwmS9KWLVvstn388cem9pWcjBgxQnfv3jVs69Chg+bOnas0adI4nD9r1qxavXp1nPnoSRcuXNAXX3zhcH7ATO6YXyXn51irjrepef3rDla5fh/56KOP7La9//77dr+WxMqUKZOWL1+e4n/ujrLa9SJZZwxhbZU4jAGuYcXndnzu37+vOXPm2MQzZsxouGe/cuVKXbhwwZS+U9r3MiHstdtKifuJ7pJa91fgfvbGpps3b7q5ksT55JNPVKdOHZt4bGysevbsqcuXLzuc+59//jGcA9u3b5+kPO3atTOM//nnnw7V5QirzElWXCuMHDnSbpsZa/DAwECtXr1azzzzjFN57NmzZ4/d1xazZMmi6dOny8/Pz6Hc5cqV09KlS+P8sWKjP6acVMnhOkmNrLoWseqeb3K2e/duTZ061W579+7d9ccff6h06dJJzt2tWzdt3rzZZWOep3hyX8usPa3Udi9n1TEPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAk3o0bN9StWzdVrFhRP/74o65fv57oc0NCQjR16lRVqlRJHTp00LVr1xI8Jzo6WiNGjFDJkiU1duxYnTt3LtH9Xbt2TWPHjlXJkiX1+eefKyYmJtHnPhIZGamhQ4eqQoUK+vXXXxUWFpbgOWFhYZo1a5bKly+vt99+W1FRUUnuFwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDy5O3pAgAASC127typjz/+2NNl2AgODta9e/cSdeyqVat08eJFF1dkbV5eXipRooR69eqlOXPm6OrVq/r5559VrFixeM/bs2ePWrVqpYcPH7qp0sSpUqWKKleubNg2efJkN1fzf2bOnKnIyEjDtldeeUVeXl6m9rd48WJt27bNsK1p06bavn27qlSp4lQf/v7+mj59uipVqmTYvmDBAqfyW4Gfn58qVqyo//znPzp+/LimT5+uXLly2T1+zpw5WrVqldvq27Ztm+7evWvYNnz4cHXo0MGhvM8++6y2bNmiVq1aPY7du3dPv/76q0P5jCxfvtzuNeTl5aUxY8bo119/jff7bU/OnDm1cuVKdevWzbA9ODhYp06dSnJes0RFRalr1666f/++YXv16tVNn5/nz5+fqOMWLVrkcB+LFy9O1HHBwcEO9/GkqVOnateuXYZtxYoV0/bt21WzZk2Hcrds2VJbt241vP569uxpdx5C4rz44ovavn273fklPhUrVtSWLVvUrl07u8d89dVXHnmOW3lMlv639rt8+bJh24svvqhvv/1Wvr6+pvaZHFy6dEnvvfee3fbOnTvrzz//VLly5ZKcu169etq5c6caNGhg95hXX3010fc+gDu4cn6VzJljrTrepub1r7tY4fp9ZMGCBfrjjz/stn/44YdasGCB8ubNm+Q6q1evrp07d6p27dpx4itXrkxyrpTMSteLZJ0xhLVV4jAGuI7VntsJmTRpkkuOTYyU9r2MD3vtxlLifqI7pNb9Fbhf2rRpDeMPHjxwcyUJa9q0qd59913DtrFjx5ryutrcuXNtYrVq1VKdOnUSdX66dOn02muv2cRPnDihgwcPOl1fYllpTrLaWmHevHlav3693XZn1uCNGjXS7t27VbFixTjx2NjYJOeKz/jx4+22NWvWTL/99psyZMiQpJxdu3bVn3/+qZw5cz6OXb9+XRs2bHC0zDg8fZ2kRlZdi1h1zze5GzJkiI4ePWq3vX79+jp48KCmTJmiJk2ayM/Pz+6x2bNnV69evbRlyxb9+uuvccYNSZo1a5ZpdXuKJ/e1zNzTSk33clYd8wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQNIdPHhQAwcOVM6cOVW6dGn17NlT7733nmbPnv34mB07dmjo0KHq2LGjSpUqpVy5cunf//639u/fn+T+/vrrLw0fPlwFCxZUoUKF1LZtW7311lv67LPP9O233+qHH37Q2LFj9d5776lnz54qUaKEcubMqeHDh+vvv/92+us9fPiwevTooezZs6thw4Z67bXXNHbsWE2cOFETJ07U2LFj9dprr6lhw4bKnj27evbsqSNHjiSpj9atW8vLy0ujRo1yqtaqVavKy8vr8b/ly5c7lS+59/u0t99+O04db7/9tkfqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQMrk7ekCAABITT755BNt27bN02XEcf/+fQUFBSXq2ClTpri4Gs+aMWOGlixZkqR/S5cu1dq1a7V161adOXNG4eHhOn78uH755Rd16dJFmTJlSrDf9evXq2HDhgoNDXXDV5k0AwYMMIxHRERo1qxZbq7m/1y/fl2LFy82bMufP7+aN29uep+9e/fW3bt3DdvKlSunnTt3auHChWrUqJF8fX0TnTdt2rTq1KmT9u3bp+7duxseExYWpoULFzpUtyt9/fXXmjZtmsP/Zs2apUWLFumPP/7QsWPHFBYWpn379mnkyJEqUaJEvH0fOHBA/fv3d9NX+j/R0dF2r3sfHx8FBQXpv//9r3LlypWofHnz5tU333yjEydOqGLFinHaRo0apUuXLjlbchz9+/fXP//8Y7e9W7duOnv2rL744gtVqFAhwXz58+fXhx9+qJMnT6pJkyaGx1y/fl1vvvmmwzWb5fTp03r99dfttg8fPlwNGzY0rb/EzKuXLl3S3r17He7D3hj4pDNnzujAgQMO9/GkmJgY9e7dW/fu3TNsz507t7Zu3ap58+apXLlyicpZo0YN/fbbb1q6dKmyZs1qeMyUKVO0atUqh+tOjdauXWvzYfZly5bVnj17NGfOHNWuXVve3va3g3x8fFSnTh3Nnj1be/futRmfnnTgwAGnP4jeUVYfk6Ojo/Xf//7Xbvtrr72m48eP6+2331a1atWULVs2+fj4mFqDp0ycOFHBwcF226tWrar9+/frl19+Ua1ateK9Xv39/dWkSRMtWbJEGzduVNGiRe0eO2HChESNnYA7uWJ+lcydY6083qbm9a87WOH6fdJLL72kGzdu2G1v3769Tp8+rXHjxqls2bLx5vL29lbDhg21cOFCbdu2zeb+dfPmzfrll1+SVF9KZ7XrRbLOGMLaKnEYA1zDis/t+OzevTtR+yhXrlzR0qVLTe07pX0vE8Jeu62UuJ/oDql5fwXuZW8NFRUV5eZK4pcnTx7NmjVLXl5eNm1bt27ViBEjTOnn66+/VmRkpE188uTJduebJ02cOFG5c+e2iY8fP96U+pLCKnOSFdcK//73v3Xz5k277UlZg/v6+uqFF17QihUrtHbtWhUoUCBO++LFi03fww8ODo73D/i2bNlSp0+f1r///W9lzJjR7nG+vr5q2bKlNm3apNmzZytz5sxx2v/zn//o9u3bptTs6eskNbLqWsTKe77J2f3799W+fXtdv37d7jE+Pj7q16+fVq9erRs3bmjv3r1asWKFZsyYoTlz5mjdunU6cuSIrl69+ngv52lnz55NMX/Y2hP7WmbvaaWmezmrjnkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBxsbGxOnbsmGbNmqXPP/9c48ePf9z2559/6uuvv9b8+fN1/Phx0/r8+++/tWjRIn311Vd6//33NWTIEA0aNEjDhw/X559/rlmzZunkyZOm9fek8PBwbdiwQd99952GDx+uwYMHa/DgwRo+fLi+++47bdiwQeHh4U71ERAQIEl68OCBGSUDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMJGvpwsAACA1iYmJUffu3XXgwAFlzJjR0+U8NnnyZPXr1y/eY65fv67Fixe7qSLPaNSokVv7i4mJ0WeffaaPPvpIMTExbu07MQICAtS1a1fDtt9//12hoaFuriiuyZMn61//+pdh28CBA7V8+XJT+zt16pT69Omj4OBgeXt727R7e3urXbt2ateune7du6ft27fr5MmT+uuvv3T37l2FhYUpNjZW6dOnV8aMGfXss8+qZMmSql27ttKlSxdv3x999JGuXr1q6tdjho4dO3qk33379qlZs2a6e/eu2/sePXq0evfurfTp09u0eXl5afDgwRowYID++OMP7dy5U6dPn9atW7f08OFDZc6cWTlz5tSzzz6rxo0bq3z58vLy8rLJs2TJEn355Zf67LPPTK09NDRUzZs315YtW5Q1a1bDY9KnT6933nlH77zzjq5cuaI9e/bo2rVrunbtmiIjIxUQEKBcuXKpfPnyKlmypGH9j0RHR6t79+66ePGiqV+Ho6ZOnarmzZurQ4cONm3e3t6aNWuWypcvb8rYtnPnTp07d04FChSwe8ySJUuc6mPz5s26ceOGsmXLZveY4OBgp/p42rFjx9S1a1f9/vvv8vHxMTymU6dO6tSpk86dO6e1a9fqn3/+UUhIiO7evatMmTIpV65cKlmypOrUqaN8+fLF29/GjRs1aNAgU7+G1ODevXvq06eP1qxZIz8/v8dxLy8vdenSRV26dNGNGze0fft2XblyRSEhIfLx8VFgYKBy586tGjVqKEuWLAn2c+PGDbVt29bpD7J3hpXHZEn64YcfNHjwYOXNm9ewvUiRIho7dmyicn3yySf68MMPzSzPpXr16qUCBQqoevXqhu3e3t7q1auXevXqpdDQUO3cuTPO9ZorVy7lzZtXNWrUUIYMGRLsb8mSJXrrrbfM/jIAUzg7v/r4+ChDhgwunWOtOt6m9vWvO1jh+n3k77//VufOnbVy5Uq7taZLl07Dhg3TsGHDdOHCBe3du1chISG6du2afHx8lDlzZhUtWlSVKlWyuw4PCQlRly5dVLt27STXmNJZ6XqRrDWGsLZKGGOA61jtuZ2QSZMmaeLEifEeM23aNEVHR5ved0r7XsaHvXZbKXU/0R1S8/4KPC82NtbTJTzm7e2tOXPmKDAw0Kbtxo0b6ty5s2nz18WLF/XTTz9p8ODBceIlSpTQ5s2b1a9fP+3YscPmvFy5cunbb79Vp06dbNpOnTqlGTNmmFJfUlhpTrLaWuGvv/5S586dtWLFCofX4FmyZFGxYsVUuXJlZc6c2TDHhQsX9PLLL2vPnj0O1WlPdHS0OnTooN27d9u9T8qdO7cmT56sH374QVu3btXff//9+H4wS5YsKlq0qKpWrWr3NZc1a9Zo4sSJaty4sWl1W+06SQmsuhax6p5vcnfixAnVr19f69atU65cueI9NiAgQJUqVUpS/hs3bqh58+a6c+eOM2UmK+7e1zJ7Tyu13ctZdcwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABILmrXri1JunjxoocrAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPA0X08XAABAavPXX3/ptdde0/Tp0z1dymPbtm3TiRMnVKJECbvHzJo1S5GRkW6sKmXbvXu3Xn/9dW3bts3TpdjVvXt3ZciQwbBt8uTJbq7G1qpVq3ThwgU988wzNm0tWrTQM888owsXLpja58KFC9W1a1fNmjVLfn5+do8LCAhQ48aN1bhxY6f7XLdunb7++mun86QUM2bM0KBBg3T//n2P9H/lyhUNGTJEP//8s91jfH199cILL+iFF15Icv5Nmzape/fuzpQYr2PHjqlevXpas2aNcufOHe+xuXPnVsuWLR3qJzIyUl26dNHq1asdOt9VXn75ZdWoUcNw3MibN6+mTZumF1980ZS+5s+frzfffNNu+6JFi5zKHxMTo+XLl6tHjx52jwkKCnKqDyNLly5Vly5dNHv27HjHwQIFCqhfv34O97Nhwwa1adNGERERDudIzTZu3KhXXnlFU6dOlZeXl017tmzZ1KJFC4fzh4SEqGnTpvr777+dqNJ5Vh+Tb926pR49emjt2rXy9vZ2WT/JUXh4uBo1aqSFCxeqadOm8R6bPXt2NW/e3OG+Zs6cqX79+ik2NtbhHICruWt+lRybY6083qb29a87JPfr90lr165Vhw4dNHfuXKVJkybeY5955hnD+4b43Lp1Sy+++CJ/oCceVrpeJOuMIaytEocxwHWs9tyOz6xZs/Tll18qXbp0hu2xsbHxromclZK+lwlhr91WSt1PdLXUvL8CPGnUqFGqX7++TTw2Nla9evUy/TXTYcOGqV69eipfvnyceOnSpbV9+3YdO3ZM+/fv17Vr15QxY0YVLVpUtWrVko+Pj02uiIgIde7cWQ8fPjS1xsSy0pxktbXCmjVr1LFjR82ZM8dla/BmzZopJCTE4Rrjc/z4cb3yyiuaNWuW4Wstj/j5+al+/fqGz8H4cnfr1s2MMm1Y7TqxOquuRay855vcHT16VNWrV9fcuXNVo0YN0/KeO3dOLVq00MmTJ5U+fXrT8nqau/e1XLGnlZru5aw65gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHial5eXJkyYoBo1akiSVqxY4eGKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADzN29MFAACQGv3yyy+aP3++p8uIY8qUKU61I3F27dqlrl27qmrVqtq2bZuny4nXgAEDDOPnzp3T2rVr3VyNrdjYWE2fPt2wzdvbWy+//LJL+g0KClKTJk30zz//uCT/kxYvXqwWLVooOjra5X0ldwcPHtQLL7yg3r176/79+x6tZfLkyRo1apTpeYOCgtS0aVPdvXvX9NxPOnz4sKpUqaKNGze6JP+VK1fUrFkzLVy40CX5nXHr1i316NFDMTExhu2tW7fWoEGDTOkrKCjIbltYWJjWrVvndB+LFy+22/bXX39p3759TvdhZP78+WrYsKEuXbrkkvw//PCDmjRpojt37rgkf2oxffp0denSRQ8fPjQ174EDB1S7dm0dOHDA1LyOsvqYvH79enXr1k3h4eEu7Sc5un//vlq2bKnx48fbHZedER4errffflu9evVSVFSU6fkBs7l6fpWcm2OtPN6m5vWvuyT36/dJv//+u5o1a2Z6rRcuXFCDBg20Y8cOU/OmRFa6XiTrjCGsrRKHMcB1rPbctufOnTsKDg62275u3Tr99ddfLutfSjnfy8Rgrz2ulLyf6GqpeX8FkKRGjRrp/fffN2z76quvtGzZMtP7fPjwodq3b293DC9VqpS6du2q119/XX379lXdunXl4+Njc1xUVJT+/e9/e3z8sdKcZLW1wm+//eaSNfjff/+tmjVr6siRI6bmfdrs2bPVr18/RUZGmpbz8OHDev7553X9+nXTcj7NateJ1Vl1LWLlPd/k7p9//lGdOnU0YsQIU54jc+bMUZUqVVw+5nmKO/e1XCG13ctZdcwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADwlKxZs2rFihUaMmSIJOnvv//WqFGjPFwVAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgKd5e7oAAABSq1deeUUXL170dBmP/fLLL4qKijJs27Vrlw4fPuzmilKOs2fP6quvvlKNGjVUrVo1zZ0719MlJahq1aqqWLGiYdu0adMUGxvr3oLsmDJlit1aXnrpJXl7u2a5u3HjRpUpU0ZfffWVwsLCTM8fGhqqQYMGqV27dnr48KHp+a3i7t27mjNnjho3bqwKFSpo9erVni7psf/85z/q1KmTbt686XSu69evq3v37urcubPbft6XLl1Sw4YN1b9/f12/ft2UnLGxsQoKClL58uW1bt06U3K6wsaNGzV27P9j777jpKrOx/E/uywsvUpRUaQqKBALIIodCwKCLX5IscUSe2LUGEtMrLEbEzXR2GKJYkNApBgVFBQsAURRFEtEBZHe2+7vj/z0K87ssmVmZ2b3/X69eCnPufc5z+w999x7zw4zN5TYfvPNN8cuu+xS6X6mTp0an3/+edK28ePHp+RYjx07NjZs2JC07Yknnqh0/tJMnjw5dtlll/jb3/4WRUVFKck5e/bs2H///ePMM88s8Z6E8hk+fHjsscce8eabb1Y619q1a+Paa6+NXr16xUcffZSC6lIn1+fkxx9/PPr16xeTJ0+ukv6yycaNG+OCCy6IvfbaKyXj9FsTJkyIH/3oR3HTTTelLCdUhXRcXyNSd43N5fm2Jt//VpVsH7/f9/LLL8fOO+8cDz74YEpqffLJJ6NHjx4xY8aMFFRXM+TSeInInTnEvVXZmAPSJ9fO7ZLcfffdFWpLperysywLa+3/T3VfT0y3mry+Qs3WunXreOSRR5L+TnTq1Klx8cUXp63vuXPnRt++fSt8H7Rq1aoYMmRIPPzwwymurGJy6ZqUa/cKqb4H/+c//xm77rprvP/++ymobsseeOCB2GeffWLOnDmVzvXII49Enz594quvvkpBZaXLtXGS63L1XiSX13yz3aZNm+Laa6+NHXbYIa688sqYO3duufbfsGFDPPXUU7HXXnvFT37yk5StSWWrXF7XqonPcrk65wEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlfPll1/GFVdcEVdccUWMGzcu0+XkjJ133jn69+8fERHvvPNO7LPPPrFo0aIMVwUAAAAAAAAAAAAAAAAAAAAAAAD8UH6mCwCAmmrJkiVxwgknRHFxcaZLiYiIr7/+OsaMGZO07d57763ianLL2rVrY8mSJfHFF1/EtGnT4sknn4wbb7wxfvzjH0f79u2jY8eO8Zvf/CamTp2a6VLL7Je//GXSeFFRUdx3331VXE3JPv3003jppZeStm2zzTYxaNCgtPW9atWq+M1vfhNt27aNiy++OKZPn17pnG+//XZcdNFF0bFjx7jrrruiqKio8oVmsaKiolizZk0sXrw4Pvjgg5g0aVL84x//iPPPPz/69u0bLVq0iJ/85Cfx73//O9OlJvXEE09Et27d4rrrrotvvvmm3Pv/97//jYsuuijatWsXjz76aBoqLF1xcXHcfffd0a5duzjzzDPjP//5T4XyrFmzJp544onYfffd47jjjouFCxemuNLUu/zyy+ONN95I2la3bt14/PHHo27dupXu58knn0waf/bZZyudOyJixYoVMXHixKRtTzzxREr6KM2SJUvijDPOiC5dusQdd9xRoQ8i37RpU7z88ssxdOjQ2HnnnUt8PVTcrFmzok+fPjFs2LAKXasWLFgQN910U+ywww5x6aWXxoYNG1JfZArk+pz81ltvRb9+/aJv375x1113xfTp02PTpk1VXkemTJ06NXr16hX9+/eP5557LtavX1/uHKtWrYrHH388evXqFYccckh88MEHaagU0i8V19eI9F1jc3m+rcn3v1Ul28fv9y1dujROPPHE6Nq1a9x///2xfPnycu1fVFQUEyZMiL333juOPfbYWLJkScprrO5yabxE5NYc4t5qy8wB6ZNr53YykydPjtmzZyfEv/nmm3jmmWeqrI7q8LMsK2vt/091X09Mt5q+vkLNk5eXF48++mi0bt06oW3JkiXx4x//ODZu3JjWGr766qvo1atX/PrXvy7zPVFxcXE89NBDseOOO5b4/oRMyaVrUq7dK6TiHnz06NHRt2/fOOGEE2Lp0qVpqbMkU6dOjV122SXOOeec+OSTT8q1b3FxcUyaNCn22Wef+NnPfharV69OU5WJcm2c5LpcvRfJ5TXfXLBkyZK44oorolOnTrHbbrvFGWecEffcc0+MGzcupk6dGrNnz44ZM2bEq6++Gk8//XRcc801MXTo0GjevHkcc8wx8dprryXkLO29DNn6u9yyytV1rZr4LJercx4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUHHz58+PK6+8Mq688sp44YUXMl1Oznj11VfjkksuiYcffjj69u0b8+bNy3RJAAAAAAAAAACQ4KWXXkr6B4DcYB4HAKh57rjjjqT3gDvttFOmSwNqGM+kUDM416HsnC8AAAC5L6+4uLi4TBvm5aW7FgAAyGmtW7eOgw46KHbeeefo0qVLdOjQIRo1ahQNGzaMhg0bRkTEqlWrYvny5bFixYqYP39+vPPOO/HOO+/E1KlTY+7cuRl+BVRUnTp1Yr/99os+ffpEnz59YptttommTZtGs2bNoqCgIJYvXx5Lly6NDz74IP7zn//E+PHjY9q0aZkuO8EOO+wQ++23X+y5557RqVOn2H777aNx48ZRv379yMvLi+XLl8eyZcviiy++iOnTp8cbb7wRzz//fKxcuTLTpZMFatWqFXvvvXfsvffeseuuu0b79u2jTZs2Ua9evSgsLIylS5fGihUr4tNPP4333nsv3n777Rg7dmwsXrw406XnpH/961/xf//3fwnxESNGxJFHHlnifl26dInBgwfHrrvuGt26dYsWLVpE48aNIy8vL5YtWxZLly6NDz/8MKZPnx6TJk2KV155Jcq4dJQ1qsucXL9+/e9qb9q0adSvX7/EbefMmRPvv/9+FVaXXo0aNYrDDjss9thjj+jZs2dst9120aRJk2jUqFEUFxfHsmXLYtmyZfHxxx/HzJkzY9q0aTFhwoRYt25dpkuHlNvS9XXTpk2xYsWKjFxjq8N86/43vbJ5/P5QnTp14uCDD4699torevbsGe3bt48mTZpE48aNY926dbFs2bJYuHBhzJw5M958880YOXJkLFiwoEprrO5yabx8K1fmEPdWW2YOSJ9cPLezVU37WVprJ1Vq8voKVLUGDRrEwQcfHIMHD45u3bpF69atY6uttoqVK1fGggUL4r///W+MHTs2nnvuufjvf/+b6XLLLFeuSbl2r7Cle/Dly5fH/PnzY9asWfH666/HqFGj4ptvvikx3+effx5t27ZNiP/mN7+JW265JeX177nnntG/f//o3bt3dOzYMVq0aBH169ePTZs2xbJly2Lx4sUxa9aseOutt2LEiBHx2WefpbyGisi1cVId5Nq9SHVY860J2rdvHx9//HHStlNPPTX+8Y9/VHFF6WNdK7fk2pwHAAAAAAAAAAAAAJX5bC2f1Q6UpEePHtGjR4+I+N888/HHH8frr7+ec5/nBwAARJx88snRtVvXTJdBDTFlypR45ulnMl0GQNpccukl0axZs0yXQQ3x9FNPx2uvvZbpMgDSomnTpnHpZZdmugxqmJtvujnmz5+f6TIA0qJDr4hjrsp0FdQkNxyW6QoAqre8vLzYY489okuXLt+933vmzJkxc+bMDFcGAECuufKqK6NevXrWyAGq2LfvM7vjr3fEp59+mulyAGqMM886M9q3bx/33ntvvD/bd8sBVIVv/+2i974DVK0jjzoy9tprrxjz3Jh46aWXMl0OQI0x4PABceCBB8aLL74Yz495PtPlAACQhM9qB9LBZ7UDAAAAQGp9+x4MqErecwnUJK61ZIp/YwbUJAefHbHroExXQU0z/i8R05/LdBUAVctntWcX76kFqoOS5iz/rgggN5jHAQBqntdeey323HPPhHifPn1i2rRpGagIqKk8k0LN4FyHsnO+QHIdO3aMzp07R5MmTaJJkybRqFGjyM/Pj5UrV8by5ctj2bJl8fnnn8d7770XGzZsyHS5AOSIvLy86NWrV3Tu3Nn7aYEyK8t7vAuqoA4AAKgRFixYEI8++mimyyAD1q9fHxMmTIgJEyZkupRK+fTTT+PTTz+NBx98MNOlkIM2bdoUkyZNikmTJmW6FEoxZ86cuPnmmzNdRlpVlzl59erV8dFHH2W6jIxYsWJFPPHEE/HEE09kuhTIuGy+vlaH+db9b3pl8/j9ofXr18dzzz0Xzz3n0/0yJZfGy7dyZQ5xb7Vl5oD0ycVzO1vVtJ+ltXZSpSavr0BVW7VqVYwYMSJGjBiR6VJSKleuSbl2r5Dr9+Cvv/56vP7665kuo9xybZxUB7l2L1Id1nxrgqZNm5bYtmTJkqorpApY18otuTbnAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkFq77LJL/N///V/sv//+0bNnz2jYsGGZ9tuwYUO899578frrr8fw4cPj5ZdfjqKiojRXWzZt2rSJrl27xnbbbRcNGzaMRo0aRWFhYWzYsCFWrVoVS5Ysiblz58acOXPim2++yXS5AABUQkGmCwAAAAAAAAAAAAAAAErWqVOnEtvmzZtXhZUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANV1BQUGceuqpce6558ZOO+1UoRy1a9eOnj17Rs+ePeP000+Pr7/+Oh588MG4/vrrY9GiRSmuuHQtW7aMIUOGxOGHHx4HHHBANG3atMz7zpkzJ/7973/HI488EpMnT05fkQAApEV+pgsAAAAAAAAAAAAAAABK1rt37xLbPvzwwyqsBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKjJfvazn8WHH34Yd955Z+y0004py9uqVau48MIL45NPPok//OEPUa9evZTlLknXrl3j3nvvjc8//zzuueeeOPLII6Np06blytGlS5c444wz4tVXX4133303jj766PQUCwBAWhRkugAAAAAAAAAAAAAAAKBk/fr1Sxr/73//G4sXL67iagAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAg0d577x2XXXZZQvyVV16Ja6+9NgMVkWqOMdRs5gBKY3wA1Czm/arnZw6QW6rzvN2sWbO4//77Y8iQIWntp1GjRnHFFVfEscceG8cdd1zMmjUr5X3UrVs3/vCHP8RvfvObKCgoSFnebt26xZNPPhkTJ06Mn/3sZzFv3ryU5QYAID1SdzcIAAAAAAAAAAAAAACkVNeuXWPPPfdM2vbiiy9WcTUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkFzr1q3jsMMOS4ivXLkyA9WQDo4x1GzmAEpjfADULOb9qudnDpBbquu8vdtuu8Wzzz4bbdu2rbI+u3XrFm+88Uacfvrp8c9//jNlebfZZpsYN25c7LLLLinL+UP77bdfzJw5MwYOHBivvfZa2voBAKDyCjJdAAAAAAAAAAAAAAAA5LILL7wwvvjii3j00UdTnvvcc88tsW3UqFEp7w8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgW717947x48dHkyZNSt1u06ZN8eqrr8bEiRNjxowZ8fHHH8eSJUti9erVUVRUFPXq1YvGjRvH9ttvH127do1+/fpF//79o3HjxiXmrFu3bjzwwANRr169+Pvf/17p19KhQ4d46aWXYvvtt9/itkVFRTFv3rxYvHhxrFq1KjZt2hSNGjWKpk2bxnbbbRcFBQWl7t+sWbOYMGFCHHTQQTF16tRK1w4AQHqUflcHAAAAAAAAAAAAAAAk1bp163jooYfi4IMPjuXLl8dbb70VH3zwQcry77333nHaaaclbVu4cGGMGjUqZX0BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfN9uu+0WEyZMiMaNG5e4zYIFC+Lmm2+OBx54IBYuXLjFnO+9916MHTs2br311igsLIwhQ4bExRdfHLvuumvS7fPy8uKuu+6KoqKiuOeeeyr8WurVqxcjRoyI7bffvsRtZs6cGY888ki88MILMWvWrFi/fn3S7QoLC6Nnz54xePDgOPHEE6Nt27ZJt2vQoEE89dRTseuuu5bpZwMAQNXLz3QBAAAAAAAAAAAAAACQaw4//PB455134uCDD46IiMaNG8eECROiY8eOKcnfrl27eOSRRyI/P/nb/v/617/Ghg0bUtIXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwPc1a9Ysnn766WjcuHHS9qKiorj55pujffv2ceONN8bChQvL3ce6deti+PDhsdtuu8XPf/7zWLx4cdLt8vLy4o477ojevXuXu49v3XLLLdG9e/ekbXPmzIlDDjkkevbsGTfccEO8/fbbsX79+lLrnjZtWlx++eXRrl27OP/882PVqlVJt912223jxhtvrHDdAACkV36mCwAAAAAAAAAAAAAAgFxy0EEHxXPPPRctW7bcLL7ddtvFtGnT4sgjj6xU/r333jumTZsW7dq1S9q+YMGCuPnmmyvVBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBJ/vnPf0a7du2Sti1btiwOPfTQuOCCC2LNmjUp6e/hhx+Onj17xsyZM5O2165dO5544olo1qxZuXN36dIlTj311KRtI0aMiB49esSECRPKnTcioqioKG699dbYc889Y8GCBUm3Of7446Nbt24Vyg8AQHrlZ7oAAAAAAAAAAAAAAADIJS+99FK88cYbSduaN28eTz/9dLz88stx1FFHRb169cqUMz8/P/r27RsjRoyIV199NVq1alXitqecckqsWrWqQrUDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlOYnP/lJDBo0KGnbsmXLYr/99osXXngh5f3Omzcv+vXrF2+//XbS9u233z6uv/76cuft1atXrFu3LiH+4osvxtFHH520rbxmzZoVBx98cGzYsCGhLS8vL04++eRK9wEAQOoVZLoAAAAAAAAAAAAAAADIJUVFRfHTn/40pkyZEltttVXSbfbbb7/Yb7/9YsOGDfHWW2/FnDlzYt68ebFixYpYu3ZtREQ0a9YsWrRoEe3atYt99tknmjRpssW+//SnP8Xo0aNT+noAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIiIKCwvjuuuuS9q2adOmOOKII2LGjBlp63/FihVx6KGHxttvvx3bbbddQvvJJ58cf/7zn+Pdd98tc85HHnkknn/++TjrrLPi3HPPja222ipWrlwZP/nJT6KoqChltb/zzjtx8803x8UXX5zQdvTRR8cFF1yQsr4AAEiNgkwXAAAAAAAAAAAAAAAAuebDDz+Mww8/PCZMmBBNmjQpcbvatWvHnnvuGXvuuWel+7zrrrvid7/7XaXzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACRzzjnnxPbbb5+07YorrohJkyalvYZvvvkmhg0bFpMmTYr8/PzN2mrVqhU33HBDDBw4sFw5Fy9eHFdddVXcdNNNcdJJJ0VhYWEsWLAglWVHRMTf//73uPjiixPiO+ywQ7Ro0SIWLVqU8j4BAKi4/C1vAgAAAAAAAAAAAAAA/NAbb7wRvXr1itmzZ6e1nw0bNsQFF1wQZ555Zlr7AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGquvLy8OPfcc5O2vffee/GnP/2pymqZPHly/OMf/0jaNmDAgOjUqVOF8q5ZsybuvPPOuPXWWytTXok+/fTTmDNnTtK2zp07p6VPAAAqLj/TBQAAAAAAAAAAAAAAQK768MMPY7fddovLL788Vq1alfL8r776avTp0yduvvnmlOcGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKgJ6tWrF82bN4+mTZtGXl5epsspVe3ataNZs2bRpEmTrK81G9SqVSuaNm0azZo1i9q1a2e6nCpTp06daN68edSvXz/TpWxRo0aNatzxIT1yYSzlQo2UX2FhYTRv3jwaNmyY6VJIo1y6tlL1zO+plSvnWy4cd8+PpcvmY/jt/UW9evUyXUqNVRPv8XJlfSzb57Zsry+b575Uqimvs6xy5fzOJGMmc7695tatWzfTpWSNmngfUhWqwz12rpwvxnDNcdhhh8V2222XtO23v/1tbNq0qUrrufTSS2PNmjUJ8by8vDjllFOqtJby+Pzzz5PGmzZtWrWFAACwRQWZLgAAAACA8vnyyy/j/fffT4h/8cUXGagGAAAAAAAgM+bOnRsrV65MiC9evDgD1QA13dq1a+Pqq6+Ov/3tb3H88cfHL37xi+jWrVuF861bty6ef/75uOOOO+KFF15IYaUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKnXrVu3hNiCBQti0aJFJe5TWFgYPXr0iE6dOkWTJk2iUaNGkZeX91377bffHmvXri1XHbVr144DDjggDjvssOjRo0fsvPPO0bJly6hVq9Z32xQXF8fSpUtj8eLFMWPGjJg4cWJMnDgxZsyYUa6+UuFHP/pRDBo0KPbYY4/o3r17bLvttlFYWLhZrcuXL4/33nsv3nrrrRgzZkyMHz8+Nm3aVOW1lldhYWF07NixxPYVK1bE559/Xq6cvXv3joMOOih69+4dP/rRj2KrrbaKhg0bbrbN+vXr44svvohZs2bFf/7znxg9enS88cYbFXoN6VLe86VZs2Zx5JFHxsEHHxw9e/aMDh06bDZONm3aFPPnz4+ZM2fGG2+8Ec8880xMnz49XeWXqLCwMA499NA49NBDo2fPntG1a9do1qzZZuf1+vXr47PPPotZs2bFlClTYsSIEfHRRx+lrIZsmYvKo3PnzlG7du2E+FdffRVLliypdP5GjRrFdtttlxCfPXt2FBcXVzp/+/bto169egnxDz/8MDZs2FChnNkwlqpDjZVR2Tk8Ly8vunbtWmL7e++9V6n60mmXXXaJIUOGRO/evaNHjx6x7bbbbnaOFhcXx5IlS+Ldd9+NmTNnxvjx42P8+PEpnSdatWoVW221VUJ8S/NZeZV0nIqKiuL9998vcb+tttoqWrVqVWL79ttvnzTepEmTpPN0adavX1+m8ybXrq2O8f9T1mNcVTI1vzdt2jS22WabpG2LFy+O+fPnVyr/9zVu3Djatm2btO3LL7+MpUuXlrp/rp1vZZEr1/Wqen7MxTkg24/htttuG0ceeWTsu+++0bNnz9hhhx2iTp0637Vv3LgxPv300+/uLUaMGBELFiyoktrKKxfHR0R23ONVpVxaH8v2tbFsri/b575UyZbXmS1rTlV9fufivJ8tY6aicvFn/n3NmjWLIUOGxIABA6JHjx7RsWPHza65q1evjoULF8bs2bNjwoQJMX78+Jg1a1bK+s+Wc/X7suE+JNvXISpim222iWOOOSb69esXu+66a2y//fab3WNv2rQpvvzyy3j33XdjypQpMXLkyBLnwYKCgmjevHlCfPHixbFx48aU1v19mT5fysoYrtxaWrbP21tyyimnJI2/9957MXr06CqtJSLim2++ifvvvz/OPPPMhLYTTzwxLrnkkigqKqryurakpPW2+vXrV20hAABsUV5xGd9N9f3FAwAAAAAAAAAAAAAAoGRt27aN/fffP3bdddfo2LFjtG/fPho3bhwNGjT47sNM161bF2vWrImvv/46Pv/885g5c2ZMmzYtXnrppVi1alWGXwEAAAAAAAAAAAAAQPVTxo9lT8pntQMl6dGjR/To0SMi/jfPfPzxx/H6669Xas4BAAAy4+STT46u3RK/7BnSYcqUKfHM089kugyAtLnk0kuiWbNmmS6DGuLpp56O1157LdNlAKRF06ZN49LLLs10GdQwN990c8yfPz/TZQCkRYdeEcdclekqqEluOCzTFQBUb3l5ebHHHntEly5dvnu/98yZM2PmzJkZrgwAgFxz5VVXRr169ayRA1Sxb99ndsdf74hPP/000+UA1BhnnnVmtG/fPu699954f/b7mS4HoEb49t8ueu87QNU68qgjY6+99ooxz42Jl156KdPlANQYAw4fEAceeGC8+OKL8fyY5zNdDgAASfisdiAdfFY7AADUPAcccEAcPvDwTJdBDeP3kEBN8u17MKAqec8lUJO41pIp/o0ZUJMcfHbEroMyXQU1zfi/REx/LtNVAFQtn9WeXbynFhIlG/+//e1v44Ybbtgslp+fH8cee2yceuqpsd9++0VBQUGJOVu0aBGLFy8uU/9t2rSJCy64IE499dRo3Lhx+Yr//73xxhtx3XXXxYgRI9J6PtevXz9OPfXUOO+886J9+/bl3n/hwoVx2223xa233hpr1qypcB0lvcZU/LuiJk2axHPPPRd777130vb//ve/ccghh8QHH3ywxVy1a9eOX/7yl/HLX/4yunXrVqF65s2bF7fffnv8/e9/j+XLl1coRyqV9Xxp27ZtXH755XHSSSdF7dq1y9XH+++/H9dee2088sgjUVRUVKl6t2S77baL3/3ud/Hzn/88GjZsWO7933jjjbj22mtjxIgRla4l03NRRTzzzDMxdOjQhPi9994bp5xySqXz//73v48//vGPCfG99tqr0uvYBQUF8c0330STJk02iy9ZsiRatWoVGzduLFe+bBpLJcmmGtM5j7/66quVmsPr168fq1atKrE92/4Na+3ateOEE06ICy64IHbcccdy779q1ap4+OGH4/rrr49PPvmk0vVcd911cfHFFyfEk81nlVHScVq5cmU0atSoxP1KmlfS4ZVXXol99913i9vl2rXVMf5/ynqM0y3T83vz5s1j1qxZsfXWWye0ff3119GtW7dYtGhRhXL/0EsvvRT7779/Qvyrr76KXXbZZYv3Pbl2vpUm08e9LDLx/JhLc0AuHMPx48dH//79y3X/s3Hjxnj44Yfjj3/8Y8J3e7z22mux5557JuzTp0+fmDZtWmXL3aJcGh/Zdo9XFXJlfSxb1sZytb5smfvS+UwakT2v81uZXnPK1PmdS/N+to2Zisq2n3lZz/VWrVrFZZddFqeddloUFhaWu47f//738fLLL5drv2Qyfa5+K9vuQ7J9HaI8evfuHVdddVUcfPDB5b7mvPnmm3HVVVfFyJEjN4vvu+++MXHixITty3uPnWvnS2mM4c1ly1paVa+jFRQUxJIlS5JeV3/1q1/Fn//85yqr5ft69uwZ06dPT9pWVc/G5TVq1KgYNCjxjdZDhgxJmJMAKJu8vLzo1atXdO7c2ftpgTIry5pYfhXUAQAAAAAAAAAAAAAANcq8efPi4Ycfjt/85jcxdOjQ6NmzZ7Rv3z5atWoVjRo1ikaNGsVWW20V2223Xey+++4xdOjQ+P3vfx+jR48u9UMtAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABy0U477RSvv/56PPbYY3HQQQdFQUFBpXPm5eXFBRdcEJ988kn85je/icaNG1c4V69eveLpp5+OyZMnx9Zbb13p2pIZNmxYfPrpp3HbbbdF+/btK5SjZcuWcc0118SHH34YBx54YIorrLytt946Xnnlldh7772Tts+aNSv69u0bH3zwwRZz7b333jF9+vS4/fbbo1u3bhWuqW3btnHDDTfEp59+GieccEKF81SlE088MWbPnh2nnXZa1K5du9z777TTTvHPf/4zpk+fHj169EhDhRG1a9eOa665JubOnRtnnHFGNGzYsEJ5evXqFc8880y88sor0aFDhxRXmSgdc1FlDB8+PGl88ODBkZeXV+n8RxxxRIn5K2u//faLJk2aJMRHjBgRGzduLHOeXBhLuVBjqmy99dYpmcNzxSGHHBIffvhh3HPPPbHjjjtWKEeDBg3i9NNPjw8//DBuueWWqFu3boqrrLnefffdlOXKhWtrTZTKY1wR2TK/L168OI4//vgoLi5OaGvVqlXcfffdFarrh84999zYf//9E+LFxcVx/PHHx+LFi1PST7afb9ly3LekJjw/VnQOyIVj2LJly3j66afj4IMPLvd9fUFBQZx44okxa9asOPPMM1NaVy6pzDWipt3j5dL6WLbPbdlcXy7MfamQy6/T+nflVOf7gmyVquexI488Mt57770455xzorCwsNz777PPPvHSSy/Fk08+GQ0aNEhJTaVJ9/pwTbsPqSqNGjWKhx9+OKZOnRqHHHJIhdbO99hjj3j22WfjqaeeiubNm6ehyi3LhfPFGM5eVb2O1qdPn6TX1eLi4hJ/t1UVZsyYUeLvKA466KAqrqZsWrdunTS+ZMmSKq4EAIAtyc90AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABA9dSnT5947bXXolevXinL2bhx43jxxRfjxhtvjLp166Ysb9++fePtt9+OPn36pCxnvXr14sknn4xHH300WrZsmZKc2267bUyYMCEuuuiilORLhc6dO8drr70W3bt3T9r+yiuvRL9+/eLLL7/cYq4TTjghJk6cGN26dUtZfc2aNYsHHnggnn766SgsLExZ3lS77bbb4v7774+GDRtWOlf37t3jjTfeiBNPPLHyhX1P27ZtY9q0aXHJJZdE7dq1U5KzX79+MXPmzBg4cGBK8iWTjrmoskaNGhVr165NiLdq1Sr23HPPSuVu06ZN7LbbbknbBg0aVKncERFHHnlk0vjw4cPLnCMXxlIu1Jgq387jyZRnDs8F+fn5cccdd8S4ceOiXbt2KclZq1at+PWvfx0zZ86MnXbaKSU5a7p33303JXly4dpaU6XqGFdEts3vL7zwQtx2221J24466qj46U9/WqnaunTpEn/605+Stt16663xwgsvVCr/t7L9fMu2455MTXl+jKjYHJALx7B3794xa9asEu+Xy6pBgwZxxx13xN133x35+fkpqS2XVGR81MR7vFxZH8v2uS3b68uFuS8Vcvl11vT171SorvcF2SwVz2MXXXRRPP3009GiRYtK5zr66KPj9ddfjx122KHSuUqSzvXhmngfUlW6desWM2bMqPRz8beOOuqomDx5cmy99dYpyVdW2X6+GMPZr6rX0Q488MCk8VmzZsVXX31VpbX80IQJE5LG+/fvX8WVbFlhYWGJv+/+4IMPqrgaAAC2pOb9NgYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASLsOHTrE2LFjo2nTpinL2axZs3j55Zdj//33L9P2RUVFsWrVqti4cWOZtm/Tpk2MHj06tttuu0pU+T/NmzePl19+OY4++uhK5/qh/Pz8uP766+PSSy9Nee7y2n333WPy5MnRrl27pO3PPvtsHHzwwbFs2bIt5jrppJPi/vvvj1q1apWp7zVr1sTq1aujuLi4TNsfeeSRMW7cuCgsLCzT9lXptttui/POOy+lOevUqRP33XdfnHvuuSnJ17lz55gyZUr86Ec/KtP2GzdujDVr1pRp2wYNGsSIESPiuOOOq0SFyaVjLkqFlStXxrhx45K2DR06tFK5Bw0aFHl5eUnbunfvHttvv32l8h9xxBEJsaVLl8a///3vMu2fC2MpF2pMldLm8fLM4bmgbt268eyzz8aZZ56Zlvzfjpu99947LflrknfffbfSOXLh2lqTpeIYV0S2zu8XX3xxzJw5M2nbX//619h2223LnTPif88N//znP6NevXoJbTNnzozf/e53Fcr7Q9l+vmXrcf++mvL8+K3yzgG5cAz322+/+Pe//x2tWrWqVJ7vO/XUU+Pvf/97yvLlivKOj5p4j5cr62PZPrdle31VMfdlg1yY40tS09e/U6U63hdku8o+j5111llx/fXXp6ia/9lll11i/Pjx0ahRo5TmjUjv+nBNvA+pKj179oyJEydG+/btU5p3p512in//+9/RoEGDlOYtSbafL8ZwbqjqdbTdd989aXzSpElVWkcyL7/8ctL4brvtVrWFlMGhhx6adK756KOP4uuvv85ARQAAlKYg0wUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANVLrVq14umnn46mTZumNO8jjzwSu+66a4ntr7zySjz55JMxefLkmDNnTqxYseK7tkaNGkX79u1j//33j+OPPz523333pDm22mqreOqpp2LvvfeODRs2VKjOOnXqxKhRo6J3794lbrNp06aYPHlyjBkzJt58881YsGBBLFq0KPLy8qJJkybRuXPn2HfffWPYsGGxzTbbJM1x9dVXx0cffRSPP/54heqsrIMOOihGjBgRDRs2TNp+zz33xC9/+csoKiraYq4OHTrEX//618jLy0va/uWXX8ajjz4a48aNi1mzZsXXX3+9Wd7mzZtHly5dol+/fnH00UfHnnvumTTPfvvtF7fffnucfvrpZXiFVeP444+P8847LyG+fv36GDduXDz//PMxffr0mD9/fqxevToaNGgQrVu3js6dO8dhhx0WAwYMKPFcy8vLi9tuuy0+/vjjGD16dIVrbN68eYwfPz622267EreZOXNmPP744zF+/PiYO3duLFmyJCL+dz5stdVWsccee8QhhxwSP/3pT5PWW1BQEA8++GB8+umnMXXq1ArX+n3pmotS5fHHH48hQ4YkxIcOHRq//e1vK5z3iCOOKLV94MCBcdddd1Uo96677pp0HDz77LNlmjNzYSzlQo2pUto8Xp45PFc89NBDMWjQoBLbi4qK4rXXXotRo0bFG2+8EfPnz4/FixdH/fr1o3Xr1tGpU6c4/PDD47DDDitxXmnWrFk899xz0bdv35g9e3aaXklmzJs3L15//fUS21u0aBGdO3dOiC9evDjmzJlTrr5mzZpV7vq+Lxeurdkol45xRWTz/L5+/foYNmxYvPXWW1G3bt3N2po2bRoPPPBAHHzwwWXO962LLroo+vTpkxBfu3ZtDBs2LNavX1/unD+U7edbNh/3b2XL82O2zgG5cAw7duxY6rPxunXr4sUXX4wxY8bEzJkzY8GCBbF06dIoLCyMFi1aRPfu3aN///4xZMiQaNy48Wb7nnLKKTFjxoxy15Rq2To+ImrmPV4urI9ly9yWq/VV1dzXp0+fjD6T5sIcX5Lqvv6drfN+Lo+ZLcnWn/kP7bnnnvHnP/85IV5cXByTJk2KESNGxJtvvhlffPFFrF69Oho3bhwtW7aMXXfdNQ4//PA49NBDo1atWklzd+7cOR588ME46qijKlzfD6V7fbgm3odUhTZt2sTYsWNjq622KnGbtWvXxosvvhijRo2K2bNnx4IFC2LJkiXfPXO2a9cuBgwYEAMHDowWLVpstm/Xrl3jrrvuin/84x9pfR25cL4Yw5VT2tydLfN2RXTp0iVpfPr06VVaRzIzZ85MGm/atGm0aNEiFi1aVMUVJZefnx/XXHNN0rZHHnmkiqsBAKAs8oqLi4vLtGEJb24EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMh2ZfxY9qR8VjtQkh49ekSPHj0i4n/zzMcffxyvv/56peYcAAAgM04++eTo2q1rpsughpgyZUo88/QzmS4DIG0uufSSaNasWabLoIZ4+qmn47XXXst0GQBp0bRp07j0skszXQY1zM033Rzz58/PdBkAadGhV8QxV2W6CmqSGw7LdAUA1VteXl7sscce0aVLl+/e7z1z5syYOXNmhisDACDXXHnVlVGvXj1r5ABV7Nv3md3x1zvi008/zXQ5ADXGmWedGe3bt49777033p/9fqbLAagRvv23i977DlC1jjzqyNhrr71izHNj4qWXXsp0OQA1xoDDB8SBBx4YL774Yjw/5vlMlwMAQBI+qx1IB5/VDgAANc8BBxwQhw88PNNlUMP4PSRQk3z7HgyoSt5zCdQkrrVkin9jBtQkB58dseugTFdBTTP+LxHTn8t0FQBVy2e1ZxfvqYVEycb/b3/721i3bl3cdtttCW1LliyJZ599NkaPHh3vvPNOLFiwIJYtW1amvs4555y4/fbbk7a9/fbbccYZZ8S0adPKXPtRRx0V999/fzRu3Dhp+2mnnRb33HNPmfN937333hsnn3xyie1PPvlkXHrppTFnzpwt5iooKIizzz47rr322qhXr15C+7Jly2KXXXaJefPmlam2kuas8v67omOPPTYefvjhqFOnTtL2q666Kn7/+9+XOd/IkSNj8ODBCfGioqL4/e9/HzfddFOsW7euzPn22muvuOuuu76bt3/okEMOiQkTJpQ5Xyok+9nfeuutcfLJJ0eTJk022+6uu+6Ka665Jr788sst5m3QoEH8+te/jgsvvLDE8bx8+fLYeeedyzxOfmjChAnRv3//pG2ff/55nH/++fHkk0+WKVfjxo3jt7/9bVx88cWRn5+f0D5v3rzYaaedYtWqVWWuryrnolRq2LBhLFy4MOrWrZvQttNOO8UHH3xQ7pyFhYWxePHiqF+/fonbPP/883H44RV7f+CVV14Zl19+eUJ80KBB8dxzW35oz/axlAs1VsU8Xt45/Fv169cv9bVk8t+wXn755XHllVeW2D527Ni46KKL4p133tlirgYNGsT5558fF110UTRs2DDpNp988kn86Ec/iuXLl5e5xuuuuy4uvvjihPhvf/vbuOGGG8qcZ0tKOk4rV66MRo0aVTjvUUcdFU899VRC/Mknn4xjjz22wnlLk2vXVsc4s7J9fo+IOPvss+Mvf/lL0rYzzzwz7rrrrjLn6t69e7z55ptJ5/mzzz477rjjjnLVlmvn27dy4bhn8/Pj92VqDsj2Y1hQUBBvvfVW0mfPTZs2xX333Rd//OMf44svvthirkaNGsW5554bl1122WbPCKtXr47FixdH27ZtE/bp06dPudZC0iVT4yMX7vFSLVfWx7J9bsv2+qpq7svkM2lE9s/xEda/S8vtvqBqVfXPvKRz/Z133onu3btvFnvuuefit7/9bbz77rtbzNutW7e4/fbb46CDDipxmx//+MfxxBNPVLredK8P58J9SC6uQ+Tl5cWkSZOiX79+SduLiori3nvvjUsvvTQWLly4xXx16tSJX//613HZZZcl/Gwvu+yyuPrqqxP2Ke89dq6dL98yhv+fdKyl5eo6Wl5eXqxZsyYKCwsT2vr16xeTJ0/OQFX/T35+fqxZsybpetdee+2VNf+O429/+1ucfvrpCfGVK1dGp06dYsGCBRmoCqB6yMvLi169ekXnzp29nxYos7K8xztxdQgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoILq168fl1122WaxdevWxfXXXx/t27ePk046KZ566qmYM2dOLFu2rEw5GzduHFdccUXStocffjh69+4d06ZNK1edTz/9dOy9994l1nDhhRdGXl5euXJGRPTv3z9OPvnkpG1r1qyJY489No499tiYM2dOmfJt3Lgxbrvttthrr71i4cKFCe1NmjSJP/7xj+WuszLOOOOMeOyxx6JOnToJbUVFRXHWWWfF73//+zLna9myZQwYMCBp27Bhw+Kaa66JdevWlavGKVOmRK9eveLpp59O2n7llVeWK1+6nHHGGdGkSZPv/r5s2bI46KCD4qyzzoovv/yyTDlWrVoVV199dey2224xe/bspNs0btw4br311grV+LOf/Sz69++ftG3y5Mmx++67x5NPPlnmfMuXL49LL700Bg4cGCtWrEhob9u2bUrGdDrmolRbuXJljBs3LmnbkCFDKpTzoIMOivr165e6zYEHHrjFbUqSrK7ly5fH+PHjt7hvLoylXKgxFUqaxysyh+eCXXbZJS6//PKkbRs3bozTTz89BgwYEO+8806Z8q1atSquuuqq6NmzZ4nzbvv27eOGG26ocM1UXC5cW6l6uTK///Wvf42xY8cmbbvpppuiU6dOZcpTu3bteOihh5Lerz///PNxxx13lLu2ZLL9fMuF414Tnh8rIxeO4XnnnRc9evRIiC9ZsiQOOeSQOO200+KLL74oU64VK1bENddcE7vuumt88skn38Xr168fbdu2LVddNUFNvMfLlfWxbJ/bsr2+qpz7MvVMGpEbc3xJavr6d6bk8pipTrp37/7d/397vR00aFC8++67Zdr/vffei0MOOSTuv//+Ere56KKLKl1nRHrXh2vifUhVOeWUU6Jfv35J21auXBn9+/eP0047Lek1N5n169fH9ddfHz169IiPP/54s7aLL7640vWWJpvPF2OYkmyzzTZRWFiYtG3evHlVXE2ioqKimD9/ftK29u3bV3E1iZo0aRIPP/xwnH766Unbr7766liwYEEVVwUAQFnkZ7oAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKD6GDZsWGy11Vbf/f2bb76JAw88MC6++OJYtmxZhXLWrl07/vWvf8XatWs3i48ZMyZ+/vOfx6ZNmyqUd9asWXHWWWclbevcuXMMGDCgXPny8/PjzjvvTNq2evXq2H///ePJJ58sd50REdOnT4/+/fvH6tWrE9p69+4dderUqVDe8vrDH/4Qd955Z+Tn5ye0rVu3Ln784x+X+DMoyeDBg6OgoCAh/vjjj8fw4cMrXOv69evjuOOOi9dee22z+IQJE+L3v/99hfOmUt26db/7/9WrV8eBBx4YL730UoVyzZ07N/r06RNvv/120vZjjjkm9t5773LXd8MNNyRtmzFjRvTv3z8WLlxY7lojIsaOHRvHH3980rZzzjknWrduXaG830rHXJQOJY3xoUOHVijf4MGDt7hNYWFh9O/fv9y5d9hhh+jRo0dCfOTIkbFhw4ZS982FsZQLNaZCafN4Rebw71u3bl2cfvrpJf7JlL/97W9Ru3bthPiGDRvi8MMPj7vvvrtCeT/++OPo06dPvP7660nbTzvttOjdu3eFclNx2X5tperl2vx+4oknJq2nfv368dBDDyWdv3/oiiuuiJ49eybEFy5cGCeeeGK5aypJNp9vuXDca8LzY2XkwjFs2rRpXHHFFUnb+vTpEy+++GKF6nv//fdj7733jnnz5lVo/5qiJt7j5cL6WLbPbdleXybmvqp+Jo3IjTm+NDV5/TtTcn3MVEdFRUVx3HHHVeh6W1RUFCeffHJMmjQpafsee+wR++67b2VLTOv6cE28D6kKDRs2jGuvvTZp24oVK+KAAw6o8DPnJ598Ev369Yu5c+du1l9VyMbzxRimJI0bNy6xbcGCBVVYSclKqqNRo0ZVXMn/s80228Sll14a77//fvz0pz9Nus0LL7xQ4v0MAACZt+XfwAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlFGXLl2++/+lS5dG3759Y8qUKZXKuWjRojjnnHOiffv2cfPNN8eqVati6dKlcfzxx1e23HjkkUfinXfeSdp20EEHlSvXUUcdFZ07d07aduaZZ8a0adPKXd/3zZw5M84///zv/j5t2rQ48sgjo0ePHrF+/fpK5d6SvLy8uOuuu+KKK65I2r58+fI47LDD4qmnnip37o4dOyaNP/jgg+XO9UMbN26Mk046KdasWRMPPfRQ9OzZMw455JCYMGFCpXOn2plnnhlvv/12pXKsWLEijj766FiyZEnS9l/96lflyveTn/wktt5664T48uXL48gjj4y1a9dWpMzvjBgxIv7xj38kxOvUqRNnnXVWpXKnYy5Kh5EjR8a6desS4nvuuWe0atWq3PkGDRq02d83btwYr776asJ2gwcPLnfuIUOGJI0PHz58i/vmwljKhRoroyzzeEXm8O/btGlT3H333SX+yYR99tkn9t5776RtF154YaWvB9/Ou19//XVCW15eXlxyySWVyk/lZOO1laqXa/P7ggUL4uSTT07atueee8ZFF11U6v69evWKiy++OGnbSSedlHS+SoVsO99y4bhX5+fHVMiFY3jyySdHo0aNEuLFxcXx4YcfVqq+r776Ko4++ujYtGlTpfJUVzX1Hi8X1seyfW7L9voyMfdV1TPp9+XCHF+amrz+nSm5PmaqoyuuuCKefvrpSuU48cQTY8OGDUnbSlqHLI90rQ/X1PuQqnDCCSfEVlttlbTt3HPPjTfffLNS+b/66qv42c9+VuX32Nl2vhjDlKZBgwZJ40VFRZW+3qbKqlWrksYbNmyYsj723XffuPHGG0v8c8stt8S9994bI0aMiE8++SS++OKLuPrqq6NNmzZJ87322mtx5JFHRnFxccpqBAAgtfIzXQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUD2dfPLJ8dFHH6Us3/z58+OCCy6Idu3axRFHHBGLFi1KSd6///3vSeP77LNPufKcd955SeMjR46MBx98sNx1JXP33XfHXXfdFfvvv3/06dMnRowYEcXFxSnJXZI6derE8OHD45e//GXS9vnz58e+++4bL7/8coXyb7PNNknjc+fOrVC+H/rggw+idevWcfzxx8fMmTNTkjPVXnnllZSNkU8//TQuuuiipG1Dhw6NNm3alDnX2WefnTR+++23xyeffFKh+n7ouuuui6KiooT48ccfn5L8Eamfi1Jp5cqVMW7cuIR4Xl5eDB48uFy5fvSjH0Xbtm03i02cODHp2Bo4cGD5Co3/jZ8fWrFiRYwfP36L++bCWMqFGiuqrPN4dXTBBRckjb/wwgvx5z//OSV9fPnll3HqqacmbTviiCOic+fOKemH8snWaytVLxfn99GjR8ff/va3pG1XXnll9OjRI2lb3bp146GHHopatWoltN11113x3HPPVaieLcnG8y0Xjnt1fX5MlVw4hmeccUbS+AMPPFCZsr4zbdq0Etcrarqafo+Xzetj2T63ZXt9mZr70v1M+kO5MMeXVU1b/86U6jRmqoMZM2bEddddV+k8n3zySYwYMSJpW79+/Sqd//tSea7W9PuQdDrrrLOSxp9//vmU3WO//vrr8Ze//CUlucoiG88XY5jSNGzYMGl83bp1VVxJydauXZs03qhRo5T1sccee8QFF1xQ4p9f//rXcfLJJ8eQIUNihx12KDXXfffdFwceeGCsXLkyZfUBAJB6+ZkuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACofp555pl45pln0pJ70aJF8corr6Qs34svvpg0vuuuu0atWrXKlKNVq1ax9957J227/vrrK1zbDxUXF8eZZ54ZEydOTFnO0jRs2DCef/75OOaYY5K2f/TRR7HXXnvFjBkzKtxHYWFh0nhxcXGFc/7QihUrUpYrHa666qqU5nvooYdi4cKFCfGCgoI47LDDypRj++23j1133TUhvnr16rj11lsrXeO3Pv7443jhhRcS4u3atYuuXbtWOn8656JUGT58eNL40KFDy5Vn0KBBCbGRI0fG6NGjE86nrbfeOnbbbbcy527WrFnss88+CfFRo0bFunXrSt03F8ZSLtRYUVUxj2erRo0axYABA5K2XXfddSnta+TIkfHuu+8mxPPy8kr82ZNe2Xhtperl8vx+/vnnx/vvv58Qr127djz88MNRu3bthLbrrrsudtxxx4T4+++/H+eff36F6iiLbDvfcuG4V9fnx1TJhWPYpUuX6NSpU9K2m2++OSX1RURcffXVsXHjxpTlqw7c4/0/2bY+lu1zW7bXl8m5L53PpD+UC3N8WdW09e9MqU5jprq4/PLLY9OmTSnJdf/99yeN77bbblG/fv2U9JHKc9V9SPp06dKlxHPtmmuuSWlfN998c8rG8JZk2/liDLMlderUSRqvqnOmLEp6Ri7p982ZMn/+/DjooIPiF7/4RaxduzbT5QAAsAX5mS4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqkLnzp3j/PPPL/VPQUFBpssEAAAAAAAAAAAAAAAAAAAAAAAAAAAAqDZuu+22TJdQZu+//36sXLkyIV5QUBDNmjUrU47DDjss8vLyEuL/+c9/YsqUKZWuMRNatmwZEydOjAMPPDBp+1tvvRV77bVXfPLJJ5XqZ+nSpUnj7du3r1TeXPHZZ5/FhAkTUppz3bp1ce+99yZtO+yww8qU4+CDD04af+GFF2Lx4sUVri2Zl19+OWl8//33r3TuXJiLRo4cGevWrUuI9+/fP+rXr1/mPEcccURCbNSoUTF//vx48803E9oGDRpU5tyDBg2KWrVqJcSfeOKJLe6bC2MpF2qsiKqax7PVIYccErVr106Iz5o1K1588cWU91fSfDN48OCU90XpsvXaStXL5fl9zZo1MWzYsFi/fn1CW/fu3eOqq67aLLbvvvvGeeedl7Dt+vXrY9iwYbF27doK1bEl2Xi+5cJxr47Pj6mUC8fwkEMOSRqfNGlSvPvuu5Ws6v/56quvYvTo0SnLVx24x0ufyq6PZfvclu31ZXruS8czaTKZfp0RqXutubDm9K1UrH9nSnUaM9XBZ599FqNGjUpZvsmTJ0dxcXFCvKCgINq1a5eSPlJ5rroPSZ+SnvVmzJgRkydPTmlf8+bNi+eeey6lOZPJxvPFGIaq06ZNm/j9738fvXr1ynQpAACUQX6mCwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIHfUrl07unfvHsOGDYsLLrggrrrqqrjtttvitttui6uuuip+85vfxLBhw6Jbt25Rq1atTJcLsJnu3bvHzTffXOqfOnXqZLpMAAAAAAAAAAAAAAAAAAAAAAAAAAAAgGrh/fffj0mTJmW6jDIrLi6Or776Kmlb8+bNy5Rjn332SRofN25chevKpHbt2sXkyZNjt912S9o+YcKE2G+//WLhwoWV7qukn/2wYcMqnTsXjB8/Pi15X3zxxaTxXr16lWn/fv36JY2nY0y//vrrSeM777xzpfLmyly0YsWKpOOgbt26ceihh5YpR+vWrWOPPfbYLDZr1qz45JNPIiLi2WefTdhn8ODBZa5x6NChCbFVq1bF2LFjt7hvLoylXKixvKpyHs9WBxxwQNJ4WcZtRZSUt0+fPlFYWJiWPkkuW6+tVL1cn9+nT58el112WdK2Cy+8MPbaa6+IiGjQoEE88MADkZeXl7DdpZdeGtOnT69wDVuSjedbLhz36vb8mGq5cAz79OmTNP7SSy9VuqYfGjNmTMpz5jL3eOlT2fWxbJ/bsr2+TM99qX4mLUmmX2dEal5rrqw5fSsV69+ZUl3GTHUxevTolOZbvnx5zJ07N2lbs2bNKp0/1eeq+5D06du3b9J4qsdcuvOms49UnC/GMFSt/fbbL1577bW4+uqrk67bAQCQPQoyXQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANmtefPm8eMf/ziOPPLI2H///aNOnTpl2m/NmjUxfvz4GD58eDzzzDOxZs2aNFdKTbHDDjvEQw89VKZtn3nmmbjlllvSUsfRRx8dv/rVr8q07YEHHhgbNmxISx0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAkI1efvnlTJdQbsuWLUsab968eZn279q1a9L4lClTKlxTpnTv3j3GjRsXW2+9ddL2f/3rX3HCCSek7HPYX3311aTx448/PsaMGRNPPPFESvrJVq+88kpa8k6bNi2Ki4sjLy9vs/gOO+wQderUifXr15e6/0477ZQ0/tprr6Wsxm999dVXSeNdunSpVN5cmouGDx8egwcPTogPHTo0nnnmmS3uP3DgwIRjPWrUqM3+/+qrr96sfffdd482bdrE/PnzS81dWFgYhx56aEJ89OjRsXbt2i3WlgtjKRdqLI+qnsezVbdu3ZLGS7ruVNa8efPi888/j+22226zeH5+fuy4444xc+bMtPRLomy9tlL1qsP8ftNNN8WAAQPigAMO2Cyen58f//znP6NHjx5xyy23RPv27RP2femll+Lmm2+uVP9bko3nWy4c9+r0/JgOuXAMd9xxx6TxdNSYrvMsV7nHS6/KrI9l+9yW7fVleu5L5TNpaTL9OiNS81pzac3pW5Vd/86U6jJmqotJkyalPOfnn38enTp1SoinYmym+lx1H5I+JZ3rkydPTkt/U6dOTUve78vG88UYZkuKi4uTxn+4PpNJJdVSUu0V8e6778YDDzxQYnt+fn40btw4mjVrFjvttFO0bt26xG1r1aoVl156aXTu3Dl++tOfxsaNG1NWJwAAqVOQ6QIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMhOrVu3jt/+9rdx2mmnRYMGDcq9f7169WLIkCExZMiQmD9/flxzzTXx97//PTZs2JCGaqlJ6tevH/369SvTtl26dInbb789Nm7cmPI6LrzwwujTp0+Zts3Ly0t5/wAAAAAAAAAAAAAAAAAAAAAAAAAAAACQzaZOnZrpEsqkTZs20bFjx+jQoUM0b9486TZ16tQpU64dd9wxafw///lPhevLhH79+sWoUaOiadOmSdtXrlwZZ511Vkq/f+DVV1+NRYsWRYsWLTaL5+fnx+OPPx6DBg2KW265JWbMmJGyPrPJhx9+mJa8y5Yti88++yx22GGHzeL5+fnRoUOHeP/990vdv0uXLknjn332WapK/M6SJUuSxps1a1apvLkyF0VEPPvss7Fu3booLCzcLD5o0KDIz8+PoqKiUvc/4ogjkub81syZM+O///1vbL/99t/F8vLyYuDAgXHvvfeWmrt///5Jv7/kiSeeKHW/b+XCWMqFGssqE/N4turatWvS+Ntvv522Pt96663YbrvtktYyc+bMtPXL5rL12krVqw7ze3Fxcfz85z+Pd955JyFXx44dY+zYsbHPPvskrefnP/95FBcXV6r/LcnG8y0Xjnt1eX5Ml1w4hp07d04aT8f1fu7cuVFUVBT5+fkpz52L3OOlXqrWx7J9bsv2+jI996XqmXRLMv06I1LzWnNlzSmV69+ZUl3GTHUxe/bslOdctmxZ0nhJa1vlkepz1X1I+nTq1ClpPF3X6VmzZsX69evTOgdm4/liDLMlq1atShrPpvuFH/4e7VurV69OWR/jxo2LcePGlXn7HXbYIYYMGRJnnXVWiesFP/7xj2PNmjVx4oknpqhKAABSqSDTBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkH2GDRsWd9xxRzRr1iwl+dq0aRN/+ctf4tRTT41jjz025syZk5K8sCWtWrWKIUOGxFNPPZXSvLvsskv06dMnpTkBAAAAAAAAAAAAAAAAAAAAAAAAAAAAoDqZMWNGpkuIiIjCwsLYYYcdomPHjtGhQ4fo1KlTdOjQ4bs/9erVS1lfzZs3TxpfuHBhyvpIt8GDB8fw4cOjbt26JW7TsGHD+Pvf/x4//vGPU9bvhg0b4rrrroubbropoS0vLy+OP/74OP7442PevHnxxhtvxLvvvhsfffTRd38WLFiQsloy4bPPPktb7sWLF8cOO+yQEC/Ld1Ik22bNmjWxePHiVJS2mZUrVyaNN2rUqFJ5s2UuKosVK1bE+PHjY/DgwZvFmzdvHv369YtJkyaVuG+dOnWif//+m8W+/vrrmDZt2maxkSNHxtlnn71ZbPDgwXHvvfeWWtvQoUMTYqtXr44xY8aUut+3cmEs5UKNZZGpeTxbtWzZMmk8ndfmb775Jml8q622SlufJMrWaytVr7rM71988UWcdtpp8cQTTyS07bPPPkn3Oe200+KLL76odN9bko3nWy4c9+rw/JhOuXAMmzRpkjS+aNGiStf0Qxs2bIgvv/wy2rZtm/Lcucg9XvlV1fpYts9t2V5fpue+VNyzlEWmX2dEal5rtqw5VeX6d6ZUlzFTXaTjGWP58uVJ4/n5+ZXOnepz1X1IeuTn50fDhg2TtpX0+iurqKgoFi9eHG3atElL/ojsPF+MYbakpGth7dq1Iz8/P4qKiqq4okQl/f5jzZo1VVzJ//Ppp5/Gn//85/jzn/8cZ555Ztx4441Rv379hO1OOOGEmDJlStx9990ZqBIAgNIUZLoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACyR35+ftx9993xi1/8Ii35e/ToEW+99VYcffTRMX78+LT0AT906qmnxlNPPZXynAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAyRYtWlSl/W2zzTax++67R48ePaJTp07RoUOH6NixY2yzzTaRl5eX9v7r168f+fn5CfF169bFunXr0t5/Kpx00klxzz33RK1atba47bHHHhsnn3xy3HfffSnr/y9/+UsceeSRsffee5e4Tdu2baNt27Zx5JFHbhZftWpVzJ07Nz766KP46KOP4sMPP4wZM2bEzJkzc+Lnv3z58rTlXrp0adJ4w4YNS92vfv36Sc+devXqxZo1a1JR2mZKOk8LCwsrlbeq56LKGj58eAwePDghPnTo0Jg0aVKJ+x144IHRoEGDzWKjR4+O4uLizWIjR46Ms88+e7PYwQcfHIWFhSWeK3l5eUlrGjNmTJnGQi6MpVyosSwyPY9nm3r16iX9Waxbty7Wrl2btn6XLFmSNN6oUaO09UmibLy2UvWqy/z+rSeffDIeeOCBOPHEE7e47f333x9PPvlkSvrdkmw733LhuFeH58d0ypVjmGy/devWxfr161NW2/etWLEiLXlzjXu80mVyfSzb57ZcqC/Tc1+q7llKkw2vMyI1r7WmrX9nSnUaM9VFOu5JioqKUp7zW6k8V92HpE9Jr2XlypWxcePGtPW7dOnSaNOmTdryZ9v5YgxTFqtWrSqxrUWLFrFw4cIqrKbkOpJZuXJlFVeS3J133hmTJk2Kl19+OWmt119/fTz99NPxzTffZKA6AABKUpDpAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyA4FBQXx+OOPx1FHHZXWfho2bBgjRoyIww47LCZNmpTWviAi4uCDD4527drFZ599lpJ8hYWF8fOf/zwluQAAAAAAAAAAAAAAAAAAAAAAAAAAAACgulq2bFna+9h5553j+OOPj+OOOy7atWuX9v5K06BBg6Tx5cuXV3ElFXffffeVa/u//OUvMXny5Pjggw9S0v/69etjyJAhMWHChNh1113LtW+DBg2iR48e0aNHj83iGzdujIkTJ8YjjzwSjz32WKxZsyYltaba6tWr05a7pHOxYcOGpe5X0piOiKhbt26laqpKVTEXpdLIkSNj/fr1UadOnc3iQ4YMifPPP7/E/QYPHpwQe/bZZxNiL7/8cqxYsSIaNWr0Xax+/fqx//77x7hx45Lm3nPPPaN169YJ8eHDh5dYz/flwljKhRrLItPzeLbJ1LV5yZIlSeONGzdOa79sLhuvrVS96jK/f98555wT++67b3To0KHEbebOnRvnnHNOldWUbedbLhz36vD8mE6OYXKrVq1KW+5c4h4vUbasj2X73Jar9UVkz9yXCtXpdda09e9MqU5jprrYsGFDpksol1Seq+5D0qewsDBpPN33wOk+dtl2vhjDlMXXX39dYtvWW28dCxcurMJqSq4jmS+++KKKKynZrFmz4tBDD40pU6Yk/M6vadOmcdFFF8VFF12UoeoAAEgmP9MFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQHW677bY46qijqqSvevXqxYgRI2Lrrbeukv6o2fLz8+MXv/hFyvIdffTR0axZs5TlAwAAAAAAAAAAAAAAAAAAAAAAAAAAAIDqaPny5WnL3a5du3j00UfjnXfeiYsuuijatWuXtr7KKi8vL2l806ZNVVxJav373/+OI444IoqKihLa6tevH48//njUqVMnZf0tWrQo+vbtG3feeWdKfnYFBQVx0EEHxX333RcfffRRnHTSSSmoMvWKi4vTlrukn2NJY7as7bkinXNROixfvjzGjx+fEO/QoUPsvPPOJe43aNCgzf6+du3amDBhQsJ2GzZsiLFjxybEBw8eXGLuoUOHJsTWrFkTY8aMKXGf78uFsZQLNVZUVc/j2SQ/Pz9pPN3X5orOu6RWNl5bqXrV8ZisXLkyzj777FK3Ofvss2PVqlVVVFH2nW+5cNyr6/NjqjiGyW3cuDFtuXOJe7z/J9vWx7J9bsvV+qqb6vQ6a9r6d6ZUpzFDZqTyXHUfUvXS+bwZEUnXTKszY5iyWLFiRSxYsCBpW8eOHau4mkRNmzaNpk2bJm37/PPPq7aYLXjrrbfitttuS9p24oknRkFBQdUWBABAqZI/MQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUKP87Gc/i7POOqvc+23cuDHmz58f8+bNi2XLlpVr32bNmsU//vGPcvcJFXHyySdHfn5+SnKddtppKclD1Zs/f36MHj261D+bNm3KdJkAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1UJxcXFa8vbv3z+mT58ew4YNi7y8vArlWLx4cUydOjUefvjhuPzyy+P//u//Yvfdd4/XX389xdXmtscffzwGDBgQo0aNihtvvDHpNj179owbbrghpf2uW7cuzjrrrOjWrVs88MADsXz58pTk3WabbeK+++6LRx99NAoLC1OSk+yXrrkonYYPH540PnTo0KTxHj16xPbbb79Z7N///nesWbMm6fYjR45MiA0ePLjEeoYMGZIQe/7552PVqlUl7kN2yNQ8DkB6nXHGGaW2n3nmmVVUCQCZYn0MMs/6N+SGXFwfrolKOk6p+i7iktSuXTut+SFXffjhh0nju+yyS0r7adCgQVx++eXlOtdLqqG4uDg++eSTVJWWMtddd11s3LgxId6yZcvo3bt3BioCAKAkBZkuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAzGrWrFncdtttZdq2uLg4RowYEU899VS88MILsWDBgs3aW7RoEX379o2f//znccwxx0R+fn6p+Q4//PA45JBDYvz48RUtH8pk2223jQEDBsRzzz1XqTydO3eO/fbbL0VVUdWmTJkSgwcPznQZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFTQgAEDYtSoUVGrVq0tbrty5cqYM2dOzJkzJz788MPN/rtkyZKk+6xdu7bCtRUVFSWNFxQUVDhnJv31r3+Nc889N4qLiyMi4rLLLouDDjoo9thjj4RtzzvvvBg/fnyMGTMmpTXMmTMnTjrppDj99NNj//33j169esXuu+8eO+20U3To0CEKCwsrlHfYsGHRqFGjrPrs8tq1a8eGDRvSkrtOnTpJ45s2bSp1v2+P/Q8tXbo0HnvssUrXVVaLFi2qsr6yxbPPPhvr169POHZDhw6Na665JmH7QYMGJc1RkjFjxsSmTZs2m0u333772HnnnePdd9/dbNsdd9wxdtxxx4QcTzzxxBZfx7dyYSzlQo3llQ3zeKaVNM+l+9pcu3btpPEtzbtVKS8vL9MlpF02XlurUk04xmVRHef3M844Y4v3sYMHD45f/vKX8be//S1l/ZYm2863XDju1e35MdVy4RiWNAZLug9IhXTmziXu8bJ3fSzb57Zsry8b5r6qWIPJhtcZkb3rTdl6fmeSMUM2cR9SssquQ6xevTppvHHjxpXKuyVNmzZNa/5sYwyXzFra5t5///3o169fQrxv374p66NZs2YxduzY6N27d7Rr1y5OOeWUMu3Xu3fvpPG5c+fG8uXLU1ZfqixdujQmTZoUBx54YEJb3759Y8qUKRmoCgCAZLJjpRgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIy58soro0WLFlvc7u23347TTz893nzzzRK3WbRoUYwePTpGjx4du+++ezz55JOxww47lJr3d7/7XYwfP768ZUO5nXbaafHcc89VKsepp56aomoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgPLYYYcd4tFHH41atWolbV+0aFE89dRTMWHChHjjjTfis88+K3cfeXl5Fa5v7dq1SeNNmjSpcM5MueSSS+K6667bLLZx48YYNmxYTJ8+PRo0aJCwzwMPPBA9evSI+fPnp7ye9evXx/jx4zf7boO8vLxo27ZtdOrUKTp16hSdO3f+7v87deoU9erVKzXnoEGD4pJLLolrr7025fVWRJMmTeKbb75JS+6mTZsmja9cubLU/Uoa0ytXrowzzjijsmVRiuXLl8eECRNi4MCBm8V333332GabbeLLL7/cLH7EEUds9vfi4uIYPXp0ifkXL14ckydPjn333Xez+ODBg+Pdd9/dLDZkyJCE/deuXVtq/mTbJ5NNYykXaiyPbJvHM6Wkea6keTFVmjdvnjS+fPnytPZbHlu6TlYH2XhtrUo14RiXRXWb37t16xa33HJLmba95ZZbYuLEiTF79uw0V5V951suHPfq9PyYDrlwDFetWpU0ns5jmOweriaq6fd42bw+lu1zW67Wl01zXyrUlNdZEdl8fmeSMUM2qen3IaWp7DrEqlWrori4OGGeqlu3btStW7fEuaCy0n3sso0xXDJraZubOHFinHLKKQnxffbZJwoKCmLjxo2Vyt+6deuYMGFCdO/ePSIifvGLX8TChQvjd7/73Rb3Peigg5LG33777UrVlE5vv/12HHjggQnxdu3aZaAaAABKkp/pAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyJxmzZrFKaecssXtJk6cGPvuu2+8+eabZc791ltvxf777x8LFy5M2l5cXBwTJ06Mf/3rX2XOCZUxcODA2HrrrSu8f0FBQZxwwgkprAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKKtrr702mjZtmhBfuXJlnHPOObHNNtvE6aefHk8++WR89tlnFeqjYcOGFa5v9erVUVxcnBCvXbt21KtXr8J5q9KmTZviF7/4RVx33XVJ2z/66KM455xzkra1bNkyHnrooXSWt5ni4uL4/PPP46WXXop77rknLrroojjqqKOiR48e0aBBg9hxxx3jvPPOi9mzZ5eY43e/+100b968ymouTbKxne7cK1euLHW/ksZ0tvzMqrvhw4cnxPLy8uKII47YLNayZcvo3bv3ZrG33norvvrqq1Lzjxw5MiE2ePDghNjQoUMTYuPGjdvi+Pm+XBhLuVBjWeTSPF4V1q1bFxs3bkyIFxQURIMGDdLWb7NmzZLGV6xYUeGctWrVqvC+yTRq1Cil+bJRNl5bS+MYp0d1md8jIurUqROPPfZY1K1bN6Ft/vz5CbF69erFY489FnXq1El7bdl2vuXCca8Oz4/plAvHcO3atVFUVJQQLygoiPr166elzyZNmqQlb66pTvd4FZHN62PZPrflan3ZNPelQk15nRWRzed3JhkzZJPqdB+SjesQ33zzTdJ4mzZtKp07mQYNGpT4s62ujOGSWUvb3L///e+k8YYNG0b//v0rlbtt27bxyiuvRPfu3TeLX3zxxXH++eeXum/Dhg3jgAMOSNpWUs3ZINnaXUREixYtqrgSAABKU5DpAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyJyTTjop6tatW+o2n376aQwcODBWrVpV7vyfffZZ/PrXv46HH374u9h//vOfeOSRR+Kxxx6LL774Yos58vLyol69eknbiouLY82aNQnxtm3bRs+ePWOrrbaKwsLC7+IjR46M+fPnl7n+evXqRf/+/aNv376xyy67RJs2baJRo0aRl5cXK1eujG+++Sbee++9eOONN2Ls2LGxZMmSMucui3bt2sUBBxwQvXr1is6dO0eTJk2icePGUVBQEKtWrYoVK1bEJ598ErNmzYoXX3wx3nzzzWrRd7rUqlUrTjrppLj22msrtP+QIUOiVatWKa5qy1q2bBkDBgyI3XffPbp27RrNmzePhg0bRn5+fqxYsSKWLVsWixYtirfffjtef/31eO2112Lt2rXl7icT51qnTp1iyJAh0bt372jXrl00adLku/Prv//9b0yfPj3Gjh0b06ZNK/frSaa01/it1atXV2j/ZD+jBg0axMCBA+Oggw6Krl27RosWLaJ27dqxZMmS+Oabb2LWrFkxbty4eOWVV2LDhg3lf0EAAAAAAAAAAAAAAAAAAAAAAAAAAAAANcQOO+wQxx13XEJ83bp10b9//5g6dWpK+tlqq60qvG9RUVEsWLAg2rRpk9DWunXr+PTTTytRWdU46qijYuTIkaVuc//998fhhx8exxxzTEJb//7948ILL4wbb7wxXSWWSXFxccyZMyfmzJkTf/nLX+KKK66IK664ImG7hg0bximnnBI33HBDBqrcXOvWreOjjz5KW+5kvvnmm1L327RpUyxcuDDhc/rr168fdevWrdDn4lN2zz77bKxfvz7q1KmzWXzo0KHxt7/97bu/Dxw4MPLy8hL23ZKRI0fGTTfdtFlszz33jBYtWsSiRYsi4n9jZ88990zYd/jw4WV+HRG5MZZyocaySMU8Xt188cUX0a5du4R4mzZtYu7cuWnpM9m9QESU6bs8Nm3alDTeqFGjStX0Q9ttt11K82WjbLy2RjjGVa26zO8RETfeeGN07949If7mm2/GwIEDY/r06bH11ltv1tajR4+44YYb4le/+lVaa8u28y0Xjnt1eH5Mp1w4hhERCxYsSDjvIv53DD/55JOU9lW3bt0S7zFqoly7x0uVbF8fy/a5Ldvry5W5r7Jqyussr2w/vzPJmCHb5Np9SC6tQ3zwwQfRsmXLhHjv3r3Tcp3eY489Ij8/P+V5s50xnJy1tM199dVXMXv27OjatWtC2/HHHx9jx46tcO6VK1eWeP2+6aab4ptvvol//vOfSduPPvroEr9besyYMRWuKd1WrFiRNP7D3wECAJBZBZkuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAzPn5z3++xW1OP/30WLVqVYX7+Ne//hWnnHJKTJo0KR599NH44IMPyrV/r169YurUqUnb5s2bF9ttt913fz/iiCPiiiuuiN122y3p9u+//37Mnz9/i33usssuccEFF8Rxxx0XdevWLXXbQw89NCIiNm3aFM8//3zcdNNNMXHixC32UZohQ4bEr3/969h3330jLy+v1G379ev33f9/8cUXcfvtt8ddd90VK1asyLm+q8Ipp5wS1157bYX2Pe2001JcTen22WefuPTSS+Pggw+O/Pz8LW5/zDHHRETE0qVL47777ovbbrstPv/88zL3V5XnWq9eveL666+PAw44oMRtdt999zjyyCPjj3/8Y8yaNSsuvfTSGDlyZEREDBs2LP75z38m3e/FF1/87rxM1m9JrzHifz+7Zs2alVp3WX5GtWrViosvvjguvPDCaNKkSYn5Dj/88Ljooovi888/jz/+8Y9x//33R1FRUYnbAwAAAAAAAAAAAAAAAAAAAAAAAAAAANRUhx9+eNLP7L7zzjtL/fzp8sjPz49WrVpVKsdnn30Wbdq0SYjvvvvu8emnn1Yqd1X49vPAt+TUU0+NPn36bPYZ5t+65ppr4qWXXoo333wz1eVVSHFxcfzhD3+Ili1bxplnnpnQfuihh8YNN9yQgco2t8cee8TkyZNTnnfbbbeN1q1bJ8Q3bNgQn3zyyRb3/+9//5v0vNhll12y5hhXV8uWLYsXXnghDj/88M3iBxxwQDRq1Oi774Y44ogjEvYty7n84YcfxgcffBA77rjjd7H8/PwYMGBAPPzwwxERMXjw4ITvrli3bl2MGjWq3K8nF8ZSLtS4JamYx/fYY4+ceb1l8d5770W7du0S4n369Im5c+empc/evXsnjb/77rtb3HfJkiVJ440bN65UTT/0/XO/usrWa6tjXPWqw/w+YMCAOPfccxPia9asiZ/97Gfx9ddfxy9+8YsYM2ZMwjbnnXdejB07NsaOHZu2+rLxfMuF457rz4/plgvHcM6cObH11lsnxPfYY48yXRPKo0uXLlv8XrmaJNfu8VIlF9bHsn1uy/b6cmHuS4Wa8jrLIxfO70wyZsgmuXYfkkvrELNnz97su5K/1a9fvxg+fHil8/9Qnz59Up4zFxjDyVlLS/Twww/HNddckxA/5phj4qKLLop58+ZVKO/SpUvjkEMOiSlTpkT79u03a8vLy4t77703Fi9eHKNHj07Y91e/+lXSnG+99VaF66kKhYWFSeObNm2q4koAAChN4uocAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1wlZbbRU9e/YsdZtp06bF+PHjK9VPUVFRHHDAAXHFFVfEBx98UKlcpbntttvi2Wefjd12263CORo1ahR33HFHzJgxI0444YSoW7dumfetVatWDBo0KF5++eUYMWJEbLvttuXuv3Xr1jFmzJgYMWJE7LfffpGXl1eu/bfddtu4/vrrY/bs2XHYYYflTN9VqX379tG/f/9y79euXbsK7VcRzZs3j8ceeywmTZoUhx56aOTn55dr/6ZNm8b5558f7777bvzkJz9JeX2VPdeuueaamDp1ahxwwAFl3meXXXaJZ599Nh544IGoXbt25OXlRUFBQdI/5f15pVrXrl3jjTfeiKuvvjqaNGlSpn222267+Mc//hHPP/98NGrUKM0VAgAAAAAAAAAAAAAAAAAAAAAAAAAAAOSefffdN2n8scceS1kfu+++e9SrV69SOaZPn5403rdv30rlzTZLly6Nn/3sZ1FUVJTQVrt27XjssceiYcOGGaisZL///e9j48aNCfFevXploJpE6Roje+65Z9L43Llzkx6/H3rnnXeSxvv06VOpuiib4cOHJ8Tq1Knz3fdC1KlTJw4++ODN2j///POYOXNmmfKPGjUqITZ48ODv/n/o0KEJ7ePHj48VK1aUKf/35cJYyoUaU6W0eTwb5/DKmDVrVtJ4v3790tLfjjvuGC1atEiIr1u3LubOnbvF/ZcsWZI03r59+0rX9n377bdfSvNlo2y9tjrGVS/X5/dWrVrFAw88kLTtt7/97XffC/b888/H3XffnXS7Bx98MFq1apWuErPyfMuF415Tnh8rKheOYUnfy5eOY2he31yu3eOlSi6sj2X73Jbt9eXC3JcKNeV1lkcunN+ZZMyQTXLtPiSX1iFeeumlpPGjjjoqatWqVen8P5SO7/zNBcZwcp65Et1///2xadOmhHjt2rXjsssuq1Tu+fPnx8EHHxwLFixIaCsoKIjhw4cnjMlBgwbFj370o6T5/va3v1WqnnTbZpttksZXrlxZxZUAAFCa/EwXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAZhx44IGRl5dX6jb33XdfFVVTOVdeeWWcd955lcrRoUOHmDp1apx55pmRn59fqVxDhgyJ//znP7H33nuXeZ927drF5MmTY8CAAZXqOyJi2223jTFjxsQZZ5yR9X2nw7p162Ljxo0ltp922mnlznnKKaeUOC5WrlxZ7nwlad++fbz55ptx3HHHVTpXo0aN4pFHHokLL7wwBZX9T2XPtfz8/Ljkkku2OPeU5IQTTognn3wyatWqVeEa0qlDhw7x8ssvx6677lqh/Q855JB45ZVXol69eimuDAAAAAAAAAAAAAAAAAAAAAAAAAAAACC3bb311knjs2fPTlkfBx54YKVzTJ06NWn88MMPr3TubDNp0qS4/vrrk7Z17Ngx7rzzziquqHSLFi2K6dOnJ8QbNWoUderUqfqCfuDAAw9MSx0ljb1XX321TPtPmzYtaXz//fevaEmUw4gRI2L9+vUJ8aFDh0bE/45Dw4YNN2sbOXJkmfM/++yzCbHDDjssCgoKokGDBtG/f/+E9ieeeKLM+b8vF8ZSLtSYSiXN49k4h1fGhAkTksYHDRqUlu+/+Pb8/KGJEyfGpk2btrj/4sWLk8Z32223ypS1mYKCgjjkkENSlq8sMvFdI9l6bXWMq16uz+8PPvhgtGrVKiH+wgsvxF/+8pfNYueff358/PHHCdu2atUqHnzwwbTVmI3nWy4c9+r0/JiOOSAXjuErr7ySNJ6K74P7ocGDB6c8Z1VJx/jItXu8VMmF9bFsn9uyvb5cmPtSoaa8zvLIhfO7rGrqfUEmZfPzWHWUa/chubQOMWHChCguLk6Ib7vttnHUUUdVOv/37bnnntGzZ8+U5swVxnCiql5Ly5V5+6uvvopRo0YlbTv11FMrfQzmzp0bhx56aCxbtiyhrV69ejF69Ojo3r17RETUqVMnbrvttqR5li1bFo8++milakm3nXbaKWn8yy+/rOJKAAAoTX6mCwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDN+9KMfbXGbUaNGpb+QSurXr19cdtlllcrRrl27ePXVV6Nr164pqiqiZcuW8cILL0S/fv22uG2tWrXi2WefjY4dO6as/7y8vLjzzjvjmGOOydq+02XFihUxevToEtuHDBkSW221VZnz5efnx0knnVRi+7/+9a9y1VeSFi1axMSJE6N9+/YpyfetP/3pTzFo0KBK50nFufbnP/+50nUcccQRcdFFF1U6T6o1aNAgJkyYEK1atapUnp49e8Ydd9yRoqoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqodmzZolja9duzYl+fPz8+PUU0+tdJ6xY8cmjXft2jUOOuigSufPNpdffnm88cYbSdt+/vOfx09/+tMK5W3Tpk1lyirRl19+mTTetGnTtPRXHi1btoz/+7//S2nOrbbaKn7yk58kbStprP7Q+PHjk8aPOOKIaNmyZYVro2yWLVsWL7zwQkJ84MCBUVBQEIMHD05oe/bZZ8ucf8qUKbFo0aLNYo0bN45+/frFoYceGoWFhZu1rV+/PkaOHFnm/N+XC2MpF2pMtZLm8crM4dlm4sSJsWrVqoT4dtttl/LvVqldu3ace+65SdvKeu689957SeNt2rSJTp06Vbi27zv66KPTNqaT/awjIho1apSW/kqTrddWx7jq5fL8ft5558Vhhx2WEF+6dGmceOKJCfFVq1bF8ccfH0VFRQlthx12WIlzVGVl4/mWC8c9F58fq3IOyIVjOGHChKTxnXbaKfr375+yfjp06JDSfOlSleMj1+7xUiUX1seyfW7L9vpyYe5LhZryOssjF87vH3JfUPVy8XmsOsq1+5BcWof45ptvkq6HR0RcccUVUadOnUr38a2rrroqZblyjTGcKF1radVh3v7DH/6QdJ0pPz8/Hn300ahfv36l8s+YMSMGDRoUa9asSWhr0qRJjB8/Ptq3bx+33HJLid+//qc//SlWr15dqTrSqX79+nHooYcmbZs9e3YVVwMAQGnyM10AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACZ0aVLl1Lbv/766/jyyy+rqJqKyc/Pjz//+c+Rl5dX4Rz16tWL559/PrbeeusUVvY/devWjVGjRkW7du1K3e7cc8+Nnj17prz/iIh777231NeWyb7T6e9//3uJbXXq1Injjz++zLkGDBgQ2267bYnt99xzT7lqK8mDDz4Y2223XUpyfV9+fn7cfvvtUatWrUrlqOy5Nnjw4Dj77LMrvP/37bLLLinJk0rNmjWLDh06pCTXSSedFP369UtJLgAAAAAAAAAAAAAAAAAAAAAAAAAAAIDqYMWKFUnjLVu2TEn+YcOGRceOHSud56uvvorJkycnbfvd735X6fzfd9ppp6Xts+bLatOmTTFs2LBYuXJl0va77rqrXJ/h3bZt27jrrrvis88+iyFDhqSqzO/UqVMnaXzNmjUp76siLrjggkp9rvwPnX/++VG3bt2E+KpVq2L8+PFlyvHxxx/HO++8kxCvU6dOnHrqqZWu8fuaNGkSbdq0SWnO6mD48OEJsSZNmsR+++0XgwcP3iy+YsWKePnll8ucu6ioKMaMGZMQHzx4cAwdOjQh/sILL8SyZcvKnP/7cmEs5UKNqVbaPF7eOTxbrV+/Ph5//PGkbZdeemnUrl07ZX2ddtppsc022yTE161bF0888USZcsyZMycWLVqUtO3EE0+sTHkREVFQUBB/+MMfKp2nJEuWLEka39L396RLNl5bHeOql6vze48ePeL6669P2nbmmWfGF198kbRt8uTJcdNNNyVtu+GGG6JHjx4pqe+Hsu18y4XjnovPj1U5B+TCMVywYEFMmTIladsll1xS2bK+c9VVV1Xq+8OqSlWOj1y7x0uVXFgfy/a5Ldvry4W5LxVqyussj1w4v3/IfUHVy8Xnseoo1+5Dcm0d4i9/+UvS+M477xzXXHNNSvo47bTTon///inJlYuM4c2lcy2tOszbM2bMiIceeihp24477hiPPvpo5OfnV6qPV199NX784x/Hxo0bE9ratGkTr7/+epx11llJ9/3yyy/jz3/+c4X6rVWrVvz0pz+N119/Pa3X/jPOOCPq1auXtG3SpElp6xcAgPKr3J0tAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5q1OnTqW2z5gxo4oqqbhtttkmdtttt0rluO6666Jr164pqihR06ZN4/777y91m1NOOWWLeYqKimLu3LnxxhtvxBtvvBEff/xxrF27dov7NW7cOC6//PKs7Dudxo0bF//9739LbD/ttNPKnKu0bV966aX44IMPylVbMgcccEAMHDhwi9stXbo0Xn/99RgxYkQ8+eST8corr8SaNWu2uF/79u3jJz/5SYXrq+y5Vrt27bjtttsqvH9N9Jvf/CbTJQAAAAAAAAAAAAAAAAAAAAAAAAAAAABkjW+++SZpvG/fvpXOve2228att95a6Tzf+tvf/pY0ftBBB8V5552Xkj722GOPuOuuu2L69OkxatSo6N27d0ryVsTcuXPj7LPPTtrWqFGjeOyxx6KgoKDUHG3bto0777wz5s6dG7/85S+jTp06cfvtt0fz5s1TWmuy72lYvXp1rFixIqX9VFT37t3jxhtvTEmu/fbbLy666KKkbQ899FC5XvM999yTNH7ppZdG586dK1RfMrfeemt88MEHce6550Z+fn7K8ua6ESNGxIYNGxLil19+ebRr126z2Lhx45JuW5pnn302ITZkyJAYNGhQQvyJJ54oV+4fyoWxlAs1plpJ83hZ5/BccNNNN0VxcXFCvHv37in7Po1dd901brrppqRt//znP+Prr78uc64pU6YkjZ966qnRtGnTipT3nUsuuSR22mmnSuUozRdffJE03rlz52jdunXa+i1Jtl5bHeOql2vze926deOxxx6LwsLChLbhw4fHv/71r1L3v+yyy+Kdd95JiBcWFsa//vWvqFu3boVrK0k2nm+5cNxz7fmxqueAXDiGd9xxR9L4AQcckIrS4rDDDqvU949VpaoeH7l2j5cKubI+lu1zW7bXV9VzX6aeSXNhjq9KuXJ+f5/7gqqXq89j1VGu3Yfk0jrE6NGjY+bMmUnbzj///DJ9D3NpDj74YN+vG8bw96VzLa26zNuXXHJJLFu2LGnbkCFD4pFHHonatWtXqo/Ro0fHySefnHRctmrVqsT9fvnLX5bpu72/r7CwMH75y1/Ghx9+GA8//HD06dMn7rzzznLXXBYdO3aMK6+8MmnbtGnTShwjAABkRnatBAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUGWaNGlSavvXX39dRZVkTseOHePss8/e4nZLliyJG264Ifr37x877bRTdOrUKfr16xeXXHJJfPbZZ1vc/4ADDogjjjgiaVu7du2iW7dupe5/zTXXRIsWLaJTp07Ru3fv6N27d3Ts2DEaNWoUAwYMiJdffrnUuq+99tqs6zvdiouL45577imxfccdd4x+/fptMc/WW28dAwcOLLH973//e4Xq+6GpU6fGxRdfHEuWLEna/uGHH8ZRRx0VrVq1ir59+8aRRx4Zxx57bOy7777Rpk2b+Otf/7rFPo477riU1FoRP/3pT6NDhw6lbrNw4cK4+uqr44ADDogdd9wxOnXqFPvuu29cc801Jf5cst24ceP+P/buOzyqov3/+CeFQAiQUKUjvSO9S68BAVHKo0hRAUUUGyJNHhABaSo+0kGqVJHeBem9Su+d0JMQkkBI8vvDH/kSs5u2Z8sJ79d1eV3uzJl77t09Z2bOkOSoffv2KlOmjAoWLKhq1aqpf//+unfvXoJtW7RoIT8/P/snCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAJnzpyxWN69e3eb4qZNm1aLFy9W1qxZbYrzvHnz5uns2bMW60aNGiV/f3+b4mfPnl2LFi2Su7u7JKl58+bas2ePNmzYoGzZstkUO7lmzpyphQsXWqyrVKmShg4dGm/7iRMn6sMPP5SXl1dMWd68ebVo0SJ5e3sbkmPlypVVqFChOOXXrl0zJL5RPvvsM3Xt2tWmGMWLF9f8+fPl4eERp+7p06f68ccfkxRv2rRpunPnTpzytGnTau7cufLx8UluqjHef/99denSRRkyZNBPP/2kgwcPqlq1ajbHTQmCgoK0cePGOOW1a9eOU7Zs2bIkx1+3bp2ePHkSq6xgwYLKmDFjrLKnT58mK/7zzHAumSFHe7A2jidmDP+3VKlS6eeff7b6nzOcPHnS6jzVo0cPffbZZzbFL1y4sP744w+lSZMmTl14eLhGjBiRpHjWcs2WLZt++OGHZOUoSS1bttSgQYOS3T4xrl+/bnVu7dGjh137tsYV51a+Y8cz2/g+duxYFS9ePE75jRs39MEHHyTYPiIiQh06dIgzx0tSiRIlNGbMmGTllRBXu97M8L2b7f7R0WOAGb7DRYsW6cqVKxbrXnvtNZtyK1GihH777TebYjiSo88Ps63xjGCW/TFXH9tcPT9Hj33Ouic1wxjvSGa5vp/HusDxzHo/lhKZbR1ipn2I6OhoffLJJxbr3N3dNWXKFPXv3z9mnk2K9u3ba8WKFYb9u5OZcQ7/w957aSll3L5x44Y6d+5stb59+/bavHmz8ubNa1M/s2fP1ueff57o46dNm6YVK1YkqY+MGTPq4sWLmjBhgvLnzx9T/vrrr2v06NFJipWQAgUKaPPmzUqbNq3F+gkTJhjaHwAAAGyX9DtNAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECKkC5dunjrg4KCEh2rYMGCmjdvXrL/69Onj61vJ0ZwcLBmzJihN998U2XLllWePHmUK1cu5cqVS7t27Yp1bJ8+feTh4RFvvDVr1qhAgQLq06eP/vzzT50+fVrnz5/Xjh07NHz4cBUuXFi//PJLgnn169fPYnmePHnibbd69WoNGDBAgYGBceqePn2qtWvXql69eho3blxM+ZkzZ9SjRw/lzp1bffr00bVr11yub0eYPn26IiMjrdZ369YtwRhdunSxeo7cvXtXf/zxR7Lze15oaKi+//575c+fX999950ePXoUU3f06FFVrlxZf/zxhyIiIuK0DQ4O1scff6x58+bF20fNmjXl5uZmSL7P+k3stda9e/d4Y61evVqFChXSwIED9ddff+nMmTM6f/68tm3bpgEDBqhIkSLavn27YbnbW2hoqNq3b68mTZpowYIF+vvvv3XhwgXt3r1bw4YNU6lSpXTu3Ll4Y7i7u6tatWoOyhgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMC1rVu3zmJ5w4YN9d577yUrZs6cObV9+3ZVrVo1puzgwYPJivW8yMhIffHFFxbrUqVKpeXLl6tXr17Jil2sWDFt3bpVL7/8cpy67Nmz686dO8mKa4Ru3brpypUrFuu++uor1a9f32rbgQMHKjo6Ok55vXr19Oeffyb4t/UT4ufnp2nTplmsW7NmjU2x7WHy5MkaO3Zsgs9TsKRZs2bavXu3smfPbrH+f//7n06fPp2kmKGhoRo0aJDFukqVKmnr1q3Kli1bknN95pNPPtGkSZNilb3yyivasWOHGjdunOy4KcnChQsTPCYyMlKrV69OcuyQkBD99ddfCR73559/6sGDB0mO/zwznEtmyNFerI3jCY3h/5YqVSr17NnT6n/O0qtXL6vP4xk7dqwmTpwoLy+vJMdt2LCh9u7dq3z58lmsHzx4sC5cuJCkmPPnz9eNGzcs1nXu3FnDhg1Lcp5du3bV4sWL5e7uHlN25syZJMdJDGtjytdff61atWrZpc+EuNrcynfseGYa31u0aKEPP/zQYt27776b6Pn46NGj+uabbyzW9ejRQy1atEhSXonlStebGb53M94/OnIMMMN3GBERoc8//9xi3dKlS9W7d+9k5Va/fn1t27ZNGTNmjCm7fv16smI5kqPnCDOt8Yxglv0xVx/bXD0/R499zronNcMY70hmub7/jXWB45nxfiylMtM6xGz7EFu2bNHEiROt1g8dOlRHjhyRv79/rP6tKV++vNavX6958+YpderUMeU3b95USEiIITmbEeewY/bSUsq4vXTpUv34449W62vUqKHjx4+rT58+8vHxSXY/P//8szZu3JjgcTt37tRHH32U5PgPHjyI89ztZ7744gstWbLE6r5UUrRv3167d++2+m/cp06d0uzZs23uBwAAAMZK+A4TAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJAipU2bNt76kJCQRMcqV66c2rdvn+z/6tSpY+O7+ceCBQuUL18+denSRb///ruOHDmia9eu6caNG7px44YiIiJijvXw8NCbb74Zb7zdu3erRYsWCgwMtHpMRESEevbsqVmzZsUbq0qVKsqfP3+c8qxZs8bb7vz58/HWS1J0dLS++OILTZ06Vc2bN1fRokU1YcIEhYaGxtvOmX07wo0bN7Rq1Sqr9W3atJGvr2+8Md5//32rdTNnztSTJ0+SnZ8lQUFBGjBggPLnz6+ffvpJDx8+VJs2beI9B5/57rvv4q339fVV4cKFDckzKddatmzZVKVKFauxDhw4oJYtWyo4ONjqMXfv3lXjxo11+vRpQ/K3tw8++EALFiywWh8QEBDvufVM9erVjUwLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAtLZt26a7d+9arJs8ebIGDhwoT0/PRMXy8vLSJ598oiNHjqhcuXIx5YGBgfrmm28MyXfFihWaMWOGxToPDw/9+OOP2r9/vxo1apSoeOnSpdOAAQN04MABi39zPDo6Wp9++qmio6NtSdsmQUFBevvttxUVFRWnzs3NTbNnz1aWLFkstj106JAmTJhgsa5atWo6ceKEBg4caLV9fBo3bqy9e/eqVKlSFusXLVqU5Jj2cPDgwVivP/vsM504cUJvvvmm3NzcEmxfunRpLV++XCtXrlSGDBksHnPp0qVkn+MTJkzQli1bLNaVL19ex44dU48ePRJ9HT7Lec2aNfrpp5/k7u4ep37fvn3asGFDsvJNaZYuXRrrOQCW7Ny5U/fv309W/GXLliV4zMKFC5MV+9/McC6ZIUd7eDaO/1tCY7hZ3Lp1Sx988IHV+u7du+vMmTPq0KFDor7bkiVL6o8//tD69evl5+dn8Zjt27dr1KhRSc716dOn+uGHH6zW9+3bV6tWrUrUc0jKly+vNWvWaPLkybHe1759+7R06dIk55YYEydOtFju5eWljRs3asSIEcqXL59d+n6eK8+tfMfOYYbxPUeOHJo+fbrFuvHjx2vdunWJjiVJo0aN0s6dOy3WTZ8+XdmzZ09SPGtc+Xozw/dutvtHR48BZvgOf//9d61cuTJOubu7u0aOHKmDBw+qcePGiYpVrFgxzZo1Sxs2bFCmTJliysPDwzVgwIBE5+Qsjj4/zLTGM4KZ9sdcfWxz9fwcPfY5657UDGO8o5jp+n4e6wLHM+v9WEpkpnWIGfchPvnkE+3Zs8dqfalSpbRq1SrdvXtXc+fO1YABA9S1a1e9+eab6tSpk/r06aMJEybo4sWLOnDggBo2bBgnxgcffKDw8HDDcjYbzmHH7KWlpHH7888/j/cZ7unSpdOIESN05coVjR8/XnXr1lWaNGkSjOvm5qYqVaro22+/1aVLl9SgQYN4j3/48KFatGihx48fJ/k9SNLXX3+tkJAQi3Wvv/66zp49qx9//FFly5ZNUlwvLy+1a9dOW7Zs0bx586w+O/7p06fq3LmzIiMjk5o6AAAA7MwtOpE7uIn5B1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcEXJfaixxN9qB2BdmTJlVKZMGUn/jDMXLlzQ7t27bRpzAAAAADjHu+++q+Ilijs7Dbwgdu7cqT+W/OHsNADAbvr176eMGTM6Ow28IJb8vkS7du1ydhoAYBd+fn7qP6C/s9PAC2bM6DEKCAhwdhoAYBcFKklvfuvsLPAiGdnE2RkAQMrm5uamihUrqkiRIjE/73306FEdPXrUyZkB5hUWFqY0adJYrR8xYoT69u2bqFh9+vTRiBEjkp3L2rVr1bRpU4t1lStX1p49exKMMXv2bHXs2DHRfdaqVUtbtmyJ95jy5cvr0KFDiYrn5+en69evK23atFaP6dWrl8aNGxerrEmTJlqzZo3VNsePH1e5cuUUERGRqDySwpl926JEiRI6fvy41fq7d+8qa9askiR/f3+tWrXK6rE9e/bUL7/8YrGuQYMG2rBhg9W2RYsW1ZkzZ5QhQwYFBQXFm3Pq1Kn15MmTeI+xJF26dAoJCUn08Xfv3lXmzJmt1levXt3qv7XZ61pr27atFixYYLW+SpUq2rt3b6JiJea63bhxoxo2bGixLqH3GBgYGO+/fSfmM9q0aZPq168f7zHPnDhxQsWLW/8ZtqlTp6pr166JioWkGfLtEHl7e7NHDgAO9uznzH753y+6dOmSs9MBgBdGj496KH/+/Jo2bZpOnTzl7HQA4IXw7HcX+dl3AHCs11u/rurVq2v1qtXavHmzs9MBgBdGU/+mqlevnjZt2qQ1q63/DAIAAACch7/VDsAe+FvtAAAAwIunbt268m/m7+w08ILh3yEBvEie/QwG4Ej8zCWAFwlzLZyF3zED8CJp2FMq19zZWeBFs/5n6bD1PzcJACkSf6vdtfAztUBc1s5/o39H5dNPP9UPP/xgtf7GjRuaPXu2tm7dqtOnTyswMFDh4eHy9fVVtmzZVKhQITVu3FjNmjVTjhw54ryHVq1aKSAgwOLfo65du7a2bt2apHxTp06tTZs2qXr16vEed+fOHa1fv16HDh3S7du3de/ePUmSr6+v8ufPr8qVK6tRo0by9va2GmPYsGHq3z/xz8O053c2dOhQq7msWrVKzZtbvpH08vLSjh07VLFiRauxIyIitHPnTv311186efKkLl26pIcPHyo0NFRubm7y8fGRn5+fChYsqHLlysnf31+FCxe2Gm/FihVq0aJF0t6gjax99q+88or27t2r1KlTx6m7e/eu1q5dqwMHDiggIEAPHjxQ+vTp9dJLL6lw4cJq0qSJihYtGm+/YWFhqlatmo4cOZLs3LNly6Z9+/Ypb968Vo+5deuW1qxZo40bN+rq1au6ffu2QkND5eXlpfTp0ytv3rwqU6aM/P39VbVqVatxbt68qapVq+rKlSuJzs9RY5GzrFmzRk2aWH9Y2pdffqkxY8YkK3aePHni/ayfPn2ql156Sffv309W/H9z9XPJDDna83y3Fju+Mfx5adOm1aNHj6zWO/uajG+eeiYoKEjr1q3T3r17FRAQoHv37snHxydm3G3atGmC4+6FCxdUuXLlmHk9qTw8PPTXX3+pZs2aVo+JiorS7t27tW7dOl25ckV37tyRm5ubMmXKpNKlS6thw4Z65ZVX4rR7/PixKlasqLfffltff/11rLqQkBClT58+WTk/b9u2bfHmLknXr1/XlStX9PDhQ0VFRcWpv3Xrljp37pxgX2adW/mOE/8dG8nVx/eNGzdafPbN2bNn9corrygsLCzRsZ4pUKCAjh49Kh8fH4v9WXvWjyVmvd5c/XuXXPv+0RJHjwFm+A59fX21f/9+FSpUyOoxAQEBWrNmjY4ePapbt27pwYMHSp06tTJlyqRSpUqpbt26KleunMW23bt316lTpyw+wyspzwFzBGfMEWZZ4xnBTPtjrj62uXp+jhr7nH1PaoYxnv3v+LEucDxHfeaO3G/99ddfLebTqVMnzZo1K1ExnLU/bJZ1iBn3Ifz8/LRhw4Z4/90ouYYOHaqBAwfqzp07ypIlS5z6pK6xzXa9PI9z2P57aWbdR7PEzc1NU6dO1bvvvpuo4yMiInT27FlduHBB9+/f16NHjxQdHS0fHx9lyJBB+fPnV7FixZQmTZok5TFy5Ej16dMnOW9BktS6dWv9/vvvCR539+5d7dmzRxcuXNDly5cVHByssLAwRUREKH369PL19VWuXLlUsWJFlS9f3uL+279169ZNU6ZMSXbuAIB/5qNKlSqpcOHC/DwtgERLzM94ezogDwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABACle4cGGn9n/t2jV169YtSW0qVKgQb/3hw4d16NChRMcLDAzUH3/8obfffjtJfd6+fTveuCVLltTBgwc1YcIE7dy5U+fOnVNISEii84qPM/t2lDVr1ujq1avKkyePxfpu3brpl19+sVpnzZYtW3TmzBlDcoxPUj/vmzdvKnPmzFbrM2XKZFM+ybnWypQpY7Xu77//1t69exMda+vWrTpy5IheeeWVJOXgSNOmTUv0sdu2bVPx4sWt1mfMmNGIlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFKE8ePHq2PHjipXrpzF+pw5c6pPnz7q06dPkmP36dNHy5cvV+XKlW1NM8bjx4/l7++vVatWqUaNGlaPy5o1q95+++14/9Z9fKZOnaoBAwYkN03DDRo0SA0aNFCVKlXi1DVr1kwff/yxfv755zh1T548UdOmTbVu3TqVL1/eYuxUqVKpdu3aql27ts153r17Vx9++KHNcYxy9OhRvfPOO1qwYIHc3Nxi1WXJkkUdOnRQhw4dkhU7LCxMrVu31pEjR2zK8fbt22rQoIE2bdqk3LlzWzzmpZdeUufOndW5c+dk93Pr1i01btxYV65cSXaMlGjhwoVq0qSJ1foVK1YkO/bVq1fjfRbA5s2bdf/+/WTH/zcznEtmyNFe9uzZk+Qx3EwGDBggNzc39evXz+oxvr6+atu2rdq2bZusPk6cOKEmTZro3r17yU1TkZGRateunQ4fPqysWbNaPMbd3V3Vq1dX9erVEx03OjpaH3zwgY4dO5bs3BKjY8eOOnLkiNKnT2/1mFy5cilXrlxW6y9dumRTDq4+t/Id2/4dJ4crj+9ffvml6tevH6c8MjJSHTp0UFhYWLJyuXDhgr744gtNnDgxTl2DBg30xRdfaMyYMcmK/YyrX2+u/L0/Y7b7R0ePAWb4DoOCgtSkSRP9+eefypcvn8VjsmfPri5duiQ59rhx4zR58mTVqlUryW2dwRlzhFnWeEYw0/6Yq49trp6fo8Y+Z9+TmmGMdxQzXd/PY13geGa9H0upzLIOMeM+RGBgoOrXr69Zs2apZcuWhsUdPXq0Bg4caFg8s+Mctv9eWkoat6Ojo/Xee+/pyJEjGjlypFKnTh3v8alSpVKJEiVUokQJQ/P46quvdPv27WTvaS1ZskTdunXT+PHj5enpafW4LFmyqFmzZslNM5aoqCj17NlTU6ZMMSQeAAAAjOfu7AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM7x9OnTeOu9vLwSHatgwYK2pmOTn3/+WeHh4UlqU6pUqXjrd+zYkeQ8EmpTokSJOGV///23Hj16FG+7UqVK6ZdfftGhQ4f08OFD3bp1Szt27NDMmTM1cOBAtW/fXkWLFpWbm1uS8nVm344SHR2tqVOnWq0vU6aMKlWqFKc8S5YsatmypdV2kyZNMiS/5MqUKZMqVKigNm3a6KuvvtLEiRO1bt06FShQIN52Pj4+NvWbnGutUKFCVuv++uuvJOewYcOGJLdxpK1btyb62IsXL8ZbnyFDBlvTAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASDGePHmipk2bJvg3npMiIiJC3bt316hRowyL+bygoCA1aNBA06dPNzx2VFSUhg0bpq5duyo6Otrw+MkVGRmpt956Sw8fPrRYP2rUKJUpU8Zi3d27d1WnTh0tXbrUjhlK165dU82aNXX9+nW79pNUixYtUvv27ZP8N+Hjc+vWLTVq1Ehr1641JN7Zs2dVrVo17d2715B4/3bw4EFVrFhRf//9t13im9nSpUsVERFhse7MmTM6c+aMTfGXL19utW7RokU2xbbEDOeSGXK0h+SO4WbSv39/vf/++wk+tyU5Vq1apRo1aujq1as2x7px44ZeffVVnT9/3oDM/lk79OzZUzNmzDAkXnwuXryo1q1bKygoyO59xcfV51a+Y+dwxfG9fPnyGjZsmMW6YcOG2ZzrpEmTrJ6zw4cPV7ly5WyKL7n+9eaK3/u/men+0RljgBm+w/Pnz6tGjRo6ePCgYXmNGDFCvXr1MiyeIzhrjjDLGs9WZtsfc/WxzdXzc8TY5wr3pGYY4x3BbNf3M6wLHM/M92MplVnWIWbchwgODlarVq3UvXt33bt3z6ZY9+7d09tvv63evXsblF3KwTk8w5B41qTEcXvcuHGqUqWKU+fKUaNGqWPHjsluP2XKFDVr1kwBAQEGZmXZ+fPnVadOHU2YMMHufQEAACD53J2dAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAOcLDw+OtT58+faJjFSpUyNZ0bLJ27dokt8mWLVu89efOnUtyzITaWOozIiJCK1euTFI/2bJlU/Xq1dWxY0cNGTJE8+bN06lTp/TgwQPNmDFDNWrUSFQcZ/btSNOmTVNkZKTV+m7dusUp69Spk7y8vCwef//+ff3++++G5RefggUL6q233tKoUaO0dOlSHTlyRMHBwbp3757279+vhQsX6vvvv1f37t3VqFEjpU2b1q75JOday5gxo9W65Fxnx48fT3IbR4mOjlZAQECijw8JCYm33s3NzdaUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUpRbt26pSpUqWrVqlc2xjh49qsqVK2vy5MkGZGZdeHi43nvvPbVo0UIXLlwwJOb58+fVsGFD9e/f35B4Rrtw4YJ69uxpsS516tRasGCBvL29LdY/fPhQr7/+utq0aaMrV64Ymld0dLTmzJmjSpUq6fTp04bGNsrChQtVtWpVHT582OZYixYtUsmSJbV9+3bbE3vOtWvXVLNmTfXv31+hoaGGxAwNDVWfPn1UuXJlXbt2zZCYKc2DBw+0adMmi3XLly+3Of6yZcsslkdGRuqPP/6wOb4lZjiXzJCj0WwZw81k2rRpKl26dLKexWHJzZs39c4776h58+YKDAw0JKYknT59WpUrV9aaNWtsinPnzh01adJE48ePNyizhG3cuFGVK1fWtm3bHNanJa4+t/IdO4crje9p06bVvHnzlCpVqjh1Bw4c0JAhQwzJ791339X9+/fjlKdKlUrz58835NlHrn69udL3bo2Z7h+dMQaY4Tu8fv26qlSpYvO1e/fuXbVs2VJ9+/a1OSdncNYcYZY1nq3Mtj/m6mObq+dn77HPVZhhjHcEs13fz7AucDwz34+lVGZZh5h1H2Ly5Ml6+eWX1b9/f50/fz5JbW/fvq0hQ4aoaNGi+u233+yUoflxDttXShy3jxw5oldeeUVvvfVWsp5RnZC7d++qX79+Kly4sM6cOROn3s3NTdOmTVPz5s2T3cf69etVuHBhjR49WmFhYbaka1FoaKh++OEHlS5dOkV99wAAACmVu7MTAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4R0hISLz1GTJkSFSc1KlTK1euXEaklGynTp1Kcpv06dPHWx8UFJTkmIGBgfHWW/tMBw8erKdPnya5v3/z9fVVp06dtH37di1btkwvvfRSgm2c2bejXL9+XWvWrLFa3759e/n4+MQq69q1q9XjZ86cqSdPnhiW37+lTp1avXr10tGjR3Xu3DnNnTtXX375pVq2bKkyZcokeO7aU3KutX9/ts9L6Jqx5MGDB0lu4ygPHz5M0vUUFRVlx2wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABSpjt37qh58+Zq06aNtm/fnuT2Bw8eVPv27VW2bFkdPnzY+AStWLFihYoWLaq3335bO3bsUHR0dJJjHDlyRN27d1fRokW1adMmO2RpnFmzZmn+/PkW64oVK6affvop3vaLFy9W/vz51aZNG23cuFGPHz9Odi4PHjzQ9OnTVaVKFb3zzjsKCAhIdixHOHLkiCpWrKhOnTrp5MmTSWobHh6uRYsWqXz58mrbtq3u3btnlxwjIiI0bNgw5c+fX999952uXbuWrDhXr17VN998ozx58mjkyJGKjIw0ONOUZeHChRbLly1bZnPsAwcO6ObNm3HKt2zZort379oc3xoznEtmyNFoto7hZnHx4kU1bdpUlSpV0sKFCxUaGprkGIcPH1b37t318ssva86cOXbIUrp//778/f1Vr1497dq1K0ltAwMDNWrUKBUqVEgbNmywS37xOXPmjGrVqqUqVapo0qRJOnr0qFOe1+HqcyvfsXO4yvg+btw4FSlSJE55WFiYOnToYMjzpSTp5s2b6tGjh8W6IkWKGDa2u/r15irfe0LMcv/ojDHADN/h06dPNWjQII0ZM0Z37txJUtvbt29ryJAhKlCggJYvX25YTs7grDnCLGs8W5lxf8zVxzZXzs8MY58RXpT3mRAzXt8S6wJnMPP9WEpllnWIWfchQkJCNGzYMBUqVEjly5dXz549NX36dG3cuFH79u3TyZMndejQIW3dulWzZ89W3759Va1aNeXIkUODBg2yeI+ZOnVqi30ZdS9uNpzD9pUSx+3o6GjNmzdPxYoVU9OmTTVjxoxkPa/6mfDwcC1btkydOnVS3rx5NXz4cJ07d04NGzbU9evX4xzv6emphQsXqkaNGsnuMyQkRL1791b27NnVo0cP7dq1y+Yx4Pjx4/r444+VM2dOff755woLC7MpHgAAABzDLTqRu8Jubm72zgUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA7CI5D+t8hr/VDsCaMmXKqEyZMpL+GWcuXLig3bt32zTmAAAAAHCOd999V8VLFHd2GnhB7Ny5U38s+cPZaQCA3fTr308ZM2Z0dhp4QSz5fYl27drl7DQAwC78/PzUf0B/Z6eBF8yY0WMUEBDg7DQAwC4KVJLe/NbZWeBFMrKJszMAgJTNzc1NFStWVJEiRWJ+3vvo0aM6evSokzMDzGvnzp2qVq2a1fpdu3apevXqCcZJnz69unbtGu8xr776qlq1amW1fu3atWratKnFusqVK2vPnj1W24aGhsrHxyfBPP9t165dqlq1qtX6t99+W7/99luSYpYpU0ZHjhyxWh8eHi5vb2+Lde+//76mTJmSpP4ScuXKFTVq1EinT5+O9zhn9p0cJUqU0PHjx63W3717V1mzZo1V1rx5c61YscJqm65du2rq1KmS/jlft27davXY4sWL69SpUzGvM2TIoKCgoHhzTp06tZ48eRLvMZJUp04dzZ49W7lz507w2ORo166dFi5caLHOGddacq4zf39/rVq1ymr9xo0b1bBhQ4t1Cb3HwMDAeP/t29b2/9ajRw/98ssvVuvjey+wzZBvh8jb25s9cgBwsGc/Z/bL/37RpUuXnJ0OALwwenzUQ/nz59e0adN06uSphBsAAGz27HcX+dl3AHCs11u/rurVq2v1qtXavHmzs9MBgBdGU/+mqlevnjZt2qQ1q9c4Ox0AAABYwN9qB2AP/K12AAAA4MVTt25d+Tfzd3YaeMHw75AAXiTPfgYDcCR+5hLAi4S5Fs7C75gBeJE07CmVa+7sLPCiWf+zdNj6nyYEgBSJv9XuWviZWsD1FC1aVDVr1lS1atVUqFAh+fn5KWPGjEqVKpUePnyowMBAnTx5UocOHdKqVat07tw5Z6csScqePbvq1KmjqlWrqlChQsqTJ4/SpUsnb29vRUVFKSgoSIGBgTp16pQOHjyoTZs26eTJk85O22nSpk2r2rVrq0yZMipWrJgKFiyo9OnTK126dPLx8VF0dLRCQkL08OFDBQcH6/z58zHz5Y4dO/T06VNnvwVJ1n/vK77f6SpVqpT8/f1VtmxZFSlSRBkyZFC6dOkUHh6uoKAgBQQE6OjRo9q7d6/Wrl2rR48e2Sv9eFWsWFE1a9ZUhQoVlC9fPmXLlk0+Pj7y9PTUkydPFBwcrMDAQJ0+fVrHjx/Xn3/+yXoGFpnhXDJDjq5i8+bNqlOnTsxrV/4d1jRp0qhhw4aqXLmyypQpo1y5csnX11fp0qXT48ePFRQUpPv37+v48eM6cuSI1q9fr8uXLzs8zzx58qhx48aqU6eOcubMqaxZsypTpkx6+vSpAgMDdfv2bR06dEg7duzQmjVrEvXMFEfy8fFRjhw5Yq3ZLAkLC0vUz7ikxLmV79h5GN/jlxKvN8kc37uZ7h+dMQa48nfo7u6uWrVqqWbNmnrllVf08ssvx6wvQkNDFRwcrKtXr+rw4cPaunWrNm/erKioKIfk5gzOOD/MssazlRn3x1x9bHP1/Fx57DPSi/I+42PG6/sZ1gWOZ+b7sZTILOsQs+9DJJe7u7siIyMt1pUoUeKF/je5ZziH7S8ljtupUqXSK6+8orJly6ps2bIqXLiwMmTIIF9fX2XIkEHu7u4KCQlRUFCQgoODdfHiRR09elR///239uzZo9DQUItxS5QooW3btilTpkxx6gIDA/Xqq6/q2LFjhrwHHx8fVa9eXWXKlFHBggVVsGBBZcqUST4+PkqbNq1Sp06tsLAwBQYGKjAwUA8ePNDJkye1e/du7d27V7dv3zYkDwCAZW5ubqpUqZIKFy7Mz9MCSLTE/Iy3pwPyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC4oOvXr8db/8orr8jd3V1RUVHxHvfw4UONHTs23mPCw8PVqlWrpKaYKE+ePLFLXEebOnWqwsPDNXnyZHl7exsSM2/evFq5cqUqVKig4OBgl+zbUVavXq3r168rV65cFuu7du2qqVOnxvy/Ndu2bdOpU6fskuN//vMfzZo1S56ennaJb6vkXmuRkZFW67y8vJIcLzltAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkHKdPn1ap0+f1rRp05ydSpIEBARo/vz5mj9/vrNTMYXQ0FCtWbNGa9ascXYqDnfs2DEdO3bM2WkkaP/+/dq/f7+z00AKYIZzyQw5ugoPD4+Y/4/vGRauIDw8XCtWrNCKFSucnUq8rl69qqlTp8Y8a8VsHj16pHPnzjk1B1efW/mOnYfx3Xiufr1J5vjezXT/6IwxwJW/w6ioKP3111/666+/nJ2KS3DG+WGWNZ6tzLg/5upjm6vn58pjn5FelPcZHzNe38+wLnA8M9+PpURmWYeYfR8iuTJkyGC17v79+w7MxHVxDttfShy3IyIi7DIfnzhxQv7+/vrzzz/l4+MTq87Pz0/r169X5cqVde3aNZv7evTokTZs2KANGzbYHAsAAADm4e7sBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAznH8+PF469OmTauSJUs6KBvHCw8Pj7c+TZo0SY6ZUJuwsLB46+fMmaMSJUpo1qxZioiISHL/lhQqVEhDhgxJ8Dhn9u0IUVFRmjZtmtX6ypUrq0yZMvL19dWbb75p9bhJkybZIz2VK1dOv/76qzw9PZPVPiAgQDt27FBgYKCxiRkgJCTEap2fn1+S42XOnNmGbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOAozz+bIjg42HmJAAAAAAAAAMD/V7RoUYvlERERunXrloOzAZAYe/bsUevWrS0+f3379u1cuwAAALCJu7MTAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4x6FDhxI85u2333ZAJs7x8OHDeOt9fX2THNPPzy/e+uDg4ARjXLp0SZ06dVK2bNnUpUsX/frrr/r777/1+PHjJOfzTLdu3RLMzdl9O8LUqVMVFRVltb5r167q0KGDvL29LdY/ePBAixcvtktuo0ePVurUqeM9Jjo6WkePHtX06dP15Zdf6vXXX1eZMmXk4+OjHDlyqGbNmjp37pxd8rPFvXv3rNaVLFkyyfHKlCljSzoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwgHTp0qlo0aIxrwMCApyYDQAAAAAAAAD8o3LlyhbLT5065eBMACTF+vXr9c477yg6OjqmbNKkSWrXrp0iIiKcmBkAAADMztPZCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnGPr1q2KioqSu7u71WM6deqkb775Rk+ePHFgZo4REBAQb32RIkWSHDOhNgn1+bzAwEDNmDFDM2bMkCS5ubkpZ86cKliwoAoUKKCCBQuqYMGCqlixogoXLhxvLG9vb9WvX1+///67y/dtT1evXtXatWvl7+9vsb5Dhw66ceOG1fazZs3S48ePDc+raNGiqlevntX66OhojRo1Sj/++KNu3rwZb6w0adIYnZ7Nzp49a7UuvvdtTePGjW1JBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4wZswYeXl5xbzeu3evE7MBAAAAAAAAgH80aNDAYvmBAwccnAmApFqwYIGyZMmi//3vf/ruu+80YMAAZ6cEAACAFMDT2QkAAIDk+eWXX9SiRYs45evWrdP777/vhIzg6nbt2qXcuXPHKR82bJgmTJjghIwAAICrY/0AAObH/gESi3kfAAAAScUaEgAAIOUwci+ZfWngxcYYAAAAXjSsfwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJCSPHjwQPv27VOVKlWsHpM9e3Z9++236tOnjwMzc4y///473vpXX301yTETanP8+PEkx3wmOjpa169f1/Xr17V169ZYddWqVdPvv/+uHDlyWG1fqVIl/f7776br22iTJk2Sv7+/xTo/Pz/5+flZbTt58mS75NSwYcN468eOHZvoazC+78FZjhw5YrWuQIECatq0qdasWZOoWM2bN1fRokWNSg0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG8/T01P/+9z9169YtVvmMGTOckxAAAAAAAAAAU/Lx8dGjR48MjZkrVy41a9bMYt26desM7QuAffzyyy/av3+/9uzZ4+xUAAAAkEJ4OjsBAADMwsvLSyVKlFCRIkXk5+enDBkyyNfXV56ennr06JGCgoIUFBSkO3fu6MiRI7px44Zd88mUKZNy584dpzxz5sx27RfmlT17dovnTPr06Z2QDeA8Pj4+8vDwiFMeFRWlkJAQJ2QEICUz+5jD+gEAzI/9AyQW8z4ApDxmvycF4PpYQwIwGusXAHAeI/eS2ZcGzMXoNRhjwIuNNT0A4EXE+gcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApzezZs1WlSpV4j/nyyy+1c+dOLVu2zEFZOca+ffvirS9ZsqSqVq2q3bt3Jype1qxZ1bJly3iP2bt3b6Ji+fj4KDo6WqGhoYk6fteuXerfv7+mT58eb36u3rcjrFy5Ujdu3FDOnDmT1G7Hjh06ceKEXXIqWrRovPVLly5NdBxX/Hu5mzdvVlRUlNzd3S3W//LLLypbtqyCg4PjjZM5c2ZNmDDBHikCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAC+99JIWLVqkV199NVb5vHnz9NdffzknKQAAAAAAAACm4u7urgEDBuiDDz5Q2bJldfv2bcNif/311/Lw8IhTHh4errVr1xrWDwD72rNnj7NTAAAAQAri6ewEAABwZTVr1lS7du1Uu3ZtFS9eXJ6eiZ86b926pf379+uPP/7Q4sWLFRQUZMdMAQCJtX37dpUtWzZO+alTp1S8eHHHJwQgRWPMAQAAAAA4C/ekAADAbFi/AAAAOB5rMBiJ8wkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMD85s6dqxEjRihdunRWj3F3d9eSJUv01Vdf6ccff1RkZGSS+3Fzc7MlTbvYs2ePbt++rWzZslk9ZuLEiapSpYoeP36cYLyJEycqderUVuujo6O1YsWKeGOkTZtWH330kb766istWbJE3bt3T7DfZ06dOhVvfZo0aVy2b0eKiorS9OnTNWDAgCS1mzRpkp0ykjJnzmxInF69ehkSx2iBgYHavHmz6tevb7E+f/782rx5s1q3bq3Lly9bPKZgwYJatmyZcufObc9UAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkEy5cuXSvn37lCNHjljla9eu1bvvvuukrAAAAAAAAACYSZ48efTbb7+pZs2akqQlS5aoQYMGCg8Ptzl2/fr19dFHH1msW7BggQIDA23uAwAAAABgPu7OTgAAAFeUIUMGDR48WNu2bVPPnj1VunRpeXp6JinGSy+9pGbNmmnq1Km6deuWFi1apFKlStkpYwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkicwMFA//fRTgse5u7tr9OjROnPmjD788EMVKFAgwTa5cuXSm2++qdmzZ+v77783Il1DRUdH67fffov3mFdeeUUbNmxQ9uzZrR7j4+Oj2bNnq3Xr1vHG+uuvv3Tjxg2Ldd7e3vr888916dIljRw5UlmyZFG3bt30xRdfJPxG/r/q1avHW3/nzh2X69tZpkyZoqioqEQfHxgYqEWLFtktn9DQ0HjrX3/99QRj+Pv7q3v37kalZLiJEyfGW1++fHmdOnVK06dP11tvvaXatWurZs2aateunaZNm6Zjx46pZMmSDsoWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASXX9+nXt2rUrVtnUqVPVokULhYeHOykrAAAAAAAAAGbx+uuv6+jRo6pZs2ZMWY0aNbR+/XplyZLFptj16tXT77//Ljc3tzh1T58+1XfffWdTfAAAAACAeXk6OwEAAFxJ6tSp9cUXX6h3797y8/MzNO6bb76p1q1ba/r06RowYIBu3bplWHwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGwxYsQIvfPOO8qbN2+CxxYoUEDjx4+XJN24cUOXL1/WvXv3FBwcrNSpUytt2rTKnj278ufPLz8/PztnbrtRo0apR48e8vLysnrMq6++qvPnz2vWrFlat26drl69qsjISGXPnl21a9fWu+++q2zZsiXY17Bhw+KUeXl5qUePHvr666/10ksvxakfPXq0GjdurJ9++klbtmxRSEhInGPy5MmjTp06aeDAgfH2f+3aNZfp29muXLmi9evXq0mTJok6fvbs2QoPD7dbPrdv3463/tNPP9Xt27c1btw4hYWFxapLmzatevXqpcGDB8vd3d1uOdrq999/19GjR1WmTBmrx6RJk0ZdunRRly5dHJgZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjNK5c2eVLl1aefLk0aeffqpJkyY5OyUAAAAAAAAAJlGkSBGLz8V+9dVXdfz4cX399deaM2eOIiIiEh0zU6ZM+vLLL/Xll18qVapUFo/56aefdPbs2eSmDQAAAAAwOU9nJwAAgKsoUaKE5s+fr9KlS9utD3d3d73//vtq1aqV2rRpo7/++stufQEAAAAAAAAA4vfpp5+qYMGCccq3bNmixYsXOyEjAAAAAAAAAM7CfiFSCs5luCLOSwD2xjgDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGCckJESdO3fWhg0b5OHhkeh2OXPmVM6cOe2Ymf3duHFDI0aM0DfffBPvcWnTptUHH3ygDz74IFn9LF++XBs3boxTnipVKvXv319ZsmSx2rZhw4Zq2LChJOn27dsKDAxURESEUqdOrSxZssjPzy9ROfy7f2f27QomTZqkJk2aJOrYyZMn2zWXXbt2xVvv7u6uESNGqHfv3jp48KCuXr0qT09P5c6dW1WrVlXatGntmp8RoqOj1bNnT/31119yd3d3djoAXEjatGnl6elp936ioqIUEhKS7PblypVT5cqVVapUKeXMmVPp06eXt7e3IiIiFBISoitXruj48ePasmWLTpw4YWDmjpchQ4ZYr8PDw/XkyZNkxSpQoIBatGihihUr6qWXXpKHh4fu3LmjkydPasWKFTpw4IARKceSJk0aeXl5xSoLCwtTRESE4X0BKZWrj3lmmTsAQIq7trLmyZMnCg8Pf2FySQ43NzdVrVpV1apVU6lSpZQtWzalS5dO7u7uCg0N1Z07d3T27Fnt3btXW7duVWhoqLNTBuAizLR+ZC3+j6R+luw/AOZUvnx5VapUSSVKlFDu3LmVLl06eXt7KzIyUiEhIbp586ZOnz6tHTt2aN++fYqMjHR2ynEULVpUtWrVUunSpZU3b16lT59eXl5eevz4sYKDg3X58mUdPXpUW7Zs0YULF5ydLoAUzJXu+V0pF2sSm6Mt2F8GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAvuocPH6pVq1by8PDQ33//7ex0AAAAAAAAAJjI6NGj9frrr6tKlSpx6rJly6bp06drxIgRWrlypbZu3aozZ87o2rVrevTokR4/fixPT09lypRJmTNnVrly5VSvXj01a9ZM6dOnt9rnoUOH1K9fP3u+LQAAAACAi7P/U/oAADCBTp06acKECfL29nZIf1myZNGGDRv0+eef6+eff3ZInwAAAAAAAACA2N544w3VrFnTYt3ixYsdnA0AAAAAAAAAZ2K/ECkF5zJcEeclAHtjnAEAAAAAAAAAAAAAAAAAAACkMmXK6MCBA5KkcePG6YsvvnByRgAAAAAAAAAAAAAAAAAAwMw2b96sjz76SBMnTnR2Kg737bffqlmzZqpQoYJd4gcEBKhbt24W6x49eqTvvvtOP/zwQ6JiZcuWTdmyZUtyDqdOndLhw4ddpm9XsGLFCt28eVM5cuSI97hdu3bp2LFjds1l06ZNevTokXx8fOI9LnPmzGrYsKFdc7Gnbdu26b///a+GDBni7FQAuJBVq1apTp06du/n3LlzKly4cJLaZMqUSZ9//rk6duyoPHnyJLrdqVOnNH78eE2aNElPnjxJaqpO1a9fP3333Xexyvr3769hw4YlKU7WrFk1atQovfPOO3J3d7d4zKBBg7R582Z9/PHHOn78eLJzfl7mzJl1+PBh5c6dO6bs5s2beuWVV3Tnzh1D+gBSKjONea48dwDA815++WVdvHgxUcdOnTpVXbt2fSFySaocOXLo008/1bvvvqssWbIkqk1oaKiWLFmi77//3u77OgBcn6uvH1mLx5XYz5L9B8B88ufPr169euk///lPkv7d8c6dO5o5c6ZGjx6tW7du2THDhHl5eem9997TRx99pJIlSya63cGDB/W///1Ps2bNUmRkpB0zBPCicaV7flfKJT5BQUF274P9ZQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOnEiRPOTgEAAAAAAACACUVGRqp58+bauXOn1b/zmi1bNr377rt69913be7vwoUL8vf3N92zJwEAAAAAxrL8NDwAAF4gH330kWbMmCFvb+94j3v69Kn27t2ryZMnq3fv3urSpYvatWunN998U++8844+/vhjDR8+XOvWrdO9e/cS7NfT01Pjxo3TJ598YtRbAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC8gDw9PeXp6Sl3dx5HAwAAAAAAAAAAAAAAAAAAbDdp0iR169ZNkZGRDu336tWrGj58uEP7fN7Tp0/l7++vixcvGh47JCRE/v7+unXrltVjfvzxR61fv97wvp/34YcfulzfzhYZGalff/01weMmTZpk91wePXqkH374wZBY9+7d0+nTpw2JZQ/ffvutTe0fPXqkxYsXG5QNAFjXtWtXXbp0Sf3791eePHmS1LZYsWIaN26cTp06pRo1atgpQ+PVqlVLQ4YMsTlOoUKFtHv3bnXq1CnB33mpW7eudu3apfr169vcryTNnj1buXPnjnkdGRmp//znP7pz544h8YGU6kUc82CZv7+/pkyZEuu/HDlyODstwLQKFy7s7BRiuFIuieXu7q6vvvpK586d01dffaUsWbIkum3atGnVoUMHHTlyRP/73/+UJk0aO2bq+hjfAdfFWjz52H8AzMXb21ujR4/W2bNn1atXL2XLli1J7bNmzaovv/xSFy5c0GeffWanLBNWp04dnTp1SuPHj1fJkiWT1LZ8+fKaPn26jh49qkqVKtkpQ9fH2hQwnivd87tSLnA8xngAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARrl7965q1aqlnTt32rWf/fv3q3r16goICLBrPwAAAAAA1+fp7AQAAHCmnj176ueff473mK1bt2rKlClaunSpQkJCEhXXzc1N9evXV5cuXdSuXTt5eHhYPfaHH37Q1atX9ccffyQpdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA7GHKlCk6deqUZs+erXz58tm1r4iICP38888aPHiwgoOD7dpXQm7fvq0aNWpoxYoVqlChgiExr127ptdee02HDx9O8Ng33nhDy5YtU7169Qzp+3m9e/fWX3/95ZJ9O9uUKVPUt29fubm5WawPCgrSwoULHZLL8OHD1bRpU5vOv9DQULVu3VqDBw9W0aJFDczOWB9++KF+/PFHpU6dOknt7ty5o5YtW6pcuXJ688037ZQdAEhubm6aPHmyzXHy58+vLVu2qHPnzpozZ44BmdlP1qxZNX/+fHl4eNgUx8fHR6tXr1aBAgViyqKjo7Vz504dP35cT58+VcGCBVW3bl15eXlJktKnT69ly5apXLlyOnv2bLL77t27t5o2bRqrbPDgwdqyZUuyYwIpnZubm2bMmKGOHTvaHMtMYx6sK1u2rN5///1YZT/88INu3rzppIwAcytcuLCzU4jhSrkkhq+vrxYtWqSGDRvaFMfd3V0fffSRatSoocaNG+v27dsGZWgujO+A62Etbhv2HwBzyZ49u9avX6/SpUvbHCtt2rQaO3asqlatqrfffltPnz41IMPE6dWrl8aOHSt3d3eb4pQoUULbt2/X+++/r9mzZxuUnXmwNgWM50r3/K6UCxyPMR4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAkQICAlSnTh317dtXffr0Udq0aQ2L/fjxY40ZM0aDBg1y6N88BwAAAAC4Lk9nJwAAgLPUq1dPP/30U7zH1KpVS9u2bUty7OjoaG3cuFEbN27UsGHD9OOPP6pBgwYWj3V3d9fcuXNVqlQpXbhwIcl9AQCSplWrVkqdOnWc8idPnjghGwApHWMOAAAAAMBZuCcFAABmw/oFAADA8ViDwUicTwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACnTtm3bVKJECX3++efq3bu3MmTIYGj84OBgTZ8+XT/99JMuXbpkaGxb3Lx5UzVq1NDAgQPVu3dveXl5JTvWzJkz9cUXX+jevXuJOj4kJERNmjTRgAED9PXXX9vU9zN3795Vr1699Ntvv7ls38526dIlbdiwQY0aNbJYP2fOHIWFhTkkl9DQUPn7+2v58uWqUqVKkttfvnxZbdq00b59++yQnbEmTpyoNWvWaOjQoWrTpo3Fv3v/vPDwcE2YMEH//e9/FRwcrGrVqsV7fHBwsJHpAkghQkNDE33s5MmTLZYfO3ZMf/31l06ePKn79+8rLCxMPj4+yp49uypXrqymTZvGWTd5eHho5syZun37ttavX2/Te7AXNzc3zZ07Vzly5LA51ogRI1S4cOGY1wEBAWrRokWc+SlfvnxaunSpypYtK0ny8fHRjBkzVKNGjWT1W61aNQ0bNixW2aZNmzR06NBkxQNeFJMnT1bHjh0t1qXUMS8pkjJ3AIAlRYsWdXYKMVwpl4T4+Pho/fr1qly5ssX6/fv3a+PGjTp+/Lju3LmjJ0+eyM/PTzly5FDNmjXVqFEjZc6cOVabsmXLavPmzapcubIePXrkiLcB4AWU1L0H1uLWJfRZsv8AmIevr6+2bdumQoUKxal78uSJduzYob179+r8+fMKCgrS48eP5ePjo8yZM+uVV15R/fr19fLLL8dp27ZtW4WFhalz5872fxOSPvvsM40dO9ZiXVRUlHbs2KGjR4/qxo0bCgoKkp+fn3LmzKny5curSpUqcnNzi9XGy8tLM2fOVFRUlObOneuItwAgBXOle35XysXZ2F8GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANtFRERoyJAhmjp1qnr06KEuXbooZ86cyY4XFBSkGTNmaOzYsbpy5YqBmQIAAAAAzM7T2QkAAOAM2bNn17x58+Tu7m71mO+//17btm2zua/jx4+rYcOG+u9//6tvvvkmzoMeJcnb21u//PKLmjZtanN/AID4Xb582dkpAHiBMOYAAAAAAJyFe1IAAGA2rF8AAAAcjzUYjMT5BAAAAAAAAAAAAAAAAAAAAAAA4Fzx/d19e/Py8tKTJ08c3q+n5z+P3Xn69KnD+04sM+RopBft/QIAAAAAAAAAAAAAAADAiyQ0NFRDhw7V2LFj1b59e7Vr1061a9dW6tSpkxXv5s2b2rx5s37//XetXr1a4eHhBmdsjMePH2vAgAGaMmWKPvvsM3Xq1El+fn6JahsWFqYlS5Zo9OjROnz4cJL7joiI0KBBg/Trr7/qo48+UqdOnZQ1a9Ykxzl79qx+++03jR07VsHBwS7ft7NNmjRJjRo1slrnSLdv31aNGjX0xRdf6NNPP1WOHDkSbHP37l398ssvGjlypEJDQx2QpTEuX76sd955Rx9//LGaNm2qypUrK1++fMqYMaMiIyN169YtBQQE6K+//tLGjRsVFhYW0zZjxozxxr5//7690wdgoHbt2ilNmjSGxfPy8tLWrVvjjKFjxoxJVPv27dvr/fffj1W2fv169enTJ8H53cfHRz179tR///vfWO/J3d1ds2bNUqFChRQSEpK4N+JAffv2VcOGDW2OkzlzZr333nuxytq2bat9+/bFOfby5cvy9/fX2bNn5ePjI0mqXr26qlevrp07dyap34wZM2rBggUxv+MgSbdu3dJbb72l6OjoZLwT4MVgabyTzDHmudrcAQDWfPrpp/rss8/ilJcqVUpHjhx5YXNJyMyZM1W5cuU45Rs2bFDfvn114MABq23Hjx8vb29vdevWTUOGDFGGDBli6kqUKKHx48erU6dOdskbgOtytfUja/H/k5zPkv0HwFxmzJihQoUKxSoLCwvTsGHDNH78+ET9m06jRo30ww8/qESJErHKO3XqpFWrVmnRokWG5vxvNWrUsDguRUZGasyYMfrxxx918+ZNq+3z5Mmj3r17q2fPnnJzc4spd3Nz07Rp07R//36dPn3aLrkDeDG40j2/K+USn3z58hkWi/1lAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMn1/N+iAAAAtmNuBRyH6w0AAAAA4Aw3btzQgAED9M0336h8+fKqU6eOKlWqpAIFCujll19WhgwZ5OXlFatNWFiYrl+/rvPnz+vAgQPavHmztmzZooiICCe9CwAAAACAK/NM+BAAAFKeadOmKVu2bBbroqOj9d577+nXX381tM///ve/unHjhiZNmmSxvkmTJmrdurWWLFliaL8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJTBw8NDjRo1UtOmTVWxYkUVLlxYmTNnjqnv2bOnXn/9dV24cEG7du3S6tWrtWPHDpv7LVCggF577TXVqVNHxYsXV+7cuZU2bVq5ubkpKipKDx480Llz57R7924tW7ZMmzdvtrnPZ7Jnz6527dqpfv36KlWqlHLnzq1UqVJJkiIiInT9+nUdO3ZMmzZt0oIFC3Tjxg3D+k4pOZYrV06vvvpqzOsTJ05o48aNyY7n6u8XAAAAAAAAAAAAAAAAAGAfoaGhmj59uqZPny5vb2+VL19e5cqVU6FChZQrVy5lyZJFadKkUZo0aRQREaGwsDAFBwfr5s2bunr1qo4dO6ajR4/q/Pnzyc5h7969cnNzM/BdJezy5cv69NNP9cUXX6hmzZqqWrWqSpcurezZsytDhgxyd3dXcHCw7t27p+PHj2vfvn36888/FR4ebnPfly5dUu/evdW7d2+98sorqlGjhgoXLqwCBQooffr0SpcunVKlSqWwsDCFhITo4cOHunDhgv7++28dOHBAx48fN2XfSXHixAnDzoklS5bYHCs4ONiwfCIjIzVy5EiNHTtW9evXV/Xq1VWqVCllzJhRvr6+Cg8P1927d3Xq1Clt3rxZmzZt0pMnT2LFqFu3brL6dsa1FhgYqHnz5mnevHmJblOkSJF46+/fv2+1ztb3aPRnNH78eI0fP96weIAZ3b5929B4H374oXLkyBGr7OjRo5o9e3aCbX18fPS///0vVtmwYcPUv3//RPX96NEjff/999q8ebPWr18vX1/fmLqXXnpJPXv21IgRIxIVy1Fq1aqlIUOGGBKrdevW8vb2jnm9detWbdu2zerxN2/e1K+//qqePXvGlHXo0EE7d+5MUr+zZs1Snjx5Yl5HRUXprbfe0q1bt5IUB3iRWBrvJPOMea40dwBAfKKjoxUdHR2n/OnTpy90LvH5z3/+ozfeeCNO+YABA/Tdd98lKkZYWJh++uknrVq1SitWrFCxYsVi6jp27KjVq1drwYIFhuUMwPW50vqRtXhsyfks2X8AzKN27dpq1apVrLKrV6+qUaNGOnXqVKLjrF+/XuXKldOiRYvUokWLWHUjRozQ4sWLLa51jZA6dWpNmzYtzr8N3b59W/7+/jpw4ECCMa5evapPPvlEixYt0vLly+Xn5xcr/vTp01WzZk27vQcAKZ8r3fO7Ui7xuXLlimGx2F8GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMeJiorS/v37tX///jh1Hh4eSp06taKjoxUeHs7f/wYAAAAAJImnsxMAAMDR6tevL39/f6v1PXv21K+//mqXvidPnqxChQqpd+/eFusHDhyoJUuW2KVvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIA5eXl5qWfPnurdu7eyZ89u9ThPT0/ly5dP+fLlU926ddWvXz+dPXtWgwcP1ty5c5Pcb5kyZTRs2DD5+/vLzc3N4jHu7u7KnDmzMmfOrCpVqqhXr146ffq0+vTpo2XLliW5z2eyZs2q4cOHq1OnTvL0tPyYnVSpUunll1/Wyy+/rObNm2vkyJGaM2eOvvrqK925cyfZfae0HFetWqUcOXLElM2YMUMbN25MVixXf78AAAAAAAAAAAAAAAAAAMcICwvTjh07tGPHDmen4jCRkZHasmWLtmzZ4pT+jxw5oiNHjrxwfUN6+vSp1q1bp3Xr1jk7FZdTrVq1eOvPnj3roEwAuBofHx8NGjQoTvlXX32l6OjoBNt369ZNmTNnjnn966+/qn///knOY+/everWrZsWLFgQq7xTp04aMWJEkuPZS9asWTV//nx5eHjElK1cuVLNmzdPVrxXX3011uuVK1cm2GblypXq2bNnzOsaNWokqc/PP/88Tr7fffedNm3alKQ4wIvm3+OdlPLHPGtsnTsAAMbx8PDQ0KFD45QPHTpU3333XZLjnTt3To0aNdLevXtj/Z724MGD48xbAJBYRu89SKzF/y2hz5L9B8A8QkNDtWnTJtWrV0+SFB4eLn9/f506dSrJsZ48eaI2bdro6NGjKlq0aEx5gQIFVKdOHW3evNmwvJ/Xr1+/WP1J0sOHD9WkSRMdOnQoSbG2bdumFi1aaP369UqTJk1MefXq1dW1a1dNnjzZkJwBAI7D/jIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuI7IyEiFhoY6Ow0AAAAAgEm5OzsBAAAcyc3NTaNHj7ZaP336dI0fP96uOfTr108nTpywWFe2bFlVq1bNrv0DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMyjSJEiOnDggMaMGaPs2bMnuX3hwoU1Z84cbdq0SdmyZUt0u6+++koHDhxQs2bN5ObmlqQ+ixYtqqVLl2rq1Kny8PBIasqqVauWjh8/rvfee0+enp6Jbufp6anOnTvrxIkTqlOnTpL7TQoz5Ojm5qa5c+cqR44cNscyw/sFAAAAAAAAAAAAAAAAAACAOdWuXTvJbRo2bKg8efLEe8y2bduSmxIAk/v888/10ksvxSrbtGmT1q1bl6j2e/bs0YoVKxQdHa2AgAD16tUr2bksXLhQp06dilVWrFgxZcqUKdkxjeTm5qY5c+bE+t2DK1euqGPHjsmOWbRo0Vivjx8/nmCbY8eOxXpdrFixRPdXpUoVjRgxIlbZli1b9N///jfRMYAX1fPjnaQUP+bFx9a5A4A51KlTRx07doz5r3r16s5OCRY0a9ZMBQoUiFV24MABDRw4MNkxr169qg8//DBWWdGiRdW0adNkxwTwYjNy70FiLZ6cz5L9B8A89u3bp/r166tixYpatGiRfvzxxzjXY1I8efJEgwcPjlNer149W9K0KlWqVOrRo0ec8s8++0yHDh1KVsxt27ZZXN9++umnyYoHwLWw//DiYX8ZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASBk8nZ0AAACO9Nprr6ls2bIW6y5fvqyePXvaPYenT5/q448/1p9//mmx/v3339euXbvsngcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwLWVKFFCW7duVebMmWOVR0ZG6tChQzp06JCio6PVrVs3SdKhQ4d048YNVapUSdmyZYvVpm7dutq7d69q1qypa9euxdvv0KFD1b9//zjlAQEB2rVrl86fP6/AwEBFRUXJz89PBQsWVI0aNZQ9e/ZYx7/33nvy8vJSx44dE/2eGzRooFWrVsnLyytO3enTp3XixAkFBAQoOjpa2bNnV/HixVW8ePFYx2XJkkXr1q1Ts2bNtHHjxkT3nZJylKR+/fqpYcOGNscxy/sFAAAAAAAAAAAAAAAAAACAuXh6emr06NHq1auXhg4dqoEDByaqnbe3t3766ad4j7lz545Onz5tRJoATCZr1qzq3bt3rLLo6Og4ZfHZuXOnWrRooYIFC6px48Z6+PChTTmtW7dOxYoVi1VWsGBB3b9/36a4Rujbt68aNWoU8zoiIkJt27bVgwcPkh0zU6ZMsV7fvn07wTb/PsbLy0ve3t4KCwuLt52fn58WLFigVKlSxZTduXNH//nPfxQVFZWErIEX0/Pj3SeffKLTp0+n6DHPGiPmDgDm0KtXL7Vq1Srm9YwZM7Rz507nJQSL2rZtG6cssXsG8Vm6dKkOHjyo8uXLx5R1795da9assTk2gBeL0XsPrMWT91my/wCYz4EDByyu9ZJj1apVccpKlChhSOx/a9mypbJkyRKr7OjRo5o+fbpNcceNG6cePXoof/78MWXFixdXtWrVtGvXLptiA3Au9h9eLOwvAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACmHp7MTAADAkbp162a17osvvkjwoa9G2bRpkw4dOqRy5cpJkkJCQrRs2TLNmzdP69evd0gOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADX5e3trRUrVihz5swxZU+ePNGYMWM0btw4BQQESJLKlCkT87f4t2zZos8++0ySVKNGDX3zzTdq1KhRTPt8+fJp/fr1Kl++vMLDwy326+/vr/79+8cq27Nnj/r27avNmzdbzdfd3V2vvfaaxo4dqwIFCsSUv/POO1q3bp3mzp2b4HvOmTOnFi9eLC8vr1jlv//+uwYNGqTjx49bbFe8eHENGjRI7dq1iynz8vLS4sWLVbx4cd28eTPBvhPLDDlKUu3atTV48GCb45jl/QIAAAAAAAAAAAAAAAAAAMB8tm3bpqpVq0qSBgwYoCxZsqh3794KCQmx2iZv3ryaN2+eihcvHm/s+fPnG5orAPP45ptvlD59+lhl8+fP18GDB5Mc6/z58xo/frzNOV27di1Oma+vr81xbVWrVi0NGTIkVtnXX3+tPXv22BQ3Xbp0sV6HhYUl2CYiIkJRUVFyd3ePKUufPn2CbWfMmKF8+fLFvI6OjlaHDh34vQUgic6fP69evXoZEstVx7z4GDl3OEKePHlUuHBh+fr6yt3dXQ8fPtT169d16tQpRUZGOju9ZMmWLZsKFiwoPz8/pUuXTpGRkXr48KFu3ryp06dPKyIiwtkpAnCgatWqxXodHBysDRs2GBL7999/V/ny5WNe16pVy5C4RmGMB8zB6L0H1uLJ+yzZfwBebMHBwQoODlaGDBliyjJmzGiXvt577704ZSNHjlR0dLRNcZ88eaIffvhB48aNi9Pfrl27bIptBNamAJA47C87H+M7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjOLp7AQAAHCUXLlyqUmTJhbrjh07pt9//92h+YwbN07+/v6aP3++Vq9erfDwcIf2b6ssWbIob968ypAhg9KnT6+oqCg9fPhQQUFBunTpkoKCgpydYoqSMWNG5c+fP+bzfvLkiYKDgxUQEKCLFy86Oz2HyZ07tzJlyiQ/Pz9lyJBB7u7uevTokR4+fKg7d+7o0qVLNj+A1Qju7u4qWLCgMmXKJF9fX6VJk0ZhYWEKDg7WnTt3dPHiRZfIE86ROXNm5cmTJ+Z6fvagxcDAQF29elX37t1zdoqcw//i5eWlwoULK2PGjMqQIYPc3NxivrPz58/r0aNHzk7RJbA2cD1mXz8wFiXMLGsjMyldunSszzMsLEz37t3TxYsXFRgY6Oz0Ypjx+mCe+IcZ1oJG47t3DLPO+8xltjHjfPA8b29vFSpUyBRzrysw+/ftLNzTO55ZxnazXFNm+TyN4ubmpvz58ytLlixKnz69fHx8FB0draCgIN2/f18PHjzQrVu39PTpU2enapHZ5jazriGNZLZrjPsrY5hlDnCWF/nzyZw5s/LmzStfX1+lT59eERERevjwoe7du6dz58657PxjiVnmJLONw0Yw+3rHEV7UcYhzw7WZZW8/JawXzTKHwb48PT1VuHBhZcmSRRkyZJAk9vSQLGYaU57dj+TOndvU9yIpSUqYV22Vku6THYlzB8mRJk2amH/TfHbP4apzFgAAAAAAAAAAAAAAAAAAAJznyy+/VIECBWJeBwUFqXHjxtqzZ0+i2u/YsUONGzdW586dNXXqVHl4eEiSihcvruHDh+uzzz6L08bNzU1jxoyJVTZ16lR169Ytwd/3jIqK0rJly7R582atX79eVapUiakbOnSo5s6dm2DOEydOlK+vb8zr6Ohode3aVdOmTYu33cmTJ9W+fXutWbNGv/76q9zc3CRJvr6+mjBhglq1apVg34llhhyzZs2qefPmxXzn0dHRMf0llRneLwAAAAAAAAAAAAAAAAAAAMynYcOGqlq1aqyyDz74QP/5z3+0fPly7du3Tzdv3lRYWJi8vb2VPXt21apVSy1atFDq1Knjjf306VONHj3anukDcFEFChRQ9+7dY5U9efJE/fr1c1JG/4iMjHRq/5ZkzZpV8+fPj/ndA0lasWKFxo4da3hfiX0GWVRUlNzd3RMdt1evXmrZsmWssu+//17r169PUn4AjOWKY158XGHuqFKlinr27BnzOigoKNZrSSpSpIg+/fRTtW7dWi+99JLFOI8fP9bmzZs1Z84czZ8/P1HfxfDhw5U7d+445aVLl45T9v333yfqeRoTJ07Ujh07EjyucuXKeu+999S0aVPlyZPH6nFPnz7Vnj179Mcff2j69Ol68OBBgrEBmFfq1KmVP3/+WGW7d+827PlZ27dvj/U6Y8aMKl68uE6ePGlI/H9z1hjvzPFdYoxHyuYK60drXvS1OPsPwIsnPDw85lnYkpQqVSrD+3B3d9err74aq+zx48davny5IfEXLVqkH3/8Mda4VLt2bUNi/xtrU9amAIznCvcH7C8zvgMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMA4ns5OAAAAR2nfvr08PDws1v3www8OzkaaMWOGZsyY4fB+kytr1qxq2bKlWrZsqYoVKyp79uzxHn/lyhXt27dPS5cu1YoVKxQUFGRoPpkzZ1bjxo0t1i1dulShoaGm7s/Hx0fNmjXTG2+8oerVq1t8iNozjx490t69e7VkyRItWLBAd+7cMTQXZypQoIA6dOigmjVrqlKlSvLz84v3+LCwMJ04cUKbN2/W8uXLtWPHDkVFRTkk18qVK+vNN99UvXr1VLJkSaVJk8bqsaGhoTp+/LjWrl2rP/74Q4cOHTIsjxo1aihfvnxxyhM6T0uUKKEKFSqoRIkS8vPzk6+vb6yH527evFnjx4+P1aZ06dIWH+YnSYsXL9aTJ0+S+S4SVqdOHeXMmTNO+cWLF7Vr165421r7jK5du6atW7caluMzOXPmVMuWLdW8eXOVL18+wfHz6tWr2rVrlxYsWKCVK1fa9XN8nqucw/aQnOuiXLlyat++vfz9/VWsWDF5elq+fY6OjtaFCxe0bds2LV68WOvXr1dERITT85eSd10nRVLXBr///rvN6wIzjjuOHHNSwvrBVcYiV73uzLQ2cpbkfHdVqlTRW2+9pUaNGqlYsWJWY1+6dEmbN2/WokWLtHbtWkVHRxuWd2K4yvWRWK52D+ksZlkLGsnVvvuUun9g1nmfucx2rjQf2DrvFilSRO7u7lbjGzH3FipUSJUrV473mGzZslksL1q0qN56660k93n06FEdO3Ysye0sMfv3bcT6mHt62+4tHHFPaqax3ZWuKWvM9Hkawc3NTVWrVlWrVq1Uv359lShRQt7e3vG2CQsL0+7du7V161atWrVK+/btMywfM8xttjDrGtJIZrvGnHV/ZcZ92IS4yhzgrDVVQlzl85Ecu6fu7e2t1157TW3atFHVqlXjHRcjIiJ08uRJrVmzRosXL9b+/fstHpc1a1aVK1cuTvmZM2d06dKlROeWUucks43DRnC19Y5kn/sUW8ciVxqHHMUVzw38H7Ps7bvafrzk+nOYK+8XOnMfydE/S2VJkSJF1L59e7Vs2VKlS5eO9R6eZ889PTP9m5IZz+XknE+uPqbYIrH3I46+F7GFK5+XieGK86qjufJ9suT8f3OxxpnnTt26dZUjR4445U+ePNHixYuTHfff/P39Y93Dh4eHa8mSJYbFf/PNN+Xl5RWnfNu2bbp69WrMa7OPM/9Wrlw5/ec//1GzZs1UtGhRq7/rJDn/3xcAAAAAAAAAAAAAAAAAAADgGrp27Rrr9UcffaQ9e/YkOc6MGTMUGRmpWbNmxZT16NFDY8aM0bVr12IdGx0drW7duunrr7+Wv7+/9u7dq+7duyfpZ1qDg4PVrl07nTp1KuZ3SF9++WVVr15dO3futNqucePGeu2112KVff3115o2bVqi+545c6YyZ86sMWPGxJS1bNlSDRo00MaNGxMdx8w5urm5ae7cuTE/fx4dHa2RI0eqT58+SY5lhvcLAAAAAAAAAAAAAAAAAAAA8xkwYIAGDx5ssc7X11fvvPOO3nnnnWTHnzlzpq5cuZLs9gDMa9iwYXGegTJhwgSHPcfBGkt/U92Zzzxwc3PTnDlzYv3t+ytXrqhjx4526y8x4nvmyL9VqlRJo0aNilW2Y8cODRgwIEm5ATCeq415CXGFuSNfvnzq0KFDzOuAgAD17NlTkuTl5aXvv/9eH3/8cbzPuZCk1KlTq0mTJmrSpIm+/fZbffjhh1q3bl28bZo3b65SpUolKs/mzZsn6riEnguTJ08ejR8/PtHxPD09VaNGDdWoUUNDhgzRDz/8oCFDhjjs+YEAHCtjxoxx1o8BAQGGxb9582acskqVKunkyZOG9fE8Z43xzhjfJcZ4vBhcYf1ozYu+Fmf/AXjxZMyYMdbr4OBgw/soVqyYfHx8YpX9+eefevjwoSHxAwICtGfPHlWrVi2mrFChQvLz81NgYKAhfTzD2jR+rE0BJIcr3B+wvxw/xncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkhaezEwAAwFEaNGhgsfzx48datGiRg7MxjxIlSqhv3776z3/+k+ADwp6XN29e5c2bV2+88YYeP36sX3/9Vd9//71hDz4rWLCg5s6da7EuX758unLliiH9OLq/NHpwswABGRRJREFUTJky6fPPP1fPnj3l6+ubqDY+Pj6qW7eu6tatq5EjR2ry5Mn673//a/iDQh2pbt26+uabb1S7du1EP8hZkry9vVWhQgVVqFBBX375pS5evKixY8dq2rRpCgsLMzxPd3d3tW/fXgMGDFDx4sUT3S5t2rSqVKmSKlWqpIEDB2r37t0aOnSoVq1aZXNOPXv2VPv27eOUWzpPM2TIoE8++UTvvvuu8ufPH2/ckJCQOGW+vr5Wr4snT55o8eLFScg88by8vLRkyZI4D/uVpA4dOmjXrl3xtrf2GS1dulRbt241LM8qVaro66+/VsuWLZN0HufJk0d58uRR27Ztdf/+fQ0bNkw///yzXR5K6IrnsD0k5bqoVKmShg8frvr16ycqtpubmwoWLKiCBQuqc+fOunnzpkaNGqWJEycaNu448rpOjOSuDd544w2b1wVmHHccMeaYff3gimORq113ZlkbuYKkfHfVqlXT6NGjVb169UTFfvnll9WlSxd16dJF58+f18CBAzVv3jxD8rbGFa+PhLjqPaSjmWEtaDRX/e5T4v7B0KFDTTfvM5fZxlXnA3vOu5Ixc2+9evU0adKkJLV5pmHDhmrYsGGS27377rs6duxYsvqUUsb3nSFDBh0+fNiQ9TH39JYl9t7CnvekZhnbXfWa+jezfJ5G8fT01DvvvKO+ffuqcOHCSWrr7e0ds7YZNGiQtm7dquHDh2vt2rU252WGuS05zL53ZASzXWPOvr8y4z6sJa44ByRnbfDtt9/GGzO5e46u+PlIjtlTT58+vb744gt99tlnypAhQ6LapEqVSmXKlFGZMmXUp08fbdu2Tf3799e2bdtiHVetWjUtW7YsTvs+ffpo5MiRic4xpc1JZhuHjeCq6x3JPvcpyRmLXHUcsjdXPjdgnr19Z68X4+Pqc5gr7xc6cx/JUT9LZUnRokU1bNgwvf7664m67uy5p2emf1My47mcnPPJ1ceU5Ejq/Yij70Vs4crnZXxceV51FDPcJ0vO/zeXf3OFc+fVV1/V4MGDLdYVLFhQFy5cSHLMf0uXLp3++OMPeXl5xSrPkyePrl27ZnP8ggULWvxdnujoaOXJkydWmVnHmX975ZVX9P3336tx48aJbuOsf18AAAAAAAAAAAAAAAAAAACA68ibN2+sn7G9ffu2TT9TOnv2bHXu3Fn16tXTnj17NHr0aN24ccPisdu2bdO2bdtUpkwZubm5KSoqKsn9Xb58WatXr1br1q1jyipXrqydO3dabfPBBx/Een3kyBGNGjUqyX2PHTtWb731lipUqBBT1r17d23cuDHJscyYY79+/WL9PPXo0aO1fPly9enTJ8mxzPB+AQAAAAAAAAAAAAAAAAAAYD6+vr5yd3e3S+wTJ07ok08+sUtsAK6tQoUKatu2bayy4ODgBJ8N6AhVqlSJUxYQEOCETP7Rt29fNWrUKOZ1RESE2rZta9jzSx89ehTrtbe3d4JtUqVKFWdusPZsAV9fXy1cuFCpUqWKKbt3757atWunyMjIZGQMwEiuNubFx5XnDkny8/PTmjVrVLVq1SS3zZ8/v9auXavhw4erX79+dsjOuhMnTlitq1SpktauXatMmTIlK3batGnVv39/tWjRQk2aNLH6e5IAzCtt2rRxyh4+fGhY/ODg4DhlWbNmNSx+YplxjI9vfJcY4/FicPX144u2Fmf/AXixlShRItb1KUlnz541vJ+KFSvGKTt48KChfRw6dEjVqlWLVVa+fHlt2rTJ0H6sYW0aF2tTAInh6vcHZhzfJfaXAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4FzuCR8CAID5eXp66tVXX7VYt2HDBkMfLJ5SpE2bVuPGjdOxY8fUoUMHeXh4JDtW6tSp9cEHH+js2bP69ttv4zygE/9o06aNzpw5o/79+8vX1zdZMby9vdWrVy+dOHFCjRo1MjhD+8uUKZNmzpypTZs2qU6dOnJzc7MpXv78+fXzzz/r1KlThn8eZcqU0aFDhzR37lwVL17cplhVq1bVypUrtWLFCmXPnt2gDOPXqFEjnThxQt9++63y58+frBjbt2/XqVOnLNa9++67tqQXr5YtWypjxoxxyh88eKDFixfbrd/EypIli+bPn6/du3erVatWNp3HmTJl0ujRo3Xy5ElVqFDBwCzNfw4bzdPTU8OHD9fu3btVv379ZMfJkSOHxo4dq2PHjqlGjRoGZpgwI67r+Bi1NrBlXcC4E5fZ1w9mH4vsfd2ZaW1kJu7u7ho+fLh27Nih6tWrJytGwYIF9dtvv2n9+vXKli2bwRn+w2zXB/eQ/zDLWtBIfPeO1aZNG1PN+8xltjPbfPBvRsy7kmPmXqMcP3482W3N/n1L/7dGtsf62Bru6R3LTGO7Ga4pM32eRilXrpwOHz6s6dOnq3DhwjbHq1WrltasWaOFCxcqbdq0BmQYP7PNbWbfO7KV2a4xV7m/Sgn7sGaYA+Lz/NrAHsz++diiadOmOnfunAYNGqQMGTIkO86rr76qLVu26KeffnLa/oUZ5iSzjcNGMft65xl73qe8qONQSjk3UiKz7O27ynrRVmaYw4xky36hJWbaR0rI559/rsOHD6t169bJvu6cuaf3ojH6XDaKmcYUI+5HXOFexJXYcl6mlHnVVinpPvkZs/wcpWT7ubNo0SKrdS1btkx2Xs9r2LChvLy84pQ3a9bMkPjW8ty9e7euX79uSB+2MHr+69evn/bt26fGjRsnO4ZZ1sEAAAAAAAAAAAAAAAAAAAAwVs6cOWO9Pn78uKKiomyK+dFHH6l69eqqWrWqFi9enGC8o0eP6siRI8nu799t//2envfSSy+pefPmscoGDBig6OjoZPXdv3//WK9btmypLFmyJCvWM2bIsXbt2ho8eHDM6127dqlv377JimWG9wsAAAAAAAAAAAAAAAAAAABz6tevnzZu3Gh43Lt376p169YKDQ01PDYA1zdy5Mg4z0MZPny47t2756SM/vHyyy+rdu3ascru3Lmjq1evOiWfWrVqaciQIbHK+vTpoz179hjWx/3792O9TszfWP/3MU+ePLE6nv/66696+eWXY15HR0erY8eOLvH37oEXnauNeQlx1blDklKlSqXVq1eratWqscojIiJ0+PBhrVy5UkuWLNFff/2lS5cuWY3Tt29fjR492s7Z/p8bN24oKCjIYl3+/Pn1559/KlOmTHHq7t+/r/Xr12vq1KkaN26cfvnlF82ZM0e7d+/WkydP4hxfunRpbd++3eJzkQGYW2RkZJyyNGnSGBbf29s7TpmlccmezDjGxze+S4zxeHG48vrxRVyLs/8AvNg6d+4cp8we//ZUunTpOGV///23oX0cPXo0TlnJkiUN7cMa1qasTQEknyvfH5hxfJfYXwYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDzuTs7AQAAHKFSpUry8fGxWGePh0OaXYkSJfT333/r448/jvMAM1t4enpqwIAB2r9/v/LmzWtYXLNzc3PTpEmTtHDhQmXOnNmQmDly5NDq1av14YcfGhLPEYoUKaIDBw6oY8eOhsfOmzev1q1bp++//96QeB9++KH27dunMmXKGBLvmebNm+vvv/9WlSpVDI37b2+99ZZWr16tXLly2RxrypQpFssbNWqkHDly2Bzfki5dulgsnzNnjh4/fmyXPhOrTp06OnnypNq1a2do3AIFCmjnzp1W33tSmf0cNpq3t7dWrVqlr7/+Wu7uxtwmFyhQQFu3blWvXr0MiZcQI69rS+yxNkjuuoBx5x8pYf1g9rHI3tedmdZGZpIqVSotX75cX3/9tSHjWcOGDbV3714VLlzYgOz+j9muD+4h/2GWtaCR+O4d5/m53wiOmPeZy2xntvng34yedyX7zb1GOnnyZLLamf37luy/RraEe3rHMtPYboZrykyfp1G6d++uvXv3qmTJkobHbtOmjfbs2aN8+fIZHvsZM81tKWHvyFZmu8Zc7f7KzPuwZpgD4mPvtYHZPx9bDBs2TKtWrVK2bNkMiefm5qZPPvlEK1asUJo0aQyJmVhmmJPMNg4bxezrnWfsORa9qONQSjk3UiKz7O272noxucwwhxktufuFlphpHyk+Hh4emjFjhsaMGWPYOsrRe3ovIiPPZaOYaUwx8n7Emfciria552VKmVdtlZLuk58x489RSsk/d06ePKkTJ05YrGvVqpUhubVo0cJi+WuvvWZI/Ndff91iuVE/G2Ero+Y/T09PzZkzR999951SpUplSExXXwcDAAAAAAAAAAAAAAAAAADAWJ6enrFeh4eH2xzz1KlT2rVrl81xEisoKCjWa29vb6vHNmzYMNZ7vn//vtasWZPsvjds2KDbt2/HvE6VKpUaNGiQ7HhmyDFr1qyaN2+ePDw8YvJr27atIiMjkxXP1d8vAAAAAAAAAAAAAAAAAAAAzCsiIkItW7Y0NOaRI0dUoUIFnT592tC4AMyhUaNGqlevXqyy69ev68cff3ROQs8ZO3ZsnGcwr1692im5ZMmSJdbvHkjS8uXL9cMPPxjaz5kzZ2K9TsxzvEqVKhXr9dmzZy0e9/HHH8f5m/djxoxx2mcKIDZXGvMS4spzhyQNHTpU1apVi3l9/vx5vffee8qcObPKlSun1157TW+88Ybq1q2r/Pnzq1ChQho1apTCwsLixPriiy/01ltvWeynXbt2qlChQpz/JkyYkOhjn/+vfv36Vt/T5MmTlT59+lhlZ86cUatWrZQtWzY1btxYXbt2Va9evdSzZ0+98847qlatmjJnzqwPPvhAt27ditU2f/78mjp1aryfIwDzCQ4OjlOWNWtWw+Jben5XpkyZDIufGI4Y4x05vkuM8XgxuPr68UVci7P/ALy4KlasGOeZ1leuXLHp76JYkzFjxjhl586dM7QPS/Es9WsPrE1ZmwJIHle/P2B/mfEdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyeOe8CEAAJhf6dKlrdbt2LHDgZm4vho1amj79u0qUKCA3fooU6aMdu/erTJlytitD7Nwd3fXggUL1K1bN8Nje3h4aPz48XrvvfcMj220XLlyafPmzXr55Zft2s9XX32lyZMn2xRj4MCBGj9+vLy8vAzKKrYsWbJo06ZNqlu3rl3iN2jQQLNnz5aHh4ch8WbOnKknT57EKffw8NA777xjSB/Py549uxo1amSxztbv1lZt27bVunXrlCVLFrvE9/Ly0rRp0/Tuu+/aFMfs57DRPD09tXr1aqvnlS3c3d31448/6ptvvjE89vOMvq7/zd5rg6SuCxh3Usb6wexjkb2vOzOtjcxm0aJFatasmaEx8+XLpz///FM5cuQwJJ7Zrg/uIf9hlrWgkfjuHcdec789533mMtuZbT6wxB7zrmT83Gukq1ev6uHDh0lulxK+b3uvkS3hnt6xzDS2m+GaMtPnaZQvv/xSEydOlKenp936KFWqlFasWCFvb2+7xDfL3JYS9o5sZbZrzBXvr8y6D2uGOSA+9l4bmP3zscUvv/yivn37ys3NzfDYjRs31sKFCw2PGx9Xn5PMNg4bJSWsdyT7jkUv6jiUUs6NlMgse/uuuF5MLlefw4yW3P1CS8y0j5SQqVOnqlOnTobHddSe3ovIyHPZSGYZU+x1P+KMexFXktzzMiXNq7ZIaffJkvl/jlJK3rmzaNEii+U1atRQ5syZbcrHzc1N/v7+Fuvq169v8/1HlixZVL16dYt1v//+u02xjWDk/DdlyhS9/fbbhsR6nquugwEAAAAAAAAAAAAAAAAAAGC8wMDAWK9feukl5yRig0yZMsV6HRISYvXYSpUqxXq9atUqRUZGJrvvqKgoLV++PFZZxYoVkx1Pcu0c3dzcNHfu3JifNY6OjlbHjh117dq1ZOfnyu8XAAAAAAAAAAAAAAAAAAAA5hcaGqoPP/xQd+/etSnOw4cPNXz4cFWrVk1XrlwxKDsAZvP999/HKRs4cKDCw8OdkM3/+eqrr/T666/HKZ8wYYLDc3n2uwc5c+aMKbt8+bJdnimzdevWWK+bN2+eYJt/P49k+/btcY6pUKGCRo8eHats9+7d6tu3bzKyBGA0VxrzEsNV5w5J8vPz02effRbzesqUKSpZsqSmT59u9bka58+f11dffaWSJUvq2LFjcerHjRsX53f+JOnEiRM6ePBgnP8s/W7asWPHLB77/H+nTp2ymF/RokXVoEGDWGX79+9XxYoVtWzZsnh/dy0kJESTJk1SiRIltHv37lh1rVu3jvO7cADM7cGDB3r06FGssrJlyxoW31KsNGnSGBY/IY4a4x01vkuM8XhxuPL68UVdi7P/ALyYmjZtqnXr1snLyytW+VdffWXT30WxxtfXN05ZUFCQoX0EBwfHKfPz8zO0D0tYm8bG2hRAUrjy/QH7y7ExvgMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACApPJ2dAAAAjlCkSBGL5dHR0Tp+/LiDs3FdJUuW1Jo1a5Q+ffp4j7t48aJWrlypnTt36ubNm7pz5448PDyULVs25ciRQ7Vr11azZs2UI0cOqzFy5MihDRs2qFKlSrpy5YrRb8U0Ro8erTZt2iR43OHDh7VmzRodOHBAt27d0r179+Tu7i5fX18VKlRIVatWVcuWLZUzZ844bSdOnBjvwzFdwbx58yzm/kxAQIAWLVqkP//8U8eOHdPt27cVEhKi6OhopUmTRn5+fipUqJDKly+vZs2aqUGDBnJ3d7cYq2vXrjp8+LDGjx+f5Dx79OihIUOGxHvM5cuX9ccff2jt2rU6c+aMbt++rUePHildunTKkiWLihQpovr16+v1119X4cKFLcZImzatlixZosqVK+vs2bNJztOa7Nmza/78+VY/m+S4d++eli5dqrZt28ap69Kli0aOHGlYX5LUoUMHeXh4xCnfs2ePxYcTOkqjRo3022+/WczteefOndOaNWu0a9cuBQQE6O7du4qIiFD69OmVM2dOVaxYUa1atVKpUqUstndzc9OUKVN06dIlbdq0Kcl5mv0ctodx48apTp06FutOnDihlStXav/+/bp8+bIePnwoDw8PZcmSRTly5FCNGjXk7++v/Pnzx9vH4MGDdfHiRc2ePdvw/O1xXT/PyLXB+++/b7V9UtYFjDvmXz+YfSyy93UnmWdtZDZff/21WrZsabHu8uXLWrp0qebNm6fg4GClSpVKWbJkUZ48edSgQQM1bdpUmTNntho7T548WrhwoWrVqqXo6Ohk52i264N7yH+YZS1oJL57x0rM3O9q8z5zmW3MNh9Ykph5d/fu3bp48aJd596HDx/q0qVL8eaaI0cOpU6d2mLbe/fuxdv237Zv356k46WU8X07Yo1sCff0jmWWsd0s15RZPk+jvPbaawnu2ezZsydmfjhz5owePHigsLAweXp6KlOmTDHXbvPmzdW0aVOrcUqXLq3JkyfrnXfeMfQ9uMrclhhm3zsygpmuMVe9vzLjPqxZ5gBr7L02MPvnY4sBAwaoR48eCR536NAhrVixQn///bdu3bqlu3fvytPTU9myZVP27NlVrVo1tWjRQnny5InT9rXXXtOXX36pM2fO2OMtxGKGOclM47BRUsJ6R7LvWPSijkMp5dxIicyyt++q68XkcIU5zAz7hZaYbR8pPr169VLnzp0t1plhT89VmPVcNpIrjCmJkdT7kY0bN7rsvUhCzHBepqR51RYp7T5ZMtfPURp97ixcuFCDBg2KU+7h4aHmzZtr5syZCb9BKypXrqxs2bJZrEuTJo3q16+vlStXJjt+8+bNLX5ne/bs0dWrV+OUm2GcsaRHjx5W1z+uNGcBAAAAAAAAAAAAAAAAAADAtV27dk3R0dFyc3OTJJUpU0ZZsmTR3bt3nZxZ4lWoUCHW69OnT1s9tmLFirFeHzhwwOb+Dx48GG8fSeXKOfbr108NGzaMeT169GitWrXKptxc+f0CAAAAAAAAAAAAAAAAAAAgZZg4caLmzJmj9u3b6+2331a1atUs/s3hf3v8+LF2796ttWvXauLEiQoMDLR/sgBc1ltvvaWyZcvGKjt+/LhNf7fdVm5ubho8eLAGDhwYp27+/Pnas2ePw3Pq27evGjVqFPM6IiJCbdu2tcsYumTJEv30009KkyaNJKlWrVqqWbOm1b8Hnz17dnXp0iVW2Zw5c2K9zpAhgxYuXCgvL6+YsgcPHqhdu3Z6+vSpwe8AQFK44piXEFecO573bPyUpGnTpqlbt26Jbnvx4kVVr15de/bsUfHixWPKM2fOrL59+6p3796G5ppY/v7+ccq6deumhw8fJjrG/fv31axZMx09elS5cuXSsWPHNGrUKB0+fNjATAG4gqNHj6patWoxr/PmzauSJUvq+PHjNsd+7bXXbI5hC8Z4yxjj4epcdf34oq/F2X8AXgzu7u7Kmzevqlevrs6dO8f6+yrPTJkyRQsWLLBL/76+vnHKkrLOSQxL8Sz1azTWppaxNgWQEFe9P3iG8d0yxncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkhqezEwAAwBEKFy5ssfzKlSsKCwtzcDauKXPmzFq1apXSp09v9ZiDBw+qT58+2rhxY7yxnj1E9/XXX9fw4cNVtGhRi8dly5ZNq1atUpUqVRQaGpr85E2qTZs2+uyzz+I9Zvny5erfv7+OHTtm9ZidO3dq1qxZ+uijj/TGG29o6NChsT5zT09PzZw5U97e3oblbqS2bdvq1VdftVgXHh6u/v376+eff1ZERITVYwICAhQQEKDt27dr3LhxKlCggIYNG6Z27dpZbPPDDz9o3bp1On/+fKLzrFGjhn788Uer9QEBARo0aJCmTZumyMjIOPUhISEKCQnRpUuXtH79en399ddq166dvv/+e+XNmzfO8X5+fvrjjz9UtmxZwx42PXLkSGXOnDlOeXR0tA4dOqSVK1dqz549CggI0N27d2P1G981OnnyZLVt2zZOebFixVS5cmXt3bvXkPwlxXlo9/M5OEvhwoW1cOFCeXh4WD1m+/bt6tOnj3bu3BlvrGXLlmngwIGqW7euxo0bp1KlSsU5xt3dXbNmzVLp0qX14MGDROeZEs5ho9WvX18ffvhhnPKNGzdq0KBBCX5f8+bNkyQ1aNBAw4cPV8WKFa0eO2nSJB08eFDHjx+3Lel/sdd1LRm/Nli9erVh64IXedwx+/ohJYxF9rzuJPOsjcymePHi+vbbb+OUHzt2TP369dOKFSustp05c6bSpEmjTz/9VP3791e6dOksHlezZk11795dEydOTFaOZrs+uIf8h1nWgkbiu3eshOZ+V5z3mctsY7b5wBJb5l3J2Ll33rx5Mfdu1mzbtk01a9a0mMfHH38cb1tbpYTvW7K8RjZqfWwN9/SOnQ/NMrab5Zoyy+dplOzZs2vWrFlyc3OzWL9z50599tlnVvdznj59qtu3b+v27ds6cuSIxo8fr3LlymnKlCmqUKGCxTYdOnTQ1KlTtWXLFkPegyvNbQkx+96REcx0jbn6/ZWZ9mHNMgfEx9ra4ODBgzavC1LC55NcjRo10uDBg+M9ZtmyZfrqq6905syZeI+bO3euevbsqcaNG+uHH35Q8eLFY9UPGTJEvXv3tjnn+JhhTjLTOGyUlLDeeSa59ykJjUUv6jiUks6NlMYse/uuvl5MCleZw1x9v9AaM+0jxSd//vxq1KhRnHIz7em5CrOey0ZxlTElIUbdj7jCvUhiuPp5mZLmVVuktPvkZ8z0c5SSsefOiRMndOLECZUoUSJOXatWrTRz5sx428enRYsW8da/9tprWrlyZbLjv/766xbLFy1aZLHc1ccZS3Lnzq0RI0bEKXe1OQsAAAAAAAAAAAAAAAAAAACuLzAwUMeOHVPp0qUl/fN3H4YOHaoPPvjAyZklTpEiRWL9blFkZKTWrFlj9fhChQrFeh3f38hIrL///jvePpLKVXOsXbt2rN8d2Llzp/r27Wtzbq76fgEAAAAAAAAAAAAAAAAAAJCyhISEaOrUqZo6dapSp06tYsWKqWDBgsqcObN8fHzk5eWlp0+f6v79+7p3755u376tw4cP6/Hjx85OHYALSJUqlb777rs45X369FFUVJQTMvrnZ+UnT56sunXrxqk7e/asPvroI4fnVKtWLQ0ZMiRWWe/evQ19PuXz7t69q2nTpsV6rwsXLtRrr72mAwcOxDo2b968+uOPP2L9XfZdu3Zp+/btsY6bPn26ChQoEKusc+fOunLlih3eAYDEcsUxLyGuOHdYc/78efXo0SPJ7R4+fKg33nhDhw8flpeXV0z5+++/r2+++UZhYWFGppko+fLli/X67t27OnToUJLj3L9/X126dJG7u7vWrVtnVHoAXMzatWtVrVq1WGV9+/ZVhw4dbIpbunRp+fv72xTDKIzxcTHGw1W56vqRtTj7D0BKMn/+fDVu3DhOuYeHh9KlSyc3NzerbcePH6+ePXvaLTdLz5M0+nm1ISEhccrie56q0VibxsXaFIA1rnp/YAnje1yM7wAAAAAAAAAAAAAAAAAAAAAA/D/27js6iurv4/gnCSGQEDqEpoD0XhVQelN6D0WkKMWOUkSwI4oNRP0JCogoAkICUgWUItIUkd57kd5LIEDK8wfHPC67m2yZLbN5v87JOcy9M997d8ptZDMAAAAAAAAAAAAAAAAAAAAAAAAA0hLs6woAAHwjPLtUtqFUp6fU9AWp0TNSra5SkWpShoxpHm46RYoUsZl+4sQJ71bEj40dO9bqJVr/SkpK0iuvvKJq1app2bJlDsf86aefVK5cOX344Yd29ylfvrzeffddp+trdpGRkfriiy/s5l+7dk2tWrVSmzZttGPHDodiJicnKzY2VpUqVdK4ceMs8ooVK6aoqCi36uwpL730ks30uLg41a9fX2PGjNGdO3ecinno0CF16dJFPXv2VEJCglV+xowZ9cYbbzgcL0OGDPrmm28UGhpqM3/Dhg2qUqWKJkyYoMTERIdiJicn68cff1TVqlW1atUqm/uUK1dOgwcPdrieqalUqZK6d+9ulb58+XJVq1ZN1apV01tvvaWff/5ZmzZt0rFjx3Ty5MmUn8uXL9uNvXz5ch06dMhm3pNPPmlI/SWpevXqKlu2rFX6tWvX9OOPPxpWjrO++eYbZcuWzWbe7du31bt3b9WpU0fr1q1zOObKlSv14IMPavr06TbzCxYsqOHDhzscLxDuYU+4t3+6ffu2+vTpoyZNmjh1vZYtW6YHH3xQQ4YMsfuyz8yZM2v8+PFu1fdennyuJePHBkaOC9Jru2P28UMgtEWefu4kc4yNzOj9999XhgwZLNI++ugjValSRQsWLEjz+Pj4eH3wwQeqU6eOzp49a3e/t956y+IlyY4y4/PBHPIuM4wFjca1957U+n5/7vfpy1xnxv7AFnf7Xcnzfa8/CJTrbW+MbNT42B7m9JcNrU9azNC2m+mZMsP5NNLbb7+t7Nmz28wbNWqUateurQ0bNjgVc/Pmzapbt66WLFlid5+hQ4c6FTM1ZunbzL52ZBQzPWP+Pr8yyzqsmfoAe9IaG7gzLgiE8+OqTJkyaeLEiQoOtv0rkjdu3FDr1q3Vtm1b7du3z+G4S5cuVYUKFTR69GiL9MyZM3t8zcYMfZKZ2mGjBMJ4R3JvnpJaW5Se26FAuTcCkVnW9v19vOgMM/Rh/sps60ipqVSpksLDw1O2zbamB/9hhjbFE/MRX85FAkEg9auuCsR5smS+36OUjL93YmNjbaY3bdpUmTJlcrhe92rZsqVb+anJnDmzmjRpYjNv9uzZLsf1N9WrV1dkZKRFmr/1WQAAAAAAAAAAAAAAAAAAADCPb7/91mK7f//++uCDD6y+Z+Fv8uTJozlz5lh81/T777/XmTNn7B5z7/czT5486XY9Tp06ZbFt73uGjvLHOubJk0czZsxQSEiIJOnChQvq3Lmzw9/hTY0/fl4AAAAAAAAAAAAAAAAAAAAEtlu3bmnr1q2aM2eOJk6cqLFjx+qjjz7SmDFjNGXKFC1YsEB//vmnbt265euqAvATzz77rIoUKWKRtmrVKi1atMjrdcmTJ48+/fRT7dq1Sw0aNLDKP3LkiB577DFdvHjRq/XKnTu3xXcPJGnevHn67LPPPFru0KFDtX///pTt/Pnza8OGDVq1apXGjRunzz//XIsWLdK+fftUtWrVlP2uX7+unj17WsR69tln1aFDB4u0sWPHav78+RZpuXPnVr9+/RQTE6N169Zp165dWrdunWbNmqW+ffsqd+7cHvikQPrkr22eI/yp70jLm2++qdu3b7t07O7du63eEZw9e3Y1bdrUiKo57d7vkl2/ft3lWL/++quWLl3qbpUQQKpWrarFixc79PPwww9bHNukSROHjy1VqpSPPmH6M2PGDKt3Fnbr1s3u+48cERoaqq+++sru+7y8jTbeNtp4+CN/Gz8yFrfE+gMQGCIiIpQ9e3arn8jISAUFBdk85vjx42rVqpWee+45JScne6xutsq3935tV9mKZ+9zewJjU9sYm+JerD9A8r/5QWpo322jfQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBq/OPNpwAAr8ldWGr7hvTcDKnlK1KtrlLlFlK1NlKdnlL0e9LzM6W6vaWwLL6urXGyZs1qM/3MmTNerol/atiwobp3724z79atW2rbtq0+/vhjl2InJibq1VdfVY8ePZSYmGhznwEDBqhKlSouxTert956S1FRUTbzTp06pZo1a2rhwoUuxb5165aee+45vfvuu+5U0Sty586tmjVr2swbNGiQ/vzzT7fif//993rqqaes0k+dOqUdO3Y4HOfFF1+0+/LFtWvXqm7dujp9+rRLdbxw4YKaNm2qv//+22b+G2+8oZw5c7oU+79efPFFixfIJiQkqE+fPmrcuLE2b97sdvyJEyfaTO/SpYvCwsLcji9JvXv3tpk+ffp03bhxw5AynNWzZ0/VqVPHZt6VK1fUqFEjTZkyxaXY8fHx6t69u2bMmGEz/5lnnlFkZKRDsQLhHvaEPHnypPz7zp07at26tb755huX433yySdq3bq13Zdr1qlTR9HR0S7Hv5cnn2tPjQ2MHBekx3bH7OOHQGiLPN2fmmVsZEZVq1a12H7++ec1dOhQJSQkOBVny5Ytaty4sd22Pl++fOrQoYPT9TPb88Ec8i6zjAWNxLX3Lnt9vz/3+/Rl7jFbf2CPUf2u5Lm+1x8EyvW2N0Y2YnycGub03mOWtt0sz5RZzqeRcubMqeTkZKv0UaNGafjw4TbzHHHjxg116dJF//zzj838Zs2aqWzZsi7FvpdZ+jazrx0ZwUzPmFnmV2ZYhzVLH5Ca1MYGRsQ2+/lx1auvvqr777/fZt6VK1fUpEkTLViwwKXYiYmJGjx4sN544w2L9AIFCrgUz1H+3ieZqR02UiCMdyTPzVPSczsUKPdGoDHL2r5ZxouO8vc+zJ+ZaR3JGWZc04P/MEOb4qn5iK/mImYXaP2qqwJxniyZ8/coJWPvnVmzZtlMDw8PV5MmTVyq33333aeKFSumuk+BAgVUuXJll+I3adJEmTNntkrfuHGjjhw54lJMM/DHPgsAAAAAAAAAAAAAAAAAAADm8fXXX+vgwYMWaUOHDtWePXs0aNAglS5d2kc1sy1r1qx6+umntWPHDpUrVy4lfffu3Xr55ZftHhcWFqaMGTNapF27ds3t+twbI0uWLAoOdu11Pf5Yx6CgIE2bNk358+eXJCUnJ6tHjx52v4/qDH/8vAAAAAAAAAAAAAAAAAAAAAAA/FdkZKTV38uXpCFDhni1HtmyZdN7772nw4cP66WXXlJoaKjVPuvXr1eNGjV06NAhr9bt3+8e/Pc9AkeOHFGvXr08XnZcXJyaNWtm8ZmDg4NVt25dPfPMM3rhhRfUvHlzi3dkXrt2TW3bttX+/ftT0ipXrqwxY8ZYxN64caNeeeWVlO2goCANHz5chw8f1tdff62OHTuqVq1aKlOmjGrVqqVOnTppwoQJOnz4sF599VWL9x0AcI4/t3mO8Je+wxFXrlxRbGysWzHGjx9vlfboo4+6FdNVV65csdjOnz+/Ye9JBnLnzq3HHnvMoZ+8efNaHFuwYEGHj82WLZuPPmH6s3//fs2ePdsiLSgoSLGxsXrooYecjhcaGqrvv/9eDz/8sFFVdAttPGAe/jR+ZCxuG+sPQPpVsGBBdenSRVFRUb6uiqkxNgUcx/oD/Gl+kBbadwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMA1wb6uAADAeyo+JvX8n1TyESm195BmzCzV7Cz1+lLKU9R79fOkiIgIm+lXr171ck3808iRI+3mPffcc1qwYIHbZUydOtXmy9EkKSQkRG+//bbbZZhFlixZ1K9fP5t5CQkJio6O1q5du9wu580331RMTIzbcTypSpUqNl+MfPnyZX377beGlPH9999r1qxZkqSdO3eqV69eKly4sD755BOHjg8NDbV48fN/nT59Wh07dtStW7fcquPt27fVoUMHm21SeHi4+vbt61Z8SWrcuHHKv+Pj4/XYY4/pm2++cTvuv7799lslJCRYpWfLlk1t27Z1O37GjBnVtWtXm3kTJkxwO74rgoKC7LZrktSrVy+tWbPGrTKSk5P15JNPaufOnSlpt2/f1jfffKOqVavq2rVracYIlHvY01566SUtXbrU7TiLFi3SoEGD7Obbuxau8ORz7emxgRHjgvTW7ph9/BAobZGn+1MzjI0CwSeffKIvv/zS5eO3b9+ut956y27+448/7lQ8Mz4fzCHNMxY0Gtfee1Lr+/2536cvc50Z+wNHuNvvSsb3vf4gkK63p8fIjmBO71lmaNvN9EyZ4XwaLTo6WhUqVNCMGTOUlJQkSVq9erVee+01t2NfuXJFgwcPtpvfrFkzt8u4l7/2bWZfOzKKmZ4xs8yv/H0d1kx9QGo8NTYIlPPjivDwcA0YMMBufq9evbRu3Tq3yxk5cqRmzpzpdhxX+GOfZKZ22EiBMt7xRFuUntshKXDujUBiprV9s4wXXeGPfZg/M9M6kjPMuKYH/+SPbYo35iO+nIuYUSD3q44K5HmymX+PUjLm3tm5c6d2795tM8/VNbxWrVpZpR09etQqrWXLli7Fb9eunc10f15/dpc/9lkAAAAAAAAAAAAAAAAAAAAwlxs3bqhdu3a6ePGiRXqxYsX0ySefaPfu3bpy5YqmT5+eklewYEHdd999HqnPgw8+qMWLF1v8LFmyRL/99pt2796tS5cuafz48cqbN2/KMQcOHFCzZs105coVu3EjIyOt0uLi4tyur63v92XNmtWlWP5Yx+HDh6tJkyYp2x9//LF+/vlnt+sk+efnBQAAAAAAAAAAAAAAAAAAAADgv4YOHapcuXJZpMXExOivv/7ySvkREREaPny4jhw5ouHDhysiIsJqn9u3b2v48OGqXbu2zp4965V6/dewYcPUtGnTlO07d+4oOjpaly9f9kr5Bw8eVI0aNTRlypSUd3rZs2LFCtWsWVPLly9PSYuMjFRMTIzCwsJS0q5cuaJOnTrpzp07ku6+Ny02NlbvvfeesmTJkmoZWbJk0ahRozRz5kxlyJDBjU8GeF/9+vXVtGlTl35q1arldvlmaPMc4eu+wxmrV6/W7du33Yrx119/6ebNmxZpVapUcSumqw4fPmyxHRYWpj59+vikLgDMYdCgQVbfS82aNatWr16tF1980eHxXMmSJfX777+rS5cukqSEhISUsaSv0MYD5uEP40fG4mlj/QEwjjvrD0atQTgqODhYjz/+uHbs2KH69et7rdxAw9gUABznD/MDR9G+AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK4J9nUFAADeUbW19NhLUkio48dki5K6fSLlut9j1fIaWy/JlaT4+Hgv18T/1KpVy+4LOqdOnapvvvnGsLJGjRqlxYsX28xr1aqVSpUqZVhZ/qxXr16KjIy0mff2229rzZo1hpX19NNP6+LFi4bFM1r+/Pltpu/cudPtF9T915AhQ/TYY4+pfPny+u6771Je5OyIjh07Kioqymbeyy+/rNOnTxtSx6NHj2r8+PE285555hlDyvjXyy+/bPHSayOcOXNGCxcutJn35JNPuh2/devWypEjh1X65s2btWnTJrfju6J169YqVqyYzbwvv/xSc+fONaSc+Ph4PfPMM7p+/bpGjx6tokWLqk+fPtq3b59DxwfiPWy033//XePGjTMs3v/+9z+7179atWqqWbOmYWX9y8jn2ltjA3fHBemt3TH7+CEQ2yJP9KdmGBuZ3fbt2/Xqq6+6HefTTz/VpUuXbOY1aNBAoaGOT77N9nwwh7zLLGNBI3HtvSu1vt+f+336MteZrT9whFH9rmRs3+sPAvF6S54ZI6eFOb3nmaFtN9MzZYbz6Qk7d+5Ut27dVLp0aU2ZMkUvvviikpOTDYk9e/ZsnTlzxmZe3bp1DSnjX/7ct5l97cgoZnnGzDS/8vd1WDP1AY4ycmwQiOfHUd27d1f27Nlt5n377beGrd1I0rPPPmu3L/IUf+2TzNIOe0KgjHf+ZVRblJ7boX8F2r1hdmZZ2zfTeNFZ/tqHmYW/ryM5KhDW9OAf/LVN8dZ8xBdzETMK5H7VGYE+T/6XGX+PUjLm3omNjbV7fFBQkNN1atWqlVXaN998oy1btliktW7d2unYwcHBatmypc08e5/D7Py1zwIAAAAAAAAAAAAAAAAAAID5bN++XQ899JDd7+NnzZpV5cqVS9nu1KmTjh07puvXr2vNmjUaM2aM6tev79LvGd8rT548euyxxyx+Hn30UdWrV0+lS5dWcLDlq3C+/PJLVahQQUePHk017r3HSVJiYqLb9bUVw1ZZjvC3OtarV0/vvPNOyva6des0fPhwt+uTWh387ZoAAAAAAAAAAAAAAAAAAAAAANKvqKgovfTSSxZpd+7c0bBhwzxedsaMGTVgwAAdOnRI7733nt33Avz0008qW7asRo0apaSkJI/X615169bViBEjLNIGDx6sv/76y6v1OH/+vHr37q3ixYtrwIAB+uGHH/Trr79q5cqV+vHHH/XWW2+pWrVqatSokXbt2mVx7KRJk1S8eHGLtCeffFJHjhxJ2f7kk0/Uvn17i322b9+usWPH6o033tBnn31mFbdTp04aNWqUsR8U8LAZM2Zo6dKlLv248+4os7R5jvBl3+GKrVu3uh0jMTHR6r0jvnqfzi+//GKV9umnn+qVV15ReHi4D2oEwN8dP35cffr0sXofbMaMGfXZZ5/p4MGDeu2111SzZk1FRkam5IeEhKhQoULq0qWLZs6cqd27d1u82/C9997TlStXvPY5bKGNB8zB1+NHxuLOYf0BMIY76w/urEF069ZNuXLlsvrJmzevihcvrjp16mjQoEFau3at1bG5c+fWkiVL1KBBA3c/frrE2BQAHOPr+YGzaN8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1wT7ugIAAM8rVE5q2N+1Y8MipPZvSyGhRtbI++y9ACohIcHLNfE//fr1s5mekJCg1157zfDyXn31VZvpQUFBeuqppwwvzx917tzZZvrVq1f12WefGVrWxYsXNXLkSENjGilTpkw2069cuWJoOceOHdPSpUtdOrZXr1420/fv369Zs2a5UStrY8eOtdkuFS5cWOXLlzekjAULFuirr74yJNa9JkyYYDO9cePGKliwoFuxe/fu7VSZ3mCvTrdu3dI777xjaFmrV69Wvnz5NHjwYJ08edKpYwPtHvaEwYMHGx4ztXugS5cuhpZl9HPtzbGBu+OC9NTumH38EGhtkaf6UzOMjcxuwIABSkxMdDvOrVu3NHXqVJt54eHhKleunMOxzPZ8MIe8yyxjQSNx7b0rtb7fSEb3+/RlrjNbf+AIo/pdydi+1x8E4vX25JpTapjTe54Z2nYzPVNmOJ+etH//fvXu3VtbtmwxLGZCQoLmz59vM6927dqGlSP5d99m9rUjo5jlGTPb/Mqf12HN1Ac4wuixQaCdH2f06NHDZvrt27ftPhOuunjxoj788ENDY6bFX/sks7TDnmT28Y5kbFuUntuhewXCvREIzLK2b7bxojP8tQ8zAzOsIznK7Gt68B/+2qZ4az7ii7mIGQVyv+qMQJ8nS+b+PUrJ/XvH3hwrT548evjhh52qS3h4uBo0aGCVvmDBAi1YsMAirXr16oqKinIq/sMPP6zcuXNbpW/evFmHDh1yKpZZ+GufBQAAAAAAAAAAAAAAAAAAAHM6ePCgqlWrpm7dumnVqlVKTk5O85iIiAg98sgjevnll7Vy5UodPXpUTz31lIKCgrxQ47s6duzId308IE+ePJoxY4ZCQkIkSRcuXFDnzp0N+x1mAAAAAAAAAAAAAAAAAAAAAAD83euvv66IiAiLtAkTJujgwYMeLbdHjx46ePCgxo4dq7x589rcZ9WqVapdu7bat2/v8frYkzt3bovvHkjS3Llz9fnnn/ukPpJ0+PBhff7553riiSfUtGlTNWzYUF27dtWIESO0adMmq/379++v6Ohoi7Qvv/xSc+bMSdl++OGH9eKLL1rs8/zzz6tixYp6+eWXNXLkSL300ksqV66c1ftzBg0apOrVqxv4CYHAY5Y2z1G+6jtcdfjwYUPinD592mI7R44cFv2Dt+zevVs///yzRVpoaKg+/PBDnTt3TosXL9YHH3ygJ598UnXr1lWBAgW8XkeY159//qlHHnnEoZ/Vq1dbHLt48WKHj921a5ePPmH6NWvWLD3//PNKSkqyyrv//vs1cuRIrV+/XlevXtWtW7d09epVJSQk6Pjx45oxY4aio6MVHByccsyMGTP0zjvvKDQ01CKWt7+jSxtPGw9z8OX4kbG461h/AMzp2rVrunjxotXPuXPndPDgQa1Zs0ZjxoxR7dq1VaNGDauxeVhYmGJiYjwyzrD1d36MHnPZiufI3xcygifHpr7A2BSexPpD+sb68l2sPQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACDQBae9CwDA7Br0k4LdeB9TjgJS1VbG1cefeOtliv4qKChIzZs3t5kXExOj48ePG17mtm3btGzZMpt5LVu2NLw8fxMZGamaNWvazJs0aZKuX79ueJnffPON4uLiDI9rhPj4eJvpOXPm9HJNbAsLC1PdunVt5o0bN05JSUmGlnf69GmbL6aWpGbNmhlSxogRIwyJY8uSJUtsthvBwcF64oknXI4bFRWlRx991Cr9xo0bmj59ustx3REaGqpGjRrZzJs+fbrOnTtneJmuPMeBeA8b7a+//tJff/1leNwtW7Zo1apVNvNs3c/uMPK59vbYwN1xQXppd8w+fgjEtshT/am/j43MbtOmTVq5cqVh8RYsWGA3r0KFCg7FMNvzwRzyLrOMBY3EtfeutPp+oxnZ79OXucZs/YEjjO53JWP6Xn8QiNdb8uyakz3M6b3D39t2sz1T/n4+zWrDhg0203PmzKnIyEhDyvDnvs3sa0dGMsMzZsb5lb+uw5qtD3CEkWODQDw/jsqaNavddnHmzJk6e/as4WVOmTLFbhtkNH/uk8zQDpuVN8Y7/zKqLUrP7ZA3efPeMDuzrO2bcbzoKH/uw8zADOtIjgiENT34B39tU7w9H/HmXMSMArlfdUagz5P/Zebfo5Tcv3d27NihPXv22Mxr27atU3Vp0qSJwsLCLNL++ecfbdmyRfPmzbNIT+1c2dOuXTub6bNmzXIqjln4a58FAAAAAAAAAAAAAAAAAAAA85sxY4bq16+vfPnyqU2bNnr//fe1cOFC/fPPP2kee99992nSpElauXKlcuTI4VL558+f17Jly6x+1qxZoz179igxMdFi/6ioKH377beaPHmygoN5TY4RgoKCNG3aNOXPn1/S3XcuPPHEEw7dAwAAAAAAAAAAAAAAAAAAAAAABIJ8+fKpb9++Fmk3btzQu+++67EyixUrpnXr1um7775ToUKFbO7zxx9/qFGjRqpfv77Wrl3rsbqk5d/vHhQoUCAl7fDhw+rVq5fP6uSsSpUqaezYsRZpmzdv1sCBAy3ShgwZYrE9fvx4ffnllzZjjh49WlOmTEnZDgoK0uDBgw2pLxBozNTmOcoXfYe7rl69akicy5cvW6VFREQYEttZ/fv316lTp6zSw8PD9dhjj2no0KH65ptvtGrVKp04cUI3btzQ9u3b9dNPP+n9999Xhw4dXP5+JALblStXtG7dOod+Lly4YHHsmTNnHD7WE++NR9rGjRun1q1bp/nerYwZM9p9p2tycrI++ugjde/eXcnJycqSJYtFvrffvUUbTxsP/+er8SNjce9i/QEwpw0bNqh69epas2aNRXquXLn08ccfG17etWvXrNKMHnPdOz6VjBszpsWTY1NfYWwKT2H9If3y5zGtPaw90L4DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADANcG+rgAAwLPylZTyl3I/TtU27seA/6lWrZry5s1rM+/bb7/1WLn2YpcpU0ZFihTxWLn+oG7dusqQIYPNvFmzZnmkzKtXr2rJkiUeie2uc+fO2UyvXLmyMmfO7OXaWKtdu7YyZcpkM89T59Tei7wrV67sduw///xTGzdudDuOPcnJyZo8ebLNvCeffNLluN27d1dISIhV+qxZs7z2Utx7PfzwwzZf0itJ33//vZdrY1+g3cOe4Km2V5JmzpxpM7106dIqUKCAIWUY/Vz7YmzgzrggvbQ7Zh8/BFpb5Mn+1N/HRmY3bdo0Q+P9/fffdvMKFSrkUAyzPR/MIe8yy1jQSFx77/J2329kv09f5hqz9QeOMLrflYzpe/1BIF5vT6852cOc3jv8vW032zPl7+fTrHbu3Gk3L2fOnIaU4c99m9nXjoxkhmfMjPMrf12HNVsfkBajxwaBdn6cUb9+fZv3liR98803Hinz0qVLmj9/vkdi38uf+yQztMNm5Y3xjmRsW5Se2yFv8ta9EQjMsrZvxvGio/y5D/N3ZllHcoTZ1/TgP/y1TfH2fMSbcxEzCuR+1RmBPk+WAuP3KFOL7ei9ExMTYzO9TRvnvgzUunVrq7R/r6ettrJVq1ZOxbdXn9jYWKfimIW/9lkAAAAAAAAAAAAAAAAAAAAIHGfPntX8+fP12muvqVWrVmrRokVK3m+//aZRo0Zp0aJFunDhgtWx9erV02+//Wb3O6Gp2bBhg5o0aWL1U6dOHZUpU0ZZs2ZV586dtXnzZovjevfurU8//dSpsoKCgpyunydieDq+szGGDx+uJk2apGx/9NFHWrx4sdv1cIQZrgkAAAAAAAAAAAAAAAAAAAAAIPANGjRIYWFhFmn/+9//dObMGY+U16xZM/3999+qVauWzfxNmzapefPmqlWrllasWOGROjhj2LBhatq0acr27du3FR0drStXrviwVo7LkiWLYmJiLL77cu3aNXXq1Em3b99OSQsPD1fLli0tjv3ggw9SjX1vftu2bRUaGmpArYHAYbY2z1He7juM8N82zx03btywSnPl+4VG+Oeff1S3bl1t377dof0zZ86s8uXLq23btho2bJhiY2N1+vRpxcbGqkyZMh6uLQB/smjRIpUuXVpjxozR9evXnTr2t99+U82aNTV06FAlJSUpLCzM6v1ecXFxRlY3TbTxtPHwf74YPzIW9y7WHwBzu3nzplq3bm31t3W6dOli+Lsdba2rRkZGGlqGrXjeWs/15NjUVxibAjCav45pU8PaA+07AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXBPs6woAADzrgQeNiZMtSspR0JhY8B9Vq1a1mZ6UlKT169d7rNy1a9fazatcubLHyvUHZcuWtZl++/Ztbd682WPlLlu2zGOx3XHgwAGb6ZkyZdKgQYO8XBtrFStWtJl+4sQJ7dmzxyNl2nuBnREvpfvxxx/djpGWSZMmKSkpySq9RIkSdl9onpbevXvbTJ8wYYJL8YxQqVIlm+kJCQnasGGDl2tjX6Ddw56wcuVKj8VOrS816nwY/Vz7Ymzg7rggPbQ7Zh8/BFpb5Mn+1N/HRma3dOlSQ+NdunRJJ06csJkXFRXlUAyzPR/MIe8yy1jQSFx77/JF329Uv09f5hqz9QeOMLrflYzpe/1BIF5vb6w52cKc3jv8vW032zPl7+fTrC5dumQ3L2fOnIaU4c99m9nXjoxkhmfMrPMrf1yHNVsfkBajxwaBdn6cUb58eZvpd+7c0Z9//umxctesWeOx2P/lz32SGdphs/LGeEcyti1Kz+2QN3nr3ggEZlnbN+t40RH+3If5O7OsIznC7Gt68B/+2qb4Yj7irbmIGQVyv+qMQJ8nS4Hxe5SS+/fOrFmzbKaXKFFCpUuXdrgeLVq0sEqbP3++3f2bNm2qjBkzOhS7bNmyKlasmFX61q1b7a4rmJ2/9lkAAAAAAAAAAAAAAAAAAABIH7Zs2aLhw4erZcuWyps3r5o2barVq1db7FOxYkWNHj3a8LJv3LihWbNm6cEHH9SYMWMs8l588UU1btzY5nG3bt2ySgsLC3O7PpkyZbJKi4+PdymWP9SxXr16euedd1K2165dq9dee83tOtjiD58XAAAAAAAAAAAAAAAAAAAAAIB7hYeHq0+fPhZpt27dsvoeg5HmzZunbNmyWaXv2LFD7du3V7Vq1bR48WKPle+MunXrasSIERZpgwcP1saNG31UI+dNmDBBJUqUsEjr06ePDh48aJFWo0YNZciQIWV79+7dOnbsWKqx9+7dq6NHj6Zsh4WFqXr16gbUGvC8ChUqKCoqyqWfRo0aOVRGixYtTNXmOcoXfYcRkpOT/SqOUQ4cOKBq1arp2Wefdem9JRkzZlSHDh20fft2vfTSS8ZXEIDfunTpkgYNGqSCBQuqW7dumjp1qrZu3aorV66kvIf9xo0bOnr0qJYsWaJhw4apbNmyatCggcX7S7Nnz24V+8yZM976GJJo4+2hjYe/8MX4kbG497H+ANjmzvqDM2sQRrh06ZI++ugji7Tg4GB17NjR0HKuXLlilWarvXaHrXiXL182tAx7GJvaxtgUwL/8eUybGtp322jfAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkJZgX1cAAOBZue4zLlbOQsbF8rbExESb6SEhIV6uiX8pV66czfRt27bp+vXrHiv36NGjOnnypM28smXLeqxcf1C6dGmb6Zs3b9bt27c9Vu7GjRs9Ftsd+/fv15EjR2zmvfPOO3rhhRe8W6F72LteO3fu9FiZFy9etJleuHBht2P/+eefbsdIyz///KOlS5fazOvdu7fT8apVq2azrdq1a5fWr1/vdDyjlClTxmb6tm3bdOPGDS/Xxr5Au4eNlpiYqK1bt3os/vbt2+3eD6VKlTKkDKOfa1+MDdwdF6SHdsfs44dAa4s82Z/6+9jIzG7duqVdu3YZHtfevZY5c2aHjjfb88Ec8i6zjAWNxLX3Ll/0/Ub1+/RlrjFbf5AWT/W7kvt9rz8ItOsteWfN6V7M6b3H39t2sz1T/n4+zerKlSt287Jly+Z2fH/v28y+dmQkMzxjZp1f+eM6rNn6gLQYPTYItPPjDHtrN5s3b1Z8fLzHyvXG+M7f+yQztMNm5enxzr+MvI/TczvkTd66NwKBWdb2zTpeTIu/92H+zizrSGkJhDU9+Ad/blN8MR8JlDbCEwK1X3VWIM+TPVWWWe+dHTt2aO/evTbz2rZt61AdHnzwQUVFRVmkXb9+XStXrrR7TEREhOrVq+dQfHv1iImJceh4s/HnPgsAAAAAAAAAAAAAAAAAAADpT1JSkn799VfVrVtXo0ePtsjr27evChXyzEsIEhMTNWjQIE2bNs0ifeTIkTb3v3r1qpKTky3SsmTJ4nY9IiMjLbYTEhJc/n6hr+uYJ08ezZgxI+UdCxcuXFDnzp3tvovBXb7+vAAAAAAAAAAAAAAAAAAAAAAA2NKtWzdlz57dIm369Ok6c+aMR8orV66cQkNDLdIuXbqkvn37qmLFivrpp588Uq4rcufObfHdA0latWqV5syZowIFCrj0c6/s2bNb7ZM/f37DPkOfPn3UtWtXi7Svv/5as2bNstq3RIkSFtuO/o34e/crXry4k7UEfOP8+fM6e/asSz/23nXwX+XKlVNsbKxp2jxneLvvMEpYWJghcTJmzGiV5qnvpTnqzp07Gj9+vEqUKKGKFSuqf//++vrrr7VixQodO3ZMSUlJacYICQnRp59+qiFDhnihxgD8ydWrVzVjxgz16NFDlStXVvbs2RUSEqLg4GBFRESoSJEiatasmT744APt3r3b6vh7x5GSdOrUKW9UPQVtfOpo4+Frvlh7YCzuXaw/APa5s/7g6BqEkebMmWOVVqNGDUPLsPWZSpYsaWgZtuJ561x6cmzqa4xNARjBX8e0aWHtIXW07wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAn2NcVAAB4Vng2A2NlNy6Wt8XHx9tM98eXE3qTvRdW7tmzx+Nl2yvD6Jdo+psiRYrYTD948KBHy/V0fHdMnTrVZnpwcLA+//xz7dixQwMGDFCpUqUUFBTk1boVK1bMZvrx48c9VualS5dspkdGRroV986dO9q0aZNbMRw1YcIEm+mdO3dW5syZnYrVu3dvp8rwFnv3xr59+7xck9QF0j3sCcePH1dCQoLH4icmJurYsWM284oWLep2fE88174aG7g7Lgj0dsfs44dAaou80Z/689jIzA4cOKDk5GTD4165csVmuqNzTbM9H8wh7zLLWNBIXHvv8kXfb2Rs+jLnma0/SIun+l3J/b7XHwTa9fbmmtN/Maf3Ln9u2834TPnz+TSDXLly6aGHHlLXrl312muv6dtvv1VsbKzd/YOD3f+1GH/v28y+dmQ0f3/GzDy/8rd1WDP2AfZ4YmwQSOfHWYULF7aZ7um1m927d3s0vuT/fZLk/+2wGfhivCMZ3xal53bIU3x1bwQKs6ztm3m8mBoz9GH+ymzrSKkx+5oe/Ic/tym+mI94Yy5iVoHarzorkOfJUmD9HmVqZTh678TExNhMb9u2rUPHt27d2ipt6dKlun37dsr2jRs3HDrOmXqkNrcxM3/uswAAAAAAAAAAAAAAAAAAAJC+DR48WOvXr0/ZDg0NVadOnTxa5qBBgyy+X1SjRg2b3/tJTk7W9evXLdKyZXP/ZQv3xrD3O7mO8GUdg4KCNG3aNOXPnz+lLk888YROnDjhdvn2mOGaAAAAAAAAAAAAAAAAAAAAAADSnx49eliljRs3ziNlhYSEaMaMGRZp+/fvV/Xq1TVp0iSP/U1yV40aNUoFChSwSKtXr57++ecfnThxwqWfew0ZMsRqn3Xr1hlS/woVKuiLL76wSNu2bZsGDBhgc/8cOXJYbF+4cMGhcs6fP59qHCA9+re9y5Qpk0W6P7d5zvBm32EkI77PJUnZs2e3Srt27ZohsY2wfft2TZgwQU8//bQaNWqkwoULK3PmzCpdurRatGihAQMG6KuvvtLWrVttHv/BBx+oUqVKXq41AH/kaF9VpkwZq7S9e/caXZ1U0cbTxsO/+WLtgbG497D+AASWAwcOWL07+941UnfZGqtUqFDB0DIqVqxolbZt2zZDy7DHk2NTf8LYFICr/HFM6wjWHmjfAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4JoMvq4AAMCzEu4YGOu2cbG8LT4+XhEREVbp975oN72x93LGS5cuebxse2UY9WIyfxUZGWkz/fLlyx4t99KlS4qPj/fLe/7jjz/Ws88+q1y5ctnML1eunMaOHStJiouL0549e3TgwAEdPHhQ+/fv14EDB3TgwAGdPn3a8LplzZrVZnqGDBn08MMPG16eJJUqVcpmemhoqDJmzKjbt11rjI8fP65bt265UzWHLViwQKdPn1a+fPks0rNmzap27dpp+vTpDsXJmDGjunbtapV+69YtTZ061ZC6uspeW+WN9tMZgXQPe8LJkyc9Xoa9e8Jef+AMTzzXvhobuDsuCPR2x+zjh0Bqi7zRn/rz2MjMzp8/75G4cXFxbh1vtueDOWTqZfrbWNBIXHvv8kXfb+S6AX2Z88zWH6TFU/2u5H7f6w8C7Xp7c83pv5jTe5c/t+1mfKb8+Xz6g5CQEBUuXFgPPPCAihUrlvLz77YRz6Cz/L1vM/vakdH8/Rkz8/zK39ZhzdgH2OOJsUEgnR9nZcmSxWb6xYsXPVrutWvXlJiYqJCQEI+V4e99kuT/7bA/8MfxjmR8W5Se2yFX+eu9ESjMsrZv5vFiaszQh/krs60jpcbsa3rwH/7cpvhiPuKNuYhZBWq/6qxAnidLgfV7lKmV4ei9M2vWLL3++utW6Q899JDy5cuX5ny7ZcuWVmnz58+32P7111/Vpk0bi7RWrVrphRdeSDV2/vz5Vb16dav0HTt2aO/evakea1b+3GcBAAAAAAAAAAAAAAAAAAAAn332mWrVqpWyXa9ePX366aceK+/MmTNav3696tSpk5L20EMP6fDhw1b7njt3zuI7QSVLltTmzZvdKr9kyZIW2+7+vq+v6jh8+HA1adIkZXv58uW6deuWGjZs6HA5FSpUsNguUKCA1fFbt27VhQsXUrbNcE0AAAAAAAAAAAAAAAAAAAAAAOlH/vz5Vbt2bYu0vXv3auPGjR4pr2fPnha/j3/+/Hk1btxYx44d80h57rL3N/c97dChQ27HiIiIUExMjMW7Uq9fv65OnTrZfTfBve9luHnzpkNl3bhxI9U4QHp0b3sn+X+b5yhv9x1Gsvd+UGflzJnTYvv27dt+/47H27dva+/evVbvNqlataq+/fZbVaxYMSUtODhYr732mqKjo71dTQAmValSJYvthIQE7d6926t1oI2njYf/8vXag8RY3JNYfwAC08WLF5U3b96U7axZsxoa31a7Zesdne6oVq2axXZSUpLbf+PFUZ4cm/o7xqYA0uKPY1pHsfZA+w4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADXZPB1BQAAnnXjsoGxLhkXy9uuXLli84VXuXPn9kFt/EdkZKTN9EuXPH+x7ZVhr06BIiIiwma6N855XFycxcuO/cW1a9cUHR2tJUuWKDQ0NNV9IyIiVK1aNauXo0p3P9/Bgwd14MAB7dq1S3///bc2bNigkydPulw3e9erZ8+e6tmzp8txXZUhQwaXX7B3+fJlYyuTisTERE2ZMkWvvvqqVd6TTz6p6dOnOxSnVatWVi8ZlKQ5c+bo4sWLbtfTHfZe4u2NZ9kZgXQPe0JcXJzHy7D37BnxInhPPNe+Ghu4Oy4I9HbH7OOHQGqLvNGf+vPYyMw81eYnJye7dbzZng/mkHeZZSxoJK69d/mq7zdq3YC+zHlm6w/S4sm5lrt9rz8ItOvtzTWn/2JO713+3Lab8Zny5/PpbaVLl1b16tVVrVo1lS9fXg888IDuv/9+ZcjgX7/K4u99m9nXjozm78+YmedX/rYOa8Y+wB5PjA0C6fw4y5drN5cvX7b5uylG8fc+SfL/dtjbzDLekYxvi9JzO+QIM90bgcIsa/tmHi+mxgx9mL8y2zpSasy+pgf/4c9tiq/6G0/PRcwqUPtVZwXyPPnfMoxm5ntn+/bt2rdvn0qWLGmRHhQUpFatWmnixIl2jy1UqJAqV65skZaUlKRFixZZpM2bN09t2rSxSCtcuLDKli2rXbt22Y3funVrBQUFWaXHxMTYPcbs/LnPAgAAAAAAAAAAAAAAAAAAANavX2+xXahQIY+XefDgQdWpUydlO1++fDb327Jlix544IGU7QoVKmjmzJlulV2+fHmrMtzhqzq+8847FtuNGzdW48aN3Sq3adOmatq0qUVazZo1deHCBYu6+Ps1AQAAAAAAAAAAAAAAAAAAAACkH02bNrX62+dz5871WHlDhw612B48eLCOHTvmsfLM6vDhw27H+Oqrr1SqVCmLtP79+2vfvn0Ox3D0b7nzN98Ba/e2d1LgtHne7juMdO/7RFxVsWJFi+0DBw4YEtcXNm3apPr162v79u0qWLBgSnqzZs2UIUMGJSQk+LB2AMyiZcuWFttbt27VzZs3vVoH2nhrtPHwF75ee5AYi3sS6w9AYMqQIYPF9p07dwyNv2/fPl29elVZs2ZNSatfv75y5MhhyPtO77//flWrVs0ibe/evbp+/brbsR3B2NQaY1MA//LHMa2jaN+t0b4DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAEcG+rgAAwLNO7DQmTlKidHq/MbF84dSpUzbTo6KivFwT/xIeHm4z/dq1ax4v++rVqzbTIyIiPF62L/nynN+4ccPjZbhqxYoV6tq1q+Li4lyOERERoYoVK6p9+/Z6/fXX9dNPP+nEiRNat26dnn76aYWFhTkd0971MqMrV654tbyJEyfafPF1w4YNdd999zkUo1evXjbTv/76a3eqZgh794a9ts1XAuke9oSbN296vAx77bsR/Z0nnmtf9VNGjAsCud0x+/ghkNoib/Wn/jo2MrPbt2/7ugo2me35YA55l1nGgkbi2nuXr863kesG9GXOMVt/kBZ/7Xf9RaBdb2+vOf2LOb33+WvbbtZnyl/Ppzfkz59f77zzjvbu3avdu3dr6tSpeumll9S4cWM98MADypAhg6+raMXf+zazrx15gj8/Y2afX/nTOqxZ+wBbvLnenx6EhobaTPdGm3X9+nWPxvf3Pulf/twOe4MZxzuS8W1Rem6H7DHrvREozLK2b/bxoj1m6cP8kRnXkewx+5oe/Ic/tym+mo94ei5iVoHarzorkOfJUmD9HqVkzL0TExNjM71du3apHteyZUurtPXr1+vChQsWaQsXLrS5RmjreEfKt1ffQODPfRYAAAAAAAAAAAAAAAAAAABw/vx5i+0cOXJ4vMx7v39s7zvDf/31l8V2/fr13S67QYMGFtsbN250K56v6hgSEuJ2OY44dOiQxbYZrgkAAAAAAAAAAAAAAAAAAHDd2LFjtXv3brs/7du393UV072SJUumeo1++eUXr/2uKQD4gzp16lilrVmzxiNlVapUSSVLlkzZPnbsmKZOneqRsoxy+vRpHThwwNCfe128eNFqn82bN7tV7969e6t79+4WaZMnT9b06dOdihMcHGzofkB6cW97J5mjzXOUN/sOo9WqVcvtGEWLFlXevHkt0nbt2uV2XF+6dOmS/ve//1mkZcmSRQ888ICPagTATKpUqaLChQtbpP3yyy9erwdtvG208fAHvlx7kBiLexLrD0Bgypgxo3LmzGmRdubMGcPLWbFihcV2hgwZDPu/1Ojo6DTL8yTGprYxNgUg+d+Y1hm077bRvgMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAtvIkOAALcwb+kpET34/yzQ7oV534cXzl16pTN9CJFini3In4mKCjIZnpSUpLHy/ZGGWaSnJzs8TISEw1oDDxo9uzZevDBB/Xnn38aGrdWrVoaP3689u7dq44dOxoa20yuXbvm1fIOHTpk86W1QUFB6tGjR5rHR0VF6bHHHrNK379/v1atWmVIHT3BG88yjGP2/s4Tz7WvxgZGxE+P7Q7jB+/zZn/K2Aj+iDlk6gJ5LMi19w+evseM7vfpy4D0wdtrTv8yex/kq/PmLtp2Y6W385k5c2a99957OnDggN58802VLFnS11UKeOl97chfnzGzz6/S4zqsN5h1bABrgbw+5Cx/bYc9yezjHdoizzH7vRHo/K3tNvt4EcYLpPaZ+xjwHH/rz/wF/arveePeDKTfozSqjFmzZtlMb9iwobJkyWL3uFatWlmlzZs3zyrt3LlzNuf7to7/V5YsWdSgQQOr9N27d2v37t12jwMAAAAAAAAAAAAAAAAAAABgqVGjRqpXr54hscLCwiy24+PjDYmbmhw5clhsX7582eZ+f/zxh8X2ww8/rAIFCrhcbt68ea3O271lOMsMdXRVXFyczp07l2pdAunzAgAAAAAAAAAAAAAAAACQ3tWuXVsvvviiSpcubfNHsv23auFd+/bt0+bNm+1epyZNmujFF1/0dTUBwGsqV65slWb0O9P+1aRJE4vt2NhYv38nwQsvvKASJUoY+nOv0aNHW+3z5ZdfulzncuXKWR2/c+dOPf/882kee+97CzJnzuxQmeHh4anGAdKbe9s7yRxtnqO82XcYrXDhwqpVq5ZbMR5//HGrtOXLlzt0rK13WN/7HUVf2bRpk1Va7ty5fVATAGbz0ksvWaXFxMR4vR6+bOP9uX2XaOPhe75ce5AYi3sK6w9A4Kpdu7ZV2qlTpwwvZ9KkSVZpr776qjJkyOBW3PDwcA0cONCh8jyFsal9jE0B+NOY1lmsL9tH+w4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDUBPu6AgAAz4q7KG1b4n6cddPdj+FLBw8etJmePXt25cmTx8u1AWDP7t27VbNmTbVs2VJLlizRnTt3DItduHBhxcTEaPTo0QoKCjIsrln44mXiEyZMsJneu3fvNI99/PHHbb5Md+LEiW7XCwgUvniu/R3tDjzN288dYyMAgNnRlwGBj7mpa8x83mjbjZVezmfBggW1Zs0aDR8+XOHh4S7HuXr1qv7++2/9+OOPevfdd/XEE0+oZs2aKlWqlIG1RSBJL8+Yt7EOazwzjw38UXJyss304GDP/6pkxowZPV6GmaSndjgQxju0RZ4RCPcGAN+ifQbMxVfzEeYiSE2gz5PpK61t27ZN+/fvt0oPCwvTo48+avOYzJkzq2HDhlbp8+fPt7n/vHnzrNJq1aqlnDlz2ty/WbNmNu+HmJgYm/sDAAAAAAAAAAAAAAAAAAAAsFS7dm2tWrVKy5Yt06effmrI92tLlChhsX3q1Cm3Y6alQoUKFttnzpyxud+qVat07NixlO2goCA9//zzLpf73HPPWfwe/ZEjR7RmzRqX4/myjsWKFXP7p3PnzhYx58yZY5FftmxZv/m8AAAAAAAAAAAAAAAAAADAszJkyKCvvvoq1d9Pffnll5WYmOjFWsGeV155RTdu3LCbP2LECBUsWNCLNQIA3ylevLjF9okTJ3Tu3DmPlFWlShWL7VWrVnmknPQsPDxcMTExypw5c0rajRs31KlTJ928eTPN4y9evGixHRUV5VC59+536dIlh44DAtW97Z0UWG2eN/sOT3jllVdcPjY8PFzPPfecRVpSUpIWLVrk0PG22sf8+fO7XB9JKl++vGbPnq2ePXu6FcfWe1Ltva8HuNeFCxf0zz//pPwwFvB/4eHh6tGjh7788ku34lSoUEHdu3e3SNu4caM2b97sVlxX+aqN90T7LtHGI3D4cu1BYizuCaw/AP7lgQce0KeffqosWbIYEu/pp5+2SvNEW7p48WKdOHHCIq148eJ64YUX3Io7bNgwq7HY33//rS1btrgV11mMTW1jbAp3sP4QGPxlTOsq1pdto30HAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAajL4ugIAAM9b/b30wINS1ryuHb9zuXRsq7F18rZt27bZzatcubJ+/fVXL9bGfyQmJtpMDw0N9XjZ9sqwVydfCwoKMiSOL895xowZPV6GURYtWqRFixYpR44caty4sapWraqqVauqZMmSuv/++xUcHOxy7IEDByosLEzPP/98mvsmJSXZTF+7dq12797tch1clZCQ4PUy3fHTTz/p/Pnzyp07t0V6sWLFVLt2ba1Zs8busb1797ZKu3Pnjr777jvD6+kKe/dGhgz+NcXiHk5dSEiIx8uw1/b6a3/nq37KqHFBoLY7Zh8/0Ba5z1/GRjCe2Z4P5pB3mWUsaCSuveOMWD/w1fn25LoBfVnqzNYfwD1cb2Mwp/c9f2nbA+WZ8pfz6Ql58uTR+vXrdd999zm0/40bN7R///6Un71796b8+9y5czaPyZkzp5FVNh2zrx15gz89Y4Ewv/KXddhA6QM8JT2fn7i4OJvp2bNn93jZ3ijDjPypHfYExju2ped26F/cG/7FLGv7gTBeBOxhTc+SUb+TCv/iq/kIcxHb6FfvYp7svEC4d2JiYjR8+HCr9LZt22r27NlW6Y0bN1amTJks0g4cOKC9e/fajL9gwQKNGjXKIi0kJETNmjXTtGnTrPZv166d3XoCAAAAAAAAAAAAAAAAAAAASF1oaKhiY2MVFRUlSapSpYpefvlljRkzxq24Xbt2tdjesmWL3X2zZcumfv36ady4cXZ/Tz0t1apVU4UKFVK2k5OTtXHjRpv7Jicn69tvv9Vbb72Vkvbyyy/r66+/1tGjR50qt1ChQho8eLBF2qRJk5yK4U91PHTokPOVvUe+fPkstq9evZpmXDNcEwAAAAAAAAAAAAAAAAAA4LxnnnlG5cqVs5v/+++/a8mSJYaUFRoaqtKlS6t8+fIqWLCgsmXLpsjISEnStWvXdPnyZZ08eVJbt27V3r17/fJvzPvaP//8o88//1yvvvqqzfwsWbLoo48+0uOPP+7lmgGAd4WHhytbtmwWaWfOnPFYeUWKFLHYtvc33OG6cePGqUyZMhZpzz77rMPvO7t3v/9+hyU19+63a9cuh44DAtW97Z0UOG2et/sOT2jbtq169eqlKVOmOH3sV199ZfW9soULF+r48eMOHf/PP/9YpdWrV08///yz03UpVaqURo4cqQ4dOigoKEh16tTRsmXLdOLECadj/RvvXqdPn3YpFtKfPn36+LoKcFCpUqU0dOhQderUSVmyZJEkrVy5UrGxsU7HypYtm6ZPn271PuUPP/zQkLq6wldtvJHtu0Qbj8Di67UHibG4J7D+APiHsmXLavjw4erSpYtCQkIUERGhfv36uRWzXbt26tSpk0VaQkKCFi1a5FZcW5KSkjRmzBiNHj3aIv2DDz7Q1q1btWLFCqdjtmnTRsOGDbNK/+STT1yup6sYm9qPdy/GpnAU6w/m509jWlexvmw/3r1o3wEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPCvDL6uAADA825ekWa/JXX5UMqc1bljj++Qloz1SLW8atu2bXbz6tatq19//dWLtfEf165ds5meI0cOj5dtrwx7dfK1zJkzGxLn+vXrNtOzZ89uSPzUREREeLwMo126dEkxMTGKiYlJSQsNDVXRokVVvHhxFS9eXCVKlFCxYsVUvHhxFS1aVBkypD3Efe6557R+/XpNmzYt1f3i4+Ntps+ePVuffvqpcx8mHbpz546+//57DRw40Cqvd+/eWrNmjc3jqlatqvLly1ulz58/X2fPnjW8nq6wd29441l2Bvdw6jJlyuTxMuzdE/b6A1/z1djAqHFBoLY7Zh8/0BYZx9djIxjPbM8Hc8i7zDIWNBLX3nFGrB/4qu/3xroBfZltZusP4B6utzGY0/sPX7ftgfZM+fp8Gi04OFixsbG677777O5z4sQJzZ8/X8uXL9emTZt05MgRJScnO1VOUFCQu1U1NbOvHXmTPzxjgTC/8pd12EDrA4yWns+PvXbR089ZaGiowsPDPVqG2flDO2w0xjv2ped2SOLe8EdmWdsPhPEiYA9repaM+p1U+BdfzEeYi9hHv3oX82TnBcK9M2vWLA0fPtwqvWXLlgoJCVFiYqJFeuvWra32nT9/vt34O3fu1OHDh1W0aFGL9FatWlnNzzNkyKDmzZtbxdi3b5927NiR6ucAAAAAAAAAAAAAAAAAAAAAcPc7/h9//LE++eSTlLSPPvpIhw4d0ty5c12KWaNGDT333HMWaXPmzLHaL3fu3Bo4cKCee+45Zc2aVcWLF1f//v2dLi8yMlLffPONRdrGjRt14sQJu8eMHz9eAwYMSPnOUKZMmTR//nzVqVNHV69edbjc+fPnW/x++6VLlzRhwgS7x4SFhSkkJMQi7caNG35VR19Jb58XAAAAAAAAAAAAAAAAAIBAFxERoddffz3VfUaMGOFWGTlz5lR0dLTatWun+vXrK2PGjA4dd/PmTf3yyy+aNWuWfvrpJ928edPlOhQpUkRTp051aN+ffvpJY8aMcbms1HTo0EEvvfSSQ/s2bNhQd+7csZn3ySef6IUXXrD7DrmuXbvqgw8+0Pbt212tKgD4vcjISKu0S5cueay8rFmzWmy78u5FdxUtWlQrVqywSu/bt6+WLVvm9foYqWfPnurZs6dF2vfff6/vvvvO4Rh//fWX4uPjU96PU7RoUZUtW1a7du2ye0z16tWVL1++lO3r169ry5YtzlUeCDD3tndS4LR53u47PGX8+PG6efOmZs6c6dD+QUFB+uSTT/TEE09YpCcnJ2vkyJEOl7t+/XolJydbvDuxT58++vTTT3X69GmH40h3r2/Hjh1TtvPkyaPFixeradOmTscKDQ3Vs88+a5F2/fp1/fPPP07FAeA9rrbxISEh6tWrl0U7NHHiRB06dEibNm1yuPxcuXLpp59+snrP+rp16xQbG+twHE/wRRtvZPsu0cYjsPh67UFiLG401h8A/xAUFKQFCxbogQceSEnr27evrly5oldeeUXJyclOx4yOjrb5f4FTpkzR5cuX7R7nTps3duxYdevWTdWqVUtJy5gxo+bOnatu3bpp4cKFDte/c+fOmjJlitXfu1m8eLF+/PFHh+MYibGpJcamgPkYPa71lzGtu1hftkT7DgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgLRk8HUFAADece6w9P0LUts3pKjijh2zbYn0y/+kpATP1s0bdu7cqcuXLyt79uxWeU2aNNEbb7zh/Ur5gevXr9tMt3WejJYjRw6b6deuXXM7dnBwsNsx7hUREWFIHHvn3N75MEpQUJBhn8HX7ty5o3379mnfvn1WeSEhISpVqpQeeeQRde3aVQ0aNLAb58MPP1RMTIxu375td58bN27YTM+VK5fzFU+nJkyYoIEDB1qlR0dH64UXXrB5jnv37m03lr+Ii4uzme6N9tMZ3MOpy5kzp8fLsHdP2OsPfM1XYwMjxwWB2O6YffxAW+RZ3hwbwXhmez4CdQ7pLLOMBY0UqNfeX9cPfNH3+3LdgL7MfP0B3MP1NgZzev/GGq6xzNxXdunSRXXr1rWZd/z4cQ0cOFBz5sxRUlKSW+WEh4e7dbzZmX3tyNe8/YwFyvzKH9Zh00Mf4I70fH4uXrxoMz0qKsqj5RYoUMCj8QOVmcc6EuOd1KTndkji3vBHZlnbD5TxImCLmdf0/PX/lOB/fDEfYS5iH/3qXcyTnRcI987WrVu1f/9+lShRwiI9e/bsqlu3rlauXGmR3qJFC6sY8+bNS7WM+fPna8CAARZpjz32mEJCQpSYmJiSVq9ePWXLls3q+JiYmDQ/BwAAAAAAAAAAAAAAAAAAAIC7PvvsM3Xr1k1Vq1aVdPd7uLNnz9bIkSP1/vvv69atWw7H6tKli77++muFhoampC1btkzr1q2z2rdo0aIaNmxYyna/fv0kSQMHDrT7vb17lSxZUtOmTVOlSpUs0t95551Ujztz5owGDRqkb775JiWtYsWK+u2339SjRw/t2LEj1ePLlCmjqVOnqkqVKhbpAwcO1Llz5+weFxsbq5YtW1qkBQUF+VUdfSW9fV4AAAAAAAAAAAAAAAAAAALdyy+/rLx589rN/+OPP7R8+XKXYkdFRWno0KHq16+fS3+XPXPmzGrTpo3atGmj06dP67333tPXX3+tO3fuOB0rPDxctWvXdmjfkiVL6vPPP1dCQoLT5aRlyJAhqlGjhkP72vv9VUm6cOGCxo8fr8GDB9s99v3331erVq1cqicAmEFYWJhV2uXLlz1WXqZMmSy2S5Qoofj4eEPLOHPmjM6cOWM3PzQ0VEWKFLFKN/s7rMqUKaNx48ZZpO3Zs0fPPPOMU3Fu376tmTNnqmfPnilpI0aMUMeOHe0e8/bbb1tsT5s2ze13igFmd297JwVOm+ftvsNoFy5cUK5cuZQpUyb9+OOPatSokd58802dPn3a7jFVq1bVmDFjVK9ePau8CRMm6K+//nK4/EuXLmnFihVq1KhRSlrOnDm1cuVK9evXT6tXr3Y41pIlS/TLL7+oadOmKWkVKlTQ1q1b9corr2jatGkOzcny5cunyZMnq0KFChbpixcvdmnuCMA7XG3jd+3apenTp+vxxx9PScuePbtWr16tN954Q1999ZXd9+hKd/uB6OhojR49Wnny5LHIi4uLsxhHepsv23gj23eJNh6BxddrDxJjcSOx/gD4j+TkZA0fPlw//vijRfrgwYPVqFEjvfPOO1q0aJFDY4bq1atr2LBhat++vVXexYsX9eqrr6Z6vDttXlJSkp588klt3LjR4m/4REZGasGCBZo5c6bGjBmjDRs22I3xyCOPaMiQIWrTpo1V3rVr19S/f/8062E0xqbWGJsC5mT0uNYfxrTuYH3ZGu07AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHJHB1xUAAHjPlTPSdy9IZRtIVVpJ+UtKwSGW+9y+IR3ZLP0xUzq9zzf19ITk5GT99ttvatu2rVXeQw89pEKFCumff/7xfsV8zN6LgO99Ubon5M6d22b6uXPnHDo+tRfoZsmSxaU6paZQoUKGxLlw4YLN9Fy5chkS355ChQopQ4bAH/olJiZq165d2rVrlyZOnKiGDRtq2rRpypcvn9W+BQsWVPfu3TV58mS78ey9EC9nzpyG1TnQ7d27V2vWrFHt2rUt0rNkyaIOHTpo6tSpFumhoaHq1q2bVZyjR4/q119/9WhdnXHq1Cmb6Z5+lp3FPZy6ggULerwMe/3dxYsXPV62K3w1NnB3XPBfgdjumH38QFvkO0aPjWA8sz0fZp5DGsksY0Ejmfnam3H9wBd9v7+uG6SXvsxs/QHcw/U2BnN682IN11j+3le+8cYbNtN37dqlOnXqGPY82Xte0wuzrx35M088Y2aeX/2XP6zDpvc+IC3p+fzs3btXzZs3t0p/8MEHPVqup+OnR/4+1pEY76QmPbdDEveGPzLL2n6gjBcBW/x9Tc+M/6cE/+OL+QhzEfvoV+9inuy8QLl3YmNjNWzYMKv0tm3bauXKlSnb1apVU/78+S32uXTpktauXZtq/Pnz52vAgAEWadmyZVPt2rW1atWqlLR27drZPD4mJibNzwAAAAAAAAAAAAAAAAAAAADgroSEBHXp0kVr1qxR3rx5JUnBwcF688039eSTT+qbb77RwoULtWXLFqtjM2bMqFKlSqlBgwbq3bu3KleubJF/4cIFPfPMMzbL/euvvzRx4kT17ds3Ja1fv35q06aNpkyZoiVLlmj79u1Wf/sid+7cevDBB9W1a1dFR0crLCzMIj8mJkaLFi1K83NPnjxZ7dq1U8uWLVPSqlSpok2bNmnOnDmKiYnR7t27U75DmC9fPpUpU0YdO3ZUhw4dlDFjRot4Cxcu1JQpU9Is1xlmqKOR0tvnBQAAAAAAAAAAAAAAAAAgUEVERGjQoEGp7vPxxx+7FLtr16768ssvlSNHDpeOv1e+fPn0xRdfqG/fvurUqZP27dtnSFxb8ubNqzZt2mj27NmGxi1fvrxq1KhhWLwxY8bopZdesvseuZYtW6py5co2f78YAALVnTt3vFbWn3/+aXjMkSNH2n3vVaDKnDmzYmJiFB4enpJ28+ZNderUSTdu3HA63ocffqhu3bopNDRUktShQweNHTtWQ4cO1a1btyzKHTNmjFq0aJGSdvv2bX3yySdufBogcAVym+fNvsNdb7zxht59992U9+717dtXPXr00IoVK/Tbb7/p5MmTiouLU65cuVS0aFE1bdpU1apVU1BQkFWszZs366WXXnK6Du+//74aNWpkkVa6dGn9/vvvOnHihHbv3q2rV69avQts0qRJWrp0qUVa9+7dtWXLFhUoUCAlLW/evJoyZYo+/PBDLV68WH/99ZcOHTqkq1ev6tatW8qUKZOyZcumEiVKqF69emrWrJkyZcpkETchIUHvvfee058NgDk8//zzqlevnsU7AMPDwzV69Gi9/fbbWrlypbZt26aTJ0/q5s2bioiIUIECBVSiRAk99thjioyMtIqZmJiozp0768CBA978KBZ83cYb2b5LtPEIbN4ePzIWNwbrD4D/mTlzpho1amTx92yku3+/ZO7cubp69arWr1+vPXv26Pjx47p+/bri4+MVHh6uHDlyqEyZMqpRo4ZKlChhM/7NmzfVvn17q7+HY7Rt27bpySef1Pfff281NuvcubM6d+6sY8eOaceOHTp16pQuX76sHDlyKH/+/KpUqZLFeOm/EhISFB0drePHj3u0/rYwNmVsCsBxrC87h/VlAAAAAIAvVK5cWatXr5Ykff7553rttdd8XCMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZpPB1xUAAHhZsrRrxd2fsCxSjgJSeDYp8Y5044p04ZiUlOjrSnrGzz//rLZt21qlBwUFqVevXho5cqT3K+Vju3btUocOHazSq1ev7tFyQ0JCVKlSJZt5O3fudCjGlStX7OZly5bNpXqlpmTJkobE2b9/v830ypUrGxLfHnsvSQ10K1asUKNGjbRhwwZFRERY5Tdv3lyTJ0+2e/w///xjM71UqVKG1TE9mDBhgmrXrm2V3rt3b02dOtUirWXLlsqZM6fVvpMmTVJycrLH6ugsey/mtde2+Qr3cOry5cun7Nmz6/Llyx6JnyNHDt1///028/bt2+eRMt3li7GBEeOCewVau2P28QNtkf9wd2wE45nt+TDzHNJIZhkLGsnM196M6we+6PvNsm4QqH2Z2foDuIfrbQzm9IGDNVxj+VNfWbp0aZUuXdpmXu/evXXx4kXDysqbN69hsczI7GtHZmLEM2bm+dW9fL0OSx+QuvR8fnbv3m0zvUCBArrvvvvsru24q2bNmh6Ji//nT2MdifFOWtJzO8S94Z/MsrYfSONF4F7+vqZnxv9Tgv/xxXyEuYh99Kt3MU92XqDcO7NmzdKwYcOs0tu0aaMBAwakbLdu3dpqn59//lmJial/sej333/XlStXrPrJVq1aadWqVanGP3jwoLZu3ZrmZwAAAAAAAAAAAAAAAAAAAADw//bv369GjRpp0aJFFt+jKVSokN566y299dZbSkxMtPj+zjPPPKMBAwYoKCjIZswLFy6ocePGOnDggN1yn3/+ed1///169NFHU9KioqI0dOhQDR06VJJ069YtxcXFKTExUVmzZlVYWJjdeEuXLlX37t0d/diKjo7WwoUL1bBhw5S00NBQde7cWZ07d3Y4zooVKxQdHe3w/s4wQx2NlN4+LwAAAAAAAAAAAAAAAAAAgah3797Knj273fwTJ05o3rx5TsUMDg7WhAkT9NRTT7lZO9sqVqyov//+Wx06dNAvv/zikTIkqW/fvpo9e7bhMY106tQpLViwQO3atbO7z8CBA9WjRw9DywUAwEhffvmlypUrZ5H2wgsvaMeOHS7F2717t4YNG6ZPPvkkJW3AgAHq2bOn1q1bpwsXLihXrlyqXbu2smbNanHskCFDUv1+DQD42okTJ9S6dWstXbpUWbJkkSSFhYWpWbNmatasmcNxtmzZoscee0zx8fFO12HFihX64osv9MILL1jlFSxYUAULFrR53MqVK63Szp07p3r16unXX39VkSJFLPKioqLUq1cv9erVy+k6Dhs2jPehAAHs8uXLatSokVatWqV8+fJZ5EVGRqp169Y235VkT3x8vLp27apFixYZXVWn+LqNN7J9l2jjAfgf1h8A//TMM89Isv1/aFmzZtWjjz5q8bduHHX58mV16tTJ4n2anvTDDz8oKSlJ3377rTJmzGiVf//999t937Yt169fV3R0tJYsWWJkNR3G2NQxjE0BmI2v23eJ9WUAAAAAgG8EBwenzIVtreECAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQFqCfV0BAIDv3Lound4nHfpLOrpFOndYSkr0da08JyYmRrdv37aZ9/zzz3v9D37nzp1bBw4c0IgRI1S4cGGvlv2vnTt32kwvUKCAR+tUpUoVhYeH28zbtWuXQzEuXbpkN+/el8QboUaNGobE2bt3r830IkWKeKTe/3rkkUc8Ftvf7dq1S19++aXNvLp166Z6rL2XRD/44IMKCgpyu27pRUxMjC5fvmyVXr9+fasX9vXu3dtqv8TERE2ePNlDtXPNtm3bbKYXK1ZMuXPn9nJt7OMeTtuDDz7osdg1a9a0m2evP/A1X4wNjBgX3CvQ2h2zjx9oi/yLO2MjGM9sz4eZ55BGMstY0EhmvvZmXD/wRd9vpnWDQOzLzNYfwD1cb+Mwpw8crOEay1/6ykaNGtlM37ZtmzZs2GBoWQ899JCh8czG7GtHZuPuM2bm+dW9fL0OSx+QuvR8ftatW2c3r2XLlh4r15Ox8f/8ZawjMd5JS3puh7g3/JNZ1vYDabwI2OLPa3pm/D8l+B9fzEeYi9hHv3oX82TnBcq9s2XLFh04cMAqvXDhwqpUqVLKdqtWraz2mT9/fprxExIStGTJEqv0/177KlWq6L777rPaJyYmJs34AAAAAAAAAAAAAAAAAAAAAKzt2LFDlStX1rRp05ScnGyVHxISoly5cqVsh4WF2f1e54IFC1S+fHlt2bIl1TJv376tFi1a6P3337f7N/7DwsKUM2dO5cmTR2FhYTb3uXPnjt588021bNnSbhxbbt68qUcffVSjR49WUlKSw8f9KykpSZ9++qkeffRR3bx50+njHWGGOhopvX1eAAAAAAAAAAAAAAAAAAACTVBQkF5++eVU95kwYYISExMdjpkhQwbFxMToqaeecrd6qcqSJYvmzp3r0ffUNGnSxNC/RRwWFqYnnnjCsHj/GjduXKr5Xbp0Uf78+Q0vFwAAI3Tv3t3qHZfTp0/XN99841bc0aNH64MPPrBIy549u5o3b64nnnhCzZs3V9asWS3y33vvPX3++edulQsA3rBu3TrVrl1b+/fvd+n4b7/9VnXq1NHZs2ddrsOAAQM0atQom99vdNaBAwdUvXp1TZs2ze1YcXFxevrpp/XJJ5+4HQuAf9u3b5+qV6+uFStWuBVn8+bNevDBBzV37lxjKuYmX7fxRrbvEm08AP/B+gPgvxITE9WvXz89/vjjOnXqlCExFy1apHLlymnZsmWGxHPU9OnT9dBDD6X5N3zSsnbtWlWtWlWLFy82pmIuYmxqH2NTAGbm6/ZdYn0ZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5hPs6woAAOAtly9f1sKFC23mRUVFacCAAV6tT9++fVWsWDG98cYbOnz4sH755Rd17NhRoaGhXqvDmjVr7OY1atTIY+Xai3379m39/fffDsW4fPmy3bwqVaq4Ui27smbNqho1ahgS66+//rKbV6dOHUPKsKVp06Yei20Gs2bNspmeO3duhYSE2D1u8+bNNtMjIyNVrlw5Q+qWHsTHx9t8MV9QUJB69OiRsp03b141a9bMar/Fixfr5MmTHq2js1Jrq+rWrevFmqSOezhtjz32mMdi16tXz2b67du3tXPnTo+V6w5fjA2MGBfcK9DaHbOPH2iL/I+rYyMYz2zPh5nnkEYyy1jQSGa+9mZcP/BF32+2dYNA68vM1h+kF0FBQR6Jy/U2DnP6wMIarrH8oa984IEHbKanNtZxVYMGDQyPaSZmXzsyI3eeMTPPr+7l63VY+oDUpefzs3PnTrv31gsvvOCRMhs0aKBSpUp5JDas+cNYR2K8k5b03A5xb/gns6ztB9J4MdB4ar0wvfHnNT0z/p+SK7iXPcvb85FAmYt46r6kX72LebLzAuneiY2NtZnepk0bSVKBAgWs+rk7d+5oyZIlDsWfN2+eVVqpUqVUvHhxSVK7du1sHmdvbu8p9H8AAAAAAAAAAAAAAAAAAAAIJJcuXVL37t1VqVIljR8/XufPn3f42HPnzum7775T9erV1bp1a50+fdqh4xITE/Xaa6+pVKlS+vDDD3Xs2DGHyzx//rxGjx6tMmXK6N1331VCQoLDx/4rISFBgwcPVoUKFTR16lTFxcWleczNmzc1bdo0VapUSQMHDnSp3ECro5HS2+cFAAAAAAAAAAAAAAAAACCQNG3a1O67NSQpOTlZ3377rVMxx44dq/bt27tbNYdkzpxZc+fOVf78+T0SPzg4WE899ZRh8Tp06KAcOXIYFu9fy5Yt0/Hjx+3mh4aGGvo5AAAwSqlSpfTVV19ZpO3bt0/9+vUzJP6wYcPUsWNHHT58ONX9Dh06pPbt2+v11183pFwA8IatW7eqYsWKGjZsmM6cOZPm/omJifr555/1yCOP6Mknn9T169fdKj85OVnDhw9X6dKlNW7cOO3Zs0fJyckux7tw4YK6d++uqlWr6vvvv9eVK1ecOv7MmTP64osvVKJECX399dcu1wOAuZw4cUKNGjVSy5Yt9dtvvykxMdHhY9esWaOuXbuqWrVq2rFjhwdr6TxftvFGt+8SbTwA32P9ATCH6dOnq1ixYurdu7dWr17t9N8iuXnzpr777jvVqFFDLVu2tPvuVk/bunWrqlatqs6dO+v33393eCyVlJSkX3/9Va1bt1bt2rW1f/9+D9fUMYxNLTE2BRAoWF+2RPsOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAtGTwdQUAAPCm0aNHq3379jbz3njjDc2cOVPHjh3zeD1y5sypl19+OWU7KChITZo0UZMmTbRt2zZVqlTJ43WQ7r5QfcuWLapcubJV3osvvqjJkycbXmZISIieffZZm3mrVq3StWvXHIqTkJCgM2fOKCoqyirvwQcfdKuO9+revbsyZDBm2LRlyxadO3dOefLkscp7+umnFRMTY0g5/1WiRAk98sgjhsc1k71799pMDwoKUq5cuXT27Fmb+X/99ZeuX7+uLFmyWOU9/vjjGjZsmKH1DGRff/21nnvuOav03r17a8SIEZLunlNbz9qECRM8Xj9nbd68WRcuXFCuXLms8vr37685c+b4oFbWuIfT1qVLFw0ZMkRJSUmGxs2YMaN69+5tM2/t2rW6ceOGoeUZxdtjA6PGBbYEUrtj9vEDbZH/cXVsBOOZ7fkw8xzSSGYZCxrJzNfejOsH3u77zbhuEGh9mdn6g0Bz584dm+nh4eEeKY/rbRzm9IGFNVxj+UNfaWssI0kXLlwwtJz8+fObbixjNLOvHZmRO8+YmedXtvhyHZY+IHXp/fzMnz9fTz/9tFV6mTJl1Lx5c/3888+Gljdo0CBD4yF1/jDWkRjvpCU9t0PcG/7JLGv7gTZeNCNvrxemN/68pmfG/1NKDfey73hzPmK2uYi370v61f/HPNk5gXTvzJo1S6+++qpVetu2bTVixAi1bNnSZnlXr151KP7ixYuVkJBg1a+1bNlSY8eOVZs2bayOOXz4sDZv3uzgJ3AO/R8AAAAAAAAAAAAAAAAAAADSk+3bt+vZZ5/Vc889p1KlSqlatWq67777VK5cOXXv3l3S3e97Tp8+XSdOnNDOnTu1a9cut8o8cuSIXn31Vb366qsqUqSIKlasqGLFiilPnjwKDw9XxowZde3aNV26dEknTpzQhg0b7H432BW7du1Sjx491LdvX9WsWVPly5fX/fffr4iICAUFBen69es6fvy4duzYoT/++EPx8fFOl9GqVStJ0ttvv6233nrLL+vornXr1ikoKMiQWGb4vAAAAAAAAAAAAAAAAAAAwFKPHj1Szf/jjz90/Phxh+N1797d5nus0pKQkKDz588rISFBkZGRypYtm8PH5siRQ5MmTVKLFi2cLtcRTz75pN5++21D/q5+v379DKiRbbGxsXr55Zft5j/xxBMaOXKkx8oHAF85duyYYb8X74gSJUp4rSx79u3b59XPbItR5e/du9fmu82MNHv2bM2dO1d16tRRkyZNVKhQIWXPnj3lOy+//PKL1qxZo8TERI/WAzAbf2jvJM+0ed7uOzwpPj5eH3zwgT766CPVrl1bNWvWVKlSpZQ9e3aFhIToypUrOnnypLZs2aJly5YZ/g5F6e41+nceGBkZqTx58ihHjhwKCwuz2vfQoUNpxtu8ebN69uypkJAQPfTQQ6pQoYJKlSqlXLlyKUuWLAoLC9PNmzd1/fp1Xbp0STt37tT27dv1999/G/4+NMCXdu3a5TdtlafqYmQbv2jRIi1atEi5cuVS3bp1VbZsWRUtWlRZsmRRRESEbt26pevXr+vYsWPauXOnVq1apdOnTxtStqf4uo03un2XaONhXulx7UEKrLE46w+Aedy8eVNTpkzRlClTFB4erpo1a6pkyZIqXry4cubMqYiICGXOnFm3b9/WpUuXdPnyZR06dEh//vmntm3bpoSEBJfKNbrNS05O1qxZszRr1izlzZtXdevWVfny5VW4cGFlyZJFmTJlUnx8vK5evarDhw9rx44d+v3333Xx4kXD6mAkxqaMTRG4WH9wHuvLxmJ9GQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGaRwdcVAADAm9atW6fff/9ddevWtcqLjIzUzJkzVadOHZdfJOmoMWPGKE+ePDbzfvjhB4+Wfa85c+aocuXKVumVKlVS48aNtWzZMkPLi46O1v33328z76effnIq1vr169W2bVur9AYNGihPnjw6d+6cK1W0kCFDBr300ktux/mvX375RY8//rhVesOGDVWhQgVt377d0PIGDRrk9y+ry5w5s55++mllyJBBH3/8seHxb9y4YTcvODjYbt6dO3e0bNkym/fZU089pTfffFN37twxoooBb/v27dqwYYMeeughi/QiRYqoXr16WrVqlXr37m113MmTJ7Vo0SJvVdNhSUlJ+vnnn/XEE09Y5TVt2lSlS5fWnj17DC0zR44cunTpklPHcA+nrUCBAurWrZvh/W+3bt2UN29em3k///yzoWUZzZtjAyPHBfcKtHbHzOMH2iLn+evYCMYz4/Nh5jmkUcwyFjSama+9GdcPUuv7jeaJdQP6MueYsT8IJPba11y5cnmkPK63cZjTe5e/tu1mfab89XwaKTk52WZ6lixZDC1nyJAhypgxo6ExzcjMa0ee4O/PmJnnV/fy5TqsWfsAb0nv52f8+PF6+umnbeZ99dVXKl++vK5evWpIWdHR0WrRooUhsQKFv7fDRmG8k7r03A5xb/gnM63tB9J40Yy8vV6Y3vj7mp4Z/0/JHu5l3/HWfMSMcxFf3Jf0q3cxT3ZeoNw7mzdv1sGDB1WsWDGL9CpVquj+++9Xq1atrI6ZP3++w/EvX76sNWvWqH79+hbprVq10ty5c1WxYkWrY2JiYhyO7yz6PwAAAAAAAAAAAAAAAAAAAKRHycnJ2rNnT8p35CpWrKju3btLktauXauxY8d6pNwjR47oyJEjHomdllu3bmnVqlVatWqVx8r493uhN2/edOl4b9TRn6S3zwsAAAAAAAAAAAAAAAAAgFlFRETY/Hvs/zVz5kyH4+XIkcPh31dNTk7W3LlzNXv2bC1btkxnzpyxyM+VK5dq1aqlJ554Qh07dkzzPTTNmzdX06ZN9csvvzhcX0cVLFhQzZo1c/s9WyVKlFC9evUMqpW1WbNm6eWXX7abX7JkSVWvXl0bN270WB0AAPBXiYmJ+u233/Tbb7/5uioA4BFJSUn6/fff9fvvv/u0HteuXdO1a9cMiZWYmKj169dr/fr1hsQDkD5cuHBBP/30U0C9e9Mf2ngj23eJNh5A4GL9ATDWjRs3tGLFCq1YscLXVXHL2bNnFRsbq9jYWF9XxW2MTQEgMPlD+y6xvgwAAAAAMFaVKlXUsWNHVaxYUQ888ICKFCmSkvf888+rVatWOnjwoNatW6fFixdr06ZNhpRbpEgRtWvXTrVr11bZsmUVFRWlyMhIhYSE6MaNGzp16pR27dqllStXaubMmTp16pQh5UrSAw88oOjoaNWtW1elS5dWVFSUMmfOrISEBF2/fl1Hjx7Vtm3btHjxYi1YsEBxcXGGle0oT5+fBx54QI0bN/ZI3Tdu3Oj0feLL+wEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADGC/Z1BQAA8LbBgwcrKSnJZl7NmjU1bdo0BQUFeaz8F154QT179rSZd+3aNX399dceK9uWr7/+Wrdu3bKZN27cOEVGRhpWVlRUlEaPHm0z79KlS/r++++dirdmzRqb6aGhoerRo4fT9bPlpZdeUokSJQyJ9a+JEyfazRs3bpxCQkIMK6tixYrq06ePYfGMljlzZg0cOFCHDx/WmDFjNGLECBUtWtTwcqKiomymJycn6/z586ke+91339lMz5Mnj55//nm363avgQMH6tVXX1VoaKjhsX1twoQJNtN79+6tKlWqqEKFClZ5kydPtttm+9qkSZPs5o0bN87QvqR48eI6efKkpk+frrJlyzp1LPdw2kaNGqWsWbMaFi9Pnjx67733bObduXNHU6dONawsT/DW2MDocYEtgdTumH38QFvkGDOMjWA8sz0fZp5DGsksY0Ejmfnam3H9ILW+35/7ffoy15mtPwgkFy9etJlepUoVj5XJ9TYOc3rPM0PbbqZnygzn0yj2yilevLhhZRQrVkz9+/c3LJ6ZmX3tyChmecbMPL+yxZfrsGbqA3whPZ+fbdu2adWqVTbz7rvvPk2cONGQ9Zv7779fX375pdtxAoVZ2mGjMN5JW3pth7g3/JdZ1vYDbbxoNr5YL0xv/HlNz4z/p2QP97LveGM+Yta5iC/uS/rVu5gnOy+Q7p3Y2Fib6V26dFGjRo2s0hcsWOBU/Hnz5lml1alTx27fGRMT41R8Z9D/AQAAAAAAAAAAAAAAAAAAADDKI488Ikk6ceKEj2sCAAAAAAAAAAAAAAAAAABgnBYtWig8PDzVfWz9zVl7RowYoVy5cqW536ZNm/TQQw+pffv2mjZtms6cOWO1z4ULF7Rw4UJ17txZDz30kI4cOZJm3GHDhjlcV2f169fP7Rh9+/Y1oCb2/fHHHzbP5X9FR0d7tA4AAAAAAAAAAAAAAAAAAAAAAADeliFDBj3//PM6cOCANm3apOHDh6tly5YqW7asxXdnMmXKpFKlSql58+YaOXKk/v77b23dulXt2rVzueySJUtq9uzZOnTokMaMGaP27durdOnSypEjhzJkyKCgoCBFRESoePHiat26tT799FMdP35ckydPVt68ed363MWLF9fcuXN18OBBjRo1Ss2aNVPRokUVHh6uoKAghYaGKkeOHKpcubJ69OihGTNm6NixYxo8eLCCg4PdKttR3jo/1atX19dff+2Rn5YtW/rd5wUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIB3eeeveQIA4Ef++usvTZw40W5+dHS0YmNjlTlzZsPLfvrpp/XZZ5/ZzR85cqSuXr1qeLmpOXv2rL777jubeSVKlLCb56yQkBDNnDlT+fPnt5k/fvx4xcXFORXzt99+s5v3+uuvKyoqyql496pWrZpGjhzpVgxbVq1apR07dtjMq127tt5//31DysmSJYtmzpypkJAQQ+IZrVu3bjpy5IhGjx6dcq0yZcqk2NhYhYWFGVpW3bp1baZfuHBBCQkJqR67YMECHTt2zGbeqFGjVK5cObfr968qVaro/fff16hRo7R9+3Y1atTIsNj+4Mcff9T169et0jt27KgXX3zRKj05OVmTJk3yRtVc8vvvv2vr1q028xo0aKDXX3/dkHJCQkI0ZcoUZcqUSV27dtWOHTs0e/ZsVa5c2aHjuYfTVqhQIU2dOlVBQUFuxwoKCtL06dNVoEABm/kxMTE6c+aM2+V4kjfGBp4YF9gSSO2O2ccPtEVpM8vYKDg42O6PEe1oemS258PMc0gjmWUsaCQzX3szrh+k1vf7a79PX+Yes/UHgWT79u020++77z5VqVLFI2VyvY3DnN6zzNK2m+WZMsv5NIq956Vu3bqKjIx0O36mTJk0Z84ci5f7pmdmXzsygpmeMTPPr2zx5TqsWfoAX0nv52fw4MFKTk62mRcdHa3p06crQ4YMLscvVqyYVq9erdy5c7scI5CYqR02CuOdtKXXdoh7w3+ZZW0/0MaLZuOL9cL0xp/X9Mz4f0r2cC/7lifnI2aei/jivqRf/X/Mk50TSPfOrFmzbKa/9tprVt+Z2b59u44cOeJU/AULFlilhYaGaujQoVbpR48e1caNG52K7wz6PwAAAAAAAAAAAAAAAAAAAADuCgoK0qeffqqaNWtKkhYvXuzjGgEAAAAAAAAAAAAAAAAAABinWbNmqeYfOnTI4b9RmyNHDvXp0yfN/VatWqW6des69bdp//77b9WvX1/nzp2zmZ+cnKxVq1ZpxowZDsd0VosWLez+7WBHZMiQQT179jSwRratXLky1fzHHnvM43UAAAAAAAAAAAAAAAAAAAAAAADwluLFi+uvv/7SF198oWLFijl9fMWKFTVnzhwtXLhQOXLkcOrY7t27a/PmzWrfvr2CgoIcPi4kJES9e/fW9u3bVatWLWerLEnq2rWrtm7dqjZt2jh1XM6cOfXxxx9r+fLlioiIcKlsR/ny/PhCevu8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA6UmwrysAAIAvDB48WHv37rWb3759e23YsMGw8rJmzaoffvhB48ePt/vHnv/880998sknhpXpjDfffFOXL1+2mdeuXTvNmjVLmTJlcjl+tmzZtHjxYtWrV89m/okTJ/TBBx84Hffvv//Wxo0bbeZlz55dU6ZMUWhoqNNxJalcuXJatGiRwsLCUtKSk5NdimXLm2++aTfvlVde0ciRI92KHxkZqUWLFql06dJuxfGk69evK2/evFbpVatW1fz58xUeHm5IOSEhIRoyZIjNvB07dqR5fGJiokaMGGEzLywsTPPmzVPRokXdqqN09wUFCxYsSLnnSpUqpWXLlmnmzJkqUKCA2/H9QVxcnGbMmGGVHhERoV69elml//rrrzp69KgXaua6YcOG2c175513Us13RHBwsL799ls98sgjKWlBQUFq3769Nm3a5NAzzj3smNatW2vu3LluvfAiPDxcs2fPVuPGjW3m37lzR++++67L8b3Jk2MDT40LbAm0dsfM4wfaorSZZWy0atUqJSYm2vyZM2eOIXVMb8z4fJh1Dmk0M4wFjWbWa2/W9QN7fb+/9vv0Ze4xY38QKNauXWs3z91nzR6ut7GY03uOWdp2szxTZjmfRlm3bp3N9EyZMrk9Vg4PD1dMTIwqVqyYkpaYmOhWzEBg5rUjI5jtGTPr/MoWX67DmqUP8JX0fn42btyoyZMn283v0qWLVqxYofLlyzsdu0uXLlq7dq3uv/9+d6oYUMzWDhuB8U7a0ms7xL3h38yyth9I40Wz8cV6YXrkr2t6Zv0/JVu4l33LU/MRs89FfHVf0q/exTzZeYFy72zatEmHDh2ySs+aNatV2oIFC5yOf/DgQe3evdsq3dZaQGxsrNPxnUH/BwAAAAAAAAAAAAAAAAAAAMAd2bNn18KFC/XSSy9Jko4dO2b3u7IAAAAAAAAAAAAAAAAAAABm9Nhjj6Wav3z5codj9e7dO82/0XvkyBG1aNFCcXFxDsf919GjR/Xyyy9bpG3evFmDBw/Wfffdp/r162vChAlOx3VUSEiIevfu7fLxbdq0sfk+H6Oldc0qVKjg1+/ZAgAAAAAAAAAAAAAAAAAAAAAAcFTZsmW1fv16Va5c2SI9OTlZ27dv19SpU/X999+npG/dulXLly/XlStXrGK1aNFC69evd/j7H0888YS+//57hYeHW6RfvXpVS5Ys0RdffKH33ntP7733nsaPH6/169crMTHRYt+8efPq119/VcWKFR38xHf16tVL06ZNsyo7Li5OCxcu1Lhx4/Tuu+9q1KhRmjRpkjZs2KCkpCSLfevXr68FCxYoKCjIqbId5cvzY7SEhIQ09wmkzwsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABrwb6uAAAAvnD9+nW1b99ecXFxdvcpX768pk2bpvLly7tcTmRkpIYOHarDhw/r8ccft7vftWvX1LNnT6s/vO0tZ86c0ZAhQ+zmd+rUSWvWrFGlSpWcjv3www/rjz/+UJMmTezu8/zzz+vatWtOx5ak0aNH28177LHHNHfuXGXJksWpmNHR0VqzZo2ioqJS0i5cuKDly5e7VEdbfvrpJ/36669281977TXNnTtXBQsWdDr2gw8+qD///FN169a1SP/555+djuVJ8+fP1/r1623mNW3aVH/88YeqVavmVhmhoaGaPHmy3TizZ892KM63336rDRs22MwrVqyY/vjjD9WuXdvlejZt2lTr16+3eb2jo6NVtWpVl2P7mwkTJnhkX19ZvHixYmNjbeYFBQXp/fff1/Tp05UvXz6nY+fOnVs///yznnjiCZv58+bN0549exyKxT3smNatW+uPP/5wqb6VKlXS2rVr1a5dO7v7fPbZZw5fM1/z1NjA0+MCWwKp3TH7+IG2KHVmGhvBeGZ7Psw8hzSSWcaCRjLztTfj+kFqfb8/9vv0Ze4zW38QKDZv3qwTJ07YzGvevLm+/PJLhYaGGl4u19tYzOk9w0xtuxmeKTOdTyOsX7/e7tht6NCh6tSpk0txixQpojVr1qhly5YpaTdu3NAPP/zgUrxAYva1I3eZ7Rkz8/zKFl+uw5qhD/Cl9H5+BgwYoF27dtnNr1OnjrZs2aLJkyeradOmypgxo919c+bMqSeeeEKrV6/WjBkzLNYDJFm8cD49Mls7bATGO45Jj+0Q94Z/M8vafqCNF83EV+uF6cGSJUsstv11Tc+M/6dkC/ey7xk1HwmkuYiv7kv61f/HPNk5gXTv2BsD32vevHkuxZ8/f75D+8XExLgU31H0fwAAAAAAAAAAAAAAAAAAAIB0+vRpvfXWW3rrrbe0ePFiX1fHVCpWrKhHH31UkrRz507VqVNH58+f93GtAAAAAAAAAAAAAAAAAAAAjFG6dOk038Xw22+/ORzP3rsZ/qt///6Ki4tzOOa9ZsyYod9++00jRoxQ6dKlVbVqVY0ePdru36E1Wp8+fVw+tl+/fgbWxL7ff/89zX0aNGjghZoAAAAAAAAAAAAAAAAAAAAAAAB4TubMmbVgwQLlzp07JS0hIUGffvqpihQpoooVK6pHjx767LPPUvJ//fVXNW7cWNmzZ1fjxo21evVqi5ilSpXSzz//rAwZMqRadunSpTVhwgQFBQWlpJ04cULdu3dX7ty51axZM7344ot6/fXX9frrr+vZZ5/Vww8/rMKFC+ubb76xiBUREaEZM2YoJCTEoc9dvnx5q7IvXryop556Srlz51arVq303HPP6c0339Tw4cPVt29f1ahRQ4ULF9a0adMsYjVo0EADBw50qFxn+OL8/PLLL6pWrZrbP//73/8s4t66dUs//PCD331eAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeFewrysAAICv7Nq1S61atdLNmzft7tOtWzdt375dW7Zs0TvvvKMmTZoof/78dvcPCwtT1apV9dRTT2nu3Lk6d+6cPvjgA+XMmdPuMTdv3lSLFi20d+9etz6PuyZNmpTqH6+uVq2aNm/erKlTp+qRRx5RcLD9YURoaKgaNWqkuXPnau3atSpdurTdfceOHau5c+e6XO+YmBjt3LnTbn7z5s21f/9+9enTR5GRkXb3CwkJUbNmzfTbb79p5syZyp49u0X+iBEjdPnyZZfraUufPn104cIFu/lt2rTRgQMH9Mknn6hixYqpxgoODlb9+vUVGxurP/74Q2XKlLHI//PPPzVp0iRD6m2knj176tq1azbzKlSooA0bNmjOnDlq3LixQkNDHY4bFhamTp06adOmTerRo4fNfW7evKnZs2c7FC8pKUk9e/bU9evXbebnzZtXq1evVmxsrCpVquRwPR988EHFxMRo6dKlFi8o+K/vv/9eCxcudDimv9u4caO2bt2a5n5nz57VvHnzvFAj9/Xv319Hjx61m9+1a1cdPHhQH330kUP3R6FChfTaa69p//79evTRR23uc/HiRQ0YMMDhOnIP27Zs2TIdPnzYIq18+fLauHGjZs6cqdq1a6fa3wUHB6t27dqaNm2aNm/erMqVK9vdd8eOHXrrrbeMqrpXGD028Ma4wJZAa3fMPH6gLUqbWcZGMJ4Znw+zziGNZoaxoNHMeu3Nun6QWt/vj/0+fZl7zNgfBIKkpCSrF/3917PPPqu9e/fqlVdeUY0aNZQzZ05DXsjH9XYPc3rvMUvbbpZnyizn0wiJiYl2x43BwcGaOXOm/ve//ykqKsqhePnz59fYsWO1d+9eValSxSLv3Xff1fHjx92ucyAw89qREcz2jJl1fmWLL9dhzdIH+Ep6Pz9xcXFq3769zp8/b3efkJAQ9e7dW0uXLtWFCxe0efNmLV68WFOnTtX06dO1fPly7dy5U2fPntX333+v2rVrW8U4fPiwBg8e7MmPYgpma4fdxXjHMemxHeLe8H9mWdsPpPGimfhqvTA9eO2116zmrP64pmfW/1O6F/ey77kyHwn0uYgv70v61buYJzsvUO6dWbNmpbnPmTNntGHDBpfiz58/P819/vnnH/35558uxXcU/R8AAAAAAAAAAAAAAAAAAABw93v9I0aM0IgRI/TLL7/4ujqm8vvvv+uNN97Qjz/+qJo1a+rYsWO+rhIAAAAAAAAAAAAAAAAAAIBhqlWrluY+mzdvdihW7ty503yfw4YNG9z+fdakpCQ1aNBAb731lvbu3etWLFcULVpUjRs3dvq4woULu3ScK/bv36+4uLhU96levbpX6gIAAAAAAAAAAAAAAAAAAAAAAOApgwYN0gMPPJCyfe3aNTVs2FADBw506G+KL1++XHXr1tVzzz2n5OTklPRq1arpzTffTPXY//3vf8qUKVPK9rZt21SpUiVNmzZNd+7csXvciRMn1KdPHz3zzDMW6WXLllV0dHSadZakCRMmKDQ0NGV77969Klu2rCZPnqz4+Hi7x/3zzz/q3r27PvroI4v04cOHKyIiwqGyHeWL83P58mVt2rTJrZ+9e/eqU6dOFnG/+OKLNO8nX94PAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8I4Mvq4AAAC+tHLlSrVu3Vpz5sxRZGSk3f0qVaqkSpUqpWzHx8fr8uXLiouLU0JCgsLDw5UtWzZFRkYqKCjI4fLj4+PVtm1brV692q3PYZSnnnpKRYoUUe3atW3mBwUFqXv37urevbsuXLigDRs26PTp0zp79qyCg4MVFRWlAgUKqGbNmsqSJUua5S1cuFCDBg1yq86JiYnq2LGjNm7caPePk+fLl08TJ07UuHHjtH79eh05ckRnz57VnTt3lC1bNhUvXlwPPvigcuTIYfP45cuX64svvlCdOnXcquu9jh07ps6dO2vp0qUKCQmxuU+mTJk0aNAgDRo0SCdOnNCmTZt05swZnT9/XkFBQSn1r1q1qnLmzGkzxvnz5xUdHa3KlSsbWn8j7N+/X7169VJMTIyCg4Ot8oODg9WuXTu1a9dOcXFx+uOPP7R3714dPnxY165d040bN5ScnKzw8HBFRkaqcOHCKlOmjB5++GGFh4enWvZbb72lU6dOOVzXPXv2qGvXrpo7d67d69WhQwd16NBBx48f17Jly1LutWvXrikkJEQRERHKkyePypQpo9q1a6tQoUKplrl27Vr169fP4TqaxYQJE/Tll1+mus93332nhIQEL9XIPRcvXlSzZs20du1au+1IeHi4hgwZoiFDhujMmTP6+++/dfbsWZ07d0537txRlixZFBUVpQoVKqhMmTKp9iVJSUnq0aOHQy+w+C/uYWvXr19Xz549tXz5cosXZgQFBSk6OlrR0dG6dOmS/vjjD506dUrnzp1TUFCQ8ubNq3z58qlmzZrKnj17muVcvnxZbdu21Y0bNzz4aTzDm2MDI8YF9gRSu2P28QNtUerMNDaC8cz4fJhxDmk0s4wFjWbGa2/W9YO0+n5/6/fpy9xnxv4gEIwfP14vvPCCChQoYDO/aNGi+vDDDx2K9cEHH2jYsGEO7cv1dh1zeu8xU9tuhmfKTOfTCCNGjFDPnj1t1i0oKEjPPfec+vfvrxUrVmjDhg3av3+/rly5ovj4eGXLlk158uRRkSJF1LhxY1WqVMnmWHnx4sX68MMPNWLECG98JL9n9rUjd5nxGTPj/MoeX67DmqEP8KX0fn727t2revXqacWKFYqKikp13yxZsjjdtl26dEnNmjXTlStX3KhlYDBjO+wuxjuOSY/tEPeGfzPT2n4gjRfNxFfrhYHu/Pnz6tq1q5YsWWIxVvC3NT2z/p+SLdzLvufsfOSxxx5zOLZZ5yK+vC/pV+9inuy8QLh3/v77bx0+fFhFixZNtVxXrV+/XufOnVOePHns7hMbG+tyfGfQ/wEAAAAAAAAAAAAAAAAAAABwx6hRo3xdBQAAAAAAAAAAAAAAAAAAAI+oXr16qvnx8fHau3evQ7EaNmyY6nsaJGny5MkO182Xbt26pZCQEGXIkMFmfr9+/bRs2TKnYvbp08fm+3uku+/idORvFTsqOTlZ27ZtU61atezuU61aNcPKAwAAAAAAAAAAAAAAAAAAAAAA8IW+fftabL/wwgtavXq103HGjRunpKQkjR8/PiVt4MCB+uKLL3Tu3Dmr/UuWLKmGDRumbF+9elUtW7bUhQsXHC7zq6++UuPGjdWhQ4eUtC5dumjGjBmpHte1a1eL74xcvHhRTZs21ZkzZxwue9iwYWratKkKFy6sGTNmaMqUKYqLi3P4+LT48vy4a+DAgYqKikrZvnTpkt57771UjzHz5wUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDjMvi6AgAA+NqyZcv00EMPaf78+SpRooRDx2TKlEn58uVzq9x9+/apY8eO2r59u1txjHT79m01bdpUMTExatGiRar75sqVS82aNXO5rGnTpqlXr15KSkpyOca/9uzZo379+umHH35QUFCQ3f1CQ0NVt25d1a1b1+HYe/fuVdeuXZWcnOx2PW1Zvny5OnTooJkzZyosLCzVfQsWLKiCBQs6Ff/q1atq3bq1jh07psqVK7tRU8+ZM2eOunbtqh9++EGhoaF294uIiFCjRo3UqFEjt8tcsWKFxowZ4/RxCxcuVJcuXTR9+vRU63rfffepd+/e7lRRa9asUatWrXTr1i234vijH374QZ988okyZ85sd5+JEyd6sUbu2717t+rWratff/01zf4hKipKzZs3d6mchIQEde/eXYsWLXLpeO5ha6tXr9ZTTz2l7777zmYfkiNHDrf6u3PnzunRRx/VwYMH3ammz3hrbGDkuMCWQGt3zD5+oC1KnZnGRjCe2Z4Ps84hjWaWsaCRzHrtzbp+4Gjf7y/9Pn2Z+8zWHwSCK1euqHv37lq2bJmCg4O9WjbX23XM6b3HTG27GZ4pM51Pd50+fVoDBgxIdd0lQ4YMatq0qZo2bep0/LVr16pLly4e+z8cszL72pG7zPaMmXV+ZYuv12HN0Af4Uno/P7t27VKNGjX0448/qmbNmobFPX78uJo3b669e/cqY8aMhsU1M7O1w+5ivOO49NYOcW/4P7Os7QfSeNFMfLleGOh+/fVXPf/88/ryyy/9ek3PrP+ndC/uZf/gifmImecivrwv6Vf/H/Nk5wTKvRMbG6shQ4bYzZ83b57LsZOTk7Vo0SL16tXL7j6zZs1yOb4z6P8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwFrFihVTzd+9e7fDfxvXkfeXLViwwKFYvnbt2jWtWbNGbdu2tZnfpk0b5c6dW+fPn3coXnBwcKrvXpkxY4b69u3rSlXt2rFjh2rVqmU3v1KlSoaWBwAAAAAAAAAAAAAAAAAAAAAA4E333Xef7r///pTtc+fOaerUqS7H++qrr9SzZ0/VrFlTf/31l8aMGaOLFy/a3Hffvn0qX768BgwYoCeeeELvv/++jh8/7nSZ48aNU4cOHVK2q1atmuYx934HZcSIETp27JhT5SYlJally5Y6d+6cbt++7dSxjvDl+XFHnjx5NGTIEIu09957T5cvX071OLN+XgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgn2NcVAADAH+zZs0eVK1fW6NGjlZiY6NGykpKSNHnyZFWtWlXbt2/3aFmuuHnzptq0aaMPPvjAI+fi1q1bGjp0qLp3766EhATD4k6fPl1PPvmk7ty5Y1jMXbt2qWHDhjp37pxhMW2ZN2+eHn30UZ08edLQuCdPnlSDBg20fv16Q+N6wqxZs9SkSRMdPXrU42XNnz9fzZs3d/n+jo2NVYMGDQy/Xv81YcIENWzYMM0/Km9WV69eVUxMjN38VatWaf/+/V6skTF27NihatWqadWqVR6Jf/bsWbVo0UIzZ850Kw73sLWpU6eqU6dOio+PNzTu9u3bVbt2bW3evNnQuN7mybGBp8YF9wrEdsfs4wfaotSZaWwE45nt+TDrHNJoZhkLGsms196s6wee6Ps92e/Tl7nPbP1BIFi5cqW6detm+NzQEVxv1zGn9x4zte1meKbMdD7dNWnSJL3zzjuGx509e7YaN26sq1evGh47EJh97chdZnvGzDq/upc/rMOaoQ/wpfR+fo4eParatWvrtddeM6T/mDlzpqpVq6YdO3YYULvAYrZ22F2MdxyX3toh7g3/Z5a1/UAZL5qNL9cLA9348ePVu3dv3b5929C4Rq/pmfX/lO7FvewfjJyPBMJcxJf3Jf3q/2Oe7JxAuHdmzZplNy8+Pl7Lli1zK/78+fPt5p04ccKr68r0fwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgqUiRIqnmO/OumZIlS6aaf/bsWY++n8RoX3/9td28jBkzqkePHg7HatasmQoWLGg3f+LEiU7VzRFpXbusWbMqa9ashpcLAAAAAAAAAAAAAAAAAAAAAADgDfd+V2PHjh1KSkpyK2b//v31yCOP6KGHHtKPP/6oxMREu/vu2rVL/fv3V6FChfTFF1+4VN6OHTsstvPmzZvq/vfdd5/q16+fsn3u3DmNGzfOpbJPnDih27dvu3SsI3xxftz15ptvKjIyMmX72LFjDtfdjJ8XAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzgn2dQUAAPAXN27c0ODBg1WpUiVNnz491T/q7aq5c+eqYsWKeuqppxQXF2d4fKMkJiZq2LBhqlmzpjZs2GBY3BUrVqhy5cr66KOPDIv5X1OmTFGdOnW0b98+t2PNmDFDDz30kE6ePGlAzdK2atUqlStXTlOmTHH7D9RL0k8//aQKFSpo06ZNBtTOO/49B2PGjNGNGzcMj3/+/Hk988wzateunW7duuVWrLVr16p8+fL66quvDLle/9q7d68aNmyo/v37686dO4bF9UcTJkxwKc/fnTx5Ug0aNFD//v11/vx5w+LOnj1bFStW1C+//GJIPO5ha7Nnz1a1atUM6ffi4+P1wQcfqFq1aob0Sf7AE2MDT48L7hWI7Y7Zxw+0Rakz09gIxjPb82HWOaTRzDIWNJJZr71Z1w/+7RvM0u/Tl7nPbP1BIJg5c6Zq166ttWvXer1srrfrmNN7j5nadjM8U2Y6n+56++23FR0drUuXLrkd68KFC+rRo4c6duyo+Ph4A2oXuMy+duQusz1jZp1f3csf1mHN0Af4Uno/P4mJiXr//fdVpEgRjRgxQgcPHnTq+Dt37mjOnDl65JFH1KVLF507d85DNTU/s7XD7mK847j01g5xb/g/s6ztB8p40Wx8uV4Y6L777js99NBD2rlzp9uxPLmmZ9b/U7oX97J/cGc+EohzEV/el/Sr/495snPMfu9s3LhRR44csZm3bNky3bx50634v/zyi905+uzZs92K7Qr6PwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC4KygoSIUKFUp1n+PHjzscr3jx4qnmb9261eFY/mDp0qU6duyY3fx+/fo5HCu1fVeuXKm9e/c6VTdHOHLtChcubHi5AAAAAAAAAAAAAAAAAAAAAAAA3hAaGmqxHR8f73bMbdu2ad26dU4dc/HiRd24ccOl8u49LmPGjKnu37JlSwUFBaVsz5s3T3fu3HGpbG/x5vlxxwMPPKD+/ftbpL3++uu6ffu2U3HM8nkBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgvGBfVwAAAH+zc+dOPf7443rggQe0detWt+Pt27dPI0aMUJkyZdSuXTvt3LnTgFp6x8aNG1WjRg01atRICxcudPqPXEtSXFycZs2alRJnz549Hqjp//vzzz9Vvnx5vfDCCzp8+LDTx69evVr16tVTt27dFBcX54Ea2nf58mX17t1bZcqU0eTJk3X16lWnjk9KStKyZctUp04dtW/fXhcvXvRQTT0nLi5OgwYNUqFChfTqq69qy5YtbsfctGmTXnnlFZUoUUJfffWVkpKS3K+opEuXLumZZ55RyZIl9eWXX+rChQsuxUlMTNSqVavUvn17lSlTRitXrjSkfv5u7dq12r17t1X6xYsXNXv2bB/UyDjJycmaMGGCChcurGeffVabN292KU58fLxmz56t6tWrq2PHjjpz5oyh9eQetrZr1y7VrFlTnTt31qZNm5w+/uzZsxozZoyKFi2qYcOG+f3LN1zh7tjA2+OC/wrUdsfs4wfaotSZaWwE45nx+TDjHNJoZhkLGs2M196s6weXL182Vb9PX+Y+M/YHZvf333+rdu3aqlWrlsaPH68tW7YoMTHRK2VzvV3HnN57zNS2m+GZMtP5dFdMTIzKlCmj999/X+fOnXP6+OPHj+vVV19V4cKFNXXqVA/UMDCZfe3IXWZ8xsw4v/ovf1mHNUMf4Eucn7vn4K233lLx4sVVpUoVPfPMM5o4caKWLl2qP//8U7t379bWrVu1Zs0azZkzR++9957atWunnDlzqkOHDjZfGJ8pUya75aXX8aUZ22F3MN5xXHprh7g3/J+Z1vbNPl40I1+uFwa6rVu3qmLFiurZs6d27drl9PHeWtMz6/8p3Yt72X+kNh9Jb3MRX9+X9Kv/j3myc8x878TGxtpMnzdvntux4+Li7M7LYmJi3I7vCl+3MwAAAAAAAAAAAAAA4P/Yu+/wqqr0f9hPQglNqlhRQUURBQVBFKyIgiIqlnFgsJdR0HHsfq1jHx0L6ti7YBkFREFQsBdAREUERSyADUYkNKlC8v4xL/yMOQkpJznnkPu+Lq5hr7X2sz9nn73XLhMiAAAAAAAAAAAAAAAAAOmgadOmUbNmzWLH/PDDDyWu16BBg2L7f/755xLXSgf5+fnx0EMPFdm/4447xt57773eOptvvnn07NmzyP4HHnigTPnW56efflrvmGbNmlXItgEAgOSaPXt2DB48uMCf0jyvAZC+zPEAAKQL96YAGybzOwAAABu6BQsWFFjeZJNNUpSk7Jo0aVJgefHixcWOb9++fYHlESNGJD1TOint/imPm266KWrUqLFu+dNPP43BgwdX2PYSqczPCwAAAAAAAAAAAAAAAAAAAAAAAABA6WXl5+fnl2hgVlZFZwGAtNS0adPYa6+9Yo899ogWLVpEixYtomnTplGnTp2oW7duVKtWLZYtWxaLFi2KRYsWxbx582LKlCnxySefxCeffBIzZsxI9UdImo022ii6d+8eHTt2jF133TW22mqraNCgQWy00UaRn58fixYtisWLF8e3334bU6ZMiYkTJ8bYsWNjxYoVKcu85557Rrdu3WKPPfaI7bbbLpo0aRJ16tSJNWvWxKJFiyI3NzemTZsWH330Ubz44osxc+bMlGX9o5o1a0a3bt2iS5cuseuuu0aLFi2iQYMGUb9+/Vi5cmUsWrQofvnll5gyZUpMmjQpXnrppZg7d26qYyfdpptuGgceeGDsvPPOscMOO8S2224bG220UdSrVy/q1asXERFLly6NJUuWxOLFi2Pu3Lnx2WefxWeffRYffPBBfPPNN5WSs1q1atGlS5fo3LlztG/fPpo3bx6bbbZZ1KlTJ3JycmLNmjWxZMmSWLJkScyePTs+//zz+Pjjj2P06NGRm5tbKRlJnebNm8d+++0Xe+65Z2y//fax9dZbR/369aNOnTqRlZUVS5YsiUWLFsWPP/4Yn3zySUyaNClGjRoVv/76a6Vl3JCP4WeeeSb+/Oc/F2ofPnx49O7du8j1WrZsGYcddljsvvvu0bp162jSpEnUr18/srKy1l33v/rqq5g8eXK8++678c4770ReXl5FfpS0U5p7g4cffjjl9wVVQabfP2zIc1GypNO90cEHHxyvvvrquuX1zauUTyaeH5n4DFkRMuFeMNky8bvPxPcHmXrddy0rn0y8HmwI6tSpE1tssUU0bNgwGjZsGHXq1Cly7FdffRVffPFFUrbr+/ZMnynSaW4vTqacU5myP8ujZs2ase+++0anTp2iU6dOseWWW0bDhg2jUaNGUb169Vi8eHEsXLgwZsyYEZ988kmMGTMmPvjgg1TH3iBk6j1kMmXaOZaJz1fpKFOuAali/yTHVlttFd99913CvrPOOivuv//+Sk6UnjJtHi4r9zulU5XmIcdG5siUd/vuF1MjVe8LN3StW7eOnj17Rrt27WKnnXaKRo0aRYMGDdLunV4m/n9KRXEsbxg2tGeRVB6XrqvJtaEdm8Vx7GQW1z8AAAAAAAAAANYq4a9lT8jvageK0rZt22jbtm1E/G+e+fbbb2PChAnlmnMAAIDUOOWUU2Kn1julOgZVxLhx4+KFYS+kOgZAhbns8suiUaNGqY5BFTFs6LAYP358qmMAVIiGDRvG5VdcnuoYVDG33XrbBvc7qgHW2rZjxDHXpToFVcktPVKdAGDDlpWVFR06dIgddthh3c97T5kyJaZMmZLiZADpY9ttt13vf/dlwIABce+995ao3rx582LjjTcusv/ee++NAQMGlKjWdtttF9dff32JxiYyefLkuPnmm4vsb926dUybNq3I/l9++SWaNm0aW2yxRXz33XdRrVq1hOMGDRoUJ5xwQrFZLrvssrjhhhuK3M6WW24ZtWrVikWLFhVbJycnJ1atWlXsmN/r1KlTTJgwodgxxx57bAwZMqTENaGquva6a6N27drekQNUsrU/Z3bPv++JWbNmpToOQJXRf0D/aNGiRTzyyCMx/YvpqY4DUCWs/beLfvYdoHL1Pqp3dO7cOUa9PCrefPPNVMcBqDIOOfSQ6Nq1a7zxxhsxetToVMcBACABv6sdqAh+VztQURo1ahTz589fdx+yevXq2HTTTSM3N7fQ2Pbt28dHH30UERG33nprXHTRRZWatSjHHXdcPPvss+uWp0+fHjvtVPTvv/3www+jQ4cO65abN28es2fPrtCMqVTa/VNWu+++e3z44YcF7mm7d+8eY8aMSfq2ilNZnxegMhxwwAFxaM9DUx2DKsb/DwlUJWt/BgMqk5+5BKoS11pSxb8xA6qSg86OaHdYqlNQ1Yy5O2Lyy6lOAVC5/K729OJnagEAAAAAAAAAAAAqV1ZWVnTs2DFatmzp52mBEivJz3hXr4QcAJDR5s2bFy+99FK89NJLqY6SckuWLIkhQ4bEkCFDUh2lxCZMmBATJkxIdYwyWbVqVYwaNSpGjRqV6igp9d///jeefvrpVMdYrzVr1sQ777wT77zzTqqjkIZmzZoVs2bNiieeeCLVUYrkGC7sq6++ijvuuCPVMdJaJt4bbOgy/f7BXLR+6XRvlJ2dXWA5Ly8vRUmqhkw8P1wn/icT7gWTLRO/+0x8f5Cp133XsvLJxOvBhmDZsmXx9ddfV/p2fd9l55m+cqXT3F6cTDmnMmV/lseqVavitddei9deey3VUaqcTL2HTKZMO8cy8fkqHWXKNSBV7J/kaNiwYZF9CxYsqLwgaS7T5uGycr9TOlVpHnJsZI5MebfvfjE1UvW+cEP3+eefx+eff57qGOuVif+fUlEcyxuGDe1ZJJXHpetqcm1ox2ZxHDuZxfUPAAAAAAAAAAAAAAAAAAAAAAAAAACoaurUqbPeMcuWLUtavV9//bXEtdq1axd//vOfSzz+jxo2bBg333xzmddf66effoqXX345Dj/88IT9xx57bJxzzjmxaNGiImucdtppRfY98cQTsWrVqqhVq1a5s/7R8uXL1zumJMcAAAAAAAAAAAAAAABAOlqwYEFMmzYtdtlll4iIqF69elx77bVx9tlnpzhZyQ0YMKDA8sSJE4sdv9NOO637+7Jly2L27NmFxtSpUyfat28f22+/fdSvXz+ys7NjyZIlMXv27Jg8eXL88ssvyQlfCUq7f8rqX//6V2RlZa1bfv3112PMmDEVsq3iVNbnBQAAAAAAAAAAAAAAAAAAAAAAAACgbKqnOgAAAAAAkHk22mijAstLlixJURIAKBvXMgAAAJJl++23L7Lvhx9+qMQkAABAVeJZhHTl2AQAAAAAAAAAAAAAAAAAAAAAAAAAAID0ULt27fWOWbFiRYnrZWdnF9ufl5dX4lrbbbddicdWtAceeCAOP/zwhH21atWKfv36xT333JOwv1u3btGiRYsiaz/44INJyZjI8uXL1zumTp06FbZ9AAAAAAAAAAAAAACAivb444/Hrbfeum55wIABsWDBgvjHP/4Ra9asSWGy9TvjjDNin332KdD29NNPFzm+WrVqUbdu3XXLc+bMKdDfrVu3+Pvf/x4HHXRQ1KxZM2GN/Pz8mDhxYtx3333x1FNPxerVq8vxCSpWafdPWXXv3j0OOOCAdcv5+flx0UUXJX0761NZnxcAAAAAAAAAAAAAAAAAAAAAAAAAgLLLTnUAAAAAACDztGnTpsDyL7/8kqIkAFA2rmUAAAAkyx577FFk31dffVWJSQAAgKrEswjpyrEJAAAAAAAAAAAAAAAAAAAAAAAAAAAA6SErK2u9Y/Ly8iohSWEtW7ZMyXYTGT16dHz//fdF9p9xxhll6nv77bdjxowZ5cpWnDVr1qx3THZ2doVtHwAAAAAAAAAAAAAAoKLdf//9MXPmzAJtV1xxRUybNi3+9re/xXbbbZeiZMU77rjj4p577inQNmnSpBgzZkyR69SvX7/A8q+//hoREY0bN46XXnopxo4dGz179oyaNWsWWSMrKys6deoUjz/+eHzyySfRvn37cnyKilOW/VMWWVlZccsttxRoe+aZZ+KTTz5J6nbWp7I+LwAAAAAAAAAAAAAAAAAAAAAAAAAA5ZOd6gAAAAAAQGZp2rRpnHbaaQXaPv744xSlAYDScy0DAAAgmbp06ZKw/aeffoqff/65ktMAAABVhWcR0pVjEwAAAAAAAAAAAAAAAAAAAAAAAAAAADZMq1evLra/Zs2aJa613XbblTdO0uTn58fDDz9cZH/btm2jY8eOhdo33njjOOKII4pc74EHHkhKPgAAAAAAAAAAAAAAgKpq6dKlcdRRR8XChQsLtO+4445x5513xtdffx3z58+Pxx57bF3f5ptvHptttlklJ/2fOnXqxMCBA+OZZ56J6tWrr2tfunRpnHrqqZGfn1/kug0aNCiwvHTp0thss83igw8+iF69epU6yy677BLvvfdeHH744aVet6KUZ/+URb9+/aJt27brlletWhWXX355UrdRnMr+vAAAAAAAAAAAAAAAAAAAAAAAAAAAlE92qgMAAAAAAJlj0003jdGjR8fmm2++rm358uXxyiuvpDAVAJScaxkAAADJ1LJly9h7770T9r3xxhuVnAYAAKgqPIuQrhybAAAAAAAAAAAAAAAAAAAAAAAAAAAAsOFasWJFsf0bbbRRiWttv/325Y2TVI888kisWbOmyP4zzjijUNuJJ54YNWvWTDg+Nzc3hg4dmrR8AAAAAAAAAAAAAAAAVdXkyZOjU6dOMWXKlIT9jRs3jrZt265b/stf/hJz5syJRYsWxZtvvhn//Oc/o3PnzhWaMTs7O0466aSYMWNGnHvuuZGVlbWub9myZXHUUUcVmX+tP/47lby8vBg+fPi6f4ezevXqGDRoUPTu3Tu22mqrqFWrVmRnZ8fGG28ce+21V1x11VUxZ86cAjVq164dzz33XIV//vVJxv4prZo1a8b1119foO2ee+6JWbNmJXU7iaTi8wIAAAAAAAAAAAAAAAAAAAAAAAAAUH7ZqQ4AAAAAAGSGDh06xKRJk2L33Xcv0D5w4MDIzc1NUSoAKDnXMgAAgKrpoosuij59+lRI7XPOOafAf9D790aOHFkh2wQAADJHRT2PeBahPDwnAwAAAAAAAAAAAAAAAAAAAAAAAAAAQNWwevXq9Y6pUaNGiev9+uuvxfbXr1+/RHVycnJiyy23LPF2K8OPP/4Yo0ePLrL/z3/+c9StW7dA2+mnn17k+CeeeCJWrVqVtHyJlOS7++233yo0AwAAAAAAAAAAAAAAQGWYMWNG7LbbbnHiiSfGuHHjSrRO/fr1Y//9949LLrkk3n///fjmm2+iX79+Sc927LHHxueffx6PPfZYoX8zM2vWrNh3331jzJgxpa7buXPn6NSpU0REfPTRR9GqVas44YQTYvjw4fHDDz/EypUrIz8/P+bPnx8TJkyI6667Lpo3bx633nprgTo5OTkxePDgqFOnTtk/ZDlU1P5Zn7PPPju23nrrdcuLFi2K66+/Punb+aNUfV4AAAAAAAAAAAAAAAAAAAAAAAAAAMqveqoDAAAAAADp75RTTol77703cnJyCrS/8sorceWVV6YoFQCUnGsZAABA1bPpppvGoEGD4qCDDopFixbFRx99FDNmzEha/U6dOkX//v0T9uXm5sbw4cOTti0AACCzVOTziGcRyspzMgAAAAAAAAAAAAAAAAAAAAAAAAAAAFQty5YtW++Y2rVrl7jenDlzonnz5kX2b7311iWqU7NmzbjwwguLHbPPPvvEkUceWeJsyfDAAw/EYYcdlrCvXr160adPn3j44Ycj4n/5dtxxxyJrPfjggxWS8ffq1Kmz3jFLly6t8BwAAAAAAAAAAAAAAACVIT8/P5588sl48sknY8stt4w999wzOnXqFG3bto1dd901Nttss2LX33bbbWPQoEFxwgknxDHHHBOLFy8uV55DDz00brjhhthtt90K9eXl5cXDDz8cF1xwQfz6669lqp+dnR0REePGjYuuXbvGypUr17vOqlWr4qKLLorZs2fH3Xffva69RYsWcdZZZ8Vtt91WpixlUdH7pzj169ePyy+/vEDbTTfdFLm5uUnf1lqp/LwAAAAAAAAAAAAAAAAAAAAAAAAAACRH9VQHAAAAAADSW3Z2dpx22mmRk5NToP25556Lfv36xZo1a1KUDABKxrUMAACg6jn00EPj8ccfj6ZNm0ZERIMGDWLs2LGx//77x8yZM8tdv1mzZvH0009HtWrVEvbfd999JfqPtAMAABueinwe8SxCWXlOBgAAAAAAAAAAAAAAAAAAAAAAAAAAgKpn2bJl6x1Tu3btEtf78ccfi+3fddddIzs7O/Ly8oodt2TJkrj99tuLHbNixYo48sgjS5wtGUaNGhU//vhjbLnllgn7Tz/99Hj44YfX/b0o7777bkyfPr1CMv5enTp11jumJMcAAAAAAAAAAAAAAABApvnxxx9j6NChMXTo0IiIaN++fXz00UcREfHmm2/GRx99FG3bto1OnTpFgwYNCqx70EEHxeuvvx5dunSJVatWlXrb++67b9x0003RuXPnhP2vvfZaXHjhhfHpp5+WuvYfLVmyJHr37h0rV64s1Xr//ve/o3PnztGnT591bWeffXbcdttt5c60PpW5f4py8cUXR+PGjdct//DDD3HnnXdWyLbS4fMCAAAAAAAAAAAAAAAAAAAAAAAAAJAc2akOAAAAAACkt7y8vDj22GPjl19+iYiI/Pz8uOqqq+K4446L3377LcXpAGD9XMsAAACqlm7dusXLL78cTZs2LdC+9dZbx4cffhi9evUqV/099tgjJk6cGNtuu23C/l9++SVuueWWcm0DAADITBX5POJZhLLynAwAAAAAAAAAAAAAAAAAAAAAAAAAAABV08KFC9c7pkmTJiWuN23atGL769SpEzvvvHOJ66WbvLy8eOSRR4rs32OPPaJt27bRoEGDOOaYY4oc98ADD1REvEIaNWq03jGLFi2qhCQAAAAAAAAAAAAAAADp46OPPoqLLroounfvHhtvvHH06tUrPvzwwwJjOnToEDfeeGOp6m611VYxbNiwePvtt6Nz586F+t97773Yb7/94qCDDopPP/20XJ9hrbvvvjt+/vnnMq172WWXRX5+/rrl5s2bxy677JKUXImkYv8k0qhRozj33HMLtP3jH/+IFStWJHU76fJ5AQAAAAAAAAAAAAAAAAAAAAAAAABInuxUBwAAAAAA0t+PP/4Yffr0iblz50b37t3juuuuS3UkACgV1zIAAICq44033ohJkyYl7GvSpEm89NJL8dprr8URRxwROTk5Ja7boUOHeP7552PChAmx+eabFznur3/9ayxevLjUuQEAgMxXEc8jnkUoL8/JAAAAAAAAAAAAAAAAAAAAAAAAAAAAUDUtXrw4lixZUuyYrbbaqsT1Pvnkk/WO+ctf/lLieuno4Ycfjry8vCL7Tz/99OjXr1/Url07Yf+CBQtiyJAhFRWvgJJ8d999910lJAEAAAAAAAAAAAAAAEhPq1evjpEjR8aee+4Z999/f4G+AQMGxCabbFKiOoccckh8+umn0bt370J9H374YRx88MGxzz77xDvvvJOU3Gs9//zzZV531qxZ8dFHHxVo23333csbKaFU7Z9Ezj333KhXr9665a+++ioee+yxpG4jnT4vAAAAAAAAAAAAAAAAAAAAAAAAAADJUz3VAQAAAACAzPDaa69FixYtYsWKFamOAgBl4loGAABQNeTl5UXfvn1j/Pjx0aRJk4RjDjzwwDjwwANj5cqVMWnSpJgxY0Z8//33sWTJknXPjQ0bNoyNN944ttlmm9hnn32KrPV7d9xxRwwbNiypnwcAAMgcZX0e+fzzzz2LUGE8JwMAAAAAAAAAAAAAAAAAAAAAAAAAAEDV9d1338XOO+9cZP9WW21V4lrvvPNO5OXlRXZ2dpFjTjzxxLjqqqti1apVpcqZLr7//vt45ZVX4tBDD03Y369fv/jpp5+KXP/JJ5+MlStXVlS8Arbeeuv1jvnhhx8qIQkAAAAAAAAAAAAAAEB6y8vLiwEDBkTHjh1j9913j4iIWrVqxVFHHRX3339/sesee+yx8cwzz0S1atUKtH/66adx5ZVXxogRI5KS8Y//JiUvLy+mTJlSrpoff/xxdOjQYd1ys2bNylUvkcraPyVRs2bN6N+/f4G2f/7zn5GXl5e0baTT5wUAAAAAAAAAAAAAAAAAAAAAAAAAILmqpzoAAAAAAJA5VqxYkeoIAFAurmUAAABVw1dffRWHHnpojB07NurXr1/kuJycnOjSpUt06dKl3Nt89NFH44ILLih3HQAAILNV9vOIZxFKwnMyAAAAAAAAAAAAAAAAAAAAAAAAAAAAVE3ffvtt7LzzzkX2b7fddiWutWDBgvjwww+jU6dORY7ZbLPN4rrrrotLLrmkVDnTyQMPPBCHHnpowr6GDRtGw4YNi1z3wQcfrKBUhW277bbF9s+ZMydWrlxZSWkAAAAAAAAAAAAAAADSW15eXgwcODAGDRq0rm2//faL+++/v8h1dt9993jqqaeiWrVq69oWLVoU5513Xjz22GNJzbdgwYJCy3l5eeWqOW/evALL9evXL1e9P6rM/VMSRx99dDRt2nTd8rx582Lw4MFJq59unxcAAAAAAAAAAAAAAAAAAAAAAAAAgOTKTnUAAAAAAAAAAAAAgGSbOHFidOzYMaZPn16h21mzZk1cccUVceqpp0Z+fn6FbgsAAMgMlfE84lmE0vKcDAAAAAAAAAAAAAAAAAAAAAAAAAAAAFXPJ598Umx/ixYtol69eiWuN2jQoPWOufDCC+OII44occ10M3LkyPjpp59Kvd77778fn3/+eQUkSmzXXXcttv/jjz+upCQAAAAAAAAAAAAAAACZYdy4cQWWmzVrVuTY7OzsGDx4cNSoUWNd29y5c2OPPfaIxx57LOnZFi9eHGvWrFm3nJeXV+6ayahRlMrePyVxwgknFFh+/PHHY9WqVUmpnY6fFwAAAAAAAAAAAAAAAAAAAAAAAACA5MpOdQAAAAAAAAAAAACAijBjxoxo3759XH311bFs2bKk1584cWJ07tw5brjhhqTXBgAAMltFPo94FqGsPCcDAAAAAAAAAAAAAAAAAAAAAAAAAABA1fLRRx8V25+VlRVt2rQpcb2nnnoqfv3112LHZGdnx7Bhw+KCCy6IatWqlbj2H3OlSl5eXjz66KOlXu+BBx6ogDSJ1alTJ1q2bFnsmI8//riS0gAAAAAAAAAAAAAAAGSGX375pcBy48aNixx7/PHHR6tWrdYt5+XlRe/evWPGjBkVlu+bb75Z9/dGjRqVu97GG29cYHnhwoXlrrlWKvZPcXJycqJr164F2p5++umk1U+3zwsAAAAAAAAAAAAAAAAAAAAAAAAAQPJVT3UAAAAAqEj//e9/4+uvvy7UPnfu3BSkAQAAAErKMz0AAMmyfPnyuPbaa+P++++PE088MU499dTYcccdy1zvt99+i7Fjx8Y999wTo0aNSmJSAABgQ5PM5xHPIiSL52QAAAAAAAAAAAAAgA3LjjvuGNttt12qY1CF5ObmxoQJE1IdAwAAAAAAAAAAACihSZMmrXdMhw4dYvz48SWqt3Dhwrjzzjvj8ssvL3ZcdnZ23HrrrdG/f/+49dZb49VXX41vv/222HW23HLL2GuvveKII46I3r17lyhPRXnooYfisssui+zs7BKNX7hwYTz//PMVnOr/adeu3Xqzffjhh5WUBgAAAAAAAAAAAAAAoOJ069Ytfvvtt3j77bfLXSsnJ6fA8ooVK4oce9pppxVY/s9//lPhv6P7/fffjx122CEiIqpXrx477rhjfPnll2Wu17p16wLLs2bNKk+8AlKxf4rToUOHqFmz5rrl3NzcmDx5ctLqp9vnBQAAAAAAAAAAAAAAAAAAAAAAAAAg+aqnOgAAAABUpL///e/x97//PdUxAAAAgFLyTA8AQLL9/PPP8a9//Sv+9a9/xdZbbx0HHHBAtG/fPrbbbrto3rx5NGjQIOrWrRu1a9eOiIiVK1fG8uXL4+eff47vv/8+Pvvss5g4cWK8/vrrsXjx4hR/GgAAIJOs73lkiy228CxCpfOcDAAAAAAAAAAAAACwYdh2u23jgK4HpDoGVcjMmTNjwoQJqY4BAAAAAAAAAAAAlNBPP/0U06dPj1atWhU5pmvXrnH33XeXuOY///nPOP7442Prrbde79htt9027r333nVZZs+eHfPnz4/FixdHTk5O1KlTJzbbbLNo0aJFNGzYsMQZKtp3330XY8aMiR49epRo/KBBg2LFihUVnOr/2X///YvtX716dbz99tuVEwYAAAAAAAAAAAAAAKAC7LPPPnHDDTfEPvvsE5988knsvvvukZ+fX66aLVu2LLA8Z86chOMaNWoUXbp0KdD28MMPl2vbJfH222/HySefvG75yCOPjJtvvrlMtZo0aVLoM0ycOLFc+dZK1f4pTufOnQssf/DBB0mrnY6fFwAAAAAAAAAAAAAAAAAAAAAAAACA5Kue6gAAAAAAAAAAAAAAlem7776LJ554Ip544olURwEAAKoYzyOkI8clAAAAAAAAAAAAAAAAAAAAAAAAAAAAbLheffXVaNWqVZH9+++/f2RlZUV+fn6J6v36669x0kknxdixY6NatWolzrHFFlvEFltsUeLxqfbAAw9Ejx49SjT2wQcfrOA0BXXr1q3Y/gkTJsTixYsrKQ0AAAAAAAAAAAAAAEBy1axZM4YOHRpNmzaNiIh27drFeeedF7fffnu56vbt27fA8uTJkxOO22233SIrK2vd8m+//RbvvfdeubZdEkOGDIk777wzGjRoEBERF1xwQdx7772xZMmSUte64ooronr16uuWJ0+eHN98801ScqZq/xRnxx13LLD80UcfJa12On5eAAAAAAAAAAAAAAAAAAAAAAAAAACSLzvVAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgOQaNWpUsf0NGzaMjh07lqrmm2++GQMGDChPrLQ3YsSImDNnznrHjR8/PqZOnVoJif6nTp06sddeexU7ZvTo0ZWUBgAAAAAAAAAAAAAAIPlWrVoVt956a4G2W265JY488sgy19x7773jr3/9a4G2YcOGJRy7zTbbFFieOXNmrFq1qszbLqmlS5fGww8/vG65adOmMXjw4MjKyipVnV69esXf/va3Am3/+te/ihyfk5MTderUKfCnOKnaP8Vp0qRJgeWS/LugkkrHzwsAAAAAAAAAAAAAAAAAAAAAAAAAQPJlpzoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQXK+//nrMmzev2DFHH310qes+8MADccYZZ8SaNWvKGq1Mvv/++7jpppsqfDtr1qyJxx57bL3jHnjggQrP8ns9e/aMnJycYsc8++yzlZQGAAAAAAAAAAAAAACgYtxxxx0xefLkdcvVqlWLoUOHxlVXXRU1a9YsVa3jjz8+Ro8eHdWrV1/XNnLkyPj4448Tjq9fv36B5fnz55dqe+Vx4403xo8//rhu+fDDD48XX3wxGjRoUKL1Tz311HjuueciOzt7Xdu4cePimWeeKXKdIUOGxNKlSwv8KU4q909RmjRpUmA5Nzc3abXT8fMCAAAAAAAAAAAAAAAAAAAAAAAAAJB81dc/BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyCRr1qyJZ599Ns4555wixxx77LFxySWXlLr2Qw89FNOnT49BgwbFNttsU56Y6/Xbb7/F3XffHddcc00sXry4Qre11kMPPRT/93//F1lZWQn7Fy1aFM8991ylZFnrT3/6U7H948ePj2+//baS0gAAAAAAAAAAAAAAAFSM3377LY477rh47733omnTphERkZ2dHddcc02cdtpp8dBDD8XIkSPj008/LbRuTk5OtGrVKg444IA45ZRTok2bNgX6f/755zj77LOL3Hb16tULLDdv3jzuu+++JHyqiBtvvDG+//77Ivtzc3PjL3/5S7zxxhuRnZ0dERG9evWKb775JgYOHBgvvPBCTJs2rcA6jRs3jm7dusXf//732GuvvQr0/fzzz/GXv/wl8vPzk5I/IrX7pyi1a9cusLxkyZKk5IlIz88LAAAAAAAAAAAAAAAAAAAAAAAAAEDyVV//EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAINM8+eSTcc455xTZ36JFi+jQoUNMmjSp1LXffffdaN26dZx//vlx0UUXRf369csTtZDFixfHo48+GnfeeWfMmjUrqbXXZ9asWTF27Ng4+OCDE/YPHjw4li9fXml56tatG4ceemixY5588slKSgMAAAAAAAAAAAAAAFCxZsyYEQceeGC8/PLLsdVWW61r32qrreLaa6+Na6+9NlavXh25ubnr+s4555y44IILIisrK2HNn3/+OQ488MCYPXt2iXNsvvnmceaZZ5b9g/zOQw89FN9//32xY95+++047rjjYvDgwZGTkxMREU2aNInrrrsurrvuuli+fHnMmzcvVq1aFY0bN45GjRol/Lxz586NQw45pML/TU5l75+SyM/PT0KaxNLx8wIAAAAAAAAAAAAAAAAAAAAAAAAAUH7ZqQ4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAk36RJk2LChAnFjjnjjDPKXH/ZsmVx/fXXx+abbx6nnnpqjBkzJlauXFnmenPmzImnn346jj766Nh0003jvPPOi1mzZpW5Xnk88MADZeqrCH379o06deoU2b9w4cIYNGhQJSYCAAAAAAAAAAAAAACoWJ999lnstttu8cwzz0R+fn6h/urVq8cmm2yybjknJyeysrIS1ho6dGjssssuMXXq1ArLmyxDhgyJAw88ML755ptCfbVr146tt946tt9++2jcuHHCz/vKK6/E7rvvHpMnT66EtAAAAAAAAAAAAAAAAAAAAAAAAAAAkPmqpzoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQMW677bZ4/vnni+zv27dvXHjhhbF48eIyb2PZsmXx6KOPxqOPPhq1a9eO9u3bR7t27WL77bePLbfcMjbeeOOoVatW1KpVK3777bdYvnx5LF68OObMmRPff/99TJ06NaZMmRLffPNNmTNERHz++eeRlZVVrhprDRs2rNy1Fi9enJQ8/fv3L7b/oYceiqVLl5Z7OwAAAAAAAAAAAAAAAOkkNzc3+vbtG//85z/jrLPOimOOOSY23njjEq37888/x8iRI+Puu++OyZMnV2zQJHv//fejVatWcdppp8WAAQNil112KXb8mjVr4o033ojbb789XnnllUpKCQAAAAAAAAAAAAAAAAAAAAAAAAAAG4bqqQ4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUjGHDhsXMmTOjRYsWCfvr1q0bJ5xwQvz73/9OyvaWL18e77//frz//vtJqVfVderUKXbbbbci+3/77be46667Ki8QAAAAAAAAAAAAAABAJZsyZUqcddZZ0b9//2jVqlXsvvvu0axZs2jTpk307ds3IiI++OCDePbZZ+OHH36IqVOnxvTp00u9ndtvvz1uv/32ZMcvk9WrV8f9998f999/f2yxxRax3377xRZbbBGbbLJJbLTRRrF06dKYN29efP755zFu3LjIzc0t9TZ69eoVERH/+Mc/4uqrr17v+HTaP2t17Nixwmqn4+cFAAAAAAAAAAAAAAAAAAAAAAAAACD5qqc6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUDHy8vLi6quvjieffLLIMRdeeGHcf//9sXr16kpMRklcdtllxfY/8MAD8cMPP1RSGgAAAAAAAAAAAAAAgNTJz8+PL774Ir744ouIiGjfvn307ds3IiLefffdGDhwYArTVZyffvopnnnmmQqrX69evYiIWL58eYVtAwAAAAAAAAAAAAAAAAAAgNSoW7duNGzYMKpVq5aw/7vvvqvkRAAAAAAA6ad6qgMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVZ/DgwXHJJZfEzjvvnLB/m222ieOPPz4ee+yxSk5Gcdq2bRu9evUqsn/p0qVx3XXXVWIiAAAAAAAAAAAAAAAANjRdunSJiIgff/wxxUkAAAAAAAAAAAAAAKgM99xzT7Ru3bpQ+1lnnRXTp09PQSJgQ2BuIVO9+eabCdsPOOCASk4CpLuqMF9Uhc9YnKr++dlwbLfddtGzZ8/Yb7/9olOnTrHJJptEjRo1il0nKyurktJlPnNF+vBdUBLJOk4cbxXL/oWqwbkOAEAmqJ7qAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQMXJz8+PSy+9NEaMGFHkmMsvvzyefPLJWLNmTSUmozhXX311ZGVlFdl/++23x88//1yJiQAAAAAAAAAAAAAAANhQZGVlxR133BF77rlnRESMHj06xYkAAAAAAAAAAAAAADJPzZo1E7avWrWqkpOUXPv27df9LPnv1a9fPwVpgA2FuYVMtf/++6c6AlDBknXPXhXmi0z9jOn2HWficyIbhtatW8dVV10Vxx57bGRnZ6c6zgYrU+fKDZHvgpJI1nHieKtY9i8l4T478znXAQDIBNVTHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKhYI0eOjBEjRkSvXr0S9m+33XbRv3//uPvuuys5GYl06dIljjrqqCL7Z86cGTfeeGMlJgIAAAAAAAAAAAAAAGBD0ahRo3jmmWeie/fuERExa9asuOaaa1KcCgAAAAAAAAAAANgQ/O1vf4uGDRumbPuff/55DBkyJGXbB6qWHXbYIb788suEfTvuuGPMmDGjkhMBAAC/5559w5du33G65aHqOO644+KJJ56InJycVEdZr2S/Q161alWsWLEifvnll5g7d258/fXXMXv27MjPz0/aNgDSTdeuXWPvvfcu1D5jxox49tlnKzVL3759Y/vtty/U/tZbb8U777xTqVnYcLnPBgAAKkv1VAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAq3oABA6Jr165Rt27dhP3XXHNNPPXUU5Gbm1vJyfijO++8s9j+AQMGxIoVKyopDQAAAAAAAAAAAAAAQPr56aef4uqrr46IiHHjxqU4TWbZeeedo1u3bhER8dlnn8Whhx4a8+fPT3EqAAAAAAAAAAAAYENw3nnnRfPmzVO2/SFDhsSQIUNStn0AAAAAgMr017/+Ne67777IyspKdZQSqYx3yL/++mt8+OGHMXbs2Bg2bFh8+eWXFbo9gMp20EEHxaWXXlqofeTIkfHss89Wapbjjz8+evToUaj96quvjnfeeadSswAAAEB5VU91AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoOJ9//33cfLJJ8e+++5b5Jjddtst3njjjUpMxR+1bNkyxo8fH+PHj0/Y/91338Xo0aMrORUAAAAAAAAAAAAAAEB6mTt3blx77bWpjpGR3nvvvbjsssuiTZs2ceaZZ8bSpUtTHQkAAAAAAAAAAAAAAAAAAIBSaNOmTdx5552RlZW13rFr1qyJ3377rRJSpV69evXigAMOiAMOOCBuvPHGeP/99+Omm26Kl19+OdXRAAAAAIA0Vj3VAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMrx/PPPx/PPP5/qGBTjq6++inPOOSfVMQAAAAAAAAAAAAAAANiA3XLLLamOAAAAAAAAAAAAAAAUoUuXLnHFFVcUan/33XfjxhtvTEEiAAAoGfeyAMlnbqUojz/+eOTk5CTs++WXX+Lee++Nl19+Ob744otYsmRJJadLH126dImRI0fGa6+9Fqecckp8//33qY4EQAVz/wTFc44AAEBi1VMdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqrpNN900evToUaj9119/TUEaAAAoOfeyAMlnbiWR/fbbL9q3b5+wb+zYsXHMMcfE4sWLKzlVeuvWrVt88sknccQRR8T777+f6jgAVCD3T1A85wgAACRWPdUBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIANzw8//BALFy6s8O18//33Fb4NAAAAAIBUO/vssxO2f/nll3H44YfHihUrKjlR+ZTlHXK1atWiTp06Ua9evWjUqFFkZ2evd50mTZrEq6++Gl27do2JEyeWMS0AAAAAsCGqnuoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMCG54ILLojnnnsu1TEAkmrFihUxadKkIvsAAIDUcs++4Uu37zjd8rBh69q1a8L2Sy65JCOPt/K+Q87JyYmWLVtGu3btolevXnHIIYdEvXr1Eo6tW7duDBs2LNq2bRu5ubll3iYAUDncZwMAAJWleqoDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZILvvvsuOnbsmOoYAABAEdyzb/jS7TtOtzxsuHbaaado3Lhxofb58+fHiBEjUpAo9VauXBlTp06NqVOnxqBBg6Jhw4bxf//3f3HeeedFjRo1Co3fcsst44YbboizzjorBWkBgNJwnw0AAFSW7FQHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACCx1q1bJ2z/4IMPIi8vr5LTpKeFCxfGJZdcEj169IjFixcnHHPaaafF5ptvXsnJAAAAAIB0lZ3qAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAk1rhx44Tt3377bSUnSX9vvPFGnHnmmQn7qlevHn379q3kRAAAAABAuspOdQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEmvUqFHC9kWLFlVykszwzDPPxPjx4xP2de/evZLTAAAAAADpKjvVAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABIrFatWgnbV61aVclJMsczzzyTsL1t27aVnAQAAAAASFfZqQ4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMkyefLkhO2bbrpp1KxZs3LDAAAAAABpqXqqAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVJSGDRvGFltskbAvNzc35s6dm7Rt1a9fP5o1a5aw76effoqFCxcWu37r1q0Ltf33v/+N+fPnJxzfqFGj6N27dxx00EGx6667xrbbbhs5OTnr+tesWRNz586NKVOmxIcffhgvvPBCTJ48ucSfJxlycnKie/fu0b1799h1111jp512ikaNGkVWVta6MatWrYrZs2fH1KlTY9y4cTF8+PD4+uuvKzVnRMRuu+0Whx12WHTo0CHatGkTW265ZYH9mZ+fH4sXL47PP/88Pvrooxg1alSMGTMm1qxZU6L6G2+8cWyyySZF9m+99dYJ2xs0aJDw2CjOqlWrKnwftmzZMmrUqFGofc6cObFgwYJy199oo41iq622KtT+xRdfRH5+frnrt2jRImrXrl2o/auvvorffvut2HWL+j4+//zzcuf6vS233DJ69+4d++67b+y6667RvHnzqFmz5rr+1atXx6xZs2LKlCkxZsyYGD58ePz3v/9NaobSSudzfo899ogDDzww9thjj9htt91i4403jnr16hUYs2rVqvjxxx9j6tSp8cknn8TIkSPjww8/TMr2M3GOL23miP8dA23bto3tt98+GjRoEBtttFGB7/+uu+6KFStWlDpLOh9bERE1atSIAw44IHr06BFt27aNnXfeOZo2bRrVqlVbNyY/Pz8WLlwYubm58emnn8bbb78db7/9dnz66aeVknGtTJxbSqO0x23Xrl3juOOOi7322it23HHHQvviu+++i8mTJ8cbb7wRzz//fPz888+lztSuXbvo27dvdO7cOdq0aRMbbbTRur5ly5bFvHnzYsqUKTF69OgYNWpUzJ49u9TbKK10OmZL+51V1DyTTDk5ObHddtsV2b9kyZL4/vvvy1W/sufEDe1etqQq+1zZYostomHDhoXaFyxYEHPmzCnPRylS48aNY7PNNivUPn/+/FLP/+k+t0Qk/569PNJpf5XGRhttFD179oxDDz00dtttt9hhhx1S8i4i3b7jsuRJ5dxa1HyzdOnSCrsXqV69euywww6F2vPy8mL69OkVss2y2GWXXeKII46IPfbYI9q2bRtbbrllgfcf+fn5sWDBgpg2bdq6e+YxY8Yk5f6jqDl5rU033bTI9tIeExHpNSdWlOKO54YNG5bp/r4iZNo1oaLfo6ZSWe7lq/J70kTS/R0OmS0dn03T5R1qpl1LSipZ9/2l/Z4aN24cxx57bHTt2jXatWsX22yzTYH3hmvf6X3xxRcxduzYuP3220uVp6Kk4zlSWo0aNYojjjgiDjnkkGjbtm1st912Ba6zf9z3Y8aMialTpyY9R3Fc6wAANjxZ+SV8y/L7mz4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAgExSnv/4nd/VDhSlbdu20bZt24j43zzz7bffxoQJE5LyH9wEWJ9DDj0kunbtmuoYVCEzZ86Me++5N9UxACrMKaecEju13inVMagixo0bFy8MeyHVMQAqzGWXXxaNGjVKdQyqiGFDh8X48eNTHQOgQjRs2DAuv+LyVMegirnt1tti7ty5qY4BUCG27RhxzHWpTkFVckuPVCcA2LBlZWVFhw4dYocddlj3895TpkyJKVOmpDgZAACZ5trrro3atWt7Rw5Qydb+nNk9/74nZs2aleo4AFVG/wH9o0WLFvHII4/E9C+mpzoOQJWw9t8u+tl3gMrV+6je0blz5xj18qh48803Ux0HoMpY+3ux3njjjRg9anSq4wAAkIDf1Q5UBL+rHQAAqp4DDjggDu15aKpjUMX4/yGBqsR/m4xU8DOXQFXiWkuq+DdmQFVy0NkR7Q5LdQqqmjF3R0x+OdUpACqX39WeXvxMLSQ2c+bMaN68eaH24447Lp577rnKD/QHjRs3jqlTp8bmm29eqO/nn3+O1q1bx/z585OyrTfffDP233//Qu1z5syJXXbZJXJzc4tdP9F8cskll8Qtt9xSoK1Zs2Zx5ZVXxsknnxw1atQoVcbp06fHjTfeGE899VTk5eWVat3S2GqrreL//u//4vjjj4969eqVev0PP/wwbrzxxhg+fHjyw/1OnTp14vTTT49zzz03WrRoUer1582bFwMHDow77rgjli9fXuzYq666Kq655pqyRi2Vd999N/bdd98K3cYLL7wQRx55ZKH2Rx55JE477bRy1y9qf3Xu3Lnc72GrV68ev/zySzRo0KBA+4IFC2KTTTaJ1atXF7t+Udf+ZP37vH322SeuvPLK6NatW6lqrl69OgYPHhzXXHNNod8FPH78+Nhzzz0LrdOpU6eYOHFieSOn7Tlfo0aNOPPMM+PMM8+M1q1bl6nGDz/8EHfddVc88MADsXjx4jJnycQ5vqSZs7Oz49hjj43TTz899ttvv6hevXqRNZs0abLe6+HvpeuxtdZmm20WF154YZx++ulRv379MtX48MMP46abborhw4dX6LNFJs4tZVHS47Z79+4xcODAaNWqVYlrr1mzJp588sm48sor48cff1zv+D333DMGDhwYnTp1KvE28vLy4umnn44rrrgiZs+eXeL1Siodj9nSzjWDBw8u9zxTkdfyBg0axMsvvxxdunRJ2P/dd9/FwQcfHF9++WWpa6dyTtzQ7mXXJ1XnyqmnnhoPP/xwofZp06bFLrvsUqYc6/Pss8/GcccdV6j96KOPjmHDhpWoRqbMLRGlP88rYr5It/1V0s/YqFGjuPTSS6N///6lnoMq4l1Eun3HZamTyrm1qPlm4cKFsdlmm8XKlSuTnuGYY46J559/vlD76NGj49BDU/tv2GrUqBEnnnhiXHjhhbHjjjuWev2lS5fG4MGD4+abb46ZM2eWOcf5558ft912W5nXL42ffvopttxyy0rZVkTq3iE3b968yO+kadOm8csvv5SoTkXdP6bbNaE4lfketTjpeC9fld+T/l46vcNJt/uEZLnpppvi0ksvLdQ+cuTI6NWrV6VmGT16dPTo0aNQ+9VXXx3XXnttiWpk2v1TUVL9DjWTriVlUZHnc6LvaYsttohrr702TjjhhFK9n3/33XfjqquuirfeeqtUuZItU86RiMLf4SabbBJXXHFFnHHGGZGTk1PqLJWx/9PpWgdQVWVlZUXHjh2jZcuWfp4WKLGSPOdkV0IOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICUyM3NjRNOOCHy8/ML9W2yySbx4IMPJmU7f/vb32L//fcv1J6fnx8nnHBC5ObmJmU7J510UnzxxRdxxhlnRI0aNUq9fqtWreLJJ5+MyZMnR9u2bZOS6fdq1KgRN9xwQ3zzzTdx1llnRb169cpUp2PHjvHCCy/Eu+++G9tuu22SU/5Pnz59YtasWTFw4MBo0aJFmWo0bdo0brjhhvjqq6+ia9euSU5YdtOmTavwbTz33HMJ23v16hVZWVnlrn/44YcXWb+89ttvv2jQoEGh9uHDh8fq1avLXb+smjZtGsOGDYt33nknDjrooFLvx+rVq8dJJ50UU6dOjf79+1dQyoLS+Zzv0qVLTJ48Oe66665o3bp1mes0a9Ysbrnllpg1a1aceOKJSclWlHSf44va5oQJE+LZZ5+NAw88MKpXr56Uuul8bEVEZGVlxYUXXhgzZ86MCy64IOrXr1/mWh07doxhw4bF+++/H5tvvnnSMq6ViXNLRapWrVrcfffd8corr0SrVq1Kve7JJ58c06ZNi549exY5Ljs7O2699dYYN25cdOrUqVTbyM7Ojn79+sWMGTPipJNOKtW6xcmkYzaR3881yZpnKsLmm28e7777bnTp0iVh/9SpU2OvvfaKL7/8slR1031OTLbKuJctSqrPlWeffTaWLFlSqH3nnXeO3XffvcxZitKgQYM44ogjCrX//PPP8dJLL613/VTvr0yTyfurV69e8cUXX8TFF19cpjkoFfepFPTHufXZZ5+NX3/9tdC4hg0bFvk8Xl79+vVL2P7oo49WyPZK6uCDD46vvvoqHnroodhxxx3LVKNu3brx17/+Nb766qu4/fbbo1atWklOmXylvR/JVE2bNi2yb/HixZWYpKBMuyZsyO9R1yrPvXxVf09a1Z5XqDqS+WxaEe9QM+1akgn69u0bM2bMiFNPPbXU7+f32WefePPNN2PIkCFRt27dCkqYXpJ5jvTu3Ts+//zzOOeccyInJ6fU61f0/netAwDY8GWnOgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApLP6m0S0OTiic9+I/U6J6HhURPPdI6rVSHUySuq1116LgQMHJuw76qij4i9/+Uu56u+www7xz3/+M2HfHXfcEa+99lq56q81cODAeOyxx6JevXrlrtWmTZv48MMP46STTip/sP9fs2bNYuLEiXHZZZdFjRrJOUH23nvvmDJlSvTs2TMp9SIiateuHUOGDImnn346mjZtmpSaW265ZYwdOzYuvvjipNQrr2nTplX4NkaMGBErVqwo1L7JJpvEnnvuWa7am222WbRv3z5h32GHHVau2hERvXv3Ttj+3HPPlbt2We2xxx4xderUIrOVRt26deOee+6JBx98MLKzs5OQLrF0PudPPPHEePvtt6N169ZJyRUR0ahRo3j88cdj2LBhkZOTk7S6a6X7HJ9Ip06dYvz48dGxY8ek1k3nYysion79+vHGG2/Ev/71r6hVq1YS0v3PXnvtFR9//HF06tQpaTUzcW6pSNnZ2TF06NA4++yzy1WnQYMGMWLEiPjzn/9cqK9mzZrx8ssvxwUXXBBZWVll3kbNmjXjscceiyuvvLI8USMis47ZRCpqrkm2li1bxvjx46NNmzYJ+999993Ye++946effipV3XSfEytCZdzLJpIO58rSpUvj2WefTdh38sknJy3TWscdd1zCz/r444/H6tWri103HfZXJsnk/XXRRRfFiy++GJtuumm5a1XWfSqF/XFuXbp0aTzzzDMJx1bE99OwYcM45JBDCrXn5ubGSy+9lPTtlUR2dnbcc8898eqrr8Y222yTlJrVqlWL8847L6ZMmRKtWrVKSs2K8uWXX6Y6QqXYdtttE7bn5ubGqlWrKjnN/2TSNaEqvEeNKP+9fFV+T1oVn1eoOpL1bFoR7zUy6VqSKa6//vp46qmnom7duuWqc/TRR8eECROiefPmyQmWxpJ1jlx88cUxbNiwaNKkSblrVcT+d60DAKgaMvMnIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACggm3ZOqLPrRFnPhlxyPkRe58Q0elPEQecEfGnGyLOeS5i35MjatZJdVJK4tJLL40pU6Yk7Pv3v/8dW265ZZnqZmdnx5NPPhm1a9cu1DdlypT4v//7vzLV/aOBAwfGueeem5Raa9WsWTMeffTR+Nvf/lbuWi1btoxx48bFbrvtVqLxq1evjuXLl5dobN26dWP48OFx3HHHlSPh/zRu3DjeeuutOProo8td64+ys7Pj5ptvjssvvzzptUtr2rRpFb6NX3/9NV599dWEfUceeWS5ah922GGRlZWVsK9Nmzax9dZbl6v+4YcfXqht4cKF8frrr5erblntt99+8frrr8cmm2yS1Lqnn356PPDAA0mtuVY6n/Mnn3xyPPbYY1GtWrUSjV++fHksW7Ys8vPzSzS+d+/e8eqrr0ZOTk6Z8iWS7nN8Ittuu2288sor0bBhw6TWTedjKyKiUaNG8dZbb8X+++9fovF5eXmxdOnSWL16dYnGb7bZZjFy5MjYaqutypxxrUycWyrafffdF0cccURSamVlZcUTTzwRnTp1KtD+7LPPRo8ePZKyjYiIa6+9Nvr161fm9TPpmE2kouaaZNt9993j/fffj2222SZh/4svvhgHHXRQLFq0qFR1031OrCiVcS/7R+l0rjz44IMJ2/v27Rs1a9Ys0fZK6uSTT07Y/tBDDxW7Xjrtr0yQyfvrb3/7W9xyyy1FPp+VRUXfp5JYorm1qPmme/fusdlmmyV1+8cee2zCOezpp5+OVatWJXVbJVGrVq148cUXo3///hVSf+01vEuXLhVSPxm+/PLLVEeoFEcddVTC9o8//riSk/xPJl0Tqsp71GTcy1fV96RV9XmFqiMZz6YV8V4jk64lmeLyyy9P6jVpl112iTFjxsRGG22UtJrpKBnnyIABA+Lmm29OQpr/J5n737UOAKDqqJ7qAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAWW2+9dWy73bapjkEV9N3s7+Lbb79NdQwAAAAAAAAAAAAqWJfjIzr3jcjKKnpMzdoRex4XsdP+EUOvjvhlVmWloyxWrVoVffr0iY8++ihq1apVoK9hw4bx+OOPx0EHHVTquhdffHF06tSpUPuKFSuiT58+sWrVqjJnXuuEE06Ic889t1D7qlWr4tVXX43Ro0fH5MmTY+7cubFs2bKoW7dubLrpptGyZcvo0aNHHHLIIdGwYcOEtbOysmLgwIHx7bffxsiRI8uUr3HjxjFmzJjYaqutihwzZcqU+M9//hNjxoyJb775JhYsWBARETVr1oyNN944OnToEAcffHD85S9/SZi1evXq8cQTT8SsWbPigw8+KFPOmjVrxogRI2KPPfYocsyaNWvi/fffj1GjRsWkSZPiv//9b8yfPz+ysrKiQYMG0bJly9h3332jT58+scUWWySscf3118fXX38d//nPfwq0//DDDzFhwoQit92kSZNo2bJlofbc3NyYMWNGCT/l/0ydOrVU48vqP//5TxxxxBGF2o888si45JJLylz38MMPL7a/Z8+ecd9995Wpdrt27RIeqy+++GL89ttvZapZHtttt10MHz486tWrV+SYlStXxhtvvBGjRo2KKVOmxH//+99YuHBh5OTkRJMmTaJNmzbRrVu3OOKII6J+/foF1j3ttNPi008/TWrmdD7nt9122/j3v/8dWUVcwH/66ad4+umn49VXX42pU6fGzz//HHl5eQU+2w477BB77713HH300bHnnnsmrLPffvvFXXfdFX/9619LnK0o6T7HJ1KtWrUYNmxYkdstq3Q+ttZ66qmnol27dkX2v/vuuzFkyJB4//33Y8aMGbFkyZJ1fRtttFG0aNEi9t9//zjhhBNi9913T1hj4403jqFDh0aXLl3KPC9l4txS0Y466qg444wzCrV/++238cQTT8Tbb78ds2fPjhUrVkTjxo1j8803j65du8YxxxwTO+ywQ8KaNWvWjEceeSR22223WL16dVxwwQXRu3fvQuMWLlwYzz77bIwaNSqmT58eS5YsiXr16sWmm24aHTp0iN69e8d+++1XZPZ777033n///Zg5c2apP3emHLOJVNRck2wHHnhgsefbQw89FGeeeWaB601JpNucuCHey/5eOp0rkyZNismTJ8duu+1WoL1Ro0Zx+OGHx5AhQ0r34Yqw4447JrzXeeutt+Lrr78udt102l+ZIFP317777ht33HFHofZ0vk/NNKmeWydNmhSffvpp7LrrrgXaq1WrFn/5y1/itttuK9U2itOvX7+E7Y8++mjStlEagwYNisMOO6zI/ry8vBg/fnyMGDEiPvzww5g7d27k5uZGnTp1YtNNN43tt98+Dj300OjRo0eRx3mjRo3i5Zdfjr322iu++OKLEuWaM2dOscdEs2bNolmzZoXaf/jhh/jhhx9KtI21Jk2aVKrxmah169YJ31tF/O89UCpkyjUh1e9RK0sy7+Wr2nvSynxeSdXxQXpK9f1TaVTUe41MuZZkim7dusW1115bqD0/Pz/eeeedGD58eEyaNCl+/PHHWLZsWdSvXz+aNm0a7dq1i0MPPTS6d+8e1apVK7R+y5Yt44knnoijjjqqMj7GOpl0juy5555x5513Fmov776PSM7+T7d3cwAAVKys/Pz8/BINLO4nigEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0lgJfy17Qn5XO1CUtm3bRtu2bSPif/PMt99+GxMmTCjXnANQUoccekh07do11TGoQmbOnBn33nNvqmMAVJhTTjkldmq9U6pjUEWMGzcuXhj2QqpjAFSYyy6/LBo1apTqGFQRw4YOi/Hjx6c6BkCFaNiwYVx+xeWpjkEVc9utt8XcuXNTHQOgQmzbMeKY61Kdgqrklh6pTgCwYcvKyooOHTrEDjvssO7nvadMmRJTpkxJcTIAADLNtdddG7Vr1/aOHKCSrf05s3v+fU/MmjUr1XEAqoz+A/pHixYt4pFHHonpX0xPdRyAKmHtv130s+8Alav3Ub2jc+fOMerlUfHmm2+mOg5AlbH292K98cYbMXrU6FTHAQAgAb+rHagIflc7kG4OOOCAOLTnoamOQRXk3ShQlbjekgqutUBV4r9NRir4mUugKnGtJVX8GzOgKjno7Ih2h6U6BVXNmLsjJr+c6hQAlcvvak8vfqa26ug2IKJ9r9Kts2pZxODzI36ZVSGR0trMmTOjefPmhdqPO+64eO655yo/0HqcffbZcffddyfs69+/f9x3330lrtWmTZuYNGlS1KxZM+F27rnnnlJlSzSf3HHHHXHKKadEgwYNCoy777774oYbboiffvppvXXr1q0b5513Xlx00UVRv379hGMWL14cO++8c/zwww+lyhwRMXbs2OjWrVvCvu+//z7OP//8GDJkSIlq1a9fPy655JK49NJLIzs7u1D/Dz/8EK1atYqlS5eWOucjjzwSp5xySpH9Q4YMicsvvzxmzJix3lrVq1ePs88+O2688caoXbt2of5FixbFLrvsUqr9edRRR8XQoUMT5jr22GNLXKcy1atXL+bNmxe1atUq1NeqVav48ssvS10zJycncnNzo06dOkWOGT16dBx6aNl+vu3aa6+NK6+8slD7YYcdFi+/XLKHzqKu/aX993nVq1ePjz76aN39xR+tWbMmHn300bjmmmvixx9/XG+9jTbaKP72t7/FFVdcUeA7WbZsWeTm5kazZs0KrdOpU6eYOHFiqXKn8zn/0ksvRa9ehS/ieXl5cdVVV8Wtt94aK1euLFGtiIjOnTvHfffdV+R3dPDBB8fYsWNLVCsT5/hEmS+55JJYuXJlDBw4sFDfggUL4sUXX4yRI0fGZ599Fv/9739j0aJFJd5eOh9bERHnnHNO3HXXXQn7Pv744zjrrLNKdT4dddRR8dhjjxX5vZ1xxhnx0EMPlbjeWpk6tyRLouP2mmuuidNPPz222GKLdW1LliyJCy64IB555JHIy8srsl52dnYMGDAg/vWvf0VOTk7CMX/961/j9ddfj88//7zAfWF+fn4MHDgw/vGPf8TixYuLzX3QQQfFQw89FNtss03C/mHDhsXRRx9dbI0/ypRjtrRzzeOPP17meaa4bUaU/lp+7LHHxuDBgxM+D0REXHfddXHVVVeVOl9E+s+Jf5SJ97JrpeO5ctZZZ8W9995bqH3UqFHRs2fPEmcpzk033RSXXnppofa+ffvGM888U+R66bi/EknWeV7eOpmwv4r6jF999VW0bNmywLh0uU8tLndlf8fJrvN7lTG3DhgwIP79738Xap86dWq0adMmKdto1qxZfPfdd4X2xaeffhq77bZbUrZRGldeeWVce+21Rfa/8sorcfHFF8dnn3223lp169aN888/Py6++OKoV69ewjEzZ86M3Xbbbb33gyVx1VVXxTXXXFOo/eqrry72M6WDyn6H3KBBg3jzzTejXbt2hfqWLFkSzZs3j9zc3BLXS8Y5ngnXhLXS+T1qut7LV7X3pJX5vFKvXr1SP6uk8/W9PIq6hx85cmTCd6IVafTo0dGjR49C7aW5JmXq/dMfVeY71Ey6liRLRZ7PV199dZxyyimF3se9/PLLcckll8S0adPWW7d169Zx1113xYEHHpiw/09/+lM8//zzpcpakdLlHImI+Oyzzwo9cyRz30eUb/9n2rs5gKoiKysrOnbsGC1btvTztECJleRnvAvfpQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAFdW2R0T7XqVfr2adiKOv+d//kt7+/e9/xyuvvJKw79Zbb43tt9++RHVq1KgRgwYNipo1axbqGz16dNxzzz3lyrnWWWedFQ0aNFi3vGjRojjwwANjwIAB8dNPP5WoxtKlS+P666+P9u3bxxdffJFwTP369eOOO+4odb5+/fpFt27dEva9//77sfvuu8eQIUNKXG/x4sVx+eWXR8+ePWPJkiWF+ps1axbXXHNNqXN269YtTjnllIR9y5cvj2OPPTaOPfbYmDFjRonqrV69OgYOHBidO3eOefPmFepv0KBBmXJmml9//TVeffXVhH1HHHFEmWoeeOCBUadO8ZNp165d1zumKIlyLV68OMaMGVOmeuVx7rnnRtu2bRP2LViwIA4++OA444wz4scffyxRvSVLlsQNN9wQ7dq1i5kzZ65rr1OnTjRr1iwpmdP5nG/atGkccsghCfv69OkTN9xwQ6xcubLE2SIixo0bFx07doxhw4Yl7L/22mtLVe+P0n2OT6ROnTpxxRVXFGhbuXJl3HzzzdGiRYs4+eSTY+jQoTFjxoxYtGhRieum87EV8b99ePXVVyfsGzx4cOyxxx4xceLEEteLiBg2bFh06dKlyP100UUXRVZWVqlqRmTm3FLRTj311Nhiiy3WLc+aNSvat28fDz30UOTl5RW7bl5eXtx9991x7LHHxurVqxOOOe+88+K6664rcF+4fPny6NmzZ5x//vmxePHi9WYcO3Zs7LfffkV+L0cccUSp9ncmHbOJFDfXlHWeSbazzjornn322YTPA3l5eTFgwIC46qqrylQ73efEDUm6nitPPfVULFu2rFB79+7dY/PNNy9VnkSysrLi+OOPL9Sem5sbQ4cOLXK9dN1f6SrT91fLli3X/T0T7lMpm8GDB8fy5csLte+yyy7Rrl27pGyjb9++CY/LRx99NCn1S2OXXXaJK6+8MmHf6tWr469//Wsccsgh8dlnn5Wo3tKlS+O6666LXXfdtcjjvEWLFnHLLbeUOTOlt8MOO8R7771X5DF8ww03RG5ubqVmyqRrQlV4j1oR9/JV6T1pZT+vVNVnFTJbRbxDzaRrSaY47bTTYptttlm3vPZ+8LDDDotp06aVqMbnn38eBx98cJH9F198cblzbqjatGmz7u/l2fePPfZYkWPKuv+9mwMAqHqyUx0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANJBzToR+51S9vUbbBqx53HJy0PFOemkk2LevHmF2uvUqRODBg2K7Ozs9da4+uqrY9dddy3UPm/evDjppJOSETMiImrVqrXu78uWLYuuXbvGm2++WaZa33zzTXTq1Ck+/vjjhP3HHHNMdOnSpVTZbrnlloR9n376aXTr1i3hfi6JV155JU444YSEfeecc05suummJa6VnZ0d9957b8K+ZcuWxf777x9DhgwpU87JkydHt27dYtmyZYX69thjj6hZs2aZ6maS5557LmH7kUceWaZ6vXr1Wu+YnJyc6NatW6lrN2/ePNq2bVuo/aWXXorffvut1PXKo2HDhnH11Vcn7MvNzY1OnTrFG2+8Uaba06dPjy5dusQPP/xQnoiFpPs536tXr6hevXqh9v/85z9FHqclsWrVqjjuuONi/PjxBdrHjh0bV111VZnrRqT3HF+UPn36xMYbb7xu+ZdffomuXbvGpZdeGosWLSpTzXQ/tiIiatSoEc8880ysWLGiQPuoUaPi+OOPjzVr1pQp39SpU2PAgAEJ+1q2bBmHHHJIqepl4txSGZo1a7bu7/Pnz48DDjggvv7661LVGDFiRNx2220J+1q1ahV9+vRZt5yXlxdHHXVUjB49ulTbmD17dpx44okJ+6pVqxZnnnlmiWtlyjFblOLmmnTwj3/8I+69996Ezw0rV66MP/3pT0Xef65PJsyJG5J0PVcWL14czz//fKH2atWqRb9+/cqU6fe6desWW265ZaH2QYMGxapVq4pcL133V7raUPZXptynUjaLFi0q8p3IySefnJRtJJq3fvvtt3jqqaeSUr807r///qhRo0bCPIceemg8+OCDZar77bffRqdOnWLChAkJ+88444zYY489ylSbktt1113jnnvuiWnTpsUuu+yScMyrr75a5L1WRcqUa0JVeI9akffyVeE9aSqeV6rqswqZrSLeoWbKtSSTbLXVVuv+npeXF8cdd1yZ7gfz8vLinXfeSdjXoUOH2HfffcucsSoo774/5ZRTkrr/vZsDAKia1v/TogAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQBbQ5OKJ2/fLVaH94RLUaycmT6XbeeefYd999k/pn5513Tkq2//73v3HKKack7Ntzzz3j4osvLnb9jh07xqWXXpqw7+STT46ff/653BkT6d+/f3z88cflqrFkyZI4+uijY8GCBQn7//73v5e4Vt++fWPzzTcv1L548eLo3bt3rFixoqwxIyJi+PDh8fDDDxdqr1mzZgwYMKDEdY466qho2bJlwr7+/fvHxIkTy5wxImLKlClx/vnnr1ueOHFi9O7dO9q2bRurVq0qV+1M8NJLL8XKlSsLte+5556xySablLreYYcdVmB59erV8d577xUa16tXr1LXPuKIIxK2P/fcc6WuVV6nnHJKbLTRRoXa8/Pzo1+/fvHVV1+Vq/6cOXPi6KOPjjVr1pSrzu+l+zm/3XbbJWx/4oknypUr4n/H4cknnxzLly+PQYMGxa677hoHH3xwjB07tty110q3Ob4oO+yww7q/L1y4MPbaa68YN25cuWqm+7EVETF//vw455xzokWLFnHbbbfF0qVLY+HChXHCCSeUK1tExFNPPRWfffZZwr4DDzywVLUycW6pbCeeeGLMmjWrTOtef/31kZubu95xN998c7zyyitl2sbrr79e5Lrdu3cvcZ1MOWaLUhFzTTJkZWXFfffdF1dffXXC/sWLF0ePHj1i6NChZd5GJsyJG5J0PlcefPDBhO1FPcuWxsknn1yqba6VzvsrHW0o+ytT7lMpu6LO/b59+0b16tXLVXuXXXaJNm3aFGofMWJEzJ8/v1y1S2ufffaJLl26JOy76KKLyv18t/Y4T/ReMCsrKy677LJy1d9QleUd8oEHHhhHHHFE9OvXLy6//PJ45pln4ptvvonJkydH//79izxux44dG7179478/PxK/pSZc03YkN+jVsa9fFV4T5qK55Wq+qxCZquI9xqZci3JVFdffXUMGzaszOufdNJJ8dtvvyXsK2rO5X/Ku+8jkrv/vZsDAKiaslMdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADSwfZ7lr9GzdoRW7ctf50NwVVXXRVvv/12Uv9ccMEFScs3cuTIuP/++xP2XXvttdG2beIvslatWjFo0KCoVq1aob777rsvXn755aRl/L133303nnjiiaTUmjVrVlx88cUJ+4488sjYbLPNSlTn7LPPTth+1113xcyZM8uc7/duuummyMvLK9R+wgknlLjGueeem7D9pZdeSto+ffDBB+O+++6L/fffPzp16hTDhw+P/Pz8pNROd7/++mu8+uqrhdqzsrKiV69epaq12267RbNmzQq0vf322wm/p549e5YuaPzv+P6jJUuWxJgxY0pdq7zOOuushO2PP/54jB49OinbmDhxYjzwwANJqRWR/uf8FltskbD9m2++KXeuiIgvv/wyNt100zjhhBNiypQpSam5VjrO8SVxyimnxNdff13uOul+bP3e3Llz48ILL4xtttkmDj/88Jg/f35S8hV1ru6zzz6lqpOJc0tlevHFF8t1r/brr7/G0KFDix3z448/xnXXXVfmbUREPProownbd91118jJySlVrXQ/ZksiWXNNedWsWTOee+65OPPMMxP2z507N/bdd9946623yrWdTJoTNyTpeK6MGzcuPv/880LtrVq1ij322KPMmerXr5/wvnj8+PEJt5dIOu6vdJbJ+ytT71Mpnffeey+mT59eqL1JkyZlevb+vX79+iVsL+p+pyJdeOGFCdtfe+21uPPOO5OyjZ9++ilOP/30hH2HH354tGzZMinb2ZCU5R3ya6+9FsOHD49BgwbF9ddfH3/+859j2223LXIbq1evjmuuuSYOOeSQWL58eSV+usLS/Zqwob5Hrax7+arwnjRVzytV+VmFzJfs9xrpfi3JRJ9++mncdNNN5aoxc+bMGD58eMK+vffeu1y1N2TJ2PcRyd3/3s0BAFRN2akOAAAAAAAAAAAAQMWpXbt2HHXUUQX+NG7cONWxIKM5rwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADZcG2+TnDpNtk5OHQqbOXNmUuudf/75MX369ELtNWrUiMGDB0eNGjUK9d10002x4447FmqfPn16nH/++UnN93vXXXddUusNGjQo5s2bV6i9evXq0aNHj/Wuv/XWW0e7du0KtS9btizuuOOOpGSMiPj222/jtddeK9S+zTbbxE477bTe9TfZZJPo0qVLwr6bb7653PnWys/Pj/79+8fbb7+dtJqZ5LnnnkvYfuSRR5aqzmGHHVao7aWXXoqRI0dGfn5+gfbNN9882rdvX+LajRo1in322adQ+4gRI2LlypWlylleO+ywQ2y//fYJ+2677bakbuv666+P1atXl7tOJpzzOTk5Cdv/eOyUx5IlS5JW6/fSbY4viRdeeCFeeOGFctfJhGMrkfnz58e7776bjGgREfHGG28kbG/Xrl1Uq1atRDUycW6pbMk414YOHVps/8CBA2P58uXl2sbIkSNj1apVhdpr1KiR8HwpiXQ8ZksiWXNNedWrVy9Gjx4dxxxzTML+r7/+Ojp37hyffvppubaTqXPihiTdzpWHHnooYfvJJ59c5kx/+tOfonbt2oXaH3zwwVLXSrf9le4ycX9l4n0qZVPUfHPSSSeVq26fPn0Ktc2dOzdeeeWVctUtrY022igOOeSQhH033XRTUrf10ksvxbRp0wq1Z2VlFXkvQcX58ssvo3Xr1vGPf/wj1qxZk+o466TjNWFDfY9aWffya23I70lT+bziWYVMVZHvNdLxWpKprrzyyqTcJzz22GMJ29u3bx916tQpd/0NUbL2fURy9r93cwAAVVd2qgMAAAAAAAAAAABQcZo2bRpDhw4t8KdVq1apjgUZzXkFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACw4apdPzl16jZKTh0KmzlzZlLrLV++PPr06ROrVq0q1NemTZu47rrrCrTtu+++ce655xYau2rVqujTp0+sWLEiqfnWmj17dowdOzapNVeuXBmPPPJIwr4ePXqsd/2DDjooYftrr70Wubm55cr2R2+99VbC9v3333+96/bo0SOysrIKtX/yyScxbty4ciZjrZdeeilWrlxZqL1bt25Rp06dEtc5/PDDC7WNGDEi5s6dG5MmTSrUd9hhh5W49mGHHRbVqlUr1P7888+XuEayHHzwwQnb33nnnZg2bVpStzVnzpwYOXJkuetkwjm/cOHChO0tWrQoX6AKlo5zfEkMHDgwKXUy4diqDNOnT49ff/21UHv16tWjUaOS3Vxm4txSmT799NP46KOPyl2nuBp5eXnxxBNPlHsby5cvj+nTpyfsS5c5LRnHbEkka64pj6ZNm8bbb78dXbt2Tdj/0UcfRefOnZPyrGJO3PCU91x58sknE95n9+nTJ3JycsqU6eSTTy7Utnjx4njuuefKVC+ZKmtu2VBU9P7K1PtUyuaJJ55I+H6sZ8+esfHGG5ep5j777BNbb711ofZBgwbFmjVrylSzrA4++OCoUaNGofapU6fGG2+8kfTtFXUP06tXr6Rvi+LtuOOO8eqrr8bFF18ctWrVSnWcCpOMa8KG+B61Mu/l19qQ35Om+nnFswqZKB3ea5RUVX0emz17dowYMSIptd5///3Iz88v1F69evXYZpttkrKNDUky931EcvZ/qq91Ea53AACpkp3qAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQDn5bkZw6q5Ynpw6FzZw5M+k1J0+eHFdccUXCvosuuig6d+4cERF169aNxx9/PLKysgqNu/zyy2Py5MlJz7bWmDFjKqTuG2+8kbC9Y8eO61137733Ttj+6quvlitTIhMmTEjYvvPOO6933X322Sdhe0XkrMqWLFmS8DitVatWdO/evUQ1Nt100+jQoUOBtqlTp64771988cVC6/Tq1avEGY888shCbUuXLo1XXnmlxDWSpVOnTgnb33zzzQrZ3qhRo8pdIxPO+Tlz5iRs79OnT7kzVaR0nOPXZ/r06fHOO++Uu05EZhxblSE/P7/IY7hx48YlqpGJc0tlStYx9csvv8S8efMS9k2ePLnIvtKaNm1awvaGDRsmpX55JeOYXZ9kzjVltc0228T7778f7du3T9g/duzY2G+//ZL2vZsTNzzlPVdyc3PjhRdeKNTeoEGDhPe367P99tuve8b9vaeffjqWLVtW6nrJVhlzy4akovdXJt6nUnbz58+P4cOHF2qvUaNGmZ+p+vXrl7D9scceK1O98jjggAMStlfUO4Gi6nbq1ClycnIqZJsUrUWLFnHzzTfHV199FYcffniq41SIZFwTNrT3qJV9L7/WhvyeNNXPK55VyDTp8F6jNKrq89jIkSOTVmvx4sXxzTffJOxr1KhR0razoUjmvo9Izv5P9bUuwvUOACBVslMdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADSwZJfklNn8bzk1KGwmTNnVkjdW2+9Nd58881C7dnZ2fHkk09GnTp14vbbb48WLVoUGvPmm2/GbbfdViG51nr33XcrpO7EiRMjPz+/UHvz5s2jZs2axa7bqlWrhO3jx49PSrbfmzNnTsL2HXbYYb3r7rTTTgnbx40bV65MFPbcc88lbD/yyCNLtH7Pnj0jKyurQNuIESMS/n2t3XffPTbbbLP11s7JyYnu3bsXah85cmSsWLGiRPmSaccdd0zYXhHnT0Ry5pBMOOffe++9hO0nnHBCHHvsseXOVVHScY5fn7feeqtc6/9eJhxblWXRokUJ2xs3blyi9TNxbqlMybz2z507N2H7Bx98UOHbaNiwYdK2UV7lPWbXJ5lzTVm0adMmxo8fHy1btkzY/8wzz0TPnj1j6dKlSdumOXHDVN5z5YEHHkjYfvLJJ5c6y0knnZSw/cEHHyx1rYpS0XPLhqYi91cm3qdSPkXNBUXNHcWpUaNGHHPMMYXaP/jgg/jiiy9KXa+8WrdunbC9qOfI8vrhhx/i+++/L9SenZ1d5H17VbVkyZL45ZdfyvRnwYIFsXLlyhJvq1mzZjF8+PC44YYbKvATpU55rwkb0nvUVNzL/96G+p401c8rnlXINKl+r1EWVfF57J133klqvUT3gBEb9j4sq2Tv+4jy7/9UX+siXO8AAFIlO9UBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAdzPokOXVmJ6lOpjvuuOMiKysrqX9++umnCsman58fxx9/fCxYsKBQ33bbbRevvPJKnHHGGYX6FixYEMcff3zk5+dXSK61vvrqqwqpu2jRopg9e3ah9uzs7Nh2222LXXeHHXZI2J6oXnkl+l4iIho1arTedXfccceE7Z984kRNthdffDFWrlxZqP2www6L7Ozs9a5/+OGHJ6y51pQpU+K7774r0J+VlRU9e/Zcb+1u3bpF3bp1C7U///zz6123IrRs2TJh+5QpUypke998803k5eWVq0YmnPPvvfdezJ8/v1B7dnZ2/Oc//4knnngidt1116RkTKZ0nOPX54MPPijX+r+XCcdWRdpss82iS5cucfzxx0fjxo0TjqlZs2aJamXi3FKZknmuLVmyJGH7jBkzKnwb/x979x0fRbX/f/ydCgFCk96R3qVXASkaSmiKoBSBq7RrRYUrdr6KIvZugCCiSFGqdFBBQLoIAlKlSO89pP7+8AcadzbZMrs7s3k9Hw8fVz9n5pzPzs4pe3Y2N2/evKa14Qkz79nMmDnWuKtZs2ZauXKlihYtalh++fJl/fe//1VSUpKp7Wb1MTGYmNlXfvzxR+3du9ch3rZtWxUvXtzlnEJCQtS3b1+H+ObNmwP++cifY0sw8Nf1suM6Fd5Zvny59u/f77nrg94AARkUSURBVBCvU6eOqlev7lZd7dq1M7w/4+PjPc7PG1WqVDGMb9682Wdtbtq0ya1csqoHH3xQBQsW9Oif/PnzK3v27IqIiFDx4sV15513avjw4Vq9erXT/dqQkBCNHDlSL7/8sp9fqW+YOScEyz5qoNby/xSs+6SB/rzCZxXYTSD3NdyR1T+P7dy509T6Lly4YBgP9J6eFZl97SXvr3+g5zqJ+Q4AACBQwgOdAAAAAAAAAABYSWhoqPLly6f8+fMrf/78ypYtm+FxZ86c0fbt2/2cHQAAAAAAAAAAAADgBr7fBQAAAAAAgDvYTwIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuGr7MqluZykkxPM6Dm6RLp8xLSX40ZEjRzRw4EDNmDHDoez22283PGfgwIE6cuSIr1PTwYMHfVb32bNnVaZMGYd4vnz5MjzPqPzatWs6e/asWanddPnyZcN4dHR0pufmz5/fMH7q1CmvcoKjS5cuacmSJYqNjU0Xz58/v5o1a6aVK1c6PTcyMlJt2rRJFzt58qTWr1+fLjZ37lw9/PDD6WKxsbGaMGFChrl16dLFIXb16lUtWLAgw/N8JU+ePIbxM2d8M4EkJSXp6NGjKlGihMd12KHPJyUl6bXXXtObb77pUBYSEqK+ffuqb9+++vPPP7VhwwZt375de/fuvfnPiRMnTMnfXVYc4zPz66+/enX+P9nh3vJGtmzZVKZMGZUrV0633nqrypcvr1tvvfXmP1FRUaa1ZcexxZ+OHj1qWl3O7qXjx4+b1salS5cM46Ghoaa1YcSf92xmzBxr3BEbG6vp06cre/bsTo/JlSuXPvvsM917772mth3sY2Iw8XdfGTdunMaMGZMuFhoaqj59+uj11193qY5WrVqpZMmSDvG4uDhTcsyIlcYWO7DK9bLjOhXeGz9+vEaPHu0Q79evn5566imX6+ndu7dD7Nq1a5o6dapX+XmqYMGChnFf7g+dPn3aMF6gQAGftZlVJScn6+jRozp69KiWLl2qsWPHqkyZMnrjjTfUvXt3w3NeeOEFbdiwQd99952fs3WPP+eEYNhHDeRa/p+CdZ800J9X+KwCuwnUvsa/WeXzhVWZ/T3vxYsXDeO+3tOzI198x+7t9Q/0XCcx3wEAAARKeKATAAAAcFf9+vU1ZcoUw7Ljx487/QEMgMB799131aFDB4f4smXLNGTIkABkBFfx3gEAsoJRo0apefPmatiwYYYP4t3w3XffOTwoB8B6fvrpJxUpUsQh/tprryk+Pj4AGQG4gc+awF/oCwAAAACsxqzPKXzeAQD4St26ddW5c2e+3wUAAICprPycEfsscAf3C2BNRvOMFeaYrIL9JNcxj8AdVl5DA5nh/gUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK44sVfa9ZNUubln56elSivizc0J/vXNN9/o888/V79+/TI9duLEifrmm298n5Skixcv+qzu8+fPG8Zz5crl9JwcOXIoJCTEIR4VFaVr166ZldpNRm1JUrZs2TI8L0eOHAoNDXWIX79+XdevXzclN6Q3ffp0xcbGOsS7dOmilStXOj2vVatWypkzZ7rYd999p7S0tHSxuXPn6uGHH04Xa9u2rbJly+b0PQ0JCTHMacGCBT65XzPjrP9cv35diYmJPmv30qVLHp9rlz4vSR988IG6du2qpk2bOj2mRIkSKlGihLp27ZoufuXKFe3bt0979+7V3r17tWfPHv3666/aunWrT8cMq43xrjhz5oxX599gp3srM8WKFVPdunVVs2ZNlS9fXrfeeqvKlSunYsWKOW3XTHYcW/ztypUrptWVmpoasDbMEuh71hVmjTXu6N+/v8aNG6ewsLBMj+3evbsGDBig+HhzPgQG05gYTKzSVz7//HO98sorioiISBcfMGCAXn/9dZfq6N+/v0Ps6tWrmjJliik5Sta5XnZh9etlx3UqvDdx4kSNGjVK4eHh6eK9evXS8OHDXVqjREdHG34OnzVrlk/vK2eioqIM5/br168rISHBZ+2eO3fOMB4dHe2zNvG3AwcO6N5771WfPn00ceJEw3vgww8/1LJly3x6H7gq0HNCMOyjBnItbyTY9kmt8HmFzyqwG3/vawR6LrErs/c3fb2nF0x8sbfszfW3wlwnMd8BAAAESnjmhwAAAFhLVFSUypcvb1iWPXt2P2cDwB2FCxc27L+//fZbALKBO3jv4I6IiAiHL4TS0tKUlJQUoIzgDqP3T+I9RHBr0qSJXnrpJbVt2zbQqSBIMbYGVpkyZVSiRAmHeN68ef2fDOBEVh0n+KwJ/IW+YB1ZdTwGAABAcDBzPWvW5xQzP++wXse/cU8gmHA/u47vdgEAAOBLVn7OiO+V4Q7uF8CajOYZK8wxwY79JPcxj8AdVl5DA5nh/gUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK5a/L5UqJyUv7j7566Il47vNj8n+Ncjjzyi5s2b69Zbb3V6zL59+/TII4/4LaerV6/6rO4LFy4YxnPlyuX0nJw5czoty549u9c5mcVZnhcvXvRzJlnH3LlzlZiYqMjIyHTxzp07a9iwYU7Pi42NdYjNmTPHIfbjjz/q0qVLio6OvhnLkSOHWrZsqcWLFxvW3ahRIxUuXNghPn36dKf5+FKg7ssrV654fK5d+rwkJSYmqnPnzlq6dKlq167t1rk5c+ZUzZo1VbNmzXTx5ORkrVixQl999ZWmTp2qa9eumZmy5cZ4b+p1l53uLSPVqlVT37591aNHD5UuXTqgudhxbPG3pKQkn7eRmJjo8za8YaV71hVmjTXuiI+Pd+v4Dz74QKtXr9auXbu8btvuY2IwsWJfOXnypObNm6du3bqli1eoUEGNGzfWzz//nOH50dHR6tq1q0N82rRpunTpkle5WfF6WZmdrpcd16nw3vHjx7VgwQJ16tQpXbxIkSK66667tHDhwkzr6Natm+Hc5e48a5ZArZXPnTtnGM+dO7dP20V6kydPVnR0tD766COHstKlS6t79+6aPHlyADKz1pwQDPuogVzLGwm2fVI+r1hDWlqaYTw0NNTPmThv01mOWZE/9jWsNJfYlT/2DGHMateeuQ4AACBrCw90AgAA+Erx4sXVq1cvw7LLly/r448/9nkOvXr1UvHijr/O2bdvn7799lufty9JgwcPNvyi9uzZsxo/frxfcgAAAFnL+vXrddttt6WL/f7776pSpUpgEoJbjN4/ifcQwevJJ5/UG2+8EZCHkJB1MLYCyAzjBABYA+MxgGBTrFgxVa5cWYULF1blypUdyu+8806FhYXp8OHDOnz4sFJSUgKQpbHcuXOrcuXKKlWqlHLlyqVcuXIpR44cSklJ0dWrV3X58mUdOnRIe/fu1ZEjRwKdLrIQO/crBL9gX88G++uD+7gnrKtjx46qWrWqQ3zKlCn6888/A5CRNHz4cMP4xx9/rMuXL/s5G0fcz67hu10AAAAAAAC4g/0kAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAZrl+WvnlOuuf/pPwlXD9v3XRp/Te+ywv+c/nyZT388MNasGCB02MefvhhXblyxW85paWl+azulJQUw3hISIjTczIqsxJneTp7zfDexYsXtWTJEnXs2DFd/NZbb1W1atW0fft2w/P+fXxCQoKWLl3qcFxSUpIWLVqk7t27p4vHxsZq8eLFhnV36dLFIXbt2rUM+7gvBeq+TE5O9vhcu/T5G86cOaPGjRvr7bff1qBBgxQWFuZVfeHh4WrdurVat26tV155Rc8995wmTpxoUrbWG+NdcfHiRa/ONyuPQCldurRee+019ezZ0zKvwY5jSzDyZX/2hhXvWVeYNdZ4a/ny5Xrvvfc0e/ZshYaGpivLkSOHpk2bpgYNGigxMdGrduz03gQrq/eVuLg4devWzSHev39//fzzzxme2717d+XIkcOwTk9Z/XpZjR2vlx3XqTBHXFycOnXq5BDv16+fFi5cmOn5vXv3dogdOnRI33//vSn5uevf8/cNvl4rc59bx8cff6y+ffuqYcOGDmUDBgzQ5MmT/ZqPFeeEYN1H9dda3kiw7ZNa5V7N6hISEgzjuXLl8nMmUnR0tGHcWY5ZkS/3Naw4lwB2R18CAADI2sIDnQAAAL5y7tw5vfTSS4qKijIsnzt3rv7880+ftR8REaHPPvtMOXPmdCg7ceKEvv32W5+1fUPRokX1ySefGJbFx8dr/PjxPs8BAAAAAKzqrbfe0rBhwwKdBgAAAAAAgCnKlCmjTp06KSYmRo0aNVK+fPkyPP7FF1/Uiy++KOmvH9qtW7dOP/30k+bMmaNNmzb5I+WbChYsqHbt2ql9+/Zq3ry5ihYt6vK5p0+f1ooVK7RgwQJNnz5dly9f9mGmyGrs3K/MEB4erpEjRxo+ezNr1iytX78+AFkBAKwsIiJC8fHxKliwoENZwYIF9fTTTwcgK2nMmDGG8S+//JL1o03w3S4AAAAAAADcwX4SAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBM549Jkx+X2v5XqtJSCglxfuzls9IPn0k7V/grO/jDkCFDMiwfOnSoFi1a5KdsAHuZPn26Onbs6BDv0qWLtm/f7hCvWbOmSpUqlS62fPlyXbt2zbD+uXPnqnv37ulisbGxevjhhw2P79y5s0Ns4cKFunLlitPXAPu7fv26/vvf/+q9997TM888o27duil37txe11usWDHFx8erbdu26t+/v65fv25CtvaTlpYW6BQCpk2bNpoxY4by5s3rcR1nz57Vnj17tGfPHu3atevmv3/00Udq1KiReckCsvc9a4WxZtq0aerTp4+SkpI0duxYjRgxwuGYWrVq6Y033tDjjz/u/wRhGjv0lSVLlujgwYMqXbp0uniPHj302GOPOV0/S1L//v0dYtu3b9fatWs9ysUO18tKuF6wm4ULF+rPP/9UiRIl0sU7d+6svHnz6vz5807PLVKkiFq1auUQnzRpkiXmdmRdn3zyiRo2bOgQb9y4sSIiIpSUlOSXPJgT/McKa3n2SWG2hIQEw3iePHn8nInzNp3lmBX5au3DXAIAAAAA5gsPdAIAAPjK1atXtXTpUnXq1MmwvH379oqLi/NZ+7fffrty5sxpWFa4cGHVrl1bv/zyi8/al6QOHTo4LZs1a5ZP2wYAAAAAK+vSpYuGDRsW6DQAAAAAAAC81qFDBz3++ONq3bq1QjL6i5EZiIqKUsuWLdWyZUs9//zz+u233/TZZ58pLi5OiYmJJmf8t9q1a2vYsGHq0aOHIiIiPKqjQIECuvvuu3X33Xfr/fff1xdffKH/+7//07Fjx0zOFlmJnfuVmcaMGeN0H/WPP/7Q+vXr/ZwRAMDqunTpooIFCxqW9evXT88++6xt5kFYB9/tAgAAAAAAwB3sJwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfOH6Zem7MdL6b6SqraQytaXoAlJEdunqeenUAWnvWmnHcinpeqCzhZmGDBmi2NjYDI+JjY3V4MGD9emnn/olp4iICCUlJfmk7sjISMN4SkqK03PS0tIM4+fPn9fUqVNNycsVZ86cybA8NTXVMB4eHu6LdPD/zZkzR4mJiQ73VpcuXfTqq686HN+xY0fDOpxZsGCBUlJSFBYWdjNWqlQpVatWTdu3b093bKVKlVSpUiWHOmbMmJHp6/AVZ30rIiLCp+16U79d+ryR3bt3q3///ho0aJBatmyp+vXrq27duqpcubJuvfVWZcuWzaNc7rvvPkVHR2c6X7jCamO8P9nt3mrXrp3mzZuXbvxx5vLly9q9e7d2796tPXv2pPvfc+fOGZ6TkJDgVt7/ZMexBb5n5XvWDj788EM9+uijN8eq5557Tq1bt1a9evUcjn3ssce0ZMkSLViwwOP27DYmBhO79JW0tDRNmDBBo0aNShfPnTu3unbtqilTphied+utt6pZs2YO8bi4OI/ysMv1sgo7X6+svE7N6lJTUzVx4kQ9//zz6eLZsmVTjx499Nlnnzk9t2fPngoNDU0XS0tL08SJE32Sqyuc3Ve+3h9ytlbmPg8MZ+u0bNmyqWrVqvr11199noOV54Rg20f191remWDaJ7XC55Ws+Fnl35xdgzx58vg5Eylv3ryG8dOnT/s3kSzGynMJYHdWmOsk5jsAAIBAsecuGAAALpo1a5Y6depkWBYbG+vxAySuaN++fYbl7dq10y+//OKz9iXjL2Ak6erVq1q2bJlP2waCycMPP6zSpUs7xFeuXKl58+YFICPvBeNrAgAAcFW+fPk0YcIEp+WrVq3SnDlztGnTJp0+fVpXr141/GL96tWrvkwTALIkPq8CAG5gTgCAzNWuXVsffPCBmjZtanrd1atX1wcffKAnn3xS//vf/zRt2jRT67/lllv07rvvqnfv3qbWmzNnTg0ZMkT9+vXTSy+9pLFjxzr9wYSVOJv3nn766QBkk7XZuV+ZLTY2VsOGDQt0Gh5jPQkAgTF48GCnZQUKFFC3bt38+qNV2F9m3+1KfL8LY6wH4WvcYwAAwBWsGQDA/4JtP4m5BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5+S+v/5B1lC1alW9/fbbLh379ttva8WKFdq5c6ePs5Ly5Mmj06dP+6TuvHnzGsYvX77s9JyEhASn5wwZMsSMtEzhLM88efL4OZOs5eLFi1q6dKk6dOiQLl63bl0VK1ZMR48eTRfv1KlTuv9OS0vTd99957T+s2fPavXq1WrevHm6eGxsrLZv354u1rlzZ4fzExISMqzf165cuWIY9/V9mTNnTo/PtUufz0hiYqKWLFmiJUuW3IyFhISoRIkSKl++vMqXL68KFSrc/Pfy5csrKioqwzo7duyokSNHavTo0V7lZrUx3p/sdG+VKVNGU6ZMUVhYmGH5mTNn9O2332rp0qXasGGDDh486HYbISEhHudnx7EFvmX1e9bqRo4cqddeey1dLDk5Wffdd5+2bNlieO9//vnnqlmzpo4fP+5Rm3YaE4OJ3fpKfHy8XnzxRYd8+/fvrylTphie069fP4fY9evXNXnyZLfbt9v1CjS7X6+svE6FNH78eD377LMKDQ1NF+/Xr58+++wzp+f17t3bIbZy5Ur98ccfpufoKmf3lbP70Cz58+c3jF+8eNGn7cLYqVOnlJCQoOzZszuUFSxY0OftW31OCKZ91ECs5Z0Jpn1SPq9Yw5EjRwzjhQsXVmhoqFJTU/2SR3h4uAoUKGBY5ixHeM/qcwlgd8x1AAAAWVt4oBMAAMCX5s2bp5SUFMPNxdatWyt79uxON0e81a5du0zLvX0INyORkZFq06aNYdmiRYt89rqBYNSrVy81atTIIR4eHq558+YFICPvBeNrAgAAcNXAgQMNH3Q9deqU7rvvPi1fvjwAWQEAJD6vAgD+xpwAABkbPny4XnnlFUVERPi0nTJlymjq1Knq0qWLHnzwQad/4Mcdd9xxh6ZPn+70B1pmiIqK0pgxY3TnnXeqW7dulv9xs7N57+mnnw5ANlmXnfuV2UqVKqVJkyYFOg2vsJ4EAP8rX7687rjjjgyPGTx4sKZOneqnjBAMnH23K/H9LjLGehC+xj0GAABcwZoBAPwv2PaTmEsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAicyMhITZ06VdmzZ3coO378uIoUKZIuFhUVpalTp6p+/fpKTEz0aW558+bV6dOnfVa3kcuXLzs95+rVq0pLS1NISEi6eP78+c1MzWvO8oyIiFBUVJSuXbsWoMyC3/Tp09WhQ4d0sZCQEHXq1EmffvrpzVjBggXVoEGDdMdt2rRJx44dy7D+uXPnqnnz5ulisbGxev3119PFunTp4nDu4sWLM7y/fS0hIUGpqakKDQ1NFw8PD1eOHDl09epVn7SbJ08ej8+1S593V1pamg4fPqzDhw/rhx9+SFcWEhKiChUqKCYmRoMHD1aVKlUM63jmmWf06aef6uzZsx7nYbUx3p/sdG+NHj3a8HpevnxZzzzzjOLi4rxeD+TKlcvjc+04tsC3rH7PWlVKSooGDhyo+Ph4w/K9e/fqkUceMSwvWLCgJk+erLZt23rUtp3GxGBit75y5MgRLVy4UB07dkwXb926tUqWLKnDhw87nNO3b1+H2Lfffqtz58653b7drleg2f16ZeV1KqRDhw5p6dKluuuuu9LFGzVqpIoVK2r37t0O51SsWFF169Z1iDubV/3l+vXrSk5OVnh4eLp4eHi4cubMqStXrvik3Xz58hnGL1265JP2kLlTp06pZMmSDnFnY5KZrD4nBMM+aiDX8hkJln1SPq9Yw4EDBwzjUVFRqlq1qn777Te/5FGzZk1FRkYaljnLEd6z+lwC2B1zHQAAQNYWmvkhAADY15kzZ7Rq1SrDsqioKN1xxx0+abdkyZKqWrVqhsc0btzYpw8h3nHHHcqZM6dh2cyZM33Wrj9cuXJFv/32281/UlJSAp0SAAAAAJsICwvTI488YljWokULLV++3M8ZAQAAAAAAuC40NFQTJkzQmDFjFBER4bd2e/bsqQ0bNqhYsWJe1XPPPfdo0aJFKlCggEmZZax169b68ccfnf7oGZDs36/MFh4erunTp9NvAABuGzhwoMOPVP+tRYsWqly5sp8ygt1l9N3u1atX+X4XAAAAAAAA6bCfBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzDR27FjVqFHDIb5x40bVqlVLx44dcyirWbOm3njjDZ/nVrhwYb/Xffr0aafnpKSk6NSpUw7xHDlyKHv27Kbl5q3U1FSdOHHCsMyX1xTSnDlzlJiY6BDv0qVLuv/u0KGDQkJCHM7NzNy5cx1ijRo10i233HLzvwsXLqxGjRo5HDd9+vRM6/c1f9+X2bNnV5EiRTw+3y593kxpaWnavXu33n//fVWrVk0vv/yy4XG5cuXSgw8+6FVbVhvj/cku91aZMmXUo0cPh/j169fVpk0bffjhh4ZjnrsKFCjg1fl2G1vgO3a5Z62oW7duio+Pz/CYiRMn6ptvvjEsa9OmjZ5++mmP2rbLmBhM7NpX4uLiHGIhISHq27evQ/yOO+5Q6dKlXaojM3a9XoESDNcrK69T8RdnY0W/fv0M471793aIXbp0yem86U9HjhwxjPtyPeus7uPHj/usTWQsJSXFMB4aGurTdu0wJwTDPmog1/IZCZZ9Uj6vWMPu3bt17do1w7L69ev7LQ9nbZ0/f16HDh3yWx5ZiR3mEsDumOsAAACyNt/uEAIAYAEzZ850WtaxY0eftBkTE5PpMWFhYWrbtq1P2pek2NhYw3hycrLmz5/vs3b9YdOmTapRo8bNf86dOxfolAAAAADYRL169VS8eHHDsp07d/o5GwAAAAAAAPd8/PHHGjBgQIbHpKSkaOXKlRo9erS6du2q+vXrq0mTJg7HPfTQQ+rRo4deffVV/fzzz05/hHpDlSpV9P3336tQoUIe5d68eXNNnTpVkZGRTo9JS0vT5s2bNXbsWPXu3VuNGjVS+fLlVaxYMRUoUEClSpVSzZo1FRMTo5EjR2rhwoVKTk7OsN3atWtr2rRpDj9gBG6wc7/yhTFjxqhhw4aBTgMAYDMRERFO/yDPvw0aNMi3ySBoZPTd7ssvv8z3uwAAAAAAAEiH/SQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGCWdu3a6dFHH3WIX7t2Tb1799bJkyf1n//8x/Dcxx57TDExMT7Nr169ej6pt3jx4ipcuLBDPCkpSX/88UeG5x46dMgwXr16dVNyM8vBgwcN43Xr1vVzJlnLhQsXtGzZMof4HXfcoejo6Jv/3alTJ4dj5s6dm2n9e/bs0a5du9LFQkND1a5du5v/HRsbq5CQkHTHXL9+XfPmzcu0fl/bvXu3YdxXfb1ixYoO18JddunzvpCWlqaXXnpJH3/8sWH5XXfd5VX9Vhzj/ckO91b79u0VGhrqEP/444+1bt06U9oIDQ1VoUKFvKrDjmMLfMMu96wVubIOkaSHHnpIhw8fNix79dVXPe53dhgTg4ld+8r8+fN19OhRh3j//v0dYv369XOI7dmzRytWrHC7Xbter0AJhuuV1dep+GtePHHihEO8T58+huvA+++/3yE2ffp0Xb161Sf5uWPHjh2G8YYNG/qszQYNGhjGt2/f7rM2kbGIiAjDeGpqqk/btcucYPd91ECv5Z0Jpn1SPq8EXmpqqrZs2WJYdvvtt/stD2dtbdq0yW85ZDV2mUsAu2OuAwAAyLocP3EBABBkZs+e7bSsQ4cOPmmzffv2Lh33zy81zObsta1YsULnz5/3WbuBEBkZefPfff0FKAAAyNy9996rWrVqpfunS5cugU4LLjJ6/3gPEUyaNm1qGE9ISPBzJshKGFsBZIZxAgCsgfEYgNU9+OCDGjRokNPyy5cv68UXX1SpUqXUokULPfvss5o9e7Y2btyoI0eOOBy/Y8cOTZ8+Xc8995yaNGmiEiVK6LnnntPp06edtlGpUiUtWLBA4eHhbuVeuHBhTZs2TWFhYYbliYmJeu+991S+fHnVrVtXw4cP11dffaV169Zp3759OnbsmM6cOaPDhw9r27ZtWrx4sV577TW1b99exYsX18svv5zh/k7btm311FNPuZUzsgY79ytfiI2N1bBhwwKdBjwU7OvZYH99cB/3hLV069ZNBQsWdOnYBx54QNmyZfNxRvbC/Wwso+924+Li/JwNAAAAAAAArI79JAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYIZChQrp888/NywbMWKEdu3aJUlauHCh4uLiDI+bNGmSChUq5KsU1bhxY5/U26hRI8P4vn37lJqamuG527ZtM4w3bNjQ67zMtGXLFsO4r64p/jZ9+nSHWGRkpGJiYm7+e9u2bdOVHz58WFu3bnWp/nnz5jnEYmNjb/57ly5dHMqXLFmiS5cuuVS/L90YV/7NV/dlixYtvK7DLn3el1544QUlJyc7xOvXr+9VvVYc4/3JDvdW8+bNDeNTp041rY26desqKirKqzrsOLbAN+xyz9rZ+fPn1bt3b8PxNCIiQlOnTlWuXLncrtcOY2IwsWtfSU1N1cSJEx3i5cqVU7NmzW7+d86cOXX33Xc7HDdu3DiP2rXr9QqUYLheWX2dCik5OVmTJk1yiJcoUUKtWrVKF2vYsKHKlSvncGx8fLzP8nPHb7/9Zhj/57hppkqVKumWW25xiF+/fl379u3zSZvIXMGCBQ3jly9f9mm7dpkTsso+qq/W8hkJln1SPq9Yw9KlSw3j3bt3N/3eNZI3b15169bNsGzJkiU+bz+rsstcAtgdcx0AAEDWFRroBAAA8LVDhw7pl19+MSwrXbq0qlWrZmp74eHhat26tUvH3vjCxGxVq1ZVmTJlDMtmzZrlkzYDJSIiQrlz5775377+AhQAAGRuz5492rp1a7p/nP3gA9Zj9P7xHiKYOHuYe/369X7OBFkJYyuAzDBOAIA1MB4DsLJChQrpzTffdFq+bNkyValSRaNGjdLRo0c9auP48eN69dVXVaFCBad/bFD660c4//d//+dW3aNHj1aRIkUMy7Zs2aJatWrp8ccf1/79+92qV5JOnjypl156SdWqVXP6Q1FJeu6551SgQAG360fwsnu/MlupUqUM/7gC7CPY17PB/vrgPu4Jaxk8eLDLx+bLl0/du3f3YTb2w/1sLKPvds+fP+/fZAAAAAAAAGB57CcBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzTJo0SYUKFXKIL1u2TB988EG62LBhw7R//36HYwsVKqRJkyb5LMdWrVopMjLS9Hrbt29vGF+1alWm565fv94w3rJlS29SMt26desM485euxWFhYUFOgWPzJ49W4mJiQ7xLl26SPrrXsmVK1e6srlz57pc/5w5cxxiMTExCg8PV86cOdWmTRuH8hkzZrhcvy/99NNPhvF27dr5pL3Y2Fiv67BLn/elM2fOaMuWLQ7x6Ohor8ZoK47x/mSHe6to0aKG8Z07d5rWRqtWrbyuw45jC3zDLves3a1cuVJjxowxLCtXrpw+/vhjt+u0w5joLiuvZe3cV8aNG6e0tDSHeP/+/W/+e/fu3ZUzZ8505UlJSfr88889atPO1ysQguF6ZfV1qpX5c2wdN26cYbxfv37p/rt3794Ox+zZs0dr1qzxRVpuW7p0qWG8Y8eOPrmeN/Y+/m3FihVKSUkxvT1krkyZMk7HtCNHjvi0bbvMCcGwj+oqX6zlMxIs+6TB+HnFjr777jvDeK5cudSrVy+ft9+3b19FRUUZli1cuNDn7XvKyp9NXWGXuQT2Zfc+YhbmOgAAgKwrNNAJAADgD7NmzXJa1qFDB1PbatasmaKjo106tlixYqpZs6ap7Ut/fRnsjNGXK3bWokWLdP997NixAGUCAAAAwA6cPYjyyy+/+DkTAAAAAAAA140YMUJ58uQxLJs5c6batWunP//805S2zp8/r0GDBmnAgAFOfxQ8fPhw3XbbbS7VV758eT3wwAOGZWvWrFHz5s31+++/e5ruTfv371fLli21ceNGw/LcuXNr4MCBXreD4GHnfmW28PBwTZ8+Xfny5XMoM/rjLgAA/FPFihUNf4h68uRJffXVV4bnDB482MdZIRjw3S4AAAAAAADcwX4SAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADw1mOPPaaYmBiH+Pnz59WvXz+H+JUrV9S3b1+lpqY6lMXExOjRRx/1RZoqWLCgevbsaWqdBQoU0P33329YtmjRokzPX7JkiWG8U6dOKliwoFe5mcnZa6lSpYpat27t52wyduXKFcN4dHS0nzMxx4ULF7Rs2TKHeIcOHRQeHq7Y2FiHsjlz5rhc/5o1a3TmzJl0sdy5c6tZs2a66667lC1btnRliYmJmjt3rsv1+9LSpUsN45UrV1abNm1MbevWW281pU679PkbihQp4pN6jx49ahjPmzevx3VacYz3JzvcW/ny5TOMJyQkmFJ/aGioHnroIa/rsePYAt+wyz0bDJ5//nlt2LDBsKxPnz7q1auXW/XZYUx0xo5rWTv3lYMHDxqute+9917lyJFDkgw/086dO1enTp3yqE07X69ACIbrldXXqVZghbF17969+vHHHx3i3bp1U65cuSRJYWFhuvfeex2OiY+P93V6LluxYoXh9SxZsqTuueceU9uKiIhwukdolX2JrKhr166G8aSkJO3Zs8enbdtlTrDTPqoZzF7LZyRY9knt/HklmGzYsEG///67Ydnw4cNvfh7whejoaD311FOGZb/88ou2bdvms7ZdZYX1ky/YZS6B9QVrHzELcx0AAEDWFRroBAAA8IdZs2Y5LTP6ssIb7du3N4zPnj3bMG70gw5vOXtNmzZt0p9//ml6e4GSK1cujR07Nl1s06ZNAcoGAAAAgB04exDF0x8aAAAAAAAA+FpkZKQeeOABw7K9e/eqV69eSk5ONr3diRMnaujQoYZloaGhGjVqlEv1HDt2TE8//bTDd9UnTpxQt27ddOnSJa9zveHChQvq2bOnrl27Zlju7Doi67F7vzLbmDFj1LBhQ4f4pk2bDH8gDADAPw0cONAwPmnSJH388ceGZU2bNlW1atV8mRaCAN/tAgAAAAAAwB3sJwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG/UrFlTY8aMMSwbOnSojhw5Yli2evVqvfnmm4Zlb7zxhmrWrGlajv/01FNPKSwszLT6hg0bpuzZszvEr1y5oiVLlmR6/v79+7Vt2zaHeGRkpB566CFTcrwhT548KlKkiEfnHjt2TKtXrzYse+aZZ7xJy8HAgQNVq1Ytj88/d+6cYbx06dIe1xlo06dPd4jlyZNHLVq0UGxsbLr4pUuX9OOPP7pcd2pqqhYsWOAQj42NVZcuXRziy5Yt04ULF1yu35dOnDihNWvWGJaNHDnS1Lb+7//+TyEhIV7XY5c+X6JECX3yySc6ePCgOnfubGpe0l+v18i1a9e8qtdqY7w/2eHeunTpkmG8YMGC3qYkSbrvvvtUrlw5r+ux49gC37DLPRsMUlJSdN999+ny5cuG5Z988oluvfVWl+uzw5jojB3XsnbvK3FxcQ6xXLly6e6771bZsmXVvHlzl85xld2vl78Fy/XKyutUK7DK2Dpu3DiHWI4cOdS9e3dJUtu2bVWoUKF05ampqfriiy/8kp8rEhMTNW3aNMOyZ599VhEREaa1NXDgQBUrVswhfv36dc2YMcO0duC6XLly6cknnzQsW7t2rRISEnzavl3mBDvto5rB7LV8ZoJhn9TOn1eCzSeffGIYv/XWW/XWW2/5rN0PPvhAJUuWNCz7+OOPfdauO6yyfjKbXeYSWF+w9hGzMNcBAABkXaGBTgAAAH/47bfftH//fsOyxo0bK1++fKa1FRMT4xA7d+6cXnjhBcPj27dvb1rbkpQvXz41btzYsGzWrFmmthVIpUqV0sqVK3XbbbfdjFnty3oAAAAA1pM3b17DuLOH6QAAAAAAAAKtQYMGuuWWWwzLnnrqKZ/+SDQuLk5fffWVYVmTJk1UoECBTOu4cuWK3nnnHZUtW1Z9+/bV9u3bJf31x4BOnDhhar6StG/fPqc/QKtYsaKKFi1qepuwH7v3KzPFxsZq2LBhDvELFy6oe/fuun79ul/zAQDYS2RkpPr162dYNmHCBK1Zs0a///67YfngwYN9mBmCAd/tAgAAAAAAwB3sJwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE9lz55dU6dOVbZs2RzKpk+frq+//jrD85977jlt27bNIZ4tWzZ9/fXXyp49u2m53lCjRg2NHTvWlLpatGih4cOHG5ZNnjxZly5dcqmecePGGcafffZZVahQweP8/u2dd97Rrl279Oijjyo0NNTt8z/99FPDeOvWrfXYY495m54kqV69evrkk0+0ZcsWzZs3Tw0aNHC7jiNHjhjGK1SooMKFC3ubYkDMnj1bSUlJDvHnn39epUuXThdbvHix4bEZmTNnjkOsc+fO6tixo0N8xowZbtXtax999JFh/I477tCTTz5pShsxMTG6//77TalLsnafL1GihD7++GPt27dPgwcPVmRkpN5//33lz5/ftLwkqXz58g6xq1evujxuOmPFMd6frHxvSdLp06cN440bN/Y6p+LFi+udd97xup4b7Di2wHx2umeDwb59+/Twww8blkVHR2vq1KkKDw93uT6rj4nO2HEta/e+Mnv2bJ08edIh3r9/fz3wwAMKCQlJFz948KCWLl3qcXt2v17+FizXK6uvUwPNKmPrt99+q7NnzzrE+/XrJ0nq3bu3Q9mSJUt09OhRX6fmljfffFNpaWkO8Ro1aujdd981pY3atWvrzTffNCz74osvDMdt+FZoaKjGjRun4sWLG5ZPmTLF5znYaU6wyz6qWcxey2ckWPZJA/F5BY7i4uJ0/Phxw7LBgwerV69eprf5n//8Rw888IBh2aFDhzRp0iTT2/SEVdZPZrPTXAJrC9Y+Yia77s0BAADAO6zIAABZxuzZsw3jYWFhuuuuu0xpo1ixYqpRo4ZDfPHixdq2bZsOHTrkUNa0aVNFR0eb0r7010OOYWFhhmXOroHd3Hnnndq8ebNq166dLv7aa69p+/btAcoKAAAAgB04+7xk9JAtAAAAAACAFTRq1MgwfubMGc2fP9/n7T/22GPpfgj/+++/a9CgQSpRooTTH/0YSU5O1uTJk1W9enXFxMToiy++8EW6kpThH1GsV6+ez9qFfQRLv/JWqVKlnP44csCAAfrjjz/8lgsAwJ7uvvtu3XLLLQ7x1atXa9euXZKkCRMmGJ7bp08fRUVF+TQ/2Bvf7QIAAAAAAMAd7CcBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABPvf3226pSpYpD/OjRoxo8eHCm5yclJal3795KTEx0KKtatareeustU/L8tyeeeEIPPfSQV3VUqVJFU6dOVVhYmENZcnKy3n33XZfrmjBhgk6dOuUQz5Ejh7766ivlzJnTm1QlSQ8++KD69++v3Llz67333tPmzZvVuHFjt+r4+uuvtWfPHsOysWPHqn379l7lWKRIEc2YMUOhoaGSpI4dO2rdunVaunSpChUq5HI9R44c0Z9//mlYNnToUK9yDJQLFy5o2bJlDvEWLVo4xObMmeN2/YsXL3boh+XKlVO+fPnSxZKTkz2q35dmzJihQ4cOGZa9/vrrio2N9ar+qlWrasqUKV7V8W9W7vOffvqphgwZosjIyJuxUqVKacaMGYqKivI6L0lq0KCBypcv7xB31m/dZbUx3p+sfG9J0u7duw3jgwYN8iqnHDly6JtvvlHBggW9quef7Di2wHx2umeDxaRJkzR9+nTDsvr16+uVV15xuS6rj4nO2HEta/e+kpycrEmTJjnEW7ZsqSFDhjjEx48fr7S0NI/bs/v18rdgul5ZeZ0aaFYZW69fv64vv/zSIX777berevXq6tKli0NZfHy8HzJzz86dO53O10OHDtUTTzzhVf0VKlTQrFmzlD17doeyhIQEvf76617VD/cVKFBAM2fOVM+ePQ3LT548qcmTJ/s8DzvNCXbZRzWTmWv5jATLPmkgPq94+1klGCUkJGjkyJFOyydPnqxhw4aZ1t7IkSM1fvx4p+XDhw9XUlKSae15wyrrJ7PZaS6BtQVrHzGTXffmAAAA4J3QQCcAAIC/zJw502mZtw8X3tCuXTvD+IIFCyRJixYtcigLDw9X69atTWlfcv5a9u3bp+3bt5vWTqC0bt1aCxcu1C233JIu/v777+u5554LUFYAAAAAAAAAAAAA4BvFixc3jP/6669KTk72eftnzpxRXFycli5dqnbt2qlKlSqKi4tTQkKCx3UuXrzYp7lv3LjRaf3FihXzWbuwj2DsV+4KDw/X9OnTHX6IK0kffPBBhs/ZAABwg7M/YP3PH+d/8cUXhvNrnjx51KNHD5/lBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACZ6dSpk4YMGWJYNmDAAJ07d86lerZu3aoXXnjBsGzo0KHq1KmTxzlmJC4uTm+//bbCwsLcPrdDhw5au3atihQpYlj+4YcfateuXS7Xd/XqVb344ouGZfXr19fKlStVqFAht/O84dFHH9Vnn32WLlarVi2tXr1ad911l8v1pKSk6MknnzQsi4iI0Ny5c/XYY495lGPlypW1cuVKlSlTxqGsSJEiOnXqlFv1/fjjj4bx//3vf2revLkHGQbe9OnTMz0mJSVFCxYscLvuy5cvO71m/7R8+XKX+7a/JCUladiwYYZl4eHhmj17tp5++mmP6m7durV++ukn5cuX72bsyJEjHtX1T1bu888//7zS0tIc4q1atdLy5ctVsmRJj/OSpLx582rChAmGZQsXLvSq7n+y0hjvT1a+tyRp8eLFhvG2bdvqP//5j0c5FStWTKtWrVKjRo1uxjZv3uxRXf9kx7EF5rPTPRtMBg4cqEOHDhmWDR8+XK1bt3apHquPiRmx21o2GPrKuHHjHGIhISEO90hKSori4+O9aisYrpc/2f16HT16NN1/Z9V1qhVYZWyNi4tziIWEhGjKlCnKmTNnuvi5c+c0Z84cf6Xmlscee0wXLlwwLHv77bf16aefKjIy0u1627Ztq/Xr16t06dKG5S+//LL279/vdr3wTPny5fXCCy9o79696ty5s9Pj/ve//+nKlSs+z8dOc4Kd9lHNZNZaPjPBsE8aiM8rZnxWCUYTJ07U0qVLDctCQkL01ltvaebMmapcubLHbVSrVk3z5s3Tq6++6vSYuXPnatq0aR634QtWWT+ZyU5zCawvGPuImey8NwcAAADPhQc6AQAA/GXNmjU6efKk4QZHTEyMQkNDlZqa6lUb7du3d4ilpaVp0aJFkqT58+dr4MCBhufNnj3bq7YlKTQ0VDExMYZls2bN8rp+IyVLllT+/PmVJ08eZc+eXVevXtWlS5d06tQphwcwzPDjjz9q3bp1aty4saS/Hhx97LHH9Mknn5jellX4+xpbSbFixVSgQAFFR0crZ86cSktL04ULF3T27FmdO3dOZ8+eNXyIHsErPDxct956q/Lmzavo6GiFhobq2rVrOnPmjA4cOKBr164FOsV0snL//beQkBCVLVtWt9xyi3Lnzi1Junjxoi5cuKADBw4oMTExwBk6stP7lytXLpUsWVJ58uRRdHS0kpKSdOnSJZ0+fVoHDx4MdHoBExERobJly9pmzPgnO+duJrtdB/pietHR0SpZsqRy586t6Ohopaam6uLFi7p48aIOHjyohISEQKcY9Oy+nrbbGGAXdruuOXPmVOnSpZUnTx7lypVLiYmJunjxoo4dO6bjx48HOr2gUqBAAeXPn1958+ZV7ty5FRoaqitXrujixYs6deoU1ztI2X2ugL0+u1oV61ZYSTDcj3Zbb1qJndZjdpt/7JavkX/+oZt/OnbsmN9yePrpp223Njx+/LhKlCjhEHd2PZG5YJirbqBfSWPGjFHDhg0d4ps2bXL6Y2sgq7P7OMh63Xey6rWtVKmS4Q9zL126lO6PS5w8eVLfffedunTp4nDs4MGD9fnnn/swS7grq97PdmCXPX077XHAvnLlyqUSJUrcXJeFhobq0qVLunDhgg4fPqzLly8HOkXYWDDsJ7rDjuN2WFiYypYtq3z58vFMsh/YaX3Ic0YZs+Pz/AgcfrtjL3Z+/cwz9mX3/XL4lt3mEcneY6m37D6+2em9s/qell32oG+w+70r2ev+BQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMEvjxo2VnJzs83ZSU1M1e/Zsl44tWrSo4uPjDcs+/vhjLV682K22x44dq06dOqlJkyYOZfHx8apevbqOHz/uVp1GNm/erDp16tz87yeeeEIdOnTQs88+q2+//VZpaWkZnl+jRg29+uqrio2NdXrMgQMH9MILL7id2yeffKIePXqoRYsWDmV16tTRb7/9ppdeeklxcXEu3w81atTQG2+8oZiYGMPyDRs2aOnSpW7lOW/ePH3++efq16+fQ1lYWJjeffdd9enTRyNHjtSSJUsyrS9Xrlx6/PHH9cwzzyhHjhwO5WlpaXr88cczfW/+7dNPP1Xv3r0d4pGRkVq2bJnefvttffLJJzp48KBb9QbS7NmzFRcXp4iICKfHrFmzRmfPnvWo/jlz5ujOO+/M8Jjp06d7VLevffvtt/ruu+/UsWNHh7LQ0FC98cYbuu+++/TMM8+4ND5VrlxZI0eOVO/evRUSEnIznpCQoOeee04TJ070Omer9vlffvlFn3zyiYYOHepQ1rhxY+3YsUNvvPGGPvnkE50+fdqlvG6466679MEHH6hChQqG5TNmzHCrvn+z8hjvT1a9tyTpp59+0unTp1WgQAGHsri4OBUrVkyvvfaaS3lFRkZq8ODBev7559PVd/78eb3wwgv67rvvMq0jM3YcW2Auu92zweLChQvq1auXVqxYodDQ0HRlISEhmjx5smrWrOnSPGTlMTEjdlvLBkNf2bNnj1asWGF4r/zTwoULdfToUa/aCobr5U92v16fffaZ+vTpo/Lly9+MZdV1aqBZZWzdvn271q5dq0aNGqWL16hRw+HYKVOmKDEx0af5eOrEiRMaPHiwvv76a8PyQYMGKSYmRs8995ymTp2aaR+tVq2aXnnlFXXp0sXpMatWrdLYsWO9STuoebOHHBoaqpw5cyo6OloFChRQ1apVVbNmTVWqVCnTc6dNm+a3zzJ2mxPsso9qJjPX8hkJln1Sf39eMeOzSrC6//77tXHjRpUuXdqwvGvXrurUqZOmTZumWbNmafny5Tp37lyGdd5yyy1q3bq1unXrpu7duzv0iX/au3evHnjgAa9egy9YZf1kJrvNJbC2YOwjZrPr3hwAAAA8Fx7oBAAA8Je0tDTNnTtXDz74oENZ/vz51bhxY61evdrj+sPCwtSmTRuH+KZNm3Tq1ClJ0vLly5WYmKjIyMh0x7Rr187jdv+pSZMmypcvn2HZrFmzTGmjZs2auueee9S6dWvVqFFD0dHRTo89f/68tm7dqoULF2rWrFnatWuX1+2npKSoZ8+e+vXXX3XhwgX17NlTa9eu9aiuRo0aqVSpUg7xefPm6dq1a07Pq1ixourWrauqVasqX758yp07d7ovwb7//nuNGzfOo5ykwF/jQKpTp466dOmiVq1aqXr16sqTJ0+Gx1+8eFGrV6/WypUrNX/+fG3bts3tNsuXL5/uYXYjRl9SSFKlSpV07733ut3mtm3btHPnTrfPc1WwvaYaNWqoR48e6tChg6pWreowht6QlpamXbt26YcfftD06dP1448/+iSfjGTl/mukbNmy6tGjhzp16qTbbrtNUVFRhsclJyfr999/18qVK/XNN99oxYoVSk1N9XO29nr/IiMjFRMTo+7du6tRo0YqV65cuh87/NPVq1e1bds2LViwQN9++622b99ueFyhQoVUvXp1h/iePXt0+PBht/IzmmOPHDni9lrLk7m6Vq1auv/++3XnnXcGdMwIxtyz2nvoCqv3RX/LmzevYmNj1blzZ9WtW1dlypRxemxqaqr27Nmj9evXa/bs2Vq0aJGuXr3qdQ7FihVTs2bNMjzG2XxUt25dt9dBf/75p9asWePWOb4UiPV0RoJ9DHAHY6vrsmXLppiYGN19991q3LhxhmPr2bNntXbtWs2cOVPffPONLly44NPc8ufPb7j3I2W+l+CJGw80/tucOXN0/fp1r+svWbKk7r//fjVr1kz169dX4cKFMzz+/Pnz2r59u5YvX665c+dq06ZNbrdp5c+rgd4nMnOcyIjV5gorC/Q94UygPrtWr15dVatWNSybOXOmz/64UosWLQzHp/3792vjxo0e1WmFdauvWGWukjKfr6w6J/hrPL7BivejndebrVq1cnrf+Oo99EYg1mOestPeqWS/fF3h7AdOKSkpfsshkD+A9NTly5cN487GKV/xZt4L9Pd2VpyrzJLV+1VsbKyGDRvmEL9w4YK6d++upKSkAGTlOquuJ6XAfp7093rW3wLx+qw2Dtp5ve4L7L0H3qBBgwzjU6dOdbj/x40bZ/jHaRo2bKhatWrp119/9UWKtpEV72d/f7crZf79rtX2he2yp893Tul5cx/16dPH43vITvvDnihQoIBiY2PVsWNH1alTR6VLl3b6PXJaWpr27t2rn3/+WdOmTdPixYvd/qxn1XvMzu+z1cbYfwrG/cSMWGFv2pP74cbz5O3atVO1atWULVs2w+N4JtmRXdaHnrDyc0ZWEYjn+TN6vmDZsmUe/5FBV9x6662qV69eulhaWprX/ycazlh1zeApfrtjH1Z6/cwzf8kK84wV9sutuJ/krWCaS+w0j0jWGkv9zZ3xbcGCBZYb2+z03vl7T8tddtmDviEY5mY73b8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC+8vjjj+vxxx/3eTsJCQmKiopy6djJkyfrlltucYjv2bNHTz31lNttp6amqk+fPtq6daty5syZruyWW27R5MmT1bZtW7fr/bf+/ftr/fr1ypYt281YxYoVNWPGDJ0+fVqLFi3Spk2bdPz4cZ07d07R0dEqXLiwKlSooJiYGFWqVCnD+q9du6YuXbro0qVLHuV37733asOGDSpVqpRDWcGCBfXRRx/phRde0MKFC7Vs2TIdPnxYJ0+e1NWrVxUZGano6GiVKlVKNWvWVPv27dWoUSOnbR07dkzdu3dXamqq23kOHjxYFStWVJMmTQzL69atq8WLF+vUqVNasmSJfvnlF508eVJnzpyRJOXJk0dly5ZVgwYNdOedd2Z437322mtavny52zmuXr1aq1atUrNmzRzKIiIiNGLECI0YMUJHjhzRoUOHdOnSJcNrceLECfXr18/t9n3h/PnzWr58uWJiYpweM2fOHI/rnzdvnj766COn5cnJyZo9e7bH9fta7969tXHjRpUvX96wvHbt2lq0aJGOHz+uhQsXauvWrTpx4oTOnTunbNmyKX/+/KpevbruuOMO1a5d27COxx57TPv37zctZ6v2+SeeeEINGjRQvXr1HMpy5cqlUaNG6fnnn9eaNWv0448/aufOnTpw4IAuXbqkq1evKiQkRDlz5lTevHlVrlw51a5dW+3bt1eFChWctjlv3jytXr0609wyYvUx3p+sem9dv35dr776qt555x2HstDQUI0aNUqDBw/W5MmTtXLlSu3atUvnz59XQkKC8uTJo0KFCql8+fK666671KFDBxUtWjRdHWlpaXrggQd06tQpF66Sa+w4tsA8drxng8WqVav02muv6dlnn3UoK1q0qD7//HN17NjRpbqsOiZmxG5r2WDpK3FxcWrRokWmx3grWK6Xv9j9eiUkJKhPnz5asWKFIiMjb8az6jo1kKw0tsbFxWU4n9wQHx/vVTu+NnXqVFWvXt1wvpak0qVLa/Lkyfrwww+1ePFirV+/XsePH9eZM2eUM2fOm/d5u3btMr3P9+/fry5duiglJcUXLyUo+GsP+Z8WLVqkvn37+q09O84JdthHNZuZa3lngmmf1J+fV8z4rBKsTp8+rfbt2+uHH35QoUKFDI8JCwvT/fffr/vvv1+pqan6/fffdeLECZ06dUpnz56V9Nf3WQUKFFCRIkVUuXJlhYSEZNr20aNH1b59e50/f97Ml2QKK62fzGLHuQTWFYx9xBfsuDcHAAAAz4WkpaWluXSgCx+aAQCwuvbt22v+/PmGZa+//rqeeeYZj+u+/fbbtXLlSof4qFGj9OKLL9787+XLl6tVq1YOx1WrVk07duzwuH1JGjNmjIYPH+4QP3nypIoUKSIXp31Dd999t5577jnddtttHtexfPly/d///Z9WrFjhcR03NG7cWDt37vRqs/7rr79Wz549HeKlS5fWoUOH0sWio6P18MMPa8CAAU4fTr1h/Pjxeuihh9zOx2rX2F9CQ0PVo0cPjRw5UtWrV/eqriVLluj111/XDz/84PI5Q4cOzfCLRl944IEH9MUXX/isfiu/Jmf9bvbs2eratWu6WM2aNfXaa6+pffv2HuW0Y8cOPffcc5o1a5ZH57sjK/Rfd967cuXK6ZVXXtG9996r0NBQt9s6cOCAXnvtNU2cOFFJSUke5+wqO71/UVFRevTRRzV8+HDlz5/fozoWLVqk559/Xhs3bkwXv/feezVt2jSH45988km9/fbbbrVhdL8Y3Sue1CMZz9V16tTR2LFjDddZrjB7zAjG3LPae5gRu/RFf6lQoYL+97//qXfv3ukevHbHlStX9Nlnn+nNN9/UsWPHPM6lU6dOXj2E5q4PPvhAjz76qN/aMxLo9XRGgnUM8ARja+Zy586tRx55RE888YThH8PIzMWLF/XRRx/p1Vdf1ZUrV9KVHT58WCVKlHA4x92xtUGDBlq3bp1hmdH191aTJk0Mf8BduHBhnTx50uN6mzZtqhdeeEFt2rTxaL1+w86dOzV27Fh9+eWXLq/b7fh51V/7RGaOE/9mx7nCjNftrUDfE/8W6M+uzZs3d3pely5dfLIGi4qK0okTJxQdHe1Qdu+992rGjBlu1Weldeu/mdUXrDJXSZnPV1adE/w1LtnxfrTDevOnn34yfEhcssbcckMg12PuCvT84y675euODz/8UP/9738d4nPnzlXnzp1dqqNUqVI6ePBguljTpk21Zs0aU3K0okOHDqlkyZIO8WeeeUavv/663/Lw97xnxneRVp6rzJKV+1WpUqW0ZcsW5cuXz6Hs7rvv1syZM9PF5s2bZ/gD40GDBpnyx1w8YdX1pBTYz5P+2Id0ty4r5uQKq46Ddl6v+wJ774GVLVs2HT161PD70oYNG2r9+vXpYqGhoTp8+LCKFSvmcPynn36qIUOG+CxXSU6fnSxevLiOHj3q07ZdkRXvZ39/tytl/v2uFfaFrbyn/29852TMF/eRK/eQnfaH3VGrVi3973//U/fu3RUWFuZRHSdOnNCoUaMUFxen5ORkl86x6j1m5/fZCmPsvwXzfqIRs8btAQMGeL0v7c79UK9ePb366qu68847PWqLZ5Ltsz50hx2eM/IFuzzPn9HzBSNGjNAbb7zhdj6u+uqrr3T//feni33//fdq3bq1T9qz6ppB4rc7GbHT/P1vVnz9zDOO3J1nrDDHZMRK++VW3E/yllXnkmCdRyRrjqX+4s34ZoU1tJ3eu0DtabnCTnvQNwTDZ0A73b8AAAAAAABZjTd/n5W/1Q7AmZo1a6pmzZqS/hpn9u/fr7Vr13o15gCAq9q1b+fx8zmAJ/744w99/NHHgU4DAHxmwIABqlK1SqDTQBaxZs0azZpp779BAAAZGfnsSMO/eQX4wsxvZ+rnn38OdBoA4BN58+bVs889G+g0kMW89eZbOn78eKDTAACfuLW+dM//BToLZCVvxAQ6AwAIbiEhIapXr54qVqx483nvrVu3auvWrQHODAAAAHYz6v9GKSoqij1yAPCzG8+ZffThRzpw4ECg0wGALGPof4eqbNmymjBhgn7f+Xug0wGALOHGbxd59h0A/Ktrt65q0qSJFsxf4PP/jwUAwN9u/F2s77//XgsXLAx0OgAAADDA32oH4Av8rXYAVnPHHXeofQfP/j/YAW+wNwogK2G+RSAw1wLISvj/JkMg8MwlgKyEuRaBwm/MAGQlbR+WancMdBbIapZ8IG2ZH+gsAMC/+Fvt1sIztYCxP/74Q2XKlAlY+wkJCYqKisr0uKeeekpjx451iKekpKhJkyZav369xzkMGjRIn376qdN233rrLZfqcTaehISEqHv37po2bZrpv/+5du2aunXrpkWLFnlVT4UKFfT999+rRIkSJmXm6MSJE2rbtq22bdvmcR158uTR/Pnz1bRpUxMzS2/8+PEaOHCgx/ND2bJl9euvvyo6OtrjHA4cOKCyZct6fL7Z+vfvr/j4eKfllSpV0u7duz2uf8uWLapVq5Zh2dKlS3XnnXd6XLeRjPqqJ8qVK6fly5erdOnS3qRl6P3339djjz2m5s2ba8WKFQ7lDRs29Gj8s2qfL1CggBYvXqw6der4LK8bTp8+rdtuu01Hjhxx6Xg7jvFm3+uusOq9FRkZqbVr16p27dqm5zN8+HCNHTtWDRo00Lp16xzKW7RooZUrV7pdrx3HFjP4475duHChYmIc/08s77rrLi1ZssSUNoYNG2a4hnzzzTf19NNPZ3q+ne7ZQIw1vmwzLCxMq1evVsOGDQ3LH330UX3wwQcu1WXVMTEjdlvL2qmvOJMtWzYdPXpU+fPnNyw/evSoSpYsqdTUVK/bstP1Mqufe1OPXa6X0WscMWKE3njjDfXv318TJkyw3DpVssZ77It6jFhlbM2RI4eOHTum3LlzOz1m27ZtN/fQre7VV1/VyJEjfVb/jh07FBMTo8OHD5tW5wsvvKCXX37ZIf7iiy9q1KhRprXjC4HeQ77hww8/1BNPPKHk5GS3zvO2j9tlTvgnq+6j2mUt70ww7ZP66/NKkSJF3D7PDvO7mSpXrqyFCxf6bZzdu3evYmJitG/fPq/qCZb1k7/uEzvOJWawW3+eOHGi+vXr5xB/4IEH9MUXX5jaljeCsY9I5l9/O+7NAUCwCwkJUf369VWhQgWepwXgMlf2nkL9kAcAAJaxbNkyXb582bCsY0fvfjXevr3xHy+dPz/9r4IXLFhgeFy7du28al9y/hrmzp3r8cP9lStX1vr16/XNN9/otttu8yI7qXXr1vrxxx/19ddfK1++fF7V9fPPP+v8+fNe1eGqtm3baseOHRo9erTKly9vev1Wvcb+UL16dW3cuFFTpkxR9erVva7vzjvv1Pfff68vvvhC2bNnNyFD39i+fXugUzCd2a/pmWee0caNG52Ora6oWrWqZs6cqblz5zp9wNBbWbn/OvPoo49q27Zt6tmzp0JDPfvIWaZMGX322Wf69ddfffrjGLu9f3fccYf27Nmj119/3at7OiYmRmvXrtWrr76qsLAwEzMMjJCQEL3wwgvasGGDV390zx9jxr/ZOXcz2e060Bf/lj17dr311lv6/fffNWDAAEVGRnpcV86cOTVs2DD98ccfGjFihMdziL/9/vvvAW0/GNbTdhsD7MJu17VTp07avXu3XnnlFd1yyy0e1ZE7d24988wz2r59u5o3b25yhsEhb968Gj9+vH766SfdeeedXo+1VapUUXx8vLZt26YmTZqYlKX5zP686ut9IrMFw1xhdVll73DlypXatWuXYVn//v29ysuZbt26GT7oefr0ac2ePdvleli34gYr7MsGy/1ot/WmVdhpPWaV+cdVdsvXE2fOnDGMW+kPrFlR4cKFDeNnz571cyb+5c2cFyxzlSuyar8KDw/X9OnTDce4Dz74QDNnzgxAVvaQ1fcYsopgGAdZr/sO1za9e+65xzD/7du3G/4BxtTUVH3++eeGdfXq1Us5c+Y0O0VkIKvez2Z9v+uredwue/p22uMwE+tB/8qXL58mTZqkLVu2qGfPnl49W1O4cGF99NFH2rZtm2rUqGFiluaywh62Ffijb2SF/cR/Mnvc9teYHRYWpldffVXr1q3z6o+G8Uyya+y0PuQ5o8wF+nn+lStXOv1DgkZ/GMksOXLkUOfOnR3iGf3RQzvitzv2HGe9ZffXzzxjT8GwX26GQP9ewBfMnEvsMo9I9h9LveXt+BbIsc1O753V97Tssgf9T3afm+10/wIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGRFderU0ejRow3LRo8erfXr13tV/2effaZFixYZlr322muqXbu2V/VL0owZM9SzZ08lJCR4XdcNJ06c0J133uk0d3fs2bNHjRs39vpaOrN582bVq1dP27Zt86qeCxcuqE2bNoqPjzcps7+lpqZq9OjReuihh5SWluZxPX/88Ye6deumCxcumJhdYM2ePVtJSUmGZbt379bu3bu9qn/u3LlOy2bMmOFV3f6wb98+NW3aVJs3bza13tdff12PPfaYqXXeYNU+f/r0abVs2VKzZ8/2SV43/Pnnn2rWrJmOHDliSn1WH+P9yar3VmJiotq1a6c//vjDtFySkpI0aNAgjR071rQ6/8mOYwvMY8d7NlikpKTo/vvv16VLlwzLx44dq5o1a7pUl1XHxIzYbS0bDH3l+vXr+vLLL52WT5w4Uampqaa0FQzXy5+C4XpNnDhR/fr1c/p5zhN2XacGklXG1qtXr+rrr7/O8Bhf7Lf4yrPPPqsHH3xQV65cMb3u+fPnq2nTpjp8+LDpdcMzW7duVevWrfXII48oOTnZ7+3bcU6wwz6q2cxcyzsTTPuk/vq8gsz9/vvvql27ts/3RCVp+vTpqlOnjvbt2+fztrxhlfWTmew4l8C6grGP+IId9+YAAADgmdBAJwAAgD8lJiZq4cKFhmXVq1dXqVKlPK67Xbt2DrEzZ85ow4YN6WLO2m/fvr3HbUtSmTJlVLVqVcOyWbNmeVTngAED9Msvv6h+/frepOagZ8+e2rZtm6pXr25qvb5w//33a+HChSpRooRP6s/K17hfv37atGmTKT84+rc+ffpozZo1Kl68uOl1eystLU07d+4MdBqmMvM1hYWFafLkyRo9erQiIiJMqTM2Nlbr1q1TmTJlTKnvhqzcf42EhYVpwoQJeu+99xQVFWVKnVWqVNG6dev04IMPmlLfP9nt/Xv++ee1bNky08a1sLAwjRw5UtOnTzetrwVCeHi4vvnmG7388ssKDTVni8NXY8a/2Tl3M9ntOtAX/1apUiVt3bpVw4YNM+29k6Rs2bLp9ddf19q1a1WkSBHT6vWVXbt2BaztYFhP220MsAu7Xdf33ntPc+bMUeHChU2pr3Tp0lq2bJn69etnSn3Bonz58tq4caP+85//KCQkxNS6K1WqpFWrVumZZ54xtV4zmP0Z3Nf7RGYLhrnC6rLa3uG4ceMM4x06dFDBggXNSC2d/v37G8YnTZrk8o/9WLfiBivsywbL/Wi39aZV2Gk9ZrX5JzN2y9dTR48eNYxXr15dhQoV8nM29lCjRg1FRkYalgV6TvAlb+a8YJmrXJVV+9WYMWPUsGFDh/imTZv05JNPBiAje8jqewxZRTCMg6zXfYdr62jQoEGG8fHjxzs9Z8KECYZ/YCM6Olr33XefabkhY1n5fjbj+11fzeN22dO30x6HmVgP+lfTpk21Y8cO9e3b19R6K1eurHXr1qlnz56m1msGK+xhW4E/+kZW2U+8wVfjtq/H7OzZs+u7777TyJEjTVuv8Eyyc3ZaH/KcUcas9Dy/s+cLqlSpYnpfuaFLly7KmTNnutjFixc1c+ZMn7QXCPx2x57jrLfs/vqZZ+w5zwTDfrlZAvl7AV8way6x0zwi2X8s9ZaZ45u/xzY7vXdW39Oyyx70P9l9brbT/QsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJAV5ciRQ19//bUiIiIcyjZt2qRRo0aZ0s6AAQN09uxZh3hERISmTp2qHDlyeN3G9OnT1ahRI23ZssXrumbMmKFq1app1apVXtd1w59//qlmzZrp2Wef1dWrV02p8+rVqxoxYoQaNGigP//805Q6ExIS9J///EedOnXS/v37Talz3759atu2rZ599llT6lu2bJkaNGign376yZT6Au3cuXP6/vvvDcvmzp3rdf1z5swxjKekpGjWrFle1+8PR44cUcOGDTVq1Chdv37dq7pOnz6tzp0765lnnjEpO2NW7fOXLl1S165d1b17dx06dMiUvG5IS0vTl19+qfr162vXrl2m1m31Md6frHpvnThxQg0bNtT8+fO9zmfr1q1q0KCB4uLivK4rI3YcW2AeO96zwWL//v16+OGHDcuyZcumadOmKSoqyqW6rDomZsRua9lg6CvO2ktLS9P48eNNbSsYrpc/BcP1+uKLL9SkSRPt2bPH67rsvk4NJKuMrRndf0lJSfryyy/9mI33JkyYoBo1amjRokWm1Hfs2DH16dNHHTt21Pnz502pE567du2aZs2apZiYGNWqVcvp3pS/2HFOsMM+qtnMXMsbCbZ9Ujt+XglW58+fV9euXdWhQwft2LHD9Pq3bdumu+66Sz169NClS5dMr98XrLJ+MpMd5xJYVzD2EV9grgMAAMgaQgOdAAAA/jZz5kynZe3bt/eozqJFi6pWrVoO8UWLFiktLS1dbMeOHYYP+DZr1kw5c+b0qH1J6tChg2H88uXLWr58udv1DR8+XBMmTFD27Nk9zikjxYsX108//aSGDRv6pH4ztG3bVpMnT1ZYWJhP6s/K1/jRRx9VfHy8IiMjfdZG7dq1NXfuXGXLls1nbXjiwIEDpm24WoWZr2ncuHHq3bu3KXX9U/ny5fX999+rUKFCptSXlfuvM3FxcRowYIDp9YaHh2vcuHF66qmnTKvTbu/f22+/rVGjRik01PyP8N26ddPnn39uer3+MmXKFHXr1s30es0eM4zYOXcz2ek60Bf/1qhRI61Zs0YVKlTwWRv169fXunXrVLlyZZ+1YQazf2DpqmBZT9tpDLATu1zXkJAQffnll3r00UdNqe+fIiIiFB8fr169epletx0VK1ZMP/zwg8qVK+ezNkJCQjR69Gi9+eabPmvDE2Z+XvX1PpHZgmWusLKsuHc4adIkJSYmOsTDw8NNH3NLliypVq1aGZaNGzfOpTpYt+KfAr0vG0z3o13Wm1Zip/WYFeefjNgtX2+sWbPGMB4SEqL//ve/fs7GHu6++27D+PXr17Vp0yY/Z+M/ns55wTRXuSor9qvY2FgNGzbMIX7hwgV1795dSUlJAcjKHrLyHkNWESzjIOt13+Haple5cmXdfvvtDvHExERNnjzZ6Xn79+/XihUrDMuGDBliWn7IWFa+n739ftdX87hd9vTttMdhNtaD/tOlSxctW7ZMRYoU8Un9UVFR+uqrr3Tffff5pH5PBXoP2wr80Tey0n6i5Ptx21djdlhYmL777jvFxMSYWq/EM8nO2GF9yHNGrrHS8/yff/650/3Gfv36mZRZeka/Q5k2bZquXbvmk/YCgd/umM9q8/e/BcPrZ56x3zwTLPvlZgnU7wV8xay5xC7ziBQcY6mnfDW++Wtss9N7Z/U9LbvsQd8QDHOzne5fAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACArOr9999XxYoVHeLXrl1T7969lZycbEo7x44d09ChQw3LKlasqPfee8+Udn799VfVq1dPDzzwgHbu3OnWuQkJCZoxY4bq1Kmje++9V2fOnDElp39KSkrS6NGjVbZsWb366qv6888/Parn8OHDeuGFF1SyZEm98cYbSklJMTlTad68eapUqZJ69eql1atXKy0tze06fv31Vw0aNEiVKlXS999/b2p+u3fvVvPmzdWwYUN99tln2rp1q1JTU01tw5+mT59uGJ8zZ47XdW/atEnHjh1ziK9YsUKnT5/2un5/SU5O1osvvqgyZcrorbfe0qlTp9w6/+TJkxo1apRuvfVWzZ0710dZpmflPv/NN9+obNmy6t69u5YtW6br1697XNe5c+cUHx+vhg0bqk+fPjp+/LjX+Rmx+hjvT1a9t06dOqWOHTuqe/fuWrVqldvnb968WT179tRtt92mLVu2eJWLq+w4tsA8drxng8UXX3yhqVOnGpZVrlzZrc8HVh0TM2K3tazd+8r27du1du1ah/jSpUt14MAB09uz+/Xyt2C4Xhs3blS1atU0ZMgQ7d+/361zg22dGkhWGFs3b96sX375xbBs/vz5tvoMfsMff/yhdu3aqX79+po+fbquXr3qdh1btmzRoEGDVKZMGX355Zc+yBLOJCYm6tKlSzpw4IDWrVunr776Ss8++6xat26tAgUKqFu3blq8eHGg07zJrnOC1fdRzWbmWt5IsO2T2vHzSjBbsGCBqlWrpnbt2mn69Om6fPmyx3VdunRJU6dO1Z133qmaNWtqyZIlJmbqH1ZYP5nNrnMJrCkY+4gvMNcBAAAEv/BAJwAAgL8tWLBAiYmJioyMdCiLjY3Vp59+6nadd911l9O2jCxatEgDBw5MF4uMjFSrVq00b948t9uX/srdWVvuPkT80EMPacyYMRke8+eff2r27NlatGiRdu/erZMnT+ry5cvKnTu3ChQooIoVK6p169bq0qWLypYta1hH3rx5NXfuXNWrV0+HDx92K0dfK1KkiL7++muFhob6pP6sfI07dOigd999VyEhIU6P2bx5s2bPnq21a9dq165dOnfunK5evaqIiAjlz59fRYsWVbNmzRQbG6vWrVs7radOnTr66KOP9OCDDzo95sqVK5lufBYqVMhwzLh8+bLOnz+f4bn/5skXHO6y62saMmSI+vfvb1h2oz+sXbtWBw4c0MWLFxUREaECBQqoVKlSatOmje666y7lzZvXaf1ly5bV119/neE944qs3H+deeSRRzRgwADDsl27dum7777Txo0bdejQIV26dElhYWEqWLCgihQpombNmqldu3YqWbJkhm2MHTtWBw4c0DfffONVrnZ7/0aMGKEnnngi0+O2bt2qefPmadu2bTp58qROnz6t8PBwFSpUSEWKFFHTpk3VsWNHFS1a1OHc+++/XytXrtS5c+c8zjMQnnrqKXXv3t2wzEpjRrDlbiY7XQf64t+qVKmixYsXK3fu3Bked+jQIX333Xf6+eefdezYMZ06dermtShWrJhatGihdu3aqWDBgk7rKFWqlJYvX6769evr6NGjLuWXkJCQ6TqoWLFihuv8Cxcu6NKlSy61I0nXr1/3+At0b1htPe0pO40BdmKn6/r666+rV69emR7322+/acGCBdq8ebNOnDihM2fOKDQ0VHny5FGFChXUqFEjderUSYUKFUp3XkhIiCZOnKjdu3d7navdTZkyRSVKlHBafuLECX377bf6/vvv9dtvv91c/6ampioqKkp58+ZV+fLlVbduXXXo0EEtW7Z0OgY9+eST2rZtmyZNmmRYbtfPq77eJzJbsMwVVpZV9w5Pnz6tOXPmGM41AwYM0LvvvuvS63NFnz59DO/hn376Sbt27cr0fKuvW2HfOcETwXQ/2mm9aSVWWo9lxKrzT7Dk661t27bp9OnTKlCggEPZsGHDNGXKFJfmyKyiYMGCevzxxw3L5s6d69EPqb3hzbzn7v6TJ3NeMM1V7shq/apUqVJO54f+/fvrjz/+8HNG3rHretJuewxZRbCMg6zXfYdr62jw4MGG8blz52b6h5XGjx+vli1bOsTr1KmjunXratOmTWakCCesdD/787tdyfvvd301j9tpT99KexysB4NTq1atNGPGDIWHZ/xTtwMHDmjBggVau3atjh8/rlOnTik5OVnR0dEqVqyY6tevr65duxr+HzJIUmhoqCZPnqyDBw9qzZo1hsfY9R6zK3/0jay2nyj5b9z2Zl/ayDvvvON0PuOZZPPvKyutDzPCc0aZs9rz/DeeL7jnnnscyu677z498cQTSkxMdO3FuaBAgQJq27atQzw+Pt60NozYdc3Ab3fSs9L8/U/B8PqZZ/5ip3nG6vvldttPcoUd5xK7zCNScIyl3jBjfOvTp09AxjY7vXdW2tMyYqc96BvsPjfb6f4FAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADwpbJlywY6hQw9+OCDevDBB/3S1rRp0zRt2jSft5OSkqIvvvhCX3zxhapXr6727dvrtttuU8WKFZU7d27lypVLCQkJunDhgo4fP66tW7dq/fr1WrRoka5cueLz/CTp5MmTeu655/Tcc8+pXr16atasmerWravSpUurUKFCypkzp8LDw5WYmKiLFy/q/Pnz2rVrl7Zv367ly5dr69atfskzOTlZU6ZM0ZQpU1SkSBG1bNlSjRo1Uvny5VWyZEnlypVLUVFRSk1N1YULF3T+/Hn9/vvv2rx5s77//nvt3LnT5zmuX79e69evlyTlzJlTRYsWVd68eZUvXz5FREQYnnPt2jWf5+Wu+Ph4xcfH+6z+YsWK+azufwsJCfFp/cePH9dTTz2l4cOHq3nz5mrWrJlq1aqlMmXKKE+ePMqVK5euXr2qixcv6vDhw9qyZYtWrlypH374QampqYZ1rly50qd5W7XPp6am6ptvvtE333yjHDlyqEWLFqpZs6YqV66scuXKKTo6Wrly5VLOnDmVlpamy5cv69KlS7p48aL27dunrVu3auvWrVq9erWSk5N9kuO/WWmM9/W97gqr3ls37qtKlSqpWbNmaty4scqXL59ufL506ZLOnz+vnTt36pdfftH8+fO1d+9ep3WuX7/ep9fcjmOLJ/yRT7t27Xzexttvv623337btPqsfM8G4h7yV5v33Xef7rvvPtPqs+qYmBG7rWWt3Fcy07hxY5+38W9Wvl5mXXMz3zurXi9Xz09KStKnn36qTz/9VHXr1lXbtm112223qVy5cjfXEv7ci7Dae+zP+SzQY+vZs2cN4778zO8PGzduVI8ePZQ9e3a1bdtWDRo0UM2aNVW8ePGb9/j169d14cIFnT17Vtu3b9evv/6qJUuW6ODBg37JcdSoURo1apRf2jKb1feQM2N2H7fqnJARq+yj2nUt/0/BtE/6T1b6vGLH+d1sixYt0qJFi5QtWzbVq1dPjRo1UtWqVVW6dGkVKVJEUVFRioqKkiRdvXpV165d0/Hjx3Xw4EFt375d69at08aNG5WYmOizHINl/RSo+8SOc4kn7Naf+/fvr/79+/ulLTMFSx/x9fW30lwHAAAAc4WkpaWluXSgxT40AQDgjUWLFumuu+5yiCckJCh//vxuf8k8ffp0de/ePV0sNTVVhQoV0pkzZxyO79Spk+bMmeMQ//TTTzVkyBC32pakHDly6OzZs8qWLZtDWa9evTRlyhSX62rYsKFWrlypyMhIw/KTJ0/q5ZdfVlxcnEsPF4eFhalXr1567bXXnH6Rs2HDBjVs2FAuLktM8/XXX6tnz54O8dKlS+vVV19V7969Dc/79ddf9d1332ndunU6ceKETp8+ne5aXL582enDBVLWusb/VqRIEe3YsUP58uUzLF+/fr2eeOIJrVmzxuU6GzZsqLi4ONWsWdPpMU2aNNHPP//sdr43/Pzzz2rUqJFD/N1339UTTzzhcb2BFKjX5KzfbdiwQZUrV1Z0dHS6+I4dO/Tcc89p1qxZmdadM2dOPf3003r66aeVI0cOp8f95z//8fhL66zcf529d1u2bFHFihUdrvny5cv10ksvadWqVS7V3759e40ePVq1atVyesyVK1dUp04d7d69273k/z+7vX+tWrXSkiVLFBYW5vSYefPm6emnn9auXbtcqjM2NlZvv/22ypcvny5+8eJFjRw5Uh9++KHDOU8++aTbD/Yb3S+zZ89W165dva5Hku68807Nnz/f4cs8K40ZwZh7VnsPb7BzXzRb/vz5tXHjxgwfiNyyZYtGjBihJUuWZFpfSEiIevToodGjR2dY5+bNm9WkSRNdv37do7z/7dixYypSpIhD/LHHHtP7779vShu+Yrf1dDCMAWZhbE2vW7du+vbbbzM8ZsGCBRo5cqR+/fXXTOsLDQ1Vz549NWrUKJUrVy5d2e+//65bbrlFBQsWdDjP3bG1QYMGWrdunWFZ6dKldejQIZfrckWTJk20evVqh3jhwoV18uRJl+q45557NGPGDMOyhIQEPf/883r//ffdeliyYsWKGjNmjLp06WJYfvXqVVWuXFmHDx92uc5/strnVV/vE2XWvrvjRLDMFZ6Mj2Zj79BYmzZttHTpUsOyOnXq6Jdffsm0Dlfs2bPHYb0sSX369NGXX36Z4bl2XLea1ResMldJ7s1XzgRiTjB7XAqm+9EO682ffvpJzZo1MywL1Nxil/WY1ecfu+drlg8//FD//e9/Dcv27duntm3b6o8//nB6fqlSpRx+DNy0aVO31oZ2EBERoblz5yomJsaw3Kqv2dm85+tn9uw4V5kpq/Sr8PBw/fTTT4b32Pvvv6/HHnssw/PnzZunjh07OsQHDRqkuLg40/I0W1bcY/DHPqS7dVkxp3+y2zho5/W6L7D3HhjZsmXTsWPHDPcg77rrrkz7Svbs2XXs2DHlzZvXoWz8+PF66KGHzEo1HWdr+eLFi+vo0aM+adMd3M/G/P3drr/ncTvt6dtlj+Of7LgefP755z1eC9p9f7hcuXLasGGD0/4g/fWe/u9//9PKlStdqjMmJkbvvvuuKlWqZFh+8OBB1axZUxcvXnQr13/m4+97zM7vcyA/K2XF/UR/j9vujtnO7ocHHnhAkyZNcojzTPJfPL2v7L4+tOtzRr5gt+f527Zt6/Qz4t13362ZM2e6lJcrhg4dqo8++ihdbNeuXapcubJpbXjKautSfrtj3fn7n+z0+pln0vNknrHCHCPZb7/cGTv/VsAZKz1DZZd5RLLXWOoLZo5v/l5D2+m9s/qelp32oG+wwtwsZY37FwAAAAAAAH/xZl+Fv9UOwJmaNWve3EtPS0vT/v37tXbtWvZyAfhFu/bt1KpVq0CngSzkjz/+0McffRzoNADAZwYMGKAqVasEOg1kEWvWrNGsmZk/iwkAdjXy2ZEZPncLmGnmtzO9+v8pAwAry5s3r5597tlAp4Es5q0339Lx48cDnQYA+MSt9aV7/i/QWSArecP4T+cDAEwSEhKievXqqWLFijef9966dau2bt0a4MwAAABgN6P+b5SioqLYIwcAP7vxnNlHH36kAwcOBDodAMgyhv53qMqWLasJEybo952/BzodAMgSbvx2kWffAcC/unbrqiZNmmjB/AX64YcfAp0OAGQZN/4u1vfff6+FCxYGOh0AAAAY4G+1A/AF/lY7AKu544471L5D+0CngSyIvVEAWQnzLQKBuRZAVsL/NxkCgWcuAWQlzLUIFH5jBiArafuwVLtjoLNAVrPkA2nL/EBnAQD+xd9qtxaeqQXga87GE37zAwD2xxgPAAAAwO6KFy+uQ4cOKTQ0NF38xIkTKl68uFJSUgKUGQAAAAAAAIJdSEiI6tevrwoVKvA8LQCXufKMd2imRwAAglJUbqlyC6lpb6nNf6U7BkoN75VK1ZJCwwOdne/NmjXLMJ49e3a3/1hLaGio2rZt6xDfsGGDzpw5Y3jO8uXLlZiY6BBv166dW23f0KZNG2XLls0hnpSUpPnzXf9VclhYmOLj4xUZGWlYvmnTJtWuXVsff/yxkpOTXaozJSVFX3zxherUqeP0j5HUr19fQ4cOdTlPX6tVq5Z69erlEP/xxx9Vv3593XbbbXruuec0b948rV+/Xvv379ehQ4du/nP27FmndWf1a/zSSy8pX758hmVvvfWWGjdurDVr1rhV57p169S0aVN9//33To8ZMWKEW3XC/+rXr6/o6Oh0sbffflu33Xab0zH7365cuaKXXnpJLVu2dDr+StLLL7+s8HD3J7us3n+due2225QjR46b/52UlKSHHnpIbdq00apVq1yuZ8GCBTfHV2cfZnPmzKmPPvrIozzt9v5ly5ZNEyZMUFhYmGH51atX1blzZ3Xq1Em7du1yud558+apatWq+vDDD9PFc+fObauxcvTo0YqIiEgXs9qY4YydczeTXa4DfTG9d999V2XLljUsS01N1YgRI1S7dm0tWbLEpfrS0tI0depUVapUSR988IHT4+rUqaMXX3zRo5yDTbCsp+0yBtiNXa5rrly5HMa/f7p8+bK6du2qDh066Ndff3WpztTUVE2ZMkU1atTQhAkT0pVVrlxZBQsW9CjXYPDEE08Yxq9cuaI77rhDb775puEeVUZ2796trl27auDAgYY/oMiRI4eeffZZj/K1Il/uE/lCsMwVVpbV9w6XLVumP/74w7Csf//+LtWRmSZNmqh8+fIO8fPnz+ubb77J9HzWrbCSYLof7bLetBo7rMfsMP/YOV8zjRkzRklJSYZl5cqV08aNG9W7d+8s/Yec8uXLp2+//VYxMTGG5d9++63b6+FgF0xzlSeySr96/fXX1ahRI4f4xo0b9dRTTwUgo6zJbnsMWUWwjIOs132Ha+uoe/fuhnuQhw8f1tKlSzM9PyEhQVOmTDEsu++++xyeH4J5uJ8956t53E57+nbY47A6V+6jrLwWHD9+vNP+cOOZxCZNmmjlypUu17lo0SLVqVPH6XcLpUuXzlLfcVmVrz8rZdX9RF+O274cs9944410/80zyemZfV/ZYX3Ic0auserz/EuXLtWBAwcMy8x6vuCG3r17O8Ti4+NNbSNY8Nsd687fNwTL62eesd88Eyz75fAtO8wjUvCMpZ4ye3zz59hmt/fO6ntadtqDluw/N9vt/gUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAb/Xt21ehoaEO8S+//FIpKSkByAgAAAAAAAAAAO847noDAIJa/pJSp5HSw1OlTs9ITXtLdWKl+t2kFgOknmOkR6ZJTftIkTkCna3vzJkzR2lpaYZlHTt2dKuuxo0bK2/evA7x+fPnOz3nypUrWrVqlUO8dOnSqlSpklvtS1JsbKxh/Mcff9SFCxdcrueRRx5R1apVDct+/vlnNWvWTEePHnU7P0k6ceKEWrVqpa1btxqWv/LKK8qVK5dHdZvtkUceUUhIyM3/Tk5O1uDBg3XHHXdo48aNXtedVa9xSEiIihYtalj21ltv6amnnlJqaqpHdV++fFndu3fX8ePHDcs7deqkChUqeFQ3AuPxxx/Xk08+qaSkJLfP3bBhg+68806n55YoUUJdunRxu96s3H9dlZSUpNjYWI0fP97jOl599VXdc889Sk5ONixv06ZNlnj/nn76aZUpU8aw7MKFC2rbtq3mzp3rbqqS/nqfHnnkEY0ePTpdvGTJkh7VFwj16tVL999WHDOcsXPuZrLLdaAv/q1Vq1bq06ePYVlCQoK6du2qN954w6O6k5KS9Oijj2rIkCFOP6c9/fTTql69ukf1B4tgWk/bZQywG7tc1+eff97pvXzixAk1adJEs2fP9qjua9eu6cEHH9TYsWM9Oj/YFChQQI0bNzYse+qpp7R27Vqv6h83bpyGDh3qED9+/Lj27t3rVd1W4st9IrMF01xhZewdyunn/vvvv18REREe5fdP/fv3N4x/+eWXSkhIyPBc1q2wkmC7H+2w3vzxxx/1zTffGP6zZs0at+vzll3WY3aZf26wW75mOnz4sD744AOn5fnz59fkyZO1detWPf74407XhsEoKipKDz74oLZv3+70u/MjR45o0KBBfs7M2oJtrvJEVuhXsbGxevLJJx3iFy5cUPfu3T2ay+EZO+0xZBXBNA7aYb1uV1xbR4MHDzaMT5w40en9/m/O9pdy5sypXr16eZwbMsb97DlfzON22tO3yx6H1bEedK5Pnz5q2bKlYdnFixfVtm1bj59JvHr1qnr06KGZM2calj/yyCPKmTOnR3XDHL7uG1lxP9HX47Yvx+zChQvf/HeeSfb9fWWH9SHPGbnPan3HWR4xMTEqVKiQpymmU7ZsWYdxLyUlRZMnTzal/mBnxb4fLOOsp4Ll9TPP2GueCab9cviXFfu2FDxjqad8Nb75Y2yz03tn9T0tO+1B32D3udlO9y8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeCskJEQDBw40LIuLi/NzNgAAAAAAAAAAmCM00AkAAPynelup30dS5eZSSAYzQLacUtNe0gMfSreU8l9+/nT8+HGtW7fOsKxDhw5u1dW+fXvD+IIFCzI8z1l5u3bt3Gpfcp7zrFmzXK4jPDxcI0aMMCw7ceKE7rnnHiUkJLid2z8lJCSoW7duunz5skNZ3rx51a9fP6/qN0ubNm1u/vv169fVsWNHffbZZ17Xm9WvcVpamjp37qw6depo1qxZSktLkyT9/PPPGj58uNf1nz171mk9ISEhHvUtBMY777yj9957z6s6Nm/erNGjRzst79Wrl1v1ZfX+66onnnhCixcv9rqemTNn6n//+5/TcnfHDLu9f1FRUXryySedlvft21dr1qzxJM10nn32WbfWClZlxTHDVXbO3UxWvQ70xfReeeUVp2UPP/yw5s6d63Ubn376qV577TXDsvDwcL344otet2FnwbqetuoYYHdWva65cuXSkCFDDMtSUlJ07733atu2bW7X+2/Dhw83ZVyyu9tuu00hISEO8QsXLmjixImmtBEXF6fZs2dLknbs2KEBAwaodOnSevPNN02p3wp8tU/kC8E6V1gNe4dSfHy8kpOTHeK33HKLYmNjvcoxe/bsuvfeew3LXPnxFutWWEkw349WXW8+//zz6t69u+E/Y8eO9SZdj9hhPWan+UeyX76+MGLECK1evTrDY6pXr6533nlHR48e1f79+/XVV1/p6aefVuvWrf2UpXfKli2rBg0aOP2nYcOGatOmje655x6NGDFCM2fO1LFjxzRu3DgVLVrUsM6zZ8+qY8eOOnPmjJ9fjbUF81zljmDuV6VKldKkSZMMy/r3768DBw74N6Eszk57DFlFsI6DVl2vBwOurVS1alU1bdrUIZ6Wlqb4+HiX6/nll1+0ZcsWwzJn3yPAXNzP7vHFPG6nPX077HHYAetBYyEhIXrhhReclg8YMEArVqzwqo3U1FT17dtXu3fvvhlLSkrS559/rgYNGujKlSte1Q/v+LJvZNX9RF+P2/4as3km2b/3lRXXhzxn5Bmr9Z2JEycqJSXFIR4eHq7777/f4/z+yaiexYsX69ixY6bUH8ys2PeDdZx1VbC+fivea8wz6QXrfjl8y4p9WwresdRV/hjffDW22em9s8Oelp32oCX7z812un8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAwdO3ZUmTJlHOIrV67U7t27/Z8QAAAAAAAAAAAmCA10AgAA/7ito9T+SSk80vVz8hWTer311/8Go5kzZxrGS5YsqRo1arhcT0xMjEPs5MmT2rRpU4bnLVy40DDerl07l9uWpNq1a6to0aIO8bS0NM2dO9fleu655x4VKVLEsGzYsGE6evSoW3k5s2/fPo0bN86wbOjQoaa04a2QkJCb//7kk09q8eLFptTLNf7LL7/8om7duqlGjRqaOnWqHnnkEaWmpppS97Rp03TmzBnDsubNm5vSBnxr+/btGj58uCl1jRkzRhcvXjQsa926tcLCwlyui/6buZ9++kkfffSRafW99dZbWrBggWFZ48aNVbduXZfrstv716tXL+XNm9ewbOLEiW7N75kZNGiQTp8+bVp9/mbVMcMVds7dTFa+DvTFvzVu3FiNGzc2LPvyyy81YcIE09p6/vnn9eOPPxqWdevWTeXKlTOtLbsKpvW0lccAO7Pyde3bt6+io6MNy0aNGqWVK1e6naMzDz74oC5cuGBafXZUrJjxpt727dt1/fp109p58skn1b59e1WrVk0TJ05UYmKiaXVbga/2iXwpmOYKK2LvUDp+/Ljmz59vWNa/f3+Pc5Okrl27Knfu3A7xdevWadu2bRmey7oVVhLM96OV15tWY4f1mJ3mH8l++fpCcnKyunXrps2bN7t0fNmyZXX//ffrjTfeUHx8vEN5r1691LlzZ1WoUEGhodZ4jOyFF17QunXrnP6zdu1aLV26VDNmzNDrr7+url27Kk+ePE7r279/v1q2bKktW7b470XYQDDPVe4K1n4VHh6uadOmKV++fA5l77//vmbNmhWArLI2O+4xBLNgHQdZr/sO1/YvgwcPNowvX75cBw8edKuu8ePHG8Zr1qyphg0bup0bXMf97D5fzuN22NO3wx6HHbAeNNaxY0eVL1/esOzTTz/Vt99+a0o7V65c0dChQ3XlyhW98847Klu2rPr376/ff//dlPrhOV/2jay6n+iPcdvXYzbPJPv3vrLq+pDnjNxnxb5z9OhRp3V4+3zBDb1793aIGe3dIj2r9v1gHGfdEYyv36r3GvPM34J1vxy+ZdW+LQXnWOoOf41vvhjb7PTe2WlPyw570JL952Y73b8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYIYXX3zRMP7ee+/5ORMAAAAAAAAAAMwTGugEAAC+V7yq1GaIZ+dmj5a6vSyFhpubkxXMnj3baVmHDh1cqqNQoUKqXbu2Q3zRokWZnrtjxw4dOnTIId6iRQtFRUW51L4kdezY0TC+ceNGHTlyxOV6+vXrZxjft2+fpk6d6nI9rnjnnXeUkpLiEK9SpYrKlStnalvemD9/vj766CPT6uMap7d9+3bdd9992rRpk2l1JiYmat68eYZlt99+u2ntwHcee+wxJScnm1LXtWvXNGXKFMOy6OhoVa5c2eW66L+Ze/rpp02v8+WXX3Za1rNnT5frsdv798ADDxjGExMTNWLECK/y+7dTp07pzTffNLVOf7LqmOEKO+duJitfB/ri3wYOHGgYT05O1siRI01tKzU1Vf/73/8My0JDQzVgwABT27OzYFhPW3kMsDMrX1dna7hLly7pnXfecTu/jJw6dUqvvfaaqXXaTfbs2Q3j58+fN7Wd/fv3a+HChabWaUVm7xP5QzDMFVaW1fcO4+LiDOPt2rVT4cKFPc6tf//+brX3T6xbYSXBfD9aeb1pNXZYj9lt/rFbvr5y8uRJNWvWTN98843XdQ0dOlSzZ8/W7t27dfXqVa1bt04ffPCBevfurWLFipmQbeCkpKTos88+U+3atbVt27ZAp2M5wTxXeSIY+9Xrr7+uRo0aOcQ3btyop556ym95wJEd9xiCUbCOg6zXfYdr+9dnnD59+hiWjR8/3u36vvrqKyUkJBiWDR482O364DruZ8/5ch638p6+HfY47IT1YHrOvhdITEx0+gffPLV8+XIVLVpUw4YNc+sZe/iHL/pGVt1P9Me47esxm2eS/+Kv+8qq60OeM3KfVfuOs+/7a9asqVq1anmU1w21a9c2vK/mzp3rVb1ZgVX7fjCOs+4Ixtdv1XuNeeZvwbpfDt+yat+WgnMsdYe/xjdfjG12eu/suKdl5T1oyf5zs53uXwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADwVp8+fVS3bl2H+P79+zVr1qwAZAQAAAAAAAAAgDlCA50AAMD37nhICg3z/PxbSkq3tTcvH6vYs2ePduzYYVgWGxvrUh0xMTEKCQlxiC9YsMCl8xctWuQQy5Ytm+644w6Xzpec5+rOl9nZsmVT8+bNDcs++ugjpaamulyXKw4fPqytW7calsXExJjaljdefvll0+riGvvP+vXrDeOFChVSVFSUn7OBO7Zs2aLly5ebWufcuXOdltWoUcOlOui/mdu8ebPWrVtner3r16/XmjVrDMvuuusul+qw2/sXHR2tRo0aGZZNmzZNp06d8io/IxMmTFBiYqLp9fqaVccMV9g5dzNZ+TrQF/8WEhKi9u2NPxDOmDFDhw8fNr3NdevWafXq1YZlHTt2NL09pOev9bSVxwA7s/J1jY6OVuPGjQ3LJkyYoEuXLrmdW2bi4uKUkJBger124ey158+f38+ZBAcz94nsjr2Xv2T1vcNFixbpzz//dIiHhYWpd+/eHuVVvHhxtW7d2iF+6dIlTZs2LcNzWbfCSoL5frTyetOKrL4es9v8Y7d8fe3atWvq3r27OnXqpN9//92UOrNly6YGDRro4Ycf1uTJk3X48GEtX75c/fr1s+U675dfftGnn36qixcvBjoVywnmucobwdSvYmNj9eSTTzrEL1y4oO7duyspKclnbSNz7DEEXrCOg6zXfYdr+5d7771XefPmdYifPXvWoz+8c/78ec2cOdOwrEePHsqTJ4/bdSJz3M/eseM8bsaevtX3OOzGjveRr4SHh6tNmzaGZVOmTNHJkydNb9MX30vDHGb3jay8n2j3cZtnkv/mj/vKqutDnjNyn5X7zoIFC3T06FHDsn79+nmamiQ5fT6BPdCMWbXvB+M4645gfP1WvdeYZ/4WrPvl8C2r9m0pOMdSd/h7fDNzbLPTe8eeVnpm7EHbfW620/0LAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN4qX7683nvvPcOyUaNGKS0tzc8ZAQAAAAAAAABgntBAJwAA8K3CFaRiVbyvp04n7+uwotmzZxvGGzVqpFtuuSXT89u3b+8QS0lJ0ZIlS1xqf/78+Ybxdu3auXR+oUKFVK9ePcMyZ6/NSNOmTRUVFWVYtmjRIpfrccfq1asN43Xq1PFJe+7asGGDNmzYYFp9XGP/+e2335yW5c+f34+ZwF1ffvml6XVu3LjRaVnJkiVdqoP+m7mpU6f6rO5p06YZxmvUqKGCBQtmer7d3r+WLVsqPDzcsCw+Pt6rvJw5ffq00zWJlVl1zHCFnXM3k5WvA33xb3Xr1lWhQoUMyyZOnOizdp3VXbNmTZUoUcJn7cJ/62krjwF2ZuXrevvttzsdW52t+bx17tw5l/dogtGpU6cM47Vq1VL27Nn9nI29mb1PZHfsvbB3KEmpqalO18YDBgzwKKc+ffooNNTx6+uvv/5aV65cyfBc1q2wkmC+H6283rQiq6/H7Db/2C1ff5k3b56qV6+uHj166LvvvlNSUpJpdYeGhqpVq1aaOHGi9u7dq759+5pWtz/Uq1dPmzdv1sSJExUdHR3odCwlmOcqM9i9X5UsWVKTJk0yLOvfv78OHDhgeptwHXsM1hCs4yDrdd/h2v5l8ODBhvEvv/xSiYmJHtU5fvx4w3hUVJT69OnjUZ3IGPez5+w6j5uxp2/1PQ47set95CtNmjRx+pn9iy++8HM2CCRf9I2svJ9o93GbZ5LT8/V9ZdX1Ic8Zuc/KfSc1NdXpvkivXr0UFhbmUV4hISHq2bOnR+dmdVbt+8E4zrojGF+/Ve815pm/Bet+OXzLqn1bCs6x1B3+Ht/MHNvs9N6xp5WeGXvQdp+b7XT/AgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIA3GjRooOXLlytfvnwOZTt37tTkyZMDkBUAAAAAAAAAAOYJDXQCAADfKlffnHryl5DyFDanLiuZOXOmYTw0NFQxMTEZnhsaGqq2bds6xNetW6dz58651P7y5cuVmJjoEG/Xrp1L57dv314hISEO8b1792rnzp0u1SFJtWrVMowfPXrUrXrcsXXrVsN4lSpVfNKeu77++mtT6+Ma+09G/c/oARBYx+LFi02v89SpUzpx4oRhWeHCrk1s9N/M/fDDDz6r++eff3ZaVrVq1UzPt9v7V6NGDcN4UlKS1q5d61VeGVm1apXP6vYVq44ZrrBz7may8nWgL/6tTp06hvHU1NQMx2hvZXQtnI3tMIe/1tNWHgPszMrXtVq1aobxxMREbd682aPcXLFs2TKf1W11e/fuNYxHRUXpscce83M29mb2PpHdsffC3uEN48ePV2pqqkPclc/rRvr3728Yj4uLy/Rc1q2wkmC+H6283rQiq6/H7Db/2C1ff0pJSdH06dMVGxurokWL6t5779Vbb72lVatW6erVq6a0UaxYMU2aNElr1qxRoUKFTKnTH0JCQtSvXz9t3bpVlStXDnQ6lhHMc5VZ7NqvwsPDNX36dMPPZu+9955mzZplSjvwHHsM1hCs4yDrdd/h2krVq1dX48aNDcvGjx/vcb0//PCD9u/fb1g2ePBgj+uFc9zPnrPrPG7Gnr7V9zjsxK73ka84WwOlpKRo3bp1fs4GgeSLvpGV9xPtPm7zTHJ6vr6vrLo+5Dkj91m570jSuHHjlJaW5hAvWLCgy7+h+7c77rhDxYoVc4hv2bLFo/qyEqv2/WAcZ90RjK/fqvca88zfgnW/HL5l1b4tBedY6o5AjG9mjW12eu/Y00rPjD1ou8/Ndrp/AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAzISEhioyMVLZs2ZQ/f35VrlxZ999/v2bNmqU1a9aoVKlShucNGTJEqampfs4WAAAAAAAAAABzhQY6AQCAb91i/H2nR/KXNK8uq9i0aZP+/PNPw7KOHTtmeG6DBg2UP39+h/j8+fNdbv/KlStatWqVQ7xcuXIqX758pufHxsYaxmfNmuVyDpJUuXJlw/j27dvdqscdZ8+eNYyXLl3aZ226Y+3atabWxzX2nwsXLjgty5s3r/8SgVuuX7+uHTt2+KRuZ30hKirKpfPpvxlLTU3Vr7/+6rP6t2zZooSEBMOyihUrZnq+3d6/KlWqGMZ/+eUXp9fBDOvWrfNZ3b5g5TEjM3bO3UxWvw70xb9Vq1bNML5161ZdvnzZZ+3u2rVLZ86cMSyrWrWqz9qFf9bTVh8D7Mrq17VSpUqG8V9++UWJiYke5eWKjRs3+qxuq9uzZ48OHjxoWPbqq69q4MCBfs7IvszeJ7I79l7YO7zh8OHDWrJkiSn5NGrUyPBz/pYtW7Rp06ZMz2fdCisJ1vvR6utNK7L6esxu84/d8g2UM2fOaMaMGXrqqad0++23K1euXCpfvry6du2qt956y+v6GzdurPXr1zsd68zw2muvqUWLFk7/admypTp06KDevXtr+PDh+vbbb3X8+PEM6yxTpoxWrVqlWrVq+SxvOwnWucpX7NSvXn/9dTVq1MghvmHDBj399NNe1w/vscdgDcE4DrJe9x2u7V8GDRpkGN+4caO2bdvmVd3x8fGG8WrVqqlJkyZe1Y30uJ+9Y9d53Iw9favvcdiJXe8jX3G2Bvr111919epVP2eDQPJF38jK+4l2Hrd5JtmRL+8rK68Pec7IPVbvO5J08OBBLVu2zLCsX79+HuXVu3dvw7izz5n4i5X7frCNs+4Kttdv5XuNeeZvwbhfDt+yct+Wgm8sdVcgxjezxjY7vXfsaaVnxh603edmO92/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJCZ7t276/r160pISNCZM2e0c+dOffXVV+rSpYvCwsIMz/nwww+1YsUKP2cKAAAAAAAAAID5wgOdAADAt3LkMbGuvObVZSWzZ8/Www8/7BCPiYnJ8Lz27dsbxhcsWOBW+wsWLFCrVq0M2//www+dnhcREaE777zTsGzmzJlu5XDrrbcaxg8dOuRWPe44d+6cYTw6OtpnbboqKSlJmzdvNrVOrrFvFChQQLfeeqvKlSt3859KlSo5PT40NNSP2cEd+/btU2pqqk/qvnDhgmE8MjLSpfPpvxk7fPiwkpKSfFZ/UlKS/vzzT5UvX96hzNl748oxVn3/SpcubRjftWuXVzllZseOHT6t32xWHjMyY+fczWT160Bf/FvFihUN47///rvP2961a5eaNGniEM9ovQf3BGo9bfUxwK6sfl3L/j/27ju+iir///g7nSSU0JEWkF6kCAEUKdKkWUCQKu2riCjrbwF1FcW1shZcOysgSBGkSBAkVOldpERqKCLSSwgJCRBI8vvDByXeuWl3bpl7X8/Hg8cunzNzzufOzCn3ZIgVKxrGDx8+nKeccurQoUNOrd/TTZ8+XaNGjbKJBwQE6Ouvv9azzz6rCRMmaMmSJTpy5IgbMvR8ztgnshL2Xmyxd5jZ+PHjDffSg4ODlZqamuN6BgwYYLf+nGDdCk/irc+jp683PZUnr8esNv9YLV9PkZGRocOHD+vw4cPavn27RowYkal89OjRSk1NVe3atdWgQQNVq1Yt2zVdZGSkli9frnr16uns2bOm5xwXF6e4uLhcnePn56cOHTpoxIgRhj97l6SiRYvqp59+0r333qtz586Zkapleetc5Sqe2q86d+5sk4skJSQk6IknnnDqz/OQM76+x+BJvHEcZL3uPFxbKTQ0VE8++aRh2cSJEx2uf/LkyXrzzTcNf8HPs88+q40bNzrcBv7C85x3VpnHnbmn78l7HFZhlefIlSpVqmQYz+2+AKzNWX3D1/cTrTpu806yLWc+V568PuQ9o9zx9L5z0/jx49W2bVub+MMPP6wiRYooPj4+x3WFhITo8ccft4mnpqZqxowZOa7HF3ly3/e2cTa3vO3ze/Kzxjxzmzful8O5PLlvS943luaWO8Y3s8Y2K907X97TctYetNXnZis9vwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgtlWrVmn48OHuTgMAAAAAAAAAAFMEujsBAIBz3bhuXl1pJtblSaKjo/X888/bxCMiIrI8r0OHDjax06dPa+fOnblqf/Hixfroo49s4h07dtQXX3xh97zmzZsrf/78NvEzZ85oy5YtucqhYMGChnF/f381atQoV3XlVKVKlQzjRp/J1Y4fP65r166ZWifXOG8CAgIUGRmpu+++W5UqVcr05+6771aBAgXcnSJMcu7cOafVnZyc7ND59N+snThxwultXLx40TCekzHAavfP3jH2roFZEhISlJGRIT8/P6e2YxZPHjOyY+XczeTp14G+eJu970XOvhZZtVGoUCGnt+0tPHU97eljgFV5+nW197wlJCQ4XHdWzp07pxs3bigw0Dd/HPLBBx/o2WefVZEiRQzL69Wrpy+//FKSdOnSJe3fv1+HDx/WoUOHbv05fPiwzp4968q0PYoz9ok8iafOFZ6MvcPMFixYoDNnzqhkyZKZ4o8++qjmzJmTozpCQkLUs2dPm/iVK1f03Xff5agO1q3wJN76PHr6etNTefJ6zGrzj9XytYqff/5ZGzduvPX3ggULqnPnzurdu7c6duxod5/qrrvu0syZM9W2bVulp6e7Kl27MjIyFBMTo5iYGD355JP6/PPPDce+smXLaurUqYY/6/cl3jpXeQp39Kty5cpp6tSphmUDBw7U0aNHc1UfnMPb9xisxBvHQdbrzsO1lXr06GH4jKakpGjmzJkO13/y5EktXbpUHTt2tCnr1q2b/vGPf7ikf/oCnue885R53J17+p68x2EVnvIceRJ7ayDGfd/irL7h6/uJVh23eSfZljOfK09eH/KeUe54et+5af78+Tp37pyKFy+eKR4cHKyePXvqq6++ynFdnTt3NuyTCxcu1IULF3Jcjy/y5L7vbeNsbnnb5/fkZ4155jZv3C+Hc3ly35a8byzNLXeMb2aNbVa6d968p+WuPWirz81Wen4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEwxMTHq3r27rl+/7u5UAAAAAAAAAAAwRaC7EwAAOFdKgnl1JV80ry5PsmbNGl28eFGFCxfO8TnFixdXgwYNbOKLFy/Odft79+7VsWPHVL58+Uzxli1bKiQkRNeuXTM87+GHHzaM//jjj8rIyMhVDvnz5zeMDxw4UAMHDsxVXY7y8/OTv7+/0tPTXdrunS5eNP9h5xpnr1q1aoqKilKDBg1Uu3ZtVapUSeXLl1dAQIC7U4MLJCcnO63u3I6Jf0f/zZoz791NCQkJhnF79yYnx3jq/bOXrzPmpjtlZGQoMTFRhQoVcmo7ZvHkMSM7Vs7dTJ5+HeiLtxUoUMAwbm9sNpO9620vJ19npfW0p48BVuXp1zU8PNww7uyxVfrr2njS2OpKiYmJ6tmzp2JiYhQYmPWPhAoVKqTGjRurcePGNmWXL1/W4cOHdejQIe3du1e//PKLtm7dqjNnzjgrdY/himfUVaw0V3gy9g4zS0tL0+TJk/Wvf/0rU3zgwIGaM2dOjup47LHHDMfp2bNnKzExMUd1sG6FJ/HW59HT15ueypPXY1abf6yWr1UlJiZqxowZmjFjhurWratPPvlELVu2NDy2VatW6tOnj6ZNm+baJLMxbdo07d69W6tWrTJcY7Rv316PPPKIFixY4IbsPIO3zlWeytn9KjAwULNnzzZ85+XTTz/V/Pnz85g5zOZNewxW543jIOt15+HaSkOGDDGMz507N8d7N9mZOHGiOnbsaBPPly+f+vfvr08++cSUdnwdz3PeuWMe97Q9fU/e47AK1oO23PV+DjyLs+63r+8nOnPcXrhwobPS5p3kXDDjufLk9SHvGeWOp/edm27cuKEpU6Zo5MiRNmUDBgzQV199leO6+vbtaxifNGlSjuvwVZ7c971tnM0tb/v8nvysMc/c5o375XAuT+7bkveNpbnlrvHNjLHNSvfOW/a0PGkP2upzs5WeXwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAww5kzZ/Tvf/9b//vf/9ydCgAAAAAAAAAApgp0dwIAAOc6sVe6p53j9aSnSWcOOV6PJ0pLS9NPP/2kJ598MsfnPPTQQ/Lz87OJx8TE5CmHJUuWaPDgwZlioaGhatGihZYtW2Z4TufOnQ3j0dHRuW4/LCws1+d4s0uXLpleJ9fYWKlSpTR48GD16tVL1atXd3c6cKPU1FR3p2AX/TdrV65ccXobSUlJhvHw8PBsz7Xa/QsKCjKMp6SkOL3ty5cvq1ChQk5vxwyePGZkx8q5m8nTrwN98TZ742hiYqLT27bXRk7Gf19h1fW0p48BVuXp19XeeGJvrWemlJQUjxpbXW358uXq06ePvv32W4WGhuapjvz586tu3bqqW7euHn/8cUlSRkaG1q9frylTpmjq1Km6fv26mWl7DGfsE7mSVecKT8beoa0JEybo5ZdfzrRn3q5dO9111106depUtucPHDjQMD5+/Pgc58C6FZ7EW59HT19vejJPXY9Zbf6xWr7eYNeuXWrdurX++9//6h//+IfhMa+88oqmTZvm4syyt2PHDj322GNauXKl4c/1X3/9dS1YsMANmXkGb52rrMAZ/eo///mPmjRpYhP/5Zdf9OKLL+Y5V5jP6nsM3sQbx0HW687j69e2Tp06aty4sWHZxIkTTWtn4cKFOnv2rEqUKGFTNmTIEH3yySemteXLfP15doSr5nFP39P31D0Oq2A9aMud6zJ4Dmf1DfYTnTdur1u3zmljNu8ku5Ynrw95zyh3PL3v3Gn8+PEaOXKkTTwqKko1atTQvn37sq0jIiJCHTt2tImfOnVKS5YsyVU+vsiKfd9XeNvnt+Kz5ovzjDful8O5PLlvS943luaWu8Y3M8Y2K907K+9peeoetNXnZis9vwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK7W8sGW7k4BAAAgVwIDAyX99Ttzky47//dhAQD+EhISIkmqf299VahYwb3JAIAPufm7WevUqaNSpUq5ORsA8A1FixaVJFWtWlUh+ULcnA0A+I7SpUtLku6++25lKMPN2QCA7yhfvvyt/+U9IgBwrZMnTiouLs7daQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMCLpKen68qVK4qPj9fRo0f166+/asWKFVq6dKlu3Ljh7vQAAAAAAAAAADBdoLsTAAA415FfpPQ0yT/AsXr+jJVSU8zJyRNFR0frySeftIlHRkbqjz/+sIl36NDBJnbjxg0tX748T+0vWrRIgwcPtol37NhRy5Yts4lXq1ZNlSpVsoknJSVp5cqVecoBtyUlJbk7Ba+XL18+vfrqqxo+fLjCw8PdnQ4AB6Snp3tFG5AyMvgPowOewNP6op+fn2Gc8d+9WE/Dm7hi3EtLS3N6G55u9uzZ2rt3r7799ls1aNDAlDr9/PzUrFkzNWvWTK+88oqGDx+uBQsWmFK3J7HqPhFzhfNY9ZlwpiNHjmjVqlVq1arVrVhAQICefPJJffDBB1mee9ddd6lNmzY28X379mnjxo05zoF1KzwJzyOMsB6DVaWnp+uFF15Q+fLl9dhjj9mU16hRQ23atNGKFStcn1w2Vq9ere+++059+/a1KWvYsKHq1q2rXbt2uSEz92Ouci8z+1Xnzp01YsQIm3hCQoKeeOIJXb9+3YyUYRK+T3oOxkEg55555hnD+MGDB7Vu3TrT2rlx44amTZtmOK9Vq1ZNzZs319q1a01rD8gtZ8/jVtrTZ48j71gP5pynvTsD56JvOJczxm1njtl8L0N2eM/ImJX6zsGDB7V27Vo1b97cpmzAgAF6+eWXs62jW7duCg4OtolPmzaNPg7AIb44z7BfDvgGZ49vnja2uYsn72lZaQ/6Tr44NwMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHibTp06uTsFAACAPGnewvZ36AIAnO/+++93dwoA4JOioqLcnQIA+Jza99RW7XtquzsNAPA51WtUV/Ua1d2dBgD4nMqVK6ty5cruTgMAfMrGjRsVFxfn7jQAAAAAAAAAAAAAAAAAAAAAAAAAAIAT+Pn5uTsFAICTMMYDAAAA8ESzZ8/W7Nmz3Z0GAAAAAAAAAABuEejuBAAAznX5gvTbMqluB8fq2TjTnHw81ZIlS3TlyhWFhoZminfq1ElfffVVppifn5/atWtnU8fGjRt16dKlPLX/888/KzU1VcHBwZniHTp00P/7f//P5vhOnToZ1rN48WKlpqbmKQfclp6e7u4UvNpdd92lBQsWqGHDhg7Vk5ycrIMHD976ExcXp4MHDyopKUmxsbEmZQsArpWRkWEY9/f3d3rbf1+HAL6MvghPxnoaQF7t3r1bDRs21KOPPqrnn39eDz74oAICAkypu1KlSvrxxx81ZswYvfrqq6bU6SmsuE/EXOFcVnwmXGH8+PFq1apVptjAgQP1wQcfZHnek08+aTgWjR8/3tT8AMATsB6DlQ0ZMkTt27dXvnz5bMratm2rFStWuCGr7L333nvq27evYVn79u21a9cuF2cE3OZovypXrpymTp1qWDZw4EAdPXrUjDRhIr5PArCasLAwu2upLVu2qHnz5qa2d/DgQbtlzz77rNauXWtqe0BuOHMet+KePnscecN6EDBG33A+Z43b3jxmA3Cu8ePHG36n7Nu3r1555ZVs5wZ731UnT55sSn4AAACAN7HiHjQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC8x+bNm92dAgAAQK40bNhQgYGBit0Vq5QrKe5OBwB8Rv369RUSEqI9u/co6XKSu9MBAJ9Rs2ZNFSxYUPv371dCQoK70wEAn1CtWjUVLlxYvx/5XWfOnnF3OgDgMypUqKBSpUrp2LFjOnnypLvTAQCfUa5cOZUpU0YnTpzQn3/+6e50AMCn/P777+5OAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwNIC3Z0AAMD51k2R7m4oFSiet/P3/Cz9GWtuTp7mypUrWr58uR555JFM8YcfflhfffVVplhUVJSKFStmU0dMTEye209OTtb69evVqlWrTPGqVauqYsWKNv/Bpocfftiwnujo6Dy1n5GRYRhft26dDhw4kKc6HWEvHyvjGv+lWLFi2rRpkyIjI3N0/NWrV3Xo0CEdPHhQBw8eVFxc3K3/f+rUKcNzSpQoYWbKAP03GwEBAU5vIzg42DCelpaW7blWu3/JycmG8YiICCdk4/o2AKugL95mb6wNDHT+tmJQUJBhPCfjv7diPQ0rs9d37fV1M9lbT3o6Pz8/p9T7448/6scff1TRokXVpk0b3Xvvvapfv76qVq2qcuXKyd/fP891v/LKKwoJCdGIESNMzBi5wVxhTVb77mpk3rx5unDhgooWLXorVr16dTVq1Ehbt261e97AgQNtYteuXdPUqVNz1T7rVvdw1lxldTyPyI6nrMesNv9YLV9vc+bMGc2YMUODBg2yKXvwwQfdkFHO7Nu3T4cOHVLlypVtyu677z43ZOQZmKs8gyP9KjAwULNnz1bhwoVtyj799FPNnz/frDQBr8Q4CORMz549VbBgQcOyvn37qm/fvi7LpWvXripWrJjOnz/vsjYBV7D6nr6n7HHAPczYH05PTzeMu2Jdhpyx8s8B2E+05axx28wxm3eSc8cTnitn4T2j3PH0vvN3c+fO1eeff26zv1m6dGm1adNGy5Yts3tu2bJl1bx5c5v45s2btX///lznAs/i6+Osr39+V2KeuY39cngbXx9L3TW+mTG2WeneWWlPyyp70Fafm630/AIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALjaD3N/cHcKAAAAuVK3bl0FBgZq+fLlOn36tLvTAQCfUa1aNYWEhGj16tU6evSou9MBAJ9R8rmSKliwoDZs2KD9+/hvPgCAKwwaNEiFCxfWjh07tGnTJnenAwA+o0vXLipVqpR2/7Zbq1atcnc6AOAzOnTsoDJlyujAgQNaHLPY3ekAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJBjge5OAADgfCkJ0g//lnr+R8pXIHfn/rlbWvKJE5LyQPPmzdMjjzySKfbggw8qLCxMKSkpt2IdO3Y0PD8mJsah9mNiYtSqVSubePv27TVu3Lhbfy9UqJAeeOABm+OuX7+e5xyuXr1qGJ87d64+++yzPNWJzLjGkp+fn2bPnq3IyEi7x5w+fVoLFy7UihUrtGPHDh0+fFjp6em5bgcwE/03a/ny5XN6GxEREYbxy5cvZ3uu1e6fvc9UuHBhp7YbGhqq4OBgp7YBWAl98TZ3XYus2khKSnJ6256I9TSszt54Ym+tZ6awsDCnt+EMoaGhTq3/woULmjVrlmbNmnUrFhwcrLvvvluVK1dW5cqVVbVq1Vv/PzIyUv7+/tnWO3z4cG3evFlz5sxxZvowwFxhXVb77mrk+vXrmjp1qv75z39mig8aNEhbt241PKdRo0aqXr26TTw6Olrx8fG5ap91q3s4e66yKp5H5JS712NWm3+slq83WrJkiQYNGmQTr1mzphuyyblt27apcuXKNvEKFSq4PhkPwVzlOfLar9577z01adLEsKxDhw5q3bq1KfndZO975htvvKFhw4YZlu3bt09PPPGEqXkAZmEcBHJmyJAh7k7hluDgYA0YMEAfffSRu1MBTONNe/ru3uOAe5ixP2xvv8cVP0NGzlj55wDsJ9rnjHHbrDGbd5JxE+8Z5Y6n952/u3btmqZPn264tzhgwAAtW7bM7rm9evUyXONOmjQp13nA8/j6OOvrn9+VmGduY78c3sbXx1J3jW9mjG1WundW2dOy0h601edmKz2/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOwLdHcCAADXOHtYmvoPqctoqXjFnJ0Tu1Ra/oWUdt25uXmKhQsXKi0tTQEBAbdiISEhat26tRYuXHgr1qFDB5tzT548qd9++82h9hcvXqyPPvrIJt6xY0eNGzfu1t8feughBQbaTuErV65UYmJintpOSUkxjBctWjRP9cEW11jq0aOHHnzwQcOyEydOaOTIkZozZ47S0tIcaicsLMyh84G/o/9mrXDhwk5vIyIiwjB++fLlbM+12v2Lj483jJcoUcKp7ZYuXdqp9QNWQ1+8LSkpyTDuivHfXhv2cvJ2rKdhdcnJyYZxe2s9swQEBLjkufb39ze9zvDwcNPrzE5qaqr279+v/fv325QFBwerevXqatq0qXr16qVmzZrZrefDDz9UdHS0bty44cx08TfMFdZlte+u9owfP17//Oc/M8V69uypF154QdeuXbM5fsCAAXbryS3WrdnzlrnKCnge4QhXrsesNv9YLV9vtHPnTsN4eHi4goODlZqa6tqEcuj06dOGcV9+dpirPEde+5XReys3Va1a1YzUcqR06dJ297Xj4uJclgeQW4yDQPbq1q2rqKgod6eRyTPPPGP4fiVgVd6+p8/PnDyLp+4P29vvKVSokMN1+yJPvc/uwn5i7pgxbpsxZvNOMm7y9veMzObpfcfI+PHjNWzYMJv4Y489poIFC9r993F9+/a1iV25ckWzZs3KUx7wLL4+zvr653cl5pnb2C+Ht/H1sdQd45tZY5uV7p1V9rSstAdt9bnZSs8vAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPv83Z0AAMB1Ek5J3z4nxYyVTsdJGRm2x6RelQ5ukqa9IC35r5R23fV5ukt8fLzWrVtnE+/cufOt/1+0aFE1bNjQ5piYmBiH29+7d6+OHTtmE2/VqpWCg4MN87lTdHR0nts+ffq0Ybxo0aJ5rhOZcY2l0aNHG8b379+vunXr6vvvv1daWprD7RQrVszhOoA70X+zVqZMGae3Ye9ax8fHZ3uu1e7fgQMHDONRUVFObdfZ9QNWQ1+87ezZs4bx4sWLO71te+u68+fPO71tT8R6GlZ34cIFw7izn7ny5cvL39+cH4Wkp6fbLcufP78pbdzJFWvt3EhNTVVsbKzGjRun5s2bq3379jp37pzhsZGRkerZs6eLMwRzhXVZ7burPfv379f69eszxQoVKqTHHnvM5tjg4GDDceLw4cNatWpVrttm3foXX5+rPAXPI5zF7PWY1eYfq+XrjbIaSzx5jXjp0iXDeL58+VyciedgrvIcVu1XOXHkyBF3pwDYxTgIZG/IkCHuTsFG5cqV1apVK3enAZjGl/f0+ZmTc1hxf/jkyZOGcU98bj2FFe+zu7CfaJ6/j9vOHLN5Jxk3ecN7Rq7k6X3HyO7du7VlyxabeGhoqJ544gnDc2rVqqU6derYxOfNm6fExMQ85QHP4uvjrK9/fldinrmN/XJ4G18fS90xvpk1tlnp3lllT8tKe9BWn5ut9PwCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsM/f3QkAAFwrI13avVya+g/pix7S9P8nzfu3NHuU9O1z0mfdpOg3pVMH3J2pe0RHR9vEOnXqdOv/t2vXTv7+ttNnTEyMKe0vWbLEJhYWFqZmzZpJkvz8/NShQwebYzIyMrRgwYI8t3v8+HHDeLVq1fJcJzLz9WtcrVo11ahRw7Bs4MCBunDhgmltFS9e3LS6AIn+m5277rpLERERTqu/WLFiKlOmjGFZXFxctudb7f7t27fPMF6mTBmVLVvWae02adLEaXUDVkRfvG3v3r2G8QYNGji13ZCQENWqVcuwbM+ePU5t2xOxnoY3sLd2q1evnlPbrVy5sml1JSYm2i0rVKiQae3cVLVqVdPrNNPSpUvVpk0bXblyxbD8zj01OB9zhbVZ7btrVsaPH28TGzRokE3s0UcfVeHChW3iEyZMyFO7rFv/wlzlGXge4SqOrsesNv9YLV9vlJKSYrcsX758LswkdwICAgzjGRkZLs7EczBXeQ6r9qucOHz4sLtTAOxiHASyFh4erj59+rg7DUPPPvusu1MATMGefmb8zMkcVtwftrffU7duXYfr9lZWvM/uwn6i8zhzzOadZNzkDe8ZuZKn9x17jN4vkKQBAwYYxvv27WsYnzRpUp5zgGfx9XHW1z+/KzHP3MZ+ObyNr4+l7hjfzBrbrHTvrLCnZbU9aKvPzVZ6fgEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADY5+/uBAAA7nMlUTq5Xzq0WTr6q3T2sJR+w91Zudf8+fNtYmXKlFHdunUlSR07drQpv379ulasWGFK+4sWLTKM32y3SZMmKlasmE351q1bderUqTy3u3v3bsN4o0aN5Ofnl+d6cZuvX+M2bdoYxn/77Tdt3rzZ1LYaN25san2Ar/ffnIiKinJa3U2aNLFbFhcXl+35Vrt/mzZtslvWqVMnp7XrzLoBK6Iv3rZnzx7DeJkyZVS+fHmntRsVFaXg4GDDsr179zqtXU/Fehre4MCBA4bxChUqqGTJkk5rt1mzZqbVdfHiRbtlpUqVMq2dm6zQH2NjYzVu3DjDsubNm7s4G9/GXGFtVvvumpU5c+YoISEhU6xNmzYqU6ZMptjAgQNtzr1x44a+/fbbPLXLuvUvzFWegecRruTIesxq84/V8nWmdu3aqUuXLi5vt1ChQnbLrl696sJMcqdEiRKG8cuXL7s4E8/BXGWLfmW+I0eOuDsFwC7GQSBrvXr1UoECBQzL+vXrp06dOjn9z7Zt2wzbf/TRR+2u7wArYU/fFj9zcpwV94djY2MN45UqVTJ8Xx7WvM/uwn6i8zh7zOadZEje8Z6Rq3ly37Hn+++/V1JSkk28adOmqlSpkk28V69eNrE//vhDK1euzHMO8Cy+Ps76+ud3JeaZ29gvh7fx9bHUHeObWWOble6dFfa0rLYHbfW52UrPLwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD7At2dAAAAnuTYsWPasWOH6tevnyneqVMn7dq1Sw899JDNOevXr1dSUpIp7f/8889KTU1VcHBwpnj79u01YsQIde7c2fC86Ohoh9rdsWOHYbxgwYKqUaOG9u7d61D94BrffffdhvGtW7ea3lbLli1Nr9MePz8/l7XlKt74mRzl6/03Jx566CEtX77cKXW3aNHCMH7t2rUcXXur3b/du3fr5MmTKl26tE3ZsGHD9PXXX5veZps2bVS5cmXT6wWsjL5424YNG+yWtW7dWpMnT3ZKu61atTKMX7t2Tdu3b3dKm57MW9fT8C2//vqr3bJmzZpp7ty5Tmm3bdu2ptV18eJFu2X169fXDz/8YFpbERERioqKMq0+Z5o9e7aGDx9uEy9ZsqT8/PyUkZFhSjt8X80ac4W1We27a1auXr2q7777Ts8999ytmL+/v/r166cxY8ZIkkqVKqV27drZnLtw4UKdOXMmT+2ybv2Lr8xVnj4n8DzC1fK6HrPa/GO1fJ2hRYsWevfdd9W0aVP9+eefWrhwoW7cuOGy9u+66y67ZYmJiS7LI7fKly9vGI+Pj3dxJp6Dueo2q/aradOmZXmu2R599FFVrFjRJr5y5UrFxsYanmMv7gk8fT0J52McBLL2zDPPGMbXr1+vadOmuSSHEiVKGPbFoKAgDRo0SP/5z39ckgfgLOzpG+NnTo6x4v5wdj9DdvT9eHdx5jNmxfvsLuwnOpczx2zeSYbkHe8ZuZon9x17UlJS9P333+vpp5+2Kevfv79Gjx596+9NmzZVZGSkzXFTpkzJc/vu5q3rUkf4+jjr65/flZhnbmO/3NqYS2z5+ljqjvHNrLHNSvfOCntaVtuDtvrcbKXnFwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIB9/u5OAAAATzNv3jyb2MMPP6yGDRuqePHiNmUxMTGmtZ2cnKz169fbxGvWrKny5curc+fOhufNnz/foXa3bt2q5ORkw7I+ffo4VDf+4uvX2KjvSNKFCxdMbad06dK67777TK1Tkq5fv24YDwsLM70tV/HGz+Qsvt5/c6JXr17y9zf/62VISIj69+9vWLZ27VpdvXo12zqseP8WLlxoGK9Vq5Yeeugh09sbPny46XUC3oC++Jc///xTv/32m2HZsGHDnNJmUFCQnn32WcOy1atX2x3XvZnV19OAJG3fvl3nz583LHvmmWec0maNGjXUpEkT0+q7ceOGzpw5Y1gWFRVlWjuS9OSTTyogIMDUOp3lwIEDhvGAgABFRETkuj6+r+YNc4W1WfG7a1bGjx9vExs4cOCt/9+3b1/DMc7ovJxi3foXb5urrDon8DzC1fK6HrPa/GO1fM1033336eeff9bq1avVtGlTSVK5cuU0ZMgQl+bxwAMPGMbPnTuny5cvuzSXnAoNDVXz5s0Nyw4ePOjibLJmb95zBuYq6/erDz74QP/85z9d9mfPnj2GecyaNcvuOadPnzblGjnCqutJOB/jIGBf/fr11bBhQ8OyiRMnuiyP2bNnKykpybBs8ODB8vPzc1kugDOwp2+Mnzk5xor7w9u3b1d8fLxhmbN+hmwmdzxjVrzP7uLL+4muYPaYfSfeSYbkHe8ZuZon952s2HtP4O9t9u3b1+aYjIwMTZ482aH2XcHX1qWO8PVx1tc/vysxz9zGfrk1MJfknK+Ppa4e38wc26x076ywp2W1PWirz81Wen4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2Ofv7gQAAPA08+fPt4k1atRI/fv3Nzw+JibG1Pbt1ffMM8+oTp06NvG4uDgdOHDAoTavX7+uFStWGJY99dRTCgoKcqh+cI0zMjIM4+Hh4aa289JLLznlWl68eNEwXrRoUdPbchVv/EzO4uv9NydKly6tXr16mV5vnz59VLx4ccOyxYsX56gOK96/r776ym7Z119/rQIFCpjWVq9evdShQwfT6gO8CX3xNqPvSJJUv359tWrVyvT2+vbtq1KlShmWRUdHm96eFVh9PQ3ctGzZMsN4mzZtVLt2bdPbGzFihOl1btq0yTD+4IMPqlixYqa0ERQUpBdeeMGUuiQpNDRU//znP/Xiiy+aVuedUlJS7JYFBATkuj6+r+YNc4W1WfG7a1ZiY2NtYlWqVNF9990nSRo4cKBN+bFjx7R06VKH2mXd+hcrzlX2WHlO4HnEnTx1PWa1+cdq+Zrpm2++MRw7xowZo8jISJfl0bNnT8P49u3bc11XnTp11KhRI0dTylbXrl0VFhZmWLZlyxant58b9uY9Z/H1ucob+xVsWXk9Cefz9XEQsGfIkCGG8aSkJM2ZM8dleaSkpGjWrFmGZRUrVlTbtm1dlgvgDFbd0/fUPQ57fHE9aLX94fT0dLvvzbdr107VqlUzpZ07FSpUyLS63PWMWe0+u4sv7yfe5Mxx2+wx+068k4ybvOE9I1fy5L6TlW3btmnnzp028fLly6tly5aSpMDAQHXv3t3mmDVr1ujo0aMO5+BsvrguzStfH2d9/fO7GvPMbeyXez7mkpxjLHXt+Gbm2Gale2eFPS0r7kFbeW620vMLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIA7hIeHq0yZMipfvrzhHzgH1x0AAAAAAAAAAAAAAADIPX93JwAAgKfZvXu3Dh8+nCnm7++vIUOG2Bz7559/au/evaa2v3jxYsP4iBEjDOPR0dGmtDtlyhTDeIkSJfTcc8+Z0sadXnzxRY0cOVKBgYGm1+2pfPkanz9/3jBeuXJl09qoXLmynn76adPqu1N8fLxhvH79+k5pzxW88TM5ky/335waM2aMChQoYFp9xYsX19tvv21Ydu3aNU2bNi3HdVnt/sXGxmrNmjWGZZGRkfr6668dSe+WChUq6IsvvjClLsAb0RdvGzdunFJTU+2W5c+f37S2ypQpo/fff9+wLD4+Plfjvzex+noauGnChAl2y7744gv5+5v3I4v69etr4MCBptV30/r16w3jQUFB6t+/vylt/POf/1SlSpUcric0NFTDhw/X77//ro8//lhvvfWWKlasaEKGmZUsWdIwnp6ebve7Z1b4vpo3zBXWZ7XvrnkxaNAgNWzYUDVr1rQp++abb5SRkeFQ/axb/2KluSo7Vp4TeB4hWWM9ZrX5x2r5muXdd981jOfPn19z585VWFiY03N47LHH9MADDxiWLV26NMf1NG7cWAsXLtSuXbs0bdo0BQUFmZWijQIFCtgdHyVp2bJlTms7L/Ly/ckRvj5XeVO/gn1WXk/C+Xx9HASMhIeHq3fv3oZl33//vVJSUlyaz8SJE+2WPfvssy7MBDCf1fb0rbDHYcQX14NW3B/+5ptvDON+fn766quv5OfnZ1pbVapU0alTpzRlyhRVq1bN4frc9YxZ8T67i6/uJ7pi3DZ7zP473km+zVOeK3fwhveMXM2T+05W7N3rAQMGSJLat2+vokWL2pRPmjTJlPadzRfXpY7w9XHW1z+/KzHP3MZ+uedjLskdXx9LXTW+OWNss9K98/Q9LavtQUvWn5ut9PwCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgCR9+eWXWrVqlc2f6tWruy0no3xWrVrltny8hauva6VKlfSPf/xDP/zwg44fP67U1FRdvnxZx48f1x9//GH4B47juhtjXAEAAAAAAAAAAAAAAEBu+bs7AQAAPNH8+fNtYoGBgTaxmJgY09veu3evjh07ZhMPCQkxPD46OtqUdhcuXKg///zTsGzMmDGqWbOmKe1IUqNGjfTOO+/oww8/1M6dO9WsWTPT6vZkvnyNz5w5Yxhv0aKF8ufP73D9+fLl0w8//KCwsDCH6zISGxtrGK9YsaLq1KnjlDadzRs/kzP5cv/NqXLlymnatGny8/NzuC4/Pz/NnDlTpUuXNiyfNWuWzp8/n+P6rHj/Ro4cqYyMDMOyXr16afr06QoICMhznlWqVNG6detUpEiRPNcB+AL64l9OnTqlGTNmGJZVrVpVkydPNqWdoKAgzZkzR8WLFzcs/+qrr5SSkmJKW1Zj9fU0cNPq1au1d+9ew7IWLVro7bffNqWdggULatasWfL3N/9HIKtXr7Zb9tprr6lkyZIO1R8VFWXKdejdu7eOHj2qsWPH3sopX758mjt3rt09prxq3ry5Yfzs2bNKT0/PdX18X80b5grrs+J316xcvnzZJtajRw8999xzNvH09HRNmjTJ4TZZt/7FKnNVTlh5TuB5hFXWY1abf6yWr1lmzpypuLg4w7KGDRsqOjpaoaGhTmu/SpUqGjdunGHZjRs3NHPmzGzraNmypVasWKHNmzerc+fOkv4aD8ePH29qrjcFBARo8uTJKlOmjGH5jh077H4/dRd7856z5jxfn6u8oV8he1ZeT8L5fH0cBIz07t3b7l7ihAkTXJyNtGXLFrtrts6dO+uuu+5ycUaAeay0p2+VPQ4jvrgetOL+8OrVq+3eq1atWmnUqFGmtBMYGKgpU6YoNDRU/fr10969ezV79myHngV3PWNWvM/u4ov7ia4at80es/+Od5L/4inPlbt4w3tGrubJfScr06dP15UrV2zi3bp1U3h4uPr27WtTlpSUpLlz55rSvrP54rrUEb4+zvr653cl5pnb2C/3fMwluePrY6krxjdnjW1WuneevqdlpT3om6w+N1vp+QUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASbr33nvVsmVLmz8FCxZ0W05G+bRs2dJt+XgLV13XmjVr6vvvv1dcXJw+/fRTde3aVWXKlFFQUJDpbeE2rnvWGFcAAAAAAAAAAAAAAACQW/7uTgAAAE80b968HB0XExPjlPaXLFmSo+NOnTqlLVu2mNLmjRs39NZbbxmW5cuXT/Pnz1dkZKTD7VSvXl0LFixQcHCwJKlWrVpau3atpk6dquLFiztcvyfz5Wu8ceNGw3i+fPn0yiuvOFR3WFiY5syZozp16tyKpaWlOVTn323YsMFu2dtvv21qW67ijZ/JmXy5/+bGo48+qvnz5ys8PDzPdYSFhemHH35Q69atDctTU1P1zjvv5KpOK96/bdu2adKkSXbL+/Tpo59//lk1a9bMdZ69e/fW+vXrVbZs2VyfC/ga+uJto0aNUlJSkmFZt27d9P333yskJCTP9RcuXFjLli3TfffdZ1h+/Phxvf/++3mu3+qsvp4G7jR69Gi7Za+++qrddVtOFSxYUDExMapSpYpD9djz66+/atu2bYZlERER+vbbb/P8j57vuece/fTTT7fWk5KUkZGRp7ouX76sEiVK2MTvvfdeLViwQGFhYXmq9+8CAwM1YsQIw7I9e/bkqU6+r+YNc4X1WfG7a1ZmzpxpEytQoIAGDBhgE1+yZImOHz9uSrusW60zV+WE1ecEnkfXW7dunTIyMgz/REdHuzQXq6zHrDb/WC1fs6Snp2vQoEFKT083LG/Xrp02b96sihUrmt52gwYNtHr1apUqVcqw/Ntvv9Xp06ezreftt9823PcfMGCAvv76awUGBjqc600316+PP/643WPGjBljWntmsTfvOXPO8+W5yhv6FbJn9fUknM+Xx0HAyJAhQwzju3fv1i+//OLibP4yceJEw3hgYKD+7//+z8XZAOax0p6+VfY4jPjietCq+8NZPfdvvfWWw/3C399fU6ZMybQu8/f3V/fu3bVz5848/2zZXc+YVe+zO/jifqIrxm1njNlGeCfZc54rd7L6e0bu4Kl9JyuJiYmaM2eOTTw8PFwDBgzQI488YlM2e/ZsXblyxbQcnMkX16WO8PVx1tc/v6sxz9zGfrlnYy7JHcZS545vzhzbrHbvPHlPy0p70Hey8txstecXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAz9ejRQ9u3b1ePHj3k7+/v7nR8BtcdAAAAAAAAAAAAAAAAMB9v4gAAYGDTpk06c+ZMlsekpqbq559/dkr7ixYtytFxP/74o6ntTpo0Sb/88othWZUqVbR582bdd999ea6/U6dO2rhxo0qWLGlT9uSTT+ree+/Nc91W4avXeNOmTUpKSjIse/nll9WtW7c81VuhQgVt2LBBnTt3vhW7fPmyvvvuuzzVZ8+vv/6qU6dOGZY98sgj+uyzzxQYGGhqm87mjZ/J2Xy1/2Zn2bJlmf7+yCOPaPPmzapfv36u66pXr542bNigLl262D3m448/1sGDB3NdtxXv3wsvvKC9e/faLW/RooViY2P1zTffqG3btgoKCrJ7bNGiRdWvXz9t2LBB3333nUqUKJGpfPr06bnOD/AV9MW/nDx5Uq+88ord8h49emjdunW65557cl138+bNtXXrVrVs2dLuMc8995wuX76c67q9hdXX08Cdfvjhhyz3U15//XX98MMPKl26dK7rbty4sbZu3aqmTZtmii9ZsiTXdWVl7Nixdsvat2+v6OhohYeH56rOXr16ad26dZnmhvPnz2v16tV5ynHBggXatGmTYVm7du20efNmNWjQIE913xQcHKxvv/3W7tr/hx9+yFO9fF/NG+YK72DF7672jB8/3inHZod161+sMFflhNXnBJ5H32al9ZjV5h+r5WuWDRs26KOPPrJbXqdOHe3evVv//ve/FRYW5nB7xYoV04cffqgtW7bY/X524cIFvfbaazmq7+WXX7ZbNnjwYG3evFn3339/nnK9U4cOHbR3794sf86wYcMGzZkzx+G2zGZv3nPmnOfrc5XV+xWyZ/X1JJzP18dB4E4NGjSwu9adOHGii7O5bdq0abp+/bph2eDBg+Xn5+fijABzWGlP30p7HH/nq+tBK+4Px8TE2L3Pfn5+eu+99/Tdd98Z7tdkp0SJElqyZIl69+5tWD5nzpw8vY8oufcZs+J9dhdf2090xbjtjDHbHt5J9oznyp284T0jV7DK+/xZsffewPvvv6/Q0FCb+KRJk0xt35l8dV3qCF8fZ33987sS88xt7Jd7NuaS3PP1sdRZ45srxjYr3TtP3tOy0h70naw+N1vp+QUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwCzPPPOMZs6cqZCQEHen4lO47gAAAAAAAAAAAAAAAIBz+Ls7AQAAPFFGRoYWLFiQ5TFr165VcnKyU9r/+eeflZqamu1x0dHRprabnp6u/v376/Lly4blpUqV0saNGzVr1izdc889Oa63SZMmio6O1k8//aTChQsbHvPNN99o6dKlecrbSnz1GqelpWn69OmGZQEBAZo9e7Y+//xzlSxZMkf1lS5dWp9++qkOHDigevXqZSp78803dfLkSUdTziQtLU2ff/653fJhw4Zp//79evHFF9WoUSMVKVJEAQEBpuZgNm/8TM7mq/03O6+++qri4+MzxWrXrq1ff/1VM2fOVNOmTeXvb/+rZ0BAgB544AHNmDFD27dvt+nTd9q1a5fefPPNPOVpxfuXnJysrl276vz583aPCQgI0KBBg7Rs2TLFx8dr+/btWrx4saZOnaqZM2dq5cqV2rNnj86cOaMpU6bo/vvvt6njyJEjevHFF3OdH+Ar6Iu3ffnll5ozZ47d8qioKO3cufPWZ8xq/A8ODlbbtm21cOFCrVmzRpUrV7Z77H//+99sv595O6uvp4G/e+qpp2zWkHfq2rWrDh06pA8//FC1a9fOsi5/f389+OCDmjdvnjZt2qRq1aplKl+/fr2mTJliSt43zZkzR3v27LFb3qlTJx06dEj/93//pwIFCtg9LjAwUJ06ddLatWs1Y8YMFSpUKFP5v//9b126dCnPefbv319JSUmGZffcc4+2bt2qefPmqXXr1goMDMxxvfny5dMTTzyhHTt2qE+fPobHpKSkaN68eXnKm++recNc4R2s+N3Vnm3btmnXrl3ZHnf69Gn99NNPprUrsW6VrDNXZccb5gSeR99mlfWY1eYfq+VrplGjRmnRokV2y8PCwvTGG2/o5MmTGjdunJo3b56rX9ZUrFgxdevWTVOnTtXx48c1cuRIu+Nqenq6Bg4cqDNnzuSo7o0bN+p///uf3fIGDRpow4YN2rp1q4YNG6batWvLz88vR3VXqVJFw4YN02+//aaYmBhFRkbaPTYhIUH9+vXLUb2ultW858w5z9fnKiv3K2TPG9aTcD5fHweBm4YMGWIYT01Ntbvv6Arnz5+321fKlSunDh06uDgjwBxW29O3yh7H3/nqetCq+8PPPPOM/vjjD7vlvXv31pEjR/T++++rbt262dZXrlw5vf7664qLi1Pbtm0Njzl//ryGDx+e55zd+YxZ9T67gy/uJzp73HbGmH3TihUrdPTo0Uwx3knOzN371O5g9feMXMEq7/NnZcOGDdq3b59NPDw83CYWFxenjRs3mp6Ds/jqutQRvj7O+vrndzXmmdvYL/dczCW5x1hq3vjm6rHNavfOU/e0rLYHfScrz81We34BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHDUPffco08//VR+fn7ZHpuWlqarV68a/kHucN0BAAAAAAAAAAAAAAAA5wl0dwIAAHiq6OhoPf3003bLY2JinNZ2cnKy1q9fr1atWtk9JjExUatWrTK97X379qlXr16aP3++AgICDI954okn9MQTT+jYsWNasWKF/vjjD509e1ZJSUkKCAhQeHi4SpYsqerVq+uBBx5QmTJlsmxzzZo1Gjp0qOmfxVP56jV+66231L9/f4WFhdmU+fn56fnnn9eQIUP0888/a+vWrTp06JASEhJ07do1FSpUSCVKlFCFChXUpk0b1alTx/AF84ULF+qjjz7SmDFjTM9/3Lhxev7551W6dGnD8kqVKumDDz7IUV3vvPOOXn/9dTPTyxNv/EzO5qv9Nyvnzp1T7969FRMTI39//1txPz8/9ezZUz179lR8fLw2b96s06dP6+zZswoICFDx4sVVqlQpNWnSRBEREdm2Ex8fr8cee8yhfyBixft34MABtWjRQitXrlTJkiWzPDZ//vyqX79+ruqPj49Xhw4dlJiYmOccAV9AX7ytX79+Kl++vBo3bmxY7u/vr379+qlfv366cOGCtm7dmmn8L1mypEqXLq0mTZooPDw82/YWLlyoESNGmP0xLMnq62ngTkePHlWPHj20ZMkSu+uy0NBQjRw5UiNHjtTx48e1fft2nT17VufOnVNAQIAKFSqkypUrq379+ipSpIhhHWfPnlXPnj3VtGlTU/NPS0tTt27dtG3bNrtjWalSpTRx4kSNGzdOGzdu1NGjR3Xu3Dldv35dERERqly5sqKiouyuhZcvX64vv/xSbdq0yXOeBw8e1IABAzRnzpxMa/Wb/P391aVLF3Xp0kWXL1/W5s2bFRcXp99//11JSUlKSUlRRkaGwsLCVKBAAVWoUEHVq1dX06ZNFRoammXbo0eP1pkzZ/KcO99X84a5wjtY8burPePHj9eXX36Z5TGTJ09WWlqa6W37+rrVKnNVTnjDnODrz6Mvs9J6zGrzj9XyNcuNGzf0+OOPa9GiRWrdurXd4woVKqQhQ4ZoyJAhSk1NVWxsrI4ePaqkpCSbY9944w2FhISoYsWKKl++fI7yyMjI0HPPPaeFCxfmKv9hw4bpnnvuyfI7WlRUlKKioiT99TPzo0eP6tixY0pMTFRKSopSU1MVGhqqiIgIFS1aVLVq1crRzxgk6erVq+rSpYuOHDmSq7xdKat5z5lzni/PVVbvV8ieN6wn4Xy+PA4C0l8/3+zVq5dh2fz583XhwgUXZ5TZxIkT9fjjjxuWPfvss059jxNwJivt6Vtpj+PvfHE9aNX94QsXLqhDhw7asGGDChcubHhMWFiYXnrpJb300ks6ffq0fv31V507d+5W7vnz51fJkiVVp04dVa9ePctfZJ2WlqY+ffroxIkTDuXtrmfMqvfZXXxtP9Fd47ajY7YkXb58WQMGDNDy5csVFBR0K847yX/xhH1qd7D6e0auYKX3+bMyYcIEffzxx9keN2nSJKe070y+uC51lK+Ps77++V2JeSYz9ss9F3NJ7vn6WGrW+Na9e3eXj21WuneevKdlpT3oO1l9brbS8wsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgKO+/fZbhYSEGJadP39eX331lRYtWqR9+/YpKSnJxdl5L6te96ZNm+q1116zia9bt07vvfeeGzICAAAAAAAAAAAAAAAAbAW6OwEAADzVzz//nGV5TEyMU9uPiYlRq1atsiy/fv26U9r+6aef1LNnT82YMUNBQUF2jytfvrwGDRrkUFurV6/Wo48+qtTUVIfqsRpfvManT5/WCy+8oAkTJtg9JjAwUA899JAeeuihXNe/du1a9enTx5EUs5SQkKC+fftqxYoV8vf3d1o7ruSNn8kVfLH/Zmfp0qX6xz/+oc8//1x+fn425UWKFFHHjh3zXP/Zs2fVrl07HT161IEs/2LF+7d37141btxY33//vZo0aeJQXXc6duyYOnbsqLi4OIWFhZlWL+Ct6It/uXr1qlq3bq158+apXbt2WR5btGhRdejQIc9tTZs2TYMGDVJGRkae6/AmVl9PA3+3YsUKdevWTd9//73df0R8U9myZVW2bNlc1Z+QkKBHHnlEJ06ccCRNu/bv36/Bgwdr+vTphmvgm4KCgtSiRQu1aNEiV3X37t3bjDQ1b9489erVS9OnT89y/Zs/f361adNGbdq0cbjNlStX6pNPPnGoDr6v5g1zhfew4ndXI9OnT9dHH32k0NBQw/KMjIwsn1dHsG61zlyVHW+YE3gefZuV1mNWm3+slq9Zrl27pk6dOumzzz7T4MGDsz0+ODhYDRs2VMOGDQ3LsxuX/i4pKUlPP/20Zs2alavzJOnGjRvq0KGD5s6dm6N2w8PDVatWLdWqVSvXbf3dpUuX9Mgjj2jt2rUO1+VM7pr3fH2usnK/Qva8YT0J5/P1cRDo06ePwsPDDcsmTpzo4mxsLV26VMePHzf8OUHHjh1VtmxZHT9+3A2ZAY6x2p6+lfY47uSr60Gr7g/v27dPzZs31/Lly1WqVKksjy1VqpQ6deqUp3auX7+unj17atmyZXk6/07ufMasep/dxdf2E109bpsxZt+0Zs0aDR48WJMmTeKd5Dt4wnPlTlZ/z8gVrPQ+vz1Tp07Vf/7zHwUHB9s9Ji0tTVOnTnVaDs7iq+tSR/n6OOvrn9+VmGduY7/cczGX5I2vj6XOHN+cPbZZ6d556p6W1fag72T1udlKzy8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHnVokUL3XvvvYZly5cvV7du3ZSYmOjirLyfla97yZIl1b59e5v45cuX3ZANAAAAAAAAAAAAAAAAYMzf3QkAAOCpUlNT7ZYdPXpUBw4ccGr7ixcvzrI8Ojraqe3PnTtXDz74oE6ePOm0NsaNG6e2bdt67AvBzuaL13jixIl68803Ta939uzZateunZKSkkyv+06rVq1S7969dfXqVae240re+JlcwRf7b3a+/PJLPfXUU1nOn3mxa9cuNW3aVLt27TKtTivevz/++EMPPPCARo0aZUqdM2fOVIMGDbRnzx4TsgN8B33xL8nJyerUqZPGjh2r9PR00+u/evWqXnzxRfXr1083btwwvX4rs/p6Gvi7+fPnq3379qavy44fP66WLVtqy5Ytptb7dzNmzNCgQYN0/fp10+rcvXu3WrVqpfPnz5tW5+zZs9W2bVv98ccfptVpz4IFC9SxY0elpaU5XBffV/OGucJ7WPG7698lJiZqzpw5dstXrlyp33//3SltS6xbJevMVdnxhjmB59G3WWk9ZrX5x2r5muXatWt65pln1KtXL124cMFl7a5YsUK1atXSrFmz8lxHUlKSOnbsqA8++MBl49XmzZtVr149rV271iXtOcpd856vz1VW7lfInjesJ+F8vj4OwrcNGTLEMH7s2DGtWLHCxdnYysjI0LfffmtY5u/vr6efftq1CQEmstqevpX2OO7kq+tBq+4P7969Ww0aNNCaNWucUv/p06fVvn17zZs3z7Q63fmMWfU+u4uv7Se6atw2c8y+6dtvv1XPnj117do10+qUeCfZ6qz+npErWOl9fiMXLlzI9t/KLVu2TKdOnXJqHs7iq+tSR/n6OOvrn9+VmGduY7/cczGX5I2vj6XOGN9cNbZZ6d556p6W1fag72T1udlKzy8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHnx/PPPG8YPHDigRx55RImJiS7OyDdw3QEAAAAAAAAAAAAAAADn8nd3AgAAWFFMTIzT29i7d6+OHTtmWJaamqrFixc7PYcNGzaodu3a+t///qf09HTT6t23b59atmypoUOH6saNG6bVa0W+eI3//e9/64knntDFixcdruv8+fPq06ePevTooWvXrpmQXfZmzZqlBx54QBs2bHBJe67gjZ/JFXyx/2Zn0qRJatKkifbt2+dwXVevXtV7772nqKgoHTp0yITsMrPi/UtLS9N7772nChUq6K233tLhw4dzdf7169f1ww8/6P7771fv3r11/vx5U/MDfAV98S83btzQyJEjdf/992vbtm2m1bt8+XLVq1dPH330kWl1ehurr6eBv1u9erVq1aqlKVOmmLIumzt3rurUqaNdu3aZkF32vv32WzVr1kxxcXEO1/Xdd9+pcePGOnXqlAmZZbZmzRrVqlVLH3/8sVJSUkyv/8KFCxo6dKi6dOli6njC99W8Ya7wHlb87vp348ePz1OZWVi3Wmeuyo43zAk8j77NSusxq80/VsvXTN9//70qVKig0aNHO/WXMG3dulU9e/ZU27Zt9eeffzpcX1paml5++WXVqVNHMTExysjIMCFLW3/++aeeeuop3X///Tp69KhT2nAWd817zFXW7VfInjesJ+F8jIPwRVFRUapXr55h2eTJk522Vsutb775xm4uTz31lPz9+ScRsC6r7elbaY/jTr66HrTq/vDJkyf14IMP6plnnjHtvZqMjAzNnj1bderU0cqVK02p807ufMasep/dxdf2E505bjtrzL5p9uzZatiwoSnfz3gn2XtY/T0jV7DS+/xGsnuPYNKkSS7Jw1l8dV3qKF8fZ33987sS88xt7Jd7LuaSvPH1sdTM8c3VY5uV7p2n7mlZbQ/6Tlafm630/AIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkFutWrUyjL/88su6evWqi7PxHVx3AAAAAAAAAAAAAAAAwLn83Z0AAACeLDU11TC+aNEil7S/ZMkSw/jKlSuVlJTkkhwuXryoZ599VlWrVtWXX36pCxcu5KmetLQ0rV69Wo899phq1aqlNWvWmJypdfniNZ4zZ45q1qypMWPG6Pz587k+/9ixY3rppZcUGRmpGTNmOCHDrP3666964IEHdN9992ncuHHauXOn0tLSXJ6HmbzxM7mCL/bf7OzYsUO1a9fWwIEDtX///lyff+bMGX300UeqUKGCRo0apevXrzshy79Y9f5dvHhRb7zxhipXrqx7771Xzz77rCZMmKClS5dqy5Yt2rdvn3bt2qX169dr3rx5evfdd/XYY4+pSJEi6tatmzZt2mRTZ758+ey258x7AFgZffEvW7ZsUVRUlNq0aaNFixbZ/Q6VleTkZM2aNUtRUVFq166dDhw44IRMvYvV19PA3yUkJGjAgAGqUaOGJk+erMTExFydn56eruXLl6tp06bq3r27Ll686KRMjW3ZskW1a9fWsGHD9Pvvv+fq3IyMDK1du1bNmjVT3759lZKS4qQs/xpvR4wYobJly+pf//qXdu7c6XCd27dv10svvaRKlSpp3LhxSk9PdzzRv+H7at4wV3gPq353vWnDhg3at2+fTfz8+fOKjo52SQ4S61arzFXZ8ZY5wdefR19mpfWY1eYfq+VrpsuXL+vtt99WmTJl9OSTT2rx4sW6ceOGw/UeOXJEEydOVOPGjdW4cWPNmjXLhGwz27dvnzp16qRKlSrpvffe0549exyu8/r161q8eLF69eqlu+++W998840yMjJMyNb1bs577pjzfH2usnK/Qta8ZT0J5/P1cRC+ZciQIYbx9PR0TZo0ycXZ2Hf06FGtWrXKsKx06dLq3LmzizMCzGW1PX0r7XHcyVfXg1bdH87IyND48eMVGRmpoUOHaseOHXmq58qVK5ozZ44aNGigHj166Ny5cyZneps7nzGr3md38bX9RLPHbVeM2Tft3r1bjRs3Vq9evfKUN+8keyerv2fkClZ6n//vVq5cqcOHDxuWxcfHa8GCBS7LxVl8dV3qKF8fZ33987sS80xm7Jd7JuaSvPH1sdSR8c3dY5uV7p2n7mlZbQ/6Tlafm630/AIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkFM1atRQkSJFbOIXLlzQwoUL3ZCRb+C6AwAAAAAAAAAAAAAAAM7nl5GRkZGjA/38nJ0LAACwgICAADVt2lRNmzZV/fr1VbFiRZUqVUqhoaEKCQlRWlqakpKSlJSUpKNHj2rv3r3avn27lixZovj4eHenbwm+do2Dg4PVokULNW7cWI0bN1bp0qUVERGhwoULKzAwUImJiUpISNCBAwe0Y8cOLVu2TFu3bnV32jbCwsJu5R4REaGwsDC7x8bFxWn//v0uzC5vvPEzOZuv9d+cqF27tjp27Kh69eqpZs2aioiIUKFCheTn56dLly4pISFBBw8e1M6dO7V27VqtW7dOOfyaajpfvn8VK1bUkSNHDMuefvppTZw40cUZAb7JG/pigQIF1L59ezVs2FB169ZVuXLlVKhQIRUoUEAZGRm6dOmSLl26pCNHjig2NlZbt27V8uXLde3aNXenblnesp4G7hQcHKy2bdvq/vvvV926dVWxYkUVKlRIBQsW1LVr13Tp0iWdO3dOsbGx2rZtmxYsWKAzZ864O+1bmjRpojZt2qhRo0aqVKmSihYtqrCwMKWlpenSpUuKj4/X7t279euvv2r+/Pn6448/3JZryZIl1bp1a9WqVUtVq1bV3XffrQIFCih//vzKnz+/JCk5OVmJiYlKSkrS6dOn9dtvv+m3337Tli1bdPjwYbfkzffV3GGu8C6+/N3VTL6+brXSXJUdb5gTfP15dJZ27dpp6dKlt/4+f/58denSxY0ZGbPKesxq84/V8jVbWFiY6tevr6ioKN17770qXbq0SpYsqbvuuktFixbNdOzRo0d1+PBhHT9+XMePH9e+ffu0Zs0aHT9+3C25Fy9eXM2bN1eNGjVUuXJlVapUSUWKFFF4eLjCwsIUGhqq9PR0XblyRcnJyTp16pT+/PNP/fbbb9q2bZvWr1+vlJQUt+TubO6c85irrN2vkDVvWE/C+RgHAQCuZNU9favscfydL64Hrbw/XKFCBbVo0UJNmjRR5cqVVb58eRUsWFBhYWHy8/NTYmKiLl26pBMnTmjnzp365ZdftHjxYl2+fNltObvrGbPyfXYHX9xPdGTcnjFjhsPtz5w5Uz179rSJZ7eXX7VqVT388MOqX7++atasqaJFi6pgwYK8k+zjrP6ekStY6X1+Sdq2bZsaNGhgE//iiy80bNgwN2TkfL64LnWUr4+zvv75XYl5JjP2yz0Xc0nu+fpYmtPxbdKkSR43tlnt3nnanpZV96BvsvrcbLXnFwAAAAAAwBc48vNxflc7AHvq1KmjOnXqSPprnDly5Ig2b97s1ndyAPiODh07qFWrVu5OAz7k999/11dffuXuNADAaQYNGqQaNWu4Ow34iI0bNyp6XrS70wAAp3l11KsqXLiwu9OAj5j3wzxt2rTJ3WkAgFNERERo1Guj3J0GfMzYj8bq9OnT7k4DAJzi7iip29vuzgK+5IP27s4AALybn5+fGjZsqKpVq9563zs2NlaxsbFuzgwAAABW89bbbyk0NJQ9cgBwsZvvmX35xZc6evSou9MBAJ8x9Lmhqlixor755hvt38fvrgYAV7j5bxd59x0AXKtL1y66//77FbMoRqtWrXJ3OgDgM27+XqyVK1dqccxid6cDAAAAA/yudgDOwO9qB+BpHnzwQXXs1NHdacAHsTcKwJcw38IdmGsB+BL+22RwB965BOBLmGvhLvwbMwC+pO3zUv3O7s4CvmbZ59LORe7OAgBci9/V7ll4pxYAYEWbNm1SkyZNbOKNGzfW1q1b3ZCR/X8Dx79vc4wzruvjjz+uuXPn2sRjYmLUqVOnPNeLrFn9unft2lU//PCDTXzu3Lnq3r27U9pkXAEAAAAAAAAAAAAA7+Xn56eoqChVqVKF92kB5FhO3vEOdEEeAADAi6SlpWnt2rVau3atu1PxWr52jVNTU7V8+XItX77c3ak4JCUlRYcOHXJ3Gqbyxs/kbL7Wf3Ni9+7d2r17t7vTyBFfvn8RERF2yy5evOi6RAAf5w19MSkpSXPmzNGcOXPcnYrP8Jb1NHCn1NRULVq0SIsWWfM3rW3evFmbN292dxo5cubMGc2YMcPdaeQa31dzh7nCu/jyd1cz+fq61UpzVXa8YU7w9efRWfz9/TP9PT093U2ZZM0q6zGrzT9Wy9dsKSkp2rBhgzZs2JApXr58ef3xxx+ZYn369NHGjRtdmV6Wzp07Z/gLm+DeOY+5ytr9ClnzhvUknI9xEADgSlbd07fKHsff+eJ60Mr7w0ePHtXRo0c1ZcoUd6eSY+56xqx8n93BF/cTrTpux8XFaezYse5OI0d88blyF6u/Z+QKVnqfv0aNGmrQoIFh2aRJk1ycjev44rrUUb4+zvr653cl5pnM2C/3XMwluefrY6mVxzer3TtP29Oy6h70TVZ+diXrPb8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgpUqSIYfzIkSMuzsS3cN0BAAAAAAAAAAAAAAAA5/N3dwIAAAAAAMC9KleubLfs+PHjLswE8G30RQAAAAAAzFGgQIFMf09KSnJTJgAAAAAAAAAAAAByYuDAgYbx2NhY7dixw8XZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPi7woULG8YvXbrk4kx8C9cdAAAAAAAAAAAAAAAAcD5/dycAAAAAAADcq1GjRnbLDh486MJMAN9GXwQAAAAAwBz33HNPpr+fP3/eTZkAAAAAAAAAAAAAyE5QUJAGDBhgWDZhwgTXJgMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAUL58+QzjqampLs7Et3DdAQAAAAAAAAAAAAAAAOfzd3cCAAAAAADAvR544AHD+LFjxxQfH+/ibADfRV8EAAAAAMBxxYsX11NPPZUptn37djdlAwAAAAAAAAAAACA73bp1U/HixW3iV69e1fTp092QEQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8BWB7k4AAAAAAAC4T40aNdSkSRPDspUrV7o4G8B30RcBAAAAAHBcyZIltWjRIt111123YleuXNGSJUvcmBUAAAAAAAAAAAAAe/z8/DRq1CjDspkzZyohIcG1CQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXCIgIEAFChSQn5+fLl++rOvXr7s7JUMFChRQYGCgR+cYFBSk/PnzKz09XYmJicrIyHB3SpmEhIQoPDxcqampunz5srvTybGbeaekpOjq1avuTsfGzfyuXLmiK1euuDsdt/P0+xUaGqrQ0FClp6fr0qVLHtdPYcyq4xfM4enjyk1WWKv4Ak++D8xBAAAAAAAAAAAAAADkTKC7EwAAAAAAAFl78cUXdeLECc2YMcP0uv/xj3/YLVu4cKHp7QFWRl8EAAAAAMBzNWzYUNHR0Spbtmym+CeffKL4+Hg3ZQUAAAAAAAAAAAAgK3369FGtWrUMy8aOHevibAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAztCoUSO1bt1ajRo1Ur169VSsWDHlz58/0zGpqak6ceKEdu/erR07duinn37SL7/84rIcQ0JC9NBDD+mhhx5S3bp1VaNGDRUuXFh+fn6Zcvzjjz+0e/dubdy4UfPnz9ehQ4dclqMk1atXT507d1bDhg11zz33qEyZMgoJCblVnpGRocTERO3du1e//vqrYmJitGzZMqWlpbkkv9q1a+vRRx9Vo0aNVKdOHZUpU0ZBQUGZ8rt48aL27Nmj2NhYLVu2TMuWLdPVq1dNzaNmzZo2sTNnzujChQuGxxcpUkTdu3dXq1atVL9+fUVGRio4OPhWeUpKis6dO6d9+/Zp+fLlWrZsmXbv3m1qzlkpU6aMunTpoubNm6tu3bqqUKFCpvxu3Liho0eP3rqm8+fP15kzZ1yWn6sVLlxYjz76qDp06KA6deqoUqVKmZ4zd96voKAgPfjgg2rfvr3q1KmjWrVqqXjx4goICLh1TEZGhhISEhQfH69du3ZpzZo1WrNmjXbt2uWSHLNSpEgRlSpVym55yZIl7caN+l129u7dm+tznMWd45fVr3uxYsVUokQJu+Xly5c3jBcqVCjX+aempjpl7vXkceUmq6xV7CldurQiIiJs4snJyfrjjz+c0mZgYKCqVq1qE09PT9f+/fvzVKcn3wdPmoNyuxaT/rq2derUUeXKlVWoUCEVKFAg03X97LPPTF8zAgAAAAAAAAAAAABwp0B3JwAAAAAAAIyVLFlS06ZNU9u2bZWYmKhff/1VBw4cMK3+pk2bavDgwYZl586d08KFC01rC7Ay+iIAAAAAAJ7t6aef1ueff57pl5JJ0pIlS/T666+7KSsAAAAAAAAAAAAAWSlRooQ++eQTw7KffvpJe/bscW1CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADTBAUFaciQIRoyZIhq1qyZ7fHBwcGqWLGiKlasqIcfflijR4/W8ePH9dlnn+nrr79WYmKiU/IsV66cXnnlFT355JPKnz9/tjlWqVJFVapUUZcuXfThhx/ql19+0Xvvvaf58+c7JT9JCgsL09NPP60XXnhBFStWzPJYPz8/FSpUSPfdd5/uu+8+Pf/88zp37pw++eQT/fe//9WVK1dMzy8oKEj9+/fXyJEjVa1atWzzK1KkiJo1a6ZmzZrpueeeU3JysqZPn673339fv//+uyk57dmzxyb28ssv64MPPsgUK126tN566y3169dPQUFBdusLCwtTZGSkIiMj1b59e0nSunXrNHr0aK1evdqUnI00a9ZMr7/+utq0aSM/Pz+7xwUGBqpy5cqqXLmyunbtqi+++ELTp0/Xm2++qaNHjzotP1crUaKEXnvtNQ0ePFghISF2j3PH/SpVqpRGjhypp59+WgULFszyWD8/PxUuXFiFCxdWpUqV1LVrV0nSL7/8ojFjxmj+/PnKyMhwSp7ZGTBggMaOHZvr84YOHaqhQ4fm6pyTJ0+qTJkyuW7LTJ4yfln9ug8dOlRvvvlmrs9r27at4XidlXXr1ql58+a5bsseTx5XbrLCWiUnOnTooIkTJ9rEExISVKpUKV27ds30Nh977DHNmTPHJr548WJ17NgxV3V58n3wxDkop2sxf39/de/eXU8//bRatGihwMBAu3VOnDhRV69edTg3AAAAAAAAAAAAAADs8Xd3AgAAAAAAwFbHjh3122+/qW3btpKkggULavny5apUqZIp9UdGRuq7776Tv7/x1sAXX3yh69evm9IWYGX0RQAAAAAAPJu/v7/69+9v8wtUZs+erUceeURpaWluygzwLFeuXNGSJUsy/UlISHB3WoCl0a8AAAAAAAAAIO8KFiyomJgYFS1a1KYsIyNDo0aNckNWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzNG3aVDt37tRnn32mmjVr5rmesmXL6oMPPtDRo0fVv39/EzOUgoKC9O677+rw4cN69tlnlT9//jzVExUVpejoaK1bt0533323qTlKUq9evXT06FF98sknqlixYp7qKF68uN59910dPHhQrVq1MjW/du3a6eDBg5owYYKqVauWpzrCw8P1zDPP6ODBg/r444+VL18+U3O0p3fv3oqLi9P//d//KSgoKNfnN2vWTKtWrdLcuXMVHh5uam7FixfXvHnztHbtWrVt21Z+fn65Oj8wMFADBgzQ7t27NXToUFNzc5cuXbpo7969GjZsmEJCQnJ9vrPul5+fn0aOHKnff/9dI0aMUMGCBfNcV1RUlObNm6cNGzborrvuMi1HT3XgwAG3tm/l8csR7r7ujtqzZ49pdXnquHKTVdYqOfX999/r8uXLNvGIiAg98sgjTmmzb9++hvFJkybluA5Pvg9Wn4OqV6+uzZs36/vvv1fr1q0VGBjoknYBAAAAAAAAAAAAALDH390JAAAAAACAzFq3bq1FixapePHimeLlypXT1q1b1aVLF4fqb9q0qbZu3arIyEjD8jNnzmjs2LEOtQF4A/oiAAAAAACeLz09Xd27d9fZs2dv/f21115Tjx49dP36dTdnB3iOc+fOqUOHDpn+7N27191pAZZGvwIAAAAAAACA3PP391eXLl0UGxurBg0aGB4zZcoUxcbGujgzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAZ+vfvrzVr1qhmzZqm1Vm4cGF9++23mjdvnkJCQhyur2zZstq6dateffVVBQUFmZCh9MADDyg2NladOnUypb7Q0FDNnTtXM2bMUPHixU2ps0yZMlq+fLleeuklh+vy9/fXl19+qaVLlyoyMtKE7KSAgAD985//VGxsrKpXr25Knfa88847+u677xQeHu5wXY8//rg2b96sChUqOJ6YpEaNGmn37t3q0qWLw3WFh4fryy+/1Pjx4+Xv729Cdu7x0ksvad68eSpatKjDdZl5vwoWLKiVK1fqww8/VL58+Ryu76b77rtP27dvV+PGjU2r0xMdOHDALe1affxylLuuu1n27NljSj2eOq7cZIW1Sm4lJydr5syZhmUDBgwwvb2IiAh16NDBJh4fH68FCxbkqA5Pvg9Wn4MaN26sTZs2KSoqyqntAAAAAAAAAAAAAACQG9Z9yw4AAAAAAC+1atUq/fLLL4ZlRYoU0bx587R69Wp17dpVoaGhOarT399f9913n+bPn6/169erRIkSdo996qmnlJycnKfcAW9CXwQAAAAAwBpOnTqlXr166cSJE2rbtq3effddd6cEAAAAAAAAAAAA+LTQ0FANHz5cw4cP1yuvvKL3339f0dHROnnypObNm2f3P5hx/vx5jRw50sXZAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADMMHDgQE2ePFkBAQE5Ov7KlStKSUlRRkZGjo7v0qWLli5dqpCQkDznWKVKFW3cuFH16tXL0fE3btzQlStXcnRseHi45s+frx49euQ5P0kqUqSIVq9erccff9yheoz4+/vr/fff16hRo/JcR758+fTjjz9q6NChJmZ228171LRpU6fUP2rUKIc+v5HatWtr2bJlKlCggEP1tGjRQj///LNKlChhUmZ/efrpp/X111+bWqerPPfcc3r//fdNrdOM+1W4cGGtXr1aLVu2zNHx6enpSk5O1o0bN3J0fKlSpfTTTz+pXLlyec7R0x04cMDlbVp9/DKDO667mfbs2eNwHZ46rtxkhbVKXo0fP94w/tBDD6lUqVKmttW9e3cFBwfbxGfMmKHU1NRsz/fk+2D1Oejuu+/WkiVLFBER4ZT6AQAAAAAAAAAAAADIq0B3JwAAAAAAADJLT09Xnz59tHHjRhUrVszwmBYtWqhFixa6fv26fv31V8XFxen48eNKSkrS1atXJf31In7RokUVGRmpZs2aqVChQtm2/Z///Ec//fSTqZ8HsCr6IgAAAAAA1rFy5UrdfffdOfrlGgAAAAAAAAAAAACcq0CBAho7dmyuzklPT1fv3r114cIFJ2UFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHCWu+++W1988YX8/PwMy0+ePKkZM2Zo6dKl2r17t86ePav09PRb5UWKFFHVqlX1wAMP6PHHH1eTJk0M62nRooU+++wzPfPMM7nOsUiRIlq2bJnKlStn95jY2FjNmjVLy5Yt0+HDh3Xx4kVJUnBwsIoVK6aGDRuqXbt26tOnjyIiImzODwwM1JQpU3T06FFt2bIl1zkGBwdr4cKFatSokd1j0tLStGHDBsXExGjbtm06c+aMLly4ID8/PxUqVEhVqlRR8+bN1atXL5UuXdqwjnfeeUeHDh3SrFmzcp3jtGnT1LlzZ7vl6enp2rRpkxYuXKhffvlFp0+fVnx8vMLCwlSyZElVrlxZHTt2VPv27Q2voSQVLlxYixYt0n333ad9+/blOkd72rRpo7feessmnpGRobVr12r+/Pnatm2bTpw4oZSUFBUsWFDFixdX/fr11bFjRz300EMKCAgwrLtKlSqaMmWKunbtmqfcKlWqpPnz5yt//vx2j7l27ZpWrlypmJgYxcbG6syZM0pISFBISIiKFi2qe+65R23atNGjjz6qggULZjr3qaee0q5du/KUm7s0adJEn376qU3cE+7Xd999p/r169stX7dunebOnasNGzYoLi5OSUlJt8oKFCigihUrqmXLlurXr58aNGhgWEexYsX0ww8/qGnTprp+/Xqe8sytU6dOafPmzXbLy5Ytq7Jly9rEjx8/ruPHj+eqrW3btuU6P0d56vhl9et+/PjxLPMvWrSoqlSpYhOPj49XXFxcrtravXt3rvO7kyePK5I11iqO2LZtm3bt2qW6detmigcEBKhPnz4aO3asaW317dvXMD5p0qRsz/X0+2DlOSggIEDz5s2zO4YCAAAAAAAAAAAAAOBOge5OAAAAAAAA2Dp48KA6duyo5cuXq1ChQnaPCwoKUpMmTez+49TcGDdunF555RWH6wG8CX0RAAAAAADrSE1NdXcKAAAAAAAAAAAAAPIgIyNDQ4YM0fLly92dCgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgDz755BOFhYXZxNPT0zV69Gh99NFHunbtmt3z4+PjtXnzZm3evFkfffSR7r//fo0bN0516tSxOXbw4MGaO3euli9fnqscZ82apQoVKhiW/fnnnxo+fLjmzp1rWJ6amqqTJ09qwYIFWrBggV599VW9/PLL+te//iV/f/9Mx4aEhGju3LmqXr26kpOTc5XjuHHjdP/999stnzt3rkaNGqW4uDjD8pMnT2rfvn1asGCB/vWvf+n555/Xe++9p9DQUJtjv/76a23YsEHHjx/PcX6vv/66unXrZrd8yZIleumll/Tbb78Zlh85ckSbNm3StGnTFB4eruHDh+ull15S/vz5bY4tVKiQFi1apHr16ikxMTHHOdqTL18+TZw40eZ+LVq0SC+//LL27Nljc86ZM2d08OBBbdy4UV9++aVq1qypzz77TK1btzZso0uXLurevbvmzJmTq9wCAwM1b948RUREGJanpaVp0qRJevPNN3XixAnDY44dO6YdO3Zo6tSpKlCggP7xj3/otddeU758+W4d8/777ys+Pj5XubnT+PHjFRAQkCnmCfdr2LBh6tChg2HZ9u3b9eyzz2rr1q12z09KSlJsbKxiY2P12WefqWvXrpo8ebIKFixoc2xUVJQGDBigCRMm5CrHvJo5c6Zmzpxpt3z06NF68803beITJkzQW2+95czUHObJ45fVr/ukSZM0adIku+Vdu3bVDz/8YBNfuXKlunfv7szUbHjquHKTFdYqjpowYYK++OILm/iAAQM0duxYU9ooW7asmjVrZhPftWuXduzYke35nnwfrD4HPf/886pbt65N/OLFi/rxxx/1008/6bffftOZM2d06dIl09oFAAAAAAAAAAAAACAn/LM/BAAAAAAAuMMvv/yiqKgo7du3z6ntXL9+XSNHjtTQoUOd2g5gVfRFAAAAAAAAAAAAAAAAAAAAwDmSkpLUo0cPl/3HSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5ipevLg6dOhgWNarVy+9++67unbtWq7q3Lhxo6KiojRv3jzD8rfeeitX9fXt21dt2rQxLNuwYYMaNGiguXPn5ri+xMREjRo1Sp06dVJSUpJNedmyZfXmm2/mKsc2bdpo0KBBhmVXrlxR9+7d1b17d8XFxeWovhs3buiTTz7R/fffr3PnztmUFypUKFc51q5dW6+//rrdtp555hl16NBBv/32W47qS05O1ttvv626detq3759hsdUrFhRH3zwQY5zzMpTTz2lyMhIm5w7d+6sPXv25KiOvXv3ql27dpo8ebLdY1566aVc5/bCCy+oTp06hmUXL15Uu3btNHjwYJ04cSJH9SUlJendd99V/fr19fvvv9+Kh4WFqWzZsrnOz13uueeeW//fU+5XwYIF9cYbbxiWTZ8+XY0aNdLWrVtzVee8efPUtGlTXbp0ybD8xRdflJ+fX67qRGZWH79gHk8cV26ywlrFDNOnT9eVK1ds4rVr11b9+vVNaaN3796G4+akSZOyPdeT74PV56CwsDC99tprmWLXrl3T+++/r4oVK2rgwIH64YcfFBcXZzcfAAAAAAAAAAAAAACcyd/dCQAAAAAAAPsOHjyoe++9V6+//rqSk5NNr3/9+vVq3Lixxo4da3rdgDehLwIAAAAAAAAAAAAAAAAAAADmSU5O1oQJE1SjRg3NmTPH3ekAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPLo4YcfVmBgoE181qxZmj17dp7rTU1NVY8ePbRp06ZM8eXLl2v06NE5ridfvnz64IMPDMt27dqlNm3a6Ny5c3nKccmSJerXr59h2bBhw1SyZMkc1ePv76+vvvrKsCwlJUUtW7bU3Llz85Tjzp071aZNG6WkpNiUNWrUSMHBwTmq53//+5+CgoJs4tevX1fHjh01fvz4POV35MgRNW7cWJs3bzYsHzx4sBo1apSnuu9Urly5W/8/PT1dPXr0yFPO6enpGjRokNauXWtY3rBhQzVv3jzH9UVEROiNN94wLIuPj1fjxo21cuXKXOcpSfv371fTpk11/PjxPJ3vKTzpfgUFBWnmzJm6evVqpnhMTIyefPJJpaWl5TpHSdq9e7eee+45w7IqVaqoQ4cOeaoXf7H6+AXzedK4IlljrWKWS5cu2V3TDBw40JQ2+vbtaxO7fv26vvvuuyzP8/T7YPU5qFevXipWrNitv58/f16tWrXSv/71L126dMmUNgAAAAAAAAAAAAAAcIS/uxMAAAAAAABZu3r1qt555x1VqFBBI0aM0N69ex2q79q1a5o/f77atm2rZs2aaceOHSZlCng3+iIAAAAAAAAAAAAAAAAAAHl38uRJ7d+/3+bPiRMn3J0aAJOlpaVl6ue7du3Sxo0bNWfOHL333nt6+OGHVaJECQ0ePJgxAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsrlKlSobxKVOmOFz3jRs3NHDgQF25ckXTpk1T3bp11a5dOy1fvjzHdfTu3Vt33XWXTTwxMVFdunTR1atXHcpx/vz5mjhxok08ODhYzz33XI7q6Nq1q6pUqWJYNnToUG3dutWhHGNjYzV8+PBbf9+6dau6dOmiOnXqKDU1NdvzmzVrpqZNmxqWvfjii7m6H0aSkpL0+OOP6+zZszZlfn5+evXVVx2q/+/eeOMNzZs3z6E6BgwYoOvXrxuWPfroozmuZ9CgQSpQoIBNPCMjQ3379tXBgwfznKMknTp1So8//rjS0tIcqsedPOl+XbhwQcOGDVPFihU1duxYJScnKyEhQf369XMoP0n67rvv9NtvvxmWtW7d2uH6fZW3jV8whyeNK5I11ipmGj9+vGG8d+/eCgwMdKju2rVr65577rGJL1y4UBcuXMjyXE+/D1afg6pWrXrr/yckJOi+++7Txo0bTakbAAAAAAAAAAAAAAAzOPbWAgAAAAAAcJnz58/r448/1scff6yyZcuqZcuWql+/vipVqqSKFSuqYMGCCg8PV2hoqCTp2rVrunLlis6ePas///xTsbGx2rp1q1atWqXk5GQ3fxrAuuiLAAAAAAAAAAAAAAAAAADk3ogRIzRixAh3pwHABS5cuKAaNWq4Ow0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC4UHh4uP71r39lim3atEkxMTFuysi9Ro0apXz58t36e1xcnKZNm+bGjAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADnKV26tGH88OHDptR/4MABlSxZUklJSXk6//nnnzeMf/bZZ/r9998dSe2WMWPGaNCgQfL3988U79evn0aPHp3t+S+88IJhfMGCBZoyZYopOY4fP15169bVrFmztGbNmlydO3LkSMP4ihUr9Omnn5qRnk6ePKmnn35aP/74o03ZI488oipVqujgwYMOt7Nr1y6NGTPG4Xp+//13zZ8/X927d7cpe+CBB3Jcz7PPPmsY//bbb7V48eI853enrVu36uuvv9bQoUNNqc+VPO1+3XT69GmNHDlSY8aMUc2aNXXhwgWHc5Skr7/+Wl988YVNvFmzZqbU74u8afyCOTxxXLHCWsVM69ev1/79+1W9evVM8aJFi6pTp06GfSmn+vbtaxifNGlStuda5T54wxw0aNAgHTp0yPR6AQAAAAAAAAAAAABwRKC7EwAAAAAAALl3/PhxTZ8+XdOnT3d3KoBPoy8CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgpyIjI1WzZk1FRkYqIiJCYWFhunHjhhISEnTx4kXt2bNHsbGxunHjhrtTBXLl3nvv1WuvvZYp9vzzz7spG/cqUaKE3nnnnUyxTz/9VNOmTcvyvIiICJUuXTpT7NSpU7p48aLpOQIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABmCgkJMYxnZGSY1kZSUlKezitfvrzq169vE09JSdF///tfR9O65ciRI1qxYoXatWuXKR4ZGakaNWpo3759ds8tUaKEmjZtalj2/vvvm5ZjRkaGhg4dmuvzChQooA4dOhiWjRkzxtG0MlmwYIH27NmjWrVqZYr7+fmpW7duprT3+uuvKy0tzeF6JGny5Mnq3r27Tfzee+9VWFiYUlJSsjy/atWqqly5smHZ2LFjTcnxpnfeeUeDBw9WYGCgqfU6myfdLyMXLlzQunXrzEhPkrRy5UrDeP369RUQEGDatfAV3jZ+wRyeNq5YYa3iDBMmTDCc6wYMGKAff/wxz/X26tXLJnb69GktWbIky/OseB+sOgdFR0crOjralLoAAAAAAAAAAAAAADCTtd6uAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACLaN26tXr16qVOnTqpVKlS2R5/7do1LVu2TN98840WLlyo9PR0h9r/97//rdatW2eKXb58WR06dHCo3rwYPHiwnnzySZt4ly5ddP78eZfnA/Pce++9NrHt27e7IRP3M7oWv/76a7bnjRw5UqNGjcoUe/TRR7VgwQLTcoMxo3GyW7duOnPmjKntPP/88+rRo0em2FNPPaUDBw7kuc6yZcvqwQcfVN26dVWhQgUVLFhQoaGhunLlihISErR//35t3bpVK1as0NWrVx39CFmqWLGimjdvrnr16ikyMlIFCxZUSEiIUlJSlJCQoKNHj2rLli1avXq14uPjnZoLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwrYSEBMN4xYoVdfDgQdcm8zdt27Y1jK9YscL035m8evVqtWvXzibesmVL7du3z+557du3l5+fn018x44d2rhxo6k55kW7du0UFBRkE9+9e7dWrlxpenuffPKJJkyYYBN/+OGHNWbMGIfq/uOPP7Rw4UKH6rjThg0blJGRYXP/AgMDFRkZmeV9l2T4vEjS2rVrtWfPHtPylKRTp07pp59+0mOPPWZqvc7kaffLFfbv36/Lly8rf/78meKBgYEqXLgw/32PXPKm8Qvm8MRxxQprFWeYMmWKxowZo+Dg4EzxTp06qVixYnka75o1a6by5cvbxKdNm6a0tLQsz/XV+3AnV81Bn3zyiSn1AAAAAAAAAAAAAABgtkB3JwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3qR79+568803VaNGjVydFxISoocfflgPP/ywYmNjNXToUG3YsCHPeTz++OOqXbu2Tbxq1aqKi4vLc725VbFiRf33v/9VWFhYpnhCQoLOnz/vsjzgHA0aNMj09/T0dO3atctN2bjX36+FJO3YsSPb8+rWrWsT27lzpxkpIRt/HyeTkpJ05swZ09t59NFH9cADD9z6e3p6uv78889c1+Pn56cnnnhCw4cPV6NGjXJ0TkpKir755hu99957On36dK7btCc4OFj9+/fX0KFDVa9evRydc+3aNUVHR+vtt9/W3r17TcsFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC4z6lTpwzjvXr10rJly1ycTWZ3/n7oOy1dutT0tjZv3mwYr1WrVpbnNWvWzDDujBzz4sEHHzSML1myxCnt2au3cePGCgkJ0bVr1/Jc908//ZTnc40kJibq8OHDqly5sk1Z4cKFsz2/cePGhvFVq1Y5nJuRmJgYPfbYY06p2xk87X65QkZGhk6dOqUqVarYlBUpUoT/xkcuedP4BXN44rhihbWKM1y4cEHz58/XE088kSkeFBSkXr166fPPP891nX379jWMT548OdtzffU+3MkVc9D+/fu1du1ah+sBAAAAAAAAAAAAAMAZ/N2dAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4g3LlymnlypWaPXu2atSo4VBdderU0bp16zR8+PA8nR8SEqLq1asbljVv3tyR1HJtwoQJCgsLs4nv2LHDpXnAOerXr5/p7wcOHFBKSoqbsnGvBg0aZPr71atXtW/fvmzPq1evXqa/X7p0SceOHTMzNRgwGid37tzplLbM6Cf33nuvdu3ape+//16NGjXK8XlhYWEaNmyY9u3bp+7du+eqTXs6duyoAwcOaPz48TbPb1ZCQkLUs2dP7dy5U6NHjzYlFwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4F7r1683jPfr18+0342cV/Z+Z/+mTZtMb+vUqVOG8apVq2Z5nr3/tsHGjRsdzskMNWvWNIzbu++OOn78uP7880+buL+/v6pVq+ZQ3WvXrnXofCNGuUpSkSJFsj3X3udxxvMpSevWrXNKvc7iaffLVS5dumQY96QcrcKbxi+YwxPHFSusVZxl/PjxhvEBAwbkuq6goCB169bNJr5ly5Yc/bdjfPk+3MnZc9Dq1atNqQcAAAAAAAAAAAAAAGfwd3cCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGB1LVu21K5du/Tggw/aPSY5OVmHDh3Shg0btHLlSm3ZskVHjhxRRkaG4fF+fn4aO3asRo8enet86tSpo8DAQLu5ukr//v3VunVrw7Lt27e7LA84R758+VSjRo1MMV++rw0aNMj099jYWKWlpWV5TpEiRVS2bNlMsZ07d5qdGgwYjZPOeH7LlSunokWLZort2LEjV3U888wz2rJli+6555485xEREaFZs2ZpyJAhea5Dkj788EMtWrRIFSpUyHMdQUFBevPNNzV16lT5+/s7lA8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHCv9evX68KFCzZxf39/zZo1S1OmTFHdunXdkJlUtWpVw/gff/xhelsXL140jBcuXDjL86pVq2YYz+3vs3aWv/8++pv+P3v3HR1Vnf9//DVJJj0QakLohN4kCVWRIiCCFGXFgqBYsa1td0WK+l0LlrXh6iqo4IooiiwKUgSUjoCmQOihJZSQkIRASC/z+2N/zHozk2RaCODzcQ6HfN73835/3rfMnZyTe2aq83PpY2NjnerFUXv37nUr356zZ8/ajYeGhlaZ26ZNG7vxnTt3utNShQ4dOqSysrJqqV0dLrXzVZ3Cw8N1zTXXaMKECapbt67dOb6+vhe5q8vflXT/gmdciveVy+F3lery008/6fDhwzbx6Ohode7c2alaw4YNs3v/nDNnjkP5f+TzcDHfg7Zt2+aROgAAAAAAAAAAAAAAVAefmm4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC5nN910k77++mv5+vrabEtNTdWcOXO0ZMkSbd++3W5+UFCQBg4cqHvuuUdjxoyx2f5///d/io2N1bJlyxzuKTo6usJt/fv3d7iOOxo2bKi33367wu2xsbEXpQ9Un65du8rb29sQi4uLq6FualbdunXVrFkzQ8yRY3HVVVfZxBISEjzVFiph7z5ZHfcld9eZMmWKZsyYYXdbamqqNm7cqP379+vMmTMqLS1V3bp11aFDBw0ePFh169Y1zDeZTHr//fe1Z88ebdiwwbkdkTRv3jyNHz/e7racnBytWbNGBw8eVFpamoqLi9WoUSM1bdpUQ4cOVf369W1yJkyYoOPHj2vq1KlO9wIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC4NxcXFevXVV/Xmm2/abDOZTLrrrrt011136fjx4/r111+1e/duHTx40PovLS2t2nqrU6eOTSw/P19ZWVkeX+v8+fN24yEhIZXmlf886QtOnz7tdk+e0KBBA7vx6uwvIyPDbtze510748SJE27l23Pu3Dm7cS8vrypza9eubTeemZnpVk8VKS4u1smTJ9WkSZNqqe9pl9r5coefn59atGihyMhItWrVSq1bt1arVq2s/wICAqp1/T+qK+n+Bc+4FO8rl8PvKtXpk08+sfudHBMnTtRf//pXh+vY+y6N/Px8LViwwKH8K/k8XErvQTt27LhoawEAAAAAAAAAAAAA4Cyfmm4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC5XgwYN0tdffy1fX19DPDc3V6+++qrefvtt5efnV1ojNzdXP/zwg3744Qf16dNHCxcuVOPGja3bTSaTZs+erVatWqmwsNChvmJiYirc1qRJE7Vs2VJHjhxxqJar/vnPf6pu3boVbo+Pj6/W9VH9oqOjbWJxcXE10EnNs/eai42NrTJv27Ztat68uSF25swZj/WFitk7Z9Vx/bqzzoQJEzRjxgyb+LZt2zR9+nStWbOmwlw/Pz898sgjmjFjhvz9/a1xb29vffjhh+rSpYvKysoc6kOS3nrrLY0fP94mfuTIET377LP67rvvVFRUZDfXx8dHo0eP1gcffKCwsDDDtmeffVbLly/Xpk2bHO4FAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABcWv75z3/q5ptv1jXXXFPhnCZNmqhJkya6+eabDfHc3FwdOnRIBw8e1MGDB5WUlKQdO3Zo586dDn8+vz2BgYEymUw28YCAgCq/Q8AV9taS/vuZ0RUJDAyUl5eXTbywsNCtffeUgIAAeXt728QLCwtVUFBQbetW9HntISEhbtXNyclxK98eZz7v+/cquj4LCwsr/MxvT6iOY1BdLqXz5aiIiAjFxMSoa9euat26tVq1aqXIyEhFRERUeI9A9bjS7l/wjEvtvnI5/K5S3ebOnasXX3xRPj4+hvidd96pZ555xqHjGxISopEjR9rEFy9erHPnzlWZf6Wch8vhPSgzM7OmWwAAAAAAAAAAAAAAoEI+VU8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJTXvHlzffPNN/L19TXEjx07phtvvFGJiYlO1/zll1/Up08f/frrrwoLC7PGIyIi9PDDD+vdd991qE5UVFSl2/v3768jR4443Z+jRo4cqVtvvbXC7Xl5edq/f3+1rY+LIyYmxiYWHx9fA53UvOjoaJuYI8ciLy9PKSkp1dESqlD+PllQUKB9+/Z5fB1710ZCQkKVee3bt9fHH39sE3/99dc1depUlZWVVZpfWFiod955R9u2bdOaNWsUEBBg3daxY0fdeOONWrp0adU7IGnMmDF6+umnbeIff/yx/vznP6uwsLDS/JKSEi1atEhbtmzRypUr1bVrV+s2k8mkGTNmqF+/fg71AgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALj1FRUUaPXq0Vq9eXeVn5ZcXFBSkrl27Gj6/WPrv5xuvX79e8+fP14IFC5Sfn+903Yr4+/s7Vau6VNTjuXPnLnIn9tVUf2fOnLEbr1Wrllt1i4uL3cr3pJo6trm5udVa35MupfNVmU6dOumuu+7SbbfdpubNm9d0O/j/rrT7FzzjUruvXA6/q1S3U6dOafny5Ro1apQhHh4erqFDh2rFihVV1hgzZozd4zVnzhyHericz8Pl9h509uzZmm4BAAAAAAAAAAAAAIAK+dR0AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwuapdu7aaN2/u8bppp9KUlp5W4XYvLy917tzZY+uVlJRoz549HqtXmQD/ALVt11bNmjVT/fr1FRIcIrPZLEkqLi5WzvkcZZzOUEpKig4cOKD8gnyX1vH19VW3bt3UOrK16tSpI39/fxUWFio7O1uHDh9SQnyCy7V/r3279vL187WOjx8/rqysLLfrAgAAAAAAAAAAAAAufSaTSfPnz1fdunUN8b1792rgwIFKS6v4b/9VOXbsmO69914tW7bMEL///vv17rvvVpnv4+OjLl26VDpnwIAB+uyzz1zusTIhISH68MMPK52TkJAgi8VSLevj4omKijKMDx8+rLNnz9ZQNzUrJibGMC4pKVFiYmINdYOq2LtP7ty5U6WlpR5fq/zr5MiRI8rOzq4yb+bMmfLz8zPEXnnlFU2fPt2p9bds2aLJkyfrvffeM8THjh2rpUuXVpkfGhqqjz76yCb++uuv69lnn3Wql9TUVN12222Ki4tTQECANX7ttdeqe/fu+u2335yqBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALh2ZmZnq06eP3n77bU2aNEne3t5u1fPx8dGgQYM0aNAgvfzyy5o+fbrmzp3rcL7JZHJr/Yuhoh6r4zOzXeHl5WU3Xt39VVT/cjinjqqpc19SUlKt9f9ImjdvrldffVW33377FXVtXim4f+FywHXxX7Nnz9aoUaNs4hMnTtSKFSuqzB8/frxNLCUlRT///LND61+O5+FyfQ86d+5cTbcAAAAAAAAAAAAAAECFfGq6AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC4XIWHh+v6Idd7vO7mLZuVlp5W4XY/Pz+Prpubm6s9e/Z4rJ49/v7+6ntNX3Xp0kXe3t525/j6+qpe3XqqV7ee2rVrp4EDByoxMVGbNm9SYWGhw2s1b9ZcN464UYEBgTY9hIeHKzw8XN1jumvFyhU6ePCgy/vUqVMnDbthmHWckZFR7ccRAAAAAAAAAAAAAHDpeOihh3TNNdcYYmfOnNGIESOUllbx3/0dtXz5cm3dulW9e/e2xjp16qTWrVtX+ffujh07ys/Pr9I5/fv3d7vHirz++utq3LhxpXPi4uKqbX1cHD4+PurSpYsh9kc+rzExMYbx7t27VVRUVEPdoCr27pPVcf02bNhQERERLq1z++2367nnntOjjz4qX19fLV++XNOnT3epj48//lgvvviiQkNDrbGoqCiHcv/+97+rQYMGhtgPP/ygZ5991qVe9u3bp3feeUdTp041xG+55Rb99ttvLtUEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACXhsLCQj366KOaOXOmpkyZojFjxqhWrVpu142IiNCcOXM0ZMgQ3XPPPSosLPRAtwDgmsGDB2vhwoWGz393VlZWlpKSkpSUlKT9+/dbf/7ggw8M31UCAFe6FStW6Pjx42rSpIkhPnr0aIWGhio7O7vC3PDwcF133XU28X//+9+yWCyebvWScDm/B12p5wQAAAAAAAAAAAAAcGXwqekGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADO8fX1rekWnBIREaHRo0YrKCjIqTwfHx9FRUWpTZs2+u7773Tq1Kkqc5o1a6YxY8bI29vbGisoKFB+fr4CAgLk7+8vSfLz89PoUaP1/fff6+Chg87tkKR69epp8KDB1nFxcbGWLl2qkpISp2sBAAAAAAAAAAAAAC4/wcHBevHFF23it99+uw4fPuyxdebPn6/evXvr6NGjWrp0qZYsWaLk5OQq86Kjo21imzZtUt++fa3jFi1aqGnTpjp27JjH+pWkvn376qGHHjLEzp07p1q1ahlicXFxHl0XF1+nTp1snmOJjY2toW5qVu3atdWqVStDjGv80mbvPlkd16+9dRy9Ns6cOaOnn35a//znP/V///d/mjJlist9FBQUKCEhQQMGDLDGwsLCqsyLiIjQpEmTDLH09HTdfffdLvciSZ999pmmTp1qiN1www169tln3aoLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuDQcOHNA999yjSZMmacCAAerRo4diYmLUvn17tWrVSn5+fi7VveOOOxQSEqKRI0dWOddisdiNZ2dna8GCBS6t74rMzMwKt5WVldmN+/j4VFc7TiktLbUbr+7+zGaz3XhF/VyOKtqXivbdU6q7/h/BsGHDtHTpUnl7e1c59/z58zpw4IAOHDigpKQkw/9nzpyxm1NQUODplv+QuH/hcnA5/K5yMZSVlWnu3Ll67rnnDHE/Pz/ddtttmjVrVoW5t99+u7y8vAwxi8WiuXPnOrz+5XQeeA8CAAAAAAAAAAAAAKD6XBpPbgIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArMrKyirdbjabL1In7mvapKn+9Kc/ycfH9uvzzp49q8zMTOXm5kqSgoKCVK9ePdWuXdswLzg4WLfdepsWfrtQJ0+erHAtX19f3Tj8Rnl7e0uScnNztXLlSh05esQ6p1mzZhp2wzCFhITIZDLphhtu0KdzPlV+fr7D++Tj46ORI0cazsOan9YoMyvT4RoAAAAAAAAAAAAAgMvbE088ofr16xtiCxcu1KpVqzw/t//MAAEZFElEQVS6zldffaWff/5Ze/bscSovOjraMC4rK9PMmTPVt29fQ7xfv36aP3++231e4Ovrq08++UQmk8kaO3/+vBYsWKAHH3zQMDcuLs5j6zorPDxcERERql+/vmrXrq28vDxlZmZq9+7dysnJqbG+qkOLFi3UsGFD1a9fX8HBwcrPz9eZM2e0Z88eZWVluVW7/HUm1ex59ZQGDRqoWbNmatCggWrVqqXc3FydPHlSiYmJKikpsZtzqR6L+vXrq2PHjqpTp47MZrMyMzOVlpamAwcOVLgvnlq3WbNm1tdYfn6+0tLStHPnThUWFlbbus6wd87i4+MvyjrOXhtHjhzR3Xff7XYvZ8+eNYx/f6+uyJ///Gf5+fkZYjNmzHD7/pGUlKQ9e/aoY8eO1liHDh3k7e2t0tJSt2oDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBLR1FRkVatWmX4LH+TyaQmTZqodevWat26tdq0aWP9uXXr1goICKi05ogRIzR16lTNmDGj0nkFBQV24+fPn9fDDz/s/M5Ug4p6rF279kXuxL7z58/bjYeGhlbrunXr1rUbP3fuXLWuezHl5ubajVf3uQ8KCqrW+le6Fi1a6Msvv5S3t7fd7ZmZmVq0aJFWr16tX3/9VcnJyU6v4cjnyKNq3L9wObgcfle5WD755BNNmzZNXl5ehvjEiRM1a9asCvPGjx9vE9uwYYOOHDni8NqXy3ngPQgAAAAAAAAAAAAAgOrlU9MNAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDl6ujRo5o3b55bNTp37qyoqCjruKSkRHv37K00x2w2G8brN6xXSnKKyz2UWcpczq1MYGCgRo8eLR8f41fnHTp0SFu2bFFaeprdvLCGYbr66qsVGRlpjZnNZt00+ibNmTtHBQUFdvO6du2qoKAg6/j7Jd/r5MmThjkpKSla/N1iTRg/QSaTSf7+/orqFqUtv2xxeL8GDxqs+vXqW8e79+zW7t27Hc4HAAAAAAAAAAAAAFzefH199ec//9kQKyws1DPPPOPxtTIzM5WZmel0XnR0tGG8b98+rVq1SqWlpfL29rbGBwwYoPnz57vd5wXPPfec2rVrZ4hNmTJF/fv3N8SKioou+t/aBwwYoDvvvFPXXXedWrVqZXeOxWLRjh07NG/ePM2aNUu5ubkO1585c6bq1q1rHRcVFWnSpEkqKSlxutfrrrtO99xzjyFWWlqqyZMnKy3N/vMWF3h5eWnMmDG65ZZbNGDAAIWFhVU498CBA/rqq6/0wQcf6PTp0073Wf46k6T4+Pgq+/vss89kMpmssU2bNmnWrFlOry9J/fv31/3332+Ivfrqq9qzZ49TdZo3b67HHntMQ4cOVZcuXezOyc/P19KlS/XWW29p+/bthm32jkVcXFyV6957770aOHCgdVxaWqqJEyc6lbN582Z99NFH1nF4eLgeffRR3XLLLWrfvr3dGtnZ2Vq6dKlee+01p49VRSIjI/Xoo4/q+uuvV6dOnezOKS4u1qpVqzRz5kytXr3aGvfz89Mnn3ximPvcc8/p6NGjHunNnvLnrKSkRImJidW+jlT166S6NGrUyDAu/2xVeT4+PrrvvvsMsdTUVMP15o59+/apY8eO1rGvr69atmypgwcPeqQ+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC4NFksFh07dkzHjh3T2rVrDdtMJpPatGmjG264QQ899JA6dOhgt8aUKVP00UcfKSsrq8J18vLyZLFYDJ+NLsnwufI1raIezWazAgIClJ+fX0Od/VdhYaFKSkrk4+NjiPv4+CgoKMipz/R3Rp06dezGc3JyqmW9mlBQUKCysjJ5eXkZ4j4+PgoMDFReXl61rFu7du1qqftHMWPGDIWGhtrEz58/rylTpmj27NkqKipya43g4GC38vFf3L9wObgcfle5WFJSUrR69WoNHTrUEO/du7fatm2rAwcO2OS0bdtWMTExNvE5c+Y4tfblch54DwIAAAAAAAAAAAAAoHr5VD0FAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBPYWGh0tLTXM43m81q27atIRYfH69zOecqzfM1+xrGGRkZbvVRXQYPHix/f3/r2GKxaM2aNdqxc0eleWnpaVr83WJ169ZNgwcNtsYDAwM1cOBArVixwm5e+/btrT8fO35MJ0+etDsvPT1dR48eVcuWLa15W37Z4tA+dezYUZ07d7aOM7MytXr1aodyAQAAAAAAAAAAAABXhptuuklhYWGG2BdffKGjR4/WTEPlmEwmdevWzRCLi4vTuXPnlJCQoJiYGGu8f//+Hlu3c+fOmjx5siG2detWffDBB3rqqacM8cTERJWUlHhs7coMGTJEL7/8snr27Fnl3AvHrlu3bvrb3/6mSZMmacmSJQ6tc/r0aT3++OOG2MaNG/XZZ5851W/79u31n//8R7Vr1zbEH330UaWlVf58yF133aXnn39ekZGRDq3Vtm1bvfDCC3rqqaf0zDPPaNasWU71Gh0dbRifOHFCp0+frjSnQ4cOmjBhgiG2e/dup9b9vZEjR2r8+PGG2DPPPONwfmhoqN544w1NnDhRZrO50rkBAQG69dZbdeutt2rOnDl67LHHlJ+fL0nq3r27YW5ZWZl27Kj8GRlJuvfee3XNNddYx7t27XI6Z8+ePZIkX19fTZ8+Xc8884z8/PwqrREaGqoJEybotttu07Rp0/Tmm29WuW5FGjRooLffflt33HGHvL29K51rNpt144036sYbb1RoaKjOnj0rSeratavhPFosFj300EMu91QVe/fJ3bt3q6ioyONrlX+dpKamVvlarg4+Pj6G554k6dChQ5XmDBkyRA0aNDDE5s6dq8LCQo/0dPDgQZtY+XsfAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD4Y7FYLDpw4IAOHDigf/7zn3rhhRf0wgsv2MwLDg7W/fffrzfeeKPCWqWlpTp9+rQaNmxoiAcGBsrf318FBQUe799ZZWVlSktLU3h4uM22sLCwS+J7EE6cOKHmzZvbxMPDw6v8vGtX2TseknTq1KlqWa+mpKWlqVGjRjbxsLAwHTlyxOPr+fv7V3hsUbUWLVrotttus4kXFhZq8ODB2rZtm0fWqV+/vkfqgPsXLn2Xw+8qF9Ps2bM1dOhQm/jEiRM1depUm3j576yRpJycHH377bdOrXs5nAfegwAAAAAAAAAAAAAAqH5eNd0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPxRdY/prqCgIOu4oKBAW7dtrTLPbDYbxiUlJR7vzV3NmzVX2zZtDbGNmzZqx84dDtdISEjQ5s2bDbFOHTspIiLCZq6Pj48aNmhoHackp1RaOzkl2fpz3bp15e/vX2U/devW1ZDBQ6zj4uJiLV269JI8/gAAAAAAAAAAAACA6nPXXXfZxD755JMa6MS+tm3bGp5HkKTY2FhJ0vr16w3xNm3aqFGjRm6vaTKZ9OmnnxqeaSgqKtK9996rkJAQtWzZ0jA/Pj7e7TWrYjab9c4772jVqlXq2bOn0/nh4eH67rvv9MQTTzg0/7333tPZs2cNsSlTpshkMjm8Zr169bRs2TLVrl3bEH/nnXf0r3/9q8K8WrVqaeHChfr3v/+tyMhIh9f7ff5HH32kd955x+Eck8mkq666yhCLi4urMi86Otom5kheRaKiogzj9PR0paamOpTbpUsXxcbG6oEHHrB5Hqcq9957r9auXavg4GBJtvt14MAB5ebmVlrDZDKpW7duhlhVx6KinPDwcG3cuFHPPfec/Pz8HNsJSb6+vvrHP/6hBx980OGc3+vdu7fi4+M1fvx4eXt7O5X7yy+/qF69epKk7t27G7Y5cvzcYe8+6c51WJHQ0FCb+191rOOIa6+9VoGBgYZY+feE8saOHWsT+/LLLz3W0/nz521iF15TAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFotF//d//1fhZ7UPHTq0yhopKfa/875z585u9eZJycnJduMxMTEXuRP79uzZYzfeq1evaluzou8Y2L17d7WtWRMOHDhgN17+89s9pW3btk59hwKMhg8fLi8vL5v4v/71L23bts0ja3h5ealhw4YeqQXuX7g8XA6/q1wsS5YsUVpamk18woQJdt+/xo0bZxP75ptvlJeX5/Tal/p54D0IAAAAAAAAAAAAAIDqZ/uXeQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAtQsICFCPHj0Msa3btqqwsLDKXLOv2TAuKSnxaG+ecNVVVxnG6enp2r59u9N1tm7bqoyMDEOsa9euNvMCAwPl5fW/r+jLzs6utG757UFBQZXO9/Hx0aiRo2Q2/+/Y/7z2Z5veAAAAAAAAAAAAAABXtpCQEF1//fWG2N69e7V169Ya6shWVFSUTSw+Pl6StG7dOptt/fr1c3vNxx9/XD179jTEXnnlFe3du1dRUVEymUyGbbGxsW6vWZmAgAD99NNPevLJJ+1uP378uL7//nvNnj1bH3zwgb755hslJSXZzDOZTHrnnXd08803V7nmuXPn9N577xlibdu21ZgxYxzq2Ww267vvvlOrVq0M8e+++05/+ctfKsyrV6+etm3bpltuucXu9uzsbK1fv17ffPONPv/8cy1evFj79u2zO/fJJ5/Ugw8+6FC/7dq1s3neIi4ursq86Ohom5gjeRUpf707em1FRUVpy5YtNsf7guPHj2vVqlWaP3++FixYoLVr19o8J9KrVy/NnTtXwcHBatOmjWHbhddcZdq2bev0MbSXc/z4ca1du9bmNXjq1Cn99NNP+uqrr/T1119r/fr1KigosFv3gw8+UIsWLars+feuueYarVu3To0bN7a7vapj2KFDB3377beSpO7duxty3bkmHGHvPlkd9yV761T3vlXkqaeesomtWbOm0pyhQ4caxnv27NHu3bs91pOvr69N7FJ8Fg4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANSs559/3u5nGPfo0aPK3MTERLvxXr16ud2XpyQkJNiN9+nT5+I2UoFdu3bZjfft27da1mvXrp3q1atnEy8sLNShQ4eqZc2asn//frvx6jr3/fv3r5a6fxQVfb/HggULPLZGTEyMAgICPFbvj477Fy4Hl8PvKhdLSUmJ/v3vf9vEmzRpouuuu84Q69WrlyIjI23mzpkzx6W1L/XzwHsQAAAAAAAAAAAAAADVz6umGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAP6Kr+1wtX19f6/jcuXOKj493KNfX7GsYl5SUeLQ3dwUEBCgyMtIQ27R5k0u1LBaLNm7aaIi1a9vOcOwkyd/f3zAuKi6qtG5RkXF7+fzyBl03SPXr17eO9+3bp8TExEpzAAAAAAAAAAAAAABXnsGDB8tsNhtiixcvrqFu7IuJibGJJSQkSJI2btyosrIyw7YBAwa4tV7z5s31yiuvGGJ79uzRq6++KkmKjo62yYmLi3Nrzcr4+Pho0aJFuvbaaw3xsrIyffXVV7rqqqvUtGlT3XTTTZo0aZIee+wx3XbbbWrbtq1iYmL0yy+/GPJMJpM+/PBD1a5du8q133nnHeXk5BhiU6dOdajvTz75RH379jXEtm/frnHjxslisdjNCQoK0vLly9W+fXubbcuWLVO/fv1Ur149DRgwQLfddpvuvvtujRkzRh06dFCHDh30ww8/2OS99tprqlOnTpX9RkVF2cRiY2OdzktJSVFGRkaVefY0b97cpldHrq3GjRvrhx9+UHBwsCFusVg0f/586zUydOhQjR8/XnfccYeuu+46hYWF6frrr9euXbusObfccov++te/ymQyGWo5cizsvTaqen6ofM6pU6c0c+ZMwzWwaNEi9erVS40aNdLgwYM1btw43X777RowYIDq16+vF154weZ5Ix8fH/31r3+tsucLWrdure+//15+fn6GuKPH8MJzNxeuzfL3LUeOnzvs3ScdfXbLGRf7/leR8ePHa+TIkYZYQkKCdu/eXWFO+/btFRERYYitXbvWo32Vfz+VpDNnznh0DQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcPnLzMy0fub+74WEhNh8531527dvtxt393P6PWnbtm1248OHD7/Indi3evVqu/ERI0bI29vb4+vddNNNduPr169XaWmpx9erSRs3brQbHzZsWLWsV/4zy+GcRo0a2Y3v3bvXY2tcd911HqsF7l+Xuuo4B5ejy+F3lYvp448/thufOHGiYTx+/HibOUlJSdqyZYtL617q54H3IAAAAAAAAAAAAAAAqp9XTTcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAH80tWvXVteuXQ2xTZs3qbS01KF8s9lsGJeUlHisN09o0aKFvL29reP8/HwdOXLE5XpHjhxRfn6+dWw2m9WsaTPDHJNMhnFZWVmlNctvN5lMFcyUOrTvoC5duljHZ86c0Y+rfqyybwAAAAAAAAAAAADAlWfw4ME2sbVr19ZAJxWLjo42jA8dOqSzZ89KkrKzs7Vz507D9v79+7u13uzZsxUUFGQdl5WV6d5771VxcbHdfkpLS2168KTXXntNw4YNM8QyMzM1bNgwjRs3rtK14+Li1K9fPy1btswQDwsL06RJk6pc+8yZM/rXv/5liEVHR+v666+vNG/y5Mm66667DLGjR49q5MiRhmcmynv//ffVs2dPQywnJ0c33XSTRowYoY0bN1b4DMW+ffs0cuRIvf/++4Z4nTp1NGHChEr7laSYmBibWFxcXJV5UVFRTuc4WsvRep9//rkiIiIMsaysLA0aNEjjx4+v8BopKyvT6tWrFR0drR9++MEanzp1qkt9lD+GFotFCQkJTuU0bNhQgwYNsu7D4MGDdcstt2j79u1283Nzc/Xiiy/q8ccft9l2xx13VNnzBfPmzVO9evUMMWeO4e/34+mnn1anTp0M89y5LhxR/r5UVlamHTt2VPs6UvXvW3n33HOP5syZYxN/8cUXK827+uqrbWIbNmzwWF+S1KhRI5tYVlaWR9cAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXV3h4eLXUPXnypN14aGhopXmrVq2yGx81apQaNGjgblsesXLlSrvxDh06WD+LvCatX79eubm5NvGmTZvqlltu8ehaZrPZ7mepS9KSJUs8utalYPXq1Xbj7du3t/v9GO5o1aqVx2v+0dSpU8duvKCgwCP1vby89MADD3ikFv6L+9elwd45kKSQkJCL3Mml6XL4XeViOnjwoNatW2cTHzNmjIKDgyVJ3t7euvXWW23m2Pt+Dkdd6ueB9yAAAAAAAAAAAAAAAKqfV003AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB/NP2u7Sdvb2/rOD09XXv27HE43+xrNoxLSko81psnhIeHG8aHDh+SxWJxuV5ZWZkOHz5siIWFh1WaYzKZ3Np+QZ06dTRkyBDruKSkREt/WKri4mKH8gEAAAAAAAAAAAAAV5arr77aMC4uLtaWLVtqqBv7oqKiDOP4+HjDeP369YZxhw4dVL9+fZfWmjBhgq6//npD7P3339e2bdus4+joaMP2ffv2qaCgwKX1qhIdHa0nn3zSEDt79qwGDBigVatWOVSjpKRE48ePV1ZWliF+3333OZT/5ptvKi8vzxCbOnVqhfNvvvlmvfrqq4ZYdna2hg0bpvT09Arz+vfvr4kTJxpi58+fV79+/fT999871KskPfHEE9qxY4d1XH6/K1L+vGZkZOjEiROV5rRq1Uq1atUyxH777TcHO626B0mKi4urNOdPf/qTrrvuOkMsOztbffv21dq1ax1at7i4WLfffruOHDkiSTKbzTZzyr/u7Cn/Wj18+LDOnTvnVI6Xl5ckKS0tTb1799ZPP/1U5bqS9OGHH9o8r1S3bl21atWqytyJEyeqd+/ehpgrx/DgwYOSpJ49e8rHx8ew3ZHj547yx/HAgQPKzc31+Drlr9GsrCylpKR4fB17wsLCtGDBAs2ZM8fmGv3222+1ePHiSvPLn2NJ2rx5s0d7bN26tWGcm5urU6dOeXQNAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwcTRp0kQffvihkpOTNXr0aI/X9/X1tRvPz8+vNO/w4cNKTEy0W++BBx7wSG8X1K5dW+Hh4U7npaamVvg50FOmTHG3LYMHH3xQV111lVM5RUVF+vrrr+1umzZtmt3Pa3fVgw8+qIiICJt4YWGhFi5c6LF1LhVpaWkVfudFZd9z4IqXXnpJJpPJozX/aHJycuzGGzRo4JH6d9xxhyIjIz1SC//F/evScObMGbvx5s2bX+ROLk2Xw+8qF9vHH39sEwsMDNTYsWMlSUOGDFHDhg0N28vKyvT555+7vOalfh54DwIAAAAAAAAAAAAAoPp51XQDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPBHEhYWprZt2xpiGzZscKqG2Ww2jEtKStzuy5PCw8IN47RTaW7XTEsz1ii/RnFxsWHs4+NTab3y24uLim3meHt7a9TIUfL19bXG1q1bp/T0dId6BgAAAAAAAAAAAABcWQICAtSlSxdDLCEhQXl5eTXUkX116tQxjGNjYw3jtWvX2uT069fP6XXq16+vd955xxBLSUnR1KlTreOAgAC1a9fOMCcuLs7ptRz14Ycfytvb2xC74447tGvXLqfqZGdn66OPPjLE2rZtq8aNG1eZm5GRYZPbv39/9enTx2ZuVFSUvvjiC5lMJmusuLhYY8aM0b59+ypd5/3337eJ3XnnnUpISKiyx98rKyvTyy+/rDVr1uj2229Xo0aN9N5771WZFxUVZRg7cl7L5ziaV5Ho6GjDODs7W0ePHq1wvslk0j/+8Q+b+O233669e/c6tXZubq5ee+01u9uOHDmi7OzsKmuU7z8+Pt7pHEkqLCzU6NGjlZSUVGX+73399dc2sY4dO1aa4+PjoxkzZtjEXTmG9upIjh8/VzVv3tzmPhkeHq6NGzd6/F/558QcOcfuCgkJ0fTp03Xw4EHddtttNtt37NihiRMnVlmn/LWWnp6uEydOeKpNSVJkZKRhvH//fo/WBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1a9Jkyb617/+pUOHDumhhx6Sr6+v3nvvPdWtW9ej67Ru3domlpeXp5ycnCpzP/74Y7vxadOmqU2bNm73dsE777yj/fv36/HHH5eXl5dTueU/4/6CQYMG6YknnvBEe+revbs+/PBDJSQkaOnSperZs6fDuW+++aYsFotNvEuXLnr33Xc90l9UVJTefPNNu9s+//xzpaene2SdS80HH3xgNz5w4ED95S9/8cgaN9xwg8aNG+eRWn9kGRkZduP2vo/CWY0bN7b5DhB4BvevmlfRdx20adNGYWFhF7mbS9Pl8LvKxbRo0SJlZWXZxC9838b48eNttq1atUonT550a91L+TzwHgQAAAAAAAAAAAAAQPW7dJ+mAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIArUP9+/WUymazj5ORkHU0+6lQNX7OvYVxSUuKJ1jymTp06hnFGZobbNU9nnK50jfz8fMM4OCi40nrBwcbt5fMl6brrrlODBg2s4/0H9ithR4Ij7QIAAAAAAAAAAAAArkBXXXWVvL29DbHY2FiXarVp00bR0dFO/6tfv77Ta8XFxRnGGzZskMViMcQGDBjgdN333ntP9erVM8QefPBB5ebmWsddu3b12DGrytVXX62ePXsaYt98841WrFjhUr0ff/zRJta5c2eHct944w0VFBQYYlOnTjWMGzVqpKVLlyowMNAQf+CBB7R27dpK6w8cONCml0WLFmnJkiUO9Vfet99+qyFDhujrr79WUVFRlfNbtmyp0NBQQ6z8dWZPTEyMTcyRvIpERUU5VeuGG25Qy5YtDbGvvvrK7rl2xNdff23zWpKk+Pj4KnNbtGjh9DG0lyNJr732mrZt21blmuUlJibaxHx9fe3M/J/Ro0erUaNGhpirx/Drr79WaWmpTdyda8IR0dHRNrHQ0FD17dvX4/+8vLwu2r6Fhobqueee09GjR/XSSy/ZPB8lSatWrdK1115ruE/b4+Pjoy5duhhinr53h4aGKiwszBDbu3evR9cAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADV76OPPtLDDz9s+JzrZs2aaeHChQoICPDIGj179lTr1q1t4sePH3co/9NPP9Xp06dt4oGBgZo/f76CgoLc7vH+++/XPffco1q1amnmzJmKi4tTnz59HM7/6quvlJSUZHfbP/7xDw0fPtyt/sLDw7Vw4ULr52ePGDFC27Zt0+rVq9WwYcMq8/fu3atvvvnG7rZHHnlETz31lFv9tWnTRosXL5a/v7/NtoKCAr322mtu1b+ULVy4UCkpKXa3vfbaaxo5cqRb9Tt27Kgvv/zSrRr4rwMHDtiNT5o0ya26gYGB+vbbb9WgQQO36sA+7l8178SJExW+Zz/yyCMXuZtL0+Xwu8rFVFhYqC+++MImfu2116pz58666aabbLbNmTPH7XUv5fPAexAAAAAAAAAAAAAAANXPq6YbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIA/ihYtWqhZs2bWscVi0foN652uY/Y1G8YlJSXG7WazQkND1aBBAzVo0EChoaHy8fFxrWkX+Pr6Gsbnz593u2bu+VzjGn7GNfIL8nXu3DnruFFEo0rrNWr0v+35+fk6l3POsL1du3a6qutV1nF2drZ+/PFHp/sGAAAAAAAAAAAAAFw5oqOjbWJxcXEu1dq4caNiY2Od/terVy+n14qPjzeMz5w5o127dhli/fv3d6rm8OHDdccddxhiX3zxhc3f1j15zKry5z//2TC2WCyaPn26y/WOHz9uE/v98waVSUtL08cff2yI3XjjjercubMkKSAgQD/88IMaN25smPPSSy/p3//+d5X1H330UcPYYrFo8uTJDvXmCVFRUTax2NhYp/NOnjyptLQ0l3po0KCBIiIiDLGqrq1JkyYZxmVlZZoyZYpL60vS2bNndfDgQZu4I8fC3muj/GvVkZwTJ07otddeq3I9e+w902M2m+3M/J+HH37YMHbnGObl5Wnv3r02cUeOnztiYmKqtX5lqmPfGjZsqNdff10pKSl68cUXVbduXZs5paWlevXVVzV8+HDl5ORUWbNTp042z4BVdX06y959pLreHwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQPV57rnnZLFYbOLXXXedfvrpJzVt2tSt+qGhofr000/tbluxYoVDNfLy8vTCCy/Y3dajRw9t2LBBDRs2dLnHxx9/XLNmzTLErrrqKm3evFlDhw51qEZpaan+8pe/2N1mNpu1ZMkSPfHEEy711759e23YsEEtWrSw2RYeHq7Tp087VOeJJ57Q2bNn7W57++239dFHH9l8xrUjhgwZou3bt6t58+Z2t//973/X4cOHna57uSguLtbTTz9td5uPj4++++47/e1vf3Op9qBBg7Rx40bVqVPHGjtx4oRLtSCb7+S4YMiQIbrvvvtcqhkREaFNmzapd+/e1hif2+553L9q3rp16+zGn332WfXr1+/iNnMJuhx+V7nYZs+ebRMzmUz68ssvFRQUZIifOXNG33//vdtrXsrngfcgAAAAAAAAAAAAAACqn1dNNwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfxT9+/U3jPft26f09HSn65jNZuvPpaWl8vLyUvt27TXixhGa9OAkPfH4E7r/vvt191136+677tb9991vjQ0ZMkSNGzd2e18q4u3tLR8fH0OsqKjI7bpFxcYafr5+NnOOHD1i/TmyVaQC/APs1vL19VXbNm2t46NHjxq2h4aGauj1Q63j0tJSLf1hqUf2AwAAAAAAAAAAAABw+ercubNNLDEx0ek6PXr0UFhYmEs9xMfHOzX/xIkTOn36tE183bp1hnGXLl1Up04dh2oGBwfro48+MsQyMjL05JNP2syNjo42jC0WixISEhxaxxn+/v66+eabDbHVq1crKSnJ5Zr2nhMwmUwO57/22muGGiaTSVOmTJEkffHFFzbHZv78+Xr++eerrBsQEKBRo0YZYqtXr9ahQ4cc7s1dMTExNrG4uLgq88rvc2xsrMs9REVFOdVDYGCghg8fboitXLlSycnJLvcgye7ry5FjYe8YVvX6tpfz4YcfqqCgoMr17Cn/jI8kZWVlVTg/NDRUAwcONMTcPYYZGRk2MUeOnzvKX4cXk7P38Mo0bdpU77//vpKTk/XMM88oJCTE7rwtW7aoe/fumjp1qkpLSx2qbe8YufN6tcfea9iTxwcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFwc8fHx+vDDD+1u69Onj/bs2aPnnntO9evXd7r20KFDtX37drvfFSBJCxcudLjWhx9+qPXr19vdFh0drV27dumRRx6x+xneFenSpYtWrFihmTNnysvLy2b7r7/+qtWrVztcb+nSpfrss8/sbvP29ta7776r3377Tddff71D9YKDgzV9+nTFxsaqTZs2NtstFouefPJJWSwWh+qlpaXpoYceqnD7pEmTdODAAY0fP96h49ipUyctXrxYq1atUmhoqN05mzZt0j/+8Q+H+rucLVq0SD/88IPdbV5eXnrjjTcUFxenoUOHOlSvffv2+vzzz7V69WrVrVvXGi8oKND06dM90vMf0caNG+1+xr4kzZ49W88995zD9xBfX189/vjj2rFjh+Gz27Ozsx367go4h/tXzSv/XTcX+Pr6as2aNXrttdfUvHnzi9zVpeVy+F3lYtq9e7e2bt1qE+/SpYtN7Msvv7T7XUOuuFTPA+9BAAAAAAAAAAAAAABUP8efBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuKxjx45q0KCBdVxaWqqNmza6VMvX7Gv92WQyadKDkxQYGFhpjslkUmhoqEJDQ3VV16t08uRJ/fTTT0pLT3Ophwp78/W1iRUXF7tdt6ioyDD29vaWj4+PSkpKrLG42Dh17dJVJpNJvr6+Gj58uL5f8r1hjo+Pj4bdMEz+/v7WWGxsrKHuqJGjDPuxfv16paV59jgBAAAAAAAAAAAAAC4/HTt2tInt2bPH6TqjRo1yaf309HSdPHnSqZy4uDi78XXr1unPf/6zdWwymXTttddqyZIlVdZ89dVX1bRpU0Ps8ccfV2Zmps3c6Ohow/jQoUPKyclxpHWn9O3bV35+fobYN99841bNiIgIm1h+fr7D+SdPntTcuXM1adIka+y2225TcXGxxowZY5i7YcMG3XPPPQ7V7du3r8xmsyE2b948h/vyhPLn9ezZszp8+HClOY0aNVLDhg0NsYquT1d6qKqeveM2f/58l9e/oLS01CYWHx9fZV5UVJRhnJqaWuXzKeVzysrKNGfOHAe6tK/861iSjhw5UuH8gQMHysvLyxBz9xhaLBabmCPHzx3lj+Px48c1efJkj6/z9ttvKywszDo+f/68kpKS3K7btm1bTZkyRXfeeafNNf17u3bt0nPPPafvvvvO6TXKHyNJSkhIcLpOZey9hj29BgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuDieeuop9ezZU927d7fZFhwcrBdffFHPPfectmzZonXr1mnv3r06evSocnJylJeXJ5PJpKCgIIWGhioyMlJRUVEaPny42rRpU+GaS5cu1ebNm53q89Zbb9Wvv/6qZs2a2Wxr0KCBPvjgAz3//PNasWKF1qxZo2PHjik9PV15eXny9fVVSEiImjVrpq5du2r48OHq3bt3hWulpqZq7NixKisrc6rHhx56SG3bttXVV19td3tMTIx+/PFHnT59WqtWrVJ8fLzS09Ot3xdQu3ZttWzZUj179tT111+vgICACtd69dVX9dNPPznV34IFC9S5c2dNmzbN7vbmzZtr3rx5ev/99/Xjjz9q+/btOnXqlDIzMxUUFKSwsDC1adNGw4YNU7t27Spd6/Dhw7rpppvsfib8lWj8+PH67bff1Lp1a7vbo6KitHLlSp06dUorVqzQzp07lZaWpjNnzsjPz09169ZV586dNXDgQLufNy5JTzzxRJXfLYCKFRYW6pVXXtE777xjs83Ly0svvviiHnroIc2bN08bNmzQ/v37lZ2drYKCAtWuXVsNGzZU69atNXToUN14441q1KiRoYbFYtHdd9+t06dPX6xd+kPh/lWzNm/erE2bNqlv374228xmsyZPnqzJkyfrxIkTSklJUU5Ojt330LS0NE2cOPEidFwzLoffVS6m2bNnV7oPF7jz/S32XIrngfcgAAAAAAAAAAAAAACqn09NNwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVzpvb2/1vaavIRafEK9z5865VM9sNlt/9vLyUmBgoNM1IiIiNG7cOP3888/asXOHS33YYzKZbGJlZWVu13WkRmZWprZu3ao+ffpIklq2bKn777tfhw8fVm5urgIDA9WqVSuFhIRYc2LjYnUq7ZR1PHDAQDVs2NA6PnjwoOLi46xjk8mkFi1aqGXLlqoVUku+vr7Kz89XRkaGkg4mKSMjw+19BQAAAAAAAAAAAABcmlq2bGkYnz171qW//Xft2lVHjx6tcl6LFi0M4/j4+CpzwsPDDeO4uDi78zZs2CCLxWL4O/+AAQO0ZMmSSuv36dNHjzzyiCG2fPlyffXVVzZzfXx81LlzZ4f6cdegQYNsYqtXr3arZvnzLcmh8/Z7M2bM0L333mt91sPb21t33323Yc7+/ft10003qbi42KGa9vb1559/dqovd0VHRxvGjlybUVFRNrHffvvNYz3k5ubqwIEDFc6/7rrrbGI//fSTy+tf8PvnTCQpNTVVaWlpVea5cgzL5+zYsUOpqakOdGlf69atDWOLxaKUlJQK5w8ZMsQm5u4xDAsLM4xPnDih9PR0t2pWJjw83OY++csvv+jLL7/06Dp+fn7697//bYjt2LFDFovF5Zpt2rTRSy+9pLFjx8rLy6vCeb/++qtmzJih7777zuW1OnToYBgXFhbqyJEjLtezp/z1nJycrDNnznh0DQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcHEUFRVp2LBh+vHHH20+g/gCs9ms/v37q3///m6vl5GRoYcfftjpvPT0dA0ePFg///yzmjRpYndOWFiYJk6cqIkTJ7rcX1pamoYOHVrpZ39XpLCwUMOHD9eyZct0zTXXVDivQYMGuvPOO3XnnXe61OMnn3yi6dOnu5Q7ffp0mUwmTZ06tcI5tWvX1q233qpbb73VpTX27NmjG264QZmZmS7lX47Onj2rG264QT/99JOaN29e4bzw8HDdc889Ttd/7733NHv2bPXr18+dNv/w/vWvf+muu+6y+x0MkhQREaHJkydr8uTJTteePHmylixZop49e7rbJirA/atm3XXXXdqxY4dCQkIqnNO4cWM1bty4wu3OfnfM5eZy+F3lYvr666/17rvvqlatWhXOSUxM9Ph3Il2q54H3IAAAAAAAAAAAAAAAqpdPTTcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFe6qG5RqlWrlnVcWFiorVu3ulzPbDbbxM6fP6+UlBSdOnVKOedzVFhYKJNM8vPzU+3Q2oqIiFDLFi3l4/O/r7Hz9vbWkCFDZLFYtDNxp8v9XEo2b9msgIAAdevWTZIUHBysrl272p27Z+8erV+/3jpu27atNU+Szp47qxUrV1jH4eHhumHoDapfv75NrXbt2umaa67Rvn37tGr1KhUVFXlmhwAAAAAAAAAAAAAAl4yGDRsaxqmpqS7VGT16dJVzwsLCdOrUKUMsLi6uyrzo6GiHcjIyMrR371517NjRGuvfv3+ltc1msz799FN5eXlZY+fPn9ekSZPszu/UqZN8fX0NsdjY2ErXcNW1115rE0tOTvb4OklJSU7NT0lJ0bx583Tvvffa3X769GkNGzZMZ86ccbhm3759DeODBw/q5MmTTvXljkaNGtm8Fly5NiX3roeoqCjDOCEhQRaLpcL55Y/b/v37lZaW5vL6kmQymdSyZUtDzJFj0ahRI4WFhRli8fHxTuesW7fOsUYr8PvnZKT/XkuVPfPSs2dPw3jfvn1uHUOTyaTIyEhDzJHj5w5712F1rNm1a1fDc1rurBMUFKTXX39dkyZNsqn5e2vWrNGMGTO0du1al9b5vQ4dOhjGhw4dqvT15azg4GC1bdvWEKvucw8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKpXRkaGBgwYoM8//1w33XRTta1z/PhxDR48WCdOnHApPykpSX369NGiRYtsPn/bE+Li4jR69GgdP37c5Rpnz57V4MGD9cEHH1T4WfeuKisr02uvvaZp06a5VWfatGk6fPiwZs6cqaCgIA9191/Lli3T+PHjlZ2d7dG6l4NDhw7pmmuu0ZIlS+x+trqrXnvtNU2ZMsVj9f7IioqKNGzYMP3yyy8231fgquLiYj322GOaPXu2R+qhcty/as6RI0c0ZswYffvtt6pdu3ZNt3PJuhx+V7lY8vLy9NVXX1X4/UiSNGfOnGpZ+1I8D7wHAQAAAAAAAAAAAABQvbxqugEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuJL5+vqqV69ehti2bdtUUFDgcs1NmzcpLS1NknTs2DEt/HahPpr1kZavWK64+DglJSUpJSVFySnJOpB0QL/++qu+//57fTTrI23fvl1lZWWGeoMGDVKDBg1c7udSs+anNfru+++Unp5ud3tmVqaWLVum5cuXW49F7dq1NfT6odY5paWl+uGHH1RYWChJatq0qW679TbVr1+/0rXbt2+v22+7Xb6+vh7aGwAAAAAAAAAAAADApSAgIED+/v6GWE5OTrWtFxMTYxOLi4urMi86OtrhnHXr1hnG3bp1U61atSqcP336dHXo0MEQe/bZZ3X8+HGHepGk+Pj4Cuu7ymQyqVu3bh6vW97JkyeVmZnpdN7s2bPtxgsKCjRq1CgdOXLE4Vr29vXXX391uid32DuvsbGxTuelpaUpNTXVpR5CQkIUGRlpiFV2rVfXcWvVqpXNMyKuvE6lqo+hvZwtW7ZUuZYzNas6hp06dTLE3D2GrVu3lp+fn8M9eIK941gda0ZFRdnEHHmdlNe9e3ft3LlTjz76qHx8fGy2l5WVadGiRerevbuGDBmitWvXutTv75nNZjVu3NgQS0pKcrvu71199dXy9vY2xNy9ngEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQM3LycnRzTffrLFjxyolJcWjtS0Wi7744gv16NFD+/fvd6vW8ePH1bdvX02bNk15eXke6S8vL0+TJ09Wz549K/wMf2cUFBTovvvu06hRo3T48GEPdCgdOnRIQ4YM0bRp0zxS79NPP1WXLl20cuVKj9RLTU3VhAkTNGLECGVnZ3uk5uXoxIkT6tWrl1588UUVFha6VSsjI0OjR4/WlClTPNQdpP9+30KvXr20bNkyt2vt3LlTPXv2rPC7LVA9uH/VnDVr1qhnz57auHFjTbdySbscfle5WCq7PxYXF+uLL76otrUvxfPAexAAAAAAAAAAAAAAANXHq6YbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIArWc8ePRUQEGAd5+TkKC4+zq2ahw8f1rwv5mnu3Ln6+puvlZyc7FBeQUGBNmzcoEWLFqmkpMQa9/b21oD+A9zqqTImk+mi1zh48KA+n/e5Zs2epW8WfqMlS5do4cKF+viTjzV37lzt3bfXOtfb21ujRo6Sn5+fNbZx00alpqZKkgIDAzVyxEiZzWZJUmFhodauXas5c+boo1kfaf6X87Vr9y5rbsOGDXX9kOvd2V0AAAAAAAAAAAAAwCXG29vbJlZcXFxt68XExNjE4uKqft4gOjra+nNGRoaOHz9e4dx169YZxl5eXrrmmmvszu3YsaOeffZZQ2zLli3617/+VWF9e/sQHx9f4XxXtW7dWkFBQR6vW96OHTuczvH399d7771nd9uqVau0detWp+rZ21dHrgtP+v01doEj5zUqKsowjo2NdbmHbt262TxLUtlxaNWqlc1x88S12K1bN5uYI/vlyjF09bhXpFmzZqpXr54hVtkxbNq0qfz9/Q2xffv2uby+JHXv3t0m5s514QhPH8eKeOL+N2rUKK1fv16tWrWy2VZcXKw5c+aoQ4cOuuWWWzx63OrUqWMTO3XqlMfqS1K/fv1sYps3b/boGgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoOZ8++23atmypcaOHas1a9aosLDQ5VpnzpzRnDlz1KtXL02YMMFjn5tcXFysGTNmqGXLlnrllVcq/Wz/yhw7dkzPP/+8mjZtqjfeeEOlpaUe6e+CpUuXql27drrzzju1efNmWSwWp2vs2LFDkyZNUrt27fTzzz97tL8jR45o2LBh6tGjh7755hvl5eU5XSMhIUGTJk1SixYt9MUXX3i0v8tVSUmJXnjhBbVo0UJvvfWWTp8+7VR+enq6XnzxRbVq1UpLliyppi7/2E6fPq0RI0Zo7Nix2rRpk9P5cXFxuv3229WtWzclJCR4vkFUiftXzTlw4ID69eunXr16adasWdq5c6fKyspquq1LzuXyu0p1i4uLq/A7P5YtW6aMjIxqXf9SPA+8BwEAAAAAAAAAAAAAUD18aroBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALhS+fv7Kzo62hDbsmWLSkpKPFI/MyvTpbzklGStXrNaw24YZo01b95cdevUVdaZLLd6Ki0ttYl5e3uruLjYrbo+3rZfv2dvrfJycnKUk5NT6ZwB/QcoLCzMOj58+LB+++0367hH9x4KDAyUJJWVlWnhtwt16tQp6/bz588rNTVVhQWFiomJkSS1b99e27Zv0+nTp6vsEQAAAAAAAAAAAABw6bNYLDYxf3//aluvR48ehvG5c+d0+PDhKvN+/5xCfHx8pXPXr19vExswYIBWrFhhiJlMJn366afy9fW1xoqKinTffffZPS4XREVFGcbHjh1TRkZGpT25okOHDjaxOXPm6NChQx5d5/fPEjjCZDLpyy+/VM+ePe1uHzFihNq2basDBw44XNPeviYlJTnVl7suPBtxQV5envbv319pTmhoqFq0aGGIxcXFeayHquq1bdvWJuaJ66P8NS5V/bqTZPM8UXZ2to4ePepUzrlz59zah/L1pMqPYZs2bWxi7l57AwYMcKoHTyi/3ydOnKiW53vKr1NYWKg9e/Y4nD9kyBAtWrRIPj7GZ6ZKS0s1d+5c/f3vf9fx48c90mt5oaGhNrHCwkKPrjFo0CDD+OzZs9q+fbtH1wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADWrrKxM3377rb799lsFBgaqf//+6tq1q9q3b6/IyEiFhIQoODhYQUFBslgsOn/+vHJycqyfw71z507t3LlTmzdvVklJSbX1mZ6erunTp2v69Onq3r27+vbtq5iYGDVv3lwNGzZUUFCQfHx8VFRUpHPnzik7O1v79+/X7t279dNPP2nnzp3V1tsFJSUl+vLLL/Xll18qPDxcAwYMUO/evdW6dWs1bdpUwcHBCggIUFlZmc6ePavs7Gzt27dPcXFx+vnnn7V3795q7/G3337TbbfdJn9/fw0ZMkQ9e/ZU165d1bhxY9WuXVvBwcEqLCzU2bNnlZWVpd27d2vHjh1atWqVkpOTPd6PyWTyeM2K3HPPPbrnnnuqpfapU6f017/+Vc8884z69eunvn376qqrrlKLFi2sxzUvL0/nzp3TsWPHlJCQoA0bNmjt2rUqKyuzW3PDhg0X9fg44nI+Xxfuc+3atVPfvn3Vp08ftW7dWqGhoapTp47MZrNycnKUnZ2tvXv3Kj4+XsuWLdPBgwcrrLl9+3aPHJPqOK4vvviiXnzxRY/XrUmX2v3LnivxuEv/vdYvfFdBUFCQGjVqZHjt2JOfn+9Q7cv5vlLe5fC7SnXLysqyG58zZ85F6+FSPA9/tPcgAAAAAAAAAAAAAACqm09NNwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAV6roqGj5+vpax2fOnNGu3btqsKP/2b17t7rHdFeDBg2sscjWkcr6NcutuoWFhbJYLDKZTNaYr9lXBQUFbtU1+5oN4+LiYlksFrdqSlKbNm0UFRVlHefk5Gj5iuWGOZ07d7b+vP/Afp06dcpurU2bN6lr164ym//ba9cuXfXTzz+53SMAAAAAAAAAAAAAoObl5uaqqKjI8BxAWFhYta0XExNjGCckJFSZU7duXTVv3tw6jouLq3R+enq69u3bp/bt21tj/fv3t5n32GOPqXfv3obYyy+/rH379lVY22Qy6aqrrjLEqurHVc2aNbOJzZw5Uzt37qyW9Rz11ltv6eabb65wu5eXl6ZNm6a7777b4ZpNmza1iR0+fNil/lz1++csJGnHjh0qKyurNKf8tSBJsbGxLvcwcOBAw7iwsFB79uypcH7Lli1tYsnJyS6vf0G/fv0M46ysLKWkpFSZFx0dbRg78vp2Jacy3bt3t4nFx8dXOL9u3bo2sczMTLd6GDJkiGGckZGhEydOuFWzMuXvkVL13Je8vb3VpUsXQywxMVElJSUO5UdGRmrRokXy8fExxHfv3q277rqr2u6lF/z+ua8LioqKPFa/efPmNu8pq1evVmlpqcfWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAl5a8vDytWLFCK1asqOlWKvXbb7/pt99+q+k2KnXq1CktWLBACxYsqOlW7CooKNDSpUu1dOnSmm7lilJWVqZ169Zp3bp1Nd0KKrB//37t379fn376aU23Ahdx/6pZubm5OnjwYE23ccm7HH5X8bTGjRvbfFeNJKWlpWn58uU10NGldx54DwIAAAAAAAAAAAAAwDO8aroBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALgSeXt7q1u3bobYtu3bZLFYaqYhOw4cOGAYhzUM80jd4uJiw9jXz9ftmn5+foZxQUGB2zVr1aqlG4beYB2XlZXphx9+MNSuX7++AgICrOODBw9WWK+4uFjHjh2zjhs3bux2jwAAAAAAAAAAAACAS0dqaqphHBERoaCgII+vExYWpoiICEMsLi6uyryoqCjDODY2tsqc9evXG8YxMTGGfWratKlmzJhhmLNr1y69+uqrldZt166dzbFxZB9cUbduXZtYWlpatazlqEcffVRPPfWUIZaUlKQlS5YYYnfeeaciIyMdrtugQQObWFZWlmtNuqBevXpq1qyZIebIeW3durVNbN++fS714O3trX79+hliiYmJKikpqTCndu3aNrHz58+7tP4FgYGB6t27tyHmyLFw5Ri6etwrEx0dbRgfP35cmZmZFc63d68rKytzq4eWLVsaxtV1j7ig/D1SkuLj4z2+TseOHW2edXJmnTlz5igkJMQQW7ZsmXr16lXtx0iScnNzbWLl+3HHuHHjbGJff/21x+oDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgynDXXXfJy8vLJv7FF1+otLS0BjoCAAAAAAAAAAAAAABXKtsnFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbmvTpo0CAwOt47y8PO3du7cGO7KVmZlpGAcFBXmkbn5+vmFcp04dt2uWr1FQUOBWPS8vL40aOUp+fn7W2KbNm3Ti5AnDvNDQUMO4/DEr7/fby+cCAAAAAAAAAAAAAC5viYmJhrHJZNLVV1/t8XW6d+9uE4uLi6syLyoqyjCOj4+vMmfdunWGsY+Pj2GfZs2apeDgYOu4rKxM9913n0pKSpzqRXJsH1zh4+NTLXVdNWLECM2cOdMQy8rK0vDhwzVlyhRZLBZr3NvbW9OmTXO4tre3t03MZDK53qyT7J3X2NjYKvNatWplEzty5IhLPYwYMcLmmYyqrq2AgACbmLvHbezYsTKbzU71Ibn22qiO11NMTIxT9co/DyRJISEhbvVQXnXdIy5w9fq9mOvcdttt6tevnyG2ceNGjRkzRrm5uR7prypnzpyxiUVGRnqkttls1qRJkwyx7Oxs/fDDDx6pDwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgCuDyWTSgw8+aHfb7NmzL3I3AAAAAAAAAAAAAADgSudV0w0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwJWoU8dOhvGu3btUWlpaQ93Yl1+QbxibzWaP1E1PTzeMG9Rv4HbN8jXKr+Gs/v37Kzw83Do+cvSItm/fbjPP39/fMC4oKKi07u+3+/r6ysuLrw0EAAAAAAAAAAAAgCvF1q1bbWK33HKLx9eJiYmxicXFxTmVl5OTo4MHD1aZs379epvYgAEDJEnjxo3TsGHDDNvee+89u39fr6yXCxzZB1fk5eXZxGrVqlUta1UlOjpaCxYskLe3tzVWXFysMWPG6ODBg9qzZ4++//57Q86ECRPUsmVLh+rn5+fbxC7mvkZHR9vEHDmvTZo0MYyLi4tVWFjoUg+TJk1yuoecnBybWP369V1a/4JHH33UJhYbG1tlnr1jGB8f7/GcykRERKhhw4ZO1Ttz5oxNrH379i730KlTJ5uYI8fPHfbuS+4cR2fWcfT+N336dMM4NzdX48ePV1FRkUd6c0Rubq6OHTtmiHXo0MEjte+//341b97cEPvss8+qfCYLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfywjRoxQixYtbOIbNmzQgQMHLn5DAAAAAAAAAAAAAADgiuZV0w0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwJWoWbNmhvG+fftqqJOKeXkZv9KutLTUI3VPnTplGDdt2tTtmk2aNql0DWdERkYqJjrGOj5//ryWL19ud275Y1RWVlZp7fLHsHw+AAAAAAAAAAAAAODytWTJEpvYuHHj1KBBA4+u0717d8O4oKDAoecOoqOjrT/Hx8c7tFZqaqqSkpIMsf79+6tevXqaOXOmIX706FFNmzbNobq/70WSTp8+rZMnTzqU66zjx4/bxDp27Fgta1WmadOmWrZsmYKCggzxSZMmaf369dbxyy+/bNju4+OjqVOnOrSGvWPYtWtXF7p1TUxMjGFcVFSk3bt3O13H1ecp+vXrp2HDhtnE4+LiKs07ffq0TaxTp04u9SBJt956q3r06GETd+R1V/61kZ+fX+Xru3xOQUGB9u7d60Cn9pU/j1LVx3DPnj02sYEDB7q0vpeXl2bNmuV0D+4qfxwzMzN17Ngxj68TFRVlGJeWlioxMbHKvL59+6pz586G2IcffqiUlBSP9ueInTt3GsaNGzdWr1693KpZr149Pf/884ZYcXGx3n33XbfqAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4Mrzwgsv2I2X/14lAAAAAAAAAAAAAAAAT/Cq6QYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4Erk7e1t/Tk/P1/p6ek12I19wcHBhnFeXp5H6p5MPWkYN2nSRIGBgS7XCwoKUpPGTQyx1FOpLtWqVauWht0wzDouKyvTsmXLlJ+f73J/BibPlAEAAAAAAAAAAAAAXHoSExMVHx9viAUHB+vtt9/26DoxMTGG8c6dO1VaWlppTnBwsNq0aWMdx8XFObze+vXrDeMePXpo1qxZql+/viE+adIkh58tiIqKMoyd6cdZCQkJNrEhQ4a4XM/X11cRERFO5dSqVUsrVqxQeHi4If7GG29o7ty5hlhsbKxWr15tiN19991q3rx5levs3LnTJjZ06FCnev29AQMGqF69eg7PL39ed+3apZKSkirzys/x9vZWs2bNHF5Xkvz9/fX+++/bxEtLS5WYmFhprr3tw4YNszOzavXr19e7775rEz9//rySkpKqzI+OjjaMd+7cqbKyMqdyEhMTq7wnVKZ79+42sapeo8ePH1dqqvF5naFDh6pp06ZOr//BBx/ommuuMcTOnj2rw4cPO13LUeXvkVL13Ze6detmGO/du1cFBQVV5o0fP94m9sEHH3iqLacsW7bMJnbfffe5VfPzzz+3uUd+8sknSk5OdqsuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAriwTJkyw+R4nSTp8+LAWL15cAx0BAAAAAAAAAAAAAIArnU9NNwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAV7rUU6k13YJdTZs2NYzP5ZzzSN1jx47p3LlzqlWrliTJZDKpW7du2rJli0v1oqKiZDKZrOOsrCydOnXK6TpeXl4aOWKk/P39rbFffvlFx44fqzCntLTUMPb29q50DR9v49cElpWVOd0nAOC/ateurebNm1dL7bRTaUpLT3N4fkhIiFq1bKWmTZuqbt26CgkJkdlslo+Pj4qLi1VQUKDs7GydPHlSBw8dVGrqxXnv9/LyUufOnT1Wr6SkRHv27HForq+vr7p166bWka1Vp04d+fv7q7CwUNnZ2Tp0+JAS4hOUX5Dvdk/t27WXr5+vJOn48ePKyspyuyYAAAAAAAAAAO54/fXXtWDBAkNs/Pjx2rFjh958802364eHhysiIsIQi4+PrzLvqquuMvxtPS4uzuE1165dq/vvv9869vX11Z/+9CfDnM8//1yrVq1yqF6LFi0UGhpqiDnTj7N2796tkydPGo7bxIkT9fe//12nT592ut7777+vsWPH6oknntDnn39e5XwfHx/95z//UadOnQzxxYsXa/LkyXZzXn75ZQ0ZMsQ6NpvNmjJlih566KFK19qxY4cyMzNVr149a2zcuHGaNm2aTp48WWWvv9e5c2ctW7ZMJSUleuONN/TOO+8oLy+vwvkhISFq3bq1IeboebXX24ABAxw6vhd8+umn6tKli018z549KigoqDQ3MTFR58+fV3BwsDU2cuRIRUREOHXc/P39tXTpUjVq1MhmmyOvU3vHsKo8d457RaKjow3jzMxMHT9+vMq8RYsW6bHHHrOOvby8NGvWLA0fPtyhdb28vPT222/bvc4dOX7uKH+PrK4127Rpo5CQEEPM0fM1bNgww/i3337T0aNHPdWaU7777jv985//NDwrdd9992nevHnauHGj0/Xee+89m+skIyND06ZNc7tXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXDlat26tmTNn2t324osvymKxXOSOAAAAAAAAAAAAAADAH4FPTTcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFe6tLQ0j9Zr2LChevXspdy8XP38888u1QgODla7tu0MsaNHj3qgu//atXuXru5ztXXco3sPJSYmKicnx6k6tUJqqXtMd0MsMTHRpZ76XdtPjRo1so5TUlL0y9ZfKs0pKCgwjAMDAivdh4DAAOvPhYWFKisrc6lXAIAUHh6u64dcXy21N2/ZrLT0qt+f69atq77X9FWbNm1kMpnszjGbzTKbzQoJCVHTpk3Vq1cvpaWlaf2G9UpJSfF06wZ+fn4ePUa5ubnas2dPlfOaN2uuG0fcqMCAQEPc399f4eHhCg8PV/eY7lqxcoUOHjzocj+dOnXSsBuGSZIyMjIc6g0AAAAAAAAAgOr29ddf65FHHlG/fv0M8X/84x+KjIzUX/7yF+Xl5blcv3xdSYqLi6syLzo62umcC9avX1/p9tOnT+upp55yuF75XiQpNjbW4XxnWSwWzZs3T5MnT7bGgoKCNGfOHN10000qLS11qI7JZNLbb7+tBx54QJL073//W3/605/0wAMPKD09vcK8jz/+WIMGDTLE4uLidOedd1aYs2HDBm3ZskVXX/2/ZyvuuecevfLKKzp27FiFeaWlpVqwYIEeffRRa8zX11cLFy7Uddddp8LCwir3U5LatWunFStWKDDwv3/vefnll/XII4+oc+fOOnPmjN2cbt262fzNzNHz+uuvv9rEnnrqKX355ZcqKSmpNNfHx0effPKJxo0bZ3e7I9d6UVGRli1bpttuu80aM5vNmjt3roYOHVplviSFhYXpP//5j3r37u1yH/aOYVV5ruRUJSYmxqV6s2bN0qOPPmroZ9iwYZo1a5Yee+wxFRcXV5jbqVMnvf/++xowYIAkqaysTF5eXk734KqLdV+KioqyiTmyb82aNVOzZs0MMVefC/OE1NRUzZ8/X3fddZc15uXlpa+++kojRoxQQkKCQ3VCQ0M1a9Ys3XrrrTbbHnzwwQrvNwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPjj6dmzpxYuXKg6derYbNu7d6/mzZtXA10BAAAAAAAAAAAAAIA/Aq+abgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArnS5ubkeqzV61GjdNeEutWvXTt2u6qZmzZo5XcPLy0vDbhgms9lsjeXn5+vYsWMV5nh7e8vHx8fwrzI7duxQYWGhdWw2m3XT6Jvk6+vrcJ++vr66+eabDWvl5+crcVeiwzUuaNWqlbp3724d5+bm6odlP1SZl5mZaRg3aNig0vkN6v9ve/lcAMDlJSY6Rnffdbfatm0rk8nkVG5YWJhuHXurBvQfUD3N/X/OvK96SrNmzTRmzBgFBgRaYwUFBTpz5owKCgqsMT8/P40eNVqtI1u7tE69evU0eNBgSVJxcbGWLl2qkpIS95oHAAAAAAAAAMBDJk6caPdvwg899JAOHz6sKVOmqEWLFg7Xi4yM1AMPPKB169ZpwYIFNtvj4uKqrBETE2P9uaCgQPv27XN4/RMnTujw4cMVbv/zn/+srKwsh+tFR0fbxBzZB3e8/fbbOnfunCE2YsQILV261KFnKzp06KCff/5ZTz75pCE+aNAg1alTp8K86dOna+LEiYbYiRMnNGLECOXn51e65iuvvGIY+/r66tlnn62y13/84x+Gv8tI0tVXX61169apU6dOleZ6eXnpvvvu07Zt29SkSRPDtkWLFunMmTMV5rpzXjdt2mTTc7du3fTJJ59U+jevXr16acuWLbr77rslSRkZGTp16pRLPcycOdMmdv311+vbb79VcHBwhXleXl669957FR8fr6uvvlqSdODAAZvrzZE+7B3D+Ph4p3PceT2FhYWpUaNGTvVwwa5du/TFF1/YxB988EElJibq6aefVo8ePRQREaGIiAhFR0fr3nvv1ffff6+dO3dqwIAB1pxPP/3UUCM2Ntb5nXHC7++RFzi63+6u48j56tOnj00sMzNTXbt29di/qu4P5f39739XXl6eIda4cWP98ssvmjJlisLDwyvMDQsL05NPPqmDBw/q1ltvtdn+5ptvavHixU71AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMufyWSSr6+v/Pz8VLduXbVv317jxo3T4sWLtWXLlgq/b+jhhx9WWVnZRe4WAAAAAAAAAAAAAAD8UfjUdAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcKUryC/wWK2c8znWn728vHTzTTdr9erV2rN3j0P5QUFBGj5suJo3b26Ib9myRSUlJRXmjRo5SpGRkYbYm2+9WeH83NxcrV+/Xtdff701FhYWpltvvVUrVqxQZmZmpX3Wq1dPw4cNV4MGDQzxn9f+rIIC545nSEiIht0wzDq2WCxatnyZ8vLyqszNzs5WTk6OQkJCJEnt2rbTrl277M4NDAxU48aNrePjx4871ScA4OIpKyurdHufPn10zdXX2MTz8/OVmpqq7LPZKioskkUW+fn6KTQ0VBEREfL39zfM7969u7y9vfXTzz95tP8LzGZztdStiK+vr24cfqO8vb0l/ff9fuXKlTpy9Ih1TrNmzTTshmEKCQmRyWTSDTfcoE/nfKr8/HyH1/Hx8dHIkSOt+7fmpzXKzKr8dwcAAAAAAAAAAC6mI0eOaPTo0VqxYoX178kXhIWFacaMGZoxY4ZSUlK0c+dOpaSk6Ny5cyosLJSfn5+CgoIUGhqqVq1aqU2bNmrYsGGFa5WUlCgxMbHKnqKjo60/79y5U6WlpU7t07p169SqVSub+LJly/T11187Vev3vUjS2bNndeTIkQpme0Z6erqeeOIJzZ071xAfNmyY9u3bp5UrV+rHH3/UsWPHlJGRIUmqU6eOOnXqpOHDh+u6666TyWQy5JaUlGjcuHHav3+/3TXvvPNOvfTSS4ZYbm6uRowYodTU1Cp7Xr58uRISEtStWzdr7L777tOMGTN04sSJCvOSk5M1bdo0vfXWW4Z47969tWPHDm3ZskUrV65USkqKTp8+LUlq0KCBYmJiNGbMGDVr1sym5urVq/X0009X2m/581paWqqdO3dWtZuSpKysLH3++ed68MEHDfG7775bffv21fz587Vr1y5lZ2erfv36ioyM1MiRI9WzZ0/Deg888IC++eYbQ424uDiHevjll1+0ePFi3XzzzYb4n/70Jw0aNEgLFizQr7/+qpMnT8rHx0fh4eHq0aOHRowYoYiICOv8nJwcPf7441q5cqXTfZQ/ho68vu0dd0fuCRWJiYmxiTl6DCXpscce0zXXXGNzv2jXrp3NNVmRv/3tbzb3KGd6cEX543j+/HklJSV5fJ2oqCjD2GKxKCEhocq87t2728Ref/11vf76655qTTt37tRVV13l8PzDhw/r8ccf1yeffGKI+/v7a8aMGXrppZf022+/KSUlRadOnZKXl5fCwsLUqlUrRUVF2dxTL5g7d67+9re/ubUvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuDyNHTvW6e9Eev/997V+/fpq6ggAAAAAAAAAAAAAAEDyqekGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOBKV1Rc5LFamzZtUssWLVWnTh1Jktls1vDhwxUdE61du3bp2LFjOnPmjMrKyqw5ZrNZ4eHhatumrTp16iRfX19DzWPHjilhR4LHerxgZ+JOtW7TWq1atrLGwsPCddeEu5SUlKT9B/YrKzNLuXm5kqSgwCDVq1dPbdu2VZs2beTt7W2ol5SUpL179zrVg8lk0sgRIxUQEGCNbd22VSkpKQ7XSEhI0LXXXitJatmypdq0aaOkpCSbeYMHDbb2XFZWVi3HFAD+SI4ePap58+a5Xadz586KioqyjktKSrR3T8XvJy1atNDVfa42xE6lndKmjZt0NPlohXleXl5q27at+vfrr5CQEGs8KipKR5OP6tChQ67vRAXMZrNhvH7DeqUkO/4eV16ZpazS7V27dlVQUJB1/P2S73Xy5EnDnJSUFC3+brEmjJ8gk8kkf39/RXWL0pZftjjcx+BBg1W/Xn3rePfu3Q7nAgAAAAAAAABwsWzevFkDBw7U4sWL1bRpU7tzmjVrpmbNmrm1ztatW1VYWFjpHD8/P3Xo0ME6jouLc3qddevW6d577zXEcnJy9NBDDzldKzo62jCOj493uoYrPvvsM7Vv316TJ082xAMCAnTzzTfr5ptvdrjW2bNndeedd2rZsmV2t/fv319z5swxxMrKyjRu3DglJCQ4vM6MGTP0zTffWMd+fn6aPHmyHn/88Urz3n77bXXs2FH33XefIe7t7a1rr73W+pyDIxYtWqQJEyaopKSk0nnlz+vevXtVUFDg8DovvfSSbr75ZjVo0MAQj4yM1PPPP19pbnFxse69916lpKQY/kZmsVicOt7333+/oqOj1bx5c0M8NDRUDz30UJXX+9mzZzV69Gj5+fkZ4gUFBQ4902LvGFb1+i6fs2fPnipznKknOXfPOHfunAYOHKiffvpJrVu3dmrtnJwcPfDAA/r66681f/58azwvL0/79+93qpYzyt8jJTl13Tij/PE9dOiQcnJyqszr3r17tfTze668N3z66adq1qyZ3deot7e3evXqpV69ejlUq6ysTK+88kqVr3cAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADggrVr1+rpp5+u6TYAAAAAAAAAAAAAAMAVzqemGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAK53FYvFYraKiIi36zyKNvWWsateubY2Hh4UrPCzcul5RUZFKS0tlNptlNpsrrHcq7ZQWf7fYoz3+3pIlS/SnMX9S06ZNrTFvb2+1b99e7du3d7hOcnKyli1f5vT61157rSIiIqzjY8ePacuWLU7ViIuPU6dOnVS3bl1J0sgRI7Vr1y4dPnJYRUVFqlWrlrp26WpYJzY2VufOnXO6XwDA/xQWFiotPc2tGmazWW3btjXE4uPjdS6n4nv0gP4DZDKZrONdu3bpx1U/VvleWVZWpn379in5aLLGjh2rhg0bWrdde+21OnTokIt7UTFfs69hnJGR4fYxq8zv37uPHT+mkydP2p2Xnp6uo0ePqmXLlta8Lb849v7bsWNHde7c2TrOzMp0o2MAAAAAAAAAAKpXbGysOnfurNdee033339/pX+fd1Z8fLzee+89zZs3r8q5Xbp0kY+Pj6EvZ61fv94mNnnyZB0/ftypOuHh4QoLCzPE4uLinO7HVc8++6ySk5P11ltvKSAgwKUaK1eu1COPPKIjR47Y3d6uXTstXrxYvr7Gv9U888wzWrJkiVNrffvttzpw4IDhb1oPPPCAXn31VaWmplaae//99+vo0aN64YUXDOffUWfPntXkyZM1a9asKuf6+/urQ4cOhpiz5/X48eP605/+pBUrVigoKMjhvGPHjmnChAlav3697r//fsO2pKQknT9/3uFaWVlZuvbaa7Vq1SqnnluRpN9++03jx4/X/v379cwzzxi27dy5U6WlpZXm2zuG8fHxHs+pSvfu3Q3j8+fP6+DBg07VSElJUXR0tF5//XWH7n1FRUX68ssvNXXqVOt1HR0dbd2ekJBQbc8uSbb3SKl67ktNmjRRvXr1XFrn98ejurjy3iBJL7zwgpKTk/XOO++oVq1aLtXYu3evHnnkEa1bt86lfAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPzxLF++XGPHjlVxcXFNtwIAAAAAAAAAAAAAAK5wXjXdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAOdnZ2fpi/hfas2eP3e0mk0l+fn4KDAyU2Wy2O8disSg2NlZfffWVioqKqq3XkpISLfx2oWJjY2WxWJzOt1gs+vXXX7XoP4tUUlLiVG7Lli3Vo3sP6zgvL08//PCD030UFxfr+++/1/nz5yVJXl5e6tq1q24afZNuHXurbhh6gyIiIqzzDx06pI2bNjq1BgCgenSP6a6goCDruKCgQFu3ba00Z+3atUpOTpYkpZ5K1Y+rfnTqvSO/IF9Lf1iq0tJSa6x+vfpq2LChk91Xrfz7vLPvlc7w8fFRwwb/24eU5JRK5yenJFt/rlu3rvz9/atco27duhoyeIh1XFxcrKVLl7rQLQAAAAAAAAAAF8+5c+f0yCOPqE2bNnrllVd0+PBhl+rk5+dr7dq1mj59ujp16qTo6Gh99tlnhr85VCQ6OtowjouLc3r9lJQU699IJGnTpk368MMPna5TvhdJio2NdbqOOz788EN16NBBs2fPVk5OjkM5xcXFWrJkiQYOHKhhw4bpyJEjduc1aNBAK1asUJ06dQzxTz75RG+99ZbTvVosFr366quGmL+/v5555hmH8l9++WV16dJF8+fPV35+vkM5J0+e1N///ndFRkZq1qxZDuV07dpV3t7ehpgr53Xjxo3q2rWr1q5dW+XczMxMvfDCC+rYsaPWr18vSYqJiTHMceVaP3bsmKKiovTqq6/q7NmzVc7ft2+f7r33XvXq1Uv79++X5NprzpVj6Knj/nvlj2FCQoJLz/Tk5OTokUceUbNmzfTUU09p0aJFiouL09GjR3XkyBHFxcXpyy+/1KRJk9S0aVPdc889Sk1NlSSFhISobdu21lqunEdnXKz7kqvrtGnTRrVq1fJ4P+W5c5znzJmj9u3b67333tOZM2ccyikrK9OGDRt0++23q0uXLlq3bp3L6wMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOCPIy0tTQ8//LBuvPFG5eXl1XQ7AAAAAAAAAAAAAADgD8CnphsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgvPz9fy1cs12+xvyk6KlqRkZEKCAioMq+oqEj79u9TbGysMjMzL0KnUllZmdauW6vEXYnq2bOn2rRuI7PZXGlOcXGxkpKStG37Npf6DA4O1vBhw2UymSRJFotFy1csV25urkv7kJmVqflfztfAgQPVtk3bCnvevn27tm7bKovF4tI6AADPCQgIUI8ePQyxrdu2qrCwsNK85JRkJackK6xhmCyyuHRPP3PmjI4eParIyEhrrFF4I6WnpztdqzJmX+P7aUlJiUfr/15gYKC8vLys4+zs7Ernl98eFBSkgoKCCuf7+Pho1MhRht8Rfl77szIyMlzqFwAAAAAAAACAiy05OVnTp0/X9OnT1bRpU/Xp00etW7dW8+bNFRISoqCgIElSTk6O9d+pU6e0d+9e7d27V8nJyS7/rXn27NmaPXu22/vQokULt2ssX77c+rf6mpScnKxJkybpiSee0NVXX60ePXooMjJSoaGhCggIUFFRkc6dO6dDhw5p586dWrt2rXJycqqse/r0abVq1cqjvX722Wf67LPPXM7ft2+fxo8fr+DgYPXt21cxMTFq2bKlateuLX9/f+Xl5enMmTPavXu3tm3bpu3btzu9xvbt2z12Xg8fPqzrrrtOrVq10ujRo9WyZUs1atRIZrNZZ8+eVVJSkrZu3aq1a9eqtLTUkPvwww/r4YcfdruHgoICTZ06VS+//LKGDBmi3r17KyIiQqGhoSosLFRWVpZ27dql9evXKzEx0Sb/9ttv1+233+7Umq4cQ08e9wuaNm3q0XqnTp3Su+++q3fffdfhnGuvvdbwt8dt27Z5tKfyPHWPrMqSJUtcOl9JSUmXxH2zKqmpqXriiSf0zDPPqFevXurVq5datmypOnXqKDg4WAUFBTp37pyOHj2qnTt3avPmzfy9FwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUqKytTfn6+srKydPToUcXGxmrNmjX68ccfVVJSUtPtAQAAAAAAAAAAAACAPxCfmm4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK5Eb7715kVZJz09XSt/XCmTyaSGDRqqXr16qh1aW76+vjKbzSopLlFBQYHy8vJ0Ku2UTp8+LYvF4vQ6i79b7HavGRkZWr58uXx8fNSoUSPVr1dfISEhMpvNkqTi4mLl5OQoIzNDqampKikpcXmt8+fP64N/feB2z7+Xk5OjJUuWqHbt2mrRooVq16ots9ms/Px8ZWRm6OjRoyoqKvLomgAA113d52r5+vpax+fOnVN8fLzD+WnpaW6tn346XZGRkdZxcHCwW/Xs8TX7GsbuvHdWxd/f3zAuKq78Pa/8e2L5/PIGXTdI9evXt4737dunxMREJ7sEAAAAAAAAAODScOzYMR07dqym24CkgoIC/fzzz/r5559rupVqd/78ea1cuVIrV66s6VYccvjwYb3zzjs12kNeXp6+//57ff/99zXaxx/NkCFDDOO1a9fWUCdwRWFhoTZs2KANGzbUdCsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC4zHzzzTf65ptvaroNAAAAAAAAAAAAAAAAA5+abgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4D6LxaK09DSlpafVdCtVKikp+X/s3Xl43GW5P/47y0ySZiZL94UWukGBUkrLIquAioCA4oLoUeQcURRQwK+ioKL+VA6g4C7IUVxwY3FBFlkUZN/sAtKylLVputJmmUmTTLbfH8joNG2atGkD+HpdVy/nvj/Pcz/vmczEJB2aqKuri7q6uqGOskWampri0UcfHeoYAPShuro6Zs2aVdC79757o6ura7tlaG9vL6hLSwf/V8kmEomCurOzc9DPeEVRFBXU3d3dfa7f8HpRUdEmVkbsOmPX2GOPPfJ1Q0ND3HrbrVuQEgAAAAAAAHg1KykpiRNPPDFfL1myJOrr64cwEQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8J+seKgDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMpkMOPiRKSkry9erVq2Px4sXbNUN5WXlBnevIDfoZiWSioO7s7Bz0MzalqKhoq66/ora2Nt7ylrfk687Ozrjhxhuio6Njq/IBAAAAAAAArz7veMc7YuzYsfn6+uuvH8I0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAf7rioQ4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADBYxowZEzvvvHNB7+677x6SHP+uYV3DoJ+RSCQK6s7OzkE/4xUdHR0FdWlpaZ/rN7zekevotaakpCSOO/a4SCaT+d7f/va3WL169VYkBQAAAAAAALaFuXPnxujRo7d4fzKZjIsuuihf9/T0xOWXXz4Y0QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALZI8VAHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDtpaqqKtLpdJSVlQ11FAAAALaRNx7yxigqKsrXL774Yrzw4gvbNcPw4cNjxx13zNddXV3x4osvDvo5yUSyoO7s7Bz0M17R2tpaUKcqU32uT6UKr2+4PyLi8MMPj1GjRuXrp55+KhY+unDLQwIAAAAAAACDLpVKxXe+8514+OGH40c/+tEWz/ne974XU6dOzde33HJLPPvss4MREQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYIuUDnUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANiWampq4qADD4pJO06KYRXDCq7lcrno6OiIjo6OaGtvi45cR77XnmuPXHsuch0v17n23Mu9V/bk/rmn4+U9nZ2dQ3QPAQAAeMVOO+0UkyZNytc9PT1x1913bdcMFRUVcdyxx0VxcXG+9/iix6O1rXXQz0okEwX1ht+bJhKJqKysjETi5XUdHR2RzWa36HvY1rbWaG5ujqqqqoiIGDd+XMSCTa8fN27cv/a2tkZzprng+i677BJ7ztozXzc2Nsatt9464FwAAAAAAADAtrPffvvF7373u5gwYUJERLzjHe+ISy+9ND71qU/1e0YikYhLLrkkPvrRjxb0BzIDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgWygd6gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsK0kk8l41zvfFbW1tZu8nkwmB+28tra2yOVy0dHREbmOXOTac5HL5SLXkYuOXEfkcrlob29/ue74Z93WHh2dHfl9bW1t0dHREd3d3YOWCwAA4D/FGw95Y0H95JNPxurVq7fL2YlEInbdddc46MCDYtiwYfn+Sy+9FHfdddc2O/MVXV1dUVxcHNOnTY9p06bFhAkTIp1O99rT09MTTU1N8eLSF2Px4sVRX1/f7/Oef+H52HPWnhERMXXK1Kgor4jWttZe65LJZOw8fed8/cILLxRcr6mpibce8daC7DfceEPkcrl+ZwEAAAAAAAC2vaVLl0ZVVVVB7+yzz44999wzzjvvvHjooYc2ubesrCze8573xGc/+9mYOXNmr+tPPvnkoOcFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYiNKhDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA28oRbzkiamtrt9t55eXlUV5ePiizurq6IpfLRXt7e+Ryuejo6IiOjo58nevI/atu/1f9yp6OXEfBGgAAgNe73XbbLUaNGpWvu7q64p577xm0+WPHjI3999+/oFdUVBSlpaUxbNiwGD58eBQXFxdcb2xsjN///veRy+UGLce/SyaSBVlO/eipMWzYsD73FBUVRU1NTdTU1MSes/aM5cuXx1//+tdYtXrVZs+bP29+zNpjVhQVFUUymYyjjz46rv/T9dHZ2ZlfU1paGkcdeVTB98fz5s3L3y4pKYnjjj0uksl/Zb/rrrti1arNnw8AAAAAAABsXytWrIhTTz01fv3rXxf0Dz/88HjwwQejvr4+FixYECtWrIj169dHWVlZ1NbWxk477RRz5syJRCKx0bm/+tWvtkd8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAPpUOdQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2FaqqqqGOsIWKykpiYqKiqioqBiUeblcLjo6OqKjoyPa2tuiI9eR77Xn2iPXnotcRy7fb2tvy6/v7OyMyZMnR0tLS2Sz2Vi/fv2gZAIAABgsJSUlcdCBBxX0FixcEM3NzYN2RsWwipg6dWq/1y9YsCDuuvuu6OzsHLQMG0okEvnbxcXFMWzYsAHPGD9+fLz//e+PO+64Ix597NE+165dtzYefPDB2H///SMiYvLkyXHKh0+J5557LlpaWmLYsGExZcqUSKfT+T3z5s+LlatW5uvDDj0sRo8ena+feeaZmL9gfr4uKiqKnXbaKSZPnhxV6apIJpNRV1cXS55ZEi+99NKA7x8AAAAAAACwdX7zm9/E2LFj45JLLomioqKCaxMmTIgJEyYMaN5Pf/rT+MhHPjKYEQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALZI6VAHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBtJZFIDHWEV41kMhnJZHKL93/us5/L3+7p6YnGxsbIZDLR0tIS2Ww2mpqaorm5OV83NzdHY2NjZLPZaGlpiUwmU1Bns9loaGiIbDYbnZ2dg3EXAQCA/2B7zd4rqqqq8nV7e3s8+OCDQ5goYtq0aVG/vD6efPLJbXbGxr7vzWazsXTp0li5cmVksplob2+PoiiKsrKyqK6pjvHjx8fknSZHaem/frVtSUlJvOUtb4menp547B+P9XnmffffFxUVFTF79uyIiEilUjFr1qyNrl38xOK466678vXOO++c3xcR0dTcFH++5c/5euzYsXHkW4+MkSNHFsyZNGlSHHjggfHkk0/GbbffFrlcrs+MAAAAAAAAwOD61re+FUuWLIkrrrgixo0bt0Uz6uvr4/TTT4/rr79+kNMBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABsmdKhDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA20r98voYNWrUUMd43SkqKora2tqora0dlHnt7e3R0tISjY2NkclkIpvNRktLSzQ1NUVzc3Nks9nIZrPR3NwcTU1Nkc1mY+XKldHQ0BAtLS35601NTYOSBwAAeG1JJpOx3377FfQeeuihaGtrG9Rz2traoq6urle/pKQkKioqoqamJoqKivL9dDodx7ztmNhhwg7xl7/+ZVCzvOLe++6NAw84MMaMGRN1dXXx4EMPxosvvrjZfeXl5bHvPvvG3nvvHcXFxfn+m970plixckWsWbOmz/1/+etf4oUXX4gD9j8gRo8e3ev62nVr48EHHownnnwi36uuro63HvHWfN3V1RU33nhjtLe3R0TExIkT453HvzMSicQmz50xY0YMHz48fnv1byOXy232fgIAAAAAAACD58Ybb4xp06bFhz/84fjQhz4Uc+bMKfg70o1pamqK+++/P3784x/H9ddfH11dXdspLQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwOaVDnUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANhW7rrrrpgyeUpUVVUNdRT6UFZWFmVlZTF8+PCtnpXNZvN/mpqaorm5OVpaWiKbzUZzc3M0NTXlr2cymWhsbIxsNptf09DQkK/Xr18/CPcOAADY1vbdZ9+oqKjI15lMJuYvmD/o56xYsSKuvubqTV5PJpMxderU2HeffWPUqFH5/uzZsyPXkYu777570DM999xz8dxzz8WI4SNi7bq1/d7X1tYWd99zd7z44otx/PHHR2npy7/mtqSkJA5946Fx7XXXbnbGM888E88880yk0+mora2N8vLyaG9rj8amxmhqaipYW1JSEscde1yUlZXle/fce0+sWLEiIiKGDRsWxx5zbCQSiYiIaG9vj/vvvz+ef/75yHXk4qCDDoqZu8+MiIjRo0fHEW85Im686cZ+318AAAAAAABgcKxfvz6+973vxfe+970YOXJkzJw5MyZPnhxVVVVRVlYWbW1t0dDQEI2NjfH000/HU089NdSRAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANql0qAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwLbS0dERv/vd72LO3DkxY5cZUVZWNtSR2MZSqVSkUqlBmdXT0xONjY2RyWQim81GS0tLNDU1RXNzc2Sz2chms5HJZKKxsTFfZ7PZTdadnZ2DkgsAAPiX8vLymDNnTkHv/vvvH5Kvv3O5XDzxxBPx1FNPxWGHHhZ77bVX/tq+++wbzz37XCyrX7ZNzl67bu0W7Xtx6Ytx+19uj6OOPCrf23HHHWN47fBY17CuXzMymUxkMpk+1xz6xkNjzJgx+fq5556Lv//97/l6n733iWHDhkVERHd3d1x73bWxcuXK/PVbbrkl2tvaY+7cuRERMWPGjHjo4Yf6lQ8AAAAAAADYNl566aX429/+Fn/729+GOgoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAWKR3qAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwLa1dtzZuv/32uPPOO2PE8BGRSCYikUhEMpmMsmRZJJPJSCQTkUwkI1n2cu+V64lkIsrLyiOR+Nce/nMUFRVFbW1t1NbWDsq89vb2yGaz0dTUFJlMJrLZbGSz2Whubo6mpqZoaWnJ142Njfk6m81GQ0NDZLPZfK+pqWlQMgEAwGvdnL3mFHyv1tDQEI8venwIE0V0d3fHX+/4awyrHBa77LxLvn/QQQfFb6/+7RAm27hFixbF3nP3jlGjRuV7U6dNjXWPrBuU+dOnT4+99torX2cymbj5zzcXrJk5c2b+9lNPPxUrV67sNefe++6NWbNmRSKRiIiIWXvMGpR8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwH+m0qEOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADbQ2dnZ6xavWqr55SVlUUymYxEaSISycS/6kQikolkJMuSL/cS/+wlX64TiURBnUwmo6SkZBDuGa8VZWVlUVZWFiNGjBiUeZlMJrLZbLS0tERTU1M0Nzfn6+bm5mhqasqvyWaz0djYmL/d0tISDQ0N+bq1tXVQMgEAwPZUUlISs2fPLug99PBD0dPTMzSBNnDnnXfGztN3jqKiooiI2GGHHSKdTkcmkxniZL09/fTTMWrUqHw9ZvSYQZlbVVUVR771yHzd3d0dN954Y7S1teV7I0eOjIqKinz9zDPPbHRWR0dH1NXVxZQpUyIiYsKECYOSEQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPjPVDrUAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgtaS9vT3a29sHZVZxcXEkEokoLy+PRCIRyWQyEolElJWV5W8nE8l/1cmX62Ty5V4ikcjvKy8vH5RMvHak0+lIp9ODMqu7uzuampoik8lENpuNbDYbzc3N0dzcnK8zmUw0NDRES0tLvrdh3djYGJlMJrq6ugYlFwAA9GX69OkxbNiwfL1+/fp44oknhjBRoWw2GytWrIjx48fne+PGjotMJjOEqTZu7dq1BXVlZeVWzywuLo7jjj0uysrK8r1777s36pfXF6yrqanpM8uG16ZMmbLRfQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADUTrUAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgP1V3d3e0t7dHe3v7oMwrLS2NZDIZiUQiysvKI5lMRmni5V5ZsiySZS9fSyaSkSz7Z++f6xPJl/ckEol8j/8cxcXFUVtbG7W1tYMyr729PbLZbDQ1NUVzc3Nks9loaWmJ5ubmaGpqKqgbGxsjm83mew0NDQV1U1PToGQCAOD1Z/fddi+oH1/0eHR1dQ1Rmo1rbGqM8ePH5+thlcOGMM2mtba1FtSD8T3hG9/4xhg7dmy+fv6F5+Phhx/uta68vLygbmtr2+TMf7+WTCajtNSv5wUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC2TOlQBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABkdnZ2d0dnZGRERTNG31vLKyskgmk7Fq1ar40/V/ipqamkin05FKpSKVSkVVVVVUV1fn63Q6XVCnUqmora2NysrKSCaTW52H146ysrIoKyuLESNGDMq8TCYT2Ww2stlsNDc3R3Nzc77OZDLR1NRUsKahoSFaWlrydWNjY2QymWhpaYnW1tZByQQAwNAqKSmJSZMmFfSefPLJIUqzaR25joK6tOTV+etki4uLC+qurq6tmjd16tSYO2duvs5ms3HzzTf36+zu7u5Nzt0wV2npq/PxBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAF79Soc6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADw6tTe3h7t7e2xatWqmDdv3lbNSiQSkUqloqamJlKpVP5PdXV1VFVVRWVlZb6urq7O1+l0Or/nlV5tbe0g3UNeK9LpdKTT6UGZ1d3dHU1NTdHc3BwtLS2RzWajubk5mpqaIpvNRktLS2QymWhoaMjX2Ww2X7/Sa2xsjEwmE11dXYOSCwCAgRk7ZmyUlJTk69bW1li9evUQJtq48vLygrqtvW2IkvQtlUoV1OvXr9/iWVVVVXHUkUfl6+7u7rjpppuitbV1i2fmFW39CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICIiNKhDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAvP51dHREQ0NDNDQ0DMq8MWPGRGVlZdTU1EQ6nY5UKhWVlZVRXV0dVVVV+V46nY7q6upIpVL5PzU1NfnblZWVg5KH147i4uKora2N2traQZnX1tYWLS0t0dTUFM3NzZHNZiObzUYmk4mmpqaCurGxMV9ns9ledXNz86BkAgD4TzB+wviCesXKFUOUpG8jR44sqNevXz9ESfo2ceLEgro5s2VfmxYXF8exxxwb5eXl+d4DDzwQdcvqNrmnq6uroC4pKdnk2tKSwl/H29HRsUU5AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEqHOgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwECtWrVq0GbV1NREKpXK/6muro50Op2vq6qqoqamJiorKyOVSkU6nc7veaVXW1sbqVQqEonEoOXitaG8vDzKy8tjxIgRgzKvubk5WlpaIpvNRnNzczQ1NeXrTCYTjY2Nkclk8r2GhobIZrP5+pXr2Ww22traBiUTAMCr0fDa4QX1YH6PEBFRVlYWs2bNigULFkRnZ+cWzRg7dmzB14k9PT2xcuXKwYoYERGjR4+O/fbdL1rWt8Qdd9yxRTNSqVTssvMuBb0XXnhhi2YdcvAhMW7cuHy9dOnSeODBB/rcs+HXrcMqhkUmk9no2ophFfnb7e3t0dXVtUU5AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEqHOgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwFBqbGyMxsbGQZmVSCQilUpFTU1NpNPpSKVSUVlZGdXV1VFVVVVQV1dXRyqVyv+pqanJ366srIza2tpBycRrS1VVVVRVVQ3KrO7u7mhqaorm5ubIZrPR0tISzc3N0dTUFNlsNv+noaGhoG5sbCyom5qaIpPJRFdX16DkAgAYDOUV5QV1S0vLoMytqKiIvffeO2bvOTvKysqiuro6/vKXvwx4TjKZjLce8daC3vLly2P9+vWb3FNSUhJFRUUFvc7Ozk2uf/txb4/p06dHxMtf+z3zzDOxdOnSAeUsLi6Oo448KhKJRL7X2toadXV1A5oTETFlypTYe++983VLS0vceNONm923du3agnrU6FGxavWqja4dNXLUJvcBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADETpUAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHi96OjoiIaGhmhoaBiUeZWVlZFKpSKVSkV1dXWk0+l8XVVVFdXV1fk6nU5HTU1NwZ7a2tpIpVJRWVkZlZWVg5KJ147i4uKora2N2traQZnX1tYW2Ww2mpubo6mpKVpaWiKbzUYmk4nGxsaCuqGhIbLZbL7X2NgYmUwmXzc3Nw9KJgDgP1dFeUVB3dbaNihzq6urY79998vXs/ecHUVRFH+762/R0dHRrxnDhw+Ptx39thg1alRB/4EHHuhz33HHHhdTp04t6H3zkm9ucn0mm8nfLi4ujuPfcXzcfvvtsfiJxf3KWVlZGUcfdXTsuOOOBf37778/Ojs7+zXjFel0Oo468qh83dPTEzfdfFOsX79+s3tf+VoxnU5HRMQuO+8Sjz/+eK91w4YNiwkTJuTrZcuWDSgjAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwL8rHeoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABsXEtLS7S0tMSqVasGZV5NTU2k0+morKyMVCoV1dXVUVVVFalUKiorK6OqqipqamrydTqdztev9GprayOVSkUikRiUTLx2lJeXR3l5eYwcOXJQ5jU3N0c2m42WlpZobm6OpqamyGaz+T+NjY2RyWTyaxoaGgquNzU15a+3tbUNSiYA4LWjtLTw17LmOnKDMnflypXx2GOPxaxZs/K9PffcM6ZNmxaLFi2K5194PtasWdPr64+KiooYO3Zs7LrrrrHLzrtESUlJwfXFTyyOF158YVAyvuLee++NyTtNjtra2oiISCQScfTRR8ecuXPi8ccfj7q6umhoaIju7u78nkQiEWPHjo2dp+8cu+++eySTyYKZdXV1sfDRhQPKUVRUFMcec2xUVFTkew8+9GAsXbq03zMWLlwYBx98cERETJ48OaZPnx5LliwpWPPmN705/7h2d3cPOCcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAvysd6gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGwfjY2N0djYOCizkslkVFZWRk1NTaTT6UilUpFKpaKqqiqqqqoK6pqamqisrMz3amtrC+qamppBycRryyvPlcHQ1dUVzc3N0dzcHNlsNrLZbGQymWhsbIyWlpZ8b926dQV1Y2NjZDKZGD9+fFRVVUV7e3vkcrno6ekZlFwAwPYzmP///dc7/hrpqnRM3mlyvldZWRn77rtv7LvvvhER0dnZGR0dHdHT0xNlZWVRUlKyyXnPPvts3HLLLYOW7xW5XC5+9/vfxXve/Z6orq7O98eOGRtjx4yNiJcfl1wuF11dXZFIJCKRSGxy3spVK+MPf/zDgB/Lgw8+OMaPH5+v65bVxf333z+gGfMXzI/dd989hg8fHhERxx5zbDz++OPx3PPPRS6Xi4MOPKjgjHnz5kVzc/OAzgAAAAAAAABg65111llx6qmnFvTOOeecuOGGG4YoEQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbLnSoQ4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBrTy6Xi1wuFw0NDYMyL5VKRWVlZaRSqaiuro6qqqp8XVVVFdXV1ZFOp6OysjLS6XTU1NQU7KmtrY1UKhWpVCqGDRs2KJl47SgpKYna2tqora0dlHmdnZ2R68hFrj0X7e3t0dHRER0dHZHLvVznOnLRkeuIXEcu2tv+Wf9zzSt1LpeLlpaWQckDAGxfXV1d8fvf/z4OPPDA2GfvfaKkpKTXmtLS0igt7ftXw3Z2dsb9D9wfjzzySPT09GyTrI2NjfHLX/0yDjv0sNhtt916XS8qKoqysrI+Z/T09MT8+fPj7nvujq6urgGdP3ny5Nhn733y9fr16+PGG28c8P3t6OiI66+/Pt7znvdEKpWK4uLimDVrVsyaNavX2meffTbuufeeAc0HAAAAAAAAYOtVVFTE5z//+Rg5cmS+t3z58rj11luHMBUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGy50qEOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2Ww2stlsrFq1alDm1dTURDqdjlQqFalUKqqqqqKqqipfp9PpqKmpydepVCpqa2ujsrIyX79yPZFIDEomXjtKS0ujtLQ0hlUM2+pZ7e3t0dHREblcLnIduci15yKXy73c68hFe1t75Dpy0ZH7Z93enr/d0dER7e3tkWvPRUdnR3R2dg7CvQMA+qOnpyfuvffe+Mc//hF7ztozZsyYEVVVVf3au379+nj88cdj4aMLo7m5eRsnjWhtbY2b/3xz/H3e32POXnNi6tSpUVFRsdl9uVwunnzqyZg3b16sXbt2wOemUqk4+qijo6ioKCJefsxu/vPN0dLSMuBZERFr162NX/36V3HYYYfFztN37nW9o6MjHn744XjwoQejp6dni84AAAAAAABePSorK+Nzn/tcQe+BBx6Im2++eYgSMZg+//nPR3l5eb5++umn46qrrhrCRIPPc5j/RB/5yEdi5MiRBb1LLrkkcrncECUCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICtUzrUAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYLA1NjZGY2PjoMxKJpORSqWiuro6qqqqorKyMlKpVFRVVUV1dXVBXVNTE6lUKt+rra0tqGtqagYlE68dZWVlUVZWNiizuru7I5fLRXt7e3R0dERHR0fkcrloa2+LjlxHvtfa1vry7X/22trbIpfL5a+3t7dHLpeLnp6eQckFAEPhl7/65XY5p6mpKe6+5+64+567o6qqKkaPGh01NTVRUVERiUQiiouL8/9/nM1kY8XKFdHQ0LBFZ/3hj3/YqqyrV6+OW269JYqKimL0qNExYsSIqK6pjmQyGYlEIjo7OqOtrS3Wr18fK1etjDVr1mzV1wPZbDZ+8MMfbFXmDWUymfjTn/4U1dXVsdNOO0V1VXUkEomoW1YXL7zwQuRyuUE9DwAAAAAAGDpz5syJL3zhCwW9M844Y4jSMJhGjx4dX/va1wp63/nOd+Kqq64aokTbxsaew6effvoQpYFtr7S0ND796U8X9BoaGuJHP/rRECUCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICtVzrUAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4NUsl8vFunXrYt26dYMyL5VKRSqVisrKyqiuro6qqqp8L51OR3V1daTT6XyvpqYmf3vDetiwYYOSideG4uLiKC8vj/Ly8kGZ19HRER0dHZHL5aK9vf3l2x256Mh1RHt7e/52riMX7W3/rP+5Pteei47OjshkMtHR0TEoeQDg1a65uTmam5uHOsZm9fT0xKrVq2LV6lVDHWWLNTU1xaOPPjrUMQAAAAAAgG1ozpw5vXrz588fgiQMto19bOfNmzcESbat/5T7Ca/4wAc+EBMnTizofe9734uWlpYhSgQAAAAA/Tds2LAoLS3d5ud0d3dHNpvdqhl77bVX7LvvvjFz5swYP358pNPpqKioiI6Ojshms7F06dJYtGhR3HXXXbF48eJBSj445syZE/vss0/stttuscMOO0QqlYqKioro6uqKbDYbK1asiKeeeiruu+++eOSRR6Krq2vQzp4yZUocd9xxsffee8eYMWOipKQk1qxZE0888UTccMMN2+Rn+OXl5ZFMJgt6ra2t/rtbAOA/VlVVVb/W5XK5aGtr28ZpBm6XXXaJQw45JPbYY4+YNGlSpNPpSCaT0d7eHs3NzfHiiy/GY489FnfddVc899xzQx0XAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGETb/jceAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAedlsNrLZ7KDMKioqiurq6kin05FKpSKVSkVVVVVUV1dHZWVlpFKpSKfTUVtbm69TqVTU1tZGKpXK92pqaiKdTkdpqV9v9p8kkUhEIpGIYcOGbdWc9vb2yGQzkc28/NxuzjRHNpONTDYTmUwmstlstLW1DVJqAAAAAIBtb3jFlJg+4s3bZPay5r9HffP8Ae2prdgpZo4+PnaqPShGV+4WqbIxUVaSjuKikujoWh/NuRWxOrs4nl13Zzy68urItK/YJtkjhvaxKS+tijdMPC12H/32GFm5c5SX1kRbZ1OsW/9sLF5zQzyw9AexvmPtVufYc+yJUV5ala+fa7g71rQ8udVzAQAoNHfu3IK6u7s7Hn300SFKw2Da8GMbEbFgwYIhSLJtbXg/u7q64rHHHhuiNLBtFRUVxec+97mCXktLS3znO98ZokQAAAAAMDA33XRTHHroodv8nGeeeSamT58+4H3Dhw+PT33qU3HSSSfFxIkT+73vySefjB/+8Ifxox/9KHK53IDPHQyTJ0+OM888M973vvfF6NGj+71vzZo18fOf/zy++c1vxqpVq7b4/FGjRsU3vvGN+OAHPxjFxcUbXfOlL30p7rzzzvjEJz4RixYt2uKz/t2IESNi4cKFscMOO+R7K1asiD333DPWrFkzKGcAALyW7LTTTvH888/3a+2Pf/zj+MhHPrKNE/VPMpmMD3/4w3H66afH7rvv3u998+fPj+9///vxi1/8Irq6urZhQgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGB7KB3qAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwJbp6emJxsbGaGxsHJR5ZWVlUVlZGdXV1VFVVRWpVCoqKyujqqoqqqurI5VKRSqVinQ6HTU1Nfm6srIyamtr83UqlYrq6upBycSrX1lZWZSVlcXIESM3uaajoyOy2Wxks9lozjS/fDvzb7ez2WhpadmOqQEAAAAANm2H6r3jnbv/aJvMvu2ZL0V98/x+rR05bOc4auf/jd1HHx9FRUUbXZMsrYyRpdNi5LBpsdvo4+Jtu3wz5i//Rfz56c9FNrd6MKNHxNA9NtNGvDneP+s3UZks/Fn0sERtDKveO3ao3jsO3vFTce3jJ8ei1X/c4gxzx58cJ+zx03y9Mrso5i+/aovnAQCwaXvttVdB/dRTT8X69euHKE3/TJgwIb785S8X9H7961/HnXfeOTSBXqXmzp1bULe1tcUTTzwxRGm2nQ2fw0888US0trYOURrYto4//vjYZZddCnpXXHFFrFu3bogSAQAAAMDrx0c+8pG45JJLIp1OD3jvjBkz4rvf/W6cffbZ8cEPfjDuu+++bZBw4yoqKuKrX/1qnHXWWVFSUjLg/aNGjYpPf/rTcdppp8UXvvCF+Na3vjXgGdOmTYtbb701pkyZstm1hx12WDzwwANx/PHHx1//+tcBn7Whq666KnbYYYd83dXVFe973/tizZo1Wz0bAOC1aPr06UMdYcAOPfTQuPLKK2Py5MkD3jtnzpy48sor49Of/nScfPLJ8cgjj2yDhK8NRx99dBx//PEFvfPPPz9WrFgxRIkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABg4EqHOgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPDq0N7eHu3t7bFu3bpBmZdKpfJ/qqqqoqqqKl+n0+moqakpWFNbWxupVCoqKysjlUpFTU1NpNPpqKysjGHDhg1KJoZGIpGI2traqK2t3eSarq6uaGlpiUwmE5lMJrIt2Whubo5sNhvZbDYymUy0tLREd3f3dkwOAAAAADA09hr3gXjn7j+KZMnAfj5eXFQSe0/475gx8m3xi4XviBcbH9hGCbefqcMPj/+Zc3OUFCfyvdaOxmjJrYlhyZExLPHyz54rEtXxgdm/i6sWvjMWr75+wOeMqdwt3rHbD/J1rmt9/Grhe6Kju3Xr7wQAAAXKy8tj1113LejNnz9/iNL034EHHhinnHJKQe83v/nNEKV59Zo7d25B/dhjj0VXV9cQpdk2NvYcnjdv3hClgW3v3HPPLahzuVx885vfHKI0AAAAAPD6UFRUFD/72c/ipJNO2upZkydPjrvuuitOPvnk+OUvfzkI6fo2duzYuO2222KPPfbY6lnDhg2LSy+9NN7whjfEf/3Xf0VnZ2e/9lVWVsbNN98cU6ZMyfd6enri/vvvj0WLFkVnZ2dMnTo1DjvssEgmkxERkU6n4/rrr4+99torlixZssWZP/OZz8RRRx1V0PvKV74Sd9111xbPBAB4rZs+ffpQRxiQM888My699NIoLi7eqjm77bZb3HvvvXHKKafEVVddNUjpXltmz57d6z1V3/rWt2LFihVDlAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGrnSoAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK9P2Ww2stnsoMwqKiqK6urqqKqqilQqFZWVlVFVVRXV1dX5Op1OR21tbaRSqXxvw7qmpibS6XSUlvpVbq82JSUlUVVVFVVVVZtc09PTEy0tLZHJZCLbko1MJvPy7Ww2Ms3/6nV1dW3H5AAAAAAA/dfd07nZNXPGfzBOmPnzKCoqKui3dTbHi433x0stS6K9szkiIioSw2N81eyYWL1vFBeV5NemykbHKXNvjx8+fECsyDw2uHdiG9nYY1NeWhXvm/WrKClOREREpn1lXPv4f8dTL92SXzN1+OHx3j1+HtXlO0RxUXG8Z+ZP45v37BwtHS/1++xEcUX81+xrI1kyLN/74+LTYnXLE1txjwAA2JRZs2ZFSUlJQW/+/PlDlKb/5s6d26u3YMGCIUjy6jV8+PCYNGlSQe+18LEdqI09h//+978PURrYtt70pjfF3nvvXdC76qqrYvny5UOUCAAAAABevdavX9/vtVdccUWcdNJJG732+OOPx9/+9rd44oknYt26ddHa2hqVlZUxduzY2HfffeOoo47q9d9ilpSUxM9//vNYvXp13HbbbVt1P/pSXV0d99xzT0ybNq3XtVwuF/fdd188/PDD8eyzz0ZTU1O0t7dHZWVljBgxIvbcc89405veFDvttFOvvSeccEK0trbGySef3K8cF154YUyfPj1fr1y5Mo477rh45JFHCtbtuOOO8cc//jFmz54dERGVlZXxs5/9LA488MB+3+d/t//++8cFF1xQ0Lvjjjvia1/72hbNAwB4vdhll12GOsKAfPvb395ov7u7O+6777547LHHYvny5dHU1BQ1NTUxfvz4mDNnTuy333693uefTCbj5z//eXR3d8evfvWr7ZAeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGGylQx0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgc3p6eqKxsTEaGxsHZV5ZWVmkUqmoqqqKk046KXbZZZdIJBORTCajLFn28u1E8uW6vCwSiZfrRCIRZeVl+dvJZDLKysoGJRObV1RUFKlUKlKpVJ/r1reuj2wmG5lMJrLZbGSz2Whubv7X7UxzdHR0bKfUAAAAAMBrzZKXbovvPjB3q+fsPeG/44BJZ+Trzu72WLD8l33uGVU5I9652xVRVFSU7zW11cefn/5sPLbymujq2fjPNqvKJsQR074S++zw4XwvWVoZ75v1m/j2/bOiu6drK+/Ny7b3Y7PvDh+JdNnYfH3VwnfFi433F6x5dt0d8bP5x8Yn9p8XxUXFMSxRGwdMOiNuf/bL/c7zjt1+GGNSu+Xr+cuvinnLfz6AewQAwEDMmTOnV2/+/PlDkGRgNsz9wgsvRENDwxCleXWaO7f39wvz5s0bgiTb1saew6/H+wkREeedd15B3d3dHRdddNEQpQEAAACALfPe9743ysvLB21eMpmMu+++O8aNG1fQv+SSS/q1/8QTT4xTTjmlV/+2226Lz372s7Fw4cI+91dWVsYZZ5wRX/7ylwvuV3FxcfziF7+IadOmRTab7VeWgfrZz34W06ZNK+i1trbGBRdcED/84Q9j3bp1m51xxBFHxLe+9a3YbbfdCvof+tCH4qabboprr722z/0jRoyID3/4wwW9E044IR555JFea1988cU4+uijY8mSJVFZWRkREQcccEAccMABcf/99/da35fa2tq4+uqro7S0NN9btWpVvP/974+enp4BzQIAeL0566yz4uyzz+7VnzlzZjz66KNDkGjTDjzwwF69rq6uuOSSS+Lb3/52rFixYpN7J06cGJ/5zGfijDPOKHjPf1FRUfzkJz+Jv//97/HUU09tk9wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAtlO6+SUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACvL+3t7dHe3h5r166Nurq6SKVTWzUvmUxGIpGIRCIRZcmySJYlo3JYZSSTySgrL4tk4p/Xk4koLyuPRDKR75WVlRXsZ+sNqxgWwyqGxejRoze5pr29PTLZTGQz2chms9GcaY5sJhuZbCYymUy0ZFuita11O6YGAAAAAF4tWjsbo755/lbNSJZUxh5j3lPQu+/F70Vj29I+971j1+9HoqQ8X6/IPBZXPHJ4rO9Y2+e+5vb6uG7RKbGs+e9x/G6X5ftjUrvFrDEnxMKVv9mCe9Hb9n5s9hz7vvzt59bdHS823r/RmcszC2PJ2ttil5FHvrxv3Ilx+7Nf7leeOeM/GHtPODlfr84+Gb9f/LF+7QUAYMvMnTu3V2/BggVDkGRg5syZU1DPn791Xxu/Hm34GEW8Nj62A7Xhc7irqysWLlw4NGFgG9pnn33i8MMPL+j97ne/iyVLlgxRIgAAAADYMqtXrx7UeR//+Mdj3LhxBb3HHnssrrrqqs3uraysjO9///u9+hdccEF8/vOf79f5LS0tcdFFF8Wdd94Zt912W1RXV+evjRkzJs4444y48MIL+zVrIN74xjfGO97xjoJeXV1dHHHEEfHkk0/2e85tt90We+21V1x77bVx3HHHFVy78MIL47rrrouenp5N7n/nO98ZFRUV+fruu++Oe+65Z5PrV6xYET/96U/jjDPOyPc+8IEPxP33b/y9SJvyi1/8IiZOnJivu7u74/3vf3+sWrVqQHMAAF6Penp6Nvo1XGdn5xCk2bSysrL4yU9+UtBbvXp1HH300TFv3rzN7q+rq4tPfvKTce2118af/vSnqKmpKZh95ZVXxkEHHdTn17MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAq0/pUAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4rcvlcpHL5QZlVllZWZQlyyKRTEQikYhkMhllZWWRTCTzvYryikgkXr6dSCaivKw8vzaRSLy8PpmM4uLiQcn0elRWVhZlZWUxcsTITa7p6OiIbDYb2Ww2MplMZLKZyGay0ZxpjpZsS2SymWhpadmOqQEAAACA14qDd/xUpMvG5Ov1HQ1x53Nf73PPyGE7x9Thh+frts7m+Nn8Y2J9x9p+n/tg3eUxbfibY4+x78r39hx3Yixc+ZsBpN+2+vvYJIorYnzV7Hz9zNq/9Dn3mbV/iV1GHhkREaMqd4mK0tpo7Wzoc8+oyhlx/K6X5euOrtb41aPviY6u9f25KwAAbKG99tqroH7uueeiqalpiNL0z6RJk2L48OEFvXnz5g1RmlevuXPnFtSdnZ3xj3/8Y4jSbDsbPoeffPLJaG1tHaI0sO2cd955vXoXXHDBECQBAAAAgFePysrK+NKXvtSrf84550RPT89m93/0ox+NESNGFPR++tOfxuc///kBZ3n44Yfjox/9aFx99dUF/Q996ENx4YUXDnje5qxfvz7uuOOOOPzwl9/j1NbWFkcffXQ8+eSTA56Vy+XiPe95Tzz22GOxyy675PtTpkyJQw89NO68885N7j344IML6htvvHGz5914441xxhln5OsDDzxwQHk/9alPxTHHHFPQ+/rXvx533HHHgOYAADC0zjvvvIKvPzOZTBx55JGxYMGCAc2555574rjjjovbbrstysvL8/0DDjggPvKRj8QVV1wxaJkBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAba90qAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADwL+3t7dHe3j4os0pKSiKZSEayLBllZWWRKE1EIpmIZPLlOplIRiLxz7r8X3UikcjXyeTLvbKyskHJ9FqSSCSitrY2amtrN7mmq6srWlpaIpPJRDabjUw2E83NzZHNZl+uM5loaWmJ7u7u7ZgcAAAAABhKlclR8cbJnyno3fnc16O1s7HPfS+tfzq+dd/MOHDHM2PO+A/Gnc9dEI1tdQM+/4G6H8YeY9+VrydUzRnwjG1lII9NqmxMFBeV5Ou1rc/2OXvt+sLrVeXjozXbsMn1pcXl8YE9r41kaWW+96cnPxkrs4/3eQ4AAFuntLQ09thjj4Le/PnzhyhN/82Z0/vr6tdC7u1t7ty5BfWiRYsil8sNUZptY2PP4Xnz5g1RGth2dt1113j7299e0Lvlllti4cKFQxMIAAAAAF4lPvWpT8WYMWMKenfccUfceuut/dr/0EMPxQ033BDHHHNMFBUVxcqVK+PMM8/c4jzXXHNNfOUrX4kZM2bkezNmzIjhw4fHunXrtnjuxjzyyCPxpje9KebOnRuf/exn49lnn43HH9/y99rkcrn4yle+Er/+9a8L+ocffnjceeedm9y3yy67FNSLFi3a7Fkb5vz3x2tz9ttvv7jwwgsLenfddVd8+ctf7vcMAIDt5dBDD41Jkybl62eeeSbuv//+IUz06pFIJOK0004r6J199tmxYMGCLZp3zz33xBe/+MX4xje+UdA/66yz4oorrtjinAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMD2VzrUAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANg2urq6orWrNVrbWgdlXjKZjEQiEeVl5ZFKpSKVSkW6Kv3y/6bSkU6/fHvYsGGDct5rQUlJSVRVVUVVVdUm1/T09ERLS0tkspk4+KCD47BDD4tly5ZFfX191NXVRX19fSxbtiza29u3Y3IAAAAAYFt589Tzo6w0na8bWpfGfS9+r197V7Usjt8vPjVuWXJudHS3bdH5q7KPF9SVydFbNGdbGMhjU1FaU1C3d2b6nN3W2bzB/to+179j1+/H2PTMfL1wxW/j4WU/7nMPAABbb/fdd49kMlnQmzdv3hCl6b+5c+f26i1YsGAIkrx6VVdXx5QpUwp68+fPH6I0285r9TkMA/W5z30uioqKCnoXXHDBEKUBAAAAgFeHUaNGxWc+85mCXk9PT69eX+6///447rjjYurUqfHJT34ynnrqqchk+n5fzObceuutMWPGjILe1KlTY926dVs1d1PmzZsXJ5xwwqDMuummm3r1dttttz73DB8+vKBevXr1Zs/ZcE0ymYyKiopobe37v7+tqamJq6++OhKJRL63Zs2aeN/73hfd3d2bPRcAYHs788wz4x3veEe+/tnPfhb333//0AV6FXn7298eI0eOzNePPfZYXHnllVs187vf/W6cdtppMXny5Hxv1113jf333z8eeOCBrZoNAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbD+lQx0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA14ZcLhe5XC5aWlpi7bq1m1xXUlISqVQqUqlUVFVVRSqVinQqHel0+uXb6XRUVlZGUVHRdkw/dIqKivKPx7ix42K//fbb6LqXXnopli9fHkuXLo36+vqor68vuF1XVxfZbHY7pwcAAAAABmJ4xZTYb4dTC3q3PfOF6OrJDWjO+o51W5wh17W+oC4tTm7xrME00MemqKi4oO7p6epzfndPZ5/7/93sce+PfXb4cL5+qWVJ/G7RR/qcDwDwn2Ts2LExfvz4GDlyZFRXV8f69etj7dq1sWjRoshkMls1e86cOb168+fP3+J5iUQiZsyYEePGjYuqqqro6emJdevWxUsvvRTPP//8oP09+4a5ly9fHqtWrRqU2ZuyLT8OmzNq1KiYNGlSjBo1KqqqqqKlpSWWL18e//jHP6Kzs3Ojewb7Y7s1dtpppxg9enSMHDkyUqlUtLa2RkNDQyxevDjWrdvy77ciNn4/582bt9G1I0eOjF133TWGDx8eiUQi1q5dG6tWrYqnn356k4/j1ther4ftbeTIkTFp0qT8a6G1tTVWrVoVjz32WLS3t2/XLNv7dVlaWhq77rprjBkzJqqqqqK4uDiy2WysWbMmFi9eHK2trYN+ZkTEpEmT4v3vf39B7/7774977rlnm5wHAAAAAK8V559/fqTT6YLeb3/72y36efizzz4bZ5555qDkWrZsWa9edXX1oMze1pqbm6O5uTmqqqryvdra2j73pFKpgro/Pyvt6OiI7u7uKC7+13uK0un0Zvf+7Gc/ix133DFf9/T0xAc+8IFYsWLFZs8EAODV5cMf/nBBffHFF0dPT89WzczlcvGtb30rvvvd7/Y664EHHtiq2YNl4sSJMX369Kiuro7i4uLIZDJRX18fTz75ZHR19f0efQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPhPUTrUAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHh96erqiqampmhqaor6+vqNrikqKorKysqoqqqKVGUqUqnUy7dTqUilU5FOpSOVSkVJScl2Tj90Ro4cGSNHjoxZs2Ztck0mk4m6urpYtmxZLF++PJYuXRr19fWxbNmyqKuri+XLl8fatWu3Y2oAAAAA4N8dufP/RklxIl8vb340Fiz/5XbNUJkYUVC3dTZv1/M3Zasfm6KizVwu7teYkcN2jnfu9qN83dndHr969ITIdWX7nwUAYDv5n//5nzjssMPy9X333ReXX355wZrp06fHcccdF/vss09MnTo1qqurI5FIxEc/+tG4/fbb+33WoYceGv/1X/8Vhx9+eEyZMmWja3p6euLRRx+Nq666Kn70ox9FS0vLgO/TnDlzevUWLFgwoBmpVCo+9KEPxXve85444IADIpFIbHRdZ2dnPPTQQ/HHP/4xfvjDH8b69ev7nFtWVhY//vGPN3rtoIMOKqgTiURcddVVm836yU9+MhoaGja77hXb6+OwMTvuuGOcccYZ8da3vjX22GOPja5pbW2NG264IS655JJ4+OGHC65t7GM7f/78Qcm2OcXFxfHOd74z3v3ud8ehhx4aY8aM2eTap59+On7zm9/ED37wg1izZs2Az9rwfnZ3d8fChQvz9ciRI+NjH/tYnHjiibH77rtvdEZjY2PccMMNceGFF8bixYsHnOHfbavXw6ZszeeliOj356apU6fG6aefHkccccQmH8eOjo647bbb4jvf+U6vmRt7PX/xi1+MF154oT93s8D2fl1WVVXFBz7wgTjxxBNjv/32i2QyudF13d3dMW/evLjmmmviiiuuiObmwfv+/9Of/nSUlpYW9C644IJBmw8AAAAAr0VTpkyJU089taCXy+XivPPOG6JE/9LV1TXUEbZKW1tbVFVV5etN/ax7U3p6evq1rru7O4qL+/ceo4iIM888M97+9rcX9C666KK47bbbBpQPAIChV1xcHAcffHC+bm9vjz/96U+DMvvaa6+Nb3/72wVfa77xjW8clNkbs99++8UZZ5yRr5uamgrqiIidd945zjrrrHjnO9+5yffRtLe3x5133hm//OUv47e//e1mv6/43//939hhhx169Tf2PqOLLrooGhsbN3tfLr/88rjvvvs2uw4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC2tdKhDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMB/np6enshms5HNZvtcN2zYsEin0pFKpyKdTkcqlYp0Kv2v2+l0JBKJ7ZR66KXT6dhtt91it9122+Satra2qKuri+XLl0ddXV3U19fHsmXLYunSpbF8+fJYtmxZrFq1Knp6erZjcgAAAAB4/ZtQNTdmjXlPQe/mp8+Jnti+P4ubVPOGgrq5bfl2PX9jtuSxyXW1FNTJ4mF9nrHh9VxX758/lxaXxQdmXxtlpal874Ynz47lmYV9zgYAGCr/8z//EwceeGC+fuKJJ/K3586dGxdeeGG8+c1v3ujeJ598sl9nvOUtb4mvfe1rse+++252bVFRUcyePTtmz54dn/nMZ+LUU0+NP/3pT/065xVz5swpqOvr62PNmjX92ltaWhqf/vSn43Of+1xUV1f3a/2BBx4YBx54YHzqU5+KT37yk3Hddddtcv0ee+wRH/jAB/qVZdSoUZtdu3jx4mhoaOjXvO39cfh3NTU1cfHFF8fJJ5+82fdgVFRUxAknnBAnnHBCXHnllXHGGWdEa2trRETsvffeBWu7u7vj0Ucf3eJc/XXSSSfF+eefH1OnTu3X+p133jm+9KUvxdlnnx3nnHNO/OhHPxrQeRs+h5966qloaXn5+5dTTjklLrnkkqiqqupzRk1NTXzwgx+M9773vfH5z38+vvnNbw4oQ8S2fz1sytZ8XorY/OemUaNGxaWXXhrve9/7oqSkpM+1iUQi3va2t8Xb3va2+OMf/xgnn3xyNDU1RUTErFmzCl6jPT098bGPfazPeRsaitflJz7xifjSl74UI0aM2Oza4uLi2GeffWKfffaJz3/+8/G5z31uwM/njRk5cmSccsopBb1//OMfcdNNN231bAAAAAB4Lbvgggt6/Rz9sssuixdeeGFoAv2b0aNH9+q98vPS14La2tqCurm5eUD7i4qK+rWuuLi43zP32Wef+MY3vlHQu+++++ILX/jCgLIBAPDqMGPGjKisrMzXf/3rXyOTyQzK7JUrV8ZDDz0U+++/f743bdq0qKmpicbGxkE549/tuOOOBe+JWLlyZZxxxhkREZFMJuOiiy6KT3ziE5t930VZWVkceeSRceSRR8ZXv/rV+PjHPx633nrrJtcfc8wxMXPmzH5lPOaYY/q17oc//GG/1gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMC2VjrUAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYfNXV1bHjjjtuk9mrVq6KVatXbfJ6cXFxzJw5c9DO6+zsjMWLFw/avKF8bCIikslkzJ49O6ZNnRa1tbVRXl4e7e3t0djYGM8+92wsXLAwWttatzrLjF1mRLIsma+XLVsW69at2+q5ALC9rV+/PtavX9/n/8eWlZVFKpWKqnRVpFKpSKfTkU6nozJVme+Vl5dvx9RDq7y8PKZPnx7Tp0/f5JqOjo5YsWJF1NXVRX19fSxfvjxeeOGFWL58edTX10ddXV2sWLEiOjs7t2NyAAAAAHhte9vO34iioqJ8/czav8aStbdt9xz7Tzq9oK5reni7Z9jQljw2LbmXCup02bg+11eVj+9zf0TEcTO+G+PSs/L1P1ZeFw/WXdbnXACAoVJUVBSzZ88u6C1YsCAiIr7whS/El7/85SgpKdno3jVr1kRdXV2f8xOJRFx88cVx1llnbVG+sWPHxh//+Mc4++yz4zvf+U6/9hQVFcWee+5Z0Js/f36/9u64445x/fXX99rfX+PGjYtrrrkmPvrRj8aPf/zjja7Za6+9tmj2plx77bWbXTMUH4d/t8cee8Qf//jHmDJlyoD3/s///E/svvvu8eY3vzmy2WzMmTOn4PrTTz8dLS0tA57bX1VVVfGTn/wk3v3ud2/x/ssvvzxmzJgRZ599dr/2bOw5PG/evEilUnHdddfFW9/61gFlSCaT8Y1vfCOam5vjiiuu6Pe+7fF62Jit+bwUsfnPTW94wxviuuuuiwkTJvQ70yve8Y53xAMPPBAHH3xwrF27Nvbee++C6wN5Pg7F63LYsGFx9dVXxzHHHLNFZ9bU1MTll18eBxxwQJx88snR09OzRXMiIs4666yoqKgo6F1wwQVbPA8AAAAAXg/mzp0bJ5xwQkGvubk5vvrVrw5RokL77bdfr97KlSuHIMnA7bbbbpFIJAp6S5Ys6XPPhj/v3fBnmhuTSCSiuLi4oJfNZje6trq6Oq655pqCXGvXro33vve90dXVtdmzAAB49dnwfQT9fc9Sfy1YsCD233//gt6cOXPijjvuGNRz+lJTUxN//vOf4w1veMOA906ePDluueWW+N///d8477zztkG6jRvMf1sOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtkbpUAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYPCNHTs2jnjLEdtk9n333xerVq/a5PWysrJBPbulpSUWL148aPOG8rHZcdKO8bZj3hbDKoYV9MvLy2Ps2LExduzY2Hvu3vHnW/4czzzzzBbn2H333eOoI4/K1y+99NKgPoYA8GrT3t4e7e3tsXbt2k2uKS0tjap0VVSmKiOdTkc6nY5UKhVV6apIpVKRSqWisrJyO6YeWolEIiZNmhSTJk3a5Jru7u5YtWpVLFu2LJYvXx5Lly6NZcuWRX19fdTV1cXy5cujrq4u2tvbt2NyAAAAAHh12nnEW2PqiMPydU9PT9z01Ge2e479dvhoTK49uKC3cMWvt3uOf7elj836jrXR2FoXNRUTIyJiUs0b4r6l393k+onV++Vvt+TWRmPb0oLre459b+w38aP5eu365+K6RR/u9/0AANjedt55515/j71gwYL4wQ9+EKeddlqfex955JE+r1dUVMStt94aBx988EavL1u2LObNmxerVq2Kjo6OGDVqVOy1114xffr0gnVFRUXxrW99K5YuXRp/+MMfNnufdtlll173af78+Zvdt+uuu8bf/va3GD16dK9rL730Ujz44IOxbNmyaG9vj3Q6HWPHjo0DDjggampqeuW94oor4rHHHouHH36416y5c+duNstAXHPNNX1eH6qPwyv22muvuPvuuyOVSm3y/MWLF8eaNWuipKQkxowZE3vssUeMHDkyv2a//faLn/70p/Hf//3fvXItWLCg31kGasSIEXHvvffGjBkzNnq9sbExHn300Vi1alW0tbVFOp2OXXfddaPrzzrrrHjiiSfiiiuu2Oy5G3sOL1q0KG688cZ44xvfWNBfuXJlLFq0KFavXh3FxcUxduzY2G+//aK8vLzX3B/84Adx2223xQsvvLDZDNvr9bAxW/N5KaLvz00HHnhg/PWvf42ysrKNXu/P83HXXXeN6667Lg477LDYe++9C/b353NNxNC8LouLi+Oaa66Jt73tbb2u5XK5eOihh+Lpp5+OlpaW/Md0+vTpMW3atF7rTzrppFi3bl2cffbZ/bq/G0qlUnH66acX9J577rnNfj4DAAAAgNe7iy++OIqKigp6//u//9vnf9O4vey00069fka9Zs2aqKurG6JEA3PyySf36v3lL3/pc8+6deti6tSp+XpjPzPf0IZrcrlcrF+/fqNrf/rTn8ZOO+2Ur3t6euKkk06K+vr6zZ4DAMCr0x577FFQ/+Mf/xjU+Y899liv3u677x533HHHoJ6zKYlEIm6++eZ4wxveUNDv6OiIRYsWxbJlyyKXy8Xw4cNjp512Kvh699+de+65kUwm49Of/vQ2z7x8+fJoamra5ucAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAf5QOdQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXl+SyeRQR3hVmjRpUrzzne+MkpKSfK+trS1aW1ujoqIiysvLIyKirKws3n7c2+P666+PZ559ZsDnjBgxIt78pjfn646Ojrjhhhuis7Nz6+8EALyGdXZ2xrqGdbGuYd0m15SUlERlZWWkU+lIp9ORSqUiXZWOdOqft9PpqKysjOLi4u2YfOgUFxfHuHHjYty4cX2ue+mll2L58uVRV1cXy5Yti/r6+li6dGksX748li1bFnV1dZHNZrdTagAAAADY/oqiKI7e5eKC3sKVv4nlmQXbNceeY98bb9/1BwW9ZU1/jyVrb9uuOf7d1j42T73059hv4kcjImLXUcfGsMSIWN+xtte68tKqmDnmXfn66bW3FlwfMWxavGv3/8vXnd25+NWjJ0RbZ3O/7wsAwPY2Z86cgnrVqlXx3ve+N0477bSC/po1a+Jvf/tbPP7447F27drIZrOxePHiTc4tLS2N3/3ud3HwwQcX9Lu7u+Pqq6+OCy+8MB577LFNZvr+978f+++/f75XVFQUl112Wdxxxx3R1NTU533aa6+9evXmzZvX555Ro0bFrbfeGqNHjy7oP/7443HuuefGzTffHN3d3b32FRUVxbve9a649NJLY+LEiQX973//+7Hvvvv22vPNb34zrrjiil7973znO3HQQQfl67Vr18YRRxzRZ+6enp5X7cchImLChAlx4403RiqV6pX717/+dVx88cUbPb+4uDje9KY3xaWXXhozZ86MiIh3v/vdsWjRoigqKipYu7mP7ZaqrKyMm2++OWbMmNHr2k033RQXXXRR3HfffRt9XsyYMSO+8Y1vxDHHHFPQv/DCC+Paa6+NhoaGPs/e2HP49NNPjx122CFf/+53v4uLL744Hn744Y1m/3//7//FF7/4xSgtLc33S0tL49Of/nScccYZfZ6/PV8PG7M1n5d6enriiSee2OjcadOmxfXXXx9lZWUF/f4+Hy+55JLYY489IiLi0EMPjfe+970xd+7cgrX9eT4O1evy1FNPjbe97W0Fvba2tvjqV78aP/jBDza5d88994xPfvKT8T//8z8F/TPPPDN+//vfxz333NPn/d2Yj3/841FTU1PQu+iiizb6vAIAAACA/xRHHHFEHH744QW9+vr6+Pa3vz00gTZw6aWX9vpvHm+++eYhSjMwe++9d5x55pkFvaVLl8af//znPvc9/fTTsc8+++Tr3XfffbP3+ZW/13jFkiVLNrruE5/4RBx//PEFvUsuueQ185gCALBxtbW1BfUzzwz83/bqy8bmbXjmtvS1r32t4D0Lzz77bFxwwQVx7bXXRiaT6bV+6tSpceqpp8YZZ5wRFRUVBdf+3//7fzF//vz49a9/XdB/73vfm/930v7dKaecEh//+Md7rd3cY7x+/frN3i8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADYXkqHOgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAry3d3d19Xk8kEtspyavPph6bZDIZbzv6bVFSUhIRES0tLXHLLbfE8y88n18zadKkOOrIoyKdTkdRUVEceeSR8ZMrfxKtra39Pr+0tDSOPfbYgo/BX/76l1i7bu0W3iMA+M/S1dUVzc3N0dzcvMk1RUVFMWzYsKiqqopUZSpS6VSk0+lIpVJRla6KVCoVqVQqSkv/c35d4MiRI2PkyJExa9asTa7JZDJRV1cX9fX1UV9fH0uXLi24vXz58li71tcsAAAAALw27TX+AzEu/a+fj3V25+LWJZ/fbucnSobFkdMviAMnfTKKiory/VxnS1y36MPREz3bLcuGtvaxuffFb8c+O5wSxUXFUVaaihNn/TKuWviu6Ohan19TWlwe75n5sxiWqP3Xvhe+lb9dUpSMD+x5bZSVpvO9m5/6TNQ3z9vSuwUAsF3MnTu3oF6/fn1ceOGF+frvf/97fOUrX4kbb7xxQHMvvPDCOOqoowp6a9eujfe///1x22239bl3/vz5ccghh8Qf//jHeNvb3pbvjxkzJk499dS4+OKL+9y/4X16ZWZfLr/88pg4cWJB78orr4yPfexj0dHRscl9PT09cd1118VDDz0UDz74YIwfPz5/bZ999onZs2fHwoULC/Y888wzG5214fnz58/fbO7NGcqPQ0TEL37xi4LHJCJi3bp18e53vzvuvPPOTe7r7u6O22+/PebMmRO///3v45hjjomIiPPOO2+jObeF73//+7HvvvsW9DKZTHzwgx+M66+/vs+9Tz75ZBx77LHxve99L84444x8v7a2Nj74wQ/Gd7/73T73b+w5vMMOO0TEy4/fCSecEH/96183ub+lpSX+v//v/4s1a9bED3/4w4Jr73vf+woybcz2fD1szLb6vHTVVVfFiBEjCnoDeT7OnTs3rr322nj7298eERGf+tSnYvfddy9Y25/n41C8LouKiuL8888v6DU1NcXhhx++2cyPPvpofPjDH4477rgjfvazn+Xfr1RUVBSf+9zn4p577ulz/4aSyWR86lOfKuitWLEifvaznw1oDgAAAAC83lx00UW9el/84hejra1tCNIUOuecc+L444/v1b/sssuGIM3AHHXUUfHLX/4ykslkQf+cc86Jrq6uPvfefffd8V//9V/5+phjjolvfOMbfe7595/dRkTce++9vdbMnTs3vvnNbxb0HnzwwTj33HP7nA0AwKtfdXV1Qd3U1DSo8zf275TU1NQM6hmbUlNTE2effXa+/r//+7/4xCc+Ee3t7Zvc8+yzz8Y555wTl112WfzpT3+KmTNnFlz/7ne/G7fcckusW7cu31u8ePFGZy1btqxX7/HHH9/kegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHg1Kh3qAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMvhdeeCGuuuqqrZ4zc+bM2GuvvfJ1Z2dnPLH4iT73JBKJgvquu++KpS8u3eIM3T3dW7x3Y4bisZk1a1ZUVlbm6+v/dH0sX768YM3SpUvjD3/8Q3zwAx+MoqKiKC8vj71m7xX3P3B/vzO9+U1vjpEjRubrRYsXxaJFi/q9HwDYvJ6enmhpaYmWlpY+11VUVEQqlYp0Oh3pdDp/u6urK5KJZEyaNKng64PXu3Q6Hbvttlvstttum1zT1tYWy5Yti/r6+qirq4v6+vpYtmxZwe1Vq1ZFT0/PdkwOAAAAAH0rKUrGEdO+VtB7YOkPoqH1hW1+dlEUx5zxJ8Vbp38tqssnFFzLda2PXyx8Z6zIPLbNc2zKYDw2q1ueiDuf+3q8aeoXIyJil5FHxjkHPxNPrL4xsrmVUZkcHbuOeltUl++Q33Pvi9+JZc1/z9fHzvh2jK+ana8Xrb4+7lv63XxdFMWx88i3xi4jj4raih0jWZKKlo6XYlXm8Vi0+g+xMvv4AO85AMDg+Pf3p0VETJ48OX/74osvjnPPPTe6uwf2/ro5c+bEWWedVdBramqKQw89NB5/vH9f93R2dsYHPvCBePbZZ2P48OH5/oc//OG4+OKLN3v+v3vppZeivr6+zz0XX3xxjBo1Kg4++OCIiPj1r38dH/7wh/uVNSKirq4uzj///Pjxj39c0D/yyCNj4cKFm91fW1sbO+64Y0FvwYIF/T5/Y4b64/Cud70rDj/88IJeY2NjHHTQQfHEE32/R/QVHR0dceKJJ8Y//vGPmDx5cq/3jkZs/eO0MW984xvj5JNPLuhls9k45JBD+vXxfMWZZ54ZBx98cOy5554REbFu3bp+7dvwOfyKVatWxcEHHxxLlizp15zLLrsszjjjjIL3UQwfPjymTJkSzz333Cb3DfXrYVt8Xjr55JPjDW94Q0FvS56P73//++PRRx+NadOmxb777ttrzeaej0P1utx///1j7NixBb3PfOYzMX/+/H6dGRHxq1/9KmbNmhXnnHNOPP/883H55ZfHlVde2e/9r/jv//7vXlkuvfTSyOVyA54FAAAAAK8X73//+2P27NkFvUWLFsXPf/7zoQn0T0VFRfGVr3wlvvjFL/a69tvf/jYeeuihIUjVt+Li4pg0aVIccMABcfLJJ8db3vKWXmv+7//+L66++urNzvr9738f3/nOd6K8vDwiIg455JA46KCD4t57793o+rFjx8Z///d/F/R++ctfFtRVVVVxzTXXRDKZzPcaGhrive99b3R2dm42EwAAr27V1dUFdSaTGdT5G5u34ZnbyitfF0dE/OQnP4mPfvSj/d77/PPPxwEHHBAPPfRQ7Lrrrvn+iBEj4txzz43PfOYzg5oVAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXq1KhzoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIOvvb09Vq1etVUzEolE7LzzzgW9BQsWRHOmuc99yUSyoH7ppZe2OstgGorHZsaMGfnbdcvqYvny5Rtdt3r16njhhRdi8uTJ+X33P3B/vzLttttuMXPmzHy9dt3auP322/u1FwAYfK2trdHa2hpr1qwp6N9///3xh9//ISIiqqqqYocddogddtghxo8fH5MmTSq4PX78+BgxYsRQxB8S5eXlMW3atJg2bdom13R0dMTKlSujrq4uli1bFsuXL48XX3wxli9fHsuWLYu6urpYsWJFdHZ2bsfkAAAAAPwnO2DSGVFbMSlft3Y0xR3PfW2bnztrzHviiOlfjVGVu/S6tq71hfjlwndHffO8bZ6jL4P12Nz+zJdiWGJk7D/p4xERUVU2Lvab+JGNrl2w/Fdx01Ofztd7jHl3fl9EREPri3HtP07O1ztU7RPvmXlljE3PjF7GnhBHTP//YuGK38YfFp8abZ19/105AMBgmzNnzkb7X/3qV+P888/fopmXXXZZlJSUFPTe9773xeOPPz6gOY2NjXH55ZfHeeedl+/tvPPOMWHChKivr9/kvr322qugnj9//mbPeuihh+KQQw6JY489Nj72sY/FKaecMqCsERHXXXdd/N///V8UFRXle7Nnz+7X3g0zR0TMm7d1X2sP5cehqKgovvGNb/Tqn3jiifHEE08M6PyWlpa48MIL40c/+lGva88//3w0NjYOaF5/fP/73+/V+6//+q9YuHDhgOZ0d3fH1772tTj11FPjxz/+cfzhD3+IXC632X0bez60t7fH29/+9liyZMmAMlx99dXxla98paC32267xXPPPbfJPUP9ehjsz0ulpaVxwQUX9OpvyfNx/fr1ccEFF8SVV17Z61p/no9D9bp8wxveUFB3dXXFb37zmwGdGRHx5S9/Oe6444647bbboqenZ8D7i4uL45xzzinoNTQ0xOWXXz7gWQAAAADwepFIJOLrX/96r/5nP/vZ6O7uHoJEL5s2bVpcccUVcdhhh/W6tmTJkjj99NOHINXLfvvb38Zb3/rWXv2SkpJIpVIFP5ve0A9/+MM444wz+nXOSy+9FD/5yU8K7us111wTxx57bK+/x5k0aVL84Q9/iFQqle898MADce+99xasu/LKK2PKlCkFvZNPPjmWLl3ar0wAALy6/fvXgxEvv89gMGWz2V69dDo9qGdszrPPPhunnXbagPdlMpl417veFQsXLoxk8l//ftwpp5wS559/frS2tg5mTAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHhVKh3qAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC8Ou09d++orKzM121tbfHgQw9udl8ikSioOzs7Bz3bUBvIY1NaWhqjR43O10tfXNrn7BeXvhiTJ0+OiIjhw4dHeXl5tLW19bln+PDh8ZY3vyVfd3R0xA033PC6fOwB4PWkubk5Fi9eHIsXL97kmvLy8pg4cWKMHz8+Jk6cGBMmTIgJEybEjjvuGOPHj48JEybE2LFjo6ioaDsmHzqJRCImTpwYEydO3OSanp6eWLlyZdTX10d9fX0sXbq04Pby5ctj2bJlm/0aCwAAAAA2p7y0Kg6f+vmC3t+e/99Y37Fum505Y+TR8dbpX4/xVbN7Xevu6Y5Hlv04bnzq/0WuK7vNMvTHYD42PdETf3zitFiy9rZ489Qvx/iqPXutWZ19Mv763Fdj4Ypf53vDK6bEu2f+JF93dXfErx59b7R2NkZExNThh8XJc26MZMmwPs+fPe7EGF25a/zokUOirbN5wPkBALbETjvtFDU1Nb36t9xyS5x//vlbNPOAAw6Ifffdt6B3zTXXxJ///OctmnfrrbfGeeedV9CbOXNm1NfXb3T95MmTe92n+fPn9/u8G264IW644YYB54yIaGpqivr6+thhhx3yvXQ63a+9c+bM6dUbSO4NDfXH4cgjj8y/R/EVv/nNb+LWW2/dovOvvvrquPzyy3u9b2HBggVbNK8vhx12WMycObOg97vf/S7+9Kc/bdG86667Lq677rp+r9/Yczgi4sILL4yHHnpowOf/4x//6NVLJpP92jsUr4dt8Xnp7W9/e4wbN66gt7XPx//7v/+LkpKSgv7mXrND+bqcOnVqQV1fXx/Z7MC/p29tbd3ixy0i4oQTTogpU6YU9L7//e9vURYAAAAAeL047bTTYqeddiro3XXXXXHTTTcNSZ5Ro0bFeeedF6effnqvf9MhIuKFF16II488Mtat23bvXdqcysrKjf4suS91dXVx2mmnxY033jigfZ/97GfjiCOOiOnTp0dExLhx4+Lhhx+Oe++9NxYtWhSdnZ0xderUeNOb3hRlZWX5fdlsNj70oQ8VzDrttNPiXe96V0Hv29/+dq+/gxg5cmS8853vjLe85S0xYcKEqKmpicbGxli2bFncfvvt8Yc//CFeeumlAd0PAID+mDNnTnz961/v99p/95a3vKXff/991llnxVNPPTXgfK8FG763pbu7e1Dnb2ze9v53QM4///zI5XJbtPeJJ56I3/72t3HSSSflezU1NXHEEUfE9ddfP1gRAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4FWrdKgDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPDqU1FREfvss09B78GHHoz29vbN7k0kEwV1Z2fnoGYbagN9bIYNGxbFxcX5urGxsc/5G16vrKyMtra2Ta4vLS2N4449LhKJfz3ud9x5R7z00kt9ngMAvDa0tbXFkiVLYsmSJZtcU1paGuPGjYuJEyfGDjvsEOPHj48dd9wxxo8fHxMmTIhJkybF2LFjC75eeD0rKiqKcePGxbhx42Lvvffe5Lq1a9dGfX191NXVRX19fSxbtqzg9rJlyyKTyWzH5AAAAAC81rxxp3NiWGJ4vm5qWxb3vvidbXLW5NpD4sjp/xs71R6w0etL1v4lbnrq07Ei8+g2OX+gtsVjs2j1H2PR6j9GTfnEGDFsegxLDI/WzsZYt/7ZWNf6fMHakqJkfGD2tVFeWpXv3bLk3KhreigiIlLJ0fH+Pa+OZMmwiIho7WiKvzz75XjqpT9He2cmasonxRsmfizmTvhQRESMr9ozjt/tR/Gbx963VfcBAKC/5syZ06vX2dkZZ5555hbP/MQnPlFQ9/T0xBe+8IUtnrds2bJevXHjxm1y/V577dWrN2/evC0+f6A2fI9fRUVFv/bNnTu3oM5ms/HMM89scY6h/jiceuqpBXV3d3ece+65W3x+U1NTPPPMMzF9+vSC/rb42J5++ukFdU9PT3z2s58d9HM2ZWPP4fr6+rjwwgu3aF42m+3V217v7diS18O2+Lz08Y9/vKDe2ufj+vXr44knnoiZM2cW9Df3fBzK12V1dXVBXVVVFUVFRdHT07PF52+JDR/39evXx3e+s21+xgEAAAAArwXpdDq++MUv9up/5jOf2e5Zqqur45xzzokzzzwzKisrN7rmgQceiHe84x2xevXq7Zxu602YMCFOPPHEeOSRR2LVqlX93tfS0hJHHXVU3HbbbTFlypSIiCguLo5DDjkkDjnkkI3uyWQycfzxxxf895qzZ8+OSy+9tGDd3//+9zjnnHPydVFRUZx77rlx7rnnRiqV2ujs97znPXHppZfG17/+9bjooou2+895AYDXt5EjR8aRRx65RXsnTJgQEyZM6NfaDf8Om9eOpqamuO6667ZqxmWXXRYnnXRSQe+tb31rXH/99Vs1FwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAF4LSoc6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACvPgfsf0Akk8l83dzcHAsWLOjX3mQiWVB3dnYOarahNtDHpry8vKDOdeT6nJ/LFV7fcP+G3nT4m2LkyJH5+sknn4x//OMffe4BAF5fOjs7o66uLurq6ja5pqioKMaMGRM77LBDjB8/PiZNmhQ77LBDTJgwISZOnBjjx4+PiRMnbvZrj9eTESNGxIgRI2LWrFmbXJPNZmPp0qVRX18fy5cvj6VLl8ayZcuivr4+6urqYvny5fHSSy9tx9QAAAAAvFpUlNbGgTueWdC7/ZkvR2d326CeU1M+MY6d8Z2YOeb4jV5/vuHeuHXJ5+P5hrsH9dytsa0fm8a2umhs2/TPQyMijplxSUyompOvn1hzU9z9wiX5+pCdPhOp5KiIiOju6YqfzDsi6poezl9vbl8eS5sejNaOhjhop7MiImL2uBPjb89fGCsyjw7K/QAA6MvcuXN79X75y1/G008/vUXzysvL4/jjC7+mvP3222PJkiVbNC+i93vdIl7+u+lN2dh9mj9//hafP1C1tbUF9cqVK/u1b6+99iqo+/teyo0Z6o/DsGHD4uijjy7o3XLLLfHiiy9u8fkREWvWrInp06cX9Ab7Y1tRURHHHXdcQe/222+PZ599dlDP6cvGnsOXXXZZtLVt2fc6paWlvXrr1q3bolkDtSWvh8H+vBQRcdhhh/3/7N13fFRV/v/x96R3QhIgTGZCB+kQsIOoiAJfUGQXUUCxgGJbbKyIZdfeELFgV2wgYgFWERFBQKQIJPRek8yQAIGQCenJ/P7Yn7MOM+lTAF/Px8NH5nzOOZ/zuXfuHW5mrhOntieOR3f3cVR1PPr7vDx8+LBTOzY2VqNGjdJnn31W5/Vra+DAgS73z7z//vvKycnxWQ0AAAAAAADA6ebhhx9WfHy8U+yrr77S2rVrfVZDZGSkxo8frwkTJig2NtbtmJKSEv373//Wiy++qIqKCp/V5kkBAQEaOXKkrrrqKg0bNkxLly6t8dy9e/fq/PPP18svv6ybbrpJAQEBlY5dsmSJ7r33Xm3bts0Ri46O1ldffaXQ0FBH7MSJExo2bJhKS0slScHBwZo1a5aGDh1abT1RUVF6/vnnlZKSohEjRpx137UBAACA09evv/7q9n6F2li7dq0KCwsVHh7uiJ167xQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwtgrydwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgNNLgwYN1KVLF6fYit9WqLy8vEbzg4ODndplZWUeq83f6rJvDDI4tSsqKqpc49R+g8FQyUip/Tnt1blzZ0f7+PHjWvjTwirzAwCAvya73a6srCxlZWVVOS4+Pl5Go1Fms1lJSUkymUxKTk6W0WiUyWSSyWRSTEyMj6r2v6ioKHXo0EEdOnSodExRUZEyMzNltVqVnp4uq9WqjIwMZWRkyGq1KjMzU1lZWbLb7T6sHAAAAAAAAN7Wq9l4hQZFOdpHT+7WOst0j67RLmGAru8yQxHBDV36Mk6s1cLdj2p3ziKPrukJvtg3VenUZKguSr7H0T5RlKnZm29yGnOu6VbH401Zs5Vx4ne3uRbueVznmW9XSGCEJOk80xjN236vF6oGAABw1r17d5fY+++/X+d8vXr1UmhoqFNs9uzZdc4nSUaj0SVWWFhY6fiUlBSn9okTJ7Rv37561VBTMTExiouLc4odPHiw2nmRkZFq27atUywtLa3Odfj7eejVq5fLPZ4zZsyo1/qS3N5DWZ/95I672j/77DOPrlGdU4/hiooKffTRR3XOZzabXWL79++vc76aquv54OnXJUkKCAhwanvieHR3f0ZVx6O/z8vFixfr/vvvd4p9+OGHMpvNevPNN5WXl1evWmpi0qRJTu3S0lJNnjzZ6+sCAAAAAAAAp6smTZrovvvuc4qVlpbqkUce8cn6ISEhuvPOOzVp0iQ1bty40nFz5szRhAkTtHfvXp/UVRMjRoxweT9fkgIDAxUTE6OmTZvqvPPO09ChQ3XxxRc7jUlISNCPP/6oAQMG6JdffqnxmkePHtUtt9yip556SoMHD9a5556rJk2aKCgoSNnZ2dq+fbu+//57paamusz94IMP1Lp1a6fYrbfeqgMHDjjakydP1tChQ53GbN68WYsXL1ZOTo4SEhLUr18/p/8HcdiwYTp48KAmTJhQ4+0AAAAA6mPjxo31zlFeXq4NGzbowgsvdMTatWtX77wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAmSDI3wUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE4vl/S+RIGBgY724cOHtW3bthrPDw4JdmqXlZV5rDZ/q+++kSSDwVCv/j80bNhQ/fr1c7TLysr03fffqbS0tFb1AAAA/FlOTo5ycnK0efPmSsdERkYqOTlZSUlJMhqNjscmk0lms1lGo1GNGjXyYdX+FRYWptatW6t169aVjiktLVVWVpYyMjJksVhksVh08OBBWa1WZWZmKjMzU1ar9ay6dgYAAAAAADibBRpCdEHyXU6xX/a/ILsqPLZGlybDdEPXLxRgCHSKW/M26qc9j2v7ke88tpYn+WLfVKVheHP9veNHjnaFvVwzN16vgtJjjlhiVCdFBMc52tsOz6s0X0l5vvYdW6pzGg2UJDWP7e2FqgEAAFylpKQ4tQ8cOKCVK1fWOV/fvn1dYosWLapzPklq0aKFS+zAgQOVjj91m9LS0uq1/h8MBoPi4+PVpEkTNW7cWI0bN1aTJk0c/zVu3Fhms9ll3t69e6vN3a1bN5d7+tavX1/nWv39PFx++eUuscWLF9drfUlq3LixU/vQoUPKzs6ud94/c7fvlixZ4tE1qnPqMbxx40YdOnSozvlOvc/AbrcrPT29zvkk754Pnn5dcscTx2OTJk2c2haLRYcPH650vL/Py4ULF2rr1q3q2LGjIxYcHKxnn31Wjz32mJYtW6bffvtNa9eu1dq1a3Xs2DG3eeqqV69euvjii51in3/+uTIzMz26DgAAAAAAAHAmeeyxxxQZGekUe++992r0Xmp93XTTTXr22WdlMpkqHbNs2TI9+uij+u2337xeT23ZbLZK+44cOaK9e/dqxYoVmjJlis477zxNnz5dHTp0cIwJDQ3VV199pS5dushqtdZq7f379+v111+v8fg77rhD1113nVNs2rRp+vbbbx3tiy66SP/4xz+cxtxzzz2aNm2aS74HH3xQkydPdmp/+eWXWrduXY1rAgAAqMyaNWtcPtutzAsvvKDevf93z/OCBQv0zDPP1Ghubb9L60xit9ud2n/+HjFPcJfv1DW9af/+/R7Jk5WV5dRu2LChAgMDVV5e7pH8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwOkqyN8FAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABOH02aNFHbtm2dYsuXL69VjuDgYKd2WVlZves6HdR135SWljq1g4Kq/tNBp/aXlpS6jAkMDNTVg69WSEiII7Z06VIdPny42noAAADq6+TJk9q+fbu2b99e6ZjQ0FAlJSXJaDSqWbNmMhqNMplMMpvNMhqNMpvNSkxMVEBAgA8r95/g4GCZzWaZzeZKx9jtdmVlZclischqtergwYOyWCyyWCzKyMiQxWJRZmamioqKfFg5AAAAAAAA3Onc5G+KCmnkaOeXHFGa9XOP5U+K6aHru8xQgCHQESssPaHvd96vdZbpHlvHG7y9b6oSaAjWqK5fKTy4gSO2cPdjOpD7m9O4+IjWTu3s/G1V5s3O36ZzGg38/3NbeahaAACAyjVt2lRNmjRxii1ZsqReOXv37u0SO3jwYL1yurN792638aZNm6px48ZOsdTU1FrlDgwM1AUXXKDevXura9euatmypZo1a6ZGjRrV6bPntLS0asekpKS4xGpb95/5+3no1auXU3vnzp3Kzs6u11oGg0EtWrRwitVnH1Xm1Nr37Nkjq9Xq8XUq4+4YXrp0ab1yduvWzam9Z88elZSU1Giur88Hb7wunWrHjh0eOR5btXL+va2649Hf52VZWZlGjhypJUuWKC4uzqkvPDxc/fv3V//+/R2x/fv36/fff9eSJUu0cOHCetc6adIkp3ZFRYVeeOGFeuUEAAAAAAAAzmSJiYkaO3asU6ygoEBPP/20V9dt1aqVPvvsM1144YWVjlm9erUeffRRj78/6y+///67evbsqZ9++snpc4D4+Hi9/PLLGjlypNfW7tq1q6ZOneoUS0tL0wMPPOAUmzBhglP77bff1rRp09zmfOWVV9SpUyfdfPPNkv77nvVDDz2k66+/3mN1AwCAv64TJ05o5cqVNRqbk5Pj1M7Ozq7x3LOZzWZzakdGRrrE6iMqKsollpeX57H81fHUWrm5uS6xyMhIn24LAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4A9B/i4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHD66HNJHxkMBkf74MGDOnDwQK1yhASHOLXLyso8UZrf1XXfFBYWOrWjIqOqHB8V5dx/6nxJuvzyy9WoUSNHe+eundqwcUO1tQAAAPhKcXGx9u3bp3379mnFihVuxwQGBioxMVHJyckyGo1KSkpSs2bNZDQaZTKZZDKZZDQaFRIS4nb+2cZgMKhp06Zq2rRpleNycnJktVqVnp4ui8WizMxMZWRkyGq1KiMjQ5mZmbLZbD6qGgAAAAAA4K8pJekmp/Z6y8cqt5d4JLdBAbq+8+cKDAh2xGzFWXrn9z46WrDLI2t4kzf3TXUGtntZpgY9He1dRxdq6f4XXMaFBzd0aheUHqsyb+Gf+kODohRoCFa5vbSe1QIAAFQuJSXFJbZ06dI65zMYDOrWrVvdC6ohq9WqnJwct33utmn9+vU1yms0GjVhwgSNHDnS6b65+igrK9OWLVuqHXdq3cXFxdq+fXud1vT38+Bu/bVr19Z7vZYtW7p8rp+amlrvvH/mrdprw90xvHLlSo/mrMl+89f54OnXJUlO9+RKnnlOW7durdDQUKdYVfvV3+flHzZu3KjevXvrs88+c7uv/6xFixZq0aKFhg8fLrvdrkWLFumpp57Sb7/9Vuu6unTpogEDBjjFvv32W+3adfq//wAAAAAAAAB4y4MPPujyPuObb76p7Oxsr605YMAAffHFF2rQoIHb/tTUVD322GNasGCB12rwl8LCQl199dXavXu34uPjHfHrr79eDz/8sDIzMz2+ZlRUlL766iuFhYU5YjabTcOGDVNJyf/uc4qIiNCgQYOc5r7wguu9SKf233zzzY72kCFDFBwcrNJS7jUCAADwtxMnTji1o6OjlZWV5bH80dHR1a7pTX++lq2PgoICl1hYWJjy8vI8kh8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4XQX5uwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwOmhefPmSk5OdrTtdruWLV9W6zzBIcFO7bKyMuf+4GBFRkYqOPi/40pLS5Wfn+8y7nRSn31TWFSovLw8xcTESJKaGptKaZWPb9q06f/mFhYqz5bn1N+uXTt17dLV0c7NzdXChQtrVAsAAMDppLy8XBaLRRaLpcpxTZo0UVJSkpKSkmQ2mx0/TSaTjEajzGazIiIifFS1/8XHxys+Pl6dO3eudEx+fr4yMjKUmZkpq9Wq9PR0WSwWZWZmKiMjQ1arVUePHvVh1QAAAAAAAGePoIBQtYq73Cm24dBMj+VPMd6oxlHnONoV9gp9mnatjhbs8tga3uLtfVOVDo2uVq9m4x3tvOJDmrVplNuxgQbnz7Qr7KVV5i6rKHZqBwQEq7y86jkAAAD1kZKS4hJbvXp1nfO1bt1akZGR9SmpRjZu3Fhpn7ttSkur4ka6/++BBx7Q008/XafPhIuKipSdna3s7Gx169ZNISEhjr5t27apuLi4itn/dWrdmzZtUnl5ea1rkfz/PLRs2dJl/Zo8B9Xp1q2bS2z9+vX1zvtn7vZdamqqR9eoTl2P4cokJycrPj7eKVbdNvnzfPD065Ikmc1mp/aOHTvqlU+Sevbs6RKr6nj093n5Z9u2bVPPnj01cuRI3XnnnbrooouqnWMwGHTllVeqX79+mjp1qh544IFa1fXII4+4xJ5//vla5QAAAAAAAADOJhERERozZoxTrLi4WFOmTPHamv/3f/+nOXPmOL574c+2bNmiJ554QnPmzPHa+qeD48eP66WXXtKLL77oiAUEBOjvf/+7pk6d6vH13nvvPbVp08YpNmbMGO3du9cpdv755ysoKMjR3r59u9LT06vMvXPnTh08eFDNmjWTJIWGhqpnz55atWqVh6oHAABAXZ04ccKp3aBBA4/md5cvNzfXo2tUxW63n1Z5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgDNNUPVDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB/BX0u6ePU3rFjhw4fPlzrPMHBwY7H5eXlCggIUJvWbdS6dWslJSUpOjraZY7dbteJEyd0MP2gtm3bJovFUvsN8KL67pv9B/ara5eukqRWLVspPCxchUWFLuNCQkLUtk1bR/vAgQNO/bGxsbrqyqsc7fLycn33/XcqKSmpcS0AAABnmuzsbGVnZys1NbXSMbGxsUpKSlJycrKMRqPMZrNMJpOMRqOSk5OVlJSk2NhY3xXtZ1FRUWrfvr3at29f6ZiioiJZLBatWrVKVqtVmZmZSk9PdzzOysqS3W73YdUAAAAAAABnBlNMTwUFhDjaBaXHZLVt8Fj+c01jnNqbsr5U+onVHsvvTd7eN5VpGNZMwzp/7GhX2Mv1xcYbdLL0aA0zGKruNVTdDwAA4GkpKSlO7fz8fO3Zs6fO+dx9bvjRRx9p7969dc7pzrp16yrt69Gjh1O7oKBAO3furDLfBx98oNtuu81t3759+7Rjxw5ZLBZlZWUpKyvL8dnyH//l5eVJkiIiImSz2ZzmV/X58x9CQkLUoUMHp1haWlq18yrj7+ehbdu2LjFPrN29e3eXWH32kzvu9t3u3bs9ukZ1Tj2G8/Ly6rX/Tj3PpaqPS3+fD55+XZKkNm3aOLU98ZxeeumlLrGqts/f5+Wp7Ha7Pv/8c33++ecymUy67LLLdOmll+rcc89Vx44dFRAQ4HaewWDQ/fffr6CgIP3jH/+o0VotW7bUsGHDnGI//fRTjY4HAAAAAAAA4Gw1YsQIl/8HbebMmcrOzvbKeh07dtTXX3/t9P0MknT8+HH985//1IcffviX+f+7vv32W7344otOsfPPP9/j64wZM0Y33HCDU+zdd9/V7NmzXcae+j72tm3barTGtm3b1KxZM0e7devWWrVqVR2qBQAAgCcdO3bMqd22bdsaf55fE+7uzTl1TW8KDQ31SJ6QkBCXWHl5uUdyAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKezIH8XAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADwvw4dOqhRo0aOdnl5uX5d8WudcoUEhzgeGwwG3XH7HYqIiKhyjsFgUGxsrGJjY9W1S1dZrVYtXrxY2Yez61SDJ3li36SuT1WXzl1kMBgUEhKigQMHat5/5qmsrMwxJigoSAP6D1BYWJgjtn79esfjwMBAXT34aoWE/G//Llu2TNnZ/t9HAAAA/pabm6vc3Fxt3bq10jHh4eFKTk6W0WiUyWSS2WxWUlKS46fRaFRiYqIPq/avsLAwtWrVSq1atXLbX1ZWpkOHDikjI0MWi0UWi0Xp6emyWCzKzMxUZmamDh06pNLSUh9XDgAAAAAA4F/NYi9yaqfnrvFY7vCghmoee7FT7PfMDzyW39u8uW8qE2AI0oiuXyoiuKEj9vOeJ7Xv+LJK55RVFDu1gwJCKhn5R3+YU7u8oqQOlQIAANRcSkqKU3vDhg2y2+11zpecnOwSe+2117Rp06Y656yt7t27O7U3btyoioqKSsffd999uu2225xix44d0/PPP68ZM2bo0KFDNV67R48eCggIcIr9+d68ynTu3FlBQUG1nlcZfz8PLVq0cIkdPHiw3nkvueQSp/axY8eUnp5e77x/ZjabXWL79u3z6BrVOfUY3rBhQ73y9ezZ0yWWlpbmduzpcD54+nVJkuLi4pzaOTk59conSf369XNqHz16VBaLpdLx/j4vq5KZmanPPvtMn332mSQpMjJSPXr00IUXXqirrrpKl156qQwGg9Oce++9V7NmzdLKlSurzf/www8rMDDQKfbcc895bgMAAAAAAACAM9BNN93kEnvrrbe8slZgYKC++OILp+8WkKTdu3erf//+Pn8f3N/27NmjsrIyp89mjEajR9fo3Lmz3njjDafYpk2bNH78eLfjGzZs6NSu6fvYR48erTIPAAAA/GPjxo1O7c6dO3s0f5cuXVxivrz/oEGDBh7JExsb6xKz2WweyQ0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACczoKqHwIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOJsFBgaq18W9nGJpG9KUl5dXp3zBwcGOxwEBAYqIiKh1DqPRqBEjRmjJkiXauGljnerwBE/tm5xjOVq9erUuvPBCSVKLFi005rYx2rdvn06ePKmIiAi1bNlS0dHRjjnrU9crKzvL0b7s0svUuHFjR3vPnj1KTUt1tA0Gg5o3b64WLVooJjpGISEhKiws1NGjR7V7z24dPXq0VjUDAACcbQoLC7Vz507t3Lmz0jEhISEyGo1KSkqS2WyW0WhUcnKyTCaT43GTJk0UFHT2/znIoKAgmc1mmc3mSsfY7XZlZWXJYrHIarUqPT1dmZmZslgsysjIkNVqVUZGhoqKinxYOQAAAAAAgHc1imzn1LbkrfdYbmNMNxkMBke7vKJUB46v8Fh+b/PmvqnMgLYvKjn2fEd7T84SLdn3TJVzCkqPObUjQxoptyij0vGRIY0cj4vK8lRhL6tjtQAAANWLj49XcnKyUyw1NbWS0TUTFxfnEsvOzq5Xztqo7TbFxcXpqaeecoplZGSoV69eSk9Pr/X6l1xyiUusJvs0JSWlTvMq4+/noUGDBi6x/Pz8euWMiIjQBRdc4BSr7/HqTqNGjVxix44dczPSO7xxXp56fGVmZionJ8dl3OlwPnhj+yUpMjLSqV1RUVGvfD179lSLFi2cYtXV6e/zsjZOnjyp5cuXa/ny5XrxxRfVsWNHff755+rWrZvTuLvvvlsrV66sMldiYqJGjx7tFFu9erWWLVvm6bIBAAAAAACAM0bTpk3Vq5fz9wrs3LlT69at88p6o0ePVufOnZ1iR48e1RVXXFGn93/PBseOHXP6PoWYmBiP5Y6MjNRXX32lsLAwRyw/P1/Dhg1TcXGx2zlRUVFO7cLCwhqtVVBQUGUeAAAA+Mep1/Y9e/b0aP4ePXo4tSsqKpSWlubRNaoSHx/vkTyn3ktRUlKikpISj+QGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATmdB/i4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOBf3bt1V0xMjKNdXFys1atX1zlfcHCwSyw/P1/p6enKysqSLd+m4uJiGWRQaGioGsQ2kNFoVIvmLRQU9L8/qxMYGKh+/frJbrdr0+ZNda6nPjy5b35b+ZvCw8PVrVs3SVJUVJS6dOniduy27du0bNkyR7tt27aOeZJ0Iu+EFvy4wNFOTExU/6v6KyEhwSVXu3btdPHFF2vHjh36adFPKikpqVP9AAAAfwUlJSU6cOCADhw4UOmYgIAANWnSRMnJyTIajTKZTDKbzUpKSnL8TEpKUmhoqO8K9xODwaCmTZuqadOmVY7LycmR1WpVenq6rFarMjIylJGRIavVqszMTGVkZMhms/moagAAAAAAgPqJCI53atuKD3ksd2xYM6f2scL9Krd7//O9oIBQGQyBTrHS8oJa5/HmvnGnfaNBuqT5A39aL1tfbBohu+xVzjt8crtTu2l0V1nyUisd3zTqf5/rHs7fVsdqAQAAaqZ79+4usdTUyq9VauLP9+X5g7ttWr9+faXjb7jhBkVHRzvFxo4dq/T09Dqt/3//939O7YqKCm3cuLHaeT169HBql5WVafPmzXWqQfL/8xAeHu4SMxgM9co5bNgwl3tG63u8uhMYGOgSq2/tteGN8/LU46uyfKfD+eCN7ZekwsJCp/ap21lb9957r0usujr9fV7Wx9atW9W3b1/t3LnT6f7hyy+/vNq5Dz74oMt9Lc8++6zHawQAAAAAAADOJFdeeaXLe89z58712noPP/ywS+yhhx6q8/u/Z4NT37MtLS31WO533nlH7dq1c4rdcccd2rVrV41z2O1V35NU23EAAADwrV27dikvL8/xfWKXXnqpGjZsqOPHj9c7d3Jyssu9IDt37lR+fn69c9fUn7+frD5O/U60PXv2eCQvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcLoLqn4IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOBsFRISovPPP98ptmbNGhUVFdU554rfVujiiy5WkyZNlJGRodVrVuvgwYPVzgsLC9N5556nnj17KiAgwBHv27evDmUd0pEjR+pcU114Y9/8vPhnHTh4QBddeJEaN27s0p9zLEerV63W9h3bHbEGDRroqiuvcrTLy8v1/fffq7i4WJJkNps19NqhCg4OrnLtc845R3FxcZr15SyVlJTUeRsAAAD+6ioqKnTo0CEdOnSoynGNGjWS0WiU2WyWyWRSUlKSzGazkpKSlJSUpOTkZEVGRvqoav+Kj49XfHy8OnfuXOmY/Px8ZWRkyGKxyGKxKD09XRaLRZmZmcrMzJTFYtHRo0d9WDUAAAAAAIB7ESHxTu2C0mMeyx0WFHNK7hyP5a7KqK5fq33jQU6xhxcaap3Hm/vmVLFhZl3X+RNHu8JeoVmbRiq/JLvauTkFe3SiKFMNwkySpC6J12mdZbrbsVEhTdS8YS9He9+xZfWsHAAAoGopKSkusdTU1HrlLCgocInFxMQoO7v6aydPqO02XXXVVU7tAwcOaOHChXVaOzk52eU+wN27d+vkyZPVzu3evbtTe/v27Y779urC38+DzWZziSUkJGj37t11znn33Xe7xNavX1/nfJUpLCx0icXExLgZ6R3ujuG0tLQ65zMajS73kFaW73Q4H7zxuiRJx48fd2qfc845+u677+qUq2PHjrrhhhtc4tUdj/4+L+vr2LFjmjNnjsaOHeuIJSQkVDknNjZWd9xxh1Nsy5Yt+v77771SIwAAAAAAAHCm6N27t0tsxYoVXlmra9euatu2rVMsPT1dn332mVfWOxOEhIQoLi7OKeap92pvueUWjRo1yin20UcfaebMmbXK8+fvwPDEOAAAAPjekiVLNGTIEElSUFCQhg4dqg8//LDeea+77jq3a/nShRdeWO8cLVq0cLmnZdu2bfXOCwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJwJgvxdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAf8479zyFh4c72jabTalpqfXKuW/fPu3bt0/xcfHKOZZT43lFRUVa/utyHTx4UNdee62Cgv77J3YCAwN1aZ9L9dXXX9Wrrtryxr6RpD179mjPnj2Kjo5Ww4YNFRYWpuKiYuWeyNWJEyecxgYGBurqwVcrNDTUEft1xa86dOiQJCkiIkKDBw1WcHCwJKm4uFgrV67U/v37VVJaoujoaHXt2lWdOnaSJDVu3FhX9rtS38//vt7bAQAAgKodOXJER44c0caNGysdExMTI5PJJJPJJKPRqOTkZKfHRqNR8fHxPqzaf6KiotS+fXu1b9++0jFFRUWyWCyyWq06ePCgrFarMjMzlZGRIYvFoszMTGVlZclut/uwcgAAAAAA8FcTHBDu1C4ut3ksd4AhyKndMLy5ru3wtkdy/7LvOeUWZXgkV2W8uW/+LMAQqBFdv1REcJwj9su+57Tn2OIa51iV/pb6t31OktQuob86NRmqLdnfOo0xyKAh7acpMOC/n8dW2Mu1OvMdD2wBAABA5VJSUpzaxcXF2rZtW71yZmZmusQ6dOig3bt31ytvTfXo0cOpXVJSoq1bt1Y6/pxzznFqr1mzps5rP/fccwoICHCKpabW7D7AUz+73Lx5c53rkPz/PBw5csQl1rFjR61atapO+a677jqde+65LvG0tLQ65auK1Wp1iXXp0qXe50ZNnXoMFxUVafv27R7LJ1V+XJ4O54M3XpckueS47LLL9PLLL9c6T0BAgN59913HvbR/Vt32+fu89ITc3FyndllZWZXj77nnHkVHRzvFnn/+eU+XBQAAAAAAAJxxunXr5hKrz3uyVenXr59L7Ouvv1ZFRYVX1jsT9OrVyyX2x3cq1EfHjh01bdo0p9jWrVt1zz33VDvXZnO+9+nP3z1RlYiIiCrzAAAAwH8++OADDRkyxNGeOHGiPvnkk2o/a69KRESEHnjgAbdr+VKzZs104YUX1vleIEkaOXKkS2zx4urv0S8vL3eJ/fk70wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAzQZC/CwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+EdYWJhSUlKcYitXrlRZWZlH8uccy6nTvIPpB7Xo50Ua0H+AI9asWTPFNYzTsePHPFJbdby9byTJZrPJZrNVOebSPpeqSZMmjva+ffu0bt06R/vcnucqIiJCklRRUaGvvv5KWVlZjv78/HwdOnRIxUXF6tGjhyTpnHPO0Zrf1+jIkSMe2xYAAADUTV5enrZt26Zt27ZVOiYsLExms1lGo1Fms1lJSUlKSkpSs2bNZDQalZSUpMTERBkMBh9W7h9hYWFq1aqVWrVqpd69e7sdU1ZWpqysLKWnp8tischisSg9PV1Wq1UZGRnKzMzUoUOHVFpa6uPqAQAAAADAWctu91rqmNCmusA8ziO5fs98X7lFGR7JVWNe2jf92zyvZrEXOtr7ji3Xoj3/qlWO39JfV4+km9Uosq0kaWTX2Vqb+ZF2Hv1BRWV5ahjeTOebbldy7AWOOb8eeFXHCw94ZBsAAAAqc+p9a5s3b1Z5eXm9cm7YsMEl1q9fP82bN69O+UJCQpSQkCCr1Vqj8d27d3dqb9mypcp78Ro0aODUPnHiRO2LlHTxxRdrxIgRLvH169dXOzcuLk7R0dFOsfT09DrV8Qd/Pw+bN292iQ0YMEAffPBBrddOSEjQ1KlTXeL5+fnavXt3rfNVZ9OmTS6xq666SrNmzapTvksvvVSbN29WTk7N7nM99Riu73nZs2dPl1hqaqrbsafD+eCN1yVJyszMdGpfddVVMpvNysio3e+u06ZN08UXX+wSP3HihPbt21flXH+el02bNtV9992n5s2ba/jw4XVaT5JatWrl1K7qtSo8PFzjx493iu3fv7/O5xIAAAAAAABwNmndurVT22KxeO3/xz/1fWdJWrZsmVfW8paWLVvq3nvv1eOPP678/Px65xs3zvUeqfruk4iICH311VcKDw93xAoKCjRs2DAVFhZWO//YMefvtvjz9z5U5dRxx48fr9E8AAAAT8nJyXH6TJ7rkf9ZsGCBLBaLkpKSJP3394B7771Xr776ap1zPvLII2ratKlTbP369W7vSfC2f/7zn7r22mvrNDciIkJ33323U6yiokLz58+vdq67Y6xp06ZKS0urUy0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAPwT5uwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgH+kdE9RSEiIo338+HFt2brFjxX9z9atW9WzR081atTIEWvVupWOrT3mk/VPh33Tpk0bde/e3dG22Wz6YcEPTmM6derkeLxz105lZWW5zbXitxXq0qWLgoODJUldOnfR4iWLvVA1AAAAPK2oqEi7d+/W7t27Kx0TFBSkpk2bymw2y2QyyWg0qlmzZjIajTKZTDKbzUpMTHRcD57NgoKCZDKZZDKZKh1jt9uVnZ2tzMxMWa1Wpaeny2KxKDMzUxkZGbJarcrIyFBRUZEPKwcAAAAAAEBNtEsYoEuaP+Ro55cc0cxN18uuilrlKSk/qU/Thmhsz58VE2ZUgCFQ55vH6nzzWLfjtx/+Xj/ufqRetQMAAFQnOjparVu3doqlpqbWO+/WrVtltVplNBodsZtvvllPPvmkjhw5Uut8b775poYNG6bx48fr008/rXJsXbbp1M/p2rRpU+saW7Vqpblz58pgMLj01WSfxsXFucRCQ0NrXcef+fN5kKTNmzcrPz9fUVFRjtjgwYNlNBpltVprvG5YWJi+++47NW3a1KUvLS2txnlqY+PGjcrJyVF8fLwjNmLECD366KO1ql36732X8+fPV1lZmV566SW9+uqrKigoqHS8N87LlJQUp3ZOTo4yMzPdjvX3+eCt1yV3AgIC9O6772rgwIE1Hj9lyhSNGzfObX9Njkd/nJdNmzbV888/rxEjRjju4/joo4+0cOHCWq8XFhamyy+/3Cm2cePGSsePGTNGCQkJTrGXXnpJFRW1+50aAAAAAAAAONtERESoQYMGTrHs7Gyvrde8eXOX2M6dO722nid16NBBkyZN0vXXX6/AwEBFRkbq9ttvr1fOa6+9VsOGDXOKlZWVaf78+fXK+9Zbb6l9+/ZOsbvuukvbt2+v0fxTx3Xu3LlG804dt23bthrNAwAA8JQxY8b4u4TTVkVFhaZMmaJXXnnFEXvhhRe0ceNGLVmypNb5rrnmGj3yiOs95pMnT65XnXU1ZMgQ3Xzzzfr4449rPfedd95RYmKiU+z7779XRkZGtXPd3ffSp08f/fDDD25GAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKenAH8XAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADwvcDAQHXr1s0ptub3NbLb7f4pyI1du3Y5tZs0buKTdU+HfRMTE6P+V/V3tCsqKvT999+rqKjIEUtISFB4eLijvWfPnkrzlZaWKiMjw9FOSkrycMUAAADwp7KyMmVkZGjlypWaPXu2pk6dqvvvv1/Dhw/XxRdfrOTkZIWGhqpp06Y699xzNWTIEN1777168cUXtWzZMu3evdvpWvNsZzAYlJiYqJ49e+rqq6/WPffco+eff16fffaZli5dql27dqmwsFA5OTnavHmzvv/+e7333nt64okndMstt+jKK69Uhw4dFBMT4+9NAQAAAAAA+EuJCU3S8M6fyWAwSJLsdru+3HSjbMWH6pTv8MntenPN+dqS/W2lY0rKTuqn3U/ok7RrVGEvq9M6AAAANdWtWzfHtc4fUlNT653Xbrfrs88+c4pFRkbqo48+UmBgYI3zGAwGvfrqqxo7dqxiY2P1ySefaN68eWrcuHGlc9xt0/r166tcZ+fOnU7tPn36qFOnTjWus0uXLlq0aJESEhLc9qelpVWbo7Cw0CV22WWX1bgGd/z5PEhSSUmJ5s+f7xQLDg7W9OnTa7x2kyZNtHjxYl1wwQVu+z1xvLpTXl6uWbNmOcVCQkL01VdfKTQ0tMZ52rVrpwULFigiIkIxMTF65plntHv3bjVs2LDSOd44L3v06FHjfP4+H7z1uvSHU+/NHTBggN59910FBwdXOa9jx45avHixxo8fL+m/99meqiZ1+uO8LC4u1nXXXee0jZ9++qnatm1b4/X+8K9//UuxsbFOsf/85z9uxwYFBWnChAlOsezs7Fq9BgAAAAAAAABnq+joaJfY8ePHvbaeu/8n6fDhw15brzItWrTQ/v37Xf674oor3I43GAz67rvvNHLkSMd7qGPHjtXLL7/s8l5yTV133XUunwFI0scff6zc3Nw65ZSk0aNHa/To0U6xTz/9VJ988kmNc6xdu9bp/7lr0aKFOnToUOWcnj17KjEx0dHOz8/Xhg0barwmAAAAaq6217N/mDp1qtP9SyEhIZo7d64GDRpUq/WHDx+uWbNmudxfsGDBArfXuL7y9ttva/jw4TUebzAY9Morr+jGG290itvtdj3zzDM1yrFq1SqXe0DGjBnjdG0MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnO6C/F0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMD32rRpo4iICEe7oKBA27dv92NFrnJycpzakZGRPlnX3/smICBAVw++WqGhoY7Yit9WyGK1OI2LjY11ap+6v06Vk5Ojli1bup0LAACAs5/dbldWVpaysrK0bt06t2Pi4+NlNBplNpuVlJQkk8mk5ORkGY1GmUwmmUwmxcTE+Lhy/4mLi1NcXJw6depU6ZiTJ08qPT1dFotFFotFGRkZjp+ZmZmyWq06cuSID6sGAAAAAADe9sbqc72W+9eDU/TrwSley1+Zj9MGeySPN/eNJOUVW/TULwkezXmiKFOfbfib4sJbqG3CVWoY1lwhQVEqKDmqrPwt2p3zk4rK8jy6JgAAQGVSUlJcYqmpqR7JPWXKFN15551On/cNGjRI3333ncaNG6f09PQq57dv315vvfWWLr30Uqd437591bBhQx0+fNjtvLps03fffad+/fo52gEBAZo7d64GDhyoXbt2VTovODhY//jHP/Tcc88pJCREkrR37161atXKMebAgQPKzc2tcn1Jys7OVkFBgdO9hN26ddPrr7+uRx55RCdPnqw2hzv+eh7+8Nprr2n48OFOsSuvvFJff/21br75ZuXn57udFxAQoJtvvlnPPPOMmjZtKknatWuXEhMTnbbFU8erOy+//LJuu+02hYWFOWIXXXSRli5dqjFjxmjr1q2Vzg0ICNAtt9yiV155RQ0aNHDq++abb3T8+PFK53r6vGzSpIljH/4hLS2t0vH+Ph+8+bokSZ9//rluvPFGp9jtt9+uPn366L333tOvv/4qi+W/988mJiaqW7duuuaaazRo0CAFBAQ45nz44YcaO3asU57169fXqAZfn5fHjh3T22+/rQceeMARa9y4sVauXKm7775bX375ZbU1R0VF6cknn3TKIUmHDh3SN99843bOyJEjZTabnWKvvPKKiouLq10PAAAAAAAAONv9+f/r/0NNPk+oqz+/1/2HNm3aqKioyKPrZGdnKzs7u9L+4OBgNW/e3CX+589H/sxut2vSpEmaNWuWU/yhhx5S37599eSTT2r+/PkqKyurtraePXvqkUce0dChQ136jh07pokTJ1abozJ/vG/7Zzt27NCdd95ZqzwlJSX68ssvNXr0aEfsqaee0t///vdK5/z73/92as+YMUMVFRW1WhcAAAA1U9vr2T9UVFTo1ltv1caNGx2x6Ohofffdd/ryyy81ZcoU/f7775XOv/jiizVhwgRdc801Ln02m0133HFHzTfCg3JychQfH6+wsDDNmjVLffv21RNPPKGsrKxK56SkpGjKlCnq06ePS997772ntWvX1mjt48ePa8mSJerbt68jFhcXp19++UW33367fv3119pvEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOBjQf4uAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgex07dHRqb9m6ReXl5X6qxr3CokKndnBwsE/W9fe+6dOnjxITEx3t/Qf26/fff3cZFxYW5tQuKiqqMu+f+0NCQhQQEKCKiop6VgsAAICzSU5OjnJycrR58+ZKx0RGRio5OVlJSUkyGo2OxyaTSWazWUajUY0aNfJh1f4VGRmp9u3bq3379pWOKS4uVmZmpqxWq9LT02W1WpWRkaGMjAzH4+zsbK7PAQAAAAAA/OhY4X6tznjH32UAAIC/uJSUFKd2eXl5lZ/d1cbhw4c1fvx4TZ8+3Sk+YMAA7dixQz/++KMWLlyojIwMHT16VJLUsGFDdezYUQMHDtTll18ug8HgNLesrEwjRozQzp07a7VNmzZtqrLW6dOn64knnlBCQoIj1qpVK23atEkzZszQDz/8oH379slmsykiIkLNmzdXnz59dP3118toNDrmrF27VkuXLtWECRMcsdTU1CrX/vO2/fLLL/q///s/p/i9996r2267TRs2bNCRI0dUWlrq1P/xxx9r/vz5leb11/Pwh1WrVmnOnDm69tprneJ/+9vf1LdvX82aNUtr166V1WpVUFCQEhMTde6552rQoEFO+9Zms+kf//iHfvzxR6c8Nd2/dXHw4EE9+uijeuWVV5ziF1xwgTZu3KiVK1fqxx9/VHp6uo4cOSJJatSokXr06KGhQ4cqOTnZJeeiRYv0wAMPVLmup8/LHj16uMSq2m/+Ph+8+bokSffcc48uvvhitWzZ0inerl07l+e6MhMmTHB7n29Nj0d/nJePPfaYBg0apLZt2zpi8fHxmjVrlp555hnNmzdPqampslgsOnnypIKDgxUdHa2WLVvqoosu0uDBgxUbG+uS9+GHH1ZhYaFLXJImTpzo1M7NzdU77/B7MAAAAAAAAFCZUz8D8LY1a9Z4POczzzyjxx9/3KM5v/zyS/Xt21djx451infv3l1z585VXl6eVq1apR07digjI0P5+fkqKipSRESEGjZsqPbt2+v8889XmzZt3OYvLCzU0KFDlZOTU6f6wsPD9dVXXykiIsIp57Bhw1RQUFDrfC+++KJGjBjh+K6Lv/3tb5o6daoefvhhFRcXO607ZcoUp8+WSkpKNHny5DptBwAAALxr06ZNstvtLp/3Dx8+XMOHD1d6erq2bNmiQ4cOKTc3Vw0bNlTTpk3VtWtXp/sx/qysrEzXXXedMjIyfLEJLh5//HE9/fTTio+PlySNHTtWN910k5YsWaKlS5fKarXq5MmTio+PV4sWLXTllVeqR48eLvtAktLS0nTffffVav3nnntOffv2dYqdc845Wr58uSwWi7Zv3668vDyX71T44IMPtHDhwtptLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOAFQf4uAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgW4GBgUpOTnaK7dixw0/VVC4gIMCpXV5e7vU1/b1vWrVqpR4pPRzt/Px8/fDDD27Hnrp/Kioqqsx96v4LCAiodg4AAABwqpMnT2r79u3avn17pWNCQ0OVlJQko9GoZs2ayWg0ymQyyWw2y2g0ymw2KzEx0eWa9mwVGhqqVq1aqVWrVpWOKSsrU1ZWltLT02W1WmWxWHTw4EFZrVZlZmYqMzNTVqtVpaWlPqwcAAAAAAAAAAAAvpSSkuLU3r59u4qKijyW/+OPP9Y555yjhx9+2CkeHh6ua6+9Vtdee22Nc504cUIjR47U/PnzqxxXl23Kz8/X2LFj9e2338pgMDjioaGhuvXWW3XrrbdWW9+GDRvUv39/ffbZZ07x9evXVzv3D//61780cOBApxokKSIiQhdddJHbOW+//Xa1ef3xPPzZmDFjlJKSombNmjnFY2NjNW7cOI0bN67aNa+55hqFhoY6xYuKiqr8HNkTpkyZog4dOui2225zigcGBqp3797q3bt3jXN98803uvHGG1VWVlbluFOP4W3btqm4uLjmRVeTT5JSU1MrHe/v88Hbr0t5eXm67LLLtHjxYrVu3bpWc202m8aOHasvv/xSM2bMcOorKCjQzp07a5zL1+dlYWGh+vXrp19//dXlvuXWrVvrwQcfrPF6f5g8ebLLc/yHa6+9Vuecc45TbNq0abLZbLVeBwAAAAAAAADuvPNOSdLYsWNd+mJiYnTVVVfpqquuqnXe3NxcDRs2TMuWLatzbdOmTVPHjh2dYvfee6+2bNlSp3zbt2/XI488osmTJzti48eP1+jRo7Vy5Url5OQoPj5evXr1UkxMjNPcCRMmaM+ePXVaFwAAAN43atQoTZ8+XSEhIS59ycnJLp/nVyU/P1/XXXedfvzxR0+WWCsWi0VXX321Fi5cqKioKEn/vb9kwIABGjBgQI3z/HGfSW3vD1myZIneeOMN3XvvvS59SUlJSkpKcjvvl19+qdU6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgLcE+bsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBvJTZJVGBgoKNdWFiow4cP+7Ei96KiopzaBQUFXl/Tn/smJiZGA/oPcLQrKio0f/58FRYWemYBg2fSAAAAANUpLi7Wvn37tG/fPq1YscLtmMDAQCUmJio5OVlGo1Emk8npsclkktFoVEhIiI+r94+goCDHdlfGbrcrOztbFotFFotFGRkZyszMdPxntVqVnp6uoqIiH1YOAAAAAAAAAAAATwgLC1P79u2dYqmpqR5fZ+LEiTp48KBeeeUVhYeH1ynHjz/+qLvuukv79++vclx9tmnu3LkaO3as3n77bQUHB9eqvk8//VR33nmnCgoK1KNHjzqtL0nr16/XTTfdpOnTpysoKKja8Xa7XevWratRbl8+D6c6duyYevfurZ9++knnnHNOreauW7dOo0aN0s6dO/XPf/7TqW/Tpk0qLy+vVb66GDNmjA4cOKB//etfNXpeTnXixAk9/PDDevfdd6sd6+4YTktLq/Waf9azZ0+ndn5+vvbs2VPlHH+dD756XUpPT1dKSopefPFFjRkzptptLCkp0cyZMzVp0iQdOnRIkpSSkuI0ZsOGDbLb7bWqw9fnZXp6unr27KlPPvlEAwYMqHZ8ZQoLC/XAAw/onXfeqXTMpEmTXOZMnTq1zmsCAAAAAAAA+GsrLy/X7bffrqVLl2ry5Mlq2rRpvXPOnz9ft99+u6xWa51zjBo1SrfccotTbObMmfrwww/rVdsrr7yihIQETZw40RGLjY3VwIEDK53z7LPP6vXXX6/XugAAAPCumTNnauvWrfr444/VrVu3Ouf57bffdMstt2j37t2eK66OVq5cqV69eumrr75SmzZtaj1/+vTp+sc//qH8/Pw6rT9+/Hjl5+dr4sSJMhj4wjMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACcWYL8XQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwLeMSUan9qGsQ36qpGpms9mpnWfL8/qa/to3AQEBGjxosMLCwhyxVatWKSMzo9I55eXlTu3AwMAq1wgKdP6TRRUVFXWoFAAAAPCM8vJyWSwWWSyWKsc1adJESUlJSkpKktlsdvw0mUwyGo0ym82KiIjwUdX+ZTAYlJiYqMTERPXo0aPScceOHZPValV6erosFosyMzOVkZEhq9WqjIwMZWZmKi/P+79fAQAAAAAAAAAAoOa6dOnicg/Y+vXrvbLW22+/rR9++EGTJk3SDTfcoOjo6GrnlJaWasGCBXr11Ve1dOnSGq1T32368MMPlZqaqsmTJ+vyyy+vcqzdbtfPP/+sZ599VsuWLZMkGY1GNWnSxGlcWlpajdeXpM8//1xr1qzRxIkTNWDAADVt2rTSsTt27KjV53C+eh7cycjIUPfu3fXEE0/orrvuUoMGDaocv2PHDr300kv65JNPHPcepqSkOI1JTU2tcz219cwzz+jrr7/WY489pqFDhyo8PLzaOVarVe+//77eeOMN5eTk1Ggdb5yXp37Wu2HDBtnt9mrn+eN88OXrks1m01133aWnnnpK119/vXr16qUWLVooLi5Odrtdx48f144dO7Rs2TLNnTtXhw8fdsyNjo5W27ZtnfLV9Xj09Xl55MgRDRw4UP369dPDDz+sSy+9tNr7gf+QmZmpL774Qq+88oqys7MrHde3b1/17NnTKfbBBx/o6NGjtaoVAAAAAAAAAE41c+ZMzZkzR8OHD9ett96qCy+8UEFBQdVP/P8KCws1e/ZsvfXWW/r999/rVUu7du30zjvvOMV27dql22+/vV55//DII49o3bp1evnll9WiRYtKx+3bt08PPfSQ5syZ45F1AQAA4F0bN25USkqKhg0bprvvvlu9e/eWwWCodl5FRYUWL16sN954Q999950PKq25jRs3qkuXLrrvvvt03333udwvcqry8nItXLhQzz77rFauXFmvte12uyZNmqSPP/5Y48eP1+WXX6527drVaJ8CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/lbzv8YHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgrxDWMc2pnZ2d7NH/jxo11/nnn62TBSS1ZsqROOaKiotSubTun2IEDBzxQXdW8vW8qc0nvS9S0aVNHOz09XatWr6pyTlFRkVM7IjxCNput0vHhEeGOx8XFxaqoqKhjtQAAAIDvZGdnKzs7W6mpqZWOiY2NVVJSkpKTk2U0GmU2m2UymWQ0GpWcnKykpCTFxsb6rmg/i4uLU1xcnDp16lTpmJMnTyo9PV1Wq1WZmZnKyMiQxWJxPLZarTpy5IgPqwYAAAAAAAAAAPhr+/3332UwGHy23sGDB3XHHXdo/Pjxuuiii3TuueeqVatWio2NVXh4uEpKSpSXl6e9e/dq06ZN+uWXX6q8P80dT2xTWlqa+vbtq9atW+uqq65S586dFRcXp7CwMNlsNmVlZWnjxo1atGiRDh065DTXarV6ZJ/u3r1bt912myQpMTFR8fHxatCggcu448eP1zq3L56HyhQVFWnSpEl65pln1K9fP11wwQUyGo2KjY1VcXGxjh07pi1btmjZsmXavHmzy/zrr79e119/vUdqqYsdO3Zo1KhRioqKUq9evdSjRw+1aNFCDRo0UFhYmAoKCnT8+HFt3bpVa9as0e+//17rNbxxXprN5jrP9fX54OvXJUnKysrS1KlTNXXq1BrP6d27twICApxia9asqXMN/jgvFy1apEWLFikhIUF9+vRRly5dZDKZFBMT4zie8/PzdeTIEW3btk0bNmzQpk2bapT7kUcecWqXlpbq5Zdfrle9AAAAAAAAwNkmPT3dp++HtmnTxmdrVWXXrl313u7CwkJ9/PHH+vjjjxUREaELLrhAbdu2VevWrRUXF6fIyEjHe6vHjx9Xbm6u9u3bpzVr1mjTpk0qKyvzyLbs3LlTUVFRHslVmW+++UZz585V79691a9fP5lMJsXGxur48eOyWCz66aeftGLFCpWXl3u1DgAAgDPNtm3bvHK97YnrWUmy2+2aPXu2Zs+ercaNG+uSSy5Rp06d1KxZM0VFRSksLExFRUXKy8vT/v37tWXLFi1fvlzHjh3zwFZ4R1FRkV544QW99NJL6tWrly644AK1a9dOsbGxCgwM1IkTJ2S1WrVhwwb9/PPPysnJ8ej6u3bt0t133y1Jio6OVqNGjdSwYUOFhoa6jN23b59H1wYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADqKsjfBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfCssPMypffLkSY/lvubqa9SmTRtJUkVFhfbs2aP09PRa5QgICNCA/gMUHBzsiBUWFiojI6PSOYGBgTIYDE6xsrKyWq0reXffVKZly5bq2bOn05rfz/++2nk5OTlO7UaNGyn7cHal4xslNKp0LgAAAHAmy83NVW5urrZu3VrpmPDwcCUnJ8toNMpkMslsNispKcnx02g0KjEx0YdV+1dkZKTat2+v9u3bVzqmuLhYFotFFotF6enpslqtysjIUGZmpiwWizIyMpSdna2KigofVg4AAAAAAAAAAABPKioq0pIlS7RkyRJ/l1KlPXv2aM+ePf4uQ1lZWcrKyvJ4Xn8+DwUFBZo3b57mzZvn87U9IT8/Xz/++KN+/PFHf5fiM6fL+XC66Nevn0vsl19+qXdef5yXR48e1TfffKNvvvnGI/l69uypvn37OsVmzJhR5T3ZAAAAAAAAAFBXBQUFZ8TnTvVRXl6upUuXaunSpf4uBQAAAF5w+PBhff311/r666/9XYpHVFRUaPny5Vq+fLnfarDZbLLZbH5bHwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKipIH8XAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADwrfCwcKd2UWGRx3Lb8m2OxwEBAbp2yLVatGiRtm3fVqP5kZGRGjhgoJo1a+YUX7lypcrKyiqdd/Xgq9WqVSun2ORXJtei8v/y5r5xJzo6WgP6D3C07Xa75v8wXwUFBdXOzc3Nlc1mU3R0tCSpXdt22rJli9uxERERSkpKcrQzMzPrWTkAAABwZiksLNTOnTu1c+fOSseEhITIaDQqKSlJZrPZ8dNkMsloNCo5OVlNmjRRUNBf48+BhoaGqmXLlmrZsmWlY8rKypSdna2DBw/KarXKYrGoTds2Ki8vV74tX7Z8m/Lz81VRUeHDygEAAAAAAAAAAAAAfwWBgYG6/vrrnWK7d++WxWLxU0Wnl0mTJjm17Xa7XnjhBT9VAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJyegvxdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAt4KCnP90TUlpicdyr1ixQi2at1DDhg0lScHBwRo4cKBSeqRoy5YtysjI0PHjx1VRUeGYExwcrMTERLVt01YdO3ZUSEiIU86MjAxt2LjBYzVWxZv75lQGg0GDBw1WeHi4I7Z6zWqlp6fXOMeGDRvUu3dvSVKLFi3Upk0b7d6922XcFX2vUGBgoCSpoqLCZ/sTAAAAOJOUlJTowIEDOnDgQKVjAgIClJiYKLPZLKPRKJPJJLPZrKSkJMfPpKQkhYaG+q5wPwoKCnJsc1VOnjwpW75N+bZ82Ww25ef/96ct/3+Py8rKfFQ1AAAAAAAAAAAAAOBsMGTIECUmJjrF5s2b56dqTi/nnHOOhgwZ4hSbM2eOdu7c6Z+CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/kICAgLUsGFDxcfHu+3ftWuXjysCAABnkj+uJWJjYxUYGOh2DNcTAAAAAAAAnhXk7wIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP5lt9s9lqukpETffPuNhv19mBo0aOCIJzZJVGKTRMd6JSUlKi8vV3BwsIKDgyvNl5WdpTlz53i0xtrw5rq9e/eW0Wh0tDMyM7Ry5cpa5UhNS1XHjh0VFxcnSRo8aLC2bNmiffv3qaSkRDExMerSuYvTOuvXr1deXp5nNgIAAAD4i6moqJDVapXVaq1yXKNGjWQ0GmU2m2UymZSUlCSz2aykpCQlJSUpOTlZkZGRPqra/yIjI/+7vU0qH1NYWKiTJ08qLy9P+SfzZbPZZLPZlJ+f7/hZXFzsu6IBAAAAAAAAAAAAAF7VuHFjHT58uE5zQ0JC9OKLLzrF7Ha73nnnHU+UdsabOHGiDAaDU+y5557zUzUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABnt3POOUeDBw9Wnz59dMEFFyguLs7lb0n9WWBgoCoqKnxYoXetWrXKbfzCCy/0Sx7gdDFt2jSlpKS4xO+8805t2LDB9wUBOG3V9lpCOvuuJ4D64loSOP2diedpfa/pb731Vo0dO9ZtH78XAAAAnH6C/F0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAODskpubq89nfK7LLr1MHTp0cOk3GAwKDQ2tMofdbldqaqqW/7pc5eXl3irVb1q0aKFze57raBcUFOj777+X3W6vVZ7S0lLNmzdPw4YNU1RUlAICAtSlSxd16dLF7fi9e/fq1xW/1qt2AAAAANU7cuSIjhw5oo0bN1Y6JiYmRiaTSSaTSUajUcnJyU6PjUaj4uPjfVi1f4WHhys8PFwJCQmVjiktLVVeXp7y8/OVn5+vPNt/H9tsnY/IyQABGRRJREFUNsfPwsJCH1YNAAAAAAAAAAAAAKitqKgoPfvss0pOTta1115bpxxvvPGGWrVq5RT78ccftXfvXk+UeEYzm80aMWKEU+znn3/W+vXr/VQRAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABA/QQHB6tDhw5q06aNGjRooAYNGigmJkYBAQHKz8/XiRMndOLECWVmZmrjxo2y2Wz+LhkAAL8xGAyKjo5222ez2WS3231c0dmtS5cu+ve//60hQ4bIYDD4uxy/ueCCC06rPMDpokOHDm6P65iYGD9UA3/i32dUhmsJwHO4lgROf2fieVrfa3qTyVTpdvN7AQAAwOknyN8FAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADOPoWFhfphwQ9at36dUrqnqFWrVgoPD692XklJiXbs3KH169crJyfHB5X6XlRUlAYOGOj4A892u10/LPhBJ0+erFO+nGM5mjFzhi677DK1bdPW7ZjS0lL9/vvvWr1mNX9gHAAAADhN5OXladu2bdq2bVulY8LCwmQ2m2U0GmU2m5WUlCSTyaTk5GQZjUYlJSUpMTHR8fvF2S44OFjx8fGKj4+vdExZWZny8/OVn58vm80mW75NNptN+bZ85Z/MV15engoKCvjdCAAAAAAAAAAAAAD84Pzzz9c333yjpKQkSdKUKVP0wAMP1Hh+cHCwXnnlFd1+++1O8ZKSklrlOZtNmDBBwcHBTrHnnnvOT9UAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIC/mgkTJiguLs4ptnPnTn388cc+r2X8+PFKTEx0iT/33HOy2WxVzh03bpyaNWvmEi8tLdUTTzzhsRrrYtCgQbr44otd4haLRW+++WaVc909P5I0a9Ysbdy4sda1VJavLioqKlRQUKDCwkLl5OQoPT1dBw4c0P79+z2Sv7Y8va/q6uGHH1ZsbKxTzF/nlKd56vgpLy9XUVGR8vPzdfjwYVksFu3cuVNZWVkeqFIyGo269957PZLLGzIzMzVt2jRHOyYmRhMnTpTBYHAZa7fb9fzzz1f7Guhpl156qa666iq3fStWrND8+fN9Wo/kuePPbrfLZrPpxIkTOnHihHJzc7V9+3bt27fPA1W6d6acO55w/vnna/jw4brsssvUsWNHl7/HUBm73a79+/dr9erVmj17thYsWKCSkhIvVwsAwOmjRYsW2rt3r9u+du3aadeuXT6u6Ow1atQoffjhhwoJCfF3KQCA0xz/PsMdriUAAAAAAABOL0H+LgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4Fufz/jcZ2sdPnxYPy78UQaDQY0bNVZ8fLwaxDZQSEiIgoODVVZapqKiIhUUFCgrO0tHjhyR3W6v9Tpz5s7xSL2+2Df5+fma9tY0j+a02Wz6z3/+owYNGqh58+ZqENNAwcHBKiws1NGcozpw4IBKSko8uiYAAAAA7ysqKtLu3bu1e/fuSscEBQXJaDTKZDLJZDLJaDSqWbNmjpjZbFZiYqKCg4N9WLn/BAUFKTY2VrGxsZWOqaio0MmTJ2Wz2WTLtyk/P1+2vP//80+xiooK3xUOAAAAAAAAAAAAAH8B6enpiomJcbTvv/9+de3aVZMmTdKaNWsqnRcaGqphw4bp4YcfVqdOnVz6n3/+ee3YscMrNZ9pCgsL9eabbzrax48f1y+//OLHigAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwF/JXXfdpebNmzvF7Ha70tPTtWTJEp/WMmbMGLffbf3GG2/IZrNVObdhw4aaOHGi276ff/5Zy5cv90iNdfHKK6+obdu2LvGnnnqq2rnunh9J2rx5szZu3FjrWirL50knTpzQunXrtGTJEs2dO1fbtm3z6np/8PS+qovu3bvrhRdecIkXFBRozpw5OnHihE/q8BZvHz9Hjx7Vb7/9poULF2ru3Lk6dOhQnfIkJiZW+npwOli3bp2mTZvmaOfl5SkiIkLjx493O95kMummm27yVXlKTEzU119/rfj4eJe+o0ePaurUqT6r5c+8ffwdP35c69ev16pVq/Tpp59qz549Hsvtq3PnzjvvrPN5Ux+hoaG65557dO+996pZs2Z1ymEwGNSyZUu1bNlSI0aMUF5enmbOnKmnn35aVqvVwxUDAIC/qrvuusvpWhwAAKA2uJYAAAAAAAA4/QT5uwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwNnPbrcr+3C2sg9n+7uUs9qJEye0ceNGf5cBAAAAwIfKysqUnp6u9PT0SscYDAY1adJEJpNJSUlJMpvNTo+NRqPMZrPCwsJ8WLn/BAQEKDo6WtHR0VWOO3nypPLz82Wz2WSz2f77OP9Pj202lZWV+ahqAAAAAAAAAAAAADjzHTp0SHfccYdmzpzpiF1++eVavXq1LBaL0tLSdOjQIRUUFCg0NFQNGzZU8+bNlZKSouDgYLc5Z8yYoSeffNJXm3Dae/jhh/1dAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgBODwaBPP/1UnTt31vHjx/1dTo188sknevrppxUYGOjSN3r0aC1fvtwPVUnnnXee2rZt6xK32+2aPn26HyryvgYNGqhv377q27evnn32WW3btk2vv/66Pv30UxUWFvq7PK8aN26c23hERIRGjRqladOm+biiM0tCQoKuueYaXXPNNXrzzTc1f/58vfzyy/r111/9XZrX/fOf/1Tfvn3VqVMnl74bb7xR33//vWbPnu2TWj755BPFx8e77bv11luVnZ3tkzp8rWHDhrriiit0xRVX6PHHH9eyZcv07rvv6osvvvB3adX649wZPHiwz8+bMWPG6Mknn5TRaPRo3piYGI0bN04333yz3nrrLf373/+WzWbz6BoAAOCvpVu3bnr11VdrNDY3N9e7xQAAgDNOba4lCgoKVFJS4uWKAAAAAAAAIElB/i4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgPfY7XZlZWUpKytL69atq3RcfHy8jEajzGazkpKSZDKZlJycLKPRKJPJJJPJpJiYGB9W7l+RkZGKjIxUkyZNKh1TVFSk/Px85eXlKf9kvmw2m2w2m/Lz8x0/i4uLfVg1AAAAAAAAAAAAAJzevvjiCyUmJmrKlClO8aSkJCUlJdUq1/Tp0zV27FjZ7XZPlggAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPS0pK0nvvvadhw4b5u5QasVqtWrhwoQYOHOjSN2zYMN19990qKiryeV2jR492G1+yZIkOHDjg22L8pEOHDnrnnXf01FNP6bHHHtMHH3xwVn5feWRkpEaMGFFp/5133qlp06b5sKIzW0BAgAYPHqzBgwfru+++07hx42S1Wv1dlteUlJTohhtu0Lp16xQaGurS/+6772rVqlXKyMjwah333nuvrrzySrd97777rr777juvrn866dOnj/r06aO77rpLt912m3bt2uXvkqrly/OmUaNG+vTTT9W/f3+v5P9DWFiYHnjgAV177bUaPny41q5d69X1AADA2Wv69OkKCQlx25eVlaXXXntNCxYs0LZt21RaWurj6gAANXXRRRfp2WefdYmvWLFCjz/+uB8qwl8F1xL4K+A1FgAAAABwJgrydwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/C8nJ0c5OTnavHlzpWMiIyOVnJyspKQkGY1Gx2OTySSz2azWrVsrMjLSh1X7V1hYmMLCwpSQkFDpmNLSUuXl5Sk/P1/5+fmy2Wyy5dtks9kcsYKCAh9WDQAAAAAAAAAAAAD+9eqrr2rChAlq2rRpneZbLBbdfffdmjdvnocrAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgLf8/e9/1+jRo/XJJ5/4u5Qa+fDDDzVw4ECXeHR0tIYMGaJZs2b5tJ7g4GBdf/31bvs+/PBDn9ZyOmjcuLHee+89jRkzRsOHD9eBAwf8XZJHjRgxQlFRUZX2d+zYURdddJFWrlzpw6rODoMHD1avXr10/fXX66effvJ3OV6zZcsWPfzww5o6dapLX2xsrD777DNddtllstvtXlm/Q4cOeumll9z27dy5U/fff79X1j3d9erVS5s2bdI///lPvf766/4up8a8ed6cd955mjt3bp3/hkVdtGjRQr/99pvuu+8+vfXWWz5bFwAAnB0uu+wydevWzW3f/PnzNXz4cJ08edK3RQEA6iQhIUGXXnqpSzw3N9fnteCvg2sJ/FXwGgsAAAAAOBMF+bsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGeGkydPavv27dq+fbvb/kmPTlJCQoKioqIUHRWt6Jjo/z2O/v+Po6MVGRkpg8Hg4+r9Izg4WPHx8YqPj690TFlZmQ5lHdK6deu0d+9eH1YHAAAAAAAAAAAAAP7RunVr3XbbbRo9erRSUlKq/Qz5xIkTWrlypT744APNmzdP5eXlPqoUAAAAAAAAAAAAAADg9HDw4EF9/vnnTrHMzEw/VQMAAAAAAAAAAAAAAAAAAAAAAAAAAFA3b775ppYvX679+/f7u5Rqfffddzp69KgSEhJc+kaPHq1Zs2b5tJ5BgwYpLi7OJZ6bm6tvv/3Wp7VU5+jRo8rPz6/VnMDAQIWHhysmJkYhISE1nnfeeedpw4YNuuGGG7RgwYLalnraGjduXI3GrFy50gfV+Nb+/fuVk5NTo7EGg0GhoaGKjo5WTEyMGjZsWKN5DRs21Pz583XDDTfo66+/rnJsQUGB1q1bV6O8Va3XqlUrl3hZWZk2bNhQr9yV/c15SXrttdc0cOBAXXnllS59ffr00YQJE/TSSy/Va313goOD9cUXXygsLMylr7S0VCNGjFBhYaHH1/WE2hx/khQQEKDIyEjFxMQoLi5OoaGh1c4JDQ3Va6+9piZNmujRRx+tT7lOvH3u1Oa8qakLL7xQCxcuVHR0dJXjSkpKtHTpUi1dulQbN27U/v37dezYMRUUFKiiokLh4eGKjo5WcnKy2rdvr169eunKK69Uo0aNKs0ZHBysadOmKTw8XK+88opHtgcAAPw13HPPPW7j27Zt09/+9jcVFxf7uCIAAHAm4VoCAIC/lqVLl+pf//qXJKlz5876+9//7ueKAAAAUJUgfxcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4OxRXl6uEydO6MSJE5LF/RiDwaDIyEjFxMQoKjJKUdFRiomOUVTUfx9HR0UrKipKgYGBvi3eT4KCgmQ2mWU2mZWdna05c+coPz/f32UBAAAAAAAAAAAAgNcUFBTojTfe0BtvvKGEhAR16tRJLVq0UExMjEJDQ1VUVKTjx48rNzdXu3bt0s6dO/1dMgAAAAAAAAAAAAAAgF+tWbNGa9as8XcZAAAAAAAAAAAAAAAAAAAAAAAAAAAA9RIVFaUZM2aoV69eqqio8Hc5VSotLdVnn32m+++/36WvX79+SkxMVFZWls/qGT16tNv4zJkzVVxc7LM6amL8+PGaOXNmnec3btxY7dq1U48ePXTFFVfoiiuuUGhoaKXjGzRooHnz5unGG2/Ul19+Wed1Txc9evRQSkpKteOGDRum8ePH6/jx4z6oyncee+yxOh8/DRo0UMeOHXXuuedq6NCh6tWrlwICAtyODQoK0owZM2SxWLRq1apKc+7YsUPnnntuner5w9VXX6158+a5xHNzc+uduzqjR4/W5s2blZCQ4NL3zDPP6Oeff1ZqaqpH13zuuefUpUsXt32PPfaYx9fzpPocfwEBAWrbtq26deumwYMHa8iQIYqIiKh0/KRJk5Senq533323ruU68cW5U9PzpibOO+88/fTTT4qKiqp0jNVq1UsvvaRPP/20yte6kydP6ujRo9q/f7+WLVumd955R4GBgerfv78mTpyoXr16VTp38uTJqqio0Kuvvlqv7QEA4HRSVFSkFStWuO0rLCz0cTVnn8suu8xt/JFHHjntfj8HAJw++PcZf+BaAgCAv5bly5dr+fLlkqThw4fr73//u58rAgAAQFWC/F0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgL8Wu92u/Px85efnVzkuIiJC0VHRioqOUnR0tKKi/vszOup/j4ODg31UtW80adJEN9xwg775+hsdO37M3+UAAAAAAAAAAAAAgNcdPXpUS5cu1dKlS/1dCgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALzswgsv1GOPPaannnrK36VU68MPP9T999/vEg8MDNSIESM0ZcoUn9QRHx+vgQMHuu378MMPfVKDLx0+fFiHDx/Wr7/+qqlTpyo6Olo33XSTHnzwQbVo0cLtnODgYM2cOVM2m00//PCDjyv2rHHjxtVoXFhYmG666Sa99tprXq7ozHHixAmtXLlSK1eu1GuvvSaz2aynnnpKN910kwICAlzGh4SEaMaMGerUqZMKCgr8ULH3ZWVl6bbbbtO8efNc+v44b7p3767CwkKPrHfZZZfpwQcfdNu3bNkyvfzyyx5Z53RUUVGhHTt2aMeOHZo1a5YiIyM1fvx4Pfroo4qIiHA7Z+rUqVq6dKl27tzp42qduTt3Dhw44LXzJi4uTl9//bWioqLc9peXl+ull17Sk08+qeLi4jqtUV5ervnz52v+/Pm65ppr9M477ygxMdHt2JdffllpaWn83QwAwFnDarWqd+/e/i7jrNShQwc1bNjQJX7s2DF9//33fqgIAHCm4N9nSFxLAADwVxcdHe3UrutnIAAAAPAe1ztlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOA0UFBQoOzD2dq7d682bNigFStWaMGCBZr91Wx9NP0jvfb6a3rjzTc0/ePp+ubbb7Rw4UKtXLlSmzdv1r79+3T06FEVFRX5ezNqrUFMA91www1KTEz0dykAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHjUE088ofPPP9/fZVRr69atWrt2rdu+m2++2Wd13HDDDQoODnaJb9q0SampqT6rw19sNpumTZumc845RxMnTlRxcbHbcQEBAfryyy/VqVMnH1foOVFRUbrhhhtc4vv373c7/s477/R2SWe0jIwM3XLLLbrsssuUm5vrdkyLFi103333+bQuX/vPf/6j9957z21fu3btNGXKFI+sExsbq08//VQGg8GlLzc3V6NGjZLdbvfIWmeCkydP6rnnnlOHDh20Y8cOt2PCwsI0efJkH1dWvYyMDK+eN59//rnMZrPbvuPHj+uKK67QpEmTKn29r6158+apS5cuWr16tdv+wMBAffHFF2rcuLFH1gMAAGevDh06uI3//vvvqqio8HE1AADgTMO1BAAAf20tW7Z0aufl5fmpEgAAAFQmwN8FAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBdFRcXKycnR/v379fmLZu1ctVKLfxpob799lt9/MnHenPam5r62lR99NFHmv3VbP2w4Af9uuJXpW1I0969e5Wdna2TJ0/6ezNchIeHa/h1w9WieQt/lwIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMcEBgZqxowZioyM9Hcp1frggw/cxjt37qwuXbr4pIbRo0e7jVdW29mqpKREL774oi688EKlp6e7HRMVFaWZM2cqODjYx9V5xsiRI92eF4888og2bdrkEm/Xrp0uueQSX5R2Rlu+fLl69+5d6d8zv++++xQUFOTjqnzrvvvu065du9z2jRs3ToMGDar3Gu+++65MJpPbvjvuuEOZmZn1XuNMdPDgQV1yySXauXOn2/5Bgwapc+fOPq6qet46b0aNGqUBAwa47Tt+/Lj69OmjpUuX1jpvdY4cOaLLLrtMv/76q9v+xMRETZkyxePrAgCAs0vDhg3dxvfv3+/jSgAAwJmIawkAAP66GjRooJEjRzraFRUV2rdvnx8rAgAAgDsB/i4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALyprKxMx44fU3p6urZt26Y1a9Zo8eLFmjN3jj77/DO9/c7benXqq3rv/ff0xRdf6Pvvv9fSZUu1PnW9du3aJavVKpvNpoqKCp/WHRwcrCFDhqhD+w4+XRcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG9q1aqVXn/9dX+XUa1Zs2apsLDQbd/o0aO9vn779u3Vs2dPl3hJSYlmzJjh9fVPR2lpabr44ou1d+9et/2dO3fWY4895uOqPGPcuHEusWPHjmnOnDn64IMPajwHrrZs2aJJkya57WvUqJGuvPJKH1fkW4WFhRoxYoRKS0vd9n/00Udq3LhxnfOPGjVK1113ndu+Tz/9VLNnz65z7rPBkSNHNGbMmEr7ffHvSV14+rwJCwvTc88957avrKxMV199tTZv3lzrOmuqqKhIgwYN0u7du932jxgxQj169PDa+gAA4MwXFxfnNp6Xl+fjSgAAwJmIawkAAP6a4uPjNX/+fCUnJztiP//8s4qLi/1YFQAAANwJ8HcBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOBv5eXlysvLk8Vq0Y6dO7Ru3Tr98ssv+s93/9HML2bq3ffe1atTX9U7776jGTNnaN68eVq8ZLF+X/u7tm/frszMTOXm5qqsrMyjdQUGBmrAgAHq2aOnR/MCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOALixYtchu/9dZbNXToUB9XUzt5eXn6+uuv3faNHDlSAQEBXl1/9OjRbuNz587VsWPHvLr26SwzM1MDBgzQ8ePH3fY/9NBDSkxM9HFV9XPuueeqW7duLvEZM2aopKREn3/+uYqLi136//a3vyk+Pt4HFZ753nzzTR05csRtX79+/Xxcje+tX79ejz/+uNu+Ro0a6ZNPPqlT3mbNmmnatGlu+/bv36+77767TnnPNitWrNB//vMft339+/f3cTU158nz5h//+IfMZrPbvscff1wrVqyodX21lZeXp+HDh6u0tNSlz2AwaPLkyV6vAQAAnLlCQ0Pdxt1dWwAAAJyKawkAAP56unbtqrVr1+riiy92xEpLSzVp0iQ/VgUAAIDKePduUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4S9jtduXn5+vQoUPavWe30tLStHz5cs3/Yb5mfTlLH3z4gaa+NlXT3pqmTz79RN/O+VaLfl6kVatXacvWLTp48KBycnJUWlpaq3UNBoMuvfRS9enTx0tbBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAdzz44IPatWuX2773339fTZs29XFFtfPhhx+6jTdp0kT9+vXz2roGg0GjRo2qVU1/Jbt379a4cePc9kVEROixxx7zcUX1U9m2fPDBB5Kk48ePa+7cuS79ISEhuvnmm71Y2dmjoqJCc+bMcdvXvXt3H1fjHy+99JKWLVvmtq9///66++67a5XPYDDo888/V0xMjEtfeXm5Ro4cqfz8/DrVejb66quv3MY7dOjgdh+eDjx13gQEBOjee+9127d161a9/PLLdaqvLtLS0vT666+77bv00kvVqVMnn9UCAAAAAAAAAADOTn/729+0atUqtWjRwhErKyvTqFGjtH79ej9WBgAAgMoE+LsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADibFBYW6siRI9q3b582btyo3377TT/++KO++vorTf94ul57/TW9/sbrmv7xdB04cKDGec/tea4GDBiggAD+LC0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4Mxw8uRJjRgxQqWlpS59cXFx+vTTT/1QVc0tW7ZMe/fudds3evRor617+eWXKykpySWekZGhRYsWeW3dM8ns2bO1YMECt32jR49WVFSUjyuqm+joaF1//fUu8XXr1mnTpk2O9vvvv+92/h133OG12s4269evdxtv1aqVjyvxD7vdrlGjRik3N9dt/+TJk9WhQ4ca55s4caJ69erltu+ZZ57RqlWr6lLmWauy126DwaDWrVv7uJqa88R5079/f5lMJrd9//znP1VeXl6n2urqqaeeUl5entu+22+/3ae11EdISIgSEhLUqFEjRURE+LsctwICAhQbG3ta1whnPGfOzoTzrL4MBoOio6PVuHFjJSQkKCgoyN8lnTY4HzwjMjJSjRs3PmN+PwO8ISIiQo0aNVJMTIwMBoO/yzlt/PH6EBsbq8DAQH+XU6U/nsPo6GieQy8JDw9Xo0aNFB8fz/WIl5xJ59ypuJ44e52Jx+Ufvz9FR0d7bY2wsDDHtQN863R/veH31LPPmfg6eKbyxzX9vn37nJ7XnJwcDRgwQLNnz/bKen+F9zIBAAC8jXcmAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDHSkpKlJOTo2/nfKsB/Qeoffv2NZrXsUNHhYeH6z//+Y/Kysq8XCUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPW3fv16/etf/9Jzzz3n0nfFFVfovvvu09SpU31fWA199NFHevbZZ13iQ4YMUXR0tGw2m8fXHD16tNv4xx9/LLvd7vH1zlSPPvqoBgwY4BKPiorSDTfcoPfff98PVdXOqFGjFBER4RL/4IMPnNqLFy/WgQMH1Lx5c6d4mzZtdPnll2vJkiXeLPOskJWV5TbeoEEDH1fiP5mZmbrjjjv05ZdfuvSFhYVp5syZOu+881RSUlJlnpSUFD355JNu+1avXq2nn37aI/WeTbKzs1VWVqagoCCXvqZNm/qhoprxxHkzZswYt/EtW7bohx9+qFNd9ZGXl6d3331XEyZMcOm78cYb9dBDD1V7DvjaRRddpL59++q8885Tt27dlJCQoLCwMKcx5eXlOnTokLZu3aq0tDTNnz9fK1euVEVFhU9qDA8P14ABA3TllVeqa9eu6tChg2JiYlxqzMjI0ObNm7Vq1SrNnTtX27dv91gNKSkpLjGr1VrpcSz995qhe/fuat26tWJiYhQdHa2AgABH/+TJk1VQUOA0p1mzZoqPj3fJdfToUaWnp9djCyqXkJCg5ORkl/iRI0eUkZFRp5xn+nOWkpJSo+erps6E86y+QkND1bdvX/Xv319dunRRx44dFR8fL4PB4DTOZrPp2LFj2rhxo5YvX65ly5Zp3bp1Hq3FV+drTZ0O54Mnudu/kpSamlrvPFU9T40aNdKwYcN0+eWXq3v37mrWrJkCAwMd/SUlJTp69Ki2b9+uRYsW6aefflJaWlqtavKmxo0by2QyVdqflJTkNm40Givd55Wp6rlo2rSp2+vD6s6RunBXt91uP62eF3+r7XkQHx+voUOHql+/furWrZtatmzpdB7Y7XYdOXJEmzdv1tq1azV37lytWbPG73VL3n2d7dq1q6655hqdd9556tKli5KSkpxyS/+9Tt+2bZs2bdqkn376SQsWLKjzevWRnJysoUOH6pJLLlHXrl1dXsvsdrsOHjyoTZs2adGiRZozZ44sFovX6vHVa4IvXw969uypwYMHq0ePHurcubOSkpKc9rEknTx5Utu3b9f69ev1ww8/aMGCBSotLa3VOomJiTIajZX2t27d2m28YcOGtX5dLykp0ZYtW6oc46l/n2vidDrn/krXE768lpCqP3b4t8C92uwXg8GgK664QsOHD9eFF16odu3aufybkJmZqQ0bNmjJkiWaPXu2rFZrnWoaOXKkLrroInXp0sXp84I/jvktW7ZowYIF+uGHH7Rr165ar+Fpp9trbF0kJCRoyJAhjt+RT71u8/frzdnwe2qnTp0UEhLiEs/IyNCRI0fqnb9BgwZq1aqVS3zDhg0eea+mbdu2ioqKcolv3bpVxcXFtc53urwOSqffvxGedrpc06elpenBBx/UG2+8od9//13Dhg3z2PvHf4X3MgEAAPzB9Y4eAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBPVFRUaP4P81VQUKAePXrUaE7LFi01/Lrh+ubbb1RUVOTlCgEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqL8XXnhBAwYMUO/evd32LV68WJs3b/ZDZdX75JNP9PTTTysgIMApHh4err///e+aPn26R9eLjIzU0KFDXeJ2u93ja53p0tLS9Ouvv7o9rv72t7/p/fff90NVtTNu3DiXWGFhob744guX+EcffaSnnnrKbY4lS5Z4pb6zyYkTJ9zGw8PDfVyJf82ePVuDBg3SjTfe6NLXtWtXPffcc3rooYcqnR8eHq6ZM2cqODjYpc9ms2nkyJEqLy/3aM1ni6NHjyoxMdElHhkZ6Ydqaqa+501gYKD69evnts+fr9Hvv/++JkyY4BKPjY3VRRddpKVLl/q+qFOEhITo7rvv1h133KF27dpVOz4wMFAmk0kmk0lXXXWVJk6cqCNHjujtt9/WG2+8oaNHj3qlzmbNmumRRx7Rjf+PvfuOjqrq+jj+mzTSINI70pEqBESa0pHekSIYQAVUkKI+iiAqKhZERXlFmjRpoUnooFLkUamhKtI7CYaeRkKS949ngYa5kzY9+X7WYi1nn3P22TP3nttwcfv1k7+/f7o1li5dWqVLl1aHDh00YcIEHThwQB9++KGWLVumlJQUq2rZu3evWWzMmDGaMGGCWR19+/bVc889p4YNG5pd4/3bt99+q9jY2FSxpk2bGl6THT16VJUrV85i9Wn74osv1LdvX7N4r169tGTJkkzlys7bzGh7pcVd1pm1ihcvrtdff13PPfecAgMD0+2fO3du5c6dWw8//LA6duwoSdq/f78+/vhjLV26VMnJyVbX5Kj1mh5XWg+2ZPT7SpLJZLI6j9F2KlmypD744AM988wz8vT0tJjPx8dHxYoVU7FixdS8eXN9/PHH+v333/XOO+9o06ZNmarNHvr27atJkyZletzAgQM1cODADPePjIw0vCa856WXXtLYsWPN4ka/vTV8fHwMt3F8fHyOu0dKS2bWwbhx49S/f395eXlZzGcymVSoUCE1b95czZs315tvvqlTp07pk08+0ezZs5WYmOjQuu15nPXx8VH//v312muvqUKFCun2z5Mnj+rVq6d69epp0KBBio+P18KFC/Xxxx/r+PHjGZ43q5o1a6axY8eqadOmafYzmUz3zwcdO3bUl19+qSVLluidd97RiRMnbF6XI44JjjgeBAYGavDgwRo+fLhKliyZbv+AgADVqVNHderU0eDBg3Xt2jVNmTJFn376qWJiYjI056BBg/Tee+9lutbGjRtbPJda8uuvv6phw4Zp9rHV+dkSV11zOel6wlHXElL61xMS5wJLMvq7tG7dWpMnT1bFihUt5jKZTCpZsqRKliypDh06aNKkSVq0aJHGjBmjs2fPpltLvXr19OWXX+rxxx+32Off+3yrVq30xRdfaMWKFRo9erSOHTuW7hz24mrH2MwoUqSIxo0bp+eee04+Pj4W+znreJOd7lPfffdddevWzSw+Z84cDRgwwOr8r7zyiuHfmTVp0kTbtm2zKreHh4d+/fVX5c+fP1X81q1bKlCgQIbzuOJxUHKNc4Q9uOI1/ZQpUxQdHa3vv/9ed+/etSpXTnmWCQAA4EyWr3gBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA6xZesWbdu+TSkpKRnqX7RoUfXu3Vt5cuexc2UAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFgvJSVFffv21a1bt8zacuXKpYULF8rHx8cJlaXv4sWL2rRpk2FbSEiIzefr1q2bAgICzOJbt27V6dOnbT6fu5s9e7ZhvEmTJvL393dwNZnz+OOPq0aNGmbxZcuWGa6V2bNnKzk52SzeuXNnFSpUyC41ZicZfY94TvDyyy9bPJ6MGjVKzZo1szj2888/V6VKlQzbhg4dqlOnTtmkxuwoPj7eMO7l5eXgSjLO2nVTt25dBQYGGuYNDQ21Krc1jh8/rvDwcMO2Fi1aOLgac40bN9bBgwfTXG8ZUbBgQY0bN05nzpzRsGHDZDKZbFajt7e3JkyYoOPHj2vw4MFZPuc++uijCg0N1e+//66KFSvarD5LatSoob1792rOnDl64okn5OHhkekcS5YsMTxPP/LII6pbt64tykwlMDBQXbt2NYtfvXpVK1euzHCenLzNjLjDOrOWh4eHRo8erVOnTmn48OGGx+OMqlmzphYvXqydO3eqZMmSNqzSMntte8l914MrevbZZ3X06FE9++yz8vT0zPT4evXqaePGjVq9erXy5Mljhwpdz19//eXsEmBjAwcO1J9//qnnn38+S9f2ZcuW1bRp03TkyBHVq1fPDhUas+dx9qmnntKJEyc0bdo0VahQIUs5fH19NXDgQB09elT/93//Z/iszBaKFCmiNWvW6KefflLTpk0zPd7T01N9+vTRoUOHNHLkSDtU6P769euns2fP6rPPPsvydUS+fPk0btw4nTx5Um3atLFxhdY7cuSIU+d3pzVnhOuJzLPV9YQ7nQsctU96enrq66+/1vr16zN9je/h4aFnnnlGhw8fNryP/3e/Tz/9VL/++qsef/zxTNfYtWtX/fHHH3rllVcyPdYd2fIY26NHD/3xxx968cUXs/R3kvY83mTH+1RLz3/bt29vk+NNhw4dMhXPjEaNGil//vxm8bCwMCUmJmYoh7ufn+15jrA1V7+mnzNnju7evWtVjpzwLBMAAMAVuO5VLwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADkILt379aGjRuUnJycof758+VX7969lT9/fjtXBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIKiI92kZq9KzU5AWpbg+pXF3Jy8fZlbmPc+fO6aWXXjJsq1atmj755BMHV5RxM2fONIw/+eSTevjhh206V0hISKZqyOnWrl2rlJQUs3iuXLlUv359J1SUcUOGDDGMW9rWFy5c0ObNm83i3t7eGjBggE1ry458fX0N47GxsQ6uxPlu376tZ555RklJSWZtJpNJ8+bNU968ec3a2rVrZ3G/Xbp0qebNm2fzWrMTk8nk7BIyzdp107x5c8P4oUOHFBERkeW6bMHoeCpZrtlRBg4cqJ9//lmVKlWyWc6AgAB99dVX2rhxowIDA63OV6JECe3evVujR4+Wt7e3DSqU6tatq/3796tLly42yWekYcOG2rFjhx599FGr8sTFxWnhwoWGbfY4H/fo0UP+/v5m8Xnz5ikhISFDOXL6NnuQO6wzaz300EPavn27JkyYIB8f29201qlTR3v37lWjRo1sltOIvba95L7rwRV9/PHHmjt3ruExKrPat2+vnTt3qnz58jaozLX99ddfzi4BNvTVV19p1qxZCggIsDpXhQoVtGPHDg0bNswGlaXNXsdZT09PffPNN9qwYYNKlixpk5weHh566aWXdPjwYVWvXt0mOe9p0KCBDh8+rHbt2lmdy9fXV59//rnmzZsnLy8vG1Tn/vz9/fXDDz9o3rx5ypcvn01yFi5cWGvXrtV7771nk3y2cvjwYafM625rzgjXE1lji+sJdzsXOGKf9PT01PLlyzV06FCr8gQGBmr58uXq37+/WZu3t7fCwsL0+uuvW/Ws0NPTU5MnT9akSZOsqNQ92OoY+9Zbbyk0NNTwuXdm2fp4k13vU9esWaO4uDizeIECBdSgQQOrchcuXFh16tQxbGvfvr1VuSWpc+fOhvGlS5emOzY7nJ/t+VzG1nLCNX1OeJYJAADgKjycXQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4H+OHDmiH1b9oMTExAz1z507t3r36q3ixYrbuTIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyJlKVJOe+UIaPEd6arjUoI9Ut5vU5Dmp23hpWKjU5HkpV6CzK3UPCxYs0OLFiw3bhg8frpYtWzq4oowJCwtTVFSUWdxkMqlv3742m6dkyZJq2rSpWfzmzZtasWKFzebJTq5cuaI//vjDsK1WrVoOribj8uTJo6efftosfuLECW3fvt3iuJkzZxrGBw8ebLPasqsiRYoYxq9du+bgSlzDb7/9pg8//NCwrXjx4poxY0aqWMGCBfXdd98Z9r9w4YIGDRpk8xqzm4ceesgwHhsb69hCMsHadRMcHGwYT+s45yjbtm0zjNesWdOxhfzLwIEDNXPmTHl4eKTbNzExUdevX9e1a9cUFxeXofwtW7bUli1bFBiY9QvXihUr6tdff9Wjjz6aof6xsbG6fv26kpOT0+3r5+enZcuW6dlnn81yfZZUqFBB69atU+7cuW2Sb9q0aYbx3r17K1euXDaZ454BAwYYxqdPn56h8Wyz1NxhnVkrf/782r59uxo2bJih/rGxsbp69aqio6Mz1L9gwYIKCwtT6dKlrajSMntte8l914MrGjdunN544w2b5nzkkUe0adMmi9dM2cXRo0edXQJsZPLkyRo2bJhNc3p6euqrr77SW2+9ZdO8/2av46yvr69WrVqlF1980aZ57yldurR27NihJk2a2CRf8+bNtXnzZuXPn98m+e7p16+fZs+ebdOc7qhAgQLatm2bOnXqZPPcJpNJ48aN04QJE2yeO6uOHDni8Dndbc0Z4Xoi66y9nnDHc4Ej9slvvvnGpsetGTNm6IknnkgVW7hwodq1a2ezOUaNGqWXX37ZZvlckS2OscOHD7f4LDyrbHW8yc73qbGxsVq/fr1hW+fOna3K3b59e5lMJsO2SpUqqXz58lblN6rv9u3b2rhxY5rjssP52Z7PZWwtJ1zT54RnmQAAAK7Ey9kFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD+cerUKYUuDVXXLl3l5+eXbn9fX191795da9au0cmTJx1QIQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADkDE/0l+r3SruPt69Ut7tUubG04l0pktfMpmvIkCFq2LChSpYsmSpuMpk0d+5cVatWTdeuXXNSdcYSExP1/fffa8SIEWZtISEh+vDDD20yT9++fWUymcziCxcuVHx8vE3myI7Cw8NVtWpVs3hwcLATqsmYfv36yd/f3yw+a9asNMetWrVKUVFRKlCgQKp4mTJl1LJlS23evNmmdWYn5cuXN4xfuXLFwZW4jvHjx6tVq1aqV6+eWVu3bt3Uv39/zZkzR5L03XffqVChQmb9kpOT1a9fP924ccPO1bo3Hx8fBQUFGbbdvHnTwdVknLXrpkKFCobx/fv3Z7Ukmzl48KBh3NfXVyVKlNCFCxccWk/ZsmX19ddfG14HSNK5c+c0f/58bdy4UYcOHTJbc35+fqpUqZIaNmyobt26qWnTpoZ56tSpoxkzZqh3796ZrjFfvnzauHGj2TXcv+3Zs0eLFy/Wpk2bdOLECcXFxaUaX7t2bbVq1UohISEqWLCg2XgPDw/NnDlTp0+f1i+//JLpGo14eXlp+fLlypMnT7p9k5KSlJKSkm6//fv3a+/evapdu3aqeFBQkDp37qwlS5Zkud5/K1u2rJ544gmz+I4dO3T06NF0x2f3bZbR7XWPO6wza5lMJi1atEjVq1e32OfHH3/UsmXL9N///lfHjh1TQkLC/TZvb2+VLl1aTZo0Ub9+/Qz3P0nKmzevVq5cqXr16unOnTs2q98e6/Ued10Prqhly5Z69913zeLJycn6+eeftWrVKu3du1cXL15UTEyM8uTJo4IFC6pmzZpq27at2rVrJy8vL8PcZcqU0cKFC9W2bVs7fwtz58+f19atWy22ly5dWqVLlzaLnz17VqdPn87wPLt27cpCdXA1ISEheuWVV8zid+7c0YYNG7Ru3TqFh4crIiJCsbGxCggIUKFChVShQgW1bt1abdu2Nbuv/7cPP/xQJ06cUGhoqE3rtudxdv78+WrXrp3F9uTkZP3yyy9avXq19uzZo4iICF29elX+/v4qXLiwypUrpzZt2qhdu3bKnz+/YY48efJo9erVatiwocXr+YyoWLGili9fbvhc5p74+Hj9+OOPWrdunQ4cOKArV67o+vXr8vHxUYECBVStWjW1aNFCXbp0Ud68eVON7du3r1X1ubtcuXJp9erVqlOnjsU+d+/e1S+//KJ169Zp9+7dioyM1NWrV2UymRQUFKQKFSroiSeeUO/evfXwww8b5hg9erT++usvzZ0717D9zJkzaR7X723HB0VFRenw4cNpf8kHHDp0KFP9bcGd1pyR7Hg94ahrCcm66wl3PhfYc5/s0qWLBg0aZBY/fvy45syZo23btuns2bOKj49X3rx5VaxYMTVu3Fg9e/ZUlSpVDHN6eXlp1qxZqlatmhISEjRy5Eh1797drN+1a9e0YMECbdiwQUePHtWtW7cUEBCgwoULq3bt2urcubNatWplsfbPPvtMW7du1ZEjR7L+A2SSOx1jGzRooEmTJpnFXeF4kxPuU0NDQ9W1a1ezeKdOnfTaa69lOW/Hjh3TbG/Xrp0mT56cpdzVqlVTmTJlzOJr1qxJ9xmIu5+f7XmOsLWccE2fE55lAgAAuBrjuz8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgNNcvnxZixcvVrdu3ZQnT550+3t7e6tTx07atHmTDh8+7IAKAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACB7azVMqtku4/1zF5R6T5IWvSpFnrRfXdnBzZs31a9fP/3888/y8PBI1Va0aFHNnDlTXbt2dVJ1ls2aNUsjRowwi1eoUEGPP/64du7cafUcISEhFueGZZbe7fzwww87uJKMGzJkiFksKSlJc+fOTXNcYmKi5s+fr5EjR5q1vfjii9q8ebPNasxuOnXqZBjfvXu3gytxHUlJSXrmmWd04MABBQYGmrV//fXX+uWXX9SiRQu1b9/eMMdnn32mrVu32rlS91elShWLbadPn3ZgJZlj7bopX768YfzPP//Mck22cuHCBUVHRxvu+xUrVtSFCxccWs8XX3whf39/s3hSUpLGjBmjzz//XImJiRbHx8XFaf/+/dq/f7/+7//+T7Vq1dK0adP02GOPmfXt1auXli5dqhUrVmSqxiVLlqh06dKGbadPn9aIESMUFhZmcfy1a9e0efNmbd68We+8846GDx+u8ePHy8vLK1U/b29vLV26VJUqVdLNmzczVaORoUOHqnr16ob1rFy5UmvWrNHBgwcVGRmpmJiYDOedPn26pk2bZhYfOHCglixZYlXN9/Tv39/i3BmRnbfZ5s2bM7W9JPdYZ9YaMWKEWrZsadi2c+dODR48WAcOHLA4PjExUcePH9fx48c1Y8YMtW7dWt9//73y589v1rdmzZp6/vnn9X//9382q99e61Vy3/Xgavz8/DRjxgyZTKZU8RUrVmj06NE6duyY2ZirV6/q9OnT2rVrl6ZPn64KFSpo8uTJatOmjeEcbdq0Ud++ffX999/b5TtYsnTpUi1dutRi+7hx4/Tee++ZxefPn6+3337bnqXBxRQpUkT/+c9/UsWSk5P1zTff6MMPP1RERITZmKtXr+rcuXPas2ePFi1aJD8/Pw0bNkyjR4/WQw89ZDjP7NmztWfPHp06dcpmtdvrODtu3Dh1797dYvuaNWv05ptv6siRI4bt586d0+7du7V48WL5+vpq+PDhGj16tIKCgsz6BgYGas2aNXr00Ud1/fr1DNd4j7e3t1auXGmYW/rfdcHMmTM1fvx4Xbp0ybDP5cuXdejQIS1atEjDhg3Tyy+/rHfffTfVdcb777+vyMjITNeXHUybNk316tUzbEtJSdHSpUs1duxYHT9+3LDPlStXdPz4ca1bt05jx47VoEGDNHHiRAUEBJj1nTJlirZv3254Xz1v3jzNmzfPYp0dO3bUqlWrzOI7duxQly5dLI5zBe605oxk1+sJd7mWcPdzgT32SX9/f3399depYjdv3tSIESM0d+5cpaSkpGqLiorS8ePHtW3bNr3//vsaNGiQvvjiC/n5+ZnlrlChgoYMGaLVq1fr448/TtWWnJyszz77TO+//76io6PN5jh79qx27dqlqVOnqlGjRpo9e7bhszZfX199+eWXFu8F7cGdjrEzZsyQp6dnqpirHG9ywn3qmjVrFBcXZ7Y+ypcvr8qVK2fpOXGuXLnUokWLNPt06NBBkydPznRuSercubNhPDQ0NN2x7nx+luz7XMaWcso1fU54lgkAAOBqPNLvAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwtKvXrmrR4kWKuhqVof4eHh56qtVTevzxx+1cGQAAAAAAAAAAAAICAvTFF1+k+tOtWzdnlwUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADARh5tI9Vsl/lxPr5S1/ck30Db15TdbNu2TZ999plhW5cuXTRw4EAHV5S+w4cPa8+ePYZtISEhVud/7LHHVKlSJbP4oUOHtHfvXqvzZ2fnz583jJcsWdLBlWRM/fr1Va1aNbP4unXrdPny5XTHz5w50zDeoUMHFS1a1Or6sqPHH39cNWrUMGz773//6+BqXMupU6c0dOhQw7bAwECtWLFCn3/+uWH7vn37NHbsWHuWl2106NDBMH7z5k2dPXvWwdVkjLXrpkiRIvL19TVsu3jxolW12cqlS5cM46VLl3ZoHfnz51fbtm0N23r27KlPPvlEiYmJmcoZHh6uBg0aaOHChYbt7777bqby9evXTy1atDBs2759ux577DGFhYVlOF9sbKw++ugjNW/eXNevXzdrL1y4sCZMmJCpGo34+/trzJgxqWLx8fGaMGGCypQpo+eff14//PCDTp06pZiYmEzlXrhwoeGYFi1aqHjx4lbVfc+zzz5rFrtx44aWLl2a7tjsvs0yu73cYZ1ZKygoSG+//bZh2+zZs9WgQQMdOHAgUzk3bNig+vXr6+rVq4btr732mjw8PDJdqxF7rld3XQ+uaODAgXr44Yfvf05MTFRISIi6deumY8eOZSjH8ePH1a5dO3377bcW+7zxxhtW1wrYywsvvKCgoKD7n2/evKnmzZtr2LBhioiIyFCOuLg4ffrpp6pZs6YOHjxo2Mff31+TJ0+2Sc338tnjOFu9enWL55/ExEQ999xz6tChg44cOZKhfPHx8frkk09UvXp1i79NyZIlLd6npmfkyJGqUqWKYdu1a9fUsmVLDRkyxOK9woNiY2M1ceJE1ahRQ8ePH78fz5Url0qVKpWlGt1Zq1atLD4njYuL09NPP62ePXum+q3SkpSUpKlTp+rxxx83fGYWGBio999/36qa3Y27rTkjXE84T3Y5F9hjn/z3ffypU6dUq1YtzZkzRykpKWmOTUlJ0bRp09S5c2clJCQY9hk+fLgmTJggHx+f+7G4uDi1adNGb7zxhqKjo9OtcceOHWrcuLFOnz5t2N6iRQvDv1+CUp33Xel4k1PuU2NiYrRhwwbDtk6dOmUpZ7NmzeTv759mnyeffFK5c+fOUv7OnTubxdL6HvdUr17dMO4u52d7PpextZxwTZ8TnmUCAAC4Itv8rScAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwOZu376txYsX69KlSxnqbzKZ9ESjJ9SsWTM7VwYAAAAAAAAAAJCz1apVSyNGjEj1p1ixYs4uCwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAN+PhLTw7I+vjcBaT6fWxXT3Y2ZswYhYeHG7Z99dVXKleunIMrSt/MmTMN47169ZK3t7dVufv375+pOfGPiIgIw3jhwoUdXEnGDBkyxDCe0W39xx9/aOfOnWZxLy8vDRw40KrasiMfHx/NmjXLsO327dtavXq1gytyPXPnztWyZcsM22rUqCF/f3+zeFxcnPr06aPExER7l+f2cuXKZfEY/8svvyglJcWxBWWALdZN7ty5LbZZOm47mqU60qrdHtq3by8vLy+z+KJFi7R8+fIs571796769eunbdu2pYqvX79ew4cPz3AePz8/TZw40bAtPDxcrVq10tWrV7NU4/bt29WnTx/DdTB48GCVKlUqS3nv6dmzpwoUKHD/85UrV9SkSRONGTNGt27dsip3dHS0lixZYhb38PBQv379rMotSU2aNNHDDz9sFl+wYIHi4+PTHMs2M+fq68wWPD09NXfuXMXFxaWKr169WgMHDlRycnKW8h4/flyDBw82bCtdurQ6dOiQpbwPste2d+f14Ir+/b625ORkdevWTfPmzct0npSUFL344ov68ccfDdurVaump556Kst1Avbk6+t7/79jY2PVrFkzbd26NUu5zp49qwYNGhje40v/O381bdo0S7kfZK/j7LRp0wzPsYmJiWrdurW+++67LOU9f/68GjRooO3btxu29+/fX40aNcpUzrx582rcuHGGbdeuXVO9evW0ZcuWTNcqSSdPnlSjRo105syZLI3PDjw9PfXNN98YtsXFxalJkyYWnz2k58iRI2revLlu375t1lazZs1U6zK7c6c1ZwnXE86Tnc4FttwnixYtev+/o6Ki1LRpU50+fTpTOTZt2qRPPvnEsK1s2bLq1avX/c/Jycnq2rWrNm3alKk5Ll26pL59+1psf+mllzKVL6dxpeNNTrtPDQ0NNYx37tw5S/k6duyYbh9vb2+1atUq07mLFy+u2rVrm8XXrl2b7vO4adOmmcXc6fxsz+eotpRTrulzwrNMAAAAV+Th7AIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJbFx8crdGmoTp48meExwbWC1aF9B3l6etqxMgAAAAAAAAAAgJyrVq1aZrF9+/Y5oRIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtlatpeSXx7ocNdtJXrlsU092dvfuXfXu3VtxcXFmbQEBAVq4cKHLvad30aJFhvXmzZtX7du3z3Jeb29v9erVyyyekJCgBQsWZDlvThEdHW0Y9/HxkclkcnA1aQsKClKPHj3M4pGRkVq7dm2G88ycOdMwPmjQIJf7zs4UGBiotWvXqmrVqobtc+fOtbj/5DQvvPCCLly4kOH+I0eO1F9//WXHirKPN954Q2XLljVsW7RokYOrSZ+t1k1AQIBhPDk5WXfu3LGqRluJiYkxjAcGBjq0jnLlyhnG582bZ3Xu5ORkDRw4UNHR0ZozZ46qVaumtm3basuWLRnO8cwzz6hw4cJm8Zs3b6pLly5Wb88NGzZoypQpZnFPT0+98sorVuUuX778/f++fv266tevr507d1qV89+mT59uGB84cKDVuQcMGJCpOf+NbWbO1deZLVy7dk0jR47Uww8/rE8++UTR0dG6fv26QkJCrM69fPly7dmzx7CtefPmVueX7Lft3Xk9uLoxY8Zo9erVVuUYOHCgxW3QsWNHq3IDjvDiiy9a/R7DmJgYde/eXVFRUYbtw4cPtyr/PfY4zjZu3Fj169c3bBs1apR+/vlnq/LHxMSoR48eunTpkmH7W2+9lal8zz33nOF9SkpKip555hkdP348S3Xec+XKFXXt2lV37961Ko+76tq1q8Vrrpdeekm7du2yKv+ff/6poUOH3v+8c+dOderUSdWqVVN8fLxVud2Fu625jOB6wrHc+VxgxB77ZEhIiM6dO5elsR9//LH+/vvvdPtNnDhRGzZsyNIcv/76q1asWGHY9tRTT2UpZ07hSsebnHafunr1asNzdd26dVWkSJFM53vw72Pv3r2rbdu2mfXr0KFDpnN36tTJMB4aGprmOEvHQnc6P9v7Oaqt5JRr+pzwLBMAAMAVeTi7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABA2u7evasfVv2gw4cPZ3hMpUqV1K1rN/n4+NixMgAAAAAAAAAAgJypdu3aqT6npKTowIEDTqoGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgC2Vf9z6HN65pIdrWp8nJ/jrr7/02muvGbbVrVtX48aNc3BFabt165ZWrFhh2BYSEpLlvO3atVO+fPnM4mFhYbp69WqW8+YU8fHxFtt8fX0dWEn6nn32Wfn5+ZnF586dq6SkpAznWbx4sWJiYszipUqVUuvWra2qMbto06aNdu3apRYtWhi2X79+XR9++KGDq3JdN27cUL9+/ZScnJxu39WrV2vatGkOqMr9PfvssxbPZRERERbPKc5kq3UTGBhoGL9z506Wa7M1S7Xkzp3boXUUK1bMMH7q1Cmb5D916pSKFCmiAQMG6MiRI5ke//LLLxvGJ0+erLNnz1pbniRp4sSJunv3rlm8b9++NskvSQMGDLDZb3rPzp07dejQIbN4hQoVVL9+/SznDQgIULdu3cziu3fv1sGDB9MdzzYz5+rrzJb+/vtvvfnmmypVqpTat2+v69ev2yTv9OnTDeNPPPGETfL/my23fXZZD64mPDxcn376qdV5zp8/r+XLlxu2NWrUyOr8gD1t375d8+bNs0muCxcu6NVXXzVs69Chg4oXL26Tee6x1XHW0jO9TZs2acqUKVbnl6QrV67oueeeM2xr06aNKleunOFcL774omF8zpw52rBhQ5bqe1B4eLi+/vprm+RyNyNGjDCMh4WFac6cOTaZY968eZo8ebIaN26sevXqKSwszCZ53YW7rbn0cD3hXO52LjBi630yLCxM69aty/L42NhYhYaGptnn0qVLGj9+fJbnkKTvvvvOMF6xYkU99NBDVuXOrlzteJPT7lNjYmIMr7VMJpM6dOiQqVyPPvqoSpQokSq2Y8cOzZ4926xvu3btZDKZMpW/c+fOZrHY2FitX78+zXFGx0J3PT9L9nmOais55Zo+Jz3LBAAAcCUezi4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJC+lJQUbdi4Qbt27crwmFKlSqlXz17y9/e3Y2UAAAAAAAAAAAA5T3BwcKrPx44dU3R0tJOqAeBoJUqU0KJFi1L9ad26tbPLAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANpK/lI3ylLRNnpzgm2++0bp16wzbxowZo/r16zu4orTNnDnTMN62bVvlz58/Szn79++fqbmQ2t27dy22eXt7O7CS9A0ZMsQwPmvWrEzliY6O1tKlSw3bXnzxxUzXlV2ULFlSr7zyin777TetW7dOlStXtth3+PDhioiIcGB1rm/r1q2aNGlSmn0iIyM1cOBAB1Xkvvz8/DRhwgTNmTNHnp6ehn3ee+89xcfHO7gyY/9eO7ZaNz4+PobxpKSkLNVoD5bOH7ly5XJoHZZ+q5SUFJvNERMTk6VxDz/8sGrWrGmY78svv7SuqH85f/681q9fbxYvXLiwateubXX+5cuXa9WqVVbnMTJ9+nTDuDXHyh49eiggIMAsPm3atHTHss2MufI6s5fr16/r119/tVm+LVu2GMZr1Khh8ffNCltu++yyHlzRuHHjlJycbJNc3333nWG8WrVqCgoKsskcgD2MHz/epvkWLlyoy5cvm8U9PDzUtm1bm81jq+Nsnjx5LL6/7aOPPrI6/79t2LBBBw4cMGzr0aNHhnJUqlRJZcuWNWxL7z44sz766CMlJCTYNKerK1KkiMVnuJ988olN5xoxYoS2b99u05zuwN3WXEZwPeE87ngucMQ++f7771udY8WKFWm2T548WbGxsVbNsWnTJsP7T5PJpMcee8yq3NmVKx1vcup9amhoqGG8c+fOmcrToUMHs9iqVau0du1as21coEABPf744xnOnSdPHjVp0sQsvm7dujTXraVjobuen+35HNVaOemaPic+ywQAAHAFXs4uAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQcdt/2a7omGg1bdJUJpMp3f6FChVSn959tGz5Mt24ccP+BQIAAAAAAAAAAGRzuXLlUuXKlVPF9u3b56RqADhDvXr11KtXr1SxWbNmOakaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABga/5BNsqT1zZ5cooBAwbo0KFDKlSoUKq4p6enFixYoBo1aig6OtpJ1aW2detWnTp1SmXLlk0V9/b2Vs+ePfXNN99kKl/+/PnVtm1bs/iFCxe0adMmq2qFa2nYsKGqVKliFv/ll1907NixTOebMWOG+vfvbxZv27atSpQooQsXLmSlTKfp0qWLSpcunaG+JpNJfn5+yp07t3Lnzq2yZcuqatWqKlCgQIbGT5gwQfPnz7ei2uwrMjIyzfbo6GjFxcU5qBr3U7hwYfXq1UujRo1SqVKlLPbbunWrvv32W5vM6ai1w7qxn+vXrxvGy5Ytq+PHjzu4mtRatmxpGP/xxx8t1p1V27dvV4cOHczijRs31t69e63K/eWXX1o1Pi3ff/+9Jk6cKF9f31Txnj176pVXXsnSMdPo/B4dHa3FixenO5ZtZsyV15m7OHHihG7evKmgoNQ3zR4eHsqXL58iIiJsMo8tt312WQ+u5syZM1qzZo3N8v3+++9KTk6Wh4dHqriHh4fKlCmj/fv322wuwFbOnDmjn376yaY57969qxkzZmjcuHFmba1bt9aMGTNsMo+tjrOtWrWSl5eXWfzgwYPaunWrTeb4t88//1xz5841i3fs2FHjx49Pd3yrVq0M49u3b9eRI0esru/f/v77b61cuVI9e/a0aV5X1rp1a5lMJrP4vn379OuvvzqhouzH3dZceriecC53PBfYe588ePCg9uzZY3WetN5xnJKSojlz5lg9R2Jiog4fPqzHH3/crC2jzwhzElc73uTU+9TVq1crPj7e7PlZ8+bNFRAQoJiYmAzlMfo+q1evVlRUlH777Tc1bNjQrP/vv/+eodxt27aVt7e3WXzp0qVpjjM6Frrr+Vmy73NUa+Wka3qeZQIAADiH+VMOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBL27dvn2JjY9WmdRt5enqm2/+hhx5S7169tWLFCkVeiXRAhQAAAAAAAAAAANlXjRo15OXllSq2b98+J1UDwBlq165tFgsPD3dCJQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwB4S4iU/bxvkibU+R05y5coVDRw4UGvWrDFrK1OmjKZMmaL+/fs7vjALvvvuO33wwQdm8ZCQEH3zzTeZytWrVy95e5vvdHPmzFFKSkqWa4TrGTJkiGF85syZWcr366+/6ujRo3rkkUdSxT09PfX888/r3XffzVJeZ+nevbu6d+9u1zlSUlI0YcIEjR071q7zuKtHH31UEyZMSLNPuXLlNHnyZD3//PMOqsoxypcvr7p162a4v4eHhwIDAxUUFKSCBQvq0UcfVc2aNfXYY4+l+/75U6dOqUePHtaWfJ+91w7rxv4uX75sGO/Tp482btzo4GpSa9SokWHcHnX9/vvvhvEqVapYlffPP//Ujh07rMqRlhs3bmjZsmXq27dvqnju3LnVpUsXLVy4MFP5ypQpoyeffNIsvmjRIsXExKQ7nm1mzJXXmTu5dOmSgoKCzOL58uVTRESE1fltve2zw3pwRUb37daIiYnRX3/9pcqVK5u15cuXz6ZzAbayadMmu+TdsmWLxo0bZxZ/7LHHbJLflsfZJk2aGMbtdV61lDc4OFj+/v6KjU37Yezjjz9uGN+yZYvVtRlZt26devbsaZfcrsjSOddeayUncrc1lx6uJ5zHXc8F9t4nN2zYYNX4e27cuKFLly6pWLFiZm0HDx7UlStXbDLPkSNHDM9tDz30kE3yZyeudrzJqfep0dHR2rhxozp16pQqnitXLrVu3VrLly9PN0fhwoXNrov//PNPnTx5UpIUFhamhg0bpmpv3769xowZk6EaO3fubBaLj4/X2rVr0xxndCx01/OzvZ+jWisnXdPzLBMAAMA5PJxdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAg844ePaoVK1coISEhQ/0DAgLUs2dPlSpVys6VAQAAAAAAAAAAZG+1atUyi+3bt88JlQBwluDg4FSfz507p6tXrzqpGgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGu3/3atPDnJ2rVrNW3aNMO2kJAQde/e3cEVWTZ37lwlJyebxevWratKlSplKldISIhZLCUlRbNnz85yfTmNyWSy2JaSkuLAStJmtA/funVLS5cuzXLOWbNmGcaff/55eXh4ZDlvdhQZGak2bdpo7Nixzi7FJfn6+mrRokXy8fFJt+9zzz2nrl27OqAqx3nvvfe0c+fODP/57bfftHnzZi1btkxTp07VkCFDVK9ePXl6eqY5z9GjR9W4cWNFRUU56JtZx5p1Y3SelNI+ZjuapVos1W4vO3bsMIz37dtXvXr1cmgtD7J0XfPbb7/ZfK6IiIhM1ZBR27Zts2p8RkyfPt0wPnDgwEznCgkJMdw3Lc3xILaZMVdeZ+7k5s2bhvF8+fLZJL+tt312WA+uaPv27TbPeeHCBcO4rfYtwNYsnVestXv3biUlJZnFS5QoIT8/P6vz2/I4W6VKFcP4f//7X5vN8W+RkZE6ffq0WdxkMumRRx5Jd3zFihUN4/Y4J0j2OVa6MkvbwF77Q07kbmsuPVxPOI+7ngvsvU/a8nxg6d5g165ddp8jb968Npsju3C1401Ovk8NDQ01jHfu3DlD49u1a2f2zGz16tX3/zssLMxsTI0aNVSyZMl0c3t7e6tNmzZm8fXr1ysmJibNsUbHQnc9PzviOao1ctI1Pc8yAQAAnIP/0w4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3NTZs2e1ZMkSxcTEZKi/j4+PunXtpkqVKtm5MgAAAAAAAAAAgOyrdu3aZrHw8HAnVALAWYKDg1N93rdvn5MqAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA9nDGRv/08Bn+GfMsGTlypP766y/DtunTp6t48eIOrsjYhQsXtHnzZsO2Z599NsN5HnnkET322GNm8W3btunUqVNZri+n8fX1tdgWFxfnwErSZlTn4sWLrapx3rx5unv3rlm8ePHiateuXZbzZidRUVF64403VK5cOW3cuNHZ5bisSZMmqXLlyhnuP2PGDBUrVsyOFWU/y5YtU7169XThwgVnl5IuW6yb2NhYw7iPj481pdlUrly5DOPR0dEOreO3337TlStXzOIeHh5atGiRFixYoDp16ji0pnsqVqxoGD937pzN57p+/bph/KGHHrIq7++//27V+Iz45ZdfDK9hmzVrplKlSmUqV0hIiFnswIED2rNnT4bGs82MufI6c2Umk0klSpTQk08+qf79+6tgwYKG/Wx1bLf1ts8O68EVHT161OY5b968aRjPjr8fsodjx47ZJW9MTIxOnz5tFjeZTCpXrpzV+W15nK1SpYphfO/evTabI6O5LdXybxUqVDCMHzx40KqaLDl79qzu3Lljl9yuqFKlSoZx3vVpO+625tLD9YTzuPO5wJ77pKW/l8oKS8+VbHn9cPv2bcN4UFCQzebILlzteJOT71PDwsIMr4/atWsnT0/PdMd36NDBLLZq1ar7/3306FGdOHHCMH96mjZtqjx58pjFly5dmu5Yo2OQu56fHfEc1Ro56ZqeZ5kAAADO4eHsAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWRd5JVKLFi/SjRs3MtTf09NT7du1V62atexbGAAAAAAAAAAAQDYVHByc6vOZM2d0/fp1J1UDwNFKlCihAgUKpIrt3bvXSdUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB7OPKTlJJiXY5zB6Xbf9umnpwmLi5Offr0UWJiollb3rx5NX/+fCdUZWzmzJmG8X79+mU4R0hISKZyw5ifn59hPCkpSXfv3nVwNZlj7ba+cuWK1qxZY9g2ZMgQq3K7s6SkJC1cuFCdO3dWiRIl9OmnnyomJsbZZbmsdu3a6aWXXjJsi4yMNIzny5fPpY7JruzkyZPq3LmzevTooZs3bzq7nDQlJSXZbN1ER0cbxr29veXh4ZHlvLZk6fxhqXZ7SUpK0gcffGCxvU+fPtq9e7cuX76s1atX6+OPP9Zzzz2nJk2aqESJEnatLW/evGaxuLg4Xbt2zeZzWfrdc+fObVXegwcPWjU+o2bMmGEWM5lMevbZZzOc48knn1Tp0qXN4tOnT89wDraZMVdeZ87m5+enqlWrqkOHDhoxYoS+/vprrV27VkePHlVcXJzOnz+vbdu2afbs2SpXrpxda7H1ts8O68EVXbx40eY5b926ZRh3lWsG4EFnz561W25LxyijY1pm2fI4++D73O6Jioqy2RwZzW2pln8LCgoyjF+9etWqmixJSUnR+fPn7ZLbFeXLl88wbs/9IadxtzWXHq4nnMedzwX23CcvX75sdY57LN0bRERE2H0O9ndzrna8ycn3qdHR0dq4caNZPG/evHriiSfSHOvj46OWLVumikVFRem3335LFQsLCzMb26FDh3Rr69y5s1nszp07Wr16dbpjjY5B7np+dtRz1KzKSdf0PMsEAABwDi9nFwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsM6NGze0cNFCde/WXYUKFUq3v8lkUvPmzRUQEKAd/93hgAoBAAAAAAAAAACyBy8vL1WvXj1VbN++fU6qBoAzBAcHm8XCw8OdUAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCXv09Lf26VqjTN2viUFGnbdzYtKcfZt2+f3nnnHU2YMMGsrWnTpnr11Vc1adIkJ1SW2qpVq3T16lXlz58/VbxkyZJq0qSJtm7dmuZ4k8mkvn37msVv3ryp5cuX27LUbK9AgQKG8Zs3bzq4EsueeOIJs9jhw4e1e/duq3PPnDlTnTt3Nou3bt1apUqV0rlz56yewxEuX76c6W2WO3duFS9e3Czu6empqVOnascO3uOdnkKFCmn27NmGbVeuXFHNmjW1bNkyNWzY0Ky9WbNmLnNMdjV3797VTz/9pBkzZmjlypVKTk6221y2XjurVq2ySV0xMTEW2/Lnz6+///7bJvNY48Fz+D3R0dEOrkSaOnWqunbtqiZNmljsU6RIEbVv317t27dPFY+Pj9epU6d08uRJnThxQsePH9eBAwe0f/9+xcbGZrmmgIAAmUwms7ifn58SExOznNcSo7kkKVeuXFblvXr1qlXjM2ru3LmaMGGCfHx8UsUHDBigDz74IEM5BgwYYBaLi4vTggULMjSebZY2V1xnjlSqVCkFBwerRo0aKl++vMqVK6eyZcuqSJEizi7tPltu++yyHlzR7du3bZ7TntdKgD3YYx3cc/36dcN4YGCg1bltdZz18/OTp6enWfzOnTuKj4+3yRxGrl27ZhjPnTt3muMsnRPu3LmjhIQEm9Rm5NatW3bL7Ur8/f3l4eFhFr9z547u3LnjhIqyH3dbcxnB9YTzuPO5wJ77ZFrPsTLL0r7oiDlgzpWON9ynSqGhoerYsaNZvHPnzmn+vWqzZs0UEBCQKrZ27VqlpKSkioWFhWnUqFFmY/38/BQXF2cxf6dOncxiGzduTPc5sdGx0J3Pz456jpoVOfGaPqc/ywQAAHAGL2cXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwXmxsrBYvWazOnTqrVKlSGRpTr149BQQEaNPmTUpJSbFzhQAAAAAAd+HrlUc1ivRUPr8yOn39F525vkN3km47uywAAADAJVSpUkW5cuVKFdu3b5+TqgHgDMHBwWYxjgMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGQ/m6dIRSpI+Upkfuwvc6TLR21eUo7z8ccfq02bNnriiSfM2iZMmKDNmzfr4MGDTqjsH4mJifr+++81fPhws7aQkBBt3bo1zfFNmzZViRLmO9miRYsUHx9vqzJzhGLFihnGL1y44OBKLBsyZIhZbObMmTbJvX79el26dMnsd/Dw8NCgQYM0duxYm8xjb6+99poWLlyYqTFBQUE6deqU8uXLZ9b25Zdfqk6dOrYqL9uaM2eOChYsaNg2YMAARUREqG/fvjpw4IDy5Mlj1mfChAn66aeftH//fjtX6rri4+MVERGhY8eO6fDhw9qxY4e2bduma9euOWR+W68dW7ly5YrFtqJFi+rvv/+229wZVbRoUcN4WrXby927d9W5c2dt2rRJdevWzdRYX19fValSRVWqVEkVT05O1o4dO/T9999r4cKFiomJyVRef39/i21eXl6ZyuVMN27ccMg8UVFR+uGHH/T000+nipctW1aNGjXSjh070hzv7++v7t27m8VDQ0N18+bNDNXANkubK64ze6tRo4aeffZZ9ezZ0/Dew9XYcttnl/XgihITE51dAuB0sbGxdst969Ytw3hgYKDVuW11nA0ICDCMW6rdVizVnzt37jTHWTon2Ltee+4nrsRZ+0NO4m5rLiO4nnAedz4XuPs+mZCQYPc5YM6Vjjfcp0phYWG6c+eO2TvCO3XqpBEjRlgc17FjR7PYqlWrzGI7duzQ9evXlTdv3vsxX19fNW/eXGvWrDHMXadOHcO/Z1y6dKnFeu4xOha68/nZUc9RsyInXtPnxGeZAAAAzpYz7swAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAdISEjQ8hXL1bZtW1WqWClDY6pXry4/Pz+tWbtGd+/etXOFAAAAAABXZpKHWleYoIYPvyJvTz9JUlON1s34C5ryez3dunPRyRUCAAAA6StdurSKFSumAgUKKCgoSLGxsbp27ZoOHz6sv//+2+r8tWrVMovt27fP6rz2rtuIn5+fqlWrpqJFiyp37tySpOvXrysqKkonT57U1atX7TKvr6+vqlevrsKFCytPnjzy9PTU7du3FRUVpcOHD+vGjRt2mfceR//Wzv6+zlC8eHFVqVJF+fLlk4+Pj65evarIyEgdOXJE8fHxdpvXUds2ODg41ecrV67o8uXLNssPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABcw50YadnbUvf3pXwlMj5u1zLp9yX2qysnSUlJUd++fXXw4EEFBQWlavPx8dGiRYsUHBysO3fuOKnC/5k1a5aGDx9uFu/evbteeuklxcXFWRzbv39/izmROZUqGb/T+cKFCw6uxFi+fPnUrVu3VLGEhATNnz/fJvmTk5M1Z84cvfXWW2Ztzz33nN555x0lJSXZZC5Xc/PmTb377rv66quvzNpq166tfv362ex3zo5efvlltWnTxrDtm2++0bp16yRJZ86c0csvv2z4W/r4+GjhwoUKDg6263sJ7G3YsGFasWJFpsbEx8crPj5esbGxdqrKftJaO7ZaN3Fxcbp06ZKKFStm1la+fHkdPHjQ6jmsERgYqEKFChm2HT9+3MHV/M/NmzfVqFEjffrppxo6dKi8vLysyufh4aEnn3xSTz75pN5//329/fbbmjFjRobHm0wmq+Z3Fbdv33bYXNOnT9fTTz9tFh84cKB27NiR5tju3bsrMDDQMGdGsc3S52rrzF7KlCmjTz75RD169HB2KZliy22fXdYDANeUkpJit9yW7t9tcVyz1XHWw8PDMG7vZw9Z/W0stdu73rt379o1v6tw1u+bk7jbmoNrc+dzgbvvk/a8foB7cJd91Z5u376tTZs2qUOHDqnipUuXVvXq1XXo0CHDce3bt0/1+c6dO9q0aZNZv6SkJK1bt07PPPNMqniHDh20Zs0aw9xdunQxiyUkJCgsLCzN7yIZHwvd+fzsyOeomZVTr+lzyrNMAAAAV2Hd1RYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwKUkJSVpzZo1im0Wq1o1a2VoTPny5dW9e3etXLlSd+7csXOFAAAAAABX5OMZoN41FqlKoQ5mbUG+JTSw9np9u6uR4u/eckJ1AAAAcEcvvPCCWrVqdf/zjh07NHny5FR9qlWrpo4dO+qxxx5T+fLlFRQUJG9vb0nS4MGDFRYWlqG5WrVqpb59+6pZs2YqXry4xX7Hjh3T999/rylTpuj69etZ+FZS7dq1zWL79u3LUi5H1n1PUFCQnnvuOXXv3l2PP/64PDw8DPulpKRo//79CgsL0xdffKGbN29aNW/evHnVv39/9erVS7Vr15anp6fFvkeOHNGyZcs0ZcoURUVFWTXvPY7+rZ39fe0hvTVdokQJDRs2TN27d1fZsmUNc8TGxmr9+vX66KOPtHfvXpvUZa9tmytXLn3//feGbY0bN0712cvLS0uXLk0358svv6wrV66k2w8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALiOG5el+SOkli9LlZtIJpPlvtHXpC0zpD+3OKq6nOHcuXN66aWXtGDBArO2KlWqaOLEiXrllVecUNk/Dh06pL1795r9e/aBgYHq0qWLFi5caDguICBAXbt2NYsfPnxYe/bssUut2VmNGjUM40eOHHFwJcZCQkKUK1euVLG9e/fqkUcesdkcf/31l2G8SJEi6tixo1auXGmzuVzN1KlTNXToUFWsWNGs7aOPPtKyZcsUFxfnhMpcW5UqVfTZZ58Ztv3555969dVXU8W+//57tW/fXj179jTrX7lyZU2aNEkvv/yyXWp1hGvXrunSpUvOLsOhLK0dW66b48ePq1ixYmbxGjVqaMWKFVbnt0aVKlVksnCBd+LECQdX84/ExESNHDlSX3/9tUaPHq1u3bopb968VuctXLiwpk+frpYtW+rZZ59VfHy8Dap1DykpKQ6b66efftKpU6fM3uHSo0cPDR06VLGxsRbH9u/f3yz2559/6tdff7V1mS7P3tssu6+z1q1ba8mSJcqTJ0+Wc1y9elXHjx/X8ePHdezYsfv/PXnyZDVq1MiG1abmyPUKADkRx1kAAOcCAM4WGhqqDh06mMU7deqkQ4cOmcVr1KihkiVLpopt2bJFMTExhvlXrVqlZ555JlWsffv2Fuvp1KmTWWzz5s26deuWxTHZFecI15Tdn2UCAAC4Ei9nFwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsK2UlBT99NNPio2JVcOGDTM0pkTxEurdq7eWLV+m6OhoO1cIAAAAAHAleXIV14DgNSqWp6bFPkVzV1eZvI3159+rHVcYAAAA3Fq/fv30xBNP3P988ODB+/9dr149ffLJJ3ryySctjv/jjz/SnaNt27b68MMPVbNmzQzVVLFiRY0fP14jRozQK6+8ogULFmRo3L8FBwen+hwREaHIyMhM5XBG3d7e3ho9erRef/11BQYGptvfZDKpVq1aqlWrloYNG6ZRo0Zp7ty5mZ7XZDJp5MiRevvtt/XQQw9laEzVqlVVtWpVvfbaa3r33Xf12WefZXreexz9Wzv7+9rTg2v6wIEDkiRfX1+98847evXVV+Xt7Z1mDn9/f3Xr1k2dO3eWl5eXVfXYe9vWqFFD3bt3z1DufPnypdv3xIkTunLlSobyAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA13InWlrzibRrqVSluVS6lpS7gOTtK8XekKLOSid+l478KCXecXa12dPChQvVvn179e7d26xt2LBhWrt2rTZu3OiEyv4xc+ZM1a5d2yweEhKihQsXGo7p2rWrAgICDHMhc7y9vfXYY48Ztu3bt8/B1RgbPHiwWax+/fr673//65D5hwwZopUrVzpkLme4e/euXn/9da1atcqsrXjx4nr99dc1fvx4J1Tmunx8fLRo0SL5+vqatSUkJKhPnz6Kj483axs8eLDq16+vUqVKmbW99NJLWrdundauXWuXmmF7ltaOLdfN0aNH1bhxY7N4vXr1rM5tLUs1nD9/XrGxsQ6uxtypU6f0wgsv6MUXX9STTz6pxx57TMHBwapcubLKlSsnf3//LOXt0aOHcufOrbZt2yolJSXNvpbab9y4ocWLF2dp/qy4deuWw+ayhZkzZ2rChAmpYoGBgerevbvmzZtnOObhhx9WkyZNzOLTp0/P1Nxss8xxhXVma+3bt9cPP/wgT0/PdPveunVLf/31l44fP67jx4/r2LFj9//7xo0bhmOMrg9cFesBSJvJZHJ2CW7N29tbiYmJdsnt4+NjGE9KSrLLfFlhqRZr31GXHkvvy0vvt7HUnt7796xl7/y2Yu3xIDk52TBu7/0hJ3G3NYecwRn7Jfsk3B33qf8TFhamhIQEs+vezp0764MPPjDr36FDB7OY0d8H3bNhwwYlJiamOmYUK1ZMNWvW1P79+1P1LVeunKpWrWqWY+nSpel9DUnGxx/Oz/bBNX32fJYJAADganiiCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADZ1G+//6aYmBi1aNFCHh4e6fYvUKCAevfureXLluva9WsOqBAAAAAA4GzF8wSrf63VyuNbLN2+ft55HVARAAAAsouaNWum+hweHi5JGj9+vMaMGZPm313cuHFDJ06csNju4+Ojzz//XC+//HKWasuXL5++//57lStXTuPHj8/wOJPJZPa99u7dm+Hxzqq7bNmyWrVqlapVq5bleefMmaP8+fPr888/z/C4gIAALVu2TK1bt87SvAEBAZo4caIaNGigp59+Wnfv3s3wWGf81s78vo7w4L6/b98+FS1aVKtXr1bt2rUzlcvT01Ovv/66Jk6cmOk6HLVtg4ODs5TfktDQUJvmAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjnfl1P/+wDlefPFFNWzYUKVKlTJrmzNnjqpXr66oqCgnVPY/ixYt0hdffCFfX99U8RYtWqho0aK6fPmy2Zj+/fubxRITE/X999/bq8xsq1GjRgoICDBs27lzp4OrMde4cWNVqlTJqTW0bNlSZcuW1alT2fdAFhYWpq1bt6pJkyZmbW+88YZmzpypS5cuOb4wF/Xxxx+rRo0ahm1jxozR/v37Ddtu3rypfv36acuWLYbvH5k9e7aqVaumK1eu2LJc2JGltWOrdbNt2zYNHjzYLN6oUSN5eXk59R0dzZo1M4xv27bNwZWk7e7du/r555/1888/p4oXKVJE5cuXV/ny5VWhQoX7/12xYkUFBgammbN169Z655139O6776bZLz4+3jAeHR2tF198MVPfIyeZPXu2xo8fLy8vr1TxAQMGaN68eYZjnn32WZlMplSxO3fuWOxvCdssa5y5zmypbNmyWrBggTw9PQ3br1y5omXLlmnz5s3as2ePLly4kOk5HtxPXRnrAUibn5+fs0twa0FBQXZ7FvXQQw8ZxqOjo+0yX1ZYqsVS7baSL18+w/itW7fSHBcTE2MYDwoKsrqmtFh6XuVqrD0eWDrn2vv3zUncbc0hZ3DGfsk+CXfHfer/3Lp1S5s2bVL79u1TxWvXrq3ixYvr4sWLqeIdOnQwy7FmzRqL+W/fvq1t27apRYsWqeLt27c3+7uPTp06mY1PTEzUqlWr0vsakoyPhZyf7YNr+n9kl2eZAAAArsgr/S4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHd18NBBxcbFqn279vLySv+VtkF5gtS7d28tX7FcERERDqgQAAAAAOAsVQt1Vq/q38vHKyBD/ZOSE+xcEQAAALKLChUqKHfu3Kli4eHh+vbbbzV48OB0x+/Zs8dim7+/vzZv3qwGDRoYtp86dUq7d+/WlStXlJCQoAIFCqhWrVqqUaOGWd/33ntPZ86c0bx589KtSZIqVqyogIDU18/h4eEZGuusuqtVq6YtW7aoQIECZm2XL1/Wr7/+qvPnz+vOnTvKnTu3ihQpogYNGqhIkSJm/SdNmqTw8HBt2bIl3Xk9PDy0bNkytW7d2qwtLi5O//3vf3Xs2DFFR0crMDBQRYsWVbly5Qy/b5cuXTR9+nQNHDgw3Xkl5/zWzvy+jmC0pi9evKitW7eqYsWKqeIXLlzQwYMHFRkZKZPJpCJFiqhhw4Zm4z/++GOtXr1aR48ezXAdjty2tWvXznBdGREaGmrTfAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADnNzZs31a9fP23ZskUeHh6p2ooUKaJZs2apU6dOTqruf/WtWLFCffr0SRX38PBQnz59NGnSpFTxEiVKqEmTJmZ5wsLCdPXqVXuWmi09+Lvfc+zYMZ0+fdrB1ZgbMmSIs0uQyWTSoEGD9Oabbzq7FLsaNWqU9u7dK5PJlCru7++vjz76SCEhIU6qzLW0bNlSI0aMMGzbsmWL2THrQdu3b9fEiRP1xhtvmLUVLFhQc+fOVZs2bWxRKhzEaO3Yat38/PPPhvGAgAC1atVK69atsyp/Vt2b38iPP/7o4GqyJiIiQhEREdqxY4dZW9myZdWqVSu99NJLql69uuH4//znP5o6daoiIyMtzhEbG6uUlBSz42q+fPmsKz6bi4iI0Nq1a82uTxs3bqzSpUvrzJkzZmP69+9vFlu5cqWuXbuWqbnZZrbliHVmSxMmTFCePHnM4rdu3dIbb7yhWbNmKTEx0ao5AgMDrRrvSKwHZDeenp42zffgu8WQOQ899JCioqLslttIdHS0XebLijt37uju3bvy8vJKFffy8lJAQIBiYmLsMm/evHkN47dv305zXHx8vJKTk82eK3p5ecnf31+xsbE2q/HfgoKC7JJXsu0xwdrjgaVzrre3t/z8/BQXF2dVfrjfmkPO4Iz9kn0S7o771H+Ehoaqffv2ZvGOHTtq6tSp9z8XKlRIdevWTdUnPDxcFy5cSDP/qlWr1KJFi1SxDh066IMPPkgV69y5s9nYn376STdu3EjnG/yP0bGQ87N9ZMdreltzt2eZAAAArsgj/S4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHd24sQJLVu+TPHx8Rnq7+fnp55P91SZ0mXsXBkAAAAAwFmeLP2a+tZcLh+vgAz1v3Rrvw5FLrVzVQAAAMgugoODU32OiopSjx49NHjw4FTxixcv6vvvv9ebb76pF154Qb169VLPnj315ptvGub19vbWypUr1aBBg1Tx5ORkzZs3T1WqVFG5cuXUq1cvvfLKK3rttdfUv39/Pfroo6pcubJ++ukns5yTJ09WwYIFM/S9atWqZRbbu3dvuuOcVXfhwoW1ceNGFShQIFX8wIEDat26tYoVK6bu3btr5MiRevPNN/Xyyy+rW7duKlq0qNq1a6eTJ0+a5fz666/l4eGR7nceMmSIWrdunSoWGxur//znPypYsKBatmypl19+WW+88YZefvllde3aVY8++qgqVaqkr7/+WikpKanGDhgwwCyfEWf91s76vo7y4Jr++++/9dlnn6lixYqSpJSUFC1ZskS1atVSyZIl1a5dOw0cOFADBgxQmzZtVKBAAY0aNUp37ty5n8PDw0NvvPFGhmtw9Lb94IMPVLVqVbM/W7ZsSdUvKirKsN+Dfw4cOJDh7woAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABj27dv18SJEw3bOnbsqBdeeMHBFaU2c+ZMw3j//v3NYn379jX8t98t5YBlefLkUc+ePQ3b1q5d6+BqzOXPn19du3Z1dhmS/vdv4Xt7ezu7DLsKDw/X/PnzDdv69eun2rVrO7gi15M/f37NnTtXJpPJrO369evq16+f2XsUjIwdO9bieztat26toUOHWl0rHMfS2rHFuomMjNThw4cN20JCQqzKbY1u3brJz8/PsM3oPRfu5tSpU/r2229Vo0YNvfXWW4Z9/Pz8NGjQoDTzJCUl6e+//zaL+/v7y9fX1ya1ZlfTp083i5lMJsNrw0aNGqls2bIZypEetpnj2Gqd2UqZMmXUo0cPs3h8fLxatGihb7/9VomJiVbP8+A7sVwZ6wHuKikpyTCeO3dum85TqlQpm+bLaYoUKWK33IULFzaMR0VF2W3OrLh48aJh3J6/jaXcERER6Y6NjIw0jFv6va3l6empkiVLWp3HEccEa48HycnJDv99cyJ3W3PIGRy9X7JPwt1xn/qPVatWKSEhwSzepUuXVJ/btWtn9vcZYWFh6eZfvXq1Weyxxx5LdW2SP39+s3clS1JoaGi6+f/N6FjI+dk+3PWa3hW42rNMAAAAV2X+f3QCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALKdCxcuaPGSxYqOjs5Qf29vb3Xu3FlVKlexc2UAAAAAAEfyMHmpW9UZaldpojxMHhkak5gUr+VHBik5JcnO1QEAACC7qF27dqrPMTEx+uijj+5//u233/TUU0+pRIkS6tevnz755BPNnDlTS5YsUWhoqPbu3WuY99NPP1WrVq1Sxa5evaqnnnpKISEh+vPPPy3WdPToUbVq1UrLli1LFX/ooYc0bNiwLH0vSdq3b1+645xV9/Tp01WsWLFUsRkzZqhOnTrauHFjmmPXrVunhg0b6syZM6niVatWVb169dIcazKZ9Pbbb6eKXb9+XfXr19fEiRMVExNjceyxY8f0yiuvqFu3brpz506qtv/85z9pzis557d25vd1lAf3/QIFCqhFixaS/vf7NmvWTL169dL+/fsNxyckJOiLL77Qc889lyreo0cPeXhk7N7U0dv23Llz+uOPP8z+lC5dOlW/ffv2GfZ78A8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABsY+zYsQoPDzds+/LLL1WhQgUHV/SPLVu26PTp02bxatWq6dFHH00VCwkJMet38eJFbdq0yW71ZVcjRoxQ7ty5Ddtmz57t4GrM9e/fXz4+Ps4uQ5JUqFAhde7c2dll2N3o0aMVGxtrFjeZTPryyy8dX5CLmTVrlooWLWrYNnjwYF28eDFDee7evas+ffoY/taSNHHiRFWtWjXLdcLxjNaOrdbNwoULDeNdu3ZVqVKlrM6fFSNHjjSM//LLL7pw4YKDq7Gvjz76SJMnTzZsa926dbrjz507ZxivXr26VXVld+vXr9f58+fN4kbXgQMGDDCLnThxQlu2bMnS3Gwzx7N2ndlC27ZtDd8H9M0332j37t02mcNkMqlw4cI2yeUorAe4o+vXrxvGg4KCbDpPxYoVbZovp6lTp45d8hYuXFjFixc3iyclJenkyZN2mTOrLL2j7fHHH7fbnHXr1jWMHzlyJN2xx44dM4zba1uWL19eXl5eVudxxDHBFseDs2fPGsaN3gOKrHG3NYecwdH7JfsksgPuU//n1q1b2rx5s1m8SZMmypMnz/3PHTp0MOsTFhaWbv6zZ8/q4MGDqWImk0lt2rRJldvT0zNVn7t372rVqlXp5v83o2Mh52f7cNdrelfjCs8yAQAAXJX537YCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALKlqKgoLVy0UNeuXctQf09PT7Vp00aPPfaYnSsDAAAAADiCn1dePV9ns+qWeD7DY6LvXNH03U114dZuO1YGAACA7KZWrVqpPj/88MPy9fVVSkqKPvzwQzVs2FCbNm3KVM46derolVdeSRW7efOmmjRpoh9//DFDOZKTk9W/f39FRkamig8cODBD44ODg1N9vnbtms6dO5fmGGfW/c477+inn366/3n+/PkaNGiQ7t69m6F5IyMjNWbMGLN4mzZt0hxXv359FSlSJFXs9ddf18GDBzM0ryStXLlSH3/8sSTp2LFjGjlypLp165bmGGf91s76vo704Jo2mUySpIiICNWtW1dbt27NUJ4FCxZo9+5/7i8DAgJUpUqVdMe5wvqXpKCgIJUpUyZVLDw8PMPjAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYL27d++qd+/eiouLM2vz9/fXwoUL5eXl5YTK/ue7774zjIeEhNz/78cee0yPPPKIWZ85c+YoOTnZbrVlR6VKldLrr79u2Pb777/r0KFDDq7I3ODBg81ivXv3lqenp13//Pt9Bf82ZMgQe39lp7t06ZImTZpk2NaoUSOXeh+Ao73wwgvq1KmTYdvcuXO1dOnSTOW7944FI76+vlq0aJF8fHwyXSecw9LascW6mT17tuE7U7y8vPT2229blTsrOnXqpJo1axq2TZs2zbHFOMi7776rhIQEs3idOnXSHWvpPSx169a1uq7sLCUlxfDasHTp0mrSpMn9z35+furRo4dZvxkzZmR5braZc1izzmzhySefNIwvXrzYZnPUrFlTgYGBNsvnCKwHuKPr168bxkuXLm3TeRo3bmzTfDlN/fr17ZK3Xr16hvHTp09n+D2EjnL48GHDeKNGjewyX7ly5VS4cGGzeGJioo4fP57u+L/++ssw3qBBA6trM2KrNeaIY4Itat2/f79h3F5rJSdytzWHnMGR+yX7JLIL7lP/ERoaahbz9va+//5sHx8ftWzZMlX7xYsXtW/fvgzlX716tVmsQ4cO9/+7c+fOZu1btmzRtWvXMpT/HqNjIedn+3DXa3pX5OxnmQAAAK7Kw9kFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAc59atW1q0eJEuR1zOUH+TyaTGTzZW0yZN7VwZAAAAAMCe8vuX19B6O1UuX5MMj4mIPqIpOx/XuZu/268wAAAAZEvBwcGG8XfeeUdjx45VSkpKpnN+88038vDwSBXr06ePDh8+nKk8MTEx+r//+79UseLFi6tChQrpjq1Vq1aqz/v27Ut3jDPr3r9/v1q0aKE2bdooLCxMgwcPztSckrRq1SolJSWlilWvXj3NMfXr10/1OTk5WYsXL8703BMmTFDTpk1VqVIlffnll7p+/Xqa/Z31Wzvr+zqS0ZqOj49Xp06ddOrUqUzlCg0NTfW5cuXK6Y5xhfUvmR8DpIwdBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBbf/31l1599VXDtjp16ujdd991bEH/MmfOHCUnJ5vFn3nmGXl6ekqSQkJCDMfOnj3brrVlNx4eHpo9e7YCAwMN2z/44AMHV2SuadOmZv8e+rVr17RixQolJyfb9c/MmTMzXFN29PHHH+vyZeP3eE+cOFE+Pj4Orsj5KlasqC+//NKw7dSpUxo6dGiW8k6fPl1hYWGGbdWrV9cnn3ySpbxwDktrx9p1ExERoTVr1hi2DRw4UHXq1Mly7szy9fXV559/bth2/fp1LVu2zGG1ONKNGzcM37Ph4+OjPHnypDl29+7dhvGmTZvapLbsbObMmYbXhgMGDLj/3926dVPu3LlTtScmJmrOnDlZnpdt5hzWrDNbKFq0qGH86NGjNpujWbNmNsvlKKwHuKNr164Zxi29IzArPD091bp1a5vly4maNWtml3vLtm3bGsZ37Nhh87mstXnzZsN4+/bt7z8Hs6XOnTsbxrdv367ExMR0x//yyy+G8TZt2lhTlkUdOnSwSR5HHBNscTz4/fffDeOW9mlXZo/91xbcbc0hZ3Dkfsk+mT246jHWkbhP/ceqVauUkJBgFr+33ps2bWr294CrV6/OVP4HtWrVSt7e3vL19VWrVq3M2h9893JGGB0LOT/bh7te07siZz/LBAAAcFUezi4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOBYcXFxCg0N1ZkzZzI8pnbt2mrXtp08PHgtLgAAAAC4mzJ5n9TQejtVIKBChscci9qkqTsb6HrcGfsVBgAAgGypVKlSypcvn1l87dq1ev/997OUs0GDBnrsscdSxZYuXap169ZlKd/mzZvNYlWqVElzTOnSpZU3b95UsX379qU5xhXqlqQNGzaoU6dOiouLy/ScMTExOnfuXKpY7ty50xxTtmzZVJ8vXbqkmJiYTM+dkJCgrVu3ZqivM39rZ3xfR7K0pj/66CPt2rUr0/mOHDmS6rOPj0+a/V1lHUlScHCwWSw8PDxLdQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMA6U6dOtfhvVo8ePVoPP/ywgyv6nwsXLujHH380ixcqVEitWrWSt7e3evXqZda+bds2nTx50hElZhuTJ09Ws2bNDNt+/fVXrV271sEVmRsyZIhZbP78+UpISLD73CtWrNC1a9fM4iaTSYMHD7b7/M4WGxursWPHGraVKVNGw4cPd3BFzuXl5aWFCxfK39/frC0pKUl9+/ZVdHR0lvM/99xzioiIMGwbPny4WrZsmeXccCxLa8cW6+add95RcnKyWdzDw0MLFy5UYGCgVfkzavLkyWbvG7nnww8/1J07dxxSR1qKFClil7yXLl0yjD/00ENpjtu4caNhvGPHjipUqJC1ZWVrFy5cMPz9unfvfn+f79+/v1n76tWrdeXKlSzPyzZLn6utM1t48B1b98THx9skv8lk0qBBg2ySy5FYD3BHf/zxh2G8QIECqly5sk3m6NKliwoXLmyTXDlVgQIF1Lt3b5vmzJcvn/r162fYtmHDBpvOZQtbt241vJcsWbKkunfvbtO5PD09NWLECMO2sLCwDOUweo+dJFWqVEmtWrXKammGSpYsqTZt2tgklyOOCbY4HmzYsEEpKSlm8cqVK6t58+ZW57cHS++dTO+dnc7ibmsOOYMj90v2SffibsdYR+I+9R83b940/HvVNm3ayMvLSx07djRry8ya3717t9nfXQQGBqpx48Zq1aqV/Pz8UrUlJSXphx9+yHD+e4yOhZyf7cNdr+mtlR2fZQIAALgqD2cXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwvMTERK1YuUJ//vlnhsdUrlxZXbt0lbe3tx0rAwAAAADYUu1iIXq+zmb5e+fL8Jjfz3+r2fvaKv7uLTtWBgAAgOwqODjYLJaYmKgRI0ZkOeewYcNSfU5JSdHYsWOznO/8+fNmsaJFi6Y5xuh77du3L80xrlC3Ldy5cyfVZz8/vzT758mTx+yzh4eHzev6N2f+1s74vo5ktO9fuHBBn376aZbyxcbGpvrs5eWVZn9XWkcP/hbR0dE6fvx4lmsBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAdQYMGKArV66YxT08PJQ7d24nVPQ/M2fONIyHhISoXbt2yp8/f4bHwJzJZNJXX32loUOHGrYnJCRoyJAhDq7KXIECBdS5c2ezuKO2dUJCghYsWGDY1r9/f/n4+DikDmeaPXu2Dhw4YNg2duxYFShQwMEVOc/777+v2rVrG7Z98MEH+u2336zKHxUVpf79+yslJcWszWQyad68eYbHPrim2bNnG8atXTcHDx7UvHnzDNsqVKigxYsXy9PTM8v5M2Lw4MEaNGiQYduZM2f09ddf23X+9JQoUUJTp07V2bNn1alTJ5vnt3Tsf/B9Ig86ffq04fHU29vb4u+ZVblz53bIO3kcafr06WYxf39/9ejRQyVLllSzZs0yNCYz2GaWueo6s4Vbt4zfQ1uwYEGb5H/66adVsWJFm+RyJNYD3NGpU6cUGRlp2Na/f3+r83t6eurdd9+1Og+k1157Ld13sWXGiBEjDN8VGBcXpw0bNthsHltJTEzUkiVLDNvGjBkjb29vm831/PPPq0SJEmbxhIQEhYaGZihHZGSkfv31V8O20aNHW1Xfg8aPH2+z+xtHHBNsISIiQjt27DBss/XvO2TIED322GNW57l27ZphvHTp0lbntgd3W3PIGRy5X7JPuhd3O8Y6EvepqRmt4aCgIDVp0kTt27dPFY+JidHPP/+cqfyrV682i3Xs2NHw7/C2bt2qqKioTOWXLB8LOT/bnrte02dVdn6WCQAA4Ko8nF0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMA5kpOTtXbdWu3duzfDY0qXLq2nn35afn5+dqwMAAAAAGALrStM0NPV58jLwydD/ZNTkrT66Eit/ONFJack2bk6AAAAZFe1a9c2i82fP18nTpzIUj5fX1916dIlVezHH3/UsWPHspRPkhISEjI9Jjg42Cy2b98+i/1dpW5byJcvX6rPERERafb/+++/U33OkyePBg4caPO67nH2b+3o7+toRmv622+/VXx8fJbyeXt7p/p89epVi32dvW0f9OBxYP/+/VnOBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOtduXLFJf9t8FWrVunatWtm8U6dOumVV14xi9+6dUvLly93RGlur1ChQtq4caOGDRtmsc+7776rQ4cOObAqYwMGDJCPj/k7xA4fPuywGmbOnGkYz58/v7p16+awOpwlJSVFo0aNMmzLkyeP3n//fQdX5ByNGzfWf/7zH8O233//3Wa/w8aNGzVlyhTDtiJFimjWrFk2mQf2l5KSYhi3xboZM2aMbty4YdjWrl07LVq0yPDYaQsDBw7UN998Y7F91KhRTns/TIkSJfTNN9/o5MmTGjJkiHx8fPTVV1+ZvTfGWuXLlzeL3b17V1FRUemOnTFjhmH8rbfeUsWKFa2u7Z5Jkybpr7/+0qhRo+Tp6WmzvM60evVqw3f+DBgwQM8++6xMJlOq+Llz57Rp0yar52WbpeYO68xaluZo0KCB1bmLFi2qyZMnW53HWVgPcEe//vqrYXzgwIFWH7veeOMNVa1a1aoc+J9q1app4sSJNsnVqFEjjR492rBtwYIFunnzpk3msbVJkyYZ3kNUr15dX375pU3mqFGjhr744gvDtvnz56f7fsV/+7//+z/DeJMmTSzeO2dWs2bNFBISYpNc99j7mGArU6dONYw3b95cw4cPt8kcwcHBmjJlinbt2qVNmzbpiSeeyHKuixcvGsZLly6t4sWLZzmvPbnbmkPO4Kj90gj7pOtyx2OsI3Gf+o8ffvhBiYmJZvFx48apVKlSqWKbN2/WnTt3MpU/LCzMLNahQwd16NDBLL506dJM5f43o2Mh52f7cNdr+szICc8yAQAAXJWHswsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADjXlq1btHXbVqWkpGSof9EiRdW7V2/lyZPHzpUBAAAAALLCy8NXfR9dqqZlR2d4zJ270ZoX3lk7zn5pv8IAAACQIwQHB5vFZsyYkeV8DRo0UK5cuVLFQkNDs5xPkooVK2YWi4uLS3PMg98rOjpax48ft9jfVeq2lr+/vwoVKpQqdvbs2TTHbN682Sz27bffavz48cqbN69N65Oc/1s7+vs62oP7fnJysr777rss5ytVqlSqz6dPn7bY19nb9t/8/PxUqVKlVLHw8HCragEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAID11q5dq2+//dbZZaSSkJCgBQsWmMV9fX3VtGlTs/jixYvt/m/Puzt/f3+9+uqrOnbsmFq2bGmx3/Lly/XRRx85sDLLBg0a5OwSdPDgQe3du9ewbciQIQ6uxjl+/vlnrV271rDthRdeUNWqVR1ckWM99NBDmj9/vjw8PMzaoqOj9cwzzygpKclm873++us6fPiwYVunTp30wgsv2Gwu2Je91s2lS5cUEhJisb1Hjx7aunWrSpcuneU5HuTj46NJkyZp1qxZhmtBkqZOnaqVK1fabM7M+vbbb/Xiiy/Kx8fnfqxUqVJaunSp/Pz8bDJHcHCwHnnkEbP4xYsXMzT+u+++U2RkpFncz89PixYtUmBgoNU19u/fXy+88IJy586tSZMm6cCBA3riiSeszutsSUlJmjNnjln8iSee0LBhw8ziM2fOVEpKitXzss1Sc4d1Zq2//vrLMD548GCr8vr5+Wnp0qUqXLiwVXmcifUAd2TpfV0FChTQ5MmTs5y3ffv2Gj9+fJbHw9yIESOsvtepVKmSlixZIi8vL7O2pKQkffHFF1blt6c///zT4v760ksvaeTIkVblL1eunH744QfD8/WdO3cy/Rxo6dKlOnfunGHbhAkT1Llz56yUeV/FihW1ZMkSmUwmq/I8yF2OCUuWLLF4TTJx4kS1bdvWqvyFChXSsmXL5OnpKUlq2bKltm/fru3btxu+pzA9V65c0ZkzZwzbXnrpJWtKtRt3W3PIGRy1Xz6IfdK1ueMx1pG4T/3HzZs39eOPP5rFjWpdtWpVpvP/+OOPZn8PW7p0aRUoUCBVLDk52apnxJaOhZyfbc9dr+kzIyc8ywQAAHBVxv9XCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgR9mzZ4/Wr1+vpKSkDPXPly+f+vTuowIFCti5MgAAAABAZgT6FNaQuttUvUj3DI+5HndOU3c10p9/r7FjZQAAAMgpgoODU30+ffq0fv/99yzna968uVnsp59+koeHR5b/lC9f3iznmTNnMvW9wsPD3aLutHh6eqpo0aKqWbOmWrVqpX79+um1117TZ599pnnz5mnjxo3atWuX2bgTJ06kmXfTpk06ePCg2Vxvv/22Ll++rJ9++knvvfee2rdvr8KFC2e5/nuc/Vs7+vs62oP7/oEDB3T58uUs56tQoUKqz2fPnrXY19nb9t8effRReXh4pIrt3bs33XEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwv1GjRumvv/5ydhmpzJw50y59cxIvLy81btxYX331lS5evKjPPvtMQUFBFvvv2LFDffv2dWCFljVv3tzw30aPjY11eC2W9q8nn3xSjzzyiIOrcY7XXntNd+/eNYt7enrq888/d0JFjjNt2jSVLFnSsG3YsGE6deqUTee7c+eO+vTpozt37hi2f/nll6pYsaJN54R92HPdhIWFpZmjfv36Onz4sEaPHq2AgACr5urUqZP279+vUaNGWeyzb98+jRgxwqp5rPX2228rJSXFLN6sWTP99NNPFtdxRgUFBWn27NmGbevXr89Qjri4OL399tuGbcHBwfrll1+sejfLyy+/rFmzZqWKVa1aVdu3b1e7du2ynNdVzJgxw3AbP/ibJSUl6bvvvrPJnGyz1NxhnVlr48aNhvEWLVro+eefz1LOIkWK6JdfflHDhg3vx/bt25elXM7EeoA7Wrp0qc6fP2/Y1rdvX33yySeZzjlgwACtWLFCnp6e92Ou9jzFXU2fPl1ffPFFqt82o1q3bq2dO3eqWLFihu3ffvut/vjjD2tLtKvhw4frxo0bhm2ff/65vv32W/n4+GQ6b/PmzbVr1y6VKVPGsH38+PE6efJkpnImJiZavD/w9PTUihUr9Oabb2a6Vklq0qSJduzYoQIFCtyPXbhwIUu5HuSIY4ItjgfJyckaOXKkYZu3t7fCwsI0fPjwLOWuWLGitm/fbrg/FCxYUJGRkVnKu3XrVsP466+/rqZNm2Ypp72505pDzuGM/ZJ90vW54zHWUbhPTS00NDTdPsnJyVq7dm2mc8fHx2vz5s3p9tu+fbuuXLmS6fz/Zuk6h/OzbbnrNX1m5IRnmQAAAK7Kw9kFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABcwx9//qEffvhBiYmJGeofGBioXj17qUSJEnauDAAAAACQEUVzP6pX6u9RyaC6GR5z/uYuTfm9ri7fPmDHygAAAJBTFClSREWKFEkV+/nnn63K2ahRI7PYqVOnlJSUlOU/y5YtM8t5/PhxizUULVpUhQsXThXbt2+fy9d9j7e3t5588kmNGTNGS5cu1d69exUVFaXExERdunRJ4eHh2rhxo+bNm6eJEyfq1VdfVb9+/dSqVStVrVrVLF94eHia8yUlJemZZ55RVFSUWVuuXLnUrFkzjRs3TqtXr1ZERITOnz+v5cuX6+WXX1b58uXT/T4PcvZv7ejv60hGa3rLli1W5axZs+b9/z579qyio6Mt9nX2tv234OBgs1h6awEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACOERcXpz59+mT4vbyOcPDgwXT/XXtJOnLkiHbv3u2AihynRYsWGjRoUKb+vPTSS3r11Vf1wQcfaO7cufrtt990+/Ztbd26VcOGDdNDDz2U5pwbN25Uq1atFB8f75gvmY4hQ4YYxpcuXergSqSFCxcqLi7OsG3w4MEOrsY5jh49qunTpxu2tWrVSm3atHFwRY7x7LPP6umnnzZsW758uebMmWOXeQ8dOqTRo0cbtvn7+2vRokXy8vKyy9ywHXuvm9deey3NfTAgIEATJkzQ+fPnNXXqVDVr1kx+fn7p5jWZTKpRo4befPNN/fHHH/rhhx9UuXJli/0PHz6s1q1bKyEhIStfw2bCw8M1depUw7b69evrjz/+0Ntvv62CBQtmOnfLli21c+dO1ahRw7A9M+emGTNm6McffzRsq1mzpg4fPqyhQ4dmao1Xq1ZNa9as0ZQpU+Th4WHWvnv3bq1fvz7D+VzVqVOnMvQup/Xr1+vixYs2m5dt9g93WWfW2LFjh+F7lCRp2rRpevvttzO8rb29vTV06FAdPHhQtWvXvh+/efOmxo4da5N6HY31AHeTlJSkzz//3GL7f/7zH61bt04VK1ZMN1fNmjW1du1afffdd/L29r4fP3jwoEJDQ21Sb060d+/eVJ9HjBihP//8Uz169JDJZEp3fNWqVfXDDz9o/fr1CgoKMuxz/vx5tzjuRkZGpvmMYfDgwTp27Jj69u2boeNs5cqVtXz5cv3444/Kly+fYZ9ff/1Vn376aZbqXb58udasWWPYZjKZ9NFHHyk8PDzD9z0VK1bU7Nmz9fPPP6e6loiPj9dbb72VpRofZO9jgi2PB+vXr7d4P+np6akvv/xSe/bsUatWrTKULyAgQKNHj9a+fftUqVIls/aUlBSNGDFCSUlJWarX0jWit7e3Nm3apEmTJqlcuXJZym0v7rbmkDM4er9kn3QP7niMdSTuU//xww8/pPv3vDt37tTff/+dpfyrVq1Kt48tnt9ERkZabOP8bFvueE2fGTnhWSYAAICr4v9oAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADcd/rMaS0JXaJuXbvJz88v3f6+vr7q3q271qxdoxMnTjigQgAAAACAkcoF26t3jUXK5RWY4TGHIpZp8aF+upscb8fKAAAAkJPUqlXLLLZ161ab57S1a9eu6dKlSxbbg4ODzWL79u1LM6cr1F2iRAn95z//UZ8+fZQ/f36bzJmcnKwDBw6k2+/w4cNq2LCh5s+fr7p166bZt0SJEipRooS6du0q6X/7zPvvv6+ff/45QzW5wm/tyO/rSEa/7W+//WZVzn+vp/Dw8EzPb2vpbdt7HjwOJCQk6I8//rBXWQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMikffv2ady4cfroo4+cXcp9M2fO1DfffJNun+xmwIABGjBggEPmSklJ0aeffqoxY8YoKSnJIXOmp1ChQurUqZNhmzO2961bt7Rs2TL169fPrC0kJESjR49WfHz2f5fZO++8o759+ypPnjxmbZ9//rk2bdrkMvuQLZQtW1ZTpkwxbLt48aJeeOEFu87/xRdfqE2bNmrZsqVZW3BwsD744AO9+eabdq0B1rPnuklJSdGAAQOUmJiY5v6YN29eDRkyREOGDFFiYqJOnDihkydP6tq1a4qJiVFKSor8/PyUJ08ePfzww6pYsaJhvUb279+vFi1a6OrVq1n6DrY2cuRI1a1bV3Xq1DFrCwwM1Pjx4/X222/rt99+05YtW/Tnn3/qzJkzun37tmJjY2UymRQQEKCgoCCVK1dONWvWVLt27VSxYkWLc27YsCHT70zp1auXdu/erTJlypi1FShQQF9//bXGjh2rDRs2aPPmzTp//ryuXLmi2NhY+fj4KHfu3CpVqpSqV6+uNm3aqH79+jKZTIZzRURE6Omnn1ZycnKmanRV06dPV/PmzdPtY2tss3+4yzrLqjt37ujDDz/UF198Ydbm4eGh8ePHa8iQIZo/f75++eUXHT16VDdu3FB8fLyCgoJUqFAhlS9fXk899ZTatWunokWLpsqRkpKi/v37KzIy0iHfxx5YD3A3X331lTp16qQmTZoYtrdp00ZPPfWUdu7cqU2bNunMmTP6+++/JUn58+dXtWrV1KJFC8P3gSUkJKh///7q0KGDPb9CtjZgwADt2rVLvr6+92MVKlRQaGiorl69qg0bNmjPnj2KjIzUtWvXlDt3bhUqVEgVKlRQ69at9cgjj6SZ/86dO+ratatu3Lhh529iG6GhoapatarGjRtn2P7www9r/vz5mjJlijZu3Khdu3YpMjJSUVFRCggIUOHChVW+fHm1bt1alStXTnOuM2fOqFOnTrp7926W6+3bt6/27Nmj8uXLG7bXrFlT69atU2RkpDZs2KD9+/crMjJS169fV65cuZQvXz5VrVpVTZs2NXzfpSQNHz5cJ0+ezHKND7LnMcHWx4OhQ4eqUqVKaty4sWF77dq1tXHjRv3999/atGmTwsPDdeXKlfv3Z0FBQSpdurTq1q2rp556Sn5+fhbnmjhxojZu3JjlWnft2qUtW7aoadOmZm1eXl4aNWqURo0apcjISJ0/f163bt0yPL9HRUWpd+/eWa4js9xtzSFncNR+yT7pPtz1GOtI3Kf+z40bN/TTTz+pdevWFvusWrUqy/nXrFmjlJQUi79NcnKyVqxYkeX8/zZ+/HjOzw7ijtf0mZHdn2UCAAC4Ki9nFwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcC0RERFatGiRunXvpqA8Qen29/LyUscOHfXjjz/q4KGDDqgQAAAAAPBvjR4eoXaVPpOHyTPDY7ac+kgbjr9lx6oAAACQEwUHB5vFdu7cmeV8ZcqUUe7cua0pKUP279+fZnutWrXMYvv27bPY3xXqfv311/Xee+/Jz88v03ljYmIUGRmpyMhI1apVS76+vvfbjh07ppiYmAzlOXbsmOrVq6eePXtqyJAhaty4cYbGNWnSRE2aNNHUqVP18ssvKyUlxWJfV/it73HE93U0ozUdHh6e5XzFixdXoUKF7n929XX0bw/+FocOHdLdu3ftUBEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACy6pNPPlHbtm31xBNPOLsUSdLChQv1+eefp/o33/8tMTFR33//vYOryj6OHj2qoUOH6qeffnJ2KakMGDBA3t7eZvFjx45px44dTqhImjlzpvr162cWz5s3r3r06KH58+c7oSrHioqK0gcffKBPP/3UrO2RRx7RkCFD9H//939OqMz2PD09tWDBAsN/8z8lJUXPPvusrl+/bvc6QkJCdOjQIeXPn9+s7fXXX9eGDRu0detWu9eBrHPEuhk0aJD279+vSZMmWTxf3uPt7a3KlSurcuXKVs0pSXPmzNHQoUMz/B4WR0hISFCbNm20YcMG1a5d27CPt7e3nnzyST355JNWz3f16lUNGTIkS+OaN2+un3/+WaVLlzbsU7hwYYWEhCgkJCTL9V25ckWtW7fWmTNnspzD1axcuVJRUVEqUKCAYfulS5e0du1am8/LNvuHu6wza3zzzTd69tlnDd+7JUnFihXTG2+8oTfeeCPTud944w398MMPhu81chesB7ib5ORk9e7dW/v371fhwoUN+3h4eKh+/fqqX79+pnIPHTpU4eHh6tChgy1KzZEOHTqkvn37KjQ0VB4eHqna8ufPr2eeeUbPPPNMlnLfuXNHPXr00J49e2xRqsO88847MplMevvtty32CQoK0tNPP62nn346S3McPXpUTz31lKKiorJapiTp5s2beuqpp/TTTz9ZPCdIWT8vfPXVV5o+fboaNGhgVZ3/Zs9jgq2PB4mJiWrfvr1Wr16tJk2aWOxXsGBBq9bKnDlz9Oabb2axyn8MGDBABw4cUFBQkMU+hQsXtvi7S9KFCxesriOz3GnNIeew937JPul+3PUY6yjcp/4jNDRUrVu3ttgeFhaW5dxXrlzRrl279Pjjjxu2//e//1VERESW8/8b52fHccdr+szICc8yAQAAXJGXswsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALiea9evadGiRererbsKFCiQbn8PDw+1atVKAQEB+u333xxQIQAAAADAw+SpTpWnqF7JIRkeczc5QSuODNLeS3PtWBkAAAByqtq1a6f6HB0drePHj2c5X5UqVcxiM2bM0IkTJ7Kc08iBAwfSbH/we8XHx+vPP/+02N/Zdc+ePVv9+/c3i6ekpOj48eM6evSoLl68qMuXLysyMtLsT2xsrCTJx8dH0dHRqXLs27cvUzWmpKRo8eLFWrx4sQoXLqymTZuqSZMmqlu3rqpXry4vLy+LY1988UV5eXlp0KBBFvs4+7d+kL2/r6M9uO/fvn1bJ0+ezHK+4ODgVJ/T2p9cadt6e3uratWqqWLh4eE2rQMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADWS0lJUd++fXXw4EEFBQU5uxzdvHlTK1euVO/evQ3bV69eraioKAdX5f5Onjypzz//XNOmTVNSUpKzyzFj6d+cnzVrloMr+cf27dt14sQJlS9f3qxtyJAhmj9/vhOqcrzJkyfrpZdeUunSpc3a3nvvPS1YsEA3btxweF22Nm7cONWrV8+w7fPPP9fPP//skDouX76sF154QStWrDBr8/Dw0Pz581W9evVs8ZtnZ45YN9988422b9+u+fPnq2bNmlblSk9UVJReeeUVLVq0yK7zZFVUVJSaNGmiefPmqUuXLnab59KlS2rRooXOnj2bpfGnT59WgwYNtHTpUjVs2NDG1Un79+9Xx44ddf78eZvndqbExETNmzdPo0aNMmyfPXu2kpOT7TI32+wf7rLOsiohIUFt2rTRb7/9pjJlytgkZ2JiooYOHarp06fbJJ+zsR7gbiIiIvTEE09o7dq1qlChgtX5kpOTNXLkSM2YMcMG1WH58uV6+umnNX/+fPn5+dkk599//62nn35aW7dutUk+Rxs3bpxOnz6tr776SoGBgTbNvW7dOvXt21fXr1+3Sb5Tp06pYcOGCgsLM3tvnzU+/vhjjR492mb5/s1exwR7iI6O1lNPPaXJkydryJAhNs2dkpKiTz/9VG+++aZN8p09e1ZdunTRihUr9NBDD9kkp6O405pDzmGv/ZJ90j258zHWUbhP/Z8ffvhB06ZNk7e3t1nbqVOn0nyfeEasWrVKjz/+uGHb0qVLrcr9IM7PjuOO1/SZkd2fZQIAALgiL2cXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwTdHR0Vq0eJG6dOmiEsVLZGhMw4YN5R/gr59//lkpKSl2rhAAAAAAci5frzx65tGlqligVYbHxCZe07zwLjp9fbsdKwMAAEBOFhwcnOrz/v37rcpXsmRJs9iUKVN08OBBq/Jm1oPf6+DBg0pKSrLY35l1v/r/7N13mF1VvT/gz0x6ISGF0CEJoUMahBLA0DtKFRCQoiKo2K+IDcQr6tWroogiIIp0CUgvUXovCQmEXqSFXtL7zO+P+cElZJI5M3PKnJn3fZ55ktl7le/ee+2111r7zMy3vpWjjjpqiW1vv/12fvrTn+aiiy7Km2++WXBZI0aMSJcuXZbY9vDDD7c4tjfeeCOXXHJJLrnkkiRJ9+7dM2rUqGy99dbZfffds9NOO6W2tnaJPF/4whdyySWX5JZbbmm0zLbSRhpTiuMtt4+3/UmTJrWqvM0337zg8trStd14443TtWvXJbZNnDix7HEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0LSXXnopX/rSl3LhhRdWOpQkyTnnnJNDDz10mfsozHvvvZdrr702l156aa6//vo2+7eTd9lllwwdOnSp7YsWLcrf/va3CkT0f84999z87Gc/W2r72LFjs8kmm+Sxxx6rQFTltWDBgpx44om59NJLl9o3YMCA/OhHP8o3v/nNCkRWPGPHjs33v//9RvdNnjw5J510UlnjufLKK3Puuefmc5/73FL71lhjjZx99tk56KCDyhoTzVOu++axxx7LqFGjctBBB+UnP/lJ1l9//VaX+VHvv/9+fvnLX+b000/P7Nmzi1p2sc2aNSv7779/DjjggPz617/OWmutVdTyL7roonz729/Oa6+91qpyXnvttYwbNy7f/OY3c/LJJ6dXr16tjm3u3Lk59dRT86tf/SqLFi1qdXlt0Z///OdG75n6+vqSjw1ds/9TLfdZS73xxhvZcsstc95552WvvfZqVVmTJ0/OkUcemcmTJxcpurbB/UC1eeaZZ7Llllvm73//e6vu67fffjtHHHFEbrzxxiJGx/jx4/PMM8/kvPPOW+pvv7WkrOOPPz5vvfVWkaKrjPPOOy+33HJLzjzzzOy5556tLu/111/Pd7/73ZKsrUybNi1bbrllvv/97+ekk05K9+7dW1zWW2+9lc997nO55pprihjh0qqpT1iwYEGOP/74XHXVVTn99NOz3nrrtbrM559/Pscdd1wmTJhQhAj/z6233poxY8bknHPOybhx44padqlV0z1Hx1GKdtna+Q2VU819bLmYpza8C7zllluy2267LbXv6quvbnX5V199dU477bSlttfX12f8+PGtLv/jPJ/LpxrH9M3R3tcyAQDamtpKBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQNs1f/78XH755Xn22WcLzjNq5Kjsvffe6dSpUwkjAwAA6Lj69Ric47e8J+sN3LXgPG/PfiZn3LdlXnjvjhJGBgBAR9a/f/+svfbaS2ybNGlSq8ocOHDgUtvefPPNVpXZXP37989aa621xLaJEycuN0+l4h44cGBOOeWUJba9+OKLGTVqVH772982O4btt99+qW1NHXtzzJs3L/fee29+/etfZ9ddd83GG2+chx9+eKl0X/7yl5dZRltoI4UqxvGWUynu6dGjR3/4/7feeivTpk1bZtq2dG0/GvcHWnsuAAAAAAAAAAAAAAAAAAAAAAAAAAAAACidiy66KBdffHGlw0iS3HLLLfnPf/6z1PZp06blpptuKn9AbVRdXV1mzZqVN998M08++WRuuumm/PnPf85xxx2X0aNHZ6WVVspnP/vZXHfddamvr690uMt03HHHNbr9uuuuyxtvvFHmaJb017/+NYsXL2503xe/+MUyR1M5l112We67775G933lK1/JsGHDyhxR8aywwgq58MILG/3b4vPmzcuhhx6ahQsXlj2ur371q8v8G+kHHnhgjjzyyDJHRHOV8775xz/+kY022ii77bZb/vKXv+S9995rcVkLFy7M9ddfnyOPPDJrrbVWTjvttMyePbtosZba+PHjM2TIkBx44IGZMGFC5s+f3+Ky3n///Zx33nnZaqutcthhh+W1114rSoyLFy/OL3/5ywwePDg//vGP89JLL7WonFdeeSU//vGPs+aaa+bnP/95Fi1aVJT42qKnnnoqd91111LbJ0yY0OiYsdhcsyVVw33WUm+99Vb23nvvHHTQQY22uaY8/PDD+fSnP51Ro0Zl8uTJJYiw8twPVJv33nsve++9d7bffvvcfffdzco7ffr0/O///m+GDRuWG2+8sUQRdmxTpkzJmDFjcsQRR2Tq1KnNyjtv3rxcfvnl2WyzzXLggQfmrbfeKlGU5fXiiy9mr732ymabbZZLLrmkRWPxyZMn5/jjj8/gwYPzt7/9rQRRNli8eHFOPfXUDB48OL/85S+b/Tfz3njjjZx88skZOnRorrnmmhJFuaRq6xNuvPHGbLTRRjnkkENy5513pq6urtllPProozn++OOz/vrrZ8KECSWIMnn22Wez/fbbZ4sttsgf//jHTJ48eZnraW1NNd1zdBzFbpdUt2ruY8vFPLVhLboxV111VavLnjp1al544YWltt97773L/RvLreH5XD7VOKZvrva8lgkA0JZ0rnQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC0bYsWLcpVV1+VXXfZNZtuumlBedZfb/306N4j/7zqn1mwYEGJIwQAAOg41uq7VY4cdVV6dxtUcJ5n37klFzxyYOYueq+EkQEA0NGNGjVqqW0PP/xwq8qsra1daltNTU2rymyu0aNHL7Vt4sSJy81TqbgPOeSQ9O7de4ltxx57bF555ZUWlbf33nsvte2RRx5pUVmFePLJJ7PTTjvlqaeeysorr/zh9h122GGZedpCG2mplhxvOTV2TzfV9puy2WabFVxWW7q2H+8H6urqMmXKlIrEAgAAAAAAAAAAAAAAAAAAAAAAAAAAANCWDRkypNIhfOgzn/lMPvOZz1Q6jCRt57wUO462clyl0NJjO+CAA4ocSfG8/vrr6dy5c6XD+FAl28/WW29d1vquvvrqsvy+/ZkzZ7bJ+3LOnDlZd911Kx3GEtrieSpUpWIv531TV1eXm2++OTfffHO++MUvZsSIERk5cmRGjhyZddddN3369Enfvn3Tt2/f1NbWZubMmZkxY0amT5+eV155JY888kgmT56ciRMnZvr06WWLuxTq6uoyfvz4jB8/Pj169Mi4ceMyYsSIbLDBBhk6dGj69OmT3r17p1evXqmvr8+sWbM+PB/PPfdcpkyZkkcffTR33313Fi5cWLI433777Zxyyik55ZRTstlmm2XbbbfN6NGjM2TIkAwaNCi9evVK586ds2DBgsycOTPvv/9+nnrqqTz22GO59dZbi/o3carhb9dst912lQ7BNfuIarnPWuryyy/P5ZdfnvXXXz/bbrtttt566wwbNiwrrrhi+vXrly5dumTGjBl5//338+STT2bixIm5/vrr8+yzzy6zzIkTJxblulX62n+gLd0PxVSs81vO6/SFL3whX/jCF8pWX0uceuqpOfXUUysaw+23355tt902a6yxRnbbbbfssMMOWXXVVTNo0KD0798/ixYtyvTp0/PGG2/kkUceyd13350bbrgh8+fPb7S8Yh1TNba5Yqurq8sFF1yQCy64IBtvvHH23HPPjBw5Muutt1769u2b3r17Z968eR9enylTpuSBBx7IjTfemFmzZhU9nrZyLidOnJhDDz003bt3z84775wtttgiI0aMyOqrr/7heVmwYEGmT5+ed999N1OnTs3kyZMzYcKEvPDCC2WN9Y033sh3vvOdnHjiidluu+2y3XbbZeTIkRk8ePCHsc6ZMyfTp0/Pyy+/nMmTJ+f222/Pbbfdlrq6ukbLvOeee0p6LYrZJ5S6j1u8eHEuvfTSXHrppRk0aFC23377bLXVVhk2bFjWWmutrLDCCunRo0fq6uoyffr0D8cnkyZNyi233JLHH3+8ZLF93IMPPpgHH3wwSdKrV6+sssoq6dev34fjp8bMmzevyXLLcV+2xXvOeOL/lHss4VnQuHKcl3322afkdZx55pk588wzS15PsZWqj03aT3/TXuephfjLX/6Sv/zlLyUrf+jQoSUre3naWj+YVO4ZUep6q3FM3xztfS0TAKAtaDufrgMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoM2qr6/PTTfflNmzZ2errbYqKM9aa62VQw4+JJePvzxz5swpcYQAAADt36hVD8uBm5ybzrXdCs7zwCvn5MrHj09d/aISRgYAAMno0aOX2jZp0qRWldnY+4W+ffvmtddea1W5zTFq1Kiltk2cOHG5eSoV92677bbE9y+99FJuvvnmFpW1+uqrZ+zYsUtse/755/P++++3NLyCTJ8+PZdffnm+/OUvf7itX79+qa2tTV1d3VLp20IbaY3mHm85FfueXnnllbPqqqsWXFZburYfPxdPPfWU958AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAltmjRojz88MN5+OGHKx1Kxc2dOzc33nhjbrzxxkqHslyuV/Vxzf5PtdxnLfHUU0/lqaeeyrnnnlvpUNo09wPV5JVXXsm5557rvm6jpk6dmqlTp1Y6jDZl3rx5ufbaa3PttddWOpQm1dfX54477sgdd9xR6VAKVm19wptvvpnLLrssl112WaVDadLs2bPz3HPPVTqMZqume46OQ7vk46q1jy0n89T2RT9YPtU4pm+u9ryWCQBQSbWVDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgOpx19135d///nfq6+sLSj9o0KB85tDPZMUVVyxtYAAAAO3crsNOzcGb/j2da7sVlL6uvi7XPfVfGT/1C6mrX1Ti6AAAINlss82W+H7BggV5/PHHW1Xmq6++utS2jTfeuFVlNtfHj2vRokV59NFHl5unUnGvv/76S3z/4IMPtrisn/70p+ncufMS2yZOnNji8prjvffeW+L7hQsXLvPdVFtoI63VnOMtp4+3/fnz57fqnv54eU21p7Z0bTfccMMlvm+qDwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKpDbaUDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgukx6ZFKuve7aLF68uKD0K664Yg495NCsPGjlEkcGAADQ/nSu7ZZDh1+cndb5YWpqagrKs2DR7FzwyAG54z+/KnF0AADwf0aNGrXE94899lgWLVrUqjIfeeSRpbbtsssuLS6vc+fOWX311ZuVZ/To0Ut8P3Xq1CxYsGC5eSoVd9++fZf4/v33329RfVtttVWOOOKIpbY//PDDy8236qqr5he/+EUuu+yyFtX7gXXXXXeJ719++eXU19c3mraSbaQSx1tOjd3Thb4fbMzH76VJkyYtN31buP+ThvtqxRVXXGLbSy+91OI4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAtqO20gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFB9nnrqqYy/YnwWLFhQUPpevXrl4IMPztprrV3iyAAAANqPXl1XyrFjbs3IVQ8pOM+MedPypwc/kalv/rN0gQEAwMf07t0766677hLbJk6c2Opyn3jiibz88stLbDviiCOy8sort6i8008/PY8//niOPvrogtKvsMIKGTZs2BLbCjmuSsU9d+7cJb7/+DUpxJAhQ3LVVVeltrZ2qX3LOvZVV101f/3rX/Piiy/mO9/5Tg466KDsvvvuza47Sbp165add955iW2PPfbYMtNX4lxX8njLpRT39Oabb77E988+++xy01f6/v9A//79l9rWrVu3FsUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC0LbWVDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgOr00ksv5dJLL83s2bMLSt+1a9fsv//+2WCDDUocGQAAQPVbuddG+cqW92ftFbcuOM+0GY/k9/dtkVdnTCxhZAAAsLSRI0empqZmiW0TJxZnXHr++ecv8X3Pnj1z3nnnpXPnzs0q53/+53/ypS99KX369Mlf/vKXXHfddVl11VWXm6c1x1WJuJ988sklvt9uu+0yfPjwguvaZJNNMmHChAwaNKjR/ZMmTWp0+/z58/PpT386Xbp0+XDb3/72t6y33noF1/2BH/3oRxkwYMAS266++url5in3ua7U8Q4bNiwvv/zyUl+77bZbs+ttSinu6dGjRzc7TyXv/w/MmzdvqW3bb799s+oHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADaptpKBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQPV64803cvElF+f9998vKH2nTp2y1557ZfTo0aUNDAAAoIqtO2CXHL/lPenfc0jBeR5/85r88YFtM2P+qyWMDAAAGtfYuv+kSZOKUvZvf/vbpd5D7LHHHrn22muz9tprN5l/vfXWy4QJE/Jf//VfS2zfYYcdMmDAgOXmHTVq1FLbJk6c2HTQqUzc11xzzRLf19TU5Morr8wGG2yw3Lq6dOmSb3zjG3nooYeyzjrrJEmee+65JdK88soreeuttxrN/+677+aPf/zjEtsGDRqUe++9N4cccshy6/5Ar1698j//8z/53ve+t8T2t956K5deeuly85b7XFfqeMeMGZM11lhjqa+nnnqqoDqbo9j39MCBA7Pmmms2O18l7/8PvPnmm5k1a9YS2zbddNP84Q9/SO/evQsqAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaJs6VzoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACq2/vvv5+LLr4oBx5wYAYNGtRk+pqamuy4w47p3at37rjzjjJECAAAUD22XOOL+dSGZ6RTbeeC89z+wq9yw9Mnpj51JYwMAACWbbPNNlvi+7q6ukyZMqUoZb/99ts54YQT8ve//32J7bvttluefPLJ3Hjjjbnpppvy0ksv5e23306S9OvXLxtttFH23HPP7LTTTqmpqVki7+LFi3PEEUfkscceW27djR3X5MmT22zcf/3rX3PyySdnpZVW+nDb0KFDM3ny5Fx00UW57rrr8txzz2XmzJnp2bNn1l577YwbNy6HHHJIVl999Q/zPPzww7npppvyve9978NtEydOXO7x/uAHP8jee++d9dZb78Nt/fv3z8UXX5z//u//zj//+c9MnDgxr776ambPnp3OnTunb9++GTJkSMaOHZu99947/fr1W6rck046KbNmzVpu3ZU415U43o+3x6ThPd1//vOf5Z6flij2PT169OgW5avk/f/R9Lfeemv22WefJbZ/6UtfytFHH51JkyblrbfeysKFC5fY//e//z1XX311cw8ZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoo86VDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgOo3Z86cXHLpJdn3U/tmrbXWKijPFltskZ49e+amm29KfX19iSMEAABo22pSm09ueHrGrvWVgvMsrluYKx8/Pg++em4JIwMAgKaNHj16ie+feuqpzJkzp2jlX3DBBVl//fXzgx/8YInt3bt3z7777pt999234LJmzJiRz372s7nqqquaTPvx43r66acze/bsgusqd9yzZ8/OF77whVx55ZWpqan5cHvXrl1z1FFH5aijjmqynkcffTS77757/vznPy+x/eGHH15uvrlz52aXXXbJnXfeudS7onXWWSff+ta3mqz7437/+9/n3HMLm++U+1xX4ng/3h6TZNKkSc2upxCN3dNz585tcXmbbbZZi/NW6v7/qJNPPjl77bVXamtrl9jeo0ePjB07ttE855xzTrPqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyq+20gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANA+LFiwIJePvzxPPvlkwXk22WST7PupfdO5c+cSRgYAANC2de3UO0eNvjZj1/pKwXnmLHwv5z68ex589dwSRgYAAE3r3r17NtxwwyW2TZo0qej1/PCHP8xxxx2XOXPmtLiMm2++OaNHj85VV13VZNrGjmvixInNrrPccV911VX53Oc+lwULFjS7ngsvvDBbb7113n777YwePXqJfYUc+0svvZTNN988N9xwQ7Pr/qh58+blhBNOyFe/+tVm5Sv3uS738Y4aNWqpbS1pk00pxT292WabLfH9/Pnzm5W/3Nf24yZNmpQjjjgiixYtKjjPQw891Ox6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA8qqtdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALQfdXV1ufa6azNx0sSC86yzzjr59EGfTvfu3UsYGQAAQNu0Yvc186Ut78kGK+1RcJ535jyXM+/fOs+9e0sJIwMAgMIMHz48nTp1WmLbww8/XJK6zjrrrGywwQb505/+lBkzZhSUZ+HChbn22muz0047Zbfddstzzz1XUL5iHlc5406S8847L1tssUX+9a9/NZm2vr4+//73v7Pjjjvm8MMPz+zZs9O/f/+svfbaS6SbOLGwdz9vvfVW9txzz+y6667597//ncWLFxcc96uvvppf//rXGTJkSM4444yC831Uuc91uY536NChWXHFFZfaXop7rRT39GabbbbE948++mizyyj3tf24iy66KBtuuGHOPffcTJs2bblpX3jhhbzzzjstrgsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACiPzpUOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA9ueWW27J7Nmzs+0226ampqbJ9KuttloOOeSQjB8/PjNnzixDhAAAAJW3Rp8xOWr01Vmh2yoF53nhvbty/qR9M2fhOyWMDAAACvfAAw8U9C6gWF5++eUcf/zx+frXv56xY8dmzJgxWWedddKvX7/06NEjCxcuzPTp0/P8889nypQpufXWWzNjxoxm11Ps4ypX3B+YPHlydtlllwwdOjS77757Nt100wwYMCDdu3fPzJkz8/rrr2fKlCmZMGFCpk2btkTed999t9XHPmHChEyYMCEDBgzIuHHjMnz48Ky55prp06dPunfvnjlz5mTWrFl566238vjjj2fy5MmZPHlyq+r8QLnPdTmO9/nnn//wmtx9990ZO3ZskmTixImtirsxpbinhwwZUpRyKnFtP+rZZ5/N5z//+STJKquskgEDBqRPnz5Lna/p06cXrU4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKB0Olc6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2qf7778/s2fPzq677Jra2tom0w8cMDCHHnJoxo8fn3fefacMEQIAAFTOJisfkEM2/Xu6dOpRcJ6J0y7I5Y99LovrF5QwMgAAqA7z58/PrbfemltvvbXSoTRLueN+/vnnc+aZZ5alrsa88847ueKKK3LFFVeUve5KtJFSH29tbW1GjhyZJJk9e3aefvrpktTT1rWF+//111/P66+/XrH6AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA1qutdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALRfjz32WK66+qosXLiwoPR9+vTJIYccklVXXbXEkQEAAFTO9kO+m8NH/CNdOvUoKH19fX1ueuaHufTRI7K4fkGJowMAAKCtGjlyZHr27Jkkue+++1JfX1/hiAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKpXbaUDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgfXvuuedy+eWXZ968eQWl79GjRz590KczdOjQEkcGAABQXp1quuagTc7LHuv9LDU1NQXlWbh4bi6afHBuef6/SxwdAAAAbd3BBx/84f+vuuqqCkYCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQ/WorHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAO3fq9NezcWXXJyZM2cWlL5Lly7Z91P7ljYoAACAMurZZUC+MObf2Xz1owrOM3P+6/nTA+My5Y1/lC4wAAAAqsKnPvWpfPWrX02STJ8+PZdcckmFIwIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGi/OnXq1OgXAAAAAADQvtRWOgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADqGd955JxdffHHeefedgtLX1tZmzJgxJY4KAACg9FbqtX6+stX9GdJv24LzvDbz0Zxx3xZ5ZcaDJYwMAACAtu6AAw7Ibbfdln/+85/p3r17kuS73/1u3nrrrQpHBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0H7V1dU1+gUAAAAAALQvtZUOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAjmPGzBm5+OKL89prrxWUftwnxmWH7XcocVQAAACls07/HfOlLe/NgJ7rFJznybduyJn3j837814uYWQAAABUgy984QsZN25ckmTevHk54YQT8qc//anCUQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFS/2koHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAxzJv3rxcetmlef6F5wtKv9lmm2WvPfdKba0/yQsAAFSXMat/Lp/b7Mb07NKv4Dz3vHRG/jpx7yxYPKuEkQEAAFAtxo8fn+nTp+eMM87IeuutlzPOOKPSIQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALQLnSsdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHc+iRYvyz3/+M7vttls23mjjJtNvuOGG6dGjR666+qosXLiwDBECAAC0XE1qssd6v8i4If9VcJ66+sW5+omv5d6X/1DCyAAAAKg2F1xwQc4///zMnz+/0qEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC0K7WVDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgI6prq4uN9xwQx586MGC0g8ePDif/vSn06NHjxJHBgAA0HJdOvXM4SPHZ9yQ/yo4z/xFM/PXiXvn3pf/UMLIAAAAqEZz587N/PnzKx0GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAu1Nb6QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOjYbr/99tx2222pr69vMu2qq6yaQw85NKuttloZIgMAAGiePt1Wz3Fj7sgmK+9XcJ5357yQP9y/dZ56+8YSRgYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB8VG2lAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIcefig33HBDFi9e3GTa/v3756yzzsqIESPKEBkAAEBhVu8zOids9UDW6LtZwXlefP/enHH/lnlj1tQSRgYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB8XG2lAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgCR5/InH889//jMLFy5sMu2AAQNyxx13ZPvtty99YAAAAE3YeNC+OW7MHenTfbWC8zzy2iX584M7ZPaCt0oYGQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANCYzpUOAACAtqXnismXLiws7a/2KmkoAABAO2XeAbBsQ8ck+5/SdLrXn0ku+HqJg6FkXGeqUSnbrXsCcwSApRXyfPRsBAAAAErN+i3QHngfCQAAAAAAAAAAAAAAAABQvV74zwu59LJLc8D+B6RHjx7LTdunT5/ceOONOeywwzJ+/PgyRQgAALCkTwz+dvZY7xepraktKH19fX1uef6/c/OzPypxZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMCydK50AAAAtD21nSodQdtR2znpt1rSo0/SrWfS9f9/1dYmC+cnC+Yk8+c0/Dvz7WTWO5WOGJY0ap9kiwObTrd4QXLOF0ofDwDAB8w7AJatkD6ytrb0cVBarjPVqJTt1j2BOQLVwro75dRU3+jZCABAR2VuBlBe1m+B9sD7SMrBXAUAAAAAAAAAAAAAAAAASuP111/PRRdflAMPODB9+/Zdbtpu3brl0ksvzQknnJA//vGPZYoQAAAgqa3pnP02+mO2WOPzBedZVDc/lz/2uUx67cISRgYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0pXOlAwCgOFYaknTuWpqy6+uTxQsbvubNSuZMT1JfmroAKm3FVZN1t05WXi8ZNCTpv0ZS26nw/HNnJG+9kLz5QvLylOT5Bxv6T6iUbr2Svis3nW7RgtLHAgAA0BKlXPv8wAdroIvmJ3NmJPNnlbY+AACql3V3AACAyjM3A6ASVhiY9B6w/DR1i5M3ni1PPE0p9F37/NnJu6+UPh6AjsBcBQAAAAAAAAAAAAAAAABK57333stFF1+U4487vsm0nTp1yplnnplVVlklJ598chmiAwAAOroenVfM4SMvz7ABOxWcZ/aCt3P+pH3zn/fvLmFkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0LHde++9jW7feuutyxwJAG3dH/7wh4wePXqp7ccff3weeeSR8gdERRlDAEBxeKa2PR35mhTr2DvyOaT964hzY30DUIiO2D9SXp4jANC2dK50AAAUx94nJisNLk9d9XXJ7PeTd19J3nkpee2p5JXHkvdfK0/9AMXWd+Vkk12S9bZJVhrSurJ69EnWGtHwtfm+yYK5yXP3J0/cnjx7X5L6YkQMAAAAHUc51z4/sHhRMuPNhjXQt15oWP989fFk/uzyxgEAAAAAAABA27DPSckaGzed7pwvJO++XPp4mlLou/bnH0ou/0HJwwEAAAAAAAAAAAAAAAAAAGi12bNn5+WXX86aa65ZUPof/ehHWWWVVXL88cenrq6uxNEBAAAdVf8eQ3P06OsyqPcGBed5c9aTOW/iXnl37vMljAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADYaqutKh0CUMVqamqywgorNLpv5syZqa+vL3NElNJGG23U6HOjT58+FYiGSjOGAIDiaA/P1PY2L6i2a1LM81+sYy9GOe2tXdF+dMS5cVvqG4C2qyP2j5SXMSYAtC2dKx0AANWnpjbp3b/ha63hyai9G7ZPfyN56s7k8VuSN5+vbIwAhei3WrLVocnGOya1nUpTR9ceyYbbN3y9/WJy9wUNfSUAAADQdnXq3LBu0G+1ZJ0tkhyc1C1OXpqSPHFb8sStyaIFlY4SAAAAAAAAgHLov2ayxsaFpR2xR3Lrn0sbDwAAAAAAAAAAAAAAAAAAQEd1+fjLs/dee2fdddctKP2xxx6blVZaKYceemjmz59f4ugAAICOZki/7XLEyCvSq+vAgvM8/fbNuXDyQZm3aEYJIwMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWmvIkCF57rnnGt23/vrr5+mnny5zRAAAQLmZF1RWez3/7fW4AACoHGNMACie2koHAED70XflZIsDk6POTA79VTJ0TKUjAmhc157J7t9IPnd2sukuSW2n8tQ7cO3kU99v6CdXWa88dQIAAADFUdspGTwq2eMbyZcuTLY5POnSvdJRAQAAAAAAAFBqI/YoPO3GOyW1nUsXCwAAAAAAAAAAAAAAAAAAQEe2ePHiXH3N1Zk8ZXLBefbbb7/cdNNN6du3bwkjAwAAOprNVjsyn9/8X+nVdWDBee57+U85b+KembdoRgkjAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJqrc6UDAKB9WnOThq8XH0kmnJG8+0qlIwJosNbIZM9vJX1WqlwMg4Ymh/06ueO85MHxlYsDAACgo9j1hGT1jZtOd+dfk2fvK3k4tAPdV0i2OTwZsWfD+ucz91Q6IgCA9s2YHgAAoPLMzQDoqGo7JxvvVHj6nn2TdbdOnrqzdDFBW2XMCHRE+j4AAAAAAAAAAAAAAACA8quvr8+ECRMye/bsjN16bEF5xo0blzvuuCO77bZbXn/99RJHCAAAtHe7r3tadhh6UsHp6+oX57qnvp27Xvxt6YICAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWqxzpQMAoH1be2Ry5B+SW/+cPHJdpaMBOrpxn0u2ODCpqal0JEmnzskOX0jWGpFc/dNk4fxKRwQAANB+9Vk5WWlw0+m69S55KLQzvfsn+/2oYe1zwh+S+rpKRwQA0D4Z0wMAAFSeuRkAHdW6Wyc9+zYvz4g9k6fuLE080JYZMwIdkb4PAAAAAAAAAAAAAAAAoHLuueeezJk9JzvuuGNqa2ubTD98+PDce++92XXXXfPMM8+UIUIAAKC96VzbPYds+vdsusqBBeeZv2hWLp5yaJ5469oSRgYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKU1duzY/PSnP11q+1133ZUf/vCHFYgIAAA6HuNyAABjIgAAYGnmCQBAMXWudAAAtH9duiW7npAMHJz868wk9ZWOCOhoamqT3b+ebLprpSNZ2jpbJPv/OLn8h8nihZWOBgAAAGiJkXslfQYlV55qfg8AAAAAAADQnozYs/l51h6Z9F0lmf560cMBAAAAAAAAAAAAAAAAAADgIx6Z/EjmzJmT3XffPV27dm0y/eDBg3P33Xdnzz33zEMPPVSGCAEAgPaid9eVc9Toq7Nm3y0KzjN93is5b+LeeW3m5BJGBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApTdw4MBsv/32S21///33yx4LAAB0VMblAADGRAAAwNLMEwCAYqqtdAAAdByj90l2/3qlowA6mtpOyT7fTTbdtdKRLNvaI5NP/aAhVgAAAKA6DR2T7H1ipaMAAAAAAAAAoFj6rtLwWe/mqqlJhu9e9HAAAAAAAAAAAAAAAAAAAABoxNPPPJ1vfvObmTFjRkHpV1pppdx6663ZZZddShwZAADQXqzSe5N8ZasHsmbfLQrO88r0h/P7+7bIazMnlzAyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoBg6VzoAADqW4bsl019P7r240pEAHcXOX0o2+ETry6lbnMx8O5k3M1k4L6mrS7p0S7r2THqskPRcsXXlD9sy2eHY5N9/bH2sAAAAQGWsv20y5sDkwcsrHQkAAAAAAAAArTV8t6SmpmV5N901uev8pL6uuDEBAAAAAAAAAAAAAAAAAACwtIkTJ+YTn/hEbrzxxqyyyipNpu/du3euvfbaHHXUUbn4Yn9YEQAAWLb1B+6ew0Zclm6dVyg4z2NvXJlLHj08CxfPKWFkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEApzZs3L3fddVej++bOnVvmaAAAgEowL6is9nr+2+txAQBQOcaYAFA8nSsdAADltXBeMuvd5uXp1Dnp0iPp2qPh/621zeHJi5OSaU+2viyA5dl452TkXi3LW7e4oa969v7klceSd15q2LYsPfokAwcna49M1t8uGbBm8+sc/cnk6buSlx9tWczQmHdfTp66s+l0i5fTvgEAAKrB7Pca5vDNVpN07pp06Z50752suFrStXvL4/jEUckzdyfvv9byMgAAaLusuwMAAFSeuRkA5VBTm2y6a8vz9+6frLNF8ux9xYsJgLbNXAUAAAAAAAAAAAAAAAAAKmvy5MkZO3Zsbr755gwbNqzJ9F27ds2FF16YQYMG5fTTTy9DhAAAQLXZZq2vZu8Nfp3amk4F57n1+Z/lxme+V8KoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBymDZtWrbbbrtKhwEAAFSQeUFltdfz316PCwCAyjHGBIDi6VzpAAAor5cfSy7/Qcvz9+ybDFg7GTQkGbpFstaIpFMznya1nZLdvpac96Uk9S2PBWB5Bg1Ndvtq8/MtnJ9MujZ5cHwy+93C882dkbw8peHrrvOTNTZOtjsqWXPTwsuoqUl2/0Zy3vHJovnNDh0a9fTdDV8AAADt3RvPJVf9tDhl9Vk5WWt4st62ydDNG9Y0C9Wpc/KJo5OrTytOLAAAtC3W3QEAACrP3AyAchg6Juk9oHVljNgzefa+4sQDQNtnrgIAAAAAAAAAAAAAAAAAlffCCy9km222yfXXX5/NNtusyfQ1NTX57W9/m1VXXTXf/e53yxAhAABQDWprOuVTG56RrdY8ruA8i+oW5Iqpx+bhaX8rYWQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAKdRWOgAAqsuc6cnLU5KHr0r+8f3kjIOT2/+SzJvZvHJWGpJsOK40MQIkye5fTzp3bV6e/0xKzv1CctvZyex3W1f/K1OTi/8ruf5/k4XzC8/Xb7VkiwNaVzcAAADQOjPeSB6bkFxxcnLuscmz9zUv/3rbJL0HlCY2AAAAAAAAAEpvxB6tL2Po5knvga0vBwAAAAAAAAAAAAAAAAAAgMK9+eab2X777fPvf/+74DwnnnhizjvvvHTq1KmEkQEAANWge+c+OXr09dlqzeMKzjNn4bs556Fd8vC0v5UwMgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKBUaisdAADVbf7s5P7LkrOOSp69v3l5R+1TkpAAsvHOySrrNS/PvZckl52UzHizuLE8NiG58JvJvJmF5xn9yaRTl+LGAQAAALTMe68mV5yS3PX3wvPUdko23KFkIQEAAAAAAABQQr0HJEPHtL6cmtpk+K6tLwcAAAAAAAAAAAAAAAAAAIDmmTVrVvbYY49ceumlBec56qijctVVV6Vnz54ljAwAAGjL+vUYnOO3vCfrDSz8F0i9PfuZnHHflnnhvTtKGBkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQSrWVDgCA9mH+7OSKU5IpNxaeZ42NkxVXLVlIQAfVpVsy7pjm5bnlrOTOv5YknCTJm88l409JFi0oLH3PFZONdypdPAAAAEDz3XNh8sh1hacfMrp0sQAAAAAAAABQOpvsktR2Kk5Zw3dPUlOcsgAAAAAAAAAAAAAAAAAAACjcwoULc+ihh+b3v/99wXn22muv3HLLLenfv38JIwMAANqitfpula9seX9W6b1xwXmef/f2nHHflnlnzrMljAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAotdpKBwBAO1KfTPhD8s5LhWdZe1TpwgE6ppH7JL37F57+gfHJQ1eWLp4PvDo1uev8wtLW1yerb1TaeAAAAIDmu/XsZO6MwtKuun5pYwEAAAAAAACgNIbv3nSad19JFsxpOl2fQcmQ0a2PCQAAAAAAAAAAAAAAAAAAgOarr6/PV7/61Xz/+99PfX19QXm23HLL3H333VlrrbVKHB0AANBWjFjl4Bw75tb07jao4DwPvfrXnPPQLpm76L0SRgYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUQ+dKBwBA+7J4YXLbuckBPy4s/ZqbJpOvL21MQMcycs/C0776RHL7uaWL5eMevCLZZJdk4NqN73/rP8njtyRP3J7MeKN8cQEAAACFWTgveerOZOReTaft1ivp2TeZM730cQEAAAAAAABQHGuPTFZcpel0k29MBq6VbLpr02lH7Jm88HCrQwMAAAAAAAAAAAAAAAAAAKCFTjvttLz22mv585//nM6dm/5TvhtssEHuueee7Lbbbpk6dWoZIgQAACplx6E/yK7DTk1NTU1B6evq63LTM9/PbS/8vMSRAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC0f127dk2fPn1SU1OT2bNnZ86cOZUOqc1zzpavtrY2ffr0SZcuXari/Kywwgrp0aNH5s6dm5kzZ5akju7du2eFFVbI/PnzM2PGjJLU0RIdtS135GteU1OT3r17p0ePHqmrq8v777+fRYsWVTqsqlVt/V2pddQ+pVh69uyZXr16Zf78+Zk5c2bq6+srHVKjevXqlV69emXBggWZOXNmFi9eXOmQSqatt+m23gd90KbnzZuXWbNmtdk23d51pHt2Waqlf23r9/QHevTokd69e6euri7Tp09vc2PJamvzHXlu8oFqafutZS7WQJuH4qqWcQ7LV23jlw98EPecOXMya9asSofTZlXr3Lha22WlGOtVjmfh0qrl/q3W/rEatfW1HEqrGsZsHWVtCICW6VzpAABof154OJk3M+m+QtNp+69R+ng+0KVH0melpEv3hq+a2mTxwmTRvGTO9GTmO0mqYf2kJundP+naM+nWs+FY6uuT+bOT+bOSOTOShXMrHWTTevVPuvduOI4u3ZO6RcmCOcn8Ocmc95OF8yodYXXqPTDp3ivp1jvp1CVZND9ZMDeZ9XYyr22uWxTV2qOSfqsVlnbxouT6/03q60ob00fV1yX3XZrs/Z3/2zbjzeSJ25KptyRv/6d8sXxUpy4N92TXHg1fnbs1bF+8MFm0IJk3I5n1bsP31aqmNum7csO90bVHw7aF8xr6nJlvNdwrpdJ7YNJjhaRbr6S2c8N5XDg3mfFWw/OSpXXq0vDM7tqz4aumtuEaLZzXcM/Mn13pCJtQk/Qe8P/7415Jp67/1x/PnZ7Mfq/SAVKIdjN2rGLt/RpUfV/XjrX3tlcMHX3eUc207/bBmkrlvTI1GblXYWl79G24v6pdu1w7aCfrrLR/nt/tU3vrVzvCHKEjjMFqahv6m269GtplbeeG6zh/dsMxWquoHh2hvSbW11qkpuGc9VihoW24z9uBdv5Oqr2NmT7OO+yWM08qvq49G9pDt14NfUptl4bPuCyY0/A1b1Yy1+8UKQ1rVEXTZN/wdqUjXL72/tyjOlT7M9bzrLw6Sr/VHtYfOsL6bSmM2LPpNHWLk8f/3fAzMZvu2nT6YVslPVdsWIeh9Kr9udaU9tA/tQe1nf5vfeeDduY6VNYHY8K+g4wHP6q9jN2M+UvHuQUAAAAAAAAAAAAAAAA6kvPOOy9vvvlmLrvssvTs2bPJ9KuvvnruvPPO7LPPPrn77rvLECEAAFBOnWu75cBN/pJRq36m4DwLFs3OJY8enqlv/rN0gQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtFNjx47NTjvtlC222CIjR47MwIED07179yXSLF68OK+99lqmTp2aSZMm5brrrss999yTurq6Zte39tprZ8CAAUttnz17dp566qkWH8fydO7cOcOHD19qe11dXR555JFml1fOc7bKKqtktdVWW+b+YcOGNbq9X79+GT16dLPqWrBgQR577LFm5WlMjx49sscee2TXXXfNiBEjstFGG6VPnz5LpFm8eHFefvnlPProo7n33nvzz3/+M0888USr6/6oxo5/2rRpef3115faXlNTk5133jkHH3xwjjrqqHTq1OnDffX19XnllVfyyCOP5JZbbslll12WadOmtSieww47LGPHjs3w4cOX+JvOCxYsyNtvv53HHnssN9xwQ66//vo8/fTTza6jucp9/5dSS6/31ltvnfXXX7/DXPNu3bplp512yu67757hw4dn4403zoABA1JTU7NEupkzZ+bdd9/N5MmTc8cdd+T222/PQw89VPL4iql79+7ZaKONlrn//fffz/PPP9+qOird3zWn3X+gd+/eGTVqVIYNG5Y+ffpkhRVWSG1t7Yf7f/WrX2XOnDktiqdSfUpNTU1GjRq1zP0TJ05scdmt0dzrM2DAgOy///7ZZZddMnLkyAwdOnSpvumtt97Ko48+mgcffDD//Oc/c//995cs/mUZMWJEPvWpT2WLLbbI8OHDs/rqqy/RhpJkxowZefzxxzNlypTcfPPNueGGG1rcrpZnWWOdYl3ztv6crHQfVIivf/3r+cQnPpERI0Zk7bXXXqpNv/jii5kyZUomTJiQK6+8Mq+++mrZYmuuahyXJ23rnq2UPn36ZO+9987ee++dkSNHZt11103nzp0/3N9W+tdquKeTZPPNN88+++yTzTbbLJtuumlWX331Je7tpGF+/8QTT+Thhx/O9ddfnxtuuCELFy4sS3wtafPjx48vagzmJs1TLW2/tdrzXEyb/z+rrrpqVl111aW2NzVPa67Gznl9fX0mTZpUtDqWpS2OiUo9L2jL2sI4p72e/3IeV1saszd3LWOllVbKQQcdlB133DGjRo3K0KFDP9z3QX/7xBNPZMKECbn55pvL0k+1NWuttVb233//qpsbt6V2WQ3a0livra0ZN1e1ram2xfNdLfdvW+wfyzWeT8o7pi/HWk5bnCe0RcUYY7Z2vPbxe60tjNk6ytoQAMVTU19fX19Qwo9NygBoW47+U7LS4KbTPf9QcvkPSh5Odv1qMnLPptPV1yW/LCBdoXoPSDbbN9l4p6R3/9aVtWhBcuE3kjeeK0pozTZs62TzfZM1NklqOzWZfJkWL0peeDC579Jk2pNFC68gq66fbHFgMnSLpEu31pX17ivJ5BuSR65PFs4tTnwfNWTzZL8fLT/NlBuTf53Z+L6VhiQj9kw2+ETSs2/T9f3ps8mMN5sfZ5J07pqM3CvZfL+kz6CWlVG3OHnu/uSeC5du4z1XTL5ySWHl/M/uLau/FDp1Sb42vuH8NGXxouSsI5NZ75Q+rraic9dk+O4NbWfg2sUp863/JJOvb7g3Fxf5s2ytuSdXXjf5xFHJkM1aVvf82cnDVyUPXpHMn1V4vgFrJdsdmaw7NmnJ9GnxomTqvxvuy5b2D40p5FwmyRvPJhd+szTlL+tademWjNw72eKgpNeKza87aRhLPHtfcs/FyRvPtKyMlurUJRm1dzL6U8mKq7S8nHdeTh66Inn05ob++eO++LekV7/ll/HrT7a8/mJrqk20ledpUvyx49P3JA/+o3Xjx+2OTMYc0HS6+rrkz0cns99reV1NOerMpP8aTaf7yxeT919rWR1t8Ro0pj33dV++OOnWq+l05x6bTC/uO97s9V/J+ts1ne7Ws5NJ1xS37qR47a+Uba+Sqn3eoW23/b61WHb7WsOxNqVT56Smtul0ixc19Lst8fgtyY2/bVnexhRrXaXUayrl0NbWPlddPzni9MLSXvjN5NXHm1f+0DHJgT9pOt3rTyfnf7V5ZS9Pta0dFKqtrrNW5DrXJLt+Jdlkl8KzzHir4b76+Ji/V7/k2L82vQbywOXJXec3O9JGFTIuXzg/+cOhSd2i1tfXpXvy5YuS2s7LTzdvVvLHw1v+/Eiq5/ldynZbqb6vlNpbv1rtc4RCdJT3Wt16JaM/2bCu2Zq1ihcfabiWr0xtWRkfqMYxfanX3QtRTe01ad/ra6VUyPOxsWdjTW0yYo+GPruQNd7GtPY+3/azDW20EONPTl4s4eftN9w+2aOAe/H1Z5KLvlW6OFqjPb+TqqYxk3fYzc/fGtUyT6qmzxv1Wz0ZsXuy8c5N3+uFWDAnefru5P5/JO+81Pry2ru2ukZVTW04qf73e235udeR52Y+p9FylbiXPM/Kqy33W43pyOsPHWH9tpw23y/Z8YtNp7v6tOTJOxr+v83hDV9NeW9acvYxrYuvOdrau/Ziq5bnWnvpn6pxzPhRrXkfWVPb8Ezc4sCk37J/D8xy+Rxo8T4rV8wxYSnGg5V6j1RtY7dlaWtj/mrv+z6qrZ1bAAAAAAAAaAsK/LXsjfK72oFlGT58eIYPH56koZ95/vnnc99997WqzwEo1B577pEdd9yx0mHQgbzwwgs58w/L+AFEgHbgmGOOyYYbbVjpMOgg7rnnnlx5xZWVDgOgZL73/e+lX78i/FALFOCK8Vfk3nvvLTj9hhtumJtuuilrrrlmQekXL16cY489Nn/5y19aGiJAi6244or5/g++X+kw6GD+91f/m9dfL/IvKwBoI3b79Ea56Lxr07/nkILzTJvxSM6buHdmzH+1hJHRXrWH39MG0JbV1NRk8803z3rrrffh572nTJmSKVOmVDgyAACqzak/OTU9evSwRg5QZh98zuwPZ/wh//nPfyodDkCH8aUvfylDhgzJueeemyefKMIfRwSgSR/87GJzP/sOQOvst/9+GTt2bK6/7vrceuutlQ4HoMP44Pdi3XLLLbnh+hsqHQ4AAI3wu9qBUvC72oG2Zocddsiee+1Z6TDogKyNAh2J5y2V4FkLdCT+NhmV4DOXQEfiWUul+BkzoCPZ5SvJqL0rHQUdzc2/Tx65rtJRAJSX39XetvhMLSzbuHHjctZZZ2X99dcvSnmzZ8/OSSedlDPOOKOge6xHjx55/fXX06dPn6X2HXHEEbnggguKEtdHXXnlldl3332X2n7ooYfmkksuaTJ/Jc/Zj370o/z4xz8uSr1NOfvss3Psscc2O1+XLl3y4x//ON/+9rfTpUuXVsfxwAMP5IgjjsjTTz/dqnIaO7ff//73c9pppyVJOnXqlN/+9rf5yle+0qLyZ82alSOPPDJXXHFFo/tra2vz85//PN/+9rdb/LNgixcvzje/+c387ne/a1H+j6v0/V9Kpb7eSXVe89ra2px44ok55ZRT0rVr16KU+dBDD2X//ffPyy+/3KpyltVmWvuzk6uvvnpuvvnmbLTRRo3unzx5cnbfffcW/Q78ttbfNdXuk4Zx8fnnn58RI0YUVObKK6+cN998s6C0baVP6dmzZ2bPnr3M/ZX6edxCrs8xxxyT3/3ud+nVq1er6nrmmWfy2c9+Nvfdd1+rymnMbrvtlrPPPjtrrrlmq8uqq6vLn/70p3znO99Z7jUrVLH7kbbSppelrfVBjVlllVVyzjnnZK+99mpxGfPmzcv3vve9/OY3v/lw26233prtt99+qbTjxo3LHXfc0eK6mqMaxuVJ275ni6WQe/+Tn/xkzj777AwaNKhVdZWyf62GezppmKf/9re/Tf/+/Vtd1htvvJGjjz46N9xQvJ9DKFabL2Z7NzdZvmpp+63VludixabN/5+f/OQn+cEPfrDU9o/PA1qja9eumT9//lLb582blx49ejSrrJaMp9vimKhU6wuVUI3jnGKd//ZaTmPa8pi9kLWMz372s/njH/+Ynj17triea6+9NocddlhmzJjR4jLaqmLMi5Pyz43bartsq/d0Wx7rVXrNuLXKtaZayudguc93W71/P64a+sdyjOeT4o7pG1OJtZy2OE8oprb0PCrXeC0p3Zito6wN0dC2x4wZk3XXXdfnaYGCFfJevXMZ4gCgA5rzfmHpamqTTl2SxQtbV1/Xnsm2n234we9ORXq6de6aHPmH5Kk7k3+flcx6uzjlNmWDTyTbHpH0b/36VJKG8zFs64avx29Lbjun9MeyynrJ9p9P1hpevDL7r5Hs8IVk7GeSh69K7rskWbSgeOXX1DRc8+Wp7bT0tm69kh2OTYbvVrxYlmfjnZJxn0t6t3KtqrZTsu7YZNhWyZSbk1v+lCycV5wYK2X1jZq+hh94+q5k1juljafNqEk2+2Sy1SFJr37FLXqlwcnOX0q2/HRy69nJk7cXr+yW3JO1nZLtjkq2OLAhf0t169XQ14zYI7n+f5MXHmo6ju2O/P/11ra83k6dG/qSDccld5zX0NcVQyHn8oP6S1V+Y/3n2qOSPb6Z9FmpZfV+WH/t/+/Ptk6m3JTcclaycG7ryizEBuMannWtjT9JBqyZ7Pa1ZPSnkht/m7z25JL7O3UpvH9rC5pqE23heVqqseNG2zd8tWb8+Ni/k60PLSztBp8oXl/xcYOGNnw15eXHkvdfa375bfkaNKY993WF9jGl+OxgbafC6q5txfO1McVuf6Vse5XSHuYd2nZxyqyG9l3bubhjpdacu+lvFCeGYq+rlHpNpUNqRt9RFb+PqUrXDprSHtZZi6m2U7LXfyUbbl94nndfTi49KZnZyHHOfi9564VktQ2WX8bQLZK7zm9WqMu0zpZN9/mduyZrbJK89Ejr61t7VMPztSkvTkrq61pWR0d9frd77bBfbQ9zhOXpSO+1NhiX7Hx80nPFVtZfmwwe3fD1n4nJTb9Lpjf/9w0lqc4xfanX3ZenGttr0r7X19qa1TdKdv9Gw7uH1vj4fX7z75u3Fjz1Xw1tqhAb79QwpiqVDT5R2D37ZHl+z06ztdt3UlU4ZvIOu3TvpT6q2uZJ1fB5oy7dG9rD6E82HktLde2ZbLJLsvHOyXP3Jbf8uWXvDdu7tr5GVQ1tOGkH7/eq4LnXkedmPqfRcuW8lzzPyqwK+q3GdNT1h/a+flsJI/ZoOs382ckzH/k7rY/9Kxl7WNNzv36rJWsOT172c+GtUm3PtfbSP1XjmLEYVl4n2eNbhY3VlsfnQFtfVynGhKUYD5b9PVKVjt0+rq2O+dtD39dWzy0AAAAAAAAAAAAAAABAW/DEE09k7Nixuemmm7LRRhs1mb5Tp04555xzssoqq+S0004rQ4QAAEAp7LLLLvnHuf/ICj37Fpzn8TevycVTDs2CxbNLGBkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQPtyzDHH5Oyzz05tbW3RyuzVq1d+97vfZZ999sn++++fWbNmLTf93Llzc9FFF+W4445bat9RRx2VCy64oGixJcmKK66YPffcc6nt06dPz5VXXtlk/rZwzsrlsccea3aeNdZYI9dee21GjBhRtDi22GKLPPLIIznssMMKukYt0alTp4wfPz6f+tSnWlxG7969M378+Bx99NH561//usS+Ll265Morr8xee+3V6jhPP/30rL322vnWt77VqrI6Ulv+uGJc76T6rvmKK66Ya6+9Nttss02ryvm4zTffPA8//HD233//3HXXXUUtu7XWX3/9TJgwIWuuuWaj+2+//fZ88pOfzIwZM5pddjX2d9tss01uuOGGrLDCCkUvuyP3KcXyu9/9LieccEJRylp33XVz11135Rvf+EZ+//vfF6XMTp065fe//32OP/74opSXJLW1tfnSl76UPffcM5/85Cfz6KOPFq3s1mrrbboa+qCxY8fm6quvzoABA1pVTvfu3fPrX/86o0aNyjHHHJNFixa1OrZq05JxeUe7Z5fnO9/5Tn7+85+npqam1WWVon9NquOe7tmzZy666KJWj6E/auWVV851112Xn/zkJzn55JNbVVax23y52ntHnZt8oBrafjF0xLnYsnT0Nk/rtGRM1N5VwziHZWsPY/af//znOfHEE1tdzt577537778/++yzT5599tkiRNY2FGtenJRvbtwe2mW5VftYr5RrxuVQrDXVcj0HS3m+q+n+rcb+sRq19bWcYjFPWL5ijdeS0ozZOsraEAClVbw3+gDwEXWLC0/b2s+XrT0q+fw5yeb7Jp06t66sxqy/XfL5PycbfKL4ZX/UCgOTA05NPvm9pH/jn9lttY22T44+M1l7ZGnK79wt2f4LyeG/SdYaXpo6uvVKxn4mOfpPyZolqqNQfVdJjvxDMny30tfVrXfyqe8ne/1X0rt/8cqtqU1G7J4c+fvStbtyGTy68LSP31K6ONqSFVdNPvPLZKfjk179SlfPCgOTT56U7PPdpHPX0tWzPF17Jof8ItnyoKQI7/+TNJyzg/472eLA5ac5/DfJlp9uuJ+KoUv3hmu294lJbafilNnWbHdUcvDPkj4rFa/Mmpr/35+dkfRfo3jlflyX7sme325o88WMP0lWGpwc9r/JiKV/ZrNdK+fzNCn92DFp3fjxvVeSVwp8d7PRjs0vv1CFlv3oTc0vu61fg2Kp5r6uPWsv88dSMe+oXh2lb23r3pvWuvylXldpS2sq1a5HMz67tmBO6eIohva4dtAe1lmLrVOXZL+Tkw23LzzP688mF347mfn2stM8fXfT5ay8TvHa1tAxxU3XlHW2KCxdIeehMZ7f7VN761fb+xyhI73Xqu2U7PGthnbTc8Xilj14dMNzcZNdiltuJbR2TF9KHam9fsD6WvONOTA59JfJgCL3rYNHJ0c18z5/b1ry0pTC0q43tnTPsy7dkyGbN52ubnHyxG2liaGl2vM7qfY2ZloW77Cbr6PMk8r5fnTtUcnnz0423690166mJhm2dXL0H5NR+5SmjmrUnteo2ts7/lL3Cx3luVdM5Z6b+ZxGcZTyXvI8K6+O1m9V8/pDe1+/rZTVN0oGrNV0uiduTxYv/L/vp7+evDK1sDo62mdEi63an2uFqub+qRzKNWYcvlty2G+SQUOLV2Z7ug7lVOoxYbWOB9vL2M2YvzAt6fucWwAAAAAAAAAAAAAAAICmvfLKK9l2221z7733FpS+pqYmP/3pT/O73/0uNcX6JWMAAEDZfPGLX8z111+fFXr3LTjPnf/5Tc6ftG8WLJ5dwsgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANqXY445Juecc05qa2ubTLtw4cK89957effddzN37tyCyt9ll11y6623pnfv3k2m/fOf/9zo9h133DFrrrlmQfUV6sADD0zXrl2X2n7xxRdn/vz5y83bls5ZOUydOrVZ6ddbb73cc889GTFiREHp58yZk/feey91dXVNpu3Ro0cuv/zyfPazn21WTIU688wz86lPfaooZZ199tnZbrvtlth20UUXZa+99ipK+UnyzW9+M1/+8pdbnL+jteWPK+b1Tqrjmg8YMCB33HFHttlmm4LSz5kzJ++8805mzZpVUPqVVlopV199dQYPHtziGIttzJgxufvuu5f5HLniiiuy6667ZsaMGc0uuxr7u3XXXbfh70WusEJRy030KcVw+umn54QTTihqmZ06dcrvfve7fO9732t1Wd27d89VV12V448/vgiRLW3w4MG56667sv3225ek/OZq6226GvqgnXbaKRMmTMiAAQNaVc5HHXHEETnvvPOKVl41ae64vKPds8vzta99Lb/4xS9SU1NTtDKL2b8m1XFPDxw4MLfffntRx9AfqKmpyY9+9KOcdtppLS6jlG2+1O29I85NPlANbb8YOuJcbHk6cpun9Zo7JmrvqmGcw7K1hzH7j370o5x44olFK2+DDTbIzTffnBVXXLFoZVZSKebFSWnnxu2hXZZbtY/1SrlmXA7FXlMt9XOwlOe7mu7fauwfq1FbX8spJvOEZSv2eC0p7pito6wNAVB6nSsdAADtU3Pev9S3op6tDkm2+2xS0/Tn1Fqla8/kk99LBq2T3FGCNZQ1Nkn2PznpXoa1xh59koN+mvz7T8mka4pXbu+ByYGnJoOGFq/M5em3WnLIL5I7/5bcd0l56vyovisnh/066d2/9HX16t9wrAOK+3NBS+i/ZvKZXyWXfjeZ/V7p6imltUcWlm7B3OSFiSUNpU1YY5PkgB8n3XqVr84Nt0/6rJxc9r1kYWGfBy6Krj2TQ/4nWWVYacrf/vMN/z5w+ZLb+wxKDv55Q39UChvtkHTumlz106S+6TW96lCT7PHNZNNdSldF/9X/f392UvLWC8Utu0ff5JCfJysNKW65H1XbKdntq0nPvsm9F5eunrainM/TpHxjx6R148cpNzX0401Zdf2GPui9aS2LcXk2HNd0mgVzkqfuaF651XINWqXK+7r2rL3MH0vFvKN6dYi+tUq892rL85ZzXaXSayrtQZ9Bhaed2/yfvy+b9rh20B7WWYutS4+G67zW8MLzvDQlueKUhjH/8jxzd7L955afpqYmGTw6mfrvwutvTP81khVXKSztOmOS285uXX1JMnTzptMsnJ+88HDzy/b8bp/aW7/aEeYIh/+mY7zX6tQlOfAnhb9HaYmuPZM9v9XQX1dzX9OaMX0pdbT3sNbXWmb7zyVbHFS68rv2aLjPB6yV3H5uYXkm31DYOLRrz2TYVsmTzVxvLsQ6WzS8b2vK8w8lc6cXv/6Was/vpNrbmGlZvMNuvo4yTyrn+9FNd2u4z2s7lb6uJOnSPdnly8nqGyXX/bIdfc6hBdrzGlV7fcdfqn6hozz3iq0SczOf0yiOUtxLnmfl1aH6rSpff+gI67eVMmKPwtI9dnPj29Ys4Hmy3tiGseK8mc2Ljep/rhWkyvuncinHmHGLA/9vDaYU2sN1KJdyjgmraTzYXsZuxvyFa27f59wCAAAAAAAAAAAAAAAAFO69997LTjvtlMsuuyx77713QXlOOOGEDBo0KEcccUQWLlxY4ggBAIDWqq2tza9+9at84xvfKDjP4rpFueqJr+T+V84qYWQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAO3P0KFD8/vf/z41NTWN7n/ppZfy97//PTfddFMeffTRvP/++0vs79GjR9Zff/1ss802OeCAA7LDDjs0Ws7mm2+es88+O4ceeuhy45k0aVImTpyY0aNHL7G9pqYmhx9+eH72s58VfnBNOOywwxrd/pe//GW5+drKOfvPf/6T2267bZlxDhw4MJtssslS299+++089thjy8zXmEcffbTgtP37989NN92UNddcc5lpHnrooVxyySW5+eab8+yzz2bu3LlL5N9ss82y66675sgjj8xKK620VP7a2tqcc845eeGFF3LnnXc261iWZ7/99suxxx671PZnnnkmf/3rX3P++edn3rx56devX1ZbbbWMGzcuBx98cDbaaKNGy+vcuXPOPffcbLLJJlmwYEG+8Y1v5MADD1wq3bvvvpsLL7wwN954Y5588snMmDEjvXr1ysorr5zNNtss++67b3bddddlxv2rX/0qt912W6ZOndqs420rbblSmrret99+e1588cV2dc1rampy8cUXZ9NNN11mmn/961+5/PLLc/fdd+fpp5/OggULPtzXpUuXDB48ONtvv32OOOKIbLfddo2W0a9fv1x55ZXZaqutMn/+/GbFWGy77rprrrjiivTq1avR/WeddVaOP/741NfXN7vsauzvOnfunPHjx6dPnz5Npl28eHGzzktH71OK4cgjj8xXv/rVpbbPnz8/N954Y66//vpMmjQpr7/+eubMmZNevXpl0KBBWXfddbP77rtnzz33zMCBA5dZ/k9/+tM8++yzueyyy1oc49///vfstddey9xfV1eXO++8M9dcc00eeuihvP7663nnnXfSs2fPrLzyyllnnXWyxx57ZK+99sqAAQMaLaNPnz655pprss0222TKlCktjrW12nqbroY+aL311sv48ePTs2fPRvfPmzcv//rXv3L99ddn8uTJefPNN/Pee++la9euH45ld9555+y3337p16/fEnkPP/zwiraPj2qr4/KkY92zyzNu3Lj8+te/Xmp7W+pfq+Ge7tatW6655ppsvvnmy0yzaNGi3Hnnnbn++uvz4IMP5o033sg777yTmpqa9O3bN+uuu2622267HHrooVl77bUbLeOkk07KU089lb/97W/NjrHUbb5U7b0jzk0+UA1tvxg64lxseTpym2/P2vKYqD2rhnEOy1ftY/Zddtklp5xySqNx33LLLbnqqqvy8MMP5+mnn06fPn2y0korZeTIkdlzzz2z1157pXPnzo2WO2TIkFx00UXZc889ixpvuTU1L07a5ty42ttluVX7WK+Ua8blUMo11VI8B0t9vqvl/q3W/rHatIW1HPOEyit0vPbqq69m9uzZZR+zdZS1IQDKo/EnFgC0UrfGP3u6lLrFyaIWrtvtcGwyZv+W5W2prQ5OOndNbjmreGVu8Ilkz283lFsutZ2SXb6cLF6QTLmp9eWtNCQ58CfJCst+f1YSNTXJJ45KVlw1uen0pL6uPPV26Zbsf0rSu3/p61phYHLoLxuOsdR69k0+fVpy+Q9LX1ex1dQmg4YWlvbVqUndotLGU2mDN0v2+1FDWy231TdM9j85uex7Zbona5J9vpusMqy01Yw7Jnnj2eTFRxq+79ozOei/k36rlbbe9bZJPnF0cvu5pa2nXLb/fLLpLqWvp+eKDdfn/K8ls94uUpl9k0P+JxnY+Jp/0W13ZDL9jeTxW8pTXyWU83maVGbsmLRs/PjUHcnOxzf0NU3ZcPvknotaHF6j1tw0WWHp9wZLeeKOZGEzxvLVdA1ao5r7uvasvcwfS8W8o3p1lL61Wrw3rWX5KrGuUqk1lfZinS0LSzdnejL7vdLG0lLtce2gPayzFlv33slBP01WXb/wPM/el1z102TxwqbTvjctefvFpufKQ8ckU/9deAzLKqNQA9ZK+qyczHij5fUNHFzYvOg/Dzf/HYfnd/vU3vrVjjBHWGlI4e8ViqUiY7D/v4a+9sgy1JX/39d0S275U3nqK7aWjulLqaO9h02sr7XE5vslWxxUnrq2PKjhefevM5tO+/RdybwvJd1XaDrtRjsmT97R+vg+br1tC0s39V/Fr7ul2vM7qfY2Zlom77CbraPMk8r5fnSDTyS7f73hmV5uG+2QdO2R/PO/2//ncxrTnteoOsI7/mL2Cx3muVcClZib+ZxGcRXrXvI8K6+O1m9V8/pDR1i/rZSuPZP1G/+9NUt499Vk2pNLb3/yzmTnLyVdui8/f+euycY7JQ//s0VhdljV/lwrVDX3T+VU6jHjJrs0XItSq/brUA6VGhO29fFgexm7GfM3T3P6PucWAAAAAAAAAAAAAAAAoPnmzp2bfffdN+ecc06OOuqogvIcfPDBGThwYPbdd9/MmjWrtAECAAAt1qtXr1x88cXZZ599Cs4zd+H7uXDyp/PMOxNKGBkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQPv0m9/8Jj179lxq++LFi/P9738/v/71r7Nw4cJl5p87d24eeeSRPPLII/nDH/6QUaNG5ayzzsqYMWOWSnvIIYfkH//4R6644orlxvTnP/85f/rTn5bafvTRR+dnP/tZAUfVtNVXXz3jxo1bavvjjz+eBx98cLl528o5O//883P++ecvs55PfvKTueqqq5baftddd2W//fZbZr7WuvTSSzN48OBG973wwgv5+te/nquvvnqZ+d99991MmDAhEyZMyMknn5yvfe1rOfXUU9O5c+cl0nXp0iX/+Mc/sv7662f69Omtjrtnz575/e9/v8S26dOn5+tf/3r+9re/pb6+/sPtb7/9dp555pncfvvt+clPfpJjjz02v/nNb9KjR4+lyl133XVz3HHH5ZprrsnPf/7zJfbV1dXlV7/6VX7yk58s9beX33777bz44ot54IEH8sc//jHbbrttzjvvvAwbNmypOrp3757f/va32WWXXZp1zG2lLVdCc6530n6u+de//vVl5rn//vvzxS9+MZMnT15m/oULF+aZZ57JM888k7PPPju77757LrjgggwYMGCptCNHjsznP//5/OEPf2hWjMV06KGH5m9/+1u6dOnS6P6TTz45p556aovLr8b+7itf+Uo23XTTRmO58sorc+2112bKlCl54403Mnv27GaV3ZH7lGJYZZVV8p3vfGeJbXV1dTnzzDPz05/+NK+//vpSed5555289NJLeeihh3LxxRenR48eOeGEE3LSSSdlxRVXbLSe8847Lw899FCef/75Zsf4ox/9KAceeOAy91977bX57ne/m6lTpza6/6WXXsqDDz6YSy65JN27d8/Xvva1nHTSSenbt+9SaXv37p1rr702I0aMyHvvvdfsWIuhrbfptt4HdenSJVdeeWWj1zdJzjrrrJx66qmZNm1ao/tfe+21PProo7n44otzwgkn5Mtf/nJOOeWUJa7JT37yk7zxxhsFx1QqbXVc3tHu2eU599xzU1tb++H3ba1/Tdr+PZ003LdbbbVVo/vq6+vzj3/8Iz/4wQ/yzDPPNJrmzTffzDPPPJPrr78+P/jBD3Lsscfml7/8ZXr16rVU2jPOOCN33HFHXnjhhYLjK0Wb//h4Pil+e++oc5MPVEPbL4aONhdbno7e5tuztjomau+qYZzDslX7mL1Hjx45++yzU1NTs8T2K664IieddFKefvrpJba/8847eeGFF/LAAw/kz3/+c9Zdd92cfvrp2WOPPRotf4899sjhhx+eCy64oCjxlltT8+LFixfnnHPOaXNz42pvl5VQ7WO9Uq4Zl1o51lSL/Rws5fmulvu3WvvHatQW1nLMEyqrueO1pPxjto6yNgRAedQ2nQQAmq9X/8LSzZvZsvLHfiYZs3/L8rbW5vs1fBXDkM2TvU9MOnctTnnNtdvXkqFLfy6vWfqukhz8s2SFgcWJqSWG75bs8pXy1bfDsclKQ0pfT6cuyX6nJCuuWvq6PtCrX7LPieWrr1j6DGo4X4V4+bHSxlJp/ddM9v1h0qVb5WJYe2Sy7WfLU9cWBybrbFH6empqG/rrrv9/PX3v7yQD1ip9vUmy5UHJmsPLU1cpbbhDssUB5auv94Bkn+8mqWkyaZNqOyX7n5IMXLv1ZTXH7l9P+q9R3jrLqVzP06SyY8ek+ePHhfOTJ24vLO1GO7YspmKUOeXGwsustmvQUtXc17Vn7WX+WCrmHdWro/St1WL2+8mCOc3PV+l1lXKvqbQH/dZIBo8uLO20x0sbS0u1x7WD9rDOWmy9+iWf+d9k1fULzzP138mVpyaLl/3z30t5+u6m0wzeLK0esw5t5vrP0M1bWV+B1/Opu5pXrud3+9Te+tWOMEf4YAxWKeUcg215ULLeNuWp6wOb75uM2ru8dRZDS8f0pVTp+UJS/jmD9bXmW3G1ZPvPl7fO0Z9MNvtU0+kWL0ym3lJYmUM2T7qv0Lq4Pq5zt8LGkfNnJ8/eV9y6W6o9v5Nqb2Om5fEOu3k60jypXO9H+62e7P7NpKaCz7dhWyU7lPn51Ba09zWqjvKOvxj9Qkd67hVbpeZmPqdRfK29lzzPyquj9VvVvP7QEdZvK2mjHZIu3ZtO99iExrcvnJs8c09hdY1o/PcPsAzV/lwrVDX3T+VU6jFjn5WTXU8oXfkfV63XoRwqPSZsq+PB9jJ2q/T1TdruNW5Mc/o+5xYAAAAAAAAAAAAAAACg5RYvXpyjjz46v/jFLwrOs9NOO+W2227LoEGDShgZAADQUmuuuWbuvvvu7LPPPgXneWfOc/nD/VvlmXeW8UunAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYpgEDBmTPPfdsdN/BBx+cX/ziF1m4cGGzypw0aVLGjh2biy66qNH9p5xySpNlXHTRRZk9e/ZS29ddd91stdVWzYpnWQ499NDU1NQstf0vf/nLcvO11XPWVhxxxBHZeeedG913xx13ZMyYMbn66qsLLm/OnDn52c9+lp122invvffeUvtXXnnlnHbaaS2O96OOOeaYrL766h9+//zzz2fUqFH561//mvr6+mXmq6+vz1lnnZV99903CxYsaDTN1772tZx22mnp2rXrh9vmzp2bPfbYIyeeeGJmzZrVZHx33XVXxo0blxdeeKHR/TvvvHPWX3/9Jsv5QEdvyy293kn1XvO+ffvmhz/8YaP7zjvvvIwdOzaTJ08uuLwkufHGG7P11lvnnXfeaXT/t7/97dTW1jarzGI54YQTcuGFF6ZLly5L7aurq8txxx2XU089tcXlV2N/17Nnz3z/+99fYtu8efNy2mmnZciQIfn85z+ff/7zn3n++ecbfQ4vT0fvU4rhC1/4Qvr27fvh99OnT89OO+2UE044Ia+//npBZcydOzf/8z//k5EjR2bKlCmNpunZs2dOP/30Zse36aabLrMPWbhwYT73uc9ln332ydSpUwsqb968efnFL36RTTfddJmxrrnmmvn1r3/d7FiLoa236Wrog77xjW9ko402anTfu+++m+OOOy7Tpk0rOL5f/vKXGT58eJ555pkPt3fr1i1rrbVWs+LqKDraPduUddZZ58P/t7X+NamOe3rXXXfNkUce2ei+uXPn5tOf/nQOPvjgJe7R5Vm8eHH++Mc/Zsstt8xrr7221P7evXvnJz/5ScHxlarNl6O9d8S5yQeqoe0XQ0ebizWlI7d5KIW2Ps5h2drDmP2YY47J2muv/eH3CxcuzJFHHpkDDjggTz/9dJP5n3nmmey1117505/+tMw0J554YlFirYSm5sW77LJLm5sbt4d2WW7VPtYr5ZpxORR7TbUxxXwOlvJ8V9P9W439YzVq62s5lEdrx2tJacdsHWVtCIDy6VzpAABonwau3XSaJJk3s/llr7dtsu1nm5+vmHb4QvLGs8nLj7a8jIGDk099L6ntVLSwmq2mNtnjW8lfjk3mzmh+/u69k4P+O+m5YtFDa7aReybvv5Y88I/S1rPqBsmIxj8jWXS7npCsMqw8dX1U/zXLX2dr9Vu96TQfeKvxzzS0C126Jfv+IOnavdKRJFt9OnnituTt/5SujhVXTTZufJ2sJHr1S7Y6OHnrP8mw4vyMXsF2/Upy7heTLP8zQm1Wr37Jzl8qf71rbpKM3Ct55NrWlbP955PVNixOTM3RuWuy+9cbntftTTmfp21h7Jg0f/w45cZkxB5Np+u/RrLysIayi6G2c7L+tk2ne+el5LUnCyuzWq9Bc1V7X9detYX2V+q211rmHdWpLbTtpO2373J679Xm52kr6yrlWlNpDzp1Sfb6dtKpwLdrT9xW0nBapD2uHbSHddZi67NycvDPkn6rFZ7n4X8m/17255yW6em7k7GfWX6aHiskq65f+Bzi47p0bxj3NsfQLZJHrmtZfUkydEzTaeoWJ889UHiZnt/tU3vsV9v7HKEjjcEGrJVsskvpyl+eHY9r6GumtbDvr4SWjOlLqa201aR8cwbray3TvXdl6t3h2Ib7/JUmftZmyo3JZp9qurxOnZP1t0smX1+c+JJkyGaFPaOfvDNZ3Lzfg1Qy7fWdVHscMy2Ld9jN05HmSeV8P7rz8W3jftts34Zz+vTdlY6kPNr7GlVHe8ffmn6hIz33SqGSczOf0yi+1txLnmfl09H6rWpff2jv67eVVshzoL4umfrvZe9/9OZkox2bLmfg2g1rANOeKDy+jqo9PNcKUe39UzmVeszYs2/TaYqtGq9DObSFMWFbGw+2p7FbW7i+Sdu7xsvSnL7PuQUAAAAAAAAAAAAAAABove9+97t57bXX8pvf/CY1NTVNpt9ss81y9913Z9ddd80LL7TjP5AGAABVZsyYMbn66quzyiqrFJznhffuyvmT9s2che+UMDIAgI5j+x22r3QIAADN0rlzwx+uHjNmTGbOmlnhaAA6jm7duiVJRo0elcFDBlc2GIAOpG/fhj/SMXz48Ga9VwWg5QYMGJAkWW+99dKte7cKRwPQcay22mpJkqFDh6Y+9RWOBqDjWGuttT781+eIAMpr2qvT8vTTT1c6DAAAAAAAAAAAAAAAAAA6uL333vvD3/n7URdffHHGjx/f4nIXLVqUI444IquvvnrGjRv34fYbbrghv/zlL5vMP3PmzFx22WU5+uijl9p31FFH5b777mtxbB84/PDDl9q2aNGi/P3vf19uvrZ6ztqCHj16LDPWSZMmZdddd838+fNbVPYdd9yRz3zmM7n++uuX+lvGX/ziF/OLX/wiL730UovK/sCqq6764f/ffvvt7LDDDs0q8+abb84vfvGL/PCHP1xq39ChQzN06NAPv6+rq8v++++fm2++uVkxTps2LYcffnjuvvvuRvd/6Utfyte+9rWCyurobbm11zupvmveqVOn/O1vf8sXv/jF9OjR48Pt11xzTY455phmxfVRzzzzTL74xS/m8ssvX2rf4MGDs88+++Sqq65qcfkt8d///d/5/ve/3+i++fPn5zOf+UyuuOKKFpdfrf3dwQcfnIEDB374/ZtvvplPfvKTuf/++1tU3ke11T5l/vz5OfLII1tcfzl17979w//PmTMnO+64YyZOnNiisl588cWMHTs2//73v7PlllsutX/vvffODjvskFtvvbXgMs8666xGr/HChQuz++6755ZbbmlRrC+//HLGjh2b66+/Pp/4xCeW2n/UUUfl3HPPzV133dWi8luqrbbppDr6oH79+uVHP/pRo/vefffdbLXVVi2K77nnnsu2226b+++/P4MHD25RGR1FR7tnC9UW+9dquKc7deqUM888s9F9c+fOzfbbb58HHnigRTFOnTo1O+20U+6///6ssMIKS+wbOXJkunfvnnnz5jVZTqnafDnae0ecmyTV0faLpSPNxQrRUds8lFpbHOewfO1hzP7B7xVPGvrbAw44INdcc02zyqivr8/xxx+fYcOGZeedd15q/yabbJLddtstN910U6vjLadC5sXPPPNMi8ou5dy4PbTLcqv2sV4p14zLodhrqvfff39Jn4OlPN/Vcv9Wa/9YbaphLYfyKMZ4LSnNmK0jrQ0BUD5Lj4gBoJX6r5GsNLiwtG++0Lyye/VLdmvB+8YXH0mefyB5+bFk1jvJ3BnJ4oVJt15Jjz7JgLWStUcm622T9BnUdHk1tcke30rOOy5Z2II5fW3n5FPfT7r2bH7e+vrkjWeTt/6TzHk/mTs9SU3Dsay4arL6hoUdwwd6rZjs/OXkmp81P5bdv9FwvZurvi557ank7ReTOdOTuTOTzl0arm/vAcmaw5MeKzRdzseNOzp55bFk2hPNz1uoTxyVfGzeXBKDRyeb7tqyvHWLG87BO680tJF5s5JOnZLufZKBaze0kW69ihpuxfVfvfC077Tj9Y0tDmq4xoVaOL+hb3zh4eTN55PpbyQL5jT0j7Wdku4rJCsMSNbYJFl3m2St4YWXXVObjDsmGd/42nZRDB7ddJpZ7yQvTUneezVZMDfp0q2hrxmwdrLGxg3H2Ryb7ZssnNt0ugXzkpenJG+9kMyb2XA+evVL+q7c8Lxpbv8/YK1kg+2SJ+9oXr62Yt2xhaV7+8XktaeTGW80XK/OXZOeKzact7WGt+y5uc1hyWMTkkUtWzfNmpsmm+/XsryLFiQvP9pwb815P5k/+//aYO+BDWV37738MtbYpGV1t3Xlep62lbFj0vzx4wdjpUL69Y12bBgfFsOQzRv6/6ZMubGw8qr5GjRXNfd17VVL2l81tr3WMO+oTh2pb60m701rfp6WrqtMe6I611SqXfcVkv1PTlbboLD0M95Knr6ntDG1RHtbO2gv66zF1H/N5OCfJSsMbDrtB+46P7nnopbV9+ZzDe2i78rLTzd08+S1J1tWx9ojk05dmplnREOexQubX1/Xng3rRk15aXIyf1ZhZXp+t1/trV/tCHOElozBqvW91pqbFpbunZcbjm/Gm8n8OUltbcNaRa/+DdetqT6+MZ06J3t+K/nLcQ1toxq0ZExfSh3xPaz1tdJ599Xk9aeS919veO7UFOE+r+3UMKb4yxeXP+Z664WGNrnq+k2XudGOyeTrmx/Lsqy/9M/yNGrqhOLV2Rrt+Z1UexszLY932IXraPOkcr0fXWW9hvd9haqvaziXzz+YvPV8w5rWgjnJ4kUNbbFL94Zr1X+NhntuyOYNayCF2um45LkHWjY/ryYdYY2qPbzj3+XL5ekXOtJzrxQqOTfzOY2284z1PCuvjtZvVfP6Q0dYv62klddJVh7WdLqXJicz31r2/hcnN/RDfVZquqwRe3pH35T28FwrVDX3T+XWFtbzXYfSa+2Y8O0X2+d4sL2M3Yz5m6/Qvs+5BQAAAAAAAAAAAAAAACie008/PW+++Wb++te/pmvXrk2mHzZsWO65557svvvumTx5chkiBAAAlueAAw7I3//+9/To0aPgPBOnXZDLH/tcFtcvKGFkAAAdy1577VXpEAAAWuQT4wr8I2gAFNXYsQX+4n4AimrMmDGVDgGgw9lk002yyaYl/KPiADRqgw03yAYbblDpMAA6nGHDhmXYsAL+cDAARXPPPffk6aefrnQYAAAAAAAAAAAAAAAAAHRw66yzTqPbzz///FaXXVdXl2OOOSaTJ0/O5Zdfnl/96leZOnVqwfnPPvvsHH300UttP/jgg/O1r30t8+fPb3FsG220UUaMGLHU9uuvvz5vvvnmcvO25XNWaYcddlhWXnnlpbZPnz49++23X6uuWZLceOONOeOMM3LCCScssb1Tp0756le/mm9/+9utKv+jjjzyyLz00kvNzvfzn/88xx13XFZaaaXlpvvlL3+ZG2+8sUWx3XPPPbniiiuy//77L7Vvt912K7gcbfn/tPR6J9V1zd9999184xvfyGmnnZZvfetb+fKXv5yFCxfmyCOPbFFcHzV+/Pg89NBD2XzzzZfat9NOO+Wqq65qdR2FqK2tzVlnnZXPf/7zje6fPn36/2PvvsOkqPL9j38mwjDkOGQYcpAMCoIEUYKIYQ2romtc0/5WN+m6QV2ud13X6xpXvbhiFgXTIhIVkCQZBsk5wxAHmIHJ8/ujLy443dOnu6u6q6rfr+eZR6z61jlnuk+d8z2nemY0evRozZs3L6J63Drenfv7RY4fP66+fftq+/btEbX1LKeOKSUlJZa0Idruv/9+rVy5MqIy8vLydN1112nVqlWqW7duufMPPfSQ5syZY1TWwIED1bdvX7/nfv3rX2v27NkRt/X666/XqlWr1KhRo3Ln//CHP2jkyJER1REqp/ZpyR1j0F133aX09PRyx8vKynTLLbdoy5YtYbfv0KFDuvbaa7V06VIlJyeHXY6XxeM9a8pp46vkjnv62muvDTguPvDAA1q6dGlEbdywYYN+8Ytf6J133pEkLVmyRH/96181efJko+vt7PPR7u/xsjaR3NH3rRIPa7FwxVOfB+zmxDwHgXkxZ//jH/+oL7/8Muzr77zzTm3ZskWVKlUqd2706NGaMWNGJM2LOjvXxZI9a2Mv9stocHuuZ+eecbRZMRfaPQ/a9Xq76f514/joRk7fy0FsRJqvSdbmbPG0NwQAiJ74zQABALbpebV57P4NoZV96f1SWjXz+B3LpXlvSdnb/J8vyPN95VtNXcUAARkUSURBVByQti2R5v5L6jxUuuQOqUrNisuumSH1uU5a+L55e8666EapTtPQrsk9Kn03Qdq0QDqdU3Fsk85S/9ukZl3Myu4wUFr8kXR4h3l72g2Q2l5sHi9Jpw5LiyZImxdIZ04GjktIlBq1l3pdK7Xrb15+QqI04tfS2w9IJUWhtc1ERjspI4S/WVhcKOUdl4rypbKy88+VFAe+LjFJuvS+0Nt3fL+06ENp63e+fh2w/GSpVR/pwuulRh1Cr8eJamSYx548bF87YimthtT7J2axpSXSss+kpZMC34ulJb6x5nSObwxd8W+p6QXSiN/4xj8Tmb2lWk2k43vN4q10YJO04D1pxwpJZf5jKlf1jTMXXi8lpZiVm1LJ9xVI7lFp4QfS+m+kogB7dYnJvrFt8M+lqrXN6pV88+vGyH6ew5GK8qWsadKqL33jWCCJSVLLntIld0r1WpiXn15L6nSplDU1vPYNvjf0aw5s8s3ZO1dJxRXs2SYm+e6rC2+UWnQPr31uFK35VHJW7iiFnj+umS4NMeiDHQZJc95QwPEuFJ2GBI8pLZHWfWNWntvfA6s4fazzqnD636Q/+T/n1r5XEdYd7sXYer4106TdWcHj+vxEqtcyeFzWdGnv2tDbcSSEPRUpsn2VisZ7p+6puFlKJanrSKnvTVJadfPr5r/tvNfSi3sHXthntVKD1tL1/y1VqWEWX1Ymff2qL0+NxOaFUu/yPz90nsze4c8VmX1Cvyalsq8/7gzj87EtevhypWA2LzQvk/nbm7w2rsbDGiHUHMztz7UqUnhGWj1Vyvqq4r0KSardVOo6Quo+SkpONa+jdlOpx2hp+ecVx7k1p7dTPD6HDYb9tdAV5UtrZkirpkjH9lQcG+59XquR1OsaacnEiuOypkkN2wUvr0knqXp96WTFv8vSSFKK1NogjzyRLe11yO/38+ozKa/lTJHgGfb54mmdFM3no11C+F0ee76XZv1TOrKz4rjj+3z51ZrpvvGk/UDf61q94t9XIkmqVs+3t7bS2b+/JWJe36PyyjP+HcvtHxfcPO+xNvPhcxrlxWKOZT6LHjePW3Zw8v5DPOzfxlpXw9/b8/2sIAFl0vrZvhwxmPYDpG9ekwpPm9Udj7wwr1nBKeNTvOeMTnkf4oXVOaEX8kEv5W5uyvndNva56bUFAAAAAAAAAAAAAAAAAAAAAAAAADeYMGGCjhw5os8++0xVq1YNGp+RkaF58+bpqquu0ty5c+1vIAAAAAC/fv/73+uvf/2rEhISjOLLyso0c+vjmr39KZtbBgAAEH8WL14c6yYAAACEpFevXkpOTtaarDU6fYZfIg4A0dK9e3dVqlRJ69au06ncU7FuDgDEjY4dO6p69erauHGjcnJyYt0cAIgL7dq1U61atbRj+w5lH8qOdXMAIG60aNFCGRkZ2r17t/bvr+AP0QEALNW0aVM1btxY+/bt0549e2LdHACIKzt2xOiPQAMAAAAAAAAAAAAAAAAAAAAAAAAAcI5GjRr5Pb59+3ZLyt++fbsyMjKUl5cX8rXfffed1q1bp06dOp13vGbNmho9erQmTZoUdrvGjBnj9/j48eODXuvk1yzWHnzwQb/HX3zxRe3atcuSOp599lndf//9Sk5OPu/4mDFj9Nvf/taSOiZPnqypU6eGde3p06c1ceLEgK+FJO3fv19jx44Nt3mSfH312muvLXe8bdu2qlmzptHvL6Qv+0Tyfkvues/POnz4sH7/+9/rmWeeUYcOHXT8+PGI2nbWuHHj1KtXr3LHBwwYYEn5waSmpuqjjz7SNddc4/f8gQMHNHz4cK1Zsybiurww3t1xxx2W3e8SY4qV5s2bp3fffdeSsvbu3avf/OY3euedd8qdu/LKK3/43TPBBOpzM2fO1CuvvBJxOyXp0KFDuuuuuzRt2rRy50aMGKEOHTpow4YNltRlwsl92g1j0P333+/3+Ntvv63p06dH3L5Vq1bp5Zdf1q9+9auIy/KieLxnTThxfJXccU8//PDDfo9PnjxZb7/9tgUtlN5991316NFDn332mebNmxfStXb3+Wj193hbm7ih71vNq2uxcMVbnwfs5NQ8B4F5LWdftWqV/v73v0dUxp49e/Tpp5/q5ptvLneuf//+EZUdC3aviyXr18Ze65fR5oVcz+o942iyai6M5jxo5evtpvvXjeOjGzl9LwfRZ0W+Jlmbs8Xj3hAAwH7JwUMAADDXrKvU7Qrz+H3rzWMbtJbaGe7xlZVJC96VvptgXr4klZZIa2ZIO1ZK1z4pNWhVcXzva6WVk6UzJ83rqN5AuuhG8/iyMmnRh9KSj6XiQrNr9q6VPnpE6jFaGnKvlJgU/JqLfip9+bRZ+SmVpaGBnzmXc/Z7WPyRVFJkEF/q6xv71ksZbaVRj0i1m5jVVaep1Oe60N97Exmtg8fsWSttnCvtXC0d3yepLPR6Ol8m1WlmHl9SLH37prTi377XLpjSYmnLIt9Xp6HS0PulSumht9NJUtPM4s6c8n3/XpScIu1YLrXtLyUkBI7Lz5U+fTy08fesPd9L7z8k3fg3qV7L4PEJCVKXy6Vvg//MmWVKS6Rv35KWfRI8Nj/XN1ds+U766d8ivw82zpOmvyAVng7SxmJpw1xp+zLfa5nRxqz8xh2lmg2lnAORtdNJdq+Rpj0nncgOHltaIm1bKm1fLg262zcHm+o6XMoK4/NWHQabjf1nFeZLM1+S1s82iy8tkXat9n216ScNf1hKqx56O90mWvOpE3NHKbT8cd030sA7paSUiuOq1paadZF2Z5m0OrCUNKnVhcHjti2RTp8IHueF98AKTh/rvMru/ueGvhcM6w53Ymwt7+z+QTAdBpmtY/auldZ9HXGzKmTnvopT91RcIcH33lROl2o1keo2l5p3lVr0lFIqhVbUhrm+XM5pvLZ34IV9Vis16ST9ZKz5fFtaIn31P9KGOZHXvXlh8Nw1o41vzRvOXNGqd3jtyuwt7VwZRn19gseUlfnyHBPM397ltXHV62uEUHIwrzzXCmT7ct9edu4Rs/hje6Q546Rln0nDfmk2Tp518Rjf+FTRvrkbc3o7xetz2Iqwvxa6nauk6c9LJw+ZxUdyn/e9WVo9VSrIDRyzYa4vnw72TDchwXevL5loXn8gLXpKqVWCxzll7eblZ1Jey5nCwTPs8uJtnRSt56OSb/wzsXmh9O//Nsvlz1Va4ht7tnznyyPa9K04dvPC8O5rN4mHPSqvPOOPxrjg5nmPtZkPn9MILhr3EvNZ9Lh53LKa0/cfvL5/G2vJlXxzXDCFZ6QtC4PHfT/LLEdMqSx1HCyt/ip4bDzyyrwWKSeNT/GcMzrpfYgXduaEbs0HvZS7uSnnd9vY56bXFgAAAAAAAAAAAAAAAAAAAAAAAADcYtasWRo8eLCmTp2qevXqBY2vXr26pk+frltuuUWffvppFFoIAAAA4KyUlBSNGzdOt99+u/E1RSX5mrT2dmUd/Ni+hgEAAMSxTz9hnxQAALhL165dlZycrFmzZungwYOxbg4AxI127dqpUqVKmjt3rnbu3Bnr5gBA3GjwYANVr15dCxcu1MYNG2PdHACIC3feeadq1aqlVatW6bvvvot1cwAgblxz7TXKyMjQ2u/Xas6cObFuDgDEjREjR6hx48batGmTpk2dFuvmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIiy1NRUv8fLysosqyMvLy/sa9944w298MIL5Y7ffvvtmjRpUtjl3nzzzeWOHT58WF999VXQa53+msVK8+bN1a1bt3LH8/Ly/L6H4dqzZ4+mTZumK6+88rzjDRo0UM+ePbVixYqI6/iv//qviK7/7LPP9OCDDwY8/+KLL+r06dMR1TFz5kzl5eUpPT39vOMJCQnq3bu3Zs2aFbQM+rJPpO+35J73/MeOHz+uRYsWRdSucwX63UFdunRRamqqCgsLLavrx6pXr67Jkydr4MCBfs9v2bJFl19+uSW/W9kL492nn36qf//735E28TyMKdYZO3aspeV9+OGH+tvf/qaGDRuedzwxMVEjR47UG2+8UeH11atX1/Dhw/2ee/rppy1rpyRNnz5dWVlZ6tq1a7lz119/veWvTUWc2qfdMAa1a9dOmZmZfs8999xzlrXx6aef1oMPPhjwvYpX8XrPmnDa+Cq5457OyMhQ3759/Z575plnLGujJD388MMhXxOtPh+N/h5PaxM39H07eWktFol46vOA3ZyY5yAwL+bsjz/+uEpLSyMuZ/z48X6f33Tu3Fk1atTQiRMnIq4jGqK1LpasWxt7sV/GiltzPTv2jKPJyn4TjXnQytfbTfevG8dHN3L6Xg5iw6p8TbImZ4v3vSEAgH0SY90AAIB3tOgpXfO4lJBgFn9sj3Rgk3n5/W42L3vOOOm7CeZl/9ipw9LHjwaPS60iXTAstLJ7XSMlG+6/FOVLX/yXtPA9qTiMfc2Vk6Uv/yaVBVnf7l4jrZ9tXm7XEVJ6TbPYc7+HkiLzOs46uFl67yFp5yrza3pdIyVXCr2uSOxZK73zC2nCb6VVU6TjeyWF+bnJHqPNY8+ckib+QVr+efD32Z91X0sTfiflHQ/9WidJqWwWd8Ydz83CcuqI9O//9vXDrUv8xxQX+vrLvvXh13P6hDT5afMxqdWF4dcVqrJSacrfpWWfhHZd9hbp87FSJJ91zpomTf6rVBjC520K8qRJf/K9d6Za9gq9bU61frY08THpRHZo15WV+ub55Z+bX5PRVqpaN7R6JKnX1eaxZ075codQ5tNzbVnkG49zj4V3vVdYOZ/GInc8eSh4bCj545mT0tbFZrEdB5vFVaRNXynFIIdaM92sPC+8B5Fyw1jnVdHqf07teyZYd7gTY6s3RGtfxS17KlZq2UP69eTwvh6ZJv3qc+n+96Wf/k0aer/Upp9ZfnSuXaulac/b8u1FzGt7B17YZ7VKy57S9X+VKqUHj5WkogLp879IG/x/1jZk+9YHn+cTEqUWPUIvu25zqVq98NqV2Tu860z2X/ZvNM9tmL+9y2vjqtfXCKY5mNefa63+Svrkz1JuCPvSZ+UekT59QloSwu+uq5QudR4ael3xjOew52N/LXRrpkuT/miWD/xYOPd5amXpgssqjinKlzZ+a1Zep0vN665I+wFmceu+saa+SHn5mZTXcqZQ8QzbP9ZJ/2Hl89HUKlLNjOBxBXnS1OfCy+XPKjrjy0P83dcFedLST6Vxd/j6YPaW8Otxg3jfo3LjM347x4V4n/e8gM9pmLPrXmI+iy7GLR837D94ff821tpfYvacbdN833O2YI7vlfZvMKu76wizuHjkhXktUm4Yn+IB70P0RSsndFs+6JXcjZzfPry2AAAAAAAAAAAAAAAAAAAAAAAAAGCf5cuX6+KLL9bOnTuN4itVqqSPP/5Y999/v70NAwAAAPCDWrVqadasWbr99tuNr8ktOKRxywYr6+DH9jUMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgzhw/ftzv8czMzCi3xL93331XBQUF5Y4PGzZMGRkZYZV58cUXq3nz5uWOv//++youLg56vdNfs1i57LLL/B7/+uuvA75m4Zo3b57f4wMHDoy47DVr1mj58uURlbFy5cqA58rKyvT2229HVL4kFRUVae3atX7PtWjRwqgM+rI177fknvfcblu3btWJEyfKHU9MTFTt2rVtq7dBgwb69ttvA44By5cvV79+/Yz/9nkwXhjvXnjhhYiu94cxxRo7d+7UN998Y2mZxcXFeuONN/yeGz58eNDrL7/8ciUnJ5c7vmbNGs2dOzfS5pXzj3/8w+/x0aNHW15XRZzap90wBl1++eUBy1u3bl3E7Trr8OHD+vzzzy0rzyvi9Z4Nxonjq+SOe3r48OFKSEgod3zlypVatGiRJW2LRDT7vJ39Pd7WJm7o+24Sq7VYJOKtzwN2cmqeg8C8lrPv3LlTU6ZMsaSsxYsXq7S0tNzxxMREtWzZ0pI6oiFa62LJurWx1/qll0Qr17NjzzharJ4LozEPWvl6u+n+deP46EZO38tB9FmZr0nW5GzsDQEA7JIY6wYAANyvcjVp0N3SdWOlSunm162eah6bXltqdaFZ7Ia50nIL9jjyc6WysuBxXUeYl1kpXeoyzDx+8t+kLRHuTWyaL817u/zxkmJp3TfSOw9KHz0ibVtiVl5istT7J+b1f2nB91CQJ336uHRwi1l8WvXQXudIlJVJc9+UJvxWyt4aeXmNOkj1DT9vWVoiff4Xac+ayOo8tF369AmpuDCycmIptbJZnJu/R1OHtkmfPSG9/7C0a9X55755XTq4OfI6ju6WVhnundVtLqXViLxOEwvekzZ+G961u7PCv3bP99LMl8O79swJ/2N0IM27hVeP0+xcKX31P75xLFxz35SO7jGPb9E9tPLrt5IatjOLLS2RPvmTdGBTaHX82JFdvjm5KD+yctzI6vk0Vrnj5L9anz+umW4W126AlJRiXq4/nYYEj8k9Jm03+Ayjl96DcLlhrPOqaPc/p/U9E6w73Imx1Ruiva/i5D0VOyQkSsmp4X1ZYcO3vte7uPzveXEUL+wdeGGf1SrtBkjX/kVKqWQWX5AnTfqjtG2phY0ok7Z8Fzwss3foRYdzzVm1m0g1G4Z2Tf1WUlWDzxlvXmBWHvN3fPDCuOr1NUIoOZiXn2tt+e7/9rINxoeAyqRv3zTvj5LU48oI6oszPIc9H/trodv6nTT9Rams/GfWzYVzn4+WVP5nMc6TNc2srLrNpXoR/jxkYrLU+qLgcfs3Ssf3RVaXFeLlmZQXcqZw8Ay7PNZJPlY/H5Wk6vXN4rYtlQpPR15fWan01d+lvP/7eaacg9I3r0mvjpHmviGdPBR5HU4Xz3tUbn/Gb/e4EK/znlfwOQ1zdtxLzGexEc/jlhv2H7y+f+sEpmPU2lnmZX5vGNugte8L5/PKvBYJN4xP8YD3ITaimRO6MR90e+5Gzm8fXlsAAAAAAAAAAAAAAAAAAAAAAAAAsNeWLVvUt29frVlj9kP9SUlJevXVV/WXv/zF5pYBAAAAaN26tZYsWaKBAwcaX7N521q9suRC7T6x2MaWAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxJ8DBw74PX7zzTdHuSX+HT9+XJ999lm540lJSbrlllvCKnPMmDF+j48fP97oeqe/ZrHSv39/v8dnzJhheV2LF/v/u2YdO3aMuOzp06dHXEZOTo7279/v99yaNWt06NChiOuQpHXr1vk9XrNmTaPr6cvWvN+Se97zaAj0OtSuXduW+jIzM7Vw4UJ169bN7/lZs2Zp0KBBOnLkiGV1un2827BhgxYsWBD29YEwplhj5syZtpQ7Z84cv8d79+4d9NpBgwb5PW5Hn6+o3B49eqhKlSq21OmPU/u0G8agCy+80O/xQP0wElOnTrW8TLeL13s2GCeOr5I77ulAbbTrNQ1VNPu8nf093tYmbuj7bhPttVik4q3PA3Zyap6DwLyWs0+ZMiXiMs7Ky8vTpk2b/J5z6pzmTzTXxZI1a2Ov9UuvsTvXs2vPOFrsmAvtnAetfr3ddP+6cXx0I6fv5SD6rMzXJGtyNvaGAAB2SYx1AwAA7pSQKDXrJl32oHTfO1Kf66TEJPPr83Kk70NYd3ccYlZ+Ub70zevm5QazfVnwmFqNpHotzcprP1BKTTOLXfaZtM3/+ixkSyZJ+zb4/n3mlLT4Y+n126SvnpWyt4VWVusLpWp1zWKXfiJtteh7KCmSvnhKyj9lFt/tCmvqDWbaP6Slk6wrr8NA89j570h711pT78HN0tw3rSkrFlIqm8WVFFlf99AHpcv/nz1fA+8Kv137N0ofPyZNeETat973HmdZuP+7+ivz2IzW1tUbSPY26buPIitj0YehX1NcKE19TiorDb/edd9IJ7LNYuu3Cr8epzhzSpryTGSvmSSVFoc2bjVsG1r5nS41j/1ugnTA//5vyI7tleb8y5qy3MTq+TRWueP+jdbnjztWSicPB4+rlC5lRvBctkoNqXn34HFrZ5ndv156D8LhlrHOq2LR/5zS90yx7nCneB9bvSIW+ypO3VPxkvxT0owXpS+f9q0T3cLNewde2Ge1wgWXS6Mfk5KSzeJP5/jeb6vm9nNtWRg8pmXP0MvN7BP4XFmZQZ29QqzPcF21ZZFZHPN3fHHzuOr1NYJpDubl51q5x3zzlVW+ed33/pmo3VRqEIXnBF7Ac9j/YH8tdLnHpCnPSjLIkUyEcp/XbCg1bFdxzIFN0uEdZuV1HGIWF0iL7r4982DWfR1ZPVaJt2dSbs6ZQsUzbP9YJ/lY/XxUklINPztj+t6aKMiTZr4sfT5WeuNOacW/paIz1pXvdPG8R+WFZ/zRGBfiad7zEj6nERqr7yXms9iKt3HLLfsPXt+/jbU6zaTGBj87n3NQ2vO9ebkbvzV/dtx1hHm58cIr81q43DI+eR3vQ+xEOyd0az7o1tyNnN8+vLYAAAAAAAAAAAAAAAAAAAAAAAAAYL+DBw/qkksu0bfffmt8zeOPP65//etfSkzkTwcDAAAAdhgyZIiWLFmiNm3aGF8zbdo0XXdXXx0/s9O+hgEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMSpBQsW+D0+ZswY/fSnP41ya/wbN26c3+O33357yGUlJyfr+uuvL3d8+fLlWrt2rVEZbnjNYqFdu3Z+j3/33XeW13Xw4MGQ2hAKq9obqI1Lly61pPyK6qhVq5bR9fRla/unG97zaDhx4oTf47Vr17a8rq5du2rRokVq1aqV3/MTJkzQyJEjlZeXZ2m9bh/vQvnb76FgTLFGoNcxUsuWLVNJSUm5402aNFFaWlqF13bs2NHv8YULF1rSth/Lzs7Wjh07yh1PSEhQ+/btbanTH6f2aTeMQW3btvV73I42zps3z/Iy3S5e79lgnDi+Su64pwO9j3b1qVBFs8/b2d/jbW3ihr7vNtFci1kh3vo83G3gwIHasGGD5V/du3e3pH1OzXMQmNdydqvXZXv37vV73HROc8I9G811sWTNe+C1fuk1dud6du0ZR4sdc6Gd86DVr7eb7l83jo9u5PS9HESfHfdCpDkbe0MAALskx7oBAIDoql5PumBYaNckpUipaVKlKlK1ulLd5lLtZlJq5fDbMWecVBDC51RbX2gWt+or6XROWE3ya/lnUqs+weMye0uHy+//lGNSliSdPiHNe8ss1kiZ9PWrUsO20tqvpeKC8Itq3dcs7nSONP+d8Ovx52S2tHiiNOiu4LF1m0s1G0o5B6xtw7kWfyytnWVtmS16mMWdOiwt/cTauld9KXUZJtXPtLbcaEhKMYsrK7W23io1pB5XWlvmuXKPSd++GVkZe9ZIH/xaqlTVmjaddXyf7/6q2TB4bO0m0o4V1tb/Y9+Ol1QWWRlHd0tHdvnGD1Orv5JO+N9LM1cmbVog9flJ8NAaDaSUSlJRBON4rC14xzfPWWH7Ut99UtVgj7VeiGOb6Xh88pC06MPQyg5m9RSp81CpUZw8A7ZjPo1V7ihZnz+qzPf69Ls5eGjHIdKWRQZl+tF+oJSYFDzu+5lm5XnqPQiDW8Y6r/LK+tFOrDvcKd7HVq+I1b6K0/ZUvOTMKenj30uHtsW6JeFz496BF/ZZI9XzamnIvVJCgln8yUPSx4/53hc77Mry7flXSg8cU6Wm1KCNlL3FrMzUKlKTToHPH9goVa4q1W4aOKZVH1/+YSqzd/CYQ9vNx0jm7/jkxnHV62sEkxzM68+1vn1TKjxtXXmlxdLscdLN/2MW36KHlL3Vuvq9iuew/8H+Wuhifp939+VnFcmaLg29P3hZHQdF9oy03YDgMSXF0gaH/FxYvD6TcmPOFKp4eoYdCtZJ9jwflaSERLM4k2eCoQj3+aQXxOselZee8UdrXIiHec9T+JxGyKy8l5jPnCFexi237D94ff821roMN4tb93Vo5RbkSVsXS+0vCR7bcbDv52vc/Nlgq3llXguXW8Ynr+N9iJ1Y5IRuzgfdlruR89uH1xYAAAAAAAAAAAAAAAAAAAAAAAAAouPEiRMaNmyYJkyYoGuuucbomrvuukv16tXTjTfeqPz8fJtbCAAAAMSPu+66S6+99ppSUgz/qLGkV155RQ899JBa9LT4DxwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAkvTdd9/p0KFDql+//nnHExMTNWHCBF155ZV6/vnntXz58hi1UJo7d662bt2q1q1bn3e8c+fO6t69u1atWmVc1rBhw1SnTp1yx8ePH29chhtes1ho27at3+O7d++2vK7jx4/7PV6zZs2Iy960aVPEZUhSbm6u3+ObN2+2pHxJOnXqlN/jNWrUMLqevmzd+y254z23Q0JCgho3bqzMzExlZmaqXr16fuNSU1MtrXfgwIGaPHmyqlev7vf86dOn9ctf/lLFxcWW1iu5f7xbvHhx2NdWhDHFGlaOGefKy8vTjh07yuVTCQkJatWqldauXRvw2o4dO/o9vmLFCkvb+OOyW7Zs6bctK1eutK3eczm1T7thDGrTpo3f42vWrIm0SeXs2rVLBQUFqlSpkuVlu1W83rPBOHF8ldxxT7dr187v8VDW4naKdp+3q7/H29rEDX3f6WK1FrNKvPV5uFt6errat29veblpaWmWlOPUPAeBeS1n37hxY0TX/9iJEyf8Hjedu51wz0ZzXSxZszb2Wr90u2jnenbtGUeLHXOhnfOg1a+3m+5fN46PbuT0vRxEn9X5mhR5zsbeEADALsmxbgAAILrqNpdG/Cq2bdi+TFo/2zw+JU1q7H8/p5ysqeG1KZA9a6XiQik5yL5i407By0pKkZp3M6t39VdSSZFZrKnsLb6vSCQkSq36mMWusuF7kKSsaVK/W6TUysFjW10orfjC+jZI0pFd0oL3rC0zvbZUp5lZ7MovpbJSa+svK5WWTJSu/L215XpZzYaxboG5Av+fE4nIgc1mr0E1/89sLHNsn7TTov397Ut9c6WJsjJp5WTr6u3zk+BxCQlS1brS8X3W1Bttp09I38+0rryyUmnLIqn7qOCx1esHjzkrvZZUr4VZ7Kop1o/HkrTic6nRY9aX6zR2zKexzB0la/PHs9bMkPre5BsDKtKqj5RaRSo8bV72WR0HB4/Zs9Zs/PHiexAKt4x1XuWV9aOdWHe4U7yPrV4R630Vp+ypeE1aNem2l6TNC6VFH/hyXLdyy96BF/ZZI3XxGN+XqaN7pI8fk3KP2Nem0mJp29Lga4vMXuavX4seUmJS4PNbl0hp1aXaTQPHNO3im7+KC4PXV7mq1Mjg8/RbFgWPkZi/4Z5x1etrBNMczMvPtU4dkdbPsb7cvWul7G1Sg1bBY1v08L3PCCzW6wXJGf1VYn8tHE64z1v2lL6bUHHM+m+kQXcFz0+q1ZOaXiDt+d68rWclJEqt+waP275Myvf/M/BRxTMp9+RMoYq3Z9imWCfZ83z0rHzD+8m0P6Fi8bpH5bVn/NEeF7w673kRn9MIjZX3EvOZs3h53HLL/oPX929jLSlF6jw0eFxZmbT269DLXztLan9J8LjUKlL7gdb2STfz0rwWDreMT17H+xBb5IThcUvuxvtrH15bAAAAAAAAAAAAAAAAAAAAAAAAAIiegoICXXfddXr55Zf1wAMPGF0zevRozZo1S1deeaVycnLsbSAAAADgcQkJCXrmmWf0u9/9zviakpISPfTQQ/rnP/9pY8sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQUlKip556Si+99JLf8zfffLNuvvlmHTx4UMuXL9e6deu0ZcsWbdu2TVu3btXevXuj0s433nhDzzzzTLnjt99+u1atWmVczpgxY8odKygo0IQJE4zLcMtrFm21atUqd+zMmTM6duyY5XXl5ub6PV6tWrWIyz5w4EDEZUiB23jw4EFLyq+ojsTERKPr6cvWvd+SO97zcKWlpSkzM1OZmZlq1aqVWrVq9cO/W7RooUqVKtla/49dffXV+uijjyqst0qVKnrzzTd11VVXWV6/28e7NWvWhH1tRRhTrLFr1y7byg7UR/316XPVrVvX7/EjR45E3KZAApUdqC12cGqfdsMYVKNGDb/Hjx49GnGbfqysrEx79uxR69atLS/breL1ng3GieNroBin3dO1a9f2e9zOPhWKaPd5u/p7vK1N3ND3ncBpazErxVufB+zk1DwHgXktZ9+3b1/EZZzr5MmTfo+7acyN5rpYsmZt7LV+6QZOyvXs2jOOFrvmQrvmQatfbzfdv24cH93I6Xs5iD6r8zUp8pyNvSEAgF2SY90AAEB8ObRdmvx0aNc0yJQSk4LHHdsjHbd4PVdaLB3cLDXpXHFcRpvgZWW0kVIqm9W7+iuzuGir11JKq24Wu3qKPW0oyJU2fit1GRY8tnlXacUX9rRj3lu+/mGlhm3N4srKpDUzrK37rE3zpaEPSmnsARip2SjWLYitE4afMUnzv89tmU3zrSvr0A7z2OwtUo5Fn+U5vNM8tmpt6+e7aNk0XyoutLbMg5vN4qr6fw7gV8P2ZnGlJTaOxwukIceldI9/1sSO+TSWuaNkbf541slsafdqqXn3iuOSU6W2F0trZ5mXLUk1MqRGHYLHfW/Y3734HoTCLWOdV3ll/Wgn1h3uFO9jq1fEel/FKXsqXpSYJLW/xJeLrfi3tOBdqSg/1q1yBjv2DrywzxqJIfdKva4xjz+4WZr0J+mM/88tWWrzAqnj4IpjMntL3xn+nqLM3hWf37ZEqlxN6n1t4JiUSlLTLtKO5cHra9HTbL7dvDB4jMT8DXvYMa56fY1gmoN5+bnW2q+lslLry5V8c+2wXwaPa2S45xrPYr1ekJzRXyX218LhhPs8o62kBEllgWPyc325VLCcUZI6DpH2fG/ayv9o1tVsPln3dehl24FnUvZwwnPseHuGbYp1kj3PR886c8IsrmVPqXZT3+uM8MXrHpXXnvE7YVyIlBPmPS/icxqhsfJeYj7zPqeMW27Zf/D6/m2stelrtie3d6153z3XjhVS7jGz97zrCOn7maHX4UVemtfC4Zbxyet4H2KLnNA57MjdeH/tw2sLAAAAAAAAAAAAAAAAAAAAAAAAANFVWlqqBx98UAcPHtTYsWONrunfv7/mz5+vYcOGaf/+/Ta3EAAAAPCmKlWq6P3339c115j/8ZZTp07phhtu0PTp021sGQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM567bXXdO2112rQoEEBYzIyMjRq1CiNGjXqvOP5+fnavn27tm3bpq1bt2rLli3KysrS6tWrdfr0acva+Pbbb+upp55SSkrKecdvvvlm/eY3v1FxcXHQMtLT0zV69Ohyx7/44gvl5OSE1B43vGbRlJ6eroSEhHLH09LSVFRUZHl9/uqSpEqVKkVcdl5eXsRlSL6/q2xn+RXVEYp478vReD+c9p5XpFmzZurRo4e6dOmi1q1bq1WrVsrMzFRGRoat9Ybi7rvv1uuvv66kpKSgsaNHj9b999+v1157zbL6vTDeHT16NOxrg4n3McUKp06dsq3s48eP+z1etWrVgNekpaX5vd8KCgqUn59vWdt+7NixY36PV6tWzbY6/XFan3bDGBSojQUFBSosLLSsbec6efKkLeW6UbzfsxVx2vgqueOerlKlihITE8sdLygoUEFBgWVtC1cs+rxd/T2e1iZu6PvR5oa1mNXiqc8DdnNinoPAvJizW90H3T7mxmJdLEW2NvZiv3QSN+R6du4ZR4Ndc6Fd86CVr7eb7l83jo9u5PS9HMSGHeMke0MAAKdKjnUDAADx49g+adIfpcIQPwfWoLVZ3I4VobfJxPH9UpPOFcdUrS2lpElFZwLH1GlmVt+xfVKuQ/cf6zY3izu2V8rzv1doiT3fS12GBY+rY9jeUB3fL21dYn25tRqbxR3bI505YX39klRaIu1aJbW/xJ7yvaZmw1i3ILbyc83iklPtbceu1daVdXRPCPVmWVfvmRPSmZNSWvXgsSmVras32rYvt77MQ9vM4hKTpORKUrHBvn/tJmZlHtll83icJXUcZE/5TmDXfBrr3FGyLn8815rpUvPuweM6DpHWzjIr84drBgePKTwtbZpnVp5X3wNTbhnrvCrW/S+Wfc8U6w53inXfltzRv53OCfsqsd5T8brEJKn3tVKLHtJnT0onDsa6RbFnx96BF/ZZw5GQKA1/WLrgcvNrdmdJnz4ZvXF5x3KpqEBKqeDzRQ3bSZWqSgUGfSOzd+BzJw9Lh3f47ruCPKlSeuDYVn18bYukvrNyDvjqNcH8DTvYMa56fY1gkoN5/bmWyRgYrr1rzeJSKktV60q5R+xri9s5Yb0gxb6/SuyvhcMJ93lyqlS9nnTyUMVxWdPM9qTbDZBm/VMqDf47MstdF0z+KWnb0tDKtQvPpOzhhOfY8fYM21S8r5Psej561umTUuEZKTWt4rjEJOknf5E+fdyXWyA88bhH5dVn/G7fP3HCvOdVfE4jNFbdS8xn3ueUccst+w9e37+Nta4jzOJCHefPKiuV1s+W+lwXPLZRB98e4ZFd4dXlJV6a18LhlvHJ63gfYouc0DnsyN14f+3DawsAAAAAAAAAAAAAAAAAAAAAAAAAsfFf//VfOnjwoF577TUlJSUFje/cubMWLVqkYcOGadOmTVFoIQAAAOAdDRs21JdffqmePXsaX7N7925dccUVWrvW8BduAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIGLFxcW6+uqrNXPmTPXp0yekaytXrqyOHTuqY8eO5x0vLS3VggUL9P777+vDDz9UXl5eRG08dOiQvvzyS1177bXnHa9bt65GjhypyZMnBy3jmmuuUZUqVcodHz9+fMjtccNrFk3+XtezkpOTo9iSyBUVFdlafmFhoa3lhyre+7Ld77fkvPf8x7p06aLbbrtNN954o5o0aRLr5gT1xhtvhBT/j3/8Q/Pnz7fs7yR6YbzLycmxrex4H1OscPr0advKPnnypN/jVatWDXhNenp6SGVZJVA/rVatmq31/pjT+rQbxqBAbbSzz9h537hNvN+zFXHa+Cq5456OVZ8yFYv22dXf42lt4oa+Hw1uW4tZLZ76PGA3J+Y5CMyLOXs0xnQ3icW6WIpsLPBiv4w1t+V6du4ZR4Ndc6Fd86CVr7eb7l83jo9u5PS9HMSG0/I19oYAAHZKjHUDAADxYfty6b1fSnnHQ7+2VmOzuCO7Qi/bxJlTZnHV6lZ8vk4zs3IObDSLi4W6zc3i9m+wtx2m5dfMkJJSrK9/y3eSyqwvt7bh3vj+TdbXfa49a+wt3w6lpWZxCRZnv7UaWVuemySlSEmG+1LJNtyH5zq83bqyzoSwL3xoq3X1StKZE2ZxyanW1htN2VusLzPP8HWTzPtinaZmcbbPd+vtLT/W7JpPY507Stblj+favEjKNyi3eVcpvZZ5uZLUcXDwmA3zpKICs/K8+h6YcstY51Wx7n+x7HumWHe4U6z7tuSO/u10TthXifWeSryo10K67SXz99yr7No78MI+a6gSk6XRj0kXXG5+ze410qQ/SUVn7GvXjxUVSDtXVhyTmCS16B68rPqtpKq1A5/ftsT339ISaceKisvK7B28Pklq2St4zOaFZmVJzN+wnl3jqtfXCCbzsZefa5WWSPttnBOP7pEKDT93Hs/PVEw4Yb0QSvl2rhnYXwuNo+5zg/xnzxrp+P7gcZWrmudxZyUkSm37BY/bOE8qccjPCvBMynpOeY4db8+wTcX7Osmu56M/KJN2Z5mF1mok3fGaNOI3vvVwauCfWUIA8bhH5dVn/G7eP3HKvOdVfE4jNJbdS8xnnuakccst+w9e37+NpRoZUrNuweOK8qWN88OvZ+0s89guI8Kvx0s8Na+FwS3jk9fxPsQYOaEj2Ja78f7ah9cWAAAAAAAAAAAAAAAAAAAAAAAAAGLmjTfe0HXXXaf8/Hyj+ObNm2vhwoXq06ePzS0DAAAAvKNr165aunSpevbsaXzN0qVL1adPH61du9bGlgEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMCfEydOqH///nrhhRdUXFwccXmJiYm65JJLNG7cOG3btk333HNPxGWOGzfO7/E77rjD6PoxY8aUO7Z3717NmjUrrPa44TWLloSEhFg3wTXKyspi3YRy6Mv2cuJ7LkktW7bUxIkTlZWVpd/85jdq0qRJrJsUtjlz5mjUqFEqLS0td65y5cr66KOPVLlyZUvq8sJ4d+rUKVvLZ0yJjJ1jRklJid/jFfXrxMTEkMqySjhttYuT+rQbxqBAbbSzz1jxvngF92xgThtfTc47QSzu6VDEos+7ob8H4pS1iRteKzt5aS3mdE7p83C/nJwcLV682PIvq9bnTsxzEBg5u/1ifc/GKoeOZG1Mv7SOW3M9u/eM7WbXXGhXH7Xy9XbT/evG8dGNnL6XA0junusBAM6XHOsGAAC8rShf+u4jafHHksLck6pWzyzu6J7wyg8m33BvKr2WdKyCNtRqZFbOwS1mcbFQ23D/Nnurve04vk8qzJdSg3zOOSFRqtlQOrrb2vp3rrS2vLOqG/b1Qza/vsf22lu+HYoLzeKSUqytt2ZDa8tzmvRavu+xRobvvz/8O0OqWkdywp5VQZ505qR15RWeNo89fsC6eiWp8IxZXGKStfVGS2G+lHvU+nIL8sxjEw1XwMbj8XbzusPh5JzACnbNp7HOHSXr8sdzlRRJ6+dIPUZXHJeQKLW/RFrxb7Ny62dKdZoFj/t+ull5knffAxNuGuu8Ktb9L1Z9LxSsO9wp1n1bckf/djon7KvEek/FboVnpBPZkZWRkCClVJZSq0iVqoS/BkurLl33lPTeQ1Lescja5GSx2Dvwwj5rKJIrSdc+KWX2Cu26us2kSunS6RwbGlWBzQulNn0rjsnsLW2aHzymIlsX/+ff25b41kGB1Gwo1WrsGwMDyWgrpdesuE7J9/2ZYv5GOGIxrnp9jWCSg3n5udaJbKnUzs+Fl/n2SZt0Dh5aq6G0Z42NbXE5J6wXpNivGdhfC52T7vOaGdIugyLXTJcG3hk8rtMQaet3BgX+nyadpSo1g8et/dq8TLvxTCo8Tn+OHY/PsE3F+zrJruej59q2VGp9kVlsUop0wWW+r7Iy6dRhKeeArx/l7Pf9O+eAlHNQKsi1t91uFG97VJJ3n/E7ff/E6fOel/E5jdBYeS8xn7mbG8YtN+0/eH3/Npa6DDfrj5sXSkURrI2O7PLlhBltgsd2ulT69k3fHBTPvDavhcJN45OX8T44Q6Q54Y6V5IMmYpW7kfPbh9cWAAAAAAAAAAAAAAAAAAAAAAAAAGLniy++0LBhw/Tvf/9bNWvWDBpfp04dzZ49W9ddd52mTw/hl40AAAAAcWjUqFGaMGGCqlatanzNxIkT9bOf/Uz5+fk2tgwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVKSoq0q9+9Su9/PLLeuyxx/STn/xEtWrVirjcBg0aaNy4cbrssst02223hf03q2bOnKldu3apefPm5x2/4oorVKdOHR09ejTgtfXr19fQoUPLHX/nnXdUVlYWVnsk579mgCn6cnwZPny4Pv74Y1WvXj3sMo4ePaotW7Zoy5Yt2rx58w//fvHFF9W/f38LW1uxSZMmacyYMSosLNTTTz+tP/7xj+ViOnXqpOeff173339/1NrlZJHMe6YYU+A19GkAAGAFL63FgHiyaNEi9e3bN9bNAGCIexax4uZcLxp7xvgPXm8AAADAPsmxbgAAwJvKSqUNc6W546XcI5GVlW74mbP+t0mFZyKry59ajcziUipVfL5Sulk5Z06axcVC5apmcaej8D3kn5RSKwePM33dQ3F4h/VlSlJqFbO4M6fsqf+snAP2lm+HkkKzuKQUa+ut2dDa8qItuZJUo4Hv+6iZ4ftvjf/7d42M4OOaE5w+YW15xQWxq7sohLrd6HSOPeUW2TD3p6SZxdk9Z9v1mjmFXfNprHNHybr88cfWTJd6jA4e13GItOLfZmV2HBI85uhuaf9Gs/Ikb78HwbhprPOqWPe/WPW9ULDucKdY923JHf3b6ZyyrxLLPRW77V0nffIn68pLTJJqN5HqtZRaXSS1vlBKNVwvSFL1etKIX1vbpmhz4t6BF/ZZQ1G3ue8rVFVq+vrfp49b3qQKbVsslZb47p9AWvYKXk6rPoHPFeVLu7P+8//bl/ueSSQkBr4ms5e0Yl8F53sHb1PuMWn/huBxZzF/wx8njqteXyOY5GBefq51Itva8vwxnXNN+1q8csp6QYrtmoH9tdA56T5PMeg3krR2ljTgZxXnjJLU6kLf2FF42qzc9gOCx+QcCC2nsxvPpPxzYs4UCp5hBxbv6yS7no+ea9030sVjpKq1Q7suIUGqXt/31axr+fP5p6Scg75x9Pg+6eAW6eBm6VSEnwt0s3jbo5K8+4w/1vsnbp/3vI7PaZiz8l5iPnM2L4xbbtp/8Pr+bawkJEoXXG4Wu3ZW5PWtnSVltAkel1ZNanux7+dw4pnX5rVQuGl88jLeB2eINCfsOrz8uXjMB52au5Hz24fXFgAAAAAAAAAAAAAAAAAAAAAAAABia968ebrkkks0Y8YMNWwY/I+bpaena/Lkybrzzjv1/vvvR6GFAAAAgPv89re/1TPPPKPExAr+KMk5ysrK9NRTT+nxx6P8B1sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQ0Pbt23XPPffo/vvv1yWXXKLevXurR48e6tChg1q1aqUqVaqEVe7111+vatWqaeTIkSorKwv5+rKyMr355psaO3bsecdTUlJ000036ZVXXgl47Y033qikpKRyx996662Q2+GPU1+zaAnUtpycHH300UdRa8fJkyejVpdXxXtfjgejRo3SF1984XdM/LGTJ09q06ZN2rJli7Zs2aLNmzf/8O+cnBy/1+Tn51vc4sBeeeUV/fKXv/yhTz3xxBO69NJLddFFF5WLve+++zRjxgx98cUXEdXJeBcaxpTQpaSkqKioyJayU1NT/R4vKSkJeE2gc8nJyZa0KZCUlBS/xytqazTEuk+7YQwK9B4Fek+tYGfZbsM9G5jTxlfJHfd0aWmp3+N29ylTsejzbujvTueGvm8HL63F4FwJCQmxbgJiwIl5DgIjZ/e+WKyLIy2ffhk5cr3YsmsudMM86Kb7143jYyxEmtM7fS8HkOJ3bwgAEB1kPQAAS+UeldbMkNZMl04esqbMlEpmcc26WFNfuJKDtDM1zayc/FORt8UuqYaf9SvItbcdkpSfK1WvHzyuUnifTwyoMF/KO2ZtmWelVDaLs/v1zc+zt3w7FBeaxVWual2dKZWk9FrWlWe3hETfONm4k9SglVS/lVSjQaxbFbniAmvLC+Uz9sUWP4vy2Of7yyk6E+sWmDOdswtsHi+dnBNEytb51CW5oxQ8f/yxQ9ulg1uljNYVxzVsJ9VqJB3fH7zMDgODx6yZYda+s7z8HgTjprHOq9zS/6zue6Fg3eFObunbUmz7t9M5ZV8lVnsqblRaIh3Z5fvaMNfXv/v8RLrwRvP7MrOX1KaftGWRrU21hFv2DrywzxotrfpIXUdKWVOjV2d+rrRnjdS8e+CYqrWlei2lwzv8n69c1beuCWTXKqnknM+/njkh7d8kNe4Q+JrMPtKKf1dwvnfgc2dt/S54zLmYv+GWcdXrawSTHMzLz7Xs3sOUzN87074Wr5yyXpBiu2Zgfy10TrrPTXP1vOPStiW+tVJFklOlthdLa2cZFJogtbk4eNi6b4yaGDU8k3JPzhQKnmEHFs/rJDufj56ruEBa9KF0+S+sLbdyNSmjmpTR5vzjp45IG+f5xtdD26yt0+nibY+KZ/zWjAtenPe8js9pWM/kXmI+cw6vjltu2n/w+v5trGT28T2vCubUYWlXVuT1rZ8jDf65lGTwU5xdR/qeTcczr81roXDT+ORlvA/OYEdO6PV80E25Gzm/fXhtAQAAAAAAAAAAAAAAAAAAAAAAACD2vv/+e/Xt21czZ85U27Ztg8anpKTo3XffVf369fWPf/wjCi0EAAAA3CE5OVmvvfaa7r77buNrCgoKdNddd+mDDz6wsWUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIV3FxsWbPnq3Zs2efdzwjI0OtW7dW69at1aZNmx/+3bZtW1WtWrXCMocPH64nnnhCTz75ZFhtGj9+vJ544gklJSWdd/z222/XK6+8EvC6MWPGlDs2f/58bdu2Lax2BOLE1ywa8vPz/R7Pzc3V/fffH+XWwArx2pe9LjMzUx988EG5MfSsQ4cO6ZNPPtGsWbO0fPly7d27N+Q6EhISIm2mkT/84Q96+umnzztWUlKim2++WVlZWapWrVq5a8aPH69ly5Zp3759YdfLeBcexhRzNWrU0JEjR2wpu2bNmn6P5+bmBrwm0LlAZVmldu3afo+fPHnS1npNxapPu2EMysvL83u8Ro0attWZnp5uW9luwz0bmNPGV8kd93SgNtp5T4ciFn3eDf3d6dzQ963mpbUYnC0tLS3WTUAMODHPQWDk7N4Xi3WxFNnamH4ZGXK92LNrLnTDPOim+9eN42MsRJrTO30vB5Dic28IABA9ybFuAADAW1b8W1oy0doykytZW55dEhMrPp9iuIdRcDryttgl1UHfQ77hnmNqFWvrPXPC2vLOlVLZLK7A/76hZYr870M42ukcs7gqNSQlSCqLvM7SUum9h8K7tlZjadQjkbfBRL2WUvdRUtv+//f9e0xJcXzW7UZuer1Mc49Cm+e7fJvH+1iycz51S+4oBc8f/VkzXcr4RfC4DoOkRR9WHNP0AqlavYpjSkukdV8bN0+S99+DirhprPMqt/Q/q/teKFh3uJNb+rYU2/7tdE7ZV4nVnooXFBf4cqyN86Ubn5aq1TW77sIbpC2L7G1bJNy2d+CFfdZoGvJzafca6Xjon8MN26aFUvPuFcdk9pYO7/B/rkVPKdH/54slSVsXlz+2bYnUuEPga5peIKVUkooKyp9Lqy41bFtxeyVp04LgMedi/o5frhtXPb5GMMnBvPxcKxprrwLT742f4ayQU9YLUmzXDOyvhc6t93nWNKlNv+BxnYZIa2cFj2vSUarq/2d2zrPum+Ax0RTPz6TcljOFgmfYgcXzOsnO56M/tnqK1Lyr1G6A/XVVqyv1vtb3tW+DNPt/pQMb7a/XCeJtj4pn/JGNC16e9+IBn9Owlum9xHwWW14ft5yeN5/L6/u3sdJ1hFnc2m9kyWfO80/5nmW1vTh4bLMuUq1G0vH9kdfrVl6c10y5aXzyMt4H54hWTuj2fNCtuRs5v314bQEAAAAAAAAAAAAAAAAAAAAAAAAg9nbt2qWLL75YU6dOVe/evYPGJyQk6LnnnlOjRo3029/+NgotBAAAAJytZs2a+uSTT3TppZcaX3PkyBFdffXVWrhwoY0tAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgB0OHjyogwcPasGCBeXOZWZm6vLLL9cDDzygCy64wO/1jzzyiF577TVlZ2eHXPe+ffs0ffp0XXHFFecd79mzpzp16qR169aVu6ZVq1bq06dPuePjx48Puf5wxfI1i4bTp0+rrKxMCQkJ5x2vXbt2jFoEu3i9L3vdX//6V1WvXr3c8ZMnT+rRRx/Vm2++qaKioojqqFq1akTXB1NcXKyf//zneuutt/ye37Fjhx588EG9++675c7VqlVLH374oQYPHqzS0tKw6me8sxZjSnk1a9bUkSNHbCvbn9zc3IDXFBQUqLi4WMnJyecdT05OVnp6uvLy8qxs4g9q1arl9/ipU6dsqc8qdvdpN4xB+fn5Ki0tVWJi4nnHk5OTVaVKFZ0+fdryOmvUqGF5mW7FPRuY08ZXyR33dKA2pqSkKC0tTWfOnIlRy3xi0efd0N+dzg1932peWIvBPklJSZaVVa1aNcvKgns4Mc9BYOTs3heLdbEU2dqYfhkZcr3Ys2sudMM86Kb7143jowkr83kp8pze6Xs5gBSfe0MAgOhJDB4CAPCSk4el1V+F9rV+rnn5F90oVbF4byHR2r2EmElKDh4jSaXF9rYjEkkpZnHR+B5KS8ziEg1fd1NF+daWdy7Tvl5i8+vr5D4YyKmjZnEJiVK6/73akJUUSQc2hfd1eIc1bahI9QbSqEek21+Vul1h/djsGGUxrDqGdbuSi16vH+3DBmR7H3DRaxYqJ8ynbrVhjlRUEDyu4xBrYrYtkU6fCB53Lq+/BxXy8H3rFnHd/wyx7nAn+rY3OGVfJVZ7Kl5ybI804XdSoeFnihq1l+q2sLVJYXHr3oEX9lmjKaWydOUj0Z1LtiwKHtOyV+Bzrcr/nqMflJVJ25aVP75tScX1JadKzboGbktCkKfm+bnSnjUVx/wY83f8ceu46vU1gkkO5uXnWna/b5JUXGgWZ5oPxyunrBekGK8Z2F8LmZPu81D6xPbl0qnDweOadZXSDT4v325A8Jh966WcA8Hjoiken0m5NWcKCc+wA4rndZKdz0f9+epZac/a6NbZuIN06wvSyN/41uFeF297VDzjD09czHtxgM9pxA7zWfTFzbjl8Lz5XF7fv42FqnWkzAqeU51r7Szr6g2lrC4jrKvXjbw6rxlx0fjkabwPjhLtnNBN+aAXcjdyfvvw2gIAAAAAAAAAAAAAAAAAAAAAAABA7B05ckSDBw/WzJkzja/5zW9+o3fffVfJyfySeAAAAMSvzMxMfffdd7r00kuNr9m4caMuvPBCLVy40MaWAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBa2b9+u119/XV26dNEf/vAHvzFpaWn6+c9/HnYd48aN83v8Zz/7md/jN998c7ljubm5mjRpUthtsFI0XjO7lZSU6PDhw+WOV6lSRZUrV45BixALXujLXtayZUtdf/315Y7n5+dr6NChev3111VUVBRxPXXr1o24jIpcffXVeuuttyqMee+99/TRRx/5PXfJJZcE7J8mGO+iJ17HlIyMDNvKbtCggd/jR44cqfC6ffv2+T1uZ1sDlX3w4EHb6rSbFX3aLWNQdna23+OB+mAkkpKS1LRpU8vLdTPuWf+cOL664Z4uLS2N6j0djmj3eTf0d6dzQ9+3klfWYohcSUmJ3+PVqlWzrI5mzZpZVhbcw4l5DipGzu590c6hrVgb0y/DQ67nDHb1U7fMg266f904Pp4VjXxeijynd8NeDhBve0MAgOhKjHUDAADRdWSXNPPl0L6m/E3anWVWfqV0qf9t9n4PQCwVF8a6BfAn96h5bJ04+Oxk677Sna9LHYdICQmxbg0AlMd8Gr6CPGnLwuBxtZtIDVoHPp+YLLXrH7ycNdPN2wYAABBPcg5I8982j8/sZVtTwsLeQXzJaCv1uyV69eUdCx7TpJOUWsXPiQSpZc/A12Vv9V/+4R3SyfKfrTpPZp8Ax3tXfJ0kbVsilfr/PCQgiXEVAICQlUlrZgYPS0iUOgwMHtf24uAxa78OHgN7kTMhnkX7+WhxofTxo9LKydGtV5I6Xybd9KyUXiv6dcM+POMPHfOed/A5jdhhPosuxi3EiwsulxKTgscd3imVFEnV61vzdXS3b04x0fkyszYCQDyIVU7o9HzQK7kbOb99eG0BAAAAAAAAAAAAAAAAAAAAAAAAwBny8vI0atQoffjhh8bX3HrrrZo8ebKqVPH3C5wBAAAAb7v44ou1ZMkStW/f3viab775Rn379tX27dttbBkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACc4Omnn9aLL77o99zw4cPDLverr77SgQMHyh2/9dZblZiYWO74mDFjyh2bNGmS8vLywm6DXex6zaJh9+7dfo9fcMEFUW4JnMDNfdmrRo4c6XeMfPXVV7Vs2TJL6khISFCDBg0sKSuQr776yiju3nvv1a5du/yee/LJJ9WvX7+w28B4F33xNKb06tXLlnIbNGigxo0blzteUlKibdu2VXjt+vXr/R6/8MILLWmbP3369PF7fN26dbbVGU2R9Gk3jEGbN2/2e9yO/t26dWslJydbXq6bcc/658TxVXLHPR0op+rZs2eUW+JftPu8G/q7G7ih71vFK2sxRO748eN+j9eoUcOyOtq2bWtZWXAPp+Y5CIyc3fuiuS6WrFkb0y/DQ67nDHbcW26aB910/7pxfDwrGvm8ZE1O7/S9HECKr70hAEB0lV+hAQDgx5xxUlmZWWyX4VLdFrY2B4gdw/sA0XUi2zzW6+NT759I1zwupabZX1dRvv11ALFQUmQWl1zJ3nak2Fx+TDGfRiRrullcxyGBz7XsJVWuVvH1ucek7cvN2wUAABBv1kyXigrMYhu2t7ctoWDvwBu2LZW+m2Aef9GNUqMO9rUnVIlJUvNu5Y9ntJGq1Ax83bYlgc9tX1pxnZm9/RxMkFoafEZw88LgMYhfjKtwsoRYNwCA7dx8n38/QyorDR7X8dKKzzdsL1WrV3FMSZG0aZ5526Ilnp5JkTMh7sXg+WhpifT1q9KkP0nZUf7ZzobtpBv/JqVE4Z5HlPCMPyTMe97D5zRih/ksOhi3EE+6GP4u7notpPvete7rnvFSpXSzutNrSq0vCvc7BADviVVO6NR80Gu5Gzm/fXhtAQAAAAAAAAAAAAAAAAAAAAAAAMAZioqKdMstt+iFF14wvmbEiBGaPXu2ateubV/DAAAAAIe55ZZb9M0336hu3brG1/zrX//S8OHDlZOTY1/DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4ChPPvmkCgsLyx3v1atX2GWWlJTo7bffLnc8IyNDl19++XnHevbsqbZt25aLHT9+fNj1282O1ywa1qxZ4/d4nz59otwSOIVb+7JXXXLJJX6Pf/TRR5bV0a1bN1WtWtWy8iJx8uRJ3XLLLSopKSl3LikpSR9++KFq1KgRVtmMd7ERL2NK3759bSn3oosu8nt8x44dKi4urvDatWvX+j3ev3//iNvlT6tWrdSgQYNyx4uKirRlyxZb6oyFcPu0G8agTZs2+T3er18/y+saOHCg5WW6Hfesf04cXyV33NOrV6/2e9yu1zRU0ezzbunvbuCGvm+VeFuLIbDjx4/7Pd6iRQvL6iA3ik9OzXMQGDm790VzXSxZM/7TL8NDrucMdsyFbpoH3XT/unF8PCsa+bxkTZudvpcDSPG1NwQAiK7EWDcAAOAO2duk9bPNYhOTpCE/t67u0vKfaXUl0+8jKdnedkSipMgsLhrfg2kdpm12ghLDfdSkFHvbYXf5dji8wzy2cUf72hFr7QZIg++REhKsK/PMKWn/BmndN9L8d6TJf5XeflB6/hpp9jjr6gGcpDDfLK5Sur3tqFTN3vK9yiu5Y0X2rJGO7w8e12GgpABzQqchwa9fO0sqKw2paZLi4z2ARSzMWc6i/wXHuiMK6NsIwCn7Kl7cU4mVogJp12qz2LrNbG2KMS/sHXhhnzVS6+dKn/9FWvCedMD/5wvLSUySRj0qpaTZ2rSQZPYuf6xVkM9BbV0c+Ny2JRVfW6OBVLvp+ccatZPSqld8XVG+tGNFxTH+MH/HBy+Mq15fI5jkNF5+rhWNtZdpHaXO+nkCx3HKeiGUOlgzOIOT7nPTOeWsk4eknSuDx2W0lmo3CXy+3YDgZWxbKuXnmrctWuLlmZQXciZYg3VSbOxYLr3zoPT5WGnLd1Jx+d/dZou6zaUrfhudumKBPSrreG1sYN7zJj6nEXvMZ/Zh3HI2r+/fRlvz7r7nRW7QdUSsWxA78TCvAZ5iw2flAolFTui0fNDLuRs5v314bQEAAAAAAAAAAAAAAAAAAAAAAADAGX71q1/p0UcfVVlZmVH8hRdeqIULF6pZM4f8gnMAAADARmPHjtV7772nSpUqGcWXlJToN7/5je655x4VF/NL8AEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOJJTk6OVq5cWe54amqqqlevHna5b7zxht+/P3v77bef9/9jxowpF7N161YtWLAg7LrtZtdrdq6kpCRLyjnXsmXL/B4fPHiw5XXBHaLRl2GuYcOGfo9v3LjRsjqGDBliWVlWWLhwof7617/6Pde8eXO98cYbYZXLeBcb8TKmDBkyRKmpqZaXO3LkSL/HTXKiWbNm+T0+atQoW3KKq6++2u/xefPmqaioyPL6YiXcPu2GMWj+/Pl+j48YMcLyuq688krLy4wmO+4h7ln/nDi+Su64pxcvXuz3eKDvPdqi2efd0t/dwA193yrxuBaDf8eOHfN7vEePHpaUn5SUpOHDh1tSVrTZkaPEE6fmOQiMnN37orkulqxZG9Mvw0Ou5wx2zIVumgfddP+6cXw8y+58XrIup3f6Xo4p1gneFk97QwCA6EqOdQMAAO7x7VtS2/5SSqXgsS16SJm9pe3+1zIhKTHc/5z+glRUEHl94dofZI+zuNCsnNQqkbfFLoVnzOIqpdvbDkmqXNUszrTNTlCUbxZn9+trco87TeFp6US2VKNB8NimF9jfnlio1UQa8Zvwri0ulI7tPf/r+H7p+F4pP9fadgJuYDoem85F4bK7fK9yS+4oBc8fK/L9DOmSOyqOqVpHatZF2p11/vGUNKnVhQZ1zAyvbfHyHiByySnWl+mW/hfLvse6w37x3LclxtaKOGVfxYt7KrF04qBZXOVq9rbDhFf2DrywzxqJVV9Ks16V9H+/N+irZ6XbX5WSDT4PWjNDGnq/NO0ftjZRknR4p1SvRcUxmb38HOsdOD73mJS9NfD5Xat982BFeUZmL+nYnnP+v0/FbZSkHSuk4jDmV+Zv7/PKuOr1NYJJTuPl51opla0tzx/yS2s4Zb0g8Z66TVTuc8P1TOHp0MvOmi619JMX/ljHIdKCd/2fa9c/+PVrvw6tXdESD8+kvJIzwRqsk2JryyLfV2oVqWVPKaOtlNFaqt9KSrPpdxG2vVhq089Xr9fE+x6VldwyNpiMC8x73sbnNKwR6RzLfGYtxi3n8/r+bbR1tef3c9iiRQ+pegPpZHasWxJ98TSvAV5gx2flgol2TuiUfDBecjdyfvvw2gIAAAAAAAAAAAAAAAAAAAAAAABA7P39739Xdna2/vWvfyk5OfifEm7fvr0WLVqkYcOGad26dVFoIQAAABBdlStX1nvvvafrrrvO+Jrc3FzddNNNmjJlio0tAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgBUyMjJ08OBBy8vdv3+/3+M1a9bUyZMnwypzx44dmj17ti699NLzjl911VWqUaOGTpw4ocTERP30pz8td+1bb70VVp3+OP01y8vL83u8WrVqYbWrIjNmzPB7fPTo0apfv74OHTpkeZ2wjtP7MiJXq1Ytv8fz8/MtKT8hIUE///nPLSnLSn/5y180dOhQ9e3bt9y566+/XnfeeafGjx8fUpmMd8ExpoSvbt26uummm/TOO+9YVmbt2rV16623+j03ffr0oNfPnTtXubm5qlq16nnHmzZtquuuu04ff/yxJe2UpKSkJD388MN+z02ePNmyekLlpD7thjFo1qxZfo+3a9dOl19+uWbOnGlJPU2bNtWIESMsKctu0czLuWf9c+L4Krnjnp4+fbrKysqUkJBw3vEOHTro0ksv1TfffBOjlvlEq8+7qb+7gRv6vlXidS2G8tavX+/3eN26ddWhQwdt2LAhovKvueYaNWjQIKIy7BbNnCieODXPQWDk7N4XrXWxZN3amH4ZHnI9Z7B6LnTbPOim+9eN4+NZdufzknU5vdP3cn6MdUJ8iqe9IQBAdCXHugEAAPfIPSIt/1zqW/5nDfwa/HNpxwqprDSyeosLzeJ2Z0k5ByKry07FBWZxlaoGj4mVwtNmcdH4HkzrKPS/j+JIRWfM4iql29sOJ/fBimRvlWoY7BVWrS01bC8d2Gh/m6JpwG1SamXz+P0bpU3zpF1Z0uEdkY/VgJfkG/6MRc2G9rajTlN7y/cqr+SOwXw/S+p/m5SYVHFcx8G+7/VcbfpKKZUqvm7PWun4vvDaFi/vQbz50XNUS6SkWV8m/S841h3no28jmpyyr+LFPZVYyjtuFmf3uGrCK3sHXthnDdeiD6UF755/7Nhead5b0pB7zcq44HJp2xJp80Lr23euzQulei0qjqlWT6rTTDq62/f/aTWkjLaB47ctrbi84kLfXNiqT+CYVn18zznOyuxdcZlS+K8V87f3eWVc9foawSQH8/JzrcrR+N4M+0ahYV+LV05ZL4RSB2sGZ4jGfV7Z8D4vCuPnwrZ+J53OkarUrDiu45DyubAkNWgT/BnxmZPS9mWhty0a4uGZlFdyJliDdZIzFJ6WNs33fZ1VKd031pz9qtVIqtlIqtVQqlo3sr30/rdKWxZF3m6niec9Kqt5aWxg3vM2PqfhLMxn1mDccj6v799GU1p133jsFgmJUpdh/vdDvC4e5zUgWtzyWTlTFeWELXp4Lx+Mt9yNnN8+vLYAAAAAAAAAAAAAAAAAAAAAAAAAEFvvvPOOjhw5ookTJ6pKlSpB4xs3bqz58+fryiuv1MKFNv9iaQAAACCKGjRooMmTJ6tPnwr+yMiP7N27V6NGjVJWVlbwYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMRMkyZN9Mc//lF33nmnbrjhBv373/+2tPzU1FS/x0+fPh1RuePGjdOll1563rHKlSvrhhtu0BtvvKEhQ4YoIyPjvPOlpaV69913I6pXcs9rduzYMb/HW7RoEWqTgtqxY4eysrLUtWvX846npKTo5z//uZ566inL6qpWrZqqVq2qAwcOWFZmvHJLX0bkTp486fd4vXr1tH///ojLv+GGG9S2bduIy7FaSUmJbr75ZmVlZal69erlzr/88stauHChNm3aZFwm411gjCnW+O1vf6sPPvhAxcXFlpT38MMPKy0trdzxM2fOaPr06UGvLyoq0scff6y77rqr3Lk//vGP+uyzz1RUVGRJW++++241adKk3PHCwkJNnDjRkjpC4cQ+7YYxKDs7W4sWLVK/fv3KnXvsscc0c+ZMS9o3duxYJSUlWVKW3aKZl8fzPRuM08ZXyR339MGDB7VgwQINGDCg3LnHHntM33zzjVVN1H333acVK1Zo2bJlxtdEq8+7rb87nRv6vlXidS2G8rZv367s7Gw1aNCg3Lnbb79djz76aNhlJyUl6cknn4ygddERzZwo3jgxz0Fg5OzeF611sWTd2ph+GR5yPeewci502zzopvvXjePjWXbm85K1Ob3T93J+jHVCfIqnvSEAQHQlxroBAAB3WfyxlJdjFlunqdTtisjrPG1YX3rtyOuyU57/9Xw5adXsbUck8nPN4qrUsLcdkvnrlJ9nbzusVHjGLM7u17dmRvAYJ9q5yjy242D72hELdZtL7crvbfp1cIv07i+l9x+Wln0mHdomlZWGV29qlfCuA5zu2D6zuEbt7W1H4472lu9VXskdg8k7Ju1YETyu3QApKeX8Y52GBL/u+xnhtUuKn/cg3qRUtr5MO/Ja+l9wrDvOR99GNDllX8WLeyqxVFpiFpcY45/n9NLegRf2WUNVVibN/l9pQYDf+bP8C2nP9+blDXtISq9lSdMC2rLQLC6z13/+3bKnlJAQOHbr4uDlBYtp0vk/8396LalB64rjS4qlbUuC1+sP87e3eWlc9foawSQH8/JzrRpRWHulGb5+pn0tXjllvSCxZnCbqNzn5X/3mF+FYfweq9ISae3XweNqZvh/LtPeYD7e+K1Uas3PEFvO68+kvJQzwRqsk5yrIE/K3iptmi8tmShNf0H66BHptVulf4yW/nWP9NmT0sL3pQPmv3dSklSvpdT0AjtaHVvxuEdlF6+MDcx73sfnNJyP+Sw0jFvu4PX922jqPLT8+Ox0F1wuJcThT34yrwH2cctn5SJxNif0Wj5I7uZDzm8fXlsAAAAAAAAAAAAAAAAAAAAAAAAAiK6vvvpKl156qY4dM/tlRrVq1dKsWbM0evRom1sGAAAAREfnzp21dOlS9enTx/iaFStWqE+fPsrKyrKxZQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIhEkyZN9Oqrr2rbtm267777lJqaqpdeekm1a9e2tJ7WrVuXO1ZcXKwjR45EVO7nn3/ut4zbb79dkjRmzJhy52bNmqW9e/eGXafbXrN9+/b5Pd6iRQs1btw4rLZV5I033vB7/A9/+IPatm1rWT3PPfecNm3apF//+tdKSkqyrNx44ra+jMgFes379esXcdkNGzbUiy++GHE5dtm5c6ceeOABv+eqVKmijz76SKmpqSGVyXh3PsYUa3Xu3FnPPvusJWX1799fjz32mN9zH3zwgU6cOGFUznPPPaeysrJyxy+44AK98MILkTTxB126dNHzzz/v99x7772ngwcPWlKPCaf3aTeMQf/85z/9Hh80aJAeeeSRiNs2ZMgQ/exnP4u4nGiJdl4eb/esKSeOr5I77unXXnvN7/FLL71UDz30kBXNU48ePfTKK69o6dKlmjlzpgYMGGB8rd193o393Q3c0PetEM9rMZS3aNEiv8fvvPPOiHLNRx99VJ06dQr7+miJdk4UT5ya5yAwcnbvs3tdLFm/NqZfho5czzmsmgvdOg+66f514/h4ll35vGR9Tu/0vZxzsU6IX/GyNwQAiK7EWDcAAOAuRWekBe+ax/e/VapUNbI6Tx01i6tWN7J67HbK8DOb9TLtbUckjhn+TElGG3vbUaeZlFI5eFxpiZRzwN62WOmE4X5/g/KfobRU7Sb2lm+XnSvMYzsPlVKr2NeWaOswSEpICB63b4P04W+lg5utqbdKdWvKAZzm2B6zuIbtpAQbV9WNO9pXtpd5JXc0sWZ68JhK6VJm7//8f5UaUvPuFV9TeFraNC/8dsXTe+AFZaVmcalp1tddy4bnmvS/4OJl3UHfhhM5YV/Fq3sqsWSyHpckP59Tiyov7R14YZ81FKUl0rR/SMs/ryCoTJr6P1LhGbMy06pLI39rSfMCOrRdyjHIO85dr7TqEziuuFDavSp4eduXVnw+KUVq3s3375a9gt8Xu7Okgrzg9frD/O1tXhpXvb5GMMnBvPxcq3o9KaWStWWeJ0Gq39Is1LSvxSsnrBck1gxuFJX7vJVZqEn+50+WwV63JHW8tPyxtv2DX7f269DaE01efyblpZwJ1mCd5E4lRb7xautiaeH70nsP+b4ObTcvo0VP+9oXK/G2R2Unr4wNzHvxgc9puBfzWXmMW+7g9f3baOoyItYtCF21ulJmr1i3IvqY14DQee2zcnZwez5I7hac299jJ+O1BQAAAAAAAAAAAAAAAAAAAAAAAAB7LF68WP3799eePWa/lC4tLU2fffaZ7rnnHptbBgAAANhr+PDhWrRokZo1a2Z8zeeff65LLrlEBw7wy9EBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACc7PXXX9f999+v1NTUH441a9ZMkyZNUlpamiV19OjRQ+3bty93fN++fRGXXVRUpHfffbfc8X79+qlLly669tpry50bP358RHW67TU7dOiQdu7c6ffcAw88EHJ5wYwfP17Z2dnljqelpWnChAmqWrVqxHXcfvvtuueee1StWjU999xzysrK0oABAyIuN964rS8jcps2bfJ7/N57742o3LS0NE2aNEkNGjSIqBy7ffDBB/rwww/9nuvWrZueeeaZkMpjvDufk8eUlJQUvfzyywG/nOrhhx/WPffcE1EZ7dq108cff6zk5ORy50pKSvT8888bl7VhwwZNnDjR77kHHnhAv/rVr8JupyS1atVKX3zxhd/+UlBQoKeffjqi8kPl5D4tuWMMmjRpknbv3u333F//+lddffXVYbetbdu2+vjjj5WQkBB2GdEW7bw83u7ZUDhtfJXccU9//PHHAfPJZ599ViNHjoyoffXr19cnn3yipKQkSdJll12mefPmad68eWrUqFHQ6+3s827u707nhr5vhXhfi+F8gcaqunXr6sUXXwy73LFjx4Z9bTRFOyeKN07McxAYObv32bkuluxZG9MvQ0eu5yxWzIVunQfddP+6cXw8y658ftSoUZbn9E7fyzkX64T4FS97QwCA6EqMdQMAAO6zZrp01P9eRTlp1aV+N0dW34kDZnGNyn+uzFFyDL+Phm3tbUckDu80i2vUwdZmGJefs18qLba3LVY6ZvjzAg1t7utNu9hbvl1yDpi/hpXSpR6j7W1PNLXoYRY340WpuMC6eqvWsa4swElM57tK6VJmH3vaULe51LCdPWV7nVdyRxPblkh5OcHjOg7+z7/bXSIlJlUcv2GeVBTBfBFP74EXFBeaxVWpaW29dZpJKZWsLVOi/5mIl3UHfRtO5IR9Fa/uqcSS6ThSlG9rM4Ly0t6BF/ZZQ3Fou7R2VvC4E9nSnDfMy23Z0/79sS2Lgsc06eybOxMSfW0KZHeW2Trl1BHfa1aRs2v5zN7By9u8MHhMIMzf3ualcdXrawSTHMzLz7USEqXGna0t81x1mvr2SU2Y9rV45YT1Qijls2ZwDrvv87rNpVTD3xcU7n1+fK+0Z23wuPaX+L7fs+pnSrWC/BzGsX3SAf8/I+IIXn8m5aWcCdZgneQdBzZJ7/9KOrjZLL55V3vbEwvxtkdlJ6+MDcx78YHPaXhLvM9njFvu4PX922hp3Mm3l+lGXUfEugXRx7wGhM5rn5WLFjflg+Ru4XHTe+w2vLYAAAAAAAAAAAAAAAAAAAAAAAAAYI0NGzaoX79+WrvW4BfySUpKStK4ceP05z//2eaWAQAAAPZ48MEHNWXKFFWrVs34mmeffVY/+clPdPr0aRtbBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACv8+c9/VllZWbnjQ4YM0TfffKOmTZtGVH6NGjX01ltv+T03bdq0iMo+a9y4cX6Pv//+++X+Dtfx48f1xRdfRFSfG1+zuXPn+j3+u9/9ToMHDw6rzEDOnDkT8G/69ujRQ/Pnz1eDBg3CLv/BBx/Um2++ed6xTp06ad68ebriiivCLjceubEvIzIzZszwe3zo0KG6++67wyozIyND8+fP18UXX/zDsZUrV4ZVVjTcd9992rlzp99zDz/8sEaMGGFcFuPd+Zw8pqSkpOgXv/hFwC8nGzdunJ5//nklJSWFfO3w4cO1ZMkSNWrUyO/5119/XevXrw+pzIceekg5OTl+z/3jH//Q66+/rtTU1FCbqksvvVRLly5Vy5Yt/Z4fO3astm3bFnK5kXByn5bcMQYVFRXp17/+td9zSUlJ+uyzz8Jq26BBg7RgwQLVrVv3h2N79+4Nq6xoi2ZeLsXXPRvMvn37zvt/p42vbrinS0tL9atf/crvuZSUFE2ePFkPPfRQWO1r27at5s2b57dP1atXT9nZ2Ubl2NXn3dbf3cQNfd8KrMVwrkmTJmnPnj1+z40ZM0bPPPNMyGXecccd581pmzZtCrt90RDtnMjrnJ7noGLk7N5msi7+/e9/H1bZdq6N6ZehIddznkjnQjfPg265f906Pkr25fOfffaZ5Tm9G/ZyzsU6IT7Fy94QACC6EmPdAACA+5SVSnPeMI/vMVqq5X8Pycih7WZxTTqHX0c0HNxqFle3uZRaxd62hOvITrO4mg2lavXsa0ezLmZxR3bb1wY7HN8XPEaSajeW0mvZ04bEJKl5d3vKjoa1s8xjL/qpVLVu8Dg3yGgTPObwTvN72FTjTtaWBzhF9lYpP9cstscoe9rQY7Q95cYDr+SOJkpLpHVfB49rdeF/8stOQ4LHfz89snbF03vgBYVnzOLq+X/2HbaWPa0t7yz6X3Dxsu6gbyNcCQn2le2EfRWv7qnEUvX6ZnGFp+1tR0USk721d+CFfdaQlP+Z7YCypko7lpvHD7pbqtMs9CaZ2rwgeExSitSsm9SwnVS5WuC4rYvN6922tOLzmb2lhESpRY+K48rKpK3fmdf7Y8zf3uW1cdXrawST98Drz7Uye9tTrmQ+hhUVSKcO29eOc9mZ09vJCesFKfb9FeGx8z5vGsJ9nnsk/HqypgaPqVLj/L2XdgOCX2Oyhx5LXn4m5bWcCdZgneQtxQXSjBfNYk330Nwk7vaobOSFsYF5rzy3rs2C4XMa3hOv8xnjlnt4ff82Wrqa/950x8nsI6XXjnUroot5LX54NWeMBa99Vi6a3JAPkrtFxmnvsZfGPqe9tgAAAAAAAAAAAAAAAAAAAAAAAADgVnv37tWAAQO0YIHBL3T+P2PHjtU///lPJSby54gBAADgDomJiXr55Zf1yiuvKCkpyeiaoqIi3X333XrkkUdUVhbCH28BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAzKxatUqvvfaa33N9+/bV+vXr9ec//1n16tULuezLLrtMS5YsUZcuXfyenzRpUshl+rNp0ya/f2/2ggsuKHdswoQJKiwsjKg+N75mgdqbkpKimTNn6rnnnlOrVq3CKtufN954Q19//bXfc926ddPatWv1i1/8QsnJycZldu7cWVOmTNErr7zi928FL1u2TNOmTQu7zfHIjX0ZkVmwYIGOHDni99z//u//6s9//rPxfZmSkqJf/OIXWrNmjXr27PnD8RMnTuhPf/qTJe21w6lTp3TzzTerpKTE7/l33nlHGRkZxuUx3v0HY4p1VqxYcd7/P/zww9qwYYOuv/56JSQkBL2+U6dO+uKLLzRt2jTVqFHDb8yePXvCulezs7N17733Bjx/7733avPmzRozZoxRv+/QoYM+/fRTff3116pdu7bfmEWLFunvf/97yG2NlBv6tBvGoE8//VRTpkzxey4hIUGrVq3SiBEjjMpq27at3nrrLc2ePfu81z0/P19/+MMfjNsUS9HOy+Ppng3mzTff1ObNm8875qTxVXLHPT1t2jSNGzfO77mkpCS98MILWr58uS6//HKj8tLT0/XYY49p5cqVateuXbnzZWVlevjhhwPmbj9mV593W393Gzf0/UixFsO5SkpK9I9//CPg+UceeURTp05V27Ztg5bVrVs3ffXVVxo/fvwPx9asWaOJEyda0la7RDsn8jo35DkIjJzd+4Kti59++mnHrY3pl6Eh13MGK/dU/XHLPOim+9eN46NkXz6fkpLyw3Erc3qn7+Wci3VC/IqHvSEAQHSZzxgAAJxj+zJp1yqpeffgsUnJ0qC7pc/HhldX9lazuPqZUpWa0umc8Oqx26FtUlmplFB+3XWexCSp81Bp5eTotCsUh3f6Xt8qNYPHdh8lzXvL+jak1ZDaDTCL3bXK+vrtdHCzVFYmGezRqusIadGH1rehXX8prZr15UbL2q+lAbcFv88kKbWyNPLX0sQ/SiqzvWm2Mvl+D++0ts7q9aWa5j9DALhKWam0O0tqe3Hw2BY9pUbtpf0brau/dhOp82XWlRdvvJI7mlozXepzXcUxyam+/rzne6lRh4pjj+6OvD/H23vgdnnHpDpNg8c1sPi5o13jHP0vuHhZd9C37WmHm5UUmcWlptnXhljvq3h5TyVWklKkFgb7o5KUc9DetlSkSg1v7R14YZ/VTtOel+78X6ly1eCxyanSqEel9x6SSoutb8u+DVLecSm9VsVxmb2k/NyKY7YtNa932xKp708Dn69eT+o6MvhrtP//2h8u5m/v8tq46vU1gmkO5uXnWp0uleaNl4oj+/1xfnUdaRZ3YFPkdTkhp7dTrNcLkjP6K8Jj533ebZRZ3IEI95U3L5DyHwieo3Uc4vu8iuSbPypSViatnx1Zu+zm5WdSXsuZYA3WSd6TvU06vl+q1ajiuLTq0WlPNLFHZR0vjA3xNO95fW1mgs9peE88zmfxNG65ndf3b6MhtYr5ntfWJVKu/9+FY7mMdlJG6+BxiUnSBZdLiz+yv01OwbzmfuSM0ee1z8pFm9PzQXK3yEXjPY7Xsc/p9w8AAAAAAAAAAAAAAAAAAAAAAAAAuEVOTo4uu+wyffzxxxo9erTRNQ888IDq16+vW265RYWFNvwyQgAAAMAi1apV08cff6wRI0YYX3Ps2DH95Cc/0dy5c+1rGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGzxq1/9Sn369FGvXr3KnatatarGjh2rP//5z/ruu+80Z84cbdiwQTt37tSpU6d0+vRpJSQkKD09XTVq1FCrVq3UrVs3XXHFFWrbtm3AOqdPn67Zs2db9j2MGzdO/fv3Dxo3fvx4S+pz22u2dOlSzZkzR4MHDy53Ljk5Wb/+9a/161//WtnZ2dqzZ49Onjyp0tLScrFHjhzRTTfdZFTnT3/6Uy1btkwtW7Ysd65u3bp6+eWX9ac//UnTp0/XrFmztGfPHh06dEinT59WamqqqlWrpmbNmumCCy7QiBEj1LdvXyUkJPit6+DBg7rhhhv8thkVc1tfRmQKCgr03//933r++efLnUtMTNTYsWN133336b333tP8+fO1ceNG5eTkKD8/XzVq1FD9+vXVunVrDRs2TFdccYUaNmx4XhllZWW6/fbblZ2dHa1vKSzfffednnrqKT3xxBPlztWrV0/vvfeeLrvsMuPyGO/+gzHFGnfccYeWLl2qypUr/3CsTZs2mjhxoo4eParp06dr+fLlys7O1rFjx1StWjXVr19fbdq00fDhw9W+ffsKyy8oKNC1116rnJycsNo3ceJEderUSY8//rjf882bN9d7772nV155RTNmzNDSpUuVnZ2tI0eOKD09XQ0aNFDr1q01fPhwdejQocK6du7cqauuukrFxcVhtTVSbujTbhiDxowZo+XLl6t169blznXr1k1Tp05Vdna2pk+frtWrVys7O1vHjx9XpUqVVLt2bXXq1EmDBw9Wjx49/Jb/0EMPadu2bSG1KVZikZfH0z1bkYKCAt16662aP3++UlNTfzjupPFVcsc9/Ytf/ELt2rXTwIED/Z7v2bOnZsyYocOHD2vmzJlatWqVDh06pKNHj0qSatSooRYtWqhPnz4aNmyY0tLSAtb17LPPasaMGSG1L1p93sn93Y3c0PcjwVoMP/bSSy/pqquu0qBBg/yeHzFihIYNG6YlS5Zo5syZ2rlzpw4fPixJqlOnjjp37qyhQ4eqe/fu511XWFio22+/XVdeeaXd30JEYpETeZlb8hwERs7ufRWtiyVnro3pl+bI9ZzBzj1Vt82Dbrp/3Tg+Svbl85I9Ob3T93LOYp0Q37y+NwQAiK7kWDcAAOBec96QfvaKlJAYPLZNP6lpF2nPmtDryTsuHd0t1WlWcVxiktR1hPTdhNDriIaCPOnAJqlRxXtIkqQeV0orJ1vfhvqZ0qHtERRQJm1bKl1wefDQriOlRR9KxQUR1OdH9yuk5NTgcZK0dYm1ddvt9Anp8A7f+xRMt1HS4olSqZXPChKkPtdbWF4M5B6Rti72jTkmWvSQBt4hfWvNz005WuFpa8vrOtLa8gCn2fKd1Pbi4HEJCdLI30lvP2DNnJeQKF3xO/O5DuV5JXc0dWyvtG+91LhjxXEdB0tV6wQvb014z63OE2/vgdudPGQW17y7lFJJKrJgrGvWzSznDQf9L7h4WXfQt+1ph5vl55rFpdeysREx3lfx8p5KrHQaIlVKN4s9tsfetlSkSg2zOLfsHXhin9VGuUelr1+VRj1iFt+glTTgNpv2x8qkLYukbldUHNayt+99DeTQdunUYfNq92/05TwV9f0BtwUvZ/MC8zr9Yf72Lq+Nq55fIxjmYF5+rpVWzTfOrPi3teU26SRl+P9Mezk7V0RenyNyejvxHBYRsOs+b9ZNqtfCLHZHhPd5caG0fo4vh69Im76+vZzqDaTaTSuO3btOOuGCny3z6jMpr+VMsAbrpNho1ME3zh6y6XeN5eyXajWqOCYpRUquZH3+EkvsUVnHC2NDPM17nl+bGeBzGrHBfGateBq33M7z+7dR0HGIby8hmMJ86cunpaJ8+9sk+X625qa/m8V2HSEt/sje9jhJPMxrXkfOGH1e+6xcIHbmhE7OB+Mld3N7zu/ksc/try0AAAAAAAAAAAAAAAAAAAAAAAAAxIv8/Hxdc801GjdunO666y6ja6677jrVqVNHV111lU6dOmVzCwEAAIDQtWjRQlOmTFGnTp2Mr9myZYtGjhyprVu32tgyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2KWwsFAjRozQ9OnT1bNnT78xKSkpuuSSS3TJJZdEXN/Ro0d13333RVzOuSZNmqSXXnpJNWvWDBizdu1arVixwpL63Pia3XHHHcrKylKNGjUCxjRo0EANGjQIeH7v3r3G9R09elSXXnqpZs+erRYtWgSs72c/+5l+9rOfGZf7Y4cOHdLw4cO1c+fOsMuIZ27sy4jMq6++qttuu03du3f3e75Ro0Z69NFH9eijj4Zc9qOPPqovvvhCPXr0iLSZths7dqwuu+wy9evXr9y5oUOH6re//a3+53/+x6gsxrv/YEyxxvfff68xY8Zo4sSJSkxMPO9cnTp1dMstt+iWW24Jq+yCggJdf/31Wr58eURtfOKJJ5SQkKA///nPAWNq1KihG264QTfccENYdWzcuFHDhg3TkSNHwm1mxNzQp90wBp04cULDhg3TN998Y3kbX3rpJY0bN87veO5U0c7Lpfi5Z4NZunSp7rnnHr399ttKSEg475xTxlc33NNFRUUaNWqUvvzySw0aNChgXL169SJ6Td9++239/ve/D+tau/u8G/q727ih70eKtRjOVVpaqptuukmrV68OOOcnJiaqb9++6tu3r3G5v/jFL7Rq1SpdeeWVVjXVNrHIibzMDXkOKkbO7m0m62LJeWtj+qU5cr3Ys2tP1a3zoFvuX7eOj3bl85I9Ob0b9nLOYp0Qv+JhbwgAED2JwUMAAPDv0HZp3Tfm8UPulZQQNMyv7Yb7Td2vlJJSwqujIt2ukCqlR17OtqVmcbWbSl1HRl7fuepnSj97RRrzgtSsW/jlbFlkFpdWTRp0V/j1+FOrsdTnOrPYQ9ulU4etrT8adq02i6taW+p3s7V1d79CatDa2jJjYcF7UlmZefyFN0j9wtvjc5W06taVlVpF6uH8z1kAEdk0T8rPNYut3Vga8SspwYIV9tAHpIbtIi8n3sU6d5Ssyx9NrJkePKZZV6lbkPyytCS0/L4i8fYeuNnhHWZxKZWlNhdHXl9ConTpvZGXU5FY9z839L14WHfQt+1pgxv6dyD5p8ziMtra245Y7avEw55KtFWrJw26xzx+d5Z9bQnGdExw096BF/ZZ7bR+tvl4I/nGh6YX2NOWzQbtqJkhNWgV+Py2JSFWWibtCDJvmvR3k7YHw/ztTV4cV72+RjAZE73+XKv/bVJ6LevKS0yWBv/cPH7nqsjrdEpObyeewyISVt/nyamh7XVYcZ+vmRY8JqWy1Lqf1G5A8Nh1X0fepmjw6jMpL+ZMsAbrpOjJaCtd95Q05nlp2C9j3RpJIXyWxy3Yo7JOrMeGSMeFeJr34mFtZoLPafhnxxzLfGaPeBq3vMDr+7d26zrCLG7LQqko3962nGvPGulEtllsjQZSc/+/m8ezvDqvxQtyxujz4mflzuWonDAG+aDXczdHvb9S2O+xE8c+r7y2AAAAAAAAAAAAAAAAAAAAAAAAABBPSktLdffdd+u///u/ja8ZPHiw5s2bpwYNGtjYMgAAACB0F110kZYsWaJOnToZX/Ptt9/qwgsv1NatW21sGQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOx25MgRDRo0SJ9//rmt9ezfv18DBgzQrl27LC03Pz9fH3zwQYUxb775pqV1uu0127Vrl6655hrl5ORY0zADO3bsUL9+/bRw4UJbyl+9erV69eqlrKwsW8qPF27ry4hMYWGhRowYoR07dlhWZlFRke699149++yzlpVpt9LSUt188806efKk3/N//etf1atXL+PyGO/+gzHFGp9++qluuOEGnTlzxrIyDx8+rOHDh+vLL7+0pLzHH39cd955p3Jzcy0p71xTp05Vv379tHv3bsvLDpUb+rQbxqDt27fr4osv1ooVKyxr19/+9jc99NBDlpUXLbHIy6X4uWeDeffdd3XbbbepqKjIsjKtHl/dcE/n5uZq2LBhev311y1smU9ZWZmeeeYZ3XHHHSorKwu7HLv6vJv6u9u4oe9HgrUYfuzgwYMaMGCAtmzZYkl5Dz30kN544w1LyoqGWOVEXuaGPAcVI2f3NjvWxZL9a2P6pRlyPWewek/V7fOgW+5ft46PVufzpaWltub0btjLkVgnxDuv7w0BAKInMdYNAAC427x3pKICs9gGraQLLguvnvVzzOKq1pYG3R1eHYF0GChd/v+ku96Q2vSLrKx1s6WyUrPYIfdKdZtHVt9ZyZWkKx6REhKlRu2ln/5NuvFvUsP2oZe1bal0Itsstsdoqd2A0OvwJzlVuuqPUmoVs/hVU6ypN9o2zDWP7ftTqXk3a+pt0EoadI81ZcXa4R3S5hD3S/rfKl3xO9+9Eg0JCdGp51yNwrjfA7n8/0mV0q0rD3Ci4kJp7dfm8R0G+eapxOTw6ktIlIY/LHUfFd71OF8sc0fJ2vzRxMZvpcIgz3wTk6Tq9SuO2bZEOp1jTZvi7T1ws4NbzWMvHiMlpURW3yV3SPVaRlZGMF5ZP9opHtYd9G3r63dL/w7EdI5r1kVKr2VfO2KxrxIveyrRVKuJdMtzUuWqZvElRdLOlfa2qSJF+WZxbto78MI+q91mvCidPmEWm5Do2xszHSdCsXu1lB/hZzK3LgnjmsWR1Xlou3TiYGRlSMzfXuXFcdXrawTTHMzLz7UqpUuj/+DbI7LCkJ9LDduZxR7bKx3cHHmdTsnp7cRzWETC6vt86IPmex3H9kjZFvycyKHtZuNFpyHB+39xobRpfuRtigavPpPyYs4Ea7BOsl/9TOnaJ6XbXpIy/+93QjZsJ110oz311WwUPKas1DfeVaTtxdKVvzf7sioPihR7VNZx+/O9eJr34mFtZoLPaZRn9RzLfGaveBq3vMDr+7d2atDa932YWDvL3rZEWmfXEfa1w4m8Nq/FG3LG6PPiZ+Wk6OaEVuWDdvBq7ubWnD8QJ419XnttAQAAAAAAAAAAAAAAAAAAAAAAACAe/elPf9L/+3//T6WlZr/kqFu3blq0aJFatTL8IXsAAADAZjfeeKPmzJmj+vWD/FK+c7z99tu67LLLdPz4cRtbBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgGjJzc3Vtddeq+uuu067d++2vPwPP/xQvXr10oYNGywvW5LGjRsX8FxRUZHef/99y+t022s2Z84c9e7dW99++60l5Zk4cOCABg4cqEceeUR5eXmWlHnmzBk99thj6t27t/bs2WNJmfHObX0ZkcnOztaFF16or776KuKysrKy1Lt37wrHYKfatWuX7rvvPr/nUlJS9NFHH6lq1arG5THe/QdjijU+/fRTXXTRRVq5cqUlZXXq1Elz586NvGHneOutt9S5c2dNnTrVkvIOHjyo22+/XVdccYWj/maqG/q0G8ag/fv368ILL9QTTzyh/Pz8sMs5fPiwRo8ercceeyziNsVKLPJyKX7u2WDef/99XXTRRdq0aVPEZdk1vrrhni4sLNT999+vESNGaPPmzRa0UNq+fbuGDRum3//+95aUZ2Wfd2t/dxs39P1IsBbDj23ZssWSPnHkyBG99NJLFrUqemKVE3mZG/IcVIyc3dusWhdL0V0b0y/NkOs5g1V7ql6ZB91y/7p1fLQyn7/iiitsz+ndsJcjsU6Id17fGwIAREdirBsAAHC33CPSsk/N4wfcLqVUDr2e7C3Soe1msT2vktr0C70Ofxq1l4b/2vfvqrWlax6XrvqjVKVmeOWdzJZ2rDCLTakkXfeUVK9leHWdlZQiXf1nqV6L84837ybd+oJ07ZOh1VFWGtp7fsXvpPYDzeP9qVxNuv6/pfqZZvF5OdLaWZHVGSsHN0sHt5jFJiT63tsWPSKrs24L6Sf/5etzXjH7danwdGjXdLpUuvN/pdZ97WmT5Bv/eoz2vW/RVq2ulNk78nJ6XCV1HBx5OYAbLJ0kFYXwHKbtxdKdr0kte4VWT6MO0m0vS12Gh3YdAotV7ihZnz+aKCqQNlrwnGjN9MjLOCve3gM327/B14dM1GokDfhZ+HV1HSldeH3415vyyvrRTvGw7qBvM7b+2AHDz30kpUgD77SvHdHeV4mnPZVoSK0i9b9NuuNVqXp98+u2Lpbyc+1rVzCnjprFuWnvwAv7rHY7fUKaGcLn66rXly570Pp2lJZI25eGf/3pHOlAGD/rsWOFr+5wbV4Y/rXnYv72Ji+Oq15fI4SSg3n5uVbTC6Qrfy8lJkdWziV3+J51mFr5ZWT1neWUnN5OPIdFpKy4zxMSpUvvk7oMM79m5ZTw6/uxLIN96pY9y+flP7Z1sVRgzWfro8KLz6S8mDPBGqyT7FOnmXTVn6Sf/VNqfVH58wN+JnUcYm2djdr79tiDyTUYE+q2kDoMMvtyyh4Me1TWcfvzvXia9+JhbWaCz2mcz8o5lvksOuJp3PICr+/f2qnrCLO4U4elXVn2tsWftV9LZWVmsW36SWk17G2Pk3hlXotX5IzR57XPykU7J7QyH7SD13I3t+f8gThh7PPqawsAAAAAAAAAAAAAAAAAAAAAAAAA8eqVV17RTTfdpMLCQqP4zMxMLVy4UD16RPhLBwAAAIAI/elPf9KECRNUubLZHzAvKyvTY489pjvuuENFRUU2tw4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADR9umnn6ply5a67rrrNGvWLBUUFIRdVk5Ojt566y1ddNFFuuWWW3TgwAELW3q+NWvWaNmyZX7PffXVVzpy5IhtdbvpNdu6dasGDRqkPn366LXXXlNWVpZKSkosrePHSkpK9Oyzz6pFixb6y1/+ot27d4dVzt69e/WXv/xFTZs21d/+9jcVFxdb3FK4qS8jMocPH9aoUaN0/fXXa8GCBSFfv2LFCt1www3q3r27srKybGhhdEyYMEEffPCB33OtWrXSa6+9FlJ5jHfnY0yJ3Jo1a9S7d2/deuutWrduXUjX5ufn65NPPlHPnj113XXX6fDhw7a0cdeuXbriiivUs2dPffTRR8rLywu5jKysLN1///1q0aKF3nnnHRtaaQ2n92k3jEElJSUaO3asWrRooWeffTaka7Ozs/XEE08oMzNTX375pWVtipVY5OVSfN2zFVm5cqU6d+6se++9V9u2bQvp2miNr264pyVp+vTp6tixo376059q/vz5Ki0tDbmM77//Xvfff7/atWunWbNmWdo+K/q82/u727il74eLtRh+7Pjx4xo1apQGDRqkhQsXhnTtiRMn9Nxzz6l169Y2tc5+scqJvMwNeQ4qRs7ubT9eFx86dCik62O1NqZfmiHXc4ZI91S9Ng+65f516/hoVT4/ffp0m1pYntP3ciTWCfHO63tDAAD7Jce6AQAA91syUeo6QkqvFTy2am3pwhukBe+GV8+VvzeLveqP0owXpe9nhl7PuW74m5RS6fxj7QZIzbpJs/9XWvd16GUu+lDK7G0WW72edMs/pJkvS+tnh15X9QbS6MekRu0Dx7S+SGp1obThW2nmS1Lh6eDlrpkhXfRT3/sZTHKq732rnykt+kAqLjRvv+Rr+xWPSLUamV+z/DOppCi0epxk5WRp5G/MYiulS9f9l/TtW9KKz6XSEPeEOg6Rhj4gVa4aejud7NQRac6/pGG/DO26mhnStU9Ih7ZLK76QNi+SCnIja0tqFal5N999326APa/16RypSs3gcUMfkN5/WDp9Irx6+t0i9b81vGsBN8o9Ki2ZFFq/r91Uuv4p6cAmafNCacdy6US2VHDO86aUSlLVelLLHlLbi6WmXaSEBOvbH+9ikTu26efLW6zOH02smS51GR7+9bnHpO3LrWuPFH/vgVuVFEk7V0pt+prF97nON6Z9N8G8jsRk6ZKfSX2uD6+N4Yh2/3Nj3/P6uoO+zdj6Ywc2+vpuYlLw2M6XSYX50pxx9uwvRGtfJR73VCyVIKVVk+o0k+o2lzJ7SS16+t6TUJSVSYs/sqeJpgpyvbl34IV9VrttXiitnyN1HGwW3+lSadtSaeO31rZj0wJfPhCO7csklYV+XeFpae86qVmX8OrdHNpnGyvE/O09Xh1Xvb5GMM3BvP5cq90AqWpdaer/SMf3hXZtem3fc5fWF5lfU3haWmvR56adlNPbieewiFQk93m1etLwh6SWvcyvsfI+l3z56+CfS6mVA8ckJAYvx225jhefSXk1Z4I1WCdZr+dV0pB7Kx4jExKlK34n1WkqLfxAKo3wZ4bSakgjf2sWe3RvZHU5GXtU1nHz8714mvfiZW1mgs9p+Fh5LzGfRU88jVte4fX9WzskV5I6DDKLXTdbYT2PitSJg9Ke782eZyUlS52HSss+tb9dTuH2eS2ekTNGn5c+KxftnNAN+aCXcjcv5/yxHvu8/NoCAAAAAAAAAAAAAAAAAAAAAAAAQDybOHGijhw5oi+++ELVqlULGt+gQQPNnTtXV199tWbPDuMXHQEAAAARSE1N1ZtvvqkxY8YYX3PmzBndeuut+vTTOPoFSwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHGotLRUn376qT799FOlpaVp4MCB6tq1q9q3b6/MzExVr15dVatWVXp6usrKypSbm6tTp07p5MmT2rZtm9asWaPvv/9eCxcuVFFRUdTafezYMb/Hx48fb3vdbnvNli1bpmXLlkmS0tPTlZGRoVq1aqlWrVpKSUnxe01+fn5EdR45ckRPPvmknnzySfXs2VP9+/dXjx491LJlS9WvX1/p6elKTk5WYWGhTp06pZycHG3atElr167VnDlztHr16ojq/7GEhARLy/uxK6+80tbyJenVV1/Vq6++ammZbuvLpux+vyV3vueffPKJPvnkE7Vr1079+/dX37591bp1a9WsWfOH8eDkyZPKycnRxo0btXLlSk2dOlVbt24NWObKlSsteb2j8Z5J0pgxY0L6244mnDLeRes1rIgTxpTTp0+f91rMmTNHgwYNsug7tF9paanef/99vf/+++rUqZNGjhypbt26qW3btqpRo4aqVq2q/Px8nThxQtnZ2VqzZo2WLl2q6dOnKzc3N2rtXLlypW666SZVrlxZQ4cOVZ8+fdS1a1c1btz4h3YWFhbqxIkTOnbsmNatW6esrCzNmjVLO3bssKVNdtwDTujTwThlDKpIdna2HnnkEU2ZMkUDBgxQt27d1KJFix/6yunTp3XixAnt2bNHWVlZ+vbbbzV37lyVlpb6LW/RokWOGPPCEYu8XHLmPWsV075QXFyscePGady4cerevbuGDRumbt26qVWrVo4aX91wT5eUlOjjjz/Wxx9/rPr162vQoEG66KKL1Lp1azVr1kzVqlVTWlqaSktLdeLEiR9yy1WrVmn27Nlav3697W10Up9nbWLGDX0/Ek5ei1mNPm/m22+/Vf/+/dWkSRMNGzZMgwcPVsOGDVW/fn3Vrl1bxcXFP8xJq1ev1sKFCzVt2jQVFBSUK2vs2LEaO3ZsxG2KZn+yMydy4n0RLjfmOVa9/l4tpyJOyl/Oitb9dM899+iee+6JSl2xcnZd/Oijj2rAgAGuWRs7rV869Z52cq7npXmxIk7ZU3XS6+20+zcQt46PVubzknU5fSBu2MuRYrd3GionzUfRHHfsztm8vjcEALBPcqwbAABwv6J8acG70rCHzOJ7/0TKmiadOhxaPRu+lS76qVSvRfDYxCRpxK+l5j2k+W9LJw6GVletxlL/W6XUyv7Pp1WTrvit1HGQNOMl6eQh87L3b5C2LJLa9DOLT02TRj3ie90WfyRtX+Z7zStSrZ7U7Qqp19VSSoDv4VwJCVLdZlLhabM2FRdIs16RrnncLD4hQbroRqnzUGnhB9Km+VL+qYoukBq1l/pcJ7W92KyOs47skpZ9Fto1TrPuG9/7bdLXJV9/H3y31G2ktOhDX/+q6L1MTJJa9pYuvF5q0smSJjtS1lSpRQ+pXf/Qr62f6RtDhj0k7V3nu28PbvGNJaeOSIVnfPeB5Hs9U9J892pqmlSjgVS7iVSnmVS3hdSwrS/GTvs2SG36Bo+r2VC66Vlp8tPS4RD2seu1lAbeJWX2Cr+NgFst/UTqONh3X4eiYTvf18A7ff9fXCgV5EkplaTUKta3E+XFInfsMChwTCT5o4n9G315UN3m4V2/7mupzP+zw7DF23vgZt/PNMslzhrwM1+eNfdf0oFNgeOSUqT2l0h9bwp9HI1UuP1vyt9Cq8fNfS8e1h30bcbWcxXlS9lbfTmaiR5X+vYk1n0t7fleOn5AKsyTSooDX1NaYra3Eum+StbUioLje0+leVfpgQ8jKyMh0bcnaLKnZmL9bCl7mzVlRcKLewde2GeNhln/lJp1karWMYu//P9J+9b59sCssmOFVFTgWxOHauvi8Ovdttj3vYfq+H7pyM7w6/0x5m9v8uK46vU1Qig5mNefazXuIN3xmrT2a2nlv31tqEitxlLX4VL30aGP5Qs/tG5edFJObyeew8IKod7ntZtIXUdK3UdJyamh1WXlfS5JRWekTfOkCy4Pv4zTOdL25ZY1KWq8+EzKizkTrME6yXq7siQZ/HxUQoJvb7vdAN+4s37Ofz7/YiohUWo/QBp0j1Strtk1e9aEVoebsEdlnWiNDXaNC/Ey78XL2swEn9Ow/l5iPouueBm3vMLr+7d2aH+JVCndLHbtLHvbEqxu0+dZXUdIyz61tz1O4vZ5LZ6RM8aGVz4rF62c0G35oFdyNy/n/LEe+7z82gIAAAAAAAAAAAAAAAAAAAAAAABAvJs9e7YGDRqkqVOnqkGDBkHjq1WrpmnTpunWW2/VxIkTo9BCAAAAQKpTp46++OIL9e9v/geEDx48qNGjR2vZsmU2tgwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABOc+bMGU2fPl3Tp0+PdVMqlJGRoaFDh5Y7np2dralTp0a1LW55zc7Ky8vTtm3bolrnihUrtGLFiqjWidC5rS8jfJs2bdKmTZv05ptvxropnsN49x9OGVOSkpJ++HdpaWkMWxK6devWad26dbFuRoXy8/M1ZcoUTZkyJdZNsZ1T+nRFnD4GzZs3T/PmzYt1MxwjFnl5PN2zFVm1apVWrVoV62YE5fR7WpIOHTqkiRMnauLEibFuil/0eXdyQ98PF2sx/NjevXv15ptvxnWfiEVO5GVuyXMQGPmLt5WVlblybUy/NEOu5wxu2FONJrfcv24dH92Yzzt9L+cs1gnxzct7QwAA6yXHugEAAG9YM0PqebVUt3nw2JRK0sA7pSnPhFhJmTTjRemW56SERLNLOg6S2vWXti+TdiyX9q6T8o5LZ076ypOkxGQprbpUu7GU0U5q1Vtq2kVKSAhefsteUufLpEUfhPatzHpVanqBVLma+TUNWklX/VEqKZb2b5CO7ZVOn5DOnPC1NTVdqlbXF1e/lVn7z/Xt+NDityySNs2X2g0wv6ZqHWnYL6XLfyHt3yQd2SXlHZPyT0nJqVJ6LalaPd9rk1Y9tPZIUlmpNO15qbQ49GudpKxU+uZ16ad/C+26Wo2kK34rlZZI+zZIx/b4+nv+KV8/r1JdqtNcatxRqlzVnrY7zVfPSjUaSBltwrs+MUlq1sX39WNlZb73KjGp/Llo27JIatPXLLZOM+m2l6XNC6X1s6UDG31jybkSk3yvW7NuUqsLpVZ9Ao8pZaXmYzLgRsUF0r//Wxrzgi+HCVdyqu8LUeTA3FEKP3808f0MafDPw7t2zQxr2yIpLt8Dt9q2RDq2z/eammp6gXTri9Kpw9LuNVLu0f/LKRJ8eWfdFlLTzlJqFbtaHUSY/S+lUvz0vXhYd9C3fRhb/2PVFKlhO/P4qrWlC2/wfZnYukT67Amz2Ej2VTpfxp5KIEkpvvfNKU4elr5+Ndat8PHq3oEX9lntVpDru7+vf8osvnJV6YrfSR89al0biguknSukNv1Cu66kWNqxMvx6ty0Nb420ZWH4dfrF/O1JXhxX42GNEGoO5uXnWsmpUreRvq9j+3z9Muegb95ITJKq1PR9f407SjUbhlfHsb3Sii+sbLWzcno78RwWVgh6n9eSqtaSGnWUamaEV4cd97kkZU2VLrg8/Os3fOvrs27jxWdSXsyZYBHWSZY7stOXP7S/xCy+dhNp+MPS0Aekfet9XzkHpBPZUlG+76us1LffllJJSqsp1WooZbSVmneX0muG1r6N80OLdxv2qCxi89jQcYi940I8zXvxsjYzwec0zOowvZeYz6IrnsYtL4iH/VurdR1hFndgky8Xi5VN86WhD0qplYPH1m4iNeks7V1rf7scweXzWrwjZ4w+r3xWzqqc8Mgub+WDXsndvJ7zx3Ls8/prCwAAAAAAAAAAAAAAAAAAAAAAAADxbuXKlbr44os1c+ZMZWZmBo1PTU3VhAkTVL9+fb3yyitRaCEAAADiWfv27TVlyhS1atXK+JrVq1fryiuv1N69MfwlUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAFbr31ViUlJZU7/v7776ukpCQGLQIAAE5Us2bNH/598uTJ2DUEAAAAAAAAAAAAAAAAlkmOdQMAAN5QVirNeUO6/imz+A6DpBX/lg5sDK2e/RukpZ9IF95gfk1SstSmr+/rrLJSqaRYSkzyfYXr4BZp8UehX5d7RJr+onTVH6WEhNCuTUqWml7g+7LK9zOlHctDv276i1LdFlKdpqFdl5AoNe7g+7LS3PGh9ymn2r1aWjNd6jI89GsTk6SmnX1f4dqzVqrTRKpSM/wynKC4QPr0cenGv0l1m1tbdkKClBDB+GGlTfOlIT+XKlczi09KljoM9H1JUlG+VJDnGxcrV5UqpZvXvfJLqedVobcZcJPDO6TpL0ijfuebw/4/e/cdZldZr4/7mZICSUglhCa9qTQBEUIROAgBQlEUkaNE5YeAeCgWiqhfUFGkCKIU6SIEJJjQE0IPCaFKCx0SAkIgvZdJZn5/zMEjkszsmcyePbPnvq9rX5C1Pu/7PrP3Ku9aa2fSWl64N9nyS603Xjlqa3PHpPnzx0K8eH+y23fqf4amePfFZOY/i5Opo30G7VVdbfLoX5IDT2t62x6rJ5/Zq3njLl2SvPNCssF2zWvfmOZsfx1t2yv36w7b9v9xbK338kPJ7t9JuvUudZJ6zb2v4p5K+7B4fv09icXzS52kXrneOyiX+6zFNvGp5LmRydYFnvM/tXWy/SHJU8NbLsNrY5NNdm5am3deSGoWNn/MGe8mM99Leq/VtHavjW3+mCvi/F1+yvW4Wu7XCEnz5mDl/lyrz9r1r5a0bGlyzwVJ7dKW7betzemLyXNYCjHpmWTtTyedujZc15728yR575Vk2tvNf7774n0tm6c1ldszqXKdM9EyXCe1vPsvSz61VdPm09Wdk/W2qX8Vy1tPJTPfLV7/bYF7VC2nrR0bmnJc6EjnvY50bdYY39MoTFP2Jeez1tORjlvloiPcv20pfT9Vf8+kEC+MLm6WxtQsSl4bk3x278Lqtx5Ufx7pKNr7ea0jM2dsfeX0Xbm2OCcs9XywnOZubfHzTVrmMy71sa+c31sAAAAAAAAAAAAAAAAAkjfffDM777xzRo4cmW222abR+srKylx88cUZMGBAzjjjjOIHBACgQ9p7771zyy23pGfPngW3ueOOO3L44Ydn/vw28o/6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAcnzve99b7vIrrriilZMAAG1V9+7ds9lmm/3rz1OmTClhGgAAAAAAAAAAWkplqQMAUD4mPpVM+kdhtRUVyZ7L/7sMjXr4muSNx5vX9l/jVybVnZPKqub3MW96ctuvktplzWv/2qPJI9c0f/yWMnViMvqPzWu7eF4y7Ixk/qwWjdQsz96VPDms1Cla1ug/JVNeb/1xlyxI7j4vqa1t/bGLYf7M5MYfJu+9UuokTbNwTuH7Zs2i5ImV2P47dU269016rpF06VZ4uzceS156sPnjQnvy8oPJ3Rckda10bHxuZPL0iNYZq9y1lbljsvLzx8YsnJ282Yyf9flRLZ/l33Wkz6A9e+Xh5K0nW3fMcTcm0ycXd4yV3f46wrZX7tcdtu0V6wjb939aVpM8en2pU/yftnJfpRzvqZTawrnJLWfU33drK8r53kE53GdtDQ9cnsz+oPD63b6drL5By43/xuNNP1e8MX7lx33ziabVz5tRvPuIzt/lpZyPq+V+jdDR5mAL59TPg1vbg1ck/3yp5ftta3P6Ymor22rimqEtm/V+8vDVpRm7WPv5R567p3ntpr+TfFCC81hLKqdnUuU8Z6JluE5qWfNnJHf+rvWOH4VYVpM81EF+r7F7VC2nrRwbmnpc6EjnvY50bdYY39NoXFP3Jeez1tORjlvlpNzv37aUrQcVVresJnnloaJGKcgLowuv3WzXpEv34mVpi9rzea0jM2csjXL5rlxbmxO2hflgOc3d2trnm7TcZ1zqY185v7cAAAAAAAAAAAAAAAAA1Pvggw+y22675cEHC/8LgD/96U9z5ZVXprLSP10MAEDL+t73vpe77747PXv2LLjN73//+xx88MGZP39+EZMBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDKGTRoUDbaaKNPLB8zZkxeffXVEiQCANqi888/P507d/7Xn5966qkSpgEAAAAAAAAAoKVUljoAAOXlwT8ndbWF1a69RbL5bs0YpC654+zk7Web0baFLJid3HxaMvuDlevn8b8lY29omUzNMe3t5G+nJ0uXNL+P2R8kfzstmTut5XI11XMjk9F/Kt34xbKsJhl+ZjLzvVYcc2ky4tfJ7CmtN2ZrWDQvuemU5PmRpU5SmDceT67+XvL6uMLbPHFr8uFbxcv0nz58K7njd0nqWm9MKLUJ9yW3/TpZPL+44zx3TzLqoqTO/tUy2sDcMWm5+WNjmnquW7IgefWR4mT5lw72GbRnd5/Xeu/P6+OS8Te3wkBtYPtr69teR7jusG0XT1vfvpfnubuTV4p97muCUt9XKdd7KqU0dVJyw0nJey+XOsknlfO9g3K4z1psNQuTu88v/FqzunNywClJVaeWGX/xvGTy801r89YTKz/um+ObVt+U+3FN5vxddsr1uNoRrhE+moOVSmvOwWZPSUb/sXXG+sjTtyXP3Fa8/tvanL6YSn29kLhmaA+euT154d7WHbPY+3mSTLi/efPrCfe1fJZSKKdnUuU6Z6KFuE5qcZOeSe69uPDv7xXbg1fW3zfpKNyjaiFt4NjQ3ONCRzrvdaRrs8b4nsaKNXdfcj5rPR3puFUuOsL925VV1Sn5zF6F1b75RP13zEvtnecLP1ZWd04+s2dx87Q57fy81pGZM5ZGuXxXri3NCdvKfLCc5m5t6fNNWvYzLvWxr5zfWwAAAAAAAAAAAAAAAADqzZ07N/vuu2+GDRtWcJvvfve7GT58eLp27VrEZAAAdBSVlZW54IILctlll6W6urqgNkuXLs0xxxyTk08+ObW1beQXIwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAqceeaZy11+0UUXtXISAKAtqq6uzmWXXZajjz76Y8uvu+66EiUCAAAAAAAAAKAlVZY6AADlZerE5MX7Cq/f/btJVaemj1OzOBn2s+SVR5redmV9+FZy/f8k0ye3TH9jr09GXpgsXdIy/RVqymvJ0J8k82eufF9TJybXn5B88ObK99UUdXXJQ1cloy5M6mpbd+zWMndacuMPk2lvF3+sZTXJXecmk54u/lilsHRx/b52+9nJwjmlTrN8095O/vbT5O+/aPq+Wbs0GfHLZP6sokT7mA/eTG75aVKzsPhjQVvz2tjk2u8n77/a8n0vq0nuuyQZdVGSupbvvyMr5dwxafn5Y0MmPp3MnVp4/cuP1L8/xdaRPoP2bMHs+s+pJa4RGvLOC8md56TVjnXldP1YLOV+3WHbLo72sn0vz8gLW/8eRkNKcV+lI9xTaW3LapLHb0n+8oNkxrulTrN85X7voBzusxbbO88nz9xWeP3q6ye7fbvlxn/t0cJrp09OZr2/8mO+82KyZEHh9U3J2BzO3+WlnI+r5X6NkNTPwTrKc63nR9WP2xrG35zcf2nxx2lrc/pi8hyWQoy8sP75RWtorf180dzk9XFNa1NXl0x4oDh5SqFcnkmV85yJluE6qeU9d09y+2/q9/VSGndj0+5DlAv3qFpGe32+19HOex3p2qwhvqexfCt7jnU+ax0d7bhVLjrC/duVscnOySqrFVb7wujiZmmKF5uQZetBxcvRVrX381pHZs7Y+srpu3JtYU7YluaD5TZ3awufb1Kcz7jUx75yfm8BAAAAAAAAAAAAAAAAqLdkyZIcdthhueSSSwpuc+CBB2b06NHp1atX8YIBAFD2unXrlhEjRuSkk04quM3s2bOz33775fLLLy9iMgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaBlHHHFEdthhh08snzRpUoYPH16CRABAW7LGGmvkgQceyPe+972PLb/lllty3333lSgVAAAAAAAAAAAtqbLUAQAoP49cm9QsKqy25xrJ9oc0b5xlNcntZyej/5jULG5eH01RV5v8447krycmsz9o2b6fH5lcf0IydVLL9rs8dXXJE7cmfz05WTi75fqdN73+vRl/c1K7rOX6XZHp7yRDf5Q8cUvxxyq1+TOTG05OXnqweGMsnJP87fTklYeLN0Zb8cojyeVD6redpUtKnabe+68mt/06uebYZNLTze9n1vvJTT9JZr7Xctn+02tjkxtPrt8uoaOaPSW5/sTkzt8ls6a0TJ9vPpFc+/3kmdv/b1lFRcv0Tb3WnjsmxZ0/NjTmi034Oz8vjCxelv/UUT6D9m765OTGH9bPt4vh1TH1887W2gY+Uk7Xj8VS7tcdtu2W0x637/+0ZEEy9MfJ6+NKneT/tOZ9lY50T6U1LF2SPHdPcuX/lzx8Vf1+2ZaV+72DcrjPWmwPX53MeLfw+u0PST61TcuM/fq4+vetEG883jJj1i5NJv2jsNpFc5PJz7fMuA1x/i4v5XxcLfdrhKRjPdd64pbk7vOLd9xZPL/+fukj1xSn///UFuf0xeQ5LI2pq01G/Kp+flosrb2fJ8lzTbx//c4LydypxclSKuXyTKqc50y0DNdJLe/VMclf/ieZ8lrrj71kUXLPBcmjf2n9sdsK96haRnt9vteRznsd7dpsRXxP4+Na8hzrfNY6OtJxq5x0hPu3zbX1voXVLZidTHyyuFma4sXRhT9HW32DZM3NipunLWrv57WOypyxNMrpu3KlmhO21flguc3dynXO3xaOfeX63gIAAAAAAAAAAAAAAADwf2pra/P9738/P//5zwtus8suu2TMmDFZa621ipgMAIBytfbaa+fRRx/N4MGDC24zceLE7Lzzzhk9enQRkwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQMvYcMMN84c//GG56375y1+mtra2lRMBAG3J2muvnX/84x/ZddddP7Z89OjROfLII0uUCgAAAAAAAACAllZd6gAAlJ/5M5Inbk0GHlFY/U5fT164N1kwq3nj/ePO5I3Hky8elWy+W1JR0bx+GjL5ueSBy5MP32r5vj8ydWJy7XHJNvslA/87WbVXy4/x/qvJQ1cm77zQ8n0nybKa5JFrkpcfSnb7drLhDi3/eSyYlTw1vH4bq13asn23ZYvnJ3eek7zxWLL7d5Oea7Rc3688ktx3SfP3wfZoyYLkoauSp0Yk2+yfbD0o6da7dTMsnJO8OiZ5cXTy3ist1+/0yfXHkr2OTbbap+X6nTcjuf/S+sxAkrrkpQfqj6EbfT759J71/63uXHgXC2Ylr41Lnrsn+eD1T64vtK+lSwofk9aZOyatM39ckedHJV/4euM/2/R3WvYcVKiO8Bm0dzPfS/7yg2SPo+vnSS3xGS1ZlDx4ef0xr5TK5fqxWMr9usO2vfLa8/b9n5YsSIaflWw6MNnlW0m/9UqdqPj3VTrqPZViWFaTvDuh/tj26phk0dxSJ2qacr93UA73WYtp6ZLkrvOSI85PKqsar6+oSPb/UXL1McnieSs39vyZ9dcga2/ReO2b41durH/3xvj6432jdY8nda34+5acv8tHOR9Xy/0aoaM913pxdP05bJ8TknU+03L9vv5Y/Wc5d2rL9VmItjinL6aOtr3SDHXJQ1ckE59M9jkx6TWg5bou1X4++dlk1vtJrzULq59wX1HjlE6ZPJMq5zkTLcd1UsuaOjG5/sT678Xs+NVktf7FHa+uLnltbPLgFcmcD4o7VnvgHlXLaY/P9zrSea+jXZutiO9p1CvGOdb5rHV0pONWOSn3+7fN0XNA8qltCqt9+cGkdllR4zTJ7A/q53Wf2qqw+q0H1c8HO6L2fF7rqMwZS6OcvivXmnPC9jAfLLe5W7nO+dvCsa9c31sAAAAAAAAAAAAAAAAAPu6Xv/xlpkyZkksvvTRVVY3/0unPfvazGTduXPbdd9+88koJfhkKAADt0uc+97nccccdWWuttQpu89hjj+Wggw7K1Kmt/MutAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgGbbbbrsMGzYsffr0+cS6V199Ndddd10JUgEAbck///nPPPbYY/nyl7/8r2XXXHNNvve976WmpqaEyQAAAAAAAAAAaEnVpQ4AQHl64pZk60FJ90/+vYVP6LxqsuuRyaiLmj/e3KnJHb9JHv1Lst1Byea7Jav2an5/H3nh3uTpEcmHb618X4Woq03+cWfy/Khkiy/Wv4drbZFUVDS/z9plyeTnkmfuSN54rMWiNmjqxOTWnyf91ku2PyTZZGCySo/m91dXl0x5LXl+ZPLifcmyDvxd1lceSV4bm3z2v5LtDklWX795/dTVJW8+njz+t+SfL7VoxHZl3vT648a4G5MNtk82/kKy0ecLO3Y1VV1d/b7x9rPJpGeSt/9Rv38WQ82iZOTv649h2x2UbDowqaxqXl+z3k+euDV58d5k6ZKWzQnloHZp8vq4+ldVp2T1DZI1Nk76rJN07Z506ZZUd0mWLq7fN+dOS2a8m3z4ZuPziy7dCsuwdPHK/xwdTbHmjksWJK8+2rrzx+WZPSV55/nkU1s3XPf8yNbJszzl/hmUg5pFyb1/SJ67O/nC15NNd04qKpvRz+L6Ph7/WzJ/ZsvnbI5ibH/ltu2V83WHbbvpym37/k+vja1/rbVF/Xu23jZJ3081/xqqJbTkfRX3VJpn2dJk2ZL6fX3BrGT+rGTWe8m0yfVz+fdfbf/vZbnfOyiX+6zF8v4ryRPDki8cVlh9j37JPv+T3H72yo/92thk7S0arlk4N/nnyys/1kfeerL+eNjY5//aoy03ZqGcv8tHuR9Xy/kaIelYz7WmT05u/GGyyc7J9l9O1v1s8/pZuqT+sxx/U/LBmy2bsana4py+mDrS9krzvP1sctX/V3/M3uHQpM/azeunreznz49Mdvt243U1i+vnP+WsHJ5JlfuciZbhOqll1dUm/7gjefau+u/EbL1fsu6WSacuLTfG/FnJKw8lz95dP9/k/7hH1XLa4/O9jnbe62jXZv/J9zSKe451PmsdHe24VU7K/f5tU2w9qPC51ouji5ulOV4cnXxqq8JqN/9icv/lSc3CokZqs9rzea0j6+hzxlIop+/KFXtO2N7mg+U2dyvnOX+pj33l/N4CAAAAAAAAAAAAAAAA8H+uuOKKTJ06NUOHDk3Xrl0brV9vvfUyduzY7L///hk/fnwrJAQAoD075JBDcv3116dbtwJ/kXGSv/71rznqqKOyeLF/aBMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgLalsrIyFRUV6datW/r375/Pfe5z+epXv5qDDz441dXVy21z3HHHZdmyZa2cFABoi4YMGZItt9wyn/rUp3LyySfnkksuKXUkAAAAAAAAAABaWEVdXV1dQYUVFcXOAgAtpqIyWXuLZJ0tk7U2T/qtl/RYPala/t+lSJLULktmf5DMeDf58K1k4lPJuy+2XuYV6dY7WX+7+p9jwCZJzwHJqj1XXL9saTLt7eTDN5P3XkleH5ssmN16eZenojJZ57PJhtsn/dZPVt8gWW31FdfXLEqmT06mvp2893Lyxvhk/oxWi9uu9Fk32XRgstZmSf+NktX6L7+udlky673693TS08kbj3tPG9Jn3fr9bcAm/3v86Fd/DOm8SuNtly5J5s1I5k1PZr2fTH0r+XBi/T65cE7xsy9Pj37JBtsna386WWuLpPdaSWXV8mvnz0qmTUz++XLy+rjkgzdaNSrwbzbfLTnw9MbrZn+QXH5k8fOUs5aaO773cv1yms5n0PZ1651sMjBZb+tkwKb18/mKyk/W1S5LZr5XP/d5Y3z9vLNmYevnbYp/3/622se2tzzlfN3RUbZtx9amqeqU9Fkn6d63fhup7pJUd0oae0wya0r9dVRL+8/7Kht9fsW17qnQXB3h3kE53Gel/Dl/l49yP66W8zVC0j6ea224Q3LoLxuvm/Ja8pf/WfH6PuvUzy/X27b+Z+3Rb/nz3mU19T/fh28mk5+r/xmXLGh2/KJra3P6YmoP2yultcbGycY71Z+T+q2XdO+z/Lq2up/vcGiyx1GN1738UHLHb4sep2yV6plUuc+ZaBmuk1peVadk7c/U3xfvs279vtd7raRT18bbLp6fzHy//r2d8mry7oT6OWex7PDlZI+jP7l83I3Jo38p3rjF5B5Vy2jOsWHme6U9LnTE815HujZrj9r7Odb5rPg64nGrXJT7/VtYnvZ+XuvIzBlbV7l9V665c8LWng+2hnKcu7WnOX9TlfrYV87vLQAAAAAAADRVgb+Wfbn8rnZgRbbaaqtstdVWSeqPM2+99VbGjx+/UsccgEIN2m9Q9txzz1LHoAOZOHFiLvnTJaWOAVA03/nOd7LFp7codQw6iHHjxmX434eXOgZA0Zz+09PTu3fvUsegg/j7rX/PY489VuoYJTNw4MDccccdBe9zCxYsyNe+9rXcddddRU4GtIRevXrlp2f8tNQx6GDOP+/8TJkypdQxgBI69dRTc/bZZxf8nam6urr8/Oc/z69+9asiJ1t5hf6+f2gpv9u31AkAyltFRUW23377bLrppv+auzz//PN5/vnnS5wMAID25qxfnpVVVlnFPXKAVvbR98z+9Mc/ZdKkSaWOA9BhHPf947LBBhvkqquuyisvv1LqOAAdwkd/d7Gjf/cdoLUd8uVDsvPOO+fuu+7Ogw8+WOo4AB3GR78X64EHHsg9d99T6jgAACyH39UOFIPf1Q60NXvssUf223+/UsegA3JvFOhInG8pBedaoCPxb5NRCr5zCXQkzrWUir9jBnQkex+fbHtAqVPQ0dx7cfKsf5YL6GD8rva2xXdqoX342te+lptvvrlJbS677LIce+yxRUoEALRHn/70p1NdXd2mrr9WdO3h7wcDAAAAAHySe6oAUD4qKiqyww47ZJNNNvF9WqBghXzHu7oVcgBAq6urTd6dUP/6l4pk1dWSTl3rXxWV9XVLFv7va0FSu6xkkVdo/sxkwn31r49Ud0m6dk86dan//7raZPGCZPH8+p8lbezvedXVJu88X//6SGV10qVb0mXV+s+jdll9/sULkpqFpcva3sx4Jxl/0//9uarT/76v3ZPqTknNovpte9H8pHZp6XK2NzPeqX+99MDHl3daJencNanuXL/vVVbVb7tLl/zva3H9dtzWzJ2WPD+y/vWRTl3rjyNduv/fMWTJ/76AtqHngMLq5k4tbo6OoJzmju2Vz6Dtmz8zefbO+ldSP5/v1rv+mqSqU7K0JlkyP1k0L1lWU9qsTfXv29/4m2LbW45yvu7oKNv2v9i+C7KsJpk6sf7VFvznfRX3VCiGjnDvoBzus1L+nL/LR7kfV8v5GiHpWM+1Zrxb/3ry7/V/ru6SdO1R/yykqtO/nRcX1L8v7UVbm9MXU0faXmmeD96of32kU9f67aPzKu1jP/9Mgf/WzoT7i5uj3JXqmVS5z5loGa6TWt6ymmTys/Wvf9epy/++p6v87/taUf8+1i5NlixKFs1t/fvklSv4lnt7/h3o7lG1jOYcGxbNLVncJB3zvNeRrs3ao/Z+jnU+K76OeNwqF+V+/xaWp72f1zoyc8bWVW7flWtoTrhq77YzH2wN5Th3a09z/qYq9bGvnN9bAAAAAAAAAAAAAAAAgI5u7Nix2XXXXTNq1KisvfbajdavuuqqGTFiRI466qhcd911rZAQAID2olOnTvnzn/+cIUOGFNxm0aJFGTJkSG6++ebiBQMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgFb0yCOP5IQTTih1DACgjXnppZdKHQEAAAAAAAAAgCKqLnUAAGg1dcmC2UlmlzrIylu6OJm3uNQpVk7t0mTh7PoXLWdZTbJgVv2LllezsP5VDmoW1b/mTit1EmBF1tyssLo59uPiKKO5Y7vlM2jTapcmc6eWOkWR2PYaVc7XHWW9bSe27zLhngqtpSPcOyiH+6x0AM7fZaOcj6vlfI3wkY4yB3NuLA8dZXuleT46H7UH/TesfzVm3oxk4tPFz1PO2tIzqXKeM9GCXCcVRc3i+ldbel+7dFv+8qVlNmc1D28h7fDY4LxHm9MO96P/5HxWXI5b7VNHuH8Ly1UG5zUotnL9rlzN4mT2lFKnKL1ynbu1xTl/ufDeAgAAAAAAAAAAAAAAAJSHCRMmZOedd86oUaOy+eabN1pfXV2da665JmussUZ+97vftUJCAADaut69e2f48OHZfffdC27z4Ycf5qCDDsr48eOLmAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFrPyJEjc+ihh2bJkiWljgIAAAAAAAAAAABAK6osdQAAAADgk9bctLC6qW8VNwcAAAAAAEBr22pQYXUT7kvqaoubpdx5JgW0VT0HLH/5gtmtmwMAVobzGQAAAAAAAAAAAAAAAAAAAACtafLkyRk4cGAef/zxguorKipyzjnn5Pe//32RkwEA0NZtvPHGefzxx7P77rsX3GbChAnZcccdM378+CImAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA1vHBBx/kuOOOy6BBgzJ//vxSxwEAAAAAAAAAAACglVWXOgAAAADwcet8JumxemG1H7xR3CwAAAAAAACtqWv35DN7Flb7wr3FzVLuPJMC2qqKyuRTWy1/3az3WzcLADSX8xkAAAAAAAAAAAAAAAAAAAAApTBjxozsueeeGTZsWAYNGlRQmxNPPDH9+/fPkCFDUlNTU+SEAAC0NbvttluGDx+ePn36FNzm3nvvzVe/+tXMmTOniMkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKA4Fi9enBkzZmTSpEl56qmncu+992bUqFH+fVcAAAAAAAAAAACADqy61AEAAACgveneL6nulMx6vzj9b7N/YXXLapJ/vlScDAAAAAAAAKXw+a8mXbo1Xjf5uWTGu8XPU0qeSQEd1ecGJ916f3J57bLkgzdaPw8ANIfzGQAAAAAAAAAAAAAAAAAAAAClsmDBghx44IG5+uqr881vfrOgNt/4xjfSr1+/fPnLX878+fOLnBAAgLbiyCOPzJ///Od07ty54DaXXXZZjj/++CxbtqyIyQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoOX87W9/y7Bhw5IkdXV1qaurK3EiAICWUVVVVeoIAAAAAADthnuqAABAYypLHQAAAADakw13SL59SXLg6UllEZ7FDdg02Xz3wmrfeTGpWdTyGQAAAAAAAEqh/0bJDl8urPbJvxc3S6l5JgV0VBvvlHzx/1v+urefTZYsaNU4ANAszmcAAAAAAAAAAAAAAAAAAAAAlNrSpUvzrW99K+eff37Bbb70pS/lwQcfTL9+/YqYDACAtqCioiK/+c1vcu2116Zz584FtVm2bFl+8IMf5Nhjj82yZcuKnBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFpWbW1tamtrU1dXV+ooAAAt5qM5zn++AAAAAAD4JPdUAQCAxlSWOgAAAAC0BxWVye7fTb5yVrLKasmATZJ9T2rZMaq7JPv/OKmsKqz+pQdadnwAAAAAAIBSWa1/cvAZSVWnxmtnvpe8+UTxM5WCZ1JAh1WR7Pi15JCfJVXVyy8Zf3PrRgKAJnM+AwAAAAAAAAAAAAAAAAAAAKCN+dGPfpQf/vCHqaurK6h+hx12yNixY7PeeusVORkAAKWy6qqr5tZbb82pp55acJu5c+fmgAMOyB//+MciJgMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAojepSBwAAAIC2rke/5MDTk7U//fHln/2vpKIiGXlhsqxm5cbo2iP5yllJ33ULq188P3nlkZUbEwAAAAAAoC3YfLdkz+8l3fsWVj/2r0nqihqpJDyTAjqqbr2TA36SrLftimtefyx55/nWywQATeV8BgAAAAAAAAAAAAAAAAAAAEBbdcEFF+TDDz/M1VdfnU6dOjVav+mmm+axxx7LPvvskxdeeKEVEgIA0FrWXHPN3HHHHdluu+0KbjN58uTsv//+efHFF4uYDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKB0qksdAAAAANqyjT6f7PfjZJUey1//mb2S/hsl912SvPN888bY+AvJHkcnvdcqvM2Tf0+WLm7eeAAAAAAAAK2p33pJRWVSUZFUdUo6r5L0XCPpv3GyyReSHqsX3te0t5OXHixe1lLxTAroqDbYPtn/R8mqvVZcM+Od5K5zWy0SADSZ8xkAAAAAAAAAAAAAAAAAAAAAbd1f//rXTJs2LcOGDUu3bt0arV9zzTXzyCOP5KCDDsojjzzSCgkBACi2rbfeOnfeeWfWWWedgts88cQTOfDAA/PBBx8UMRkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAaVWXOgAAAAC0RRWVye7fSXb4SlJR0XDt6usnh/8u+fCt5OWHkndeSKa9nSxZsOK++2+YrLdNsvnuyYBNmpZt/qzkyb83rQ0AAAAAAECpfOP8pGv3lunrwT8nqWuZvtoCz6SAjqyyKvmv45JVe6245sO3klt+uuJjHQCUmvMZAAAAAAAAAAAAAAAAAAAAAO3FyJEjs+eee+buu+9O3759G63v1atXRo0alcMPPzwjRowofkAAAIrmgAMOyNChQ9O9e+G/LHrYsGH55je/mUWLFhUxGQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDpVZc6AAAAALRFdbVJv/WTiorC2/TfsP71kUVzk0Xzk5pFSe2ypFPnZJWeSdfuSUVl87Pd+4ekZmHz2wMAAAAAALRHLz2YTHy61ClalmdSQEdWuyy547fJERckVcv5VvvEp5Lbzk6WLGj9bABQKOczAAAAAAAAAAAAAAAAAAAAANqTJ554IgMHDsyoUaOy3nrrNVrftWvXDBs2LMcee2yuuOKKVkgIAEBLO/HEE3Peeeelqqqq4Da/+c1vcvrppxcxFQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDbUVnqAAAAANBW3XN+snBO89t37ZH0GpCsvn6yxkZJn3WTVVZLKlbiavzZu5LXxzW/PQAAAAAAQHs0+4PkvktKnaI4PJMCOrIpryVjrv34srra5NHrk1t+lixZUJJYANAkzmcAAAAAAAAAAAAAAAAAAAAAtCevvvpqdt5557z44osF1VdVVeXPf/5zfvaznxU5GQAALamqqiqXXnppfv/736eqqqqgNkuWLMmQIUNy+umnFzkdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQNtRWeoAAAAA0FbNn5n8/f8lNYtKnaTexKeT0X8qdQoAAAAAAIDWtWRRMvzMZNHcUicpDs+kgI7uiWHJpGfq/3/utOTm05JxNySpK2ksAGgS5zMAAAAAAAAAAAAAAAAAAAAA2pP33nsvu+66ax599NGC25x11ln505/+lMpK/xwyAEBb16tXr9xzzz055phjCm4zbdq07LnnnrnuuuuKmAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACg7aksdQAAAABoy/75UjL8l0nNotLmeOPxZPiZSV1taXMAAAAAAAC0psXzk7+dlnz4VqmTFJdnUkBHd9e5yfOjkmuOSSY/V+o0ANA8zmcAAAAAAAAAAAAAAAAAAAAAtCezZs3K3nvvndtvv73gNscdd1xuvvnmdO7cuYjJAABYGRtuuGEee+yx7L333gW3eeWVV7Ljjjtm7NixRUwGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0DZVljoAAAAAtHWTnk7+elIy6/3WH7uuLnliWDL8zGTpktYfHwAAAAAAoFQ+eLP+Gc17L5c6SevwTAroyObPTEb+Plk0r9RJAKD5nM8AAAAAAAAAAAAAAAAAAAAAaG8WLVqUQw45JFdddVXBbQ499NCMHDkyPXr0KGIyAACaY+DAgXn88cez+eabF9zm/vvvz0477ZS33nqriMkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2q7KUgcAAACA9mDqxOS645Nn7khql7XOmNMnJzefljx0ZVJX2zpjAgAAAAAAlNrcacn9lybXn1D/vKQj8UwKAAAAAAAAAAAAAAAAAAAAAAAAgNZUW1ubo446KmeddVbBbfbYY488+uijGTBgQBGTAQDQFEcccUTuv//+9OvXr+A2V155Zfbdd9/MmjWreMEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2rjqUgcAAACA9mLx/OS+PyXP3pns+LVks12T6s4tP87UScnTw5MXRid1tS3fPwAAAAAAQFuydEny4VvJ+68kr49P3nm+Yz8j8UwKAAAAAAAAAAAAAAAAAAAAAAAAgNb2i1/8IlOmTMnFF1+cqqqqRuu32mqrPPbYY/nSl76U119/vRUSAgCwImeddVbOOOOMVFRUFFRfW1ubU045Jeedd16RkwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC0fdWlDgAAAADtzbS3k7vOTe6/NNlst2T9zyWf2ipZZbXm9VdXm0ybnLz1ZPL6uOS9l1s2LwAAAABQPj54M7n97MbrFs0rfhaAQt1zQVL1b99WXLqk/rVoXjJ3WrJgVv3zEj7OMykAAAAAAAAAAAAAAAAAAAAAAAAAWtOll16aDz/8MDfccEO6dOnSaP3666+fsWPHZr/99stTTz3VCgkBAPh3Xbp0ybXXXpuvf/3rBbeZP39+/vu//zsjRowoXjAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAdqS61AEAAACgvVo0L3nu7vpXkvQckPRas/7Vo1/SqWvSqUv9fz9SszhZuiRZODuZMzWZ/X7ywZtJzaLS/AwAAAAAQPsyf0byyiOlTgHQNK+PK3WC9s0zKQAAAAAAAAAAAAAAAAAAAAAAAABay6233prp06fntttuy2qrrdZo/eqrr54HH3wwX/7ylzN69OhWSAgAQFI/D7vtttuy0047Fdzmn//8Zw488MA888wzRUwGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0L5UlzoAAAAAlIvZU+pfb/+j1EkAAAAAAAAoV55JAQAAAAAAAAAAAAAAAAAAAAAAAFBMDz30UHbbbbeMHDkyAwYMaLS+e/fuufPOOzNkyJAMHTq0FRICAHRsn/3sZ3PHHXdk/fXXL7jN008/ncGDB+f9998vXjAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAdqiy1AEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIC24bnnnsvOO++cN954o6D6zp0754YbbsgJJ5xQ5GQAAB3bvvvum3HjxmX99dcvuM3w4cOz22675f333y9eMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIB2qrLUAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgLZj4sSJGThwYJ5++umC6isqKnLhhRfmt7/9bZGTAQB0TN///vdz5513pkePHgW3Offcc/OVr3wlCxYsKGIyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgParstQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAtuXDDz/MF7/4xdx///0FtznllFNyzTXXpKqqqojJAAA6jsrKylx88cX54x//WPAcq6amJkcddVR+8pOfpK6ursgJAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANqvylIHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2p558+Zl0KBBufnmmwtuM2TIkIwYMSKrrLJKEZMBAJS/7t27584778zxxx9fcJuZM2dm3333zVVXXVXEZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADlobLUAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgLappqYmhx9+eC6++OKC2xxwwAG5//7707t37yImAwAoX+uuu27GjRuXQYMGFdzmzTffzE477ZQHHnigiMkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAykdlqQMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABtV11dXf7nf/4nP/3pT1NXV1dQm5122imPPvpo1llnnSKnAwAoLzvssEOeeOKJbLnllgW3GTNmTHbccce8+uqrRUwGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUF4qSx0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABo+84+++wcddRRWbZsWUH1n/70pzNu3LhsscUWRU4GAFAeDjvssDz88MMZMGBAwW2uvfba7LXXXpk+fXoRkwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUn8pSBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANqHq6++OoccckgWLlxYUP26666bRx99NF/4wheKnAwAoH0744wzMnTo0KyyyioF1dfV1eW0007Lt7/97dTU1BQ5HQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAED5qSx1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoP244447svfee2fmzJkF1ffp0yf3339/9t9//yInAwBofzp37pzrr78+v/zlL1NRUVFQm4ULF+arX/1qfvvb3xY5HQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAED5qi51AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoH0ZO3Zsdt1114waNSprr712o/WrrrpqRowYkaOOOirXXXddKyQEAGj7+vbtmxEjRmSXXXYpuM2UKVNy4IEH5sknnyxiMgAAAKA92GSTTTJ48OAGa/7whz9k6dKlrZQIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgfakudQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKD9mTBhQnbeeeeMGjUqm2++eaP11dXVueaaa7LGGmvkd7/7XSskBABouzbbbLPcdddd2WijjQpu88ILL2T//ffPO++8U8RkAAAA5auqqiqbbLJJPvvZz+ZTn/pUevbsmR49eqS6ujrz5s3L7NmzM23atLz00kt58cUXM3fu3FJHhgZtueWWOf/88xusueyyy7J06dJWSgQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANC+VJc6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0D5Nnjw5AwcOzF133ZUvfOELjdZXVFTknHPOyZprrpmTTjqpFRICALQ9e+65Z4YNG5bevXsX3Oaee+7J1772tcybN6+IyQAAAMpPjx498pWvfCWHHHJI9t5776yyyioFt3322WczfPjw3HzzzXn11VeLmBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAohcpSBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANqvGTNmZM8998ydd95ZcJsTTzwxN910Uzp16lTEZAAAbc93v/vdjBw5Mr179y64zR/+8IcccMABmTdvXhGTAQAAlJdevXrlrLPOyuTJk3PNNdfkwAMPzCqrrNKkPrbZZpuceeaZefnllzNixIhst912RUoLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlEJ1qQMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADt28KFC3PwwQfnyiuvzJAhQwpqc9hhh6Vfv345+OCDM2/evOIGBAAoscrKypx77rk5+eSTC26zdOnSHH/88bn88suLmAwAAKD8HHDAAbnyyiuzxhprtEh/FRUVOeiggzJ48OBcdNFFOe2007J48eIW6Zvyt8466+QXv/jFCtcvXbo0xx57bCsmAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4CPVpQ4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC0f8uWLcu3v/3tfPDBBznllFMKarPXXnvloYceyn777ZcPP/ywyAkBAEqjW7duGTp0aAYPHlxwm9mzZ+erX/1qRo8eXcRkAAAA5eeCCy7ISSedVJS+Kysrc9JJJ+W//uu/su++++a9994ryjiUlz59+uSoo45a4fpFixbl2GOPbcVEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfKSy1AEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDyceqpp+bEE09MXV1dQfXbbbddxo4dmw022KDIyQAAWt/aa6+dRx99NIMHDy64zcSJE7Pzzjtn9OjRRUwGAABQXiorK3PdddflpJNOKvpYW265ZcaOHZsNN9yw6GMBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxVNZ6gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEB5ueiii3LEEUdkyZIlBdVvvPHGGTduXLbeeusiJwMAaD2f+9zn8sQTT2SbbbYpuM1jjz2WHXfcMS+99FLxggEAAJSh3/72t/nWt77VauOtv/76ueeee7Laaqu12pgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAy6oudQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKD8DB06NNOmTcvf//73dO/evdH6AQMG5JFHHslBBx2Uhx56qPgBAQCK6OCDD85f//rXdOvWreA2N910U4YMGZLFixcXMRkAAED5OfTQQ/PjH/+4ye2WLVuW6dOnZ8mSJenXr1+6du3apPabbrpprr/++hx00EFNHhtawpQpU3LnnXc2WLNs2bJWSgMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAND+VJc6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUJ5Gjx6dPfbYI3fffXdWX331RutXW221jBw5MkcccURuvfXWVkgIANDyfvSjH+Wcc85JZWVlQfV1dXX51a9+lZ///OdFTgYAAFB+VltttfzpT38quP7BBx/M0KFDc++992by5Mmpq6v7WF+77rprBg8enCOPPDJdu3ZttL8DDzwwX/nKV9zTpiTGjRuXwYMHlzoGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAu1VZ6gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAED5euqppzJw4MBMmjSpoPouXbrk5ptvzrHHHlvcYAAALay6ujpXXHFFzj333FRWVhbUZtGiRfnv//7v/PznPy9yOgAAgPL0//7f/0v//v0brXvjjTfyX//1X9lzzz1zxRVX5O23305dXd3HaubMmZO77rorxxxzTDbeeOPcfPPNBWW44IIL0qVLl2blBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEqnstQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA8vb6669np512yvPPP19QfVVVVS655JKceeaZRU4GANAyevfundGjR+eoo44quM2HH36YPfbYIzfeeGMRkwEAAJSvXr165Zhjjmm0bvz48fnCF76Q+++/v+C+//nPf+brX/96fvGLXzRa+6lPfSrf+MY3Cu4bAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaBuqSx0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAof1OmTMluu+2W2267LbvvvntBbX7+859nwIABOfbYY1NbW1vkhAAAzbPxxhvn7rvvziabbFJwmwkTJuSAAw7IpEmTihcMAACgzH3729/OKqus0mDNu+++m0GDBmXWrFnNGuOss87K2muvnaOPPrrBuh/84Ae55pprVri+oqJihVnr6uqycOHCjy3r3r179t9//+y+++7ZbLPNsvrqq6dr165ZuHBhZsyYkRdffDFjxozJnXfemQULFjT9B2vEgAEDstdee2W33XbLgAED0q9fv/Tt2zdLly7NtGnTMm3atLz22mu59957M3bs2NTU1DSp/6a+H0myzjrrZOutt06/fv3SpUuXfy2//fbbM2XKlILGXX311TNo0KBst9122WKLLdKnT5907949lZWVmTt3bmbPnp3p06fnmWeeyfjx4/PYY49l0aJFBfVdXV2dzp07f2L5qquu2mC7ioqKRmuSZOHChamrq/tE28b2gYa2j6Z+Dt26dcv++++fvfbaK1tssUX69u2bTp06ZebMmZk2bVpefPHFjBo1KmPGjGnyNrEiG2+8cQ466KB8/vOfz3rrrZeePXumoqIi8+bNy+TJk/Pss89m5MiReeKJJ1pkPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoGOpLnUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgY5g9e3b22WefDB06NIccckhBbY4++uisvvrqOfzww7N48eIiJwQAaJrddtstw4cPT58+fQpuc++99+arX/1q5syZU8RkAAAA5e9b3/pWozVHHnlkZs2atVLjnHjiidlrr72y0UYbrbBm2223zWc+85lMmDBhuet32GGHPP7448td9+6772bddddNkvTs2TM///nPc/TRR6d79+4rHO+LX/xijj/++MyfPz+XXHJJfvOb32TmzJlN+KmWb/DgwfnZz36WHXbYoaD60047LfPmzctll12W3/zmN5kxY0ZB7Qp9P5LkwAMPzC9+8Yt87nOfW279K6+8kilTpjQ43q677pqf/vSn2XvvvVNZWdlovkMPPTRJMmvWrFx99dW58MIL88477zTY5uSTT84555zTaN//qUuXLpk/f36jdRtttFHeeuutjy1r6H1M6vP37t17hesL/Ryqqqpy6qmn5sc//nF69uy5wv7222+//OQnP8k777yTM888M9dcc01qa2sb+rEazHbOOedkjz32WGHNdtttl0MOOSRnnnlmXnzxxfz0pz/N7bffniQ5/PDD85e//GW57R544IHss88+zcoFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUl8pSBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADqOxYsX59BDD82f//zngtsccsghGTVqVHr27FnEZAAATXPkkUdm9OjR6dOnT8FtLrvssuy3336ZM2dOEZMBAACUv/79+2frrbdusGb8+PF54IEHVnqshQsX5vzzz2+07ktf+tJKjbP99tvnhRdeyMknn5zu3bsX1KZbt2758Y9/nAkTJmTPPfds9tibbrppnnrqqdx+++3ZYYcdmtS2e/fu+dGPfpRJkyZlyJAhzc6wPBdeeGFuu+22fO5zn2tW+z59+uSmm27KI488kn322SeVlZVNat+rV6+cfPLJmTBhQr7xjW80K0NLqKmpyaRJk0oy9hZbbJEnn3wyv/rVrwp+TrPuuuvmyiuvzD333JMePXo0abzKysr8+te/zuOPP5499tij4Haf/exnc9ttt+Xaa69Np06dUlFRkerq6uW+mrodAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5auy1AEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICOpba2Nt/73vdy1llnFdxm9913zyOPPJIBAwYUMRkAQGHOPvvsXHvttencuXNB9cuWLctJJ52UY489NsuWLStyOgAAgPK35557pqKiosGaSy+9tMXGu/766zNv3rwGa/bZZ59m97/DDjvkgQceyLrrrtus9muuuWZGjhyZr3zlK01u+6UvfSmPP/54tttuu2aN/ZEePXrkmmuuydlnn71S/XzkrLPOygknnNDs9htssEGeeuqpHHbYYSudpUePHrnhhhvy4x//eKX7ao6JEyemtra21cfdcMMN89BDD2XbbbdtVvsvfelLGTNmTFZZZZWC6isrK3PjjTfm9NNPb3T/XpEjjzwyw4YNS1VVVbPaAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHUtlqQMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAd0y9+8Yscd9xxWbZsWUH1W221VR577LFssskmRU4GALB8Xbt2zS233JLTTjut4Dbz5s3LwQcfnAsvvLB4wQAAADqYbbbZptGaUaNGtdh48+bNy7hx4xqs2WqrrZrVd/fu3TN8+PD06NGjWe0/0qlTpwwdOjQ77LBDwW323HPP3H333enVq9dKjf3vTjvttJx66qkr1ccuu+ySM844o9nt+/btm4cffjgbbLDBSuX4T7/97W9zwAEHtGifhXj99ddbfcxu3bpl9OjR6d+//0r1s/XWW+dPf/pTQbUXXXRRDjvssJUaL0kOPPDA/OQnP1npfgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgPJXWeoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAx3XppZfmsMMOy+LFiwuqX3/99TN27Nhsv/32RU4GAPBxa6yxRh5++OEceuihBbeZPHlydtlll9x5551FTAYAANDxbLbZZg2uf+edd/LBBx+06JhPPvlkg+vXXHPN9OjRo8n99urVK2uvvXZzY31Mp06dctNNN6VLly6N1q611lq56aabUlVV1SJj/7tf/vKX2XnnnZvVtrKyMhdddFEqKiqaPf51112Xddddt9ntV6SysjJ/+MMfivKeNeT1119v1fGSpHfv3tlwww1bpK9vf/vb2WWXXRqsGTx4cI4//vgWGS9JPvvZz7ZYXwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQPmqLHUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgY7v11luz7777Zs6cOQXVr7766nnwwQez9957FzkZAEC9rbfeOk899VQ+//nPF9zmiSeeyOc///k899xzRUwGAADQMW200UYNrn/hhRdafMxCru8ay9UaNtxww5xwwgmN1l111VVZffXVG62bM2dOHnrooQwbNizDhw/P+PHjs2TJkgbbVFdX54orrig4879ba6218rnPfa5ZbZNkjz32yP77799o3axZszJ+/PiMGDEiw4YNy5gxY7Jw4cJG222wwQb5xje+0ex8zfHaa6+16njF8MMf/nCF6zp16pQLL7yw9cIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD8r+pSBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHjooYeyyy67ZNSoUVlzzTUbre/evXvuvPPODBkyJEOHDm2FhABAR3XAAQdk6NCh6d69e8Fthg0blm9+85tZtGhREZMBAAB0XD179mxw/fTp01t8zBkzZjRas9pqq7XIWOPHj89VV12VZ599NtOmTUufPn2yzTbbZMiQIdl1110bbf/DH/4wF1xwQZYuXbrc9dtuu2323XffBvuYOnVqTjrppNx0001ZtmzZx9b16NEjP/nJT3L66aensrJyue0//elPZ9CgQbnnnnsazduSHn/88Zx66qk55ZRT0rt370+sf/3113PKKafkzjvvTE1NzcfWrbbaavn1r3+d448/vsExDjvssFx//fUfW/buu+/m0Ucf/URt9+7ds80226ywr7q6uowdO7bB8Z555pkG17eWUaNG5ZprrslLL72U+fPnp3///tlzzz1z8sknp2/fvg22PfDAA9OrV6/MmjXrE+uOOOKIbLjhho2OP3Xq1Fx++eW5//77895772XZsmVZa621ss8+++S4445b7ucNAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQkOpSBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEiSF154ITvttFPuvffebLrppo3Wd+7cOTfccEPWXHPNXHDBBa2QEADoaE488cScd955qaqqKrjNb37zm5x++ulFTAUAAEC3bt0aXD979uwWH3PWrFmN1nTv3n2lxliyZElOOOGEXHbZZR9bPmnSpDzzzDO5+uqrc8QRR+TKK69M165dV9hP//79M3jw4AwfPny560855ZQGc0ydOjU77rhjJk6cuNz1c+fOzc9+9rO89957ueSSS1bYz4knnph77rmnwbEKMWfOnPz973/PnXfemTfeeCPTp09PbW3tv7L+uwULFuScc87JZZddlh//+Mc58cQT/7W9PP/889l9991X+FnOmTMnP/jBD9K3b98cfvjhK8yzyy67pKKiInV1df9aduONN+bGG2/8RO1WW22V5557boV9LV68OLvuuusK17cFCxYsyHe+853cfPPNH1v+1ltvZfz48bn66qszZsyYbLzxxivso7KyMjvttNNyt4fvfe97jWa4++67c/jhh2fOnDkfW/7mm29mzJgxufDCCzN8+PDssssuBf5UAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASWWpAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHzk7bffzsCBA/Pkk08WVF9RUZHzzz8/5513XpGTAQAdSVVVVS699NL8/ve/T1VVVUFtlixZkiFDhuT0008vcjoAAABWXXXVBtfPnz+/xcecN29eozXdunVbqTF+8IMf5LLLLmuw5oYbbsiRRx7ZaF/777//cpdXV1dn8ODBDbb9/ve/n4kTJzY6xqWXXpoJEyascP3uu++ezp07N9pPQ26++east956+fa3v51bb701zz33XN5999289957ee+991JTU7PcdrNnz84ZZ5yRDTbYIBdddFHmzp2br371q5k1a1ajY/76179ucH3Pnj2zySabNOfHaZeOOeaY3HzzzStcP2XKlBx11FGN9rPzzjt/Yln//v2z4447Ntju6aefzkEHHZQ5c+assGbatGnZZ5998uqrrzaaAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4COVpQ4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADw76ZNm5Y99tgj9957b8FtfvjDH+Yvf/lLqquri5gMAOgIVltttdx999055phjCm4zY8aM7L333rnuuuuKmAwAAICPVFRUNLi+rq6uxccspM/GcjXkvvvuy5///OeCav/2t781eg99jz32WO7y7bffPquuuuoK202aNCm33HJLQTk+yrIiXbp0yfbbb19wX//p+uuvz9e//vXMmjWr2X1MnTo1J554YtZaa6289tprBbWZMGFCpk+f3mBN3759m52pPXnggQdy/fXXN1r38MMP5+WXX26wZsCAAZ9Y9sUvfrHR/ea4447L0qVLG82wYMGCHH300Y3WAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfKSy1AEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD+0/z583PAAQfkxhtvLLjNN7/5zdx+++1ZddVVi5gMAChn66+/fsaNG5cvfelLBbd5/fXXs+OOO+aRRx4pYjIAAABKraKioqj9X3zxxU2qv/zyyxtcv8EGG6RLly6fWL7bbrs12O6OO+5oUo7nn3++wfWf//znm9TfR959990cffTRzWq7PPPmzWtS/fvvv9/g+j59+qxMnHbjqquuKrh2zJgxDa7v3bv3J5ZttdVWDbZ54YUX8sQTTxSc4ZFHHslzzz1XcD0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANCxVZc6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwPLU1NTkiCOOyIcffpgTTzyxoDaDBg3KAw88kP322y8zZswobkAAoKzstNNOGTFiRPr3719wmwceeCCHHnpoZs6cWcRkAAAA/KdFixala9euK1zf0LrmKqTPhQsXNrv/hx56qEn1jz76aIPrKyoqsuGGG+bll1/+2PINNtigwXaTJ0/OWmutVXCO6urqBtevscYaBff17y6++OIsWrSoWW2bok+fPtlggw2y4YYbfuK/DenWrVvRs7UFjzzySMG1EydObHD9aqut9ollG2+8cYNtmrpfJMno0aOz9dZbN7kdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQ8VSXOgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBDTjrppLz//vv57W9/m4qKikbrd9xxx4wdOzb77LNPJk+e3AoJAYD27ogjjshVV12VLl26FNzmyiuvzLHHHpulS5cWMRkAAADLM2/evPTq1WuF6xta11yF9Dlv3rxm9f3hhx9mzpw5TW4ze/bs9OzZc4U1ffv2/cSyPn36NNjvueeem3PPPbdJWRrS2HgrMnLkyBbLkCQbbbRRdtxxx2y77bbZZJNNssEGG2SDDTZIjx49WnScclJXV5cpU6YUXN/Y9r+8Zzy9e/dusM0bb7xR8PgfmTBhQpPbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHVN1qQMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA05ne/+10++OCDXHnllamubvyfZ958880zbty47LPPPpkwYUIrJAQA2quzzjorZ5xxRioqKgqqr62tzSmnnJLzzjuvyMkAAABYkXnz5jW4vlevXi0+ZiF9NpZrRWbOnNmsdrNmzUrPnj1XuL5bt26fWNa3b99mjdVcffr0aVa7V155ZaXH7tKlS4455ph897vfzZZbbrnS/XU0c+fOzdKlSwuur62tbfIYy9tG/92sWbOa3Gdz9ycAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKDjqSx1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgEJcd911Ofjgg7NgwYKC6tdee+2MGTMmAwcOLHIyAKA96tKlS4YOHZqf/exnqaioKKjN/Pnz85WvfCXnnXdekdMBAADQkLfffrvB9ZtuummLj7nZZps1WjNp0qRm9V1TU9OsdosWLWpwfZcuXT6xrFu3bs0aq7mqq6ub3GbBggVZsmTJSo37xS9+MW+88UYuvPDCbLnllivVV0dVW1tb9DGqqqoaXL906dIm99nc/QkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOh4KksdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoFB33XVX9tprr8yYMaOg+t69e2f06NEZPHhwkZMBAO3J6quvngcffDBf//rXC27z3nvvZbfddsuIESOKFwwAAICCvPrqqw2u33zzzdO9e/cWHXPHHXdscP2sWbMyderUZvVdUVHRrHblasmSJSvV/vDDD8/o0aOzzjrrtFAiimXZsmUNru/cuXOT+2xOGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoGOqLHUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAphg/fnx22WWXvPPOOwXVr7LKKhk+fHi+853vFDkZANAefPrTn87jjz+enXbaqeA2zz77bD7/+c/nmWeeKWIyAAAACjVhwoQG11dWVmbXXXdtsfGqqqoycODABmteeumlZvffuXPnZrXr2rVrg+sXL178iWULFixo1ljtxbbbbptrrrkm1dXVzWo/ZcqUjB07NrNmzWrZYCzXvHnzGlzfq1evJvfZt2/fZqYBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA6mupSBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGiql19+OTvvvHNGjRqVT3/6043WV1VV5corr8yAAQNy9tlnt0JCAKAt2nvvvXPLLbekZ8+eBbe54447cvjhh2f+/PlFTAYAAEBTPPDAA43WHH300bnnnntaZLwDDzwwa6yxxkpnWpE+ffo0q12vXr0aXL+8a9kZM2Y02Obcc8/Ns88+26w8y/Puu++2WF+FOO+889KlS5cGa+rq6vLCCy/kqaeeyksvvZQ333zzX68FCxYkSZ588slsv/32rRG5Q5s+fXqD6z/zmc80uc+tttqquXEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAOprrUAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJrj3XffzS677JK77rorO+20U6P1FRUV+fWvf50BAwbkhBNOSF1dXSukBADaimOOOSYXX3xxqqurC25z7rnn5tRTT01tbW0RkwEAANBUb7zxRt5+++2st956K6wZPHhwNt5447zxxhsrPd4Pf/jDRmtGjhzZ7P779u2bfv36Zdq0aQW36d+/f3r27NlgzfTp0z+xbMaMGQ22eemll3LjjTcWnKMt2WyzzbLnnnuucH1dXV3OPffcXHjhhXn//fcb7Ktr164tHY/leP311xtc39DnuSL77LNPc+MAzXTGGWekW7duSZKrr7660X0bAAAAoCncewAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACKqbrUAQAAgI7hwgsvzP777/+J5ffdd1+OPfbYEiQCgPIzZsyYDBgw4BPLf/Ob3+Tqq68uQSLKnW0OANo/53NoPe6RQuvqqPtcR/25l8d7AQAAAAAAAAAAAAAAAAAAAAAAAADQscycOTN77bVX/va3v+WAAw4oqM0PfvCD9O/fP9/85jdTU1NT5IQAQKlVVlbmoosuyvHHH19wm5qamhx77LG56qqripgMAACAlXHLLbfkRz/60QrXV1VV5a9//WsGDhyYZcuWNXucE044IQMHDmyw5t13381jjz3W7DGSZJ999skNN9xQcP2uu+7a4Pq6urq89dZbn1j+9ttvN9hu2223zbXXXltwjrZk7733bnD9BRdckFNOOaWgvtZcc82WiNSoqqqqVhmnrXruuecaXL/hhhtm0KBBueeeewrq74ADDshmm23WEtGAJjjhhBPSr1+/JMmDDz6Y119/vcSJAAAAgHLi3gMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQTNWlDgAAbdluu+2W9ddfP6uttlq6deuWLl26pLa2NvPmzcucOXMyZ86cvPnmm3n55ZezaNGiUscFaNPWWGONbLzxxp9Y/uKLL5YgDdARderUKRUVFZ9YXldXl5qamhIkgpa3/vrrZ5111vnE8l69erV+GDoE2xxthfM8QPM5n0PrcY8UGteSc/uOus+195+7rW4DrjsBAAAAAAAAAAAAAAAAAAAAAAAAANqHhQsX5uCDD86VV16ZIUOGFNTmsMMOS79+/XLwwQdn3rx5xQ0IAJRM9+7d87e//S2DBg0quM3MmTNz6KGH5oEHHihiMgAAAFbWJZdckpNPPjmVlZUrrNlxxx1z+eWX5+ijj05tbW2Tx9hvv/1yzjnnNFp36aWXNqv/f3fyySdn6NChBfdzzDHHNLj+zTffzOLFiz+x/NFHH22w3X777ZcTTjihoAxtzWabbdbg+hEjRhTcT9++fVsgUTJ37twG13fq1Cm9e/fOzJkzW2S89ubBBx9MbW1tg/vxn/70p2yzzTaZM2dOg3317ds3l156aUtHBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAylhlqQMAQFvSr1+/HHfccfn73/+eqVOn5uGHH851112Xiy++OL/97W9z5pln5pe//GV+//vf56qrrsott9ySZ555JvPnz89rr72WP//5zxn0/7N33+FRVO/fxz9phJBO6FIlSAcF6QhIJ3SU3rGjiApIExWkKkX9CkgH6U0gFGnSWwCRXkQ60ntPQpLnDx/yc9ndZJPMJrvJ+3VdXLqn3OfO7sw5ZyZl6tVTunTpUvpLAQAAwHN2796t8PBws38HDx5M6dQAAEASsc4DAAAAqQN7ezjqMeCoeQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBcVFSUOnfurBEjRtjcp0aNGtq0aZOyZMlix8wAAEBKyZUrl3bs2KF69erZ3OfUqVOqUKGCNmzYYMfMAAAAAABGOHPmjJYtWxZvu7feekuhoaEJuhfs6uqq7t27KzQ0VJ6ennG2ffDggSZNmmRzbGtKlSqlr776yqa2bdu2Vc2aNeNss3HjRovlYWFhioiIsNovODhYzZo1symPZxo2bKgPP/wwQX3sISgoyJA43bt3NySOJN25cyfeNiEhIYaN52zu3Llj9Vh9Jl++fNq4caPy5MljtU3+/Pm1efNm5cyZ0+gUAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKRirimdAAAAjqBcuXJaunSpLl++rLFjx6pp06bKlCmTzf1dXV1VoEABvfPOO1q1apVu3LihMWPGKHv27HbMGgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM/r06ePunfvrujoaJvaly5dWtu3b1e+fPnsnBkAAEhOZcqU0e7du1W8eHGb+2zbtk3lypXTiRMn7JgZAAAAAMBIPXv2VHh4eLzt6tevr1OnTmnw4MEqVqyY1XZBQUFq3769Dh8+rO+//15ubm7xxv7mm290/fr1BOVtzYABAzR06FC5urpabfPOO+9o6tSp8cZavny5xfLw8HCtWbMmzr7jx4/Xiy++GO8YklS5cmXNmTNHP/30kzZt2pSi99sfPXoUZ33Tpk3jjRESEqL33nvPqJR0+/Zt3bt3L842o0aNUoUKFQwb09n8/PPP8bYpVaqUjh8/rqlTp6pNmzaqWrWqKleurJYtW2rKlCk6fPiwihYtmgzZAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEhN3FM6AQAAUlLu3Lk1btw41a9f39C4vr6++uSTT/TBBx9o4sSJ6tOnjx49emToGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALDsxx9/1JUrVzRz5kylS5cu3vbBwcHasWOH6tatqwMHDiRDhgAAwJ7eeOMNzZw5U15eXjb3mTVrlt566y1FRETYMTMAAAAAgNFOnz6toUOHauDAgfG29fHxUf/+/dW/f39dunRJZ86c0bVr1xQeHq5MmTIpe/bsKly4sFxdXW0e/+jRoxozZkxSvgQTLi4u6tu3r5o3b65JkyZp7969un79ugIDA/XKK6+offv2Kl26dLxxLl26pFWrVlmt//bbb9WwYUOr9VmyZFFYWJj69u2rWbNm6cmTJ2ZtSpYsqbfffltdu3aNfc+qVq2qQ4cOqU+fPvrpp59s+IqNde3atTjrP/nkE127dk0//vijHj9+bFKXIUMGde/eXQMHDkzQMWCLsLAw1apVy2p91qxZtWPHDm3ZskVHjhzRzZs3zdr8/PPP+ueffwzNy1EsXrxYBw8eVIkSJeJslz59enXu3FmdO3dOpswAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApHbuKZ0AAAAppX379ho7dqx8fX3tNoanp6e6deumkJAQtWvXTrt27TIs9kcffaQ8efKYlW/ZskXLly83bBwAAAB7YC8DAAAAAAAAAAD3ywEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOxtwYIFunHjhpYuXWrT8yuzZcumLVu2qGnTptqwYUMyZAgAAOyhT58+Gjp0qFxcXGxqHxMToy+//FKDBw+2c2YAAAAAAHv55ptvVKFCBdWtW9fmPjly5FCOHDmSNO7du3fVpEkTRUZGJimOJcHBwRoxYkSi+3/77beKioqyWr9t2zZt375dlSpVstomU6ZMmjRpkn766ScdPnxYN27cUExMjDJnzqycOXMqa9asFvt5e3vrf//7n5o3b67OnTvr9OnTif46Emrnzp1x1ru6umr48OHq1auX9u3bpwsXLsjd3V05c+ZU+fLllSFDBrvktXr1atWqVSvedlWqVFGVKlUs1i1fvlz//POP0ak5hJiYGH300UfatGmTXF1dUzodAPHw8fFRlSpV9PLLL6tgwYLKkiWLAgICYuv79++vkJAQnTp1Srt27dK+ffviXJOS6pVXXlHZsmVVrFgx5ciRQ76+vvLy8lJkZKQePHig8+fP68iRI9q8ebOOHj1qlxw8PT1VqlQplS1bVkWLFlVgYKACAgKUPn16PX78WHfu3NHt27d18OBB7d69W/v377fL/iG5+Pn5mbx+8uSJIiIiUmUuBQsWVJUqVVS8eHHlzp1bvr6+SpcuncLDw3Xv3j2dO3dOBw8e1ObNm5N1zwOkRa6urvLx8bFb/Hv37iU5RqlSpVSmTBkVKVJEOXPmlI+Pj7y8vBQVFaUHDx7o8uXLOnHihLZv3649e/YYuj6++OKLatSokV599VVlzZpVbm5uun79uo4dO6bly5frjz/+MGysZ9KnT6906dKZlD1+/Nip1zgAtkvJOe95z+8JrYmIiNCTJ08MHZv5F7APR7r34EjzneT816kpOWdbU7x4cb322msqWrSocuXKJR8fH3l4eOjx48e6f/++zp49q0OHDmnjxo06d+5cosex5zWNEdczAP7lDPcf0tL+l70vAEfaj6fUXpx7DwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDycU/pBAAASAlff/21vvrqq2QbL3/+/Nq6davat2+vefPmGRKzbdu2Kl++vFm5u7u7li9fbsgYAAAA9sJeBgAAAAAAAAAA7pcDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkhw0bNqhatWpatWqVsmbNGm97Pz8//fbbb2rfvr0WLFiQDBkCAACjpEuXThMnTlTHjh1t7vP48WN16NBBixYtsmNmAAAAAAB7i4mJUatWrbRx40a98soryTLm48eP1bx5c508eTJZxkuIEydOaNy4cfG269ixo/744w/5+/vH2c7T01OlS5dOcB5VqlRR586dNWDAgAT3TawNGzbo4cOH8vb2jrNdUFCQatWqlUxZSVOmTNGgQYPizSst27p1q77++msNGjQopVMBYEXDhg31wQcfqGbNmvLw8LDarkqVKqpSpUrs67t372r+/PkaP3689u/fb0guGTNm1GeffaYOHTooV65cNvc7fvy4xo0bpwkTJigiIiLJeRQuXFgffvih2rVrF+96+l83b97UjBkzNHbsWJ0+fTrJeSSnfv36aciQISZl/fv319ChQ1NNLunSpdNbb72lDz/8UEWLFrW53759+/TTTz/pl19+UVRUVJJyAGCuatWq2rBhg93iu7i4JKpfvnz51L17d7Vu3VpZsmSxud/169c1Y8YMjRw5UlevXk3U2JKUOXNmfffdd2rfvr1cXV0ttvnqq6+0ceNGdevWTUeOHEn0WP8VFBSk/fv3K2fOnLFlly9fVsmSJXX9+nVDxgDgeFJ6zrMkb968OnPmjE1tJ0+erHfeeceQcZl/AftwlHsPjjbfpZbr1JSasy3x8vJS165d9f777ys4ONjmfvv27dN3332nBQsWKDo6OkFj2vOaJrHXMwDMOer9h2fS0v6XvS+QdjnSfjwl9+LcewAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACSn+UnhQAAkIr17dtXX331VbztoqOjNW3aNPXo0UOdOnVSs2bNVLduXdWvX18tWrTQW2+9pW+++UaLFy/WhQsX4o3n7u6u2bNnq3379kZ8GQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALDBvn37VKlSJZ0+fdqm9unSpdPcuXP10Ucf2TkzAABglKCgIP3+++/q2LGjzX2uXLmiqlWratGiRXbMDAAAAACQXO7evauqVatq8+bNyTJW7dq1tW7dOruPlVBPnjxRixYtFBkZGW/bU6dOqWPHjoqJibFLLuvXr9fXX39tl9jWPHz4UGPGjDEk1s2bN3XixAlDYt29e1eDBg0yJFZq9s033+iHH35IUoyHDx9yvwcwWOnSpbV3716FhoaqXr168vDwSFB/f39/vfvuu9q3b5/mzJmjrFmzJimfd955R2fPnlX//v2VK1euBPUtVKiQfvzxRx0/flyVKlVKdA6enp4aMWKEDh06pA8//FD+/v4J6h8UFKTPPvtMx44dU//+/eXm5pboXJJTlSpVHGY9s1cu1apV0/HjxzVu3DgVLVo0QX1LlSqlqVOn6uDBgypTpozhuQFpnY+PT0qnYMLLy0sjR47UyZMn1b17d2XJkiVB/TNnzqyePXvq9OnT+vTTTxOVQ3BwsHbt2qWOHTvK1dU1zravv/66du7cqRo1aiRqrOfNnDlTOXPmjH0dFRWl1q1b6/r164bEB+BYHGHOs6ZAgQKGxrMF8y9gPEe59+CI811quk5NiTnbknr16unvv//WyJEjFRwcnKC+pUqV0ty5c7V9+3bly5cvQX0d7ZoGgGWOfq6mpf0ve18g7XG0/XhK7sW59wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACkjLifFgIAQCrToEEDDRkyJM42f//9t7p3764XXnhBXbp00ejRozVjxgwtWbJEa9as0apVq7Rw4UJNnTpVX375pd58803lzp1bJUuW1Hfffaf79+9bje3q6qpp06apcuXKRn9pAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsOLUqVOqWLGi9u/fb1N7V1dX/e9//9PgwYPtmxgAAEiyggULKiwsLEHPjj506JDKli2rPXv22DEzAAAAAEByu3//vmrVqqWhQ4cqKirKLmNs27ZNpUqV0rZt2wyN++DBA/32229JihEeHq6mTZvq4MGDNvdZtmyZ3njjDT18+DBJYz8vNDRUDRs2tNvnEJdhw4bpjz/+SFKMR48eqVmzZrp8+bJBWUnffvutFi9ebFi81OqTTz7RBx98oPDw8AT3vX79umrVqqWNGzfaITMgberatat27dql0qVLJzmWi4uLWrdurf379+u1115LVP8ZM2Zo4sSJ8vX1TVIu+fLl0+bNm9WuXbsE9/Xz89PWrVv1+eefy83NLUl5pEuXToMHD9batWuVPn36JMWyt8yZM2vevHlJ/podOZfu3bvr999/V758+ZIUp0iRItq2bZvat29vUGYAJMnHxyelU4iVLVs2hYWFqUePHkmeizJkyKDRo0dr/vz5cnd3t7mft7e3Vq1apRdffDG2LCYmRtu3b9fEiRM1btw4rVmzRhEREbH1vr6+WrZsmQoUKJCknHv16qV69eqZlA0cOFCbN29OUlwAjskR5ry4JHVOSyjmX8B4jnLvwRHnu9R2nZrcc7Ylffr00cqVK5UjR44kxSlfvrx2796tYsWK2dzHka5pAFjn6OeqM+1/k4K9L5D2ONp+PCX34tx7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFKOMU9cBQDACXh7e+vnn3+Wi4uLxfrw8HD1799fP/74oyIjIxMc/+DBg/r88881dOhQDRs2TO+//77Fdm5ubpozZ45KlCihO3fuJHgcAAAAJE6LFi3k5eVlVh4eHp4C2QAAACOxzgMAAACpA3t7OOox4Kh5AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIOGuXr2qKlWqaNmyZXr99ddt6tO/f39ly5ZN7777rqKjo+2cIQAASKjq1atr0aJFCgwMtLnPb7/9phYtWujBgwd2zAwAAAAAkFIiIyPVv39/LVmyREOGDFHt2rUNiXvhwgUNHTpUEyZMUExMjCEx/+vp06dq1KiRZs6cqVatWiW4/9mzZ9WmTRvt3LkzwX2XLFmiChUqaObMmSpZsmSC+//XrVu3NGDAAI0bNy5JcZLi0aNHCgkJUWhoqMqVK5fg/ufOnVPz5s21Z88ew3Nr3ry5BgwYoC+++EIeHh6Gx08tfv75Z/32228aPHiwmjdvLk9PzzjbP3nyROPHj9fXX3+te/fuqUKFCnG2v3fvnpHpAqnWZ599plGjRlmsu3r1qjZt2qR9+/bp0qVLGjdunHx9fSVJ48eP15MnT1ShQgWVKVNGbm5uJn2zZcumtWvXKiQkRBs3brQ5n4kTJ6pDhw4W6w4fPqxNmzbp2LFjunXrlh4/fixvb29ly5ZNZcuWVb169eTn52fSx83NTTNmzNC1a9e0du1am3Lw9PTUunXrVKZMGYv1hw4d0tatW3X48GHdvn1bjx8/VoYMGZQxY0YVL15c1apVU8GCBc36Va9eXcuXL1edOnUc8vvSLi4umj17trJnz57Sqdgtl08//VSjR4+2WBcdHa3t27fr4MGDunTpku7evauAgADlyJFDpUqVUrly5eTi4mLSJ126dJoxY4aio6M1e/ZsQ3MF0ipvb++UTkGS5O/vr61btyo4ONisLiIiQtu3b9fu3bt16tQp3b17V+Hh4fL29lZQUJBKliypGjVqKG/evGZ9W7RoocePH6tTp0425TF8+HAVKFAg9vWVK1fUqFEjs+uYPHnyaOnSpXr55Zcl/fs+Tp8+XZUqVbL5a/6vChUqaOjQoSZlGzZs0ODBgxMVD4Bjc5Q5Ly6W9tf2xPwLGMtR7j044nyXGq9Tk3vOfl7Pnj01bNgwi3WXL19WaGio/vrrL125ckWPHj2Sl5eXsmfPrpdffll16tRRlixZTPpkypRJa9euVfHixXXz5s14x3eUaxoAcXP0c9WZ9r+Jxd4XSHscbT+e0ntx7j0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKcc9pRMAACC59OjRQy+88ILFujt37qhx48basmVLkse5c+eOPvjgA61du1Zz586Vp6enWZtcuXJp5MiRevvtt5M8HgAAAGxz8uTJlE4BAADYCes8AAAAkDqwt4ejHgOOmhcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAS5/79+6pbt65mz56tN99806Y+b731ljJnzqyWLVvqyZMnds4QAADY6q233tL48ePl4eFhc5+ffvpJ3bt3V3R0tB0zAwAAAAA4gr1796pOnToqU6aM3nnnHTVu3FhZsmRJUIzIyEht2LBBc+fO1ezZs/X06VM7Zfuvp0+fqnXr1po5c6ZGjx6tggULxtvn1q1bGjNmjL7//ns9ePAg0WMfOnRIL7/8sho1aqR+/fqpbNmycnFxsbn/qVOnNHnyZI0fP153795NdB5GuXbtmipVqqQePXrok08+Ufbs2ePtc+PGDY0dO1bffvutHj16ZJe8YmJiNGjQIE2YMEHvvfeeGjRooJIlSypdunR2Gc+ZnTt3Tu3bt1e3bt1Ur149lS1bVnny5FFgYKCioqJ09epVXblyRZs2bdL69ev1+PHj2L6BgYFxxr5165a90wecXtWqVfXdd9+ZlZ84cUK9e/fW8uXLTe6zjhkzRr6+vpKkpUuXau3atZKk7Nmz68MPP9Rnn30mLy+v2Pbp06dXaGioXnnlFf3999/x5tOqVSu9/fbbZuVr165V7969tX///jj7e3t766OPPtLXX3+t9OnTx5a7urrql19+UXBwsE3raN++fVW2bFmz8i1btujTTz/Vvn374o1RsWJF/fjjjypdurRJec2aNdW1a1f99NNP8cZIbn379lWtWrVSOg1J9smlUqVKGjVqlFl5VFSURo0ape+//16XL1+22j9Xrlzq1auXPvroI5P9k4uLi6ZMmaK9e/fqxIkThuYMpEU+Pj4mrzds2KDOnTsnex7Tp09XcHCwSdnjx481dOhQjRs3zqa9Zu3atTVmzBgVKVLEpLxjx45auXKlFi5cGGf/oKAgvfXWWyZlLVq00J49e8zanjt3TiEhITp58qS8vb0l/bsWVaxYUTt27Ig31/8KDAzU/Pnz5e7uHlt29epVtWnTRjExMQmKBcA5OMKcF59PPvlEn376qVl5sWLFdODAgSTFfh7zL2AsR7r34GjzXWq9Tk3OOft51atX17fffmtWfvr0aX300UdavXp1nHOqu7u7unTpou+++05+fn6x5dmzZ9f48ePVokWLeHNwlGsaAHFz9HPV2fa/7H0B2MKR9uMpvRfn3gMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQstzjbwIAgPNzc3PTe++9Z7W+VatW2rJli6FjLlmyRG+88YaWLl1q8tCsZzp27KghQ4bozJkzho4LAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA6yIiItSyZUv973//U9euXW3q06hRI61bt04NGzbUnTt37JsgAACIk4uLi0aMGKFevXrZ3CcqKkrdu3fX2LFj7ZgZAAAAAMAR7dmzR3v27NF7772n0qVLq0SJEipevLjy5MkjX19f+fv7y83NTffv39e9e/d08+ZNHT58WIcPH9bOnTt17969ZM951apVWrVqlUqWLKkGDRqocOHCypo1qzJmzKjHjx/H5rht2zatW7dOT58+NWzs0NBQhYaGKigoSNWqVVOlSpWUNWtWBQUFKSgoSG5ubnr48KHu3r2rM2fO6MiRI9q4caNOnDiRoHF2794tFxcXw/K2JCoqSt9++61Gjx6tGjVqqGLFiipWrJgCAwPl7++vJ0+e6MaNGzp+/Lg2btyoDRs2KCIiwiTG66+/bpfcrl69qkGDBmnQoEHy8PDQSy+9FJuXt7e3xT5///23WVlS30ejP4dx48Zp3LhxhsWTpDt37mju3LmaO3euzX1eeumlOOtv3bqV1LSAVG/cuHFydXU1KZs3b546duxoNlfG5fLly/riiy80ZcoULV26VCVKlIit8/Hx0ezZs1W+fHnFxMRYjeHt7a2ffvrJrHzo0KHq37+/TXk8fPhQI0aM0MaNG7V27Vr5+/vH1mXNmlUfffSRhg8fHmeMLFmyqE+fPmbl48aN04cffmhTHpK0Y8cOlS1bVrNmzVLr1q1N6oYMGaJp06bp4cOHNseztypVqmjQoEEpnYYk++Ti6empKVOmmK2H165dU0hIiP744494Y1y4cEEff/yxFi5cqNDQUAUEBJjEnzp1qipXrhzncQ4gfj4+Piavb926pfPnzydrDlWrVlWTJk1Myi5cuKDatWvr+PHjNsdZu3atXnnlFS1cuFCNGjUyqRs+fLgWLVoU55zRrFkzeXl5xb7esmWLtm7darX95cuXNW3aNH300UexZe3atdOOHTtszlmSfvnlF+XKlSv2dXR0tNq0aaOrV68mKA4A5+Aoc158YmJiLPY38n7ZM8y/gLEc5d6Do813qfk6NTnn7P9Knz69pk+fbvaeLlmyRG3bttXjx4/jjfH06VNNnDhRYWFh2rRpk8l72rx5c5UsWVIHDhyIM4YjXNMAiJ+jn6vOtP9l7wvAFo60H3eEvTj3HgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICU5Z7SCQAAkBwqVaqkHDlyWKz75ZdftGbNGruMu3LlSg0bNkwDBgwwq3N3d9dnn32mbt262WVsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWBYdHa0PP/xQV65c0aBBg2zqU7lyZW3dulV16tTRpUuX7JwhAACwJEOGDJo1a5aaNm1qc5/79++rRYsWWr16tR0zAwAAAAA4upiYGO3du1d79+5N6VRsduDAAR04cCBFxr5586YWL16sxYsXp8j4Rnr69KnWrFmjNWvWpHQqFkVGRurIkSMpnUaqUqFChTjrT548mUyZAM6pRo0aKlKkiEnZ9u3b1aZNG8XExCQq5pkzZ1S1alVt377dJHbZsmXVokULzZ8/32rfd999V0FBQSZl06ZNU//+/ROcx+7du/Xuu++ajdexY0cNHz48zr7NmjWTp6enSdmWLVv04YcfJjiP6OhotW/fXkWLFlWJEiViy/38/FS/fn0tWLAgwTHtIXPmzJo3b57c3Nxiy1asWKEGDRqkmlz69eunggULmpTdv39fdevW1Z9//pmgWFu3blWjRo20du1apU+fPra8YsWKeueddzRx4sQk5Qqkdb6+viavHz9+nOw5PHr0SBs2bFD16tUlSU+ePFFISIiOHz+e4FgRERFq3ry5Dh48aDIPvfjii6pWrZo2btxote9rr71m8nrFihXxjrdixQp99NFHsa8rVaqUoHw/++wzszl3yJAh2rBhQ4LiAHAejjLnORLmX8A4jnTvwdHmO65Tjffxxx8rV65cJmVbtmxRq1atFBERkaBYBw4c0Pvvv6958+ZJkq5cuaLZs2fr7t278fZ1hGsaAPHjXP0/Sd3/svcFYAtH2o87wl6cew8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgORQq1YtzZkzJ/b18ePHzf4GDgAAAAAAAAAAAACkVa4pnQAAAMkhrgdejRs3zq5jDxo0yOxhZXv27FH79u3Vo0cPu44NAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA67755hu9++67ioqKsql9sWLFtGPHDhUsWNDOmQEAgOe98MIL2rJli5o2bWpznzNnzqh8+fJavXq1HTMDAAAAAACAPVStWjXBfWrVqqVcuXLF2Wbr1q2JTQlIE+rVq2dW1rNnT8XExCQp7p07d9SiRQtFRETElt28eVOBgYFx9gsLC9Py5ctjx79y5Yq6d++e6DwWLFig48ePm5QVKlRIGTNmjLNfSEiIWdkXX3yR6DyioqL05Zdf2jROSnBxcdGsWbOUPXv22LLz58+rQ4cOqSYXDw8Pde3a1az8008/1Z9//pmomFu3btWAAQPMyj/55JNExQOcRbVq1dShQ4fYfxUrVjR8DG9vb5PXjx8/NnyM+OzZs0c1atTQq6++qoULF+r777/X4cOHEx0vIiJCAwcONCuvXr16nP2e/7mlI0eOxDvW83kWKlTIhgz/Va5cOQ0fPtykbPPmzfr6669tjgHAPuw5/zrKnOdImH8B4zjSvQdHmu+4TjWeu7u72dcaHh6udu3amRwnCTF//nyNHDlS9evXV86cOdWzZ0+dPXs23n6OcE0DOLu0cv/BUSR1/8veF0g90sL9B0fZi3PvAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQHDw8PJQpU6bYfwEBASmdEgAAAAAAAAAAAAA4DPeUTgAAgORQtGhRi+U3b95UWFiYXcd++vSpRowYoQkTJmj+/Pn63//+pz179th1TAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANhm0qRJun79uubOnav06dPH2z5Pnjzavn27QkJCtHv37mTIEAAAlCpVSsuXL1eOHDls7rNz5041btxY169ft2NmAAAAAAAAMJq7u7tGjhyp7t27a/DgwRowYIBN/by8vPTDDz/E2eb69es6ceKEEWkCqVaxYsVMXt+8eVO7du0yJPaRI0c0ffp0vfbaaxozZoxmzpypJ0+exNlnx44datSokfLnz6+PP/5YJ06c0P3795OUx5o1a1SoUCGTsvz58+vWrVtW++TKlcvk9d27d7Vt27Yk5fHbb7/p6dOncnd3jy3LnTt3kmIapW/fvqpdu3bs68jISLVo0UK3b99ONbk0btxYmTJlMik7ePCgpk6dmqS4P/74o7p27ap8+fLFlhUuXFgVKlTQzp07kxQbcFTdu3dXkyZNYl9Pnz5dO3bsMHQMHx8fk9ePHz82NH5C/PHHH2rRooUhsVauXGlWVqRIkTj7ZMyY0eT1tWvX4h3n+Tbp0qWTl5dXvO9jQECA5s+fLw8Pj9iy69evq3Xr1oqOjo53XAD2lRzzb0rPeY6E+RcwjqPde5AcY77jOtV49erVU/bs2U3K/ve//+nChQtJiturV68E93GkaxrAWaW1+w8pLan7X/a+QOqRFu4/OMpenHsPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQMpyTekEAABIDs8/NOuZpD701VazZs1Szpw51aFDB+3ZsydZxgQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBtli5dqjp16ujOnTs2tQ8KCtKGDRtUt25d+yYGAADUpEkTbdmyRTly5LC5z7x58/T666/r+vXrdswMAAAAAAAARsuZM6e2bt2q7t27S5K++OILjR8/Xj4+PnH2y507t9avX6/ChQvH2W7evHmG5QqkVoGBgSavL168aGj8Tz/9VEWKFNGkSZP05MkTm/udOnVK3bt317hx45Kcg6Wvyd/fP84+WbNmNYsRExOTpDwiIiJ09epVk7Js2bIlKaYRqlSpokGDBpmU9enTR2FhYakql7feesus7NtvvzXkcx0zZoxN4wGw3fP7wcePH6dQJsa6d++e7t27Z1L2/Fr8vMS8F5GRkYqOjjYp8/X1jbff9OnTlSdPntjXMTExateunS5fvhxvXwB4XmLmPEfC/AsYx1HvPRglsfMd16nGe+ONN8zKfvzxxxTIJPVe0wCpDefq/zFi/8veF0BKSMx+3FH24tx7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFKWe0onAABAcrD2sKubN28my/hPnz7V9evXk2Us/MvX11e5cuWSn5+ffH19FR0dHfvgt3PnzqXIg6ATysPDQ/ny5VNAQIB8fX3l6uqqx48f6+bNmzp79qxDPYTUx8dHuXLlkr+/v3x9fRUZGan79+/rxo0bOnfuXEqnl2wyZcqkjBkzKiAgQH5+fnJ1ddXDhw917949Xb9+XVeuXEnR/HLkyKFMmTLJ19dX3t7eiomJ0d27d3Xr1i3dvn1bt27dSvJDDR1Zrly5lDFjRvn7+yt9+vR69OiR7t+/r+vXr+vSpUspnZ4kxz+G7M3Hx0c5c+aMnbtdXV11//593b17VxcuXNCDBw9SOkVJrDEwBp9B8nGG+f8Zb29v5cmTR/7+/vLx8VFERITu3buny5cvp/o14HnOvG9xpvObYw7ONEc6E2eaByTn2YenBGc5R5xl3XSma15n+ewl1nPJuY6t1MDNzU358uVTYGCg/Pz8JEn37t3T3bt3dfbsWUVERKRwhnFz9vxhG2dZGx0V71/SOft76OLionz58ikoKIi5EgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGnSli1bVKVKFa1Zs0bZs2ePt723t7dCQ0PVpUsXzZo1KxkyBAAg7enZs6dGjBghV1dXm9rHxMRo8ODB+vLLL+2cGQAAAAAAAIxWq1YtzZkzR5kyZTIpf//999W6dWuFhoZqz549unz5sh4/fiwvLy9ly5ZNVapUUaNGjeTp6Rln/KdPn2rkyJH2/BKAVMHez1189OiRXePbIioqKsF93N3dTV6Hh4cbksvzcZ4fJ7llzpxZ8+bNk5ubW2zZ8uXLNXr06FSVi6urq1577TWTsvDwcIWGhiY5tiQtXLhQ33//vcn3N6pWrWpIbCCt8vHxMXntCOuJUZ48eRL7PGFJ8vDwSFB/W9fu6Ohom7/vKkndu3dX48aNTcpGjBihtWvXJig/APivpM55joT5F0i8tHDvIaHzHdep9lGzZk2T13/88YcuXLiQIrmk5msaIDXhXLXOHvtf9r4A7CUh+3FH3otz7wEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABIXu4pnQAAAMkhMjLSYnm6dOmSORPbBAcHq1SpUnG2yZQpk8XyggULqkWLFgke89ChQzp27Fi87cqXL6/cuXOblS9fvlyPHz+22u+ll15S6dKlVaRIEQUGBsrPz8/koWsbNmzQpEmTEpz3MwEBAWrYsKEaN26s0qVLK2/evFbbRkdH6+TJk9q9e7eWLl2q1atX2+WBnol5r0qWLKk2bdqodu3aKlKkiNVjNCYmRidOnNDGjRu1YMECbdq0ycjU45UuXTrVrVtXzZs3V/ny5ZU/f365uLhYbPvo0SMdOnRIq1at0uLFi3XkyBGL7bJkyaJixYqZlZ88eTLFHtIcn1y5cqlNmzaqXLmyypQpo6xZs8bZ/s6dOzpy5Ih+//13hYaG6o8//rBrfqVKlVKTJk1UvXp1FStWTP7+/nG2v3fvnrZv364tW7Zo5cqVOnTokF3zs7cSJUrozTffVI0aNVS8eHH5+vpabXvnzh0dPHhQv/32m5YsWaITJ04kS46OfgzZW6ZMmdSwYUM1aNBApUqVUp48eazOJTExMfr777+1c+dOzZ8/X2vWrFFUVFSy5MkasylROca3n0mJvYy19+2ff/7R9u3bEzSeM3wG1mTMmFE1a9a0WBffni4xgoKCVKNGDYt1y5YtU3h4uKHjOcP8/4ynp6fq1q2rN954QxUqVIhzT3Xr1i3t2rVLv/76qxYtWqS7d+8ma6725kj7Fmc+v+OT2o+5KlWqKFu2bGblERERWrp0qWHj1K1b1+SB4pL0+PFjLV++3LAx3njjDbm5uZmVb926VZcvX050XGeaIxOKdd52jrAPd9T7S85yjjjSuhkXZ7rmdZbPXkr967ktHOHYcubrqsTMwcWLF1fLli1Vr149FS1aVJ6enhbbPX36VMePH9eWLVu0aNEibd68WdHR0TbnlhbyT6xixYqpSJEiFuvWr1+vW7du2W3sF198Ua+++qpZeUxMjBYuXGi3cRMisWtj7969E70uxvWZ/Prrr3r69Gmi4tqiatWqFue+06dPa+/evQmO52h7CyP39snF0d7DxMiXL59atmypRo0a6eWXX5aXl5fFdik516f0MZDYvJL7e//P3ytnDQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEicQ4cOqUKFClq7dq1eeumleNt7eHjol19+UZYsWTR69OhkyBAAgLTB3d1d48eP19tvv21zn/DwcL311luaPXu2HTMDAAAAAACAPXzxxRcaOHCgXF1dLdb7+/urffv2at++faLHmDFjhs6fP5/o/kBa8fyz7rJly5ZCmdhPlixZzMriew70/fv3lTlz5tjXQUFBhuTy/HMN7927Z0jcxHBxcdGsWbOUPXv22LLz58+rQ4cOqS6XQoUKydvb26Ts999/1/379w2Jf+XKFYWFhalChQqxZcHBwQoICNCdO3cMGQNIa54/Z41+pnxKCgwMNHmd0LXAxcXFpnbW9tqWlClTRt99951J2fbt2/XFF18kKDcAeF5S5zxHwvwLJF5auPeQ0PmO61Tj5cyZUy+88IJJ2YoVK1Iom9R9TQOkJpyr1hm9/2XvC8CeErIfd+S9OPceAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKQGGzdutFj++uuvJ3MmAKzhPAUAAHFJ63sFo75+S3HSynsIAAAAAEByS+v3MwAAAJB07imdAAAAyeHmzZsWyzNlypTMmdimdu3aGjt2bKL61qtXT/Xq1Utwv44dO+rYsWPxtuvevbtatWplVp4nTx6dP3/epMzX11cfffSRunTpouDg4DjjPnjwQJMmTUpY0pIKFCigPn36qF27dkqXLp1NfVxdXVWwYEEVLFhQ7du318OHDzVhwgSNHDlSly9fTnAO1iTkvSpVqpS+++47Va9e3abYLi4uKlSokAoVKqQPPvhAR48e1RdffKElS5YYkrs1Xl5e+vjjj/X5558rY8aMNvXJkCGDypUrp3LlymngwIFavXq1BgwYoL1795q0q1atmubPn2/Wv0ePHho9erQh+RulUqVK+vLLL1WzZs0EPVwvICBAlSpViu1/7Ngxfffdd5o1a5YiIyMNyc3V1VUtW7ZUv379VKxYsQT19fPzi51Dhg0bprVr12r48OFWb0Q7qjfeeENffPGFXn75ZZv7BAQEqEqVKqpSpYqGDRum33//Xd988402b95slxwd+RhKDiVLllSfPn3UvHlzubm52dTHxcVFBQoUUIECBdShQwddvXpVgwYN0sSJE/X06VNZQSlcAAEZFElEQVS75Mkak7Q1JrH7GXvuZay9b0uXLtX27dsTNJ4zfAbWBAcHW1xzJcv5J1XBggWtjpc1a1Zdu3bNkHGcYf5/xs/PT926ddOnn36qoKAgm/pkzJhRISEhCgkJ0ejRozV27FgNGTJEDx8+tGuu9uSo+xZnPr+tSSvHXPXq1fXVV19ZrHvxxRd15syZJI/h6+ur0NBQeXh4mJTHxMQoR44cunLlSpLHKFKkiBYtWmRWHh0drezZsycqpjPNkYnFOh8/R9qHO9r9JWc4Rxx13bTEma55neGzfyatrOdxcaRjy5mvqxIyB7/66qsaMmSIateubVNsd3d3FStWTMWKFVPXrl119uxZDRs2TNOmTTPsPHb2/BMrY8aMVo+B3r1769tvv7Xb2N98843atGljVr5hwwYtXLjQbuPGx6i1MbHrYlyfSZMmTbRs2bIExbOVl5eXli9fLl9fX7O6Fi1amH3vxRpH3lsYube3J0d+DxMif/78Gjx4sFq0aGHT+pqSc31KHwOJzSu5v/f//L1y1hAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDEO3funCpVqqRVq1apTJky8bZ3cXHRqFGjlCNHDvXs2TMZMgQAIHULCAjQokWLVKNGDZv73LhxQ02aNHGov20OAAAAAAAA2/n7+yfouaUJdfToUX388cd2iw+kJpcvXzZ5nTVrVhUsWFAnTpxIoYyMV65cObOyK1euxNnn5MmTevHFF2Nf58qVS1myZEnQM4afFxwcLD8/P5Oyv/76K9Hxkqpv374mzwSOjIxUixYtdOfOnVSXy6uvvmpWtm/fPkNiP/Pnn3+qQoUKJmWlSpXShg0bDB0HSCt8fHxMXj9+/DiFMjFWkSJF5OHhYVJ28uTJOPs8fPjQ5LWXl1e843h4eJjttx88eGCxrb+/vxYsWGCS182bN9WyZUtFRUXFOxYAWJOYOc+RMP8Cxknt9x4SM99xnWq8YsWKmZUdOHAgBTL5V2q9pgFSG87V/2PE/pe9L4CUkND9uCPtxbn3AAAAAAAAAAAAAAAAAAAAAAAAAAAAYCp//vwqUKCA/P395e/vL19fX7m6uurBgwe6d++e7t69qwsXLujo0aOKjIxM6XQBWFGtWrWUTgFAPJztPE2XLp3F8oiIiGTOBACAtMHZ9grPGLVnMOrrNyIO+6C0h88cQGrCnAYAAJKTM97PYL8EAADgWFzjbwIAgPO7ceOGxfLg4GCzBzumVUeOHDE0Xq1atXT06FENHTpUwcHBhsaWpPTp02vUqFE6fvy4unTpYvWmky28vb312Wef6cyZM+rdu7fZw9LsycXFRV9++aX27Nmj6tWrJzpOkSJF9Ouvvyo0NFQZM2Y0MMP/8/rrr+vkyZMaPnx4ksaoW7eudu3apSFDhsjNzc3ADO0vICBAkydP1tatW1W7du0kHyuFCxfW1KlTdejQIVWsWDHJ+RUrVkx79+7VnDlzLD7wOqFq166tDRs26JdfflH69OmTHM/eChUqpN27d2vRokV6+eWXkxSrRo0a2rRpk+bOnavAwEBjEpTjH0P2FhgYqBkzZmj//v1q1apVkuaArFmzauzYsTp06JCKFy9uYJasMc9LjjXGCEbvZYyQ1j6DlOIM8/9/NWrUSH/99ZcGDx6soKCgRMXw8/NT3759deTIEVWpUsXgDJOHs+9bnOn8TkvH3IIFC6zWNW7c2JAx6tSpY/ZAcenfYyIkJMSQMazlumXLFl27di1BsZxtjnQmzjQPOMs+3BJ7319ylnPEWdZNZ7rmdZbP/pm0tJ5b4kzHVmrh5uamIUOGKCwsTLVr1050nLx582rChAk6cOCASpUqZWCGcXP2/C3ZsmWL/vrrL4t1nTp1stu4GTJksLo/nTp1qt3GjY+Ra2Ni18UtW7boxIkTFus6d+6cpJzi0qxZM/n6+pqV37hxQ0uXLrUphrPsLRxZankPP/74Yx06dEitWrVK9PrqSHMl/vX8vXLWEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgKS5ceOGXn/9da1du9bmPj169NAvv/wid3d3O2YGAEDq9uKLL2rnzp2qUaOGzX2OHz+ucuXKafv27XbMDAAAAAAAAPbUr18/rV+/3i6xb9y4oWbNmunRo0d2iQ+kNlu2bDEr69OnTwpkYh958+ZV1apVTcquX7+uCxcuxNlvw4YNJq9dXV319ttvJymXd999N95xkkuVKlU0aNAgk7LevXsrLCwsVeZSvHhxs7JDhw4ZFl+SDh48aFZWtGhRQ8cA0hIfHx+T148fP06hTIxl6Tmz8e2Lb926ZfI6S5Ys8Y7zfJuIiAir++Np06Ypb968sa9jYmLUoUMH/fPPP/GOAwBxScyc50iYfwHjpPZ7D4mZ77hONV6BAgXMyo4dOxZnHw8PD2XNmlX58uVTzpw55efnZ1g+qfWaBkhtOFf/T1L3v+x9AaSUhO7HHWkvzr0HAAAAAAAAAAAAAAAAAAAAAAAAAACQ1hUrVkyDBw/Wtm3bdP/+ff3999/67bffNG/ePE2YMEEjR47Ut99+q3HjxmnWrFlavny59u/fr4cPH2r//v36+eefVb16dbm6uqb0lwIAAOzkpZdeUnh4uMV/L730UkqnBwAOy9XVVQULFlSjRo30zjvvqEWLFib1QUFBatmypSpUqKAcOXKkUJbmfH19Vb58ebVp00bvv/++evXqpS+//FL9+vVT9+7d1bFjR7322mvKmjVrSqcaKyAgQBUqVFDbtm318ccfq2/fvvryyy/Vt29fffzxx2rbtq0qVKiggICAlE41VUuNe4bU+DUhbnzmAFIT5jQkxaeffqovv/zS5F9K+Pjjj83y+PLLL1WkSJEUyQcAkLqwXwIAAHA8/CQqACBNOHHihMVyDw8PNWjQIJmzcTwxMTHxPgg3Idq0aaPffvtNOXPmNCzmfxUsWFAHDx7UZ599Zugv1nh6emr48OHatWuXsmXLZlhca9zd3bVo0SINHDjQsK+jYcOGCgsLM3mImxEGDBig9evX64UXXjAknpubm/r166cFCxbIw8PDkJj2FhwcrL179+qtt96Si4uLobELFiyobdu2qW/fvomO0alTJ/3xxx965ZVXDMzsX+3bt9eOHTsM+/ztoUuXLvrzzz9VpkwZQ+O2atVKhw4dUrFixZIcy9GPIXurVKmSjh49qg4dOhgat1ChQgoLC1OrVq0MiccaY5291hgjGL2XMUJa+wxSijPM///1ww8/aNmyZYb9UkCePHm0fv16iw84dmTOvm9xpvM7rR1zR48etboeNGnSxJAxGjVqZLWuYcOGhozRtGlTi+ULFy5MUBxnmyOdiTPNA86yD7fE3veXnOUccZZ105mueZ3ls38mra3nz3OmYyu1SJ8+vVasWKF+/foZts4VLlxYYWFhevvttw2JFxdnzz8ukyZNslheuHBhw+e0Z5o0aSJvb2+z8nv37unXX3+1y5jxsdfamJh10dpnUr9+fWXOnNmo1Ex07tzZYvmMGTMUGRkZb39n2Vs4stTwHrq5uWnKlCn64Ycf5OXlZUhMR5kr0zpr98pZQwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJLm4cOHql+/vmbOnGlzn/bt2ys0NFQZMmSwY2YAAKROr732msLCwlSoUCGb+6xdu1blypXT6dOn7ZgZAAAAAAAA7C0yMlKNGzdWaGiooXEPHDig0qVL68SJE4bGBVKzNWvWKCIiwqSsU6dOevfdd1MoI2ONHj3a7Pm3q1atirffnDlzzJ4h2r9/f7388suJyqNixYr65JNPTMru37+vRYsWJSpeUmTKlElz586Vm5tbbFloaKjGjBmTanMJDAw0K/v7778NHcNSPEvjArCNj4+PyevHjx+nUCbGefXVV9W9e3eTsvPnz+u3336Ls99ff/1l8rpo0aLxjlWsWDGT1ydPnrTYrlu3bmratKlJ2ahRo2xaKwEgLomd8xwJ8y9gnNR87yGx8x3XqcbLkSOHWdnz74Gbm5uaNGmiadOm6eTJk3ry5ImuXLmi06dP68KFC7p7965u376tzZs3q0+fPnrxxRcTnU9qvKYBUiPO1f+T1P0ve18AKSEx+3FH2otz7wEAAAAAAAAAAAAAAAAAAAAAAAAAAKRF7u7u+uCDD3Ts2DEdOnRI/fv3V6VKlcz+BkBcPDw8VLJkSb333nv6/fffdfnyZX377bcKCgqyY+YAAAAA4NiCg4PVt29fbdq0SY8ePdLx48e1bNkyTZw4UR07djRpmz17ds2bN087duzQP//8o3/++Ufz5s1Tly5d5Ovrm2w5u7m5qUaNGho7dqzOnDmje/fuaefOnZo9e7bGjx+vb7/9VgMHDtSQIUP0/fffa/r06dqyZYuuXLmiv//+Wz///LMqVaqUbPk+U7x4cX333Xc6ePCgbt26pR07dmjWrFn64YcfNHToUA0cOFBDhw7VDz/8oFmzZmnHjh26deuWDh48qG+//dbsbwkBAAAA+FepUqU0evRoDRw40OSft7d3sufy6aefmuUxcOBA9vMAAAAAAKRSrimdAAAAyeH333+3WvfVV1/Jw8MjGbNxPGfPntWjR48MiVWrVi3NnDlTbm5uhsR7Xvny5bVjxw4VKFDALvElqUyZMgoLC1OhQoXsNoYkzZkzR82aNTM8bnBwsDZs2KAsWbIYEm/06NEaNGiQXF2N3zo2a9ZM06dPNzyu0XLkyKGNGzcqf/78dhvDxcVFQ4cO1ciRIxPc9+OPP9bUqVOVLl06O2T2r1deeUWhoaHy9PS02xiJ9fnnn2vKlClKnz69XeK/8MIL2rp1q8qVK5foGI5+DNlbkyZNtH79emXLls0u8b28vDR79my1bt06SXFYY+Jn9BpjFCP3MkZJa59BSnCG+f8ZFxcXzZo1Sx9//LEBmZny8PDQ1KlT1bZtW8Nj20Nq2Lc4w/mdlo+5hQsXWiyvXLmyMmbMmKTYLi4uCgkJsVpfq1atJB/b2bNn16uvvmpWHh0drV9//dXmOM40RzojZ5gHJOfZh1ti7/tLznKOOMu66UzXvM7y2Utpez1/xpmOrdTCzc1NK1asUN26dQ2P7e7urkmTJqlnz56Gx37G2fOPz/Tp0xUZGWmxrlOnTnYZs127dhbL58+fr8ePH9tlzLjYe21M6Lo4Y8YMRUREmJW7u7vbZY7NlSuXqlevbrFu0qRJ8fZ3lr2FI0st7+HEiRPVpUsXw+M6wlyZ1lm7V84aAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkHRPnz5Vhw4dNGrUKJv71KtXTxs2bEjyMzMAAEhLOnbsqPXr1ytTpkw29/n5558VEhKie/fu2TEzAAAAAAAAJJdHjx6pcePG+uCDD3Tjxo0kxbp//76GDRumChUq6Pz58wZlCKQNV65c0cyZM83KJ0yYoClTptjt+enJ4fPPP1fTpk3NysePHx9v34sXL2rChAkmZRkyZND69esVEhKSoDyaNm2q3377TR4eHiblI0eO1J07dxIUK6lcXFw0e/Zs5ciRI7bs3Llz6tixY7Lmkdy5+Pv7m5XdvXvX0DEsff8iICDA0DGAtMTb29vk9X+fk5o7d261aNFCX3/9tSZNmqR58+ZpyZIlmjNnjiZMmKDPP/9c9evXl6+vb3KnbVW9evW0Zs0as2cmf/7554qKioqz75YtW0xeN2jQIN7x6tevb/J627ZtZm1Kly6tkSNHmpTt2rVLffv2jTc+AMQlKXOeI2H+BYyTWu89JGW+4zrVeJkzZzZ5/fjxYz19+jT2dYcOHXTmzBktWbJEnTp1UnBwsFxdXc3iBAQEqEqVKho2bJhOnjypBQsWKE+ePAnOJ7Vd0wCpFefq/0nq/pe9L4Dkltj9uCPtxbn3AAAAAAAAAAAAAAAAAAAAAAAAAAAA0pp27drp5MmTGjdunAoVKmRY3CxZsqhXr146c+aMvv76a3l5eRkWGwAAAAAcXe3atbVx40adPHlSQ4cOVdWqVeXp6ZmgGDly5FDLli01ZcoUXblyRdOnT9eLL75op4wlNzc3de7cWSdPntT69evVtWtX5c2bN0Ex8ufPr/fee0/btm3TwYMHbfobPklVtWpVbd68WQcPHlTPnj1VvHhxubi42NTXxcVFxYsXV69evXTo0CFt3LhRr732mp0zBgAAAJzLe++9Z7G8devWyZwJAAAAAABIa9xTOgEAAJLDoUOHdOXKFYsPEi5UqJCmT5+udu3aKSYmJgWyM/fw4UNdvHgxzjZZsmQxe5CZJD148EB37txJ0HiWHgiWGNmyZdPcuXMtPjTXCIULF9aaNWvk5+cXZ7vz589rxYoV2rlzpy5fvqzr16/L3d1dWbJkUY4cOVS1alXVq1fP7IHA/5U7d279/vvvKlOmjC5dumT0l6KePXuqefPmFusuXryopUuXateuXTp79qzu3bsnDw8PZcqUSblz51bNmjVVp06dOB/WnC9fPs2dO1c1atRIUp69e/fWp59+Gm+7gwcPavny5Tp06JCuXbumGzduxL7n2bJlU6VKldSgQQNlz57drG+bNm20ZcsW3b59O0m52tOcOXOUM2dOq/VXr17V4sWLtWHDBh0+fFjXrl3TgwcPFB0dLS8vLwUEBCg4OFilS5dW/fr1Va1aNas/gNejRw8dOnRIM2bMsDm/77//Ps4f6Nu3b1/sMXXixAndvn1bjx49koeHhzJmzKjs2bOrcuXKatiwYZzHTKlSpTR27Fi9/fbbNudmb++8845GjBgRZ5tn59Tq1av1119/xX4+fn5+ypQpk1566SXVqFFDTZo0Ub58+SzGCAgIUGhoqF599VVduHAhwXk6+jFkT9WrV9fChQvl7h735efZs2e1atUq7dq1S1euXNH169f19OlT+fr6KkeOHCpTpoyaNm2ql156yWJ/V1dXzZw5U+fOndOOHTsSnCdrjPFrTHz7GUfcyxjFUT6D1MxZ5v9nhg8frrZt28bb7vDhw1q1apX27dunq1ev6ubNm3J1dZW/v78KFCig8uXLq1GjRsqSJYtJPxcXF02bNk1//fVXonNMDvXr13f6fYuznN9p+ZhbsGCBvvzyS7NyNzc31a9fXzNnzkx07AoVKigoKMhqvbe3t6pVq6a1a9cmeoxGjRpZPEe2b9+uK1eu2BTD2eZIZ+Ms84Cz7MMtsff9JWc5R5xp3XSWa15n+eyfScvr+TPOcmylJmPGjLE6X5w4cUIrVqzQ3r17df78ed2/f19ubm7KnDmzsmXLpsqVK6tevXrKlStXnGN89913Onv2rBYtWkT+CXTjxg0tW7ZMb775plld69at9emnnyoiIsKw8TJlyqRatWpZrJs6daph49gqudbGhKyLzz4TS/vDLl266Pvvv7f567NF+/btLX79W7du1YkTJ+Ls60x7C0eVWt7Dbt26qUuXLhbrUsNc6YiS83v/1u6Vp/U1BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEg9e/bUpUuXNHLkyDj/Xukz5cqV044dO1SnTh2dO3cuGTIEAMB5DR06VH379rW5fVRUlHr27Gn434YHAAAAAMCebty4oVmzZlmtf/ToUTJmAzi2n3/+WbNmzVKrVq3Utm1bVahQQZ6envH2Cw8P165du7R69Wr9/PPPCXoeGABTffv2Vd26dfXCCy+YlHfp0kXt27fXmjVrtG7dOoWFhenQoUMplKXtXFxcNHDgQA0YMMCsbt68eQoLC7MpTu/evVWzZk0VKlQotiwoKEgrV67UunXrNGXKFG3dulWXLl0y65szZ0699tprevvtt1W9enWz+j179mjo0KEJ+KqM0bdvX9WuXTv2dWRkpFq0aJEic2hy5uLv729Wdv/+fUPHsBTP0rgAbOPt7W3yOkOGDOrdu7c6duyowoUL2xTj6dOnWr9+vf73v/9p1apV9kjTKldXV+XOnVsVK1ZUp06dLD4DdtKkSZo/f368sX799Vf98MMPSp8+vSSpSpUqqly5stVn3GbLlk2dO3c2KXv++tTPz08LFiwwedbu7du31bJlSz19+jTenADgv4yc8xwJ8y9grNRw78HI+Y7rVOM9fw3x4MEDSf/OvXPnzlVISEiCY7q6uqp58+YKCQnRhx9+qBkzZiQ6n6Rc09SrVy9BeQOwnbPffzBSUve/7H0B2JtR+3FH2otz7wEAAAAAAAAAAAAAAAAAAAAAAAAAAKQVgYGBmjZtmho3bmzXcXx9ffXVV1+pefPmatmypQ4fPmzX8dKySpUq6YsvvjAr37p1a4r8zV3AUXBuAACA5JQ3b15NnjxZNWrUMDRuhgwZ1LFjR7Vp00bjxo1Tv379DH3WVuHChTV//nwVL17csJjFixfX8uXLtXz5cnXu3Fk3b940LLYkBQQE6H//+5/atWtnWMxq1appy5YtmjZtmj755BPdu3fPsNgAAACAM/Lx8VGbNm0s1n3wwQeaPHlyMmcEAEgsvmcGAAAAZ+Se0gkAAJBcxowZoxEjRlisa9OmjbJly6YOHTron3/+SebMzM2YMSPeB8nu3LlT5cuXNyufPHmyPv30U3ulFqfvvvtOQUFBFusOHDigFStWKCwsTFevXtWNGzdMHi727GG81mTMmFErV66Un5+f1Tb79+9X7969tXbt2jhjTZ06VS4uLmrZsqWGDh2qfPnyWWyXI0cOLV++XBUrVlR4eHicMROiYMGCFm8YHj16VF988YWWLFkSZ//JkyfL29tbvXr1Uq9evZQhQwaL7apXr64uXbpo6tSpicqzevXqGjJkSJxtli9frl69eunEiRNxtnt2PDds2FCjR49WcHCwSf23336rfv36JSpPe3vzzTdVtWpVi3VPnjzRgAED9OOPPyoiIsJimwcPHujBgwe6ePGiNm3apFGjRumll17SiBEj1KRJE4t9xo0bpw0bNujChQvx5pctWza5uLhYrNu9e7c+/fRT7dixw2J9VFSULl26pEuXLumPP/7QDz/8oHLlymnixIkqUaKExT5vvfWWpkyZop07d8abm72VK1dOP/30k9X6a9euaeDAgZo4caLFhxnevn1bt2/f1smTJ7Vy5Ur16tVLbdu21bBhw5QjRw6z9lmyZNHixYtVrlw5xcTE2Jynox9D9pQ/f34tWrRI7u7WLz137typPn36aMuWLXHGWrx4sfr06aO6devq+++/V8GCBc3auLm5ac6cOSpRokSCfjiVNeb/GLnGxLefccS9jBEc6TNIrZxl/n+mWbNm+vzzz+Nss2rVKvXr108HDhyw2mbLli2aMmWK3nvvPbVq1UqDBg1S/vz5Y+s9PDz0yy+/yNPTM8E5Jods2bJp5syZTr1vcZbzO60fc0eOHNHx48dVqFAhs7qmTZtq5syZiY7dqFGjeNs0bNgw3v1CXJo2bWqxfMGCBTb1d7Y50tk4yzzgLPtwa+x5f8lZzhFnWjed5ZrXWT77Z9L6ei45z7GVmlSrVk3dunUzK//999/19ddfa9u2bXH2f7bPCgkJ0dChQ1WyZEmrbadPn66DBw/qr7/+SlrS/+Hs+dtq4sSJevPNN83KAwMD1aBBA/3666+GjdWiRQuL+4kTJ05o165dho1jC3utjda+joSsixMnTlTz5s3NyosXL65XXnlFf/75Z7wxbNW5c2erOcTFmfYWjiq1vId58+bV8OHDzcpT21zpaBzle/9pdQ0BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwh9GjR+vatWuaOnWqPDw84m1fsGBB7dy5U3Xq1NGhQ4eSIUMAAJxL+vTpNXPmTIt/S9maBw8eqHXr1lqxYoUdMwMAAAAAwHinT59W+/btUzoNwGk8ePBAkydP1uTJk+Xp6alChQopf/78CgoKkre3t9KlS6enT5/q1q1bunnzpq5du6b9+/crPDw8pVMHUoXr16+rSZMmWr16tdmzxz08PNSgQQM1aNBAksye5VyrVi3dv39fx48f1+3bt5MtZ2uCg4M1ceJEvf7662Z1J0+e1IcffmhzrEePHqlWrVpat26dChUqZFJXq1Yt1apVS5J09+5d3b59W48ePZK3t7cCAwPl5+dnNe6ff/6pkJAQi8/ZtqcqVapo0KBBJmW9evXS7t27kzWPlMjFx8fHrOzRo0eGjvHgwQOzMl9fX0PHANIKLy8vubq6mpTNmjXL6nOHrXF3d1fdunVVt25dbd26Ve+9956OHTtmWJ7z5s1TnTp1zMrd3Nzk4+MTZ77jxo3TRx99ZNM4N27c0JQpU0zWsAULFqhhw4b6448/TNrmzp1bS5YsMZn3du7cafZM46lTp+rFF180KevUqZPOnz9vU04A0p7kmvMcCfMvYCxnufeQXPMd16nGS5cuncnrhw8fysfHR+vXr1eZMmUs9rl7967u3r2r9OnTKygoSG5ubhbbeXt7a/r06cqVK5cGDx4cby5GX9Ns2bLF8OsZAM5z/yG5JHX/y94XgBGSYz/uSHtx7j0AAAAAAAAAAAAAAAAAAAAAAAAAAIC0oFSpUlq2bJly5syZbGMWKVJEe/bs0Xvvvadffvkl2cZNS7Jmzaq6deualVv6XVsgLeHcAAAAyaVZs2aaPn26Xf/OpIeHh7p3765atWrpjTfe0PHjx5Mcs0WLFpo+fbq8vLwMyNBcw4YNtW/fPtWoUUN///23ITFfeuklrVq1Svnz5zck3vM6d+6sihUrql69ejpz5oxdxgAAAACcQZs2bSz+3VDp3+83lS5d2uzvdQIAHBPfMwMAAIAzck/pBAAAKcPLT8rzihSUS/Lyl6IipUd3pMsnpItHpOinKZ2h8caOHatevXopU6ZMFuurV6+uU6dOafLkyZo4caIOHjyYzBk6t5IlS6pt27Zm5Zs2bVKvXr20d+/eJMX//vvvlS9fPot10dHR6tu3r7799lub48XExGjevHlavHixRo0apW7dullsV6pUKX311Vfq169fovK2ZOjQofLw8DApGz16tPr06aPIyEibYjx8+FBff/21Vq5cqd9++83sodnPDBw4UL/88ouePk3YSe3p6akpU6ZYfeDxo0eP1Lp1a4WGhiYo7vLly7V69WqNHj3a5OF7fn5+6t27d4JiJZdPP/3UYvnDhw9Vs2ZN7dq1K8Ex//rrLzVt2lTvvPOOxo8fb/Y+Z8iQQf3799f7778fb6yvv/7aYvmoUaP0+eefKzo6OkG5hYWFqVKlSlq2bJmqV69usU3v3r3VpEmTBMU1mpubm6ZOnWr2YO9n/vjjDzVq1EiXLl2yOWZUVJR++eUXrVmzRkuWLFGFChXM2pQpU0Zdu3bV2LFjbY7r6MeQPU2ePFmBgYEW6yIjI9W1a1dNnjw5QTFXr16tUqVKacaMGXrzzTfN6vPkyaPevXurf//+NsdkjTFl7zUmteMzsC9nmv+lfx8k/NNPP1mtf/Dggdq3b6+lS5faHDM6Olpz5szRkiVL9L///U9vvfVWbF2hQoUSlF9y+vrrr62uCc6yb3GG85tj7l8LFy7UgAEDzMpr164tT09PhYeHJypugwYN4m3TsGFDq2t/fHx8fPT666+blcfExOjXX3+Nt7+zzZHOyBnmAcl59uGW2PP+kjOdI860bjrDNa8zffYS6/kzznBspTbP3/tI7JqxatUqrVq1Sv3799c333wjFxcXszbe3t4aO3asatWqlaSc/8vZ87fVunXrdPbsWeXNm9esrnPnzjbtG23Vrl07i+VTp041bAxb2Wtt3LBhQ5LXxfXr1+vMmTMW7y927txZf/75Z4LysqZixYoKDg42K79z544WLVoUZ19n2ls4qtTyHr788ssmr1PrXAnL0uoaAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYC+zZs3SjRs3tGjRInl7e8fbPnv27NqyZYsaN26sLVu2JEOGAAA4h6xZsyo0NFRly5a1uc/FixfVoEEDHThwwI6ZAQAAAAAAwNGEh4frwIED3BcCktnevXtVtmxZzZ8/X6+++qrVds8/27Bnz57q2bOnJOncuXPavXu3Nm/erAULFuj69et2zfm/MmfOrH79+unDDz80e069JJ09e1Z169bVrVu3EhT34sWLevXVVzVkyBB98MEHFp+h7e/vL39//3hjPXnyRD/88IO++uorhYeHJyiPpMqUKZPmzp1r8rznZcuW6YcffkjWPFIqF0vP5EzoM0rjYymepXEBR1WqVCkNGTLE5rb/VatWLf3222829f3kk0904sSJONv4+PiYlSX1fHrttde0Z88edejQwbDnu3p7eysgICBBfS5cuKCuXbtqxYoVCerXu3dv1a5dWwUKFJD0788o7d69W9u2bdORI0f09OlT5c+fXzVq1JCnp2dsvwcPHqhjx44msbp27ao33njDpOz7779XaGioSVmmTJnUrFkz1apVSy+88IICAgJ0584dXbx4UevWrdOSJUt048aNBH0dAMw50vwbl+Sc8xwJ8y9gLGe495Bc8x3XqcZzdXU1eR0VFaXJkyerTJkysWUPHz7U5MmTtWzZMu3cuVNPnjwx6VOoUCHVqlVLXbt2VaFChczG+Oabb/TPP/9o2rRpceZi9DWNPa5ngJTiSPtfZ7n/kJySsv/9L/a+gONxpPk3LsmxH3e0vTj3HgAAAAAAAAAAAAAAAAAAAAAAAAAAQGpWtmxZrV27Nt6/2xoVFaVt27Zp8+bNOnDggE6fPq3bt2/r0aNHio6OlpeXl/z8/JQ7d24VLlxYlStXVs2aNeXn52c1Zvr06TV9+nR5eXlpwoQJRn9pAAAAAJBi3nnnHf38889mf4fRkidPnujSpUuKjIxUwYIFY8vDw8P18OFDZcyYMd4YRYoU0e7du1W7dm3t2rUr0Xk3a9ZMc+bMMXlOhTUPHjzQ+fPndf/+fT158kReXl4KDAxU7ty5Tf4WjyW5c+fW1q1bVbZsWV24cCHR+UpS0aJFtWXLFpveJ0l6+vSp7t27p4iICKVLl05+fn5yd3ePt1/BggW1a9cuVapUSX///XeScgYAAACc1fvvvx9v/TvvvJNM2QAAAAAAgLQm/u/qAQBSlYy5pMrtpYKVJRcrP4MT/lDau1Tas1iKeJSs6dnVw4cP1aVLFy1btszqg7U8PT314Ycf6sMPP9Rff/2lb775Rvv27dPJkycVGRmZzBk7l27dupm8r0+fPtVHH31kyC+2VK9eXe3bt7dY9+TJE7Vs2dLsgWW2ioyM1Mcff6yjR49q3LhxFo+NXr16ac6cOTp8+HCixnje8w+3/uSTT/TDDz8kKtaePXtif8DNw8PDrD5nzpxq0qSJFi1alKC4vXr1Ut68eS3W3b17VyEhIdqxY0diUlZkZKS6deume/fuqV+/frHluXLlSlQ8e8qUKZMqVKhgsa5nz55J+sFCSZo0aZJcXFzMzpMrV67Y9AN1Li4uyp49u1n5qFGjYh+KnhgPHjxQ8+bNdeTIEWXLls2svlGjRipQoIBOnjyZ6DGSqlu3bipSpIjFup07d6p69epmD/C21dWrV1W9enWFhYWpRIkSZvWDBw/WjBkzzB5oa4mjH0P21L59e1WrVs1i3b1799SoUSNt3rw5UbEfPXqkli1bauHChWrWrJlZfbdu3TR06FA9fPgw3lisMdbZa41J7fgM7MtZ5v9nBgwYYHGtfjZerVq1dOjQoUTl+/jxY7399tu6deuWevXqlagYycXankVyrn2LM5zfHHP/WrhwoQYMGGBW7u3trZo1a2rlypUJjpk3b14VLVo03nZ58uRRkSJFdPTo0QSPUa9ePaVLl86sfMeOHbp06VK8/Z1tjnRGzjAPOMs+3Bp73l9ylnPEmdZNZ7nmdZbP/hnWc+c5tlKbrFmzxv5/ZGSkGjZsqDVr1iQ63pAhQ3Ts2DHNnz/f4i8b16xZU02aNNHSpUsTPcZ/OXv+CTF58mQNHjzYrLxu3brKkiWLrl27luQx8uXLZ/E8jIqK0syZM5McPyHsuTYatS5OnjxZQ4YMMStv06aNevToYcj3GDt37myxfNasWXGuY860t3BUqfU9TO1zJSxLa2sIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAva1evVrVq1fXqlWrFBQUFG/7gIAArVmzRq1bt+bvdgIAIKlYsWJauXKlcufObXOfP/74Qw0bNtTly5ftmBkAAAAAAAAA4L9Onz6tMmXKqHXr1vrss8/Mnvkenzx58ihPnjxq3ry5vv/+e61YsUL9+vXTsWPH7JSx5O/vr88//1zdu3eXt7e3xTY7d+5UkyZNEv0sv6CgIGXKlElubm5JSVXu7u7KnDmzAgMDdeXKlSTFSggXFxfNnj1bOXLkiC07e/asOnXqlGw5OGIuAExlypRJdevWTVTfF154QS+88IJNbf39/eNtY20+l6Q7d+5oz5492rt3r/755x/dvn1bkZGR8vX1VcaMGVWyZElVrFhRL774osW4CxYsUPPmzbVkyRKb8jXaCy+8oFatWmnPnj26evWqzf0ePnyoevXqae3atbFfm6urq6pUqaIqVapY7HP//n01bdrU5LnJL7/8skaPHm3Sbu/evfr8889jX7u4uKhv377q27evfHx8LMZu3ry5Ro8erSFDhmjEiBGKiYmx+WsBYMqR5l+jJXbOcyTMv4DxnPHeQ3xSw3yXGuXNm1f58+ePfb1gwQJ98MEHunXrltU+x48f1/Hjx/XTTz/prbfe0o8//igvLy+TNj/99JM2b96s06dPW41jj2saR7ieAYzgSPvf1Hz/IbGSsv99hr0v4Jgcaf41mrPvx7n3AAAAAAAAAAAAAAAAAAAAAAAAAAAAUqtSpUpp3bp18vPzs9rm6tWrGjVqlKZPn67r16/HG/Po0aNavXq1xowZI09PTzVu3Fh9+vTRK6+8YrG9i4uLxo8fr+joaE2aNCnRXwsAAEg5T5480d69e63WAUBaU79+ff38889ydXW12mbr1q2aPXu2tm3bpiNHjkiSQkJCtHLlytg2J0+eVPHixRUUFKQKFSqobt26at26tTJmzGgxpq+vr1avXq3XX39df/75Z4LzfvXVVzVv3jyrz/yIiYnRb7/9poULF2rDhg06f/68xXYeHh565ZVX9Oabb6pLly4KCgqy2C5btmxavHixKlasqKdPnyY4X0nKmTOn1q5da/U9kaTIyEgtWbJES5cu1a5du3T27FmTv9vj4uKivHnzqnz58mratKmaNGkiDw8Pi7GyZMmidevWqWzZsjZdI8NUatwzpMavCXHjMweQmjCnIaFeffVVq9/veebZ8w3u37+fTFkBAGA/7JcAAAAcj/XvwAIAUp1itaROY6VCVSSXOFYAT2+pUlup409SUO7kyy85LF++XF999ZVNbV966SXNnDlTR44c0aNHj3Ts2DEtXrxY33zzjVq3bq2SJUsqffr0ds7YedSsWTP2/8PDw9WgQQNNmDDBkNiDBw+2WvfRRx8pNDQ0yWP8/PPPGjZsmMU6d3d3m4+bhBozZox++OGHJMXYt2+fhg4darW+bdu2CYrn5eWlHj16WK3v0KGDduzYkaCYlvTv39/hH3z68ssvy8XFxaz87t27mjZtmiFjTJw4UUuXLpX07y+QdenSRXny5NHIkSPj7RsTE6PGjRtryZIlsT/At3PnTpOH+CXWrVu3rMZxcXFRvXr1kjxGYrm7u6t3794W665evao333wzyTecnzx5ombNmunBgwdmdQEBAerUqZNNcRz9GLIXFxcXffnll1bru3Tpos2bNydpjOjoaHXo0EF//fVXbFlkZKSmT5+usmXL6uHDhzbFYY2Jm9FrTFrDZ2AsZ5r/JcnHx0cffPCBxbqoqCi1aNFChw4dSmyqsT7//HND5ip7erZnKVWqVKrZtzji+c0x938OHTqkEydOWKxr0qRJomI2bNjQrMzaLwA1aNAgUWM0bdrUYvnChQvj7etsc2Rq4IjzgDPtw62x1/0lZzpHnGnddIZrXmf67CXW82ec4dhK7T799FOtWbMmyXF+/fVX9enTx2q9EfOaJc6ef3ymTZumqKgos3J3d3e1adPGkDGsxVmzZo0uX75syBi2sufaaNS6OHXqVIu/1B8UFGTxWiKh0qdPrxYtWlismzhxYpx9nWlv4ahS63uY2udKWJbW1hAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDksHv3blWqVEnnzp2zqX369Om1aNEivfPOO3bODAAAx1a3bl3t2LFDuXPb/gDtJUuWqEqVKvzNYwAAAAAAAABIIXPnzlWZMmVUsGBBde/eXXPnztXff/8d+6xHW7i7u6tJkyY6dOiQhgwZYniO3t7e6tevn86ePat+/frJ29vbrE1ERIT69eunypUr69q1a4kap2nTpjp06JDatm0rNze3JOXs7u6uLl266PDhw6pdu3aSYiVE3759TcaLjIxUixYtdOfOnWTLwRFzAeC47ty5oxUrVpiUhYaGqlGjRsqcObNq166tfv36aezYsZozZ44WLlyoqVOnauTIkWrfvr3y58+vSpUqafny5Wax3dzc9Msvvyg4ODi5vhwTrq6uatu2rQ4fPqxq1aolqO+pU6dUrlw5TZ8+XdHR0XG23bBhg8qXL6/ff/89tszX11cLFy6Up6dnbNndu3fVvHlzRUZGSpI8PDy0aNEiDRkyRD4+PnGO4ePjo2HDhmn+/Plyd3dP0NcCIG1IypznSJh/AftwhnsPtkot811q89/7OIMHD1bLli1169Ytm/rGxMRo8uTJqly5su7du2dSlyFDBo0YMSLO/va6pknp6xkgtUnN9x+SIin7X/a+AFJCatiPc+8BAAAAAAAAAAAAAAAAAAAAAAAAAACkNoGBgfr111/l5+dnsT46OlqjRo1Svnz59N133+n69esJHiM8PFwLFixQqVKl1L59e6t/W8TFxUVjx45V2bJlEzwGAABIeefPn1eZMmUs/jt//nxKpwcAySpz5syaNWuWXF1dLdbv2LFDJUuWVJUqVTRhwgQdOXIk3pg3b97UihUr9NFHHylHjhzq2rWrbt68abGtv7+/fv31V/n6+iYob09PT/3yyy/y8PCIM+/69etr+vTpcc7vkZGR2r17tz7//HPlzp1bP/30k9W/ZVqmTBl98MEHCcr1GVdXV82bN085cuSw2mbOnDnKly+fWrZsqblz5+rMmTNmucTExOjMmTOaO3euWrRooRdffFFz5861GjNv3ryaOXNmonJO61LjniE1fk2IG585gNSEOQ0J9d5778XbxtvbW23btk2GbAAAsD/2SwAAAI7H8ndhAQCpzssNpJAekns62/sE5pDajvr3v6nJN998o88++0xRUVE293F3d1ehQoXUrFkzffHFF5ozZ47279+vhw8f6u+//1ZoaKi++eYb1atXT4GBgXbM3nG5uLjE/n+PHj20Zs0aQ+JWqFBBFSpUsFg3a9YsTZkyxZBxJGnAgAHatGmTxbpmzZopf/78ho0lSUeOHNHnn39uSKwRI0aYPYj4mRo1apg87Dg+bdu2VUBAgMW6adOmKTQ0NDEpWvTee+/pxo0bhsUzmrUfpDty5IjCw8MNG6dHjx4KCQlR0aJFNW3aNEVERCSof7NmzVS8eHHNmzdP3bp1i/ehgLaaP3++1R+srFKliiFjJMabb76pbNmyWaz77LPPdOnSJUPGOXXqlCZNmmSxrmvXrjbFcJZjyGgNGjSw+mDjn3/+WYsXLzZknIcPH6pr1656+PChxowZo3z58qlz5846fvy4Tf1ZY2xj5BqTlvAZGM+Z5n9J6tChg9VfQBg0aJC2bNmSqPwsefvtt3X37l3D4tnLn3/+mSr2LY56fnPMmVq0aJHF8oYNG5pcv9qqYcOGZmXWfoHJUtv4uLu7KyQkxKw8JibGpr2Ts82Rzs5R5wFn2YfHxV73l5zxHHGGddMZrnmd7bNnPf+XMxxbqdnWrVs1duxYw+KNGjVKq1atslhXoUIFlS5d2rCxJOfP3xaXLl2ymlPnzp0NGaNdu3YWy6dOnWpI/MSw19poxLp45coVrVy50mKdEZ9J06ZNLf5Bu7CwMB06dMimGM6wt3B0qek9TAtzJSxLq2sIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAvZ04cUIVK1bU4cOHbWrv5uamiRMnasCAAXbODAAAx9S9e3etWLHC6nM6LBk2bJiaNWumR48e2TEzAAAAAAAAAIAt/vrrL/34449q06aNChQoIB8fH5UpU0b379+PbXP9+nVFRUVZjeHm5qZ+/fpp/vz5Js83T6x06dKpe/fuOn36tIYMGaKAgACL7ZYsWaIiRYpo2LBhiX4uZfPmzbVw4UKLzxs9ePCgBg4cGPvs5BdeeEGZMmVSzpw5VaxYMTVo0EDffPONjhw5YtY3KChIy5cvV506dRKVV0JUqVJFgwYNMinr2bOn9uzZY/exHTkXAI7tzp07atiwoV555RWNHz9e5cqVU+PGjbV8+XI9ffrUphg7duxQo0aN1LZtW4WHh5vU+fj4aPz48UnOs02bNgoKCjL7lyVLFgUHB+u1115Tjx49tH37drO+mTJl0urVq/X6668naMwbN26oc+fOCg4OVvfu3TVr1iytW7dOGzdu1Lx58/TVV1+pdOnSqlGjho4ePWrSd/LkyQoODjYp69Kli86ePRv7euTIkWrWrJlJm0OHDun777/XgAED9MMPP5jFbd68uYYNG5agrwOA80mJOc+RMP8C9uNo9x7S+nyXGs2dOzfRP8+/b98+vfnmm4qJiTEpf+ONN8zm9v8y+prmv4y6ngHgPPcfUkJi97/sfQEkVVrej3PvAQAAAAAAAAAAAAAAAAAAAAAAAAAApCa//PKL8uTJY7Hu7t27qlOnjnr27KnHjx8bMt6sWbNUsmRJHTx40GK9h4eHFi5cqMDAQEPGAwAAAICUMHz4cKvP5xgxYoQqVapk9brIFuHh4Ro/frwKFiyoDRs2WGyTN29e/e9//0tQ3M8//1yFCxe2WDdp0iRVqVJFhw4dSnC+jx49Urdu3dSxY0erzyT58ssv5eHhkeDYPXv2VKVKlSzWRUZGqkOHDmrbtq3++eefBMW9ePGi2rRpo06dOln9m3d16tTRe++9l+CcAQAAAGfl6+ur1q1bm5VfuHDBrOyDDz5IjpQAAAAAAEAa5J7SCQAA7O+FIlLNRN5nTu8rNRsoTftAirbtOYdOYcyYMTp8+LAmTZpk9ZdAbOHq6qr8+fMrf/78atiwoSQpJiZGR48e1ezZszVz5kxdvHjRqLSdwsqVKzV27FjD4r377rsWy58+fap+/foZNo4kRUdHq0+fPtq1a5dZnaurq7p06aL+/fsbNl737t1tfoBofB4/fqw5c+bo/fffN6vz9fVVoUKFdOTIEZtidezY0WJ5RESEevfunaQ8n3f9+nWNHDlSw4cPNzSuUdKnT2+x/M6dO4aOc/r0aZ0+fTpJMY4cOWLxm49JERERoeXLl6tTp05mda+99pqhYyWEpXwk6dSpU5o3b56hY40ZM0Yff/yx3NzcTMoLFy6s/Pnz69SpU3H2d6ZjyEidO3e2WB4REaGvvvrK0LF+//13Zc+eXffv309wX9YY2xi5xqQlfAbGc6b5X5JatWplsfz+/fsaM2aMIXk+c/36dQ0bNsxh91TPc/Z9i6Oe3xxzphYsWGBxbc2aNavKlStncU22xsfHR1WrVjUrX758uXx9fVW0aFGT8goVKihjxoy6deuWzWNUrVpV/v7+ZuVhYWE23VdwtjnS2TnqPOAs+3BbGH1/yZnPEUdeN53hmtfZPnvW8385w7GVmvXq1cvwmAMHDlRISIjFulatWumPP/4wbCxnz99WEydOjP2+1H+VKFFCJUuW1IEDBxId+5VXXlGhQoXMym/evKnQ0NBExzWK0WujUevixIkT1bhxY7PyevXqKWvWrLp69Wqic7S2z5s4cWKCYzny3sJZpIb3MK3MlbAsLa8hAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA9nTp0iW99tprWr58uSpXrmxTn0GDBilbtmzq1q2boqOj7ZwhAAApz83NTT/99JPF5/VYExERoXfffVczZsywY2YAAAAAAAAAgKR49OiR9u7dq/DwcPn6+kqS2rVrp02bNqlYsWKqUKGCmjZtqtdff12urq4mfVu0aKFjx47p66+/TvT4HTp00JAhQ5QzZ06rbTZv3qz+/ftr+/btiR5HkgoVKqTp06ebPcv61KlTevvtt7Vp0yarff/55x8dOXJEK1eu1JdffqmaNWtq8uTJypMnT2ybdOnSae7cuSpZsqQuXLiQpFytyZQpk+bOnWvyNSxdulQ//vijXcZz5FxiYmLMyp7/bJPKUjxL4wKOKiwsTJUqVbKp7fDhw02ex/vbb79p8ODBNvU9evSozTnt379fXbt2tbm9JXPmzNG9e/e0bNkyk7WpZs2aqlSpUpLWi/v371utu379uk6dOqVt27Zp9OjRKlu2rKZNm6YiRYrEtvH09NTChQtVokQJXbp0KUFjnzlzJkFz6HvvvacWLVqYlI0dO1a//vpr7OuKFSvq448/Nmnz0UcfaezYsWbxevTooZEjR5q8nj9/vvbu3WtzTgD+5YjzryUpOec5EuZfwP5S+t5Dcs13XKcmj4cPH+qTTz5JUox169ZpwYIFatmyZWyZi4uLWrRooaFDh8bZ16hrmpkzZxp+PQOkFEfc/zr6/YeUlJD9L3tfwLE54vxrSXLsxx19L869BwAAAAAAAAAAAAAAAAAAAAAAAAAA4OzatGmjBg0aWKy7e/euqlatqgMHDhg+7sWLF1W5cmVt2rRJpUqVMqvPnTu3RowYoXfffdfwsQEAAADA3oKCgtSuXTuLdT/++KP69Olj2Fg3b95U7dq1tXjxYjVu3NisvmPHjvrhhx/0559/xhsrQ4YMVv8u5MKFC/Xee+8l+W9lzpw5Uy+88IKGDRtmVpcpUyY1aNBAS5YssTletmzZNGDAAIt10dHRat68uZYtW5bofCVpxowZevDggRYuXCgXFxez+iFDhmj+/Pm6c+dOksYBAAAAnEHbtm3l7e1tVt6zZ08NHDhQhQoVii0rUaKEypYtq927dydnigAAAAAAIA1wjb8JAMDZvf6O5JqEZ1UF5ZJeDjEuH0exbt06vfTSS+rRo4du3bplWFwXFxcVLVpUQ4cO1blz57Ry5UoVLVrUsPiObuDAgYbFcnFxUUiI5YNv4cKFunDhgmFjPRMWFmb1IZzWfmkoMfbv36/ff//dsHiSFBoaarWuePHiNsXw9fVV+fLlLdbNnz9f169fT1RucZkyZYoiIiIMj2uEJ0+eWCzPmDFjMmeScqx9gzJLlizy8vJK5mz+fWhjlSpVLNaNHTtW0dHRho534cIFHTx40GJd3bp14+2fFo8hd3d31axZ02LdnDlzdO3aNcPHjOthoNawxiSMEWtMWsJnYDxnm/99fX1VoUIFi3VTpkxJ1LwVn4kTJ1pdd9KK5Ni3OOr5zTFn7uDBg/rrr78s1jVt2jRBserUqaN06dKZlJ07d06HDh2y+Es2bm5uqlevXoLGsJbTggUL4u3rbHOks3PUecBZ9uG2MvL+EueIZUasm45+zetsnz3r+f9x9GMrNdu3b5/CwsIMj7t7927t2LHDYl2dOnUMG8fZ80+IVatW6dKlSxbrOnXqlKTY1n6pf86cOYqMjExSbEdlxLq4evVqXbx40azczc3N6ntqixdeeEE1atQwK79//77mz5+f6LhGc7TvJTij5HoP09JcCctYQwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOznzp07qlWrVpzPIXhe165dNX/+fLNnYwAAkNr4+flp1apVev/9923uc+vWLdWqVUszZsywY2YAAAAAAAAAAHuJiIjQvn37NHbsWNWsWVMlSpTQ5s2bzdoNGDBABQsWTHD8/Pnza8eOHZoxY4Zy5sxpsc2uXbtUo0YNVatWTdu3b0/wGM/78ccflSFDBrMxSpYsqU2bNiUo1vr16/Xyyy/rwIEDJuWBgYEaOXJkUlO1yMXFRbNnz1aOHDliy86cOZPk5xk6ay6Wnh3u7e1t6Bg+Pj5mZffu3TN0DMCe7t69qx07dtj07+bNmyZ9r169anPfBw8eJPvXtmLFCv38889m5R06dEi2HHbv3q1XX31V27ZtMykPCgrSd999Z9exS5Ysqe+//96k7M8//9Rnn31mUtarVy+T1+PHj9fYsWMtxhw1apSmT58e+9rFxUU9e/Y0JF8grUmN829KznmOhPkXMJa97z0kRlLmO65Tk8esWbN07dq1JMcZMWKEWVmtWrWSHNdWKX09AxgpNe5/n3GE+w8pib0v4NhS4/yb2P14atqLc+8BAAAAAAAAAAAAAAAAAAAAAAAAAAA4Gk9PTw0bNsxiXVRUlBo1amT291mNdP/+fdWpU0cXLlywWN+lSxcVLVrUbuMDAAAAgL288cYbSpcunVn56dOn1bt3b8PHi4qKUqtWrXTw4EGL9QMHDrQpTu3atRUYGGhWfvHiRb311luKiYlJUp7PfPfddzpx4oTFunr16iUoVp8+fSz+HSHp36972bJlCc7PksWLF2vo0KEW64KCgtStWzdDxgEAAAAc3fvvv29WduvWLS1dulRTpkwxq/vggw+SIy0AAAAAAJDGuKZ0AgAA+8paQMpROOlxSjVKegxHFBERodGjRyt79uxq1qyZlixZovDwcMPiu7q6KiQkRAcOHNDYsWOt/nBOarFnzx7t2bPHsHilS5dWlixZLNZNmzbNsHFsjV2iRAnlzJnTkDFmzZplSJz/2rt3r9W6XLly2RSjWrVqcnd3t1g3derUROUVnxs3bmjlypV2iZ1U169ft1hesmRJpU+fPpmzSRmHDx+2WpcxY8ZkzORflSpVkpeXl8W61atX22XM7du3WywvVapUvH3T4jFUsWJF+fr6Wqz75Zdfkjkb61hjEsaINSYt4TMwnrPN/6+99prVPdX8+fOTlJc1t2/f1tq1a+0S21kkx77FUc9vjjnLFi1aZLG8cePGCYrTsGFDs7LQ0FBJUlhYmK5du2ZTn7g0amT5xsvixYvj7etsc6Szc9R5wFn24bYw+v4S54hlRqybjn7N62yfPev5/3H0Yys1mzdvnt1iWzuOixcvrsyZMxsyhrPnnxDR0dFW7zO1bdtWbm5uiYrr4uKiVq1aWayz1/cIHIER62J0dLTV96hLly6JykuS2rdvL1dX8x/tmTt3rh4+fJjouEZztO8lOKPkeg/T0lwJy1hDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA7OvJkydq2rSppkyZYnOfN998U6tXr7b63AEAAJxd3rx5tWPHDtWuXdvmPidPnlS5cuW0ZcsWO2YGAAAAAAAAAEhOR44cUY0aNbRo0SKTcldXV/Xp0ydBserVq6c//vhDFSpUsFi/b98+hYSEqEKFCtqwYUOic/6v0qVLq1atWiZl165dU/369RP9nNE7d+6oXr16unfvnkl5ixYtFBwcnOhcrenbt6/J/fqIiAi1aNFCd+/eNXwsZ8jF0lhGf+/eUryUeL8BWDZw4EBFR0eblNWpUydZc3j8+LEaNWqkmzdvmpS3atVKOXPmtMuYPj4+WrhwodKnTx9bdv/+fTVv3lwRERGxZRkyZFCDBg1M+g4fPjzO2M/XN2nSRB4eHgZkDSA1SIk5z5Ew/wL2Z+S9h6RI7HzHdWryWLFihSFx/vzzT12+fNmkrGTJkobEtoUjXM8AsE1aPV99fHzY+wJIEYnZj6eWvTj3HgAAAAAAAAAAAAAAAAAAAAAAAAAAgCPq1q2bcufObbHuq6++SpbnlN24cUOtW7c2+/1/SXJzc9O3335r9xwAAAAAwGiVK1e2WD5hwgQ9efLELmM+efJEXbp0Mbm+ioyM1OzZs/X111/bFGPp0qUqVKiQxo0bZ/Ksj549e+r+/fuG5RoVFaUZM2ZYrHv11VdtjuPn56e33nrLYt2ZM2fi/fs9CfXNN9/o3LlzFus++ugjeXp6GjoeAAAA4GjKlClj8W++z5o1SxEREZoxY4YiIyNN6lq2bCl/f//kShEAAAAAAKQRrimdAADAvvKXMSZOxpySf1ZjYjmiiIgILVmyRM2aNZOfn58qVKigzz77TMeOHdPTp0+THN/NzU1du3bVtm3blD17dgMydkxz5841NF6pUqUslkdHR2vnzp2GjvVf27Zts1pn1EN916xZY0ic/7p+/bquXr1qsS5rVttO4OLFi1ssj4yM1K5duxKdW3zies9T0t9//22x3MvLS927d0/mbFLG7du3rdYFBgYmYyb/snYOXrp0SceOHbPLmAcPHrRYXrhw4Xj7psVjyNpnFBUVpbCwsGTOxjrWmIQxYo1JS/gMjOds83/RokUtlkdERGjfvn1Jyisu69evt1tsZ5Ac+xZHPb855ixbsGCBxfKCBQvqpZdesimGi4uLQkJCzMpDQ0MlSTExMVq5cqVZfd26deXm5mbTGK+88opy5cplVr57926dP38+3v7ONkc6O0edB5xlH24Lo+8vcY5YZsS66ejXvM722bOe/x9HP7ZSs40bN9otdlz3W4oUKWLIGM6ef0JNmjRJMTExZuWZM2dWvXr1EhXz9ddfV44cOczK9+/fr/379ycqpjMw6npy8uTJFv/4W5EiRRL0S///1blzZ4vlEydOTFQ8e3G07yU4o+R6D9PaXAnLWEMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADsKzo6Wm+//baGDBlic5/XX39dW7ZsSRPPIwIApC3ly5dXWFiY1WdzWLJ582aVK1fO6jMsAAAAAAAAAADOKyoqSp06dTJ7tnvTpk3l4uJiU4z69etr2bJl8vf3N6s7fPiwmjVrptKlS+u3334zJOdn2rZta1Y2cOBA3bp1K0lxL1++rOHDh5uVt27dOklxn1elShUNGjTIpKxnz57au3evoeM4Uy537941K7N0XCWFpXh37twxdAwAiXft2jWz5/LmyZPH8LkgPrdv39a3335rUubq6qo333zTLuNNnDhRBQoUMCl7++23derUKZOycuXKyd3dPfb1sWPHdP78+ThjnzhxQufOnYt97enpmehnfANInZJ7znMkzL9A8jDi3oMREjPfcZ1qvMePH5uVHTlyxLD4R48eNXkdGBgoDw8Pw+LHxVGuZwDEL62erxMnTjR5zd4XQHJK6H48tezFufcAAAAAAAAAAAAAAAAAAAAAAAAAAAAcjYuLiz7++GOLdUePHrX4N1ntZfv27Zo8ebLFunr16ik4ODjZcgEAAAAAI7z00ksWy9euXWvXcf/44w8tW7ZMt2/f1vDhw5U3b161a9dO+/btsznGX3/9pQ8//FAvvPCCevTood9//10LFy40PNeNGzdaLM+ZM6fNMVq0aCEfHx+Ldb169VJERESicrMmPDxcffr0sViXJUsWhYSEGDoeAAAA4Gjef/99i+XPvs9z/fp1rVixwqTOy8tL7du3t3tuAAAAAAAgbXFN6QQAAPYVlNu4WBlzGRfLkUVERGjXrl0aM2aMihQpIi8vLxUpUkRvvvmmvvzySy1YsECHDx9O1A/UlCxZUmFhYcqTJ48dMk95u3btMjRe0aJFLZYfPHhQDx48MHSs/zpx4oRu3rxpsa5IkSJJjh8eHm72sGCj3Lp1y2K5l5eXTf0LFy5ssfzPP//UkydPEp1XfMLCwuwWOylOnjxp8mC7/xoyZIjefffdZM4o+Vl6AOIzAQEByZfI/1eoUCGL5UY+zPt51s4rW+bytHgMWZsnDxw4oEePHiVzNtaxxiRcUteYtILPwD6cbf4vWLCgxfI///zT8B/M/6+9e/faLbYzsPe+xZHPb445yw4cOKCTJ09arGvcuLFNMcqXL6/MmTOblN27d0+bN2+Ofb1s2TKzfv7+/qpcubJNYzRt2tRiua2/gORsc6Qzc+R5wFn24bYw+v4S54hlRqybjn7N62yfPev5/3H0Yyu1io6O1oEDB+wWf//+/VbvMVv7RfKEcPb8E+PcuXNav369xbpOnTolKma7du0slk+dOjVR8ZyFUdeTFy5csPoHEDp37pzQtFS+fHmLx9f+/fv1xx9/JDiePTna9xKcUXK8h2lxroRlrCEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADJ44svvlC3bt0UHR1tU/uXX35ZO3bsUP78+e2cGQAAyaNly5bauHGjsmTJYnOf6dOnq1atWrp9+7YdMwMAAAAAAAAApKSHDx9q4sSJJmX+/v56+eWX4+1btGhRLVq0SB4eHiblt2/f1jvvvKMSJUpoyZIlRqYbq1KlSiavo6KiNG/ePENiz5kzJ97xkiJTpkyaO3eu3NzcYss2b96sX3/9VTly5EjUv+cFBASYtcmePbtD52LpueRGP4PTUjxrz0MHkDKOHj1qVpY1a9Zkz+PXX381KytXrpzh47z99ttq3bq1SdmECRO0YMECs7YFChQweW3pvbLk+XbBwcEJzBJAapdcc54jYf4FkldS7j0YKaHzHdepxrP0td24ccOw+NevXzcr8/PzMyx+fBzlegZA/NLa+fr8/pe9L4CUkJD9eGrYi3PvAQAAAAAAAAAAAAAAAAAAAAAAAAAAOKK6desqV65cFut69+6tqKioZM2nf//+evz4sVm5i4uL3n777WTN5b88PT2VMWNGpU+fPsVygPG8vLyUMWNGBQQEyMXFJaXTscrDw0OBgYHy9/d36DyRPJ7NRz4+PimdSrJwlvNUco5zNa2tZ76+vgoMDDT7m/mIX1p779La3GqktHasJEZgYKDF8osXL9p97A8//FA5c+ZU3759denSpUTHuXv3rkaPHq2aNWsqOjrawAz/ZS23gIAAm2O0atXKYvmJEye0ePHixKQVr3nz5unvv/9OUD7OIF26dMqYMaMyZMiQ0qkgCZx1bUtr+1V7SSvvo5ubmwICAhx6L+Ks52JKY49pLi29J8/OGy8vr5ROJdHSwjzs5+dncc+7Z88eHTp0KPb15MmTzdq8//77ds0NSZeW5hyjOdt7lxbmq+TmbMdAapIWjmdnuAZKCxz1PHem76kCAGAP7imdAADAvjL4GxgrwLhYzuTp06c6duyYjh07ZvKDNG5ubsqfP7+KFSumsmXLqkKFCipfvrzSpUsXZ7xcuXJp0aJFqlixoiIjI+2dfrKJjIzUvn37DI1p7SFrx48fN3QcS06cOKGKFSualRcsWDDJsU+dOmWXHyST/v1hNUviOy6fyZMnj8XyEydOJDonW9j6kLmUMGvWLPXv39+s3M3NTRMmTNAHH3ygSZMmafXq1Tp9+nQKZGicTJky6cUXX1T+/Plj/8V1zLu6uiZjdv968cUXLZafP3/ebmPevn3bYrmvr69N/dPSMSRJ+fPnt1j+119/JXMmcWONSbikrjFpBZ+BfTjb/J8vXz6L5adOnUpSTvGx9sP5qVFK7Fsc+fzmmLNu0aJF6tu3r1l5kyZN9N1338Xbv2HDhmZlq1evNrmeX7dunZ48eWL2QxcNGzbU5s2b4x2jcePGFssXLVoUb1/J+eZIZ+bI84Cz7MPjY4/7S5wj9l03Hfma19k+e9ZzU458bKVWFy5csOv3LCIjI3Xx4kUFBweb1Vk7XxPC2fNPrIkTJ6pWrVpm5Q0bNlTGjBl169Ytm2N5enrqjTfeMCuPiIjQnDlzkpSno3m2NtauXdvw68mJEyeqbt26ZuWtW7fWp59+qoiICJtjderUyeoYKckZvpfg6FLqPUyrcyUsYw0BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABIHj/99JOuXbummTNn2vQMghdffFHbt29XSEiI4X+/HwCA5PTFF19o0KBBcnFxsal9dHS0+vXrpxEjRtg5MwAAAAAAAACAI9iwYYMGDBhgUpYvXz79+eefVvu4ublp7ty5Sp8+vUn5yZMnVbduXbs/6zhPnjwmry9evJigZ//F5dy5c7p37578/PysjpcUw4YNU44cOUzKqlatqosXLxo2Rq9evdSrVy+TsrNnz5o9v9uRcjlw4IBZ3+LFixuWhySVKFHCrOzgwYOGjgEgaa5du2ZW5u/vn+x5/P3333r69Knc3d1jy56fL5OqePHi+t///mdSdvDgQXXv3t1i+8DAQJPXN2/etGmcGzduxBkHAJJjznMkzL9AykjMvQejJXS+4zrVeLdv3zYri4iIMCx+eHi4WZmbm5th8ePjKNczAOKXls7X5/e/7H0BpJSE7MedfS/OvQcAAAAAAAAAAAAAAAAAAAAAAAAAAOCo3n77bYvlR48e1YoVK5I5m39/X3LatGnq2rWrWV2nTp3Ur18/RUdHJyhmkSJFzMquXr1q9Xc4M2bMqObNm6t69ep65ZVXlCdPHpNnnT569EjXr1/XsWPHtG7dOq1du1aHDx9OUE72kilTJmXJksVqfe7cuS2W+/v7W3yf4hIREaG///473nYJff8lydPTUyVKlFBwcLD8/f3l6/v/2LvvsCiu9m/gX3pv9l7BXqPYu9h7F0UFY4slRqPGEk1ijP40pmmMEQ32BtjAXrCjYsUuttgroEgRpLx/5NVH3FnYMrM7s/v9XFeu5+E+M+fczs6cc2Zmd8Yl2/v2FixYgLdv32qcq42NDZo3b462bduiWrVqqFy5MvLnz5/tWTRZWVl49eoV4uLiEB0djcOHD+Pw4cOCv3WWUo0aNdCxY0fUrl0bVatWRdGiRWFnZ5ctz4SEBFy9ehVnz57Fzp07sXfvXmRkZBg0T13Y2dmhbNmyasvfvHmDBw8eSNK2HI8NTVSpUgVdunRBnTp1UK1aNRQtWhQ2NjYfyrOyshAfH48rV67g4sWL2Lt3L/bu3avV8SEXSjpOAWUcqx4eHujSpQvatWuHatWqoWzZstn2H0OMZ+qOn6tXr4rajp2dHdq0aYM2bdqgevXqqFixIjw8PLKNHWlpabh37x4uX76MyMhIbN26Va9jtUiRInB3d1eJx8fH48mTJzrXm5M8efKgUKFCKvHY2Fg8e/ZMpzqNse2MzdB9K/cVcfYVOcwpdfXxucTHUlJSJG9bqn1MbElJSYLxj4/NnDg6OqJp06aCZRs3btQ5L01s3LgR06ZNU4m3adMGFhYWyMrKkrR9fbm4uKBDhw5o3749atSogXLlymWb02RkZODp06e4ePEiTp8+jS1btuDChQui52GoOYMhGfLfJJfzBnO6/iJErM/c3LejOnXq1EHLli1Rp04d1KhRA/ny5YOzs3O2ZdLS0vDo0SNcvnwZ58+fx/bt23H69GmD5SiHeSbnmNqT2zxTDtsEMNw4VqRIEfTs2RONGjVCzZo1UaJEiWx9WEZGBh4/fowrV64gMjISYWFhaq8DWVtbI0+ePCrxuLg4pKena5wT+2HN+Pn5wdHRUSW+bNmybH/v3r1bZZnKlSujQYMGiIyMlCw/uWKfw+skxhzDjN1fFShQAPny5dMqZ11YWFigYsWKKvHMzExcv35dtHbksA/oSqn3zD5mDvc/lHAOpI66vj4pKQn37t2TpE1ra2uUK1dOJa7PsS/X41xO91TlNrchIiLzZp37IkREpGTp78SrK0PEukxBRkYGYmJiEBMTg82bNwP47+JLr169MH78eJQvX17turVr18a8efMwbtw4Q6UruYcPHwq+AFcfQhdKAOEX+YpNXRtivKDzxYsXetehjrovk2nq0wtp70m9zV+9eoWsrKxsFzvkYt68efjiiy8Eb6gC/30xftGiRQCA169f4/r167h9+zZu3br14b/bt28LvvDV0KysrFCyZEmUKVMGZcuWzfZfmTJl4OLiYuwUc+Xq6ioYt7S0RJ06dSRpU90PedQdL58ypX1IE+r6SUP03drgGKM9fccYc8HPQBpK6//VjamvXr3SJ6VcvXjxQuUlx0olx3mLnI9v7nPqBQcHY8qUKSrxevXqoUCBArnOsTp16qQSCwsLy/Z3cnIyIiIi0L59+2zxjh07YsKECTnWX6pUKcEXgp89exb//vtvjuu+p7Q+Usnk3A8oZR6eGymuL5nDMWLMcVPO57xK++w5nmcn533LVD169EjyNtSNS2L0U0rPX1dbt27FixcvkD9//mxxW1tb9O3bF3/99ZfGdXXs2FGw7wwPDxf1C+uGYMyxMSwsDM+ePUPBggWzxd9/gTskJESjeuzs7NC3b1+VeEpKCtauXStKrurI8ZxcaeS6Dc21ryRhHEOIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIDCc4OBgvX77E1q1bNXpWZ8GCBXHo0CF07doVERERBsiQiIhIPHZ2dli+fDl8fX01XicpKQl+fn7YunWrdIkRERERERERERERkawIvWMxX758Oa4zaNAgVK1aNVvs5cuX8PHxwf3790XNT8in7+0T+319L1++zNaGuvfX68Ld3V20urRx584dlZiccjlz5oxKrHbt2qK2W6tWrWx/Z2Zm4vz586K2QUT6ycjIMHYKH8TFxaFAgQIf/hZ6Z6yunJycEBISAnt7+w+xxMRE9OrVC6mpqYLrODs7Z/s7JSVFo7aSk5NzrIeICJC2z5MT9r9ExqPLtQcpaNPf8TxVfI8fP1aJubm54fnz56LUL3Sd482bN6LUrQk5nc8QUc7M5Xj9dP7LuS8RGZum83Elz8V57YGIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIjkytraGq1btxYsCwwMNHA22dseOXKkSrxgwYKoXbs2oqKitKrvypUrKrFvvvkG8+bNyxYrUqQIZs6ciYEDB8LGxkZtfY6OjihZsiRKliyJtm3bAgCOHj2KGTNm4NChQ1rlJraRI0fihx9+0Hq9Vq1aCW6nnBw9ehRNmjTJdTlNt7+lpSV69eqFoUOHomnTprC2tlZb57Jly/D27dtc2y5UqBAmTJiAoUOH5vosNQsLC3h4eMDDwwNly5ZF9+7dAQCnT5/GnDlzsGXLllzb05WjoyOGDh2KsWPHonTp0rnm6ebmhvr166N+/foYPXo0Xrx4gd9//x2//fabxr9NNjQ3Nzfs2LEDDRs2FCy/f/++2v5IDHI8NtSxsbHBoEGDMGHCBJQvXz7HZS0sLJAnTx40btwYjRs3xqhRo5CUlIQ1a9Zg7ty5uHv3rs55GIqYx+nWrVuRlZUlWa5KOVYLFCiAb7/9FsOGDYOdnZ3a5Qwxnqk7fiwsLESpv3jx4pgyZQoGDBiQ6zMWbG1t4eXlBS8vL3Tr1g0///wzTp8+jdmzZ+v0ntZ27dph2bJlKvErV66gSpUqWtenib/++gt9+vRRiffo0QObN2/Wqi5jbjtjMGbfyn1FnH3FmHNKfSUmJgrGXV1dkZSUJHn7SuDk5CQY1/TzadCggdrPeuPGjTrnpYkNGzZg2rRpKnE3NzdUr14dFy5ckLR9XXl4eGDy5MkYOXJkjse2lZUVihYtiqJFi6Jdu3aYMWMGrl+/jtmzZ2Pt2rXIzMwUJR+p5wzGIPW/SY7nDeZ0/UWIWJ+5uW/Hj9nY2GDEiBEYMWIEKlWqlOvytra2KF26NEqXLo1OnTphxowZePjwIRYsWIAlS5YgISFBkhzlNM/kHFN7cplnymmbANKPY3Xq1MGPP/6IVq1a5VinlZUVihcvjuLFi6Nt27aYOXMmzpw5gx9//BFhYWHZlm3QoAEOHz6sUkfdunW1uqfAflgzw4cPV4klJydj/fr12WLq5osjRoxAZGSkJLnJGfscXicxxhgml/5q3LhxmDx5skY568PBwUFw2yQmJsLFxUXv+uW0D+hKSffMPmXq9z+UcA6kCXV9/atXr1CoUCG1z+TWR9euXRESEqIS37VrF9q3b69VXXI+zufPny+re6pymdsQEREBgPrRhYiITELyK/HqSooXry5TFR8fj8DAQPzzzz8YOXIk5s+fD1tbW8FlR40ahfnz5wu+nFiJ4uPF30HUXZh89eqV6G19St2/R4yLpVJ+8U3fCxfqLupI8fl+LCsrCwkJCXBzc5O0HV0kJCSgb9++2LlzZ44XZ4D/vvhWt25d1K1bV6UsMTERt2/fxq1bt3D16lWcPn0aUVFRePbsmSR5ly9fHt7e3qhVqxaqVKmCsmXLokSJErCyspKkPUNRt48GBAQgICDAoLlYWFjA0tIy1y8CKnUf0pWx+hFtcYzRnpQ/ODIl/AykobT+X90X/A3RFyYlJclyTpUTpcxb5Hx8c59T78KFC7h16xY8PT2zxS0tLdGpUyf8888/atctWbKkypeyMjIysHPnTpVlt23bpnKDvXz58vD09MStW7fUttGlSxfBeHBwsNp1PqW0PlLJ5NwPKGUenhsp8jW1Y0Ru46acz3mV9tlzPM9OzvuWqTLED7bVXXfJ7cuGmlB6/rpKT0/HypUrMWHCBJUyf39//PXXXxrX5efnJxgPCgrSOT9DkNvYmJGRgeXLlwt++T8gIEDwC7tCunbtKtg3BwcHi/olZ7ltPyVS0jY0176ShHEMISIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIjKsiIgINGvWDDt37kTBggVzXd7FxQW7du3CgAEDtHqPBRERkTHlz58f27ZtQ/369TVe5/Hjx+jUqRPOnTsnYWZEREREREREREREJDcpKSkqMTs7uxzX+eabb1RiEyZMwP3790XLKyefvqM6t3cva+vT+vR5H7pc3L1719gpfCCUS0xMDBISEuDq6voh1qxZM3h4eIjyfvESJUqgVq1a2WI3btxAYmKi3nUTkXjy5s2rEouNjTVCJqpjwbt370Sr+++//0b58uWzxYYPH46YmBiN68jKyhJ1OSIyb1L2eXLC/pfIeHS59iAFbfo7nqeK79SpUyqxIkWK4Pnz56LUX7hw4Wx/v337VnDfk4qczmeIKGfmcrx+Ov/l3JeIjE3T+biS5+K89kBERERERERERERERERERERERERERERERERERERyVbduXTg7O6vEs7KyjPqOzujoaNy4cUPlN5oA0LJlS0RFRYneZr9+/RAYGAgnJyed1m/cuDEOHjyITZs2YdCgQUhKShI5Q/m5cuWKaHVVqFABq1atgre3tyj1WVhY4Ouvv8aPP/4Ie3t7very9vbG5s2bUaRIETx58kSU/D7m6+uLP/74A/nz59e5jvz58+Onn37CyJEjMXDgQERERIiYof4KFy6MPXv2oGrVqoLlly9fRps2bfD48WMDZyYNfY6N1q1bIzAwECVLltS5DicnJwwfPhxDhgzBggULMHXqVLx9+1bn+qQixXF64sQJ9OjRw6yP1W7dumHp0qWCz9PRhFLGMxsbG3z//feYOHEibGxsdK7H29sbW7ZswbFjxzBo0CDcuXNH43U3bNiA3377DS4uLtnilStXRq1atXD27Fmd8xLi5uaGLl26qMSfP3+OsLAwjeuRw7YzNGP3rdxXDLeviD2nFIu655mVKFFCkjFLiYoUKSIY1/TZQure033v3j1cvXpV57w0cfnyZTx48ADFixcXzOvChQuStq+LTp06YenSpShYsKBO678/1iZOnAg/Pz9cvHhR5AwpN8Ye2/TB6y/iMIft2LBhQwQGBqJSpUp61VOsWDHMmzcPU6ZMwbhx47By5UqRMjT+sbhhwwYsW7YsW4xzTGlIOc9U6jbRlYuLCxYvXoz+/fvrXEft2rWxbds2bN68GUOHDkVcXJyIGWrGHPrhnNStWxfVqlVTiYeGhuLNmzcq8aysLFhYWGSL9erVC2PHjhXleaKmxtT7HF4nMWx/be79lZiUug8Ym5j3k039/ocSzoE0tWHDBvz+++8q30Vxd3dH586dERISInqbfn5+gvGgoCCN65Dzcf7+vurXX3+tVz2GuKf6KbletyciItNjaewEiIhIWo9E+u5HZgbw7JY4dZmDjIwMLFy4EK1atUJycrLgMjY2NpgwYYKBM5PO69evRa/T0dFRMJ6QkCB6W5q2oetF44+lpaXpXYdU1F3cUbcfi0nOL5/et28f+vfvr9cLnZ2dnVG9enX06NED06dPR1hYGJ48eYIjR47g888/1+vC2nuFChXCjBkzcO3aNVy/fh2rV6/GV199BR8fH5QuXRpWVlZ6t2Fs6voFuVPKPiQGY/bd2uAYQ1LhZyANpfX/6vIV+nKQ2AwxbxODEuctcj6+uc/lLDQ0VDDetWvXHNfr2LGjSuzYsWOCX9wLDw8XfCl2hw4dcmxDXQ6bNm3Kcb2PKa2PVDIl9gNym4fnxpDXl5RE7uOmXM95lfbZczxXJdd9y1Tps501pW5/FuOaiNLz10dgYKBg3NvbGxUrVtSoDnd3d7Rv314l/uTJE+zevVuv/KQg97Fx6dKlgucHrVu3RuHChTWqIyAgQDCu7vPWhty3nxIodRuac19JwsxxDCEiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIypnPnzqFhw4a4dUuzl4Pa2tpi/fr1GD16tMSZERER6a9SpUo4deoU6tevr/E6Fy5cQJ06dXDu3DkJMyMiIiIiIiIiIiIiXTVu3BhHjx5V+55NfeTLl08l9vLlS7XLV69eHeXKlcsWu3//PlavXi16buq8ePEi29+FChUStf6CBQtm+/v58+ei1f306VPcunVL1P8+FRcXp7LM+fPnZZ0LAERERGT729raGt27d9dxS2fXu3fvXNsjIuPz9PRUiT179szgedja2iJPnjyS5BEQEAA/P79ssaCgIKxbt06reiwtLUVdjojMl5R9npyw/yXKnZyuPUhBl/6O56niunDhApKSkrLFmjZtKkrdLi4uqFmzZrbYpUuXRKlbU3I5nyGi3JnD8So0/+Xcl4iMSdv5uBLn4rz2QEREREREREREREREREREREREREREREREREREJA+uBYCqrYEG/YCmgwHv7kCpWoCVjbEzM64WLVoIxi9fvownT54YOJvs9u3bJxj38fERva1Zs2Zh7dq1cHJy0ruuHj164OTJkyhVqpT+icnclStXRKmnbt26OHHiBLy9vUWpz9XVFREREfj5559hb28vSp3Af++7rVu3rmj1OTg4IDQ0FOvWrUP+/PlFqbNo0aLYt28fJk2aJEp9YvDy8sKJEydQtWpVwfKjR4+iUaNGePz4sYEzk44ux4alpSUWLVqEPXv2oGTJkqLkYWVlhXHjxuHixYuoUKGCKHWKRarjtH79+mZ/rG7evBl58+bVux45j2fFihVDVFQUpk6dChsbcSZzjRo1wsWLF9GhQweN10lKSsKGDRsEy6R4dl+fPn0Ej5cVK1YgPT1dozrksu0MRS59K/eV/0i9r4g9pxTT06dPBePqzsfMUYMGDQTjmj4LrnLlyoLx6OhonXPSxsWLFwXj6vIypokTJ2Lbtm0q717RRdWqVXH69Gn4+/vrnxhpRC5jm654/UUc5rAdBw0ahMOHD6NSpUqi1enh4YEVK1Zg8+bNsLOz06suuRyLnz7T+T3OMcUl5TxTqdtEV5UqVUJ0dDT69+8vSn3du3fH8ePHUbhwYVHq05Q59MO5GTFihGB86dKlgvFDhw6pxOzt7TFo0CAx0zIJ5tDn8DrJfwzRX7O/Eo9S9wE5EOt+8qRJk0z6/ofcz4G0lZSUhPXr1wuWSXEdyd3dHe3atVOJx8XFISwsTKM65Hycf3xfVSxS3FMVIufr9kREZHr4lg4iIhN35zSQmaF/PQ8uAmnJ+tdjbo4cOYJRo0apLR84cKABs5HWmzdvRK/TwsJCMJ6ZmSl6W8Zog7LLysoydgo5Cg4ORp06dXD27FnR6rSwsEDjxo2xbNkyXLt2DZ07d9apHnt7e8ycORO3bt3CDz/8ILsfQNB/5LwPGYLcjnGOMURkDIboCzMyRDgBlBDnLYbFfe4/wcHBgnEfHx84OjqqXU9obqXuRvqTJ09w7tw5lXinTp3U1u/h4YHGjRurxM+fP4/bt2+rXY9IG3Kbh+dGiutLSqakcdPcz3mlZO7jOfctw1H6NRGl56+Pmzdv4siRI4Jlmn7xtGfPnrC1tVWJr169Wlb/bqWMjXfu3MHBgwdV4lZWVhgwYECu6xcuXFjwIXHXrl1DZGSkznkpZfvJmdK3oTn3lSTMnMYQIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIrm4ffs2GjZsqPHzty0tLbFw4ULMmjVL4syIiIh016pVK0RGRqJ06dIarxMeHo5GjRrh0aNHEmZGRERERERERERERLqoXbs29u7diyNHjqBRo0aYNm0a7OzsRG2jRo0aKrEnT56oXb5Vq1YqsdDQUIO+N+/p06fZ/i5QoADKly8vSt316tVT2caftqePMWPGwMvLS9T/PvXLL7+oLLNo0SJZ5wIAy5YtU4lNnjwZ1tbWOmzp/3F0dMT48eM1ao+ItOfq6ipKPY6OjmjatGm22NOnT5GUlCRK/dpo1KiRSiynsVFTlStXVukDr1y5gtGjR+e67ps3b7L97eDgoFGbjo6OOdZDRCRVnycn7H+JcibHaw9S0KW/43mquDIzM3HkyJFssX79+olSd7du3WBjY5MtdvToUY3WFeOcRk7nM0SmyhSvP0hF3fw3N5z7EpGUtJ2PK20uzmsPRERERERERERERERERERERERERERERERERERExle0EuA7HxixCmg3Hmg0EKjbG2g+DOj9EzAmGGgSANg65l6XKapVq5Zg/NPngRjDoUOHBOOfffaZqO1MmzYN06ZNE7XOKlWqYO/evXBxcRG1XrnR5LkFuSlTpgx2794Nd3d3/RMC4OHhgUOHDqFZs2YaLZ+ZmYmkpCSkp6fnumyhQoWwfft2FC9eXM8sgTx58uDQoUPo0aOH3nV9ytLSEnPnzhV9v9ZFrVq1cPz4cZQsWVKwfNu2bWjVqhVev35t4Mykpe2xYW9vj23btmHkyJGS5OPl5YXIyEg0bNhQkvq1JeVxCpj3sTpq1CjR6gLkOZ6935+FnmMnJD09HSkpKRot6+TkhK1bt6JPnz4a5xMYGCgY79evH2xtbTWuRxMBAQGC8aVLl2q0vty2ndTk1rdyX/nP+31FbGLPKcV2/Phxwfjw4cNVnpdornx9fQXjZ86c0Wj9ihUrCsYvX76sc07auHTpkmC8QoUKBmlfU19++SXmzZsHCwsL0eq0tbVFUFAQvvzyS9HqJGFyG9u0xesv4jCH7RgQEIDly5fDyspKo+VTUlKQnJyMrKwsjZbv1q0b9uzZo/OztpVwLJrrHFOK8xEp55lK3Sa6ql69Og4fPozSpUuLWm+FChVw4MABODk5iVqvOubQD+fGzc1NcN+6efMmjh07JriOumd7jhgxQtTclM6c+hxeJ/mPlP01+yvxKHUfkAsx7iePGjUKc+fOFSGb/5HT/iz3cyBdqevr27Rpg0KFConaVq9evQTHj3Xr1iEtLS3X9eV8nGtzX9WY91SFyP26PRERmR5LYydARETSSowFLu3Vv57I9frXYa5WrFiBs2fPCpblyZMH1apVM3BG0sjMzDR2CiQCdRfPLC2lnzaKfaNDCpcvX0bt2rXRtWtX7N+/HxkZGaLVXbZsWWzbtg2zZ8/Wet2jR49i+vTpet38TUpKwoULFxASEoLZs2fD398fDRs2NJk+Si7kug8REREZQuHChTlvIaM4f/48bt++rRK3t7dH69atBddxcnISvNkcHh6utp1t27apxJo0aaL2CxYdO3YU/MJDSEiI2jaITB2vL/2PEsdNnvOSVLhvEeVO3RdP/fz8NLq+7+fnJxhfvny5XnmJSYqxUcpxUd1nou5HGh8bMGCA4LmCujo1ocS5hdxwG5KpMocxhIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiEhunj9/jmbNmuHAgQMarzNt2jQsW7bMIO8VJCIi0sbw4cOxc+dOuLm5abzOb7/9hq5duyIpKUnCzIiIiIiIiIiIiIhIV4MHD0arVq0+/F22bFnR3wH86Ts+3717h/Pnz6tdvmbNmiqxw4cPi5pTbiIjI1Vio0aNEqVuoXqOHz8uSt2Us127duHRo0fZYp6enhgzZoxe9U6ZMgWFCxfOFjt79iwuXLigV71EchYbG4uHDx9++C8+Pl7U+i0sLNCzZ0+cP38eGzZsEKXOcePGwd7ePltsx44dGq1bpkwZ/Pbbb3B2dhYllxEjRqjE9B3rHB0dERISAgcHhw+x5ORk9OrVCykpKbmuHxcXl+3vggULatTup8uJvS8QUXZS97+AMvo8OWH/S5Q7OV57AOTR3/E8VXyLFi3K9nedOnXQpUsXveq0tbXFDz/8oBJfv3692nXEPqfR53yGSMnM7fqDEuQ0/80N575EymEO1x+UNBfntQciIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiLjazgA6PcLULyK+mVsHYB6fYCAxUC+UgZLTTbKlSsnGJfDM08uXrwoGHd3d0fevHlFacPHxwczZ85UiWdlZeHw4cMYN24cGjdujDJlyqBQoUIoV64cGjZsiNGjR2Pnzp3IyMhQW7eXlxdWrlwpSp7aePjwIU6ePKn2v5s3bwquFxcXl+N6Qv9dvnxZr1ytrKywefNmuLu761XPx9auXSv4nOT3jh49irFjx6J27dpwdXWFlZUVnJ2dYWNjA1dXV1SvXh1jx47F2bNnBdfPly8fNm3aBBsbG51ztLW1RXh4OOrUqaN2mYyMDBw5cgSTJ0+Gj48PqlatiiJFiqBo0aKoVKkSunTpgl9++QWPHz9WW8esWbPQp08fnfPUV8uWLXHo0CHkz59fsHzp0qXo3r07UlNTDZKPnI+N1atXo2PHjmrLMzMzcfz4cUyePBktW7ZE5cqVUbhwYZQtWxYNGjTAwIEDsWHDBrx69UptHR4eHtixYwcqVqyoVW5SkPo4BczzWK1Xrx7++OOPbDElj2dC8uTJg71796J48eJql7l48SKmTZsGb29v5MmTBzY2NnB0dISdnR2KFi2KLl26YNGiRWqPF2tra6xcuRJ169bVKKczZ84Izps8PDzQuXNnjerQRPny5VGvXj2V+KFDh3Dr1q1c15fjtpOa3PpW7iv/Y21tLep+IsWcUmwHDx4UjJcsWVLwmYnmplWrVqhdu7ZgmdD7R4QULVpUMH7p0iWd89KGuvNXdXkZQ5MmTfDbb7+pxNPS0hAeHo6RI0eiQYMGH+YL7/vDQYMGYf369Tn2hxYWFvj9999z7HdJf3Ib27RhitdfjMEctmOZMmXw559/wsLCQrD88ePHmD9/Plq1aoXChQvDysoKjo6OcHJygqWlJfLmzYv69etj4sSJOHnypNp2mjZtigULFuiUo9yORc4x/yPF+YiU80ylbhNdFSpUCLt370a+fPnULvP27Vvs3LkTX3zxBZo1a4aKFStmm5P4+vpi1apViI2NVVm3YsWKWLx4sZT/BADm0Q9rYsCAAdmes/nesmXL1K6zadMmwX21fPnyaNKkiZjpKZa59Tm8TvI/UvTX7K/Eo9R9IDdyvmf2KaF7H4Dp7M9KOAfS1ZkzZxAdHa0St7KyQv/+/UVty8/PTzAeFBSU67pyP85zuq8ql3uqQpRw3Z6IiEyPtbETICIi6R1dCZSpDbgIfy85V1cOAA+Ev99BGlq4cCFWrFghWNa0aVO1X6Axd+ouUllbSz+FUXfSn9OFM1OQlJQkGDfExQolXRDZtm0btm3bhrx588LHxwefffYZatasiXLlyqF48eKwtLTUue4pU6bAzs4OX3/9tUbL58uXT+2XCD/19u1b3Lp1Czdv3sTNmzcRExPz4f8/efJEcJ0CBQponLshZGVlCcaPHj2KGzduGDgb9fnkRk77kNgyMzMF44bou7XBMYbIcNTd0NOG0vp/dcez2DeWhNja2krehi7y5cuHEydOoGTJkhotbwrzFkPiPpe70NBQfPPNNyrxrl27YuvWrSrx1q1bq/zbrl+/rvaLIQAQFham8sUjGxsbtG7dGps2bRJsW12u2lBaH0nSUMo83BiUeIwofdyUyzmv0j57jue5k8u+ZQxinFflxsrKSvI21O1rYlwTUXr++goNDcXChQvh4eGRLV6kSBH4+Phg7969atctVqyY4I9TTp48ievXr4ueqy6kHhulGBc3b96M2NhYlQe9VahQAXXq1EFUVJTadQMCAlRiqampWLVqlU65KH1uIQemsg3Nva8kYaY+hhARERERERERERERERERERERERERERERERERERERERERERERERERERHJVWJiItq1a4fVq1ejT58+Gq3z+eefI3/+/Ojbty9SUlIkzpCIiChnlpaWmD9/PsaNG6fxOunp6Rg9ejSWLFkiYWZEREREREREREREpK85c+ZgyJAh2d6vPH78eNy4cQOBgYF61z9kyBCVd+FFRETg9evXatcpVaqUSszQ76resmULxo8fny02cuRIbNiwAZGRkTrX265dO/j5+anEt27dqnOdpLnMzEz8+uuv+OWXX7LF/+///g/R0dGIiIjQus4uXbpgypQpKvH58+frnCeREgwZMkSyuhs1aoRly5ahfPnyAIAaNWrA398fK1as0LnO2rVrY+rUqSrxzZs357hepUqVMHXqVPTt2xdWVlZwcnLCsGHDdM4DALp164ZevXpli6Wnp2PHjh161fvXX3+hYsWK2WIjR47EtWvXNFr/0+WqVq2q0XqfLnf16lWN1iMi3UjZ/yqpz5MT9r9EuZPbtQc59Xc8TxXfjh07EBMTg3Llyn2ILVu2DBcvXsTdu3d1qjMoKEjletXRo0dx5swZweWlOKfR5XyGyBSYy/UHJdFn/su5L5FymMP1ByXNxXntgYiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIyLh8RgGfddJ8ebeCgN+vwJrxwMt/JUtLViwsLFCmTBnBMk1/Eyml27dvIy0tDba2tipl5cqVw4kTJ/Sq397eHsuWLYOlpWW2+I4dO/DNN9/gypUrKus8e/YMN2/eRGRkJBYtWoRKlSphwYIFaNmypWAb739TGxISoleu2ggKCkJQUJDa8u7du2PTpk0q8YiICJXf/0pt9OjRqF69uko8Pj4e27Ztw/bt23Hp0iU8e/Ysx+civzdmzBi0a9dOsOzcuXP44osvEBUVpXb9N2/e4OLFi7h48SIWLFiA7t27Y/ny5XB1dc22nLe3N/z9/bF06dJccxKyePFiNGjQQG15aGgopk2bhpiYGMHyx48f49q1awgLC8PkyZMxevRozJ49Gw4ODirLLlmyBMePH8fDhw91ylVXvXr1wpo1awSPXwD48ccfMWPGDIPmJNdjY/r06ejZs6fa8t27d2PSpEm4dOmSYPmdO3dw4sQJrF69Gk5OThg/fjwmTZoEZ2dnlWXd3NywY8cO1KhRAwkJCaL9G7RhqOMUML9jNTAwEFZWVh/+Vvp4JmTjxo2Cz8IHgAcPHmD8+PEIDQ0VLE9LS8Pjx48RFhaGsLAwTJ06Fd988w0mT56sMhews7NDaGgoKlSogKSkpFzzCgwMxF9//aUSDwgIUJuPtvz9/dW2rQm5bjupyLVv5b7yP2LuJ2LPKaVw+fJlnD17FrVq1VIpmzJlCmJjY1WeqWMunJ2dsXjxYsGylJQUjZ4HZ21tjTx58giWPXnyRK/8NPX06VPBeKFChQzSviY+Pf/NysrC4sWL8dNPP+Hx48eC67zvD1etWgUnJyeMGzcOEydOFJx7WVhYYO3atahcubLBzz/MgVzHNk2Y6vUXQzOX7fj777/D0dFRJZ6ZmYkZM2Zg/vz5SE1NVbt+XFwcTp48iZMnT2L+/Plo0KABFi9ejGrVqqksO2zYMISGhmLfvn0a5yfHY5FzzP8R+3xEynmmUreJLiwsLBASEqJ2XpSZmYl//vkH06ZNw4sXLwSXeX/sbNiwAba2thg3bhy+/fbbbMfOgAEDJH1Xnrn0w5oYPny4Siw9PR0rV65Uu05qairWrVuHkSNHqpSNGDECR44cETVHJTLHPodj2P+I2V+zvxKXEvcBTcj1npmQT+99AKa1P8v9HEhfS5cuxZ9//qkS9/f3F+16aLFixdC4cWOVeHR0NM6fP5/r+nI+ztXdV5XbPVUhSrhuT0REpsfa2AkQEZH0kl8Bm74H+v4fYO+i3boPLgO7f5cgKTOzf/9+tWWlS5c2YCbKkpiYKBj38PCQvG11bbx580byto3JWNvcwcFB7Q8o5Cw2NhYbN27Exo0bP8RsbW1RpkwZeHp6wtPTE+XKlfvw/0uWLKlyAUzI+PHjcfLkyVwvwFpYWCA4OFht+dOnTxEeHo79+/fj/PnzuH37NjIzMzX/B/7/NuTk7du3gvHQ0FAsWLDAwNnoz9j7kBTUfUbu7u6GTSQXHGOIDEfox2DaUlr/r66PMURfKHQT1djez1lKliypdhlTnLcYEve53AUHB+Obb75RiXfs2BGWlpYq+1vnzp1Vlg0PD8+xjejoaDx48ADFixdXqevTL5PY2dmhTZs2KnVcvHgRN2/ezLGdTymtjyRpKGUebgxKO0ZMadw09jmv0j57jueaM/a+ZQxinFflxt7eXvI21O3P6vZ/bSg9f32lpqZizZo1GDNmjEqZv78/9u7dq3ZdX19fwXEhpy9MG5IhxkYpxsV3795h1apVGDdunErZ4MGD1X6RtU6dOqhQoYJKfMuWLYiLi9M6D1OaWxiLKW1Dc+8rSZgpjyFEREREREREREREREREREREREREREREREREREREREREREREREREREREcvfu3Tv4+vri+fPngs+HFNK5c2ccOHAAHTp0QHx8vMQZEhERCXNycsL69evRqVMnjdeJj49Hnz59sG/fPgkzIyIiIiIiIpKXUqVKYfXq1Tku8+233+Lw4cMGyoiIiEgzDx48wI8//oiZM2dmiy9ZsgSlSpXC9OnTkZGRoVPdX3zxBRYuXKgSnz9/fo7rubq6qsSeP3+uUw66On78OM6dO4fPPvvsQ8zKygrbt29Hp06dcPz4ca3rbN26teA7lQ8ePIgrV66oXa906dKIiIhQiQ8dOhT79+/XOg9z9/vvv6Nfv36oVavWh5itrS22bt2Kfv36Yfv27RrX1adPH6xYsQJWVlbZ4rt27cKGDRtEy5nI3Dx79gyenp7ZYkuXLgUArFixQuv6mjRpgs2bN8PR0TFbPDIyEjt37lS7noWFBcLDw1GmTJkPsaFDh+L169eYNGkSsrKytM6ld+/egueOK1aswKtXr7Su771BgwZh0KBB2WKrVq3CypUrNa7j9OnTePv27Yd3I5cuXRqVKlXC1atX1a5Tu3ZtFCpU6MPfiYmJuHDhgnbJE5EsKKnPkxP2v0SakdO1Bzn2d3I5TzWl6w+TJ0/G5s2bP/ydL18+HDhwAF26dMGlS5c0rsfW1haLFy9G//79s8UzMzMxceJEtetJcU6j7fkMEeVOLtcflETf+S/nvkQkt/m4XObiOeG1ByIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIuOq1hb4TPNXd31g6wj0+AFY/gWQlix+XnJTpEgR2NnZCZY9fPjQwNmoyszMxNOnT1GiRAmVstKlS+PEiRN61T9kyBAUL178w9/p6ekYNWoUAgMDNa7j6tWraN26NZYtW4aAgADBZSZNmiT4bFtz5+joqPI8mNTUVPz++++YM2cOXr9+rVV9rq6u+O677wTL1qxZA39/f62fmbR582bExMTg2LFjcHNzy1Y2ceJELFu2TOvfW/v4+GDw4MGCZSkpKRg4cCBCQ0M1ri89PR2///47Dh06hL179yJ//vzZyt3c3PDDDz/g888/1ypPfXzxxRf4888/YWlpqVKWmZmJMWPG4K+//jJYPnJWpUoVTJ8+XbBMlz4pKSkJP/74I9auXYvt27ejYsWKKsuULl0a8+bNw4gRI3TOW1eGPk4B8zpWq1at+qEtUxzP/Pz84OPjI1h2/PhxdOvWDS9evNC4voSEBEybNg1Hjx5FcHAwXFxcspUXK1YMP/zwAyZMmJBrXWvXrsX8+fNVnmPUpk0bFC5cGE+ePNE4LyEWFhYYMGCASjwuLg6bNm3KdX05bzspyLlv5b7yv31FrP1E7DmllH766adsz1v82Pz589GsWTNMnDgR169fN3BmxmNtbY1NmzahbNmyguUbNmzQ6DP08PCAhYWFYNmbN2/0ylFTCQkJgnF3d3dYWFjo9JwmsXl5eX34/69fv0a3bt1w8OBBjddPSkrCrFmzsH79eoSHhwv2h66urvjtt9/Qq1cvUXKm/8h5bNMEr7+Iwxy2Y/78+dGuXTvBMl9fXwQHB2tdZ2RkJLy9vbF+/Xp0795dpXzmzJnYt2+fRnXJ9VjkHFOa8xEp55lK3Sa6GjJkCBo1aiRYlpiYiM6dO2s1J0lLS8PcuXMRHByM/fv3Z3tO5uTJk/XOVx1z6Ic1Ub9+fVSpUkUlvnPnTjx79izHdZctW4aRI0eqxHv06IG8efMiNjZWtDyVxlz7HI5h0vTX7K/Eo9R9wNS8v/cBmN7+LPdzIDGsWbMGP//8MxwcHLLFq1Spgpo1a+L8+fN6t9GvXz/Ba4NBQUG5rivn41zdfVW53VMVoqTr9kREZFpUv6lGREQm6fltYNWXwIu7mq9zcQ8QPAXIeCddXubi0aNHar+Mky9fPgNnoxzqtpmHh4fkbatrw1BfqjKWuLg4wXiBAgUkbbdIkSKS1m9IaWlpuH79OrZv347ff/8dI0eOROvWrVGmTBk4ODigevXqGDlyJI4ePZpjPT///DOsra1zXKZPnz5o3ry5SvzRo0fw9fVFsWLFMGzYMAQHB+PmzZvIzMzU+t/z6Q0pY0tOFv7VYt68eQ2ciXQMuQ9JQd1nJHSB1Zg4xhAJE/pRo76cnJz0rkNp/X9SUpJg3N3dXdJ2raysZDd2A+rnLIBpz1sMiftc7s6dO4c7d+6oxPPmzavyRU0LCwu0b99eZdlt27bl2k54eLhKrH379io35318fAT7R12+hKG0PpKkoZR5uDEo7Rgx9XHTkOe8SvvsOZ7rR07XU+R6XpUbQ1wTUbc/JyYm6l230vMXg7ovCXft2hWurq5q1/Pz81OJpaSkYOPGjaLlpg9DjI1S9YPqPpO+ffuqfXCdv7+/VnXlxtTnFoZgStuQfSWpY6pjCBEREREREREREREREREREREREREREREREREREREREREREREREREREZESZGVl4csvv8S0adOQlZWl0Tr169fHsWPHUKxYMYmzIyIiUlW8eHFERkaiU6dOGq9z+/Zt1K9fH/v27ZMwMyIiIiIiIiL5cXR0RKNGjXL8T67v2SQiIpo9ezYiIyNV4lOmTMGVK1fg6+ur9v2cn7KwsED79u1x+PBh/PXXX7CysspWHhwcjP379+dYh729vUrMy8sL1apVE/W/ggULqs0hKysLo0ePVrm36+HhgSNHjuCPP/5A6dKlNdom5cqVw5IlS7B7926V9xenp6djzJgxOa5vY2ODUqVKqfxnyu8YlVJmZiYGDx6Md+/eZYu7uLggPDwcGzZsQJ06dXKso2HDhti6dSs2bNigsr++efMGw4cPFz1vInNy8+ZNLFiwIFvM2toay5cvx/bt29GwYUON6vH09MTixYtx8OBBlfOxd+/eYezYsTmun5WVhalTp6rEJ0yYgLNnz6JLly6wtrbWKJfatWtj06ZN2LhxI2xtbbOVxcXFYfLkyRrVI6RixYr466+/ssWuX7+OL774Qqt60tLSVN5VO3PmzBzX+f7777P9vXbtWp3e+UxExqeUPk9O2P8SaUcu1x7k2N/J5TzVlK4/bNmyBYGBgdlipUuXxsmTJzF9+nS4urrmWkfHjh1x+vRpDB48WKVszpw5OHXqlNp1pTin+Zgm5zNElDu5XH9QCjHmv5z7EpHc5uNymYurw2sPRERERERERERERERERERERERERERERERERERExmXrCDRVffSExtwKAvX6iJePnOX0PI9nz54ZMBP11OXh4uKid93Fixf/8P8zMzPRp08fleefaOL971+PHDkiWF67dm00adJE5zxNla+vL/Lly/fh75cvX6JFixaYPHkyXr9+rXV9NjY2WL9+Pd6+fZstvnPnTgwYMAAZGRk65Xn58mWMGjVKJe7l5YV27dppVZelpaXKb5HfS05ORrNmzRAaGqpTnhcuXICPjw+Sk5NVyurUqaPy+26pfP/99/jrr79gaWmpUpaamorevXur3Qbm6O+//4aNjY1K/N27d2jfvr1OfRIA3LlzB3Xr1sXJkycFy4cNG5br7/KlYOjjFDDPY9UUxzN7e3vMmzdPsCw6Oho+Pj548eKFTnXv3r0bAwcOFCwbM2ZMjs/Efy8hIQEhISEqcSsrK/j5+emU18d8fHxQtGhRlfjq1auRlpaW47py33ZSkHPfyn0lOzH2E7HnlFLasmULdu3apba8Y8eOuHLlCvbv34/PP/8cXl5eBszO8JydnbFz5060bt1asDwxMRHffvutRnXl9FzUN2/e6JSftnJqx1BzcU0lJyejRYsWKs/M1NTt27dRt25dnDt3TrC8Z8+eGj8TkDQj57FNE7z+Ig5z2I6dOnUSfKbdxo0bERwcrHO9aWlp6NOnD06cOJEtvm/fPsyYMUPjeuR6LHKOqUrO80wlbxNdODs7Y/bs2YJlb968QfPmzXWek9y9exeNGjXC7du3s7UnFXPohzUxYsQIwfjSpUtzXff8+fM4f/68StzW1hb+/v76pqZo5trncAxTJUZ/zf5KHEreB0yVKe7Pcj8HEsPr16/V3lMLCAgQpQ2hMePdu3dYu3ZtjuvJ/ThXd19VTvdU1VHSdXsiIjItqt9WIyIik/XqCbBiFLDzF+BpDJCVpbpM2lvg5glg9Vhg929AxjvVZUg3sbGxgvFPXwZJ//P8+XPBeP78+SVv++OT9I+9fPlS8raN6caNG4Jxb29vSduVun65SEtLw8WLF7F48WI0adIEbdu2VXsxrWTJkujbt2+O9QlduLx+/TqqV6+ODRs26HxB7GPqjgVjefr0qWDcXPpSsfchKTx+/FgwLrd9iWMMmbOcXtIqxZeIhL6AoC2l9f/q5v5S94UlSpQQ/HGqsam72Wrq8xZD4j6nGXU34bt27Zrt7zp16qBAgQLZYrGxsSpfJhCybds2lVi+fPlQt27dHNvMLcecKK2PJGkoZR5uDEo7Rsx53BT7nFdpnz3Hc+lIcT1FiedVcmhD3fEXFxend91Kz18Mly9fxqlTp1TiDg4O6N27t+A6lStXRrVq1VTimzdvRkJCgug56sIQY6NUfe3169dx7Ngxlbibm5vgOYGtra1gH3T79m2df0RmznMLsZjSNmRfSeqY6hhCREREREREREREREREREREREREREREREREREREREREREREREREREREpCSzZ8/GkCFDNH7eaaVKlRAZGYmKFStKnBkREdH/eHt7IyoqSvAZxeocO3YMdevWVfvOXCIiIiIiIiIiIiKSp4yMDHTo0AHR0dEqZeXLl8e6devw7NkzhIeHY/r06Rg0aBDs7Ow+LNOlSxfMmTMH27ZtQ2xsLHbs2IEmTZqo1BUZGYnBgwfrlOOpU6cQHR0t6n+jR4/Osc0TJ07g66+/VolbWlriyy+/xO3bt3H+/HkEBgZi8uTJGDFiBAYNGoQvvvgCU6ZMwbJly3Dx4kXcuHEDw4YNg4WFRbZ6srKyMGzYMFy5ckWnbUK6u3jxIgYPHoysrCyVsj59+uDUqVO4d+8eduzYgWXLlmH+/Pn4559/sHPnTjx69AjHjh1Dly5dVNZNT09H79698eDBA0P8M4hM2qRJk3D48GGVeIcOHXDs2DE8evQIGzZswMyZMzFq1CgEBARg6NChmDRpEv766y+cP38eMTExGDFiBCwtLbPVkZWVhUGDBuHMmTO55rFx40YsXbpUJV6zZk1s3boVsbGx2L17N37//Xd8/fXXGD58+IexYOrUqVi9ejViYmJw+vRpdO/eXaWelJQUdO/eHbGxsVpsnf9xcHBASEgIHB0ds9XZq1cvJCcna13f3Llz8e7duw9/9+jRA7///nu2cf99u4sXL0aHDh0+xNLS0jB//nwd/hVEJBdy7/PkhP0vkfbkdO1Bjv0dz1PFN3bsWJw9ezZbzNHRETNnzsTjx4+xc+dOTJ06FQEBAejatSt8fX0xZswYLF26FHfv3kV4eLjg9yc3bNiA6dOn59q+VOc02pzPEFHu5HL9Qe7EnP9y7ktEcpuPy3UuzmsPRERERERERERERERERERERERERERERERERERExle1NeDgql8dn3UGrGzEyUfOnJycBOOZmZl4+/atgbMRlpSUJBh3dnYWtZ3vvvsOmzdv1qsOf3//bL8N/ZjQb1vNXbly5T78/1evXqF+/fqIjIzUub7Y2FiMGTMGpUuXxi+//IKkpCS8evUKAwcO1DvXtWvX4tKlSyrxli1balVP9+7d4eXlJVg2cuRIREVF6ZTfexcvXsT48eM//B0VFYVu3bqhWrVqSEtL06vu3FhYWGDx4sX47rvvBMsTEhLQtm1bbNq0SdI8lKRx48Zo2LChYNnEiROxb98+vep/8+YNevTogefPn6uUWVhYYOrUqXrVrwtjHKeA+R2rpjie9evXD4ULF1aJJyQkoFu3bnrPW7Zu3Yply5apxG1tbTFq1CiN6ggMDBSM6/p8/48FBARo1ebHlLDtxKSEvpX7yv+IsZ+IPaeUWr9+/XDnzh215ZaWlmjZsiWWLVuGmJgYxMXF4fDhwxg7dqwBs5Re7dq1cfbsWbRq1UrtMpMmTcLjx481qs/e3l5t2Zs3b7TOTxc5tZNTfsYwcuRInDt3Tq863veH8fHxguVfffWVXvXT/yhhbNMGr7+Iw1S3Y9myZQXjK1eu1Lvu9PR0BAQEICUlBatXr0b16tXRunVrjY8huR+LnGNmJ+d5ppK3iS4GDRqEfPnyCZZ9+eWXej//98mTJ/Dz80NGRoZe9WjLVPvh3Li7u6NXr14q8SdPnmDXrl0a1SG0fwLAiBEj9MpN6cy5z+EYlp3Y/bW59ldiMJV9wJSY4v4s53MgManrd/v16wdra2u96q5SpQqqVq2qEg8PD8/1WedyP87V3VfVl5j3VNVR2nV7IiIyHfrNLIiISHGyMoHL+/77z8EV8CgCOLoD6e+A5FfAy3tAZrqxszRN6r7oamtra+BMlOPq1auCL22rVauWpO3a2dmhcuXKgmVXrlyRtG1ju3btmmC8aNGiKFasGB4+fChJu/Xq1ZOkXrnbs2cPfHx8cPLkSTg4OKiUd+jQAWvWrBFct3z58qhYsaJKPCAgQKsXjOcmf/78otUlBnX7YPny5Q2ciTzosw9JRd1nVL16dYPmkRuOMWTOEhIS1Ja5ubmJ3t7HN0B0pbT+PyYmRjBeo0YNSdv19PSUtH5dqJuzAKY/bzEk7nOaCQ4OxqRJk1TiXbp0yfaj1c6dO6sss2PHDmRmZubaxsGDB5GYmKjyMIdOnTrh5MmTAP77grNQG1euXMH169dzbeNTSusjSRpKmYcbg5KOEY6b2el7zqukzx7geG5IYlxPUeJ5VW4KFy4Md3d3Ub5sJyRfvnwoWrSoYJm6/V8bSs9fLIGBgahbt65K3N/fX/CLmX5+foL1BAUFiZ6bLgw1Nko5LgYGBqJRo0Yq8cGDB2Pjxo3ZYl26dIGHh4fKskuXLtWpbc4t9Gdq25B9JeXE1MYQIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiUKCgrCixcvsHHjRsHnaH+qePHiOHbsGDp06PDhvRhERERS6dGjB1avXq3RGPXemjVr8Pnnn6t9rzMRERERERERERERydurV6/QrFkzrFq1Cp06dVIpd3NzQ8eOHdGxY0eVspEjR+Za/44dO+Dr64ukpCRR8jWU3377Dba2tpg9ezYsLS2zlVlYWKBGjRo6vZv63bt3+PLLL7F8+XKRMiVtrVmzBpmZmVi+fDlsbW1VykuUKIESJUpoXF9iYiJ69+6N3bt3i5kmkdlKT09H27ZtsWHDBnTp0kWlvEiRIujTp4/W9aakpGDkyJFYv369xut88cUXAIChQ4eqlLm6uqJNmzZo06aN1rm8evUKvXr1wuHDh7Ve971FixahcuXK2WJjxozB5cuXdarv2rVrmDJlCubPn/8hNnbsWAwaNAiRkZGIjY1F3rx50ahRI7i6umZbd+LEibh165ZO7RKRfMi5z5MT9r9EupHTtQc59nc8TxXX27dv0bJlS4SHh6Nx48bZypycnNCuXTu0a9dOqzoXLVqEsWPHIisrK9dlpTin0eV8hohyJqfrD3Im5vyXc18iAuQ3H5fjXJzXHoiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIzPs57+ddg6ACWqAXfP6l+XnDk7OwvGU1NTDZyJem/fvhWMu7i4iNZGdHQ05syZo3c9d+/exdatW9GrVy+VskaNGuldvykbPHiwaL+Nffr0KSZMmIA5c+agUqVKiI2NFaXeJUuW4M8//8wW+/QZObkZO3asYDwsLAwrV67UObePBQYGonr16ti4caPBniFna2uLtWvXomfPnoLlT58+Rdu2bREdHW2QfJRiwoQJgvH9+/fjjz/+EKWNx48fY+jQodi2bZtKWefOneHl5YWbN2+K0pY2DHmcAuZ1rIpxnMlxPBs9erRgfMGCBbh7964obcyZMweDBw9Weab9wIEDMWPGjFzXj4yMxNWrV1GpUqVs8QoVKqBOnTqIiorSKS9XV1d07dpVJX7ixAlcvXo11/WVsO3EpIS+lftK9n1FzP1EzDmlVF69eoUmTZogPDwcNWvWzHV5Dw8PNGnSRCVerlw5HDt2DNeuXcPVq1cRHR2NM2fOICEhQYq0RePu7o7vv/8eo0aNgrW1tdrlFi5ciMWLF2tc76f9z8cM9b7unM6jraysDJKDJo4ePSrafObff//FpEmTsHTpUpWyrl27olChQnj69KkobZkzJYxtmuL1F3GY8nYsUqSIYPz27dui1H/jxg0ULFgQb9680XpduR+LnGNKez4i5jzTVLaJpkaNGiUY37VrF1asWCFKGydPnsTChQvx1VdfiVJfbky5H87NwIED4eDgoBJfuXIlMjIyNKpj7dq1+OWXX2Bvb58t7unpiRYtWiAiIkKUXJXM3PocjmHS9dfm3F+JwRT2AVNiqvuznM+BxHTs2DFcv34dFSpUyBbPmzcvOnToIHgOpCk/Pz/BeFBQUK7rKuU4//S+qhjEuqeqCSVctyciItOh/o4hERGZvJQE4PF14NZJ4N+zwPPbQGa6sbOSVpEiRfD333/j888/N3jbefPmFYwnJycbOBPluHLlimC8aNGiWr1gTVve3t6CL3YDoNHFciU7ceKE2rIOHTpI1q6UdcvdxYsX1X7pT+hLkO/5+PioxC5duoSTJ0+KlhsA1K1bV9T69KXupYZ16tSBhYWFgbORB133IalcvHhRMF62bFnky5fPwNmoxzGGzFl8fLzaskKFConenhhjidL6/xs3bgjGS5UqhYIFC0rWrhQ3rfQlNGcBzGPeYkjc5zRz9uxZwZvaZcqUyfZC7Y4dO6oso+kN+nfv3mHPnj0q8Y/rrFevHgoUKKCyTHBwsEZtfEppfSRJQynzcGNQ0jHCcVOVPue8SvrsAY7nhqbv9RQlnldpwtvbW7K669VT/1SzmJgYUdpQev5i2LBhg+CXXxs2bIiyZcuqxH19fVVi9+7dk80PVAw1Nkp5jIWEhODVq1cqcR8fHxQtWjRbLCAgQGW59PR0nX9IxrmF/kxxG7KvJHVMbQwhIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiUqrw8HC0atUqx+dhfyxPnjw4cOCAWb8PkIiIpDd58mSEhITAwcFBo+WzsrIwffp0DBgwAGlpaRJnR0RERERERERERERSevXqFTp37oyhQ4fi8ePHotT57Nkz+Pv7o2PHjoLv0VOCuXPnolGjRqK9r/HixYvw9vbG33//LUp9pLt169ahTp06uHDhgl71HD9+HJ999hl27dolTmJEBAB4+/YtunbtCn9/f7x48ULv+s6ePYtatWpp/R7pjIwMDBs2DP3798eTJ0/0zgMAduzYgcqVK2P//v061+Hn56fyrux169bhn3/+0Su3X375Bf/3f/+XLebu7o727dtjwIABaN++PVxdXbOV//TTT1iwYIFe7RKRPMi1z5MT9r9E+pHLtQe59nc8TxXX69ev0bx5c8ycOVOv7zc+fvwYPXr0wOjRo5GRkaHxemKe0+h6PkNEuZPL9Qe5kmL+y7kvEclxPi6nuTivPRAREREREREREREREREREREREREREREREREREclDvpLi1JO3hDj1yJmtra1gXJtndUgtPT1dMG5nZydaG9OnTxft37x8+XLB+GeffQZHR0dR2jA1W7ZswZYtW0SvNzY2FkePHhWtvoiICJVYzZo1YWVlpdH6BQoUQMOGDQXL5s6dq1duH8vKysLIkSNx+PBh0erMibOzM3bt2oWePXsKlt+6dQsNGjRAdHS0QfJRChcXF7Rr106wbM6cOaK2FRYWhitXrqjELSws1H5uhmKI4xQwr2N1+vTpotQjp/GsRIkSqFmzpko8OTkZv/32m2jt3LlzR/D5FyVLlkTFihU1qmPp0qWC8U+fR6GN3r17C76jNjAwMNd1lbTtxKCkvpX7yv+ItZ9INaeUwqNHj9CoUSMsXboUmZmZOtVha2uLhg0bYsiQIfj1119x4MABvHr1CtevX0dgYCCaNm0qctb6cXBwwKRJk3Dnzh2MHTsW1tbWapddvHgxxo4da8DszMuPP/4oan2rV68WfBagtbU12rZtK2pb5khJY5smeP1FHKa8HdVd78vKyhKtDV3ewaWUY5FzzOzkOM80lW2iqXLlyqlt76effhK1rV9++cVg9zVMuR/OzfDhwwXj2jxz8/Xr19i8ebNg2YgRI3TKy5SYa5/DMSw7sfprc+6v9GUq+4ApMdX9Wa7nQFJQ19f7+/vrVa+vr69K7OnTp9i9e3eO6ynxOBfzvqoY91Q1oaTr9kREZBosjZ0AERGRIeTNmxfz58/H7du3MXz4cMyYMSPHL+KIzc7ODnnz5hUse/XqlahtWVhYiFqfMR0/flxtWcuWLSVrt0WLFoLx1NRUnDt3TrJ25eDy5ctqX749ZswYSdr08fGBp6enJHUrRXBwsGC8YMGCao/pMmXKqMSioqJEzQsAmjVrJnqd+jh//rxg3NXV1axvEuiyD0nl7NmzassaN25swExyxjFGvkxpLiNX8fHxasuEbgTpw93dHd7e3nrXo7T+31h9YatWrSSrW1dCcxbAPOYthsR9TnOhoaGC8S5dugAAihcvjmrVqmUrS0tLw969ezVuY9u2bSqxatWqoXjx4gCAbt26aZVbbpTWR5I0lDIPNwYlHSMcN4Xpes6rpM8e4HhuDPpcT1HieZUm2rRpI1nd6n68nZqaiqtXr4rShtLzF0NycjI2bNggWDZo0KBsfzds2BAlS6o+bW7lypWS5KYLQ42NUo6Lb9++xdq1a1XilpaWGDhw4Ie/CxUqhNatW6ssFx4ejmfPnunUNucW+jPFbci+UlkMeb3c1MYQIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiU7fvw4GjdujEePHmm0vKOjI7Zu3aryHEkiIiJ92djYYPny5ZgzZ47Gz01++/YtfH19MWvWLImzIyIiIiIiIiIiIiJDWrZsGcqUKYPPP/8cERERyMzM1Gr9t2/f4uDBg/Dz80Px4sVN4v13J06cQKVKldC9e3fs2bMHGRkZWq2fnp6OsLAwdOjQATVr1kR0dLREmZK2oqOj8dlnn6FPnz44cuQIsrKyNFovMzMT+/btQ+fOndGoUSPcvHlT4kyJzNfKlStRokQJDB06FCdOnNBqXEpPT8euXbvQunVr1K5dG9euXdM5j3Xr1qFs2bIICAjA0aNHkZ6ertX6KSkpWLlyJerWrYuOHTvi8ePHOudSvnx5/P3339liMTExGDZsmM51fmzKlCno2bMn7t69m+Nyd+7cQffu3fHtt9+K0i4RyYec+jw5Yf9LJB65XHuQY3/H81RxZWRk4LvvvoOXlxf++OMPvHjxQuN1r127hjFjxsDLywubN2/WOQcxzmn0PZ8hotzJ5fqDnEg5/+Xcl4gA+c3H5TAX57UHIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIi+XBwFaceJw9x6iF5u3fvHsLDw0Wr7/jx44K/d7W2tkbJkiVFa8eU/P7778ZOQSPXr19XiVlbW8PDQ7POom3btoLvGTx//jwiIyP1zs8Y8ufPj8OHD6NFixaC5WfPnkWDBg1y/Z20OWrdujVsbGxU4pcvX0ZERITo7ak7zjp16iR6W8Z0/fp1JCYmqsTN5VgVc0yT03jWqlUrwfj+/fsRFxcnaluHDh0SjDdr1kyj9VetWoXU1FSVuK+vL+zs7HTKKSAgQCWWkJCA4ODgXNdV0rYTg5L6Vu4r2YmxnyhlTvlecnIyhg0bhurVqyMsLEzrd2gIsbCwQPny5TF06FAcOnQI9+/fx8SJE2FraytCxrqxsbHByJEjcefOHcydOzfH8TgzMxMTJ07EyJEjNX6GEGnn3r172Ldvn6h1pqam4p9//hEsa9u2rahtmSMljW254fUXcZj6dnz16pVgvHTp0oZN5BNKORY5x1Qlt3mmqWwTTambC0RHR+P48eOitvXw4UPs2LFD1DqFmHo/nJOGDRuiUqVKKvHDhw/j1q1bWtW1dOlSwXjXrl1RoEABnfIzFeba53AMU6Vvf23O/ZUYTGEfMCWmvD/L9RxICitXrkRaWppKvEOHDsiXL59OdTZu3BglSpRQia9evTrX663mfpyLcU9VE0q7bk9ERMpnbewEiIiIpOTi4oIJEyZg3LhxcHFx+RAvUaIExo0bh59//tkgeaj70jgA3LhxQ6c63717Jxh3dHTUqT45evDgAS5duoSqVauqlI0ZMwbLly8XvU0bGxt88cUXgmWHDh1CUlKS6G3KTXh4OIYPH64Sr1y5Mtq0aYM9e/aI2t748eNFrU+J1PUDVlZWcHd3R3x8vEpZ/vz5VWKxsbGi5lWkSBHUr19f1Dr1FRUVhaSkJDg5OamU9e/fH9OmTTNCVsanyz4klXPnziEuLg558uRRKRs+fDi2bNlisFxywjHG+MxhLiNX6enpePbsGQoWLKhS5u3tLWpbAwYMgJWVld71KK3/P3fuHF6+fCl4Q2/48OEIDQ0Vvc2KFSuiXr16oterL6E5C2Ae8xZD4j6nueDgYEycOFEl3rVrV8yePVvwS8cHDx4UvFGszs6dO5GZmQlLS8ts8Q4dOuDvv/9Gly5dVNa5fv06rl69qnEbH1NaH0nSUMo83BiUdIxw3BSm6zmvkj57gOO5MehzPUWJ51Wa8PX1xaRJk5CZmSlqvXZ2dhg0aJBg2ZEjR/D27VtR2lF6/mIJDAzE0KFDVeKDBg3CjBkzPvzt5+enskxWVpYk18V0ZYix0RDjYmBgIEaNGqUSDwgIwJw5cwD893kIHeuBgYE6t8u5hf5McRuyr5QnuVwvN6UxhIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiEjprly5ggYNGmDPnj2oUKFCrstbW1tj+fLlKFiwIObNm2eADImIyNR5eHhgy5YtaNq0qcbrPH/+HF26dMHJkyclzIyIiIiIiIiIiIiIjCU1NRVBQUEICgqCq6sratWqhc8++wzFihVDwYIF0aNHD9ja2gIAdu3ahdOnT+PBgwe4ceMGTp06hbS0NJ3b9vLyEuufIaqMjAxs2bIFW7ZsgaOjI2rWrAlvb28UK1YM7u7ucHNzg729PVJSUvD69Wu8evUK9+/fx+nTp3HhwgWd3/cYExMDCwsLAMDixYsxYsQIMf9ZGnnfvhxIkUtWVhaCg4MRHByMAgUKoEmTJqhSpQpKliwJZ2dn2Nvb4+3bt0hISMDdu3dx+fJlHDlyBHFxcaLnQkTC3r59i2XLlmHZsmXw8PBAgwYNUL58eXh6esLFxQUuLi4AgPj4eMTHx+PJkyc4deoUTp8+jZSUFNHySElJwYoVK7BixQo4OjqiXr16KFeuHDw9PZEnTx44OTnBwcEBaWlpiI+Px6tXr3Dnzh2cOnUKFy9eRHp6uih53LhxA87OzqLUpc6mTZuwdetWNG7cGK1atfow3sXHx+PRo0fYu3cvjh07hoyMDEnzICLjkUufp6mrV69KPm9l/0skLmNee/iYHPs7Y5ynGvL6gyH67E/dv38fX331FcaPH4/atWujTp068PLyQoECBeDo6IjMzEwkJCTg+fPnuHTpEiIjI3Hr1i3R2pfLOQ0R5UxJx6opzH859yUiQH7zcWPfM+K1ByIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIvl49xawc9K/njQ+OsIsbN++XdT6EhIScPv2bXh6eqqUeXh4iNqWKbh+/TqOHDli7DQ0kpWVJRjPkycPXr58mev6jRs3Fozv2bNHr7yMpWTJkti3b5/aZ1Lv27cP3bp1Q1JSkoEzU4bmzZsLxnfv3i1Je+rqrVu3Luzs7JCamipJu4aWlZWFJ0+eCO6X5nCsijmmyWk8a9SokWBcis9E3TteK1eurNH6cXFx2LJlC/r27Zst7ubmhq5du2Ljxo1a5ePp6YkGDRqoxNetW4fk5ORc11fSthODkvpW7ivZ6bufKGlO+anLly+jS5cuKFCgAPr06YOuXbvC29v7w7PT9FG8eHHMmzcPI0eOxNixYxEWFiZCxpqxtLTEgAED8P3336NUqVK5Ln/z5k0MHDiQ79qW2N69eyWpNyIiApMnT1aJe3t7S9KeOVHS2JYbXn8Rh6lvxydPngjGfX19JevDNKGUY5FzTFVym2eawjbRRv369QXjYvdlH9fbuXNnSer+uA0xya0fzom6Z98vW7ZM67oOHTqEO3fuoEyZMtniNjY2CAgIwNy5c3XKUenMuc/hGKZK3/7anPsrMZjCPmBKTHl/lus5kBRiY2OxdetW9O7dO1vcxsYGvr6+WLhwodZ1+vn5CcaXL1+e67rmfpyLcU81N0q+bk9ERMplbewEiIiIpFSqVClMnz5d8AWIs2bNwu7du3Hp0iXJ8xg4cKDasjNnzuhUZ3x8vGA8b968OtUnV1u3bkXVqlVV4jVr1kSLFi0QEREhant+fn4oVKiQYNmWLVtEbUuu/vrrLwwfPlywbMmSJahatSrevHkjSlu+vr5o166dKHVJycHBASNGjIC1tTV+/vln0evP6UaMlZWVYFzohzpOTiL8KvAjkyZNgo2Njah16uvdu3fYv38/unTpolI2ZMgQfP/993j37p0RMsuZHPchqWRmZmLnzp2CF6Nbt26N8uXL48aNG6K26ebmhtevX2u9HscY4zKXuYxcnThxAl27dlWJN2/eHPny5RPlpoeNjQ3Gjh2rdz2AMvv/vXv3ol+/fipxHx8fVKlSBZcvXxa1va+//lrU+sSi7sfF5jBvMTTuc5o5c+YM/v33X5Uf7NSuXRtFihRBp06dVNbZtm2bVm3ExsYiMjJS5QZ7p06dcPDgQZQrV05lnZCQEK3a+JgS+0gSn5Lm4YampGNEqeOmXM95lfTZv8fxPDu57lvvKe28ShNFihSBr68v1q5dK2q9/fv3R/78+QXLdu3aJVo7Ss9fLGfOnMGFCxdQo0aNbPESJUqgWbNmOHToEKytrdGrVy+VdQ8fPox///3XMIlqwBBjoyHOJy9evIjTp0+r/Hjcy8sL9evXx4kTJxAQEKCy3v379/X6gq5S5xZyYorbkH2lPMnlerkpjSFEREREREREREREREREREREREREREREREREREREREREREREREREREREpuD+/fto2LAhdu7cibp16+a6vIWFBebOnYvChQtj3LhxBsiQiIhMlaenJ3bu3AkvLy+N17l06RI6d+7M5xUTERERERERERERmYmEhAQcPHgQBw8e/BB78eIF8uXLBwD4/fffsXfvXmOlZxTJyck4fvw4jh8/btB2HR0dP/z/tLQ0g7ZtLp4/f47Q0FCEhoYaOxUiUiM+Ph47duzAjh07jJpHcnIyIiIiEBERYdQ8pJSRkYFDhw7h0KFDxk6FiIzMHPo8OWH/S+ZILtce5NjfGeM81ZSvP2RmZiIqKgpRUVFGy0Eu5zRElDMeq4bBuS8RfUxu83FTvmfE/peIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiCh3b14Cdk7615PwQv865C4rK0swbmFhYeBM1FOXS2Zmpij1HzlyRJR6PvbgwQN4enqqxPPkySN6W0pnCr+b1fRzrVixomA8MjJSzHQMomrVqtizZw8KFy4sWL5+/XoMGjQI7969M3BmylGpUiXB+LFjxyRp7+HDh3jw4AGKFy+eLW5paYny5cvj4sWLkrRrDK9fvxaMm8OxKvaYJpfxrEKFCoLxEydOiN7WkydPBOPlypXTuI4lS5agb9++KvGAgABs3LhRq3z8/f0F44GBgRqtr7Rtpy+l9a3cV/5H3/3EFOaUz58/x8KFC7Fw4UJYWFigQoUKqF27NqpWrYoqVaqgZs2aKFSokE51lypVClu3bsW3336L2bNni5y5qh49emDWrFlq96uPpaWlYcGCBZgxYwZSUlIkz83cHT16VJJ6o6KikJWVpXL+XqpUKdja2prc81ENSWljW054/UUcpr4d1e3bAwcOxM6dOxESEmLgjP6jpGORc8zs5DbPNIVtog11/16p3ht36tQpSer9mKn3w+p4eHigZ8+eKvHXr1/r/NzPf/75Bz/99JNKfPjw4Zg7d65OdSqdufc5HMOy07e/Ntf+SiymsA+YElPen+V6DiSVwMBA9O7dWyXu7++PhQsXalWXjY2N4Pzk1KlTuHbtWq7r8zjX/55qbkzhuj0RESmPpbETICIiktKlS5ewadMmwTJbW1ts3bpV7Re7xdKkSRP06dNHsCw5OVnnCzlxcXGC8Zo1a+pUn1wtXrxY7ZdoFi9eDGdnZ9HaKlq0qNobLnFxcVi9erVobcnZxYsXcfjwYcGykiVLYsmSJaK0U6pUKfz555+i1CUVBwcHjB8/Hnfv3sWvv/6KmTNnonTp0qK3U7BgQcF4Zmam2mP95cuXKjGhC7i68vT0xNChQ0WrT0wrV64UjBcoUACjRo0Svb2JEydiwoQJsLa21npdOe9DUvrnn38E4xYWFvjrr79E/QGml5cXnjx5gpUrV6J8+fJarcsxxrjMZS4jV+puuNnY2GDQoEGitDFu3DiULVtWlLoAZfX/ALB06VK1ZX/++ScsLcW7LFezZk0EBASIVp+YhOYsgPnMWwyJ+5zmhL68Z2FhgX79+qF58+YqZdu3b9e6jW3btqnEWrRoAT8/P8Hlg4ODtW7jY0rrI0kaSpmHG4NSjhGljZtKOOdVymf/Hsfz/yhh3wKUeV6liTlz5sDFxUW0+vLnz48ff/xRsCw1NVX0ayJKz18s6vqT9z8YaNu2LfLmzatSHhQUJGVaWpN6bDTk+aS6H2UMHjwYtWvXFvwh5j///KP2IXeaUNrcQo5MdRuyr5QfOV0vN5UxhIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiMhUxMXFoUWLFti1a5fG63z11VdYu3YtbGxsJMyMiIhMVYsWLRAVFQUvLy+N19m1axcaNGiAf//9V7rEiIiIiIiIiIiIiIhI0MfvQI6NjTViJkRERERERERkqnj9gYiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIzN2/58Wp555I9chZUlKSYNzW1tbAmahnZ2cnGE9MTBSl/mvXrolSz8dev34tGHd3dxe9LaU7deqUsVPIVaFChdCwYUMMGDBAsFzT46V8+fKC8fPnldXZNGrUCEeOHEHhwoUFyxMTEzFq1Ci8e/fOwJkpS8WKFQXj586dk6zNs2fPapWLknx8nObJk0dwGXM4VsUe0+QynpUrV04wfu/ePdHbio+PF4x7eHhoXMehQ4dw69YtlXirVq1QtGhRjeuxsLDAwIEDVeLnzp3TeH9U2rbTl9L6Vu4r/6PvfqKEOaU2srKycO3aNaxevRqTJk1C+/bt8fnnn2dbJj4+HuHh4bh9+zaysrJyrdPCwgI//fQT5s2bJ1XaaNu2Lc6ePYvQ0FBUqFAh1+XfLzdx4kSkpKRIlhf9z82bNyWp9/Xr14L9haWlJcqUKSNJm+ZCaWNbTnj9RRymvh2PHTsm+ExlS0tLbNy4EStXrkT16tUNnpeSjkXOMbOT2zzTFLaJNjw9PQXjUl1juXz5MtLS0iSp+z1T74fVGTRoEOzt7VXi69evx9u3b3Wqc8WKFcjIyFCJly5dGq1bt9apTqUz9z6HY1h2+vbX5tpficUU9gFTYsr7s1zPgaRy4MAB3LlzRyX+2WefoUqVKlrV1a5dO8F7gkFBQRqtb67HuZj3VHNjatftiYhIGSyNnQAREZHUvvvuO8GL6wBQpkwZHDx4EMWKFZOk7VKlSmHVqlWwsLAQLNfnpsHFixcF46VLl0a1atV0qlOOnjx5gnXr1gmWlStXDsuXLxelHRsbG4SEhCB//vyC5X/99ReSk5NFaUsJJkyYoPYLdr6+vlizZg2srKx0rt/LywtHjx5Ve7FFDvr164d///0Xv/zyCwoWLAgAsLe3R2hoqNofbOmqSZMmgvHnz58jMzNTsOzZs2cqsaZNm8LZ2VnvfOzt7bFp0yY4OjrqXZcUwsPD8eDBA8GyOXPmoFKlSqK1VadOHcyaNQs///wzLly4gMaNG2u8rtz3ISkdOnRI7TjVokULTJs2TZR2rK2tsXLlSjg4OGDgwIG4evUqgoODNR4HOcYYl7nMZeTq0KFDasu+/fbbD/2Wrry9vfHjjz/qVcenlNL/v3fo0CFcvXpVsKxp06aibR9XV1ds3LgRlpbyvMwnNGcBzGfeYkjc5zQXHBwsGJ8+fbrKPO3ChQtq+56chIeHq8Ts7e0xfvx4lXhMTAwuX76sdRuftqekPpKkoZR5uDEo5RhR0riplHNepXz273E8V86+BSjzvEoTxYsXx+rVq9Xe19CGhYUF1q9fjyJFigiWb9y4ES9fvtS7nY8pPX+xrFmzRvAH6D179oSTkxP8/PxUyt68eYPQ0FBDpKcxqcdGQ55Prl+/XvChb3369MGoUaNU4pmZmRp/uVcdJc0t5MpUtyH7SvnJ6Xq5oZnKGEJERERERERERERERERERERERERERERERERERERERERERERERERERERkSpKTk9G5c2esXr1a43X69euH7du3w8nJScLMiIjI1Hz++efYvXs3PDw8NF7nzz//RMeOHQWfx05ERERERERERERERNJq1aoVGjRoAABIS0vD5cuXjZwREREREREREZkaXn8gIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiICruwHsrL0q+PeBSAxVpR0ZE3dO81sbGxgaWlp4GyEOTg4CMbFeh/bo0ePRKnnYwkJCYJxuWxTOYmOjjZ2CrCzs0P58uXRvn17jB49Gr///jvCwsJw+fJlJCcn48mTJzh27BhWrVqlVzt58uQRjL948UKveg2pU6dO2LdvH9zd3dUu4+zsjCVLlhguKYXKnz+/YFzK/eHly5eC8Xz58knWpli0OU7LlCmjV1tKPlbFHtPkMp4Jvbc1JSUFcXFxorelbn7h4uKiVT1Lly5ViVlaWmLAgAEa19GiRQsUL15cJR4YGKhxHUrcdvpQYt/KfeU/+u4ncphTGtqjR4/QuXNneHp6wt3dHc2bN8ecOXNw+/btHNebOHEiunXrJmouNWrUwJEjR7Br1y589tlnuS6/d+9eeHt7o1evXrh7966ouQgx1LiVUztZ+l6kEMm9e/ckq1tdf6HN+9dJlRLHNnV4/UUcpr4d3717hzlz5giWWVhYYODAgbhw4QIePHiAzZs348cff8SgQYPQsGFDFCxYULK8lHYsco75P3KbZ5rCNtGUpaUlnJ2dBcvU7d/6yszMlGRbfszU+2F1hg8fLhhftmyZznU+fvwYe/bsESwbMWKEzvUqGfscjmEf07e/Ntf+SiymsA+YElPen+V6DiQldfMHf39/rerx8/NTiaWkpGDDhg0arW+qx7kh76nmxhyv2xMRkfGZ3tkJERHRJ65evYqZM2eqLS9fvjyio6PRpUsXUdv19vbGiRMnULJkScHy9PR0zJs3T+f6jx8/rrbsxx9/1LleOZo2bRrevHkjWNazZ09s2LABdnZ2Otfv4eGBvXv3on79+oLlDx8+xNy5c3WuX4nOnDmDoKAgteX9+/fHgQMHUKlSJa3r7tevH44dO4ZixYrpk6LkEhMTUaBAAZX4Z599hrCwMDg6OorSjrW1Nb7++mvBsitXrqhdLzIyUiVmb2+PKVOm6JWPo6MjQkJCUK1atQ+xjIwMveoUW3p6utp+3d7eHlu3blXb92qjQoUKCAsLg62tLQCgcuXKOHLkCFatWqX2SzEfk/s+JLWc9sWZM2fqva9aWlpi5cqV2fpuS0tL9OrVCxcuXICXl5dG9XCMMR5zmsvI0dmzZ3HmzBnBMnd3d6xYsQI2NjY61V21alVs3779Q/8JiPOlcKX0/x+bMWOG2rKpU6fmeJ6iCVdXV+zcuVPjPs8YhOYsgPnMWwyN+5xmTp8+LfgjEVdXV5VYWFiYTm3cuHEDN2/eVIkLzQFDQkJ0auNjSuwjSRpKmYcbmlKOESWNm0o551XKZ/8xcx/PlbJvAco8r9JUly5dsHXrVjg5Oelch6OjIzZt2oSWLVsKlqelpWHWrFk6158TpecvhoSEBMF5ppOTE/z9/dG5c2eVsuDgYKSkpBgiPY1JPTYa8nwyKSkJ69evV4m7uLgIfhl49+7dePjwoV5tKmluIVemvA3ZV8pLTtfLDc1UxhAiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiU5Oeno6BAwfil19+0Xid1q1b4+DBg8iXL5+EmRERkSmwsLDAvHnzsGzZMo3ftZCRkYHRo0djzJgxyMzMlDhDIiIiIiIiIvNlYWEBR0dHwf8cHBxUlndyckLv3r2xZMkSHDlyBFeuXEFMTAxOnTqFHTt2YO7cuWjRooXO71vMibu7O3r16oV58+Zh+/btiIqKwtWrV3Hjxg1ERUVh586dmDNnDjp06ABra2tR23ZwcECnTp0we/ZshIWFISoqCteuXcP169dx5swZ7N69G7/++it8fX3h4eGhczvafh6lSpXC+PHjERISgrNnzyImJgbXrl3DqVOnsG7dOowePRrFihXTqO3atWvjhx9+QHh4OM6fP4+YmBhER0dj//79CAwMRPfu3eHs7Kzzvy0nhQoVQv/+/bFkyRJs27YNx48fx/Xr13H58mUcOnQIoaGhmD17Npo1aybJvkVERML69++PsLAwWFhYAABWr17NdwsSERERERERkah4/YGIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiOg/z24BN47qvn5WJnA4SLx85CwpKUltWd68eQ2YiXrq8khMTBSl/jdv3ohSz8f4vjjNxcbGGqytIkWKoFOnTpg2bRqWL1+Ow4cP4+HDh0hJScH169exY8cOLFy4EGPHjkWnTp1QuXJlwefa68LR0RGWlpYq8dTUVKSmporShtQCAgKwZcsW2Nvb57psr169MHjwYANkpUwODg6wsrJSiaempuLt27eStRsfHy8Yd3FxkaxNbRnzOAWUf6yKPabJYTxzdHT88Hy1jzk4OCAlJUX0/9SNS3Z2dlrlvWLFCrx7904lrk3fGBAQoBJLTk7GunXrNFpfqdtOV0rtW7mv/Eff/cSQc0o5SkhIwKFDhzB16lR4enqiQ4cOuHTpktrlg4KC4Orqqne7rq6uWLx4Mc6ePYvGjRvnuvyRI0fQuHFjtGnTBmfOnNG7/Y/lNE4b6h1Ntra2asvkMo9ISEiQrO5Xr14JxqV6T5c5UOrYpg6vv4jDHLbjwoULcfz48RyXKVasGLp164Zvv/0WK1aswLFjx/D06VMkJiYiOjoamzZtwty5czFkyBB4e3vrNddQ4rHIOeb/yGmeaSrbRFPq9tXExESkp6dL1q66OYlYzKEf/lTjxo1RoUIFlfjFixdx9uxZvepeunSpYLxTp04oXLiwXnUrEfscjmEf07e/Nsf+Siymsg+YElPfn+V2DiS15cuXC84H+/fvL3iPToiLiws6deqkEt+yZYtG179M4Tg39j1VTZj7dXsiIjIOzWYTRERECjdr1iwcOXJEbXmePHmwdetW7Nu3Dw0bNtSrreLFi2P58uU4efIkChUqpHa53377DTExMTq3c/bsWTx58kSwrHPnzliwYAGsra11rl9OHj9+jClTpqgt79OnD44ePYqqVatqXXeTJk0QFRWFZs2aqV1m1KhRov0QR0nGjh2Lq1evqi1v2rQpLl68iH/++QetWrXK8QtnefPmxcCBA3H8+HGsXbsWBQoUyFa+Zs0a0fIWS1hYGE6cOCFY1rp1a5w8eRK1atXSqw1bW1usWLECNWvWFCzftGmT2nVPnDgheCH4m2++Qc+ePXXKp1SpUjh+/Dg6duz4IZaYmIi1a9fqVJ+UgoKCcPr0acEyLy8vnDx5EvXr19e5/g4dOiAyMhIFCxZUKRswYAA+++yzXOuQ+z4ktZ07d6pt38LCArNnz8batWsFt3FuChQogN27d6Nfv36C5SEhIbh586ZGdXGMMR5zmsvI1S+//KK2rG3bttiyZQucnJy0qtPX1xdHjx7NNta/fPkShw4d0jXNbJTQ/39s06ZNOHDggNry6dOnY9OmTShSpIjWudatWxdRUVEq5y+7d+/Wui4pqZuzAOYzbzEk7nOaCw0N1Wi5bdu26dxGWFiYRsuFhITo3MbHlNZHkjSUMg83BiUcI0oaN5V0zquEz/5j5j6eK2nfApR5XqWpzp074+TJk2q3U05q1KiB48ePo1u3bmqX+fXXXyUdN5SevxgCAwMF43PnzhX8YmRQkPyeGif12Pieoc4n1X0m+i6rjpLmFnJlattw79692f5mXykfOV0vN8a1clMYQ4iIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIhM1YQJE/D1118jKytLo+W9vb1x/PhxlCxZUuLMiIhIqRwdHbFp0yZMnDhR43XevHmDjh07YtGiRRJmRkRERERERETAf9d5k5KSBP+LiYn5sJyVlRWmTZuGR48eYePGjRg2bBgaN26MSpUqwcvLC3Xq1EH79u0xadIkHDhwALdv38bnn38OS0tLvXNs3rw5tm/fjpcvXyI4OBgTJ05Ehw4d4O3tjYoVK6JcuXLw9vZGu3btMHnyZGzfvh1PnjzB999/L/heJG1UqVIFK1asQFxcHMLCwjBlyhR06tQJ3t7eqFChAsqXL49atWqhTZs2GDduHNatW4cXL14gPDwcTZs21bo9TT8PDw8PrFmzBrdv38Yvv/yCnj174rPPPoOXlxcqVKiAOnXqwNfXFwsXLsS///6LNWvWqH3ncOPGjXHq1CmcPn0aM2bMQMeOHVGjRg14eXmhWrVqaNmyJYYOHYpNmzbh4cOHmDRpEuzs7HTeph/r1KkToqKi8OTJE6xZswbDhg1D586d0aBBA5QvXx6VK1dG06ZN0aNHD0yZMgUHDx5EXFwcfv75Z+TJk0eUHIiISJWlpSX++OMPrFmzBvb29gCA6OhojBs3zsiZEREREREREZGp4PUHIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiVXsWAHGPdFv3cBDwNCb35UzB8+fP1ZYVLlzYgJmopy6PnHLXxrt370Sph3Tz+vVrSeuvXLky5s6di3///RePHj1CWFgYZs2aBX9/fzRp0gRFixaFhYWFpDkAgJOTk2A8ISFB8rbFEhQUBCsrK42XX7hwIcqXLy9hRsplrP0hPj5eMO7q6ippu7mRy3EKKP9YNcUxTd1nAgD29vai/yfWO0SeP3+O8PBwlbiXlxfq16+f6/ouLi7o1q2bSnzjxo148+aNRjkoddvpSql9K/cVcUg9p1SanTt3onbt2li1apVgubu7O0aNGqVXG1WqVMGZM2cwYsSIXN+rFRUVhVatWqFp06Y4duyYXu2qk5qaqrbs/bM6pZbT+71yys+QkpOTJatb3XHo7OwsWZumTqljmzqmOFc1BnPYjmlpaejSpQvOnz+v9bpOTk6oVq0aunfvjkmTJmHp0qWIiopCYmIi9u/fj4CAAK3fx6jEY5FzTPGIOc80lW2iKXXtJyUlSdqu1MemOfTDnxoxYoRgfOnSpXrXvX37dsF7PdbW1hg8eLDe9SsN+xyOYWIyx/5KLKayD5gSU9+f5XYOJLWnT59i586dKvFChQqhTZs2GtXRvXt3wWt+QUFBGq2v5OO8cuXKsrinqgletyciImPI+a4lERGRicjMzESfPn1w48aNHJfz8fHBsWPHcOPGDcydOxdFihTJtW43Nzc0aNAAX331FY4dO4Z79+7B398/xy8HnTx5ElOnTtX63/GxjIwMLFy4UG35mDFjcP36dUycOBF16tRBnjx5tPpSu9wsWrQIISEhasu9vb1x4cIFrFy5Eg0aNMhx+9va2qJVq1YIDw/H4cOH4enpqXbZ3377DWFhYXrlrlRJSUno3r07Xr58qXYZKysrDB48GHv37kVcXBzOnTuHXbt2YdWqVVi/fj0iIiJw5coVPHv27MNn86k7d+5g4sSJUv5TdDZo0CC1N0uqVq2KqKgobN68GS1btoS1tbXG9drb26N37944f/48+vfvL7hMcnIyNm/erLaOjIwMrFmzRiVuZWWF4OBgLFy4EAULFtQonyJFiuCPP/7AjRs3UKNGjWxlP/zwAx4/fqxRPYaUmZmJQYMGITExUbC8UKFCiIyMxMaNG1G1alWN661Xrx62bNmC7du3w8PDQ3CZf/75B3v27NGoPjnvQ4YwfPhw3Lt3T215v379cOfOHcydOxfVq1fPtb7ixYtj+vTpiImJQatWrQSXefnyJcaPH69VnhxjjMPc5jJyFBISgitXrqgt79ChA27duoXPP/8cLi4uapeztrZGhw4dcOTIEaxbtw5ubm7Zyr///nvRboAopf//2JAhQxAXF6e2vHv37rh16xZ+/vlnVKlSJce6LC0t0bx5c2zevBknTpxQ+RHqsWPHsHLlSq1zlJK6OQtgPvMWQzP3fU5TwcHBuS7z+PFjnDt3Tuc2NBnnb9++jejoaJ3b+JgS+0iShlLm4YamhGNEaeOmUs55lfDZf8rcx3Ol7FuAMs+r1Nm/fz/+/fffbLEqVarg7NmzWL9+PRo2bJjjNRErKys0atQI69atw7lz51T6nY9FR0fjhx9+ECnz/yg9fykcP34c165dU4kLfRk0JiYGkZGRhkhLK4YaGw11PnnmzBmN5v9Pnz7F9u3b9W5PaXMLOTK1bTh16lSVOYa595VykdP1cmNcKzeFMYSIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIjIlP36668YOHAg3r17p9Hy5cqVw4kTJ7R6HjsREZmHwoUL48iRI+jWrZvG69y/fx8NGjTA7t27JcyMiIiIiIiIiLRRsWJFnD59GrNmzVJ5H6I6xYsXx7Jly7Br164c37eYk2LFiiE8PBwRERHo0KGDVu9XypcvH7777jtcv34d3t7eWrft4uKCRYsWITo6GoMGDYK9vb3G61pZWaFjx444dOgQtm7diqJFi2rdfk6aNGmCy5cvo3///jm+G+zjfPr3749Lly6hTp06H+IWFhaYM2cODh8+nC2eEzc3N8ydOxeHDx9G3rx5df43lCtXDmfOnEFYWJjWn4+zszMmTJiAf//9F/7+/jrnQETK9PXXX2P48OEYPnw4rl69aux0TFZmZiY8PT0//B0REYFmzZqpfS80ERERERERkangtQfD4fUHIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiVamJQOi3QNxD7dY7FQxEhUqTkxy9efMGz549EywrW7asgbNRlSdPHrXPdL9586aBsyEpJCQkSFJvyZIlsW7dOly6dAmTJk1CyZIlJWlHUxYWFoLxjIwMA2cirgMHDqBz587IzMxUKXN0dMTGjRtha2trhMzkTd27EaTeH9TVr27/lJrcjlPAdI9VJTPW/imGwMBAwXhAQECu6/bq1QuOjo4a1ylEydtOF0ruW7mv6E+qOaWSpaWlwd/fH7t27RIs/+qrr3T+7Fu3bo1Tp07By8srx+Wio6PRqVMn1K1bF/v379epLU3l9AzOPHnySNp2bu2kpqbKZi6RlZUlWd1ym2uaAiWPbUT6io2NRf369fHXX3+Jss9bW1ujZcuWCAoKwq1btzSaZ72n1GORc0xxiDnPNJVtoi8p5yMABK9Tku7y5MmDHj16qMRTU1Oxdu1avetPT0/HqlWrBMuGDRtmdscN+5z/cAwjY+M+QMYgp3MgQ1DXL2v6fnU/Pz+V2P379xEREaHR+ko8zj++ryqHe6qa4HV7IiIyBmtjJ0BERGQoT58+RZMmTRAREYHKlSvnuGy5cuUwadIkTJo0CQkJCXjx4gXevHmDN2/eICsrC87OznBxcYGbmxsKFCigVR6XLl1C+/btkZ6ers8/BwCwePFijB49GkWKFBEsL1u2LObNm6dRXbNmzcL06dP1zklKAwcORIkSJVC3bl3BcktLSwwcOBADBw5EbGwsoqKi8PTpUzx//hxWVlYoWLAgihQpgnr16sHJySnX9sLDw/H111+L/c9QlBs3bqBp06aIiIhAwYIFc1zW2dkZNWvW1Kr+uLg4tGvXTrYXRW7evAl/f3+EhIQIfhHC0tIS3bp1Q7du3ZCYmIiTJ08iJiYGd+/exZs3b5CcnIysrCw4OjrCxcUFpUqVQoUKFdCwYUM4ODjk2PaMGTPU/nDtvZkzZ2LQoEEqN3osLCwwevRojBgxAgcOHEBUVBRu3bqFV69eITU19UPfVapUKfj4+KBatWqCFwDDw8Mxf/58zJkzR4OtZXjXrl2Dr68vtm7dCisrK8Flevfujd69e+P+/fvYv38/7t27h+fPn+PNmzewsrKCk5MTChYsiAoVKqBRo0YoWrRojm0ePnwYI0eO1DhHue9DUouNjUW7du1w/PhxeHh4CC7j6Oj4Ycx9+vQpzp49ixcvXuDFixd49+4dnJ2dUbBgQVSrVg0VKlTI8WJ1RkYG+vfvj0ePHmmdK8cY4zC3uYzcZGRkoGfPnjhz5oza/bZQoUJYtmwZFi9ejMjISPz7778fjk93d3d4enrC29sb7u7uguvv27cPixYtgo+Pj2h5K6H//9i///6LPn36YPfu3WrzdXBwwIQJEzBhwgQ8fPgQ586dw/Pnz/HixQtYWVnBzc0Nnp6eqFmzptov3z9//hx9+/ZFw4YNdcpTSurmLID5zFsMifucZqKionD//n2UKFFC7TLh4eF6tXHs2DHExcXl+OOckJAQvdr4lNL6SJKGkubhhqaEY0RJ46aSznmV8Nl/zNzHcyXtW0o9rxKSmJgIf39/7Nu3DzY2Nh/iFhYW6Nu3L/r27Yu4uDicPHky2zWR/Pnzo1ChQqhXr57af8PH4uLi0LVrV7x9+5b5G8DSpUvx66+/5rpcUFCQAbLRjdRjo6HPJwMDA7Fo0aIcl1m+fLloP8JU0txCrkxpG7548QL9+vXDzp07s42x5t5XykVO18uNca3cFMYQIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIlO2Zs0aPHv2DJs3b4azs3OuyxcuXBhHjhxBly5dcOTIEQNkSEREcle9enVs374dxYoV03idqKgodO7c2ejvyiQiIiIiIiKi/ylTpgwOHTqEAgUK6LR+69atcfToUdSvXx8pKSkar1e/fn1s27YN+fPn16nd90qUKIGjR4+iZ8+e2L59u0brlClTBtu3b0fFihX1ahsAunTpggYNGqBbt244fvy43vXVqFEDO3bs0Oja/afy58+PvXv3ol69erh+/ToCAwMxZMgQnfKoW7cujh07Bm9vbyQmJmq1buvWrbFx40aN3luWExcXFyxfvhzlypXD1KlT9aqLiJRj1apVxk7BbPj5+eH8+fMIDg7GlClTRHsXKhEREREREZGc8dqDYfH6AxERERERERERERERERERERERERERERERERERERERERERkapXT4DVXwGtRgEVmwEWFuqXTYwDDi4Brh02VHbycfPmTRQsWFAlXqVKFWzZssUIGWXPQUhGRgbu3r1r4GxICllZWaLX6ePjg5CQEL2e4R4XF4ebN2/i5s2buHHjxof/f/bsWfESVbiNGzdiwIABePfuHX7++Wd88803KstUr14d8+bNw1dffWX4BEnWpDxOFy1ahHr16omXLJGO9u7di3v37qFkyZLZ4n369MHYsWNzfPdMQECASuzKlSs4efKk6HmS8XFf0Z8Uc0pTkJWVhc8//xx3796FnZ1dtrICBQqgRo0aOH/+vFZ1Nm/eHFu3boWDg4PaZa5fv47p06cjNDRUp7x1kZSUhOTkZDg6OqqUCZ3vSkHde8mePn1qkPaJiExNamoqRo0ahT/++ANTpkxB9+7d4erqqne9RYoUQVBQEFq1aoWAgACkpqaKkK38cI4pDs4zdadu21laWkraro2NjaT1m5tBgwapnEsAwOnTp+Hl5SVKG5cuXRKMlyhRAm3btsWuXbtEaUcJ2Of8h2MYEZkrczoH2rVrFx4+fIhixYpli3fp0gXu7u549eqV2nULFSqEFi1aqMRXrlxpsmOpvvdVjXVP1VQ/DyIikjdrYydARERkSM+fP0fTpk2xYsUKdOzYUaN1XF1dRbngAAD79u1Dz549kZCQIEp9r169gp+fH/bv3y/5DSU5ePv2LVq2bInNmzejdevWOS6bN29etGvXTue2Vq9ejcGDB/NkHcDVq1dRt25dbNiwQdQLI/fv30f79u0RExMj+AU2udi8eTN8fX2xZs2aHG+sOjs7w8fHBz4+Pnq3GRERgd9//z3X5Z4+fYqxY8di6dKlguXW1tZo06YN2rRpo3UOR44cQf/+/bVez9C2b9+Ovn37Yt26dTl+PiVKlMDgwYP1auvQoUPo0qUL0tLStFpPzvuQIVy7dg1NmjTBvn37UKhQoRyXLVSoEDp06KBTO+/evUPfvn2xd+9endbnGGMc5jaXkaPr169j2LBhWLNmDSxy+CW5jY0NmjZtiqZNm2pVd79+/cRIU4US+v+P7d+/Hz179sSGDRsEv1T0sWLFiqncEMzNq1ev0LlzZzx69EjnHKWU25wFMI95iyGZ+z6nqdDQUIwfP15t+bZt2/SqPzMzEzt37oSfn5/aZYKDg/VqQ4jS+kiShlLm4cYg92NEaeOmks555f7Zf8rcx3Ml7VtKPa8ScvjwYQwbNgxBQUGC/5Y8efKgffv2Otf//PlztG7dGv/++68eWaqn9PylsGrVKvzf//0fbG1t1S6TkZGBVatWGTAr7Ug5NhrjfHLNmjWYP3++2gcOZGVl5fhv1ZbS5hZyZGrbcM+ePfjyyy+xcOFC9pUyI7fr5aYwhhARERERERERERERERERERERERERERERERERERERERERERERERERERGZun379qF58+bYuXMn8ufPn+vy7u7u2LNnD3x9fbF161bpEyQiItnq2LEj1q9fD2dnZ43X2bhxI/z9/fH27VsJMyMiIiIiIiIibTg5OWHfvn0oUKCAXvVUr14dixYt0vh9nrVr18b+/fvh6OioV7vv2dnZISQkBM2bN8fJkydzXLZkyZI4duwYChcuLErbAJA/f37s378frVq1wrFjx3Sux8XFBdu3b9fqmsun3NzcsH79eqxduxZDhgzRuR4AqFChAhYtWoRBgwZpvE6LFi2wc+dOWFlZ6dX2x6ZMmYKEhAT83//9n2h1EhEREB8fj8qVKyMpKcnYqRARERERERGRieL1ByIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiImGpicD2uUBUKFCpBVCqJuCSD7CxB5JfAS/+BW6dBK4eAN6lGjtb47h+/ToaNWqkEq9fv74RssmuXr16gvE7d+7g3bt3Bs6GlKBdu3YIDw/X6BnuiYmJiImJQUxMDG7evJntf+Pj40XNKzMzUzBubW0tajuG8ueff+LLL79EVlYWAODbb79Fy5YtUbt2bZVlx44di71792Lnzp2GTlO2MjIyBONS7w82NjaCcXX5SEXq41Sf93ia2rFqCt73M5969eoVNmzYYLA8YmNjtV4nKysL//zzD2bOnJkt7urqim7dumHdunWC65UpU0ZwbhYYGKh1+0KUsO10oeS+lfuK4fYTc/TkyRNs2LBB8L1IzZs3x/nz5zWuq0yZMti2bRscHBwEy+Pi4vDtt99iyZIlasdUKT19+hRlypRRiZcuXdog7Qu1DfyXl1zY2NhIdi5ta2srGDf0XNOUKHlsIxJTTEwMAgICMHz4cDRr1gze3t6oVasWKlSogDJlysDOzk6nen19feHi4oJOnTrluJxSj0XOMf8jp3mmuW2T5ORkwbirq6uk7bq7u0tav7kZPny4YLxRo0Y4deqU5O1/8cUX2LVrl+TtmCIl9zkcw/4jpzFMiSwsLHRel/sAGZuxz4EMITMzE8uXL8f06dOzxe3s7NCnTx8sWbJE7bp9+/aFpaVltlhWVhaWL1+ucftKOs41va9q6HuqREREcsVv9xARkdmJjY1Fp06dMGjQICxYsEDyGzEAkJKSgunTp+PXX39Ve5Ktq4MHD6Jfv35YsWIF7O3tRa1bjpKSktChQwf83//9H8aNG6dy0UNfb9++xfTp0zF//nxR61W6e/fuoVGjRvjmm2/wzTff6H3crF+/Hl9++SVevnwpUobSCg4OxrNnz7By5UqULFlS0rbCwsLQu3dvjb/osGzZMixdulTUHIKDgzFw4ECkpirjF4OhoaF48uQJgoODUaRIEUnaWLx4Mb788kukp6frtL6c9yFDuHz5MmrVqoV169ahadOmotf/9OlT9O/fHxEREXrVwzHGOMxtLiNH69atg62tLQIDA9V+AU9bly9fRuvWrSUd65XQ/39s69ataNu2LdauXStqvg8fPkTHjh0RHR0tWp1SWLZsGYoVK4bvvvtO1HqVNm8xJHPf5zQRHByM8ePHC5YlJyfrPbcA/pub+fn5CZbdvXtXqx8naUNpfSRJQynzcGOQ+zGitHFTSee8cv/sP2Xu47mS9i2lnlcJWbFiBZKTk7Fq1Sqdv3gpJDo6Gj179sStW7dEq1OI0vMXW2xsLLZs2YI+ffqoXWbv3r148uSJAbPSnlRjY+vWrQ1+PpmQkICQkBAMHDhQsDwiIgJ3794VtU2lzS3kyNS24aJFi5CSkoLFixerfdCBLpTaV8qJnK6Xm8oYQkRERERERERERERERERERERERERERERERERERERERERERERERERERGTqzpw5g4YNG2Lv3r0oVapUrsvb29sjNDQUX3zxhejvwCMiIuXYtm2bxu9rzMrKwqxZszBjxgyJsyIiIiIiIiIibXl4eMDDw0OUugICAhAUFIRjx47luFz+/PmxY8cOODo6itLue/b29lizZg2qVq2KlJQUwWUcHBywa9cuFC5cWNS237cfHh6OGjVq4N69ezrV4ebmBjc3N71zqVGjBmrUqKF3PQAwcOBA/P333zhx4kSuyxYpUgQbNmyAlZWVKG1/7Mcff8SRI0cQGRkpet1EROYsKSnJ2CkQERERERERkYnj9QciIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiL1nt/+7z9SdfjwYQwZMkQl3rhxY1hbWyM9Pd0IWf2nRYsWgvHDhw8bOBNSglKlSmHdunVqn+EeGxuLTZs2Yd++fTh9+rTOz7rXxdu3bwXjYjwz39CmTp2KOXPmZIulp6fD19cXFy5cgJOTk8o6K1asQLVq1fD06VNDpSlriYmJgnF3d3dJ282TJ49gPCEhQdJ2P2aI49TCwkLn/EzpWDUV6j6TxMREfPHFFwbORntBQUH47rvvVPb5gIAArFu3TnAdf39/lVhqaipWr16tVdtK33baUnrfyn2FpLRnzx4MGjRIJV6xYkWN67CyssL69evh4uIiWH727Fl07doVDx8+1DlPfcXExKBMmTIqcW3+nfpQ187NmzcN0r4m3Nzc8PLlS0nqVtffquufKXdKH9uIxJaWloa9e/di7969H2IWFhYoVqwYPD094enpCS8vrw//39PTEw4ODjnW2bFjR0ydOhWzZ89Wu4ySj0XOMeXF3LZJUlISsrKyVK7T2Nvbw97eXu320JfUx6Y5adq0KcqXL2/UHNq3b49ixYoZ9TxDqZTe53AMI33lNg/MCfcBkgtjnQMZyrJlyzBt2jRYWlpmi/v7+2PJkiVq1/Pz81OJHTlyBHfv3tW4baUc5zndVzX2PVUiIiK5ssx9ESIiItO0cuVKlCpVCjNmzJDsiyGpqan4559/4OXlhV9++QVZWVmStLNx40Y0atQIx48fl6R+uUlPT8eECRPQoEEDnDlzRrR69+3bhxo1amD+/Pmi1WlKMjIyMHv2bJQqVQozZ87E7dva/drs3bt32LRpExo0aIB+/fpJdtxJ5fDhw6hcuTJ+/fVXJCcni15/bGwsRo4ciW7duiE1NVWrdXv37o34+Hi9c3j58iX69++PPn36aJ2DsR0/fhxVqlTB33//jczMTNHqvXbtGpo1a4aRI0fq/UNBOe9DhvD48WM0b94cw4cPF+34z8rKQnBwMKpVq4aIiAhR6uQYYxzmNpeRoxUrVqBx48aIiYnRu661a9eibt26ePLkiQiZ5UwJ/f/HDh06hMqVK2PlypWi5BsaGopq1aohOjpahOyk9/3333PeYmDmvs/l5tSpU3jw4IFg2d69e0XZt3bv3o13794JloWEhOhdf06U1keSNJQyDzcGuR8jShs3lXTOK/fP/lPmPp4rad9S6nmVkODgYNSuXVuUayNv377F7Nmz4e3tjVu3bomQXe6Unr/YAgMDcywPCgoyUCb6kWJsNNb5ZE6fSW6fl66UNreQI1PbhkFBQahXrx6uXbumd12m0FfKiZyul5vKGEJERERERERERERERERERERERERERERERERERERERERERERERERERERk6m7evIn69evj4sWLGi1vZWWFwMBAzJgxQ+LMiIhIbqytrbF06VJYWlpqtHxqaioGDBjAMYOIiIiIiIjITHz99de5LrNgwQIUKFBAkvbLli2LcePGqS2fM2cOKlasKEnbAODu7o7ly5dLVr+xfPXVVxot988//yB//vy5LpeQkIBDhw4hNDQUW7ZswcmTJ5GWlpbjOu+vSxERERERERERERERERERERERERERERERERERERERERERERERERERERERERERkek7cOCAYNzZ2Rk+Pj4GzuZ/3Nzc0Lx5c8Gy/fv3GzgbUoLZs2fD3d1dJZ6YmIgxY8agSJEiGD58OEJDQ3Hv3j2D5pacnIysrCyVuI2NDRwcHAyai64yMjLw+eefY86cOYLlt27dwpgxYwTL8ufPj9WrV0uZnqKkpqYiPT1dJW5tbQ0nJyfJ2vXw8BCMv3nzRrI2P2WI49TZ2Vnn/EzhWDU16j6TPHnyGCEb7T169Ai7du1Sibds2RLFixcXXGfgwIEqsU2bNiE+Pl6rtpW+7bSl9L6V+wpJ6fLly4LxfPnyaVzHiBEjUKdOHcGyU6dOoUmTJnj48KFO+Ynl6tWrgvHatWsbpH117Vy5csUg7WtCaB4mdd2JiYmStWnqlD62ERlCVlYWHjx4gIMHD2Lp0qWYNGkSunfvjmrVqsHJyQnly5fH2LFjce3aNbV1TJkyJcd5j5KPRc4x5cUct8nLly8F44UKFZKkPScnJ7XHDmlvxIgRxk4BVlZWGDJkiLHTUCSl9zkcw8yPlZWVqPW5uLjovC73AZIzQ5wDGcr9+/exb98+lXi9evVQrlw5wXXKlSuHWrVqqcSDgoK0alspx7m6+6pyuKdKREQkV5bGToCIiMiY4uPj8eOPP6JEiRIYMGAANm7ciNevX+tVZ2ZmJk6ePImvv/4axYoVw5AhQ/Do0SORMlbv7NmzaNSoEerXr4/FixfjwoULyMjIkLxdYzp16hS8vb3h4+ODHTt2IC0tTes6kpKSsHHjRnh7e6N169a4ceOGBJmalvj4eHz33Xfw9PTEZ599hi+++AJLly7Fnj17cOrUKVy7dg3R0dE4duwYNm/ejJ9++gldu3ZFnjx50LNnT5w4cUKlTnt7e7XtvXv3Tsp/jlaSkpI+HNuTJ0/GhQsX9K7z3LlzmDRpEsqWLYvFixcjMzNT6zpCQkJQqVIlzJkzR+0N55zcv38fkyZNQsmSJbFu3Tqt15eL+Ph4fPHFFyhXrhwWLVqE2NhYnerJyMjAoUOH0LVrV1SuXBmHDx8WLUe57kOGkpWVhcDAQJQsWRIjR47E+fPndaonJSUFISEhqFWrFvr06YMXL16InCnHGGMwx7mM3Jw6dQpVqlTBmDFjcPfuXa3WzcrKwpEjR9C4cWP4+fkhOTlZoixVKaH//9irV6/g7++PihUrYvny5UhISNBq/czMTOzbtw8NGzZEr169tP6Ch7Fx3mJ45r7P5SY0NFQwvm3bNlHqf/Pmjdr+JCQkRJQ2cqK0PpKkoaR5uKHJ/RhR2rippHNeuX/2nzL38VxJ+5ZSz6uEXL58GXXr1oWvr69O2/zZs2eYP38+SpUqhWnTphn8Oq/S8xdTREQEbt++LVgWFxeHsLAwA2ekO6WNjeocP35c8EvLL1++xJYtWyRr11S2nzGZ2jY8f/48qlSpgoCAAFy/fl3r9U2pr5Sbj6+XG/NauSmNIURERERERERERERERERERERERERERERERERERERERERERERERERERESm7unTp2jSpIlWz0z/4YcfsGTJElha8hXXRETmwN3dHbt378aQIUM0Wv7ly5do2bIl1q5dK3FmRERERERERCSmPXv2oG/fvqhWrRrKli2L+vXrY9q0aRq9u7Nz585wd3dXW16zZk307ds313oSEhLw22+/oW3btqhYsSLKlSuH1q1b47fffkNKSkqO6wYEBAjGy5Yti9GjR+fadnx8PObNmwcfHx9UqFABnp6eaNSoEaZOnYp79+7lun7z5s3RuXPnXJfTRHp6OgIDA9G8eXOUKVMGVapUgZ+fn07vWExJScHPP/+MBg0aoHTp0qhevTpGjBih0bszu3fvDgcHhxyXqVmzJtq2bZvjMi9evICfnx/y5MmD5s2bo1evXujevTvq16+PfPnyYdasWTm+H7RSpUpo165drvkSEREREREREREREREREREREREREREREREREREREREREREREREREREREREREZGyPXnyBNeuXRMsGzhwoIGz+Z/evXvD1tZWJZ6VlYWIiAgjZERyVqpUKfTp00clnpqaCh8fH/z5559IS0szQmb/yczMxLNnzwTLChYsaOBsdNO9e3cEBQXluMzy5csRGhoqWObj44OJEydKkZoiPXr0SDBeqFAhydpUV/fTp08la/NjhjpO8+XLp/O6pnCsmpqMjAy8ePFCJe7o6Ah7e3sjZKS9wMBAlZiFhYXgPKt58+YoWbKkRnXkxhS2nbaU3rdyXyGpqHsfVt68eTVa397eHtOmTRMse/bsGTp06IDk5GSd8xPL2bNnBeOfffYZnJ2dJW3bxcUFNWrUECw7f/68pG1rQ8r5jLq6X758KVmb5kDpYxuRMWVlZSEmJgYLFixA5cqV8cMPPwgu5+zsjCFDhuRYl5KPRc4x5cMct8mNGzcE43Xq1JGkvdq1a8PS0lKSus1Nvnz50L17d2OnAQAYMmQIP1cdmEKfwzHMNGVkZAjGXVxcRG2nePHiOq/LfYCUSsxzIENR10/7+/sLxv38/FRib968UXt/Wh0lHOc53VeVwz1VIiIiubI2dgJERERykJKSgjVr1mDNmjWwsrJC7dq1UblyZfTo0QMFChSAs7MzXFxc4OzsDCsrK6SlpSE1NRWvX7/Gs2fP8ODBA1y9ehUXLlxAZGQkXr9+bbR/y8mTJ3Hy5EkA/524FylSBO7u7nB3d4ejo6Pa9WJiYjSq39fXF76+vqLkKpYDBw7gwIEDcHFxQdu2bVG7dm1Ur14dxYsXh5ubG1xcXJCVlYXXr1/j9evXuHPnDi5evIioqCjs27cPqampkuRljG3VqlUrg7Z3/vx5Ub7o5ebmprYsJSVF7/rFFh8fj7lz52Lu3LkoWLAgWrZsicqVK6NcuXIoU6bMh/7i/RfwkpKSkJCQgDdv3vw/9u48Xus5/x//85w6RZukjexFZCtLadEijVRkKcYeQ0LW8Z2QZcYMYyxjX4aYrEmakEQhpVCJipikhEpRaVHazjm/P+bHZ8y5zumqc13nOsv9frt1u/Fanq/HeV/v7breda5YvHhxfPzxx/Hxxx/H5MmTY+7cuSnJtHjx4rj22mvjj3/8Y3To0CFatWoVrVq1+uUcsP3220flypVj1apVsWLFipg9e3Z89NFHMWbMmJgyZUqRta+55pq45pprip2xpI6JuXPnRv/+/eOyyy6Ltm3bRtu2baNFixaxxx57RMOGDWPbbbeNqlWrRm5ubqxevTpWr14d8+fPj08//TQ+/PDDeO2112L58uVpzVga96GStHbt2njooYfioYceit133z06dOgQhx9+eDRp0iR23XXXqFWrVlSrVi2ysrJi1apVsXLlyli4cGFMnz49pk6dGqNHj44ff/yxRLK6xvyfkrrGpPNeJpXbrby+Bhs3boz7778/7r///jj88MPjqKOOipYtW0bjxo1jhx12iGrVqkVubm6sXLkyli9fHp988klMmzYtXnzxxfjqq68KrXvCCSekPXtZOP//t88//zzOPffc6NevX3Tp0iXatGkTBx10UOyxxx6x3XbbRa1atX55z/H999/HzJkz44MPPoiXX3650H/EFxHx/PPPx/PPP19iP8fWKO33LeX1+K7I+1xRrrzyyrjyyivTukZJv09LpKydI7eG6/zmlab78NL2+VJpPkZK+3UzkbL0nrc0v/aJVPTreVnZt8ry+6r/lZeXF88991w899xzsffee8exxx4bLVq0iGbNmsUOO+wQtWrViqysrFi5cmWsWLEi5syZE9OnT48JEybEO++8E/n5+SWeubTnz9Q1cMWKFQnbn3322Yz+Uqmtka5rY7qui4Vp1qxZia3138rCvUVpv7cvb9swLy8vBg8eHIMHD479998/unXrFs2bN49mzZpF7dq1Y7vttivT58rSWitZ77//frRo0SItz/2TVZ6uIQAAAAAAAAAAAAAAAAAAAAAAAAAA5d3KlSvj6KOPjiFDhiT9u6379u0b9erVi1NPPTVt37kFQObtueeeMWrUqNhnn32SGv/vf/87unfvHvPmzUtzMgAAACBV1q5dG+eee24MHTr0V+3z5s2L999/Px5//PF45513okmTJoXWyM7OjtatW8fo0aMT9v/+97/fbI4333wzTjnllFi2bNmv2ufMmRNjx46Nhx56KN5+++3YaaedftX/+eefx3333ReDBw9OWHfAgAFRqVKlItcePXp0nHbaaQW+e2nu3LkxadKkuOOOO+Kuu+6Kiy++uMg61157bbz88stFjtmcJUuWxLHHHhtTp079VfusWbNi6NChMWrUqPjNb36TVK3PP/88unfvHl988cWv2mfOnBlDhgyJSZMmxf7771/o/MqVK8ehhx4a77zzTqFjBgwYUGSG77//Plq1ahVffvllwv7Vq1fH9ddfH4sWLYoHH3yw0DqXX355ofsXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOXH008/HTfffHOB9l69esUf/vCHWLBgQYlnuuKKKxK2v/HGG/H999+XcBpKu27dukV2dnaB9gcffDAmT56ckjUS1d8SX331VTRs2LBA+yGHHBLz588vVu2SkOz3Apx//vnRqlWr2GWXXQr03XzzzTFu3Lj44IMPUh2vzPn0009jt912K9DeqlWrmDt3blrWbNmyZcL2WbNmpWW9/1VSx2n9+vWLVaOsH6vl0ddff53wdd1///3LxPlk1KhRsWjRogLf/3LOOecUuP/q06dPgflz5syJ8ePHb9XaZX3bbamyfm61r5AuGzZsSNiek5OT1PxTTz01dtxxx4R9l19+eYHvv8qUwvb/nJyc6NKlS4wYMSJtax999NEJt2dubm5MmjQpbetuqUMPPTQteRo1ahQNGjQo0L5x48ZCv0eL5JT1axuUFvn5+fHHP/4x6tWrFxdddFGB/qOPPjpuu+22QueX5WPRPWbpUtG2yWeffRbt2rUr0N6uXbt4/vnnU75eq1atUl6zojr77LOjSpUqmY4REf+51+zevXuMHDky01HKnLJ+znENK59++OGHhO21atVK6TpNmzYt1nz7AGVdcd8DlZSXX345lixZUuBzpTPPPDMGDhwY+fn5v2o/7bTTCtR4/vnnY+3atVu8dmk/zot6rpoKqXimCgClUeVMBwCA0iY3NzcmT54ckydPjscffzzTcYpl7dq18cUXX2Q6RolZvXp1DBs2LIYNG5bpKGyh2rVrF9pX2IfkpcWSJUvi2WefzXSMX2zYsCHGjh0bY8eOzXSUjMvNzY0JEybEhAkTMh2lSKVtHypp8+fPj/nz58cTTzyR6ShFco3JjIp2L1PavP/++/H+++9nOsYWKyvn/59t2LAhRo0aFaNGjcp0lBLnviUzKvI+R9k7R5I+ZeU+vKSV5mOkrF43y8p73tL82ifiel529q2y+r4qkc8//zzuvPPOTMfYamU9f3Hsu+++ccghhyTsK8vPwcrqtbG0sP2Krzxuw08++SQ++eSTTMcggUx9Vl5eryEAAAAAAAAAAAAAAAAAAAAAAAAAAOXZ+vXro1evXvHQQw9F3759k5pzwgknxOuvvx49e/aMlStXpjkhACWtbdu28eKLL0bdunWTGv/mm29Gr169YsWKFekNBgAAAKRUv379YujQoYX2L168OM4777x4++23i6zTpk2bGD16dIH2nJyc6NmzZ5Fzp02bFsccc0xs3Lix0DFz5syJY445JqZNmxbZ2dkxevTouPfee2PMmDGFzqlUqVL06tWryLXff//9OO6442LTpk2Fjtm4cWP0798/atasGWeddVah41q1ahV77LFHfPnll0WuWdQ6xx57bEydOjVh/6ZNm+L888+PuXPnRuXKlYustWLFijj66KNj/vz5CftXrVoVF1100Wa/k7Vly5bxzjvvJOyrXLlyHHvssUXOv/jii5PaHg899FBcfPHFsd9++yXs79ChQ1SpUiU2bNiw2VoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlF3//Oc/46abbopKlSr9qj0nJyeuu+666NevX4nmOfnkk2PfffdN2PePf/yjRLNQNrRv3z5h+3PPPZeyNQ455JBizZ8+fXq0atWqQHvr1q1j+PDhxapdmqxYsSLOOOOMGDduXGRnZ/+qLycnJ5577rlo3rx5/PjjjxlKWDp88sknccwxxxRob9euXTz77LMpX69p06axww47FGhfv359zJ07N+XrJVJSx+m2225brBoV5VgtSz7++OM49NBDC7S3atUqPvjggwwk2jJ5eXnxz3/+MwYOHPir9saNG0e7du1i4sSJERFRvXr1OOmkkwrMf/TRR7d67bK+7bZUWT+32lcqhk6dOsUf//jHOOOMM+Kbb74pkTUL+67sNWvWJDX/lFNOSdg+Z86clF7Hi2vhwoUxe/bsaNq0aYG+M888M0aMGJG2tQv7jq0pU6aUqvve1q1bxz333JPyuocffnjC9rlz50ZeXl7K16tIyvq1DUqbG264Ifr27VvgOwkPO+ywIueV5WPRPWbpUtG2ybhx4+L8888v0H7iiSfGFVdcEbm5uSld77TTTktpvYrsggsuSNh+xhlnxLBhw9K27rhx46JNmzYF2vv16xcjR45M27rlVVk/57iGlU8//PBDwvY99tgjpet06NChWPPtA5QXW/seqKRs2rQpnnjiifjDH/7wq/add945jjzyyHjzzTd/aWvVqlU0bty4QI3HH398q9Yu7cd5up+rpuKZKgCURtmbHwIAAOnVpEmTQvsWLFhQgkkAAAAAAKD8OOeccxK2z5w5Mz766KMSTgNAWeIaAgAAAAAAAAAAAAAAAAAAAAAAAABQNuXl5cUFF1wQN910U9JzOnToEBMmTIiGDRumMRkAJe3000+PN998M+rWrZvU+EGDBkXXrl1jxYoV6Q0GAAAApNRbb70VTz311GbHjR8/Pj777LMixxT2OfERRxwRNWrUKHLuhRdeGBs3btxsjpkzZ8Zvf/vb2GuvvaJHjx4xZsyYIse3bds2tt9++yLHXHTRRbFp06bNrh0Rcdlll8XatWuLHHPssccmVSuRIUOGxNSpU4sc8/XXX8e4ceM2W+vee++N+fPnFznmnXfeiXnz5hU5pqjP/w899NCoVq1aof3z58+PYcOGFVn/vz3//POF9lWtWjUOPfTQpGsBAAAAAAAAAAAAAAAAAAAAAAAAAAAAUDZ9++23MXLkyIR9559/fhx88MEllqVatWpxxx13JOz77rvv4qWXXiqxLBVNpUqVMh1hq+24444J2zf3O/+3xJFHHlms+ZMnT07Y3q1bt2LVLY0mTJgQf/vb3xL2NW7cOB588MESTlQ86Tg2xo4dm7C9R48eaVnv+OOPT9g+fvz4yM3NTfl6iZSF4zSiYh2rZcWUKVMStnfs2LFkgxTDo48+Gvn5+QXazznnnF/+u3fv3lG9evVf9W/cuDEGDx681euWh223JcrDudW+Un61adMmxo0bF2+99Va0b98+/vCHP5TY2rvttlvC9qVLl252bs2aNaNz584J+wYNGlSsXOlQ2Hc3HXvssYVuh+Lac889C71PGDp0aFrW3FpHHnlkVKlSJeV1C/v5J06cmPK1KprycG2D0mTZsmUxffr0Au01a9Ys8vxY1o9F95ilR0XbJmPHjk247zVq1ChOPPHElK51+OGHx0EHHZTSmhVVp06dYq+99irQvnz58hg2bFhs2LAhbX8Ke4/RtWvX2HXXXdP9o5c75eGc4xpW/ixfvjxheyqfRVeuXDl+85vfFKuGfaBwZfl5ckW0te+BStKjjz6asL1Pnz6/+v8zzjijwJg5c+bEu+++u1XrlvbjPN3PVVPxTBUASqPsTAcAAICWLVsW2jdnzpwSTAIAAAAAAOVDTk5Ogb9Y+rPC/iIqAES4hgAAAAAAAAAAAAAAAAAAAAAAAAAAlAc33nhjXHTRRZGbm5vU+AMPPDDee++92GuvvdKcDICScNNNN8VTTz0VVatW3ezY3Nzc+P3vfx/nn39+bNq0qQTSAQAAAKn02GOPJT32nXfeKbJ/++23T9h+8MEHFznv448/jqlTpyadY/jw4TFv3rykxh5yyCFF9k+fPj0++uijpNdesWJFjBgxolhrFuXZZ59Natz777+fslqTJ08usr+w1zUion379kXOHTlyZFIZfjZz5swi+1u2bLlF9QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAom/74xz9GXl5egfbs7Ox49tlno1q1aiWS48EHH4xddtklYd+f//xn39+WAmvWrEnYXrNmzRJOkjqF/Y73devWpaR+dnZ2nH/++cWq8dprryVs33fffaNz587Fql0aXX/99YV+L8KZZ54Zp59+egkn2rySPDbGjx+fcL1ddtklevXqldK1cnJy4tJLL03Y9/LLL6d0raKUheM0ouIdq2XBmDFjErYfd9xxUa9evRJOs3W++uqreOONNwq0n3zyyb/cY/Xp06dA/8svvxzff//9Vq9bHrbdligP51b7SvlTq1atePXVV2PSpEnRsWPHX9r79u0b+++/f4lk6N69e8L2zz//fLNzDzrooKhcuXLCvtGjRxcrVzo8/fTTkZ+fX6C9cuXKceONN6ZlzT/+8Y9RqVKlAu2bNm2K559/Pi1rbq169erFb3/725TWrFu3bpx22mkJ+wq7ryJ55eHaBlurYcOGaam7aNGihO21a9cudE5ZPxbdY5YeFW2bLF26NOG+FxFx4403RpUqVVK21p///OeU1aro+vXrl7D9mWeeiQ0bNqR17aFDh8aPP/5YoD07Ozv69u2b1rXLo/JwznENK38+/fTThO0NGzaMJk2apGSNk046qdivk32gfD5PLu1K03ugkvTFF1/E22+/XaD9xBNPjBo1akRERKVKleLkk08uMObxxx/f6nVL+3GezueqqXqmCgClUXamAwAAQLt27RK2f/3117F8+fISTgMAAAAAAGVfr169Ev7lznXr1sXTTz+dgUQAlBWuIQAAAAAAAAAAAAAAAAAAAAAAAAAA5cNDDz0Up5xySqxfvz6p8bvvvntMmjQpDj300DQnAyBdttlmmxg2bFhcf/31kZWVtdnxP/74Yxx//PHx97//vQTSAQAAAOkwYcKEpMd++eWXRfbXqlUrYXuzZs2KnDdx4sSkM2yp/fffv8j+SZMmbXHNzc3Z3M9blKlTpyY17uuvvy6yf/Xq1TF79uykan3zzTdF9hf2ukZE7LHHHkXO/frrr2OnnXZK+k/lypWLrNegQYMi+wEAAAAAAAAAAAAAAAAAAAAAAAAAAAAoH2bMmBFPPfVUwr6mTZvGs88+G9nZ2WnNcNlll8XZZ5+dsG/OnDnx8MMPp3X9iuKHH35I2L7bbruVcJLUWb16dcL2evXqpaT+qaeeGo0bNy5WjW+//bbQ371/zTXXFKv2/+rbt28cdNBBKa25pXJzc+PUU0+NH3/8MWH/Qw89FHvuuWcJpypaSR4bGzZsiKFDhybsGzhwYOTk5KRsrb59+8ZOO+1UoH39+vUxbNiwlK2zOWXhOI2oeMdqWTBv3rz4+OOPC7RXqVIlzj///JSutd1220XDhg1TWvNnjzzySIG2GjVqxEknnRR77LFHtG/fPqk5W6K8bLtklZdzq32lfFm1alXCn7dKlSrxxBNPRNWqVdO6fu3atePUU09N2JfMd2k1b948YfuaNWsS7jOZNnv27Hj99dcT9vXp0yfh8VMcnTp1ijPPPDNh3/PPPx/ffvttStdLhauuuioqVaqUsnpXXnllbLPNNgXa16xZE2PGjEnZOhVVebm2wZbYeeed46GHHoqvvvoqevbsmfL6VapUSdj+008/FTqnPByL7jFLh4q4Te67776E7fvtt1/cfPPNKVmjb9++cdRRR6WkVkVXt27dOP744xP2DRo0KO3rr127Np577rmEfb/73e9Seh9bEZSXc45rWPny+eefx7JlyxL29enTp9j1K1euHH/84x+LXcc+UD6fJ5dWpfE9UEl79NFHC7RVq1YtevfuHRERXbp0ifr16/+qPy8vL5588smtXrO0H+fpfK6aqmeqAFAapfdvtwIAwGbsu+++cfjhhyfse+utt0o4DQAAAAAAlH1ZWVkxcODAhH1DhgyJFStWlGwgAMoM1xAAAAAAAAAAAAAAAAAAAAAAAAAAgPJl+PDh0bVr11i1alVS4+vVqxfjxo2LLl26pDkZAKnWoEGDGD9+fPTq1Sup8QsWLIh27drFK6+8kuZkAAAAQLrk5+fH4sWLkx7/448/FtmflZWVsL1+/fpFzvv888+TzrClNrf2F198scU1Nzdnc2sWJjc3N5YvX57U2M29Ft99913S665evbrI/sJe14iIOnXqFDn39ttvj4ULFyb9Z9iwYUXW29x6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAJQf1157baxcuTJhX8+ePeOZZ56JnJyctKx94YUXxl133VVo/xVXXBGbNm1Ky9oVzcKFCxO277XXXtGgQYMSTpMaS5cuTdjeunXrYtdu1KhRkfvmlnj44YcTtnfu3Dkuu+yylKxx6KGHxkMPPRTTp0+PkSNHRsuWLVNSd2vMnTs3+vfvn7CvZs2a8dxzz0XlypVLOFXhSvrYuOOOOyI/P79A+wEHHBB33313StZo0aJF3HHHHQn7nnzyyS36roXiKivHaUTFO1bLgkcffTRh+8CBA2OvvfZK2Tp33XVXzJ49Oy699NLIzs5OWd2IiBdffDHhMXfOOefE2WefXeD7Sr766qsYO3ZssdctD9tuS5SHc2tF2VcyuZ+UtD//+c8J2w8++OAYMmRIWrfFnXfeGXXr1i3Qvnz58pgwYcJm5+++++4J29P5HVjFdfPNNydsz8rKiiFDhsSOO+6YknUaNWoUQ4YMSdiXl5cXf/vb31KyTqodcMABcfvtt6ekVocOHeIPf/hDwr6nnnpqs9/VRXLKw7UNkrHzzjvHgw8+GHPnzo1+/fpFlSpV4t577035d+k1adKkQNvatWs3e84q68diRbnHzPT7kWRUtG3yyiuvxMyZMxP2XXnllXHeeecVq36XLl1Sdgzyn3NClSpVCrR/8MEHhb6OqTZo0KCE7Q0bNozjjjuuRDKUJ+XhnOMaVv68++67CdvPP//8qF27drFqX3vttbHPPvsUq8bPKvo+UB6fJ5c2pf09UEkaPnx4wu+Z79OnT0REnHHGGQX6xowZE4sWLSrWuqX5OE/Xc9VUP1MFgNKm9NxRAwBQav2///f/4rTTTktL7UsvvbTQvpEjR6ZlTQAAAAAAKM9OP/302G+//RL23XnnnSWcBoCyxDUEAAAAAAAAAAAAAAAAAAAAAAAAAKD8efvtt6N9+/axePHipMbXqFEjXnnllTj11FPTnAyAVNl///1jypQp0bJly6TGT5s2LVq2bBkzZsxIczIAAAAgnVavXh2bNm1KenxeXt5WrVOjRo0i+1euXLlVdZNRs2bNlK+9YsWKIvtr1aq1xTUjIn788cekx27utUhlraLssMMOWz13a9SpU6dE1wMAAAAAAAAAAAAAAAAAAAAAAAAAAAAgcxYtWhR9+vQptP+3v/1tjBs3LnbdddeUrbnNNtvEfffdFw8++GBkZWUlHHPPPffEqFGjUrZmRbdw4cJYsGBBwr6LLrqohNOkxueff56w/YILLihW3WrVqsULL7wQ9erVK1adnw0ZMiTmzJmTsO/222+Pbt26Fat+w4YNY9iwYZGdnR0RET169IjJkyfH2LFjo379+sWqvbWeeOKJeP755xP2HXbYYfGXv/ylhBMVrqSPjc8++6zQbXPRRRfFFVdcUaz6e+21V4wYMSK22WabAn3r1q2LW2+9tVj1t1RZOU4jKuaxWto99thj8f333xdor1atWjzzzDNRvXr1Yq9x3nnnxTnnnBO1atWKe+65Jz788MNo3bp1sev+bNOmTfHEE08UaO/YsWNceOGFBdoHDRoU+fn5xV63PGy7LVEezq0VZV/J5H5S0kaMGBHvvPNOwr4TTjghRowYsdnvnNoaf/nLX+Lcc89N2Ddo0KDYsGHDZmsU9t1QCxcuLFa2dJo4cWK88MILCft22mmnGDduXDRq1KhYa+yyyy4xbty4aNCgQcL+f/7znzFz5sxirZFOV1xxRZx//vnFqrHvvvvGc889F5UqVSrQt2nTprj77ruLVZ//Ux6ubZCMhx9+OC688MKoUqXKL2277rprDBs2LLbddtuUrNGyZcto0qRJgfbCPgv4b2X9WKwo95iZfj+SjIq2TfLz8+PSSy9N2JednR2PPvpoDBw48JfPSLbEb3/72xg5cmTKzhEU/jndoEGDSizD5MmTY9asWQn7+vXrV2I5yovycM5xDSt/Crunql+/ftx1111bXbdnz55x4403bvX8/1XR94Hy+Dy5tCnt74FK0vr16+Ppp58u0H7EEUfE/vvvH8cff3yBvscff7zY65bm4zwdz1XT8Uw13XJycuK+++4r9A8A/K8t/4QJAIAKo0GDBjFmzJi47bbb4qGHHoqmTZumtH7btm2jb9++Cfu+//77GDlyZErXAwAAAACA8q5+/fqF/mPlV155pdB/fAIAriEAAAAAAAAAAAAAAAAAAAAAAAAAAOXXjBkzok2bNvHFF18kNb5KlSrxzDPPxGWXXZbmZAAUV9euXePdd9+NXXfdNanxI0aMiPbt28e3336b5mQAAABAuuXl5ZXIOlWrVi2yf/369WVq7c3N2Wabbba4ZkREfn7+Vs1Ld62iVK9evUTW+VnlypVLdD0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAMuvFF1+Mu+++u9D+tm3bxqxZs2LAgAHF/t3ZJ554YsycOTP69+9f6JjJkyfHVVddVax1KOjtt99O2H711VdH+/btSzZMCrz++usJ27t06RK/+93vtqrmTjvtFBMnTozDDz+8ONF+JTc3N37/+98n7MvJyYmXX355q7+bdp999okJEybE7rvvXqCvYcOG8f33329V3VTo27dvfP311wn7/vCHP0Tnzp1LOFHhSvrYuOyyy2LlypUJ+/7+97/Hww8/HFWqVNniul26dIkpU6bEbrvtlrD/T3/6U8ybN2+L6xZHSR2nH3744VbV+m8V9VgtzdauXRs33nhjwr7DDjssJkyYEPXr19/q+pdeemn84x//+FXbQQcdFJMmTYqjjz56q+v+r0cffbRAW1ZWVoHsubm58fjjj6dkzfKy7bZEeTi3VoR9JdP7SUk766yzYvXq1Qn7jjvuuJg2bVp06dIlJWvttNNOMXLkyBg4cGDC/mXLlsXf/va3pGrVqlUrYfuPP/641flKwmWXXRbLly9P2Ne0adP46KOP4rjjjtuq2scff3x8+OGHsddeeyXs//bbb2PAgAFbVTudFi1a9Kv/f+SRR+Lvf/97VKpUaYtrde/ePd5///1o2LBhwv77778/Zs+evVU5Saw8XNtgc66//vqE3wd45JFHxptvvhm77LJLserXrl07HnvssYR9o0ePTqpGWT8WK8I9ZkTpv8+siNtk/Pjx8fDDDxfa/5e//CVmzJgR3bp1i+zs7M3WO/jgg2PMmDExZMiQX31/6rffflvq71NLs86dO0fjxo0LtK9duzaGDBlSolkGDRqUsL1Lly6x5557lmiWsq68nHNcw8qX5557rsB71J/16dMnbrnlli2uef7558cLL7zwq+vI559/vtUZI+wDEeXveXJpUxbeA5WkRx55pEBbVlZWPPvsswX+XsoPP/wQL730UrHXLM3HeVHPVbdGup6ppltOTk7079+/0D8A8L82/8kSAAAVUrdu3eLjjz/+5cOVWrVqxdixYxM+HNsau+22WzzzzDOFPuy8//77Y+PGjSlZCwAAAAAAKoJatWrFq6++GjvssEOBvvz8/EL/ET0AuIYAAAAAAAAAAAAAAAAAAAAAAAAAAJR/X375ZbRt2zamTZuW1PisrKy4++6749Zbb01zMgC21sUXXxyvvPJK1KxZM+k5J510UqxduzaNqQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP7jyiuvjCeffLLQ/ho1asStt94aX3/9dTz44IPRqVOn2GabbTZbNysrKw466KAYOHBgzJ49O4YPHx577bVXoeNnzJgR3bt3j02bNm3Vz0HhHn744YTtVapUiTfeeCNuvfXW2G233Uo41dZ75513YunSpQn7Hnnkkbj++uujcuXKSdWqUqVKXHrppTFjxoxo0aLFL+0rVqxIRdQYOXJkDB48OGFfpUqV4u67744PPvggfvOb3yRVr0aNGnHdddfFtGnTEh5P+fn5cfnll0d+fn5xYhfLypUr4/TTT4+8vLwCfVlZWfHUU09F3bp1M5CsoJI+NpYsWRL9+vUrtP+CCy6Izz//PM4444yk9uH99tsvRowYEWPGjInatWsnHDNx4sS4/fbbtzbyViup4/SGG25ISd6KeKyWdg899FCMHz8+Yd/BBx8cn3zySVx00UVJ70cREQcccECMHj067rnnnsjOzi7QP3Xq1Bg7duxWZ/5fc+bMKfRn+G+jR4+ORYsWpWzd8rDttkR5OLdWlH0lk/tJSZs/f36cf/75Ce+HIiL23nvvGDNmTLzxxhvRu3fvqFKlyhbVz8rKipYtW8agQYPiiy++iB49ehQ69oILLojly5cnVbdSpUoJ23fffffo27dvif3ZZZddtmh7LFq0KPr06VPodbVevXrx0ksvxfjx46N3795RvXr1IuvVqFEjevfuHRMmTIgRI0YUeu+am5sbZ5xxRixbtmyL8paEf/zjH/HFF1/8qu2KK66ITz/9NHr16hVZWVmbrXHAAQfEyy+/HK+88krUqlUr4Zj58+en7H6M/1Merm2wOR999FE89NBDCftat24dn376aVx//fVb9fnB0UcfHVOmTIn9998/Yf+wYcOSqlPWj8WKco8ZUfrvMyviNrn00ktj8uTJhfbvv//+MWrUqFi6dGk888wzcd1118X5558fvXr1irPPPjsGDBgQDz30UHz55Zcxbdq06NKlS4Ea/fr1i3Xr1qXzxyjXCju/vfDCC7Fq1aoSzfLUU0/Fhg0bCrRnZWVF3759SzRLeVAezjmuYeXLpk2b4q677iq0/5prrolRo0YV+Qz5ZwcffHCMHj06HnnkkV+9DlOnTo0XX3yx2Fkr+j5Q3p4nlzZl4T1QSZo1a1a8//77BdoPOOCAAm3PPvtswnuFrVFaj/OinquWtmeqAFCaJH/FBgCgwujcuXOMGjWqQPsuu+wSU6ZMifPOOy9GjBix1fXbtm0b//rXv6J+/foJ+5csWRJ33nnnVtcHAAAAAICKJDs7O3r27Bl33XVXoX9R+YknnoiZM2eWcDIASjvXEAAAAAAAAAAAAAAAAAAAAAAAAACAiuW7776Ljh07xosvvhidO3dOas6AAQOiQYMGcd5550Vubm6aEwKQjOzs7Ljnnnuif//+Sc/ZuHFjXHjhhZGfn5/GZAAAAEB5tGbNmiL7q1atmra1161bV2T/Nttss8U1Nzfnp59+2uKaZdXatWszHQEAAAAAAAAAAAAAAAAAAAAAAAAAAACAci4/Pz/69OkTmzZtinPPPbfQcXXq1IkLL7wwLrzwwti4cWPMmTMn5s2bF8uXL481a9ZEfn5+bLvttlGrVq3YfffdY++9946aNWsmleHDDz+Mo446Kn744YdU/Vj8l0mTJsXEiROjXbt2BfpycnJiwIABMWDAgFi4cGF8/fXXsXr16sjLyyswdsmSJdGnT58SSFy09evXx8033xx33XVXgb7s7Oy46aabol+/fvHUU0/FhAkTYvbs2bFixYpYt25dbLfddlG/fv1o0qRJHH300dG9e/fYcccdf1UjPz8/zj777HjppZdSkrdfv36x9957R5s2bRL2H3LIIfH666/H999/H2PGjImPPvoovvvuu1i2bFlERGy33Xaxxx57RMuWLeM3v/lNbLvttoWu9de//jXefPPNlOQujokTJ8Zf//rXGDhwYIG+HXfcMQYPHhw9evTIQLJfy8Sx8dxzz8X++++fcNtEROy2227x1FNPxf333x+vv/56TJkyJRYvXhzLli2L6tWrR4MGDWKvvfaKY445Jpo2bVrkWvPmzYvjjz8+I995XFLH6ffff5+yzBXxWC3tTj755Jg6dWrsuuuuBfrq1asXDzzwQNxwww0xevToeOONN+Kbb76J7777LtauXRtVqlSJmjVrxq677hoHHnhgdOvWLQ4//PBC1/r222+jd+/eCY/x4njkkUeiQ4cOmx2TauVh222J8nBuLe/7SmnYT0ra0KFDo1atWkW+bp07d47OnTvH2rVrY/LkyTFlypSYP39+7LLLLr8aV7t27ejfv3/sscce0bRp02jXrl1st912m80wcODAGD58eLF/lsMPP7zI80Cqde/ePb755pstmjNy5Mi44oor4u677y50TPv27aN9+/axcePGmDVrVsyZMydWrFgRGzZsiKpVq0bt2rWjSZMmsd9++0VOTs5m1+zXr1+89dZbW5SzpKxbty7OPPPMGD9+fFSpUuWX9r333juGDRsWS5cujddeey2mTZsWixcvjh9++CFq1qz5y/mwa9eumz0f/vTTT3H88cfH6tWr0/3jVEjl4doGm3PFFVdEy5Yt49BDDy3QV6NGjbjpppvi+uuvj3fffTfefvvt+Oyzz2L+/PmxevXqWLt2bWRlZUX16tWjdu3a0bhx42jRokV069Yt9tprr0LXHDlyZEyaNCnpjGX9WCzv95gRZec+s6Jtk40bN0bXrl1j7NixCY/xn22//fZx2mmnbXH9v/zlL/Hyyy8XJ2KFVr9+/ejZs2fCvkGDBpVwmohly5bFyy+/HL169SrQd84558T1118fGzduLPFcZVl5OOe4hpUvd911V/Ts2TPhs5iIiG7dukXXrl3j/fffj9dffz2+/vrr+P777yMrKyvq1KkTBxxwQHTp0iUOOuigAnPXr18f5557bpx++ukpyVqR94Hy9jy5NCoL74FK0iOPPJLUZ46PP/54Stctjcd5Uc9VS+MzVQAoLSpnOgAAAKXPuHHjYurUqXHYYYcV6KtTp07861//ivHjx8e9994bo0ePjp9++mmzNbOzs6NVq1YxYMCAQh+y/ey8886LNWvWbHV+AAAAAAAoj7bddtu48MILIyJ++Qfde++9d7Ru3ToaNGhQ6LylS5fGVVddVVIxASiFXEMAAAAAAAAAAAAAAAAAAAAAAAAAAPjZjz/+GMccc0w89dRTccoppyQ1p0+fPlG3bt04+eSTk/r+QgDSp1atWvHcc8/FMccck/Sc5cuXx0knnRRvv/12+oIBAAAA5dayZcuK7N9uu+3Stvbq1atTvnbt2rWL7F+1atUW1yyrli9fXmT/7bffHtOnT0/ZegsWLEhZLQAAAAAAAAAAAAAAAAAAAAAAAAAAAADKjvz8/Pjd734XM2bMiNtuuy2qVq1a5PicnJxo1qxZNGvWrNhrP/7443HJJZfE2rVri12Lwp111lkxY8aMqFmzZqFjGjVqFI0aNSq0f/78+WlItnUefPDBOOuss6JFixYJ+3faaacYMGBADBgwYItrDxgwIF5++eXiRvzF+vXro1u3bjFq1Kho27ZtoePq1asXp59+epx++ulbtc6gQYPiuuuu29qYKXfjjTfGUUcdFa1atSrQ171797jkkkvivvvuy0CyX8vEsXHddddFVlZWXHvttYWO2W677eLkk0+Ok08+eYtq/+zTTz+Nrl27bvY7LdKpJI7Tli1bFjfmLyrqsVqafffdd3HUUUfFW2+9FTvvvHPCMQ0aNIg+ffpEnz59tnqdJUuWxNFHHx1ff/31VtcozPDhw+O+++6LOnXqJOxftGhRjBo1KuXrlodtt6XK+rm1vO8rpWU/KWmPPvporFu3Lh5++OGoVq1aoeOqVasWnTp1ik6dOiXs33nnnbfovik3Nzf+8Ic/xN///vctzlyW3XPPPZGdnR133nlnZGVlFTouJycnmjdvHs2bN9+qdXJzc+OSSy6JQYMGbWXSkvH+++9Hv3794rHHHiuwPerWrRtnnHFGnHHGGVtV+6effooTTzwxZsyYkYqoFKKsX9tgczZs2BDHHHNMvP7663HwwQcnHJOTkxMdOnSIDh06FHu9pUuXxoUXXrjF88rysVje7zFL0/uRzamI22TFihXRuXPnePLJJ6Nnz54pq3vHHXfE9ddfn7J6FdE555wTOTk5BdrnzJkT77zzTgYS/ee9U69evQq0169fP44//vgYNmxYBlKVXeXhnOMaVr7k5ubGKaecEtOnT4969eolHJOdnR1t2rSJNm3aJF03Pz8/+vXrF5988kmqolb4faC8PU8ubcrKe6CSMnTo0Lj77rujVq1ahY75+OOP48MPP0zpuqX1OC/quWppe6YKAKVF5UwHAACg9MnLy4vTTz893n333ahbt27CMT9/ALdx48aYNm1afP7557FgwYJYvXp1rFu3LiIitt9++9hhhx1it912iyOOOCK22267za596623xiuvvJLSnwcAAAAAAMqDmjVrxp133rlFc/Ly8uK0007zj18BKjjXEAAAAAAAAAAAAAAAAAAAAAAAAAAA/tvGjRvj1FNPjcWLF8dll12W1JwePXrEm2++Gd27d48ffvghzQkBSGT33XePV155Jfbbb7+k58yZMye6desWX3zxRRqTAQAAAOXZ8uXLi+xv0qRJ2tZevHhxkf177733Ftfc3JzNrVmebO61/fTTT+PZZ58toTQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlHf33ntvjB8/Pp566qk44IAD0rrW0qVLo3///jF06NC0rsN/fPnll3HiiSfGCy+8ENttt12m4xTbhg0b4phjjon33nsv9thjj5TU3LhxY/Tv3z8eeeSRlNT7bytXroyjjjoqHnjggTj33HNTWjsvLy9uvfXWGDhwYErrFldubm6cdtppMX369KhZs2aB/ttvvz3Gjx8fM2fOzEC6/5OpY2PgwIExb968uOeee6J69eoprT1q1Kg444wzYsWKFSmtu6XK2nEaUTGP1dJuzpw50bp16xg+fHi0bNky5fU//PDD6NmzZyxYsCDltSMi1q9fH08//XRceumlCfv/+c9/Rl5eXlrWLuvbbmuU5XNred9XPv7445TXLSueeuqpmDZtWgwdOjT233//tK/32WefxVlnnRUffPBB2tcqje66666YN29ePPbYY7HDDjukvP53330Xffr0idGjR6e8djr885//jNzc3Bg0aFDk5OSkpOaSJUuiV69eMXHixJTUo2hl+doGyVi6dGl07NgxnnzyyTj++OPTts6CBQviqKOOioULF27V/LJ6LJb3e8zS9n5kcyriNlm1alUcf/zx0bdv37jllluKdX+2bNmyuPTSS31/Zwr07ds3YfugQYNKOMn/GTt2bHz99dex6667Fujr169fDBs2LAOpyrayfs5xDSt/Fi1aFEcccUSMGjUqGjduXOx6eXl5cckll8TgwYOLH+5/VOR9oLw9Ty6Nysp7oJKwdu3aGDJkSFxwwQWFjnn88cfTsnZpPM5T/Vw13c9UAaA0yM50AAAASqc5c+ZEt27dYuXKlUWOy8nJicMPPzzOOuusuPbaa+Ovf/1r3HXXXXHXXXfFDTfcEBdffHH06NEjqQ9LH3roobjmmmtS9SMAAAAAAECFlp+fH/369YuxY8dmOgoAZYxrCAAAAAAAAAAAAAAAAAAAAAAAAABA+Zefnx+XX355DBgwIPLz85Oa07p165g4cWLsvPPOaU4HwP86/PDDY/LkybHffvslPWf8+PHRqlWr+OKLL9KYDAAAACjv5s+fX2R/mzZt0rb2xx9/XGT/EUccscU1Nzdn1qxZW1yzrPrqq6+K7G/RokUJJQEAAAAAAAAAAAAAAAAAAAAAAAAAAACgopgxY0YcdNBBcdppp6Xle9ZWrFgRAwcOjN133z2GDh2a8voU7o033oiWLVvGO++8k+koKbFkyZJo1apVjBo1qti1Zs6cGS1btoxHHnkkBckSW7duXfzud7+L4447LubNm5eSmnPnzo0uXbrEwIEDU1Iv1ebNmxf9+/dP2Fe1atUYOnRobLvttiWcqqBMDjOc/wABGRRJREFUHRuPPfZYHHDAAfHaa6+lpN63334bZ555ZvTo0SNWrFiRkprFVdaO04iKeayWdgsWLIh27drFwIEDY+3atSmpuXbt2hgwYEC0bNkyFixYkJKahSlsn83Pz49Bgwalde2yvu22Rlk+t5bnfaWi+/TTT+Oggw6Kc845J77++uu0rLFgwYK4+uqro3nz5vHBBx+kZY2y4qWXXopmzZrFU089FXl5eSmpmZubG4MHD45mzZrF6NGjU1KzpDz55JPRpk2bmDNnTrFrDRs2LPbbb7+YOHFiCpKRrLJ8bYNkrF69Ok444YTo3bt3yq+T+fn58fTTT8dhhx0Ws2fPLlatsnoslud7zNL4fmRzKuo2eeSRR2L33XePgQMHxty5c7do7nfffRc33XRTNG3aNJ599tk0Jaw4unTpEnvuuWeB9k2bNsUTTzyRgUT/kZ+fH4MHD07Y16lTp2jSpEnJBionyvo5xzWs/Jk9e3a0bNmy2O+rv//+++jatWs8+OCDKUpWUEXeB8rb8+TSqKy8ByoJRT3z27hxYzz99NNpW7s0Huepeq5aUs9UASDTsjMdAACA0mvq1Klx2GGHxWeffZbWdTZu3BhXXXVVXHTRRWldBwAAAAAAKorVq1fHKaecEo8++mimowBQxriGAAAAAAAAAAAAAAAAAAAAAAAAAABULLfddlucc845sWnTpqTGN2vWLN59993Yd99905wMgJ+dcsopMW7cuKhfv37ScwYPHhxdunSJH374IY3JAAAAgIpgwoQJRfa3aNEiDjzwwKTrNWrUKPbcc8+kxk6dOrXI/v322y8OP/zwpNeuV69e9OzZs8gxU6ZMSbpeWTdx4sQi+7t161ZCSQAAAAAAAAAAAAAAAAAAAAAAAAAAAACoSPLz82PIkCGxzz77xDHHHBODBw+OFStWbHW9jRs3xquvvhpnn3127LrrrnHLLbfEmjVrUheYpH3++efRvn37aNWqVfzjH/+ImTNnRl5eXqZjbbXvv/8+evToEb17997s73dP5MMPP4zf/va30bx585g+fXrqAyYwcuTIaNq0aZx++ukxadKkyM/P3+IaM2bMiAsuuCCaNm0ab731VhpSps6TTz4Zzz33XMK+ffbZJ+65554STpRYpo6NL7/8Mo455pg47LDD4vnnn4+1a9ducY3p06fHBRdcELvvvns8/fTTaUhZPGXxOI2oeMdqabdx48a45ZZbYo899oibb745FixYsFV1vvnmm7jhhhtil112idtuuy1yc3NTnLSgWbNmxfvvv1+gfezYsTF//vy0r1+Wt93WKqvnVvtK+ZaXlxeDBw+OJk2aRM+ePWPo0KFbtW/+txUrVsTIkSOjd+/esfvuu8ff/va32LBhQ4oSl23fffddnHXWWdGsWbO47777YunSpVtV5/vvv4977703mjVrFuecc04sW7YsxUlLxgcffBD77bdfXHjhhTFv3rwtmrtu3boYNmxYHHzwwXHyySeX2W1Q1pXVaxtsiRdeeCH22GOP6N27d7zxxhuxfv36ra71ww8/xOOPPx6tWrWKM888MxYvXpySjGXxWHSPWfpU1G3y448/xi233BJNmjSJgw8+OPr37x+PP/54vPHGGzF16tT47LPP4qOPPooJEybEU089Fddcc020bt06dtxxx7jxxhsT3oNUrVo14VqbNm1K949TZvXr1y9h+6hRo2LJkiUlnObXHnvssYSfv2VlZcUFF1yQgUTlQ1k+57iGlU/Lly+Pbt26xZFHHhnvvffeFs1dsWJF3H777dGkSZMYO3ZsmhL+n4q8D5S358mlVVl4D5RuH374YXz00UcJ+0aNGrXVn+klqzQe58V5rpqpZ6oAkClZ+Un+TZ6srKx0ZwEAoJTaZptt4qqrroqrr746qlevntLaEydOjEsvvbTQD7gAAAAAAEiNIUOGxG9/+9sC7S+++GKccMIJGUi0Zcp6/lSoX7/+Zv/Rypo1a+LZZ5+NP/3pT7Fw4cISSgZAaecaAgAAAAAAAAAAAAAAAPAfSf5a9oT8rnagMAceeGAceOCBEfGf88y8efPi/fffL9Y5ByBZx3Q7Jo488shMx6AC+fLLL+PBBx7MdAyAtDn33HNj32b7ZjoGFcS7774bI/41ItMxANLm2oHXxvbbb5/pGFQQ/xr+r3jvvfcyHQPKhe7du8fzzz8f1apVS2r88uXLo3v37vH++++nOVnFVbt27Rh43cBMx6CCufOOO2Px4sWZjsF/ue666+Kmm25K+u+v5Ofnx7XXXhu33nprmpNB2bPnYRG9/pzpFFQkt3XNdAKA8i0rKysOPfTQ2HvvvX+5X545c2bMnDkzw8kA/qNZs2Yxa9asIsecdNJJ8a9//avQ/pYtW8bkyZML7V+xYsUWPZe76KKL4oEHHii0/4033oguXboUaK9cuXKsXLmyyM+PJ02aFB06dIjc3NzN5njjjTeiQ4cO8dhjj8Wf/vSn+Pbbbwsdm5WVFYsXL4769esXOmbGjBnRqlWrWL9+/WbXHj58eJx44omF9ufn58fOO+8cixYtKtCXytfj5JNPjqFDhxbaP3369GjRokVSta699tq4+eabC+1/4YUXonfv3gn7qlatGqtWrYoqVaoUOn9z++n/OvbYY2PXXXctcl+D0uamP98U2267rc/IAUrYz3/P7IH7H4j58+dnOg5AhXHRxRfFHnvsEY899lj8+7N/ZzoOQIXw879d9HffAUrWCSeeEG3atIlXR70a48aNy3QcgArj59+L9dZbb8XoV0dnOg4AAAn4Xe1AOvhd7UBp06lTp+jWvVumY1AB+WwUqEhcb8kE11qgIvHdZGSCv3MJVCSutWSKf2MGVCRd+ke06JHpFFQ0Y+6LmD4q0ykASpbf1V66+Du1kDo5OTlx0EEHRfPmzaN58+ax1157Ra1atWK77baLWrVqRXZ2dqxevTpWrVoVK1eujAULFsT06dNj+vTp8eGHH8aqVasy/SNQiOrVq8eOO+4YtWvXju233z5ycnISjvvpp59K/bOrpk2bRrt27aJ169bRpEmTX/1Mq1evjhUrVsRnn30WH330UYwaNSq++OKLTEeOhg0bRseOHePwww+PJk2axC677BI1atSIbbfdNvLy8mLlypWxYsWK+Pe//x0ffvhhvPXWW/HZZ59lOnaFkIljY5tttokuXbpEy5Yt48ADD4xGjRrFdtttFzVq1Ij169fHypUrY/ny5TFr1qyYMWNGjBkzJr766quUrF1SyuJxGuFYLY0OPfTQaNeuXRxyyCGx2267Rf369aN69epRuXLl2LBhQ6xatSpWrFgRs2fPjlmzZsWbb77pfdn/r6Jtu4pwbk2XiravlLQqVarEgQceGIcddli0aNEidtppp2jQoEHsuuuuv/pOqPXr18f7778fCxcujIULF8b8+fPj3XffjRkzZvh8I0mVKlWKQw45JNq3bx/77bdfNG7cOHbYYYeoUaNGVKlSJTZs2BA//vhjLFu2LObOnRuffPJJTJgwIT788MOkvverrDnkkEOiS5cu0bx582jcuPEv58R169bFypUrY/HixTFz5syYMmVKvPbaa7FmzZpMR+Z/uLZREVSrVi06dOgQBx54YOyzzz7RuHHjqFmzZtSoUSOqV68e+fn58eOPP/7yeeTcuXN/eRYzadKk2LRpU9ozOha3jnvMgmyTLZednV3ofVqzZs18JgNFcM7ZerZd6u2yyy5x9NFHR8eOHWOnnXaKevXqRZ06dWLTpk2xYsWK+O677+Kjjz6KSZMmxejRo2PDhg0ZzVuR94Hy9Dy5tCoL74HS4Y033ojOnTsXaD/uuONi5MiRJZ6ntB3nv/vd78rcM9VUGTduXHTs2PGX//d7d8uurKysOOyww2Kvvfby92mBpCXzDLRyCeQAAKCMW7duXfzlL3+Jhx9+OM4666z43e9+F82aNdvqeuvXr4/Ro0fHAw88EG+88UYKkwIAAAAAUJhFixbFv//97wLtCxcuzECaLVfW86dCbm7ur7bB+vXrY82aNbFw4cKYM2dOvPfee/HWW2/F2rVrM5gSgNLINQQAAAAAAAAAAAAAAAAAAAAAAAAAgM0ZNWpUdO7cOUaNGhV16tTZ7Pg6derEm2++Gaecckq88sorJZAQoGKpUqVKPPbYY3HGGWckPeenn36KM888M4YPH57GZAAAAEBFs2nTphg1alT07t270DFt27aNl156Kc4888z44YcfEo6pWrVqPPnkk9G5c+eIiLjgggvirLPOigceeCD++te/xvLlywvMyc/Pj2effTYuv/zyQtc+6KCDYuzYsXHyySfH4sWLE46pXr16PPzww3HiiScW8ZNGvP3227Fo0aIix5Qn69evj9dffz2OPfbYQsc89NBDMX369Jg3b95m67Vr1y6effbZqFGjRvTu3TvOOeec+PLLL1MZGQAAAAAAAAAAAAAAAAAAAAAAAAAAAIByauPGjfHBBx/EBx98kOkopNiaNWviiy++yHSMlJg9e3bMnj07HnvssUxHSdrixYvjueeei+eeey7TUfgfmTg21q1bFyNHjoyRI0eW6LolqSwepxGO1dLIfcnWq2jbriKcW9Olou0rJW3Dhg0Jt3G3bt1i1KhRv/z/nDlzomPHjiWcrnzJzc2NKVOmxJQpUzIdpVSYNm1aTJs2LdMxKAbXNiqCtWvXxujRo2P06NGZjlIox+LWcY9ZkG2y5WrVqlVoX6LvXgX+j3PO1rPtUu+bb76JQYMGxaBBgzIdJSkVeR8oT8+TS6uy8B4o1Ro1ahSdOnUq0L5kyZJ49dVXM5Co9B3njz32WJl7ppoqlSpV+uW/c3NzM5gEgNKqcqYDAABQdixdujT+/ve/x9///vfYeeedo2PHjtGiRYto3Lhx7LHHHlGrVq2oXr16bLvtthERsX79+vjpp5/iu+++i2+++SZmzpwZU6ZMiXHjxsWaNWsy/NMAAAAAAFQsv//97+P3v/99pmNstbKePxWWLVsW++67b6ZjAFAGuYYAAAAAAAAAAAAAAAAAAAAAAAAAAJCM999/P9q1axevv/567LLLLpsdX61atXjxxRejb9++8fjjj5dAQoCKYYcddogXX3wx2rVrl/ScxYsXx3HHHRdTp05NYzIAAACgorrllluid+/eRY7p3r17zJ8/P5544ol46623YuHChbFx48Zo1KhRHHbYYdG3b9/YcccdfzVn2223jauuuir69u0bd9xxR9x+++2xbt26X425/fbb46KLLooqVaoUuvYRRxwRc+fOjSeffDJef/31+OabbyI3NzcaNmwYHTp0iHPPPTfq16+f1M9Z0dx2221x7LHHFtpfv379mDx5clxzzTXx9NNPF3h9IiIOOuigOO+88+Kiiy6K7OzsiIjo0KFDfPzxx3H11VfH/fffn7b8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJAKTZs2Tdi+cePGWLJkSQmnAQBga5x11lm/fN/6f3v66acjNzc3A4koTWrXrv3Lf69atSpzQQAotSpnOgAAAGXTggUL4umnn46nn34601EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAFPjss8+iTZs28frrr0ezZs02O75SpUoxaNCgaNiwYdxyyy0lkBCgfNt3331j5MiR0bhx46TnTJ8+PXr06BELFy5MYzIAAACgIps+fXq88sor0aNHjyLH1apVKy655JK45JJLtqh+rVq14rzzzou//e1vBfoWLVoUt956a9xwww1F1qhWrVr069cv+vXrt0Vr/+zll1+ON954Y6vmlmUTJ06MSZMmRdu2bQsdU7du3Xj00Ufj/vvvj08++SSWLl0a+fn5Ua9evdh5552jQYMGCedVr1497rvvvujdu3ecc845MW/evHT9GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQLC1btkzY/u9//7uEkwAAsDWysrKib9++CfseeeSREk5DaVOjRo1o2rTpL/+/ePHiDKYBoLTKznQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASocFCxZEu3bt4r333ktqfFZWVtx8881x7733RlZWVprTAZRfXbp0iffeey8aN26c9JyRI0dGu3btYuHChWlMBgAAABBx/vnnx6JFi9JW/4orrogNGzYk7Pvzn/8c06ZNS9vaixcvjr59+6atfml39tlnx8qVKzc7rmrVqnHIIYfE0UcfHV27do1DDjkkGjRosNl57du3j3POOScVUQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgLY466qiE7en8XlUAAFKnR48esfvuuxdonzBhQnz++eclH4hS5c4774wqVar88v9TpkzJYBoASqvsTAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACg9Pjhhx+ic+fO8corryQ955JLLokhQ4ZETk5OGpMBlE8XXHBBvPrqq7HddtslPeeuu+6K448/PtasWZPGZAAAAAD/sXjx4jj++ONj3bp1Ka999913x7/+9a9C+zdt2hTdunWLL7/8MuVr//jjj9GtW7dYsmRJymuXFXPnzo2zzz478vPz01L/jTfeiD/+8Y9pqQ0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAxVK9evWU12zUqFF07949Yd/rr7+e8vUAAEi9G2+8MWH7PffcU8JJKE0qV64cDz/8cPTt2/dX7YMHD85MIABKtexMBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKB0+emnn+L444+PwYMHJz3nlFNOidGjR0eNGjXSFwygHMnOzo6///3v8fDDD0flypWTmrNp06bo169fXHnllZGXl5fmhAAAAAD/Z+rUqdGxY8dYsGBBymree++9ccUVV2x23HfffRdt27aNadOmpWztBQsWxBFHHBEfffRRymqWVS+99FKcdNJJsWbNmpTWffnll+PYY4+N3NzclNYFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoGLJzs6OG264IebMmRP169dPae2rr746KlWqVKB93bp18dprr6V0LQAAUu/MM8+MQw45pED7vHnzYsSIERlIRGnQoEGDeOutt+KCCy74VfuQIUPi7bffzkwoAEq17EwHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoPTJzc2Nc845J/72t78lPadz587x9ttvR/369dOYDKDsq169erz44otxxRVXJD1n5cqV0a1bt/jHP/6RxmQAAAAAhZs8eXK0aNEiXnrppWLVWblyZZx++ulx2WWXJT3n22+/jbZt28bNN98cGzZsKNb6TzzxRDRv3jymT59erDrlyYgRI6J169YxY8aMYtdavnx5XHzxxdGzZ89Yt25dCtIBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUFHtsssuMX78+PjTn/4UO+64Y/zrX/+KbbbZJiW1O3fuHBdffHHCvqFDh8aKFStSsg4AAOnRpEmTuOeeexL23XTTTZGfn1/CiSgNGjVqFB999FEcccQRv2p/7bXX4txzz81QKgBKu+xMBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKD0uvrqq+Pyyy+P/Pz8pMYfcsghMWnSpNhjjz3SnAygbGrUqFFMnDgxjj322KTnfPnll9GmTZsYO3ZsGpMBAAAAbN7SpUvj+OOPj+bNm8ewYcNi/fr1Sc9dvnx53HnnnbHnnnvGs88+u8Vrr1+/Pq677rrYe++945577okVK1YkPfenn36KZ555Jlq0aBF9+vSJZcuWbfH65d3HH38czZs3j549e8bkyZOTfi7ws7lz58Y111wTe+65Zzz44INpSgkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbKn33nsvOnTo8MufPn36ZDoSAAAk5YQTToiZM2dGu3btfmlr27ZtjBkzJurWrVus2kceeWQMHz48srKyCvRt2rQpbr755mLVBwAgvVq2bBlvvvlmbL/99gX6Pvvss3jqqacykIrSYOHChfHee+/9qm3QoEFx3HHHxbp16zKUCoDSrnKmAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFC63XPPPfHdd9/F4MGDo0qVKpsd36RJk3j33Xeja9euMWPGjBJICFA2HHzwwTFy5MjYaaedkp7z3nvvRc+ePeP7779PYzIAAAAgVT799NPIysoqVo0pU6YUu8Z/e/DBB+PBBx9MWb2IiBkzZsTJJ58cVatWjdatW0fHjh1jt912i7p168YOO+wQVatWjZUrV8ayZcvi448/jsmTJ8ebb74ZmzZtKvbaX331VVx++eXx+9//Ptq1axeHH354HHDAAdGwYcOoVatWZGdnx6pVq2LZsmUxa9asmDp1arz55puxbt26rVovla/H888/H88//3xKat1yyy1xyy23pKTWf3v55Zfj5Zdfjh122CE6duwYbdu2jQYNGsQOO+wQO+ywQ1SqVCnWrFkTK1eujC+//DJmzZoV48aNi9mzZ6c8CwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQfD/88ENMmDAh0zEAAGCL7b333lG7du0C7UcccUTMmjUrrr766nj66adj48aNSdesU6dOXHXVVXHVVVdFTk5OwjH33HNPzJkzZ2tjAwCQIllZWZGTkxNZWVlRvXr1qF+/fhx88MHRu3fvOPbYY6NSpUoJ51144YWRl5dXwmkpTfr06RMHHHBA7LLLLnH55ZfHP/7xj0xHAqCUq5zpAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJR+Q4YMiaVLl8a//vWvqFGjxmbHN2zYMCZMmBA9e/aMt99+O/0BAUq5E088MZ588smoXr160nOefvrp+N3vfhcbNmxIYzIAAACArbd+/fp4++23M/I5cG5ubowfPz7Gjx9f4mtXBMuWLYvhw4fH8OHDMx0FAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgArojjvuiBNOOCFatWpVoK9+/frx+OOPx6233hqvvPJKTJgwIT7//PNYsGBBrFmzJtavXx+VK1eOOnXqxA477BAtWrSII488Mrp37x41a9YsdM2PPvoorr322nT+WAAAJKl3794xdOjQLZpz//33x/jx49OUiLJi9erVcfzxx0elSpXi448/znQcAMqAypkOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQNkwduzY6NSpU7z66qtRr169zY6vVatWvPbaa3H66afH8OHDSyAhQOl09dVXxy233BJZWVlJjc/Pz48bbrgh/vKXv6Q5GQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQOmTm5sbPXr0iHfffTf22muvhGPq168f5557bpx77rnFXm/evHnRrVu32LBhQ7FrAQBQ8saNGxdXXnllpmNQSnz66aeZjgBAGZKd6QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUHR988EG0bds25s+fn9T4qlWrxtChQ+PCCy9MbzCAUignJyf++c9/xl//+tfIyspKas66devi1FNPjb/85S9pTgcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFB6LV26NNq3bx/vvvtuWtf54IMPok2bNrF48eK0rgMAQHq8+uqr0aNHj9i4cWOmowAAZVB2pgMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQtsyZMydat24dM2fOTGp8pUqV4sEHH4w//elPaU4GUHpsv/32MXbs2OjTp0/Sc7777rvo1KlTDB06NH3BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyojFixdHx44d48Ybb4y1a9emtPb69evjlltuidatW8eSJUtSWhsAgPRbsmRJXHjhhdG9e/eU3ysCABVHdqYDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUPYsXrw42rVrF+PGjUt6zg033BD/+Mc/IjvbV2wD5VuTJk1i8uTJ0aFDh6TnzJo1K1q1ahXvv/9+GpMBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACULRs3boybbrop9tprr7j55ptj0aJFxaq3cuXKuOeee2LvvfeOgQMHxqZNm1KUFACAdMjLy4s1a9bEN998E++8807cfffd0aNHj9h5553j4YcfznQ8AKCMq5zpAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJRNq1evjq5du8YzzzwTvXr1SmpO3759o169enHqqafG+vXr05wQoOS1b98+RowYEXXq1El6zpgxY6J3796xatWqNCYDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAouxYtWhTXXXdd3HDDDXHwwQdHx44d47DDDos999wzdt9996hVq1ZUqVLlV3N++umnWLhwYcydOzemTZsW48aNi/Hjx8fGjRsz9FMAAJCM559/Pp5//vlMxwAAKoDKmQ4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABA2bVhw4Y45ZRT4r777ouLLrooqTknnHBCvP7669GzZ89YuXJlmhMClJyzzz47HnnkkahSpUrScx5++OHo379/5ObmpjEZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABA+ZCXlxcffPBBfPDBBwX6KlWqFFWrVo38/PxYt25d5OfnZyAhAAAAAGVFdqYDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAULbl5eXFxRdfHDfccEPSczp06BATJkyIhg0bpjEZQMnIysqKW2+9NQYPHhxVqlRJak5ubm70798/LrzwwsjNzU1zQgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgPIvNzc31q5dGz/99FPk5+dnOg4AAAAApVx2pgMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQPvz5z3+Ovn37Rm5ublLjDzzwwHjvvfdir732SnMygPSpVq1aDB8+PAYMGJD0nNWrV0ePHj3igQceSGMyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAw2ZkOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQPnx6KOPRq9evWLdunVJjd99993jvffei5YtW6Y5GUDq7bjjjjFhwoQ44YQTkp7z9ddfR5s2beK1115LYzIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoCjZmQ4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABA+fLiiy/G0UcfHStWrEhq/A477BBvvfVWdO3aNb3BAFLooIMOiilTpsQhhxyS9JwpU6ZEy5Yt45NPPkljMgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgc7IzHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDyZ8KECdG+ffv49ttvkxpfvXr1ePnll+OMM85IczKA4uvRo0dMnDgxdt5556TnvPDCC9GhQ4dYsmRJGpMBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMnIznQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyqePP/44WrduHZ9//nlS43NycuLJJ5+MK6+8Ms3JALbe5ZdfHi+++GLUqFEj6Tl//etfo3fv3rFu3bo0JgMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkpWd6QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUX1999VW0bds2pk6dmtT4rKysuPPOO+OOO+5IczKALVOpUqV46KGH4q677opKlSolNWf9+vXRp0+fuPbaa9OcDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADYEtmZDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAED5tnTp0ujUqVOMGTMm6Tm///3v48knn4zKlSunMRlAcmrXrh2jR4+Ofv36JT1n6dKl0blz53jiiSfSmAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2BqVMx0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA8m/NmjXRo0ePGDx4cJx22mlJzTnzzDOjbt260atXr1i7dm2aEwIktueee8aoUaNin332SXrOv//97+jevXvMmzcvjckAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAo76pXrx61a9eOSpUqJez/+uuvSzgRAAAAAAAAQPlROdMBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqBg2btwYp59+enz33Xdx+eWXJzXnmGOOibfeeiu6desWy5cvT29AgP/Rtm3bePHFF6Nu3bpJz3nzzTejV69esWLFivQFAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANiMcePGJWzv1KlTCSeBLffAAw9Es2bNCrRfeOGF8e9//zsDifhfZfEcUxYz8x9eOyqSxo0bR/fu3aNDhw7RqlWrqF+/fuTk5BQ5Jysrq4TSOR4BAAAAAACA8qdypgMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQsVxxxRXx7bffxq233hpZWVmbHd+qVauYNGlSHH300fH111+XQEKAiNNPPz0ee+yxqFq1atJzBg0aFBdeeGFs2rQpjckAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANq9jx46ZjgBb7eCDD47DDz+8QHutWrUykIZEyuI5pixm5j+8dlQEzZo1ixtuuCF69+4d2dnZmY5TKMcjAAAAAAAAUN6U3ie0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlFu33XZbnHPOObFp06akxu+zzz7x7rvvxn777ZfmZAARN910Uzz11FNRtWrVpMbn5eXF//t//y/OP//8pM9rAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcMopp8SHH34Yp5xySmRnZ2c6DgAAAAAAAECF4iktAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGfHEE0/E8ccfH2vXrk1qfKNGjeKdd96Jtm3bpjkZUFFVrVo1hgwZEtdff31kZWUlNWfNmjVx0kknxR133JHmdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJQnF1xwQQwZMiSqVq2a6SgAAAAAAAAAFVJ2pgMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQcY0aNSo6deoUy5YtS2r89ttvH2PHjo1jjz02zcmAiqZevXoxbty4+O1vf5v0nIULF0b79u3jxRdfTF8wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyp0DDjgg7rnnnsjKytrs2Nzc3Fi3bl3CPwAAAAAAAABsvcqZDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDFNmXKlGjbtm28/vrrsdtuu212/LbbbhsjRoyIvn37xuOPP14CCYHybv/994+RI0fG7rvvnvScadOmxbHHHhvffvtt+oIBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5cbo0aMLtL3zzjtxyy23ZCANAGydtm3bxnXXXVeg3TWtbPJ6ZtbgwYOjatWqCfuWLl0aDz74YIwaNSo+++yzWL16dQmnoyxwDAMAAAAAAEDxVc50AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJg9e3a0adMmXn/99dh///03O75SpUoxaNCgaNiwYdxyyy0lkBAor7p27RrPP/981KxZM+k5I0aMiDPOOCPWrl2bxmQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAedK1a9cCbT/++GMGkgDA1mvQoIFrWjni9cycDh06xMEHH5ywb+zYsdGrV69YtWpVCaeirHEMAwAAAAAAQPFlZzoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAREQsWrQojjjiiJg4cWJS47OysuLmm2+Oe++9N7KystKcDiiPLr744njllVeiZs2aSc+5/fbb46STToq1a9emMRkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADlVf/+/RO2z549O4477rhYtWpVCScCAAAAAAAAqJiyMx0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfrZixYro0qVLvPzyy0nPueSSS2LIkCGRk5OTxmRAeZKdnR333Xdf3H///VGpUqWk5mzcuDHOO++8+MMf/hD5+flpTggAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEB5deSRRyZsHzBgQKxbt66E0wAAAAAAAABUXNmZDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/bd26dXHCCSfEY489lvScU045JUaPHh01atRIYzKgPKhRo0a88sor0b9//6Tn/PDDD9G1a9ctOi8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADA/9p3332jTp06BdqXLVsWI0eOzEAiAAAAAAAAgIorO9MBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4H/l5eXFeeedFzfffHPSczp37hzvvPNONGjQII3JgLJsl112iXfffTeOOeaYpOfMnTs3WrduHW+99VYakwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFARNGvWLGH75MmTIy8vr4TTAAAAAAAAAFRs2ZkOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIW57rrr4pJLLom8vLykxjdv3jzefffdaNy4cZqTAWXNYYcdFlOmTIkDDjgg6TnvvPNOtGrVKmbPnp3GZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFQUderUSdg+b968Ek4CAAAAAAAAQHamAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBR7r///jj11FNjw4YNSY3fc889Y9KkSXHwwQenORlQVpxyyikxYcKEaNiwYdJzBg8eHJ07d45ly5alMRkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVyfbbb5+wfeXKlSWcBAAAAAAAAIDsTAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAzXn++efjmGOOidWrVyc1vkGDBvH222/HkUcemeZkQGl33XXXxZAhQ2KbbbZJanx+fn5cc801cc4558TGjRvTnA4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICKpLDv3N6wYUMJJwEAAAAAAAAgO9MBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBlvvfVWdOzYMZYsWZLU+Jo1a8bo0aPj5JNPTnMyoDSqUqVKPPXUU/HnP/85srKykprz008/Re/evePWW29NczoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIJOyMx0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkvXhhx9G27ZtY968eUmNr1KlSgwZMiT69++f5mRAabLDDjvEm2++GWeccUbScxYvXhwdOnSI4cOHpzEZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/2vbbbeNOnXqxDbbbJO2NSpXrhzbb799bLvttmlbo7iqVq0aderUiRo1amQ6SqlTs2bN2H777SMnJyfTUSqcn/fLdB6fxfHz+aN27dqRlZWV6ThJKe3bNNV+/nlL8/k3EefkklGlSpWoU6dOVKtWLdNRSoTrWWaV5vNvWbyelWXO8WVTaT5OKlWqFLVr13aOr+BK63W+NB87AAAAAAAApUXlTAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACALTF37txo06ZNvPbaa9G8efPNjs/Ozo777rsvGjZsGNddd136AwIZ1bRp0xg1alQ0btw46Tkff/xxdO/ePb755ps0JgMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACifmjVrVqBtyZIlsWzZsoTjjzzyyDjllFOidevW0bRp06hSpcovfZs2bYqvv/46pk+fHm+99VYMGzYsvvvuuy3O1KJFizjttNOiTZs2ccABB0TNmjV/6Vu7dm18//33MXPmzBg9enS8+uqr8dVXX23xGsWx//77R8+ePaNly5Zx4IEHRqNGjSInJ+eX/vz8/Pjhhx9i1qxZMXPmzBgzZkyMGTMm1q1bl/IsW/r6RURUrVo1DjzwwGjSpElst912UbNmzcjKyvql/957792qrFWrVo2jjz46jj766DjooINi3333je233/5XtTds2BBfffVVfPLJJ/Huu+/Giy++GF988cUWr5UOdevWjfr162/RnO222y7ha1CUDRs2pOVn3n777aNnz55xzDHHxIEHHhiNGzf+1X7587Hz2WefxdixY2PMmDHxySefpDxHIjk5OdGpU6fo2rVrHHjggbHffvtFvXr1olKlSr+Myc/PjxUrVsTy5ctjxowZMX78+Bg/fnzMmDEjZTm29HipU6dO9O7dO4488sho0aJF7Lbbbr8652Vym6ZDo0aN4oQTToj27dvHQQcdFLvvvnuBc/z8+fN/Oa+9+OKLsWTJkgwm/o/Sck6uX79+1K1bt0D75s7JWyorKyv23XffAu15eXnx73//O2Xr/K+aNWtG9+7do1u3btG8efPYe++9o2rVqr/05+bmxuLFi2PmzJkxderUGDFiREyfPj1tedKpvF/Pdt1114Ttrmmbl4nrWXl4PYsjU+f4OnXqRMOGDQvtb9CgQaHtW7rdIyI+/fTTLZ5TWpWW+77CtGzZMjp37hwtW7aM5s2bR926daNGjRq/GrNhw4ZYuHBhfPLJJ/HRRx/FK6+8ElOnTt2q9crTMbzTTjtF7dq1C7SvWbMmbe/JK1euHHvvvXeB9uLc92zJdf6RRx4psWt8aTp2StPnDAAAAAAAAMmonOkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsKWWLFkS7du3j5deeik6deqU1JyBAwdGw4YNo2/fvpGXl5fmhEAmHHnkkfHCCy/E9ttvn/Sc0aNHx8knnxw//vhjGpMBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUX7NmzSrQNmDAgLjtttt+1Xb00UfH3XffHfvss0+htSpXrhx77rln7LnnnnHiiSfGPffcE08++WRcf/31sXDhws1mOfzww+Puu++OVq1aFTqmWrVqsdtuu8Vuu+0Wxx57bOTl5cWzzz4b1113XXz11VebXWNr5eTkxNlnnx1XXXVVNG3atMixWVlZUadOnTjiiCPiiCOOiIsvvjjWrFkTTz/9dPztb3+LL7/8MmW5kn39srOzo3fv3nH++edHhw4donLlyoXWHDRoUKxbty7pDLvssktcc801ceaZ/x979x0eRdX2cfy36RASQhOkiHSkFxHpSu9NilQD0hUUUUAFfUQFFRT0AQslSJHy0HtHpYOI0nuREuktBFIgef/wglfY2WSzO7vZDd/PdeXS3OfMfe7M7pwzs+zOdlKGDBmS7BsQEKBChQqpUKFCatGihUaOHKnffvtNw4cP18KFC+0e0xX69Omjjz76KEXb1KlTx/AxSMrGjRtVvXr1FG2TlCeeeEJDhgxRjx49FBgYaLPfv4+d+vXrP6jlgw8+0C+//GJaPf+WI0cOvf322+revbtCQ0OT7GuxWJQpUyZlypRJBQoUUMuWLSVJv/32m0aMGKGFCxcqMTHRqXrsPV5y5sypYcOGqXPnzvL397eZLzX2qStUq1ZNQ4cOVe3atWWxWGz28/PzU8GCBVWwYEG1bNlSY8eO1fTp0/XRRx/p1KlT7itYnjkn9+/fX4MHD7aKGz3HnJEuXTrD5/KtW7cUEhJi2jj3ZcqUSYMHD1afPn2SnON9fX2VK1cu5cqVSw0aNNAHH3ygQ4cOafjw4frpp5+84nupH+f1TGJNS0pqrmfe/Hg6yhPm+PDwcH355Zcp3q5Pnz7q06dPiraJjIxUrly5UjyWp/G0875/8/f3V69evdSrVy8VK1Ys2f4BAQHKly+f8uXLpyZNmuiDDz7Q2bNn9c033+iHH37QzZs37R47LR3DDRo00MSJE63i169fV44cORQbG2v6mM2bN9ecOXOs4itWrFDDhg1TlMuRdX7kyJEuX+M98djxhNcZAAAAAAAAAAAAUsIntQsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHBEVFaX69etr7ty5dm/z6quvasGCBQoKCnJhZQBSw6uvvqqVK1cqU6ZMdm/z9ddfq3Hjxrp165YLKwMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAx5uvr6/++9//auXKlSpatGiKt+3SpYv279+vRo0a2ezn4+OjUaNGacuWLapYsWKKxvDx8VHHjh115MgRhYeHp2hbe9WtW1dHjx7VhAkTVKRIEYdyBAcHq2fPnjp69Ki++uort34/Z9GiRbVt2zbNmjVLtWrVkp+fnyl5/f399emnn+r48ePq3bu3MmTI4FCeChUqaMGCBdq4caPy589vSm2ebP/+/ablatGihQ4cOKC+ffsqMDAwxdtXq1ZNP//8s+bOnavg4GDT6rJYLHr77bd18uRJDRgwQKGhoQ7nqlChgubPn6/NmzfrySefNK1GW9q3b68jR47o1Vdflb+/f4q3d9U+dYVs2bJp/vz52rBhg+rUqSOLxZKi7f38/BQeHq59+/apT58+LqrSmrfPyd6kSZMmOnjwoAYOHOjQHF+0aFFNnTpVf/75p0qVKuWCCs3Beua4tL6mefN65ggzH09HPY5z/OHDh1O7BKd4+nFSpUoV/fnnn/rmm29UrFgxh/Pkzp1bX3zxhU6dOqVXXnnFlNrM5upjeNasWYbfKR8WFqamTZu6ZMyOHTsaxiMiIuzOYcY674o13tOPneS46nUGAAAAAAAAAAAAR/ikdgEAAAAAHi9jxozR0aNHrX6+++671C4NAAA4YePGjYZrfNeuXVO7NAAAPB7XygAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOCcuLk5t27bVt99+a/c2TZs21Zo1axQWFua6wgC4jY+Pj7766itNnDhR/v7+dm1z9+5d9erVS2+++aYSEhJcXCEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPL58fHw0b948vf76607lyZgxo5YsWaKXX37Zqi0gIEDLli3TgAEDZLFYHB4jICBAkydP1tChQ50p9SE+Pj4aN26cVq1apbx585qS09fXV/3799eePXtUtGhRU3ImpWLFitq6dasqVKhgat7cuXNrx44deu+99+z+PsLkVK1aVXv27FGjRo1Myeep9u/fb0qegQMHav78+cqSJYvTuV566SVt27ZNTz/9tNO5QkNDtX79eo0cOVJBQUFO57uvUqVK2rVrlypWrGhazkd98skn+umnnxQcHOx0LjP3qSs899xz2rdvn1q0aOF0ruDgYI0bN07jx4+Xj4+PCdUZSwtzsjd55513tGjRImXPnt3pXCVLltRvv/2m8PBw5wszGeuZc9LymubN65mjzHo8HfE4z/GHDx9O7RIc5unHySuvvKJff/1VxYoVM6kyKVOmTPrxxx81f/58BQYGmpbXDK4+hqOjozVz5kzDNles8WFhYWrQoIFV/OrVq1q8eLFdOcxe581a4z392EmOq15nAAAAAAAAAAAAcJRfahcAAAAA4PGSPXt2FSxY0Cq+b9++VKgGnsLf39/ww5GJiYmKj49PhYoAACn19NNPK3fu3FbxsLAw9xeDB1hjAcA7cK0MAEDqslgsKly4sIoUKaKMGTMqY8aMCg0NlZ+fn6Kjo3Xz5k3dvHlTFy9e1N69e3X58uXULhkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhISEjQa6+9pr///lvDhg0z/O6WR1WtWlUbN25UvXr1FBkZ6YYqAbhCcHCwZs6cqSZNmti9zY0bN9S6dWutWbPGhZUBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACTpu+++U7NmzUzJZbFYNGXKFJ08eVLbt29/EJ81a5bq169vyhiSNGzYMJ08eVLTp093Kk9QUJDmzJmjxo0bm1TZwwoVKqQtW7aoSZMm2rx5s0vGyJ8/v1auXKmwsDBT8xYqVEjr1q1Tnjx57Op/9+5dxcfHK126dMn2DQ4O1sKFC9WxY0fNnj3b2VI90v79+53O8dprr+nzzz83oZr/V6JECa1evVrly5dXVFSUQzkyZcqkdevWqWzZsnb1T0hI0J07dxQYGCg/P79k++fIkUNLly5VuXLldObMGYdqtOX999/X+++/b2pOM/apK9SoUUNLly5VhgwZTM3bvXt3WSwWde/e3dS8UtqYk71Jv3799MUXX5iaMyAgQBEREQoNDdU333xjam5HsZ45L62uad68njnDjMfTEY/7HH/48OHULsEhnn6cdOnSRZMmTZLFYrGr/507d5SYmKh06dLZtU2LFi20atUq1atXT7GxsSmuzxXccQyPHz/e8FyvXr16ypEjh86fP2/aWK1bt1ZAQIBVfMaMGYqLi0t2e1et886u8Z5+7CTHVa8zAAAAAAAAAAAAOCP5f0UBACANqVixomrUqJGqNZw9e1YzZsxI1Rrgeo0bN1axYsWs4jNmzNDZs2dToaKkn//ffvutbt265eaKAOD/7dixQ2XKlLGKHzp0SM8884z7CwIAII1gjYUjuKYFAABGzPw3lsTERMXFxSkmJkZXrlzRxYsXdfLkSdM/2Jk+fXq9/vrrpuZ0lR9++EE3btx48LuPj4/69etn+GFhSdq3b5+WL1/urvIekjt3brVv395m+5QpU3ThwgU3VuSY0qVLq23btqpZs6ZKliyp9OnT271tZGSk/vjjDy1atEjz58/XlStXXFjpP8z+d86EhATFxsYqOjpaFy5cUGRkpA4fPqzbt2+bNsajnnzySXXq1MmwbenSpTpw4IDLxralfPnyqlWrlmHbo8clAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMB7fPLJJ4qMjNT48ePl6+ubbP8SJUpoy5Ytqlevng4fPuyGCgGYKVeuXFq6dKnh9zXZcvLkSTVu3DhV7pENAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI+bli1bqkePHlbxEydOaMqUKfr111/1119/KSYmRpkzZ9aTTz6pmjVrqlWrVipcuLBhzoCAAE2aNEllypTR3bt3NWDAALVo0cKq3/Xr1zVr1iwtX75chw4dUlRUlDJkyKDs2bPr2WefVYsWLVSjRg2btX/77bfavHmzTp486fDfP23aNDVu3Nhme0JCgrZu3aolS5bot99+0/nz53X16lWlT59e2bNnV8GCBdWwYUPVr19fYWFhhjkyZcqkZcuWqVKlSjp48KDDtRrx9fXV/PnzbY7tqMyZM2v16tXKkyePzT579uzR7NmztXr1ah0/flzXrl2T9M/jnzVrVj377LOqW7euOnToYFifn5+fpkyZolOnTmn79u2m1p+Us2fPatu2bTbbn3/+eavY1atXdeTIkRSNs2/fvhTX9mgdX3/9tVU8MTFRGzZs0MKFC7Vz506dO3dOt2/fVmhoqLJly6ayZcuqYcOGqlevns3vjy1UqJCmTJmili1bOlTbTz/9pLJly9ps37hxo+bOnavNmzfryJEjioqKetAWEhKifPny6YUXXlDnzp1Vvnx5wxxZs2bVvHnzVKVKFcXHxztU56Nq166tYcOGWcU9YZ+arUCBAlq4cKEyZMhgs09sbKzWr1+v5cuXa8+ePbpw4YKuX7+uwMBAZcmSRSVLllTt2rXVrFkzhYaGPrRtt27dtHv3btPr9vY52ZtUr15do0ePtorHxcVp1apVWrFihf7880+dP39et2/fVnBwsLJnz65ChQqpfv36atCggc19bLFYNGbMGJ04cUJLly518V+StMd5PcuSJYsKFSpkFWdN+3+etJ550+PpKE+c4//+++8k93vu3LmVO3duq/jZs2d19uzZZPP/286dO1PU31N40nHyqPz582vs2LGyWCyG7ZGRkZoxY4ZWrVqlffv26eLFi0pISHjQnjlzZhUuXFhVq1bVSy+9ZHgdIEk1atTQN998o549e9qsJa0dwzt37tTu3btVunTph+K+vr7q0KGDvvzyS9PG6tixo2E8IiIi2W3NWuenTJli+hrvycdOclz1OgMAAAAAAAAAAICz/FK7AAAA3KlGjRr6/PPPU7WGTZs2acaMGalaA1zL399fERERypYtm1VbtmzZ9M4776RCVUk//6dPn65bt265uSIAAAAAgKfhmhYAANjijn9juX37tv744w9t3rxZy5Yt06ZNmx76EHNKZciQIdX/Xchec+fO1Y0bNx78npCQIF9fX5v1x8bGqkKFCtq7d6+7SpT0z41Ppk+fbvPmZQsXLtQXX3zh1ppSKjAwUL179za8OYy9cubMqZw5c6pRo0b69ttvtW7dOn366afauHGjiZU+zB3HYGJiok6ePKlNmzZp7dq1Wrx48UPPS2flyZPH5t9w9uxZHThwwLSx7FWlShWbNT16XAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAvEtERIQuXbqk2bNnK126dMn2z5s3rzZv3qyGDRtqx44dbqgQgBnKlSunJUuWKGfOnHZvs3XrVjVr1kyXLl1yYWUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAElKnz69/vvf/z4Ui4qK0oABAzRp0iQlJCQ81Hb+/HkdOHBA69at09ChQ/Xaa69p5MiRCgwMtMpdvHhxde3aVevWrdPw4cMfaktMTNSYMWP0n//8Rzdv3rTa9tixY9q8ebO+/vpr1alTRxMmTFDevHmt+oWEhGjUqFF66aWXHPnzNXToULVq1cpm+8qVKzVw4EDt3bvXsP3EiRPaunWrpk2bpuDgYL311lsaOHCgMmTIYNU3Y8aMWrZsmcqUKWP4Nzvq9ddfV+nSpa3i165d06JFi7R06VLt3btXFy5c0I0bN+zOO3v2bD399NOGbWfOnNFbb72luXPnGrbHxcUpMjJSixcv1uLFi/Xee+9p0KBBGjx4sHx8fB7qGxgYqLlz56po0aKKjo62uz5nREREKCIiwmZ7YmKiVWz9+vVq3bq1K8uyMn78ePn6+j4UW7ZsmQYNGqT9+/db9b9w4YKOHj2qLVu2aNy4cSpWrJi++eYb1apVyzB/ixYt1Lp1a82ZMydFdfXt21cNGjQwbNu1a5d69+6d5HfQRkVFac+ePdqzZ4+++eYbtWzZUpMnT1ZoaKhV3woVKig8PFwTJkxIUY1GgoKCNHHiRKvnoCfsU7P5+flp/vz5CgsLM2y/d++eIiIi9NFHH+ncuXOGfU6fPq0//vhDU6dOVUhIiPr166chQ4YoKCjoQZ/PP/9cV69eNa3utDAne5NHj4fExER99913+vTTTxUZGWm4zf19PHXqVAUHB6t///565513DI9fi8Win376ScWLF9fZs2dd9nck53Fez1q2bKl58+ZZxVnT/uFp65k3PZ6O8NQ5fubMmZo5c6bN9g8++EAfffSRVXzChAkaNmxYkrnTAk87Th41ZswYpU+f3iqekJCgDz74QKNGjVJsbKzN7a9evapt27Zp27ZtGjVqlCpXrqzvvvtOpUqVsurbo0cPzZ07V2vWrDHMlRaP4QkTJmjs2LFW8fDwcH355ZemjJE7d25Vq1bNKr5792798ccfyW5v1jqfN29eU9d4Tz92kuOq1xkAAAAAAAAAAACc5ZN8FwAAAKRE8+bNlS1bNsO28PBwBQQEuLkiAAAAAADswzUtAABITenTp1eVKlU0cOBA/frrr/r777/16aef6sknn0zt0lLFl19+qXXr1hm2BQYGaubMmYY3KHOld955RzVq1DBs+/vvv/Xqq6+6tZ6UsFgs6tWrl06cOKHRo0ebltfPz0/16tXThg0btGrVKpUpU8a03O5msViUP39+de7cWVOnTtXFixc1e/ZsVahQIbVLAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAIUuWLFGdOnV07do1u/pnyZJF69evV/369V1cGQAzNG/eXBs2bFDOnDnt3mbWrFl68cUXdenSJRdWBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC479VXX33oe+dOnTqlcuXKacKECUpISEhy24SEBP33v/9V69atdffuXcM+/fv318cff6yAgIAHsTt37qhRo0Z66623dPPmzWRrXLNmjWrUqKFz584Ztjdr1ky5c+dONs+jSpQooaFDhxq23b17Vz179lSDBg20d+9eu/JFR0fr448/VunSpXXw4EHDPvny5dMXX3yR4lptSZ8+vYYMGfJQLDY2Vp9//rny5cunLl26aN68eTpy5Ihu3Lhhd96OHTuqdu3ahm2bN29W+fLlNXfuXLvz3bx5U++//74aNWqkqKgoq/bcuXPro48+sjvf46JkyZIP/v/+c7Jx48bav3+/XdsfOHBAdevW1eTJk232GThwYIpqCg0N1YcffmjYNn36dD333HPasWNHinLOnz9fVapUsfkcfeedd2SxWFKU00i3bt2UN2/eB797yj51hTfeeEOlSpUybLt27Zrq1q2rHj162JxXHxUVFaVPP/1UZcuW1cmTJx/E06dP79D8ayQtzMneplChQg/+/8aNG6pVq5Zee+01RUZG2rV9dHS0PvnkE5UrV87mPg4NDdXo0aNNqdcRrGeew9PWNG9ez7wRc7x38vTjJFu2bGrQoIFhW7t27fTpp58qNjY2RfVt2bJFFSpU0Pz58w3bhw0blqJ83m769Om6c+eOVbxEiRIqW7asKWO0b9/e8DGPiIhIdlsz13kz13hPP3aS46rXGQAAAAAAAAAAAMzgk9oFAAAApDW9evWy2ZY1a1a1bNnSjdUASXv99dc1cuRIq58mTZqkdmkAPBTzBgAAaRvXtADgebgOw+PsiSee0Hvvvafjx49r+PDhCgoKSu2S3K5z5866evWqYVvx4sXd+uH/MmXK6JNPPjFsS0xMTLLW1JY7d2798ssv+u677x66MZzZ6tatqx07dujNN9902RjuFBAQoDZt2mjHjh2aN2+ennrqqdQuCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAFNu8ebOqVaumc+fO2dU/ODhYixcvVseOHV1cGQBnvP3225o3b56Cg4Pt6p+YmKiPP/5Y7dq1U2xsrIurAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADclzt37gf/f+XKFb344os6duxYinIsWbJEX375pWFb0aJF1a5duwe/JyQkqGXLllqxYkWKxvjrr7/0yiuvGLb5+vqqV69eKconSd9//738/f2t4vHx8WrYsKHGjx+f4pySdOLECVWsWFHbtm0zbO/Ro4eee+45h3I/ql27dsqaNeuD3y9fvqyaNWtq8ODBunHjhkM5g4KC9MUXXxi27d69W7Vr19alS5ccyr1y5Up17tzZsK1v377Knj27Q3nTuoSEBLVt29ah52RCQoK6du2qDRs2GLY/++yzql69ut35/P39NXPmTMXExDwUX758uTp16qR79+6luEZJ2rdvn1577TXDtkKFCqlBgwYO5f23PHnyPPh/T9qnZgsLC9OHH35o2Hb16lVVrFhR69evdyj3oUOHVKVKFZ09e9aZEg2lhTnZW92+fVs1a9bUzz//7ND2x48fV8WKFbVr1y7D9latWqlKlSrOlOgQ1jPP5CnzrzevZ96IOd47efpx0qRJE/n5+VnFZ8+erf/9738O1SZJcXFxatu2rbZu3fpQfM2aNfrggw8czuuNbty4oblz5xq2denSxZQxOnbsaBWLj4/XTz/9lOR2rlrnzVjjPf3YSY4rXmcAAAAAAAAAAAAwi09qFwAAAJCWFCxYUC+++GKSfRz5sA7gKh06dNDbb79t9VOzZs3ULg2Ah2LeAAAg7eKaFgA8E9dhgJQuXTq9++67+uOPP1SyZMnULsetIiMj1a1bN5vtffv2Vb169VxeR1BQkGbMmGF4gwNJGj16tNauXevyOhzRsGFD7dmzx203LvL399fo0aO1YMECBQUFuWVMd2jZsqX27Nmjl156KbVLAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgxfbv36/KlSvr0KFDdvX39/fX1KlT9dZbb7m4MgAp5efnpwkTJmjkyJHy8fGxa5uYmBh16NBBH3zwgYurAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAk5ZVXXtGpU6cc2vaTTz7R1atXk+33+eefa+XKlQ6NsW7dOpvb1qtXL0W5qlWrpipVqhi2vfPOO1qzZk2K6/u3qKgovfTSS7p48aJVm8Vi0XvvvedU/vsKFy784P+vX7+uSpUqacuWLU7lbN++vZ588kmr+M2bN9WiRQvFxMQ4lX/hwoWaOHGiVTwgIECvvfaaU7nTqg8//FDz5893Kkd4eLji4+MN25o1a2Z3nitXrqhv377Kly+fvvzyS0VHR+v69evq3LmzU/VJ0k8//aS9e/cattWqVcvp/P/mSfvUbF27dlVISIhVPDExUR07dtTRo0edyv/333/rpZde0r1795zK829pZU72Vn369NGuXbucynF/H1+7ds2w/c0333QqvyNYzzyTp8y/aWU98wbM8d7L04+TAgUKGManTJnicF333b17V126dNGdO3c0bdo0lS5dWnXr1nX6+eqNxo8fbxhv3769/Pz8nMpdokQJlSxZ0iq+ZMkSXblyJcltXbnOO7vGe/qxkxxXvM4AAAAAAAAAAABgFp/ULgAAACAt6dGjhywWS5J9atSooaJFi7qpIgAAAAAA7MM1LQAA8HRFixbV5s2bVbNmzdQuxa0WLFigiIgIwzaLxaIff/xRWbNmdWkNo0aN0jPPPGPYtnv3br377rsuHd9RrVq10qJFi5QpU6Yk+yUkJGjXrl2aPHmyhgwZot69e+uVV15Rx44d1b17dw0YMECfffaZlixZor/++suusZs3b6758+c7/eFxT5IxY0bNmTNH/fv3T+1SAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABIsdOnT6tKlSravn27Xf0tFou+/PJLjRo1ysWVAbBXpkyZtHbtWnXr1s3ubS5evKgXX3xRM2fOdGFlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDkLFq0SMuWLXN4+1u3bmnevHlJ9jl37pw+/vhjh8eQpIiICMN46dKlFRgYaHeet99+2zC+du1aff311w7V9qjIyEh1797dsK1p06YqVKiQKePc17VrVx07dszpPK+//rph/JtvvtHJkyedzi9JI0aMUEJCglW8c+fOpuRPS3bv3q0RI0Y4nefkyZNauHChYVvVqlVTnO/8+fN6++23lTdvXjVt2lRXrlxxssJ//PDDD4bxatWqmZJf8tx9apbevXsbxn/88UetWLHClDF27Nhh87FyRFqck73Fxo0bNWXKFFNynTp1SgMHDjRsa968uXLkyGHKOPZiPfM8njj/evN65i2Y472fpx4nOXPmNIwfP37c4Zr+7fDhw8qePbs6d+6sPXv2mJLTG23atEmHDh2yimfJkkWNGjVyKnfHjh0N47au+//N1eu8GWu8px47KWHW6wwAAAAAAAAAAABm8UvtAgAA8BQ1atTQ+fPnXT7OnTt3XD4GUoe/v7/Cw8Pt6tuzZ0/179/ftQUBAAAAAGAnrmkBAIAzUvpvLH5+fsqQIYMyZMigrFmzqnjx4ipevLiqVq2q7NmzJ7ltSEiIFi9erBdeeEE7d+5Msu/ly5dVpEgRu+uypXLlypo8ebJh22uvvaa1a9c6Pcbp06eTbO/Xr5+qV6+uggULWrXlyJFDkyZNUrNmzZyuw0j9+vX12muvGbbFxMSoXbt2iouLc8nYzmjdurVmzpwpX19fm302b96sCRMmaOHChbpx44bduYsWLapWrVqpV69eypUrl81+DRo00PTp0/Xyyy+nqPaUcuTfOQMDAxUaGqqMGTPq6aefVtmyZfXss8+qTJkySW5nsVj01VdfKSoqShMnTnSiagAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3O/q1auqWbOm5s6dqwYNGti1zYABA/Tkk08qPDxc8fHxLq4QgC0FCxbU8uXLVahQIbu32b9/vxo3bqxTp065rjAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgF0+/vhjp3PMmzdP3bt3t9k+ZswY3blzx6kxli5dqri4OAUEBDwU9/f3V9myZbVt27Zkc4SEhNj87swRI0Y4Vd+jFi9erP3796t48eIPxS0Wi1q1amXaeAsWLNCCBQuczvPUU0+pbNmyVvHbt29r9OjRTue/78SJE1q7dq3q1q37UDxv3rx65plndPDgQdPG8nZDhw7VvXv3TMk1efJktW7d2iperlw5pU+fXrdv305xzitXrmjjxo1mlCdJWr9+vWG8bNmy8vX1NWVfePo+dUbhwoVVsGBBw7Yvv/zS1LE++eQT9ejRQ35+fk7lSYtzsjcxY/3/t2nTpmn48OHKli3bQ3E/Pz/Vr19fP/74o6nj2cJ65pk8ef71xvXMWzDHpx2edpwEBgYaxhMTE52u7b6oqCjTcnmzCRMmGJ5LhoeHa9GiRQ7nbdeunVXs/PnzWrlyZZLbuWOdN3ON97Rjx15mvc4AAAAAAAAAAABgJufeqQQAQBpy7NgxRUZGpnYZ8GItW7a0esOvLa+88ooGDx6s2NhYF1cFAN6hTZs2SpcunVWceRIAAOewxsJeXNMCAABnmPVvLBaLRVWrVlV4eLheeeUV+fr6GvYLDg7WvHnzVLJkSd28edNmvoSEBB05csTpunLnzm2z7ezZs6aMkZzo6Gi1b99eW7ZsMbwpTdOmTdW9e3dNmDDB1HGzZs2a5E1N3n77bY+8CUiZMmU0depUm88hSapZs6Z+/vlnh/IfOnRIn3zyiUaOHKk+ffrok08+Ufr06Q37tm3bVhs2bNC3337r0Fj2MPPfOQsUKKAOHTrozTffVKZMmWz2++6777Rr1y7t2rXLlHEBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHCX27dvq2nTpoqIiFCnTp3s2qZ9+/bKmjWrWrZsqejoaBdXCOBR1atX14IFC5Q5c2a7t1m9erVat26d5D3tAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADusXv3bv3+++9O50kqR0JCgqZMmeL0GHfu3NGhQ4dUqlQpq7Z8+fJp27ZtyeaoW7eu/P39reL79u3T+vXrna7xUWPGjNGECROs4k2aNNGIESNMG8MMderUMYyvXbtWV69eNWWM+3755RfVrVvXKv7CCy/o4MGDpo7lrf766y8tWbLEtHybN29WYmKiLBbLQ3E/Pz/lzZvXI/b7oUOHdOvWLWXIkOGhuJ+fnzJlyqTLly87lT+t71OjY0qSNmzYoP3795s61t9//62lS5eqefPmTuVJi3Oyt/jrr7+0Zs0aU3PGxsZq0qRJGjx4sFVb/fr19eOPP5o6ni2sZ54nrc+/j3L1euZNmONhi7PHyfXr1w3j+fLl09GjR80qE5KmTJmiESNGKCAg4KF4o0aNlDVrVofmtGrVqumpp56yik+bNk337t1Lclt3rfOeusa7a40x63UGAAAAAAAAAAAAM/mkdgEAAABpRa9evezumylTJrVu3dqF1QCAdzl69Kj27Nlj9XP48OHULg0AAK/GGgt7cU0LAAA8QWJiojZu3KhXX31VJUuW1IYNG2z2feqppzR8+HA3Vpf6fvvtN/3nP/+x2T5mzBgVLlzY1DEnTZqk7NmzG7atWLFC48aNM3U8M4SGhmru3LkKCgqy2eerr77Szz//7PRYsbGxGj16tJ577rkkr7M+//xz5c2b1+nx3OH48eMaNmyYChUqpIiICJv9/Pz8FBERYXWDEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAvMHdu3fVuXNnffnll3ZvU7duXf3888/KmjWrCysD8KhXXnlFa9asUebMme3e5vvvv1fDhg118+ZNF1YGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALDXqlWrTMlz+fJlXbp0ybDtzz//tNmWUvv37zeMh4WF2bX9iy++aBhfuXKloyUlyVbeihUrKjAw0On8hw4d0oYNG5zOI0lVq1Y1jJv1HPm3bdu2GcaLFy9u+ljeaunSpabmu3nzpo4fP27YlilTJlPHclRiYqL+/vtvw7aUfH+mLWl9n1asWNEw/vPPP7tkvOXLlzudI63Nyd5k9erVLsm7fv16w3iFChVcMp4R1jPPk9bn30e5ej3zdszxkJw/Tmxt265dO6fqgrUrV65o4cKFVnF/f3+H93fHjh0N45MnT052W3et8566xrtjjTHzdQYAAAAAAAAAAAAz+aR2AQAAAGlB4cKF9cILL1jFL168qJ9++slwm169erm4KgAAAAAAksc1LQAA8EQHDx5U7dq1NXPmTJt9evTooTx58rixqtQ3YsQIbdq0ybAtffr0mjFjhvz8/EwZq1u3bmratKlh28WLFxUeHm7KOGb75ptvVKBAAcO2xMRE9e7dWwMGDDB1zP3796t69eo2b9iRIUMGjRs3ztQxXe3KlSt69dVXNXjwYJt9SpcurTZt2rixKgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzPX2229rwIABSkxMtKt/hQoVtHnzZuXNm9fFlQGQpOHDh+vHH39UQECAXf3v3bun/v37q3fv3rp3756LqwMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2GvLli2m5Tp//rxhfPv27S4fIywszK7tixUrZhjftGmToyUl6ezZszpz5oxV3MfHR0WKFHE6/y+//OJ0jvuKFi1qGN+6datpY9z3999/G8YLFy5s+ljeasOGDabnNHouSlLmzJlNH8tRN27cMIybUWNa36e25hRXHMOStHHjRqdzpLU52ZuY8fgZ2bFjh+H3Uj/99NN2fxeus1jPPE9an3+NuHI983bM8bjPmePE1vOoc+fOat26tVN1wdr48eMN4+Hh4SnO5e/vr1atWlnFt2/froMHDya7vbvWeU9e4129xpj5OgMAAAAAAAAAAICZfFK7AAAAgLSgR48ehvEpU6bo22+/NWyrUqWKihcv7sqyAAAAAABIFte0AADAU8XHx6tDhw42b7Ll7+/v0IdyvVlCQoI6dOigmzdvGraXL19ew4YNc3qcggULasyYMTbbu3TpoosXLzo9jtnKlSunzp0722wfMGCAvv/+e5eMffHiRdWtW1dRUVGG7Y0aNVKJEiVcMrYrff7550k+F15//XX3FQMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAt89dVX6ty5s+Lj4+3qX7hwYW3dulUlS5Z0cWXA4ysoKEhz5szRu+++a/c2t27dUvPmzZO8tzYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIHUcPXrUtFxRUVGG8SNHjrh8jLCwMLu2f+aZZwzju3btcrSkZP3+++8pqiUltm/f7nSO+woXLmwY/+uvv0wb475r164ZxjNlymT6WN7q4MGDpue8ceOGYdze48dVcuTIoSpVqqhTp07KnDmzYZ+AgACnx0nr+7RQoUKG8T179rhkvOPHjyshIcGpHGltTvYmZq7//3bjxg3DdcPHx0f58+d3yZiPYj3zPGl9/r3PXeuZt2OOf7yZdZxs2rRJV65csYr7+Pho9uzZmjJlikqXLu10vfjHunXrdOLECat4uXLlVKJEiRTlatCggeFjHxERYdf27lrnPW2Nd+caY+brDAAAAAAAAAAAAGbyS+0CAAAAvF1AQIDCw8MN2yZNmqTDhw/r0KFDKlq0qFV7r1691LdvXxdXCAAAAACAMa5pAQCAp0tMTFTXrl21d+9e+fj4WLW3bt1aH3/8cSpUlnpOnz6t3r1766effjJsHzRokFasWKGNGzc6lN/X11czZsxQcHCwYfu4ceO0fPlyh3K72ldffSWLxWLYNmPGDI0ePdql4584cULvvvuuxo4da9g+YMAAdenSxaU1uMKQIUPUunVr5cqVy6qtatWqyp07t86ePZsKlQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYI7p06fr8uXLmjt3rs17NP/bk08+qQ0bNqhZs2basGGDGyoEHh85cuTQokWL9Nxzz9m9zenTp9WkSRPt2bPHhZUBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwVGRlpWq5bt24Zxs+fP2/aGFFRUYZxHx8fu7bPli2bYfzSpUsO15Scy5cvG8azZs3qdO7du3c7neO+TJkyWcXu3Lmjq1evmjbGfbaeKyEhIaaP5a3OnTtnes6bN28axu09fhwVGBiop59+WgUKFFD+/PlVsGBB5c+f/8FPunTpXDr+fWlpnxrJmDGjYfzKlSsuGS8+Pl6RkZHKnTu3wznS2pzsTf766y+X5b569aqefvppq7jROuMKrGeeJ63Mv56ynnk75vi0zV3HSXx8vEaMGKFRo0ZZtVksFnXu3FmdO3fW2bNn9dtvv2n//v06duzYg58LFy6YUsfjZOLEiRo+fLhVPDw8XG+//bbdeTp27GgVu3PnjmbNmmXX9u5a5929xnvSGmPm6wwAAAAAAAAAAABm8kvtAgAAALzdSy+9pCxZsljFN2/erMOHD0uSJk2apJEjR1r16dSpkwYOHKg7d+64vE4AAAAAAB7FNS0AAPAGBw4c0MaNG1WjRg2rthIlSihTpky6du1aKlSWembMmKFGjRqpffv2Vm0+Pj6aPn26SpUqpRs3bqQ494cffqgKFSoYth04cCBFH4B2pxo1ahg+R6R/bgbXq1cvt9Tx7bffqk+fPipWrNhD8UOHDunQoUNuqcFs0dHRGjt2rEaMGGHY/sILL2j69OlurgoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHOtXLlSNWvW1PLlyw2/z+NRYWFhWrVqldq1a6eFCxe6vkDgMVC6dGktXbpUuXPntnubHTt2qGnTprpw4YILKwMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOCM6Otq0XAkJCak2hj3SpUsnX19fq3hsbKxiYmKcKStJ165dM4yHhIQ4nfvKlStO55Ck9OnTy2KxWMXTpUunO3fumDLGvxmNJUmBgYGmj+WtoqKiTM/pzPFjj5w5c6p8+fIqVaqUChYsqPz586tAgQLKmTOnzcfcnbxxn9rL1jEcGxuruLg4l43rzD5Ni3OyN7l586bLcl+/ft0wniFDBpeNeR/rmWfytvnX09czb5EuXTqrGHN82uEJx8l///tftWjRQlWqVLHZJ3fu3MqdO7datGjxUDw6OlrHjx/XsWPHdOzYMR09elS7d+/Wnj17FBsb6+rSvdLkyZM1bNgw+fn5PRTv0KGDBg4caNe8HBISoiZNmljFFyxYYNe5iTvXeVet8Z5w7CTHrNcZAAAAAAAAAAAAzOaXfBcAAAAkpVevXobxiRMnPvj/qVOnasSIEVZvFMqYMaPatm2rH3/80ZUlAgAAAABgiGtaAADgLebPn68aNWpYxS0Wi5555hlt2bIlFapKXb1791aVKlWUN29eq7annnpK33//vdq1a5einJUrV9Z7771n2BYXF6f27du79MYGzujZs6fNtkGDBrnkBh1GEhMT9fXXX+uHH37QyZMnNWvWLM2cOVN79+51y/iusmjRIo0YMcKwrUKFCpo+fbqbKwIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwHw7duxQlSpVtGrVKsN7QD8qKChIc+fOVe/evTVhwgQ3VAikXY0bN9bMmTOVIUMGu7eZO3euOnXq5LH3UAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/CM+Pt7lY8TFxbl8DHsEBwcbxm/evOnSca9du2YYDw0NdTr3jRs3nM4h2d430j/fEwr3c8exaYbixYurc+fOatu2rV3fO5uavGWfOiK15rfo6GiHt02Lc7I3uX37tsty21qbUvL9uI5iPfNM3jD/etN65i2MjkfmeO/macdJXFycmjVrpjVr1qhs2bIp2jY4OFilSpVSqVKlHorfvXtXv/76q3766SfNmjVLd+7cMbNkr3b+/HktX75cTZs2fSieI0cO1atXTytWrEg2R8uWLQ3X44iICLtq8NZ13tOOneSY9ToDAAAAAAAAAACA2fxSuwAAAOCckJAQ5cmTR6GhoQoJCVFCQoJu3rypmzdv6q+//lJMTExql5imFSlSRNWrV7eKR0VF6X//+9+D3y9evKilS5eqefPmVn179eqlH3/80YVVpl158uRR5syZlTFjRgUFBen27duKiorSpUuXFBkZmdrlJcnf31/58uVTWFiYQkJC5OPjozt37ujKlSs6deoUb7RLgp+fn/Lnz8++c5GsWbMqc+bMCgsLU2hoqHx8fBQdHa2bN2/q0qVLOn/+fGqXaKqcOXMqa9asCgkJUXBwsBITE3Xjxg1dvXpV165d09WrV5WYmJjaZT52j4sj2EfmSAvnlqyxjgkODlbevHmVMWNGZciQQXFxcbp586b+/vtvrzl+vPncMC3LkCGDcufO/WBe8fHxUVRUlG7cuKEzZ87o1q1bqV2ipMf3+cM1LbwZa/7DLBaL8uXLpyxZsjz44OfNmzd148YNnTp1ymNuTvNv3jD3cp2Rurz9+oR5ynyHDx+22fb0009ry5YtbqzGM9y8eVMdO3bUr7/+Kh8fH6v2l19+WUuWLNGMGTPsypchQwZNnz5dvr6+hu3vvvuudu/e7VTNrpI5c2a1bNnSsO3o0aOaPn26W+uZNm2adu3apZ07d7p1XFc6ePCgrl27pkyZMlm1FShQIBUq8l6cYwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAZzt8+LAqV66sVatWqUSJEsn29/X11fjx45UjRw59/PHHbqgQSHvefPNNjRo1yua90o2MGDFC7733ngurAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4k8TExNQuQZLk4+NjGL93755Lx7WV32KxOJ375s2bTueQzKkFj5e8efNqxIgRevnll3n+eABbj4Gr57e7d+86vG1anJO9iSvX5tTcx4/b4wjnsZ65jtE8zxzvnTz5OLly5YoqVaqkr776Sj179kzR97Eb8fPzU61atVSrVi198sknGjJkiCZPnmxStd5v/Pjxatq0qVU8PDxcK1asSHb7jh07WsVOnz6t9evX2zW+pz3/kuPJx05SzHqdAQAAAAAAAAAAwGx+qV0AAABImbCwMDVp0kTNmjVT+fLl9fTTT9vsm5CQoKNHj2rHjh1auHChVq5cqdu3b5te0/PPP6+nnnrKKr5kyRLduXPH5naFCxdW+fLlVaxYMWXKlEmhoaHy9/d/0L5+/XpNmDDB9HrN1LNnT8P4rFmzrPb1hAkT1Lx5c6u+FStWVOnSpbV7925XlJimlCpVSq1atVKtWrVUsmRJhYSE2Ox7/fp17dmzRytWrNCCBQt0+PBhU2tx5HlfunRptW/fXnXr1lWxYsUUEBBg2C8xMVGHDx/Wzz//rP/973/65ZdfHKqxYMGCKleuXJJ9smbNahgvUqSI2rRpk+Ix9+7dq4MHD6Z4u+SULFlSbdu2VaNGjdyy72zJnDmzateubdiW3JzniCxZsqhWrVqGbYsWLVJsbKzTY+TJk0ft27dX1apVVaFCBWXPnj3J/tevX9f+/fu1bt06LV68WL///rvTNUi2j6lz585p8+bNpowhSeXKlVPz5s1Vs2ZNlShRQhkzZkyy/82bN7V582Zt2LBBy5Yt0969e02rJSmp9bi4e95wZs7wlOeut0sr55buXmPTgsDAQNWvX18vvfSSKlWqpAIFCth8c/bVq1e1bds2zZ8/X3PnztWNGzfcXK2x1Dg3LFGihIoVK2bYNn/+fKc+GJqcGjVqGM51J06c0M6dO21u56419r6sWbOqSZMmaty4scqVK6e8efPafG4lJibq2LFj2rp1q2bPnq1Vq1a5/ENS93nStUVq4prWPKn12og3X6Ow5jsvX758atu2rZo2baoyZcooXbp0hv3u3r2rQ4cOacOGDZo7d65+/fVXJSQkuLla75h7U+M6Iy29fuMsT7s+YZ7yPOfPn7fZliFDBjdW4lk2bdqkESNG6P333zds/+6777Rp0yadPn062Vxjx45Vvnz5DNvWrVunr776yqlaXalt27YKDAw0bBszZox7i5F0586dJK/VvNX58+eVKVMmq3i2bNlSoRrvwWuZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOB9IiMjVa1aNS1ZskRVq1a1a5thw4bp008/TZXvBAC8la+vr8aOHatevXrZvU1cXJx69OihKVOmuLAyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwX2JiYmqXgMdQ7dq1NWfOHIWFhTmc4+rVqzp69KiOHj2qw4cPP/j/cePG6fnnnzevWAAAbGA9A5LnDcdJbGysXnvtNX399dd699131bJlS4WGhjqdN2fOnIqIiFCdOnXUpUsXxcbGOp3T261YsUJnz55V7ty5H4o3a9ZMYWFhun79us1tc+TIoZo1a1rFp0yZkiava73h2LElLT4eAAAAAAAAAAAgbfBL7QIAAIB9ChUqpMGDB6tjx44KCAiwaxsfHx8VKVJERYoUUadOnRQdHa0ffvhBo0aN0t9//21abW+88YZefvllq3jevHl1+vTph2IhISF6/fXX1bVrVxUsWDDJvLdu3dKECRNMq9NsgYGBeuWVVwzbJk6caBVbuXKlIiMjlTNnTqu2Xr16qXfv3qbXmFa89NJLGjJkiMqUKWP3NmFhYapevbqqV6+uESNGaN26dfr444/166+/mlJTSp735cqV08iRIw3f7GXEYrGoaNGiKlq0qHr37q0DBw5oyJAhWrBgQYpqrFu3rsaNG5eibe5r0KCBGjRokOLtXnnlFR08eNChMY2UKlVKI0aMUMOGDe3qb9a+s6VgwYKaPXu2YZvRY++sIkWK2Bwve/bsunjxosO5q1Spog8++EC1a9eWj4+P3duFhYWpSpUqD7Y/ePCgRo4cqenTpys+Pt7hemwdUwsXLtTmzZsdziv9sx62bdtW7733nkqUKJGibUNDQx8cDyNGjNDq1av12Wef6eeff3aqJltS+3Fx97zhyJyR2vsorUgr55aptcZ6s9DQUPXt21f9+/dXlixZ7Nomc+bMatiwoRo2bKivvvpK48aN06effqro6GgXV2ssNc8NM2fObHNtbt68uRYtWpSifPZKly6dlixZopCQEKu2Nm3aaOfOnTa3deUa+2+lS5fW4MGD1bp1a/n6+tq1jcViUaFChVSoUCF17txZFy5c0LBhwzR+/HjdvXvXtNr+zROvLVIL17TmSq3XRrz5GoU133EFChTQJ598ojZt2th1Tuzn56cSJUqoRIkS6tOnj06dOqURI0Zo8uTJbjkX9oa5NzWvM9LC6zfO8tTrE+YpzxMVFWWzLSgoyI2VeJ4PP/xQdevWVYUKFazaQkND9dNPP6lGjRpKSEiwmeOll16yeX549epVde7c2bR6XaFu3bqG8bt372rmzJluribtunTpkp555hmreHBwcCpU4/l4LRMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAvNv169dVu3ZtzZw5Uy1atLBrm9mzZ6tDhw6Ki4tzcXWA9wsNDdWcOXNs3mvcyNWrV9WiRQtt2LDBhZUBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOC4e/fuGcb9/PxcOq6/v79h3FY9qSExMdEwfv36dc2aNcttdVy5csVtY8ExDRo00JIlS+Tr65ts31u3bunIkSM6cuSIjh49+tB/r127ZrhNTEyM2SU/FmzNJ7bmH7M4k585OWkWi8Wl+f39/RUfH++S3AEBAYZxd+xj1jPYi/XM9YyOeeZ47+Jtx8mRI0fUpUsX9ezZUy+88IIqVKig8uXLq2jRosqfP78CAwMdytuuXTuFhISoSZMmptbrjRISEjR58mQNHTr0oXhgYKDatm2rH374wea2L7/8snx8fB6KJSYmavLkyXaP7wnrvD1rvLcdOwAAAAAAAAAAAN7Ctf/iDAAAnBYUFKRPP/1Ub775ptUbRVIqODhYb731ll577TV9+OGHGjlypBISEkyqNHl16tRRRESEcufO7bYxXalVq1bKnDmzVXz//v3asWOHVTwhIUE//vij3nvvPau2Dh066O2331Z0dLRLavVWRYsW1dSpU1WhQgWnc9WqVUu1atXSrFmz1KdPH5tvJDKTxWLR0KFD9eGHHzp1/BYrVkzz58/XkiVLFB4erqtXr5pYpbn2799vWq53331XH330kVMfsPCmfecuYWFhGjVqlLp27WrKByyeeeYZRUREaNCgQeratau2bNliQpXmKVGihKZOnaqyZcuakq9u3bqqW7eupk2bph49epj25sPH7XG5LyVzxuO6j8yWVs4tH8c11gxNmzbV+PHjlT17dodzhIaG6t1331X79u3VuXNnbdiwwcQKk+YJ54YbNmzQ4cOHVaRIEau2Ll26aNGiRU7XZqRly5YKCQmxil++fFkLFy50yZj2ypQpk8aMGaPOnTs7nSt79uwaN26c+vbtqzZt2mjv3r0mVPgPT3j+eBquaVNHWnttxNVY863169dPn332mdKlS+dwjqefflo//PCD3nzzTXXs2FG7du0yscL/5w1z7+N6nWHm6zfOSAvXJ8xT8BT37t1T+/bt9eeffyo4ONiqvWrVqho8eLCGDx9uuH3OnDk1fvx4m/m7deumyMhI0+o1m8Vi0QsvvGDYtn79eq89Z/dEcXFxhnF7Pvz9OHlczzEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIC2KjY1Vq1at9N1336lHjx7J9m/VqpWyZMmiZs2aKSoqyg0VAt7p6aef1tKlS1W8eHG7tzl69KgaNmyoY8eOubAyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACcc+vWLcN4WFiYS8fNnDmzYfzmzZsuHTclYmJiDOO3bt1S79693VwNPNXTTz+tGTNmyNfX17D9ypUrmjdvntasWaPffvtNf/31V4rHsFgszpb5WIqOjjaMZ8yY0aXjBgcHO7wtc3LS0qVL59L8GTNm1OXLl12S29ZjaOsxNxPrGezBeuYeRsc8c7z38ObjJC4uTqtXr9bq1asfGit37twqWLCgChYsqEKFCj34/4IFCya77jZu3Fjvvfeehg8f7pKavcnEiRP1/vvvy8fH56F4eHi4fvjhB5vbdezY0Sq2YcMGnTx50u6xvWGd9+ZjBwAAAAAAAAAAwNP5JN8FAACkliJFimjPnj166623rN5Y4ozAwEB99tln2rZtm3LkyGFa3qS0b99eK1asUO7cud0ynjv07NnTMD5x4kSb20yaNEmJiYlW8ZCQELVr18602tKCrl276o8//lCFChVMzfvyyy9r7969KlGihKl5H+Xn56e5c+fqo48+Mu34bdKkibZv366nn37alHxmS0xM1MGDB53O4+vrq2nTpmn48OHy9/c3oTLP33fuUrBgQe3cuVOvvvqq6W+aK1KkiDZt2qR3333X1LzOCA8P1++//66yZcuanrtTp07asmWLcuXK5XSux+1xuS8lc8bjuo/MllbOLR/HNdYMX3/9tRYtWqTs2bObki9v3rxau3atwsPDTcmXHE86N5wwYYJhvFGjRsqWLZtZpT2kS5cuhvEpU6YoPj7eJWPao0qVKjpw4IA6d+5sat6iRYtq+/btevnll03J50nPH0/CNa37pcXXRlyJNf9hvr6+mjRpkr7++mvTPiz/zDPPaPv27erWrZsp+f7NG+bex/U6w6zXb5yVFq5PmKfcLygoyGbb7du33ViJZzp27Jj69etns/2jjz7Ss88+a9g2ZcoUmzcUmDhxohYsWGBKja5StmxZmzdcWLt2rXuLSeP4MHbyHtdzDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABIyxISEtSzZ08NGzbMrv4vvviiNmzYYNr3BQFpTaVKlbR9+3YVL17c7m3WrVunihUr6tixYy6sDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA58XGxuru3btWcT8/PwUHB7ts3EyZMhnGo6KiXDZmSt2+fVuJiYlW8cyZM6dCNfBUw4cPV1hYmFX81q1b6tu3r3LmzKmePXtq7ty5+uuvvxwaI0OGDE5W+XiKiYlRQkKCVdzPz0/p06d32bgZM2Z0eNu0Nif7+vo6tf2jQkJCTM33KKNj2dW5b9265bIx72M9gz1Yz9wjNjbWKuatc/zjKK0dJ4mJiTpz5ox+/vlnTZgwQQMHDlTLli1VqlQpBQcHq0iRInrjjTd08OBBmzneffdd1hNJp0+f1po1a6zizz//vAoXLmy4TeHChVW+fHmreERERIrG9oZ1Pq0dOwAAAAAAAAAAAJ7EJ7ULAAAAxp5//nlt2bJFhQoVctkYFSpU0Pbt21W0aFGXjSFJderU0bRp00x/Y3BqKlq0qKpVq2YVj4uL07Rp02xud+LECf3666+Gbb179zatPm83cOBATZo0SUFBQS7JnytXLm3cuFEVK1Z0SX5JmjFjhlq2bGl63oIFC2r9+vV64oknTM/trFOnTun27dtO55kwYYI6duxoQkUP8+R95w45c+bUzz//rAIFCrhsDIvFouHDh2vUqFEuG8Ne/fr1U0REhAICAlw2RtmyZbV48WIFBgY6nONxe1z+zd4543HeR2ZKS+eWj+Ma6wyLxaLp06erX79+puf29/dXRESEOnToYHruf/O0c8MpU6YoLi7OKu7n5+eSfZEnTx7VrFnTsG3ChAmmj2ev5s2ba+3atcqRI4dL8qdLl04//fST2rVr51QeT3v+eAquad0vLb424mqs+Q8bP368unbtanpePz8/TZgwQW+//bZpOb1h7n2crzPMev3GGWnl+oR5yv2SOve8cuWKGyvxXBEREVqwYIFhm5+fn2bMmGF1s5w333xTtWvXNtzm6NGjeuONN0yv02ylSpWy2bZx40Y3VpL22bohUmqvLZ7icT7HAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDHwYcffqg+ffro3r17yfYtU6aMtmzZ4tJ71gLeqEOHDvr5559TdE/+iRMnqn79+rp27ZoLKwMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwDznzp0zjOfIkcNlY9rKff78eZeNmVL37t3TpUuXrOLp06dXUFBQKlQET/P000+rbdu2VvHY2FjVrl1bY8eOVVxcnNPjZM2a1ekcj6sLFy4YxrNnz+6S8YKCgpyeO71xTrb1PcohISEO12QkT548puZ7lKueF0nlvnz5ssvGvI/1DMlhPUt9njzH4x+P23GSmJioI0eO6JtvvlHx4sX10UcfGfbLkCGDunXr5ubqPNP48eMN4+Hh4Ybxjh07WsWioqI0d+7cFI3r6ev843bsAAAAAAAAAAAAuJtfahcAAACsPfPMM1q1apVCQ0OT7Hf69GktXbpUW7du1d9//61Lly7Jz89PTzzxhHLmzKkaNWqoQYMGypYtm80cTz31lNatW6cKFSooMjLS7D9FOXLk0MyZM+Xj42N67tTUq1cvw/jixYt15cqVJLedOHGiXnjhBat4uXLlVL58ef3+++9mlOi1unfvrs8//zzJPmfPntXChQu1cuVKHTlyRBcvXtStW7cUGhqqrFmzqnDhwqpVq5aaN2+ufPnyGeYICwvT4sWL9eyzz+rMmTOm/g1vv/22WrdunWTt27Zt06lTp3Tz5k35+/sra9aseuqpp1S7dm3Vq1dPYWFhNvPny5dPM2fOVK1atZKsIzo6WmfPnk2yzxNPPKGAgACr+K1bt3T9+vUkt33Upk2bUtTfSO/evdWlSxfDNnfuu7RoxowZyp07t832CxcuaN68eVq/fr327dv34LhKSEhQunTpFBYWpoIFC6p8+fJq1KiRXnjhBVksFsNcAwYM0N69ezVlyhRX/TlJatSokcaMGWOzPknatWvXg+fT4cOHde3aNd2+fVv+/v7KnDmznnzySVWtWlVNmjRJ8vlSrlw5jRs3zuE3w3ra4+LOecPeOcPT9pE3Skvnlp6yxnqTzz77TB06dEi23759+7R8+XLt2rVLFy5c0JUrV+Tj46OMGTOqUKFCev7559W0aVM98cQTD21nsVg0efJkHTlyxCX1u/vc0J4PB16+fFmLFi0yfC527dpVY8aMsetvs1enTp0M562NGzfq8OHDpo5lr5o1a2rOnDny80v65eVTp05p+fLl2rZtm86fP69Lly7p7t27CgkJUc6cOVWhQgW1aNFChQsXNtzex8dH06ZN019//aUtW7akuM60cG3hKlzTuldafW3ElVjzH9a3b1917drVsO3w4cNaunSpdu7cqdOnTysqKkq+vr7Kli2bcuTIoapVq6pBgwbJfsB+5MiROnXqVIo/mPYob5l7Pek6wxtfv3FGWrk+YZ5KHXnz5rXZ5o6bbniLbt26qWLFisqZM6dVW6FChfT111+re/fukqQSJUros88+M8xz9+5dtW/fXrdv33ZpvWawdU0h/XO9C/M8+rrAfVFRUW6uxDN50jkGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMA1vvvuO128eFE//fSTAgMDk+ybP39+bd68WQ0bNtSuXbvcVCHguYYNG6YhQ4Yk+T2D/5aQkKBBgwZp1KhRLq4MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABzHThwQHnz5rWKV6xYUcePH3fJmM8995xhfP/+/S4Zz1GnT5/WE088YRUvUaKEdu7cmQoVwZM0bNhQPj4+VvFvv/1W27dvN2UMHx8fw+cg7HPkyBE9+eSTVvFnn31WJ0+eNH28woUL2/19qLZ445x87do1w3hoaKjDNRkpUqSIqfke9eyzz2rz5s2m582VK5eyZ89uFY+Pj3fJ89AI6xmSwnqW+jx5jsc/HufjJDExUf/5z3+ULVs29enTx6q9Xr16+uKLL1KhMs+yePFiXbhwwWrN79Spk95//30lJiY+FG/fvr1Vjv/973+6fft2isf25HX+cT52AAAAAAAAAAAA3MEvtQsAAAAPy5w5s5YtW5bkm2j//PNPDRo0SKtXr04yV0REhCwWi9q2bavhw4crX758hv1y5sypJUuWqHLlyoqNjXWq/keNHDlSWbJkMWzbvXu3li5dqu3bt+vChQu6fPmy7t69+6D91q1bptZilsDAQHXu3NmwbcKECcluP2/ePI0dO1ZhYWFWbb169VL37t2dLdFrVaxYUWPHjrXZfvHiRX300UcaP378Q8+V+65du6Zr167p6NGjWrZsmd555x116NBBI0aMUM6cOa36P/HEE5o3b54qVqxo9QYtRxUpUkTDhw+3ih84cEBDhgzRggULktx+4sSJCg4O1jvvvKN33nlH6dOnN+xXs2ZNde3aVRERETZzTZkyRVOmTElyvK1bt+r55583rKN///5Jbmu2XLly6fPPP7eKp8a+S2tatWqlGjVqGLbFxMRo6NCh+uabbxQXF2fY59atW7p165bOnj2rX375RV9++aUKFy6szz//XM2bNzfc5ttvv9X69et15swZs/4Mu+TIkUPTpk2z+cGcHTt2qH///tqyZYth+7179xQZGanIyEj9/vvv+vrrr1WxYkWNHz9epUqVMtzm1Vdf1aRJk7R169YU1eqJj4unzRueuI+8TVo6t/SkNdZbtGzZUgMHDkyyz/Lly/Xee+9p9+7dNvts2LBBkyZNUs+ePfXyyy9r2LBhKlCgwIN2f39/TZ06VYGBgabVLqXOuaHFYrHrvHD8+PFq3bq1VbxkyZIqW7as/vjjj2Rz2KtLly42a0gNBQoU0Ny5c+XnZ/ul5a1bt2rw4MHasGFDkrnmzZunwYMHq379+hozZozhhz99fX01Y8YMlSpVSjdv3rS7zrRwbeEqXNO6X1p8bcSVWPMf9vTTT+uzzz6ziq9bt07/+c9/tGnTpiS3nzZtmqR/PqA1fPhwlS5d2mbfH3/8UXv27NGRI0ccqtVb5l5Pu87wtOswV0or1yfMU6mnSZMmhvGEhIQkr2keN1evXlXnzp21Zs0aw9fIunXrpmXLlmn58uWaMWOGzWu5Dz74INU/YGyvQoUKGcbPnj37WJ5PuUr69OkNb8AkyW03vvFknnaOAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwnXnz5unKlStatGhRkvdfl6Ts2bPrl19+UfPmzbV+/Xo3VQh4lsDAQP344496+eWX7d4mOjpaHTt21MKFC11XGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALrJv3z41aNDAKl61alXNmDHD9PGKFCmiLFmyWMVjY2N1/Phx08dzxt69e/Xss89axStWrKidO3emQkXwJNWrVzeMz5o1y7Qxypcvr3Tp0pmW73Fz+PBh1ahRwypeqVIlzZkzx/TxjMZKKW+ck69du2YYz5cvn1O1PcqM/ZuUSpUq6euvvzY97/PPP28YP378uBISEkwfzwjrGZLCepb6PHmOxz84TqQPPvhAPXr0kJ+f30PxChUqpFJFnuXu3buaMmWKBg4c+FA8d+7cqlmzptatW/cgVrFiRRUoUMAqR0REhENje/I6z7EDAAAAAAAAAADgWj6pXQAAIHWkC5WK1pCqdJRqvya92EOq2EZ6qrTk45f89nCdMWPG2HwDbUJCggYNGqSyZctq9erVduVLTEzUrFmzVKRIEf33v/+12a9cuXL68MMPHarZltKlS6tDhw5W8V9++UUVKlRQmTJlNGTIEC1ZskQ7duzQiRMndPr06Qc/V69eNbUes7Ru3VqZMmWyip85c0Zr1qxJdvuYmBibb/hr166dQkJCnK7RG/n6+ioiIkIBAQGG7b///rvKli2rb7/9Vnfv3rUr57179zR16lSVK1dOW7duNexToUIF9enTx+G6HzV8+HD5+/s/FPvqq69UpkwZLViwwK4c0dHR+s9//qMXXnhBV65csdnvo48+snpDnjerUKGC1fOffWeO/v37G8ajo6P14osvatSoUYqLi0tRziNHjqhFixbq0aOH7t27Z9WePn16vf/++w7V64z//Oc/hnO0JH355ZeqVKmStmzZkqKc27dvV5UqVbR+/XqbfQYNGpSinNLj9bg4in3kvLR0bskamzIZMmTQ2LFjbbbfunVLLVq0UKNGjbR79267ciYkJGjGjBkqWbKkJk2a9FBb0aJFlS1bNqdq/rfUOje097xw7dq1OnnypGFbly5d7Mphj8qVK6tgwYJW8evXr2vu3LmmjZMSEydOtLnWxsfHq3v37qpcubI2bNhgd86VK1eqXLlyNv+mvHnzpmitTSvXFq7CNa17pdXXRlyJNf9hZcqUUfr06R/8fn+urV27tjZt2mR3nuXLlz94viUmJhr2CQ4O1rhx4xyq05vmXq4zUk9auT5hnkodWbJkUf369Q3b9u/fr5s3b7q5Is+2bt06jR492mb7xIkTNWHCBJUsWdKwfePGjfrss89cVZ7p8ufPbxg/c+aMmytJ2+rUqWM1/9134MABN1fjeTjHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDHyy+//KLq1avr/PnzyfYNCQnRihUr1KZNGzdUBniWbNmy6eeff9bLL79s9zaRkZGqXr26Fi5c6LrCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwoTVr1hjGGzduLF9fX9PHa968uWH8119/1b1790wfzxk7duwwjL/wwgvuLcQDueK54W2efPJJw/jBgwdNG6NmzZqm5Xocbdy40TDeoEEDl4zXpEkTp3N445x89epVw3i5cuUcLcuKn5+f6tata1o+IzVr1lRAQIDpeRs2bGgY37Rpk+lj2cJ6lrTHfU1La+uZNz6enjzH4x9p7ThxxJUrV/Tnn39axUNCQkxdP73xGL5vwoQJhvHw8PCHfu/YsaNVn6NHj2rLli0OjevJ6zzHDgAAAAAAAAAAgGv5pHYBAAD3ypxHavqe9Posqem7UpWOUrkmUoWWUo2u0sufS31nS1U6SQHpU7vax0/NmjXVqVMnw7aYmBi1aNFCX3zxhUO54+Pj1a9fP/Xu3VuJiYmGfd555x2VKFHCofxG+vbtK4vF8uD3u3fvqlevXnrxxRe1c+dO08Zxt169ehnGJ0+ebHPfPmrixImG8eDgYHXo0MHh2rxZ3759VaxYMcO2rVu3qmrVqoqMjHQo94ULF1SzZk3t2bPHsP2TTz5RhgwZHMr9qGefffah3998800NGDBA8fHxKc7122+/qW7duja3zZ07t803eqYF7DtzZM2aVZUqVTJse/vtt7Vt2zan8k+YMEF9+vSxip8/f17Hjh1zKndKWSwWm286/PLLL/X2228rISHBody3bt1S69atdf78ecP2pk2bqlChQnbne5weF0exj5yX1s4tWWNTZujQoTbnxAsXLqhy5cpauHChQ7nv3Lmjbt26aeTIkU5UmLTUOjdMyXmhrXP69u3by9/f36HaHtWlSxfD+PTp0xUTE2PKGCnRqVMnmx8yuHnzpurUqWNzvyTn9u3batu2rebPn2/Y3rdvXwUHB9uVK61cW7gK17TulVZfG3El1nzb4uPj1aRJE4fnWkn69NNP1apVK929e9ewvXbt2g7tE2+Ze7nOSD1p6fqEeSp1fPPNN0qXLp1h25IlS9xcjXcYPHiwdu/ebdiWJUsWde7c2bDtxo0b6tixo93nhp4gLCzMMG7rtTw4pn379jbbNmzY4MZKPA/nGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADweNq9e7cqV65s171iAwICNHPmTL3xxhtuqAzwDMWKFdP27dtt3sfZyJ9//qnnnntOu3btcmFlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC41q+//qro6GireJ48edSqVStTx/L391e/fv0M2xYvXmzqWGZYvXq1Ybxp06bKli2bm6vxLCEhIaldQqrLlCmTYTwmJsaU/D4+PurevbspuR5Xa9asMYwXLVpUtWvXNnWs/Pnzm5LTG+fkAwcOGMZz5MihggULOlTbo1566SWXz7vZsmXTyy+/bGrOrFmzqn379oZtK1euNHWspLCe/cPo2JJY07x1PfPWx9Pb5nj8w9uOkxw5cpiW698iIyMN42FhYSnO5a3HcFKOHTumX375xSresmVLZciQQZLk6+urNm3aWPWJiIhweFxPXue97dgBAAAAAAAAAADwNj6pXQAAwH1K1JHCx0lFq0uWJFaAwGCpSgfplbFSlqfcVx+kTz75xGbb66+/bsobt77//nuNGDHCsM3Pz08ffvih02Pc9+83RsfGxqpx48b64YcfTMufGooVK6YqVapYxRMTE1P0Bp4//vhDf/75p2Fb7969HS3Pa/n5+WnQoEGGbRcuXFCrVq2cfsNQTEyMWrZsqVu3blm1hYWFKTw83Kn8RkaPHq2vv/7aqRy7du3S8OHDbbZ36NDBqfyein1nnjJlyshisVjFb9y4ocmTJ5syxvjx47Vw4UJJ/3w4pGvXrsqbN69GjRplSn57JSYmqlmzZipXrpwWLFigxMRESdLWrVs1cOBAp/NfvXrVZh6LxaIGDRrYnetxelwcxT5yXlo7t/w31omkZciQweY55b1799SmTRvt3bvX6XEGDhzokg+XpOa5YUrOCyMiInT37l2reJYsWdSkSROn6pOkoKAgww8OSP/MX+5msVj0wQcf2Gzv2rWrfv31V6fGSEhIUOfOnXXkyJEHsfj4eP3444967rnnbH6I5N/S6rWFWbimdb+0+NqIO7HmP6x///5atWqV03nmz5+vwYMH22xP6fWTN829XGeknrR6fcI85R5vvPGGzRtu3L17V99++62bK/IO8fHxateune7cuZOi7Xr16qXTp0+7qCrXCA4ONoxfv37dvYWkYVWrVrV5jfr333/rt99+c3NFnoVzDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4fJ08eVJVqlTR77//nmxfHx8fjRkzRp999pkbKgNSV506dbRlyxbly5fP7m2WLFmiqlWr6ty5cy6sDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA14uLi9Ps2bMN295//335+/ubNlaPHj2UM2dOq3hsbKzmzJlj2jhmOXHihPbu3WsVDwgIUPfu3U0dK2PGjMqRI4epOV0pb968qV1CqouKijKMZ8uWzZT87dq1U4ECBUzJ9bi6cOGCtmzZYtj23nvvmTrWxx9/LIvF4nQeb5yTjxw5oitXrhi2hYeHO1reA35+fvrPf/7jdB57vP322/L19TUt31tvvaWgoCCreHR0tFavXm3aOMlhPfvHtWvXDOOP+5rmreuZtz6e3jbH4x/ecpzkzp1b3333nf766y81a9bMhMoeFhAQYBi/c+dOinN56zGcnAkTJljF0qdPr9atW0uS6tSpoyeeeOKh9oSEBE2dOtXhMd21zjuyxnvLsQMAAAAAAAAAAOCtfFK7AACAe5RpLDUcIPkZv3fDUKacUocv//kvXK9SpUqqVKmSYdv06dM1adIk08YaOnSofvnlF8O2li1bmvZmin+/MXrAgAFatWqVKXlTU69evQzj69at019//ZWiXBMnTjSMlypVShUrVkxxbd6sVatWNt9Y9NZbbykyMtKUcY4fP274Bi1J6tOnjylj3Ld//34NHDjQlFyff/65bt68adhWq1YtU8bwJO7cd2a+8d9TGb0ZWPpnP8fGxpo2zoABA9SwYUMVL15ckydPVlxcnGm5U+qPP/5Qy5YtVbJkSc2aNUt9+/ZVQkKCKblnz55t88Mv1atXtzvP4/i4pBT7yDlp8dzyPtaJ5HXu3FkhISGGbcOGDdOGDRtMG6tbt266ceOGafmk1D83tPe88Pz581q2bJlhW5cuXZyqTZJatGih0NBQq/j27dsN3/zvao0bN1bBggUN277//nvNmzfPlHGio6PVp08fRUdHa/To0cqXL5+6dOmiQ4cO2bV9aj9/JPOvLczENa37pcXXRtyFNf9hGzdu1Lhx40zL9+WXX2r58uWGbZUqVVL58uXtzuVNcy/XGakjrV6fME+5Xrp06TRmzBiNGTPGZp/p06fr3Llz7ivKyxw8eFDvvPOO3f2nT5+uWbNmubAi1wgODjaMx8TEuLmStClHjhyKiIiw2T516lTTXn/1VpxjAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDj7eLFi3rhhRe0bt06u/oPGjRIkydPdvt9yDNmzKjnnntOLVu2VPdu3fVGvzc04K0B6v9mf73+2uvq3KmzGtRvoKJFisrf39+UMfPkzqNSpUol+fPkk0+aMpaj0gWlU+nSpdWkSRN16dJF/fr204C3BmjAWwPUr28/denSRU0aN1HpUqWVLiidw+MEBAToueeeU/t27fVan9c04K0Bev2119WxQ0dVqlTJqdz/VrRI0Yf2b+bMmU3JmxK9evXS8uXLlTFjRru3GTlypJo3b67o6GgXVgYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgPuMGjVKiYmJVvGSJUtqzJgxpoxRtmxZjRo1yrBt6tSpunjxoinjmG3ChAmG8ffff1+FChUybZzRo0fr8OHD6tevn3x8fEzL6yqFChVS9uzZU7uMVHX58mXDeKVKlZzOnStXLo0ePdrpPJDGjRtnGH/xxRc1YMAAU8aoX7++2rdvb0ouyTvn5C1bthjGu3fvrrCwsJSW95D33ntPRYsWdSqHvUqWLKmRI0eakqtGjRoaOHCgYdu0adMUFRVlyjj2Yj2Tzp07Zxh/3Nc0b13PvPXx9MY5Hp5/nOTOnVvffvutjh8/rl69eikgIEDffPON6d8dX7BgQavY7du3HVrTvPUYTs68efN09epVq3h4eLgkqWPHjlZtq1evVmRkpFPjumOdd2SN9/RjBwAAAAAAAAAAwNt51jszAAAukauYVLu3Y9sGhUgtP5J8/MytyROtWLFCv/32m6k/r7zyit3j9+jRwzB+9+5dvffee2b9mZKkhIQEDR482LDNx8dHXbt2NXW8ZcuW2XxDtjcJCgpSp06dDNsmTpyY4nw//fSTYmJiDNt69eqV4nze7P6box51/PhxzZo1y9SxRo8erXv37lnFn3nmGRUoUMC0cd544w3dvXvXlFx37tzRjBkzDNtCQkJMGcOTuHPfuetDBqkpKCjIMH79+nVTxzlx4oRWrFhhak5n7d+/X+3atdPvv/9uWs64uDgtWbLEsK1atWp253mcHxd7sY+ck5bPLVknkvfyyy8bxqOiokx/8/SlS5c0YsQIU3Om9rlhSs4Lx48fbxhv0KCB0x9q6NKlS4rGdDVb9cTFxenDDz80dax169bpySef1FtvvWXzgyO2pPbzRzL/2sIsXNOmrrTy2og7seY/7J133jE950cffWSzzdb5hBFvmnu5zkgdafX6hHnKdcLCwtS7d28dP35cb7zxhs1+58+f11tvveXGyrzTuHHjtHz58mT7nTp1Sn369HFDReYLDg42jMfFxbm5krQnf/782rhxo80PmkdHR+vLL790c1Weh3MMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMCtW7fUoEEDu/uHh4dr4cKFSpcunQur+kdYWJiaN2uu7t26q3q16sqfL78yZswof39/WSwW+fr6KigoSE888YSKFy+uxo0bq0f3HqrwbAVZLBanxq5YsaLq1qmb5E/hQoVN+ktTJigoSLVr1VavXr1Up3YdFSlcRFkyZ1FAQIAsFossFosCAgKUJXMWFSlSRHXq1FHPnj1Vq2YtBQYGpmisvE/lVbdu3VS9WnXlzJlT6dKlk8ViUVBQkHLkyKEqlauoW7duKliwoFN/0/3H7/6+LVe2nG7evOlUzpTw8fHRf//7X3333Xfy87Pvy5Dj4+PVrVs3DRw4UAkJCS6uEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA9zl48KD+97//Gbb16dNH/fv3dyp/oUKFtGDBAgUFBVm1xcTE6LPPPnMqvytNmjRJly5dsoqnT59eP/30k4KDg50eo1u3burSpYtCQ0P19ddfa9euXapUqZLTec1y9uxZw3ifPn3cXIlnOXLkiGG8Z8+eTuVNnz695s6dq2zZsjmVB/+YM2eOTp8+bdj22WefqUmTJk7lL1asmGbMmOFUjkd545xsq94nnnhCo0ePTnG++5o1a6YPP/zQ4e0d0b9/f3Xv3t2pHM8884xmzZolX19fq7a7d+9qzJgxTuV3BOuZdO7cOdY0A966nnnr4+mNczw8/zj5/vvv1bt3bwUEBDyIPfXUU5ozZ47SpUvnVO77nnvuOcPvt7d1HCbHW4/h5MTGxmr69OlW8WrVqqlEiRJq3ry5VVtERITT47p6nXd0jff0YwcAAAAAAAAAAMDb+aR2AQAA13uxu+Rj/V5Eu2XJI5VpaF49nqpUqVJ69tlnTf2JiYmxa2yLxaKGDY138pw5c3TmzBkz/1RJ0vbt27V582bDtsaNG5s61kcffWRqvtTSpk0bhYWFWcWvXr2qBQsWpDjf9evXNX/+fMO2tm3bKmPGjCnO6Y0CAwNVvXp1w7Zx48YpISHB1PHOnDmjPXv2GLbVr1/flDH+/PNPrVu3zpRc9y1evNjUfJ7K3fuuZMmSpo7liWytRZkzZ3ZzJWnHjh07DONPPPGE3W+65XFJHvvIcWn53JJ1InkhISE236Q9adIkRUVFmT7m+PHj7b72SY6nnBvae164cuVKww81+Pr6qmPHjg7XlStXLtWqVcsqHhUVpdmzZzuc11F+fn6qXbu2YduMGTN08eJF08d05LnqKc8fybxrCzNxTZu60sprI+7Cmv+wXbt2afv27abn3bFjh7Zs2WLYVq9ePbtyeNvcy3WG+6XV6xPmKXMEBgYqS5YsKlKkiJo3b6733ntPq1at0sWLF/Xtt9/qySeftLltfHy8OnfurGvXrrmxYu/15ptvJttn6NChLrlmdAeLxWIYT0xMNG2MZcuW6eDBg6b8rF271rS6XCUoKEhDhw7Vvn37DG8OcN8HH3xg+OH0xw3nGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA6Z97aP/3v/+1u3/jxo21bt06ZcqUyWU1FS1aVK90fiXJ+w0bSZcunWrUqKE2rdvI39/f4fFd+bc5I2fOnOoS3kVlypSRr6/9X/rr5+ensmXLqkt4F+XIkcOubZ566im1bNlS6dOlfxCLiYnRtWvXHrrHcWBgoJo1baaCBVL2WN2XJUsW1a71/98zFB8fryVLluju3bsO5UupDBkyaOnSpXr99dft3ubatWuqX7++Jk2a5MLKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABIPW+88YZu3Lhh2PbVV1/p+++/V0BAQIrz1qlTRzt27FDevHkN2z/66COdOHEixXnd5fbt2/rwww8N2ypUqKANGzboiSeecDh/v3799MMPPzwUK126tDZv3qx69eo5nNdMv/zyi2F88ODBql69unuL8SCrVq0yjNepU0evvvqqQzlz5sypTZs26fnnn38Q27Vrl0O58I/4+Hi99dZbhm1+fn5auHCh3nnnHYdy16pVSxs3bnzou3HPnTvnUK5HeducPGvWLEVGRhq2hYeHa/jw4SnO2b17d82dO1c+Pj4PYkeOHElxHns8Wvv48eP11Vdfpeg7he9r1KiRtm3bZvN7hceOHavDhw87VKczWM/+wZpmzZvXM299PL1tjofnHydDhw5VYmKiVbxmzZpat26d8uTJ41De+8LCwmx+x/uKFSsczuutx3Byxo8fbxWzWCyaMWOGgoODH4pfu3ZNixYtcnpMV67zzqzxnn7sAAAAAAAAAAAAeDuf5LsAALxZ9kJSzmecz1OuqfM5HkdHjx61q1/58uVtvjFj8uTJZpZkV+5SpUopd+7cpozx22+/6bfffjMlV2rr1auXYXz69OmKi4tzKOfEiRMN4+nSpVOnTp0cyultqlSponTp0hm2rVy50iVjbt682TBerlw5U/JPnz7dlDz/tnPnTtNzeiJ37ztn3xzpDS5dumQYL126tIKCgtxcTdqwb98+m22ZM2e2KwePS/LYR45Ly+eWrBPJq1atmvz8/AzbZs+e7ZIxr127ptWrV5uSy1PODe09L0xISFBERIRhW9euXR2uqVOnTg99IPK+mTNnKjo62uG8jqpcubJCQkIM26ZOnermamzzlOePZN61hZm4pk09aem1EXdhzX/YrFmzXJbb1vlByZIllS1btmS397a5l+sM90ur1yfMU9ZOnDihO3fu2P0THx+vmJgYXb58WYcOHdKCBQv06aefqm7duvL3909yrHv37unll1/WmjVr3PTXeb///Oc/yfYZPHiwAgMDXV+Ml6pZs6aKFi1qyk+BAgVS+88xlDVrVtWvX18RERG6cOGChg0bZnOdl6TVq1dr9OjRbqzQc3GOAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC4r1+/fnr//feVmJhoV/9KlSpp06ZNpn3P078VL15cjRo2srr/d3x8vI4fP64//vxDW7du1fbt27Vn7x79/fffVnXnyZNHLZq3cGh8Hx8fm997k5ry5M6jNq3bKDg42Krtxo0bOnHihPbu3au9e/fqxIkTunHjhlW/DBkyqG2btsqZM2eSYwUEBKhRw0by9fWVJEVHR2vevHkaO26sJkVM0thxY/W/Of9TVFSUJMlisah+/fpJ3iPaiJ+fn5o0afLQY7123VpduXolRXkclSdPHm3ZskUNGjSwe5vjx4+rUqVKWr9+vQsrAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgdV24cEG9evWy2d6zZ08dOXJEHTt2lJ+fX7L5ihcvrgULFmj16tUKCwsz7LNp0yaNHDnS0ZLd5rvvvtOvv/5q2FauXDnt27dPffr0sWu/3FeyZEmtWLFCX3/9tXx8fKzaf/vtN61Zs8bhms30/fffG8YDAgK0du1affbZZ8qbN6+bq0p9Gzdu1OXLlw3bxo8fr6FDh9r9nAgICFC/fv20e/dulS1b9kH8+vXr+uCDD0yp93E2b948LV261LDNx8dHX3zxhXbt2qV69erZla9o0aKaOnWq1qxZo8yZMz+Ix8TEaMiQIabU7G1z8t27dzV69Gib7e+++66WLVumQoUKJZurXLlyWrFihcaPH//Q3/bbb79p4cKFDtWXnB9++EHHjh17KNa/f38dOHBArVq1ksViSTZHyZIltXjxYi1dulShoaGGfU6dOpWqx/Tjvp5JrGlGvHk989bH09vmeHj+cfLHH3/ou+++M2yrVKmSDhw4oKFDhypr1qwpzl2vXj3t2LFDJUqUMGyfM2dOinPe563HcHL279+vbdu2WcVLlixpFZsxY4bi4uJMGdfsdd6MNd7Tjx0AAAAAAAAAAABvZ/87PAAAXqlABXPyZM4tZcwu3bhgTr7HxfHjx+3qV65cOcN4QkKCtm7damZJD9m0aZPNttKlS+vs2bNOjzFz5kync3iCEiVKqFKlSoZtEydOdDjvzz//rBMnTih//vxWbb169dLYsWMdzu0tSpcubRiPjIzUwYMHXTLmnj17DOPPPPOMKflXrVplSp5/u3Tpki5cuKDs2bObntuTuHvfpfX9KcnqQw73pUuXTm+88YY+//xzN1fk/a5du2azLVOmTDp37lyyOXhcksc+clxaPrf05HUiMDBQ5cuXN7O0B86fP68TJ07Y1bd48eKG8bi4OO3atcvMsh6ydu1aNW3a1Ok8nnJumJLzwokTJ2rIkCFWb5gvVqyYnn32We3cuTPFNXXp0sUwPn78+BTnMoOtx+XevXvavn27m6uxzVOeP5J51xZm4Zo2daWV10bcyZPX/NTw888/uyx3UueHxYoVs/lBs/u8be7lOsP90ur1CfOUtcDAQLeMc+HCBXXs2FFr1651y3hpQfv27dW+fftk+xUvXlwjR45Uv3793FCVd8mVK5eCgoJSu4wkjRkzRtHR0Xb3t1gsCgwMVGhoqDJmzKh8+fIpZ86cdm+/a9cutWrVSomJiY6Um+ZwjgEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+Lfhw4fr/PnzGj9+vHx9fZPtX6xYMW3ZskX16tUz7V7/WbNmVd06dWWxWB7E7ty5o183/KpDhw7p7t27htuFhISoWrVqKvZMsQexp556yqHv4klISND3P3xvFa9cqbLKlCmTolxmSZ8+vZo1ayY/v4e/2v348ePasmWLLlw0/uLe7E9kV+XKlVWgQIEHMX9/fzVv1lwRkyMUExNjuF2pUqUUHBz84PdFixcpMjLyoT6nT5/WgoUL1KljJ1ksFgUFBalsmbLasnWL3X9X7Vq1lTVL1ge/7z+wX/v377d7e2dUqFBBixcvVo4cOezeZtOmTWrevLmuXLniwsoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPAMs2bNUokSJfT+++8btufNm1fTpk3T2LFjtWrVKu3YsUPnz5/XlStXFBwcrOzZs6tQoUJq0KCBihQpkuRYJ06cUPPmzXXv3j1X/Cmma9OmjX777Tc99dRTVm3ZsmXTuHHj9MEHH2jFihVau3atzpw5o4sXL+r27dsKCAhQSEiInnrqKZUqVUoNGzbU888/b3Osv//+W61bt1ZCQoIr/yS7bd68WZs2bVLVqlWt2vz9/TVo0CANGjRI586d0+nTpxUVFWVY+4ULFxQeHu6Git0jNjZWn376qUaPHm3V5uPjo2HDhqlXr16aNm2aNmzYoMOHD+v69euKiYlRxowZ9cQTT6hgwYKqV6+eGjVqpCeffPKhHImJiXrllVd06dIld/1JaVrHjh21c+dOFSxY0LC9bNmyWrlypc6fP68VK1Zoz549unDhgq5du6bAwEBlzpxZJUqU0IsvvqiyZcsa5njjjTd04sQJ02r2tjl59OjRatasmeFcIUkNGzZU/fr1tW3bNq1atUqnT5/WpUuXZLFYlDlzZpUsWVJ16tRR6dKlrbaNjY1V165d1aFDB4frS0pMTIw6deqkX3/9VQEBAQ/ihQsX1pw5c3T58mWtXLlSv//+u86fP69r164pJCTkwT6uX79+svv4zp07at68uaKiolzyN9jrcV7PJNY0I968nnnz4+ltc/zjzhuOk/79++u5557Ts88+a9WWIUMGDRs2TEOHDtWWLVv0yy+/6ODBgzp16pSioqJ0+/ZtWSwWBQcHKywsTAUKFFDZsmXVsGFDFSpUyOaYS5Ys0ebNmx2u2ZuP4eSMHz8+yTXyvoiICFPHNWudHzx4sClrvDccOwAAAAAAAAAAAN7ML7ULAAC4Vhbrf/93WOY80o0L5uVL6y5fvqwbN27Y1bd48eKG8T179ujWrVtmlvWQw4cP68qVK8qSJYtVW7FixbRs2TKnx9i2bZvTOTxBz549DeM7d+7U3r17ncodERGhTz75xCpevHhxVa5cWVu2bHEqv6crWrSoYXz//v0uG/Pq1auG8bx58zqdOzY2VgcOHHA6j5GrV68qe/bsLsntCVJj36VLl84l43mSo0eP6q+//jJ8fn/66ae6du2axo8fnwqVea+k1vewsDC7cvC4JI995Li0em7p6etErly5nHpjfFK+//579e7d266+tj4c8scffyguLs7Msh6yc+dOU/J4yrlhSs4Lz5w5o9WrV6t+/fpWbV26dEnxvnn++edVuHBhq/iff/6p33//PUW5zFKsWDHD+O7du3X79m03V2Obpzx/JHOuLczENW3qSiuvjbiLp6/57paQkKDdu3e7LP+ff/6pmJgYBQUFWbUVLlxYv/76a5Lbe9vcy3WG+6XF6xPmqdSRmJioOXPm6PXXX+fDoCmQN29effvtt3b379u3r1asWKEVK1a4sCrzJSQkyMfHxypuFHOErZsMeZLWrVu7bay1a9eqZcuWqX7jG0/COQYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4FERERG6dOmSZs+ebdf9xvPkyaNNmzapUaNGpnzXRd06deXr6/vg96tXr2rW7FnJft9MVFSUli9frltRt/Tcc889iFd8rqJ2796t+Pj4FNVhNF5Kc5ipdu3aD31HQ2JiotauXavde5L+bogLFy9owcIFKlOmjGrXqv0gnj59er344os27+/97+91OHP2jCIjIw37Xbx4UadOnVK+fPkebLdlq33f+1KsWDGVKFHiwe9Xrl7RmjVr7NrWWS+99JKmTZuWonvqT58+Xa+++qpLv1MLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABPM2TIEFksFr333ns2+2TMmFFt2rRRmzZtHBrjwIEDql+/vq5cueJomW538eJF1a5dW+vXr1fu3LkN+2TPnl3h4eEKDw93eJwLFy6oXr16On36tMM5XKFz587avXu3QkJCbPbJlSuXcuXKZbP91KlTLqgsdX377bfq3LmzypYta9ieM2dODRo0SIMGDUpx7kGDBmnx4sUPfXcrHHfjxg3Vr19f69atU968eW32y5Ejh7p06ZLi/N98843Gjx+v6tWrO1OmFW+ak+/du6e2bdvqzz//VLZs2Qz7+Pj4qHLlyqpcubLdeRMTE9WrVy/t27fPqfqSs23bNvXq1UuTJk2SxWJ5qC1r1qzq2LGjOnbs6FDuO3fuqGXLltq9O+nvJ3aHx309k1jTjHjzeubNj6c3zfHw/OMkLi5ODRo00KpVq1SuXDnDPv7+/qpRo4Zq1Kjh8Dj3Xb58Wb1793Y6jzcfw0mZPXu2xowZo9DQUJt99u7dq127dpk6rjvW+ZSu8Z5+7AAAAAAAAAAAAHgzn9QuAADgWukzmpgrzLxcnujw4cPat2+faT/r1q2ze+zChQsbxg8dOmTWn2fT4cOHDeNFihRxOnd8fLzpb25JDenSpVOnTp0M2yZOnOh0/smTJ+vevXuGbWa8wcrT5c+f3zDuyjcQX7t2zTCe1JvQ7HX8+HElJCQ4ncfIjRs3XJLXU6TGvgsICHDJeJ5m+vTphnFfX1/98MMP+uOPP9SnTx+bx+PjLGvWrHruuefUrl07DRkyRJMnT9bs2bNt9vfxsf8ym8cleewjx6TVc0vWCfvky5fPMH78+HGXjnvs2DFT8njKuWFKzwvHjx9vGG/Xrl2Kn0e23qRvawx3KFCggGH8yJEjbq4kaZ7y/JHMubYwC9e0qSutvDbiTqz5Dztz5ozi4+Ndlj8+Pl5nz541bLPnPNsb516uM9wrLV6fME+5V2xsrP73v/+pVKlSatu2rS5dupTaJXkNHx8fTZ8+XRkzpuwfCydPnmzzZi+eKiYmxjBu1rFTsGBBU/J4u7i4OA0ZMkR169ZVVFRUapfjcTjHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8asmSJapTp47N++w/KnPmzFq3bp0aNWrk1LhFixZVzpw5H/x+584dzZ07V7dv37Y7x8ZNG3Xx4kXFxMTojz//0Lz581z6/QnukPepvCpc6OF76G/ctFG79+y2O8eff/6pzZs3PxQrXqz4Q/v7Pj8/Pz2R7YkHv5/+K+nvcvjr9F8P/j9z5swKCgpKtp7MmTOrTu06D36Pj4/XkiVLdPfu3WS3ddbgwYM1Z84cpUuXzq7+iYmJGjp0qDp16qS4uDgXVwcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgOd5//331a1bN0VHR5uee9myZapSpYrOnDljem5XO3r0qCpVqqQdO3a4JP+uXbv07LPPau/evS7J74yTJ0+qZcuWunHjRmqX4lHi4uLUoEEDnTx50rSc8fHx6tmzp0aOHGlaTvzj+PHjqlKlinbt2mVq3s8++0xvvPGGqTn/zZvm5MjISFWrVk3Hjx83JV9CQoJef/11/fjjj6bkS87kyZMVHh5u6nckX7hwQXXr1tXKlStNy+msx3k9k1jTjHjzeubtj6c3zfGPO284Ti5fvqwXXnhBCxcuNCWfLWfPnlXVqlV17tw5p3N5+zFsy+3btzVz5swk+0RERLhkbFeu846s8d5w7AAAAAAAAAAAAHgrv9QuAADgWnfNey+j7pmYyxPVrFlTkZGRqTJ2WFiYYfzatWsuH9vWGBkzZnQ699mzZxUbG+t0ntTWtm1bw/1hzxt87BEZGalVq1apYcOGVm2tWrVSv3793PJcSC2hoaGGcR8fHz333HMuGbNAgQKG8QwZMjid+9KlS07nsMUVbxT1JOw71/niiy/Uu3dvZc6c2bC9TJkyGjdunCTpxo0bOnTokI4fP65jx449+Dl+/LguXrzozrLdwtfXV3nz5lX+/PlVoECBh37y58+vkJAQl43N45I89pFj0uq5JeuEfWzNW9evX3fpuJcuXdLdu3fl5+fcy42ecm6Y0vPCxYsX68KFC8qePftD8UyZMqlZs2aaM2eOXXkCAwP18ssvW8Xv3Lmjn376KUU1mcnWMexp1yme8vyRzLm2MAvXtKkrrbw24k6s+Q8z48N3ybF1jNpzPeSNcy/XGe6VFq9PmKfc4/Lly3rzzTe1ePFiRUVFpXY5Xundd99V1apVDdtOnDghi8WifPnyWbVlz55dkydPVuPGjV1domliYmKUPn16q3hgYKBp+ZcuXZri7QoWLKiiRYuaUkNqunfvnubNm6d3331XJ06cSO1yPBbnGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI5s3b1a1atW0YsUK5cmTJ9n+6dOn18KFC9WtWzdNmTLFoTFLlSz10O9bt23VzaibKcqRmJio+Qvm686dO7p3755DdXia0qVLP/T7xYsXtWPHjhTn2bZ9m4oUKaKsWbM+iJUqVcrqO3HTp08vHx+fB78n9z1Sj7YHBwcrJibGZn8/Pz81bdJU/v7+D2Lrf16vy5cv2/FXOC4gIEATJkz4P/buO0zK6vwf8LOFtnSRIlJUUDAqWCg2UBFUxK5RirEn0TR/sSXGNI1pRo3JN0aD2KKggIJBBRQriiBKERUQLFjpCEtn2d3fH7lCsu4sbpnZYXbv+7q84nvOe57z2ZnZd84ZN/PGBRdcUO4xmzdvjgsuuCAee+yxFCYDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAXd+9994bL7zwQvz973+Pk046qcr1li5dGtddd108/PDDSUiXPp999lkcffTRce2118YNN9wQeXl5Va65adOmuPHGG+O2227bpe/P+dxzz0WvXr1ixIgR0adPn3TH2WUsX748evfuHffff38MGjSoSrXmzZsXF154YcydOzc54Sjl888/j969e8cvfvGL+MlPfhL16tWrdK1Vq1bFpZdeGhMmTEhiwsQy6Zr83nvvRa9eveLhhx+OgQMHVrrOypUrY9iwYTFlypQkpvt6//znP2P+/PkxatSo2HfffatUa+zYsXHFFVfE6tWrk5QueWrz+1mE97REMvn9LNOfz0y6xtd2mfB7sn79+jjzzDPjnHPOidtuuy06dOiQtNrFxcUxcuTIuPbaa2PZsmVJq5vpv8NlGT58eHz3u99N2FdQUJDS39Fkv89X9T0+E353AAAAAAAAMlFuugMAkFqb1iav1sYvk1eLkho3bpywfe3atSmf+8svEz+xZWVKRu1Mc/nllydsf+yxxyI/Pz8pc4wYMSJOPvnkUu3169ePCy+8MO64446kzLMratSoUcL2iy++OC6++OJqzZKVlRXZ2dlRVFRU6RobN25MYqKSiouLU1Z7V+CxS538/PwYPHhwTJw4MXJzd74NbNq0afTu3Tt69+5dqm/Dhg3xwQcfxPvvvx/z58+PN954I2bOnBnLly9PVfSk6tKlS/Ts2TMOO+ywOPDAA6NTp07RoUOHyMnJSUsez8vX8xhVTk1dW3qfKJ+GDRsmbK+OtfnGjRujadOmVaqxq6wNK7ouLCwsjPvvvz9++tOfluq7+OKLY+zYseWqc8YZZyR8DMeMGZO0vUdllPW87Gp7vl3l9RORnL1FstjTpteu9nuSCbznl5TKx+M/ylonlnVdLc85u/K11z6jetXE/YnrVGITJkyITZs2VXhc//79Y/fddy/V3qJFi1i8eHGsX78+GfFqnV69esWvf/3rhH2FhYVx/vnnR0TEK6+8kvCzsUGDBsXll18ed999dypjJs2GDRtit912K9XerFmzpNQfOXJkjBw5ssLjrrvuuvjjH/+YlAzpsHjx4nj00Ufj/vvvj48++ijdcXZ51hgAAAAAAAAAAAAAAAAAAAAAAAAAAACU5d13340jjzwynnnmmfjGN77xtefn5ubG/fffH61bt47hw4dXaK7GjRtH+/btdxxv2rQp5s6dW9HIEfHv78ytKRo0aBCdOnUq0fbqtFcrVau4uDheefWVOPOMM3e0ddmvS7zwwguxbdu2HW3169cvMW5bwbbYmf8dm2j8Vx3f7/gS3/W+cOHCePvtt782f1W0aNEinnjiiTj66KPLPWbZsmVx2mmnxRtvvJHCZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJA5Pvrooxg4cGD06NEjrr322jjllFMiLy+vQjXmzp0bd911VzzwwAOl7omYqQoKCuJ3v/tdjBgxIn70ox/FhRdeGO3atatwnU8//TTuueeeuPPOO2PNmjUpSJp8ixYtir59+0avXr3ikksuiSOOOCIOPPDAyM7OTne0tFq5cmWccsopcc4558SVV15ZoXtqRkTMnj07brnllhgzZkwUFxenKCX/sX379vjVr34Vd911V1xzzTVxwQUXRMuWLcs9fsWKFXH33XfHrbfeGuvXr09h0pIy6Zq8Zs2aOPnkk+O4446L3/72t3HEEUeUe+zatWvjnnvuiZtvvjny8/NTlnFn3nzzzTjggAPi0ksvjWuvvTb22Wefco/dsmVLPPnkk/H73/8+5syZk8KUVVeb388ivKclksnvZ5n+fGbSNb62y5Tfk8ceeyzGjRsXZ511Vnz3u9+NPn36RL169SpV68svv4zx48fH3XffnbL7wGf673Ais2fPjjlz5sQhhxxSqu/pp5+OVatWpXT+ZLzPJ/M9PlN+dwAAAAAAADJJbroDAJBan8+POOiEqtcpKoxY/n7V65BYWX/oVR1/BFvWHA0bNqxy7XXr1lW5Rrp169YtevfunbBvxIgRSZvnySefjBUrVkSrVq1K9V1++eVxxx13JG2uXU1F/9BxV+ePLyvPY5daU6ZMiWHDhsUDDzwQDRo0qFSNRo0aRffu3aN79+5x9tlnR0REcXFxvPrqq/Hggw/GP//5zygoKEhm7Cpr06ZNfOc734khQ4ZE165d0x2nlNr6vFSEx6jiaura0vtE+ZT1/FfH/4Fx06ZN0bRp0yrVyOS14T333BM/+clPIisrq0T7CSecEHvssUcsXbr0a2tcfPHFCduHDx+elIyVlc7rSkVk8usnVexp068mfDZS3bznl7R58+aUz1HWOqE8a7hMvfbaZ1Sfmrg/cZ1K7IorrogvvviiwuMuueSSuPfee0u1Z2VlxR133BFHHnlkMuLVKg0bNoxRo0ZFbm7iPwe5+eabY/r06RER8dvf/jZ++ctfJjzv9ttvj5dffjkWLFiQsqzJsnTp0ujQoUOp9jZt2qQhTeYoLCyMzZs3x4YNG2LZsmXxxRdfxPz58+Ott96KqVOnxieffJL0OXf2f+7OyclJ+nzlsbN5i4qKKlTLGgMAAAAAAAAAAAAAAAAAAAAAAAAAAICyfPbZZ3H00UfH008/HUccccTXnp+VlRV//OMfY6+99oqNmzaWe55O+3QqcQ+d9z94v8Lft1sT7bXXXiW+k3jz5s3x0UcfVbreRx99FJs3b97xfcR16tSJDu07xPsf/Pfmv1lR8l5GX/c8fLX/q/dC+l/7d90/DjrooB3HX375ZTzz7DPlzl8ZXbp0iaeffjo6depU7jFvv/12DBo0KD799NMUJgMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBXsrP78SXLwIEDUz7H7bffHrfffntK53jzzTfjvPPOi/r168eAAQOiV69e0a1bt9hzzz2jadOm0ahRo9i6dWusW7cu1qxZE++++2689dZb8eyzz8bHH3+ckkzV8fx9nRUrVsTPf/7z+PnPfx49evSIo48+Og477LDo2LFjtGrVKho2bBi5ubmxbdu2yM/Pj7Vr18Z7770X7777bjz//PMxb968dP8IlTZz5syYOXNmREQ0bNgw9thjj2jWrFk0b9486tSpk3DM5s2by1W7Op/biy++OC6++OKk1Xvsscfiscceiy5dusTRRx8dRxxxRHTu3LnEY7N+/fpYu3ZtLFiwIObMmRNPP/10vP/++2XWnDlzZpUfk0x+TFNp2bJlcc0118R1110Xffv2jaOPPjq6d+8ee+21145r26ZNmyI/Pz8+/fTTmDt3bkydOjVefPHFMu8BO3Xq1JQ/3rviNbksL774Yhx55JHRvn37OPHEE+PYY4+Ntm3bRsuWLWO33XaL7du3x9q1a2PFihUxZ86cmDZtWkyaNCm2bduWsN71118f119/fZUylff5KSgoiLvvvjvuvvvuOOyww2LAgAFx8MEHR6dOnXY8zlu2bIl169bFsmXLYt68eTFz5syYPHlybNxY/ns9JzNzZdXm97MI72mJ7KrvZ+WRyuezOuzq1/ibbropbrrpppTPkwrJfv1lwu9JUVHRjpx5eXlxzDHHRLdu3aJr167RqVOnaNy4cTRq1CgaNmwYxcXFsWHDhli/fn3k5+fHBx98EPPmzYt58+bFtGnTYvv27UnLtTOZ/jv8VWvWrEnYft9991Vbhsq8z48bNy5l7/G78u/OrvA5AwAAAAAAQEXkpjsAAKn14RsRRYUR2TlVq/PpvIhtm5KTidLK+oODsv7YOJlSOcf69etTVru6fPe7303Yvnjx4njllVeSNs/27dvjoYceiquvvrpUX5cuXaJv374xderUpM0H1E5jxoyJ+fPnxwMPPBCHHXZYUmpmZWVFnz59ok+fPnH99dfHVVddFRMmTEhK7aqoX79+/OxnP4urrroqGjZsmO44O1WbnpfK8hhVTE1dW+7qNm3aFJMnT05J7XfffbfKNYqLi5OQZOcKCwtTPseu7MMPP4wXX3wx+vXrV6I9JycnvvWtb8Utt9yy0/F77LFH9O/fv1T7ggUL4rXXXktq1mSpjtcVVWNPm3414bMR0ssaLnXsM6qH/Qlf5/77748f/ehH0b1791J9RxxxRJx33nkxevToNCTLXH/961+jU6dOCftmzJgRv/nNb3Yc33TTTXHiiSdG7969S53boEGDGDVqVPTq1SsKCgpSljcZvvjii4Tt7du3r+Yk6bPnnnuW+TjsSrZs2VJmX+PGjasxyX81bdq0zL7KfAGBNQYAAAAAAAAAAAAAAAAAAAAAAAAAAABl+fLLL+P444+PMWPGxCmnnFKuMVdccUUsWLAgJk2eVK7vYG/VulWJ4w8++KBSWWuaNm3alDj+4MMPqnT/naKiovjwww/jgAMO2NHWuk3reP+D98scU9b395e3/z+aN28eAwYM2HG8ffv2ePKpJ1P6neL9+vWLxx57LJo3b17uMZMmTYpzzz03NmzYkLJcAAAA7Lr+dOuf0h0BAKBSrr6m9L3aAUi97//g++mOAFArXXrppemOAFDrnHX2WXHW2WelOwZArXPyoJPj5EEnpzsGQK3Tr1+/6NevX7pjANQqr732WowfNz7dMQAAAAAAAAAAAAAAAACAStqyZUs8+eST8eSTT6Y7yi7nzTffjDfffDPdMdJi48aN8f77Zd8rszZ677334r333ot777033VEoh6KionjppZfipZdeSneUCsmka/Knn34aI0aMiBEjRqQ7SqXMmjUrZs2ale4Y1aI2v59FeE/7qkx/P8vk5zOTrvG1Xab8nmzatCkmTZoUkyZNSneUcsvk3+GIiD333DOOO+64Uu3Lly+PiRMnpiHRrvU+nym/OwAAAAAAALuy3HQHACC1NqyOePvZiO4Dq1bntUeSk4fapaioKN0RqiQvLy/OP//8hH2vv/569O3bN6nzLV68uMy+K664IqZOnZrU+YDa6Z133okePXrE6aefHj/4wQ/iuOOOi5ycnKTU7tSpU/zrX/+K3//+9/Gzn/0sKTUrY4899ogJEyZEjx49qlRn48aNsXjx4h3/LFq0KBYvXhzr16+PefPmJSntv9WG56WqPEbs6pYtWxYDB1Zx40XGGz58eMIbnV988cVxyy237HTst771rYTXteHDhyctH7WLPe2uIdM/G4Gazj4D0q+4uDiuvvrqeO655xL233LLLfHEE0/E1q1bqzlZZjr77LPjkksuSdi3fv36GDZsWBQWFu5oKywsjKFDh8Zbb70VjRo1KjXm4IMPjt/97ndx7bXXpixzMnz88ccJ29u1axeNGjWKDRs2VHMiyrJly5Yy+5o2bVqNSf6rWbNmZfbtLO/OWGMAAAAAAAAAAAAAAAAAAAAAAAAAAABQls2bN8cZZ5wRI0aMiIsuuqhcY/bff/9o0KBB/GvCv6KgoGCn57Zq2arE8cqVKysbtUZp07pNiePly5ZXueby5cvjgAMOKHOOrz5Xubk7v538V/sLtpV+rnNycuK0U0+LunXr7mh76aWXYsWKFeXOXVGXXnpp3HXXXVGnTp1yj/nb3/4WV155pXu3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJAUF1xwQWRnZ5dqf/jhh6OwsDANiQAAAAAAAKhpctMdAIDUe+XBiH16RDRuWbnx7z4f8em85GaipLL+ECQ3N/Vv1XXq1EnY7o9TIgYPHhxNmjRJ2Hf++efH+eefX21ZzjrrrNh9991j1apV1TZndSkuLk7Y/sorr8R7771XzWnKzgPpkJWVlbLa//rXv+Jf//pXtGjRIvr37x+HHnpoHHLIIbHffvtF+/btE/7xYnldf/31Ua9evbj66quTmLh8dt9995g+fXp07NixXOdv2bIl3n///Vi8eHEsXrw4Fi1atOPfly5dmnBMq1atkhm5hJr6vCSTx+jrWVvWbmU91mU9N8lUt27dKtfYldaGlVkXjhs3LlavXh0tWrQo0d61a9fo1atXzJw5s8yxF198cam2rVu3xj//+c8K50i2oqKihO3VcV2piF3p9ROR/r2FPS2pkMo9Conl5OSkfI6y3sPLs4arKdde+4zUsT+hPJ5//vmYOHFinHzyyaX6OnToEFdddVX8/ve/T0OyzNK2bdsYPnx4mf0//OEP48MPPyzV/uGHH8aPfvSjuO+++xKOu/rqq2Py5Mnx/PPPJy1rss2bV/Z/yDzooINi+vTp1ZiGndnZnqB58+bVmOS/mjZtmrC9oKAg8vPzq1TbGgMAAAAAAAAAAAAAAAAAAAAAAAAAAIBECgsL4+KLL47ly5fHT37yk3KN2WuvveLcc8+NcePGxebNm8s873/vnVPWd+3m5uZG69ato1mzZlGvbr3IysqKbdu2RX5+fqxYuWKn9TPVV78HedXqqt9HZeWqlTud46uPY6OGjXZar1Gjkv2Jnod+/fpFy5b/vUHxe4vei7lvzS1P3ArLysqKP/7xj3HttdeWe0xhYWFceeWVceedd6YkEwAAAJnjl7/4ZbojAABUyPU/uz4aNGgQf/u/v8WKFSvSHQeg1rjq6quiWbNmMeKeEfHJJ5+kOw5ArXHpZZdGx44d46GHHorFixanOw5ArTBs2LDo0rVLPDnhyXjjjTfSHQeg1hh0yqDo3bt3PPvMs/Hqq6+mOw5ArdF/QP/o27dvTJ06NZ6b8ly64wDUKtu3b093BAAAAAAAAAAAAAAAAAAAAAAASJmsrKz4zne+k7Bv+PDh1ZwGAAAAAACAmio33QEASL1NayMe/3XE4D9E1G9csbGfvhMx+Y4UhKKEDRs2JGxv3rx5yucua47169enfO5d3eWXX57uCDvUrVs3Lrroorj11lvTHSXptmzZkrD9sccei7/+9a/VnAZ2LQ0aNEj5HKtXr47Ro0fH6NGjd7TVrVs39tlnn+jcuXN07tw59ttvvx3/3rFjx8jOzv7auldddVXMmDEjxo4dm8r4JWRlZcWYMWOiY8eOZZ6zbNmyePLJJ+O5556LOXPmxAcffBBFRUUVnifVatLzkioeo7JZW9ZuZT3/zZo1S/nceXl5Va6R6WvDgoKC+Oc//xk//vGPS/VdcsklMXPmzITjevXqFV27di3VPn78+FizZk3Sc1ZUWc9LdbyuKiLTXz/JZk9LKlTHHoWS6tevn/I5yrqel7Wu+F817dprn5F89ieU19VXXx0nnHBC5OaW/hOGn/3sZ3HffffF8uXL05Asczz00EOx2267JewbO3ZsPPjgg2WOvf/++2PQoEFx9tlnl+rLysqKf/7zn3HQQQftEvuTRObNm1dmX58+fWL69OnVmIad+fLLL2PLli0J1zht2rRJQ6KIPfbYI2H70qVLo7i4OClzWGMAAAAAAAAAAAAAAAAAAAAAAAAAAACQyE9/+tNYunRp/PnPfy7X/dH2aLNHDBk8JB57/LHIz88v1Z+VlRV16tTZcbxx48YS/R07dIzDDjssOnbsGDk5OQnnKC4ujmXLlsXct+bGggULKnyft11V3bp1SxyX554MX2fjhpKPb916JefYvGVz5OfnR5MmTSIiYo+2e0TMKbve/35n8ubNmyN/fcnnuEuXLtG9W/cdx2vXro1nnnmmsvF3qkGDBvH444/HmWeeWe4x+fn5cd5558XkyZNTkgkAAIDMsnnz5nRHAAColK1bt1rLAFSj/9w/1vUXoHr952+Ctm3b5voLUE3+c+0tKChw7QWoRoWFhRERsX37dtdfgGq0ffv2Hf/r+gsAAAAAAAAAAAAAAAAAAAAAAAAkyymnnBJ77bVXqfapU6fGokWLqj8QAAAAAAAANVJuugMAUD1WfBDxzx9FnPnLiJZ7l2/MvGcipvwtorAgtdmIWL9+fcL25s2bp3zusuYoK1Nt0b179+jZs2e6Y5Tw3e9+N2699dZ0x0i6TZs2JWxv0aJFNSeBqsnOzk56zYYNGya9Znls27YtFi5cGAsXLizVV7du3ejatWscddRRMWTIkOjTp0+Zdf70pz/F+PHjd9z8NdXOO++8OO644xL2ff7553HNNdfE2LFjd9wMvLLy8vKqNL6yMvV5qU4eo3+ztqzdNm7cmLC9WbNmKZ03JycnKdfHmrA2HD58ePz4xz8u1T548OC48sorY+vWraX6LrroojJr7QrKel6aNm1azUl2ria8fpLFnpaImrVHqc2qYw1X1jphw4YNXzu2Nlx77TOqxv6E8lq4cGHcc889ccUVV5Tqa9SoUdx8883x7W9/Ow3JMsPVV18d/fr1S9j32WefxXe+852vrfHtb387Dj/88Nhzzz1L9bVt2zZGjBgRZ511VpWzpsK8efNi06ZNCfel/fv3j1tuuSUNqSjLxx9/HF26dCnVfthhh6UhTdnzfvzxxymd1xoDAAAAAAAAAAAAAAAAAAAAAAAAAACAiIi//OUvsWLFinjggQeibt26X3v+brvtFkOHDI3HHn8sVq1aVaKvXr16JY63bdsWERH169ePgScNjE6dOn1t/aysrNhjjz1ijz32iJ49esakSZNi+YrlFfiJdj05OTmRm1vyVu7/eWyqYltByRr16tYrdc5HSz6K7t26R0REp306RYP6DWLzls2lzqtbt27st+9+O46XLFlSor9Zs2Zx4gkn7jguLCyMJ596Mik/x1c1atQonnjiiejWrVu5x3z00UdxyimnxPz585OeBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDa7Ve/+lXC9r/85S/VnAQAAAAAAICaLDvdAQCoPmuXRjzw/YiJt0UsWxRRXFz6nG1bIhZPj3joyojJf44oLKj+nLXRihUrEra3bNky5XPvvvvuCdtXrVqV8rl3ZZdffnm6I5TSuXPn6NevX7pjJN2yZcsStrdo0aKak8DXKyoqKrOvUaNGSZ9vzz33THrNqtq2bVvMmzcv7rrrrujbt2+cdNJJsXLlyoTnduzYMQYPHlxt2X75y18mbF+4cGF07949Hn300SgsLKzyPGW9d6bTrvy87Cpq02NkbVm7rV69OmF7qq9dHTp0iOzsqn/UWBPWhgsXLoxXX321VHvTpk3jjDPOKNVet27dhNecDz74IF588cVURKywL774ImH7rvaeWBNeP8liT1t72KPUfNXxmJd1nVyzZs3Xjq3t197atM+oLPsTKuKXv/xl5OfnJ+y75JJLolu3btWcKDMcfPDB8bvf/S5hX3FxcVxwwQWxdu3ar63z5ZdfxgUXXBDFif4DYkSceeaZcckll1QlasoUFBTEyy+/nLDvuOOO2+X2LrXdvHnzErZ37do1JWvYnenYsWOZr4+yclYHawwAAAAAAAAAAAAAAAAAAAAAAAAAAIDa5ZFHHolTTjklNmzYUK7zGzVqFEMGD4n27duXaK9bt26J44KCgmjYsGEMGzosOnXqVOFcu+++ewwePLhSY3clX31cIv792FTVtm3bShzn5OREbm5uibbZs2bv+P7vunXrxsknn1zqnNzc3Bh40sCoX7/+jrZZs2aVqHvaqaeV+DlefvnlWL58eZV/hq9q3ap1nD/s/Ap9N/z06dOjd+/eMX/+/KTnAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKB2+9a3vhWHHXZYqfYPP/wwxo8fn4ZEAAAAAAAA1FTZ6Q4AQPUqLop4Z0rEP38U8bfzIh7+fxHjfh0x5oaIB74f8ddzIsbfGLH0vXQnrV3mz5+fsD3RH5AkU7169eKAAw5I2Pfuu++mdO5dWcOGDWPYsGHpjpHQFVdcke4ISffZZ58lbO/SpUs1J4Gvl5+fX2Zf06ZNkz7ffvvtl/SayfbMM89E//79Y/PmzQn7Bw0aVC05unTpEvvvv3/CvosvvjhWr16dtLlatmyZtFqpsqs8L7uymvwYWVvWbosWLUrYfvDBB6d03s6dOyelTk1ZGw4fPjxh+yWXXFKq7fTTT4/mzZuXar/nnnuSnquyynpeunfvXs1Jdq6mvH6qyp62drFHqfn22GOPaNasWcrq77777rHnnnsm7CtrXfG/XHtLqsn7jMqyP6EiVq1aFb/97W8T9mVnZ8cdd9xRvYEyQP369eORRx6JunXrJuy/9dZb48UXXyx3vRdeeCFuv/32Mvv/+te/Jm3/l2yTJ09O2J6bmxtDhw6t5jTszOzZsxO2Z2dnR8+ePas1S+/evcvsmzNnTjUm2TlrDAAAAAAAAAAAAAAAAAAAAAAAAAAAgJpvypQpcdxxx8XKlSvLdX69evXi7LPOjv32/e+9JHJyckqcUxzFccbpZ+y4P05RUVG8O//deOJfT8Q/hv8j/nzHn+PW226NO++8M0aOGhnTpk2LDRs2lKhRp06dOPWUU6Nt27ZV/AnTJysrq1RbUVFRleuWp8bqNatjxowZO4733nvvuOzSy+KEASfEUUceFQP6D4hLL7k09t133x3nzJo9K5YtX7bj+Lhjj4tWrVrtOH7//fdj9pz/ft9zVlZW7L333tGvX7844/Qz4txvnhunnnJqHHH4EbH77ruX++fp3LlzDB48OBo1alTuMY8++miFXrcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUF6dO3eOv/zlLwn7brrppiguLq7mRAAAAAAAANRkuekOAED6bM7/9z+k37vvvpuwfc8994wOHTrEJ598kpJ5e/bsGXXr1k3YN3/+/JTMmQmGDBkSjRs3Tth3wQUXxOrVq1Oe4cYbb4wePXqUaj/99NOjVatWsWLFipRnqC7vvPNOwvZevXpFVlaWP5hil/Lll1+W2demTZukz9e7d++k10yFefPmxV133RVXXXVVqb6+fftWS4b+/fsnbH/77bdjxowZSZ3L81Jz1NTHyNqydnvvvfcStu+1117RunXrWL58eUrm7dOnT1Lq1JS14dixY+Ovf/1rNGvWrER7//79Y88994zPP/98R9vFF19cavz27dvjgQceSHHK8ps3b17C9k6dOsXuu+8eq1atquZEidWU109V2dPWLvYotUPPnj1jypQpKal9+OGHl9m3aNGirx3v2ltaTd1nVJb9CRV1xx13xPe+973o2LFjqb7jjjsuTj311HjyySfTkGzXdPvtt0fXrl0T9s2ZMyduuOGGCte8/vrro3///tG9e/dSfQ0bNoxHHnkkjjjiiNi+fXuFa6fS6NGj4/bbb4+cnJxSfVdddVXceeedUVhYmIZkfNULL7xQZt/5558fL774YrVlueCCC8rse/7556stR3lYYwAAAAAAAAAAAAAAAAAAAAAAAAAAANR8b775Zhx11FHx7LPPxl577fW15+fm5sYpp5wSL7zwQsx9a26p/j3b7hlZWVkREbFs+bJ46qmnYu3ataXO27xlc2xeujmWLl0aM9+YGUcfdXT07NmzxDyDTh4U9z9w/y73HdWZYNpr06JBgwZx8MEHR0REo0aNolu3bgnPnb9gfrz88ss7jvfbb78d4yIi1uWvi0mTJ+04btOmTZx04kmx++67l6rVpUuXOOqoo2LhwoXx7JRnY9u2bWVm7NmjZ/Tt23fH6+XrFBcXx8033xy//OUvy3U+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFREr169YuzYsdG8efNSfQsWLIiHHnooDakAAAAAAACoyXLTHQAAiJg2bVqZfccff3zcf//9KZm3X79+Cdu3bt0as2fPTsmcmeC73/1uwvZXX3212v6Ap1WrVgmf9zp16sQll1wSf/jDH6olR3WYM2dOwvYmTZrE/vvvH/Pnz6/mREREZGVlpTvCLunLL78ss++QQw6Jxx9/PGlzNWvWLHr27Jm0eqk2ZsyYuOqqq0q1t27dOrKysqK4uDil8++zzz4J22fOnJn0uY499tik10yV6nxeMvW6ke7XbipYW9Zus2bNKrOvT58+8dhjj6Vk3gEDBiSlTk1ZG27ZsiVGjhwZ3//+90u0Z2dnxwUXXBC///3vIyKiTZs2ccIJJ5Qa/+STT8by5curJWt5fN3ravz48dWYpmw15fVTVfa0tYs9Su1w4oknxpQpU1JS+5hjjknYvnXr1nJdN117E6uufUYm7MPsT6iobdu2xU9+8pN49NFHE/bfdtttMWnSpNi+fXs1J9v1DBo0KK644oqEfZs3b46hQ4dGQUFBhesWFBTEkCFDYvbs2VG/fv1S/T169Igbb7wxbrjhhgrXTqXly5fH5MmTY9CgQaX6OnbsGJdffnnceeedaUjGV73xxhuxevXqaNGiRam+wYMHx1VXXRXr1q1LeY4OHTrEwIEDE/YtXrw4lixZkvIMFVUTP8sEAAAAAAAAAAAAAAAAAAAAAAAAAACgpMWLF8cRRxwRzzzzTHTr1u1rz8/Ozo7+/ftHXsO8WLBgQYm+/3yn/eeffx5jxo6JwsLCr61XWFgYL099OfLz8+P444/f0d60adM4+OCD480336zgT0RExHPPPxdLPl4SRx5xZLRq1apU/+o1q2PG9BmxYOF/n8OmTZvGiSecuOO4sLAwnnrqqdi6dWtERLRv3z7OOvOsqFOnzk7n7tq1a+y2227x6OhHY9u2bSX6/vP66XbQ17/W/mPr1q1x6aWXxsiRI8s9BgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC+KisrK+rUqRNZWVnRsGHDaNWqVRx66KHxzW9+M0499dTIyclJOO6KK66IoqKiak4LAAAAAABATZed7gAAQMSnn34ab7/9dsK+H/7whymZs06dOnHFFVck7HvppZdi48aNKZl3V3fIIYdEjx49EvaNGDGi2nKMGTMm1q9fn7DvO9/5TmRlZVVbllSbOXNmma+3YcOGVXOa2qegoCBhe15eXjUnyQzbt2+P5cuXJ+zr2bNnUuf61re+VeYfFO6K3nvvvYTtOTk50axZs5TP37Jly4Ttq1evTuo8bdu2jSOOOCKpNVMpFc9LTbtupPu1mwrWlrXb7NmzY9WqVQn7vvvd76Zkzv333z8OP/zwpNSqSWvD4cOHJ2y/+OKLd/z7+eefn/D9vqyx6TJ79uxYs2ZNwr5Uva4qoya9firLnrb2sUepHYYMGRLZ2cn/T3r16tWLCy+8MGHf1KlTY8uWLV9bw7U3sWTvMzJ5H2Z/QmWMHj06Xn/99YR9++67b3z/+9+v5kS7nlatWsX9999fZv9VV10VCxcurHT9BQsWxLXXXltm/09/+tPo06dPpeunyh133FFm329/+9to27Zt9YWhTMXFxTFmzJiEfXl5eXHZZZdVS44f/ehHZa6xRo0aVS0ZKqomfpYJAAAAAAAAAAAAAAAAAAAAAAAAAABAacuWLYu+ffvGyy+/XO4xRx5xZBx11FGl2rdt2xb/mvCvKCwsrFCGOXPnxIKFC0q0HXLwIRWqsStLxv1TKlrj/fffj38+9M/4x/B/xJixY2LCkxNi7Nixcc+Ie+L+++8v8Xjn5OTEaaeeFvXq1dvR9sqrr8TSpUsj4t/f6XzqKadGnTp1IiJi69at8eKLL8Z9990Xd//j7hg5amS88+47O8a2atUqThhwQok89erVi7PPOju6HdSt3D/DqlWr4vjjj4+RI0dW6GcHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgK/65je/GVu3bo0tW7bE6tWrY8GCBTFy5Mg444wzIicnJ+GYv/3tb/Hyyy9Xc1IAAAAAAABqg+x0BwAA/u2JJ55I2H7IIYdEv379kj7f+eefH23atEnYN378+KTPlykuv/zyhO3r16+PsWPHVluOTZs2xejRoxP27b333jFgwIBqy5JqBQUF8dxzzyXsu+yyy6JOnTrVnKh2+fLLLxO2t2jRopqTZI7p06cnbD/uuONi9913T8ocderUiSuvvDIptf6jQYMG8eMf/ziuvfbapNb9j02bNpXZV9YfRyZTcXFxwvaGDRsmdZ7rrrsuqdelTHxeqvu6kYmP0a7A2rJ2e/bZZxO29+/fPw488MCkz3f11VcnrVZNWhvOmzcv3njjjVLt++67bxxxxBEREXHxxReX6v/kk0/imWeeSXm+iigqKoqJEycm7DvhhBOiS5cuSZ+zadOmFR5Tk14/lWVPWztl6h6F8mvbtm0MGTIk6XWHDRsWLVu2TNg3adKkctXI1Gtvpu0zMv3zG/sTKuPHP/5xmX2/+tWvYrfddqvGNLueBx54oMxr+NNPPx133313lef429/+Vub7QXZ2djz88MOVWren0nPPPRevvfZawr6mTZvGY489tsu+N9U29957b5l9N910U3Tq1Cml8/fo0aPM9W1RUVE88MADlaqbaWsMAAAAAAAAAAAAAAAAAAAAAAAAAAAAdl3r1q2LE088MZ566qlyj+napWupttlzZu/0+2135pVXXilxj7imTZsm7V4Y1amwsLBUWzK+1zc3J7dcc33V+vXr45NPPolFixbFx598HOvWrSt1zrHHHButW7fecfzhhx/Gm2++ueO4Z4+ekZeXFxH//m7lsY+NjVmzZ8WaL9fEhg0bYunSpTF58uSYNWvWjjFdu3bd8R3nTZs2jaFDh0bHjh3L/fMuWLAgevfuHdOmTSv3GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABIlhdffDGuuuqqdMcAAAAAAACghspOdwAA4N/uuuuu2LZtW5l9jRo1Stpce+65Z/zxj39M2LdmzZp46KGHkjZXJmnYsGEMHTo0Yd+jjz4amzZtqtY8I0aMKLPviiuuqMYkqffggw8mbG/VqlV8//vfT/p81157bVxzzTWRm5ub9NqZZs2aNQnbDznkkGpOkjleffXVhO116tSJCy+8MClz/PjHP45OnTolpVaDBg3iqquuio8++ihuv/32uOmmm2LvvfdOSu3/1bp164TtRUVFZb7OkmnVqlUJ2zt37py0OTp37hzf/va3k1Irk5+X6rpuZPJjtCuwtqzd7rnnnjL7/va3v0V2dvI+EjzkkEPi4osvTlq9iJq1Nhw+fHjC9ksuuSR69OgR3/jGN0r13XvvvVFcXJz0LFV17733JmzPysqKv//975GVlZW0ufbdd99YunRpPPjgg9GlS5cKja1Jr5+KsqetvTJtj0Ll/P73v4/GjRsnrV7Lli3jN7/5TcK+rVu3VmgNl0nX3kzdZ2T65zf2J1TG9OnTY+zYsQn7mjdvHr/+9a+rN9Au5Ac/+EEMHDgwYd+KFSuSuke76KKLYuXKlQn7OnToEHfffXfS5kqW6667rsw91RFHHBGjR4/eJdbvtd2sWbPihRdeSNiXl5cXDz30UFI/v/hf9evXj4cffrjM18GYMWNiyZIlFaqZqWsMAAAAAAAAAAAAAAAAAAAAAAAAAAAAdm1bt26NCy+8MN6a91alayxatKjSY/Pz82P58uUl2sr6rtxd2datW0t9f3XdOnWrXLdO3ToljgsKCpJy76F99923xP0I1q9fHxMnTSxxzoEHHrjj399b9F4sW7YsYa1Xp70aBQUFO467HdQt2rVrF8OGDYsWu7Uod6Znn302Dj/88Pjwww/LPQYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkmXixIlxyimnREFBQbqjAAAAAAAAUENlpzsAAPBvS5cujVGjRiXs22+//eL+++9Pyjx16tSJsWPHRsuWLRP2//3vf49NmzYlZa5MM3To0GjUqFHCvnvuuaea00S8/vrrMX/+/IR9p5xySuyxxx7VnCh1nnzyyfj0008T9v3+97+Pb3zjG0mbq1evXnHzzTfHn/70p5g7d2706dMnabUz0bx58xK277333tGtW7dqTpMZXnrppTL7fv7zn0fr1q2rVL9nz57xm9/8pko1/mPo0KGxZMmSuO2223bkql+/fjz22GNRr169pMzxH3379k3YvmLFiigqKkrqXIksX748YfsxxxxT5rW9IurXrx+PP/545OXlVblWpj8v1XHdyPTHaFdgbVm7vfTSS2WuI4855pikvc80adIkRo8eHdnZyf2IMZ1rw2R75JFHYsOGDaXazzvvvPj+979fqr2oqCjuu+++pOdIhpdeeqnM94B+/frFDTfckJR5cnNz48EHH4wGDRrEBRdcEPPnz48xY8aU+z2mNu8t7Glrr0zao1B57du3j4ceeiiysrKqXCsrKyseeeSRaNu2bcL+0aNHx6pVq8pdL1OuvZm8z8j0z2/sT6is6667LrZt25aw74orroguXbpUc6L0+8Y3vhF/+tOfyuy/6KKLYuXKlUmbb8WKFXHJJZeU2T948OAYNmxY0uZLhmnTpsU//vGPMvvPPPPMmDhxYuy2227VmIpEfvGLX5TZd8QRR8SDDz6YlLXP/6pbt26MHz++zOvH9u3b48Ybb6xQzUxeYwAAAAAAAAAAAAAAAAAAAAAAAAAAALDrKyoqiilTpsRr01+r8Nji4uIqf3f18hUl7xHXuFHjKtVLl4KCghLHdevVrXLNr34P8ZYtW6pcs0mTJnHSiSftOC4qKoqnnnqqRO3dd989GjRosOP4/fffL7NeQUFBiXtKdOrUKb55zjcjr0H578l39913x8knnxz5+fnlHgMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAybB8+fK44oorYtCgQbFp06Z0xwEAAAAAAKAGy053AADgv2644YZYv359wr5zzjknHn300ahXr16l6zdv3jyeffbZOOKIIxL2f/bZZ/HHP/6x0vUz3eWXX56w/Z133ok33nijmtP824gRIxK25+bmxqWXXlrNaVJn+/btcdNNNyXsq1+/fjzxxBPRsWPHKs/TtWvXmDBhQtStWzciIg444ICYOnVq/POf/4yWLVtWuX4mmjZtWpl9v/nNb6oxSeaYNWtWvPnmmwn7mjVrFg888EDUqVOnUrUPOuigeOqpp3a8RiMiiouLK1UrImLDhg3RqlWrUu2HHnpoTJgwIfLy8ipd+3/l5ubG1VdfnbDv3XffTcocX+e1115L2F6/fv24/vrrq1Q7Ly8vxo4dG926ddvRVlhYWOl6mf68VMd1I5Meo1deeSWKi4sT/jN+/Pik5Kwsa8va7Ze//GWZfT/72c/KXHuVV5MmTWLixImx7777VqlOIulcGyZ7Xbhx48Z45JFHSrU3btw4LrroolLtkydPjs8++yxp8yfbzt5Tb7rppiq/52ZnZ8eDDz5Y4rqSnZ0d3/zmN2Pu3Lnler3V5r2FPW3tlUl7FKrm9NNPjyeeeCIaNmxY6Rp5eXnx+OOPx/HHH5+wf9u2bXHzzTdXqGamXHszaZ/xVTXh8xv7EypjyZIl8de//jVhX25ubtx2223VnCi96tatG4888kjUr18/Yf+dd94ZkyZNSvq8Tz31VNx9991l9v/973+PvfbaK+nzVsW1114bCxYsKLN/wIAB8dZbb6Vs/qZNm8Yvf/nL+OlPf5qyOWqC1157Le67774y+88///x45plnYvfdd0/KfO3bt4+pU6fGSSedVOY5t956ayxcuLBCdTN5jQEAAAAAAAAAAAAAAAAAAAAAAAAAAEDmeO211+K5556LoqKico8pLi6OZs2aVWnezZs2lzj+33tYZJLNm0v+HM2bN69yza/W2LJlS5XqZWdnx2mnnlbiu/tfnfZqfP7F5yXO++pzunr16p3W/d/+Jk2aRE5OTrnyFBYWxo9//OO44oorqnTvPgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD4OkVFRbFx48b49NNP45VXXok77rgjTjnllGjXrl3cfffd6Y4HAAAAAABALZCd7gAAwH998cUXcf3115fZf95558Urr7wSBx10UIVr9+3bN2bOnBnHHntsmed8//vfjw0bNlS4dk1w2GGHxaGHHpqwb8SIEdWc5r8eeuihKCgoSNj3ne98J7Kysqo5Uercd9998cYbbyTs23fffWPGjBlxxBFHVLr+oEGD4rXXXovWrVuX6vvWt75V5vNf082aNSuWLl2asO+0006Lv/71r5Gbm1vNqXZ9t912W5l9J510UowfPz4aNmxYoZpDhgyJV155JVq1arWjbdWqVfHSSy9VNmZMmDAhpk+fnrDvhBNOiBkzZsRhhx1W6foREXXr1o0HHnggDjnkkIT9jz/+eJXql9f06dNj/fr1Cft+8pOfxDnnnFOpunvttVdMmzYtTjnllB1tGzZsiJEjR1aqXkTmPy/Vcd3I9MdoV2FtWbs9/vjj8fzzz5fZ/4tf/CIef/zxaNu2bYVr9+7dO2bOnBlHHXVUifbJkydXuFZZ0rU2TMW6cPjw4Sk5Nx0mTpxY5vUxKysrfve738XIkSMTrrm/TqtWrWLy5MkxdOjQhP1jx46NxYsXl6tWbdxb2NOSKXsUKu7ZZ58tcXzaaafFjBkzylzH7szBBx8c06ZNizPPPLPMc26//fZyX2//VyZcezN5n1ETPr+xP6GyfvOb38Tq1asT9g0aNCj69+9fzYnS5w9/+EN069YtYd/8+fPjmmuuSdncV111Vbz33nsJ+5o0aRIjR46M7Oxd589PNmzYEKeeemp8+eWXZZ7Trl27mDZtWpx11llJuYZmZ2dHnz594s9//nN88sknceONN0bz5s2rXLemu+qqq2LJkiVl9g8YMCAWLVoUV155ZeTl5VVqjqZNm8bPfvazWLBgQfTu3bvM895+++349a9/XeH6mbzGAAAAAAAAAAAAAAAAAAAAAAAAAAAAILPMfWtuTHhyQmzfvr1c52dnZ8eQwUOiTes2lZ6zuLi40mN3JStWrChx3HL3llWu+dUaX52joo455pho0+a/z9VHSz6KmTNnljqvfv36JY63bNmy07rbtm2rcJaNGzfGGWecEXfccUeFxwIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAeYwZMyaysrIiKysrcnJyolGjRtGhQ4fo27dv/PjHP46nn346tm/fnu6YAAAAAAAA1BLZ6Q4AAJR05513xtixY8vs79mzZ8ydOzcefPDBOPLIIyM7u+y387p168aAAQPiySefjJdffjk6d+5c5rl//vOfY8KECVXKnskuv/zyhO3btm2Lhx9+uJrT/NeqVavKfF7at28fAwcOrOZEqVNUVBQXXnhhbNiwIWF/mzZt4rXXXovRo0fHQQcdVO66hx9+eIwfPz6eeuqpaN68ecJz7r333njmmWcqlTvTFRYWxv/93/+V2f/DH/4wFi5cGNdee2306tUrdtttt8jJyanGhLumsWPHxrvvvltm/6BBg+L999+PSy+9NBo3blzmebm5uTFo0KCYOnVqjBo1Kpo2bVqi/9e//nWsW7euSlkvvPDCWL9+fcK+gw46KGbOnBnjxo2L448/PnJzc8tdt379+nHuuefGnDlzYtiwYQnP2bRpU4wbN65SuSuqsLCwzOt1Tk5OjBkzJv7v//4vWrduXa56bdu2jb/85S/x3nvvxcEHH1yi78Ybb4wvvviiSnkz+XmprutGJj9GuxJry9rtsssuizVr1pTZf9ZZZ8X7778ff/rTn+LAAw/caa3s7Ow47rjjYty4cTF9+vTo0qVLif5XX301HnzwwaTkjkjf2jAV68I333wz3nrrra89b9myZfHUU08lde5U+O53vxsff/xxmf1Dhw6NDz/8MP74xz9G9+7dv7Ze+/bt4xe/+EUsWrQoBgwYkPCcVatWxVVXXVXujLVxb2FPSybtUaiYn/3sZ6Xezw888MCYNWtWPPLII3HUUUftdA2Xk5MTRx99dIwaNSpmz55dan/zv95666248cYbK5UzU669mbrPqCmf39ifUBn5+fnxq1/9qsz+P//5zzt9rdQUAwYMiP/3//5fwr5t27bF0KFDY8uWLSmbf/PmzTFkyJAoKChI2H/kkUfGDTfckLL5K+ODDz6Ik046KdauXVvmOUceeWQ8/vjjsXLlynj44YfjO9/5Thx66KHRpEmTndbOysqKDh06xMCBA+Pqq6+Ohx9+OJYvXx5Tp06N//f//t/Xjue/1q1bF6eeemqZa4iIiObNm8cdd9wRn3/+edx///1x7rnnxl577RVZWVkJz8/Ozo7OnTvHsGHDYtSoUfHZZ5/Fb3/722jYsGGZc6xevTpOO+202Lp1a6V+jkxdYwAAAAAAAAAAAAAAAAAAAAAAAAAAAJB53n///Xjs8cfK/d3UeXl5ce6550bHjh0rNV+DBg1KHFf2u3zTbdmyZSWO27dvX+Wa7dq32+kcFdGpU6c47NDDdhxv2LAhJk6cmPDcr34/e1FRUZl18/LyKnSfiIiI9evXx+mnn54R91MCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEiG3HQHAABKu+CCC6JDhw7Ru3fvhP3Z2dlxwQUXxAUXXBCrV6+OmTNnxrJly2LFihWRk5MTrVu3jrZt28bhhx8eDRs2/Nr5nnzyybj66quT/WNkjEaNGsWQIUMS9j3xxBOxevXqak5U0ogRI+Lss89O2HfFFVfExIkTqzlR6ixYsCCGDBkSTzzxROTk5CQ859xzz41zzz03Pvnkk3juuefi448/jhUrVsT69esjJycnGjZsGK1bt46uXbvG0UcfHXvuuedO53z55Zfje9/7Xip+nIxx1113xQ9+8INo27Ztwv5OnTrFLbfcUq5aN998c/ziF79IZrxdUmFhYZxzzjnx5ptvlnmdbdOmTYwYMSLuuuuueO2112LJkiWxcuXKKCgoiGbNmkXnzp2jZ8+e0axZs4Tjp0yZEnfeeWf079+/SlkXL14cF110UYwdOzays7NL9WdnZ8eZZ54ZZ555ZmzYsCFmzJgRixYtio8++ijWr18fmzZtiuLi4sjLy4vGjRvHXnvtFV27do2jjjoqGjRosNO5f/nLX8by5curlL8ibrrpprjwwgsjLy+vVF9WVlb84Ac/iMsvvzyef/75mDlzZrz//vuxdu3a2Lp1azRt2jRatWoVe+21V/Tv3z+6desWWVlZpeo8+eSTceutt8bvf//7KmXN9OclWdeNnV0zMv0x2pVYW9ZeS5YsifPOOy8mT55c5tqqQYMGcc0118Q111wTn332WcyePTtWrFgRK1eujJycnGjatGl07tw5DjnkkNhtt90S1lixYkUMHjw4jjrqqKTmT8faMFXrwuHDh8edd96503Puv//+KCwsTMn8ybR69eoYOHBgTJs2LZo3b57wnLy8vLjuuuviuuuui2XLlsWsWbNi5cqVO9ZCjRo1itatW0e3bt2ia9euCd9z/6OwsDCGDRsWn3/+eYVy1qa9hT0tEZm1R6FiVq5cGUOHDo2JEyeWWBdnZWXF4MGDY/DgwbFmzZqYMWNGiTVcy5Yto02bNnH44YeX+Zz+rzVr1sQZZ5wRW7ZsqXTWTLj2ZvI+o6Z8fmN/QmXcfffd8cMf/jC6dOlSqu/AAw+Myy67LIYPH56GZNVjt912iwcffLDMdfP1118fb731VspzzJkzJ37xi1/EH/7wh4T9v/rVr2LKlCkxY8aMlGcpr5kzZ8Zxxx0XkyZNijZt2pR5XrNmzWLYsGExbNiwHW3r16+PtWvXxubNm6OgoCDq1asXjRs3jsaNGyf8/LG8Pvvss7j00ksrPb4meuedd2LQoEHx9NNPR6NGjco8r1mzZnHRRRfFRRddFBERBQUFsXz58ti0aVMUFBRE3bp1d6wlylqLJLJ69eoYMGBALFmypNI/QyavMQAAAAAAAAAAAAAAAAAAAAAAAAAAAMg8n332WTw6+tE45+xzdvrdvv9Rt27dOOvMs2LS5EmxcOHCCs3VokWLEsfr8tdVaPyu4oulX5Q4bteuXeTl5cWmTZsqVa9hw4bRbs92JdqWLltaqVpNmjSJgScN3HFcVFQUTz/9dGzevLlS9f5j9913j7POPCuaNGlS7jHLli+L8ePHx7vvvluluQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMkluugMAAKVt2bIljj/++Bg3blyccMIJOz23RYsWMXDgwErP9dBDD8Ull1wSxcXFla6R6YYNGxYNGzZM2DdixIhqTlPaM888E5999lm0a9euVN/JJ58c7dq1i88++ywNyVLjqaeeisGDB8eoUaOiTp06ZZ7XoUOHuOSSS6o010svvRSnn356bNu2rUp1Mt3atWvj/PPPj+eeey6ys7PTHSdjLFy4ML7zne/Eww8/HFlZWWWeV6dOnTjmmGPimGOOqVDtoUOHJiNmRESMGzcuhgwZEg8//PBOf68aNWoU/fv3j/79+1d5zhdeeCHuuOOOKtepiGXLlsWVV14Z99xzT5nn5ObmxoknnhgnnnhihetPnTo1hg0bVpWIJWTy81Jd141Mfox2JdaWtdtzzz0X55xzTjz66KNRr169nZ7brl27hGvOnVm7dm2cdtpp8fnnn1clZpmqe22YqnXhww8/HLfeems0aNAgYX9xcfFO3792NQsWLIi+ffvGlClTok2bNjs9t02bNjFo0KBKzVNQUBCDBw+OZ599tlLja8vewp6W/8ikPQoV88wzz8SPfvSj+L//+7+Ez+1uu+0WJ598cqXrr1ixIk444YRYsmRJFVL+WyZcezN1n1FTPr+xP6EyCgsL49prr40JEyYk7L/55pvjkUceifXr11dzsupx7733xh577JGw7/nnn4/bb7+92rLccsstMXDgwITriJycnBg5cmR07949NmzYUG2Zvs7cuXOje/fuMXLkyApd0xs3bhyNGzdOWo7CwsL4xz/+ETfccEOsXbs2aXVriqlTp0b//v1j/PjxZb7ev6pOnToV/hzjqz788MM47bTT4t13361SnYjMXWMAAAAAAAAAAAAAAAAAAAAAAAAAAACQmVatWhWjHhkV55x9Tuy2225fe35OTk4MOnlQ5OXlxezZs8s1R4P6DWLPPfcs0bZs2bJK5U23Tz/9NPLz86NJkyYREZGVlRUHH3xwvPbaa5Wqd8ghh5S4h8SaNWsq9dhkZ2fHqaecGvXr19/RNn369Pj0s0/LHFNYWFjiOCcnp9Q5e++1d5x66qlRt27dcmdZtHhRTJw4MbZv317uMQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANUF2ugMAAIlt3LgxBg0aFLfddlsUFRUlvf6WLVvi2muvjQsuuCC2b9+e9PqZ5PLLL0/Y/sknn8Rzzz1XzWlKKy4ujgceeCBhX3Z2dnz729+u3kDV4LHHHovjjjsuvvjii5TNcdddd8WAAQMiPz8/ZXNkkhdffDGGDh0aW7ZsSXeUjDJq1Ki45JJLoqCgIGk133nnnejXr1+sWrUqaTUjIsaMGRMDBgyIjz/+OKl1E5kwYUKcfPLJUVhYmPK5vmrEiBFx4403Jr3umDFj4oQTToj169cnvW6mPi/Vdd3I5MdoV2JtWbs98cQTcdJJJyV9bfXZZ5/FscceG6+//npS635Vda4NUyU/Pz/Gjh1bZv8LL7wQH330UcrmT4V33nknDjvssHj55ZdTUn/ZsmVx0kknxbhx46pUpzbsLexp+V+ZtEehYu6888647LLLYtu2bUmt+9Zbb8VRRx0Vb731VtJqZsK1N1P3GTXl8xv7EyrjySefjBdffDFhX8uWLePnP/95NSeqHpdddlmcccYZCfvWrFkTF1xwQbXmKS4ujvPPPz/Wrl2bsH+fffaJv/3tb9WaqTxWrFgRJ5xwQlx22WWxcuXKap27sLAwRo8eHQcddFB8//vfL/OxI+L111+P7t27x8SJE6tlvkcffTQOOeSQePfdd5NWM1PXGAAAAAAAAAAAAAAAAAAAAAAAAAAAAGSm/Pz8eOTRR2LpsqXlOj8rKyv6Hdcv+vbpW67zDz/88MjO/u8t0FesWJHR37X8zrvvlDju2aNnNG7cuMJ1mjRuEj0O61Gi7e23365Upr59+sYee+yx4/iTTz6J6TOm73TMV+9ZkNcgr8TxoYceGmeeeWbUrVu33Dlef/31mDBhgu/4BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABqpex0BwAAyrZ9+/a45ppr4sgjj4w333wzaXWnTJkSBx98cNx6661Jq5mpevbsGQcffHDCvvvvvz+Ki4urN1AZ7r333jKzXHbZZZGdXfOWddOmTYsDDzww7r777igqKkpa3QULFsSxxx4b3/ve92L79u1Jq1sTjB49Oo4++uiYNm1auqNklAceeCD69OkTixYtqnKtkSNHRu/evWPp0qVJSFbayy+/HAcccEDcfvvtsWnTpqTXX716dXzve9+LM888M7Zu3Zr0+uX161//Os4999z48ssvq1xr1apVMWzYsDjvvPNS9jNl8vNSXdeNTH6MdiXWlrXbSy+9FAcccEA8+OCDSVlbPfbYY9GtW7d46623kpDu69WEteHw4cMr1bcr++KLL+K4446L7373u7Fq1aqk1CwuLo4xY8ZEt27d4oUXXkhKzZrw+imLPS2JZNIehYq577774vDDD48FCxZUudaWLVvid7/7XfTs2TPef//9JKQrKROuvZm6z6gpn9/Yn1AZV111VZnXlCuvvDL22muv6g2UYvvuu2/85S9/KbP/29/+dnzxxRfVmOjfPvvss7j88svL7L/wwgvj3HPPrcZE5VNcXBz33ntvdO7cOa6//vr4/PPPUzrf0qVL49Zbb43OnTvH4MGDk/L+XRusXLkyBg0aFKeeemq88847KZnjjTfeiOOOOy6GDBkS+fn5Sa+fqWsMAAAAAAAAAAAAAAAAAAAAAAAAAAAAMtPmzZtjzJgxsWTJknKP6dWrV5x04kmRlZVV5jmdOnWKQw89tETbG2+8UdmYKZOTkxO5ubkl/inLW2+9VeK7fevUqRNnnH5G1K1bt9zz1a1bN84888wS82zevDnefuftCmffZ599okePHjuON27cGE89/dTXjlu9enWJ45atWkZERFZWVvTv3z/6Hdev3PeDKSwsjEmTJ8Urr75SgeQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADVLdroDAABf7/XXX4+ePXtG//794+mnn45t27ZVuMbGjRtj9OjR0bNnzzjhhBPivffeS0HSzHP55ZcnbC8qKor77ruvmtOUbcmSJfHiiy8m7Gvbtm2ccsop1Zyoenz55ZdxxRVXxH777Rd33nlnrF69ulJ1CgsL46WXXoozzjgjDjjggHj55ZeTnLTmmDVrVhx99NFxxBFHxF133RVz586NwsLCdMfa5b3++utx4IEHxg9/+MP46KOPKjS2uLg4pk6dGn369Inzzz8/Nm3alKKU/7Zx48a4+uqro127dvHTn/405s6dW+Was2fPjuuuuy46deoUd911VxQVFVU9aBWNHTs2vvGNb8Tvf//7WLVqVYXHf/LJJ3HddddFx44dY9SoUSlIWFImPy/Vdd3I5MdoV2NtWXutXbs2Lrrooth///3j/vvvj/z8/AqNLyoqiilTpsRRRx0V3/zmN+PLL79MUdLEMn1tOG3atFiwYEGp9lWrVsX48eOrJUMqFBcXx/Dhw6Njx47xve99L+bMmVOpOps3b46xY8fGYYcdFuedd16sXLkyqTkz/fVTFntaypJJexQqZs6cOXHggQfGxRdfHAsXLqzw+OXLl8ett94ae+21V9xwww1RUFCQgpT/lgnX3kzdZ9Skz2/sT6iIuXPnxkMPPZSwr169enHLLbdUc6LUyc3NjUceeSTy8vIS9t93330xbty4ak71X6NHj46HH364zP5//OMf0a5du2pMVH75+fnxhz/8ITp27Bj3339/pT47LMv8+fPjjjvuiAEDBkS7du3i2muvjSVLliStfm3y1FNPxUEHHRQnnHBCjBw5ssKfYXzV6tWr47777oujjz46evXqFS+99FJygpYhU9cYAAAAAAAAAAAAAAAAAAAAAAAAAAAAZKaCgoIYN35cwvvjlOXAAw+MM04/I3Jzc0v1HXTgQXHqKadGVlbWjrbPP/88Fiwsf/3qctqpp8X/u/L/lfinLBs3bix1z4PWrVvHueeeGy1atPjauVq0aBHnnXtetGzZskT7Cy++EFu2bKlQ7saNG8fAkwbuOC4uLo6nJz5drvuErF27NtavX7/juMt+XaJu3bpx9llnx8HdDy53hs2bN8fYx8bGu+++W6HsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1TVZxcXFxuU7Mykp1FgCgnBo3bhwnnXRS9OjRI7p37x7t27ePpk2bRuPGjaO4uDjWrVsX69atiw8//DDmzZsXM2fOjClTpsTWrVvTHR2qJCcnJ4466qg46qij4pBDDom999472rRpEw0aNIh69epFYWFhrF+/PtavXx9LliyJ+fPnx+zZs2Py5MmxZs2adMfPWHl5edG2bdto1qxZNGvWLPLy8so8d9GiRbFw4cJqTLdrOvzww6N///7Rq1ev6NSpU7Ro0SLy8vKisLAw1q1bF2vWrIl33nknZs2aFU888UR8/PHHac3bunXrOP744+OAAw6I/fbbL/bZZ59o3LhxNGrUKBo1ahQRERs3boz8/PxYv359LFu2LN5+++14++234/XXX48PPvggrfm/Tt26deOYY46J3r17R+/evXe8nps3bx65ubmRn58fa9eujffeey/mzJkTzz77bMycOTPdsTP6eSnvdaOq14xd7TE64YQT4plnntlx/MQTT8SZZ56Z1DlSwdqy9qpbt24MGDAgjjzyyOjevXvsvffe0bRp02jSpEls3bo11q1bFytXrox58+bFm2++GRMmTIjly5enO/YO1oa7rr322iuOOeaYOPzww6Nz587RoUOHaNKkSeTl5UVWVlbk5+fHunXr4vPPP4+5c+fGG2+8EZMmTYoNGzZUW0avH2qbTNujUH4HHnhgnHzyyXHwwQfHN77xjWjWrFk0bdo0srKyYt26dbF27dpYvHhxzJ07N6ZOnRqvvPJKlPM/DSZdplx7d7V9RnnVlM9v7E+AdNhvv/2iZ8+ecfDBB0eHDh2iffv20bJly2jQoEHk5eVFnTp1orCwMDZv3hybN2/esZ/5/PPPY9GiRfHWW2/FW2+9FStXrkz3j1Jj1alTJ3r06BG9e/eO7t27R4cOHaJdu3bRqFGjyMvLi9zc3CgoKIhNmzbFhg0b4tNPP42PP/445syZE6+//nrMnj07ioqK0vozZOoaAwAAAAAAAAAAAAAAAABqoqp894LvagfK0q1bt+jWrVtE/Ps68+GHH8aMGTPS9n0vQO0y8OSB0a9fv3THoBb56KOP4u93/j3dMQBS5pJLLon9v7F/umNQS7z22msxftz4dMcASJmf3fCzaN68ebpjUEuMe3xcTJ8+Pd0xAFKiWbNmccPPbyj3+ccde1wcdthh5T7/iy++iHHjx0VERMeOHeOwQw+Ltm3bljhn06ZN8fDIhyM/P7/cdXfmmL7HRM+ePXccv/HGG/Hy1JcrVevMM86MTp06lWi79bZbdzrmrLPOin323qdEW2FhYSxevDjeW/RerFm9JjZu2hgREQ3zGkaLFi1iv/32i3333TdycnJKjFu8eHH8a8K/KpQ5KysrhgweUuJxnj5jekybNq3cNXr36h19+vTZcZyfnx9NmjQp9/gvv/wyHh/3eKxduzZh/2233hbLli0rdz2ATLJPz4hzfpPuFNQmt5yU7gQANVtWVlb06NEj9ttvvx1/7z1v3ryYN29empMBAJBpbvrNTdGgQQOfkQNUs//8ndmdf7szlixZku44ALXG977/vdh7773j3nvvjYULFqY7DkCt8J//76K/fQeoXmeedWYceeSRMfHpifHiiy+mOw5ArfGf78V64YUXYtLESemOAwBAAr6rHUgF39UO7GqOO+64OHnQyemOQS3ks1GgNvF+Szp4rwVqE/cmIx38zSVQm3ivJV38f8yA2mTADyIOOSXdKahtnv2/iLlPpzsFQPXyXe27Fn9TCwAAAAAAAAAAAFC9srKyomfPnrHvvvv6e1qg3MrzN9651ZADAEiy9evXx9ixY2Ps2LHpjgLVqrCwMKZOnRpTp05Nd5RaZdOmTfH++++nO0ZGmTFjRsyYMSPdMcpt+fLlMWrUqHTHSJlt27bFlClTYsqUKemOUiGZ/LxU13VjV3uMsrOzSxwXFRWlKUnFWFvWXtu2bYunn346nn46M7/JyNpw17VkyZJYsmRJPPjgg+mOUiavH2qbTNujUH7vvPNOvPPOO+mOUS6Zcu3d1fYZ5VVTPr+xPwHSYdGiRbFo0aIYOXJkuqNQhoKCgpg+fXpG3/ggU9cYAAAAAAAAAAAAAAAAAAAAAAAAAAAAZJYXX3oxNmzcEH379I2srKyvPb9t27bxvSu+F1lZWQnP37hxYzw+7vHIz89PRdy0mDBhQpx91tnRvn37HW05OTnRtWvX6Nq1a7nrfPzxx/H0xIrf/6lPnz7Rtm3bHceffvZpvPbaaxWqMXvO7DjggANit912i4iIJk2alHvsp59+Gv+a8K/YsmVLheYEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKipstMdAAAAAKAmaNy4cYnj9evXpykJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC10RtvvBGTn5kcRUVF5To/Ozs7srKySrV/9NFH8dDDD8WKFSuSHTGttm/fHmMfGxuzZs2K4uLiCo8vLi6ON954Ix4f93hs3769QmP33nvv6Nmj547jTZs2xVNPPVXhHAUFBfHWvLcqPO6dd96JsY+NjS1btlRoHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABATZab7gAAAAAANcFBBx1U4njVqlVpSgIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQG317rvvxubNm+PUU06NOnXqlHtcUVFRfPLpJzHrzVnx0ZKPUpgwvYqKiuLFl16Mt995O3r16hX7dt73ax+ngoKCWLx4cbw+8/VYvXp1heds1KhRnDzw5MjKyoqIiOLi4pg4aWJs3LixwrUOP/zwOOrIo3bU+jrFxcXxyiuvxMw3ZlZ4LgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAmi433QEAAAAAMl3Lli3jsssuK9E2e/bsNKUBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKA2+/DDD2PM2DFx1plnRYMGDco1prCwMObMmRMfLfkoZblenvpyvDz15aTUGv/E+CqNX7VqVUycODFyc3Njjz32iN1b7B6NGzeOOnXqREREQUFBrF+/PlatXhVLly6N7du3V3quDRs2xJ1/v7NKeXNycuKkk06K/bvuX+4xBQUF8fTEp+P999+v0twAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADVVbroDAAAAAGSy1q1bx9NPPx177LHHjrbNmzfH5MmT05gKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDabOnSpfHoo4/G2WefHU2aNPna8+vUqROnn3Z6PDvl2XjnnXeqIeGuYfv27fHpp5/Gp59+mu4oZWrQoEGcecaZ0bZt23KP2bBhQ4wfPz6Wr1iewmQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJktO90BAAAAADJVjx494s0334zDDjusRPsdd9wRa9asSVMqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACIWL1mdTzy6COxavWqcp2fnZ0dJ55wYvTu3TvFySivFi1axPnDzo+2bduWe8yKFSvi4ZEPx/IVy1OYDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAg82WnOwAAAABAJvr2t78dr776arRr165E++TJk+MXv/hFmlIBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMB/rV+/Ph599NH44osvynV+VlZW9Dm6T/Tr1y/Fyfg6HTt2jKFDhkbTpk3LPeaDDz6IRx59JDZs2JDCZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANUN2ugMAAAAAZJrs7Oy48MILo169eiXax4wZE6eddloUFhamKRkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJS0ZcuWGDN2THzwwQflHnPoIYfGKYNOiexst0JPh+7dusfZZ51d6n5pO/PmrDfjiX89EQUFBSlMBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQc2SnOwAAAABApikqKopvfvObsWLFih3HP//5z+O8886LgoKCNKcDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICStm/fHk/864l4++23yz2ma9eucfZZZ0edOnVSmIz/lZWVFccee2wMGDAgsrPLdxv6oqKimDJlSrz00ktRXFyc4oQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADVHdroDAAAAAGSipUuXxpAhQ+Lzzz+PAQMGxG9/+9t0RwIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgDIVFxfHM88+EzNmzCj3mI4dO8Z5550XeXl5KUxGRESdOnXijNPPiB6H9Sj3mC1btsTj4x6Pt+a9lcJkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1U266AwAAAABkqhdeeCH22Wef2LZtW7qjAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAubw67dXYuHFj9OvXL7Kysr72/Dat28SQwUPisccfi3Xr1lVDwtqncePGcdaZZ0XLli3LPWbt2rUxbty4WPPlmhQmAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACoubLTHQAAAAAgk23bti3dEQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoELmzJ0TTz39VBQWFpbr/ObNm8fQIUOjZcuWKU5W+7Rp0ybOH3Z+hR7bzz7/LEaOHBlrvlyTwmQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADVbdroDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANXrvffei8fHPR7btm0r1/kNGzaMwecNjvbt26c4We2x3777xXnnnhcNGzYs95j58+fH2LFjY/OWzSlMBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQ82WnOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQ/T755JMYPXp0bNy4sVzn16tXL84+6+zYb9/9Upys5uvVq1eceuqpUadOnXKdX1xcHK9OezUmTpoYhYWFKU4HAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFDzZac7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJAey1csj0cefSTWrl1brvNzc3PjlFNOiYO7H5zSXDVVdnZ2nHTiSdG3T9/Iysoq15jt27fHU08/FTNmzEhxOgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA2iM73QEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA9Fm7dm2MemRUrFixolznZ2dnR//+/ePII49McbKapX79+vHNc74ZBx54YLnHbNq0KUaPGR3vvfdeCpMBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANQ+2ekOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKTXpk2b4tHRj8Ynn3xS7jFHHnFkDBgwILKyslKYrGZo3rx5DBs6LNq3b1/uMStXroyHRz4cS5cuTWEyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDaKTvdAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAID027ZtWzw+7vF4b9F75R7TvVv3OO200yI3NzeFyTJbhw4dYtjQYdG8efNyj/nwow9j1COjIj8/P4XJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABqr+x0BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB2DYWFhfHUU0/FnLlzyj1m3877xjnnnBP16tVLYbLMdNCBB8XZZ50d9evXL/eYOXPmxPjx46OgoCCFyQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAarfsdAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAdh3FxcXx/PPPx7Rp08o9pt2e7WLI4CHRqFGjFCbLLH379o0TTzwxcnJyynV+UVFRPPf8c/H8C89HcXFxitMBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANRu2ekOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOx6ps+YHs8++2wUFRWV6/zdd989hgwZErs13y3FyXZtubm5cfppp0evnr3KPWbbtm0xfvz4mDt3buqCAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwQ266AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC7pnlvz4t5b8+Ldu3axRmnnxH169ff6flNmzSNSy65JAoKCmLChAnx0ZKPqilp+rVs2TLOOvOsaNy4cbnHLF26NMY/MT42bdqUwmQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHxVdroDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALu2zz77LB4d/Whs2LChXOfXqVMnzjjjjPjG/t9IcbJdQ6dOnWLI4CHRuHHjco9ZuHBhjB4zOjZt2pTCZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJJKd7gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADArm/VqlUx6pFRsWbNmnKdn5OTEwMHDoweh/VIcbL06tmjZ5xx+hlRt27dcp1fXFwc06dPj6eefiq2b9+e4nQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACSSne4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQGbIz8+PUY+MiqVLl5br/KysrDj22GPjmGOOSXGy6pednR0nnHBCHHPMMZGVlVWuMdu3b4+JkybGtNempTgdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA7k53uAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDm2LJlS4weMzo+/OjDco/p2aNnDBw4MLKza8bt1evVqxdnn3V2dDuoW7nHbNq8KcaOHRsLFixIYTIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMojO90BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMyyffv2eOKJJ+Ld+e+We8wB3zggzjjjjMjNzU1hstRr2rRpDB06NDp27FjuMavXrI6RI0fG5198nsJkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUV3a6AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACZp6ioKCZNmhRvvPlGucfss/c+cd6550X9+vVTmCx19my7ZwwbNixa7Nai3GM+/vjjGDVqVKxbty6FyQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqIjsdAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMtfLL78cL730UhQXF5fr/D322COGDN7dYrEAARkUSURBVBkSTRo3SXGy5Np///3jm9/8ZuQ1yCv3mHlvz4vHxz0eW7duTWEyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqKjvdAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDM9uasN2PSpElRWFhYrvNb7NYihgwZEi1atEhxsuQ46qij4uSBJ0dubm65zi8qKooXX3oxnn322SgqKkpxOgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKio73QEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAzDd/wfx44oknoqCgoFznN27cOIYMHhJ7tt0zxckqLzc3N0499dQ44vAjIisrq1xjtm3bFk/864mYNWtWitMBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFBZ2ekOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANQMHy35KEaPGR2bN28u1/n169ePc845Jzp16pTiZBWXl5cX5517XnTZr0u5x6xfvz4eefSR+PDDD1OYDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAqspOdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACg5li2bFk88sgjsS5/XbnOr1OnTpx+2ulx4IEHpjhZ+e2+++5x/rDzY4899ij3mGXLl8XDIx+OlStXpjAZAAAAAAAAAAAAAAAAAADA/2fvvqOsqs6HAb9TaNIRLIiCglJUVBQLYAMLKCCgoqKxB9HYu/6MJkaxRGNJLFFEjQQbAopiiWhEbCixICBWLAFBEOl95vsjCz9x7gxT7p1778zzrMVazt7n7P3eOefsvc97zh0BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEiG3HQHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFQtPy78MR599NGYP39+qbbPzc2NQw85NPbee+8UR7Zx27baNgYdNygaNGhQ6n0+++yzeOyxx2LZsmUpjAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgGTJTXcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQNWzdOnSePSxR+O7/35Xqu1zcnKiW9du0aNHj8jJyUlxdIntuuuu0b9//6hZs2ap95n87uR4+pmnY+3atSmMDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAZMpNdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABA1bRq1aoYNWpUfP7556XeZ7ddd4vevXtHXl5eCiPbUE5OTvTo3iMO6nFQ5OaW7n8Bv27dunjxxRdj4sSJKY4OAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBky013AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDVtXbt2nj6madj6tSppd6n7Q5t48gBR0bNmjVTGNn/1KxZM/r37x+77bZbqfdZsWJFjBo1KqZ+XPrPBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABA5shNdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABA1VZYWBgvvvRivP3226XeZ5tttoljjzk2Ntlkk5TF1aBBgxh03KDYbtvtSr3PwoUL458j/xnffvdtyuICAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACC1ctMdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFA9THpjUkyYMCEKCwtLtf1mm20Wg44bFI0aNUp6LFtuuWWccPwJ0bRp01Lv8+2338Y/R/4zfvrpp6THAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABA5clNdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABA9fH+B+/Hs889G+vWrSvV9o0aNYrjjj0uNt9s86TF0LZt2zhm4DGxySablHqfjz/+OJ4c9WSsXLkyaXEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJAeuekOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKheZs6cGaOeGhWrVq0q1fZ169aNY445JrbZZpsK97333ntH78N7R35+fqm2LywsjImvT4wXXnwhCgoKKtw/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADpl5vuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDq59tvv43HHn8sli1bVqrta9asGUcOODLatm1brv7y8vLisF6HRbeu3SInJ6dU+6xZsybGjRsXkydPLlefAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABkptx0BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUTz/88EOMfHRkLFy4sFTb5+XlRe/De8duu+5Wpn7q1K4TRx99dHTo0KHU+yxbtiwef+Lx+PSzT8vUFwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmS833QEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1deiRYvi0cceje/nfl+q7XNycqJHjx7RrWu3Um2/aZNN4/jjj48WW7UodUzz5s2LR0Y8Et9/X7qYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADILrnpDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACo3pYvXx6PP/54fP3116XeZ++9945DDzk0cnJyit2mZcuWMWjQoGjUqFGp2/3iiy/i0ccejaVLl5Z6HwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsktuugMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWLNmTTw1+qn45JNPSr3PzjvvHEf0PSLy8/OL1O3ScZc4csCRUatWrVK3996U92Ls02NjzZo1pd4HAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDsk5vuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiIgoKCuLZ556N/7z/n1Lv06ZNmzjqqKOiVq1aERGRk5MTBxxwQBx88MGRm1u6/517QUFB/Otf/4p///vfUVhYWK7YAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADIHrnpDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgl1555ZV4fdLrUVhYWKrtW2zVIo479rho3Lhx9DuiX+yx+x6l7mvVqlXx1Oin4sOPPixvuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZJn8dAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8GvvvPNOLFu2LA45+JDIzc3d6PZNmzaNU085NXJyckrdx6JFi2L0mNGxYMGCioQKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECWyU93AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACJfPzxx7FixYrofXjvqFGjxka3z8nJKXXbs2fPjjFjx8SKFSsqEiIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFkoN90BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABTniy++iFGjRsXKlSuT1ub06dPj8ScejxUrViStTQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAskduugMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKMl/Z/83Hn3s0ViyZEmF2iksLIxJb0yK8c+Pj3Xr1iUpOgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsk1uugMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2JgFCxbEo48+Ggt+XFCu/deuXRvPPvdsvP3220mODAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAbJOb7gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASmPxksXx6KOPxpw5c8q03/Lly+PxJx6PmTNnpigyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACySW66AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAorZUrV8bjTzweX371Zam2nz9/foz454iYM2dOiiMDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBb5KY7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICyWLt2bYwdOzamTZ9W4nazZs2KkY+OjMWLF1dSZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZIP8dAcAAAAAkO1yc3OjcePG0aRJk2jSpEnUqlUr4XYLFiyIadOmVXJ0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQNRUUFMTzzz8fS5Ysid077R41atTYoO7DDz+MV159JQoLC9MYJQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmSg/3QEAAFSm22+/PQ4//PAi5S+//HKceeaZaYiICMcFIBFjY+bbfffd44gjjoj99tsv9tprr6hdu/ZG93n22WejT58+lRAdQNVgPoTq6fXXX48tttiiSPkNN9wQw4cPT0NEkL1cT1SEtRgAAEB2c18HkBnkaYF0MgYBkE3kMqBqyvZrO1lr6sMOOyzuuOOOIuW33npr3HvvvRWKsarK9nMHAIDsZ00KAAAAAAAAAAAAAJC9Jk2aFJMnT452bdtFy1Yt45tvvolPP/00VqxYke7QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADIUPnpDgAAyFw1atSInJycIuWFhYWxZs2aNERUcZtvvnm0adOmSPnHH3+chmhYz3EBKMrYmLm6dOkSf/jDH+Lggw9OdygAVZ75kHSrirmRbNCqVato0aJFkfJGjRpVfjCQ5VxPVIS1GAAAQHZL5n2dXCklcX5AyeRpM5fxi+rAGARANvGMGqqmbL+2k7WmXrVqVcLfQ0FBQXlDq/Ky/dwBgF/Lzc2Ntm3bxvbbbx+NGjWKBg0aRIMGDSI/Pz+WL18eixYtikWLFsW8efPiww8/jIULF6Y7ZKj2rEkBAAAAAAAAAAAAALLb6tWr46OpH8VHUz9KdygAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGSB/HQHAACpstVWW8Xxxx+fsG7p0qVx9913pzyG448/Prbaaqsi5V988UU89dRTKe8/ImLIkCHRoEGDIuU//vhjDBs2rMR9J0+eHLvuumuR8k8++STat2+frBCBLLbXXnvF/vvvn5S2CgsLY/Xq1bFy5cpYsGBBzJs3L7766qv49ttvk9J+RMQmm2wSZ599dtLaS6W///3vsWjRop9/zs3NjXPPPTdq1qyZcPuPP/44xo8fX1nhbaBFixYxaNCgYusffvjhmDt3biVGBKlz0UUXxc033xy5ubnpDgUAipUJOZGI7M+LRMiNAAAAAFSG3r17R4cOHYqUjxw5Mr777rs0RFTys/C77747li5dWskRQXrJlVIS5weQrYxfAAAAVJb58+eXqRyAzOKZdvkk8zvoEREFBQWxatWqWLZsWcydOzdmz54dM2fOjOXLlyetj2Tr3LlzDBw4MPbff//Yeeedo3bt2qXed9asWfHee+/F6NGjY+zYsbFixYoURgoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANVbfroDAIBUWbhwYfzhD3+IOnXqJKx/5pln4rvvvktZ/zVq1Ii///3vUbdu3SJ1c+fOjaeeeiplfa+35ZZbxj333JOwbvjw4TFs2LCUxwBUbfvvv3/cdNNNKe1j+fLl8f7778cbb7wRzz33XEyaNCkKCgrK1Va9evVSHm+yjBo1KhYtWvTzzwUFBZGXl1ds/KtWrYrOnTvH1KlTKyvEiIjIycmJESNGxP7775+wfuzYsXHzzTdXakyQKrfeemtceOGF6Q4DADYq3TmRCHkRAAAAAEqnRo0aMXz48GjWrFmRumbNmsUll1yShqhKfhY+YsSIWLp0aSVHBAAAAAAAZKv58+eXqRyAzOGZdvlVxnfQCwsL46uvvopJkybFyy+/HM8888wG381Oh7p168a5554bgwcPjlatWpW7nVatWkWrVq3iqKOOiqVLl8ZTTz0Vf/rTn+KLL75IXrAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBEROSmOwAASJXly5fHv/71r2LrDzvssJT2v++++0bdunUT1m2++eax2267pbT/iIjDDz+82LoxY8akvH+AZNhkk02ia9eucemll8Zrr70Wc+bMieuvvz623HLLdIdW6W699daYMGFCwrpatWrFo48+GrVq1arUmC655JLYf//9E9bNmTMnTjvttEqNB1KlX79+ceGFF6Y7DAAolXTnRCLkRQAAAAAonX79+kWzZs0S1p188slRs2bNSo4IAAAAAAAguebPn1+mcgAyh2famS0nJye22267OPHEE+Mf//hHzJs3Lx5//PHo3LlzpcdSo0aNuPDCC2PWrFkxdOjQaNWqVdLarlevXpx00kkxY8aMuO2226JRo0ZJaxsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEivP/3pT/Hqq68W+de1a9d0hwYASWfeAwAAADJZfroDAIBUGjNmTPTt2zdhXZ8+feK+++5LWd+HHXZYifW9evWK999/P2X9R0T07t07Yfny5cvj5ZdfTmnfG3P22WdHy5Yti5RPnDgxxo0bl4aIiHBcyA6bbbZZXHnllXHBBRfE7bffHtdee22sXLky3WFVmhNPPDGmTp0aTZo0KVK34447xs033xznnXdepcSy6667xnXXXZewrrCwME488cT48ccfKyUWqpZMm48aN24cDzzwQInbTJo0KZ5++umYMmVKzJ8/P5YvXx6FhYVFtlu+fHmqwgR+JdPGEqhs6cyJRMiLAAAAAJVPTjA7DRkypNi6pk2bxoABA+Kxxx6rxIgAspv5EADIVtYxAJnFuAyQXKtWrYqlS5dGvXr1Nij/4Ycf0hQRwMZZE/6PZ9rZpWbNmjFw4MAYOHBgjB49Oi644IL45ptvUt7v9ttvH4899lh06tQppf3UqFEjzj///Dj66KOjf//+8e6776a0PwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAILVycnJiyJAh0bRp0w3KCwoK4pNPPklTVACQGuY9AAAAINPlpzsAAEilcePGxbp16yIvL69IXY8ePaJ27dqxcuXKlPTdq1evjdYPHTo0JX1HRNSsWTMOOuighHUvvPBCyj53aR1//PGx9957FynPz8+PcePGpSEiIhwXskudOnXiiiuuiP79+8fAgQNj6tSp6Q6pUsyePTtOP/30GD16dML6c845J8aPHx8vvvhiSuOoXbt2jBw5MmrUqJGw/rbbbouXX345pTFQdWXafDR48OBo0qRJwroffvghjjvuuJgwYUIlRwVsTKaNJVDZ0pkTiZAXAQAAACqfnGD2adOmTRx44IElbjNkyJB47LHHKikigOxnPgQAspV1DEBmMS4DJN/8+fOjXr16P/9cWFgYP/74YxojAiiZNaFn2tluwIAB0aNHjzjttNPiqaeeSlk/xx57bAwbNizq1q2bsj5+bauttorXX389zjjjjHj44YcrrV8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACC5dt9992jatGmR8vfeey8WLFiQhogAIHXMewAAAECmy093AACQSgsWLIhJkybF/vvvX6SuTp06ceCBB8bzzz+f9H633nrr6NChQ4nb7LPPPtGwYcNYtGhR0vuPiDjwwAOjbt26CetGjx6dkj4B0qFdu3bxxhtvRL9+/eKVV15JdziVYsyYMTF8+PA49dRTi9Tl5OTEQw89FDvvvHPMnz8/ZTHccsst0b59+4R1H374YVxxxRUp6xsqU15eXpxzzjkJ65YvXx77779/zJgxo5KjAoCNS1dOJEJeBAAAAIDSGTx4cOTk5JS4zf777x/t2rWLTz75pJKiAgAAAAAASL758+dHq1atfv75p59+inXr1qUvIAA2yjPt7NewYcN48skn46KLLorbbrst6e2ffvrpcd999230PImIKCgoiI8//jjef//9+Pzzz2P+/PmxfPnyWLduXWyyySbRsGHD2GqrraJTp07RqVOnqFevXont1apVKx566KGIiHj44YeT8XEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJLi1VdfTVh+4IEHVnIkAACZ56677ooOHToUKT/zzDPjk08+SUNEAKRbz549E5a/+OKLlRwJpJ61EGDeo7ry7AQAACB75Kc7AABItdGjR8f++++fsK53797x/PPPJ73P4h4Q/FJeXl4cfPDBMWrUqKT3HxHRp0+fhOVr166N5557LiV9AvzS/vvvH99//32pt8/Pz4969epFvXr1omnTprHjjjvGjjvuGN26dYvNN9+8xH3r168fzzzzTBxwwAHx3nvvFbvd/Pnzo23btqWOqThdunSJBx98MGHd7373u3j55Zcr3Mc333xTYv25554b++23X7Rp06ZI3RZbbBEPPPBAHHHEERWOI5GePXvG7373u4R1K1eujOOOOy5Wr16dkr6hsu2xxx6x1VZbJaz74x//GDNmzKjkiACg9NKRE4mQFwEAAABg42rUqBEnn3xyqbY944wz4oILLkhtQAAAAAAAACk0f/78En8GILN4pp1aZf0OekRErVq1okGDBtGwYcNo1apV7LbbbrHHHnvErrvuWuJ+OTk58Ze//CWWLFkSw4YNq0DUG/rtb38bf//73yMnJ6fE7d5+++24//77Y8yYMbFw4cJStZ2fnx+9evWKU045Jfr161diH/fff3/897//Tcp32wEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkuGAAw5IdwgbVbNmzYTlq1evruRIAIDqplOnTrH33nsXKW/QoEEaogEgE/Ts2TNh+fPPP1/JkUDqWQsB5j3Kqqrk87Ph2QkAAAD/k5/uAAAg1caOHRt33HFHwrrDDz88fve73yW9z8MOO6xU2/Xq1StGjRqV9P4j/vfZEnnttdfip59+KlUbAwcOjDp16hQpX7VqVUVCA6qJzz//PGbPnl3hdnJycqJbt25x8sknx0knnRR5eXkJt6tbt2489dRTsfPOO8fixYsTblNQUBCffvpphWNq0aJFsXXfffddUvrYmGXLlsWgQYPizTffjPz8ord2ffv2jd/+9rdx//33J7Xfpk2bxkMPPVRs/cUXXxwzZsxIap+QTl27dk1YvnLlyrjvvvsqORoAKJt05EQiqk5eJEJuBAAAACBVBgwYEM2aNSvVtieddFJcfvnlcjKQRnKllMT5AWQr4xcAAACVaf78+SX+DEBm8Uw7tZL1HfSIiNatW8fxxx8f559/fjRu3LjY7e655574z3/+E//5z38q3Oe+++4b99xzT+Tk5BS7zbRp0+K8886LCRMmlLn9tWvXxrhx42LcuHGx++67xx133FHsd11r1KgRTz31VLRv3z5pv1MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAijr33HOjUaNGG5R99tln8eijj1Z6LGeddVY0bdq0SPnNN98cK1eurPR4gPTbYYcdYubMmQnr2rZtG59++mklRwQAAKRCnTp1on379tG6devYfPPNo27dulGrVq1Ys2ZNLF26NJYsWRKzZs2K6dOnx7x581IeT15eXuy1116x3Xbbxeabbx516tSJBQsWxLx582LKlCkxa9aslMdA5mnYsGHsvffeRcp/+umneOedd9IQEVCSFi1axI477hgtWrSIBg0aRL169SIiYvny5bFkyZL4+uuv4/PPP48vvvgizZH+f1tuuWXsvPPO0bhx42jUqFE0atQoatWqFatWrYqffvopfvrpp1i4cGFMnTo15syZU2lxmRerJ/MeZSWfDwAAQDrkpzsAAEi1b775Jt5///3YbbfditS1bNkydtxxx5g2bVrS+svPz48ePXqUatuePXsmrd9f6tChQ7Rq1Sph3ZgxY0rdzmeffZakiADKr7CwMF5//fV4/fXX45Zbbol777039ttvv4TbbrPNNjF06NA4++yzKznK9Hj33XfjD3/4Q1x33XUJ62+//fZ47bXXkvqg8YEHHojNN988Yd3zzz8fd911V9L6gkyQ6MWPiIjJkyfHTz/9VLnBAEAZVXZOJKJq5UUi5EYAAAAAUmXIkCGl3rZx48Zx9NFHx4gRI1IYEVASuVJK4vwAspXxCwAAgMo0f/78En8GILN4pp09vvjii7j22mvjrrvuiptvvjlOPfXUhNvl5+fH8OHDY7fddovCwsJy99esWbN4/PHHIy8vr9htbrvttrjssstizZo15e5nvSlTpsR+++0XN954Y1xyySUJt2nQoEHcfvvtMXDgwAr3BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJAMF1xwQbRq1WqDsoKCgvjvf/8bEydOrNRYzjnnnGjXrl2R8r/97W+xcuXKSo0FAAAAqoPBgwfHbrvtVqT8n//8Z0yaNCmlfbdo0SJOOOGE6Nu3b+yxxx5Ro0aNUu03Z86cePbZZ2P06NHxwgsvJD2u4cOHR79+/aJx48bFbjN9+vS4//7746677oo1a9YkPYZfa9u2bZx//vlFygsKCuKqq66KhQsXpjwGInr06BF5eXlFyl9++eUoKChIQ0TAL+Xl5UWfPn2iX79+cdhhh0WzZs1Ktd+CBQvi3//+dzzxxBPx9NNPx6pVq1Ic6f9Xq1atOOqoo2LAgAGx5557RosWLUq973fffReTJ0+O0aNHx6hRo1ISd8uWLeOaa64xL1ZT5j0AAAAgG+SmOwAAqAxjxowptu7www9Pal/dunWL+vXrl2rb5s2bR8eOHZPaf0RE7969i617+umnk94fQGWZMWNGHHTQQfHoo48Wu83gwYNj6623rsSo0uuGG24o9kXFTTbZJEaOHBn5+flJ6ev000+Pvn37JqybN29enHzyyUnpBzLJlltumbD8/fffr+RIAKB8KjMnEiEvAgAAAMDG7bDDDnHAAQcUKZ83b17885//TLjPkCFDUhwVAAAAAABA6sybN2+Dn3/44Yc0RQLAxnimnZ0WLFgQp512Wlx++eXFbrPLLrvEwIEDK9TP/fffX+z3TgsLC2Pw4MFx4YUXJvWPzBcUFMSll14aF154YbHbHH300XHIIYckrU8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAZMvNzY1HHnkkGjZsmO5QAAAAgBQ59NBD4957740hQ4YU+dehQ4eU9bv99tvHyJEj4+uvv44bbrgh9tlnn6hRo0ap999yyy3jt7/9bTz//PMxffr0OO6445IW21VXXRWnnHJKNG7cuMTtOnToELfddlvMmDEj9tprr6T1n0jt2rVj1KhRCY/TggULYuHChSntn/+vV69eCcuff/75So4E+KUaNWrE+eefH19++WWMGTMmTjrppGjWrFmp9990003jyCOPjMcffzy++eabuPzyy6NWrVopjDiicePGceutt8bs2bNjxIgRMWDAgGjRokWZ2mjRokUMGDAgRowYEbNnz45bb701GjVqlLQYr7rqqpg5c6Z5sRoz7wEAAADZIDfdAQBAZRgzZkyxdX369ElqX4cddljC8rFjxyYs79mzZ1L7jyj+M02ZMiW+++67pPcHUJnWrFkTxx9/fLzzzjsJ62vUqBEnn3xy5QaVRgUFBXH88cfH4sWLE9bvvvvuce2111a4nzZt2sTtt99ebP0pp5wS8+bNq3A/kGmKe+nnhx9+qORIAKB8KjMnEiEvAgAAAMDGDR48OGH5ww8/HHfffXfCuq5du8aOO+6YyrAAAAAAAABSZv78+SX+DEDm8Ew7u910000lfh/67LPPLnfb+++/fxxxxBHF1p933nlx//33l7v9jbntttvirrvuKrb+6quvTlnfAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMmwzTbbxD333JPuMKqVrl27xvPPP1/k35VXXpnu0AAAAKhimjdvHiNGjIicnJxK6zM3NzeuuOKK+Pjjj+O4446L3NzcCrfZvn37GDlyZDzzzDPRtGnTcreTl5cXDz/8cPzpT38q036tW7eOV199NXr37l3uvjfmb3/7W+y0005Fyl977bX4wx/+kLJ+Kapnz54Jy1988cVKjgRY74ADDoipU6fGbbfdFttss02F29tss83ihhtuiOnTp8e+++6bhAiL6t+/f8yYMSMuvPDCaNKkSVLabNKkSVx44YUxY8aM6NevX4Xa+uWcWKtWrTLta16sWsx7ZArPz0jEeQEAAKxX8adNAJAFPv744/jyyy8T1u2zzz7RuHHjpPWV6AHBwoUL4+qrr064/WGHHZa0viMiGjduHPvss0/CujFjxiS1L4B0KSwsjFNPPTUKCgoS1h999NGVHFF6ffPNN3HmmWcWW3/ZZZdV6CWOvLy8GDlyZNStWzdh/V133RXjx48vd/uQyRo1apSwfOnSpZUbCACUU2XmRCLkRQAAAAAoWc2aNePkk09OWPfAAw/Em2++GZ988knC+iFDhqQwMgAAAAAAgNSZP3/+Bj//8MMPaYoEgJJ4pl01XHXVVfHf//43YV23bt2iRYsW5Wr31ltvLbbuoYceir/+9a/larcsLrzwwvjiiy8S1nXt2jU6duyY8hgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKuK4446LQYMGpTuMamPzzTePnj17Fvm32267pTs0AAAAqpDc3Nx47LHHomnTppXWZ926dePZZ5+NoUOHRs2aNZPefp8+feKdd96JFi1alGv/P//5z3HiiScWKV+6dGlMmzYt3n333Zg1a1YUFBQU2aZOnToxatSo2GWXXcrVd0mOP/74OO2004qU//DDD3HccccljIfUaN++fcLza9q0afHf//43DREBl112WUyYMCHatm2b9La32267eOWVV+Kcc85JWpu5ublx7733xujRo2PzzTdPWru/tMUWW8SYMWPi3nvvjdzc3HK1UdycGGFerE7Me2QSz89IxHkBAACsV74sGABkobFjxyYsz8vLi0MPPTQpfTRv3jx23nnnIuUvvvhiTJ06Nb755psidV27do369esnpf+IiJ49e0ZeXl7CuuJ+BwDZaPr06fH6668nrNtpp52icePGlRxReo0cOTJGjhyZsC43NzdGjBgRDRs2LFfb11xzTXTu3Dlh3fTp0+Piiy8uV7uQDYpbVxUWFlZyJABQfpWRE4mQFwEAAABg44488sjYdNNNi5S/8cYbMXPmzIiIeOCBBxLu+5vf/Cbq1KmT0vgAAAAAAABSYf78+SX+DEBm8Ey7ali2bFn87W9/K7b+gAMOKHObhx9+eOy+++4J677++us466yzytxmeaxevTrOPffcYusHDx5cKXEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVMTdd98d22yzTbrDAAAAAJLkuuuui3333bfS+qtTp068/PLL0atXr41uu2rVqvjkk0/irbfeitdeey3eeuut+Pjjj2Px4sUb3Xe77baL1157LTbddNMyxdezZ884//zzNyj78ssv44gjjojGjRvHTjvtFHvuuWdsu+220aJFi7jpppti3bp1G2xfq1ateOyxx6J27dpl6rskO+ywQ9x7771FygsLC+OEE06IOXPmJK0vNq5nz54Jy1944YVKjgSIiLjnnnvixhtvjNzc3BK3KywsjC+//DLeeuutePbZZ2P06NHxyiuvxEcffRRLliwpcd/8/Py4884744orrkhKzA899FCcccYZpdp20aJFMXPmzHj33Xfjtddei3fffTdmzpxZqvkwIuKMM86IBx98sMwxJpoTI8yL1ZF5DwAAAMgWJWcIAaAKGT16dLF1ffr0SUofxb3YMX78+IhI/KAgPz8/evTokZT+I4r/LF988UVMmzYtaf0AZILixvacnJxo3759JUeTfmeeeWZ8/fXXCeu22WabhC8NbEyXLl3iyiuvTFi3evXqGDRoUKxcubLM7QIAUHkqIycSIS8CAAAAwMYNGTIkYfmwYcN+/u9//OMfsXbt2iLbNGzYMI455piUxQYAAAAAAJAq8+fPL/FnADKDZ9pVx9NPP11sXefOncvc3uDBg4utu+iii2LFihVlbrO8xo8fH9OnT//55xUrVsQTTzwRAwYMiIsuuqjS4gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAor4YNG8aIESMiJycn3aEA1dDKlSvjvffeS/hv5cqV6Q4PAACyzqGHHhqXX355pfb5xBNPxN57711s/XfffRd//OMfo1OnTlGnTp1o3759dOnSJQ444IDo0qVL7LzzztGwYcPYeuut49RTT41JkyYV29Z2220Xw4YNK1N8t9xyywZ5jxkzZsTuu+8ezzzzTKxdu3aDbefMmROXX355HHvssVFYWLhBXbt27eLUU08tU9/FqVWrVjz55JNRr169InU33nhjvPTSS0nph9Lr1atXwvIXXnihkiMBbrjhhhgyZEiJ24wfPz6OOeaY2HzzzaN169bRpUuX6NOnTxx55JHRo0eP2GWXXaJx48ax1157xXXXXRcLFiwotq2hQ4fGCSecUKGYL7744vjNb35TbH1hYWG8+uqrcdJJJ0Xr1q2jUaNG0a5du9hzzz3jgAMOiD333DPatWsXDRs2jNatW8dJJ50Ur776apG56JdOPPHEuOiii8oU56/nxAjzYnVl3qM85PMBAABIh/x0BwAAleXNN9+MefPmxWabbVakrmfPnpGbmxsFBQUV6uOwww4rUlZYWPjzA4LnnnsuBg8enHC/sWPHVqjviIjc3Nzo2bNnwroxY8ZUuH0i8vPzY7vttotGjRpF/fr1Izc3N1asWBELFiyIWbNmxYoVK9IdYrWUbcdl6623jiZNmkTDhg2jdu3asXz58liyZEn88MMPMXv27HSHl1VmzpxZbF2rVq3izTffrMRo0m/x4sVxwgknxGuvvRa5ublF6o899tgYN25cjBw5slTt1atXL0aMGBF5eXkJ66+44or48MMPKxRzJsvLy4ttt902GjduHA0aNIiI//2OFy1aFLNmzYrVq1enOcLUaN68eTRt2jTq168fdevWjcLCwli0aFH8+OOPsXDhwvjxxx9LfOGGylO/fv3Yeuuto0GDBlG/fv0oKCiIxYsXx+LFi+Prr7/2osFG5ObmRuvWrWPTTTeN+vXrx9q1a2Px4sXx448/xqxZs5J6ntevXz9atmwZjRs3jjp16sTq1atjyZIl8fXXX8f8+fOT1k+maNq0aTRp0iQaNWoUDRo0iNzc3Fi2bFksXrw4fvjhh/j+++/THWJGyMbxtl69etGiRYufx53c3NxYsmRJLFq0KL799ttYunRpukOkGJWRE4mQF0m1GjVqxLbbbhtbb711Rt/31q1bN1q2bBkNGzaMevXqxerVq2Px4sUxZ86crJkDrLMyT3VdX2T79SQHljzV9XdZFcbjbMwvVdfzrTSq63y0XqbfE2bjffYvrV/vZ8uzrlTI9HMsXbJlXM72azAdsuXYJlvbtm1jv/32K1K+ZMmSeOKJJ37+ed68efHss89Gv379imw7ZMiQeOihh1IYZdWTzddoNq6pfynb488kmb5WyObrrCrI9hxCttwPVNf74mzP00Zkx9qzOp5f9erVi6233joaNmwY9evXjzVr1sRXX30VX3/9dbpDK7NsGcfWy4ZrYr2qMAZVRdm+9iAzZNvYmQpV4VpyHDPP+u8WZfr7Vetl07qEiqkKY162yrQ19Q8//FDiz8lQHe+xk02+d+MS5TWWLFkS8+fPz5rcRjbMw67n9PBMu2qZMWNGLFy4MBo3blykrnXr1mVqa8stt4zDDz88Yd3UqVPjqaeeKleMFfHXv/41evXqFY8++miMGzculi1bVukxVCfZNC5nwzxXXeTk5MS2224bm266aca/N5It6+BsvRYLCgpchwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkMC+++4bl112Wdx4443pDgWoZr755pvo3LlzusMAAIAqoXnz5jFixIjIycmptD4vvPDC6N27d8K6VatWxVVXXRV33HFHrFmzZqNtfffdd/Hggw/Ggw8+GL169Yrhw4fHFltsUWS7fv36xcCBA+OJJ57YaJuHHHJI7LjjjhuUnXDCCfHTTz+VuN+oUaPi4YcfjpNPPnmD8gsuuCDuueeeKCws3GjfJbnzzjujY8eORconTZoUv//97yvUNmVXu3bt2HfffYuUr1ixIl5//fU0RATVV+/evePyyy8vtv7tt9+Os846K95///2NtrVu3bqYPHlyTJ48OW688ca48MIL4+qrr478/Pwi295///0xZcqUmDFjRpljbt26dVx//fXF1n/00Udx6qmnxpQpU0rV3pdffhlffvll/OMf/4jdd989Hnzwwdh5550Tbjt06NAYM2ZMfPnllxttN9GcWFhYaF6shsx7lJd8PgAAAOlQNJsHAFVUYWFhPPPMM3H66acXqWvSpEnss88+8cYbb5S7/by8vDjooIOKlE+ZMiV++OGHiIiYMGFCrF69OmrWrLnBNr169Sp3v7/UpUuXaNy4ccK6MWPGlLm9vffeO7bZZpsi5f/9739L/F21adMmOnXqVGLbTZs2TVjetm3bGDhwYNkCjYipU6eW62Fkaey8885xzDHHxOGHHx4dOnQocvzWKywsjJkzZ8arr74aTzzxRPz73/9OSTzl5bik77h07NgxjjrqqOjRo0fsvPPOUb9+/WK3/emnn+Kjjz6K559/PsaMGRMzZ86sxEizz/fff19sXb169SoxkswxadKkuOGGG+L//u//Etbfc889MWnSpPjmm2822tbf/va32HbbbRPWTZgwIf7yl79UKNZUK24eGzduXKxYsSLhPuvHll69esWOO+4YtWrVSrjd2rVr45NPPomJEyfGqFGj4rXXXouCgoKkxl9ZOnXqFP369Yvu3bvHTjvtFA0bNixx+8WLF8cbb7wREydOjOeeey6mTp1apv4yaT5q3rx5dOvWrcR969Spk7B89913L1cs3333Xbz55ptl3i8iolGjRtGnT5844ogjYvfdd49WrVoVu21BQUF89tlnMXny5Bg7dmy88MILsXz58nL1W5LyXGcRETvssEPsvvvu0aFDh2jcuHE0aNAgatSo8XP9K6+8Evfff3/S+69Xr14ce+yxcfzxx8eee+4Zm2yyScJ2ly1bFh988EGMHTs2Hnvssfjuu+82Gsuv7bjjjnHaaafFoYceGu3atYvc3NyE233//ffx2muvxRNPPBFPP/10rFu3rsx9pdvWW28dgwYNim7dukXnzp1j8803L3H7n376KaZNmxYTJkyIZ555ptQv/v1SZY8lyVjXVvZ4mwxNmzaNPn36RO/evaNTp07RsmXLYr9IUVhYGJ9//nm89dZb8fjjj8eLL76YVefzzjvvHO3bty+2fsGCBTFhwoRKjCi5Up0TiaiaeZGI8udGytJWSfPmLrvsEoMGDYpDDjmk2HvfdN/31qpVK3r27BlHHnlk7LPPPtG6detix4off/wx3n777Rg9enSMGjUqFi1aVKmxFied66z99tsv4Re7Vq9eHWPHji13u7/Ws2fPaNCgwQZlK1asiHHjxiWtjyOPPDLy8vKKlL/++usxZ86cMrWVjvVFJqgK19P6PNj5559faTmwnXbaKTp06JCwbvTo0bF27dpyt70x+++/f8Lz88svv4z33nuv3O1W13xiVbnvzbb8Uiadb+nOM/xadZ2P1sv0e8JMu89O1Xo/Iv1r/lTJhHMs08ad9X45Nnfp0qXY7dK5DkjHNZhJzxfKI5Pm3HQ644wzEpY/9thjRdZz999/f/Tr16/ItnvttVfssssu8eGHH6YixCohk+bJbF9TZ3v8yZTMXGlpZMJaoSTpus4ydT6s7POjPDmEK6+8MqPyB9lwP1Bd74urUp42k9eemXJ+Veb4VbNmzejZs2ccffTRsffeexd7bi1fvjymTp0a48ePj6eeeiqmTZuWsL3NNtssdtpppyLln332WXz77bdliq2qjmPrZcM1sV5VGIOKk6nrmNLIxOcXqVCesaCiebImTZokfNdkY/2W16abbho9evRIWPf000/HqlWrSt1WVR87UyETr6XqfByzeVz+tdJ8tyhTjkc2rUtK4n2njasqY15E6p+LJVumr6nnz58fu+yyy88/J+PazpR77GyWSc9VIjLzei1tXiMiPbmN0siGeTgTv5uTLWvCZPJMu+r5/vvvE37PpFmzZmVq59hjj024doyItH3X+t5774177703LX0nkim5nrLmeYqTTeusTJrnMnEtU9m23XbbOOaYY6Jv376x6667Fvs99XS/N5Jp6+DiVMVrMZPzPgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkA7XXntt/Otf/4opU6akOxQAAACgjHJzc+Oxxx6Lpk2bVlqfrVu3jqFDhyasmzdvXvTs2TPef//9crX9/PPPR5cuXWLixInRokWLIvXXXHNNPPnkk1FYWFhiO4MGDSpS9p///KdUMdxwww1x8sknb1DWpk2b2H333eO9994rVRuJHHvssTF48OAi5QsWLIhjjz021q1bV+62KZ8DDjggateuXaT81VdfjVWrVqUhIqieGjduHMOHDy+2/q9//WtceOGFsXbt2jK3vWzZsvjTn/4Ur732WjzxxBOx+eabb1Bfu3bteOCBB6JLly5lbvuaa66JmjVrJqx79tlnY8CAAbFmzZoytxsRMWXKlNh9991j9OjR0bt37yL1NWvWjGuuuSZOOumkjbaVaE58+eWXzYvVkHkPAAAAyCY5hRt7GrR+w5ycVMcCACl32GGHxXPPPZew7sYbb4wrrrii3G3vu+++MXHixCLl1157bVxzzTU//zxhwoTo3r17ke123HHHmD59ern7j4i46aab4tJLLy1SPm/evNhiiy02+hLIrz366KNx7LHHFikfO3Zs9O/fv9j9zjrrrLjrrrvK1FdFnXTSSfGPf/xjo9uV5TN17NgxbrjhhjjssMPKFdP06dPjqquuijFjxpRr/2RzXP6nMo/LkUceGVdddVXsuuuu5W5jwoQJPz+Mz0SXXnpp3HTTTQnrttpqq5g9e3ZK+99uu+3iiy++SFh33nnnxZ133pmSfrt37x4TJkxIWHfEEUfEM888k5J+SysvLy/eeuut6Ny5c8L6SZMmxf777x8FBQXFtnHkkUfGqFGjEtb9+OOPsfPOO6f8+FZUcWNLy5Yt45tvvtmgbI899ojrr78+DjnkkHL1NWvWrLjhhhviwQcfLPdLLL9W3nm4NHJzc+OYY46JK6+8MnbaaacKtfXSSy/FjTfeGK+++mqpts+k+ahv377x9NNPV2osf/3rX+Pcc88t0z7bb799XH755XHCCScU+xLVxixbtiz+/ve/xy233BJz5swpVxuJlOU6q1+/fpx99tlx6qmnRps2bUpsd9iwYfHb3/42af3n5OTE4MGDY+jQodGkSZONtvtLa9eujWHDhsU111wT8+bN2+j2rVu3jttuuy369OlTpn4iIr7++uv4v//7v/jnP/9Z5n3ToWvXrnH11VfHQQcdFLm5ueVuZ8aMGfHnP/85RowYUeoxtLLHktKua38tneNtReyyyy5x+eWXx9FHHx15eXnlamPu3Llx7bXXxn333Veul1LXS+V8uF7v3r3jiSeeiDp16iSs/+abb+Lggw+OTz/9NCn9pUsqcyIRVTMvEpHcc7As82anTp3iz3/+c8Lf1cZU1n1vgwYN4pxzzokLLrggNt100zLvv3jx4rjrrrvi+uuvj2XLlm1Q9+233yb8otNFF10Uf/nLX8od869lwjrrD3/4wwbXyC9tt9128dVXX5Urrl+qX79+LFiwIGrUqLFBeWFhYTRv3jy+//77CvfRoUOHmDZtWpHygoKC2HLLLUu1jopI7/oinarC9VTRPFhFcmD77bdfsfv169cvZfd9derUiblz50b9+vWL1A0cODCefPLJMreZafnEyliLRWTGeFycbM8vlSTTzreI9OcZ1quu89F6mXRP+GuZfJ9dWev9iMx7BllWmXSOZcq4s14611Slke5rMJOeL5RFJs656VKrVq2YPXt2wjz9XnvtFZMnT96gLDc3N7799tto3rx5ke3vvffeOPPMM1MWa0T6n4WXVbqv0eJk+5q6qsafzPxmsu8RM2mt8GuZcJ1l6nyYLTmETMgfZMP9QHW9L5an/Z9Urz0z7fyqjPGrTp06ce6558all15a5ndWIiJeeOGF+P3vf1/kDw8NHDgwHn/88SLbl+e8qmrj2HrZcE2sVxXGoI3J1HVMSTL5+UUqlHYsSGaebM8994x33nknYV2iMaiiunTpEm+88UbCus0337zUz7Ujqu7YmQqZfC1V5+OYqeNyZX23qLKPRzatS0rD+07FqypjXrKfi1XGvVd1WFP/WqbdY6dCVf1e1cZk0nPsiuY1Iiont1GSbJiHfTcnc3imnXyZEONrr70W++23X5HyadOmlWkOeO655xLef6xcuTKaNWsWS5curVCcVUGm5HrKmuf5tWxaZ2XiPJdJa5lkKMuatHXr1nHdddfFwIEDy3XuVMa75Jm8Dv616nQtZlLeBwAAqqPy/B2S9fytdqA4HTt2jI4dO0bE/8aZL7/8Mt5+++0KjTkApdXrsF7lftcRyuOrr76Ku++6O91hAKTMqaeeGu07tE93GFQTb775ZowZnRnfOwFIhSv/78po3LhxusOgmhj91Oh466230h0GQEo0atQo/u+q/0t3GFQzt95ya1K+3w2QibbrHHHUn9IdBdXJzT3THQFA1ZaTkxN77LFH7LDDDj+/7/3RRx/FRx99lObIAADINtf+6dqoU6eOHDlAJVv/ntldf7srZs2ale5wAKqNs353Vmy77bbxwAMPxCczPkl3OADVwvrvLnr3HaBy9R/QP7p06RLjnxufsr+tDUBR6/8u1iuvvBLPj38+3eEAAJCAv9UOpIK/1Q5kmgMPPDAOO7zo/5cYUk1uFKhOzLekg7kWqE78v8lIB+9cAtWJuZZ08R0zoDo5+OyI3XqnOwqqm5f+GvHBc+mOAqBy+VvtmcU7tZDYV199Fa1atSrVtp9++mnsuuuusWLFipTEMmPGjGjXrl2R8k033TR+/PHHlPSZSQYMGBBPPfVUkfJRo0bF0UcfnYaIqA6Kmwd9Vw0AIOKtt96Kvffeu0j5XnvtFZMnT05DRFB+Q4cOjSuuuKJI+YwZM6J9+/ZFys8444y47777KtTnk08+GUcddVSR8iVLlsQ+++wT06ZNq1D7ERF77rlnvPHGG5Gfn/9zWUFBQfzrX/+Kk08+eaP/n6PPP/88WrduvUFZWe6HEuUyzj///LjjjjtK3cYvtWnTJv7zn/9E/fr1NygvLCyMww8/PJ5/3nc20uGOO+6Ic889t0j5ueeeG3/961/TEBFUjkxbC91www1x+eWXJ6y7884747zzzktKP7vssktMmjQp6tWrV6TuyCOPjNGjR5e6rYYNG8bcuXOjVq1aReree++96NKlS6xZs6ZC8UZE1KxZM958883Yfffdi9StXLkytthii1i0aFGJbSSaE88666y45557Sh2HebFqMO+RadLx/Myzk8znuSoAZJ+cnJzo3LlzbL/99t6nBUqtNO9451ZCHACQMV5++eVYunRpwrrevSv2rfHDDkv8x0ufe27DbwWPHz8+4Xa9evWqUP8RxX+GZ555psp/+SsZL9H80hVXXBHvvfdesce1NDp06BCjR4+OZ555Jpo0aZLE6LJHdT0u7dq1i8mTJ8eoUaNi1113rVBbPXr0iH//+9/x6KOPRuPGjZMTIFXeunXrYtCgQbFs2bKE9d26dSv2BZKIiObNm5f48uPpp58es2fPrnCcmSAvLy+uv/76eOedd+KQQw4pdzutWrWKv//97/Hhhx9Gp06dkhhh8u20007x3nvvxciRI2OnnXaqcHuHHHJIvPLKK/GPf/wjateunYQIky/Z81FFfPLJJ6Xetnbt2nHrrbfGJ598EqeeemrUrFmz3P3WrVs3Lrzwwvjqq6/isssui9zcyk0JHXzwwTF9+vQYOnRotGnTplL7btCgQTz77LNx7733lmvuz8/PjyFDhsSHH34YXbt2LXHbk08+OaZNmxZ9+vQpV6wtW7aMESNGxNixY4u88JVJGjVqFMOGDYvXX389DjnkkAqfT+3bt4/hw4fH1KlTo0uXLkmKMrnKM45k43jbuHHjePjhh+ODDz6IY489NvLy8srd1uabbx533XVXTJ06NXbeeeckRplcJ598cowdOzbq1KmTsP7jjz+OffbZJz799NNKjiz5UpkTiZAXSZacnJy4+uqr49133y33HxSujPvevn37xqeffhrXXXddbLrppuVqo0GDBnHFFVfEtGnTYr/99ktyhCXLpHXWE088UWzdEUccUe64funQQw+NGjVqFCnPycmpUI7ll4qLdeLEiTFv3ryN7l8d1xfrZfv1lKw8WEVyYBMnToyZM2cmrDvllFPKHdPGDBgwIOG6ff78+TF27NgytVVd84mZNB5XRLbll6rC+ZaqPEN1no8iMv+eMBvvs38tGev9iOx9Bpnp51hJUp3fzIQ11cZUhWuwPCryfKEqzLnJdtRRRyUct6ZNm5bwS/cFBQXx0EMPJWzr+OOPj7p16yY7xKyV7ddotq2pfy3b488Umb5WyPbrrCIy4Xl7snII6cwfZMP9QHW+L5an/f9StfasrufXgQceGJ999lnceOON5b5me/bsGW+//XZcf/31FZofKyobxrH1suGa+KVsH4MyWXnXMVXl+UWqpOs9wGyUTWNnKlSVa6m6H8dkSub9ZUW/W1RZxyPb1iWl5X2noqrKmBeR3vf+y6u6ramr6z12MlWVfG+qr9dk5DUi0pfbyIZ5uDpez5nwzKEknmlXTatXr05YXpYxKS8vr9g1wksvvVTsd3XILtk0LmfDPLcx2XjvUZJzzz03pk6dGscee2y5z51UvzeSLevg6ngtZlLeBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0mWHHXaI2267Ld1hAAAAAGVw6KGHxuWXX16k/NVXX40///nPKemzffv2cdRRRyWsGzx4cEybNi0p/UyePDn+/ve/R0TEp59+GldccUVsvfXW0bNnz/j+++9L3HfTTTeN1q1bV6j/KVOmFCnbe++9y9VWzZo148knn4z69esXqbvlllvi+eefL1e7VNyhhx6asPyFF16o5Eig+mrYsGGcc845CeteeumlOP/885PW14cffhgnnHBCwrqrr766TG0ddNBBUatWrYR1Z5xxRqxZs6bM8SWyevXqOOOMMxLW1a5dO3r06FHi/sXNie+9916Z4jAvVg3mPQAAACCb5KY7AACoTKtXry72IclOO+0U22yzTbnb7tWrV5GyBQsWxLvvvrtBWXH9H3bYYeXuOyKiVatW0aFDh4R1Y8aMqVDbma6wsDBmzJiRlLby8vLikUceiaFDh0aNGjWS0mafPn3inXfeiVatWiWlvWxRXY/LqaeeGu+//3507tw5qe0ee+yxMXXq1Nhpp52S2m62q127drF1y5cvr8RIMs/nn38e5557brH1f/zjH2OPPfZIWPfwww9HkyZNEtYNGzasyswrtWvXjmeffTauvPLKyM1Nzu1x+/bt45133onTTz89Ke0l28knnxxTpkyJ3XbbLelt/+Y3v4k333wzttpqq6S3XRHJnI+SYebMmaXarm3btvHRRx/FhRdemLTzMyKiVq1aceONN8bbb78dW2yxRdLaLcmgQYPi+eefjxYtWlRKf7/UsGHDmDhxYoXX2hERW2yxRbzyyivRvXv3hPXXX399PPjgg8W+7FYWRxxxRPz73/+ORo0aVbitZGvTpk289957cdppp0VOTk5S227btm1MmjQprrjiiqS2W1HlGUeycbzt2rVrTJ8+PU488cSkttuuXbt455134thjj01qu8lwySWXxIMPPhh5eXkJ6ydNmhTdunWL2bNnV3JkqZHKnEiEvEgy5Ofnx6hRo+KPf/xjUub/VN333nHHHfH000/H5ptvnpT2WrZsGS+//HKcfPLJSWlvYzJtnTV9+vRi55l+/folJba+ffsWW9enT5+k9NG/f/+E5U8++eRG962O64v1sv16SkUerLw5sPvvvz9h+eGHHx7NmjVLRmhFnHLKKQnLH3744TJ90aW65hMzbTwur2zLL1WF8y1VeYbqPB9FZP49YTbeZ/9astf7Edn1DDLTz7GSpDq/mUlrquJUhWuwPCryfKEqzLmpUNyXuIcNG1bsPg888EAUFhYWKa9fv34cd9xxSYstm2X7NZpta+pfy/b4M0WmrxWy/TqriEx43p6KHEJl5w+y4X6gOt8Xy9Mmlsy1Z3U9v37/+9/Hyy+/nJQxPi8vL6688sp44oknkvYObVlkwzi2XjZcE7+U7WNQJivvOqaqPL9IlUGDBqXlPcBslE1jZypUlWupuh/HZErW/WWyv1uUyuORbeuSsvC+04aqypgXkd73/suruq2pq+s9djJVlXxvqq/XZOY1Iio/t5EN83B1vJ4z4ZnDxnimXTUl4xrbY489ol69egnrXn755Qq3T/pl07icDfPcxmTjvUdx8vLy4oEHHog77rgj6tSpk5Q2U/HeSLasg6v7tZgJeR8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKgM//73vxOWn3HGGdGnT5/KDQYAAAAol+bNm8eIESMiJydng/K5c+fGcccdF+vWrUtJv+eee27C8pdeeikee+yxpPZ17bXXxj777BNt27aNG2+8MWbPnl2q/TbffPMK9z1z5syktXv77bfHrrvuWqT87bffjiuvvLJcbVJxLVu2jLZt2xYpnzVrVnz22WdpiAiqp/79+0fdunWLlK9bty7OPffcKCwsTGp/Tz/9dLz88stFynfZZZfYfffdS93OXnvtlbD8nXfeif/85z/lji+RKVOmxOTJk8sUx3rFzV2ffvppmWIwL2Y/8x4AAACQbXLTHQAAVLbRo0cXW3fYYYeVq80tt9wydtlllyLlL7zwQpEHcdOnT49vvvmmyLbdunVL+ECvtA4//PCE5UuXLo0JEyaUu91sMGvWrFi+fHlS2rr//vvjhBNOSEpbv9SmTZt45ZVXYrPNNkt625mqOh6XSy+9NB544IGoXbt2Utr7ta222ipef/31jT7Ark622GKLYusWLFhQiZFkpuHDh8eYMWMS1uXn58fIkSNjk0022aD8/PPPj4MOOijhPp999lmcd955SY8zHfLy8uLZZ5+Nnj17Jr3t/Pz8uP/+++Piiy9OetsVce6558bw4cOjZs2aKetjt912i2eeeSZq1aqVsj7KKpnzUTIkejno1/bee+948803Y/vtt09ZHJ07d4533nkn2rVrl7I+IiIOPvjgeOSRRyIvLy+l/SSSn58fzz33XMJ1ennVrFkzxowZU+TloMsuuyzpL2R16tQpHnnkkaS2WVHNmzePV199NVq3bp2yPnJycmLo0KFxyy23pKyPsirrOJKN422/fv3i5ZdfLnFtVRF16tSJf/7zn3HcccelpP3yuOWWW+Lmm28utv7pp5+Ogw46KBYtWlSJUaVeKnIiEfIiyTJy5MgYMGBAUttM5n1vTk5OjBgxotgvO1VEjRo1Yvjw4XH88ccnve1fytR11pNPPpmwvFu3btGkSZMKxZOTk1Pi9X3wwQdXeM7acsstY4899ihSXlBQUOK4E1F91xdV4XpKZR6sPDmwhx9+OFavXl2kPD8/PyW/i6233jq6d++esO7+++8vdTvVNZ+YqeNxWWVbfqkqnG+pyjNU1/lovUy/J8zG++xEUrHej8iOZ5CZfo6VJNX5zUxbUyVSVa7B8ijv84WqMOemQrt27WLfffctUr569eoSc+FffvllvPbaawnrzjzzzKTFl62y/RrNtjX1r2V7/Jki09cK2X6dVVS6n7enOodQWc/NM/1+oLreF8vTblwy1p7V9fz6y1/+Etdee23k5ib3K1sDBgyIhx56KKltlkamj2PrZcM1sV5VGIMyXXnWMVXl+UWqrM+VUTrZMnamQlW6lqrzcUy2ZN1fpuK7Rak4Htm0Limv6vy+0y9VpTEvne/9l0d1XFNX13vsZKoq+d5UX6+pymtEVE5uIxvm4ep6Paf7mcPGeKZddTVs2DBheVnOx44dOxZbN2nSpDLHRGbJpnE5G+a5jcm2e4+Nue++++LUU09NervJfG8kW9bBrsX/yYS8DwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApNq5554bs2bNSlj3wAMPxOabb165AQEAAABlkpubG48//ng0bdp0g/KCgoIYNGhQzJ07NyX91qhRI4477riEdb///e+T3t+8efPi7bffLvN+TZo0KVJWWFhYpjYWLlxYqnY35uijj44zzzwzYfvHHHNMrF27tsxtkhw9e/ZMWP7CCy9UciRQvR199NEJy0eOHBkzZ85MSZ/FzVknnHBCqdvYbrvtEpa/+OKL5YppY4obm4qLY73i5sRFixaVqX/zYvYz7wEAAADZJj/dAQBAZRs/fnysXr06atasWaSuT58+ce+995a5zUMPPbTYvhJ54YUXYvDgwRuU1axZM7p37x7jxo0rc/8R/4u9uL5WrVpVrjbLa9myZfHdd9+VuM1mm22W8BgsXbo0fvrppzL1N2nSpDJtX5wzzzwzTjnllIR13333XYwdOzbefvvtmDVrVixevDhq1KgRTZs2jW222SYOOuigOPTQQ6NRo0bFtr/tttvGo48+Gj169EhKvGXluCSWrOPy29/+Nm666aYSt1kf7wsvvBCffvppzJs3L5YuXRoNGjSIpk2bxg477BA9evSIfv36xbbbbpuwjUaNGsUzzzwTe+yxR3z77bcVirkqaNmyZbF18+fPr8RIMtfpp58ee+21VzRv3rxI3fbbbx933HFH/Pa3v42IiJ122iluvPHGhO2sXbs2Bg0aFMuXL09pvJXltttuK/a6nzlzZjz77LPx3nvvxTfffBNLliyJvLy8aNasWWyxxRbRrVu36NWrV2y99dYl9vHnP/85Zs2aFaNGjUrFRyiTww8/PG6//fbIyckpdpv//Oc/P4+pM2fOjIULF8by5cujRo0a0aRJk9hyyy2jW7du0adPnxLHzE6dOsVdd90Vp59+esL6TJqPVq5cudFYmjdvHrm5uUXKFy1aFEuWLClTLKtWrdpof+3bt48XX3wxGjRoUOJ233zzTTz77LPx1ltvxZw5c+KHH36I/Pz82GyzzaJ58+ax//77R69evaJZs2bFtrHNNtvEhAkTonPnzjF79uwyfZbS2GKLLeLRRx9N+PurDH/84x+ja9euRcqXLVsWTz31VEyYMCE+/fTTWLJkSdSvXz+aNWsWHTt2jL59+8aee+5ZbLsNGjSI+++/P/bbb7+IiDjwwAPjhhtuSLjt119/HY8//ni88cYb8d///jdWrVoVTZo0iS222CL23Xff6Nu3b2yzzTbF9tW7d+8YMmRIue5RUmHkyJHRokWLYuvnzp0bTz31VLzyyivx8ccf/7zWKSgoiDp16kSjRo2iTZs2sfvuu8fhhx8eBxxwQLHj0kUXXRRTp06Nhx9+OGF9ZY4lZVnXZtJ4W1rdu3ePJ598MvLzS04Vz5o1K8aPHx9vv/12fP/99/HDDz/E2rVro379+tG8efPo3Llz9O/fP3bYYYeE++fm5sYjjzwSX3/9dbz55psVirki8vLyYvjw4XHiiScWu80DDzwQgwcPjoKCgkqMrHKkIicSIS+SDBdffHGxL3v/+t53xYoVabnvvfHGG+P444/f6HYff/xxjB8/Pv7zn//E3LlzY8GCBZGbmxsNGzaM7bffPvbee+/o27dvbLbZZhvsl5OTEw8++GB8+umnFYqzOJm8znriiSfi6quvLlKel5cXhx9+eDzyyCMb/4DF2GeffWLTTTcttr5u3bpxwAEHxEsvvVTuPvr27Ztw7nvjjTfi+++/L3HfTFpfVKZsv55Kkwf729/+Vqk5sPnz58fTTz+dcCw99dRT4/bbby/VZyut3/zmNwnPtddff73UX9CprvnETB6Pyyqb8ktV4XxLZZ6hus5HEZl/T5iN99mJlGW9n43PIEuS6edYSVKd3yzt2DxkyJC0jcuZdg1m0vOF4lSFOTdVhgwZkrD8mWeeiQULFpS477Bhw+KAAw4oUt6pU6fYfffdY8qUKckIMetk2jVaHtm0pq6K8WeCTF8rZOJ1lg3zYbJUVg4h1fmDbLgfqK73xdUhT5sJa8/qeH5ddtllccEFF2x0u48++ijGjRsXU6dOjXnz5sX8+fOjefPmscUWW0TXrl2jd+/eseWWWxbZb9CgQTFx4sSEf6AoFbJhHIvInmtivWwfg8oj09cxVen5RSqk+13AbJMtY2cqVKVrqaofx0wflxMpy3eL0vV+VUT2rUvKqzq/77ReVRrzsnGur45r6up4j51MmZjvLY9UX68VyWusH9vSmdvIlnk4k67nja0LM21NmEqeaVddv57n1yvLd0OLew5ZUFAQ06dPL1dcZI5MGpdLki3zXEmy8d6jJOecc06ceuqpCesy5b2RbFoHV/VrMTc3NyOuQwAAAAAAAAAAAAAAAAAAAACAynDVVVdF3bp1IyJi+PDh8dlnn6U5IgAAAKAqkXsAAAAAAAAAAAAAAAAAAAAAAKgaFi1aFMcff3xMnDgx8vLyNqhr1qxZPPjgg3HYYYelKbrUql+/fuTn58fSpUtjzZo16Q6HNKlVq1bUrVs3Vq9eHUuXLk13OGSI9efF8uXLY+XKlekOp4j18a1YsSJWrFiR7nBIsjp16kSdOnWioKAgFi1aFIWFhekO6Wd5eXlRv379yMnJqdLzZyYfg6okG9ZiNWrUiHr16kVBQUEsXrw4484F65iizJHUrFkz6tWrFytXrozly5enO5xKc91110W3bt2KlP/pT3+KV155JWX9du/ePRo2bFik/N13343JkyenrN+yatCgQZGysq7zly1bVqQs0WcvyXbbbRfDhg1LWHfyySfHN998U6b2skWm31+t17Nnz4Tlzz//fMr6zJbfTSpk65o7049ZVVgL7b333gnLR40albI+33777ZgzZ05sueWWG5QfeuihpW4j0VwTEfH1119XKLbiFDdnbGxuSsacGGFerArSMe9BVZXp64NkqS654WyRrXnBbLheqsKaGgCgqspPdwAAUNkWL14cr776asKHVt27d486deqUOYGR6IshBQUF8eKLLybc/rnnnovBgwcnbGfcuHFl6jsiYpNNNokDDjggYd2YMWPK3F5FPfzww/Hwww+XuM1bb72V8CHmsGHD4oILLkhVaMXaaqut4qabbipSPn369Ljqqqs2+nscNmxY1K1bNy655JK45JJLYpNNNkm4Xffu3ePUU0+N4cOHJyXusnBcUndc9tprr/jb3/5WbP28efPij3/8Y9x3332xdu3aIvULFy6MhQsXxmeffRbPPfdcXHLJJXH88cfHDTfcEM2bNy+y/WabbRZPPfVU7LXXXlnzYkiq9OnTJ2F5QUFBfPjhh5UcTWb68ccf48QTT4x//etfkZOTU6T+9NNPj+eeey7Gjx8fI0eOjFq1aiVs5+qrr4733nsv1eFWigMOOCDOOeecIuUTJkyIP/zhDzFp0qQS93/kkUci4n/z9tChQ2OXXXYpdtuHHnooPvroo/j0008rFnQFbLHFFvHII48kPP4REZMnT44LLrgg3nzzzYT169ati9mzZ8fs2bNjypQpcccdd8Ree+0V9913X3Ts2DHhPqeddlo88MAD8dZbbxWpy6T56KWXXoqtt966xG3mzJkTW2yxRZHyq6++Ou68886kxRIR0aRJk3juueeKfWEqIuKDDz6Iyy67LF566aUS2xo+fHjk5OTEMcccE0OHDo1tt9024XbNmzePcePGRZcuXWLVqlUViv/X/vznP8emm26asO7DDz+MZ599Nt55552YO3duzJ8/f4M5sqIPa3fccce47LLLNihbt25d3H777fGnP/0pFi1alHC/cePGxfXXXx/77bdf3HPPPdGhQ4eE2+27774xcODAGDduXPzjH/8ocn3NmTMnLr300vjnP/9Z7Fz9xBNPxHnnnRdnnnlmDB06tNjj/pe//CVGjRoV8+fP39jHTqmjjjoq9t9//4R1K1eujN///vdx5513xurVqxNus3Tp0li6dGl899138e9//ztuvfXW2GGHHeKmm26Kfv36Jdzn7rvvjldeeSW+/fbbInWZNJasl2njbWm0bt06Ro0aFfn5xaeJ33rrrbj88stj4sSJJbb11FNPxeWXXx49e/aM22+/Pdq2bVtkm7y8vBg5cmR07NgxFi9eXK6YK6JOnToxatSoEv+4w/XXXx9XXXVVJUZVuVKRE4mQF6motm3bxtChQ4uUl+bet7LuewcMGBCXXnppiduMHz8+rrzyyhLvxSZOnBgPPPBAnHHGGXHsscfGtddeG61bt/65vkaNGvGPf/yj2PuS8sr0dda0adPik08+iXbt2hWp69+//8/3IOXRt2/fjW7Tp0+fjX7ukvTv3z9h+RNPPFHifpm2vqgs2X49lTYPdvfddxepS3UO7L777oujjz66SPnOO+8cu+22W7z//vsbbaO0TjnllGJjKI3qmk/M9PG4LLIpv1RVzrdU5Rmq63wUkfn3hNl4n51IRdb7EdnxDLI4mX6ObUwq85sVGZsra1zOxGswE3OCv1RV5txUqFWrVpx44okJ6+6///6N7v/UU0/F3/72t2jUqFGRuiFDhsRvf/vbioaYdTLxGi2rbFpTJ5Lt8WeCTF8rZOp1lunzYbKkIofwxRdfVHr+IBvuB6rrfXF1ydOme+1ZHc+v7t27x/XXX1/iNuPGjYtLLrkkZs6cWaRu6tSpERE/j/V9+vSJv/zlL9GmTZsNtrv55pvjyiuvTFLUxcuGcSwie66J9bJ9DCqvTF7HVKXnF6lSXK4s1e8BZqNsGTtToSpdS9XhOGbyuJxIRb5bVJnHI9vWJRVRXd93Wq8qjXkR6X3vvzyq45q6Ot5jJ1Om5nvLI5XXa0XzGr+UjtxGtszDmXY9b2xdmElrwlTyTLvq2mSTTYr8Yfz1vvrqq1K3s/322ycsnzVrVlbkdihepo3LxcmWeW5jsu3eoyStWrWKG2+8sUh5Jr03kk3r4Op0Lab7OgQAAAAAAAAAAAAAAAAAAAAAqAznnXdeNG3aNCIiXn311fjss8/SHBEAAABQlcg9AAAAAAAAAAAAAAAAAAAAAABUHW+++WbccMMNcdVVVxWp69WrV/zud7+Lu+66Kw2RJUetWrXi0EMPjUMPPTR22WWXaN++fTRu3DhycnJ+3mb16tXx9ddfx8cffxxvvvlmjB07Nj7//PNy9de0adPYbLPNiq3fZpttEpY3bNgwOnToUKa+Vq9enTDO7bffPmrUqFGkfM6cObFw4cIy9ZFI/fr1Y+utty5SPmPGjCgsLKxw+9tuu23UqVOnSPlnn30Wa9asKXe7O+20UxxxxBGx5557RseOHWOrrbba4Pf0448/xrRp0+Kjjz6Kl156KV566aVYuXJluftLJNExnjt3bixYsKDYfWrVqhUdO3aMNm3aRMOGDaN+/fobnL933nln0uMsq1q1akXr1q2LrV+yZEl8++23JbZR3Pk/ffr0MsVS1t9xkyZN4uijj47u3bvHbrvtFi1btoyaNWv+XL98+fL44YcfYsaMGfGvf/0rXnrppfj444/LFFNFNG/ePI466qjo1q1b7LbbbrHNNttsEN+6deti9uzZMW3atHjzzTfjmWeeiQ8//DBhW/n5+dGkSZMi5T/++GOsXbs2ZZ/h14xR/1OjRo048MADo2fPntGxY8fYcccdo1mzZpGXl/fzNoWFhfHTTz/Fjz/+GB9++GG89tprceedd1b4M5TGnnvuGT169Ig999wzdt1112jatGnUq1dvg21Wr14d//3vf+Pjjz+O999/P5599tl49913KyW+ZCjvMXjttdeKvc4yQabNNZW9FiuvXXfdNXr37h177LFH7LzzzrHVVltFrVq1fq4vLCyMxYsXx/Tp02PKlCkxfvz4eOmll2LdunWVEt/G1jGFhYWxcOHClK9lIsp+jqXq/Npqq62if//+sd9++8Uuu+wSrVq12mCOXLt2bcyaNevn38fYsWNj7ty5Ze4nW2222WY//+3QX9rYeFBWOTk50b59+yLlBQUF8cknn5SprbKeW40bN47+/fvHwQcfHLvssktst912G1y369ati++//z4++uijePfdd2PMmDHxwQcflCmmbHDooYfG5ZdfXqT81VdfjT/+8Y8p7fvwww9PWP7II4+ktN9kKOv4XdHxvmbNmvHkk09GgwYNitTdfvvt8cwzz1So/UyxsbF5zZo18e233/68rnryySdj9uzZCduqU6dObLvttkXKv/zyy6TPb/n5+dGjR48i5WvWrIlXXnklKX1k6++mojJpzV3V8gVVcS209dZbJ8xbrF27NiZMmJDSvl966aU46aSTNihr3759NGvWLH744YeN7p8ozxERsWjRoqTE92s//fRTmeIoSXnmuOo6LzZv3jwaNWpUpHzZsmXx9ddfp6TP/Pz82GGHHYqUl2e9/cs2yzPvVfbnT8VnT4XqmussTz4/E56fVVTjxo3jiCOOiF69ekXHjh2jdevWGxz/dK8PkqUyc8OVeV6U5nlTpuVWIzInL1jV1tMRVfMZHABAVZab7gAASI86DSLa7R/R9YSIg34XceDgiL0GRmyzS0RufrqjS70xY8YkLK9du3Z07969TG3l5ubGwQcfXKT83XffLTbJM2HChFi9enWR8l69epWp7/UOOuigDV7uWW/NmjXx3HPPlavN6qZz585Rv379Dcr+8pe/xK677lrs+fJry5Ytiz/84Q9xwAEHlJj8/OMf/xj5+dXgQkuCbDgueXl5MXz48A2SoL80ZcqU2G233eLuu+8udVJz3bp18Y9//CM6deoUb731VsJtOnfuHGeddVaZ461KNt100+jZs2fCumnTpsXixYsrOaLMNWHChLjtttuKrR82bFjcf//9sfPOOyesf/311+PGG29MVXiV7uabb97g5zVr1sRvf/vbOOigg2LSpEmlbmf8+PGx6667xlVXXVXsQ+a6deum/cujf/jDH6Jx48YJ62699dbYZ5994s033yxTm++880507dq1xJchLrvssjK1yf9e7kn0AmPE/17quOyyy2K33XaLl156qVTtFRYWxmOPPRZt27aNv/71r8Vu16lTp7jmmmvKFXNxdtlllzj++OOLlP/73/+Ozp07/3ztjBs3LiZPnhxffvllfPPNNz//+/HHHyvU/5/+9KcNXqb88ccfo3v37nHxxReX6sWziRMnxt577x1TpkwpdpuLLroozjvvvGjRosUG5a+99lp07NgxRowYsdEXUAoKCuKuu+6K7t27Fztv1alTJ0477bSNxpxqF1xwQcLyZcuWxYEHHhi33HJLwnucknz66afRv3//GDx4cMIX5zbZZJP4v//7v3LFmw7ZON4OGzas2JjXz49dunSJiRMnlrrNF154ITp16hSjRo1KWN+yZcu0zBGNGjWKl19+OQ477LCE9QUFBXH22Wcn/IMQVU0ycyIR8iLJMHTo0CIvS5bl3jfV97316tWLv/3tb8XWL126NPr37x+HH354qb+oUFBQECNHjoydd945HnjggQ3q2rVrF82aNStznCXJhnXWk08+mbD8kEMOSXh+l1bv3r03uk2fPn3K3X69evXiwAMPLFJeWFgYo0ePLnHf6ri+yPbrqSx5sNJIdg7s5Zdfjq+++iph3SmnnFKqNkqjS5cu0aZNmyLlP/30U7FroF+qzvnEbBiPSytb8ktV5XxLZZ6hOs5H62X6PWE23mcnUtH1fkT2PoPM9HOsJKkcd5I9NqdqXK4q12BlqSpzbqocffTRCc+nb7/9Nv71r39tdP+VK1fGyJEjE9Ydd9xxRd4pqA6qwjWaLWvq4mR7/Jkg09cKVeE6y2apyCGkI3+QDfcD1fG+uDrladO99qxu51etWrXigQce2OB9lV9avnx5HHHEEdG3b9+YOXNmqdocN25cdOjQocg526BBg0qZM7JhHMumayIi+8egqqoqPb9IhUS5ssp6DzAbZcPYmSpV6VqqzscxU1X0u0WVcTyybV2SDNXxfaf1qtKYl+73/suquq6pq9s9drJVlXxvKq/XVOQ1Iiovt5FN87DrOTN5pl11HXzwwcX+Ufmy/E8bi1v7fffdd+WKi8yRDeNyNs1zJcm2e4+N2XXXXWOTTTb5+edMfG8km9bB1fFazPS8DwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVIY//OEP8e677yasu+WWW6J9+/aVHFHFbb311nH33XfH/Pnz4+mnn46zzjorunbtGk2aNImcnJwNtq1Zs2Zsv/320b9///jzn/8cn332WUyePDn69etX5n7POuusmDZtWrH/brvttoT7HXzwwSXul+jf8OHDE7Z18803J9z+z3/+c5k/TyIXXHBBwvb33nvvCredn58f77//fpG2J02aFIWFhWVur0aNGnH66afHJ598ElOnTo3rrrsu+vbtG61atYoaNWpssG2TJk1i3333jd/97nfx9NNPx/z58+Pee++NbbfdtsKfa71Ev7fTTjutyHa5ublxzDHHxMsvvxxLly6NyZMnx8iRI+Oee+6Jm2++OW666aaf/22yySZJi688GjZsGBMmTCj2PH3++edLFWNx+5dVaX/HzZs3j2HDhsX3338f9957bwwcODC23377qFmz5gbbbbLJJtGyZcvo2bNn3HrrrTF16tSYOHFiHHDAAWWOrSz23HPPePHFF+O7776LO+64I44++uho06ZNkfjy8vJi6623jp49e8a1114bH3zwQbz77rvRt2/fIm126dIl5s6dW+Rfp06dUvpZfq26j1FbbLFF3HLLLTF//vx48cUX44ILLogePXrEFltsEXl5eRtsm5OTE40bN47WrVvHgAED4o477ojJkydH//79i8xlyVCjRo0455xzYtq0afHOO+/E0KFDo1+/ftGqVauoV69eke1r1qwZ2267bfTp0yeuvvrqmDx5cnz77bdxySWXRIMGDZIeX7JU9Bh88MEHKT0OFZUpc0261mJlsckmm8R5550XX375Zbz//vvxpz/9KY444ojYbrvtolatWhtsm5OTEw0bNox99tknzj777Bg/fnzMmTMnrrzyyqhTp05K4ivLOiYnJ6dS1jIRpTvHUnl+7bvvvvHSSy/Ft99+G3/961/j6KOPjh122KHIHJmfnx9t2rSJAQMGxL333hvfffddPPjgg9GqVauK/gqyQnHzYaLxoCLq1KmTsJ/i7i9LUtp4W7RoEX//+99j7ty58cADD8Sxxx4b7du3L3Ld5uXlxVZbbRW9evWKq6++Ot5///2YMWNG/OY3v4nc3Nxyf+ZM0rx58xgxYkSRcXXu3Llx3HHHleseqiy6deuWsHz8+PEp7Tcb3XrrrQnX3e+++25ccsklaYgouUo7NteoUSO222676N+/f9x+++3x3XffxVNPPZUw79S5c+eE40LHjh2THv8+++wT9evXL1L+5ptvxtKlSyvUdrb/bsorE9fcVSVfUJXXQi1atEhY/v3338eyZctS2vdnn32WsHyXXXYp1f6rV69OWP7r9Umy1K5du0xxZJpsnRd79eqVcCz54IMPUnas+/Xrl7DPv/zlL+Vus7zzXkmfPxVS8dlTobrmOsuTz8+E52fltdlmm8Wdd94Zc+bMiQcffDAGDhwY7dq1K5KfSdf6IBnSlRuuzPOiNDIlt5qJecGqsp6OqNrP4AAAqrKq8XQPgFJrsnVE3ysjzn4sou8VEV1PiOjUJ6LzgIj9T4049qaIcx6P6PqbiJrpfY86pZ5++uliE7a9e/cuU1v77LNPNGrUqEj5c889V+w+y5Yti0mTJhUpb9myZbRt27ZM/UdE9OnTJ2H5v//971i0aFGZ2yPi/PPPj4suuijWrFlT5n3ffffdOOSQQ4rdt0WLFil/ibOqysTjcs4550SHDh0S1r311lvRrVu3mD17dpnbjfjfy2rdu3ePjz76KGH9ddddl/BhQ3Vx5513Fvui8bhx4yo5msx3+eWXx4cffpiwbtNNN40TTzwxYd2iRYvihBNOSPlLk5Vp8803//m/16xZE3369Ilhw4aVu73rr78+jjrqqFi7dm3C+oMOOiht435OTk5sueWWCetuvfXWuPjii6OgoKBcbS9dujSOPvro+P777xPW9+3bN7bffvtytV0dde/ePX7zm98krFu5cmX0798/br755nK1vWbNmjj33HPjzDPPLPZavuSSS2KnnXYqV/uJnHPOORu8oLh27doYMmRIHHjggfHee+8lrZ/i7L777j//9+LFi6NHjx4xceLEMrWxZMmS6NWrV/z0008J6/fcc8+45pprNiibOHFi9OzZM+bPn1+mvqZMmRInnXRSsfVnnXVWWl/Sb9q0aeyzzz4J6y6++OJ4++23K9T+/fffH2eddVaR8u+//z4+//zzCrVdWbJxvP3Nb35T7IsEixcvjoMPPrjc8+Py5cvjmGOOidGjRyesP+ecc6Ju3brlars8mjdvHpMmTYouXbokrF+9enUcd9xxcdddd1VaTOmUzJxIhLxIMuyxxx4b/Fzee99U3ff+/ve/L3aMmzt3bnTp0iXGjh1b5nYjIlasWBGnn3560l4MTSRb1llPPvlkwvK6devGQQcdVK74WrVqFTvuuONGt2vZsmWxuY2N6dWrV5GXwyL+9/J0SfmQ6rq+yPbrKVV5sGTmwIpbvwwaNKjIS6LldcoppyQsHzFiRKxcuXKj+1fXfGK2jMellS35papyvqUqz1Bd56OIzL8nzMb77OIka70fkV3PIDP9HNuYVOY3s2FNVZWuwcpSVebcVBkyZEjC8gcffLDUzyCLGzPq1q0bxx9/fLljy0ZV5RrNljV1cbI9/nTL9LVCVbnOslWqcgjpyB9k+v1Adb0vlqctXjLXntXx/LrkkkuK/eNTixYtioMPPjieeeaZMre7Zs2aOOecc2Lo0KEblG+99dblCbNMMn0ci8iea2K9bB+DqqKq9vwiFX6dK6vM9wCzUTaMnalQ1a6l6nocs0mmvV8VkX3rkmSobu87rVfVxrx0v/dfVtVxTV0d77GTqSrle1N5vaYqrxFRObmNbJmHXc+ZyzPtqmvQoEHF1pXlu4bF/SHguXPnljkmMke2jMvZMs9tTLbde5RFJr43kk3r4Op+LWZq3gcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACrDunXrYtCgQbFs2bIidbVr145HH300atSokYbIyq5GjRpx/fXXxxdffBFnnnlm1KtXr1ztdO7cOcaMGROvv/56bLfddkmOMjmmTZuWsPyJJ55IWN6nT5/IycmpcL99+/Yttv2K2n///aNhw4ZFyseOHRtr164tU1uHHHJIfPbZZ3H//fdH27ZtyxxL3bp144wzzojPPvss/vKXv0Tt2rXL3EZ5tGvXLt5+++147LHHokePHpGfn18p/ZbHlltuGa+//np07do1Yf3HH38c++yzT8ycObOSIyvZoEGD4tNPP43TTjutXGPbvvvuG6+++mqMGjUq6tatm9TY6tevHyNGjIh33nknDjnkkHJds3vssUc8/fTT8dRTT0WTJk2SGl8yVNcxKicnJy6++OL46quv4qKLLooGDRqUK4bOnTvH6NGj44033ogtt9yyXG0k0rVr1/jggw/izjvvjA4dOpS7nRYtWsTNN98cs2bNipNOOilp8SVDso5BROqOQ2VJ5VyTLWux4447LmbNmhW33357bLvttuVqo1mzZnH99dfHZ599Ft27d09qfBVdx0Skby0TESk5v5o1axajR4+OiRMnxsEHH1zmOSM/Pz9OPvnk+Pjjj+Oss85KSkxUvpNPPjlmzJgRgwcPLtc6rl27dvGPf/wjPvjgg+jYsWMKIqw8ubm58fjjj0fTpk03KC8oKIhBgwbF3LlzU9p/nTp1Ev4Ov/vuu/jiiy9S2ncy5Obmlmn7vLy8cvc1YMCAOPvss4uUL1q0KAYOHFjme91MUtGxOScnJwYMGBAfffRRXHnllUm5HyiPXr16JSx//vnny91mVfndlFW2r7kzOV9QHdZCie63IyLmzZuX8r6L62PHHXcs1f4LFy5MWJ6qc7e4dn/88ccyt1XWOTGi+s6Ljz32WCxdurRIeaNGjYrNR1XUCSeckLB8+PDh5W6zvPNeSZ8/FVLx2VOhuuY6M11xz8/Ko3///jF9+vQ455xzolatWmXeP5Xrg2SpDrnhZEr1c7xszgtm8no6ono8gwMAqMrKnsUCIGvtdHDEyXdFtNsvIqeEGaBW3Yiux0ec9LeITbepvPgq0/fffx/vvPNOwrrDDz+8TG0ddthhCcvHjx9f4n7F1Rf3wKEkxcU8ZsyYMrdFxG233RZ33HFHhdr4z3/+E0OHDi22/vjjj69Q+9VRJh6X/Pz8uOyyyxLWzZ07N4466qhYuXJlmdr8tZUrV8aAAQOKfaB48sknV6j9bHXeeefFoEGDEtatXbs27r777kqOKPOtWbMmjjvuuFixYkWZ9hsyZEh88803KYoq/S644IJ48cUXK9zO6NGj4/LLLy+2/tJLL61wH+VRWFgYRxxxRHTq1CnGjBkThYWFERHx1ltvJSWmH3/8sdh2cnJyyrWuqa6uu+66YuvOPvvseOaZZyrcx7333hs33HBDwrr8/Py45pprKtzHegcddNDP/71q1aro3bt3/P3vf09a+2Vx+umnxwcffFCufX/44Ye49tpri63/5QPj77//Po4++uhyz/1jx46NV199NWHdNttsE3vttVe52k2GXXfdNeFD4EWLFsWDDz6YlD7uu+++GDt2bERETJ8+PU499dRo2bJl3HLLLUlpP9WybbzNycmJq6++utj6U089NV577bUytflrBQUFceKJJ8ann376c9maNWvioYceij333DPhH11IhR122CHefPPNYl9aXbJkSfTq1avYl9WqomTmRCLkRZKtove+yb7vrVevXpx55pkJ69atWxcDBw6MqVOnlqnNRC699NKkrHcSyZZ11tSpU4v9oxH9+vUrV1yJXogt7v6ud+/e5eqjf//+CcuffPLJEverjuuLbL+eUp0HS1YObPjw4Qlf1t50002T8pJ47dq1Y+DAgQnr7rvvvo3uX53zidkyHpdHpuaXqtL5lqo8Q3WcjyKy454w2+6zSysTn3WlQjacYxuTqnEnW9ZUVfUaTJWqNOemQocOHRL+EcXCwsIyfaH1/fffLzbXX9y9VlVVFa/RTF1Tl1a2x1/ZsmGtUBWvs2yS6hxCuvIHmXg/UB3vi+VpNy5Za8/qdn7VqVMnLrroomLrTzzxxHjzzTcr1Mf//d//pfX5ZyaOY9l0TURk/xhUVVXl5xfJ8utcWbreA8xGmTh2pkpVvpaq03HMFpn2flVE9q1LkqW6ve+0XlUb8zLpvf+Nqa5r6up2j51sVSnfm6rrtTLyGhGpy21k0zzses5MnmlXXd26dSv2nd85c+bEu+++W+q2ivsDrosXLy5XbGSGbBiXs2me25hsuvcoq0x8bySb1sGuxczM+wAAAAAAAAAAAAAAAAAAAAAAAMD/Y++u46M4/v+Bv+KOJrgT3N2lkIYkJFiLBIe2FCtavLSFIqWFltICHzQ4JFAkgQDBXVrcvUhxjRCSkOT3R3/ky7G7ycnu3e7d6/l48GjvPbczc7md2dnZvVkiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiLST7Y8QCV/oH5noElvoFY7oFgNwMHJ0jXTjuvXr2PIkCGiaVWqVMHkyZPNWyEjFCpUCMePH8fYsWPh5CTPl9+wYUOcPXsWLVu2lCU/OV24cEE0HhUVhTdv3gjiefLkQd26dU0qM1++fKhevbpoWnBwsEl5A0Dbtm1F4xEREXrnYW9vj9mzZ2P79u0oWrSoyXVycHDA0KFDcfbsWZQtW9bk/DJTp04dHDlyBLVq1VK0HDmUKlUKR44cQaVKlUTTDxw4gIYNG+L+/ftmrlnmJk2ahJUrV8LDw8PkvD755BMcPXoUxYoVM71iAMqXL48zZ86gS5cusuTXrl07HDp0CPnz55clP7nYYh+VLVs27N69Gz///DNcXV1NrgcA1KtXDydPnkSdOnVMzqtHjx7Yt28fypcvL0PN/pMzZ04sWbIE69evh4uLi2z5GkuJ7wCQ93swFyWPNVoYi7m5uWHdunVYtWoVfHx8ZMmzYMGC2LFjB0aOHGlyXnKPYwDzjmWA//Yxufev2rVr4/z585L9sCE8PDwwe/ZszJ8/H/b29jLUjsxl5syZCAsLg6enp8l5VapUCX/99Rd69uxpesUsZNKkSWjYsKEg/sMPP2D37t2Kl1+6dGk4ODgI4idOnFC8bEPFx8cLYm5ubgblIXb+EBcXl+V2xYsXx+LFi0XTevfujX/++cegeqiJnH2zo6MjJk+ejI0bN8LZ2VmG2hkmICBANL59+3aj8rOmv40htD7mVvN8ga2Mhdzd3UXj+vS3poqNjRWNFyxYUK/tL1++LBo3dZ5DilR7uHTpUqbbyXFMBGz3uJiQkIDVq1eLpikxrsyRIwcCAwMF8efPnyMyMtLofI097mX2+eWm1GdXgi3OdWqB1PUzQ40cORLr169H7ty5Tc5L7vGBXGxhblhOSs6tan1eUM3jacB2rsERERERWTN1zWYSEZFiqgYDQcMBRwOujeYsAHSZ8d9/rdH69etF44ULF5a8iVuM2AWCx48fZ3mjx9atW0XjYhP5malWrZroZEp6errqJv+14MKFC7LcsAgA06ZNk7xg2rx5c9EbhEicWr+XTz/9FPny5RNNGzZsmGw/+Lhx4wYWLFggmta/f39ZytAKNzc3zJw5EzNnzpR8z4oVK/Dvv/+ar1IacunSJYwYMULv969YsQJr1qxRsEaWdeDAAcyePVu2/GbMmIHo6GjRtHr16qFGjRqylWWoU6dOoV27dqhUqRLWrFmDr776CmlpabLkHR4ejmfPnommNW7cWJYyrF29evVQr1490bQVK1Zg0aJFspU1fvx47N27VzStXbt2KFmypCzl2NnZZfz/8OHDjb5p1FQbN27E2rVrTcpj/vz5SExMzPJ9Q4cOxePHj00q69dff5VMs+SPqwoUED8pvHDhApKSkmQrZ/jw4QgKCkKFChUQFhaG5ORk2fI2F630t8HBwfD19RVN+9///oc///zT4PqJSUhIQP/+/ZGQkIBff/0VxYsXR69evSRvDJVbjRo1cOjQIcmbRR4/fowmTZqY5UciaiPXnAjAeRE5yXXuK+d5b/fu3eHl5SWaNnHiROzfv9+oOor5/PPP8erVK9nyA7Q3zlq3bp1oPCQkRGd8pa+QkBBBbN68eaI3goq9NyuOjo4ICgoSxNPT07M8ltji+ELr7ckc82ByzIE9fPgQW7ZsEU3r1auX0XV7p23btsiWLZsgfuzYMZw7dy7L7W11PlFr/bEh1Dy/ZE37m1LzDLZ4PAK0dU6olfNsfaj1WpcStLSPSVGq39HKmOoda2qDSrKmY64S+vbtKxrftWsXbt++bVBeCxcuFI1XrlxZUwuUycVa2qiax9T60Hr9LUFLYwVraWdaYq45BHPPH6j1fMAWz4s5T6sfOcaetrZ/denSBTly5BBNCwsLk+265ZdffomnT5/Kkpch1NqPaalNANrvg6yRNV+/kNOHc2WkH7X2nUqw5rZkS9+jVqjx/ipAe+MSOdnS/U6AdfZ5arnvXx+2Oqa2tXNspVjDfK9S7dVc8xqAMnMbWjoOsz2rE69pW6d8+fJJLtQOAMuWLTPoOCC1EKycbZfMTwv9spaOc1nR0rmHIdR+34gWxsFsi/9R47wPEREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREREUkrWB4InQ70XQYEDgMadgfqdAA+6gN0mAx8FQE07gU4u1u6ptqwcOFCbNq0STTt66+/xkcffWTmGumvVKlSOHz4MKpWrarX+9++fYvExES93uvh4YGNGzeiY8eOJtRQfhcuXBCNx8fHY/v27aJpbdq0ManM4OBg2NnZiaZVqlQJRYoUMSn/Vq1aCWIvX77Erl279Nre1dUVmzZtQv/+/U2qh5h3+1iDBg1kzxsASpQogW3btiFHjhyK5C+nGjVq4NChQyhatKho+qZNm/Dxxx/j1atXZq5Z5saNG4dx48bJmmfFihURExMDLy8vk/KpUqUK9u3bh+LFi8tUs/+ULVsWu3btgoeHh6z5msLW+qicOXNi7969aNq0qV5lpKWlISEhAW/fvs3yvfny5cPmzZtRuHBhvfIW06tXL4SFhcHBwUGv9ycmJuL169dIT0/X6/1t27bF9u3b4eLiYnQdTaXkdwDI8z2Yi5LHGi2MxXLlyoW9e/fik08+MSkfMfb29pg2bZpJxxklxzGA8mMZ4P/2MTk1adIEu3btQp48eWTN94svvsC8efNkzZOUM3PmTAwePFjWPJ2dnbF48WIMGjRI1nzNoUWLFhg9erQgvmfPHkyYMMEsdShTpoxo/OLFi2Yp3xDPnj0TxKTGjFLEjp1i+b7PyckJERERyJ49uyDtjz/+wPr16w2qg5oo1Te3atUKGzduhL29vaz5ZiZPnjyi45dHjx7h9OnTBudnTX8bQ2h9zK3m+QJbGgtJnWc6OjoqXrZUGfny5dNr+8OHD4vGg4KCRI8DpsiWLRsCAwNF044cOZLptlLHREPraMvHxfnz54vGW7Rooff+oq/27dvD2dlZEF+1ahWSk5ONytPU457U59fCZ1eKrc11aoXU9TNDDBgwANOmTZOhNv9HrvGBXGxhblhOSs6tan1eUM3jacC2rsERERERWTPlZwmJiMjiCpYH/PoZt62rF9BuAhDWD0jT7xqkZmzcuBE//fSTaFrLli1x7ty5LPPIkycPqlWrJojrc6PXxYsXcefOHcGkdJMmTeDm5qb3TYDBwcGi8b///hv//vuvXnnQ/xk8eLDeF9yzkpiYiFWrVqFv376CNC8vL5QtW1aWiXdboNbvpWfPnqLxGzduYM2aNaZUU+DXX3/FoEGDBBcfypUrJ2s5apUjRw6EhoZi/PjxyJ8/v+T7Hj58iGHDhpmxZtoze/ZsBAUFISgoKNP3/fPPP4pdYFGLESNGyJ7nhAkTJP+2nTp1wokTJ2Qv0xAXLlxAaGiorHkmJycjKipKtE9s1KiRrGVZqz59+ojG3759i7Fjx8paVlpaGkaPHo2jR48K0uzt7dG7d29ZL1Bu2bIFs2fPli0/Q6Snp2PUqFEm55OQkICtW7eiXbt2ku85e/asLMf+7du3IzY2FtmyZROk1atXDzNnzjS5DGO4urqKxl++fClrOTdv3sTNmzdlzdNS1N7f9urVS7KM7777zpjqSdq1axfy58+PuLg4WfPNip+fHzZs2ABPT0/R9Js3b+Ljjz+2mn3OUHLMiQCcF5GbXOe+cp73durUSTQeFxeHX3/91aR6fujJkyeYOnUqfvzxR9ny1No4KyIiQvQ9efPmRZ06dUTzluLp6YkmTZoI4lFRUfDy8kKFChV04vXq1UOuXLnw/Plzvcto0qSJ6A3sx44dw7179zLd1hbHF1pvT+aaB8tsDqxkyZK4ceNGlnnMnz8frVu3FsQDAwORN29ePHr0yOj6SY2jpH4M8CG1zCfq+7eUi9b6Y0OoeX7JGvc3uecZbPF4BGjznFDt59n6UOu1LiVocR+TIne/o6Ux1fusoQ0qyRqPuXJxdXVFt27dRNMWLlxocH4rV67E9OnTRY/hffv2xbFjxwzO0xpovY2qeUytD63X3xK0OFbQejvTEnPNIZh7/kCt5wO2eF7MeVr9mTr2tLX9q0ePHqLx5ORkWe5deefJkyeYPn26rPuVPtTaj2mpTQDa74OskTVfv1CCJe8F1CK19p1KsOa2ZEvfo1ao8f4qQHvjEjnZ0v1OgHX3eVo41tvqmNrWzrGVZg3zvXK3V3PNawDKzG1o6TjM9qw+vKZtnUqUKIHt27fD19dXND0hIQEzZswwKE93d/En9KakpBhcP1IPLfTLWjrO6UsL5x6G0Mp9I2oeB7Mt/h+1zfsQEREREREREREREREREREREREREREREREREREREREprVixYli+fLlk+t69ezF+/HiTyylQoADCw8Ml0xMTE+Hv729yOfSfrL5XAPjmm2+wb98+M9WIiIiU5unpicaNG6Nq1aooU6YM8uTJgxw5cmSkjxs3DkFBQbhx4waOHj2KkydPIjU1VbH6VKtWDbVr10bFihVRoEABeHl5wc3NDSkpKYiPj8edO3dw4cIF7Nu3DxcvXlSsHgBQqVIlNGrUCBUqVEDhwoXh6ekJJycnJCYmIi4uDv/88w/OnTuHPXv24Pbt24rWRUnZsmXTef3mzRskJyfLlr+avlM11YXI1tnb28PT01Ox/GNjY03Ow87ODnXr1kW9evVQsWJF5MmTB56enrC3t8fr16/x5MkTXLt2DcePH8f+/fvx+vVrGWr+nxIlSqBVq1aoWbMm8ubNCwcHBzx58gSXLl1CVFSUIs9DdHV1hbOzs04sMTGR63cSkSglx5Af5i0lOTkZb968kaXMd9j/EinD1ucetDD2zYy7uzscHR0VLQP471k/8fHxRm/v4uKC6tWro3bt2qhQoQJy5syJHDlywNXVFYmJiXj58iVevHiBs2fP4vjx4zh9+rQifW316tVRq1YtlC9fHoUKFYKnpyfc3NyQmpqK+Ph4PHjwAFeuXMGhQ4fw119/KbqvE5F2+mBLzVuae/zLsS8RqWmsVKZMGTRu3BiVKlVCkSJF4OXlBWdnZyQlJSE2Nha3b9/G2bNnsW/fPlmfJ8a5ByIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIvVp0A2o3xmws5N+j7MbULcjUK4p8Od3wNN/zFU77frss89Qp04d5MuXTyduZ2eHZcuWoVKlSnj58qVlKichV65ciImJQeHChSXfc/bsWYSHhyMmJgY3btzAixcvAADOzs7w9vZGzZo14e/vjy5duuiss/OOo6Mjli5din/++QfHjh2TLOfevXs4evSoZHru3LlRqlQpQfz58+e4evVqJp9S6Pz585Jp4eHhaN26tSDepk0bjBo1yqBy3teqVatM01u2bIm5c+calXe1atVEv8NNmzbp/Rvb5cuXIzg4WDI9LS0NR44cQVRUFP766y88fPgQz58/h7u7Oxo0aICgoCAEBASI7gMAkDNnTmzZsgX16tXDpUuX9KqTPhwcHLB+/XrJctWkefPm2Lhxo+TaIAsWLEDfvn2RlpZm5pplzs/PDxMnThTE09PTsX//fmzcuBF///03/v33X7x+/RrZsmWDj48PqlWrhqCgILRo0QIODg6ieZcqVQpLly5Fu3btjKpbvnz5sG3bNnh7e0u+582bN9i9ezeioqJw6dIlPHr0CC9evICHhwfy5s2LokWLIjAwEC1btkTu3Ll1ti1Xrhzmzp2LhQsXGlU/JdhSH7Vy5UpUq1ZNMv3AgQNYt24dDh06hKtXryIuLi4jzcvLC8WLF0fTpk3RvXt31KhRQ7C9t7c3/vzzTzRo0MDg9QhKlCiBP/74A3YSg6n79+9j1apV2L59O86fP4/Hjx/rtO1cuXKhdOnSaNiwIT755BPUrVtXNJ8mTZpg1qxZ+PLLLw2qn1yU/g4A074Hc1HyWKOmsZgUZ2dnREVFoXbt2pLvSU1NxaFDhxAdHY2///4bjx49wrNnz2BnZ4fs2bOjVKlSaNy4MUJDQ1GgQAHRPCZNmoTr169n+rwmKaaMY/LmzQtfX1+LjWUAZfaxkiVLZjruAICkpCTs3r0b0dHROHv2LB49eoSXL1/CxcUFuXPnRqVKleDn54fWrVsL1s79/PPPcebMGdnqS8ro3r07Bg8eLIgnJydj+/bt2Lp1K06fPo2HDx/i9evXGeOjUqVKISAgAIGBgZL7pZ2dHWbOnImbN29i8+bNCn8SeRQoUAArVqwQHL8fPXqE0NBQpKenm6UeRYoUEY1nte6Tvb09atasiUqVKqFMmTLIlStXxjME4uPjERsbm/E8mb///huvXr0yua6PHz82OY/SpUsLYk+ePMl0m+nTp6NmzZqC+MmTJzF8+HCT62Qp+vTNycnJ2L17N7Zs2WJw3xwYGIipU6diy5YtSn8UAIC/v7/oeHj79u0G52VtfxtDaHnMreb5AgA2NRaSWuM6s/kSufj4+IjG3d3d9dp+165dePbsmWBOxt3dHVOnTkX//v1NruM7kydPhoeHhyD+9OlT7N69O9NtpY6Jvr6+Bq2naMvHxb///htnzpxBlSpVdOIODg7o0qULZsyYIVtZXbt2FY0vXrzY6DxNPe5JfX4tfHYl2dJcpynUcv1MH3Xr1sVvv/0miKtlfCAHtcwNm3O/MIXS1/G0PC+o9vG0LV6DIyIiIrJWyj+Jj4iILO6jLwB78XkCveQuDFQNAk5GylcnNbh27RouXryI8uXLC9JCQkLw448/ZplHQECA6GRgdHS0XnXYtm0b+vTpoxNzcXHBRx99pHceISEhovENGzbotT39n9OnT2PXrl2y5hkZGYm+ffuKplWqVAkXLlyQtTxrpNbvxcXFBY0bNxZNmz17tuw/+rh79y7Onj2b6U0k1sDFxQWenp7w9vZGuXLlUL58eTRp0gQfffQRnJycMt02JSUF3bt3z7iRmqQNGTIEQUFBmb5n/PjxOjciWZuTJ08adeN8Vo4fP47Dhw+jfv36grQWLVpgxIgRspepBsePH0fPnj0F8Tx58sDNzQ2JiYnmr5RG2NnZSbbHtWvX4u7du7KXeezYMRw6dAgNGjQQpAUHB2PcuHGylTVhwgTZ8jLUzp07Zbv4vXv37kwvrs6ZM0eWcpKTk3HkyBG0aNFCkFa1alVZyjDGmzdvROO5cuUyc01Ijv7W0dERfn5+ommrVq2S5QcCHzL3mKJDhw5Yvny54KHV75w6dQoBAQGKfFatkGNOBOC8iJzkPveV47zXy8sL9erVE01btGiRIm17/vz5+P777+Hq6mpyXlocZ509exZXr14VvaG8bdu2md4Q+KEWLVoI+sHbt2/j3Llz2LRpE0aPHq2T5uDggMDAQKxcuVLvMtq2bSsaj4iIyHJbWxtfaL09mXMeLLM5sICAAMyePTvLPLZt24Z79+6hUKFCOnEHBwd07drV6JvzCxYsiObNmwvicXFxev3wXU3zifr+LeWgxf5YX2qeX7LW/U3ueQZbOx4BtnFOaAhzzWuq9VqXEqxtH5Oz39HamMocrOHagrUec+XSoUMH0R9jPX/+3Ki5m5cvX2L9+vXo3LmzIK1jx44YMmSILIuo0H/M0UbVPKbWh9brbwnWNlYwlTUcC+Vk7jkEc80fqPl8wNbOizlPaxhTx562tH95eXlJLggRHh6e5aJBhlq0aBEmTpwoeT1cbmrtx7TWJrTeB1kja75+oRRL3guoNWrtO5VgzW3Jlr5HrVDj/VWA9sYlcrOl+52suc8D1H+st+UxtS2dY2uZOed75Wyv5p7XAOSd29DacZjtWX14Tdu6uLq6YsSIERgzZgzc3Nwk3/ftt9/K1r+Z68E1pAy198taO87pS+3nHobgfSPyjIPZFv+P2uZ9iIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIlObu7o6GDRtKpjds2BCHDh3Ctm3bTCrH1dU103Li4+NNyp90ZfW9AkDu3LnNVBsiIlJSSEgI+vXrBz8/Pzg5OUm+r3HjxjrruLx69Qrh4eGYO3cuTp8+LUtdcuXKhWHDhqF79+4oXLiw3ttdvnwZc+bMwbx585CcnCxLXdzc3NC/f3/07dsXvr6+em938uRJ/Pzzz4iIiJB9nSkljR07FpMnT9aJjRs3DlOmTDEpXzV9p2qqCxH9nyZNmmD37t2K5W9nZ2f0tvnz58eQIUPQu3dveHt767XN69evsX79ekybNg3nz583umwfHx/8/PPP6NatG+zt7UXf891332HPnj346quvZHtGQu7cuXH69GkUKlQoI/bgwQNUqVJFkXWOiUjblBpDAkCxYsVw69Ytvd67cOFCfPHFFyaXCbD/JVIK5x7+o+axrz62bNmCpk2bKloGAFy/fh2lSpUyeLty5cphwIAB6Nq1K7Jnz673ds+ePcPSpUsxe/Zs3Lx50+By31e8eHEMHjwYoaGhyJMnj97bPXnyBEuXLlXVutVE1kbNfbAlj02WGP9y7Etku0wdK02fPh2PHj2SpS7Ozs747LPPMGDAAFSoUEHv7U6ePIk//vgDy5YtQ2pqqlFlc+6BiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIhInfwGANVD9H9/9rxA11+AFcOAp/8oVi2r8OzZM/Ts2RNbt24V/D6/UKFCmDdvHjp27Gih2okLDw9HsWLFRNPu3r2LYcOGYd26daLpycnJuH//PiIjIxEZGYmxY8di1KhRGD16tOD3pS4uLli3bh3Kli2LhIQE0fwWL16MxYsXS9a1Xbt2+PPPPwXx3bt3o3379pLbGSoqKgpv3ryBq6urTrx06dIoU6YMrly5YnCeLi4uaN68eabvCQkJwdy5cw3OGwDatm0rGl+7dq1e248fPx6ffvqpZPq2bdswcuRInDt3TjT95s2bWL58OTw8PDBs2DCMHDkSnp6egvdlz54dW7ZsQdWqVREbG6tX3bIycOBAVKlSRRB/8eIFNm3ahM2bN+PcuXN49OgRXr16JUuZxmjfvj1WrFgBZ2dn0fQffvgB3377rZlrlTVXV1csXLhQ0Ka3bNmCUaNGif5O/NGjR7h27RoOHz6M2bNno3z58pg1a5ZkG2jbti3at2+v9/76jp2dHdauXYt8+fKJpqelpWHRokUYN26c5G/Nb968iSNHjmDNmjVwdnbG0KFD8c033+jsv926dTOq3SvFVvqor776CoGBgaJpJ0+eRL9+/XD8+HHJ7ePi4nD27FmcPXsWs2bNkjyG1KpVCz179sSCBQuy+BS6Zs6cCXd3d0E8LS0N3377LaZPn46kpCTJ7Z8/f46jR4/i6NGjmD59OurXr4+5c+eicuXKgvf26dMH69atw44dOwyqo6mU+A7CwsKQLVs2wXuN/R7MRcljjZrGYlLmzp2L+vXrS6avW7cO48aNw9WrV0XT79+/j0uXLiEyMhKjR4/GwIEDMWXKFLi5uQneO2/ePBw6dAj37t3Tu35yjGOOHDlisbEMIL6PmbJ/OTo6Yv369ciRI4doempqKhYvXowJEybg33//FX3PnTt3cOrUKSxbtgxeXl4YNGgQvvnmG53jz7Rp0/D8+XP9PiSZXb58+TB27FidWHp6OubOnYvJkyfj/v37otu9axPLli2Dh4cHhg4dihEjRoj233Z2dli5ciUqVKhgULu1BHt7e4SHhwvW4E9LS0Pnzp1lW/NJH3nz5hWNS30njRo1Qr9+/RAYGCjZrj/09u1b7N+/HytXrsSKFSuMXsPvyZMnuH37NooWLWrU9gBQo0YNQezo0aOS72/dujUGDRokiMfGxqJ9+/aafY5KVn1zWloalixZgu+//x53794VfY8+ffPXX39ttrW2pMaKhj6/0Rr/NvrS8phbzfMFwH/7lS2NhaTGplLHHDnlz59fNC423heTmpqKuXPn4ptvvhGk9e3bF3///Xemc8b66t69OwYMGCCaNnfu3CzXXJQ6JtasWRMnTpzQux62flxcsGAB/vjjD0G8Z8+emDFjhixlFCpUCI0aNRLEz5w5g1OnThmdrxzHPbHPr4XPriRbmes0lVqun+lj/vz5cHBw0ImpZXwgF7XMDWtlv1ByblXL84JqH0/b6jU4IiIiImsl/qQQIiKyGnlLAQXKmZ5P9Vam56FGGzduFI3XrVsXuXPnznL7oKAgQSw1NRUxMTF6lb9lyxbRuNSFhw/lyZMHNWvWFE2T+mwkbcWKFbLn+ffff0umGfKwTlum1u+lQYMGkhe+Db05Rl+HDh1SJF+l3Lx5E4mJiXr/S0lJwZs3b/D06VNcvnwZGzZswOTJk+Hv75/pQ+CB//reTp06mf2Geq36/vvvs3zP6NGj4eLionxlLGTNmjWK5R0eHi4ar1SpEnx8fBQr15LOnz8vmZYrVy4z1kR7atSoIflA27CwMMXKlcq7cuXKOg95NcVff/2Fv/76S5a8jBERESFbXpnt4wCwYcMGxcuyZFuSuuhbpUoVwU09pCw5+tv69evDy8tLNG3ZsmVG1UtN+vfvj9WrV0v+UHvPnj1o0qQJHj9+bOaaqY+pcyIA50XkJPe5rxznvY0aNYKjo6NomtSY11QvXrzQe//JilbHWVI/Fm7durVB9QgJEa4YFBkZCQA4duyYaD8otk1mWrUSnzQWuzHxQ7Y2vtB6ezL3PJjUHFj16tX12j4tLU3yBtrevXsbXa9u3boJbuoEgNWrV+v1w3w1zSfq+7eUg1b7Y32oeX7JGvc3JeYZbO14BFj/OaGhzDWvqdZrXUqwpn1M7n5Ha2Mqc7CGawvWeMyVU9++fUXjpixwsnDhQtG4m5sbunXrZlSeJM4cbVTNY2p9aL3+lmBNYwU5WMOxUE6WmEMwx/yBms8HbO28mPO0hjNl7GlL+1fTpk0l9y05FkT60NOnTyWvsypBrf2Y1tqE1vsga2TN1y+UYOl7AbVGrX2nEqy5LdnS96gVary/CtDeuEQJtnK/kzX3eVo41tvymNqWzrG1zFzzvXK3V3PPawDyzm1o7TjM9qw+vKatfd7e3ggICMDixYvx6NEjTJw4MdNF72NiYvDrr7+asYakZmrvl7V2nNOHFs49DMH7RuQZB7Mt6lLbvA8REREREREREREREREREREREREREREREREREREREZGlLV682CbX7s9KoUKFsGDBAsl/c+fOtXQViYjIitWoUQN///03IiMjERgYCCcnJ4O2z549O/r06YOTJ09i1apVyJs3r0n1+eKLL/DPP/9g3LhxBq/1XLZsWcyaNQuXL19GgwYNTKoHAAQGBuL69euYPn06fH19Ddq2evXqWL16NQ4dOoTixYubXBdzaNy4MSZOnCh7vmr6TtVUFyLS5enpaekqCNjb22PkyJG4fv06Ro4cCW9vb723dXd3R9euXXHmzBn88ccfRq3F5uvri6NHj6JHjx6wt7fP9L0fffQRjhw5gubNmxtcjpjly5frrJuempqK0NBQyfXmiMh2KTWGfKdUqVKK5S2F/S+R/Dj3oEuNY19r4OLigmnTpuHcuXMYMGAAsmfPbtD2uXPnxrBhw3Dp0iWMGzcODg4OBtfBzc0N06dPx7Vr1zB48GDJZyNJ8fHxwddff42hQ4caXDYR6UetfbAlj02WGv9y7Etke+QaK928eVOW8VLTpk1x+fJlzJkzBxUqVDBo2+rVq2Px4sU4e/YsatWqZXDZnHsgIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiJSp8oBQPUQw7dzdgc+mfDffylz27dvxx9//CGa1qFDB3Tr1s3MNZLWtWtX+Pn5iaYdOnQINWrUwLp16/TOLzY2FuPGjUPLli0RFxcnSC9UqBAmTJhgdH3NJT4+Htu3bxdNa926tVF5Nm/eHO7umTegZs2aZfkeKWL1io2NRUxMTJbbVqxYEePHjxdNe/v2Lb788ksEBgbi3LlzWeaVkJCAH374AVWqVMGlS5dE31O8eHH89NNPWealD3d3d3zzzTc6saSkJEybNg3FixdHr1698Oeff+Lq1at49eqVLGUao1+/flizZg2cnZ0FaWlpaRgwYAC+/fZbC9Qsa59//jmKFi2a8frdPhEcHIwLFy7olcfFixfh7++PsLAwyfeMHDnSqLo1bNhQNC0+Ph5+fn7o06eP3r81T05OxrRp01C5cmXcvHlTJ2306NEG108pttBHZcuWDd99951o2ooVK1C7dm0cP37coDqsX79esh8YMWIE7Ozs9M7Lx8cHgYGBommhoaGYPHkykpKSDKrf4cOHUatWLaxfv140Xck1McUo9R00aNBAtu/BXJQ81mhhLObn54fevXuLpiUmJqJ9+/Zo3749rl69qld+b9++xcyZM1G/fn3R/jl79uwG1VHOcQxg/rEMINzH5Ni/Bg8ejMqVK4umvXjxAv7+/ujTpw/+/fdfvfKLi4vD5MmTUa1aNdy6dUun7u+v80Lq0q9fP501K1+9eoXmzZtjwIABuH//vl55JCQkYNKkSahevbpkm8iWLRt+/fVXWeqspEmTJomOHX/44Qfs3r3brHXx8fERjT979kznda1atXD06FHs378foaGhyJEjh95lODo6olmzZli0aBH++ecf9O3b1+j6HjhwwOhtfX19Ub58eUH84MGDou8vWrQolixZIpr2+eefC8bpWpJZ3/zq1SsEBgbis88+w927d/XKT6pvtre3N9v55ccffyyIpaenY8eOHQblY41/G31ofcyt5vkC4L/9Soy1joWk+sccOXKgdOnSipZdr1490XhWaxC+b/r06aLnB3Z2dli4cCEmTJgAR0dHo+rn4OCAMWPGICwsTHT/f/LkCWbMmKFXXmLHxDZt2uhdFx4X/+vfEhMTBfGKFSuiWrVqspTRuXNn0e968eLFJuUrx3FP7PNr4bMryRbmOm1NpUqVMv5fbeMDOdjC3LCclJxb1fq8oNrH07Z6DY6IiIjIWuk/U0dERJpU0vDnSonKVQjIbtozdFVJauLN3t4eAQEBmW5rb28veoHg2LFjePHihV7l79q1C8nJyYK41ETjh4KCgkQn/69fvy45kUXSpC5KmOLJkyd49OiRaJqpD6a2FWr9XqpUqSIav3//vmLt7+zZs4rkqxQXFxe4urrq/c/YC/+PHj1CQECAZJ9Oujp37ozOnTtn+b4KFSrg559/NkONLGPPnj2K5X3kyBHJNLEbQ6xBZmOfnDlzmrEm2lO9enXReFpaWqb7kqmkbkgCpI9xhlq9erUs+RhLzhvAM/tBzMWLF/H48WPZyrpy5Ypo3JAbxeV2/fp10bibm5vkzZikDDn6W6k2npqaimPHjhlVL7WYMGECZs+eLXmD6tq1axEQECD6ozpbZMqcyLv3cV5EPnKf+8px3iv1sPvk5GScPHnS6LplZefOnbLko9VxVkREhGi8TJkyet/4b2dnh6CgIEE8MjISwH83OG/ZskWQHhAQAAcHB73KqFatGgoXLiyIHz9+HHfu3Mlye1sbX2i9PZl7HkxqDqxcuXJ657Fw4UKkpaUJ4uXLl0fNmjWNqlevXr1E4/Pnz9drezXNJxrytzSVVvtjfah5fska9zcl5hls7XgEWPc5oTHMNa+p1mtdSrCmfUzufkeLYyqlWcO1BWs85sqlYsWKkj8wX7hwodH57tmzR/LH06YsmkJC5mijah5T60Pr9bcEaxoryMEajoVyssQcgjnmD9R8PmBr58WcpzWcKWNPW9q/3l9A430pKSk4evSoImVm1n/JTa39mNbahNb7IGtkzdcvlGDpewG1Rq19pxKsuS3Z0veoFWq8vwrQ3rhECbZyv5M193laONbb8pjals6xtcxc871yt1dLzGsA8s1taO04zPasLrymbXkzZ85EWFiY3v+WLFmC1atXY8uWLTh48CD+/fdfPHnyBFu3bkWvXr2QLVu2TMs7efIkPv30U6Snp5vpE5Laqb1f1tpxTh9aOPcwBO8bkWcczLaoS23zPkRERERERERERERERERERERERERERERERERERERERJaWP39+zJs3z9LVUJ1cuXLh888/l/zXs2dPS1eRiIisVP/+/XH06FHUqFHD5Lzs7OwQGhqK06dPo1GjRkZtv3TpUsyfPx9eXl4m1aV48eLYt28funbtanQeo0ePxpYtW1CgQAGT6lK3bl0cP34cFStWNCkfpfn4+GDNmjV6rw+sDzV9p2qqCxGJ8/T0tHQVdGTPnh3btm3DtGnT4O7ubnQ+9vb2GDBgAI4cOYI8efLovZ2Hhweio6NRokSJjFh6ejoOHTqE+fPnY86cOdi+fTuSk5Mz0r28vLBp0yaUKlXK6PoCwIgRIxAYGKgTmzBhAvbt22dSvkRkfZQYQ37I1D7NUOx/ieTHuQchtY19rUG2bNlw4MABjBw50uTjkrOzMyZNmoSYmBi4urrqvV2+fPlw7NgxDB8+3OQ6/PLLLwgPD4ejo6NJ+RCRkNr6YEsfm0wZ/5qCY18i2yPnWMnd3d3k8dLgwYOxa9cuFC9e3KS6lC9fHgcPHkS3bt303oZzD0REREREREREREREREREREREREREREREREREROrk7A406W389tnzAnU7ylcfazZixAhcvHhRNG327NkoVqyYeSskwtXVFT/99JNo2pkzZ+Dn54cnT54Ylfe2bdvQvXt30bSvvvoKefPmNSpfc4qIiBCNt2nTxqj8QkJCsnyPi4sL/Pz8DM67WLFiqFy5siAeGRmJlJSULLf/3//+BycnJ0E8JSUFQUFBmD9/vsF1unnzJurUqYOjR4+Kpvfp0we1a9c2ON8PhYaGwtvbO+P106dP0axZM4wePRqvXr0yOX85fP/995gzZw7s7e0FaUlJSejQoQPmzJljgZrpp3Dhwhn/n5aWho4dOxq1T6SlpaF3797Yv3+/aHrNmjXRuHFjvfPz9PTElClTRNPi4uLw0UcfYc+ePQbXEwBu3bqFhg0b4saNGzrlqYm191FOTk5YvXo13rx5oxOPjo5Gt27dkJqaanA9AGDAgAGi8VKlSgnWKshMSEiI6HoQ4eHhkt+NPpKTk9GxY0ccOXJEJ75jxw58++23RudrDKW+g/Pnz8v2PZiLUscaLYzF7O3tJY9Rr1+/RtOmTbFu3Tqj6nj69Gn4+fnh9evXgrTatWvD2dlZr3yUGMcA5hvLAMJ9zNT9K0eOHPjuu+9E054/f446depg9+7dRuV9+fJlNGjQAPfu3TNqezKv99eafP36NZo1a2b0+OjGjRuoU6cOTp48KZr+6aefokGDBkblbQ4tWrTA6NGjBfHdu3djwoQJZq+P1DMB4uLiAPy3ft+kSZNw7Ngx1KlTx+Ty8ufPj7lz5+LgwYMoUqSIwduvWbNGEKtSpYpe244aNUoQ++eff/D3338L4o6OjoiIiECOHDkEaf/73/+wdu1avcpUo8z65pcvX6JevXqIiYkxKm+xvtnUdR/1UaNGDfj4+Ajif//9N54+fap3Ptb4t9GX1sfcap0vAKT3K2seCz158gQPHz4UTVPyPCtbtmyoV6+eyfm8evUKn3/+uWianZ0dvv32W5w9exZ9+vTRux27u7ujd+/eOHnyJKZMmSI6NwcAn332md5jb7FjYosWLXhcNMCrV68kzyN79eolSxli6xanpKRg5cqVRucp13FP6vOr+bObg7XPddoqtY0P5GILc8NyUvI6ntbnBdU8nrb1a3BERERE1kh8ZoyIiKxGbsPvA5CUq3DW79GaEydOSF7gCw4OznTb2rVrI1euXIL4li1b9C4/ISEBBw8eFMRLliwJX1/fLLeXmvTesGGD3nWg/yQlJUn+yMdUz58/F427ubkpUp41UfP3UrZsWdH4hQsXjK5TVqTqbKvS09MRERGBSpUqYefOnZaujiYULVrUoB8offXVV6q8gd9UaWlpOHPmjGL5nz59WnDT1zulS5dWrFxLyuzintjNLfR/KlSoIBo/e/Ys4uPjFSv3ypUrePbsmWha+fLlZSlD6qKqObx+/Ro3b96ULb+XL19Kpp07d062cjIry9HRUfImc6Vdu3YNt2/fFk2bPHky+vTpY+Ya2S45+lupNn7mzBnRH3FpgZ2dHebOnZvpTTRz5sxBx44ddR6UbetMmRMBOC8iJ6XOfU097y1Tpoxo/NSpU4q2JbEbp42h1XHWmTNncO3aNdG01q1b61WHunXrCm5sjo2Nxb59+zJeb9q0SbBd9uzZ0bBhQ73KaNu2rWhc35vYbW18ofX2ZO55MKn+q2jRonrncffuXckfnBlzc37dunVFz+lPnz6NEydO6JWHmuYTDflbmkqr/XFW1D6/ZI37mxLzDLZ2PAKs85zQFOaY11TztS4lWNM+Jne/o8UxldKs4dqCNR5z5fLll1+Kxv/++2+T59UXL14sGq9QoQLq169vUt70f5Ruo2ofU2dF6/W3FGsaK8jBGo6FcrLEHILS8wdqPx+wtfNiztMazpSxpy3tX+XKlRONnzp1SvJ4bqpjx44pku+H1NyPaa1NaL0PskbWev1CKZa8F1Br1Nx3KsFa25KtfY9aoNb7qwDtjUuUYCv3O1lrnwdo41hvy2NqWzrH1jJzzffK3V4tMa8ByDe3obXjMNuzuvCatuW1b98ePXv21Ptfjx490KlTJwQFBaFBgwYoUKCA3mXt3LkTTZs2zXjQi6GkHgbh4OBgVH6kDmrvl7V2nNOHFs499MX7Rv4jxziYbVGX2uZ9iIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiI1ODTTz9Fly5dLF0NIiIimzds2DDMnj0bjo6OgrRHjx4hPDwco0aNQrdu3XTW/Zo7dy5+/fVXHD16VHRdr3z58iEmJgYfffSRQfWZP38+unfvLpp2/vx5/PHHHxgwYABCQ0PRpk0bdOnSBcOHD0d4eDhiY2MF2zg4OGDp0qXw9/c3qB4A8PXXX2Pq1Kmws7MTpD148ADz5s3D8OHD0aVLF7Rt2xadO3fG8OHDsXz5cjx+/Fiwjbe3N2JiYpA7d26D62IOdnZ2WLlyJfLnzy9rvmr6TtVUFyIS5+HhYekqZPDw8EBMTAw+/vhj0fS///4bP/74I7p164aAgAA0a9YM7dq1w4ABA7B69WrRdcirVq2KPXv26P05f/zxR5QqVSrj9cOHD1GnTh00bNgQX375JQYMGICAgACULl0ap0+f1qn7kiVLDPq876tXrx6mTJmiE9u9ezcmTZpkdJ5EZJ2UGkN+SOq5Bkph/0skL849iFPT2FfN9H02touLC3bs2IFatWqJpp87dw5z5sxB//79M77bzp07Y+DAgZg3bx6uXLkiul2zZs0QFRUFe3v7LOuQPXt2HDhwAJUqVRKkJScnY8+ePZg2bRr69OmDjh07ZuxfgwYNwqJFi/DPP/8ItuvQoQMWLlyYZdlEZBi19cGWPjaZMv41Fse+RLZHibESYPx4aejQoZg5c6boOC8tLQ0HDhzA7NmzMW7cOAwcOBDffPMN5syZg6NHjyI9PV2wjbOzM5YuXar3vVCceyAiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIlKnSv6AWzbT8qjeCnBwkqc+1iwpKQmhoaFITk4WpHl5eWHlypV6rfmhpM6dO4uusRUbG4u2bdvizZs3JuW/ceNG0d/KOjs7Y8CAASblbQ6RkZFISkoSxOvWrYs8efIYnF9wcLDO67dv3+LgwYOC94WEhBicd+vWrUXjERERWW7bqFEjNGjQQDRtxIgR2LFjh8H1eScuLg6ffPKJ6FrGdnZ2GDt2rNF5v1O6dOmM/3/58iXq1auHw4cPm5yvHOzs7DB37lx89913oumxsbEICAjAn3/+aeaaGe+7777D+vXrTcqjZ8+eSElJEU2T2pfF9OjRA97e3qJpgwYNwt9//21U/d558OABunbtKrpGmBpYex/17NkzfPXVVyhevDhmzJiBhIQEvHz5UnIdG32tXLkS586dE01r3ry53vmULFlSNL506VKj6vW+t2/folevXkhMTMTy5ctRpUoV+Pv7m9QfG0Op7wCQ73swF6WONVoYi7Vr105nDZH39e/fH8ePHzepjmfPnsWwYcMyXh8/fhxt27ZF5cqVRcfRH1JyHAOYZywDCPcxU/ev3r17w8vLSxBPT09H165dce3aNZPyf/DgAT755BPVHiNJXP/+/XHy5EmT8njXJl68eCGaPmTIEJPyV0qBAgWwYsUKwXNZHj16hM6dO4uuuaQ0FxcX0XhSUhIcHBywbt06jBs3TvRZMqZo0KAB/vrrL9SuXdug7bZs2YLLly/rxJYvX45s2TKfZGrdujV69+4tiP/6669IS0sTxH/66SfRup05c0a1+5e+pPpmAOjVqxcuXbpkUv6W6JsDAgJE49u3bzcoH2v82+jLmsbcapovAMT3K1sYCx04cEA03qdPH9mPKe/nLbY2uzEiIyMxYsQIyfRy5cph3rx5ePr0KU6cOIEFCxZg4sSJGDZsGL788ksMGzYMEydOxLx58/DXX3/h+fPnWLRoESpXriyZ54gRIxAVFaV3HcWOiXZ2djwuGmj+/Pmi8c6dO5u8P1WsWFF0XdCoqCjR5yzpS67jHiD++dX82c3B2uc6bZXaxgdysYW5YTkpNbdqLfOC76itvdj6NTgiIiIiayTPDB4REamWe3YZ88ohX15qsnHjRgwcOFAQl7oA8E5QUJBoPDo62qDyo6Oj0axZM9Hy//jjD8ntnJycJB/WaOqEki26ceOG6IU5Obx69Uo07uzsrEh51kTN30uJEiVE43fu3DG6TlmRujnP1iQlJWHTpk344YcfcP78eUtXRzPs7e2xYsUKZM9u2OAgLCwMlSpVwpMnTxSqmfndvXtX8sKJHFJSUnDv3j34+voK0qT6Di3x9vZGiRIlULJkyYx/ZcqUkXy/pX8kq3bvXzR934c3ISnhypUrqF+/viCe2fepr5SUFJNvTjfFjRs3ZM0vMTERqampcHBwULysuLg4yTRPT0+8fv1a1vL0tWLFCowbN04Qd3BwwLx589CvXz8sWLAA27Ztw82bNy1QQ+ujVH8rdXPL1atXjaqnpTk5OWHVqlX49NNPM33f/fv3LfLjELXLbE7EwcEh05s3OC8iH6XOfU097y1evLhoXO5j34euX78uSz5aHmetW7cOY8aMEcTbtGmDn3/+OcvtxW6A3bZtm8550I4dO/DmzRu4uroKtt23b1+WZUjddLZu3bost33HlsYXWm9P5p4Hk5oDk/qBmZT58+eLzvOHhoZi6NChev1Q/Z2ePXtKlqEvNc0nGvq3NIWW++PMqH1+ydr2NyXnGWzpeARY3zmhISw1r6nma11KsJZ9TIl+R6tjKrlY67UFazvmysXNzQ3dunUTTRNb7MpQYWFhmDBhguicfb9+/VSzyKSWWKKNqn1MnRWt199SrGWsYAxrPRbKyVJzCErOH2jhfMCWzos5T2s4U8eetrJ/FS1aVDR+5coVxcq8ePGiYnm/T839mNbahNb7IGtkrdcvlGDpewG1Rs19pxKstS3Z2veoBWq9vwrQ3rhEKbZwv5O19nlaOdbb+pjaVs6xtcJS871KtFdLzGsA8s1taPE4zPasDrymbTuSk5MxceJETJkyxaTfFL158wYeHh6COM/ltE/N/bIWj3OZ0cq5h75s8b4RJcfBbIv/R43zPkRERERERERERERERERERERERERERERERERERERERGowe/Zs7N+/H3fv3rV0VYiIiGxSkyZNRNeZvXLlCkaNGoWoqCidNYR//fXXjHVTNm7ciJiYGABA/vz5MWDAAAwbNgxubm4Z73d1dUVkZCSqVaum13qgnTp1wueffy6Ix8TEYNSoUTh9+nSm23t4eGDgwIH4/vvvdda7tbe3x7Jly+Dr64v4+Pgs6wEAzZo1w08//SSI37x5EwMHDsS2bdsyXQvN0dERvXv3xs8//4xs2bJlxPPnz4+5c+eiQ4cOetXDnMaMGYOPP/5Y1jzV9J2qqS5EJM3T01Pn9e7du9GrVy+L1GXp0qWoXbu2IL5jxw6MGTMGJ06ckNx2zpw5cHNzQ58+fTBx4kSdY0H58uUxZ84c9OjRI9Pyc+fOjc8++0wn1qFDB/z111+C996+fRtBQUG4du1axlqb9evXR/369Q1eMzVnzpwIDw+Ho6NjRuzRo0fo3LmzSeuAEpF1UmIMKWbIkCEYOnSoIF6xYkWcOXNG1rLY/xLJi3MP0tQ09jVGx44dBc8bMoWzszP279+P/Pnz68RnzJih1/ZjxowRHb/v378fQ4cO1Wst7fr162PWrFmoUaOGTtzPzw/9+/fHH3/8ken2S5YsEaw/nZiYiClTpmDOnDl4/vx5lnXw9/fHr7/+ivLly2fEevTogS1btmDt2rVZbk9E+lFTH2zpY5Mc41+OfYlIH0qNlQDDx0sNGjQQHWempqZixowZmDlzJh48eCC5feHChTFixAgMHDgQdnZ2GXE7OzssWrQIf//9d6bPi+PcAxERERERERERERERERERERERERERERERERERkXr51jU9D2c3oEhl4Jb0cnX0/509exZjx47F9OnTBWn169fH2LFjMWnSJAvU7D8DBw4Ujc+aNQu3bt2SpYypU6eid+/esLe314l3794d3377rSxlKCU+Ph7bt29Hq1atdOJ2dnYICQnBokWL9M6ratWqKFSokE5s3759WLNmDRo2bKgTb9mypcF1bdOmjSAWFxeXscZRZr7++mvR+M6dO/Hbb78ZXJcP3b9/H1988QU2bdokSGvVqhVKlSqFa9eumVwOAPTu3VuvtZrMwdnZGStXrsSnn34qmv7w4UMEBATIvtacks6cOYOpU6eanM+tW7ewceNGtG/fXpD2YXvIzIABA0TjW7duxZIlS4ytno6jR4/i999/x5AhQ2TJT0620kc9fPgQX3/9NaZOnYry5cvj2bNnBpf/oXnz5omuudWoUSO98yhQoIBo/MaNG0bX631XrlxB3rx5ERcXJ0t+plDiOwDk+R4sQc5jjRbGYoMHDxaNR0ZGYunSpbLUcf78+ahSpQrCw8Oxb98+g7ZVehwDmHcsA/y3j5mqX79+ovElS5Zg69atJucPAMePH8e8efPQv39/WfIjZR04cEC2NvvPP/9g5MiRWLBggSCtTZs2yJcvHx4+fChLWXKwt7dHeHg4vL29deJpaWkIDQ3Fo0ePLFIvZ2dn0fjbt28RFhaGdu3aiaanpqbi5MmTuHbtGp4+fYqXL1/CyckJuXPnRt68eVG7dm3BuqcfypMnD3bu3InGjRtnuRbg+0aOHInIyMiM15UqVcLx48cxePBg7NixQ2f9XW9vbwwaNAijR48WHIOuX7+OhQsXCvIPCQkRXaM7Pj4e7du3R1JSUqb1c3R0hI+PD9LT0/HkyROkpqbq/dnMQapvXrVqFTZu3ChLGebumwMCAkTjhh5rrPFvYyitj7nVNl8AiO9XtjAWWrdunejfr3z58ujevbts44F3smfPjjFjxsia5/Tp0/Hy5Uv8/vvvkuuDOzs7o3r16qhevbrR5bx58wZfffWV6DEpKx8eEwEeFw118OBBXL58GWXLltWJ586dGy1bthQ9/9JX165dReOLFy82Ok9AvuMeIP751fzZzcFW5jptiRrHB3Kxpblhuck5t2pN84JqbC+2fg2OiIiIyBo5Zv0WIiLSsrcp8uWVKmNearJhwwbRG/Zy5MiR6XaBgYGC2MOHDw264QL4b2JF7EclQUFBmT5EtnHjxoKHUgL/PZTr2LFjBtWBgCdPniiWd0JCgmJ5Wzs1fy/ZsmUTjdvb24s+YFoOJUuWVCRfrXj69CmGDBmCyMhIq7xYorQxY8ZIXhS4efMm7OzsULx4cUFa3rx5ERYWhuDgYKWraDb//vuv4mW8ePFCNO7l5aV42aZycHBA0aJFUaJECZQsWVLnX4kSJTTxGbREaswptQ/JSaqM7Nmzm5z3vXv3sryJSUly3Wj5vjdv3mQ8VFfJshITE2XNTy4//fQT+vXrh1y5commV61aFbNnzwYAvHr1CpcvX8aNGzdw/fr1jH83btzA48ePzVltVbNUfyvVxs3R78jN09MTGzduRPPmzbN874QJE7B7924cOXLEDDXTjszmROrXr48DBw5Ibst5Efkode5r6nmvVD/08uVLk/LNypMnT/D27Vudh9AbQ8vjrIiICNEb8evWrYs8efJkeTwNCQkRxD68wf3169fYvXs3goKCdOLBwcGSN+C9U6xYMVSuXFkQP3HiBP75559Mt32fLY0vtN6ezD0PJjUHJtbvZyYyMhKPHj1C3rx5deI5c+ZE69atsXbtWr3ycXFxQadOnQTxxMRErFy5Uu/6qGk+0dC/pSm03B9nRu3zS9a2vyk5z2BLxyPAus4JP6TWeU01X+tSgrXsY0r0O1odU+lLrW1QadZ2zJVLx44dRfuD169fY/Xq1Sbnf//+fWzfvl1wTgsAn376KQYNGqS5fkdpamyjah9TZ0Xr9bcUaxkriFFjO9MaS80hKDl/oIXzAVs6L+Y8reFMHXvayv4l9fdQsv96+fIl0tPTYWdnp1gZgLr7Ma21Ca33QdbIWq9fKMHS9wJqjZr7TiVYa1uyte9RC9R6fxWgvXGJUmzhfidr7fO0cqy39TG1rZxjq4Va53uVaK+WmNcA5Jvb0OJxmO1ZHXhN2/qlpqbizz//xJgxY3Dz5k2T85P6XaHUAvmkHWrul7V4nMuMVs499GWN941YchzMtvh/1DjvQ0REREREREREREREREREREREREREREREREREREREpAbZs2fH0qVL0axZM0tXhYiIyCbNmTMH9vb2OrE1a9agR48eSE5O1jufBw8e4JtvvsGiRYuwceNGnTVjPT09sXLlStStWxfp6emSeXh4eOCPP/4QxKdMmYJx48bpVY+EhARMmzYNe/bsQUxMjM76dHnz5sXAgQPx448/ZpmPq6srlixZIlhfccOGDejSpQsSExOzzOPt27eYP38+jh07hr179+qsg9u+fXtUqVIFZ86c0etzmUPjxo0xceJEWfNU03eqproQUeY+XJ/r+fPnuHPnjtnrERoaik8++UQQ/+abbzB58mS98khMTMRvv/2GLVu2ICoqCmXLls1I6969O6KjoxEeHi65fbt27eDm5pbxev/+/Thw4IDk+x88eICwsDAMHDgwI9a1a1ccPnxYr/q+s2zZMhQuXDjjdVpaGjp37oxHjx4ZlA8RWT8lxpBS0tPTRc8n3r59K3tZ7H+J5MW5B2lqGfsaS+51g/v164f8+fPrxM6ePYvly5dnuW2ePHkwevRoQXzOnDkYMGCA3nU4fPgwateujRUrViA0NFQnbfLkyQgLC5N8NlaTJk3Qpk0bndjdu3fh7++Py5cv612HmJgYVKtWDWvXrkWrVq0y4j/++CPWrVuX6T5ORPpTSx+shmOTqeNfjn2JSB9Kj5UA/cdLLi4uWLRokeA64OPHjxEUFIQTJ05kWY+7d+9i0KBBWLt2LSIjI3WuA7q4uGDx4sVo2LChZF0490BERERERERERERERERERERERERERERERERERKRe3kXlySd3EeBW1j9bJAAzZsxAUFCQ6Fr13333HWJiYnD8+HGz16tIkSKoVq2aIP769Wv8+uuvspVz8+ZN7Ny5E/7+/jrxokWLoly5crh06ZJsZSkhIiJC8NtfAGjTpg0WLVqkdz7BwcGCWGRkJDZv3oz09HSd3wfnz58f1atXx8mTJ/XKO2fOnGjUqJEgHhUVhaSkpEy39fLyQmBgoGja1KlT9SpfH5GRkbhw4QIqVKigE7ezs8Onn34qS1kbNmzAhg0bTM5HDp6enti0aZPkMyquX78Of39/3Lp1y8w1M8348eORmpoqS15hYWFo3769IF69enW4u7vj9evXmW5funRplCtXTjRN33VV9TVjxgx89dVXcHBwkDVfOVh7H/W+Z8+eZbp2gSF2794tGq9WrRocHBz02s9dXFxE43KuoxUXFydbXnKQ8zsA5PkezE3OY40WxmJ58uRBgwYNRNOmTZsmWx3T09PRv39/g7cz1zgGMM9YBpBnHytdujR8fX1F02bMmGFS3h+aNGkS+vTpA0dHR1nzJfn98MMPsua3fPlyTJkyBT4+PjpxR0dHBAQEYMmSJbKWZ4pJkyahYcOGgviECROwZ88eC9Qoc71790a3bt0E8RMnTuCnn37Ctm3bEBsbm2keZcuWRc+ePdG/f394eXmJvsfLywtbt25F1apV9V6jKSoqCrNnz9ZZB7VMmTLYtm0bXrx4gVu3biEhIQF58uSBr6+v6Pg5JSUFnTp1Eoz3CxcujKVLl4qW26dPH1y7dk0Qd3JyQocOHdC6dWs0bdoU3t7eGePW9PR0PH36FHv27EFkZCTWrl1r0DrBcsusb54+fbqsZZmrb86WLRvq1q0riL969QrHjh3TOx9r/NuYQqtjbjXNFwDS+5UtjIWioqLw5MkTwTEaAH755RccPnxYtE81hp2dHZYuXYpcuXLJkt/7Fi5ciAMHDmD69Omicxam2rx5M77++mtcuXLFqO3FjokAj4uGWrBggWi77NmzJzZt2mR0vh+uvQ4ADx8+xLZt24zOU67j3vvEPr8aP7s52dJcpy1Q2/hATrY4NywHOedWrW1eUG3thdfgiIiIiKyTemYxiYhIEa9fypdXwgv58lKTffv24cWLF8iZM6fe2/j4+KBGjRqC+NatWw0u/+LFi7hz5w6KFCmiE2/atClcXFwkJ5lDQkJE45s2beKDX40g9bBeOfD7MJ6av5cPHwr7Tq9evdCrVy+T8jaUvb090tLSzFqmPiIjI426WOPn5wdvb29BPHfu3Lh27ZpVXixRWu3atfH999+LpqWmpqJr164AgAMHDohOzLds2RJ9+/bF//73PyWraTZK9i3vvHz5UjQu1XdYSpkyZVCrVi3UqFEDFStWRMmSJVGkSBFeoDEjqZt5pfYhOb14IT7Al6qTHHmbixLtXGrsIHdZah07xsbGolOnToiOjs7yxsjs2bOjTp06qFOnjiAtPj4eN27cwPXr13Hx4kX89ddfOH78uNU/WFhN/a3UscjS7dZQPj4+2LdvH6pXr67X+x0cHLB69WpUrlw5yx9d2JLM5kSCg4Mlb17nvIi8lBqfmvp38PDwEI2bo79ISEhA9uzZTcpDy+Os06dP4/r164IfPtjb2yMkJCTTG2eLFi2KihUr6sRSU1MRHR0teO+mTZsQFBSkEytTpgx8fX1x/fp1yTJat24tGo+IiJDcRowtjS+03p7UMg9mZ2dn0DxYamoqwsLCMHr0aEFar169sHbtWr3yadOmjejfMCIiwqBxhVr+joDhf0tTaLk/zoza55esbX9Tsr+0peMRYD3nhGo6z86Kmq91KcFa9jEl6quWvlmOfllLbVBpavleAfOO8bLSt29f0fi6detkm5tbuHCh4JwWAFxdXdGjRw/MnDlTlnK0SCttVO1j6qxovf6WYi1jBa20M62x1ByCVucP5DofsKXzYs7Tykffsaet7F+WOL6lp6cjNjbW5P0qK2rux7TWJrTeB1kja71+oQStjdctTc19pxKstS3Z2veoBWq9vwrQ3rhEKbZwv5O19nlaOdbb+pjaVs6xLUFL873mvI6tdNuSa25Di8dhtmd14DVt63Xt2jWsWbMGYWFhsj74MTY2Frlz5xbExWKkLWrul7V4nMuMVs499KX1+0bUNg5mW8yamu4PJCIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIispSPPvoIQ4YM4fotREREZta8eXOUL19eJ3bo0CF07tzZ6DV+b926hSZNmuDQoUM6edeuXRsdOnRAeHi45LZ9+vQRrAMWFhaGcePGGVyP48ePo0+fPoLyevTogR9//DHL7QcNGoTChQvrxPbv349OnTohOTnZoLqcOXMGffv2xZo1awAADx8+xMqVK/Hq1SuD8lGSj48P1qxZo7Ne0ebNmxEcHGxSvmr6TtVUFyLK3IdrdCcmJpq9Dg4ODpg0aZIgPmnSJEyePNng/K5fvw5/f38cP34c+fLly4hPmDAh02Njo0aNdF5v3rw5y7I2b96MgQMHZrxu0KCBQXUdNmyYoP+fPHkydu/ebVA+RGT9lBpDqgH7XyL5cO4hc2oY+6qFh4cHvvvuO0F85MiReu0r7dq1g4uLi05s//79GDBggMF1SUtLQ7du3VChQgVUrlw5I54tWza0bNlS8rlIr1+/xu7du9GsWTMAwJs3bxAUFITLly8bXIfk5GS0b98eSUlJGbESJUqgadOm2LNnj8H5EZGQWvpgNRybTB3/cuxLRPpQYqx09uxZlClTJiOu73hp7NixOtsBQFxcHAICAnDq1CmD6nLgwAG0atUKMTExcHV1zYjXr18fX3zxBebPny+6HeceiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiI1Mstmzz5eOSUJx9b0b17d5w7dw45c+r+4RwdHbFy5UpUrVoVCQkJZq3Txx9/LBrfuXMnnj9/LmtZe/fuhb+/vyDetGlTXLp0Sday5BYZGYmkpCTB+i9+fn5wd3fH69ev9cqnVatWglhUVBQePnyIv//+G7Vq1dJJCw4OxsmTJ/XKOzg4WGfNtHfWrl2b5bb+/v5wcnISxM+fPy/7b3VnzpyJBQsWCOIhISGYOnWqLPmrgY+PD7Zt24bq1auLpp84cQKBgYF48uSJmWtmmtu3byMqKkq2/A4dOoT09HTY2dnpxB0dHVG0aNEs+4aAgADR+JkzZ3Do0CHZ6gkA9+7dw5YtW0TbsaVZex+llMuXLyM+Ph6enp46cUdHR+TMmRNPnz7NMo+XL1+KxosXL45r167JUU2rJ8f3YG5yHmu0MBYLCAgQ9NMAcOrUKRw+fFjWOhrDnOMYQPmxzLsyTCX2XQP/rV944cIFk/N/34MHD7B582a0adNG1nxJXrdv38aOHTtkzTMpKQmLFi3C6NGjBWkBAQFYsmSJrOUZq0WLFqJ13L17N3744QcL1ChrY8eO1Xn9/PlzfPbZZ9i4caPeeVy+fBmjR4/GtGnTMHPmTHTv3l30ffny5cP8+fPRunVrvfMeOnQocufOjU6dOunEc+bMKZjz+FBSUhJCQ0Nx4sQJnbiDgwPCw8NFt1+4cCFWr14tiLdt2xbTp09HiRIlRMuys7ODj48POnTogA4dOuCHH37AiBEj8Oeff2b1ERUh1TcfPXrU4LXBsmKuvtnPzw+Ojo6C+M6dO5Gamqp3Ptb4t1ETc4y51TZfAIjvV7YyFkpMTMSMGTNE12nNlSsXoqOj0bBhQzx69Mjksn755ReDjiGGqlOnDsqWLatI3mXLlkWdOnVw5coVo/OQOiYCPC7qa+nSpZg6dSqcnZ114i1btoS3t7dRfVSjRo1QpEgRQXz58uUGHZ8+JNdx731in1+Nn92cONdpPdQ4PpAT54aNI+fcqjXNC6qxvfAaHBEREZF1srd0BYiISFn/XpQnn7RU4NF1efJSm9TUVL0eovW+Fi1aiN5AFx0dbVQdtm3bJoi5ubmhSZMmkttIPUh9w4YNRtXB1iUnJ1u6CiRCzd+Lu7u7paugev369UNoaKjB/0aNGiWan52dnWp+HKQlHh4eWLVqleiFbQCYNGkSjhw5giNHjmDy5MmS+fzyyy8oV66cUtU0K3M8xDkuLk407uHhoXjZWcmXLx++/fZbXLp0CZcvX8by5csxZMgQ+Pn5oXjx4qIXvkk5UseT2NhYxcuWKkOO/fTVq1cm52GKlJQUqyzL0nbs2IEuXbqY1I96enqiSpUq+OSTTzB+/HhERkbiwYMH2L9/Pz777DPRC/5apdb+1pL9jpwaNGgg+UNtqXZZtGhR0Zs8bFlmcyJS8w4A50XkptZzX6n+QmqsKyd9bwrNjNbHWevWrRONZ/UDBbG2cfDgQbx48UIQj4qKQnp6uiDesmXLTMuQqoMxN6DbyvjCWtuTFixYsEB0P/f390f+/Pn1yqNXr16i8fnz5xtUFy3/HU2h9f5Yitrnl6xtf1N6nsFWjkeAts8J1XqenRW1jveVouV97H1K9Dta75u12gaVpvXvVQmVK1dGnTp1RNMWLlwoWzlRUVF4/PixaFrfvn1lK0crtNhG1T6mzorW628pWh4raLGdaY2l9g8l5w+0cj5gK+fFnKe1DFvYv6TKl+N7z0x8fLyi+QPq7se01ia03gdZI2u9fqEES98LqDVq7juVYK1tyda+Ry1Q83eitXGJkqz9fidr7fO0cqznmNo2zrHNRavzvUq0V0vNawDyzG1o9TjM9mxZvKatbampqYiPj8fDhw9x+vRpREdHY/r06ejWrRuKFi2K0qVL49tvv8WtW7dkLff+/fui8bx588paDlmGWvtlrR7npGjl3ENfWrxvRO3jYLZFIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIi0sfUqVNRvnx5S1eDiIjIpgQGBgpiX3/9teg6sYZ4+fIlOnTooLP+8LNnz5AzZ85Mtzt27JjOOrUPHz7E4MGDja5HREQELl++rBMrW7YscuXKlel2jo6OGDJkiE4sKSkJXbt2NXpN5fDwcEyfPh0tW7ZEoUKF8PXXX+Off/4xKi+52dnZYcWKFTrPg75z5w66d+9uct5q+U7VVhciLWvatCm6d++e8a9+/fqyl/HhumzmWCPuQy1btkSJEiV0YidOnMD48eONzvPu3bvo16+fTqxMmTKix+P309934cKFLMs5f/68zuuyZcvqXcc6dergxx9/1Int27cP33//vd55EJEyzNH/GkLJMaQasP8lkg/nHjKnhrGvWgwbNkywPvzu3buxfft2vbYPCgoSxL755huj65Oamopvv/1Wr3Le+euvv9C8eXPUrFkTa9euxcyZMwXHB0OIzUM1a9bM6PyItMRW5h8AdRybTB3/cuxLZD2U7H+VGCtNmDBBEM9qvOTk5IT+/fsL4kOHDsWpU6eMqsuBAwdE544/vN74Ps49EBERERERERERERERERERERERERERERERERERqVfKG3nySbbdpUSM8u+//6JPnz6iab6+vpg5c6Z5KwSgYcOGonF910QxxNGjR0XjFSpUkL0sucXFxSEmJkYQd3V1RYsWLfTKI2/evKhZs6ZO7Pz587h16xYAYNOmTYJtQkJC9K5jmzZtBLGEhARs27Yty20/+ugj0bg+2xpKKs86derAxcXFpLwvX76M/fv3m5SHHIoWLYpDhw6hevXqouk7duxAkyZN8OTJEzPXzHSbN2+WNb/Y2FjcuHFDNC2r9bYAoF69eqJxueupdL6msvY+Sinp6el48OCBaJq+66xJbR8aGmp0vWyNHN+DOcl9rNHCWKxRo0aicSXqaAxzjmMyy1eOsQwg3z5Wp04d0fiePXtMzltMdHS0IvmSfMTGCnLYvXu3aLxWrVqKlGeoAgUKYMWKFbCzs9OJP3z4EKGhoSavHasUR0fHjP8/d+4cqlevjo0bNxqV14sXL9CjRw/06dMHqampou9p1aoVWrVqpXeeKSkpCA0NxeTJkw2qy507d/Dxxx9jw4YNgrQff/xRdHx//vx5fPXVV4L4lClTsH79esGzFjJTvHhxrFu3DlOnTjWo3nKpXbu2aHzXrl2KlGeOvjkgIEA0vnXrVoPysca/jZqYY8yttvkCQHw8ZEtjoVmzZkn+DX19fXHq1CnJ8xF9eHl5YcOGDZmuR2iKAgUKYOfOnVi6dCl8fX0VKcPX1xdLly7Fzp07UaBAAaPyeP+YmJKSYtC2tn5cfOfZs2ei4xwnJyej51e6du0qGg8LCzMqv3fkOu69T+zzq/GzmxPnOq2HGscHcuLcsOHknlu1pnlBNbYXXoMjIiIisk72lq4AEREp6+ZfQJr4fQEGuXsWSH5tej5qJXZxBvjvBnAxYg8sfvv2LXbs2GFU+Vu2bBGNSz1EtkyZMihZsqQgHhcXJ3njDhGRVoSFheHMmTOiafXq1UPHjh3NXCNtmzVrlugxA/jvRvIffvgh4/XEiRNx7Ngx0fe6ublh1apVcHJyUqSe5pSWlmYVZRjK1dUVEydOxPXr1zFhwgSDHghKyvnwZuZ3tL6fxsXFKZY3WVZERARq166NEydOyJannZ0dGjVqhIULF+LSpUsG3cCuRlrtb9X6IwpDrV27FjVq1MDr1+KTGB06dECvXr3MXCt1k5oTKV++POdFSJQ5+gupHzoZQuvjrIiICNG4n58f3N3dJbcTO45GRkaKvvfBgwc4efKkIJ7ZzbM5c+YU/XHxqVOnJG9Oy4otjy+00p607ObNm6I/GnJwcEC3bt2y3D5//vzw8/MTxC9duoTDhw/LUkdrp/X+2BJ5m7MMrTDHPIMtH48AdZ8TavU8m3SpeR8Tw/nN/8M2SIb68ssvRePXrl3DgQMHZCvn7du3WL58uWhamTJl0LhxY9nKUjMtt1Gtj6m1Xn+1UfNYQcvtTGssNYdgS20tM7Z8Xsx5WuXZ8v6lJDUfP0l/7IMsx1qvXyiBc2WUGbYlInqftd/vZK19ntaP9bY2puY5tmm0Pt+r9fb6IVuf22B7thxe01aPggULws7OzqB/jo6O8PLyQv78+VGtWjW0bNkSI0aMwIoVK3Dnzh3F6iq10HCxYsUUK5PMi/2y8qxtLKOlc0EtjYPZFomIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiCgrrq6uWLlyJRwdHS1dFSIiIptRsWJFndfPnj3D0aNHZcn7woULWLJkCS5duoQ+ffqgUKFC+N///pfpNocPH0arVq1QqlQpzJo1Cz/88IPJ6xxt375dECtZsmSm2wQGBiJ//vw6sd9//x137941qS4jRoxAdHS0qtZEBYAxY8bA398/43VKSgo6dOiAFy9emJy3Wr5TtdWFSMsGDx6MpUuXZvz74osvZC/D09NT53ViYqLsZWSlQ4cOgtj48eNNznfjxo2C9dil1lQFgFy5cum8fvz4cZZlfPgeZ2dnuLm5Zbldjhw5EB4eDicnp4zYkydPEBoaymdIEKmAOfpfQyg5hlQD9r9E8uHcQ+bUMPZVAx8fH4wYMUInlp6eLohlpnDhwjqvX716hYMHD5pUr61bt+Lt27c6sSJFimS53YkTJ9ChQweMGTPGpPLFlC9fXvY8idTIVuYfAHUcm0wd/3LsS2Q9zNH/yjlW2rJliyCW1XipdevW8Pb21omdPXsWixcvNqkus2bNwq1bt3Ri5cqVQ7169UTfz7kHIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIi9Yp7Kk8+sU/kyceWrFu3DsuWLRNN+/zzz9GmTRuz1qds2bKi8SNHjshe1oMHD0TjpUuXlr0sJURERIjG9f3OWrZsCTs7O51YVFSU6P+/U6NGDeTLly/LvF1cXNCiRQtBfPPmzXjz5k2W20v9htnU9W3E3Lt3T3QNZHt7e5QpU8akvPfu3WvS9nKoVKkSjhw5glKlSommr169Gi1btkRCQoKZayaP/fv3y56n1JrYH/5mXYxUH3bo0CGT6iTl2LFjiuQrB2vuo5T06tUr0bg++x8g3U92794d7du3N7petsbU78Gc5D7WaGEsVq5cOdH44cOHTa6THMw5jgGUHcsA8u1jUnVRYt8CgAMHDiiSL8lHqe/o+PHjSE9PF8SLFSsGZ2dnRcrUl729PcLDwwXrMaWlpaFz5856rYlkaffu3UOLFi1w+/Ztk/NasGABBg8eLJn+7bffGpznN998g1WrVmW5tuCNGzcwevRolC5dWnRfDAoKwvDhwwXxhIQEtG/fXjBm/PXXX01a42v06NH45ZdfjN7eWNbYNwcEBIjGxdaLzIw1/m3URukxt9rmCwDx/cqW9qnExET07t1bci2+/PnzY8+ePVi8eDF8fX31ztfZ2Rn9+vXDxYsXBXMO27ZtM6XKGXx9fXH06FE0b948y/e+ePECR44cQXR0NFavXo0lS5Zg9erViI6OxpEjR/D8+fMs82jevDmOHj1q0N/hQ9988w3Kly/P46KR5s+fLxrv2bOnwXk5OTnh008/FcSPHTuGS5cuGZzf++Q67n1I7POr7bObG+c6rYMaxwdy4tyw4eSeW7WmeUE1thdegyMiIiKyTo6WrgARESkr/hlwLgaoEmhaPodXy1Mftdq2bRsSExMFD8Vq2bIl5syZoxOzs7PTebj5O4cPH5a8CJuVXbt2ITk5WXBjTWBgIIYMGSJ4f8uWLUXz2bp1K5KTk42qAxGRWqSnp2P48OHYuXOnaPpPP/2EjRs3Iikpycw1055PPvkEvXv3Fk2Li4tDly5dkJqamhFLTU1F586dcebMGcGDjwGgatWqmDJlikEPXid1yJ8/PyIjI1GzZk2T8klISMC1a9cy/l29ehXXrl1DXFwczp49K1NtyRrwYbHW7fz586hZsyZat26NgQMH4qOPPoKDg4MseZcsWRKbNm3C1KlTMXbsWFnyNCf2t5Y1e/ZsfPXVV0hPT8fgwYOxYMEC0ff9/vvvOHToEK5evWrmGqqT1JwIwHkRIks6deoUbty4gZIlS+rEXV1d4e/vj40bNwq28fDwQNOmTQVxsRtk39m0aRNq1KihE2vcuDG8vLxEb4APDg4WPe6vXbtWsgx9cHxBSpo/fz6aNWsmiPfq1Qs//fRTptt269ZNdF+U+rEDESnDXPMMPB6pD8+zyVI4v/kftkEylLu7O7p27SqaduzYMTRu3FjW8q5duyaZ1q9fP0V+mKUmbKNEymM7I1vD82JSkjXvX2KLLQL/LTagJEsv5khEtoNzZUREpC9bu9/JWvBYrz3WfI6tJGuY71WivVpqXgPg3AbA9mwJvKZNxrp586Zo3MfHB7ly5dJrsXtSP/bLyuK5h2VocRzMtkhERERERERERERERERERERERERERERERERERERERERZqVq1KiZMmIBx48ZZuioZ8uXLh+bNm6Nx48bIly8fvL29kTt3brx9+xZPnz7F06dPcfXqVcTExODQoUNISUnRK19HR0fRNZvc3d0z3c7Ozi7L9wBAYmKi5HpUlmRnZyf6nGXgv/WzEhMTdWIeHh5o2bIlmjdvjnLlyiF37txwcnLCixcv8PTpU5w/fx7bt2/HgQMH9P7b6ytHjhz4+OOPUatWLZQvXx558uSBp6cnHBwc8OrVKzx9+hRnzpzBwYMHsX37drx9+1a2st3c3ODn54d69eqhYsWKyJcvH7y8vGBnZ4f4+Hg8ffoUFy9exF9//YVt27bhxYsXRpVj6PdRrFgxtGvXDvXq1UOJEiXg5eWF1NRUxMbG4saNGzh8+DA2btyIe/fuZVpuzZo1ERISgurVq6NQoULw8PBAYmIinjx5gps3b2Lbtm2IiYlBfHy8UZ9LilLtmUjLcubMqfM6q/ZrqKFDh+L169cGb3fjxg0MHjxYljqIfabs2bNnus0nn3wiiM2aNUuW+qhN48aNMXHiRJ3Y6NGjcezYMVnLsfR3qta6EJE4T09PndcfjkvNoV69ejqvY2NjsWPHDlny/vPPP1G9evWM15mtm2rM3yIlJQVpaWk6axF7eXllue2SJUtQtGjRjNfp6eno2rUrHjx4kGWZRGRbzDWGtCT2v0Ty4dxD5tQw9lWDb7/9Fl5eXjqxNWvW4OTJk3rnkTdvXp3X9+7dM/k6SXJyMh49eoSCBQtmxPLly2dSnoaKjY1FtmzZMl5/2KaIyHhq64MteWySY/zLsS8RWUJsbKzB46XPPvtMEPvpp59kGTv++uuvgmuKn332GY4cOSJ4P+ceiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiI1OufU4B30azfl5Xbp0zPwxYNGDAAjRo1QvHixQVpCxcuxNGjR/Hw4UOz1KV06dKi8du3b8teltQ641pZb2TTpk1ISkqCi4uLTjw4OBj29vZIS0vLdPtWrVqJ5vnO2bNncefOHRQpUiQjZmdnh5YtW2LRokWZ5u3n5wcPDw9BfO3atZlu9065cuVE44asj2OIEydOoHDhwqL1OHv2rNH5WnqtuIYNGyIqKgo5cuQQTY+Pj8eAAQM0vTb8pUuXZM/z1atXonGpv+P7fH19ReOnTilzgDp//jySk5NFn8FhadbcRymhQYMGKFGiBHLlyiWaru93fPDgQTx79gy5c+fWidvb2yM8PBzBwcH45ZdfcObMGZPrbG3y5cuHkiVLyvI9mJPcxxotjMXKlCkjGleqrzWUuccxgHJjGUC+faxUqVKicVPrJ+XGjRuCdWNIXa5du6ZIvq9evcLt27dRrFgxnbi9vT1KlCiBy5cvK1KuPiZNmoSGDRsK4hMmTMCePXssUCPDpKWloXXr1rKuozR79mzUqFEDvXr1EqTVqFED9erVE11PKjNdunSBk5NTxvgqb9688PT0xJMnT/Do0SOcOHECV69eldy+YMGCWLZsGezs7ARp/fr1E+xDrVu3xpAhQwTvjY+Px8KFC7Ft2zbcv38/I++goCB89tlngufhDR06FHv27EFUVJRBn9cUUn3z6dOnFSlP6b65XLlyosfDixcvGrw+s7X9bdTCnGNutc0XAOL7la2Nhfbv349Bgwbhjz/+EE13dHREr1690L17dxw5cgS7d+/G0aNH8ejRIzx79gxJSUnImTMnfHx8UKpUKfj5+cHPzw/e3t6CvC5fvozhw4cjICDApDrnyZMHe/fu1Vkv+0Pnzp3D//73P8TExOD69etZ5lmiRAn4+fmhb9++qFatmuh7ChcujL1796JatWp48uSJUXW/fv06j4tG2rVrF27evIkSJUroxKtXr46KFSvi/PnzeucVGBgo2uctXrzYpDrKedz7kNjnV9NntwTOdVoHNY4P5MS5YcPJPbdqTfOCamwvvAZHREREZJ0cLV0BIiJS3oGlQImagJePcdtf2AXcVeaammokJiZix44dgsnkkJAQzJkzRydWq1Yt0Ytj0dHRRpefkJCAgwcPolmzZjrx0qVLo3jx4rh165agXmI2bNhgdB2IyDBSD/87cOAArly5ooq6aNmuXbsQHR2NoKAgQVqRIkUwbNgwTJ061QI1044CBQpg/vz5kulfffUVbt68KYjfvHkTgwYNkryoPHz4cGzbtg27du2Sra7m5uDgoHgZUhc3UlNTFS/7Q97e3jhy5IjOQz0z8+bNG1y/fh3Xrl3DtWvXcPXq1Yz/l7p5NU+ePHJW2aZI7ROOjspP2Tg5OYnGLbGfkjZt2rQJmzZtQu7cueHn54fq1aujWrVqKF26NAoXLmzSzZNjxoyBi4sLhg8fLmONlaWV/lbqJitz9DtK+uabbzB58uSM1wsXLkRgYCDatWsneK+HhwfWrFmDOnXqaPqH3XKRmhMBOC9i66TGBFJjCDnJcbOQNYyz1q1bh1GjRgnibdq0wcaNGwVxf39/wd/u8uXLmf6AMDIyEhMnTtSJOTk5wd/fH3/++ado2VJ1lYO1ji+03p60Pg+2fv160Zt7y5Yti9q1a+P48eOS24r94DIpKQnLli0zuB5q+jsC5ptTtIb+WIza55dsdX+Ti7UejwBtnRNq5TybdGlpHzM3NfXN+vTLbIP6UdP3Clj+mNupUydky5ZNNK1r167o2rWr2erSrl07eHt74+nTp2Yr05ysoY2qfUydFa3X31K0NFawhnamNZaaQ+B1cyFrPS/mPK28jB17WuP+lZCQIBpXerELSyymoSZaaxNa74OskbVev6DMiS3gRqZhWyLS3rhEadZ8vxP7PMvimFrIGs+xlcL5XmmWmteQqwxrOQ6zPZsPr2mTsTJbVLZy5crYu3ev+SpDGZSa61FLv2wtxzlrpYX7RrQ+DmZb1L8uREREREREREREREREREREREREREREREREREREREREtmjUqFHYvHkzjhw5YtF6hISEYPz48ahVq5Ze7x8zZgzi4+Pxv//9D1OnTsXz588zff+wYcMwbdo0g+vl4uIiuc7U+0qWLImbN28anL/SatWqhWPHjomm3bt3D4ULFwbw3xoQo0ePxogRI5A9e3bJ/IKCgjBy5EjcvXsXEyZMQFhYmOTzM/T10UcfYfjw4QgICMhyLYrAwEAAwNOnTzF79mxMmzYNiYmJRpddsWJFfP311+jYsSNcXV0zfW+LFi0A/LdmxdatWzF9+nTs27fPoPL0/T5y5syJ33//HaGhoZJrQ9SuXRuhoaGYOXMm1qxZg+HDh+PRo0c672nUqBGmT5+O2rVrS9apefPm+OKLL/Dq1StMmTIFv/32G5KSkgz6XB9Suj0TaZnSa5+8fv1a0fz1Ycw6r35+fjqvT5w4gbt378pVJdXw8fHBmjVrdI53UVFR+OWXXyxYq6ypae1eNdWFyJp4enrqvDb38cTFxQXFixfXiR09ehRv376VJf+DBw/qvM6ZMyfKlSuHS5cuZbmtvsfutLQ0g9Z1Gzx4MFq3bq0TmzZtGmJiYvTOg4hsg1bHkKZi/0tkPM49ZM7SY181KFGiBL788kudWHJyMsaOHWtQPh8+Z8jUeWWpfMz9rO43b97oPIfBHM/zIbIV1twHmzpvqcT4l2NfIlKKIeMle3t7NGrUSCeWlJSEyMhIWeqydu1azJw5U6dvbNKkiV7bcu6BiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIhIPS7sBGq0BuzsjM/j9mkg/plsVbIp8fHx6NKlCw4cOCBYIzx37txYunRpxvrcSsuZM6cglpiYqMia1fHx8aJxLy8v2ctSQlxcHGJiYhASEqITz5UrFxo2bIj9+/dLbuvs7CxYD/jx48c4fvy4TiwyMhIDBw7UiYWEhGDRokWZ1q1NmzaC2OvXrxEdHZ3pdu/4+PiIxp88eaLX9oZ6+vSpaNzb29ukfM+cOWPS9qYICQlBREREpmvve3p6Yt68eejQoYMZayavf//9V/Y8Y2NjReNZ/e7c3t5esL7KO1L7mKnS0tLw/Plz5MuXT5H8TWHNfZQxXFxcUKxYMZQsWRIlSpSAr68vSpQokfHPzc1NlnJSUlIwdepUTJ8+XZBmZ2eH7t27o3v37rh37x7++usvXLhwAdevX8/49+GzLqyJub4Dc5P7WKOFsViuXLlE40qNEwxl7nEMoNxYBpBvH5N6DtKzZ8qcxKWkpOD+/fsoVKiQIvmT6W7fvq1Y3s+fP0exYsUEcbE+zlxatGiB0aNHC+K7d+/GDz/8YIEaGW7FihU4efKk7PmOGTMGHTp0gIeHhyCtffv2Rj1TLyUlBXv37sXevXsN2s7BwQHh4eHInTu3IG3JkiVYvny5TszV1RULFiwQvPfatWv4+OOPBfv5uXPnsG3bNsycORM7d+4UPJth4cKFKFKkiGzru2YlR44conGlzl+U7pul5q62bdtmcF7W9rcxFzWNudU0X/CO2HjIFsdCs2fPRvbs2TF58mTJ9zg4OKBhw4Zo2LChUWXcu3cP/v7+kuskGvIcnNWrV6NgwYKiaU+ePMEXX3yBTZs2GVS/mzdvYv78+Zg/fz4CAwOxePFi0bmdggULYs2aNWjevLlB+X+Ix0XjLFy4EFOmTBHEe/bsia+//lrvfLp27SqIJSYmYs2aNSbVT87jnhixz6+Wz24JnOu0DmocH8iJc8OGk3tu1ZrmBdXWXngNjoiIiMh6mffJdEREZBGvXwJ/fg90+hFwNfAe/bvngW0zFaiUCq1fvx6tWrXSiX300Udwd3fXedhjUFCQ6PamTgpHR0ejWbNmgnhAQADmzp2b8Tp79uyiF/FSUlI4MU1kRm/evBGNr1u3DrNmzTJzbazT8OHD4e/vL/pA7bFjx2Lx4sU2eXFFX8uXL5e84Xvt2rVYunSp5LZhYWFo2bIlPvnkE0GanZ0dli1bhkqVKilyc7s5ZPYjL7lI3fwmdfO+Uuzs7BAREYGiRYtKvufhw4eIiorCzp07cerUKdy4cQNpaWkGl0PGkdonzHHDtVQZcXFxipdN1uXZs2cIDw9HeHh4RszZ2TnjJlZfX1+ULl064/+LFi2q10XqYcOG4ejRo1i7dq2S1ZeFlvpbqXGs1LFL7VJTU/Hll1+K3uD1+eefo06dOqI3oFarVg3Tpk3DsGHDzFFN1RObEwE4L2LrpMYp5ugv3N3dTc7DGsZZERERGDVqlCAeHBwMe3t7wXFErB1HRUVlWsaZM2dw9+5dFC5cWJDXn3/+qRNzcXERvXn67NmzuHbtWqblGMraxhdab09anwdLSUnBsmXLMHToUEFa7969BTeUv1O7dm2ULVtWEN+wYYNRcyJa/zsayxr6YzFqn1+y1f1NbtZ2PAK0c06opfNs0qWVfcwStNQ3sw3qT0vfqzn07dvX0lXI4OzsjJ49e4r+yE/rrKWNqn1MnRWt199StDJWsJZ2pjWWmkPgdXNp1nZezHladbGm/csS/ZebmxucnZ0Vy18LtNYmtN4HWSNrvX5BmdPqoudqxrZEpL1xidKs+X4n9nmWxTG1NGs6x1YC53szZ6m+Ta65DWs7DrM9K4/XtMlYZ8+elUxr1KiRwQvOkzyUnuuxdL9sbcc5a6P2+0asaRzMtkhERERERERERERERERERERERERERERERERERERERERiHBwcsHz5clSpUgUJCQlmL7906dJYtWoVatSoYfC2np6e+Prrr/Hll19i0KBBWLJkifwV1ENKSgr++ecfi5Qth3LlymHlypWoVq2a3tsULlwYCxcuRIcOHfDpp58ataZfoUKFMHfuXAQHBxu8rbe3N7777jv06tULn376Kf766y+Dtvfy8sKPP/6Ivn376rW+wvscHBwQHByM4OBgbNq0CQMGDMC///5rUB6Zady4MVavXo0CBQroXZ8uXbrA398fwcHBGc8UnTp1KkaNGqX3uhbZs2fHtGnT0K5dO7Rs2RLPnj0zuO7W0J6JlPbhM3zz5ctnoZooJ0+ePILYq1evJN9fqFAhFCxYUCe2efNm2etlaXZ2dlixYgXy58+fEbtz5w66d+9uwVrpx9DvVElqqguRNfHw8NB5nZiYaNbyc+bMKRi3Pnz4ULb8Hzx4IIjVqlULly5dynJbfcfThpxX1KpVCz///LNO7NChQ/jmm2/0zoOIbIOWx5CmYv9LZDzOPWTO0mNfNZgyZQqcnJx0YnPnzjX4OkdcXBx8fHwyXufOnVuO6sHb21vndWxsrCz56uvDZ4yYu3wia2bNfbCp85Zyj3859iUiJRkyXipbtqyg/9+1a5dsz418+PAhjh07hnr16mXEfH19kSNHDrx8+TLTbTn3QEREREREREREREREREREREREREREREREREREpB6PrgNXDgBlGxu3fXoasG+xvHWyNUeOHMGUKVMwfvx4QZq/vz8GDRqEWbNmKVoHd3d30d+Aurm5KbJGgdTvTV1cXGQvSykREREICQkRxNu0aYP9+/dLbtesWTPB74A3b96M9PR0nVhkZCQGDhyoE/v444/h4uKCpKQk0bzt7OxE6xQdHa3X9+jm5gYHBwdBPCkpCW/evMlye2O8ePFCNO7l5WVSvsas8y6HXr16YcGCBaJ/xw+1b98evXv3xuLF2uxE5frt+vvS0tKM2k5qf4mPj8fbt29NqVKmXr58qdq1xqyxj8pKgQIFUKNGDVSuXBm+vr4oUaIESpYsiQIFCui9zoGpfv/9d7Rt2xYNGjSQfE+hQoVQqFAhtG3bVieekJCAGzdu4Pr167h+/TquXbuGM2fO4OzZs5J/U7VRw3dgTnIea7QwFnN3dxddCyQpKUkV+6glxjGAcmMZQJ59TGrfSkpKQnJyssn5S1FinEDyUXKdR6m1hzw9PRUrMzMFChTAihUrRNfhDw0NFYxx1GrSpEmK5Pvo0SMsWrQIgwYNEqQFBARg2LBhipQrZvLkyaJjqEuXLqF///6CeI8ePXTWZQWA5ORktGzZErdv35Ys5+bNm2jZsiXOnDmjsz5snjx50LVrVyxatMiET6Efqb45OTlZ0WOqkn1zYGCgaHzbtm0G5WONfxu5aWHMrab5AkB8v7LlsdCUKVNw69YtLFy4EO7u7rLmffLkSbRp0wZ3795FmTJlRN+jb1vu0qULmjVrJpp27tw5+Pn54fHjx0bXFQC2bt2KihUrYseOHaLPEG3WrBk6d+6MVatWmVSOMWzpuCgmLCwMEydOhKOjo068S5cuGDlypF59gpeXl+g81IYNG0weD8t13JMSFhaGKVOm6MTU8tktxRbnOq2N2sYHSrD1uWFDyTm3am3zgmprL7wGR0RERGS9HLN+CxERWYPHN4Blg4C23wI+xfXb5ux2YMcfQGqKsnVTi6ioKKSmpupMMrm4uKB58+aIiorKiIldILh//z7OnTtnUvlbt27F9OnTBfGgoCDMnTs343WLFi0EF08AYPfu3Zq9AECkRa9fvxaNy/VQaQIuX76MBQsWoF+/foI0T09PTJo0CV988YUFaqZ+w4cPl7zZ4t69e+jTp0+WeXzxxReoW7cuChYsKEgrUKAAFi5ciHbt2plcV0v48CGgSsiRI4doPD4+XvGy39exY0d89NFHomn//vsvvv76a6xduxapqakmlSP3zUe2ROqioDn2U6ky1HzTG2lHcnIyLl++jMuXLwvSnJ2dUbZsWTRo0AChoaFo1KiRZD4///wzNmzYoOhFaTloqb+VGsdmz57d5LzNLTExEZ06dUJkZKRo+osXL9CtWzfs3LlT9IdwQ4YMQUxMjGw3/GmZ2JwIwHkRW5eQkCAalxrrysXBwUGW/s4axlknT57EzZs3UaJECZ147ty50bBhQ50bZ+3s7BAUFCTIY9OmTVmWExUVJbgxPSgoCHZ2djo32vr5+QluxgWAtWvXZlmGHLQ8vtB6e7KGebD58+dj6NChgninTp0wePBg0Zt0e/bsKZmXMazh72gMa+iPDclbTqbML9nq/mYOWj4eAdo5J9TSeTbp0so+Zgla6pvZBvWnpe9VaVWqVEGtWrUsXQ0dX375peh8k9ZZSxtV+5g6K1qvv6VoZaxgLe1Mayw1h8Dr5obR8nkx52nVT6v71/Pnz0XjefLkUazMAgUKKJa3VmitTWi9D7JG1nr9wpqI3etjKrHr3WQatiUi7Y1LlGbN9zuxz7MsjqkNo9VzbCVwvjdzlpjXAOSb27CF4zDbs3x4TZtMcf78ebx8+VJ07OHv748ffvjB/JXSGGuZ6zFnv2wLxzktU/t9I9Y+DmZbJCIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIgAoWbIkfv31V/Tp08es5fr7+yM8PNzktdC8vLwQFhaG0qVLY+zYsfJUzgC3bt1CWlqa2cuVQ4kSJbB3716j18zy9/fHgQMHUK9ePSQmJuq9Xb169bBp0yb4+PgYVe47RYoUwYEDB/Dpp59i8+bNem1TokQJbN68GeXKlTOpbABo3bo16tevj7Zt2+LQoUMm51e1alVs2bIFnp6eBm/r4+ODmJgY1K1bF5cvX8bo0aONqkOdOnVw8OBB1KpVy6DnulhLeyZS2oMHD3Re582bF2XKlMGVK1csVCP51alTRxB7+PCh5PsrVqwoiJ05c0bWOqnBmDFj4O/vn/E6JSUFHTp0wMuXLy1XKT0Z+p0qSU11IbImH44/DRnby0FsLTY51w2PjY0VxKTORT5cw9vNzS3L/J2cnARrRUqNpbNnz46IiAg4OTllxJ49e4aOHTuavKYdEVkfLY8hDcX+l0g+nHvInKXHvpZWo0YNdOjQQScWGxtr1Prw165d03muUuHChZEnTx48fvzY6Pr5+voiW7ZsOrGrV68anZ8x3j9WAP99TiKShzX3wYYem+QY/3LsS0SWUL58eYPGSzVr1hTETp48KWudTp06hXr16unEqlevjt27d+vEOPdARERERERERERERERERERERERERERERERERESkbttnAXlKArkKGr7tvsXAQ/MuUWGVJkyYgBYtWqB27dqCtJ9++gm7du3ChQsXFCvfw8NDMs3V1VWxcrUsMjISycnJcHZ21om3bt0aw4YNk9wuJCREENu0aZMgtnfvXsTFxcHLyysj5u7ujqZNm2L79u2iedetWxd58+YVxCMiIiTr8z6p/UBsXUm5vHjxQjT+4Vo4hnr16pVJ2xtr8eLFBr3/999/x6FDhzS5TlVKSoqlq5DBxcVFNP7hb93lpmTbMJU19lFiKlSogO7du6Njx44oWrSo0fnIJTk5Ga1bt8aOHTtQrVo1g7b18PBA5cqVUblyZZ3427dvsW/fPqxcuRJr1qxR3dpBavsOzEnOY40WxmKWGCcYwlL1U2osA8izj1nq76L0MZhM8/r1a8XyltpvjXkWlKns7e0RHh4Ob29vnXhaWho6d+5s0vqd5nTlyhVF1+bcuHEjBg0aJIiXLl0arq6uePPmjWJlvxMQEICRI0cK4omJiWjfvr3o+Kd///6C2MKFC/X6W126dAlLlizBF198Ichz0aJFBtTcOFJ9s9LnsUr1za6urmjcuLEgnpiYiP379xuUl7X9beSitTG3muYLAPH9ytbHQqtXr8bhw4fxv//9DwEBASbnl5ycjOnTp2PixIlISkoCIP4cHAB6HVfs7e0xZcoU0bQ7d+7A399ftuP4s2fPEBAQgKNHj6J48eKC9ClTpmD16tVIT0+XpTx92NpxUczDhw8RHR2NVq1a6cTz5cuHFi1aYOvWrVnm0a5dO9HzaUPnbz8k53FPiti6ymr47JZkK3Od1kxt4wMl2OLcsCnMMbeq1XlBtbUXXoMjIiIisl72Wb+FiIisxcsHwJIBQPSM/374IXbdI/kNcO0IsHwwsO1XIFVdcxSKev78OQ4cOCCIBwcHZ/x/7ty5RR8GFh0dbXL5Fy9exJ07dwTxZs2a6UyMv1+f923YsMHkOhCR/qQekpo7d24z18S6ffvtt5ITxb179xZcVCGgatWqkjdbpKeno3v37nj58mWW+bx48QLdu3eXvFGibdu26N27tylVtZiCBY345ayBpPqC58+fK172+7799lvR+OXLl1GlShWsWbNGlgd8fniDLulP6uYnHx8fxcuW+t6ePn2qeNlk25KTk3H27FnMnTsXjRs3RkBAAJ48eSL63qJFi6JTp05mrqHhtNTf3r9/X7G8zenly5f4+OOPERkZmen79uzZg+nTp4um2dnZYenSpaI3f9kaqTkRgPMituzZs2eicaX7iyJFiggeZG8MaxlnrVu3TjTepk0bnde1a9dGnjx5dGLPnj3DkSNHsixD7IZab29v1KlTJ9Mys6qjOal9fKH19mQN82CXL1/GwYMHBfHs2bOL7tvOzs6i+8mNGzewZ88eo+pgDX9HY1hLf/whtc8v2er+ZmlqPx4B2jkn1NJ5NunSyj5mCVrqm9kG9ael71Vpffv2tXQVBHx9fdGsWTNLV0N21tJG1T6mzorW628pWhkrWEs70xpLzSHwurl81H5ezHlabVPz/iW1iHitWrUUK1PJvLVCa21C632QNbLW6xdak5aWJpmmxKK15jiXszVsS0TaG5eYg7Xe78Q+z7I4ppaPms+xlcD53sxZYl5Dzvxt/Thsa+3ZVLymTaZIT0/Hvn37RNPq16+PfPnymblG6mTrcz1y98u2fpxTO7XfN2LL42C2RSIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIuuRkJAguQ7cO1988YXkc26V0KxZM0RHRyNHjhyy5TlmzBiMHj1atvz0de3aNbOXKQcPDw/s2LFDsJ6hoapUqYLZs2fr/f6aNWti586dsq1B6OLigrVr16Ju3bpZvrdo0aI4ePAgypUrJ0vZwH9rKe7cuRMNGzY0KR8vLy9s3rzZpDVmsmfPjtWrV+Prr782qS5ly5Y16Du1pvZMpLT9+/cLYta0rxcrVgxNmjTRiT158gR3796V3KZUqVKC2KVLlzItx8nJCXnz5kXx4sVRqFAhZMuWzbgKm0njxo0xceJEndioUaNw7NgxC9VIf8Z8p7ZQFyJr8+EYNDEx0azli63n5urqKlv+bm5ugliuXLlE3/vhGnX6nC99+J7k5GS8fv1a9L1hYWEoVqxYxuv09HR0794d//77b5blEJFt0fIY0hjsf4nkw7mHzFl67GtpP/30E+zs7HRiU6dOlXyWTWZ2796t89re3h6ff/65SfXr06dPluWY286dOy1aPpE1sdY+2Jhjk6njX459ichSevbsKYhlNl6qVKmSIHbu3Dk5q4SzZ88KYhUqVBDEOPdARERERERERERERERERERERERERERERERERESkbknxwLpvgOf3DNvuWARwfJ0ydbI1qamp6Ny5MxISEgRpLi4uWL16NZydnRUr/8N1UShrsbGxiImJEcRLlCgh+pvbdz58HsGbN2+wY8cOwftSUlKwbds2QTwkJEQy7zZt2ghiiYmJiI6Oltzmffb29qJxsXUr5SKVt6n7ZGxsrEnby2nXrl1o1aoV0tLSBGnu7u4IDw9XtH3bsvT0dEXzF/tO1cIa+6j3FS1aFKtWrcK5c+cwcuRIFC1a1OA8lPLs2TPUq1cPc+bMkaX/dHR0RPPmzbF48WJcv34dvXr1kqGWplPzd2Auch5rtDAWk6qjkuMEQ1hiHJNZ/nJ8p3LsY5b63t6+fato/mQaJcdISrYJQ02aNEn0eVYTJkzAnj17zF4fYym9LufBgweRlJQkiDs4OKB06dKKlg0ABQoUwPLly0X3kYEDB+LChQuCeK5cuUTX2FqxYoXe5a5cuVIQq1q1KrJnz653Hsaytr65SZMmos+22Lt3r+i+lRlr+9uYimNueYjtV7a6T73v9u3bCAwMRIMGDRAZGWlUnWNjY/Hbb7+hbNmyGDdunE6b1/eZNGL8/f1RpEgR0bR+/frh4cOHBtc1M48fP0a/fv1E04oWLQp/f39Zy8uMLR4XpcyfP180LrYup5iuXbsKYnfu3DF5zXU5j3uGsvRntyRrn+sk62Erc8NykHNu1RrnBbXAlq/BEREREVkL8ZE0ERFZrfQ04PwOYNkg4I+OwIohwPrvgYhxwJIBwKxPgQ0TgAdXLF1Ty9iwYYMg1rJly4z/9/f3F52IkmtSWGyS2t3dHY0aNQLw36RTYGCg4D3p6emIjIyUpQ5EpJ9798R/eVemTBkz18S6PX36FJMnTxZNs7e3x8yZM81bIZVzdXXN9IeH06dPN+imyd27d+OXX36RTJ81axZ8fX0Nrqel5c+fHzly5FAsf29vbxQsWFA07erVq4qV+6EyZcqgXLlyomm9evXCs2fPZCvLx8dHtrxszcWLF0XjNWrUULRcFxcXyRstxG5MIlLS9u3b4efnh8TERNH098/J1Ehr/a3UOLZKlSom521Oe/fuxaFDh/R677hx43DixAnRtDx58mDZsmVyVk2zxOZEAM6L2DKpsWvVqlUVLVeucwxrGWdFRESIxlu3bq3zulWrVoL3bNmyRa+br/bs2YP4+HhB/P2bZ+3s7ETLuHDhAi5fvpxlGeamtvGF1tuTtcyDSf0woXfv3oJY69atkTNnTkF8wYIFRpdvLX9HQ1lLf/whtc8v2er+pjZqOx4B2jgn1Np5NunSwj5mKVrpm9kGDaOV71VpHh4e6NKli6WrIUrqR+NaZU1tVO1j6qxovf6WooWxgjW1M62xxBwCr5srS23nxZyntS5q2r8uXbokGi9YsCAKFSqkSJl169ZVJF8t0Vqb0HofZI2s9fqF1mS24IwSC56ZY0FVW8O2RKS9cYk5WOv9TuzzLItjauWo6RxbbpzvzZol5jUA+eY2eBzWZc3t2VS8pk1ykPrdjL29Pbp3727m2qgT53p0mdov8zinbmq+b4TjYF1si0RERERERERERERERERERERERERERERERERERERERNqVmJiIL774Isv3LVy4EN7e3orXp0CBAlizZg0cHBxkz/uHH35A/fr1Zc83M9euXTNreXLJmTMnSpQoIUtevXr1QsOGDbN8n4+PD7Zs2QJ3d3dZyn3H1dUVK1asgJubm+R73NzcsHXrVuTPn1/Wst+VHxUVhaJFixqdR/bs2SXXyTBE1apV8fPPP5ucT/fu3VGvXr0s32dt7ZlIadu3b0dycrJOrGfPnujTp4+FaiSvX375Bfb29joxqbXH3ilQoIAgdv36dZ3XDg4OaNOmDcLCwnDt2jW8efMGDx8+xM2bN3H37l28evUKL168wL59+zB69GjZjm9y8Pb2xurVq3X6ycjISPz6668WrJX+jPlObaEuRNbG09NT57XUemNKEVuDUc712fLkySOI5cqVS/S9H65RJ7Wu+fsqVqyo81rqHPGrr75C27ZtdWIzZsxgX0ZEAlofQxqD/S+RfDj3kDlLj30tyd/fH82aNdOJ/fvvv5g5c6ZR+a1atQopKSk6sXHjxhn9/Jv69etjyJAhOrG4uDisW7fOqPyMUbNmTZ3Xd+7cwdatW81WPpG1s9Y+2Jhjk6njX459icgSatasicGDB+vEshov5cyZUxD78DqgqcTyEyuXcw9ERERERERERERERERERERERERERERERERERETq9/IBsHwIcHEPkJ6e+XvjnwNRU4F9i81SNZtx48YNwW9K36lUqRJ+/PFHM9eIshIRESEab9OmjWi8cuXKKFKkiE5s165dkutAREZGCmIhISGS9WndurUgtnXrViQkJEhuY63Ss+rIzCQ8PByBgYGIioqSXL++SpUq+Omnn8xcM+si9X1/uC6J3JycnBTN31TW2kf5+fnh9OnTCA0NhZ2dnUHbvvP8+XMcO3YMK1asQKdOnVCjRg0cPXrUqLzEJCUlYcCAAShfvjyWLFkiuv6vMQoUKIDFixdj1apVcHFxkSVPY8j9HYwfP16R70FpajnWkPXiPkZkvBYtWmD06NGC+O7du/HDDz9YoEZZS0pKEo3fuXNH0XJTUlLw8OFD0TSx9aTkZG9vjzVr1og+s2/lypVYvFh84ql+/fqCMcibN28MGkccPHhQsK6rvb29Xs8LI12BgYGi8W3btpm5JtaFY24yl8OHD6N169bw8fFBly5dMGfOHBw4cAD37t1DbGws0tPT8fbtW7x48QI3b97Etm3bMH36dPj7+8PHxwdDhgzBrVu3BPmKPacGAB49epRlndq3by8aP3jwoGJrDG7fvh379+8XTevQoYMiZX6Ix0VdW7duxb179wTx1q1bI0eOHJlumy9fPsF68ACwdOlSk8+zzHXcU+NntzRrnesk62Ptc8Ny0XqfZEt4DY6IiIjIejlaugJERGQ5ibH//aP/s3HjRvz22286sYIFC6JKlSo4c+YMgoKCBNukpKRg586dspS/ZcsW0YceBwUFYdeuXahbt67oRaTjx4/jwYMHstSBiPRz/vx50Xjt2rVhZ2fHCXAZzZw5E/3790fRokUFaR999BFCQkIQFRVlgZqpzy+//IKyZcuKpp06dQrjxo0zOM8xY8bAz88PVapUEaR5eHhg9erVqFevHt6+fWtw3pZUq1Yt7NixQ5G869atK5n24YM8leTn5ycaP3funOw3jtWpU0fW/GzJhQsXROMFCxZEkSJFFLt5uFatWnB2dhZNu3jxoiJlEmXm7NmzmDt3LoYNGyZIa9y4sQVqpD+t9bdnz54VjZcsWRLe3t54+vSpyWWozdu3bxEaGopTp07Bw8NDkO7v74/hw4djxowZFqideojNiQCcF7FlV65cEY0XK1YMefPm1etmcGM0atRIlnysZZx14sQJ3Lp1C8WLF9eJlyhRAhUqVMj4nMHBwYJtN23apFcZKSkp2L59Oz755BOdeHBwcMZ5ZN26dUV/GCB1U68aqGl8ofX2ZC3zYGvXrsWsWbMEN+L7+fmhYMGC+PfffzNivXr1Emz/9u1bLFmyxOjyreXvaChr6Y+lylDr/JKt7m9qpKbj0bv6iFHTOaHWzrNJlxb2MUvRSt/MNmgYrXyvSgsNDYWXl5doWvfu3fHs2TPF6zBhwgTUrFlTEG/dujXy5MmDx48fK14Hc7C2NqrmMbU+tF5/S9DCWMHa2pmWWGIOgdfNlaem82LO01oftexfR44ckUxr2bIl5s2bJ3uZLVu2lD1PrdFam9B6H2SNrPn6hZa8ePFCMi1fvnyyl8cxuPzYloi0Ny4xB2u934l9nmVxTK0stZxjy43zvVmzxLzGu7zlwOOwkLW2Z1PxmjbJYe3atfj9999Fx2aDBg3CL7/8YvbfWefPnx8HDhzAsmXLEBYWhrt375q1/A9xrkfIlH6Zxzn1U+t9IxwHC7EtEhERERERERERERERERERERERERERERERERERERERaVdkZCQWL16M3r17S74nb968WLBgAdq2batoXRYtWgQfH58s3xcbG4uTJ0/i6dOncHBwQP78+VG9enXJdeUAwNHREQsWLECFChXkrHKmtPzsCzkNHz4cBw8ezPQ9s2bNEl3fUA4lS5bE0KFDMWXKFNH0qVOnoly5coqUDQA5cuRAWFgYmjVrplgZ5jZkyJBM11kDrK89Eynt4cOHWL58OT777DOd+Lx581CnTh2MGzcODx8+tFDtTDNy5EjRMcTcuXMz3e7DPiQxMVFnLbLu3btj0qRJKFy4cKb55MiRA40bN0bjxo0xefJk/PnnnxgxYgRu375twKeQl52dHVauXIkCBQpkxG7fvo0ePXpYrE6GMPY7tfa6EFkjDw8PndeJiYkZ/1+kSBHUrVsX5cuXR8GCBeHl5QUXFxckJiYiLi4ON27cwIULF7B//37ExcUZVf6LFy+QkJCgU4+qVasalZcYsbxcXV1F37t//3506dIl43VwcDB+/vnnTPP/cI1gsfOiGjVqYPr06Tqxo0ePYsyYMZnmTUS2R+tjSGOx/yWSD+ceMmfpsa8lTZs2TRAbP3483rx5Y1R+9+7dw7x58zBw4MCMmLu7O3bu3Inu3bsjOjpa77zatm2LJUuWwMnJSSc+ffp0vHz50qj6GSowMBArVqzQiY0cORKpqalmKZ/IFlhjH2zsscnU8S/HvkRkbu/GSh9e389qvJQ9e3ZB7NWrV7LWLTY2VhDLkSOHIMa5ByIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIm1Iigc2TwOOrwPKNwOKVQO8vAEnV+D1S+DJP8D1o8DFXUBKkqVra50WLVqE4OBgtGnTRpA2ZMgQREdHY+fOnbKXm56eLhp/+fIl1qxZI3t5Up49e2a2suSwadMmJCcnC34L3KZNG0yePFnw/uDgYNE8pERHRyM1NRUODg4ZsSJFiqBChQq4cOGCznvLlCmDMmXKCPJYu3Ztlp/jHanfLzs6Ouqdh6E+XPcmq7poyR9//IFBgwZltK9vvvkGzZs3R82aNQXvHTx4MGJiYgxaO4j+z+vXr0Xj2bJlU7Rcsd/Xq4m19VHAf2swREVF6ZQpJT4+HlevXsXVq1dx7do1nf++ePFC8H5j1wTLzNWrV9GrVy98+eWXaNq0KWrVqoUaNWqgbNmyKFGiBFxcXIzKNzQ0FF5eXggJCZG5xllT8jsAlPketEALY7G0tDTRuJLjBENYYhwDqH8sI1UPqXrLRen8rZmdnZ3iZTg5OSElJUWRvKWeg2TONlGgQAGsWLFC8Ld8+PAhQkNDJftcS5M6Bj558kTxsh8/foyiRYsK4mLrWMnphx9+QKNGjQTxK1eu4Msvv5TcrmTJkoLY1atXDfpuU1NTcf36dcHz1EqUKKF3Hsay1DFVqb65RYsWovFt27YZnJe1/W2MxTG3vMSOQRwLCb18+RKrVq3CqlWrZMmvWLFiovEHDx5kuW29evVE40qfG0VERKBx48aCeN26dRUt9x1bPS5KSUtLQ1hYGMaPH68Td3FxQceOHTFv3jzJbTt16gR7e3udWHp6OsLCwkyul5zHvcyo8bNbmjXOdZJ1s8a5YbXivKCyeA2OiIiIyHqp40o/ERGRSty5cwenTp1CtWrVdOItW7bEmTNnRC8QHDx4ULaHOu7atUt0EjwgIADDhw8XnfQGgA0bNshSvhqY46YpMhy/F6FTp06JxrNly4Zy5crh4sWLZq6R9UpOTsaoUaMkbxaYMWMGtm7dirdv35q5ZurSsmVL9OvXTzQtMTERnTt3NuqG0ZSUFISGhuLkyZNwdXUVpNesWRMTJkzAuHHjDM7bklq0aIEdO3YokneTJk1E40lJSWbtG6Ru9jh+/LjsZTVt2lT2PMVY4/Ho0KFDkmnNmzdX7EaPZs2aicaTkpJw8uRJRcokykpERASGDRsmiOfNmxd2dnay3fwvd1+itf72xIkTkmmNGjWyqvPL9127dg2DBw/GwoULRdOnTp2KvXv3Zvr3sXZScyIA50VsVVb9xbp16xQp9+OPP5YlH2saZ61btw4jRowQxFu3bo0LFy6gcOHCqFy5sk5acnIyYmJi9C5j06ZN+OSTT3RilStXRuHChXH37l20bdtWsm5qZq7xRVa03p6sZR7szZs3WLlyJQYMGKATt7e3R/fu3TF16lQAQL58+eDv7y/YPioqCo8ePTK6fGv5OxrKmvrjD6l5fslW9ze1UsvxCNDGOaHWzrNJlxb2MUvRSt9srW1QqesLWvlelSb1w+eDBw9i+fLlZqlDnjx5RMeWTk5O6N27N3788Uez1ENp1tZG1Tym1ofW628JWhgrWFs7e5/ar7dbYg6B183NQy3nxZyntU5q2L/Onz+P+/fvo0CBAoK0r776KtOFYYzh5+cHX19fWfPUIq21Ca33QZamxDjGmq9faInU4ogAUK1aNfz555+ylZUjRw7UqlVLtvzoP2xLtknt55fmprVxiblY4/1O7PMsi2Nq5anhHFtu1jzfKxdzz2sA8s5t8DgszhztWWtjQl7TJjm8ePEC0dHRog+TLViwIAYMGIDffvvNrHXq27cvSpYsiQkTJuC7775DTEwM5s+fj6ioKIv85p5zPeKM7Zd5nFM/td43wnGwOLZFIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIi7Ro8eDA++ugjFC9eXPI9bdq0QY8ePbB06VJF6lCtWjUEBARk+p4nT55g6NChWLNmDVJTU3XSvLy8MHLkSIwdOxb29vai25cvXx6BgYHYunVrRuzevXs4ePCg4L2enp6oWrWqZF3S09MzXUMPgFWtZ7d9+3aEhYXh4sWLSEhIQJ48edCsWTMMGzYMuXPnznTbVq1aIUeOHHj58qVoerVq1dCpU6cs6xAbG4tFixZh+/btuH37NlJTU1GsWDEEBgaib9++cHNzk9y2V69emDJliiBesmRJDBw4MMuyX7x4gQULFiAmJgb37t3D27dvkS9fPjRu3BhffvklihYtmun2H330EVq1aoXIyMgsy8rK27dvsXjxYqxevRq3b9+Gu7s7qlatiq+//jrTffZDiYmJ+OOPP7BhwwY8ePAA2bJlQ7169TBq1KhM+wIAaNeuHdzc3JCYmCiabqn2TKR1Y8aMQUBAAAoWLKgT7927N7p164bt27djx44dOHbsGM6dO2ehWurPzs4OEyZMwPjx4wVpa9aswbFjxzLd3sPDQ+d1fHw8gP/Wplm9ejWCgoIMrpO9vT3at2+PoKAgDBgwQLFxTVbGjBmj81znlJQUdOjQQfJYqRamfqfWWhcia/ZhX+zu7o5Ro0ahR48eKFeunF55vH37Fjt37sTvv/+O6Ohog+tw9uxZ1KtXL+N1kSJFUKFCBVy4cMHgvD4UEhKi93vXr1+P3377Da6urgCAxo0bo2HDhqLnkwCQL18+9OrVSye2YsUKndfZsmVDREQEnJ2dM2IvXrxAx44dLbLmJRGpm1bHkKZi/0skL849SFPD2NcSOnfuLJhXvnDhgslzJqNGjYKfnx/Kli2bEcudOze2bNmCHTt2YNGiRThw4ADu378v2LZQoUJo1KgRPv/8c9FnCv3111+i8/1ysbe3R5EiRVC/fn307NlT8FydBQsWIDw8XLHyiWyRNfXBph6bTB3/cuxLRErLaqwE6Ddeyp49uyAWFxcnWz2l8hMrl3MPRERERERERERERERERERERERERERERERERERE2vL4xn//yDI+//xz1KlTB/nz59eJ29nZYenSpahUqRKeP38ua5lv3rwRjcfHx6Nfv36ylmVNYmNjsWPHDrRs2VInXqNGDRQoUECw9kurVq10Xqenp2Pz5s2S+T9//hyHDh1C48aNdeIhISGC9SJbt24t2P7NmzeZ5v+hd2sTfyhHjhx652GoXLlyicZjY2MVK9Mcxo4di6lTp+rE3r59i9DQUJw+fVqwFggALFmyBJUrV8bDhw/NVU2rkZCQgPT0dNjZ2enEXV1d4erqKtnHmUrJtiEHa+ujihUrhlWrVsHBwUE0/dmzZ/jzzz+xY8cO/PXXX7h9+7beeQMQ7D9ySk5ORkxMDGJiYnTKK1SoEHx9feHr64tSpUpl/L+vr2+mzwUBgODgYIwdO1bR9cI+pPR3ACj7PaiZFsZiUnUUW2vEEiwxjgHUP5ZJSEgQjSv9vYmNdUg/WfX/csiePTuePn2qSN5SbU6qjSohPDwc3t7egriHh4esz9fw9PQUjU+ZMgVjxowRTRs9erTk2lHPnj0TjUu1YzlJleHo6KhYmR9//LHo3+nNmzdo3759pp9b7DluDx48MLgODx8+FKzFKNWvy0mqPWixby5SpIjOurjv3L59G1evXjU4P2v62xiLY275ifUntrRPWUrp0qVF41euXDF626yeZ2qqw4cPi8al6iMnWz4uZmbhwoUYN26c4BmbPXv2xLx58yS369q1qyC2f/9+3Lp1y6T6yH3cy4zaPrsaWNtcJ9kOa5kbVjPOCyqL1+CIiIiIrJd91m8hIiKyLevXrxfEQkJCULNmTfj4+AjS5HyQY0JCguiDvMqXL48iRYogODhYdLuNGzfKVgdzSUlJEY27u7ubuSb0Pn4v+jt+/LjkBdwuXbqYuTbWLzw8XPKmv1KlSmHAgAFmrpG65MmTB2FhYZLpw4YNw+XLl43O/9KlSxgxYoRk+ujRo9GoUSOj87eE0NBQwYV4Obi4uKBHjx6iafv371fsgooYsXELIH2TqrEKFCiAevXqyZqnLR2P7t69i3PnzommffXVV4qU6eTkJPnjlL1795rlhmUiMVI3FTo4OBh14dhcfYnW+tuTJ09KLkzw5Zdfmpy/mi1atAh//vmnaJqTkxPWrFlj8zf+is2JAJwXsVUnT56U/NGZUv1FuXLlULduXVnysqZxVkREhGi8TZs2AP5rox/as2ePQT/ii46ORlpamiD+7mZdsRtmL1++jIsXL+pdhiXIPb4wltbbkzXNg82fP1803qtXr4z/79q1q+iPuaS21Zc1/R0NYU398YfUPL9kq/ubWqnleARo45xQa+fZpEsL+5ilaKVv1nobNPf1Ba18r0qqVq0aatasKZq2cOFCs9UjIiICcXFxoml9+vSxmkUVtN5GP6TmMbU+tF5/S9DCWMEa2plWr7ebew6B183NRy3nxZyntU5q2b+ioqJE4xUqVECLFi1kLWvYsGGy5qdVWmsTWu+DzMWc4xhrvn6hJW/fvsWjR49E02rVqiVrWd26dZNc0JGMx7Zk3bR6fmluWhuXmIs13u/EPs+yOKZWnlrOseVkDfO95mDOeQ1A3rkNHofFydmerWFMyGvaJKcZM2ZIpn3//fcoUKCA2eri4+ODgQMHZry2t7dHQEAA1q9fr/ji/VI41yPO2H6Zxzn1U+t9IxwHi2NbJCIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIi0q74+Hh069ZNdP25982aNQtFixZVpA6jRo3KNP3JkyeoU6cOVq5cidTUVEF6XFwcxo8fr7NmiJghQ4bovF61ahUaNWok+Ce1NsE7SUlJotu9/+/YsWOZ5qEFr1+/RqdOnRAQEIDw8HCcO3cON2/exNGjRzFlyhRUrFgR169fzzSP/8fefUdFcbVhAH/oSrd3RcUSe8HeC/YWY9fYImiMJfbYYuwaS9TYYpRYQcGKYu8KKvZKwN4VEUGKdL4/cuRz3dlly2yZ3ed3jue4986894XduXPnznDX0tJS6RoK48aNyzaPEydOoFSpUhg7diyOHDmCf//9F/fv38exY8cwduxYVK1aFa9evZLbLyIiAiNHjkT16tUF406aNCnbdVYOHTqEUqVKYdKkSThx4gTCw8Px8OFDBAcHY/78+ShTpgxWrVqV7c8wZcqUbLfJztu3b1G/fn0MHToUp0+fxuPHj3H37l1s27YNtWrVwtGjR1WKExERgSpVqmDixIm4cOECnjx5glu3buGvv/5CtWrVcOfOHaX7W1tbK1x7CjDc8Uwkde/evUOXLl0E17KxsbFBhw4dsHz5cly8eBHx8fHIkydPVr2npyfq1auHXLly6TNlhdzd3XHixAlMnz5dru7+/fv46aefso1ha2sr8zohIQGOjo44fvw42rVrJ7hPbGwsnj17hsjISMH+5TMHBwds3LgR06ZNyzYPsTVu3BizZs2SKZswYQJCQ0P1nos6xHhPTTEXIlOWM2dOubXgtm7digULFuCbb75ROY61tTXatGmDoKAgnD17Vq19AeDw4cNyZZMnT1YrhpDKlSsrPJ8IiYqKwoYNG2TK/P39UbNmTbltixcvjqCgIDg6OmaVXbhwAefPn5fZzsfHB6VKlZIpGzhwIJ49e6ZyXkRkHqQ6hhQD+18icXHuQZixjH31zcbGBnPnzpUrnzRpUrb3i7KTmJgIT09P/Pvvv3J1np6e2L59O16+fImYmJisee4nT54gNjYWz58/h6+vL5o3by637/Xr19GuXTukpaVpld/27dvx4cMHuX8fP35EWloaHj9+jG3btsHT01Nmv9WrVxvN94MTmQpT6oPFODdpO/7l2JeIxKDpWAlQfbz0Zd/1WWJioij5fyb0nZ1OTk5yZZx7ICIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIlLd+/fvMXDgQGRmZsq3DsPXAAEZFElEQVTVFS5cGH///bfobSYmJgq2lzt3btHbMjX+/v5yZRYWFujUqZNMWb58+VC7dm2ZsqtXr+L169dK4wcGBsqVdezYUa6sS5cucmVHjhwR/JtgRZKTkwXXnbG2toaDg4PKcdShaL2luLg4nbSna+np6fjhhx8wf/58wfoHDx5g5MiRgnX58uXDli1bdJmeSYuKihIsL1iwoE7ac3BwMJr1wpQxpT5q3rx5cHV1lSuPj4/HyJEjUbhwYQwdOhQ7d+7E06dPVY77mdA6DbqUmZmJ58+f49SpU/j7778xceJEdO3aFVWqVIGDgwPKlSuH0aNHIywsTGGMyZMn6/Vcrev3AND/+2AspDAWU5SjjY0NcubMaYCMZBliHAMY/1gmKSlJcN1Da2tr2Nvb66xdFxcXncU2Ntl9H5O6hNbvEZtQX67r2Oqc87XVsGFDwXInJye4ubmJ9i9v3ryC7eTJk0fhPorGrADw4sULwfKvv1NGF+zs7ATLU1NTddJewYIFsXXrVlhYWMjVjR49Grdv31a6v1Dfq8lnTGifL9cJ1hVFfbONjY3k+uY2bdoIlgt994UqTOl3oymOucUn9LniWEj3FH2fZXh4uNL9nJ2dFY6vhL4/U0yK5kCsra11OkYz9/OiMs+ePcOxY8fkyuvWrYuyZcsK7lO2bFnBdS59fHy0zkfs854yxvazGwtTmusk8ybFuWFjxnlB3eM9OCIiIiLTZJn9JkREROZl7969cmW1a9fGgAEDBLc/ePCgqO0rijd06FBUqVJFrjwiIiLbm2/G6MOHD4Llhr4xZe74vqguNTUVx48fF6wbMmQIbGxs9JyR6RszZozCuhkzZpj1DZONGzciX758gnVBQUFYu3at1m2sXLkShw4dEqyztLTE1q1bJfWgTOHChdG7d2/R4/bt21fhe6Ho96crQg/8AxD9xtnEiRNF7/PM7XwkNP4E/nvwqnnz5qK3169fP4U3+Pbs2SN6e2Q6cubMiTFjxmDChAk6ia/sS5Y1+WMNffUlUutvMzIyFF53tmrVCuXKldO6ja8Z0xjBy8tL4R9suLu7Y9WqVXrOyLgoOidxXsR8HT16VLC8ZcuWqFSpkujtjRs3TtR4pjLOunLlCp48eSJX7uHhgcKFCws+4Lpv3z612nj//j1CQkLkyjt27Ihy5coJPrQcEBCgVhtCpDa+0IaUjydTmge7desWLl++LFdepkwZ1KtXDwAwaNAgufpnz57hyJEjWrVtSr9HdZlKf/w1Y55fMufPmybM6XwkhWtCqV1nkywpfMYMRSp9s9SPQX3fX5DK+6pLw4YNEyyPi4sT5bpRVYmJidixY4dgXcmSJeHp6am3XHRJ6sfo14x5TK0KqedvCFIYK5jCcSbl++36nEPgffP/M6frYs7T6p+5fL5Wr16tsO6vv/4SbbGi3r17o23btqLEkjopHhNS7oP0Rd/jGFO9fyE1Fy5cECxv1qyZwkVe1WVjY4PRo0eLEovk8VgyXVK+vtQnKY5L9MFUn3din2dY5j6mNpdrbDGZwnyvPuhrXgMQf25DqudhKR3PpjAm5D1tEtP58+dx/vx5wTpXV1f4+fnp7by5bNkyhX9Xv3XrVr3kIESKcz3G2i9L9TxnToz1uRGpjoN5LBIREREREREREREREREREREREREREREREREREREREZEywcHBWLRokdJtnJ2dsXnzZlhYWIjatrW1teAael/66aef8Pjx42xjrVmzBnfv3lVY36RJE9ja2qqdo7kaNmyYwrV9AODNmzcYMmRItnHq168vWG5jY4POnTsr3ffq1ato27Yt3r9/r3Cb+/fvo23btkhLS0NGRgaCgoLQunVrlCtXDitXrkR8fLzcPlZWVujWrZvSti9evIhOnTohJiZG4TapqakYMWIENm/erDRWnTp1ULJkSaXbKJOamoqOHTsKflcoAKSlpcHLywtpaWlK48TExKB169Z48OCBYP3Hjx8xfPjwbPOpXbu2YDmPZyLtXLlyBbVr18aVK1eUbmdhYSFzPh4/fjxCQkIQHR2NJ0+ewN/fHz/99JPCtXZ0JV++fPjjjz9w7949NGvWTK7+yZMnaNOmDaKjo7ONZWlpKfM6PT0d69evR61atbLKEhISsHz5cjRv3hw5c+aEq6srSpQogQIFCsDa2hrffPMNRo0ahX///VewjdmzZwt+x7Ku5M2bV249tX379mH58uV6y0FdYr6nppQLka7UqFEDhw4dUunf12NsT09PlfdV5bvsHB0d5cq0vRZs1KgRLl++jK5du6q8j5+fHzIyMmTK+vTpo9U6ozY2Nli7dq3cuSY7kyZNwv3797NeFypUCKGhoThz5gxWr16NFStWICgoCBEREahRo0bWdvHx8RgwYIBMrOHDh+O7776TKVu2bBkCAwNlyvLmzQtvb28EBAQgJCQE9+7dQ0hICPz9/eHl5SXaOpRE5s6Y+t+vSXEMKTb2v0Ti4tyDPGMZ++rb8OHD4ebmJlN25swZBAUFiRL/xYsX8PDwwPLly5GSkiK4jYuLC9zc3FChQgWUKFECzs7OgtslJSVh4cKFqFevHqKiorTOzcHBAa6urnL/nJycFL73HTt2xE8//aRwfWoiKTGm8a8p9MFin5u0Gf9+iWNfIuNjTP2vMpqMlZ4/f67WeEkoztfzwNoSiqcof849EBEREREREREREREREREREREREREREREREREREanu6NGj+PPPPwXrunbtioEDB4raXnp6Ot69eydXbm9vjxw5cojalqnZt2+f4NovXbp0kXndvn17ub/F3bdvX7bxv/4bWgCoW7cu8uTJk/W6QIECqFu3rtx2/v7+2cb/2suXLwXLCxYsqHYsVSiK++bNG520p2tdu3aFj4+P0m3++ecf7Ny5U7CuZcuWmDBhgi5SM3nh4eGC5YrW+teWh4eH2muuGoKp9FFubm7o2bOnXHlycjJatmyJlStXKlyHS1XGtAZBZmYmIiIisGLFClSsWBEzZ84U3M7R0VGl7zERgz7eA8C43gd9ksJYLCMjA2/fvhWsK1CggJ6zEabvcYyy2MY0ltH3+5YjRw6d/s4NJT09XbDcyclJ1HaKFSsmajwhujxmFcUWY41LU/Do0SOFdYq+40ofa9IqauPDhw+it2VpaYnt27cjf/78cnU7duzAunXrso1hbW0tV5aamqp2LsnJySrF1gVFx4TQ70UMuuqb27RpI1h+6NAhjWOayu9GExxz647QeIhjId1xdHRExYoV5cqfPXuW7ZhA2fWP0Hdkiunjx48K63LmzKmTNnlezJ6i34GieyT9+vWTK4uLi1M4H6sOXZz3lDGmn91YmMpcJ5Eyxjg3LAWcF9Qt3oMjIiIiMk0ccREREX3lzp07ePjwoUyZpaUlhg0bJrft8+fPce/ePVHbV3TDYdy4cYLle/bsEbV9fVH0RZPVq1fXcyb0Jb4v6tm0aZNgef78+fHTTz+J3t6ECRMwfvx4o7iBawgXLlxAQECAYF2uXLnw22+/6TchIzFixAi0bdtWsC4yMhKDBg0Sra2BAwcKPugOAMWLF8fatWtFa0sf5s+fL+rDv/ny5cPs2bMF65KTk7FlyxbR2lKFoodz3N3dRWvD3d0dXl5eosX7zNzOR2vWrFH4QOCaNWsEv4xcU0WKFMHChQsF66Kjo/X+OSVpyJkzJ8aOHYvHjx9j6dKlmDVrFkqWLCl6O4oe5szIyFD5i+q/pK++RIr97YYNGwTLLSwssHr1aoVfRq2JMmXK4PXr19i0aZPWXwAuhg8fPuD7779X+KXeAwYMQO/evfWclfEQmhMBOC9izv7++2+FdStXrhT1wZ7q1auLev0CmNY4S+ghYAsLC/Tp0wfNmjWTqztw4IDabQg9YNu8eXPBB5MB7R6Yler4QhtSP570OQ+m6zkwRQ/nDx48GB4eHqhQoYJc3YYNG5CZmal12+Y6n2hK/fHXjHl+yVw/b+owx/MRYPzXhFK8ziZZxv4ZMyQpjKmkfgwa4v6COZ9zHRwc0KdPH8G67du3IzExUa/5rF+/XmHdjz/+qMdMdEfqx6gQYx5Tq0Lq+RuCsY8VTOE4k/L9dn3NIfC++X/M8bqY87Tq0WbsaW6fr1u3buHMmTOCdSVKlMBff/2ldRtubm5YuXKl1nFMiZSOCUD6fZA+6HscY8r3L6Tk/PnzguU2NjYYMGCAKG2MGTMGpUuXFiUWyeOxZLqkfH2pb1Ibl+iLqT3vBLDPMzRzHVOb2zW2mExhvlcf9DGvAehubkNK52EpHs9SHxPynjbpwoQJExQ+U9y4cWP8888/Os/h559/VvjZ/vDhg8J7svogpbkeKfTLUjrPmStjfG5EauNgHouyeBwSEREREREREREREREREREREREREREREREREREREREpNn36dNy8eVPpNo0bN1b4/bea8vDwgL29vcL6J0+eICAgQOV4ytbFs7Ozg4eHh1r5mauTJ0+qtBbDmTNnEBYWpnSbggULCpY3atQo23UGf/zxR6Smpmabx61bt9CrVy+UKVMGHTp0wNGjR5Vu36BBA+TKlUvpNsOHD0daWlq2bQPA6NGjs113qWPHjirFEuLn54fLly8r3ebZs2c4deqU0m1WrFiBJ0+eKN3m3LlzePTokdJtFL2nPJ6JtPfo0SPUqlULffr0wZUrV9Tev0SJEujevTtWrlyJV69eYc+ePfjmm290kOn/ubi4YO7cuXj8+DF+/vln2NjYyG1z4cIF1KlTJ9v+RRE3Nzf07Nkz67W/vz+KFy+On3/+GadOnUJSUpLcPv/++y/+/PNPVKhQAV5eXvj06ZPcNitXrkSpUqU0ykkdFhYW2LZtGwoXLpxV9uTJEwwcOFDnbWtCH++pFHMh0rW8efOiTZs2Kv3Lnz+/zL5FihRReV8XF5dsc3FwcFBYFxMTg2PHjmH+/PkYMWIE+vbtix49euCHH37AhAkTsHXrVoXHo4ODA/z9/fHtt9+q9Du5f/8+du3aJVNmYWGBnTt3onbt2irF+JKNjQ02b96M+vXrq71vQkIC2rZtK/OzWVpaonHjxvjxxx8xcuRItGvXDnZ2dln1cXFx6NKlC+7fv59VVq1aNSxdulQm9pUrVzBx4sSs1xYWFpgyZQoeP36Mv/76C926dUO9evXwzTffoF69eujevTvWrVuHx48f45dffhH1uwmJzJEx9b9fktoYUlfY/xKJj3MPsoxl7KtPTk5OmD59ulz5hAkTRG0nT548yJs3L6ysrLSKY21tjXz58mU7p69LvXr1UrgGM5HUGNP4V8p9sK7OTdqMfz/j2JfIOBlT/yu2IkWKSHq8xLkHIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIvVMnDgRd+7cEaz7888/RV/r9dmzZ4LllSpVErUdUxMbG4vjx4/LlTdr1gxOTk5Zrzt16iS3TWBgYLbx79+/j/DwcJkyS0tLtG3bNut1x44d5f5mNjk5Gfv37882/tfu3bsnWF6nTh21Y6lC0ZqXd+/e1Ul7uqbKewoAXl5eeP78uWDd3LlzuS68BhR9j0PDhg110p6ujgmxmUof1a5dO1haWsqVr169GpcuXVI5jiKWlpZy61AYi8zMTPz2229YvXq1YH3r1q31koeu3wPAuN8HfZDCWOzp06eC5TVr1tRzJsL0PY4BpDGWiYiIECzX1XijbNmyJrmey4cPHwTLnZ2dRW2nXLlyosYToqv3vkiRIoLrI6WmpuLx48c6aVNK0tPTFV4DAMCNGzcEy4sUKaKjjP5P0fdjvX//XvS2fvvtNzRp0kSu/MGDBxgyZIjo7RkrRX2zrs6p5cuXF71vtrKyQosWLeTK09LScPLkSY3jmsLvRlMcc+uO0OeKYyHdad68OaytreXKg4ODs903MzNTYd2X6xTqgrL4GRkZOmmT58XsBQYG4u3bt3Ll33//veCx1qdPH7kyf3//bL/7NDu6Ou8pYyw/uzExlblOIlUZy9ywFHBeULd4D46IiIjINMnPRhMRERH27t0rVyZ04+vgwYOit33v3j3BhwgV3cTas2eP6Dnow61btwTLS5YsiSpVqug5G/qM74t69u/fr/BBsPnz56NChQqitVW7dm3MmTMHixYtwo0bN9CoUSPRYkvJxIkTkZKSIlj3448/6uXBS2NSoUIFLFq0SGH9wIED8e7dO9Hai4yMxODBgxXW9+rVC3379hWtPV0rVqwYtmzZIsoDPhYWFvDz80PhwoUF63fs2IGoqCit21GH0IMGANCkSRM4OjpqHT9HjhzYtWsX7O3ttY71NXM7H71+/Rq+vr6CdWXLlsU///wjSjs2NjYICAhAvnz5BOtXr15tUg+XkDj69OmDJ0+eYMmSJVl/IJAjRw7s3LlT9Af5GjduLFgeGRmp0YN7+upLpNjfnj59WuHvp3nz5pg6daoo7VhbW2PTpk3ImTMn+vfvj3v37sHf39/gffnp06eVjqHWrl2LkiVL6jEj4yI0JwJwXsRcnT59WuEDWU2aNMHs2bNFacfZ2Rk7duwQ/CMKbZjSOMvf31+wfPr06XLHx40bN5T+4ZoiQg/A5siRA2PHjpUrj4iIULgATnakPL7QhtSPJ33Ng+ljDszPzw/x8fFy5T179sRPP/0kV56RkQEfHx9R2jbX+URT6o+/ZszzS+b6eVOHOZ6PAOO/JpTidTbJMvbPmCFJYUwl9WPQEPcXzPmc26dPH4Wfi7///lvP2QCXLl1SeN3VoUMHFCpUSM8ZiU/qx6gQYx5Tq0Lq+RuCsY8VTOE4k/L9dn3MIfC++X84TyuP87SytBl7muvna/z48QoXS+rduze2bt0KKysrjWKXKVMG586dQ+7cubVJ0eRI5Zj4TOp9kD7oexxjyvcvpOT06dMK66ZNmya4qK06atWqJdrxRcJ4LJkuKV9f6pvUxiX6YkrPO33GPs+wzHFMba7X2GIxhflefdHlvAag27kNqZyHpXo8S31MyHvapAsXL17E+vXrFdZ///332L59u84W0B8+fDiWLl2qsP63334z6FhRKnM9UumXpXKeM2fG+NyIlMbBPBZl8TgkIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiJSLjU1FX379kVycrLS7ebOnYvKlSuL1q6iv1n/TGhdPGUUre3zWe3atdWKZ642bNig8rbnzp1TWp8rVy7B8ho1aijd7/bt27h8+bLKeezatQuPHj1SaduaNWsqrb9x4wauX7+uctsxMTHZfgd0dm0qo2itxq9dvHhRlDiXLl1SWq/oPeXxTCQePz8/1KpVC+XKlcPo0aPh5+eHBw8eKFzbUIi1tTW6dOmC27dvY+7cuaLn6ODggClTpuDJkyeYMmUKHBwc5LZJSUnBlClT0LBhQ0RGRmrc1pdrNs6ZMwc9e/ZEdHS0SvtmZmZi/fr1aNiwIT5+/ChTZ29vj4ULF2qcl6omT56MVq1aZb1OTU1Fjx49EBMTo/O21aHP91RKuRCZo5iYGBw4cECmLDAwEJ06dUK+fPnQqlUrTJkyBatWrYKvry8CAgLg4+ODxYsX4/vvv0fp0qXRoEEDwfGflZUVNm/eDHd3d5VyGTduHOLi4mTKnJ2dce7cOYwaNQrW1tYqxSlbtizOnj2LXr16AQDS0tKQmpqq0r6fPXz4EHXq1MHGjRuzXWPt5MmTqFu3Lk6cOJFV5uTkhICAAJm14GJjY9G9e/esXGxsbLBz507MnTs32/XtHB0dMX/+fOzYsUPl3wMRSYdUxpD6wP6XSDc49/AfYxr76sukSZOQJ08embKAgAC15uOz8+233+L27dvo27evVt/FAfz3ORs8eDDu3Lkjc27Up759++LOnTto2rSpQdonMlVS7IP1cW7SZvzLsS8RGYKlpaXkx0uceyAiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiJSXXJyMvr06SO4nr2joyO2bdum9ZojX7p9+7ZgeZ06dURrw1T5+/vLldna2qJNmzZZ//f09JSpf/78ebZrg38mtOZDx44ds/7fpUsXufqjR4/KrTGpijt37giWN2zYUO1Y2SlXrpzcGj3Af5/9hw8fit6eMYmJiUG/fv0E/+7axsYG27dvz/bvpUnWqVOnBMu7du0qal/5WZ8+fUSPqSum0Ecp+m6G7du3qxxDmZo1ayJnzpyixNKVX3/9FWlpaXLltWrV0kv7un4PAGm8D7okhbHYjRs3BMvr1aun30QU0Oc4BpDOWCY8PFywXFfvW5MmTXQS19A+fPggWF6yZElR29HH709X733dunUFyx8+fJjtekPm4Pnz54Ln8s8ePHiA9+/fy5Vn9x1V2qpevbrgtUdycjIiIiJEbat58+aYOnWqYFvdu3dHfHy8xrEtLCz0so9YFPXN9evX10l7uli3rH79+nB2dpYrDwkJ0Wg+4jNT+N1oimNu3RH6XHEspDs9evQQLP9yXUFFEhMTFdYVLFhQ45xUUahQIYV1CQkJorfH86Jq0tLSsGnTJrnyokWLonnz5jJlderUQenSpeW29fHx0ToPXZ33lDGWn93YmMJcJ5G6DD03LAWcF9Qt3oMjIiIiMk2Whk6AiIjIGO3evVul7Q4ePKiT9g8fPqzSdq9fv8alS5d0koOuBQcHK6ybPXu2HjOhL/F9UU9aWhpmzZolWJcjRw7s3bsXJUqU0Lqd8uXLIzAwELa2tgCAihUr4uzZs9i8eTPy5cundXwpefLkCVasWCFYZ21tjSVLlug5I8OxtbWFn58fcuTIIVi/atUqHDp0SPR2Dxw4gLVr1yqsX716Ndzc3ERvV1c6d+6MvXv3Cn5Rsqrs7e2xa9cutGjRQrA+JSUFc+bM0Ti+pkJCQgTLc+TIgcmTJ2sV297eHgEBAahSpUpWWXp6ulYxv2SO56OpU6cqfOCgW7du2L59u8wXt6orV65cOHr0qMKH5V68eIGFCxdqHJ9MV3x8PPLnzy9XXqNGDQQGBsLe3l6UdqytrTFu3DjBurt372oUU199iVT7W2W5zZo1S+vcLS0tsWnTJpl+x9LSEt27d8eNGzdQpkwZreJra9q0abhy5YpgnbOzM/z8/NR6EOLcuXPIzMwU/Ldnzx6x0tYLVedEAM6LmItff/1VYd2UKVMUXherytnZGQcPHtRZv2Aq46zLly/j6dOncuVCDzUHBgZq1EZ4eDju378vVy50vg8ICNCoDUDa4wttSfl40sc8mL7mwBISEuDn5ydX7uTkhIEDB8qVHz58GC9evBClbXOeTzSV/liIsc4vmfPnTVXmej4CjPuaUKrX2STLmD9jhiSFMZXUj0FD3F8w53PusGHDBMvv3LmDy5cv6zmb/6xfv16w3NraGj/88IOesxGf1I9RRYx1TK0qqedvCMY8VjCF40zq99t1OYfA++b/x3laYZyn/Y+2Y09z/XxduXJF6cIuffv2xYkTJ1ChQgW14vbp0wfnz59H0aJFtU3R5EjlmPiSlPsgfTDEOMaU719IxdWrVxU+w+Pq6oqNGzfCxsZGo9iVK1fGgQMHso5fAMjMzNQoFinHY8k0Sf36Up+kOC7RB1N63ulL7PMMy9zG1OZ6jS0WU5jv1RddzWsAup/bkMp5WKrHs9THhLynTboybtw4wXHoZz179sSlS5dQrVo10dp0cnLCtm3bsGrVKoWLx587d07h3+Dri1TmeqTSL0vlPGfujO25ESmNg3ks/h+PQyIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiItXcvXsXU6ZMUbqNra0ttm7dqvE6F18rWbKk0vpnz56hcOHCKv+ztrZWGq9AgQKi5G3qzp49q/K2jx8/VlovtE4igGzX3jp//rzKOairUqVKSuuVrRGl6T6arDX2marrOj179kxpfXh4uEpxnj9/rrRe0XvK45lIfBEREVixYgX69OmDMmXKwNHREbVq1ZJZv/Xdu3dK16qxsrLClClTsGPHDoXrbKnD1tYWo0ePxqNHjzB37ly4uroKbrdnzx5UqFAB8+fPR0ZGhtbtAoCfnx+mT5+u0b7Xrl1Dt27d5NbX+u677+Du7i5GeoIaN24st8bO+PHjDbZmnxBDvqfGnAuROYuJiUHHjh1RvXp1rFmzBnXq1EHnzp2xf/9+pKWlqRQjJCQEnTp1Qt++fZGcnCxT5+joiDVr1qgU5/nz5xgyZIhc/21ra4vly5fj4cOHmDp1KurWrQsnJ6eseisrKxQtWhS9evXCjh07EBYWhrp162bVz507F7GxsSrl8KWoqCgMGjQI7u7uGD16NLZu3Ypjx47h1KlT2L59O2bMmIGaNWuiRYsWuHfvnsy+69evlzvnDB48GE+ePMl6vXjxYnTt2lVmm9u3b2PZsmWYPn06li9fLhe3e/fumD9/vto/CxEZLymMIfWN/S+R7pj73IMxjX31oUCBAvj5559lylJTU7VeW/lL3bt3R0BAgOA88q1btzBz5ky0a9cOFStWRJEiRZA3b14ULVoUlSpVQocOHTB79mzBdY3z5MmD/fv3o3Xr1lrl16dPH+TJk0fuX/78+eHu7o5GjRph3LhxcnP+efPmxeHDh9GsWTOt2iei/5NSH6zveUtNx78c+xKRtjQdKwHSHy9x7oGIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIhIdbdv31a4nn3dunU1Xj9WSGhoqGB506ZNRWtDn6ysrPTW1t69e5GSkiJX3qVLFwD//Q4dHR1l6gIDA1WOv2/fPrmyNm3awNraGg4ODmjZsqVcfUBAgMrxv3Ts2DHB8g4dOoj+O/38+/namTNnlK7FZCrOnj2LhQsXCtaVLl0aq1ev1nNG0nbs2DG5NVUBoEiRInJ/g66tunXromrVqqLG1CVT6KMKFSokWB4WFqZWHEWaN28uShxdev/+PW7cuCFX7uTkBFtbW523r+v3AJDG+6BLUhiLXbp0SbC8Xbt2es5EmD7HMYB0xjLnzp0TLG/btq1O2uvYsaNO4hpadHS0YHmNGjVEa8Pa2hqtWrUSLZ4izZs318m5Q1FfoMvvxRJSp04dvfybPXu2YPu///674PYdOnRQmndmZiaOHj0qV+7h4aHT741q3769YPnNmzdF7csKFCgAX19fWFpaytWNHTtWcJyjiNDY1s7OTu2ccuTIoVJsXVB0XLRp00Yn7XXu3Fn0mIpyPXTokFZxTeF3oymOuXVHaDzEsZBuuLq64ttvv5UrT09PF5w/+FpCQgISEhIE67L7PkxtKYofHx+PT58+idoWz4vq+fvvvwXLBw4cKPO6X79+ctvcv38fISEhWuegq/NedozhZzc2pjDXaWj6vH9G4tDH3LDUPxecF9Qt3oMjIiIiMk3yM1NERESECxcu4O3bt0q3SUlJwYkTJ3TSflBQkErbqXLjzVhdvXoVr1+/Fqzr1KkTVqxYAWtraz1nRXxf1Ofj44PLly8L1pUpUwYXL15EvXr1NI7fvn17hISECD449v3334v64KJUzJ49G+/fvxesa9++veCNPFO0YMECVKlSRbDu3r17GD9+vM7aHjt2LMLDwwXrnJ2dsW3bNsEHIYxVp06dcPHiRVSvXl3tfatVq4bg4GDBh2Q+W7p0Ke7fv69Nihq5cOEC4uLiBOsmTZqEbt26aRTXzc0NwcHBMg/DxsfHY9u2bRrFE2KO56NXr15h8uTJCut79uyJc+fOoXLlymrHbty4MUJDQ5X+QcpPP/2E+Ph4tWOT6QsMDMSFCxcE61q1aoWLFy+iZs2aWrVha2uLjRs3KuyHd+3apVFcffUlUu1vDx48qPB3a2FhgXnz5mHbtm0a/QFD/vz5cfjwYfTp00ewPiAgwCDnxi+lpaWhd+/eCh9UVfaHIqZOlTkRgPMi5mTXrl1K3+vp06dj165dKFy4sNqx69Spg9DQUDRo0ECm/PDhw2rHUsSUxlk7d+5UaTttjg1VH7TV5oFZKY8vtCX140mX82D6ngNbt26dTrZVhbnOJ5pSfyzEWOeXzPXzpipzPR8Bxn1NKNXrbJJlzJ8xQzP2MZXUj0FD3V8wx3NuzZo1Fba7fv16PWfzf1u2bEFqaqpgnbe3NywsLPSckbikfowqY6xjalVJPX99M+axgikcZ1K/366rOQRjmD8wJpyn5TytImKMPc358zV69Gjcu3dPYX2TJk1w69YtbNiwAZ6enrCxsRHcLk+ePOjfvz+Cg4Oxbds25M+fX6Z+69atouYtZVI4Jr4k9T5I1wwxjjH1+xdSsWTJEoV1bdq0wZ49e+Dg4KBWzN69e+PcuXMyfWhUVBROnz6taZqkBI8l0yT160t9k9q4RF9M5XmnL7HPMyxzG1Ob8zW2GExhvlefxJrXAPQ/tyGF87BUj2cpjwl5T5t0KS4uDl27dkViYqLCbapWrYrLly9j48aNKF++vMZtOTo6YsKECXj8+LHCe6AAEBsbi0GDBmncjpikMNcjpX5ZCuc5c/T1l0kZ03MjUhoH81j8D49DIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIi9SxdujTbdSeqVKmCOXPmiNJe7ty5ldYvWrQIL1++VPlfdmvjZdceAZmZmXjz5o3K22e3hp+itX++XkPraxERESrnoK7s2n7w4IHaMbPbJ7s2FUlPT0d0dLRK24q1nqKi9TU+U/Se8ngm0r3ExERcuXIFycnJWWX9+vWDvb09atasiREjRuDEiRPIyMiQ27dHjx6YMWOGVu33798fDx8+xLJlyxT2a2fOnEHDhg3RtWtXPHz4UKv2vpSQkICff/5ZqxjHjh2Dv7+/TJmFhQV69OihVVxF8ubNCz8/P1hZWWWV7d27FytWrNBJe5ow5HtqzLkQGcKlS5fQoEEDlf6dO3dOZt9Dhw6pvK+yNXK/duPGDQwfPhyhoaEa/1y+vr7o1q2b3LmpZcuWcutVK+Lv748RI0YInt+KFy+OOXPm4MKFC/j48SOSk5Px8eNHpKWl4fnz5/Dz80OPHj1gaWmZtY+fnx9mzpwptwZwenq6yj/X48ePsWLFCnz//fdo1aoVmjdvjt69e2PWrFm4du2a3PZDhw6VO9+sWrUKu3fvznpdv359jBo1SmabESNGoEqVKhgzZgzmzJmDn3/+GRUrVsT48eNlths3bhw8PDxUzp+I/s/Y+l8pjCENif0vke6Z69yDsYx9dW3atGlya5ivW7dOtN9j+fLlsXHjRpnzGAA8fPgQzZo1Q9WqVfHbb7/h0KFDuHfvHl69eoX379/j5cuXuHv3LoKCgvDrr7+iUqVK8PT0xNOnT2Xi2Nraws/PD8WKFdM4x7i4OERHR8v9e/fuHR4+fIjz589j6dKlaNiwIerUqSNzDrezs0NAQIBG39tDZCyMbfwLGH8fbMh5S3XGvxz7Ehk3Y+x/hWgzVgJUGy9lZmbKlX09ftSWUDyhdoVw7oGIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIhINUuXLsWJEycE66ZNm4aiRYuK0s7Ro0cFyzt16oR8+fKJ0oYuJCQkCJY7OTnpLYfY2FgcP35crrx9+/awtrZGx44d5er27duncvyQkBC8f/9epszZ2RkNGzZE69atYWdnJ1OXkpKCwMBAleN/6cyZM4K/02LFiqFbt24axRRiY2Mj97fBn2mauxRNnz4dly9fFqz7/vvv0bdvXz1nJF1RUVGCxyEAzJgxA7a2tqK1NXv2bNFi6YMp9FG5cuUSLE9KSlIrjhBLS0t4eXlpHedLBQsWFDXeZ69evRIsd3V11Ul7X9LlewDo5n2QGimMxQ4fPixY/s0336BFixZ6zkaevsYxgLTGMseOHRMsL1++PFq2bClqW6VKlRI9prFQtOZQwYIF4e7uLkob3333nV6O93z58qFXr16ixsybNy/69OkjWKeo79CV0NBQvfxT9P1ZDx8+FNz+7t272ea+c+dOuTILCwuMHTtW69+LkJw5c+LHH38UrNu7d69o7VhYWMDX1xcFChSQq9u1axdWr16tVryvx56AZnMAQvtERUWpHUcTis77FSpUEP2cWr58eTRt2lTUmADQpk0bwXJtj3lT+N1oimNu3REaD3EspBujRo2Cvb29XPnJkydV7mPDw8MFy7/77jutcstO165dBcsV5aMpnhfV9+DBA8Hv/O3atSscHR0B/Lc2ptB34/n4+IiSg67Oe9kxhp/d2JjCXKe+GMP9M3Nk7HPDpvq54LygbvEeHBEREZFpssx+EyIiIvOTmZmZ7STP2bNnFU60aevEiRNISUnJdrs9e/bopH19SE9Px59//qmwfuTIkfj3338xYcIE1K5dG7lz5xb9S9dIHt8X9WVkZGDAgAGIj48XrC9YsCBCQkKwY8cOVK5cWeW4devWxZ49e3DgwAGFD5Js2LABR44c0ShvKfv48aPSL3P/448/YGlp2pc6np6e+PnnnwXrUlJS0KdPH9EeNBLy6dMn9O7dG6mpqYL19evXx9SpU3XWvraOHz+OJ0+eyJRVqlQJV69ehZ+fHxo0aKD0M2RlZYWGDRvC19cX165dQ7Vq1RRue/PmTcycOVOkzNWTnp6OrVu3CtZZWVnB398ff/75p+CDK0IKFy6M5cuXIzw8XO5nnjlzpsIbmZow1/PRqlWrEBAQoLC+Vq1auHHjBjZt2oT69esr/Zza2trC09MT+/fvx5kzZ5Q+5P7HH3+Y7A1OEseAAQMQFxcnWFe5cmWEhoZi9+7daNGiBaytrVWOmyNHDvTo0QPXr19X+MeziYmJMl9UrA5N+hJN25Fqfzt06FA8ffpUYX2fPn3w6NEjLFy4EFWrVs02XrFixTB9+nRERETA09NTcJuoqCid/VGEuh48eKDwwQ8AmDRpEpo1a6bHjIyDKnMiAOdFzM2QIUMQHR2tsL5r16548OABFi1ahEqVKimNZWlpiWbNmmH37t24cOECypUrJ1N//vx5bNq0SZS8PzOVcZa/v3+227x69QrXrl3TuA1V8n348CFu3rypcRuAdMcXYpDy8aTOPJiqDDUHduXKFZU+x2/evMGBAwdEbduc5xNNpT8GpDO/ZM6fN1WY8/kIMN5rQilfZ5MsY/2MGZou+mYx+2WpH4OGur9gjufcYcOGCZanpKQo/AzpQ1RUlMKxX7FixdC2bVs9ZyQuqR+jX5LKmFoRqedvDIx1rGAKx5kp3G/XxRwC75vLM+frYnOZpzXk2NNcP18JCQno2rWr0kV6rKysMHjwYBw9ehTR0dG4du0aDh06hM2bN+PkyZO4e/cu3r59m9XHfe3Ro0eYMGGCLn8MSZHKMfElKfdBumaocYwp3b+QqoCAAKULtLZv3x4PHjzADz/8oHRRHGtra7Rv3x5nz56Fr68vXFxcZOp/++03xMbGipY3yeKxZHpM4fpSn6Q4LtEHU3re6Uvs8wzL3MbU5nqNLQZTmO/VJ23nNfz8/Aw2tyGV87AUj2cpjwl5T5t07c6dO+jUqZPSv+W2trbGgAEDEBYWhsuXL2PatGlo2rQp8ubNq3AfGxsbVK1aFQMHDsSuXbvw7t07/P7778iTJ4/CfRISEtC2bVs8fPhQq59JLFKZ65FKvyyV85y5mTJlitx1ibE8NyK1cbA5H4s8DomIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiDTXv3//bNeeGD9+PBo1aqR1W8rW/tAFTb9j25zExcUhLS1N5e0zMjI0asfR0VFpvS7XulW2NoumbcfExCitd3Z2VjsmAIXrMQjR9L0QKw6PZyLDSUlJwbVr17Bq1Sq0bNkSVapUwZkzZ+S2mz59utz6oKooXbo0QkJCsGnTJhQtWlRwm4sXL6JFixZo2rQpgoOD1W4jO1u3bkVkZKTWcRYuXChXpuj7mLRhYWGBbdu2oXDhwllljx8/xsCBA0VvSxPG8J4aYy5EhhQbG4uQkBCV/r1//15m37dv36q8rzrjS7EcOHAAa9eulSvv37+/yjFWr16NTp06ZXsusLW1VTjez8zMxO+//45+/fohMzNT7ppE2RqY2qhatSqWLVsmU3b9+nW57/z7el3hNWvWYNWqVYIxlyxZgo0bN2a9trCwwPjx40XJl8jcGFP/a+xjSKlh/0skLnOYexCDGGNfXSlYsCC8vLxkyhITEzF79mzR2lixYgXs7e1lyi5evIiqVavi9OnTasU6fvw4qlWrJvedSLly5cLixYu1TVUloaGh8PDwkCnLkycPFi1apJf2iXTBmMa/YhO7D5bauYljXyLjZor97+ex0vnz52XKsxsvCX1/hoODg6i5CT2P8vHjR1HbADj3QERERERERERERERERERERERERERERERERERERNS/f39ER0fLlVtZWWW7BrmqHj16hNu3b8uV29rayq2noi0XFxcULFhQlFgfPnwQLC9RooQo8VXl7+8vV+bi4oImTZqgY8eOMuVxcXFqrROTkZGBgwcPypV37NgRXbp0kSs/fvy4xmvPp6SkYMeOHYJ1U6dOhY2NjUZxv+bt7S2zFtxnycnJCAgIEKUNKUhPT0fv3r0V/g37mjVrUKpUKT1nJV1//vmnYHnFihUxd+5cUdrw9vZGy5YtRYmlT1Lvo4TWUACAfPnyqRVHSO/evVG6dGmt4wBA0aJFsWbNGjx9+hSdO3cWJeaXbG1tBcs/ffokeltf0+V7AIj7PkiVFMZir1+/VrgG1OTJk7VNS4a3tzeqVq2q1j76GscA0hrLfF5XR8iUKVNEbWv27NmwsLAQNaaxiIiIkFuz6DMx1jS2trbGb7/9pnUcVY0fPx5WVlaixRs7dixy5MghV56QkICjR4+K1o6p279/P6KiouTKR40apXCdPm2MGTNGsC/LzMxU2J9qYvr06WjevLlc+aNHjzB48GC14wnNjxQrVkztOMWLF5crUzTHILZXr17h8uXLgnVi983z588XNR7w3xiwevXqcuWRkZG4ceOGVrGl/rvRBsfcuqNoPGSOY6G8efPi559/xq1bt/D999+LGrto0aKYOHGiYJ2iORshX6+7+FnXrl1RtmxZjXLLTtmyZdG1a1fBunPnzonaFs+Lmvn777/lyuzt7dG9e3cA/30vXv78+WXqMzIysHnzZq3b1uV5TxWG/NmNldTnOvXFWO6fmQupzA2b6ueC84K6x3twRERERKbH2tAJEBERGas9e/YofWBPaBJZLAkJCTh//rzgzaTPPn78iFOnTuksB31Ys2YNRowYITjRBvz3xZa///67SrHmzJmD6dOni5me2eL7or6wsDD07t0be/fuVfgwXo8ePdCjRw88e/YMx48fx9OnTxEZGYm4uDhYWVnBwcEBBQoUQPny5dGwYUMUKVJEaZtnzpzB8OHDdfHjSMLatWsxcuRIwS90r1SpEoYMGYJ169YZIDPdy507NzZt2qTwwZTJkyfLfTG5Lly/fh3Tp0/HggULBOtnzJiBY8eO4eLFizrPRV3x8fEYOHAgjh07JnPzyMLCAr169UKvXr0QHR2Nixcv4s2bN4iMjISVlRXy5cuHggULom7dunB1dc22nejoaHTp0gVJSUk6/GmUmzVrFgYMGAB7e3u5OgsLC4wYMQLDhg3DiRMnEBoaigcPHiAmJgbJyclwcXFB/vz54ebmhpYtW6JKlSqCn7v9+/dj8eLFoj+EZ67no/79+6N48eKoU6eOYL2lpSX69++P/v374/379wgNDZX5nBYoUACFCxdG3bp1VfrC2v3792PcuHFi/xhkYu7fv4+BAwciICAAlpaWcvWWlpb49ttv8e233yI+Ph4XL15EREQEHj9+jLi4OCQmJiIzMxP29vZwcnKCm5sbypcvjwYNGiBnzpxK2/7111/x9u1bjXMXqy/Jrh+Ran/7/v17tG3bFsHBwciVK5fgNvb29pg4cSImTpyIN2/e4OrVq3j37h3evXuH1NRUODo6okCBAqhSpQrKly+v9OHZ9PR09O3bFy9fvhTtZ9CWj48P2rZti27dusnVWVpaYuvWrahSpYrCPyIyVdnNiQCcFzE3T548Qc+ePXH48GGF1705c+bE+PHjMX78eLx48QLXrl1DZGQk3r17BysrK7i4uMDd3R3Vq1dH7ty5BWNERkaiV69eaNCggeg/gymMs0JDQ/Hs2TPBh72/bFcb58+fR3R0tML3CIAoD8dJeXyhLakfT6rOg9WtW9fo58DWrVuHVatWKd3mn3/+QXp6uuhtm/N8oin0x4C05pfM+fOWHXM+HwHGfU0o1etskmXMnzFDU6dv9vHx0Xu/LPVj0FD3F8zpnOvo6IjevXsL1u3du9fgc2nr16/Hd999J1j3448/6nReSx+kfox+JqUxtSnmbwyMeaxgCseZKdxv1+ccgrneNzfn62Jzmac15NjTnD9f4eHhaNKkCU6ePIkCBQoo3dbR0VFwERtFoqOj0bZtW3z8+FHbNE2KFI6JL0m9D9I1Q41jTOX+hVSlp6ejW7duuHLlisLfX8GCBbF+/XqsWbMGISEhePLkSda1gaurK9zd3VGrVi2F11rHjh3DqlWruJCJjvFYMj2mcH2pT1Ibl+iDKT3v9DX2eYZjbmNqc77GFoMpzPfqky7nNQDdzm1I4Tws1eNZimNC3tMmfTlx4gS6dOmCnTt3ZvvFsR4eHvDw8Mh6nZCQgOjoaCQmJiItLQ329vZwcXGBi4uLWl8clJiYiE6dOuHChQsa/xxik8pcj5T6ZSmc58zNu3fv0KdPHxw8eFDm82Msz41IaRxsLsdiYmIij0MiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIRPX/+HCNHjsTmzZsVbmNpaYnNmzfj22+/1aotVdaLE5O1tbVe25OijIwMvbRjZ2entD45OVlSbWe3T44cOdSOCQCZmZka7WcIPJ6JjMfdu3fRokULbN++Hd26dcsqt7S0xC+//IJBgwapHKtt27bw8/ODi4uLYP21a9cwbdo0HDp0SOu8lTlw4IAoca5fv47Xr1+jUKFCWWVVq1YVJfaXJk+ejFatWmW9TklJQY8ePRAbGyt6W+oylvfU2HIhIt2aOXMmhg0bJrMmWuvWrdWKERQUhPLly2PatGnw9vbOdq3KL50+fRqTJk1CaGgogP+uCb5e8ywhIUGtfFTh6OiIgIAAmeuBuLg4dO/eHSkpKVll9vb26NChg8y+CxYsUBp7wYIFGDhwYNbrLl26wMbGBqmpqeIkT0R6Z8xjSKlh/0uke6Y49yAWMca+ujBu3Di5ufGVK1eK9r0pNWvWhKenp0xZZGQk2rdvr/FYOyYmBm3btsW///4LZ2fnrPIePXpg6tSpePDggVY5q+LTp094//498uTJk1XWq1cvTJo0CS9evNB5+0SkHrH6YKmdmxwdHTn2JSKD+PTpEzp16oT79++rPF4SmudwcnLCmzdvRMvLyclJpXa1wbkHIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIuDVq1fw9vbGzp07ddrO33//jRUrVsiVT506FQEBAbh//74o7fzxxx/47rvvMH36dKxcuVKr9dpfvnwpWF6mTBkUKFBAtHVfsrN3716kpqbCxsZGpnz69OkoUaKETNmRI0fU/pvWffv24fvvv5cp69y5M3Lnzi23bUBAgFqxv7Z48WIMGjQIFhYWMuWVK1fGsmXL8NNPP2kVv3r16li8eLFg3ebNmxEZGalVfKl5+PAhRowYgY0bN8rVOTk5Yfv27ahfvz7S0tL0n5zEHDhwALdu3UKVKlXk6saOHYvw8HCsX79e4/ienp5YtmyZFhkajtT7qKioKMHyevXqYdeuXWrH+9Iff/yh1f4AULRoUUyZMgU//PADbG1tAQArVqzAuXPnEB0drXX8z9zd3eXKEhMTERcXJ1obiujyPShSpIgo74MpkMJYbO3atWjQoIFceYsWLTB69GgsX75c6/w8PDywZs0aWFpa4sCBA5g9e3bWetfZ0fU4BpDmWGbVqlWoX7++XHmzZs0wbtw4LFmyROs22rRpgz59+mgdx5iFhISgY8eOcuVeXl5YvHgxYmJiNI49ZcoUlC9fXovs1FO5cmUsWrQIY8eO1TpWkyZNMHHiRMG6LVu26OU8ZSpSU1OxbNkyzJkzR6Y8R44c2LNnDxo3boxPnz6J0lazZs3w22+/Cdbt2rULjx49EqWdpk2bYsaMGXLln9cE//jxo9ox7927J1dWunRp2NnZqfxdaA4ODnLjYOC/dYD1ZeXKldi0aZNcefPmzTF27FgsXbpU6za6deuGLl26aB3na61atZI71wL/XUuIQcq/G21wzK1bQuMhcxkLWVlZoV27dhg8eDDat2+fNTcwa9Ys7NmzB/Hx8aK0sW3bNsHvVvz333/V+j60PXv2YNSoUXLlNjY2WLt2LTw9PZGenq5Vvl+ysrLC2rVr5eZMvsxHLDwvam7Xrl34888/5eaaBg4ciH/++Qf9+vWT2+fo0aN49eqV1m3r+ryXHUP+7MZK6nOd+mIs989MndTmhk35c8F5Qd3iPTgiIiIi02Nt6ASIiIiM1YkTJ5TWHzx4UKftHzx4EM2bN1daL/Uv14qJiUG/fv1w/PhxmS/CJMPi+6KZAwcOoFevXvD19VV40xkAihcvjsGDB2vV1unTp9G5c2eZL+4zN+np6ZgwYQICAwMF6+fMmQM/Pz+TfGhxw4YNKFSokGDdiRMnRHmgSlW///472rZtiyZNmsjVfX6ApGrVqqI8kCK2M2fOwNvbGz4+PoIPAuTOnRvt2rXTOH5kZCRatWqFJ0+eaJGl9t68eYPRo0fj77//VriNtbU1WrdurdEXUZ89exZ9+/bVJkWFzPV8lJSUhBYtWmD37t1o1aqV0m3z5MmDtm3batzWli1bMHjwYGRmZmocg8zH7t270bt3b2zdulXpWMfR0REtW7ZEy5YttW7z5MmTWt881ldfIuX+NiwsDI0bN8axY8dQsGBBpdsWLFgQ7du316id1NRU9OrVC0ePHtVof13y8vJC3bp1UbRoUbm6woUL459//kGnTp0MkJnhnDhxAnFxcYJfVv4Z50XMz/Hjx9GtWzds374ddnZ2SrctWrSo4DGlTExMDDp16qTwwTZtmco4a+fOnUr/CHDfvn1axc/IyMDBgwcFH0r+zN/fX6s2PpPq+EIMUj+eVJkHk8Ic2NatW7F48WLkzJlTsD4zM1Pp+E5b5jqfaCr9MSCt+SVz/bypwpzPR4DxXhNK+TqbZBnrZ8wYqNo3G6JflvoxaMj7C+Zyzu3bt6/gH5ED0OoPisRy5MgRvHjxQvBaql27dihatChevHhhgMzEIfVj9EtSGlMLkXr+xsBYxwqmcJyZwv12fc0hmPt9c3O+LjaHeVrAsGNPc/583bt3D3Xq1MH27dtRt25dUWI+e/YM7dq1Q0REBOzt7UWJaUqkcEx8Sep9kC4ZahxjSvcvpOrff/+Ft7c3tm7dKniN9ZmNjQ2aNGki+OyystjGuiigqeGxZHpM4fpS36Q2LtEHU3re6Uvs8wzL3MbU5nyNrS1TmO/VN13MawD6mduQwnlYisezFMeEvKdN+nTkyBHUqVMH+/btE1wsWBEHBweFn1NVhYWFoVu3boKL0huaVOZ6pNQvS+E8Z26OHDmCUaNG4c8//zS650akNg7msSiPxyEREREREREREREREREREREREREREREREREREREREVH2tmzZgs6dO+O7775TuI2bm5tJrKlFRERkitLT0zFw4EA0atQIBQoUyCr/9ttvVV6LtX379tizZ4/gejB37tzBr7/+ij179oiaNwB8+vRJruzu3buixb937x4KFSqU9TpXrlywsbFBamqqKPEbN26MWbNmyZSNHz8eV65cESW+Ngz1nhp7LkSke5GRkbhw4QIaNGiQVVaiRAm4uLggNjZW5TgfPnzAuHHjMHPmTLRv3x5t27ZFlSpV4ObmBicnJ1haWiIxMRHv3r1DWFgYzpw5g3379iEsLEwmjqurq1zst2/favzzKbJu3TqUKVNGpmzIkCF4+PChTFmdOnVgbW2d9TosLAzPnj1TGjs8PBxPnz5FiRIlAAB2dnbw8PDAhQsXRMqeiPTJmMeQUsT+l0g/pDz3oEtijX3FZG9vjyFDhsiUJScnY+nSpaK1IbSm8syZMxEdHa1V3NevX2PBggWYN2+eTHnv3r0xe/ZsrWKr6vfff8fChQuzXltaWqJbt268R0ZkhMTog6V4blq3bp3Ma459iUifPnz4oNZ4Sag/dnFxETUnoXgxMTGitsG5ByIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIqL/7Nq1C5s2bcKAAQN01saGDRswffp05MuXT6bc3t4e27ZtQ7NmzZCQkKBVG0OGDMGgQYMAAMuXL8fgwYPx448/avw3ni9fvsSLFy9QtGhRubrhw4djxowZWuWrqtjYWBw/fhxt27aVKW/SpInctvv27VM7/pEjR5CSkgJbW9usstKlS8ttl5aWplH8L4WFhcHf3x89e/aUqxs+fDgePHiAP/74Q6PYZcqUwZ49e5AjRw65uqSkJCxYsECjuFK3adMmtGvXDj169JCrq1WrFubMmYNffvnFAJlJS2ZmJkaNGoXTp0/L1VlaWuLvv/9GgQIFMH/+fGRkZKgVu1evXti4cSPs7OxEyla/pN5HRURECJYPHToUu3btUjveZ/b29nLnPE2sXbsW7du3lykrXrw4AgIC0KFDB8G14NVVu3ZtuLu7y5W/ePFC69iq0OV7sHPnTlHeB1MghbGYn58ffv31V7n1QABg0aJFuH//Pg4ePKhxfgULFkRAQAAsLS0BAB06dECHDh1w/Phx9O3bF5GRkUr31+U4BpDuWCYgIADz589H8eLF5eoWLFiAiIgI7N+/X+P4FSpUgK+vrzYpyrGxsVG6juPIkSNFbU8V/v7+6Nixo1x5/vz58ccff2QdW+rq3Lmz3q5bvjRmzBiEhYXh77//1jjGN998g+3bt8PKykquLi0tjWtJamD58uUYNWoU8ufPL1Pu4eEBf39/9OjRQ+uxhYeHB3bv3i24DmB6ejp+/fVXreJ/li9fPvj6+mb16V+aMGECrl69qlHcixcvIi0tTWbNKSsrK7Ro0ULlc5CnpycsLCxkylJSUhAaGqpRTprYvn075s2bhyJFisjVLVy4EPfv39eqb65Zsyb++ecfbVJU6Ovris8OHz4sSnwp/260wTG3bikaDxnrWEhMdnZ28PHxQd68eWXK3dzcsH79evTu3VulNc4VsbS0xObNm9G4cWPB+okTJ6oV//Tp04iIiEDZsmXl6po1a4YNGzZg4MCBmqYrx8fHB82aNROs+/fff3H27FlR2uF5UTvJycnYunUrRo0aJVPeqFEjVKpUCV26dJHbx8fHR5S2dX3ey44+fnZjvP5SRupznfpiLPfPTJ3U5oZN+XPBeUHd4j04IiIiItMjP0tFREREAP67SaLIkydPEB4ertP2Dx06pLTe2L7YUVOnTp1Cnz59kJSUZOhU6At8XzSzc+dONGvWDK9evdJZG2vWrIGnpyc+fvyoszakYv/+/Th16pRgXb58+TBt2jQ9Z6R7Q4YMEbwxDADR0dHo37+/XvPJzMxEv379FH5hZalSpbBy5Uq95qSOjRs3olevXkhOThY17s2bN9GgQQPcvHlT1LiaWr9+PWbOnCl6XH9/f7Rq1QpxcXGix/7MXM9HCQkJaN++PZYsWaL2DTdVJCUlYcKECejfvz/S0tJEj0+my9/fH56ennj69KnO2woMDES7du2Qnp6udSx99SVS7m/v3LmDmjVr4syZMzqJ/+bNG7Rp0wa7d+/WSXxtxcTEoF+/fgr73I4dO2L48OF6zsqwUlJSlM5LcF7EfO3duxdt2rQR/br3xYsXaNq0KS5duiRq3K+ZwjjL399fYV1iYiJOnjypdRuBgYEK6x4/fozr169r3cZnUh1fiEHqx5Ou58H0MQf28eNHBAQEKKw/efIkHj9+rLP2AfOdTzSF/vgzKc0vmevnTRXmfD4CjPeaUMrX2STLWD9jxsCYx1RSPwYNeX/BHM65w4YNEyx/9uwZjh8/ruds5GVmZmLjxo2CdZaWlvDy8tJvQjog9WP0S1IaUwuRev7GwFjHCqZwnJnC/XZdziHwvvn/mfN1Medps6ft2NOcP19Pnz5Fw4YNMXXqVK3H7n5+fqhZsybu3r0rUnamSQrHxJek3gfpkqHGMaZ0/0KqfH19MXjwYKSmpooW886dO2jevDmioqJEi0nK8VgyPaZwfalvUhuX6JqpPe/0JfZ5hmVuY2pzvsbWlinM9+qbmPMagH7nNqRwHpbi8Sy1MSHvaZO+3bt3D9WqVcMff/yhl/NnRkYG1q9fDw8PD9y7d0/n7WlKKnM9UuqXpXCeMzerVq3CkCFDlK5PpAkxnhuR2jiYx+L/8TgkIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiJSnbe3N968eaN0myZNmmjVRmJiolb7k3QlJCQorbezs9NZ29mt+ZQjRw61Y2a3z6dPn9SOKTU8nomMT0JCAtatWydT5uLigmrVqmW7b8WKFbFz507Y2NjIlH/48AFeXl6oUqUK9uzZI2a6WaKjo+XKxFwf6927d3Jlzs7OosTOmzcv/Pz8YGVllVV25swZ7N69G4ULF9bo39dcXV3ltilUqFC2uRnyPTXmXIhIf4TWeCxQoIBGsT5+/Ag/Pz/0798f1apVg6urK6ysrGBpaQkHBwe4ubmhbdu2WLBgAcLCwuT2L1OmjFzZ69evNcpFkSFDhqB3794yZX/99Zfg2vJf56Pqephfb+fu7q5mlkRkDIx5DClF7H+J9Euqcw+6JubYVwx9+vSBq6urTJmvry/evn0rWhsNGjSQeZ2eno7t27eLEtvX1zfb9nRJ6Hu769Spo7f2iUg92vTBUjw3fT3+5diXiAxBnfGS0H3AsmXLipqPUDyhdjXFuQciIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiWSNGjMCjR490Fj8xMREzZswQrKtVqxbOnj2L/Pnzaxx/1KhR+Ouvv2TKqlatiuDgYLRu3VrjuKdPnxYs/+WXX9C4cWON46pL6O9gv5aeno6DBw+qHTs+Pl7hz/mlEydO4MOHD2rH/9ro0aMRGxsrWLd06VKsXbsWtra2asX09PREaGgoSpQoIVg/c+ZMnX6+jZ23tzeePXsmWDdx4kS0aNFCzxlJ05kzZ7B27VqF9XPmzMHNmzfRrl07WFpaZhuvRo0aOHr0KPz8/GS+0+H169eIj48XJWd9kXIfdeTIEcFyT09P/PDDD2rHA4DChQvj/PnzWa+vXbumURwAmD59OjIzM+XKmzdvjhMnTqBYsWIaxwb+W+dyw4YNgnWHDh3SKraqdPke1K1bN6tMm/fBFEhhLJaeno5x48YJ1tnY2CAwMBCjR4/WKL/y5cvj7NmzcHNzk6srWLCg4PceCNHFOAaQ9lgmNTUVY8eOFayztrbG3r17MWHCBI1it2jRAufOnUOuXLmyyl6+fKlRrC/Z2NhgxIgRCv8Zwvbt2/Hq1SvBuoEDB2LevHlqx/Ty8sLOnTtlxiUREREa56iudevWYenSpTLrNauqffv2uHjxIgoWLChYv3LlSoSHh2ubotmJj4/HyJEjBes6dOiAS5cuabVO0rBhwxAcHCy3dupnc+fOFfy+AXVZWFjA19dXcG3uffv2YcWKFRrHTkxMlBnHfebl5aVyDKFtz507h+TkZI3zUldKSorCc6q2fXPnzp1x+vRpODo6apOiQq1atZIry8zMxNGjR0WJL+XfjTY45tYtReMhYx0LiSkxMRHLli0TrOvZsye2bdsGBwcHjWIXKFAAR44cQZ8+fQTrAwMDsX//frXjTp8+XWHdgAEDcOTIEa2//6FQoUI4evQo+vfvr3CbadOmadXGZzwviuPrNfqB//9uv/4Mf/jwAfv27ROlXV2f91Sh65/dGK+/siPluU59Mpb7Z6ZMinPDpvy54LygbvEeHBEREZFpyX7ERkRERHI0mXRW17179xQ+UJ6SkqK3h0b1YceOHWjYsCGCg4MNnQp9ge+LZoKDg1GpUiWsXbsWGRkZosUNCwtD06ZNMXz4cKSlpYkWV+rGjh2r8Pc8evRowQeRpapMmTJYvny5wnovLy+FD7bq0osXLzBs2DCF9QMGDECPHj30mJF6/P394eHhgStXrmgdKykpCfPmzUOtWrXw4MEDEbITz2+//YYePXqIcmM7KioKffv2Rc+ePfXyQIm5no/S0tIwfvx41K9fX5TP52fHjh1DtWrVsHjxYtFiknk5c+YMKlasiKVLlyIxMVH0+O/fv8fw4cPx7bffitrH6KsvkXJ/++rVKzRr1gxDhw5FVFSUKDEzMzPh7++PKlWq4OTJk6LE1JUzZ87g999/V1i/ZMkSVKpUSY8ZGZ7QF6d/xnkR83b69GlUrFgRmzZtEuW6d+fOnahSpQpu3rwpQnbZk/o469KlS3j+/Llg3dGjR0U5Zxw+fBipqamCdQEBAVrH/5pUxxdikPrxpIt5MH3PgQk9nK9KnZjMdT5R6v3xl6Q0v2SunzdVmPP5CDDea0IpX2eTLGP9jBkDYx5TSf0YNOT9BVM+59aqVQvVqlUTrPvnn38E/7jOEDZs2KAwlyFDhqj0x07GTurH6JekNKYWIvX8jYGxjhVM4TgzhfvtuphD4H1zeeZ8Xcx5WmFijj3N+fOVnp6OefPmwc3NDbNmzcLDhw9V3jc1NRW7du1C/fr10adPH9HOkaZOCsfEl6TeB+mSocYxpnT/Qqo2btyIRo0aibIQ77Zt21CnTh28fv1ahMxIHTyWTI8pXF/qm9TGJbpkis87fYl9nmGZ25janK+xtWUK8736ps28BmDYuQ0pnIeleDxLZUzIe9pkKAkJCRg7diyqVq0KPz8/pKen66Sd3bt3o1KlSvDy8tJJ/yE2qcz1SKlflsJ5ztz4+Pigbt26onyxk9jPjUhtHGzuxyKPQyIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIvVFR0dj0KBBOm9DmUWLFqFv376i/fvjjz90+vOQ6t6/f6+03sXFRWdtx8XFid62q6ur0vqPHz+qHVNqeDwTGSeh7xYqWbKk0n2srKzg5+eHHDlyyJTfv38fHh4eWL9+vU7XnhNa1yclJUW0+EJr5FhZWYkSe/78+ShcuLBMWZMmTfDixQu8fPlSo39fmzBhgtw2ISEhSvMy9HtqrLkQkX5FRkbKlYk97le1//jmm2/kysLDw0XLo3Llyvjzzz9lym7duoXRo0cLbp8rVy6Z19ldL3329brEX8chImkw1jGkFLH/JTIMKc496Jo+xr7q6N+/v1zZ6tWrRW2jRIkSMq9fvHiR7Zyxqp4+fSo3x/51e7r04MEDuTWNvz53E5Hx0LQPluK56evxL8e+RGQo6oyXhL7DsHLlyqLmU6VKFbmyW7duiRKbcw9ERERERERERERERERERERERERERERERERERERE8uLj49G3b1+kp6frrI01a9bgzJkzgnU1atTAnTt3MHz4cFhbW6scs3Llyjh06BCWL18OS0tLufrLly/j2LFjGue8du1awXJbW1scP34cCxYs0Ms6Knv37kVqaqrSbUJCQjReL2bfvn3ZbuPv769R7K+9ffsWw4YNU1g/dOhQREREoF+/ftl+FipWrIg9e/bg6NGjCteYP3/+PBYtWqRNypIXGxuLvn37IiMjQ67OwsICW7ZsQd68eQ2QmfSMGjUKly5dUlhfqVIlBAUFISoqCtu2bcO0adPg5eWFbt26YcCAAZg0aRLWrFmDx48f4+rVq/D09JSLMWzYMCQlJenyxxCdlPuoc+fOya0P8Nm6deswffp0lc9Ltra2GDVqFG7evInq1asDAGJiYvDrr79qlBsAXL9+HWvWrBGsq1evHu7du4fp06drdAy3bt0aoaGhqFSpkmB9QECA2jE1oev3AND+fTAVUhiL7d+/Hxs3bhSss7KywrJly3DlyhW0atVKpXiOjo6YNm0arl69ijJlysjVZ2Zm4ueff1Z5bSoxxzGA6Yxldu3ahQMHDgjWWVpa4vfff8e1a9fQunVrleKVL18emzdvxrFjx5A7d+6s8qSkJEybNk2UnI1NWlqa0u/vmTx5MoKCggQ/x1+rUaMGDh06hHXr1sl8Di9fvoy9e/eKka5C165dk3k9ZswY3Lt3D926dYOFhUW2+1euXBmBgYE4cOAAnJ2dBbd58uQJ+3Qt+Pv7Y9OmTYJ1lStXxt27d/HXX39luybtZxYWFujcuTOuXLmCNWvWwNbWVnC7kJAQzJo1S+O8vzRlyhS0bNlSrvzp06cYOHCg1vGXLVsmV9alSxeVzj3t27dHu3btVIqpazt27MDBgwcF6zTpm6tWrYqdO3di7969cHR0zCqPjo7Go0ePRMm5Ro0ayJcvn1z51atXFY4XNSHF3422OObWvV27dgmWm8NYaNmyZXj48KFgXe/evXHnzh388MMPcmvFKlKwYEH8+uuvuH//vmB/DwBv3rzBDz/8oFG+/v7+CseuANCqVSuEhYVhyZIlcHd3Vyu2u7s7lixZgrCwMME5n8/27dun8DOjLp4XxXH37l1cvHhRrlxonU1fX19RvodPX+e97BjiZzd2Up7r1CdjuX9myqQ4N2zKnwvOC+oe78ERERERmQ7VnzggIiIyQykpKYIPVwQFBeml/cOHD8Pb21uu/OTJk4iLi9NLDvpy9epVNGzYEHXr1kX//v1Rr149VK5cGVZWVoZOzazxfdHMhw8f8OOPP2Lx4sUYM2YMevXqhTx58qgdJz09HefOncOyZcsQGBhodF/sagxu3LiBLVu2YMCAAXJ1dnZ2+P3339GjRw8DZCYua2tr+Pn5wd7eXrDex8cHu3fv1nNW/7djxw506NAB/fr1E6z/66+/EBISghcvXug5M9XcuXMHderUQY8ePTBp0iRUq1ZNrf3fvn2LLVu2YPHixXj79q1ukhRBQEAAzp07h1GjRsHLy0vtG5fPnj3DypUrsWrVKiQmJuooS2HmfD66dOkSatWqhRYtWmDMmDHw9PRU+PCvIgkJCThw4AAWL16MK1eu6ChTMicJCQkYN24c5syZA29vb/Tq1UvtvvNr165dw/bt27Fu3TrExsaKk+hX9NWXSLm/zczMxLp167B161YMGDAAXl5eMg8fq+rTp084cOAA5s+fj+vXr+sgU92YPn06WrRogVq1asnV5ciRAzt27EDNmjXN5kGGgwcPcl6EFIqJicHAgQMxb948/PLLL/juu+8U/mGZkIyMDJw4cQK//fYbQkJCdJipYlIeZ+3cuRNjxoyRK1flgVdVxMXF4cyZM4IPvevqD9mlOr4Qg9SPJzHmwQw5BxYcHIywsDB88803MuVRUVHYs2eP3vIw5/lEKffHX5LS/JI5f96yY87nI8B4rwmlfJ1Nsoz1M2YMjHlMJfVj0JD3F0z1nKvoj7UyMjLg4+Oj52wUe/LkCU6dOoXmzZvL1RUuXBgdOnRAYGCgATITl9SP0S9JaUwtROr5GwNjHSuYwnFmKvfbtZ1DMIb5A2NnztfFnKf9jy7Hnub8+QL+e49mzJiBGTNmoHr16qhTpw5q1KiB4sWLw9XVFc7OzkhJScHDhw8RFhaGy5cv48SJE4iPjxeMp2xRqOwWXzEHUjgmviT1PkiXDDmOMZX7F1J16dIlVKpUCUOHDsXYsWNVXmgV+O/a4ty5c5g6dSrOnz+vwyxJFTyWTIupXF/qk9TGJbpkis87fY19nuGY25ja3K+xtWEK872GoOq8RlxcHCIjI41mbkMK52EpHs9SGBPynjYZ2t27d9GnTx9MnjwZvXv3Rq9evVC1alWtYoaHh2P79u3w8/NDeHi4SJnqj1TmeqTUL0vhPGdurl+/jkqVKqF///6YNGkSypcvr9b+unxuRGrjYHM7FnkcEhERERERERERERERERERERERERERERERERERERERae/w4cNYu3atwvVntBUdHa20/t69e/D19dVJ22RY2b337u7uOmv7zZs3SuvLli2rdszs9smuTVPA45nIOL18+VKuLLu1cgYMGIDKlSvLlEVFRaFly5Z49uyZqPkJefXqlVyZi4sLIiMjRYnv6uoqVxYXF6ez2Prw6NEjpfWGfk+NNRci0q/09HRDp5Dl67Us09LSEBYWJkpsBwcHBAQEyKwTHB8fj+7duyM5OVlwH0dHR5nXnz59Uqmtr9ew+zoOEUmDsY4hpYb9L5HhSHHuQdeMaexbqFAhNGzYUKYsPDxc9O/u+fq7bN6/fy9q/KioKJk2XFxcRI2fnejoaOTPnz/rtTrf3UNE+qVpHyy1c9PX41+OfYnI0FQdLwmNQz08PETNpWbNmjKvMzIycP36da3jcu6BiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiISLGLFy9i7ty5+PXXX3XWRo8ePXD58mUUL15cri5fvnxYtWoVfv31Vxw6dAjHjx/H8+fPERkZicTERNja2sLJyQnFixdHlSpV0K5dO9StW1dhW69fv0b37t2RkZGhcb7BwcE4f/683PovAGBjY4NJkyZh0qRJePnyJZ49e4a4uDjB9t6+fYuBAwdqnEdMTAxOnDiBNm3aKNxm3759Gsffv38/Vq1apbA+LS0Ne/fu1Tj+17Zv345KlSph6tSpgvUlSpTAli1bsHLlShw5cgShoaF48+YN3r9/DwcHBzRs2BBt27ZFuXLllLbz6NEjdOnSxajWEzKU8+fPY/78+YK/80KFCmHjxo3o0KGDATKTltTUVLRp0wbHjh1T+nf2uXLlQp8+fdSOP2fOHAQGBmqTokFIuY9KTk7G3Llz8ccff8jVWVpaYtasWRg2bBi2bNmCs2fPIjw8HDExMUhKSoKLiwvy588Pd3d3tG7dGu3bt0ehQoWy9s/MzMSAAQPw7t07jXL7bMyYMahdu7bgZ87R0RGzZs3C9OnTERISgtOnTyMsLAxPnjxBXFwcEhMTYWFhAQcHB7i6uqJ06dKoXr062rVrhzJlyihsc//+/QgODtYqb1Xp8j0AxHsfTIUUxmLDhg1D2bJlUb9+fcH6mjVr4siRI3j37h2OHj2K69evIzIyMmvtPBcXF5QsWRK1a9dGq1atkDNnToVtzZ8/HydOnFArP23HMQUKFECZMmVMbizTr18/XLlyReH3FFWvXh2HDx/GmzdvcOjQIdy6dQtv377Fhw8fYGdnh9y5c6NSpUpo1qwZqlevLhhj9OjRJrcW75f++OMPdO7cWfDaAwDatWuHNm3a4OLFizhy5AiePXuGd+/ewcLCArlz50blypXh6ekpt3Y78F9fO3jwYPTt21enP8OgQYMQGhoKOzu7rLKyZcsiICAAUVFROHz4MK5evYo3b97gw4cPcHJyyjom2rRpk+0x8enTJ3Tp0kW07yUxV97e3ihVqhQaNWokV2drawtvb294e3sjLCwMJ0+eRHh4OKKiovDhwwfY2toiT548yJ8/P+rWrYumTZtmuzb3vXv30KFDB1H6skaNGmHmzJly5ampqejRowdiYmK0biMwMBB3795FxYoVZcoDAgLQr18/7N+/X3C/b7/9Flu2bJErv337Ng4cOKB1Xpro27cvrly5gtKlSwvWZ9c358mTJ6tv+fr38dmPP/6IMWPGoFSpUlrnq+h64siRI1rH/prUfjfa4phbPx48eGCWY6GEhAT069cP58+fh5WVlVy9m5sb1q9fj5UrV+LcuXO4ffs2Hj16hLi4OCQnJ8POzg6urq5wd3dHnTp14OHhAUtLS4XtxcfHo127doiKitI45++//x6XLl1S+J2VLi4uGDt2LMaOHYunT5/i8uXLuHfvHqKjo7OOjRw5csDV1RW5c+dGhQoVUKtWLZQoUSLbtsPCwjBgwACNc/8Sz4viWrdundJr3M98fHxEaU+f573s6PtnN3ZSnuvUJ2O5f2bqpDY3LNbnom3bthq1r2ucF9Qt3oMjIiIiMh0WmZmZmSptaGGh61yIiIiIZNjb26Nw4cJwdXWFq6sr7O3tFW4bERGBf//9V4/ZmS++L+qzsrJCgwYN0KBBA1SvXh0lS5ZEwYIFkTNnTtjZ2SE9PR1xcXGIi4vDkydPcO/ePVy7dg2HDx9GdHS0odMnkiw/Pz/06tVLrnzv3r349ttvFe5XtmxZdOzYEdWrV0eFChWQJ08eODs7w8LCArGxsYiJicH9+/dx48YNnD17FufOnYOKl9ZGw9bWFk2aNEGdOnVQp06drH49V65csLa2xsePHxETE4Pw8HBcv34dR48eRWhoqKHTlmGu5yMnJye0adMGHh4eqFq1KooVKwYXFxc4OTkhMzMTsbGxiI2NxaNHj3Dr1i2Ehobi2LFjCr/4lUgsBQoUQIsWLVCxYkWULVsWpUqVgpOTExwdHbO+GDghIQEfP35EXFwc3rx5g9u3b+P27du4dOkSHj58aJC8Ve1LNO1HTKG/dXNzQ5MmTVC3bl24u7ujePHicHZ2hr29PSwsLPDx40fExsbi5cuXuHHjBi5fvoxDhw4hPj7e0KkbTKtWrWQeLMxu7EFkCmxtbeHp6Yn69eujatWqKFmyJFxcXODs7Izk5GTExsbi3bt3uHXrFq5cuYLAwEC8ffvW0GnL4DjL+Eh1fKEtqR9Pn+fBRowYwTkwLZjzfKKx9cfmML9kzp83VZjr+egzY7smNIXrbJJlbJ8xY/Fl39y1a1ej6ZdN5Rg01P0FnnNJ14z1GJX6mFrq+UudsY0VjPU404Qp3G9Xdw5h7ty5nM/VgLleF5vKPK2xjz3N9fMlhpIlSypc1MrLywvr16/Xc0bGTSrHxGdS74N0zVDjGGO7f2Fu6tati5YtW6J27dooXbo08uTJA3t7e6SnpyM2NhbR0dG4c+cOrl69ir179+Lp06eGTpkU4LFkekzh+lKfpDYuIe2wzzMccxxT8xpbfaY03ytFhpjbkMp5WIrHM8eERNnLly8f6tWrh9q1a6NUqVIoWbIk8ubNCwcHB9jb28PKygoJCQlZY8TPY5Xr16/j+vXruH//vqF/BFFJaa5HKv2yVM5z5qRSpUpo164dqlWrhgoVKsDV1RUuLi4Gf25EquNgUzgWra2teRwSERERERkpba7HuFY7ESlSpUoVVKlSBcB//cyjR49w8eJF/u0QEelF23Zt0bx5c0OnQWbk8ePHWL1qtaHTICLSmcGDB+ObCt8YOg0yEyEhIdize4+h0yAi0pkpU6cgV65chk6DzMTuXbtx4cIFQ6dBRKQTrq6umDptqqHTIDOzZPESvHnzxtBpEBHpRKlaQLfZhs6CzMnvbQydARGRabOwsICHhwfKli2b9bz3rVu3cOvWLQNnRkTKVKhQAXfv3lVYHxUVhXz58qkUy97eHjdu3ECZMmXUziM+Ph5OTk4K66dMmYK5c+cqrF+xYgVGjx6tdrvaqFKlCm7evKmwPjU1Fba2tnrM6P+ye18B4LvvvsPu3bsV1teuXRuXLl1SWB8TE6PWPcjhw4dj1apVCuuPHz8OT09PufJJkyZhwYIFCve7fv06atSooXIe6hg5ciRWrFihsP7u3buoVKmSWjF37NiBHj16KKz38fHBDz/8IFcu5vvRo0cP7NixQ2G9qn+3ld1xuXPnTnTv3l3t/QxxPJPxmTV7FnLmzMk5ci29e/cOefPmBQC0bt0aR48eVbht0aJF8fz5c5myUaNG4c8//1S4T3h4OMqWLStTNnDgQGzatEmLrFVXo0YNXL16VaasevXquHHjhijxL126hNq1a2e9TkpKQs6cOUWJHRAQgG7duokSSx0bNmzAkCFDFNYb+j011lzMyefnzFatXIUnT54YOh3S0p49e9ClS5es1xs3bsSgQYMMl5CKVq5ciZ9++kmmrHTp0grX0tWlJ0+eoESJElmvr169Cg8PD1Fib9myBf369ZMp69u3L3x9fRXuM3v2bEybNi3r9bJlyzBmzJhs21qzZg2GDRuW9Xrq1KmYN2+eBlmTrgz/aThKliyJDRs24N8wrh0sdbrqf411DKkOoTmr9evXw8vLS5T4qmD/S599/ttFPvuuHVOfe9A1Yxr7DhgwABs3bpQpW7hwIX755RdR24mPj4eDg0PW61u3bqFq1aqixX/69CmKFy+e9frly5coWrSoaPGz8/79e+TOnTvr9eXLl2Xmlwj4tuu3qF+/Pg4GHcSpU6cMnQ6JwNzmH6R2bvp6/Muxr/n6vC7WyZMncejgIUOnQyKQav+rzngpNjYWzs7OWa/T0tKQP39+fPjwQes8ihcvLvddPGFhYahQoYLWsTn3QEREmuJa7USkC1yrnYiMTbNmzdCufTtDp0FmiHOjRGROeL4lQ+C5lojMCb+bjAyBz1wSkTnhuZYMhX9jRkTmxHMEUL2DobMgc3P0T+BGkKGzICLSL67Vblz4TC2RsMePH8PNzU2uvESJEnj27JnO27eyskJwcDDq1KmjcJs8efIgOjpa4zbKlCmDkydP6nTtkbdv38LT0xO3b9/WOlbJkiVx8+ZNpWv1Z+fJkycoWbKkVnkMGjQIPj4+CuvLlSuHiIgIjePfuHFD4Xozx44dQ6tWrTSOrcjcuXMxZcoU0eMCwL1799CmTRu5tZVUpeh8pOu/GdNlu9kd39mtO/WZWDnq83f8zz//YODAgXLlAwYMwObNm9WO5+zsjM2bN6Nz584iZPefxYsXY8KECQBk1xD7Up06dRAaGipam2KSch9la2uLixcvonr16hrHEDJx4kQsWrRI4XdZNGnSBGfPnlUpVt68eXHkyBGdfffHl6KiolCtWjW8fPlS5219pqv3ABD3fRCboc41UhiLubi4ICgoCA0aNBA5s/9bv349vL29Nb4G1eU4BtB+LAPo/zNWunRpnDhxQmbdcLF8/q6cxo0b48yZM3L16pwj7e3tkZCQoLDekGsEFC5cGDdu3FD5+8hUkZmZicGDB2Pjxo2YP3++3DqW2X0vmaKYQiwsLNC9e3fs2LFD9N/jp0+f0LVrVxw+fFjUuMaof//+guvnDR06FOvWrROlDXt7ewQFBaFp06aixFPk0qVL6Ny5M96+fat1rLx58+LmzZsoXLiwXN24ceOwdOlSrdv4rHLlyggNDUWOHDnk6kJDQ3H48GG8ePECFhYWKFasGNq0aSP4HQlJSUmoVasW7ty5I1pu6nJ3d8fx48d10jfPnDkTv/32Gy5cuIC6devK1at7/XL27Fk0atRIrrxhw4YIDg7WKlchUvrdiEFKY26pzhdIZSykK7169cLWrVthZWWlszY+fPiATp064fz581rHKlKkCI4fP47y5cuLkJlq7t27h5YtW+L169dax+J5UXz29vZ4/fq1zDqbX7t9+3bWvU1t6fu8p4wuf3Zjvv5SRspznV/T5XlVn/fPpDo+EIPU5obF+Fyo8r4aam4VMP55QakfL7wHR0SkPxYWFqhVqxbKlCnD52mJSGWq3F+31kMeRERERBpJTEzEgwcPDJ0GfYXvi/rS09Nx9uxZgz0ATUTqiYiIwJIlSwydhk6lpKTg2LFjOHbsmKFT0Zi5no/i4uIQEBCAgIAAQ6dCJOPt27dKv2TYWOm6LzGF/vbJkyd48uSJ4B9MkDBLS0uZ1xkZGQbKhEh/UlJSEBQUhKAg6a6Ox3GW8ZHq+EJbUj+eOA8mDnP+PZpKfyyl+SVz/rypwlzPR58Z2zWhKVxnkyxj+4wZiy/75vnz5xs6nSymcgwa6v4Cz7mka6ZyjH4mpTG1EKnnbyyMbaxgSseZKdxvN5U5BGNnrtfFnKfVD3P9fInB1dVVYd2HDx/0l4hESOWY+EzqfZCuGWocw7GHYV28eBEXL140dBokAh5LpscUri/1SWrjEtIO+zzDMccxNa+x1WdK871SZIi5Damch6V4PHNMSJS9d+/eITAwEIGBgYZOxShIaa5HKv2yVM5z5uTOnTtG+cUOUh0H81gkIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiKi7CQmJqJfv34ICQmBlZWVqLHPnz+vtL5du3YYPXq0qG1mJy4uTmm9jY0NcuXKxTWrtZTdGgLVq1dHlSpVcOvWLZXiFSlSBHZ2dnj06FG2216+fFlpfcWKFVG3bl2V13LJly8fOnfurHSb0NBQlWJJmTEez0RS0ahRI8ybNw8+Pj74559/RI2dN29eubKoqCiF21etWhVly5aVKXv27Bm2bNkial7K3LhxAwkJCXBwcMgqa9KkCW7cuKF1bCcnJ1SvXl2m7Pbt21rH/ezNmzeiryHo7u4u8zo6OhrR0dEyZdevX1e4vzG8p8aYCxHp39f9GfDfWmj6Vr16dZQoUUKm7OjRo6LEHjRoEPr16ydT5uPjo/Z6b5aWlqJuR0TGzRjHkFLD/pcoe5x70C9jGfsC/733X8tuLlcT7969k5nLKViwoKjxCxQoIPM6MjJS1PjK2NraInfu3DJlhno/iSh7mvTBUjs3CY1/OfYlIkNSd7x08uRJdOnSJeu1tbU1unbtig0bNmidS48ePQTb0xbnHoiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiyl56ejr59++LGjRtwdHTUSRv3799HvXr1sGvXLtSuXVv0+NeuXUPnzp3x4sULUeI9fvwYXbt2xc6dO+Hi4iJKTE3s3bsXf/31F2xsbOTqIiIiEBERoVX8wMBAVK1aVbAuICBAq9iKTJ06FY8ePcLy5ctl1r7RVlBQEPr164eYmBjRYpqC9PR09OnTBzdu3ICTk5Nc/aJFi3DmzBmVv1fAnH38+BFdunSBt7c35s2bhzx58mgc6/379xg1apTaf/tubKTcR6WkpKBt27a4cOECSpYsqVWsz1JTU7Fo0SJRYgH/rQvXtGlTbN68WWa9B7G9ePECLVu2xMuXL3XWhhBdvQcjRozAunXrRIlnSqQwFouNjUXLli2xatUqDB48WMTsgIyMDCxYsABTp07VKo6uxjGAdMcyDx8+RIMGDRAYGIgaNWqIFnfBggWYPHmyaPGM2atXr9CoUSMEBQWhdOnSWsfLyMjAyJEjsXHjRu2TU1FAQAAsLCywadMm5MiRQ5SYb9++Rbdu3XSyDqe5SkxMhKenJ5YuXYqRI0eKHj8zMxN///03Ro4ciZSUFFFibt26FYULF5YrP3DgAJYuXSpKG5/dvn0bQ4cOxT///CO3llTt2rVVOn9mZGRg6NChuHPnjqi5qevBgwei982ZmZmYMmUKFixYIEo8AHB2dka9evXkymNjY1X+/jl1SeV3IxaOuXXP3MdC27dvR2pqKnx8fODs7Cx6/Lt376J79+4ICwsTJd7Lly9Ru3ZtLFmyBF5eXqLEVGbnzp0YPHhwtt+vqiqeF8WXmJgIPz8/DB06VOE2Pj4+orRliPOeMvr82aVCynOd+mQs989MndTmhs3hc8F5Qd3iPTgiIiIi6eO3dBARERERERERERERieTrPwYX60FUIiIiIiIiIiIiIiIiIiIid3d3hXViLe5PRERERERERKQrnNsgIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiKxhYaGYt68eaLHvXTpElJSUhTWu7u7o2vXrmrF7NixI3766SeNc4qJicl2m3bt2mkcn/5z+fJlJCYmKt1m9erVsLKyUinepk2bEB4ejrVr16JQoUJKt7106RIiIyOVbrN27VrY2dmp1HZ222ZmZmL//v0qxZIyYzyeiYydh4cHjh49irNnz6Jhw4aYOnWqyn2PqqpVqyZX9vr1a4Xbe3p6ypXt3LkTGRkZYqalVEZGBs6ePStT1qdPH1Fif/vtt7CxsZEpO3funCixAWDkyJEoU6aMqP++tmTJErltVq1apTAnY3hPjTEXIlKNs7OzKHHs7e3RpEkTmbI3b94gISFBlPjq+Pnnn+XKAgICtI5bsWJFuf747t27GDFiRLb7xsXFybzOmTOnSm3a29srjUNE0mCMY0gpYf9LpBznHlRnimNfQPj9uXTpkujtvHnzRuZ1/vz5Ua5cOVFi161bV+5z+3V7utSwYUO5MmWfcSJSn6H7YGM9NwlRNP7NDse+RKRL6o6X1q9fL1f2yy+/wNraWqs87O3tMXbsWJXaUwfnHoiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIhU9/DhQ4wePVqnbbx48SJrPZ3s1jlXVWJiIiZNmoTatWvjxYsXosT87Pjx46hdu7aoa+Cq68OHDzh58qRgXWBgoNbx9+3bJ1ienp6OPXv2aB1fkQ0bNqBy5co4fPiw1rFev36N77//Hh06dFDpuwrM0aNHjxT+nbWdnR127Nih8t9UE7Bu3Tq4ublh6tSpePjwoVr7RkZGYtasWShXrhx8fX11lKH+SL2Pevv2LerUqYOgoCCtY926dQu1a9fWOs7X4uLi8O2336J79+549uyZqLEzMzOxdetW1KpVC+Hh4aLGVpUu3oN169aJkJlpksJYLCkpCT/88AM6deqER48eiZDhf+NcT09PTJ06VZR4Yo5jANMYy7x8+RJ16tTBrFmzkJycrFWsqKgodO7cGZMnTxYpO2kIDw9H7dq1cejQIa3ivHv3Dm3atMHq1atFykx1/v7+qFu3Lm7cuKF1rICAAFSsWBHnz5/XPjGSkZaWhlGjRqFp06YqrYWnqlu3bqFJkyYYOnSo0u/AUscvv/yC1q1by5U/f/4cAwYMEKWNr23evBldu3bFp0+f1N43KSkJ3333HTZv3qyDzNQnZt/8/PlztGnTBgsWLBApu/+0aNFCcA2zEydOID09XdS2viSF342YOObWPXMfC+3atQtVq1bF8ePHRYuZmJiIuXPnokaNGggLCxMtLvDfdba3tzdatWoleuzPwsPD0blzZ3Tv3l209Qh5XtQdZX1aamoqtm7dKko7hjrvKaOvn10qpD7XqU/GcP/MHEhtbtgcPhecF9Q93oMjIiIiki5LQydARERERERERERERGQqKleuLPM6KirKQJkQEREREREREREREREREZGpUbZ48v379/WYCRERERERERGR+ji3QUREREREREREREREREREREREREREREREREREREREREREREREujBz5kxcuXJF1JjJyck4cuSI0m3WrFmDUqVKqRSvYcOG8PX1xcqVK3H69GmULFlS7Zw+fPiAjx8/Kt1myZIlqFevntqx6f/S0tIQFBSkdJsGDRpg3759yJUrl8Jt7OzssGPHDrRo0QLW1tYYOnQoHj58iEWLFiF37tyC+2RmZsLX11dp21WrVsWxY8dQsGBBhds4ODhgy5Yt6Nq1q9JYp0+fxqtXr5RuYwqM8XgmMnaDBw+Gp6dn1uvSpUtj3rx5orYxaNAgmdepqam4fv26wu2rV68uV3bmzBlRc1LFqlWrZF7Xrl0bnTt31iqmra0tZs6cKVfu5+enVVxjZyzvKWBcuRBJ2fv37/HixYusfx8+fBA1voWFBbp164br169j+/btosQcM2YMcuTIIVOW3fXAl+zt7dG/f3+584O6KleujH79+smUXblyRem5URX29vYICAhAzpw5s8oSExPRvXt3fPr0Kdv9o6OjZV4XKFBApXa/3k7szwIRydJ1/0vqY/9LlD3OPShnjGNfsbm7u8u8fvnyJd69eyd6OyEhIXJlP/30kyixheIEBwcr3adUqVL4448/4OjoqHX7w4YNkyvjfAaZA3OafzCmc5Myysa/2eHYl0g69DH/IOZYCVB/vHTo0CG8fPlSpszd3R0jR47UKo/JkyejUKFCMmVXr17FjRs3NI7JuQciIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIi9fn4+GDPnj06bSM1NRXz5s1DyZIlMXfuXLx48UKjOM+fP8evv/6KYsWK4ffff0d6errImf4nIiICjRs3Rp06dfDXX3/h1q1byMjI0Elbivj7+wuW79u3T+vYV69exevXr+XKz5w5g6ioKK3jK/P48WO0bdsWtWrVgr+/PxITE9Xa/8aNGxg6dCjc3NywdetWHWVpOjZv3qxwrZDy5ctj+fLles5I2uLj4zFv3jy4u7ujRo0aGDFiBHx8fHD8+HFcvnwZYWFhuH79Os6ePYstW7Zg8uTJqFevHgoVKoQZM2bg/fv3cjHt7OwE20pLS9P1j6MVqfdR7969Q4cOHdC9e3ecP39e7f2vXbuGXr16oVq1alqtk5CdnTt3omTJkujevTuOHz+O5ORkjWN9+PABPj4+qFOnDr7//nu8efNGxEzVJ5X3wFRIZSy2f/9+lCtXDn379kVwcDAyMzPVjnHz5k0MHToU5cqVw8mTJ0XNT9txDGB6Y5m0tDTMmDEDbm5uWLJkidprJ0ZGRmLWrFkoVaoUAgMDdZSlcYuOjka7du3QvHlzXLhwQa19Y2JisGjRIri7u+PYsWM6yjB7N2/ehIeHBwYMGICwsDC19k1KSkJAQABq1KiBHj16CI6XSDxnzpxBpUqV0LlzZxw6dAipqalqx0hJScHBgwfRpk0bVK1aFefOnRM1xzlz5siVpaWloVevXnJrRIlp3759qFixIgICAlTeZ9euXahYsSL27t2rs7w0oW3f/Pr1a0yYMAHffPMNjh49Knp+bdq0ESw/dOiQ6G19zdh/N2LjmFv3zH0s9OTJE3h6eqJ+/frYtWuXRuPjz3FmzZqFkiVLYtq0aUhJSRE50/87duwYKlSogIYNG2LLli0a5/zZp0+fsHPnTnTs2BHly5cX9X1s0KABz4s6dO3aNYVr8wcFBYk2B2XI854i+vrZpUTqc536ZAz3z8yFlOaGzeFzwXlB3eM9OCIiIiJpsjZ0AkREREREREREREREpiBfvnwYMmSITNm1a9cMlA0REREREREREREREREREZmahg0bCpY/e/ZMpwsZERERERERERGJgXMbRERERERERERERERERERERERERERERERERERERERERERERESkC+np6ejXrx+uX7+OnDlzihb3999/R8eOHRXW58+fH5cuXcLkyZOxdetWJCUlyW1TtWpVDBkyBMOHD4elpSUAoEmTJrh9+zZ++eUXrFy5Uq2cLl26BE9PT4X1BQoUQEhICM6ePYu7d+/i/fv3ctusXbsWL1++VKtdczNv3jx0795d6Tbt27fHkydPsGnTJpw8eRIvX75EamoqihQpglq1asHb2xuFChWS2SdnzpwYP348vL29sXjxYixatEjuc7No0SIMHz4ctra2Cttu1KgRHj58iM2bN+PIkSN4/vw50tPTUbBgQTRp0gSDBw9G/vz5Vfo5zYUxHs9Exmz+/PkYMmQIbGxsssrGjh2L8PBwrFu3Tuv4Q4YMQePGjWXKTp48idjYWIX7uLm5yZWFh4drnYu6goKCEBERgbJly2aVrV+/Hrdu3cLjx481iunj4yP38507dw5XrlzRJlWjZyzvKWBcuRBJ2ZAhQ3QWu2HDhli/fj3KlSsHAKhWrRoGDhyIjRs3ahzTw8MDU6ZMkSvfvXt3tvuWK1cOkyZNQvfu3eHo6AgAOHXqFHbu3Kl2Hi4uLvD19c0aY362cOFCtWN9bfXq1fjmm29kyoYPH46wsDCV9v96u8qVK6u039fb3bt3T6X9iEgzuux/STPsf4myx7kHxYxt7KsL9vb2cHFxkSl7+/atTtras2cPxo4dK1M2fPhwbN++HSEhIRrHbdu2Lfr16ydXvnfvXsHtK1SogClTpqBXr16wsrKCg4MDvL29NW4fgNx9jLS0NAQFBWkVk0gKzGn+wVjOTdnRZvzLsS+RdOiy/9XFWOnbb79Ve7yUkZGBpUuXYsmSJTLlCxYswM2bN3Hy5Em18+jcuTMmT54sV7548WK1Y32Jcw9EREREREREREREREREREREREREREREREREREQkJSVLljR0Clm6du2ql3YiIyMxbdo0TJs2DR4eHmjYsCFq1qyJEiVKIH/+/HBwcIC1tTVSUlLw8eNHxMTEIDw8HHfv3sWJEydw69YtveT5WWhoKEJDQwEADg4OKFSoEFxdXZErVy6ZdYK+9OnTJ1Ha9vHxgY+PjyixhBQuXFhnsVVx5coV9OzZEzly5ICnpydq166NKlWqoEiRInBxcYGjoyOSk5Px+PFj3L17Fzdv3sTRo0fx9OlT0XOxsLAQPaYxtdu7d2/07t1bo33FylGfv+NBgwZh0KBBOm/n+vXruH79ulYxLC0t4eTkJFgnVl+iK6bSR+3cuRM7d+5EuXLl0LBhQ9SrVw/u7u4yfX1cXBxiYmIQFhaG69evIygoCA8ePBCMFxoaKvrnPSMjIytPe3t7NGnSBFWqVEH58uVRunRpODk5wdHREQ4ODsjMzER8fDzi4uLw8eNHPHz4ELdu3cKtW7cQHByMtLQ0UXMTg9jvAaCb90FbxpKPFMZiaWlp8PX1ha+vLwoWLIimTZuibt26cHd3R7FixeDo6IicOXMiIyMDsbGxiImJwb///otr167h5MmTKq8zog1VxzGxsbGIjo7W+VgGMPxn7M2bNxg/fjwmTpyIxo0bo2HDhqhatSrc3NyyfieJiYn4+PEjnj9/jhs3buDs2bM4deoUMjIyBGOePXtW658rMTFRJsapU6fQtGlTrWLqyqlTp1C/fn0UK1YMrVu3RtOmTVG4cGHky5cPuXPnRlpaGmJiYhAZGYnr168jODgYhw4dQkpKimC8yZMnC67xoyvp6enYvHkzNm/ejEqVKqFdu3aoVq0aypYtC2dnZzg6OiIpKQmxsbF48+YNbt26hdDQUBw+fBgJCQl6y9PYfP6d6VtgYCACAwPh6uqKRo0aoX79+ihTpgzc3Nzg7OwMBwcHAEBcXBzi4uLw4sUL3L59G9euXcPx48cRHx+vs9ysra11Fjs7jx8/Ro8ePVCqVCl07NgRzZs3R6FChVCgQAEA/60R++rVK5w6dQoHDhzAw4cPDZarKlTpmz99+oSPHz/i8ePHuH37No4ePYqQkBBkZmbqLK82bdoIlh85ckRnbX7NWH83umLMY25TmS8w1rGQvly4cAHdunWDnZ0dmjdvjurVq6NixYooVapU1jWrnZ0dkpKSkJCQgMjISDx48AA3b97EmTNncOfOHb3nHBwcjODgYAwaNAgVKlRArVq1UKtWLRQpUgSurq5wcXGBq6srbG1tkZ6ejqSkJMTHx+PNmzd4/vw57ty5gytXriA0NBSpqak6y5HnRd2Kjo4WLBdzzssYzntCdPGzS+n662umMtepz/OGLu+fmcr4QAxSmxvW5HOhCmMaExnbvKCpHi/mfg+OiIiISEoMN3tFRERERERERERERGQiChQogKCgIBQqVCir7NOnTzh8+LABsyIiIiIiIiIiIiIiIiIiIlPxzTffoG7duoJ1J0+e1HM2RERERERERETq4dwGERERERERERERERERERERERERERERERERERERERERERERERHpUnh4OCZOnIg///xTtJjnz59HcHAwGjRooHCbvHnz4u+//8bKlStx584dREVFITMzE/ny5UPRokVRoEABwf0cHBzw559/onv37hg0aBAePXqkUk6HDx+Gp6dntts1btwYjRs3Fqzbv38/Xr58qVJ75urGjRs4cOAAOnTooHQ7Z2dnjBw5EiNHjlQrvrOzM4YMGYKFCxfK1b169QoLFizAr7/+qjSGvb09hg0bhmHDhqnV9meBgYE4fvy4RvtKkTEez0TG7Pnz55g9ezZmzZolU/7XX3/Bzc0N06dPR3p6ukaxf/zxR8Hz9eLFi5Xu5+zsLFcWGRmpUQ7a+uWXX7B79+6s13nz5sWJEyfQuXNn3L59W+U4tra2WLNmDfr27StTnpGRgQkTJijdt2TJkoLrOXp5eUmmfzem99SYciEiYW/fvoW7u7tM2d9//w0A2Lhxo9rxGjdujN27d8Pe3l6mPCQkBAcPHsx2fysrKwwcOBAWFhYy+Tx69AjXrl1TOY88efJgz549qFSpklweO3fuVDmOkAEDBmDAgAEyZZs3b8amTZtUjnH58mUkJSUhR44cAP47/1SoUAH37t1TuI+HhwcKFiyY9To+Ph43btxQL3kiIglj/0ukGs49KGZMY19dzT84OTnJlX348EHjeMoEBwfj2rVrqFGjRlaZlZUVDhw4gI4dOyI4OFjtmK1atUJAQIBc+alTp3D37l25cgsLC+zfvx+lSpXKKvPy8kJsbCwmTpyIzMxMtXPo0aOHXNnGjRsRExOjdiwi+j9j6oMB4zk3KaPt+JdjXyLS1Vhpy5YtcuWqjJeWLVuGPn36oGbNmllltra22Lt3L/r06YMDBw6onEfPnj2xceNGWFlZyZQfOnQI27dvVznO1zj3QERERERERERERERERERERERERERERERERERERCQtV65cwZUrVwydhsoSEhLw4MEDQ6dhcpKSkrB//37s37/f0KkQ6Z3QOiqfRUdH6zETCg8PR3h4ODZs2GDoVJRKTEzEoUOHcOjQIUOnIjqpvAemRApjsTdv3mD79u1arUmiSxzHyMvIyMDp06dx+vRpQ6ci6Ms1bzRd21PXnj9/jvXr12P9+vWGTkVjd+7cwZ07dwydBqkgJiaG/ZiAR48eYfny5Vi+fLmhUxGFMfXN5cuXR/HixeXKw8LC8Pz5c73nY0y/G33gmFv3zO0z9bXk5GTJXbOmp6fj9u3buH37Nnx8fAydjlEytfPiZ0WKFEGzZs3kyt++favS+siqMLbz3mf6+NkBaVx/kTh4/0w/pDY3bOqfC84LGj/egyMiIiLSD2tDJ0BEREREREREREREJGUeHh7Ys2cPihYtKlO+bNkyPuBARERERERERERERERERGRmJkyYgJcvX8LX11fUuKNGjVJYx0UTiIiIiIiIiEgMuprXADi3QUREREREREREREREREREREREREREREREREREREREREREREREurdy5Up06tQJnp6eosUcMGAArl69ChcXF6Xb2dnZoWbNmmrHb9y4MQYNGoTp06ertP2GDRswa9YsODg4qN0WqcfLywtXr15F4cKFdRJ/zJgxSElJEaybPXs22rdvr9FnShVv3ryBt7e3TmIbM2M7nomM3bx589CmTRvUr19fpnzy5Mno2rUrZs6cid27dyM5OTnbWBYWFmjbti0mTZqExo0by9X7+/vj+PHjSmPkyJFDrqxMmTJISkrKtn11vH37Fm/fvlW6zZ49e7Bu3TqZvrRkyZK4ePEiFixYgOXLl+Pjx49KY3To0AFz585FlSpV5Ormz5+PS5cuKd3fxsYGbm5ucuX29vZK9zMmxvSeGlMuRCTs/v37WLFiBcaMGZNVZm1tjX/++QfdunXD/PnzERwcnG0cd3d3jBs3Dt7e3rC0tJSpS01NxejRo1XK5969e/D19UXfvn2zylxdXXHu3DlMnz4da9euRWJiosL97ezs0KNHDyxZsgT58uWTqUtISMCAAQNUykORb775BqtXr5Yp+/fff/Hjjz+qFSclJQU7duyQyWfWrFno1q2bwn1+++03mdfbtm1DRkaGWu0SEUkV+18i9XDuQZgxjX11Nf9gZ2cnVxYTE6NVTEUyMzMxYsQIBAcHw8LCIqs8V65cOHv2LFauXIlly5bh8ePH2cYqW7Ysxo0bBy8vL5lYAJCWloaRI0cqzGHKlCnYvn27TPn48ePRokULzJw5E0FBQUhLS8s2Bw8Pj6xj5EvR0dH45Zdfst2fiJQzpj4YMJ5zkyJijH859iUifYyVANXHSxkZGRg8eDCuXLkCGxubrHInJyfs378fO3bswNKlSxEaGqowRoMGDTBhwgR07txZri4uLg5Dhw7NNg9FOPdAREREREREREREREREREREREREREREREREREREREREUlOuXDnB8tTUVK7XTEREpAOurq5Z/8/uezOIiEh8rVu3Fiw/fPiwnjMhIiJz179/f7n1kQFg69atSE9PF6UNYz3v6eNnB3j9RUREhsV7cERERET6YW3oBIiIiIiIiIiIiIiIpMrLywt//vkn7OzsZMoPHz6M6dOnGygrIiIiIiIiIiIiIiIiIiLStwIFCmDLli3w9PTEx48fcfXqVYSHh4sSu0GDBvD29hase/fuHfbv3y9KO0RERERERERknnQ5rwFwboOIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiPRn4MCBuHPnDnLlyiVKvIcPH2LAgAHYs2cPLCwsRIn5pePHj+O3335TefvY2FjMmjULCxcuFD0XkvXmzRt06dIFZ8+eRY4cOUSNvWzZMuzevVthfVpaGtq1a4eLFy+iZMmSorYdHx+Pdu3a4e3bt6LGlQJjO56JjF16ejrat2+P06dPo2rVqjJ15cqVg6+vL2JjY3Hu3DmEhobi2bNnsLOzy9qmc+fOaNasGSpUqIBGjRopPDeHhIRg8ODBGuV46dIljfZTZs6cOZg+fXq2240ePRo1a9ZEzZo1s8rs7e0xa9YsTJo0CWfPnsX58+fx+vVrfPjwATlz5kTevHlRpUoVtGzZEm5uboJxt2/frlL7psqQ76kx50JE/5k4cSJq1KiBJk2ayJS3b98e7du3x6tXr3Du3DlERETg7du3SExMhLW1NXLlygU3NzfUq1cPVatWFRwLZmZmYsCAAbhy5YrK+YwYMQJNmjRB0aJFs8rs7e2xZMkS/Pbbbzh16hRu3bqFV69e4dOnT3BwcEDhwoVRpkwZtGnTBk5OTnIx09PT0bNnTzx48ECN34ysnDlzIiAgAPb29lllnz59Qvfu3ZGYmKh2vIULF6JPnz6wsbEBAHz33XdYtmwZJk2ahOTkZJl2ly5divbt22eVpaSkYPHixRr/LEREUsL+l0h9nHtQzNjGvvqQmpqqs9gXLlzAuHHjsHTpUplyS0tLjBo1CiNHjsTNmzdx+fJlPHr0CDExMfj06RPs7e3h6uqK0qVLo3bt2qhcubJg/MzMTHh7e+Pu3bsKc9ixYwdatGgBLy8vmfLq1atj7969+PjxIy5cuIB///0Xz58/R3x8PJKSkmBvb49cuXLhm2++QZ06dVCmTBm52J8+fULXrl3x/v17DX47RPQ1Y++DjWXeUszxL8e+RKTLsRKg/njp1q1bGDx4MDZv3izXn/fs2RM9e/bEs2fPcOfOHbx+/RoxMTHIlSsXChUqhKpVq6Jw4cKCcdPS0tCjRw88f/5cpTy+xrkHIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIikqLatWsLlv/77796zoSIiMj0OTo6oly5clmv37x5Y8BsiIjMU9u2bQXLDx06pOdMiIjInFlYWMDb21uwbt26daK1Y4znPX397Lz+IiIiQ+M9OCIiIiL9sDZ0AkREREREREREREREUmRpaYkBAwbAzs5Optzf3x/9+vVDenq6gTIjIiIiIiIiIiIiIiIiIiJ9ateuHTZu3Ih8+fIBAJydnXHs2DE0a9YMDx8+1Cp2iRIlsG3bNlhaWgrWr1y5EqmpqVq1QURERERERETmS5fzGgDnNoiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiISL9evXqFH3/8Edu3bxct5r59+/Ddd99hy5YtcHBwEC1uYGAgevbsqfb3IP/++++oXbs2vvvuO9FyIWGXL19G06ZNsXPnThQtWlSUmCtWrMCYMWOy3S4yMhINGjTA/v37UbNmTVHafvHiBTp27IgbN26IEk+KjO14JjJ2MTExaNq0KTZv3oyOHTvK1bu4uKBDhw7o0KGDXN3w4cOzjR8UFITevXsjISFBlHz1KSkpCS1atMD+/fvRqFEjmToHBwe0bdsWbdu2VSvmqlWrMHr0aGRmZoqZKhGRyUhLS0ObNm2wfft2dO7cWa6+cOHC6Nmzp9pxP336hOHDh8PPz0+t/WJiYtCiRQucOXMGBQsWlKlzcnJCp06d0KlTJ5XjJSUloXfv3ggKClIrj6+tWrUKFStWlCkbOXIk7ty5o1G8sLAwTJ48GYsXL84qGz16NAYMGICQkBC8f/8eefLkQcOGDeHs7Cyz74QJE/DgwQON2iUikhr2v0Sa4dyDMGMb+5qCP/74A7a2tpg3b57c92dYWFigWrVqqFatmtpxU1NTMWrUKPzzzz/Zbvvjjz8CALy8vOTqnJ2d0bp1a7Ru3Vqt9mNiYtC9e3ecOXNGrf2ISDH2waoRc/zLsS8RAboZKwGaj5e2bt2KjIwM/PPPP7C1tZWrL168OIoXL65yvPj4ePTo0QOHDx9WK48vce6BiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIpKhly5aC5VevXtVzJkRERKZvyZIlMmvmhIaGGjAbIiLzY2dnhyZNmsiVf/r0CWfPnjVARkREZK46dOgANzc3ufKzZ88iIiJClDaM9bynj58d4PUXEREZHu/BEREREemHZfabEBERERERERERERHR1zIyMtC9e3dERkZmvZ42bRp69uyJ1NRUA2dHRERERERERERERERERET60KJFCwQFBSFfvnwy5cWKFUNoaCi+/fZbjWM3aNAAoaGhKFGihGD927dvsWTJEo3jExEREREREZF50+W8BsC5DSIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiMowdO3bAz89P1Jh79uxBvXr1cPPmTa1jRUdH46effkLnzp2RlJSkUYzu3btjxowZ/B5lPbh06RKqV6+Offv2aRUnNjYWffv2xejRo1Xe5/Xr12jQoAHmzp2LlJQUrdrftGkTqlWrhhs3bmgVxxQY2/FMZOxiYmLQqVMneHl54dWrV6LEfPv2LQYOHIgOHTogLi5OlJiGEBsbi2bNmmHWrFla9dOvXr3Cd999hxEjRiA9PV3EDImITE9SUhK6dOmCgQMH4t27d1rHu3r1KmrWrImNGzdqtH9ERAQ8PDxw8uRJrfK4fv06atWqhb1792oVp1+/fhg0aJBMma+vLzZs2KBV3CVLlmDBggUyZa6urmjXrh2+//57tGvXDs7OzjL1c+fOxYoVK7Rql4hIKtj/EmmHcw/CjG3sawoWLlyIhg0bIiIiQpR4t27dQq1atbB27VqVtk9PT4e3tzf69u2L169fa91+UFAQKlasiOPHj2sdi4hksQ9WThfjX459iUjssRKg/XjJ19cXtWvX1vo5i+DgYNSoUQOHDh3SOAbnHoiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiEjXHBwcRI9ZpEgRtG/fXrDuyJEjordHRERkrqytrbF27Vp4e3vLlJvK+mdERFLRpEkT5MiRQ678zJkzSE5ONkBGRERkrmbMmCFYvnz5ctHaMNbznq5/dl5/ERGRungPjoiIiEjaLA2dABERERERERERERGRVL1+/Rq9e/fGy5cv4enpiblz5xo6JSIiIiIiIiIiIiIiIiIi0qNTp07h8uXLgnW5c+fG7t27cfr0aXTt2hU5c+bMNp6lpSXq1auHvXv34vz588ifP7/CbYcMGYKEhASNcyciIiIiIiIi8yb2vAbAuQ0iIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIjIOP/74I168eCFqzNu3b6NatWro3LkzLl26hMzMTLX2f/jwISZPnoxSpUph9erVWuWSmZmJWbNmoVixYpgxYwYuX76MlJQUrWKSYlFRUejSpQuqVauGgIAAJCcnq7xvdHQ0lixZglKlSsHX11fttpOTkzFt2jSULVsWy5cvR0xMjMr7fvr0Cdu2bUP16tUxcOBAvH//Xu32TZUxHc9EUrF+/XqUKlUKP/zwA06ePImMjAy19k9KSsKpU6fQr18/FCtWDJs2bdJRpvqVnp6OGTNmoEyZMli+fDnevXun8r5hYWEYOXIkypQpg927d+swSyIi07Np0yYUL14cXl5euHDhglrnpbS0NBw6dAitWrWCh4cHwsLCtMrl5cuXaNGiBTp06IDTp08jPT1d5X3Pnz+P3r17o2bNmrhz545WeZQrVw5r166VKYuIiIC39//Yu+8wq6rzf9jPDEPvIKiIAVFQUVBURMQu9hZQ9IcFlNix69deYo8aFXsSAcVGVJpdAcESRMUCCBZQAQXFQgfpM+8feTXinIEp58w5Z+a+r4srutbez/qcs9deuzBOTi9T3V9dccUVccwxx8SMGTPWu93XX38d3bt3j6uvvjop4wJkOusvJI93D4ll0r1vRTB+/Pho27ZtdO/ePV577bUS3b9H/Pc7ff755+Owww6LDh06xKRJk0qc4amnnoott9wyTjnllHj77bdjzZo1Jdp/+fLlMWjQoDj88MPju+++K/H4QPFZgwtL5f2ve18gInn3Sp06dUrK/dKkSZNip512iuOOOy7eeuutYv9sQX5+fowaNSqOPPLI2GOPPWL69OmlzuDdAwAAAAAAAAAAAAAAAAAAAKmUm5sb1157bUyfPj2aNm2a1NqXX355VKlSpVD7ihUr4tVXX03qWABQWW288cYxZsyYOOOMM9ZpHzx4cLzxxhvpCQVQSR1yyCEJ2z3/AFCeTjrppNh5550LtX/99dcxfPjwpI2Tide9VH92z18AlIS/gwMAqBjy0h0AAAAAAACy2ZgxY6JVq1axatWqdEcBAAAAAAAAoJzl5+fHCSecEO+8805stNFGCbfZe++9Y++9947Vq1fHhx9+GNOmTYvZs2fHkiVLYsWKFdGwYcNo3LhxtGjRIvbcc8+oX7/+Bsf929/+Fi+++GKyPw4AAABQiSTjvUZEeLcBAAAAAAAAAAAAAAAAAAAAAAAU26effho5OTkpH2fRokWx+eabp6T2888/H88//3w0btw49tlnn+jSpUtsvPHG0bhx42jcuHFUqVIlli1bFosWLYoZM2bE1KlTY+zYsfHFF18kPcsPP/wQN9xwQ9xwww1RtWrVaNOmTTRs2DDq168ftWvXTrjPl19+mfQcyTiu77//flLnxoMPPhgPPvhg0upFREyaNCmOPfbYqF69enTu3Dn22WefaNGiRWy00UbRuHHjqF69eixatCjmzZsXn3zySbz33nvx+uuvx5o1a8o89qxZs+KCCy6Iiy++OPbYY4/Ybbfdol27drHJJptEvXr1Ijc3NxYvXhzz5s2LqVOnxoQJE+L111//7XeGlVQyj8czzzwTzzzzTJnr3HLLLXHLLbckIdH/ZNL5DNlg5cqVMXDgwBg4cGDUq1cvdt5559hpp52iefPmsfHGG8fRRx8d1apVi4iIV155JSZMmBDffvttfPHFF/Hee+/FqlWrSj1269atk/UxUuKbb76JCy64IC666KLYZZddYtddd43WrVtH06ZNo1atWpGfnx+LFy+OH3/8MT755JN45513ynRNnjZt2m/r9EMPPRRnnnlmsj5KsZX1OpFJxzSTsgDFt2LFiujfv3/0798/GjZsGLvvvntsvfXWsdVWW0XdunWjbt26ERGxYMGCWLBgQXz//ffx3nvvxYQJE2L58uVJz/PSSy/FSy+9FI0bN4699tor2rZtG1tssUXUqVMnateuHStXroylS5fGN998E1OnTo0333wz5s6dm7Txv/jii6hTp07S6iUydOjQGDFiROy5555xwAEHRPPmzaNBgwaxYMGCmDNnTowcOTL+85//xNq1a1OaA8he5fFe8PfK412k9ReSy7uHxNJ175uq9w/ffPNNuV8Tfm/t2rUxfPjwGD58eNSqVSs6dOgQHTt2/G19rV+/ftSoUSOWL18eixYtioULF8Y333wTEyZMiIkTJ5b6vfvvLV++PB599NF49NFHo1atWrHbbrtFmzZtYquttopGjRpF7dq1o2bNmrFq1apYsGBBLFy4ML7++ut47733YvLkyUn5ewegeNL5/iETr02pvv917wtEZN69UkFBwW8/99C0adPYa6+9Yvvtt48WLVpEnTp1okaNGrFixYpYvHhxzJgxI6ZMmRJvvfVWzJ8/Pynje/cAAAAAAAAAAAAAAAAAAABAqmy++ebx1FNPxR577BEREcOGDYuuXbsm5Xct7b///tG3b9+EfU8//XQsXLiwzGMAQGW32WabxYQJE2LTTTddp/3VV1+NPn36pCkVQOV10EEHJWx/9dVXyzkJAJXVVlttFffcc0/CvhtuuCEKCgqSNlamXfdS/dk9fwFQEv4ODgCg4shLdwAAAAAAAMh2q1atSncEAAAAAAAAANJk+vTpceihh8aoUaOifv36RW5XtWrV2G233WK33XYr03gPPfRQXHHFFWWqAQAAABBR/u81IrzbAAAAAAAAAAAAAAAAAAAAAAAAKoZ58+bF0KFDY+jQoemOEhERq1evjqlTp6Y7RqWwcuXKeOONN+KNN94o97HXrl0bb775Zrz55pvlPnZFlmnnM2SDxYsXx9ixY2Ps2LG/tf3000+x0UYbRUREv379YuTIkemKlzb5+fnx/vvvx/vvv19uY9aqVeu3f161alW5jQuQSRYsWBAvvfRSvPTSS+mOEvPmzYvhw4fH8OHD0x0lJdauXZu25yGAysz6S2Xk3UNi6br3rajvH3755ZcYN25cjBs3Lq0ZxowZE2PGjElbBqB4Mun9Q0Xm3hf4vUy7V/rxxx9jyJAhMWTIkHRHSTrrLwAAAAAAAAAAAAAAAAAAQOXSrVu3GDhwYDRo0OC3ti5dusTIkSOje/fu8fPPP5e69n777RdDhw6NnJycQn1r1qyJm2++udS1AYD/mTNnTowfPz66d+/+W1v//v3j7LPPjtWrV6cxGUDl86c//Sm23XbbQu2zZs2KL774Ig2JAKhsdt1113j22WejYcOGhfo+++yzePzxx5M2VqZd98rjs3v+AqC4/B0cAEDFkpfuAAAAAAAAAAAAAAAAAADZbMKECdGxY8d47rnnEv7SmmRYvXp1XHHFFXHnnXempD4AAABQOZXHe40I7zYAAAAAAAAAAAAAAAAAAAAAAAAAAJJtyy23/O2f582bl8YkAAAAQEXl/QMAAAAAAAAAAAAAAAAAAAAAAEDF0aZNm2jQoEGh9j333DOmTp0al19+eTzxxBOxevXqYtds1KhRXHLJJXHJJZdE1apVE25zzz33xPTp00sbGwD4g5NPPjnatWsXm2++eVxwwQXxz3/+M92RACqlrbfeOt54441C7a+99lr5hwGgwsrJyYmqVatGTk5O1K5dO5o2bRo77bRT9OjRI4444oioUqVKwv3OOuusyM/PT1qOdF33/vj5Dz744HL97J6/ACgOfwcHAFCx5KU7AAAAAAAAAAAAAAAAAEC2mz59euy0005xySWXxOWXXx61a9dOWu3//Oc/cd5558XHH3+ctJoAAAAAv0rle40I7zYAAAAAAAAAAAAAAAAAAAAAAAAAAJLtgAMOiN133z0iIlatWhVTpkxJcyIAAACgovH+AQAAAAAAAAAAAAAAAAAAAAAAoGL5+9//Ht26dYtOnToV6mvatGkMHDgw/va3v8WLL74Yb731VkybNi1mz54dy5Yti5UrV0ZeXl40atQoGjduHB06dIj99tsvDjvssKhbt26RY3788cdx5ZVXpvJjAUCls2TJkvjzn/8cVapUiU8++STdcQAqrVGjRsWoUaPSHQOACq5Hjx7x9NNPl2if+++/P958882k5kjXda+knz/Zn93zFwDF4e/gAAAqlrx0BwAAAIBU+O677+Lzzz8v1D5nzpw0pAEAAAAg23i/BAAAZZPt99TZnh8ASJ8VK1bETTfdFP/4xz+iV69e8Ze//CXatm1bqlorV66MV155JR544IEYPXp0kpMCAAAArCuZ7zUivNsAAAAAAAAAAAAAAAAAAAAAAAAAAEiVE044Ifr37x85OTkREfH444/H8uXL05wKAAAAqEi8fwAAAAAAAAAAAAAAAAAAAAAAAKh41q5dG4cffni888470bp164TbNG3aNPr06RN9+vQp83hff/11HHroobFq1aoy1wIA1vXpp5+mOwIAAJCBxo4dGxdddFG6Y6RFqj675y8ANsTfwQEAVCx56Q4AAAAAqXDxxRfHxRdfnO4YAAAAAGQp75cAAKBssv2eOtvzAwDp9/PPP8ddd90Vd911VzRv3jz22Wef6NChQ2y55ZaxxRZbRL169aJ27dpRs2bNWLlyZSxfvjx+/PHH+Pbbb2Py5Mnx/vvvx9ixY2PZsmXp/igAAABAJVOS9xoR4d0GAAAAAAAAAAAAAAAAAAAAAAAAAEA5yc3NjbvvvjvOO++839omTZoUF154YRpTAQAAABWJ9w8AAAAAAAAAAAAAAAAAAAAAAAAV288//xx77bVXDB06NHbfffeUjfPBBx/E4YcfHj/88EPKxgAAAAAA/ufll1+OHj16xOrVq9MdpdxV5s8OQGbwd3AAABVHXroDAAAAAAAAAAAAAAAAAFRUs2fPjieeeCKeeOKJdEcBAAAAKBHvNQAAAAAAAAAAAAAAAAAAAAAAAACA4rj44oujRo0aERHx6aefpjlNxZWfnx9bbbXVb/8+ZsyYOProo2PJkiVpTAUAAACp591D+fH+AQAAAAAAAAAAAAAAAAAAAAAAoOKbO3du7LPPPnHFFVfEZZddFrVq1Upa7ZUrV8add94Z1113XaxZsyZpdQEAAACAxH744Yf461//Gv/4xz/SHaXcVebPDkDm8XdwAAAVQ166AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQfR577LF0R6g0TjzxxPj444/jmWeeiSuuuCLWrl2b7kgAAACQct49lC/vHwAAAAAAAAAAAAAAAAAAAAAAACq+1atXxw033BD9+/ePs88+O0455ZRo1qxZqestWrQoHn300bjrrrvim2++SWJSAAAAACAiIj8/P5YvXx7z58+PmTNnxocffhijR4+O1157LdasWZPueCmXn58fc+bMqZSfHYDs4e/gAACyX166AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARVuwYEFst912sWzZsnRHAQAAACoo7x8AAAAAAAAAAAAAAAAAAAAAAAAqj++++y6uvvrquPbaa2OnnXaKffbZJzp27BitWrWKli1bRr169aJatWrr7LN8+fKYM2dOfPXVV/Hhhx/G2LFj480334zVq1en6VMAAJRMTk5OuiMAGaRz587pjpCxfDcA6ffMM8/EM888k+4YaVPZPz8A2cvfwQEAZK+8dAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANZv2bJl6Y4AAAAAVHDePwAAAAAAAAAAAAAAAAAAAAAAAFQu+fn58cEHH8QHH3xQqK9KlSpRvXr1KCgoiBUrVkRBQUEaEgIAAAAAAEB28XdwAADZJy/dAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMgMa9eujV9++SXdMQAAAAAAAKDC8HdwAACZKTfdAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKC85KY7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJSX3HQHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgPKSm+4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUF5y0x0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyktuugMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAeclNdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoL3npDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABA9qhdu3Y0aNAgqlSpkrD/m2++KedEAAAAAAAlk5fuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG/LAAw9E27ZtC7WfddZZ8fnnn6chEVBczl8AAKA8jR07NmH7vvvuW85JACqOLbfcMg477LDYe++9o1OnTtG0adOoWrXqevfJyckpp3RAunj3SyYyL6Hi8HwPAEB5yEt3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACADdlpp51it912K9Rer169NKQBSsL5C2SiZs2axZZbbhl/+tOfok6dOlG7du3Iy8uLVatWxeLFi2PJkiXx448/xpQpU2LevHnpjgsAlMA+++yT7ggAFUbbtm3j2muvjR49ekRubm7S6larVi1h+6pVq5I2RqaqzJ+dise7XzKReUlFU5nvHTzfAwBQHvLSHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAglRo1ahTHHntsHHjggbHnnnvGRhttVOx9f/jhh3j//fdjxIgR8fzzz8fPP/+cwqQAlVu9evXiggsuSNhXUFAQd911VyxbtqxcM+29996x9957J+x75513YvTo0eWa57zzzosGDRqU65i/9+mnn8aQIUPSNj5AKhS1tg4ZMiQ+/fTT8g+UIY477rgYNGhQVK9ePal127RpE1988UXCvq233jqmTZuW1PEySbI/e7LvC1atWhUrVqyIn3/+OebOnRtffvllzJo1KwoKCpI2BkBllmjdnj59egwePLjcs5x99tkJ35HefvvtsWLFiiL369OnTzRv3rxQ++rVq+PWW29NasaSOvTQQ2OXXXYp1D579uwYOHDgevfN1PvBynzfBAAA5SUv3QEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUqFdu3Zx7bXXxlFHHRVVq1YtVY2NN944jjjiiDjiiCMiPz8/RowYETfddFN8/PHHSU4LwOLFi2OTTTaJs846K2F/ixYt4tRTTy23PM2aNYthw4ZFo0aNCvX99NNP8Y9//KPcsvzqwgsvjJYtW5b7uL8aMmRIDBkyJG3jA6RCUWvr559/Hp9++mn5B8oAZ5xxRjz00EORk5OT7iisR3ncFyxdujQmTJgQo0aNimHDhsUXX3yR0vEAKrJE63Z+fn7MmTMn3nrrrXLNcu6558Y222xTqP3++++PFStWFLlfs2bN4vrrr0/Y99Zbb8W4ceOSlrGk7rvvvmjVqlWh9quvvnqD+7ofBACAyis33QEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkqlBgwYxaNCgmDRpUhxzzDFRtWrVpNTNzc2N7t27x0cffRTDhw+PjTfeOCl1Afifiy66KD7//POEfX/5y1+iW7du5ZZl0KBB0ahRo4R9p5xySvz444/llgUAyku7du3innvuiZycnA1uu3bt2lixYkXCP1QMderUiX333TduueWW+Pzzz+M///lPHHbYYemOBVBh5ObmxuOPPx7169dPd5RiefTRRyM/Pz9hX+/evcs5zf906dIlWrVqVag9Pz8/Bg0alIZEAABAtshNdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAZOncuXN8+umn0atXr8jJyUnZOH/+859j6tSp8ec//zllY1A5dOnSJV555ZVCf6688sp0R4O0WLFiRfTs2TNWrVqVsL9///6x6aabpjzH+eefH127dk3Y99BDD8VLL72U8gwVgTUOMp/zlD969NFHo3r16gn7fv7557jhhhuiU6dOUa9evcjLy4uaNWsm/EPF1KVLl3jxxRdj1KhRsfnmm6c7DkCF8Kc//SkeeuihdMcoltmzZ8fo0aMT9h177LFF3kOkWu/evRO2jxo1KmbPnl3OaQAAgGySl+4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMlw+OGHxzPPPBM1a9Ysl/EaN24cw4YNi759+8ZDDz1ULmNS8Wy88cZx8MEHF2pfunRpGtJAZpg4cWJcddVVcccddxTqa9SoUTz22GNxwAEHpGz87bffPm677baEfZ9//nlcdNFFKRu7orHGQeZznvJ7e++9d+y0004J+0aNGhXHHHNMLF68uJxTkYm6du0aH3/8cRx11FExbty4dMcByHo9e/aMF198MZ566ql0R9mg/v37x4EHHliovX79+nHkkUfGs88+W655qlevHscee2zCvv79+5drFgAAIPvkpTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQFl16tQpnn322ahRo0aR2xQUFMS4cePitddei4kTJ8Znn30WCxcujMWLF8fq1aujatWqUadOndhoo41i6623jvbt28chhxwSnTt3jipVqiSsmZOTEw8++OBv/wtActx5551x6KGHxr777luor2vXrnHBBRdEv379kj5utWrV4qmnnorq1asX6lu1alX07NkzVqxYkfRxy2r27NmxcOHClI/z7bffpnwMANLnnHPOSdj+xRdfxJFHHpmR10AKK819QZUqVaJWrVpRp06daNiwYeTm5m5wn8aNG8drr70W++23X7z//vulTAvArx588MH4z3/+E9988026o6zXc889F/Pnz49GjRoV6uvdu3c8++yz5ZrnqKOOivr16xdqnz9/fjz//PPlmgUAAMg+eekOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAWdevWjWHDhkWNGjUS9q9duzb+8Y9/xG233RbffvttkXVWr14dCxYsiAULFsT06dPjxRdfjFtuuSU22WSTuOiii+Lss8+O2rVrJ9z3nnvuiY8++ijefffdpHwmgMquoKAgTjrppPjkk0+iYcOGhfr/9re/xeuvvx6ffPJJUse99dZbo127dgn7rrrqqpg4cWJSx0uWiy++OJ555pl0xwAgy+23334J2y+77LJYsWJFUsZYsWJFfPDBB0X2VWTl9dnLel9QvXr1aN26dXTo0CGOOOKIOOSQQ6JOnToJt61du3YMGzYs2rdvH/Pnzy/1mABE1K9fP5544onYe++9o6CgIN1xirRq1ap48skn49xzzy3Ud9BBB0XTpk3jxx9/LLc8vXv3Ttj+xBNPxKpVq8otRypU5vsmAAAoL3npDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQFjfeeGM0a9YsYd+sWbPiiCOOiE8++aTU9efOnRuXXnppPPTQQ/Hkk09G586dC22Tl5cXgwcPjvbt28eSJUtKPRYA/zNnzpw47bTTYsiQIYX6qlevHoMHD46dd945Vq5cmZTx9t9//7jwwgsT9o0dOzbuvPPOpIwDAJlo2223jUaNGhVqnzdvXrzwwgtJG+ebb76Jjh07Jq1eNsmWz75y5cqYMmVKTJkyJR5//PFo0KBBXHHFFXHhhRdG1apVC22/2Wabxc033xxnnXVWGtICVCx77rlnXHbZZfG3v/0t3VHWq3///nHuuecWas/Ly4uePXvGPffcUy45mjZtGgcddFDCvgEDBpRLhlTKlnsHAADIZrnpDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQWg0bNowzzjgjYd9XX30Vu+22W3zyySdJGWvGjBmx9957x0svvZSwv2XLlnHhhRcmZSwA/mvo0KHx6KOPJuzbbrvt4vbbb0/KOA0bNoxBgwZFTk5Oob4FCxbESSedFAUFBUkZCwAyUdu2bRO2v/fee5Gfn1/OacgkCxcujMsuuywOPvjgWLx4ccJtTj311Nh0003LORlAxXTDDTfEzjvvnO4Y6zV58uT46KOPEvb16tWr3HIcf/zxUaVKlULtH374YUyePLnccgAAANkrN90BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAErrhBNOiBo1ahRqz8/Pj5NOOinmzp2b1PFWr14d3bt3jw8//DBh/0UXXRT169dP6pgAld0555wTX331VcK+c889Nw466KAyj/HPf/4zNttss4R9p59+esyZM6fMYwBAJmvUqFHC9q+//rqck5CpxowZE2eeeWbCvry8vDj++OPLORFAxVS1atV46qmnombNmumOsl79+/dP2L7TTjvFdtttVy4ZTj755ITtRWUDAAD4o9x0BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAorf333z9h+0svvRTjx49PyZirVq2Kk046KVauXLlO+4oVK2LYsGFRu3btlIwLUFktW7YsTjjhhFizZk2hvpycnHj00UejcePGpa5/0kknRY8ePRL2PfroozFkyJBS1waAbNGwYcOE7YsWLSrnJGSywYMHF/msfdBBB5VzGoCKq02bNnH33XenO8Z6PfXUU7FixYqEfb169Ur5+O3atYsddtihUPuKFSti8ODBKR8fAACoGHLTHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgtDp27JiwffDgwSkd97PPPotBgwZFRMS3334bl19+eTRv3jz69OkT3333XUrHBqiM3nvvvbjxxhsT9m2yySYxYMCAUtVt2bJlPPDAAwn7vv766zj33HNLVRcAsk2NGjUStq9ataqck5Dpinrebt++fTknAagY3njjjYTtZ5xxRhxxxBHlG6YEFi1aFMOHD0/Yd+KJJ0ZOTk5Kx+/du3fC9mHDhsWiRYtSOjYAAFBx5KY7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBpNW3aNGH7Z599lvKxb7311ujevXu0bNkybrvttpg3b17KxwSozG666aZ45513EvYdddRRcdppp5WoXm5ubjzxxBNRt27dQn1r166NE044IZYuXVqqrAAAFdXEiRMTtm+88cZRrVq18g0DUAGcd955MXPmzIR9AwYMiI033rh8A5VA//79E7Y3a9Ys9t9//5SNm5ubGyeccEKJMgEAACSSm+4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDlUb169WjUqFHUrFkz3VFKrG7dutGwYcOoWrVquqNsUM2aNaNRo0ZRo0aNlI2Rl5cXDRs2zMhj+evnb9CgQeTk5KQ7TrH8em6k8piVVTafv2WVTXOqatWq0bBhw6hfv37GZ021X+dsnTp10h2lSFWqVIkGDRpk1PUlEzOtT82aNYvM+cMPP6R8/JkzZ8bw4cMjPz8/5WOtT7Vq1aJRo0ZRq1attObYkGy4n7KOkiyV/Z48VfLz8+OEE06IxYsXJ+zv169ftG7dutj1Lr/88ujSpUvCvuuvvz7efffdUuUk+2XDM1o2XFczQTYcywjHk3Vly7ytKHzfJTd37twi++rWrZvSsbPpPd2vsmGOVeZ3v8lgXqZGZZqXixYtihNOOCHWrl1bqK9JkybxyCOPpCFV8YwZMyZmzpyZsK93794pG/eAAw6ITTbZpFD7zJkzY+zYsSkbt7LLhrUDAABKKi/dAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAimmzzTaLbt26xV577RU77LBDtGzZMqpVq/Zb/5o1a2LmzJkxefLkGDlyZIwYMSJ++OGHNCb+r+rVq8dBBx0UBx10UOywww6x7bbbRsOGDSMnJ+e3bVatWhWzZs2KKVOmxDvvvBMjRoyIL7/8MmkZ2rZtW6jthx9+iHnz5iXcfr/99ovjjjsuOnfuHFtvvXWh7/mbb76JiRMnxpgxY+LZZ5+NH3/8scSZOnToEMcff3zsvvvu0a5du6hbt+5vfb/88kv89NNPMXny5HjllVfi5ZdfjlmzZpV4jJKqWrVq7LvvvnHwwQdH+/btY7vttosmTZpElSpVftumoKAgFi5cGPPnz49JkybFm2++GW+++WZMmjQpqVlKcswaNWoUPXr0iP322y86dOgQLVq0WOeY/fp9fvbZZzFq1KgYOXJkTJkyJal5NyRbz9+yyqQ5VRw77rhjHH744bHLLrtEu3btYrPNNovq1auvk3Xx4sXx6aefxocffhgvv/xyjBw5MtauXVvmsUu6TkX8d31t3759bLXVVlG/fv2oW7fuOmvrvffeGytWrChVnu233z6OOuqo2HXXXaN9+/ax2WabRdWqVX/rLygoiAULFsTUqVN/m7cjR44s9Xilseuuu8b+++8fu+66a+y4446x0UYbRZ06ddbZZtWqVTFnzpyYMmVKfPzxx/Hiiy/GhAkTyiXX6aefnjGZSqKgoKDIvt/Pr0xW0vOpYcOG0a1btzjggANihx12iFatWq1z7q9duzbmzp0bkydPjgkTJsTw4cNj4sSJqYqfUCbcTxVHea2jG220UTRt2rTI/j/96U8J2+vXr59wfqzPqlWrivU9pmMdb9q0aWy00UYlHrckcnJyYtttty3Unp+fH59//nmJarknz1wzZ86Mc845Jx577LFCfbVq1YqnnnoqOnfuHGvWrFlvnV122SWuv/76hH3jx4+Pm2++OSl5K7pMXONKqmHDhnHUUUfFIYccEu3bt48tt9xynXvJdD+jZcp1NR3XjpKOmQ3P2+k4nhXhPM0mmT5vGzVqFJtssknCvo033rjI9pLOhYiITz/9tMi+ouqtb5/i1smk77u4mSNK/tnTaeXKlUX2/f49Wllkynu6bJxjG1JZ3/0mg3mZOuZlxDvvvBO33nprXH311YX6DjnkkOjbt2888MADaUi2YY888kjC5+vu3bvHmWeeGcuWLUv6mCeffHLC9oEDByZ9rHSrzPdNqVa9evXYcssti+xfsmRJfPvtt+WYCACAdMgpWN9Pnvx+wyz5IRQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgD8q5q9lT8jvageK0r59+2jfvn1E/Hed+frrr+Pdd98t05oDUFyHHHpI7LfffumOQSUyY8aMePCBB9MdAyBl+vTpE9u23TbdMagk3nnnnRg+bHi6YwCkzJVXXRkNGzZMdwwqiWFDh8X48ePTHQMgJRo0aBBXXX1VumNQydz59ztj7ty56Y4BkBKtOkYcc2O6U1CZ3H5wuhMAVGw5OTmxyy67RJs2bX77ee/JkyfH5MmT05wMAIBsc8ONN0TNmjW9IwcoZ7/+nNkD9z8QM2fOTHccgErj7L5nxxZbbBEDBgyIzz/7PN1xACqFX//bRT/7DlC+unXvFrvvvnu8/NLLMXbs2HTHAag0fv29WGPGjIlXXn4l3XEAAEjA72oHUsHvagcyzb777huHHnZoumNQCXk3ClQmrrekg2stUJn4/yYjHfzMJVCZuNaSLv4bM6AyOeCciA6HpzsFlc3I+yImvpTuFADly+9qzyx+phaKb88994xrrrkmunbtWqL/XmXNmjXxxBNPxPXXX1/o91iOHz8+dtttt0L7dOrUKd5///2yRo6IiM033zyuuOKKOOmkk6JOnTol3n/ChAlxyy23xIgRI8qcJdHactlll8Xtt9++TttBBx0U/fr1i2222abYtdeuXRuPPfZYXHPNNTFnzpwNbr/bbrtFv379olOnTsUeIz8/P5566qm4+uqrY9asWcXer7g22WSTuOSSS+K0006LevXqlarGhAkT4tZbb40RI0YkZS0vzjFr1qxZ3HDDDdGrV6+oWrVqieq//fbbce2118Ybb7xR1qjrla3nb1ll4pwqSq1ateK0006L888/P7bYYosS7//TTz9Fv3794u67747ly5eXOkdx16nc3Nzo0aNHnHbaabH33ntHXl5ekTUbN24c8+fPL3aGqlWrRu/eveOSSy6Jrbfeuvjh/3/Lli2LJ554Im677baYMWNGifcvjqpVq8aZZ54ZZ555ZrRt27ZUNWbPnh333ntv/POf/4zFixdnRK5UZCqL5cuXR40aNQq1t2vXLqZMmZKGRCVT3POpefPmcc0118Qpp5xS4uvI559/Hrfccks8+eSTkZ+fX6a865NJ91NFScc6eu2118b1119f4rFK4+2334699tprg9ulYx2/9dZb4/LLLy/WuKVVq1atWLZsWaH2pUuXRt26dUtUyz155vv3v/8dxx13XMK+W265Ja666qoi961Zs2ZMnDgx2rRpU6hvyZIlscMOO6Ts/qCsZsyYES1btizUftxxx8UzzzxT7nmyZY2LKPw7NZo2bRpXX311nH766VG9evUSZ0n1M1qmXVfTce0o7pjZ8LydzuOZiedppknm2prp8/aiiy6KO++8s8T7ldR3330Xm222WZH9xV2rNyTTv+9EkvXZI9J3X9CyZcsi75WaNGkSP//8c6lrZ9p7umycY0WprO9+k8G8TJ3KNi+LWrdbtGgR33zzTVSpUiXGjx8fHTt2LLTNihUrYqeddorPPvssKVk+++yzhO8ySvqePuK/97ozZ86M3NzcQn29evWKxx9/vNQ5E6lbt2788MMPUbNmzXXa8/Pzo2XLlvHtt9+WuGamPWv/nvumwpLxOzPr168fL730UnTp0iVh/zfffBMHHnhgfPHFF2UeC4DkyMnJiY4dO0br1q39PC1QbMV5Bi/8JAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUApNmjSJYcOGxVtvvRUHHHBA5OTklGj/vLy8OPnkk2PKlClx9tlnpyhlYVWrVo2bb745vvrqqzjrrLOiTp06parTsWPHGD58eLz99tvRqlWrJKdcV5UqVeK+++6LV199NbbZZpsS73vKKafE1KlT47DDDityu9zc3Pj73/8e77zzTnTq1KlEY+Tm5saJJ54Y06ZNi5NPPrlE+65PTk5OXHLJJTFjxoy4+OKLo169eqWu1bFjxxg2bFiMGzcuNt1006RlLMrxxx8f06ZNi7/85S9RtWrVEu+/5557xtixY2PIkCFRu3btpOfL1vO3rLJtTvXs2TNmzpwZ/fr1iy222KJUNZo0aRI333xzTJ8+Pfbbb78kJ1zXNttsE++++278+9//jv333z/y8vKSVvvAAw+M6dOnx8MPPxxbb711qWrUrl07zjjjjJg+fXrcddddUaNGjaTli4jo0qVLTJw4Me69995o27Ztqes0b948br/99pg5c2b07t07I3IlO1NZ/fzzzwnb27dvX85JUufkk0+Ozz77LE4//fRSXUe22WabeOyxx2LixIkp+V6y5X4q29bR0pg6dWrSaqVyHa8IKus9eSY544wz4ttvv03Yd/nll8eee+5Z5L533313tGnTJmFf3759Y8aMGUnJSHIlc43r1q1bfPrpp3HuuedG9erVS7x/Kp/RsuW6mkg6rh2Z/rydzcezNJJ5nlZkmT5vk+GLL75Id4TfVIbvu7w1adKkyL7FixeXqma2vaf7vUyfY5X13W8ymJfmZXlbu3ZtHH/88bFs2bJCfTVq1IjBgweX6nim2rfffhuvv/56wr5UvD/u0aNH1KxZs1D76NGji3xPQPFk+tqRLJtuumm8/fbb0aVLl4T9U6ZMic6dO2fUPS0AAKmTm+4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAED223XXXWPKlCnRrVu3MteqXbt2PPDAA/Gvf/0rcnNzk5CuaM2bN4/3338/rrzyyqhatWpSau6xxx4xefLkOOyww5JS749yc3Nj6NChcc4555SpTv369eOFF16I//f//l+hvmrVqsVLL70UF198ceTk5JR6jGrVqsUjjzwS11xzTVmiRkREvXr1YsyYMXHHHXdEjRo1ylzvV507d46PPvooOnXqlLSaf3TTTTfFk08+GbVr1y5zraOPPjrefffdaNmyZdmD/f+y9fwtq2yaUzVr1owhQ4bEU089FU2aNElKzc022yxGjRoVl156aVLq/VGnTp1i/Pjx0bFjx6TWzc3NjQceeCBee+21aNGiRVJqVqlSJS688MKYPHlybLPNNkmp2bt373jzzTejbdu2SakXEdGwYcN49NFHY9iwYVG9evWMyJWMTMkwffr0hO3JWNcyQb9+/eKRRx6JOnXqlLlWu3btYsKECXHyySeXPdj/Lxvup7JxHS2tqVOnJqVOqtbxiqKy3pNnmkWLFsWJJ54Y+fn5hfpyc3PjiSeeiHr16hXqO/zww+OMM85IWPPpp5+Oxx9/POlZSY5krXGXXnppDBs2LBo3blzmWsl+RsuG62pR0nHtyPTn7Ww+nqWVrPO0Isv0eZssX3zxRbojRETl+b7LW6tWrRK2z58/P1atWlXietn0nu6PMn2OVdZ3v8lgXv6XeVn+vvzyy7jgggsS9u2www5x8803l2+gYhowYEDC9n333TeaN2+e1LF69+5dogwUT6avHcnSunXrGD9+fLRr1y5h/9tvvx177LFHfPfdd+WcDACAdKkYT5MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQNrsvffe8frrr0fTpk2TWve0006Lf/7zn0mt+XutW7eOd955J3bcccdibb9mzZpYvnx5sbatXbt2jBgxIo477rgyJEzsoYceiqOOOioptXJycmLQoEHRqVOnddr//e9/x8EHH5yUMSIibrjhhjjxxBNLvX/Dhg3jjTfeiH322adY2+fn58eyZctizZo1xdp+k002iRdffDE233zzUmdcn6uuuiqp9bbffvsYOXJk1K1bt8y1svX8LatsmlONGjWKN954I44++ugy1/qj3NzcuO2225I+R1u1ahWvvvpqNGjQIKl1a9SoEc8991ycffbZSa37q1+vC126dClTnVNOOSUeeeSRqFKlSrG2X758efzyyy9RUFBQrO27desWr732WlSvXj1lucorU7KMHj06YfvRRx8dHTp0KOc0ydWvX784//zzk1qzWrVqMXDgwDjvvPPKXCsb7qeycR0ti6lTp5a5RqrW8YqkMt6TZ6q33nor7rjjjoR9f/rTn+If//jHOm1NmzaNgQMHJtz+22+/jTPOOCPpGUmeZKxxffv2jdtuuy0Jaf4nWc9o2XBdLUo6rh1XXXVVRj9vZ/PxLItknKcVWabP22T64osv0h2hUn3f5a179+4J2z/66KMS18qm93R/lOlzrLK++00G83Jd5mX569+/fzz33HMJ+y655JLYd999yznRhg0fPjwWLFhQqD03NzdOOOGEpI3TsmXL2HPPPQu1z58/P0aMGJG0cSqbTF87kmXnnXeOcePGRYsWLRL2P/fcc3HAAQfEokWLyjkZAADplJfuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABA9tpyyy1jxIgRUadOnSK3WblyZYwZMyZefvnlmDx5cvzwww+xcOHCqF69ejRu3DjatWsXXbt2jaOOOirq1au3zr6nnnpqTJo0Kem5GzVqFCNHjozNN9+8yG0mT54cTz/9dIwcOTK++uqrWLBgQUREVKtWLTbaaKPYZZdd4sADD4wTTjghGjRoUGj/vLy8GDRoUMycOTPee++9pOTu3r17nH766YXav/766xg0aFC8+eabMWvWrFixYkU0atQoNt1009hvv/3imGOOiTZt2iSsWa1atRgwYEDsuOOOsWbNmrj44oujW7duhbZbuHBh/Pvf/46XX345Pv/881iyZEnUqVMnNt5449hll12iW7dusffeexeZ/cEHH4xx48bFjBkzSvy5n3zyyejQoUOR/W+//XYMGTIkxo0bF9OmTYslS5b81le3bt3YYostYp999olevXrFzjvvnLDGRhttFEOHDo0uXbrE6tWrS5yxKF27di3UVlBQEG+99VaMGDEiPvjgg5gzZ0788ssvUa9evWjSpEl06NAhDj300DjooIOiSpUqCeu2bt06Bg0aFN27dy91tmw9f5MhW+ZUtWrV4oUXXohdd921yG3Wrl0b48aNi5dffjk++OCD+OGHH2LevHmRk5MT9evXj9atW8dee+0VPXv2jGbNmiWscdNNN8WXX34ZTz/9dKly/l6VKlVi2LBhCdfFsnr88cfj8MMPL7I/Pz8/xo8fHy+88EJMmDAh5s6dG/Pnz49atWrFxhtvHFtttVUceuihcfDBBxeZr2HDhvHSSy9F586d47PPPitxxlatWsX9998fOTk5Cfu/++67eOqpp+K1116LKVOmxI8//hj5+fm/9Tdq1CjatGkTe+yxRxx99NGx2267Jayz9957x7333htnnHFG0nL17t27XDMl0yuvvBI333xzofacnJwYMWJE7LHHHvHtt9+We66y6tWrV5x//vmF2letWhWvvfZavPLKKzFx4sSYO3du/PLLL1G7du3YeOONo3Xr1nHwwQfHIYccUuRcz8nJiX79+sXXX38dL774YqnyZcP9VKaso7Nnz4533323yAyNGzeO1q1bF2qfP39+TJs2bQOfcl1Tpkwp0fZ/lMp1vKKorPfkmezqq6+Orl27Jrwv69mzZ7zwwgsxePDgiIh45JFHokmTJoW2y8/Pj5NOOikWLVqU8rwVTTatcbvttlvcc889hdoz4RktG66rRUnHtaNr165xww03FGrPhGMZkXnHM5vO04osU+bt999/X+R8aN68eTRv3rxQ++zZs2P27NkbrP17H3zwQYm2T7ZM+b4rorZt28ZRRx2VsO+5554rcb1seU/3R5k+xyrzu99kMC8LMy/L31/+8pfo1KlTbLLJJuu05+TkxGOPPRbt2rWLhQsXpidcAqtWrYonn3wyzjnnnEJ9J598ctx2221JGeekk05K+J77ySefjFWrViVljMom09eOZNl///3XuwY9/PDDceaZZ67z9yMAAFQOOQUFBQXF2rCIH7oBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMh0xfy17An5Xe1AUdq3bx/t27ePiP+uM19//XW8++67ZVpzAIrrkEMPif322y/dMahEZsyYEQ8+8GC6YwCkTJ8+fWLbttumOwaVxDvvvBPDhw1PdwyAlLnyqiujYcOG6Y5BJTFs6LAYP358umMApESDBg3iqquvSncMKpk7/35nzJ07N90xAFKiVceIY25Mdwoqk9sPTncCgIotJycndtlll2jTps1vP+89efLkmDx5cpqTAQCQbW648YaoWbOmd+QA5ezXnzN74P4HYubMmemOA1BpnN337Nhiiy1iwIAB8flnn6c7DkCl8Ot/u+hn3wHKV7fu3WL33XePl196OcaOHZvuOACVxq+/F2vMmDHxysuvpDsOAAAJ+F3tQCr4Xe1Aptl3333j0MMOTXcMKiHvRoHKxPWWdHCtBSoT/99kpIOfuQQqE9da0sV/YwZUJgecE9Hh8HSnoLIZeV/ExJfSnQKgfPld7ZnFz9RCYXl5efHhhx/+dm780dq1a2PgwIFx/fXXx5w5czZYr27dunHeeefF1VdfHTVq1Pit/Zdffon58+dH8+bNC+3TqVOneP/990ucfdSoUdG1a9eEfd9++21cdNFFMWTIkGLVqlevXlx22WVx+eWXR25ubqH+2bNnxzbbbBPLli0rdr5Ea8v1118fp512WjRr1uy3tiVLlsTFF18cAwYMiPz8/CLr5ebmRt++feOOO+6I6tWrJ9zmjDPOiNdffz0+/fTTqFat2jpZ+vXrF3/9619j8eLF6819wAEHxMMPPxwtWrRI2D9s2LA4+uij11vjj84999y49957E/Z99NFHcdZZZ5VoDnTv3j0eeeSRqFevXsL+008/PR5++OESZYxIfMyuu+666NOnzzrfx0svvRSXXXZZTJ06dYM127ZtG/fee2/sv//+RW5z7LHHxrPPPlvivNl8/pZVtsypiIgBAwZEnz59iuwfMmRIXHXVVTFt2rQN1srLy4tzzjknbrnllqhZs2ah/kWLFsX2228fs2fPLla2RHP+sssui5UrV0a/fv0K9S1YsCCee+65ePHFF+OTTz6JH374IRYtWlSssSIirrnmmrjhhhuK7H/11Vfj0ksvjU8++WSDtWrXrh0XXXRRXHrppVGnTp2E28yYMSN23HHHDa57f/T888/HEUccUag9Pz8/rr322vj73/8eK1euLHa93XffPR566KEiz9UDDzwwRo0aVa65kpUp2V5//fUi/45w3rx5cfbZZ8czzzxTzqmKJ9H5dPfdd0efPn2ifv3662z30EMPxc033xzffffdBuvWrl07Lrzwwvi///u/IteoxYsXx3bbbVfsc//3Mv1+KiKz19Hf6969ewwdOjRhvh49epS4XnGU9zoeEXHrrbfG5ZdfnnDc22+/vUS1ilKrVq2E82Tp0qVRt27dEtVyT55d2rRpEx9//HHUqlWrUN+iRYuiffv2ceihh8ZDDz2UcP+//e1vccUVV6Q6ZlLMmDEjWrZsWaj9uOOOy8hrXaascRERn3zySbRr126dtkx5RsuG62o6rh3FfdaOyJxjGZEdx/P30nGeZppkrq3ZOm8jIq699tq4/vrrC7Vfd911630mL42i1uqS/v6jbPy+k/XZI8r/vqB+/foxduzY6NChQ6G+JUuWRMuWLWP+/PnFrpcN7+mycY5V5ne/yWBempepVNS63aJFi/jmm28KtR900EHxyiuvJLxGPPPMM3HccceVOstnn30W22yzTaH2xo0bl2gt/70ddtghJk6cmLBvl112iQ8//LBUdX/vyy+/jC233LJQ+4477hiTJk0qdd1MftZ231RYST97jx494oknnljnfdvv3XjjjXHttdeWOB8A5SsnJyc6duwYrVu39vO0QLEV52e8C795BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAohvPPPz/at2+fsG/BggVx4IEHxumnnx5z5swpVr0lS5bEzTffHB06dIgZM2b81l6rVq1o3rx5UjJHRJx44onRtWvXhH3jxo2LnXfeOYYMGVLseosXL46rrroqDjvssFiyZEmh/ubNm8f1119f6ry/+stf/hLNmjX77d9nzpwZO+20Uzz88MORn5+/3n3z8/Pjvvvuix49esSaNWsSbnPhhRfGjTfeGNWqVfutbfny5XHYYYfFRRddFIsXL95gxlGjRsXee+9d5DE/6qijSnQs69WrF9ddd13CvieeeCJ23XXXeP/994tdLyJi2LBh0aVLl1i0aFHC/v/7v/+LnJycEtUsyqmnnhotWrSIiIg1a9bEGWecEYcffnhMnTq1WPt/+umnceCBB8YjjzxS5DaXXnppqbJl6/lbVtk0p7p27Rp9+vRJ2Ld8+fLo0aNH9OjRI6ZNm1asemvWrIl+/frF7rvvHj/99FOh/vr165d5rapVq1ZcffXV67StXLkybrvttthiiy3ilFNOiaFDh8a0adOK/L4S2X777eOaa65J2PfruXXIIYfEJ598Uqx6y5YtixtvvDF22GGH+OyzzxJus8UWW8Ttt99e7IwREU2aNIlDDjkkYV/Pnj3j5ptvjpUrV5ao5jvvvBMdO3aMYcOGJey/4YYbyj1XMjKlwrXXXhsFBQUJ+xo3bhxPP/10TJ48Ofr27RubbLJJOacrubPOOivq16//278vWrQo9t9//+jbt2989913xaqxbNmyuOmmm2KnnXYqcq7Xq1cv7r777hLny4b7qWxcR9MtVet4RVIZ78mzxbRp0+LCCy9M2Fe/fv0YPnx43HXXXQn7P/zwwyLvNahY2rVr99s/Z9IzWjZcV4uSjmvH75+1IzLrWEZk9/EkdTJ93lY0vu/UaNOmTfznP/+JDh06JOy/+eabY/78+cWul03v6f4o0+dYZX33mwzmpXmZaV577bW4//77E/Yde+yxcdJJJ5VzovWbNGlSfPzxxwn7evfuXeb6nTt3ji233LJQ+0cffRSTJk0qc/3KKNPXjmQ466yz4t///vc679t+lZ+fH3379o1rr702DckAAMgUuekOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABknwYNGsR1112XsG/+/PnRqVOnGDNmTKlqf/7559GlS5eYPXt2WSImVKNGjbj99tsT9k2aNCm6du0aP/30U6lqv/rqq9GrV6+Efeeee25svPHGpar7q+bNm//2z/PmzYt99903vvzyyxLVeOGFF+LOO+9M2LfNNttEz549f/v3/Pz86N69e7zyyislGmPWrFnRu3fvhH1VqlSJM888s9i1qlatGoMHD44VK1as0/7yyy/HSSedFGvXri1Rtl9NmTIl+vbtm7CvdevWccghh5Sq7h9tvvnmEfHf7/K4446Lf/3rXyWukZ+fH3369Im33norYf8uu+wSe+21V4lqZuv5mwzZMqdyc3PjwQcfTNj3yy+/xD777BNDhgwpcc6IiIkTJ0bXrl3jl19+KdS36667RrVq1UpVNyKiZ8+esdFGG/327z///HPst99+cfnll8eiRYtKXfcf//hHVK1atVD76tWr49BDDy3VuRUR8fXXX0enTp3i3XffTdh/+umnx6677lrsekcccUTk5eUVan/66afjmWeeKVXGiIhVq1bFcccdF+PHj1+nfdSoUXHttdemJVdZM6XCuHHj4oYbbljvNu3atYv7778/vvvuu/j0009jwIABcc4558R+++0Xm2yySTklLZ4aNWr89s+//PJL7LfffjF27NhS1frqq6+iU6dO8dFHHyXsP+aYY6JLly4lypbp91PZuo6mW6rW8YqkMt6TZ5N//etf8fzzzyfs22mnnaJmzZqF2n/55Zc4/vjjY82aNamORwZJ9TNaSWTDdXV90nHt+PVZOyLznrez/XiSOpk8bysi33dy7bDDDvHAAw/E1KlTY/vtt0+4zWuvvVbk+leUbHlPl0gmz7HK/O43GcxL8zIT/d///V98+umnCfseeOCBaNmyZfkG2oABAwYkbO/Zs2fC99QlUdS7jqLGZMMyee1Ihr/+9a/x4IMPRm5ubqG+lStXxrHHHlvke2QAACqPwneLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAb0KdPn6hbt26h9oKCgjjxxBNj+vTpZar//fffx9FHHx1r164tU50/Ov7442PTTTct1L548eLo1q1brFixokz1R4wYEf379y/UXq1atejbt2+Zav9e7969Y+bMmaXa96abbor58+dvcLvbbrstXn311VKN8frrrxe570EHHVTsOvPmzYtzzz03tthii7jzzjtj2bJlsXDhwujVq1epcv3ek08+GZ988knCvv3337/M9X/vuuuui2HDhpWpxsknnxyrV69O2HfUUUeVqFa2nr/JkC1zqnv37tG6deuEfWeffXa8//77Jc73e5MnT46LLrrot39///33o1u3btG+fftYtWpVqeu2adPmt39euHBhdO7cOd55550yZd1zzz2jS5cuCfv+7//+L0aNGlWm+kuWLImjjz46fvzxx0J9OTk5ceWVVxa71pZbbpmwfdCgQaXO96s1a9bEKaecEsuXL4/HH388dthhhzjwwAOL9flTlassmVLlr3/9awwePHiD2+Xk5MS2224bffr0ifvuuy9ef/31+P7772PBggUxbty4ePjhh+OCCy6IAw44IDbbbLNySL5+Z599dnz00UdlqvHrXF+wYEHC/gsuuKDYtbLhfipb19F0S8U6XpFVlnvybNOnT5+YO3dusbe/8MILY9q0aSlMVH6222672GuvvZL6Z7vttkv3x0qJVD+jlUQ2XFfXJ93Xjkx73s7240n5yLR5W9FV1u+7NPcF+++/fxx11FFx4oknxlVXXRWDBw+Or776KiZOnBhnn3125OXlJRxr1KhR0a1btygoKChRxmx5T7chmTbHKvO732QwL//HvMwcK1eujJ49eyZ851S3bt148sknIzc3Nw3JEnvyySdj5cqVhdo32mijOPjgg0tdt1q1anHccccVal+xYkU89dRTpa7L/2Ta2lEWOTk58dBDD8V1112XsH/x4sVx8MEHx9ChQ8stEwAAmStznqgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgKxx1llnJWx/9NFH45VXXknKGO+//37885//TEqtX51zzjkJ2++9996YMWNGUsa49dZbIz8/v1B7r169klL/ueeei5deeqnU+y9dujSGDh263m3mzJkTN954Y6nHiIgYOHBgwvYddtghqlevXqJac+fOjUsuuSRatGgRRx55ZMybN69M2X5V1Pzac889k1L/V7feemuZa8yYMSNGjBiRsG+PPfYoUa1sPX+TKdPn1Pnnn5+w/fnnn49BgwaVOFci//rXv+Khhx6KffbZJzp16hQjRoyIgoKCpNSOiOjTp098+eWXZa5zySWXJGwfPXp03HPPPWWuHxHx3XffxWmnnZaw78gjj4zWrVsXq06zZs0Stn/11VelzvZ7X3zxRWy88cbRq1evmDx5crH3S2Wu0mZKpeOPPz6uu+66Us3nBg0axO677x6nnnpq3H333TFy5MiYPXt2LFiwIF577bX461//Gl27do0qVaqkIHlib7/9dtLO+5kzZ8all16asO/Pf/5zbLLJJsWqkw33UxVhHU23ZK3jFVVlvCfPFvPmzYvevXsX63x8/vnn41//+lc5pCof1157bbz55ptJ/XPxxRen+2Ml3aRJk1L+jFYS2XBdLa7yvnaUx7Es6fN2RTqepEYmztuKrDJ/36W5Lxg9enSMGDEiHn/88bjpppvi//2//xetWrUqcow1a9bE9ddfH4ccckgsX7681Fkz/T3d+mTiHPPuNznMS/My00yePDmuvPLKhH277757kX3psHDhwhg+fHjCvt69e5e67pFHHhkNGjQo1D58+PBYuHBhqevyX5m4dpRWtWrV4plnnokzzzwzYf/cuXNjr732ijfeeKNc8gAAkPly0x0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMgubdq0ia222iph35133pnUsW666aZYs2ZNUmr96U9/ig4dOhRq/+WXX+Luu+9OyhgREV9//XWMHj26UHuLFi1i2223LXP9G2+8scw1hg4dut7+fv36xfLly8s0xosvvhirVq0q1F61atWEx6E45s2bF2+//XaZcv3emDFjErZ36NAhqlSpkrRx1q5dm5Q6jzzySML2nXbaKWrVqlWsGtl6/qZKJs6ppk2bRpcuXRL23XbbbaXO9kcFBQVx9tlnx5tvvpm0mr8aPnx4DB8+vMx16tatG4ccckjCvltvvbXM9X/v+eefj6lTpxZqz8nJiWOOOaZYNapXr56wvaCgoEzZfm/JkiUl3ifVuUqTKdVuuOGG2GeffeKDDz5ISr0GDRrEgQceGNddd12MGjUqvv/++7j77rtju+22S0r99UnGdf/3Hn/88fjpp58Ktefl5cXBBx+8wf2z4X6qIqyj6Zasdbwiq8z35Nlg5MiRcd999613m7lz50afPn3KKVH2mjFjRrojJN0111yT8me04j6fZcN1tbjSce0oj2NZkuftinQ8SZ1Mm7cVne87db744oto27Zt/PWvf03ad5yJ7+k2JNPmmHe/yWdempeZ5M477yxyDl133XWx6667lnOiog0YMCBh+xFHHBENGjQoVc3evXuXaCxKJtPWjtKqU6dOvPLKK0X+vc6XX34Zu+++e0yaNCmlOQAAyC656Q4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGSXAw88MGH7W2+9FVOnTk3qWN9//328+OKLSal1wAEHJGwfPXp0zJ8/Pylj/OqNN95I2L7PPvuUqe6kSZPiww8/LFONiFhvjfz8/Bg0aFCZx1i+fHl8/vnnCfu22GKLMtdPhs8//zyWLl1aqD0vLy8aNmyYlDFmzZqVlDoREePGjYuCgoJC7Xl5edGiRYti1cjW8zdbJGNOHXzwwZGTk1Oo/eOPP4533nmnzBnLQ79+/ZJS58ADD4yqVasWap8yZUqMGTMmKWP8XlG5jzjiiGLtv3DhwoTt6V7zMjVXqr311lvRsWPHOOaYY+LVV1+NtWvXJq12kyZN4oILLojJkyfHgAEDomnTpkmr/XuzZs2KUaNGJbXmypUrY8CAAQn7Dj744A3unw33UxVhHU23ZK3jFZV78uwwe/bs9fYvWrQoli1bVk5psteMGTPSHSGpZs2aFS+88ELS6hX1jFbc57NsuK4WV3lfO8rrWJbkebsiHU9SIxPnbUXm+06trbfeOl577bW49NJLo0aNGumOk1Cq3/1m4hzz7jfzmZf/Y16WTq9evWLBggWF2vPy8uLJJ5+M2rVrpyFVYaNHj07492PVq1ePY489tsT1mjRpkvDd5axZs+L1118vVUb+JxPXjtJo0qRJvPnmm7Hffvsl7P/www9j9913r3DvOgAAKLvcdAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALJLp06dEraPHTs2JeO9/PLLSamzxx57JGx/7bXXklL/9959992E7dttt12Z6iYr688//xw//fRTwr6JEycW2VdSU6dOTdjeoEGDpNQvq4KCgvj+++8T9jVq1CgpY7z44otJqRMRsXjx4vjqq68S9jVs2LBYNbL1/M0WyZhTe+65Z8L2VKxVqfD555/HW2+9lZRa++67b8L2V199NSn1i1u3U6dOUb169Q3uX9Sx79mzZ5lylVWm5iovQ4cOjUMOOSQ222yzOOuss+KJJ54oci0tqdzc3OjTp09Mnz49Dj300KTU/L2RI0cmvWZExJgxYxK2d+zYcYP7ZsP9VLavo+mWzHW8onJPnvl23HHHuOmmm9a7zdZbbx133nlnOSXKXjNmzEh3hKRK5vNZRNHPaMV9PsuG62pxpOPaUV7HMqLyHU9SJxPnbUXm+069LbbYIm677baYPn16HHnkkemOU0iq3/1m4hzz7jfzmZf/Y16Wzpw5c+L0009P2LfVVltFv379yjfQejz66KMJ23v37l3iWscff3zk5eUVah84cGCJa1FYJq4dJdWiRYsYN25c7LTTTgn7R40aFXvvvXfS3rcBAFCx5KY7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQXbbeeuuE7ePHj0/JeG+//XZS6myzzTYJ21OR+/vvv0/Y3qZNmzLVfeedd8q0/+/NnTs3Yft7772X8jEaNGiQtDHKatGiRQnbGzVqlJT6b731VlLq/Orbb79N2F7cvNl6/maTss6pbbfdNmF7Ms//VHrjjTeSVqtt27YJ2//zn/8kbYzfmz17dsJzLDc3t8hz5/eKytWrV6/o0aNHmfOVVqbmKm8//PBD/OMf/4iTTjopttpqq9hoo41i7733jrPOOiseeOCBGDt2bPzwww+lql2vXr14/vnn44wzzkhq5lStoe+//34UFBQUam/ZsmVUq1Ztvftmw/1Utq+j6ZbMdbyiqoz35HvuuWd88sknSf/Trl27JH3K/6lRo0YMHjx4g+tZRMTZZ58dhx12WNIzVCQzZsxId4SkSvbzWUTiZ7Ti3vtnw3W1ONJx7SivYxlR+Y4nqZOJ87Yiq+zf95IlS+Lnn38u1Z8FCxbEypUriz1W8+bNY8SIEXHzzTen8BOVTirf/WbiHPPuNzuYl/9lXpbekCFD4rHHHkvYd+qpp8af//zn8g1UhEceeSThO8jdd989ttxyyxLV6t27d6G2goKCePTRR0sbj9/JxLWjJNq1axfjx4+P1q1bJ+wfPHhwHHbYYbFs2bKkjw0AQMWQl+4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEB2ad26dcL2yZMnp2S8r776KvLz8yM3N7dMddq0aZOwfdasWWWqm8iCBQsStjds2LBMdadPn16m/X9vyZIlCdunTZuW8jEaNGiQtDFKY5NNNoktt9wyWrVqFY0aNUq4TbVq1ZIy1meffZaUOr9atGhRwvbifqfZev5mumTOqa233jph+8cff1zqfOXpvffeS1qtbbfdNmH7Rx99lLQx/ujDDz+MzTffPGGWDZ0n//nPf2LevHnRuHHjddpzc3Pj6aefjsMPPzzuuuuumDRpUlIzb0im5kq3efPmxVtvvRVvvfXWOu2NGjWKbbfdNtq2bRvbbbdddOjQITp27Bg1a9Zcb70qVarEQw89FHPmzIkXX3wxKRmTed3/vUWLFsWsWbOiZcuW67Tn5uZGq1at4vPPPy9y32y4n8r2dTTdkrmOV1SV8Z68bt26sf322ycp0f9saG0tjbvuuiu22WabYm//yCOPxPbbbx8//vhj0rOUt+OOOy6eeeaZdMfIaMl+PotI/IxW3PMrG66rxZGOa0d5HcuIync8SZ1MnLcVWWX/vk899dQy3xfk5eVF06ZNY7vttosdd9wxjjrqqNh9990jJyen0LY5OTlx5ZVXxpo1a+K6664r07hlVV7vfjNxjnn3m7nMy8LMy7Lp27dv7LnnnrHFFlsU6uvfv3+8++67MXfu3DQk+59Zs2bF66+/Hl27di3U16tXr2JfL359R/tHo0ePjm+++abMOcnMtaO49thjj3jhhReKrLt06dLo27dvrF69OqnjAgBQseSlOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkF3q16+fsH3evHkpGW/16tXx3XffRfPmzctUp2HDhoXali9fHvPnzy9T3USWLl2asL1u3bplqvvdd9+Vaf/fKyrj3LlzkzbGkiVLErbn5uYmbYxEqlevHi1btowtt9wyWrVqFVtttVW0atXqtz81a9ZM6fi/N2fOnKTWW7x4ccL24n6n2Xr+plt5zqlGjRolbP/pp5+SNkYqTZo0KWm1mjRpkrA9ld/Fzz//nLB9o4022uC+q1evjltvvTX+/ve/F+rLycmJXr16Ra9evWL27NkxYcKEmDp1anz55Ze//fnhhx/KnL8suYYPH15umTLZ/PnzY9y4cTFu3Ljf2vLy8qJz585x4oknRs+ePYu8nufk5MRjjz0WO+64Y3zzzTdlzjJr1qwy1yjK/Pnzo2XLloXaE90vbag/0+6nsn0dTbdkruMVlXvyzHX44YfHWWedlbDvp59+Snhv0aRJkxg0aFAccsghqY5HBkj281lE4me04p5f2XBdLY50XDvK61hGVL7jSepk4rytyHzfZbdmzZr47rvv4rvvvotRo0bFHXfcES1btozbb789evTokXCfa6+9NiZMmBAvvvhiynJlyrvfTJxj3v2mj3lZNPMyNZYuXRonnHBCvP3221GlSpV1+ho3bhyDBg2Kgw46KE3p/mfAgAHRtWvXQu0nnXRSXHfddcWq0bt37yJrkxyZuHYUxxFHHBHPPPNM1KhRo8ht6tSpE//85z/j2GOPTdq4AABUPHnpDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZI9atWpFTk5OofaVK1fGqlWrUjbukiVLyrR/Ublr1qwZy5cvL1PtRBKNFRFRvXr1MtVdtmxZmfb/vfz8/LSNkSzNmjWLnXfeOdq3bx9bbbVVtGrVKrbccsto1qxZkcegvJV17v5RWb7TbD1/y1O651StWrUiNze3UPvKlStj5cqVKR8/GebNm5eUOjVr1owqVaoUal+5cmWsWLEiKWMksmDBgoTtdevWLdb+9913X3Tr1i26dOlS5DbNmzeP5s2bR7du3dZpX7ZsWXz11Vfx5ZdfxpdffhnTp0+PSZMmxeTJk8t8/IuTq1u3buWaKZusWbMm3n777Xj77bfjqquuiptuuinOOOOMhNs2bNgwbrzxxujdu3eZx128eHGZaxRl4cKFCdvr1KlT5D7ZcD9VEdbRdEvWOl6RuSfPTE2bNo2BAwcm7Pvhhx+iQ4cO8dxzz0XHjh0L9R988MFxzjnnxP3335/qmKRZKp5NSnuOZcN1tbjSce3IpGMZUbGOJ6mTafO2ovN9p8bMmTPj2GOPjZNOOikeeeSRhO9u7r///hg9enSZ39+k+z3dhmTaHPPut3yYlyVjXqbW+PHj45ZbbolrrrmmUN+BBx4Y5513Xtx7771pSPY/w4cPjwULFkTDhg3Xad9iiy2iS5cuMW7cuPXun5ubGyeeeGKh9gULFsTw4cOTmrUyy7S1ozhOOeWUePjhhxPei/xRjx49ok+fPkW+NwIAgLx0BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAskft2rUTti9evDil4y5btqxM+xeVOyKiRo0aZapdnlavXp3yMVatWpXyMcpiu+22i169esVxxx0XLVq0SHecDSqPY1Zc2Xr+plomzal0HaNkWrRoUVLqpOu7WLBgQcL2evXqFWv/VatWxVFHHRWjRo2KDh06lGjs2rVrR/v27aN9+/brtK9ZsybefPPNePLJJ+Pf//53LF++vER1y5IrlZmy1c8//xxnnnlmjB8/PgYOHBi5ubmFtjn++OPjmmuuiW+++aZMY/3yyy9l2n99ijpX69SpU+Q+2XA/VRHW0XRL1jpekbknz0yDBg2KJk2aJOw75ZRT4vvvv4/jjz8+Jk6cmHCtuOOOO2Ls2LExderUVEcljbLh+Swic66rxZWOa0cmHcuIinU8SZ1Mm7cVne87tR5//PGoW7duPPDAA4X6WrRoET169IjHH3+8xHUz6T3dhmTaHPPuN3XMy9IzL1Pv+uuvj4MOOih23XXXQn233357vP7662l9zl25cmU89dRT0bdv30J9vXv3jnHjxq13/65du8amm25aqP3JJ5/07iSJMm3tKI6BAweWaPv77rsvxo0bF1988UWKEgEAkM0K/9QHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEARcnJyEravXbs2peOuWbOmTPsXlZvCCgoK0h0hoRYtWsRTTz0Vn3zySVx66aXRokWLdEfKOtl6/qZKJs6pdB2jZFq8eHFS6uTm5iZsT/V3UVT9klxH5s2bF507d44HH3wwKXnz8vJi//33j4EDB8aXX34Zp5xySqnqJDNXsjJls0GDBsVf//rXhH15eXlx8sknl3mMVF6TSzPXs+F+qiKso+mWrHWcssm0e/JFixbFBx98kPQ/y5YtS0q+c845Jw4++OCEfQ888EC88sorERHx5Zdfxvnnn59wuxo1asTgwYOjWrVqSckEG5IN19Xicu2oWMcToLgefPDBeO+99xL29enTp0S1MvE9Xbbx7jf5zMuyMy9Tb+3atXH88ccnfL6uXr16RjznDhgwIGH7scceG9WrV1/vvr179y5RTSq3119/PY488sjIz88v1FerVq14+umn034+AACQmfLSHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANana9eu8eyzz0aDBg1KXWP+/Pkxffr0mD59enzxxRe//fMDDzwQu+22W/LCkhXMqdQpKChId4SMsHLlyujbt2/cc889ccUVV0T37t2jXr16Za7brFmzGDhwYBxwwAFxyimnxMqVK9Oeq6yZstktt9wSp5xySmyxxRaF+vbdd9+44YYb0pAKysY6TiLjxo2Ljh07pjtGQtttt13ccccdCfs+++yzuOSSS9ZpGzBgQBx22GHRrVu3Qtu3a9cu/va3v8VFF12UkqxQUbl2AFReDz30UHTq1KlQe+fOnaNq1aqxevXqDdbwno5MZF6STb766qs4//zzo3///oX6MuE59+OPP46JEyfGjjvuuE57/fr148gjj4xnn3024X516tRJ+Ow+ceLEmDhxYgqSks2efvrpOOmkk2L16tVxxx13xGWXXVZomx122CFuv/32uOCCC8o/IAAAGS0v3QEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgOyxdu3ahO1Vq1ZN6bhlrV9QUJCwfeHChfHvf/+7TLVLYt68eeU2VkVxyCGHxAsvvBBVqlTZ4LZLly6NadOmxbRp02L69Onr/O+CBQsS7rNixYpkR85Y2Xr+Jlsmz6n8/PyE7Xl5eaWuma2Kmq+p/i6Kmq9F5dmQadOmxSmnnBJnnHFG7LPPPtGxY8fYeeedY5tttolWrVpF9erVS1W3Z8+eUbdu3TjiiCOSluuEE05Ia6ZstHbt2njwwQfjjjvuKNTXuXPnqFq1aqxevbrU9cu6//pUq1YtYfv65no23E9ZR8nJyUl3BMpRtWrVYvDgwVGjRo1CfatWrYqePXsmvDc79dRTo1OnTtGsWbNCfRdccEG88sorMWrUqJRkhl9lw3WV4nM8gcrq5ZdfTthevXr1aNu2bUyaNGm9+2fye7ps491v8piXyWNelp8BAwbE4YcfHn/+858L9V1wwQXx8ssvx+jRo8s/2P9vwIABcd999xVq7927dzz77LMJ9znmmGOiZs2ahdr79++f9Hxkt/vvvz/OO++8357Lrr766th///1jl112KbTt+eefHyNHjizyHgYAgMrJTxMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMW2bNmyhO3169dP6bi1a9cu0/4rVqxI2L506dI466yzylSb1GnZsmU89dRTUaVKlYT98+bNi6FDh8aoUaNiwoQJMWvWrBKPkZOTU9aYWSNbz99kyvQ5VdRalepjlImWLl2asL1BgwYpHbdRo0YJ2xcvXlymuqtWrYqRI0fGyJEjf2vLycmJ5s2bx1ZbbRVbbbVVtG7d+rd/3mqrraJmzZrrrXn44YfHlVdeGbfccktSct18880ZkSnbjB49OmF79erVY5NNNolvv/221LXr168fP//8c6n3X5+izqWizr2I7Lifso6yoXWKiuW2226Ldu3aJey78sorY9KkSQn75s+fH717946RI0cWunfLycmJQYMGRbt27WLevHlJzwy/yobrKsXneAKV1U8//RQrVqyIGjVqFOpr0qTJevfN9Pd02ca73+QwL5PLvCxfp556anTq1Ck23XTTddp//5w7f/78tGR78skn4+9//3tUr159nfaDDjoomjRpEj/99FOhfU4++eRCbStXroynnnoqVTHJQldeeWXceuut67StWbMmevbsGRMnTky4Hjz66KPRvn37mDt3bnnFBAAgw+WmOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkD1WrFgR+fn5hdrz8vKiVq1aKRu3fv36Zdr/l19+iYKCgkLtjRo1KlNdUuuWW26JBg0aFGpfunRpnHvuudGsWbM444wzYsiQITFr1qxSjVGnTp0ypswe2Xr+JlOmz6mi1qqqVatGzZo1S103G61cuTLWrFlTqD0vLy9q166dsnEbNmyYsH3JkiVJH6ugoCC+/fbbGDt2bDz88MNx6aWXRvfu3aN9+/ZRu3bt2HrrreP888+Pzz77rMgaV1xxRVKvZZmYKdNNmzatyL7GjRuXqXai9SpZiqq9dOnSIvfJhvsp62h2qlKlStJq1a1bN2m1yGwHHnhgnH/++Qn7xowZE3feeed69x89enTcc889Cfs23XTTGDBgQJkzwvpkw3WV4nM8gcrsp59+Sti+oWfaTH9Pl228+00O8zK5zMvyNW/evDj55JMT3pc2a9YsHn744TSk+q8FCxbEiBEjCrXn5eVFz549C7X/6U9/ir322qtQ+/Dhw2PBggWpiEiWWbt2bfzlL3+JW2/9/9i78+gqq7N/3HcOCTJFEGVQHACZqjigyKAUnFFqi/I6VRSxFqV9caqtWHGqrdZWq9ZZK85YFFtbrQVU1CoooiLggKAggljmQRDDEPL74/3p0m9ONCQn58nhXNdarCX7Pufen3j2s/eTh4i/T1v/8MMP45xzzklba9asWTz00EM1GQ8AgByTSjoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJBbFi9enHa8RYsWNTJfvXr1omXLltXqUVpaGkuXLi033qBBg6hXr161elMzWrduHSeddFK58fXr18fhhx8et956a2zYsKHa8+ywww7V7pFLcvH6zZRcWFObN2/O+mdUmy1cuDDteE2uqYp6L1q0qMbmTKesrCxmz54dN998c+y5557xm9/8Ju3rGjVqFD/96U/zNlNtsG7duli/fn3a2vbbb1+t3jV53VfUe9myZRW+Jxfup+yjtVtpaWna8eLi4ozNscsuu2SsF7XX9ttvHw888EAUFBSUq61cuTIGDRpUqT7Dhw+PGTNmpK31798/hgwZUq2c8G1y4Vyl8nyeQD6r6D4/lUpV+J5ceE6Xi/L52W8mWJc1w7rMrmeeeSZuueWWtLUBAwbE4MGDsxvoa0aOHJl2/PTTTy83dtppp6X9nr+iHuSfAQMGxL333vutr7nvvvvi8ccfT1s7/PDD41e/+lVNRAMAIAdV/BQLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACCN2bNnpx3v2rVrjczXoUOHKCgoqHaf+fPnpx3v3LlztXuTef369YtUKlVu/Pbbb4/XXnstI3OkUqlo3rx5Rnrlily9fjMhV9bUxx9/nHZ8//33r1bfXPTee++lHe/evXuNzdmtW7e04++++26NzfldysrK4sorr4zbb789bb1v375ZTlQ7M32pYcOGWZ+zrKws7Xi6PWdL1NTe3KpVq2jRokW58Y0bN8ZHH330re/Nhfsp+2jttXLlyrTj2267bcbm6NixY8Z6UXuNHDkyWrZsmbZ21llnxcKFCyvVZ8OGDXHKKadESUlJ2vpNN90UHTp0qHJO+C65cK5SeT5PIF8VFRWlHd+8eXOF78mV53S5Jp+f/WaCdVkzrMvsu+iii+Kdd95JW7vllluibdu2WU70f5577rm098z77bdf7Lnnnt8YO/3008u9bv78+TFhwoQay0duefLJJyv1uiFDhsSCBQvS1q6++uoa24sAAMgt1fvJDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAg78yaNSvteM+ePWtkvj59+mSkz9tvv512vHv37hnpT2b17t077fjo0aMzNsf+++8f9evXz1i/XJCr128m5MqamjZtWtrxmvqMarN33nkn7XivXr1qZL6OHTvG9ttvX258/fr1MWfOnBqZc0tcfvnlsWnTpnLjBxxwQAJp/k9tytSiRYu45ZZb4pNPPolmzZplbd5tt9026tWrl7a2du3aavWuqeu+R48eacfnzJkTmzdv/tb35sL9lH209lq5cmXa8TZt2mRsjtp070HNGDJkSPTv3z9t7YEHHojHH398i/q9++67MXz48LS1Bg0axCOPPBKFhYVbnBMqIxfOVSrP5wnkq4q+B/+274lz5TldrsnnZ7+ZYF3WDOsy+9avXx+nnHJKrF+/vlytUaNGMWrUqKhTp07Wc5WVlcX999+ftjZo0KCv/rl79+7Rvn37cq+57777oqysrKbisZVatWpVnHrqqWmfexcVFcXo0aOjUaNGCSQDAKA2SSUdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADILS+//HLa8aOPPrpG5vvhD3+YkT5TpkxJO37wwQdnpD+ZteOOO6YdnzlzZsbmOPTQQzPWK1fk6vWbCbmypl577bW04/369at271zz7LPPph0/5phjok6dOhmf79hjj007/p///CdKS0szPt+WWr58eUybNq3ceHFxcdStWzf7gaJ2ZNpuu+3i2muvjblz58awYcOiSZMmcdFFF2Vl7oiItm3bVlhbvHhxtXofeuihNfLvsaL9ZOLEid/53ly4n9qa9tGa2OuStGLFirTj++23X0b6FxYWxpFHHpmRXtROHTp0iJtuuilt7ctzoCpuvvnmGD9+fNra/vvvH7/97W+r1Jdvt7XtcVWRC+cqlbc1fp6uU+C7tG7dusLvWxcuXFjh+3LlOV2uyednv5lgXdYM6zIZb7/9dlxyySVpaz169IjLLrssy4n+z3333RdlZWXlxk899dQoKCiIiIjBgweXq5eVlcV9991X0/HYSr300kvxhz/8IW1t9913j9tvvz3LiQAAqG1SSQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHLLs88+m3a8U6dOcfjhh2d0rrZt22as5zPPPJN2/Ec/+lE0a9YsI3OQOdttt13a8ZKSkoz0T6VSMWTIkIz0yiW5ev1mQq6sqXHjxqUd/973vheHHXZYtfvnkv/85z/x+eeflxvfZZdd4vjjj8/oXEVFRXHuueemrT355JNb3K9ly5bVjZTWp59+mna8SZMmlXp/TeSqbqbqOO644+Kjjz6K4cOHR4MGDb4aP++882Lfffet8fkjIgYMGJB2vKSkJObNm1et3s2aNYuTTz65Wj3+XzvssEOccsopaWsV7T9flwv3U7m4j6bb6yIiiouLs5ykZr333ntpx1u2bBnt2rWrdv//+Z//qTXrkMwrLCyMRx555Bv7/ZdKS0tj4MCBsXbt2ir3P/3002PZsmVpaxdddFH06dOnyr3zXb7scVWRC+cqlZfLn6frFKiq4447Lu34xo0b44MPPqjwfbnynC7X5POz30ywLmuGdZmcG264ISZMmJC2dumll8bOO++c5UQR8+bNi+eff77c+E477RSHHXZY1K1bN0466aRy9QkTJsTHH3+cjYhspS677LJ4/fXX09ZOO+20GDhwYJYTAQBQm6SSDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5JbFixfHK6+8krZ2ySWXZHSu3/72t1FQUJCRXnPnzo2333673HjdunVjyJAhGZnjS40bN46WLVtmtGe+WbNmTdrxZs2aZaT/j3/849h9990z0iuX5Or1mwm5sqb++9//xqRJk9LWfv3rX1e7/9edddZZsc8++2S0ZyZt2LAhHn300bS1ESNGRFFRUcbmOuuss2KnnXYqN75+/foYM2ZMpfvsvPPOcccdd8THH38c/fv3z1i+L9WtWzft+BdffJFYrqpmyoT3338/iouLy40XFRXFqFGjolGjRjU6f6NGjeKMM85IW5s4cWJs3ry52nP88pe/jDp16lS7z5d+8YtfRL169cqNf/755/HMM8985/tz4X4qF/fRlStXph3fbbfdqt27Npk9e3YsX748bW3w4MHV6l1YWBhXXnlltXpQu/3ud7+L/fffv8La5MmTq9V/8eLFceaZZ6atpVKpePjhh6NJkybVmiNf5cseVxW5cK5Sebn8ebpOgapo1KhRXHjhhWlrkydPjpKSkgrfmyvP6XJNPj/7zQTrsmZYl8kaNGhQrFixotx4nTp1avzZaUVGjhyZdvz000+PY445JrbbbrtKvwcqq7S0NH784x/H2rVr09bvuOOOaNu2bZZTAQBQW6SSDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5J7bbrst7fghhxwSF154YUbmOOqoo+KUU07JSK8v/eUvf0k7PmLEiGjfvn3G5rnxxhtj1qxZce6550YqlcpY33yybNmytOM9e/asdu9WrVrFjTfeWO0+uSpXr9/qyqU1deedd6YdP+yww+K8887LyBxdu3aNO+64I6ZNmxZPPfVUdOvWLSN9M+3666+PsrKycuN77bVX3HTTTRmZo0uXLnH99denrT344IOxZMmS7+yx8847x+233x5z5syJoUOHRt26dePmm2+Opk2bZiTjl9q1a1dubN26dbFmzZrEcm1ppkyaOXNmPProo2lre+yxR/z73/+O+vXr19j8N910U+y8885pa2PGjMnIHHvttVdcd911GenVp0+fuOiii9LWHnrooUp/ZrlwP5Vr++jChQvTjrdv3z5atGhR5b610SuvvJJ2fMiQIdGkSZMq973kkkuiU6dOVX4/tVufPn3iV7/6Vdra5MmT47e//W1G5nnyySfj7rvvTlvbeeedK6zx7fJpj6uKXDhXqbxc/Txdp8CWSqVS8Ze//CVatWqVtv7II4986/tz6TldrsnXZ7+ZYF3WHOsyOZ9++mmcddZZScf4hr///e+xatWqcuMDBgyI//3f/y03vmrVqnjiiSeykIyt3Zw5c2LYsGFpa8XFxTF69OgoLCzMcioAAGoDf2oCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGyxMWPGxPz589PWrr322vjhD39Yrf577LFHPPLII9Xqkc7IkSNj6dKl5cYbNGgQo0aNioYNG1Z7jp/+9KdxxhlnxLbbbht//vOfY+rUqdGzZ89q9803s2fPTjt+9tlnV6tvgwYN4vHHH49mzZpVq08uy9Xrt7pyaU399a9/jQ8++CBt7brrrot+/fpVq3/Lli1jzJgxkUqlIiLimGOOiddeey2effbZaN68ebV6Z9rMmTPjscceS1v7+c9/HhdccEG1+rdv3z6eeOKJqFevXrlaSUlJXHvttZXqc+edd8bPfvazqFu37ldju+66a4wZMybq169frYxf6tatW7Rr167c+CeffJJYrqpkyrRLLrkk1qxZk7b2/e9/P1566aVo27ZtRucsKCiIm2++Oc4888y09RUrVmR0H7zgggtiyJAh1erxve99L0aPHh116tQpV9u0aVPcdNNNle6VC/dTubaPLly4sMLr5uc//3m1stY2Fe3pzZs3jxtvvLFKPfv37x9XXHFFdWJRizVp0iQefvjhr663r1u7dm0MHDgwSktLMzbf+eefX+F94wknnBCDBg3K2Fz5Ip/2uKrIhXOVysvVzzOb12lRUVHccsstFf4Car8ddtgh/v73v8fJJ5+ctr5kyZJ46KGHvrVHLj2nyzW59uy3Np0L1mXNybV1ubX529/+Fg888EDSMb6yfv36tJ9XgwYN4tBDDy03PmrUqFi/fn02opEHHnjggQqfTx5wwAHxu9/9LsuJAACoDcr/KSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwHfYuHFj/OIXv0hbKywsjH/84x/xq1/9qkq9DzvssHj55Zdju+22+2ps4cKFVer1/1q3bl1cccUVaWsHHHBAvPTSS9G8efMq9z/33HPjrrvu+sbYPvvsE5MmTYq+fftWuW8+Gj9+fNrxI444Is4888wq9dxpp51i4sSJ0aNHj6/Gpk6dWqVeuSxXr9/qyqU1VVpaGhdeeGHaWlFRUTz55JNx3nnnVal3p06d4qWXXorWrVuXq7Vs2TKWLl1apb416bzzzovVq1enrd1www1x5513Rt26dbe47xFHHBFTpkyJ3XbbLW39N7/5TcydO7dSvS677LIoKysrN37ooYfGhAkTYpdddtnifF/XpEmTGDlyZNra2LFjE8lV1UyZNm/evBg6dGiF9a5du8a0adPiwgsvjPr161d7vi5dusQLL7wQ55xzToWvueKKK2Lt2rXVnuvr7r777rjhhhuiTp06W/zeH/zgBzF58uRo2bJl2vqtt94as2bNqnS/XLifysV99MUXX0w7fvHFF0fv3r2r1LM2Gj16dHz66adpa4MHD45rrrlmi/oNGTIkHn/88UilUl+NzZ49u1oZqV3uuuuu2HnnndPWzjnnnEqf1ZX1xRdfxCmnnBIbN25MW7/11lujTZs2GZ0zH+TLHlcVuXCuUnm5/Hlm6zotKiqKYcOGVfgLqL3atWsXl19+eXz44YfRv3//Cl938cUXx+eff/6tvXLpOV2uybVnv7XpXLAua06urcut0bBhwzL+/XN1VPRcubqvhco466yzYv78+WlrF110URx22GFZTgQAQNJS3/0SAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDy/va3v8W//vWvtLVUKhV//OMfY+rUqdG3b99K9evUqVM8+OCD8eyzz0bTpk2/Gi8pKYlLL700I5kjIu644474z3/+k7a23377xTvvvBM///nPo7CwsNI999prrxg7dmz8+c9/jlQqVa7++uuvx7PPPlvlzPno5ZdfjmXLlqWt3X333XHZZZdV+jOqW7dunHvuuTF9+vTo0qXLV+OrVq2Kyy+/PCN5c02uXr/VkWtr6qmnnor7778/ba1OnTpx0003xRtvvBFHHnlkpfo1atQoLr300njzzTejffv25eplZWVx/vnnR1lZWXVi14jFixfH0KFDK6yfffbZMXv27Dj11FMr9Rnuueee8cQTT8QzzzwTTZo0SfuaiRMnxnXXXVfpjG+99VbccccdaWs9e/aM9957Ly677LLYYYcdKt3zS3379o0pU6ZE586d09bHjBmT9VzVyVQTHnnkkbjrrrsqrBcXF8f1118fH3/8cdx4443Ru3fvqFOnTqX7N23aNAYNGhT//ve/480334w+ffpU+NoJEybEbbfdtkX5KzJ16tRv/P6CCy6I9957L44//vgoKCj4zvfvtdde8eSTT8a//vWv2HbbbdO+Zt68eVXat3LhfirX9tE777wz7XjdunXjueeei2uvvTZ22223KvWuTTZt2hQ33nhjhfVf//rX8fTTT6f9d/x1++23X4wdOzbuvvvub6yz119/Pf7xj39kKi4JGzRoUJx44olpa48//niF13h1vfnmmxXujcXFxfHII49s0TmSLT179owBAwbU+K9jjz12i7Plyx5XVblwrlJ5ufp5uk5h61Kd+4Ljjz8+Tj/99Bg2bFhceeWV8dhjj8X7778fH3zwQfzmN7+Jxo0bVzjvo48+Gvfdd9935su153S5Jh+f/WaCdVmzrMtkrV27NgYOHBilpaVJR4mI/3vuOX369O983fTp0+Ott97KQqKK1fT32h06dEj068tHq1evjoEDB8bmzZvL1QoKCuKhhx6q0p/lAACQuyr/tB4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4P9x6qmnxhtvvBHt2rVLW+/SpUuMGzcuFi1aFGPHjo0ZM2bE4sWLY+XKlbHNNttE06ZNo3PnznHIIYdEly5d0vY477zzYu7cuRnNfeKJJ8brr78eu+66a7las2bN4rbbbovLL788xo4dG88991wsWLAglixZEuvWrYu6detGcXFx7LrrrrH33ntHv379okePHhXO9d///jdOOOGE2Lx5c0a/hq3d+vXr4+qrr44bb7yxXC2VSsVVV10VQ4cOjYceeiheeumlmDVrVqxatSpKSkqicePG0bx582jXrl307ds3fvCDH8SOO+74jR5lZWVx+umnx9KlS7P1JdU6uXr9VlUurqmhQ4dGhw4d4sADD0xb33///WP8+PGxdOnSeOaZZ+Ktt96KJUuWxPLlyyMionHjxtGmTZvo1q1bHHnkkVG/fv0K5/r9738fEyZMyFj2TBs9enR07tw5RowYkba+2267xUMPPRS33nprjB8/PqZMmRKLFi2K5cuXR8OGDaNFixbRvn37OProo6Njx47fOtfcuXPj2GOPjdLS0i3KeMEFF0S3bt2ia9eu5WqNGjWKq666Ki677LJ45ZVX4sUXX4yZM2fGvHnzYs2aNbFu3booKCiIhg0bRpMmTWL33XePLl26RL9+/aJ9+/YVzvnUU0/FpEmTMpLrmmuuyVqmmjB06NAoKCiIs846q8LXNGvWLM4///w4//zzY8OGDTFr1qyYOXNmrFixItauXRuff/55FBYWRnFxcRQXF8dOO+0UnTt3jlatWlUqw9tvvx3HH398lJWVZeRrOuOMM2LKlCmxzTbbfDXWoUOHGDNmTCxbtizGjRsXb775ZixatChWrlwZxcXFX631o4466jvX+hdffBHHHntsrFmzpkr5cuF+Kpf20UmTJsXEiROjV69e5WpFRUUxfPjwGD58eCxcuDDmz58fa9asSfvvY/HixTF48OAq58iGG2+8Mfr375/2a42I6NevXxx11FExefLkGD9+fMyfPz+WLl0aBQUF0adPnzjiiCNin332Kfe+9evXx09+8pMYOHBgTX8JZEHbtm3j1ltvTVtbuHDht+73mfCHP/whjj766Ojdu3e5Wo8ePeKyyy6LK6+8skYzbKkvz7iaVlJS8q37YTr5tMdVVS6cq1ReLn6erlPYumTrvuDrxo0bF4MGDarUa3PxOV2uybdnv5lgXdY86zJZkydPjquvvjouv/zypKNERMTIkSPj5ptv/tbX3HPPPVlKU7GaPlOHDx8ef/zjH2usP+lNnDgxfv/736f9M6cdd9wx7r///jjmmGMSSAYAQBIKkw4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOSu1atXx1FHHRUTJkyI3XbbrcLXtWzZMs4444wt7n/zzTfH3XffHb17965OzHKWLFkShx9+eDz//POx8847p31NixYtYvDgwTF48OAqz7N48eLo27dvzJ8/v8o98tntt98egwYNii5duqSt77TTTjF8+PAYPnz4FvcePnx4PPnkk9GtW7fqxsxZuXr9Vkeuran169dHv3794umnn46DDjqowtc1a9YsBg4cGAMHDqzSPPfcc09ceumlVY2ZNZdeemkUFBTEJZdcUuFrGjduHCeeeGKceOKJVZrjvffei6OOOiqWL1++xe/dsGFDHH300TF+/PjYb7/90r6mqKgo+vTpE3369KlSvq9btmxZ/OxnP8tYriuuuCJrmWrK2WefHcuWLYuLL744UqnUt762bt26sddee8Vee+2VkbknTpwY/fv3j1WrVmWkX0TEjBkz4rTTTotHH300CgoKvlHbYYcd4tRTT41TTz21Sr2/+OKLGDBgQEyfPr3K+XLhfirX9tFBgwbF9OnTo7i4uMLXtGrVKlq1alVhfd68edXOUdNKS0vjpJNOimnTpkWzZs3SviaVSsWBBx4YBx54YKV6lpWVxdChQ+Odd97JZFQSUqdOnRg1alTaa6GsrCwGDRoUK1eurNEMZWVlceqpp8bbb78djRs3Lle/9NJL45lnnolXXnmlRnNsTfJlj6uqXDhXqbxc/Txdp0BV3XrrrXHBBRfEpk2bKv2eXHtOl2vy8dlvJliXNcu6TN5VV10Vffv2je7duycdJUaNGhXXX3991K1bN219/fr1MWrUqCynIp9cccUVcfjhh6e9Hn7wgx/EOeecE7fccksCyQAAyLZv/+kSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDvMGfOnDjooINi6tSpGe177bXXxnnnnZfRnl/3wQcfRM+ePWPKlCk10n/q1KnRtWvXePvtt2ukfz7YsGFDHH300fHRRx9lrOfGjRvj7LPPjuuuuy5jPXNZrl6/VZWLa2r16tVx+OGHx7333pvx3ps3b45rrrkmhgwZEmVlZRnvXxNGjBgRP/3pT+Pzzz/PeO+nn346DjrooFiwYEGVeyxbtiwOPvjg+Mc//pG5YGl88skn0atXr1i4cGGtybWlmWrKiBEjonfv3jFnzpyszLdu3bq4+OKL45BDDokVK1ZkvP+YMWPi5JNPjpKSkoz1XLx4cRx55JExbty4avfKhfupXNpHP/rooxgwYECsXr06A+lqt08//TS+//3vZ+Ra3bx5cwwbNizuv//+6gejVrj88sujR48eaWs33HBDPP/881nJsWDBghg6dGjaWp06deLhhx+O4uLirGTZGuTTHldVuXCuUnm5+Hm6ToEtNWPGjDjssMPinHPOiU2bNm3Re3PxOV2uybdnv5lgXdY86zJZpaWlMXDgwFi7dm3SUWLFihXxz3/+s8L6P//5z1i5cmUWE5FvSktL45RTTok1a9akrV933XWx9957ZzkVAABJSCUdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADIfQsXLozu3bvHVVddFevXr69Wr2XLlkX//v3j17/+dYbSVeyTTz6JXr16xYgRI2LdunUZ6blu3boYPnx4dOvWLT755JOM9MxnHCwiZwABGRRJREFUixcvju7du8fTTz9d7V4zZsyIbt26xd13352BZFuPXL1+qyoX11RJSUmceeaZ8aMf/Sjmzp2bkZ5z5syJI444IkaMGJGRftk0cuTI2GuvvWLcuHEZ6fff//43TjvttDjmmGNi1apV1e63Zs2aOO644+KEE06I+fPnVz/g15SVlcXDDz8cBxxwQMyaNatW5KpOppoyadKk6Ny5cwwbNizmzZtXI3OUlpbG3/72t/je974Xf/jDH2LTpk01Mk9ExGOPPRY9evSIadOmVbvXmDFjYs8994yJEydWP9j/Lxfup3JpH33uueeiW7du8fLLL2e0b200a9as6NatW4wdO7bKPZYuXRpHHXVU3H777RlMRpIOPPDACq+r6dOnZ/0+c/To0TFq1Ki0tTZt2sRtt92W1Ty5Lp/2uKrKhXOVysvFz9N1CnyXL774Ip544ok46qijYp999onnn3++yr1y8Tldrsm3Z7+ZYF3WPOsyWXPmzInzzjsv6RgREXHPPfdUqQaZMnfu3Bg2bFja2jbbbBOPPvpo1K9fP8upAADItlTSAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACArcOmTZviiiuuiNatW8ef/vSnWLp06Ra9f8mSJXHVVVdF27Zt48knn6yhlOVt3LgxrrnmmmjTpk1cffXV8cknn1Spz4IFC+Lyyy+PXXbZJf74xz9GaWlphpPmr6VLl8YxxxwTJ5xwQkycOHGL3z916tQ4+eSTY999941p06ZlPuBWIFev36rK1TX11FNPRceOHWPgwIExadKkKCsr2+Ie06dPj7PPPjs6duwYzz//fA2kzI6PPvoojj766DjggAPisccei3Xr1m1xj2nTpsXZZ58drVu3jocffjjjGR9//PFo06ZNnHDCCfHcc8/F+vXrq9xr5cqVce+990b37t3jtNNOi0WLFiWeK5OZakJJSUncdttt0a5duxgwYEA8+OCDW7y3pfPuu+/GL3/5y2jVqlUcf/zxMX/+/Ayk/W7Tp0+Prl27xumnnx4zZ87coveWlJTEmDFjYr/99osTTzwxli9fnvF8uXI/lSv76OzZs6N3797RvXv3uOuuu2LGjBmxefPmGpkraStWrIh+/frFoYceGq+++mql37dq1aq47rrrol27dvHss8/WYEKyqbi4OEaNGhV16tQpVyspKYkf//jHsXHjxqzn+tnPfhYff/xx2tppp50WJ510UpYT5bZ82uOqKlfOVSonFz9P1ymwYcOGWLNmTcybNy9ee+21GDVqVIwYMSIOO+yw2GGHHWLAgAExfvz4jMyVq8/pckm+PfvNBOuy5lmXybr33nvjiSeeSDpGPPvss7FgwYJy4wsWLIjnnnsugUTkowcffDBGjx6dttapU6f485//nOVEAABkW0FZJX9yoKCgoKazAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADUiKr8D92/5O9qByqy9957x9577x0R/7fPzJ07NyZPnlytPQegso7ud3QceuihSccgj3z00Udx+223Jx0DoMb85Cc/ie/t8b2kY5AnXnnllXji78n/j9YBasolIy6J7bbbLukY5Im//+3v8eqrryYdA6BGNGnSJEZcOiLpGOSZP13/p1i0aFHSMQBqRNsDIo7/bdIpyCd/PCrpBABbt4KCgujatWt06NDhq5/3njFjRsyYMSPhZAAA5JqrfntV1K9f3zNygCz78ufMbrv1tpg3b17ScQDyxs//9+fRpk2bGDlyZLw/8/2k4wDkhS//20U/+w6QXccNOC4OPPDA+PfT/44XXngh6TgAeePLvxfr+eefj7H/Hpt0HAAA0vB3tQM1wd/VDtQ2hxxySPT7Qb+kY5CHPBsF8onzliQ4a4F84v9NRhL8zCWQT5y1JMV/YwbkkyOGRXQ5JukU5JtnbomY9nTSKQCyy9/VXrv4mVrYcqlUKnr37h29evWKffbZJ1q3bh2NGzeORo0axbp16+Kzzz6LBQsWxLRp0+Kll16KF154ITZv3px07IiI6Nq1a/Tq1Sv233//2G233aJ58+bRsGHDKCwsjA0bNsRnn30Wq1atilmzZsW7774bEyZMsD9nUceOHaNXr17Rs2fPaNeuXTRp0iS22267KCoqijVr1sSqVati5syZ8dZbb8XTTz8dH374YdKRc04uX79VkatrqmXLlnHwwQdHjx49ol27drHLLrtEo0aNon79+rF58+ZYvXp1rFq1Kt5///2YOnVqPP/88zFz5sykY9eIevXqxRFHHBHdunWLvffeO1q1avXVml2/fn2sXr06VqxYEe+++25Mnz49nnnmmfj444+zmrFBgwbRp0+f2HvvvaNTp06x++67R3FxcTRq1CgaNmwYZWVlsXbt2lizZk189tlnMWfOnK/u/ydNmhSbNm2q0VwnnnhirclUUwoKCmLfffeNPffcM/bYY4/o1KlT7LDDDt/4mjdv3hyfffZZrF69+qt1M3369Jg6dWpMnTo1li9fnvFcFX1P8W3/3W/nzp2jX79+se+++0aHDh1i2223jUaNGkVJSUmsXr06Fi1aFDNmzIgpU6bEuHHj4vPPP8947u+SC/dTubSPNmzYMHbcccdvnFHpfPHFFzn9M0K77LJL9O3bNw4++ODYaaedolmzZtG0adPYtGlTrFq1KsaPHx+TJk2KsWPHxoYNG5KOC2RIvuxx1ZEL5yqVl4ufZ01dpy+88EIcfPDBX/3e330D5OpzulxSm5/91tZzwbqsebV5XQIAUDsUFBTEAQccEO3bt/fztEClVeZnvAuzkAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyEObN2+OF198MV588cWko2yxN954I954442kY1CBWbNmxaxZs2LkyJFJR9lq5fL1WxW5uqYWLVoUo0ePjtGjRycdJXElJSXx1FNPxVNPPZV0lAqtW7cuxo4dG2PHjk06yjfU1lw1oaysLN5666146623ko5Sbe+880688847Scf4VrlwP5VL++jnn38eH374YdIxatyCBQvinnvuiXvuuSfpKEAW5cseVx25cK5Sebn4edbUdVqnTp2v/rm0tDTj/YHck6vP6XJJbX72W1vPBeuy5tXmdQkAAMDWLZV0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACC/NGnS5Kt//uyzz5ILAkCt4FwAAAAAsi2VdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgfzRq1Cg6duz41e8XLVqUYBoAkuZcAAAAAJKQSjoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkD/+9Kc/Rd26db/6/ZQpUxJMA0DSnAsAAABAElJJBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC2foWFhXHnnXfGWWed9Y3x+++/P5lAACTKuQAAAAAkqTDpAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDWrUWLFjFmzJj4/ve//43xv/71r/Hiiy8mEwqAxDgXAAAAgKQVJh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2Hq1atUqXn/99dhxxx2/MT5u3Lj4yU9+klAqAJLiXAAAAABqg1TSAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICt18KFC+PVV1/9xtg999wTP/rRj6KkpCShVAAkxbkAAAAA1AappAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAW7fBgwfHBx98ECUlJTF06NAYMmRIbNy4MelYACTEuQAAAAAkrTDpAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDWbc2aNXHsscdGnTp14u233046DgAJcy4AAAAASStMOgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACw9XvvvfeSjgBALeJcAAAAAJKUSjoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZEsq6QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQLamkAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEC2FCYdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBfFRQUJB0BAAAAAAAAACDvpJIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANmSSjoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZEsq6QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQLamkAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEC2pJIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANmSSjoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZEsq6QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQLamkAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEC2pJIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANmSSjoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZEsq6QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQLamkAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEC2pJIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANmSSjoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZEsq6QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQLamkAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEC2pJIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANlSmHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACC3/c/x/5N0BACALVJUVBQREUcccUSs+2JdwmkA8keDBg0iIuLggw+ONWvXJJwGIH9sv/32ERFx0EEHxZ577plwGoD80HLHlhER0aVLl9ip1U4JpwHIH61bt46IiM57dY6m2zdNNgxAHtlll10iIqJjx45fPQcGIDvmzJkT096alnQMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAnFWYdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAILf16NEj6QgAAFWy9z57Jx0BIC/t2XnPpCMA5KVOnTolHQEg77Rp2ybatG2TdAyAvLPrrrvGrrvumnQMgLzTqlWraNWqVdIxAPLK5s2bY9pb05KOAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkLMKkw4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOS2p59+OukIAABb5Mgjj4yioqJ46T8vxZq1a5KOA5A3DjnkkGjQoEG88sorsXLlyqTjAOSNnj17RtOmTeP111+PJUuWJB0HIC8c0PWAaN6iebzz9jvx8fyPk44DkDf23HPPaN26dbw/8/2YM3dO0nEA8kbHjh2jXbt28eGHH8asWbOSjgOQVz5d+GnSEQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHJaYdIBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDc9uILLyYdAQBgixx66KFRVFQUr7/+eixatCjpOAB548ADD4wGDRrEW1Pfinnz5iUdByBv7LHHHtG0adOYMWNGvD/z/aTjAOSFtm3aRvMWzWP27Nnx6quvJh0HIG9st9120bp165g7d64/xwbIovr160e7du1i/vz59l8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAckoq6QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQLamkAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEC2pJIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANmSSjoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZEsq6QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQLamkAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEC2pJIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANmSSjoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZEsq6QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQLamkAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEC2pJIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANmSSjoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZEsq6QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQLamkAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEC2pJIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANmSSjoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZEsq6QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQLamkAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEC2pJIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANlSmHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2Br07t07tt9++6RjkCcaNGgQ77//ftIxyCObNm6K4447LukYADVm06ZNzlaypmGDhs5VYKv230//G4sXL046BnmidevW0bJly6RjANSIVCrle1WyrlevXlFaWpp0DIAaUbRNxNJ/Jp2CfOIxMNn20ksvxfLly5OOAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOaUw6QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwNahfv34UFxcnHYM8snHDxqQjkGfsccDWztlKtqRSKecqsFUrLS2N0tLSpGOQJ4qKiqKoqCjpGAA1xveqZFuDBg2SjgBQo0o/TzoB+cRjYLKtTp06SUcAAAAAAAAAAAAAAAAAAPhK48aNo3nz5knHIM80bNgwVixfkXQM8lC9bepF+/btk44BkBXOW5LgrAXySb1t6jlrybqGDRs6a4G84awlKdtuu63zFsgb9TdErPsw6RTkm6bbRDhqScKSJUti9erVSccAAAAAAAAAAAAAAAAgQwqTDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOS+Fi1aRI8ePZKOQR5auHBh0hHIQ8XFxdGzZ8+kYwBkjfOWbHPWAvnGWUu2NW3a1FkL5BVnLUlo0aJFtGjRIukYANlREvHZlKRDkG92bhSxs29tScDkyZNj9erVSccAAAAAAAAAAAAAAAAgQ1JJBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBsSSUdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALKlMOkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsDWYNm1a1KtXL+kYAAAAAAAAAABAnlm9enXSEQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIOcUJh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtgaLFy9OOgIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQKJKSkpi+fLlSccAAAAAAAAAAACoESUlJUlHAAAAAAAAAAAAAAAAIIMKkw4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADkvvnz58f8+fOTjgEAAAAAAAAAAAAAAAAAAAAAAAAAAADfKZV0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMiWVNIBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIFtSSQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAbEklHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACyJZV0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMiWVNIBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIFtSSQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAbEklHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACyJZV0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMiWVNIBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIFtSSQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAbEklHQAAAAAAAAAAAOD/Y+/Oo6Sq7rUB/3pgkhZlEBRQcQQNIKJBUSQOGARHEpwuoF6NA3GMSiBqYlTUGwE1ztOVGDHiEKPivVHBcImKKBqBDzWKKApIhHQrUzc00PX94UrFkqmH6q6q7udZ612LfarO3ruqkLerCo4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQV/IzvQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACoK/mZ3gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADUlfxMbwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADqSn6mNwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB1JT/TGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIC6kp/pDQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBdyc/0BgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKCu5Gd6AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFBX8jO9AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKgr+ZneAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANSV/ExvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOpKfqY3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHUlP9MbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgLqSn+kNAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQF3Jz/QGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoK7kZ3oDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUFfyM70BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqCv5md4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1JX8TG8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA6kp+pjcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAdSU/0xsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAupKf6Q0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAXcnP9AYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgruRnegMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQV/IzvQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACoK/mZ3gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADUlfxMbwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADqSn6mNwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB1JT/TGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIC6UpjpDQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQqlGjRtGzZ8/o0aNH7LnnnrHddttFUVFRrFu3LlasWBFLly6NOXPmxNtvvx2LFy/O9HYBIOvpVgBIH70KAOmjVwEgvXQrAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUBWFmd4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN/o2bNnXHLJJXHSSSfFdtttV6lz3n777Xj00UfjgQceiDVr1qR1P506dYpBgwZFnz59Yt9994127drFtttuGwUFBVFaWhpLliyJ999/P6ZOnRpPPPFELFmyJK3rb07fvn1j2rRpaZ/31FNPjSeffDIiIvbdd9+YPXt2FBb++3/zc+2118b111+flrVatmwZ8+bNi9atWyeP/epXv4obbrhhq+fWxetSWFgYZ599dpXP25yysrJ49NFH0zYfQGVlS7d27Ngxjj322Dj88MNjn332iY4dO0ZRUVE0adIkysrKoqSkJObNmxdvvPFGPPfcc/Hmm2+mZd3K0Kt6FaCysqVXq6Jbt27Ru3fv5Pj999+P1157rdbWa+i9GlH73apXgfoim3r1Bz/4QXTu3HmL95k9e3advleN0KuZ/Hx+9913j1NOOSX69u0bXbp0iXbt2kWzZs1i/fr1sWrVqvjss89izpw58ec//zkmTZoUq1evTtvaANWVTd3qO9ba6Va9CgAAAAAAAAAAAAAAAAAAQEREo0aNomfPntGjR4/Yc889Y7vttouioqJYt25drFixIpYuXRpz5syJt99+OxYvXpzp7QJATtK3AFC7dC0A1C5dCwC1T98CAAAAAAAAAAAAAAAAUB/lJRKJRKXumJdX23sBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKgVlbws+ya5VjuwOd27d4/u3btHxDd/znzyyScxY8aMGv2ZAzRc7dq1i7vuuisGDx5c7TmWLFkSP//5z2PChAk13s/ee+8dN998cwwaNKjSPw9t2LAhfv/738eoUaNi6dKlNd7DlvTt2zemTZuW9nlPPfXUePLJJ5PjsWPHxhVXXJEcl5WVRZcuXeLzzz+v8Vr33ntvXHDBBcnxxx9/HN/73veivLx8s+fU5euyww47pPV1/Mc//hE77bRT2uYD2Jps6dYuXbrE6NGjY9CgQZGfn1/p8959990YMWJEvPLKK9Veu7L0ql4F2Jps6dWqatOmTcyaNSs6dOiQPHbffffF8OHDa23NhtqrEXXXrXoVyHXZ2KsvvfRS/PCHP9zifcaOHRsjRoxIy3qV1VB7NZOfz++5554xduzYOPHEEyt9TklJSdx8881x6623RkVFRbXXBqiubOpW37F+o7a6Va8C8F15eXlx4IEHxt577538c37OnDkxZ86cDO8MAIBcc/0N10ezZs1i3Nhx8Y9//CPT2wFoMK66+qpo2bJl3H3X3bFgwYJMbwegwfjphT+N3XbbLf77v/87/v7B3zO9HYAG4eyzz4599t0nnvnjM/HGG29kejsADcagHw2KQw45JP73f/43pk6dmuntADQYAwYOiCOPPDL+8pe/xJ//98+Z3g4AAJvgWu1AbXCtdqAu9ezZMy655JI46aSTYrvttqvUOW+//XY8+uij8cADD8SaNWvSup9OnTrFoEGDok+fPrHvvvtGu3btYtttt42CgoIoLS2NJUuWxPvvvx9Tp06NJ554IpYsWZLW9TenLq4vsO+++8bs2bOjsLAwefu1114b119/fVrWatmyZcybNy9at26dPParX/0qbrjhhq2eWxevS2FhYZx99tlVPm9zysrK4tFHH03bfAA1kS1927Fjxzj22GPj8MMPj3322Sc6duwYRUVF0aRJkygrK4uSkpKYN29evPHGG/Hcc8/Fm2++mZZ1K0PX6lqAmsiWrq2qbt26Re/evZPj999/P1577bVaW0/fbrpv165dq2sBtiLbuvYHP/hBdO7ceYv3mT17dp2+r43QtZn8fH/33XePU045Jfr27RtdunSJdu3aRbNmzWL9+vWxatWq+Oyzz2LOnDnx5z//OSZNmhSrV69O29oA6ZJtfduQvrfVtVuna4GGxrXas4u/UwsAAAAAAAAAAABQt/Ly8uL73/9+7LXXXv4+LVBplfo73olKiggRERERERERERERERERERERERERERERERERERERERERERERERERERERERERERGRnExNZHrvIpK96d69e2Lo0KGJoUOHJoYMGZLo3bt3Ii8vL+P7EpHcy5FHHpn48ssva/Qzy7c9+uijiSZNmlR7P0OHDk2sXr262ut/+eWXid69e9fqc9a3b9+0PV/fdsopp6SsU1RUlFi8eHHKff74xz/WeP89evRIbNiwIWXe/v37Z9Xrsttuu1V7rU1ZsmRJxv9bE5GGk2zq1rVr19Zo7XHjxtX686VXq06vikhDSjb1alXz4osvbrT+vffeW6trNsRejajbbtWrIpLLydZe/eSTT7a61pgxY+r8+WqIvZrJz+dPP/30Gq09derURPPmzTP+35mINKxkU7f6jvXf69RGt+pVERHZVPLy8hLf//73E0OGDEn+Xc7u3btnfF8iIiIiknu5/obrE2PGjknsuOOOGd+LiEhDylVXX5UYM3ZMolOnThnfi4hIQ8pPL/xpYszYMYku+3TJ+F5ERBpKzj777MSYsWNq/e+GiIhIagb9aFBizNgxiSOOOCLjexERaUgZMHBAYszYMYkBAwdkfC8iIiIisunURKb3LiLZG9dqF5G6SLt27RJPPfVUjX6e+eKLLxJDhw5Ny3723nvvxB//+MdERUVFpddfv3594uGHH060bdu21p+vurq+wNixY1NuLy0tTeyyyy5peQz33ntvytzz5s1LNG7cOGtelx122CEtz+m/uCaeiGRDsqVvu3Tpknj66ac3ut7M1vztb39LHHXUUXXyXOlaXSsiUp1kS9dWJ23atEksWrQoZS/15Xrvud63ulZE5N/J1q596aWXtrpufb4GfK53bSKRvs/399xzz8Szzz5bpeezuLg4ceWVVyby8/Mz/t+YiEhE9vVtQ/zeVtduPrpWRBpqXKs9u+Lv1IqIiIiIiIiIiIiIiIiIiIiIiIiI1G3y8vISvXr18vdpRaRKqYzCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAjBg4cGM8880w0adIk5fiaNWti8uTJMWnSpJg1a1YsXbo0SkpKomnTprHDDjtEx44d46ijjooTTjghunTpknLu0KFDo127dnHCCSfEmjVrqrSfYcOGxSOPPBJ5eXkpx1esWBHTp0+PefPmxYoVKyIiolWrVtGjR4/o1atXFBQUJO/btm3bmDx5chxyyCExZ86cKq1fXaWlpXHPPffUeJ4PP/wwZbxq1aq4/PLLY+LEicljP/rRj6Jfv34xZcqUaq9z1113RX5+fnL8zDPPxEsvvbTZ+2fidWnevHlVHxZAVsimbv3Vr34VjRs3TjlWXFwcM2bMiE8++SRWrFgRiUQiWrRoEXvuuWf07t07WrZsmXL/yy+/PBo3bhwXX3xxFZ+J6tOrehXgX7KpV6tq1KhR0b9//1qbv7Lqe69G1H236lUgV2VrrxYWFsYuu+xS7cdVl+p7r2by8/mzzjorHn744Y3WXr16dUydOjU+//zzKC4ujsLCwthhhx2ie/fuceCBB6Y8vsMPPzwmTZoURx11VCQSiUqvDVBd2dStvmOt/W7VqwAAAAAAAAAAAAAAAAAAAA3TkUceGY8//ni0bdu2RvPstNNO8eijj0b//v3jJz/5Saxdu7Za8wwdOjTuv//+2Gabbap0XkFBQfznf/5nHHvssXHSSSfFG2+8Ua31s8mvf/3rOP3006N9+/YREdGsWbO47bbb4sc//nGN5u3Ro0ecd955KccuuuiiKC8v3+w5df26FBUVVWkdgGyXLX172WWXxW9+85uNru1eGfvvv39MmTIlbr311rjiiiuqfH420rUA9Ue2dG11TZgwITp06FAna9W1XO9bXQvwjWzu2r322qvGc+SyXO/aiPR8vn/66afHQw89VOW1W7VqFWPGjIljjz02jjvuuFi9enWV1wZIl2zrW9/bfkPXfkPXAgAAAAAAAAAAAAAAAOlUmOkNAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADRE+++/fzzzzDPRpEmT5LFEIhGPPfZYjBw5Mr744ouNzlm5cmUsW7Ys3n///Xj55Zdj5MiRMXjw4Bg7dmzsuuuuyfsdffTR8fvf/z5OOeWUSu+nS5cu8cADD0ReXl7y2OLFi2PkyJHx5JNPxrp16zZ5XocOHeK6666Lc845J3msefPm8fjjj0f37t1jw4YNld5Dda1YsSJGjBhRK3M/8cQTcf7558cRRxyRPHbnnXdGt27dYv369VWeb+jQoXHooYcmx6WlpXHppZdu9v6Zel2KiopSxj//+c/jlVde2eI5W1Kd5wqgqrKpW/v37x+//vWvk+N33nknrrrqqpg8eXIkEolNntOoUaMYPHhw3HLLLdGxY8fk8YsuuigmT54czz//fKXWrim9ujG9CjRE2dSrVdWnT58YPXp0rcxdVfW5VyMy0616FchF2dyrGzZsiPbt2290/Ne//nUMHz68WnPWlvrcq5n8fL5r164brV1SUhIjRoyIP/zhD7FmzZpNntexY8f4r//6rxgyZEjy2BFHHBGXX355jBs3bqvrAtRENnWr71g3LZ3dqlf1KgAAAAAAAAAAAAAAAAAA0DANHDhwo+sLRESsWbMmJk+eHJMmTYpZs2bF0qVLo6SkJJo2bRo77LBDdOzYMY466qg44YQTokuXLinnDh06NNq1axcnnHDCZv8N+OYMGzYsHnnkkZR/Ux7xzb/fnz59esybNy9WrFgRERGtWrWKHj16RK9evaKgoCB537Zt28bkyZPjkEMOiTlz5lRp/eoqLS2Ne+65p8bzfPjhhynjVatWxeWXXx4TJ05MHvvRj34U/fr1iylTplR7nbvuuivy8/OT42eeeSZeeumlzd4/E69L8+bNq/qwALJWtvTtr371q7juuus2Ol5cXBwzZsyITz75JFasWBGJRCJatGgRe+65Z/Tu3TtatmyZcv/LL788GjduHBdffHEVn4nq07W6FmBLsqVrq2vUqFHRv3//Wl2jMvTtN32rawE2ls1dW1hYGLvssku1z69Lurb2Pt8/66yz4uGHH95o7dWrV8fUqVPj888/j+Li4igsLIwddtghunfvHgceeGDK4zv88MNj0qRJcdRRR232/38HUJuyrW8b8ve2unZjuhYAAAAAAAAAAAAAAABIu0QlRYSIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIhITqYmMr13EcnedO/ePTF06NDE0KFDE0OGDEn07t07kZeXl/F9iUhupHnz5on58+en/Nyxbt26xGmnnVat+YqKihLTpk3b6GeZCy64oNJzTJkyJeXc2bNnJ1q3bl3p8y+44IKN1j/99NNr5fnr27dvyjpLliyp1derS5cuifLy8pQ1L7/88mq9Tl988UXKPCNHjszK16Vfv34p5wwcOLBWn2MRkZomm7o1Ly8vMXfu3OQ5Dz/8cCI/P7/Sa7du3Trx7rvvpqz73nvv1dpzp1f1qojId5NNvVrVtGnTJrFo0aKN1vqXe++9t1afu4bUqxGZ6Va9KiK5llzt1TFjxqTMP2bMmDp/7hpSr2by8/np06ennPf3v/890a5du0qv/Zvf/Cbl/OLi4kTz5s3r/PeLiDScZFu3+o5180lHt+pVvSoisqXk5eUlvv/97yeGDBmS/Luc3bt3z/i+RERERCT3cv0N1yfGjB2T2HHHHTO+FxGRhpSrrr4qMWbsmESnTp0yvhcRkYaUn17408SYsWMSXfbpkvG9iIg0lJx99tmJMWPHJHr37p3xvYiINKQM+tGgxJixYxJHHHFExvciItKQMmDggMSYsWMSAwYOyPheRERERGTTqYlM711Esjeu1S4itZX9998/sWbNmpSfSSoqKhKPPvpoon379pWeZ/DgwYkFCxZs9PPNk08+WaX9dOnSJVFWVpYyx6JFixJDhgxJNGrUaLPndejQIfHQQw9ttP57772XKCgoqJXnrq6vL/CXv/wlZb0PPvggUVhYWK25hg4dmjLX6tWrEx07dsy61+Xggw9OOW/EiBGJnj17Vjv+jayIZCrZ0rf9+/dPVFRUpJz79ttvJ374wx9u8f1Fo0aNEqeffnpi4cKFG619wgkn1Nrzpmt1rYhIZZMtXVvd9OnTJ7F+/fqN1k0k6t/13nOtb3WtiMg3yfauzcvLS7Rt23aj3HPPPSnrNIRrwOda10ak5/P9rl27bnR93uLi4sTZZ5+daNq06WbP69ixY2LChAkbrX3FFVfU+e8VEZFs61vf2246uvbfdK2INLS4Vnt2xd+pFRERERERERERERERERERERERERGp2+Tl5SV69erl79OKSJVSGZW+onumH4yIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIhIdVMTmd67iGRvunfvnvyfyQwZMiTRu3fvRF5eXsb3JSK5keuvvz7lZ46KiorEoEGDajRns2bNEq+++mrKvF999VWiZcuWWz137733TlRUVCTPW758eWLnnXeu8h6efvrplPWfe+65Wnn++vbtm7LOkiVLav01u+WWW1LWXLFiRWLHHXes0hxjxoxJmeODDz5IFBYWZuXrcuKJJ6acc8QRR9T6cywiUpNkW7f269cvMXny5MRbb72VKCgoqPLae+21V2Lt2rUpa/fo0aNWnju9WrW961URaQjJtl6tSl588cWUNW699daU8b333lurz11D6dWIzHWrXhWRXEuu9up3u2HMmDF1/tw1lF7N5PvV008/PeWc4uLixC677FKldfPz8xPvvvtuoqSkJHH33Xcnvv/979f57xURaVjJpm71HevWU9Nu1at6VURkS8nLy0t8//vfTwwZMiT5dzm7d++e8X2JiIiISO7l+huuT4wZO6bK3wmIiEjNctXVVyXGjB2T6NSpU8b3IiLSkPLTC3+aGDN2TKLLPl0yvhcRkYaSs88+OzFm7JhE7969M74XEZGGlEE/GpQYM3aMf3skIlLHGTBwQGLM2DGJAQMHZHwvIiIiIrLp1ESm9y4i2RvXaheR2kjz5s0T8+fPT/l5ZN26dYnTTjutWvMVFRUlpk2bttHPOBdccEGl55gyZUrKubNnz060bt260udfcMEFG61/+umn18rzV9fXF+jSpUuivLw8Zc3LL7+8Wq/TF198kTLPyJEjs/J16devX8o5AwcOrNXnWESkNpItfZuXl5eYO3duyjkPP/xwIj8/v9Jrt27dOvHuu++mzPHee+/V2nOna3WtiEhlki1dW920adMmsWjRoo3W+5f6dr33XO1bXSsiDTm53LUN8Rrwudq1ETX7fH/69Okp5/39739PtGvXrtJr/+Y3v0k5v7i4ONG8efM6//0iIg032di3vrfddHTtN3StiDTEuFZ7dsXfqRURERERERERERERERERERERERERqdvk5eUlevXq5e/TikiVUhn5AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECdadOmTVxxxRUpx+6///7405/+VKN5y8rKYtiwYbF69erkse233z5+8YtfbPXcjz76KLp27RoPPPBAlJWVxU033RQLFy6s8h7uueeelHHPnj2rPEe2uu6662Lx4sXJ8bbbbhu33HJLpc/v3LlzXHrppSnHfvrTn8b69es3e04mX5eioqKUcVlZWZXXBagr2ditU6ZMiaOPPjrOP//82LBhQ5XXnjdvXrz88sspxw466KAqz5Ot9KpeBbJXNvZqZY0aNSr69++fHI8bNy6effbZtM2frTLRqxGZ61a9CuSSXO7VhqqhvV8999xzU8bXX399fP7551Vat6KiIo477rjYcccd48ILL4yZM2dW6XyAqsi2bvUd69bVpFv1ql4FAAAAAAAAAAAAAAAAAAAappEjR8buu++eHCcSiTjllFNi4sSJ1Zpv1apVccwxx8Rrr72Wcvzmm2+Oli1bbvX8vffeO4488sjkeMWKFXHcccdFcXFxpfdw3333xR//+MeUY6eddlqlz89mf//73+P2229POfbrX/86dtxxxyrNc+2118ZOO+2UMu+4ceM2e/9Mvi7NmzdPGbsmHpCL6rJvtySRSMRll10WU6ZMiYiImTNnxrnnnhsVFRWVXru4uDhOOeWUKC8vTx7bd999o0ePHpV/AFlM1+paIDdl23vbqpowYUJ06NAhOb7tttvSvkY2ydW+1bVAQ5brXdvQ5GrXRlS/b08//fTo3bt3clxSUhI//OEP48svv6z02r/4xS9i1qxZ8dVXX8U999wTxxxzTMo1lAFqW7b1re9tN0/X6loAAAAAAAAAAAAAAAAgffIzvQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAhuTMM8+MbbbZJjleunRpjBgxIi1zL1iwIK677rqUY2effXY0btx4q+e+//77cf7550fHjh3jzjvvrNb6c+fOTRm3bdu2WvNko9WrV8fPfvazlGNDhw6N3r17V+r8O++8Mxo1apQcT5w4MaZOnbrV8zL1uhQVFaWMy8rKqrU2QF3I1m6NiHj33XervfasWbNSxh06dKj2XNlGr+pVIHtlc69uSZ8+fWL06NHJ8YwZM2LUqFE1njcXZKpXIzLTrXoVyCW52qsNWUN6v7rzzjvH4YcfnhwvW7Ys7rnnnmqtvXjx4igvL6/WuQBVkY3d6jvWLatJt+pVAAAAAAAAAAAAAAAAAACAhqdNmzZxxRVXpBy7//77409/+lON5i0rK4thw4bF6tWrk8e23377+MUvfrHVcz/66KPo2rVrPPDAA1FWVhY33XRTLFy4sMp7+O6/Q+/Zs2eV58hW1113XSxevDg53nbbbeOWW26p9PmdO3eOSy+9NOXYT3/601i/fv1mz8nk6+KaeECuq+u+3ZopU6bE0UcfHQcccECcf/75sWHDhiqvPW/evHj55ZdTjh100EFVnidb6VpdC+SWbHxvWxWjRo2K/v37J8fjxo2LZ599Nq1rZKNc7VtdCzREud61DVWudm1E9fr23HPPTRlff/318fnnn1dp3YqKijjuuONixx13jAsvvDBmzpxZpfMBaiIb+9b3tluma3UtAAAAAAAAAAAAAAAAkB75md4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQENy9tlnp4wffvjhWLVqVdrmf+CBB6KsrCw5bt26dRx33HGVPr+kpCRKS0urtfZ3z2vcuHG15slWTz31VLzyyivJcV5eXtx9992Rl5e3xfNOOumkOProo5PjlStXxuWXX16ltev6dWnevHnK+Nu/pwCyTbZ3a3V9/fXXKeNmzZrV+pp1Sa8CZKdc7NU2bdrExIkTo6CgICK++XP+lFNOifXr19do3lySyV6NqNtu1atALsnFXqXhvF897rjjUh7Tc889F+vWravW2gB1JZu71Xesm1edbtWrAAAAAAAAAAAAAAAAAAAADdOZZ54Z22yzTXK8dOnSGDFiRFrmXrBgQVx33XUpx84+++xK/Tv/999/P84///zo2LFj3HnnndVaf+7cuSnjtm3bVmuebLR69er42c9+lnJs6NCh0bt370qdf+edd0ajRo2S44kTJ8bUqVO3el6mXpeioqKUsWviAbmmrvu2stfU+dvf/hbvvvtutdeeNWtWyrhDhw7Vnivb6FpdC+SWbH1vWxl9+vSJ0aNHJ8czZsyIUaNGpWXubJerfatrgYYol7u2IcvVro2oet/uvPPOcfjhhyfHy5Yti3vuuadaay9evDjKy8urdS5ATWRr3/redvN0ra4FAAAAAAAAAAAAAAAA0iM/0xsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaCjat28f++67b8qxBx54IK1rLF++PJ566qmUY/3790/rGpvTunXrlPGKFSvqZN26dOGFF0Z5eXlyvP/++8e555672fs3bdo0brvttpRj1157bSxZsqTW9vhd1XldioqKUsZlZWVp3RNAutTnbm3ZsmXKeOXKlbW+Zl3TqwDZJVd7dcKECdGhQ4eIiEgkEnHGGWfEwoULazRnLsrFXo2oerfqVSBX5Gqv8o1c7NWqdmrPnj1TxpMmTUr7ngDSqT53q+9YN6ZXAQAAAAAAAAAAAAAAAAAAGqazzz47Zfzwww/HqlWr0jb/Aw88kHL9statW8dxxx1X6fNLSkqitLS0Wmt/97zGjRtXa55s9dRTT8Urr7ySHOfl5cXdd98deXl5WzzvpJNOiqOPPjo5XrlyZVx++eVVWruuX5fmzZunjF0TD8g1dd23Venamvj6669Txs2aNauTdeuKrgXIHdn+3nZz2rRpExMnToyCgoKI+ObP/1NOOSXWr19f47lzRS72ra4FGqJc7Vpys2sjqt63xx13XMpjeu6552LdunXVWhsgU7K9b31vu2m6FgAAAAAAAAAAAAAAAKDm8jO9AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICG4vDDD08Zf/LJJ/Hpp5+mfZ3JkyenjI844oi0r7EpBx98cMr4iy++qJN169KHH34Yt956a8qxm266KVq2bLnJ+48aNSo6deqUHM+dOzfuuOOO2tziRqrzuhQVFaWMy8rK0rongHSpz916wAEHpIw/+uijWl+zrulVgOySi706atSo6N+/f3I8bty4+J//+Z9qz5fLcrFXI6rerXoVyBW52Kv8Wy72alU7tUePHinj2bNnp3tLAGlVn7vVd6wb06sAAAAAAAAAAAAAAAAAAAANT/v27WPfffdNOfbAAw+kdY3ly5fHU089lXLs29ezq02tW7dOGa9YsaJO1q1LF154YZSXlyfH+++/f5x77rmbvX/Tpk3jtttuSzl27bXXxpIlS2ptj99VndfFNfGAXJaJvq2rrv3u9WxWrlxZJ+vWJV0LkP1y+b3thAkTokOHDhERkUgk4owzzoiFCxfWeN5ck2t9q2uBhiaXu5Zv5FrXRlS9b3v27JkynjRpUtr3BFCb6nvf1vfvbXUtAAAAAAAAAAAAAAAAQM3kZ3oDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1F165dU8Zvvvlmrawzc+bMlPEee+wRjRs3rpW1vu3CCy9MGb/11lu1vmYm3HDDDbFw4cLkuHXr1nHjjTdudL9dd901Ro4cmXJs+PDhsWHDhlrf47dV53UpKipKGZeVlaV1TwDpUl+7tUuXLtGvX7/keN26dTF58uRaWy+T9CpA9si1Xu3Tp0+MHj06OX7jjTdi1KhRNd5fLsu1Xo2oerfqVSBX5FqvsrFc69Wqduo+++yT/HVpaWl89tlnG91nm222iT59+sRZZ50Vl1xySVx22WVxzjnnRL9+/aJNmzbp2ThAJdXnbvUda6pdd901ZaxXAQAAAAAAAAAAAAAAAAAAGobDDz88ZfzJJ5/Ep59+mvZ1vnuN1yOOOCLta2zKwQcfnDL+4osv6mTduvThhx/GrbfemnLspptuipYtW27y/qNGjYpOnTolx3Pnzo077rijNre4keq8Lq6JB+SyTPRtXXXtAQcckDL+6KOP6mTduqRrAbJfrr63HTVqVPTv3z85HjduXPzP//xPjebMVbnWt7oWaGhytWv5t1zr2oiq922PHj1SxrNnz073lgBqVX3v2/r+va2uBQAAAAAAAAAAAAAAAKiZ/ExvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKCh2HvvvVPGc+bMqZV1PvzwwygvL0+O8/PzY4899qiVtf7lvPPOi8MOOyzl2B/+8IdaXTNTSktL47LLLks5dv7550ePHj1Sjt12223RtGnT5Pj3v/99vPbaa3Www3+r7utSVFSUMi4rK9vo9j322CP222+/2G+//WKPPfZIeawAdaU+dusOO+wQTz/9dBQWFiaPjR8/PoqLi2tlvUzTq3oVyB651Ktt2rSJiRMnRkFBQURElJSUxCmnnBIbNmxI615zTS71akT1ulWvArkil3qVTculXq1qpxYUFETz5s2T4yVLlqTc3q9fv3jhhRfiq6++ildffTXGjx8fv/3tb+O2226Lhx56KCZPnhxLly6NGTNmxJlnnpnyGQZAbamv3eo71k1367/oVQAAAAAAAAAAAAAAAAAAgIaja9euKeM333yzVtaZOXNmyniPPfaIxo0b18pa33bhhRemjN96661aXzMTbrjhhli4cGFy3Lp167jxxhs3ut+uu+4aI0eOTDk2fPjwOr+mYHVel61dEw8gm2Wib+uia7t06RL9+vVLjtetWxeTJ0+u1TUzRdcCZLdcfG/bp0+fGD16dHL8xhtvxKhRo2q0v1yXS32ra4GGJhe7lo3lUtdGVL1v99lnn+SvS0tL47PPPtvoPttss0306dMnzjrrrLjkkkvisssui3POOSf69esXbdq0Sc/GAaqpvvdtQ/jeVtfqWgAAAAAAAAAAAAAAAKD68jO9AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICGom3btinj4uLiWlvrq6++2uLa6XTqqafG3XffnXLs7bffjpdffrnW1sy0Z555JuXx5efnx1133ZUcH3300TFo0KDkePny5XHllVfW6R5r8ro0b948+et169ZFYWFhnHbaafH444/HwoULY+XKlfHxxx/HrFmzYtasWfHxxx9HaWlpfPzxx3H//fdHnz590v54ADalPnVrUVFRnHfeeTF37tz43ve+lzz+3nvv1XmH1DW9qleB7JBLvTphwoTo0KFDREQkEokYNmxYLFq0KG37y2W50KsR1e9WvQrkilzqVTYvF3q1Op3aokWLlPGqVasiIqJVq1bx/PPPx+TJk+PYY4+Nxo0bb3aOvLy8OOigg+J3v/tdvPvuu9GzZ88aPAqArauP3eo71i13q14FAAAAAAAAAAAAAAAAAABoWPbee++U8Zw5c2plnQ8//DDKy8uT4/z8/Nhjjz1qZa1/Oe+88+Kwww5LOfaHP/yhVtfMlNLS0rjssstSjp1//vnRo0ePlGO33XZbNG3aNDn+/e9/H6+99lod7PDfqvu6FBUVpYzLyso2un2PPfaI/fbbL/bbb7/YY489Uh4rQCZlom9ru2t32GGHePrpp6OwsDB5bPz48bV6naJM0rW6Fshuufbetk2bNjFx4sQoKCiIiIiSkpI45ZRTYsOGDWnbay7Klb7VtUBDlGtdy6blStdGVL1vCwoKUv6/KkuWLEm5vV+/fvHCCy/EV199Fa+++mqMHz8+fvvb38Ztt90WDz30UEyePDmWLl0aM2bMiDPPPDPl8w6AulKf+7ahfG+ra3UtAAAAAAAAAAAAAAAAUH35md4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQENRVFSUMv76669rba3vzv3dtdNhm222idtvvz0ef/zxKCwsTB5fvXp1nHPOOZFIJNK+Zja56KKLory8PDk+9NBDY8iQIVFYWBh33HFHyn2vvvrqWLZsWZ3sKx2vy7d/v+Tn58fChQvj8ccfj9NOOy06duy4yXPy8vJijz32iPPOOy9effXVeOONN6Jnz541f0AAW5BL3XrggQfGpEmTUvLCCy/EK6+8EnPnzo2vv/467r///mjbtm3ynPnz58fAgQNj5cqV6XgIWU2vptKrQCbkSq+OGjUq+vfvnxyPGTMm/vd//zddW6sXsrVXI2rerXoVyBW50qtsXbb2ak06dbvttksZr169Onbcccd488034/jjj6/yXrp27RqvvfZanHDCCVU+F6Cy6lO3+o61ct2qV/UqAAAAAAAAAAAAAAAAAADQsHz7mqwREcXFxbW21ldffbXFtdPp1FNPjbvvvjvl2Ntvvx0vv/xyra2Zac8880zK48vPz4+77rorOT766KNj0KBByfHy5cvjyiuvrNM91uR1ad68efLX69ati8LCwjjttNPi8ccfj4ULF8bKlSvj448/jlmzZsWsWbPi448/jtLS0vj444/j/vvvjz59+qT98QBUVqb6tja6tqioKM4777yYO3dufO9730sef++99+q8V+qartW1QPbKtfe2EyZMiA4dOkRERCKRiGHDhsWiRYvSsr9cl+19q2uBhirXupbNy/aujahe37Zo0SJlvGrVqoiIaNWqVTz//PMxefLkOPbYY6Nx48abnSMvLy8OOuig+N3vfhfvvvuu/78KUOfqa982tO9tda2uBQAAAAAAAAAAAAAAAKqnMNMbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGgomjVrljIuLS2ttbVWrVqVMt5mm23SNnd+fn6cccYZMXr06OjQoUPKbaWlpfGjH/0o5syZk7b1tqZNmzYxc+bMKp+3YcOGOPjgg6u97rx582Ls2LFx1VVXJY+NGTMmOnfuHF26dEkee/fdd+Pee++t9jqVlc7XpXnz5slfFxQURNu2bau8n4MPPjhmzJgRF198cdx///1VPh+gMnKpW9u2bRvHHXdcpe9/9913x5VXXhlr1qyp0jo1pVe/oVeBhigXerVPnz4xevTo5Hj69Okp3ZFt9Oq/patb9SqQK3KhV3ONXv1GOjq1cePGKeOKiop49tlnY88994yIiPXr18fjjz8ezzzzTLz99tuxbNmyKC8vj1atWsVee+0VRx99dAwfPjx22mmn5BzNmjWLJ598Mo488siYPn16mh4twL/Vh271Hes3KtOtelWvAgAAAAAAAAAAAAAAAAAADU9RUVHK+Ouvv661tb7++uto167dZtdOh2222SZuuummuOSSSyIvLy95fPXq1XHOOedEIpFI+5rZ5KKLLoq5c+cm/13+oYceGkOGDIknnngi7rjjjpT7Xn311bFs2bI62Vc6Xpdv/37Jz8+PhQsXbvW6eHl5ebHHHnvEHnvsEeedd17MmDEjLrzwwvjb3/5W/QcDUA2Z6tvqdO2BBx4Y1157bcqxvLy8aNasWbRr1y66dOkSBQUFKbfPnz8/Bg4cGCtXrqz+xnOErk2la4FskUvvbUeNGhX9+/dPjseMGRP/+7//m7b91QfZ2Le6Fmjocqlr2bps7NqImvXtdtttlzJevXp17LjjjvHqq68mr1dbFV27do3XXnstTjvttHj++eerfD5AddS3vm3I39vq2q3TtQAAAAAAAAAAAAAAAMB3FWZ6AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANVSKRqLO58/Ly0jLvySefHDfccEN07tx5o9sWLFgQgwcPjnfeeScta1VWYWFhHHjggVU+b/78+TVee/To0TF06NDYZZddIiJip512il/+8pfJ2xOJRAwfPjwqKipqvNaWpPt1KSoq2ujYkiVL4pVXXomZM2fGokWLYvny5ZGXlxfbbbdd7L777nHIIYfEMcccE02bNk2e06hRo7jvvvuioqIiHnzwweo9OIAqyMVu3ZyTTjopXn/99Xj88cdrdZ3v0qt6FeBfsq1X27RpExMnToyCgoKIiCguLo5TTz01NmzYUCt7TAe9+o10dqteBXJVtvVqLtKrtff5/CGHHBL5+fkREfHOO+/Eqaeeusnnrbi4OIqLi2PGjBnxm9/8Jm688ca48sork7c3adIkJkyYEF27do3S0tIq7wOgKnKtW33Hmmpr3apX9SoAAAAAAAAAAAAAAAAAANDwNGvWLGVcm//WetWqVSnjbbbZJm1z5+fnxxlnnBGjR4+ODh06pNxWWloaP/rRj2LOnDlpW29r2rRpEzNnzqzyeRs2bIiDDz642uvOmzcvxo4dG1dddVXy2JgxY6Jz587RpUuX5LF333037r333mqvU1npfF2aN2+e/HVBQUG0bdu2yvs5+OCDY8aMGXHxxRfH/fffX+XzAaorU31bna5t27ZtHHfccZW+/9133x1XXnllrFmzpspr1YSu/YauBfhGrry37dOnT4wePTo5nj59ekqnZBt9+42zzjpL1wINXq50ba7Rtd9Ix3vbxo0bp4wrKiri2WefjT333DMiItavXx+PP/54PPPMM/H222/HsmXLory8PFq1ahV77bVXHH300TF8+PDYaaedknM0a9YsnnzyyTjyyCNj+vTpaXq0AJtXX/q2Pnxvq2s3pmsBAAAAAAAAAAAAAACA2laY6Q0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANFR5eXk5M/fAgQPjxhtvjB49emx0W0VFRTz00ENxxRVXxKpVq9K6bm36+OOPazxHWVlZXHrppfGnP/1pk7f/93//d7z55ps1Xmdzaut1ueaaa+L666+P/fffP6ZNmxY33nhjTJkyJRKJxBbPa9WqVYwcOTKuuOKKKCgoSB6/66674s0334w5c+ZUaR8AVZXN3VpcXBz/93//t9Hxpk2bRps2bWL33XeP/Pz85PEOHTrEH/7whzjssMPiwgsv3OqfwZmmVzdPrwK5Ktt6dcKECdGhQ4eIiEgkEjFs2LBYtGhRureWFepDr0bUTrfqVSBXZVuvNiT1oVdr+/P5f30eMX369DjyyCNj7dq1Wz2nvLw8RowYEZ999lnceeedyeO77bZbDB8+PMaNG1etvQBUVq50q+9YN21r3apXv6FXAQAAAAAAAAAAAAAAAACAhqw2r8X63bnTda2Bk08+OW644Ybo3LnzRrctWLAgBg8eHO+8805a1qqswsLCOPDAA6t83vz582u89ujRo2Po0KGxyy67RETETjvtFL/85S+TtycSiRg+fHhUVFTUeK0tSffrUlRUtNGxJUuWxCuvvBIzZ86MRYsWxfLlyyMvLy+222672H333eOQQw6JY445Jpo2bZo8p1GjRnHfffdFRUVFPPjgg9V7cAA1VFd9WxfXzDvppJPi9ddfj8cff7zW1/o2XatrAbYkG9/btmnTJiZOnJi8VndxcXGceuqpsWHDhrTvMV307Td9O378+I2O61qgocvGrs1Furb2Pt8/5JBDkterfeedd+LUU0/d5PNWXFwcxcXFMWPGjPjNb34TN954Y1x55ZXJ25s0aRITJkyIrl27RmlpaZX3AVATudi39eV7W127dboWAAAAAAAAAAAAAAAASLfCTG8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoKEoKytLGTdv3rzW1ioqKkoZr1mzplrz9O3bN26++eY45JBDNnn7lClT4sorr4zZs2dXa/50KC8vj+nTp1f5vJdffjkt6z/77LPx4osvxjHHHJNyvKSkJEaOHJmWNb6rtl+XF154IV544YXYZ5994oMPPqj0ef96zJMnT45JkyZF06ZNIyKicePGMW7cuDj66KOrtR+Azcmlbn3zzTfjiCOO2OztLVq0iOOPPz5GjhwZ3bp1Sx4fPnx4rFq1Kn7+859XbcPVpFc3pleBhiKbe3XUqFHRv3//5PiWW26JP//5z7Wyt3RqiL0aUbvdqleBXJHNvZqrGmKv1uXn8ytXroxBgwbF2rVrq3TeXXfdFYccckicfvrpyWMXXXRRjBs3rsZ7Avi2XOtW37Fu3Za6tTboVQAAAAAAAAAAAAAAAAAAgNySl5eXM3MPHDgwbrzxxujRo8dGt1VUVMRDDz0UV1xxRaxatSqt69amjz/+uMZzlJWVxaWXXhp/+tOfNnn7f//3f8ebb75Z43U2p7Zel2uuuSauv/762H///WPatGlx4403xpQpUyKRSGzxvFatWsXIkSPjiiuuiIKCguTxu+66K958882YM2dOlfYBkA7Z3LfFxcXxf//3fxsdb9q0abRp0yZ23333yM/PTx7v0KFD/OEPf4jDDjssLrzwwq3+uZxpunbzdC1Qn2Rj106YMCE6dOgQERGJRCKGDRsWixYtSufWskZ97ltdC/CNbOzahqQ+d21Eej7f/9dnF9OnT48jjzyyUterLS8vjxEjRsRnn30Wd955Z/L4brvtFsOHD3etWqDO5VLf1rfvbXXt1ulaAAAAAAAAAAAAAAAAIN0KM70BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIZi1apVKePtt9++1tZq2bJlyri0tLRK5++8887x29/+NgYNGrTJ21977bW4+uqr469//Wu195guJSUlccQRR2R0DxdddFF88MEH0ahRo+SxX/7yl1FSUpLWder6dfnggw+qdd6UKVNi+PDhMX78+OSxfv36RefOnePDDz9My94AInKrW7dmxYoV8dhjj8UTTzwRt99+e1x44YXJ20aMGBGTJk2KV199Na1rbope/Te9CjQ02dqrffr0idGjRyfHr7/+elx99dW1trd0aki9GlG33apXgWyXrb2ayxpSr2bi8/k777wzli5dWq1zr7rqqjjttNMiLy8vIiI6deoUXbt2jblz56ZtfwC50q2+Y62azXVrOulVAAAAAAAAAAAAAAAAAACA3FBWVpYybt68ea2tVVRUlDJes2ZNtebp27dv3HzzzXHIIYds8vYpU6bElVdeGbNnz67W/OlQXl4e06dPr/J5L7/8clrWf/bZZ+PFF1+MY445JuV4SUlJjBw5Mi1rfFdtvy4vvPBCvPDCC7HPPvtU6bp4/3rMkydPjkmTJkXTpk0jIqJx48Yxbty4OProo6u1H4CqyFTfVqdr33zzzS1eI6dFixZx/PHHx8iRI6Nbt27J48OHD49Vq1bFz3/+8yqvWR26dmO6FmjIsv297ahRo6J///7J8S233BJ//vOf0763dNO3qXQt0JBle9fmKl27sXR+vr9y5coYNGhQrF27tkrn3XXXXXHIIYfE6aefnjx20UUXxbhx42q8J4AtycW+ra/f2+raytG1AAAAAAAAAAAAAAAAQDoVZnoDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3Fa6+9FocddlhyfNRRR8UDDzxQ5Xn69OkTr7322mZv79KlS7Rt2zbl2IwZMyo198knnxyPP/54FBQUpByfPXt2/PKXv4xJkyZVeb8Nwfz586O4uDh23HHH5LG5c+embf5cfF1+97vfxc477xzXX3998tivf/3rOP300zO4K6C+yYVurar169fHRRddFDfffHN8/vnnkZ+fHxERf/3rX2PnnXeORYsW1cq62USvbkyvAnUhG3v1xRdfjP79+0dERCKRiIEDB8aLL75Y5T01ZLXdqxG51616FagL2dir1Fx9eb+6du3alHFFRUX88pe/rPZ8CxYsiAcffDDOO++85LETTzwx7T9zAA1btndrrr0vyha12a16FQAAAAAAAAAAAAAAAAAAILfMnz8/9t9//+R4zz33rLW1dtttt5Txxx9/XOlzBwwYEI899li0bNlyo9tmzpwZV199dUyePLnGe0yXkpKSOOKIIzK6hwEDBsSSJUtSri8waNCgKCkpSesadf26fPDBB9U6b8qUKdGsWbOYM2dOdOvWLSIi+vXrFyNGjIgxY8akc4sAG8lU31alaytrxYoV8dhjj8Vjjz0WERFPPfVUDB48OCIiRowYEQcffHD07ds37et+l67VtQDflq3vbVu3bh2zZ8+ODh06RETEP//5z+jRo0csXry41vaXTvr2m77t1atX2taK0LVAbsrWrs11urZ2P9/v27dvLF26tFrn/sd//EfstddeceCBB0ZERKdOneLMM8+MRx55JJ1bBEiRK33re9uq0bWbpmsBAAAAAAAAAAAAAACA78rP9AYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGoq5c+emjA866KAqzzF8+PD461//Gnfcccdm79OrV6+U8fz582PVqlVbnfuAAw6Ixx57LAoKCpLHli9fHmeffXb06NEjJk2aVOX9UnO5/Lq8//77KeMdd9wxQzsB6qts79aaWLx4cbz11lspx6rz+EilVwE2L9t6ddSoUdG/f//k+KWXXorS0tLo27dvpdOjR4+UOdu3b7/RfbbffvsqP07+LVe7Va8CtS3bepXsV5ed+tVXX200rqioqNGcy5YtSxm3aNGiRvMBfFc2d2uuvi+qz/QqAAAAAAAAAAAAAAAAAABA7pk3b17KeL/99qvWPH369Nni7V26dInGjRunHPv8888rNffJJ58ckyZNipYtW6Ycnz17dpxwwgnRq1evmDx5ctU2TI3l6uvy1FNPpYx79uyZoZ0ADUmm+rayXVsTl112Wcq1Xw477LDo2LFjra/bEOhagMrL1ve2jz32WHTo0CEiIhKJRAwbNiwWL15crb1ROyrTt9lG1wKZkK1dS/arq/e2a9euTRlXVFTEnDlzajTn3/72t5SxzzuA2pYLfZurn1nWZ7oWAAAAAAAAAAAAAAAAqC8KM70BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIZi6tSpKeNdd9019t577/joo48qdf7IkSPjv/7rvyIi4uKLL46lS5fG6NGjN7pfv379UsZvvPHGVufOz8+PCRMmRKNGjZLH/vGPf8QPfvCDSu+P9Mv116W4uDhlXFRUlKGdAPVVNndrOsyfPz8OPvjg5HjHHXesk3XrK70KsGXZ1qvfPfeYY46JY445plJ72ZwTTjghTjjhhJRj+++/f8yaNatG8zZUudytehWobdnWq2S3uu7UFStWxIYNG6KgoCAiIioqKmo8ZzrmANiSbO3WXH5fVF/pVQAAAAAAAAAAAAAAAAAAgNw0d+7clPFBBx1U5TmGDx8ed999d9x1111xySWXbPI+vXr1ShnPnz8/Vq1atdW5DzjggHjssceS/748ImL58uXxs5/9LMaPH1/lvZIeufy6vP/++ylj1x4G6kIm+rayXVtTixcvjrfeeivluu4HHXRQLFq0qNbXrs90LUDVZON721GjRkX//v2T45deeilKS0ujb9++ld5Tjx49Usbt27ff6Pw5c+bE119/Xek5+bdc7VtdC2RCNnYt2a8uu/arr77aaFzTa80uW7YsZdyiRYsazQewNdnet7n6Hqo+07UAAAAAAAAAAAAAAABAfZKf6Q0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANBRLliyJ9957L+XY+eefX+nzy8vLU8Y33HDDRudvv/32cfLJJ6cce+GFF7Y697Bhw6JLly7JcUVFRQwaNCg++uijSu+P9Mv116VRo0Yp4+/+HgaoqWzu1nRYtWpVyrhJkyZ1sm59pVcBtizberWgoKDSa9fEp59+Wifr1Ee53K16Faht2darZLdMdOr8+fOTv27ZsmWN52vTpk3K+Ouvv67xnADflq3dmsvvi+orvQoAAAAAAAAAAAAAAAAAAJCbpk6dmjLeddddY++99670+SNHjox77rkn8vLy4uKLL45rrrlmk/fr169fyviNN97Y6tz5+fkxYcKElGuY/eMf/4hevXrF+PHjK71H0ivXX5fi4uKUcVFRUYZ2AjQkmejbynRtunz7WjARETvuuGOdrV0f6VqAqsvG97ajR49OGR9zzDExbdq0KuW3v/1tyhwnnHDCRvfp1KlTpR8n/5bLfatrgUzIxq4lu9V1165YsSI2bNiQHFdUVNR4znTMAVAV2dy3ufweqr7StQAAAAAAAAAAAAAAAEB9k5/pDQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0JA8//HDK+Kyzzortt9++UufedtttcfPNN6ccu+eee2Lw4MHJ8bnnnhtNmzZNjlesWBGTJk3a6tw/+clPUsZPPPFEzJgxo1L7ovbk+uvSvn37lPGXX36ZoZ0A9Vm2dms6tGzZMmX89ddf18m69ZVeBdi6+tyrm1JSUhLLly/P2Pq5Lpe7Va8CdaGh9SrVl4lOff3115O/LiwsjM6dO9dovn333TdlvGDBghrNB7Ap2ditufy+qL7SqwAAAAAAAAAAAAAAAAAAALlpyZIl8d5776UcO//88yt9fnl5ecr4hhtu2Oj87bffPk4++eSUYy+88MJW5x42bFh06dIlOa6oqIhBgwbFRx99VOn9kX65/ro0atQoZfzd38MAtSETfVuZrk2XVatWpYybNGlSZ2vXR7oWoOqy8b1tQUFBpdeviU8//bRO1qlvcrlvdS2QCdnYtWS3THTt/Pnzk7/+7v+DrjratGmTMvb/sQNqWzb3bS6/h6qvdC0AAAAAAAAAAAAAAABQ3+RnegMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADckjjzwSq1evTo5btWoVt99+e6XPv+qqq+L+++9PjvPz8+Oxxx6Lo446Knbfffe49tprU+7/8MMPR2lp6RbnbNmyZRx66KEpxx566KFK74naUR9elyOOOCJl/Pnnn2doJ0B9lo3dmi7dunVLGX/55Zd1sm59pFcBKieberVz5841zrBhw1LmfOKJJ1JuP/DAAyv92EiV692qV4G6kE29SvbKVKdOmzYtZXzSSSdVe67WrVtv9Bjeeuutas8HsDnZ1q25/r6oPtKrAAAAAAAAAAAAAAAAAAAAue3hhx9OGZ911lmx/fbbV+rc2267LW6++eaUY/fcc08MHjw4OT733HOjadOmyfGKFSti0qRJW537Jz/5Scr4iSeeiBkzZlRqX9SeXH9d2rdvnzJ27WGgrtR131ama9OlZcuWKeOvv/66ztauj3QtQPVk63vb2lRSUhLLly/P6B5yVS73ra4FMqUhdi3Vl4muff3115O/LiwsjM6dO9dovn333TdlvGDBghrNB1AZ2dq3ufweqr7StQAAAAAAAAAAAAAAAEB9k5/pDQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0JMXFxTF27NiUY2eeeWYMGTKk0nMMHz48nnrqqeS4cePG8eyzz8Yf//jHaN68efL4qlWr4qabbtrqfD169Ii8vLzkeN26dfHaa69Vej/Ujky+Lj169Ignn3wy7rjjjmrP0b59+xg8eHDKsZdeeqmmWwPYSDZ2a0TE9ttvH9tss02l9/BdvXr1in322Sc5TiQS8fbbb1d7voZOrwJUTjb16kcffVTjfP755ylzfvXVVym3f/rpp5V+XKTKVLfqVSCXZFOvkr0y1alPP/10LF++PDm+4oorYtttt63WXNdcc00UFhYmx7NmzYr58+fXeI8A35Vt3eo71uyjVwEAAAAAAAAAAAAAAAAAAHLbI488EqtXr06OW7VqFbfffnulz7/qqqvi/vvvT47z8/Pjsccei6OOOip23333uPbaa1Pu//DDD0dpaekW52zZsmUceuihKcceeuihSu+J2lEfXpcjjjgiZfzd6ycC1Ja67tutdW06devWLWX85Zdf1tna9Y2uBai+bHtv27lz5xpn2LBhKXM+8cQTKbcfeOCBlX58/Fuu962uBTIl27qW7JWprp02bVrK+KSTTqr2XK1bt97oMbz11lvVng+gsrKxb3P9PVR9pGsBAAAAAAAAAAAAAACA+ig/0xsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaGhuueWW+Pjjj1OO/f73v4+zzjqrUucnEokYMmRIvPzyy8ljRUVF0aNHj5T7XXnllbFs2bKtzrfrrrumjD/99NMoLy+v1F6oPZl6XZ555pl499134+STT46f/vSncdRRR1V5jkaNGsUjjzwSzZs3Tx4rKSmJqVOnpnOrAEnZ1K1t2rSJm2++OT777LMYN25cpdb/rhYtWsRDDz2UcuyNN96IL7/8slrzoVcBqiKbepXslYlu1atALtKrbE2m3q+uXr065bOHHXbYISZMmBB5eXlVmuf444+PSy65JOXYmDFj0rJHgE3Jpm71HWv20asAAAAARERcc801cfPNN8fNN98ce+21V6a3AwAAANQzPnsAAAAAAACA2lVcXBxjx45NOXbmmWfGkCFDKj3H8OHD46mnnkqOGzduHM8++2z88Y9/TLkG2apVq+Kmm27a6nw9evRI+ffj69ati9dee63S+6F2ZPJ16dGjRzz55JNxxx13VHuO9u3bx+DBg1OOvfTSSzXdGkCl1HXfVsb2228fP//5z2Obbbap9B6+q1evXrHPPvskx4lEIt5+++1qz9fQ6VqA6su297YfffRRjfP555+nzPnVV1+l3P7pp59W+rHxb5nqW10L5Lps61qyV6a69umnn47ly5cnx1dccUVsu+221ZrrmmuuicLCwuR41qxZMX/+/BrvEWBrsrFvfW+bfXQtAAAAAAAAAAAAAAAAUB/lZ3oDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1NaWlpDB48ONasWZM8lp+fH+PHj48nnngidt55563OsW7duvjxj38cn3322SZvf+qpp+L++++v1H5atGiRMi4uLq7UedSuTL0uixYtSv66oKAgJk2aFEOHDq30+TvttFP8+c9/jn79+qUcv/baa1N+zwOkUzZ162677RajRo2KFi1axAUXXBD33XdfNG/evNKPpUuXLvF///d/0a1bt5Tj1113XaXnYGN6FaDysqlXyV6Z6Fa9CuQivcrWZPLz+ZtuuikWL16cHJ9wwgnx3HPPxXbbbVep888555x48sknIz8/P3ls+vTp8fjjj6d9rwD/kk3d6jvW7KNXAQAAAIiIuPTSS2PUqFExatSo2G233TK9HQAAAKCe8dkDAAAAAAAA1L5bbrklPv7445Rjv//97+Oss86q1PmJRCKGDBkSL7/8cvJYUVFR9OjRI+V+V155ZSxbtmyr8+26664p408//TTKy8srtRdqT6Zel2eeeSbefffdOPnkk+OnP/1pHHXUUVWeo1GjRvHII4+kXLO4pKQkpk6dms6tAmxRXfbtlrRp0yZuvvnm+Oyzz+I3v/lNjBs3rlLrf1eLFi3ioYceSjn2xhtvxJdfflmt+dC1ADWVbe9tyU6Z6FtdC9QXupbKyNR729WrV6d8TrHDDjvEhAkTIi8vr0rzHH/88XHJJZekHBszZkxa9ghQGdnWt763zT66FgAAAAAAAAAAAAAAAKiPCjO9AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICGaPbs2XHSSSfFs88+G02bNk0eP+WUU+LEE0+MV155JZ5//vmYNWtWLF26NP75z39GYWFhtGzZMvbee+/4wQ9+EIMHD45dd911o7nLy8vjkksuqfReCgtT/1c2nTp1invvvbf6D+5bbrrppli4cGFa5mpoMvW6XH311TFgwIDYc889IyKiWbNm8eijj8Zll10W48ePj6lTp8a8efNi3bp1yXOaN28evXr1ih//+Mdx5plnRlFRUcqc06ZNS9veATYnW7p15syZ8eCDD8a5554bERHnn39+nHTSSfG73/0uXnzxxZgzZ06UlJSknNOmTZvo1atX/Md//EecfPLJ0bhx45TbH3vssXj55Zer+pTwLXoVoGqypVfJXpnoVr0K5Cq9ypZk8vP5kpKSGDJkSPzlL3+J/Pz8iIg4/vjjY/78+XH77bfHn/70p3jvvfdSzmnVqlX069cvLrvssujdu3fKbUuXLo0hQ4ZEIpFIy/4BNidbutV3rNlHrwIAAAAAAAAAAAAAAAAAAOS+0tLSGDx4cMyYMSN5XYH8/PwYP358DBgwIK688sqt/pv8devWxY9//OOYO3fuJq8v8NRTT8X9999fqf20aNEiZVxcXFzJR0JtytTrsmjRouSvCwoKYtKkSXHeeefFhAkTKnX+TjvtFI8++mgcddRRKcevvfbaWLNmTVr3CrAl2dK3u+22W4waNSo5vuCCCyIvLy+uuOKKWL16daUeS5cuXeIPf/hDdOvWLeX4ddddV6nz2TRdC1Az2dK1ZLdM9K2uBeoLXUtlZPLz/ZtuuilOO+206NChQ0REnHDCCfHcc8/FsGHDYvny5Vs9/5xzzom77roreZ3biIjp06fH448/Xmt7BviubOtb39tmH10LAAAAAAAAAAAAAAAA1EeFmd4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEP10ksvxQ9/+MOYOHFitG/fPnm8SZMmMXDgwBg4cGC15m3cuHE8/fTT0a9fv1izZk2Vz99pp53iggsuqNba3/Xggw/GwoUL0zJXQ1dXr8vKlSvjmGOOicmTJ8duu+2WPH7AAQfEAQccEBERFRUVsXLlyli7dm1su+220axZs82u9c4778Txxx8fGzZsSMveAbYkW7r1oosuil122SX69+8fERHt2rWLkSNHxsiRIyMiYs2aNVFaWhobNmyI7bbbLho3brzZuV544YU466yzqrVvNk+vAmxdtvQquaEuulWvArlMr1JZdf35/LRp0+LUU0+NCRMmRJMmTSIionXr1nHDDTfEDTfcEGVlZbFs2bIoLy+PVq1aRcuWLSMvL2+jef7xj3/EgAEDYsGCBWnZO8DWZGO3+o41++hVAAAAAAAAAAAAAAAAAACA3DR79uw46aST4tlnn42mTZsmj59yyilx4oknxiuvvBLPP/98zJo1K5YuXRr//Oc/o7CwMFq2bBl77713/OAHP4jBgwfHrrvuutHc5eXlcckll1R6L4WFhSnjTp06xb333lv9B/ctN910k+sLVFOmXperr746BgwYEHvuuWdERDRr1iweffTRuOyyy2L8+PExderUmDdvXqxbty55TvPmzaNXr17x4x//OM4888woKipKmXPatGlp2ztAVWRD386cOTMefPDBOPfcc5PHzj///DjppJPid7/7Xbz44osxZ86cKCkpSTmvTZs20atXr/iP//iPOPnkkze6zvtjjz0WL7/8clWfEr5F1wLUXDZ0LdmttvpW1wINha5lazL5+X5JSUkMGTIk/vKXv0R+fn5ERBx//PExf/78uP322+NPf/pTvPfeeynntGrVKvr16xeXXXZZ9O7dO+W2pUuXxpAhQyKRSKRl/wCVlU1963vb7KNrAQAAAAAAAAAAAAAAgPqocOt3AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKC2vPrqq9G9e/e47bbbYsiQIZGfn1+teRYtWhTNmzePli1bRkTEoYceGk8//XSceOKJsWHDhnRumQZg/vz50atXr7jtttti6NChG92en58f22233RbnSCQS8dvf/jZGjRoVa9eura2tAmwkG7q1vLw8jj322CgtLY3GjRtvdHvTpk2jadOmW5xj7dq18etf/zpuueWWqKioqNZjIDvoVSCXZUOvwrfpVSCX6VWy1dNPPx1LliyJRx55JPbYY4+U25o1axa77LLLFs9/8cUX45xzzokvvviiNrcJsBHdSjbSqwAAuWuvvfaK448/fov3ueOOO2L9+vWbvK1Dhw5xwQUXbPbcsrKyuOmmm2q0R7Jbr169tvh76OOPP45HHnmkDncEAAAAAAAAAAAAAACQ21566aX44Q9/GBMnToz27dsnjzdp0iQGDhwYAwcOrNa8jRs3jqeffjr69esXa9asqfL5O+200xb/LVFVPPjgg7Fw4cK0zNXQ1dXrsnLlyjjmmGNi8uTJsdtuuyWPH3DAAXHAAQdERERFRUWsXLky1q5dG9tuu200a9Zss2u98847cfzxx7vGBZAx2dC3F110Ueyyyy7Rv3//5LF27drFyJEjY+TIkRERsWbNmigtLY0NGzbEdtttt8lrv//LCy+8EGeddVa19s3m6VqA6smGriV3pKtvdS3QkOhaqqKuP9+fNm1anHrqqTFhwoRo0qRJRES0bt06brjhhrjhhhuirKwsli1bFuXl5dGqVato2bJl5OXlbTTPP/7xjxgwYEAsWLAgLXsHqKps7Vvf22YfXQsAAAAAAAAAAAAAAADUB/mZ3gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQ1dcXBxnnHFGdO3aNe68885YsmRJpc5bv359vPLKK/Gf//mfsfvuu8eAAQNi9erVyduPPfbYGD9+fG1tm3run//8ZwwbNiz233//GD9+fJSUlFTqvFWrVsVDDz0U3bp1i5/97Gexdu3aWt4pwMayoVs3bNgQXbp0iVtuuSU+//zzSu992bJlccstt0SXLl3iv/7rv6KioqLS55K99CqQy7KhV+Hb9CqQy/Qq2er111+PLl26xPDhw2Pu3Llbvf+GDRti8uTJMWDAgBgwYEB88cUXdbBLgI3pVrKRXgUAyE3dunWLcePGbTGNGzfe7PkdOnSIa665ZrMZMWJEHT4aMuHAAw/c4u+BoUOHZnqLbMU+++wTgwYNissvvzxGjx4dt912W9x5550xduzY+NWvfhUXX3xx/PCHP4z27dtneqsAAAAAAAAAAAAAANBgvPrqq9G9e/d49NFHa3SN1kWLFsVXX32VHB966KHx9NNPR0FBQTq2SQMzf/786NWrV0yYMGGTt+fn58d2220Xbdu2jWbNmm3yPolEIm6//fY49NBDY+XKlbW5XYCtqu2+3Zry8vI49thj46abbory8vJN3qdp06bRqlWr2GGHHTb7b37Xrl0bv/jFL+LEE0+M9evXV+9BkBV0LVDfeG9LttG1QH2ja8lmTz/9dBx11FExf/78jW5r1qxZ7LLLLrHnnntGq1atIi8vb6P7vPjii3HAAQfErFmz6mC3AJunb8lWuhYAAAAAAAAAAAAAAABIt8JMbwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAb3zwwQdxySWXxKWXXhqdO3eO/fbbL3bffffYfvvtY9ttt41169bF8uXL48svv4y5c+fGrFmzYvny5cnz33zzzRg0aFC88MIL0bhx44iIGDZsWBQXF8fPfvazza576623xq233lrrjy9d/vrXv0ZeXl6mt7GRnXbaKa3zZcvrMmvWrDj77LMjPz8/evToEfvuu2/svvvu0aJFi2jevHmUlpZGSUlJLF26NGbOnBlz5syJioqKTG8bICIy163/8umnn8bIkSNj5MiR0alTp9hvv/1ijz32iDZt2kTz5s2jUaNGsXLlyvjqq69i0aJF8dZbb8VHH31Ua8/HpujVuqVXgVyW6V6tjrruuYbSqxHZ0a16Fchl2d6rI0aMiBEjRtR4nppoKL2aDZ36L+vXr4/77rsv7rvvvmjfvn384Ac/iPbt20fbtm1j2223jdWrV8eyZcvi/fffj+nTp0dJSUmmtwyQlIluzaY/wyujIXRrNr0mehUA4N86deoUjz76aI3mWLduXaxatSpWrlwZixcvjvfeey/ee++9+Nvf/uazf4j0/HdWWSUlJXHiiSfW2n4qKipi9erVsWLFiliwYEF8+OGHMX369Pjwww+rNd+WFBQUxLHHHhtDhw6Nfv36RcuWLSt97qeffhrPP/98PProo/HOO++kfW9A5RUVFUXfvn2jR48e0blz52jbtm1sv/32yduvvvrqGDhwYMyfPz9mzJgRf/vb32LDhg1p30eLFi0qdb/y8vJYs2ZN2tdPh86dO0ffvn2jW7duscsuu8S2224bjRs3jrVr18aKFSvis88+izlz5sS0adPik08+qbV9NGnSJHr27Bm9evWK733ve9GyZcvYfvvto2nTplFWVhZff/11fPXVVzFnzpx46623YtasWbFu3bpa2w+QO7p16xaHHXZYfO9734udd945ioqKolGjRlFWVhYrV66MBQsWxP/7f/8vpk6dGp999lmt7CGTfbD77rvHCSecEAceeGC0a9cuCgoKYtmyZfHBBx/EpEmTauXn1qZNmya/W/uXsrIyfy4Dm/TdPyPXrFkT5eXlaZt///33j169ekXXrl2jffv2se2220azZs2Sny1+/vnn8d5778W0adPi/fffT9u6/vyF+i9bPnuIqB+fP0TU/WcQ+fn5UVRUlIadb9qKFStqbW6g7tXHPzPS+bN4Xf/862dfoGfPnvH9738/9t133+jYsWMUFRVFs2bNYsOGDbFq1apYsmRJfPjhh/H666/HzJkza+1n8YjMfZfmswcAAAD4t+Li4jjjjDPi5ptvjuHDh8fgwYMr9W/V169fH9OmTYsJEybEY489Fj179oxXXnklmjdvHhERxx57bIwfPz7OOOOM2n4I1EP//Oc/Y9iwYTFu3Li45JJL4sQTT4xWrVpt9bxVq1bFxIkT4/bbb4/33nuvDnYKUDm12beVsWHDhrj66qvjoYceigsuuCBOO+202GWXXSp17rJly2L8+PFx7733xoIFCyp1DtlP1wL1jfe2ZBtdC9Q3upZs9vrrr0eXLl3iJz/5SVx44YXRtWvXLd5/w4YN8Ze//CVuvfXWePHFF+tolwBbp2/JVroWAAAAAAAAAAAAAAAASKe8RCKRqNQd8/Jqey8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAALWikpdl3yTXagc2p3v37tG9e/eI+ObPmU8++eT/s3fnYV6P6+PA71lap1WJslRUKClanCxlC0X2sm8JR5ZwhHJ80SGc7Me+ZqvknGwRoShKIoksoQgt0q69Zn5/nEu/8zHTrJ+Zz5TX67q6rvO+n+e5n/sTPe97nuaM+OCDD0p05gAkS48ePWLo0KGRnp4eERHffPNNtG3bNpYtW5biygBg8+TdCgDJ470KAMnjvQoAyeXdCgCbj7S0tGjbtm00a9Zs4/d7T5s2LaZNm5biyoA/at68eUyfPr1Uci9evDhGjRoVzz77bLz22mslynXcccfFf/7zn3znZGVlxcqVK/Mca9++fUyaNGmTa5csWRK1a9cuUY2Ub71794777rtvk+NvvfVWdO7cuVT2Ls0/Z380b968qF+/fpnX8/PPP8ezzz4bDz30UMycObPE+c4444y4/vrro3HjxiXO9eabb0b//v3jo48+KnEuUmPAPwZElSpV4vbbbo958+aluhwKqVu3bnHBBRfEIYccEhUqVCj0uqVLl8Zzzz0XDzzwQEydOjUptTRq1ChmzZpVqLmPPvponHvuuUnZNxkqVqwY55xzTlx44YXRokWLQq+bMmVK3HvvvfHUU0/Fhg0bklLLbrvtFhdeeGGcdtppUbNmzUKvW7hwYTz55JNx3333JeUdQdnpf03/qF27dtx3733x/fffp7ocNlNVqlSJ3r17x1//+tdo0qRJoddNmTIlBg0aFMOHD4/s7Oyk1JKq98HWW28dgwYNitNPP33j33HlZezYsXHxxRcnrVevU6dOTJ06NbbffvuNsblz50arVq1iwYIFSdmD0tH7wt7RuHHjeOyxx+KrL79KdTn8SfTv3z9uuummhNg111wTAwcOLFHerbbaKi6//PI444wzYocddij0uq+++iruv//+eOihh2Lt2rXF2tv5S1H07Nkzdmu+W4z4z4iYOHFiqsuhkMrT3UPE5n3/EJHaO4gDDzwwxowZU6y1heHnk5Vfxx53bOyzzz7x2quvxdixY1NdDpuJLe3MSFYvnor+V++7+erStUscdNBBMWbMmBj12qhUl8NmqHHjxtGnT584+eSTo169eoVet2DBgnjyySfjtttui/nz5yelllT2se4eAChNflY7UBr8rHYgFdLS0mKXXXaJVq1axU477RS1atWK6tWrx7p162Lp0qUxf/78+Pzzz2Pq1KmxdOnShLWdO3eOkSNHRsWKFTfG7rrrrrjsssvK+mOwhUlPT4/WrVtH8+bNY6eddooaNWps/P+kLVq0KH755ZeYPHlyTJs2LWnfvwhQmpL5vi3uu7ZRo0bRqlWr2HnnnaNu3bqRlZUVFSpUiOXLl8fixYvjp59+ig8//DBmzJiRlM9M+eZdC2xpfG1LeeNdC2xpvGspzxo0aBCdOnWKBg0aRL169aJ69eqxYsWKWLBgQXzxxRcxYcKEWLRoUarLBCiQ9y3llXct8GfiZ7WXL76nFgAAAAAAAAAAAKBspaWlRbt27aJp06a+nxYotMJ8j3dmGdQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQBkaPnx41K5dOx588MGYOnVqHHroobFs2bJUlwUAmy3vVgBIHu9VAEge71UASC7vVgAA2LzUrl07TjnllDjllFPi888/jxtuuCH+/e9/p7qsLcb2228f11133SbH169fHxdccEEZVsSf2XbbbRdXXnllXH755fHYY49F//79Y9GiRUXOU69evXj22WfjkEMOSVptnTt3jgMPPDBuuummGDBgQGRnZyctN5BbmzZt4qGHHoo2bdoUa33NmjXjvPPOi3PPPTeGDRsWl112WcyfP79ENTVt2rRE61PlgAMOiMcffzwaN25c5LV77bVXPP7443HFFVfEWWedFZMnTy52HZUqVYoBAwbE3/72t8jIyCjy+jp16sTll18eF110UQwYMCBuueWW2LBhQ7HrATYfXbp0iUcffTQaNGhQ5LV77bVXDB06NPr06ROnnHJKzJo1q8T1pOJ90KRJk3jjjTdip512KnDugQceGBMnToxjjz023n777RLv/fTTT8f222+/8XnDhg1x8sknx4IFC0qcG9iydOzYMQYMGJD0vOeee27cfvvtUb169SKv3XXXXeOee+6Jyy67LE4//fR4//33i7Te+QtbtvJ49xCx+d4/RKT+DqJatWpFXgP8eW1JZ0ayevFU9b96X/jzqVKlSvzjH/+ISy+9tFh/Z7T11lvHFVdcEb17946///3vceedd5aonlT2se4eAAAAoHBycnLiq6++iq+++qrIa9988804/fTTY+jQoZGenh4REUcccURcd911fr4AJZKdnR1TpkyJKVOmpLoUgKRI5vu2uO/a77//Pr7//vsi78+WybsW2NL42pbyxrsW2NJ411KezZkzJ4YOHZrqMgBKzPuW8sq7FgAAAAAAAAAAAAAAACiJzFQXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDyPfTQQ7Fy5cp46aWXYtmyZakuBwA2e96tAJA83qsAkDzeqwCQXN6tAACwedp9993j+eefj5dffjnOP//8mDdvXqpL2uxttdVW0atXr02Or169Oi644IIyrAgiMjMz4/zzz48jjzwyTjrppHjvvfcKvbZx48bx1ltvxU477VQqdV133XXRvHnzOPnkk2PDhg1J3wOI6N27d9x9992RmZlZ4lxpaWlx8sknx4EHHhg9evSI8ePHFztX06ZNS1xPWevTp0/ccccdkZ6eXqI8zZs3j/feey969eoVTz/9dJHX16hRI956661o165dieqIiKhYsWLceOONcdBBB8URRxwRq1evLnFOoPy6+uqrY+DAgZGWllaiPH/5y1/iww8/jAMPPDA+//zzEuUq6/dBVlZWvPbaawn9bU5OTkyYMCGmT58e69evj5133jkOPPDAqFixYkREVK9ePV566aXYc88945tvvin23n379o0uXbokxG644YZ49913i50T2DJtvfXWMWzYsMjIyEhazrS0tBg8eHCcccYZJc7VuHHjePfdd+Oss86KZ555plBrnL+wZSuvdw8Rm+f9Q0T5uIOoVq1aifYG/ly2lDMjWb14Sfrfkvxe6n3hz2fbbbeN0aNHR8uWLUucq2rVqnHHHXfEX/7ylzj11FNj/fr1Rc6Ryj7W3QMAAACUneHDh0ft2rXjwQcfjKlTp8ahhx7q5wsAQJL97/t233339a4FgCTztS0AlC7vWgAofd63AAAAAAAAAAAAAAAAAJRHJf+vGQIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQLj399NOpLgEAtijerQCQPN6rAJA83qsAkFzerQAAsPk66qijol27dnH44YfHtGnTUl0OUEq22267ePPNN+PYY4+N119/vcD51atXj9deey122mmnUq2re/fusXbt2jjttNNKdR/4M7r88svj9ttvz3Ns/vz58c4778SUKVNizpw5cf/990f16tUjIuKBBx6I1atXR4cOHaJdu3aRkZGRsHbbbbeN0aNHR9euXWPs2LHFqm2XXXYp1rpUueyyy+KOO+7Icyw7Ozvef//9mDZtWsyZMyeWLl0atWrVigYNGsRee+0Ve++9d6SlpSWsqVixYjz55JORnZ0dzz77bKHrqFSpUrz55pvRrl27PMc/++yzGD9+fHz++eexePHiWLVqVVStWjW22mqraNmyZRxwwAF5/t4fdNBB8corr8Rhhx0W2dnZha4H2HxcccUVcfPNN+c5Nnfu3Hj55ZdjxowZMW/evFi5cmVUqVIl6tevH61bt47DDjss6tWrl7Cmbt26MXr06GjZsmUsXLiw2HWV9fvglltuiaZNm258njdvXhx11FExefLkhHkNGzaMF198MVq3bh0REVlZWTF48ODYd999i7Vvhw4dYuDAgQmxMWPGxI033lisfMCWKy0tLZ599tmoX79+UvM+/PDDccYZZ+Q59vnnn8c777wTX375ZSxatChWrVoVWVlZse2220b79u2jS5cuUaNGjYQ1GRkZ8eSTT8Yvv/wSo0ePLnB/5y9sucrz3UPE5nf/EFF+7iCysrJK9DmAP5ct4cxIZi9ekv63uPS+8OdTs2bNGD9+fDRp0iTX2Nq1a+P999+PDz/8ML777rtYunRprFmzJrKysqJOnTrRqlWrOPjgg6NRo0a51vbo0SNWrVoVZ511VpHqSXUf6+4BAAAAytZDDz0UK1eujJdeeimWLVuW6nIAYIv0+/t2wYIFqS4FALZIvrYFgNLlXQsApc/7FgAAAAAAAAAAAAAAAIDyJjPVBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEnVr18/xo8fH507d44PP/ww1eUApaRy5coxYsSIaNeuXUyfPj3fuYMGDYpdd921TOo69dRT480334wnn3yyTPaDP4NOnTrFoEGDcsW//vrruOqqq+KVV16J7OzsjfE777wzqlevHhERL774YowePToi/tsjXHjhhXH55ZdHlSpVNs6vXLlyvPzyy7HnnnvGt99+W+T6Lr300rjssstyxXfffff49NNPi5yvNO27775x++2354pv2LAhbr/99rjrrrti7ty5m1y/ww47RN++feOiiy6KtLS0jfG0tLR47LHH4qOPPoqvv/66ULX069cv2rdvnys+bty4uOyyy2LKlCkF5thnn33innvuiTZt2iTEDznkkOjdu3fce++9haoF2HwcdNBB8c9//jNXfObMmXHRRRfF66+/Hjk5OZtcn5mZGT179oxBgwZFjRo1Nsbr168fDzzwQPTo0aPYtZXl+6BOnTpxzjnnJMR69OgRkydPzjX3hx9+iK5du8Y333wTWVlZEfHf83OfffaJCRMmFGnf2rVrx3PPPReZmZkbY/Pnz49TTjkl39934M+pX79+0blz56TmPOmkk6JXr1654qNHj46rrroqpk6dmu/6rKysuOiii+L666+PypUrb4ynp6fHU089FU2aNInffvttk+udv7DlKu93DxGb1/1DRPm6g6hWrVrC85gxY+Lss88u5CcB/my2hDMjWb14MvpfvS9QGIMHD44mTZokxFatWhUDBw6M+++/PxYtWlRgjkMPPTTuvPPOaN68eUL8zDPPjFdffTWef/75QtWS6j7W3QMAAACkxtNPP53qEgBgi+d9CwCly7sWAEqXdy0AlD7vWwAAAAAAAAAAAAAAAADKk/RUFwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMlQo0aNeOmll2K77bYr1Px58+bFyJEj8/21YcOGUq4aKKoqVarE8OHDIyMjY5NzmjZtGueee26hc65YsSI+/vjjePPNN+PVV1+Nt956K6ZNmxZr1qwpdI577rknatWqVej5QP7uv//+SE9PT4gNGzYs9thjj3jppZciOzu7UHnmzp0bf//736NFixYxbdq0hLFq1arFs88+G2lpaUWuLycnJ7Kzs3P9Wr9+fZFzlaZKlSrFY489lusz/vLLL7H33nvHVVddFXPnzs03x48//hiXXHJJdOrUKZYsWZIr/+OPP16o38N69erF1VdfnSt+//33R6dOnWLKlCkFf6CImDBhQrRv3z6GDh2aa+ymm26KrKysQuUBNg+VK1eOwYMH5zpnXnjhhdh9991j1KhRkZOTk2+O9evXx8MPPxwdO3bMdY517949WrVqVez6yvJ9cNxxx0WVKlU2Po8bNy7Gjx+/yflz586NJ554IiF22mmnFXnfp556KnbYYYeNz9nZ2XHKKafE/Pnzi5wL2LJ17NgxBgwYkNScWVlZce+99+aKDxw4MA477LCYOnVqgTlWrFgRt956a3Tq1CmWLl2aMLbNNtvERRddlO965y9sucr73UPE5nP/EFG+7iAi/vt7/78WLVoUs2fPTtovYMuyuZ8ZyezFS9r/6n2BwujUqVMcc8wxCbEff/wx9tprr7jxxhtj0aJFhcozevTo2HPPPePll1/ONXbLLbcUqncsD32suwcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABIrcxUFwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwJ/P66+/Ht9++22eY2lpaVGtWrWoU6dONGzYMHbfffdIS0srVN5tt902nn/++dhnn30KnDthwoTo1q1bkeqGzclTTz0Vn376aYnzrFy5MgnVbPrPfaVKlaJOnTqxxx57RJMmTQqVq3nz5tGzZ8945JFH8hzv1atXpKenF6qmW265JcaNGxc5OTm5xitWrBidO3eOK6+8Mjp27Jhvrho1asSll14a119/faE+A7BpBx98cDRv3jwh9v7778cpp5yS55/Vwpg1a1Z06tQp3n///YTc7du3jx49esRzzz1XoprLq/79+8cuu+ySEFu+fHkcfvjh8cknnxQp1/jx4+Ooo46K0aNHR+XKlTfG99lnnzj33HPj4Ycfznf9cccdF5UqVUqIjRs3Li688MIi1RERkZ2dHaeffnq0aNEi9thjj43xGjVqxBFHHBHDhw8vck6gfLrkkktihx12SIiNGzcuTjrppFi7dm2Rcn366afx17/+NYYNGxYREfPmzYtnn302li5dmrR6S9P++++f8Dxy5MgC14wcOTIuuuiijc/77rtvkfa8/PLL48gjj0yI3XTTTTFmzJgi5QG2fFtvvXUMGzYsMjIyNsZGjhyZ6wwpqvPOOy/q1KmTEHviiSfimmuuKXKuDz/8MM4777xcvf+ZZ54Zt9xyyybXOX9hy+TuIfnK0x1ERET16tUTnletWlWkGoA/l835zEh2L17S/lfvCxTGypUrY8yYMXHQQQdFRMTq1auja9eu8dVXXxU519q1a6N79+4xbdq0hH50p512igMOOCDGjh2b7/ry0Me6ewAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDUykx1AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/Pk88sgjMWLEiELNrVu3bhx55JHRr1+/aNasWYHzO3ToED179ozHH3+8pGXCZu2ll14q9J+zslCYP/fNmjWLyy+/PHr16hUZGRn5zr300kvjkUceyXPssMMOK7Cev//973HTTTflO2ft2rXx6quvxquvvhpXXnll3HrrrXnOy8nJiddffz3Gjx9f4L5Awbp06ZIrdsUVV0ROTk6J8i5ZsiR69OgRU6ZMiYoVK0ZExMKFC6N27dolylteVahQIXr37p0rftlll8Unn3xSrJzjx4+Pa6+9NgYNGpQQv/TSS+Phhx/Od23Xrl1zxf7+978Xq46IiA0bNsT//d//xYsvvphrn+HDhxc7L1B4BxxwQOy4444bn7/99tuYMGFC0vJnZmbGpZdemhBbs2ZNnHbaabF27dpi5Xzuueeibdu2MXbs2HjjjTdiw4YNSai0bOyyyy4Jz9OnTy9wzeeff57wvOuuuxZ6v7333jtuueWWhNi7774b119/faFzAKWjtM/fokpLS4tnnnkm6tevvzE2e/bsOOOMM2LRokUlyj1p0qR45ZVX4sgjj4y0tLSYN29e9OnTp9j5hg8fHjfccEPCebjrrrvGVltttclanb+wZXL3kFzl7Q4iIiIrKyvhedWqVcWqA0i9suh/N9czozR68ZL2v3pf2HKU5vk7efLkOPjgg6NNmzZx1VVXxXfffZfra+miWLt2bdxwww0xZMiQhPhBBx0UY8eO3eS68tLHunsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA1EpPdQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJCfX3/9NQYPHhy77bZb9O3bN7Kzswtcc/PNN0elSpXKoDogmWbMmBF//etfo2vXrrF69ep85zZv3jxatGiRK16hQoXYfffd8107fvz4uOmmm4pU2z//+c+46667EmJLliyJO++8M5o2bRpdu3aNt99+u0g5gbz98c/wwoUL44MPPkhK7unTp8fgwYPjyy+/jPPOOy+23377ePDBB5OSu7w5+uijo27dugmxadOmxeOPP16ivPfcc0/MmjUrIbbbbrtFhw4d8l23ww47JDwvXbo03nvvvRLVMmrUqFi/fn1CbMcddyxRTqDw+vTpE08++eTGX+eee25S83fp0iXq16+fEPvXv/4VP/74Y4ny9u3bN1577bXYsGFDifKUta222irh+ZdffilwzR/nVKxYMapUqVLgulq1asVzzz0XFSpU2BhbsGBBnHzyyYX6mhwoXaV9/hZVv3794tBDD934vG7duujRo0csXry4xLknTJgQRx11VDRt2jTuueee+Mc//hHLly8vUc433ngjV2znnXfe5HznL2yZ3D0kV3m7g4iIqFatWsLzqlWrSlQLkDpl0f9urmdGafTiJe1/9b6w5SiL8/fjjz+OHj16RL9+/Uqc69VXX80Va968eb5ryksf6+4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUisz1QUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBhZGdnx2233Rbffvtt/Oc//4n09PRNzq1Xr16cdNJJ8eSTT25yTlpaWlSpUiXfPVeuXFnsegtSoUKFqFChwibH169fH2vXri1UrszMzKhYseImxzds2BBr1qwpcH7VqlXz3SctLa3AORERq1atipycnALn/a9tt902Dj744OjYsWNsu+22Ubdu3ahTp06sX78+fv311/j1119jxowZMXr06Hj//fdj3bp1RcpfkGbNmsVRRx0V7dq1i0aNGkWNGjVi/fr18csvv8S8efNi7NixMXLkyJg3b15S9yVvo0ePjgEDBsTAgQPzndehQ4eYPn16QmyrrbaKjIyMfNeNGDGiWHX1798/zjjjjPjpp5/iX//6Vzz77LOxatWqYuUCNq127doJzz/99FNS81922WWl+o4vL84555xcsX/+859Ffkf/0dq1a+POO++Me+65J9d+EydO3OS6bbbZJuH5p59+Skot8+fPj+22225jbNttty1RTqD8OP7443PF/nj2/JlUq1Yt4bkwfei6desiOzs74evn6tWrF7h28ODB0bBhw43POTk5cdppp8XcuXOLWDWwpevYsWMMGDAgIXb11VfHpEmTkrrPd999F3369ElKrry+vqhZs+Ym5zt/Ycvk7iG5ytsdRETxzm/gz2tzPDNKqxdPRv+r9wVSYdmyZbFs2bKoUaPGxtgf+/4/Ki99rLsHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASK30gqcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAED58eKLL8ZNN91U4LwLL7ww3/F27drFihUrNvnr559/TlbJefrnP/+Z7/533313oXNdfvnl+eYaNmxYoeZPnDgx330qVaqU7z6//2rcuHGha+/WrVt8+OGHMXfu3HjmmWfivPPOi6OOOir22Wef2GWXXaJFixbRqVOnOP7446Nfv34xduzYWLRoUQwaNCi22mqrQu+zKQcccECMHz8+vv766xg0aFD06NEj2rdvH7vuumvsvvvucdBBB8Upp5wSjzzySMyZMyeGDBkS22+/fYn3pWCPPPJIbNiwId85LVu2zBXLysoqMPevv/5arJpWrVoVe+65Z7Rq1SoeffTRWLVqVbHyAPnLyckp1fwrV64s1fzlQXp6euy///4JsTVr1sTLL7+clPzPP/98ZGdnJ8Q6deqU75rMzMxc9STDH/P8cR9g83XIIYckPH/88cfx448/pqia8qew78s/ntcF6dOnTxx99NEJsVtvvTVGjx5dpDzAlm/rrbeOYcOGRUZGxsbYK6+8EnfccUcKqypYQXcNBXH+wpbB3UPylMc7iIiIatWqJTz/mf6ZAEW3uZ0ZZdmLl0b/q/cFSsvq1asTnitUqLDJueW1j41w9wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABlLT3VBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQFFdf/318d133+U7p127drHtttuWUUX8bt26dfH9998XOK9Zs2bx0Ucfxcsvvxzt2rUr0h7VqlWLK664Ir7//vs466yzilVnpUqV4sEHH4yxY8fGfvvtV6g1aWlpcfLJJ8fXX38dRxxxRLH2pfB+/fXXmDNnTr5z6tSpkyu2YsWKAnPnta6wZs+eXey1QOEsWrQo4dn7vOh23XXXyMrKSoi9/fbbsXz58qTknzdvXkyaNCkh1qRJk6hVq9Ym1/xx75Kcxf+rbt26Cc/Lli1LSl4gtbbffvvYbrvtEmIjR45MUTXlU1paWqHmpaenFzpnu3btYtCgQQmx999/P/7+978XqTZgy5eWlhbPPPNM1K9ff2Ns9uzZccYZZ6SwqsKpV69ertjSpUsLvd75C1sGdw/JUx7vICIiV02rVq1KSj3AlmlzOjPKuhdPdv+r9wVKU+3atROe8/s7o/Lax0a4ewAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICyVvj/EggAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJQT2dnZ8a9//avAeYceemgZVMP/mjVrVmRnZ+c759BDD41JkyZFmzZtSrRX9erV44knnoiBAwcWaV2VKlXitddei/PPP79Y+1atWjVeeOGFOOaYY4q1nsJbtGhRvuM1atTIFVu4cGGBeU844YRi1wSUvrlz5yY8b7PNNrHLLrukqJrNU9u2bXPFpkyZktQ9Pvnkk1yxvfbaa5Pzv/nmm4TnHXbYIerVq1eiGpo0aZLrXTBjxowS5QTKh9133z1X7NNPP01BJeXHihUrEp6rVKlS4JoKFSpEenp6Quy3337Lc27NmjVj+PDhUaFChY2xhQsXxoknnhgbNmwoRsXAlqxfv34J927r1q2LHj16xJIlS1JXVCHtvffeuWLz5s3b5HznL2yZ3D0kT3m8g4iIqFatWsLzqlWrkloTsGXZnM6M0u7Fk9H/6n2BVGjevHnC+RKR+++m/ld56mPdPQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBqpRc8BQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyp+nn366wDkdOnQog0r4X998802+4wcddFC89tprUatWraTt2a9fv7j66qsLPf+pp56Kgw46qER7VqhQITp37lyiHJSO9evXx9y5c/Ods99++8Utt9wSaWlpZVQVUBTjxo3LFSvKOU9Ey5Ytc8U+++yzpO4xbdq0XLEWLVpscv6YMWMSntPT06NXr14lquG8884rcB9g89S0adNcsS+//DLfNRUqVIhtttkmGjduHNtvv33UqFGjtMpLiUWLFiU816tXr8A1f5yzdu3aWLlyZZ5zn3jiiWjUqNHG55ycnDjjjDPi559/LnqxwBatY8eOMWDAgITYVVddFZMmTUpRRYXXqFGj6NSpU0JswYIF8eOPP25yjfMXtkzuHpKnPN5BRERUq1Yt4XnVqlVJrQnYsmwuZ0ZZ9OIl7X/1vkCqnHXWWblib7311ibnl6c+1t0DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApFZ6qgsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDiWLRoUcyYMSPfObvssksZVcPvvvnmm02ONWjQIIYNGxYZGRlJ3/cf//hH7LPPPgXOO+ecc+KEE05I+v6Ujq222irf8VWrVuUZHzNmTIG5r7rqqvjss8/ikksuiZYtW0aFChWKVSOQfG+88UasXbs2IXbWWWfFeeedl6KKNj+1a9fOFfv222+Tukde+fLa93dDhgyJdevWJcSuueaaaN26dbH232effeLSSy9NiC1fvjz+/e9/FysfUL40aNAgV+yP505GRkYcc8wx8cQTT8Q333wTq1evjnnz5sXMmTPjxx9/jKVLl8bixYvj3Xffjauvvjp22mmnsiq/VPzx698WLVoUuGb33XdPeN7U12sXX3xxHHvssQmx22+/PV577bUiVgls6erWrRtDhw5NuNt5+eWX484770xhVYV3xx13RHp6ekKsoLPO+QtbJncPyVMe7yAiIqpVq5bwvKm7ZICIzePMKKtevKT9r94XSIW2bdtGnz59EmKzZ8+OUaNGbXJNeepj3T0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAamWmugAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACiuyZMnR7NmzTY5vssuu5RhNUREzJgxY5Njjz32WGy99dYF5li2bFlMmTIlfv3118jIyIj69evHXnvtFRUrVtzkmszMzHjkkUeiRYsWm5xTrVq1GDhwYIH7byl23HHHaN68ebHWzpkzJ5YsWZLcgoqoVq1aUb9+/XznLFiwIM/4K6+8EqeeemqBe7Ro0SLuvvvuiIjIycmJuXPnxg8//BCzZ8+OH374Ib7//vuYNWtWTJ8+PX788ceifwigWObNmxdPP/10nHPOOQnxhx56KPbee++45pprYt68eSmqbvNQs2bNXLGlS5cmdY9ly5blitWqVWuT83/66ad46KGH4qKLLtoYq1q1arz11ltxxhlnxGuvvVbovY899tgYPHhwVKhQISF+2223pfz9BSTHH79uWLVqVaxfv37j8xlnnBE33nhj7LDDDvnmqVWrVnTs2DE6duwYN910U/znP/+Jvn37xg8//FAqdZemcePGJfS4Rx55ZAwaNCjfNUcccUTC83vvvZdrTps2beK2225LiH3wwQfRr1+/ElQLbInS0tLi2WefjQYNGmyM/fDDD3HmmWemsKrCu/LKK+PYY4/NFX/ggQfyXef8hS2Tu4fkKY93EBERWVlZCc+rVq3a+L933HHH+Mtf/hLNmzeP7bbbLqpXrx6VKlWKVatWxfLly+O7776L6dOnx7hx42L58uVJ+QxA+Vbez4yy7MVL2v/qfYGy1qVLl3jmmWdyfT/JlVdeGRs2bNjkuvLUx7p7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgNTKTHUBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQXPPnz893vHbt2mVUyeblp59+ivfeey9XvFq1atG6detNrsvJyYn3338/39xTpkzJM77nnnvG4Ycfnu/aBQsWxGWXXRbDhg2LDRs2JIxVr149rrzyyujfv3+kp6fnub558+bRpUuXGDVqVJ7jZ599dtSrVy/fGiIili1bFo8++miMGjUqfvzxx8jOzo5GjRpFt27d4swzz4waNWoUmKM8uPPOO4u99vjjj48RI0YksZqiO+200yIzMzPfOTNmzMgz/vzzz8c//vGPaNq0aaH3S0tLiwYNGkSDBg2iQ4cOucYXL14cH374Yfz73/+OESNGxKJFiwqdGyi6fv36xeGHHx7bbbddQrxnz55x+umnxxtvvBFvvvlmTJo0KT777LMUVVl+1axZM1ds+fLlSd0jr3x57fu/rrrqqjjkkENi11133RirU6dOvPrqq/Hmm2/GY489FuPHj485c+bkWrv99tvH/vvvH7169YqDDjoo1/jkyZNj4MCBxfgkQHmUlZWV8Pzbb79FRESNGjVi6NCh0bVr1yLnTE9Pj+7du0fXrl3jwgsvjCeffDIptZaVESNGxN133x2VK1eOiIiOHTvGfvvtl+fXdhER2267bZx99tkJsWeeeSbhuUaNGjF8+PCoWLHixtjixYvjxBNPjPXr1yf5EwCbu379+sWhhx668XndunXRo0ePWLJkSeqKKoS0tLS44YYb4tprr801NmzYsJg0aVK+652/sOVy95Ac5fUO4o9fU1StWjWuuuqqOPPMM2O33XYr1L7r16+Pt956K/71r3/Fa6+9VviCgc1OeT8zyrIXL2n/q/cFSlt6enrsuOOOsc8++8RZZ50VnTt3zjXnkUceieeeey7fPOWpj3X3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKmVmeoCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACguBYvXpzveJUqVSIjIyM2bNhQRhVtHoYMGRJDhgzJFd9jjz3i008/3eS6NWvWxP7771+sPa+66qp8xxcsWBB77713zJo1K8/x5cuXx7XXXhtz5syJ+++/f5N5Lr300hg1alSeY+eee26Bdb799ttx4oknxsKFCxPi33zzTbz55psxaNCg+M9//hPt2rUrMNfm7Ntvv03p/m3bto2bbrqpwHkTJkzIM56dnR2XXXZZvPLKK5GWlpaUmmrXrh2HHXZYHHbYYXHffffFAw88EAMGDIhFixYlJT+QaMGCBXHMMcfE66+/HnXq1EkYq1ChQhx55JFx5JFHRkRETk5Ownjnzp1j+fLl8dVXXxXYK2ypqlWrliu2cuXKpO7x22+/5YpVr1493zUrV66Mzp07x5tvvhm77rprwljnzp2jc+fOERGxdOnSWLx4caxcuTKysrKidu3aUaNGjU3m/eSTT6Jr166xfv36YnwSoDyqWLFiwvOKFSuiWrVq8dZbb22yF1+6dGksXbo0KleuHHXq1ImMjIw852VlZcXgwYNjhx12iBtvvDHptZeWX3/9NR577LG48MILN8aGDx8e3bp1i48//jhh7o477hgvvPBCwvtg4sSJ8d577yXMe/zxx2OnnXZKiJ111lkxe/bsUvgEwOasY8eOMWDAgIRY375948MPP0xRRYXTpEmTePjhh+PAAw/MNfbNN98knKmb4vyFLZe7h+Qoj3cQVapUifT09ITYM888U+S74szMzDj88MPj8MMPj/Hjx8f5558fX375ZZFyAOVfeT8zyroXL2n/q/cFkmHYsGFx2GGH5YpnZGREtWrV8j2j77///rjooosK3KM89bHuHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACC1MlNdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFNfy5csLnFO1atVCzaP0ZGZmRrdu3fKdc+GFF8asWbMKzPXAAw/EhRdeGC1atMhzvFOnTlGxYsVYu3ZtQrxBgwbRsmXLfHN/9NFH0bVr11xr/9ePP/4YhxxySEybNi0aNmxYYL2bq5kzZ6Zk36233jouvvjiuOKKK6JKlSr5zv3pp5/i448/3uT4q6++Gtdee23ceOONyS4zKlasGH369IkzzjgjTjzxxHjzzTeTvgfw33O5ffv28dxzz0Xbtm03OS8tLS3h+YorrogrrrgiIiJ++OGH+PDDD+Pdd9+N4cOHx4IFC0q15vLij78nERHZ2dlJ3SOvfHnt+0c//fRTtG3bNm666aa44IILomLFirnm1KxZM2rWrFlgrtWrV8fdd98d1113XaxZs6ZwhQP52muvveKmm24q9Nz/1blz5xg1alSh1l566aXx9ddfb3I8PT094XnDhg3x6KOPRrt27TbGVqxYEY8++mi89NJLMXHixFi9enXCml133TU6d+4cvXv3jl133TXXHv/4xz/i559/jieeeKJQNZcHV111VRx66KHRtGnTiIioX79+fPjhh/Hee+/F9OnTY/369bHzzjvHwQcfHJUqVdq47rfffoszzzwzIVfv3r3j+OOPT4jddddd8fLLLyfE6tatG8cdd1x07tw5tttuu6hVq1YsWbIkfvrpp3jzzTfjhRdeiF9//bWUPjH8eZSX8zcvdevWjaFDh0ZGRsbG2EsvvRR33313kfKUpa233jr69+8fF154YVSoUCHX+Pfffx+HH354LFq0qFD5nL+w5XL3UHLl8Q6iWrVqRZpfGPvvv39Mnjw5zjjjjBgxYkSJcgHlq/8tz2dGqnrxkvS//0vvC+VPeTp/85OVlRW1atUq0poff/wxevfuHSNHjizU/PLWx7p7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgNTJTHUBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQXDk5OQXOSUtLK4NKyE/btm2jatWqmxz//vvv4/nnny90vuHDh8cNN9yQ51ilSpWibdu2MWHChIR4x44dC8zbu3fvWLt2bYHzli1bFj179oy33367cAVvZn755Zf47bffkp73xBNPjN133z1XvEqVKlGnTp1o2bJltGvXLjIyMgqV76GHHirwDLjpppti6dKlceedd0ZmZmax6s5P7dq147XXXotzzjknnnrqqaTnByJmzpwZ7dq1i5NPPjkuv/zyaNu2bZHWN2zYMBo2bBjdu3ePu+66K0aOHBn9+/ePL7/8spQqpjDq1KkTdevWLfSZvymZmZmx9dZbR+3atWPevHlJqg7+3OrWrRuHH354sdZut912sd122xVqbs2aNYuUu1GjRrHzzjtvfB4+fHhccMEFsWjRok2u+eqrr+Krr76Ke++9N84555y45557okqVKglz7r333nj33Xdj5syZRaonVVasWBFdunSJ0aNHx0477RQREenp6dGxY8dNfs2zfPnyOPbYY+Obb77ZGGvdunXccccdCfM++uijuPLKKzc+p6WlRb9+/aJfv35RrVq1PHN379497rjjjrjpppvi1ltvLdTX6EDeyuv5m5aWFs8++2w0aNBgY+z777+Ps846q0h5ykrNmjXjyiuvjD59+kRWVlaecyZOnBjHHHNM/PLLL4XO6/yFLZu7hy3Ppt4BERFLliyJyZMnx0cffRQ///xzLF68ONatWxfVq1ePrbbaKlq1ahX77LPPxvP+j3mHDx8e3bt3jxdeeKE0PwJs8cpT/1tez4xU9uIl6X9/p/eF8qk8nb/Jtt1228VJJ50UkydPjvnz55f5/iXl7gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABSJzPVBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQHGlpaWlugQKoWPHjvmOv/LKK0XKN23atHzH27dvHxMmTEiItWjRIt81n332WUyePLnQNYwZMyY+++yzaNmyZaHXbC6+/fbbUsnbo0ePpOWaO3du3H333YWae++998aHH34YgwYNKvDfxeLIzMyMRx99NL7++uuYNGlS0vMD/zV06NAYOnRoNGvWLA4//PD4y1/+Eu3atYudd9650P1AZmZmHHPMMdGtW7e49dZb45prrinlqsnLscceG4MHD44aNWqUOFdmZmb07Nkzjj766DjllFNi9OjRSagQKI8yMjI2/u8bb7wxrr322kKvzcnJiUcffTSmTJkSY8eOTTh/qlatGrfeemt07949qfWWpu+++y723nvvGDRoUJxxxhmRnp6+ybljxoyJiy++OL744ouNserVq8fzzz8flSpV2hhbunRpdO/ePdatWxcRERUqVIhhw4bFcccdV2A91apVi5tvvjn22muvOOWUU2L9+vUl+HRAedOvX7849NBDNz6vW7cuevToEUuWLEldUXnIysqKPn36RN++faNWrVp5zlm7dm1cf/31ceutt0Z2dnaR93D+wpbP3cOWY8mSJTFy5Mg48sgjN8ZefvnlePTRR2PUqFGFOjP32WefuPrqq6Nbt24J8YyMjHjqqadizz33LLW7dKBsldczI9W9eEn6X70vkArp6elx6qmnxmGHHRbdu3ePd955J9UlFZm7BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEiNzFQXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxVWlSpUC56xZs6YMKiE/jRs3znd89uzZ0aBBg0Lny8zMzHd8m222yRXbeeed813z3nvvFXr/340ePTpatmxZ5HXl3XfffZfqEvKVnZ0d55xzTixfvrzQaz788MPo1KlTHHDAAXH66afH0UcfHXXq1ElaTRUqVIjnnnsumjZtGuvWrUtaXiC3GTNmxIwZM+Kee+6JiIiqVatG8+bNY8yYMVG9evWIiFiwYEFstdVWkZGRkWeOjIyM6N+/fzRp0iROOumkyMnJKbP6/+y6d+8eQ4cOzfOfzbRp0+KFF16ISZMmxQ8//BBLliyJNWvWROXKlaNWrVrRqFGj2HvvveO4446LFi1aJKytU6dOvPLKK3HUUUfFG2+8UVYfB0iBoUOHxrXXXlustVOmTIkTTjgh3njjjUhLS9sYP/7446NJkybx7bffJqvMUvfrr7/G2WefHQMGDIhu3bpFu3btYptttonMzMyYP39+fPnllzFy5MiYMmVKrrWPPvpoNGnSJCHWs2fP+P777zc+33bbbXHcccclzPnss8/i7bffjoULF0bdunWjc+fO0bx5843j3bt3jx9++CH69u2b3A8LpEzHjh1jwIABCbErrrgiJk+enKKKcqtYsWJccMEF0b9//6hXr94m573wwgvRt2/fEt95OH/hz8Hdw+ZvyZIl0a1bt2jdunWcd955MXjw4Pjwww+LlGPChAlx1FFHxSmnnBKPP/54VKpUaeNYtWrV4oEHHojOnTsnu3QgBcrjmVFeevHi9r96X6CkTjnllKhQoUKueEZGRtSoUSPq168f7du3j+OOOy723XffhDl169aN119/Pbp06RJjx44tq5KTxt0DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlL3MVBcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADFVbt27XzHc3JyYs2aNWVUDZuy1VZb5Ts+aNCgGDRoUKnuV9C/KzNmzCjyPl9++WWR12wOvvnmm1SXsEk5OTlxySWXxKhRo4q1/p133ol33nknzjvvvNh9991jjz32iFatWsVOO+0UO+64Y+y4446x9dZbFyt3w4YN44wzzojHHnusWOuB4lm5cmV89NFHsWbNmqhevXpERJx22mnxzjvvxO677x4dOnSIY489Ng488MBIT09PWNujR4/48ssv4/rrr09B5aUrJycnVywjIyOpe+SVL699f7frrrvG4MGDc6377rvvolevXvHOO+9scu3PP/8c06dPj1dffTX+7//+Lw455JB49NFHo2HDhhvnVKxYMYYOHRqtWrWKH3/8segfCIiIiEmTJsW+++5bqLm33HJL7L///hufR40aFTfeeGOh1n7xxRdFrm3FihVx6aWXFnnd/3rzzTdj+PDhceKJJ26MpaWlRY8ePWLgwIElyp0Ks2bNinvuuafQ888///zo0aNHQuy+++6LESNGbHzeZ5994pJLLkmYc9FFF8V9992XK9/f/va3uO222xKen3vuufjoo48KXRPwX+Xt/K1bt24MHTo0oXd78cUXi3TmlLYzzjgjbrrppth+++03Oefdd9+Na665Jt5///2k7u38hT8Xdw/5K493EL+bOnVq9O7du0R7DxkyJJYtWxYvvfRSwj/fQw45JPbdd9+kv2Pgz6K89b8R5efMKI+9eFH6X70vlG/l8fzNy/Llyzc5tmDBgvjuu+/ivffeizvuuCPat28fTzzxRDRv3nzjnEqVKsXzzz8fe+yxR8yZMyfPPOW5j41w9wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABlKTPVBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQHFttdVW+Y7/+uuvZVQJ+alTp06Z7pfXvxdZWVn5rlm6dGmR91m0aFGR15Sl0047LV544YUir1u7dm0pVFNyS5Ysib/+9a/x3HPPlTjXhg0b4tNPP41PP/00nn766YSxKlWqxA477BA77rhj7LLLLrH//vvHUUcdFVWqVCkw7yWXXBKPPfZYiesDSm7t2rUxZcqUmDJlStx3333RokWLuO+++6JTp04J86699toYOnRofP311ymqtHQsX748VywrKyvPeHFVq1YtV2zZsmWbnH/PPfdE1apVE2IffPBBHHLIIbFixYoi7f3WW29F69at45133olWrVptjNeuXTtuu+22OPHEE4uUD/j/li5dGhMmTCjU3IULFyY8z58/v9Bri+OZZ56JX375pcR5br311lznROfOnWPgwIElzl2etWrVKu66666E2CeffBKXX355Qqxv374Jzw888EDcd999eea8/fbbY/fdd4+zzjorIiLS0tLiiiuuiJNOOilpdcOfRXk6f9PS0uLZZ5+NBg0abIzNmjVr45/1VNt5553j6aefjg4dOmxyzgcffBDXXHNNjBkzpgwry5vzF7Zcf/a7h9+VxzuIZBs5cmQ8+OCD0bt374T4GWecEe+//36Z1QFbkvLU/yZbSc6M8t6LF4beF8q3LfH8/fDDD6Nt27YxevTo2G+//TbG69SpE4MGDYpTTz01z3VbUh/r7gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABKJj3VBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQHHtscce+Y7/+OOPZVQJ+cnKyirT/TIzM3PFKlSokO+aNWvWFHmftWvXFnlNWVq1alWsXLmyyL/Wr1+f6tJzGTlyZDRv3jyee+65Ut9r1apVMWPGjHjrrbfivvvui5NOOimaNGkSY8aMKXDtHnvsEVtvvXWp1wgU3fTp0+Pggw+Of//73wnx9PT0uPrqq1NUVelZunRprlj16tWTukde+fLaNyKiTZs20blz54TYL7/8EkcccUSsWLGiWPsvWbIkunTpEsuWLUuI9+jRI5o0aVKsnED5NnLkyKTk+eSTT2Lu3LkJsVatWiUld3lVrVq1eP7556Ny5cobY8uXL4/u3bsnfF1TtWrVOPLIIxPW3nLLLfnm/uP4McccU+DXX0D51q9fvzj00EM3Pq9duzZ69OixyV6vLHXp0iU+/vjj6NChQ57jU6ZMia5du0aHDh0K9XV8aXP+wp/Ln+3u4Xfl7Q6itNxwww2RnZ2dEDvssMPKtAZg81HcM6M89+KFUa1aNb0vkBKrVq2Ko446KhYuXJgQP+mkk2L77bfPc82W0se6ewAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICSS091AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUBwVKlSI1q1b5zvnq6++Kpti2OylpaWlugT+YMWKFfHwww9H69ato1u3bjF37tyU1TJnzpzo2rVrTJ06tcC5++67b+kXBBTLhg0b4qyzzor58+cnxI899tgt7j2wdOnSXLGaNWsmdY+88i1ZsiTPuaeeemqu2A033BCLFi0qUQ1z586NW265JVf85JNPLlFeIPVWrVqVKzZ9+vSk5f/iiy8SnmvXrh0VKlRIWv7y5uGHH46mTZsmxHr16hXfffddQmzvvfeOzMzMjc9ffvllzJ49O9/cX3/9dfzwww8bnytVqhRt27ZNQtVAKnTs2DEGDBiQELviiivio48+SlFF/98RRxwRL730Up596Oeffx7HHXdctGnTJkaNGpWC6vLm/IU/nz/T3cPvytsdRGn55ZdfYuLEiQmxhg0bJv2zAluG4pwZ5bkXL6yHH3444VnvC5SlxYsXxz//+c+EWHp6epxwwgl5zt9S+lh3DwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFBymQVPAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA8ufQQw+NihUr5jvn448/LqNqUis9PT3VJeRr5cqVqS4h1qxZk+945cqVi5yzUqVKxS3nT2nOnDmxbNmyXPH169fH4sWLY/HixbFw4cKYMmVKTJo0KaZOnRrr1q1LQaV5W7NmTfz973+PkSNH5juvfv36ZVQRUBwrVqyIhx9+OK699tqNsZo1a0br1q3jk08+SWFlybVo0aJcsWbNmsVHH32UtD2aNWtWqH0jIvbdd9+E5w0bNsSwYcOSUseQIUNi4MCB+e4HbH7yOk9+/fXXpOVfsGBBrliNGjVi4cKFSdujvOjVq1ecfPLJCbGHHnoohg8fnmtu06ZNE56/+OKLQu3xxRdfRMOGDTc+N2nSJCZOnFiMaoFUqlu3bgwdOjQyMjI2xt59990YMWJENGjQICl71KpVK1eunJycmDt3br7rWrRoEf/+97+jQoUKCfHFixfHlVdeGY899ljk5OQkpcZkcf7Cn9ef5e7hd+XtDqI0ffHFF7nuHLbZZptYunRpmdcClH9FOTPKcy9eWH/sf/W+QCqMGDEibr311oTY3nvvnefcLaGPdfcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyZGZ6gIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKA4LrnkkgLnjB07tgwqKR3p6emFnrv11luXYiUlt2jRonzHBw0aFFOnTk3afj/99FOu2MqVK/NdU6tWrSLvs9VWWxV5zZ/ZxRdfHCNGjEh1GSUyZsyYAufUrVu3DCoBSmLMmDFx7bXXJsQaN24cn3zySYoqSr5PP/00V6xly5ZJ3WOPPfbIFZs2bVqecxs2bJjw/NNPPxXYHxTWDz/8EMuWLYsaNWpscj9g87N48eJcsbVr1yYt/5o1a3LFMjIykpa/vGjZsmX861//SohNmzYt+vTpk+f82rVrJzwvXLiwUPv8+uuv+eYBNg8333xzNGjQICHWqVOnPO9Ziqtv377Rt2/fhNj3338fjRs33uSajIyMGDp0aFSuXDkh/s0338Thhx8eM2fOTFp9yeL8Bf4Mdw+/K293EKXpl19+yRWrWbNmmdcBbB6KcmaU1168sP7Y/+p9gVT59ttvY/369ZGZmbkx9sfz9Xebex/r7gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACSJ7PgKQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUL507tw5OnfunO+cuXPnxieffFJGFRVdTk5OvuNZWVmFzrXtttuWtJxStWjRonzHv/jiixgyZEip1rBgwYJ8x3fbbbci5yzOGlKjffv20bdv3zjzzDNj5cqVxc6zatWqWLt2bVSsWHGTc6pWrVrs/EDZ+Pnnn3PF6tatm4JKSs9HH32UK9a2bduk7tGmTZuE5+zs7E32XjVq1Eh4XrhwYVJr+fXXXxP2qFmzZlLzA2Vvzpw5uWI1a9aMX375JSn5a9WqlSu2fPnypOQuL7KysuL555+PypUrb4z99ttv0b1791izZk2ea6pVq5bwvGrVqkLt9cce+495gM1DXmdjWZg5c2a+42eeeWa0bNkyIfbrr7/GIYccErNnzy7N0orF+QtE/DnuHn5X3u4gStOGDRvKfE9g81WUM6O89uKF8cf+V+8LpNqiRYuiXr16G5//+HdUv9uc+1h3DwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJBc6akuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAimK77baLZ555JtLS0vKdN3jw4LIpqJiWL1+e73jDhg0Lnatjx44lLadQMjIyirXuhx9+yHd8zz33LFbeovjmm2/yHS/O72Hnzp2LWw5lZM8994yRI0fGpEmT4oQTToiLL764RPmysrKiYsWK+c757bffSrQHUPpWrVqVK1apUqUUVFJ6ZsyYEcuWLUuIHXDAAVG7du2k5N9xxx2jTZs2CbGvv/56k2dgdnZ2wnNmZmZS6thUvj/uB2x+Jk2alCvWoEGDpOWvX79+wvPq1avzfD9szh588MHYZZddEmLnn39+zJgxo9A5cnJykjoPIC+zZs3Kd/yqq67KFbviiiti9uzZpVVSiTh/gYg/x93D78rbHURpqlOnTq7YwoULy7wOYPOwOZwZBfXihfHH/lfvC6TaH//OaN26dXnO25z7WHcPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkFyZBU8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDyoU2bNvHSSy9FvXr18p23bt26ePDBB8uoquJZtGhRvuN77rlnVK5cOVavXp3vvAMOOCC23377pNS0fPnyfMcrVKgQtWvXjsWLFxcp73vvvZfveNeuXaNPnz5FyllUn3/+eb7jTZs2jQMOOCDeeeedQuU7+OCDo2XLlkmojNLQsmXLGDBgQBxzzDEJ8RtuuCHefPPNmDJlSrHyHnLIIQXO+eWXX4qVG0i0//77x8CBA+Pxxx+PJ554Iqm569atmyv266+/JnWP8mDMmDEJ52BmZmYcd9xx8dhjj5U4d48ePfLcb1MWLFgQWVlZG5+33XbbEtfwv7bZZpuEZ2cxbP6mTp0aK1asSDg7OnXqFFOnTi1x7urVq8eee+6ZEPvss89KnLc8Ofvss+O0005LiD3++OMxZMiQIuVJT09P6jygfJs3b158++23Sc3ZpEmThOdFixbluhP75JNPNrm+VatW0axZs4TY7Nmz4+mnn05ekUnk/IXNi7uH5ClPdxCl6Y/vtYiI+fPnp6ASYHNQlDOjPPbihZFX/6v3BVKpYsWKsdVWWyXE8uvXNsc+1t0DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJF9mqgsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICCNGzYMPr16xdnn312VKxYscD5jzzySMyePbsMKiu+uXPn5juelZUVJ598cjzxxBObnFOxYsW49957k1bTkiVLCpzTtWvXePbZZ4uUd9KkSbF27dpN/rNr0qRJHHfccTFixIhC5+zWrVvsuOOOcd999xVq/rhx4yInJyfS0tI2OeeBBx6Itm3bxooVK/LNVaNGjXjssccKXStlp0GDBnHXXXfFCSeckOc/60qVKsXo0aPjuOOOi3HjxhUpd61atWLQoEEFzvviiy+KlBdI1LZt2xg4cGB07tw5IiLq168fQ4YMiTVr1iRtj9atW+eKFfRe3hw9+uijccwxxyTErr766njyySdj/fr1xc5btWrVuPzyy/Pcb1PmzZsXjRo12vhcr1692GWXXeLrr78udh2/+8tf/hKVKlXKtR+wecvOzo5x48ZFly5dNsZOOeWUuPvuu0uc+9hjj40KFSokxMaPH1/ivOVFixYtcn2dNH369LjooosKXLt8+fKE5ypVqhRqz6pVq+abB9g8XHzxxUnPmZOTk/B8++23x8CBAwu9/vevC/7Xv//978jOzi5xbcnm/IXNh7uH5CtPdxB/VKNGjVi2bFmxa/jfWjp16pQQmzdvXoF/nwBsXlJ1ZpTHXrwgm+p/C6L3BUrTfvvtlyuWXx9envvYvLh7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgNKRmeoCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD489l///0jMzMzz7G0tLSoXr161KlTJxo1ahQdO3aM5s2bFzr3/Pnz4//+7/+SVWqpmTRpUoFzbr311hg/fnx8++23ucaqVasWw4YNixYtWiStpsWLF8eyZcuiRo0am5xz++23x8yZM2PixImFzrtmzZp44403olu3bpuc88ADD8TUqVNj5syZBebbb7/9YsiQIVGtWrXo3r17nH322TFr1qx81yxatCg++OCD6NChwybn7LrrrjF27Ng44YQTYvbs2XnOadSoUfznP/+Jhg0bFlhnqjVr1izat2+flFxffvllLF++PCm5StPq1aujS5cukZaWtsk5derUibFjx8aTTz4Zt99+e0yfPj3fnBkZGXHUUUfFoEGDYuedd8537ooVK+LDDz8sVu3Af/Xs2TM6d+688XnnnXeOgQMHxt/+9rek7XH22WcnPK9bty4++eSTpOUvL0aNGhU///xzbLfddhtjTZo0iYsvvjjuvPPOYuft169f1K9fPyH28ccfx9SpUze5ZsKECfGXv/wlIXbhhRfGJZdcUuw6/jfPH73//vslzgsUbOHChfHTTz9tfF68eHFS8993333RpUuXjc/t27ePo48+Ol566aVi56xYsWLccMMNueJDhw4tds7ypGrVqvH8889HlSpVNsZWrlwZ3bt3j1WrVhW4ftGiRQnP22yzTaH2/eO8ZP+7ACQq7fO3PNlzzz1zxd59990UVJI/5y9sXtw9JF95uoOI+O/fMx1//PFxzTXXxNy5c6Nr167FruF3l112WVSuXDkh9uqrr5Y4L1Cw0u5/nRlFl1//WxC9L2w+yuL+YaeddoqLL744rr322vjtt99KnO+vf/1rrlh+9wjlrY/Nj7sHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKD2ZqS4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIA/n0svvTQuvfTSpOfNzs6Onj17xsKFC5OeO9l++OGHmDNnTjRo0GCTc7beeuuYMmVK/Otf/4q33347FixYEHXq1Il99tknevfuHdttt13S65o0aVJ07tx5k+PbbLNNTJgwIcaNGxfTp0/P8/f6wQcfjJ9//jkh9s9//jO6deu2ybz16tWLSZMmRb9+/eKZZ56J1atX55rTqlWr6NWrV/Tu3TvS09MjIqJTp07x2WefxdVXXx333ntvvp/tkUceiQ4dOuQ7p127djFjxox4+umnY9SoUTF79uzIzs6Ohg0bxpFHHhknnXRSVK1aNd8c5cXNN9+ctFwHH3xwjBkzJmn5SsuiRYviwQcfjCuuuCLfeenp6XH22WfH2WefHTNnzowpU6bErFmzYtmyZbFu3brIysqKWrVqRdOmTeMvf/lL1KpVq1D7P//887Fu3bokfBL487r55pujV69eUaFChY2xyy+/PL7++ut4+OGHS5y/V69e0bFjx4TYmDFjYunSpSXOXd5kZ2fHHXfcEbfffntC/JZbbolPP/20WOf60UcfHf369csVv+222/Jd98ILL8Tll1+eEOvdu3cMGzYsJkyYUOQ6ftelS5c47bTTcsVffPHFYucECq9Xr16lmv/VV1+NGTNmRLNmzTbGHn300Zg2bVrMmjWrWDkff/zxaNSoUUJs/Pjx8dFHH5Wk1HLj/vvvj9122y0h1rt37/jyyy8Ltf6P81q2bFmodX+c98UXXxRqHVA8pX3+lid/PLMjIr7++uuyL6QAzl/YvLh7SL7ydAex3377xaOPPhq77LJLRES0bt06zjrrrBg8eHCRa/hd27Zto3///rniI0aMKHZOoPBKs/91ZhRPSfpfvS9sPkrz/G3evHn0798/TjrppMjIyIisrKw477zzSpTz2GOPje7duyfE1q9fH6+++uom15SnPrYg7h4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACg9GSmugAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEiWq666Kl577bVUl1FoTz/9dFx11VX5zqlevXr0798/+vfvXyY1vf7669G5c+cC53Xs2DE6duyY59grr7wSP//8c0Lsvffei/fffz/23XffTeasW7duPPLII3HvvffG559/Hr/++mvk5OTE1ltvHdtvv31ss802ea7LysqKf/3rX9G9e/c4++yzY+bMmXnOGzJkSFx33XXRsGHDfD9bpUqVolevXtGrV69851E+DRgwII4//vho3LhxoebvtNNOsdNOO5V43w0bNsTNN99c4jzwZ/fjjz/GP/7xjxgwYEBC/KGHHopGjRrFtddeGxs2bChW7gsuuCD+9a9/5YrfdtttxcpXlho3bhxjxozJFT/33HPjrbfe2uS6u+66K0455ZRo06bNxljFihXjxRdfjFNOOSVGjhxZ6BpOPPHEGDx4cGRkZCTER40aFcOGDct37fvvvx9TpkyJvfbaa2MsIyMjRo4cGd26dYv333+/0HX87tBDD43nn38+V3zs2LExffr0IucDyqerr746RowYsfG5bt268fbbb8fRRx8dn332WaHzVKxYMR544IE49dRTE+LZ2dnRt2/fpNWbSmeeeWaceeaZCbGnnnoqnnzyyULnmDx5cqxevToqV64cEf99/zRv3jy++OKLTa5p27ZtbLvtthuff/vtt5g6dWrRigfYhBo1auSK/fLLLymoZNOcv7D5cfewacW9f4goP3cQ8+fPjyZNmiTEHnnkkYiIGDx4cKFr+F3Hjh1jxIgRUbVq1YT4hAkTNqu/jwLy5swoupL2v3pfIC0tLV555ZWEv6M/99xzY+nSpXHllVdGTk5OkXP26NEjnn766VzxwYMHx5IlS/JdW1762Py4ewAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDSlZ7qAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBmuvvrquO2221JdRpHce++9sX79+lSXkeCxxx6LFStWlEruM888M5YuXVrgvEqVKkWbNm3isMMOi8MPPzzatGkT22yzTYHrOnbsGGefffYmx9esWRN9+/YtUs1sfpYvXx6nnHJKrF27tkz3vfHGG2PGjBlluidsqQYOHBgTJkzIFe/Xr19Mnz49Tj755KhUqVKhcqWlpUXXrl3j3Xffjfvvvz8yMjISxocPHx5vvfVWUuouTRUqVIhGjRrl+lW1atV812VnZ0fPnj1j3bp1CfHq1avHK6+8EsOGDYv27dvnm2PfffeNF198MYYNGxaVK1dOGFu+fHmcf/75Bdafk5MTF110UeTk5CTEa9euHePGjYu77747GjduXGCeiIhmzZrFQw89FK+//npkZWUljK1fvz4uvvjiQuUBNg8vvPBCPPzwwwmxxo0bxwcffBDXXntt1KhRo8AcRx55ZEyePDl69uyZa+zmm2+OSZMmJa3eVNltt93i/vvvT4h99dVXccEFFxQpz9q1a+O5555LiA0YMCDfNddff33C87PPPhvZ2dlF2hdgU/7Yf0ZENG3aNPbYY4+k/irMvVNenL+w+XL3kLfi3j9ElJ87iG+++SbuueeehFhmZmY88cQTMXLkyNh3330LzBER0aRJk3jggQdi7NixUadOnYSxdevWRZ8+fQqVByjfnBlFk4z+V+8L5OTkRP/+/XPFr7jiivj444/j6KOPjszMzELlatu2bfznP/+J5557LipWrJgwtmjRorj66qsLzFFe+thNcfcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApa9w/8UUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAop5YsWRK9evWK//znP6kupch++umnuO666+Kmm24qca6PP/442rRpU+I8S5cujQEDBsStt95a4lx/9N1338WZZ54ZL7zwQqSlpSU9/1tvvRXXX399vnOef/75eOKJJ+Lss89Oyp6TJ0+Odu3aJSUXyfPBBx/E0UcfHS+88EJUrly51Pd7/vnn44Ybbij1feDPYsOGDXHEEUfEO++8E61atUoY22WXXWLIkCGxdOnSGD9+fHz44Ycxe/bsqFSp0sY5Rx99dBx44IHRvHnz2H///aN27dp57jNhwoTo2bNnqX6W8mDatGnRs2fPeOqpp3K9f0888cQ48cQTY/bs2fH555/H3LlzY8mSJVG7du2oX79+tGrVKho0aJBn3vXr10ePHj3ixx9/LFQdEydOjL/97W9xxx13JMTT09PjkksuiYsvvjg+/fTTmDx5csycOTOWLFkSq1atiqpVq0atWrVi5513jvbt20fLli3zzJ+TkxPnnXdeTJ8+vVD1AJuPPn36RJs2bRK+3qlatWoMGDAgrrrqqhg3bly89957MXfu3Fi8eHFUqVIl6tatG3vssUcccsgh0ahRozzzDhs2LK699toy+hSlp0qVKvH8889H1apVN8ZWrVoV3bt3j5UrVxY536233hqnnHJKVKhQISIijj/++LjrrrviqquuijVr1iTse8cdd8QRRxyxMbZ27dq47bbbSvBpAAo2adKkpOe88cYbi/xOcP7C5s3dQ+koL3cQV155Zey1117RqVOnhPgRRxwRRxxxRMyZMyfGjx8fM2bMiPnz58fKlSsjMzMzateuHY0aNYoOHTpEq1at8vx7jJycnDjzzDPjo48+KuTvClDeOTMKJ5n9r94XeO655+Lggw+Oc889NyG+5557xosvvhjLli2LiRMnxldffRU//vhj/Pbbb7F69eqoWrVq1K5dO3bbbbfYe++9o2nTpnnmX7VqVRx33HGxcOHCQtVTXvrYP3L3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGUjM9UFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAceTk5MSzzz4bV199dfz888+pLqfYbr755ujYsWMcdthhxc7xyCOPxKeffhpt2rRJSk3//Oc/o3379nH88ccnJd//eumll+L444+Pp59+OrKyspKW9+WXX44TTzwxNmzYUODc888/P+rUqRNHHXVUifYcPHhwvPXWW/HMM8+UKA+l4/XXX49DDjkknnnmmWjUqFGp7JGTkxP33ntvXHrppZGTk1Mqe8Cf1ZIlS+KAAw6Ip556Krp165ZrvGbNmnHkkUfGkUcemWusd+/eBeZ/9dVX4+STT44VK1Ykpd7y7plnnons7Ox44oknomLFirnGd9xxx9hxxx0Lne+3336LHj16xOuvv16kOu68886oWLFiDBw4MNLT0xPG0tLSonXr1tG6desi5YyIWLduXVxyySXxxBNPFHktUP6tXr06Dj744HjllVdi//33TxjLysqKLl26RJcuXYqU87777os+ffpsET3cfffdFy1atEiIXXzxxfH5558XK9+XX34Z/fr1i9tuu21jrE+fPnHmmWfGhAkTYuHChVGnTp3Yb7/9okaNGglr+/btG99++22x9gXY3Dh/YfPn7qF0lIc7iPXr18fhhx8ew4YNi6OPPjrXeIMGDeLEE08sdL7frVq1Knr37h1Dhw4t8lqg/HJmFE4y+1+9LxARccEFF0RExLnnnptrrEaNGnHYYYcV6/tolixZEt27d4933323SOvKQx/7R+4eAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoGykp7oAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoigULFsR9990Xu+22W5x++unx888/p7qkEsnJyYlu3brFkCFDirX+jjvuiPPPPz9ycnKSWlf37t3juuuui3Xr1iU1b0TECy+8EB06dIhPP/20xLkWLVoUF154YRx99NGxevXqQq1Zt25dHH/88XHbbbcV6/ctJycnbrvttujZs2fSf99Jrvfffz923333uOuuu2LlypVJzf3ZZ5/FvvvuG5dccklkZ2cnNTfwX0uWLImjjjoqzj333JgzZ05Scs6fPz/OOuusOPLII2P58uVJybm5GDJkSLRv3z6mTp1aojzvv/9+7LXXXjFq1Khirb/11ltjv/32ixkzZpSojt9NmzYt2rVrFw8++GBS8gHl09KlS+PAAw+MAQMGxNq1a4udZ86cOXH88cfHRRddFBs2bEhihalx2mmnxdlnn50QGzJkSDz22GMlynv77bfHLbfckhCrVatWdO3aNU4//fTo2rVr1KhRI2H8pptuinvuuadE+wJsLpy/sOVw91A6ysMdxOrVq+OYY46Js846KxYsWFCiOiIiPv7442jTpk0MHjy4xLmA8seZkb/S6H/1vsCGDRvivPPOi1NPPTXmzp2blJyvvvpqtGjRIt56661irS8Pfezv3D0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABA2UlPdQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPBH69evj2XLlsXPP/8cH3zwQQwdOjT+9re/RYcOHWKbbbaJiy66KL7++utUl5k069ati1NPPTVOOOGE+Oabbwq15qOPPoqDDjoo/va3v0VOTk7Sa8rJyYkBAwbEDjvsENddd11Mnjw51q5dm7T8n332WbRu3TqOPvromDRpUpE/w3fffRf9+vWLnXbaKe6///4i779+/fro27dv7L333jFq1KhC7z9u3LjYf//9o2/fvqXy+07yrVixIi677LLYYYcdol+/fjF58uRi/7NbuXJlPPvss3HooYdG69atY+LEiUmuFsjLo48+GjvttFOcc845MWbMmMjOzi7S+tWrV8fYsWPjtNNOix122CGefPLJUqq0/Pv0009jr732ihNPPDHGjRtX6PMwOzs73nzzzTjqqKNiv/32K3S/sikTJ06M5s2bx3HHHRdvvPFGbNiwoUjr169fHy+//HIcccQRseeee8ann35aonqAzcOGDRviuuuui6ZNm8bdd98dCxYsKPTaL7/8Mi6++OJo2rRpjBgxohSrLDu77LJLPPjggwmxGTNmxHnnnZeU/P369YsTTjghZs2ale+8mTNnxnHHHRd///vfk7IvQHnn/IUtk7uH5CsvdxBPPvlk7LjjjnHuuefGxIkTi/TPdv369TFq1Kg49NBDo23btvHll1+WqBag/HNm5Faa/a/eF4iIGDJkSOy8885x9tlnx/jx42P9+vVFWr9q1ap48sknY++9944jjzwy5syZU6J6ykMf6+4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAylZaTiH/SyVpaWmlXQsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQKko5I9lz5Of1Q5syh577BF77LFHRPz3nJk5c2Z88MEHJTpzAAAAAAAAAAAAAMhfWlpatG3bNpo1a7bx+72nTZsW06ZNS3FlAMmVnp4e7du3j65du8auu+4aW2+9ddSqVStWrlwZ8+bNi6lTp8arr74aU6ZMKfPaKlSoEM2aNYvatWtHzZo1IysrK895b731VixatKhIuevUqRMHHHBA7LvvvrHNNttEnTp1ok6dOpGRkRErVqyIpUuXxqxZs2L69OkxduzY+Prrr5PxkTbabrvt4sgjj4x27dpFw4YNo1atWhERsWzZsvjhhx9iypQp8cYbb8Q333yT1H1Jja233jo6dOgQu+yyy8Y/Z9WqVYvq1atHZmZmrFixIpYtWxbLli2LBQsWxNSpU+OTTz6J6dOnx5o1a1JdPkkw4B8DokqVKnH7bbfHvHnzUl0ORVSjRo1o06ZN7LXXXrH99tvHNttsE8cff3xUrFgxIiJGjRoVkydPjh9//DG+/vrrmDRpUqxduzbFVZdP9erVi44dO8buu+8eDRs2jGrVqkXlypVj9erVsWzZspg1a1Z8/vnnMW7cuCK/24uiatWqseeee0a7du1i++23j1q1akXNmjWjcuXKsWrVqli6dGksWbIkZs+eHZMnT46pU6fG6tWrS60eSk//a/pH7dq1475774vvv/8+1eWwmUtPT4+2bdtG+/bto2nTplGvXr2oWrVqZGdnx7Jly+KXX36Jzz77LCZMmBDffvttqsvdbGVkZMT+++8fnTt33nhGL168OH7++ecYPXp0vPfee7Fhw4ZUl0kBel/YOxo3bhyPPfZYfPXlV6kuBygE5+/mr2fPnrFb891ixH9GxMSJE1NdDkXk7iH5yssdRO3atWOfffaJXXbZJZo0aRLVq1eP6tWrR0TE4sWLY/HixTF37tyYNGlSTJ48OVatWlVqtVA6jj3u2Nhnn33itVdfi7Fjx6a6HDZzzoyyoffdMnTp2iUOOuigGDNmTIx6bVSqy2EzVrVq1fjLX/4SzZo1iyZNmsRWW20VWVlZUaVKlVi7dm0sXrw4lixZEjNnzoxJkybFtGnTYv369aVWT3npY0uD8xfgz8fPagdKg5/VDgAAAAAAAAAAAFD2/Kz28sX31AIAAAAAAAAAAACUrbS0tGjXrl00bdrU99MChVaY7/FOyynkd4L74e0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAwOaqkD+WPU9+VjuwKXvssUfsscceEfHfc2bmzJnxwQcflOjMAQAAAAAAAAAAACB/aWlp0bZt22jWrNnG7/eeNm1aTJs2LcWVAQCwuRnwjwFRpUqVuP2222PevHmpLockWLBgQdStWzciIg477LAYPXp0iisC8tL/mv5Ru3btuO/e++L7779PdTkAfxq9L+wdjRs3jsceeyy++vKrVJcD8KfQs2fP2K35bjHiPyNi4sSJqS6HJHD3AJuHY487NvbZZ5947dXXYuzYsakuB+BPo0vXLnHQQQfFmDFjYtRro1JdDgAAefCz2oHS4Ge1AwAAAAAAAAAAAJQ9P6u9fPE9tQAAAAAAAAAAAABlKy0tLdq1axdNmzb1/bRAoRXme7zTy6AOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKBfSU10AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlJX0VBcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZSU91QUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAWclMdQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUBJ/+9vfonLlyhER8cUXX6S4GgAAAGBL4+4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtjyZqS4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEriqaeeSnUJAAAAwBbM3QMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABsedJTXQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUlfRUFwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABlJT3VBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBZSU91AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFBW0lNdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJSV9FQXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGUlPdUFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/j7275436zMI4/PzPjI0thAEjZwsqymxNRUmX7bIfgTL7DbJdUibpNiUfYUm1pIMOWrpNSQcSSLwJBNgzs1WiFEhxtMy5see6GkujKX7VU4yObgMAAAAAXSodAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAF0qHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABdKh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXSodAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAF0qHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABdKh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXSodAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAF0qHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABdKh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXSodAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAF0qHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABdKh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXSodAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAF0qHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABdKh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXSodAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAF0qHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABdKh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXSodAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAF0qHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABdKh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXSodAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAF0qHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABdKh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXSodAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAF0qHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABdKh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXSodAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAF0qHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABdKh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXSodAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAF0qHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABdKh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXSodAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAF0qHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABdKh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXSodAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAF0qHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABdKh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXSodAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAF0qHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABdKh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXSodAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAF0qHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABdKh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXSodAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAF0qHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABdKh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXSodAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAF0qHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABdKh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXSodAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAF0qHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABdKh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXSodAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAF0qHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABdKh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXSodAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAF0qHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABdKh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXSodAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAF0qHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABdKh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXSodAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAF0qHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABdKh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXSodAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAF0qHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABdKh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXSodAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAF0qHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABdKh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXSodAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAF0qHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABdKh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXSodAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAF0qHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABdKh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXSodAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAF0qHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABdKh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXSodAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAF0qHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABdKh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXSodAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAF0qHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABdKh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXSodAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcBpU1ZjNZukMAAAAAAAAAAAAgFOtqkZVpTMAAAAAAAAAAAAAAACA37HVDgAAAAAAAAAAALB+tto/bW5qAQAAAAAAAAAAANbLPS2wLvN0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEk3TdPY398fV69eHYvFIp0DAAAAAAAAAAAAcOocHR2Nqhrz+XwcHByMaZrSSQAAAAAAAAAAAAAAAMCw1Q4AAAAAAAAAAACwbrbaP31uagEAAAAAAAAAAADWxz0tsG7zdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBpcP78+bG3t5fOAAAAAAAAAAAAADj1pmlKJwAAAAAAAAAAAAAAAAC/Y6sdAAAAAAAAAAAAoIet9k+Xm1oAAAAAAAAAAACA9XNPC6zDPB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwEh0dHY3FYjFms9lvn/knMwAAAAAAAAAAAAC9lsvlWK1W6QwAAAAAAAAAAAAAAADYKLbaAQAAAAAAAAAAAPJstWe5qQUAAAAAAAAAAADIck8LfCyVDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADiJnj59Ol68eDGWy2U6BQAAAAAAAAAAAGBjvXr1arx8+TKdAQAAAAAAAAAAAAAAABvFVjsAAAAAAAAAAABAnq32LDe1AAAAAAAAAAAAAFnuaYGPZZ4OAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOImePHkyHjx4MPb390dVpXMAAAAAAAAAAAAANs5yuRzPnj0bjx49Sqcwxrh8+XI6AQDgT5mmaYwxxmd/+WzMZrNwDcDm+PXNPTg4GIeHh+EagM2xvb09xhjj0qVLfssDaLKzszPGGOPChQveXoBGZ8+eHWOMsbe35/0FaHTu3Lnf/np/AXq9fv16PH/+PJ0BAGwoW+0AAAAAAAAAAAAAWbba89zUAgAAAAAAAAAAAOS4pwU+pmm1Wq2O9cVpWncLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBaHHOW/YNstQMAAAAAAAAAAAAAwB/77vvv0gkAAAAAAAAAAAAAG+XevXvjp1s/pTOAE8BWOwAAAAAAAAAAAAAAAAAAAAAAAAAAAACwiY6z1T5v6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATrE3b96kEwAA/pTd3d0xTdN4+/btWC6X6RyAjbGzszOqyvsL0OzMmTNjNpuNd+/ejcVikc4B2Ai/vr3v378fR0dH6RyAjbG9vT3m8/k4PDwch4eH6RyAjbG1tTW2tra8vwAB3l0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAID/z7RarVbH+uI0rbsFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAtjjnL/kG22gEAAAAAAAAAAAAAAADg9Pnm22/G7u7u+OH7H8bjx4/TOQAb4+t/fj0uXrw4fvzXj+Phw4fpHICN8dU/vhpXrlwZN2/eHL/895d0DsBGuHHjxvj8r5+PW/++Ne7fv5/OAdgYX/79y3Ht2rVx+z+3x927d9M5ABvji799Ma5fvz7u3Lkzfr79czoHAIAPsNUOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGyi42y1V0MHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfBIqHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABdKh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXSodAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAF0qHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABdKh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXSodAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAF0qHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABdKh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXSodAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAF0qHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABdKh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXSodAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAF0qHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABdKh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXSodAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAF0qHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABdKh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXSodAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAF0qHQAAwP/Y+e8oqeuzf/y/dnYpC1KEgEiVJkYIGogEBJWigCVyYwkI5CYaRbFhRKNfu1iIUaNiuxPBhootESwUFTuRIIoFsIG9gIIgIAsu7P7++Bzz07g7M9tmFnw8ztlzsvN6vq/rubOvkHNyzg4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmZLIdgEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADIlES2CwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECmJLJdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADIlke0CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkCmJbBcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACATElkuwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABkSiLbBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBTEtkuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJmSyHYBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyJREtgsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABApiSyXQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyJZHtAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJApiWwXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgExJZLsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZEoi2wUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgUxLZLgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACZksh2AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMiURLYLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQKYksl0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMiWR7QIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQKYlsFwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBMSWS7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGRKItsFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIFMS2S4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmZLIdgEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADIlES2CwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECmJLJdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARUe0YAARkUSURBVAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADIlke0CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkCmJbBcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACATElkuwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABkSiLbBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBTEtkuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJmSyHYBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyJS8bBcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKgOBgwYEOedd94PXvvyyy/jt7/9bZYaAQAAAAAAAAAAAAAAAAAAAFAV8rJdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgOthpp52ib9++P3jtk08+yU4ZAAAAAAAAAAAAAAAAAAAAAKpMXrYLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABERDRt2jTp+datW2P16tUZakN11ahRo8jLy0ua+eKLLzLUBgAAAAAAAAAAAAAAAAAAANgWJbJdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABg6NChsXLlyqRf48ePz3ZNqoHjjjsu5V353e9+l+2aAAAAAAAAAAAAAAAAAAAAQDWWyHYBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOCnrUGDBnHTTTclzXz44YdxySWXZKgR1dnVV18db731VtLMddddFzvttFOGGgEAAAAAAAAAAAAAAAAAAADbmkS2CwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP21//etfo1mzZkkzp5xyShQUFGSoEdXZli1b4sQTT0ya2XHHHePmm2/OUCMAAAAAAAAAAAAAAAAAAABgW5PIdgEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4Kerf//+ccwxxyTNPPbYY/HII49kqBHbgqeffjruu+++pJmhQ4fGEUcckaFGAAAAAAAAAAAAAAAAAAAAwLYkke0CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBPU05OTlx33XVJM8XFxXH22WdnqBHbknPPPTe2bNmSNHP11VdHrVq1MtQIAAAAAAAAAAAAAAAAAAAA2FbkZbsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZEr//v0rdV5xcXF8++23sWnTpvjqq69i5cqVsXHjxkrdAbA9+9///d/o0qVL0sw//vGPWLx4cZX2qFmzZrRs2TI6depU4lmLFi3is88+i+Li4irt8X2dOnWKFi1apJXdunVrPPvss1XcqHxycnKiX79+aefnz5+f9v+WLl++PO666674/e9/X2qmdevWcfLJJ8fVV1+ddgcAAAAAAAAAAAAAAAAAAABg+5eX7QIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQKXPnzq3yHatXr44333wzXn/99Xj++efj6aefjpUrV1b5XoBtTa1ateKSSy5JmikuLo6LLrqo0vf27t07BgwYEH379o2OHTtGkyZNSs03bdo0PvnkkygsLIyPPvooFi9eHM8++2w899xzsWjRoigqKqrUft857bTT4oQTTkg7/+tf/zoWLFhQJV0q4tBDD43p06enne/cuXMsXbo07fyECRNi1KhRkZeXV2rmvPPOi1tvvTXWrFmT9lwAAAAAAAAAAAAAAAAAAABg+5bIdgEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADYnjRu3Dj69OkTJ554YkybNi0+//zzeOGFF+KEE06IOnXqZLseQLVxyimnRKtWrZJmHnzwwViyZEml7OvWrVvcdddd8fXXX8fcuXPjnHPOib333juaNGmS1vM1atSI9u3bx5AhQ+Kvf/1rLFy4MD7++OOYOHFidOzYsVI6VsS4ceOyXaFEVd3r/fffj6lTpybNNGzYMM4999wq7QEAAAAAAAAAAAAAAAAAAABsWxLZLgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADbs5ycnOjdu3fcfPPN8emnn8b5558f+fn52a4FkFU1a9aMM888M2XuqquuqvCunj17xrPPPhsvv/xyjBw5MmrVqlXhmd9p3rx5nH322fH222/HvffeG23btq202WV15JFHRrNmzbK2vyRdunSJfv36Vfmea665JmVm7Nix0ahRoyrvAgAAAAAAAAAAAAAAAAAAAGwbEtkuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD8VDRs2jAkTJsQ777wT+++/f7brAGTNqFGjomnTpkkzixYtigULFpR7R40aNWLixInxwgsvxL777lvuOenIycmJYcOGxVtvvRWXXnppJBKJKt1Xkho1asTYsWMzvjeZU089NSN73njjjZg3b17STJ06deL444/PSB8AAAAAAAAAAAAAAAAAAACg+sv8p0MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAT1zLli3j8ccfj4svvjjbVQCyYvz48SkzN9xwQ7nnt2rVKhYuXBhnn3125ObmlntOWdWsWTPOPffceOaZZ6J58+YZ2/udE044IWrWrJnxvSXZcccdY9SoURnbd9NNN6XMnHLKKVGjRo0MtAEAAAAAAAAAAAAAAAAAAACqu0S2CwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBPUU5OTlxwwQXx97//PdtVADJq0KBBsfvuuyfNfP311zFt2rRyzd9ll11i3rx50bVr13I9Xxn22WefmD9/fuyyyy4Z3du0adP47W9/m9GdpTn22GMjPz8/Y/sefPDB+PLLL5Nmdt555xg+fHiGGgEAAAAAAAAAAAAAAAAAAADVWV62CwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANu2Fi1axAknnFDqeUFBQVx++eUZbLRt8j4CAAAAAAAAAAAAAAAAAAD8dB133HHxxRdfxHnnnZftKgAZcfLJJ6fM3HvvvVFQUFDm2fXr14/Zs2dHq1atylOtUrVq1SqeeeaZ2HfffeOjjz7K2N7TTjst7rrrroztK0kikUjr91yZvv3227jnnnti3LhxSXMnn3xyTJ06NUOtAAAAAAAAAAAAAAAAAAAAgOoqL9sFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgqtStWze6dOkSnTt3jiZNmkT9+vWjXr16UVhYGGvXro1169bFBx98EK+++mp8+OGH2a67zWrRokWcd955pZ6vXbs2Lr/88gw22jZ5HwEAAAAAAAAAAAAAAAAAAKqPTZs2pZ2tUaNG5ObmVnjnOeecE88880w8+eSTFZ4FUJ01btw4Bg8enDJ3//33l2v+TTfdFJ06dSrzc1u2bImPPvooCgsLf/R8YWFhrFmzJpo2bVrmuW3atImHHnooevbsGYWFhWV+vjy6d+8ePXv2jPnz52dkX0mGDBkSrVu3zvjeBx54IMaNG5c006NHj+jQoUMsW7YsQ60AAAAAAAAAAAAAAAAAAACA6igv2wUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAytWvXLoYNGxaHHXZYdO/ePXJyctJ67quvvopHHnkk7rnnnnjyySejqKioiptSHe2yyy4xderUjOz66quvYsiQIRnZBQAAAAAAAAAAAAAAAAAAQPq2bNkS+fn5ZXqmVq1aUb9+/dhll12ic+fO0bNnzxgyZEg0a9Ys7Rk5OTlxyy23xK677hqFhYVlrQ2wzRg2bFjk5eUlzaxatSqeffbZMs/eZ599YuTIkWnn161bF7fffnvMmDEj5s2bF5s3b44RI0bE3Xff/YPcypUro1WrVvGzn/0s+vXrF0OHDo3DDz88atasmdaebt26xeWXXx5nnnlmmX6eihg3blzMnz8/Y/tK2p8N8+bNi88++yyaN2+eNDdixIiYMGFChloBAAAAAAAAAAAAAAAAAAAA1VHyT8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBtRKdOneKCCy6IYcOGRW5ubpmfb9SoUYwePTpGjx4d77zzTpx99tnx0EMPVUFTqrM6depEnz59MrJrxYoVGdkDAAAAAAAAAAAAAAAAAABA1du8eXN8+eWX8eWXX8ZLL70Ut99+e4wdOzYOOOCAuPTSS2OvvfZKa84uu+wSxx13XNx0001V3Bgge373u9+lzDz00EOxdevWMs++6KKL0soVFRXFtddeGxdeeGFs2LAh7fmrVq2KBx54IB544IFo1qxZTJgwIY499tjIyclJ+ez48eNj6tSp8frrr6e9ryKOOOKIGD9+fHz22WcZ2fd9Xbt2jf322y/je7/zz3/+M04++eSkmd/97ncxYcKEDDUCAAAAAAAAAAAAAAAAAAAAqqNEtgsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBF5OTkxJ/+9Kd4/fXXY8SIEZGbm1vhmbvuumv885//jDlz5kTjxo0roSUAAAAAAAAAAAAAAAAAAADwU1NcXByPP/549OjRI04//fQoKipK67mTTjqpipsBZE/btm2jZ8+eKXMPPvhgmWe3a9cu+vXrlzJXWFgYQ4cOjfHjx8eGDRvKvOc7K1asiDFjxsTgwYNj3bp1KfM5OTkxYcKEcu8rq7y8vBg7dmzG9n3fqaeempW933nggQdSZjp06BC/+tWvMtAGAAAAAAAAAAAAAAAAAAAAqK4S2S4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADlVadOnZg9e3ZcccUVUbNmzUqfP3DgwHjllVfiF7/4RaXPBgAAAAAAAAAAAAAAAAAAAH46rrnmmjj66KPTyu6+++4+6wDYbh188MEpM5s3b45nn322zLMPOuigyMnJSZk7+eST4+GHHy7z/NI8/vjjMWDAgNi4cWPKbPPmzSM/P7/Sdqdy/PHHV8ln8yTTqFGjGDlyZEZ3/rd//etf8c0336TMHXTQQRloAwAAAAAAAAAAAAAAAAAAAFRXiWwXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA8qhXr148/vjjMXDgwCrd07p163jiiSeibdu2VboHAAAAAAAAAAAAAAAAAAAA2L7deeed8eCDD6aV7d+/fxW3AciOwYMHp8y8+OKLsXnz5jLP7t27d8rMK6+8En//+9/LPDuVhQsXxrHHHlvq+VNPPRX7779/9OjRIwoKCip9f2maNGkSw4cPz9i+iIjjjjsuateundGd/23Lli3x/PPPp8wNGjQoA20AAAAAAAAAAAAAAAAAAACA6iqR7QIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAeU6dOjd69e2dk10477RRz5syJOnXqZGQfAAAAAAAAAAAAAAAAAAAAsH268sor08r16NGjipsAZF6NGjWib9++KXNz584t1/xOnTqlzNxxxx3lmp2OadOmxZw5c/7zfXFxccyYMSN+/etfx4ABA8r9c1XUuHHjMrYrkUjESSedlLF9yaTzfv/617+O+vXrZ6ANAAAAAAAAAAAAAAAAAAAAUB3lZbsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACU1ZlnnhlDhgwp83ObN2+OVatWRSKRiEaNGkWtWrXSfrZjx44xYcKEOOOMM8q8FwAAAAAAAAAAAAAAAAAAACAiYsGCBfHJJ59Ey5Ytk+Y6duxYJfsbNmwYPXv2jD333DPatm0bzZs3j7p160Z+fn4UFRXFxo0b4+uvv44PPvgg3n777Zg/f34sXrw4iouLq6TP9mR7e29r164dffv2jT333DM6d+4cjRo1ivr160deXl5s2rQp1q1bFx999FEsXrw45s2bF4sXL8525e3C9+9R7969t+k7VJI+ffpE3bp1U+aeeuqpcs1v3LhxysyiRYvKNTtdF198cey///5x7733xsSJE2PJkiVVui8d3bp1i7333jv+9a9/VfmuoUOHRqtWrap8TzrSuUe5ubnRv3//mD59etUXAgAAAAAAAAAAAAAAAAAAAKqdvGwXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAsmjZsmVcfPHFaWW3bt0a06ZNi4ceeiiefvrpWLNmzX/OcnJyokOHDnHggQfG2LFjY7fddks577TTTotbb701li5dWu7+bPvuvPPOeO211yo8Z+PGjZXQBgAAAAAAAAAAAAAAAAAAgG3NsmXLomXLlkkzTZo0qbR99erVi9GjR8fw4cNj7733jpycnDI9/8UXX8Q//vGP+Nvf/lbuv7c/5ZRTomvXrkkzGzdujHHjxpVrfjI77bRTXHrppUkz69ati/Hjx5d5dnV4b0tzzTXXxA477FDq+XnnnRcrV6780eu//OUv46yzzopDDjkk6tatm/a+Dz74IO6444644YYbYtWqVeXq/N8OOeSQGDJkSNLMggUL4pZbbqmUfY0aNYorrrgiZe6EE06IrVu3VsrOiIrdo6q8Q1Whf//+KTObN2+OBQsWlGt+nTp1Uma+/PLLcs1O14svvhht2rSJTz/9tEr3fN+nn34aLVq0SJoZN25c/Otf/6ryLqn+HS8oKIjatWuX+d/L8li0aFFs2LAh6b+FEf/vXk6fPr3K+wAAAAAAAAAAAAAAAAAAAADVT162CwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQFn8+c9/jvz8/JS55557Lo4//vh46623SjwvLi6Od999N95999244YYbYty4cfGXv/wl8vLySp2Zm5sbp512WowZM6bc/dn2zZgxI/75z39muwYAAAAAAAAAAAAAAAAAAADbqM8//zxlZocddqjwnrp168a5554bJ510UtSvX7/cc5o2bRpjx46NsWPHxuzZs+OPf/xjqZ/nUJpNmzbFsccemzJ39913x4IFC8pbtUTDhw9Pufvvf/97mWZWp/e2NKNGjYqf/exnpZ5feeWVsXLlyv9836RJk7jpppviiCOOKNe+XXbZJS688MIYP358XHrppXHVVVfF1q1byzXrO926dUv5u9thhx3illtuqdCe789K556edNJJFf7ZIirnHlXlHaoK3bp1S5lZunRpbNmypVzzi4qKUmZyc3PLNbssPv300yrf8X133313jB07NurVq1dq5rDDDosWLVpUabc99tgj9tlnn6SZqVOnxjHHHJP0c34qS3Fxcbz++uux9957J82lcy8BAAAAAAAAAAAAAAAAAACA7VMi2wUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBdLVq0iOHDh6fMPfjgg7H//vvHW2+9ldbcoqKiuOaaa2L06NEpsyNHjox69eqlNRcAAAAAAAAAAAAAAAAAAADgv23evDllJi8vr0I7Bg4cGO+88078f//f/xf169ev0KzvGzx4cLz++utxzjnnlOm5e++9NzZu3JgyN3LkyPJWq9DMKVOmpD2vur23laFv376xdOnSOOKIIyo8a4cddog///nP8cwzz8ROO+1UCe22T1Vxj7J5h9LVrVu3lJnXXnut3PPXrFmTMtOkSZNyz6+uvv7667jtttuSZvLy8uLEE0+s0h7jxo1LmZk0aVKVdvhv6dynPfbYI3JycjLQBgAAAAAAAAAAAAAAAAAAAKhuKvZJPwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkEHHHXdc5ObmJs28+uqrcdRRR8WWLVvKPP+ee+6Jgw8+OEaMGPGjs2XLlsU999wTd999d6xfv75Mc5s0aRIHHnhgdO/ePX7+859Ho0aNYocddohEIhHr16+Pr7/+OlavXh2vvPJKzJ8/P1588cXYtGlTmfuXpk2bNtGvX7/Ya6+9omPHjtGgQYOoX79+5OXlxTfffBPr16+P999/PxYvXhxPPfVULFy4sNJ2l6RGjRrRv3//OPTQQ6N9+/ax0047Rd26dWPNmjWxatWqWLx4ccyZMyeef/75KCwsrNIuPyX5+fmx//77R69evaJLly7RrFmzqFevXuTk5MSGDRti1apVsXTp0njppZdi9uzZsWbNmjLNr1OnTtLzb7/9Nq3/XiabU1BQEMXFxSln5OXlRc2aNUs937JlS3z77bcp5wAAAAAAAAAAAAAAAAAAAFSFnJyclJl0/ra6NOeff35cfPHFae0pjxo1asRll10WPXr0iGHDhsXmzZtTPrN+/fp44IEHYvTo0Ulzw4YNiz/+8Y9RVFRUKV07dOgQe+21V9LM0qVLY8GCBWnNq47vbUUddthhMW3atKR/p18effr0iRdeeCH69esXn3zySaXO3tZV5T3Kxh1KV7NmzaJZs2Ypc6+++mq5d6xatSo6deqUNNO9e/d45plnyr2jupo0aVKccsopSe/VmDFjYsKECVVyLxo3bhxHHXVU0sxTTz0VS5YsqfTdySxatChlZocddoiOHTvGO++8k4FGAAAAAAAAAAAAAAAAAAAAQHWSl+0CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQrqOOOirpeVFRUYwePTq2bNlS7h0XXnhhjBgxIiIiVqxYEffdd1/cddddsXDhwjLP2meffeLcc8+NAw44IBKJRMr8EUccERERa9eujVtvvTWuvfba+Pjjj8u89ztDhgyJP/7xj7HvvvtGTk5O0myfPn3+858//fTTmDRpUtx8882xfv36cu//bzk5OXH00UfHxIkTo2nTpqXmDjrooPjTn/4UH3/8cVx88cVx2223RVFRUaX1+Knp0qVLnHHGGTFs2LCoXbt20uygQYMiImLr1q0xa9asuOqqq+LZZ59NuaNGjRqxYsWKqFevXqmZ2267LY455pikc7p27RqvvfZaqee//e1v44EHHkjZ54Ybbojjjz++1POzzz47rrjiipRzAAAAAAAAAAAAAAAAAAAAqkKDBg1SZtatW1eu2ZMmTYpTTjmlXM+W1ZAhQ+LRRx+Ngw8+OL799tuU+cmTJ8fo0aOTZnbaaacYMGBAPPHEE5XS8bvPkEjVKx3V+b0trz59+sS0adOiZs2aVTK/Q4cOMWvWrOjVq1ds2LChSnZsazJ1jzJ1h8qiW7duaeWSffZEKitXrkyZOeqoo+Lqq68u947qavny5TFz5sw4+OCDS8387Gc/i6OOOipuv/32St8/ZsyYlJ9tcu2111b63lTSvU/dunWLd955p4rbAAAAAAAAAAAAAAAAAAAAANVNItsFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgHS1btoxdd901aWbOnDnx+uuvV2jPsmXL4uKLL44DDjggWrRoEaeddlosXLiwTDMaNWoU9957bzz33HMxaNCgSCQSZXq+YcOGcfrpp8eSJUtixIgRZXo2ImKnnXaKmTNnxvTp02O//faLnJycMj3fokWLuOKKK+LNN9+MwYMHl3l/SerWrRtPPPFETJkyJZo2bZrWM61atYrJkyfHrFmzol69epXS46ekXr16ceONN8Zrr70Wo0ePjtq1a6f9bG5ubhxyyCHxzDPPxPTp06NFixZJ84WFhTF79uykmb59+6bcO3DgwKTngwYNSjkjIqJ///5Jz2fMmJHWHAAAAAAAAAAAAAAAAAAAgKqw8847p8ysWbOmzHPPP//8OOWUU8pTqdz233//mDJlSlrZF154Id55552UuZEjR1a0VtqzCgsL46677ko5p7q/t+XRpEmT+Oc//xk1a9assh0REV26dIlJkyZV6Y5tRabvUVXfobJK9dkx30nn34nSzJs3L2Wme/fu5fpMl23BddddlzIzbty4St+bm5sbJ510UtLM+++/H48++mil704l3fvUsWPHKm4CAAAAAAAAAAAAAAAAAAAAVEeJbBcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIB09O/fP2VmypQplbLroosuiieffDKKiorK/Gzbtm1j4cKFMWzYsAr3qFevXtx9991x5plnpv1MmzZtYt68eXHggQdWeH+LFi1i5syZMXbs2ArNqVmzZjz11FMxYMCAcj0/cODAeP755yM/P79CPX5K2rVrF//+97/jxBNPjEQiUaFZQ4YMiUWLFkXv3r2T5mbMmJH0vG3bttG6deukmcGDByc9HzRoUNLziP93bzt27Fjq+fLly+Ott95KOQcAAAAAAAAAAAAAAAAAAKAq5OfnR5cuXVLmVq5cWaa5hxxySFx88cVl7vP+++/H/PnzY9asWfHEE0/EK6+8EqtWrSrTjFGjRsWxxx6bVjadz4Y47LDDonbt2mXqUJJu3brFrrvumjTzyCOPxJdffpk0s628t2V17bXXRpMmTapk9n87+uijY5999snIruqqPPeout+hsmrTpk3KzNatW2PFihXl3jF37ty0cpMnT07r82y2NU888US8+eabSTN77rln9OnTp1L3HnbYYdGiRYukmUmTJkVxcXGl7k3H2rVr45tvvkmZS/W5KAAAAAAAAAAAAAAAAAAAAMD2KZHtAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkI6uXbumzMydOzcDTUrXuHHjePbZZ6Nt27aVOvfPf/5zHHLIISlzubm5MWPGjGjfvn2l7c7JyYmbbropjjjiiHLPqFOnTvTo0aNCPfbYY4+48cYbKzTjp6JNmzbxwgsvxM9//vNKm9mkSZN48skno0+fPqVmZs6cGVu2bEk6p2/fvqWe5efnJ50fEdGyZcuUP1f//v2Tns+YMSPpOQAAAAAAAAAAAAAAAAAAQFX6zW9+E3Xr1k2ZW7hwYdozGzVqFJMnT46cnJy08osXL47f//730axZs2jXrl306tUrDjrooBg4cGB07949mjRpEp07d44LLrggvvrqq7Rm/vWvf43mzZunzN15550p/za9Xr16cfDBB6e1N5mRI0emzEyZMiXp+bb03pbVr371q1LPCgoK4r777otjjjkmevToEe3bt48OHTpEz54948gjj4z/+7//ixUrVpRp36WXXlrRytus8t6j6n6Hyqp169YpM5999lkUFRWVe8drr70WH3/8ccpcfn5+PP7443HllVdGo0aNyr2vOpo0aVLKzLhx4yp1Z6p5GzZsiFtvvbVSd5bFJ598kjKTzv0EAAAAAAAAAAAAAAAAAAAAtj+JbBcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIB0dOzYMen5e++9F2vXrs1MmVLccccd0apVq0qfm0gkYtKkSZGbm5s0d+qpp8Yee+xR6fsjIqZMmRI777xzlcxO19FHHx19+vTJaofqLj8/P2bNmlUlv6vatWvHI488Em3atCnxfM2aNfHCCy8kndG/f/9Sz/bbb7+oVatWyh6DBg1Kej5gwICk59OnT0+5AwAAAAAAAAAAAAAAAAAAoCrk5+fHZZddllb2xRdfTHvuhRdeGDvttFPK3ObNm2PMmDHRtWvXuOOOO2LlypWlZpcuXRqXXHJJtGnTJu65556Us+vVqxcXXXRRytyKFSti1qxZKXOjRo1KmUkmJycnhg8fnjTz2WefxezZs5NmtqX3tjJs3bo1rrnmmmjdunUMHz48brvttnjppZfivffei+XLl8e///3vePDBB2Ps2LHRrl27uOCCC2Lr1q1pzd53332jc+fOVfwTVE/lvUelqc53KJnWrVunzHzyyScV3nPFFVeklcvNzY0zzjgjPv7443jggQdi9OjR8Ytf/CJq1KhR4Q7ZdOedd6b8HJ6hQ4dGy5YtK2XfL3/5y+jdu3fSzB133BHr1q2rlH3lkc69Sud+AgAAAAAAAAAAAAAAAAAAANufRLYLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAOtq1a5f0fMmSJRlqUrJ+/frFwQcfnDK3du3amD9/fkyfPj0efPDBeP7556OgoCDlc23bto0RI0YkzRx77LEp5xQVFcXy5cvjpZdeipdeeinee++92LRpU8rn6tevH+eff37KXFUbP358titUaxMnToyf//znVTa/YcOGcdttt5V6PmPGjKTP9+vXr9SzwYMHp9Vh0KBBSc/79+9f6tnq1atj3rx5ae0BAAAAAAAAAAAAAAAAAACoTDVq1Ihbb701OnTokDK7YcOGePbZZ9Oa27JlyzjhhBPSmtm3b9+45ZZbori4OK3Z3z03cuTIuPLKK1Nmjz766GjevHnK3OTJk1NmDjrooGjQoEFaHUvSt2/flF3uuOOOKCoqKvV8W3xvK2Lt2rXRv3//OP3002PVqlUp8wUFBXHJJZfEkUceGYWFhWntGDVqVEVrbnOq8h5VtzuUSsuWLVNmPv300wrvmTx5cnz++edp5+vUqRNHHHFE3H777fH666/Hpk2b4uabb/5RLi8vL2rXrl3hflVt48aNceuttybN5Obmxoknnlgp+0499dSk58XFxXH99ddXyq7y+uSTT1JmWrRokYEmAAAAAAAAAAAAAAAAAAAAQHWTyHYBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABIR4MGDZKef/XVVxlqUrJ///vfcfbZZ8eaNWtKPH/33XfjsMMOi6ZNm0avXr1i6NChceSRR8a+++4bzZo1ixtuuCHljmHDhpV61qZNm9h9992TPn/ZZZdF48aNo0OHDtGjR4/o0aNHtG/fPurVqxcHHnhgPPPMMyU+t2bNmvjLX/4Sl19+ecqO6ZgzZ04MHz48unbtGu3bt49evXrFueeeG6tXr0757KGHHhoNGzaslB7l1bRp02jdunW5vmrXrl1lvdq3bx8nn3xyytx3v8/9998/dtttt+jQoUP06dMnzjnnnPjwww9TPt+vX7849NBDSzybMWNG0mdbt25d6tmgQYNS7o6I2G+//aJWrVolnrVv3z5atWpV6rOPPfZYFBUVpbUHAAAAAAAAAAAAAAAAAACgsrRr1y6efPLJGD58eFr5e+65JzZs2JBWdsyYMVGzZs2Uud///vcxf/78tGaW5Kyzzoq5c+cmzeTl5cWxxx6bctZjjz0WK1asSJqpWbNmHH744WXq+H0jR45MmZkyZUrS823xvS2vgoKC2H///eO5554r87MPPfRQXHrppWllBw8eXOb527pM3KPqcIfSscMOO6TMrFu3rsJ7Nm/eHKNHjy73Z0wkEomoX7/+j15v1qxZbNy4MT744IOYPXt2XH311TFq1Kjo0qVL5ObmVrR2pbr++utT/vxjxoyp8Geh/OxnP4ujjjoqaebxxx+Pt99+u0J7Kmr9+vUpM+ncTwAAAAAAAAAAAAAAAAAAAGD7k8h2AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASEfdunWTnq9bty5DTUq2cePGuOKKK6Jt27Zx2WWXxTfffPOfs9dffz169OgRDz30UBQWFv7o2XXr1sUpp5wS06ZNS7qjT58+kZOTU+JZq1atkj47c+bMOO+882Lt2rU/OtuyZUvMnj07+vfvH5MmTfrP6++8806ceOKJ0bJlyzjrrLPik08+SbojlY0bN8bw4cNj8ODBcd9998Ubb7wR7733XsyfPz8uv/zy6NKlSyxbtizpjEQiEb169apQj4q6+eab48MPPyzXV5cuXaqs11lnnRW5ublJM7NmzYp27drFWWedFXPnzo233347li9fHvPmzYuJEydGx44d48Ybb0y565xzzinx9ffffz+WLFlS5u4tW7aM3XbbLa1sfn5+7LPPPiWe9e/fP+mzM2bMKHM3AAAAAAAAAAAAAAAAAACA8sjJyYk+ffrE5MmT4+2334599903ree2bt0a119/fdp7jjnmmJSZe++9N/7xj3+kPbMkxcXFceqpp6bMHXXUUSkzW7dujTvvvDNlbuTIkWl1+281a9aMww8/PGnmueeei+XLlyfNbIvvbXmdfPLJ8fLLL5f7+YkTJ8aHH36YMte1a9eoU6dOufdsizJxj6rDHUpHOr/7goKCStn1xBNPxPnnn18ps74vJycn2rRpE4MGDYrTTz89pk6dGm+88UZs2LAhZsyYEcOHD68Wd/yDDz6IRx55JGmmcePGFb4TY8aMiVq1aiXNXHvttRXaURnSuVc5OTkpfxYAAAAAAAAAAAAAAAAAAABg+5PIdgEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEhHfn5+0vONGzdmqElyX3/9dZx33nnRtm3buO6662L9+vVx5JFHxtq1a1M+e9lllyU9b9CgQXTs2LHEsyZNmiR9dvny5Sn3FxcXx/jx42Py5MlxyCGHRKdOneLmm2+utPf2hBNOiPvuu6/U8xUrVsSxxx6bcs7ee+9dKX2yIZ3fQ3nk5ubGEUcckTQzf/78OPTQQ5PexcLCwjj55JPjzjvvTDrr17/+dbRt27bEs4cffjhl3/82aNCgMuUHDx5c4usDBgwo9ZnNmzfHnDlzyrQHAAAAAAAAAAAAAAAAAAD4aUokEnHQQQel/TVkyJAYNWpUjB07Nq688sqYOXNmrFy5Mp5//vn4wx/+EHl5eWnvvv7662Px4sVpZbt37x4tWrRImikqKoqLLroo7f3JLF26NB5//PGkmd12263Uv0f/vsmTJ6fM9O3bN5o3b552v+8cdNBB0bBhwwrt35bf27KaN29e3HrrrRWaUVhYmNaMRCIRXbp0qdCubUkm71E271A6atasGYlEImWuoKCg0nZefvnlceGFF1bavGRq164dhx56aEybNi2+/PLLuPbaa2PHHXfMyO7SXHfddSkzp512Wrnn5+bmxkknnZQ0884778Ts2bPLvaOypPv5OXXq1KniJgAAAAAAAAAAAAAAAAAAAEB1k/oTMQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoBrIyclJel5cXJyhJun58ssv47TTTovmzZvHO++8k9YzS5YsidWrVyfNNG7cuMTXCwoKkj7Xv3//qFGjRsoOW7ZsieOOOy4ee+yxlNmyeOqpp2Lq1Kkpc88++2y8+eabSTPNmjWrrFoZ9fXXX8eaNWuqZHbv3r1jxx13TJo58cQTY8uWLWnNGzduXGzcuDFp5je/+U2Jr0+fPj2tHd83ePDgMuUHDhxY4uv9+vUr9ZmnnnoqvvnmmzLtAQAAAAAAAAAAAAAAAAAAfpoSiUQ89thjaX9Nnz49pk6dGjfddFOcccYZceCBB0aTJk3KvPe9996L8847L+18On+r/cwzz8Tbb79d5i6lefTRR1NmevfunTLz7rvvxgsvvJA0k0gkYtiwYWl3+87IkSOTnq9bty4efPDBpJlt+b0tq4kTJ1bKnPvvvz+tXJs2bSpl37Yg0/coW3coHXXq1Ekrl+rzLspqwoQJMWzYsIx+5kSdOnVi3Lhx8d5778Vpp52Wsb3/7emnn47FixcnzXTt2jX22Wefcs0//PDDo3nz5kkzkyZNKtfsypbu7z/dewoAAAAAAAAAAAAAAAAAAABsPxLZLgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJUhJycn2xVKtGHDhjLlP//886TnjRo1KvH1L774IulznTt3jldeeSVOPPHE2HPPPWOHHXYoU6+KmjJlStrZ559/Pun5jjvuWNE6WbF8+fIqm929e/ek56+++mosWrQo7Xlr166Nhx56qFw7FyxYECtWrCj1uXbt2v3g+0QiEQMGDCgxe//995f4+i9+8YvYeeedf/Ba586do2nTpqXunTFjRqlnAAAAAAAAAAAAAAAAAAAA2bZq1aoYNGhQfPPNN2k/06NHj5SZyv5b63nz5qXM/OpXv0pr1uTJk1NmRo4cmdas79SrVy8OOeSQpJl77703CgoKkma29fc2XatXr46ZM2dWyqy33nor1q9fnzLXvHnzStm3Lcj0PcrGHUpXzZo108p9++23lb77/vvvjw4dOsQtt9wSW7durfT5pWnYsGFcc801cd9990WtWrUytvf7Jk2alDIzbty4cs1O9dy6devijjvuKNfsypbuvcrW7wkAAAAAAAAAAAAAAAAAAADInkS2CwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQDoKCwuTnteqVStDTSpHo0aNonv37nHkkUfGn/70p/i///u/mDNnTrRr1y7pc3Xr1i3x9TfeeCO++eabpM926dIlbrzxxli0aFGsX78+Vq5cGfPmzYs77rgjzj///Bg+fHh06tQpcnJyyv1zlea5555LO/v+++8nPa9fv35F62TF8uXLq2x2ly5dkp7PmzevzDNTPbP77ruXevbII4+Ueta3b98ffL/XXnvFjjvu+KPca6+9Fn/7299KnTNw4MAffN+/f/9Ss8XFxUk7AQAAAAAAAAAAAAAAAAAAZNMXX3wRgwcPjmXLlpXpuT333DNlZu7cueVsVbIPPvggZaZDhw5pzXrggQdi/fr1STPdu3ePXXfdNa15ERFDhw6N2rVrJ81MmTIl5Zxt/b1N19y5c6O4uLjS5i1ZsiRlZocddqi0fdVdpu9RNu5QZavM+/h9K1asiDFjxkTnzp3jyiuvjI8++qhK9pTkt7/9bTz99NNZuft33XVXfPXVV0kz//M//xOtWrUq09zu3bvH3nvvnTRz6623xoYNG8o0t6pU1b0CAAAAAAAAAAAAAAAAAAAAtn2JbBcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIB0bNq0Kel5vXr1MtSkbNq3bx8jRoyIK6+8MqZPnx6vvfZarFu3LlavXh0LFy6M+++/P6644oo4/vjjY+DAgVGnTp1y7SksLIxHH320TM80bdo09t577/jf//3fmDBhQkybNi3eeuutWLNmTdx+++3Ru3fvcnX5b8XFxbFixYq08xs2bEh6npOTU9FKWbF8+fIqm920adOk58uWLSvzzFTPJNs5Y8aMUs/69ev3g+8HDRpUYm7mzJnx/PPPl3ofBg8e/IPvBwwYUOrOl19+OT777LNSzwEAAAAAAAAAAAAAAAAAALLl5Zdfju7du8fLL79cpudyc3OjZcuWSTNFRUXx7rvvVqTej6xduzaKi4uTZlq1apXWrI0bN8a9996bMjdy5Mi05kVEjBo1Kun50qVLY8GCBUkz28N7m65XX321Uud99dVXKTPl/WyNbU027lE27tC25u23344//elP0aZNm+jVq1ecffbZcf/998eyZctSvncV0atXr7jllluqbH5pCgoKYvLkyUkzubm5cdJJJ5Vp7qmnnpr0vKioKK6//voyzQQAAAAAAAAAAAAAAAAAAADIhrxsFwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgHSsWbMmmjRpUup5gwYNMtgmuVq1asUJJ5wQf/jDH+IXv/hFxvZefPHFcfjhh0deXl6F5jRo0CBGjx4do0ePjocffjjGjBkTK1euLPe89evXx5YtW9LOFxUVlXtXdbZs2bIqm12vXr2k519//XWZZ65duzbpef369Us9e/LJJ2Pjxo1Rp06dH53169fvB98PHjy4xBmPPfZYFBYWxty5c2PIkCE/Oj/ggAMiJycniouLIycnJ/bbb79S+0yfPr3UMwAAAAAAAAAAAAAAAAAAgGxYv359XHbZZXHNNdfEt99+W+bnmzdvHolEImnm888/j5YtW5a3Yqk2bdoU+fn5pZ43atQo7VmTJ0+O4447LmlmxIgRceGFF6ac1bRp0+jfv3/KfalsL+9tOpYvX16p89L5fINU7+32Ilv3KNN3aFs2f/78mD9//n++r1u3buy6666x2267xdChQ+PII4+s1H3Dhw+PZ555Jv72t79V6txUbrjhhhg/fnzk5uaWmjnuuOPioosuik2bNqWc17Rp0xg+fHjSzMyZM+O9994rc1cAAAAAAAAAAAAAAAAAAACATMvLdgEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEjHZ599Frvuumup523bts1gm9L17ds3pk6dGi1btsz47jfffDPGjh0bt9xyS6XNPPTQQ2PPPfeMgQMHxttvv12uGUVFRZXWpzoYM2ZMPPbYY2V+bvXq1VXQ5v+pVatW0vPNmzeXeWaqZ2rXrp302ccffzz+53/+50dnLVq0iPbt28fy5cujQYMG0aNHjx9l1qxZEy+++GJERDz22GMxZMiQH2UaN24c3bp1i5dffjm6desWDRs2LLXPww8/nPRnAQAAAAAAAAAAAAAAAAAAyJRVq1bF7bffHldddVWsXLmy3HMaNWqUMtOiRYtYvnx5uXeUV35+ftrZBQsWxJIlS6Jz586lZjp06BC/+tWvYuHChUlnDRs2LHJzc0s9LywsjKlTp6bstL28t+lYu3Ztpc4rz+cbbK+q6z2q7DuUruLi4rRyiUSiipuU7ptvvolFixbFokWLIicnJ4488sgfnK9evTpOOeWU6NChQ+y5557Rs2fPaN68eZl2XHHFFXHPPffE+vXrK7N6Uh9//HHMmDEjDjvssFIzjRo1ipEjR8aUKVNSzhszZkzUrFkzaebaa68ta80qle692t4+JwcAAAAAAAAAAAAAAAAAAABILXufdgEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGXwwQcfJD3v0qVL5ObmZqZMKY466qh44oknomXLllnrMHny5Pjd734XBQUFlTazdevW8eijj0b9+vUrbea2bPXq1fHZZ5+V+Wvz5s3Zrp5RM2bMKPWsX79+ERExYMCAEv97O2fOnCgqKoqIiFmzZpU6Z9CgQRER0b9//1IzH374YbzxxhtpdQYAAAAAAAAAAAAAAAAAAKhKN954Y7Ro0SLOPPPMWLlyZYVm1a5du5JaVb5atWqVKT958uSUmZEjR6bMjBo1Kun5I488EqtWrUo5Z3t6b1PZuHFjpc7j/6+63qPKvkPpSveu1axZs4qblF9BQUFMmzYtLrnkkjj88MOjRYsW0bt377jvvvuiuLg4rRkNGjSIE044oYqb/ti1116bMnPaaaelzOTl5cWJJ56YNLN06dKYO3dums0yI9175d9EAAAAAAAAAAAAAAAAAAAA+OlJZLsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACk47XXXkt6XqtWrdhjjz0y1ObHfvnLX8Ztt90WeXl55Xp+xYoVMW/evFi7dm2Fu9x1112x++67x5133hmFhYUVnhcR0aFDh5gwYUKlzKLybdq0Kel57dq1yzwz1TMFBQVJzx999NEoKioq8axfv34RETF48OASzx977LH//OdPPvkkFi9eXGLuu+cHDBhQao8ZM2Yk7QkAAAAAAAAAAAAAAAAAAFCSZcuWpf310UcfpTVz0KBBUVxcXCn9atWqVSlzqoOpU6fGt99+mzQzfPjwSCQSpZ63b98+evTokXTG5MmT0+qzPb23qZT2uQBU3E/pHqUj1edUfGdbe9/+9a9/xfDhw2OfffaJL774Iq1nTj/99MjJyaniZj/0/PPPp/z8ni5dusR+++2XNHPEEUfEzjvvnDRz3XXXlblfVUv3Xm3cuLGKmwAAAAAAAAAAAAAAAAAAAADVTemfagMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANXISy+9lDIzatSoStnVqVOnaNKkSZmeueqqq6JWrVpJM8XFxfH666/HrbfeGmeccUYMHTo0unbtGnXr1o2dd945+vTpE8uWLatI9f/44IMPYvTo0dG0adM4+uij47bbbos33ngjNm/eXO6ZY8aMiYYNG1ZKPyrX+vXrk543aNCgzDNT/a7XrVuX9HzVqlXx4osvlnjWr1+/iIgYOHDgj86Ki4tj9uzZP3ht1qxZJc7p1atXNGrUKPr06VNqjxkzZiTtCQAAAAAAAAAAAAAAAAAA8N+2bNkSHTt2TPurbdu2sXTp0pRzO3ToECeffHIGfoJty+rVq+Phhx9OmmnWrNl//la9JEcddVTS5z/77LOYM2dOufoBFVdUVBTffvttylx+fn4G2lS+efPmRa9eveKrr75KmW3WrFl07do1A61+6LrrrkuZGTduXIXO16xZE1OnTi1Tr0yoU6dOWrmCgoIqbgIAAAAAAAAAAAAAAAAAAABUN4lsFwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgHT8+9//jg0bNiTNjBo1KmrXrl3hXddff318+umn8eCDD8agQYMiJycnab5Tp07Rv3//Us+Li4vjL3/5S7Ro0SL22GOP+MMf/hBXX311TJ8+Pd54443YuHHjf7KV0f/71q5dG7fffnscc8wx0bVr18jPz4+WLVvGfvvtF0cffXRceumlMW3atHj33XdTzsrPz48BAwZUaj8qx4oVK5Ke77rrrmWemeqZVDsjIqZPn17i6zvvvHP85je/iTZt2vzo7KWXXopVq1b94LWZM2eWOCcvLy/OOeecqFu3bonnX3/9dTz33HMpewLlc95558XEiRNj4sSJ0bFjx2zXAQAAALYz/r8HAAAAAAAAAAAAYFtSVFQUZ5xxRlrZCy64IBo1alTFjbY9kydPTpkZOXJkuc4iIm6//fYoKioqcy+g8nz/M1ZKsy3/+/jee+/Fcccdl1a2b9++VVumBPfcc8+PPtPjvw0ZMqTEzwOJiNhrr72iZ8+eSZ+fPHlyFBQUlLtjVUnnXhUWFsbWrVsz0AYAAAAAAAAAAAAAAAAAAACoThLZLgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOnYsmVLzJo1K2mmSZMmcdlll1VoT8+ePWP//fePGjVqxOGHHx6zZ8+ODz74IC644IJo1apVic8ccMABSWf+9a9/jbPOOis+//zzlPt33nnncvVOV3FxcXz66afx3HPPxe233x7nn39+jBgxInbdddfYe++9U3bca6+9qrQf5fPGG28kPd9nn33KPDPVM0uWLEk54+GHHy717PLLLy/x9UcfffRHr73wwguxfv36EvMnnXRSqTtmzpwZW7ZsSdES/n/s3Xd4VVXWOOCVUAOhKUhTUYGxoSKi2MAGKtgLWD/B3mYGEVAZ24hjR9RxUEdRsYJlUFFEGaRYEEQFVMCOIAoISCcQSn5/fD/zGQOpN7lJeN/n4Xk8+6y99rr3HDfnrMlEiqpnz55x3XXXxXXXXRc777xzsssBAAAAKhi9BwAAAAAAAAAAAKC8GTVqVIwZMybfuLp168Ytt9xS7PU2btxY7BxlyejRo+PHH3/MM+a0006LatWq5Rrfd999Y7fddstz7hNPPFHgWirad0vBpaSkJCyX+yi3xYsX5xuz7bbblkIlJWf48OExderUfOMOPfTQUqgmp3Xr1sWjjz6aZ0xqauoWf5fHX//61zznbty4MQYNGlTk+kpSQe6rJUuWlEIlAAAAAAAAAAAAAAAAAAAAQFlTOdkFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQT311FPRtWvXPGOuuuqqeO+99+LVV18tdP66devGE088ESkpKTnGd9xxx7jlllvi5ptvjtGjR8cVV1wRs2fPzj6/66675pm3oLXsuuuuse222xa67i2pWbNmZGVlxZo1awoU/+GHH8b1118fTzzxxBZjGjRokKjySKApU6bkeX7PPfeMAw88MCZNmlSgfA0aNIiTTjopz5iPPvoo3zxff/11fPXVV5v9d6RVq1abnfPmm2/mGtuwYUOMGTMmTjnllFznqlevvsX1X3vttXxrBAAAAAAAAAAAAAAAAAAASJTevXvH1KlTIzU1Nc+4yy67LAYNGhRffvllkddau3ZtvjEzZsyIv/71r0Veo6g2btxY6DlZWVkxZMiQuPHGG7cYU7t27TjuuONi+PDhOcbPOeecPHO/++678d133xW4lor23VJw1apVS1iusnofJfMemjt3brRo0SLPmO22266Uqik5L7zwQuy77755xjRq1KiUqsnpoYceimuuuSYqV668xZiLLroobr755sjIyMgea9iwYXTr1i3P3CNGjIg5c+YkrNZEKsjvzJk7d24pVAIAAAAAAAAAAAAAAAAAAACUNVv+LQwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFDGvPnmm/HVV1/FrrvuusWY1NTUePnll6Nnz57x0EMPRVZWVoFy77zzzvHyyy/H7rvvnmfudu3axcKFC3OMb7vttgX7APno2bNnQvLUqFEjrrzyyrjmmmti+PDhcemllxZ47pdffpnn+erVqxe3PErA5MmT45dffonttttuizGPPPJItGvXLtatW5dvvkceeSSqVau2xfNZWVnx+uuvF6i2ESNGRN++fQsU+8svv8Qnn3yy2XMjR46MU045pUB5IiLWr18fo0aNKnA8AAAAAAAAAAAAAAAAAABAcX322Wfx1FNPxfnnn59nXOXKlePee++N4447rshrrVmzJt+YKlWqxNixY4u8Rml74okn4oYbboiUlJQtxpxzzjkxfPjw7OOUlJQ488wz88w7ePDgQtVREb/biqxSpUoJy1WrVq2E5XIf5TZ37tx8Y3bcccdSqKRkTZo0Kd+YRP2+msL66aefYvjw4dGtW7ctxtSrVy/OPffceOyxx7LHLr300qhatWqeue+///5ElZlwzZo1yzemIPcnAAAAAAAAAAAAAAAAAAAAUPGkJrsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoqKysrOjfv3++cZUqVYp//etfMW3atDjzzDOjXr16W4zdc889Y+DAgTFjxoxo06ZNvrn//e9/x5o1a3KM/fH4j0455ZR883bp0iUuvfTSfOPykpaWFldffXX88MMPcffdd0f9+vXjkksuid69exc4x8EHH5zn+UWLFhWrRkpGVlZWPP/883nG7LPPPvHf//43GjVqtMWYmjVrxjPPPBOnnnpqnrnGjx8fP//8c4Fqe+211woUFxExatSoIp3bnAkTJsSKFSsKNQcAAAAAAAAAAAAAAAAAAKC4rr/++nx/D0HE//6egU6dOhV5nQULFuQb07hx4yLnT4Yffvghxo0bl2fMcccdF7Vr184+7tChQzRt2nSL8StWrIiXX365UHVUxO+2IktPT09Yru233z5hudxHuc2dOzffmPr160fNmjVLoZqSs3Dhwnxj6tevXwqVbN4DDzyQb0zPnj2z/7lKlSpx+eWX5xn/2Wefxbvvvlvs2kpCpUqVCvTvdkHuTwAAAAAAAAAAAAAAAAAAAKDiSU12AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUBjPP/98jB8/vkCxe++9dwwdOjQWL14cn3/+eYwZMyaGDRsWL730Urzzzjsxf/78+OKLL6JXr16RlpaWb7558+bFHXfckWv8l19+yXPeVVddFddee+1m16hRo0b069cvXn311UhNTS3Q5/qjqlWrxlVXXRWzZ8+Oe++9Nxo0aJDj/IABA2L06NFx3HHHRXp6+mZz7LDDDnHDDTfE7bffnuda8+bNK1KNlLx77rknMjMz84xp3759fPfdd/Hwww/HySefHPvtt1+0bt06jj322Ljjjjvi+++/j3PPPTfftfK7T35v4sSJsXjx4gLFvvHGG1s89/PPP8dnn31W4HVfffXVAscCAAAAAAAAAAAAAAAAAAAkyvz582PAgAEFir3vvvuK/LsGli5dGhkZGXnG1KpVK7bbbrsi5U+WwYMH53m+WrVqcdppp2Uf5/f/kR82bFi+39MfVdTvtjzK7/coRETUrl07YevttttuCcvlPsrthx9+KFDczjvvnNB127VrFx07dkxozrwUZM+pUqVKKVSyeRMnToxPPvkkz5g999wzjjjiiIiI6Nq1azRq1CjP+Pvvvz9R5SXcDjvsEJUqVco3bs6cOaVQDQAAAAAAAAAAAAAAAAAAAFDWVE52AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUFjnn39+fPLJJ7HNNtsUKD41NTVatWoVrVq1Kta6l1xySaxYsSLX+Icffpjv+nfeeWf07ds3Pv300/jxxx+jcuXKsf3228eBBx4YNWrUKFZdVapUieuvvz7q16+/xZhOnTpFp06dIiLil19+iWXLlsX69eujWrVqUb9+/ahbt26B1hozZkyxaqXk/Pzzz3HnnXfGTTfdlGdcjRo14rLLLovLLrusSOuMGDGiUPdBVlZWvPHGG9GjR4884zZs2BD//e9/84wZNWpU7L333gVa9/XXXy9oiUABpKenR4cOHaJ169ax6667xnbbbZfj747rr78+unTpEt99911MmjQpPv3009i4cWOJ1FK7du0CxWVmZsbatWuLvV5qamqkp6cXO8+WbO7ZojS0adMm9t9//9hjjz1i++23j/T09EhLS4uNGzfGqlWrYv78+fHVV1/FBx98EFOmTCmx6/l7e+21V7Rv3z723HPP2GGHHSI9PT2qVKkSGRkZsXLlyvjhhx/i888/j3HjxsWcOXOKtVZFva5A4ZXm3vObXXbZJU488cRo27ZtNGzYMCpVqhSLFi2KWbNmxeuvvx6ffPJJQtb5verVq0fVqlVzjGVkZMT69esTvhawdfnj8/natWsjMzOz3Ndir4bStzX3HiIq9nvq1tyDKMnrqvcA5cvW0n/449+hnmeBRCkr/Qe9BwAAAAAAAKCw7rrrrrjkkkuiUaNGecbtueeecdFFF8Wjjz5apHVmzZoVbdq0yTPm0EMPjeHDhxcpfzIMHz48li5dGvXq1dtizDnnnBNPPvlkVKlSJU4//fQ88z3++ONFqqMifrflUUF+ZneXXXZJ2HpHHHFEwnJFuI/+6LPPPitQ3O677x5ffPFFsdfbb7/9on///tGlS5f47LPPYp999il2zoKoU6dOvjGJ+nn0onrggQfi6aefzjOmZ8+eMW7cuOjZs2eecYsXL47nn38+keUl1B577FGguILenwAAAAAAAAAAAAAAAAAAAEDFUjnZBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQGH98MMP0a1btxg5cmRUq1atVNa85pprYtSoUZs9N3bs2Fi9enXUrFkzzxzbbrttdOrUKeG1rV69Om677ba47777ChS/3XbbxXbbbVfodb788suYNm1aoedRem699dY47rjjYr/99iuR/AsWLIhLLrmk0PNee+216NGjR54xEydOjOXLl+cZM3LkyLj22mvzXW/69Okxd+7cwpQIbMEJJ5wQl19+eXTs2DGqVKmyxbgOHTpEhw4dso+XL18eL7zwQjz88MMJ/btjp512itmzZxcodvDgwXHxxRcXe83DDjssxo4dW+w8W5KSklJiuf9o5513jp49e8ZZZ51VqGeBRYsWxVNPPRUDBgyIhQsXJrSmtLS0uOKKK+Kyyy6LFi1aFHjep59+Gvfcc0+8+OKLsWnTpkKvW5GuK1B4ydp7GjRoEPfcc0/8z//8T6Smpm425uabb45x48bFX/7yl5gxY0ah19icbbfdNqZNmxbbb7999tj8+fNjn332iUWLFiVkDWDr9Le//S1uu+22HGPXX3993H777eW2Fns1lD69h/9V0d5T9SD+V0leV70HKPu2xv7D4sWLs489zwKJUlb6D3oPAAAAAAAAQFGsWbMmbrjhhhg8eHC+sf/4xz9i6NChsXLlykKvM23atGjTpk2eMYcffngMHz680LmTZd26dfH888/HlVdeucWYI444Iho1ahQHHHBA1K1bd4txM2fOjI8++qhIdVTE77Y8Ksj/tt24ceOoX79+jp9jKoo6derEYYcdVqwcf+Q+yunzzz+P9evX5/nz4xERe+21V7z00ktFXmefffaJ/v37x4knnpg9tvfee0fnzp23+PtjEqlJkyb5xqxYsaLE68jLCy+8EAMGDMjzZ75POOGEOPPMM+OAAw7IM9ejjz4a69atS3SJCdOqVasCxfm9OgAAAAAAAAAAAAAAAAAAALB12vx/RQQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMq4d955J0455ZTIyMgo8bVuueWWuOeee7Z4fvXq1XHfffclZK0lS5bEV199Veh5999/f4wePTohNWzJ5ZdfXqL5Kb4NGzZEly5dYvbs2QnPvWrVqujSpUssXLiw0HNHjx4da9euzTNm5MiR+eaZOHFiLF++PN+41157rcC1AZu33377xccffxwjRoyIzp07R5UqVQo1v06dOnHJJZfEp59+Gs8//3w0bNgwIXW1bNkyIXkKIz09vdTXTLS0tLQYMGBAfPPNN9GzZ8/YbrvtCjW/QYMG0adPn/j++++jV69eCaurc+fO8e2338aAAQOiRYsWhZrbpk2bGDp0aHzwwQex8847F3rtinBdgaJJ1t7TokWLmDRpUnTv3j1SU1PzjD3iiCPiww8/jKOOOqpQa2zJM888E9tvv3328caNG+Oss86KRYsWJSQ/sHXq0KFD9O/fP9llRETiarFXQ+nSe8iporyn6kHkVFGuK1B4W2v/4TeeZ4FEKSv9B70HAAAAAAAAoDiefPLJ+Pzzz/ONa9CgQdxwww1FWuO9997LN+ass86KatWqFSl/sgwePDjP86mpqXHGGWfEOeecU6w8eamo3215M2/evALFHXnkkcVe66KLLorq1asXO8/vuY9yyszMjJkzZ+Ybt/feexcp/5577hkvv/xyTJ06NU488cRc5x988MFS+a47duyYb8wPP/xQ4nXkJTMzM/7973/nGZOamhpDhgzJM2bDhg3x0EMPJbCyxCvI/TR79uxYtmxZyRcDAAAAAAAAAAAAAAAAAAAAlDl5/5dEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgDBs1alQceOCB8e2335ZI/uXLl8cpp5wSf//73/ONveOOO+KTTz4p1npr1qyJU089NebPn1+k+aeddlqMHTu2WDVsSd++fWP8+PElkpvE+uWXX+KQQw4p9v34e/PmzYv27dvH1KlTizR/zZo18c477+QZM3LkyHzzbNy4Mf773//mG/faa68VuDYgtyuuuCImTZoU++23X7FzpaSkxFlnnRXTpk2L9u3bFztfy5Yti52jsNLT00t9zURq1KhRTJ48OXr37h2VKlUqVq4aNWrEwIED44UXXojKlSsXK9d1110XI0eOjCZNmhQrz4EHHhgfffRRtGrVqlDzyvt1BYomWXtPzZo1480334xddtkleywrKys++OCDePTRR+Ohhx6Kt99+OzIzM7PP16pVK1577bVi/93Xt2/f6Ny5c46xW265JSZMmFCsvMDWrUGDBjFs2LBiP1+WpVrs1VC69B5yqwjvqXoQuVWE6woUnv6D51kgMcpK/0HvAQAAAAAAACiuTZs2RZ8+fQoU27Nnz9h5550LvcZbb72Vb0z9+vXjrLPOKnTuvOy8887RrFmzhOb8vWnTpuX7/2+/+OKL44QTTtji+fXr18czzzxT5Boq6ndb3sycObNAceecc06x1tlmm22iX79+xcqxOcm4j8r6PVSQ34ex//77Fzpvly5d4vPPP4/TTjstUlJSNhvTvHnzGDRoUKFzF0aNGjUKdD1nzJhRonUUxEMPPRTr16/PM6ZatWp5nh8+fHj89NNPiSwr4QpyP3366aelUAkAAAAAAAAAAAAAAAAAAABQFhXvv5gHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABJ9tlnn0WrVq2iX79+0bt370hPTy92zo0bN8bTTz8dN910U8ybN69Ac9asWRNdunSJESNGRLt27Qq95pw5c6Jr164xZcqUQs/9zapVq+LYY4+NG264Ia677rqoWrVqkXP9ZvHixdGzZ894/vnni52L0jN//vw45JBD4sYbb4y+ffsW61546qmnonfv3rFkyZJi1fTqq6/Gcccdt9lzP/74Y8yYMaNAed588804/fTTt3j+p59+ik8//bRINQIRV199ddx7772bPbdw4cIYP358fPrpp/Hzzz/HQw89FLVq1YqIiIcffjjWrl0bBx10UOy///5RqVKlHHMbNWoUo0ePji5dusS4ceOKXN+uu+5a5LlFVbNmzVJfM1Hq1KkT7733XrRo0SLXuczMzPjggw/io48+iu+++y6WL18e69ati5o1a8a2224b++yzTxx11FGx00475ZrbrVu3yMjIiB49ehSprj59+sQdd9yx2XPz58+PESNGxNdffx0LFiyINWvWRFpaWjRu3Dhat24dxxxzTGy33XY55tSvXz9Gjx4de+21V4H/virP1xUommTuPXfeeWe0bNky+3jBggVx4okn5nr/a9asWbz66qvRunXriPjfvWrIkCFxyCGHFOETRxx00EFx++235xgbO3Zs/OMf/yhSPoCIiJSUlHjuueeicePGyS4lobXYq6H06D1sXnl/T9WD2Lzyfl2BwtN/8DwLJEZZ6T/oPQAAAAAAAACJMnr06Hj77bfjmGOOyTOuWrVqcdddd0W3bt0KlX/BggXx3nvvRfv27fOMu+OOO+KNN96IxYsXFyr/5lSqVCmef/757N/1MGjQoMjKyip23j8aPHhwDBo0aIvn99xzzzznv/7668X6vBX5uy1PFi1aFD///HM0adIkz7jjjz8+9t1335g6dWqR1vn3v/8d2267bZHm5qW076PycA9NmjQpLrjggjxjmjRpEttvv32Bf+9LRMS4cePi119/zfc6XnjhhfHDDz+U2M9Q3HLLLfnerxER48ePL5H1C2PBggXx0ksvxdlnn13kHPfff3/iCioB9erViz/96U/5xk2ePLkUqgEAAAAAAAAAAAAAAAAAAADKosrJLgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIpr3bp18fe//z0GDhwYF154YZx11lmx//77FzrPnDlz4sUXX4zHH388vvrqq0LP/+WXX+KQQw6J3r17x1VXXRWNGzfOd87ixYtj0KBBcffdd8eaNWsKveYfrV+/Pm6++eZ48skn48orr4zu3btHgwYNCp3nm2++ieeffz4GDhwYK1asKHZdlL5169bFDTfcEI899lj06tUrunfvHnXr1i3Q3IyMjBg+fHgMGDAgpk2blpB6Xn/99cjKyoqUlJRc5958880C5xk1alSe50eMGFHo2oD/ddhhh8U999yTa/yrr76Ka6+9Nl5//fXYtGlT9vh9990XtWrVioiIV199NUaPHh0REY0bN44rr7wyrr766khLS8uOr169eowYMSL23Xff+Pbbb4tU41VXXRW9evXKNd6qVauYPn16kXLmJz09Pcfx2LFj4/zzzy+RtRJtyJAh0aJFixxjGRkZcfvtt8dDDz0Uv/76a745jj766Ljvvvtijz32yDHevXv3GDlyZLz00kuFqunII4+Mu+++O9f4999/H3/+85/jrbfeiqysrC3Or1y5clxwwQVxzz33RO3atbPHGzduHA8//HB069atQHWU5+sKFF4y955tt902Lrzwwhxj3bp1iylTpuSKnTNnTnTp0iW++eabqFmzZkREHHzwwXHwwQfHxIkT8/2cv1evXr144YUXonLlytljCxcujLPPPjvPzwqQn379+kWnTp2SXUZEJK4WezWUHr2HLSvv76l6EJtX3q8rUDj6D55ngcQpK/0HvQcAAAAAAAAgkfr06RMdO3aMSpUq5RnXtWvXOOSQQ+KDDz4oVP7HHnss2rdvn2dMo0aN4umnn44TTzwxNmzYUKj8v5eSkhKPP/54HHjggRER8eCDD8aZZ54ZF154YZF+T0Nennvuubj33nujevXqRZo/ePDgYtdQUb/b8mbMmDFx3nnn5RmTmpoajz76aHTo0CEyMjIKlf+uu+6K008/vTgl5qm07qPycg/997//LVDcQQcdVKifI87IyIhBgwbFTTfdlG/srbfeGjvssEP89a9/jXXr1hV4jfz06dMn+vTpk2/cypUrs39GPtkeeOCBOPvss4s095NPPokPP/wwwRUlVrt27QoUV9D7EgAAAAAAAAAAAAAAAAAAAKh4KucfAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5cOKFSvivvvui/vuuy8aNmwY7dq1izZt2kSzZs2iadOmUaNGjahRo0ZkZmbG8uXLY8WKFTF37tyYOnVqTJs2Lb744oti17Bx48a4++67Y+DAgXHUUUfFwQcfHK1atYp69epFnTp1Yu3atbF48eL48ssvY9y4cTF27NjIzMzMkeOII44odh0//PBD9O3bN/r27Rv77LNPHHLIIdGyZcvYZZddolatWpGenh5VqlSJjIyMWLVqVaxcuTK+//77+Pzzz+OTTz6JGTNmFHitjz76KFJSUopd828eeuiheOihhxKWrzBmzpyZ0M9SGIn+Hn8zZ86cuOqqq6J3795x6KGHxoEHHhh77bVXNGrUKGrXrh2pqamxYsWKWLJkScyYMSOmTJkS77zzTqxduzahdSxcuDBSU1OLnWfBggVJu0ZQ0T300EO5/j0dNmxYdO/ePdffVXmZP39+3HDDDfH444/Hq6++GnvvvXf2ufT09HjuuefiwAMPjKysrELXmJWVtdl5GzZsKHSugkpPT89x/Ouvv8bcuXNLbL1EOeyww+Lkk0/OMfbjjz/G0UcfHV9++WWB84wePTr23XffeOmll+LEE0/Mce7OO++Ml19+ucDXsnr16jFkyJBc+/grr7wS55xzTmRkZOSbY8OGDfHoo4/G5MmTY/z48VG3bt3sc127do199tknpk+fnm+e8npdgcJL9t5z6qmnRlpaWvbxu+++G++9994W15o/f348+eST8ec//zl77Nxzz42JEyfmW+fvPf3007HDDjtkH2/atCnOPvvsWLhwYaHyAPxehw4don///skuIyISW4u9GkqP3sOWlef3VD2ILSvP1xUonGTvO2XlmdbzLJAIZaX/oPcAAAAAAAAAJNoXX3wRTz75ZFx00UX5xt5///2x//77Fyr/sGHD4tZbb41mzZrlGde5c+d466234tRTT40VK1YUao2IiHr16sWTTz4ZJ510Uo7xQw45JKZPnx633HJL3H333bFx48ZC596c5cuXx/Dhw+Pss88u9Nyff/453n777WLXUFG/2/Lm1VdfjfPOOy/fuLZt28Ybb7wRp512Wixbtizf+Lp168YjjzwSZ5xxRgKq3LLSuI/K0z30ww8/xDfffBMtW7bMM+7www+Pl156qVC577vvvrjkkkuiUaNG+cZecsklcdRRR8XVV18dI0aMKNQ6f/SnP/0p7rvvvujSpUuB4p955pmE/16Povroo49i8uTJ0a5du0LPvf/++xNfUIIV5Pf4LFq0KKZNm1byxQAAAAAAAAAAAAAAAAAAAABlUmr+IQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUP4sXLgwRowYEX//+9/j/PPPj6OPPjoOPfTQaNOmTRx44IFxzDHHRNeuXaN3797x7LPPxhdffJHQ9Tds2BBvv/123HzzzXHaaafFkUceGfvtt18ccsghcdJJJ8W1114bb731VmRmZiZ03c2ZPn16PPTQQ9GrV6846aST4sgjj4wDDjgg9t133zj44IPj6KOPjtNOOy369u0bTz/9dMyYMaPEa6L0bdy4MSZMmBB33XVXnHvuudGxY8c44IADom3btnHkkUdG165d4+9//3uMHDky1q5dm+xygVJ21FFHxR577JFj7IMPPoizzz67yH9XzZ49Ow477LCYOXNmjvEDDjggunXrVuRaS1utWrVyHGdkZCSpksJZs2ZNjB07Nvt47dq10aVLl/jyyy8LnSszMzO6du0aX331VY7xXXbZJQ4//PAC5/nrX/8aO+ywQ46xd999N84888xCf6/Tp0+Pyy67LPt4wYIFce+998by5csLNL+8Xleg8JK997Rv3z7H8RtvvJHvOn+MOeSQQwpV59VXXx3HH398jrHbbrstx98LAIXVoEGDGDZsWFSqVCl7rCB7WnmoxV4NpUPvIW/l+T1VD2LLyvN1BQon2ftOWXmm9TwLFFdZ6T/oPQAAAAAAAAAl5cYbb4zVq1fnG9e2bds499xzC5V7/fr1cdNNNxUo9qijjoqvvvoqLr/88qhatWqB5tSuXTuuuuqq+Oqrr+Kkk07abEy1atXi9ttvj48//jh23333Ateen8GDBxdp3pAhQ2LTpk3FXr8if7flyeuvvx6//PJLgWKPPPLI+Oabb6JXr165frbrN82bN49bbrklvv/++zjjjDMSWepmleR9VF7vodGjR+cb06lTp0LnXbZsWVxyySUFjm/evHm89tpr8d1338WNN94YBx98cFSuXLlAc1u0aBGXXnppvPXWW/Hll19Gly5dCjRv7dq1cccddxS4xtLwwAMPFHrOwoUL44UXXiiBahKrIPfRmDFjSqESAAAAAAAAAAAAAAAAAAAAoKwq2G+bAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKDC6ty5c66xPn36RFZWVrHyLlu2LLp16xaffvppVK1aNSIilixZEvXq1StW3tJUs2bNHMcZGRlJqqRwpkyZEkcddVTst99+ce2118Z3330XX3zxRZHzZWZmxi233BLPP/98jvEjjzwyxo0bl+/8ypUrx1VXXZVjbN26dXHuuedGZmZmkWp64YUXom3btjFu3Lh4++23Y+PGjQWeW16vK1Q0hx9+eOy4447Zx99++21MnDgxYfnLwt6z66675jieMWNGvmv8cb/ebbfdClxfu3bt4s4778wxNmHChPj73/9e4BwAf5SSkhLPPvtsNG7cOHts7ty5cd5558Wvv/5a7muxV0Pp0HvIW3l+T9WD2LLyfF2hItF/2LySeKYFKI6y0n/QewAAAAAAAABK0oIFC+Kuu+6K/v375xt75513xn/+859C/ezZ008/Heeee2506tQp39hGjRrFQw89FPfcc0+MHz8+Pvroo/jll19iyZIlsWnTpkhLS4s6depE8+bNo02bNnHwwQdHlSpVClRH8+bNY82aNQWuOz/jxo2L77//PnbZZZdCzXviiScSVkNF/W7Lkw0bNsSAAQPi7rvvLlB8/fr1Y+DAgTFw4MCYN29eLFy4MJYtWxbp6emx0047RcOGDfOcn5GREWlpaYkoPVtR76O77767Qt5Db731Vlx55ZV5xrRs2TKaNWsWc+bMKVTu119/PZ566qno3r17gefssssu0b9//+jfv39s2LAh5s2bF+vXr88V16BBg/jss8+iRYsWRb5Hrr/++pg3b16R5paUl156Ke69994cPzeTn0ceeWSz31FZsu2220br1q3zjRs9enTJFwMAAAAAAAAAAAAAAAAAAACUWZWTXQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAydWqVascx0uWLIlJkyYlJPeMGTNiyJAh0b59+7jvvvvimWeeibVr1yYkd2lIT0/PcZyRkZGkSormk08+iW7duiUk18iRI3ON7bHHHgWa27lz52jcuHGOsQcffDB+/PHHYtXUt2/fIs0r79cVKoqePXvGySefnH08ZMiQmDhxYsLyl4W9Z5tttslx/Msvv+Q7548xVatWjbS0tHz3qrp168YLL7wQVapUyR5btGhRnHXWWbFp06YC1wzwR/369Yujjz46+3j9+vXRrVu3WLp0aYWoxV4NpUPvIW8V4T1VDyK3inBdoSLQf9i8knimBSiOstJ/0HsAAAAAAAAAStqAAQPisssuiyZNmuQZ17Rp0+jTp0/ceuuthcrfvXv3+Pjjj/PN/5uaNWvGcccdF8cdd1yh1snLlVdeGXPmzElYvoiIJ554Iv7xj38UOH7ChAnx3XffJbSGivrdlif/+te/4tJLL43mzZsXat72228f22+/faHm3HTTTXHPPfcUak5BFOU+uuWWWxK2flm6h8aMGRMrV66MWrVq5RnXpUuXePjhhwud/+KLL45GjRrFMcccU+i5lStXjp122mmz56pVqxZ77bVXoXP+5rXXXov77ruvyPNLyoYNG+Lhhx+O/v37Fyh+/fr1Rboupa1z586RkpKSZ8yGDRvi9ddfL6WKAAAAAAAAAAAAAAAAAAAAgLIoNdkFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJBc9erVy3E8b968hObv1atX7LHHHvHYY4/F2rVrE5q7pKWnp+c4zsjISFIlybdixYpYsWJFjrE/3jtbctppp+Ua++c//5mQuorCdYWtQ1nYe4qy36xfvz42bdqUY6xWrVr5zhsyZEg0a9Ys+zgrKyvOPffcmD9/fgGrBcitQ4cO0b9//xxj1113XUyePLnC1GKvhtKh95A376k5VZQehOsKW4eysO94pgXKu7LSf9B7AAAAAAAAAEpDRkZGXH/99QWKvfbaa6Nx48aFyj9//vw4/vjjc/0cXmn529/+Fs8880zC8w4ZMiTX/46al8cffzzhNVTU77Y8ycjIiB49esSGDRtKdJ1nn302XnrppRLJncz7qKzdQ2vXro3hw4fnG7e5n9MriPXr18fJJ58cEyZMKNL8kvDOO+/EWWedFVlZWckuZbP+/e9/R2ZmZoFiX3zxxVi4cGEJV1R8Bbl/3n777ViyZEkpVAMAAAAAAAAAAAAAAAAAAACUVanJLgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA5MrKyirR/GvWrCnR/CUpPT09x3F5/iyJsHbt2hzHVapUKdC8jh075jj+5JNP4scff0xYXYXlusLWoaztPREF/zt306ZNhcrbs2fPOOmkk3KM3XXXXTF69OhC5QH4vQYNGsSwYcOiUqVK2WOvv/56DBw4sELXYq+GkqH3kDfvqblVhB6E6wpbh7K07/zGMy1QnpSV/oPeAwAAAAAAAFCannrqqZg+fXq+cTVr1ow77rij0PmnTp0ahx9+eCxatKgo5RXJpk2b4pprrilSvQXx008/xdtvv12g2BUrVsTLL79cInVUxO+2vHn//ffjsssuK7GfT37vvffiwgsvLNGffy7t+6gs30PPPvtsvjGHHXZYbLPNNkXKv3bt2ujYsWM88MADRZqfSE899VR06dIlMjIykl3KFv3yyy8xbNiwAsWWhe80PzVq1Ihjjjkm37iC3IcAAAAAAAAAAAAAAAAAAABAxZaa7AIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASK5ff/01x3GjRo2SVEnZU7NmzRzHGRkZSaqkbKhXr16O4xUrVuQ7Z/vtt4+mTZvmGHvjjTcSWldhua5Q8ZXFvSciIiUlpUBxqampBc65//77xz333JNj7IMPPogbbrihULUB/F5KSko8++yz0bhx4+yxuXPnxnnnnVfha7FXQ8nQe8ib99TcKkIPwnWFiq+s7Tu/8UwLlBdlpf+g9wAAAAAAAACUtqysrOjdu3eBYs8777xo06ZNodeYOnVq7LvvvvH+++8Xem5hLViwII455phc/7tlog0ePLhAccOGDSvRn9mriN9tefP444/HhRdeGOvXr09o3jfffDOOOeaYyMzMTGjezSmt+6is30Njx46NBQsW5BlTuXLlOO2004q8xoYNG+Kqq66KU045JebNm1fkPEW1cOHCOPvss6NHjx6lcm8V1wMPPJBvzKRJk2LKlCmlUE3xnHTSSZGWlpZnzOrVq2PEiBGlVBEAAAAAAAAAAAAAAAAAAABQVhX8vxICAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQIU0f/78HMcNGzaMXXfdNUnVlC3p6ek5jjMyMpJUSfLtscceUaVKlRxj33zzTb7zWrVqlWts+vTpCaurKFxXqPjKyt6zevXqHMdpaWn5zqlSpUqkpqbmGFu1atVmY+vUqRMvvvhijv15yZIlccYZZ8TGjRuLUDHA/+rXr18cffTR2cfr16+Pbt26xbJlyypcLfZqKB16D3nznppTRelBuK5Q8ZWVfcczLVBelZX+g94DAAAAAAAAkAzvvPNOjBo1Kt+4lJSUuP/++4u0xk8//RSHHXZYXHrppbF48eIi5chLZmZm3HvvvdGyZcsYM2ZMwvP/0YgRI2LRokX5xg0ePLjEa6lo32159OSTT0aHDh3i22+/LXauzMzM6NevX5xwwgml+vOeJXkflZd7aNOmTfHss8/mG9ejR49ir/Xqq69GixYtolevXiXy7+0fLV26NG6++eb405/+FEOHDi3x9RLl008/jYkTJ+YZU9S/l0pbQe6b//znP7FmzZqSLwYAAAAAAAAAAAAAAAAAAAAo01LzDwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgInv33XdzjV133XVJqKTsSU9Pz3GckZGRpEqSr0ePHrnGxowZk++8li1b5hqbNWtWnnOqVKkSDRs2jJ133jm23377qF27doHrLAjXFSq+srL3/PrrrzmOt9tuu3zn/DEmMzMz1qxZs9nYJ598Mnbaaafs46ysrDjvvPPip59+KnyxAP9fhw4don///jnGrr322pg8eXKFrMVeDaVD7yFv3lNzqig9CNcVKr6ysu94pgXKo7LSf9B7AAAAAAAAAJKpd+/esXHjxnzj2rdvH6ecckqR1ti0aVM8+uij0axZs7j88stj+vTpRcrze3Pnzo0bb7wxdthhh+jTp0+sWrWq2DkLYsOGDfHMM8/kGTNjxoyYMmVKqdRTkb7b8mrSpEmx5557Rq9eveLHH38s9PyNGzfGs88+G61atYo777wzNm3aVAJV5i3R91F5vIcefPDBfPfCgw8+OFq0aFHstdatWxf3339/NG3aNE455ZR4+eWXY+3atcXO+5s1a9bE66+/HmeffXY0adIk+vfvHytWrEhY/tLywAMPbPHczz//HP/5z39KsZqiadKkSXTs2DHfuPvvv7/kiwEAAAAAAAAAAAAAAAAAAADKvMrJLgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA5Hr77bcjMzMzqlatmj3Wo0eP+PDDD+PRRx9NYmXJl56enuM4IyMjSZUkV9u2baNnz545xubOnRujRo3Kd26TJk1yjX377bc5jitVqhQnnHBCnHTSSXHooYfGLrvsEqmpqTlili1bFp999lmMGjUqXnzxxfj++++L8En+l+sKFV9Z2Xu+/vrr2H///bOP99xzz3jzzTfznNOqVascx998881m4/7yl7/EKaeckmPs3nvvzTc/QF7q168fQ4cOjUqVKmWPjRgxIu67774KW4u9GkqH3kPevKf+n4rUg3BdoeIrK/uOZ1qgvCkr/Qe9BwAAAAAAACAlJSWp68+aNSsqV65cKmutWbMmHnnkkXjkkUdip512ik6dOkW7du2iVatW0axZs2jYsGGu72Pjxo2xYsWK+Pbbb+Orr76KTz/9NN56662YNWtWqdS8Ob17947evXsnbf3NKevfbYMGDRKeMz/nn39+nH/++aWyVmZmZtx///3xz3/+Mzp06BDHHXdcHHjggdGyZcto2LBhjtj169fH999/H5999lmMGTMmXnnllVi0aNFm886dO7dU94i87qMDDjigXPz7WVRz586NV155JU4//fQ846644oq4+uqrE7JmZmZmvPrqq/Hqq69GWlpa7LvvvrH//vvHAQccEM2bN49GjRpFo0aNolq1apudv3Llyvjll1/ip59+im+++Sa++OKLmDx5cnzyySeRmZmZkBr/6PLLL4/LL7+8RHL/0Ysvvhgvvvhiia9TpUqVEst9+eWX5/p5zT969913Y+rUqSVWAwAAAAAAAAAAAAAAAAAAAFB+lM5vAgIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgzFqwYEE888wzceGFF+YY//e//x3t2rWL66+/PhYsWJCk6pKrZs2aOY4zMjKy/3nHHXeMAw88MPbYY49o2rRp1KpVK6pVqxYZGRmxcuXK+O6772LGjBnx7rvvxsqVK0u79ITp3LlzPPvss1G1atUc49dcc01s3Lgx3/kNGjTIcZyRkREbNmzIPj7vvPPiH//4R+ywww555qlbt2506NAhOnToELfddlv85z//ib59+8acOXMK8Wn+l+sKFV9Z2XvefffdOOecc7KPjz/++LjnnnvynHPcccflOH7//fdzxey3334xYMCAHGOTJk2Kfv36FagugM1JSUmJ5557Lpo0aZI9NmfOnOjevXuFrsVeDaVD7yFv3lP/V0XrQbiuUPGVlX3HMy1QnpSV/oPeAwAAAAAAALA1++GHH+Kxxx6Lxx57LMd49erVIy0tLVJSUmLNmjWxdu3aJFVYfvluk2fTpk0xfvz4GD9+fPZYpUqVokaNGlGlSpVYtWpVZGZmJq/AQtjcfVTR76F77703Tj/99DxjLr744rjlllti+fLlCV07IyMjJk6cGBMnTsx17oILLojHH388x9i8efPy/blAkistLS0uv/zyfOMGDhxYCtUAAAAAAAAAAAAAAAAAAAAA5UHlZBcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQPL169cvjj322GjatGmO8QsuuCD+53/+J95+++3473//G5MnT47PP/88SVWWvpo1a+Y4rlGjRlx77bXRvXv32H333QuUY8OGDTFmzJh48MEH48033yyJMhMqNTU1dtxxxzj44IOjR48e0alTp1wxjz32WLzwwgsFyvfH73DVqlUREVG7du0YOnRodOnSpUg1du3aNbp06RJXXnllPPXUU4WavzVeV9jalJW9Z/jw4fHAAw9E9erVIyKiQ4cOceihh8b777+/2fhGjRrF+eefn2Ps2WefzXFcu3btePHFF6Nq1arZY0uXLo0zzjgjNmzYUNiPBZCtX79+cfTRR2cfr1+/Prp16xbLli2r0LXYq6H06D1s2db6nlrRexCJvK6dO3cuVN1A6Sgr+45nWqA8KSv9B70HAAAAAAAAgNzWrl0ba9euTXYZFZLvNjk2btwYK1euTHYZCVHR76FJkybFpEmT4sADD9xiTHp6elxyySVxzz33lFpdFfk7r8h69OgR2267bZ4x3333XYwYMaKUKgIAAAAAAAAAAAAAAAAAAADKutRkFwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABA8i1atChOPvnkWLJkSa5zVapUieOPPz4eeOCBmDRpUqxatSq23Xbb7POdOnWKgw46KOrVq1eaJZe4tLS0SE1NzTH27LPPxp133hm77757gfNUrlw5jj322Bg5cmS8++67hZpbUoYNGxZLly7N9WfFihWxYcOGmD17djz33HPRqVOnXHMfeuihuPTSSwu8VtWqVXMcr169OtLT02PMmDHRpUuXzc5Zvnx5zJ07N3755ZfYuHHjFnPXrFkzhgwZEjfccEOB66nI1xX4P2Vl71m8eHE8/vjjOcZefPHF2G+//XLF7rjjjjFy5MhIT0/PHvvwww/j/fffzxH3xBNPxC677JJjrEePHjF37tx86wHYkg4dOkT//v1zjPXt2zc++uijCl+LvRpKj97D5lX099SttQeR6Otalq4p8H/Kyr7jmRYoL8pK/0HvAQAAAAAAAACg7LnxxhvzjenZs2dUrly5FKqhvEpJSYmrr74637ibbropsrKySqEiAAAAAAAAAAAAAAAAAAAAoDzwGy0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiIiIjz/+OA444IB44YUXom3btluMS0lJyXHcp0+f6NOnT0REzJkzJz766KOYMGFCvPjii7Fo0aISrbkkpaen5xr742cvrPbt28eUKVPivPPOi+HDhxcrV3HUrFkz6tatW6g5P/74Y1xxxRXxxhtvFGpeampqjuONGzfG4MGDY//9988eW716dQwePDhee+21+PDDD2Pt2rU55uy2227RqVOnuOKKK2K33XbLtcatt94aP/30Uzz55JP51lORryuUBW3atInbbrutwLG/16lTpxg1alSB5l511VXx1VdfbfF8Wdp7rr322jj66KOjZcuWERHRuHHj+Oijj+L999+PGTNmxIYNG6J58+Zx1FFHRbVq1bLnrVq1Krp3754j1xVXXBGnnXZajrH7778/RowYkWOsfv36ceqpp0anTp2iadOmUbdu3Vi2bFnMmzcv/vvf/8Yrr7wSixcvzrNuYOtRv379GDp0aFSqVCl77LXXXosHHnhgq6nFXg2lR+8ht4r+nrq19iASfV3L0jWFskD/Ibey8EwbEZ5ngS0qK/0HvQe9BwAAAAAAAACgbBozZky88847cdRRR20xpmnTpnHmmWfGs88+W4qVUZ6cdNJJ0aJFizxjpk+fHs8//3wpVQQAAAAAAAAAAAAAAAAAAACUB5WTXQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZcf3338f+++/f5x11llx9dVXR9u2bQs1v1mzZtGsWbPo2rVr3H///fHGG2/E3/72t5g1a1YJVVxyatasucVzy5YtiylTpsTHH38cP/30UyxdujTWr18ftWrVim222Sb22WefOPjgg2OXXXbZbN4XX3wxunbtGq+88kpJfoSEatq0aZx55pkxZcqUWLhwYZHz7LTTTtG8efPs4xdffDEuv/zy+PXXX7c458svv4wvv/wy/vWvf8WFF14Y//znPyMtLS1HzL/+9a+YMGFCfP/993mu77pCyapfv34ce+yxRZrbtGnTaNq0aYFi69SpU6jcydx7Vq9eHZ07d47Ro0dn7x+pqanRoUOH6NChw2bnrFy5Mk455ZT45ptvssdat24dAwcOzBH38ccfxzXXXJN9nJKSEv369Yt+/fpFenr6ZnN37do1Bg4cGLfddlvcddddkZWVtcXagYovJSUlnnvuuWjSpEn22A8//BA9evTYqmqxV0Pp0nvIyXtqbhWhB1ES17U8X1NINP2H3MrSM63nWeCPylL/Qe/hf9mrAQAAAAAAAICy6Nprr40pU6ZESkrKFmOuueaaeO655/y8A5t17bXX5hvz+5+1AQAAAAAAAAAAAAAAAAAAAIiIqJzsAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoe4YOHRpDhw6NP/3pT3HsscfGgQceGPvvv380b948UlJSCpSjcuXKcfLJJ8cJJ5wQd911V1x//fUlXHViLVu2LN544404/vjjs8dGjBgRgwcPjlGjRsWGDRvyzXHwwQfHddddFyeccEKO8UqVKsXTTz8d++67b3z77bcJr70kpKamxjnnnBPHHHNMdO3aNcaPH1+kPJUqVcr+53/84x9x4403FnhuVlZWDB48OD799NMYN25c1K5dO/tcjRo14q677oquXbvmmcN1ha1Tsvee7777Ltq1axf33HNPnHfeeZGamrrF2LFjx8Zf/vKXmDlzZvZYrVq14qWXXopq1apljy1fvjy6du0a69evj4iIKlWqxLBhw+LUU0/N9zOlp6fHHXfcEW3atImzzz67QHsfULoOP/zwqFq1apHnr1y5Mj788MN84/r16xdHH3109vH69eujW7dusWzZsiKvXVTJrsVeDaVP7+F/eU/NrSL0IErqupbXawpbC/2H/+N5FsqHrbH/oPfwf+zVAAAAAAAAAEBZ88knn8TLL7+c58/L7bXXXtG9e/cYMmRI6RVGuXD66afHgQcemGfM2LFjY/To0aVUEQAAAAAAAAAAAAAAAAAAAFBeVE52AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUXV9//XV8/fXX8c9//jMiImrUqBF77LFHjB07NmrVqhUREYsWLYptttkmKlWqtNkclSpVir/97W/RokWLOPPMMyMrK6vU6i+OZcuWxQknnBCtW7eOSy65JIYMGRIfffRRoXJMnDgxTjzxxDj77LPjiSeeiGrVqmWfS09Pj4cffjg6deqU6NLzdfbZZ0eVKlVyjVeqVClq164djRs3jgMOOCBOPfXUOOSQQ3LE1K9fP956663o3LlzjBs3rsg1DB06NG688cYizf3000/j9NNPj7fffjtSUlKyx0877bRo0aJFfPvtt1ucW5GvK5C/ZO09ERGLFy+O888/P/r37x8nnHBC7L///tGwYcOoXLlyLFy4MGbNmhVvvPFGfPrpp7nmDh48OFq0aJFj7IILLogffvgh+3jAgAFx6qmn5oj5/PPP45133oklS5ZE/fr1o1OnTrHHHntkn+/atWvMmTMn+vbtW5ivAigFQ4cOjUaNGhV5/rRp02LffffNM6ZDhw7Rv3//HGN9+vSJKVOmFHndoiortdirITm25t5DRMV/T91aexCJvq7PPfdc9niyrymQv621/5CSkuJ5FsqZrbH/kOw69B4AAAAAAAAAAPJ29dVXR+fOnSM9PX2LMXfeeWf85z//iZUrV5ZiZZRl1apViwEDBuQZs27durjyyitLqSIAAAAAAAAAAAAAAAAAAACgPKmc7AIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKD/WrFkTH3/8caxbty5q1aoVERHnnntujB8/Plq1ahUHHXRQnHLKKXHEEUdEampqjrndunWLWbNmxd///vckVF5006ZNiyuuuKJYOZ5//vlYsWJFvPbaazm+l44dO8YhhxwSH3zwQXHLLJSVK1du8dyiRYviu+++i/fffz8GDhwYBxxwQDz55JOxxx57ZMdUq1YtXnrppdh7773j559/LvT6q1evjquuuqoopWf773//Gy+++GKcccYZ2WMpKSnRrVu3uP322/OdXxGvK5QFkydPjkMOOaRAsXfeeWe0b98++3jUqFHxj3/8o0BzZ86cWejaysLeExExe/bs+Oc//1ngNS+99NLo1q1bjrFBgwbF8OHDs48PPvjg+Otf/5oj5s9//nMMGjQoV77evXvHgAEDchy/8MIL8fHHHxe4JqD8q1+/fgwdOjQqVaqUPfbqq68Wan+qiLX8xl4NybU19h4iKu576tbeg0jUdX3mmWfKzDWFskD/IX/JfKb1PAv8piy98/9WS7Lr+I3eAwAAAAAAAADA5s2bNy/69esXDz744BZjGjZsGDfeeGNcc801pVgZZVmfPn2iWbNmecbceuut8eWXX5ZSRQAAAAAAAAAAAAAAAAAAAEB5kpp/CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADkLTMzMz799NMYNGhQdOzYMfbee++YMGFCrrgbb7wxdt111yRUmHxvvPFGPPLII7nGzzvvvCRUU3AfffRRtG3bNt5///0c49tuu23cc889Rcr57LPPxi+//FLs2u66665cY506dSp23sIor9cVSsry5ctj4sSJBfqzZMmSHHMXLlxY4LmrVq0qdG3lce/ZZ5994v77788xNnXq1Lj66qtzjPXt2zfH8cMPPxyDBg3abM577703hgwZkn2ckpISffr0SUi9QPmQkpISzz33XDRp0iR7bPbs2dGjR4+tupaisldD6dF7KJjy/J6qB7Fl5fWaQknRf0isRD/Tep4FIsrWO/8fa9F7sFcDAAAAAAAAAGXboEGDYtKkSXnG9OzZM1q0aFGidUyfPj2uv/76HH/uvvvuEl2TwmvSpEn069cvz5jPP/98sz+bCQAAAAAAAAAAAAAAAAAAABARkZrsAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACoeGbMmBFHHXVUvPzyyznGU1NT47rrrktSVcl3yy23xKZNm3KMHXPMMUmqpuAyMjLixBNPjCVLluQYP/PMM2P77bcvdL433ngjIXVNnTo15s+fn2Nsn332SUjuwiiv1xW2NuVt70lPT4+XXnopqlevnj22cuXK6Nq1a2RmZmaP1ahRI44//vgcc++88848c//x/MknnxxVqlRJQNVAedCvX784+uijs48zMzOjW7dusXz58q26lqKwV0Ny6T1sWXl+T9WD2LzyfE1ha1Pe9p2Seqb1PAuUpXf+39ei97Dl8/ZqAAAAAAAAAKCsyMrKigsvvDC++OKLLf75+uuv4+KLLy7ROmbMmBG33357jj8PPvhgia5J4V1wwQUxe/bsPO+XCy64IDZs2JDsUgEAAAAAAAAAAAAAAAAAAIAyKjXZBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQMW3cuDF69OgRCxcuzDF+yimnREpKSpKqSq5ffvklPvzwwxxjzZo1izp16iSpooJbunRp3H333TnGUlNT4/TTT89zXkZGRq6xGTNmJKyumTNn5jiuV69eVKlSJWH5C6I8X1eoqCrC3vPoo49Gy5Ytc4xddNFF8d133+UYa9euXVSuXDn7eNasWTF37tw8c3/11VcxZ86c7ONq1apF27ZtE1A1kCh77bVXNGzYsMh/jjrqqM3m7dChQ/Tv3z/HWJ8+feLjjz8ujY9VZmspKns1JJ/ew+aV9/dUPYjcyvs1hYqqIuw7JfVM63kWyoetsf+g9/B/7NUAAAAAAAAAQFk2c+bM2GuvvfL8c+211ya7TMqAf/zjH/neK+XpZ4YAAAAAAAAAAAAAAAAAAACA0lc5/xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKJrVq1fHo48+GjfeeGP2WJ06daJ169YxderUJFaWPDNnzoxDDjkkx1jDhg1j+fLlSaqo4IYPHx533XVXjrF27drlOefXX3/NNbZ48eKE1bRo0aJcY7Vr144lS5YkbI2CKM/XFSqi8r73XHTRRXHWWWflGPv3v/8dL774Yq7Yli1b5jieOXNmgdaYOXNmNGvWLPu4RYsW8eGHHxahWqAkJHLP+k39+vVj6NChUalSpeyxCRMmxPDhw6NJkyYJWaNu3bq5cmVlZcX8+fPLbC1FZa+GskPvYfPK+3uqHkRu5f2aQkVU3vedkn6m9TwLZd/W2H/Qe8jJXg0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDWrnKyCwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgYhs7dmzceOONOcZ23nnnmDp1apIqSq5ffvkl11idOnWSUEnhffvtt7Fhw4aoXLly9liTJk3ynLN06dJcY5mZmQmrad26dbnGKlWqlLD8BVWerytUROV579lrr73iwQcfzDH22WefRc+ePTcbX69evRzHS5YsKdA6ixcvzjMPUPHccccduZ7dDjvssJg3b17C1ujbt2/07ds3x9gPP/wQO++8c5mtpSjs1VD26D3kVt7fU/Ugcivv1xQqovK875TGM63nWdg6laV3/s3VoveQk70aAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACArV1qsgsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoGL76aefco3Vr18/CZWUDRs3bkx2CcXy66+/5jiuXbt2nvE///xzrrE6deokrJ66devmGlu5cmXC8hdUeb+uUNGU172nZs2a8dJLL0X16tWzx1atWhVdu3aNdevWbXZOenp6juOMjIwCrbVmzZo88wAVz+b2rtLw/fff5xorS7UUlr0ayia9h9wqwnuqHkROFeGaQkVTXved0nqm9TwLW6ey9M6fjFr0HgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKB8SU12AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUbBkZGbnGqlWrloRKyoZtt90219iSJUuSUEnRVK5cOcfx+vXr84yfPHlyrrEmTZokrJ7GjRvnOF67du1m77mSVt6vK1Q05XXveeSRR2LXXXfNMXbppZfG119/XeAcWVlZCY0DKK7Zs2cnu4RsiajFXg1lk95DbhXhPVUPIqeKcE2hoimv+05pPdN6ngVKU1npP+g9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQPlSOf8QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACq69u3bx+233x5PPPFEPPnkkwnNXb9+/VxjixcvTuga5UmLFi1yjS1cuDAJlRRe1apVY5tttskxll/t06ZNi9WrV0fNmjWzxw477LCYNm1aseupVatW7LvvvjnGPv/882LnLYryfF2hIiqPe8/5558f5557bo6xJ554Ip5//vlC5UlNTU1oHFBxLFiwIL799tuE5vzjM9Cvv/4av/76a46xqVOnlulaCsNeDcWj91C6yvt7qh5EbuX9mkJFVB73ndJ8pvU8C1unsvTOn+ha9B4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACg4qmc7AIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASJ62bdvG7bffHp06dYqIiMaNG8fzzz8f69atS9garVu3zjU2f/78hOUvDbVr144VK1YUO0+NGjXisMMOyzG2YMGCWL16dbFzl4ZDDz0011h+13LTpk3x7rvvRufOnbPHzj777HjggQeKXc8pp5wSVapUyTH23nvvFXi+6woVV1neezZnzz33jEGDBuUYmzFjRvz5z3/Od+7KlStzHKelpRVozRo1auSZB6h4/vKXvyQ8Z1ZWVo7je++9N26//fZyVUtB2auh6PQeCs576v+pSD2IRFzXinBNoSIqq/vOlpT2M63nWdg6laV3/kTXovcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFU9qsgsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBkqVOnTnTp0iVuvfXWeOWVV2L8+PExbdq0+Oabb3L9ueCCC5JdLgCUiAsuuCA6deqUfdy8efO4/fbbE7rG+eefn+N4/fr1MXXq1ISuURJSUlLi9NNPj6lTp8awYcMSkrNXr15RvXr1HGMjR45MSO7N2WWXXeK+++6L9PT0hOS77LLLco1NmDAh33mDBg3KcXzAAQfESSedVKxaqlatGrfcckuu8aFDh+Y5ryJcV6golixZEvPmzcv+s3Tp0oTmL0t7T15q1KgRL730UqSlpWWPrVmzJrp27RoZGRn5zv/1119zHDds2LBA6/4xLtHfP0BFYq+G4tF7yFtFeU/Vg8gp0ddV7wGKTv/hfyXjmdbzLEDB6T0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAclROdgEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFDamjdvHn379o3zzjsv0tLSCjSnbt26JVsUFVKlSpWiZcuW0apVq9hxxx2jTp06UatWrahcuXKsWrUqli9fHosXL46ZM2fGF198EStXrkx2ycBW6I477oiLLrooqlSpkj129dVXx1dffRWPPvposfNfdNFF0aFDhxxjY8eOjeXLlxc7d0k69NBDY/DgwbHrrrtGRETr1q2jR48eMWTIkCLnbNu2bfztb3/LNT58+PAi59ySPfbYI/72t7/FmWeeGZUqVYqaNWvGJZdcUqycp5xySnTt2jXH2IYNG2LkyJH5zh05cmR8/fXX8ac//Sl7bPDgwfHZZ5/F7Nmzi1TPE088ETvttFOOsffeey8+/vjjLc4p79cVKpqLLrqoRPOXlb0nPw899FDsvvvuOcauuOKKmDVrVoHm/zFur732KtC8P8bNnDmzQPMAtkb2aigevYctqwjvqXoQuZXEddV7gKLTf/hfyXim9TwLUHB6DwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJAcqckuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAStPpp58e06dPj0svvTTS0tKSXQ4VUK1ataJHjx7x2muvxcqVK2PWrFnx0ksvxb333hs33XRT9OrVK/7yl79Ev3794s4774zBgwfHxIkTY8WKFTF16tS46aabYtddd032xwC2Ij/++GPceuutucb//e9/x+233x6VKlUqcu7LL788HnnkkVzjAwYMKHLO0rJw4cJo0aJFjrHHHnssevToUaR8HTp0iLfeeitq1KiRY3zixInx5ptv5jl35513jtmzZ+f607Fjx83Gp6SkxOuvvx7nnHNO9vW7+OKL45577omUlJQi1d+tW7cYNmxYrvEhQ4bEsmXLCpTjuuuuy3Fcv379eOedd2KvvfYqVC1Vq1aNxx9/PM4555wc45s2bYq+ffvmObcsXVegdJSFvScv3bt3j+7du+cYe/rpp+Opp54qcI4pU6bE2rVrs4933nnn2GOPPfKc07Zt22jUqFH28apVq2LatGkFXhNga2KvhuLTe9iysvSeWtj+Q4QexJaUxHXVe4CyLdn7Tn6S8UzreRag4PQeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIHkqJ7sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoDTvttFNMnz49ateunexSqICOP/74GDx4cDRs2LBYeVq3bh2tW7eOW265JSIiNm3aFA888ED069cv1q1bl4hSATbr1ltvjQcffDDGjx8f++yzT/Z4v379ol+/fhERsXz58njvvffio48+irlz50a1atWy40466aQ44ogjYo899oj27dtHvXr1NrvOxIkT4+ijj47Vq1eX7AdKgG+++SaqV68eY8aMicMOOywiIipXrhxPPvlkPPnkkxER8fPPP8d7770XX3/9dSxcuDDWrFkTlStXjnr16sVOO+0UBx10UOyzzz6RkpKSK39WVlacc845MXTo0HxrqVKlSuy00065xmvUqLHZ+KysrGjevHk8+uijcfHFF2eP9+nTJ/r06RMREStWrIgPP/wwvvzyy/jxxx9j1apVsXbt2qhRo0bUq1cvdt9992jXrl20bNlys2tkZGRE586dY8KECfnW/5tXXnkl0tLS4v3334/99tsvIiJ23nnn+OyzzyIiYvXq1fHuu+/G+++/H/Pnz4+lS5dGWlpa1K9fP/bee+/o2LHjZr+HiIhhw4bF2WefHVlZWXnWUJauK1A6ysLeszlpaWkxZcqU2HPPPbPHMjIy4oADDogvvviiULkyMzOjTZs2MX369KhSpUpERMyYMSMeeOCBuPbaa3O8S6SlpcXAgQPjsssuyzF/3333jU2bNhX6cwBUZPZqSCy9h80rS++phe0//JZfDyK3kryueg9QNiV739mSZDzTep4FKDi9BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEi+yskuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASsPf/va3qF27drLLoAIaOHBg9OrVq0Ryp6amRq9evaJjx45x7LHHxs8//1wi6wBERCxbtiwOP/zwePrpp+OEE07Idb5OnTpx/PHHx/HHH5/r3BVXXJFv/pEjR8ZZZ50Vq1evTki9pWHDhg1x7LHHxrBhw+Kkk07Kdb5JkyZxxhlnFDpvRkZGXHHFFTF06NBElLlFl19+eUREXHzxxbnO1a5dO4455pg45phjCp132bJl0bVr15gwYUKh565duzaOOuqoeP3116N9+/Y5ztWsWTM6d+4cnTt3LlTOQYMGRc+ePSMrK6tA8eX9ugKFVxb2ns3N33PPPXOM/eUvf4kvvviiSPlmzZoV/fr1iwEDBmSP9ezZM7p37x4TJ06MJUuWxLbbbhuHHnpornfjvn37xrffflukdQEqMns1JJ7ew+ZVhPdUPYjcSuK66j1A2ZbsfWdL80vzmTYiPM8CFILeAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACRfarILAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAklavXr0499xzk10GFUxqamo89dRT0atXrxJfa6+99ooPPvggdtlllxJfC9i6LVu2LE488cS4+OKL4+eff05IzoULF0aPHj3i+OOPj5UrVyYkZ2lau3ZtnHzyydGjR49YtGhRsfN98sknsd9++8WQIUOKX1w+Nm7cGJdcckmcc845MX/+/ITkHDlyZOy5554xZsyYIudYvnx5HHHEEdG/f//IzMwscp6ff/45TjvttPjzn/8cGzduLNTc8nxdgaIpC3vPb84999w4//zzc4w9//zz8fjjjxe5roiIe++9N+68884cY3Xr1o0uXbrE//zP/0SXLl2idu3aOc7fdttt8c9//rNY6wJURPZqKDl6D5tX3t9T9SA2L5HXVe8Byodk7zu/l4xnWs+zAAWn9wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABlQ2qyCwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJJ2+OGHR1paWp4xc+fOjfPOOy+aNm0aVatWjUqVKuX4M3DgwFKqlvLizjvvjPPOO6/U1ttpp51i1KhRUbt27VJbE9h6DR48OHbZZZe48MILY+zYsbFp06ZCzV+7dm2MGzcuzj333Nhhhx3iqaeeKqFKS89TTz0VO+64Y1x88cXx4YcfFuo72bBhQ4waNSqOPvroaNu2bcyaNasEK83t+eefj+bNm8f5558f7733XmzYsKFQ8zMyMuKpp56Kdu3axfHHHx8///xzsWvauHFj3HzzzdGyZct44IEHYtGiRQWeO2vWrPjLX/4SLVu2jOHDhxerjvJ8XYHCKwt7z6677hqPPPJIjrGvv/46LrnkkiLn/L1+/frF6aefHrNnz84z7vvvv49TTz01brjhhoSsC1CR2KuhdOg9bF55f0/Vg9i8RFxXvQcoP8rCvlMWnmk9zwJsWVnYpyPs1QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABARkZKVlZVVoMCUlJKuBQAAAAAAAAAAAAAAAAAAAAAAAAAAAACgRBTw17Jvlt/VDgAAAAAAAAAAAAAAUDEMGDAgevfuvcXzmZmZsdtuu8Xs2bNLsSrKs9NPPz1eeumlQs/buHFjLFmyJDIzM6N+/fpRvXr1QucYMWJEnHTSSYWeB/yf/rf2j7S0tLh3wL2xYMGCZJdTLtSuXTv222+/aNOmTWy//fbRsGHDOO2006Jq1aoRETFq1KiYMmVK/Pjjj/HVV1/F5MmTIzMzM8lVl6x69erFwQcfHLvuumu0aNEiatWqFbVq1YqIiKVLl8bSpUtj/vz5MXny5JgyZUpkZGQkZN2HH344LrvssoiIOOmkk2LEiBGFzlGjRo048MAD409/+lO0aNEittlmm6hZs2akpaVFZmZmLF26NJYtWxbff/99TJ48OT777LPYsGFDQurfktTU1Gjbtm0ccMAB0bJly9huu+2iRo0asWnTplixYkX88ssv8fnnn8fEiRPj22+/LbE6knVdtxZ/u/5vUa9evRj0r0Hxww8/JLscKDN7T0moVKlStG/fPjp16hTbb7991K1bN5YuXRo//fRTjB49Ot5///3YuHFjssuklFxx5RWx8847x+OPPx5fzvoy2eUA/5+9umK74IILYvc9do/h/xkeH374YbLLKRf0HjavPPcfIvQgtkT/oeSccuopcfDBB8ebI9+McePGJbsciIiyse+UlD8+02ZlZXme3Up17tI5jjzyyBg7dmyMenNUsssB/j+9BwB+z+9qBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAC2RgX5Xe2VS6EOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABIqt122y3P888++2zMnj27lKqhvKtdu3YMGjSowPHjxo2LoUOHxujRo2Pu3LmRlZWVI1f79u3jhBNOiO7du0f16tXzzXfiiSfGaaedFv/5z3+KVD9AUaxYsSLGjRsX48aNyx5btGhR1K9fPyIi7r///hg9enSyykuKpUuXxsiRI2PkyJGlum6NGjWy/zkzM7NIOdasWRNjx46NsWPHJqqsYtu0aVN89NFH8dFHHyW1jmRdVyA5ysreUxI2btwY48ePj/Hjxye7FAC2wF4NOek9bF557j9E6EFsif4DbF3Kwr5TUjzTApRt9mkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADIX2qyCwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJJWt27dPM9/+umnpVMIFcLf//732G677fKN+/bbb6Njx45x5JFHxmOPPRZz5syJrKysHDErVqyIkSNHxmWXXRYtWrSIF154oUA1DBw4MKpVq1ak+gEo35o3b579z0uWLEliJQAAAEBFpf8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADA1iA12QUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBJq1u3bp7nf/7559IphHKvbt26cdlll+UbN2nSpDjwwAPjnXfeKXDun376Kc4888y4+eab843dcccd4+yzzy5wbgAqhk6dOsXBBx8cERGZmZnxxRdfJLkiAAAAoKLRfwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBrUTnZBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQKJUr149UlNTc41XqVIlz3lVq1aNGjVq5BmTmZkZGzZsyD5OSUmJtLS0zcZmZWVFRkZGrvHtt98+9tlnn6hfv35Uq1Yte3zEiBGxYMGCPNf/vbS0tOjYsWMcdNBB0apVq2jUqFHUqlUrUlJSYtWqVbF48eKYOXNmTJkyJd56661YunRpgXP/XmE/40477RSnnnpqHHTQQbHLLrtErVq1YuPGjbFixYr47rvvYuLEifHqq6/GvHnz8l27bdu2ccIJJ0SbNm1i++23j5o1a0ZGRkYsWrQovv/++3jrrbdi9OjRsWrVqiJ9tqI6//zzt/id/GbevHnRuXPnWLZsWZHW6N+/fzRt2jQuueSSPOP+8pe/xJNPPrnF84W9funp6XHcccfFYYcdFrvuums0aNAgqlevHhkZGfHrr7/GF198Ee+991688cYbsWbNmsJ/sM1o1qxZHHHEEbH//vtHy5Yto06dOlG7du2oXLlyrF69OlauXBmzZ8+OL774IsaOHRsff/xxQtYFKI/OOeecGDx4cKSkpERExDPPPLPZ5w0AAACAotJ/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGtSOdkFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAokyZMiVatWpV6HnDhg3LN6Z79+7x9NNPZx/vv//+MXny5M3Gzps3L3bYYYfs4xNPPDFuvvnmaNOmzWbjv/zyy1iwYEG+NbRq1Sr69OkTZ5xxRlSvXj3P2GOOOSYiIjZu3BijRo2KAQMGxIQJE/Jd4/cK+hnr1asXDz74YJx11lmRmpq62fgDDjggzjrrrLj//vtj2LBh0bt371i4cGGuuPbt28eAAQPigAMO2GJdRx11VFx88cWxfPnyuP322+OBBx6IdevWFeqzFdV5552Xb0z37t1j2bJlxVrnqquuiqOOOiqaN2++xZh999039txzz5gxY8Zmzxf0+tWpUyduuummuOSSSyI9PX2L6x1++OHx5z//OVavXh0PPfRQ3HHHHbF06dJCfKr/c9JJJ0WvXr2iQ4cOkZKSkmfsoYcemv3PP/30U/zzn/+Mhx9+OFauXFmktQHKm9TU1Ljvvvvir3/9a/bY9OnTo1evXkmsCgAAAKhI9B8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADYGqUmuwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgPvvnmmyLNu//+++O1116LNm3aFHntWrVqxaBBg2L69OnRvXv3qF69eoHnVqpUKY4//vgYP358vPrqq9G0adMi17E5HTp0iC+++CLOOeecSE1NLVA955xzTnz++edxwAEHZI+npKTEHXfcERMmTMgxnpc6derEXXfdFRMmTIhtt922yJ+hoLbbbrvYZ5998oyZNGlSjB07tthrZWRkxL333ptv3NFHH12sddq2bRuff/55XH311ZGenl6gOTVr1oy+ffvGjBkz4sgjjyz0mm+++Wa8+uqrcdhhh0VKSkqh5jZt2jTuuuuumDVrVhx77LGFXhtIrN69e8ell14al156acycOTPZ5VRYmzZtihYtWmQfjx07Ng4//PBYuXJlEqsCAACAkqf3UHr0HwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANgapSa7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKA+++eabQs/p379/9OzZs1jr7rLLLjF58uS44oorIjU1tVi5TjrppJg6dWoccsghxcrzm9atW8fIkSOjSZMmhZ7boEGDGD16dOy2224REfHoo4/GddddFykpKYXO1a5du3j//fcjPT290HML48gjj8y3vocffjhh6z3zzDOxatWqPGOOOeaYIufff//9Y+zYsbHDDjsUaX7jxo3jrbfeitNOO63Ac5o1axadO3cu0nq/17Rp03jzzTfj8ssvL3YuoOiefvrpePTRR+PRRx+NefPmJbucCu3cc8+NOXPmxD333BNHH310LFu2LNklAQAAQInTeyhd+g8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABsbVKTXQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJR1y5cvj8WLFxdqzqGHHho33HBDsdZt1qxZvP/++7H77rsXK8/vNWjQIMaMGROHHnposfLUqlUr3njjjUhPTy9yjjp16sTQoUOjT58+cdFFFxWrnt122y0GDRpUrBz5ad26db4xb7/9dsLWW7VqVUycODHPmL333rtIudPT0+OVV16JWrVqFWn+b6pUqRJDhw6N/fffP9/YSpUqxWuvvVas9X4vJSUlHnrooTj99NMTlhOgrFq6dGnsueeecc0118TGjRuTXQ4AAABQAek/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsLVJTXYBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQ1n3zzTeFik9NTY0HHnggUlJSirxmWlpajBo1Kho3blzkHFtSvXr1eP3116NZs2ZFzlGnTp1o2rRpsWtp3bp13HPPPcXOExFx3nnnxUEHHZSQXJuz66675nn+xx9/jIULFyZ0zSlTpuR5vnHjxlGrVq1C561bt25Crl9ERJUqVWLYsGFRrVq1POP++te/xj777JOQNX/v8ccfL5F/TwDKmtWrVye7BAAAAKCC038AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABga5Ka7AIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKCs++abbwoV36RJk2jTpk2x1rzjjjti9913L1aOvNStWzeefPLJEsufLFdddVWJ5W7evHme5z///POErzl9+vR8Y/KrqzTssssu0bNnzzxjLrroojzPb9q0Kb777ruYMmVKTJkyJb7//vtYu3ZtvmvXrl07brzxxkLVCwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbN0qJ7sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABIlKlTp8ayZctyje+3336Rlpa2xXmzZs2KJUuWbPH8uHHjElFegTVv3jz+/Oc/5xu3dOnSeOyxx2L06NExb9682LBhQzRq1Cg6dOgQl156aTRr1izP+UcccUSceOKJMWLEiGLXvGHDhnjiiSdi6NChMWfOnKhRo0a0bt06+vTpE61bty5UroyMjPjXv/4Vr7zySsyfPz9q164dBx10UFx77bWx88475zn31FNPjbS0tMjIyCjGp9m8OnXq5Hk+r3uoqH799dd8Y2rXrp2QtSZNmhSPP/54TJs2LRYvXhzbbLNNtG7dOnr06BHt27fPd37v3r1j4MCBsWHDhlznmjVrFnvssccW5952220xYMCAXP/+Vq5cOTp27BjXXnttHH744bnm/fbvwIMPPphvfQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAL+pnOwCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADg/7Fzp8FZ1lf/wE+ugCxhiSyB8q/1ERA33K1aKY9jW8WRQldbK+PSdqRIFzpSprZIO9bKVMuMWKdWxbHuVjstioq4VEWhqEFRERVlCYKoYTEJgSQkeP9fdKwPldxLCPdVyeczwwuuc37nfK871+tfezn33HN3+fy1116Lgw8+uNVzF198ccyZM2dPxYqIiLq6uvj73/8eDzzwQKxYsSI2bdoUH3zwQUREbNiwYafen//851FaWpp13kMPPRRnn3121NTU7PR85cqVsXDhwpgxY0ZcddVV8cMf/jDrnF/+8pe7/e7vvfdejBkzJiorK3d6vmzZsrj77rvjwQcfjNNOOy2vWW+88UaMHj06VqxYsdPzl19+Oe66665YuHBhDB8+vNXznTp1iuOOOy6efvrpwl8kh7Kysqz12tradt/5n3/fXenRo8du7di+fXtMmjQprrvuup2eV1VVxQsvvBA33XRTjBs3Lm688cbo2rVrq3MqKipizJgxMXv27I/V9ttvv1bPzZ07Ny655JJd1lpaWmLevHnx8MMPx8yZM+MnP/lJRPzrO5k5c2bccsstsW3btnxeEwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4N86pR0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2dnfffXdMmDAhampqcvaWlpbGN7/5zaw9zzzzTIwdOzZaWlpa7Wlubo4f/ehH0bNnzzj33HNb7TvhhBPigAMOiNWrV+fM1tqeMWPGRGVl5S7rLS0tccEFF8TKlSujU6dOWWfV1NTEqFGjoqqqapf1urq6mDhxYjz11FNZ5xx//PHx9NNP55W/EN27d89a37p1a7vvrK+vz9lTVla2Wzt+/OMfxw033JC154477ojm5ua4++67s/aNHj06Zs+e/bHn/fv3b/XMypUrc2bMZDIxefLk6N69e9x7773x4IMP5jwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQmiTtAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsDe77bbb4qyzzoqampq8+keMGBH77rtv1p6JEydGS0tLXvMmTZoU27Zty9ozZsyYvGbtyl133RWVlZVZe95666144okncs76wx/+EFVVVVl7nn766Vi1alXWnoEDB+bc1RYlJSVZ65lMpt135jMzV65sHnvssbjhhhvy6r3nnnvikUceydpzyimn7PJ5Q0NDq2e+8IUvROfOnXPub2lpiQsuuCAefPDBnL0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADZJGkHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAvdW6deti/PjxBZ059thjs9ZffPHFWLJkSd7zampqYvbs2bu1M5s777wzr75nnnmm3WY9++yzWev77rtvXnM+CUpKSvbo/Guuuaag/uuvvz5r/YADDoguXbp87Hl1dXWrZw477LB44YUXYuLEiXHUUUdFjx49CsoEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQqE5pBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgL3VNddcE42NjQWdGT58eNb6woULC86xcOHCGDduXKv1Qw89tOCZH6qsrMyr76233spa37JlSyxfvjyvWWvXrs1a79WrV15zCtXY2Bhdu3ZttZ6t1lb5zGxoaGjz/CeffLKg/gULFmStl5SUxODBg+O1117b6fnSpUtj69atUVZWtstzw4cPjz/+8Y///n91dXWsWLHi3//efPPNWLJkSbzxxhuRyWQKygwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPCfOqUdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA9lbz5s0r+ExFRUXW+ooVKwqemetMrp2t2bFjR2zevDmv3vr6+qz16urqvPdu2bIla72kpCTvWYWor6+P8vLyVuvZam2Vz8xcv21rqquro66uruAztbW10bt371Z7+vbt+7Fnzc3N8cADD8S3v/3tvPZUVFRERUVFnHTSSTs9r62tjXvvvTdmzZoVCxcuLCg7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAh5K0AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwN7q9ddfL/hMz549s9Zra2sLnllTU5O13qtXr4JnRkTU19fn3fvBBx8UbdaekitjeXl5u+/MZ2Yhv93/9f7777fpXK7vqaysbJfPL7300mhpaWnTzg/17t07zjvvvFiwYEHcd999MWDAgN2aBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAdExJ2gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBvtG3btti+fXvB57p06ZK13tTUVPDMXGe6du1a8MyIiEwm06Zze3rWnrJmzZqs9WHDhrX7zoMOOihnT1VVVZtmNzc3t+lcY2Nj1npr3/Brr70WF154YZt27srYsWPjueeey+s3AgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+L+StAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDeaPv27WlHoJ0tX748a/3ggw+OHj16tOvOE044IWu9pqYmNmzY0KbZJSUlbTq3O2688cZoaGhot3mf+cxn4oEHHohevXq120wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGDvl6QdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+EhjY2PWeteuXQuemetMQ0NDwTM7omXLlmWtJ0kSI0eObLd9paWlMWLEiKw9r776apvn77PPPm06l+t7ampqylo/9NBD49Zbb43m5uY27f9PQ4cOjd/85jftMgsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOgYkrQDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAH9myZUvWeu/evQueWV5enrVeV1dX8MyO6PHHH8/ZM378+HbbN3bs2BgwYEDWnnwytaZPnz5tOpfre9q6dWvWelVVVZx33nlRUVER3/3ud+PPf/5zLF26NJqamtqUJ+Jfv3uuXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB/qlHYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgI++++27W+rBhwwqemetMrp38y4oVK2LNmjWx//77t9ozZsyYGDp0aKxYsWK3902ePDlnz7x589o8v2/fvtGvX7/YuHFj3mcqKiqid+/eWXs2bdqU16yampq4+eab4+abb46IiJKSkhg0aFAMGTIkBg8eHEOGDIkhQ4bEcccdFwceeGDWWd26dYsvfvGL8be//S2v3QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQMeWpB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD4yNKlS7PWR44cWfDMXGeWLVtW8MyO6q9//WvWemlpadx+++1RWlq6W3smTZoUI0aMyNqzbt26WLRo0W7tGTVqVEH9ub6lTCYTq1atalOWTCYTb7/9djz11FNx8803x7Rp0+Lss8+OYcOGxUknnRTvvPNO1vOf/exn27QXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADoeJK0AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB+prKzMWj/ssMPixBNPzHte//794ytf+UrWnueeey7veR3dtddeGx988EHWnhNOOCGuv/76SJKkTTvOOOOMuOKKK3L2/elPf8qZJZeLLrqooJwTJkzIWl+5cmU0NTXlnFNWVhbdu3fPe++iRYti6tSpWXv69++f9zwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKBjS9IOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfOTZZ5+N6urqrD3XXXdddOnSJa95uXozmUzcf//9BWXsyFavXh333Xdfzr7vf//7MWfOnKioqMh7dpIkMWnSpJgzZ07Ov299fX3MmjUr79mtOeaYY+LXv/51Xr3jxo2LL33pS1l7nnjiiZxzpkyZElVVVXHVVVfltfdDr7/+etZ6165dC5oHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB0XEnaAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgI9kMpm48847s/YceeSR8eijj8bAgQNb7SkrK4vbbrstvv71r2ed9eSTT8b69evblLWj+tnPfhZNTU05+0aPHh0rV66M3/72tzF8+PBW+/r27RvnnHNOvPLKKzFz5swoLS3NOfuyyy6LDRs2FJS7NdOmTYvp06dHkiSt9lxwwQVx00035Zx1//33t1rr1q1bXHTRRXHllVdGv379Yvz48TF58uS8c5500klZ6+31ewAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHu/TmkHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAdvb73/8+Jk6cGPvss0+rPSNHjoyVK1fGrbfeGg8//HCsXbs2duzYEQMHDoyTTz45vve970VFRUXOXdOnT2/P6B3CqlWrYvr06XHppZfm7O3Ro0dMnTo1pk6dGuvXr4/Vq1dHdXV1NDU1Rb9+/eJTn/pUHHLIIZEkSd77X3311bjqqqt25xV2UlJSEr/4xS/izDPPjFmzZsXixYtjw4YNse+++8bRRx8d55xzThx77LE556xfvz7mzp37sef77LNPTJw4MS6++OIYMGDATrUZM2bEqFGj4uqrr4758+dHfX39x87vt99+cd5558W0adOy7l+3bl3OjAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABERndIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA7Gz9+vXxu9/9Ln71q19l7evevXtMmDAhJkyY0KY9c+bMiccee6xNZzu6yy67LD73uc/F6aefnveZQYMGxaBBg3Zrb21tbXz1q1+N5ubm3ZqzK0OHDo0rrriizeevvPLK2LFjx8eed+7cOaZOnRr9+vXb5blTTz01Tj311IiIqK6ujpqammhubo4uXbpEv379ory8PK/9vmUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBfSdoBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAj7vsssvi+eef32Pz33333Rg/fvwem7+3y2QycdZZZ8WSJUuKtrOhoSHOPPPMePPNN4u2M1/Lly+Pa6+9dpe1rVu3xuWXX57XnIqKihg2bFgcdthhMXTo0CgvL8/r3Ouvvx4vvvhinmkBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICOLkk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8HEtLS1xxhlnxOrVq9t9dn19fZxxxhnx3nvvtfvsjqS2tjZOPvnkmD9/flF2nXbaafHoo4/u8V2FamxsjG9961vR3Nzcas/MmTPjkUce2WMZLrzwwj02GwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2PskaQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB2rbq6OkaMGBHPP/98u81ct25djBw5MpYsWdJuMzuyLVu2xKmnnhrTp0+PHTt27JEdCxYsiGOOOSYWLFjQrnPr6+vjoYce2q0ZTU1N8bWvfS1efvnlnL3f+MY34vHHH9+tfbsyZcqUePLJJ9t9LgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsPdK0g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC07p133okRI0bE5ZdfHtu3b9+tWbfcckscddRR8eKLL7ZPOCIiorm5OaZOnRonnnhiPPLII+02d+3atXHhhRfG//7v/8aqVavabe6HWlpaYuzYsfGXv/ylTeerqqrilFNOiXnz5uXVX19fH6effvpuf8cf2rhxY4wbNy5mzJjRLvMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICOI0k7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkF1TU1NccsklMWzYsLj66qujpqYm77MNDQ1xxx13xNFHHx3nn39+bNq0ac8F7eAWL14co0aNiuOPPz5mzZoV1dXVBc9obm6Ohx9+OM4///wYPHhwXHfddZHJZPZA2n9paWmJ73znOzF69OhYvnx5Xmc2b94c06ZNi8MPPzwWLVpU0L7m5uY46KCDYsaMGbFhw4a2RI4333wzLr300hgyZEjceeedbZoBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB0bJ3SDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHvaIYcc0u4zn3vuuSgpKWn3udmsWbMmfvrTn8bkyZPj85//fJx44olx+OGHx8CBA6NXr16RJEnU1dXFpk2bYtmyZVFZWRn/+Mc/orGxsU372vMd77nnnrjnnnvaZdb06dNj+vTp7TJrT6isrIzKysr4wQ9+EMcee2wcccQRcfjhh8f+++8fPXv2jN69e0dpaWls2bLl33+vV155JV555ZVYtGhR1NXVFT3z3LlzY+7cuXHkkUfGl7/85TjkkENiwIAB0adPn2hoaPh3xgULFsSjjz4aLS0tbd5VVVUVU6ZMiSlTpsSRRx4ZI0aMiAMPPDAGDx4cPXv2jB49ekTnzp2joaEh6uvrY8uWLbFq1apYunRpPP/887Fs2bJ2fHMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAj6pR2AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoDA7duyI+fPnx/z589OOQhaZTCYWL14cixcvTjtK3l566aV46aWX9tp9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAERFJ2gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgWJK0AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECxJGkHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgGJJ0g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxZKkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACKJUk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABRLknYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKJYk7QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQLEnaAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKBYOqUdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgPa3cePGuP3221utb9u2rYhpAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/nt0SjsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA7W/VqlVxzjnnpB0DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgv06SdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoliTtAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAsSdoBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoFiStAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAsSRpBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBiSdIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMWSpB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiiVJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUS5J2AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACiWJO0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUCxJ2gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgWJK0AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECxJGkHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgGJJ0g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxZKkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACKJUk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABRLknYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKJYk7QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQLEnaAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKBYkrQDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQLEkaQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAYknSDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADFkqQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIolSTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFEuSdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoliTtAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAsSdoBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoFiStAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAsSRpBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBiSdIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMWSpB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiiVJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUS5J2AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACiWJO0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUCxJ2gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgWJK0AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECxJGkHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgGJJ0g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxZKkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACKJUk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABRLknYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKJYk7QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQLEnaAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKBYkrQDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQLEkaQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAYknSDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADFkqQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIolSTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFEuSdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoliTtAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAsSdoBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoFiStAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAsSRpBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBiSdIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMWSpB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiiVJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUS5J2AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACiWJO0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUCxJ2gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgWEoymUwmr8aSkj2dBQAAAAAAAAAAAAAAAAAAAAAAAAAAAABgj8jzWvZdclc7AAAAAAAAAAAAAADkNn78+LQjAAAUZPCQwVFaWhpr1qyJ7U3b044D0GH8zwH/E507d461a9dGY0Nj2nEAOoxP7/fp6NatW7z99tuxbeu2tOMAdAiDBg2Ksh5lUf1eddTW1qYdB6DD6F/RP8rLy2Pjxo3x/ub3044D0GH07dc3+vTpE5s3b45NGzelHQegQ1n26rJYuGBh2jGATwB3tQMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHVE+d7WXZPK80d3l7QAAAAAAAAAAAAAAAAAAAAAAAAAAAADAJ1We17LvkrvaAQAAAAAAAAAAAAAgt9/P+H3aEQAAAAAAAAAAAAA6lH/+858x+++z044BfAK4qx0AAAAAAAAAAAAAAAAAAAAAAAAAAAAA6Ijyuau9JJPnje4ubwcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPqnyvJZ9l9zVDgAAAAAAAAAAAAAAuR1xxBFpRwAAKMin9/t0JEkS76x/J5qbm9OOA9BhDPp/g6JTp07x7rvvxvam7WnHAegwBgwYEF26donq6upobGhMOw5Ah9C/f//o1r1bbN68Oeq31KcdB6DD6NOnT/To2SNq3q+Jurq6tOMAdBjl5eXRq3evqKuti5qamrTjAHQomzZtirfffjvtGMAngLvaAQAAAAAAAAAAAAAAAAAAAAAAAAAAAICOKJ+72ksyed7o7vJ2AAAAAAAAAAAAAAAAAAAAAAAAAAAAAOCTKs9r2XfJXe0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAwCeVu9oBAAAAAAAAAAAAAAAAAAAAAAAAAAAAgI4on7vakyLkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgP8KSdoBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoFiStAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAsSRpBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBiSdIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMWSpB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiiVJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD8f3bnmAYAAAAB0Gb/0LbQBxIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAyt6dB+lV3XfC//bT6kVba0UrkkD7voAEErttMJsEGMzuJQZsJ3njVKoS562aeeePmVRlZqrimczEceK8sT32QGJcCXYwxjDGGGzMvkhCGwJJBiQhtKC1Wy21uvv9Qy8PtNDS3ep+npb4fKpU9Zz7nHvP7z733nPuOff2EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJRKodwBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQKkUyh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlEqh3AEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAqRTKHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUSqHcAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECpFModAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJRKodwBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQKkUyh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlEqh3AEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAqRTKHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUSqHcAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECpFModAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJRKodwBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQKkUyh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlEqh3AEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAqRTKHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUSqHcAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECpFModAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJRKodwBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQKkUyh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlEqh3AEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAqRTKHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUSqHcAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECpFModAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJRKodwBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQKkUyh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlEqh3AEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAqRTKHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUSqHcAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECpFModAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJRKodwBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQKkUyh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlEqh3AEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAqRTKHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUSqHcAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECpFModAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJRKodwBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQKkUyh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlEqh3AEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAqRTKHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUSqHcAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECpFModAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJRKodwBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQKkUyh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlEqh3AEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAqRTKHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUSqHcAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECpFModAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJRKodwBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQKkUyh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlEqh3AEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAqRTKHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUSqHcAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECpFModAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJRKodwBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQKkUyh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlEqh3AEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAqRTKHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUSqHcAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECpFModAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJRKodwBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQKkUyh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlEqh3AEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAqRTKHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUSqHcAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECpFModAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJRKodwBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQKkUyh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlEqh3AEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAqRTKHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUSqHcAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECpFModAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJRKodwBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQKn0KncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnLpmzZqV2t61SZKGhoasXLGyS/KWWr9+/TJt+rRi+s3fvZmtW7eWMaLT57ftCSorKzN27NiMGzcu/fr3S21NbVLxwfdPPfVUtryzpXwBAvRwgwcPzoSJE4rp19e+nl27dp10XjhZzreeyXEB3jdgwIBMmDAhZww7I3369EllZWXxu53v7cwvf/nLMkYHnIp64hheqRnngvIyFs+pTBsCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPBRvcodAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJzOKiqT6t7ljuLkHTqQNDeVOwrgdDRmVjJyarmjAAAAAAAAAPh4qaioKH5ubW096e1ddfVVGTZsWJJk06ZNWbliZZfkLbWhQ4fmlltuKaZ//MCPs3Xr1jJGdPr8tuW2cOHCXH7F5RkwYMAx86xYsSJb3tnSZtn06dNTWVmZJDl06FBWr17drXECh7n2SmfIkCEZNWpUMb1p06a89957R807ZsyYNu3k9773vezateuk83YkBjiajpxvlI7jUnof7ud1heP1FTtSVlf0OY+lsrIyY8aMyciRIzN4yODU1NSkUCjk4MGDadzfmK3btmbTxk3Ztm1bt8XQUT3ltyuFQYMG5brrr8uMGTOOud9vv/12fvnLX5Y4MnqKrh6f4uOjI2N4p2N/o7PjXMDxdWQ8qiNj8afzONfpWMee7krVhhx5/99V93ruH7tfRUVFRo0alVGjRmXIkCGpra1Nr6pebfrZmzdtLsnz03Id7+4ot6NjNs5vAAAAAAAATlfmagc4PnO1AwAAAAAAAAAAAAAAAAAAAAAAAAAAwOnJXO0Ax9eT5mrvVe4AAAAAAAAAAAAAAAAAAAAAAAAAAAAA4HQ2YEry2T9NUlHuSE7Os/+crPhFuaMATkdnz08W3lruKAAAAAAAAAA+Pr7wxS9k1qxZSZKmpqb8xX/6i+zfv7/MUUH3+cyNn8kFF1zQqXVvu/229O7dO0myZ8+e/MV/+ouuDA04Btde6UybNi3X33B9Mf0v//Ivee7Z5z52MQCc6s4444z8+f/95122vRUrVuT7/+v7XVJWS0tLDhw4kIaGhmzZsiVvv/12Vq5cmS3vbOl0fEOHDs1ln7gsc+bMSW1t7Qnzb9++PS88/0KefvrpNDY2drrcrnDHHXdk7ry57crb2tqaAwcOpLGxMdu3bc+mzZvy+trXs3bt2rS2tnZvoCdp+Ijh+f2v/n769e9X7lDooUaMGJE//bM/LaZ/9fiv8vDDD5cxIk5Xp1t/42TGuYDj667xqNN5nOt0q2NPd6VsQz7c79m3d1++8Y1vZN++fSe1zanTpubuu+8upr/3ve9l1cpVJ7VNPjBgwIBceumlmTN3Turq6k6Yf/v27XnxxRfz26d+2y397HI9z+6ufkpHxgKSw/u8f//+7N69Oxs3bsyGDRuy4tUVaWpqOulYAAAAAAAAoJzM1Q5wfOZqBwAAAAAAAAAAAAAAAAAAAAAAAAAAgNOTudoBjq8nzdXeq9wBAAAAAAAAAAAAAAAAAAAAAAAAAAAAwOmssiYZNDqpOMUnb6/pV+4IAAAAAAAAAAA4Wf3798/06dOL6aqqqpx77rl56qmnyhgVdJ958+blggsuaLPs3Xffzbp161JfX5+Wlpbi8u3btpc6PAAgyahRozJkyJBi+tVXXy1jNCQfPSYrV65sc98EHVEoFNK7d+/07t07Q4YMyYwZM3LVVVfl7bffzkM/fSjr16/v0LauvOrKXHbZZSkUCu1eb+jQobn6mqtzyaWX5IF/fSDLly/vzK6UXEVFRWpra1NbW5uBAwdm4qSJufTSS7Nnz548+cSTeeqpp3rktVlZWZnPf/7z6df/gz9EaWpqymtrXsvWbVvT1NRUXL5nz55yhFh26tlk4aKFbdILFizIo48+mubm5jJFBD2fcS6gK7kf+XgpZxvSr3+/3HLrLfnud77bpdula1RUVOSKK67IJz75ifTq1avd6w0dOjRXXXVVLrnkkvz4xz/O0leWdllM5Xye3VP6KVVVVamqqkpdXV3GjBmTRYsWpbGxMc8991weffTRNB1sOvFGAAAAAAAAoAcyVzsAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8HFkrnaAU0evcgcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABA91uwYEEqKyvbLFt0waI89dRTZYoIutenr/x0m/QD//pAnnnmmTJFAwAczcJFC7No0aJi+ut/9vUyRkPy0WPyH/6f/5DGxsYyRsTpaMyYMfn9P/j9/OY3v8lPH/zpCfNXVlbm9770e5k6depHvjt06FC2b9+ehoaGNDc3p7qqOv3r+mfQoEGpqKgo5uvbt28+/4XP59FHH81jv3isS/enlOrq6rLkuiU559xz8p1//E727t1b7pDamDNnToYPH15Mb9q0Kd/9znezZ8+eMkbVs3zc69mqqqqcc845bZb1698vM2fOzLJly8oUFfR8xrmArvRxvx/5uCl3GzJt2rQsWrRIu9XD1NTU5Et3fSkTJkw46vf19fXZt29fDjQeSFV1Verq6tK3b982efr06ZM777wzZ44+Mw899FCXxFWu59k9vZ9SW1ubSy+9NLNnz853v/vdbHlnS7lDAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADit9Cp3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHSvioqKnL/w/I8sHzZsWM4+++xs2LChDFFB9xkzZkyGDh1aTL/80st55plnOrSNre9uTU1NTZKkvqG+S+MDjs21Vzr1DfXZ8s6WYnr//v0fyxgATjevvfZaHvvFY51ev6GhocvKquxVmdqa2gwdOjRnn312pkydkl69eiU53E+95JJLUqgo5N/+7d+OW84Nn7khU6dObbNs+fLlefrpp7Nh/Ya0tLR8ZJ3a2tpMmz4tl112WUaNGlVcfuWVV2bf3n159tln272f3eXe/31vdu/efdTvCpWF1FTXZODAgRk9enSmTZ+Wurq64vejR4/OH/zhH+Sbf/PNDh2z7jbvnHnFzy0tLbn3f9+bPXv2lDEiepo5c+ekd+/eH1m+cNHCLFu2rAwRcTo7XfobXTHOBRxfd41Hnc7jXKdLHXu66yltyJLrlmTdunXZunVrycvmo6qqqvKVr3wlY8eNbbN806ZNefrpp7N61ers3bv3I+vV1dVlxowZufiSi3PGGWcUl1962aVp2N+Qx3/5+EnFVc7n2aXspxxvLKCioiLV1dXp169fRo0elenTp7e5hgcNGpSvfvWr+dbffivbtm3r0rgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPs56lTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAutfkyZMzePDgYrqlpSWFQiFJsmjRomzYsKFcoUG3GDduXJv0iy++2OFtfPOb3+yqcIAOcO2Vzisvv5JXXn7lYx8DwOmmfl99fve73/W4sp588sn07ds31157bRact6C4/KKLL8rKVSvzxutvHHW9M888M+dfZNtdAAEZFElEQVSff34x3dTUlH+675+yYsWK45bX2NiYV15+JUtfWZorPn1FrrjiiuJ3111/XV5//fXs2LGjXbF3l40bN7Y7hoqKisyfPz9LrluS3r17J0nOOOOMLF68OD/60Y+6M8wO+XBf7K233sr27dvLGA090aKFi4qfPzw+NXHixAwdOtQ5Q5c6XfobXTHOBRxfd41Hnc7jXKdLHXu66yltSFVVVe648478zf/8mzQ3N5clBj5w4003Zuy4scX0oUOH8uC/PZhnn302ra2tx1xvz549eeaZZ/Lcc8/l6muuzmWXXVb87sorr8za19Zm48aNnY6rnM+zS9lPae9YwEsvvZSfPvjTTJ8xPTfeeGMGDBiQJOnXr19uvuXmfOtvv9VlMQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB83BXKHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADda+HChcXPW7ZsybKly4rpWbNnpU+fPuUIC7pN3YC6Nul33323TJEAAADvq6+vz49+9KM8/vjjbZZfc801x1xn4aKFqaioKKYf/tnDWbFiRbvLbG1tzf959P/kiSeeKC6rqqrKpz71qfYH3gO0trbmhRdeyN996+/S1NRUXD5/wfwMGTKkjJF9oFevXundu3cxrR/GkUaMHJGx48YW048+8mib7xcuWnjkKkCMcwHQeT2pDRk9enSuvOrKspXPYVOnTs38+fOL6UOHDuX7/+v7eeaZZ9La2tqubbS0tORnD/0sj//yg759oVDI9Tdcf1Kxlet5dk/vp6xauSrf/JtvZs+ePcVlZ599dqZOm1rGqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABOL4VyBwAAAAAAAAAAAAAAAAAAAAAAAAAAAACns6peSf17yc53kp2bk707kv17k6bGpLkpaT6UtLaWO0oAAAAAAAAAAE5n/fv3z7Tp04rp5597Ps89/1wx3atXr8yfP78coUG3qampaZM+ePBgmSIBAACO9Ogjj2bbtm3F9JgxYzJw4MCj5h0/fnzx84EDB/Lss892qsxHfv5Idu7cmT179uTRRx/Nz3/+805tp9zeeeedPPnEk8V0RUVFZsycUcaIPlBTqx/G8S1atKj4ub6+Pk8++WTWr19fXDZ//vxUVlaWIzTo0YxzAdBZPaEN2bt3b/HzpZdemvETxh8nN92poqIii5csbrPsoYceypo1azq1vUceeSSbN28upseOHZthw4Z1alvlfJ59KvRTdu3alYd/9nCbZbNmzSpTNAAAAAAAANA55moHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD6OzNUOcOroVe4AAAAAAAAAAAAAAAAAAAAAAAAAAAAA4HRQqEyqapOBI5PRM5MRk5Lhk5LVTyTfuuOIzBVJZVXSu39SNywZMSUZPT0ZNDoZMDyp7ZdUVJRjLwAAAAAAAAAAOB2dd955qaysTJIcOnQoL730UhoaGrJjx44MGTIkSbJw0cL8+te/LmeY0KUqvIQFAAA9VktLS5YtXZbLr7i8uOzs8WfnlZdf+UjeAXUDip+3b9+eQ4cOdarM5ubm/MO3/yHvvfdeWlpaOrWNnmLpsqVtfrszzzyzjNF8oCJH9MNayxMHPVNVdVXOOeecYvqll15Kc3Nznn/u+YwfPz5J0rdv38yePTuvvPLRugA+zoxzAdBZPaENuf+H9+eeL9+TJCkUCrn99tvzjb/6RhobG8sc2cfPpEmTMnz48GL6rbfeytO/fbrT22ttbc1jv3gsF19ycZYtXZbly5dn7969ndpWuZ5nn0r9lOXLl+emz96UqqqqJCnGBwAAAAAAAD2NudoBAAAAAAAAAAAAAAAAAAAAAAAAAAAAgI8jc7UDnPp6lTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOFVV9zk84fqomcnEBcmo6Ul1bduJ19e0HmXF1qT5YLJvx+F/m1cnL/8kqemXDBh5eCL36Z9MRkxMKs0kDAAAAAAAAADASaioqMj5C88vpletWpWGhoYkyQvPv5Crrr4qSXLGGWdkwsQJWffGurLE2R0KhUImT56cyVMmZ8SIEenTp0+SZP/+/dnyzpasXr06a9eu7ZKyKisrM3ny5EyaNCnDRwxPnz59UllZmQMHDmTnezvz1ltvZeXKldm5c2eXlNeVBgwYkBkzZmTM2DEZPHhwamtrU5GK7G/cn7179+atN9/KmjVrsnXr1nZvs3///hk5cmQxfeTv3L9//4wZOyYDBwxMdU11kuTN372ZDRs2dGofBg4cmGHDhn1k2YdNmjQpBw4cOOY2Nm7cWLw23nfWWWeluvpwfAcOHMibb77Z7pgKhUImTZqUKVOntDn/Ghsbs23rtrz+xutZtXJVDh06VFxnzNgxqSxUJkl27NiRvXv3HnXbI0eOTP/+/Yvpjp7HQ4cOzeDBg4vpDRs2pKmp6ah5P/wb7NixIzt27Ch+V1FRkTPPPDMjRoxIbe/aVFYejv2JXz3Rrjhqa2szY8aMnH322Rl6xtDU1tYmOfwbbd26NevWrcvqVatz8ODBDu3f+yZMnJBJkyZl1MhR6dO3T2qqa3Ko+VAaGhqy9d3D23/ttdeOue9dqVAoZPyE8Zk8+XB91K9fv1T1qkrToaY0NDRk29ZtWb9+fVavXt3mnDiezlxn7T02Y8aMybTp0zJq1Kj0798/VVVVaTrYlD179mTjxo1ZuWpltryzpX073wkdufaOd44OGDAgc+bMybizxmXggIGpqq5KY2Nj9u3blw3rN2TFyhXZ+V731cvHi23M2DGZO3duRo8enT69+6S5pTn19fXZtGlTXl3+ajZu3HjM7dbV1WXuvLkZf/b4DBg4IIVCIQ31Ddm+fXvWrFmT1atXp6WlpV0xHnkebdq8KfX76ju5x51zsjF0VxtcznOrJ9VfSdf+xsOGDftIG31kevLkycdcf926dWlubu5Q/JMnT860adMyYsSI9O7TO0lSX1+fbVu35bW1r+W1Na+1+5o5mu5oz7qz/T1Se47Jie6jetpxKXW7W1FRUdyf4SOGp3fvrj/PTldbtrS9n+jfr/9R8xUqC8XP7T1mx7J9+/aTWr+neG/He23SH+4fnEhX1lsTJ05MofDB8Xm/3/O+QYMHHbde39+4P2+/9fYJy+nq+9NS9llLWc/29LGJuXPmFs+3JHn+ueeTJMuXL88Nn7mh+N3CRQvzyiuvdHj7J6qrJ02alKnTpmbkiJHFtqexsTHvvvtuXl/7etasWdOhOuZ47XVdXV1mz56ds846K4MGDUpV9eFzdvee3Xn7rbezYsWKbNu2rcP7+GHtuZaXLV3Wrm2Vu53rzjG89vQ3jszT3Nycdes6NkY6adKkVHzojwrXr1/f6Taru8a5jlSOvlRX38t+WHfW7d09hpUkvXr1yuTJkzNx4sSPHo+dO/Pm797M8uXLjzle2B6DBw/OjBkzMnbs2AwaNCjVNdVpbj48HvHuu+9m7Wtr8/rrr3foei53/TF06NBMnz49Z445M4MGDUpNdU2aW5rT0NBQrD/WrVuX1taj/aFvWyczFtwd2+3Kfk133Y/0xDGdcp+TndGV12ap2pCOeu211/Lb3/42F154YTGmmz57U+67974uLedEuroePBXPt/POO69N+sknnmxXHXk8r776al599dWT2kY5n2d3dz+lKzU1NWXnzp3F67wjYwEncio8zzia7r5P645xxiN15fOAD4/BHHkc2+PD6+/Zu+eYYy2n8r133359M2vmrIwdN7b4bkShopCDBw9m586d2bhxY1avXt2hdyMAAAAAAIDDzNUOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHwcmasd4PSiygUAAAAAAAAAAAAAAAAAAAAAAAAAAIAOGjAimXRRMv7cZMTkpKZv2wnbO+vAvmTr68nWN5KVjyVnTEjOvzmZsKBrtl9qlZWVGTJkSAqFwkltp7W1NS0tLWlpaUlTU1P279+fpqamTm2rf//+qa6uPmG+/fv3p6GhoVNlJElVVVXq6upOmK++vj6NjY3FdKFQyKBBg0643r59+3LgwIFOl3s07//Ozc3NOXDgQJqamtLaerT/faDjevXqlQEDBpww3+7du3Po0KGTKqt///6prKxsd/7W1tbs3bs3LS0tJ1UuAAAAAAAAAPRUkydPbvM+wvPPPV/8/OKLL+bTV366+H7HooWLsu6NdSWPsTvMmzcvV19z9THfxZg4cWIuuviivLP5ndz3T/fl3S3vdrqsioqK/Lt//++O+d7GWWedlXnnzMt111+XFStW5KGfPpT33nuv0+V1lbq6uixevDhz5s457js+c+bMyZLrlmT1qtV54IEHsmvXrhNue/z48fnc5z9XTH/9z76eJBk0eFBuuP6GTJ029SNlPvbYY9mwYUOn9mXmzJm5/obrj5vnC1/8wnG//8ZffeMj7wzdfMvNGTZsWJJk06ZN+ev//tftimf27Nm59tprM3jI4KN+P2HChCxctDB79uzJQw89lFdefiVJcvfdd6dv375Jkh8/8OM8/fTTR13/k5/8ZObOm1tMv//7tte588/N5ZdfXkz/l//8X7Jjx46j5v3wb/Doo4/msV88liRZtGhRLr/i8qOe908+8eRx3z2qrq7Opz/96Sy6YNEx3+eaMGFCFi1alIaGhjzxqyfy5JNPtvsdn6nTpub666/P0KFDj5ln8uTJuejii9LQ0JBf//rXeeJXT6S5ubld2++oc845J1dedWUGDz76+ZAkU6ZMyUUXX5S9e/fmF//nF3nmmWdOuN3OXGdP/OqJ429zwvgsWbIkZ5555jHzzJw1M1ddfVXeeOON/OQnPzmp+vNYOnLtHe0crayszDXXXpMLL7zwmO+TzZo1K4uXLM5LL76UBx98sM27fN2xH+/HVl1dnVtvuzWzZ88+6jpTpkzJJz/5yaxZsyb3//D+7Nu3r833n7r8U7n88svTq1evj6w7cdLELFy0MNu2bcu//Mu/ZP269SeM8cjz6Hvf+15WrVzVkd08aZ2NoaKiIhdccEE++alPdksbXI5zq6fVX93xG19wwQW58KILj1vul7/y5aMub2pqyr//d/++3fEPHz48d9x5R0aNGnXU7ydPnpwLL7ow27dvz4MPPpjVq1a3e9tJ97Zn3dH+Hkt7jsnx7qN62nEpdbs7bty43HzLzRk+fHi37M/p7sj77/fvhY+W7/3zvrPvy59ujvybipqamhOu0x311he++IX07t37mN/PnDkzM2fOPOb3r776an7w/R8c8/vuuj8tZZ+1FPVsd98XdZWFixYWP7/15lt5993Dx6qpqSlLly7NwoWHvx8/fnyGDRuWrVu3dmj7xzquo0ePzm233ZYRI0ccdb0JEybkggsu6FC7kBy9va6oqMjV11ydiy+++Kj37Mnh+8Vrrr0mq1atyk9+8pPsfG9nR3azQ9fy4EGD23X/Uc52rrvH8NrT32hsbMz1N1xfPJ5Jcu+992bZ0mXtKuOCCy7IZ278TDG9bOmyrF27tkNxflh3jXO9rxx9qaR77mU/rDvq9u4ew0oO/z3hJZdckksvuzT9+vU7ap6zzjor8+bNy5LrluSZp5/Jwz9/OE0H2//3lUOHDs3iJYszffr0VBzjD1WnTJmSSy65JLt3785jv3gszz77bLu23RX1x3/9L/+13fvyvhEjR2Tx4sWZMmXKMfNMnjw5l1x6Sd599938+Mc/PuGzj86OBZ9IZ7bb1f2a7rof6YljOqdS3607rs3ubkNOxkM/fSgTJ04sHoO5c+dm1apVxecj3am76sFT6XxLDl97kyZPKqYbGhqycuXKkpR9IuV8nt3d/ZSu9uHrs6amJpWVlV0yPnwqPM/4sFLcp3XXOOP7uuN5wIfH1j98L94eFRUVbdZ/+aWX88///M9HzXsq3nv37t071157beYvmH/M5zvjzhqXufPmZvGSxVm3bl1++uBPs2nTpnZtHwAAAAAAPs7M1d4+5mo3V/v7zNUOAAAAAAAAAAAAAAAAAAAAAAAAAAAAcHowV3v7mKvdXO3vM1c7p4qP/s/sAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEcUKpPhk5MLP5+MmpzU9EkqjpgfurU1aTmUNO5NDjQkB/Ynrb2Smn7//+TrrUlzc9LclLS2HP53VK3Jwfpk0/LkgVeTM85OFt2ejJub9O7cvNxlMWbMmDzyyCPtmoy8PVpaWtLa2pqDBw9m165defXVV/PQQw/l17/+dbZt29auSb///M//PPfcc88J87300ktZvHhxp2P94he/mP/4H//jcSeub21tzZIlS/LSSy8Vl40YMSLPP//8cScfP3ToUL7+9a/nhz/84Ue+u/jii3Pfffd1Ou7W1ta0tramqakpBw8ezDvvvJOlS5fmN7/5TZ566qls3769U5Orn3/++bn//vtPOKn61VdfnaVLl3Yy+mT06NF58skn06dPn3av09jYmFtvvTUvvPBCp8sFAAAAAAAAgJ5s0aJFxc+7du3K2rVri+ndu3dn7dq1mTp1apJk5qyZ6duvb+r31Zc8zq5SKBRy8y03Z/78+e3KP3LUyPzxH/9xfvjPP8zevXs7XF7v3r3zxd/7YurqTvxiT0VFRWbNmpUpU6bk/h/en+XLl3e4vK5y1lln5Ut3falD71lMmz4tfzLuT/KP/+8/ZuPGjR0uc9CgQfmjP/qjdv1Wpdba2prt27d3ybZu+MwNufDCC9uVt66uLnfccUeGDRuWRx95tEvKL4Vrrrkmn/jkJzq17tChQ3P3PXdn6NCh7crfp0+fXHPtNZk6bWq+993vpbGx8bj5L7/i8lx55ZXtjqdPnz656qqrMnPmzHznH7+Tffv2tXvdEykUCrntttsy75x57V6nf//+ufGmGzNm7Jj86P4fdbjMk7nOrrzqynzqU59KRUVFu/JPnDgxf/Inf5L7f3j/Sb331dWqq6tzz5fvydlnn33CvIVCIQvOW5BxZ43LP3z7H7J79+5uja1379655557Mnbc2BPmnTp1ar72ta/lm9/8Zvbu3ZuKiop89ubP5rzzzjvhumeccUa+/OUv575778uKFSu6IvQe5/32d8KECe3K3xVtcHefWz2p/krK8xufyNatW9Pa2tquvFOnTc3nPve51NTUnDDv0KFD86UvfSkP/+zhPPHEE+3afne3Z0dzMu1vd+opx6Uc7e7sObNzxx13nPAd6aRz59nHwZH3Hcc6l7Zv3168vxk0aFBGjRqVzZs3d3t8PVmvXr3apE/0nn856q322LZ12zG/K/X9aU/ts56onu2JbfbRjBo1KmPHfnAf/Nzzz7X5/vnnns/ChQuL6YWLFubBf3vwpMudNWtWbrv9tlRXV58w7/vtwpQpU3Lvvfd2+O9namtr84UvfCGTJk9qV/7p06dn/Pjx+cH3f5DXX3+9Xet09Fo+meu4u9u5Uo/hHU9TU1P+6b5/ytf++GvF/b3xxhuzft36E5Y1ZMiQXLv42mJ6165d+dd//dcuja+jjjfOVa46o1z3sidTt5ei7ezfv3++dNeXMmbMmHaVUVlZmYsuviiTJk/KP3z7H7Jnz54TrjN33tzccsstqaqqalcZAwYMyE2fvSmzZ8/OD37wg07dA3S0/rjssss6dI+8aNGiXH/D9e3afpIMHz48X/nKV/LQQw/lN7/+TbvLKYdy9GvaoyP9vhMpRz3UE/tu5bg226Mrn5Uc6dChQ8X29v3+zI033pjfbfhddu7c2S1lJqX/rXvi+fa+kSNHtnkuuH7d+jQ3N3d7ue1RrufZ5eqnnIyKtG8s5WT15OcZ3X2fVor2uKc9D+gKPfnee9DgQfnqV7+aIUOGtDumCRMm5Gt//LX85Mc/ybPPPtvu9QAAAAAA4OPCXO0dZ652c7W/z1ztAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKcuc7V3nLnazdX+PnO1c6roVe4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAoCfrVZOMnJucf2Ny1qzDk7gf6UBDsnFFsnlNsn1DsuPtZP/uw8uHnZv80f1JZa+kpeXwxO0HGg7n2fB8svmNZNdbScOupKX5KAG0JtvWJz/9z8nwicmCm5PJFxzeXk9XWVmZIUOGZMiQIV2+7bFjx2b27Nm58847c/Dgwbzwwgv5q7/6qzz++OPZu3fvMdd77LHH8vWvfz3V1dXH3f78+fMzcODA7Nq1q8OxVVZWZsmSJRk5cuRx87399ttZs2bNR9YdPnz4CSdvr62tPep31dXVGT58eIdjPpaJEyfm4osvzte+9rU0NTVl+fLl+fu///s8+OCD2bZtW7u3835cJ5q8vVevkzux77rrrowfP77D691yyy156aWX0tJyrP9RAQAAAAAAAABOTXV1dZk2fVox/eILL6a1tbVNnuefez5Tp05NcvjdhQULFuSJXz1RyjC71E033ZT58+e3WVZfX58VK1Zk08ZNqW+oT21tbYYMGZJZs2bljDPOSHV1dW6/4/b87KGfdaisquqqfPX3v5rRo0cXl23cuDGrV63Ojh07cujQofTr1y/jxo3L9BnTU1NTk+TwuxSf+/znct+992XZsmUnv9MdNGzYsNzz5XuK8STJnj178vLLL2fz5s3Zu2dvWltb069/v4wfPz7nnntuMW/fvn3zxd/7Yv77f/vvaWhoaHeZvXr1yj1fvid1dXVtljc0NOTAgQNpbW3N/ob9nd6nXbt25fW1r7fdz+HDMmDAgGJ63bp1aWk++vsh9Q31OXToUKfLf9/111+fCy+8sM2yfXv3ZcXKFdm8aXPqG+pTXVWdwYMHZ9r0aTnzzDOTJJdffnm2vLPlpMsvhQULFuQTn/xEm2WHDh1KfX19mpuP9hLcBwYMGJA/+MM/aHMeHDx4MEtfWZo33ngje/buSUUq0r+ufyZOmJi58+YW3/UaP3587rr7rnz77799zHLmzJ2TK6+8ss2yN998M8uWLcuunbuyb9++1NTUpH9d/4wfPz6zZs0qnttnnnlm7r7n7nzzb755wv1or89+9rOZd868YrqlpSWvv/56Vq1alV27dmV/w/5UV1dn2PBhmTtnbsaOG1vMu2DBgry75d08+eST7S6vPdfZsVx19VX51Kc+1WbZxo0bs2zZsmzZsiUHGg+ktrY2I0aMyOw5s4vnbq9evXL7HbfnwIEDWb16dbtj7S6FikJuu/22nH322UmS1tbWrF27NuvWrcuunbtSKBQyaNCgzJg5o7gPyeF68Qtf/EK+9bff6rLjfzQ33XRT8Tg3NDTk5ZdezjvvvJODBw+mbkBdpk2dlomTJhbzDx4yODffcnO++53v5tNXfjrnnXdecb/WrF6TN954I7t3705tbW3OPPPMzJk7J717905y+Njcetut2fzfNue9997rtn0qh6O1v0n3tsHdfW71tPqrO3/jrdu2nrDNPvL7961bv65d8Q8dMjRXfPqKYkx79uzJsqXLsnXr1jTsb0jfPn0zZuyYzJ49u5inoqIi1y6+Ntu2b8vKFSuPu/3ubs+O5mTa3xNpzzE53n1UTzkupW53R48endtvv734fnRX78/HRZ++fdqk9+3bd9R8r615rc174rfceku+/fffzv79ne9DnOoGDhzYJl2/r/6Yebuz3lq/bn2bv8+o7FXZ5ljt2rUr27Ye+28PNmzYcNTlpb4/7c4+a3fWs+W4L+qshYsWFj8fPHAwy5a2LfPtt9/Olne2ZMTIEUmSc889Nw//7OGT6quPGjUqd37uzmJd/d577+XV5a9m2/Zt2b9/f3rX9s6o0aMyc+bMNsd+xswZufPOO/P973+/3WUVKgq5+ZabM2nypCRJc3Nz1qxek9+9+bvs2rUrFRUVGThgYCZNnpSJEyemoqIiSVJbW5u77r4r3/rbb+Xtt98+bhmdvZY7c/9RinaulGN47bFp06Y88sgjufbaa5Mkffr0yS233pLv/ON3jrlORUVFbrv9tmI92NLSkh/+8w9Pun3qrnGuctUZ3XkvezwnU7eX4p6/T58++cP/6w8zdOjQNsvfeuutvPbaa3lvx3s52HQwdXV1GTVqVObOnZuqqqokyfDhw/OVr34l/+Ov/0eampqOWca8efNy+x23F+ucJGlsbMzKlSvz1ptvpb6+PlVVVRkydEimTZvW5tyYNHlSvvLVr+TvvvV3xy3jSJ2pPzpSd1x40YW54YYb2izbv39/Vq1albfe+mCfBg8enJkzZmbkqMN/41koFHLddddlf8P+vPjii+3en1Lrrn5Nqfp9J1KOeqgn9t2689rsKc9KjmXz5s155OePZPGSxUkO3wvdfsft+btv/d1xx687q9T1YE883z5s2LBhbdInuv8slXI+zy5HP+VkfXgsZf/+/d32t/E99XlGKe7Tunucsac9D+gKPfneu7KyMnd96a42c540NjbmpRdfysZNG7Nn954caj6U/v36Z8iQIZk9Z3axPaisrMxNn70p9fX1efXVV0/qNwIAAAAAgNOFudo7z1zt5mo/Mi5ztQMAAAAAAAAAAAAAAAAAAAAAAAAAAACcOszV3nnmajdX+5Fxmaudnu4UqFoBAAAAAAAAAAAAAAAAAAAAAAAAAACg9CoKyYgpybnXJ5MuTKqOmOu7tTXZvSVZ+lCy/oVk97tJ04EkrW3zNR38YML3QiEp1CRVNUm/Qcm42YcnbN+5OXnrlWTNb5LNqw9P8H6k1pZky9rkkW8k659NLv69pG5Yd+z5qae6ujoXXnhh5s+fn0cffTR/+Zd/meeff/6oeV988cXs27cvgwcPPu426+rqcs455+Txxx/vcDzDhw/P5MmTT5jvwQcfTENDQ4e3Xy5VVVU599xz8+1vfztf/vKX89d//dd54IEHcvDgwXKHliSpqanJ3Xff3al1b7vttvzlX/5ldu7c2cVRAQAAAAAAAEB5LThvQQqFQpKktbU1z7/w0XcqVq5cmX379qVfv35JkoULF+aJXz1RyjC7zJw5c3Le+ecV062trfnVr36Vxx57LE0HP/pSzs8f/nnmzJ2Tm2++OTU1Nbl28bUdKu+zN302o0ePTpLs2bMnP7r/R3nttdc+ku+3v/1t+vbtm8VLFmf+/PlJkoqKitx6263ZvHlztm3b1qFyT9Ztt9+WmpqaYvrxXz6eRx55JK2trR/Ju2zpsvzysV/mrrvvKu7rwIEDc8kll+SRRx5pd5mLFi3KsGGHX3h67/9j777joyzz/f+/ZzLpgYQ0QkJCDwRQihASUESUpqJioanrquseV9dz1q3n7O757fnuOWfr2T3HXdfdY3ctiIoNlKLSpCX03iFAElpCep/M/P7IYWCSzGRmMi3h9Xw8fJjrvq8299z3dd1tPly6pK++/Er79u3z2vsz+/bt0759++yW3XvfvcrNzbWlX3/tddXX13ulvfYMHz5cN950o92yNWvW6ItVX6ipqe3+t2rVKg3LGqb58+crOjpas++arZCQEJ/1zxvCwsI06/ZZkiSLxaIdO3Zo06ZNKjxT2O7+09qDDz2onj172tJHjhzRu4veVVVVVZu8O3fs1PLly7XwwYUaMmSIJGnAgAG69dZbtWrVqnbrv+OOK8dwY0Oj3njjDR05cqTdvFvzt+rTTz7VggULlDU8S5LUt29fTbpxktavW9/hZ+nIsKxhGp893pYuKSnRG6+/oXPnzrXJe/jwYX29/mvl5uZqzr1zZDAYJEnTpk9Tfn6+6urqXGrT0+MsMzNTt956qy3d2NioDz74QDt37GyT9+DBg1qzZo3GjB2jBx54QKGhoTIajZo3f55+99vfBfyduGFZw5Seni5JKiws1Ntvva2SkpI2+b788kuNHjNa8+bNk8lkkiRlZGQoOztbmzdv9knfMjMzNWDAAEnSju07tGTJkjbv361ft14jRo7QQw89ZOtXVlaWxo8frylTpkiSysrK9Pprr6u4uNiubF5enlauXKnHHn/Mtg0iIiI0bfo0LX53sU8+U6BcPf9K/pmDfb1vBdP4Jfl2G2/auEmbNm6yW9Z6zn7xxRc71f8ZM2coLCxMzc3N+vyzz7VhwwZZLBa7PJs3b9Znn32mBx980DbPSNKcOXN08MDBNvmv5uv5rLXOzr8dceU78cZ5lC+/l0DMu/fdf59MJpPP9rNrRXrfdLt0RUVFu/m2bNmiW6beooiICElSWlqavv+D72vVqlXavWt30LzT7k8jR460S585c8ZhXl+OW6+//rpdOiYmRr/4t1/Y0nv37NWnn37q0me6LBDnp768ZvXlOBuI8yJPhIaFasyYMbb07j271dDQ0CZfXn6e7r77bklSVFSURo0ape3bt3vc7oKFCxQSEqLGxkZ9uORDh3Ut/XSpJt88WTNmzLDdRxt53UhNyJmgvC15LrV13fXXKSUlRZJ07OgxLVq0SJWVlW3yrVmzRqmpqZo3f55SU1MlSSaTSQ899JB+//vfy2w2O2zDk2P58vHo7vmHr+c5f9/Dc9W6tes0bNgwDRo0SJI0bNgwTZgwQXl57e8HkydPVv/+/W3p9evX6/jx453uh6/ucwVizPD1uawznRnb/XHOP3/BfCUmJtrSZWVlWvzuYof70GeffaYFCxZo6NChklp+wzhz1kwt/XRpu/mTk5M1d95c2/muJOXn5WvZsmXtnvOuXLFSWcOzNPeBuYrp0fKsID09XXPmzNF7773n8HO05un44crYkdEvQ3fddZfdsg0bNmjlipXtHg+rVq7SqFGjNG/+PIWGhtraOXz4cLvfZaD58rrGX9d9HQnEOBRs126+PjaD4VlJR9avX69hWcM0ePBgSS1j5i1Tb9Hqr9z/PbczgRgHg21/ay0hMcEuff7CeZ+15Y5APc8O1HVKZ0RGRtrFSKgob/8+SmcF8/MMX5+n+eM+Y7A9D/CGYD73Hjt2rFL6pNjS+/bu07vvvtvu8S5Jq1ev1nXXXae58+ba7kXee9+9OnT4ULvXqwAAAAAAAAAAXCuI1d51EKvdP4jVDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcG0gVnvXQax2/yBWO64FxkB3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAYBOTKM3+F+mB/5CyptgHbm+sl84dlT75rfTKE1L+B1LJKampXm0Ct7vCGCIlpEujZ0v3/j9p4R+lwROvBHxvrale2v+V9Naz0sltkrmdQO/XqvDwcM2ePVvLli3Tww8/3G6empoaffnlly7VNW3aNI/6MXLkSPXv399pHrPZrA8//FBWqwc7TYAZjUZlZ2fr5Zdf1ltvvaWoqKhAd0mSdNNNN6lv374elU1LS9Mdd9zh5R4BAAAAAAAAAAAAABBYBoNBEyZMsKWPHT2msktt/2Fzi8Wi7du329IJCQku/cP1wcZoNOrO2XfaLfvg/Q+0/PPlamp0/JLN7l279cJfXlBTU5NCQ0Ndbm/gwIEae8NYW/pPz/1Jhw8fdpi/pqZGi99drNWrV9uWhYaG6p4597jcpjeEhITo6JGjqq+vlyR98cUXWr58udP3WCorK/X6a6+rsbHRtix3Yq4MBoPL7d4y9RZJ0r59+/Rfv/8v5efnq7a21sNPEXwMBoPuuvsuu2VLP12qzz/7XE1Njve/QwcP6YW/vKD6+nrFxsYqIiLC113tlHHjxqlHjx6qr6/XKy+/osXvLtaZ02dceg9q1OhRGjBggC197OgxvfLyK6qqqnJYprq6Wq+8/IoKCwtty6bcMqXdd5ZSU1PVq1cvW/qLL77QkSNHnPaprq5Or732mk6ePCmLxaJ9e/fp5ImTHX4WV9TX1augoMD2OZ5//nmdO3fOaZnNmzdr8+bNtnR4eLhuGHeDy216epzdfc/dtr8tFotef+117dyx02mZnTt2atE7i2zp6OhoW/uBlJ6eLkk6fvy4/vL8X1RSUuIw766du7TkgyV2yybfPNlnfbu8/2/btk2LFi2yG1Ovtn/ffq1cudJu2QNzH5DJZFJ1VbWe//PzKi4ubrdsdXV1y3jdcKXu0aNHKzIy0kufIvBaz7/l5eV+mYN9uW8F2/gVqG3sTWFhYbbxbP369bJYLO3mq6mu0auvvKoLFy7YlsXGxmrUqFEO6/b1fNaezsy/wcSX30sg5t309HSffZ5rRVhYmEaNvrIdmpubdezYsXbz1tbWaskS+7E1Li5Oc+fO1b/9v3/Tk995UnfOvlPjx49XRkZG0J9Xd1avXr009dapdsv27dvXbt5AjFudFYjz0654zdqV5uwxo8fYHZf5efnt5tuxfYfMZrMtnZub26l2U1JS1NzcrL/97W92975aM5vNWv3Var391tt2y2fNmuXyvaKUlBRJ0r69+/Tiiy+qsrLSYd7i4mI9//zzOn36tG1ZfEK8brzxRodlPD2WPT2OfTnP+fsenjusVqsWvbNIdXV1tmWz75qt+Pj4Nnl79+6tmbNm2tJFRUVasXyFT/rlDYEaMwJ5Luvp2O6PuXP4iOHKysqypUtKSvTcc8/p+PHjDtu4fLwdPXJUUsv+2rNnT4f5773vXplMJlt65YqVev/99+3279YOHjioP/3pT3Zj2Pjs8R3+VvJqno4frpwj33vvvTIajbb00k+X6pOPP7Hd627P7t279eorr9r2ubr6OiX3Tnb58/hTIK5r/CmQ93SC6dotUMdmMLFarXp30bt2Y/L06dM9/n2wI4HY1sG2v7UWHRVtl66vczx++ksgn2cH6jqlM8aNH6eQkCtBKDq6j+ypYH2e4Y/zNF/Px8H2PMBbgvnce8SIEba/a2pq9M4776ihocFpv/bu3as3//6mpJZzljVr1ngUSwYAAAAAAAAAgO6CWO1dE7Ha/YNY7QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN0Xsdq7JmK1+wex2tGdGQPdAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgkVolDTydunxF6Vhk6WIGMlgaFlntUhnDktLfyu9/ax0ZI3U7MXA6QaDFB4l9cmU5vx/0rzfSCmZksFBJOHqEmnJ/yeteVmqKvVeP7o6g8GgxMREvfDCC7rrrrtkuPwFXuWFF17oMGi6wWDQ2LFj1aNHD7faDwkJ0Y033qjw8HCn+Q4cOKB9+/a5VXewiYqK0n333ad33nnH7e3kbUajUU8++aSMRs9Db//kJz+RyWTyYq8AAAAAAAAAAAAAAAisocOGqlevXrZ0Xn6ew7z5efl26ZzcHJ/1y1dGjBihuLg4W3rXzl3Kz893XOAqxcXFWv75crfau2XqLXbpiooKl8qtWL5CJ06csKUzMzOVlpbmVtud0dzcrOXLl+tX//krffLJJ/ryiy9dKldeXq7du3bb0lFRUerTp4/L7fbo0UNnzpzRm39/U01NXnzxKkhkDc9SQkKCLX348GGtX7/epbIXLlzQsmXLfNU1r7r8ntC7i97VkSNH3Co7+abJtr/NZrMWLVoki8XSYbnm5mZ98vEntnRoaKhuGHdDm3xxveLs0seOHXOpX1arVYveWaTf/+73euONN3TmzBmXynWkoKBAf3n+L/rrX/+qRe8sUk11jUvl1qxeY/d+2+BBg11u05PjbOjQoUpOTralN2/arKNHj7pUdu/evTp65Ere7OzsTr3D5S21tbV65+13ZDabO8y7bds2nT171pZOTEy0mzu9raKiQh9/9HGH+TZu2KjGxkZb+vK7kB99/JEqKyudlq2srNT2HdttaZPJpIyMDM86HIRaz79vv/W23+ZgX+1bwTZ+BXIbe9O6det06NChDvOZzeY254GZQzMd5vf1fNaezsy/wcZX30sg5l3Jd5/HG4aPGK4f/fhHbv03c9ZMn/bpagaDQffff79iY2Ntyw4fPqy6ujqHZXbt3KXFixe3GYdDQ0M1aNAg3XzzzZo7b66e+cdn9O//8e/6+b/+XN/+9rd1x513aMSIEQoLC/PZ5/GnYVnD9N1nvqvIyEjbsn379unChQvt5g/EuNUZgTo/7YrXrF1pzr76PtOFCxdUUFDQbr7a2lrt37fflu7Xv59S+qR0qu0vVn2hM6ddO0/as2ePNm3aZEtHR0dr9JjRLrdVVVWl999/v8PfLElSU2OT3vz7m3Zj2qQbJznM7+mx3Jnj2FfznL/v4bmroqJCH3zwgS0dHh6uefPn2f1GzWg0av6C+bbfITU1Nemdt99Rc3OzT/vWGYEaMwJ5Luvp2O6PufPmm2+2/W21WvX2W2+7dA5rsVj0/vvvK29Lnn7/u9/r7bfebjdfenq6Bg0aZEsfPnxYX37p2n3gsrIyLVq0yG7ZLbfc4iB3+zwdP5yNHYMGD7Lb7w4cOODy/ddjx45pxfIVWrx4sX79q1/r+LHjLpXzt0Bd1/hLIM9dguXaLdDHZjCpqKjQh0s+tKVDQkK08MGFCg0L9Ur9gdzWwbK/taf1dXF9fb1P23NFIJ9nB/I6xRN9+/bV9OnT7Zbt3LnTZ+0F4/MMf5yn+Xo+DrbnAd4SzOfeV2/z06dOu9y/I0eO6K9//at+/atfa/269V3mfhEAAAAAAAAAAN5ErPauj1jt/kOsdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgO6DWO1dH7Ha/YdY7eiOPN+DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADoRpIGSLN+LE1/SgqPtl9XXy1tfkf6+BfS8U0uBG03SGFRUs8+UlyC9OG/Se/9VFr8L9KSX0hf/VXa/blUeUGyWNopbpDSr5fu+3dpwgOSKaL9ZizN0q5PpaW/lirOe/Kpu6/o6Gj96le/0oABA9qs2717ty5cuNBhHcOHD1daWppb7UZFRemOO+7oMN+6detUVlbmVt3ByGAwaNasWfrJT36i0NDQgPUjIyNDN9xwg9M8lvYOtqsMGjRIo0aN8ma3AAAAAAAAAAAAAAAIqJycHNvftbW12rfX8T80f+HCBZ0qOGVLDx8+POD/mLu7ho8YbpdevXq1W+U3btyoyspKl/JGRkYqMzPTlj569KjL7VitVn35xZd2y0aPGe1yeW+pq6vThq83dPhOxdVaf84+ffq41eZHH33kVntdyXXXXWeX/mLVF26V35q/VVVVVd7sks8cOnRI+/fvd6tMz549ldEvw5betWuXy8ebJBUUFKikpMSWzsrKapMnxBhilw4LC3O5/rKyMrv6venE8RM6cuSIy/nLy8tVWlpqS/dJ9e1x1nrfXbd+nVvtbd221fZ3VFSUMjIynOT2j7y8PLf2r107d9mlffkZNm/erIaGhg7zNTU16fjx43bLysvLtWf3HpfaOXjwoF06ra9770IGq/bm34KCApfLd3YO9tW+FUzjV6C3sbeYzWatWb3G5fwHDhxQY2OjLe3ou/LHfOaIJ/NvsPHV93I1f867/vg8nREREaHk5GS3/jObzT7t02Wpqan6hyf/QWPGjrEta25u1rKlyzosu23rNv3hv/6gPXv2qLm52Wne2NhYDckcoilTpuibj35Tv/jFLzR33lzFxcV19iN4VVyvOCUkJLT7X3JystLT03XddddpxswZ+sEPfqDHH39cPXv2tJWvqKjQRx9+1G7dgRy3PBXI89OudM3alebs1NRUpaen29L5eflO8+fn26+/+v6Wu+rq6rRunXv70No1a+32g5EjRrpc9uv1X6u2ttbl/OXl5dqxY4ctHRcX1+7vmDpzLHt6HPtynvPnPTxP7dm9R9u2bbOlBw4cqJtuusmWnnrrVPXt29eWXrZ0mUu/VQuUQI8ZgTyXdXds98fcGRMTY/ebxyNHjqiwsNDlNsrKyvTBBx/o4sWLDvO0/n5af38dOXb0mN0+MnTYUEVEOPiRayuejB+XORs7rr/+erv0V19+5XIbUstYs23rtg7PIYOBv+8n+kMgx6FgunYL5LEZjHbv3q3t27fb0klJSbr7rru9UrcvtrUrgml/a48xxGiXduc+wKhRo7RgwQKX/rtz9p0u1xuo59mBvE5xV2hYqCZPnqwnv/Ok3TG/fft2t84h3BVszzP8fY/DV/NxMD0P8LZgPPeW7Ld5WLjr21tq2Q+6yr0iAAAAAAAAAAC8jVjt3Qux2v2DWO0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABdH7HauxditfsHsdrR3ZgC3QEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALJGCKNnClNWiDFJLYETr/MapXKiqXPfi+dO9SSdsRgkOJSpH7jpIHjpZ6JUnhPafcyacuX7ec3mqTE/tJ190jDxkuRPSSD8Uqe6Dhp0jekPiOlr/4iVZ5rW4/VIhXulRb9WLr/P6SEvvaf4VqWlZWlH/7wh3rmmWfU3NxsW15dXa0PPvhATz/9tNPyKSkpuv7663Xo0CGX2xwwYIBGjhzpNE9DQ4PWrl0rs9nscr3e1tjY2Kb9kJAQ238GN3ai0NBQ/eM//qM2bNigFStWeLurLpk5c6bTQPvl5eXav3+/cnNzZTQa280THh6ub37zm9qxY4eszg52AAAAAAAAAAAAAAC6gNjYWGVlZdnSO3bssHt/oj15+Xnq17+fpJb3CMZnj9fqr1b7tJ/e1L9/f9vf5eXlOnv2rFvlLRaLDhw4oJycnA7zDhw40O4dhD2797jV1tGjR1VXV6fIyEhJ0uDBg90qHyglpSV26aioKJfLni0+qzOnz3i7S0FjwIABtr8rKip06tQpt8pbLBYd2H9AE3ImeLtrXrdlyxa3y1y9fSTp4IGDbtdx5vQZJSYmSpJSU1PbrK+srLRLjxgxQidOnHC7nWBQUlJi+6y+Ps4GDLzy3Zw/f15ll8rcKt+6vdS0VBUUFLhVh7ft2LHDrfyFhYV26ZgeMd7sjh135otz587ZzeX79u5zq+zVYqJ995n8qbPzr9S5OdhX+1YwjV+B3sbecujgIdXV1bmc32Kx6OzZs+rXr+VcOCam/e/KH/OZI57Mv8HGV99LZ3k67wbr5+kMd88DLotPiNeYMWMcrjeZTIqIjFBSUpL69++vPn362K23Wq364P0PdPHiRZfaKykp0Zt/f1PRMdEaOWKk+g/or4yMDCUkJCgkJMRhubDwMI0fP16jR4/WRx99pK35W137gD725JNPely2pKREr77yapu55LJAjlueCtT5aVe7Zu1Kc3Zubq7t7+bmZm3fvr3DfpWVlalXr16SpBtuuEGfffaZmhqb3G77yOEjbv92p6ysTOfOnbPt7/0H9He57P79+91qS5IO7D+g7OxsW7p///4qKiqyy9PZY9mT49iX85w/7+F1xscffayBAwYqPiFekjTr9lk6fPiwTCaTbrvtNlu+gwcPatOmTT7tS2cFeswI1LmsR/dJ/DB3Dhw40O63e3v2uP99dOTq76eqqsqjezV7du+xHa8hISEaMHCAS9vDk/HjMmdjx6BBg2x/V1ZW6vTp0y63cS3w9LrGXwI5DgXTtVsgj81g9dGHH2nAgAGKj2+ZbyfkTNCBgwd0YP+BTtXri23tCl/tb2FhYerRo4fL9UpSU1OTw2tFT4wYMUJjxjq+9r9aSUmJli1d1mG+QD7PDuR1itSyPauqqtpdZzAYFB4erh49eyi1T6oGDxms8PBwuzyFhYX6+KOPPWrbVcH2PKMr3ONwZT4OpucB3hSs596SVFlVqZQ+KZKkvn37qmfPnl4dHwEAAAAAAAAA6G6I1d59EavdMWK1t0WsdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcK0hVnv3Rax2x4jV3hax2iFJpkB3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAQIlOlG5+Shqe0xLE/Wpms3QiX1r5P1JdheM6wqOlfqOliQ+3BE43muyDpzuKgW21Ss1N0vmj0vnfS5vjpewHpKybpej4K+VCTNKQbCm5n7Tsj1LRrvbrqzwnLfqBNOMfpUE5LeW6irKyMhUXF9sFWL+a0WhUVFSUUlJSFBkZ6XJgcYPBoEcffVS///3vdfLkSdvy5uZmffbZZ/rWt76l8PBwh+VDQkI0e/Zsffjhhy4HWp89e7ZCQ0Od5iksLNT69etdqs8X6urq9KMf/Uh79uyxWx4TE6P09HT1799fw4cPV3Z2tvr06eNSnTExMXruuec0atQo1dfX+6LbDvXo0UP33nuvTCbHO/2WLVv0s5/9TG+99ZaysrLazWMwGDRt2jSlpqaqqKjIV90FAAAAAAAAAAAAAMAvxmePt/sHzvPz8jsss3vXbt1999229ylycnK0ZvWaLvGPoBuNRsXHx9vSZ86c8aiewjOFUk7H+Xqn9LZLnz592u22zpw5o8zMzJb6evfuIHdgGY1GxcbFtulneITjd29aO3HyhLe7FTRCQkLUq1cvW/rMac/2v9NnTmtCzgRvdctnTp442XGmVpKSk+zSZ8+edbuOquoq29/R0dEymUx273UVFhaqvr5eERERkqQbb7pRtbW12rRpk+rq6txuLxAiIiKUkJBg917b5c/jCnePM6PRqISEBFv6bLEH30tVlV06Li7O7Tq8qbm5WefOnnOrTHV1tV06MjLSm12yMZvNunjxosv5a2tq7dLFZ4s9LhsR6fp+FMy8Mf9Kns3Bvty3gmn8CuQ29qbCwkK3y1RXXfm+HI29/pjPHPFk/g02vvpePNXZeTfYPk9rBQUF2rRxk1tljh8/7lFb/fv3V//+/T0qW1dXpw8//FC7du5yu2xNdY3y8vKUl5cnqeW8PDEpUb1791ZKSop69+6t1NRUJSYm2pULDQ3V3LlzFWoK1aZN7m2jYNHY0KiNGzfqyy+/VGNjo8N8gRy3PBHI89Ouds3aVebssLAwjR4z2pY+ePBgm3Ok1qxWq7Zt3aZp06dJahkvR48era35W91uv7DI/bFaatkuqampkqSoqChFRUWptrbWaZmmpiZduHDBo7aulpSU1CZPZ49lT45jX81z/r6H1xkNDQ1655139NTTT8loNMpkMmn+gvkymUwKCWn5IWJ1dbXeW/yebzviBYEeMwJ1LuvJ2O6PuTM5Odkuv6f3Eh0xGAx2bXj6fbcu17t3bx08cLDDcp6MH5c5GzuuPqfz9DN1R529rvGXQI5DwXLtFuhjM1g1NDRo0TuL9J2nvmN7rjl37lz94b/+0Obc3lW+2tau8NX+NmLECC18cKFb9Z48eVIv/OUFu2Wtf8d/+ZzGFYlJiR1nclOgnmcH+jpFkmbfNdujcpJ06NAhvfP2Oz79PX8wPs8I5nsc7szHwfQ8wJuC9dxbko4ePWo7fwgPD9djjz+mjz/6WAUFBW63BwAAAAAAAABAd0es9uBArHb/IlY7sdoBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACI1R4ciNXuX8RqJ1Y7HOtCQycAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN6TnCnN+L7UZ0DbdeYmafsyafObUmNN++VDI6XBudLYe6Q+g9sGf3dXzSVp7UvSobXSLd+W+o60Xx/bW7rvX6VPfyUVbG+/jroKaeVz0qxQaVC248DxwWbx4sX6wx/+oLq6Ood5IiIilJycrFGjRunpp5/W8OHDZTQaO6w7PDxcDz30kP793//dbvm+fft09OhRjRw50kHJFlOmTFFUVJQqKys7bCskJETz5s3rMN/+/ft16dKlDvP5Sn19vT788EOdO3fOYZ6IiAgNGTJE3/72t/Xwww+rZ8+eHdY7ZMgQ3XbbbVq2bJk3u9uhoUOH6qabbnK43mKxaPHixdq7d69WrlypYcOGOfwHAAYMGKCcnBwtWbLEV90FAAAAAAAAAAAAAMDnDAaDJkyYYEsXFhbq7NmzHZZrbGzU7t27lZ2dLUnq1auXhg4dqkOHDvmsr94SERFh9y5JdXW1R/WUl5e7lK9Hjx526aqqKrfbuvp9lNDQUIWHh6uhocHterwlNCxUSYlJio+PV0JCghISE5SQkKD4+Hj16tVLISGde0Hq/LnzXupp8ImItN//Kqs6fteoPVWV7u9H/lZdXa3a2lq3y8XExNilhw0bpoGDBrpVR3Jysl06PDxcZrPZlm5ubtaa1Ws06/ZZkiSj0aiZs2Zq+ozpOn/+vC5cuKDSklKVlJa0/L+kxKX3wrwtLi6u5Ri76r/4hJbjLioqqlN1u3ucRURE2B3bMTExmpAzwUmJtowG+/f4wsPD3SrvbZ6Mx63H3s6Od46427fGpka7tDtzW1NTk106pLMvuQYJb8y/kmdzsC/3rWAavwK5jb3Jk7m4ofFK/4xGowwGg6xWq10ef8xn7fF0/g02vvpenPHlvBuIz+OOS6WXtHPnTp/U7Q2NDY3auWunVq1c5bUxrbm5WefPndf5c+e1Z/ce2/KePXtq7NixmnLLFEVHR9uW33X3XTpx8oTOnXX8Xn0w+uSTT7Q1f6tL42qgxi1PBfL8tKtds3aVOXv0mNGKiIiwpfPz8l0ql5+fr1tvu9V2rZ2bm6ut+Vvdbr+iosLtMpJUXWV/7h0VFdXhXOxxW63O86Oi285PnT2WPTmOfTXP+fseXmedOnVKX331laZNmyZJ6tu3r9369xa/5/Fn8KdAjhmBPJf1ZGz3x9zZug1Pvw9HIiIiZDKZrtTv4T3H1uNAj5geDnI6L+cOZ2PH1ecI3t5mwc6X1zX+EshxKFiu3QJ9bAazgoICrVm9RrfedqskKTo6WnPnzdUrL7/iUX2+2ta+KuPPewV1tfa/43fnfv6B/Qd04vgJh+vH3jC2zbHuTCCfZwf6OsVTRUVFWrt2rXbt3OXztoLxeUag73F4az4OpucB3hSs596StGXzFt08+WbF9GhpLy0tTU9/92nV1NSouLhYpSWlulhyUaWlpSotKVVpaWmb/RIAAAAAAAAAgGsBsdqDB7Ha/YtY7cRqBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1zZitQcPYrX7F7HaidUOx0yB7gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP5kMEpDJklTvyP1TGi73mqVdq+Qvn5Zspjbq0Dqe700caGUMVIymuzLWpql+irp3DHp0hmptk4Ki5Qa6yVZnffNapHOHpY+/Ddp2jPS0Bvtg8JHxEi3/0ha/gfp5Nb266irlD77rXT/r6TUoV0jgPuRI0d04sQJWa3ON9CJEyeUl5enDz74QD/96U/13e9+V6GhoR3WP3fuXP3Hf/yHXf3nzp3T9u3bOwzenpqaqqFDh2rrVgcb/CopKSnKysrqMN+iRYs6/KyBVl9fr7179+r73/++1q5dq//93/9VfHx8h+WefPJJffbZZ377fAaDQd/97ncVHh7uME9dXZ0++eQTmc1mrVixQk888YSio6PbzRsaGqr58+dr2bJlamho8FW3AQAAAAAAAAAAAADwqWHDhikuLs6Wzs/Ld7lsfl6+srOzbemc3BwdOnTIm93zibCwMLu0p8/9GxsbXcoXHmb/rkJ9fb3bbbUuEx4e7vf3FZKTkzUhZ4KGDRumxMREGY1Gn7VVV1fns7oDLdRk/w5TQ71n36Mn+5G/efo9hoXaH6N33X1Xp/tiaOfluDVr1igxKVHjx4+3LTMajerTp4/69OnTJn9dXZ1Onz6tXTt3aceOHbJYLJ3uV2shISEaM2aMRo8ZrYyMDEVGRnq9jcvc/X5aj52DhwzW4CGDO9WH9r4Xf6qtrQ1o+864ffy0eg2vrtb18sH+jqKnvDH/tlfOlTnY1/tWsIxfgdzG3lRb48H35cJh46/5rLXuch7lq+/lav6cd/3xebqKxoZGVddUO1zf3Nysuto61dbV6uzZszpz+oyOHDnit3GhsrJSa9eu1dZtW/XEE08oLS1NUsv+ctttt+mtN9/ySz8c+cvzf9GlS5ccrr9l6i268cYbbemkpCSXt12gxi1PBfL8tKuNtV1lzs7NzbX9XVFR4fI9pvLych07dkyZmZmSpPT0dKWmpqq4uNit9l29z9Nae9ulI02NTR61ZbFY1NTUZPt9VOvvVvL+sezKceGz8yk/38Pzhi+/+FKZmZnq16+f3fJNmzbp4MGDfutHZwRyzAjk+OpJ2/6YO711HDjSesyqb/Dw+65zfyyUPBw/OuDrbRZs/Hld4y8BvacTJNdugT42g92qVauUOTRT6enpklqedU6aNEkbN250uy5fbWtXBMv+5kjruTEiMsLlsl9++aXT9QMHDVSPHj1cri+Qz7MDfZ1yud3m5ub2V1pb9tu6ujpVlFfozJkzOnHihEfteCoYn2f4+x6HL+fjYHke4E3Beu4ttZw/vPraq3rssccUExNjWx4dHa0hQ4ZoyJAhdvktFotKSkp0+PBhbdm8RRcuXOh0vwAAAAAAAAAACGbEag8+xGoPPsRqJ1Y7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADofojVHnyI1R58iNVOrPZrlanjLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAdA8hodKEeVLOPMkU1na9uUnas0Ja/UJLIPXWTNHS5Eek0bdLplYxw2srpKObpb0rWwKwW5tblieOkZ58W6opk3Yulw6sbAnu7kx9lfT576WSAilnvhR6VVzqmF7S7H+Rlv5KOrmt/fINNdKH/yrd9/+kPlldI4C7q6xWq0pLS/Uv//Iv6tGjhx5//HEZOviAqampSkhIUElJiW2Z2WzWypUrtWDBAoWFtbMz/B+DwaC5c+e6FLz9/vvvV0hIiNM89fX1WrVqVYd1BYumpiYtWbJEoaGhev31151uK0nKyspSYmKiLl686Jf+JSYmat68eU7zvPfeeyovL5ckbdq0SYWFhRo6dKjD/HfeeaeGDx+unTt3erOrAAAAAAAAAAAAAAD4TU5uju3v5uZmnThxQj179nSpbHl5uS5dumT7R96zsrIUGxuriooKn/TVVyyWdl7+cYHL/2B9q9dVPGnPanGxLR8wGo26c/admjRpkoxGo9O8jQ2NulhyUSUXS1RfX68JORM8arOpqcmjcgguHn+PfnqHzWq16r3F7+nQoUO67bbb1KdPH6f5IyMjNXToUA0dOlRTb52qv//97zp39pzX+tO3b189+NCDSkxM7LDf5eXlKikp0cWLFzVwwECl9Elxuz2OMzfG8QAI5r51GV6YfyXP5mBff39BM34FcBt7k1U+aj9A72R3l/HdZ9/L//H3vOvrz9OV7Nu3T4sWLQp0NzpUU12jN15/Qz/+yY9lMpkkSSNGjJDJZJLZbA5Yv6qqqlRZWelw/coVKzVmzBhFR0dLknJycrRp4yadP3++48q70W9JfK3LjbVdYM5OS0tT3759bemDBw6qR48eLpc/cOCAMjMzbenc3FwtWbLErT54eg7nyfa0tPdDNE/aa++4DcCx7K95zuf38LzAYrHo5MmT6tevn93y48eO+60PnRbAMSOQ46tHbfvjePPS9+Eqrx1nLm4bf4wfvt5mgeTv6xq/CeQ9nSC9dvP3sRnsLBaL3nn7HT377LMKC2/5HfMdd96hY8eOuXbt00HdnvDkfMNX+9vx48f1yiuvuFWmrrauzbKamhq79OXnwYEQqOfZwXCdIkl/feGvKi0tdbucvwTl8ww/jne+no+D5nmAFwXtuff/OXP6jP74hz9q+ozpGjtmrG2uaY/RaFRycrKSk5M1adIkrVu7TsuXLw/O4wIAAAAAAAAAgE4iVnvXR6x2/yJWOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQPdArPauj1jt/kWsdlxrTIHuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/mAwSBMfliY8IBmNbddbLdKBNdK6l9sP3N4zRZr5Pan/mLbrzh6RVr8oFe9vW9YqKTxKioiWbv2WNHqW9MVfpDM7/2+lA81NUv77UtJAadhN9usiolsCuP/9n6TywvbL11VKX/6vdP//k6LiHLfTVTU2NuqXv/yl7r//fsXFxTnNGxoaqrS0NLvg7ZK0Zs0aVVRUKCkpyWn5++67T//8z/+s5uZmh3kMBoNmzJjRYb9Xr15tCyTelbz33nuaPXu2FixY4DRfUlKSRowYobVr1/qlXw8//LDCw8Mdrm9oaNDzzz9vS1dXV2vFihVOg7eHh4frH/7hH/Tkk096ta8AAAAAAAAAAAAAAPhDbGyshg0bZkuHhITohz/6ocf1GY1Gjc8ery+/+NIb3fMZq9X+RRxTiGf/fHdISIhL+SwW+5eETCaT03dL2m3LZN9W6zp9acGCBRo9ZrTdspqaGp0+dVrnL5zXxQsXVVJSoosXL6qqqsqWJykpSRNyJnjUptXZy1JdXJO5yS4dFh7mUT0RERHe6I5LjO29ROeC1seaqyzN9vv3+++/73Fdl9XX1ztct2f3Hu3ZvUeJiYnq16+f+vTpo4TEBCUmJCohMUGhoaFtyiQlJempp57Sn577U5t3zTyRlpam7zz1HYWFXdkfLBaLiouLdbb4rC5cvKCLF1uOtdKSUpnNZlu+Bx98UCl9Utxu093jrPW4c2D/Ae3bv8/tdq928cLFTpUHnPHG/CsFdg7uSKDHr2thG3eGv+ezyzrbxrUgEPMuuqaysjIdOHBA119/vaSWcS49PV0nT54McM8cq6+v16pVqzRnzhxJLefys++arZdfernDsoEatzwVyPPTrnbN2hXm7NzcXLt0Tm6OcnJzPK5vzNgxWrZsmRoaGlwuYzJ5eH+o1XZx5bjxtC3J/n6U1dK2LW8fy748jjvi73t43jBgwABNnjy5zfJ777tXJ0+etLt3FqwCOWYE8lzWk7HdH3Nn6zZCQkI8+j4cafN9e+k4C+R1Xeu2/TkG+FN3vq7pCucuvtYdj01vKykp0aeffqr7H7hfUstvwxc+uFB/eu5Pbu0vvtrWgVRZWanKyspO11NUVGSXTk9P73Sdngjk8+xguE6BZ/x1j8Of83Ggnwe05unzYyl4z72vVlVVpSUfLNGnn3yqAQMGKDUtVUmJSUpMSlRCQoJiY2PblDEajbpl6i0KjwjXRx9+1Km+AQAAAAAAAAAQbIjV3r0Qq92/iNUOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQdRGrvXshVrt/Easd1wpToDsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIA/WK1S74HtB26XpKrSlmDpTfVt18X3le74sZSS2bbOw1ukNX+Rqi523AeDQUrsK935A2n5H6WC7c7zR/SQonu1v85okixm520l95dMER33q6sqLCzUxo0bdccddzjNFxISosTExDbLz58/r2PHjnUYvD05OVl9+/bVqVOnHOZJTEzUwIEDO+zzSy+9JKvVSdT+IGWxWPTHP/5R9913n8LCwhzmi4qKUlZWll+Ct4eHh2v+/PlO82zZskVHjx61W/biiy/qmWeekdHRYCBp/vz5+uEPf6jq6mqv9BUAAAAAAAAAAAAAAH+ZMGGC02finsjJydFXX34V1O88NDQ02KUjIjx7aSY8wvE/It9Re62XdSQyMtJpnb5y3XXXafSY0bZ0cXGxln66VMeOHeuwrMnEP4venvq6elmtVhkMBklSjx49PKrH03KeiImJ8VtbklRXX2eX3r1rt1/2+ZKSEpWUlLRZ3rNnT6WkpGjQoEHKyc1RVFSUpJbjcs69c/TSiy91uu158+fZ3rWyWCxavXq1NmzYoJrqmg7LmkL9c6zV1dl/LyWlJdqav9UvbQOe8Mb8KwVuDnZHoMava2kbeyJQ8xk61hXmXQSPwjOFuv76621pf56He2rL5i2aNGmSkpOTJUlDhw7V0KFDdfjwYaflutq4xfmp64J9zg4PD7e79+DNOvO25LlcxtP7Q55sF0/bMplMdvdbGhrbttXVjmVn/H0Pr7MiIiK0YOEC2/3WqqoqxcTEyGAwKDo6WgsWLNCLL77ol750RrCPGcHEH8dbbW2tXToiIkKNjY1eq7/N9x3pv7HQV9rbZt1Rd76uYRzqnsemL+Tl5SkrK0sjRo6QJKWmpmrW7bO0bOkyl+vw1bbuDs6ePavGxkbbWDOg/4CA9CNQz7OD5ToFnvHXdVEg5mNfPQ9w9zi7Vp4fNzU16ciRIzpy5Ijd8tDQUCUkJigjI0OjRo1SZuaV4DITJ07Uzh07VVBQ4PP+AQAAAAAAAADgL8Rq736I1e4/xGoHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADouojV3v0Qq91/iNWOa4V7/0I4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABd2JZ3Jaul/XXhUVJETPvrRt/VErjdYLBffnqPtOJ3rgVuv1qPRGn2P0s9kx3nSegn3f+fUt/hbdfVVUnL/kuqPOe4/PBbpalPSmHdOHi7JP35z3/uME9YWJgGDx7c7rq//vWvHZYPDw/vMED8DTfcoPT0dKd5ioqKtG3btg7bC1aHDh3Sli1bnOYxGo1KS0tzGhjdW7Kzs5WZmelwfXNzs95++23V1NTYLT969Kj27dvntO4ePXrowQcf9Eo/AQAAAAAAAAAAAADwF4PBoPHZ471eb2xsrLKysrxerzfV19ersaHRlu4V38ujeuLj413KV3apzKNyjsrU1NSoqanJ7To8MXHSRNvf1VXV+usLf9WxY8dcKhsdHe2rbnVpzc3NKiu7sk/07dvXo3o6ev/oauZms106PDzcrbZ69OjhVv7Oav0OT2xsrF/bb62yslJHjhzR8uXL9fvf/V6XSi/Z1mVmZiouLq5T9Q8YMEB9+vSxpVesWKGVK1aqprrGSakr/HWsNTU12Y09gf5egI54Y/5tXc6fc7A3+Hr8Yhs7F2zzGVp0lXkXwaO+vt4u7e65dCBYLBYtW7bMbtnsu2Z3+N5+Vxu3OD91XbDP2aPHjPbJsZWbm+tW/oT4BI/aie91ZbtYrVZVVlZ2WKZHjx4KDQ11v61W311FRUWbPF3tWHbG3/fwOuv+B+5Xr14tfbRYLHrz72/q6/Vf29YPyRyiyTdP9ktfOiPYx4xg4o/jrXUb3t6fGxoaVFdX1+n6W5drvR/5k9lsVmPjlbHj6nG6u+ju1zWMQ93z2PSV9957z+78a/LkyQ5/I94eX23r7sBisej0qdO2dHxCvAYOHOjXPgTyeXawXKfAM/44Twu2+bizzwPCw3h+7I6mpiadO3tO+Xn5eunFl7Rsqf29uOzs7AD1DAAAAAAAAAAA3yFWe/dDrHb/IVY7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABA10Ws9u6HWO3+Q6x2XAtMge4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD+UnxQKj4spWW1XRceLWXdJJ07LFma7dcdWi+NuV0KCb2yzGqVqkukxjrP+hLZU7rtGemTX0rNTVeWGwxSxjjp7n9uP5h8Q6209hXp+EbHdQ+eJM34nmQKdZynuzh06JCsVqsMrSPrtxIZGdnu8pUrV6qurs7hekkKCQnRzTffrL/97W+yWNpG/zcajZo0aZLTOiRpxYoVunjRzUj/QaS+vl4bNmzQ5MmTneZLT09XaGioGhoafNaXkJAQ3XXXXerRo4fDPEVFRVq3bp2sVqvdcrPZrOeee04vv/yyw/3GYDBo4cKFeu2119TY2OjVvgMAAAAAAAAAAAAA4CtZWVmKi4uzpb/88ktt3ODkJRMn0jPS9dhjj9nSObk5OnDgQGe76FPnL5xXenq6pJb3FwwGQ5v3BjoyYMAAl/KdPXvWvtzAATp58qTL7ZhMJqWlpTmsz5f69+9v+3vvvr2qr693uWzf9L4+6FH3UFBQoPj4eElSfHy80tLSVFRU5HJ5o9GorOHtvNjmQF2t/YtrcXFxOn/+vMtt9evXz+W2vKG4qNgunZGRoQsXLvi1D45UV1drxcoVWrhwoW1Zenq6ysvLPa6z/4D+dumt+VtdLms0GpWamupx2+4qLi627Q8ZGRl+axfwRGfnXymwc7C3+WL8Yhs7F8zz2bWsK8278Fyv+F6aPn266uvq9cknn3SqrqioKLt0bW1tp+rzl4MHDurY0WMaPGSwJKl3797KycnRpk2bHJbpiuMW56euCfY5Ozc31/Z3fX29/vBff5DZbPaoroe/8bAGDhwoSUpLS1Pfvn1VWFjoUtl+/T279r26XFlZmZqampzkbmE0GpWenq4TJ0543JYknT/X9tq+Kx7LzvjzHl5njBs/TqNGjbKl169fr5MnT+rMmTMaOmyoevfuLUmaNWuWjh877tZ9IH8L9jEjmPjjeGu9r2RkZKigoMCrbZw9e9Y2dmZkZCgkJETNzc0dlLI3YKD9cRbo77yoqMh27KdneDZ2BLPufl3DONSiOx6bvlBbW6v3Fr+nbz3xLUktv/edv2C+ln++3OU6fLGtu4v8rfm260pJmjx5stvnsJ0RyOfZwXKdAs/44zwtmOdjT54HxPWKc6uNgYMGetg7zwT7te66deuUk5ujxMRESbJdxwIAAAAAAAAA0J0Qq737IVa7/xCrHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoOsiVnv3Q6x2/yFWO64FxkB3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAf7E0S5veahuc/bIhN0nRCW2XlxRIxUftlxkMUkqmFBPveX8yrpMGjLuSNoZII26TZv+w/cDtVqu0/TNp/yrJ2jaGuGSQBtwgTXv62gjcLkkVFRWqra11msdgMCgkJKTddZcuXdKaNWs6bGfo0KFKSGhn55AUExOjG2+80Wl5s9mstWvXdulA4M3NzSooKOgwX2JiosLCwnzal+TkZM2aNctp0P7du3fr5MmT7a5bs2aNCgsLnbaRlZWlESNGdKqfAAAAAAAAAAAAAAD4U05Oju1vi8WizZs2q7q62qP/Dh44qJKSElt9Q4cOVVxcXAA+leuOHz9u+zsiIsLt5/6RkZEaNmyYS3kLCgpUX19vS48fP96ttm644QaZTCZb+tDBQ26V91R4eLhdu9VV1W6VHzVqlLe71G3s37ffLn3rbbe6VX7sDWMVGxvrcv6y8jK7dL9+/Vwumzk0U1FRUS7n94ZTp07JYrny0tt111/ns7ZiYtp5+a4DxUXFdunIqEiv9qG62vVjbejQoQoPD+9U++64+p2wXr16KS0tzW9tA+5qb/519h5hewI1B7siGMavQG3j5mYHL3cHGX/OZ4HW+jsJDQ3el9O70rwLz9x+++36yU9+onHjxiknN0e9e/fuVH39B/S3S1dUVHSqPn9aunSp3Tg0fcZ0RUREOMzfFceta+X8tLPjbDCfF/Xt29fue9u5c6fKy8s9vke1ZcsWu/pzc3Nd7suAAQPcvp81aNAguzLHjh1zuezYG8a61ZYkjRs3zi599f2ty7riseyMP+/heSoxMVFz7pljS58tPqsVy1dIavmN2KJ3FtmOY5PJpIUPLgzq86VgHjOCjT+Ot1OnTtnNAzeMu8HrbRw6dOX7CQsLc/u+rtFotBuf6urqdOrUKa/1zxMnTpyw/R0REaGs4VkB7I33BeK6xp/XfYxDLbrjsekrhw8f1sYNG23p2NhYzbp9lsvlfbGtu4vdu3arsrLSlh4xcoRfn/8F6nl2MF2nwDP+OE/z53zsq+cBV49XGRkZbtU/evRot/vUGf681jUYDB49Hy8uvrLNO/v8BQAAAAAAAACAYESs9u6HWO3+Q6x2AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACArotY7d0Psdr9h1jtuBYYA90BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD86cxe6cim9tf1SJRGz2m7vLFa2v25ZG6yX96rjzRogiTH8aOdCouUJj4sRfWSQsKkKd+Wpn1Xioprm9fcJO1cJm16zUHweYOUNUW685+lHu3HGO+W6uvrVVFR4XH55uZmvfHGG7JarU7zDRo0SJmZme2u69+/v7Kzs52WLy4u1saNGz3uZ7CoqanpcFtFRkbKaPRtCOwpU6Zo2LBhDtc3Nzdr0aJFMpvN7a4vLi7WqlWrnLaRkJCg22+/3eefBQAAAAAAAAAAAAAAb4iLi9PQYUNt6cOHDquysrJTdebn59v+NhqNmpAzoVP1+dqunbvs0tNnTJfJZHK5/J133unyP1jf3NysnTt32tKJiYkutxMVFaXbpt1mS5vNZu3YscPl8p3R1NRk9+5HbGysy2VHjhypvn37+qJb3cK+fftUXl5uS1933XUaP368S2UTEhI0e/Zst9o7VXDKLj1u/DiXyoWEhOj22293qy1vaGho0OFDh23pYcOGKTU11a06pk6dqvj4eIfre8X30gNzH9DP//XnGjhwoFt1t35HqLGx0a3yrTU22Jd39VgzGo2aPmN6p9p2V+ux87bbbms/owNpaWnKycmRweDhi5SAG9qbfydOnOhy+UDOwc4E0/gVqG1cU1PjXkcDxB/zWbBo/Z24c77rb11p3oVnzM1mhYSESJJMJpMeevghRUVFeVRXRkaG3e8CqquqVVRU5JV++kNxcbG2b9tuS0dHR2vatGkO83fFcetaOT/t7DgbzOdFObk5dun8vHwHOV2zd89e1dXV2dKjx4xWRESES2WNRqNmzZrlclvt5W+9TzozduxY9e7d2+X8w4YNszv/KygosLu3cFlnj+VgO//w5z08TxiNRi18cKHCwlvaMJvNemfRO2puvvKDvqKiIn3xxRe2dHJysu6++26f9amzgnnMCDb+mDubmpq0b98+Wzo1NVWjRo1yuf64uDh964lvOfytoyTt2L7Dbp+dPmO6y2OnJE2ePFlxcXG29Pbt22WxWFwu7ws7d+y0u7c9Y8YM2zmiK2bOnKmZs2Z6fB7pa4G4rvHndR/jUIvueGz60rJly3T+/Hlb2p1nWr7Y1t2FxWLR6q9W2y277/771L9/f5+3Hcjn2cF0nQLP+OM8zR/zsa+fB5w+fdr2d1xcnIYMGeJS3aNGj1J6erpb/eksf3ynBoNBY8eO1Y9+/CM9/PDDbvfx6m3e2ecvAAAAAAAAAAAEK2K1dy/EavcvYrUDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB0XcRq716I1e5fxGpHd8e3DQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC4ppgbpK1LpNqqtusMBmncHS1B3Fs7tlE6f8J+mdEkjb9PiulEsPSUQdLkx6V5v5bG3SOFRrTN01gv5b0nrf5b+4HbDSHS9XdKt/9QiuzZfjuWZuniScnc6Hlfg5HVatW5c+c6VUd+fr6Ki4ud5omOjlZubm67gbynTp2qyMhIp+UPHjyowsLCTvUzGHQUuF2SjEajDAYP/0UDF4SFhenZZ591GlS9vLxcn332mcP1jY2N+vTTT1VXV+cwj8Fg0MMPP6ykpKRO9RcAAAAAAAAAAAAAAH+YMGGC3bP0vPy8Tte5fdt2WSwWWzo7Ozuo/xH0oqIiHTt6zJbu06eP5i+Yr5CQkA7Ljs8er+wJ2W61t2b1GjU1NdnSI0aM6LBMRESEHvnmI4qLi7Mt27Jli6qq2nmZyQcsFovKLpXZ0iNGjlBERDsvLLWS0idFc+fNleTa+yPXIovF0uZ9lfsfuF9TpkxxetwMGDBA33nqO4qKinKrvcLCQlVUVNjVM378eKdlDAaD5syZoz59+rjVlresW7/O9rfRaNTCBxcqOibapbKTJ0/WrNtn6Yc/+qFum3Zbm+PaaDTq6aefVnZ2tkJCQrTwwYVKTGznRUAHrr/+erv01ceJJ0pKSuzSN9xwQ4dlDAaD7r3vXvXt29evx1lhYaFOnLjycuTI60Zq4qSJLpWNjonWQw8/pPvuv0/P/OMzSktL81U3AZvW8++ds+/sEnOwI8E2fkmB2cYdvccbTHw5nwWT1t/J+Gzn5xmB1JXmXXhm3dp1Kiu7Mr6lpKToqaefUu+U3m7V07dvXz3yzUfszs+3bt3a7j6QNTxLc+fNtf03fcZ0zz+Aly1fvlyNDVd+GDLpxklO546uNm5dK+en3hhng/G8KDw8XGNGj7Glzxaf7fRvacxms3bu3GlLh4WFaezYsS6XH3vDWE2dOrXDfEajUffff7/69e9nW1ZUVKSjR4+63FZoaGibbetI3759tWDhArtla9ascZjf02M5GM8//H0Pz10zZ81Uenq6Lb1i+QqdO9v2t2urv1qt06dO29ITciZo5MiRPu1bZwTjmBGs/DF3rlltf7zfd/99yuiX0WH9YWFhmr9gvoYOHaonvv2EvvvMd9u991hRUaG8vCvPCBISEvSNR76h8PDwDtu4ftT1mjlrpi3d2NCodWvXOSnhH+fPn9fBAwdt6dTUVM2dN9elZxbDhw/XLVNv0a233qqf/exnGjV6lC+76pFAXNf4+7qPcah7Hpu+ZDab9fZbb8tsNrtdlm3t3MaNG3Xw4JUxNTIyUv/w5D84/B19R4YOHapecb06zBeo59nBeJ0Cz/j6PM3X87E/ngfs37ffLn33PXd3OPalpqbq3nvvdbkf3uTr7zQnJ0cLFi5QUlKSBg8ZrDvvvNPlvkVGRmrQoEG29NX3J6/2wNwH7O4jpqamutwGAAAAAAAAAADBgFjtnvc1GBGr3b+I1Q4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANB1Eavd874GI2K1+xex2tHdOd6rAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADops4dkU7slNqLQx0aLuXMk9Qq9nRjrbRriWSx2C+P7yvlzG+b3x3XT5P6jmx/XbNZ2vSOtGWRZDG3XR8SKt1wtzT1cSnE1H4dZrO0Y6n0wb9Kn/1OKu9crPOgYrFYVFpa2qk6Lly4oI0bN3aY7+abb1Z4eLjdMqPRqPnz53fYx5UrV8psbucL7GJMJlOHgdktFotLQd49lZmZqTFjxjjNs2TJElVVtfMvNFwlPz9fZ86ccZpn8ODBmjRpktt9BAAAAAAAAAAAAADAnwwGg8Znj7elq6uqdfDAwU7XW1lZqUOHDtnSPXv21PDhwztdry99/PHHampqsqVHjRql7z7zXQ0aPKjd/AkJCXrggQc0d+5cSdLBAwdVU1PjUltlZWX6/LPPbelHvvmI7plzj3r06NEmr8Fg0MiRI/VP3/snDRw40La8tLRUK5avcKk9bzl46Mq+ER0drW8++s12+yy1vBszIWeCnn76aUVGRupUwSldvHjRX13tcnbt3KVt27bZ0kajUXfceYd+9OMfadbtszRq1CgNHjxYw4cP14033qgnvv2Ennr6KcXGxspisWjjho7fYbrMYrFow9cb7Jbd/8D9mjJlikJCQtrkT0tL07ee+JYm5EyQ1PLujL8dP3ZcO3fstKV79+6tZ555RkOHDnVYpmfPnrr//vs1+67ZkqTQ0FCNHzdexhCjXT6LxaIvVn1hS8fGxuof/+kfNXHSRIWGhjqs32g06sYbb9QtU2+xLauuqtbp06fd/nxXO3LkiJqbm23p6TOma+zYsQ7zJyUl6bHHH9OECS3fz9X7kT989NFHdmPnnDlzdM899ygyMrLd/AaDQVnDs/Tss88qMTFRkpSenq6MjAy/9BfXttbzr8lk6jJzcHuCbfySArONjx09prq6Olt69uzZ6tmzZyc+he/4cj4LJq2/k/Hjxwft99LV5l1/iekRo4EDB3r8X3pGeqA/gk1DQ4Pefuttu/fxe/furWeffVbz5s/T4MGD2z0HlqSQkBANHDRQc+fN1TP/+IzdPlxaWqovvvii3XJ9+vTR+PHjbf8F07VwVVWV1qxdY0uHhITojjvvcJi/K45b18L5qTfG2WA8LxozZozCwsNs6bz8PK/Um59nfw2bk5vjUrnKykpJ0qzbZ+mRbz6ipKSkdvNl9MvQd576jt39NYvFoo8+/MjlPtbW1spsNispKUnfe/Z7mjBhQrtjU3h4uKbeOlVPPf2UoqKibMsPHTqkA/sPOKzf02M5WM8//HkPzx2DBw/WlClTbOkTJ05o/fr17ea1Wq1atGiRGhsbbcsemPuAYmNjvd4vbwjGMSNY+WPuLCoq0tfrv7alIyMj9Z3vfEfTZ0x3ON8NGjRIT3/3aQ0adOU4KSoqkqX1D17/z/LPl+vSpUu29JAhQ/RP3/snDR8+vN3fB/bs2VP33XefHnroIbvxa9myZSovL3f42f3p448/Vm1trS09duxYPf3dp+320atFRUVp+ozpeuSbj8hovPJdnD7V+WtnbwvEdY2/r/sYh1p0x2PTl86ePevx9822dm7xu4tVUlJiS5tMJt1737368U9+rClTpigtLc3h78nDw8OV0S9Dt027TT/4wQ/0rSe+pZgeMU7bC+Tz7GC7ToHnfH2e5uv52B/PA7Zt22Z3rdS7d2/9w5P/oJSUlDZ5Q8NCNXHSRD393acVFRWlS5cu6dixY04/g7f5+jvdunWr3Vh385Sb9djjjyk1NdVpv5KSkvT4tx63Ozd3dM1+ww032N1HjOsV57RuAAAAAAAAAACCEbHaPe9rsCFWu38Rqx0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKBrI1a7530NNsRq9y9itaO7czCMAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQfVmbpXX/Kw0aLUX2bLt+6BTpwFqpaL/98gNfS4NvljInSlfHrx41Uzq9UzrScfxv1/tolRpqpC9flw4sk9ROLOzwKOm2Z6TMSS1B59tjbpA2vSvlv9cS/P3wRen0Lmns3dLo2VJUrP1n6Yo6Gyi8rq5OX3/9te677z6FhIQ4zHfzzTcrOTlZp06dsi1LTk7uMJC4xWLRhx9+2Kk+BgODwaCkpKQO8zU0NMjS+l858KLvfe97Tr8ns9msv/71rx3Wc/78eeXn5yszM9NhHqPRqGeffVaffPKJmpubPeovAAAAAAAAAAAAAAC+ljU8S7Gxsbb09u3bvfbsPj8vX8OHD7elc3JztG/fPq/U7Qvnz5/X+++/r/nz58toNEqS+vbtqyeffFIVFRUqKipSTU2NIiMi1Su+l1JTU23/kH11dbXef/99/eCHP3C5vQ0bNigpOUkTJ06UwWDQpEmTlJubq6KiIpWWlspsNismJkbp6emKjo62K1tVVaVXXn5FDQ0N3tsALli7Zq2ys7MVGhoqSRo0aJB++rOf6sjhIzp37pzqG+oVER6h+Ph4DR4yWDExMZKkmpoavfPOO3r8W4/7tb9dzfvvvS+TyaTRo0fbliUmJmrq1KlOy3227DOVlZVp0o2TXG5r/fr1GnndSPXr109Sy7sud9x5h6beOlWnTp1SdXW1IiIilJiYqJSUFFu5kydPasvmLcrOznbvw3nBkiVL1Dult1JTUyVJCQkJ+tYT39KlS5d08uRJVVVVyWqxKqZHjOLj4zVgwADbsSy1vOv12uuvqamxqU3deXl56te/n8aPHy9JioyM1Jw5c3TnnXfqVMEplZSUqK6uTlarVWHhYYqPj1f//v0VFRVlV8/y5cs7/U5aVVWV8vLyNHHiRElSSEiIFixcoFtvu1XHjx9XZUWlrNaWz5mRnqG+6X1tn/Pr9V/r1KlTts/hD+fOntOSD5Zo7ry5tn5MunGSJuRM0MkTJ3Wx5KLqausUHhGunj17ql+/fnbzjiRt3bpVmzdv9lufcW27ev6V1GXmYEeCafy6zN/buLGxUWvXrtWsWbMkSZNvnqzJN09WTU2NGhsb7T7X839+XlVVVV75nJ7y5XwWLFp/J1Lwfi9dbd71l8zMTKfvSXfk0qVL+vWvfu3FHnXOqVOn9Oorr+qb3/ymwsLDJLV81+PGjdO4ceNksVh06dIl1dbWqqmpSWFhYYqIaLmuae/d87KyMr304ktqagre49CZdWvXKScnx3ZONnLkSA0aNEjHjx9vN39XG7euhfNTb42zwXZelJObY/vbbDZrx/YdXqm3qKhIxcXFtn24T58+yuiXodOnTjst9/lnn+u2abcpMTFRI0eO1MiRI3Xu3DlduHBBDfUNioqOUmpqqnr16tWm7NJPl9r9fqgjZWVlytuSp3vvu1fR0dG6/4H7defsO3X69GlVVlYqxBii2LhYZWRkyGQy2ZUtKSnRoncWddiGJ8fyZcF2/uHve3iuiIqK0vwF823t1NfX691F7zo9xy4pKdFnn32mOXPm2NXx4v++6LVzc28KtjEjmPlj7ly2bJmSeydr6NChkiSTyaRp06Zp6tSpKiosUllZmRobG9WjZw8lJyUrPiHervyZM2e09NOlDuuvr6/Xq6+8qie/86TtHm9SUpIefexRVVdX68zpM6quqVZYWJgSEhKUlpZm2/8v2/D1hqCaT8vKyvT2W2/rm49+03Z/OyMjQ9956juqrKxUUWGRamprZDKZ1Cuul1LTUm35pJbfeb733nsqKysL1EdwKBDXNYG47mMc6p7Hpq+tW7dOw7KGafDgwW6VY1s7V1NToz//6c965JuPaODAgbblCQkJuuPOOyS1nNPX1NSotrZWFotF4eHhioiIsG3P9lRVVWn58uVtlgfyeXawXaegc3x5nuaP+djXzwOampq0ePFiPfroo7YxLT09XT/44Q90tvisLly4oCZzk3r1arnOioyMlNQSr+PDJR9q4qSJLn0P3uTL79RsNuvNv7+pJ7/zpO2zZmVlKSsrSyUlJSosLFRlZaWamppkCjEpOiZaffr0sbsGlVqu/fLy8ny8JQAAAAAAAAAACBxitROr/WrEancNsdqJ1Q4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALo+YrUTq/1qxGp3DbHaidV+LTAFugMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARCTYn05QvSzB9IoaH266J6SrkPSst+JdVXX1lutUir/iz1SJb6DL4S9DwkVJr6Han8nHTheOf7ZmmWzuyT1rwiXTjcfp7YPtKcX0rJGe2vt1ql8vPSupelI1/br6urkja+Je39Ssp+QMrMlaJ7df0g7p3xxRdfqLS0VMnJyQ7zxMTEaPLkyXrzzTdty2bOnKnQ1jtQK/v379eZM2e81tdACQsLU3Z2dof5SkpK1NTU5JM+JCUl6fbbb3eaZ9OmTTp06JBL9b3wwgtauHChjEajwzy5ubnKysrSvn373OorAAAAAAAAAAAAAAD+kpuba5fOy8vzWt0HDx5UVVWVevToIUnKzMxUfHy8Ll265LU2vG3njp1qbm7WAw88oIiICNvy2NhYxcbGtlvm/Pnzeu3V11RVVeV2ex99+JHKLpXpjjvvkNTyj8Wnp6crPT3dYZnTp0/rrbfeUtmlMrfb66zy8nK99dZbevjhh2Uytfwz5yaTScNHDNfwEcPbLVNaWqrXXn0tqL/3YGGxWPT2W2/r+LHjmjlrpqKjo53mr6mp0eJ3F+vgwYO67rrr3G7r9dde16OPPaqMjCsvkkVGRmrYsGHtljl+/Lhef+11JSQkuNWWtzQ0NOiFv7yghQ8u1PDhV/a3+Ph4xcfHOy174cIF/f2Nv+v8+fMO87y3+D1VVlbqlltusb0TFBoaqsFDBmvwkMEd9u/LL75Ufn6+i5/GuaWfLlXv3r01aNAg27Lk5GSH76hZrVatXbtWn3/2uUaNGuWVPrhj+/btqqur04KFC2xjp8lk0pDMIRqSOcRhOYvFojVr1mjlipX+6iog6cr8O2PmDNt8FuxzsDPBNH5d5u9tvGb1GqX0TtGYsWNsy6Kjo9vMpYYgeOHZ1/NZsGjvO5GC83vpavMuPHP06FH98Y9/1Lz58zRgwAC7dUajUYmJiS7Vs2fPHn380cceXf8Fi6amJi3/fLnmL5hvWzb7rtl67n+ek9VqbZO/K45b18L5qbfG2WA5L0pPT1daWpotvW/fPtXV1XmlbknKz8vXPXPusaVzc3N1+tRpp2Xq6uv08ksv6+FvPGzrW0pKilJSUhyWaWpq0icff+LR/bXNmzcrPDxcM2fNVEhIiCIiIpSZmem0TEFBgf7+xt9VW1vbYf2eHsvBev7h73t4HZk7d65du5988onKyjo+PjZt3KSRI0baxqbBgwdrypQpWrNmjdf76A3BMmYEO3/MnRaLRa++8qruuusuTbpxkm15SEiIMvplKKOfgx+OSjp06JDefuttmc1mp22cP39ez//5eT308EPq27evbXlMTIyyhmc5LHf5XOPrr792mCdQjhw5ohf+8oIe+eYjiouLsy3v2bOneg7v6bBcfX293lv8nvbu3euHXnomENc1gbjuYxzqnsemr7276F19/wffV1RUlFvl2NbO1dbW6sX/fVG33HKLJt88WZGRkXbrTSaT03Ozq9XV1Wlr/lZ98cUXqq+vb7M+UM+zg/E6BZ3j6/M0f8zHvn4ecPDAQX3wwQe69957FRISYlveJ7WP+qT2aZPfbDbr3UXv6vDhw5o4aaJLn8GbfP2dFhcX64UXXtBDDz2k3r1725YnJia6dD+xtLRUL7/0cofn3gAAAAAAAAAAdHXEaidW+9WI1d4xYrUTqx0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHQPxGonVvvViNXeMWK1E6v9WmAKdAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiUIxuktDHSmGmSoVXs5v6jpbF3SZsWSbJeWV5X1hLAfc7PpNjeV5b3TJJm/JO08rnOBXBvapB2fSptfk+qr2y73mCUBuVKkx+TEvu2X4fVKp07LK36i3T+iOO2Ks9KX/1F2rtcyp0vDZ4oOYlh3a2dOHFChYWFToO3S9KCBQvsgrfPnTu3w7pfffVVWa3WDvMFu7i4OOXm5naYr6ioSI2NjT7pw6xZs5SQkOBwvcVi0dtvv+1y+zt27FBRUZHS09Md5jEajXrqqaf01FNPud1fAAAAAAAAAAAAAAB8LS4uTpmZmbb0yZMndfHiRa/Vb7FYtH37dk2ZMkWSZDAYNCFngpZ/vtxrbfjCnt17dKrglKZNm6YxY8coLCys3XyNDY3akrdFq1auUkNDg8ftrV27Vr1TemvUqFEKDQ11mO/c2XNat36dtm/bHtD3SQ7sP6A/Pfcn3Tn7Tg0ZMkQGg6HdfLW1tdq4caPWrFmjpsYmP/eya9uyZYu279iukSNHatjQYeqd0ltRUVGyWqyqqKxQeVm59u7dq4MHD8psNkuSDEb778FisXTYTnV1tf76wl81efJkTblliiIjI9vN19DQoI0bNmrVqlVqbm7u9OfrjIaGBr326mvKysrStOnT1LdvX4f7oCSVlZVpw9cbtHHjRpf6vmL5Cu3atUtTpkzRyJEjFR4e7jR/c3Ozjh49qi+++EKnT512+/M4Yjab9eL/vqgpU6bopptuUkyPGId5jx07ppUrVqqgoMBr7XviwIED+s1vfqNbb71V48aNc7g/SS3b7eCBg/ryyy9VVFTkx14CV6xdu1b79+/X1Fundpk52JlgGb+u5s9tbLVa9c4772jPnj1asGCBwsLbP38LFr6ez4LB1d/JxIkT1a9fv6D9XrrivAvPlJaW6oW/vKBBgwcpNzdXQ4cOVURERIflGhsatXffXuVtydPJkyf90FPf2759u26afJPS0tIkSWlpaRo3bpy2bt3abv6uOG519/NTb46zwXBelJObY5fOy8vzWt1Sy+8/7px9p0wmkyRp1KhR+vSTT1VXV+e0XGlpqZ7/8/OaNm2aJk6a6HDMMJvN2rtnr1atWqWSkhKP+7l27VqdPHlSs2fPVr/+/RzmKykp0do1a5Wfn+/W9+Dusbz006VBff7h73t4juTk5GjEyBG29L59+7Rt6zaXyy9evFg/+OEPbOPUjJkzdPToURUWFnq9r94QDGNGV+CPudNisejjjz/Wtm3bNG3aNA0dNlQhISEO858/f16rv1qtHTt2uPw5SktL9ec//Vnjxo/T5MmT1bt3b4d5GxsatXv3bn311VcqLS11uQ1/Kyws1O9++zvlTszVTTfdpLi4OId5m5qatGvnLq1atUrl5eV+66MnAnFdE6jrPsah7nls+lJFRYWWLFmihx9+2O2ybGvnmpub9eWXX2rDhg2aOGmihg8frvT0dBldCDhQW1urU6dOac/uPdq1a5fteVdrgXyeHazXKegcX56n+Ws+9vXzgPy8fBUXFeuOO+7Q4CGDHeY7feq0Pvn0E589Y3CVr8+9z509p//+438rOztbuRNz1adPnw7LlJeXKy8vT+vWreNdCQAAAAAAAADANYNY7cRqv4xY7R0jVjux2gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQPdBrHZitV9GrPaOEaudWO3XAoPVxaPV2T/GDQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAVxWTKN3/Syl5UNt1jXXSh/8mnd7Vdl3/G6W7fySFR9gvLz8rrX5ROrapJZ0wRnrs11JHYX7NTdK5Q9LaV6SzhyWrpW2esChpyhPSsJuliOj267E0Sye3Sct+JzVUO2/zasZQKetW6ZbHpaiebdd/9Tdp+0eu1ydJgwYN0pYtW5wG25ak73//+3ruuec8CnBuMpm0bNkyTZ8+3WEei8Win/zkJ/rDH/7gtK5f/vKX+vnPf+40T3V1tXr37q26ujr16tVLO3fuVEZGhsP8NTU1uu6661RQUOC03svS09N14sQJhYSEOMxjNpv17W9/W6+//nqbdTNnztTnn3/utI2ysjKNGDFC586dc6lPlz322GN66aWXnMastlqt+sEPfqD/+Z//sVt+yy23aNWqVU4/lyRlZ2dr27Zt7a6LiorSm2++qTlz5jgsb7FYtGbNGm3dulUWSzsHUSvh4eH6xje+oaSkJKf5Tp48qQkTJqikpKTDOuG+yY9KOfN8385vZ3j+jygQqx0AAAAAAAAAAAAAuq7Q0FANGDBAvVN6Kzo6WgYZVFNbo/PnzuvEiRNqamryXlthoRrQf4B6925pyxhiVEN9gy5duqQzZ84E5bsHsbGx6te/n+Lj4xUZGSmr1arq6moVFxer4GSBS+9gwDuys7P1wNwHbOm33nxLu3fvdrm80WhU//791Se1j2JiYmQ0GlVbU6vz58/r+PHjXt3XvalHjx4aMHCAevbsaet3Q0ODKsorVFhUqHNn3XvP6WpGo1F90/sqOTlZPXv2VHh4uAwGgxoaGlRXV6cL5y+oqKhIdXV1XvxEbYWEhCg9PV2paamKiopSeHi46uvrVVpaqoKTBSovL/dp+54wGAzKyMhQSkqKomOiFRUZJbPZrJraGl28cFEFBQWqr68PdDcBm644BzsTLOPX1fy5jQ0Gg2JiYhQZGdnm3dPz588H5fmJL+ezYNFVvpeuOO/Cc0ajUSkpKUpOTlZsbKzCI8IVFhqmxqZG1dXVqaa6RsXFxbpw4ULQ7KPBoquNW9fC+am3xtnudl7kjlGjRumhhx+ypV977TUd2H/AljaZTBo4cKB6p/RWTHSMJKm2tlYXLlzQyZMn3d6HfvTjHyk5OVmSVFRUpP/57/+xW5+QkKD+/furV3wvhYeHtxxjFRU6c+aM146xrnYsO+PPe3i44loeM9zlj+MtNCxUAwcMVHx8vKJjom3nshXlLWPH+fPnO91GUlKS0tPT1atXL0VERrTMpzU1OnfunApOFshsNne6DX9LSkpSRkaGYmJiFB0dLYvVopqaGl043zK+NzY2BrqLbgvUdU0grvsYh1p0x2MzWLGtOxYeHq6MjAz17NlTUVFRio6JltFgVF1dnWrralVXW6dz587pwoULge4qIMl352n+mo99/TwgNjZWgwYNUmxcrKKiomzXpqcKTgXtcezrc+/Y2FilpaUpITFBkRGRCgsLk9lsVn19vcorynXu7Dm3Y3EAAAAAAAAAANBdEKu9BbHaidXeEWK1E6vdV4jVDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAYBCrvQWx2onV3hFitROr3VeCKVa7yffdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgeFWXSJ8/Jz3wSyk6zn5dWKR0x4+kxT+RLhXaryvYIH1ULc34nhSXciU4e1wf6a6fSoc2SZvfliJjpeYmyRTWtu2meqnignT+qLRrhVS8V2ovfnlIqNRvnDT121KvPu0HgrdapcoSacv70p6l7Qd/d8bSJB36Sorv0xJEuaNg893Ra6+9pp/+9KcyGo0O80RFRSk3N1erV69WTk6OEhMTnda5atUqnT171ttd9bs+ffrot7/9rdPA7ZLU0NCgQ4cO+aQPw4cP19SpU53mMRqNmjp1aof5rtbRZ5Kkvn37atasWXrzzTddrhcAAAAAAAAAAAAAAASHpqYmHTlyREeOHPF9W43+a8tbKioqtGf3nkB3A5J69epll66pqXGrvMVi0YkTJ3TixAlvdsvnqqqqfLYPWiwWnT51WqdPnfZJ/a5qbm5WQUGBCgoKAtoPd1itVp06dUqnTp0KdFcAl3TFOdiZYBm/rubPbWy1WlVVVaWqqiqft+UtvpzPgkVX+V664rwLz1ksFhUXF6u4uDjQXelyutq4dS2cn3prnO1u50XeZDab/bptSktLVVpa6tM2utqx7Iw/7+HhCsYM1/njeGtqbNLhw4d92sbFixd18eJFn7bhb93xMwXquiYQ132MQy26434crNjWHWtoaNDRo0cD3Q3AZb46T/PXfOzr5wEVFRXasWOHT+r2FV+fe1dUVKiiosJn9QMAAAAAAAAA0JURq70FsdqJ1e4MsdqJ1Q4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALofYrW3IFY7sdqdIVY7sdqvFaZAdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgEC7cFha9Rfp9mel8Cj7dTEJ0sx/kpb+Tqq6aL/u9C7pw3+TbntSyhh9JeC5KVQaebOUOUHa8Zn0/i+k+BQpOl4KMUnNZqnmklRWKJUUSnVl7QdtNxil+H5SzgPSsJtbyjpyYqu0/lXpYoGkdurqSHiMlH2/NP7eazNwuySdOXNGx44dU2ZmpsM8BoNBd999t9atW6cbb7xRkZGRDvNaLBYtXbpUDQ0Nvuiu3yQkJOill15SfHx8h3lLS0u1f/9+r/fBaDTqnnvuUWxsbId5XQnG7q7Q0FDdcccd+uCDD1RXV+f1+gEAAAAAAAAAAAAAAIB+/frZ/rZarSouLg5gbwAAAAAAAAAAAAAAAAAAAAAAAAAA1xJitROrXSJWuyPEaidWOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA6L6I1U6sdolY7Y4Qq51Y7dcSJ8MsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADXjmMbpA0J0s2PSaawK8sNBiltpDTzWWnpb6T6SvtypQXSR/9PGndfS/Dz0Igrwc/DIqSmKunMDumMWoKxX2a1OO9PfIZ0/R3SsElSzyTH+RpqpO0fSvlLpEZPYkobpJRh0k2PSP1H2ffxWmM2m/XGG2/oP//zPx3mMRgMuuGGGzRs2DBlZ2c7DRR+8eJF5efn+6KrfmEwGDRmzBj953/+p2699VaXgqIXFxeruLjY632Jjo7WwoULvV6vO6ZOnaohQ4Zoz549Ae0HAAAAAAAAAAAAAAAAgltaWppKSkrU0NDgcpm4uDgNGjzIlj5//rxqa2t90T0AAAAAAAAAAAAAAAAAAAAAAAAAANpFrHZitROr3R6x2u0Rqx0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHRXxGonVjux2u0Rq90esdqvDaZAdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgGBgtUg7PpFkkCY/0hKE/TKDUeo/Vpr3W+mDn0k1l+zLNtZJm96S9n8hjblLGjheiu0jmULbtuGQoSV/8iBp4kNS2nApLPJKIPjWGuqkUzultS9J5R7Gyo6MlW78hjTiVvug89eyTz/9VP/yL/+imJgYh3kGDBig73//+xo3bpzTuvbs2aOTJ096u4udZjQaFRsbq4sXL9otNxgMMhqN6tmzp8aOHaunnnpKt9xyi2JiYlwK3C5Jb775ppqbm73e5xkzZqhfv35er9cdiYmJmj9/vvbu3Sur1RrQvgAAAAAAAAAAAAAAACD4GAwG3TzlZs2cOVMHDhzQ39/4u8tl7733XhmNRlt6y5YtvugiAAAAAAAAAAAAAAAAAAAAAAAAAAAOEaudWO0SsdqJ1e4YsdoBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEB3Rax2YrVLxGonVrtjxGq/NpgC3QEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIKF1SLt+EiyNks3P9YqgLtBSh4gPfAr6YvnpaL9klrFb6443xJMPW+xlJzZkr+pUTKFSZZmyWJpKWMwSkajFBImRfSQYpOlwROkwTdKcSnOg6ibm6RTe6Sdn0oFW1vqdVd0L2nIjdLEB6WYXu6X785OnTqlDRs2aObMmQ7z9O7dWwsWLFB4eLjDPBaLRV9//bXq6up80c1OiYmJ0RtvvKELFy7YLU9NTVWfPn2UmJio0NBQB6Udu3Dhgt555x1vddPGaDTq5z//eYcB5C0WS6eCqhuNxg7bePzxx/Wb3/xGlZWVHrcDAAAAAAAAAAAAAACA7mnGjBm69bZbJUnXXXedHv/W43pv8XuqqqpyWCY6Olr33nevsoZn2ZZVVFQoPy/f5/0FAAAAAAAAAAAAAAAAAAAAAAAAAKA1YrWDWO3EaneGWO0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKC7IlY7iNVOrHZniNXe/ZkC3QEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIKJ1SrtXCo1NkpTH28Jrn7Z5QDud/2ztGWJtHupZDG3raOuUjq1TTq1XUoZL838vtRYKzXUtASIN4VJ4TFSjwSpV7oUEy+FdBAx2GKRygqlta9Ip3dLTR7EBI/oIY24TRo+Veo9SDKGuF9Hd1dTU6M1a9ZoxowZDgN5G41GRUREtLvussbGRi1dutQXXey0kJAQZWdne7VOq9WqX//617p06ZJX65WkoUOHatCgQU7zlJaW6oEHHtDFixc9bufZZ5/Vo48+6jSAe1JSkmbMmKH333/f43YAAAAAAAAAAAAAAADQPW3evFnZE7LVo0fLS2fDhg3Tz37+M504fkInTpxQdXW1autqFWIMUUxMjDL6ZWh41nCFhYfZ6mhubtZbb76lpqamQH0MAAAAAAAAAAAAAAAAAAAAAAAAAMA1jljt1zZitXuGWO0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABdH7Har23EavcMsdrRXXQwFAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcO2xWqR9K6RLp1oCryf0bQncflmPJGnqt6TMXGn1i1LJiZYybSuSmpqkrCn25V1laZbqqqRzR6RtH0pF+yVzo5uVGKQeidL4+6TBuVLPRMlIdGKHrFar1q9fr4qKCsXFxXlcz/nz57V//37vdSyINTc364MPPtArr7zik/ofeeQRRUVFOc3z9ttva/369bJY2jsQXfO73/1OCxcu7DAw/49+9CMtWbKkTVu9e/fW2LFjVVtbq127dqmiosLjvgAAAAAAAAAAAAAAAKDrqaio0IsvvqjHHntMvXr1kiSFhIRoSOYQDckc0mH5uro6vfPOOyooKPBxTwEAAAAAAAAAAAAAAAAAAAAAAAAAcI5Y7dcuYrW7j1jtLYjVDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAugNitV+7iNXuPmK1tyBWe/fA8AgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQHusUvEB6f2fSZMfbQnUHnpVTOcQk9RvlPSN/5EOb5K2vi9dOiM11XeyWatUVdISqL1wv1SwXSorbumPywxSeLSUNEgae6c0ZGJLf+Ga/fv36+TJkxozZozHdbzxxhsym81e7FVwslqtWrJkiZ566ilVV1d7vf7ExETddtttMjj51w9qa2v14YcfdipwuyQdO3ZMJ06c0PDhw53my8zM1HXXXafdu3fblk2cOFGjRo1SQUGBTCaTnnjiCb333ns6ffp0p/oEAAAAAAAAAAAAAACAruXc2XP67z/+t6ZNm6bsCdkKDw/vsIzFYtGuXbu0auUqlZaW+qGXAAAAAAAAAAAAAAAAAAAAAAAAAAC4gFjt1yxitbuOWO0tiNUOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC6FWK1X7OI1e46YrW3IFZ798FQCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAE1XnpZX/LZ3cKt38uNQjwX59SKg0/GZp8HipcJ90PL8l6PulIqmpQTIYnddvtUgNtdLFgpZA7WePSJcKpdpLkrnRvb6GhEoJGVK/cdLgbCl1aMsyuKe6ulo7duzwOHi72WzWkiVLvNyr4GM2m/X666/rxz/+scrLy33SxtixYzVs2DCneXbv3q39+/d3ui2LxaI333xTv/71r53mi4mJ0Zw5c7Rnzx5ZrVaFh4crJSVF69ev18MPP6zTp0/ro48+0oMPPthhXQAAAAAAAAAAAAAAAOh+6urq9Omnn2rFihUaPHiw+vfvr4TEBEVFRik0LFTNzc2qralVZVWlThWc0rFjx1RZWRnobgMAAAAA0KUdPHhQv/n1b2zpyirfXmu/9OJLCgkJkdTyGxsAAAAAAAAAAAAAAAAAALozYrVfe4jV7hpitROrHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAdG/Ear/2EKvdNcRqJ1Z7d2QKdAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAh25gbpwFfSqd3S5EekIROl8GjJYLiSJyxKGpgt9b9BaqiRqkql2gqp8KD0wU+liDjJFNoSrN3cJNVckmrLpJoKqalesphb1rnLaJLi+kjXTZf6jZFie0sRMR0HjYdzr7/+uh599FEZje5vyP379+vo0aM+6FXgWa1W1dbW6tixY/rXf/1XrVixQmaz2SdthYaGauHChYqKinLan9WrV+vSpUteafPdd9/VL37xC0VERDjMYzQadffdd+tvf/ubzp07p9DQUF28eFEVFRWaMGGCIiMj9frrryssLExGo1EWiwcHNgAAAAAAAAAAAAAAALq8xsZGHThwQAcOHAh0VwAAAAAA6PYaGxtVWlrqt/bKy8v91hYAAAAAAAAAAAAAAAAAAMGAWO3XHmK1t49Y7cRqBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1xZitV97iNXePmK1E6u9uzMFugMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHQVNSXS8j9IWxZL18+QMm+U4lLsA6UbQ6TIni3/SdKZXdLJHd7rQ0ioFBYp9UqThk2Wht0iRcfZB5IPJhaLpcPg1VartVNtWK1Wp21YLBa329i+fbtKSkqUmJjodn8WLVqkhoYGt8tdZrFYZHDyhTr7PB1tC1dZrVY1NzersbFRlZWVKi4u1okTJ3T8+HGtWLFCeXl5amxsdKu+jj5Xa2lpabrnnnvU3NzsME9VVZU+++yzTu9Dl509e1Zr1qzR9OnTneYbNmyYcnJy9PHHH6upqUlJSUkqLS3V66+/roaGBiUmJqq2tpbA7QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoNsgVrv7iNXuPmK1tyBWOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQPAgVrv7iNXuPmK1tyBWOwLBYHVxb3JnZwYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoLszGKSeKVL6KClrspR+vWQKbZvv69elzYs8byfEJEXGSrGpUnyqlDFa6jtS6pHQEijeX776m7T9I/fKREVFKTc3V6Gh7WyYqxw8eFCnTp3yqF8Gg0Hjxo1TQkKC03yHDx/WyZMn3ao7JydHcXFxbvdp+/btunjxotvlJCkiIkJTpkxxmsdqtWrfvn0qKipqsy4xMVHjxo3zqO2r67dYLKqpqVFVVZXq6+tVUVGhiooKNTY2ehQoPT4+XtnZ2R3m27x5syoqKiRJycnJGj16tNP8DQ0N2rRpk5qamtzukyODBw/WwIEDO8x38uRJHT16VJI0fvx45eTkaOvWrYqLi1N2drZefPFFnTt3zmv96s4mPyrlzPN9O7+d4XmQf2K1AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwBbHaO0asdvcRq51Y7dciYrUDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANC1EKu9Y8Rqdx+x2onVfi0KpljtBquLezjB2wEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaJ8xRIrqJWWMkobkSmkjpNBIyWiQNr8rbXExeLshRIqIkWKTpeQhUuowKTZFikmQeiRKoeEtQeMDwZPg7cC1wmAwKD4+XqmpqTKbzTpz5oyqq6sD3a0uI5iCtztCrHYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANpHrHbg2kas9s4hVjsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAF0XsdqBaxux2jsnmGK1m3zfDQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAujdLs1RdIh34quU/g1EKj5ai4qSELGlArtRQLjXUtKwLi5LCo6SeyVJUvJTQV0oeLMXES6FhkgyS0diSF0Dws1qtKi0tVWlpaaC7AgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4FfEageubcRqBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1ypitQPXNmK1dx+mQHcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDuxmqR6qta/jMkSo/9WjIYAt0rAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPAtYrUDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuBYRqx0AuiZjoDsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIC/GAPdAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/MUY6A4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOAvxkB3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfzEFugMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHRnNaelr16QZAh0TzqncG+gewAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgKyFWOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBrEbHaAaDrMAW6AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA/5+deydsGABgKBiLP5oCKZPu2RwCHbxEyudu1vAQCAAAAIBPdv+73X5/1hUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAF2+2gEAAAAAAAAAAAAAAAAAAAAAAAAAAACAb+SrHeB9ZB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALVkHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEvWAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANCSdQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC0ZB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALVkHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEvWAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANCSdQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC0ZB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALVkHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEvWAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANCSdQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC0ZB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALVkHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEvWAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANCSdQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC0ZB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALVkHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEvWAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANCSdQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC0ZB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALVkHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEvWAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANCSdQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC0ZB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALVkHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEvWAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANCSdQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC0ZB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALVkHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEvWAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANCSdQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC0ZB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALVkHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEvWAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANCSdQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC0ZB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALVkHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEvWAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANCSdQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC0ZB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALVkHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEvWAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANCSdQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC0ZB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALVkHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEvWAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANCSdQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC0ZB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALVkHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEvWAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANCSdQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC0ZB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALVkHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEvWAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANCSdQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC0ZB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALVkHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEvWAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANCSdQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC0ZB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALVkHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEvWAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANCSdQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC0ZB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALVkHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEvWAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANBynOd5Xhoex7NbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACe4uIt+798tQMAAAAAAAAAAAAAAAAAAAAAAAAAAAAA78pXOwAAAAAAAAAAAAAAAAAAAAAAAAAAAADwja58tafQAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC8h6wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABoyToAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWrIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJasAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAl6wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABoyToAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWrIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJasAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAl6wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABoyToAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWrIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJasAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAl6wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABoyToAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWrIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJasAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAl6wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABoyToAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWrIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJasAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAl6wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABoyToAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWrIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJasAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAl6wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABoyToAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWrIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJasAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAl6wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABoyToAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWrIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJasAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAl6wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABoyToAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWrIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJasAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAl6wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABoyToAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWrIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJasAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAl6wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABoyToAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWrIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJasAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAl6wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABoyToAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWrIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAe7M4xDQAAAAKgzf6hbaEPJAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUvfuPrbuu9zj+Pt9z2u0cHOnEo4OkouIYsMaJUsMf2jPMILEskFQ5EUVHXGWLojZkC40mRON/m2YqRB0jcsQB0WVqdKHGGByLQYUZ3RAjW0YkCxnMxMaQdHRk6/3jxpt7b2A/2Pl+Pm15PJL9teb1fm5/tP1j+xQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgFSK3AEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQSpE7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFIpcgcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAKkXuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEilyB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqRS5AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACCVIncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApFLkDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBUitwBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkEqROwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABSKXIHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQCpF7gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABIpcgdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKkUuQMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAglSJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKRS5A4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAVIrcAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJBKkTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUilyBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAqRe4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASKXIHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACpFLkDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIJUidwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACkUuQOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgFSK3AEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQSpE7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFIpcgcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAKkXuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEilyB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqRS5AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACCVIncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApFLkDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBUitwBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkEqROwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABSKXIHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQCpF7gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABIpcgdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKkUuQMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAglSJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKRS5A4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAVIrcAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJBKkTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUilyBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAqRe4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASKXIHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACpFLkDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIJUidwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACkUuQOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgFSK3AEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQSpE7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFIpcgcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAKkXuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEilyB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqRS5AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACCVIncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApFLkDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBUitwBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkEqROwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABSKXIHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQCpF7gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABIpcgdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKkUuQMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAglSJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKRS5A4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAVIrcAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJBKkTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUilyBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAqRe4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASKXIHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACpFLkDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIJUidwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACkUuQOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgFSK3AEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQSpE7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFIpcgcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAKkXuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEilyB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqRS5AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACCVIncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApFLkDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBUitwBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkEqROwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABSKXIHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQCpF7gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABIpcgdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKkUuQMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAglSJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKRSyx0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMCpVSqVeMtb3hIXXnhhvO1tb4tGoxELFy6MBQsWxIIFC6JSqZz15r333ltCKQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDsV5mZmZk5ow+sVMpuAQAAAAAAAAAAAACAN6QVK1bEsmXLur67c+fOOHHiRNd3AQAAAAAAAAAAAADmojN8lv1VeasdAAAAAAAAAABIbcmSJdFqtWLFihUxMDAQAwMD0d/fH7Varat3/PsomN+8fQvMNW9/+9vj1ltv7ermP/7xj3jggQe6uglnwtdhILe58HW13W53bes/fJ6E+cH3UgAAAAAAAAAA0H3eagcAAAAAAAAAAAAAAOB0vA0LAAAAAAAAAAAAwHx0Jm+1V2bO8EV3j7cDAAAAAAAAAAAAAEA5Nm/eHBs2bOj67nnnnRdTU1Nd3wUAAAAAAAAAAAAAmIvO8Fn2V+WtdgAAAAAAAAAAIIXBwcG4+eab49prr42BgYEkN/37KJjfvH0LzDVDQ0Px2GOPdXVz9+7dcc0113R1E86Er8NAbnPh6+q5/J+v1+LzJMwPvpcCAAAAAAAAAIDu81Y7AAAAAAAAAAAAAAAAp+NtWAAAAAAAAAAAAADmozN5q72WoAMAAAAAAAAAAAAA5pze3t7o7e2NBQsWRLVajYiI48ePx/T0dExPT8fJkyczFwIAAAAAAAAAAAAAAAAAAAAAAAAAADDXNRqNWL9+faxduzauuOKK3DkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbxi13AEAAAAAAAAAAAAAkNqiRYtixYoVsXTp0li6dGm8+93vjosuuiiazWY0m83o6+uLSqVyyo1jx47F0aNH/+fXs88+G88880wcOHAgnnrqqXjhhRcS/WkAAAAAAAAAAAAAAAAAAAAAAAAAAACYa3p7e+Nzn/tcfPnLX45ms5k7BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOANp5Y7AAAAAAAAAAAAAADK1t/fH9ddd12sXLkyrrrqqli2bFlUKpVz2qzX63HxxRfHxRdf/Kq/f/jw4fjDH/4Qv/vd72JiYiIOHjx4TvcAAAAAAAAAAAAAAAAAAAAAAAAAAACYH6688srYvn17XHHFFblTAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN6warkDAAAAAAAAAAAAAKAMK1asiE9+8pNxww03xLJly5Lf7+/vj/7+/rjpppvi29/+dhw8eDB++ctfxgMPPBD79u1L3gMAAAAAAAAAAAAAAAAAAAAAAAAAQF6bN2+ODRs25M54TTMzM/HKK6/EK6+8ElNTUzE5ORmTk5Px4osvxuHDh+O5556LAwcOxNNPPx2HDh2KmZmZ3MkwJ42NjcWmTZuip6cndwoAAHPEokWL4sUXX4x6vV7K/o4dO6LdbpeynVqz2YwjR45EtVrt+va6devi3nvv7fouAAAAAAAAAAAAAAAAAAAAAAAAAAAAp1apVOK5556L/v7+rm1eeumlcfDgwa7tAQAAAAAAAAAAAAAAAHNXLXcAAAAAAAAAAAAAAHRLX19fjI6Oxmc+85m4/PLLc+f8H0uXLo077rgj7rjjjvjLX/4S9913X/zgBz+IY8eO5U4DAAAAAAAAAAAAAAAAAAAAAAAAAICoVCrR29sbvb29cd5550Wz2XzNj52amoq9e/fG448/Hrt3747du3fH9PR0wlqYmzZt2hQbN27MnQEAwBzz0ksvxc9+9rP4xCc+Ucr+9ddfH/V6fV78/ISRkZGoVqtd352eno4f//jHXd8FAAAAAAAAAAAAAAAAAAAAAAAAAADg9K677rro7+/v6ubatWtjfHy8q5sAAAAAAAAAAAAAAADA3FTkDgAAAAAAAAAAAACAc/Wud70rvve978Xzzz8fmzdvjssvvzx30im9973vjXvuuScOHz4cd911VyxevDh3EgAAAAAAAAAAAAAAAAAAAAAAAAAAnLFGoxFDQ0MxPj4ev/rVr2JycjJ27doVt9xyS7zpTW/KnQez0pYtW2Ljxo25MwAAmKM6nU5p241GI4aHh0vbT6ndbpey+/Of/zz+/e9/l7INAAAAAAAAAAAAAAAAAAAAAAAAAADAqY2OjnZ9c82aNVGtVru+CwAAAAAAAAAAAAAAAMw9Re4AAAAAAAAAAAAAAHi9Lrzwwvj+978fzzzzTKxfvz4ajUbupLNywQUXxNe+9rV49tlnY2xsLGq1Wu4kAAAAAAAAAAAAAAAAAAAAAAAAAAA4a/V6Pa6//vr40Y9+FEePHo1OpxPve9/7cmfBrLFu3boYGxvLnQEAwBz2m9/8Jp5//vnS9tvtdmnbqTSbzWi1WqVsdzqdUnYBAAAAAAAAAAAAAAAAAAAAAAAAAAA4tQsuuCBuuOGGru8uWbIkhoeHu74LAAAAAAAAAAAAAAAAzD1F7gAAAAAAAAAAAAAAOFu1Wi3Gx8fj0KFDsW7duqjVarmTzklfX19s2bIlnn766Wi1WrlzAAAAAAAAAAAAAAAAAAAAAAAAAADgdavX67FmzZr405/+FI899lhcc801uZMgq8HBwbjnnntyZwAAMMfNzMzE9u3bS9tfvXp11Ov10vZTGBkZiWq12vXdI0eOxK9//euu7wIAAAAAAAAAAAAAAAAAAAAAAAAAAHB6t9xyS/T29payPTo6WsouAAAAAAAAAAAAAAAAMLfUcgcAAAAAAAAAAAAAwNm4+uqr47777ovly5fnTum6Sy+9NH7729/Gd77znRgfH4+XX345dxIAAAAAAAAAAAAAAAAAAAAAAAAAALxuQ0ND8eijj8bu3bvji1/8Yjz11FO5kyCpnp6euP/++6NWq+VOAQBgHuh0OnHnnXeWst1oNGJ4eDh27txZyn4K7Xa7lN3t27fHyZMnS9kGADgb73//+6PVanV1c+/evbFnz56ubgIAAAAAAAAAAAAAAAAAAAAAAAB00+joaGnbw8PDsWTJknjhhRdKu8EbgzcDAeY3n+cBAAAAAAAAAAAAYP6r5Q4AAAAAAAAAAAAAgDNRqVTiK1/5Snz1q1+NarWaO6c0lUolvvSlL8WqVavixhtvjEOHDuVOAgAAAAAAAAAAAAAAAAAAAAAAAACAc7Jy5cr485//HN/97ndjfHw8pqamcidBEnfeeWcsX748dwYAAPPE3//+93jyySdjcHCwlP12ux07d+4sZbtszWYzWq1WKdudTqeUXQCAs9VqteKb3/xmVze/8Y1vxJ49e7q6CQAAAAAAAAAAAAAAAAAAAAAAANAtg4ODMTAwUNp+rVaLT3/607Fp06bSbvDG4M1AgPnN53kAAAAAAAAAAAAAmP+K3AEAAAAAAAAAAAAAcDrNZjMeffTR+PrXvx7VajV3ThLLly+PJ598Mq699trcKQAAAAAAAAAAAAAAAAAAAAAAAAAAcM6q1Wp84QtfiP3798fVV1+dOwdKt3jx4ti4cWPuDAAA5plOp1Pa9urVq6Ner5e2X6aRkZFSfp7F3r17429/+1vXdwEAAAAAAAAAAAAAAAAAAAAAAAAAADi9tWvXln5jdHS09BsAAAAAAAAAAAAAAADA7FbkDgAAAAAAAAAAAACAU7nsssvij3/8Y6xcuTJ3SnKLFy+OiYmJ+NSnPpU7BQAAAAAAAAAAAAAAAAAAAAAAAAAAuuKSSy6JPXv2xO233547BUq1YcOGOP/883NnAAAwzzz88MNx/PjxUrYbjUYMDw+Xsl22drtdym6n0yllFwAAAAAAAAAAAAAAAAAAAAAAAAAAgFOr1+tx8803l35n6dKl8cEPfrD0OwAAAAAAAAAAAAAAAMDsVeQOAAAAAAAAAAAAAIDXMjQ0FL///e/jne98Z+6UbKrVavzwhz+M2267LXcKAAAAAAAAAAAAAAAAAAAAAAAAAAB0RU9PT9x9992xdevWqFQquXOg63p7e2P9+vW5MwAAmIcmJydj165dpe232+3StsvSbDaj1Wp1fff48ePx8MMPd30XAAAAAAAAAAAAAAAAAAAAAAAAAACA0/vYxz4W559/fpJbo6OjSe4AAAAAAAAAAAAAAAAAs1OROwAAAAAAAAAAAAAAXk2r1YqJiYno6+vLnZJdpVKJrVu3xpo1a3KnAAAAAAAAAAAAAAAAAAAAAAAAAABA19x2222xY8eOqNVquVOgq2688cZ485vfnDsDAIB5qtPplLa9evXqqNfrpe2XYWRkJKrVatd3d+3aFf/617+6vgsAAAAAAAAAAAAAAAAAAAAAAAAAAMDpjY6OJrt10003xaJFi5LdAwAAAAAAAAAAAAAAAGaXIncAAAAAAAAAAAAAAPx/H/rQh+KRRx6JRqORO2VW2bZtW6xatSp3BgAAAAAAAAAAAAAAAAAAAAAAAAAAdM1HP/rRePDBB6NSqeROga659dZbcycAADCPPfLII3H06NFSthuNRgwPD5eyXZZ2u13K7v3331/KLgAAAAAAAAAAAAAAAAAAAAAAAAAAAKd2ySWXxNDQULJ7jUYjPv7xjye7BwAAAAAAAAAAAAAAAMwutdwBAAAAAAAAAAAAAPC/XXbZZfGLX/wiGo1G7pRZp6enJ37605/GVVddFQcOHMidAwAAAAAAAAAAAAAAAAAAAAAAAAAAXdFut+Of//xn3H777blT4JwtXLgwPvzhD5d+5+WXX44nnngiHn/88Th8+HBMTk7GSy+9FCdPniz9NgAAeZ04cSIeeuihGBsbK2W/3W7Hzp07S9nutmazGa1Wq+u7R48ejYmJia7vAgAAAAAAAAAAAAAAAAAAAAAAAAAAcHpr165NfvOzn/1sbNu2LfldAAAAAAAAAAAAAAAAIL9a7gAAAAAAAAAAAAAA+I+3vvWtMTExEX19fblTZq1FixbFjh074gMf+EBMT0/nzgEAAAAAAAAAAAAAAAAAAAAAAAAAgK74/Oc/H/v27Ytt27blToFzMjQ0FAsXLixt/8iRI7F58+bYunVrTE1NlXYHAIDZrdPpxNjYWCnbq1evjnq9HseOHStlv5tGRkaiWq12fffBBx+MEydOdH0XAAAAAAAAAAAAAAAAAAAAAAAAAACAUyuKItasWZP87uDgYAwMDMRf//rX5LcBAAAAAAAAAAAAAACAvIrcAQAAAAAAAAAAAAAQ8d8P9v/kJz+Jd7zjHblTZr33vOc98a1vfSt3BgAAAAAAAAAAAAAAAAAAAAAAAAAAdNXdd98dAwMDuTPgnKxataq07T179sTy5ctjy5YtMTU1VdodAABmv3379sX+/ftL2W40GjE8PFzKdre12+1SdjudTim7AAAAAAAAAAAAAAAAAAAAAAAAAAAAnNpHPvKRuOiii7LcHh0dzXIXAAAAAAAAAAAAAAAAyKvIHQAAAAAAAAAAAAAAERF33XVXtFqt3Blzxvr16/19AQAAAAAAAAAAAAAAAAAAAAAAAAAwryxYsCAeeuih6OnpyZ0Cr9uVV15Zyu4TTzwRq1atisnJyVL2AQCYezqdTmnb7Xa7tO1uaTabpfzchn379sX+/fu7vgsAwH+xd99hVpXn/rifKZRhKIqAgBKliLEGxRJLFHtoQVEHNbEBGjWJ52iiSUwzx68pGnOOiSbGxihFUYEEiV2sxCj2LqBiRwkWQGCAYf/+8KeJCjjlXXvvmbnv63quc5S9Pu8zi732u7Ou8VkAAAAAAAAAAAAAAAAAAAAAAAAAX2zMmDEFW/tb3/pWtG7dumDrAwAAAAAAAAAAAAAAAIVRXugGAAAAAAAAAAAAAGDPPfeMn/3sZ4Vuo8n5y1/+Etttt12sWrWq0K0AjfTYY4/Ftddemzx39erVyTMBAAAAAAAAAAAAAAAAAAAAAAAAIEvbbbddnH766fHb3/620K1Ag2y//fbJM1esWBFHH320WbRAvZl9C9C8TZw4Mc4777woLy9Pnj1s2LCoqKiI5cuXJ89OZeTIkVFWVpY8d9y4cUly7MMAX8znJLAuvksBAAAAAAAAAAAAAAAAAAAAAABAy9S1a9cYNmxYwdbfaKONYsSIEXH99dcXrAcAgEIyGxYAAAAAAAAAAACAlqq80A0AAAAAAAAAAAAA0LK1bt06Lr/88igtLS1YDytXrozZs2fHI488EvPmzYuXXnopFixYEB9++GEsW7YsampqoqysLNq3bx8dOnSIDh06xMYbbxzbbrttbLvttrH99ttHnz598t73lltuGaeddlqcd955eV8bSGvSpEkxadKkQrcBAAAAAAAAAAAAAAAAAAAAAAAAAEXhZz/7WVx99dXx1ltvFboVqJcuXbpEt27dkudOmDAh5syZkzwXaP7MvgVo3t5555249dZbY+jQocmz27VrF0OGDIkpU6Ykz06lqqoqeebq1auT7Z32YYAvduSRRxa6BaBI+S4FAAAAAAAAAAAAAAAAAAAAAAAALdMxxxwTrVq1KmgPY8eOjeuvv76gPQAAFIrZsAAAAAAAAAAAAAC0VOWFbgAAAAAAAAAAAACAlu0nP/lJbLnllnlfd9GiRXHdddfF5MmT45///GfU1NTUO2Py5Mmf/P99+/aNkSNHxmGHHRa77LJLylbX60c/+lFccsklsXjx4rytCQAAAAAAAAAAAAAAAAAAAAAAAABA8fjggw9i+fLljcooLS2NysrKqKysTNRV41RWVsaPf/zjOPXUUwvdCtTLl770pUxyL7nkkkxyAQBo+qqrq2Po0KGZZFdVVcWUKVMyyW6srl27xt57750896abboqFCxcmzwUAAAAAAAAAAAAAAAAAAAAAAAAAAOCLjRkzptAtxP777x9f+tKX4tVXXy10KwAAAAAAAAAAAAAAAECelBa6AQAAAAAAAAAAAABars033zx+9KMf5XXNZ599No466qjo3r17nHLKKXHPPfdETU1No3NffPHFOP/882PXXXeNXXfdNW6//fYE3X6xDTfcME4//fS8rAUAAAAAAAAAAAAAAAAAAAAAAAAAQPE58cQTo0ePHo2qjTfeONq3bx/l5eXRuXPn2GqrreKII46I8847L+64444k8zvr64QTTohu3brlfV1ojJ49eybPfPfdd+ORRx5JngsAQPMwffr0eO+99zLJHjZsWFRUVGSS3VgjR46MsrKy5LnV1dXJMwEAAAAAAAAAAAAAAAAAAAAAAAAAAPhiX/3qV2OrrbYqdBtRWloaxx13XKHbAAAAAAAAAAAAAAAAAPKotNANAAAAAAAAAAAAANBynXvuudG6deu8rPXOO+/EN7/5zdh2223jmmuuidWrV2e21kMPPRQHHnhg7LPPPvHqq69mts7H/vu//zsqKyszXwcAAAAAAAAAAAAAAAAAAAAAAAAAgOattrY23nvvvXj++edj8uTJ8cMf/jAOOOCA2HjjjWP06NExc+bMvPXStm3bGDNmTN7WgxR69uyZPPOhhx5KngkAQPOxcuXKmDx5cibZ7dq1iyFDhmSS3VhVVVXJMxctWhQzZsxIngsAAAAAAAAAAAAAAAAAAAAAAAAAAMAXGzt2bKFb+MTo0aOjpKSk0G0AAAAAAAAAAAAAAAAAeVJa6AYAAAAAAAAAAAAAaJkGDBgQRx55ZF7Wmjx5cmy99dYxadKkyOVyeVkzIuLuu++OHXbYIW6++eZM1+nUqVMcffTRma4BAAAAAAAAAAAAAAAAAAAAAAAAAEDL9cEHH8S4ceNiv/32i1122SXuvffevKw7duzYvKwDqXTs2DF55osvvpg8EwCA5qW6ujqz7KqqqsyyG6pLly6x9957J8+95pprYtWqVclzAQAAAAAAAAAAAAAAAAAAAAAAAAAAWL/KysoYNWpUodv4xGabbRb77bdfodsAAAAAAAAAAAAAAAAA8qS00A0AAAAAAAAAAAAA0DL97Gc/i5KSkkzXyOVyceaZZ8YRRxwRixYtynStdXn33XdjyJAhccUVV2S6zqmnnpppPgAAAAAAAAAAAAAAAAAAAAAAAAAARETMnj079t577xgxYkS88847ma7Vp0+f2GWXXTJdA1Jq27Zt8sz33nsveSYAAM3Lgw8+GC+88EIm2UOHDo2KiopMshtq5MiRUVZWljy3uro6eSYAAAAAAAAAAAAAAAAAAAAAAAAAAABfrKqqKtq3b1/oNj5l7NixhW4BAAAAAAAAAAAAAAAAyJPSQjcAAAAAAAAAAAAAQMvTt2/fOPjggzNdY/Xq1XH44YfH+eefn+k6dXXiiSfGjBkzkucuW7YsrrnmmjjjjDOipKQkeT4AAAAAAAAAAAAAAAAAAAAAAAAAAKzN9OnTY8CAAfHkk09muk7Wc0whpYqKiuSZixcvTp4JAEDzU11dnUluZWVlDBkyJJPshho1alTyzGeeeSYeeeSR5LkAAAAAAAAAAAAAAAAAAAAAAAAAAAB8sTFjxhS6hc85+OCDo3PnzoVuAwAAAAAAAAAAAAAAAMiD0kI3AAAAAAAAAAAAAEDL8/3vfz9KS7P7VdZcLhejR4+OKVOmZLZGfa1ZsyaqqqriqaeeanTW6tWr4+9//3scddRR0bVr1zjqqKPi73//e+RyuQSdAgAAAAAAAAAAAAAAAAAAAAAAAABA3bz11lux7777xty5czNb4+tf/3pm2ZBa69atk2fW1tYmzwQAoPkZP358rFmzJpPsqqqqTHIbokuXLrH33nsnz62urk6eCQAAAAAAAAAAAAAAAAAAAAAAAAAAwBfr379/7LHHHoVu43PatGkT3/rWtwrdBgAAAAAAAAAAAAAAAJAH5YVuAAAAAAAAAAAAAICWpV27dnH00UdnusZZZ50V48ePz3SNhli+fHl8+9vfjlmzZkVJSUm9js3lcnH//ffHxIkT44YbbohFixZl1GV+lJeXR+/evWOTTTaJrl27xkYbbRTt2rWL1q1bR+vWrT953apVq6KmpiZWrFgRK1asiH/961/x1ltvxVtvvRULFiyI1atXF/CnaLo6d+4c2267bfTo0SM6duwYHTp0iMrKyigpKYmamppYsmRJLF26NBYvXhzz58+P559/PlasWFHotj9RXl4eW265ZfTt2zc6duz4SbVu3TpyuVwsX748li1bFkuWLIlXX301XnrppXj99dcjl8sVunUS2nDDDWPrrbeOnj17fvI+bt++fZSWlsbq1atj+fLl8dZbb8X8+fNj/vz5sWDBgkK3XFCdO3eO/v37R8+ePWPjjTeOysrKaNOmTZSVlUVtbW0sXbo0Pvzww1i6dGksXLgw5syZE6+99lqh2wYAAAAAAAAAAAAAAAAAAAAAAACagEWLFsWhhx4aDz/88KfmSqay/fbbR2VlZXz44YfJs2mcTTfdNDbffPPo2rVrdO3a9ZNZdx+/D1auXBkrV66MpUuXxr/+9a9YuHBhvPLKK/Haa6+ZE8l6denSJTbbbLPo1atXdOrUKSoqKqKioiLatWv3ySzFZcuWfVLvvvtuzJ8/P1555ZVYunRpodsvmNLS0th0002je/fu0b179+jatWu0a9cu2rRpE23bto3S0tKI+GjecU1Nzaeuz3/961/x2muvxWuvvRZr1qwp8E+SP85Zy2PvKry6zBZetmxZfPDBB+YL///Mdaeu3njjjZg5c2bsv//+ybOHDh0aFRUVsXz58uTZ9TVy5MgoKytLmllbWxsTJkxImtkS+W5FU2BfhabFNQsfcT+j8NzPAAAAAAAAAAAAAAAAAAAAAAAAyNbYsWML3cI6jR07Nv7whz8Uug1osczkK6zOnTvHtttuGz169PhkHl9lZWWUlJRETU1NLFmyJJYuXRqLFy+O+fPnx/PPPx8rVqwodNufKC8vjy233DL69u0bHTt2/KRat24duVzuk3mCS5YsiVdffTVeeumleP311713/oNrEKgPzx4DAAAAAAAAAAAAmrryQjcAAAAAAAAAAAAAQMty2GGHRfv27TPLv+222+I3v/lNZvmN9cADD8SVV14ZY8aMqdPrn3jiiZg4cWJce+218dprr2XcXTbKy8tj9913j9133z122WWXGDBgQHzpS1+KsrKyRuWuXr065s6dG08//XQ89dRT8Y9//CPuv//+qKmpSdR587H55pvHsGHDYujQobHDDjvExhtvXK/j16xZE/Pnz48nnngibr755vj73/8eb775Zkbdfl779u3joIMOiuHDh8fAgQNjyy23jFatWtUrY/ny5fHQQw/F/fffH7fffnvce++9Bos3MVtttVUMGTIkDjrooNhuu+2ie/fu9Tp+yZIl8dBDD8UDDzwQM2fOjHvuuSfWrFmTUbeFt/3228eBBx4Ye++9d+yyyy7RrVu3emcsX7485s2bFw888EDcfvvtMXPmzHj33Xcz6BYAAAAAAAAAAAAAAAAAAAAAAABo6p566qm4+OKL47TTTkueXVZWFjvvvHPcfffdybMLpVu3btGpU6dPqk2bNut9/ezZs2PhwoV56m7tttlmm9h7771j5513joEDB0b//v2/sO91WblyZcydOzceffTRmD17dtxzzz3x5JNPJu6YpqC0tDS233772GWXXWLXXXeNnXfeOfr16xcVFRUNznz33XfjiSeeiH/+85/xwAMPxAMPPBD/+te/EnZdHEpLS2OHHXaIvfbaK3bdddfYeuutG3VdfmzVqlXx8ssvx2OPPRYPP/xw3H///TF79uyora1N1HnhOGctj72rODR2tnBEy5ovbK47jVVdXR37779/8tzKysoYMmRITJkyJXl2fY0aNSp55m233RYLFixIntuc+W5FU2BfhabFNQsfcT+jOLifAQAAAAAAAAAAAAAAAAAAAAAAkD9lZWVxzDHHFLqNddpuu+1ip512iocffrjQrUCzZyZf4W2++eYxbNiwGDp0aOywww6x8cYb1+v4NWvWxPz58+OJJ56Im2++Of7+97/Hm2++mVG3n9e+ffs46KCDYvjw4TFw4MDYcssto1WrVvXKWL58eTz00ENx//33x+233x733ntv5HK5jDouLq5BoK48ewwAAAAAAAAAAABorkpydfwN8pKSkqx7AQAAAAAAAAAAAKAFuOuuu2LQoEGZZC9atCi23nrreOeddzLJT6V79+7x2muvRXl5+Vr//OWXX45JkybFxIkT47nnnstzd2lUVlbGIYccElVVVbHPPvtE+/bt87JuTU1NzJo1K6ZPnx6TJk2KhQsX5mXdL9K9e/f4xje+kSTriiuuiNra2i98XZs2beJb3/pWfO9734uvfOUrSdb+T48++mj8+c9/jvHjx0dNTU3y/IiIIUOGxPe+973Yd999o3Xr1kmz33zzzbjuuuvij3/8Y7z00ktJsxsi5XvkY2+++WbMmDEjSVYh3sMREd26dYtvf/vbMXr06Nh8882TrP+xhQsXxrRp0+KSSy6Jxx57LGl2oXzpS1+KE088MY466qjo3bt38vxcLhcPPPBA/OUvf4nrrrsuVqxYUafjevfuHb169Wr0+u+//74HAAAAAAAAAAAAAADQKHUcy75WZrUDAAAAAAAAACmcf/758YMf/CB57qhRo+K6665LnltfG2+8cbz++uvrnLnZGN/5znfiT3/6U4OPL9RcvYiI8vLyGDJkSOy1114xcODA2GGHHaJTp071WnPo0KFx00031bfVRikvL4/99tsvRo0aFYMHD47u3btnut7ChQvj5ptvjsmTJ8ftt98eq1atynS99TnxxBMbfOzhhx8e+++/f8JuIqZMmRK33XZb0syP1dbWxhVXXJFJ9rq0adMmDjzwwBg5cmQMHz48Ntpoo0zXW7NmTdx///1x/fXXx5QpU+Ktt97KdL0stWvXLoYMGRKHHXZYDBkyJDp06JCXdRcvXhx33nlnTJ48OW688cZYtmxZXtZNwTkr/tm3KbXkvWtdmuNs4YjmN1/YXPdP22uvveKee+5Jmnn33XfHPvvskzSzWFVUVMTbb7+dyZ533XXXxahRo5Ln1keXLl1iwYIFUVZWljS3qqoqrr/++qSZEc1vH27p3606deqU/Bp4//33835PZ/To0cnv3dT3XkmW7Kuf1hT21cbch1mbxnxObr/99vHVr341aT9NwdSpU+Nf//pXQdZuidfsfvvtF3379m3wmkJfEgABGRRJREFU8QceeGAceuihCTuKuOOOOzL5LvSxu+66K+bOnVvv45rbd6l1cT/j89zPAAAAAAAAAADIjlntAAAAAAAAAAAAQDH6xje+EX/7298K3cZ6/eUvf4mTTjqp0G2sk9mp61afmWRmBuafmXyfV4iZfG3atIlvfetb8b3vfS++8pWvJFn7Pz366KPx5z//OcaPHx81NTXJ8yMihgwZEt/73vdi3333jdatWyfNfvPNN+O6666LP/7xj/HSSy8lzS60lnYN+pyvu2KYDduzZ88YNmxY0h4iIpYvXx7jx49PnltfAwYMiF122SVpZtb7umePAQAAAAAAAAAAAE1dnWa15+ooIpRSSimllFJKKaWUUkoppZRSSimllFJKKaWUalRtvPHGuTVr1tT1V1jr7eSTTy74z1jXuuGGGz7V+9tvv537wx/+kNt1110L3ltjaptttsldccUVuQ8//DCzv+e6WrVqVe7vf/977utf/3rBz8tee+2V7Odq167detdq06ZN7qyzzsq98847ydZcn7fffjv305/+NFdRUZHkXJWWluaOOeaY3NNPP52X/levXp2bNGlSrn///s3mPfKxu+66qyj7+6L3cETk+vXrl7vqqqtyNTU1ydZdn5kzZ+b222+/gn9WNLS233773A033JCrra3Ny/nK5XK5d999N3f++efnNthggy/s7/zzz0+yZsr3tFJKKaWUUkoppZRSSimllFJKKaWUUkoppZRqmdUYhe5dKaWUUkoppZRSSimllFJKKaWUUs2jUs3m+qyqqqqC/2wf14033pjJz3jRRRc1qq98z9WLiNxWW22Vu/DCC3MLFy5s9JpDhgzJ299hnz59cr/97W/zNttybRYtWpS74IILcltssUVB3sctyYsvvpi389q3b9/chRdemFu8eHHBft7a2trc1KlTc7vttltB3lsNrf79++f++Mc/FvTcfWzp0qW5v/zlL7ltttmm4OfFOatbFfvs2xRl78rP338xzhbO5Zr2fGFz3bN/336s2D63sq4rr7wy+TnM5T7a01LNpG9onXjiicl/rvfeey/Xpk0b7+f1lO9W/z4PqT333HN5/zmWLFmS/Oeo672SLMu+uvZqCp9DxdTf6aefnryfpmDHHXd0zebxmr3mmmsK/SPn3f77799sP8MaU+5n5Ofv3v0MpZRSSimllFJKKaWUUkoppZRSSqlPV2MUunellFJKKaWUUkoppZRSSimllFJKKaWUUko135o+fXqiKU8fmTVrVtK8XC6X++CDDwo+n3d9ZXbqutVndqqZgfkrM/nWXfmcydemTZvcWWedlbe/h7fffjv305/+NNnnaWlpae6YY47JPf3003npf/Xq1blJkybl+vfvX/D3iWuwYeVzvjCfRR+r72zYysrK3NKlS5P3kcvlcr179y74dThjxoykP1NtbW2uV69emfTq2WNKKaWUUkoppZRSSimllFJKKaWUUkoppZRqLlUXpQEAAAAAAAAAAAAAeTJs2LAoKSnJJPvZZ5+NSy+9NJPsLPz5z3+OJUuWxFVXXRUHHnhg9OjRI0499dR48MEHC91ag2y33XYxY8aMePrpp2P06NHRrl27QrcU5eXlMWTIkLj55ptj9uzZMXTo0EK3lLnBgwfHs88+G+eee2507do1L2t269YtzjnnnHjmmWfigAMOaFTWjjvuGA899FBcddVVsc022yTqcP3KysriyCOPjKeeeirOOeecaNOmTV7WZe3at28fv/3tb+OZZ56JY445Jlq3bp2XdffZZ5+44447Ytq0abHZZpvlZc0UunfvHhMmTIjHH388Dj300Cgtzd9/JrLhhhvGD37wg3jxxRfje9/7XpSVleVtbQAAAAAAAAAAAAAAAAAAAAAAAKB43XrrrZnkfulLX8okNwuVlZXxu9/9Lp588sk49dRTo0uXLoVuqU622267mDx5csydOzfOPPPMvM22XJvOnTvH6aefHi+88EJMmTIlBgwYULBemru5c+dmvsaAAQPixhtvjDlz5sSpp54aHTp0yHzNdSktLY1DDjkk/vGPf8Q//vGP2HPPPQvWS1307ds3rrvuunj++efju9/9bkHP3ccqKyvjxBNPjKeffjqmT58e22+/faFb+hTnrGWxdxWPQs0Wjmia84XNdSdr1dXVmeRWVlbGkCFDMsmuq1GjRiXPnDx5ctTU1CTPbQ58t6IpsK9C0+KabZnycQ+yKXE/o3i4nwEAAAAAAAAAAAAAAAAAAAAAAFB43bt3Tz739rjjjotFixYlzezYsWMcdthhSTOhGOR7ZqCZfMVj8ODB8eyzz8a5556bt7+Hbt26xTnnnBPPPPNMHHDAAY3K2nHHHeOhhx6Kq666KrbZZptEHa5fWVlZHHnkkfHUU0/FOeecE23atMnLuim5Bluepjwb9sMPP4wbbrghk+yRI0dmkltXHTt2bPTn4GfNnDkzXnvttaSZnj0GAAAAAAAAAAAAtESlhW4AAAAAAAAAAAAAgJZjxIgRmWX/8pe/jNra2szyU7vzzjuja9eucdxxx8Xtt98ea9asKXRLDdK5c+e48sor4/HHH4+hQ4cWup112mmnnWLGjBkxY8aM2HTTTQvdTnJt2rSJcePGxU033RR9+vQpSA+9e/eO2267LS6//PJo1apVvY5t1apV/P73v4+HHnooBg4cmFGH69e6dev46U9/Go899lj079+/ID20dPvvv3/MmTMnzjzzzGjdunVBejj44IPjueeei+OPP74g69fHUUcdFS+88EJ885vfjJKSkoL10blz5/jDH/4Qs2fPjt69exesDwAAAAAAAAAAAAAAAAAAAAAAAKA4zJ49O5PcjTfeOJPc1L761a/Gc889F9///vejvLy80O3UyYYbbhiXXnppPPHEE1FVVRWlpaWFbukTJSUlMXLkyHjsscdi3LhxsdFGGxW6pWZn7ty5mWV369YtLr/88njkkUdi2LBhRfXeiojYbbfd4r777ovx48cX3WdMRUVF/P73v4/nnnsuDj/88ILOnlyf4cOHx+OPPx5XXHFFdO7cuaC9OGcti72ruBTDbOGIpjFf2Fx38uXee++Nl19+OZPsqqqqTHLrokuXLrH33nsnzx03blzyzKbOdyuaAvsqNC2u2ZarpqYmXn311UK3URTczygu7mcAAAAAAAAAAAAAAAAAAAAAAAAUh2OPPTbKysqS5c2aNSvmzp0b119/fbLMj40dOzZ5JhRSPmcGmslXPNq0aRPjxo2Lm266Kfr06VOQHnr37h233XZbXH755dGqVat6HduqVav4/e9/Hw899FAMHDgwow7Xr3Xr1vHTn/40Hnvssejfv39Beqgv12DL1Bxmw2b1LIFDDz00k9y6GjFiRPKZqCnPlWePAQAAAAAAAAAAAC1Zcf3mJAAAAAAAAAAAAADNVqtWrWK//fbLJPu1116LKVOmZJKdpZqamkK30CiHH354vPDCC3H88ccX3VDXdRk6dGg8++yz8a1vfavQrSTTq1evmDVrVhx33HGFbiUiIsaMGRO33XZbdOrUqU6v79atW9x9991x2mmnJX2YR0NttdVWMXv27Bg+fHihW2kxSkpK4uc//3nceuut0aNHj0K3ExUVFXHllVdGdXV1tGnTptDtfE6bNm3iL3/5S0ycODE6duxY6HY+scMOO8Sjjz4a3/jGNwrdCgAAAAAAAAAAAAAAAAAAAAAAAFBA8+bNyyS3a9eumeSmNGLEiJg5c2b06tWr0K3U2dFHHx0vvPBCnHDCCVFSUlLodtbruOOOizlz5sSYMWMK3UqzMmfOnExyjz/++Jg3b16MGTOm6GfXfutb34oXXnghDjnkkEK3EhERu+66azzxxBNx2mmnRatWrQrdzhcqKSmJ0aNHF/QcOmcti72reBTbbOGI4p4vbK47+TZ+/PhMcocOHRoVFRWZZH+RkSNHJp9nP2fOnHjwwQeTZjZ1vlvRFNhXoWlxzbZsL774YuRyuUK3UXDuZxQP9zMAAAAAAAAAAAAAAAAAAAAAAACKS+q5Vx/P5p0wYULS3IiIvfbaK/r165c8FwolXzMDzeQrHr169YpZs2bFcccdV+hWIuKjPeC2226LTp061en13bp1i7vvvjtOO+205DPLG2KrrbaK2bNnx/Dhwwvdynq5Bluu5jAb9p577on58+cnz/3qV78aPXv2TJ5bV4cffnjSvMWLF8e0adOSZHn2GAAAAAAAAAAAANDSFfdvUAIAAAAAAAAAAADQbAwcODDatWuXSfZFF10UtbW1mWSzdpdeemlcd9110aVLl0K3Um8dOnSI8ePHx3nnnVf0g6y/yJe//OWYPXt2DBw4sNCtfMqgQYPigQceiO7du6/3ddtvv308/PDDsfvuu+eps7rp2LFjTJs2LY444ohCt9LstW7dOv72t7/FL3/5y6IbEn3sscfGTTfdlNne1RB9+vSJf/7zn3HiiScWupW12mCDDeJvf/tbfOc73yl0KwAAAAAAAAAAAAAAAAAAAAAAAECBvPvuu5nkVlRUZJKbyjHHHBNTp04t+j4/1rNnz7jrrrvi6quvjq5duxa6nTrr3LlzXH755XH//ffHl770pUK30yzMnTs3aV6HDh3immuuiSuvvDI6dOiQNDtLnTp1iqlTp8YFF1wQZWVlBetj7Nixcd9998UWW2xRsB4aqkuXLjF16tT405/+FOXl5Xlb1zlrOexdxaWYZwtHFNd84bZt25rrTkFUV1dnkltZWRlDhgzJJPuLjBo1KnnmuHHjkmc2Zb5bUezsq9C0uGaJSH//salxP6O4uJ8BAAAAAAAAAAAAAAAAAAAAAABQXPbcc8+ks1BXrVoV119/fUREzJo1K1555ZVk2R8bM2ZM8kwolKxnBprJV1y+/OUvx+zZs2PgwIGFbuVTBg0aFA888EB07959va/bfvvt4+GHH47dd989T53VTceOHWPatGlxxBFHFLqVz3EN0lxmw1511VXJM0tKSuLggw9OnlsXHTp0iAMPPDBp5uTJk2P58uWNyvDsMQAAAAAAAAAAAICPlBa6AQAAAAAAAAAAAABahq997WuZ5OZyuZg0aVIm2axdt27d4oQTTih0G412xhlnxLXXXhulpU3z16q32GKLmDlzZmy88caFbmWtttpqq5gxY0ZUVFSs9c+32WabuOuuu6JXr1557qxuysrKYsKECTFq1KhCt9JstW3bNmbMmBHDhw8vdCvrtO+++8btt98elZWVhW4l+vXrF/fff38MGDCg0K18oYsuuihOOeWUQrcBAAAAAAAAAAAAAAAAAAAAAAAAFEAul4vly5cnz23Tpk3yzFT233//uOKKK5rMjMuddtopHn744Rg0aFChW2mwPfbYI2bPnh277bZboVtp8ubOnZssq1+/fvHYY4/FEUcckSwz304//fS45ZZb1jlTNUvnnXdeXHbZZdGqVau8r53SySefHLfeemt06tQp87Wcs5bD3lVcmsJs4YjimC/crVu3uOeee8x1pyBefvnluP/++zPJrqqqyiR3fbp06RJ777130sw1a9bE+PHjk2Y2Zb5bUezsq9C0uGb52Jw5cwrdQsG4n1Fc3M8AAAAAAAAAAAAAAAAAAAAAAAAoPmPHjk2ad9NNN8W77777yT9fc801SfMjIo499tgoKytLnguFkOXMQDP5issWW2wRM2fOjI033rjQrazVVlttFTNmzFjn82K22WabuOuuu6JXr1557qxuysrKYsKECTFq1KhCt/IJ1yARzWc2bHV1deRyueS5hx56aPLMuhg+fHjyZ/KNGzeuUcd79hgAAAAAAAAAAADAv5UWugEAAAAAAAAAAAAAWoavfe1rmeQ++OCD8frrr2eSzedtttlm8c9//rPQbSRTVVUVl112WaHbqLcePXrEzJkzo0ePHoVuZb0GDhwYkyZNipKSkk/9+759+8Ydd9wRnTt3LlBndVNWVhZXXXVV7LLLLoVupdlp1apV/P3vf48DDjig0K18od133z2uvfbaz72P86lv375x9913F/01/58uvvjiOPbYYwvdBgAAAAAAAAAAAAAAAAAAAAAAAFAAtbW1yTNbtWqVPDOFrbfeOqZMmRLl5eWFbqVODj/88Lj33nub1Hy7denWrVvcdddd8a1vfavQrTRZq1evjvnz5yfJGjBgQMyaNSv69u2bJK+Q9t9//7jllluiffv2eVvz3HPPjTPOOCNv62Vt3333jbvvvjs23HDDzNZwzloOe1dxaUqzhSMKO1/445nuzWnGdVOd696SVVdXZ5I7dOjQqKioyCR7XUaOHBllZWVJM++888544403kmY2Vb5bUezsq9C0uGb5T3PmzCl0CwXhfkZxcT8DAAAAAAAAAAAAAAAAAAAAAACg+LRv3z4OP/zwpJnjx4//1D9PmDAhaX5ERI8ePWLw4MHJc6EQspoZaCZfcenRo0fMnDmz6P8+Bg4cGJMmTfrcLL6+ffvGHXfcEZ07dy5QZ3VTVlYWV111VVHMZHUN8rHmMht2/vz5cc899yTP3XvvvWOjjTZKnvtFqqqqkubNmTMnHnjggQYf79ljAAAAAAAAAAAAAJ9WWugGAAAAAAAAAAAAAGgZdtxxx0xyp0yZkkkun9erV6+4++67o3fv3oVuJanRo0fHz3/+80K3UWetWrWKyZMnx6abblroVurk4IMPjh/+8Ief/HOnTp3i9ttvj+7duxewq7pr06ZNTJs2rcn021RcdNFFse+++xa6jTobNmxY/O53vyvI2ptvvnncddddsckmmxRk/ca45JJLYsCAAYVuAwAAAAAAAAAAAAAAAAAAAAAAACATrVq1imuvvTY6duxY6FbqbPLkyVFRUVHoNpJp06ZNjB8/vknNFi0mL730UtTW1jY6Z4899oh77rknunXrlqCr4rDXXnvFbbfdFm3bts18re9+97tx1llnZb5Ovg0YMCBuv/32aN++ffJs56zlOOOMM+xdRaapzRaOKMx84eY60z2i6c11b+muu+66WL58efLcysrKGDJkSPLc9Rk1alTyzOrq6uSZTZHvVhQ7+yo0La5ZPmvu3LmFbiHv3M8oPu5nAAAAAAAAAAAAAAAAAAAAAAAAFJ8jjjgi2rVrlyxv8eLFMWPGjE/9u2eeeSaefPLJZGt8bOzYsckzoRCymBloJl9xadWqVUyePDk23XTTQrdSJwcffHD88Ic//OSfO3XqFLfffnt07969gF3VXZs2bWLatGkF7dc1yH9qTrNhx40blzyzrKwsvvGNbyTPXZ/27dvHQQcdlDSzMefGs8cAAAAAAAAAAAAAPq+00A0AAAAAAAAAAAAA0PxtsMEGsckmm2SSPXPmzExy+bQOHTrEzTffHJtvvnmhW8nEL37xi9hrr70K3Uad/OpXv4qvfe1rhW6jXs4+++zo379/RERcfvnl0bt37wJ3VD89e/aMSy65pNBtNBsnnnhinHjiiYVuo95OP/30OPDAA/O6Ztu2bWP69OnRq1evvK6bStu2beOGG26ITp06FboVAAAAAAAAAAAAAAAAAAAAAAAAgOR++ctfxnbbbVfoNurshBNOiJKSkkK3kYlf/vKX8b3vfa/QbTQ5c+fObXTGl7/85ZgxY0Z07NgxQUfFZbfddourrroq0zUGDhwYF1xwQaZrFNLAgQPjmmuuSfrZ45y1HCeccEKcd955zfZcNMW9q6nOFo7I73zh5j7TPaJpzXVv6ZYsWRLTpk3LJLuqqiqT3LXp0qVL7L333kkzszw3TYnvVhQ7+yo0La5Z1mbOnDmFbiGv3M8oPu5nAAAAAAAAAAAAAAAAAAAAAAAAFKexY8cmzbvhhhuipqbmc/9+woQJSdeJiBg6dGhsvPHGyXMh31LPDDSTr/j86le/iq997WuFbqNezj777Ojfv39ERFx++eXRu3fvAndUPz179oxLLrmkIGu7Bvms5jQb9oYbboilS5cmzz3ssMOSZ67PsGHDom3btsny1qxZE+PHj2/QsZ49BgAAAAAAAAAAALB2pYVuAAAAAAAAAAAAAIDmb7vttsskd+nSpfH4449nks2nXXvttbHNNtsUuo3MlJaWxsSJE6N9+/aFbuULnXLKKYVuod7atGkTV1xxRZx88sl5H5ScyogRI2LkyJGFbqNZOP/88wvdQoNdfvnl0aFDh7ytd+GFF2a2h+ZL37594/jjjy90GwAAAAAAAAAAAAAAAAAAAAAAAEAelZWVJc+sqalJntkYO+64Y5x55pmFbqPOhg8fHn/+858L3UamLrzwwjj88MML3UaTMnfu3EYd361bt7j55ptjgw02SNNQEaqqqoqf/vSnmWS3atUqrr322mjdunUm+cVi2LBh8Ytf/CJJlnPWcrSEfSui6e1dTXm2cET+5gs395nuEU1rrjsR1dXVmeQOHTo0KioqMsn+rJEjRyb/35nXXXddLF++PGlmU+O7FU2BfRWaFtcsn/Xhhx/GW2+9Veg28sb9jOLkfgYAAAAAAAAAAAAAAAAAAAAAAEDx2XrrrWPXXXdNmjl+/Pi1/vtrrrkmcrlc0rXKy8vj2GOPTZoJ+ZZ6ZqCZfMXplFNOKXQL9damTZu44oor4uSTT47DDjus0O00yIgRI2LkyJF5XdM1yGc1t9mwy5Yti+uvvz557v7775/X2Z+p37933HFHvPHGG/U+zrPHAAAAAAAAAAAAANattNANAAAAAAAAAAAAAND8bbPNNpnkPvDAA7FmzZpMsvm3//qv/4ohQ4YUuo3MbbrppvHjH/+40G00W3vuuWdcfPHFhW6jUS688MJo3bp1odto8srLywvdQoP16tUrzj777LysNWrUqDjxxBPzslbWmvLfOQAAAAAAAAAAAAAAAAAAAAAAAFA/JSUlUVFRkTz3ww8/TJ7ZUCUlJfG73/0uysrKCt1Kney2224xefLkJtNvQ5WUlMT48eNj7733LnQrTcacOXMafGxZWVn87W9/i8033zxdQ0Xqf/7nf2LQoEHJc0899dTo169f8txi9NOf/jR23XXXRuc4Zy1DS9m3Ipre3tXU58zmY75wS5npHmGue1Nyxx13xBtvvJE8t7KyMm/v91GjRiXPrK6uTp7Z1PhuRbGzr0LT4pplbebOnVvoFvLG/Yzi5X4GAAAAAAAAAAAAAAAAAAAAAABA8RkzZkzSvDfeeCPuueeetf7Z66+/Hvfee2/S9SLS/wyQbylnBprJR2p77rlnXHzxxYVuo1EuvPDCaN26dV7Wcg2yNs1xNuy4ceOSZ7Zu3TqGDh2aPHdt2rVrF4MHD06a2ZBz4tljAAAAAAAAAAAAAOtXWugGAAAAAAAAAAAAAGj+evfunUnuE088kUku/9avX7/47W9/W+g28ub000+PXr16FbqNZqukpKTQLTTKpptuGqNHjy50GxTYKaecEj169Mh0jU022SQuu+yyTNcAAAAAAAAAAAAAAAAAAAAAAAAAyMKGG26YSe6HH36YSW5DHHDAAbHPPvsUuo066dy5c0ydOjUqKioK3UpetGnTJqZMmRLdunUrdCtNwty5cxt87FlnnRVf/epXE3ZTvEpKSuKKK65Ieh116NAhfvaznyXLK3ZlZWUxbty4KCsra3CGc9YytLR9K8LelW9ZzhduaTPdI8x1bypyuVxMmDAhk+yqqqpMcv9Tly5dYu+9906a+dJLL8X999+fNLOp8d2KYmdfhabFNcu6NOb+Y1PifgZZy8fzkgAAAAAAAAAAAAAAAAAAAAAAAPKlvLw8jj766KSZEydOjFwut94/T61///6x5557Js+FfEk1M9BMPrJSUlJS6BYaZdNNN43Ro0dnvo5rkHVpjrNh77vvvnjppZeS5x522GHJM9dm2LBhSa/VDz74IKZNm1bv4zx7DAAAAAAAAAAAAGD9SgvdAAAAAAAAAAAAAADN32abbZZJ7nPPPZdJLv924YUXRps2bQrdRt60bds2zjzzzEK3QRE766yzory8vNBtUEBt27aNn/zkJ5muce6550aHDh0yXQMAAAAAAAAAAAAAAAAAAAAAAAAgC3379s0k98MPP8wktyHOPffcQrdQZxdddFF079690G3k1UYbbRR/+ctfCt1GkzB37twGHbfjjjvGz3/+88TdFLc+ffrEr3/962R5Rx99dHTq1ClZXlOw1VZbxSmnnNLg452zlqEl7lsR9q58ynK+cEub6R5hrntTUl1dnUnu0KFDo6KiIpPsj40cOTLKysqSZmZ1PpoS360odvZVaFpcs6xLQ+8/NjXuZ5C1fDwvCQAAAAAAAAAAAAAAAAAAAAAAIF++8Y1vRNeuXZNmTpgwYb1/fv3118fKlSuTrhkRMXbs2OSZkC+pZgaayQfrdtZZZ0V5eXmma7gGWZfmOhs2i2cNDB48ONq2bZs897MOP/zwpHnXXntt1NTU1OsYzx4DAAAAAAAAAAAA+GKlhW4AAAAAAAAAAAAAgObvS1/6Uia5zz//fCa5fGTQoEExZMiQQreRd8cee2xUVlYWug2KVK9evVrkdcGnHXfccdG+fftMsgcMGBBHH310JtkAAAAAAAAAAAAAAAAAAAAAAAAAWdtxxx0zyX3zzTczyW2IrbfeutAt1MkhhxwSRx55ZKHbKIiDDz44jjjiiEK3UdRqamri1VdfrfdxJSUlMW7cuCgvL8+gq+L23e9+N/r3758k6+STT06S09T84he/iHbt2jXoWOes+WvJ+1aEvSufspgv3FJnukeY695UPP/88zF79uzkuZWVlTF48ODkuf+pqqoqaV4ul4urr746aWZT5LsVxcy+al+laXHNumbX54UXXih0C5lzP8P9jHzJ8nlJAAAAAAAAAAAAAAAAAAAAAAAA+TR27NikeU899VQ89dRT633N+++/HzfffHPSdSMiDj/88OjQoUPyXMiHFDMDzeQzk4/169WrV6azW12DrsH1aa6zYa+66qrI5XJJM9u1axdf//rXk2Z+VkVFRfLPg3HjxtXr9Z49lubZYwAAAAAAAAAAAEDz1/J+2xIAAAAAAAAAAACAvOvRo0cmuS+99FImuXzkZz/7WeZrPP300/HUU0/F888/H2+88UYsXbo0li1bFrW1tdGmTZvo3LlzdO7cOb785S/HPvvsE7179868pw4dOsTRRx8dl1xySeZr0TQdf/zxMX369EK3QQFVVlbGqFGj4oorrkiefcEFF0RpaWnyXAAAAAAAAAAAAAAAAAAAAAAAAIB82G+//TLJNYe0fjbaaKMWP1vz4osvjrvuuivefvvtQrdSlF566aXI5XL1Pu7oo4+O7bffPoOOPq+2tjYeffTReOCBB+LNN9+MRYsWxbvvvhsrVqyItm3bxoYbbhidO3eOnj17xm677RYDBw6M8vLyzPopKyuLX/7yl3HkkUc2KmfzzTePbbfdNlFX67Z8+fJ46aWXYv78+bF48eJYtmxZrFq1KiIiWrVqFZWVldGhQ4fo1atXbLHFFlFRUZF5TxtttFGccMIJceGFF9brOOes/uesqbFvfcTelR9ZzBfOx0z3CHPdaZzq6urYeeedk+eOGjUqpk6dmjw3IqJLly4xaNCgpJn33HNPvPLKK0kzmxrfrZr/d6umzr5qX6Vpcc26Ztdn7ty5hW4hU+5nfMT9jPzI8nlJAAAAAAAAAAAAAAAAAAAAAAAA+dKzZ8848MADk2aOHz++Tq+bMGFCjBgxIuna7dq1iyOOOCIuu+yypLmQD42dGWgm30fM5OOLHH/88TF9+vTkua7Bj7gG1625zoZ99dVX46677op99903ae6hhx4af/3rX5Nm/qchQ4ZEu3btkuW98MIL8eCDD9brGM8ea/yzxwAAAAAAAAAAAICWIbvfagQAAAAAAAAAAACA/1/nzp2TZ+ZyuVi4cGHyXP7t//7v/6Jbt26x7bbbJs195JFH4k9/+lPcdNNNsWDBgnod27dv3zjjjDNi9OjR0apVq6R9/adRo0Y1q8HYtbW18fDDD8dTTz0V77zzTtTU1ESrVq2isrIyevXqFQMGDIh+/foVus31WrRoUTzwwAMxb968WLJkSaxZsybatGkTG264YfTr1y923nnn6NixY156GTp0aGy44Ybx3nvv5WU9PlJTUxNPPPFEPPPMM7Fo0aL48MMPo6SkJCoqKqJLly7Rt2/f2HHHHaN9+/Z56Wf06NFxxRVXJM3cb7/9kg8lr4uXXnopnnvuuXjllVdiyZIlsWLFioiIT4Zs9+3bNwYMGBAbbbRR3nsDAAAAAAAAAAAAAAAAAAAAAAAAmo6OHTvGsGHDMsmeN29eJrnN1a9+9avo1q1b3tZ7++2348knn4z58+fHe++9FytWrIhcLhcVFRWxwQYbxGabbRbbbbdd9OzZM289de7cOX7729/Gcccdl7c1m5I5c+bU+5jWrVvH//zP/2TQzafdf//9ccEFF8Sdd94ZS5YsqfNxlZWVsd9++8UPf/jD2H333TPpbdSoUXHuuefG008/3eCMAw88MGFHn/bWW2/FJZdcEjfddFM88sgjkcvl6nzsFltsEfvvv38MGzYsvv71r0dpaWnS3j788MMYN25czJgxo97HOmf1P2dNTb73rQh7Vz4V22zhiPTzhbOa6R5hrjvpXHPNNfG///u/0bp166S5Q4cOjYqKili+fHnS3IiIkSNHRllZWdLM6urqpHlNke9Wzf+7VVNnX7Wvkl8rV66MRYsWNfh416xrdn3mzp1b6BYy5X7GR9zPaLr3MwAAAAAAAAAAAAAAAAAAAAAAAPLtuOOOSzpzNpfLxTXXXFOn1954442xePHi6NixY7L1IyLGjh0bl112WdJMyIfGzgw0k+8jzXEmX21tbTz88MPx1FNPxTvvvBM1NTXRqlWrqKysjF69esWAAQOiX79+hW5zvRYtWhQPPPBAzJs3L5YsWRJr1qyJNm3axIYbbhj9+vWLnXfeOfl+sC5Dhw6NDTfcMN57772kua7BjzTHazCV5jwbdty4cbHvvvsmzRw+fHiUl5fH6tWrk+Z+rKqqKmnelVdeWa/Xe/ZYmmePAQAAAAAAAAAAAC1Ero4iQimllFJKKaWUUkoppZRSSimllFJKKaWUUkqpeldZWVldf2W1XhYuXFjwn60lVElJSe7II4/MzZs3r9F/Z88991xu0KBBSfrq3bt37oknnkjwTlq7VatW5Tp16pTsPO61116Z9bo+8+bNy51yyim5DTbY4At73HzzzXPnnHNO7oMPPihIr2uzZs2a3NSpU3P77LNPrqSkZL39l5aW5g444IDcjBkz8tLb4YcfnvRay+I9ctdddxV1f3WxZs2a3I033pgbOXJkrm3btl/YZ2lpaW7QoEG5q6++Ordq1apMe6utrc117tw56ftg2rRpmfb8n+67777c2LFjc927d69zfzvuuGPuggsuyC1atChvff6nlO9ppZRSSimllFJKKaWUUkoppZRSSimllFJKKdUyqzEK3btSSimllFJKKaWUUkoppZRSSimlmkedf/75iaZzfVpVVVXBf7aIyP3whz/M5OfL5XK5gw46qFG9FWquXipDhgyp88/ar1+/zGfy5XK53LPPPps744wzcv369atzb5tvvnnuv//7vzOdK/qfamtrc1tvvXW93y8twfnnn1/v83LKKadk2tPDDz+c22OPPZJ8Hu2zzz5JZuquTXV1daN6u+qqq5L3VFtbmzv77LNzrVq1SnL+Nt9889wf/vCH3OrVqxvd26uvvpr7wQ9+0Kh5v85Z46rYZ9/ma9/K5Zr33pXPv/+6KObZwrlcNvOFU850z+XMdU/NfOOPasqUKcnPbS6Xy40cOTKTfu+4446kfS5dujRXWVmZ13NejO9n360aXv37909wtj7tueeey/tnwZIlS5L/HO3atUvao321Ze2rxdTf6aefnryfYnf88ce7ZhuhIdfsNddck1k/xeS9995r1p9h7md8mvsZTfd+hlJKKaWUUkoppZRSSimllFJKKaVaXjVGoXtXSimllFJKKaWUUkoppZRSSimllFJKKaVU068XX3wx0WSmj8ycObNe648bNy7p+h/bdtttC35uzU5dt/rMTjUzsO5lJt+/NZeZfPPmzcudcsopuQ022KBO5/icc87JffDBBwXpdW3WrFmTmzp1am6fffbJlZSUrLf/0tLS3AEHHJCbMWNGXno7/PDDk35Wmov5afW5Bn3OF/azKNVs2IqKitzixYuT99fY5+Stq9q2bZtbunRpsj5Xr16d69GjR7168OyxjzT22WNKKaWUUkoppZRSSimllFJKKaWUUkoppZRq+lUXJblcLhd1UFJSUpeXAQAAAAAAAAAAAMCndOnSJRYuXJg899lnn41tttkmeS5rV1ZWFqNHj45f/OIXsckmm9T7+D//+c9x2mmnRU1NTbKe2rdvH1OnTo0DDjggWeZ/OuKII2Ly5MlJsvbaa6+45557kmTVxYcffhg/+clP4qKLLora2tp6Hdu1a9eorq6OIUOGZNRd3Tz66KNx4oknxiOPPFLvY7/+9a/H1VdfHV27ds2gs49cdtllceKJJybLy+I9cvfdd8c+++yTJCvf7+GIiNtvvz1OP/30ePrppxt0fP/+/eOFF15I3NWnpfyc6NGjR7z66qtRXl6eJG9d/vnPf8b3v//9+Mc//tHgjA4dOsSPfvSjOOOMM6JVq1YJu1u/lO9pAAAAAAAAAAAAAFqmOo5lXyuz2gEAAAAAAACAFM4///z4wQ9+kDx31KhRcd111yXPrY8ePXrE888/Hx07dkyencvlonPnzvH+++83OKMQc/VSGjp0aNx00011em11dXUce+yxmfXywgsvxA9+8IOYMWNGo3IOPPDA+N3vfhfbbbddos7WbvLkyXHEEUfU65j+/fs3eL0f/ehHcfzxxzf4+LU577zz4oorrkiauXDhwnjvvffqdcxzzz0XX/7yl5P28bErrrgiTjnllFi5cmWyzA033DCmTp0agwYNSpYZEbFs2bLo3r17LFmypEHHP/jgg7HLLrsk7emEE06Iyy+/PGlmRMRXvvKVuPrqq2P77bev97EPPfRQXHDBBTFlypR6z8j9LOescYp99m3W+1ZEy9i71qWpzhYeN25c7L777ok7+7SU84X/U2NnukeY617sn1tN2fDhw2P69OnJc6+77roYNWpU0swuXbrEggULoqysLFnm1Vdfnfme81nF+H723arhsph///zzz8dWW22VNPOLLFmyJNq3b580s7KyMpYtW5Y0M8K+mkIxfg59VmP+m6+1aUx/vXv3zvs1uTYlJSVxwQUXxJZbbpnpOv/3f/8Xp512WrI812zd9OjRIzp06NDg9caMGRNnnnlmg49fm3HjxsVvfvObpJmrVq2Kl19+uVEZxfwZ5n7G57mf0bTvZwAAAAAAAAAALYdZ7QAAAAAAAAAAAEChDBo0KO66666kmaNHj45x48bV+fX77bdf3HHHHUl7iEg/368hzE5dt/rMTjUzsO5SzxT9LDP58jeT78MPP4yf/OQncdFFF9V7nnPXrl2juro6hgwZklF3dfPoo4/GiSeeGI888ki9j/36178eV199dXTt2jWDzj5y2WWXxYknnpgsz1zMz6vrNehzvu6KeTZsxEfPuxo9enSSrI+lvlY/dsghh8TUqVOT5d1yyy0xePDgeh3j2WMfaeyzxwAAAAAAAAAAAICmry7/PUR5HvoAAAAAAAAAAAAAoAWrrKzMJHfp0qWZ5K7PRhttFPvtt1/e162Pd955J+6+++7kubW1tXHZZZfF1VdfHaecckr8/ve/r/Oxv/71r+Oss85K3tPSpUujqqoqnnrqqdh0002T5++xxx4xefLk5LlZe/rpp2PkyJExd+7cBh2/cOHCGDZsWFRXV8cxxxyTuLu6+f3vfx9nnnlmvYfJf+yWW26JPfbYI+6+++7o2bNn4u4+sv/++2eSS0RNTU185zvfiSuuuKJROXPmzInx48fH0UcfnaizzzvooIOSfU6MGTMmysuz+888amtr48c//nH87ne/a/QDOJYsWRI/+clP4vrrr48pU6ZEnz59EnUJAAAAAAAAAAAAAAAAAAAAAAAANEXl5eVx7bXXRseOHTPJf+qpp+L999/PJDvfFi9eHPfdd1/cf//98dxzz8W8efPivffei6VLl8bq1avXedyKFSvqlN+1a9c48sgjU7X7KblcLn7729/Gz372s/X2Wle33XZb7LDDDnHWWWfF2WefHaWlpQm6/LxDDz00Ntlkk3jjjTfqfMycOXMavN6iRYsafOy6vP32243qKYW99torvvzlL2eS/eMf/zh+85vfJM9977334oADDog777wz9tprr2S57dq1iyOPPDIuvfTSBh3fv3//ZL1ERMycOTMuv/zypJkfe+KJJ2KPPfaIadOm1Wkea21tbUybNi1+//vfxwMPPJCsD+es+cpy34poWXtXMUg5W3ivvfaKcePGNZn5wv/pszPdzzrrrOjSpUudjzfXnSzddNNN8c4770S3bt2S5g4dOjQqKipi+fLlyTJHjhwZZWVlyfIiIsaNG5c0r6ny3YqmxL5Kvr388svx8ssvF7qN+MlPfhJbbrllpmvcfvvt8f3vfz9ppmu2bt5666146623Grze22+/3eBj12XRokUFv//YlLifsXbuZzTt+xkAAAAAAAAAAAAAAAAAAAAAAABZGzNmTNK8mpqamDJlSr2OmTlzZrz11lvRo0ePpL0cffTRceaZZ8aqVauS5pJ/ZgbWTdeuXTPLNpMvv55++ukYOXJkzJ07t0HHL1y4MIYNGxbV1dVxzDHHJO6ubn7/+9/HmWeeGbW1tQ06/pZbbok99tgj7r777ujZs2fi7j5SlxnbdWUu5trV9Rr0Od98XHnllTF69OikmQcffHCcdNJJsWbNmqS5VVVVSfPq+9wFzx77t8Y+ewwAAAAAAAAAAABoGcoL3QAAAAAAAAAAAAAAzVvr1q0zya2pqckkd3322muvmDx5ct7XrY+777477r777szya2pq4n//93+jffv28YMf/CA6duy43tdfeumlcdZZZ2XWz/vvvx/HHXdc3HHHHcmzBw4cmDwzazNnzowRI0bE0qVLG5WTy+VizJgx0a9fv9h9990TdffFamtr4+STT47LLrus0Vlz586NQw45JGbNmhXl5el/db53797RqVOn+OCDD5Jnt2Tvv/9+jBgxIu69994keccdd1xstNFGMWTIkCR5n7XTTjslySkpKYkTTjghSdba1NTUxMiRI+Omm25Kmvv444/HrrvuGjfddFPsvPPOSbMBAAAAAAAAAAAAAAAAAAAAAACApqF169Zx/fXXx1577ZXZGqlm1BXKihUr4oYbboirr7467rzzzlizZk1ma5144omZzIOtqamJI488MqZNm5Y0t7a2Ns4555yYPXt2TJkyJdq1a5c0PyKivLw8Tj755PjpT3+aPLslOemkkzLJvfrqq+M3v/lNJtkREatXr46jjjoqnnzyyejcuXOy3OOOOy4uvfTSeh9XUlISG2ywQbI+IiLGjRuXNO+zli5dGsOGDYtZs2atc2bv4sWL4/LLL48//OEP8corryRd3zlr3rLatyLsXfmWerZwbW1tk5kvvC4fz3S/7LLL4rTTTjPXnaJQW1sbkyZNiv/+7/9OmltZWRmDBw+OqVOnJsusqqpKlhUR8eqrr2b6HIemwncrmir7Ki3JN77xjTjnnHMyXWPevHlRVVWV2X1K1yzNnfsZa+d+RvO4nwEAAAAAAAAAAAAAAAAAAAAAAJCFjh07xqGHHpo088Ybb4zFixfX65hcLheTJ09OPqN3o402ioMPPjiuv/76pLlQrE488cRMcs3ky6+ZM2fGiBEjYunSpY3KyeVyMWbMmOjXr1/svvvuibr7YrW1tXHyySfHZZdd1uisuXPnxiGHHBKzZs2K8vLyBN19Wu/evaNTp07xwQcfNDrLXMy1a4rXII0za9asmDdvXvTr1y9ZZteuXWPPPfdM+sy8Nm3axLBhw5Llvf/++/HXv/61Xsd49tinNfTZYwAAAAAAAAAAAEDLUVroBgAAAAAAAAAAAABo3lq1apVJbk1NTSa569O3b9+8r1mszjnnnOjdu3f87ne/ixUrVqz1NY899liceuqpmfdy5513xsMPP5w8d8CAAVFa2nR+5XrWrFkxdOjQRg9j/9jq1avjlFNOiVwulySvLk466aQkw9g/9tBDD2U6oHe77bbLLLslWrlyZQwfPjzp4Ow1a9bEmDFjYsmSJcky/9NWW22VZJj+DjvsEF/60pcSdPR5a9asicMPPzxuuummTPL/9a9/xUEHHRRPP/10JvkAAAAAAAAAAAAAAAAAAAAAAABA8dpyyy3jn//8Z3zjG9/IdJ2s5qllbeXKlXHRRRdF79694+ijj47bb7891qxZk+maxxxzTPLMVatWxfDhw2PatGnJsz92yy23xEEHHZTZzNlvfetbmeS2FG3atIkRI0Ykz3388cfjhBNOSJ77WW+88UacdtppSTN33XXX6Ny5c72Pq6ysTNpHRMQLL7yQPPOzampq4pBDDokPPvjgU//+pZdeiv/6r/+KTTbZJL7//e/HK6+8knxt56x5y2LfirB35VsWs4Ujms584S+ydOlSc90pKtXV1Znkjho1KllWly5dYtCgQcnyIiKuuuqqpHlNle9WNHX2VZq7bbbZJiZOnBglJSWZrbF48eIYPnx4vP/++5mt8THXLM2V+xnr5n5G87mfAQAAAAAAAAAAAAAAAAAAAAAAkNJRRx0VFRUVSTPHjx/foOMmTJiQtI+PjR07NpNcKEaej7N2TWkm36xZs2Lo0KGxdOnSJHmrV6+OU045JXK5XJK8ujjppJPisssuS5b30EMPxaWXXpos77O22267JDnmYq5bU7oGSSOLZy8ceuihSfO+/vWvR/v27ZPlXXPNNbFy5co6v96zxz6voc8eAwAAAAAAAAAAAFqO0kI3AAAAAAAAAAAAAEDz1rp160xy6zO4NJUtttgi72sWs3fffTfOOOOM6Nu3b1xyySWxevXqT/6strY2jj766MyGNH/WxRdfnDyzXbt20atXr+S5WViwYEGMGDEiVqxYkTT3iSeeiIkTJybNXJeLL744Lr/88uS5Z599drIh9Z/1la98JZPcluqkk06K+++/P3nuggUL4he/+EXy3IiI8vLy2GabbRqds99++yXoZu1+/vOfx4033phZfkTEe++9F8OHD4/3338/03UAAAAAAAAAAAAAAAAAAAAAAACA4tCjR4/4y1/+Ek8//XTssMMOma71zjvvxG233ZbpGlmYO3du7LrrrvG9730vFixYkJc1d9hhh+jfv3/y3O985ztx++23J8/9rPvvvz9Gjx6dSfZmm20Wu+22WybZLcE+++wT7dq1S577/e9/P29zhidNmhRvvfVWsrzS0tI44IAD6n1cFudxyZIlyTPX5rXXXotzzz03Ij66Xg855JDo169f/OEPf8hs/muEc9acZbVvRdi78i2r2cIRTWO+cF2Z606xeOKJJ+LJJ59Mnjt06NCoqKhIkjVy5MgoKytLkvWxq666KmleU+W7Fc2FfZXmqHPnzjF9+vRo3759ZmusWbMmjjrqqHj++eczW2NtXLM0J+5nrJ/7GR9pTvczAAAAAAAAAAAAAAAAAAAAAAAAUhg7dmzSvHfffTduvvnmBh37yCOPxAsvvJC0n4iI/fff32w6WgTPx1m3pjKTb8GCBTFixIhYsWJF0twnnngiJk6cmDRzXS6++OK4/PLLk+eeffbZmc28/spXvtLoDHMx16+pXIOkc/XVV8eaNWuSZo4cOTJp3uGHH540b9y4cfV6vWePfV5Dnz0GAAAAAAAAAAAAtBylhW4AAAAAAAAAAAAAgOattDSbX1lNPay1Lvr165f3NZuCN998M04++eTYcsstY8KECbFmzZq49NJL45lnnslbD9OnT88kd9NNN80kN7VTTjklFi1alEn2eeedl0nuf3rllVfijDPOyCR74cKFcdVVV2WS3bt370xyW6Ibb7yx3kOp6+OPf/xjLFy4MJPsPn36NDojq0HSDz30UPzqV7/KJPuz5s+fH9/+9rfzshYAAAAAAAAAAAAAAAAAAAAAAACQfyUlJTFo0KC49NJLY968eXHiiSdGeXl55utee+21UVtbm/k6Kd16662xww47xOOPP57XdQ8++ODkmTfffHNcdtllyXPXZdKkSTFlypRMsg855JBMcluCYcOGJc+84447YubMmclz12X16tVxySWXJM0cMmRI0ryG2mijjfK21oUXXhg77bRTfO1rX4u//vWvkcvl8rZ2Ss5Zcchi34qwd+Vb1rOFI4p/vnB9metOMaiurk6eWVlZGYMHD06SVVVVlSTnY7NmzYoXX3wxaSb/5rsVhWRfpbkoKyuLG264IfPvpz/+8Y/j73//e6ZrrI9rlubA/Ywv5n7GR5rb/QwAAAAAAAAAAAAAAAAAAAAAAICG2m677WLgwIFJM6+77rpYtWpVg4+fOHFiwm4+UlpaGscff3zyXCg2no+zfk1hJt8pp5wSixYtyiT7vPPOyyT3P73yyitxxhlnZJK9cOHCuOqqqzLJ7t27d6MzzMX8Yk3hGiSd1157Le66666kmZtuumnsvPPOSbJat24dw4cPT5IVEfHcc8/F7Nmz63WMZ4+tXbE8ewwAAAAAAAAAAAAoTqWFbgAAAAAAAAAAAAAAmoq+ffsWuoWi9tJLL8XRRx8d22+/ffzsZz/L69rvvvtuvPTSS8lze/XqlTwztQcffDCmTZuWWf5TTz0Vc+fOzSw/IuIXv/hFLF++PLP86667LpPcnj17ZpLb0qxYsSJOOumkTNdYvXp1TJ48OZPsTTbZpFHHt27dOvbcc89E3Xzad77zncjlcplkr811110Xt9xyS97WAwAAAAAAAAAAAAAAAAAAAAAAALLTvn372H333eOUU06Jyy+/PN54442466674oQTToh27drlrY8rr7wyb2ulcMstt8Q3vvGN+PDDD/O+9gEHHJA0r7a2Nk499dSkmXXx3//937Fy5crkuanPT0syePDg5Jn/7//9v+SZX+T6669Pmrf77rvX+5gs3tt77bVX8sx1WblyZTzyyCN5W+/jNVNr7uesqcjic9nelV/5mC0cUdzzhRvDXHcKaeLEibF69erkuaNGjWp0RpcuXWLQoEGNb+Y/jBs3LmleU+a7Fc2VfZWm7v/+7/9in332yXSNa665Js4777xM16gr1yxNmfsZX8z9jI801/sZAAAAAAAAAAAAAAAAAAAAAAAA9TV27NjkmRMmTGjU8RMnTkzUyaeNHj06SkpKMsmGYuH5OOtX7DP5HnzwwZg2bVpm+U899VTMnTs3s/yIiF/84hexfPnyzPKvu+66THJ79uzZ6AxzMb9YsV+DpJfFM+4OPfTQJDkHHnhgdOzYMUlWRMN+Vs8eW7uGPHsMAAAAAAAAAAAAaDlKC90AAAAAAAAAAAAAADQFrVu3jl69ehW6jSbhmWeeiUWLFuV93dmzZyfP3GSTTZJnpnbBBRdkvsYNN9yQWfY777yT2UM1PnbffffFO++8kzw3xUB2PhpI/eabb2a+ztVXX51J7qabbtqo43fbbbeoqKhI1M2/3XLLLfHwww8nz/0iP/rRj/K+JgAAAAAAAAAAAAAAAAAAAAAAALR0v/71r2P27NmNqkceeSTmzJkTCxYsiOXLl8eSJUti1qxZcfHFF8eYMWOiR48eef+5pk+fHk888UTe122op556Kg455JBYuXJl3tdu37597LLLLkkzr7322pg3b17SzLp4/fXX46qrrkqe+5WvfCW6dOmSPLe522ijjaJPnz5JM99666249957k2bWxXPPPReLFy9Olte3b9/o0KFDvY5ZtmxZsvU/9l//9V+x4YYbJs8tFs5Z85TFvhVh78q3fM0Wjije+cIpmOtOIbzzzjtx6623Js8dOnRoo2dujxw5MsrKyhJ1FLF8+fK47rrrkuU1db5b0dzZV2mKxo4dG9/97nczXePhhx+O0aNHZ7pGQ7hmaWrcz6gb9zP+rTnfzwAAAAAAAAAAAAAAAAAAAAAAAKiL1q1bx7e+9a2kmfPnz49Zs2Y1KuOll16KBx98MFFH/7bZZpvFfvvtlzwXioXn43yxYp/Jd8EFF2S+xg033JBZ9jvvvBMTJ07MLD8i4r777ot33nkneW7Pnj0bdby5mHVT7Ncg6U2dOjXpM6kiIg499NAkOVVVVUlyIiJqa2tjwoQJ9TrGs8fWrSHPHgMAAAAAAAAAAABajtJCNwAAAAAAAAAAAAAATUHv3r2jtNSv3xazN998M3lmZWVl8syU3n///fjb3/6W+Tr33XdfZtmTJk2K1atXZ5YfEZHL5eIf//hH8txu3bolz2xpcrlc/O53v8vLWrNnz44lS5Ykz914440bdfw222yTqJNP+8Mf/pBJ7hd54okn4pZbbinI2gAAAAAAAAAAAAAAAAAAAAAAANBS9enTJ3baaadG1Y477hhbbLFFbLzxxtG2bdtC/0gREXH22WcXuoU6W7p0aRx22GGxYsWKgqw/cODAKCsrS5p56aWXJs0r9NolJSWx8847J89t7nbcccfkmVOnTo1cLpc8ty5mz56dLKukpCS23377eh2zcuXKWL58ebIeIj6ajXnLLbdEz549k+YWC+esecpi34qwd+VTPmcLRxTvfOGmrCXOdefTqqurk2dWVlbG4MGDG5VRVVWVqJuPTJs2LZPPj6bKdyvIhn2Vhtpjjz3iT3/6U6ZrLFiwIEaMGFGw+5bFyDVLQ7mfUTfuZ/yb+xkAAAAAAAAAAAAAAAAAAAAAAEBLd/DBB0fnzp2TZk6cODFJzoQJE5LkfNbYsWMzyYVi4Pk4X6yYZ/K9//778be//S3zde67777MsidNmhSrV6/OLD/io9mF//jHP5LnduvWrVHHm4tZN8V8DZKNFStWxHXXXZc0s1+/frHttts2KqNVq1bxjW98I1FHEbfeemssWLCgXsd49ti6NeTZYwAAAAAAAAAAAEDLUVroBgAAAAAAAAAAAACgKejbt2+hW+ALvPfee8kzKyoqkmemdPvtt8fKlSszX+eZZ57JLHv69OmZZf+np59+Onlm27Ztk2e2NI899li8/PLLeVvviSeeSJ7Z2M+JLbfcMlEn/7Zw4cK47bbbkufW1eWXX16wtQEAAAAAAAAAAAAAAAAAAAAAAIDm4frrr4/HHnus0G3U2c9//vOYM2dOwdbfaaedkua9+eabce+99ybNrI+HH3445s6dmzx34MCByTObux133DF55rRp05Jn1lXqGaUDBgyo9zHz589P2kNExC677BLPPvts/OpXv4p+/folzy8056z5Sb1vRdi78i3fs4UjinO+cFPWEue682nTp0/P5H0watSoBh/bpUuXGDRoULpmIqK6ujppXnPguxWkZ1+lIXr16hVTp06NVq1aZbZGTU1NHHLIIfHmm29mtkZT5JqlodzPqDv3M/7N/QwAAAAAAAAAAAAAAAAAAAAAAKAlGzNmTPLMCRMmJMmZPHly1NbWJsn6TwcffHB07tw5eS4UA8/HqZtincl3++23x8qVKzNf55lnnskse/r06Zll/6fUz7eJiGjbtm2jjjcXs+6K9RokO+PGjUueedhhhzXq+AMOOCA6deqUqJuIK6+8st7HePbY+jXk2WMAAAAAAAAAAABAy1Ba6AYAAAAAAAAAAAAAoCno169foVvgC3zwwQfJMysqKpJnpnTnnXfmZZ1XX301li5dmjy3pqYmZs2alTx3bYpxIDsRN910U17Xe/zxx5NnNvZ90L9//0Sd/Nstt9ySyUNq6mrGjBmxfPnygq0PAAAAAAAAAAAAAAAAAAAAAAAANG3vvvtufPe73y10G3X22muvxZ/+9KeC9jBgwICkebfffnvSvGLpIfV5agl23HHH5JmzZ89OnllXixYtSprXp0+feh8zb968pD18rFOnTvHjH/845s6dG3PmzIkJEybED37wgzjkkENiu+22i3bt2mWybj44Z81PFp/H9q78yvds4YjinC/clLXEue582sqVK2Py5MnJc4cOHdrg98LIkSOjrKwsWS9vvPFG3HHHHcnymgvfrSA9+yr1VVFREdOnT49u3bplus63v/3t+Oc//5npGk2Ra5aGcj+j7tzP+Df3MwAAAAAAAAAAAAAAAAAAAAAAgJaqV69esf/++yfNfOSRR+L5559PkrVw4cJM5te2adMmvvnNbybPhWLg+Th1U6wz+e688868rPPqq6/G0qVLk+fW1NTErFmzkueuzdNPP508s7GzBM3FrLtivQbJzj/+8Y+YO3du0syRI0c26viqqqpEnXz0TL8bb7yx3sd59tj6NeTZYwAAAAAAAAAAAEDLUF7oBgAAAAAAAAAAAABo3latWpVJbmlpaSa569KvX7+8rkfdtG/fPnr37h29e/eO3XbbLXl+mzZtkmem9Nhjj+Vtrfnz58e2226bNPO5556LlStXJs1cl5dffjl5ZmMHshNx77335nW9efPmJc9s7Ptgyy23TNTJv+XrYQ3rUlNTE/fcc098/etfL2gfAAAAAAAAAAAAAAAAAAAAAAAAQNN06qmnxjvvvFPoNurs17/+ddTU1BS0h759+ybNu+uuu5LmNcTdd98dp5xyStJMM2brb7PNNkua98orr8TixYuTZtbH+++/nzRvk002qfcxDz74YAwfPjxpH5+1xRZbxBZbbBHf/OY3P/XvFyxYEPPmzYsXX3wx5s6dGy+++OIn//zee+9l2lNjOGfNT+p9K8LelW/5ni0cUZzzhZualj7Xnc+rrq6Ok046KWlmZWVlDB48OKZOnVrvY6uqqpL2Mn78+MjlckkzmwPfrSAN+yqNcdVVV8WAAQMyXeN///d/46qrrsp0jabENUsK7mfUnfsZ/+Z+BgAAAAAAAAAAAAAAAAAAAAAA0FIdf/zxUVpamjRz/PjxSfMmTJgQBx10UNLMiIgTTjgh/vjHPybPhULzfJy6KdaZfI899lje1po/f35su+22STOfe+65WLlyZdLMdXn55ZeTZzZ2lqC5mHVXrNcg2Ro3blz86le/Spa33XbbRb9+/Ro0W7S8vDxGjBiRrJdrrrmmQZ9/nj22fg159hgAAAAAAAAAAADQMpQXugEAAAAAAAAAAAAAmrcVK1Zkktu6detMctfFMODCKC8vj8022yx69+4dffr0iT59+kTv3r0/+eeNNtqo0C0W1LPPPpu3tZYsWZI885lnnkmeuS5Z9N+qVavkmS3Nc889l9f1Pvjgg+SZjXkftGrVKvmA7YiIRx99NHlmff3jH/+Ir3/964VuAwAAAAAAAAAAAAAAAAAAAAAAAGhiJk2aFBMnTix0G3VWW1sb119/faHbiL59+ybNe/LJJ5PmFUsPqc9TS9CrV6+keYV+b73//vtJ8zbddNN6HzNr1qykPdRH9+7do3v37rHnnnt+7s/ee++9ePHFF2PevHmf1Ny5c+O5556L9957rwDd/ptz1vxk8Xlc6M+XrHoo1r0r37OFI4pvvnAxMted+nrwwQfjhRdeiC233DJp7qhRo2Lq1Kn1OqZLly4xaNCgpH1UV1cnzWsufLeCurGvkpWf/OQncfjhh2e6xm233RY/+MEPMl2j2LhmyQf3M+rO/Yx/cz8DAAAAAAAAAAAAAAAAAAAAAABoqUaPHp00r7a2Nq699tqkmdOmTYtly5ZFu3btkuZut912MXDgwHjkkUeS5kKheT5O3RTrTL5nn302b2stWbIkeeYzzzyTPHNdsui/sbMEzcWsu2K9BsnW+PHj4//9v/8XpaWlyTJHjhwZ5513Xr2P23///WODDTZI1se4ceMadJxnj61fQ549BgAAAAAAAAAAALQM5YVuAAAAAAAAAAAAAIDmbcWKFZnktm7dOpPcdenXr19e12tJevToEb17944+ffp87v9usskmSQfxNicffPBBLF26NG/rZTHQ/PXXX0+euS5Z9E/jLFu2LK/vgYiIxYsX53W9L9KpU6fkn3G1tbXx/PPPJ81siCeeeKLQLQAAAAAAAAAAAAAAAAAAAAAAAABNzKxZs+L4448vdBv1ct9998W//vWvgvbQqlWr6NatW7K8XC4Xzz33XLK8hpo7d26sXLky6Rza9u3bR6dOneKDDz5IltmclZWVRffu3ZNmfvnLX45rrrkmaWZ9bLbZZknzNtlkk3ofc99998W7774bnTt3TtpLY2244Yax0047xU477fS5P1uwYEE89thjcd9998V9990XDzzwQNTW1uatN+eseUm9b0XYu/KtELOFI4pvvnChmOtOatXV1fHrX/86aebQoUOjoqIili9fXudjRo4cGWVlZcl6ePDBB+OFF15Iltec+G4F/2ZfJd9GjBgR55xzTqZrzJ07N6qqqmLNmjWZrlMIrlkKyf2M+nE/49/czwAAAAAAAAAAAAAAAAAAAAAAAFqi/fbbL/mzAe688854++23k2Z++OGHMX369DjiiCOS5kZEjB07Nh555JHkuVAono9Td8U4k++DDz6IpUuX5m29JUuWJM/M50zBLPpvDHMx66cYr0Gy9/rrr8edd94ZBxxwQLLMQw89NM4777x6H3f44Ycn6+GZZ55p0HdKzx77Yg159hgAAAAAAAAAAADQMpQXugEAAAAAAAAAAAAAmrcVK1ZkktumTZtMctemtLQ0Nt9887yt19y0bt06tthii+jfv3/06dMn+vTpE717944+ffrEZpttFm3bti10i03SggUL8rpeFgPN33rrreSZ61JsA9nJ/3s4ImLx4sV5X3N92rdvnzxzwYIFsWrVquS59fXiiy8WugUAAAAAAAAAAAAAAAAAAAAAAACgCXnxxRdjxIgRsXLlykK3Ui833XRToVuILl26JM3717/+ldlM2fpYs2ZNvPXWW7HZZpslze3SpUt88MEHSTObqx49ekRpaWnSzC222CK22GKLpJmF1LFjx3ofU1tbG1OmTIkTTjghg46y0b179xg8eHAMHjw4IiLee++9mDFjRkyaNCluvfXWyOVyma7vnDUvqfetCHtXvhVitnBE8c0Xzoq57uTb+PHj49xzz036va+ysjIGDx4cU6dOrfMxVVVVydaPiKiurk6a15z4bkVLYl+lmGyzzTYxYcKEKCkpyWyNxYsXx/Dhw4vqfz/Uh2uWYuZ+Rv25n/GRlnI/AwAAAAAAAAAAAAAAAAAAAAAA4D+NHTs2eeb48eOTZ0ZETJgwIY444ojkuUcddVScfvrpsXz58uTZUAiej1M/LX0m35IlS5JnvvXWW8kz1yWL/hvDXMz6K7ZrkPwYN25cHHDAAcnydtlll9h0003j9ddfr/MxZWVlcfDBByfr4corr2zQcZ499sUa8uwxAAAAAAAAAAAAoGUoL3QDAAAAAAAAAAAAADRvWQ0HrqyszCR3bb70pS9Fq1at8rZeU/eVr3wlvva1r8Xuu+8eO++8c/Tp0yf5AFnyP2B81apVyTPz+TNk0T+Ns3Tp0ryvuXLlyryvuT5Z7GX5fljDurzxxhuFbgEAAAAAAAAAAAAAAAAAAAAAAABoIp599tk44IADYtGiRYVupd6efPLJQrcQXbt2TZpXLHPtIj7qZbPNNkua2bVr13jxxReTZjZXHTt2LHQLRa9t27YNOu7CCy+ME044IXE3+bPhhhvG0UcfHUcffXTMnz8/LrroovjTn/4Uy5cvz2xN56z5SL1vRdi78q0Qs4Ujim++cCrmulNob7zxRsycOTP233//pLlVVVUxderUOr22S5cuMWjQoGRr19TUxLXXXpssrzny3Yrmyr5KsercuXPceOON0b59+8zWWLNmTRxxxBHxwgsvZLZGaq5ZmhL3M+rP/YyPNNf7GQAAAAAAAAAAAAAAAAAAAAAAAOuy4YYbxiGHHJI0c9myZTFt2rSkmR+79dZbY9GiRbHRRhslze3YsWMcdthhMX78+KS5UCiej1M/xTaTb8mSJXldb9WqVckz8/kzZNF/Y5iLWX/Fdg2SH9OmTYsPPvggOnXqlCzzkEMOiT/+8Y91fv2+++4bnTt3TrL26tWrY+LEiQ061rPHvlhDnz0GAAAAAAAAAAAANH+lhW4AAAAAAAAAAAAAgOatpqYmk9wshhmvS79+/fK2VlM1aNCguOyyy+KNN96Ixx9/PP74xz/GkUceGf369YvSUr+2nIUVK1YUuoVGaw4/Aw334YcfFrqFgmvfvn3yzMWLFyfPbIj333+/0C0AAAAAAAAAAAAAAAAAAAAAAAAATcBDDz0UX/va1+LNN98sdCsN8swzzxS6hejQoUPSvGKaJ/fee+8lz0x9vpqzioqKQrdQ9Bp6jp555pm48cYbE3dTGJtvvnn87ne/i5dffjm+853vRElJSSbrOGfNRxafw/au/DJbuPHMdafYVFdXJ88cNmxYnb8rjRw5MsrKypKtPX369KLaG4qR71Y0J/ZVil1ZWVnccMMN0bt370zX+dGPfhQ333xzpmuk4JqlqXI/o/7czwAAAAAAAAAAAAAAAAAAAAAAAGiZvvnNb0abNm2SZv71r3/NbJ7U6tWr4/rrr88ke+zYsZnkQiF4Pk79FNtMvhUrVhS6hUZrDj9DQ5mLWX/Fdg2SHytWrIjJkycnzTz00EPr9fqqqqpka998883x9ttvN+hYzx77Ys4RAAAAAAAAAAAAsC6lhW4AAAAAAAAAAAAAgOZt5cqVsXz58uS5Xbp0iZKSkuS5a9O3b9+8rNPUdOjQIc4888x4+eWX46677oqxY8dGz549C91Wi7F69epCt9BozeFnoOFWrlxZ6BYKrn379skzi+lBBzU1NYVuAQAAAAAAAAAAAAAAAAAAAAAAAChikyZNin333TfefffdQrfSIB9++GG8/vrrhW4jWrdunTSvmGbJZdFLmzZtkmc2VxUVFYVuoeiVlJREq1atGnTs6aef3qzmc2688cZx0UUXxYMPPhjbbrttJms4Z81D6n0rwt6Vb83pOswnc90pZlOnTo0lS5YkzaysrIzBgwfX6bVVVVVJ1x43blzSvObKdyuaMvsqTcmFF14Y++yzT6ZrTJw4Mc4///xM12gM1yzNgfsZ9ed+BgAAAAAAAAAAAAAAAAAAAAAAQMs0duzY5JkTJkxInpmP/L322iv69euXSTbkm+fj1E+xzeRbvXp1oVtotObwMzSUuZj1V2zXIPmT+lkFX/va16Jr1651em1ZWVkcfPDBydZuzM/i2WNfrDHPHgMAAAAAAAAAAACat9JCNwAAAAAAAAAAAABA8/fmm28mzywrK4uNNtooee7abLHFFnlZpyn5+c9/Hq+99lr89re/jc0337zQ7QBNUC6XK3QLBZfFkPna2trkmQ21atWqQrcAAAAAAAAAAAAAAAAAAAAAAAAAFKFly5bF6NGj45vf/GZ8+OGHhW6nwd59991CtxAREa1bt06at3LlyqR5jVFTU5M8M/X5as4qKioK3UKT0KpVqwYdN2/evDj77LPTNlMEdt5553jooYfi2GOPTZ7tnDUPWXwO27vyy2zh+mnbtq257hS95cuXxw033JA8t6qq6gtf06VLlxg0aFCyNRcsWBC33nprsrzmzHcrmiL7Kk3NCSecEN/5zncyXePhhx+OMWPGZLpGQ7lmaU7cz6g/9zMAAAAAAAAAAAAAAAAAAAAAAABanh122CG+8pWvJM1cuHBh3HbbbUkzP2vWrFkxf/78TLKLdWYg1Jfn49RPsc3ko2kzF7P+XIMt1z//+c+YM2dOsrzS0tIYMWJEnV47aNCg6NKlS5J1Fy1aFDNmzGjw8Z49VjcNffYYAAAAAAAAAAAA0LyVFroBAAAAAAAAAAAAAJq/N998M5PczTbbLJPcz9pkk01i6dKlyWv58uV56T+1oUOHxi9/+cvo1KlToVsBAAAAAAAAAAAAAAAAAAAAAAAAAKAJufvuu2PgwIExbty4QrfSaEuWLCl0CxERUVZWljRvzZo1SfMaI4teysvLk2c2V61atSp0C83er3/967j11lsL3UZyFRUVUV1dHb/5zW+SZztnTV/qfSvC3kXxGjp0aLzwwgvmutMkVFdXJ88cNmxYVFRUrPc1I0eOTLo3TJw4saj2hWLnuxVNiX2VpmbPPfeMiy++ONM13nrrrRgxYkTU1NRkuk5DuGZpbtzPqD/3MwAAAAAAAAAAAAAAAAAAAAAAAFqesWPHJs+89tpro7a2NnnuZ11zzTWZ5B577LGZzDODfPN8nPoxk4+UzMWsP9dgy5b6+XiHHXZYnV5XVVWVbM1JkybFqlWrGny8Z48BAAAAAAAAAAAANJzfRgYAAAAAAAAAAAAgc2+++WYmuV/+8pfjkUceyST7Px155JGZ5O61115xzz33ZJKdhTZt2sTvf//7OOWUUwrdCgAAAAAAAAAAAAAAAAAAAAAAAAAATcgbb7wR3//+92Py5MmFbiWZpUuXFroFoBk4/PDD46677oqBAwcWupXkfvjDH0a7du3i1FNPTZrrnAHFzkx3mqJ77703Xn755ejdu3eyzMrKyhg8eHBMnTp1na+pqqpKtl5ERHV1ddK8lsB3K4qdfZWmqFevXjF16tRo1apVZmvU1NTEwQcfnNlzoRrKNQsAAAAAAAAAAAAAAAAAAAAAAADQMrVp0yaOOuqo5LkPPvhg9O/fP3nuZ82ePTuT3B49esTgwYNjxowZmeQDAPBpV199dZx77rlRWlqaJG/fffeNTp06xQcffLDO15SWlsYhhxySZL2IiCuvvDJZFgAAAAAAAAAAAAD1U17oBgAAAAAAAAAAAABo/t56661McrfaaqtMcvm8DTfcMG688cbYY489Ct0KAOtRUlJS6BY+UUy9AAAAAAAAAAAAAAAAAAAAAAAAAIXx2muvxe9+97u4/PLLY9myZYVuJ6nly5cXugWgGViyZEkcdNBBcfPNN8fOO+9c6HaS+973vhdvvvlm/OY3v0mW6ZwBxcxMd5qy8ePHx89//vOkmVVVVTF16tS1/lmXLl1i0KBBydZ69NFH4+mnn06W11L4bkUxs6/SFFVUVMT06dOja9euma5zwgknxEMPPZTpGvXlmgUAAAAAAAAAAAAAAAAAAAAAAABouUaOHBkbbLBB8twJEyYkz8y3sWPHxowZMwrdBgBAi/Dmm2/G7bffHgcddFCSvFatWsWwYcNi4sSJ63zN3nvvnWwu9VNPPRWPP/54kiwAAAAAAAAAAAAA6q+00A0AAAAAAAAAAAAA0Py98cYbmeRut912meTyaRtttFHcf//9scceexS6FYBmZcWKFckzy8vLk2c2VKtWrQrdAgAAAAAAAAAAAAAAAAAAAAAAAFAgDz74YBx77LHRp0+f+MMf/hDLli0rdEvJ5XK5QrcANBOLFi2KvffeO6ZOnVroVjLxq1/9KoYNG5Y00zkDipGZ7jR11dXVyTOHDRsWFRUVa/2zkSNHRllZWbK1xo0blyyrpfHdimJkX6Wpuvrqq2PAgAGZrnHBBRfE+PHjM12jvlyzAAAAAAAAAAAAAAAAAAAAAAAAAC3b2LFjC91C0Ro6dGhsvPHGhW4DAKDFSP3sgsMOO2y9f3744YcnW+vKK69MlgUAAAAAAAAAAABA/ZUWugEAAAAAAAAAAAAAmr/nn38+k9zdd989k1z+rV27dnHzzTfH1ltvXehWAJqdpUuXJs+sqKhIntkQJSUl0bp160K3AQAAAAAAAAAAAAAAAAAAAAAAAOTR3Llz45e//GVsscUW8dWvfjWuvvrqWL16daHbAmgSli9fHoceemicdNJJsWzZskK3k1RJSUlceeWV0a1bt6S5zhlQTMx0pzl4+eWX4/7770+aWVlZGYMHD17rn1VVVSVbZ9WqVXHNNdcky2uJfLeimNhXaap++tOfxmGHHZbpGrfeemuceeaZma5RX65ZAAAAAAAAAAAAAAAAAAAAAAAAgJZt8803j3322afQbRSt8vLyOOaYYwrdBgBAi/HXv/413n///WR5Bx10ULRr126tf1ZSUhIjR45Mss7q1atj4sSJSbIAAAAAAAAAAAAAaJjSQjcAAAAAAAAAAAAAQPP35JNPZpLbpUuX+PKXv5xJNh+5/PLLY+eddy50GwDN0tKlS5NnbrDBBskzG6Jz586FbgEAAAAAAAAAAAAAAAAAAAAAAADI2KuvvhoTJ06M0aNHx2abbRb9+/ePs88+O+bNm1fo1lqUVatWJc0rLy9PmtcYWfRSU1OTPLO5WrlyZaFbaJH+8pe/xNZbbx1TpkwpdCtJde3aNX7/+99nku2cNS2p960IexfFwUx3movq6urkmVVVVZ/7d126dIlBgwYlW2PGjBmxaNGiZHktme9WFAP7Kk3RiBEj4n/+538yXWPOnDkxatSoWLNmTabr1JdrlpbA/Yz6cz8DAAAAAAAAAAAAAAAAAAAAAACg5RgzZkyUlJQUuo2iNnbs2EK3AI3i+Tj1YyYfKZmLWX+uQWpqauLaa69NlldRURGDBw9e65997Wtfi4033jjJOn//+99j4cKFjc7x7DEAAAAAAAAAAACAhistdAMAAAAAAAAAAAAA/H/s3Xl4VuW1P+6VhCkBB6pIVVRAURTrPCuoxVYRFERFnGlJtdraqq1aj9oev6d6bI+znmq1NSmioCJaHBGqdaqKIAIio6BFARlkhhAS8vujPz1aURPY+91J3vu+Lq5aePNZKxuf/Wz3Betp/P75z3/GsmXLUsk+6qijUskl4pxzzonTTz896za+0YoVK2L8+PExceLErFsBqJNVq1Ylnrntttsmnrkxtt9++6xbAAAAAAAAAAAAAAAAAAAAAAAAADbB+vXrY+XKlfHee+/FK6+8Eg8//HDcdtttccEFF8QRRxwRW265Zey0005x1llnRVlZWfzzn//MuuW8tXbt2kTzmjdvnmjepmjRokXimZWVlYlnNlZr1qzJuoW89cEHH8Qpp5wShx12WDz55JNZt5OYM844Iw488MBUsl2zhiPpfSvC3kX2GspM9whz3flmDz/8cOLPgb169Yri4uIv/Fzfvn2jqKgosRrl5eWJZeHZqrErLCzMuoWvZV+lIdpzzz1j8ODBUVBQkFqNZcuWxQknnJDaGVAby5olX3ifUXfeZwAAAAAAAAAAAAAAAAAAAAAAAOSHgoKCGDBgQNZt1Hu77rprHH744Vm3Ue/V99mp+cz5OHVjJh9JMhez7qxBIiLKysoSzTv55JM3+PP9+vVLrEZSPTt7DAAAAAAAAAAAAGDjNcm6AQAAAAAAAAAAAADyw8SJE6Nr166J555yyilx9913J56b77bYYou46aabsm7jM0uWLIkZM2bEzJkzY+bMmZ/983vvvRcLFy6MiIjzzjsv/vjHP2bcKUDtrVy5MvHMrbfeOlq1apVKdl3ssssumdYHAAAAAAAAAAAAAAAAAAAAAACAfHL++efH448/vsk569evjzVr1kRFRUVUV1dvemPkxNq1axPNKy4uTjRvU6TRS0VFReKZjdWaNWuybiHvvfbaa3HCCSdE586dY+DAgXH22WdH27Zts25roxUUFMRVV10Vffr0Sa2Ga1b/Jb1vRdi7yFZ9m+keYa47m2bFihXx2GOPxRlnnJFYZsuWLaNHjx4xfPjwz36uX79+ieUvWrQonn766cTy+D+erRqn+vTs9O/sqzRE3/rWt2LEiBHRqlWr1GqsX78++vfvH9OnT0+txsawZskn3mfUnfcZAAAAAAAAAAAAAAAAAAAAAAAA+eH73/9+tGvXLus2GoQf/ehH8eqrr2bdRr1Wn+a08UXOx6kbM/lIkrmYdWcNEhExZsyYmDp1anTu3DmRvF69ekWzZs2isrLys58rKCiIvn37JpK/cOHCeOqppxLJcvYYAAAAAAAAAAAAwMZrknUDAAAAAAAAAAAAAOSHiRMnRteuXRPPPeqoo2LrrbeORYsWJZ6dz66++urYeuutc1pz4cKFMX369Jg5c+aXfixdujSnvQDkwtKlS6OqqiqaNEnur3cUFBTEnnvuGa+//npimRtj3333zbQ+AAAAAAAAAAAAAAAAAAAAAAAA5JOlS5fGggULsm6DjCxevDjRvDZt2iSatym22WabxDOTvl6NWUVFReKZjz/+eLz88suJ52apsrIy9RpTp06Nyy67LK644oo49NBD48QTT4zvf//7sddee0VhYWHq9ZN0wgknRIcOHWL27Nmp1nHN6q807sP2LrKUxUz3CHPdSVd5eXmcccYZiWb269cvhg8fHhERW2+9dRx11FGJZT/wwANRVVWVWB5f5tkqPQUFBTmtV1JSkvOadWFfpaEpKiqKYcOGRYcOHVKtc/nll8ezzz6bao2NYc2ST7zPqDvvMwAAAAAAAAAAAAAAAAAAAAAAAPJDaWlp1i00GKeeempcdNFFsWLFiqxbqRWzU/k85+PUjZl8JMlczLqzBvlUWVlZ/O53v0ska7PNNotjjjkmnn766c9+7vDDD49tt902kfwkz11w9ljt5OLsMQAAAAAAAAAAAKDhaZJ1AwAAAAAAAAAAAADkhzFjxsRPfvKTxHOLiori9NNPjzvuuCPx7Hy12Wabxfnnn59qjcWLF8eLL74Y//jHP2LcuHExadIkw5aBvFNdXR2zZ8+OTp06JZp70EEHxeuvv55oZl0dccQRmdYHAAAAAAAAAAAAAAAAAAAAAAAAyBeLFi1KNG/bbbdNNG9TfPvb3048M+nr1ZgtXbo08cxx48bFzTffnHhuvli/fn28+uqr8eqrr8YVV1wRm222WRxyyCGx1157xV577RVdunSJnXfeObbccsusW/1KhYWFccYZZ8R1112Xk3quWf2Txn3Y3kVWcjHTPcJcd3Jv9OjR8dFHH8X222+fWGavXr2iuLg41qxZE3379o2ioqLEssvLyxPL4ut5tkpecXFxTuttttlmOa1XF/ZVGqLbb789jj766FRrDB48OG666aZUa2wMa5Z8431G3XmfAQAAAAAAAAAAAAAAAAAAAAAA0PhttdVWceKJJ2bdRoNRUlIS/fv3j3vvvTfrVmrF7FQ+z/k4dWMmH0kyF7PurEE+df/998f111+f2PkIJ598cjz99NOf/f9+/folkhsRUVZWlliWs8cAAAAAAAAAAAAANl6TrBsAAAAAAAAAAAAAID+MGjUqteyLL7447rzzzqipqUmtRj4599xzUxmmv2TJkrj//vtj6NCh8frrryf++1VYWJhoHkAuTJ8+PTp16pRo5jHHHBO33357opl10bJlyzjssMMyqw8AAAAAAAAAAAAAAAAAAAAAAACQT5YuXRqVlZXRrFmzRPJKSkqibdu28fHHHyeSt7E222yzaNOmTaKZNTU1sXDhwkQzG7P58+dHdXV1FBUVJZa57bbbJpZFxIoVK2LUqFFfmv/cunXr6NixY+y8885f+NGxY8do165d5rN8TznllLjuuusyqe2aZS/pfSvC3kV20prpHmGuO9mqqamJwYMHxxVXXJFYZsuWLaNHjx4xfPjw6NevX2K5kyZNirfffjuxPOrGs9WmS2sf+SodOnTIab26sK/S0Jx33nlx4YUXplpjzJgxUVpammqNjWXNkm+8z6gb7zMAAAAAAAAAAAAAAAAAAAAAAADyw1lnnZXojK58UFpaGvfee2/WbdSK2al8nvNxas9MPpJmLmbdWIN83rx58+K5556LHj16JJLXu3fvOO+886K6ujoiIk4++eREcidMmBATJ05MJCvC2WMAAAAAAAAAAAAAm6JJ1g0AAAAAAAAAAAAAkB/mzZsXkydPji5duiSe3bFjxzjppJNi+PDhiWfno/79+yeaV1lZGb/97W/j5ptvjlWrViWa/XnFxcWpZQOkZfr06dGzZ89EM4855pho2bJlqvfcr3PyySc74AcAAAAAAAAAAAAAAAAAAAAAAAAgh2bPnh277bZbYnldunSJjz/+OLG8je0haR9++GGsW7cu8dzGav369TFv3rxo165dYpkdO3ZMLIuvtmTJkhg3blyMGzfuS7/WrFmzaN++fXTs2DF23nnn2GWXXb7wz82bN0+9v3322Sdat24dS5YsSb1WbblmuZX0vhVh7yIbSc90jzDXnfqjvLw8rrjiikQz+/XrFy+99FIcddRRiWWWlZUllkVyPFvV3mabbZbTep06dcppvbqwr9KQHHHEEXHnnXemWmPu3LnRp0+fWLt2bap1NpY1Sz7yPqP2vM8AAAAAAAAAAAAAAAAAAAAAAADID6WlpVm30OAcdNBB0aVLl5g8eXLWrXwjs1P5d87HqR0z+UiDuZi1Zw3y78rKyqJHjx6JZG211VbRrVu3eOGFF+Kwww6L7bbbLpHc++67L5GcTzl7DAAAAAAAAAAAAGDjNcm6AQAAAAAAAAAAAADyx3PPPZfKoN6IiOuuuy5GjBgRVVVVqeTni2222SYOO+ywxPJWrlwZffr0ib/97W+JZX6VLbfcMvUaAEmbOnVq4pnFxcVx8sknx6BBgxLPro3zzjsvk7oAAAAAAAAAAAAAAAAAAAAAAAAA+eq9996L3XbbLbG8gw46KJ5//vnE8jbGgQcemHjmzJkzE89s7D788MNo165dYnmdO3dOLIuNU1lZGdOnT4/p06d/6deaNGkSu+++e3z/+9+Ps846K/bZZ5/U+jjooINi5MiRqeUnyTVLXtL7VoS9i9xLeqZ7hLnu1C9Tp06NN998M9F7W69eveL111+PoqKiRPKqqqrigQceSCSL3GnIz1Zr165NvI8mTZpEq1atYuXKlYlnb8h3vvOdnNSpK/sqDcmOO+4Yw4cPj6ZNm6ZWo6KiIvr06RPz5s1LrcamsGbJV95n1J73GQAAAAAAAAAAAAAAAAAAAAAAAI3fgQceGHvuuWfWbTRIpaWlcckllySaaXYqueB8nNoxk480mItZe9Yg/+6vf/1rLFmyJFq3bp1I3sknnxwvvPBCnHrqqYnkrVu3LpVzF5w9BgAAAAAAAAAAALBxCrNuAAAAAAAAAAAAAID8MXLkyNSyO3fuHD/72c9Sy88Xhx9+eBQUFCSW94tf/CL+9re/JZb3dXbYYYec1AFI0qRJk1LJvfTSS1PJ/SZdu3aNww8/PJPaAAAAAAAAAAAAAAAAAAAAAAAAAPlq6tSpieZ179490bz60sO0adMSz2zs3n///UTz2rdvH1tttVWimSSnqqoqJk2aFDfddFPsu+++ccIJJ8T8+fNTqbX33nunkptrrtnGSXrfirB3kXtJz3SPMNed+qe8vDzRvJYtW8a1116bWN6zzz4bCxYsSCyP7NX3Z6uKiooUOonYY489UsndkPrwzLQh9lUaipKSkhgxYkS0adMm1To/+tGP4s0330y1xqawZhufpH8/GyvvM2rP+wwAAAAAAAAAAAAAAAAAAAAAAIDGb+DAgVm30GCdffbZ0bRp00QzzU5tvOrTzEDn49SOmXykwVzM2mtoa7A+3ecbq8rKyhg6dGhieSeddFIUFhbGKaeckkjek08+GYsXL04k6/OcPQYAAAAAAAAAAACwcQqzbgAAAAAAAAAAAACA/PHiiy/G8uXLU8u/9tprY9ddd00tPx8ccsghiWXNmjUr7r333sTyvkkuDxsASMqYMWNixYoViefuvffe0adPn8Rzv8nvf//7nNcEAAAAAAAAAAAAAAAAAAAAAAAAyHdjx45NNK9r166xxRZbJJpZF8XFxdG9e/fEc998883EMxu7t956K/HMww8/PPFM0vHkk0/G/vvvH//85z8Tz27fvn3imfWBa1Y7Se9bEfYuci/Jme4R5rpTPw0ZMiQqKysTzdx8880TyyovL08si/qpvj1bVVRUJN5HRMSee+6ZSu6/23rrrWPffffNSa26sq/SUPzlL3+JvffeO9UaN954YwwePDjVGpvKms1WTU1N4pmbbbZZ4pmNkfcZted9BgAAAAAAAAAAAAAAAAAAAAAAQONWXFwcp59+etZtNFhbbbVV9O7dO9FMs1Prh8Y+M9D5OLVjJh9pMBez9tJcg439Pt+Y3XfffYllbbfddvHzn/882rVrl0heWVlZIjn/ztljAAAAAAAAAAAAABunMOsGAAAAAAAAAAAAAMgfFRUV8dBDD6WW36pVqxg+fHiUlJSkVqOx69y5c2JZf/3rX1MZdLwhTZs2jb333jsntQCSVF1dHS+++GIq2bfeemsUFxenkr0hF1xwQRxyyCE5qwcAAAAAAAAAAAAAAAAAAAAAAADAv4wdOzbRvObNm0e/fv0SzayLk046KVq1apV47rhx4xLPbOzeeuutxDN79uyZeCbpmTt3bpx99tmJ57Zr1y7xzPrCNftmSe9bEfYuci/Jme4R5rpTPy1ZsiSefPLJrNvYoE8++SSeeOKJrNsgB+rTs9WqVatSuVfvs88+iWduyNlnnx0FBQU5qVVX9lUagmuuuSZOOeWUVGs888wzcfnll6daIwnWbLbWrl2beGbr1q0Tz2yMvM+oPe8zAAAAAAAAAAAAAAAAAAAAAAAAGrdTTjklNt9886zbaNBKS0sTzTM7tX5o7DMDnY9TO2bykQZzMWsvzTXY2O/zjdnYsWPj3XffTSzvuuuuSyRnwYIF8fTTTyeS9e+cPQYAAAAAAAAAAACwcQqzbgAAAAAAAAAAAACA/PLnP/851fwuXbrEgw8+GE2aNEm1TmPVvn37xLLSGBr7VY466qho0aJFzuoBJGnUqFGp5O60005x9913p5L97/baa6+4+eabc1ILAAAAAAAAAAAAAAAAAAAAAAAAgC+aMWNGzJ8/P9HMiy++OAoKChLNrK1LL7008cylS5fGpEmTEs9t7MaPH594Zu/evaOoqCjxXNLz0ksvJf7vQqtWrRLNq29cs6+Xxr4VYe8it5Kc6R5hrjv1V3l5edYtbNDQoUOjsrIy6zbIkfrybFVVVRWLFi1KtI+IiF69eiWe+e8KCgrioosuSr3OxrKvUt/16dMnrr322lRrTJs2Lfr37x81NTWp1kmCNZutioqKxDPbtWuXeGZj5H1G7XifAQAAAAAAAAAAAAAAAAAAAAAA0PiVlpZm3UKD973vfS922GGHxPLMTq0fGvvMQOfjfDMz+UiLuZi1k/YabOz3+caurKwssazi4uJEcgYPHhzV1dWJZP07Z48BAAAAAAAAAAAAbJzCrBsAAAAAAAAAAAAAIL+88cYbMWXKlFRr9O7dO4YNGxZNmjRJtU5jtO222yaWtXDhwsSyvsnpp5+es1oASRs9enRq2eecc05ccsklqeVH/GsA/RNPPBEtWrRItQ4AAAAAAAAAAAAAAAAAAAAAAAAAXy3p2XZ77LFHnHbaaYlm1saJJ54Y+++/f+K5o0ePjvXr1yee29h98sknMXPmzEQz27ZtGyeeeGKimY1Zly5dYvDgwdGmTZtM+3jppZcSzSspKUk07/Ncs4YhjZms9i5yKcmZ7hHmulN/Pf3007FgwYKs2/iSsrKyrFvIG56tvmju3LmJ9hER0aFDh1SeJT7v3HPPjQ4dOqRaY1PYV6nP9txzz7j//vujoKAgtRpLly6NE044IZYvX55ajSRZs9mqqKhIPHP//feP5s2bJ57bGHmf8c28zwAAAAAAAAAAAAAAAAAAAAAAAGjcdt555+jWrVvWbTR4hYWFMWDAgEQzzU7NXj7MDHQ+ztczk480mYv5zdJeg/lwn2/MBg8eHNXV1Vm38QXl5eWpZTt7DAAAAAAAAAAAAGDjFGbdAAAAAAAAAAAAAAD557777ku9Ru/eveP555+PbbfdNvVajUlJSUliWc2aNUss6+tstdVW0b9//5zUAkjDu+++G9OmTUst/+abb46f//znqWR37NgxXnjhhdhxxx1TyQcAAAAAAAAAAAAAAAAAAAAAAACgdp555pnEM2+99dZo3bp14rlfpVWrVnHnnXemkp3G9ckXTz/9dOKZV155ZeKZdXXqqadGx44ds27jK+2+++7x0EMPxaRJk+LMM8+M//qv/8q0n3nz5iWaV1RUlGhehGvW0KR1X7Z3kStJznSPMNed+qu6ujoefPDBrNv4gilTpsTYsWOzbqPR82y1YR999FGifXxqwIABqeRGRGy55Zbx+9//PrX8JNhXqa+22mqrGDFiRLRq1Sq1GtXV1dG/f/+YMWNGajWSZs1ma+HChYlnNmvWLLp165Z4bmPkfcY38z4DAAAAAAAAAAAAAAAAAAAAAACgcRs4cGDWLTQaAwcOjIKCgsTyzE7NXj7MDHQ+ztczk480mYv5zdJeg/lwn2/M5s+fHyNHjsy6jc+89dZbMWnSpFRrOHsMAAAAAAAAAAAAoO4Ks24AAAAAAAAAAAAAgPxzzz33xNKlS1Ov07Vr13j77bejZ8+eqddqLIqLixPL2n777RPL+jq//vWvE+0bIAt//OMfU82/9dZb45577omSkpLEMo899th4/fXXY5dddkksEwAAAAAAAAAAAAAAAAAAAAAAAICNM2LEiFizZk2imW3bto0hQ4ZEUVFRorkbUlBQEIMGDYoddtgh8ex169bFY489lnhuvnjqqacSzzzwwAPjlFNOSTy3tvbee+8YPHhwTJo0KS666KLM+tiQ3XbbLYYMGRLvvPNO9OvXLwoKCiIiorS0NI444ojM+mratGmiedXV1YlluWYNUxr7VoS9i9xJeja6ue7UZ+Xl5Vm38AVlZWVZt9Coebb6elOmTEm0j0+dd9550bFjx1Sy//SnP0WbNm1SyU6KfZX6qKioKIYNGxYdOnRItc7ll18eI0eOTLVG0qzZbM2bNy+V3F/84hep5DY23md8Pe8zAAAAAAAAAAAAAAAAAAAAAAAAGrfCwsI499xzE89dvnx5TJ06td7+WLJkSeLfc0TETjvtFN27d08sz+zU7OXDzEDn43w1M/lIm7mYXy8XazAf7vON3X333Zd1C5/JRS/OHgMAAAAAAAAAAACou8KsGwAAAAAAAAAAAAAg/yxfvjxuvPHGnNTaZptt4sknn4ynn346dtttt5zUrI299947fvKTn2TdxpesW7cusawkDyf4KgcddFC9vI4AdVVeXh5r165NtcaPfvSjmDx5cpx++ulRUFCw0Tnt2rWLsrKyePbZZxvVISwAAAAAAAAAAAAAAAAAAAAAAAAADdnKlSvjqaeeSjz32GOPjfLy8igqKko8+1MFBQVx9913x0knnZRK/siRI2PJkiWpZOeDv//977Fq1arEc++8887YeuutE8/9Jttss0088sgj0axZsygpKYnbb789Xnrppdh5551z3svnderUKQYPHhzvvvtu9O/fPwoLC7/w60VFRTFs2LDYbrvtMumvY8eOieatXLlykzNcs4YtrX0rwt5FbiQ50z3CXHfqtwkTJsTEiROzbiMiItavXx+DBw/Ouo1GybNV7UyYMCHRPj7VrFmz+P3vf5947q9+9as4+eSTE89Nmn2V+uj222+Po446KtUagwYNiptvvjnVGmmwZrM1d+7cVHKPPfbY6NmzZyrZjYn3GV/P+wwAAAAAAAAAAAAAAAAAAAAAAIDGrUePHqnMJ73yyitj9913r7c/LrroosS/50+VlpYmlmV2avbyYWag83G+mpl8pM1czK+XizWYD/f5xu6JJ56ITz75JOs2orKyMoYMGZJ6HWePAQAAAAAAAAAAANRdYdYNAAAAAAAAAAAAAJCfbrvttli8eHHO6vXo0SPefffdGDFiRBxzzDE5q/t5HTt2jMsuuyzGjh0bb7/9dvTr1y+TPr7O6tWrE8vq2bNnqoNdt9lmm3jooYdSHTYNkCtLliyJYcOGpV6nffv28eCDD8Z7770X1157bey///5RWPjNf72kZcuW0bNnzxgyZEjMnDkzBgwYkHqvAAAAAAAAAAAAAAAAAAAAAAAAANTNH//4x1RyzzrrrBgxYkRsueWWiWe3atUqhg0bFuedd17i2Z9K67rki8rKyhg+fHjiuW3bto1HH300mjZtmnj2V/nWt74Vo0aNik6dOn3h57t27RoTJ06Mn/3sZ1FQUJCzfiIidt555xg0aFBMmTIlzjzzzK+dE9m2bdsYNWpUtGvXLocdRjRv3jx69eqVaObKlSs3+mtds8YjzfuzvYu0JTnTPcJcd+q/8vLyrFuIiIhRo0bFvHnzsm6jUfFsVTcTJ05MtI/PO/nkk+NHP/pRYnlXXHFF/Pd//3dieWmyr1LfnHfeeXHhhRemWuONN95IdM3nkjWbrU8++SQWLVqUSvaQIUNiv/32SyW7MfE+46t5nwEAAAAAAAAAAAAAAAAAAAAAANC4DRw4MPHMqqqqePjhhxPPTdLjjz+e+Cy+T/Xp0ydat26dSJbZqdnLl5mBzsfZMDP5yAVzMb9aLtZgvtznG7PKysoYMmRI1m3EE088EZ988knqdZw9BgAAAAAAAAAAAFB3hVk3AAAAAAAAAAAAAEB+WrlyZfzud7/Lac3CwsI44YQTYtSoUTFnzpz4wx/+EMcdd1y0atUq8VpFRUXxne98J37wgx/EvffeG7NmzYr33nsvfv/738f++++feL2kLF++PLGs4uLiuP322xPL+7ytt946nn322Wjfvn0q+QBZSOueuSEdOnSIX//61zF27NhYtmxZvPXWWzF8+PD4y1/+EnfffXfcfffdMWjQoBgxYkS8++67sXTp0njyySejf//+0bx585z1CQAAAAAAAAAAAAAAAAAAAAAAAEDtjR49OqZMmZJK9vHHHx9vv/12fP/7308s88gjj4zx48dH3759E8v8d7NmzYqnnnoqtfx8cffdd6eS261bt/jrX/8aLVq0SCX/8/bZZ58YO3Zs7LXXXhv89ZKSkrjtttvipZdeil122SX1fjp06BBlZWUxbdq0OPvss6OoqKhWX7fHHnvE66+/HgcddFDKHf6f//zP/4w2bdokmrlw4cI6f41rVvdrVt+luW9F2LtIV5Iz3SPMdaf+e+CBB6KqqirrNqKsrCzrFhoNz1Yb92z1zjvvJL4HfN5dd90VpaWlm5Sx+eabx6BBg+KGG25IqKv02VepT7p27Rp33nlnqjXmzp0bffr0icrKylTrpMWazd7EiRNTyd1ss83i1VdfjZ/97Ge1fjbIR95nbJj3GQAAAAAAAAAAAAAAAAAAAAAAAI1bmzZtolevXonnjho1KhYtWpR4bpJWrVoVI0aMSCW7efPmcdZZZyWSZXZq/ZAPMwNHjx6dWraZfPD1zMXcsFyuwXy4zzd29eHMg1z24OwxAAAAAAAAAAAAgLppknUDAAAAAAAAAAAAAOSv22+/PUpLS2PXXXfNee127drFBRdcEBdccEHU1NTEjBkzYty4cTFjxoyYM2dOzJkzJxYtWhRr1qz57EdERHFxcZSUlHz2o2XLltG6deto3759dOjQIdq3bx/t27ePHXfcMZo2bZrz72tTffDBB7HTTjsllnf66afHe++9F9dcc01imXvttVcMGzYsOnXqlFgmQH0wZsyYGD58eKqD7jekVatWse+++8a+++6b07oAAAAAAAAAAAAAAAAAAAAAAAAAJO/GG2+MP//5z6lk77TTTjFy5Mh45pln4oYbboiXXnppo3IOPfTQuOKKK6J3794Jd/hlN954Y9TU1KRep7H7xz/+EZMnT44uXboknt2jR494/fXX47TTTotp06Ylnl9cXByXXXZZXHnlldGiRYtv/PwRRxwREydOjP/4j/+I2267LfF/f9q3bx/XXHNNnHPOOdGkSZONyth+++3jtddeiz/84Q9x9dVXx7JlyxLt8VOFhYVx9dVXx69+9avEs+vye+2a/Usa66M+SHPfirB3kZ6kZ7pHmOtO/bZgwYIYOXJk9OzZM7Meli1bFo8//nhm9RsLz1b/srHPVtXV1fHCCy+k9kxQVFQU9957b3Tv3j0uv/zymDNnTq2/tkmTJvHDH/4wfv3rX8f222+fSn9psa9SX+y4447x6KOPpn7m0PLly+Pee+9NtUZdnXXWWbW+n1uz2ZswYUJ897vfTSW7RYsWcdttt8Uvf/nLuOuuu2L06NExfvz4qKqqSqVeQ+V9xpd5nwEAAAAAAAAAAAAAAAAAAAAAANC4nXPOOanM6xs8eHDimWkYPHhw9O/fP5Xs0tLSuOOOOzY5x+zU+sHMwE1nJh98PXMxvyyXa9B9vuEbN25cvPPOO7HnnntmUv/jjz+OZ599Nmf1nD0GAAAAAAAAAAAAUDdNsm4AAAAAAAAAAAAAgPy1du3aGDBgQLzyyitRWFiYWR8FBQWx6667xq677ppZD/XF+++/H926dUs08+qrr46OHTvGxRdfHAsXLtzonJYtW8avfvWruOyyy6J58+YJdghQf1xxxRVxwgknpHJoDgAAAAAAAAAAAAAAAAAAAAAAAACNX3l5eVxxxRWpzlrt0aNH9OjRI2bPnh2PP/54vPzyyzFx4sT44IMPoqqq6gufLSoqih133DG+853vRNeuXaN3797RqVOn1Hr7vPfffz/+9Kc/5aRWPrjtttvinnvuSSV77733jokTJ8Ydd9wRN954Y8yfP3+TM9u0aRMDBgyIn/3sZ9GuXbs6fW1xcXHccsstceqpp8aAAQNixowZm9zPjjvuGFdffXUMGDAgkbmThYWF8dOf/jR++MMfxpAhQ+JPf/pTjBkzJtavX7/J2c2aNYuTTz45Lrvssth33303OW9Dpk+f/o2fcc2+qDbXrCHKxb4VYe8ieWnMdI8w1536rby8PHr27JlZ/YceeijWrl2bWf2GzrPVF23Ks9Vzzz0XvXv3TrCbL+vfv3/07ds3nnzyyfjrX/8ar732WsyePftLzy1bb711HHDAAdGjR4/o379/bLPNNqn2lRb7KvVBSUlJjBgxItq0aZN6rc6dO0fnzp1Tr1MXdfl325rN3gsvvBCXXHJJqjV22GGHuP766+P666+PysrKWLhwYSxZsiQqKirqnHX99dfHY489lkKX2fE+44u8zwAAAAAAAAAAAAAAAAAAAAAAAGj8Bg4cmHjm6tWr4/HHH088Nw0jR46MxYsXx1ZbbZV49l577RX7779/jBs3bpOzzE7NXr7MDJw+fbqZfP8/M/nINXMxvyjXazBf7vONXVlZWdx0002Z1L7//vujuro6pzWdPQYAAAAAAAAAAABQe02ybgAAAAAAAAAAAACA/Pbaa6/FrbfeGpdeemnWrRAREyZMSCX3jDPOiB49esTdd98d9913X8ycObPWX3vwwQfHaaedFj/4wQ9iyy23TKU/gPpi5syZcdddd8XPfvazrFsBAAAAAAAAAAAAAAAAAAAAAAAAoAFav359/Md//EcMGzYs9VodOnSISy65JC655JKIiKipqYlVq1bF6tWrIyKipKQkSkpKorCwMPVeNuSqq66KdevWZVK7Mbrvvvvi8ssvj1122SWV/GbNmsUvfvGLuOiii+KZZ56Jxx57LF599dVaz7LdYostYvfdd49u3bpF9+7d4+ijj46mTZtuUk+HHXZYTJgwIa6++uq45ZZboqamZqNyjj322HjiiSc2uZ8NKSkpiYEDB8bAgQNj+fLl8fLLL8eYMWNi1qxZMWvWrJg7d+5n63L16tWffQ/NmzePFi1aRElJSWy33Xax0047xW677RZdu3aNww47LLbYYovEe/1UTU1NvPbaa1/7Gdfsi2pzzRqqXO5bEfYukpPWTPcIc92pv0aMGBFLliyJ1q1bZ1K/vLw8k7qNgWerL9rUZ6vHH3887rjjjtSfF5o1axZ9+/aNvn37RsS/nptWrlwZa9asicLCwthyyy1T+T3Ngn2V+qBXr16x9957Z91Gg2DNZu+FF16IqqqqaNKkSU7qNWvWLLbffvvYfvvtN+rr27Rpk3BH2fM+44u8zwAAAAAAAAAAAAAAAAAAAAAAAGjcDjnkkNh9990Tz/3rX//62Uyt+q6qqioeeeSR+PGPf5xKfmlpaYwbN26Tc8xOzV6+zAw0k+//mMlHrpmL+UW5XoP5cp9v7AYPHhy/+93vcvb7+HlZnLvg7LGNP3sMAAAAAAAAAAAAyD+5/xOmAAAAAAAAAAAAAPBvrrrqqujZs2fstttuWbeS91577bXUslu3bh1XXnllXHnllfH+++/HuHHjYsaMGbFkyZJYvnx51NTURPPmzWOzzTaLdu3aRadOneKAAw6ILbbYIrWeAOqja6+9Nvr37x/bbLNN1q0AAAAAAAAAAAAAAAAAAAAAAAAA0AA9+uijMXLkyDj22GNzWregoCBatWoVrVq1ymndDfn73/8eDz74YNZtNCrV1dVxzTXXxJAhQ1Kt06xZs+jdu3f07t07IiJWrVoV//znP2PhwoWxZs2aWLdu3Wefa9WqVbRs2TLatWsXW221VSr9FBcXx0033RSnnHJKDBgwIKZPn17njNdeey3Wrl0bTZs2TaHD/7P55ptHz549o2fPnqnW2VTvvPNOLFy48Gs/45p9UW2uWUOW1b4VYe9i46U50z3CXHfqp8rKynjooYfixz/+cc5rz5gxI/V115h5tvqiTX22mjt3bowaNSrnzy6FhYWx+eabx+abb57TurlgX4WGxZrN3sqVK+Pll1+Oo48+OutW8pr3Gf/ifQYAAAAAAAAAAAAAAAAAAAAAAEDjV1pamkru4MGDU8lNy+DBg1Obz3v66afHJZdcEhUVFZuUY3Zq9vJlZqCZfP9iJh9ZsQb/JYs1mC/3+cZuwYIF8eyzz0avXr1yWnfs2LExefLknNaMcPbYppw9BgAAAAAAAAAAAOSfJlk3AAAAAAAAAAAAAAAVFRXRp0+feO2112LLLbfMup28Nm7cuFi5cmXqQ5nbt28f7du3T7UGQEP1ySefxJlnnhnPPfdcFBQUZN0OAAAAAAAAAAAAAAAAAAAAAAAAAA3QhRdeGBMnToyWLVtm3UrOVVRUxI9//OOs22iUhg4dGpdeemkceOCBOavZsmXL2H333WP33XfPWc0NOfTQQ2PChAlx9dVXx8033xw1NTW1/trly5fHPffcE5deemmKHTYcTz311Dd+xjX7otpcs4Yun/etCHtXQ5Srme4R5rpTv5SXl2dyvyovL895zcbEs9UXJfFsdd9998Wxxx6bQDdE2FehobFm64eysrI4+uijs24j73mf4X0GAAAAAAAAAAAAAAAAAAAAAABAY9eyZcs47bTTEs9dtGhRPPfcc4nnpunVV1+NDz74IHbaaafEs7fYYos45ZRTYvDgwZucZXZq9vJlZqCZfGbykS1rMLs1mC/3+caurKwsevXqldOa9913X07rfZ6zxzbu7DEAAAAAAAAAAAAg/xRm3QAAAAAAAAAAAAAARERMnTo1+vbtG+vWrcu6lbxWWVkZTzzxRNZtAOS90aNHx3//939n3QYAAAAAAAAAAAAAAAAAAAAAAAAADdSsWbPi5z//edZtZOKXv/xlTJs2Les2Gq1zzz03Kioqsm4jEy1atIgbb7wxbrzxxjp/7XXXXRfLli1LoauGpaamJv785z/X6rOu2b/U5Zo1ZPm8b0XYuxoiM93JV2+88UbO71c1NTVx//3357RmY+TZ6l+SerZ69NFHY9asWQl0RIR9FRoaa7Z+GDZsWKxYsSLrNvKe9xneZwAAAAAAAAAAAAAAAAAAAAAAADR2/fr1i1atWiWe+/DDD0dVVVXiuWl78MEHU8suLS1NJMfs1Ozly8xAM/nM5CNb1mB2azBf7vON3RNPPBGLFy/OWb21a9fG0KFDc1ZvQ5w9tnFnjwEAAAAAAAAAAAD5pTDrBgAAAAAAAAAAAADgUy+88EKcd955WbeR99I8pACA2rvmmmvilVdeyboNAAAAAAAAAAAAAAAAAAAAAAAAABqoP//5z/Hwww9n3UZOjRgxIv73f/836zYatSlTpsRVV12VdRuZWbFiRdx66611/rpPPvkkrr322uQbamCef/75mDlzZq0+65r9S12uWUOXj/tWhL2rITPTnXxVXl6e03rPP/98zJkzJ6c1GyPPVv+S1LNVdXV1/Pa3v02gIz5lX4WGxZrN3po1a/y3ZD3hfQYAAAAAAAAAAAAAAAAAAAAAAACN2cCBA1PJfeCBB1LJTVuafR955JGxyy67bHKO2anZy6eZgWbyQbaswWzk032+MVu3bl1OZy2PGDEilixZkrN6G+LssY07ewwAAAAAAAAAAADIL4VZNwAAAAAAAAAAAAAAn1deXh6//OUvs24jrz311FMxffr0rNsAyHvr16+Pk046KSZPnpx1KwAAAAAAAAAAAAAAAAAAAAAAAAA0UAMGDIjx48dn3UZOTJ48Oc4888ys28gLt9xyS4waNSrrNjJx3nnnxZw5czbqa2+99db4xz/+kXBHDct//Md/1Onzrlndr1lDl0/7VoS9q6Ez0518df/998f69etzVq+8vDxntRo7z1bJPlsNGjQopk6dmlhevrOvQsNizdYP//M//xMrVqzIug3C+wwAAAAAAAAAAAAAAAAAAAAAAAAap1133TUOP/zwxHPff//9BjsndfLkyTFx4sTU8gcOHJhIjtmp2cunmYFm8kG2rMFs5NN9vjErKyvLWa377rsvZ7W+jrPHNu7sMQAAAAAAAAAAACB/FGbdAAAAAAAAAAAAAAD8u5tuuinOPffcqKqqyrqVBmX8+PFxwQUXbHJOTU1N/O53v0ugo2ysXLky3n333azbAEjEokWL4uijj44pU6Zk3Uqt1dTU5HQoOgAAAAAAAAAAAAAAAAAAAAAAAABfbc2aNXHCCSfEP//5z6xbSdXcuXOjV69esXLlyqxbyQs1NTVxyimnxDvvvJN1Kzl1yy23xNChQzf662tqauLss8+OpUuXJtdUAzJ06NAYM2ZMnb7GNav7NWvo8mXfirB3NQYNfaZ7hLnubJyPPvoonn/++ZzUWrlyZQwfPjwntfKBZ6tkn62qq6ujtLQ0ampqEsvMpVmzZmXdwhfYV6FhsWbrh08++SSuvfbarNsgvM8AAAAAAAAAAAAAAAAAAAAAAACgcSotLU0l98EHH0wlN1cGDx6cWva5554bhYWFm5xjdmr28mlmoJl8kC1rMBv5dJ9vzMaPHx8TJ05Mvc68efPiueeeS71ObTh7DAAAAAAAAAAAAODrbfrf7AEAAAAAAAAAAACAFAwaNChOPPHEWL16ddat1Hvr16+PG264IQ466KCYOnVqIpllZWUxduzYRLJy7bzzzmsUBwAAfGrhwoVx9NFHx7Rp07JupVZ+/vOfR3l5edZtAAAAAAAAAAAAAAAAAAAAAAAAAPD/++ijj+K73/1u1m2kZtGiRdG9e/d4//33s24lryxfvjyOP/74mDdvXtat5MTQoUPjF7/4xSbnzJo1K/r16xfV1dUJdNVwfPTRR/HTn/50o77WNcs/n+5b8+fPz7qV1Ni7Go+GPNM9wlx3Nl6u5lA/8sgjzqxImGerZL366qtx1113JZ6btlmzZsUll1ySdRtfYl+FhsWarR9uvvnmeP3117Nug/A+AwAAAAAAAAAAAAAAAAAAAAAAgMalqKgozjnnnFSyBw8enEpurgwZMiRqampSyd52223j+OOPTyTL7NTs5dPMQDP5IFvWYDby6T7fmJWVlaVe4/7774/169enXqe2nD0GAAAAAAAAAAAA8NUKs24AAAAAAAAAAAAAAL7KM888E926dYuZM2dm3Uq9NXv27DjqqKPiyiuvjKqqqsRya2pq4vzzz49169YllpkL99xzTwwZMiTrNgAS9/HHH8fhhx8ezz33XNatfKX169fHxRdfHHfccUfWrQAAAAAAAAAAAAAAAAAAAAAAAADwb9577714//33s24jcR9++GEceeSRMXXq1KxbyUtz5syJ7373u/Hhhx9m3UqqHn744Tj77LOjpqYmkbxRo0ZFaWlpYnn13bp16+L000+PxYsXb3SGa5Z/3nvvvejWrZu9i3qvoc50jzDXnU0zfPjwWLFiRep1ysrKUq+RjzxbJeuSSy6JMWPGpJKdhsrKyujXr18sXbo061a+xL4KDYs1Wz/U1NTEmWeemdfvEOoT7zMAAAAAAAAAAAAAAAAAAAAAAABoLHr27Blt27ZNPHfChAkxZcqUxHNz6cMPP4yXX345tfzS0tLEssxOzVa+zQw0kw+yZQ3mXr7d5xurBx54IKqqqlKtUV5enmr+xnD2GAAAAAAAAAAAAMCGFWbdAAAAAAAAAAAAAAB8nXHjxsXee+8d9957b9at1CvLly+Pyy+/PDp37pzaYQJvvfVWXHzxxalkp2H48OFx4YUXZt0GQGoWL14cxx13XFx99dWxfv36rNv5glWrVkWfPn3itttuy7oVAAAAAAAAAAAAAAAAAAAAAAAAAL7CoYceGuPHj8+6jcS88847ceihh8a7776bdSt5berUqXHYYYfFtGnTsm4lFX/4wx+if//+UVVVlWhueXl5DBw4MKqrqxPNrW+qq6vjjDPOSGSOsmuWf2bMmGHvokFoaDPdI8x1Z9OtWbMmhg0blmqN2bNn2w9T5NkqOZWVldGnT5+YO3duajWSsn79+jjnnHNi3LhxWbfyleyr0LBYs/XDrFmzonfv3rF27dqsWyG8zwAAAAAAAAAAAAAAAAAAAAAAAKBxKC0tTSV38ODBqeTmWprfR8+ePaNt27aJZJmdmr18mxloJh9kyxrMvXy7zzdGCxcujKeffjq1/DfeeCOmTJmSWv6mcPYYAAAAAAAAAAAAwJcVZt0AAAAAAAAAAAAAAHyT1atXx3nnnRe9e/eOhQsXZt1Opqqrq+Ouu+6KnXfeOf7nf/4nKisrU633hz/8Ie66665UayRh+PDh0a9fv6iurs66FYBU1dTUxHXXXRfdu3ePDz/8MOt2IiJi7NixcdBBB8UTTzzx2c8VFBQkXsc9HgAAAAAAAAAAAAAAAAAAAAAAAGDTzJ8/Pw477LD4y1/+knUrm2zIkCFx8MEH15vZfPluzpw5cfjhh8cLL7yQdSuJWbt2bZSWlsZPfvKTqKmpSaVGWVlZ9OzZM5YvX55KftbWrl0bZ599dgwbNiyxTNcs/9i7aCgaykz3CHPdSU55eXmq+YMGDUo1H89WSZo3b15079495s+fn3qtjVVTUxM/+MEP4qGHHsq6lW9kX4WGxZqtH1599dXo1atXrFixIutWCO8zAAAAAAAAAAAAAAAAAAAAAAAAaNi+/e1vx/HHH594bk1NTQwZMiTx3Cw88sgjUVlZmUp2kyZN4pxzzkksz+zU7OXbzEAz+SBb1mDu5dt9vjEqKytrkNlJcPYYAAAAAAAAAAAAwBcVZt0AAAAAAAAAAAAAANTWiBEjYuedd47rrrsuVq9enXU7OVVRURF/+tOfokuXLnHhhRfGokWLclb7wgsvjHvuuSdn9erqzjvvjNNOOy2qq6uzbgUgZ/7+97/HbrvtFjfccENUVFRk0sPq1avjV7/6VRx88MHx7rvvfuHXmjRpkni9NWvWJJ4JAAAAAAAAAAAAAAAAAAAAAAAAkG8qKipiwIABceaZZ8aSJUuybqfOli1bFj/4wQ/ijDPOyLsZtfXd4sWLo3v37nHllVdGVVVV1u1skvHjx8d+++0Xf/7zn1OvNXLkyDjwwANj7NixqdfKpXnz5sWRRx4ZQ4YMSTzbNcs/9i4aivo+0z3CXHeS9dJLL8Xs2bNTya6pqYm//OUvqWTzRZ6tkjN16tTo1q1bfPjhhzmrWVuVlZUxYMCAGDRoUNat1Jp9FRoWa7Z+GD16dHTr1i0++OCDrFshvM8AAAAAAAAAAAAAAAAAAAAAAACg4Tr33HOjqKgo8dwXX3wxPvroo8Rzs7B06dJ45plnUssvLS1NNM/s1Ozl28xAM/kgW9Zg7uXbfb6xefLJJ2PRokWJ565duzaGDh2aeG7SnD0GAAAAAAAAAAAA8H8Ks24AAAAAAAAAAAAAAOpixYoVcfXVV8fOO+8cd999d4MfMPpN5s+fH9dcc03ssMMO8aMf/SimTZuWSR/nn39+XHnllbF+/fpM6m/IihUrol+/fnHRRRc1+n8PADZk9erVceWVV0bHjh3jtttui5UrV+as7k033RTt27eP3/3udxvcG5o3b5543TVr1iSeCQAAAAAAAAAAAAAAAAAAAAAAAJCvHnzwwdhjjz1i6NChWbdSa8OGDYsuXbpEeXl51q3wFWpqauKGG26II444IiZMmJB1O3W2fPnyuPTSS+Oggw6Kd999N2d1p0+fHoccckhcc801jWL+4tChQ2OfffaJN954I7Uarll+snfRENTHme4R5rqTnvvvvz+V3Jdffjlmz56dSjZf5tkqOTNmzIgDDjggXnrppZzX/ioffvhhdO3aNQYNGpR1K3VmX4WGxZqtH95+++3o0qVL3HXXXVFTU5N1O4T3GQAAAAAAAAAAAAAAAAAAAAAAADQ8AwcOTCX3gQceSCU3K2l+P7vuumscfvjhiWaanZq9fJwZaCYfZMsazK18vM83FlVVVak82z3++OOxbNmyxHPT4OwxAAAAAAAAAAAAgH8pzLoBAAAAAAAAAAAAANgY8+fPjwsuuCB22WWXuP7662P+/PlZt5SYtWvXxogRI+L000+PHXfcMX7729/GokWLsm4rbrjhhujRo0fMmTMn61ZixIgRsffee8cjjzySdSsAmZs3b15cfPHFse2228YFF1wQL7/8cqxfvz7xOmPGjImf/vSnseOOO8Yvf/nLWLhw4Vd+tmXLlonXr6ioSDwTAAAAAAAAAAAAAAAAAAAAAAAAIJ/Nnz8/Tj/99DjssMPi1Vdfzbqdr/TGG29Et27d4tRTT42PPvoo63aohTfeeCP23Xff+OEPf9ggZgdXVFTErbfeGp06dYpbbrklqqqqct5DdXV1/Pa3v41dd901Bg8eHNXV1TnvYVNNmjQpevToEaeffnosWLAg9XquWX6yd9EQ1KeZ7hHmupOu8vLyVHLLyspSyeWrebZKzscffxzf/e5344Ybbsjkvy0+7/HHH4/99tsvxowZk2kfm8K+Cg2LNVs/rFq1Ki688MLYf//94/HHH4+ampqsW8p73mcAAAAAAAAAAAAAAAAAAAAAAADQUBxxxBHRqVOnxHMrKytj2LBhiedm6YknnogVK1akll9aWpp4ptmp2cvHmYFm8kG2rMHcysf7fGORxhkJ9913X+KZaXP2GAAAAAAAAAAAAJDvCrNuAAAAAAAAAAAAAAA2xQcffBBXXXVVtGvXLvr27RvPPfdcVFdXZ91Wna1bty6eeuqpOOecc2KbbbaJ3r17x9ChQ2PdunVZt/YFzz33XOyxxx6xdu3aTOpPmjQpjjnmmOjdu3fMnj07kx4A6quVK1fG3XffHd26dYvtttsuzjzzzLjnnnti/PjxUVFRUaesysrKmDp1apSVlcWAAQOiffv2cfDBB8f//u//xuLFi7/x67fZZpuN/Ta+0urVqxPPBAAAAAAAAAAAAAAAAAAAAAAAACDitddeiyOOOCKOOuqoGDlyZNTU1GTdUtTU1MTf/va3OOaYY+KQQw6Jl19+OeuWqKOampooKyuLXXbZJS666KKYMWNG1i19yQcffBBXX311dOjQIS655JJYsGBB1i3Fhx9+GGeffXbsuuuucffdd8fKlSuzbukbvfnmm9G3b9/Ya6+94tlnn815fdcsP9m7qO8+nel+6623mutOozZ79ux45ZVXEs1cvXp1DBs2LNFMas+zVTKqq6vjyiuvjH322SfxNVIbM2bMiGOPPTZOOumkWLhwYc7rJ82+Cg2LNVt/jB8/Pk466aT4zne+EzfddFPMmzcv65bynvcZAAAAAAAAAAAAAAAAAAAAAAAA1HelpaWp5D799NOxdOnSVLKzUlFREcOHD08tv1+/ftGqVavEc81OrR/ycWagmXyQLWswt/LxPt/QTZgwISZMmJBY3ty5c2P06NGJ5eWSs8cAAAAAAAAAAACAfFaYdQMAAAAAAAAAAAAAkITq6up47LHH4thjj402bdpE//79Y9CgQfV2QHx1dXWMGTMmfv/730ePHj3iW9/6VvTq1Svuv//+WL58edbtfa2VK1dGx44d4/bbb49ly5alXm/9+vXx5JNPxnHHHRd77bVX/O1vf0u9JkBD9/HHH8eDDz4Y559/fuy3335RUlIS7du3j0MPPTROOumkOPPMM6O0tDTOP//8GDhwYPTv3z969eoV3bp1ix133DFatGgRu+++e/zwhz+Mv/zlL/HBBx/Uqf52222X+Pc0d+7cxDMBAAAAAAAAAAAAAAAAAAAAAAAA+D8vvvhiHHfccbHLLrvEDTfcEO+//37Oe5gzZ07ceOONsdtuu8UxxxxjFmkjsGrVqrjzzjtj1113jeOOOy4effTRWLVqVWb9VFZWxqOPPhrHHntsdOjQIa677rqYP39+Zv18lVmzZsUFF1wQbdu2jXPPPTeee+65qKyszLqtz3z44Ydxyy23xHe+85046KCD4rHHHsu6JdcsT9m7qM9WrlwZl1xyibnuNHrl5eWJ5j366KOxcuXKRDOpO89WyZg8eXJ07do1jjnmmHj++edTrzd+/Pg455xzokuXLvHcc8+lXi+X7KvQsFiz9cvkyZPjl7/8ZWy//fbRtWvX+PWvfx1///vfY82aNVm3lre8zwAAAAAAAAAAAAAAAAAAAAAAAKA+atWqVZx66qmpZA8ePDiV3Kyl+X2VlJRE//79U8s3O7V+yMeZgWbyQbaswdzKx/t8Q1ZWVpZY1qBBg2L9+vWJ5WXB2WMAAAAAAAAAAABAPiqoqampqdUHCwrS7gUAAAAAAAAAAAAAUnHAAQfEwQcfHPvtt1/ss88+seeee0azZs1yVr+qqiqmTZsW77zzTkyaNCneeuuteOWVV2LFihU56yEtzZs3j969e8epp54a3bt3j9atWyeSu27dunjllVfimWeeiUceeSST4dIAbLyHH3448UOBBg4cGPfdd1+imQAAAAAAAAAAAADkl1qOZd8gs9oBAAAAAAAAAMhXBxxwQBx//PHxve99Lw4++OBo2rRpovlVVVXx5ptvxujRo+Opp56KN954I9F86qdmzZpF9+7do0+fPnHEEUdE586do7CwMJVaNTU18fbbb8fo0aNj1KhR8corr8SaNWtSqZW2Vq1axfe+97048sgj44gjjoh99tknioqKclL7448/jjfffDNeeumlePrpp2Py5Mk5qbupXLP8ZO+ivjLXHWjoPFttut133z369+8fp512Wuy2226JZM6ZMyeeeuqpePDBB+Pll19OJLMhsK9Cw2LN1k8FBQXRoUOH2GOPPWL33XeP7bbbLtq2bRtt27aN1q1bR/PmzaN58+bRokWLTdrzL7/88rj//vsT7Lxx8j4DAAAAAAAAAIBcMKsdAAAAAAAAAAAAgK9idmr9km8zA83kg2xZg7mXb/d5Gg9njwEAAAAAAAAAAAANWW1mtRfU1HKiu+HtAAAAAAAAAAAAADQWTZo0iT322CN222232H777aNdu3ax/fbbf/Zjs802ixYtWkRxcXE0adLkK3MqKyujoqIiKioqYvHixTF37tyYN29ezJ0797MfU6ZMiWnTpsW6dety+B1mo6CgIPbdd9/Yd999Y++99/5sGPF2220XW2655Qa/ZvXq1bF8+fJ4//33Y8qUKTFlypSYPHlyvPjii7Fq1arcfgMAJOadd96JLl26JJp53HHHxciRIxPNBAAAAAAAAAAAACC/1HIs+waZ1Q4AAAAAAAAAABHNmzePvfbaKw444IDo3Llz7LzzztG+ffto06ZNbLXVVlFUVLTBr1u/fn0sXrw4Fi5cGB988EHMnDkzpk2bFuPGjYu33347KioqcvydUN+0atUq9t1339h///2jY8eOscMOO8SOO+4YO+ywQ7Rq1SqKi4u/8murqqpixYoVsXLlyli6dGnMnDkzpk+fHtOmTYvp06fHu+++G0uWLMnhd5M7zZs3j86dO8eee+4ZnTt3/uy6bbvttrHllltG69ato3nz5rXKWrZsWSxatCgWL14cCxYsiFmzZsXMmTPjvffeiwkTJsRHH32U8neTG65Z/rF3UV+Z6w40Bp6tNs12220Xhx9+eBx22GHRqVOn6NChQ+y0007RsmXLDX5+zZo1sWzZspg+fXpMnjw53nnnnXj55Zdj0qRJOe68/rGvQsNizcI38z4DAAAAAAAAAIC0mNUOAAAAAAAAAAAAQG2YnUqWzOSDbFmDQF04ewwAAAAAAAAAAABoSGozq72gppYT3Q1vBwAAAAAAAAAAACAfFRYWRnFxcRQXF0dhYWGsW7cuKioqoqKiolZ/YJd/KSgoiObNm0dxcXE0bdo01qxZE6tWrYr169dn3RoACdt8881jyZIlUVhYmGjunnvuGZMnT040EwAAAAAAAAAAAID8sil/F8SsdgAAAAAAAAAA+GYtWrSI5s2bR7NmzaKgoCDWrl0blZWVZrmSiBYtWkRJSUk0adIkIiKqqqpixYoVsW7duow7q9+aNm0azZo1++x/P7Vu3bqorKyMyspK1/DfuGb5xd5FfWSuO9CYeLaqu4KCgiguLo6SkpLPzklZvnx5VFdXZ91ag2RfhYbFmoXa8T4DAAAAAAAAAICNZVY7AAAAAAAAAAAAAJvC7FTqAzP5IFvWIFBXzh4DAAAAAAAAAAAA6ova/Jnngppa/slow9sBAAAAAAAAAAAAAAD4Jscff3w89dRTiWauW7cuWrVqFZWVlYnmAgAAAAAAAAAAAJBfajmWfYPMagcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGiqz2gEAAAAAAAAAAAAAAAAAAAAAAAAAAACAfFSbWe2FOegDAAAAAAAAAAAAAACAPNG3b9/EM999992orKxMPBcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMhPhVk3AAAAAAAAAAAAAAAAQOPQokWLOOmkkxLPHT9+fOKZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABA/irMugEAAAAAAAAAAAAAAAA2zR577BEdOnTIuo0455xz4lvf+lbiuePGjUs8EwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyF+FWTcAAAAAAAAAAAAAAADAxjvrrLPizTffjEceeSSaNm2aWR/FxcVx9dVXp5I9atSoVHIBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAID8VJh1AwAAAAAAAAAAAAAAANRds2bN4o9//GPcf//9UVJSEvvvv3/cdtttmfXzm9/8JnbYYYfEc99///2YNm1a4rkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAED+apJ1AwAAAAAAAAAAAAAAANRNhw4dYtiwYbHffvt94ecvuOCCWLBgQfznf/5nTvv53ve+F5dddlkq2U8//XQquQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQP4qzLoBAAAAAAAAAAAAAAAAau/EE0+Mt956K/bbb78N/vpvfvOb+H//7//lrJ9DDjkkhg8fHoWF6fw1lcceeyyVXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIH8V1NTU1NTqgwUFafcCAAAAAAAAAAAAAADAVygqKorrr78+Lrvsslr9PY/HH388BgwYEMuWLUutp379+kVZWVmUlJSkkv/+++9Hhw4dUskGAAAAAAAAAAAAIP/Uciz7BpnVDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0VGa1AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAD5qDaz2gtz0AcAAAAAAAAAAAAAAACb4Nvf/nY8//zzcfnll0dBQUGtvqZPnz4xc+bMKC0tjaKiokT7adeuXQwdOjQeeuihKCkpSTT78+65557UsgEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgPxVUFNTU1OrDxYUpN0LAAAAAAAAAAAAAAAA/+aoo46KoUOHRtu2bTc64+OPP47y8vJ47LHHYuzYsVFdXV3njKKiojj66KPjnHPOif79+0fTpk03up/aqKysjB133DE+/vjjVOsAAAAAAAAAAAAAkD9qOZZ9g8xqBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaKrPaAQAAAAAAAAAAAAAAAAAAAAAAAAAAAIB8VJtZ7QU1tZzobng7AAAAAAAAAAAAAABAbl155ZXxX//1X1FUVJRY5qpVq2LcuHHx3nvvxezZs2P+/PmxevXqWL16dVRWVkZERNOmTaOkpCTatGkTHTp0iL322isOPPDAaNWqVWJ9fJM777wzLrroopzVAwAAAAAAAAAAAKDxq+VY9g0yqx0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAaKjMagcAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8lFtZrUX1NRyorvh7QAAAAAAAAAAAAAAALnRunXrGDx4cBx//PFZt5KJVatWRceOHWPBggVZtwIAAAAAAAAAAABAI1LLsewbZFY7AAAAAAAAAAAAAAAAAAAAAAAAAAAAANBQmdUOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOSj2sxqb5KDPgAAAAAAAAAAAAAAAKilAw44IIYNGxY77bRT1q1k5pZbbokFCxZk3QYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANBIFdTU1NTU6oMFBWn3AgAAAAAAAAAAAAAAkNdOPvnkePDBB6NZs2ZZt5KZadOmxT777BMVFRVZtwIAAAAAAAAAAABAI1PLsewbZFY7AAAAAAAAAAAAAAAAAAAAAAAAAAAAANBQmdUOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOSj2sxqL8xBHwAAAAAAAAAAAAAAANTC22+/HZWVlVm3kZnq6uo4++yzo6KiIutWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACARqww6wYAAAAAAAAAAAAAAAD4l/feey9+/vOfZ91GZn7729/Gm2++mXUbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAI1dQU1NTU6sPFhSk3QsAAAAAAAAAAAAAAAAR8dhjj0WfPn2ybiOnHnnkkejXr1/WbQAAAAAAAAAAAADQiNVyLPsGmdUOAAAAAAAAAAAAAAAAAAAAAAAAAAAAADRUZrUDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPmoNrPaC2pqOdHd8HYAAAAAAAAAAAAAAIDc2GKLLeLvf/977LPPPlm3khP/+Mc/4rvf/W6sXbs261YAAAAAAAAAAAAAaMRqOZZ9g8xqBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaKrPaAQAAAAAAAAAAAAAAAAAAAAAAAAAAAIB8VJtZ7YU56AMAAAAAAAAAAAAAAIA6WLZsWXzve9+LqVOnZt1K6saOHRsnnHBCrF27NutWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAPFGYdQMAAAAAAAAAAAAAAAB82aJFi6J79+4xe/bsrFtJzejRo+Ooo46KTz75JOtWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAPFKYdQMAAAAAAAAAAAAAAABs2Ny5c+PQQw+Nl19+OetWEjdo0KA4/vjjY9WqVVm3AgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5JnCrBsAAAAAAAAAAAAAAADgq3388cdx9NFHx80335x1K4lYvnx5nHXWWXHuuefGunXrsm4HAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADIQwU1NTU1tfpgQUHavQAAAAAAAAAAAAAAAPA1+vbtG7fffntsv/32WbeyUZ5//vkoLS2N2bNnZ90KAAAAAAAAAAAAAHmolmPZN8isdgAAAAAAAAAAAAAAAAAAAAAAAAAAAACgoTKrHQAAAAAAAAAAAAAAAAAAAAAAAAAAAADIR7WZ1V6Ygz4AAAAAAAAAAAAAAABIwPDhw6NTp07xm9/8JlavXp11O7U2ZcqU6NWrV3Tv3j1mz56ddTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECeK6ipqamp1QcLCtLuBQAAAAAAAAAAAAAAgFrabrvt4qqrroozzzwztthii6zb2aA333wz7rjjjnjwwQejuro663YAAAAAAAAAAAAAyHO1HMu+QWa1AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAANlVntAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEA+qs2s9oKaWk50N7wdAAAAAAAAAAAAAACg/ikuLo5TTjklSktLo1u3blm3E4sWLYoRI0bEXXfdFWPHjs26HQAAAAAAAAAAAAD4TC3Hsm+QWe0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQENlVjsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkI9qM6u9oKaWE90NbwcAAAAAAAAAAAAAAKjfdthhhzjqqKPi6KOPjiOPPDI6duyYes3KysqYOHFi/O1vf4sRI0bEa6+9Vqu/1AIAAAAAAAAAAAAAubYpf87VrHYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoKEyqx0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAyEe1mdVeUFPLie6GtwMAAAAAAAAAAAAAADQsO+ywQ3Tp0iU6duwYu+yyS3Ts2DF23nnnaN26dbRs2TJatmwZTZs2/dqM9evXx5o1a+KTTz6JOXPmfPZj2rRpMXbs2HjnnXeiqqoqR98RAAAAAAAAAAAAAGy8Wo5l3yCz2gEAAAAAAAAAAAAAAAAAAAAAAAAAAACAhsqsdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgH9VmVntBTS0nuhveDgAAAAAAAAAAAAAA0PgUFRVFy5Yto0WLFl/4+bVr18bq1atj3bp1GXUGAAAAAAAAAAAAAMmq5Vj2DTKrHQAAAAAAAAAAAAAAAAAAAAAAAAAAAABoqMxqBwAAAAAAAAAAAAAAAAAAAAAAAAAAAADyUW1mtRfU1HKiu+HtAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBDVcux7BtkVjsAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0FCZ1Q4AAAAAAAAAAAAAAAAAAAAAAAAAAAAA5KPazGovzEEfAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUC8UZt0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5Eph1g0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABArhRm3QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADkSmHWDQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECuFGbdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAORKYdYNAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwP/H7hzTAAAAIADa7B/aFvpAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl70DZnWMaAAAABECb/UPbQh9IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABld45pAAAAEABt9g9tC30gAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAADylNQAAARkUSURBVAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAKDs3LFOW2kUhdGfbSOlQQIZ3iNFeP86RV4kkVGKdGA87USa6bhnG1irvNVX3WqfHwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgClpBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMCUtAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgStoBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMCXtAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiSdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMSTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApqQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFPSDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIApaQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAlLQDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYEraAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAl7QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYknYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATEk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKakHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABT0g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAKWkHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwJS0AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBK2gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwJe0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJJ2AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAExJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACmpB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAU9IOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgClpBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMCUtAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgStoBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMCXtAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiSdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMSTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApqQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFPSDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIApaQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAlLQDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYMq+HQC8f1dXV+v29nY9PDysL1++tHMAAAAAAAAAAAAAPp3n5+d1PB7Xr1+/1vl8bud8Sja1AAAAAAAAAAAAAD32tABAk7sSAAAAAAAAAAAAgC63JX02tQAAAAAAAAAAAAA99rQAQJO7EgAAAAAAAAAAAIAutyV9NrUAAAAAAAAAAAAAPfa0wFvatwOA9+9wOKyvX7+u+/v7td/7rQAAAAAAAAAAAABMO51O6/fv3+vHjx/r58+f7ZxPyaYWAAAAAAAAAAAAoMeeFgBoclcCAAAAAAAAAAAA0OW2pM+mFgAAAAAAAAAAAKDHnhYAaHJXAgAAAAAAAAAAANDltqTPphYAAAAAAAAAAACgx54WeEtpBwDv38PDwzocDo5MAAAAAAAAAAAAAEp2u926vb1d9/f37ZRPy6YWAAAAAAAAAAAAoMeeFgBoclcCAAAAAAAAAAAA0OW2pM+mFgAAAAAAAAAAAKDHnhYAaHJXAgAAAAAAAAAAANDltqTPphYAAAAAAAAAAACgx54WeEtpBwDv3/X19bq+vv7r2/l8LtUAAAAAAAAAAAAAfE673c7D4UU2tQAAAAAAAAAAAABd9rQAQIu7EgAAAAAAAAAAAIA+tyVdNrUAAAAAAAAAAAAAXfa0AECLuxIAAAAAAAAAAACAPrclXTa1AAAAAAAAAAAAAF32tMBb8ScB3tT5fF5//vxZT09P6/X1tZ0DAAAAAAAAAAAA8GElWXd3d+vm5mZdXV21c/gXm1oAAAAAAAAAAACA7dnTAgCXyF0JAAAAAAAAAAAAwAy3JZfLphYAAAAAAAAAAABge/a0AMAlclcCAAAAAAAAAAAAMMNtyeWyqQUAAAAAAAAAAADYnj0tsJV9OwD4eI7H4/r+/ft6eXlppwAAAAAAAAAAAAB8WLvdbn379m3d3Ny0U/gPNrUAAAAAAAAAAAAA29rtduvx8dGeFgC4OO5KAAAAAAAAAAAAALbnrfbLZlMLAAAAAAAAAAAAsC1vtQMAl8pdCQAAAAAAAAAAAMD2vNV+2WxqAQAAAAAAAAAAALblrXZgK/t2APDxnE6n9fLyss7nczsFAAAAAAAAAAAA4MM6nU7rdDq1M/gfNrUAAAAAAAAAAAAA27KnBQAulbsSAAAAAAAAAAAAgO25LblsNrUAAAAAAAAAAAAA27KnBQAulbsSAAAAAAAAAAAAgO25LblsNrUAAAAAAAAAAAAA27KnBbaSdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMSTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApqQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFPSDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIApaQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAlLQDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYEraAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAl7QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYknYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATEk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKakHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABT0g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAKWkHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwJS0AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBK2gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwJe0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJJ2AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAExJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACmpB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAU9IOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgClpBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMCUtAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgStoBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMCXtAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiSdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMSTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApqQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFPSDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIApaQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAlLQDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYEraAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAl7QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYknYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATEk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKakHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABT0g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAKWkHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwJS0AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBK2gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwJe0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJJ2AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAExJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACmpB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAU9IOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgClpBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMCUtAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgStoBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMCXtAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiSdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMSTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApqQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFPSDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIApaQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAlLQDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYEraAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAl7QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYknYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATEk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKakHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABT0g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAKWkHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwJS0AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBK2gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwJe0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmJJ2AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAExJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACmpB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAU9IOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgClpBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMCUtAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgStoBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMCXtAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJiSdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMSTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApqQdAAAAAADwD3v3HqYFVe0P/DvDcBMEVATvkiCZiqLkJc3yDkQCaZYGdo6KGVpqapKKl0zkV5amdjRTsBIryiwtBUXTE1JSmlpeyksm3hBQQAS5zfD7g6OC877DO/eB+XyeZ55499p77bWZ9Uf4wBoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaCrlzV0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANJXy5i4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmkp5cxcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATaW8uQsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAplLe3AUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAUylv7gIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgqZQ3dwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0NoNGJZUtG/uKgAAAAAAAAAAAAAAAACgdShv7gIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoDUbMDw5ZHTyqbOauxIAAAAAAAAAAAAAAAAAaB3Km7sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGitPvTR5KCTVv96p08k+x/XvPUAAAAAAAAAAAAAAAAAQGtQ3twFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBrtNl2ydBzk/I276/t94Vkp082X00AAAAAAAAAAAAAAAAA0BqUN3cBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANDadOyaHHlx0r7T2utlZcngryVbfrg5qgIAAAAAAAAAAAAAAACA1qG8uQsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgNakvCIZdl6yyVaF4207JMPHJp27N21dAAAAAAAAAAAAAAAAANBalDd3AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQmhx2arLd7jXv2Xjz5MgLk4r2TVMTAAAAAAAAAAAAAAAAALQm5c1dAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC0FgOGJ7sPLm3vFn2TT53VqOUAAAAAAAAAAAAAAAAAQKtU3twFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBr8KGPJgedVLszO30i2f+4xqkHAAAAAAAAAAAAAAAAAFqr8uYuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2dJttlww9Nylv8/7aqlXJS/9Ye9/cF5J3Fq29tt8Xkp0+2fg1AgAAAAAAAAAAAAAAAEBrUdHcBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAhqxj1+TIi5P2ndZe/+NNq/93237vr701N7nvh8nRlyZt2q5eKytLBn8tWTg7ee1fTVExtCxbb711TjzxxIKxVatWZdy4camqqmriqgAAAAAAAAAAAAAAAID1WUVzFwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAG6ryimTYeckmW629/tQfkpm/TPb5XPUzsx5P7r0uGXja+2ttOyTDxyY3fy15e17j1gwtzVFHHZVvfvObBWOPPfZYvvWtbzVxRQAAAAAAAAAAAAAAAMD6rry5CwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACADdVhpybb7b722qtPJ3ddUfO5x+9KHvnt2msbb54ceWFS0b5BS4QWb/DgwUVjU6dObcJKAAAAAAAAAAAAAAAAgA1FeXMXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbogHDk90Hr7321tzk1xcnVSvXff4PP0peeHjttS36Jp86q6EqhJavffv2+eQnP1k0PnXq1CasBgAAAAAAAAAAAAAAANhQVDR3AQAAAAAAAAAAAAAAALRePXZIPnZsaXuf+VPy9P2NW09z2ahbMvS80vY+NDn5zyONWk5JGqNm/bB+9gIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtWc292rr43xus9obx/rYCwAAAAAAAAAAAAAAAAAAAAAAAACl2H6P5KCT1l5b/k5y6wXJOwtLy7GqKrn9smTklUn37d9f3+kTydwXkj//vOHqbQz77bdfPv3pT2efffZJnz590r1793Ts2DErVqzI22+/nZdffjlPPvlk7rvvvtxxxx2ZO3duve6rqKjIoEGDMmTIkOy5557p3bt3unTpkvLy8rzxxhuZN29eXn311TzwwAOZNm1aHn744VRVVdXprq5du+bEE0/MEUcckX79+qVbt25Zvnx5XnrppTz44IO56aab8uCDD9Ypd8eOHXPccccVjU+aNClLliypU+4POuSQQ3LvvfcWjS9cuDC9evXKggULap37iiuuyNe+9rWi8VNPPTXXXnvtOvN84hOfSMeOHQvG3n777cyYMeO9z+vDewAAWjOzuVdbH+dzm9XeONbHXgAAAAAAAAAAAIANSUVzFwAAAAAAAAAAAAAAAEDrtdEmyYcPKG3v/FeTpxu3nGZT0S7ZbrfS9v7jnsatpVSNUbN+WD97AQAAAAAAAAAAAAAAAAAAAAAAAAAAAIDaM5t7tfVxPrdZ7Y1jfewFAAAAAAAAAAAAAAAAAAAAAAAAgFLsPyIpb/P+56rK5HffTub9p3Z5li9Jbrs4GXllslG399f3PSb5y61J5YoGKLaBfe5zn8vFF1+cj3zkIwXj7dq1y6abbppNN900u+22W4499tgsW7YsP/7xj3Puuedm/vz5tbqvvLw8o0ePzrnnnputt9664J4ePXqkR48e2XnnnXPooYfm0ksvzXPPPZexY8dm8uTJtbpv8ODBmTRpUjbddNO11jt27Ji+ffumb9++OeGEEzJ58uSceOKJWbx4ca3yf+9738vo0aMLxiZMmJAf/ehHtcpXk/vuuy933nlnhgwZUjDetWvXjBkzJueee26t8m699dY55ZRTisaffvrpXH/99SXlGjx4cNHYfffdl5UrV671uaW/BwCgNTObe7X1cT63We2NY33sBQAAAAAAAAAAANiQVDR3AQAAAAAAAAAAAAAAANSs38Bk4+6l7X3098k7Cxu+hq13Trbfo7S9Lz6avPJUw9cAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALQuZrUDAAAAAAAAAAAAAAAAAAAAAAAAAOu78jZrf/7jj5PnH6pbrgWvJbdflnxuXNKm7f/lL09WrapXiQ2uc+fOmTRpUoYNG1brs+3bt8/JJ5+cI444IkOHDs0jjzxS0rltttkmv/71r7P33nvX+s4+ffrkF7/4Rb761a9m6NChefPNN9d55stf/nKuvfbalJWVrXPv5z//+ey66675+Mc/ngULFpRU0+DBgzN69OiCseeffz6nn356SXlq4+yzz87AgQNTUVFRMH7aaaflyiuvzJw5c0rOedFFF6V9+/ZF42eddVYqKytLyjVo0KCisalTp1Zba+nvAQBYF7PaAQAAAAAAAAAAAKBpFP4XSAAAAAAAAAAAAAAAALQYuw9KtvpIaXv/Nb2Rhrfvknz8uNL2rlxueDsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUH9mtQMAAAAAAAAAAAAAAAAAAAAAAAAA67s//jj59DlJx67JX25N/vKr+uV76e/J776dDP5aUla+On/VyoaotGF06dIl999/f/bcc8965dlqq61y7733Zr/99svTTz9d494+ffpk+vTp2WKLLep15/77758ZM2bk8MMPz0svvVR034ABA3L11VenrKys5Ny77LJLJkyYkKOOOmqde7t3756bbrqpYKyysjIjR47M4sWLS767VP/85z/zox/9KKecckrB+EYbbZTzzz8/p59+ekn5+vTpk+OPP75ofNq0aZkyZUpJubbddtt85CPFB5Xefffd1dZa8nsAAEphVjsAAAAAAAAAAAAANI3y5i4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADY0sx5Prh2RXHVUMv3HDZPzmQeTaz6/Ouffbm+YnA3lxz/+cfbcc88GydWtW7f87Gc/S5s2bYru6dKlS+65555sscUWDXLnTjvtlN/85jc13jlhwoS0bdu22vozzzyTiRMn5vbbb8/y5curxY888sgMGzZsnTXceOON6dmzZ8HY+PHj89BDD60zR11deOGFWbhwYdH4ySefnG222aakXJdcckkqKioKxiorK3PmmWeWXNfAgQOLxp599tm88MILBWMt9T0AAAAAAAAAAAAAAABAy1H4Xw0BAAAAAAAAAAAAAAAAQB1suk1y8JdL2zv9x8nrzzVqOQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATcKsdgAAAAAAAAAAAAAAAAAAAAAAAKAmK5c1bL6qlQ2bryEcffTR+cxnPtOgOfv3759jjz02kyZNKhi/6qqr8qEPfahB7xwwYEDOOeecjB8/vlpsv/32y+67715t/bbbbsvRRx+dqqqqJMk+++yTP/7xj2nXrt1a+0499dTcfvvtRe8+4YQTMmzYsIKxhx9+OBdffHEtXlJ7b7zxRi699NJcfvnlBePt27fPRRddlJNOOqnGPP369csxxxxTND5hwoQ88cQTJdc1aNCgorGpU6cWjbXU9wAAAGxozGoHAAAAAAAAAABgfVbe3AUAAAAAAAAAAAAAAAAAsOFo3ynZ4aOlfXXs2tzVAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0DLPaAQAAAAAAAAAAAAAAAAAAAAAAgNasbdu2ueaaa2rc849//COjR49O//79s/XWW+fDH/5wDj/88PzP//xPli1bVm3/ihUrctttt+X5558vmG+nnXbKF7/4xRrvnD59eo4++uhsueWWadOmTTp27Jhdd9015513XubNm1f03EUXXZRNNtmk2vqgQYMK7j/77LNTVVX13ueZM2dm8uTJ1fYdeOCBadeuXcEcO+ywQ6666qqCsSVLluQLX/hCKisri9bcUK6++uq88MILReP//d//nd69e9eYY9y4cSkrKysYW7RoUS644IKS62nTpk0OPfTQovEpU6bUeL6lvQcAAGBDZFY7AAAAAAAAAAAA67Py5i4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFg/DRs2LD179iwav/7667Pnnnvmhz/8YR5//PG8+uqreeaZZzJt2rR85Stfyb777puFCxcmSZ577rmMGTMm22yzTY466qj8+c9/LpjzpJNOSnl5edE7x44dm0984hO59dZbM3v27FRVVWXp0qV58sknM378+Oy6667529/+VvBs+/btM3LkyGrrO++8c7W11157LS+88EK19enTp1dba9u2bXr37l1tvby8PLfccks6d+5csJ6zzjorzz77bMFYQ1u+fHnGjBlTNF5RUZFLLrmkaHyfffbJEUccUTR+2WWXZc6cOSXXs++++6Zr164FY8uWLcsDDzxQ4/mW9h4AAAAAAAAAAAAAAACgZSn+r9QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGowatSoorH7778/o0ePzsqVK4vueeyxx/KFL3whBx10UHbcccd85zvfyZw5c2q889Of/nTR2M0335xx48bVeP7111/PkCFD8tZbbxWMn3TSSdXWunXrVm2tWJ3F1jfddNNqa+edd1723Xffgvvvuuuu/PCHPywYayy/+tWv8qc//alo/Jhjjskuu+xSMDZ+/Pii51588cVceeWVtapl0KBBRWPTp0/PO++8s84cLek9AAAAAAAAAAAAAAAAQMtS3twFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADrn44dO+bQQw8tGv/617+eVatWrTPPXXfdlQceeKCkOzt16pQdd9yxaPzSSy8tKc/s2bMzceLEgrF+/fqle/fua621adOm2r4VK1YUPF9svVCOiy66qODeuXPn5vjjjy8Ya2xnnnlm0Vh5eXnB3+ODDz44Bx10UNFzY8aMybJly2pVx6BBg4rGpkyZUnKelvIeAAAAAAAAAAAAAAAAoGWpaO4CAAAAAAAAAAAAGlu7jZLDT0vuuTpZvqS5qwEAAGBNK95J5v6ntL2L5zdqKbQA+gEAAAAAAAAAAAAAAAAAAAAAAAAAAACA1sJsbtakHwAAAAAAAAAAAAAAAAAAAAAAAABYn/Xv3z9t2rQpGHv66afzyCOPNPidW265ZcrKygrG5s6dm2eeeabkXNOnT88ZZ5xRMDZgwIDcfffdNZ4vLy+v1foHdezYMRUVFQVjo0aNypw5c0rK09BmzpyZX/ziFznmmGMKxocPH56PfvSjefjhh99bGz9+fI35Jk+eXKsaunfvngEDBhSNr+t788H7m/s9AACsZjY3a9IPAAAAAAAAAAAAQHMr/K+7AAAAAAAAAAAANhBl5ckR30h675106JT8+qJkVVVzVwUAAMC7XnkquenLzV0FLYV+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAKC1MJubNekHAAAAAAAAAAAAAAAAAAAAAAAAANZnAwYMKBqbNm1ao9y58cYbF429+eabtcpV0/4BAwbk7rvvfu/zkiVLqu3p3LlzwbPF1hcvXrzW5yuuuKLgvgkTJuSOO+4oWltTGDNmTIYPH54OHToUjI8bNy4DBw5MkgwdOjR777130VxnnHFGre8/7LDDUlZWVjD2yiuv5Mknn6xVvuZ+DwAAq5nNzZr0AwAAAAAAAAAAANDcypu7AAAAAAAAAAAAgMZ04Kik9//NW95hr+TgLzVvPQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwodhll12Kxp588sm1Pnft2jXHHntsLr744lx//fW55ZZbcv311+ecc87JJz/5yZSXl5d0Z1VVVdFYp06dSiv8/2y00UZFYzvssMNan1966aVqe3r16pX27dtXW995550L5pw1a9Z7v/7Upz6VL3/5y9X2PP/88zn99NOL1tVUZs2alauuuqpo/PDDD88BBxyQsrKyjBs3rui+yZMn56GHHqr1/YMHDy4amzp1aq3zNfd7AAAAAAAAAAAAAAAAgJanorkLAAAAAAAAAAAAaCy7DUz2OnLttQHDk3mzksfvapaSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGCD0a1bt6KxWbNmJUl22GGHXH755TniiCPStm3bovtff/31XHHFFbnqqquybNmyovveeuutorGtttoqm222Wd544411F59kt912Kxrr2rXrWp9nzJiRk08+ea21du3a5Qtf+EJuuumm99batm2bY489tlq+F154IXPnzk2SdO/ePRMnTqy2p7KyMiNHjszixYtLqr+xjRs3LieccEI233zzgvHLLrss1113XXbdddeC8WXLlmXMmDF1unvgwIFFY1OnTq1TzuZ8DwAAAAAAAAAAAAAAANDylDd3AQAAAAAAAAAAAI1h292Sw75SOHbo6GS73Zu2HgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADY0HTt2rVobNGiRTnllFPy1FNP5cgjj0zbtm1rzNWzZ898+9vfzmOPPZZddtml6L6XXnopK1asKBgrLy/Pl770pZJqb9u2bUaNGlU03qVLl7U+33HHHXn77ber7bvmmmvy1a9+Nf369cuBBx6Yu+66K3369Km275Zbbnnv1xMmTEjPnj2r7bnsssvy0EMPlVR/U1i0aFEuuOCCovGPf/zjufbaa4vGr7zyyrz44ou1vrd///7p0aNHwVhlZWXuvffeWudMmu89AAAAAAAAAAAAAAAAQMtU0dwFAAAAAAAAAAAANLRuWybDzkvaFJkL3qZtMnxs8tPTkgWvNW1tAAAAtAybbJNstVOyRZ9ko02SDp2SNu2SFUuT5UuSha8nc/+TvPT35O03mrva0myyTbLdbsnmvZKNN0/adUjK2iQrlyVLFyULZiezn01e/keytPrPoWrVNrR+0AvFde2Z9Nwx6dk72ahb0r7T6q82bZOqytXf7+XvJG/NSea9mMz5d/LmS81dNQAAAAAAAAAAAAAAAAAAAAAAAAAAAEDD2dBmcyfmc9fHhtYPeqE4s9oBAAAAAAAAAAAAAAAAAAAAAACAxtS1a9eisdGjR2fEiBG1zrnTTjtlxowZOeyww/LXv/61WnzlypX529/+ln322afg+QsvvDAzZszIH//4x6J3lJWV5brrrkvv3r2L7vng2xYuXJjx48dn3Lhxa6136tQpV199dU1PymuvvZYrr7wySXLiiSdm6NCh1fb89a9/zTe/+c0a8zSHG264Iaeddlp23nnngvFiPTBnzpxcdtlldbpz0KBBRWMzZ87MggUL6pQ3aZ73AADQ/Da02dyJ+dz1saH1g14ozqx2AAAAAAAAAAAA1qWiuQsAAAAAAAAAAABoSO02Sj5z0erhWzXpsHFy9LjkJ19ZPZQLAACA5rFR12TQmaXtffg3yazH6n5Xm7ZJ/yFJv8OTHjuUfu61fyWP/j558r5kVdX76923T/b6bM1n31mYPHBj3eotRVl5svNByUc/k/TsU9qZqsrkhUeSv/46mfV449VWF/qh7pqyF7beOdnn88XjHTqXnuuALyZ7Vv95ZkXdc3XtB+hvsk3S77Bkl0OSjbvX7myyenj/8zOTx+5cPdAdAAAAAAAAAAAAAAAAAAAAAAAAAAAAoCGYzV0/ZrXX/a4NrR/Mai/OrHYAAAAAAAAAAAAAAAAAAAAAAACgqbRr165obMSIEXXO27Vr1/zud79L//79M3v27GrxW2+9Nfvss0/Bsx06dMi0adNyySWX5Ac/+EEWLly4VnyPPfbI5ZdfnkMOOaTGGtq0aVNtbfz48Tn00ENz0EEHlfyWqqqqjBgxIm+++WZ69+6d73//+9X2LFmyJCNGjEhlZWWSZLPNNstnPvOZ7Lffftlqq61SUVGRN954I48++mh++9vf5p///GfJ99dXVVVVzjrrrEyZMqVW5y644IIsWrSoTncOHjy4aGzq1Kl1yvmu5ngPAADvM5u7fsxqr/tdG1o/mNVenFntAAAAAAAAAAAA1EZFcxcAAAAAAAAAAADQUMrKkyO+kWzeq7T9m2yVfObC5JfnrT1sDQAAgKZT0T7pU/jnMFXzr+l1v2enTyYHjUo23rz2Z7f88OqvfT6X3P395OUnV6937r56IHRNFr7eeMO6N/9QMuTrtRs8niTlbZLee6/+em5mcvdVyeI3G6fG2tIPddPUvdBpk9K/T+uy5YdL37tqVfLOW6Xv77xZcvDJyU6fqH1da+rac/WA+T2OSP791+T+G5I3X6pfTgAAAAAAAAAAAAAAAAAAAAAAAAAAAACzuevOrPa637Oh9YNZ7YWZ1Q4AAAAAAAAAAAAAAAAAAAAAAABsSHr27Jkf/OAH+exnP1stduONN+bCCy/MxhtvXPBsu3btcumll+biiy/OE088kddffz3t2rVLnz59su2229a5plWrVmXYsGGZNGlShg4dus79CxcuzMiRI3P//fenvLw8kyZNSufOnavtO/PMM/Pss8+mrKwsY8eOzbnnnpuOHTtW2/e5z30u48ePz2233ZZRo0Zl/vz5dX5LbUydOjX33HNPDj/88JL2P/HEE7nxxroNJOzcuXM+9rGP1VhLfTXlewAAWJvZ3HVnVnvd79nQ+sGs9sLMagcAAAAAAAAAAKAuypu7AAAAAAAAAAAAgIZy4KjVw8ZqY/v+yaGnNEo5AAAAtABt2iaDzkiGnlu3Qd1r2mzb5JjvJAOGNUhp9dJ3/2Tk92s/rPuD+uyT/Pe1yRZ9G6SsFm9D7IfW1AuL5iaVK0rbu9ugZNSN9R/cvqaystX/7em//yfZq/rPlQMAAAAAAAAAAAAAAAAAAAAAAAAAAABoUTbE2dxJ65rP3ZA2xH5oTb1gVjsAAAAAAAAAAAAAAAAAAAAAAACwoXjooYfyjW98I0cffXSGDRuWk046KT/96U/zzjvv1HjuqKOOyh577FFtfcGCBRk7duw6762oqEj//v0zcODAHHTQQdl2223r/IZ3LVq0KMOGDcspp5ySWbNmFdyzcuXK3Hrrrdlzzz3z+9//Pkly/vnnZ999962296677sr111+fjh075q677soll1ySjh071ljDkUcemUcffTQ777xzvd9TqjPPPDOVlZUl762qqqrTPYccckjatm1bMPbGG2/k4YcfrlPeD2qq9wAA0LQ2xNncSeuaz92QNsR+aE29YFY7AAAAAAAAAAAATaGiuQsAAAAAAAAAAABoCLsNTPY6cu21ZYuT159Pttvt/bXnHkq2/HDSaZP31/b4dDLvxeTR3zVNrQAAADSNinbJUd9Mtq/+85/qrLxNcsjopKw8mVf4Zzc1ur77Jb33WV1LQ+jULTnm/yWTzkzm/adhcrZEG2I/tLZeePOV0vYd8F/Jx45tvDoq2iUHjUq6b5dM/X6yys/2AgAAAAAAAAAAAAAAAAAAAAAAAAAAAFqYDXE2d9L65nM3lA2xH1pbL5jVDgAAAAAAAAAAAAAAAAAAAAAAAKzvFi5cmC9+8Yu54447qsVuvPHGjBkzJj//+c9z4IEHFs0xatSonHrqqdXWr7nmmhx88MEZNmxYnetbunRpOnToUDC2atWqGs9ed911ue6669K/f//069cvm266aZYtW5ZZs2blz3/+c+bPn//e3r322isXXnhhwTzHH398ktXvGTRoUMm1b7/99vntb3+bPfbYI4sXLy75XF09+eSTmThxYk466aQa902ZMiXTpk2r8z2DBw8uGps2bdo6vy+laqr3AADQdDbE2dxJ65vP3VA2xH5obb1gVjsAAAAAAAAAAABNoby5CwAAAAAAAAAAAKivbXdLDvvK2mtVlckd45M3PjA4bdG85LaLk5XL114/5MtJrwGNWiYAAABNqSwZNrZhB3Wv6aCTkg81058jd9yv4YZ1v6vdRsnw85O27Rs2b4uxgfZDa+uF+SUMb9/9U407uH1N/Q5PBp3RNHcBAAAAAAAAAAAAAAAAAAAAAAAAAAAAlGwDnc2dtL753A1iA+2H1tYLZrUDAAAAAAAAAAAAAAAAAAAAAAAALd3SpUuLxlatWpXhw4fnjjvuKLpn9uzZGTx4cB599NGie4YMGVI0/zHHHJPf/e53pRe8hldeeSWjRo0qGl+0aFFJeR577LHcfPPNueqqq/LDH/4wd911V+bPn/9evGPHjpk0aVIqKioKnp8zZ04GDx6cE088sWB87ty5+c9//pNVq1ZVi+244465/PLLS6qzIYwdO7bG35fKysqcddZZ9bpj4MCBRWNTpkypV+4Paor3AADQRDbQ2dxJ65vP3SA20H5obb1gVjsAAAAAAAAAAABNoby5CwAAAAAAAAAAAKiPblsmw85L2rRde/2BG5MXHi585rV/JVOuTNace13eZnWezbZrvFoBAABoOh87Jum9d+PlLytP9jqy8fI3h023TQ4Z3dxVNA79UDsttRfefLnmeJceycEnN00t7+p3+OovAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJbCbO7aa6nzuRuCfqidltoLZrUDAAAAAAAAAAAAAAAAAAAAAAAALd1bb71VNHbbbbflgQceWGeOpUuX5utf/3rR+Pbbb5+uXbsWPTt8+PB8/etfzzvvvLPOu9515513Zr/99surr75adE9Nb6uNK6+8Mn379i0Yu/HGG5Mk55xzTrVYVVVVjjvuuPTo0SMf+tCH0q9fv7z8cvVBdSeccEI23XTTBql1XebMmZNbb721aPwPf/hDnn766Trn79u3b3r16lU0fs8999Q5dyGN/R4AAJqO2dy111LnczcE/VA7LbUXzGoHAAAAAAAAAACgKZQ3dwEAAAAAAAAAAAB11W6j5DMXJRt1W3v971OTh39T89mn708emrz2WvtOyZEXJx0LzwQHAABgPbH5h5L9RzZ3FeunXQ9bPQB7Q6If6qYl9sL8V2qOf+zYpG37pqllTYeckmzkvycBAAAAAAAAAAAAAAAAAAAAAAAAAAAALYDZ3HXXEudz15d+qJuW2AtmtQMAAAAAAAAAAAAAAAAAAAAAAAAt3cKFC4vG7rjjjpLz3H///Vm8eHHReM+ePYvGqqqq8t3vfje9evXKJZdckqeeeiqrVq2qtm/+/Pn56U9/msMOOyyf/vSnM2vWrGyyySZF89b0tlINGTIkJ598csHY888/nzPOOCNdu3bNAQccUC3+s5/9LJMmTXrv85NPPpmzzz672r727dtn0KBB9a61VMuWLatTrBQDBw4sGnv88ccze/bseuUvpDHfAwBA0zCbu+5a4nzu+tIPddMSe8GsdgAAAAAAAAAAAJpCRXMXAAAAAAAAAAAAUBdl5ckR30g277X2+kv/SO75QWk5pv842WzbpO/+769tslUy7Pzkl+clVSsbqloAAICms/PBydvzGj7vNjs3fM7GcvCXkvI2zV3F+qm8TTJgeHL/j5q7koajH+qmJfbC/FeLx9q0TT5yUO3yrapKFs1Llr69+r8Dte2YdOqWdNi4dnnadUj2PSb5w/W1OwcAAAAAAAAAAAAAAAAAAAAAAAAAAAA0LLPazeauj5Y4n7u+9EPdtMReMKsdAAAAAAAAAAAAAAAAAAAAAAAAaOnmz59fNPbyyy+XnKeqqiqzZ89O7969C8Y7d+68zhxz5szJRRddlIsuuihdunRJr1690qVLlyxatCivvfZa5s6dm1WrVq11pm/fvkXzzZ49u+T6C+nevXsmTJhQMFZZWZkRI0Zk8eLF2X///dOmTfVBgnfeeWdJa0myxx575Gc/+1m96m0JBg8eXDQ2derUJqwEAGD9YVa72dz10RLnc9eXfqibltgLZrUDAAAAAAAAAADQFCqauwAAAAAAAAAAAIC62H9k0nvvtdcWvJb89tLVw7ZK9fvvJF/4XrJFn/fXtttt9WC3e69tmFphfbP11lvnxBNPLBhbtWpVxo0bl6qqqiauCgCAUn3smOauoHlts2uy/R61P/f688nzM5M3XkyWLExSlnTaJNlix6Tvx5Mumzd4qQ3qtX8l/3owWfBq8s6ipH2npNsWSe99ku371y5Xv8OT+29IsmqdW1u81tgPG2ovVFUmC2v4mWpb77J6iHopFr6e/PGm5Pm/JMuXVI+3bZ/ssHeyyyFJn31rzrVyefL0/yb/uKe0uwEAAAAAAAAAAAAAAAAAAAAAAAAAAIDGY1Z765vNnWy487nrqzX2w4baC2a1AwAAAAAAAAAAAAAAAAAAAAAAAOuDv//970Vj5eXltcpVVlZWNLZ8+fJa5XrrrbdqrO1dAwYMKBp75JFHanXnB02cODE9e/YsGBs3blxmzpyZJNl888JD/2bNmlVt7e23386CBQvSrVu3tdZ79OhRr1pbgvbt2+fAAw8sGp86dWrTFQMAsB4xq731zeZONtz53PXVGvthQ+0Fs9oBAAAAAAAAAABoKhXNXQAAAAAAAAAAAEBd7DZo7c/LFie3fTN5Z2Ht8qxcltx2cXLc95ONu7+/3n9Icu+19a0S1k9HHXVUvvnNbxaMPfbYY/nWt77VxBUBAEDp+n+6dvsXzE6m/SB54eHC8af+kDxwYzLgM8kBX0wq2tW/xoY078Vk6pXJq/8sHH/4N8l2uyfDxiYdNy4tZ4fOyea9krkvNFiZzaY19UNT9sJzM5Orjy5+bou+yefGlXbH7eOSFx8rYeOq1QPci9l8+9LuW/p2MumMZPH84ntWLEv+NX3114cPSAadsXoI/pqWLEgevTN59Herfw0AAAAAAAAAAAAAAAAAAAAAAAAAAADQ3FrTbO7ErPZ1aU39YFZ7afeZ1Q4AAAAAAAAAAAAAAAAAAAAAAAA0pkceeaRobPvtSxyclqRt27bZaqutisYXLFhQm7JKvnPgwIFF43/729/qnHvUqFE54ogjCsb++te/5pJLLnnvc7t2hYf9LVu2rOT1YjnWJwcccEA6duxYMPb2229nxowZTVwRAADrg9Y0mzsxq31dWlM/mNVe2n1mtQMAAAAAAAAAALAu5c1dAAAAAAAAAAAAQF2sOWCrqjL5/eXJvP/ULdfb85LffitZsfT9tfmv1qs8WK8NHjy4aGzq1KlNWAkAANROu42SvvuVvn/uf5JbvlZ8UPe7qiqTv96a3Hbx6qHOLcWr/0wmfa34sO53zXo8+dX5NQ++/qCtd6lfbS1Ba+qHpu6FqpXJ0kXFv5a9XXr+ZUtqzvXe1zpybtSttPv+/ZeaB7d/0L+mJ7df9v7neS8mU65MrjsumXGzwe0AAAAAAAAAAAAAAAAAAAAAAAAAAABAy9CaZnMnZrWvS2vqB7PazWoHAAAAAAAAAAAAAAAAAAAAAAAAWoa///3vWb58ecHYZz/72ZLzfOpTn0qHDh0KxhYtWpSXX365TvXVZNSoUdl4440LxubOnZvnn3++Tnl79+6d73//+wVjS5YsyYgRI1JZWYtBea3E4MGDi8b+8Ic/ZMWKFU1YDQAA64PWNJs7Mat9XVpTP5jVblY7AAAAAAAAAAAADae8uQsAAAAAAAAAAACoi9/9v+Q/f0tefy65fVzy/EP1y/fav1YPXZv9zOq8v7mkQcqE9U779u3zyU9+smh86tSpTVgNAADUzrb9kop2pe1dvjT5zTdrN8T5P39L7r22brU1tCULV/85dvmS0vbPfib5ey3+7/yWH65TWS1Ka+kHvbBam7al7atcWfvc/3kk+cP1yeRzk4knJ/+4O6n088QAAAAAAAAAAAAAAAAAAAAAAAAAAACAFqS1zOZOzOcuRWvpB72wmlntAAAAAAAAAAAAAAAAAAAAAAAAQEuwfPny/O53vysYGzRoUD772c+uM8cmm2yS7373u0Xjf/7zn0uq5ZBDDskvf/nL3Hzzzevcu8MOO+SSSy4pGp80aVJJd35QeXl5Jk2alE6dOhWMf+1rX8uzzz671try5csL7u3QoUPJ68uWLatlpS3PoEGDisamTq3FYEEAAFqN1jKbOzGfuxStpR/0wmpmtQMAAAAAAAAAANBQKpq7AAAAAAAAAAAAgLp486Xkl+c1bM4XH0t+elrD5mwpNttssxx11FEFY48//nhmzpxZ65wVFRUZNGhQhgwZkj333DO9e/dOly5dUl5enjfeeCPz5s3Lq6++mgceeCDTpk3Lww8/nKqqqjrV37Vr15x44ok54ogj0q9fv3Tr1i3Lly/PSy+9lAcffDA33XRTHnzwwTrlTpKOHTvmuOOOKxqfNGlSliwpcQreOhxyyCG59957i8YXLlyYbt261TrvFVdcka997WtF46eeemquvXbdUwU/8YlPpGPHjgVjb7/9dmbMmPHe51Le0qtXryxYsGCd935QQ70HAIDWpdcepe/9yy+TBa/V/o5/3J3sfFCyff/an21I03+SLFlQuzOP35X0H1La3o5dal1Si9Na+kEvrLZiaWn7ttl19aD32g5ff/g3ta8JAAAAAAAAAAAAAAAAAAAAAAAAAAAAoKm0ltncifncpWgt/aAXVjOrHQAAAAAAAAAAAAAAAAAAAAAAAGgpbrjhhhx11FEFY5MmTUrPnj1z3XXXpaqqqlq8X79+ueWWW9KnT5+i+X/+858XjfXo0SPHH398vvSlL2WHHXZ4b/3NN9/MmDFjsnRp9eFtBx54YH784x+ne/fuRfPeeOONRWM1GTt2bPbdd9+CsTvvvDM/+tGPqq2//vrrBfdvv/32mTFjxlprXbt2TdeuXUvOsb7YZpttsvPOOxeN33333U1YDQAA64vWMps7MZ+7FK2lH/TCama1AwAAAAAAAAAA0FAqmrsAAAAAAAAAAAAAGt9PfvKTDBlSeCrbd7/73cycObPkXOXl5Rk9enTOPffcbL311gX39OjRIz169MjOO++cQw89NJdeemmee+65jB07NpMnT65V7YMHD86kSZOy6aabrrXesWPH9O3bN3379s0JJ5yQyZMn58QTT8zixYtrlT9Jvve972X06NEFYxMmTCg4YL2u7rvvvtx5551Fvx+FBrGvy9Zbb51TTjmlaPzpp5/O9ddfX1KuwYMHF43dd999Wbly5Vqf1/WWMWPG5Nxzzy3p7nc15HsAAGhdevQubV/lyuSxu+p+z19/3bzDupcvSZ6YVvtzrz+fvLMo6bjxuveWsqelaw39oBfeV+oA+022SoZfkDxwY/LGrEYtCQAAAAAAAAAAAAAAAAAAAAAAAAAAAKDJtIbZ3In53KVqDf2gF95nVjsAAAAAAAAAAAAAAAAAAAAAAADQUtxzzz355z//mZ122qlarH379vnBD36Qs88+O3fddVeee+65LF++PD179szHP/7xHHjggSkrKyua++WXX87PfvazgrGvfvWr+d73vpe2bdtWi5122mk54YQTMm3atMyaNSuLFi1Kjx49st9++2XXXXet8T133nlnnnrqqXW8urq99torF1xwQcHY3Llzc8IJJxSMPfHEE1m5cmUqKirWWh8+fHi1tw8dOrRgjkceeaTW9bYkAwcOLBp79tln8+9//7sJqwEAYH3RGmZzJ+Zzl6o19INeeJ9Z7QAAAAAAAAAAADSUinVvAQAAAAAAAAAAYH12+umnZ8iQIQ2Sa5tttsmvf/3r7L333rU+26dPn/ziF7/IV7/61QwdOjRvvvnmOs98+ctfzrXXXlvjMPd3ff7zn8+uu+6aj3/841mwYEHJdQ0ePDijR48uGHv++edz+umnl5yrVGeffXYGDhxYbTj7u3r06JE5c+aUnO+iiy5K+/bti8bPOuusVFZWlpRr0KBBRWNTp06ttraut5x22mm58sorm+09AAC0LptsXdq+1/5V+qDnQv79cLL07aRD57rnqI9ZjyeVK+p2dt5/km37rXtfc72tIbWGftAL75v/Wul7e++9+mvh68ncf68+O//VZMFryYJXV6+vqmq8WgEAAAAAAAAAAAAAAAAAAAAAAAAAAAAaWmuYzZ2Yz12q1tAPeuF9ZrUDAAAAAAAAAAAAAAAAAAAAAAAALcWqVaty/PHHZ8aMGSkvLy+4p1evXjnllFNqnfv000/P8uXLC8b+93//NxUVFUXPdu7cOZ/5zGdqdd9bb72Vk08+uVZnkmSjjTbKLbfcUrSeE088MXPmzCkYW7RoUe67774MHDhwrfXPfvaz+cpXvpLrrrsulZWV2X///fPd73632vklS5Zk6tSpta65JRk8eHDR2N13392ElQAAsD5pDbO5E/O5S9Ua+kEvvM+sdgAAAAAAAAAAABpK8X+hBgAAAAAAAAAAwHpvjz32yHe+850GydWnT59Mnz49W2yxRb3y7L///pkxY0YOP/zwvPTSS0X3DRgwIFdffXXKyspKzr3LLrtkwoQJOeqoo0ra371799x0000FY5WVlRk5cmQWL15c8v2l+uc//5kf/ehHRYfXn3/++Tn99NNLytWnT58cf/zxRePTpk3LlClTSsq17bbb5iMf+UjReKGh6et6y0YbbdRs7wEAoHVp0zbpvGlpe1/7Vz0vW5W8+nSyw171zFNHc/9T97PvvFXavor2db+jJWgt/aAX3vfyE8nK5UlFu9LPdO25+uuDqipXD3Bf8FryxkvJ688ms59N3pjVcPUCAAAAAAAAAAAAAAAAAAAAAAAAAAAANJTWMps7MZ+7FK2lH/TC+8xqBwAAAAAAAAAAAAAAAAAAAAAAAFqShx56KN/+9rdz7rnnNljOH/zgB7ntttuKxv/+97/nqquuyhlnnNFgd37lK1/JK6+8UutzV1xxRXbccceCsRtuuCG/+93vajw/fvz4HH744SkrK3tvraysLNdcc00uv/zyLF26NN26dSt49n/+53/y1lslDt1rgcrLy3PIIYcUjU+ZMqUJqwEAYH3RWmZzJ+Zzl6K19INeeJ9Z7QAAAAAAAAAAADSU8uYuAAAAAAAAAAAAgMbRqVOnTJ48Oe3a1WJqWRFdunTJPffcky222KIBKkt22mmn/OY3v0mbNm2K7pkwYULatm1bbf2ZZ57JxIkTc/vtt2f58uXV4kceeWSGDRtWUh033nhjevYsMKUtq4enP/TQQyXlqYsLL7wwCxcuLBg7+eSTs80225SU55JLLklFRUXBWGVlZc4888ySaxo4cGDR2LPPPpsXXnihYKymtyTN9x4AAFqXdhuVvvet1+t/3/xX65+jrt5+o+5nl7/TcHW0ZK2lH/TC+1YuS57/S8PkKm+TbLJV8qEByUeHJ0O+npz4o+SkicnHv5hs3L1h7gEAAAAAAAAAAAAAAAAAAAAAAAAAAABoCK1lNndiPncpWks/6IX3mdUOAAAAAAAAAAAAAAAAAAAAAAAAtDTnnXdeLr300gbJdcMNN+S0005b575zzjknU6ZMqfd9VVVVOf3003PzzTfX+uyQIUNy8sknF4w999xzOeOMM9aZ43//939zxRVXFIx16NAh3bp1Kxh77LHHMnbs2FJLbZH23Xffou9bvnx5HnjggSatBwCA9UNrmc2dmM9ditbSD3rhfWa1AwAAAAAAAAAA0FAqmrsAAAAAAAAAAAAAGse1116bHXfcsUFyXXXVVfnQhz7UILneNWDAgJxzzjkZP358tdh+++2X3Xffvdr6bbfdlqOPPjpVVVVJkn322Sd//OMf065du7X2nXrqqbn99ttrvP+EE07IsGHDCsYefvjhXHzxxSW+pG7eeOONXHrppbn88surxdq3b5+LLrooJ510Uo05+vXrl2OOOaZofMKECXniiSdKrmnQoEFFY1OnTi0aq+ktSfO9BwCgtfrJqcm8WQ2fd+/PJgf8V8PnbSjtOpS+d+ni+t+39O3656irFcvqfnbVqoaroyVrLf2gF9Y24+ak735JWXnj5N9kq2S/LyR7HZU8fFvy51+sHhoPAAAAAAAAAAAAAAAAAAAAAAAAAAAAtAxmta/b+jybOzGfuxStpR/0wtrMagcAAAAAAAAAAAAAAAAAAAAAAABamgsuuCDPPPNMvv3tb2fLLbes9fkFCxbk7LPPzoQJE0rav2LFigwfPjzf+c53ctppp6WsrKzWd7700ksZNWpU7rnnnlqf3XzzzTNx4sSCscrKyowcOTJLliwpKdc3vvGNbLHFFhkxYkRJ+//xj39k+PDhWb58ecn1tkSDBw8uGps+fXrJv38AAK2VWe3rtj7P5k7M5y5Fa+kHvbA2s9oBAAAAAAAAAABoCI3019AAAAAAAAAAAABoTiNGjMgXv/jFBsm10047rTPX9OnTc/TRR2fLLbdMmzZt0rFjx+y6664577zzMm/evKLnLrroomyyySbV1gcNGlRw/9lnn52qqqr3Ps+cOTOTJ0+utu/AAw9Mu3btit67ww475KqrrioYW7JkSb7whS+ksrKy6PmGcvXVV+eFF14oGPvv//7v9O7du8bz48aNKzqcftGiRbngggtKrqVNmzY59NBDi8anTJlS4/ma3pI0/XsAAFqzlSuSysb4WtncL6tZedvS91Y2wM87WrG0/jnqakMcut3QWks/6IW1zXsxeaj6fyZocG3bJx87NhnxvaTTpo1/HwAAAAAAAAAAAAAAAAAAAAAAAAAAAFAas9rXbX2ezZ2Yz12K1tIPemFtZrUDAAAAAAAAAAAAAAAAAAAAAAAALdHNN9+c3r1755xzzsmjjz6aVSUMk3v55ZfzzW9+M3369MmECRNqdd/y5ctzxhlnZM8998wvfvGLLF68uKRzjz/+eE477bT07ds399xzT63ufNeECRPSo0ePgrFLL700M2fOLDnXypUrM3LkyJxyyil58803a9z3ox/9KPvss09efPHFWtfc0gwcOLBobMqUKU1YCQDA+sms9nVbn2dzJ+Zzl6K19INeWJtZ7QAAAAAAAAAAADSEiuYuAAAAAAAAAAAAgIbVu3fvXHfddQ2W76STTkp5eXnR+NixYzNu3Li11pYuXZonn3wyTz75ZCZOnJi77rore+65Z7Wz7du3z8iRI3PNNdestb7zzjtX2/vaa6/lhRdeqLY+ffr0HHfccWuttW3bNr17987TTz9dbX95eXluueWWdO7cueB7zjrrrDz77LMFYw1t+fLlGTNmTH75y19Wi1VUVOSSSy7JiBEjCp7dZ599csQRRxTNfdlll2XOnDkl17Lvvvuma9euBWPLli3LAw88UOP5mt6SNP17AACgRmUNkKIBctBC6IcNyvSfJF23SHY+qPHv6tknOe6q5ObTksXzG/8+AAAAAAAAAAAAAAAAAAAAAAAAAAAAgHozm5s16YcNilntAAAAAAAAAAAAAAAAAAAAAAAAQEv0zjvv5PLLL8/ll1+e7t2754ADDsiWW26Z7t27Z/PNN09VVVUWLlyY5557Lo8++mj+8Y9/1PvOxx57LMcee2zatWuXvffeOzvvvHO22267dO7cOe3atcuSJUsyZ86cPPfcc/nLX/6Sl19+ud53Dh06tN45Pui6667LT37ykwwZMiT7779/tt5661RUVGTevHl59NFHc/vtt+eVV15p8HtLNXr06IwePbpBcm222WYZMGBA0fjdd9/dIPfUpCHfAwBAC2U2N2vSDxsUs9oBAAAAAAAAAACor4rmLgAAAAAAAAAAAICG07Zt20yePDkbb7xxg+X89Kc/XTR28803Z9y4cTWef/311zNkyJD861//SpcuXarFTzrppFxzzTVrrXXr1q3avjlz5hTMX2x90003Lbh+3nnnZd999y0Yu+uuu/LDH/6wYKyx/OpXv8qf/vSn7LffftVixxxzTC677LI8+eST1WLjx48vmvPFF1/MlVdeWas6Bg0aVDQ2ffr0vPPOO+vMUdNbkqZ9DwAArU/litL3VrSr/30V7eufg8ajH1q33387mftC8on/TsrKG/euLpsnw8Ymvzgnqaps3LsAAAAAAAAAAAAAAAAAAAAAAAAAAAAACjGbmzXph9bNrHYAAAAAAAAAAAAAAAAAAAAAAACgJZs3b15+85vfNNl9y5cvz4MPPpgHH3ywye5saEuWLMmvfvWr/OpXv2ruUhrVYYcdlvLywoP0Xn311TzxxBNNXBEAAOsLs7lZk35o3cxqBwAAAAAAAAAAoD4a+a+eAQAAAAAAAAAA0JT+3//7fxkwYEC19YULF9YpX6dOnbLjjjsWjV966aUl5Zk9e3YmTpxYMNavX7907959rbU2bdpU27diReHJe8XWC+X46Ec/mosuuqjg/rlz5+b4448vGGtsZ555ZsH18vLygr/HBx98cA466KCi+caMGZNly5bVqoZBgwYVjU2ZMqXkPMXekjTtewAAaH1WLC19b4fO9b+v48b1z0Hj0Q/M/GXy41OT5x5q/Lu22SXZ49ONfw8AAAAAAAAAAAAAAAAAAAAAAAAAAABAIWZzsyb9gFntAAAAAAAAAAAAAAAAAAAAAAAAAKxvBg8eXDQ2derUJqwEAID1jdncrEk/YFY7AAAAAAAAAAAAdVXe3AUAAAAAAAAAAADQMAYNGpSvfe1rBWMnnXRSnXJuueWWKSsrKxibO3dunnnmmZJzTZ8+vWhswIAB6zxfXl74r7wVW/+gjh075pZbbklFRUXB+KhRozJnzpyScjW0mTNn5he/+EXB2PDhw/PRj350rbXx48fXmGvy5Mm1ur979+41fg/uvvvuknPV9Jakad4DAEDrtHxJ6Xu7bVX/+zbZuv45aDz6gSSZ+0Jy28XJhC8lM25J5r2YrFrVOHft8/mkTdvGyQ0AAAAAAAAAAAAAAAAAAAAAAAAAAABQE7O5WZN+IDGrHQAAAAAAAAAAAAAAAAAAAAAAAID1y8CBA4vGpk6d2oSVAACwvjGbmzXpBxKz2gEAAAAAAAAAAKibiuYuAAAAAAAAAAAAgPrbYost8tOf/jRlZWXVYjfccEN+9atf1SnvxhtvXDT25ptv1ipXTfsHDBiQu++++73PS5ZUn7LXuXPngmeLrS9evHitz1dccUX69u1bcO+ECRNyxx13FK2vKYwZMybDhw9Phw4dqsXGjRv33lDzoUOHZu+99y6a54wzzqj13YcddljB3kmSV155JU8++WSt8tX0lqTx3wMAQOtUuSJ5+42k82br3rvVTvW7q6y8/jloXPqBNb0xK5lx8+qvdhslPfskPXZINtkq6bpF0m3LpGvPpKJd3e/ovGnSa4/k+b80XN0AAAAAAAAAAAAAAAAAAAAAAAAAAAAApTCbmzXpB9ZkVjsAAAAAAAAAAAAAAAAAAAAAAAAALd3uu++enj17FoxVVlbm3nvvbeKKAABYn5jNzZr0A2syqx0AAAAAAAAAAIDaqGjuAgAAAAAAAAAAAKifsrKyTJo0KZtvvnm12FNPPZXTTz+9zrmrqqqKxjp16lSrXBtttFHR2A477LDW55deeqnanl69eqV9+/ZZtmzZWus777xzwZyzZs1679ef+tSn8uUvf7ngvueff75ev0cNZdasWbnqqqsyZsyYarHDDz88BxxwQB588MGMGzeuaI7JkyfnoYceqvXdgwcPLhqbOnVqrfPV9Jak8d8DAEDr9eYrpQ3r7tk76dIzeev1ut3Te++kfe3+SEQz0A8UsnxJ8tLfV3+tpWx1v3T7v2HuPXsn2++RdN++9Ny99jS8HQAAAAAAAAAAAAAAAAAAAAAAAAAAAGgeZnOzJv1AIWa1AwAAAAAAAAAAAAAAAAAAAAAAANASDRo0qGjsL3/5S+bPn9+E1QAAsD4ym5s16QcKMasdAAAAAAAAAACAdalo7gIAAAAAAAAAAAConzFjxuSQQw6ptr506dJ8/vOfzzvvvFPn3G+99VbR2FZbbZXNNtssb7zxRkm5dtttt6Kxrl27rvV5xowZOfnkk9daa9euXb7whS/kpptuem+tbdu2OfbYY6vle+GFFzJ37twkSffu3TNx4sSC91ZWVmbkyJFZvHhxSW9obOPGjcsJJ5yQzTffvFrssssuy3XXXZddd9214Nlly5ZlzJgxdbp34MCBRWNTp06tU86a3pI07nsAAGi9Xn8u2a74Hz3eU1ae7Dk0eeCGut2z99F1O0fT0g/rh/Ly5q7g/6xK3p63+uvlJ5Inpq1e/shByZCzk/I2606x+Q6NWyIAAAAAAAAAAAAAAAAAAAAAAAAAAABAMWZzsyb9sH4wqx0AAAAAAAAAAAAAAAAAAAAAAAAAkhdeeCEXXXRRwdjMmTObuBoAANZHZnOzJv2wfjCrHQAAAAAAAAAAgJamorkLAAAAAAAAAAAAoO723XfffOtb3yoYO+OMM/LEE0/UK/9LL72UFStWpG3bttVi5eXl+dKXvpTx48evM0/btm0zatSoovEuXbqs9fmOO+7I22+/nc6dO6+1fs0116Rz58554IEHstlmm+X8889Pnz59quW75ZZb3vv1hAkT0rNnz4L3XnbZZXnooYfWWX9TWbRoUS644IL88Ic/rBb7+Mc/nn79+hU9e+WVV+bFF1+s9Z39+/dPjx49CsYqKytz77331jpnUvNbksZ7DwAArduLjyZ7HVna3gHDkqf+kMx5vnZ37HFEss0uta+Npqcfms/yd0rf27HLuvc0p6fvT3ruUNqQ/o26Nn49AAAAAAAAAAAAAAAAAAAAAAAAAAAAAIWYzc2a9EPzMasdAAAAAAAAAAAAAAAAAAAAAAAAAGrnl7/8ZXOXAADAes5sbtakH5qPWe0AAAAAAAAAAACsz8qbuwAAAAAAAAAAAADqpkuXLvn5z3+eioqKarHbbrst119/fb3vWLlyZf72t78VjV944YX5xCc+UWOOsrKyXHfddendu3fRPV27rj3dbOHChRk/fny1fZ06dcrVV1+dv//977n//vtz6KGHVtvz2muv5corr0ySnHjiiRk6dGjBO//617/mm9/8Zo21N4cbbrihaOyDv0/vmjNnTi677LI63Tdo0KCisZkzZ2bBggV1ypusfstTTz1VNN4Y7wEAoHV76e/JimWl7W1TkXzmwqTrFqXn7/Ox5OAv1a02mp5+aD5L3y5975Yfbrw6Ktone302OfTU+uV58bHS9nXYuH73AAAAAAAAAAAAAAAAAAAAAAAAAAAAANSV2dysST80H7PaAQAAAAAAAAAAAAAAAAAAAAAAAAAAAJqW2dysST80H7PaAQAAAAAAAAAAWJ+VN3cBAAAAAAAAAAAA1M2NN96YXr16VVufNWtWTjzxxAa759Zbby0a69ChQ6ZNm5bzzz8/Xbt2rRbfY489Mm3atHXW06ZNm2pr48ePz/3331+rWquqqjJixIi8+eab6d27d77//e8X3LdkyZKMGDEilZWVSZLNNtsso0aNysSJEzN16tTce++9mTx5cr7xjW9kp512qlUN9VVVVVXrMxdccEEWLVpUp/sGDx5cNDZ16tQ65XxXVVVVzjrrrFqfq897AABo3VYsS/75x9L3d+2ZjLwy+chBNe9r0zb5+BeT4WNX/5r1g35oPssWl75354Mafuh5Rbvko59JTv5JctCoZM8jkt771j1fVWVp+1aVuA8AAAAAAAAAAAAAAAAAAAAAAAAAAACgoZnNzZr0Q/Mxqx0AAAAAAAAAAAAAAAAAAAAAAAAAAACgaZnNzZr0Q/Mxqx0AAAAAAAAAAID1WUVzFwAAAAAAAAAAAEDtjRo1KkcffXS19crKyhx77LFZsGBBg91144035sILL8zGGxeepNauXbtceumlufjii/PEE0/k9ddfT7t27dKnT59su+22db531apVGTZsWCZNmpShQ4euc//ChQszcuTI3H///SkvL8+kSZPSuXPngnvPPPPMPPvssykrK8vYsWNz7rnnpmPHjtX2fe5zn8v48eNz2223ZdSoUZk/f36d31Mb99xzTw4//PCS9j7xxBO58cYb63RP586d87GPfaxofOrUqXXK+8EcTfUeAABIkkd/l/Q7rPT9nTZJjhiTHPDF5LmZyRuzkiUL3o9tsWPS52PJRl0bpVwamX5oHiuXJW/NSbr0WPfeDhsnn70kuX1csmhe/e5t0zbpPyTZ53NJ503Xjg39RnLH+OT5mbXPu66B/u9atqT2uQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAaitncrEk/NA+z2gEAAAAAAAAAAAAAAAAAAAAAAAAAAACantncrEk/NA+z2gEAAAAAAAAAAFifVTR3AQAAAAAAAAAAANTORz7ykVx11VUFYxdeeGH+9Kc/Neh9CxYsyNixY4ve+a6Kior079+/Qe9etGhRhg0bltGjR+cb3/hGtttuu2p7Vq5cmd/+9rcZM2ZM/v3vfydJzj///Oy7774Fc9511125/vrr07Fjx9x2220ZNGjQOus48sgjM2DAgHzqU5/KU089Vb9HleDMM8/M448/njZt2pS0t6qqqk73HHLIIWnbtm3B2BtvvJGHH364Tnk/qKneAwAASTL7mdVDt/vsU7tz3bZMPjq8UUqiGemH5vPK06UNb0+SrT6SfOmm5Pm/rP6eLX07WbWq8N5nZiTvLFx7rU3bZPfByb7HVB/a/q62HZKjvpk8/UDy19tW37MunTZJPnZsstvA0t6x4LXS9gEAAAAAAAAAAAAAAAAAAAAAAAAAAAA0BrO5WZN+aD5mtQMAAAAAAAAAAAAAAAAAAAAAAAAAAAA0LbO5WZN+aD5mtQMAAAAAAAAAALC+qmjuAgAAAAAAAAAAAChd+/btM3ny5Gy00UbVYvfff3/Gjx/fKPdec801OfjggzNs2LA651i6dGk6dOhQMLaq2ES2/3PdddfluuuuS//+/dOvX79suummWbZsWWbNmpU///nPmT9//nt799prr1x44YUF88ydOzfHH398ktVvGjRoUMn1b7/99vntb3+bPfbYI4sXLy75XF08+eSTmThxYk466aQa902ZMiXTpk2r8z2DBw8uGps2bdo6vy+laqr3AADAux64IfnQgKSNfzlD9ENzefmJ5COfLH1/m7ZJ3/1Xf9Vk9jPVh7d/4vhkryNLu+cjB67+WrIgmf1c8tbrybLFycrlSVl5UtFu9dD2zbZLeuyQlLcp/Q2v/rP0vQAAAAAAAAAAAAAAAAAAAAAAAAAAAACNwWxu1qQfmodZ7QAAAAAAAAAAAAAAAAAAAAAAAAAAAABNz2xu1qQfmodZ7QAAAAAAAAAAAKyv/JVDAAAAAAAAAACA9ciVV16Zfv36VVufN29eRowYkVWrVjXKvatWrcoxxxyTX/7ylzniiCNqff6VV17JmDFjMmnSpILxRYsWlZTnsccey2OPPVY03rFjx0yaNCkVFYX/etyoUaMyZ86cDB48OCeeeGLBPXPnzs3ixYuz/fbbp6ysbK3YjjvumMsvvzynnHJKSfXWx9ixY3PMMcdk4403LhivrKzMWWedVa87Bg4cWDQ2ZcqUeuX+oKZ4DwAAvOvNl5P/nZAcfHJzV0JLoB+ax9MPJAeOStq2b/y7HvltsufQ2g3o36hbssNHG7aO5/7csPkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAastsbtakH5qHWe0AAAAAAAAAAAAAAAAAAAAAAAAAAAAATc9sbtakH5qHWe0AAAAAAAAAAACsr8qbuwAAAAAAAAAAAABKM3z48IwePbpg7L/+67/y2muvNer9S5cuzfDhw/P1r38977zzTsnn7rzzzuy333559dVXi+556623GqLEXHnllenbt2/B2I033pg77rgjSXLOOedUi1dVVeW4445Ljx498qEPfSj9+vXLyy+/XG3fCSeckE033bRB6q3JnDlzcuuttxaN/+EPf8jTTz9d5/x9+/ZNr169isbvueeeOucupLHfAwAAH/Twb5J//rG5q6Cl0A9Nb+mi5Ml7m+aut+as/h43p1mPJ/NebN4aAAAAAAAAAAAAAAAAAAAAAAAAAAAAABKzuVmbfmh6ZrUDAAAAAAAAAAAAAAAAAAAAAAAAAAAANA+zuVmTfmh6ZrUDAAAAAAAAAACwvipv7gIAAAAAAAAAAABYt2233TYTJ04sGLvrrrsye/bs7LnnnjV+FbPFFluUvLeqqirf/e5306tXr1xyySV56qmnsmrVqmr75s+fn5/+9Kc57LDD8ulPfzqzZs3KJptsUjTvwoULa3h9aYYMGZKTTz65YOz555/PGWeckSTp2rVrDjjggGp7fvazn2XSpEnvfX7yySdz9tlnV9vXvn37DBo0qN71lmLZsmV1ipVi4MCBRWOPP/54Zs+eXa/8hTTmewAAoJDffzt59k8Nn/fNV5J/P9zweWlc+qHpzbglWbKgae76403JK083zV0fVLkiue+HzXM3AAAAAAAAAAAAAAAAAAAAAAAAAAAAQCFmc7Mm/dD0zGoHAAAAAAAAAAAAAAAAAAAAAAAAAAAAaB5mc7Mm/dD0zGoHAAAAAAAAAABgfVTe3AUAAAAAAAAAAACwbl//+tezySabFIx96lOfyiOPPLLOr2JGjhy51r77779/nfXMmTMnF110UXbZZZd069Ytu+++ew444ID0798/PXv2zGabbZb/+q//yr333vvemb59+xbNN3v27HXeWZPu3btnwoQJBWOVlZUZMWJEFi9enCTZdddd06ZNm2r77rzzzpLWkmSPPfaoR7Utw+DBg4vGpk6d2oSVAABA46mqTH57afKXWxsu5+vPJ784J1k8v+Fy0jT0Q9Nb/Gby++8kq6oa/65VVclvLk5ef67x7/qgaf+TzH2h6e8FAAAAAAAAAAAAAAAAAAAAAAAAAAAAKMZsbtakH5qeWe0AAAAAAAAAwP9n796jq67O/PE/CSckgQDhIljECyCgIPUGFbUgggjo4PXreAEdBVqr7aitnY632gIi3+rYWv1VrQq2FXRabeugQEBRKKCCd62tCmgFFQnKRQEh198ffGtDc05uJDnJ8HqtddbIfp797PfHtbuWs1bdBQAAAAAAAAAAAAAAAAAgPbzNTUXuQ+PzVjsAAAAAAAAAAADNUSLdAQAAAAAAAAAAAKheVlZWo521cuXKWvV/9tln8frrr1fbd/TRR6esvfTSS7U685/NmDEjunTpkrQ2derUWL58+Zd/3meffZL2rVmzptLa1q1bY/PmzZGfn7/beufOnesetgnIzs6OoUOHpqwXFBQ0XhgAAGhg5WURi+6PeP+ViGHfiui4f93nvDQ74k8PRJTsjMjMrNm+stK6nUfDcB8a399e3vWA++jvRSRaNuxZ27dEPPyDiDHXRPT8WsOeFRFRWhzx5P8X8fr8hj8LAAAAAAAAAAAAAAAAAAAAAAAAAAAAoLa8zU1F7kPj81Y7AAAAAAAAAAAAAAAAAAAAAAAAAHujiy66KA466KCktV/96lexZs2axg0EAMBeydvcVOQ+ND5vtQMAAAAAAAAAANDcJNIdAAAAAAAAAAAAgKZl5cqV9T4zKysrRo4cmbL+8ssv13n2xIkTY8yYMUlrL7zwQkyePHm3tZYtk78Ut3Pnzhqvp5rRXAwePDhyc3OT1rZu3RrLli1r5EQAANDw3nspYsalEf2GR/Q/OaLbYREZGdXvK9oe8daSiBWPRGz84B/rLZP/I3UlJcn/Xw3SzH1oXH9dFLF+dcSwSyN6DGjYs4q2R/z+xohDTth1Xl6Hhjnn3Rcjnrk34lP/u2QAAAAAAAAAAAAAAAAAAAAAAAAAAABAE+dtbipyHxqXt9oBAAAAAAAAAAAAAAAAAAAAAAAA2NtccsklMXTo0KS1RYsWxZo1HrQDAKDxeJubityHxuWtdgAAAAAAAAAAAJqTRLoDAAAAAAAAAAAA0LSsXLmy3mdOnDgx2rRpk7S2YcOGWL16dZ3m9uzZM26//fakte3bt8fYsWOjtLS0TrP/Nxs9enTK2tNPPx3FxcWNmAYAABpPeVnEn5/c9WvdIaLrIRH79opo1T4iJy+iRSKieGfEzq0Rmz6KWPf2rl9pkn9Ezs6r2ZlFX9TvN1B/3IfGtXFtxKM3RHQ6aNej+QcdGdG5R0RGZsOc99biiHeWRfQ5PuKIMRH7HRqR2WLPZu7cFrF6ecTrCyLWvFovMQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAahbe5qch9aFzeagcAAAAAAAAAAAAAAAAAAAAAAAAAAABIH29zU5H70Li81Q4AAAAAAAAAAEBzkUh3AAAAAAAAAAAAAJqWlStXVtszfPjwuPTSS2Pnzp1x4YUXVtnbo0ePmDx5csr6zJkza50xIiIzMzNmzpwZrVu3Tlr/7ne/m/RbioqKkvbn5OTUeH3nzp21SNr0jBo1KmWtoKCgEZMAAFBTM7+b7gQRKx7Z9atvnxVG3JL6H1EbzLaNESuf3fWriw7datb3+Sc162usvw/zbtv1qw8Nkdl9aJ53oTY++VvE4ukRiyMi0XLX37s2nXY9mp9oGZHIqnp/Tf8zFRFRVhLx18W7ftmtI/b/asR+fSPad931y+sYkZWz69y/Ky/b9ch+0RcR2zdHfPJ+xIa/RWx4N2LN68kf7wcAAAAAAAAAAAAAAAAAAAAAAAAAAAAajrfa619Teps7onm+z+2t9n/wVnvNeasdAAAAAAAAAAAAAAAAAAAAAAAAAAAAqA1vtde/pvQ2d0TzfJ/bW+3/4K32mvNWOwAAAAAAAAAAAE1dIt0BAAAAAAAAAAAAqN4LL7wQ+fn5ezTjvPPOS7r+9ttvxyuvvLLbWcl07tw5LrnkkvjmN78ZPXr0+HJ948aN8Z//+Z+xY8eOSnuGDh0av/rVr6JTp04pc91///01/YTd3HDDDTFo0KCktTlz5sS9996btLZ+/fqk6wceeGAsW7Zst7V27dpFu3btajyjOejWrVv07ds3ZX3+/PmNmAYAAJqn1h0i8jrUrPezwobNQvq5D3VXUhRR+O6uX0PbuS1i1XO7fv8sI3PXo/Hl5bsyAQAAAAAAAAAAAAAAAAAAAAAAAAAAAJCct7mpyH2oO2+1AwAAAAAAAAAAAAAAAAAAAAAAAAAAADQv3uamIveh7rzVDgAAAAAAAAAAQFOUSHcAAAAAAAAAAAAAqjdjxoyYMWPGHs0477zzkq4//vjj8R//8R9V7v33f//3uO222yIrK6tS7Yorrojx48fHk08+GWvWrInPP/88OnfuHMcdd1wcdthhVc6dM2dO/OUvf6n5R/w/AwcOjB/+8IdJaxs2bIjx48en3PvnP/85SkpKIpHY/b9Cd8YZZ8RDDz2029ppp52WdMZLL71Uy8RNx8iRI1PWVq5cGe++2wgv5gEAQDPXZ3DNe9evbrgcNA3uQ/NXXhZRvDPdKQAAAAAAAAAAAAAAAAAAAAAAAAAAAACaPm9zU5H70Px5qx0AAAAAAAAAAAAAAAAAAAAAAAAAAACgZrzNTUXuQ/PnrXYAAAAAAAAAAAAqykx3AAAAAAAAAAAAAJq+xYsXRyKRSFnPy8uLM888M6688sq44YYb4pvf/GYcdthhVc787LPP4tJLL611llatWsWsWbNS5pkwYUIUFham3P/555/HwoULK63/n//zf+I73/lOtGjRIiIijj/++Piv//qvSn3bt2+PgoKCWuduKkaPHp2yNn/+/EZMAgAAja9VfsSQSyIio+4zMjIjjjy15v0fv133s2hY7gMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAewtvc1OR+wAAAAAAAAAAAAAAAAAAAAAAAAAAAADA3sLb3FTkPgAAAAAAAAAAAADJJNIdAAAAAAAAAAAAgKbv9ddfj5///Odx1VVX1dvM73znO/Hhhx/Wet9Pf/rT6NWrV9LafffdF48//ni1M6ZNmxYnn3xyZGT844W+jIyMuPPOO+PWW2+NHTt2RH5+ftK9v/jFL+Kzzz6rde6mIDMzM4YPH56yPm/evEZMAwAAjavbYRGnXReR12HXg9uLp9dtzqBzIzoeULPeTR/t+tH0uA8AAAAAAAAAAAAAAAAAAAAAAAAAAAAA7C28zU1F7gMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAewtvc1OR+wAAAAAAAAAAAACkkpnuAAAAAAAAAAAAADQPP/jBD2LevHl7PKesrCyuvPLKePDBB2u999RTT41LL700aW3VqlVx1VVX1WjO4sWL46c//WnSWk5OTuTn5yetvfrqq3HDDTfU6IymaNCgQSm/raioKBYtWtSoeQAAoLF87ZyI836y66HuiIhjzokYdumuR7tr46jTIr5+Uc3731lWu/k0DvcBAAAAAAAAAAAAAAAAAAAAAAAAAAAAgL2Ft7mpyH0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAYG/hbW4qch8AAAAAAAAAAACAqiTSHQAAAAAAAAAAAIDmobi4OM4444y45ZZb4oorroiMjIxaz1i7dm1MnDgxFixYUOu9++yzT8yYMSNprbS0NMaNGxfbt2+v8bxrrrkm9t133xg7dmyN+t94440444wzoqioqMZnNDWjR49OWVuyZEmt/v4BAEBzkJ0Xcer3Iw4eVLk24MyIg46KWP5IxKrnInZuSz4js0XEfv0ijjs/4sAja352eXnEa3PrlpuG4T4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAsLfwNjcVuQ8AAAAAAAAAAAAAAAAAAAAAAAAAAAAA7C28zU1F7gMAAAAAAAAAAABQE4l0BwAAAAAAAAAAAKD5KCoqiquuuip+9atfxX/+53/GmDFjonXr1tXue+2112L69Olx3333xY4dO+p09vTp06Nz585JazfddFMsX768VvNKSkpi3LhxsWzZsrjpppuiQ4cOKftmzJgRV111VXzxxRe1zt2UjBw5MmVt3rx5jZgEAAAaXpeDI06/ISJ/39Q9nQ7c9Zh3eVnEpo8iPiuMKPoiorQkIis7olW7XT0tW9X+/L8ujti8ru75qV/uAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAB7C29zU5H7AAAAAAAAAAAAAAAAAAAAAAAAAAANq2XLlvHVr341+vbtG506dYrWrVtHaWlpbNmyJTZt2hR/+ctf4o033ojS0tIGOb93794xYMCA6NatW2RnZ8eWLVtiw4YN8fzzz8d7771XL2e0b98+jjnmmOjVq1e0a9cuvvjiiygsLIy33347XnjhhSgvL6+XcwAAYE95m5uK3AcAAAAAAAAAAACgphLpDgAAAAAAAAAAAEDjyMjIqLdZr776apx//vnRsmXL+NrXvhZ9+/aNAw44IPLy8qJly5axffv2KCwsjFWrVsWKFSvigw8+2OMzTzvttHpIXtndd98dv/71r+PUU0+N448/Pvbbb79IJBLxySefxCuvvBL/8z//Ex9++GGDnF2dyy67LC677LJ6mdWxY8c4+uijU9bnz59fL+dUpT6/BwAAqtL/5IgR34lItKxZf0ZmRIduu371oXhHxJJf1c8s9pz7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDewtvcVOQ+AAAAAAAAAAAAAAAAAAAAAAAAAEDDGThwYFx99dVx6qmnRl5eXpW927dvjzlz5sQdd9wRS5curXb2PffcE0cffXSl9euuuy6efPLJiIi44IIL4vrrr4++ffumnPP222/HzTffHDNnzoyysrJqz/1nX//61+O6666LESNGRCKRSNpTWFgY9913X0ybNi22bdtW6zMAAKC+eJubitwHAAAAAAAAAAAAoDaS/9tTAAAAAAAAAAAAUANFRUWxdOnSGj1C3pRt3749HnnkkXjkkUfSHaXBjBgxIjIzM5PWPvroo/jzn//cyIkAAKDhlJXW/KHuhrBoesSWj9N3PrtzHwAAAAAAAAAAAAAAAAAAAAAAAAAAAADYW3ibm4rcBwAAAAAAAAAAAAAAAAAAAAAAAACof/n5+XHXXXfF+eefX+M9rVq1inPOOSfOOeecmDlzZlx22WWxdevWlP19+vSJAQMGVFpv3759dOzYMR544IEYM2ZMtef26dMnfv3rX8f48ePjzDPPjE2bNtUob05OTtx5550xceLEans7d+4c119/fVx88cVxyimn1Gg+AAA0BG9zU5H7AAAAAAAAAAAAANRGZroDAAAAAAAAAAAAAA1v9OjRKWsFBQWNmAQAABremwsj/vJ0es5+fX7EK4+n52yScx8AAAAAAAAAAAAAAAAAAAAAAAAAAAAA2Ft4m5uK3AcAAAAAAAAAAAAAAAAAAAAAAAAAqF/dunWL559/Ps4///w6zxg3blw8/fTTkZOTU+u9bdq0iYKCghgzZkyt9p1wwgmxZMmSyM3NrbY3Jycn5syZExMnTqzVGfvtt18sWrQoevToUat9AABQX7zNTUXuAwAAAAAAAAAAAFAbmekOAAAAAAAAAAAAADS8kSNHpqwVFBQ0YhIAAGgcc2+LWL2icc/8y9MR83/euGdSM+4DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHsLb3NTkfsAAAAAAAAAAAAAAAAAAAAAAAAAAPWjVatWUVBQEH369NnjWQMHDoxf/OIXtd53yy23xIABA+p0Zr9+/eLOO++stu+uu+6KYcOG1emM9u3bxwEHHFCnvQAAUB+8zU1F7gMAAAAAAAAAAABQU5npDgAAAAAAAAAAAAA0rMMPPzy6dOmStFZaWhpPPfVUIycCAICGV1Ya8cfJEa883jhnLX0w4olbIsrLGv48as99AAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBv4W1uKnIfAAAAAAAAAAAAAAAAAAAAAAAAAKB+TJo0Kfr161dv8y6++OLo3bt3rfZ06NBhj84cP3589OrVK2X9pJNOiksuuWSPzgAAgHTyNjcVuQ8AAAAAAAAAAABATSXSHQAAAAAAAAAAAABoWKNGjUpZW7FiRWzatKkR0wAAQOMpK4l48hcRf3sl4sRvRuTvW/9nfPTXiIX3RKx7u/5nU7/cBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2Ft7mpiL3AQAAAAAAAAAAAAAAAAAAAAAAAAD2XHZ2dpSUlEQikahUe+655+L++++Pl19+OQoLCyMrKysOPfTQuOqqq2LkyJFJ52VmZsbll18eV111VZ0zrV+/PubOnRsffvhhtG7dOgYNGhTHHntsyv6MjIz49re/nfLMadOmVXvm22+/HYsWLYrCwsJo3759DBo0KAYMGFDXTwAAgHrnbW4qch8AAAAAAAAAAACAmqj8b40BAAAAAAAAAAAA/6u899578aMf/Shpbfny5Y2cBgAAGt/KZyPefSGi37CIr46O6HrIns0rLYn428sRL8+OeO/F+slI43EfAAAAAAAAAAAAAAAAAAAAAAAAAAAAANhbeJubitwHAAAAAAAAAAAAAAAAAAAAAAAAAKi7K664Iu68886YMmVK/Ou//mtkZGRERMT//b//N6699tpK/e+//34UFBTEf//3f8e5556bdOaJJ55YpyxlZWUxZcqUuOmmm6KkpGS32mmnnRa/+93vIjs7O+ne4cOHJ10/8sgjY8CAASnP3LJlS0yYMCF+//vfV6oNHjw4Hn744dhvv/1q8RUAANCwvM1NRe4DAAAAAAAAAAAAUJVEugMAAAAAAAAAAAAADet3v/tduiMAAEDalRZHvD5/169t54j9+0fs1y+iw34R+V+JyGkbkZUd8f/+t5m+VLwj4vNPIz4rjChcFfHRWxF/eyWiaHt6voP64T4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAsLfwNjcVuQ8AAAAAAAAAAAAAAAAAAAAAAAAAUHcrV66M8847L6ZNmxY333xzZGVlxbXXXlvlnuuuuy7OPffcpLX+/ftHTk5O7Nixo1Y5fvSjH8VNN92UtDZ79uyYOnVqTJ48OWm9X79+kZeXF1u3bt1tfcyYMSnPKy4ujpNPPjlWrFiRtL5kyZIYMmRIvPrqq9GmTZsafgUAADQ8b3NTkfsAAAAAAAAAAAAApJJIdwAAAAAAAAAAAAAAAABoTJ8VRry5cNfvnyVa7nqwu7w8oqSo8bPR+NwHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPYW3uamIvcBAAAAAAAAAAAAAAAAAAAAAAAAAOrmtddei1NPPTVatmxZbe+7774bH330UXTt2rVSLSMjIzp27Bgffvhhjc9+//33Y+rUqVX23HPPPTFp0qTIyMhIemaXLl1i69atu62fcMIJKefNmDEjVqxYUeWZ7777bvz4xz+O2267rco+AABIF29zU5H7AAAAAAAAAAAAAFSUme4AAAAAAAAAAAAAAAAA0FSUFEUU7/RQN7u4DwAAAAAAAAAAAAAAAAAAAAAAAAAAAADsLbzNTUXuAwAAAAAAAAAAAAAAAAAAAAAAAABUr6io+of72rVrF5999lnKeocOHWp15sMPPxzl5eVV9mzYsCH+9re/1erMQw45JGX/zJkza5TtwQcfjJKSkhr1AgBAU+JtbipyHwAAAAAAAAAAAGDvk0h3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA5qRFixbRvXv36NGjR3Tv3j169uz55V/36NEj8vPzq9yflZVVq/P+/Oc/16jv448/ju7duyet5ebm7vbnFi1aRNeuXZP2lpeXx0svvVSjMzds2BBvvfVWHHbYYTXqBwAAAAAAAAAAAAAAAGgKEukOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQ1PXs2TMuvPDCOPXUU6N///6RnZ3daGevX7++Rn07d+6s8czWrVunrG3dujW++OKLGs/6+OOP47DDDqtxPwAAAAAAAAAAAAAAAEC6JdIdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgqcrLy4vbb789Lr744mjRokVaMhQVFdX7zJycnJS17du312rWxo0b9zQOAAAAAAAAAAAAAAAAQKNKpDsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBT1KlTp1i8eHH07ds33VGatPLy8nRHAAAAAAAAAAAAAAAAAKiVRLoDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0RY8++mj07du3xv2ffPJJrF69OlatWhUjRoyIzp07N2C6PbNz586UtZycnFrNatu27Z7GAQAAAAAAAAAAAAAAAGhUiXQHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABoasaMGRMnnHBCyvq7774bjz/+eKxYsSLeeuutWL16dWzZsuXL+osvvhidO3dujKh1sm3btpS1tm3bRiKRiJKSkhrN6tKlS33FAgAAAAAAAAAAAAAAAGgUiXQHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABoasaNG5eyduONN8aUKVOq3N+mTZv6jlSvSkpKYv369dGlS5dKtYyMjDj88MPjpZdeqnZOTk5O9OnTpyEiAgAAAAAAAAAAAAAAADSYRLoDAAAAAAAAAAAAALUzfvz46NWrV9LajBkzYuXKlY2cCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOB/n0GDBiVdX7duXUyZMqXKvbm5udG9e/eGiFWvVq5cGV26dElaO/vss+Oll16qdsZpp50WrVu3ru9oAAAAAAAAAAAAAAAAAA0qke4AAAAAAAAAAAAAQO2cf/75cdJJJyWtPfPMM7Fy5cpGTgQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADwv0/nzp2Trq9Zs6baveecc05kZWXVd6R6t3Tp0vj617+etHb55ZfHvffeG3/7299S7s/Ly4tp06Y1UDoAAAAAAAAAAAAAAACAhpOZ7gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE1NaWlp0vX+/ftHx44dU+7r1q1b3HLLLQ0Vq17NnTs3Za1du3axYMGCOPTQQ5PW99lnn3j88cejR48eDRUPAAAAAAAAAAAAAAAAoMFkpjsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBT8/HHHyddb9WqVRQUFMQxxxyz23p2dnacd955sWLFiujSpUtjRNxjS5YsiXfeeSdlvVevXvH666/Hww8/HBMnTozTTjst/u3f/i3uuuuuWLVqVQwdOrTxwgIAAAAAAAAAAAAAAADUo0S6AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANDVLliyJnj17Jq0NGDAgnn/++fj000/jgw8+iJycnDjwwAMjJyenkVPuuUmTJsWsWbNS1hOJRJx33nlx3nnnNWIqAAAAAAAAAAAAAAAAgIaVme4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABNzW9+85tqezp27BiHH3549OnTJ3JycnarlZWVRUlJSUPFqzcPPfRQLFy4cI/nNIdvBQAAAAAAAAAAAAAAAPi7zHQHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABoap555pmYPXt2nfdfffXV8cknn9RjooZzwQUXxKpVq+q8/yc/+cke7QcAAAAAAAAAAAAAAABobJnpDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0BRdcMEF8dxzz9VqT3FxcVx33XVx++23N0yoBlBYWBhDhgyJ559/vtZ777zzzrjmmmsaIBUAAAAAAAAAAAAAAABAw8lMdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgKZo27ZtMXjw4Ljxxhtj48aN1fYvXrw4BgwYENOmTWuEdPVr3bp18fWvfz2+853vxIcfflht/2uvvRbDhg2LK664ohHSAQAAAAAAAAAAAAAAANSvRLoDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0VaWlpTFlypS49dZbY9iwYXHsscdGt27dIj8/P0pLS+OTTz6JN954IxYsWBArV67cbe9XvvKVGp9z4okn7nHWPZ1RWloav/jFL+Kuu+6KIUOGxPHHHx99+vSJdu3axRdffBHr1q2L999/P+bOnVvpWw899NA9OhsAAAAAAAAAAAAAAACgMSXSHQAAAAAAAAAAAACqk5ubG0cddVT069cvOnbsGG3atInS0tLYvHlzbN68Of7yl7/Eyy+/HDt37mywDP369YtjjjkmunXrFrm5ubF58+YoLCyMFStWxJtvvlkvZ3Tu3DmOPfbYGDhwYOzYsSMKCwvjrbfeimXLlkVpaWm9nAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABA3ezYsSPmzp0bc+fOTXeUBldeXh6LFy+OxYsXpzsKAAAAAAAAAAAAAAAAQINIpDsAAAAAAAAAAAAApDJ48OD43ve+FyNHjozc3Nwqe4uLi2P+/Plxxx13xJNPPlmj+TNmzIiBAwdWWr/mmmtizpw5ERExbty4uOGGG6JPnz4p56xZsyamTZsW999/f5SUlNTo7IqGDRsW119/fQwdOjQyMzMr1Tdv3hwzZsyIyZMnx5YtW2o9HwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+IfMdAcAAAAAAAAAAACAf9apU6f4wx/+EH/605/ijDPOiNzc3Gr3ZGVlxb/8y7/EggUL4ve//33k5+dXu6d79+5x2GGHVfq1a9cuOnXqFE888UQ8+OCD0adPnyrnHHDAAXH33XfHsmXLonPnzjX9zMjNzY1f//rXsXDhwhg2bFhkZib/r/Xl5+fH9773vXjnnXdiwIABNZ4PAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUlkh3AAAAAAAAAAAAAKjooIMOioULF0aPHj3qPOOss86Kgw8+OI477rjYtm1brfe3bds25s+fH0cddVSt9n3ta1+LZcuWxVFHHRWff/55lb25ublRUFAQQ4YMqfH8zp07x9NPPx2bNm2qVS4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOAfMtMdAAAAAAAAAAAAAP6udevWMW/evOjRo8cez/rqV78a9957b532Tps2LY466qg67T344INrdO4999wTQ4YMqfX8Nm3axAEHHFCXaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQERkpjsAAAAAAAAAAAAA/N1NN90UhxxySL3NO//886Nfv3613pefn79H55533nnRv3//lPWTTz45Lrrooj06AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqJtEugMAAAAAAAAAAABARcXFxZGVlVVpfenSpXH//ffHyy+/HOvXr49EIhGHHnpoXHnllTFmzJikszIyMuLb3/52XH755XuUad26dTFnzpxYu3Zt5OXlxTHHHBNDhgypcs+///u/xze/+c2ktZtvvrnKvX/961/jmWeeiY8//jjat28fgwYNimOPPbbO+QEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgH9IpDsAAAAAAAAAAAAA/N13v/vduOOOO2Ly5MlxwQUXRGZmZkRETJ06NW644YZK/R999FEsXLgwfvOb38SFF16YdObQoUPrnKesrCwmTZoUU6dOjdLS0t1qI0eOjD/+8Y+Rm5ubdO+wYcOSrh911FFx9NFHpzxz06ZN0bdv30rrxxxzTPz2t7+NAw88sBZfAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/LPMdAcAAAAAAAAAAACAit5777248MIL46tf/Wo89thjsWDBgrjhhhuq3HP99denrB166KGRl5dXpyw//vGPY/LkyVFaWlqpNn/+/Jg0aVLKvT179oyOHTtWWj/ttNNS7ikqKoqTTz45aW358uUxePDg2Lx5c/XBAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlDLTHQAAAAAAAAAAAACSefPNN+PMM8+Mf/mXf6m2d+3atfH++++nrHfs2LHW569duzZuuummKnvuu+++KCsrS1nfd999K60NGTIkZf/06dPjxRdfrDLTtddeW2UmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgapnpDgAAAAAAAAAAAABVKS4urranY8eOsXXr1pT1Dh061Prc//7v/47y8vIqezZu3BirVq2qMtc/69OnT8r+WbNmVZvr4Ycfjp07d1bbBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJJdIdwAAAAAAAAAAAACoTiKRiIMPPji6d+8ePXr02O3XvXv3aNOmTZX7s7Kyan3mm2++WaO+9evXR+/evZPWcnJydvtzixYtomvXrkl7y8vL46WXXqr2vC1btsTrr78eAwcOrFE+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgd4l0BwAAAAAAAAAAAIBkevfuHRdddFGccsop0a9fv2jZsmWjnr9+/foa9e3cubPGM1u3bp2ytnXr1tixY0eN5nz88cc1PhMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANhdIt0BAAAAAAAAAAAAoKI2bdrEHXfcERdddFFkZmamLUdRUVG9z8zJyUlZ2759e43nbNy4sT7iAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAXimR7gAAAAAAAAAAAADwd507d47FixfHIYccku4oAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAD2G+//WLChAlJa+Xl5TF16tQoKytr5FQAAAAAAAAAAAAAAADA3iaR7gAAAAAAAAAAAADwd48++mgccsghNe7/9NNPY9WqVbFq1aoYPnx47Lvvvg2Ybs/t3LkzZS0nJ6fGc9q2bVsfcQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACg0Z199tkxadKkpLVXX301pkyZ0siJAAAAAAAAAAAAAAAAgL1RIt0BAAAAAAAAAAAAICLi9NNPj8GDB6esr1q1Kp544ol44YUX4u23347Vq1fH5s2bv6w///zzse+++zZC0rrbtm1bylrbtm0jkUhESUlJtXOa+ncCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQCqjR49OWSsoKGjEJAAAAAAAAAAAAAAAAMDeLJHuAAAAAAAAAAAAABARMXbs2JS1G2+8MaZMmVLl/jZt2tR3pHpXUlIS69evjy5dulSqZWRkxOGHHx4vvfRSlTNatmwZffv2baiIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPwvkpubG8ccc0wcdthh0adPn2jXrl20bds2IiK2bt0aW7ZsiVWrVsUbb7wRy5cvj88//7xB82RnZ8cJJ5yQsl5QUFCnuU3tOwEAAAAAAAAAAAAAAICmL5HuAAAAAAAAAAAAABARMWjQoKTrhYWFMWXKlCr3ZmdnR8+ePRsiVr175513okuXLklr55xzTrz00ktV7j/11FOjXbt2DRENAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoFH16tUrRo0aFccdd1z07t079t9//2jdunW0atUqiouL47PPPov33nsvXnnllSgoKIjHH388iouL63RWu3btYsKECTFmzJjo379/5OfnR1FRUaxduzaWLl0aDzzwQCxdurTO35KbmxsXXnhhyvrMmTNj+/btdZ5fW6ecckp885vfjJNPPjlyc3NrtKeoqCieeeaZeOCBB+KRRx6JsrKyes81ZMiQlHm2bt0ay5Ytq9W8pvqdAAAAAAAAAAAAAAAAQNOXSHcAAAAAAAAAAAAAiIjYZ599kq6vXbu22r1nn312ZGdn13ekBrFs2bIYPHhw0tpll10W9957b7z77rtJ661atYpbbrmlIeMBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANLgRI0bED3/4wxg8eHDKnqysrOjYsWN07NgxBgwYEN/4xjfik08+iWnTpsWdd94ZxcXFNT5v9OjRMXPmzOjQocNu67m5udG7d+/o3bt3jB8/Pn7729/GhAkTYtu2bbX+pttuuy0uu+yypLXp06fHvffeW+uZdXHsscfGXXfdFUcccUSt97Zs2TJGjhwZI0eOjClTpsSVV14Z8+bNq9d8o0ePTllbuHBhlJSU1GhOU/9OAAAAAAAAAAAAAAAAoOnLTHcAAAAAAAAAAAAAiIiUD3T369cvOnfunHJf165d47/+678aKla9mzNnTspa27Zt48knn0xa69SpUzz++ONx8MEHN1Q0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAaVnZ0dDz74YCxYsCAGDx5c6/2dOnWK2267LZ577rnYf//9a7TnW9/6VsyZMyc6dOhQbe+5554by5cvj/z8/FrlGj16dFx22WVJa6tXr44rr7yyVvPqaurUqbF06dI44ogj9nhWr169Yu7cuXHvvfdGIpHY83D/z6hRo1LWCgoKajSjOXwnAAAAAAAAAAAAAAAA0PRlpjsAAAAAAAAAAAAARER8/PHHSddzcnJi3rx5ceyxx+623rJlyzj33HNjxYoV8ZWvfKUxItaLpUuXxjvvvJOy3qNHj3j00Ufjsssui7POOivGjx8fd999d6xatSqGDRvWiEkBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA6k92dnYsWLAgxo0bt8ezjj766FiyZEl07dq12r477rgjMjIyajy7X79+MX369Br3d+rUKR544IGktdLS0hg3blxs27atxvPqokWLFvHggw/GddddF5mZmfU6+xvf+EY88cQTkZubu8ez9t9//zj00ENT1ufPn1/l/ubynQAAAAAAAAAAAAAAAEDzkEh3AAAAAAAAAAAAAIiIWLJkSRx88MFJa0cddVQ8++yzsXHjxli7dm3k5OTEgQceGDk5OY2csn5MmjQpZs2albJ+9tlnx9lnn92IiQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAa1s9//vMYMmRIvc078MAD47e//W0MHjw4Zc/06dMjKyur0vo777wTS5cujY4dO8bo0aOjZcuWu9XPOuusOP300+N//ud/qs1x//33R5cuXZLWpk2bFs8//3y1M/bUHXfcEePGjWuw+SNHjoxZs2bFWWedtcdzUlm5cmW89957Ve5vLt8JAAAAAAAAAAAAAAAANA+Z6Q4AAAAAAAAAAAAAERG/+c1vqu3p0KFDHH744dGnT5/IycnZrVZeXh7FxcUNFa9ePfTQQ7Fw4cI9mlFSUlJPaQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAa1tFHHx2XXnppvc/9+te/Hueee27S2nHHHReHH354pfU//OEPceihh8aECRPijDPOiCFDhkRRUVGlvm9/+9vVnj9+/Pg4/fTTk9ZefPHF+PGPf1ztjD01bty4uPzyy2vUu23btnjttdfiqaeeigULFsQrr7wSn332WY32nnnmmfEf//EfexI1Ro0albJWUFBQ5d7m9J0AAAAAAAAAAAAAAABA85CZ7gAAAAAAAAAAAAAQEbFo0aJ47LHH6rz/mmuuiQ8//LD+AjWw888/P1auXFmnvbfddlu89dZb9ZwIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoGEccMABsX79+pT1p59+OiZMmBBf+9rX4qCDDor9998/Bg4cGN/97ndj9erVVc6+7LLLkq6PGjUq6fr3v//9KCsr+/LPy5cvj9/+9reV+oYOHRotW7ZMeW6PHj3i5z//edLa9u3b44ILLojS0tKqou+x/Pz8+NnPflZt3/z582PEiBHRvn37OOKII2LEiBExcuTIOOqoo6JDhw4xePDgePTRR6udM2nSpNh///3rlLVFixZx0kknpazPmzcvZa05fScAAAAAAAAAAAAAAADQfGSmOwAAAAAAAAAAAAD83dixY2Pp0qW12lNSUhI33nhj3HLLLQ2UqmFs2LAhhgwZEs8++2yt9t11113x/e9/v4FSAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANS/P/7xj3HAAQfExIkT4+233/5yvaSkJC6++OIYPnx4zJgxI1544YV4//3344MPPogXX3wxbr/99ujXr1/Mmzcv5ezjjz8+cnJyKq337du30tq6devivffeq7S+ZMmSSmtZWVnRs2fPpGdmZmbGrFmzIi8vL2n96quvjpUrV6bMXF+uu+666NSpU8r6F198Eeecc06MGjUqnnrqqSguLq7UU1paGkuXLo1zzjknTjrppNiyZUvKebm5uXHTTTfVKeugQYOiXbt2SWs7d+6MRYsWpdzbnL4TAAAAAAAAAAAAAAAAaD4y0x0AAAAAAAAAAAAA/m779u0xdOjQuOGGG+LTTz+ttn/x4sUxYMCAmDJlSiOkq38ff/xxDB48OC6//PL44IMPqux9/fXXY8SIEfHtb3+7kdIBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1J+ioqKYPn16HHLIIXH66afHs88+G3fccUf8+te/rnLfzp074+KLL46SkpKk9UQiEQcffHCl9fz8/EprhYWFSWekWu/QoUPS9euuuy4GDRqUtDZ37ty45557ktbqU05OTkycODFlvbS0NE455ZR49NFHazxz4cKFMWTIkPjiiy9S9px33nnRqVOnWmWNiBg1alTK2pIlS1Ke2dy+EwAAAAAAAAAAAAAAAGg+EukOAAAAAAAAAAAAABWVlpbG1KlT47bbbothw4bFscceG926dYv8/PwoLS2NTz75JN54441YsGBBrFy5cre93bt3r9VZJ5544h7nHTFixB7tLysri7vvvjvuueeeGDx4cBx//PFxzDHHxBdffBHr1q2LNWvWxNy5c+Odd97ZbV///v336FwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAdJk9e3bMnj07MjMza9RfWFgY77zzTvTt2zdpPT8/v9JaixYtKq0VFxcn3Z9qPdmMAQMGxI9+9KOk/Rs2bIhLLrkkaa2+nXXWWdG+ffuU9ZtvvjkWLVpU67mvv/56XH311XHXXXclrbds2TLGjRsXt99+e63mjho1KmVt3rx5KWvN7TsBAAAAAAAAAAAAAACA5iOR7gAAAAAAAAAAAACQzI4dO2Lu3Lkxd+7cdEdpFOXl5fGnP/0p/vSnP6U7CgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECjKCsrq3FvcXFxylpRUVGNZmRmZtZq/Z/l5ubGrFmzIpFIJK1PnDgxCgsLazRrT40ePTpl7bPPPouf/OQndZ79y1/+Mq655po44IADUp59++2313hep06d4uijj05Znz9/fspac/pOAAAAAAAAAAAAAAAAoHmp2b9ZBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQBpmZmXHQQQelrH/wwQeV1rZv315pLS8vL+n+VOvbtm3b7c8//elPo3fv3kl7p0+fHrNnz06Zsb4NGzYsZe2hhx6qlL02ysrK4r777ktZHzJkSCQSiRrPGzFiRGRkZCStffjhh/Hmm2+m3NucvhMAAAAAAAAAAAAAAABoXjLTHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIJWxY8dGu3btktbWrVsX69atq7S+du3aSmsHHXRQZGdnV1rv27dv0tlr1qz58q9POeWU+Na3vpW0b/Xq1XHllVcmrTWE9u3bR9euXVPWFy5cuMdnPP300ylrOTk50bNnzxrPGj16dMpaQUFBylpz+04AAAAAAAAAAAAAAACgeclMdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgH/WunXruOKKK+Lee+9N2TNr1qwoLy+vtL5s2bJKay1btowLLrhgt7WsrKw4//zzK/W+9957sWHDhoiI6NSpU8yYMSPp+aWlpTFu3LjYtm1bld9Sn/r06VNl/YUXXtjjM15++eUoLS2tc4aKRo4cmbJWUFBQ5zOa2ncCAAAAAAAAAAAAAAAAzUsi3QEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgL3TDTfcEMOHD99tLZFIRIcOHaJXr16RlZWVcu+nn34at956a9La7NmzY+vWrZGXl7fb+p133hl5eXmxaNGi6NixY1x//fVx8MEHV9o/a9asL/96+vTp0aVLl6Tn3HzzzfH888+nzNgQUmX5uw8++GCPz9ixY0d88sknKc+qLsPfHXHEEdG5c+ektdLS0njqqadS7m1O3wkAAAAAAAAAAAAAAAA0P4l0BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA9k79+vWLoUOH1npfaWlpfOMb34jCwsKk9S1btsS0adNi6tSpu623bt067rjjjipnr1u3Ln72s59FRMSECRPitNNOS9r3wgsvxKRJk2qdfU/l5eWlrG3bti1KS0vr5ZwtW7ZEly5dap2holGjRqWsLV++PDZv3pyy3py+EwAAAAAAAAAAAAAAAGh+EukOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQU0VFRXHuuefGY489VmXftGnT4qSTTooTTzyxxrPLyspi7NixsXHjxujZs2fcfvvtSfu2b98eY8eOjdLS0oiI6NixY5x55plx3HHHRdeuXSORSMSnn34ar7zySjz22GPx1ltv1ThDdVq1apWytnXr1no7p6pZeXl5NZoxevTolLWCgoIq9zan7wQAAAAAAAAAAAAAAACan8x0BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqKmsrKw48cQTI5FIVNlXXl4ep59+esyePbtGc7ds2RKnn356PPPMM5GZmRkzZ86MvLy8pL3f+973YuXKlZGRkRE//OEPY+3atXHffffFJZdcEiNHjozhw4fHv/7rv8a0adPir3/9a/z+97+P9u3b1/pbk8nIyEhZKy8vr5czIiLKysrqlOHv8vLy4thjj01ZLygoqHJ/c/lOAAAAAAAAAAAAAAAAoHnKTHcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICaysjIiCuuuCLmzZsX2dnZVfZ+/vnncfrpp8fll18ea9asSdpTUlISjz76aBx11FHxxBNPRETE9ddfH4MGDUraP3fu3PjlL38Zubm5MXfu3Jg8eXLk5uZWmeOss86KV155Jfr27VuDL6xaeXl5ylpGRsYez6/JrLKysmr3Dx8+PLKyspLWPv3003jxxRer3N9cvhMAAAAAAAAAAAAAAABonhLpDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUFsnnXRS/PKXv4yLL7642t6777477r777jjiiCOif//+0aFDh9i5c2esWbMmnnvuudi0adOXvQMHDowbb7wx6ZwNGzbEJZdcEhERd955Z4waNarGeQ888MB47LHH4sgjj4xt27bVeN8/2759e8paXl5enef+s1atWqWsbdmypdr9o0ePTll78skno7y8vMr9zeU7AQAAAAAAAAAAAAAAgOYpke4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDe6Xvf+1786Ec/2m0tOzs7OnXqFEceeWScf/75MWDAgJT7/+3f/i2mT58eS5YsqdF5r776arz66qsp67m5uTFz5sxIJBJJ6xMnTozCwsIYPXp0TJgwIWnPhg0bYtu2bXHggQdGRkbGbrVevXrFrbfeGpdffnmN8iazdevWlLXWrVtHixYtorS0tEazWrRoEWeddVY88sgjlWrt2rVLuW/Tpk3Vzh45cmTK2rx586rd31y+EwAAAAAAAAAAAAAAAGieMtMdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADYO61bty7eeeed3X5vvPFGPPPMM/HTn/40Bg4cGOPHj4/i4uKUM6688sp6y/Ozn/0sevfunbR2//33x+zZsyMi4gc/+EGlellZWVx44YXRuXPn6N69e/Tv3z8++OCDSn3jx4+PDh061Dnj+vXrq6x369atRnNyc3Nj9uzZ8bvf/S6uvvrqSrWvfOUrKfdu2rSpytm9e/eOgw46KGV9wYIF1eZrDt8JAAAAAAAAAAAAAAAANF+Z6Q4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJDKAw88EJMnT05ZHzFiRL2cc+qpp8all16atLZ69eq46qqrIiKiXbt2MXjw4Eo9Dz30UMycOfPLP7/55pvx/e9/v1JfdnZ2jBo1qs4533rrrSrrAwcOrHZGfn5+PPXUU3HKKadERMStt94aF1100Zf1ww8/PDIyMlLuX716dZXzR44cmbL22muvxccff1xtxubwnQAAAAAAAAAAAAAAAEDzlZnuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVbn33ntT1tq2bRtdunTZo/mdOnWK6dOnJ62VlpbG2LFjY9u2bRERcdhhh0WLFi0q9c2ZM6dGaxERRx55ZJ2zbt68OT766KOU9ZNOOqnK/V27do2lS5fGcccd9+VaRkZGTJ8+PU499dSIiC//b6rz33rrrSrPGD16dMpaQUFBlXsrntPUvxMAAAAAAAAAAAAAAABovhLpDgAAAAAAAAAAAAA0Tfvtt19MmDAhaa28vDymTp0aZWVljZwKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2BsVFhbGjh07IicnJ2m9bdu2sX79+jrPnzFjRnTp0iVpberUqbF8+fIv/7zPPvsk7VuzZk2lta1bt8bmzZsjPz9/t/XOnTvXOWtExMKFC+PCCy9MWrvgggvi6quvjm3btlWqtWvXLp599tk48MADK9USiUQ88sgjccopp8TFF1+c8uznn3++ymzZ2dkxdOjQlPWCgoIq91fUlL8TAAAAAAAAAAAAAAAAaN4y0x0AAAAAAAAAAAAAaJrOPvvsmDRpUtLfWWedFWVlZemOCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOwlMjMzIysrK2V9x44ddZ49ceLEGDNmTNLaCy+8EJMnT95trWXLlkl7d+7cWeP1VDNqat68eSlrbdq0iWuvvTZpbcuWLfHQQw+l3JubmxtPPvlkdOvWLWXP/Pnzq8w2ePDgyM3NTVrbunVrLFu2rMr9FTXl7wQAAAAAAAAAAAAAAACat8x0BwAAAAAAAAAAAACaptGjR6esFRQUNGISAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4H+bgw46qFb9Rx99dLRo0SJlvbCwsE45evbsGbfffnvS2vbt22Ps2LFRWlpap9kN6Q9/+ENs3LgxZf3aa6+N4cOHJ61dd911MX369JR7E4lEytr27dvjV7/6VZXZRo8enbL29NNPR3FxcZX7K2rK3wkAAAAAAAAAAAAAAAA0b6n/DSMAAAAAAAAAAACgUeXm5sYxxxwTZ599drRr1y7atm0bERFbt26NLVu2xKpVq+KNN96I5cuXx+eff96gWbKzs+OEE05IWS8oKKjT3L9/42GHHRZ9+vRJ+3cCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD8/+zdd3gU5drH8TuFBAKhNxEEQaKiNBGkKUpLIEpT4CBBBbGgKKhHPK9dRFGxoCgoCoggHaUTqoAUKSogSBWQIh1CGklIMu8fXlHCziRbZnafmf1+rut3nePMzjPP7E55MsveAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMC/2rdvL88++6zExsZKjx49ZObMmYUuExYWJu+++67h/FOnTklmZqbHfQkNDZXJkydL8eLFdec/88wzsm/fPpfpWVlZuq8vWrSo29O96e+Vy3/55Zfywgsv6M4PDQ2VhQsXyoMPPijTp093mf/oo49K+fLlpXPnzh6td8qUKZKUlFTga+Li4gznJSYmerQ+lbcTAAAAAAAAAAAAAAAAAAAAAAAAgL2FB7oDAAAAAAAAAAAAAAAAAAD31KhRQ9q3b+/RMmPHjrWoN67KlSsn9957r+68bdu2ycaNG91qp1SpUvLwww/LPffcI3Xr1pXSpUtLVlaWHDlyRNauXSsTJkyQtWvXet3PYsWKSZ8+fQznT548WdLT071u3xsdO3aURx99VNq3by/FihUr9PVZWVnyww8/yIQJE2TmzJmSm5trep/uuOMOw76kpqbKunXrPGrP020U8c92AgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA60VGRkrv3r3l2WeflZtuuumf6ZMnT5batWvLxx9/LGlpabrL1qpVS8aMGSN33XWXYftLlizxql8vv/yyNG3aVHfewoULZezYsbrzTp48qTu9evXqsm7dunzTSpUqJaVKlXK7DU+8/fbb0q9fP6lQoYLu/MjISJk2bZr0799f3nvvPVm9erVkZWWJiEhubq707NlTli1bJrfffrtb60tNTZW33nqrwNdUrVpV6tSpYzjfm89Kxe0EAAAAAAAAAAAAAAAAAAAAAAAAYH/hge4AAAAAAAAAAAAAAAAAAMA98fHx8umnn3q0jFGhcStMnDhR4uPjdee9//77snHjxkLb6NChg0yePFnKli2bb3qxYsUkJiZGYmJipF+/fjJ9+nR5+OGHDYu7F+SDDz6QAQMG6M4bN26cX9+zZs2ayejRo6VBgwYeLRcRESGxsbESGxsrb775pgwaNEgWL15sat86dOhgOG/FihWSnZ3tVjvebqOIf7YTAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYb9OmTVKvXj2X6REREfLWW2/Jq6++Kj/++KMcOnRIzpw5I7m5uVKuXDlp0KCBNGnSREJCQgpsf+bMmR73qXHjxvLKK6/ozjt9+rT069fPcNkdO3ZIdna2hIeH55vepUsXmTJlSr5pnTp10m3j559/9rDHrpKTk2XQoEEu67xS27ZtpW3btpKeni779++X06dPi6ZpctVVV0m1atXcXt9///tfOXToUIGviY2NNZy3b98+OXDggNvry6PidgIAAAAAAAAAAAAAAAAAAAAAAACwv/DCXwIAAAAAAAAAAAAAAAAAUEHt2rUD3QVDgwYNkvj4eJ/aePzxx2X06NGFFmUXEenZs6fcfPPN0rJlS0lKSnJ7HR06dJABAwbozvvjjz9k0KBBbrflq7feekv+97//SWhoqE/t1K5dWxYtWiRffvmlPPHEE5KdnW1K/+Li4gznJSYmutWGWdsoYt12AgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA640dO1Y+/fRTw/mRkZHStm1br9pev369zJ8/36NloqKi5Ntvv5Xw8HDd+Q8//LCcOnXKcPmUlBRZsWKFxMbG5pt+3333ycCBA2XMmDGSk5MjLVq0kPfff99l+fT0dElMTPSoz0amTp0qzZs3l4EDBxb62qioKKlXr55X6zl69KiMHTu20Nd16NDBcN6SJUu8WreIetsJAAAAAAAAAAAAAAAAAAAAAAAAwP5CA90BAAAAAAAAAAAAAAAAAIB7atWqFegu6GrYsKG89957PrXRqFEj+eSTTyQkJMTtZW666SYZN26c268vX768TJgwQXdeTk6OJCQkSFpamtvteSssLEwmTZokL774ooSGmvfP+B555BFZsGCBFCtWzOe2qlWrJjfeeKPh/MIKrlu1jSLmbicAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPCP0aNHy9KlS01v98KFC/LYY495vNyHH34otWvX1p335Zdfyvz58wttY/jw4aJpWr5pISEhMmrUKElNTZXz58/L2rVrpWLFii7LfvbZZ5KcnOxxv40MHjxYJk6caFp7eqpWrSqffPJJga8JDQ2VNm3aGM5fvHixT31QZTsBAAAAAAAAAAAAAAAAAAAAAAAAOENooDsAAAAAAAAAAAAAAAAAAHDPddddF+guuChevLhMnz5dIiIifGpn3LhxUqRIEZfpe/fulfHjx8vcuXMlKyvLZX63bt2kc+fObq3jq6++kkqVKunOGz58uPz000+eddpLn3zyiSQkJFjSdmxsrHz77bemtGNk3759cvDgwQKXt3IbRczbTgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4B+apkn37t1lzZo1prWZmpoq8fHxsmPHDo+Wi4+Pl8cee0x33v79+2Xw4MFutbN69Wr58MMPdecVLVpUSpcurTtv69at8vLLL7u1Dnfl5OTIQw89JG+88Ybk5OSY2vblBg4cKK+88orh/KZNmxpud1ZWlqxatcqn9auynQAAAAAAAAAAAAAAAAAAAAAAAACcITTQHQAAAAAAAAAAAAAAAAAAFC4kJERq1qwZ6G64GD16tNSuXdunNpo3by7169d3mf7dd9/JjTfeKA8//LB06dJF7rjjDsnKynJ53ZNPPlnoOvr16yedO3fWnbdlyxZ5/fXXPe63NxISEuSJJ54o9HVpaWmybds2Wb58uSxdulR+/fVXSU5OdmsdXbt2leeff96nfsbFxRnOS0xMLHBZd7dRJPDbCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/Cc5OVnatWsnw4YNk0uXLvnU1po1a6RevXqybt06j5arUKGCjB8/XndeTk6OJCQkSHp6utvt/e9//5Nvv/3W7df/9ttv0qVLF8nKynJ7GU+8/vrr0qxZM9myZYsl7YuIDB06VAYMGKA7r0OHDobL/fjjjx69twUJ9HYCAAAAAAAAAAAAAAAAAAAAAAAAcIbwQHcAAAAAAAAAAAAAAAAAAFC4smXLyvr1612mR0VFSZMmTQLQI5HevXvLAw884HM7cXFxutP/+9//Sm5u7j//vXHjRpk+fbr06dMn3+vuvPNOiYiIMCx+XrNmTfn4449156Wnp8v9998vOTk5XvbefaVLl5aPPvqo0NctWbJE7rnnHpdi9mFhYdKsWTMZNGiQ3HfffQW28cYbb8i0adPkyJEjHvczLCxM2rZtazh/8eLFhvM82cb3339fVq9eHbDtBAAAAAAAAAAAAAAAALxVvHhxKV26tISFhenOP3z4sJ97BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQHbVtAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAD4V1ZWlrzyyivyxRdfyIABA6R79+5Su3Ztt5dNTEyUzz77TJYuXerV+seNGycVK1bUnTds2DDZuHGjR+1lZ2dLQkKCrFu3ToYNGyZly5Y1fN348eNl8ODBcvHiRY/77YnNmzdL48aNJTY2Vh599FGJi4uTqKgot5bNzs6W5cuXy+bNm+XFF180rJfw6aefytmzZ2XGjBn5psfGxhq2vXjxYvc3wg2B3E4AAAAAAAAAAAA4B7XEAQAAAAAAAAAAglt4oDsAAAAAAAAAAAAAAAAAACjc2bNn5a677nKZHhMTI3v27PF7f2rVqiVjxowxpa06deq4TDt+/LgcPHjQZfqPP/4offr0yTetSJEiUqtWLdm1a5fL60NDQ+Xbb7+VEiVK6K77ueeek3379nnZc8+8+OKLUr58ecP5Fy9elAceeEBmzZqlOz8nJ0fWrl0ra9eulTZt2sjs2bOlVKlSuq8tVqyYDBs2TB588EGP+9m0aVPDdjMzM2XVqlWGy/q6jSL+204AAAAAgHU+++wz3b/3BwwYILt37w5AjwAAAGA1xoCAd3744Qfd6XrfDSM4sE8AgJpq1aol8fHx0qpVK7ntttukYsWKUqRIkQKXCQkJ8VPvnIFroBr4HOAus/YV9jkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACojhoZ/kFtU8B7nKdwJfYJ2AljAADBQOXatowb7IfPDMGIMSMA5Md4AAAAAAAAAAAAAAAAAAAAAAAAAICTHT16VF566SV56aWXpFq1alK3bl2pXbu2VKhQQYoXLy5FixaV1NRUOX/+vJw9e1Z+/fVX2bp1q2RlZfm03k6dOpm0BfmNGTNGJk6cKPHx8dKiRQu5+uqrJTw8XM6cOSO//vqrzJ07V44dO2bJuo0sWbJElixZIkWLFpUmTZrIzTffLDfccIOUKlVKSpYsKaGhof+8x3/88Yf89ttvsmHDBklLSxMRkT///FO++uor3bZDQ0Pliy++kMTERElOThYRkXLlykmjRo0K7I8V/L2dAAAAAOBk1DwB4FSc39REDULAO5zT4DT+3qdVriWuMq7bAJyKsRUAAAAAAAAAEZHwQHcAAAAAAAAAAAAAAAAAAGAvRYoUkenTp0t0dLQp7ZUuXdpl2qlTp3RfazS9bNmyutNffPFFadq0qe68RYsWyeeff+5eJ31UtGhR6d+/v+H8nJwc6dixo6xatcqt9lasWCF33HGH/PTTT1KsWDHd1/znP/+R5557Ts6cOeNRX+Pi4gzn/fjjj3Lx4kXdeWZvo4i12wkAAAAAsM4tt9yi+/d4yZIlA9AbwL8iIiJ0p/v6AEIAAFRn9zEg13AEyp133hnoLkAx7BMAoJY6derIq6++Kt27d5fQ0NBAd8fRuAaqgc8B7jJrX3HiPhcZGSk333yzVK1aVapVqyZRUVFy6dIlSU5OluTkZDl37pz8/vvvcvz48UB3FQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXZf/dr5UqVJSsmRJfj+PoObEGhkqorYp4D3OU7gS+wTsxO5jAFiLMRbszg61be04bgj2c4MdPzPAV4wZASA/xgNwmmAf4wMAAAAAAAAAAAAAAAAAAAAAAMDYkSNH5MiRI4Huhs/S09Nl5syZMnPmzEB3JZ+MjAxZs2aNrFmzxqPlxo0bJxUrVpS3337bZd65c+ckPj5ekpOT/5nWrl07w7oLf/31l+zYscOzjnvIX9sJAAAAZ6FWO5AfNU/gDuqIwJ/M2t84v6nJ7jUIOR8iUDinwWn8tU/boZa4yrhuq83p2wdYibGV/3HOAgAAAAAAgIrCA90BAAAAAAAAAAAAAAAAAIC9vPPOO9KoUSOX6RcuXJBSpUp53F5YWJjLtEuXLum+1mi6Xhu33nqrvPbaa7qvP336tPTt29eDXvqmW7duUqZMGcP5b7/9tqxatcqjNrdv3y7PPfecjB49Wnd+RESEJCQkyMiRIz1qNy4uznDe4sWLDedZsY0i1m0nAAAAnO3pp5+W0qVL+9xOTk6OZGZmSkpKipw6dUqOHTsme/bskQsXLvjeSQCA48TExMiePXt0511//fWyd+9eP/cIAAC4g2s4AAAA9PTs2VMmTpwokZGRge5Kocz6XiRPVlaWZGRkyJkzZ+TEiROyf/9++fPPP0XTNNPWAQBOERoaKq1atZIePXpIy5Yt5YYbbpDw8MJLPJ4+fVp+/fVXmTdvnsyePVtOnDjhh96qzezrmafWrl0rK1euDNj6AQAAAAAAAAAAAAAAAAAAAAAAAAAAACBQvP3tvAi/nwcAEWqbAgAAWIExFuzOTrVt7YRzAwDV2OW5qZUrV5ZHH33UlLascPToURk/fvw//12yZEkZPHiw7ms1TZMPP/xQ0tLS/NS7v7Vq1UpatWqlO2/9+vWyfPlyv/YHAJyCMT4AAAAAAAAAAAAAAAAAAAAAAABgT8OHD5cKFSrIM88888+0Y8eOSbt27WTXrl35XtuhQwfDdhITEy3roxk82U4AAADYG7XaAcA31BGBP7G/QWXsnwBgL9QSD25Ov247ffsAOAvnLAAAAAAAAKjKvX9JCgAAAAAAAAAAAAAAAACAiMTFxeUrZn25Rx55RGbMmGHKekJDQz2afqVixYrJt99+a1hwsX///nLq1Cmv++epgoqYJycny7vvvutVu1988YX873//k2uuucZwvSNHjnS7vfLly0ujRo0M5y9ZssRwnlXbKGL+dgIAAMD5nnnmGalRo4Zl7R85ckTWrVsniYmJMn/+fDl37pxl6wIAAAAAAAAAAP712GOPyZgxYyQkJCTQXXGL1d+LiIikpqbK5s2bZdmyZfLdd98ZFt0HgGBRsmRJ+e9//yuPPvqoVKpUyePlK1SoIO3bt5f27dvLJ598Ij/88IMMHTpU1qxZY0Fv7cEf17OCvPPOO7Jy5cqArR8AAAAAAAAAAAAAAAAAAAAAAAAAAAAA/M3X386L8Pt5AAAAAACAK9mtti0AwHt2eW5qlSpV5I033jC5d+b56aefZPz48f/8d3JyslSuXFkGDBig+/rq1atL//79/dU9qVKlinz33XdStmxZl3mnT5+Wzz//3G99AQAAAAAAAAAAAAAAAAAAAAAAAAAEl7TzIif2/fvf5/8KXF+AKz377LNSoUIFSUhIkD179ki7du3kyJEjLq+LjY01bCMxMdHKLprC3e0EAACAPVGrHQAAAACA4EQtcQAAAAAAAAAAABQmNNAdAAAAAAAAAAAAAAAAAADYQ+XKleWbb77RLWLw5ZdfysyZM71qNz093WVaiRIldF9rND0tLS3ff3/44YcSExOj+9px48bJvHnzPOylb1q3bm04b8qUKS79d1dubq58+eWXhvPvuOMOCQ8Pd7u9du3aGRapOHbsmOzcudNwWau2UcT87QQAAAB8Va1aNfnPf/4jX3/9tZw4cUKmTp0qt9xyS6C7BQAAAAAAAAAAfFS3bl35+OOP3XrQS05OjmRkZOjGaUqUKCF33XWXvP3227J7925Zu3atxMfHB7pbAOB34eHh8r///U8OHTokr7zyitcPCr9caGiotGnTRlavXi1Lly6VOnXqmNBTAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD0WfHbeRF+Pw8AAAAAAEBtWwCAmYL5uanPPvus7N69W3feww8/LF27dvVbXyZOnChly5bVnde3b185deqU3/oCAAAAAAAAAAAAAAAAAAAAAAAAAAguO5aJfPPUv1n5eaB7BOT30EMPyYgRI6RFixZy5MgRl/n169c3rHmZk5Mjy5cvt7qLpihsOwEAAGA/1GoHAAAAACB4UUscAAAAAAAAAAAA7ggPdAcAAAAAAAAAAAAAAAAAAOoLCQmRyZMnS4UKFVzm/f777zJo0CCv29YriF2jRg2JjIyUzMzMfNONih8ePnz4n//fsWNHefzxx3Vf98cff/jUV2+UKVNGqlSpYjh/xYoVPrW/cuVKefPNN3XnFS1aVGrVqiV79uxxq60OHToYzktMTDScZ/U2ipi7nQAAAICZihQpIv/5z3+kZ8+eMnXqVHn66afl7Nmzge4WAAAAAAAATNCiRQt5+eWXXab/+OOP8vbbbwegRwAAq3399dcSGRmpO+/MmTMyevRoWbhwoezatUtSUlL83Dt1tGjRQhYsWCDLly+Xfv366f4bMABwmpo1a8q0adOkcePGlq2jXbt2smXLFnnyySdlwoQJlq0HAAAAAAAAAAAAAAAAAAAAAAAAAAAAABCc/PHbeRF+Pw/rUB8OAGA3XLsAOAnnNKBw1LYFAFgl2J6bmpGRIb169ZKNGzdKRESEy/yvvvpKfvrpJzl+/Lil/Rg0aJC0bdtWd96YMWNk4cKFlq4fgDX4+7ZgvD8AAAAAAAAAAAAAAAAAAAAAAAAA3JWTkyNDhgwxnB8XF2c4b9OmTXL+/HkrumW6wrYTAAAA9kKtdtgdtSEAAAAAwDfUEgcAoHDchwQAAAAAAABEwgPdAQAAAAAAAAAAAAAAAACA+l544QVp06aNy/SMjAzp2bOnXLx40eu2161bJ4899li+aREREXL//ffnK3JYpEgR6dWrl8vyBw8elNOnT4uISPny5WX8+PG668nJyZGEhARJS0vzuq/euP766wucv3nzZp/a/+WXXyQnJ0fCwsIM179nzx632oqNjTWcl5iYaDjP6m0UMXc7AQAAACuEhITI/fffL23atJF7771X1q1bF+guAQAAAAAAwEeVKlXSfXB1ampqAHoDALBaq1at5JZbbtGdt2zZMrnvvvskOTnZz71SW9u2beXXX3+Vzp07890IAEfr2LGjTJ8+XUqUKGH5uooVKybjx4+XJk2ayIABAyxfHwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgOPjzt/Mi/H4e1qA+HADAbrh2AXASzmlAwahtCwDwh2B6burWrVvlpZdekhEjRrjMK1u2rHzzzTfSrl07y9Z/8803y7vvvqs7b/fu3fLss89atm4A1uLv24Lx/gAAAAAAAAAAAAAAAAAAAAAAAAAwy8GDB+W1117Tnbdx40Y/9wYAAACgVjucgdoQAAAAAOA9aokDAOAe7kMCAAAAAAAAIuGB7gAAAAAAAAAAAAAAAAAAQG1NmzaVN998U3fe4MGDZceOHT61P2/ePElNTXUpoDhq1CgpUaKErFq1SsqVKycvvfSSXHfddS7Lf/vtt//8/3HjxkmlSpV01/P222/LTz/95FNfvWHUnzxHjx71qf2MjAw5c+aM4XoKW3+eBg0aSMWKFXXn5eTkyPLlyw2XtXobRczbTgAAAAS3o0ePSlJSkluvDQkJkcjISImOjpaSJUtKsWLF3FquUqVKsmLFCunSpYskJib60FsAAAAAAAAAAOBPAwcO1J2+Z88e6dSpk2RkZPi5R77x5HuRPGFhYRIVFSUlSpSQMmXKSGhoaKHLlCtXTpYsWSKtW7eWTZs2edlbAFBX586dZcaMGRIREVHg65KSkmT58uWyZs0a2b17t+zcuVMyMzMlPDxcoqOjpUyZMhITEyP16tWTNm3aSKNGjQps7/HHH5fMzEwZPHiwiVtjP95cz7xx4sQJy9cBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIHi7W/nDx8+LCkpKfx+HgAAAAAAoBBOq20LAPCeas9NzcjIkB07drjVrpFSpUpJtWrVXKZnZ2fL7t27fWr7wIEDhvM++OAD6dixo9x1110u89q2bSuDBw+WkSNH+rR+PRERETJlyhSJjIx0mZeVlSW9evXi2g4AAAAAAAAAAAAAAAAAAAAAAAAAAFCIGTNmBLoLAAAAwD+o1Q4AAAAAAKglDgAAAAAAAAAAAHeFB7oDAAAAAAAAAAAAAAAAAAB1lSxZUqZOnSrh4a7/3Oy7776TL774wud1XLhwQYYPHy5vvfVWvunFixeXTz75pMBljx8/Lh999JGIiDz88MPSqVMn3ddt3rxZ3njjDZ/76o0SJUoYzktLS5OcnByf13HhwgWpVKmSx+u/XFxcnOG8jRs3SlJSkuF8f2yjiDnbCQAAgOD23HPPef2goUqVKslNN90kjRs3lm7dukmTJk0MXxsZGSmzZ8+W5s2by7Zt27ztLgDAZjIyMmTLli2G8wAAgJq4hgMAACBP69atdae/8MILthwb+vK9iMjf33fUrl1bGjZsKPfcc4906NDB8N/oFC9eXL777jupV6+enDt3zut1AoBq4uLiZNasWbr/jjbP9u3b5e2335Y5c+ZIZmam7mtOnjwpIn//e9Zvv/1WRESuvfZaGTRokDz++OMSGRmpu9ygQYPk2LFjMmLECB+3xL58vZ4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAQLAz67fzIvx+HgD0UNsUAADAfIyxYEdOq22rIs4NAOxCteem/v7771K3bl2v+pOnW7duMnv2bJfpZ86c8bntgmiaJn369JHffvtNypQp4zL/nXfekRUrVshvv/1m6nqHDx9uuF0vvfSSbN261dT1AUCwYowPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPAHarUDgLWoIwJ/Yn+Dytg/AUB91BJHHqdft52+fQCchXMWAAAAAAAAVGX8r04BAAAAAAAAAAAAAAAAAEHvq6++kho1arhMP3z4sDz88MOmrWf48OHStm1bueuuu9xeJjc3V3r37i3nzp2TWrVqyciRI3Vfl56eLr1795acnBwRESlXrpx07dpVmjdvLlWqVJHw8HA5e/as/PrrrzJnzhzZvXu3GZv0j6ioKMN5qamppqyjoHZKlCjhVhsdOnQwnJeYmFjgsv7YxsLacnc7AQAAAG+dPHlSTp48KStXrpR3331XrrvuOhk2bJj07NlT9/VRUVEydepUadCggWRlZfm5twCAQDh8+LA0btw40N0AAAAe4hoOAAAAEZEbb7xRypYt6zL97NmzMn/+/AD0KPAyMzNlx44dsmPHDpk0aZKULl1a/u///k+eeeYZKVKkiMvrr776annrrbdkwIABAegtAJjvmmuukW+//dbwQeGpqany3HPPydixY71q/+DBgzJ48GD58MMPZcqUKdKiRQvd1w0bNkwWLVokO3fu9Go9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDgZfVv50X4/TwAUNsUAADAfIyxYDfUtvUPzg0AggHPTXV17NgxeeSRR2TWrFku8yIjI2Xq1KnSqFEjyczMNGV9bdq0kWeeeUZ33g8//CAffPCBKesBADDGBwAAAAAAAAAAAAAAAAAAAAAAAAAAAABYj1rtAGA96ojAn9jfoDL2TwBQG7XEcTmnX7edvn0AnIVzFgAAAAAAAFQVGugOAAAAAAAAAAAAAAAAAADU1L9/f+nevbvL9JycHOnVq5ckJSWZti5N06Rz584yb948t15/4cIF6dy5s/zwww8SGhoqkydPlhIlSui+9tlnn5V9+/ZJSEiIvPLKK3LkyBH58ssvpW/fvhIbGytt2rSRHj16yPDhw2XXrl0ye/ZsKVOmjGnbFhISYjhP0zRT1pGbm+vV+vOUKFFCmjVrZjg/MTGxwOX9sY0ivm8nAAAAYKb9+/fLf/7zH4mNjZXU1FTd19x4443y+OOP+7lnAAAAAAAAAADAU3Xq1NGdvnHjxgL/zUowSUpKkhdeeEHi4uIkOTlZ9zX9+/eXq666ys89AwDzhYeHy6xZs3QfBCby90O+b731Vp8eFJ7n8OHD0qpVK5kwYYLu/IiICPn6668lNJTSkQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA9/nzt/Mi/H4eAAAAAAAEL2rbAgCswnNT/zZ79mz5+uuvdefddNNN8t5775mynjJlysjEiRMlJCTEZd758+elT58+ommaKesCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYC1qtQMAAAAAgDzUEgcAAAAAAAAAAIAn+NeeAAAAAAAAAAAAAAAAAAAXN954o3z88ce681599VVZv3696etMSUmRzp07yxNPPCGHDx/WfU12drbMmjVLbrnlFlmwYIGIiLz00kvStGlT3dcvWrRIvvjiCylWrJgsWrRIhg4dKsWKFSuwH926dZNff/3VsICDpzRNM5wXEhJiyjoKasedYhNt2rSRIkWK6M47e/asbNmypcDl/bGNhbVFUQ0AAAAEytKlS+Wuu+6SzMxM3fnPP/+8qeNiAAAAAAAAAABgPqOHwR44cMDPPVHfypUr5fHHH9edFx4eLvfff7+fewQA5hswYIA0btxYd96hQ4ekRYsWsmfPHtPWl5OTI/3795fvv/9ed/6tt94q9913n2nrAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4n79/Oy/C7+cBAAAAAEBworYtAMBqPDdVZODAgfLHH3/oznvqqackNjbW53V88cUXcvXVV+vOe/TRR+XYsWM+rwMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAf1CrHQAAAAAA5KGWOAAAAAAAAAAAADwRGugOAAAAAAAAAAAAAAAAAADUEhkZKdOnT5eoqCiXeT/88IMMHz7c0vWPGTNGqlevLg0bNpQHHnhABg8eLAMGDJD4+HipWLGidO/e/Z8iCo0bN5ZXX31Vt53Tp09L3759RURk1KhREhcX53YfqlevLnPmzJHixYv7vD3p6emG80qUKOFz+yKi+1nluXDhQqHLd+jQwXDesmXLRNO0Apf3xzaK+L6dAAAAgFW2bNkib7zxhu68qlWrSqtWrfzcIwAAAAAAAAAA4IkyZcroTuffpOibOnWqbNiwQXdebGysn3sDAOYqXbq0vP7667rzUlNTJTY2Vo4fP276enNzc+XBBx+Uv/76S3f+kCFDTF8nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMCZAvXbeRF+Pw8AAAAAAIIPtW0BAP4Q7M9NTUtLk969e0t2drbLvJCQEPn666+lXLlyXrffp08f6d69u+68r7/+WmbNmuV12wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD8i1rtAAAAAADgctQSBwAAAAAAAAAAgCdCA90BAAAAAAAAAAAAAAAAAIBaPvroI6lbt67L9DNnzkjv3r1F0zS/9GPr1q0yadIk+fjjj+Xzzz+XRYsWyfnz5/+ZX6xYMZk8ebKEh4frLt+/f385deqUdOjQQR5++GHd15w+fVoOHTqku021a9eWESNG+LwdqamphvOKFy8uYWFhbrUTFhYm3bt3151XqlQpw+Uuf8+MxMbGGs5bvHhxocubtY0i1m4nAAAAYKUPPvhAkpOTdee1b9/ez70BAAAAAAAAAACeKFq0qO70rKwsP/fEPqZOnao7vV69en7uCQCY63//+5+ULVtWd96TTz4pe/futWzdKSkpMmjQIN15NWvWlGuvvdaydQMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnCOQv50X4ffzAAAAAAAguFDbFgDgL8H+3NSNGzfKm2++qTuvcuXKMm7cOK/arVGjhnz22We68w4cOCBPPfWUV+0CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAxqtQMAAAAAgMtRSxwAAAAAAAAAAACeCA10BwAAAAAAAAAAAAAAAAAA6ujSpYsMGDBAd96DDz4ox48f93OPjH300UcSExOjO++rr76SefPmiYjIkCFDXObn5uZKnz59pGLFinLttddK3bp15ejRoy6v69evn2HBR3edPHmywPlVq1YttI1ixYrJvHnzZMaMGfLcc8+5zLvqqqsMlz1//nyBbcfExEiNGjUM5y9durTQ/pmxjSLWbicAAABgtaysrH/+DrlSw4YN/dwbAAAAAAAAAAAAa23dulV3eqVKlSQiIsK/nQEAk0REREj//v115/3444/yzTffWN6HWbNmyf79+0Xk7weHT548WeLj46VixYpy8OBBy9cPAAAAAAAAAAAAAAAAAAAAAAAAAAAAALA3FX47L8Lv5wEAAAAAAAAAMBvPTRUZNmyYrF+/Xnde586d5ZFHHvGovdDQUJk8ebJER0e7zMvJyZHevXtLamqqV30FAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4H/UagcAAAAAAAAAAAAAAAAAAIAvwgPdAQAAAAAAAAAAAAAAAACAGqpVqybjx4/Xnbdo0SI5ceKE3HLLLV61XblyZZdlf/nlF6/aEhGJj4+Xxx57THfeH3/8IYMHDxYRkVKlSsntt9/u8popU6bI5MmT//nvnTt3yn//+1+ZNm1avtdFRkZKXFycTJkyxeu+7t69u8D5jRs3lj///NNwfunSpWXhwoXSvHlzEREZMWKEnD59+p+Ck/Xr15eQkBDD5f/4448C1x8bG2s4b9u2bXLixIkClxfxfRtFrN9OAAAAwB+2bNkiCQkJLtOvu+46y9cdHR0t4eHhkpqaKpcuXbJ8fd4qUqSIlChRQnJzcyU5OVk0TQt0l/4RGRkpxYsXl6ysLElNTQ10d5SQ955cvHhRLl68GOjuBITd3oNixYpJsWLFJDc3Vy5cuKDUMWYkr8/p6emSkZFhyTrCw8MlOjpaMjIybPE5miVv/7XyvfWW3Y4tp7DLeEE1dnzfVD7+7ciO+4AvOEcjj932/WA+90VEREiJEiUkIyND0tPTA90dKMAux4PdzjN2Ybd7A9wXcBWM53XuzdpXQf+uKDo6Ws6ePevH3njOTudMlb9fgRoYW5nn3nvvlXLlyunOe+GFF/zWj0GDBklkZKQsWrRIMjMz/bbePOxT5mCcY0z1axvHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOxMld/OiwT+9/OBwG/NoccuNeLMQG1T5LFj/YZgOlavFIx18FAwuxwPdjzXeMMOtfPsOgaw8/idc7f17Lx/2OU8bhY7f1ZOEEz7m12vd1cKps/MF3Yba9rhc3XKMaSCQD43VQW5ubnSu3dv2bZtm5QsWdJl/siRI2XVqlWyb98+t9r73//+Jy1atNCd98Ybb8hPP/3kU3/hH4wJ7SksLEyio6MlJCTENtdcf7HD/SCnsOv5ww7jPwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIFGq1B5Zdf8sPawVzrQRqiPpXXu0WK/e18PBwiY6OloyMDOXqqlG7BiqhBiHy2KnGZzCPWUQYtwSaHerz2el4hme4bsNqdrjGButxoPr1h3uN8Bc772sqn2NVP8cAAAAAAAAUJjzQHQAAAAAAAAAAAAAAAAAAqOH555+XMmXK6M7r2LGjdOzY0eu2ExISJCEh4Z//Tk5OllKlSnnVVvny5WXcuHG683JycqR3796SlpYmIiI333yzhIWFubxu4cKFbk0TEWnYsKFMmTLFq76KiCQlJclff/0lVapU0Z3ftm1bmTVrlu68KlWqyNKlS+Wmm276Z1pISIiMGzdOzp49KwsXLpT4+PgC17179+4C+9ehQwfDeYmJiQUue/l6vN1GEf9sJwAAAOAPx48f153u7d8/eiIjIyU2NlZiY2Olfv36cuONN0qZMmUkJCTkn9dkZWXJn3/+KTt27JD169fLnDlzZP/+/ab1wV0NGjSQu+++W2699VapW7euXH311RIZGfnPfE3TJDk5WX7//Xf5+eefZdGiRbJ06VLJycmxvG8333yzdO7cWZo0aSL16tWTq6++WooUKZKvb+fPn5edO3fK9u3bZenSpbJ06VJLit/UqVMn33+fPHlSzp49a/j6yMhIqVevnlx33XVSqlSpf4rf5Pnkk0+86ufVV18tXbt2lTvuuEPq168vNWrUkIiIiH/mZ2dny6FDh/55P+bMmSMnT570eD0qq1Klitx3333SsmVLadiwoVxzzTX53oOcnBz566+/ZOfOnbJ+/XqZN2+ebNu2Tbet8PBwKVu2rMv0c+fOSXZ2ts99LVKkiNx1110SFxcn9erVk5tuukkqVKiQ7z6IpmmSlJQk586dk23btsnq1atl9erVhn321pX7sEjB+3Hr1q2lZ8+e0qxZM7n++utd9rPDhw/L1q1bZeXKlTJz5kw5deqUx31q2LCh3H///dK8eXOpW7euREdH/zMvPT1dTp8+Ldu3b5fFixfLokWL5M8///R4HUb03g8Rkd9//93ndgp6X8uWLSvdu3eX1q1bS8OGDaV69er53tu87d61a5csW7ZMli5dKjt27PCoT96y07HlLU8/LxHrzud5bftzvFClShUpXbq0y/Tz588bjo98VbZsWalcubLL9LNnz3p9fVJlnGWn479ixYpSvnx5j/rrjZCQELnxxhtdpufm5pp6b1iVfcCfVBwDBuqc6s01nPOfefu+nc59gRYdHS3x8fHSsWNHadCggcTExOT7WzsnJ0dOnDgh27dvl82bN8v3338vW7du9WpdRvt4WlqaqWPoy4WHh0tMTIzLdLPP+ZcrX768VKxY0XD+Nddcozu9VKlShucOI1lZWaZfN8qUKSOdO3eWDh06SL169aRWrVr57nGocDyocJ4xmwp/A6hyb4D7Avl5+n6UKVNGunbtKu3atZP69etLzZo1LTuvqyKQ92aNxlJ5KlWqZDjd03O+iOf3g+yooAfX6v2brUBR5ZzpLpW/X/FVZGSk1KpVy3B+SkqKHDlyJN+02rVr5ztP5Dl+/LicP3/e5z5FR0dLtWrVXKbv2rXLlAdkXnvttVKsWDGX6fv27fPqoQZOHFuppl+/frrTf/rpJ9mwYYPf+rFo0SK/rId9yjwqfwctEtjvLVS+tnEMAAAAAAAAAAAAAAAAAAAAAAAAAAAAwIlU+e28iLm/n1ftt9QigfmtuRPrcVxei8Pu9eFE7FEjziwq1jYVCcz5gtqmga/fYHV90w8//NDU/gaSv+qbUtv0b1y7zKHKucZqdqmdp+oYoDB2rhXlrxqmqp3TzHoGjDvsvH8EW932QH1W1Lb9mwrjBn+dG5zyzCUVPjM7uHK82bx5c57Z4SO7jhntwh/PTVXdoUOHZODAgfLNN9+4zIuKipIpU6ZIs2bNCj3P3nrrrfLGG2/oztuwYYO89dZbpvTXV3rfDdj5ewER7+t0i9h7/C5i/fdXvvKmnrw7mjRpIm3atJEmTZpIgwYNpHz58lKiRIl8r8nKypJjx47Jjh075Ndff5UFCxbI5s2bPV6Xan/fFiQQ94P8+f64M04Pxr//nTj+AwAAAAAAAAAAAAAAAAAAAAAAAAAAAACVUKv9X9Rq9xy12n3npBpoqtYQNbvfIoGp1e5uOwX1vXXr1tKzZ09p1qyZXH/99S41zw4fPixbt26VlStXysyZM+XUqVMe9UdEpGHDhnL//fdL8+bNpW7duhIdHf3PvLz9efv27bJ48WJZtGiRZTW4L6dKLeNAXZv8WbfmSsFSf91TKtYgtNP+ybMrrKvxSX0nY/56boUI5049/qzP5w0VjmdvUEvcPVy3C16viHOu24H6O80O11in1KH3lCfXn0mTJvn12iOiTt1Qs1SsWFHKly/vMr2w85unQkJC5MYbb3SZXti4R7X7kMFYo1bEWedY1ce4AAAAAAAAXtHcJCKEEKKbevXqaQkJCVpCQoLWu3dvrVmzZlpISEjA+0UIIYQQQgghhBBCCCGEEEIIIYQQIiJau4GiDUn8N+0GBr5PZiYmJsa0f/s1ZswYd/9Jmc+2bNni9TbPmzfPsN033ngj32u7dOmi+7rmzZvrtn3+/HmX106cONHnz+mbb74x7HNycrJWvHhxl2VKlSqlHTp0yHC59PR07c4779SOHDli+JrFixcX2K/IyEgtPT3dcPk777zT0m3013YSQohTExISojVu3Fjr3bv3P/+Ws169egHvV7CGf1NLiFo5ePCg7tixR48elq43NjZWd70pKSk+t12tWjVt9OjRWkpKiuHYuCCbNm3SunTpYvl7HxUVpQ0aNEg7cOCAV/08deqU9uKLL2rFihUzvW9FihTR+vfvr+3evdurvqWmpmqff/65du2115rarysNGTLE5TWhoaFaz549teXLl2uXLl0qsJ9ly5b1aP233367tnTpUi03N9ej9+PSpUvahAkTtBo1ari0uWHDBt1lmjRpYvk+6E2aNGmiLVmyxOP3QNM0bfPmzVqnTp1c2rzjjjsseQ8qV66svf/++9qFCxc87mueTZs2aV27djVtrKJHbz+OjY3Vdu3a5VFfs7OztfHjx2tXX321W31p2rSp9tNPP3m0jpycHG3SpEla9erVLXs/NM3z32i6+75WqVJF++qrr7SsrCyPtlvTNG3NmjUe3f9x8rHlr+PAyvO5SODGCw8//LBuezt27LDsPZ82bZruOrt162ab983X/UmF43/48OFu99eXREVF6a7HjHG2ivuAP6LyGFCPP86pRgpahvOfefu+HlXPfWbHyJWvK1OmjPbuu+969Xnt2rVL69OnjxYaGupR34z28fPnz2uRkZGWvB/33Xef7joXLVpk2Wfw6quvevyeemvNmjWm7RMVK1bUPvnkEy0jI8OrfvjjeFDpPGN29PjrbwDV7g24+14E830BvfejatWq2hdffOHVNc3b83ogo8q92Weffdar9Xvj2LFjfn2PA/W9SI0aNQzfg/Lly/t8/Giab7XPVDtnFhRVvl8xYsY2lipVSlu7dq3hOv7880/t+uuvd1nu+++/1339V199ZUq/jMaDzZo187nt8PBwLSkpyaXtc+fOaeHh4R61pdrYyohK+5w3KVq0qOEY+5FHHglYv6yIavuUSOCuZ75ElXHOldHj7+8tVLm22ekYIIR4n5CQEK1Jkyb8e1pCiEfxRaD7TghRN/yuhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIcT/oVa7WuHf1BKiRpz823k9gagBG+jfmjuxHsfltThUqw9ntO9pmj1rxJkVlWubGn1mVp8vjBS0DLVN7VXbWeXj1MiVr/N3fVNqm5ovGK9dqp1rrIpZtfOs/jtc9TGAXgI9fjeKHhVqmKp2TjNi1udg9/3DiXXbVf6snFrb1siVr1Np3OBun72N6s9ccnf7VfrMVI4v402e2aEfO44ZfYkTn5tqlG7duumu8/jx4wH9DIzud2mapr311lsFLlusWDFtz549ussmJyebPs7zJXrfDdj5ewFv6nSrMCbUix4V70e7G2/ryRf0uT311FPazp073fugdBw5ckR7/vnntZIlS/q8X1vB3Xt2VyaQz1Lw5/vj7XHk7rJ2PX/osev4jxBCiBqhVjshxJv4ItB9J4SoG35XQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEOL/UKtdrfBvaglRI9Rqp1a7r6FWu3v7nqYFRw00PSrUEDWr3yrWxnG377GxsdquXbvcf6M1TcvOztbGjx+vXX311W71pWnTptpPP/3k0TpycnK0SZMmadWrV7dknwxk7RpV9jWr97fC2gmW+uvuRuUahHpU3T95doV1NT6Dqb6TkStf5+/nVhS0jwfbuTNQ9fk8icrHc56ClnFqLXGzwnXbnP3MTtdtb7bPl8/HDtdY1evQWxFfrz9WX3sCfa/RyuNn+PDhum3oHT++JCoqSnc9hdUsV+0+pJFg3NfsdI61wxiXEEIIIYQQEhyhVjshxJu4w+2K7oHeGEKIuuGHJoQQQgghhBBCCCGEEEIIIYQQQghROe0GijYk8d+0Gxj4PpmZmJgY0/7t15gxY9z9J2U+mzp1qlfb279/f8M2N23apIWFheV7fY8ePXRf26hRI932T5w4YVpfL0+vXr0KfD+GDRumu9zbb79d4HKFFSUYPHhwgf1q27at4bIpKSlakSJFLN9Gf2wnIYQ4NRRvVyv8m1pC1MrBgwd1x449evSwdL3t27c3HF9722aRIkW0t956y6uiLHp+/PFHrWbNmpZsf69evbRTp06Z0s+jR49qrVu3NvWzOXTokCl9y87O1j788EOtaNGipvTtSlcW57nhhhu0TZs2ud0/d4vyV6hQQfvuu+98fj9SU1O1J554Il/bZhXwszrR0dHa5MmTfX4PNE3TZs+ene+9N7t4W0hIiPbf//5Xu3jxoin91TRNW79+vXbVVVeZvg9rWv79OCwsTBs1apRPfU1KStLi4+MN+xAaGqq9//77XhXgy5OZmak99NBDlrwfmmZNgcT7779fS01N9Xqb88yaNUsrXrx4UB5bZkWPv87nIoEfLxQvXlxLTk7WbcvoXqwvKVWqlO758OTJk/keiqL6++aE41/1gpR23QesjB3GgHr8cU41UtAynP/+Zsa+r0fVc5/ZMXL5a+655x7d7zE9tX37do/uIRcvXtywmH/37t0teT/mzJmju7777rvPss/AnwWMx4wZY8o+0bVrV+3MmTM+98eq40HF84w/jl2rr1eq3hvQw32B/K7cNx566CGvH5ZyOU/P64GKSvdm/fmwl5UrV/r1fQ7U9yKNGzc2fA8iIiJ8Pn40zbvaZ6qeM42i0vcrRnzdxquuukrbvn27Yfu//fabVqVKFcP3R8/JkydN+U5+y5Ytuu2//fbbPrfdpk0b3bbHjx/vdhuqjq2MqLLPmf2Z5eTkaOXLlw9Yv8yMqvuUSOCuZ95GpXHOldHjz+8tVLq22ekYIIR4H4q3E0K8iS8C3XdCiLrhdyWEEEIIIYQQQgghhBBCCCGEEEIIIYQQQggh/g+12tUK/6aWEDXi5N/O6/Hnb6lF1PituRPrcVz+GtXqwxnte1f2W/UacWbFDrVNA3W+MFLQMtQ2/ZvdajureJwaufw1gahvSm1T8wXTtUvVc43ZMbt2nlV18+wyBrgyKozfPTlOVahhqto5zYgZn4Hd9w+n1m1X+bNyam1bI5e/RrVxgzt99iZ2eeaSO9uv2memYswcb/LMjr9j1zGjr3HSc1MLS7du3XTXefz48YB+BqVKldIOHz6s27ecnBzt9ttvN1z2888/N9wX+/TpE/D96/LofTdg5+8FPKnTLaLOmFAvelS8H+1OfKknr5cWLVpoO3fudHu7C3Pu3DntwQcfdGvdqv19e3lUeJaCP98fb48jd5e16/lDj93Gf4QQQtQKtdoJId7EF4HuOyFE3fC7EkIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBD/h1rtaoV/U0uIGqFWO7XafX2fqdXu3r53Zb+dWgNNjwo1RFU8Xxgxu+9hYWHaqFGj3O63nqSkJC0+Pt6wD6Ghodr777+v5ebmer2OzMxM7aGHHjJtX1Shdo0q+5rV+1th7QRL/fXCYocahHpU3T95dsXfrKjxGUz1nYxc/ppAPLcibx8P9nNnIOvzuRM7HM95ClrGqbXEfQ3XbXP3Mztdt73ZPm8/H9WvsXapQ292zLz+mH3tEVHjXqOVx8/w4cN127jy+PE1UVFRuusprGa5avchjQTjvmaXc6zqY1xCCCGEEEJIcIVa7YQQb+KOUAEAAAAAAAAAAAAAAAAAwM/27dvn8TK1atWSkSNH6s5LT0+X3r17S05Ojo89s8Z3330n586dM5z/f//3f9KmTRuX6S+++KKMGzfOcLnw8HDDeenp6fL1118X2K8OHToYzlu5cqVcunSpwOUv5+02ili/nQAAAE5UsqJI3fYize8XadVPpHE3kRqNRMKKBLpnwa1o0aK60y9evOhVe1WrVpVNmzbJiy++KEWKmPPhtmzZUrZv3y7x8fGmtCciUqxYMZk1a5ZMmTJFKlSoYEqbV199tSxbtkyGDBniUzuhoaHy2WefyZIlS6R69eqm9C0sLEyeeeYZ2b59u9xwww2mtGnktttukw0bNkjjxo1NbbdJkyayY8cO6dq1q89tFS9eXD777DMZO3ashIba5+dqderUkW3btknv3r1Naa9bt26ybt06ueqqq0xp73IlS5aUlStXyogRIwzPM95o1qyZ/PLLL3LbbbeZ1uaVQkNDZfbs2TJw4ECf2ilVqpTMnz9f/vOf/7jMi4iIkIULF8pzzz0nISEhXq8jIiJCJkyYIK+88oovXfWbYcOGybfffivFixf3ua17771XfvrpJ6lRo4bPbdnp2PInq87nImqMF9LS0mTatGm68/r27WtKny7Xs2dP3fPh119/LdnZ2W61ocL75i1Vj3+7sfM+4C2njAGtPKd6ivPf3/yx7wfzue/555+XuXPnSqVKlXxuq27durJ582Z56KGH3Hp9WlqaTJ06VXeeu214onTp0rrfX547d07mzZtn+voCYefOnT63MWTIEPnuu++kXLlyPrdlxfFg1/OM2cy+Xtn13gD3BVyNHDlSJkyYICVKlPC5LU/P6/5m93uzvtqzZ0+gu+AXNWvW1J1+7tw5ycrK8nNv/manc6bK36+YqXbt2rJhwwapW7eu7vwff/xRWrZsKX/99Zfu/Pnz50tGRobL9IoVK0rTpk196lvlypXllltu0Z139913+9S2iBj+DT5jxgy3lmds5X9G/8Zx27ZtcubMGT/3xnzsU+ZwwjjHqntsql/bOAYAAAAAAAAAAAAAAAAAAAAAAAAAAACchVrt+pz+2/mCWFmvUKXfmjuxHkegmFEfTkT9GnFmcUptUxF16ptS2/RvdqvtrPJxaiRQ9U2pbWq+YLl22flc4wkraudZUTfPjmMAlcbv3gqGGqZmndM85YT9I1jqtjvhs/KWSrVtVR83mMVJz1wKls/MF2aPN3lmhz3HjHZn9nNT7ezChQuSkJAgubm5LvNCQ0Nl8uTJUrJkSZd5d999tzz22GO6bU6fPl0mTZpkel99offdgJ2/F3C3TrcTxoSq3I8ujK/15K/04IMPyurVq6VOnTqm9bFMmTLy9ddfy3fffSeRkZGmtesrT/6+tdOzFOzO7ucP1cd/AAAAAAAAAAAAAAAAAAAAAAAAAAAAANRArXZ91GqnVrsvqNXunWCugWbXGqJ2qY1zpdDQUJk9e7YMHDjQp3ZKlSol8+fPl//85z8u8yIiImThwoXy3HPPSUhIiNfriIiIkAkTJsgrr7ziS1dFxN61a+y6rxWE+uvOqUGo0v7Jsyv+ZnWNz2Cv7xSo51aIcO5UvT6fHY9nFahUS7wgXLfNZ8frttVUv8Y6qQ69J8y+/ph57VHpXiP8g2fUeE/Vc6zqY1wAAAAAAACz8DRFAAAAAAAAAAAAAAAAAIDf7du3z6PXh4aGyuTJkw1/jPjMM8/otpmVlaX7eqNCV3rTMzMzPeipvszMTPnyyy8N54eGhsrChQulZ8+eLvMeffRRmTt3rsfrnDJliiQlJRX4mri4OMN5iYmJHq3Pl20UsXY7AQAAnOTqOiK93hd5/BuRDs+KtHxA5LYeInc9KtLjLZGnZojc0VckIirQPQ1OlStX1p1+9uxZj9uqXbu2rF+/Xho0aODW67Ozs+XixYtuvbZ48eIyZ84cw/G5J8qWLSurVq2Se++91+e2rhQaGirvvvuuvPTSS14tX7RoUZk7d6488cQTJvfsb3mfUYsWLSxpv2bNmpKYmCilS5c2td1WrVrJihUrpGLFiqa2+8gjj8gXX3xhaptWqV+/vqxevVquvfZaU9u94YYbZMWKFaYUU8pTpkwZWbVqldx5551uvT43N1fS0tLcLuJXuXJlWbBggVSrVs2HXhobM2aMdO7c2ZS2QkJCZOLEiS7FxqdNm1bgPQ5PDR06VBISEkxrzwovvfSS1+dGIzfffLMsXbpUoqOjvW7DTseWP1l1PhdRa7wwduxY3en333+/REREuNWGu4wKoxZ0f/JyKr1vnlL1+LcbO+8D3nLKGNDKc6q3OP/9zcp9P5jPfU8//bS89957Pj1Y6EoREREyfvx4efrpp916vdE+Hhsba3gfxFvdu3fXPW6mTJli+L2v3fhawPjJJ5+Ud99916Te/M3M48Gu5xmzmX29svO9Ae4L5Ddy5EgZNGiQqW16el73F7vfmzWDXR724qtu3brpTv/ll1/83JO/2emcqfL3K2Zq1KiRrFu3zvAhCnPnzpV27drJhQsXDNtITU2VJUuW6M7r0qWLT/27++67DcfbdevWlWuuucan9jt16uQyLSkpSVasWFHosoytAqNevXq609euXevnnpiPfcocThjnWHWPTfVrG8cAAAAAAAAAAAAAAAAAAAAAAAAAAACAc1CrvWBO/u18QaysV6jab82dWI8jUHytDyeifo04sziltqmIevVNqW36N7vVdlbxODUS6Pqm1DY1VzBcu+x8rvGElbXzzKybZ8cxgGrjd28ESw1TM85pnnLC/hEsddud8Fn5QpXatqqPG8zipGcuBctn5gtPxpuqjDVVP/fbcczoBGY+N9UJ1qxZIyNGjNCdd80118jnn3+eb1rFihVl/Pjxuq8/cuSIPPbYY6b30VdG3w3Y9XsBd+p0O2FMqNr9aCNm1JO/XN++fWXChAkSFhbm1usvXrwo6enpommaW6/v2rWrLFmyRCIjI916vdXc/fvWTs9SsDu7nz9UH/8BAAAAAAAAAAAAAAAAAAAAAAAAAAAACDxqtReMWu2lTW9btd/yU6vdPMFQ79ZKdq0hapfaOHrGjBkjnTt3NqWtkJAQmThxotx22235pk+bNk3i4uJMWYeIyNChQyUhIcHr5e1cu8bO+1phgrn+ulNqEKq4f/Lsir9ZVeMz2Os7Bfq5FSLBe+5UvT6fHY9nVahSS7wgXLetY6frttVUv8Y6qQ69J6y8/vh67VHtXiP8g2fUeEfVc6zqY1wAAAAAAAAzhQe6AwAAAAAAAAAAAAAAAAAANWzevNnnH73/5z//0Z2+Z88e+fXXX/OtyxMvv/yyNG3aVHfewoULDX8gf/LkSd3p1atXl3Xr1uWbVqpUKSlVqpTbbXjq7bffln79+kmFChV050dGRsq0adOkf//+Eh8f/08BkdzcXOnZs6csW7ZMbr/9drfWlZqaKm+99VaBr6latarUqVPHcL5RMcSCeLKN7733nqxevdry7QQAAHCSFn1Emt8vUlC9vYhiIk17itx4p8js10TOHPJX7yAiUqtWLd3pp0+f9qidsmXLytKlSwssprt9+3aZPn26LF26VP744w85f/68iPxdRLF8+fJy6623Svv27aV37966f+uFh4fLxIkT5dChQ7Jx40aP+pcnIiJC5s+fL02aNDF8TU5Ojqxbt04WLVokW7ZskZMnT8rZs2clJCRESpUqJbVr15Y77rhDevXqJVWqVNFtY9iwYbJ//36ZPn26R/2bNGmS3H333Ybzc3NzZcOGDTJ//nzZvHmznDhxQs6dOydRUVFSqVIlue6666Rjx44SFxdn+PdymTJlZOHChdKsWTPZtWuXR/0rSFhYmHz33XemF6erVauWzJkzR0qUKGH4mszMTFm5cqUsWrRItm/fLidPnpSkpCSJjIyUcuXKSd26daVt27bSuXNnKVmyZL5l+/fvL9u2bTO1z2arXLmyJCYmSvny5Q1fk5GRIStXrpT58+fLrl275OTJk3L+/HkpXry4VKpUSapXry4dOnSQ+Ph4KVeuXL5lb7zxRhkzZox89dVXpvT322+/lYYNGxrO//HHH2XWrFmybt062bt3r6SkpPwzLzo6Wq699lq588475YEHHpBGjRrptlG+fHmZPXu2tGjRQi5dumRKv0VEunXrJo8++qjL9AMHDsjEiRNl9erV8ueff0pGRoaULVtWrrrqKmndurXcd999EhMTo9tmRESEjBs3Tho0aCDZ2dny3HPPSdeuXV1el5SUJNOmTZNFixbJ7t27JSUlRUqUKCGVKlWSW2+9Vbp27SqtWrUy7Pvo0aNl3bp1cvDgQe/fAIu0bdtWhg4d6jJd0zRZs2aNzJkzR7Zs2SLHjh2T9PR0KVmypFSoUEEaNmwoHTt2lNjYWMPiWrVr15aJEydKt27dPO6X3Y4tf7HqfC6i3nhhy5YtsnXrVpcCwGXKlJFOnTrJrFmzPN5GPddff73uveJVq1bJ/v37C11etffNE6oe/3Zj533AW04ZA1p5TvUF579/WbHvB/O574477pCPPvrIZXpWVpYsWbJEFi9eLFu3bpUTJ05Ienr6P2Oq2rVrS1xcnHTo0MHweAkJCZGRI0fKgQMHZMGCBQX2Y8uWLbJt2zapX79+vulhYWHSu3dv+eCDD7zexisZPfho/Pjxpq1Dz9GjR+Wnn34ynF+uXDmpXbu2y/Rz587J3r17PVrXjh07PO5fnqZNm8rHH3/sMl2V48Gu5xmzWXG9suu9Ae4L5PfAAw/oPgjQ3+d1f1H13uzx48cLPOdXrVpVqlat6jL96NGjcvToUbfWkWfLli0evd6O6tSpY/iwxblz5/q5N3+zyzlT9e9XzNKmTZsC/x798ssv5fHHH5fc3NxC25o+fbru/talSxd54YUXvO6j3oN3LxcfHy9jxozxqu2GDRvqjo3mzp1b6L7D2Cpw9Mb+IqL891+FYZ8yj6rjHHdZdY9N9WsbxwAAAAAAAAAAAAAAAAAAAAAAAAAAAIBzUKu9cE797XxBrK5XqOJvzZ1Wj+NydqkPJ6J+jTizOKW2qYia9U2pbfovu9V2Vuk4NaJCfVNqm3Lt8oSdzzWesrp2nhl18+w6BlBx/O6JQNcwtdM5zRt23z+CqW67ip9VsNW2VX3cYBYnPXMpWD4zX3gy3hwzZowSY03Vz/12HTM6gVnPTXWSl19+Wdq2bav7N1KvXr1k/vz5MnXqVBERmTBhglSoUMHldbm5udKnTx+5cOGC5f31ht53A3b9XsCdv1VVHBN6QsX70XrMrCcvIlKzZk359NNPJcTgC92//vpLpkyZIkuWLJEdO3bIqVOn8rVdtmxZiYmJkZYtW8q9996re19bRKRVq1byySefyGOPPaY7X8W/b1V6loI/359AsPP5Q/XxHwAAAAAAAAAAAAAAAAAAAAAAAAAAAIDAo1Z74ajVbj4Vf8tPrXY1akMGcw20QNcQ9ZZdauPo6datmzz66KMu0w8cOCATJ06U1atXy59//ikZGRlStmxZueqqq6R169Zy3333SUxMjG6bERERMm7cOGnQoIFkZ2fLc889J127dnV5XVJSkkybNk0WLVoku3fvlpSUFClRooRUqlRJbr31Vunatau0atXKsO+jR4+WdevWycGDBz3ebpVq13jCzvuaO4Kh/roep9QgVHX/5NkV/zK7xmew13dS4bkVIsF57lSlPp8ROx7PhQm2WuIF4bptLbtct62m+jXWSXXoPWHW9eejjz4y/dojoua9xmBlp/uQ3rD7vqbqOVb1MS4AAAAAAIDpNDeJCCGE6KZevXpaQkKClpCQoPXu3Vtr1qyZFhISEvB+EUIIIYQQQgghhBBCCCGEEEIIIYSIiNZuoGhDEv9Nu4GB75OZiYmJUerffhkZMWKE1202btxYu3Tpkm67p06d0ipWrGi4bHR0tO6yM2bMcHltnz59dNfRo0cP096fXr16Ffh55UlLS9O2bdumLV++XFu2bJm2Y8cO7cKFC24tq2ma9thjjxXal4cffthw+b1791q+jf7aTkIIcXJCQkK0xo0ba7179/7n33LWq1cv4P0K1vBvaonVaftk/r9t3Mng70QrXyPwfQ9EDh48qDuGNHN8r5ddu3bprveDDz7wqJ1ly5YZjoMPHz6s3XfffW63VbJkSe2tt97ScnJydNs7cuSIVrx4ca+2d9y4cQWO2WfOnKnFxMS41VZ4eLg2ePBgLT09XbetpKQkrWrVqm737ZVXXimwb4sXL9bq1q3rVlvFixfXXnnlFS0lJcWwvQMHDmglS5b06n280pAhQ7RBgwbprufcuXPahAkTtHvvvVeLiYnRSpUq5fZ6wsPDtW3bthluQ3Z2tjZ27Fjt6quvdqu96Oho7aWXXtIuXryYr520tDTtyJEjuuto0qSJpcdgYQkJCdF+/PFHw/cgJydHGzt2rFahQgW32ouIiNBeeOEF3X3jpZde8vk9eOqppwz7+vPPP3v8fnbr1q3Av7sfeeQRU/ZhTdO0119/XTt27Fi+acnJydojjzyihYaGFtheaGio9tRTT2kZGRmGfX300Ue1WrVqaZmZmfmm5+bmah9++KFbx2O7du20Q4cOGa5j9uzZpr0fmub5fTo9r776qm6fFyxYoN10001utVunTh1t+fLlhv3UNE3r3r27o48tK6LHqvN5XlQcLwwYMEB3+YULF5r2Xg8fPlx3Hb169bLt++bO/qTq8W/0eQwZMsTUYywqKkp3PSkpKY44dqyMHceAeqw+pxqtV9Pcu4Zz/svPm31fj6rnPrNjZO/evfn+Ozc3V/vss8+0KlWquNVu8eLFtZdffrnAvwEuXLjg1t/aTz75pO7yv/32m2nvQ9WqVbXc3FyXdWzdujWgn4/I339L6Zk5c6Zf94nt27e7TFPpeFD9POOPz8mK65Ud7g3o4b5Afh9++KGWlJTk0tdAndetjp3uzV6ZV199VXcdr776asDf18Li7+9FSpUqpf3yyy+660xOTtbKli3rcZtG3F3eDufMvKj8/Yqvn0Neunfv7nKevtzQoUM9aq9EiRIuf4vmuf766736HCIjI7W0tLQCP4tFixZ5/TkPHTpUt834+PhCl7XD2MpIoNoxI6GhoVpWVpZuf1q2bBmQPpkVO+xTIoH7nt/d2Gmco8fKe2wqX9vsdAwQQrxPSEiI1qRJE/49LSHEo/gi0H0nhKgbfldCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQ4v9Qq12t8G9qidWhVnvhcfJv50UCU69Q1d+aB1s9jsvj7/pwRvuepqlfI86M2LG2qdFnZvX5wog7y1LbND+71XYO9HFa0P6nSn1Tapty7XI3djjXmBF/1s7ztm6eXccAqo7f9aLHDjVMVanX7E1bdt8/gqVuu90+q8tj19q2RlQeNxjxtB27PnPJiMqfmSoxa7zJMzv+jl3HjGbH7s9N9SRGY8Hjx48H/HPIS0xMjOF97qSkJO2aa67RHn/8cYO9VtOGDx8e8G0oKEbfDTjxewE7jQn1qHw/+vKYXU9eRLR58+bptpWTk6O99NJLWmRkpEftNW/evMDrTbt27bz63Pz9962dnqUQiPfHiDdt2eX8oUf18R8hhBC1Q612Qog38UWg+04IUTf8roQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCHE/6FWu1rh39QSq0Ot9sJDrfb8qNXuWVSuyXJ5qHcb+OPODjVE9dilNo6e119/XTt27Fi+acnJydojjzyihYaGFtheaGio9tRTT2kZGRmGfXz00Ue1WrVqudTkyc3N1T788EO3zkvt2rXTrR+SZ/bs2R6/F3aoXaPH6n3N6v3N3XaCrf66HWsQ6lF9/+TZFfmZUeMzmOo7GVHluRUiwXfuVL0+n92O5zy+fCZ2rSXuabhu+2c/s8N125ftK6wd1a+xdq1Db0bMvP6Yfe1R9V6jVceP0TE8ZMgQUz/zqKgo3fWkpKT41C41agO3r6l8jlV9jEsIIYQQQggJ3lCrnRDiTdzhdkX3QG8MIUTd8EMTQgghhBBCCCGEEEIIIYQQQgghhKicdgPzFy9sNzDwfTIzMTExSv3bLyMjRozwqr2oqCiXwiKXu+eeewptIzEx0WW53NxcbeDAgVpYWJgmIlqLFi20kydPurwuLS3N6x9YGmXUqFEFfma+OnLkiFv/fmfWrFmGbYwaNUrpbfRkOwkhxMmheLta4d/UEitTL87zwu15eWyiaBFRgd8Gf+fgwYO648gePXpYts6WLVsajl+7devmdjsJCQmG7axdu9btolJXJi4uTktOTtZt9/333/e4vbZt2xr2Mz093aNCf5enQYMG2qlTp3TbHTdunFtt3HzzzYaF/C9duqQ9+uijXvWtZs2a2u+//2643Z9//rlX7V7p9ddf106fPp1vWkZGhvbOO+94XZBORLTnnnvOsO/nzp3TWrdu7VW7N9xwg3bgwAHDti8XqMJleXnkkUcM+5aSkqLdddddXrV77bXXan/88YdLe768ByVLltTOnDmj28akSZP+uafhaW6++WaX4vN59u7d69X4Rc+VRRwPHjyoXXfddR61e88992iXLl3SbX/Xrl3alClT8k1LT0/XOnTo4NE6qlevrh09elR3HdnZ2V4V0DdiRjuHDx/O99/entNCQ0O18ePHG/Z18+bNjj22rIoeq87nIuqOF0qWLKn7MJTs7Gztqquu8vl9DgkJ0T1mz549q0VERNj2fXNnf1L1+LdbQUq77ANmxo5jQD1WnlMLWq+muXcN5/znytN9X4+q5z6z446kpCSvx1S1atUq8G9Zd4rwlipVSktPT9ddvmHDhqa8D0OGDNFt/+mnnw7o5yOiTgHjy6l2PNjhPOOPz8ns65Vd7g3o4b5Aflc+ACPQ53UrY7d7s1fGzg978ef3IjExMdpvv/1m+Hm88MILXrVrxJ1l7XLOFFH7+xVfP4e8DBgwwPDhTjk5OdoTTzzh1TbOmTNHt01v70N07NjRcHvzZGRkaFFRUV61r/dwggsXLmhFihQpcDm7jK2MBKodM1K1alXD/lx77bUB6ZMZscs+JRKY7/ndjd3GOXqsusem+rXNTscAIcT7ULydEOJNfBHovhNC1A2/KyGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgjxf6jVrlb4N7XEylCr3b049bfzedFjZb1C1X9rHiz1OK6Mv+vDGe17V1KtRpxZsWNtU6PPzOr6pkbcWZbapq5UrO1sJNDHaUH73+UCWQeP2qZcu9yJXc41vsbftfO8rZtnxzGA6uP3K6PHDjVMVanX7M0xYvf9I1jqttvts7o8dq1t6w7V9jcjnrZj12cuuUO1z0yFWDHeDPZndthxzGhF7PzcVE9jNBY8fvx4wD+Hy/Poo48avj8///yz4T2KLVu2aOHh4QHvf2HR+27Aad8L2G1MqEfl+9F5saKefIUKFQyfM+LLeTEiIkKbPXu2brsbNmzwqk1//n1rp2cpBOL9MWufzntP7HL+0KP6+I8QQojaoVY7IcSb+CLQfSeEqBt+V0IIIYQQQgghhBBCCCGEEEIIIYQQQgghhBDi/1CrXa3wb2qJlaFWu3uhVvvfqNXurJosV4Z6t/6NHjvUENVjh9o4Ru0cOXIk338fPHhQu+666zxq95577jGskbNr1y5typQp+aalp6drHTp08Ggd1atX160Jr2l/152vWrWq223ZpXaNHqv3Nav3N3fbCbb663asQahH9f2TZ1e48rXGZzDVd3JHoMctwXTuVL0+nx2P5zy+fC52rSXuabhu+2c/U/267ev2FdaO6tdYu9ah9zVWXH/Muvaofq/RiuNn+PDhum14e//SKFFRUbrrSUlJ8aldatQGbl9T9Ryr+hiXEEIIIYQQEtyhVjshxJu4w+3A40ZCAAEZFElEQVSK7oHeGEKIuuGHJoQQQgghhBBCCCGEEEIIIYQQQghROe0G5i9c2G5g4PtkZmJiYpT6t19GRowY4VV7n3/+uWGbY8eOdauNVq1aabm5ubptXLx4UTt//rzhOt577z3T36OwsDDt66+/LvBz89WoUaMK7ENoaGiB292xY0flt9Gd7SSEEKeH4u1qhX9TS6xKRJRoT83wvnj7kETR7ugb+O3wdw4ePKg7hvSlgEhBiYyM1Hbv3q27zvPnz2vFihVzq52iRYtqf/31l247W7du1YoWLepTP7t06aLbdmZmplapUiW32wkNDdX27t2r21ZaWprPxanq1aunWwDtt99+c6tA2dq1a3X7lpWVpbVr186nvkVHR2sbNmzQbT83N9erbb/Snj178v336dOntebNm/vU79KlSxsWUTx79qxWu3Ztn9q/6qqrXAps6wlE4bK8lChRwqXwX57k5GTt1ltv9fk92L9/v2nvQbly5bRRo0a5FItfuHChz+9F7969DfvnzT2Bwpw5c0arUaOGV3195513Cm1f0zQtJydHi4uL82odbdq0MWx32LBhpr0fZr+vOTk5Wrdu3XzaF1avXm3Y/h133OHIY8uq6LHifC6i/njB6L7g888/7/O2t2vXTrftkSNH2v59K2x/upwqx7+IvQpS2mkfMCt2HQPqseqcWth6Nc39azjnv/w83fcLo9K5z+wUJi0tTbvlllt8Wkd0dLT2888/G66jRYsWhbbxzTff6C77ySefmPI+bN++3aXtrKwsrVy5cgH7bPKiSgHjPKodD3Y5z/jjczL7emWXewOF4b5Afqqc162K3e7NXhk7P+zFH9+L1K9fX/vss88Mi7hrmqYlJiZ6/R2pEXeWtcs5U/XvV3z9HEREe/311w3byMjI0O69916vt+/+++/XbXf9+vVetTdmzBjDvl6uU6dOHrddo0YN3bYmTZpU4HJ2GlsZ8bRPZrVjRm688UbD/nj7gOdAx077lIj/v+f3JHYb5+ix4h6b6tc2ux0DhBDvQ/F2Qog38UWg+04IUTf8roQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCHE/6FWu1rh39QSq0KtdvfjxN/OXx49VtYrVP235sFQj0Mv/q4PZ7TvXU61GnFmxa61TY0+M6vrmxpxd3lqm+anYm1nFY9Td7ddhTp41DZ1xbXr39jpXONrAlE7z9O6eXYdA6g+fr8yhVHh3K0XVeo1e9qO0/YP1c7jZsZun9XlsWttWzvub0Y8acPOz1yy42cW6Fg53gzWZ3bYdcxoRez63FRvYjQWPH78eMA/hyszd+7cQvefy6WlpWkxMTEB77c70ftuwGnfC9htTKhH9fvRVtWT79evn26b06ZN83mbw8PDtfXr1+drd+nSpV7vE/78+9Yuz1II1Ptjxj6dFzudPwqj2viPEEKI+qFWOyHEm/gi0H0nhKgbfldCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQ4v9Qq12t8G9qiVWhVrv7oVY7tdo1zXk1Wa4M9W79m8KoWkNUj+q1cdx9z8+cOaPVqFHDqz6+8847hbavaX/v03FxcV6to02bNobtDhs2zO127FK7Ro/V+5o/9jd3lw+W+ut2rUGoxw77J8+uyM/MGp9OHrMUtu2aps64JVjOnSrX57P78exL3+xaS9yTcN32LL7uZ6pet83avsLayaPaNdbOdeh9jVXXHzNqw6p+r9Hd/d6TNoYPH67bxpAhQ0z93KOionTXk5KS4lO71KgN7L6WR6VzrMpjXEIIIYQQQgihVjshxJu4I1QAAAAAAAAAAAAAAAAAAFBQfHy8PPbYY7rz9u/fL4MHD3arndWrV8uHH36oO69o0aJSunRp3Xlbt26Vl19+2a11eCInJ0ceeugheeONNyQnJ8f09kVEBg4cKK+88orh/KZNmxpud1ZWlqxatcqn9ftjG0UK304AAAAnqNtepFhJ39q4pZNIWBFz+gNXJUuWlMWLF8v111+vO3/8+PFy8eJFt9q6//775aqrrnKZnpycLF27dpWMjAyf+jpnzhz56quvXKZHRETIk08+6XY73bp1k9q1a+vOe+KJJ2TTpk1e91FEZPv27fLss8/+89+bNm2Srl27Sr169SQrK6vAZW+//XZp0aKF7rznn39eli1b5lPfUlJS5N5775VTp065zAsJCZEXX3zRp/ZFRGJiYv75/0lJSdKsWTNZv369T23269dPoqOjXaZrmiYJCQmyb98+n9o/fvy43HvvvZb+DeirBx98UMqXL6877+mnn5YtW7b41P7x48clISHBtPfg7Nmz8tRTT8m1114rH3zwgaSlpUlSUpI88MADPrf97bffym+//aY7r02bNj63f6UHH3xQDh065NWyw4YNk3PnzhX6unfffVcSExO9WseKFSsMl42NjfWqTX947bXX5LvvvvOpjYceekguXbqkO69z585utWG3Y8ufrDifi6g/Xhg7dqzu9H79+vnULxGRvn37erTOy6n+vnlClePfbpy0D7jLSWNAq86pZuL8l5/Z+34wn/ueeOIJ+eWXX3xqI+9v2fPnz+vOd+d7V6P97f7775fw8HBfuic333yz1K1b12X6/Pnz5ezZsz617USqHQ9OOc+YwezrlVPuDXBfID9VzutWcMK9WSe66aab5I477vAobdq0kc6dO0tCQoK89NJLMnXqVPnjjz9k69at8sQTTxhe+5ctWyZdu3YVTdP8vJX2OWeq/P2Kr0JCQmTMmDHy2muv6c5PTk6WuLg4mT17ttfrmDdvnmRmZrpMb9q0qVSsWNHj9u6+++58/52dnS1r1651ed0999zjcdtGY6oZM2YUuBxjq8AqXry47nRN0yQ9Pd3PvTEH+5Q5nDLOseIem+rXNo4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAZ6BWu/uc+Nv5wlhVr9AOvzUPhnocdqFajTizOKm2qYj69U2pbZqfirWdVTxO3aVCHTxqm6pFtWuXk841hbG6dp4eT+vm2XEMYIfxu6dUOHc7hRP3D9XO42Zx4mflBE7d35z8zCWnfma+sHK8GazP7LDjmNEJzHxuqtP169dPTpw44fbrn3nmGdm7d6+FPTKP3ncDTvpewCljQlXvR1tdT75WrVq60ydOnOhVe5fLzs6Wvn37ysWLF2XSpElSv359ad++vc/7hD/Y5VkKdueU80ce1cZ/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKLWu3uo1Y7tdpFnFWTxS6CuVaCnWqIqlobx1MPPvigHDp0yKtlhw0bJufOnSv0de+++64kJiZ6tY4VK1YYLhsbG+t2O3auXeOUfc0dwVJ/3Uk1CO2wf/LsivzMrPEZzGMWEXXGLcFy7lS5Pp8TjmcY47rtX6pet/1NtWusk+vQF8aq64+v1x473GuEMzhxX1PpHKvyGBcAAAAAAMAymptEhBBCdFOvXj0tISFBS0hI0Hr37q01a9ZMCwkJCXi/CCGEEEIIIYQQQgghhBBCCCGEEEJERGs3ULQhif+m3cDA98nMxMTEKPVvv4yMGDHCo3YqVKignTx5Uret7Oxs7bbbbvOovfDwcG3y5Mnu/pM5bfv27Vr16tUtf78aN26sbd682e1+eWrAgAG6633zzTcNl1m+fLmttrGg7SSEEKcnJCREa9y4sda7d+9//i1nvXr1At6vYA3/ppZYlZ7v5P+bxttc2yjw2+LPHDx4UHfs2KNHD1PX06FDB23Xrl2GY9UzZ85oFSpUcLu9X375RbedN99807Q+16xZU8vJyXFZx6FDh9xu48cff9Tt59y5c03rZ0hIiDZ69GitVatWHi03d+5c3b4tW7bM1M++U6dOuuvJzc3Vateu7VFbBenatasp/d23b59u++PHjzf1ffnss88K3J4mTZqYuj5P8vvvv+v2adGiRaau56OPPrLkPShXrpx2++23m9bPJ598Urd/mzZt8ritgsyZM8fnvo4dO7bAdRw9elQrVqyYT+vo3r27bttZWVlaZGSkKe+Hme/r1q1btbCwMFP2hRkzZuiuY+PGjW4tb/djy6wUxqzzuYg9xgs7d+40/XMqWbKklp6e7tLm+vXrHfO+ubM/qXT8i4g2fPhw3TaGDBli2vsqIlpUVJTuelJSUtxuw077gFmx6xiwMGaeU91ZrydtcP7Lz5N9vyCqnfv8te9pmqatWbPG1HX1799fdz2XLl3SKleuXOjyRvdAOnfu7FO/3nnnHd124+PjA/a5XJ5u3brp9m/mzJl+3ydUPB7scp7x5+ekadZcr1S9N1AQ7gvkp9p53ezY8d7slXn11Vd123711Vf9/n56GqPvRfzh0qVL2uuvv+7zNcqIN22pes5U+fsVXz6HiIgIbebMmYbLHj9+XKtfv74p22d0rnn44Yc9aqdBgwYubSxfvlz33PrXX3953M8ffvjBpZ3k5ORCryt2GlsZ8cc+Z1VatWql25eLFy8GpD9mxE77lIjx9ez//u//tFtuucXUVK1a1e1+2XGcUxiz/mZR/dpmt2OAEOJ9QkJCtCZNmvDvaQkhHsUXge47IUTd8LsSQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEP+HWu1qhX9TS6wKtdrdjxN/O395CmNm/Se7/Nbc6fU49OLv+nCF7Xsq1ogzK3atbVrYZ6Zp1tSLM+JJG9Q2zU/F2s6qHafubLtKdfCobZof165/Y6dzjdkxu3aeHk/r5tlxDGCX8Xthn1Uelc7dV0aVes2etOG0/UPF87hZseNndXnsWtvWjvubEU/asPMzl+z4mQU6Vo83g/GZHXYcM1oVuz431ZsYjQWPHz8e8M9BL+3bt9dyc3ML3Ic0zdw6qv6K3rjJKd8L2HFMWBhV7kf7o578hAkTdNuOiYkxbdujo6NNaScQ9+zyouqzFAL5/nizT18Zu50/CqLi+I8QQoj6oVY7IcSb+CLQfSeEqBt+V0IIIYQQQgghhBBCCCGEEEIIIYQQQgghhBDi/1CrXa3wb2qJVaFWu/uhVju12vM4pSaLXqh3698UROUaooVRpTaOp32fM2eOz/0cO3Zsges4evSoVqxYMZ/W0b17d922s7KyvDruRdStXVMYK/Y1f+xvnrQRDPXX7VqDsDAq7588uyI/M2p8On3MUtC2a5p645ZgOHeqXJ/P7sezL/2yay1xT8J127OYsZ+peN02c/sK+3xUvMbauQ69r7H6+uPttccu9xovjxFP2hg+fLhuG0OGDDF1u6OionTXk5KS4lO71KgN7L6maeqdY1Ue4xJCCCGEEEIItdoJId7EHaECAAAAAAAAAAAAAAAAAA52dIfI1kX/5uiOQPcI7hg3bpxUrFhRd96wYcNk48aNHrWXnZ0tCQkJ8sQTT8i5c+cKfN3YsWPltttukz///NOjdXhj8+bN0rhxY4mLi5PvvvtO0tPT3VouOztbEhMT5c0335ScnBzD13366afSo0cPl+mxsbGGyyxevNitPrjL220U8X07AQAAnKB8dXPaKXeNOe1A5Oqrr5aBAwfK+vXrZdGiRXLDDTcYvnbgwIFy+vRpt9q95pprpGHDhi7T09PT5aOPPvK6v1c6cOCALF++3GV69erV5cYbbyx0+YoVK0qLFi1057377rs+9y+PpmnyxBNPyOrVq91eJjo6Wjp06KA7b/jw4WZ1TURE5s2bJzt37nSZHhISIvfdd58p6/j+++/l+++/97mdmJgYue6663TnffDBBz63f7lhw4ZJdna2qW2aISYmxnD/fuutt0xd1wcffFDg37DeOnv2rPz444+mtbdy5Urd6Q0bNpSwsDDT1vPmm2/63Mbs2bMLnD9y5Ei5ePGiT+tYsGCBZGVluUwvUqSI7rk50F555RXT9rMJEyboTr/lllskKiqqwGWdcGz5g1nncxH7jBe+/PJL3el9+/b1uk89evSQYsWKuUwfO3Zsocva5X1zhyrHv904aR9wl1PHgGaeU63A+S8/s/b9YD73mTGevtykSZN071OEh4dLXFxcocsb7eMPPfSQT/3q1auXy7QTJ05IYmKiT+06kWrHg1POM2az6nrlz3sDZuG+QH6qndfN5LR7s3Dfnj17pE6dOvL6668rde9GxfupKn+/4osSJUrI4sWLDY+//fv3S/PmzWXbtm2mrG/GjBm607t06eJRO3fffbfLtHnz5smCBQtE07R806+66iq55ZZb3G67TJkycvvtt7tMnz9/vmRmZhoux9gq8CIjI3Wnm3Xfo1atWtKxY0dT4s6Y3Un71Ntvvy0///yzqUlISHBr3U4c55j1N4vq1zYnHQMAAAAAAAAAAAAAAAAAAAAAAAAAAADBjlrt7rP6t/Mi/v/9vLvMrP9kp9+aO7keh12oViPOLE6tbSqidn1Tapvmp2JtZ5WOU3epVAeP2qZqUO3a5aRzjTfMrp2nx5O6eXYcA9hp/O4ulc7ddufE/UO187hZnPhZOYFT9zcnP3PJqZ+ZL/wx3gy2Z3bYccxoV1Y9NzVYLF26VEaNGlXga06cOCH9+vXzU4/Mo/fdgBO+F3DimFCV+9H+qidv9F3llfuUL1JSUkxrK1BUfJaC3Tnt/KHa+A8AAAAAAAAAAAAAAAAAAAAAAAAAAABA4FGr3X3UaqdWex4n1GSxi2CulWDXGqKq1Mbxhhnv+ezZswucP3LkSLl48aJP61iwYIFkZWW5TC9SpIhufTx32LF2jZ33NU84vf66U2sQqr5/8uyK/Myo8RnMYxYR9cYtTj93iqhbn88JxzOMcd0ODNWu2/6m2jXWyXXo3WH19ceba4+d7jXC3py4r6l2jlV1jAsAAAAAAGCl0EB3AAAAAAAAAAAAAAAAAACstGuVyNJP/s2uVYHukbn27t0rISEhhvE3o348//zzHrXTqVMnw7Zef/11r/s3ZswYqVatmvTo0UM+/vhjmTVrlsyZM0e++uorefLJJ6VGjRry2GOP+Vyky1NLliyRe++9V8qVKyetWrWSUaNGyTfffCNz5syRefPmyZQpU+Szzz6TZ599Vtq1ayelS5eWDh06yKuvviqPPfaYYbuhoaHyxRdfSMmSJf+ZVq5cOWnUqFGBfbHCldv45JNPWrqdAAAATlHMpCFO8TLmtGN3Xbp0kSFDhriVF154QV5//XX54IMPZOzYsbJixQo5ceKEHD16VEaNGiXNmjUrcF1Dhw6VadOmud23du3a6U5fvny5nDt3zqPtLMyqVat0p995552FLhsXF6f79+avv/4q69ev97Fnvmnfvr0UKVLEZfqOHTsMCxX7YuTIkbrT77nnHkvb91T79u11p69Zs0a3yJAvjh8/LgsWLDC1TTMYFRHdtm2brFu3ztR1HT16VBYuXGhqm1bYvXu3pKamukwPDw+XMmXMuWhs27ZNfv75Z5/bKaiN3NxcmThxos/ruHjxouzevVt33rXXXutz+2b6888/Zf78+aa1t27dOt0iW+Hh4VK9esFPkeHYco9Z53MR+4wXvvnmG92HlPTq1cuw2Fth9AqgJicnGz7M5XJ2ed8Ko9LxbzdO2Qc84dQxoJnnVCtw/nPl674fzOe+P//8U5YtW2Zqm5mZmTJu3Djdee48fGHixIm6DyqKj4+X8uXLe9Wn22+/Xa65xvWpg5MmTVKuMHagqXg8OOE8YwXVr1d5Cro3YAbuC+Sn4nndTE67Nwv3XX/99bJkyRIZMmSIFC1aNNDdsYwZ91NV/n7FWxUqVJDVq1dL69atdef//PPP0rx5czl48KBp65w3b57u311t27b16KFqnTp1cpk2f/58OXHihGzZssVlnt6DgI3cfffdug/JnDlzZoHLMbZyvqeffloWLlxoSqpWrVro+tinCrZ//363XufEcY5Zf7Oofm3jGAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAOarWrxd+/n3eXmfWf7PRbcyfX47ADFWvEmcWptU1F1K4XR21TV6rVdlbpOHWHanXwqG0aeCpeu5xyrlGFr3Xz7DgGsNP43R2qnbvtzon7h2rncbM47bNyAifvb0595pKTPzNf+Gu8GUzP7LDjmDEQVH5uajA5evRogfMvXLggaWlpfuqNefS+G3DC9wJOHBOqcD/an/Xkk5KSdKer9jxQp/HHs2lV56Tzh4rjPwAAAAAAAAAAAAAAAAAAAAAAAAAAAACBR612tVCrXa3f8lOrPbCCuVaCnWuIqlAbxxvbtm2Tn3/+2ed2CmojNzdXJk6c6PM6Ll68KLt379adp0pNHn/UrrHrvuYpp9dfd2oNQtX3T55d4cqXGp/BPGYRUXPc4vRzp4i69fnsfjyjYFy3A0O167Y/qXiNdWodenepeP2x071G2JvT9jUVz7EqnmMAAAAAAACsFhroDgAAAAAAAAAAAAAAAAAA4E/p6ekyc+ZMGTx4sHTv3l26du0qjzzyiIwePVqOHTsW0L5lZGTImjVr5Omnn5YHH3xQunbtKp07d5bevXvLwIED5aOPPpLly5dLWlraP8uMGzdOXnzxRd32zp07Jx06dJDk5OR/prVr105CQ/X/+eBff/0lO3bsMHejrpC3jaNHj7Z0OwEAAJziUoY57WRdNKcdu+vVq5e8++67buWdd96R1157TZ599ll55JFHpHXr1lKpUqVC16FpmgwdOlRee+01j/rWsmVL3elLlizxqB13/PTTT7rTb7rppkKXvf3223WnW9FPT91111260xMTEy1Zn1G7t912m9cF2vLs3r1b1qxZ41Mbl/dHzw8//GBK+1datGiRJe36olmzZrrTrSo26K8ihr7QNE2OHz+uO69s2bKmrMOs88KZM2fk9OnTuvO2bt1qOM9TRgUtS5cubUr7ZjF7/0pOTpY//vhDd15hhdw5tgpn5vlcxD7jhXPnzsn333/vMr1UqVLSpUsXj/ty3XXXSfPmzV2mT5kyRdLT0wtd3i7vW2FUOv7txin7gCecOAY0+5xqBc5/rnzd94P53Ld06VJL2jUqYNu4ceNClz179qzMmTPHZXqRIkWkV69eXvUnISFBd/qECRO8as/JVDwenHCeMZsdrld5Cro3YAbuC+Sn4nndTE66NwvPXXvttfLuu+/Kvn37dB+W6gRm3E9V+fsVb1SvXl3WrVsnt9xyi+78ZcuWSatWrUw7T+dJSUnRPacWLVpUYmNj3WqjUqVKcuutt+abtmPHDjl48KCIiMydO9dlGU8ezqD3919aWlqh50TGVs5Xu3Ztv66Pfapg+/fvd+t1ThvnmPk3i+rXNo4BAAAAAAAAAAAAAAAAAAAAAAAAAAAA56BWu1r8/ft5d5hd/8lOvzV3cj0OO1CxRpxZnFjbVET9enHUNnWlWm1nlY5Td6hWB4/apoGn4rXLKecaVfhaN8+OYwA7jd/dodq52+6ctn+oeB43i9M+Kydw8v7m1GcuOfkz84W/xpvB9MwOO44ZA0Hl56YGiwYNGsiwYcMKfM31118vH3zwgZ96ZB697wac8L2A08aEKtyP9nc9eaP7Et7e+4N7/PFsWtU56fyh4vgPAAAAAAAAAAAAAAAAAAAAAAAAAAAAQOBRq10t1Go3H7Xa7SuYayXYtYaoCrVxvGVWDbkzZ84Y1t3ZunWraTV5du7cqTu9dOnSprTvK6tr19h5X/OU0+uvO7EGoR32T55d4cqXGp/BPGYRUXPc4vRzp4i69fnsfjyjYFy3A0O167Y/qXiNdWodenepeP2x071G2JvT9jUVz7EqnmMAAAAAAACsFhroDgAAAAAAAAAAAAAAAAAAAN8MHz5cPvroo3zTjh07Ji1btnQpjtGhQwfDdlQvHujJdgIAADhFyhlz2kk2pxYtCnHixAmJjY2V1157zeNlb7jhBt3pGzZs8LVbLoyKrMTExBS67I033qg7ff369T71yQx16tTRnb527VpL1nf06FE5cuSIy/TQ0FC5/vrrfWp71apVPi1/OaO+WLFviYj8+OOPlrTrC6Pja926dZasb+PGjZa0a7YLFy7oTjejeLeIueeFEydO6E438702WocqBdfzWFG8Uu9cJlL4vsCxVTgzz+ci9hkviIh88cUXutP79u3rcV8eeugh3eljx451a3k7vW8FUen4txun7AOecOIY0OxzqlU4/+Xn674fzOc+q46rTZs2iaZpLtNr1KghERERhS5vtP8Z7a8FKVKkiNx3330u0zdu3Ci7du3yuD2nU/F4cMJ5xmx2uV7lMbo3YAbuC+Sn6nndLE66N+s0KSkpcubMGa9y/vx5yczMdHtdVatWlTlz5shbb71l4RYFjq/3U1X+fsVTdevWlQ0bNhg+9Hjq1KkSHx8vaWlplqx/xowZutPdfXhOfHy8hISE5Js2f/583f+fp1GjRlK5cuVC246MjNR9wPCCBQskI6Pgp3YztlLXlfuLt6677jpT2nEX+1TBjB5sciWnjXPM/JtF9WsbxwAAAAAAAAAAAAAAAAAAAAAAAAAAAIBzUKvdd2b9dl7E/7+fd4fZ9Z/s9ltzp9bjsAMVa8SZxYm1TUXsUS+O2qb5qVjbWZXj1B0q1sGjtmlgqXjtcsq5RhW+1s2z4xjAbuP3wqh47rYzp+0fKp7HzeK0z8oJnLy/OfWZSyp+Zrfffrv89ttvpqdu3bpub4O/xpvB9MwOO44ZnciX56YGg6JFi8rUqVPdGus+8cQTEh8f74demUvvuwG7fy/gtDFhoO9HB6KevNFn9cADD0j37t1NWw9cWf1sWtU56fyh4vgPAAAAAAAAAAAAAAAAAAAAAAAAAAAAQOBRq9131Gr3jN1+y0+t9sAJ5loJdq0hGujaOL5Yv369aW2dOHFCd7qZ9QON1lG6dGnT1uErK2vX2Hlf84aT6687sQahXfZPnl2Rny81PoN5zCKi7rjFyedOEXXr89n9eFadFTWZPanHzHU7cFS6bvuTitdYp9ahd5eK1x+73WuEfTltX1PxHKviOQYAAAAAAMBqoYHuAAAAAAAAAAAAAAAAAAAA8N2zzz4rkydPFhGRPXv2SLNmzXSLkugVDsyTmJhoWf/M4u52AgAAOMWhX81p50+T2oG+M2fOyAsvvCDXXXedLFu2zKs2jArY/fnnn750Tdf58+d1p5cpU6bQZY0Kz/z6a+B3shtvvFF3+i+//GLZOn/++WeP+uIuM4t/1a5dW3f69u3bTVvH5f744w/Jzc21pG1vGT14war9dseOHZKVlWVJ276qXLmytGjRQvr06WNYmMmMQvEiIvv27TOlHRGRlJQU3el79+61fB0qFVwXEUvugxgVci9s2zm2Cmd2MUe7jBdE/i62un//fpfp7dq1k6uvvtrtfoSEhMgDDzzgMv2XX35xe1+z0/tWEJWOf7txyj7gCSeOAVUrkGuE819+vu77wXzuM3M8fbkLFy7o7gOhoaFSs2bNQpdfsWKFHDhwwGX6LbfcIjfffLNHfenQoYPu3yXjx4/3qJ1goeLx4ITzjNnscL1y596AGbgvkJ+q53WzOOnerNP0799fKlSo4FXKli0rRYsWlSJFisjVV18t7du3lyFDhsi6det0H+Yk8vc49sUXX5Q33njDz1tqDTPvp6r8/YonWrZsKWvWrJGrrrpKd35qaqo8+eSTcunSJcv6MHfuXMnMzHSZfvfdd0toaOFl9Tp16qTbZp7t27fL4cOH880PCQmR+Pj4Qttu27atFC9e3GX6zJkzC12WsVXg6e1XIiLh4eE+tx0WFiY1atTwuR1PsE8ZO3XqlOH470pOG+eY+TeL6tc2jgEAAAAAAAAAAAAAAAAAAAAAAAAAAADnoFa7+6z87bxIYH4/7w6z6z/Z7bfmTq3HYQcq1ogzixNrm4rYo14ctU3zU7G2syrHqTtUrINHbdPAUvHa5ZRzTaDl1c7ztW6eHccAdhu/F0bFc7edOW3/UPE8bhanfVZO4OT9zanPXFLxM4uOjpabb77Z9BQrVsztbfDXeDOYntlhxzGjk5jx3NRg8OGHH8oNN9zg9usnTJggFStWtLBH5rv8Pn4eu38v4LQxYSDvRweqnvzatWvl7NmzLtNDQ0Nl+vTpMnHiRKlfv76p6wxm/nw2reqcdP5QcfwHAAAAAAAAAAAAAAAAAAAAAAAAAAAAIPCo1e4+arWbw26/5adWe+AEc60Eu9YQtUOtdiNmvucpKSm60/fu3Wv5OgK9L/urdo2d9zVvOLn+uhNrENpl/+TZFfn5UuMzmMcsIuqOW5x87hRRtz6f3Y9n1VlRk9mTesxctwNHpeu2P6l4jXVqHXp3qXj9sdu9RtiX0/Y1Fc+xKp5jAAAAAAAArFb4v0AEAAAAAAAAAAAAAAAAAAC28NBDD8mIESOkRYsWcuTIEZf59evXl0qVKukum5OTI8uXL7e6i6YobDsBAACcZOdyEU3zrY0/t4qkutbTgI+ys7Nl2rRp0rVrV6lWrZq89957kpaW5nV7egXsLl68KOfOnfOlm7pSU1N1p0dHRxe6rFGx39OnT/vUJzNUqFBBd7qVfTtz5ozu9PLly/vU7rZt23xa/nKlSpXSna5XaMcMly5dkr/++suStr0RGhoqJUqU0J1n9Pn5Kjc315Jj1x2RkZFy/fXXS8eOHWXgwIEycuRImTdvnuzYsUPS09Pl+PHjsnbtWvnmm29MKQhfEDP3A6Pz1okTJ0xbh1HBdXceBOFPx44dM73N5ORk3ekFbXuwHVveMvN8LmKf8UKeL7/80mVaaGio9OnTx+02WrduLdWqVXOZPnbsWLfbsNv7ZkSV49+OnLIPeMKJY0Czz6lW4vz3L1/3/WA+91lRVD+P0T7gbnH9r776Snf6Qw895FE/EhISXKZdvHhRpk2b5lE7wULF48EJ5xmzqXC9UuXeAPcF8lP5vG4GJ92bhavs7Gz566+/ZNmyZTJixAhp2bKl1KxZs8AHlb766qty9913+7GX3vHnOVPl71fcdc8998iyZcsKLPpfokQJ+eKLLyztR0pKiixdutRletmyZaVly5YFLhsRESFt27bNN+3UqVOyadOmfNPmzZvnsuw999xTaN+6dOniMi09PV0WLVpU6LKMrQIvIyNDd3pkZKTPbVerVk0yMzMlNTXVo2g+/GMBJ+1TAwcOlOrVq5uWBg0auL1up41zzPybRfVrm5OOAQAAAAAAAAAAAAAAAAAAAAAAAAAAgGBHrXb3WfnbeZHA/H7eHWbXf7Lbb82dWo/DDlSsEWcWJ9Y2FVGjXpw7qG36LxVrO6tynLpD1Tp41DYNHBWvXU4511jN3dp5vtbNs+MYwG7j98Koeu62K6ftHyqex83itM/KCZy6vzn5mUtO/cx85a/xZjA9s8OOY0a7M/u5qU539913y4ABA3TnGY0tKlSoIBMnTrSyW6bTe76C3b8XcNqYMFD3owNZT/7SpUsyfPhw3XkhISHywAMPyNatW+XIkSPy3XffyZtvvikPPvigtGjRQipVqmR6f+xOlefP2IGTzh8qjv8AAAAAAAAAAAAAAAAAAAAAAAAAAAAABB612t1HrXZz2O23/NRqD5xgrpVg1xqidqnVrsfMmmRG9eNOnDhh2jr0akWJWL8vq1K7xs77mrecWn/diTUI7bR/8uyKf/lS4zOYxywiao9bnHruFFG3Pp/dj2cUjOt2YKly3fYn1a6xTq5D7y4Vrz92u9cI+3LavqbaOVZEzXMMAAAAAACA1cID3QEAAAAAAAAAAAAAAAAAAGCOnJwcGTJkiOH8uLg4w3mbNm2S8+fPW9Et0xW2nQAAAE5ycr/Inh9FbrjDu+W1XJHV483tk5399ddfhgVKjJQsWVKqVKniMj0sLEzef/99+fnnn33uV1RUlISEhLhML1asmFy8eNHn9q+kty6RwgvdR0VF6RZyyczMlMzMTFP65q1ixYpJWFiYy/TMzEzDwv5mMPo7yteChGYV1zPatzIzMyUrK8uUdegxKlwdCEafRWpqqmRnZ1u23qSkJKlcubJl7VepUkUaNWok9erVk+uuu05q1qwptWrVkipVqhge4/6WlpZmWlu5ubkBW4dqrDi+vNl2px5bZjOzWKpdxguX+/rrr2XYsGFSpEiRfNP79esn77zzjltt9O3b12Vaenq6TJkyxa3l7fi+GVHl+LcbJ+0D7nLqGNCqAtRW4Pz3L1/3/WA+93l6/8ITSUlJutONCl9facKECTJ06FAJD89fsqR3794yZMgQt97j6Oho3Qejff/995Zuu52pdjw45TxjNn9er1S/N8B9gfxUPq/7ymn3ZuGeQ4cOSY8ePaRPnz4yYcIE3X3g008/leXLl1u6H7gr0OdMlb9fcVffvn3lyy+/1P2sr9S9e3fp16+fjB9v3ZeUM2bM0B1PdunSRdasWWO4XOvWraV48eL5pi1YsMDlYczz5s2TgQMH5pvWrl07iYyMNPzMQkJCdPu0aNGiQsdHjK3UkJ6ebjivePHiPo09Dh065NU1ateuXXLDDTd4vJzT9qnTp0/L4cOHTWnLE04c55j5PbTK1zanHQMAAAAAAAAAAAAAAAAAAAAAAAAAAADBjlrt7rPyt/Mi/v/9vLvMrP9k19+aO60eh12oViPOLE6tbSpin/qm1Db9l4q1nVU4Tt2lah08apsGjmrXLieda8wSyNp5dhwD2HX8XhBVz9125MT9Q7XzuFmc+Fk5gVP3Nyc/c8mpn5kv/DneDJZndthxzBgoqj431ekqVqxoWBv75MmT0rBhQ5k7d640btzYZX5cXJwMHDhQPv30U6u7aSm7fi/gxDFhIO5Hq1BPftSoUdK1a1dp0aKF4WuqVq0qVatWla5du+abnpaWJn/88Yfs379f9u/fL/v27ZNt27bJ9u3blah7bJVAP0vB7px2/lBt/AcAAAAAAAAAAAAAAAAAAAAAAAAAAABADdRqdx+12n1n19/yU6s9MIK5VoJda4japVa7Hl/P4Zcz2s/8sQ6zqF67xs77mrecWH/dqTUI7bR/8uyKf/lS4zOYxywiao9bnHjuvJxq9fmccDzDGNftwFPhuu1vql1jnVyH3hNmXX8WL17s87XHrvcaYT9O3NdUO8fmUW2MCwAAAAAAYLXwwl8CAAAAAAAAAAAAAAAAAACc4ODBg/Laa6/pztu4caOfewMAAAB3LflEpGItkbJXe77s6vEiJ/aa3ye7euaZZ2TGjBkeLVOmTBk5cOCAlC5dOt/0kJAQGTlypNx+++0+9+vKAuKXK1q0qM/tm8Won4EuiigSuL4ZFegpWbKkT+1euHDBp+XzBOp9MbMItq+MikNa3Ucr3uObbrpJHnjgAenZs6dUr17d9PbNdunSJcvXYWUhSlX54311h5OOLSuZdT4Xsc944XKnTp2S+fPnS7du3fJNr127tjRr1kw2bNhQ4PLR0dEuxd5ERKZPn+52ITs7vm9GVDn+7cZJ+4C7nDoGNPOcajXOf+YJ5nNfQQ+p85XR8eTuwxdOnDghixYtkk6dOuWbXrlyZYmNjZXFixcX2ka3bt1098Xx44PkKYReUO14cMp5xmxWX6/sdG+A+wL5qXxe95XT7s3CM5MmTZLo6Gj57LPPXOZVr15dunfvLpMmTQpAz9Q6Z6r8/Yq7PB2njRo1StatWyd79uyxpD/z5s2TrKwsiYiIyDe9c+fO8uyzzxoup/cAsLlz57pMW7VqlaSkpOR7IENUVJTceeedsmTJEt22mzZtKpUqVXKZ7s53k4yt1HDy5EnDeZUqVZIDBw74sTe+YZ8yhxPHOXb/HtpdHAMAAAAAAAAAAAAAAAAAAAAAAAAAAADOQ6129zjpt/Oe8EcNWNV/a+60ehx2oVqNOLM4tbapiH3qm1Lb1FxOPVbdoWodPGqbBo5qx4OTzjW+UKV2nh3HAHYdvxdE1XO3HTlx/1DtPG4WJ35WTuDU/c3Jz1xy6mfmCyeMN1X7XO04ZgwUVZ+b6nQTJ06UChUq6M7r27evHD9+XO6//37ZunWr7v48YsQI+eGHH2Tnzp1Wd9UUTvpewIljwkDcj1ahnnxWVpZ07txZli1bJg0bNvRo2eLFi0u9evWkXr16+aZnZ2fL6tWr5dtvv5Vp06bJxYsXTetvoKhyP8gJnHb+UG38BwAAAAAAAAAAAAAAAAAAAAAAAAAAAEAd1Gp3D7XafWfX3/JTqz0wgrlWgl1riNqlVrsef+xvWVlZlq/DF3aqXWPnfc1bTqy/7tQahHbaP3l2hTmCecwiova4xYnnzsupVp/PCcczjHHdDjwVrtv+pto11sl16D1h1vUnb1+24tqj+r1G2I8T9zXVzrF5VBvjAgAAAAAAWC000B0AAAAAAAAAAAAAAAAAAAD+MWPGDBk6dKhujAoOAgAAIPAyU0VmvSxy7qhny22cIbJpljV9Cibnz5+XoUOH6s5r2bKl3HvvvT6vIyQkxOc2/MGonzk5OX7uiavQUP2fSVndN6P2ff1MzSosFKjPLDs729L2zaBpmqXt5+bmmtZW9erVZcqUKfLbb7/JkCFDlC/c7U9Wf47wnJ2OLX8ws1CcXcYLVxo7dqzu9L59+xa6bPfu3SUqKsrtNvXY9X2DeYJxH3DqGFC14riF4fwHX1k5rjLjb1mj/fGhhx5ya/mEhASXaYcPH5aVK1e63QcEFucZfVZdr7g3oM9O9wVUP6/7wmn3ZuG50aNHy8aNG3Xn9evXz8+9UfOcqfL3K75YsWKFdOrUSfeeXVRUlEyfPt3lwbtmSU5OlqVLl7pMr1mzptx0002Gy9199935/jsjI0OWLVvm8rpLly5JYmKiy3S9BwPn6dKli8u0ixcvyqJFiwyXycO5Sw2nT582vL9RtWpVP/fGN+xT5nDiOMfu30O7i2MAAAAAAAAAAAAAAAAAAAAAAAAAAADAeajV7h4n/XbeE2bWf7Lrb82dVo8DgeXU2qYi9qpvSm1TmEHlOnjUNoUI5xrVaufZcQxg1/F7QVQ+d9uNE/cPp+Kzggp45pI1Lly4IFu2bDE9aWlpbq2f49l8dhwz2ok/npvqZAMHDpS4uDjdeZ999pksXrxYRET2798vgwYN0n1d0aJFZerUqZbV1jabk74XcOKYUJX70YGoJ3/27Flp1qyZjB492pTPMDw8XNq0aSPjx4+X/fv3u3WfXFWq3Q9yAieePwAAAAAAAAAAAAAAAAAAAAAAAAAAAABAD7Xa3UOtdt/Z9bf81GqHv9m1hqgqtXFUZXVtQm/ZsXZNsO5rTqu/7tQahHbbP3l2BXyl+rjFaefOK6lUn4/j2XpW1GT2tR4z123/CvR1G/qCsQ69mdcfX649dr3XCPthX/Mvlca4AAAAAAAAVgsPdAcAAAAAAAAAAAAAAAAAAAAAAABQsKTjIl/1//v/V6wlUqe1SI2GItHlRYoUFUlPEjl9SGT/TyK/rxC5lBnI3jrPRx99JIcPH5ZZs1yr4c+aNUuGDBkiI0aM8Lp9oyJSSUlJMm3aNK/b9dTZs2cLnG9UjCo8PPA/UTIqEmN134oUKaI73deiNWYVFjPqh1G/zWJ1+54wKnZYunRpS9dboUIFn9vo0KGDzJ8/X8LCwgp9bWpqquzdu1f27t0r+/bty/e/58+f113mhx9+kDvvvNPnfiI42fnY8iczC0XaZbxwpSVLlsirr74qQ4cOzTf9kUcekVWrVsmUKVN0l6tZs6aMGzfOZfqgQYPkp59+cnv9dn3fkJ8vxQ+DcR9w6hhQ1QetGOH89zfOf94rUqSIXLp0yZK2IyIidKd78rfswoUL5c0335RXXnkl3/QePXrIypUr5YsvvjBcdvDgwdK2bdt80zRNkzvvvNN2x3ow4zyjz+x9mHsDzqH6ed0XTrs3C+/cc889curUKZfpd955p9SvX1+2bdtmeR9UPmeq/P2KNz799FN5+umn/7nuRUZGyoYNG+TWW2/N97r69etLZmamxMfHW/Jw2969e8vp06ddzoNff/21NG7c2OX1L774olxzzTX5pj399NNy8eJF3fYff/xx6datW7596sknn5QxY8bIzp078732+uuvlyFDhri00a9fP7ceysTYSg2apsnixYt1H+Dcs2dPWbNmTQB65R32KXM4cZxj1t8sql/bOAYAAAAAAAAAAAAAAAAAAAAAAAAAAACciVrthXPSb+c9YWb9Jzv/1txJ9TgQWE6tbSpir/qm1Db9G/UbfKNyHTxqm0IkeM81VtbO86Vunh3HAHYevxfUtqrnbrtx4v7hVHxW8CeeueRf69at070v5S8qjDed9netHceMdmP1c1OdKCIiQrZs2SJ169Z1mZeVlSVNmjRxqZM+btw4+f777+W3336TKlWq5JtXt25dycjIkNjYWFm2bJmlffeVk74XcOKYMND3qQJdTz4zM1OefPJJefLJJ0Xk72P1zjvvlMaNG0ujRo3khhtukJo1a0pkZKRH7VapUkXGjx8v48ePlwULFuh+L6oilZ+lYHdOPH8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAgBFqtReOWu2+s/Nv+Z1UkwXqs2sN0UDXxoFn7Fy7Jlj3NafVX3dqDUK77Z88u+JvTqvx6U+qj1ucdu7Uo0p9Po5n6wWyJjPXbTUE+rod7KhDn58V1x9Prz12vtdoJyEhIYHuQsCxr/mfKmNcAAAAAACA/2fvvsOkqu7H8b93WUAFBLFGRVEBjQpGKWKvNBsJiRWMGsXyidGIGo0FEw2YhFiTmEgUUtQvokZjA8FYsMTeEqNgQTGIgAhIkbY7vz/y04g7A7vT7+zr9TzvRzln5pwzM/eee+bO3vcttMKeYQIAAAAAAAAAAAAAACCv5rzz36C47rrrrnjqqadir732qld3ySWXxB//+MeYO3duVm0vW7YsbfnixYvjjDPOyKrNQsg0zrZt2xZ5JPUtXrw4bXmhE3S1b98+bfmnn35a0H4bKlPiskJ/Zq1atSpo+42xZMmSSKVS9RJZrbPOOrHOOutk3K5zleu217Fjx7jtttsyJu6eN29e3HXXXTF58uR4/vnn4/333290H5J7kYuk7ltJlpT1QjpjxoyJyy67rN6cdtJJJ2VMYnriiSfWK1u+fHn85S9/aVTfSX7f+J9111036+c2xW3AGrB8mP/IRdu2bePjjz8uSNuZ1lSZvltnctNNN8XFF18c1dXVq5WfeOKJa7z5wpAhQ+qVTZkyJaZPn96o/ikt80zhOTdQWZIwr2fLuVkiIubOnRvLli2LddZZp15dMW50Ue5zZjn/vtJYF110UVx55ZWrla1atSqOPfbYeOWVV9J+N/zjH/8Y3bp1i48++iivY/n0009j8uTJceihh65W3r1799h8883jww8/XK38iCOOWO3fqVQq7r///oztf/LJJ/HUU0/Fvvvuu1r54YcfXu/GvgMHDqz3/GXLlq2x/a8+Nh1rq+J77bXX0t48Yp999inBaLJnm8oP65zMyv3YZh8AAAAAAAAAAAAAAAAAAKh8crVnVinXzpdKkq81r6R8HJSW3KblQ25TclXuefDkNqUpzjWFzp2XS968JK4Bkrx+z6Tc5+4kqcTto1L5rCgm91xqWprierPQkrhmTKJC3je1Ev3iF7+Irl27pq276KKL4tVXX01b98knn8QJJ5wQkyZNqndcqKqqij/96U/RtWvXmDdvXt7HnC+V9LuANWF+lVM++c+tWLEiJk2aFJMmTfqirKqqKrbccsvo1KlTdOrUKTp37vzF/3fq1Gmt96477LDD4qKLLoqRI0cWZMz5Uu73Ukg68wcAAAAAAAAAAAAAAAAAANBUydWemVztuUnytfyVlJOF8ieHKIUmd01yVVL+dTkIy4d7V5CLJKxbKmnubIhS5eezP1c2x+3yUcrjdlMnD/2aNfb4kynv8+cacuxJ8rnGJFnbOqEpsK2VXlPOQQ0AAABUtuq1PwQAAAAAAAAAAAAAAAA455xzIpVK1Stff/3144orrsi63aVLl6ZtN1Pyl1LJNM7mzZuXPEnQ8uXLY9WqVfXKa2pqCppMboMNNkhbvmjRooL12RjLli2Lurq6euU1NTWx3nrrFazfQicIbKxMCUs322yzgvTXqlWrjNtGQ40cOTJtgqnFixfHD37wg9h8883jtNNOizvvvDOrxN0REa1bt85pjJDEfSvJkrJeSGfmzJkxYcKEeuUHHXRQdOjQIe1zvvvd79Yru+uuu2L+/PmN6jvJ71uSZbr5RLbatGmT9XOb4jZgDVg+zH/kopAJZ/N184UZM2bE5MmT65X37t07unTpkvY5Xbp0ie7du9crHzNmTKP6pvTMM4Xn3EBlScK8ni3nZvnc3Llz05YX40YX5T5nlvPvKw1VW1sbJ598clx55ZVp699+++34wQ9+kLZu4403LtiNacaPH1+vrKqqqt5NfDfeeOPo1avXamUvvvhizJo1a43t33vvvfXK0t1I+pvf/Ga9soceeqjBc7G1Vfl48skn05bvvPPOBTv3XQi2qfywzsms3I9t9gEAAAAAAAAAAAAAAAAAAJqySrl2vlSSfq15peTjoLTkNi0fcpuSq3LPgye3KU1xril07rxc8uYlcQ2Q9PV7OuU+dydJJW4flcpnRbG551LT0RTXm4WWxDVjUhXqvqmVpm/fvnH22WenrXvkkUfiqquuWuPzH3744bjuuuvS1n3ta1+Lm2++OecxFlql/C5gTZgf5ZpPPpNUKhUffPBBPProo/GHP/whfvSjH8WgQYOiW7du0apVq9h+++3j7LPPjjfeeCNjGz/+8Y/L/the7vdSSDrzBwAAAAAAAAAAAAAAAAAAAF8lV3tukn4tf6XkZKH8ySFKocldk1yVlH9dDsLy4d4V5CIJ65ZKmjuzVYz8fPbnyua4XT5KedxGHvrGWtPxJx/HnqSfayyUZs2a5bW9Nm3a5LW9JLKtlaemkoMaAAAAqGzVpR4AAAAAAAAAAAAAAAAAJMHzzz8f48aNS1t3yimnxE477ZRVu7W1tTF37tx65eutt16ss846WbVZCHV1dTF79uy0dZtuummRR1PfzJkz05YXMnF/prY/+uijgvXZWMX+zNZZZ52yu1nC1KlT05Z/NYl/vvTo0SOqq7O/dK9jx45x9NFH1ytfvnx5HHzwwfGb3/wmVqxYkcsQIyJio402yrkNmrak7VtJl5T1QiajR4+uV1ZVVZU2WekBBxwQW2+9dYPaWJukv2/lrra2Nm15vhNIZkp22xBNdRuwBiwf5j+yVcjv2ZnazpT4ek0ybZ8nnnhi2vIhQ4bUK1u0aFHceeedje6b0jLPFJZzA5UnKfN6tpybJSLzd8RCn89JwpxZ7r+vNMSgQYPWesOssWPHZlzXHXzwwXH++efnfVx/+9vf0n6+X73R7qGHHhpVVVX1nrs26W7s27t379hwww2/+Pemm24avXv3rve4dDcdzsTaqnw8/vjjabepqqqqOPLII0swouzYpvLHOie9cj+22QcAAAAAAAAAAAAAAAAAAGjKKuXa+VJK8rXmlZKPg9KT27R8yG1KLpKQB09u06atqc01xcidl2uu0SSuAZK8fk8nCXN3klTa9lHJfFYUk3suNR1Nbb1ZLElcMyZRoe6bWkk23HDD+NOf/lTvXHdExPz589OeP0vnggsuiNdeey1t3cCBA2Po0KE5jbPQKul3AWvC3JVrPvlspFKpmDZtWlx//fWx0047xU9/+tO0j2vdunWccsopRR5dwyXhXgqVwPwBAAAAAAAAAAAAAAAAAADAl8nVnrskX8tfSTlZKG9yiFJIctckXyXlX5eDsHy4dwXZSsq6pZLmznzLV34++3Plc9wuH6U6biMPfT7lKzdsks815qq2tjZteZs2bfLaT4cOHfLaXlI15W0tiSolBzUAAABQ+SrzDDAAAAAAAAAAAAAAAAAUwIUXXhjLli2rV96sWbO45pprsm53xowZact33nnnrNsshPfffz9teffu3Ys8kvr+/e9/py3ffffdC9ZnpuRfr7/+esH6bKxp06alLe/Ro0dB+uvSpUu95Pil9sYbb6Qt33vvvQvSX67b3CGHHJI2+dsNN9wQzz77bE5tf666ujo22WSTvLRF05W0fasSJGW9kM4DDzwQH374Yb3yk046qV5ZumTNb731Vjz++ONZ9Z3k963czZ8/P235+uuvn9d+tt9++5ye3xS3AWvA8mH+I1uF2l+32GKLtAndV65cGdOnT290e/fee2/axPHHH3982nnhuOOOq1c2fvz4WLp0aaP7pvTMM4Xj3EDlScq8ni3nZomIaN68edryurq6gvablDmznH9faYh0N7hNZ+jQofHBBx+krRsxYkTe58OFCxfGww8/XK/8gAMOWO2GGUcccUS9xzTkNb311lv1bhBTXV0dAwYM+OLfhx9+eL217/Lly+O+++5ba/tfZm1VHj777LOM38OHDh1a5NHkxjaVH9Y5mZX7sc0+AAAAAAAAAAAAAAAAAABAU1VJ186XSpKvNa+kfByUltym5UNuU3KRhDx4cpvSlOaaYuTOyzVvXhLXAElev6eThLk7SSpt+6hkPiuKyT2XmpamtN4sliSuGZOqUPdNrRQ333xzbLbZZmnrTj311Jg5c2aD2lmxYkUcd9xxad/riIhrr702unTpkvU4C62SfhewJsxdueaTz1UqlYqf/OQnccMNN6St79evX5FH1HBJuZdC0pk/AAAAAAAAAAAAAAAAAAAA+DK52nOX5Gv5KyknC+VNDlEKSe6a5Kuk/OtyEJYP964gW0lZt1TS3FlIuebnsz9XNsft8lHK43ZTJw99/uV67EnyucZczZ8/P235+uuvn9d+tt9++7y2l1RNeVtLuiTnoAYAAAAqX/2/4AEAAAAAAAAAAAAAAADSmjFjRlx77bVp6/r06ROHHHJIVu3+85//TFtebkmgXnnllbTle+yxR3EHksa//vWvtOWFStC1/fbbx4YbblivfPny5fHOO+8UpM9sfDXh/OcK9Zntt99+BWk3F48++mja8kGDBkWzZs3y3l+6ZKKNse+++6YtHzduXE7tfln37t1j3XXXzVt7NE1J27cqQVLWC+nU1dXF2LFj65Vvt912qx2rW7VqFd/+9rfrPe4Pf/hD1n0n+X0rd5kSUm6zzTZ57SfX9UVT3AasAcuH+Y9sFWp/7d27d9ryd955J+rq6hrd3qpVq+JPf/pTvfItt9wyDjzwwNXKdt9999huu+3qPXbMmDGN7pfyYJ4pHOcGKk9S5vVsOTdLRMTGG2+ctnzx4sUF7Tcpc2Y5/76STwsWLIghQ4aknYOaN28e48aNi9atW+e1z/Hjx9cra9GiRfTv3/+L/+/Tp89q9R988EG89tprDWo/3Q16Dz/88C/+/5vf/Ga9+kmTJsWiRYsa1P7nrK3KR7rvOBERXbt2zfq34FKwTeWHdU5m5X5ssw8AAAAAAAAAAAAAAAAAANCUVcq186WS9GvNKyUfB6Ult2n5kNuUXCQhD57cpjSluaYYufNyzZuXxDVA0tfvX5WEuTtJKm37qGQ+K4rJPZealqa03iyWJK4Zk6pQ902tBEOHDo2BAwemrfvTn/4Ud955Z6Pae/311+OCCy5IW7feeuvFbbfdFjU1NY0eZ7FUyu8C1oTFU4p88vkwfPjwWLVqVb3ynj17lmA0DZOUeykknfkDAAAAAAAAAAAAAAAAAACAr5KrPTdJv5a/UnKyUN7kEKWQ5K5JvkrKvy4HYflw7wqylZR1SyXNncWQbX4++3Nlc9wuH6U8bjd18tAXTrbHnqSfa8zF/Pnz05Zvs802ee3HfPxfTXlbqxRJzEENAAAAVL7qUg8AAAAAAAAAAAAAAAAAkmTkyJExZ86ctHVXXXVVVsmgnnvuubTl+++/f6PbKqRnn302bXk5JMafPHly2vLDDjusIAm60iVqj4h4/PHHo7a2Nu/9ZeuJJ55IWz5gwICC9PflZPblYvLkyZFKpeqVb7HFFjFo0KC89tW7d+/YZZddcmrja1/7WtryN954I6d2v+yrSVAhG0nbtypBUtYLmfzhD39Iu82cdNJJX/z/kUceGa1atVqtfuXKlfHHP/4x636T/r6Vs08++SRt+W677Za3PmpqaqJv3745tdEUtwFrwPJi/iMbBx54YLRo0SLv7Wb6/v7kk09m3WamZOMnnnjiav8eMmRIvce89dZb8fTTT2fddykV4lxD0phnCse5gcqTpHk9G87N0rFjx4zb+MyZMwvad1LmzHL+fSXfpkyZEr/4xS/S1m233XZxww035LW/e+65J1asWFGv/PO5Yv/994/WrVuvVnfvvfc2uP2//e1v9cr69+8fNTU10apVqzj44IPr1d9xxx0Nbv9z1lbl469//WssXLgwbd1VV10VNTU1RR5RdmxT+WGdk1m5H9vsAwAAAAAAAAAAAAAAAAAANGWVcu18qST9WvNKycfRWPLD5ZfcpuVFblOylZQ8eHKbNm1Naa4pRu68XCVxDZD09ftXJWXu/qpyndMqbfuoZD4risk9l5qWprTeLJYkrhmTrBD3TU26Ll26xLXXXpu27t13340zzzwzq3avv/76eOihh9LWde/ePa644oqs2i2GSvldwJqwuIqdTz4f5s2bF6+88kq98jZt2uTtu3S+t7Wk3Euhocr1uGP+AAAAAAAAAAAAAAAAAAAA4Kvkas9N0q/lr5ScLI1VrrkhKlVSc4iSDJWWu6apqpT863IQlhf3riAbSVq3VMrcWQzZ5uezP1c2x+3yUqrjdlMnD33hZHvsSfq5xlx88sknact32223vPVRU1MTffv2zVt7DVGu5yGb8rZWKYqRgxoAAACgsapLPQAAAAAAAAAAAAAAAABIkkWLFsVll12Wtm6HHXaIM844o9FtTpo0KW35EUccERtvvHGj2yuUiRMnpi3/+te/HgcddFCRR7O6xx9/PJYsWVKvvEOHDvGd73wnr301b948zjrrrLR1jUkGXwyZEhftsMMOaZPN52LbbbfNe5v58PHHH8fDDz+ctu6yyy7La/KfK664Iuc2Nthgg7Tly5Yty7ntiIjq6uoYOnRoXtqiaUvavlUJkrJeyOT9999Pu80cddRRsd5660VE/STNEf89ts6dOzfrfpP+vpWzf//732nLN9tss+jUqVNe+vj2t7+d8+fUFLcBa8DyYv4jGxtvvHEcc8wxeW1zo402iuOOOy5tXabv+w3x9ttvx2OPPVavfNCgQV/cQK1Zs2Zx1FFH1XvMmDFjsu63WNKda4j4bzLZps48UzjODVSeJM3r2XBulm9961tpy1euXBlvvfVWQftOypxZzr+vFMKll14azz//fNq6448/PgYPHpy3vhYuXJj2O9ehhx4aNTU1aW88lO5mvZk8/fTTMW/evNXK1l9//dh7772jX79+0bJly9XqVqxYkdV8ZG1VPj777LO4/vrr09btsMMOcfnllxd5RNmxTeWHdU5m5X5ssw8AAAAAAAAAAAAAAAAAANCUVcq186WS9GvNKyUfRybywxWH3KblRW5TspWUPHhymzZtTWmuKUbuvFwlcQ2Q9PX7V5X73J20Oa3Sto9K5rOimNxzqWlpSuvNYknimjHJCnHf1CSrqamJ22677YtzYl9WW1sbgwcPjsWLF2fd/gknnBAff/xx2rof/ehHsd9++2XddiFVyu8C1oTFV8h88ptttlnWz12TDz/8MG15u3btGtVOsb7fJuVeCl/l+39m5g8AAAAAAAAAAAAAAAAAAIBkkKs9N0m/lr9ScrJkkrTcEJWq3HOIkmxJzV3D6iol/7ochOXFvSvIRpLWLZUyd35VOeXnsz9XNsft8lKq43ZTJw/9/xTi+JPNsSfp5xpz8e9//ztt+WabbRadOnXKSx/f/va3C3YMT9p5yKa8rZVCOa1xAQAAAAop9zuGAwAAAAAAAAAAAAAAQBMzevTojAl4fvrTnzY6mci7774b//znP+uVt2jRIu9Jdtu2bZt1cpVZs2bFU089lbbuxz/+cS7DqufUU0+NXXbZpcGPX7FiRdx+++1p6y6++OJo3rx5voYWp556amy++eb1ypcvXx533HFH3vrJh9mzZ8fTTz+dtu6iiy7Ka19XXHFFVFVV5bXNfPn1r3+dtnynnXaKESNG5KWPU089NS8JDBctWpS2PF/JuI499tjYbrvt8tIWJGnfqgRJWS+syejRo+uVtW7dOr797W/HNttsE/vuu2+DntMYlfC+latp06bVu7HN59IlpG2smpqa+MlPfpJzO01xG7AGLD/mP7Jx3nnnRbNmzfLW3rBhw2KdddapV75kyZKMyf0b6g9/+EO9svXWWy+OPPLIiIjo06dPbLLJJqvV19XVxZ///Oec+i2G+fPnpy3feuutizyS8mOeKRznBipTkub1xnJutmlr3bp1nHvuuWnrnnnmmbzdlDCTpMyZ5fz7SiHU1tbGscceG4sXL05b/7vf/S623XbbvPU3fvz4emVt27aN/fbbr96NfRctWpT25mGZ1NXVxYMPPliv/PDDD49vfvOb9coffvjhWLhwYYPb/5y1VXm5+uqrM36OF154Ydqby5Ub21R+WOdkVu7HNvsAAAAAAAAAAAAAAAAAAABNXSVcO18qlXCteSXk48hEfrjikNu0/MhtSraSkgdPbtOmqynNNcXInZerJK4BKmH9/lXlPHcnbU6rxO2jUvmsKDb3XGo6irXeLPVas5iSuGZMunzfNzXJfvazn0X37t0z1j3zzDM5tT979uw4+eST09ZVV1fHLbfcUrbvdyX8LmBNWHyFyCe/5ZZbxu9+97t4//33Y+DAgfkY5mpatGiRtvyzzz5rVDvF+n6blHspfJXv/5mZPwAAAAAAAAAAAAAAAAAAAJJDrvbsVcK1/JWQkyWTpOWGqGTlnEOUZEtq7hrqq4T863IQlh/3riAbSVq3VMLc+blyzM9nf65sjtvlpxTHbeShL+TxJ5tjTyWca8zWtGnTYt68eWnrTjzxxJzbr6mpiZ/85Cc5t5NJ0s5DNuVtrZjKcY0LAAAAUEjVpR4AAAAAAAAAAAAAAAAAJE1dXV2cd955aevat28fl112WaPbTJeoMOK/yWU6d+7c6PYyueaaa2Lq1Klx1llnRXV14y8v+v3vf5+2/KCDDoqzzz471+FFRESPHj3id7/7Xbzyyitx3333Ra9evRr0vF/96leRSqXqlXft2jWuvfbavIxt1113jV/96ldp6/785z/HnDlz8tJPPv32t79NW37AAQfEueeem5c++vfvH8cdd1xe2iqE+++/P1577bW0dcOGDYtTTjklp/b79OmTt23s448/Tlu+xx575Nz2FltsEddcc03O7cDnkrRvVYqkrBcyueeee9IeK0866aQ44YQT6iWCff/992Py5Mk595v0962cZUoUPHTo0GjXrl1ObV900UWxww475NTG55riNmANWF7Mf2Sja9euMWrUqLy0td9++8WPfvSjtHV/+ctfMt5EqKHuuuuu+OSTT+qVf56geMiQIfXqJk2aFB9++GFO/RbDzJkz05Z37tw5Nt100yKPpvyYZwrDuYHKlKR5PRvOzTZN1dXV8Yc//CG22GKLtPW33XZbwceQpDmznH9fKYR33nknzjzzzLR1bdq0iXHjxkVNTU1e+rrnnnti5cqV9covvfTSejeeeOihh9I+dk3+9re/1SsbOHBgHHbYYfXKc7mRg7VV+ViwYEFccMEFaeuqqqri1ltvjWOOOabIo2o821R+WOdkVu7HNvsAAAAAAAAAAAAAAAAAAABNWaVcO18qSb/WvFLycaQjP1zxyG1aXuQ2JVtJyYMnt2nT1lTmmqTkzkviGiDp6/evKue5O4lzWqVtH5XMZ0UxuedS01KM9Wap15rFlsQ1Y5IV4r6pSbTffvvF+eefn7bumWeeiSuuuCIv/dx7770xevTotHVbbrllxrpSq5TfBawJiy9f+eS33HLLuOGGG+Kdd96J008/PVq0aBHXX399tG/fPq/j7dSpU72ypUuXlu3326ScD/oq3//TM38AAAAAAAAAAAAAAAAAAAAki1ztuUn6tfyVkpMlnSTmhqhU5ZxDlGRLau4a6quU/OtyEJYX964gG0lat1TC3Fnu+fnsz5XNcbu8lOq43dQ11Tz0xTj+ZHvsSfq5xlw8/fTTacuHDh0a7dq1y6ntiy66KHbYYYec2liTJJ6HbMrbWqGV+xoXAAAAoGBSDRQRQgiRNrp165YaMmRIasiQIanBgwen9thjj1RVVVXJxyWEEEIIIYQQQgghhBBCCCGEEEIIIYQQQghRyVFVVZXq2bNnavDgwV/8LWe3bt1KPq6mGv6mVojyiunTp6e9Puaoo47Ke1+TJ09O29eKFStSnTt3blRb6623XmrOnDlp23vuuedSrVq1ynm8p5xyymrtvvLKK6k99tijUW00a9YsNW3atIyv+5BDDslpjJtttlnaz3Dy5MmpTTbZZK3PHzduXMZrpM4555ycxta5c+fUe++9l7btzz77LLXttts2us108r2dNm/ePPX++++n7WvlypWpww8/PKf2d9xxx9Qnn3yS8X3/XK9evfL+2hoT++233xrHd/HFF6eqq6sb3e4xxxyTWrZs2Vpff0Pfg1GjRqV97qRJk3J6/eutt17qH//4x1rHuO++++a8DadS+d2OJ0yYkLaPvn375q2PYcOGpe1j1KhRJXk/ivG+fh5jx45N29d3v/vdBj0/KftWIaOYn1dS1gtril/+8pf1xl5XV5eaPXt2vfJLLrmkyb1vxdyect3/IyI1ZMiQjGMeO3Zs1mMbOHBgqra2NmPbqVQqtWjRoorcBvIVSV0DZlLo96sY/Zr/yuNzz8fcV4xt78uGDh2aUx9f//rXU7NmzUrb9sqVK1Pbb799Xl7LddddV6/9urq61M4775xavHhxvbojjzyyJO95NvHBBx+kff9++tOfFm2bKMTrysf+kJR5JmmfU6nPDZTTexFRGecFviwp83o2kbRzs1+N4cOHp21/+PDhJXtPGxrF/F3k89hoo41S99xzT8bPfPbs2Y06DmSytueVes5szPnUcv99JZfPYU1x++23Z2z35z//ed62yQcffHCtn1cqlUoNGTKk0W23bt06tXz58rW2vXLlytQGG2yQ03aXlLVVJqVqp1DxyCOPrPEzv+aaa1LrrLNOQfo+4IADUvPmzUvbb5cuXSpum4oozfGsoZG0dU4m+X5fyv3YlrR9QAiRfVRVVaV69erl72mFEI2KXJR67EKI8g3XlQghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIUP+RqL6/wN7VClGeU8tr5iPxcP/95FPuan6Rda/7VqIR8HJmimPnhir3tlVPOxKTmNi32Z1bMPuU2Lf1nEFFe++naXvuXJSEPntymhd8mCtGX/KYNj1LmzmtM3rykrgGStn5viHKdu5OYr7lSto98v78R5be2Sdpn9eVIam7bJG5v+RpzUu+5lK/XX8zPrNRR6PVmU7xnR1LXjIWIpN43NZsYNGhQ2v5nzZpV8L7btWuXcR26aNGivJxT/3Ksu+66qalTp2bc9sp1HqyU3wWStibMpJCfdSH6zDWf/P3335/2uX//+99T6667bl5ed69evdL2MXXq1KzaK8b32yTdS6EU70++t+kkzR/5es0NiUpZ1wshhFhzyNUuhMgmclHqsQshyjdcVyKEEEIIIYQQQgghhBBCCCGEEEIIIYQQQghR/JCrvbzC39QKUZ4hV3v2kaRr+dNFpeRkSRfy3RYvGqIcc4gW8zPLd5/FGPuECRPS9tG3b9+89TFs2LC0fYwaNWqtz01S7ppifF5J394qIf96UnMQFuPzLVW/7l3RuPe/EJ9zua1Z1rTtfVk5rlvSRdLnznLPz5fk/TmVym2fTmou8caE43bjohj9luK4ne/XV8zPJ1/H2KTmoc8lCn38yTU3bNLONWbS2HaGDBmSsa2xY8dm/ZoHDhyYqq2tzdh2KvXf/N25fu5y1CZnW2tI5DLHlvsaVwghhBBCCCHkahdCZBMNUR0AAAAAAAAAAAAAAABAVoYNGxZ1dXX1yps3bx6/+tWvGtXW0qVL47LLLktb17Nnz5gyZUpssskmWY0zIuKss86KG2+8cbWyXXbZJZ566qno169fg9upra2Nc889N21d8+bN4957742zzz47qzHusMMOMWXKlOjYsWO9us022yzmzp271jbOPvvsWLhwYdq6q6++On7/+99HixYtGj22Pn36xHPPPRdbb7112vqf/vSn8e677za63WJYuXJlDBs2LG1dTU1N3HPPPXH++edn1fZBBx0UTzzxRGywwQZflM2cOTOrtgrt8ccfj9///vcZ63/2s5/Fq6++GoccckhUV6/90rvddtstJk2aFP/v//2/aNmy5Rfls2bNisWLF2c9zoceeihteZ8+feLkk0/Oqs3NN988nnzyyejdu/cXZS+99FJWbcFXJWXfqhRJWS+syR/+8Id6ZVVVVfXGXVtbG2PGjMlLn5XwvpWrcePGxYcffpi27sQTT4yRI0c2us2hQ4fGnXfeudqcMW3atKzHGNE0twFrwPJj/qOhvjqvjh49Oq6++upo1qxZo9s69NBD45lnnonNNtssbf1vfvObmDp1albj/KrRo0fXK6uqqorbbrstWrVqtVr5/Pnz429/+1te+i2Gxx57LG35hRdeGPvuu29xB1NmzDOF4dxAZUvKvJ4N52abhk6dOsXw4cPj7bffjoEDB2Z83IUXXhhLliwp+HiSNGeW++8rhXLqqafGjBkz0tb96Ec/ioMOOigv/YwfP36tj6mtrY0HH3yw0W0vXrw445rwy/7+97/H/PnzG93+56ytys/RRx+dcfuNiPjhD38YU6dOjRNOOCGaN2+ec3/NmzePww47LJ566ql45JFHon379jm1Z5vKH+uc9Mr92GYfAAAAAAAAAAAAAAAAAACA4l87H5H/6+dLJenXmldCPo5M5IcrDrlNy4/cpjRGEvObym3adDWVuaYYufPykTcvqWuApK/f0ynXuTuJc1olbh+VymdFMbnnUtNRyPVmuaw1iy2pa8aky+d9U5PmxhtvjC233DJt3Q9+8IO8H8c/++yzOO6442LlypVp63/zm9/ENttsk9c+86FSfhewJiyNXPPJX3rppZFKpeqVH3jggfH3v/89OnTokNP42rVrFzfffHPaugkTJmTVZjG+3ybpXgpf5fv//5g/AAAAAAAAAAAAAAAAAAAAkk2u9uwl/Vr+SsnJkk4Sc0NUsnLNIUpyJTl3DfVVQv51OQjLj3tX0FBJvG9FRPLnznLPz2d/rmyO2+WnFMdtmmYe+kIef/KRGzbp5xqzNW7cuHprss+deOKJMXLkyEa3OXTo0LjzzjtX23anTZuW9RjXJInnIZvqtlZo5b7GBQAAACiYVANFhBBCpI1u3bqlhgwZkhoyZEhq8ODBqT322CNVVVVV8nEJIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCVHJUVVWlevbsmRo8ePAXf8vZrVu3ko+rqYa/qRWivGL69Olpr4856qijCtLfTTfdlPGanAMOOKDR7T322GMZ25szZ07q//7v/1I1NTUNbq9r166pCRMmZGzz2WefTVVXVzd6nGPHjl3j9UgvvPBCqm/fvg1qq3Xr1qlLLrkktWTJkrRt1dXVpQ466KAGj+2YY45Z49jee++91JAhQxr0Pu60006pu+++e43tPfHEE6lmzZpltf2kU6h947777lvj63jppZdS/fr1a1BbO+ywQ+rPf/5zqq6ubrU2Pvvss9SJJ56Ytv1evXoV7LU1NJo3b5565pln1vg+pFKp1CeffJK69dZbU5dccklq6NChqe985zupE044IXXBBRekfve732WcZ1KpVOqII45IzZ07N+v3oGXLlhmfX1tbm7r00ksbPAe0aNEiddZZZ9Vrb/78+alDDz00bR/77rtvzttwKpXf7TjTHNbQOaYhMWzYsLR9jBo1qiTvRzHe188j03z+3e9+t6L2rUJGMT+vzyMp64Vsxv+5++67r0m+b5kUYjvKx/4fEanzzjtvjZ/lAw88kOrcufNa29ltt93Svp/PPfdc6he/+EW98kWLFlXkNpDvSNoaMJNCv0/F6tf8V/rPPV9zXyG3veHDh6feeuuteuVTp05Nfec732nQeceuXbum7r333ozvbSqVSk2fPj3Vpk2bvL6ef/zjH2vs83O/+c1vSvJ+Zxt77bVXxteyYsWK1M9//vPU1ltvXbBtIpUq//2h3OeZfEehP6dSnxsop/ciojLOC7z44ov1ypIwr2cTSTo3+9UYPnx42j6GDx9e8vd1bZHpnMo111yTGjRoUFbx+XmbM888M/WTn/wkNX78+NSbb765xs/jc+PGjWv0a8hkbc8r9ZzZ2POpEeX9+0q2n8PaYu+9907V1tambfvDDz9MbbTRRjn30a5du9SKFSvW+N5OmTIl6/b/7//+b41tp1Kp1Pe+97287NNJWFtl0tjXmq92Chldu3ZNffzxx2v9/D/66KPUb3/721Tfvn1Tbdu2bVDbzZs3T+20006pwYMHp8aNG5dauHDhWvtJpVKpLl26VNw2FVH83/kbG0la52RSqPemnI9tSdoHhBDZR1VVVapXr17+nlYI0ajIRanHLoQo33BdiRBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIUTxQ6728gp/UytE+UYhr52PKN7186W45idJ15p/NSopH8dXo5j54Yq97ZVbzsSI5OU2LfZnVuw+5TYt/WdQjvtpOknNbyq3aeG2iVSq/I9dSZhrcoli5M7LZ968JK4BkrR+zyQJOUyTmq+5EraPfLynX41yXNsk6bP6ciQ1t20St7d8jjmJ91zK5+sv1mdWLpHP9aZ7dvw3krhmzHck/b6pjYlBgwal7XfWrFkF7fe73/1uxtd8xx13FLTvCy+8MGPf//jHP/J2Pj9fUUm/CyRpTZhJIT/rQvWZaz753/72txnHtmjRotSll16aVU76fv36paZNm5ax7b322iur11uM77dJvJdCMd+fQmzTSZk/8vma1xaVtq4XQgiRPuRqF0JkE7ko9diFEOUbrisRQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEKH7I1V5e4W9qhSjfkKs9+0jKtfzpopJysnw15LstXmRS7jlEi/mZ5bvPYow9Uy65vn375q2PYcOGpe1j1KhRa31uknLXFOPzSvr2FlE5+deTloOwWJ9vqfp174qGv/+F+JzLbc2S6bUn9b4VEcmfO5OQny+J+3Mqlds+ndRc4tmE43Z59Vuq43a+Xl8xP598HmOTmIc+1yjE8Sefx54knWvMJJu2zjvvvDWO84EHHkh17tx5re3stttuaY+1zz33XOoXv/hFvfJFixblvE3JUZusbW1tkescm4Q1rhBCCCGEEKLphlztQohsoiGq/v+TNWtVVVXVkIcBTVC3bt2iW7duERGRSqXi3XffjWeeeSYaOL0AAAAAAAAAAAAAkIWqqqro0aNHdOnS5Yu/937ttdfitddeK/HImiZ/UwvlZfr06dGxY8d65UcffXSMHz8+7/1tttlm8fbbb0erVq3q1b366qux6667Nmo+2GSTTeL555+PrbbaKuNjZs+eHRMmTIiHH344Pvjgg5gzZ04sXbo0WrRoEW3atImtttoqunXrFoccckj07t07YzuzZs2K3r17x4wZMxo8vs+1bNkyHnnkkdhzzz3X+Li5c+fGpEmT4uWXX445c+bEvHnzIiKibdu2sc0220SvXr2ib9++se6662ZsY+TIkXHxxRc3anw/+9nP1vqchQsXxkMPPRTPPfdcfPTRRzFv3rxo1apVbLrpptG5c+cYMGBAbL/99mts4913341evXp98boaK922Uahrudq2bRsvvPBCdOrUaY2P++ijj2LChAnx2muvxezZs2P+/PnRsmXLaN++fey8885xwAEHxK677pr2uaeddlq8+eab8fjjj9er23333eO5557Ly2vJRbt27WLy5MnRo0ePvLf9s5/9LC699NKYO3dubLTRRvXqG/oe/PCHP4xrrrkmY/2HH34Yf/nLX2LKlCkxderUWLBgQSxbtizatm0bm2yySXTq1Cn69esXhx56aHzta19b7bmpVCq++c1vxkcffRTPPvtsvbb322+/mDJlSgNe7f/aSyef2/GECROif//+9cr79esXkyZNyksfw4YNi6uuuqpe+a9+9as4//zzG9xOvt6PYryvnxs7dmyceOKJ9cpPOOGE+POf/9zgdpKwbxVKMT+vzyVlvZDJcccdF7feeusaH3PEEUfEfffdl7c+I5LxviVx/2/WrFk89thjsffee2d8TF1dXTzzzDPx0EMPxYwZM2Lu3LlRVVUV7du3j65du0afPn1il112qfe85cuXR48ePWLw4MFx4YUXrla3ePHiaNOmTYPHGZGMbSDfkrYGLMWcWsx+zX/pJXHuy5d0r/2CCy6IKVOmxOOPPx4tWrSoV//xxx/HxIkT48UXX4yPPvoo5s+fH23atPniu2z//v3X+l32s88+iz322CNeffXVvL2WiIiTTjopxowZs9bHde/ePV566aW89l1oTzzxxBqPdRERM2fOjBkzZsSiRYuirq6uXv3s2bPTbn9fltT9odznmXwrxudUynMDjXkdzgusLtP7scsuu8Rzzz0XLVu2rFdXzvN6tpJybvarhg8fHj/96U/rlV922WVx+eWX56WPQsn0u0gpTJw4MQYOHBgrVqxo1PNymU+SdD41orx/XynkvL6mueGBBx6Iww47LOc+Mh0zPnfeeeelne8bokOHDmtcf6xatSo23XTT+OSTT7Jq/8uSsLZK4rnwXOy4447x8MMP15sjMkmlUvH+++/HM888E0uWLIlly5ZFs2bNonXr1tGmTZto06ZNbL755tGpU6eoqalp1FgmT54cgwYNisWLFzf4OUnYpiKK/zt/NpKyzin2vlXOx7aI5OwDQPaqqqqiZ8+e0blzZ39PCzRYLn/jXW7fWYDy4boSAAAAAAAAAAAAgOKTq728+JtaKG/ZXjv//vvvx6xZs8ri+vlS5SlIyrXm6VRKPo50ipUfLiK5OeLyJWm5TSNKM1/IbVr6/A3F+gzKcT+tpPymcps27WNXEuaaXBU6d17v3r3zljcviWuAiOSs35OewzSp+ZqTvn2U+zyeT0n5rL4sqbltk7i95XvMSbvnUhI/s3LRmPXm2LFj3bOjAZK6ZsynpN83tTEGDRoUd911V73yjz76qMG/PTTWtttuG6+88krae1TNnDkzunbtGvPnzy9I3xH/3Qcfe+yx2HfffdPW//SnP42f/OQnBes/G5X0u0BS1oSVdj46l3zyLVq0iKeeemqN66qVK1fG008/HY899li88cYb8d5778WiRYti6dKlUVVVFa1atYp27drFdtttF7vuumsccsgh0blz54zt3XfffXHEEUc0/AV+RTG+3ybtXgpflo/3Z8CAAWvtpyl+/0/q+g+A8iVXO5ANudqBQnBdCQAAAAAAAAAAAEDxydVeXvxNLZQ3udqzl4Rr+TOppJwsXyXfbXEkNYdoknPjFGPsmeaGfv36xaRJk/LSx7Bhw9LOL7/61a/i/PPPX+vzk5K7plTHpiRtbxGVk389aTkIk759ro17V6SX7v1vCmuWiMq6b0VE8ufOJOTnS+L+HJHbPp3UXOLZcNwur35LddxO2ro5Iv/H2KTloc9VPo8/3/nOdwqSGzYp5xrzud03a9YsHnvssTWey6urq4tnnnkmHnrooZgxY0bMnTs3qqqqon379tG1a9fo06dP7LLLLvWet3z58ujRo0cMHjw4LrzwwtXqFi9enDa/d2O5R01ytrW1yXWOTcIaFwAAaLrkagey0aC/8U41UEQIIUTa6NatW2rIkCGpIUOGpAYPHpzaY489UlVVVSUflxBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIUQlR1VVVapnz56pwYMHf/G3nN26dSv5uJpq+JtaIcorpk+fnvb6mKOOOqpgfV5yySUZr8s5+eSTG91e586dUx988EFDL/3JykcffZTq2rVrTq+7bdu2qSeffLKg4/zDH/6Q9Zw6YsSIgo7t9ddfT3Xo0CGn9zCdQu4f2223Xeq9994ryPtx3XXXpSIite+++6at79WrV1HngjXF+uuvn7rnnnvy+vpHjRr1Rftz587N6T1o0aJF6qWXXsrr+D53/vnnpyIi1atXr7T1++67b87bcCqV3+14woQJafvo27dv3voYNmxY2j6+/LkW8/0oxvv6eYwdOzZtX9/97ncrbt8qVGRS6H6Tsl5IFy1btkzNmzcvY78zZ85MVVdXN8n3LZNCvBf53P8333zz1Jw5c/L6PtbV1aVOPPHEVESkrrzyynr1ixYtqshtoBCRpDVgJoV+j4rVr/mv9J97Pue+Qm17P/rRj1IRkTrppJNSdXV1+fhoVrN06dJU//79C/J61ltvvdTChQvX2P9rr71Wkvc619hmm21Sn376aU7v/fTp0yt6fyjneSbfkUk++yjluYFyey8q5bzAkUcembh5PZdIwrnZr8bw4cPT9jV8+PCSv59ri0y/ixTbr3/961RNTU1WryGThjw3SedTP49y/X0lk3xsp82aNUs988wzGfv4wQ9+kHMfJ5100hrfky5duuTU/iuvvJKx7UmTJuV1vy73tVUmpWqnGPG1r30t9dhjjxXio2iQefPmpU4//fSK3aYiSvM7fzaRhHVOJoV8X8r12JakfUAIkX1UVVWlevXq5e9phRCNilyUeuxCiPIN15UIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCFD/kai+v8De1QpR/lPra+VQqt+vnMynGe5eEa83TRSXl4/hqFCs/XLG3vXLLmfh5JCm3abE/s2L3Kbdp6T+DctxP00lqflO5TdesKRy7yn2uyTUKnTsv33nzkrYG+DySsH7PJCIZOUyTnK856dtHvqMc1zZJ+qy+HEnNbZtJOW9vhRhzku65VIjXX+jPrJyi0OvNpnjPjqSuGfMVlXDf1IbGoEGD0vY5a9asgvTXrFmz1D/+8Y+0fdbV1aUOPPDAonzGHTp0SC1YsCDtOFatWpXac889S74dfjkq7XeBJKwJMynk51zIPnPNJ7/RRhulXnzxxZw+l4aaO3duaosttsjp9Rbj+20S76WQz/enVNt0uc8fhXjNmaIS1/VCCCHqh1ztQohsIhelHrsQonzDdSVCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQxQ+52ssr/E2tEOUfcrVnH+V+LX+mqLScLF8O+W6LE2t67eWcQ3RN4y7Fe1VuY58wYULaPvr27Zu3PoYNG5a2jy/nKlxTJCV3TSaF3NaStr1FVFb+9STlIMwkKdvn2sK9Kxr+/hfiPSi3NUum157U+1ZEVMbcmYT8fEnbn1Op3PbppOYSzzYct8un31Idt/P1+or5+RTiGJukPPT5iGIdf3LJDZuEc42ZZNve5ptvnpozZ05eX2ddXV3qxBNPTEVE6sorr6xXv2jRorxsU+5Rk1k5bmtrinzMsUlY4wohhBBCCCGaZsjVLoTIJhqiOgAAAAAAAAAAAAAAAICcXHXVVTFz5sy0dSNGjIjWrVs3qr233nor9thjj3juuefyMbx6XnrppejRo0f885//zKmdhQsXxsEHHxxjxozJ08j+p66uLkaOHBlDhw6NVCqVVRsXX3xxnHLKKbFkyZI8jy7igQceiL322is++OCDvLddSO+8807stdde8dJLL+W13Z///Odx9tln57XNQvr000/jm9/8Zpx22mkxb968nNqaN29eDB48OM4///w8jS5ixYoVMWDAgJg+fXre2ly5cmWcdtppMWrUqLy1CV9V7vtWpUnKeiGd5cuXxy233JKxfuzYsVFXV5f3fiOS/b6Vsw8//DD22WefeOedd/LSXl1dXZx55pnxxz/+MS/tfVlT3AasAcuH+Y/GGDt2bJx44omxcuXKvLU5e/bs6Nu3b0ycODFvbX7Z0qVL4//9v/+3xscU4hxCMUyfPj0GDRoUCxcuLPVQypZ5Jr+cG6g8d9xxRxxzzDGxbNmyvLVZ6Hk9F87NNi2vvfZaHHTQQfGDH/wgVq1aVfT+kzhnlvvvK4VQW1sbxx13XCxatCht/ahRo6Jbt2459XHPPfdkXD9PmzYtpk2bllP79957b8a6O+64I6e2v8raqvzMmjUrDjzwwBg2bFhRvxcsXrw4rrrqqthuu+3i97//fdbt2KbyxzonvXI/ttkHAAAAAAAAAAAAAAAAAACgdNfOR+Tv+vlSSeq15pWUj+Or5IcrLrlNy4fcpjRW0vKbym1Kpc81Scudl9Q1QFLX759LQg7TJM9pSd8+mhKfFcXknktNRyHXm6Vea5ZKUteMSZbv+6aWq+HDh0fv3r3T1l199dXxyCOPFGUcH3zwQZx++ulp65o1axa33HJLtGnTpihjaYhK+13AmrD4cs0n//HHH8f+++8f99xzT4FG+F//+c9/Yu+99844HzZUMb7fJu180Jf5/p+e+QMAAAAAAAAAAAAAAAAAACC55GrPXlKv5a+0nCxfluTcEJUiCTlESa4k566hvkrKvy4HYflw7woaI2n3rYiojLkzCfn57M+VzXG7fJTyuE3Ty0NfjONPrrlhk3quMRcffvhh7LPPPvHOO+/kpb26uro488wz449//GNe2luTJJ+HbIrbWqElYY0LAAAAkE/VpR4AAAAAAAAAAAAAAAAAJN1nn30WF110Udq6TTfdNGPdmnyeoOTiiy+OpUuX5jrEiPhvEsQLLrggevXqFf/5z3/y0uayZcvi5JNPjiOOOCLefffdvLT5zjvvRJ8+feLiiy/Oua2bb745unbtmrfEkrNmzYrjjz8+DjvssFiwYEFe2iy2mTNnxu677x6XX355LF++PKe2Pv744xg4cGD8+Mc/ztPoimv06NHRsWPHuPjiixudQGvOnDlx+eWXx/bbbx+33XZb3sc2e/bs2H333eOBBx7Iua3XXnstevXqFaNHj87DyGDtynnfqjRJWS+kk2lOSqVScdNNNxWs34hkv2/lbOrUqdGrV6+YMGFCTu3MnTs3+vfvHzfccEOeRlZfU9wGrAHLh/mPxvjzn/8ce+65Z7z11ls5t3XHHXfETjvtFE8++WQeRpbZmr53rFy5co2JzMvdww8/HL169Yonnnii1EMpW+aZ/HJuoPKMHz8+evfuHa+88krObRVrXs+Fc7OV7bPPPou77747+vfvH7vssks88sgjJR1PEufMcv99pRDefffdOPPMM9PWtWzZMm6//fZYd911s25//vz5GbfFNd2Ut6H+9re/pS2vra2Nu+++O+f2v8raqvzU1dXFNddcE506dYpf/vKXMX/+/IL19eabb8b5558fW265ZZx33nl5OfbZpvLHOie9cj+22QcAAAAAAAAAAAAAAAAAAKC4185HFOb6+VJJ4rXmlZaP46vkhysuuU3Lh9ymNFbS8pvKbUqlzzVJy52X1DVAEtfvX5aEHKZJntOSvn00JT4ris09l5qGfK83y2mtWSpJXTMmVSHum1pu9txzz4y5SF999dWibx/jxo2LW2+9NW3dNttsE7/97W+LOp41qcTfBawJiy/XfPKLFi2Kb33rW3HkkUfGjBkz8jq2VCoVt9xyS/Ts2TOmTp2alzaL8f02aeeDvsz3//8xfwAAAAAAAAAAAAAAAAAAAFQGudqzl8Rr+SsxJ8uXJTk3RKVIQg5RkivJuWuor5Lyr8tBWD7cu4LGSNp9KyIqY+5MQn4++3Nlc9wuH6U8bvNfTSkPfaGOP/nMDZvEc425mjp1avTq1SsmTJiQUztz586N/v37xw033JCnka1dks9DNsVtrdCSsMYFAAAAyJfqUg8AAAAAAAAAAAAAAAAAKsGf//znePnll9PWnXPOObHVVls1us2VK1fGyJEjY5tttokRI0Zknfjugw8+iOHDh0eHDh3il7/8ZdTW1mbVzprcd999sf3228fgwYPjqaeeilQq1eg2Xn311TjttNNi++23z5h4PRvTp0+PAQMGRM+ePWP8+PFZJSV85ZVX4rTTTouOHTsmIlHk2qxatSouu+yy6NixY1x11VUxd+7cRj3/88Rl2267bV6S4ZfS4sWLY+TIkdGpU6fYbbfd4swzz4wxY8bEww8/HM8//3y88cYb8fLLL8eUKVPiL3/5S/z4xz+OPfbYI772ta/FZZddFvPmzavXZsuWLdP2tWrVqkaNbe7cuXHYYYfFkUcemVWC1JdeeimOOeaY+MY3vpGXJPPQGOW8b1WaJK0Xvuz111+PZ555pl755MmT47333ito3xHJfd/K3SeffBKHHHJIHHjggfGPf/yjUc9dsGBBjBo1Kjp16hSTJ08u0Aj/pyluA9aA5cH8R2O98MILsdNOO8UZZ5wR7777bqOeu2zZsrjjjjtit912i6OOOirtGivfXnrppYznRx544IH4+OOPCz6GQpo2bVrsu+++sfvuu8eNN94Yr732WtTV1ZV6WGXFPJNfzg1UnldffTV69OgRJ5xwQrzxxhuNem4p5vVcOTebbCtWrIhFixbFe++9F88++2zceuutcfHFF8dBBx0UG220UQwaNCgeeuihUg/zC0mdM8v595VC+POf/xzjxo1LW7fDDjvEddddl1P748ePT1ue6aa8jfHiiy/GrFmz6pU//vjjBVvnWluVp48//jguuOCC2GKLLeL444+Pv/71r7FkyZKc2qyrq4vnn38+RowYET169Iivf/3r8atf/SoWLlyYp1H/l20qf6xzMivnY5t9AAAAAAAAAAAAAAAAAAAA/qsQ185HFO/6+VJJ4rXmlZaP46vkhysuuU3Lg9ymZCNJ+U3lNiWi8ueapOXOS+oaIInr9y9LQg7TJM9pSd8+mhKfFcXmnktNQz7Wm+W61iyVpK4Zk6oQ900tF23atIlbb701mjVrVq9u2bJlceyxx8bKlSuLPq4zzjgj3n///bR1xx9/fBx99NFFHlFmlfi7gDVh8eUjn/ydd94Z22yzTRx55JHx8MMPx/Lly7Mez/z582PMmDGx++67x/HHHx8fffRR1m2lU4zvt0k7H/Rlvv+bPwAAAAAAAAAAAAAAAAAAACqRXO3ZSeK1/JWYk+XLkpwbolIkIYcoyZXk3DWsrtLyr8tBWB7cu4LGStJ9KyIqa+4s9/x89ufK5rhdHkp93Oa/mloe+nwdfwqVGzaJ5xpz9cknn8QhhxwSBx54YPzjH/9o1HMXLFgQo0aNik6dOsXkyZMLNMLMknwesilua8VQ7mtcAAAAgHyoSqVSqQY9sKqq0GMBEqpbt27RrVu3iIhIpVLx7rvvxjPPPBMNnF4AAAAAAAAAAAAAyEJVVVX06NEjunTp8sXfe7/22mvx2muvlXhkTZO/qQWKqUePHrH33ntH9+7dY+utt45NNtkkWrVqFTU1NbFixYr49NNPY8GCBTF16tR4/fXX4+9//3tJjg+bbbZZ7L///tG7d+/o1KlTdOjQIVq3bh3rrrtu1NXVxcKFC2PBggXx5ptvxksvvRSPPPJIo5NfZ2udddaJPn36RK9evaJbt26xxRZbRNu2baN169axfPnyWLhwYXzyySfx+uuvx6uvvhqTJk2K999/vyhjK5Xq6urYd999Y++9945ddtklOnbs+MV7snTp0vj000/jgw8+iFdeeSWmTJkSjz76aGISNBVbdXV1xkSVO+64Y07b+fbbbx9777137LHHHtGpU6do165dbLDBBtG8efNYtGhRLFiw4Itkcw888EC8/fbbWfcF5aaQ+1YlSsp6odx43/KvQ4cO0a9fv9h///1j8803j4033jjat28fq1atigULFsScOXPi5ZdfjqeeeiomTJgQK1asKOl4m9o2YA3I55ratp903bt3jz59+sQ3vvGN2G677b7Yb5ctWxYLFy6Mjz76KF577bV47rnnYuLEiXm5YV1jPfzww3HQQQfVKz/iiCPivvvuK/p4Cq1Vq1bxta99bbXvaOl89tln8eijjxZ5dOXBPJM/zg2Ut0y/C60pd9POO+8chxxySHzjG9+ILl26xPrrr19283o+OTdLMSV1zizn31coD9ZW5ammpiZ23nnn6NmzZ3z961+PDh06xNe//vVYb731Yp111omI/34nWLZsWSxatChmzpwZM2fOjLfeeiteeeWVePXVV+PTTz8tydhtU/lhnZNZuR/b7AOQfFVVVdGzZ8/o3Lmzv6cFGiyXv/GWqx3IxHUlAAAAAAAAAAAAAMUnV3t58Te1kHzprp3//PrgJFw/XwquNS9P8sMVj9ymfE7+huQp9/ymcps6dqVTyXNN0nLnJXUNUE7r90rOYZrUOa2ctg/WzGdF0rjnUnJ8eb3Zs2fPillrlkpS14xAMlgTJtN6660X++23X3Tr1i122GGH2G677aJNmzbRunXraNWqVaRSqVi8eHEsWrQoPv3003jnnXe++BuQp556KlatWlXU8Rb6+23Szgd9VUPfnwcffLDII1sz8wcAlUqudiAbcrUDheC6EgAAAAAAAAAAAIDik6u9vPibWkg+udobz7X85SmpuSHLUSXnECWZkp67pqmr5PzrchDyuUrOJ1+Jyv2+FRGVO3cmIT+f/blyOW5D/iQtD31jjj8vv/xy0Y89TfFcY4cOHaJfv36x//77x+abbx4bb7xxtG/fPlatWhULFiyIOXPmxMsvvxxPPfVUTJgwIVasWFHqIa8mqechm+K2VgxJWOMCAACVS652IBsN+RvvqlQD/xJc8nYgExeaAAAAAAAAAAAAABSf5O3lxd/UAgCfa9euXcyfPz9t3WabbRazZ88u8oigMti3AACSYYsttogZM2ZEdXX1auWzZ8+OLbbYImOya4BKkM3NAAEAAIDcSN4OZCOXv/F2vg/IxHUlAAAAAAAAAAAAAMUnV3t58Te1AABAPshtCjQFcpgCNB3uuQQAAABAocnVDmRDrnagEFxXAgAAAAAAAAAAAFB8crWXF39TCwCVRw5RIF/kXwdoPHMnAOVOHnoAAACA8iBXO5CNhvyNd/VaHwEAAAAAAAAAAAAAAAAANMj222+ftnzlypUSt0EO7FsAAMnw3e9+t96NFyIibrnlFjdeAAAAAAAAAAAAAAAAAAAAAAAAAAAAMpLbFACASuKeSwAAAAAAAAAAAAAAAAAAAAAAAAAATZv86wCNZ+4EoNzJQw8AAAAAUNnq/1oJAAAAAAAAAAAAAAAAAGSlV69eacvffPPNIo8EKot9CwCg/FVVVcWpp56atm706NFFHg0AAAAAAAAAAAAAAAAAAACUXlV1RM9B//0vAAAAAACZyW0KAEClcc8lAAAAAAAAAAAAAAAAAAAAAAAAAICmS/51gMYzdwKQBPLQAwAAAABUtupSDwAAAAAAAAAAAAAAAAAAKsXBBx+ctvzFF18s8kigsti3AADK32GHHRYdO3asVz5lypSYNm1a8QcEAAAAAAAAAAAAAAAAAAAAJbbfyREHnBqx/ymlHgkAAAAAQHmT2xQAgErjnksAAAAAAAAAAAAAAAAAAAAAAAAAAE2X/OsAjWfuBCAJ5KEHAAAAAKhs1aUeAAAAAAAAAAAAAAAAAAAUW6tWrfLe5hZbbBGHHnpo2rqHHnoo7/1BObJvAQA0XZdddlna8uuuu67IIwEAAAAAAAAAAAAAAAAAAIDS27lPRK9v//f/ew6K6NavtOMBAAAAAChncpsCAFAq7rkEAAAAAAAAAAAAAAAAAAAAAAAAAEC+yb8O0HjmTgDySR56AAAAAACyUV3qAQAAAAAAAAAAAAAAAABAsVRXV8fw4cPjrbfeik022SSvbV944YXRrFmzeuXLli2LiRMn5rUvKDf2LQCApu3444+P7t271yt/99134+677y7BiAAAAAAAAAAAAAAAAAAAAKB0ttgpot9Zq5f1OTOiQ7fSjAcAAAAAoJzJbQoAQCm45xIAAAAAAAAAAAAAAAAAAAAAAAAAAIUg/zpA45k7AcgXeegBAAAAAMhFTakHAAAAAAAAAAAAAAAAAADF0KFDh7jtttti7733joiIv/71r3HwwQfHsmXLcm77oIMOiu9///tp626//fZYsGBBzn1AubJvAQA0bZ06dYrrrrsubd3ll18eqVSqyCMCAAAAAAAAAAAAAAAAAACA0ll/k4hvXRrRrPnq5c2aRwy8KOKWcyIWzCrN2KBcbLHFFnHyySenrUulUjFixIioq6sr8qgAAAAAKAW5TQEAKAX3XAIAAAAAAAAAAAAAAAAAAAAAAAAAoBDkXwdoPHMnAPkiDz0AAAAAALmqKfUAAAAAAAAAAAAAAAAAAKDQvvWtb8WYMWOiXbt2X5TttddeMWnSpBg0aFB8/PHHWbd94IEHxl133RVVVVX16latWhUjRozIum0od/YtAICmrVevXnHHHXfEBhtsUK/ujTfeiL/85S8lGBUAAAAAAAAAAAAAAAAAAACURvN1Ir7904j12qWvX69dxLcui7h1WMSKpcUcGZSXb3/72/HTn/40bd0rr7wSV1xxRZFHBAAAAEApyG0KAEApuOcSAAAAAAAAAAAAAAAAAAAAAAAAAACFIP86QOOZOwHIF3noAQAAAADIh+pSDwAAAAAAAAAAAAAAAAAACq1Lly6rJW773D777BOvv/56nHTSSdG8efNGtdm+ffsYOXJkTJw4Mdq2bZv2Mdddd1289dZb2QwZEsG+BQBQ+aqqqqJFixbRsmXLaN++feywww5x3HHHxd133x1PP/10bLXVVmmfd8YZZ0RdXV2RRwsAAAAAAAAAAAAAAAAAAAAlUhVx+AURG2+z5odt3DHi8AsjqqqLMiooSwMGDMhYN3HixCKOBAAAAIBCk9sUAIBy455LAAAAAAAAAAAAAAAAAAAAAAAAAABkS/51gMYzdwJQDPLQAwAAAACQDzWlHgAAAAAAAAAAAAAAAAAAFNqvfvWr+Na3vhW77757vbpNNtkkxowZEz//+c/j/vvvjylTpsS0adPiP//5TyxZsiSWL18eNTU10b59+9hwww1j1113jQMPPDAOPfTQaNOmTcY+X3755bjooosK+bKg5OxbAACV78gjj4zbb7+9Uc/5zW9+E48//niBRgQAAAAAAAAAAAAAAAAAAADlZ98TIzrt0bDHbtcrYv9TIh4dXdAhQVlq2bJl7LfffhnrJ06cWMTRAAAAAFBocpsCAFBu3HMJAAAAAAAAAAAAAAAAAAAAAAAAAIBsyb8O0HjmTgCKQR56AAAAAADyoabUAwAAAAAAAAAAAAAAAACAQqutrY3DDjssnn766ejcuXPax2yyySbxve99L773ve/l3N+7774bhxxySKxYsSLntqCc2bcAAPiqRx99NIYNG1bqYQAAAAAAAAAAAAAAAAAAAEDRfP2AiN2Patxzeg6KmPd+xGsPFWZM+dS5c+fo379/7LnnntGlS5fo0KFDtGrVKtZbb71YuXJlfPrppzF9+vR4+eWXY+LEiXHffffFypUrc+qzqqoq9txzzzj88MPjG9/4Rmy//faxwQYbROvWrSMiYsGCBfHJJ5/EP//5z3j66afjr3/9a0yfPj2rvtq2bRsnn3xyHH744dG1a9do165drFixIj744IN48sknY+zYsfHkk09m/VrWXXfdOP744zPW33LLLbF06dKs2//cQQcdFA8//HDG+oULF0bHjh1jwYIFjW776quvjnPOOSdj/fe///244YYbGtTWvvvuG+uuu27ausWLF8dTTz31xb+T8poAAAAAyB+5TQEAKDT3XAIAAAAAAAAAAAAAAAAAAAAAAAAAoFjkXwdoPHMnANmQhx4AAAAAgHyoLvUAAAAAAAAAAAAAAAAAAKAYPv7449h3333j6aefLmg/L7zwQuy5557x0UcfFbQfKBf2LQAAPvfggw/GYYcdFitXriz1UAAAAAAAAAAAAAAAAAAAAKAovrZ9xIBzIqqq/ldWVxvx8furP+7DNyJWrVi9rM+ZER26FX6M2erTp09MmTIlpk2bFtdff30cc8wxsdtuu8XGG28c6623XkRENG/ePDbccMPo0aNHDB06NO6666748MMPY9iwYdG8efOs+j3ppJPi7bffjieffDIuuOCC6NevX3Ts2DHatm0bzZo1i2bNmsWGG24YnTt3jkGDBsWvfvWrePvtt+P++++P7bffvlF9DRgwIN5999246qqrYv/9948NN9wwmjVrFuuuu2506dIlvve978UTTzwR48aNi1atWmX1eq666qq48cYb00avXr1i6dKlWbX7VX//+9/jgQceyFjftm3buOCCCxrd7hZbbBH/93//l7H+jTfeiBtvvLHB7Q0YMCBj3d///vdYtWrVav9OwmsCAAAAID/kNgUAoFjccwkAAAAAAAAAAAAAAAAAAAAAAAAAgEKTfx2g8cydAORCHnoAAAAAAHJVXeoBAAAAAAAAAAAAAAAAAECxfPTRR7H//vvHZZddFkuXLs1r28uXL4+RI0fGHnvsEbNnz85r21Du7FsAAE3b7Nmz44wzzohDDz007+tBAAAAAAAAAAAAAAAAAAAAKFetN4r41mURNS1WL3/0DxEf/HP1stnvREy4JiKV+l9Zs+YRAy+KaPe1wo+1MVq2bBl/+ctfYtKkSbHPPvs0+vkbbbRRXHXVVfGPf/wjOnTo0OjnjhkzJrbddttGPa+6ujoOPfTQeOWVV2Lo0KENes7pp58eDzzwQLRv336tjz366KPj2WefjXbt2jVqXAMGDIgzzjgjbd0777wTZ599dqPaW5vzzjsvVq1albH+rLPOik022aRRbV522WXRsmXLjPXnnntu1NbWNri9/v37Z6ybOHFivbIkvCYAAAAAciO3KQAApeCeSwAAAAAAAAAAAAAAAAAAAAAAAAAAFIL86wCNZ+4EIF/koQcAAAAAIBfVpR4AAAAAAAAAAAAAAAAAABTTypUr4/LLL4/OnTvHiBEj4sMPP8ypvYULF8Z1110XXbp0iYsvvjhWrVqVp5FCsti3AAAqX11dXSxZsiQ++OCDeOKJJ+Laa6+Nww47LLbccsv4/e9/X+rhAQAAAAAAAAAAAAAAAAAAQNHUtIwY9JOI1u1XL391YsSL96R/zhuPRjw7fvWy9dpFfOuyiBbr5X+M2WjZsmVMmjQphgwZknNb3bt3jyeeeCI233zzBj2+bdu28fDDD+fU5zrrrBOjR4+OU089da1ju/7666OqqqrBbe+0005x8803N/jxG220UYwdOzZtXW1tbQwZMiSWLFnS4PYa4s0334zRo0dnrF9vvfXi4osvbnB7nTp1ipNOOilj/eTJk2PChAkNbq9Dhw7x9a9/PWP9Qw89VK+s3F8TAAAAAA0ntykAAOXGPZcAAAAAAAAAAAAAAAAAAAAAAAAAAMiW/OsAjWfuBKAY5KEHAAAAACBbNaUeAAAAAAAAAAAAAAAAAACUwocffhiXXHJJDB8+PHbbbbfYf//9o2fPnrHttttGx44dY/31148WLVqs9pzPPvssZs6cGe+88068+OKL8eijj8bjjz8eK1euLNGrgPJj3wIAqCzjx4+P8ePHl3oYAGWvqqqq1EMAAAAAAAAAAAAAAAAAAKCIDj0vYrNOq5fNeC1i8m/W/LwpYyPabxnRZa//lW3cMeLwCyP++pOIVF2+R9o41113Xey77755a2/rrbeO22+/PfbZZ5+1PnbMmDGxyy675KXfG264IZ5++un417/+lbb+5ptvjubNm9crnzZtWjz55JOx4YYbxoABA+rlzBo0aFAMHDgw/va3v611DDfddFNsuummaeuuvPLKeOaZZxrwShpv+PDhMXjw4Gjbtm3a+tNOOy1GjRoV//nPf9ba1uWXXx41NTVp62pra2PYsGGNGlu/fv0y1r311lsxffr0tHXl/JoAAAAAWDO5TQFWJ4cpQHlyzyUAAAAAAAAAAAAAAAAAAAAAAAAAPieHKLAm8q8DNJ65E4BSkYceAAAAAIDGqin1AAAAAAAAAAAAAAAAAACglOrq6uKFF16IF154oV5ds2bNomXLlpFKpWLZsmWRSqVKMEJIJvsWAAAAAAAAAAAAAAAAAAAAAABQifY6PmL7fVYvm/9hxN9GRNStWvvz7/9lxOCrIjbt9L+y7XpF7H9KxKOj8zvWxujevXucdtppeW937733jqOPPjpuv/32jI855JBDYtCgQXnrs1mzZnH11VdH375969Xtueeescsuu9Qr/+tf/xpHHnlk1NXVRUTE7rvvHlOmTIkWLVqs9rjvf//78be//W2N/X/ve9+LgQMHpq174YUX4ic/+UkDX0njzZs3L372s5/FqFGj0ta3bNkyLrvsshg6dOga2+natWscc8wxGetvvvnm+Ne//tWosfXv3z9j3cSJEzPWlfNrAgAAAAAAACqHey4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFQWeegBAAAAAGio6lIPAAAAAAAAAAAAAAAAAADKVW1tbSxdujQ+++wzidsgj+xbAAAAAAAAAAAAAAAAAAAAAABAEm2/T8Sex61etnxJxN2XR3y2sGFtrFoecddPIhbPW72856CIrn3zMsysbLXVVjF79uyM9Y888kicfPLJ0atXr+jYsWN06NAhevbsGeecc0688847a2z7jDPOWGP9+eefn7HuH//4R3zve9+L3r17x1ZbbRUdO3aMQw89NO6+++41tnnwwQfHZpttVq+8f//+aR9/3nnnRV1d3Rf/fvbZZ+P222+v97j9998/WrRokbHfbbfdNq677rq0dUuXLo3jjjsuamtr1zj2XF1//fUxffr0jPUnnnhibLfddmtsY8SIEVFVVZW2btGiRXHppZc2akzNmjWLgw8+OGP9hAkT1vj8cnxNAAAAAAAAQNPhnksAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJVFHnoAAAAAAL6sutQDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAcrfXkIiqqv/9u6424v5fRnz8XuPaWfxxxN2XR6xctnr5AUNzHmLW7r777thqq63ilFNOialTp35RvmrVqjjxxBPjoIMOijFjxsTzzz8f77//fvznP/+JF154Ia699trYaaedYsKECRnb3muvvWKdddbJWH/PPffE9OnTVytLpVIxdOjQ2HPPPWPs2LHx7LPPxgcffBDvv/9+PPjggzFo0KA4/fTTM7ZZVVUVffv2rVe+44471iubNWtWvf4jIp544ol6Zc2bN4/tttsubZ/V1dVx6623RuvWrdPWn3vuufHWW29lHHO+rFixIi644IKM9TU1NXH55ZdnrN99993j8MMPz1g/cuTImDNnTqPG1Lt372jbtm3auuXLl8djjz22xueX42sCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACSr7rUAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgHLXfJ3V//342Ih3ns2urVlTIyZeE5FK/a/sy/9fCitWrIibb745dthhhxg4cGA8/fTTcf3118ef/vSnNT5v+fLlceKJJ8aqVavS1tfU1ESnTp0yPv+6666LTp06xaBBg74ou+GGG+Kmm25aY7833nhj/P3vf89Yv9VWW9Ura9euXb2yOXPmpH1+pvL27dunLb/ooouid+/eaesefPDB+P3vf59hpPl3xx13xNNPP52x/phjjomddtopbd2VV16Z8Xnvv/9+XHPNNY0eT//+/TPWPfHEE/HZZ5+ttY1ye00AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDyVZd6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUO4e/l3Eis8i6mojnr0j4vk7c2vvjccjHrvpv+2t+Cxi8m/yM858uPfee2OvvfaK888/v0GPnzNnTkybNi1jfbt27db4/Lq6urj77rujR48eccstt8SIESMa1O+jjz6asW7TTTetV9asWbN6ZStXrkz7/Ezl6dro0aNHXHbZZWkfP3fu3DjppJMyjrNQhg0blrGuuro6fvazn9UrP/DAA+OAAw7I+LwLLrggli9f3uix9O/fP2PdhAkTGtxOOb0mAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAg+apLPQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACh37zwT8ZujI64dFPH4zflp8/m7Iq791n/bfXNKftrMp7q6ugY/duXKlRnrVqxY0aA2XnzxxTj++ONj1qxZDXp8dXV1xrqqqqqc2lhT21+27rrrxq233ho1NTVp60855ZSYM2dOg9rKp2effTbGjRuXsf6b3/xm9OjRY7WyK6+8co3t3X777Y0ex0YbbRTdu3fPWP/QQw81uK1yeU0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBlqC71AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAlWrYhYtbwAba7Ib5vFVl1dHR07dsxY/5///Kcg/Xbr1i1j3YIFC+qVLV26tF5Z69at0z4/U/mSJUtW+/fVV18dXbp0SfvYm2++Oe69996MYyy0Cy64IJYtW5axfsSIEV/8/xFHHBG9evXK+Ngf/vCHWY2hT58+UVVVlbZu5syZ8frrrzeqvXJ4TQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQGWoLvUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA5Bo8eHC0bds2bd2sWbNi1qxZee9z2223jSOOOCJj/TvvvFOv7IMPPqhX1rFjx2jZsmW98h133DFtuzNmzPji/w855JA4/fTTM/Z/9tlnZxxfMcyYMSOuu+66jPV9+/aNffbZJ6qqqmLEiBEZH3f77bfHM888k9UYBgwYkLFu4sSJjW6vHF4TAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQGapLPQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACB5WrVqFWeddVaMHj0642NuvfXWSKVSee23bdu2MW7cuGjRokXGxzz11FMNKmvRokUcd9xxq5U1b948jj322HqPnT59esydOzciIjbaaKMYM2ZM2r5ra2tjyJAhsWTJkjW+jmIYMWLEF2NOZ+TIkXHsscfGzjvvnLZ++fLlccEFF2Tdf79+/TLWTZw4Mas2S/2aAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAylBT6gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADl6ZJLLomDDjpotbKamppo3759dO7cOZo3b57xufPmzYtRo0bldTw77bRT3HrrrbHLLrtkfMxzzz0X06ZNq1d+7733xuLFi6N169arlf/617+O1q1bx2OPPRYbbrhhXHzxxdGpU6d6z7/11lu/+P+bb745Nt1007T9jxw5Mp555pmGvqSCWrRoUVx66aXx+9//Pm393nvvHV27ds34/GuuuSbef//9rPr+xje+EZtssknautra2nj44YezareUrwkAAGBtWrVqFe3atYtmzZqlrZ8xY0aRRwQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGRSU+oBAAAAAAAAAAAAAAAAAAAAFNOjjz6atvyAAw4o8kgAoLh++9vfxo477liv/Iwzzog333yzBCOiEtiuIDe+n0BumtI+1JRe61c15dcOQNPguzUAAAAAAAAAAAAAAEmw0047xf7779/o59XW1sbQoUNjzpw5eRnH+uuvHxdddFEMGzYsmjdvvsbHXnLJJWnLFy5cGFdeeWWMGDFitfJWrVrF9ddfv8Y2Z82aFddcc01ERJx88slxxBFHpH3c888/Hz/96U/X2Fax/eEPf4izzjor7XUMERFt27ZNWz5nzpwYOXJk1v32798/Y92zzz4bCxYsyLrtUr0mAACAL9tuu+3i0EMPjf322y9233332GSTTdb6nbWqqqpIowMAIuR4oTwlIc9eEsZIYZk/G67c9pdyGw/FZd8FoFCsMQDyz/odAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMpHTakHAAAAAAAAAAAAAAAAAOWiZcuWsfPOO8eWW24Zbdu2jfXXXz/WW2+9WLlyZXz66afx6aefxieffBL//ve/Y9asWaUeLgAAWdp///1LPQSgArRo0SJt+YoVK4o8Emi43XbbLXr37l2vfP311y/BaKgUtivIje8nNGX5WFM3pX0oia81X9+b8vXafY9LDp8V0NT4bg0AAAAAAAAAAAAAQKVasWJFHH300XHPPffk3FaLFi3i+9//flxyySXRvn37tT7+d7/7XUyePDlj/ZVXXhkHH3xwHHDAAQ0eQ11dXQwePDg++eST2G677eLaa69N+7ilS5fG4MGDo7a2NiIiNtxww/jWt74Ve+65Z2y++eZRU1MT8+bNi5dffjnuueeeePPNNxs8hlzU1dXFueeeGxMmTGjU8y699NJYtGhR1v0OGDAgY93EiROzbjeidK8JAKCSydUODbfjjjvG8OHD48gjj4zq6upSDwcAWAM5XihHScgxmIQxUljmz4Yrt9yZ9t+mzb5benKrUqls21hjFJ79DJoe63cAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKB81pR4AAAAAAAAAAAAAAAAAlEp1dXXst99+cdRRR8Xee+8dO+ywQ9TUNOySm7lz58bLL78c9957b9x1113x0UcfFXSsZ511VrRr1y7ndlKpVCxevDgWLlwYCxYsiAULFsQbb7wRs2bNyn2QaRx44IGx99571yufNm1ajBs3riB9ZnLcccdFp06d6pU/9thjMWXKlKKOBQAASLYuXbrE1KlT09Ztv/32MW3atCKPCAAAksWauvKV22dcbuMhM58VAAAAAAAAAAAAAAAAVI7mzZvHAQccEPfff3+sWrUqqzaqqqri+OOPjyuuuCK22mqrBj1n/Pjx8YMf/GCNj0mlUjFw4MC45ZZb4ogjjlhrmwsXLowhQ4bEo48+GtXV1XHLLbdE69at0z522LBh8dZbb0VVVVVccskl8eMf/zjWXXfdeo876qij4sorr4y//vWvccopp8T8+fMb9PpyMXHixJg0aVL07du3QY//17/+FTfddFPW/bVu3Tr22GOPNY4nV8V+TQAAlUaudrnaI+Rqz8bRRx8df/rTn6Jly5alHgoldM4550SbNm1WK5s6dWrcfvvtRR9LpjnyzjvvjH//+99FHw8AANB48jFCZbAvU6ls21B49jMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACitmlIPAAAAAAAAAAAAAAAAAIpt/fXXj/POOy9OPfXU2HTTTbNqY+ONN46+fftG37594/rrr49HH300Lr/88pgyZUqeR/tf55xzTnTs2LEgbUdEzJo1K1544YV46qmn4tZbb43//Oc/eWm3T58+ceGFF9Yrv//++2PcuHF56aOhjj/++Ojfv3+98ssuu6xgnxsAAAAAAAAAAAAAAAAAAAAAAAAANEVVVVVx1llnxY477hiHHXZYLF++vFHP79u3b1x11VWx8847N+jxqVQqfvGLX8SPf/zjBj1+0aJFMXDgwDjjjDPiwgsvjK222qreY1atWhX33HNPXHDBBfHuu+9GRMTFF18cvXv3Ttvmgw8+GDfeeGOsu+668de//jVtDsSvGjRoUHTv3j0OOeSQ+Pe//92gsedi2LBh8eqrr0azZs0a9Ni6urqs+zrooIOiefPmaevmzZsXL7zwQtZtf1kxXxMAQKWQq70+udrlam+o0047LX73u99FVVVVqYdCCe22225x9dVX1ytftGhR3H///bFkyZKijifTHPnmm28W5XwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECSVZd6AAAAAAAAAAAAAAAAAFAsNTU1ceGFF8Z7770Xl156aWy66aZ5abe6ujoOOuigePzxx2PSpEmx44475qXdYvra174Whx9+ePz85z+P999/Px588ME44ogjSj0sAAAAAAAAAAAAAAAAAAAAAAAAACDBDj744Ljxxhsb/Ph27drF+PHj46GHHoqdd965Qc95//334+CDD44f//jHjR7f7373u9h6661j1113je9+97vxwx/+MM4444w49NBDY5NNNokjjzwy3n333YiI6NmzZwwfPjxtO3Pnzo2TTjopIiJ+/etfR//+/Rs8hq233jruueeeaNWqVaPH31ivv/56jBkzZq2PmzBhQkyePDmnvgYMGJCxbvLkyZFKpXJq/3PFfE0AAEknV3tmcrXTEF27do3rrrsuqqqq1vrY2traWLZsWdog+U477bS05W3atIljjz22yKMBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAXNaUeAAAAAAAAAAAAAAAAABTDtttuG+PGjYuePXsWtJ8+ffrECy+8EN///vdj7NixBe2rUKqrq2PAgAExYMCAeOihh+LUU0+NGTNmlHpYQIXaa6+94pJLLqlX/sQTT8TIkSNLMCIAIImsKQAAACgF30cBAAAAAAAAAAAAAACApmLYsGFx2WWXrVbWsmXL2GijjWLXXXeNY489Nnr06JHx+SeccELcfPPN8cQTT6y1r+effz46derUoHF99tln8ctf/jJ+/vOfx7Jlyxr0nExeeeWVeOWVVzLWr7vuunHLLbdETU1N2vpTTjkl5syZEwMGDIiTTz457WPmzp0bS5Ysia233jqqqqpWq+vcuXOMGjUq/u///i/r19BQl1xySRxzzDHRpk2btPW1tbVx7rnn5txPv379MtZNmDAh5/a/rFivCQAgyeRqbzi52snkj3/8Y7Rs2TJt3ccffxw33HBDPPDAA/HGG2/EokWLijw6iqV169Zx3HHHZaw/44wz4qabbiriiAAAAAAAKAR5yAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoOmoKfUAAAAAAAAAAAAAAAAAoNAOOeSQuP3226N169ZF6W/dddeNMWPGRK9eveKMM84oSp+F0q9fv3j99dfjzDPPjD/96U+lHg5QgTbddNPo379/vfLFixeXYDQAQFJZUwAAAFAKvo8CAAAAAAAAAAAAAAAATcWsWbNi1qxZaeseffTRuPrqq+Okk06KG2+8MZo3b572cWeffXY88cQTa+xn8803j06dOq11PLW1tTF27NgYPnx4xnHl2zXXXBNdunRJW3fTTTfFvffeGxERP/rRj+rV19XVxQknnBC33HJLRETstNNOMXHixNhyyy1Xe9z3vve9uOSSS+KTTz7J8+hXN2fOnLjzzjvjpJNOSlv/yCOPxBtvvJFTH126dImOHTtmrJ80aVJO7X9VMV4TAECSydWePbna+dx+++0Xu+22W9q6yZMnx3e+85349NNPizwqSuG4445b43y62267Rffu3ePFF18s4qgAAAAAAMg3ecgBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKDpqCn1AAAAAAAAAAAAAAAAAKCQBg4cGOPHj48WLVqs8XELFiyIhx9+OKZMmRJvvvlmzJgxIxYtWhTLly+PmpqaaNOmTWywwQbRpUuX6NatWxx00EHRvXv3NbZ5+umnx/Lly+OHP/xhHl/R6v7zn//EggULGvz46urqaNWqVay//vrRtm3bqK6uXutzWrduHX/84x9jk002iVGjRuUwWgAAAAAAAAAAAAAAAAAAAAAAAACgEo0dOza22GKLuOKKK9LW9+nTZ43Pr6qqinHjxq21n3vvvTcuvPDCeOONN7IaZzYOPfTQOO2009LWvfPOO1/knWzbtm3ss88+9R5z2223xS233PLFv19//fU477zz6r3eli1bRv/+/eO2227L3+AzWL58eVZ1DdWvX7+Mda+++mp89NFHOffxVYV+TQAASSVX++rkaidbZ555ZtryqVOnxhFHHBHLli0r8ogoldNPP71Bjxk6dGgRRgMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQK5qSj0AAAAAAAAAAAAAAAAAKJT+/fvHnXfeGTU1mS+jee2112LkyJFxzz33xPLlyzM+bvbs2RER8fzzz8ett94aERHbbLNNnH322XH66adHy5Yt0z7v7LPPjpkzZ8aoUaNyeCWZnXvuuTF+/PisntuiRYvYaaed4hvf+EYcccQRccghh0SLFi0yPv6Xv/xlzJw5M2677bZshwsAAFARli1bFi+88ELGOgAAYM2sqStfuX3G5TYeMvNZAQAAAAAAAAAAAAAAQLKNHj06rrjiirR166+/fmy66aZf5Hf8qlNPPTX22WefjG2/+uqr8f3vfz+eeuqpvIy1oTbaaKO4+eab09bV1tbG4MGDY8mSJRERsfPOO0ezZs3qPe6BBx5oUFlExK677loReR8HDBiQsW7ixIlFHAkAQNMmV/uaydVOYxx44IFpyy+44AJ5MZqQHj16xK677rrWxx177LExbNiwWLRoURFGBQAAVAL5GKEy2JepVLZtKDz7GQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlFZNqQcAAAAAAAAAAAAAAAAAhbDVVlvFrbfeGjU16S+hWbx4cZx77rkxevTorPuYPn16/PCHP4yrr746brvttthrr73SPu5nP/tZPPjgg/H6669n3VchrFixIl5++eV4+eWXY+zYsdGuXbs4//zz47zzzosWLVqkfc6NN94YTz75ZMyYMaPIowUAACgfM2bMiJ49e5Z6GAAAkFjW1JWv3D7jchsPmfmsAAAAAAAAAAAAAAAAINnmzJkTy5Yti3XWWSdt/frrrx+zZ8+uV15TUxOXXnppxnZHjx4dZ555ZqxcuTJvY22oMWPGxKabbpq2bsSIEfHss89+8e+NN9447ePS5XBcvHhxLFiwINq1a7da+SabbJL9YMtEy5YtY//9989YP3HixOINBgCgCZOrfe3kaqehvv71r0f79u3rlc+bNy/uu+++EoyIUjnttNMa9LhWrVrF4MGD4/e//32BRwQAAFQK+RihMtiXqVS2bSg8+xkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJRWdakHAAAAAAAAAAAAAAAAAPlWU1MTd955Z7Rv3z5t/fTp06NHjx4xevTovPQ3Y8aM2G+//WLs2LFp61u0aBF//OMfo7q6vC/nWbBgQVx88cXRtWvXmD59etrHtG7dOn75y18WeWQAAAAAAAAAAAAAAAAAAAAAAAAAQLmrrq6O5s2bZ6xftmxZ2vJ+/frFFltskbbuoYceitNPPz1WrlyZlzE2ximnnBKHH3542rrnn38+Lr/88tXKWrRokfaxy5cvb3B5pjaSZJ999ol11103bd3ixYvjqaeeKvKIAACaHrnasyNXO5nsuOOOacufffbZqKurK/JoKJU2bdrEscceW6/8gw8+SPv4M844o9BDAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgD6pLPQAAAAAAAAAAAAAAAADItzPOOCN69uyZtu69996LvfbaK6ZOnZrXPmtra+OUU06Ju+++O219jx494jvf+U5e+yyUadOmxT777BPvvfde2vqjjjoqOnXqVNxBAQAAAAAAAAAAAAAAAAAAAAAAAABF1bFjx0Y9vnv37tGsWbOM9XPmzElbPnDgwIzPueCCCyKVSjVqHPmw3XbbxbXXXpu2bunSpTF48OCora0t7qASYsCAARnrHnnkkVi5cmURRwMA0DTJ1Z4budr5qvbt26ctf/fdd4s8Ekpp8ODB0apVq3rl5513Xrz55pv1yrt16xa9evUqxtAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMhBdakHAAAAAAAAAAAAAAAAAPnUrl27+MlPfpK2bvHixdGvX7+YNWtWQfquq6uLE044IT788MO09T/60Y8K0m8hzJw5M0477bS0dVVVVfHd7363yCMCAAAAAAAAAAAAAAAAAAAAAAAAAIqhb9++MXHixJg+fXoceeSRDXpOs2bN4he/+EXG+jlz5sTy5cvT1nXv3j1t+dtvvx2vvvpqg/rPp+rq6rjllluiVatWaevPOeeceOutt+qVr1ixIu3j11lnnQaXZ3qPkqR///4Z6yZOnFjEkQAANE1yteeHXO182QYbbJC2fOHChUUeCaV0+umn1yv75JNP4p577ombb7457XPOOOOMQg8LAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAc1ZR6AAAAAAAAAAAAAAAAAJBPF154YbRv3z5t3fe///2YNm1aQftftGhRnH322XHHHXfUq9t2221jm222ienTpxd0DPkyadKkePjhh+Pggw+uVzdgwIAYPnx4CUYFAAAAAAAAAAAAAAAAAAAAAAAAAORby5YtY/DgwTFs2LDYaaedvii/5ZZbonPnznHdddfFkiVL0j53u+22i9/97ndxwAEHZGz/oYceyli39dZbpy1fuHBhHHLIIQ18BfXNmTMnXnjhhUY/75JLLonevXunrXvggQdi9OjRaetmz56dtnzrrbeOp556arWytm3bRtu2bRvcRlJsueWWseOOO2asX9N2AABAfsjVnj9ytfO5ddZZJ235ihUrijwSSqVnz56xyy671Cu/5ZZbYsWKFfGnP/0pRo4cGc2bN1+t/uijj44f/vCHsXDhwmINFQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACARqop9QAAAAAAAAAAAAAAAAAgX1q0aBGnnHJK2ronnngi/vznPxdlHHfeeWe8/fbb0alTp1i0aFH87W9/i//3//5fTJo0KVatWlWUMeTL+PHj4+CDD65Xvuuuu8Y666wTy5YtK8GoAAAAAAAAAAAAAAAAAAAAAAAAAIB8eu6556Jbt271ylu0aBEjRoyI4cOHxxNPPBHvvfdefPzxx1FXVxcbbrhhfOMb34hevXpFVVXVGtu/4447Mta1a9cubXn37t3jgQceaNTr+LL7778/Dj/88EY9p2fPnnHppZemrZs7d25873vfy/jcf/3rX7Fq1aqoqalZrfyb3/xm3HbbbauVHXHEEWnbePHFFxs13nLTr1+/jHVvvfVWvPvuu0UcDQBA0yNXe/7J1Q5ERJx++ulpy2+66aaI+O85g/vvvz++9a1vrVa/7rrrxvHHHx+/+c1vCj5GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACyU1PqAQD/H3v3HR9Ftf9//LNJSCCF3nsHKZEaQBCRIgiEJqIIUryiKFiuBb0i6EUQ/YoVFQWkyEURRIEgJaBSpCiiAiJVkN4DIaQSMr8//CWy7GyyZWZ3zu7r+Xi8H5qzO2fOTjlzZtk9CwAAAAAAAAAAAAAAAAAAAAAAjHLXXXdJqVKldB977rnnfNqWJ554QiIiImTFihWSmZnp03Ubac2aNbrloaGhUqNGDdmzZ4+PW6SW0NBQiYmJEZvNJleuXJGrV6/6u0mWVaRIESlSpIjk5ORIcnKyaJrm7ybZCYZ9GQyvUTURERESFRUlWVlZcuXKFX83xyW5bU5LS5OMjAx/N0dXbhvT09MlPT3d383xGSuf41a/BpghJiZGwsLCLLcvrHycmKFQoUISHR0tOTk5cvnyZcsdeypeB0TUuBYEIra78azaV+cK1jGNiLpjBxXO02A9roJtDORL4eHhEh0dLRkZGZKWlubv5rhM1XbDkarXDH9he7lH1e1FHwe4T4WxvNXf5/Ilq9/PW/n6ocq9kdX3cbDeWwMAAAAAAAAAAAAAAAAAAAAAAsf06dPl/fffd/p4RESEdO7c2aO6N2/eLAkJCU4fDw0N9aheo0VGRsr8+fMlLCxM9/F//etfcvbsWafLp6SkyLfffitdu3a1K+/fv7+MHj1apk2bJteuXZO2bdvKlClTHJZPS0uTVatWefci/OzOO+90+tjq1at92BIAAIDgxFztxmOudu+o8n121ak6j6kqihYtKvfee69D+bZt22TXrl15f8+cOVP69u3r8LyRI0fm+54LjKXCXEucs9Zg9blM/MXq24U5XgIffSSup8LxYOX5xa6nSv/JPSRcYfXxipFUOXf1WHU/BUM/o/Jxk0uF+WCtJBiO6xvljsHMPEbCwsIkJiZGMjIylD2XAokq4+5AoMJ9mDNcP1yn4jmlwv4NhHEYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADBLszfDQAAAAAAAAAAAAAAAAAAAAAAAACM8sADD+iWb926VbZs2eLTtqxYscKn6zPLiRMnnD5WsWJF2bNnjw9bY21xcXHSqVMniYuLkyZNmkjp0qUlOjra7jlZWVly4sQJ+f333+XXX3+Vl156yU+t9Z9ChQrJ7bffLt26dZPY2Fhp2LChlClTRkJDQ/Oeo2maXLp0SZKSkmTHjh2yfv16Wb9+vezYscMnbfRkXy5fvly2bdvmk/YZwZevsXTp0lK2bFmnj1etWlW3vFixYtKgQQO31pWVlSUHDx4s8Hl69Z45c0YuXLjgdJmIiAiJjY2V2rVrS7FixSQmJkZsNlve4++9955kZGS41d7rNWrUSHr37i1xcXESGxsrlSpVkkKFCuU9rmmaXLx4UXbv3i07d+6UxMRESUxM9GqdevS2zR9//KH73JIlS8rdd98tHTt2lKZNm0q1atUkPDw87/G0tDQ5d+6c7NmzR9asWSOJiYny+++/G9reglSsWFH69+8v7dq1k6ZNm0rVqlXt2njt2jU5efKk7N69WzZv3izLli1z2teEhYVJyZIlHcqTkpIkOzvbtNfgCav2YypcA4wWEREhXbt2la5du8rNN98sN910k5QoUcKu/8jKypIjR47I77//Lps3b5YlS5a41Jd5y6rHiVmaNGkiPXv2lBYtWkjjxo2lUqVKEhERkfe4pmly+fJl+eOPP2T79u2yYsUKSUxMlGvXrvmkfVa+DuR3jfTltUCVMYWI82unO/VYZbvfqGzZslK6dGm32usJm80mN910k0N5Tk6O7N2717D1iFi7r85VqVIl6du3r7Rv315uvvlmqV69ut0+z87Olr/++iuvf1iyZImcOXPGZ+0zi5XGDiqdp64K1uPKn2Mg1fpQd4/7EiVKSN++faVLly5y8803S82aNe3GW9euXZPTp0/Lzp07Zdu2bfL111/Lb7/95nJ7Ar3d7qpYsaIUL17coTw1NVWOHDliyjrDwsKkbt26DuVmXJ/d5Y9rhrN9cPHiRTl16pSnLyVfJUuWlPLlyzuUX7hwwa0+2urXWBH3x9RmstL2cldMTIz06NFDunfvLk2aNJG6dev6vI+z2j72pD3+vh8N1j4/GO+5XeWv97ms9m8rVr+ft/r1Q4X3h62+j0WC994aAAAAAAAAAAAAAAAAAAAAABDYPvzwQ+nVq5fccccdhtabnJwsDz/8sKF1muWtt96SOnXq6D42Y8YMSUhIKLCOyZMnyx133GH3XQibzSZTp06VN954QzIyMnS/OyYi8sEHH8jly5c9arsVhISESKdOnZw+vnLlSh+2BgAAIDgxV7vxmKvddSrP1e5sjp9c5cqVc1ru7jwjIt7NwaLqPKYi5s/1bZbBgwdLZGSkQ/nMmTPt/l61apWcOHFCKlWqZFfesGFDueWWW2Tz5s2mtjMQBOJ8cv44Z+vUqWO3jlynTp2SixcvelxvrpiYGKlSpYpD+Z49e0TTNK/rr1GjhhQpUsSh/MCBA3L16lW367PKXCZW6zetsl3yE4hzvJh5fqp2boowrjFbRESE1KpVy+njKSkpcuzYMR+2KH9WOR6csfr8YtdTpf9UYU40f7DaXJ7O+KKPUWG8YiRVzt0bWXk/+bOf8dW5bMXf5wrE+WCtxN/XT3/NG9yxY0e55557pE2bNlKvXj2H/vHo0aPy22+/yXfffSeLFi2Ss2fPutUeEZGmTZvKfffdJ7fccos0btxYYmJi8h7LPQ537twpK1eulBUrVhg2P7QvfsfCl78D5C1/jLv9PQ/5jXw5HrTSfRjXD3NY5V42EPevquN3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAM1FIkIIIbqJjY3VBg8erA0ePFgbNGiQ1qZNG81ms/m9XYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGBHJvNprVs2VIbNGhQ3mc5Y2Nj/d6uYA2fqSXEGilcuLCWkZGh+92YESNG+L193ubw4cO6r23AgAGmr/vixYu66+7Vq1eBy06ePFl32YSEBJ9vw5UrV+q2Zfz48R7XWahQIe2xxx7Tdu/eXeB3tPQcO3ZMe/bZZ7WiRYv6/RgzO+XLl9emTJmiJScne7StNE3TfvrpJ61v376mXGe93Zcq7E9/vcbx48d7vD53bdiwwaU26RkzZozD80JCQrR77rlHW7t2rXb16tV8112yZEmP9smDDz6o7d2716PXe+XKFe2jjz7SatSoYdhxoufG51SsWFGbOXOmlpWV5XabN2zYoHXo0MH04z0uLk5bvXq1lpOT43Ybt23bpnuNa9++ve7z4+Li/H5++/McdyVWvAY4Y9RrrlKlivbhhx9qKSkpHr/ePn36BNVxYkYiIyO1J554Qjt06JBHr/Xs2bPaCy+8oBUpUsSU9qlyHdC7RvrjWqDKmELT3O9L9Fhlu98YZ/d4eu319vzVk5KSYtg6rNpXX59bb71VS0xMdHtMc/XqVW327Nla9erVHercsmWL7jJWGdOIqDN2sOp5ynHlGKuMgVTrQ11ta+XKlbWPP/7Yo+N+z5492v3336+FhIQY9vpVbLcz+S3zr3/9S3eZixcvahEREaacS/3799dd54oVK0xZnyvx5zXD2T74/fffTXu9CxYs0F1nv379LL+9jDz+zagj0LZXiRIltNdff92jsa4V+jir1ePv+9Fg7fOdMaIeFcfyVnify9Vtafa/rVj9ft6K14/cWOXeSPV9LBKc99aEWDk2m02Li4vj87SEELfiDX+3nRBi3fC9EkIIIYQQQgghhBBCCCGEEEIIIYQQopcuo0Ubs+qfdBnt/za5kqJFi2rr16/36jN310tJSdHatm1b4HrN4s7chz169HBaz4EDB7TIyEiX65oyZYrbbf3111+18PBwn+3radOmGbLdrs8tt9zitM7MzEy3tqFVXhMhxLphrnZrhc/UEmKNMFe7eWGuducJlLnan3rqKY/a74kTJ054tJ1VncfU7PkofJEdO3Y4tDU1NVWLiYlxeO6kSZN0X9unn35qahv92UcaGVePKyvNJ6cXf5+zX3/9tW69M2fONOT1OZubqU2bNl7XHRYWpl26dMmh7qSkJC0sLMytuqw2l4ke5vHRTyDP8WLm+anKuenvPlIvenxxfjpjxGsqVqyY9sMPPzhdx5EjR7R69er5tY1WPR5ujJXnF7sxKvSfqsyJ5kmcUb0evRjVxziLCuMVI6PCuavSfjKinzGij3HGqNdp5d/n0qPifLBWipWun84YUY/ecdK1a1dtz549br3W7OxsbdasWVqlSpVcakvr1q21rVu3urWOa9euafPmzdOqVavm9f71xe9YGPk7QM5420Z/jrv9PQ+5r7Zxbqx6H6aH64ea51Sg719Vx++EEEICO8zVTgjxJN7wd9sJIdYN3yshhBBCCCGEEEIIIYQQQgghhBBCCCGEEEII8X2Yq91a4TO1hBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIb4Nc7UTQjyJS3OyM3k7IcTb8EUTQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEN+HydutFT5TS4g10qlTJ93vxVy7dk0rXbq039vnbQ4fPqz7+gYMGGD6uk+dOqW77n79+hW47OTJk3WXTUhI8Pk2XLlypW5bxo8f71F9bdu21Xbv3l3wl7NckJSUpA0dOtTvx5kZsdls2jPPPKOlp6cbsq00TdM2b96sVahQwbA2GrkvNc2a+9Ofr3H8+PGGrbcg06ZNc6lNesaMGWP3nPr162s//fSTy+suWbKkW/vkjjvu0P766y9DXnd2drb21ltvaYULF/b6WNFz/eP33XefduXKFa/b/OWXX2pRUVGGH+sxMTHa//73P6/bp2matnjxYrv92r59e93nxcXFBfU5nl+sfA1wxtt6CxUqpE2aNEnLysoy5PVu3LhRq1mzZkAfJ2Zl4MCB2tmzZw15rcePH9c6duxoaPtUug7ceI3017VAlTGFprnfl+ixyna/Mc7u8W5sr7eJjIzUXU9KSorXdVu5r85NmTJltK+++srrtl25ckV79NFH7eresmWL7nOtMKZRbexg1fOU48o+VhoDqdaHutLWYcOGaSkpKV5v1507dxr271wqttuZ/JaJiopy+hruvvtuU86nJUuW6K6vf//+pqwvv1jhmhEVFaVdvnxZt67mzZsb/pqLFSum+3rPnDmjhYWFWX57GXn8m1FHIG2v+Ph47fTp01632Z99nNXq8ff9aLD2+c4YUY9qY3mrvM+lx5f/tmL1+3krXz9ErHVvpOo+Fgnee2tCrB4mbyeEeBJv+LvthBDrhu+VEEIIIYQQQgghhBBCCCGEEEIIIYQQvXQZLdqYVf+ky2j/t8nVhIeHa6+88orXn/Vfv369VqNGDZfWaRZX5z4sU6aMdubMGd06srOztVatWrm1DcPCwtyaE2vnzp1atWrVfLqfp02b5vV2uzGvvPKK0zrXrl2r5GsihFg3zNVurfCZWkKsEeZqNy/M1a6fQJqr/amnnjLkdbjiu+++c6ttKs9javZc375Iq1atdNs6d+5c3efXrFlTy8nJcXh+enq6VqJECdPa6c8+0si4clxZbT65G2OFc3bgwIG69Z05c8aQcfrPP/+sW/+rr77qdd3OxjOzZs1yuQ6rzmWih3l87BMMc7yYeX5a/dwUsUYfaaXz0xlvX0+FChW0nTt3Oq1/165dWsWKFT3eNka00crHQ26sPr/Y9VGp/7T6nGjexBnV67kxRvYxN0aF8YqRUencVWU/Wem9Kme8fY0q/D6XHtXmg7VSrDanqDNG1HP9cRIaGqpNnTrVq9d66dIlrUePHk7bEBISok2ZMkX3vTxXZWZmasOGDfNqH/vidyyM/B0gZzxtmxXG3f6eh9zsbXx9rHwfpofrh5rnVKDuX1XH74QQQoIjzNVOCPEk3vB32wkh1g3fKyGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgjxfZir3VrhM7WEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghvg1ztRNCPIkrQgQAAAAAAAAAAAAAAAAAAAAAAAAIAJ06ddIt37Fjh5w/f97HrQksNpvN302wnKFDh8r69eulQYMGhtRXokQJmTNnjnz11VcSERFhSJ1WULRoUfnuu+/kjTfekMKFCxtWb5s2beSXX36RVq1aeV2X0ftSxHr7MxheY67du3cbUk+rVq1ky5Yt0rJlS0Pqu15ISIh88MEHsnr1aqlWrZohdYaGhsq///1v2blzp9SvX9+QOvVMnDhR5s+fL1FRUV7Xddddd8nWrVulevXq3jfs/2vQoIHs2LFDBg0aZEh9/fr1k02bNkmFChUMqc8sVj3HVbgGGK1y5cry008/yQsvvCCFChUypM527drJzp07pUePHl7VY9XjxAxFihSRL7/8Uj777DMpU6aMIXVWqlRJ1qxZI2PGjPG6LpWvAyLWvxYYxagxhVGCZbv7gpX76lxxcXHy+++/S9++fb2uKyoqSj744AOZPn26hIRYe4oR1ccOVj9Pg/W4CqYxkD+88847Mnv2bImOjva6rsaNG8u2bdtk2LBh3jesAKq2+0apqany+eef6z5mRnuKFy8ud955p0N5UlKSLFu2zPD15ccq14zU1FRZsGCB7mPDhw83rF257rnnHt3XO2fOHMnOzna6nFW2lypU317PPvusLF26VMqVK+d1Xf7s44KZ3v1oMPf5vmDlsbzV3+e6kZn/tmL1+3mrXz9UuDey+j4WCd57awAAAAAAAAAAAAAAAAAAAABA8MrKypJx48ZJzZo15dVXX5UDBw64teyyZcuka9euctttt8nhw4dNbKlxPvnkEylbtqzuYxMnTpQff/zRrfqys7Nl8ODB8uijj0pSUlK+z5s+fbq0atVKjhw54tY6rKhr165OH1u5cqUPWwIAABCcmKvdPMzV7oi52j23b98+l56n+jymZs5H4UsjR47ULZ8xY4Zu+aFDh2TdunUO5YULF5ahQ4ca2bSgZOX55Kx0ziYkJEhGRoZDedmyZaV169Zetal8+fLSrFkz3cd69uzpVd0i4nR+j4ULF7q0vApzmTgTzPP4iATPHC9mnp9WPjet1Ed6QqVxTZ06dWTLli3SuHFj3cc3btwo7dq1k5MnT/q4Zf9Q4Xiw+vxi11Op/xw6dKil50RDwczsY1QYrxhJpXP3elbeT8HwXlWg/D6XleeDtRoV5hQ1Q0hIiCxevFhGjx7tVT3FihWThIQEuffeex0eCw8Pl2+++Uaefvppr97/Dw8Pl9mzZ8u4ceO8aWrQUmncbRR//S6WCvdhBeH6UTCVzymr719Vx+8AAAAAAAAAAAAAAAAAAAAAAADBrkmTJpKSkiIpKSkyadIkfzcHAAAAAAAAAAAAAAAAAAAAAAAAAKAIfl0IAAAAAAAAAAAAAAAAAAAAAAAAASE2Nla3/IcffvBxSwJPsWLFdMvT09N93BJrGD58uMyePVtCQ0Nden56erqkpaWJpmkFPrdv376yevVqiYiI8LaZfleiRAlZt26ddOjQwaXn5+TkSGpqqmRnZ7v0/PLly8vy5culSpUqHrfRzH0pYo39GQyv8Xq7d+/2uo6aNWvKqlWrpHjx4t436AaFCxeWpUuXyqOPPmp43SIiderUkc2bN0vbtm0Nr3vs2LEyduxYQ+ts1KiRJCYmSkxMjNd13XzzzbJ+/XqpUaOGAS37R/369eXbb7+VqKgoQ+s1ilXPcRWuAUbLPf+aNGni0vOzs7NdHktFRUXJkiVL5J577vGobVY9TsxQsmRJWbdundx1112G1x0SEiKvv/66V32hytcBEetfC4xkxJjCKMG03c1m5b4612233SbffvutlC1b1qt6bjRixAj5+OOPDa3TSKqPHax+ngbrcRVMYyB/eOedd+SJJ54wtM7w8HCZNWuWPP7444bWez1V2+3M9OnTdcu7du0q5cuXN3Rdd999t4SHhzuUf/bZZ5KVlWXouvJjtWuGs31w33336W4vbwwfPly3fMaMGU6Xsdr2sjrVt9fjjz8u//d//yc2m82wOv3ZxwUrZ/ejwdjn+4KVx/JWf5/rRmb+24rV7+etfv1Q4d7I6vtYJHjvrQEAAAAAAAAAAAAAAAAAAAAAEBE5fvy4jB07VurWrStVq1aVHj16yJNPPimTJk2Sd955Rz766COZMmWKjB07VkaOHCmtWrWSmJgY6d27tyQmJrq1LpvNZkri4+NdWn+vXr2c1vHyyy97sPX+Nm3aNKlSpYoMGDBA3n33Xfnyyy9lyZIlMnPmTBk1apRUr15dHn74Yb/M7/jII494vd2uV6pUKWnevLnTx1evXu1Nc11i9GsCAABQDXO1m4e52u0xV7t39u3bV+BzVJ/H1Mz5KHypWLFiuvMWHDhwIN++debMmbrlI0eONKxtwcjK88lZ7Zy9cuWK0/di+vTp41Vbevbs6XS+q8aNG0vVqlW9qr9Xr14OZZcuXZJvv/22wGVVmMvEmWCex0ckuOZ4MfP8tOq5abU+0l0qjWuaN28umzZtkmrVquk+vnTpUunSpYskJyf7uGX/UOF4sPr8YtdTqf/MvY90BfNFW5OZfYwK4xUjqXTuXs/K+ykY3qsKlN/nsvJ8sFajwpyiZpk2bZr07t3bkLpsNpvMnTtXWrVqZVe+YMEC6datmyHrEBGZMGGCDB482LD6goFK424j+eN3sVS4DysI14+CqXxOWX3/qjp+BwAAAAAAAAAAAAAAAAAAAAAAgEhISIhER0dLdHS0hIeH+7s5AAAAAAAAAAAAAAAAAAAAAAAAAABFhPm7AQAAAAAAAAAAAAAAAAAAAAAAAIAR6tSpo1u+Y8cOH7cksMTExEjhwoV1H0tOTvZxa/yvZs2a8v7774vNZtN9/OTJk/LZZ5/J6tWr5ffff5ezZ89KTk5O3uMlS5aUunXrSrt27eSuu+6S1q1bO9Rx2223yXvvvScPP/ywaa/DF+bPny9NmzZ1+vjGjRvlyy+/lE2bNsn+/fslJSUl77GYmBipUaOGdOjQQYYMGSLNmzfXraN06dKyePFiadu2rVy9etWt9vliX4r4d39a5TUeP35ctm7d6rSdpUqV0u3Dk5KSZP/+/fm9RAe///67W8+/UWhoqHz11VdSvHhxr+pxZt68edKzZ0+nj+fk5MiWLVskISFBtm3bJqdPn5akpCSJjIyUcuXKSe3ataV79+7SrVs3p20sUaKEfPPNN9KmTRvZs2ePIe3u3LmzTJgwwaFc0zTZsGGDLFmyRH7++Wc5ceKEpKWlSdGiRaVMmTLStGlT6d69u3Tt2lVCQ0N1665Tp47MnTtX+vXr53H7ypcvL6tWrZLSpUs7fU5GRoZ89913kpCQIHv27JEzZ87IxYsXJSoqSsqVKyfVqlWTO++8U3r06CGlSpWyW/amm26SadOmycyZMz1uoxmsco7rsfo1wGglS5aUxMREqVKlitPn7Ny5U7744gtJTEyUP//8Uy5evCgiIuHh4VK6dGlp0aKF3HHHHTJo0CDd8zssLEzmzp0rf/31l/z4448ut83Kx4nRwsPDJSEhQeLi4pw+59q1a7Jp0yZZsWKF/Pzzz3LmzBm5cOGC2Gw2KVasmNSpU0fat28vAwcOlIoVK+rWMXHiRDl48KB88cUXbrdR1euAiDWuBSqNKYxihe0eKKzcV+eqVauWLFmyRKKjo50+JzMzU7777jtZsWKF7Ny5U86cOSOXLl2SiIgIKVWqlDRu3Fg6d+4svXv3lqJFi9ot++CDD1r2PRKVxw5WP0+D9bgKpjGQPwwZMkSeeOIJh/KsrCxZvXq1rFy5Un777Tc5ffq0pKWl5d131alTR7p16yZ33nmn07GMzWaTd955Rw4dOiTLly+n3QX4+eefZceOHXLzzTfblYeGhsqgQYPkzTffNGxdgwcP1i2fNWuWYetwhdWuGT///LP89ttv0qRJE7vyEiVKSK9eveTLL790/cXlo169erp90bp16+TgwYNOl7Pa9rI6lbdX+/bt5e2333YoV7mPsxIr3I8GY59vNiuP5VV4n+t6Zv7bigr381a+fqhwb6TCPg7We2sAAAAAAAAAAAAAAAAAAAAAAPQcO3ZMjh075u9mKCktLU0WLVokixYt8ndTTNWlSxcJCQnRfezkyZOWmdcFAAAgkDFXuzmYq91eoM7VfurUqXznGalcubJUrlzZofz48eNy/Phxt9b1888/F/gclecxNXuub1+6//77pUiRIg7lBc1XvXjxYvnggw8ctkG9evWkffv2smHDBiObGRSsPp+cFc/ZL774Qnr37u1Q3qdPH3nuuedcfm036tWrV76P9+jRQ6ZNm+ZR3U2bNtWdi2Tp0qUFzr2iwlwmzgT7PD7BOMeLWednfvx1bopYs490lUrjmk6dOuV7Ls2YMUNGjhxpNzb3BxWOByvPL3Y9lfrP/O4jrTAnGgpmZh+jwnjFSCqdu9ez8n4K1Peqrhcov89l5flgrUaFOUXN0q9fP3nooYccyg8dOiRz586V9evXy5EjRyQjI0NKliwpFSpUkI4dO0r//v2lbt26unWGh4fLJ598Ik2aNJHs7Gx5+umnpW/fvg7Pu3TpkixYsEBWrFghe/fulZSUFImOjpZy5cpJixYtpG/fvnLbbbc5bfuHH34omzZtksOHD3u+AYKIlcbdVpiH3Ewq3Iflh+uHa6x0TrnD6vtX1fE7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADwguYiESGEEN3ExsZqgwcP1gYPHqwNGjRIa9OmjWaz2fzeLkIIIYQQQgghhBBCCCGEEEIIIYQQQgghhJBAjs1m01q2bKkNGjQo77OcsbGxfm9XsIbP1BLi/4SEhGhZWVm634tp166d39tnRA4fPqz7+gYMGGDqeuPi4px+56hChQoFLj958mTdZRMSEny+DVeuXKnblvHjx7tcx7Jly3TruHbtmjZ27FgtIiLCrTbt2LHD6fbt0qWL3487T/PYY485fV3bt2/X4uLi3KqvX79+WnJystM6R4wY4XYbjd6Xt9xyi+X2pyqvsV+/frr1LVq0yLRto2fMmDHaE088oftYUlKSNnv2bO2uu+7S6tatqxUrVsztdY4bN87pttM0TVu5cqXWuHFjl+qKiorSxo0bp6WkpDit79ChQ1rRokUN2TZ//fWXQ9ny5cu1hg0bulRngwYNtLVr1+b7+u+++26P9qXNZtM2btzotN5r165p06dP18qUKeNSfeHh4dpzzz2nu23Hjh2ruw53+zSjYtVzXIVrgLNjXdM8+071mjVrnNZ39OhRrX///i7XVbRoUW3SpEnatWvXdOs7duyYFhUVpfxxYkY++eQTp+3StL+vK3Xr1nWprrCwMO3JJ5/U0tLSdOu6dOmSVrlyZbfap/J1YPz48Za+FuTGKmMKTXO/L1Fpuzu7xxszZoyh2zYyMlJ3PSkpKR7VZ+W+WuTvfie//jU7O1ubPn26VqlSJZfqi4mJ0caOHaulp6fb1ZOamqodO3ZMdx3+GtOoPHaw6nnKcWXdMZBqfaiet956S7t06ZJdWU5OjvbBBx9oFStWdKneqKgo7cUXX8z3XE1OTnZ7vKVyu51xZdlRo0bpLrtr1y7DjqnKlStrOTk5Duv47bffDD12C4pVrxmPPPKI7vLffPONYa/dWf8xcOBA5baXkce/kXWovr32799v93eg9HFWrufG/a3H6PvRYOrzzd7nvhrLe/rarfo+lx6z/23F6vfzVr9+WPXeSKV9HMz31oSoFJvNpsXFxfF5WkKIW/GGv9tOCLFu+F4JIYQQQgghhBBCCCGEEEIIIYQQQgjRS5fRoo1Z9U+6jPZ/mwgxM3PnznX6OcxPPvnE7+0jhARemKvdWuEztYT4P8zVbt56mavdPsE6V/v48eO93nauRuV5TM2ej8LX2bVrl8PruHr1qlauXLkCl/3ggw90t8Nnn31mSlv91UcaHT1Wn0/OqudsdHS0wzwXuerVq+fR/omIiNBSU1Pzfb0rVqzweP9PmDBBt84ePXoUuKzV5zJxdnwH+zw+wTrHi1nnZ378dW5atY+0wvnpbL2a5v7cBnfffbeWmZnptL4JEyZ4vP+NaqMqx4PV5xfLjWr9p959pJXmRDMqzqhej5l9jIj1xytGRrVzV5X9ZMbci86408c44+62V/H3ufRY/bcdrBYrzynqjLuvUc/LL7+snThxwq7s8uXL2ogRI7SQkJB86wsJCdEee+wxLSMjw2kbH3roIa1WrVoO17WcnBztrbfecmns2KVLF91jOdfixYvd3ha++B0LI38HyBl36lBl3H19/XrM+l0sI7ZxblS4D8vvdXP9cC0qnFMq7l+Vx++EEEKCL8zVTgjxJN7wd9sJIdYN3yshhBBCCCGEEEIIIYQQQgghhBBCCCFWS7NmzfI+//bGG2/4vT2EEEKIGWGudmuFz9QSQgghhBBCCCGEEEIIIYQQQgghhBBCCCGE+DbM1U4I8SQuzcnO5O2EEG/DF00IIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCfB8mb7dW+EwtIf5P5cqVnX4vpkaNGn5vnxE5fPiw7usbMGCAqeudOHGi7nrPnTvn0vKTJ0/WXT4hIcHn23DlypW6bRk/frxLy5cpU0a7evWqofshPDxcW7x4sW6dW7Zs8ftx50mKFi2qnT9/Xvc1zZs3TwsNDfWo3kaNGmmXLl3SrXf//v1uXXvN2JdW258qvcZ+/frp1rdo0SLTto+el19+WTt37pxdWUZGhvbaa69pxYoV82p9jRo10rKysnTXe/XqVe2hhx7yqN6aNWtqf/zxh269mqZpH330kSHbxoj2hoSEaLNmzXJa77Zt2zzaBiNGjHBaZ0pKinb77bd7VG+NGjW0P//806E+PXFxcaYdq85i1XNchWtAQce6u/UMHjzYaV0//PCDVqZMGY9ec7du3bTLly/r1jtlyhSljxOz4kxaWprWv39/j+ps0qSJdvbsWd16P/nkE7eOYZWvA0ePHjWkzWZdC3JjlTGFprnfl6i03Z3d440ZM8bQbRsZGam7npSUFLfrsnJfnZunn37aaRuTkpK0jh07etTG+vXra4cOHXJa9/X8MaZRfexg1fM02I8rK4+BVOtD9aSnp9v9fenSJY/vu2rVqpXvWMbTa7iK7XbGlWWLFSumpaWl6S7ftGlTQ46pMWPG6Nb/+OOPG3rs5hcrXzOKFi2qpaamOiyfnZ2tVahQwevXbrPZtOPHjzvUf+HCBS08PFy57WXk8W9UHYGwva4XSH2cleu5Pr66Hw2WPt8X+9xXY3lPXnfnzp2d1ufv97n0mPlvK1a/n7f69cPK90aq7GOR4L23JkS1MHk7IcSTeMPfbSeEWDd8r4QQQgghhBBCCCGEEEIIIYQQQgghhOily2jRxqz6J11G+79NhJiZ06dPO/0c5t133+339hFCAi/M1W6t8JlaQvwf5mo3b73M1f5Pgnmu9vHjx3u17VyN6vOYmjkfha/Tpk0b3de4dOlSl5Zv2rSp7vKZmZlaqVKlDG+vv/pIo6PHyvPJWf2cXbJkie7yns6D2L17d6dtypWRkaFFRkZ6VP+OHTsc6ktOTtYKFSqU73IqzGXi7PgO5nl8RIJ7jhdfn5/+ODet3kdeHz2+GNc4404djzzyiHbt2jXdeq5du6Y9+uijfm+jKseD1ecXuz4q9Z/O7iOtMieakXFG5XrM7mNUGK8YGZXOXVX2k1lzLxrRxzjjbltU/H0uPVb/bQcrxepzijrjbnv0HDt2zO7vw4cPa7Vr13ar3vj4eKfbb8+ePdpnn31mV5aWlqbdeeedbq2jWrVqunPHa9rf89NXrlzZrfp88TsWRv4OkDOuLq/SuDs3vv5dLG+38fXbxOr3YQW9bq4fBUeVc0rF/avq+J0QQkhwhrnaCSGexBv+bjshxLrheyWEEEIIIYQQQgghhBBCCCGEEEIIIcRqadasWd7n39544w2/t4cQQggxI8zVbq3wmVpCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQ34a52gkhnsSlOdmZvJ0Q4m34ogkhhBBCCCGEEEIIIYQQQgghhBBCCCGEEEKI78Pk7dYKn6klxP+56aabnH4vJjIy0u/tMyKHDx/WfX0DBgwwbZ2FCxfW/vrrL931fvnlly7VMXnyZN3lExISfL4NV65cqduW8ePHu7T8Aw88oLv8ggULvGpXWFiYtnnzZrs6ExMTtS5duvj9uPMkpUqV0qZOnaqlp6fbvaZvvvnG67oHDRqkuw80TdO6d+/ucj1m7Usr7U+VXmO/fv1027po0SLTto+effv22f197tw57ZZbbjFkfT/88IPuOrOysrw+NmJiYrQtW7bo1p+Tk6PFxcV5vW1yXbt2TevXr59X7V2/fr3T+tu3b+9WXdHR0dq5c+d067p8+bLWokULr9paoUIF7eDBg/luE03T3N7GRsSq57gK14CCjnV36ihcuLB28uRJ3Xp+++03rXDhwl695j59+ujWnZmZqZUrV07Z48SMhISE6L7W1NRUr8/R2NhYLTU11aHuXbt2aeHh4S7VESjXAU2z3rXg+lhlTKFp7s/PoNJ2d3aPN2bMGEO3bWRkpO56UlJS3KrH6n21iGjFixfXLl++rFvPhQsXtDp16njVxgoVKmjHjh1zuv9z+WNMEwhjh1xWOk+D/biy8hhItT60IKmpqVqzZs28amtMTIy2fft2p+to27at23Wq2G5nXF3+008/1V3+vffeM+SY2rlzp0PdWVlZWqlSpQw9dvOL1a8Zc+bM0V3+2Wef9bp9Xbp00a37nXfeUXZ7GXn8G1FHIGyvXIHYx1m1nuvjy/vRYOjzfbXPc5k5lnd3HB8SEqLt379fty4rvM+lx6x/W1Hhft7q1w8r3xupso+D+d6aENXC5O2EEE/iDX+3nRBi3fC9EkIIIYQQQgghhBBCCCGEEEIIIYQQopcuo0Ubs+qfdBnt/zYRYlZuvvlmp5/BzM7O1kqUKOH3NhJCAi/M1W6t8JlaQvwf5mo3Z53M1W6fYJ6rffz48V5tO1ej+jymZs717evMnTtX9zX27NnT5Tp++eUX3Tqefvppw9vrjz7SjBTEanMtWf2cve+++3SX37x5s0dtmjZtWoH7SNM0rVevXm7XXb16dd265s2bl+9yKsxlkt/xHczz+AT7HC/+OD99eW6KWL+PvD56fDGuccbV5V9++WWndWRkZGh33XWX39uo0vFg9fnFcqNa/6l3H2mVOdGMjjOq1mN2H6PCeMXIqHbuqrKfrPxelTPutEPV3+cqiNV+28Fqsfqcos6425aCnD9/XqtevbpHr/O1114rsH5N+/tY7Natm0fr6NSpk9N6J06c6FZdvvgdC6N+w8KIY0CVcff18fXvYnm7jXOjwn2YK687F9cP/ahyTqm2f1UdvxNCCAneMFc7IcSTeMPfbSeEWDd8r4QQQgghhBBCCCGEEEIIIYQQQgghhPg7TZs21SZNmqQlJCRou3fv1lJTU/M+/5aenq7t3btX++abb7SxY8d6PJdVWFiY9tBDDxmW+++/36N2NGjQQBs7dqy2bNky7eDBg9qFCxe07OxsLTs7W7tw4YJ28OBBbdmyZdrYsWO1Bg0aGLqda9asqT3//PPaihUrtEOHDmmpqalaTk6OlpWVpSUlJWm//vqrNnfuXO3ee+/VoqKi/H5cEEJIoIe52q0VPlNLCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQ4tswVzshxJO4NCc7k7cTQrwNXzQhhBBCCCGEEEIIIYQQQgghhBBCCCGEEEII8X2YvN1a4TO1hPg/LVq00P1OTE5Ojt/bZlQOHz6s+xoHDBhg2jpfeeUVp9836t+/v0t1TJ48WXf5hIQEn2/DlStX6rZl/PjxLi0/adIk3eXvvPNOr9tWr149LS0tTfv0008D5ppevnx5bcqUKdqVK1e0ixcvaqVKlTKk3p07d+ruhzfffNPlOszcl1bZnyq9xn79+um2ddGiRaZtn4JcvHhRq127tiHruvXWW52u54knnjBkHRUrVtTOnDmju44lS5YYtm1efPFFr9tao0YNLSsrS7d+d85jEdFGjRrltK3Dhg0zZNu2bt1ay87Ozne7xMXFmXasOovVz3ErXwNy44w7dTzwwAO6dSQnJ2s1atQw5DXPmDFDdx0TJkxQ/jgxMv3799d9rUOHDjWk/ocffjivzh9//FHr06ePy/f9gXQd0DTrXQuuj5XGFEbVY8Xt7uweb8yYMYZu28jISN31pKSkuFWP1ftqEdGeeuop3eVzcnIM67Pj4uIsOabJjcpjh1xWOk+D/biy8hhItT60IEaNtapXr64lJSXprsOT67iK7XbG1eXbtWunu/z58+e1sLAwr15no0aNdOtevHixocetq7HqNeOWW27RXX7Pnj1et+2zzz7TrbtBgwbKbq/r44yv61B9e+UKxD7OqvVcH1/ejwZTn2/2Ps9l5lje3fPc2XtcmmaN97kKYuS/rahwP58bq14/rHxvpMo+DuZ7a0JUC5O3E0I8iTf83XZCiHXD90oIIYQQQgghhBBCCCGEEEIIIYQQQoheuowWbcyqf9JltP/bRIhZee6555x+BnPz5s1+bx8hJDDDXO3WCp+pJcT/Ya52c9bJXO32Cea52sePH+/VtnMlgTaPqZHzUfg6xYsX19LS0hxe08mTJ7XQ0FCX63n00Ud1t82BAwcMb7M/+kgzUhArzbWkwjkbHR2tZWRkOCybk5OjlS1b1u32HDt2zK6eq1evahs3bnSof8aMGW7X/cQTT+i+zvj4+HyXU2EuE1eP72CbxyfY53gx8/y0wrmpQh95fQpi1rjGmYKWs9ls2rRp05wun5ycrHXo0MGvbVT5eLDq/GK5Ua3/1LuPtMqcaEbHGdXq8VUfo8J4xciodu6qsp+s/F6VM+7UoervcxXEar/tYLVYfU5RZ4yqJ1ePHj08fo3R0dHahQsXClzHq6++6tW2dPZ++7Zt29yqxxe/Y2HUb1gYeQxYfdx9fXz9u1hGbGPV7sPye925uH7kH6ufU6rtX1XH74QQQoI3zNVOCPEk3vB32wkh1g3fKyGEEEIIIYQQQgghhBBCCCGEEEIIIf5IWFiYNnr0aO3gwYNufyZux44dWt++fd1aX5kyZbz6HN6NTp065db64+LitB9++MHt9WzcuNHr76vUrl1bW7JkiVvrvXDhgvbMM89oISEhfj9WCCEkUMNc7dYKn6klhBBCCCGEEEIIIYQQQgghhBBCCCGEEEII8W2Yq50Q4klcESIAAAAAAAAAAAAAAAAAAAAAAACA4qKionTLMzMzfdySwDF06FB54YUXdB87ceKELFu2zMct8r+KFSvqlv/5559e171v3z4pV66cDBkyRHbu3Ol1fVZw+vRpeeaZZ6RatWrSq1cvuXDhgiH1fvzxx7rlt956q8t1mLkvRayxP4PhNZrpgQcekIMHDxpS1zPPPKNbvnbtWnn33XcNWcfJkydlxIgRuo/16tVL6tSp4/U6duzYIZMnT/a6nsOHD8uSJUt0H2vXrp1bdY0aNUq3fOXKlTJnzhw3W6Zv69atMnXqVEPqMpLVz3ErXwOMNHr0aN3y9957Tw4fPmzIOiZPniw5OTkO5UOGDClwWasfJ0Z64oknHMqWLVsmc+fONaT+6dOny7Rp06RDhw7SqlUrWbJkiWia5tKygXIdELHmtSAYsN29Y/W+WkTkkUce0S2fM2eOrFy50qu25frpp5+cXketQPWxgxXP02A+roJpDORPGzduNGys9ddff8mYMWN0H+vTp4+UL1/ekPWIqNvugvzwww+yd+9eh/JSpUpJjx49vKp78ODBuuWzZs3yql5PWfWasXnzZvnjjz8cyuvXry9xcXEet6to0aLSp08fh/ItW7boru9GVt1eVqX69grUPg72gqnP9wWzx/LujuP13uMSsc77XAUx8t9WVLifz2XV64fV741U2MfBfG8NAAAAAAAAAAAAAAAAAAAAAADgicOHD8tLL72km//+97/+bh4AAEBQYK524zFXuyPmajdXIM1jKmLsfBS+NmTIEClSpIhD+dy5c+XatWsu1zN//nzJyMhwKK9du7Z07NjRqzYGI6vNtaTCOXvlyhVZvXq1Q7nNZpP4+Hi32tKkSROpXLmyXdn69et194kncyLpzbuWkpIiiYmJ+S6nwlwmrgq2eXyCfY4XM89PK5ybKvSR7rDSuCY8PFwWLlwoI0eO1H389OnT0r59e1m3bp1vG5YP1Y4Hq84vlku1/lPvPtIqc6LBkS/7GBXGK0ZS7dzNZfX9FOjvVQXi73NZ8bcdrMbqc4r6wtKlS+Wbb77xePkrV67I4sWL833OiRMn5JVXXvF4HSLO526++eabJSIiwqu6g4HVx92qU+0+rCBcPwqm8jllxf2r6vgdAAAAAAAAAAAAAAAAAAAAAAAg2NSuXVu2bdsmU6dOlVq1arm9fGxsrHz11VeyfPlyKVGihEvLREdHu70eo7z88suyZcsWadu2rdvLtmvXTrZs2SIvv/yyR+seOHCg7NixQ3r37u3WciVLlpQ33nhDvv32W6dzZgIAAAAAAAAAAAAAAAAAAAAAAACA1YT4uwEAAAAAAAAAAAAAAAAAAAAAAACAtyIiInTLs7OzDVtHrVq1pHv37oYkMjLSsHYZrXDhwjJx4kSZPXu2hITof/3o5ZdflqysLB+3zP+cHWeaphlSf0pKiiH1WM2FCxdk48aNhtX33Xff6ZY3bdpUQkNDXarD7H0p4v/9GQyv0Sxff/21fP3114bUFRMTI3feeafuY5MnTzZkHbmWLVsmu3fvdii32WzSv39/r+sfN26cXLt2zet6RERmz56tW96sWTOXr5F169aVm266SfexSZMmedw2PW+++aZhr90oqpzjVrwGGKVq1arStGlTh/K0tDR5++23DVvPoUOHZO3atQ7l1apVc3oO5FLlOPFW2bJldX/89PXXXzdsHZqmyaOPPirr1693a7lAug6IWO9aECzY7p5Toa+uW7eu1K5dW/exN99805D25Zo4caKh75OYQdWxg9XO02A/roJlDORvr7zyiqH1zZs3T86dO+dQHhYWJt26dTNsPaq22xUzZszQLR82bJhX9Q4cONCh7PTp07Jq1Sqv6vWWFa8ZzvbB8OHDPW7XgAEDpEiRIg7l06dPd6seK24vK1N1ewVyHwd7wdbnm8nssbw743hn73GJWON9roIY+W8rKtzP67Ha9cPK90Yq7ONgv7cGAAAAAAAAAAAAAAAAAAAAAADwxMKFC2XChAm6Wb16tb+bBwAAEBSYq904zNXuHHO1myfQ5jE1cj4Kf3j44Yd1yz/55BO36klOTpavvvpK97GRI0e63a5gZ6W5llQ6ZxcuXKhb3qdPH7fa0bNnT922LV++3OE6UKFCBWnWrJnLdZcoUUJuvfVWh/KEhATJzMx0upwKc5m4Ktjm8WGOl7+ZdX76+9xUqY90hZXGNdHR0bJy5Uqnr+3gwYNyyy23yI4dO3zcMudUPh6sNr+YiJr9p959pBXmRIMjX/YxKoxXjKTiuSuixn4K5PeqAvX3uaz22w5WZOU5RX3FiPeAFi9enO/j77zzjqSnp3u1juXLl+v+O0GhQoV0+0/os+K4W3Uq34c5w/XDdSqeU1bbv6qO3wEAAAAAAAAAAAAAAAAAAAAAAIJNgwYNZMuWLdKkSRO7ck3TZNeuXTJv3jz59NNP88p37Ngh3377rSQnJzvU1aNHD9myZYuULVu2wPVGRUV53XZPTJ48WV566SWH+RGTk5Nl9erVMnXqVJk0aZJMmjRJpk6dKqtXr3Z4rSEhIfLSSy/Jq6++6ta6hw0bJvPnz3f4jk5qaqosX75cPvzwQ3nllVdk8uTJMnPmTPnpp58kJyfH7rkdOnSQhIQEsdlsbq0bAAAAAAAAAAAAAAAAAAAAAAAAAPwhpOCnAAAAAAAAAAAAAAAAAAAAAAAAAHj88cflm2++MSSVK1f298txUKZMGXnsscdk7969MnbsWKc/wvTdd9/JzJkzfdw6a7h06ZJueY0aNXzbkCC3d+9euXLlikN5WFiYlChRwqU6gmFfBsNrNMs777xjWF133HGHFCpUyKH8999/l++++86w9eRy1vb4+Hiv6j1y5IgkJCR4Vcf1Nm3aJJqmOZSHhYVJtWrVXKqjW7duuuU7duyQTZs2edW+Gx0/fly++eYbQ+v0VrCe40ZcA4zSpUsX3fK1a9dKUlKSoetat26dbnmHDh3yXS5YjpNu3bo5jF1//fVX2bx5s59a9I9AuQ6IWPNaEAzY7t5Roa++4447dMs3bNggu3fv9rJV9k6dOiXLly83tE6r88XYwYrnabAfV8EyBvKnI0eOyJo1awytMzMzUz755BPdx5zd/7lL1Xa7au7cuZKVleVQ3qNHDyldurRHdd56661StWpVh/J58+bJtWvXPKrTqoy4Znz66aeSmZnpUD5w4ECJiIjwqF3Dhw93KLt8+bIsXLjQo/qMYqX7cxX4akwSyH0c7NHnG8MXY3l33/PW+/dZq7zPVRAj/21Fhft5X/D2+mHleyMV9nGw31sDAAAAAAAAAAAAAAAAAAAAAAAAAAAAzjBX+9+Yq92RFb7PrrpAmsc0v/pV0LZtW2nQoIFD+fr16+XgwYNu1zdjxgzd8j59+kjZsmXdri9YWW2uJZXO2WXLlunOk9a5c2eJjIx0uQ29evVyKEtISJDTp0/Lzz//7PBYz549Xa67Z8+eEhoa6lC+aNGifJdTYS4TVwXbPD7M8fI3s85Pf5+bKvWR3tTva2XKlJH169dLx44ddR/fvn273HLLLXL48GEftyx/gXY8eMOI+SlV7D/17iO5h7QeX/cxKoxXjKTiuSuixn4K5PeqAvH3uaz42w5WFMjHtSt27Ngh27dv97qe/OrIycmRuXPner2O9PR02bt3r+5jwbK/rIh59APvPozrh3+ZfU5Zcf+qOn4HAAAAAAAAAAAAAAAAAAAAAAAIJkWKFJGEhAQpXbp0Xll2dra8/fbbUr16dYmNjZUhQ4bIu+++m/f4mjVrpHPnzlK8eHHp3LmzbNy40a7OevXqyYoVKyQsLCzfdUdHR9v9PWbMGGnevLnH6dq1a4Gv9/bbb5fnn3/eruzcuXMyfPhwKVeunHTr1k0ef/xxefHFF+XFF1+Uxx9/XLp16yblypWT4cOHy7lz5+yW/c9//iO33357gesVEWnUqJFMnz7dbm7GpKQk+de//iWlS5eW+Ph4GTVqlIwfP15eeOEFGTFihLRq1UqqVasm8+fPd3gdTz31lEvrBQAAAAAAAAAAAAAAAAAAAAAAAAB/CvF3AwAAAAAAAAAAAAAAAAAAAAAAAAAV1KlTx99N0FWrVi1p1qyZy2nRooXcfvvt0rt3bxkxYoS8//778sMPP8jJkyflvffek2rVqjld159//in33HOPD1+dtZw6dUq3fODAgT5uSXDTNM3pvihZsqRLdQTDvgyG12iGvXv3yoYNGwyrz9kP6a1atcqwdbhSb6tWrSQiIsLjepcvX+7xsnouX74sf/75p+5jJUqUcKmONm3a6JYb3Vaz6/VUsJ7jRlwDjNKuXTvd8tWrVxu+rq1bt+qWN2zYMN/lguU4ufXWWx3KzNgPngiU64CINa8FwYDt7h0V+upWrVrpln///fdet0nPihUrTKnXqnwxdrDieRrsx1WwjIH8KTEx0ZR6v/vuO93yli1bGlK/qu121YULF2TJkiUO5YUKFfL4+B88eLBu+ezZsz2qz8qMuGYkJSXJ119/7VBerFgx6dOnj9ttql27ttxyyy0O5Z999pmkpaW5XZ+RrHR/rgJfbK9A7+Ngjz7fGL4ay7s6jtd7j0vEOu9z5cfof1tR4X7eF7y9flj53kiFfRzs99YAAAAAAAAAAAAAAAAAAAAAAAAAAACAM8zVzlztVv4+u+oCaR5To+ej8LWRI0fqls+cOdOj+tatWyeHDh1yKC9UqJAMHz7cozqDkdXmWlLpnE1JSdHdfoULF5auXbu6tP5y5cpJixYt7Mp+//13OXz4sIiILF261GGZ+Ph4l+oWEd352lJTUwvcnirMZeKKYJzHhzle/mbG+WmFc1OlPrIgVhnXVKtWTTZt2iTNmjXTfXzNmjVy2223yblz53zcsoIF0vHgLSPmp1Sx/9R7zdxDWos/+hgVxitGUvHcFVFjPwXye1WB+PtcVvxtBysK5OPaFUb1MefPn3d67frtt98Mu67t3r1bt7x48eKG1A/3MY9+4N2Hcf3wL7PPKSvuX1XH7wAAAAAAAAAAAAAAAAAAAAAAAMHk6aeflpo1a+b9nZKSIh07dpSnnnpKjh49WuDy3377rbRv315GjRolmqbllTdv3lzGjx+f77LR0dF2f+/evVt++eUXj7Nz584C2ztlyhS7vw8dOiRNmzaVOXPmSGZmptPlMjMzZc6cOdK0aVOHudDeeOONAtcrIjJ9+nQpVKhQ3t/79u2TBg0ayKxZsyQjI8PpcsePH5fBgwfL//3f/9mVv/DCCxIVFeXSugEAAAAAAAAAAAAAAAAAAAAAAADAX0L83QAAAAAAAAAAAAAAAAAAAAAAAADALDabzbC6ateubVhdRnr11Vdl+/btLmfbtm3y3XffyZIlS2T69OkyatQoadu2rYSFheW7nr1798rtt98u58+f99Ers54ffvhBt3zIkCFy9913+7g1wS05OVm3vGTJki4tHwz7MhheoxnWrVtnaH0NGjTQLXe2f7x1/PhxOXbsmEN5SEiI1KtXz+N6N2zY4E2zdOm1U8T187h+/fq65Zs2bfK4Tfn58ccfTanXU8F8jnt7DTCKs2Nwy5Ythq/r1KlTuuV169bNd7lgOU5uuukmh7LNmzf7oSWOAuU6IGLNa0EwYLt7R4W+2tm5aUYbRUQ2btxoSr1WZvbYwYrnabAfV8EyBvIns/b5Tz/9JJqmOZRXr15dwsPDva5f1Xa7Y/r06brlw4YNc7uuQoUKSf/+/R3Kf/zxR9mzZ4/b9anAiGvGxx9/rFs+fPhwt9vjbL8528++ZpX7c1WYvb2CoY+DPfp87/lqLO/qea73HpeIdd7nyo/R/7aiwv28r3hz/bDyvZEK+zjY760BAAAAAAAAAAAAAAAAAAAAAAAAAAAQWJirnbnajWTl77OrLpDmMTV6PgpfKlGihO58LMnJyfLll196XO8nn3yiW/7www97XKeRbr31Vtm1a5fhady4sWFttNpcS6qdswsXLtQt79Onj0vr79Gjh8OYIiEhQff/czVv3lzKly9fYN0RERHStWtXh/Lly5dLRkZGvsuqMJeJK4JxHh/mePmH0eenFc5N1frI/FhhXNO4cWPZsmWL1KlTR/fxzz//XHr06CGpqak+bplrAul4MIK381Oq2H/q7WvuIa3DX32MCuMVI6l47oqosZ8C+b2qQPx9Liv+toMVBfJx7Qoj5+M9ffq0brmRx7uzdRQvXtywdcB9wT6PfqDdh3H98D8zzykr7l9Vx+8AAAAAAAAAAAAAAAAAAAAAAADBZMSIEXZ/P/bYYx59T+PDDz+URx991K7sqaeekjJlyjhdJioqyu7v9PR0t9frjlq1akmzZs3sygYNGiQnTpxwuY4TJ07IoEGD7MqaN28uNWvWzHe5gQMHSps2bfL+TkpKkjvuuEPOnDnj8rr/85//yG+//SYXL16UDz/8ULp162bZeVIAAAAAAAAAAAAAAAAAAAAAAAAAIFeIvxsAAAAAAAAAAAAAAAAAAAAAAAAAeCszM1O3PCwszJD6Q0NDpXr16obUpaJPPvlEWrduLceOHfN3U/zqhx9+kAsXLjiUh4SEyBdffCFz586Vm2++2Q8tCw7ly5eXtm3byv333y8lS5bUfU54eLhLdQXDvgyG12iGH3/80dD6brrpJt3yX375xdD1XG/79u1utcUVe/bs8XhZZ5KTk3XLixcv7tLytWvX1i3/9ddfPW1Svn7//XfJysoypW5PBNs5buQ1wCh169bVLT9y5Ijh67p48aJueYkSJfJdLliOk3r16jmUmdUXuCtQrgMi1rwWBAO2u3dU6Kvr1KmjW75z506v26Tnzz//lJycHFPqthJfjh2seJ4G+3EVLGMgfzpw4IAp9SYnJ+v20SEhIQX+SL0rVG23O7799ls5dOiQQ3mzZs2kUaNGbtV155136vahs2bN8rh9VmT0NWPdunVy8OBBh/IuXbpIpUqVXK7HZrPJkCFDHMp/+eUXv97vWPH+3Mp8ub2CoY+DPfp87/lqLO/qOF7vPS4R67zPlR+j/21Fhft5Mxl1/bDyvZEK+zjY760BAAAAAAAAAAAAAAAAAAAAAAAAAACgJuZqNxdztf/Nyt9nV10gzWNq9HwUvjR06FApXLiwQ/nnn38uGRkZHtc7Z84cuXbtmkN5jRo15I477vC4XqPExMRIo0aNDE+RIkUMa6PV5lpS7ZxdunSp7lihZ8+eEhISUuDyvXr10q0z186dO+Xo0aN2j9tsNunRo0eBdXfu3FmioqIcyhctWlTgsirMZeKKYJzHhzle/mH0+WmFc1O1PjI//h7XtGvXTjZs2CAVKlTQffzKlSsyatQouXr1qo9b5rpAOh48ZeT8lCr2n3r3kdxDWoM/+xgVxitGUvHcFVFjPwXye1WB+PtcVvxtBysK5OPaFUa+B5SSkqJbvn//ftPXofIxqCrm0f9HoN2Hcf3wD1+dU1bcv6qO3wEAAAAAAAAAAAAAAAAAAAAAAIJFlSpVpGrVqnl/nzt3TubNm+dxfR999JFs3bpVRES2bdsmDz74oCQlJTl9fnR0tN3f6enpHq/bFa1bt7b7++eff85rrzu2bt3q8F2wG+u+0YgRI+z+njBhgsN8NgXJycmRnj17Svny5WXUqFGybds2t5YHAAAAAAAAAAAAAAAAAAAAAAAAAH8I83cDAAAAAAAAAAAAAAAAAAAAAAAAAG9lZGTolkdERBhSf5UqVSQzM1MyMzPdWi4qKkpsNpshbfCHgwcPysMPPyzfffedv5tiCVevXpXJkyfLlClTHB6z2WwyZMgQGTJkiBw/fly2bdsmu3fvloMHD+blzJkzfmi1OiIiIqR69epSq1YtqVmzptSuXVtq1qyZlyJFihi2rmDYl8HwGs2wY8cOQ+srU6aMbvm5c+cMXc/1zp8/r1teunRpj+s8ceKEx8s6c/nyZd3ykJCQApcNCQlx+LHFXM5ev7dycnIkKSlJypcvb0r97gq0c9yX1wCjlChRwqEsPT093x8J9dSVK1d0y2NiYvJdLtCOE2dKlizpUGZmP+uOQLkOiFjvWhAs2O7eUaGvLlasmG75hQsXvG6TnqtXr8rJkyelcuXKptTvK1YaO1jxPA324ypYxkD+dOTIEdPqTkpKkurVqzuU6/Xp7lK13e6aOXOmvPrqqw7lw4YNk2eeecblegYPHuxQlp6eLgsWLPCqfb7mj2vGjBkz5PXXX7crCwkJkfvvv19ee+01l+ro2LGjVKlSxaF8+vTphrTRGStdY1Vgpe0VLH0c7NHne8dXY3lXx/F673GJWOd9rvwY/W8rKtzPe8NX1w8r3xupsI+D/d4aAAAAAAAAAAAAAAAAAAAAAAAAAAAAamKudnMwV7s9K3+fXXWBNI+p0fNR+NLDDz+sWz5z5kyv6j158qSsXr1aunfv7vDYyJEjJTEx0av6g4HV5lpS7ZxNSUmRxMREiY+PtysvWbKktGvXTjZs2OB02fDwcOncubNd2dmzZ+Wnn36yK1u2bJmMHj3ariw+Pl4++eSTfNvWp08fh7K0tDRZsWJFvsuJqDGXiSuCcR4f5nj5h5Hnp1XOTdX6yPz4c1wTHx8vCxculMKFCzt9TnR0tHz88ccyYMAAH7bMPYF0PDjjy/kpVew/nd1Hcg/pX/7uY1QYrxhJxXNXRI39FKjvVQXq73NZ8bcdrChQj2tXnTx50rC6nPUtp0+fNmwdKSkpuuUqH4NWZaV54a0u0O7DuH6YwyrnlBX3r6rjdwAAAAAAAAAAAAAAAAAAAAAAgGBRqVIlu79///13ycnJ8arOhx9+WKKjo2Xz5s0FPvfG7wGnp6d7te6CVKhQwe7vX3/91eO6fv31V2nevLnTuq9XpUoV6dChQ97f586dkw8//NCj9ZrxPSIAAAAAAAAAAAAAAAAAAAAAAAAAMFOYvxsAAAAAAAAAAAAAAAAAAAAAAAAAeCstLc3pY1FRUZKamupV/X/99ZfExMS4vdyePXukfv36Xq3b165evSrLli2T6dOny5o1a0TTNH83yVKmTp0qffv2lbZt2zp9TuXKlaVy5crSt29fu/LU1FT5888/5eDBg3Lw4EE5cOCAzJs3TzIzM81utqVUrFhRmjdvLrGxsVK7dm2pWbOm1KpVSypWrCg2m81n7TB6X+7YsUN27txpqf0ZDK/RaBcuXDCsriJFikhoaKhDeWZmpmRkZBi2nhtdvHhRt9yT61iulJQUj5d1xpsfZnT2Wq5cuSLZ2dke11uQS5cuSfny5U2r310qnuNWuQZ4KzIyUre9RYoUMeWHP51tm4iIiAKXVfE4cUdkZKSEhITYlWVmZlqifYF0HRCx3rUgWLDdPadCX+2sjZmZmZKVlWVY225kxnFlFhXGDlY7Tzmu/hboYyB/u3z5sml1X7p0Sbc8Ojra67pVbbe7Zs+eLRMmTJCwMPuppQYNGiRjxoxxqY+JiYmR+Ph4h/Kvv/7a1O3oDStdM+bMmSMTJ06UQoUK2ZU/8MAD8tprr7lUx/Dhwx3K0tLS5LPPPjOkjVbaXipQYXsFSx8He8Ha5xvFSmN5vfe4RKzzPldBjPy3FRXu511lheuHFe+NVNjH3FsDAAAAAAAAAAAAAAAAAAAAAAAAAABAVczVbhzmas8fc7UbL9DmMTVyPgpfuvXWW3X7q507d8r27du9rn/GjBnSvXt3h/L4+HipUKGCnDp1yut1BDIrzbWk6jm7cOFC3TmH+vTpIxs2bHC6XMeOHSUqKsqubPny5Q7Xx2XLlsno0aPtyrp06SIRERFO+3mbzabbphUrVhQ4H4kKc5m4Ktjm8WGOF0dGnZ9WODdV7SOd8de4Zvjw4TJjxgzdbXmju+++Wx544AGZNWuWD1rmnkA7Hvw9v5jK/WdB95HMF+1b/u5jVBivGEnVc1el/WTG3Ivbtm1z7wUYLFB/n8tK88FanRXnFPUVb/8t43rOjg9frAOe8/e4W3WBdh8mwvXDW1Y/p6y2f1UdvwMAAAAAAAAAAAAAAAAAAAAAAASTQoUK2f1txHendu7c6fJzb5yPyYzvX18vMjLS7m9v5uNKTk62+/vG13K9nj172n3XZunSpXL16lWP1w0AAAAAAAAAAAAAAAAAAAAAAAAAKgnzdwMAAAAAAAAAAAAAAAAAAAAAAAAAb505c8bpY+XKlZNDhw75sDVq0DRNUlJS5OLFi7J7927Ztm2b/PTTT7J161ZJSkoydD16QkJCDFuHq5yt01kb9WRlZUnv3r1lzZo10rRpU7fWHxUVJbGxsRIbG5tXNm3aNFm/fr3Mnz9fFixYYPqPhflLw4YNZciQIXLPPfdItWrV/N0cETF+X4qIZGdnW2p/BsNrNNqNP4LnDWc/oOfNj/S54uLFi7rlRYsW9bhOq/24X0REhG55amqqqes1e9+5S5Vz3IrXAG/l9wOZhQsX9mFLCqbKceIpvX1hlXM1kK4DIta7FgQLtrvnVOir/dVPmD1m8pZqYwernaccV38L9DGQv6WlpZlWt7P78ujoaK/rVrXd7jp9+rSsWLFCevXqZVdevnx56dq1q6xcubLAOvr166d7vZw1a5Zh7TSCVa8ZZ8+elYSEBOnXr59deZ06daRNmzayZcuWfJePiYmRvn37OpR/8cUXkpKS4nG7rLq9rEq17RUsfRzsBVOfbwYrjeX9NY43ii/+bUXEOvfz+bHa9cOK90Yq7GPurQEAAAAAAAAAAAAAAAAAAAAAAAAAAKAq5mp3H3O1/4O52v0r0OYxNXI+Cl8aOXKkbvmMGTMMqX/58uVy9uxZKVu2rF15WFiYPPDAAzJp0iRD1hOorDTXkqrn7LJlyyQrK0vCw8Ptynv37i1PPfWU0+Xi4+MdypYuXepQtm7dOklJSZGYmJi8ssjISOnQoYOsXr1at+7WrVtLuXLlHMoXLlzotD25VJjLxFXBNo8Pc7w4Mur8tPK5afU+0hl/jWvcnQ9u6tSpsmnTJtm3b59JLfJMIBwPVppfTOX+09P7SOaLNoe/+xgVxitGUvXcVWk/mTH34rfffuvXPiZQf5/LSvPBWp0V5xT1FV8cJ1lZWaavA+6x0rhbdYFwH3Yjrh/uU+mcstr+VXX8DgAAAAAAAAAAAAAAAAAAAAAAEExu/D7TjfN6me3GuanM/s7mjd89KVGihMd1lSxZ0u7vlJQUp89t1qyZ3d8JCQkerxcAAAAAAAAAAAAAAAAAAAAAAAAAVBPi7wYAAAAAAAAAAAAAAAAAAAAAAAAA3jp37pxkZ2frPla5cmUft8a3Ro8eLdWqVXM5VatWleLFi0toaKgUK1ZMqlevLj169JCXX35ZVqxYIUlJSYa2LyMjQ7f8xh/J8oWYmBjdcmdtdObChQvSpk0b+fDDD+XatWtetSksLEw6deoks2bNkoMHD8rw4cO9qs9qqlWrJp999pns2rVLxowZI9WqVfN3k+wYuS9FrLk/g+E1Guny5cuG1RUSov8VTiP2Q36c1W+z2UxdrxVommZq/Tk5OabW7wkrn+NWvwZ4Q7XzycrHibf09oXZ/ayruA4A/qXCMe+sjWb3E87eP/G3QB47+BLH1T8CeQzkb2bee5k5llG13Z6YPn26bvmwYcNcWn7w4MEOZUePHpXvvvvOm2YZRoVrhrN94Erfcffdd0tkZKTLdRZEhe1lJapur2Dq42Av0Pv8YOGvcbxRjPy3FVX7FitfP6x2b6TCPubeGgAAAAAAAAAAAAAAAAAAAAAAAAAAAKpirnbmancFc7VbU6DNY2rkfBS+UrJkSbnrrrscyjMzM2X+/PmGrCM7O1s+/fRT3cceeughv87LkJycLD///LPhSU1NNayNVpprSdVz9vLly5KYmOhQXrNmTWnYsKHT5Xr27Gn3d0ZGhqxZs8bheVevXpVVq1Y5lMfHxzutu0+fPg5l6enpsmLFCqfL5FJhLhNXBds8Pszx4sio89MK56aqfaQzVhrXfPvtt9KrVy/d382IjIyUL774QsLDw/3QMudUPh6sOL+Y6v1n7n2kFeZEgyNf9jEqjFeMpOq5q9p+MnruRav2McH4+1zBzGpzigYSs88luM6K427VqXwfBu9xTnlP1fE7AAAAAAAAAAAAAAAAAAAAAABAMDlx4oTddwVvvvlmKVmypM/Wf+Mcgunp6aaub9++fXZ/t2rVyuO6blx2//79Tp/bpEkTu7937Njh8XoBAAAAAAAAAAAAAAAAAAAAAAAAQDVh/m4AAAAAAAAAAAAAAAAAAAAAAAAA4C1N0+T48eNSvXp1h8fq168vGzZs8H2jfOTcuXNy9OhRfzfDqYyMDN3yYsWK+bglztfprI35yczMlFGjRsm7774r//nPf6Rfv35StGhRr9pXsWJFmTVrlnTp0kWGDx8umZmZXtXnb507d5ZFixZJ8eLFPa4jKSlJDhw4IAcOHJB9+/bl/f8HH3wgrVu3NqSdZuxLEWvtz2B4jUa5/scDYV3O9lNISIip6y1UqJCp9XvKiue4KteAYGLF4wQAgFyMHWAWxkAIVitXrpTjx49L5cqV7cp79+4txYsXl0uXLjldtnz58tKxY0eH8rlz51rifRNVrhmJiYly5MgRqVatml35PffcI0888YSkp6c7XXb48OEOZbt375atW7e63Q5VtpdVsL2gokDu86GOYD9eVLh+cG8EAAAAAAAAAAAAAAAAAAAAAAAAAAAABAfmameudlcwVzt8QcX5KIYOHSoREREO5du2bZM6deoYtp5du3bplletWlW6desmK1euNGxd7ti0aZO0bNnSL+uGby1cuFB69uzpUN6nTx/ZvXu3Q3lsbKxUrVrVruzbb791Op/asmXL5O6777Yri4+Pl9GjR+s+v3fv3g5lK1eulNTUVKevIRCp2G/CeEacn5ybxrPK+fnFF1/I/fffL1evXpU33nhDnnvuOYfn3HzzzfJ///d/8uSTT/q+gQFGhfnFVJWZmSkNGjRgTjSLoY9BoAik96r4fS7kYk5RBDLG3YCxOKcAAAAAAAAAAAAAAAAAAAAAAAAQLC5evCi7d++WRo0aiYhIWFiYTJgwwelcKkaLjo62+9vZnC9GWbdunWRkZEjhwoVFRKRhw4bSrVs3WbVqlVv1dO3aVRo0aJD3d3p6uqxfv97p82+66aa8/09LS5MjR444PCcyMlKaNWsmtWvXlqJFi0pISIikpKTIkSNH5LfffpPz58+71UYAAAAAAAAAAAAAAAAAAAAAAAAAsIowfzcAAAAAAAAAAAAAAAAAAAAAAAAAMMKuXbukevXqDuU333yz7xuDPBcuXNAtL1asmI9bIlK8eHHdcm9+hGr//v0yfPhwefjhh6VDhw7SsmVLad68udSvX19q1qwpERERbtc5cOBAiYmJkfj4eI/b5W933nmnJCQkSGhoaIHPvXLliuzfv1/2798vBw4csPvvxYsXdZfJyMgwusmm7EsRa+3PYHiNVnLt2jXd8rAwc7/aWahQId1yZ+1RUVpamm550aJFTV2vs+uIVVjlHFfxGuAuTdN0yy9duiQLFizwWTucjbPyY5XjxCg5OTkOZWb3s67iOgB4x2azebW8Cn21s/PS2XlsFLPrd1cwjB18ieNKX6CNgQribR9akEKFCsnVq1dNqTs8PFy33IixjKrt9kROTo7Mnj1bxo0bZ1ceEREh99xzj3z88cdOl7333nslJCTErkzTNJk9e7YpbXWHStcMTdPkk08+kQkTJtiVFy1aVPr27SufffaZ7nI1a9aUdu3aOZRPnz7d7TaotL2sQPXtFUx9HOwFap8fbPTe4xKxzvtcvqTC/fz1VLt+WOHeSIV9zL01AAAAAAAAAAAAAAAAAAAAAADA34YMGaI7x6eIyJw5c+To0aO+bRAAAABcwlzt1sRc7cE5V7s7mMfU/x5++GHd8nbt2smPP/7okzY88sgjsnLlSp+sS0VWmmtJ5XN26dKlkpWV5fCa+/TpI5MmTXJ4fs+ePXXrcGbFihVy7do1uzlZqlatKg0bNpTdu3fbPbdevXpSr149hzoWLVpU4OsQUWMuE39QYbswx4s+I85PZ3x5bqrcR1rV+++/L48//nje+f3iiy9Kp06dpEWLFg7PfeKJJyQxMVFWrFjh62bqUvF4sPL8YoHSf1phTjT8wx99jArjFSOpeu6qvJ8C4b0qfp8LN+L6CW+Z/RsW7rLyuFt1Kt6HwXucU8ZRdfwOAAAAAAAAAAAAAAAAAAAAAAAQbObMmSNTpkzJ+3vUqFFy8eJFefnll03/XlN0dLTd3+np6Q6PlytXLu95V65ckRMnTnj8PZ0rV67I3Llz7eZK+/TTT+X22293mDvGmZtuukk+/fRTu7K5c+fKlStXdJ8fGhoqUVFReX+fOnXK7vHOnTvLk08+KV26dHE6h5emafLTTz/JtGnTZP78+ZKdne1SWwEAAAAAAAAAAAAAAAAAAAAAAADACsz95S8AAAAAAAAAAAAAAAAAAAAAAADAR3bu3Cnx8fEO5bfeeqsfWoNcJ06c0C0vV66chISESE5Ojk/aERYWJqVLl9Z9zFkb3ZGVlSWJiYmSmJiYV2az2aRy5cpSu3ZtqV27ttSpUyfv/2vXri1FihRxWl/Pnj3lhRdekFdffdXrtvla9erV5bPPPpPQ0FDdxy9cuCCLFy+WNWvWyLZt2+TIkSNur8Nms3nbTKeM3pci1tufwfAarcDZD+gVL17c1PWWLFlSt/zy5cumrteXUlNTRdM0h76gcOHCUrhwYY9/ULEgZu87o/jzHFf9GuAqZ8fYlStX5JFHHvFxazwTKNcCvX1RrFgxn60/P1wHAO8U1OcURIW+OjU1Vbfc7H7s+h9z9rdgGTv4EsdV/gJlDFQQb/vQghQrVkzOnz9vSt3OxkrOxlbuULXdnpo5c6aMHTtWQkJC7MqHDRsmH3/8sdPlBg8e7FC2YcMGOXz4sOFtdIeK14xZs2bJSy+95NDm4cOHy2effaa7zLBhwxzKMjMzZd68eW6tW8Xt5U+BsL2CrY+DvUDr84ORs3tYq7zP5Usq3M/nUvn64c97IxX2MffWAAAAAAAAAAAAAAAAAAAAAAAAfxs+fLh06NBB97F169bJ0aNHfdsgAAAAuIS52q2JudqDb652dzGPqX/ddtttUq9ePX83Q7p37y6VK1eW48eP+7splmSluZZUPmcvX74sa9askR49etiVN2/eXCpWrCgnT560K+/Vq5fd35qmyfLly53Wn5SUJJs2bZL27dvblcfHx8vu3bvtynr37u2wfEZGRr713/hcPVaay8QfVNguzPGiz4jz0xlfnpsq95FW9MILL8jkyZPtyrKzs2XgwIHy22+/6R7Xc+bMkdjYWDl9+rSvmumUaseD1ecXC7T+M1jmi7Yyf/UxKoxXjKTquRsI+0nl96r4fS44w/UTnjL7NyzcYfVxt+pUuw+D9zinjKXq+B0AAAAAAAAAAAAAAAAAAAAAACDYfPTRRzJq1CipUaNGXtmLL74od999t3z44YfyzTffyJ9//mnKuq//LsjVq1clLCxM+vXrJ71795Z27dpJ5cqVHZbRNE0OHTok3377rcybN09++OEHt9b54osvSp8+faRcuXIiIlKmTBnZtm2bTJo0SaZPny7nzp3TXa5UqVIyYsQIGTdunERGRuaVnzlzRsaNG+d0fUWLFrX7O/e7ayVLlpQ5c+boznl5I5vNJq1atZJWrVrJM888I0OHDpVffvmlwOUAAAAAAAAAAAAAAAAAAAAAAAAAwArC/N0AAAAAAAAAAAAAAAAAAIC5mjRpIhs3bhQRkffee0/Gjh3r5xYBAAAAgDmc/WBSo0aNpHz58nL69GkftwgiIn/99ZdueZEiRaRBgwby+++/+6QdsbGxEh4ervuYszZ6S9M0OXbsmBw7dky+//57u8dsNpvUqVNHlixZIjfddJPu8v/5z3/ko48+kqSkJFPaZ5ZXX31Vihcv7lB+5coV+c9//iPTp0+XrKwsr9YRHR3t1fLucmVfduvWTUaOHKns/gyG1+hrmZmZkp2dLWFh9l/lDAsLk6ioKElNTTVlvSVKlNAtT0lJMWV9/nL+/HkpU6aMQ3n58uVN6dejoqKcblsV+OocD8RrgJ60tDTRNE1sNptdecmSJf3UImOoeC3Q2xeFChWSIkWKSHp6uk/a4AzXAQSb0NBQQ+uLiYnxankV+uqMjAzJycmRkJAQu/KwsDCJjIyUtLQ0U9ZbrFgxU+r1RLCMHXyJ48p9VhgDWa0PLUjx4sXl/PnzptWtJ/fH572tW8V2e+ro0aOyZs0a6dq1q11569atpW7durJ//36HZerWrSvNmzd3KJ81a5Zp7XSViteMEydOyMqVK6Vnz5525Z06dZIqVarIsWPHHJYZMmSIQ9nixYvl4sWLbq1bxe3lT4GwvYKtj4O9QOvzg5Gze1irvM/lSyrcz+cKhOvH9Xx1b6TCPubeGgAAAAAAAAAAAAAAAAAAAAAAAAAAACpjrnZrYq724Jur3V3MY+pfI0eO9HcTROTveekefPBBefnll/3dFEuy0lxLqp+zCxculB49etiV2Ww26dWrl3z00Ud5ZWXKlJG4uDi7523fvl1OnTqVb/3Lli2T9u3b25XFx8fLa6+9ZlfWp08fh2VXr17t8hxXKsxl4g8qbBfmeHHO2/MzP746N1XvI63i2rVr8tBDDzmdH+7gwYPy2GOP6T5epkwZmTdvnnTp0sXsZhZItePB6vOLBUP/aYX5ooOBv/sYFcYrRlL13A3U/eRqP/Puu+/qLu/LPobf54KruH4GLiN/x8Ls37Bwh9XH3apT7T4M3uOcMpaq43cAAAAAAAAAAAAAAAAAAAAAAIBgk5qaKv369ZPvv//e7vs19erVk3fffVfeffddSUpKkuPHj+c9VqFCBUPmZLz++zYhISFy7NgxKVu2bL7L2Gw2qVWrltSqVUseeugh2bp1q4waNUp++eUXl9Z5/vx56dGjh6xZsybv+1xFihSRiRMnyn//+1/5448/ZP/+/ZKcnCyapkmxYsWkbt260rBhQ4fvK168eFF69OiR75xeN37fJTU1VcqXLy8bN26U2rVru9Tm6zVq1Eh++OEHuffee2XZsmVuLw8AAAAAAAAAAAAAAAAAAAAAAAAAvhZS8FMAAAAAAAAAAAAAAAAAACoLCQmR6OhoiY6OlvDwcH83BwAAAABMs379esnKynIot9lscvfdd/uhRRAR2b9/v6Snp+s+1rJlS5+1w9m6Ll26JEePHvVZO3Jpmib79++Xhg0byn//+1/d50RHR8uDDz7o45Z5p3r16nLPPfc4lGdmZkrnzp3l/fff1z1P3VW6dGmv6zBK7r587733Am5/5gqG12iWEydO6JaXL1/etHU6q9vbHze0mn379umWx8XFmbK+Fi1aSEhIYH4t16hzPJiuAdeuXZNz5845lEdGRkrhwoX90CLzWfVakJOTI2fOnHEoL1eunM/akB+uAwhE165d0y2PiYkxdD1VqlTxanlV+mq9PkzEvH6scOHCpvZB7gimsYOvBfNxZTSjx0Cq9KEFMXOs5azu/H6o3tu6jWBmu70xffp03fJhw4bplg8ePNihLCUlRb788ksjm+U2la8ZevvAZrPJkCFDHMpvv/12qVatmkt15Efl7eUPgbK9grGPg71A6fODlbP3uESs8z6Xr6hyPx8o1w9XGXlvpMo+5t4aAAAAAAAAAAAAAAAAAAAAAAAAAAAAqmKudmtirnZ9gTpXu6eYx9Q/SpcuLf369fN3M/I8+OCDATsXtresNteSyufs0qVLdccLffr0sfu7R48eYrPZHJYtyLJlyxzKWrduLaVKlcr7u1y5ctK6dWuH5y1cuLDA+nOpMpeJr6myXZjjRZ+Z56evzk0RtftIq+jXr5/MmjUr3+fMnj3b6fxxnTt3lmeffdaMprlNleNBlfnFgrn/tOpvZqjI332MKuMVI6l47gbjfrq+n7FCH8Pvc8EIXD/V4IvfsTD7Nyxcpcq4W3Wq3IfBe5xT5lBx/A4AAAAAAAAAAAAAAAAAAAAAABCMfvvtN2nVqpXs3LlT9/GSJUtKbGxs3t+DBg2SU6dOSXJysnz//ffy2muvyS233OL2eqOiovL+PzQ0VMqWLet2Ha1bt5atW7fKww8/7PIy27dvl2bNmsmKFSvsykNDQ6Vx48Zy1113yQMPPCD/+te/pH///hIbGyuhoaF2z12xYoU0bdpUtm/fnu+6wsPD7f7OycmRJUuWSO3atUVEJDs7W+bNmyd9+/aVKlWqSOHChSUkJERKly4tbdq0kfHjx8upU6fs6ihSpIgsXLjQo20OAAAAAAAAAAAAAAAAAAAAAAAAAL7GrzsCAAAAAAAAAAAAAAAAAAAAAAAgIKSnp8v69et1HxsxYoSPW4NcOTk58ttvv+k+duutt/qsHc7WVdAPXZlN0zR5+eWX5cMPP9R9vGvXrj5ukXe6d+8uISGOX1v78MMP5ccffzRkHSEhIR79qJovBNr+1BMMr9FIf/zxh255q1atTFtnXFycbvnu3btNW6c/7NmzR7e8Xbt2pqzPzH1mJd6c48F2DTh69KhueaNGjXzcEt+z2rXgyJEjDmXNmzf3aRuc4TqAQHTx4kXd8qJFixq6nnr16nldhwp99f79+3XLW7RoYcr66tatKzabzZS63RVsYwdfCubjykxGjIFU6kPzY9axVKlSJSlXrpxD+dWrV+Xw4cNe169qu72xbNkyOXPmjEP5/fffr3ve3nfffQ5lCxculLS0NFPa5yqVrxnffPONnDx50qF8+PDhDmXDhg1zKDtw4IDTf/dwRuXt5Q+Bsr2CsY+DvUDp84OZ3ntcItZ5n8uXVLifD5TrhyeMuDdSYR9zbw0AAAAAAAAAAAAAAAAAAAAAAAAAAABVMVe7NTFXe/6sNtepvzCPqX8MHTpUwsPD/d2MPJUqVZIePXr4uxmWZLW5llQ+Z5OTk2Xt2rUO5bfffrvExMTk/d2rVy+H5yxbtqzA+g8cOCD79u2zKwsJCZE777wz7+/4+HiH+TYyMzMlISGhwPqvp8JcJv6gwnZhjhd9Zp6fvjw3Ve4jrcKV/lbk7/u8Y8eO6T42adIk084pd6hyPKgyvxj959+4j/SOFfoYFcYrRlL13A22/XQ9K/Qx/D4XjMb107p88TsWZv+GhatUGXerTpX7MHiPc8ocqo7fAQAAAAAAAAAAAAAAAAAAAAAAgtH+/fulSZMmMnToUNm8ebNLyxQtWlQ6dOggzz33nGzatEn+/PNPGTx4sMvrjI6Odig7deqU/O9//5MnnnhC7rrrLuncubN06dJF+vfvL2PGjJElS5ZIRkaG3TKFChWSjz76yK15ImvXri2VK1d2+fk3qly5xwo8kAABGRRJREFUstSpU8ft5W655Za876ht375d6tevL0OGDJElS5bI8ePHJTMzUzRNkwsXLsjWrVvllVdekerVq8uUKVPs6omIiJD//e9/EhkZ6fFrAAAAAAAAAAAAAAAAAAAAAAAAAABfcPx1KAAAAAAAAAAAAAAAAAAAAAAAAEBRc+fO1S1v3LixdO/e3cetQa41a9bolt999926P5ZltOLFi0u/fv10H0tMTDR9/a4YP368ZGdnO5S3bNnSD63xXPv27XXLFyxYYNg6mjdvLkWKFDGsPjMEyv7MTzC8RiP8/vvvuuXt2rUzZX316tWTUqVKOZRnZmbKn3/+aco6/eX777/XLe/Xr5+EhoYavr777rvP8DqtzJNzPNiuAbt27dItz/1BzGBglWvBb7/95lDWpk0bn7bBGa4DCEQXL17ULa9Ro4ah67ntttu8rkOFvnrfvn265Wb1Y0ZsV6ME29jBl4L5uPIFb8ZAKvWh+THrWGrdurVu+Z9//ik5OTle169qu72RnZ2t+5555cqVpWPHjnZlrVq1klq1ajk8d9asWaa1z1UqXzNycnJk9uzZDuW1atWyuy+IioqSu+66y+F5M2bMcHudKm8vfwiU7RWMfRzsBUqfH8z03uMSsc77XL6kwv18oFw/vOHNvZEK+5h7awAAAAAAAAAAAAAAAAAAAAAAAAAAAKiMudqtibnaC2aVuU79hXlM/ePhhx/WLR88eLBERESYms2bN+uue+TIkWa+ZGVZba4l1c/ZhQsXOpSFh4dLt27d8v6/S5cudo8fO3ZMdu7c6VL9CQkJDmXx8fF5/9+nTx+HxxMTEyUlJcWl+nOpMJeJP6iwXZjjxTkzz09fnZuq95EquXTpkgwePFj3mlWoUCFZsGCBT+438qPK8aDK/GL0n/aC/T7SbGb2MSqMV4yk6rkbbPvpRv7uY/h9LpjF38c2HPnidyysMq5TZdytOlXuw+A9zilzqDp+BwAAAAAAAAAAAAAAAAAAAAAACFaapsmnn34qbdu2lcqVK0v//v3ljTfekNWrV8vp06cLXL5mzZoyb948SUxMlKJFixb4/BdffFF+/fVXERFZv3693HHHHVKpUiW5//775b333pOvvvpKvv32W1m7dq0sXrxY3njjDenbt69UqlRJ/u///k+uXbtmV9/7778vsbGxBa73v//9ryQmJuo+98KFC7Jjxw7ZuHGjbNy4UXbs2CHnz593eF5sbKwkJibKf//73wLXd72QkBAREdm8ebO0bdvWpe+OZWVlybPPPiuPPfaYXXmNGjXkkUcecWv9AAAAAAAAAAAAAAAAAAAAAAAAAOBrIf5uAAAAAAAAAAAAAAAAAAAAAAAAAGCUr776SpKTk3Ufe/PNNyUsLMzHLYKIyPLly3XLo6OjZdCgQaavf8iQIVKkSBHdx1auXGn6+l1x4cIF+e233xzKY2JiJDw83PcN8lCFChV0y/fs2WPYOjp27GhYXWYJlP2ZH1+8xtDQUEPq8ac1a9bolvfs2dOU19enTx/d8vXr1zv8uKDq1qxZI5qmOZRXqlRJ+vXrZ+i6WrduLTfffLOhdVqdJ+d4sF0DfvrpJ93yDh06+LYhfmSV692PP/7oUNa9e3efrT8/XAesIRDGFFaSlJSkW96sWTPD1hEWFiZ33HGH1/Wo0Fdv3LhRt/zOO+80ZX3x8fGm1OuJYBs7+FIwH1e+4M0YSKU+ND8dO3Y0ZbznbAz3ww8/GFK/qu321owZM3TLhw0bZvf34MGDHZ5z4MAB2bx5sxnNcovq14wZM2bovocxfPjwvP+/++67JSoqyu7xq1evypw5c9xen+rby9cCZXsFax9ndb6+Hw2EPj+Y6b3HJWKd97l8SYX7+UC5fnjDm3sjFfYx99YAAAAAAAAAAAAAAAAAAAAAAAAAAABQGXO1WxNztRfMKnOd+gvzmPre7bffLnXq1HEoT0pKkkWLFklWVpapmTlzpm67unXrJlWrVjX75SvHanMtqX7OLlmyRLKyspyup0OHDhIdHW332LJly1yuf+nSpQ5l3bp1k7CwMImKipLOnTs7PL5o0SKX68+lwlwm/qDCdmGOF+fMPD99dW6q3keqZsOGDfL666/rPlarVi358MMPfdwie6ocD6rML0b/aS/Y7yN9waw+RoXxipFUPXeDbT/dyN99DL/PBbP4+9iGI7N/x8IXv2HhKlXG3a6y6u9iqXIfBu8F2jllFaqO3wEAAAAAAAAAAAAAAAAAAAAAACBy4sQJWbx4sYwZM0a6desmPXr0yHvs+++/lylTpkhiYqLufI1dunSRb7/9tsDvWy5fvlyaNWsmDRo0kA4dOjj9XvCNkpKS5LnnnpNu3bpJRkZGXnl4eLi8+eab+S779NNPy/jx48Vms+WVnTlzRl544QWpVauWlC5dWpo0aSLt27eX9u3bS5MmTaRMmTJSo0YNef755+X06dN5y9lsNhk/frw8/fTTBbb5eikpKdK3b1/JzMx0a7n3339fPv/8c7uy0aNHu1UHAAAAAAAAAAAAAAAAAAAAAAAAAPhaiL8bAAAAAAAAAAAAAAAAAAAwVtOmTWXSpEmSkJAgu3fvlo0bN+Y9Nnr0aNm7d6988803MnbsWGnWrJnP29e4cWN56KGH8tKuXTufrbt69ery73//WxYvXix79uyRpKQkuXr1quTk5MiVK1fkwIEDsnTpUnnyySelQoUKhq23QYMGMnbsWFm2bJkcPHhQLly4INnZ2ZKdnS0XLlyQgwcPyrJly2Ts2LHSoEEDt+quWbOm3fY0Mv44PgAAAABvpaeny3vvvaf7WP369WXChAk+bhFERLZt2yZ79+7VfWzMmDESGRlp2rpjYmLkmWee0X3s119/lV27dnlUb/ny5b1plq6TJ0/qlhcvXtzwdZmlRIkSuuXX/6CZN0JCQmTEiBGG1JXLjH0pYq39afXXmJqaqlseExPjbpMsZ/369bqvr0qVKtK/f39D11WoUCF5/PHHdR9btmyZoeuygvPnz8vatWt1H3vppZcK/LFGd7zyyiuG1WUGq5zjKl4DvJGYmKhb3qtXLylTpoyPW1MwqxwnZli1apVD2U033SSdOnXyWRuc4TrgW4E8prCSP/74Q7e8fPnyUrt2bUPWcddddxnSl6rQV69Zs0a3vH79+tK5c2dD11WzZk3D6/RGsI0dfCmYj6sbWW0MpFIfmp8yZcrIvffea2idpUuXlvvuu0/3Mb3xnidUbbe3Dh48KOvWrXMo79evn0RHR4uISGhoqAwYMMDhObNmzTK7eS5R/Zpx5MgR3fcwBgwYkPfe+LBhwxweX7ZsmZw7d87t9am+vXwtULZXsPZxVmGV+9FA6PODmbPzyirvc/mSCvfzql0/rHZvpMI+5t4aAAAAAAAAAAAAAAAAAAAAAAAAAAAAKmOudmtirnbXWGGuU39hHlPfGzlypG75/PnzJSsry/T1f/HFF3LlyhWH8pCQEHnooYdMX79qrDbXkurnbHJysu4caT169JCwsDCJj493eGzp0qUu179582a5cOGCXVnRokWlXbt20rVrV4mIiLB7LCsry6PXosJcJv6gwnZhjhfnzDw/fXVuqt5HqmjcuHGybds23cfuv/9+GTRokI9b9A9VjgdV5hdTvf/kPlJNZvQxKoxXjKTquavafgq0Pobf54KI9eYUhTnM/h0LX/yGhatUGXffyCrzkLtKlfsweE/Vc8rqVB2/AwAAAAAAAAAAAAAAAAAAAAAAIH/bt2+XZ599Vrp27SqlS5eW+Ph4h+/St2jRQl599VWX6tuzZ49H7Vi7dq088sgjdmWdO3eWevXq6T6/QYMG8tprr9mVfffdd9KwYUOZPHmyHDp0yOm6/vrrL3n99delYcOGDt9dfu2116RBgwYut3vq1Kly9uxZl59/vRdeeEE0Tcv7u3r16tKoUSOP6gIAAAAAAAAAAAAAAAAAAAAAAAAAXwjxdwMAAAAAAAAAAAAAAAAAAN4LCwuT0aNHy8GDB+WXX36RF154QXr27CkNGjSQyMjIvOcVLlxY6tWrJ927d5eJEyfK9u3bZceOHdK3b1+ftLN06dKycuVK+fjjj/MyaNAg09dbt25dWbx4sRw6dEjeeust6devn9SvX19KlCghYWFhYrPZJCoqSmrXri29evWSt99+W44dOyazZs2SsmXLerzeuLg4+eGHH2T37t0yceJEiY+Pl1q1aknJkiUlNDRUQkNDpWTJklKrVi2Jj4+XiRMnyu7duyUuLs7ldbRo0cJuexqZnj17evzaAQAAAH966623JDk5Wfex559/XgYMGODjFkFEZNq0abrlNWvWlDfffNO09U6dOlWqVKmi+9iHH37odn2VK1eWadOmyZEjR6R3797eNs9OeHi4bnl6erqh6zFTSkqKbnmZMmUMqX/gwIFSq1YtQ+oyc1+KWGN/qvIaL168qFterVo1t9tkNVlZWfLFF1/oPjZ27FgpVKiQYet66KGHpGLFig7lmZmZsmjRIsPWYyVTp07VLW/YsKFMmjTJkHU89NBD0rlzZ0PqMprVznGVrgFGOHTokOzatcuhPDw8XEaMGGHouooVKybly5f3aFmrHSdmOHXqlGzatMmh/D//+Y+h63nooYfk5ptvdmsZrgO+FchjCivZv3+/XLhwQfexYcOGeV1/WFiYvPzyy17XI6JGX33mzBnZvHmz7mMvvPCCt82y88orr4jNZjO0Tm8E29jBl4L5uMpl1TGQSn1oQZ555hkJDQ01rL6nnnpKChcu7FCempoqiYmJhq1H1XZ7a8aMGQ5lkZGRcvfdd4uISJcuXRw+H5OTkyOffvqpT9pXkEC4ZkyfPt2hLDo6Wu666y6pUaOGtG/f3qVlXBEI28uXAml7BWsfZwVWuh9Vvc8PZs7e4xKxxvtcvqTC/bwq1w+r3hupsI+5twYAAAAAAAAAAAAAAAAAAAAAAAAAAIDqmKvdmpirvWBWmOvUX5jH1LdKly4tffr00X1s5syZPmlDWlqaLFiwQPexf/3rX4bOKRQorDTXUiCcswsXLnQoK1asmNx2220SHx9vV56SkiLr1q1zue6cnBxZsWKFQ3l8fLzuubd27VqnY5f8qDCXiT+osF2Y4yV/Zp2fvjo3A6GPVM21a9dk4MCBcuXKFd3Hp02bJjVr1vRxq/6myvGgyvxiqvaf199HGi2Y7yN9xYw+RoXxipFUPXdV2U+B/F5VsP8+VzCz6pyiMIeZv2Phy9+wcIUq4+4bWWkecleoch8G76l6TlmdquN3AAAAAAAAAAAAAAAAAAAAAAAAuC47O1uWL18urVu3lo8++sjusVGjRknZsmVNXf+cOXMcvsvdq1cv3edOmDBBwsLC8v7etWuXxMfHO/1uop6kpCTp1auX7Ny5M6/M3e8gevOdsb/++ku2b99uV9a8eXOP6wMAAAAAAAAAAAAAAAAAAAAAAAAAs4X4uwEAAAAAAAAAAAAAAAAAAO/Url1btm3bJlOnTpVatWq5vXxsbKx89dVXsnz5cilRooQJLfzH//73P6lUqZKp67jR4MGD5ddff5V+/fqJzWZzebnQ0FAZPny47Nq1S9q0aeP2el9++WXZsmWLtG3b1u1lt2zZ4tYE6wAAAADsXbp0SZ577jndx2w2m8yfP1/uvfdeH7cK06dPl9OnT+s+NnLkSBk0aJDh6/zXv/4lQ4cO1X3s6NGjMnfuXJfrqly5snz44Yfy559/ysiRIyU8PFzee+89KVmypFHNldq1azuUpaWlSUpKimHrMNv58+d1yz25t75RpUqV5O233/a6Hl/sSxH/7k/VXuOJEyd0y+vUqSPlypXzqG1WMmXKFNE0zaG8cePG8s477xiyjqZNm8qUKVN0H/v000/l7NmzhqzHapYvX273w4XXe+qpp+TBBx/0qv4uXboYto+MZNVzXIVrgNFmzJihWz527FipU6eOYet5++23Zd++ffL4449LSIhrXw+36nFilht/sFVEpFOnTvLEE08YUn+LFi1k2rRp8ttvv0lCQoLExcW5vCzXAd8J9DGFlWzevFm3fMSIEVK8eHGv6n7hhRekfv36XtVxPSv31bk++OAD3fLbb79dnn76aSOaJ926dZP77rvPkLqMEoxjB18K1uNKhTGQSn1ofho3bixvvPGGIXXddtttMmbMGN3H5s2bZ+jYUtV2e2vx4sWSlJTkUD5s2DAR+fuzNTdKTEyUkydPmt00lwTCNWPJkiW64/Lhw4fL0KFDHT7TdOTIEVmzZo1H6wqE7eVLgbS9grWPswIr3Y+q3ucHO733uESs8z6XL1n9ft7q1w8V7o2svo9FgvfeGgAAAAAAAAAAAAAAAAAAAAAAAAAAAIGBudqtibnaC2aVuU79hXlMfWf48OESHh7uUP7zzz87nffaDDNnztQtL1++vPTq1ctn7VCF1eZaUv2cXbJkiVy9etWhfNy4cVKtWjW7stWrV+s+Nz9Lly51KOvdu7f07NnToXzRokVu1X09FeYy8QcVtgtzvDhn5vnpq3NT9T5SRX/++aeMHj1a97GYmBhZsGCBhIWF+bhVf1PheLD6/GLXU6n/1LuPtNKcaHCdGX2MCuMVI6l07l7PyvspGN6rCtbf5wpmKswpCnOY9TsWvvwNC1eoNO6+npXmIXeVCvdh8J6q55QKVB2/AwAAAAAAAAAAAAAAAAAAAAAAwD05OTkyatQo2b59e15Z4cKFpV+/fqav+8a5XZo1a+bwnKJFizrMR/bkk09KWlqa2+tLT0+XJ5980q6sd+/eEhMT4/DczMxMu79zcnK8np/tl19+sfu7cuXKXtUHAAAAAAAAAAAAAAAAAAAAAAAAAGay/i/ZAwAAAAAAAAAAAAAAAACcatCggWzZskWaNGliV65pmuzatUvmzZsnn376aV75jh075Ntvv5Xk5GSHunr06CFbtmyRsmXLmtLW559/Xrp27WpK3c7cf//98umnn0pkZKRd+eXLl2XVqlUydepUmTRpkkyaNEmmTZsmW7ZskWvXrtk9t2zZsrJmzRqJjY11eb2TJ0+Wl156SUJC7D+ml5ycLKtXr7Zb79SpU2X16tV2+yQkJEReeuklefXVVz141cbJzs726/oBAAAAb3z88cfy/fff6z4WFhYmn3/+ubz99ttSuHBh09pw++23m3aPpaKMjAx54YUXnD4+b948eeqppwxb3wsvvCAzZ850+viYMWPk6tWrLtf30UcfySOPPCLh4eF5ZVWrVpVFixZJkSJFvGqriEhcXJzUrl3bofz48eMFLluoUCGZOnWq0/jS/v37dcsffvhhr+qNjIyUL7/8UsqUKeNVPSLm70sR7/anEVR7jSdOnHC63KOPPup2fVazZ88eWbhwoe5jjz76qPz73//2qv46derI119/rXtNy8jIkNdee82r+q1M0zR5/PHHdR8LCQmRGTNmyNixYx3ep3PFvffeKwkJCYadM0ay6jmuwjXAaJ988omcO3fOoTwyMlLmz58vUVFRXq/jwQcflOHDh0vRokXl3XfflV9++UXatGlT4HJWPU7M8vnnn+uWv/HGG9K9e3ev6i5fvrwsWrQory/p2bOn/Pjjj7JmzRqXxvtcB3wn0McUVuLsmC5btqy8/fbbHtfbu3dveemllzxeXo+V++pcixYtkqNHj+o+9tprr0l8fLxX7WvQoIF89tlnXtVhhmAcO/hSsB5XKoyBVOpDC/Lvf/9bRowY4VUdN910kyxYsEBCQ0MdHsvOzpZ33nnHq/r1qNpub2RmZsr//vc/h/Jbb71VGjVqJH369HF4bNasWT5omWsC4ZqRnZ0tc+fOdSjv0KGDPPLIIw7lM2fOFE3TPFpXIGwvXwq07RWMfZwVWOl+VPU+P9h9/vnncuDAAd3HrPA+ly9Z/X7e6tcPFe6NrL6PRYL33hoAAAAAAAAAAAAAAAAAAAAAgGAVHh4uLVq0kCFDhshTTz0l48aNkxdeeEFGjRol9913nzRp0kT3u3dGqlu3rtx3330yZswYGTdunDz++OMycOBAqVGjhmHrKFGihHTr1k0ee+wxefHFF+Xpp5+W+++/X+Li4sRmsxm2HgAAAFgDc7VbD3O1589Kc536C/OY+o6zeSLyO2fM8OOPP8ru3bt1Hxs5cqRP26IKK821pPo5m5ycLGvXrnUov+222xzKli5d6nb9q1evlqysLLuyWrVqSYkSJezKsrOzPao/lwpzmfiDCtuFOV6cM/P89NW5qXofqaq5c+c63e4tW7aUiRMn+rhFf1PheLD6/GLXU6n/1LuPtNKcaHCP0X2MCuMVI6l07l7PyvspGN6rCtbf5/IlK/0GpIgac4rCHGb8joU/fsOiICqNu69npXnIXaXCfZjKrHL9UPWcUoGq43cAAAAAAAAAAAAAAAAAAAAAAAC4Lycnx2HeKb15Xoz2xx9/2P1dvnx5h+e0bNlSChUqlPf36dOn5bvvvvN4nd9//72cPn067+/w8HBp2bKlw/MuXrzo8HdOTo7H6xURh++tFy1a1Kv6AAAAAAAAAAAAAAAAAAAAAAAAAMBUmotEhBBCdBMbG6sNHjxYGzx4sDZo0CCtTZs2ms1m83u7CCGEEEIIIYQQQgghhBBCCCGEEEICPUWKFNH+/PNPu896Xb16VXvrrbe0qlWr5j2vWbNmeY+/8cYbeeWdOnXSNmzY4PB5sZ9//lkLCwsztK3t2rXTsrOzdT+fNm3aNFO2T/369bX09HS7dR0/flwbNGiQVqhQIafLVapUSZs5c6ZDO3fv3q2FhoYWuN7bb7/dYdmzZ89qw4YN0yIiIpwuFxERoQ0bNkw7e/as3bK33357vusrXry41qxZM68zdepUu/VmZGTYHUeEEEKsF5vNprVs2VIbNGhQ3mc5Y2Nj/d6uYA2fqSXEmilTpox25MgR3XuRXEeOHNGGDh2a732COylUqJDWs2dPbdOmTfmut27dum7XffjwYd26BgwY4Pdt7U4SExPz3TZfffWVVr9+fY/rb9iwoZaQkJDvOpYuXep2vU2bNtVycnJ069u8ebNWpUoVj9tcvHhxbdeuXbp1v/POOwUuHxkZme/r9eX+7dy5s9N2/Otf//KozooVK2q//PKLXV3bt2/XXUf79u39ui+N2J9GRMXXOG/ePN36MjMzXdqv7sYZs/ZJuXLltEuXLjld70cffaSFh4e7XW+XLl20ixcvOq33+eefN2TbmLFNZs+erbuuIUOGuF3XtGnTnG4DTdO0Xbt2ad27d9dCQkIKrKtZs2a616qTJ09qKSkpuvXHxcWZduzoxarnuArXgIKOdU1z/3h/5JFHnNa1fft2rWzZsh7vi8cff1y7du2aQ705OTla165dlTxOzIwz2dnZ2hNPPOFRnfXr19f279+vW++uXbtcvvdX/Tqgada/FuRG1TGFats9LCxMO3HihNN2v/rqq263a8SIEdrVq1ft6tm3b59D3SkpKW7XbdW++vrcddddTtt47do17dlnn/WofZ06ddIuXLhgV9/x48d11+PrMU2wjh1ciVH9YzAeVyqMgVTqQ1311ltvufR5ihvTo0cPLTk52Wm9b7/9tkf7ScV2O2Pk+dGwYUPddezcudOhLCkpyaPxqVlR7ZrhLHXq1HH6Oq6XnZ2tVaxYMWi2lzO+qiMQtpfedSUQ+zir1XNjfH0/ml9U7vNV2ud60RvLuzuOj4+Pd9pmf7/P5cttKWLt+3mrXz9UuDey+j7OTTDeWxOiYmw2mxYXF8fnaQkhbsUb/m47IcS64XslhBBCCCGEEEIIIYQQQgghhBBCCCFEL11GizZm1T/pMtr/bSL2admypbZgwQKnc0xdLzU1VVu4cKHWrl07l+v/6KOPtG3btjmkS5cuec+57777tN27d+e77r1792pDhgxxaS4tvbRr105bsWKFw3fTr3fmzBlt4sSJWlRUlCYi2vfff+/0ub7+7hwhhDgLc7VbK3ymlhBrhrnarRnmaneMFec6vTHjx4/Xbd/48eMNXQ/zmJqfTp066bY7NTVVK1q0qM/b8+STT+q2JycnR6tZs6bL9QRKH+kqq8y1pNI5q5dhw4YVuK2zs7O1kiVLelT/6tWrC6x/1apVXr8OFeYyye/4Nut8UmG7MMeL85h5fvrq3FSpj3TG7P1sxnqLFSvm9D4wJydH69Spk1/aaPXjwerzi90YVfpPZ/eRVpoTzcg4o3o918foPkaF8YqRUeXcVWU/Wf29Kmc8aY9qv89l5GsvKN7+toOVfgPS7OPaase2L7b5ypUrdddxxx13GLaOp556Sncdb7zxhlv1GP07Fmb+DpA3+061cff18eU85N5s4+tj9fsws163KwmU64dK55RK+zc3qo7fCSGEBGeYq50Q4km84e+2E0KsG75XQgghhBBCCCGEEEIIIYQQQgghhBBCrJZmzZrlff4tv+/+1axZ0+6zchs3bjS9bR06dLBb57Zt2xyeM2TIELvnfP/9916vd/369XZ1Dh48WPd52dnZec85e/as1+udMGGC3Xpff/11vx8fhBASKGGudmuFz9QSQgghhBBCCCGEEEIIIYQQQgghhBBCCCGE+DbM1U4I8SQuzcnu0rM0Jm8nhDgPXzQhhBBCCCGEEEIIIYQQQgghhBBCCPFPXnzxRbvPeV2+fFm79dZbHZ5X0ETmjz76qJaTk2NX14QJEwxrZ+nSpbXjx487/XzatGnTTNk+a9eutVvPjh07tFKlSrm8/MiRIx3aOnDgwAKX2759u90yf/75p1apUiWX11upUiW75X/++WfTj6WoqCjt9OnTduvNb9J7Qggh1giTt1srfKaWEOumcePG2vnz553ek+Q6ffq09sEHH2h33HGHVqxYMZfrL1SokNawYUNt0KBB2oIFC7Tk5OQC16Vpmla3bl23X8vhw4d16xowYIDft7M7KV26tPbXX3/lu32ys7O1+fPna/3799dKlChRYJ2lSpXSBgwYoC1YsEC7du1avnUfOHBAK168uEdt/+CDD5zWm5KSoo0bN04rXbq0W3V27dpV279/v9N627ZtW2AdkZGR+b5mX+7fiIgI7dy5c7rtuHbtmjZu3DgtLCzMpbrCw8O1xx9/3KG+ixcvaj169NBdR/v27f22L43an0ZFtdfYtm1bp3VmZWVpr732mlatWjXDto8zZu6Te++91+l6NU3T/vrrL23w4MEunSMNGzbUvv7663zr27hxoxYaGmrItjFje8yePVt3XUOGDHG7rkKFCmlbt27Nd3tomqYlJSVp8+fP11588UVtxIgRWv/+/bWhQ4dqzz33nDZt2jSn11pN07RevXo57d/i4uJMPXb0YsVzXJVrQH7HuqZ5dryvW7fOaX1nz57VHn30UZdfu8jfY9iVK1c6rfPHH3/UQkJClDxOzIyzfiXXzz//rN1xxx0u1RUdHa29+OKLWmpqqm5dOTk5WqdOndxqn8rXAU2z/rUgN6qOKVTc7s8884zTdmuapn3zzTdanTp1CqynWbNmun3eTz/9pL3++usO5SkpKR69bqv21dcnISEh3236yy+/aF27dnWprvr162uffvqpw78Dp6ena8OGDdOt39djmmAeOxQUI/vHYDuuRNQYA6nShzpz4+ciNE3T9u3bp/Xv39+lfxtp3LixtmzZsny3weHDh7WYmBiPjgEV2+2M0efHli1b8m1/rvfff99n56wrUe2akV/yG5PkSkhICKrt5Yyv6giE7TV+/HjtwIEDDuWB1sdZrZ4b4+v70YKiap+v0j7Xi95Y3pNxvFXf5/LltsyNVe/nVbh+qHBvZOV9fH2C8d6aENXC5O2EEE/iDX+3nRBi3fC9EkIIIYQQQgghhBBCCCGEEEIIIYQQopcuo0Ubs+qfdBnt/zaRv1O8eHHts88+8/gzhfPmzdOio6MLXM/333+vu/yAAQO0UqVKFfj9vhutW7fOpTkac1O4cGFtxowZbq3j+PHjWmxsrNO2a5qx38ElhBBvwlzt1gqfqSXEumGuduuFudrtY9W5Tm/M+PHjdds3fvx4w9fFPKbmZtGiRbrtnjt3rl/aU6pUKS0zM1O3Ta+99prL9QRKH+mMleeTU+Wc1Uvx4sW1rKysfNe3YcMGj+t/9NFH861b0zTtgQceMOS1qDCXiTNmnlMqbBfmeNGPmeenL89NVfpIZ8zez2att127dk7vC06ePOnWmN3INlr5eFBhfrEbo0r/6ew+0kpzohkVZ1Sv58YY2ceIqDFeMTKqnLuq7Cez5l40oo9xxpPtr9rvcxn52guKt7/tYKXfgDT7uDbq+mnUtvLFNnfWz7g6t68reeqpp3TX8cYbb7hdlxG/Y+GL3wHyZt+pOO7OjS/nIfdmG98YK9+Hmfm6C0qgXD9UOqdU2r/XR9XxOyGEkOALc7UTQjyJN/zddkKIdcP3SgghhBBCCCGEEEIIIYQQQgghhBBCiNXSrFmzvM+/5ffdv6JFi9p9Vm737t2mt61Lly5269y0aZPDcx566CG75yxfvtzr9S5fvtyuzoceekj3efv27ct7ztWrV71e74cffmi33v/85z9+Pz4IISRQwlzt1gqfqSWEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgjxbZirnRDiSVxh+/8TsxfIZrO58jQAQSg2NlZiY2NFRETTNDl06JBs3bpVXOxeAAAAAAAAAAAAAAAA4KEjR45I1apV8/4eNmyYzJ071+F5zZo1k+3bt4uIyJQpU+TZZ591eM7IkSNl2rRpeX+npqZKjRo15Ny5c163c9WqVdK1a9e8v99++23597//nff3Rx99JI888ojX67le3bp1Ze/evXmffbt8+bI0atRIjh075lY9X375pdx11115fy9btkx69+7t9Pm1atWSgwcP2pW1adNGtm7d6tZ6b/zsTa1ateTQoUNu1eGOcePGyYQJE/L+vnjxotSsWVMuXbpk2joBAN6z2WzSokULqVu3bt41b+fOnbJz504/tyw48ZlawNoaNGgga9eulQoVKrj0fE3T5MiRI3LkyBE5deqUpKamSkZGhoSGhkp0dLTExMRITEyMVKxYUWrXri1hYWFutWfNmjXSr18/uXLlilvLHT58WKpXr+5Qfs8998jChQvdqsvfGjRoIN9//72ULVu2wOfm5OTI3r175cyZM3Lu3DlJSkoSEZFSpUpJ6dKlpXz58lK/fn2Xvv908uRJ6dChgxw4cMCjdoeHh8umTZukRYsWTp9z9epV2bx5s6xbt0727Nkjf/31l6SkpEhaWprYbDaJioqS4sWLS61ataRp06byxBNPOK0rISFBevXqVWC7IiMjJTU11enjvv5u2JNPPilvv/2208dPnjwp8+bNkw0bNsi+ffvk0qVLkpGRIcWKFZOyZctK7dq1pWvXrtKjRw+H81bTNOnTp4+cPn1afvzxR4e6b7vtNtmwYUOBbTRjX3bv3l3q1KnjtD5X96dRVHyNGzdulHbt2uX7nBMnTsjRo0clJSVFcnJyHB4/c+aMDBs2rMB1ORunmX2+TJw4UcaOHZvvc5KTk2X16tXy008/yenTp+XChQsSFRUl5cqVkzp16sidd94p9erVy7eOQ4cOSVxcnFy4cMHtNuptGzO2y+zZs3X31dChQ+XTTz91u77ixYvLmjVr8j3mPTVx4kQZN26cnDt3TkqXLu3weKtWreSnn34yfL35seo5rsI14Pr69HhyvJctW1a2bdtm9579jc6cOSMrV66UtWvXyrFjx+Ts2bOSlpYm4eHhEhMTI1WrVpXY2Fjp3r27tG7d2mk9p06dktatW8vRo0cLbJdVjxOzREREyHfffSe33HJLvs87d+6cJCYmyq+//ipnz57N6yuLFSsmNWrUkLi4OLnjjjukSJEiTut49dVXC+zP9ah6HRBR41qQS8UxhYrbPTQ0VNatW5fvts7JyZGtW7fK6tWr5ejRo3Lu3Dmx2WxSsmRJady4sXTp0kVuvvlmh+UyMzOlRYsWMmjQIHn++eftHrty5YrExMS43M5cVu2rr1esWDH5+eefpXbt2vk+7/Tp07Jy5UrZuXOnnDlzRi5evCgRERFSsmRJadSokdx+++3StGlT3WUffvhh2bt3r6xfv97hMX+MaYJ17FAQI/vHYDyuVBgDqdKHOjvub775Zvnpp58kIiLC4bHz58/LqlWrZPv27XL69Gm5ePGixMTE5I1lunXrVuBYJj09Xdq0aSM7duxwua2qt9tXfczw4cNl1qxZBT6vefPm8ssvvxi6bm+pdM3Iz3333Sfz58/P9zm9evWShIQEr9aj0vYy4vj3tg7Vt9dzzz0nGzZskPXr10t4eLjD44HSx1mtHj2+vB8tiMp9fi4V9vmN9Mbynozjrfo+lz/+bcXK9/NWv36ocG8kYu19nCsY760B1dhsNmnZsqXUqVOHz9MCcJk3n/FmrnYAzvC9EgAAAAAAAAAAAAAAAOjpMlqkac9//v51ucia9/3XHvytcuXKsnbt2gK/X1eQbdu2Sfv27SUjI8Ppc77//nvp0KGDQ/mDDz4oI0eO9GjerN27d0vLli0lPT093+cVLlxYvvnmG+nYsaPb67h48aKkpKQ4/d6Hkd/BBQBvMFe7tfCZWsDamKvdepir3di52n1h/Pjx8t///teh/KWXXrL7/S+jMI+pOcqWLSvHjx+XQoUKOTzWvn172bhxox9aJbJo0SLp37+/Q/nZs2elcuXKcvXq1QLrCJQ+UsX55ETUOGedWblypXTr1s3p488884y8+eabHtVdpUqVfOf7yM7OlnLlyuVd27yhwlwmzOOjjzlenDPr/PTluSmiRh/pr3GNmevNb7t/88030rNnT93HbmR0G618PFh9frEbqdJ/FnQfaYU50YxitXkUVehjRNQYrxhJlXP3RlbdT76ee9GdPsboc1Cl3+fy93ywIq7PCWu134AUsf6coipcp3I5u6fq2rWrJCYmGrKOp556Sve+bMqUKfLss8+6VZe7v2Oxfft2v/wOUDDNC38jX81DHkz3Ydfj+uEZVc4plfbv9VQdvwMAgg9ztQPwBHO1AzAD3ysBAAAAAAAAAAAAAACAL3Xu3FmuXr2q+72MXM2aNZPt27eLSP7f/StTpoycPXs27+9ffvlFmjdvbmyDbzB06FCZM2dO3t9ff/219OvXz+459913n8yfPz/v7x9++EFuvfVWr9b7ww8/SNu2bfP+HjhwoCxYsMDhebNmzZLhw4fn/V2/fn3Zt2+fx+tdt26d3HbbbXl/33ffffL55597XB8A4B/M1W4tfKYWAAAAAAAAAAAAAAAAAADAt5irHYAnXPqMt+YiESGEEN3ExsZqgwcP1gYPHqwNGjRIa9OmjWaz2fzeLkIIIYQQQgghhBBCCCGEEEIIIYSQQE6VKlXsPuN19uxZLSQkRPe5zZo1y3veG2+84bTOLVu2aJqmaT/99JN27733aqGhoV638/nnn7dr55QpU7T27dvblU2bNs2UbdSgQQPt448/1tLS0rTnnnvOozo6duxo19Zjx47l+/xBgwbZPX/btm0erffnn3+2q+e+++4z7VgqU6aMdvnyZbv1Pf300z45jgkhhHgXm82mtWzZUhs0aFDeZzljY2P93q5gDZ+pJcT6qVChgrZu3TpXv0pjigsXLmgjR470+DUcPnxYt94BAwb4fft6kvr16zt9TWY4cOCAVqtWLa/bXbp0aW379u2mt/fcuXNapUqVXGpTZGRkvnX5et+Gh4drv/zyiynb5dlnn9VERIuLi9N9vH379pbbl5rm3v40Mqq9xho1aji8T+Guw4cPu7QuZ3yxXyZNmuTVayzI7t27tSpVqnjcPl9tl9mzZ+uua8iQIR7XWbRoUW3JkiWGbs/r31M9d+6c7nP+H3v3HV7j/f9x/HWyJBIiQYzQql0lYo/ao6hVSrVmq8Pu0Br98qWUanXRodpaJS21Ss2apagWETFLbVozRJDIOr8/vpf8HDknkrMPz8d1vS/uz+e+35/3Gfc4J/e575o1azp9/Zbccx33lH2AI7YDZcqUMZ4+fdohj/22c+fOGStVquTx7xNHRnBwsHHLli0OfZzffvutTZ/5PXE/YDR6zr5A8sxjCk993osWLWq8cOGCTc/13dLT043PP/+8UZJxwoQJmfoTEhKsfuzuuq2+M0qVKmU8ceKEQ2qbPHmyUVKmv9fe5opjmgf52MFZ6+mD+L6SPOMYyBO2oZZIMnbu3NmYnp5u1/qNRqPx5s2bxpYtW9r0+nti3VnVbM/InTu3MT4+PsvHEhsb65L19l7hSfuMrCJXrlzGy5cvW6zl7NmzFs8Bu1+fL0ucmcPTn6+hQ4caJRlfeOGF+3ob5255zIUzP4/eKzx5m+9Jr/ndYe5Y3trjeHf8nssSR78X3PXzvCfsPzzhs5E7v8Z3xoP42ZogPCkMBoOxZs2anE9LEESOwhaurp0gCPcNfldCEARBEARBEARBEARBEARBEARBEARBEARBmIvmA2Ucuvr/o/lA19f0oEfu3LmN+/bts+l8wjtNnz49y/E2btxodrmsfnOaHdOmTbvnY50xY4ZNY2TFnr/BJQiCsCW4Vrt7BefUEoT7B9dqd7/gWu1Zc4drnd4Zo0aNMlvnqFGjHDYm1zG1fwwbNsxszYcPH3ZpXU888YTF57Nz587ZynG/bCOzel+56/Xkboe7r7OW4oUXXshy3LJly9qUPyYmxmLuNWvW2PWxuPu1TCxx9Hrl7s+LxDVeXLF+OnPdlNx/G2mJo19jR47r7e1t3L59u8UxBg0a5LIa3fX94AnXF7s7PGX7+aB8jrTE0/OYC3ttY26HJxyv2DM8Zd31lNfJXbcxltjy3vGU+3M54rFbClvv7eBu94B09vvaaHTde9teebKKVatWmR3jiSeesNsYgwcPNjvGnetWTsLe97FwxH2ALMnu8p543H07nHUdcktsqd1dP4c5e7twO+6n/YenrFPOfK649xNBEATxIAbXaicIwpqwhatrJwjCfYPflRAEQRAEQRAEQRAEQRAEQRAEQRAEQRAEQRDOiPr16xs3b95sNBqNxujo6CzPUalatWrG+W9Z/favbt26JufKLV++3OGPY9asWSZjTpo0KdM8TZo0MZknLi7O6O3tbfWYPj4+xri4OJOcjRo1Mjtvr169TOYbNmyY1ePmz5/fmJKSYpLPHtdFJAiCIP4XXKvdvYJzagmCIAiCIAiCIAiCIAiCIAiCIAiCIAiCIAiCIAiCIJwbXKudIAhrIju8BAAAAAAAAAAAAAAAAADwOOHh4SbT+/btU3p6uk05+/Tpo8cff1w1a9bUvHnzlJaWZlO+evXqady4cRnT27dv1/Dhw23KmRMHDhxQnz59VKxYMX3++edW5di3b5/JdFhYWJbzFylSxGR69+7dVo1793J357WnUaNGKU+ePBnTp06dsvr5AgAAANzZv//+qyZNmmjw4MGKj4936tjXr1/Xxx9/rFKlSmnq1KlOHdudHTp0SFWqVNGSJUscPtb8+fNVtWpVHT161OZcly5dUqNGjRxa95kzZ1SvXj2dPXvWYWM4UnJyslq1aqXjx4/bLWdKSor69OmjDz/80G45nfFaSq59PT3tMR4/flwdO3Z0+nba2UaMGKGXXnpJN27csHvuFStW6PHHH9fp06ftntsTXLt2TU899ZT69Omjy5cv25Tr8uXL6tatm4YMGWKn6uzPHddxT9kHOMKRI0dUp04d/fnnnw7JHx0drerVq2vv3r05Ws4d3yeOFB8fr2bNmmnGjBl2z52enq733ntPL7/8soxGo9V52A843oNyTOEO/vnnH9WvX98un7Wk/61nAwcO1KxZs+yS727uuq2+09GjR/X4448rOjrajpVJ77//vl577TW75rSHB/nYwZketPeV5BnHQJ62Db3bggUL9OyzzyopKcluOc+fP68nnnhCq1evtlvOu3lq3fZy8+ZNzZ07N8t5HHEsbQ/3yz7j1q1bioqKstg/c+ZMm88Bk+6f58tZ7pfna+bMmXr++eeVkpJit5yetI1zB+70edSTt/n4H0/4nstZ3PXzvCfsPzzhs5Hkvq/xnR7Ez9YAAAAAAAAAAAAAAAAAAAAAANyvxowZo8cee8xu+Z5//nmVLVs2x8uFhobaNG7v3r1VpkwZi/3NmjXTCy+8YNMYAAAAuP9wrXb3w7XaLXOXa526Gtcxtb9XXnnFbPu0adOcXImptWvX6tSpU2b7+vbt6+Rq3Je7X0/OU9fZJUuWWLx+1eHDh3X48GGb8v/8888W+xYsWGBT7rt5wrVMXMETnheu8WKeI9dPZ66bkuduIz1ZWlqaunbtqoSEBLP9H374oSIiIpxc1f+46/vBE64vdjdP2X7yOfL+Y+9tjCccr9iTp6y7d3PX1+lB2sY8aPfnepB5yjVFYX/2vI+Fs+9hkV2eeNx9mztdhzyn3PVzGGznyeuUp/DU43cAAAAAAAAAAAAAAAAAAAAAAID7kZ+fnxYtWqT69etLkqpUqaI33njD5rxdu3Y1mY6JibE4b2RkpObPn6/PPvvM6vGKFi2qTp06mbT98ssvmebbs2eP0tPTM6ZDQkL09NNPWz1ux44dFRISkjGdlpZm8ffdCxcuNPk93Ztvvqk8efJYNe7IkSPl4+OTMR0TE2OX31ICAAAAAAAAAAAAAAAAAAAAAAAAgKN4uboAAAAAAAAAAAAAAAAAAEDO+fr6mkwnJSXZnDM2Nlbbtm2zOY8kFShQQPPmzZO3t7ckKS4uTs8884xSU1Ptkj8n4uLidPPmTauWvXs5Pz+/LOfPnTu3yfS1a9esGvfOi6dLUmBgoFV57qVkyZLq06ePSdvIkSOVnJzskPEAAAAAV0tPT9enn36q0qVLa+LEibpy5YpDxzt06JCGDBmiYsWK6a233tLVq1cdOp4nunr1qjp06KDWrVvrwIEDds+/d+9etWjRQl26dFFCQoLd8iYkJKhDhw7q3LmzTp06Zbe8RqNRUVFRqlGjhv766y+75XWF8+fPq1atWlqxYoXNuWJjY1WzZk198803dqjMlKNeS8l9Xk9Pe4zr1q1TzZo19dtvv9kln7uaPn26KlWqpNWrV9sl37///qsePXqoTZs27G8kffPNNypRooRGjBiR45sJXrhwQWPHjlW5cuX0ww8/OKhC+3HHddxT9gGOcObMGdWrV08jRoyw+nvpu928eVPDhg1TzZo1debMGatyuOP7xJGSkpL04osvql27djp27Jhdch49elTNmzfXiBEj7JKP/YDjPSjHFO7gr7/+Us2aNbVq1Sqb8ly8eFEtW7bUlClT7FSZee66rb7T2bNnVatWLY0dO1a3bt2yKdelS5fUvn17vf322zbX5SgP8rGDMz1o7yvJM46BPG0berf58+erdu3aiomJsTnXggUL9Nhjj2nLli22F3YPnlq3vWS1jUxJSVFUVJQTq8mZ+2WfYWlMo9GoadOm2W2c++X5cpb75fmaPXu26tatqyNHjticyxO3ce7AnT6PevI2H//jCd9zOYu7fp73hP2HJ3w2ktz3Nb7Tg/jZGgAAAAAAAAAAAAAAAAAAAACA+1GuXLksXi//999/14svvqgqVaooPDxcJUqUUKtWrfTLL79YzOfl5aX+/fvbXNf58+c1c+ZMjRs3Tp9++ql+//33LOc3GAwaMGCAxf4JEybcc8y//vpLX3/9td5991198cUX2rlzZ47rBgAAgOfhWu3uh2u1m3LHa526GtcxtZ/mzZurZMmSmdpTU1P13XffuaCi/2c0GjVr1iyzfY0bN1bp0qWdW5Abc/fryXniOnvlyhVt2LDBbN/PP/9sc/6lS5eabU9LS9NPP/1kc/67ecK1TFzBE54XrvGSmSPXT2evm5JnbiM93bFjxzRw4ECzfbly5dKPP/6ogIAAJ1f1P+76fvCE64vdzVO2n7c/R7rzNdGQM/bexnjC8Yo9ecq6ezd3fZ0etO+qHqT7cz3IPOWaorA/e9zHwlX3sMguTzzuvs2drkOeU+76OQy28+R1ylN46vE7AAAAAAAAAAAAAAAAAAAAAADA/SY5OVkfffSRSdvEiRP11FNPWZ2zXr166tOnj0nb4sWLzc67ePFi7d69W507d1b//v3VtGnTHI/n6+ur7777ToGBgRltcXFx2rhxY6Z5L1++rK1bt5q0ffzxxypcuHCOxy1SpIg++eQTk7YtW7bo8uXLZue/ceOGpk2bljFdsGBBRUVFyWAw5Gjctm3b6tVXXzVp+/DDD3OUAwAAAAAAAAAAAAAAAAAAAAAAAACczcvVBQAAAAAAAAAAAAAAAAAAcu7KlSsm02FhYS6qxLyoqCiFh4dLkoxGo3r27KnTp0+7uKqcy58/v8n0tWvXspz/xo0bJtMhISFWjRsaGmoynZCQYFWee5kwYYJ8fX0zpvfs2aOoqCiHjAUAAAC4k0uXLmnYsGEKDw9Xjx49tHjx4kzH89ZIT0/Xjh07NH78eFWvXl2PPvqoPvroI8XHx9uh6vvbypUr9dhjj6lVq1aaP3++rl+/bnWuhIQEzZs3T0888YQiIiK0Zs0aO1ZqauHChXrkkUfUuXNnrVu3Trdu3bIqz5UrVzRjxgzVqlVLPXr00Llz5+xcqWtcvHhRbdq0UefOnbVly5YcLx8dHa1nn31WkZGRiomJsX+Bd7DXaym57+vpSY/x8OHDatCggWrVqqWvv/5asbGxSk9Pt+sY7uD48eNq1aqVatSoofnz5+vmzZs5zhETE6M+ffqoRIkSfK9zl+vXr+u9995T6dKlVbVqVQ0cOFAzZszQunXrtGPHDh08eFC7d+/W5s2bNWfOHL399tuqU6eOihQpotGjR5u9+WGuXLnMjpWamuroh3NP7raOe9I+wN5SUlL03nvv6ZFHHtH48eN15swZq/KcPn1ao0aNUvHixTVx4kSlpaXZXJu7vU8cbdmyZSpXrpy6deumrVu3ymg05jjHnj171KdPH5UrV04bNmywa33sBxzvQTmmcAdxcXF68skn1aRJE/3+++85Wvbq1av68MMPVbp0aa1du9ZBFZpy5231bampqRo9erRKlCihjz/+WBcvXszR8hcuXNDYsWNVsmRJ/fzzz3ary1Ee5GMHZ3rQ3le3ufsxkKdtQ++2Z88eVa9eXb169dLBgwdztGxSUpIWLFigqlWr6plnnrF4E3pH8NS67SE6Olq7d+8227dixQpdunTJyRXlzP2wz9i/f7+2b9+eqX3t2rU6ceKEXce6H54vZ7pfnq+dO3fqscceU79+/XTs2LEcLevp2zh34S6fRz19m4//5+7fczmLu36e95T9h7t/NpLc9zW+04P62RoAAAAAAAAAAAAAAAAAAAAAgPvJq6++qgoVKujHH380+a3O+++/r7p162rGjBmKiYnRP//8o5MnT2r16tVq2bKlfvzxR4s5GzdubHU96enpGjNmjIoVK6bevXvrv//9rwYPHqy6deuqffv2Wf4OpGnTpmbbq1SpourVq1tcLj4+Xp06dVL58uXVt29fjRo1SoMGDVKNGjXUoEEDnT171urHAwAAAM/BtdrdD9dqd/9rnboS1zG1j759+5ptX7Fihc6fP+/kajKbPn262WuLGAwG9enTxwUVuS93v56cJ66z8+fPN9u+dOlSm3Pv2rVL//77b6b2TZs2OexaSJ5wLRNX8ITnhWu8ZOao9dMV66bkmdtITzd79mzNmzfPbF/58uU1efJkJ1f0/9z1/eAp1xe7kydtP939mmjIGXtvYzzheMWePGndvZM7v04P0ndVD9r9uR5knnBNUdiftfexcId7WGSXJx533+Yu1yG3hrt+DoPtPHmd8hSeevwOAAAAAAAAAAAAAAAAAAAAAABwv/n0009NfgPj7e2tRYsWadSoUfLz88tRrh49emjVqlXy8fHJaFu+fLmio6PNzn/nb6u9vb21bNkyde/ePdvjFSlSRKtWrVKzZs1M2kePHq2kpCSzy4wfP95kulixYtq4caMee+yxbI9bsWJFbdiwQeHh4Vnmvtt7771ncs3ydu3aaenSpQoODs7WuC+++KLmz58vLy+vjLZt27Zp7ty52a4dAAAAAAAAAAAAAAAAAAAAAAAAAFzBYDQajdma0WBwdC0APFRERIQiIiIkSUajUceOHdP27duVzc0LAAAAAAAAAAAAAAAArBASEqLLly9nnNuVmpqqQoUKKS4uLtO8VatW1a5duyRJH330kYYMGeLQ2oYPH64JEyZkTN89ZoMGDbRp06aM6alTp6pfv34OrclaXbp00bx58zKmDx06pEcffdTi/G3atNGyZcsypvfv36+KFSvmeNz9+/erQoUKJnlXrFiR4zxZqVatmnbs2GFyfmCLFi20Zs0au44DAHAcg8Gg6tWrq2zZshnb89jYWMXGxrq4sgcT59QCns/Hx0cVK1ZUjRo19Oijj6p48eIqXry4goKClDt3bvn7+0uSEhMTlZSUpISEBJ09e1Znz57VkSNHFBMToz179ujatWsufiT3h1y5cql69eqqXbu2KlSooIcffliFCxdWQECAAgICJEk3b95UYmKizp07p5MnT2r//v36448/tHPnTiUnJ7uk7ty5c6thw4aKiIhQ+fLlVapUKeXJk0dBQUEKDAyU0WjU9evXlZCQoGvXruno0aOKiorS1q1blZqaarc6Nm7cqEaNGmVMu8tvw8qVK6d69eqpTp06Kl26tPLly6eQkBD5+voqISFBV69e1cGDB7V7926tWLFCf//9t8tqtea1vH0sZu/X01E87TEGBgaqSJEiJu8bcxITE7Vx40an1mYv/v7+at68uWrWrKmIiAiFh4crODhYQUFBunXrluLj4xUXF6f9+/drz549WrNmjU6ePOnqsh8YXl5eSktLM9tXoUIFHTx40MkVZc3d1nFP2gc4QvXq1VWvXj1Vq1ZNDz/8sMLCwhQYGCgfHx8lJyfr2rVrunr1qv766y/t379f69evd8rne3d7nzha4cKF1ahRI9WuXVulS5fOON4PCAhQenq64uPjdfXqVR06dEjR0dHasGGDU9dt9gPO8SAcU7iD4sWLq0WLFmrUqJGKFi2qggULKjQ0VKmpqbp69aouXLig3bt3a+vWrVq1apXLPsPdyV231bd5eXmpQYMGqlevnipXrqwSJUpkbCNu3rypa9eu6fTp04qJidHmzZu1ceNGpaenO60+e3vQjx2c5UF7X93m7sdA7rQNtfQ3jqy+a6pYsaKefPJJRUZGqmzZssqbN6+CgoKUlJSk+Ph4nTt3TrGxsfrzzz+1evVq3bhxg7pdYN26dWratGmm9nbt2pmc9+IJ2GfkDM9Xztwvz1e1atXUvHlzRUZGqlSpUhn7+/t1G+euXPV59H7a5uP/ufv3XM7kjp/nPWX/4e6fjW5zx9f4Tg/qZ2vA3RgMBtWoUUNlypThfFoA2WbLOd7ucj4eAPfD70oAAAAAAAAAAAAAAABgTvOBUpU2/z+9e7m09gvX1QNTlStX1nvvvSdfX1898cQTWc5bsmRJHT161Gyf0WhU7ty5lZSUlKnv7msD3u2///2vxo0bl2X/2LFjLY6bN29eXb9+3aR91KhRGjNmjNllUlJSVK9ePf35558WxyxZsqRiYmKUJ08ei/M0bNhQmzdvttgPAM7CtdrdC+fUAp6Pa7W7F67VjqxwHVPcz+7H68mxzroHd7+Wiau4+/PCNV7uf2wjcSd3fT94yvXF7uQp209PuSYaXMvdj1fsyVPWXXPc9XWydjvz1VdfPXDbGE+7P5ejuOs9IO/E/vPBZO4+Fnnz5nXb+wBZwxOPu+/kqffFctfPYZ7GHfcfnr5OeQJPPn4HANx/uFY7AGtwrXYAjsDvSgAAAAAAAAAAAAAAAOAsZcuW1ZYtW1SwYEGT9tOnT+vbb7/V8uXLtWfPHkVGRmrXrl2SpI8++kgjR45U+fLl1bhxY/Xu3VuVKlUyWf7ChQuqWbOmxd9R5cmTR9HR0SpdurRJ+65duzRz5kxt3LhRR44cUUpKSkZfYGCgatasqaefflq9evVSUFCQybKbNm1S06ZNLf7WV5Lmzp2rZ5991qQtOTlZCxcu1A8//KAdO3bowoULJv1hYWGqUaOGunbtqk6dOsnPz8+k//vvv1f37t0tjnlbw4YNtWHDBnl5eWW0Xb58WZMmTdJPP/2k/fv3m8wfGhqqZs2a6fXXX1edOnVM+i5cuKBatWrpxIkT9xwXAJB9XKvdvXBOLQAAAAAAAAAAAAAAAAAAgHNxrXYA1sjOOd4GYzbPBOfi7QAs4YcmAAAAAAAAAAAAAAAArrF3715VrFgxY/rLL7/UwIEDM81XtWpVkwuZDxkyxGE11atXT7/++qu8vb0lSb///rvq169vcoHyBg0aaNOmTRnTU6dOVb9+/RxWky02b96s+vXrZ0zPnj1bvXr1sjh/UFCQLl68KH9//4y2Vq1aafXq1Tka985zbxITExUWFqbr16/nKMe9bNiwQY0bN86YXr9+vZo1a2bXMQAAjsXF290L59QCANzJnZ9n09LS5OPj4+KKAMDz5cuXT1euXDHbV7hwYZ0/f97JFQEAAACAY1n6G4e7X4fIU+t2lvDwcJ06dUpeXl4m7efPn1d4eLjJOT4AAM/GNh8AADwouHg7AGvYco433zUCsITflQAAAAAAAAAAAAAAAMCc5gOlKm3+f3r3cmntF66rB+b5+fkpOTn5nvOdPXtWRYsWNdtXrFgxnT17NlP7xo0b1ahRI7PLnDx5Uo888kiW5xkVLFhQ58+ft3gOY+nSpXX06FGTtvXr16tJkyZm5//666/Vt29fi+PdNnjwYH388ccW+xs2bKjNmzffMw8AOBrXancvnFMLAAAAe+B6cgAAAAAAOB/35/of7gEJALAG+w8AAOBqXKsdgDW4VjsAR+B3JQAAAAAAAMD9JzIyUr/99psk6bPPPtOIESNcXBEAAAAAAP+vUqVKWrFihYoXL262PzU1VXFxcQoLC5Mk3bp1S35+fhbPg7tw4YKaNm2qffv2ZTluqVKltHbtWj3yyCNm+9PT05WQkKBbt24pT548CggIsJhr165daty4sRISErIc08/PT8uXL1fz5s0tzpOSkqL4+HhJUnBwsHx9fS3Ou3r1arVr104pKSlZjntbp06dFBUVpVy5cmXqS0xM1MWLF5WcnKzQ0FCFhISYfY7PnTunVq1aKSYmJltjAgCyj2u1uxfOqQUAAAAAAAAAAAAAAAAAAHAurtUOwBrZOcfbywl1AAAAAAAAAAAAAAAAAAAcYNasWSbTAwYM0Lvvvitvb2+X1FOgQAHNmzcvY/y4uDg988wzSktLc0k9tnrllVdUv359k7Yffvghy2WuX7+u7777zqRt9uzZeuyxx7I97qOPPmoy/d133+n69evZXj47WrRoocaNG2dMG41GDRkyxK5jAAAAAABcJ1++fBn/v3btmusKAYD7SLly5cy2p6Sk6Pz5806uBgAAAAAA6/Ts2VNeXpkvOxUVFeWx5/gAAMxjmw8AAAAAAAAAAAAAAAAAAAAAAAAA2ZOcnHzPeYKDg7O8tl9oaGiOx507d66MRmOW81y8eFEnTpzI0bjly5e3OH9UVFS2apszZ45SU1OzNS8AAAAAAAAAAAAAAPBs3J/rf7gHJADAGuw/AAAAAAAAAAAAAAAAANyvvLy8FBQUpKCgIPn5+bm6HAAAAAAATOzdu1eRkZEWr/Xt4+OjsLCwjOlcuXLJYDCYzbVo0SJVrFhR+/btu+e4R48eVc2aNS1e79vLy0vBwcEKCwtTQECA2XmMRqMmTZqkxx9/XAkJCfccMzk5Wa1bt9bYsWMtXjvc19dXBQoUUIECBeTr62t2npSUFI0ePVpt27ZVSkrKPce9beHChWratKmOHj2aqS8gIEAPPfSQSpcurdDQULPP8erVq1WtWjXFxMRke0wAAAAAAAAAAAAAAAAAAAAAAAAAcCUvVxcAAAAAAAAAAAAAAAAAALDO1KlTdfz4cZO2kSNHav/+/Xr11VdVqlQpp9YTFRWl8PBwSf+7SHmPHj105swZp9ZgL126dNGXX35p0rZz506tWbPmnsuOHDlS58+fz5guWLCgduzYoREjRqhgwYIWl8ufP7+GDx+unTt3ZrSdP39e//3vf614BJYZDAZNnDjRpG3u3LnavXu3XccBAAAAALhGUFCQypUrlzF97tw5F1YDAPePmjVrmm0/dOiQkysBAAAAAMA6BoNBr7zyitm+b775xsnVAAAciW0+AAAAAAAAAAAAAAAAAAAAAAAAAOSMt7e3SpcurSeeeEJ9+vTRxIkTtXDhQu3atUtXrlzR1atXVb58eYvL+/r65njMffv2ZWu+rK4pGBAQYDLt7e2tokWLmp3XaDRq165d2Rrz4sWLXGMLAAAAAAAAAAAAAIAHBPfn4h6QAADrsP8AAAAAAAAAAAAAAAAAAAAAAAAAXCcuLk5du3ZVZGSkpk6dqkuXLmV72QsXLmjGjBmqUqWKOnXqpIsXL2Z72UuXLqlHjx6qUqWKZs6cqbi4uGwtd/36dU2bNk2VKlXSG2+8oVu3bmV7zJSUFI0ePVoVKlTQxx9/nKN6L168qI8++kiPPvqoxo4dq9TU1Gwve9vWrVtVvnx59evXL1vXV09LS9PatWvVqlUrtWrVSv/880+OxwQAAAAAAAAAAAAAAAAAAAAAAAAAV/FxdQEAAAAAAAAAAAAAAAAAAOvcuHFDHTt21MaNG5UvX76M9nLlymny5MmaPHmy4uLidObMmYy+IkWKqHDhwjp37pxdaxk+fLhatGiRMf3hhx9q5cqVdh3DGXLnzq333ntPr776qgwGQ0b7jRs39OKLL8poNN4zx6VLl9S6dWutXbtWISEhkqSAgACNGzdOY8aM0YEDB3T48GHFx8fLaDQqODhYZcuW1WOPPSZvb++MPFeuXFHr1q1zdGH67OjevbsiIiIyppOTkzVixAi7jgEAAAAAcJ2PP/5Yfn5+GdN//vmnC6sBgPtHs2bNzLbv2rXLyZUAAAAAAGCdNm3aqESJEpnaN2/erMOHDzu/IACAw7DNBwAAAAAAAAAAAAAAAAAAAAAAAIB7K1WqlHr06KHWrVurUqVKypUrl1PHP3/+fLbmu3XrVrZzBgYGWuy7fv26EhMTs53r3LlzqlixYrbnBwAAAAAAAAAAAAAAnon7c3EPSACAddh/AAAAAAAAAAAAAAAAAAAAAAAAAK4XGxurfv36qX///ipfvryqVaumYsWKqVKlSuratask6Y8//tC8efN05swZ7du3T4cOHbJ53JiYGPXu3VteXl6KjIxUhQoVVLJkSeXNm1eBgYG6efOm4uLidOHCBe3YsUOxsbFKT0+3acwjR47orbfe0ltvvaXSpUurRo0aKl68uPLly6fg4GBJUnx8vK5evarTp09rx44d+vvvv21+rJKUmpqqqVOnaurUqSpatKgaNmyookWLKiwsTHny5NGNGzd08eJFHThwQNu2bVNcXJxdxgUAAAAAAAAAAAAAAAAAAAAAAAAAZ/NxdQEAAAAAAAAAAAAAAAAAAOvFxMSoVq1aWrBggSIiIjL1h4aGKjQ0NGO6W7du6tatm65du6bo6Gj98ccf+vnnn7Vt2zara6hXr57GjRuXMb1t2zb95z//sTqfK3h5ealnz54aN26cwsPDTfpu3rypjh07KjY2Ntv5du3apapVq+rLL7/Uk08+mdHu7e2tSpUqqVKlSlkuv3LlSvXv318nT57M2QO5Bz8/P5PXSpK+/PJLnThxwq7jAAAAAACcz8fHR1988YVeeeUVk/ZZs2a5piAAcJHAwEDduHHDrjnDw8PVunVrs32//PKLXccCAAAAAMBRRo8ebbZ98uTJTq4EAOBobPMBAAAAAAAAAAAAAAAAAAAAAAAAwLKgoCBNmjRJzz//vLy9vV1WR3Jyst1z+vv7W+y7efNmjnLFxcXZWg4AAAAAAAAAAAAAALAj7s9lf9wDEgBgDfYfAAAAAAAAAAAAAAAAAAAAAAAAgPsxGo06ePCgDh48KEmqWrWqunbtKkn67bffNGnSJIeMm56erujoaEVHRzskvyV///23/v77b6eOeds///yjuXPnumRsAAAAAAAAAAAAAAAAAAAAAAAAAHA0H1cXAAAAAAAAAAAAAAAAAACwzeHDhxUZGakePXqoT58+qlu37j2XyZs3rxo1aqRGjRpp2LBhOnbsmEaPHq2oqKgcjV2gQAHNmzdP3t7ekqTLly+rS5cuSktLs+qxuELnzp317rvvqly5cpn6Tpw4oU6dOmnXrl05zlu6dGkVK1bMqpqKFSumMmXK6OTJk1Ytb8nAgQP10EMPZUzHx8dr3Lhxdh0DAAAAAOB8hQoV0oIFC1S/fn2T9rlz5+rXX391TVEA4GReXl4aOXKk+vbtq8jISF24cMFuuYcPH57xHeidkpKStHr1aruNAwAAAACAo/To0UPVqlXL1H7s2DH99NNPLqgIAOAobPMBAAAAAAAAAAAAAAAAAAAAAAAAwLICBQpo06ZNqlChgqtLcXtGo9HVJQAAAAAAAAAAAAAAAHF/LkfhHpAAAGuw/wAAAAAAAAAAAAAAAABwv6pSpYo6deqkiIgIlSxZUiVKlMjoGzhwoNq2baujR49q27ZtWrVqlaKjo3M8ho+Pj3r37m23mhMTEzVnzpws5ylZsqSaNWtmtzHvtHPnzhw/D/nz51fnzp3VtGlTVaxYUeHh4QoMDJQk3bhxQ2fPntXevXu1fv16LVy4UJcvX3ZE6QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAs8HF1AQAAAAAAAAAAAAAAAAAA2xmNRs2ePVuzZ89WeHi4ateurVq1aikiIkKVK1dW4cKFs1y+ZMmSmjNnjnr27KlOnTrp2rVr2Ro3KipK4eHhGTX06NFDZ86csfnxOMOTTz6p8ePHKzIyMlNfenq6pk2bpjfffFPXr1/Pce4xY8bov//9rwwGQ6a+y5cv68yZMxnPcd68eRUeHq4CBQpkzBMREaE1a9bo3Xff1ejRo3M8vjl58+bViBEjTNomTJiguLg4u+QHAAAAALhGeHi4duzYoSJFipi0r1692q432AYAd1a8eHH98MMPqlevniRp8eLFatasmZKSkmzO3bRpUw0YMMBs348//qirV6/aPAYAAAAAAI5UunRpTZ482Wzf2LFjZTQanVwRAMBR2OYDAAAAAAAAAAAAAAAAAAAAAAAAQNYWLlyoChUqZHv+S5cu6ejRo/r777/VvHlzhYWFObA62926dctin7+/f45y5c2b19ZyAAAAAAAAAAAAAACAjbg/l2NwD0gAgDXYfwAAAAAAAAAAAAAAAAC43/j4+Khv3756/fXXVapUKYvz+fv7q1y5cipXrpyefPJJjRs3TrGxsXrnnXf0008/ZXu8kJAQff311/YoXZJ07tw5zZkzJ8t5qlevbtcx7zR69GhFR0dna96QkBCNHz9eL774ovz8/MzOkydPHpUvX17ly5dX586dNXnyZE2bNk0jR468r8/vBgAAAAAAAAAAAAAAAB5UgYGBypcvn7y9vc32nzp1yskVAQAAAAAAAAAAAAAASfJxdQEAAAAAAAAAAAAAAAAAAPs6e/asFi1apEWLFkmSqlatql27dkmSNm7cqF27dikiIkK1atVScHCwybLNmzfX+vXr9fjjjys5OTnLcYYPH64WLVpkTE+cOFGrVq2y86OxvwYNGmjChAmqW7eu2f5169bprbfe0p49e6zK/+abb2rUqFEmbefPn9fkyZP1448/6tixY2aXK1GihLp06aLXX39dhQsXlsFg0KhRo3Tt2jV9/PHHVtVyp6FDhyo0NDRj+syZM5o8ebLNeQEAAAAArnX27Fn9/vvv6tixY0bbtGnT1L9/f6WkpLiwMgBwjg4dOmjGjBnKly9fRtvjjz+uNWvWqGPHjrp06ZLVuZs0aaJFixbJYDBk6ktNTdX48eOtzg0AAAAAgDPUrFlTCxYsUEhISKa+gwcPas6cOS6oCgDgCGzzAQAAAAAAAAAAAAAAAAAAAAAAACBrbdu2VcOGDS32Hzt2TMuWLdOff/6pQ4cO6ejRo4qPj8/o37lzp8LCwpxRqtVu3LhhsS9v3rzy8fFRampqtnIVKlTIXmUBAAAAAAAAAAAAAAArcH8ux+EekAAAa7D/AAAAAAAAAAAAAAAAAHA/KV26tBYsWKDIyEirlo+IiNDixYu1YsUK9ejRQ1euXLnnMkFBQVaN5enq1KmjxYsXq3DhwjlaLleuXBowYIA6dOigp556Sjt27HBQhQAAV4iMjNRvv/0mSfrss880YsQIF1cEAAAAAAAAAACysnHjRrPtjRs3dnIlAABPVapUKbVu3VoNGzZUrVq1FBYWJl9f3yyXMXfNSABA9nEcDwCOwfYVAAAAAAAAwIPAx9UFAAAAAAAAAAAAAAAAAACcZ9euXRoyZIgkycfHRy1bttSoUaNUo0aNjHmqV6+u9957T2+99ZbFPPXq1dO4ceMyprdu3er2NyQpXry4Jk+erA4dOpjt37Jli0aMGKHNmzdbPUaFChX0/vvvm7Rt2LBBzzzzjC5fvpzlsidOnNAHH3ygb7/91mTe999/X6tWrdKBAwesriskJESvvfaaSds777yjpKQkq3MCAAAAANzH888/r0qVKql48eJ6/fXX9fXXX7u6JABwmrJlyypfvnyZ2uvXr6/9+/dr+PDhioqKUkpKSrZzhoaG6q233tJbb71l8eLakydP1pEjR6wtGwAAAAAAuzEYDPL19ZXBYFBgYKDCwsJUtWpVde7cWW3btpW3t7fZ5fr166f09HQnVwsAsAXbfAAAAAAAAAAAAAAAAAAAAAAAAACwXvfu3S32jRo1Su+++26Wy+fJk8feJdldamqqzp8/r0KFCmXqMxgMqly5snbt2nXPPP7+/ipXrpwjSgQAAAAAAAAAAAAAANnE/bkci3tAAgCswf4DAAAAAAAAAAAAAAAAwP2gQoUK2rRpkwoUKGDSbjQatW/fPsXExMhoNKpnz56SpD179ujSpUuqXr26goODTZZp3bq1fv/9dzVo0EAXLlzIctzAwED7PhAXS01Nvec8DRs21OrVq+Xv75+p78SJEzpw4IDOnTsnSSpcuLAqVKigEiVKmMxXtGhR/frrr2rWrJl+//13u9QOAHA9Ly8vBQUFSZL8/PxcXA0AAPenf/75R6NHj5Ykbdu2zcXVAAAAAAAAT9eoUSNXl5Bjlv4GkZyc7ORKAODBVqFCBY0aNUqdO3eWl5eXq8sBgAeKJx7Hw30VLVpUpUqV0kMPPaSgoCAFBgbKx8dHycnJunbtmhISEnThwgXt27dPly9fdnW59w1/f39VqlRJRYsWVXBwsPLmzavcuXMrNTVV8fHxio+PV1xcnPbv36/z58+7utwHBttXAAAAy0qVKqUyZcooODhYxYoVk5eXl65fv65r164pPj5ep0+f1oEDB3J0rxlPxt+rAAAA4Ml8XF0AAAAAAAAAAAAAAAAAAMA1UlNTtXz5cq1cuVJffvml+vbtm9E3YMAATZw40ezNuvLnz6958+bJ29tbknTp0iV16dJFaWlpTqs9p1q1aqXvv/9eISEhmfp27NihESNGaO3atTaPM3bsWPn4/P+peXv37lXbtm118+bNbOeIi4tTbGysIiIiJEk+Pj5655139Mwzz1hd12uvvZZx8xhJOnLkiGbOnGl1PgAAAACAe0lISNBTTz0lb29v7d2719XlAIBTffTRR+rQoYNq1aqVqS8sLEwzZszQ+++/r+XLl2vz5s06fPiwzpw5oxs3bujWrVvy8fFRaGio8ufPrypVqqhJkyZq3bq18uTJY3HM3bt36z//+Y8jHxYAAAAAANnWuXNn/fjjjzla5osvvtCmTZscVBEAwFHY5gMAAAAAAAAAAAAAAAAAAAAAAACA9WrXrm22/d9//9W7776b5bIBAQF65JFHHFGW3R05ckSFChUy2/f0009r165d98zRrl07BQYG2rs0AAAAAAAAAAAAAACQA9yfy7G4ByQAwBrsPwAAAAAAAAAAAAAAAAB4uoCAAC1btkwFChTIaEtNTdXnn3+uSZMm6dSpU5KkqlWrqmfPnpKktWvXasiQIZKkpk2bavTo0apfv37G8uXKldPKlStVu3ZtpaamWhw7KCjIZHro0KFav3691Y8lq7FuW7NmjapVq2b1GLe98MILGjhwYMb0rVu3FBUVleUyhQoV0k8//SR/f3+T9mXLlumdd95RdHS02eWqVq2qMWPGqE2bNhltuXPn1tKlSxUWFmbDowAAAACAB8u5c+c0duxYV5cBAAAAwEVeffVV5cuXz275kpOTlZSUpEuXLuncuXP6+++/dfLkSRmNRruNAQD2VLZsWf31119m+8qVK6fDhw87uSIAeDB16dJF3333nXLlyuXqUrLF3HH0kSNHNHfuXKfX0r9/f5Pz3G6bOHGikpKSLC7Xu3dvFStWLFN7SkqKJkyYYNcac+rJJ59U9erVM7WfOXNGM2bMyHJZS59xFi5cqAMHDuS4Fnt+ZkpPT1diYqISExN16dIlnTp1SidPntS///5rl/w5Ze/nyhZvvPFGpuvA/vXXX/rxxx+dWoctChcurFdeecXVZViUnfUHsFZoaKieeeYZPfHEE6pfv77Z/ZIl58+f159//qklS5bo559/1qVLlxxY6f3F29tbTZs21TPPPKO6deuqbNmy8vb2ztay//zzj3bu3KmffvpJixYtUkJCgoOrBQAAAKSKFSvq2WefVaNGjVS5cuVMv6M0JyUlRQcOHND27ds1f/58/frrr0pPT3dCtc7F36sAAADg6XxcXQAAAAAAAAAAAAAAAAAAwLXS09M1YMAA1ahRI+MmWP7+/urYsaOmTp2aaf7vv/9e4eHhkiSj0agePXro7NmzTq05Jzp37qy5c+dm+kH3nj179N///lfLli2zyzh58+ZVu3btTNpef/113bx5M8e5Xn/9dW3YsCFjun379sqTJ49VPy738/NT//79Tdref//9+/KHPgAAAADwIHP2hSgBwF2kpaWpTZs22rZtm8qUKWN2nrCwMPXu3Vu9e/e2ebxjx47pySefVHJyss25AAAAAABwhY0bN2rw4MGuLgMA4ARs8wEAAAAAAAAAAAAAAAAAAAAAAADg/4WFhZltP3Xq1D2X7dy5s3x9fe1dkkNs2bJF9erVM9vXv39/ffPNNzpx4oTF5YOCgjRhwgQHVQcAAAAAAAAAAAAAALKL+3M5HveABABYg/0HAAAAAAAAAAAAAAAAAE/25ptvqmTJkhnTCQkJat26tX777bdsLb9+/XqtX79e/fv31xdffCGDwSBJqlatmkaNGqVRo0ZZXDYoKMhkev/+/YqOjrbiUWTf1atXbR4jMDBQnTt3Nmn7/PPP73kduylTpigkJCRj2mg0ql+/fvr666+zXC46Olpt27ZV//799eWXX2a0FyxY0IrqAQAAAAAAAAAAHkxvvPGGSpQo4dAxrl+/rh07dmjt2rVavHix/vrrL4eOBwAAAM/Sp08fffXVVxnnWHkCc8fR6enpOnv2rDZv3uzUWgYNGqTy5ctnav/iiy+UlJRkcbmiRYtqzJgxZvs2b96srVu32q3GnPr8889Nzt+7beTIkfdc1tJnnEOHDll1bTRnfGa6cOGCduzYoQ0bNmjJkiU6duyYQ8e7zd7PlbWqVq2qTz75JFN7QkKCli9frhs3bjitFltktU65g+3bt2vGjBmuLgP3mUqVKmnUqFFq37691fezLlSokNq2bau2bdsqPT1dS5Ys0bhx47R79247V3v/KFCggIYPH64XXnhBoaGhVuUoWrSo2rVrp3bt2umrr77STz/9pFGjRunvv/+2c7UAAAB40Pn4+Ojll1/Wq6++avY7rHvx9fVV5cqVVblyZfXp00cXLlzQd999pw8++ECXL192QMUAAAAArOHl6gIAAAAAAAAAAAAAAAAAAK6Xnp6uSZMmmbQ1bNgw03zDhw9XixYtMqZ/+eUX3bx5Uw0aNMh2REZGmuQsWrRopnny5ctnl8dVrVo1ff/99/L29s5oi4+PV+/evRUZGally5bZZRxJqlGjhsmP98+dO6cNGzZYlWvjxo06d+5cxrSfn59q1KhhVa6nn37a5KZgFy9eVFRUlFW5AAAAAAAAAHd06dIlNWjQQNu2bXPoODt37lTdunVNvrsDAAAAAMCTrFy5Um3atFFKSoqrSwEAOBjbfAAAAAAAAAAAAAAAAAAAAAAAAAAwlZaWZra9UqVKyp8/v8XlihUrpokTJzqqLLtbuXKlxb7g4GCtWbNGjz76qNn+ggULatmyZSpZsqSjygMAAAAAAAAAAAAAADnA/bkAAAAAAAAAAAAAAAAAAAAA2NPLL79sMj1o0CD99ttvOc4zZcoU9e/f36Rt8ODBKliwoMVlAgMDTaYTExNzPK4rDB48WIUKFcqYvnLlisaPH5/lMs2aNVPHjh1N2v7zn//o66+/zva4U6ZM0ahRo0za6tSpk+3lAQAAAAAAAAAA4FhBQUFq3Lix3nvvPR06dEhbtmxR69atXV0WAAAA3EClSpU0efJkGQyGe86blpampKQks+EOvLy8NGfOHAUHB7u6lGyZNWuW0tPTzfb16tXLydX8v8cff9zsfULT09P13XffuaAixwsLC1Pr1q318ccf6+jRo9q1a5d69eolPz8/V5fmFH369DHbnidPHj333HNOrgZAduTLl0/fffed9uzZo06dOsnX19cueb28vNSxY0dFR0frp59+MjkvGZK/v7/GjRun48eP680331RoaKjd8j733HM6cOCAJk+e7DHHMgAAAHB/3bt315EjRzRlyhSVL1/eLjnDwsI0ZMgQHT9+XO+8844CAgLskhcAAACAbXxcXQAAAAAAAAAAAAAAAAAAwD1s27bNZLpYsWKZ5hk3bpzJdMuWLdWyZUubxm3Xrp3atWtn0lalShXFxMTYlNfLy0tRUVEmP6o/d+6cGjZsqMOHD9uU25zw8HCT6UOHDtmU7/DhwypcuHDGdNGiRa3K07NnT5PpWbNmKTk52abaAAAAAAAAAHdz7tw5NWrUSG+//baGDRum3Llz2y33rVu39PHHH2v06NFKTU21W14AAAAAAJzl/PnzeueddzR16lRXlwIAcDC2+QAAAAAAAAAAAAAAAAAAAAAAAABg3rlz51SqVKlM7blz59bq1as1cOBA/fHHHxntuXLlUocOHfTJJ5+oUKFCzizVJr/99psOHz6ssmXLmu0vU6aMYmNjtXDhQq1fv14XLlxQSEiIatWqpW7duilv3rxOrhgAAAAAAAAAAAAAAGSF+3MBAAAAAAAAAAAAAAAAAAAAsIfixYvroYceypi+ePGi5syZY3W+qVOnqlevXqpdu7Z27NihTz75RHFxcRbnDwoKMplOTEy0emxnKViwoIYMGWLSNn78eF29ejXL5fr27WsyvWfPHn3wwQc5Hn/8+PF65plnVLFiRUlSnz599Pvvv+c4DwDA9apUqaJOnTopIiJCJUuWVIkSJTL6Bg4cqLZt2+ro0aPatm2bVq1apejo6ByP4ePjo969e9ut5sTERJuOFUqWLKlnnnlGDRo0UPny5VWoUCEFBAQoNTVV169f18mTJxUbG6tVq1Zp2bJlunHjRo5yN2vWzOrasrJz506rnn8AAAAAAADg8ccf1/Lly7Vu3Tr17t1bp0+fdnVJAADAwR5//HGNHDkyU/tvv/2m9957zwUVwV3MmjVLuXLlMtt36dIlTZkyRStWrNDBgweVkJDg5Opy7qGHHtJXX32lrl27urqUezpz5ozWrVunJ554IlPfM888o0GDBunWrVtOr6tXr15m29euXaszZ844uRrXqFq1qmbNmqXx48dr+PDhioqKcnVJDhMUFJTl+tKvXz9NmzbNiRUBuJc6depo0aJFKlKkiEPHeeqpp1S/fn299NJLWrJkiUPH8gQVK1bUvHnz9NhjjzlsDF9fX7366qtq3bq12rdvr/379ztsLFfiswkAAPc39vXuISQkRDNnzlT79u0dNkaePHk0evRode7cWV26dNG+ffscNhYAAACAe/NxdQEAAAAAAAAAAAAAAAAAAPdw6dIlk+nQ0NBM83h7ezulluPHj9uco0ePHipfvnzGdHp6ujp06KDDhw/bnNscf39/k+mc3JzEnLsv2JM7d+4c58iVK5eaNGli0vbDDz/YVBcAAAAAAADgrlJSUjR27FhNmzZN/fv31wsvvKCiRYtanS8+Pl6zZs3SJ598olOnTtmxUgAAAAAAHCM9PV2JiYmKi4vTiRMntGvXLq1bt06//PKLUlNTXV0eAMCO2OYDAAAAAAAAAAAAAAAAAAAAAAAAQM789ttvKlWqlNm+6tWra/v27bp8+bLOnDkjf39/Pfzww5muP+8pxowZo++//95iv4+Pj5599lk9++yzTqwKAAAAAAAAAAAAAABYi/tzAQAAAAAAAAAAAAAAAAAAALBVeHi4yfS+ffuUnp5uU84+ffooKChI27Ztu+e8QUFBJtOJiYk2je0Mo0aNUp48eTKmT506pc8//zzLZQoWLKh27dqZtI0YMUJGozHH46enp2vEiBFaunSpJKlz58569dVXde3atRznAgA4n4+Pj/r27avXX3/d4jVRJcnf31/lypVTuXLl9OSTT2rcuHGKjY3VO++8o59++inb44WEhOjrr7+2R+mSpHPnzmnOnDk5Xq506dL66KOP1L59e7P9vr6+CgkJUUhIiCIjI9WzZ0/FxcVpwoQJ+uSTT7J1fFK9enW7PtY7jR49WtHR0Q7JDQAAAAAAgAdDs2bNtHv3brVv315bt251dTkAAMCBChUqpJYtW2Zqv379uguqgbto2LChqlatarZv7dq16tSpk0ee//Pcc89p+fLl+uGHH1xdyj1NmzZNTzzxRKb24OBgtWvXTgsWLHBqPbly5dIzzzxjtm/atGlOrcUdhIeHa86cOXrllVf03HPP6ezZs64uye66du2a6ZzJO1WtWlXVqlXTrl27nFgVAEvatGmj+fPnKyAgwCnj5c+fX4sXL9aAAQP01VdfOWVMd/Tcc89pxowZTrt/eKlSpbR9+/aMY5r7DZ9NAAC4v7Gvd72qVatq6dKlKlasmFPGq1Chgnbs2KE+ffpo9uzZThkTAAAAQGY+ri4AAAAAAAAAAAAAAAAAAGC9Zs2aKSUlRZs2bbI5V65cuUymk5KSbM5pjbi4OMXHx9uc56WXXjKZ/vHHH7V9+3ab81py9w+hgoODbcqXL18+k2lrLuZTvXp1+fn5ZUzHxcUpJibGproAAAAAAAAAd/fPP/9o5MiRGjVqlKpWrapGjRqpRo0aKlmypEqUKKG8efOafG8mSYmJiTp79qyOHj2qXbt2aePGjdq0aZNSUlJc9CgAAAAAwLUMBoOrS7CKp9Zti/nz52v+/PmuLgMA4ARs8wEAAAAAAAAAAAAAAAAAAAAAAADAerNnz9bzzz+f5Tz58+dX/vz5zfalp6crPT1dPj4+DqjOvn744Qf17t1bTZs2tSlPamqqRzxeAAAAAABw/3gQrycHAAAAAEBOcH8uAAAAAAAAAAAAAAAAAAAAANby9fU1mU5KSrI5Z2xsbLbnDQwMNJlOTEy0eXxHKlmypPr06WPSNnLkSCUnJ2e53BNPPGHyXF++fFmrV6+2uo6VK1cqLi5OoaGhyp07txo3bqylS5danQ8A4BylS5fWggULFBkZadXyERERWrx4sVasWKEePXroypUr91wmKCjIqrHs6bnnntO0adOUO3fuHC0XGhqqDz/8UK1bt1abNm1048YNB1UIAAAAAACAB92ZM2d09erVHC3j7e2t3LlzKygoSCEhIfLy8rrnMvnz59cvv/yiJk2a6M8//7SyWgAAAHiigQMHmm3/66+/1K5dO7uct+UqU6ZM0ZYtW3Tq1ClXl5KlpUuXZpxzdbdevXppwYIFTq2nffv2Cg4OztQeFxenn3/+2am13Et8fHyOz+3z9vZWQECAAgMDc3TPkfr16ys2NlbPPPOM1q9fn9NS3Vrfvn2zNc/LL7/shGpsk5SUpH379tmUIzg4WMWLF8/UnpqaqkOHDtmU+9ixYzYtD9SqVUsLFiyQv7+/xXmMRqO2bt2qX375RTExMTp48KCuXr2qa9euKSUlRb6+vgoKClKBAgVUrlw5RUREqFWrVqpTp468vb3N5jQYDJoyZUrGvw+anj17aubMmff8nu3atWtat26dNm/erIMHD+rkyZNKSEjQrVu35OPjo+DgYBUoUECVKlVSrVq11LZtWxUoUMBivqCgIC1cuFBNmzbV1q1b7f2wAAAAcJ+qWbOm1qxZY/b7nTulpaVpy5Yt2rRpk/bs2aNjx47p7NmzSk9PV0BAgPLmzauHHnpIjz76qOrVq6dmzZopb968FvP5+/tr1qxZCggI0Ndff23vhwUAAAAgG3xcXQAAAAAAAAAAAAAAAAAAIOfq16+v8ePHq379+tq9e7eqVasmo9FoU84yZcqYTP/777+Z5ilXrpxNY0j/+yHLnDlzMqZ//PFHjRo1KmM6JSXF5jFCQkL0+OOPm7RNmzbN5rxZOXfunMn0Y489Jm9vb6WlpeU4l4+PjypUqJBl/uyoW7euyfQff/yR4xwAAAAAAACAp0pPT9fOnTu1c+fOTH3e3t7KlSuXjEajkpKSbP5+FQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAO5r48aN+vnnn9WuXTurln/zzTc1bNgwFS5c2M6VOUbXrl21detWlS5d2qrlP/jgA7Vv317ly5e3c2UAAAAAAAAAAAAAAMBW3J8LAAAAAAAAAAAAAAAAAAAAQE5duXLFZDosLMyp4wcFBZlMJyYmOnX8nJowYYJ8fX0zpvfs2aOoqKh7LlejRg2T6eXLlystLc3qOlJTU7V8+XL17NlTklS9enUtXbrU6nwAAMerUKGCNm3apAIFCpi0G41G7du3TzExMTIajRnb9j179ujSpUuqXr26goODTZZp3bq1fv/9dzVo0EAXLlzIctzAwED7PpAcev755zVjxgwZDAaT9hs3bmjjxo06deqULl++LB8fHxUsWFARERGqXr26vLy8MuZt1KiRli1bpqZNm7rsd1GpqakuGRcAAAAAAADO8eabb2r+/PlWL58rVy6VKVNGVapUUdu2bdWqVatMfwe7LTAwUIsXL1ZERITi4uKsHhMArJGUlGT2OmW3+wAAjtOkSROz7cOGDfP4bXBwcLCioqLUsGFDt77WZXJysr7//nsNGjQoU1+LFi0UFhZ2z7/B21OvXr3MtkdFRSk5OdlpdWTHK6+8YvVnJh8fH4WHh6ts2bKqUaOGmjZtqgYNGsjHx8fiMqGhoVq5cqWeffZZ/fTTT9aW7VaqV6+uKlWq3HO+5557ToMHD1ZCQoITqrLegQMHVKlSJZtydOzYUYsWLcrUfunSJZtzA7bIkyePFi9eLH9/f7P9aWlpmjp1qj744AOdPn3aYp6UlBRduXJFV65c0ZEjR7R8+XK99957Kly4sAYPHqz+/ftbPLdr8uTJio6O1vbt2+3ymDxBly5dNHPmTJPzxu62b98+TZgwQYsXL87y+On8+fM6fPiwtm3bpq+//lo+Pj568sknNWbMGEVGRppdJleuXPr5559Vu3ZtHTlyxNaHAwAAgPtc1apVtXbtWuXNm9fiPOfPn9fHH3+sWbNm6eLFi1nmO3DggFavXq1PP/1UuXLlUvv27TV8+HCL3yUYDAZ99dVXSk9P17fffmvTY3EF/l4FAAAAT2f5L50AAAAAAAAAAAAAAAAAALfk5+enRYsWqWDBgpKkKlWq6I033tAnn3xiU96uXbuaTMfExGSa5/DhwzaNIUmFCxc2mb5y5Ypd8t4pMjLS5KYiKSkp2rJli13HuNuePXuUnp6e8SPzkJAQPf3001Zd5KRjx44KCQnJmE5LS9PevXtznKdcuXIm07t27cpxDgAAAAAAAOB+lJaWpps3b7q6DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADhJ165dtXbtWtWpUyfby6SkpGj06NGaNGmShg0b5sDq7OvChQtq0KCBFi9erNq1a+do2c8//1zDhw9X+/btHVQdAAAAAAAAAAAAAABwFO7PBQAAAAAAAAAAAAAAAAAAAMCcs2fPymg0ymAwSJIqV66s0NBQxcXFOWX8oKAgk+nExESnjGuNatWqqXPnziZtQ4cOldFovOey1atXN5neuXOnzfXs2rVLPXv2NJsfAOBeAgICtGzZMhUoUCCjLTU1VZ9//rkmTZqkU6dOSZKqVq2asW1fu3athgwZIklq2rSpRo8erfr162csX65cOa1cuVK1a9dWamqqxbHv3tcOHTpU69evt/qxZDXW3SpWrKhvvvkm4zhDkuLi4jRkyBD98MMPSkpKMrtcsWLF9P7776tbt24ZbY0bN9bgwYP18ccfWxxvzZo1qlatWrbrs+SFF17QwIEDM6Zv3bqlqKgom/MCAAAAAADg/nXr1i3t27dP+/bt05w5c5QvXz69/fbbeuONN+Tr65tp/vDwcI0fP179+vVzQbUAHmSnTp1SjRo1XF0GADxwHn30UYWGhmZqv3z5spYtW+aCiuyvfv36GjZsmN5//31Xl5KladOmadCgQZnafXx89Nxzz2ny5MlOqSMsLEwtWrQw2zd9+nSn1OAsqampOnnypE6ePKm1a9fqvffeU/78+fXiiy/qtddeU9GiRc0u5+fnp/nz56tVq1Zat26dk6u2vz59+mRrvsDAQHXr1k1Tp051cEUALHn33XctbptOnjyptm3bau/evVbnP3funIYOHaqvvvpK33//vdn7afv4+Gju3LmKiIhQQkKC1WN5ivLly2v69Ony8vIy25+QkKChQ4davW1MTU3Vzz//rGXLlqlPnz6aNGmScuXKlWm+0NBQfffdd6pbt65V4wAAAODBEBISosWLFytv3rxm+9PT0/Xpp5/qv//9r1W/lbx165bmz5+v+fPnq3v37po8ebLZ7xYNBoO+/PJL7dmzR3/++WeOx3El/l4FAAAAT2f+22wAAAAAAAAAAAAAAAAAgNtKTk7WRx99ZNI2ceJEPfXUU1bnrFevXqaLSSxevNjqfI6QK1cu5c6d2yQsefjhh02mjx8/ruTkZIfWd/nyZW3dutWk7eOPP1bhwoVznOuTTz4xmd6yZYsuX76c4zz58+c3mf73339znAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPN2NGzdUv359jRo1SnFxcfecf9OmTapevbomTJjghOrs799//1W9evU0cOBAnT179p7z79mzR02aNNGrr77qhOoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOMuVK1e0f//+jGkfHx+NHTvWaeMHBQWZTCcmJjpt7Jz68MMPZTAYMqbXr1+vNWvWZGvZMmXKmEzv27fP5nr27t1rMT8AwL28+eabKlmyZMZ0QkKCmjRposGDB+vUqVP3XH79+vVq0KCBBgwYIKPRmNFerVo1jRo1Kstl797X7t+/X9HR0VZHbGxsth/3N998I19f34zpv/76SxUqVNCMGTOUlJRkcbkzZ86oe/fumjhxokn7f/7zHwUGBlpc7urVqzY9tujoaP3111/q3LmzSd7PP/88W68TAAAAAAAAcNvVq1c1bNgwtWzZUteuXTM7z0svvaQiRYo4uTIAAAC4QoUKFcy2//HHH0pPT3dyNY4zduxYVatWzdVlZCk2NlbR0dFm+3r27Om0Orp27Spvb+9M7bt27crR3+U91eXLlzVx4kSVKVNG48ePV1pamtn5fHx8tHDhQpUrV87JFdpXnjx59Nxzz2VqP336tNn5+/Xr5+iSAFgQEhKiPn36mO07evSoateubXL+ri2OHz+uhg0basWKFWb7S5QooTfeeMMuY7kzf39/LVy40OJ5YceOHVONGjU0depUm8cyGo2aOnWqGjRooIsXL5qdp06dOnrxxRdtHgsAAAD3r9mzZ+vhhx822xcfH68WLVrorbfessvvJKOiolS5cmWL3xf5+vpqwYIFCgkJsXksAAAAANnn5eoCAAAAAAAAAAAAAAAAAAA59+mnnyomJiZj2tvbW4sWLdKoUaPk5+eXo1w9evTQqlWr5OPjk9G2fPlyixc1cZWFCxfqxo0bJmFJ3rx5TaYvX77s6PIkSePHjzeZLlasmDZu3KjHHnss2zkqVqyo8PDwLPNmV/78+U2m4+LirMoDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJ4uLS1N7777rsLDw9W6dWuNGzdOs2bN0pIlS7Ro0SJ9/fXXGjhwoMqWLatGjRopNjY2Y9kiRYrIYDBkCkvX9W/cuLHZ+Q0GgzZv3pytem3NkZaWpi+//FLFixdXo0aNNGLECM2ePVtLly7VvHnz9Omnn+r1119X2bJlFRkZqY0bN2Ys++ijj9pUOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD3MWvWLJPpAQMG6N1335W3t7fDxw4KCjKZTkxMzNRfqlQpVa5cWZUrV1apUqXk7+/v8Lru1qJFCzVu3Dhj2mg0asiQIdlePjg42GT67NmzNtf0zz//WMwPAHAvL7/8ssn0oEGD9Ntvv+U4z5QpU9S/f3+TtsGDB6tgwYIWlwkMDDSZvntf6yjPPfec6tSpkzEdFxenJ554QufPn892jrffflsxMTG6cuWKpkyZopYtW+rGjRuOKDfD4MGDVahQoYzpK1euaPz48Q4dEwAAAAAAAPevDRs2qG/fvmb7fHx81LVrVydXBAAAAFcIDQ01237s2DEnV+JYvr6++uGHHxQQEODqUrI0bdo0s+1Vq1bVY4895pQann/+ebPtlmq7X928eVMjR45Uw4YNLZ5PEBwcrO+//94p5zM6Srdu3TKdvyFJb731lg4dOpSpPSIiQjVr1nRGaQDu0q1bN7PnKaenp6tHjx46d+6cXcdLSUlRx44dtWvXLrP9gwcPvu/PEX7jjTcs7n+PHj2qxx9/XH/99Zddx/zzzz/Vpk0bi+fSffDBB25/PAMAAADX6Nq1q9q0aWO2Lz4+Xg0bNtS6devsOuaZM2dUr149RUdHm+1/6KGH9MEHH9h1TAAAAABZ83F1AQAAAAAAAAAAAAAAAACAnEtJSVGXLl20ZcuWjBt8eHl5acyYMXrppZf07bffavny5dqzZ0+mZXPlyqXy5curcePG6t27typVqmTSf+HCBQ0cONApj8NRfHxMT48rUaKEvvrqK7vkfu+993T69Gmzfb/88ovmzZunZ599NqOtfPnyio6O1sKFC/XDDz9ox44dunDhgslyYWFhqlGjhrp27apOnTqZ9H3//fdau3atVbXe/UPzhIQEq/IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwP0iKSlJK1eu1MqVK11dilMYjUZt2rRJmzZtcnUpAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFxg6tSpGjBggB555JGMtpEjR6pz586aMmWKVqxYoaNHjzpk7MDAwIz/p6SkyMfHRx07dlT79u1Vr149FStWLNMyRqNRx44d0/r16zVnzhxt2bLFIbXdZjAYNHHiRJO2uXPnavfu3dla3s/PT7ly5TJpu379us11JSQkZPw/ODjY5nwAAMcoXry4HnrooYzpixcvas6cOVbnmzp1qnr16qXatWtrx44d+uSTTxQXF2dx/qCgIJPpxMREq8fOiZdfftlkeuzYsTp16lSOcqSnp6tNmza6ePGikpOT7VmeWQULFtSQIUNM2saPH6+rV686fGwAAAAAAADcv+bOnatBgwapTp06mfpatGihjz/+2AVVAQAAwJlCQkLMtsfHxzu5EscrW7asPv30U/Xt29fVpVj0ww8/6JNPPpG/v3+mvp49e2rYsGEOHb9SpUqqXLlypvakpCTNnTvXoWO7q61bt6pevXrauHGj2XMGq1WrpqFDh2rChAkuqM525taHuLg4LVmyRA899JA+/PDDTP39+vXTn3/+6YzyANyhadOmZttXrFih33//3SFjJicnq0ePHtq9e7fJ+cZJSUlavHixAgMD78tjBul/52u9/fbbZvuuXbumFi1a6Ny5cw4Z+88//9SgQYM0bdq0TH358+fXs88+q5kzZzpkbAAAAHimXLlyWfxuIi0tTe3atdOePXscMnZCQoJatGih6OhoFS9ePFN/7969NXnyZO3fv98h4wMAAAAw5ePqAgAAAAAAAAAAAAAAAAAA1jl8+LCaNm2qFStWmPxIo3jx4ho7dqzGjh2r1NRUkxuADBo0SG+++aYMBoPZnBcuXFDTpk118uRJh9fvTEWKFLHbBWS+/fZbnT592mJ/r169lD9/fjVv3jyjzc/PT127dlXXrl0l/e/GZrd/eB8cHCxfX1+zuVavXq0XXnjBLnVL/7tRGgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4MN27cUMeOHbVx40bly5cvo71cuXKaPHmyJk+erLi4OJ05cyajr0iRIipcuLDOnTtn09hBQUEZ//fy8tLp06cVFhaW5TIGg0GlSpVSqVKl9Morr2j79u0aMGCAoqOjbarFku7duysiIiJjOjk5WSNGjMj28nnz5s3Udv36dZvrSkhIyPi/r6+v/P39lZSUZHNeAIB9hYeHm0zv27dP6enpNuXs06ePgoKCtG3btnvOe+e+VpISExNtGjs7ihcvrkaNGmVMX7x4UVOmTLEq19mzZ+1U1b2NGjVKefLkyZg+deqUPv/8c6eNDwAAAAAAgPvX3LlzVadOnUztd/4NCgAAAPcvf39/s+3JyclOrsS+fv31V5O/Dd/Wp08frVixQsuWLXN+UdkQHx+vn376Sc8991ymvu7du2v48OEyGo0OG79Xr15m2xcvXqz4+HiHjevu/v77b7Vu3Vrbtm1TYGBgpv63335b33zzjS5fvuyC6qxXo0YNVa5cOVN7VFSUkpOT9d133+m9996Tr6+vSX+XLl30+uuvP9DvCcAVatSoYbZ97ty5Dh334MGD+u677/TKK6/o9OnT+vLLLzVt2jSP2+bl1MiRI03O17rTK6+8oqNHjzp0/OnTp+ull15S7dq1M/UNHDhQM2fOdOj4AAAA8CyDBg3SQw89ZLZv9OjR2rx5s0PHv3Tpkp577jlt3rxZXl5eJn3e3t6aOHGiWrdu7dAaAAAAAPyP171nAQAAAAAAAAAAAAAAAAC4q7179yoyMlJz5841e4ERHx8fk5tn5cqVSwaDwWyuRYsWqWLFitq3b5/D6n0QJCcnq3Xr1ho7dqxSU1PNzuPr66sCBQqoQIECmS7SIUkpKSkaPXq02rZtq5SUFEeXDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgPtUTEyMatWqpdjYWLP9oaGhioiIyJju1q2b/v33X8XHx2vjxo16//33Vbdu3RyPGxgYmPF/b29vhYWF5ThH7dq1tX37dvXp0yfHy96Ln5+fxo0bZ9L25Zdf6sSJE9nO4eXllaktLS3N1tIy5TA3DgDA9Xx9fU2mk5KSbM4ZGxurbdu2ZWveO/e1kpSYmGjz+PfSpk0bGQyGjOmlS5cqJSXF4ePaomTJkpmOJUaOHKnk5GQXVQQAAAAAAID7SUxMjNn2QoUKyc/Pz7nFAAAAAHby6quvWjyPavr06SpUqJBzC8qBadOmmW0vWrSomjZt6rBxvby81K1btxzV9CCJjY3Va6+9ZrYvT548Gj58uJMrsl3fvn3Ntt9+vS9evKjly5dn6g8ICFCPHj0cWhuAzCydx3zw4EGHjz1hwgR17NhRJUqU0AcffKDLly87fExXCggIUK9evcz2rV27Vj/++KNT6hg5cqTJdHp6un799Vd9/fXXnJsNAACADAaDQa+++qrZvgMHDuj99993Sh1bt261+B1Sq1atVLp0aafUAQAAADzo+PYYAAAAAAAAAAAAAAAAADxcXFycunbtqsjISE2dOlWXLl3K9rIXLlzQjBkzVKVKFXXq1EkXL150YKUPjpSUFI0ePVoVKlTQxx9/nKPn9eLFi3r00Uc1duxYpaamOrBKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPAgOHz6syMhI9erVS9u2bcvWMnnz5lWjRo00bNgwbd26VUePHlX37t2zPWZQUFCmtn///VdRUVF67bXX9PTTT6tZs2Zq3ry5OnXqpKFDh2rJkiVKSkoyWcbX11dTp07Vyy+/nO2xs2PgwIF66KGHMqbj4+M1btw4u44BALi/XblyxWQ6LCzMqePfva9NTEx0+JhVq1Y1mV62bJnDx7TVhAkT5OvrmzG9Z88eRUVFubAiAAAAAAAA3E/OnTtnsS9PnjxOqSFPnjwKCQkx+R7MneTKlUuhoaEKCAhwdSnZFhAQoNDQUOXLl08Gg8HV5dzT7efY39/f1aU4nLe3t/Lly+fW7/k7PUivzd38/PwUGhqq3Llzu7qUbLm93jvytfLx8VFISIhbbw/dfZ9ypwd5/cqKp20nbXX7fWDuPCXYJj4+Xt26dVNaWlqmvoIFC2rmzJkuqCp7NmzYoBMnTpjt69Wrl8PGbd68uQoXLpyp/cSJE9q4caPDxvUk06dP12+//Wa276WXXvKobXrevHn17LPPZmrfsWOH9u7dmzE9bdo0s8v37dvXYbXBdp5wnME+MGcCAgIsHhudP3/e4eOfOHFCP/30k9LT0x0+1t1c8V555plnFBwcbLZv2LBhTqtj/fr1OnLkiH7//Xe9+uqrCg8PV+PGjfXNN9+45LWAZ2xfJc/6bGytB+2zo7P4+voqJCREwcHBbve9sjvXJrnneufO64k713Ybx6sPjvvhtW7ZsqWKFy9utm/YsGFmvx9zlBEjRpj9XYjBYNBLL73ktDruJ55yDAoAAAD34ePqAgAAAAAAAAAAAAAAAAAA9hEbG6t+/fqpf//+Kl++vKpVq6ZixYqpUqVK6tq1qyTpjz/+0Lx583TmzBnt27dPhw4dcnqdmzdvtuqHf23btpUkvfPOOxo9enSW837yySf65JNPrKrPno4cOaK33npLb731lkqXLq0aNWqoePHiypcvX8YP1OPj43X16lWdPn1aO3bs0N9//2238WvUqGG3XAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPBcRqNRs2fP1uzZsxUeHq7atWurVq1aioiIUOXKlVW4cOEsly9ZsqTmzJmjnj17qlOnTrp27VqW848cOVJjx45VlSpVtGnTJo0fP17r1q2T0WjMcrnQ0FANGzZMb775pry9vTPav/jiC/3xxx+KjY3N/oO2IG/evBoxYoRJ24QJExQXF2dzbgDAg+Ps2bMyGo0yGAySpMqVKys0NNRp+5OgoCCT6cTERIePGRkZaTK9Z88eh49pi2rVqqlz584mbUOHDr3n8QgAAAAAAACQXbdu3bLYd+ffuuwhV65catGihVq0aKHKlSvr0UcfVUhISMZ3lJKUnJyskydPat++fdq2bZuWLFmiv//+2651ZKVo0aLq1KmT6tWrpypVquihhx6Sn59fRn9aWpr++ecf7d+/X9u2bdPPP/9s8XtGHx8fhYaGZmqPi4tTamqqXer19fVV48aN1bJlS0VEROixxx5TwYIFTV47o9Goq1evKi4uTnv27NGmTZu0adMmu30/WqFChUxt58+f1+XLl83OHxoaqs6dO6tJkyaqUqWKHn74YZPn+ObNm7p48aIOHjyotWvXas2aNdq3b59danW2mjVrqmnTpqpZs6YiIyNVoECBTN+NJycn6+zZs9q3b592796t5cuXa8eOHS6pNyQkRO3bt1erVq0UERGhUqVKydfXN6PfGa+NufeTJB04cMDmPFm9L0NCQtShQwc1b95clStXVsmSJZUrV66M/rS0NJ07d06xsbHasWOHfvrpJ8XExOSoJnvX3KRJE3Xp0kV16tRRuXLlTNaj1NRUnTp1SjExMdqwYYMWLFigCxcu5LimKlWqqGvXrqpbt64qVaqkPHnyZPTdfj/ExsZq1apVWrlypU6ePJnjMayVnX3KkSNHHLY/cedtX4ECBRQWFmax/6GHHjLbHhwcbHEdtCQ5Odmm59XTtpO2qlixotq3b6+aNWsqIiJC4eHhJttZo9GoK1euaP/+/YqNjdWaNWu0Zs0aJSUl2TRuaGholudVFSpUyGJ7Tt8TUs632Y60bds2TZgwQSNHjszU16pVKw0YMEBffvmlCyq7t5kzZ2rMmDGZ2jt27Ki+ffvqxo0bdh/z+eefN9s+Y8YMu4/lyUaMGKHNmzdnas+XL586deqkqKgoF1SVc927d1fu3LkztU+bNs1kevXq1Tp79qzCw8NN2h977DHVrVtX27Ztc2iduDd3OI6/F1ftA++W02M46X/HnRERESpdurSCg4OVJ08ek2POzz77zO51mpPVuUJ31uPp3OW98sILL5ht37hxo3bv3m3Xse6lcuXKTjmvzhE86bOJOZ6wffWE71vtwdWfHcPCwlSgQIFM7ffah+SUwWDQo48+mqk9PT1dhw4dsts4t0VGRqpNmzaqXr26KlWqpPDwcJPvw4xGo65du6YDBw5o165dWrlypdasWaO0tDS71+JJtbnreufq9cRTa7vNXY5BPO141RP39e7yWtvbSy+9ZLb9wIEDWr58uVNruXTpkmbOnKn+/ftn6nv++ef1n//8R+np6dnO56r1wlV/r3qQ/o4KAAAABzJmkySCIAizERERYezevbuxe/fuxm7duhnr1KljNBgMLq+LIAiCIAiCIAiCIAiCIAiCIAiCIAiCIAiC+F9UrVo141ywDz/80OX12BofffSR0Wg0Gm/evOnyWgiCIAjClWEwGIw1atQwduvWLeNczoiICJfX9aAG59QSBEEQBEEQBEEQBEEQBEEQBEEQBEEQBEEQBEEQBEE4NwwGg7FmzZqcT0sQRI7CFq6unSAI9w1+V0IQBEEQBEEQBEEQBEEQBEEQBEEQBEEQBEGYi+YDZRy6+v+j+UDX10QQBEEQ91NwrXb3Cs6pJQiCIAiCIAiCIAiCIAiCIAiCIAiCIAiCIAiCIAiCcG5wrXaCIKwJrtVOEIQjgt+VEARBEARBEARBEARBEMT9F1WrVs34G8GGDRuMH374ofGXX34xXr161ezfEXbs2GH08/PLVu5HH33UqpqaNWtmTExMNBl37dq1dnm848aNM8l7+vRpo7+/f47zhIWFZXpuAgMDba4vMDDQJGfu3Lld/h4hCIIgzMfevXtNttlffPGF2fnu3Nd++OGHdhl7ypQpdt8H3SuuX7+eMd6NGzfMzpM7d25jvXr1jM8//7zx1VdfNb7++uvGF1980disWTNjgQIFnPr6bNiwweQ5WrduncvfMwRBEARBEARBELYE12p3r+CcWoJwrzh+/LjZv2s988wzDh23RIkSZsc1Go12+z6sePHixilTphgTEhIsjpWVP//80/jUU0859HmoWbOm8ZdffjGmp6fnuL4dO3YY27VrlylngwYNzM5fs2ZNm+stXLiw8aOPPjLGx8db9Zzefl47dOhg87bfnKFDh2aar2jRosZp06YZk5OTc1zr5s2bjY0aNXLa+mhL+Pr6GgcNGmTcv3+/1a/N6dOnjUOGDDHmzZvX7q+N0Zj5d3dhYWHGzz77zJiUlOTy1ya7NdvrfVmsWDHj119/bdX78uDBg8YePXoYvby8HPbYzdXcokUL48GDB3NUa2pqqnHGjBnG8PDwbNVSu3Zt4/bt23M0RlpamnHOnDnGhx9+2KHrmC37FHvuT8xxl23fqFGjcjyWtTZv3pzj+txpO+mM8PX1Nb700kvGQ4cOWfVYr1+/bpw6darxkUcesbqGwYMHW/1c59TZs2ed/hxbOo5+6KGHjJKM3t7exj///NPsPImJiVafG2YuLG2fQ0NDc5yrePHixrS0NLP5evToYffnMU+ePMabN29mGistLc1YvHhxu7421n7GcdVnJnOxa9cus7UsWbLEYx7bnj17Mo1348YNY548eTLNO378eLP1zZ492+nPvbOiY8eOZh/zv//+6/CxLbl7Pnc6jjcX7rAPzM5za+4YzsvLy9ilSxfjunXrjCkpKVnWac023tq4+5zk2ypWrOiS9eR+fa8EBgZaPH53xD74fg53+2xiyd3zufv2VfKM71ttDXf67DhhwgSz+c3tQ2yJ3Llzmx0nISHBrmO89tprxmPHjln1nF64cMH4n//8xxgQEGD319yda5Pcc71zp/XEk2q7s0Z3OgaRPO941d329Z70WtszfHx8LG6bXnvtNZfUVLlyZYvPZ07/TmqOM9YLS3L6XGS3/gfl76gEQRCEaXCtdoIgrIns8BIAAAAAAAAAAAAAAAAAAB7k8ccflySdPXvWxZUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA95ddu3ZpyJAhatGihQoUKKC2bdtqx44dJvNUr15d7733XrbyHTx40Ko61q1bp379+pm0NWvWTOXKlbMq320hISF67bXXTNreeecdJSUl5TjXrVu3MrX5+flZXdtt/v7+9xwHAOAeZs2aZTI9YMAAvfvuu/L29nb42EFBQSbTiYmJmfpLlSqlypUrq3LlyipVqlSmfUxOeHt7KzAwMGP633//Nelv1qyZli9fritXrui3337TzJkzNXnyZH366aeaNm2a1q5dqwsXLmj79u3q1auXfHx8rK4lO1q0aKHGjRtnTBuNRg0ZMsShYwIAAAAAAODBU7BgQYt9165dsym3r6+vxo8fr6NHj6pfv36ZvhPMrho1auinn37Sb7/9ppIlS9pU093y5MmjqKgo/fHHH3riiSdkMBhynKN69epaunSpFi1apNDQULvWdzeDwaC33npLx48f15tvvqm8efNanatGjRpavHixtm7dqiJFitixysy6du2qw4cP68UXX5Svr2+Ol69fv742btyohQsXmnzP624ef/xxxcTE6LPPPlOFChWszlOsWDFNnDhRJ06cUK9evexYYWYdOnTQgQMHNGjQIOXKlSvHy3vKa2PO888/r4MHD+qVV16x6n1Zvnx5zZ49WzExMYqIiHBAhaa8vb31+eefa/Xq1SpfvnyOl33hhRe0f/9+tW7d2uJ8Xl5e+uijj7Rt2zbVqlUrR2N4eXmpe/fuOnz4sJ5//vkcLZsd9tinOHJ/Ys6DsO3bv39/jub3xO2kLZ544gkdOXJE3377rdXnCwUGBqpPnz46cuSIPvnkE5v+XuoMf/31l6tLyCQtLU1du3bVjRs3MvX5+/tr7ty5Vq2jjnb69GmtX7/ebJ8j3vedO3dWQEBApvZ169bp9OnTdh/P082cOdNse7Nmzexy/p2j1apVy+zxy8KFC5WQkJCpffr06TIajZnaO3furJCQEIfUiKy5+3G8J+8Dy5cvr+3bt2vevHlq2rSpw88PyolLly6ZbXfG5xFHccf3Sv369c0eG6Smpmrp0qU25Ybj5PSziSXuvn31hO9b7eFB++zoLM8995xOnDihSZMm6ZFHHrEqR8GCBTV+/HgdOXJETZo0eSBqs/d6Z691zp3XE3eu7TZ3PAbJLnc+XnUka/f1nvxaZ1etWrXMbpuMRqPmz5/vgoqkPXv2WPyesGnTpnYfz9PXiwfhbwkAAABwLs86IgYAAAAAAAAAAAAAAAAAPLAMBoM+/fRT1a5dW5K0atUqF1cEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCGn5+f2fbk5GQnVwIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyEpqaqqWL1+ulStX6ssvv1Tfvn0z+gYMGKCJEyfqwoULDht/1qxZGjx4sCpVqpTR1q5dO3344YdW53zttdcUFBSUMX3kyBHNnDnTqlzXrl2T0WiUwWDIaMuTJ4+uXLlidX23c9x248YNpaWl2ZQPAOA4U6dO1YABA/TII49ktI0cOVKdO3fWlClTtGLFCh09etQhYwcGBmb8PyUlRT4+PurYsaPat2+vevXqqVixYpmWMRqNOnbsmNavX685c+Zoy5Yt2R4vb968JtPXr1+XJIWGhmrWrFlq27btPXMYDAbVqlVLtWrV0ltvvaVevXopOjo62zVkl8Fg0MSJE03a5s6dq927d9t9LADA/xQqJeUr6uoq8KA5/7d09V9XVwEAAOA8ecOkhyOlPAUkX3/p5lXp4knpdKyUluLq6h5cJUuWNNseFxdn0zWXixUrpmXLlikyMtLqHHerV6+eYmNj1aVLF61YscLmfBUqVNDy5ctNvh+1RceOHVWhQgU1adJE//5r/4P9vHnzaunSpWrUqJFd89apU0fR0dF66qmn9Mcff9g1tySNGzdOI0aMsEuup59+WuXKlVPbtm114sQJu+S0l169emn69Ony9va2W86QkBDNmjVL7du313PPPadbt27ZLbckDR06VB988IFdcrnza2POpEmT9Nprr9klV6VKlbRjxw716dNHs2bNskvOu3l5eWnRokVq3769TXmCg4O1bNkyde3aVfPmzTPp8/Pz09KlS9WyZUubxvDz89PMmTNVvHhxvfvuuzblus3e+xR770/MeVC2ffv378/2vJ64nbSWl5eXPv/8c/Xv399uOb29vfXGG2+oTZs2ateunQ4dOmS33Pb0119/uboEs/7++2+9/vrr+vbbbzP1Va5cWePHj9fQoUNdUFnWpk+frubNm2dqb9y4sYoVK6YzZ87YbaxevXpZrAGZLVu2TJ9//nmm9sDAQFWvXl3btm1zQVXZd+d5lHcyt45I0rFjx/Trr7+qcePGJu3+/v7q1auXJk2aZO8SkQV3Po739H1grVq1tHr1auXLl89hY9jiyJEjZs+n6tChg3744QcXVGQ9d36vNGnSxGz7jh07dO3aNVtKhAPl5LOJJe68fZU84/tWe3iQPjs6S0BAgObMmaOnn37abjnDw8O1du1avf3225nOdb1fapMcs97ZY51z5/XEnWuT3PsYJDvc/XjVkXK6r/f01zonLB2/7tu3zyF/r8yutWvXqly5cpnamzVrpgkTJthtHE9fLx6UvyUAAADAuXxcXQAAAAAAAAAAAAAAAAAAAPcSEhKiuXPnqkWLFpKkEydOaMyYMS6uCgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQU2XLltVff/1ltq9cuXI6fPiwkysCAAAAAAAAAAAAAAAAAAAAAAAAAAAAANxLenq6BgwYoBo1aqhatWqSJH9/f3Xs2FFTp0516NgLFixQpUqVMqarVq1qdS4/Pz/179/fpO39999Xenq6VfmMRqOuX7+uPHnyZLQFBwdbXZ+5HFevXrU5HwDAcW7cuKGOHTtq48aNypcvX0Z7uXLlNHnyZE2ePFlxcXE6c+ZMRl+RIkVUuHBhnTt3zqaxg4KCMv7v5eWl06dPKywsLMtlDAaDSpUqpVKlSumVV17R9u3bNWDAAEVHR99zvLv3cTdu3FDhwoX122+/qXTp0jmuv2LFitqyZYueffZZ/fzzzzlePivdu3dXRERExnRycrJGjBhh1zEAAKYiWklV2ri6Cjxo1nwuxaxwdRUAAACOF15BatBbKl7RfH9yohT9s7T9Ryn5pnNrg9SxY0ez7dn5zs2SMmXKaP369SpevHi25k9NTVVKSooCAgLuOW9gYKCWLFmi7t2768cff7S6xsqVK2vdunUqUKCA1TnMKV++vNavX68aNWrYNW9ISIjWr1+vKlWqZGv+9PR0JSYmKleuXPLx8bnn/IULF9by5ctVtWpVnT592tZyM4wYMcLu321WrFhRa9asUbVq1ZSQkGDX3NZ64YUXNH36dBkMhmzNn5iYKKPRqICAgGwt06FDB/3yyy9q0aKFbt26ZWu5kqQBAwbogw8+sEuu29zxtTFn0qRJeu211+ya08/PTzNmzFDevHn12Wef2TW3JH311Vdq3769XXIZDAZ99913On78uP7444+M9nnz5qlly5Z2GUOSxo4dq+PHjysqKsqmPI7ap9hrf2LOg7Ltk6T9+/dnaz5P3E5ay9/fXwsWLFCbNo75wrlMmTLatm2b2rZtq61btzpkDFtYupeHO5g2bZratGljdnv61ltvadWqVdq4caMLKrPsp59+0pUrVxQSEmLS7uXlpW7dutltX16iRAnVr18/U3tcXJyWLFlilzHuNydPntSxY8dUsmTJTH1Vq1bVtm3bXFBV9gQHB6tLly6Z2o8cOaItW7ZYXG7atGlq3Lhxpva+fftq0qRJ9iwRWXDn43hP3weWLFlSq1evNjl/yt2sW7fO7Hr49NNPq0qVKtq9e7cLqso5d3+v3HnO953c8dgL/y+7n00sceftq+QZ37faw4P02dFZQkNDtWrVKtWsWdPuub28vPTBBx/I19dX48ePv69qk9z3Oyl3Xk/cuTbJ/Y9B7sUTjlcdKSf7ek9/rXPq9u8k77Z582YnV2Lq119/1cCBAzO12/K7yrt5+nrxIP0tAQAAAM5177MFAQAAAAAAAAAAAAAAAAAe7Z9//tHo0aMlya0vcJGVxx57TM2aNZMk7d27V08++aQuX77s4qoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAB0N6eromTZqkOXPmZLQ1bNhQU6dOdei4Bw4cMJkuXLiw1bmefvppFSxYMGP64sWLioqKsjqfJF26dEl58uTJmC5Tpoz27t1rU84yZcpk/P/y5cs25QIAOF5MTIxq1aqlBQsWKCIiIlN/aGioQkNDM6a7deumbt266dq1a4qOjtYff/yhn3/+Wdu2bcvRuIGBgRn/9/b2VlhYWI5rr127trZv365Bgwbp66+/znJePz8/k+n09HQtWbJEpUuXliSlpqZq7ty5Wrx4sXbu3KmLFy8qOTlZoaGhKlOmjJo3b65+/fqpSJEiGTkCAgI0f/58NWnSJMePP6s6x40bZ9L25Zdf6sSJE3bJDwAAAAAA4EyP95DqdpUMBsvz+AVItbtIjzaSFo2WLp1wVnWoUKGC2rdvb7Zv6dKlVuUMDQ3VmjVrVLx4cYvzxMbG6scff9SaNWt09OhRXblyRdL/vhsrUKCAqlevrieeeELdunVTvnz5Mi3v4+Oj7777TidOnNAff/yR4xoLFy6s1atXq0CBAhbnSUpK0oYNG7Rs2TIdPHhQ58+f15UrVxQYGKhChQrp4YcfVqtWrdS6dWvlz5/fZNlHH31UX331laZNm5bj2iz5/vvvVaVKFYv9v/32mxYuXKitW7fq8OHDSkhIyOjLkyePHnnkETVq1Eg9e/ZUtWrVzOYoUKCAFi1apMcff1wpKSk219ysWTONHTs2U7vRaNTmzZu1ZMkS7dy5U2fPntXNmzeVN29eFSxYUFWqVNGTTz6pFi1ayNvb22zuMmXK6LvvvlPHjh1trtNWJUuW1BdffCGDhQ3dP//8ox9++EG//PKL9u3bpwsXLig9PT2jPzQ0VGXLllW9evX09NNPq3bt2mbzNGzYUJ999pn69Oljc821a9fW5MmTM7Xfb6+NOT179tRrr72WqT05OVm//PKLVq1apZiYGJ07d043b97MWOfLlCmjli1bqlWrVma3S5JkMBg0adIkHTt2TMuXL7dbzR07dtQrr7ySqf3YsWP67rvvtGnTJp08eVJJSUkKDQ1VkSJF1KRJE3Xq1Elly5Y1m9PPz0/Tp09XZGSkUlNT9eabb6pDhw6Z5rt69armzZunlStX6tChQ0pISFBQUJAKFSqk6tWrq0OHDmrYsKHF2qdMmaKtW7fq+PHjVj12W/cpLVu2dOj+xBx32PadOXNG27dvt9ifP39+k/M6bouLi9Phw4fv8QhN7du3757zeOJ20hZz5sxRmzZtLPanp6fr999/17Jly7Rjxw6dO3dOcXFxyp07twoVKqTSpUvrySefVMuWLS1ub0JCQrRixQrVqVNHBw8evGdN//77b5bviWLFiqlYsWKZ2s+cOaMzZ87cM/+ddu7cmaP5ne3FF19UrVq1Mp2/ZTAYNHv2bFWqVElXr151TXFmJCcn6/vvv9fAgQMz9T3//PP64IMP7DJOjx49zK6j33//vZKTk+0yxv1o9+7dKlmyZKb2qlWruqCa7OvRo4cCAgIytd/r88uiRYv05ZdfZto2lStXTg0aNNDmzZvtWSbMcPfjeHfcB2aXt7e3Fi9ebHFcd7Fq1SqNHz8+U7vBYNCSJUtUr149nT592gWV5Yy7v1fMHStL//vsgZxxt88mlrj79tUTvm+1hwfts6Mz+Pn5admyZapZs6bFedLS0rR161atXLlSO3fu1Pnz53X58mUZDAYFBwerTJkyatCggZ577jkVLVrUbI5x48bp77//1o8//nhf1CY5fr2zdp1z5/XEnWu7zd2PQbLirser7rqv9+TX2hqW/g4QExPj3ELuYun4OV++fMqfP7/Nvzd01/Uiu9zhbwkAAAC4fxmMRqMxWzNmdWYvgAdaRERExkUnjEajjh07pu3btyubmxcAAAAAAAAAAAAAAAAgW4YOHapKlSqpb9++unHjhqvLAQDA5QwGg6pXr66yZctmnO8dGxvLRU9chHNqAQAAAAAAAAAAAAAAAAAAnMtgMKhGjRoqU6YM59MCyDZbzvHmWu0ALOF3JQAAAAAAAAAAAAAAADCn+UCpSpv/n969XFr7hevqAQDgfsO12t0L59QCAABrlC1bVn/99ZfZvnLlyunw4cNOrggAAAAAAAAAAAAAAMBzcK12ANbgWu0AHIHflQAAAAAAAAD3n6pVq2rXrl2SpI8++khDhgwxO1/JkiV19OjRjOktW7aofv36Dq2tUaNG2rhxY8b0zp07VaNGDatyrVq1Si1btsyY/vDDDzV06FCb6lu8eLE6dOiQMT1mzBi98847NuUcO3as/vvf/0qSZs+erV69etmUDwDgHAaDQT169FCfPn1Ut27dHC9/7NgxjR49WlFRUdmaPyYmRpUrVzZp+/fff7V+/Xrt2LFDZ86cUXx8vAwGg4KDg1WyZEnVrVtXLVu2lL+/f6Z8r7zyir799luL49197Zj09HR5eXlJknbt2qUuXbqYHCeY4+fnp/Hjx+utt94yaT9+/LgqVqyomzdv3vNx38vgwYP18ccfZ0zHx8erZMmSiouLszk3AMCyu6/RDjjDms+lmBWurgIAnItrtbsXzqmFozUbIFVtm7Nlkm9KUYOlSyccUpJbO378uEqUKJGpvUuXLpo/f77dxwsODtbGjRtVpUqVTH0JCQkqUaKEVd9JrV27Vs2aNTPbd/r0aQ0ePFgLFy7MVq68efNq2LBhGj58eMZ3eXc6c+aMypcvrxs3bmS7PoPBoM2bN6tevXpm+9PT0zV9+nSNGDFCFy9evGc+Pz8/vfHGGxo5cqSCgoJM+kaOHKlx48ZlWqZWrVr6888/s13zoEGD9Nlnn5nti46OVr9+/XKUr2PHjpo5c6by5s1rtv9e37Xezdx+Y/To0erdu7cefvhhk/YVK1Zo2LBh2r9//z3zVqhQQZ999pmaNm1qcZ5nnnlGCxYsyHatjvDzzz+rbdvMG7v09HSNGjVKH330kW7dupXtfHXr1tVXX32VsY++2xNPPKG1a9dmK5elffrevXtVqVIlkzZ3eW0s1ZzT3wqay/Ppp5+qd+/eCg4ONpnvq6++0vjx4/XPP//cM29gYKDeeOMNDRkyxOI6dO3aNT322GM6c+aMzTWPGTNGL7/8sooWLZrRlpCQoDfffFPTp09Xenq6xXxeXl4aMGCAPvzwQ+XKlcvsPH369NH69et14MAB+fn5mdQyadIkvfPOO7p27VqWdTdv3lzffvttpvX9tsWLF+vpp5/OMocl9tqnOGJ/4snbvo4dO2rRokWZ2hcuXKjOnTtbndcSd95O2tt///tfjR071mL/6tWrNXToUO3du/eeuQIDAzV48GANHTo00zHGbcePH1dkZOQ919N7GTVqlMaMGZOpffTo0Vk+Hndh6Tj64Ycf1qlTpzK1t2jRQqtWrTK7b5k/f766dOlidS0HDx5U+fLlM7Xnz5/f6r/3Vq5cWTExMWb7qlevnnHOnC3+/vtvlSpVKlN7ZGSk9uzZY3Vee3/GcfZnpnsZM2aMRo0alal9w4YNWW7HzXHmY9u7d68qVqxo0paamqpixYrp/PnzWS775Zdfqn///pna586dq65du9q1TleztL88d+6cihQp4tCxPfE43lP2geae22HDhunWrVuaNGlSpr4rV65o6dKlWr58ufbu3avz588rPj4+R2Pa2/r169WkSROzfZcvX1b//v1dsk3MLnd/r/j4+CgpKUne3t6Z+mrXrq0//vgjW3mQPc7+bOKJ21fJ/b9vtRd3/uw4YcIEDR8+PFP7sGHDNHHixGzXdC+5c+c2+9xfv35defLkyXG+6dOnq3fv3hb7Fy5cqBEjRmTrvos+Pj4aOHCg3nvvPQUEBGTqj4+PV8WKFbP9fZg71yY5b73L6TrnzuuJO9cmuf8xyG33w/HqnZy9r5c857W2F4PBoMTERLN/A6hXr562bt3qgqr+x8vLS4mJiSZ/e7itbt26+v3337OVx1XrhSP/XuUpf0sAADge12oHYI3snOOd+Zs/AAAAAAAAAAAAAAAAAADc0MSJE9WjRw+X/LAVwP+xd9/hUdTd38c/6YQk9Ca9915FQHoJSpXem3RFbhW9RUBRsAuCCtJ7ERCkV5F6UwRCE6T3TigJgYSU5w8f8iPsbMq27Cbv13Xlkjln5nzPzu7UxB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOBINWrU0Lp160x+Pvroo+RuzSmwfgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASB537tyJM50pUya7j+nl5RVnOiIiwqI6Pj4+qlevXpzYggULLO7rmf3798eZrl27ttU1n6/xYn0AgPOKiYnRnDlzVKNGDeXOnVtt2rTRN998ow0bNujGjRsJLl+wYEHNnTtXGzduVLp06RKc/+OPP9ahQ4ckSdu2bVOjRo2UK1cude3aVRMmTNBvv/2mLVu2aPPmzVq2bJm++eYbtWrVSrly5dLXX3+tqKioOPV+/PFHlS1bNtGv193dXZK0e/du1ahRQ2fPnk1wmYiICL3//vt666234sQLFCigAQMGJHpsc9KlS6fhw4fHiX3xxRcKDg62ujYAAAAAAIAjlW0iVWyW9OW800pvfPrvf2E/RYsW1c6dO1WhQgXD/JgxYyy6J9WlSxc1aNDAMLdr1y5VqlRJS5cuTXS9hw8favjw4XrttdcUEhJiks+dO7c+/fTTJPXYp08f1axZ0zAXGhqqBg0aqG/fvrp9+3ai6kVEROirr75S2bJlde7cuTi5Dz/8MEm9GUmXLp1GjRplmJs3b56qVq2qffv2Janmb7/9pho1aujBgweG+ffff19ubm5J7vV5ffr0Ub58+WKnIyMj1a9fP73++us6fvx4omr8/fffatSokWbOnGl2nmHDhlnVp7WyZs2qwMBAw1zHjh01ZswYhYeHJ6nm7t27VaVKFf3222+G+dGjRye5zxeVKVMm9t8p9b0xMmDAAKVPnz52+sGDB6pfv74GDRqka9euJarGo0eP9Pnnn6tixYo6ceKE4Tzp0qXTuHHjbNJz7969lTNnztjpCxcuqGLFipo6daqio6PjXTY6OloTJ05U27ZtFRkZaTjP0KFD9dlnn8nb2zs29vjxY7322mv6z3/+o4cPHybY46ZNm1S7dm1dvXrVMN+iRQvlzp07wTovsuUxxR7HEyOpZd+XFK66n7RE6dKlNWLECMPcs89CYGCgjh49mqh6jx490meffaZy5cqZ3d8UKFBAX3/9tcU9p1YbNmzQjz/+aJhr166dunbt6uCO4nf48OHY36u/qHv37lbXr169ugoVKmQSP3jwoA4fPmx1/ZTs0qVLhnFLjnuOUr16dZUuXdokvnbtWt28eTPB5adNm2YYf+ONN5Q5c2ar+0P8nPU83tWPgWnTptXHH38cJxYeHq6vvvpKBQoUUM+ePbVs2TKdOnXK7HW0I40cOVIxMTGGucyZM2vx4sU6cuSIBg0apBw5cji4u/i5wmclZ86c8vDwMMyZu+aB63PW/avkGvdbbSE1XTs6SoMGDdSrVy/D3OPHj9W2bVu1bdtWp06dSlS9yMhIjR8/Xq+88orhvfP06dMn+rPjzL1Jjt3ukrLNOfN24sy9Sa5xDhIfVztfTU6u/l5bImfOnPLx8THMXblyxcHdxBUdHW32/0EpUKCAVbVdfbvgdwkAAACwN/fkbgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/J3v27GrSpInJT4UKFZK7NafA+gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIPEaNGig2rVr26SWj49PnOknT57YpG58cubMGWf65s2bFtWpXLmyvL29Y6eDg4MVFBRkTWuSpD179sSZfvXVV5UtWzaL67300kuqWbNm7PTevXstrgUASD5Xr17VsmXLNGzYMDVp0kSvvfZabG7r1q369ttvtXHjRj148MBk2YYNG2rLli1xjltGVq9erYoVK6pkyZKqU6eONm3apJiYmAR7Cw4O1gcffKAmTZrEOZZ7e3vru+++S8KrlEJCQtSqVSuFh4cnabkff/xRCxcujBMbPHhwkmoYGTZsmDJlyhQ7feXKFf3www9W1wUAAAAAAHAk77RS7V6WL58+u/Rye9v1g/9Trlw5/fTTTzp+/LhKly5tOM+GDRv09ddfJ7l2mjRpzC53+PBhNWjQQLdv305yXUlav369unXrZph76623lD179kTV8ff319ixYw1zISEhqlu3rrZu3WpRj+fPn1fNmjV19uzZOONZy8vLSwsXLjT5vebatWvVtWtXRUVFWVT32LFjGjRokGGuSJEiCgwMtKjuM3ny5In9d3R0tNq3b68pU6YkuU50dLR69eql7du3G+YrV66sV1991eI+rdWsWTN5enqaxBcvXqxff/3V4roRERFq3769/ve//8WJb9q0SSNHjrS47otS8ntjJE2aNLH/DgsLU7169Sze5s+ePatq1arp4MGDhvk2bdqoRo0aFtV+Xu7cuWP/fffuXdWtW1dnzpxJUo1Vq1aZ/f1J8eLF1bFjx9jp6OhotW7dWuvWrUvSGBcvXlT37t0Ncx4eHurfv3+S6tnrmGKr44k5qWXflxSuvp9MismTJ8vLy8sk/vTpUzVt2tSiz4IknTt3TtWqVTP5+55n+vbtq6pVq1pUOzV7//339ffffxvmfvrpJ+XPn9+xDSVg+vTphvGOHTsabmNJYW7/bW5M/J/r168bxq09ntiTuWPy1KlTE7X8oUOHdOjQIZO4t7e3evToYU1rSAJnO89w9WNgx44dlSVLltjpO3fuqF69evrwww8N/y4que3atUujR4+Od54yZcroxx9/1LVr1/T3339r+vTpGjx4sOrVq6ccOXI4qFNTrvBZie9ezq1btyzqD67D2favrnC/1VZS07WjI7i7u+vnn382zIWFhalOnTpaunSpRbWDgoLUoEEDhYWFmeSqVq2a4N8NO3NvUvJsd4nd5px5O3Hm3iTXOAeJj6udryYnV3+vLZEuXTqzOUv//0VbMtdDQECAVXVdfbvgdwkAAACwN/fkbgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC2U6tWLW3fvl2bNm3SuHHj5ObmZnXNIkWKxJm+fv261TUTUrdu3TjTly5dsqjOK6+8Emd67969Fvf0vD///FOXL1+OnXZ3d9egQYMsrjd48GC5u7tLkk6dOqX9+/db3SMAwLkcOHBA77//vho3bqwsWbKoWbNmJvv7ypUra+zYsYmqd+LECYv62Lx5swYMGBAn1qBBAxUrVizRNSZOnKhbt25ZNP5HH32kmJiY2On8+fOrdOnSFtWSpIwZM2rIkCFxYp988omePHlicU0AAAAAAIDkUKaR5JvOuhoVm0seXrbpx9WVKlVKr776apJ+6tevrxYtWqhLly4aPny4Fi5cqLNnzyooKEgDBw6Up6en4VibNm1Sq1at4tz3SqxOnTrppZdeMok/fPhQrVq1svo+14oVKzRt2jSTuLe3d6J/t9W9e3dlyZLFMPf222/rr7/+sqrH69evq0uXLoqKirKqzvPu3r2rt956SwUKFNB3332nR48e6f79++rWrZvVtefPn6+jR48a5urXr291/WdGjRql3377zaoaPXr00NOnTw1zLVq0sKq2NQoVKmQYnz17ttW1IyMj1bNnTz1+/Fhz585VuXLl1KhRI23atMnq2s+k5PcmIQMHDtTBgwetqhESEqI33nhD9+7dM8y/8847VtV/Uffu3XXhwgWLlv38888VHByc4HxfffWV1q9fb9EYW7ZsMbts48aNk1TLnscUWxxPEiM1b1/Pc/X9ZGLVqlVLNWrUMMy9//77Vvf0bH9j9HtNNzc3ffTRR1bVT43Cw8PVsWNHRUREmOQCAgI0f/782L9/cgbz589XeHi4STxLlixq0qSJxXW9vb3Vvn17k/iTJ0+0YMECi+umFqGhoYZxX19fB3eSOBkyZFDbtm1N4tevX9e6desSXcfoOCpJ/fv3t7g3JI0znWekhGNg0aJFY/99//59Va9eXbt377a6rj198sknWrhwYYLzubm5qUSJEurVq5cmTpyoLVu26Pr167p375527dqlqVOn6p133lHDhg2VK1cuu/bsKp8VPz8/w3h0dLTheQNSFmfav0qucb/VVlLLtaOjtG7d2uT/m3lm4MCB2rdvn1X1jxw5ov/85z+x0/v27VOrVq1UtmzZBPeVztyb5Jjt7kWJ3eaceTtx5t5c5RwkPq54vpocUsJ7bYn4zl+d4f9BePTokWHc39/fqropabtwtnNQAAAApAzO85tuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECKlytXLo0cOdLwZ8SIEXJ3d0/uFgEAAAAAdvTkyRP99ddfhj9PnjxJ7vYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIEXw9vbWsmXLVKtWLUlShQoVNHToUKvrdurUKc50UFCQ2XnLly+vX3/9VRMmTLB4vJw5c6pNmzZxYhs2bLCoVrFixeJMHzhwwOK+nhcTE6OZM2fGib333nvKnTt3kmvlzZtX//nPf2Knp06danV/AADnFhkZqdWrV+vll1/W5MmT4+QGDRqkbNmy2XX8WbNm6ejRo3FizZs3T/TyS5YssXjsCxcumByPK1WqZHG9IUOGyN/fP3b69OnTJsdoAAAAAAAAV1D4ZetrePtKectaXyclGDlypLZt25akn82bN2vFihWaO3euPv/8c3Xo0EEFCxY0O0ZkZKQ+/fRTBQYG6vHjxxb1OXjwYMP4hAkTdP78eYtqvuiLL75QdHS0Sbxbt26JWn7QoEGG8XXr1mnWrFnWtBZrz549mjhxok1qPe/GjRt67733lC9fPjVv3lx37961Sd1ffvnFMP7s97TWOnz4sL744gur65w/f14rVqwwzNWsWdPq+pbKmTOnYfzs2bM2qf/PP/8oe/bs6tatm44cOWKTms+k9PcmPjt27NDs2bNtUuvChQsaNmyYYa5ly5bKkSOHTcb5/ffftWbNGouXDw0N1bJly+Kd5+rVq/rss88sHkOSZsyYYRgvV66cfHx8El3H3scUa48nCUnN29eLXHk/mRTvvfeeYXzz5s364YcfbDLGtWvX9OabbxrmmjdvriJFithknNTkyJEj+uijjwxzr7zyitlccrh//76WL19umOvevbvFdZs3b64MGTKYxJcvX6779+9bXDe1MPeMGm9vb6d8pmm3bt3k6+trEp89e7aioqISXWf+/PmGr71w4cKqV6+eVT0iYc52npHSjoG9evXSmTNnbFbPnjp16qRRo0YpJiYmyctmyJBBr7zyivr06aNx48Zp48aNunLliu7du6cNGzbok08+UYMGDeTh4WGzfl3ls/L83249Lzw83Kre4Pycbf8qucb9VltJLdeOjjJkyBDD+MqVK212T2zKlCmaNGmS6tSpo2rVqmnFihWJOiY5c2+SY7Y7S7c5Z95OnLk3VzkHSSxXOl91tJT2XieWs5+/mrt3EhAQYLMxXHm7cMZzUAAAAKQMzvebSgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAivXGG2/o008/Nfxp3bq1oqOjk7tFAAAAAIAdXbp0SVWqVDH8uXTpUnK3BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAApQkREhL799ts4sa+//lotW7a0uGbNmjXVr1+/OLHffvvNcN7ffvtNhw4dUtu2bTVw4EDVr18/yeN5eXlp9uzZ8vPzi40FBwdr69atSa4lSZkzZ44zff36dYvqGJk0aZIePnwYO502bVqtXLlSAQEBia6RLl06rVq1SmnSpImNzZgxw2Y9AgCcW3R0tAYNGqQDBw7ExtKkSaPWrVvbfewlS5bEma5YsaLhfOHh4XGmo6OjdeTIEavGPnjwYJzp3LlzW1TH29tbAwcOjBP78ssv+Z5TAAAAAADgkrLks02dzHltUwfx++eff1SyZEl98sknioqKsqhG3rx5VaFCBZN4WFiYxo0bZ22Lsc6dO6fNmzebxPPly6cSJUrEu2zRokXNzjNmzBib9PfMd999Z/G6TMjdu3e1Y8cOm9X7448/DOMVKlSQh4eH1fVHjBhhs3Uxc+ZMw3jFihWVNm1am4yRVD4+PobxmJgYm40REhJis1rPS+nvTXw+++wzm9abO3eubt++bRL39PRUkyZNbDKGLXpetmxZvPnx48fr8ePHVo2xevVqRUREmMS9vLwMjxNGHHFMseZ4khipeft6kSvvJxMrICBAgYGBhrkvvvjCpmOtXLlSx48fN4m7ubmpTZs2Nh0rtfjuu+/Mng+NGjVKVatWdXBH5k2fPt0w3qxZM2XIkMGimt27d0/SWIgrMjLSbM7T09OBnSTOi387+UxS3+8HDx6Y/bvL/v37J7kvJI0znWektGPg8uXLtXz5cpvUcpTRo0erTp06+uuvv2xSL0OGDGrUqJFGjRqlTZs26fr16xo3bpxKlSplVV1X+qx4eXkZxu11nwfOw5n2r5Jr3G+1pdRw7ego2bJlU40aNQxzX331lc3GiYmJ0cCBA7Vt27ZEL+PMvUmO2+4s3eaceTtx1t5c6RwkMVzxfNVRUtp7nRTe3t6GcWc5fzV378TcfiOpXH27cLZzUAAAAKQc7sndAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAg9QgMDDSbW79+vQM7AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFKucePGKSgoKHbaw8NDy5Yt08iRI+Xt7Z2kWl27dtW6devk6ekZG1u9erUOHjxoOP+VK1fijLtq1Sp16dIl0eO99NJLWrdunRo0aBAnPmrUKD158iRJvT+TOXPmONPBwcEW1TFy48YNvffee3FiFSpU0NatW1WqVKkEly9VqpT+/PNPlS1b1m49AgCcX3R0tMaPHx8nVrt2bbuP+/fff8eZzpEjh+F89+7dM5mOjo62auzbt2/HmU6XLp1Fdd544w1lzZo1Tt158+ZZ1RsAAAAAAEBy8bXsFokJv4y2qYP4FStWTBs2bNCwYcOUJk0ai2o0bNjQML5582ab/77ozz//NIzXqVMn3uWaNGliGD98+LB27dplZVdxXblyRWvWrLFpTXs5efKkQkNDTeKenp7KmNG6jfDixYtatWqVVTWet2vXLsXExJjEPT09lS9fPpuNkxT37983jBcoUMCxjSRRanhvzLl48aI2bdpk05rh4eGaPn26Yc7cvicpDh8+rAMHDlhdJ74a0dHRmj17ttVjPH78WCdPnjTMJXa7cNQxxdLjSUJS8/ZlxFX3k0nRqFEjeXl5mcSPHTumP/74w+bjvfj72GeaNWtm87FSi27dupn8Lln6dzubP3++/Pz8kqErU5s3b9bFixdN4j4+PmrXrl2S62XNmtXwOHXx4kVt2bLFoh7hvGrUqKGSJUuaxLdt26YzZ84kud7UqVMN4y1btlS2bNmSXA+J42znGSntGGiuvrPbvn27qlSpojZt2mj9+vWKioqyWe2sWbPqnXfe0ZEjRzR9+nSLt++U9llByuNs+1fJNe632lJquHZ0lCZNmsjNzc0kfujQIe3evTsZOvo/ztyb5Pz3pJx5O3HW3lLaOYirnq86Qkp7r5F4rrxdOOM5KAAAAFIO9+RuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgH76+vqpTp44GDx6siRMnas6cOVqxYoVWrFihefPm6aefftLQoUPVoEEDBQQE2L0fHx8f1a5d22x+/fr1FtV1ttcJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJLenT5+qffv2un37dmzM3d1dn376qc6cOaMRI0aoQoUKcnd3N1nWx8dH5cqV0zvvvKMjR45ozpw58vf3j83funVLgwcPNjv28OHDdebMmdhpX19fzZ07V3/99ZcGDRqkkiVLysvLK84yfn5+qlu3rn788UedOnVK9evXj5Pftm2bJk2alOT18HwPzwsJCbG4lpGpU6dq3bp1cWKVKlXSwYMHtXDhQrVu3VolSpRQxowZlTFjRpUoUUJvvPGGFi5cqIMHD6pChQpxll2+fLlN+wMAuIbdu3fHmc6dO7fdx7x7926c6eeP+c97+PChoqKiYqejo6OtHtsWNSSpW7ducaZnzZqliIgIm9QGAAAAAABwtKdPbFMn4rFt6iBhBQoU0FdffaXTp0+refPmSV6+Zs2ahvENGzZY25qJPXv2GMZLlSoV73LVq1c3jK9evdrqnhxZ19ZiYmJ0/fp1w1ymTJmsqm3rdfDw4UOdPXvWMJcxY0abjpVY5tZdx44dHdxJ0qSG98acjRs32qXuH3/8YRivUqWK1bVttS+9c+dOnL+/eF5QUJDZXFIdP37cMJ4hQ4ZELe+oY4qlx5OEpObty4ir7ieTom7duoZxS59pmBBzdatVqyYfHx+7jJnSXb16VX379jXMFS5cWOPHj3dsQ/GYNWuWYbx79+5JrtWpUyd5enqaxGfMmJHkWnB+/fv3N4xPmzbNonp//vmnzp07ZxL38vJSz549LaqJhDnbeUZKOgaePHlS27dvt6pGclu2bJkCAwOVK1cuDRgwQPPmzTP7/iaVu7u7evXqpdOnT6tp06ZJXj4lfVaQMjnb/lVyjfuttpQarh0dpVatWoZxe3x2ksqZe5Oc/56UM28nztpbSjoHSQnnq/aUkt5rJJ6rbxfOeA4KAACAlMP0t8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUoX8+fOrUaNGSVpmypQpNhu/du3aql+/vqpWraoqVaooffr0iomJ0YMHD3T//n39888/2r9/vzZu3Kjdu3dbNEb69OnVu3dvNWvWTGXKlFGGDBkUERGhy5cva+fOnZo5c6Z27txp8Wvw9fVV165dzebnzZunsLAwi+tbqmnTpurbt68aNWokX1/fRC0TERGhrVu3aubMmVqyZImio6Nt3terr75qtp/Q0FDt2rUrSfWc9XUCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzuDUqVOqX7++1qxZozx58sTG8+TJo9GjR2v06NGKjIxUcHBwbO6tt97Su+++Kzc3N8Oat27dUv369XXx4kWz44aEhKhJkybatGmTChQoEBuvVKmSKlWqJEmKjo5WSEiIwsPDFRAQEO/3iR04cEDNmjVTVFRUol97QmJiYmxW65k2bdpo7dq1ql27dmzM29tbHTp0UIcOHRJdZ/PmzerUqZPN+wMAOL87d+7Emc6UKZPdx/Ty8oozHRERYXbes2fPqmjRopKkjBkzWj12lixZ4kzfv38/yTV8fHxUr169OLEFCxZY0xYAAAAAAECyCrkj+fhZX+fhbetrpATPfh9lCQ8PD6VNm1Y+Pj6Jmj937txasWKFvvjiCw0fPjzR4xQvXtww/r///S/RNRLr+vXrhvFn9/3MMddjUp83lFh79+61S117ePDggWHc2vu727dvt2p5I5cvX1bhwoVN4o64F23E3LPDunXrprVr12rJkiUO7ihxUsN7Y86OHTvsUnffvn2KiYkx+TuF/Pnzy9vbO97fXSTE0uffGblx44ayZs1qErflPuvGjRuG8QwZMiRqeUcdUyw9niQkNW9fRlx1P5kUJUuWNIxb83zJ+Fy5ckWXL1+O83dUkuTu7q5ixYrpyJEjdhk3pVu6dKnmzJmjbt26meT69OmjNWvWaMWKFY5v7AUzZ87UyJEjTY43r7zyigoVKqSzZ88mulb37t1NYjExMZo1a5a1baYa5v4+UbLP3/ZZKmPGjGrTpo1J/MGDB1q6dKnFdadPn64xY8aYxPv166evvvrK4rowz9nOM1LSMfDPP/+0sjvncfPmTU2ePFmTJ0+WJGXOnFmlSpVSyZIlVbp0aZUsWVIlS5ZU9uzZk1w7Xbp0WrlypQYNGqRffvkl0cu50mfF3P47vn0+XJ+z7V8l17jfakup4drRUUqUKGEYt+X9JUs5c2+S89+TcubtxFl7c6VzkISkpPNVe0hJ73VSOfv5q7k+oqOjra7t6tuFM56DAgAAIOVwT+4GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACSP1157Tb/88kuSfqzl5uamAQMG6MyZM/rzzz81YsQINW7cWJkyZZKHh4c8PT2VOXNmFSpUSE2bNtWoUaO0a9cunThxQj169EjSWIGBgTp37py+++471alTR5kzZ5aHh4d8fX1VtGhR9erVSzt27NCiRYvk5+dn0ev57rvvzK6rqlWrKiwszKK6lqpevboOHTqkNWvWqEWLFvL19U30st7e3mrcuLEWLVqkkydPKjAw0Ob9xVdzy5YtioyMTFQdZ3+dAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgLM4evSoypcvr4ULFyomJsYk7+npqWzZssVO+/j4yM3NzbDWsmXLVLp0aR07dizBcc+ePauqVatq3rx5hnl3d3elT59e2bJlM/t9YjExMRo/frxq1KihkJCQBMdMbmFhYWrYsKHGjx+v6OjoJC8fHR2tb7/9VoGBgXry5IkdOgQA2EODBg1Uu3Ztm9Ty8fGJM+2I40HOnDnjTN+8edPsvLt27Yr9t6enp4oVK2bV2CVLlowzfeHChSTXqFy5sry9vWOng4ODFRQUZFVfAAAAAAAAyenCIdvUuWijOq6uT58+ypo1q0U/mTJlUpo0aeTl5aVcuXKpUaNGGjZsmHbt2mX4ezfp3+czffTRR/r0008T3WPRokUN4xcvXrToNcfn3r17hvGMGTPGu1zhwoUN44cO2eeDduzYMUVERNilti3kyJFDNWrUUNeuXZUpUybDeZ6/b2mJEydOWLW8kQcPHhjGM2TIYPOxEmPnzp26e/euSdzd3V2LFy/W7NmzVa5cuWToLH6p4b0x5/Tp03ap++DBA8N9nru7uwoWLGhVbVv2bO7vFk6dOmX3MRL7WXDUMcXS40lCUvP2ZcRV95NJUaJECcP4wYMH7TbmgQMHktQLEmfQoEE6f/68YW7atGnKkSOHgzsydfHiRW3ZssUw161bt0TXKVWqlCpUqGAS37x5sy5dumRxf6lNmjRpDOPR0dF6+vSpg7sxr3v37oa9Lly40Kq/6Zg1a5aioqJM4gUKFFCjRo0srgvznO08IyUdA/fu3WvV8s7s7t272r59uyZPnqzBgwerXr16ypEjhzJnzqyaNWuqb9+++uGHH7R9+3Y9fvw4wXoeHh6aNGmSXn/99UT34EqflfDwcMO4l5eX1T3BeTnb/lVyjfuttpQarh0dxdzfxNrrPnhSOHNvkvPfk3Lm7cRZe3Olc5CEpOTzVVtISe91Uj169Mgwbu3v+Gzlxf+35JnQ0FCra7v6duGM56AAAABIOdyTuwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyaNIkSIOHS9fvnzavXu3fv75ZxUqVChJyxYvXlwzZ87U1q1blSNHjgTn79+/v9asWaNMmTIlOG/79u21d+9eZciQIUk9BQYGasCAAYa5s2fPasiQIUmqZ60xY8Zo586dKl++vNW1ihQporVr12rKlCny9PS0vrn/r0mTJmZz69evT1QNV3idAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgDMJDg5Wp06dVL58eU2ePFl37txJ9LK3bt3SjBkzVKFCBbVp00a3b99O9LJ37txR165dVaFCBc2cOVPBwcGJWi40NFTTpk1TmTJlNHToUIWHhyd6zOT29OlTDR06VOXKldP8+fMVFhaW4DJhYWGaN2+eypYtq/fff1+RkZEO6BQAYK1atWpp+/bt2rRpk8aNGyc3Nzera774fbHXr1+3umZC6tatG2f60qVLZufdtm1bnOmWLVtaPG7mzJlVo0aNOLF9+/Yluc4rr7wSZ3rv3r0W9wQAAAAAAOAMjm+WYmKsq3ExSAq9a5N2ICkyMlLXrl3Tpk2b9M0336hmzZoqWLCglixZYnaZkSNH6vXXX09U/YwZM5rEHj9+nOjfrSVFaGioYTwgIMDsMu7u7vL39zfMJeX3jkkRHR1tl9efWD4+PipWrJiaNm2qwYMHa/z48Vq5cqWOHTumsLAwXb9+XTt37tScOXNUsGBBu/Rw9epVm9d8+PChYdzd3d3mYyXG06dP9cUXXxjm3Nzc1K1bNwUFBeny5cv67bff9Nlnn6l79+6qUaOGsmfP7uBu/09qeG/MuXjxot1qm9vmjfaRSXHt2jWrln+euX3ojRs3bDZGSEiIYTyxnwVHHVMsOZ4kRmrevoy46n4yKbJmzWoYT8rfJyWVufOXLFmy2G3M1CA0NFSdO3dWVFSUSS5z5syaPXt2MnRlavr06Ybxrl27JrpG9+7dk1Qbxnx9fQ3jjx8/dnAn8evXr59hfNq0aVbVvXbtmjZs2GCY69+/v1W1YczZzjNS0jHw8OHDVi3vioKDg7Vr1y5NnTpV77zzjmrXrq106dLp1Vdf1ZQpU8ye10v/nsfNmTNHefPmTdRYrvRZefLkiWHc29vb6p7gvJxt/yo5//1WW0sN146OkilTJsO4Pfe5ieXMvUnOf0/KmbcTZ+3Nlc5BEpIaz1eTIiW910llbp/i5eXlFPePzd07Mdd3Urj6duGM56AAAABIOTyTuwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyaNQoUIOG6tgwYL6888/lSdPHqvq1KlTR9u3b1fdunV19epVw3kqVaqkCRMmyM3NLdF1S5UqpenTp+uNN95I1PxZsmTRzJkzDXNRUVHq0qWLHj16lOjxreHh4aFZs2apS5cuNq/95ptvKm/evGrVqpUeP35sVa08efKoRIkSZvMbNmyId3lXeZ0AAACuytvbW/7+/nry5InCwsKSux2n4ePjIz8/P0VERCg0NDS523FKrKOUITXvA559hsPCwvTkyZPkbsfQsx4fP37MdSsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqxw5ckQDBgzQwIEDVbx4cVWqVEm5c+dWmTJl1KlTJ0nS3r17tWjRIl25ckXHjh3TyZMnrR43KChIvXr1kru7u8qXL6+SJUuqYMGCSpcuXez/8x0cHKxbt25p//79OnLkiKKjo60e93lVqlSxab2EHDt2TF26dFGaNGn08ssvq3Tp0sqTJ4/8/PwkSY8ePdLly5d17Ngx7dmzx2n/n3cAgDFvb28tW7ZMWbNmlSRVqFBBQ4cO1ffff29V3WfH42eCgoLMzlu+fHl99NFHunHjht5++22LxsuZM6fatGkTJxbfd4QuXbpUP/zwg9KnTy9Jevfdd/Xzzz8rJCQkyWN//PHH8vT0jJ0OCgrS2bNnk1ynWLFicaYPHDiQ5BoAAAAAAADO5OYZ6Z8dUvFXLVs+JlraNsO2PcHUhQsX1K5dO3Xt2lUzZ86Uh4eHyTw//vijNm/eHO/vgdKmTWv4nCVfX1+7fB+xuWc6+fj4mF0mICDAMB4aGqrIyEib9GXk/v37ypEjh93qS//eI61UqZLKli2rwoULq2DBgipUqJBy5syZpOdf2YMl910TYuvfwdrCxIkT1apVK9WoUcPsPLlz51bu3LnVqlWrOPFHjx7p7NmzOnPmjM6cOaPTp0/r8OHDOnLkiMLDw+3Wc2p5b4w8fPjQbrXv379vGPf397eqri2fJWfufXLEGInhyGOKJceTxEjN25c5rrifTCxfX1/Dc6jw8HC7/h3NvXv3DOPmznmQeP/73/80duxYjRgxwiTXqFEjvf3225owYUIydPZ/li9frnv37iljxoxx4gUKFFCNGjW0a9eueJd3d3c3fJ7mvXv3tHz5cpv2mtJlyZLFMG7P842kqlWrlooXL24SP3LkiE3+NmHq1Klq2rSpSbxZs2Z66aWXdP36davHwP9xpvOMlHYMvHv3rlXLpxSRkZHasWOHduzYoeHDh+vzzz9Xv379DOfNmDGjPvvsM3Xv3j3emq72WYnv2ihDhgxmr/vg2pxp/yq5xv1We0jJ146OkjZtWrm7u5vEw8PDk309OHNvkuvck3Lm7cTZenO1c5CEcL5qXkp7r5MqvvPXzJkz6/bt2w7sxrgHI7Z4drSrbxfOdg4KAACAlMUz4VkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApESFCxd2yDienp5asWKF8uTJY5N6RYoU0ZIlS1SjRg3FxMSY5KdPny4vLy+T+KlTp7Rz505lzpxZgYGB8vb2jpNv3bq1WrRood9//z3BHqZNm6bs2bMb5r744gvt2bMnka/GehMmTFCXLl3sVr9x48aaP3++WrdubXUdc06fPq3z58/Hu7yrvE4AAIDkULJkSZPYzZs3dffuXcP5M2bMqFatWqlhw4YqV66cChYsKB8fn9h8VFSUbty4oSNHjmj//v1avny5goKCkr1vSfLx8VHZsmVVuHBhpU+fXgEBAXJzc4vNT5gwQU+ePLGon9KlS6tFixaqWrWqypYtq1y5csW5toiJidG9e/d0/PhxHTlyRBs3btTGjRstGi9LlizKli2b2XzevHkN4+nTpzdcb/GJiIjQmTNnkrSMOY5aR8m9fnLmzKkMGTKYzPvo0SNdvHgxSfUTy9PTU0WLFjWJR0dH6+TJk/Eu64r7AHPv099//211nfhee6ZMmdS2bVvVq1dPFSpUUL58+eLcHwgLC9Pt27d14sQJbdq0SRs3btSxY8eS1JO1cubMqTZt2qhmzZqqUKGC8ubNG6fHqKgoXbt2TcePH9fu3bu1cuVKHT582LCWp6enMmXKZBIPDg5WZGSk3V4DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOcXExOjEydO6MSJE5KkihUrqlOnTpKkHTt2aPz48XYZNzo6WgcPHtTBgwftUt8ZPXnyRH/++af+/PPP5G4FAGBDERER+vbbb/XVV1/Fxr7++mudO3dOK1assKhmzZo11a9fvzix3377zXDe3377Ta1atZL073eS/P7779qyZUuSxvPy8tLs2bPl5+cXGwsODtbWrVvNLvPo0SNNmzZN7777riQpa9asmjdvnlq2bGn4PbHmNGvWTG+//Xac2DfffJOk/p/JnDlznOnr169bVAcAAAAAAMCZbJggZSskZcqV9GW3zZBunLJ9TzA2d+5cBQQE6KeffjLJ5cuXT23bttXcuXPNLv/8/bkXpUmTxiY9Wuv577B+3qNHj+w67sOHD+1St1SpUurWrZvat2+vfPny2WUMW3j69Glyt+AQERERatGihTZt2qQKFSokaVk/Pz+VLVtWZcuWjROPjIzUtm3bNH/+fC1atEiPHz+2Zcup5r0xEhYWZrfaDx48MIz7+/tbVdcR71dERITdx0gMVzimJCQ1b1/muOJ+Min9GbHXOcAz9+7dM4ynS5fOruOmFp9++qkaN26sqlWrmuS+/vprbdmyRcePH0+Gzv4VHh6uBQsWaNCgQSa57t27a9euXfEu36BBA7300ksm8fnz5zvN8cBV5MyZ0zB+5coVB3diXv/+/Q3jU6dOtUn91atX69atWybPafL09FSvXr00ZswYm4yDfznTeUZKOwaaO5dPze7cuaP+/fvrf//7n2bMmCF3d3eTeTp16qQRI0bo0qVLZuu42mclvr/byp49u+7fv29NW3BSzrR/lVLGtbElUvK1o6Mk1z43MZy5N8l1tjtn3k6crTdXOwdJCOer5qW09zqpbt26ZTb30ksv6fbt2w7sxrgHI/H1nViuvl042zkoAAAAUhbTO/oAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUjw3NzcVLFjQIWO99dZbKlOmjE1rVq9eXb179zaJv/LKKypXrpxJ/LffflOJEiXUu3dvtWzZUq+++qoiIiJM5hs0aFCCY/fq1UstWrQwzP3111/65JNPEn4BNtKlSxcNHDgwUfM+evRIhw8f1ubNm7Vx40YdOnRIDx8+TNSyrVq10vvvv29Nq2rSpInZ3Pr16+Nd1pVeJwAAQHI4fvy4yY/R+XLu3Ln1yy+/6ObNm5o+fbo6dOigEiVKyMfHJ858Hh4eypUrlwIDAzVy5EgdOnRIJ06cUNeuXeXu7u7wvt3d3dW+fXtt3rxZoaGh2rdvnxYsWKBJkybp66+/1ldffRX7kzZt2iT14OXlpT59+ujkyZM6evSoPv/8czVv3lz58+eXl5dXnHnd3NyUKVMm1apVS4MGDdLvv/+uO3fuaPLkySpQoECSxh04cKDh63/2M27cOMPlGjZsGO9yRj8zZsxIUm8vSo51lNzrJzAw0HDeoKAgk+3FVlq2bGk45vfff5/gsq64DzD3ftiijtFrz5kzp6ZNm6YbN25o8uTJateunYoUKSJvb+8486VNm1b58uVTkyZN9N133+no0aPavn276tSpY+lLTbSqVatqw4YNunLlin744Qe1bdtWhQsXNunRw8NDefLkUZMmTTR69GgFBQVp//79at68uUnNV155RTdv3jT5qVixot1fDwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJDSjRs3TkFBQbHTHh4eWrZsmUaOHGnyvSEJ6dq1q9atWydPT8/Y2OrVq3Xw4EHD+a9cuRJn3FWrVqlLly6JHu+ll17SunXr1KBBgzjxUaNG6cmTJ/EuO3bsWF29ejV2unnz5vr999+VPn36RI3du3dv/frrr3G+z2b37t1auHBhovt/XubMmeNMBwcHW1QHAAAAAADAmYSHSks/loKvJDzv8/b+Ku1bap+eYN7PP/+svXv3GuZ69eoV77Jubm72aMkhYmJi7Fo/OjrapvXy5cunBQsW6OjRoxo2bJjy5ctn0/qw3N27d1W9enX9/PPPioqKsrqep6en6tevrxkzZujMmTPq2bOnDbqEZN/t3tx77wr7SXvvDxPLFdYVLJNS95Pmnn9hi9cYH1fe37iCqKgoderUSY8ePTLJ+fj4aOHChUn+fbqtTZ8+3TDerl27BJ9L07179yTVhHlFixY1jD//9xDJKVOmTHrjjTdM4uHh4Zo/f75NxoiMjNScOXMMc3379mW/lIKltGNgYp8ZnBrNnj3b7HOuPT091aNHj3iXd7XPSnBwsOHzwiUpT548VvcFJEZqPn6m1GtHRzH32bH3PjcxnLk3ybW2O2feTpypN1c7B0kI56vmpbT3OqlCQkJ08+ZNw1yhQoUc2suLMmXKZPb/zzh9+rTV9dkuAAAAAPOMr5QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApGiZMmXS7t279eeff8b52bdvn83H6tOnT7z5vXv3Knfu3PL09JSXl5fy5s2rLl266NChQ/Eu17t3b5NYkyZNDOd97733FB0dHWfMxYsXm8xXp04deXt7mx2zYMGC+uGHHwxzYWFh6tSpk6KiouLt21YyZMigcePGJTjfhg0b1LBhQ2XMmFHly5dXw4YN1bhxY1WsWFGZMmVSrVq1tHTp0gTrfPrpp8qTJ49FvXp4eKhBgwZm8+vWrTObc6XXCQAA4Mx69OihEydOqG/fvvLy8kry8sWLF9ecOXMUFBSksmXL2qFD8+Pu2bNHixYtUv369eXp6Wmz2o0aNdLp06c1depUFStWzKIafn5+6tevn06fPq3vv/9eadKksVl/tnL8+HGLl00N68ho/SxatEihoaEm8QwZMqh58+Z26aNLly6G8RkzZtikvqvuA2yhU6dOOnXqlHr37m3Ra69Vq5a2bt2qpUuXys/Pz+b9BQQEaN68edq7d68aNWokNze3JNeoXLmyfv/9dy1btkyZMmWyeY8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATD19+lTt27fX7du3Y2Pu7u769NNPdebMGY0YMUIVKlSQu7u7ybI+Pj4qV66c3nnnHR05ckRz5syRv79/bP7WrVsaPHiw2bGHDx+uM2fOxE77+vpq7ty5+uuvvzRo0CCVLFnS5PtW/Pz8VLduXf344486deqU6tevHye/bds2TZo0KcHXHRwcrM6dO8f5rtdmzZrp7Nmz+vjjj1WqVCmTZTJlyqR27dpp9+7dmjZtWpzvIrp165Y6d+6smJiYBMc24uvrG2c6JCTEojoAAAAAAADO5v51ae470t9bpYRunYQGS6u+kLbZ5iuNYQFz99aqV69u0XcjOxNz9+6M7n3aki3XW4MGDRQUFKSOHTta9D3Q0r/3Rvfu3at58+ZpxIgR6tChgypVqqQ9e/bYrM/ULDw8PPb+9qxZs/Tw4UOb1M2ZM6dmzJihBQsWyMfHxyY1ASA5sJ+EKzl79qyGDBlimCtTpoy+/PJLB3cU16FDhxQUFGQST58+fbzPpfH391erVq1M4kFBQYb1EL9y5coZxv/++28Hd2Kse/fuhvvF/fv3q0iRIqpatapNfo4ePWo4ft68ec0+nxdwNpb+zU9qMXbsWJ0/f94wV7duXQd3Y38XLlwwjBcvXtyxjQCpFNeOQMKceTtx5t5cGeeriM/p06cN46VLl3ZwJ4kbPyoqyuz1RVKwXQAAAADmeSZ3AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAc7+7du6pbt65JvGjRovrnn39sNk7+/PlVsmRJs/lZs2apV69eiomJiY1dvnxZ8+fP18KFC7Vo0SK1bdvWcNmXX35ZWbJk0Z07d2JjRmNdv35d58+fN4nv2LFDXbt2jRPz8vJSoUKFdOLECZP53d3dNX/+fPn7+xv28+677+r06dPGL9QOPvroI2XJksVs/vHjx+rWrZuWLl1qdp6oqCjt3LlTO3fuVP369bVs2TKlT5/ecF5fX199/vnn6t69e5J7ffnll83WDQ8P159//ml2WVd6nQAAAM5q/PjxGjJkiE1qlSlTRvv371e/fv00a9Ysm9Q0p1q1alq/fr0yZMhg07ru7u6aOHGiBg4caLOaHh4eGjp0qF5//XU1b95cJ0+etFltax0/fjzJy9h7HRUtWtRmda1ltH4ePXqkhQsX6s033zTJ9ejRQ0uWLLFpDxkyZFBgYKBJPDg4WCtXrrS6vqvuA2zh888/1/Dhw21S64033lCxYsXUrFkzXbhwwSY1S5YsqdWrV6tAgQI2qde6dWuVLFlS9erV0/Xr121SEwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIB5p06dUv369bVmzRrlyZMnNp4nTx6NHj1ao0ePVmRkpIKDg2Nzb731lt599125ubkZ1rx165bq16+vixcvmh03JCRETZo00aZNm+J8f0mlSpVUqVIlSVJ0dLRCQkIUHh6ugIAA+fr6mq134MABNWvWTFFRUYl63du2bVP79u01b948+fj4SJIyZ86szz77TJ999pkeP36s27dvKyIiQpkyZVLGjBkNX++NGzcUGBhos+90kRTne24BAAAAAABcXXiotPorad9SqWQ9KX8FKSCL5JVGCrsv3b4gndkj/b1Fehqe3N2mbmvXrjWM+/j4qGTJkjp8+LBh3tz9rPv372vRokU26y8hd+/eNZsLCwszjKdLl85e7UiSzb6jPjAwUKtWrZKHh0eC84aGhurUqVM6deqUTp8+Hee/9+7dM1zmyZMnNukT/zp16pR69uypfv36qU6dOqpSpYoqVaqk4sWLq2DBgrH3pJOqY8eOCggIULNmzWzcceri5eWlp0+f2qW2t7e3YTyxv7uAcxxT4juewDZS0n7S3Pbt6elp13G9vLwM4+xvbGv69Ol6/fXX1bJlS5PcO++8o7Vr12rz5s2Ob+z/mz59uiZOnGgS7969u9nn0rRp08bw9+7Tpk2zeX8pna+vrypUqGCYO3DggIO7MdavXz/DeM2aNbV3716H9DBgwACtW7fOIWPBsTgGpi5RUVH6+eef9c0335jkqlevHu91lit+Vo4ePWr4jLry5ctb2xaQKM5wbSwl//VxSrp2TCxzf5ObWNHR0YZxe+9zE8OZe5OcY7uzZJtz5u0kuXtzxXMQWIb3Wjp58qRq1qxpEq9evbrDe3neyy+/bBg/d+6c3X5PAwAAAOBfznHHBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECKlC9fPrO5kJAQDRo0SDExMYb56Oho9e3bV82bN5ePj4/hPHny5NGdO3dipzNkyGAyz61btwyXNRfPlCmTYfyjjz7Syy+/bJhbu3atJk+ebJizhzRp0qhPnz5m81FRUWratKn+/PPPRNfcsmWLXn31Ve3Zs0e+vr6G83To0EHvvvtunHWeGE2aNDGb27Fjhx4/fmyYc7XXCQAA4IzGjx+vIUOG2LSmt7e3ZsyYoXTp0mnChAk2rf1MwYIFtX79esNzfGukSZNGS5Ys0euvv27Tus8UKVJEu3fvVrNmzbRr1y67jJFUx48fT9L8jlhHNWrUcPr1M2XKFL355psm8caNGytHjhy6ceOGzXpo27atvL29TeILFixQRESEVbVddR9gC8OHD9fw4cNtWrN06dLauHGjKlWqpJCQEKtqlStXTps3b1aWLFls1N2/ihcvri1btqhKlSo2rQsAAAAAAAAAAAAAAAAAAAAAAAAAAAAgZbt27ZpGjRolSdq9e3cydwMAgGs5evSoypcvrx9//FEdOnSQm5tbnLynp6eyZcsWO23ue1YladmyZRowYIBu376d4Lhnz55V1apVNW7cOHXp0sUk7+7urvTp08dbIyYmRj/88IM+/PBDhYeHJzjm85YuXarr169r9uzZKlSoUJycr6+v8ubNG+/y69evV+/evXXt2rUkjQsAAAAAAJAa3Tr77w+c1+3bt/XkyROlSZPGJJc1a1azyz158sQwHhoaqgEDBtisP2s8evRIMTExJvc+06RJozRp0ph9DdayxffU58+fXwsWLJCHh4dh/u7du1q2bJk2bdqk/fv36+LFi0ke48X1AtuIiIjQxo0btXHjxtiYm5ubcufOrcKFC6tw4cIqUqRI7L8LFy5s9nlUz7z++uv66KOPNHbsWHu3n2KlT5/ebs/1MrfNh4aG2mW8lMgVjimwnZSwnzS3fdv6WTUvMvesyocPH9p13NSoT58+qlatml566aU4cTc3N82ePVtlypRRcHBwsvQ2f/58ffvttya/v2/cuLGyZs1q+Dv7Hj16mMTCw8O1YMECe7WZYtWuXdvs307s27fPwd2Yql27tooVK5bcbahp06bKnTu3rly5ktytwMY4BqY+mzdvNoz7+PgoR44cunz5smHeFT8rR44c0RtvvGESr1WrltV9AYnBtXFcKeHaMbES6jsh5j47Cf0driM4c2+S6293zrydJFdvrngOAsvwXkvbtm1Tnz59TOK1atWSp6enIiMjHd6TJNWrV88wvm3bNgd3AgAAAKQ+nsndAAAAAAAAAAAAAAAAAADAMq1GSV6m3wMI2MydC9IfvyR3FwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABcXdasWc3mDhw4oLCwsHiXv3//vo4eParKlSsb5rNnzx5n2sPDw2Sep0+fGi5rLm5Uo3Llyho1apTh/Ldv31bPnj0Nc/bSunVrZcyY0Wx+7Nix+vPPP5Nc98iRI3r33Xf1888/G+a9vb3VpUsXjR8/Pkl1mzRpYja3bt06szlXe50AAADOplu3bhoyZIhJPCIiQhs2bNC6desUFBSkGzduKCwsTH5+fsqePbuKFCmiJk2aKDAwUBkyZDCs7ebmpvHjx+vcuXNavXq1Tfv28PDQb7/9ZnZsa8ydO1evv/662Xx0dLT+97//adWqVdq/f79u3Lih4OBgpU2bVtmzZ1fhwoXVtGlTNWnSxGx/GTNm1Jo1a1S9enWdOHHCcJ4rV65oz549ZvvInDmzihQpYhIPDg7WqVOn4n+RLzh27FiS5nfEOnKF9fPXX3/p8OHDKleuXJy4h4eHOnfurO+++y5J48SnS5cuhvEZM2ZYVddV9wG20KBBA40ePdokHhMTo+3bt2vFihX666+/dPXqVYWFhSldunTKmjWrKlSooKZNm6px48aG9wckqUiRIpo9e7Zat25tcX85cuTQ+vXrlSVLFrPzPHnyRH/88YdWrVqlEydO6ObNm7p3717s+5QvXz4FBgbqtddeU+bMmeMsW6JECU2aNEnTpk2zuEcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqcuNGzcM/z9tAACQOMHBwerUqZO+/PJLDRgwQG3atIn3+0Wed+vWLa1evVoTJ05UUFBQksa9c+eOunbtqu+++05vv/22WrRooUyZMiW4XGhoqBYtWqTx48fr+PHjSRrzebt27VLx4sXVp08fDRo0SKVLl453/qioKP3xxx/6/vvvtX79eovHBQAAAAAAAJzR7du3lSdPHpN4fN+5HhYWppiYGLm5ucWJJ+Y+nyPduXPH8FlUOXLk0IULF2w+np+fX7zPLUqssWPHGq7/0NBQ/fe//9WUKVMUERFh1Rj+/v5WLY/Ei4mJ0eXLl3X58mVt3bo1Ts7NzS32O9b79++vEiVKGNb473//q8mTJys4ONgRLac4GTJk0J07d+xW20hoaKhdxkuJXOWYAvtxtf1keHi4IiMj5enpGSfu6ekpPz8/PXr0yC7jmjvHCAkJsct4qdndu3fVo0cPrV+/3mTflDNnTk2dOlVvvPFGsvR27949rVixQu3bt48T9/T0VMeOHTVhwoQ48bx58+rVV181qbN8+XLdu3fPrr2mRJ07dzaMHzt2TFevXnVwN6b69++f3C1I+vc5SX369NEnn3yS3K3AxjgGpj7xPVctc+bMunz5smHOFT8r27dvN4wXLVpUefPm1aVLl6zqDUgI18YJc5ZrR3PPCbRUQECAVcub++x4eXnJ19dXjx8/tqq+NZy5NyllbnfOsp0kV2+ueA4Cy/BeS1u2bDGM+/v7q0GDBsny/zykT59edevWNcxt3rzZwd0AAAAAqY9nwrMAAAAAAAAAAAAAAAAAAJxR3rKSj19yd4GUzNMruTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkBI8efLEbO7x48cOqeHu7p6k+It8fX01f/58eXp6Gub79OmjW7duJaqWrQQGBprNPXz4UF999ZXFtX/55Rd9+OGHyps3r9mxx48fn+h6WbJkUaVKlczmN2zYYDbnSq8TAADA2eTIkUMfffRRnFhMTIwmTZqkMWPG6Nq1a4bLnTt3Tv/73/80Z84c+fn5aejQoXr//feVLl06k3nd3Nw0f/58lSpVSleuXLFZ74MHD1a5cuVM4vfu3dPvv/+u1atX6+jRo7p586YePHiQ6LojRoxQmzZtzObXr1+vYcOG6ejRo4b5Z+tm7ty58vPz03/+8x8NGzZM/v7+JvOmT59ea9asUfny5fXw4UOT/IwZMzRjxgyzvbRu3VrLli0zif/xxx9q27at2eWs5ah15CrrZ+rUqfrxxx9N4j169NB3331nkzFy586tWrVqmcQPHz6sQ4cOWVzXlfcB1kqTJo2mTZtmct2/Zs0affDBBzp+/LjJMjdv3tTp06e1e/du/fTTTypZsqQmTJig+vXrG47RqlUrtW3bVkuWLElyf25ublqyZIly5MhhmI+Ojtb06dM1fPhw3b5923CeZ+/TokWL5O3traFDh+rjjz+Os6117dpV//zzT5L7AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGC5I0eOaMCAARo4cKCKFy+uSpUqKXfu3CpTpow6deokSdq7d68WLVqkK1eu6NixYzp58qTV4wYFBalXr15yd3dX+fLlVbJkSRUsWFDp0qWTn5+fwsLCFBwcrFu3bmn//v06cuSIoqOjrR5XkiIjIzV58mRNnjxZOXPmVO3atZUzZ05ly5ZNAQEBevTokW7fvq2///5bu3fvVnBwsE3GfaZKlSo2rQcAAAAAAABYKioqyjAe33OSoqKidPv2bWXLli1OPG3atEqTJk28z25ypH/++UdZs2Y1iVetWlUXLlyw+XiVK1dO9POlzMmfP7/at29vEg8PD1eDBg20d+9eq+o/kyVLFpvUgXViYmJ06tQpnTp1ShMnTtSoUaM0atQok/n8/f3Vp08fff3118nQpevLnj27zpw5Y7faRu7cuWOX8VIiVzmmIHk4637y6tWrypcvn0k8R44cOnv2rF3GNPesiBs3bthlvNRu48aNmjhxot5++22TXOvWrdWjRw/NmjXL8Y1Jmj59uuH5Yvfu3TVhwoQ4sa5du8rNzc2wBpImU6ZMat26tWFuzZo1Du7GVJYsWcz2lxz69Omj0aNH2+xvPOA8OAamLmFhYQoPD5ePj49JLnPmzPEu62qfld27d+vx48fy9fU1ybVp00bff/+91f0B8eHa2Dr2uHY0d988ICDA6n6flydPHquWj46O1s2bNw33gdmzZ7fLffDEcubepNS33TnrPRZb9+Zq5yCwXGp/r69fv64TJ06oRIkSJrlu3bpp/fr1Du+pXbt28vb2NonHxMTojz/+cHg/AAAAQGpj3V8tAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEA8rl69ajZXsGDBRNUoUKCA2dyVK1fiTIeFhZnM4+/vb7isufijR4/iTH///fcqWrSo4bzTp0/XypUrzfZnL/Xq1TObW7BggclrSIro6GhNnTrVbP7VV1+Vp6dnous1bNhQbm5uhrmrV6/q+PHjZpd1pdcJAADgbAYMGKD06dPHTj948ED169fXoEGDdO3atUTVePTokT7//HNVrFhRJ06cMJwnXbp0GjdunE16lqS0adPq448/jhMLDw/XV199pQIFCqhnz55atmyZTp06pQcPHiS6bunSpTVixAjDXGRkpPr166fAwEAdPXo0UfUePXqkzz77TOXKlTO7bgoUKKCvv/460T0mN0evI1dYP/PmzdPjx49N4qVLl1aFChVsMkanTp0Mr5lmzJhhVV1X3QfYQp8+fZQvX77Y6Wef39dffz3ea9Dn/f3332rUqJFmzpxpdp5hw4ZZ3F/NmjUNc6GhoWrQoIH69u2r27dvJ6peRESEvvrqK5UtW1bnzp2Lk/vwww8t6hEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAdWJiYnTixAnNmzdPX375pb777rvY3I4dOzR+/HgtXbpUJ0+etOm40dHROnjwoObNm6fRo0frvffe04ABA/Tuu+9qzJgxmjp1qoKCghQdHW3TcZ+5du2aFi5cqO+++04ffPCBBg4cqPfff19ff/21Vq9ereDgYLuMCwAAAAAAADgDLy8vw3hC9+MuXbpkGC9durTVPdmKue+pNvd9y9aqVq2a1TWaNm0qd3d3k/jPP/+svXv3Wl1fktzd3ZUtWzab1ILtxMTE6JNPPtHPP/9smG/cuLGDO0o5KleubJe6uXLlUvbs2U3iT58+1fnz5+0yZkrlCscUJD9n2k/+/fffhnFbnAuYU7VqVcN4Yp9ngaQbNmyYjh07ZpibOHFiop9ramubN2823G9WrFhRpUqVihPr3r27yXyXLl3Sli1b7NZfSvX+++8rbdq0hrlZs2Y5thkD3bt3l7e3d3K3EStXrlx67bXXkrsN2AHHwOTl5+fn8DFjYmIM40b3Lp7nap+ViIgIbdq0yTDXt29fq/qyRIYMGZLl/Uby4trYNmx17Xjv3j3DeLp06SzuzUixYsWsrnHx4kXDeKVKlayubS1n7k1KvdudM91jeZG1vbnaOQgsx3v977OLjbRp00a5c+d2cDfS0KFDDeObN29O9HNuAQAAAFgu/rv2AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGCFkydP6tGjR4a5YsWKqXHjxvEu/8YbbyhXrlyGubt37+rixYtxYpcvXzaZL3/+/PLx8TGJlyxZ0rDupUuXYv/dtGlT9e/f33C+s2fPasiQIWZ7t5eMGTMqZ86cZvNbtmyxeow//vjDbC5NmjQqVKhQomsFBgaaza1fv95sztVeJwAAgLNJkyZN7L/DwsJUr149bd261aJaZ8+eVbVq1XTw4EHDfJs2bVSjRg2Lar+oY8eOypIlS+z0nTt3VK9ePX344Yd68OCBxXUnT54sLy8vk/jTp0/VtGlTTZkyxaK6586dU7Vq1bRnzx7DfN++fVW1alWLajtacqwjZ18/Dx480NKlSw1zPXv2tMkYXbp0MYk9ffpU8+fPt6quq+4DbCFPnjyx/46Ojlb79u0t+vxGR0erV69e2r59u2G+cuXKevXVV5NU09/fX2PHjjXMhYSEqG7duha/T+fPn1fNmjV19uzZOOMBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD7y5o1q2E8NDQ03uWOHj1qGK9WrZrVPdmKue9Obt26tTw8PGw+XqdOnayuYe47pBctWmR17WcqVaokX19fm9WDbY0cOVKRkZEm8SpVqiRDNylD9erV7VL35ZdfNoyfPXtW0dHRdhkzpXKFYwqchzPsJ48dO2YYr1mzpl3GK1asmDJnzmwSDw8Pj/OsB9hWeHi4OnXqpPDwcJOcv7+/5s+fb5dzyoTExMRo1qxZhrlu3brF/rtatWoqUqSIyTwzZ85UTEyMvdpLkQoVKmT2GbA7duzQyZMnHdyRqX79+hnGu3TpIh8fH7v+7N6923Bsc8/UhWvjGJg8smfProkTJ+rKlStm7+PYQ7p06eI8U+x5Cd03csXPyty5c83WbtasmVX9JdWIESN048YNTZkyhfsBqQjXxrZl7bXjvXv3DOMFChSwqq8X1a5d2+oaQUFBhnF73RNLCmfuTWK7c4Z7LOZY2psrnoPAMrzX/97jiYqKMol7eXnp448/dmgv7dq1U4kSJQxzv/zyi0N7AQAAAFIr9+RuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDK9fjxY/32229m80uWLFHHjh1N4u7u7urZs6fmzp1rdtnFixcrMjIyTmzXrl0m83l7e6tTp05xYl5eXobjnj9/Xrdv35YkZcmSRTNmzDAcOyoqSl26dNGjR4/M9mcvxYoVize/f/9+q8c4ePCgoqKiLO7heY0bNzabW79+vcVjONvrBAAAcGYDBw7UwYMHraoREhKiN954Q/fu3TPMv/POO1bVf6Zo0aKx/75//76qV6+u3bt3W1WzVq1aqlGjhmHu/fff16ZNm6yq/2zd3Lp1yyTn5uamjz76yKr6jpBc68gV1s+UKVMM4506dZKnp6dVtUuXLq0yZcqYxFetWqW7d+9aVft5rrQPsLVRo0bFe18iMXr06KGnT58a5lq0aJGkWt27d1eWLFkMc2+//bb++uuvJPf3vOvXr6tLly7xXusCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADbyp8/v7y9vQ1zV69ejXfZffv2Gcbr1KljbVs2s2nTJsXExJjEc+XKpdatW9t0rJdfflnlypWzus5LL71kGD9x4oTVtZ+pV6+ezWrB9u7evaugoCCTeEBAgNntFfGrV6+eXdZd06ZNDeM7d+60+VgpnSscU1IqDw+P5G4hyZxhP2nueSivv/66XdZpy5YtDePbtm3jOQ92dvToUbPPqHn55Zc1YsQIB3f0r5kzZxqe53bp0kVubm6S/n1uyYtiYmI0c+ZMe7eXonh6emr27Nny9fU1zH/++ecO7shU3bp1VaRIEZN4cHCwlixZooiICLv+TJs2zbCvJk2aKG/evPZ++XAwjoGOlTFjRn355Zc6d+6cBg8erAwZMmjYsGEOG79gwYJmczdv3ox3WVf8rKxatUp37twxzH399dcOO3f28/NTr1695O/vrzfffFP79u1TUFCQBg0aJD8/P4f0kBxc8drE1rg2ti1rrx2Dg4MN4xUrVrS2tVienp5q1KiR1XX27t1rGDd378qRnLk3ie3OGe6xmGNpb654DpJa2Hr9817/+xzYVatWGebefPNNmx6z4pM2bVp9++23hrlbt27p999/d0gfAAAAQGrnntwNAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEjZRo8erbCwMMNcQECAFixYoMWLF+uHH37QhAkTtGTJEl29elUzZsyQr6+v4XIPHjzQF198YRJfuXKlQkNDTeITJ07UW2+9pTJlyqhOnTpau3atChcubDLf/PnzY/89ffp0Zc+e3XD8sWPHas+ePYY5ezPX0zNXrlyxeownT57ozp07FvfwTPny5ZUtWzbDXFRUlDZv3mzxGM70OgEAAJzZjh07NHv2bJvUunDhgoYNG2aYa9mypXLkyGGTcZ7p1auXzpw5Y3Wd9957zzC+efNm/fDDD1bXl6Rr167pzTffNMw1b95cRYoUsck49pKc68jZ18/OnTt18uRJk3jmzJn12muvWVW7S5cuhvEZM2ZYVfd5rrwPsNbhw4cN7x0k1fnz57VixQrDXM2aNZNUa9CgQYbxdevWadasWUnszNiePXs0ceJEm9QCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJa9WqlWH86dOnOn36dLzLbty40TDevHlzZc2a1erebOHOnTtmnzU0atQoeXt722yszz77zCZ1MmbMaBh/8uSJTeq7u7ub/X56JJ29vuf82rVrhvEMGTLYZbyULmvWrOrQoYNNa2bJkkWdOnUyzK1fv96mY6UGrnBMcXWPHj0yjAcEBNh13JS6n9y2bZvhOs2TJ4/atGlj07G8vLz09ttvG+ZWrlxp07Fg7Pvvv9eWLVsMcx9//LFy587t4I7+fRbLH3/8YRLPmTOn6tevL29vb7Vv394kv2XLFl28eNERLaYYkyZNUo0aNQxz27dvN3sMc6T+/fsbxufPn6+IiAi7j7948WLD5/G6u7urb9++dh8fjsUx0HFatWql8+fP64MPPlDatGlj40OGDFH58uUd0kPr1q0N40+ePNGFCxfiXdYVPyvh4eEaP368Ya548eIaNWqUJe0l2ZgxY0zOa8uVK6dvv/02zmfBVSXXtYkrSM3Xxs547fj3338bxnPkyKHChQtb01asN954wybvrbl7USVKlFD9+vWtrm8NZ+5Ncq3tzhm3k2ecqTdXPAdJaRx1rOe9/tcnn3yi6Ohok7i7u7sWLFjgkPPHn3/+WXny5DHMffbZZ4qMjLR7DwAAAAAk9+RuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDKdubMGQ0aNEgxMTFm52nXrp3efvttvfXWW2rTpo1y5Mhhdt6oqCj16dNHV65cMck9ePBAX3zxhUncz89PEyZM0JEjR7R161Y1aNDAZJ7r169r3LhxkqTevXurefPmhuPv379fn376qdn+7M3f399s7tGjR4qKirLJOA8ePLCoh+c1adLEbG7v3r26f/++RWM42+sEAABwZp999plN682dO1e3b982iXt6esZ7/pdUy5cv1/Lly62uExAQoMDAQMOc0bWDNVauXKnjx4+bxN3c3NSmTRubjmVLyb2OnH39SNLUqVMN4z169LCqbseOHU1iN27c0Pr1662q+zxX3QfYwogRI2x27Thz5kzDeMWKFZU2bdpE1ShatKhKlChhmBszZozFvRn57rvvbPbaAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjv2rVrGjVqlEaNGqUNGzYkdzsAAAAAAAAAbMjf31/vvvuuYW7Pnj168uRJvMufO3dOR48eNYl7e3vrzTfftEmPz6RPnz7eZ0PFZ+LEiYbxUqVK2ex7lvv27Wv4bClLhISEGMazZs1qk/odO3ZUoUKFbFIrNcudO7cmTZqkixcvqkWLFjav7+3tbRh//PixzcdKLd577z15eHjYrN5//vMfpUmTxiT+6NEjbdy40WbjpBaOOqZYczxxdffu3TOM58uXzy7jpfT9ZEREhBYvXmyYGz58uLy8vGw2Vt++fZUzZ06TeHh4uJYsWWKzcRC/bt26KTg42CTu4eGRbM+OnD59umG8e/fuev3115UxY8ZELwNTbm5umjx5svr06WOYDw8P14ABAxzclaksWbKoZcuWhrlp06Y5pIewsDAtWrTIMNe7d2+bnoMh+XEMdJyTJ08qICDAJO7l5aX58+fb/fjj7++vnj17GuZ27typ6OjoeJd31c/Kjz/+aHjMl/7tu2nTphb1mFi1a9fWW2+9ZZibNWuW4XPYXI2jr01ciavcb7UlZ752PHXqlO7evWuYs/ZZkNK/z1D85JNPrK4jSdevX9euXbsMc//9739tMsYzffv2Vbly5RI9vzP3JrnGPSln3k6csTdXPQdJSRx1rOe9/tfhw4c1d+5cw1yxYsW0YMECubu72238IUOGqHv37oa506dPa/LkyXYbGwAAAEBc9jvzBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAID/b9asWerQoYMiIiKsqvP48WO1bNlSS5cuNTvPF198oa1btyapbnR0tDp37qzg4GAVKlRI48ePN5wvLCxMnTt3VlRUlCQpc+bM6tOnj2bMmKH169dr8+bNWrx4sT788EMVL148ST0kVtq0ac3mQkNDbTZOfLX8/f0TVSMwMNBsbv369fEu60qvEwAAwFldvHhRmzZtsmnN8PBwTZ8+3TDXpEkTm41j7pw8qRo1aiQvLy+T+LFjx/THH3/YZIznmeu7WbNmNh/LVpxhHTnz+pGk2bNnG17Pvvbaa8qSJYtFNWvVqqW8efOaxOfOnRt7zWktV94HWOvixYtatWqVzert2rVLMTExJnFPT0/ly5cvUTXMrZ/Dhw9r165dVvX3oitXrmjNmjU2rQkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAcjdu3NDo0aM1evRobd68ObnbAQAAAAAAAGAj7u7umjp1qnLlymWYX7BgQaLqTJ061TA+fPhwFSlSxOL+XjRu3Dj9888/evvtt+Xu7p6kZVevXq0jR44Y5v7zn/+oT58+VvXWsGFDm31HvSTduXPHMF69enWra+fKlUvjxo2zuk5qljt3bv388886e/as+vfvL29vb02YMEGZMmWy6TiFCxc2iYWFhSkkJMSm46QmZcqU0TfffGOTWrVr19awYcMMc3PnzuV9spAjjinWHE9c3dWrVw3jRYoUUfbs2W02TmraT3777beGz4MoU6aMzc4NKlSooG+//dYwN2fOHN26dcsm4yBh165dU9++fZO7jTh+++033b9/3yTeunVrDRo0yCR+//59LV++3AGdub4cOXJoy5Yt6tevn9l5Pv74Y/39998O7MpYz5495e3tbRL/66+/zF4H2cO0adMM4zly5FDz5s0d1gccg2OgY5w4cUKLFy82zJUsWVJr166Vr6+v3cYfP368cufObZhbsmRJomq44mflwYMH+uCDDwxz7u7uWrp0qRo0aJDkPhOjfPnyWrlypeG1SkREhNnX6WocdW3iqlzhfqstuMq14+7duw3jb775pjJkyGBNa/roo49UvHhxq2o8b/LkyYbx+vXra8iQITYZo3Llypo0aZKCgoK0atUqVa1a1eV7k5z3npQzbyfO3JvkmucgKYkjj/W81//66KOP9ODBA8NcixYtNH/+fMPnP1trwIAB8f7ecejQoYqMjLT5uAAAAACMpa6/ggEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQLHx8fFSnTh15eXlZXadevXry9PQ0O09MTIxatGihlStXJqrmgwcP1KJFC23dulXu7u6aN2+e/P39Def9z3/+o9OnT8vNzU0jRozQ5cuXNXXqVPXs2VONGzdW/fr11a5dO33xxRc6ceKEli1bpowZM1r0Ws1xc3Mzm4uJibHZONHR0Rb18Iy/v7+qV69uNr9+/fp4l3eV1wkAAODMNm7caJe6f/zxh2G8SpUqNql/8uRJbd++3Sa16tataxhP6HzUUubqVqtWTT4+PnYZ01rOsI6cef1I0t27d7VixQqTuJeXlzp27GhRzS5duhjGZ86caVE9I666D7CF1atX27Tew4cPdfbsWcNcYq/7zV0j27pXe9cFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABSlixZ9Ntvv6lDhw6G+Vu3bmnu3LmJqjV9+nTdvn3bJJ42bVrNnz9ffn5+VvUqSX369FHPnj2VLl06/fDDDzp48GC8zxd6UUxMjN5++23DnLu7u6ZOnarhw4fL3d09yb116NBBq1atkq+vb5KXNefUqVOG8X79+llVN23atFq6dKmyZs1qVZ3UbvLkyRowYIC8vb1jY3nz5tWSJUts9jmoWrWqChcubBK/cuWKTeqnZkOHDtWbb75pVY0SJUpo0aJF8vDwMMlFRkZq/PjxVtVPzex9TLH2eOLqrl69anY/MnDgQJuNk5r2kydOnNCvv/5qmBs4cKCGDh1qVf0iRYpo+fLlSpMmjUnuyZMn+vLLL62qj6RbtmyZZs+endxtxAoPD9eCBQtM4mnTplW9evVM4vPnz1d4eLgjWnNZfn5+GjZsmE6dOmX22UiStHjxYn377bcO7Mw8c9cJ06ZNc2gfe/fu1fHjxw1z/fv3d2gvsD+OgY7z0UcfKSQkxDBXq1Ytbd++XQULFrTpmG5ubpowYYJ69+5tmA8ODjY8/hhx1c/KtGnTtG3bNsOcr6+v1q1bZ/Zek6Xatm2rbdu2KV26dIb5Tz75xOyzyJ7n5eWliRMnmv1xBo66NnFVrnC/1RZc5drR3D4sW7ZsGjdunMW9tWjRQqNGjbJ4eSMLFy7U6dOnDXPffPONmjZtalX9HDlyaMmSJbH30V9//XXt3btXmzZtUrZs2Vy2N8kx250l25wzbyfO3JvkuucgKYUjj/W81/+6du2aevToYTbfoUMHbd26VXnz5rXJeGnSpNHEiRP1888/y83NzXCeH374QWvWrLHJeAAAAAASJ+l//QgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASeDr66vNmzdrwIABcnNzs6qWu7u7hg4dqrVr18rLy8vsfCEhIWrRooUGDhyoS5cuGc4TGRmppUuXqmLFilq9erUkafjw4Xr55ZcN51+7dq1++eUX+fr6au3atRo9erR8fX3j7bd169Y6dOiQSpYsmchXmLCYmBizOWvXb2JrRUdHJ7h8/fr1zb5Hd+/e1V9//RXv8q7yOgEAAJzZjh077FJ33759hudr+fPnl7e3t9X1//zzT6trPGPuXHznzp02G+N5V65c0eXLl03i7u7uKlasmF3GtFZyrKMXOfP6eWbKlCmG8R49eiS5lpeXl9q0aWMS37t3r06cOJHkeua46j7AFrZv327zmkbbtiRlypQpUcsXL17cML5r1y6Le4rP3r177VIXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDUrHDhwho5cqTOnDmjFi1amJ3vww8/1KNHjxJVMywsTKNGjTLMValSRdu3b1e2bNks6leS3n77bf3yyy9xYuXKldOuXbvUuHHjRNfZtm2bJk+ebDb/+eef6/Dhw2ratKnc3d0TrFexYkVt3LhRCxculI+PT2z8+vXrCg0NTXRfRjZs2GAYb9iwoXr37m1RzZw5c2rnzp1xnnF18OBBi2qldiNGjDD8vvN69eppy5YtypMnj1X1M2TIoOnTpxvm1q1bZ1Vt/GvKlCn6/vvv5eHhkeRlX3vtNe3Zs0c5cuQwzP/444/6559/rG0x1bLnMcVWxxNXZ+65Kh9++KFeffVVm4yR2vaTQ4YM0YMHDwxz33//vSZPnmzR8zAaNmyoffv2KV++fIb5Tz/9VOfOnUtyXVhv8ODBTrXuzW0P1s6bmnh6eqpOnTqaOHGirl69qq+++koBAQFm59+2bZu6d+/uwA7Nq1+/vgoVKmQSDwsL08KFCx3ez7Rp0wzjDRs2VMGCBR3cDeyNY6BjXLhwQf379zebr1y5soKCgvTuu+8m+KzqxKhQoYK2bt2qt956y+w8o0aNStK9D1f9rLRv3143btwwzHl6euqHH37Q9u3bVb16dYvHkKQiRYpo0aJF+vXXX5UuXTrDef766y999dVXiarn5eWlwYMHm/1xFo64NnFVrnK/1Vqucu24aNEiXbt2zTDXo0cPjR07Nsm9vfnmm1q6dGmc+9CnTp1Kcp0XRUVF6d133zXMeXl5aeXKlRoyZIhFtYsXL67t27crf/78JrkcOXLo9u3bLtub5Jjt7nmJ3eaceTtx5t6ecdVzkJTCkcd63ut/rVixQuPHjzebr1Gjho4fP64PPvhAfn5+Fo/TunVrHTlyJN5zy7179+q9996zeAwAAAAAlkn4rx4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwArTpk1TzZo1bVqzYcOGmjhxYoLzTZo0Sfny5VOFChXUrVs3vfPOOxowYIBee+01ZcuWTW3bttW5c+ckSVWqVNHIkSMN69y+fVs9e/aUJE2cOFFNmjRJdK/58uXTihUr5Ofnl+hl4hMWFmY25+/vb5MxJClt2rRmcw8ePEhw+cDAQLO5TZs2KSYmJt7lXeV1AgAAOLPTp0/bpe6DBw908eJFk7i7u7sKFixodf29e/daXeOZEiVKGMYPHjxoszFedODAgST1ktySYx0lpQ9nsWXLltjrx+dVrFhRpUuXTlKtwMBAZcqUySQ+Y8YMi/sz4qr7AFs4ceKEzWuau0bMkCFDopYvXLiwYfzQoUOWthSvY8eOKSIiwi61AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwBdWrV1fr1q0t+mnTpo26d++uwYMH65NPPtGvv/6qkydP6vTp0/r000+VPn16s+MuXrxYM2fOTFKvkyZN0rZt2wxzFStW1LFjxzRw4EB5enomumaZMmW0bt06/fDDD3J3dzfJ79+/X5s2bUpSn2+//Xa83ydfunRprVmzRnfu3NH8+fP18ccf680334xdnx988IEmTZqk8+fP68CBA2rYsKFJjf79++vJkydJ6utFO3bs0J07dwxzU6ZM0YgRIxK9Lr29vfX222/r8OHDqlChQmz8/v37Zp95hfgdOnRIkyZNMsxVr15df//9t0aMGKEsWbIkuXbjxo21b98+s98hv2TJkiTXxL9efIbB0KFD9ffff6tNmzZyc3NLcPkyZcpo5cqVWr16tdKlS2c4z4ULF9iubMDWxxR7HE9c2eTJkw3j3t7e2rx5s7788kvly5fPqjFS237y5s2b6t+/v9l8v379dOrUKXXp0iVRn9tSpUpp+fLl2rhxo9lnSuzcuVPffPONpS3DSqGhoercubOioqKSuxVJ/x7jDh8+nOB8hw8ftttzRpJLo0aN1Ldv3yT9DBw4UO+9957GjBmjOXPmaM+ePQoNDdXWrVs1ePDgeK+VJGnt2rVq0qSJwsPDHfQq42du/7N06VI9fPjQwd1Ic+fONXzmjJubm/r27evwfmBfHAMdZ8GCBfrll1/M5gMCAvTtt9/q4sWLGjdunF599VV5eHgkun6mTJnUrVs3rV27VgcOHFDt2rXNzrtlyxb99NNPSerfVT8rN2/eVPPmzRUSEmJ2nlq1amn37t3avXu3Bg4cqEKFCiWqdsaMGdWxY0f9/vvvOnHihNq3b2923gsXLqhly5aKjo5O8mtwZo64NnFlrnK/1Rqucu0YGRmpcePGmc3/97//1Zo1a1SkSJEEa1WsWFHr1q3TlClT4rx3+/fv14oVKxLdU3xWrVqlWbNmGeY8PDw0fvx4/fXXX2rUqFGi6vn7++vjjz/WgQMHDF9jTEyM3nnnHcXExLh0b5L9t7sXJWabc+btxJl7e8ZVz0FSCkce63mv/89//vMfzZkzx2ze399fX375pS5duqSff/5ZdevWVZo0aeKt6ebmpnLlymn48OH6559/tGzZsniPe4cPH9Zrr72myMhIi18HAAAAAMsk/q4FAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACRRnTp11KlTp3jn2b59u4YPH67g4GC5ubkpU6ZMKl++vDp06KBXXnnF7HL9+vXTtGnT9NdffyXYR1BQkIKCgszmfX19NW/ePHl6ehrm+/Tpo1u3bikwMFC9e/c2nOf27dt69OiR8uXLJzc3tzi5IkWK6JtvvtHAgQMT7DUhoaGhZnN+fn7y8PBQVFRUomp5eHiodevWWrJkiUkuffr0Zpe7d+9egrUbN25sNrdu3ZBB9BwAARkUSURBVLoEl3eV1wkAAODMLl68aLfawcHByp8/v0k8Y8aMVtc+fPiw1TWeyZo1q2H89u3bNhvjRXfu3DGMZ8mSxW5jWiM51pERZ10/z5s2bZrGjh1rEu/Ro4fee++9RNfp0qWLSezx48datGiRVf29yFX3AbZw9epVm9d8+PChYdzd3T3BZd3d3eXv72+YM7fPsFZ0dLSCg4OVI0cOu9QHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDZvfPOO3rnnXccOub69evVrVs3i5Zt166d9u/fr7x585rksmbNqp9++kkjR47UunXrtHnzZl2+fFm3bt1SWFiYvL29FRAQoLx586ps2bJq2rSpXn75ZbNjXb9+XW3btlV0dHSSenz69KmaNGmiTZs2qXLlymbny5gxY4LPrjLy+eefa+XKlUle7kXh4eEaM2aMxo0bZ5Jzd3fX6NGj1b9/f82dO1fbt2/XP//8o/v37+vJkydKnz69smXLpsKFC6tx48Z67bXX9NJLL8WpERMTo+7duzv8O91TkqFDh6pq1aqGnyN/f3+NHj1aI0aM0O7du/Xnn3/qxIkTunDhgkJCQhQWFiY3Nzf5+fkpQ4YMKlSokCpUqKCmTZuqSJEiZsdctWqVdu3aZc+XlaL17NlT+/btk4+PT2ysaNGiWrJkie7cuaP169frwIEDunHjhu7du6eAgABlz55dRYoUUZMmTVSsWLF46z9+/FgtW7ZUSEiIvV9KqmDtMaVUqVJ2PZ64sl27dmnnzp2qWbOmSc7Ly0sffPCBPvjgA129elWXLl1SSEiI4fq5efOmevToYXac1LafXLRokUqXLq3hw4cb5vPly6e5c+fqxx9/1IYNG7Rv3z7duHFDd+/elZ+fX+z+JjAwMMH9zblz59SyZctEPwsR9rFnzx6NGTNGI0eOTO5WJEnTp0/XhAkT4p1n2rRpDurGcXr37m32Ga22FhMToy+++EIjR450mu0vW7ZsatGihWEuud7vu3fvauXKlWrTpo1JrmfPnhoxYoSePn2aDJ3BXjgGOk7//v3l5uamvn37mp0na9assfeTIiIi9M8//+jEiRMKDg5WaGioHj16JE9PTwUEBCggIEA5c+ZU6dKllStXrkT1cPToUbVp00YxMTFJ7t9VPyv79+9XYGCg1q1bp4CAALPzVa9eXdWrV5f07zP0zpw5o8uXLys0NFSPHz+Wp6en0qdPr4wZM6pkyZLKkydPosa/du2a6tWrZ5fnmiU3R12buDJXuN9qLVe5dhw3bpxatGhh+HmVpKZNm6pJkybas2ePNmzYoEuXLun27dtyc3NTpkyZVKZMGTVs2FDlypUzWTY8PFy9evVS586dk9RTfPr376+iRYvqlVdeMcxXqlRJGzZs0O3bt7Vx40YdOnRIt27d0t27dyVJ6dOnV4ECBVS1alU1atRIvr6+Zsf64osvtGXLlhTRm+S47S4p25wzbyfO3NszrnoOkhI4+ljPe/2vmJgY9ejRQ5GRkerVq5fZ+TJlyqQBAwZowIABevr0qU6fPq1z587p8uXLiomJka+vr9KlS6f8+fOraNGi8Z4LP+/gwYNq0KCB7t27Z6uXBAAAACAJPJO7AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAp15AhQ8zmwsLC1KVLFy1fvtwkt2PHDk2cOFGdOnXSzJkz5e3tbbZ+165dre5z3LhxKlq0qGFu2rRpWrlypSRp2LBhJvno6Gh1795d8+bNkySVKlVK69evV+7cuePM16tXL3388ccKDg62qtebN2/Gm8+dO7cuXryYYB1fX18tXbpUTZs21XvvvafvvvsuTu6ll14yu+y9e/firV20aFHlz5/fbH7jxo0J9ucKrxMAAMDZPXz40G6179+/bxj39/e3uvbdu3etriH9e77n4eFhEg8PD9eTJ09sMoYRc+eRAQEBdhvTUsm1jow44/p50cyZMzV69Gh5enrGiXfu3FnDhg1TdHR0gjUCAgLUrFkzk/jy5cttvs266j7AFkJCQmxeMzHvrznmPt+hoaGKjIy0uG5C7t+/rxw5ctitPgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+D8//vijhg4davF3D9+6dUsNGjTQH3/8YfL8o2eyZ8+uHj16qEePHhb3efPmTTVu3FiXLl2yaPn79++rfv36mjNnjlq0aGFxHy/69ttvNWLECJvV+/nnn9WtWzdVqFDBMJ8zZ0598MEH+uCDD5Jc+4MPPtDKlStVtWpVa9tMtSIiIhQYGKgNGzaoYsWKhvN4eXmpdu3aql27ttXj3blzRwMGDLC6Tmp25MgRde3aVYsXL5abm1ucXJYsWdSlSxd16dLFotqPHz9W69atdfjwYVu0CjnmmGLt8cSVdevWTYcPH473WRu5cuVSrly5zOYvXLgQ7xipcT/58ccfy83NTR999JHZedKnT6927dqpXbt2Fo3x999/q0mTJjZ7Pg6sM3r0aDVu3FjVqlVL7lY0f/58ffvtt2afnRoeHq758+c7uKuU4++//9bgwYO1devW5G4ljp49e8rLy8skfvr0ae3YsSMZOvrX1KlT1aZNG5N4tmzZ1LJlSy1ZsiQZuoI9cQx0nH79+unOnTv68MMP5e7uHu+83t7eKlOmjMqUKWOTsXfu3KkWLVqYff5XYrjqZ2XXrl2qVq2afv/9dxUpUiTB+bNmzaqsWbOqevXqVo27Z88etWvXTpcvX7aqjjNzxLWJK3OV+63WcJVrx6ioKLVv315BQUHKmjWr4Tzu7u565ZVX9MorryS6bkxMjPr3769jx44luaf4hIeHq2nTplqzZo1q1Khhdr6sWbOqc+fO6ty5s0XjTJs2TR9//HGK6U1yzntSzrydOHNvz3PVc5CUwNHHet7rf8XExKh37946fPiwvv76a/n4+MQ7v5eXl0qWLKmSJUtaNe6MGTP01ltvKSwszKo6AAAAACwX/28OAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBCHh4eaty4sdn8kCFDtHz58nhrLFiwQMOHDzebf+211yzu7/ka/fr1M8ydPXtW77zzjiQpffr0qlWrlmGP8+bNi50+fvy43nvvPZP5fHx81KRJE6v7PXnyZLz5KlWqJFgjQ4YM2rx5s5o2bSpJ+uabb9StW7fYfLly5eTm5mZ2+bNnz8ZbP773/fDhw7px40aCPbrC6wQAAHB2YWFhdqv94MEDw7i/v7/daieVn5+fYfzhw4c2qW/OvXv3DOPp0qWz67iWSK51ZMQZ18+Lbty4obVr15rEc+TIEe910PNat26tNGnSmMRnzJhhdX8vctV9gC08ffo0uVuIw8fHxzD+6NEju46bHNsyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACpzZEjR1S/fn299dZbioyMtKrW6dOnVb16de3bt89G3cV18OBBVa5cWUePHrWqzsOHD9WyZUv169dPd+/etarW3bt31blzZ73//vtW1XlRRESEAgMDdf78eZvVfPr0qfr166dvvvnGZjVTszt37qhOnTpasWKFXce5cuWKatasqatXr9p1nNRgyZIl6tChg548eWKzmjdv3lSjRo20fv16m9XEv+x5TLHV8cRVnT9/Xq1bt7bZM1bMSY37yeHDh6tPnz52eZ7DmjVrVKNGDV2+fNnmtWGZqKgode7cWaGhocndioKDg/X777+bzf/+++9mn0sE886cOaMBAwaobNmy2rp1a3K3Y6Jv376G8WnTpjm4k7g2bdqkS5cuGeb69+/v4G7gKBwDHWf48OF69dVXHfbc4rCwMH344YeqW7eugoODra7nqp+VEydOqHLlypo0aZJiYmJsXv95UVFR+uabb1SrVq0U/7l31LWJK3OV+63WcJVrx2vXrqlWrVo22/9GR0dr8ODBmjVrlk3qvejBgwdq0KCBXZ4zGR0drbFjx+rNN9+0aJ/ozL1JznlPypm3E2fu7Xmueg7i6pLjWM97/X8mTJigatWq2f04f+fOHXXo0EG9e/e267OIAQAAACTMPbkbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJAyFS5cWL6+voa5x48fa86cOYmqM2XKFMXExBjmMmbMqFy5clncY5YsWTR9+nTDXFRUlDp37qxHjx5JkkqXLi0PDw+T+dasWZOomCRVqFDB4l6fuX//vq5du2Y236BBg3iXz5kzp3bu3KlXXnklNubm5qbp06frtddek6TY/5ob/+TJk/GOERgYaDa3fv36eJd9fhxnf50AAADOztx5tC1ERUUZxt3c3Kyu/fDhQ6trSJK7u7th3FzvtmLPdWNrybWOjDjj+jEyZcoUw3iPHj0StXyXLl1MYpcuXdIff/xhTVuGXHUfkJrY8z2SpOjoaLvWBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgtXr8+LGWL1+uJk2aqFy5cjb9rukrV66oZs2aGj58uMLCwmxSMywsTB988IGqVq2qK1eu2KSm9O93d+fPn1/Dhw/X2bNnk7TsrVu3NHr0aBUrVkwLFiywWU/Pu3nzpqpVq2b2mVJJceTIEVWtWtXs95XDMiEhIWrVqpXatm2rS5cu2bR2TEyM5s2bpypVquiff/6xae3U7Ndff9XLL7+soKAgq2stWbJEpUqV0s6dO61vDIZsfUyx1/HEFW3evFlVq1bVjh077DpOatxPTp8+XWXKlEn0cw8Tcv36dXXt2lWvv/667t+/b5OasJ2zZ89qyJAhyd2GJGnatGkW5RBXcHCw5syZo9dee01FixbV5MmTk+V5SAlp2LChChYsaBKPjIzU7Nmzk6Gj/xMTE6NZs2YZ5urWravChQs7tiE4DMdAx9m1a5dKly6twYMH68KFC3YZIyoqSsuWLVOJEiX01VdfKTIy0ma1XfWz8vDhQw0cOFDVqlXT6tWrbf4Mr5iYGC1evFglSpTQsGHDbLrOnZmjrk1cmSvdb7WUq1w7/vPPP6patarWrVtnVZ3bt2+rSZMm+vnnn62qk5AnT56od+/eat68uc6dO2eTmmfPnlXDhg01fPjwFNubZJ/tztptzpm3E2fu7Xmueg7i6pLjWM97/X8OHz6scuXKqVOnTjpz5oxNa9+/f1/Dhw9X/vz5tXjxYpvWBgAAAGAZ9+RuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDKlDlzZrO5q1evKiIiIlF1Hj58qODgYIvGSciMGTOUPXt2w9yYMWO0d+/e2OmsWbMaznfp0iWTWGhoqO7fv28Sz5Ytm2WNvmDLli1mc506dZKfn59hLn369Nq9e7dKlSplkvP09NSSJUtUp04d9ejRw2z9PXv2xNubj4+P6tSpYza/fv36eJd/njO/TgAAANhPTExMcrcAmLVu3TpduXLFJN6iRQtlyJAh3mVz5MihevXqmcRnz57N5z6FM/f+uru723VcLy8vu9YHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAli4iIUEhIiC5cuKC9e/dq/vz5Gj58uOrXr68sWbKodevW2rBhg13Gfvr0qcaOHasCBQpozJgxht+PnRiXL1/WyJEjlSdPHn399deKioqycaf/Pq9p7NixKly4sCpWrKjBgwdrxowZ2rx5s/bv368TJ07o0KFD2r59u+bOnav//ve/ql69ul566SWNGjVKd+/eNanp4+NjOFZkZGSS+7t9+7Zef/11tW3bVjt37kzy8gcPHlSHDh1Uvnx5BQUFJXl5JM7SpUtVoEABtW3bVps3b1Z4eLjFte7du6cZM2aoWrVq6tq1q27cuGHDTiFJhw8fVuXKldW9e3edOHEiScs+efJES5YsUcWKFdWuXTvDfQBsyxbHFEccT1zRqVOn9Oqrr6patWr65ZdfdOTIEUVHR9tlrNS2nzx//rwCAwNVpUoV/frrrwoLC0tyjaCgIPXr10/58+fXvHnz7NAlbGXGjBlavnx5crehTZs26fLlyybxy5cva/PmzcnQkXOKiopSSEiIbt26pRMnTmj9+vX65Zdf1K9fP1WoUEHZsmVT9+7dtXbtWqd+Jk///v0N42vWrNHNmzcd3I2p6dOnG64/Nzc39evXLxk6gqNwDHScJ0+e6KefflLhwoXVunVrzZkzR7dv37a67vHjx/Xee+8pV65catOmjeGzr23BlT8r+/fvV7NmzVS6dGl98cUXOnfunFX1Tp8+rdGjR6tEiRLq0KGDTp8+baNOXYcjr01clSvdb7WGK1w7BgcHq2nTpqpXr57+97//JWnZ+/fv65tvvlHhwoW1adMmm/STGKtWrVKxYsXUuXNn7dq1y6Lz3MOHD6tfv34qVqyY/vjjj1TRm623O1ttc868nThzb8+48jmIK0uOYz3v9f+JiYnRwoULVbx4cQUGBmrWrFm6f/++RbWePn2qtWvXqnv37sqbN6/Gjh2rR48e2bZhAAAAABZzi0nk3RU3Nzd79wLARZUtW1Zly5aV9O9NhXPnzmnPnj1O/QcUAAAAAAAAAAAAAAAAKcGQZZKPX3J3gZTsyjFpwXvJ3QUAwBw3NzdVrlxZRYsWjf177yNHjujIkSPJ3FnqxN/UAgAAAAAAAAAAAAAAAAAAOJabm5uqVKmiIkWK8Pe0ABLNmr/x5rvaAZjD/1cCAAAAAAAAAAAAAAAAIw0HSxVe/7/pQ6ulTT8mXz+WKFq0qP755x+z+aT8bV3NmjW1Y8cOw9ylS5eUL1++RNd6+PChAgICDHPly5fX4cOHE13rmT59+mjq1KmGuf3796t69eqKioqKjbVr106LFy82mbdy5co6cOCASfzGjRvKnj17nNiiRYvUsWPHJPf6oo4dO2rBggVm82PGjNHHH39smBs7dqz++9//ml02MjJSnp6eZvNDhw7V+PHjzeYbNGigTZs2GeZCQ0OVKVMmPX361Ozyz3Pm1wkgefBd7c6Fv6kFnIe57c7b2zvR515J9fvvv6t58+Ym8ZYtW+r3339PVA1zfdvq/+nJnDmz7ty5YxK/c+eOsmbNapMxjAwfPlyff/65STy+89cXtW7dWsuWLTOJL126VG3btrW6x2eSax0ZvffOuH7MGT16tEaMGGES79+/v3755Rezy73zzjsaN25cnFhMTIwKFSqk8+fPW9yPK+4DbLX923s/8ryZM2eqR48eJvHu3btrzpw58S7r5+en0NBQk/iTJ0/k6+trqxZNnDlzRoUKFTKJV6tWTfv27bPbuAAAAAAAAAAAAAAAwH74rnYAluC72gHYA/9fCQAAAAAAAAAAAAAAAJ734ne0A46wcaIUtCa5uwAAx+K72p0Lf1MLIDlUrlxZNWvWVKVKlZQvXz5ly5ZNfn5+8vT0VEREhB4+fKj79+/rn3/+0fHjx7VlyxaXPE64u7vHeXbU80qWLKkTJ05YVb9YsWKqWbOmqlevrsKFCytDhgzKmDGjvLy8FBISovv37+vEiRM6dOiQ1qxZozNnzlg1HiyTNm1a1a5dW2XLllXx4sVVqFAhBQT8P/buO7qqMu0b8J0QOoSiFAW7gA0UBQSxjXS72BUsjGId22thrGPDOo46RUVF7IKAiKKIDioOiggiXbGACgJK7yUk3x/fGmeYnGDKOTkJXNdarDHP/ez7+Z2dffbZew8JNaNGjRpRvXr1yMvLi1WrVsXKlStjxYoV8e233/56bTR27NjIyclJ90sot4rzO+D322+/OProo+OAAw6Ipk2bRnZ2dtSoUSPWrVsXy5cvjwULFsSUKVNi/PjxMXLkyFi9enWq4lNIv/WZ8sMPP5T7z5N0qV69euywww6bfb4ksnbt2nj//feLvc62dp6sUqVKdOrUKdq0aRMtWrSIRo0aRa1ataJGjRqxfv36WL58eSxZsiSmT58ekydPjlGjRsX333+f7tgAUGI+A0tXRkZGHHDAAbHvvvvGPvvsE3vttVdsv/32m11n5ebmxooVK2L58uW/7v/JkyfH559/Hp9//nksXrw4LdnL+7Gy8847R7t27aJly5ax2267xS677BI1a9aMatWqRZUqVSInJyeWL18ey5Yti6VLl8b06dNj0qRJMWnSpJg1a1ZKs73//vtx5JFH/vp1efmdPKV1b1KebQvPW8vDveNOO+0UXbp0iSOPPDJ23HHHqFevXtStWzdycnJi2bJl8fPPP8ekSZNi7Nix8fbbb8eGDRtSnum3NGzYMI488sho27Zt7LnnnrHTTjtFjRo1omrVqpGbm/vr+erLL7+Mzz//PEaPHl3i59pbQ7aIsvm+K8vvk7Kc7d/K+zVIeVban/W+15urWLFi7L///nHAAQfEAQccEE2aNIns7OzYaaedIjMz89f35fLly2Pu3LnxxRdfxBdffBGff/55rFixIt3xAaDc87vageIozN/xziqFHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwDbol19+KbDWuHHjqF+/fvz888+/2WfPPfeMmjVrFmudguyxxx7x8MMPJ6ytWbMmzj777Ni0aVOR+5aWoUOHxpIlS6Ju3boJ63/84x/j/fffj3/+85/5ajfeeGPUr18/fv/73yfcNisrq8B116xZEwMGDNhitm7duhVYGz16dGzcuHGL2/+3svw6AQDKg1q1asWiRYtS0rt27doJx1etWpWS9YqjoCwFZU+Wgq5fV6xYkdJ1iyNd+yiRsrh/CvLUU0/FTTfdFJmZmZuNn3feefHEE08UuF2PHj3yjY0ZMyZmz56d9IwRzgFlyerVqyMvLy8yMjI2G69SpUpUqVIl1q1bl5J10/FeBgAAAAAAAAAAAAAAAAAAiq51m9bR8oCW6Y7BNubT8Z/G5C8mpzsGAAAAAAAARTBhwoSYMGFCumOkXHZ2doG1JUuWlLj/V199FV999VU8/fTTJe5F6qxZsybefvvtePvtt9MdhUKYNm1aTJs2Ld0xKIJt5TMlHVavXh3ffPNNytfZ1s6T69atizfeeCPeeOONdEcBgFLlM7B05eXlxaRJk2LSpEnpjlJk5f1Y+eGHH+KHH36IgQMHpjtKPhUqVPj1v8vyv3n+v0rr3qQ82xbujcvDveOPP/4YTz31VDz11FPpjlJoCxYsiFdeeSVeeeWVdEfJpyxniyib77uy/D4py9n+rbxfg5Rnpf1Z73u9uY0bN5bJcxoAAFAyWekOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbJ3mz59fYC0zMzPuvvvuuPDCC3+zzz333FNgLTc3N37++eci5crMzIwXXnghqlevnrB+9dVXx9dff51vfMOGDQnnV6lSpdDj69evL0LSgq1fvz6efPLJuOGGGxLWMzMzY8SIEXHuuefGwIED89V79+4d22+/fZxwwglFWvell16KZcuWbXFO165dC6yNHDmySOuV5dcJAFAe1K5dOxYtWpSy3omsWrUqJesVx/r16yMnJyeysrI2G8/Kyorq1avH6tWrU7JunTp1Eo6vXLkyJeuVRLr2USJlcf8U5Icffoh33303unTpstl427Zto2nTpjFr1qx82zRt2jQOOuigfOP9+/dPWc5t/RxQ1ixatCjq1auXb7xhw4YxZ86cpK9XvXr1As9HAAAAAAAAAAAAAAAAAABA2bL99ttHk6ZN0h2DbUyi37kHAAAAAAAAZUGzZs0Sjm/cuDEWLlxYymkAAAAA2Jb997/ZtmLFivQFAQAAAAAgpTLTHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANg6rVixIiZNmlRg/YILLojnn38+GjZsmLC+0047xdChQ+OUU04psMfHH38cOTk5Rcp18803R9u2bRPWRowYEf369UtYW7hwYcLxXXbZJd9YrVq1olatWoXuURx9+/aNX375pcB65cqV45VXXol33303OnXqFJUqVfq1lpubG6effnp89NFHhV5v1apVcffdd29xTuPGjWOfffYpsP7OO+8Uer1/K4uvEwCgvGjQoEGp9160aFHK1iyOefPmJRwv6D4kGQrqvWDBgpStWRLp2EeJlNX9U5CC7h3PO++8hOM9evTIN7Zy5coYPHhwMmNtxjmgbPnqq68Sjrdp0yYl67Vq1SoyMzNT0hsAAAAAAAAAAAAAAAAAAAAAAAAAAAAgVQr63c1ffvllKScBAAAAYFtWo0aNaNas2a9fl7d/bw8AAAAAgMLLTHcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABg6zV48OAt1nv06BFz586Nf/zjH3HXXXfF3XffHY8//nh8/PHHMWfOnDjppJO2uP2QIUOKlKd169Zxyy23JKz98ssv0atXrwK3nTZtWuTk5OQbP/HEE/ONHX/88Ql7TJw4sXBBC2HFihVx5ZVX/ua8jh07xqhRo2Lp0qUxefLkeO+99+Ldd9+NiRMnxv7771/o9a699tqYM2fOFud06dKlwNrXX38d3333XaHX+7ey+DoBAMqLVq1apaRvo0aNokGDBvnGN27cGLNnz07JmsU1Y8aMhOMHH3xwytZs06ZNwvHp06enbM2SSMc+SqSs7p+CDB8+PBYuXJhvvGfPnpGRkZFv/Kyzzso3NmjQoFizZk1K8kU4B5Q1M2fOTDh+6KGHpmS90n4PAwAAAAAAAAAAAAAAAAAAAAAAAAAAACRDx44dE44n899/AgAAAIDf8uc//zkqVar069fjx49PYxoAAAAAAFIpM90BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACArddf//rX+Omnn7Y4p0KFCnHJJZfETTfdFDfeeGNcdNFF0a5du8jMzNzidj/88EP069ev0FmqVasWL774YmRlZSWs//73v4+ff/65wO1XrlwZ//znP/ONn3LKKXH55ZdHhQoVIiKiffv28eCDD+abt2bNmhg5cmSh8xbGyy+/HH/7298KNbdatWrRokWL6NChQ3Ts2DH23XffyM7OLtS2c+fOLdS+7tatW4G1d955p1BrJVLWXicAQHnRrl27lPRt27ZtwvFvv/02cnNzU7JmcU2bNi3h+KGHHpqS9Zo1axbbbbddvvH169fHt99+m5I1Syod++h/leX9U5CcnJx49tln8403btw4jjrqqM3GDj744Nhjjz3yze3fv3/K8kU4B5Q177//fsLx7t27//pMIZnOOuuspPcEAAAAAAAAAAAAAAAAAAAAAAAAAAAA+Lfq1asnvWejRo3imGOOSVgryb+BBAAAAACFlZWVFY8//nj07t17s/EBAwakJxAAAAAAACmXme4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADA1mvlypXRu3fv2LRpU1L75uTkRO/evWPNmjWF3uahhx6KJk2aJKw9+eST8cYbb/xmj3vuuSfy8vI2G8vIyIi//vWvsWrVqli6dGn861//ivr16+fb9u9//3usWLGi0HkL66qrropnn3026X3/W+PGjePRRx/d4pzMzMzo0KFDgfW33367RBnKyusEAChPjjrqqKhUqVLS+x599NEJx//1r38lfa2SevfddxOOH3vssVGhQoWkr3fiiScmHP/www+Tcl+UisxlYR+V5f2zJU8++WTC8fPOO2+zr3v06JFvztdffx0ff/xxKmL9yjmgbHn33XfzPVOIiGjUqFF07949qWu1bds29t9//6T2BAAAAAAAAAAAAAAAAAAAAAAAAAAAAIj4//9W0a233hpff/11wn+rqST69OmT8HeOr1u3LkaOHJnUtQAAAADgfzVo0CBGjx4dF1100WbjL7/8cnzwwQfpCQUAAAAAQMplpjsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwdRsxYkSceeaZkZOTk5R+GzdujNNOOy3eeeedQm9zzDHHxEUXXZSw9s0338RVV11VqD4ffvhhPPTQQwlrVapUidq1ayesffHFF3HzzTcXao2i2rRpU5x33nlx++23x6ZNm1KyRkTE5ZdfHrfcckuB9bZt2xb4+jds2BAffPBBidYvK68TAKA8qVevXpxxxhlJ7bn99tvHWWedlbA2cuTIpK6VDB9++GGsXr063/hOO+0Up5xySlLXqlixYlxxxRUJa8OHDy9Sr0SZIyJq1qxZ5Fy/pSzso7K8f7bkm2++SXiv071796hRo0ZERFSoUCFOO+20fHP69++f6njOAWXMokWL4r333ktYu+2226JSpUpJW+vOO+9MWi8AAAAAAAAAAAAAAAAAAAAAAAAAAACAf9tpp53iww8/jNtvvz122GGHGDp0aFSpUiUpvTt06BCXXXZZwtrAgQNj2bJlSVkHAAAAABJp1KhRTJo0KQ477LDNxkeOHBm9evVKUyoAAAAAAEpDVroDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAW79XX301vvrqq3jyySejTZs2xe4zbty4uOiii2LKlCmF3qZevXrRv3//hLVNmzZFjx49Ys2aNYXu16dPn2jYsGGcffbZhZo/derUOPHEE2PDhg2FXqM4/vSnP8WIESPiH//4R7Rq1Sola9xxxx2xaNGieOyxx/LVunXrVuB2H330UZH28Zak+3UCAJQ31157bbz44ouxadOmpPS75pprokqVKvnGV69eHaNGjUrKGsm0YcOGGDhwYPTq1Stf7aabboqhQ4fGxo0bk7JW7969Y8cdd8w3vn79+nj11VeL1Gvp0qUJx3fZZZdiZduSdO+jsr5/fsuTTz4ZRx555GZj1apVi1NPPTWeeeaZ6NSpU9SvX3+zem5ubjz33HOlkm9bPweUNX/961+jU6dO+cb33XffuPvuu+O6664r8Rq9e/eOjh07lrgPAAAAAAAAAAAAAAAAAAAAAGwtOnbsGIcdfli6Y7ANevONN+Ozzz5LdwwAAAAASJqTTjop+vfvH7Vr1/51rH379jFq1Kjo3r17LFq0qNi9jzrqqBgyZEhkZGTkq+Xk5MTdd99d7N4AAAAAUBjz5s2LTz75JLp37/7r2FNPPRWXXnpp0v49PwAAAAAAyqbMdAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC2DVOmTIm2bdtGt27d4tVXX41169YVaru1a9fGwIEDo1u3btGuXbuYMmVKkdZ9+umno379+glrd911V3z66adF6peTkxM9evSISy+9NJYsWbLFef369YuDDz44vv/++yKtUVyfffZZtG7dOrp27RpDhw6NNWvWFHrbnJycGDlyZNx5552xadOmAuf97W9/i9NOOy3feJcuXQrc5u233y50jsJI5+sEAChvmjdvHg888EBSeh1xxBFx/fXXJ6w9//zzsXLlyqSsk2wPPvhg5OXl5Rtv3rx5PPzww0lZo2XLlvHggw8mrD333HPx888/F6nfvHnzEo43adIkGjRoUOR8vyWd+6g87J8tGTJkSMJ7w/POOy8iInr06JGvNmrUqPjpp59SHS0inAPKmjfffLPA5xrXXHNNXHDBBSXq36lTp6S9ZwEAAAAAAAAAAAAAAAAAAABga1GxUsWoVq2aP/6U+p+srKx0H/4AAAAAkFRNmzaN2rVr5xs/7LDDYvr06XH++edHxYoVi9Szbt260bdv3xg5cmTUqlUr4ZxHHnkkvv766+JEBgAAAIAiOe+88+Lrr7+OdevWxcUXXxwXXnhhbNy4Md2xAAAAAABIMT8VDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/GrWrFmRkZGRsv55eXkxcuTIGDlyZFSoUCH22WefaNmyZey1116RnZ0dERHLly+P5cuXx/z582PSpEkxc+bM2LRpU7HXPP7445MVfzOPPfZYPPvss3HMMcdE+/bto1GjRpGVlRWLFi2KSZMmxeuvvx7z5s1Lydq/5Z133ol33nknqlSpEm3atIn99tsv9tprr6hVq1ZkZ2dHZmZmrFq1KpYuXRrffvttTJ06NT755JNYvXp1RER8//338dRTTyXsnZmZGU888USMHDkyVqxYERER2223XRx00EFbzJMKpf06AQDKq6uvvjpmzpwZTz75ZLF77L333vHKK69EhQoV8tVycnLi4YcfLkHC1Jo5c2YMGjQoTj/99Hy1Sy+9NL755pv4y1/+Uuz+TZo0iddeey2qVKmSr7Zu3bq49957i9xz3rx5MXfu3GjcuHG+2qWXXhq33XZbsbIWJF37qLzsny1Zv359vPDCC3HFFVdsNn7YYYfFfvvtFyeeeGK+bfr3719K6f6/bf0cUJbk5eXFFVdcER988EG+WmZmZjz55JPRoEGDuOeeeyI3N7dIvc8444wYMGBAVK5cOUlpAQAAAAAAAAAAAAAAAAAAAAAAAAAAAP7jwQcfjJNOOikOPvjgfLX69etH//794957740333wzxowZE7NmzYq5c+fG6tWrY/369ZGVlRV169aN7bbbLlq2bBlHHXVUHHPMMVGzZs0C15w0aVLceOONqXxZAAAAAPCrlStXxoknnhgVKlSIqVOnpjsOAAAAAAClJCvdAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgG3Tpk2bYurUqTF16tR0Rym2NWvWxKuvvhqvvvpquqMktG7duhgzZkyMGTOmSNs9/fTTUb9+/ejbt2++2pIlS+KYY46JFStW/DrWqVOnyMzMTNjrp59+imnTphUteBGV1usEACjP+vXrF3vvvXdcd911sWnTpiJte8wxx8RLL70U2dnZCet/+9vf4quvvkpGzJS58soro2vXrlGrVq18tYceeiiaNWsWV1xxRWzYsKFIfTt16hSDBg2K2rVrJ6zffvvt8d133xUncnzwwQfRo0ePfON9+vSJf/7zn0W+/v0t6dhH5Wn/bEm/fv3iiiuu2GwsIyMjXnrppahevfpm40uXLo3XX3+91LL927Z+DihLPvzww3j88cfj4osvTli/66674owzzogbbrghRo4cGbm5uVvsd+CBB8a9994bnTp12mx8/vz5UbNmzahRo0bSsgMAAAAAAAAAAAAAAAAAAAAAAAAAAADbrk2bNsWxxx4bH3/8cTRp0iThnPr160evXr2iV69eJV7vu+++i6OPPrrIvx8dAAAAAEpixowZ6Y4AAAAAAEApy0x3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMqee+65J/7yl79sNjZv3rw49NBDY9y4cZuNd+vWrcA+I0eOTEm+ZCnK6wQAKG8+//zzzb6++uqrY8aMGXHKKadERkbGb27fvHnzGD58eLz55puRnZ2dcM6cOXPi1ltvTUreVFq4cGFcfPHFBdYvuuiimDVrVvTo0SOysrJ+s9++++4br732WowaNSpq166dcM6//vWveOCBB4obOR5//PGE45UqVYr33nsv7r333thll12K3f9/lfY+Km/7Z0umT5+e8P6hefPm+cZeeuml2LBhQ2nEcg4ow6644or49NNPC6zvt99+MWLEiFi0aFG8+OKLcfPNN8eFF14Yp5xySpx77rlxww03xGOPPRazZ8+OiRMnRqdOnfL1uPjii2PdunWpfBkAAAAAAAAAAAAAAAAAAAAAAAAAAADANmbRokVx+OGHx8cff5zSdSZMmBCHHHJILFiwIKXrAAAAAAAAAAAAAGSlOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABl0zXXXBP16tWLHj16xFdffRWdOnWKH3/8Md+8Ll26FNhj5MiRqYyYFIV9nQAA5c35558f48ePj8qVK/861rRp03j11Vdj0aJFMXLkyJg4cWIsWLAgli5dGjVr1owGDRpEkyZNomvXrtGsWbMt9l+7dm2ceOKJsXLlylS/lKR45ZVXYr/99oubbropYX2XXXaJ559/Pv72t7/FO++8E+PHj48FCxbE4sWLo3r16r/um27duv3mvvnuu+/ixBNPjE2bNhU779ixY+Nf//pXHHrooflqFStWjBtuuCFuuOGGmDdvXvzwww+xcuXKyM3NzTd34cKFcd555xVqzdLaR+V1/2xJv379om3btr85r3///iVeq7CcA8qujRs3RteuXePdd9+NVq1aFTivTp06cdZZZxW5/1133RXDhw8vSUQAAAAAAAAAAAAAAAAAAAAAAAAAAACAhBYsWBBHHnlk/PGPf4wbbrghqlWrlrTe69evjz//+c9x2223RU5OTtL6AgAAAAAAAAAAABQkK90BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKLvOO++8mD9/ftx3332xePHifPX9998/GjRokHDbTZs2xXvvvZfqiEnxW68TAKA8mjJlSvTs2TMGDhwYGRkZm9W233776NGjR/To0aNYvdeuXRvdu3ePyZMnJyNqqbn55psjIyMjbrzxxgLn1KpVK0477bQ47bTTirXGjBkzomvXrkm5rjznnHNi8uTJUbNmzQLnNGrUKBo1alRgfc6cOUVaszT20ZFHHllu909BBg4cGA8//HBkZ2cXOGfq1Knx+eefJ2W9wnAOKNuWLVsWHTp0iOeeey5OOOGEpPV98MEH45ZbbklaPwAAAAAAAAAAAAAAAAAAAAAAAAAAAID/tXHjxrjjjjviqaeeiksvvTTOP//82HHHHYvdb/ny5TFgwIB46KGH4ocffkhiUgAAAAAAAAAAAIAty0x3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMquTZs2xfXXXx+LFy9OWO/atWuB244fPz6WLl2aqmhJ9VuvEwCgvHr11VfjjDPOiHXr1iWt58KFC6Nz584xcuTIpPUsTTfddFNccMEFsXr16qT3HjFiRLRv3z5+/PHHpPSbPXt2dO/ePZYvX56UfoWV6n1U3vdPImvWrImXX355i3P69+9fSmn+wzmgbFuxYkWceOKJcdFFF5X4fnTx4sVx9tlnx3XXXZekdAAAAAAAAAAAAAAAAAAAAAAAAAAAAABb9tNPP8XNN98cO+20U7Ru3Tquu+66GDRoUEyYMCEWLVoUGzZsyLfN2rVr45tvvol33nkn+vbtG506dYp69erFVVddFT/88EMaXgXw3zIyMhL+AQAAAAAAAAAA2FplpTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5dfs2bPjtttuS1j79NNPSzkNAACJDBo0KL766qsYMGBAHHDAASXq9eqrr8Yll1wSixcvTk64NHn66adj9OjR8Y9//CO6du1a4n7z58+P66+/Pl544YUkpNvce++9F23atImnnnoqDjvssKT3L0h52Ufp2j+J9OvXLy666KKEtY0bN6bk+CgM54Cyr1+/fvHSSy/FFVdcEb169Yo99tij0Nv+/PPP8fjjj8ejjz7q+wIAAAAAAAAAAAAAAAAAAAAAAAAAAACkRW5ubkyYMCEmTJiQr1ahQoWoXLly5OXlxbp16yIvLy8NCQEAAAAAAAAAAAASy0p3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMqvQYMGpTsCAACFMHny5GjVqlWcffbZ0adPn9h7770Lve26devijTfeiHvuuScmTZqUwpSla/bs2dGtW7do1apVXHfddXHsscdGtWrVitTjiy++iMceeywGDBgQGzZsSFHSiFmzZsXhhx8ebdq0iV69ekW7du1iv/32i8zMzJStGVF+9lG69s//+vzzz2PSpEnRsmXLfLURI0bEokWLSjXPf3MOKPtWrVoVffv2jb59+0bLli3jkEMOiQMPPDB23nnnqFWrVtSoUSPWrVsXK1eujO+//z5mzJgRH3zwQYwfPz5yc3MT9qxcuXLC8ZycnFS+FAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBfbdq0KdasWZPuGAAAAAAAAAAAAAAJZaU7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkHqbNm2K5557Lp577rnYb7/94uijj44DDjggmjZtGtnZ2VGjRo1Yt25dLF++PBYsWBBTpkyJ8ePHx8iRI2P16tVJz5ORkZH0nsUxYcKEOP3006NKlSrRqVOnaNOmTbRo0SIaNWoUtWrViho1asT69etj+fLlsWTJkpg+fXpMnjw5Ro0aFd9//32pZh0/fnyMHz8+IiKqV68eO+ywQ9SuXTvq1KkTFStWTLjN2rVrS7xuedlH6do//23JkiUJx/v375/UdYqjLJ0DkvX+L83zyPnnnx/nn39+qaw1adKkmDRpUol6ZGZmRs2aNRPWkn3cAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUR1npDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFuLFT9HLPh6868BAADKomnTpsW0adPSHaNMWbduXbzxxhvxxhtvpDtKoaxevTq++eabUl2zPO2jdOyfRo0axe9+97t84wsXLoy33nqrVLP8FueArV92dnaBtSVLlpRiEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAsikr3QEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBr8emg//8HAAAA2Pacc845kZmZmW/8hRdeiE2bNqUhEduyZs2aJRzfuHFjLFy4sJTTAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUPZnpDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADlWUZGRvTu3TthrV+/fqWcBiLatGmTcPzLL78s5SQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGVTZroDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQHl27LHHxq677ppvfMyYMTFr1qzSD8Q2r2PHjgnHJ06cWMpJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADKpsx0BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDy7Lbbbks4/sgjj5RyEsqb6tWrJ71no0aN4phjjklYe+edd5K+HgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAeZSZ7gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQXvXs2TMOOuigfOPfffddvPbaa2lIRHmQmZkZt956a3z99ddRv379pPbu06dPVKhQId/4unXrYuTIkUldCwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgvMpMdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoj/bcc8945JFHEtbuuOOOyMvLK+VElAc77bRTfPjhh3H77bfHDjvsEEOHDo0qVaokpXeHDh3isssuS1gbOHBgLFu2LCnrAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUd1npDgAAAAAAAAAAAAAAAABEvP/++wnHf/e735VyEtg2/P3vf4999tkn3/gll1wSX375ZRoSAQBA+eX6Ov08VwCgrPHZBAAAAAAAAAAAAAAAAAAAAAAAbCvatGkTr776atSpUydfbebMmfH888+nIRVl3UknnRT9+/eP2rVr/zrWvn37GDVqVHTv3j0WLVpU7N5HHXVUDBkyJDIyMvLVcnJy4u677y52bwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACArU1WugMAAAAAAAAAAAAAAABAuuy4446xxx57xM477xw1atSI6tWrR1ZWVmzYsCFWrFgRK1eujJ9//jmmTZsWixcvTmmWI488MqX9U6FSpUoJxzds2FDKSaDoDjzwwGjbtm2+8ezs7DSkSY7KlSvHfvvtF40bN45atWpFdnZ2VKtWLTZu3BgrVqyIFStWxJIlS2LGjBkxf/78dMcFAGArsjVeX5c35fG5AqSSe2RIv/L42eSZNwAAAAAAAAAAAAAAAAAAAAAAUJCMjIyoWLFiZGRkRPXq1aN+/fpx4IEHxqmnnhrHHXdcVKhQIeF2l1xySeTm5pZyWsqDpk2bRu3atfONH3bYYTF9+vTo06dPvPDCC7Fx48ZC96xbt25ce+21ce2110bFihUTznnkkUfi66+/Lm5sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICtTla6AwAAAAAAAAAAAAAAAEBpqVu3bpx22mnRuXPnOOyww2L77bcv9LYLFy6M8ePHx7Bhw2L48OGxaNGiFCYt+5o2bRpfffVVwlqzZs1i1qxZpZwItj2ZmZlxxBFHxGmnnRaHHnpo7LXXXpGVVbgfG/zll19i0qRJMXz48BgyZEgsWLAgxWnLviuuuCJq166dtvX/9a9/xejRo9O2PiRLst5LmzZtivXr18fKlSvj559/jnnz5sVXX30Vy5cvL3Hvhg0bRu/evUvcJ1Xmzp0b/fv332wsOzs7rrrqqoTz8/Ly4qGHHorVq1eXQrr/OOKII+KII45IWPv444/jvffeK9U8W7PatWvH3nvvHbvvvntst912Ub169ahYsWJs3LgxVq9eHYsXL47vvvsuZs6cGcuWLUt33F9VrVo19t5779hjjz2iQYMGUb169ahcuXJs3LgxVq1aFStXrow5c+bEjBkz4ueff0533HK7nwH4/8rLPXKyrpfz8vJi1apVsXz58li2bFksW7YsZs6cGfPnzy95yASOOuqoOPTQQ/ONz5o1K1555ZWUrFmQs846K/bcc8984x988EGMGTOmVLOwdfHMGwAAAAAAAAAAAAAAAAAAAAAA2JJTTz01Bg4cWKRt/va3v8WHH36YokSUdw8++GCcdNJJcfDBB+er1a9fP/r37x/33ntvvPnmmzFmzJiYNWtWzJ07N1avXh3r16+PrKysqFu3bmy33XbRsmXLOOqoo+KYY46JmjVrFrjmpEmT4sYbb0zlywIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKHey0h0AAAAAAAAAAAAAAAAAUq158+Zx6623xgknnBAVK1YsVo8GDRrEcccdF8cdd1zk5ubGsGHD4q677opJkyYlOS3AlmVnZ8e1114bvXv3jgYNGhSrR7169aJz587RuXPnePTRR+P999+PO+64I8aMGZPktOXH1VdfHbvuumva1r/33ntj9OjRaVsfkiXV76Uff/wxxo4dGyNHjow33ngjlixZUuQeO+64Y9x+++0pSJcc48aNi/79+282tmLFimjYsGFccsklCbfZZZdd4oILLiiNeBHx//fh0KFDo27duvlqv/zySzz++OOlluXfzjjjjDjiiCNKfd2nnnoqJk6cmPS+zZs3j3POOSe6dOkS++23X2RkZPzmNnl5eTFt2rQYOXJkPPfcczFt2rSk5/otjRs3jh49esTxxx8frVq1KvT91/z58+PNN9+MoUOHxsiRI1Oc8j/K634G4D/K2z1yqq+X58+fHxMmTIixY8fGiy++GHPnzk1K306dOkWfPn3yjb/55pvxyiuvJGWNwurZs2d07do13/htt922TT/XAAAAAAAAAAAAAAAAAAAAAAAAoGx5//3345prrkl3DMqwTZs2xbHHHhsff/xxNGnSJOGc+vXrR69evaJXr14lXu+7776Lo48+OjZs2FDiXgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAW5OsdAcAAAAAAAAAAAAAAACAVKldu3Y88sgj0bNnz8jIyEha38zMzOjevXt07949hg0bFhdffHEsXLgwaf0BEsnKyoprr702rr/++qhTp07S+mZmZkaHDh2iQ4cO8e6778ZVV10VM2bMSFp/gGTaaaed4owzzogzzjgjNm7cGEOGDIkHHnggPv/883RHS7lrrrkmfve738Vee+2Vr/b73/8+RowYEa+99lqpZHn22Wejbt26CWvnn39+/Pzzz6WS47917do1zj333FJf9/3334+JEycmrd8RRxwRd9xxRxx++OFF3jYjIyOaN28ezZs3j+uuuy4++OCDuPXWW+Ojjz5KWr6CNGnSJG6//fY4/fTTIzMzs8jb77DDDnHhhRfGhRdeGDNnzow777wzXn755RQk/f/K634G4D/cIye2ww47xHHHHRfHHXdc9O3bN9555514/PHHY/jw4emOBgAAAAAAAAAAAAAAAAAAAAAAANuMt956K0499dTYuHFjuqNQxi1atCgOP/zwGDJkSBxyyCEpW2fChAlx7LHH+nc1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASyEx3AAAAAAAAAAAAAAAAAEiFdu3axYwZM+Kcc86JjIyMlK1z4oknxvTp0+PEE09M2RoAu+++e3z88cdxzz33RJ06dVK2TqdOnWLChAlx/vnnp2wNgGSpWLFinHHGGTFhwoR48cUXY7vttkt3pJRat25dnHnmmbFhw4aE9aeeeip22GGHlOe48soro2PHjglrjz32WIwYMSLlGRKpUaNGWtZNltq1a8fzzz8fH3zwQRx++OFJ6XnkkUfGmDFjon///pGdnZ2Unv8rMzMz/vjHP8a0adPizDPPjMzMkv8Kg7333jteeumlGD58eGy//fZJSPkf5XU/w9aoffv28fbbb+f7c+ONN6Y7GuWAe+TCyczMjG7dusXrr78eI0eOjJ133jndkUgj511ga+TcBgAAAAAAAAAAAAAAAAAAAACUNQsXLoxLLrkkjjnmmFizZk2641BOLFiwII488si47bbbkn7crF+/Pvr27Rvt2rWLhQsXJrU3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDWIivdAQAAAAAAAAAAAAAAACDZjj322Bg0aFBUrVq1VNbbbrvtYujQoXHZZZfFY489ViprAtuOo48+OgYOHBg1atQolfWqVq0a/fv3jzZt2sQll1xSKmsClERGRkacddZZ0aFDhzj55JNj7Nix6Y6UMl988UXcdNNN8cADD+Sr1a1bN5577rno1KlTytbfb7/94r777ktY+/LLL+Oaa65J2dq/pbQ+J1OhadOm8dZbb8Uee+yRkv7nn39+HHLIIdGtW7eYPXt20vpWr149Xn311ejWrVvSev634447Lj799NM44ogjYu7cuSXuV173M2ytGjRoEF27ds03vmrVqjSkoTxxj1w8Xbp0ienTp8fll18ezz77bLrjkAbOu8DWyLkNAAAAAAAAAAAAAAAAAAAAAEiX3NzcWLt2bSxZsiTmzJkTEydOjPfeey/eeeedyMnJSXc8yqGNGzfGHXfcEU899VRceumlcf7558eOO+5Y7H7Lly+PAQMGxEMPPRQ//PBDEpMCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGx9stIdAAAAAAAAAAAAAAAAAJLp4IMPjldffTWqVKlS4Jy8vLwYO3ZsvPPOO/HFF1/EzJkzY9myZbFixYrYuHFjVKxYMWrUqBHbb799NGvWLFq0aBHdunWLdu3aRYUKFRL2zMjIiH/84x+//i9AMpxwwgkxaNCgqFSp0hbnLVu2LN57770YM2ZMfPnll/HDDz/EypUrY/369ZGVlRU1a9aMOnXqRNOmTaNFixbRoUOHOOigg7bY8+KLL47169fHVVddlcRXVP7MnTs3li1blvJ1FixYkPI1IJ2K8l7KyMiIypUrR82aNSM7OzuqVq1aqO0aNGgQ//znP+PEE0+MkSNHFjhv3bp1MW3atEL1LEitWrVip512yjeek5MTX375ZYl6f/fdd1us//nPf46jjz46fve73+WrdezYMa666qp4+OGHS5QhkUqVKsVLL70UlStXzlfbsGFDnHnmmbFu3bqkr1tYNWrUSNvaJbHvvvvGmDFjom7duoWan5OTEytWrIgNGzZEpUqVIjs7O7KyfvvXBjRr1izGjRsX7du3j2+++aaksaNq1arx3nvvRdu2bX9z7vr162P27NmxdOnSX3PXrFkzdt5558jOzt7itrvvvnt8+OGH0aZNm1i8eHGx85bX/QzA5rbme+Si3ntmZmZG9erVIzs7O2rVqhWZmZm/uU2NGjViwIABUb9+/XjggQdKkBYAAAAAAAAAAAAAAAAAAAAAACirMjIy0h0BtlqDBg2KQYMGpTvGFjkHlH8//fRT3HzzzXHrrbfGgQceGEceeWS0bt06dt9999h1110jOzs73+/kW7t2bcybNy++/fbbmDhxYrz//vvx4YcfxsaNG9P0KgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAypesdAcAAAAAAAAAAAAAAACAZKlZs2YMHTo0qlSpkrC+adOmePzxx+O+++6LH3/8scA+GzdujKVLl8bSpUvj66+/jjfffDP69u0bDRs2jGuuuSYuvfTSqF69esJtH3nkkfj8889j3LhxSXlNZdW6detiwoQJBdaAkuvatWsMHjw4srIK/lHAKVOmRN++fWPYsGGxfv36AuctXLgwIiI+++yzePHFFyMiYrfddosrr7wyLr744qhcuXLC7a688sqYN29ePPDAAyV4JeXb//3f/8WgQYPSHQPKvZK8lxo0aBD77rtvtG7dOrp37x5t2rQpcG7lypVjyJAhccghh8TkyZMTzpkxY0Y0b968WFn+rXv37jFkyJB844sWLSpx79+Sl5cXPXv2jKlTp0adOnXy1e+999745z//GVOnTk3quvfcc0+Br+2mm26KL774IqnrFVWi6/MFCxbE3LlzU7ru0qVLi71t48aNY9SoUVG3bt0C52zcuDFee+21GDZsWIwbNy7mzJkTeXl5v9YzMjJi1113jbZt28ZJJ50UJ554YlSsWDFhr/r168e7774bbdq0iV9++aXYuSMiBg0aFG3bti2wPnfu3Hj66afj9ddfjy+++GKzzP+tcePG0alTp+jVq1cceuihCefsvvvu8dRTT8VJJ51UrKzleT8D8B9b+z1ySa6XK1WqFPvuu28ccMABcfzxx8fRRx8dlSpVKnD+/fffH/PmzYuXXnqpuHFhq+SZNwAAAAAAAAAAAAAAAAAAAAAAAGVFbm5uTJgwIeHvx6pQoUJUrlw58vLyYt26dQX+7lcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAonK90BAAAAAAAAAAAAAAAAIFnuvPPO2HHHHRPWvv/++zjuuONi6tSpxe6/YMGCuP766+Oxxx6LF198Mdq1a5dvTlZWVrz88svRokWLWLlyZbHXKut++OGHaN26dbpjwFZr5513jhdffDGyshL/GOCqVavi//7v/6Jfv37FXmP27Nlx1VVXxUMPPRQvvfRStG/fPuG8u+66K956662YPn16sdcCKImFCxfGwoULY/To0XHffffFnnvuGXfddVecfvrpCedXq1YtXn755TjggANiw4YNpZy2dMybNy8uvPDCGDx4cL5a5cqV4+WXX46DDjoo1q9fn5T1OnToEFdffXXC2vvvvx9//vOfk7JOSdSoUSPf2BNPPBF/+tOfSj9MIWRmZsYrr7xS4P1LRMRLL70U119/fcybN6/AOXl5eTF79uyYPXt2vPzyy9G4ceO4//7748wzz0w4f9ddd43nn38+unbtWuzs11xzTRx77LEJa+vXr4+bb745Hnnkkdi4ceNv9po7d24888wz8cwzz0S3bt2if//+0bBhw3zzTjzxxDjttNNi0KBBRcpanvczAP/hHnnLNmzYEJMmTYpJkybFM888E7Vr147rrrsurr322qhUqVLCbZ544on417/+FT/88EMpp4WyyzNvAAAAAAAAAAAAAAAAAAAAAAAAyoNNmzbFmjVr0h0DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGCrkZnuAAAAAAAAAAAAAAAAAJAMderUiYsuuihh7dtvv422bdvG1KlTk7LW7Nmz44gjjogRI0YkrO+6665x9dVXJ2UtYNuTlZUVgwcPjrp16yasz549O1q1ahX9+vVLyno//PBDHHHEEfHMM88krFeqVCkGDBgQmZl+JBEoG7755ps444wzokuXLrFq1aqEc/bee++4+OKLSzlZ6RoyZEgMGDAgYW3fffeN+++/Pynr1KlTJ5599tnIyMjIV1u6dGn07Nkz8vLykrJWSdSoUSPf2Jo1a9KQpHCuvfbaaN++fcLaxo0b45xzzomzzz475s2bV6S+c+fOjbPOOivOO++8yMnJSTinS5cuBd47/ZY99tgj+vbtm7D2888/R7t27eLBBx+MjRs3Frn322+/HYccckjMnTs3Yf22225LeBxuSXndzwD8h3vkolu2bFncdNNN0bx585g9e3bCOTVq1Eja9SIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUV5npDgAAAAAAAAAAAAAAAADJcPbZZ0eVKlXyjefm5kbPnj1jwYIFSV1v48aN0b1795g4cWLC+jXXXBO1atVK6prAtuGSSy6J1q1bJ6zNmTMn2rdvH1999VVS19y0aVNccMEF8dprryWst2rVKk455ZSkrglQUqNGjYrf/e53sX79+oT16667LjIyMko5Vem6/PLL49tvv01Y+8Mf/hBdunQp8RpPPPFENGrUKGGtd+/eMW/evBKvkQzVq1fPN7ZmzZo0JPltDRs2jFtuuSVhLTc3N0499dR4/vnnS7TGs88+G2eccUbk5eUlrN99991Ru3btIve99957o3LlyvnGV65cGUcddVRMmjSpyD3/2+zZs+Pkk0+OnJyczcZzc3Pjxx9/jAYNGhS6V3nezwD8h3vk4ps1a1YcdthhMWfOnIT10047Lfbcc8/SDQUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABlSGa6AwAAAAAAAAAAAAAAAEAydOjQIeH4iBEj4pNPPknJmhs2bIiePXvG+vXrNxtft25dDB06NKpXr56SdYGtV+3ateNPf/pTwtqqVauiS5cuMX/+/JSsnZubG+eee2789NNPCevXX399StYFKIkJEybE7bffnrDWuHHjOOKII0o5UelavXp1nH322ZGTk5OvlpGREQMGDIjtttuu2P179uwZp556asLagAEDYvDgwcXunWyJrr3Xrl2bhiS/rU+fPlGjRo2Etdtvvz1ef/31pKwzZMiQ6Nu3b8LadtttF3/4wx+K1G/vvfeOU045JWGtd+/eMX369CJnTGT8+PHxxBNPRETErFmz4o9//GPstNNO0bVr11iwYEGh+5TX/QzAf7hHLrl58+bFRRddlLCWkZER55xzTiknAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgLIjM90BAAAAAAAAAAAAAAAAIBlat26dcPzll19O6bozZ86MZ599NiIifvzxx+jTp080btw4evXqFT/99FNK1wa2Pn369Im6desmrF122WUxa9aslK6/cuXKuPLKKxPWdt9999htt91Suj5Acfz5z3+OFStWJKx17ty5lNOUvk8//TTuvPPOhLWGDRvG008/Xay+u+66a/z9739PWPvuu+/iD3/4Q7H6pkpmZv4fnV+7dm0akmxZdnZ2/P73v09Ymz17dtx7771JXe/OO++M77//PmHt8ssvj8qVKxe61xVXXJFwfNSoUfHKK68UK19B7rjjjmjXrl00a9Ys7r333iLfW5Xn/QzAf7hHTo5Ro0bFe++9l7DWrVu3Uk4DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZUdmugMAAAAAAAAAAAAAAABAMtSvXz/h+MyZM1O+9j333BPdu3ePXXfdNe67775YvHhxytcEtj6VKlWKCy64IGHto48+iueee65UcgwePDi++eabiIhYuXJlvPDCC3HMMcdE/fr1Y/bs2aWSAaAoNmzYEMOHD09Ya9myZSmnSY+77rorPv7444S1E044IS688MIi9cvMzIwXXnghatasma+2adOmOPvss2PVqlXFylqa1qxZk+4I+Zx22mlRo0aNhLXrrrsuNmzYkNT11q9fH3369ElYq1+/fhx99NGF6lOxYsU488wzE9ZuueWWYucryM8//xzjxo0r9vbldT8D8B/ukZNr0KBBCcdbtmwZVapUKeU0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUDZkpjsAAAAAAAAAAAAAAAAAlFTVqlWjYsWKCWsLFy5M+fpz5syJ1157LXJzc1O+1pZUrlw56tatG1WqVElrjnSoVKlS1K1bN6pVq5buKIVWqVKlMp+3Zs2aUadOnQLfX2XBv4/7qlWrpjtKiZ188smx3XbbJazdcMMNpZrlyiuvjO7du0e9evWiZ8+e8dZbb0VOTk6pZigPx1958O/3SI0aNdIdpUypWLFi1KlTJ2rVqhUZGRnpjpOP47/oJkyYkHB8zz33LOUk6ZGbmxtnn312rFixImH94YcfjiZNmhS6X58+faJ9+/YJa7fffnuMGzeuWDlL29q1a9MdIZ8zzjgj4fhXX30VQ4YMScmar7zySnzzzTdFyvO/jjrqqKhVq1a+8c8++yzGjx9fonypUF73c1lQXq+vy/JnZ4UKFaJ27dpRp06ddEehmMrrNXV5fFby39wjJ9e7776bcLxChQqx2267lXKa8ue/z+Vl8bNma7YtPPPe1o6vbeF7mi5Vq1aNunXrRu3atcvk865tXVm+ZwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAbVlWugMAAAAAAAAAAAAAAABASeXl5RVYy8jIKMUkpadOnTpxwgknRLdu3aJFixaxxx57RMWKFX+tr1mzJn755ZeYOXNmvPvuuzFq1KiYNm1aUjPss88+CcdnzJhR4j4LFy6MxYsXJ5xfp06dOOmkk6JTp06x//77x+677x6VK1f+tb5p06ZYsGBBTJkyJT777LN47bXX4osvvihSptLMXBp5f0vlypWjS5cu0aVLl9h///1j7733jjp16mz2/tmwYUN8//33MW3atPj4449j2LBh8c0335RqzkaNGsVJJ50Uhx9+eOy///6x6667RqVKlX6t5+TkxJw5c2LKlCkxatSoGDZsWCxcuLBUM5ZEr169Eo6PGzcuPvnkk1LN8tZbb5XaWuXl+CsP9ttvvzjhhBOiTZs20aJFi2jUqNFmnw15eXmxdOnSmD59+q/vk1GjRsW6deuSlqGo58eI/38MtGjRIvbcc8+oVatW1KxZc7Pv/6OPPlqijAcccEAce+yx0apVq2jevHk0atRos8+NvLy8WLFiRcyYMSMmTpwYb731VowaNSo2bdpU7DULy/GfPPPnz084XqtWrVJOkj5z5syJyy+/PJ577rl8tWrVqsVLL70U7dq1i5ycnC32adWqVdx+++0Ja5988kncfffdSclbGtauXZvuCJupVq1aHHHEEQlrAwcOTOnaAwcOjJtuuinfeJcuXSIjI2OL91QREcccc0zC8eeffz4p+ZKpPO/n0lYer6/L+mdnmzZtokOHDtGmTZs44IADYvvtt48aNWpslm3evHkxbdq0mDRpUrz55pvx2WeflUq2kqpcuXLsscceBdZXrlwZP/74469fb7/99lG/fv0C5++8884Jx2vVqlXg84aCbNiwIWnf47JwTR1RPp+VJNu2eo+cKvPmzSuwtuOOO8bMmTNLMU3Z9lvn8oiyeT4vr+fd/7Y1PfMuSHk9vorrt643N27cGD/++GNMnjw5Pvzww3j11Vfjp59+StiratWqsdtuu2029t133xX6M7h+/fqx/fbb5xv/redWRZWRkRF77713vvHc3Nz48ssvk7JGxYoV43e/+1107do1WrRoEfvuu2/Uq1cvKlSo8OucvLy8WLZsWSxZsuTX/fvhhx/G5MmTk5Lh31L9LLA8ntvKyj1LWXxOCwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABlUUZeXl5eoSZmZKQ6C1BOtWjRIlq0aBEREXl5efHdd9/FuHHjopCnFwAAAAAAAAAAiunKIRGVq6c7BVuzudMiXro23SkAKEhGRka0atUqmjZt+uvf954yZUpMmTIlzcm2Tf5OLZQNa9eujSpVquQbb968eUybNi0NiYqmoHPG//5cT/369ePmm2+O3r17R+XKlYu0xkcffRS33nprfPDBB8WNuZnCZi5OnxtuuCHuv//+zcYaN24ct9xyS5x//vlRsWLFIq3x5ZdfRt++fePFF1+M3NzcIm2bSKozJztvQXbaaaf44x//GD179owaNWoUefvPPvss+vbtG8OGDUt+uP9y2GGHxS233BIdO3Ys0vGVk5MTL7zwQtx+++0xZ86czWqffPJJtG3bNt82Bx98cIwfP76kkYusSpUqsWzZsoTv6969e8eTTz5Z6plSrawdf7Nnz45dd9013/jpp58egwYNSsoaqVCxYsU499xz49prr41mzZoVefvVq1fHCy+8EPfdd1/Mnj27xHkKe37MzMyMU089NS688MI44ogjIisrq8Ce2223XSxZsqRIOapVqxYXXnhhXHnllbHbbrsVaduIiF9++SUefvjh+Mtf/hJr164t8va/pawd/8mUrvdSly5dYuTIkfnGV61aFTVr1kz6et27d48hQ4bkG1+wYEHssMMOSV+vKF555ZU4/fTTE9b69u0bN910U4HbVq1aNb744oto2rRpvtrKlStj//33T8q5IhUSnX9at24dEyZMSEOaxDp27Bjvvvtuwtq+++4bM2bMSNna++23X0ydOjVhrWXLlvHFF19scfvPP/88WrZsmW98zz33jG+//TYZEZOmPO/n0lIer6/L8mdnxYoV4+KLL46LL7449tlnnyJvP3fu3Hj00UfjiSeeiBUrVhQ7R7Lu0ROpVatWjBgxItq3b5+w/sMPP0Tnzp3jq6+++nXs1ltvjdtvv73EaxfGRx99FIcffnixty9r19QR5fNZSTJtzffI6bz3XLp0adSuXTvf+AknnBDDhw/f4rb33HNP9OnTJ9/4m2++Gccdd1yyIhbK22+/HV27ds03ftttt8Udd9xRrJ4lPZdHJO98Xlxl8by7LT/z/m9bw/FVVMW93szLy4vXXnstbr755pg5c+ZmtcMPPzw+/PDDzcaKcq1Z0Hks0edrSVSrVi1Wr16dbzwZzycaNmwY1157bVx44YWRnZ1drB6fffZZ3HPPPTFs2LCk/H/ZqX4WWBbPbQUpa/csZeU5LQBAacjIyIjWrVtHkyZN/H1aoNBKcl/sd7UDBfFzJQAAAAAAAAAAAAClz+9qL1v8nVoAAAAAAAAAAACA0uV3tQPF4Xe1A6ng50oAAAAAILm6Hd0tjjrqqHTHYBvz1oi34v333093DIBS4bOWdBk6ZGh88skn6Y4BUCo6XR7R8th0p2BbM+qvEV+MSHcKgNLld7WXLf5OLQAAAAAAAAAAAEDp8rvageIozN/xziyFHAAAAAAAAAAAAAAAAJByixYtSjj+739cYWtw0kknxYwZM+IPf/hDVK5cucjbH3bYYfH+++/H4MGDo3r16ilImDrnnXdezJw5M3r37h0VK1Ys8vZ77bVXPPfcc/HFF1+U2jFRksypzluxYsW4++6749tvv41LLrkkatSoUaw+rVu3jtdeey0++uij2H333ZOcMqJevXoxdOjQGDNmTHTq1OnXH7ItrKysrDjvvPNi2rRpcemllyY9XzK1b98+4fs6Nzc3XnvttTQkSp3ycvyVB507d46vv/46nnzyyWjWrFmxelSvXj0uuuii+Prrr+Ohhx6KKlWqJDllfnvttVeMGzcuXnnllejQoUNkZWUltf+ZZ54Zc+bMiYcffjh22223YvWoV69e3H333fH1118n9R+Hdvynjn886z8uuuii+PHHHxPW+vTpE4cddliB2/7lL3+Jpk2bJqxddtllMXv27KRkLC1r165Nd4TNtGvXLuH4999/HzNmzEjp2tOmTSvwuCgo179VrVo14TXp3Llz49tvv01KvmQqr/u5NJTH6+uy/tnZvn37+OKLL+LRRx+NffbZp1g9GjduHPfff3/MmTMnzj333KRlS5YddtghPvroo2jfvn3C+rRp06Jdu3bx1VdflXKy/5g+fXqxty2v19QR5fNZSWFtS/fIpWndunUJx5N9T1beJONcHlH2z+fJVJLz7v/a2p95b2vHV0mvNzMyMqJ79+4xZcqUuPHGG4u8/dYqIyMjrr322pg9e3b83//9X2RnZxe7V+vWrWPo0KExduzY2GGHHZKYsmCpfhaYLMU9t5X1e5YtKS/fGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABIpcx0BwAAAAAAAAAAAAAAAKBosutHNO8ccchZEUf0imjdPWLXgyIqVEx3svT6+uuvE46fdNJJpZwkNa6//voYOnRobLfddiXudfLJJ8e4ceNi1113LXmwUvDwww/HM888EzVq1Chxr+bNm8dnn30W5513XsmDbUGyMqcib+PGjWP8+PFx4403RsWKyTlxHHrooTFlypQ45phjktIvIqJNmzYxbdq0pLyHq1evHn//+9+jX79+kZlZNn+srkOHDgnHJ0+eHIsWLSrlNKlTXo6/si4zMzP+/ve/xzvvvBO77LJLUnpWqFAhrr766pgyZUrstddeSemZyMEHHxyffPJJtG7dOum9q1atGoMHD46XXnop6tWrl5SejRo1infffTeuv/76Evdy/KdWlSpVEo6vXbu2lJOk3/Lly6NHjx6Rm5ubr5aZmRkvvPBCZGdn56sde+yxcdFFFyXsOXDgwHj++eeTnjXVytr3f9999004Pnny5FJZf8qUKQnHC8r1b02bNo0KFSrkG584cWJSciVbed3PqVYer6/L+mfnueeeGx9++GHss88+SUgWUadOnRgwYEAMHTo0KleunJSeJdWkSZP45JNPonnz5gnrH330URx66KHx008/lXKyzU2fPr3I25Tna+qI8vmspCi2lXvk0paRkZHuCGVOss/lEWXzfJ5sxTnvJrK1P/Pe1o6vZF5vZmVlxd133x3Dhg2LSpUqJSFd+ZWdnR2jR4+OBx54oMBnH8XRrl27+Pzzz+Pggw9OWs9EUvksMNmKc24r6/csW1KevjcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkEqZ6Q4AAAAAAAAAAAAAAABA4TTaJ+LMByMufi6i2zURh54TcfBpEb/rHXHa3RF/GBRx+PkRlaqlO2l6vPfeewnHTz755GjZsmUpp0muyy67LO67776k9txvv/1i1KhRUbNmzaT2TbaHH344rrzyyqT2rFSpUvTv3z+uuOKKpPb9t2RnTmbeJk2axMcffxwHHHBAoebn5OTE2rVrCzW3evXqMWzYsDj99NNLkPD/O+KII+Kf//xn1K9fv8S9/tuFF14YTzzxRFJ7JkuLFi0Sjv/rX/8q5SSpU16Ov7KuSpUq8frrr8ell16akv7//j61b98+6b133333GDlyZNSuXTvpvevWrRsffPBBnHzyyUnvnZmZGffdd1/cdNNNxe7h+E+9hg0bJhxfvHhxKScpG8aMGRMPPPBAwtrOO+8cjz/++GZj9evXj/79+yec/+OPP8ZFF12U9IylYc2aNemOsJm999474fi0adNKZf2pU6cmHN9rr722uF2zZs0Sjs+YMaPEmVKhvO7nVCqP19dl/bPz/PPPj2eeeSYqVKhQqPlr164t9DnppJNOinfeeScqV65c7HzJcNBBB8XYsWNjl112SVh//fXXo1OnTrF8+fJSTpbf9OnTizS/PF9TR5TPZyVFtS3cI6dDrVq1Eo4X9vy5tSnuuTwvL69Q88vK+TwVinreTWRrf+a9rR1fqbrePP7442PYsGGRmblt/qq0OnXqxAcffBBHHnlkoebn5ubG6tWrIycnp1DzGzZsGG+++WbstNNOJUhZsFQ+C0yFop7byvo9y5aUt+8NAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKRSVroDAAAAAAAAAAAAAAAA8Nva94w45KyIjIyC51SqGtH29Ii9j4wYclvEojmlla5sePvtt+Puu+/ON56RkRHDhg2LQw89NH788cc0JCuZtm3bxiOPPJJvPC8vL8aMGRPDhg2LCRMmxLx582LNmjWRnZ0d9erVi5YtW8bRRx8dXbp0iQoVKiTs3aRJk3j22Weje/fuqX4ZxXLOOefElVdemW98w4YN8c4778Tbb78dX3zxRSxYsCDWrFkT1atXjwYNGkSTJk2ia9eu0a1bt6hdu3bC3hkZGfHwww/Hd999F2+++WbaMu++++6llrdu3boxatSo2GmnnQqcM2XKlBg4cGCMGjUqvv3221i6dGlERFSqVCm23377aNWqVXTu3DnOPvvshFmzsrLi2WefjTlz5sSnn35arJx77LFHDBs2LGrUqFHgnPXr18fo0aPjrbfeiilTpsTChQtj2bJlUbly5dhuu+2iefPm0bFjxzjhhBMiOzt7s20vuOCCmDx5crGypVKTJk0SjpfFrMVRXo6/8uD555+PY489tsB6bm5ufPLJJ/HGG2/EZ599FgsWLIglS5ZEtWrVokGDBrHnnnvG0UcfHV27di3wnFOnTp0YMWJEtGvXLmbOnJmU3BUqVIihQ4cWuGZJVKpUKd54441o06ZNgXM2bdoUY8eOjbfeeismTJgQCxcujMWLF0dGRkbUqlUrmjRpEocffniceeaZseOOOybscdddd8U333wTAwcOLFI+x3/p2GOPPRKO//LLL6WcpOy4+eabo2PHjnHQQQflq5155pnxxhtvxMsvvxwREc8880zUq1cv37zc3Nzo2bNnLF++POV5U2Ht2rXpjrCZRo0aJRyfOnVqqaw/ZcqUhOMF5fq3nXfeOeH4d999t8XtMjMzo1WrVtG8efNo1qxZ1K1bN2rUqBGZmZmxatWqWLFiRcyZMyemTp0aEyZMSNpxVl73c6qUx+vrsv7Zufvuu8ff/va3yCjgIc1PP/0UL730Urzzzjsxbdq0+PnnnyM3N/fX19a0adM49NBD4+STT462bdsm7HHEEUfEo48+GhdddFGRsiVLhw4dtnjcPPnkk3HxxRf/+roSmTt3bowbN67A+nbbbZfwPmjJkiUxa9asIuWdNm1akeaX12vqiPL5rKQ4tvZ75HSoWbNmVKlSJWGtvF7rlURJzuURZfN8XpbPu/9ra3/mvTUeX1tSmOvNDRs2xOjRo2PEiBFFvt7s1q1b3HPPPTFixIhUv5Qy58UXX4yWLVsWWP/oo49i8ODBMXbs2Jg1a1asXLny11rNmjVjt912iyOPPDLOOeechM8GIiK23377GDJkSLRv3z42btyYtOzJehZYVs9tZf2eZUtS+ZwWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMqjrHQHAAAAAAAAAAAAAAAAYMs6XhZx4HGFn1+rQUSPhyJeuCZi0ZyUxSpzJk2aFKNHj46jjjoqX23nnXeOSZMmxaWXXhqDBg1KQ7ri69evX1SoUGGzsREjRsQNN9wQ06dPzzd/4cKF8fXXX8fHH38cf//732OfffaJRx99NDp06JCw/0knnRSnnnpqvPrqqynJX1wNGzaMG2+8cbOxvLy8eOyxx+Luu++On376KeF23333XXzyySfx3HPPRfXq1ePqq6+O6667LrKzs/PNzcjIiBdffDH23XffmDt3bloyL1y4sNTyDhw4MHbdddeEtR9//DGuueaaGDx4cML6hg0b4qefforhw4fH8OHD48Ybb4wbbrgh+vTpE5mZmZvNrVy5cgwePDj22muvWL16dZEyZmVlxdChQ6N27doJ65s2bYr+/fvH7bffHvPmzUs454cffohJkybFc889FzVr1owrrrgibr755qhSpcqvc+67775YsmRJkbKlUmZmZuy2224Ja1999VUpp0mN8nD8lQe33HJLnHLKKQXWR44cGddff31MnTo1Yf3f58jnn38+qlevHtdcc01cf/31UaNGjXxza9WqFSNGjIgDDjggVqxYUeLsl19+eey///75xpcuXRqvv/56vPnmmzF16tRYuHBhLF++vEi9H3vssTjkkEMKrA8ePDhuuummmDVrVsL6Tz/9FDNnzozhw4dHnz594vLLL4++fftG1apV88194oknYuzYsUU6Dzv+S8fxxx+fcPyzzz4r5SRlR05OTpx11lkxadKkqFatWr76Y489FmPHjo2jjz46jj766IQ97r///vjwww9THTVl1qxZk+4Iv8rKyoq6desmrM2fP79UMixYsCDheMOGDbe4XYMGDRKOF3RNfthhh8Ull1wS3bp1K/C67n/l5OTEmDFj4sUXX4wXXnghNmzYUKjt/ld53s+pUF6vr8v6Z+fDDz+c8Lyam5sbt956azz44IOxfv36hNsuWbIkxo0bF+PGjYsHH3wwDjnkkHjssceiRYsW+eb27t07Bg8eHO+++26hsyXDqaeeGi+88EJUqlQpYf3OO++MW2+99Tf79O/fP/r3719gvXv37jFkyJB846NHj45TTz218IGLqDxfU5fHZyXFsS3cI6fD3nvvXWBt9uzZpZikbCjJuTyibJ7Py+p5N5Gt/Zn31nh8FeS3rjdzc3NjwIAB8ac//Sl+/PHHhHMKc7157bXXxi+//JKKl1Bm/eEPf4hu3bolrH3++edxySWXxPjx4wvcfuXKlTFlypSYMmVKPProo9G9e/d45plnEn7+t27dOs4777x48sknk5Y/Wc8Cy+q5razfs2xJKp/TAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEB5lJnuAAAAAAAAAAAAAAAAABSsRdeIA48r+naVqkWcfPv//99tya233hp5eXkJa9ttt10MHDgwpkyZEpdddlk0bNiwlNMVT/PmzX/975ycnLjooovi2GOPjenTpxdq+xkzZkTnzp3jmWeeKXDO9ddfX+KcyXbJJZdErVq1fv16+fLl0aFDh7jsssvip59+KlSP1atXx1133RUHHnhgzJw5M+Gc7Ozs+Mtf/lImMqcyb48ePaJjx44Ja2PHjo2DDjooBg8eXOh+K1asiJtuuimOOeaYWLlyZb5648aN4/bbby9yziuvvDJatGiRsLZ06dLo3Llz9O7dO+bNm1eofitXroy77747WrZsGbNnz/51vFq1atG4ceMi50uVHXfcMSpWrJiwVtjXWpaVl+OvrNtvv/3illtuSVj79+dDt27dYurUqYXqt3r16rjzzjtj//33L/Ccs9tuu8X9999f7Mz/Vq1atbj55ps3G1u/fn3cd999sdtuu8X5558fQ4YMiVmzZsXy5cuL1Ltjx47Rq1evhLW1a9fGqaeeGqeeemrMmjWrUP1ycnLi4YcfjkMOOSR++eWXfPVatWoV6fhy/JeOQw89NPbaa6+EtbFjx5ZymrJl1qxZcfXVVyes1apVK1577bV46KGHEtYnTpxY4HmnPMjNzY2NGzduNta8efPo2bNn3HvvvTFo0KAYOXJkjB07Nj777LP46KOP4u23344XX3wxbr311jj11FOTes9Qp06dyMjISFhL9H5OhRUrViQcr127doHZIiLq1auXcHzx4sWbfd26desYN25cjBkzJs4888yoXbt2obNlZWXFUUcdFU8//XTMmTMnLr744kJv+9/K835OhfJ4fV3WPzvr1asX3bp1S1g788wz4+67747169cXut/HH38crVu3jqFDhyas33HHHYXulQyXXHJJvPLKK1GpUqV8tdzc3Ljsssvi1ltvLdVMyVSer6kjyuezkuLY2u+R0+X4449POL5o0aKYP39+KadJr2SfyyPK3vm8rNuan3lva8fXlq43ly9fHt26dYvf//738eOPPxaqX0HXm5mZmeX6GqSosrOz47bbbktYe+GFF6JNmzYxfvz4IvUcOnRotG/fvsBnb9ddd13S7ldS+SywLCjr9yxbsrV/bwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgODLTHQAAAAAAAAAAAAAAAIDEKlWLOKJX8bev1SCi7enJy1MejB07Nu64444tzmnevHn87W9/i59++ilmzJgRTz/9dFx++eVx1FFHRcOGDUspadHl5ubG6aefHv369SvWtr169YoxY8YkrLdq1SoOP/zwkkZMqipVqvz632vWrImjjjoq3n///WL1+vbbb+Pggw+Ozz//PGH9lFNOifbt2xer939LVuZk561SpUrcf//9CWuTJ0+Ojh07xi+//FLknBERI0eOjHPOOSdh7Q9/+EM0aNCg0L1q164dt912W8LakiVL4uCDD47Ro0cXK+eXX34Z7du3j7lz5xZr+1SrWbNmgbWFCxeWYpLkKy/HX3nw+OOPR8WKFfONb9y4MY4++uhifT5ERHz33Xdx8MEHx7hx4xLWe/fuXay+/+3MM8+M7bff/tevFy1aFEcddVT06dMnli9fXuy+mZmZ8Y9//CNhbc2aNXHkkUfG4MGDi9X7iy++iI4dO8aaNWvy1dq0aROVKlX6zR6O/9JRuXLleOqppxLWli1bFm+//XYpJyp7+vXrF8OHD09YO/DAA6Nq1ar5xtesWRNnnXVW5OTkpDpeyqxduzYiItq2bRtPPfVUzJs3L6ZMmRLPPfdc3HDDDXHqqadGly5d4pBDDolWrVrFoYceGl27do2zzjorbr/99hg0aFDMnz8/Jk+eHNdee23UrVu3RHkqV65cYG3lypUl6l1YW1pnS+e1atWqbbFfRkZG3HXXXfHpp5/GwQcfXLKQEbHDDjvEY489Fv/6179i5513LtK25Xk/J1t5vL4uD5+dxx13XGRlZeUbHzhwYAwaNKhY2TZs2BCnn356fPLJJ5uNv/vuu3HrrbcWq2dx/OlPf4p//OMfkZmZ/1eRrF+/Pk477bQCr73Ki3ReU7dp06ZYvf9beXxWUhxb8z1yulSpUiV69OiRsPbhhx+Wcpr0S8W5PKLsnM/Lk63xmfe2dHxt6Xpz2bJl0a5duxg1alSxeie63tzS58PWpmLFivHyyy/HunXrNht/6623omfPnrFp06Zi9Z02bVpcdtllCWtNmjSJbt26Favv/0rVs8CyoDzcs2zJ1vy9AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDiykx3AAAAAAAAAAAAAAAAABJr3jmianbJehx4fESFisnJU1786U9/ipdffvk352VkZMTee+8dvXr1ir/+9a/xz3/+M+bPnx9Lly6NsWPHxpNPPhlXXXVVdOrUKRo1alQKybfstttui6FDh5aox3nnnRcbN25MWDvhhBNK1DuVLr300vj8889L1GPlypVx8sknx9KlSxPWr7rqqhL1/18lzZzMvGeddVbssMMO+cZXrFgRJ510Uqxbt664MSMiYtiwYfHUU0/lG69UqVJcdtllhe7Tq1evqFmzZr7xvLy86NGjR3z99dclyjl//vw4+eSTY9OmTSXqkwrVq1dPOJ6Xlxdr1qwp5TTJVV6Ov7LusMMOi/bt2yesXXfddfHuu++WqP+/zzk///xzvlpGRkaJekdENG3a9Nf/XrZsWbRr1y4+/vjjEvft3r17NGnSJGHt0ksvjfHjx5eo/5QpU+Kaa6759evx48fHSSedFC1atIgNGzb85vaO/9TLzs6Ot99+O5o1a5aw3r9//1i7dm0ppyqbevXqFQsWLCj0/KuvvjpmzZqVwkSpl5WVFZ999ll88skn8fvf/z523HHHYvVp0aJFPPDAAzFv3ry49957C/zc/i1VqlQpsLZy5cpi9SyqLa2zpXyVK1dOOL5+/fqoUKFCDB48OG666aakfGb8t/bt28dnn30Wbdq0KfQ25Xk/J1t5vL4uD5+de+yxR8LxZ599tkTZcnJy4vzzz4+1a9fG888/H/vvv3907ty5xNd5hZGRkRGPPfZY3HbbbQnrK1asiK5du8aQIUNSniWV0n1NfeONN5ao//8qj89KCmtrvkdOl5tuuil22WWXhLVXXnmllNOkX6rO5RHpPZ+XR1vjM+9t6fgq6HozIuL888+PmTNnlqh/WX6em2qLFy+OP/zhD7HbbrvFn//851i9enUsW7YszjnnnBL3fvHFF2Pq1KkJax06dChx/4jUPQssC8rDPcuWbM3fGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAorsx0BwAAAAAAAAAAAAAAACCxPduWvEelqhE7tyh5n/LmrLPOittuuy3y8vKKvG3t2rXjkEMOiQsuuCD+8pe/xKhRo2Lu3LmxdOnSeOedd+JPf/pTdOzYMSpUqJCC5IlNnjw57rnnnhL3mT17dgwbNixh7dBDDy1x/1T46KOP4tlnn01Krzlz5sT111+fsHbiiSdGw4YNk7JOsjInK+/ll1+ecPzRRx+N2bNnFzvff7vnnnsiNzc33/g555xT6B6XXHJJwvEBAwbE22+/Xexs/238+PHxxBNPJKVXMlWvXj3h+Pr160s5SfKVl+NvS/bYY4848MADk/qncePGRcpw7bXXJhx/77334pFHHknGy4yffvopLrzwwoS1Jk2aJGWNiIhevXrFN998k5ReV155ZcLx4cOHJ+2zo1+/fvHYY4/FkUceGQcffHAMGzas0NcXW8PxX5Z169YtPv300/jd736XsL548eK49957SzlV2bV48eI499xzC3X8Dh8+PPr161cKqVKrcuXK0apVq6T1q1KlStxwww0xa9asOOyww4q8fWZmwT/av2HDhpJEK7QtXVts6f6mUqVKCcdzcnLimWeeie7duyesb9q0KT777LN46aWX4tFHH4077rgj7rnnnujXr1+8/vrrMX/+/N/MXL9+/XjvvffigAMO+M25EeV7Pydbeby+Lg+fnTvuuGPC8W+//bZEuSIivvrqq2jQoEGcc845MWXKlBL3K4xKlSrFoEGD4uKLL05YX7BgQRx++OHxwQcflEqeVEr3NfXxxx+ftOvq8vispCi25nvkdDj33HPjxhtvTFibN29eDB8+vJQTpV8qz+UR6Tmfl0db6zPvben4Kuh686WXXirwe1JUZfV5bmlZsGBBXHvttbHLLrvE8ccfH4sXL05K34L2aXHudX9LMp8FlgXl4Z6lsLa27w0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFFdWugMAAAAAAAAAAAAAAACQ2Pa7JKfPdjtHzJ6YnF7lyR133BEffPBB/PnPf45WrVqVuF/t2rWjc+fO0blz54iI+OWXX+LFF1+Mp556KqZPn17i/ltyyy23xKZNm5LS65lnnolTTz013/iBBx4Y1apVizVr1iRlnWS58847k9rv+eefj759+0a9evU2G8/KyoquXbvGgAEDSrxGMjOXNO/OO+8cLVu2zDe+Zs2a+Mtf/pK0nN9991289957v74//m2XXXaJvffeO2bOnLnF7Zs2bRp77rlnwtqf//znpOWMiLjrrruid+/ekZVVdn68rnLlygnHc3JykrbGHnvsEc2aNUtKrw8++KBQ54rycvz9lr59+0bfvn1L1ON//fGPf4x77723UHNr1qwZ3bp1S1i75557khkrhg8fHtOnT4999913s/FTTjklKWu99tpr8dprr5W4T0RE/fr1o3379glr9913X1LWiIjIy8uLSy+9tMjbbS3Hf1nTqFGjOOmkk+Kss86Kdu3abXHu5ZdfHr/88kspJSsfRo0aFX/961/jiiuuKHDOggULolevXqWYqvzZcccdY/To0XHppZfGk08+me44adWrV6/o2bNnvvGJEyfG/fffHyNHjowVK1Zsscdee+0V5513Xlx66aVRs2bNhHNq1qwZb7/9dhxwwAGxcOHCpGTf2pXH6+vy8tlZ0LV7Xl5eUvKtXLkyKX0Ko0aNGvH666/HUUcdlbD+zTffROfOnWP27NmllilVysI1dUZGRtKuq8vjs5Ki2FrvkUtblSpV4uabb44bb7wxMjIyEs7505/+FBs2bCjlZOmX6nN5ROmez8urrfWZ97ZyfG3pevPBBx9M6lpl8XluaVu8eHF89NFHSes3evTohOMtW7aMChUqJO29mcxngWVBeblnKYyt7XsDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACWRle4AAAAAAAAAAAAAAAAAJFY1Ozl9qtdJTp/yaMyYMdG6des4+eST44ILLohOnTpFhQoVktK7Xr16cdVVV8UVV1wRAwYMiD/+8Y/x888/J6X3f/v+++/jjTfeSFq/sWPHRl5eXmRkZGw2npWVFbvsskvMnDkzaWuV1Pfffx/vvvtuUnuuX78+nn766ejTp0++WteuXWPAgAEl6p/szCXN26lTp4Tj7733XixZsiQZEX/1wQcfROfOnfONH3nkkb95XCXaLuL/v4enT5+elHz/Nn/+/HjzzTfjxBNPTGrfsu6KK66IK664Iim9mjVrFrNmzfrNeeXl+EuHb775ptBzO3fuHBUrVsw3Pm3atBg9enQyY0VExMMPPxxPPvnkZmPHHXdc3HPPPUnpnSxdu3bN91kWETFp0qT4+OOPk7ZOcTn+8zvxxBNj1113LdTcjIyMqFq1atSsWTNq1qwZe+yxR+y7777RoEGDQm1/xx13xCuvvFKCtFuvuXPnbrG+fPnyWL16dSmlKV0bN26MadOmxcSJE2P+/PmxZMmSWLFiRWRkZEStWrWibt26sdtuu8XBBx8ce+yxxxZ7ZWVlxRNPPBE5OTnxzDPPlNIrKHtuvPHGzb5esmRJ/P73v49hw4YVuseXX34Zffr0ifvuuy8efvjhOOeccxLOa9iwYfTr1y9OOOGEkkTeZpTH6+vy8tm5bNmyhOO77bZbfP3118mIVyrq1asXI0eOjAMPPDBhfeLEidGtW7f45ZdfSjlZapSFa+qI5FxXl8dnJWVROu6RS0u9evXijDPOiP/7v/+LXXbZpcB5o0ePjqeeeqoUk5UdW8u5vDzbmp95byvHV0HXm+PGjYtJkyYlda1t9XluKn355ZexatWqqFGjxv9j777Dq6rSvgE/CSHUUKWIqIigCILSRBTF3vtrwwL6OrYRdXRsg11Hxzp2LGPvIthQUFCxYUFBQEVBcKRJ7y205PtjPnkHcwJJzkm/7+viGs+z9n7WLyc766x9hhw2qmdkZET9+vVj/vz5KZknle8FlgXl5Z6lICra9wYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkpFR2gEAAAAAAAAAAAAAAABIbG12RLVayfdZsyr5HuXdoEGDYtCgQdGkSZM49thjY88994zu3bvH9ttvn3Tv9PT0+N///d84/vjjo1evXjFkyJAUJP4/b7/9dkr7LV26NKZMmRKtWrXKM1a/fv2UzpWsYcOGFUvfDz/8MK666qo89a5duybduzgyJ5O3R48eCevvvfde0rn+6Msvv0xYb9eu3WbP7datW8L6iBEjksqUnyFDhsQxxxxTLL3LqtatW5f4nOXl+isNkydPLvCx++67b8L6u+++m6o4m+3brVu3qFatWqxevbrIfX/66af45JNPkom2kb322ithvTiur6Jw/efVq1ev6NWrV7HOkZubGzfffHNcf/31xTpPebXrrrvG3//+900es+OOO8bdd98dF1xwQQmlKl4rVqyI119/PZ577rn4+OOPC7yONW3aNPr06RPnnXdetGjRIuExaWlp8dhjj8WPP/6Y789hRZeR8X8fV/Ddd9/FkUceGVOnTi1Sr0WLFkWfPn3is88+i4cffjiqVKmS55ijjjoqjjrqqHjrrbeKnLmyKI/76/Ly2jlr1qyE9V69ehXbPWyqbbvttjF8+PB87xGGDx8exx57bKxYsaKEkxWfsrCnjkjNvro8vldSFpXGPfLmbL/99tGpU6cCH5+enh5ZWVlRp06daNy4ceyyyy6x6667Rrdu3TZ6jU5kypQpcdJJJyUbudyqCGt5eVeR3/OuLNfXbrvtlrD+wQcfFMt8lfH93OKUm5sbs2bNSvh62KBBg5g/f37Sc6T6vcCyoLzcs2xORfzeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAyMko7AAAAAAAAAAAAAAAAAIktmx9RrVbyfZbOS75HRTFnzpx45JFH4pFHHomIiIYNG0a7du2ibdu2sfPOO0fbtm2jbdu20aRJk0L3rlOnTrz11ltxwQUXxKOPPpqyzJ988knKev1u+vTp0apVqzz1Bg0apHyuZHz66afF0nfUqFGRm5sbaWlpG9VbtGgRmZmZsWbNmiL3Lo7MyeRt06ZNwvoXX3yR0owREbNmzUpY32GHHTZ77o477piwXhw5I4rv2kq1P37Pk5HoZ764lZfrrzRMmTKlwMe2bds2Yf2zzz5LVZyNzJgxI6ZPnx5bb731hlp6enrsuOOOMX78+CL3/eijj1KQ7v/stNNOCeuff/55SucpKtd/yZs9e3b07t07hg8fXtpRyqTq1avHSy+9FJmZmZs99s9//nMMGTIk3nnnnRJIljonn3xyXHvttdGuXbtYvnx53HnnnfHPf/4zli9fXuhes2fPjttvvz3uvPPOuOKKK+LGG29M+NxlZGTEiy++GO3atYtVq1al4ssol2bMmBEHH3xwvutRYfzrX/+KzMzMePDBBxOOX3fddfHWW28lPU9FVx731+XltTO/PVjv3r1jyJAh8eqrryaVrbi1b98+3nvvvdhyyy0Tjr/00kvRp0+fWLt2bQknK15lYU8dkZp9dXl8ryRVyvs98ubceuutceuttxb7PD/99FMcdNBBMX/+/GKfq6wq72t5RVCR3/OuLNdXedxvsrElS5YkrKfqZybV7wWWBeXlnmVzKuL3BgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACSkV7aAQAAAAAAAAAAAAAAAEjs129T02dqivpURAsWLIhPPvkkHnnkkejbt2/st99+0bRp02jYsGH06NEjzjnnnLjvvvvik08+iVWrVm22X5UqVeLhhx+OI444ImUZf/zxx5T1+t2SJUsS1uvVq5fyuZLx888/F0vfJUuWxNSpU/PU09PTo2XLlkn1Lo7MyeTdYYcdEtYT9UvWokWLEtbr16+/2XNbt26dsD5+/PikMuVnypQpkZOTUyy9i2L16tUJ6xkZGSnpX6VKlWjRokVKehVGebn+StrcuXNj2bJlBT5+p512SlgfM2ZMqiLlMXr06ALnKKivvvoqqfP/aMcdd0xY//bbsrHxcf2XnPnz58eVV14ZrVq1iuHDh5d2nDLrn//8Z7Rp06bAxz/11FPRuHHjYkyUeq+88krsvPPOcfjhh8f2228fN910Uyxfvjypnjk5OXHbbbfF7rvvHgsXLkx4zHbbbRcXXnhhUvOUZzk5OXH00UfHrFmzUtbzoYceiqeeeirhWOfOnaN79+4pm6uiKo/76/Ly2vnZZ5/FggUL8tTT09PjlVdeiWeeeSZ22WWXpDMWhx49esQnn3wSW265ZcLx5cuXxwUXXBBr164t4WTFr6zsqTeVpaDK43slhVVR75HLgieeeCJ23333mD59emlHKVXleS2vKCrye96V5frKb785duzYYpmvrL2fW141bdo09txzzzj99NOjQYMGCY/JzMxMyVypfi+wLCgv9yybUxG/NwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQjIzSDgAAAAAAAAAAAAAAAEBiP7wf0fnoiLS0oveYOjZi+YKURao0Fi5cGCNHjoyRI0duqGVkZET37t3jtNNOi169ekVWVlbCc9PS0uLZZ5+NXXfdNaZNm5Z0lpkzZybd44+WLl2asJ6enp7yuZIxderUYuu9cOHCaNGiRZ56/fr1k+pbXJmLmjfR+KpVq2LhwoWpirbB8uXLE9bz+1n5b3Xr1k1YX7CgeBawtWvXxm+//RbNmzcvlv6FlZ2dnbBerVq1lPTfeuutY/Xq1bF69epCnVerVq1IS+JFqLxcf5vTt2/fGDx4cNJ9frd27dpCHd+oUaOE9Xnz5qUiTkLz58/PU9tiiy2S6jlu3Likzv+jBg0aJKwX5/NSGBXl+i+r1q1bFwMHDoxXXnkl3n333XzXUf7jiCOOiPPPPz/h2Lx58xKuM40aNYpnnnkmDj300OKOl3JDhgxJec9vv/02DjzwwBgxYkTUqVMnz/hVV10V999/f5GvxZLah29qntzc3CL1fP7552PMmDFFjZSvv/3tb3HiiSdGrVq18oydcMIJ8cUXXxS6Z3l+ngurPO6vy8tr59q1a+Mf//hH3HXXXXnG0tLSonfv3tG7d++YMWNGfP311/HDDz/E5MmTN/yZM2dO0vmL4sgjj4wBAwZE9erV8z2mdu3a8eijj8aJJ55YgslKRlnZU0ckv68uj++VFFZFvUcuTZMnT45zzz03Pvzww9KOUiaU17W8IqnI73lXluurXr16Cev5vf4lq6y9n1tWVatWLVq0aBHbb799tGzZMlq1ahUtW7bc8KdGjRolliXV7wWWBeXlnmVzKuL3BgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACSkVHaAQAAAAAAAAAAAAAAAEhszuSIiZ9GtNm7aOfn5kR8/GRqM1Vm69ati08//TQ+/fTTuPrqq+Pvf/97nHvuuQmPrV+/ftx8883Rp0+fpOddtmxZ0j3+KCcnJ+U9i8PSpUuLrffixYsT1mvXrp1U3+LKXJS8NWvWjLS0tDz1GjVqxKpVq1IVbYNEc0VEVKtWbZPn5Zdz9erVsWbNmpRkS6Q4fraKauXKlfmO1apVK1asWJFU/19//TWysrIKfd6PP/4Ybdq0KdKc5eX6K4h58+bFtGnTku5TFDVq1IgqVarkqa9evTqys7OLbd5FixblqRXlGvpvCxYsSOr8/1azZs1IT0/PU1+9enWsXr06ZfMUVUW6/lPpt99+K/TrZJ06daJZs2Z56lWqVIm77rorRo8enap4FVbjxo3jyScT3xTMmTMnOnbsGG+++WZ07do1z/ghhxwSffv2jQcffLC4Y5YLY8aMiX79+iV8PurXrx+HHXZYvPbaa/mev6n1qWrVqinJuDmZmZn5jhV1/fz73/9e1DibNGfOnHjiiSfioosuyjN2yCGHxKWXXprwvIr6PBdGedxfl7fXzgceeCCOPfbY2HPPPfM9pnnz5tG8efM49thjN6qPHz8+Jk+eHJMnT46ff/45xo0bF+PHjy/Wa+PMM8+Mf/3rXwn3lX90wgknxP/+7//m+9pRHpWlPXVE8vvq8vheSWFVxHvk0rB27dp466234rHHHovhw4dHbm5uaUcqU5JZy1esWBFTpkwp8fW8Iqno73lX9Osrv73bmjVrijVjWXo/t7Q1a9YsOnfuHB06dIhWrVpFy5YtY/vtt49mzZrlu9ctaal8L7AsKG/3LJtS0b43AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJCsjNIOAAAAAAAAAAAAAAAAQP7euz+i8fYRDbYq/LkfPxkxe1LqMxExf/78OO+88+KLL76IJ598MtLT0/Mcc8opp8S1114b06ZNS2qutWvXJnV+ebZy5cpi671kyZKE9dq1ayfVt7gyFyVvrVq18h2rXr160plSJb+cS5cuLdZ5V6xYUaz9C2POnDn5jjVp0iR++eWXEkyTGuXl+ivrSuvnY9GiRXlqderUSapnfutYUZTW81JQrv/ELrnkkhgwYEChzqlfv3788ssvUa9evY3qaWlpce+998Zee+2VwoQV0zPPPBONGjVKOHbmmWfGrFmz4pRTTomxY8cmvHbvvPPOGDFiRPzwww/FHbVcePjhh+PPf/5ztG3bNs/Y8ccfH6+99lq+565evTrfsZJaG2rUqJHv2Kby5WfixInx888/JxNpk95444246KKL8tR32GGHqF69emRnZ+cZq4jPc2GVx/11eXvtXLNmTRx99NExfPjw6NixY6HO7dChQ3To0GGj2rp16+Ljjz+OF154IV5++eVYtWpVKuPGk08+WajjH3jggRg5cmRMnDgxpTlKS1naU0ckv68uj++VFFZFvEcuTrm5ubFs2bJYtGhR/PDDD/H111/HqFGj4ssvv4yFCxemdJ5EEr0vWtzymzO/jIkks5bXqlWrVNbziqSiv+dd0a+v/F5bU/neTyJl6f3c0tCuXbvo3bt3nHTSSbHtttuWdpzNKu7roaSVt3uWTalo3xsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASFZ6aQcAAAAAAAAAAAAAAAAgf6uXRwy8JmLhjMKd99WAiFEDiycT/+eZZ56JG264IeFYRkZGnHHGGSWap6LJzc0ttt7r169PWE9LS0uqb3FlLkreZL+WkpJfzvy+5lRZt25dsfYvjHnz5uWbp3nz5iWcJjXKy/VX1qWnJ/410OL++UjUP9nv6dKlS5M6/7+V1rpRUK7/1Fm0aFHcdNNNCcd69OgR//M//1PCicqXvn37xiGHHJJw7KGHHoqhQ4dGRMTkyZPj4osvTnhc9erV46WXXorMzMxiy1me5OTkxHPPPZdwrEuXLps8d9myZfmONWjQIKlcBZXfPKtXry7SGvr+++8nG2mTPvvss1i9enWeepUqVWKHHXZIeE5FfJ4Lqzzur8vja+eCBQuie/fu0b9//6Sf24yMjNh///3jySefjMmTJ8eZZ56ZopT5++CDD+Koo46KnJycPGM1a9aMV155pcKs/WVpTx1Rdt93iCi+zIVVEe+RC6Jv376x7bbbFvjPNttsE/Xq1YsqVapE3bp1o0WLFnH44YfHDTfcEEOGDImFCxemNF92dnbCeu3atVM6T0FkZWUlrOeXMT+pXMsjSmc9p+yqyNdXedxvlmfbbrttvPjii/Hdd9/FFVdcEdtuu21pRyqQVL4XWBaUx3uW/FS07w0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJCu9tAMAAAAAAAAAAAAAAACwaYtnRTz3l4gJIyJyczd97PKFEYP/EfHxkyUSjYi49dZb49///nfCsX333beE0wDlUW5ubsyYMSPhWJs2bUo4DRSP3M1tYiAfDz74YEyZMiXh2J133hmZmZklnKh8aNeuXdx5550Jx3788ce47LLLNqo98cQT8frrryc8vn379nHbbbelPGN59dZbbyWst2rVKmrWrJnveStWrIiVK1cmHGvSpElKsm1O48aNE9Znz569yfNWr16dsD5t2rSkM23K2rVr881Wv379hPXy/DxT/qxevTouuOCCaNu2bTz99NOxdOnSpHs2a9YsnnzyyXjxxRejWrVqKUiZ1yuvvBKHHnpoDB48ON/Xil122SXuuOOOYpkfNqey3iPPmzcvpk2bVuA/06dPjyVLlpTYvVZ2dnbCet26dUtk/oLMmV/GTSmOtTyiZNZzyj7XF8k64IADYuzYsdGrV69IS0srUo+FCxfGV199Fc8//3xce+21cfLJJ0fnzp3jyy+/THHajXkvsOzyvQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAjWWUdgAAAAAAAAAAAAAAAAA2b/XyiLdvjxg1MKLtfhEtOkZkbRFRtXrEysUR836NmPxlxIQPItauLu20lcv69eujf//+ceedd+YZ6969e1StWjXWrl1bCsnKv+J87jIzMxPW169fn1Tf4spclLy5ubkJ64sXL46XX345JbkKYsGCBZscz+9rqFq1anHEKbH+hfXdd99FixYt8tR32WWXkg+TAuXl+ivr8vv5yMgo3l8PTfTzkez6mEo5OTkJ68X9vBSU6z+11q5dG1deeWUMHDgwz9h2220XF198ccJ9WGWWmZkZL730UlSvXj3P2Jo1a6JXr16RnZ2dZ+xPf/pTdOvWLZo1a5Zn7C9/+UsMHTo0hg8fXiyZy5Off/45cnNzIy0tbaN6WlpaNGzYMFauXJnvubNnz46WLVvmqW+33XYpz5lIorkj/pNrUxJdLxER8+bNSzrT5sydOze23XbbPPW6devme055fZ5TpTzur8v7a+ekSZPizDPPjHPPPTf22Wef6Nq1a3Tu3DnatGkTLVu2jGrVqhW6Z69evSIrKyuOPPLIImXKz4MPPhgXXXTRhuf8mmuuif333z+6dOmS59iLL744hg0bFkOGDElphpJWlvbUEWX3fYeI4nuvpCgq2j1yRZDfGrmp1+TiUq9evYT1+fPnF7lncazlEcW3nlO+VLTrq7Telylr7+fm54/3ikV16KGHxuDBg6NKlSqbPXb58uUxadKkmDRpUvz8888b/e+iRYsSnpPffR6Jlfd7FgAAAAAAAAAAAAAAAICKZtddd41PP/00IiLuv//+uPrqq0s5EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOVZRmkHAAAAAAAAAAAAAAAAoODmTvnPH8qW999/P2G9WrVq0bRp05g+fXoJJ6oY6tatG/Pnzy+W3vXq1UtYX758eVJ9iytzUfJmZ2fne87555+filgpsWLFioT1unXrFuu8tWrVKtb+hTV+/Pg48sgj89T32muvUkiTvPJy/ZV1+f2M57cmpEqDBg3y1JYuXVqscxZGftdXca8bBeX6T71BgwbFyJEjY88998wzds0118TTTz8d8+bNK4VkZdPtt98e7du3TzjWr1+/GDduXMKxhQsXRp8+fWLYsGGRlpa20VhaWlo888wz0b59+1iwYEHKM5cna9eujYULF0bDhg3zjNWtW3eTe/9JkyZFy5Yt89R32mmnlGbMT37z/Pzzz5s8L7/veX77uFTKb46MjPw/KqG8Ps+pUh731xXltXPNmjUxbNiwGDZs2IZaWlpaNG/ePFq1ahWtWrWKQw89dMN/16hRY5P9jjjiiOjXr1/ceuutKcnXr1+/+Mc//rFRbd26ddGrV68YO3Zswu/h008/HR06dIjZs2enJENpKEt76ojk99Xl8b2Soqho98gVwcyZMxPWmzRpEunp6ZGTk1MiOTIyMmKLLbZIOJZfxsIoyFreunXrDf9dGus55VdFub7ye10oy/vNkrS571lBtGjRIl588cWoUqVKwvEFCxbEoEGDYvjw4fH111/H1KlTCz3HH+/72bSKcs8CAAAAAAAAAAAAAAAAUFGkp6dH7dq1IyIiMzOzlNMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQ3qWXdgAAAAAAAAAAAAAAAAAo7yZNmpTvWMOGDUswScVSr169Eu+9fPnyYumbrKLkXblyZeTm5uapN2jQIFWxUiI7OztycnLy1DMyMqJmzZrFNm/dunWLrXdRfPbZZwnrO++8czRt2rSE0ySvvFx/Zd3q1atj3bp1eeoZGRlRq1atYpu3fv36eWrLli0rtvkKK7/rq2rVqlGjRo1SSLQx13/xuOSSSxI+r3Xq1Imbb765FBKVTQcddFBcfPHFCcc+/PDDuPvuuzd5/vvvvx/33XdfwrEtt9wynnjiiaQzVgT57cEyMzM3ed6ECRMS1rt06ZJ0poLIb54ffvhhk+fNmDEjYX1zX28qVKtWLWF97dq1+Z5TXp/nVCmP++uK/NqZm5sb06dPjxEjRsS//vWvOO6446JDhw5Rq1at2HHHHePiiy+OH3/8Md/z//a3vyX9PKxfvz7OOuus+Mc//pFwfPLkyXHhhRcmHGvUqFE899xzSc1f2srSnjoi+X11eXyvpCgq2j1yRfDrr78mrNeoUSPatm1bYjk6dOiQ7x4kv4zJ+uNafsUVV5TKek7FVB6vr/z2m1WrVi2z+81NqVKlSkr7ZWVlJd3j1ltvTfi6vHz58rjwwgujWbNmce6558bAgQNj6tSpRZqjdu3aSaasXCryPQsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVHbppR0AAAAAAAAAAAAAAAAAyruVK1fG6tWrE441bNiwhNNUHE2aNCnx3vPnzy+WvskqSt7169fHvHnz8tRr1qwZ1atXT1m2VJgzZ07CenE9n9WrV4+mTZsWS++i+vjjj2PNmjV56mlpaXHCCSeUQqLklKfrr6ybOXNmwnpxXsOJes+ePbvY5iusnJycEl83CsP1Xzy+/vrrePnllxOO/elPf4p27dqVcKKyp2HDhvHMM89EWlpanrFFixZF7969C9TnyiuvjPHjxyccO/roo+Pss89OKmdFkJGRkbCek5OzyfNGjx6dsN6pU6eoXbt20rk2JSsrK3bdddeEY99+++0mz508eXLCeqNGjZKNtVn5zbFo0aJ8zymvz3Mqlbf9dWV87czNzY1JkybF/fffH+3atYsbb7wx4XG1a9eOP/3pT0nNddxxx8WTTz65yWOeeuqpGDhwYMKxAw44IC6//PKkMpS2srKnjkh+X10e3yspiop2j1wRTJo0KVatWpVwrGvXriWWI7+5Fi9eHNOmTSuxHL8ryfWcyqcsX1/5vTY0bty4WOZLxfu569evT1jPyspKqu8fbb311kmd36JFizjppJPy1FevXh0HHHBAPPjggwlfIwtriy22SLpHZVIZ71kAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoLJIL+0AAAAAAAAAAAAAAAAAkGq1atUq8Tlzc3MT1tPT/QpPUXXp0qVY+m611VbRpEmTPPW1a9fGv//976R6F0fmZPJOmzYtYX3nnXdOSbZUmTRpUsJ6cV0DO+ywQ6SlpRVL76JatWpVfPzxxwnHzj777BJOkxrl5for6yZMmJCw3q1bt2Kbc7fddstT++GHH4ptvqKYOnVqwnrnzp1LOElirv/icdVVV0V2dnaeepUqVeKee+4phURlyxNPPBFNmzZNOHbOOefEzJkzC9RnzZo1ccoppyR8riMi7r333thhhx2KnLMiaNSoUcL6ihUrNnlefq/1VatWjQMPPDDpXJty8MEHR9WqVfPU169fHyNHjtzkuWPHjk1Y32qrrVIRbZPyu6YXLFiQ7znl9XlOpfK4v67Mr525ublxww03RP/+/ROOH3zwwUn1f+uttwp03Nlnnx3Tp09POHbLLbcU2/VTEsrKnjoi+X11eXyvpCgq4j1yeZeTk5PvnmCvvfYqsRz5zTV69OgSy5Cf4l7PqdzK2vWV336zuN6XadOmTdL7zUWLFiWs16lTJ6m+f7Tjjjsmdf5hhx2W8P9X6t+/f3z11VdJ9f5denp6NG7cOCW9KpPKfM8CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABVZemkHAAAAAAAAAAAAAAAAgFRp0qRJPPDAAzFjxoxo1KhRic1bp06dqF69esKx5cuXl1iOiqZ79+7F0nf33XdPWJ8yZUrk5OQk1bs4MieT97vvvktY79atW9K5UmnixIkJ68V1DfTs2bNY+ibrmWeeSVhv3759HHbYYSWcJnnl5for677//vuE9R49ehTLfDvuuGM0bNhwo9rq1atjypQpxTJfUY0dOzZhvbjWjcJy/RePadOmxb333ptw7MADDyyXa2WqnH322XH00UcnHHvmmWdi4MCBher3ww8/xJVXXplwrGbNmvHiiy9GRkZGoXNWBI0bN47MzMyEY/Pnz9/kuTNnzsx333P66acnnW1TevfunbA+atSozd6zTJ48ORYsWJCnvvfee6ckW346duwYtWvXzlNfvXp1TJo0Kd/zyuvznErlcX/ttTPiuuuui3Xr1uWpd+3atUTmX7x4cZx22mkJ7zOrVq0aL7/8csKfyfKgLOypI1Kzry6P75UUVUW7R64Ihg8fnrB+wgknlMj6UK9evTjuuOMSjg0bNqzY5y+o0l7PqdjKyvWV335zjz32KJb59tlnn6R7LFq0KGF9u+22S7r3f0t2b5zffdbLL7+cVN//1rlz56hRo0bK+lUW7lkAAAAAAAAAAAAAAAAASk/Hjh3jlltuicGDB8cPP/wQn3766Yaxvn37xk8//RTvvPNOXH311dGpU6eUzt2yZcu46qqrYsiQIfHLL7/EihUrIicnJ9asWRMLFy6Mb7/9Np555pk4+eSTo1atWimZs2HDhnHeeefFq6++Gj/++GMsXbo01q9fH+vXr4+lS5fGjz/+GAMGDIhzzz034ecbFFXPnj3jnHPO2eQfv1cHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUROmlHQAAAAAAAAAAAAAAAACSVb9+/bjtttvil19+ib59+0a9evXiiiuuKLH5W7Zsme/YnDlzSixHRbPffvtFZmZmyvsedthhCeufffZZ0r2LI3MyeUeNGpWwvs8++yQTKeU+/fTThPVDDz20WOY78sgji6Vvsl577bVYsmRJwrG77747MjIySjhRcsrL9VfWDR8+PGH9iCOOiCpVqqR8vmOOOSZP7eOPP47169enfK5kfPXVVwnr+a2ZJc31X3xuvfXWmDt3bsKxu+++u1h+Lsq6HXbYIe69996EY7/vj4vi/vvvj/feey/hWOfOnePmm28uUt/y7qCDDkpYX7RoUSxatGiz57/66qsJ60ceeWRsu+22SWXLT8uWLfNdH1955ZXNnp+bmxvDhg3LU+/SpUs0adIk6Xz5OfzwwxPWx40bt9nXpfL4PKdSedxfe+2MWLBgQYwdOzZPPSsrq1jujRP55JNP4vbbb084tv3220f//v2LPUNxvJaXhT11RGr21eXxvZKiqmj3yBXB22+/nbBeu3btOPXUU4t9/t69e0eNGjUSjg0dOrTY5y+osrCeF0ZlvIcqz8rK9ZXf68MhhxxSLPMdffTRSfdYuHBhwnqnTp2S7v27jIyMfO8ZC2rLLbdMWP/xxx+T6vvf9ttvv5T1KquKY21zzwIAAAAAAAAAAAAAAABQsjIyMqJv374xefLkGDNmTPTr1y+OOOKIaNu2bdSsWXPDcdWrV48dd9wxDjvssPj73/8eo0ePjnHjxsWxxx6b1PytWrWKN954I6ZMmRL/+Mc/4tBDD43tttsuatasGWlpaVG1atWoX79+7LrrrtG7d+946aWXYtq0aXHZZZdFenp6keasX79+9O/fP3777bd4+OGH4/jjj482bdpEVlZWpKenR3p6emRlZUWbNm3ihBNOiEceeSRmzpwZDz74YNSrVy+przciol+/fvHoo49u8s/xxx+f9DwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABlTXppBwAAAAAAAAAAAAAAAIBkHHvssfHvf/87rrzyyqhZs+aG+sUXXxy77rpriWQ47rjjEtazs7Pj119/LZEMFVGjRo3i5JNPTmnPLbbYIk455ZSEY++++27S/VOdOdm8w4YNS1g/6qijolGjRkllS6Xhw4cnrLdp0yYOOOCAlM7VsmXLlPdMlVWrVsX999+fcKxNmzZx0003lXCi5JSX66+s+/jjj2PFihV56ltvvXUcf/zxKZ2ratWqcdFFF+Wpv/XWWymdJxXyWwN32mmn2H///Us4TV6u/+KzbNmyuP766xOOtWnTJs4///wSTlS6MjIy4sUXX9xoH/y79evXx6mnnhrLly8vcv8+ffrE/PnzE45dccUV0bNnzyL3Lg4tW7aMww8/vFjnOPHEExPWv/rqqwKd//zzz0dubm6eekZGRr7XdrJuuOGGqFKlSp76unXrYsCAAQXqMXDgwDy1tLS0uPTSS5POl0iNGjXy/Xl+4403Nnt+eX2eU6U87q/L42tn06ZNU97zt99+S1ivV69eyufKz7XXXhtff/11wrHTTz89Tj311JTMk2iPGxGRlZWVkv7/rSzsqSNSs68uj++VFFVFu0euCL7++uv46aefEo5dccUVCfekqZKVlRWXXXZZwrFvv/02vvvuuyL1LY61PKJsrOd/VJLrLv9Rka+v/PZubdu2Tfn7Mm3atIl99tkn6T4TJkxIWG/atGm0atUq6f4REf/zP/+T9N61fv36CevZ2dlJ9f1denp6nH322SnpVRaU5NpWHu9ZAAAAAAAAAAAAAAAAAMqzr7/+Oh544IHYfvvtC31uhw4d4rXXXou3334739/d25RevXrFuHHj4uijjy7UeQ0aNIg777wzPvjgg6hVq1ahzu3evXtMmDAhzj///MjMzCzwedWqVYsLLrggfvjhh+jatWuh5vyj1q1bJ3U+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAeZVe2gEAAAAAAAAAAAAAAAAgGT/99FNkZWXlqVetWjVeeOGFqF27drHOX7t27TjzzDMTjn322WeRk5NTrPNXdJdddllUqVIlZf0uvfTSqF69ep76ihUrYtiwYSmZI5WZk837yy+/xHfffZennpmZGWeffXZKMv6ubt260bRp0yKdO2fOnPj8888TjvXr1y+ZWHncfPPNkZaWltKeqfTPf/4zlixZknDsqquuihNPPLGEExVdebn+yro1a9bEK6+8knDs6quvjqpVq6ZsrnPOOSeaNWuWp/7qq6+mbI5UmTVrVowcOTLh2N/+9reUznXOOefELrvsUqhzXP/F67HHHosJEyYkHLvxxhujXr16JRuoFP3973+Pzp075zv25ZdfJtV/zpw5cdZZZyUcS09Pj+eff77MPN8vvPBCTJo0KV544YWoX79+sczRo0ePOPLIIxOOFXQvOXHixHjvvfcSjp1xxhmx9957FzlfIvvuu2+cfvrpCccGDBgQs2bNKlCfwYMHx/z58/PUL7roomjevHlSGRO55JJLEr4m5ebm5vu6+N/K6/OcKuVxf12eXjubN28eDz/8cEydOjWOPvroFCb7z9ebyKpVq1I6z6asX78+evXqFcuXL084/vDDD0fLli2TnmfRokUJ69tuu23Svf+oLOypV69enbJ9dXl8r6SoKtI9ckXx8MMPJ6y3bNky7r777mKb94EHHoitt9464Vj//v0L3a841/KIsrGe/1FJrruVXWW4vn777bf4+uuvE46ler/5j3/8IyV9Jk2aFAsWLEg4dsYZZyTdPyMjI2644Yak+yxbtixhvVGjRkn3jojo1atXbL/99inpVRaU5NpWnu5ZAAAAAAAAAAAAAAAAAMq7tm3bxq677rpRLTc3N7777rt47rnn4tlnn91QHzduXHzwwQcJfzf98MMPjy+++CIaN25c4LnPOOOMeOGFF6JmzZob1VesWBFvv/129O/fP26++eb4xz/+EY8//niMGjUqz2dO7rPPPjF48OACfyZHz54948MPP0z4u2W//vprDBkyJJ588sl48sknY8iQIfHrr7/mOa5Zs2bx0UcfRffu3Qv8tf63jIyM2GabbYp0LgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQHmXXtoBAAAAAAAAAAAAAAAAIBk//vhjvPLKKwnH2rZtG0OGDIkaNWoU2/z33ntvNG/ePOHYq6++WmzzVhbt27ePO++8MyW9evbsGVdccUXCseeeey6WLVuWknlSlTlVef/1r38lrF999dXRunXrIuf7o3vuuScmTpwYF110UaSnF/5X1x566KGE9X333Tf++te/JhsvIiIOOeSQOOWUU1LSq7gsXrw4rrzyyoRjaWlp8cILL8TJJ59cwqmKrrxcf2XdXXfdFbm5uXnq7du3j3vvvTclc3Ts2DHuuuuuhGNz585NyRyp9sgjjySs77///nHxxRenZI4uXbrEww8/HGPHjo3BgwfHbrvtVuBzXf/FJycnJy677LKEYw0aNIjrr7++hBOVjp49e8bll1+ecOzLL7+Mm2++OSXzvPXWW/HYY48lHGvevHm+YyWlXbt28cYbb8Qpp5wSVapUibp168YTTzyR8nnq1auX79e6fv36ePnllwvc65ZbbklYT0tLi5deeim23HLLImX8o6222ipeeumlhGM5OTlx++23F7jX2rVrE77mVK9ePV5//fWU3nPtu+++ccMNNyQcGzRoUPzyyy8F6lMen+dUKo/767L+2tm8efPo379/TJkyJc4777zIzMyM+++/Pxo0aJCybK1atcpTW7lyZcruVwtqypQp0bdv34RjWVlZ8fLLL0dGRkZSc8ycOTNhvXXr1tGkSZOkeidS2nvqZ599NmX76vL4XklRVbR75Irgsccei9mzZyccO++88+LUU09N+ZxnnXVW9OnTJ+HYtGnT4plnnilwr5JYyyPKznr+30p63a2MKtv19eCDDyas77fffnHppZemZI7jjz8+jjnmmJT0ioj4/PPPE9bPPvvsqFevXlK9+/XrF23atEmqR0TE/PnzE9a7d++edO+tttoq7rnnnqT7lCUlvbaV9XsWAAAAAAAAAAAAAAAAgIqgRo0aMXjw4A2P161bF/fcc0+0aNEiOnToEL1794777rtvw/jw4cPjgAMOiHr16sUBBxwQn3766Ub9dtxxxxgyZEiBPidh5513jsceeyzS0tI21BYuXBhnnXVWbLHFFnHkkUfGBRdcENddd13069cvzj777OjWrVtsu+228cILL2zUa9999y3Q71w2adIkXn/99ahevfpG9cGDB0fnzp1ju+22i8MPPzzOOuusOOuss+Lwww+P7bbbLjp37hxvv/32RufUrFkz3nzzzSL9fuv69eujWbNm0aRJk43+PPzww4XuBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUN6kl3YAAAAAAAAAAAAAAAAASFa/fv1i2bJlCcf22muv+OSTT6Jly5YpnTMtLS3uv//+OOussxKOL1y4MF588cWUzllZXXLJJXH22Wcn1WOnnXaKl19+OapUqZJnbN26dXHvvfcm1f+Pks2cyrxPPPFEzJs3L0+9Zs2a8cILL0StWrWKnPN3f/rTn+LMM8+MOnXqxH333RdjxoyJ7t27F6rHq6++GtOmTUs4dtttt8WRRx6ZVMa2bduWm5/JRx99NEaMGJFwLCMjI1566aW45557onr16sWWYd99943GjRsn3ae8XH9l3Y8//hgDBgxIOPbnP/85LrnkkqT6t27dOl5//fWE11R2dnZSvYvTSy+9FD///HPCsTvvvDMOO+ywpPo3bdo0Xn311UhP/8+v4x5xxBHx1VdfxfDhwwv08+H6L15Dhw6N999/P+HYBRdcEK1bty7hRCWrXr168fzzz2+4Pv/b8uXL49RTT43169enbL6//OUvMWnSpIRjJ5xwQvTu3TtlcxVWvXr14uijj96oduyxx6Z0f1erVq0YMmRI7LTTTgnHX3zxxZg1a1aB+3322WcxcODAhGPNmjWLESNGxFZbbVWkrL/beuutY8SIEdGkSZOE40899VSMHz++UD3vu+++mDt3bp56ly5dYsCAAVGjRo0iZf1jr9deey2qVq2aZ2z9+vVx3XXXFbhXeX2eU6U87q/L+mvnI488Eueff35kZmZuqG2zzTbx6quvpuT632233aJVq1Z56jNmzEi6d1E888wz+e5Bu3btGn//+9+T6j9z5sx8v7Y///nPSfVOpLT31LfddltS/f+oPL5XUlQV6R65IsjOzo5+/frlO/7cc8/FpZdemrL5+vXrF48//ni+41dccUWsXbu2wP2Key2PKHvr+e9Ket2tjCrb9fXyyy/HzJkzE47dfvvtSe83O3fuHE899VRSPf4ov71A48aN45577ily36OPPjquv/76Ip//3/K79z733HOT6luzZs0YOHBgNGrUKKk+ZU1Jr21l/Z4FAAAAAAAAAAAAAAAAoCL461//uuGzI5ctWxb77bdfXHrppfl+jsZ/++CDD2LvvfeOCy64IHJzczfUO3fuXKDPLXnsscc2+tyTiRMnRtu2bePJJ5/c5OdxzZgxI0477bS44447Nqr369dvs7971r9//6hfv/6Gx7m5uXHeeefFUUcdFWPGjMn3vDFjxsSRRx4ZF1xwwUb1Ro0aFenzAnJzc2Pu3Ll5/qxYsaLQvQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMqb9NIOAAAAAAAAAAAAAAAAAMn69ddf47zzzst3vEuXLjF27Nj461//GjVq1Eh6vo4dO8aIESPiwgsvzPeY66+/PpYvX570XPzHY489Fv/85z+jSpUqhT738MMPjy+//DKaNm2acPzBBx+MiRMnJhsxj6JmTnXelStXxvXXX59wrGvXrvHJJ59E48aNC5Xxv1100UXx6KOPblTbZZddYuTIkXHwwQcXuM/atWvj0ksvTTiWkZERb7zxRlx++eVFyrj//vvHp59+GvXr199QmzlzZpF6lZSTTjoppk2blu/4X/7yl5g4cWL06dMnqlatmpI5q1atGkcccUSMHDkyPvzww2jQoEHSPcvL9VceXHzxxbFkyZKEY//85z/jkUceiczMzEL3PfDAA2PUqFGx7bbbJhy/8cYbC92zpKxfvz7++te/JhyrWrVqvPXWW3HxxRcXqXebNm3ik08+iRYtWuQZa9q0acybN2+zPVz/xe/SSy+NnJycPPWqVavGXXfdVQqJSs6jjz4azZs3Tzh24YUXxi+//JLS+VatWhWnnHJKrF27NuH4gw8+GNttt11K5yyokSNHxvDhw/PUL7744nj77bdjq622Sqp/9+7dY9y4cdG9e/eE4ytWrIhrr7220H0vvvjiWLhwYcKxHXfcMb799ts46qijCt03IuKYY46JMWPGROvWrROOz5o1K6688spC912+fHm+90BHHHFEfPXVV9GqVatC9/3deeedFyNHjox69eolHL/lllvixx9/LFTP8vg8p0p53F+X9dfOa6+9NnJzc/PU99tvv/jggw9i6623LnK2evXqxRNPPJFwbOjQoUXum6xzzjkn3/uSK664Ivbff/+k+n/00UcJ61dddVXsvffeSfVOpDT31Kl+bY4on++VFFVFuUeuKJ566qmE+6+IiLS0tLj77rvjtddeizZt2hR5jnbt2sXgwYPjlltuyfeYt956K1555ZVC9S3OtTyi7K7nvyvpdbeyqWzX15o1a/J9XybZ/ebRRx8dH330UdSuXTuZiHm8/PLL8dtvvyUcO+OMM+LWW28tdM+zzz47Bg4cGOnp//dxbpMmTSpyxvfeey9h/cADD4yzzjqrSD2bNWsWn332Wey+++4bamPGjClSr7KoJNe2sn7PAgAAAAAAAAAAAAAAAFARnH322Rv++8ILL4xPP/200D369+8ff/7znzeqXXrppdGoUaN8z+nVq9dGnzGzcOHCOOigg2LOnDkFnvdvf/tbjB07NhYtWhT9+/ePQw45JFasWJHv8QcccEAcd9xxG9X69euX53fNNqV///5x3XXXbVQ7/fTT8/28HAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPJKL+0AAAAAAAAAAAAAAAAAkAovvvhiPProo/mOZ2VlxV133RVTp06Ne+65J/bee++oUqVKgfs3aNAgevfuHUOGDInRo0dHz5498z32gw8+iIceeqhQ+clrzJgxGz2+5JJLYsKECXH88cdHWlraZs9v3759vPXWW/H2229HnTp1Eh7z66+/xnXXXZeSvBHJZS7OvA8//HB8/PHHCcc6deoU33//ffz5z3+OjIyMAvds3759DB06NO67775IT8/7q2pff/11DB8+vFA5Bw0aFG+//XbCsfT09LjjjjtizJgxcfDBBxeoX5s2beLZZ5+N4cOHR4MGDTbUs7Oz45prrilUtpI2b968OOKII2LBggX5HrPNNtvE008/HdOnT4+HHnooDjrooKhbt26B56hatWq0a9cuTj311Hj55Zdj/vz5MXjw4Nhjjz1S8SVsUF6uv7Juzpw5cd555+U7fu6558akSZPitNNOK9Bz2a5du3j99ddj2LBhUa9evYTHfPbZZ3HnnXcWNXKJGDx4cDz99NMJx6pUqRL33ntvfPPNN3HQQQcVqF/t2rXjmmuuidGjR0fr1q3zjOfm5sZf/vKXyM3NLVA/13/x+u677+Kpp55KOHbUUUfFvvvuW8KJSkbv3r3jxBNPTDg2cODAfH8mkjV69Oh89yFZWVnx4osvFmp/nUpnn312wvrhhx8eEydOjIceeih22WWXQvXs2bNnDBo0KD777LPYfvvt8z3usssui6lTpxaqd0TEb7/9FmeccUa+60mjRo3izTffjI8//jhOOOGEqFWr1ib71a5dO0444YT45JNP4vXXX48tttgi4XHr16+P0047bZN7jE0ZMGBAPPPMMwnH2rdvHz/88EM8+uijsd122xWoX1paWhx99NHxzTffxMMPPxyZmZkJj/v888/jpptuKnTe8vo8p0p53F+X5dfOb7/9Nh5++OGEY927d48JEybEtddem+91kZ+DDz44Ro0aFTvvvHPC8VdffbVQ/VJpyZIlceqpp0ZOTk6esbS0tHjuuecK/fX+t0ceeSRhPTMzM95///247bbbYtttty1y/z+qCHvq8vheSSpUpHvkiuKUU07Z5B7o2GOPje+//z5eeOGFOP7446N+/fqb7dmwYcM48cQT4+WXX47x48fHEUccke+xkydPjj59+hQ6d3Gt5RFlez3/XUmvu5VNZby+XnnllRgyZEjCsaLsN3fZZZcYOHBgvPHGG1G7du0N9YULF8Yvv/ySdN5169bFPffck+/43/72t3jnnXcSvif0R506dYqhQ4fGY489ttG+4euvv4433nijyBk//fTTmD9/fsKxxx57LK699toC74UzMzPjoosuinHjxkXHjh031BcvXlzmXuuTUdJrW1m+ZwEAAAAAAAAAAAAAAAAo77beeuvYZpttIuI/v2f+3HPPFbnXI488El9++WVE/Of3tP70pz/FwoUL8z3+j59hc9NNN8W0adMKNWdOTk4cccQR0bRp07jgggvi66+/3uTxf/wMhHHjxsXtt99eqDkjIm655Zb4/vvvN6qde+65he4DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQWaXl5ubmFujAtLTizgKUUx06dIgOHTpERERubm788ssv8eWXX0YBlxcAAAAAAAAAAIro4kER1WqVdgoqshnfR7x4WWmnACA/aWlp0aVLl9hhhx02/H3v8ePHx/jx40s5WeXk79RC2fLoo4/GOeecU6Bj16xZExMnTowff/wxFi5cGMuXL48VK1ZERkZGZGVlRVZWVjRr1ix23nnn2GqrrQrU87vvvou99947Fi9eXKjc+a0ZxfF7PU899VScccYZeep9+vSJZ599tsB9UpU5vz677LJLjBo1KqpVq5ZnbP78+fHuu+/G6NGjY/bs2bFo0aLIysqKJk2aROvWreOQQw6JHXfccZPzrlq1Krp37x7jxo0rVN5UZm7VqlWJ5I2IaNy4cXz99dexzTbb5HvMnDlzYujQofH+++/H9OnTY+7cubFy5crIzMyMrKys2GabbaJDhw5x2GGHxe67755vn1mzZsXuu+8e06ZNK3TOunXrxjfffBOtWrXa5HGzZ8+OoUOHxvjx42POnDmxaNGiqFatWjRo0CB23nnn2HfffaNjx44Jzz333HPjp59+io8//jjPWLdu3WLUqFGFzl1c2rZtG++//35sueWWBTo+Nzc3pk6dGlOnTo1Zs2bFihUrIjs7O6pUqRK1a9feaG1r1apVZGRkFCrP8OHD47jjjovly5cX6rzycP39+9//jhYtWuSpn3TSSTFgwIBC9SpOf//73+Pqq6/e5DFLliyJ9957L0aNGhWzZ8+OBQsWRK1atTaskYceeuhm15xffvkldtttt1iwYEGh8pXk69nvqlWrFh9++GHssccemzxu3rx5MWzYsPj2229j7ty5G762unXrxnbbbRe77bZbHHTQQVGjRo18e9x6662bff7/qDxc/6lU0j9LTZs2jcmTJ0etWnnfMB83blx07NixWO7NjjvuuBg0aFCe+uzZswu8ZhdFy5YtY+zYsZGVlZVnbObMmdG+fftYtGhRsc2flpYWH330Uey9994Jx2+88ca44YYbim3+TVmzZk1UrVp1k8fMnj07vvjii/j5559j+vTpsWLFili5cmVUr1496tevH1tssUXsuuuu0b1792jQoMFm5+zfv39ccMEFSeW++OKL4957793scWvXro0ffvghfv7551i8eHGsWbMmqlWrFvXq1YtWrVpFu3btNvv1R0ScffbZ8fjjjyeVOTMzM95///3Ya6+9Nnncjz/+GB9++GFMnDgx5s+fH4sWLYrMzMxo2LBhNG7cOHbffffYZ599ol69epvsM2HChOjRo0dS13Z5fJ5TpTzur8vya2dmZmaMHDkyunTpku8xa9eujc8//zw++uij+PHHH+PXX3+NZcuWxcqVK6N27dpRr1692H777aNjx45x2GGHRevWrfPtNXjw4DjqqKMKlK0492Gb2oO+8847ccQRRxS596effho9evTY5DEzZ86MadOmxbJlyyInJyfP+Jw5cxK+z5Gfsr6njiif75WUhIpwj1xe7j0Lom3btjFixIho3LjxZo/NycmJn376KebMmRPz5s2LhQsXRkREw4YNY4sttoimTZtGmzZtCrRm/fbbb7HPPvvEzz//XKTcya7laWlpUatWrWJbz4tbSa67lfE978p4fdWrVy+++eab2H777Td5XH77zYYNG0b79u3jwAMPjHbt2iU896STTopLLrkkz76uKHvNKlWqxEcffbTJn4OcnJz48ssv47333otp06bFvHnzIi0tLRo0aLAh6y677JLnvNWrV0eXLl3i1FNPjauuumqjseXLlye8l0/kL3/5S9xzzz35jv/222/x3HPPxSeffBITJ06MxYsXR3Z2dtStWzcaN24crVq1ioMPPjgOP/zwPK+Zubm5ccwxx8Ts2bPjq6++ytO7Z8+e8cknnxQo5+/9Einpz6wr6T1lWb5n+V1Z+d4AAJSEtLS06Nq1a7Ru3drfpwUKLJm/R+DeCsiP3ysBAAAAAAAAAIDk7b777vHFF19ERMSIESNiv/32S3hcp06dYvTo0RERcdddd8Xll1+e8LgOHTpE7dq14/PPP9/kvFtvvXVMnTp1w98TnDdvXmy11Vaxdu3aon4pm9WoUaOYOXPmRp9lcsQRR8Q777xTpH5HHXVUvPnmmxser1y5MrbccstYunRpUjnvvPPOuOyy//uw+k093wClwWe1ly3+Ti0AAAAAAAAAAABAyfJZ7UBR+Kx2oDj4vRIAAAAASK1DDzs0389ig+Iy5J0hMWLEiNKOAVAivNZSWl4b9NqGz98FqOgO7BvR8YjSTkFlM+yBiLFF+6h3gHLLZ7WXLf5OLQAAAAAAAAAAAEDJ8lntQFEU5O94Z5RADgAAAAAAAAAAAAAAACgx5557bsyfPz+uuuqqSE9P3+SxmZmZ0b59+2jfvn1K5v7ss8/i6KOPjsWLF6ekX2U3fvz4OP300+OVV17Z8MuVv9tiiy3itNNOi9NOO61IvVetWhXHHXdcjBs3LhVRNyiuzKnIO3fu3DjggAPiww8/jObNmyc8pkmTJnHGGWfEGWecUeR55syZEwcffHBMmzatSOcvWbIkDjnkkPjggw9i2223zfe4pk2bxplnnlno/vfff3889thjsffeexcpX0mbMGFCdO7cOV566aXo2bPnZo9PS0uLFi1aRIsWLVKaY+HChXH11VfHI488UqTzy8v1Vx5cc801kZaWFv369cv3mLp168aJJ54YJ554YpHmmDBhQhxyyCGxYMGCosYsUatXr47DDjss3nnnndhzzz3zPa5Ro0Zx6qmnxqmnnlqkeR5//PG45pprCn2e6794zZ49O2677ba4+eab84ztsssu8b//+7/xxBNPlEKy1KtSpUq88MILkZWVlWcsNzc3evfuHYsWLSrWDLm5uXHaaafFd999F3Xr1s0zfs0118SwYcPi888/L9YciRxxxBExaNCgqF27dr7HNG3aNI499tiUzPfQQw9F3759k+5z3333RXp6etx999159o//rWrVqrHrrrvGrrvuWqR51q9fHxdeeGE8/vjjRUz6f9asWROHHHJIvPPOO7HPPvvke9xOO+0UO+20U1JzffXVV3H00UcnfW2Xx+c5Vcrj/rosv3auWbMmDj300HjvvfeiU6dOCY+pWrVq9OzZs0D7902ZP39+nH/++Un1SJXrr78+DjjggOjWrVuescMPPzwuvPDCeOCBB4rUu3fv3jFu3LiEr2+/22qrrWKrrbbKd/zXX38t1JzleU9dHt8rSaWKco9cUUyYMCF69uwZQ4cO3exznJ6eHm3bto22bdsmNefkyZPjkEMOiSlTphS5R0mu5RFlaz2PKJ11tzKpjNfX4sWL45BDDon333+/WPabN954YwwYMCAuueSSZGJusH79+jjppJNi7Nix0ahRo4THpKenxx577BF77LFHgfvm5ubGeeedF99//33SGfv37x+9e/eOjh07Jhxv1qxZXHnllXHllVcWuveVV14Zb731Vuy2227JxixTSnptK8v3LAAAAAAAAAAAAAAAAADlWdWqVTf8d3Z2dtL9xo8fX6DjjjjiiI1+h//NN9+MtWvXJj3/phx00EEbfb0LFiyId999t8j9hgwZEgsXLowGDRpERETNmjVj3333jTfffDPprAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABVdemkHAAAAAAAAAAAAAAAAgFS7+uqrY++9944pU6aUyHwrV66Mq666Kvbdd99YuHBhicxZWbz66qtx8sknR3Z2dsp6zpkzJw466KB49913U9bzv6U6cyrz/vzzz9G9e/cYNWpUCpLlNWbMmOjSpUt89913SfWZMmVK7LnnnjFmzJgUJfuP2267LS6++OKU9iwJs2bNiv322y8uvfTSWLJkSYnOvXz58rj77rtj++23j0ceeSSpXuXl+isPrr766vjTn/4UK1asSHnvd955J/bcc8+YPn16ynsXpyVLlsQBBxwQTz75ZMp75+TkxK233hpnn3125ObmFqmH67943X333TFz5syEY7fcckvUrl27hBMVj+uuuy523333hGP//Oc/48MPPyyRHNOnT4/zzjsv4ViVKlXi+eefj6ysrBLJ8t+GDRsW3bt3j2+++aZY51m5cmWcc8450bdv35T1vOeee+LYY4+NBQsWpKznf5s7d24ceeSR8fDDD6es58qVK+PAAw+MBx54IGU9/1tubm489thjsffee8ecOXNS0rM8Ps+pUh7312X5tXP+/Pmxzz77xBtvvJH6YP/fjBkzokePHvm+vpW09evXxymnnBLLli1LOH7nnXdGhw4ditT73//+dxx33HElfq9TnvfU5fG9klSqKPfIFcVPP/0UHTt2LNY18XcDBgyITp06peQ935JYyyPK3noeUXrrbmVSGa+vyZMnp3y/mZubG3/729/ihhtuSFnP3/3222+x1157pez/Q8rJyYm+ffvG008/nZJ+a9asiUMPPTT+/e9/p6RfRMTatWvj3HPPjTvvvDNlPcuS0ljbyvI9CwAAAAAAAAAAAAAAAEB5tWjRog3/3bhx4xKbt1OnThs9Hjx4cLHP2bVr140ev/3227F+/foi91u3bl28/fbbG9W6dOlS5H4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACVSXppBwAAAAAAAAAAAAAAAIDiMHLkyNh5552jb9++8euvvxbLHOvXr49BgwbFTjvtFLfffnusW7euWOap7AYMGBC77757jB07Nuler776arRr1y4+++yz5INtQqoyF0feGTNmRI8ePeLqq6+OlStXpqTnypUr48orr4zddtstZsyYkZKeM2fOjG7dusVNN90Uq1evTqrX/Pnz4+ijj46//e1vKclWGnJycuKee+6JVq1axR133BGLFi0q1vl++umnuPzyy6N58+Zx2WWXxeLFi1PSt7xcf+XBE088Ee3bt4933303Jf1mzZoVp59+ehxxxBEp+36XtOzs7DjrrLPiqKOOil9++SUlPadMmRIHHnhgXH311Un3cv0Xn1WrVkW/fv0SjjVp0iTfsfJkjz32yPc6HDduXIm/xr388svxwgsvJBzbbrvt4qGHHirRPL/7/vvvY7fddosLLrggpk+fntLeubm5MWjQoGjbtm3861//SmnviIg333wz2rZtG88991zk5OSkpOf69evj6aefjrZt28bQoUNT0vO/rVu3Li666KLYZ5994ocffkhZ3/Hjx0fPnj3j3HPPjTVr1qSsb0T5fJ5TpTzur8vya+eyZcvi2GOPjRNOOCGmTZuWkmwR/1lrnn/++ejatWtMnDgxZX1T4Zdffom+ffsmHKtWrVq88sorUaNGjSL1fv/992O33XaLTz/9NJmIhVae99Tl8b2SVKoo98gVxeLFi+PYY4+Nww8/PCZMmJDy/t99910cfPDBcdJJJ8WyZctS1re41vKIsr2eR5TeuluZVMbrK5X7zenTp8chhxwSt912W4rS5TVx4sTYbbfdkt7Dz5s3Lw455JDo379/ipL9x5w5c6Jbt27xzjvvJN1r/Pjxsdtuu8Vjjz2WgmRlV2msbWX5ngUAAAAAAAAAAAAAAACgPJo5c2bk5uZGRMQuu+wSDRo0KJF5d911140ejxs3rtjn7NKly0aPv/nmm6R7jh49epNzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkFh6aQcAAAAAAAAAAAAAAACA4pKdnR0PPfRQtGrVKo477rh49tlnY968eUn3/eGHH+Kyyy6LrbbaKo4//viYNm1aCtKyKePGjYsuXbpEnz594scffyzUudnZ2fHqq69Gp06d4sQTT4wFCxYUU8qNFTVzSeRdu3Zt3HrrrbHddtvFLbfcEjNmzChSn+nTp8d1110XW2+9ddxxxx2xfv36lOZct25dXH/99dGiRYu4++67C/3zO3fu3LjpppuiZcuW8dZbb6U0W2mZP39+XHnllbHVVlvF6aefHq+99lqsWLEi6b45OTnx9ddfxy233BJdunSJnXbaKe66665YsmRJClJvrLxcf+XBv//97zj00EOja9euMWDAgFi5cmWhe4wdOzbOPffcaNGiRTz//PPFkLLkDR48OHbcccc49dRTY+TIkZGbm1voHuPGjYtzzz03dtxxx/jwww9Tls31X3yeffbZ+PbbbxOOXXLJJbHNNtuUcKLUycrKihdeeCGqVKmSZyw7Ozt69eoVa9euLfFc559/fkydOjXh2Omnnx4nnXRSCSf6j9zc3Ojfv39st912ceKJJ8Y777xTpPXxd3Pnzo37778/dt555zj++OPz/ZpTYe7cudG7d+9o27ZtPPDAAzF//vwi9Zk3b17cf//90bZt2zjzzDOLff/78ccfx8477xxHH310DB06tEjX45o1a2LIkCFxyCGHxC677BKffvppMST9j/L6PKdCedxfl/XXzoEDB8Z2220XJ5xwQrz//vuxevXqIvVZtGhRPPnkk9GtW7c4/fTTY/bs2SnJl2rPPvtsvPzyywnH2rRpE/fdd1+Re0+aNCn23nvv6NatWzz66KMxfvz4yMnJKXK/girPe+ry+F5JqlWEe+SKZMiQIdGuXbs49NBDY8CAAbF8+fIi91q2bFm8/PLLcdBBB0WHDh1i2LBhKUy6sVSt5RHlZz2PKL11t7KpbNdXsvvNWbNmxeWXXx477bRTsf7c/27hwoVx2GGHxX777RdffPFFoc5dvHhx3HnnndGqVasYPnx4seSbN29eHHHEEXHCCSfEZ599Vujzx4wZEyeffHLsuuuuMXbs2NQHLINKY20r6/csAAAAAAAAAAAAAAAAAOXJokWL4ocffoiIiIyMjLjppptKZN6ddtppw3+vXLky4WfM1KxZM3r06BFnnHFGXHTRRfGXv/wlzjrrrDjggANiiy22KPScrVu33ujx999/X/jgf/Ddd99tcg4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASS8vNzc0t0IFpacWdBSinOnToEB06dIiIiNzc3Pjll1/iyy+/jAIuLwAAAAAAAAAAFNHFgyKq1SrtFFRkM76PePGy0k4BQH7S0tKiS5cuscMOO2z4+97jx4+P8ePHl3KyysnfqYXyJS0tLXbddddo165dtG3bNtq0aRNbbLFFZGVlRe3ataNWrVqRk5MTS5cujSVLlsSSJUti4cKFMW7cuBgzZkyMGTMmFixYUNpfRoWS33q5qd9p2nnnneOwww6LXXfdNXbYYYeoU6dO1K5dO7Kzs2PJkiUxe/bsGD9+fIwaNSrefffdWLFiRZnMnJGRUSJ5C6JLly7Ro0eP6Ny5c2y77bbRuHHjqFWrVmRkZMSaNWti6dKlsXjx4pg4cWL88MMP8cEHH5T43iM9PT323nvv6NGjR+yyyy7RokWLqFu3btSuXTtWrlwZS5cujenTp8fYsWPjk08+iREjRkROTk6JZiwNGRkZsfPOO0fXrl1jp512iq233jq23nrrqF27dtSsWTOqV68eERGrVq2K7OzsWLZsWcycOTNmzpwZP//8c4wdOzbGjRsXS5cuLbWvoTxcf+VB9erV48ADD4zddtstOnToEFtttdWGn5HVq1dveE374YcfYty4cTFs2LCYOnVqaccudk2bNo199tkndt9992jVqtWGn48aNWpETk5OLFmyJBYvXhw//fRTjBkzJj788MP48ccfSyyf6x+KX7Vq1aJHjx7RoUOH2GmnnaJ169Yb1sfatWtHRER2dnYsX748Zs2aFb/++muMHTs2vvzyy/j2229LLXeVKlWic+fOsffee0e7du1i++23j4YNG0bt2rUjMzMz1qxZE8uXL48FCxbElClT4vvvv49PPvkkxowZE+vXry+13PXq1Yu99tor9thjj2jdunW0aNEi6tSpE7Vq/ef/2Fq2bFksW7YsZsyYEd99912MGTMm3n///Vi+fHmp5C2vz3MqlNf9dVl+7axZs2b07NkzOnToEG3atIntt99+o/cbfr/+ly5dGlOmTNnwnu7IkSNj3bp1JZKxPKlVq1ZsueWWUa9evahfv35UrVo14XGrVq2KESNGpGTOsrKnLo/vlZQVFeEeuaKoVq1adOnSJXbfffdo27ZtbLvtttG0adOoUaNG1KhRIyIiVq5cGatWrYrZs2fH1KlT44cffoivvvoqvvnmm1izZk2p5N7cWp6bmxvLly+vkOt5aay7lU1lu742td9ctWpVLF26NP7973/Hd999F8OGDYvPP/8839fAL774InbfffeNat26dYtRo0alLO/WW28dBx98cOyzzz7RrFmzaNSoUTRo0CDWrVsXixcvjrlz58a3334bI0eOjKFDh5b4OrXjjjtGjx49onv37tGqVauNflaXLVsWixcvjh9//DG+/fbbeOedd2Ly5Mklmq+sKo21rSzfswAAVERpaWnRtWvXaN26tb9PCxRYMn/H22e1A/nxeyUAAAAAAAAAAJAaf/3rX+Ouu+7a8Pjvf/973HDDDRt9zkenTp1i9OjRERFx1113xeWXX17k+apUqbLR73BOmTIlWrVqteHxAQccEH/5y1/iwAMPjMzMzIQ9cnNzY9SoUfHwww/HCy+8UKDfCc3Ozo5q1apteLzDDjvEzz//XOSvI+I/v4v4008/bXg8f/78aNSoUVI977zzzrjssv/7sPpkn2+AVPNZ7WWLv1MLAAAAAAAAAAAAULJ8VjtQFD6rHSgOfq8EAAAAAFLr0MMOjf3226+0Y1DJDHlnSIwYMaK0YwCUCK+1lJbXBr0WX3zxRWnHACgRB/aN6HhEaaegshn2QMTYd0o7BUDJ8lntZYu/UwsAAAAAAAAAAABQsnxWO1AUBfk73hklkAMAAAAAAAAAAAAAAADKjNzc3Pj222/j22+/Le0oJOH777+P77//vrRjFEpZz/zNN9/EN998U9oxNiknJyc++uij+Oijj0o7Spmybt26GDt2bIwdO7a0oxRZebj+yoPs7OwYPHhwDB48uLSjlCmzZ8+Ol19+OV5++eXSjpKQ6x+K3+rVq+ODDz6IDz74oLSjFMr69etj1KhRMWrUqNKOUiiLFy8uV69H5fV5ToXyur8uy6+dK1eujKFDh8bQoUNLO0qFsGLFipg8eXKJzlme99Rl/X2HklIR7pEritWrV8fIkSNj5MiRpR2lUCrzWl4a625lU9mur/K235w+fXo8/vjj8fjjj5d2lIQmTpwYEydOjCeeeKK0o5QrpbG2leV7FgAAAAAAAAAAAAAAAICy7pFHHokLLrggtttuu4iIuOaaa+KEE06I/v37xzvvvBNTpkxJ6Xx16tTZ6PHy5csjIqJBgwbx9NNPx5FHHrnZHmlpadGtW7fo1q1bXHbZZdGnT58YM2ZMvsdnZmZGtWrVEs6bjGXLlm30uG7dukn3BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqAzSSzsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQea1YsSKOO+64jWo77rhj3HfffTF58uRYsGBBPPXUUxvGttxyy2jatGmR56tbt26e+Zs2bRpfffVVHHnkkYXut/POO8dnn30WRx11VL7H1KlTJ09t+fLlhZ7rj5YtW7bR46pVq0b16tWT7gsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFDRpZd2AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoHIbO3ZsjB8/PuFYgwYNokOHDhsen3rqqTFr1qxYsmRJjBgxIm677bbYY489CjxXZmbmRo9zcnLijTfeiFatWkVExLp16+K5556LY489NrbeeuuoXr16pKenxxZbbBHdu3eP6667LmbNmrVRjxo1asSAAQPyzZGenp6ntn79+gJnzk+iHonmAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGPppR0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABg1113jT59+sTnn39eoOPr1KkT++yzT1x55ZUxcuTImDJlSpx22mmFnnePPfaIbt26RUTE6NGjo02bNtG7d+944403YsaMGbF69erIzc2NBQsWxJdffhk333xztGjRIu66666N+lSrVi2ef/75qFmzZqEzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAULLSSzsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAbm5uPPvss7HnnntG8+bN4/jjj48777wz3nvvvZg9e/Zmz2/ZsmU899xzMWzYsKhTp06B501PT4+IiM8//zz23HPPmDJlymbPWbNmTVx++eVx4YUXblTfbrvt4vzzzy/w3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJSOjNIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8N9mzpwZgwYNikGDBkVERKdOnWL06NERETFixIgYPXp0dOjQIbp16xZ169bd6NwDDzwwPvjgg9hzzz1jzZo1BZpv2bJlceyxx8bq1asLlfPBBx+MPfbYI3r16rWh1rdv37j77rs3e25aWlqh5iquHgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQOVQq1atqFevXlSpUiXh+LRp00o4EQAAUFa4XwCoXKz7AAAAAPB/Mko7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEGNHj06Lr/88oiIyMjIiEMOOSSuu+666Nq164ZjunTpErfeemtcdtllBer5wAMPxNy5c4uUp1+/fnHyySdHWlpaRES0aNEidt555/j+++83HLN69eo852VmZsaKFSuKNOfvqlevnqeWaC4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACjLevfuHWeeeWbCsYsvvjjGjx9fwonKv+233z4OP/zw6NmzZ3Tr1i0aN24cVatW3eQ5v/+bbBXBiBEjEtb33XffUukDFZmfEwAofyr7/QJQvNwjlD3WfQAAAADYtIzSDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAU69ati7fffjuGDBkSDz30UJx33nkbxi644IK44447Yu7cuZvt8+qrrxY5w6+//hqjR4+OLl26bKh17tw5vv/++w2Ply5dGrm5uZGWlrahlpWVFYsWLSryvL/3+G8rVqyI9evXJ9UTAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABKWosWLWKfffZJOFavXr0SzVLetW3bNq677ro44YQTIj09vbTjlJr8rqfS6gMVmZ8TACg/3C8AJcE9Qtlh3aciyczMTFhfs2ZNCScBCsvPLwAAUB5klHYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAZOTk5MQFF1wQXbt2jc6dO0dERPXq1eO4446LRx55ZKNjV69enefc8ePHJzX/mDFjokuXLhseN2/efKPx3NzcWL58eWRlZW2o1a1bN6k5E/VYvHhx0j0BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoDy56KKLol69ehvVfv7553jppZdKPMuf//zn2GKLLfLU77jjjsjOzt7kuf/7v/+b598/iohYu3Zt/OMf/0hZxqI47LDDNvp3mn43Y8aMePLJJzd5bqLvT0TEwIEDY8KECYXOkl+/osjJyYlVq1bFqlWrYv78+TFt2rSYOnVqzJo1KyX9CyPVz1MyLrnkko3+za2IiIkTJ8Yrr7xSojkompNOOimeeeaZqFatWmlHAajQKuqeJCJ1X9v69etj9erVsWzZspg7d27MnDkzJk6cGEuWLEk+ZALJ7Kcq2168pEyYMCEGDhxYavMXVXHuhyvqtUb54X4BoHKx7lOR7LDDDjFx4sSEYzvuuGNMmjSphBMBBeXnFwAAKC8ySjsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAsnJycuLee++N5557bkOtZ8+e8cgjj2x03KJFi/I8zsnJSWruefPmbfS4Tp06eY6ZP39+ZGVlbXjcunXr+O6775Kat3Xr1hs9XrBgQVL9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKC8ueSSS6JFixYb1XJycmLmzJnxySeflGiWCy+8MNq0aZOn/uCDD0Z2dvYmz23WrFnceOONCcc++eSTGDlyZEoyFsUDDzwQLVu2zFO/5pprNntuou9PRMRPP/0UEyZMKHSW/Pql0ty5c+Prr7+ODz/8MN5444345ZdfinW+iNQ/T0XVqVOn+Oc//5mnvmzZsnj77bdjxYoVJZaFwjv33HPj4YcfjrS0tNKOAlDhVdQ9SUTxf23Tp0+PkSNHxrvvvhuDBw+OhQsXpqRvMvupyrYXLykDBw6MgQMHltr8RVHc++GKeq1RPrhfAKhcrPsAAAAAUDjppR0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgFT7//PONHjdv3jzPMUuXLo3169dveJyTk5P0vAXpMXbs2I0ed+jQIel5/9jjj3MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQGWUnp4ezz33XNStW7e0oxTY008/ne+/h9SnT58STvN/9txzz2jZsmWeek5OTjzzzDOlkKj4NW7cOA4//PC4++67Y8qUKTF69Ojo06dPZGZmlna0YnfuuecmrGdlZUWvXr1KOA2F0b59+7jvvvsiLS1ts8euX78+srOzE/4BoOyoqHuSrbfeOk4++eR4+umnY/bs2fHSSy9Fp06dSjWTvTi/K+79sGuN0uJ+AaByse4DAAAAQOGll3YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAVJg/f/5Gjxs0aJDwuClTpmz47/r16yc97xZbbLHR48WLF+c55uuvv97occ+ePZOe9489/jgHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFRW22yzTTz88MOlHaPAZsyYEe+//37CsRNPPDGqVatWwon+o0+fPgnrw4cPjxkzZpRwmtLRqVOnePrpp+OXX36J0047rbTjFJvatWvHKaecku/4+eefX4JpKKynn34633Vi/vz5cdNNN0W3bt2iTp06kZGRETVq1Ej4B8qCPffcM4YOHZrnT79+/Uo7GpSqirgnqVq1apx88snxzTffxAsvvBANGzYslRz24kSUzH7YtUZpKen7Bfs5oDIqS2uf94kAAAAAoPAySjsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQuR1wwAHx/vvvJ92nWrVqGz3Ozs5OeNzIkSNjhx12iIiIjIyM2HHHHWPixIlFnrdt27YbPf7111/zHPPll19u9HjvvfeOxo0bx9y5c4s055Zbbhk9evTYqPbVV18VqRcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVES9evWKt99+O1588cXSjlIgjz/+eBx00EF56nXr1o2jjjoqXn311RLNU61atTjxxBMTjj3++OMlmqUs2GqrreK5556Lc845J3r16hUzZ84s7Ugpdcopp0Tt2rXzHe/UqVN07tw5Ro8eXYKpKIiePXtGp06dEo4NHz48jj/++Fi6dGkJp4Kia9KkSRxyyCF56suXLy+FNFD2VMQ9SVpaWpxyyimx//77x//8z//EyJEjSzyDvTgltR92rVHSSuN+wX4OqIzKytrnfSIAAAAAKJqM0g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUTnvttVfccsstsddee0V6enrk5uYm1a9169YbPZ41a1bC4z7++OM488wzNzw+5phj4vbbby/SnA0bNow999xzo9qoUaPyHPfRRx/F9OnTY+utt46IiPT09Ljgggvi+uuvL9K8ffv2jfT09A2PJ02aFF9//XWRegEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABARdW/f//47LPPYtq0aaUdZbPefPPNWLhwYTRo0CDPWJ8+feLVV18t0TxHH3101K1bN0994cKF8dZbb5Vols1ZsmRJrFq1qlDnVKlSJWrUqBG1atWKtLS0Ap+31157xfjx4+PEE0+MDz74oLBRy6zzzjuvQMecffbZxTL/Z599FrfddltERLRt2zaOOuqoYpmnIurbt2/C+sSJE+Ooo46K7OzsEk4EUHlV5D3JjBkzYvHixQU6Ni0tLapVqxZZWVlRp06dqFGjRoHOa9KkSXzwwQdxzDHHxLvvvptE2sKrTHvxwnwvkzF9+vRinyOVSmo/XJmuNcoG9wsAlYt1HwAAAACKJqO0AwAAAAAAAAAAAAAAAACVW2E+lLSsKI+ZAQAAgPLB+w4AsLHu3buXdgQAAAAAAAAAAAAAAAAAoBhlZmbGoEGDolGjRhERcckll8Q///nPpHqecsopGz0eO3ZswuMGDhwY9913X9StWzciIv76179G//79Y9myZYWe85prromMjIyN5pwyZUqe43Jzc+Opp56K6667bkPtsssui3/9618xY8aMQs25zTbbxKWXXrpR7V//+lchkwMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAxVe3bt14/vnno2fPnpGbm1vacTZpzZo18cILL8SFF16YZ+zggw+Oxo0bx9y5c0ssT58+fRLWn3/++VizZk2J5SiIc845JwYMGFCkczMyMmKrrbaKHXbYIbp27Rr7779/7L333hv9+1R/1KBBgxgyZEicfPLJ8frrrxc1dpnRpUuX6Nix42aP69WrV1x66aVF+je/NufDDz+MDz/8MCIiTjrppDjqqKNSPkdFtd9++yWsX3nllZGdnV3CaQAqt4q8J/nrX/9a5K+tSZMm0a5du+jatWscd9xxsdtuu+V7bLVq1WLQoEGxxx57xLhx44oat9Aq0148me9lRVWS++HKdK1RNrhfAKhcrPtUVNnZ2fHNN9/kOwaUXX5+AQCA8iK9tAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACVz5o1a+Kuu+7a8PiOO+6IY445psj9evToEeeee+5Gtddeey3hsStWrIjHH398w+NGjRrF888/H2lpaYWa88gjj4yLLrpoo9qdd96Z7/EPP/xwLF26dMPjmjVrxltvvRVZWVkFnrNOnToxePDgqF69+obaggUL4sknnyxEcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACoPPbaa6+48sorSztGgfz3v6/03zIyMqJXr14llqNx48Zx8MEHJxx74oknSixHSVi3bl1MnTo1hg8fHrfeemvsv//+0bRp07jyyivjt99+y/e8zMzMGDBgQBxwwAElmLZ4/PHfAMtPrVq14tRTTy3mNBG1a9fe6PHq1auLfc7yaqeddooGDRrkqS9YsCAGDx5cCokAKKqKvCeZM2dOfPjhh3H77bdHt27donXr1vHKK6/ke3zNmjXjpZdeiszMzBJMaS9emZX0fti1RklxvwBQuVj3qcimTZsWXbt2Tfhn2rRppR0P2AQ/vwAAQHmRXtoBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAyumee+6JsWPHRkRElSpVYtCgQXHddddFZmZmofqcfvrpMXTo0MjIyNhQe/vtt2PMmDH5nnPrrbfGzJkzNzw+6qij4s0334y6desWaM6zzjorBgwYEOnp6Rtqn3/+ebz00kv5njN79uy47LLLNqp17NgxRowYEe3atdvsnO3atYuPPvooOnTosFH94osvjoULFxYoNwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABURjfddFN07ty5tGNs1vjx4/P995d69+5dYjlOOeWUqFKlSp766NGjY/z48SWWo7QsWLAg7rjjjmjdunXccsstsX79+oTHZWRkxMCBA2PHHXcs4YSpk5WVFb169cpTnz59esLjzz///OKOFC1bttzo8bJly4p9zvKqbdu2CetfffVV5OTklHAaAFKtou5JJk+eHCeffHIcfPDBsXz58oTH7LTTTnHeeeeVaC578cqpNPbDrjVKivsFgMrFug8AAAAARZde2gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDKae3atXHSSSfFvHnzIiIiPT09brzxxpg8eXJce+210bFjx0hPT89zXrVq1WKXXXaJv/zlLzF+/Ph49tlno3bt2hvG586dG3379t3k3AsXLoxTTz01cnJyNtSOPPLImDJlSlxzzTXRrl27POc0aNAgTjzxxPj888/j8ccfj+rVq28056mnnhq5ubmbnPdf//pXDB06dKNa586dY8yYMfHSSy/FcccdFzvttFPUr18/6tevHzvttFP8z//8T7z00ksxZsyY6Nix40bnvv766/HCCy9sck4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqOyqVq0aL774YtSoUaO0o2zW448/nrDeqVOnhP++UnE444wzEtbzy1ZRrVy5Mq655pro2bNnzJkzJ+ExdevWjRdeeCGqVKlSwulS49RTT41atWrlqV922WXx008/5al36NAhdtttt2LLk5WVFaeccsqGxzk5OfHLL78U23zlXYMGDRLWPWcAFUtF3ZMMGzYs9t1331i9enXC8csvvzzS0tJKNJO9eOVTWvth1xolwf0CQOVi3QcAAACAoksv7QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDlNWnSpNh///03qm299dZx0003xZgxY2L16tUxdOjQDWMXXnhhrFq1KsaOHRv33HNPtG/ffqNz586dG/vvv39MnTp1s3N//PHHcdJJJ8Xq1as31Bo2bBg333xzfP/997Fy5cqYOnVq/Pzzz7FgwYKYP39+vPLKK9G9e/eN+syePTsOPvjg+PXXXwv0NR9//PHx8ccfb1TLzMyMk08+OQYNGhQTJkyIhQsXxsKFC2PChAkxcODAOPnkkyMzM3Ojc95///045ZRTCjQnAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFR2O+ywQ9xzzz2lHWOzXnzxxcjOzk441rt372Kfv3379rHLLrvkqWdnZ8dLL71U7POXRSNHjowePXrEjBkzEo537tw5rrjiihJOlRrnnXdentrChQvjjTfeiCeeeCLhOeeff36xZKlfv34MHjw4WrRosaE2YsSIfH8e+M9zlsiSJUtKOAkAJaEi7km++eabuPHGGxOONW/ePHr27FmieezFK5/S2g+71igJ7hcAKhfrPgAAAAAUXXppBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACq37777Ll566aXIzc3NM5aRkRGNGzfe8LhatWqRlpaWsM+gQYNi5513ju+//77Acw8cODD233//mDJlSp6xGjVqxDbbbBOtWrWKBg0aJJz33Xffjc6dO8fYsWMLPOfKlSvjwAMPjHvvvTdycnIKfN7vcnJy4q677opDDz00srOzC30+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFR0H330UcL6ueeeG0ceeWTJhimkJUuWxOuvv55w7LTTTsv333FKlT59+iSsv/baa7FkyZJinbssmzx5chx++OGxYsWKhON/+9vfomHDhiWcKjldu3aNXXbZJU/9+eefjzVr1sQzzzwTa9euzTN+0kknRd26dVOaZeedd45Ro0ZFz549N9TWrVsX11xzTUrnqWiqV6+esL5mzZoSTgJASamIe5K77747li5dmnDsoIMOKtEs9uKVS2nuh11rlAT3CwCVi3UfAAAAAIouvbQDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnHLKKbHrrrvGI488EvPnzy/weXPnzo0nn3wyOnbsGMcff3zMmzev0HOPHDky2rRpE+eff358//33mz1+/fr1MXz48Dj00EPj0EMPjd9++63Qc65duzYuueSS2GWXXeKFF16IlStXbvaclStXxvPPPx8dOnSIyy+/PNatW1foeQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgMrjooovi119/TTj2xBNPRJMmTUo2UCE9/vjjCevNmjWL/fffv9jmTU9Pj1NPPbVQmSqT8ePHx8UXX5xwLCsrK6666qoSTpSc8847L2H99+/1vHnz4u23384zXqNGjTj99NNTluOYY46Jr776Klq1arWhtn79+jjzzDPjyy+/TNk8AFBRVLQ9yZo1a+Ktt95KONaxY8cSTmMvXpmU9n7YtQYAAAAAAABlQ0ZpBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIiIGD9+fJx//vnx5z//Odq0aROdO3eO5s2bR/v27eOUU06JiIivvvoqXn755ZgxY0Z8//338dNPP6Vk7nXr1sUjjzwSjzzySDRr1ix69uwZzZo1i8aNG0dWVlasWLEi5s2bFxMmTIjPP/88Fi5cmJJ5v//++zjttP/H3n2GR1Vufx//pRNICCC9SBek994JnVBFThAIqEAUFEWxIEVB4IB4RFBR6SKCCEiTEooUKYooRIrSkS4SSggkISTPCx/5G2dPmF6S7+e6cumse+91r5nZZc1O2NNb2bJlU7169VSpUiUVK1ZMOXLkkCQlJCTo7NmzOnjwoPbs2aPExESHzGvO8OHDNXz4cKfOAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAs924cUNPPPGEtm/fLj8/v3Rj+fLl09y5c9W+fXs3VfdgW7Zs0enTp1WiRAmTsaioKG3atMkp87Zq1UoFCxY0iZ8+fVrffvutU+b0NrNnz1ZUVJQaN25sMvb0009r1KhRTv++KUfImTOn/vOf/5jE9+7dq19++eX+41mzZqlr164my0VHR+uDDz5wSC1nz55VQEDA/cfXr19XZGSk1q9f75D8Rvz8/BQaGiofHx/dunVLd+/eddpcgDdiHzEvODhYwcHBSk1N1Y0bN5SWlubukswKCAhQSEiIUlNTdfPmTY+uFdbLLD3J33788Uf17t3bJF6mTBmX10IvnjV4Qj/MtmY7b+hVgoKCFBAQoFu3brm7FGRB3tSzulpoaKj8/f099tjhTIGBgQoJCVFiYqJu377t7nKcgm3fswUFBSlHjhxKTk7m/PgAf2/Lt2/fdtrnOn9/f4WGhioxMVF37txxyhyZgTf0nc7y9z7rzO3QETi2wFresm0DAAAAcD1/dxcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP+UlpamI0eO6MiRI5KkGjVqqFevXpKkHTt2aOrUqU6d/8KFC1q0aJFT5/i3xMREbd26VVu3bnXpvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZFa7du3SxIkTNXLkSJOxdu3aafDgwfrwww/dUJll5s6dq7feessk3q1bN0VHRyshIcHhc/br188wPmfOHIfP5c3eeOMNbd++3SSeK1cuPfbYY/r888/dUJV1evfurezZs5vEZ82ale7x+vXrdf78eRUpUiRdvGLFimrQoIF27dpldy379u3Tq6++qv/973/av3+/unfvrpMnT9qd92916tRRy5YtVadOHVWrVk158+ZVSEhIumWSk5N1/vx5HTx4UD///LPWrFmjvXv3OqwGW+XJk0cFCxY0O16gQAGz8QoVKlg93+HDhw3j+fPnV968eU3ily9f1tWrV62exxwfHx89+uijJvHU1FT9+uuvDpsHpv65n4SHhzt1H8mbN6/y589vdvzhhx82jIeFhVm9XScnJ+v48eNWrfO3gIAANW/eXG3btlWVKlVUsWJF5cuXT35+fveXSUtL0/Xr1xUXF6cDBw5o27Zt2rZtmw4cOGDTnPaoVq2aOnbsqFq1aqly5coqUqSIgoKC0tV68+ZNHT58WPv27dPatWsVExOje/fuubxWawUFBal06dJmx+Pj43X27FkXVuQ5MkNP8reLFy8axsPCwlxcyV/oxTM/T+mH2dYezBv6+UqVKqlz586qU6eOqlSpoiJFiiggIEDSX+fga9eu6dChQ4qNjVVMTIxiYmKUmJho97zu+rzgCf1c2bJl77/G/3Tx4kVdu3bNqjmMhIaGqlixYibxI0eOKC0tze78JUuWVHBwsEn82LFjunv3rsV5PKlnNXpvH/SZMSgoSFWqVFGZMmUUFham0NBQ+fj43B+fNm2azftKUFCQ2rRpozZt2qhq1ap69NFHlTt37nT5k5OTdebMGR08eFC7du3SihUrbP784GzWvr65c+dW165d1apVK1WtWlWlSpVK9/ng3r17unTpkmJjYzVixAjt37/fWaU7hTu2fU849nnKdSJLZHRulJx7fvwndx2brJ23RYsW6tmzp+rXr69y5copMDDw/lhKSop+//137d+/X1u2bNFXX32lP/74I8P5jVSvXl29evVSgwYNVLlyZYWGht4fu337tq5cuaLY2FitW7dOa9eu1ZkzZ6yew9nMbcf2bKv/5A19p6Ws3Qbz5MmjHj16qEWLFqpevbqKFy+ebjv8exs5cuSINm7cqJiYGB08eNBp9ZvjjmMLfadjOGr/zazbNgAAAADP4JNm4Sexf14sAoB/qlKliqpUqSLpr4tVJ0+e1J49exxyoQcAAAAAAAAAAAAAAADmDV0mBeVwdxXIzM4dlL542d1VAADM8fHxUa1atfTII4/c/3vv2NhYxcbGurmyrIm/qQUAAAAAAAAAAAAAAAAAAHAtHx8f1a5dW2XLluXvaQFYzJ6/8eZe7QDM4d+VAAAAAAAAAAAAAAAAAK5To0YN7du3T5I0ZcoUDR8+3M0VAQDchXu1exb+phYAAAAAAAAAAAAAAAAAAMC1uFc7AFtwr3YAzsC/KwEAAAAAAAAcq137dmrRooW7y0AWs/abtfr222/dXQYAuATnWrjL8mXLtXv3bneXAQAu0WqIVL2ju6tAVhMzXdr/jburAADX4l7tnoW/qQU8y6lTp1SiRAmTePHixfX777/Lz89Pu3fvVu3atU2WSUxMVI0aNXTkyBGH1HLkyBGVL1/eJP7QQw8pLi7O6nzFihXT6dOn5evrazLWt29fLViwwKY6zQkNDdXly5cVHBycLp6amqoSJUro7NmzVuc09/707NlTS5YscXs+e+zbt081atQwia9cuVJdunSxKpc7nteBAwfun8/+dvv2bRUsWFDx8fHp4uPHj9eIESNMcixYsEB9+/Z1WE3R0dGaM2eOkpOT7c4VEBCg6OhoRUdHq0KFCjblOHfunKZNm6ZPPvlEN2/etLsmWwwbNkzvvvuuS+a6cOGCihQpYjg2ceJEvfbaaybxV199VZMnT3ZYDdmzZ1dCQoJJ/NatWwoNDbUql7nezNp/P+moPJ7I3v3E1n1k9OjReuutt6yezxY7duxQkyZNrFqnYMGCevnllzVgwADlzJnTpnn37t2riRMnasWKFU79nJA9e3YNGDBAQ4cOVcmSJa1e/8qVK5o6daree+893blzx+Y6nLmfhIWF6ZtvvlHDhg0Nx3///Xe1bt1av/32m91zWSOz9iSS+55bmzZttH79epO4pecAR9dNL575eUo/nBm2NWfwhn4+ICBAUVFRevnll1WuXDmr1k1ISNDnn3+uSZMm6dSpUzbX4K7PC57Qz3399deG57nZs2fr6aeftntec8+xQYMGdv9NkL+/v/7880+FhYWli1+7dk358+dXSkrKA3N4Ys9qlMPoM6Ovr6969OihAQMGqGnTpvL39zeb05ZrasWKFdPrr7+uPn36KCQkxKp1pb9elwkTJmjFihVWr+tMlr6+RYsW1ahRo9S/f38FBARYnP/XX3/VhAkTtHDhQqWmpjqlXsn+zwju3PY94djnKdeJzLHn3Cg57vz4T+46Nlk6b5s2bTR16lTD3yuYc+/ePX322WcaNWqUzp8//8Dl69Wrp6lTp6pu3boWz5GamqovvvhCI0eO1JkzZyxez9mccWzxhr7TFpZug4ULF9bYsWPVt29fq84b0l/HqtGjR2vr1q32lPpA7j62ZPW+01Gceb3eW7dtAABgO+7VDsAWllwLNP1tHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4uXv37qlXr15KSEgwGcuWLZsWLVqkgIAAN1T2YGfPntXmzZsNx6Kiohw+X48ePRQcHGwS37Rpk86ePevw+bzd3LlzDePh4eEKDAx0cTXWqVu3rqpUqWISX7p0qeLj403is2fPVlpamkm8R48eyp07t8Pq+vjjj5WcnGx3noYNG2r//v2aNm2aKlSoYHOeokWLavLkyTp9+rRT9jlP89tvv7m7BLiQI/YTb9hHDh06ZPGyPj4+evnll3Xq1Cm99NJLypkzp83z1q5dW8uXL9fOnTtVqFAhm/NkJDIyUqdPn9bUqVNVsmRJm3Lky5dP48eP17Fjx9SiRQsHV2i/QoUKaceOHWrYsKHh+MGDB1W/fv0sf/zy5p7kn4x6DXeiF8/cPKkfZlsz5Q39fOvWrXXs2DHNnDlT5cqVs3r9HDlyaNCgQTp27Jj+97//KVu2bA6tzxncdb41188tWbLEMB4RESEfHx+75+3UqZPZ/PZq2rSpwsLCTOIrVqxQSkpKhut6W8/6b+XLl9eePXu0ePFitWzZUv7+/g7LHRAQoPHjx+vEiRN65plnFBISYlOe2rVr6+uvv9aOHTtUqlQph9XnCv369dORI0c0cOBAq693li9fXp999pn2799veI50N2/f9q1lzWdZZ7H2uG/vuVFy3/nRmccmc/z8/DR9+nStX79e5cuXt3rd/v3769ChQ+rQoYPZ5Xx9fTVlyhTt2rVLdevWtWoOX19f9e7dW0ePHlW/fv2sWtebeEPf6Uy9evXS0aNH9dRTT9n0e7LGjRvr22+/1dKlS5UjRw4nVOgZx5as2nd6M2/YtgEAAAB4Jl93FwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADP9O233xr+AAAAALAcfTUAAFkP538AAAAAAAAAAAAAAAAAAAAAAAAAAAAAgCPlzC9Vbi016CU1fVKq3U0qUVPyC3B3Zd7j+PHjeuGFFwzHqlatqvHjx7u2ICvMnj3bMN68eXMVLVrUoXNFRUVZVUNWt3r1asN4jhw5VKtWLRdXY53o6GjD+MyZMw3jJ0+e1NatW03i2bJlM7vduEtUVJS2bdumChUqOCxn7ty5NW/ePC1fvlxBQUEOy+tpfvvtN3eXABdx9H7iyfvIoUOHLFouZ86c2rJli9555x1ly5bNYfPXr19fP/30k+rWreuwnMHBwVq6dKm++OIL5cuXzyE5ixQpoo0bN+qVV15xSD5HKFu2rHbv3q3KlSsbju/YsUONGjXShQsXXFyZ5/HmnuSfzO17d+7ccXEl/4dePPPytH6Ybe3/eHo/7+vrqw8//FAbNmxQ8eLF7a7Nz89PL774omJjY1W+fHm78zmTuz4vmOvnVq9ercTERJN4/vz5Va9ePbvmLFiwoGrUqGE41rFjR7tyS1LXrl0N40uWLMlwPW/qWY3UrVtXu3fvVu3atR2eu2jRovrhhx80YsQIBQQ45qJpo0aNFBsbqw4dOjgkn7NNnTpVc+fOVUhIiF15KleurL1796pfv36OKcwBvH3bt4Wln2WdydLjvqPPjZJrz4/OPDaZ4+vrq2XLlmnIkCF25QkLC9Pq1av1n//8x2QsMDBQ33zzjV566SX5+PjYPEdgYKDmzp2rUaNG2VOqR/L0vtPZ3n77bS1cuFA5cuSwO1f37t21Z88elShRwv7C/j9POrZkxb7Tm3n6tg0AAADAs/m6uwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyMiFCxc0ZswYjRkzRhs2bHB3OQAAAAAAAACQpTRr1szwB0DmEhgYaPgDAAAcg77aPehxAADuxPkfAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOAIRSpIkVOk6M+kdsOkRn2luo9LzQdKj4+XnlsiNekvBWZ3d6XeYdasWVq5cqXh2Msvv6zmzZu7uCLLfP3117p27ZpJ3NfXV0888YTD5ilRooQaN25sEo+Li9OKFSscNk9mcubMGZ08edJwrEaNGi6uxnJhYWHq2bOnSfzYsWP67rvvzK43a9Ysw3h0dLTDarNX//79NXfuXPn5+Vm0/J07d3T79m2lpaVZtHzXrl21YcMGBQUF2VOmx/rtt9/cXQJcwJr9JDPsI4cOHXrgMrlz59bWrVstvk9QamqqEhISlJKSYtHyBQsW1Jo1a1SsWDGLls9Injx5tHXrVnXv3t3uXP/m6+urSZMm6Y033nB4bmvVrFlTO3fuVPHixQ3HV65cqVatWunGjRsurswzeWtP8m8FCxY0jF+9etXFlfwfevHMyRP7Yba1v3h6P58tWzatXLlSzz77rE3rZ6Rs2bLatWuXGjZs6PDcjuKuzwvm+rlbt26Z/a7rLl262DVnx44d5ePjYzhWuXJlPfzww3bl79Spk0ns+vXr2rx5s9l1vKlnNVKqVCmtX79euXLlcnjuv/efatWqWbR8SkqK7ty5Y9GyOXLk0IoVKwzPG55k6tSpGjp0qMPyBQYGas6cOXr++ecdltNW3r7t28qSz7LOZslx35nnRsn550dnHpsyMmPGDHXu3NkhuXx8fDR//nzVrVs3XXzx4sVq27atQ+aQpLFjx6p3794Oy+dunt53Otsbb7zh8Os/lSpVUkxMjEJDQ+3O5WnHlqzWd3ozT9+2AQAAAHg+f3cXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZuXTpksaOHevuMgAAAACP9vzzzytXrlwm8aVLl+rw4cNOnTtv3rx69tlnzY4fOHBAK1eudGoNAAAAAADbPfLII/rtt98Mx8qVK6ejR4+6uCK4mtF1hWPHjmnRokUurePZZ59V3rx5TeKTJ09WYmKi2fWefPJJFS1a1CR+9+5dTZw40aE1Wqt9+/aqVauWSfzcuXOaM2dOhus643qPuZy2SE1N1Z07d3Tnzh39+eef+v3333XmzBldvHjRIfmt4c5rY0ZefPFFhYaGpov99ttv+vLLL11eC5CV0eMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8HYN+0gNekk+PuaXCQyW6vWUHm0mLRsj/XnaVdV5r6eeekp169ZVwYIF08V9fHz02WefqXLlyrp+/bp7ijMjOTlZCxcu1JAhQ0zG+vXrp0mTJjlknj59+sjHYINbuHChkpOTHTJHZvTzzz+rVKlSJvEaNWq4oRrL9OnTR8HBwSbxWbNmZbjesmXL9OGHH5rc/61cuXJq0qSJtm/f7sgyrVaqVCl98MEHhtuxJF24cEFffPGFNmzYoIMHD+qPP/5Qamrq/fE8efLokUceUaNGjdS9e3fVq1fPME/Tpk01bdo0DRo0yCnP498uXryoPXv2mB0vWrSo4X0Zz507p3Pnzlk1148//mh1ffAulu4n7777rlP3kXPnzmW4XT/00EMqW7asSTwuLs7qe8kdPHjwgcssXLhQ1atXNzu+Y8cOLV26VDt37tTRo0cVHx9/fyw0NFQlS5ZUs2bN1LdvX9WsWdMwR968ebVs2TI1bNhQd+/eteo5/C0wMFCrV69WnTp1zC5z79497dy5U2vXrtWPP/6oy5cv6+rVq/Lx8VFYWJjKli2rJk2aKDIyUoULFzbM8fbbb+v48eNuu5dmy5YttWLFCoWEhBiOz5w5U9HR0em2T3hnT/JvpUuXNoxfuXLFxZX8H3rxzMkT+2G2Ne/o5xcsWKCOHTuaHU9NTdXu3bu1evVq7d27V5cuXVJiYqIKFCigMmXKqH379mrbtq3Ze4Xnzp1b33zzjerXr68jR45YVJO7Pi94Sj/35ZdfqnPnzibxLl266NVXX7Vqnn/q1KlThuMdOnTQjBkzbMpdvXp1FStWzCS+cuXKDPtEb+lZjfj5+Wn58uUOu0/+P+XJk0cxMTGGr+nfYmNj9eWXXyomJkYnTpzQtWvXJP3VX+fNm1e1atVS69at9cQTTxjW6O/vr/nz5+v06dP6/vvvHf4c7NW3b18NHTrUJJ6cnKwNGzZo3bp12r9/vy5duqTbt28rR44cKlCggMqWLau2bduqXbt2hs/bx8dHU6dO1cmTJ7VmzRoXPBNjnrTte8Kxz9OuE9lyboyLi1P27Nmden60hDOPTRnp1q2bBg4caBI/efKk5s+fr23btunMmTNKTExUnjx5VKhQIbVo0UKPPfaYHnnkEcOcgYGBmj17tqpVq6aUlBS99NJL6tq1q8ly169f1+LFi7V27Vr9+uuvio+PV0hIiAoUKKBatWqpa9euatq0qdnaP/roI+3cuVOnTp2y/QXwAN7QdzpTeHi4xo4daxJPS0vT9u3btWLFCv344486f/68bt++rZw5cypfvnyqXr262rdvrzZt2sjPz88wd9myZTV//nx169bNrho98diSlfpOb+UN2zYAAAAAz+fv7gIAAAAAAAAAAAAAALBWtWrVtGPHDknStGnT9MYbb7i5IgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPd68cUXVaJECZP4r7/+qsOHDztt3rCwMG3cuFHVqlUzHD948KA+/PBDp80PAAAAAADsZ3RdITU1VefPn9f27dtdVsdzzz2n8uXLm8Q/+OADJSYmml2vcOHCeuuttwzHtm/frp07dzqsRmtNnz5dpUqVMomPHDnyges643qPuZyO9Mcff2jv3r3asmWLVqxYoZMnTzp1Psl918aM1KhRQ//73/9M4vHx8VqzZo0SEhJcWg8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPBO4YOlGhGWLx9WQOr9P+nzYdKfp51WVqZw9epV9evXT+vWrZOPj0+6saJFi+qTTz5Rz5493VSdebNmzdKQIUNM4uXLl1fNmjW1b98+u+eIiooyjM+ePdvu3JnZoUOH1L17d5N48eLF3VCNZQYNGmQSS0lJ0fz58zNcLykpSV988YWeffZZk7Ho6GiX3sPQyNSpU5U9e3aTeGpqqkaPHq0pU6YoKSnJ7PpxcXHas2eP9uzZoylTpqhBgwaaMWOGqlSpYrLswIEDtXTpUm3cuNGhz8HIokWLtGjRIrPjo0ePNrwv48yZMzV27FhnlgYvZM9+4sh9ZM6cOZozZ47ZOrt166Zly5aZxLds2aIePXqYXc8Wzz33nNq1a2c49tNPP+mZZ57RDz/8YHb9+Ph4xcbGKjY2VtOmTVO3bt00d+5c5cyZ02TZ2rVrq1+/fpo5c6ZNtc6YMUMNGjQwO7506VK98cYbOnr0qOH4hQsXdOTIEa1atUqvvfaahgwZogkTJig4ONhk2U8++UQ7d+7UuXPnbKrVVj169NDnn3+uwMBAw/Fx48Zp9OjRLq3JW3hjT/JvnTp1Mozv3bvXxZWkRy+e+XhqP5zVtzVP7+dHjRqlxx57zOz4+vXr9corr+iXX34xGTt58qR2796tBQsWKEeOHBo2bJheeeUVhYSEmCwbFhamb775RtWqVdPNmzcfWJe7Pi94Sj+3evVqJSYmKlu2bOnijzzyiMqVK6fffvvN6pxBQUFq2bJlhstERERoxowZVueWpK5duxrGv/rqK7PreFPPamTIkCGqWrWqSfzatWtauXKl1qxZo19++UWXL1/WjRs3rMr95Zdfmr3//tmzZzVs2DAtXbrUcDw5OVkXLlzQqlWrtGrVKo0YMUKvvvqqXnvtNfn6+qZbNigoSEuXLlX58uU96n7zBQsW1IgRI9LF0tLSNGPGDI0fP14XLlwwXO/v49Jnn32mHDly6MKFC4bbg4+PjxYuXKiKFSu6/LOB5Hnbvicc+zzpOpE950bJuedHSzjz2GRO9uzZNX369HSx+Ph4vfTSS5o9e7ZSU1PTjV26dEmHDx/W5s2bNWrUKA0ePFjvvPOOgoKCTHJXrFhRTz75pDZv3qwJEyakG0tLS9PUqVP15ptvGr5+x48f186dO/X++++rVatWmjlzpuFnydDQUE2ZMsXws6c38fS+05myZcumWbNmmZznvvnmG7366qs6dOiQyTqXL1/WsWPHtGvXLn344YeqUKGCpk2bZrZf6tq1q3r06JFhb5MRTz22ZJW+01t5w7YNAAAAwDv4PngRAAAAAAAAAAAAAAA8i6+vr0JCQhQSEmL2H+kDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAuXLkyKH169erWrVqhuO//fabWrZsqatXr7q2MAAAAAAAYDdfX18tWLBAYWFh7i7lgebNm6fU1FTDsaioKBdX838aNmyoUqVKmcRTU1M1f/58N1TkGvnz51eHDh307rvv6sSJE9q3b5+ioqIUGBjo7tJcYtCgQYbx0NBQRUZGurgaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgjaq0lWpEWL9eYHap+1t//RcZ27Bhgz744APDsccff1x9+vRxcUUPduDAAf3888+GY46471r9+vVVunRpk/hPP/2kAwcO2J0/M/v9998N40WLFnVxJZapX7++KlWqZBJfu3atLl++/MD1Z82aZRjv3r27HnroIbvrs1W+fPnUrl07w7HIyEiNHz9eSUlJVuXctWuXateureXLlxuOjx071uo6AXdy9H6SGfaRnDlzasyYMYZjn3/+uerUqaMffvjBqpzLly9Xw4YNdePGDcPx4cOHy8fHx+paw8PD9eSTTxqO3blzRz169FCPHj109OhRi/KlpKRo6tSpatCgga5cuWIyHhYWprfeesvqOu3xzDPPaPHixYb3MU1NTdXgwYM1evRol9bkTbytJ/m3Ro0aqXz58oZjO3fudHE16dGLZy6e3A9n5W3N0/v5SpUqadSoUYZjKSkpGjRokNq1a6dffvnlgbkSEhI0btw4Va1aVUeOHDFcpmTJkpo8ebLF9WVlt27d0oYNGwzHOnfubFPOli1bKnv2jC+wtWjR4oHLmGNU182bNxUTE2O4vDf1rEayZ8+ukSNHposlJSVp0qRJKlmypPr3769ly5bp6NGjZusxp3fv3goPDzcc27lzp2rWrKmlS5danO/mzZt644031KFDB8XHx5uMFy1a1OU98oM888wz6b5T4saNG2rZsqUGDx6sCxcuWJQjISFBNWrUMHtMypkzp9577z2H1GsNb9/2MztHnhsl158fnXlsyshTTz2lwoUL3398+vRp1ahRQzNnzjT7vSt/S01N1fTp09WjRw+lpKQYLvPiiy9q3Lhx6T5X37lzRx06dNCwYcN08+bNB9a4ceNGNW3aVOfPnzcc79y5s9d8zjTi6X2nsz399NMqXrz4/cd/768dO3bUoUOHLMpx+PBhtW7dWnPnzjW7zCuvvGJTfZ58bMkKfac38/RtGwAAAID38HV3AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwLtky5ZNa9asUb169QzHT5w4oRYtWuiPP/5wcWUArNGwYUOtW7fO5GfEiBHuLg0AAACAB3j44Yc1Y8YMd5fxQOfOndOmTZsMxx5//HEFBQW5uKK/REVFGcY3btyoc+fOubga96lRo4bmzZunkydPqnfv3u4ux6lCQkLUq1cvs+PPPPOMC6sBPA/XooC/sC8AQNbBMR8AAAAAAAAAAAAAAAAAAAAAAAAAAACALQKzS02ftH39sAJSvZ6OqyczGz58uA4fPmw49uGHH6pEiRKuLcgCs2fPNoxHRkbK39/frtzm7p9mbk78n4sXLxrGCxQo4OJKLBMdHW0YnzlzpkXr//zzz/r5559N4oGBgerXr589pdklIiLCcD/48ssvtWTJEpvzJicnq2fPntq9e3e6+MaNGzV69Gib8wLu4Iz9xNv3kYCAAC1atEiJiYnp4mvXrlWfPn107949m/IePHhQgwcPNhwrW7as2rVrZ1U+X19fffTRR4Zjt2/fVrNmzbR06VKr65Sk/fv3Kzw8XLdv3zYZq1OnjgIDA23Ka60333xTH330kXx9fU3GkpKS9Pjjj5t9DfAXb+tJ/ikoKEizZs0yHLt+/brWrVvn4opM0YtnHp7eD2fVbc3T+/mPP/5YAQEBJvG7d++qffv2+vTTT62u7eTJk6pbt6727NljOD5w4EDVqVPH6rxZkbltpEuXLjbli4iIeOAyQUFBCg8Ptzp3iRIlVKVKFZP4qlWrdPfuXcN1vKVnNScyMlJ58+a9//jPP/9UixYt9Nprr+nGjRs2582WLZsmT55sOHbgwAGFh4frypUrNuVev369+vbtazj23HPPeVR/lS1btvv/f/v2bbVo0ULffvut1XlOnDihunXr6qeffjIcf+yxx9SwYUOb67SFt2/7mZ0zzo2S686Pzjo2PUjRokXv///Vq1fVvHlzHT9+3Kocq1ev1rvvvms4Vr58eUVGRt5/nJqaqm7duln9merMmTNme0c/Pz+zPbU38PS+09mKFSt2//9TU1PVs2dPm/bX1NRUPfnkk9q+fbvheK1atdSkSROr83r6sSWz953ezNO3bQAAAADew/QvFgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMwICAjQ8uXL1axZM8PxM2fOqHnz5rpw4YJrCwNgtQIFCqht27YmP9WrV3d3aQAAAAA8RGRkpHr16uXuMh5o1qxZhvGwsDB16tTJxdVIQUFBevzxxw3HzNWa2RUpUkQLFizQ9u3bVaRIEXeX4xS9evVSSEiI2fEaNWqoZs2aLqwI8CxciwL+wr4AAFkHx3wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtqjcWgrOaV+OGp0kvwDH1JOZJSUlKTIyUsnJySZjoaGhWrhwoXx9fd1QmXkLFy5UUlKSSTxv3rxq27atzXkDAwPVs2dPk3hiYqK++OILm/NmFbdu3TKMBwcHu7iSB8uVK5d69OhhEr948aLWrVtncR5z99WLjo62uTZ7lS5d2jA+f/58u3OnpKSof//+unPnjhYsWKCqVauqdevW2rhxo925AVdy1n7izfvI1atX9dxzz6lkyZJ69913lZCQoOvXr6tv37525164cKF++eUXw7GWLVtalatbt24qW7as4dizzz6rH374wer6/ik2NlbDhg27//iHH35Q165dVaVKFcNeyZF8fHw0Y8YMjRkzxnD85s2batu2rZYtW+bUOjIDb+pJ/ilnzpxat26dypUrZzg+Z84c3blzx8VVmcpsvXjFihXVpEkTh/5UrFjRafU6ijf0w5ltW7OUJ/fzjRs3VsOGDQ3Hhg8fblfPEx8fr+7du+uPP/4wGfPx8dGIESNszp2VrFq1ynC/qVevnvLnz291vo4dO6Z7nJKSou+++85kuYiICKtzd+7c2TC+ZMkSs+t4S89qziOPPHL//69W1I89AAEZFElEQVRfv6769etr165dduft1auXChUqZBK/efOmunbtqsTERLvyr1ixwvB4HxgYqMGDB9uV21meffZZ/fTTTzav//cx6dq1a4bjL7zwgs25beHt235m5sxzo+Sa86Ozjk3WiIqK0unTp21a9+2331ZcXNwDl5s0aZLWr19v0xybN282u26bNm1syukJPLnvdLUxY8Zo+fLlduXo16+f7t69azhmru8xxxuOLZm978wsPG3bBgAAAOBdPOsvRgEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMfy9fXV4sWL1a5dO8Px8+fPq0WLFjp79qyLKwMAAAAAAM7y0Ucf6eGHH3Z3GRlauXKl4uLiDMeioqJcXI3UuXNnhYWFmcTj4uK0atUql9fzIDdu3NClS5es+rly5Ypu3bqltLQ0q+Zq3LixYmNj1bJlSyc9G/eJjo52yDIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACDrKlPP/hyBwdLDVezPkxXExsZqxIgRhmMNGjQwO+Yu169f19dff204Zs991zp16qRcuXKZxL/++mtdv37d5rxZRWJiomE8MDBQvr6+Lq4mY3379lVwcLBJfP78+bp3757FeRYuXGj4vMuUKaMWLVrYVaOtChcubBg/ceKEQ/L/9ttvKlCggPr27avY2FiH5ARczZn7ibfvI5cuXdLLL7+s4sWLq1OnTrp69apD8n7yySeG8caNG1uVZ+jQoYbxVatWaf78+VbXZeTTTz/VjBkz1KxZM9WtW1crVqyw+r6j1goMDNSSJUvM3q/z0qVLatKkibZu3erUOjILb+pJ/tauXTt9//33at68ueH41atX9d///tfFVRnLbL346NGjtW3bNof+vPTSS06r11G8oR/ObNuapTy5n3/55ZcN45s2bdL7779vd20XLlzQgAEDDMc6deqksmXL2j1HZnfr1i1t2LDBJO7j46OIiAirclWrVk1FixZNF9u2bZthz9WhQwfrCpXUpUsXk1h8fLxiYmIeuK6n96yWePLJJ3X8+HGH5BoyZIhhfNq0aTp16pRD5pg4caJSU1NN4n379nVIfkfasWOHQz4bnD59Wq+88orhWJcuXVSwYEG757BWZtj2Mxtnnxsl154fHXlsstTKlSv1zTff2Lz+rVu3tGzZsgyXOX/+vMaNG2fzHJI0Z84cw3jVqlUVFBRkV2538eS+05UOHDigiRMn2p3n1KlTWrFiheFYo0aNrMrlDceWrNJ3ejNP3LYBAAAAeBd/dxcAAAAAAAAAAAAAAMCDVK9eXY899piqVKmiUqVKqUSJEvfHhgwZooiICJ04cUK7du3SunXr9NNPP9k9Z9GiRdWhQwc1a9ZMjz76qIoWLaqQkBAFBQXpzp07iouL07Fjx7R7926tXLlS33//vd1zZqRUqVIKDw93Su4ff/zRptesVKlSevzxx9WkSROVL19eBQoUUHBwsFJSUnTr1i2dOXNGsbGxWrdunVavXq2EhAS76vS09wQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgKxo3rx56tatm+HY5cuX1aJFC508edLFVQEAAAAA7JGYmKgff/zR7BgQFhamzz//XE2bNlVaWpq7yzGUnJyshQsX6rnnnjMZa9OmjfLnz68//vjDZfVERUUZxj///HMlJye7rA5LDRw4UEuWLLFpXX9/fxUpUkSPPPKIateurZYtW6pJkyby9/c3u06ePHm0du1a/ec//9HXX39ta9kepVatWqpevfoDl4uMjNSwYcMUHx/vgqqArI0eBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIA3ylvcMXkeelg6tc8xuTK7d999V+3bt1eLFi1MxsaMGaOYmBj98MMPbqjM2OzZs/Wf//zHJB4REaFcuXLp+vXrVuc0d/+02bNnW50rK0pJSTE75u/v71H3oBs0aJBh3Nr3+saNG1q+fLl69eplMhYdHa0tW7bYVJ89goKCDOOOvI8i95GDt3P2fpIZ9pGrV69qx44dDstn7nhYvXp1+fn56d69ew/MkT9/fjVs2NBwbNKkSXbV909paWl69tlnHZbvQUJCQrRy5UrDHkySjh8/rtatW+vUqVMuq8nbeUtPUqRIEXXt2lW9evVS/fr1M1x2yJAhunLliosqezB68Yx5w/7qLf1wVtzWPLWfDw0NVbt27QzHJk6caG9J961atUqHDh1SxYoV08V9fHz02GOPOXSuzGrJkiXq1KmTSbxLly5WbecdO3Y0ia1atUpr1qxRWlqafHx87scLFSqkGjVq6KeffrIod+7cudW4cWOT+OrVq5WUlGRxjZ7Ys1ri66+/dth96R9++GHD+8Lfvn1b7733nkPmkKSTJ09q06ZNat26dbp48eLF9eijj+rIkSMOm8te48aNc1iuBQsWaMKECcqXL1+6uL+/v9q2bat58+Y5bC5reOu2n9m46twoueb86MhjkzUcsc8uW7ZMAwYMMDs+depU3blzx6451qxZo+TkZAUGBqaLBwQEqHr16tqzZ49d+d3BU/tOVxs1apTDjnNz585Vjx49TOI1atRQ9uzZdfv27Qfm8KZjS1bqO72Rp23bAAAAALyP+W9hBQAAAAAAAAAAAADAjfz9/RUdHa0XXnhBpUuXNrtctmzZVK5cOZUrV07t27fX22+/rdjYWL355ps2/QOK8uXL6+2331bXrl3l6+truExwcLCKFCmiIkWKqFmzZnr99df1888/a/jw4dq8ebPVc1qiVq1a+uSTT5ySe8yYMRb/8bYklSlTRlOmTFHnzp0NxwMCApQ7d27lzp1b1apVU9++fRUXF6eJEyfqf//7n1JTU62qz1PfEwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAspoZM2aoT58+hmN//vmnWrZsqaNHj7q4KgAAAACAvX7//XfVrl3b3WXAwzVu3Fivvvqq/vvf/7q7FLNmzZql5557ziTu7++vyMhIvf/++y6pI3/+/GrTpo3h2OzZs11SgyulpKTozJkzOnPmjDZu3KgJEybooYce0lNPPaWhQ4eqcOHChusFBgZqyZIlateunTZt2uTiqh1v0KBBFi2XI0cOPfHEE/r444+dXBEAehwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3ig4p2Py5MjtmDxZRd++ffXLL78od+70L5y/v78WLlyoatWqKSEhwU3Vpbdp0yadOXNGxYsXTxcPCgrS448/rk8//dSqfPny5VPbtm1N4mfOnNHmzZvtqhWepWHDhqpQoYJJfNu2bTp+/LjV+WbOnKlevXqZxLt06aL8+fPrjz/+sKlOW12/ft0wXrJkSR07dsyltQCeiv3E9X799VfdunVLISEh6eL+/v7KnTu3/vzzzwfmaNu2rXx8fEziP//8s3bt2uWwWl0pX758Wr9+vWrUqGE4vm/fPrVr105XrlxxcWV4kC5duqhEiRIWLevj46Pg4GCFhoYqNDRUpUuXVsWKFVWgQAGL1h87dqwWL15sR7WORy+esVOnTrm7hAx5Uz+cFbc1T+1TWrdurYCAAJP4wYMHtWXLFofONXXqVM2cOdMkHhERoYkTJzp0rsxo1apVSkpKUlBQULp4eHi4smfPrtu3b1uUp1OnTiax1atX69KlS/rxxx9N7nncsWNH/fTTTxbl7tixo/z8/EziX331lUXrO4sjelZLTJ061SF5JKlVq1aG8U2bNikuLs5h80jS1q1b1bp1a5N4s2bNdOTIEYfOZau/vyfAUZKSkjR79my99tprJmNt27bVvHnzHDaXO7lq289sXHlulJx/fnTksclSBw4c0L59++zOk1GO1NRUzZ8/3+457ty5o19//VVVqlQxGStZsqT27Nlj9xyu5ql9pyudOXNGq1evdli+nTt3Ki0tzeT6lb+/v4oXL27R+dKbji30nZ7LE7dtAAAAAN7H190FAAAAAAAAAAAAAADwb2XKlNHevXs1ffp0lS5d2ur1q1SpouXLl2vNmjUmN1fKyAsvvKADBw6oe/fu8vW17lfq1atX16ZNm/Tuu+9aW65XiYyM1IEDB9S5c2er1suTJ4/eeecdbd68WTly5LB4Pd4TAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8w5QpUxQdHW04du3aNbVq1UqHDh1ycVUAAAAAAMCVxo4dq5o1a7q7DLNiY2P1008/GY717dvXZXX06tVLfn5+JvF9+/YpNjbWZXW409WrVzV58mSVLVtW48eP17179wyX8/f319KlS1WuXDkXV+hYoaGhioyMNImfPXvWcPlnnnnG2SUBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAvdTfRMXmS7zgmT1Zx/vx5DRw40HCsTJkymjp1qmsLeoB58+YZxqOioqzO1atXL/n7+5vE58yZY3UueDZz3zcwa9Ysm/Jt3bpVJ0+eNIkHBASof//+NuW0x8WLFw3jRveKA7Iq9hPXS0tLM/u658mTx6IcjRs3Noxv2LDB5rrcqXjx4tq5c6dq1KhhOL5x40Y1bdpUV65ccXFlsERkZKQmTZpk0c9///tfjRkzRsOGDdOAAQPUokULFShQ4IFzpKWlaezYsRozZowLnpH16MXNO3XqlLtLyJC39cNZbVvz1D6lefPmhvH169c7fC5zOevWraugoCCHz5fZxMfHKyYmxiSeLVs2tWnTxqIcBQoUUK1atdLFDh48eP/4tnLlSpN1IiIiLK6xS5cuJrGEhASnbE/WcETP+iC//vqrtm/f7pBcktSoUSPDuDN65D179hjGK1as6PC5bGW07dtry5YthvHatWs7fC53ccW2nxm58tyYUV5HnB8dfWyylKOOVX/++afZz8779+932Odqc99TmytXLofkdzVP7Ttdac2aNQ7Nd/PmTZ04ccJwLHfu3Bbl8KZjC32n5/LEbRsAAACA9/F1dwEAAAAAAAAAAAAAAPxThQoVtHv3blWrVi1dPC0tTb/88osWLFigzz777H78wIED2rx5s27cuGGSq0OHDtq9e7fy58//wHlHjx6t9957T4GBgeniV69e1TfffKPp06dr/PjxevvttzVt2jStXbtW165dM8kzbNgwTZ8+3cJn6xlSUlIsWq5fv35auHChsmfPni6ekJCgNWvW6KOPPtK4ceM0ceJEzZo1Sz/88INSU1PTLdusWTOtXr1aPj4+D5wvK78nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4kjfffFMvvfSS4Vh8fLzatGmj/fv3u7YoAAAAAADgcgEBAfriiy8UHBzs7lLMmjVrlmG8Ro0aqlixoktq6Nevn2HcXG2Z2e3btzVy5Eg1bdpUly9fNlwmLCxMCxculJ+fn4urc5wnnnhCOXLkMIm//PLL+vXXX03iVapUUZ06dVxRGgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8DLxfzomz80rjsmTlSxdulSfffaZ4djTTz+tLl26uLagDMydO1dpaWkm8QYNGqh06dJW5YqKijKJpaWlad68ebaWl+X4+PiYHTN6n9whd+7ceuyxx0ziN27c0NKlS23OO3v2bMP4oEGDbM5pq++++84w3rdvX/Xo0cPF1QDGGjdurF9++cXhP5UrV7ZofvYT97hx44ZhPE+ePBat/+ijjxrGd+3aZXNN7lK5cmXt3r1bZcuWNRxftGiROnTooISEBBdXljl4Q0/yIJcuXVKbNm00ZswYd5diFr24eadOnXJ3CWZ5Yz+c1bY1T+1TKlSoYBg3V689zp07p7Nnz5rEfX19Va5cOYfPlxktWbLEMG7pNZ0OHTqYnE9Xr15t+P9/q1mzpgoWLPjA3EFBQWrTpo1JfM2aNUpMTLSoPmeyt2d9kK1btzokz9/Kly9vGN+9e7dD55GkixcvGsYfeeQRh89lqx07djg85w8//GB4HipRooQCAwMdPp+7OHvbz4xceW6UnHt+dPSxyVKO/Dx/6dIlw/j333/v9Dly5crlsDlcyVP7Tlfavn27w3Ma7aeS5cdTbzu20Hd6Jk/ctgEAAAB4H193FwAAAAAAAAAAAAAAwN+Cg4O1evVq5c2b934sJSVF7733nkqUKKEqVaqob9++ev/99++Pb9y4UeHh4cqVK5fCw8NN/uFRuXLltHbtWvn7+5udt02bNnrzzTfTxfbt26c2bdooX7586tixo55//nmNHDlSo0aN0tChQ9WhQwcVKFBAvXr10rlz59KtO2TIEHXq1MmOV8JUTEyMatasaffPBx98kC5vUlKSPv/88wfOX6lSJX366afp/jA8Li5OTz31lPLmzauIiAgNHjxYo0eP1ogRIzRgwADVrVtXxYsX18KFC9Plat68uYYNG5bhfN7wngAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkBW89NJLGjNmjOFYQkKC2rVrp71797q4KgAAAAAA4C6PPPKI3nvvPXeXYdYXX3yhxMREw7G+ffs6ff7KlSuratWqJvHExEQtWrTI6fN7qp07d6pRo0Y6d+6c4XjNmjX1yiuvuLgqx4mOjjaJxcXFacWKFZo9e7bhOs8884yzywIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAF7o9M+OyXPGQXmymsGDB+vUqVOGY7NmzVLBggVdXJGxM2fOaPPmzYZj1tx3rWLFiqpevbpJfNOmTfr9999tri+ryZYtm2E8NTVVd+/edXE1xqKiogzrXLRokdl7+Fli3rx5unfvnkm8ZMmSat26tc15bfHdd9/p6tWrJnFfX199+eWXmj9/vuH9AgFXCg0NVaVKlRz+ExwcbNH87CeuU7BgQTVs2FB9+vRRnjx5DJcJDAy0KFe5cuUM4z//7F0NX6NGjbR9+3YVKlTIcPzWrVsaPHiwx5w7vZE39CTm/Pnnn3r11VdVpkwZbdy40d3lZCiz9OI9e/aUj4+PQ38uXLjg9Lpt5Y39cGbZ1izlqX3Ko48+ahj/6aefnDLfvn37rKoD6a1cuVJJSUkm8Y4dO8rX1/eB63fq1Mkw599iY2NN9hsfHx916NDhgbnDw8OVI0cOk/hXX331wHWdxZE964N8//33Dsnzt0ceecQwfubMGYfOI0nXrl0zjOfOndvhc9nq2LFjDs9548YNw9fT19dXpUqVcvh8ruTKbT8zcvW5UXLe+dHRxyZLOXKfjY+PN4wfPXrU6XPkypXLYXO4kqf2na505MgRh+e8ceOGYdzS7cTbji30nZ7JE7dtAAAAAN7nwZ/qAAAAAAAAAAAAAABwkZdeeindP+SJj49XixYtNGzYMIv+gejmzZvVpEkTDR48WGlpaffjNWvW1OjRow3X8fHx0bvvvisfH5/7sblz56pOnTqKiYlJl+ff7t69q0WLFqlatWrav39/urGJEyc+sF5rXL9+XT/99JNdP7/99pt69OiRLu/06dMtem0//fRTBQQE3H/822+/qUKFCpozZ06G/3D53Llz6t27tyZPnpwuPmLECMM/BJe85z0BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACCzi46O1pQpUwzH7ty5o4iICO3cudPFVQEAAAAAAFfZunWrYXzQoEGKiIhwbTEWunHjhr7++mvDsd69e8vHx8ep80dFRRnGly9frhs3bjh1bk93/PhxdejQQQkJCYbjr7/+uh566CEXV2W/2rVrq2rVqibxzz//XMnJyZo/f77u3r1rMt6zZ0+FhYW5okQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOBFDm2S0tLsy3Fmv3TrqkPKyXJu3bqlJ554Qvfu3TMZe+ihhzR//nw3VGVs9uzZhvE+ffpYnMPc/dPM5Yax4OBgw/idO3dcXIl5gwYNMozPmjXLrrwXLlzQhg0bDMeio6Ptym2tu3fvauLEiYZjPj4+6tu3r/bv36+zZ89q+fLlGjdunKKiotSwYUMVKFDApbUC7mLNfsI+krGgoCCVK1dO7du315AhQzR16lStWrVKBw8e1O3bt3Xx4kV99913+uyzz1SqVCm75sqTJ49h/MqVK3bldaWIiAht3LhRuXLlMrtMSEiIPvnkE9cVlQl5Q0/yTykpKVq8eLG6du2qYsWKafLkyWbvXetp6MW9j7f2w1lpW/PUfj5fvnyGcWedh//880/DeN68eZ0yX2YTHx+vmJgYk3iePHnUqFGjDNcNDAxUeHh4utgff/yhH374IV1s1apVJutact/+Ll26mMRu376ttWvXPnBdW7myZ32QAwcOODRf7ty5TWJ37txRXFycQ+eR/rpeaCQ0NNThc9nqzJkzTslr7vU0ev09iSdt+5mRq8+NkvPOj44+NlnqwoULDstl7hh16dIlh80RHx9vGPf19XXYHK7kqX2nK50/f97hOW/evGkYt3Q78bZjC32nZ/LEbRsAAACA9/F3dwEAAAAAAAAAAAAAAPxtwIAB6R4/99xz2rFjh9V5PvroI6WmpmrGjBn3Y8OGDdP06dNN/mg7LS1NL7zwgl599VWFh4dr7969GjBggFJTUy2e7+rVq3r88cd18OBBBQYGSpIqVKigatWqaf/+/VbX7yzDhg1L9w8Frl27pvHjxz9wvcjISNWvX//+47i4OLVu3VqXL1+2eO7XX39drVu3VvHixbVo0SLNmzfP7D+0z0rvCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnqpPnz766KOPDMeSkpLUpUsXffvtty6uCgAAAAAAuNLzzz+vVatWqUSJEiZjs2fPVuXKlXX58mXXF/YAs2bNUmRkpEm8cOHCatmypTZt2uSUeX19ffXEE0+YrQlSbGyshg4davh6hIaG6rXXXtPw4cPdUJntoqOjDeN/P8crV65ozZo16tq1a7rx4OBg9enTRx988IHTawQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN7j8nHptx1S+Sa2rZ+WKm2b49iasprdu3drwoQJGjVqlMlY69at9fzzz2vatGluqCy9r7/+WteuXVPu3LnTxUuWLKmGDRtq586dGa7v6+ur3r17m8SvXbumr7/+2qG1ZnZ58+Y1jN+8edPFlRhr3LixypcvbxKPjY3Vvn377M4/c+ZMtW/f3iQeERGhQoUK6eLFi3bPYanp06era9euatiwodllihYtqqJFi5rcIy4hIUEnTpzQ8ePHdfz4cR07dkwHDhxQbGyskpKSnF064DKW7icjR45MF8uq+0jhwoVVs2ZNValSRWXKlFGpUqVUunRpFS5cWD4+Pk6fP3v27PL19TWJJyUlec3r3r9/f82cOVN+fn4PXLZHjx568sknNWcODa0tXNGTXLhwwep8OXPmVOHChU3ifn5+mjJlikP6EVejF/cu3twPZ7VtzdP6+eDgYMPzV1JSkhITE23K+SDXrl0zjIeGhjplvsxoyZIlioiIMIl36dJF27dvN7teixYtlCNHjnSxNWvWKC0tLV1s1apVGjJkSLpYq1atFBQUZHZb8/HxMaxp7dq1unPnjtmaLOXuntUSV69edViu7NmzGz6v4OBgh7ye/2buNQwKCnL4XLZy1jWo69evG8ZDQkKcMp+1vGHbz2zccW6UnHd+dOSxyRoJCQkOy5Wamuq2ObyZp/WdrhYfH+/wnPZsJ956bMmKfaen87RtGwAAAIB38nd3AQAAAAAAAAAAAAAASFKxYsX08MMP33985coVLViwwOZ8H3/8saKiolSvXj3t3btX//vf/xQXF2e47KZNm7Rp0ybVqFFDaWlpunfvntXzHTt2TDExMerYseP9WN26dbV//35bn4JD5cuXT8OHD08XGz9+vNl/UPVPAwYMSPd47Nix+v33362aPzU1VR07dtSVK1eUnJz8wOWzwnsCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICn6t69u+bOnSsfHx+Tsbt376pHjx6KiYlxQ2WmQkND5e/vr1u3bunu3bvuLidLCwgIUEhIiFJTU3Xz5k2lpaW5uySv4ufnp9DQUPn4+LA9mxEUFKQcOXIoOTlZt27dcnc5FgsODlZwcLBu376txMREp8zh7++v0NBQJSYm6s6dO06Zw14cr/9PVtnf/972U1NTdePGDc4L/x/7gm143WzD6/Z/vOWY9He/c+fOHY89p7vK36+FM3soe2WV9+vGjRt64okntH37dvn5+aUby5cvn+bOnav27du7qTrztmzZotOnT6tEiRImY1FRUdq0aZNT5m3VqpUKFixoEj99+rS+/fZbp8zpjWbPnq2oqCg1btzYZOzpp5/WqFGjPHbf/7ecOXPqP//5j0l87969+uWXX+4/njVrlrp27WqyXHR0tD744AOn1ugO3vC5x1uvM8D7eOu25sn9mDccYzILb91+beUtnx0lz/+djKfXl5WumWSl55oRb9q/3YntBQAAAAAAAAAAAAAAAAAAAAAAAAAAAPAsG6ZJ+UtLeYpYv+62OdKlo46vKat566231KZNG9WpU8dkbPLkydq8ebMOHTrkhsr+T1JSkr744gsNHjzYZCwqKko7d+7McP3w8HAVKlTIJL5w4UIlJyc7rM6soHDhwobxc+fOubgSY9HR0YbxmTNnOiT/mjVr9Mcffyh//vzp4v7+/nryySc1fvx4h8xjieTkZHXu3FkbN25U9erVrVo3R44cqlKliqpUqZIunpKSom3btmnhwoVavHhxpr4PJbIGW/eTrLSPVKxYUX379lXPnj1VvHhxt9aSI0cOw/jNmzddXInt5syZY9Xy06dP186dO/Xbb785qaLMyxU9yYsvvqglS5ZYtU7u3Ll18uRJ5cqVK13cx8dHU6dONbxPraejF/cu3twPZ7VtzdP6eXech69du2YYz5kzp9PmzGxWrVql5ORkBQYGpot37txZw4YNM7teRESESWzlypUmsa1btyo+Pl6hoaH3Y9mzZ1ezZs20YcMGw9z16tVTgQIFTOLWnlP/yZN6VkvcuHHDYbnM7ZuSlC1bNofN401u377tlLzm3reQkBCnzGcJb9v2Mxt3fUZ11vnRkccma7ji3q+e2Ot5Ek/rO13N0+4/7K3HlqzSd3oTT9u2AQAAAHgnf3cXAAAAAAAAAAAAAACAJBUpkv7OUwcPHlRqaqpdOQcNGqSQkBDt2rXLouV/+uknu+bbv3+/OnbseP/xv5+TO40ePTrdH2v//vvvmj59+gPXK1asmJo1a3b/8ZUrV/TRRx/ZVMP58+etXiczvycAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHiidu3aadGiRfLz8zMZu3fvniIjI7V69WqX1xUUFKQ2bdqoTZs2qlq1qh599FHlzp1bPj4+95dJTk7WmTNndPDgQe3atUsrVqzQ8ePHbZ6zcOHCypUrl0k8ISFBZ86csTlvRvz9/fXII4+YxFNTU/Xrr786ZU5bVKtWTR07dlStWrVUuXJlFSlSREFBQffH09LSdPPmTR0+fFj79u3T2rVrFRMTo3v37tk8Z/78+ZU3b16T+OXLl3X16lWb8/6bj4+PHn30UZO4I9+DOnXqqGXLlqpTp46qVaumvHnzKiQkJN0yycnJOn/+vA4ePKiff/5Za9as0d69e62eK2/evMqfP7/Z8YcfftgwHhYWpgoVKlg1V3Jysl373D9VqlRJnTt3Vp06dVSlShUVKVJEAQEB98fT0tJ07do1HTp0SLGxsYqJiVFMTIwSExMdMv8/Gb0OGW13LVq0UM+ePVW/fn2VK1dOgYGB98dSUlL0+++/a//+/dqyZYu++uor/fHHH1bXVL16dfXq1UsNGjRQ5cqV03137e3bt3XlyhXFxsZq3bp1Wrt2rdOOWUbccbz+N2vfs7/rrlKlisqUKaOwsDCFhober3natGk2b1uu3N/dJSAgQM2bN1fbtm1VpUoVVaxYUfny5UvXS6Slpen69euKi4vTgQMHtG3bNm3btk0HDhxwaC2Ofu8l299/T9gXvJEn9XzXrl3TxYsXbc6bkTx58qhgwYIm8atXr+ry5ctW5/OE7c1T9j9POiY9SOHChfXYY4+pUaNGql69uh5++OF0fcO9e/d04cIFHTp0SLt27dKqVavM1ujv7688efKYxOPi4pSSkmJxTeb6v8OHD1ucw1yejLaHPHnyqEePHmrRooWqV6+u4sWLp3st/u5vjhw5oo0bNyomJkYHDx60qiZ7eeL75Uq7du3SxIkTNXLkSJOxdu3aafDgwfrwww/dUFnG5s6dq7feessk3q1bN0VHRyshIcHhc/br188wPmfOHIfP5e3eeOMNbd++3SSeK1cuPfbYY/r888/dUJX1evfurezZs5vEZ82ale7x+vXrdf78eRUpUiRdvGLFimrQoIF27drl1DqdyRs+91hyneG7775z+jUGR/D0a2SeeC3KUT2OJTzlmlZm6se84RhjxFX7Qma9Juts3vTZUXLP72QyS32ecM3EVTzluf77GObq60Pu2L89sf95EE/ZXgAAAAAAAAAAAAAAAAAAAAAAAAAAAABkLOmWtHSk9Ng4KU9Ry9f7fon0w1Ln1ZWV3Lt3T7169dKBAweUI0eOdGNBQUFatGiRatWqpeTkZDdV+JfZs2dr8ODBJvHHH39czz33nJKSksyuGxUVZTYnrGN0f3lJOnfunIsrMZUnTx51797dJJ6UlKSFCxc6ZI6UlBR99tlnevnll03GBg4cqAkTJigtLc0hc1ni6tWrql+/vv73v/9p0KBBht+9YA1/f3+1bNlSLVu21Ntvv62RI0dq7ty5DqoWWc2NGzf0448/OjyvtffZdOR+kpn2keLFi2vixIn6z3/+k+6eLO5krg5X3WvKWTZv3qz3339fK1askK+vb7qx7Nmz68svv1SdOnXc3mt5G0/tSa5du6axY8fqf//7n8lYo0aN1L17dy1btswNldmHXtw7ZIZ+OKtta57Uz//7HPU3Z56HzeX2lN7EG9y8eVMxMTHq2LFjunipUqVUsWJFHTp0yHC9fy+fmJiojRs3mix39+5drV+/Xj169EgXj4iI0IYNGwxzd+nSxSR2584drV27NqOnYsgTe1ZL3Lx502G5vOl5u4qzrrt40jHJW7f9zMYd58aM8tu7LTjy2ORpXHk91lt5Ut+Z1XnrsSWz950AAAAAkFX5u7sAAAAAAAAAAAAAAAAkKSAgIN3jxMREu3PGxsbancMa169fT/c4ODjYpfObU6pUKQ0aNChdbOTIkRbd3KBjx47p/uh85cqVunv3rsNrdBZPfU8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPBEzZo10/Lly02+Z1KSUlNT1bdvXy1btsylNRUrVkyvv/66+vTpo5CQkAyXDQwMVNmyZVW2bFl17dpV77zzjvbu3asJEyZoxYoVVs/drl07zZo1yyR+/fp1FSxYUElJSVbnfJAuXbroq6++MomvW7dO7du3d/h81siePbsGDBigoUOHqmTJkhku6+Pjo7CwMNWvX1/169fXkCFDdOXKFU2dOlXvvfee7ty5Y/X8L774ol577TWT+KuvvqrJkydbnc+c4OBgHTp0yCR+69YthYaG2pw3ICBA0dHRio6OVoUKFR64fGBgoEqWLKmSJUsqIiJCo0eP1rlz5zRt2jR98sknunnzpkXzPvvss3rrrbesrrdVq1aGr0NGduzYoSZNmlg9198CAgIUFRWll19+WeXKlctwWR8fH+XJk0eNGzdW48aNNXjwYCUkJOjzzz/XpEmTdOrUKZvr+Dej18Fou2vTpo2mTp2q8uXLm83l7++vUqVKqVSpUurWrZvef/99ffbZZxo1apTOnz//wFrq1aunqVOnqm7dumaXyZ49u4oXL67ixYsrIiJCqamp+uKLLzRy5EidOXPmgXPYyp3H63+z9D3z9fVVjx49NGDAADVt2lT+/v6G+WbNmmXVdy67a393tYIFC+rll1/WgAEDlDNnzgyX9fHxUe7cuZU7d26VLl1a3bp1kyTt3btXEydO1IoVK5SWlmZ3TY5+7yXr339P2he8iSf2fIcOHVKlSpWszmeJjz76SD179jSJd+/eXcuXL7c6lydsb+7e/zzxmGROnTp1NG7cOLVq1Srd98j/m5+fn4oVK6ZixYqpbdu2Gjt2rH788UeNGzdOq1atSrdsgwYNtG3bNpMcdevW1Q8//GBxbeb6v4zqtDSP0fZQuHBhjR07Vn379jX8HPq3f/Y3bdu2lfRX7zl69Ght3brVqtqs5cnvl6u9+eabatOmjWrXrm0yNmXKFG3ZskVHjhxxQ2XmzZ07V2PGjJGvr2+6ePbs2dWtWzctWLDAofOFhoaqc+fOJvHU1FTNmzfPoXNlBjt27NBPP/2kGjVqmIw99thj+vzzz91QlfUGDRpkErt9+7YWLVqULpaamqr58+drxIgRJstHR0dr165dTqvRGbzhc4+11xlccY3BETz9GpknXotyVI9jjide0/L2fswbjjEP4qp9IbNek3UWb/rs6O7fyXh7fVnpGp2nPdd/H8NcdX3Infu3J/Y/5nja9gIAAAAAAAAAAAAAAAAAAAAAAAAAAADgwa5flBa8ILUaLD3aTMrotim34qRvP5GOmN7qDHY4ceKEhg4danjvysqVK+u///2vhg0b5obK/s/PP/+s/fv3q1q1auniYWFh6tSpk+F9zyUpJCREXbt2NYnv379f+/fvd0KlmVvVqlUN44cPH3ZxJaaioqIUFBRkEt+7d6/Kli3rsHl++eUXw/jDDz+stm3bat26dQ6byxJJSUkaPHiw3n//fb3++uvq1q3bA+9NYYnChQtrzpw5atWqlfr37++U7yxA5rZz507D+3u6gzP2E2/eR8LDw/XVV18pV65cNueIi4vTsWPHdOzYMf3222/3///DDz9UvXr1HFesl/vyyy/Vp08f3b17V++8845effVVk2WqVq2qyZMn64UXXnB9gV7Mk3uSDz74QIMHD1bp0qVNxt555x2tXr1aycnJbqjMdvTi3iEz9MNZcVujn4e9lixZoo4dO5rEu3TpYngvwCpVqujhhx9OF9u8ebPZ+2auWrVKPXr0SBeLiIjQkCFDDJc3uof9unXrlJCQYPY5GPHmntWZ93JF5ufN2z48G8cm0HfCXpm17wQAAACArMz8tykBAAAAAAAAAAAAAOBC165dS/c4f/78bqrEdrlz5073OD4+3k2VpDdx4kQFBATcf3zgwAF9/vnnFq1bo0aNdI9Xr17t0NqczVPfEwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMCTBWaXfHzdXQVgXtItd1cAAACQOdWrV0+rV69WtmzZTMbS0tL09NNP64svvnBZPQEBAXrzzTc1fPjwdN/LaK3atWvr66+/1nfffaeoqCidPHnS4nUXL16sqVOnKiQkJF08V65c6tSpk7766iub6zKnd+/ehvE5c+Y4fC5rREZG6v3331e+fPlszpEvXz6NHz9ezz77rIoWLerA6jxfw4YN9emnn6pChQp25SlatKgmT56s119/XS+++KLmz5/voAod49ChQzav27p1a3366acqXry4zTly5MihQYMG6emnn9a0adM0YsQIJSYm2pzPUn5+fpo6daqGDBli07r9+/dXt27d9MQTT+ibb74xXM7X11eTJ0/WsGHD5OPjY9Ucvr6+6t27tx5//HENGjRI8+bNs7rOjHjC8doW5cuX12effabatWs7NG9W2N99fHz00ksvady4cYZ9gzVq166t5cuXa/fu3erevbsuXrzooCrNc9Z77637grt5wuu2ePFivffeewoNDU0Xr1ixomrWrKl9+/bZXJeRsLAwde7c2ST+xx9/aNWqVRbn+fu1e+aZZ2yuJTMce73pmBQaGqoZM2boiSeesDlHrVq1tHLlSi1fvlwDBgxQXFycAyt0rV69eunTTz9Vjhw5bFq/cePG+vbbb7Vs2TJFRUUpISHBofXxfpm6d++eevXqpf3795u8b9myZdOiRYtUu3Zt3b17100Vmjp79qw2b96sVq1amYxFRUVpwYIFDp2vR48eCg4ONolv2rRJZ8+edehcmcXcuXNVo0YNk3h4eLgCAwOVnJzshqosV7duXVWpUsUkvnTpUsXHx5vEZ8+erddff93kc12PHj00dOhQXbt2zWm1OpI3fO6x9zqDu64xwDr2XItyFG++puWp/Zg3HGM8SVa9Jmstb/rsKDn+dzJ9+/bVli1bskR9nnCtyVW89bk6+vqQt+3f9rL1uO+t2wsAAAAAAAAAAAAAAAAAAAAAAAAAAACAvyTdktZMkn5YKlVoIZWoLoXmlQKySbevS1dOS8f3SIc3S3eT3F1t5jR79mx17NhRXbp0MRl74YUXtHbtWm3atMn1hf3D7NmzNX36dJN4VFSU2fupP/bYY4b3T5s1a5bD68vsgoODVb16dcMxR9/b1BaDBg0yjDdq1Ejff/+9S2p45plntG7dOpfM9W9Hjx5V//79NWjQIDVr1ky1a9dWzZo1Vb58eZUqVUpBQUE25Y2MjFRoaKgiIiIcXDEkWX0/dtjH3H7Svn37LLOPtGvXTqtXr5afn98Dl71165aOHj2qo0eP6tixY+n+a+7ekvbcoys1NdUw7u/vb3NOd/rggw/0/PPPKy0tTZI0cuRItWzZUrVq1TJZdujQoYqJidHatWtdXaZX8vSe5O7du3r11Ve1dOlSk7GSJUtq6NCheuedd9xQmX3oxT1fZumHs+q25u5+/t69e4ZxZ56Hzd0zzlwtMLZy5UolJycrMDAwXbxLly4aP368yfIdO3Y0zGHO2rVrde/evXT948MPP6yKFSua3DuwXLlyKleunEkOa78Dz5N7Vlf7u5f8t+vXr2vx4sUuq+Pq1asum+tBAgICnPJdEf/eh/7mymMS275ncce5UeL8COdzd9+Z1XnzsSUz9p0AAAAAkNV5519jAAAAAAAAAAAAAAAynfPnzystLe3+DTiqVq2qPHnyKC4uzs2VWa5mzZrpHh89etRNlfyfmjVrqkePHulir7zyitl/tPZv1apVS/f4wIEDjirNJTzxPQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA83ZMfSznzu7sKwLyp3aTk2+6uAgAAuEPO/FLxalJoXikgm3T7unTljHQ2Vrp3193Vebdq1app3bp1CgkJMRwfPHiw5s6d67J6ihYtqtWrV5t8r6I9GjVqpNjYWPXs2VPffPONReskJCRo0aJFGjBggMlYv3799NVXXzmsPknKlSuX2rVrZxKPi4vTqlWrHDqXpYKDg7VgwQJ1797dYTmLFCmiV155RZMnT3ZYTk8WFRWl2bNny8/Pz2E5c+fOrXnz5qlz586KjIxUUlKSw3Lb49ChQ1av4+vrq+nTp+vZZ591WB1+fn568cUX1bFjR3Xq1Em//vqrw3L/m6+vr5YtW6bOnTvblScsLEyrV69Wr169tHjx4nRjgYGBWrlypdq2bWvXHIGBgZo7d66KFSumcePG2ZXrb55yvLZW3bp1tX79euXKlcuhebPC/p4zZ06tXLlSzZo1c2je+vXr66efflKXLl30/fffOzT3PznrvffWfcHdPOV1S0hI0OLFiw17vv79+2vfvn0Oq0+SevbsqWzZspnE582bp5SUFItyOPq189ZjrzcdkypUqKA1a9aoZMmSDsnXrVs3VahQQS1atNDFixcdktOV3n77bb3xxhsOydW9e3eVK1dOEREROn36tENy8n6Zd/z4cb3wwguaOXOmyVjVqlU1fvx4vfLKK26ozLzZs2erVatWJvHmzZuraNGiOnfunMPmioqKMlsDjK1evVrTp083iefIkUO1atXSrl273FCV5aKjow3jRvuIJJ08eVJbt25V8+bN08WzZcumqKgoTZ061dElOpynf+5x9HUGV15jgPVsuRblKN5+TctT+zFPP8Z4oqx4TdZa3vTZ0Vm/k9m4caNef/11u38v4+n1ecq1Jlfw1ufq6OtD3rR/O4otx31v3V4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAmPrjxF8/cI+nn35adevWVaFChdLFfXx8NH/+fFWuXFlxcXFuqk5auHChpkyZoqCgoHTxNm3aKF++fLpy5YrJOv369TOJJSUl6YsvvnBWmZlW06ZNTV77v/3www8uria9pk2bqly5cm6tQZLat2/v8HsAWis5OVkxMTGKiYm5H/Px8VHRokVVpkwZlSlTRmXLlr3//2XKlFFwcHCGOTt27KgRI0ZowoQJzi4/y3nQaw/n+Pd+klX2kRIlSuiLL74wex+0q1evatmyZdq4caP27t2rM2fOWD2Hj4+PzfUlJiYaxsPCwmzO6S4jRozQxIkT08VSUlIUGRmp/fv3K0eOHCbrzJs3T1WqVNGlS5dcVabX8uSe5G/Lli3Tzp071bBhQ5OxkSNHat68eYa9qyejF/dsmakfzurbmrv6+Vu3bhnGHf29J/+UJ08ew/jNmzedNmdmdPPmTW3cuFEdOnRIF69Zs6YKFy6sCxcupIt36tQp3eO0tDStWbPGbP64uDjt3LlTTZo0SRePiIgwuXeg0XdbJSYmZpj/3zy9Z3U1cz3yrVu39Mwzz7i4Gs8QFhamP//80+F5zR3vzB0fHY1t3/O449wocX6E63Ad2T28+diS2fpOAAAAAIDk6+4CAAAAAAAAAAAAAACQpGvXrqX7o2F/f3+NHTvWjRVZp3z58goPD7//+O7du9q4caMbK/rLO++8k+4fFG3evDndPyJ4kEcfffT+/9++fdvwHzRlz55djRo1Ur9+/fT888/rhRde0FNPPaXw8HDlzZvXvidgB099TwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1ilSQYqcIkV/JrUbJjXqK9V9XGo+UHp8vPTcEqlJfykwu7sr9U7ly5dXTEyMcuXKZTj+4osvasaMGS6rp2zZstq1a5eqVatm0fIpKSm6c+eORcvmyJFDK1asUM+ePS2u59NPPzWMt2nTRgULFrQ4jyV69OihwMBAk/gXX3yh5ORkh85liTx58mjr1q3q3r27w3NPmjRJb7zxhsPzepr+/ftr7ty58vPzs2j5O3fu6Pbt20pLS7No+a5du2rDhg0KCgqyp0yH+ef301oiW7ZsWrlypZ599lmn1PP38aRhw4ZOyS9JM2bMUOfOnR2Sy8fHR/Pnz1fdunXTxRcvXqy2bds6ZA5JGjt2rHr37m13Hk87XluqVKlSWr9+vdnznq2ywv6eO3dubd26Vc2aNbNo+dTUVCUkJCglJcWi5QsWLKg1a9aoWLFidlRpnrPee2/dF9zN0143cz1fr169DPsze/Tv398wPnPmTIvWt+a185TtzRn7nzcdk6pWrapt27apZMmSduf6p/Lly2vz5s3KkSOHQ/M62xtvvOHwzwKVKlVSTEyMQkND7c7F+/Vgs2bN0sqVKw3HXn75ZTVv3tzFFWXs66+/1rVr10zivr6+euKJJxw2T4kSJdS4cWOTeFxcnFasWOGweTKbM2fO6OTJk4ZjNWrUcHE11gkLCzM8bx47dkzfffed2fVmzZplGI+OjnZYbc7i6Z97nHmdwRXXGGA9a69FOYq3X9Py1H7M048xniorXpO1hjd9dnTm72R8fX3t/r2Mp9fnadeanMlbn6ujrw950/7tSNYe9711ewEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAT3T16lX169fP8J4nhQsXtvi+ks5y7do1w/ue+fv7KzIy0iT+8MMPq0mTJiZxc/dvQ8bM3dvu4MGDOn/+vIurSc9T7nPm5+enp59+2t1lmEhLS9PZs2f17bffaubMmXrllVfUrVs3ValSRTly5FC5cuU0dOhQHTlyxGyO119/XXny5HFh1Z7J0ntIWcoR9xmF/bLKPjJhwgTD++PcunVLzz33nAoXLqxBgwZp6dKlOnPmjE1zhISE2FyfufuuBQQEKDg42Oa8rnTv3j099dRTmjhxouH48ePH9dxzzxmO5cuXTwsWLHBmeZmGJ/ck//Tiiy8abtM5c+bUuHHj3FCRfejFPVtm6ofZ1ky5oldJSkoyvI+dv7+/0+47nzt3bsN4fHy8U+bLzJYsWWIS8/HxUadOndLF8uXLpzp16qSL7du3TxcvXsww/6pVq0xiERERJrEuXbqYxDZs2KBbt25lmP+fPL1ndTVzPbKnf/ZwJkd/J9OD8lqz/dqDbd/zuOPcKHF+hHtllWtk7uTtx5bM1HcCAAAAACRfdxcAAAAAAAAAAAAAAMDf5s2bl+7x4MGDNW7cOIff5MPR8uXLp6VLl8rf3/9+bO7cubp69aobq5LatGmj5s2b33+clpam4cOHW7y+n59fuj9y//cfg4eHh2vNmjW6du2aduzYoblz5+r999/Xe++9p1mzZmnjxo36448/tGfPHkVFRaV7fZzNU98TAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIB1GvaRer0rFatkfpnAYKleT6n/DClvCZeVlimUKlVKmzdvVr58+QzHX3/9dU2dOtVl9eTJk0cxMTEqVqyY2WViY2P1xhtvqHbt2sqTJ48CAgKUPXt2BQUFqUiRIurcubM+/PBDXb9+3XB9f39/zZ8/X3Xr1rWoph9//FEHDhwwifv5+emJJ56wKIelevfubRifM2eOQ+exRGBgoFavXq06deqYXebevXvavn27XnvtNYWHh6ty5coqXLiwihQpogoVKqhz58569913deHCBcP13377bfXs2dNZT8HtSpUqpQ8++EA+Pj6G4xcuXNCUKVPUqlUrFSpUSH5+fsqePbty5MghX19fPfTQQ6pfv76GDx+uPXv2mJ2nadOmmjZtmtnxc+fOac+ePWZ/jh07ZrheXFxchusZ/Rw8eNCq12jBggXq2LGj2fHU1FTt3LlTr732mlq2bKmKFSuqUKFCKl26tBo0aKC+fftq8eLFZvd3ScqdO7e++eYbPfroo1bVZolu3bpp4MCBJvGTJ09qzJgxatasmUqWLKlChQqpYsWKCg8P14QJE3T06FGzOQMDAzV79uz738v60ksvqWvXribLXb9+XR9//LE6deqkRx55RIUKFVLZsmXVqFEjvfDCC9q2bVuGtX/00UcqWbKklc/4/3ji8doSfn5+Wr58uXLlyuWwnJLn7O/OtnDhQlWvXt3s+I4dOzR06FDVqlVLOXPmlJ+fn0JCQhQQEKCcOXOqatWqGjp0qPbt22c2R968ebVs2TIFBAQ4tHZnvffeui+4mye+bj/++KP2799vEs+dO7c6depkUQ5LlCtXTvXq1TOJb926VcePH3/g+g967Txxe3PW/uctx6SCBQtq/fr1yps3r9llEhMTtXbtWj3zzDNq1qyZHn30URUsWPB+zxMZGanPPvvM8HvaH330Uc2YMcPm+lwtPDxcY8eONYmnpaVp27ZtevHFF9W4cWOVKlVKBQsW1COPPKKGDRtqyJAhWrt2re7du2c2d9myZTV//ny76uP9stxTTz2lS5cumcR9fHz02WefOXyft0dycrIWLlxoONavXz+HzdOnTx/DfnDhwoVKTk522DyZ0c8//2wYr1GjhosrsU6fPn0UHBxsEp81a1aG6y1btszwXFyuXDk1adLEUeU5nDd87rH3OoM7rzFkJp58LcpRvPmalqf2Y95wjLGWq/aFrHZN1lre8tnRFb+TkWz/vYyn1+eJ15qcxVufqzOuD3nS/u2p/Y+3bi8AAAAAAAAAAAAAAAAAAAAAAAAAAAAA4MliYmI0ffp0w7Fu3bo59P5mtpg9e7ZhPCoqyiRm7v5p5nLAvDx58qhbt26GY998842Lq0kvb968Zmtzh6efflq+vr7uLsNiaWlpOnr0qKZNm6aKFSvqrbfeMlwuJCRETz/9tIurcx9z96MKDQ116DwZ3TcDniGz7CMlSpQwvP9RUlKSwsPD9cEHHzjk3qIZ3fP2QVJTU3X58mXDsQIFCtic15W6dev2wO9emTt3rpYuXWo4Fh4eruHDhzujtEzDk3uSf9u7d68WL15sOPb000+rYsWKLq7IfvTinikz9sNsa5ZzZK9y/vx5w3jBggXtrtOavEb3hkfGVq5cadjLdenSJd3jDh06mOwvK1eufGD+VatWmcTq1aunhx566P7jAgUKGH5PyZIlSx6Y/2/e0LO62r1793TlyhWTePbs2ZUtWzY3VOR+zvpsYC7vn3/+6ZT5/olt33O5+tyYUW7Oj3C3zHKNzBN487Els/SdAAAAAIC/eM9fuAEAAAAAAAAAAAAAMr2PP/5Yp06dShcbOXKkDh06pOeff16lS5d2U2XGQkJCNHDgQB08eDDdPxo/dOiQXn75ZTdWJvn4+Gjy5MnpYosWLdLPP/9scY6cOXOme3zr1i1Jf/1j/1WrVmnjxo3q0KGDAgMDM6yjbt26mjdvnn7++WfVqFHDimdhPU9+TwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1gkfLDV8QvLxsWz5sAJS7/9JeUs4taxMo0iRItq8ebMKFy5sOD527Fj997//dWlNX375pUqUKGE4dvbsWfXo0UNVq1bVhAkT9OOPP+ratWv3x5OTk3XhwgWtWrVKQ4YMUfHixTVhwgSlpqaa5AoKCtLSpUuVI0cOi+qaOXOmYbxfv34WrW+JokWLqnHjxibxAwcOWPV9lI4yY8YMNWjQwOz40qVLVaFCBTVt2lSTJk3S5s2bdfDgQV28eFEXLlzQkSNHtGrVKr388ssqXry4XnzxRd25c8ckzyeffKKiRYs686m4zdSpU5U9e3aTeGpqqkaOHKlSpUpp+PDh2rRpky5dumSyrcbFxWnPnj2aMmWK6tevr4YNGyo2NtZwroEDB6pVq1aGY3PmzFH9+vXN/rz22muG623ZsiXD9Yx+rly5YvHrM2rUKD322GNmx9evX69q1aqpUaNGmjRpkrZs2aLDhw/r0qVLOnnypHbv3q0FCxYoMjJSRYsW1ejRo+9//+q/hYWF6ZtvvjH5vlZ7ZM+eXdOnT08Xi4+P18CBA1W2bFmNHTtW27Zt0+nTp3Xp0iUdPnxYmzdv1htvvKFHH31Uzz//vJKSkgxzV6xYUU8++aRKly6tCRMmpBtLS0vTe++9p+LFi+uZZ57R6tWrdezYMV26dEnHjx/Xzp079f7776tZs2Zq3bq1zpw5YzhHaGiopkyZYvPz99Tj9YMMGTJEVatWNYlfu3ZN8+bN02OPPaZy5copV65c8vHxuf8TFxeXYV5P2d+d6bnnnlO7du0Mx3766SfVrVtXTZo00bRp07Rv3z7Fx8enWyY+Pl6xsbGaNm2aatWqpe7du+vmzZuG+WrXru3Qc6xk+3v/oPffW/cFd/PU1+3TTz81jPfv39+i9S1hbts2N/e/mXvtPHl7c8b+5y3HJB8fH3311VcqWLCg4Xhqaqpmzpyphx9+WB06dNDHH3+sbdu26ddff9Xly5fv9zyLFy9WVFSUChcurNdee82k5+nTp4/hZwlPky1bNs2aNUu+vr7p4t98840qV66sZs2aaerUqfruu+906tQpXb58WceOHdOuXbv04YcfqkOHDqpSpYo2b95sdo6uXbuqR48eNtXH+2Wdq1evql+/fkpLSzMZK1q0qD755BM3VGXerFmzDOPly5dXzZo1HTJHVFSUYXz27NkOyZ+ZHTp0yDBevHhxF1dinUGDBpnEUlJSNH/+/AzXS0pK0hdffGE4Fh0d7ZDanMHTP/c44jqDu64xZDaeei3KUbz5mpYn92Oefoyxhav2hax0TdZa3vLZUXLd72Qk234v4+n1eeq1Jmfw1ufq6OtDnrZ/e2r/463bCwAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4uldeeUUHDx40HJs+fbpKlSrl4or+z6ZNm/T777+bxGvUqKGKFSumixndP+3333/P8B4zMDZ8+HDDe+hI0rx581xbzL9ERUUpMDDQrTX8U5EiRdShQwd3l2GTtLQ0vfnmm/roo48Mx9u0aePiitznn/ep+CdH33OoXLlyDs0H5/LmfaR9+/Ym92iTpI8++kjff/+9Q+bw9fVV/vz57cph7nsHHHVvVWdbtWqVRcsNGDBAZ8+eNRwbP368atWq5ciyMhVP7kmMvPbaa0pMTDSJ+/n56b333nNDRfahF/dMmbEfZluzjb29yuHDhw3jdevWtbs2I3Xq1DGMm7ufN8y7ceOGNm3aZBJv3ry5QkND7z/u1KmTyTKW9C/Hjh3Tb7/9li7m6+ub7p6JERER8vnXFzEmJSVp9erVD8z/N2/pWV3N6HgoSZUqVXJxJZ7BGb1ykSJFVKBAAZP43bt3derUKYfP929s+57L1edGifMjvIM3XyPzBN58bMksfScAAAAA4C+mVyUBAAAAAAAAAAAAAHCThIQEdevWTdevX08XL1eunN5//30dP35cV69e1dy5c++PFSpUSAULFnRKPbVq1dLq1avT/axZs0abN2/WwYMHdf36dX3yySfp/sHOiRMn1L59e8XHxzulJkv17t1bVapUuf84OTlZb7zxhlU5wsLC0j1OSEhQwYIF9f333ysiIsLqmipVqqTvvvvO8I/NLeXN7wkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwHJV2ko1rP/qPAVml7q/9dd/YV7+/Pm1ZcsWlShRwnB85syZGjNmjEtr6t27t8LDww3Hdu7cqZo1a2rp0qUW57t586beeOMNdejQwfA7DYsWLaq33nrLolyff/657ty5YxKvVKmSqlevbnFNGenVq5d8fHxM4nPmzHFIfmuEh4frySefNBy7c+eOevTooR49eujo0aMW5UtJSdHUqVPVoEEDXblyJd1YWFiYxe+DN8mXL5/atWtnOBYZGanx48crKSnJqpy7du1S7dq1tXz5csPxsWPHWl2nu1SqVEmjRo0yHEtJSdGgQYPUrl07/fLLLxblS0hI0Lhx41S1alUdOXLEcJmSJUtq8uTJNtf8b0899ZQKFy58//Hp06dVo0YNzZw5U6mpqRmum5qaqunTp6tHjx5KSUkxXObFF1/UuHHjFBgYeD92584ddejQQcOGDdPNmzcfWOPGjRvVtGlTnT9/3nC8c+fOKlq06APz/JsnH68zkj17do0cOTJdLCkpSZMmTVLJkiXVv39/LVu2TEePHtWNGzcszpsV9vecOXOa7Qs+//xz1alTRz/88INVOZcvX66GDRuafa2HDx9ueF60hbPee2/dF9zNk1+3hQsX6vbt2ybxNm3aqFChQhbXZI6Pj4/69OljEo+Li9OyZcseuL65187dr1tGnLH/edMx6emnn1ajRo0Mx27duqXw8HANHDjQpEc2Jzk5WZMmTVKVKlV08uTJdGOvvfaa1fW52tNPP63ixYvff/x339exY0cdOnTIohyHDx9W69atNXfuXLPLvPLKKzbXx/tlnQ0bNuiDDz4wHHv88ccNj3nucuDAAf3888+GY1FRUXbnr1+/vkqXLm0S/+mnn3TgwAG782d2v//+u2Hcls8rrlK/fn1VqlTJJL527Vpdvnz5gevPmjXLMN69e3c99NBDdtfnaJ7+uceR1xnccY0B3sPbr2l5aj/m6ceYzMLbt19redNnR1f+Tkay/vcynl6fJ19rcjRvfa6Ovj7kTfu3O3nr9gIAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3iApKUm9evUyvC9KSEiIFi5cKD8/PzdUJqWlpWnevHmGY3379r3//3Xr1lXZsmVNlpk7d67S0tKcVV6mVLp0aQ0dOtRwbMeOHfr1119dXFF6gwYNMoz37t1bQUFBTv3ZtWuX4dzR0dHOfMpON3r0aMN7i9euXdsN1bjHtWvXDOMlS5Z06DxNmzZ1aD64hjfuI02aNDGML1682GFz1KxZU8HBwXbl2L9/v2G8fv36duX1NNevX1fv3r0Nv/MhICBAixcvVkhIiBsq82ye3pMY+f333zV16lTDsVatWql9+/auLchO9OKeKTP2w2xr9rG1Vzl48KBh3Ny97e1Rrlw5w/tUJyUl6cSJEw6fLytYsmSJSSwwMFBt27a9//+tWrVKN3727FnFxsZalH/16tUmsYiI//sCxi5dupiMx8TEGN7bzxxv6Vldzdy9dOvWreviSjyDMz4b1KtXzzB+4sSJB35PmyOw7XsuV54bJc6P8D7eeI3ME3j7sSUz9J0AAAAAgL/4ursAAAAAAAAAAAAAAAD+af/+/apbt67ZPz7OkyePqlSpcv/xE088oYsXL+rGjRv69ttv9d///lcNGjRwSC358+dXx44d0/106NBBLVq0UMWKFU1uvPThhx+qUqVK+v333x0yv60CAwP19ttvp4t9+OGHOn36tNV5/ik1NVUrVqxQmTJlJEkpKSlasGCBunbtqmLFiilbtmzy9fVV3rx5Vb9+fY0ePVoXL15MlyM4OFhLliyx+T3y1vcEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGC5wOxS0ydtXz+sgFSvp+PqyWxy586tTZs26ZFHHjG7TMOGDRUUFOSymrJly6bJkycbjh04cEDh4eG6cuWKTbnXr1+vvn37Go4999xzKlCgwANz3LhxQ0uXLjUc69+/v011/Vvv3r1NYnfv3tXChQsdkt9Svr6++uijjwzHbt++rWbNmpl9LR5k//79Cg8P1+3bt9PF69SpY/I9mt4uIiJC/v7+JvEvv/xSS5YssTlvcnKyevbsqd27d6eLb9y4UaNHj7Y5r6t9/PHHCggIMInfvXtX7du316effmpT3pMnT6pu3bras2eP4fjAgQNVp04dm3L/W9GiRe///9WrV9W8eXMdP37cqhyrV6/Wu+++azhWvnx5RUZG3n+cmpqqbt26ad26dVbNcebMGUVFRRmO+fn5KTo62qp8nn68zkhkZKTy5s17//Gff/6pFi1a6LXXXtONGzdszpsV9veAgAAtWrRIiYmJ6eJr165Vnz59dO/ePZvyHjx4UIMHDzYcK1u2rNq1a2dT3n9zxnvvzfuCO3n663bz5k199dVXJnE/Pz/DXs1a4eHhKlKkiEl8wYIFSk5OznDdjF47d79uGXHG/uctx6SQkBBNmDDBcCw+Pl7NmzfXt99+a3WdknTq1Ck1atRIJ06cSDefpytWrNj9/09NTVXPnj1t6vtSU1P15JNPavv27YbjtWrVUpMmTazKyftlu+HDh+vw4cOGYx9++KFKlCjh2oIyMHv2bMN4ZGSkYT9nDXM9t7k5kd7FixcN457c95j7LDVz5kyL1v/555/1888/m8QDAwPVr18/e0pzCk//3OOM6wyuvMYA7+Ht17Q8tR/z9GNMZuHt26+1vOWzozt+JyNZ/nsZT6/P0681OZI3P1dHXx/ylv3bnbx5ewEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAb/HLL79oxIgRhmP16tXTqFGjXFzR/5k7d67S0tJM4r1795aPj48kGd7vKi0tTXPnznV2eZmKv7+/5s+fr+DgYMPxt99+28UVpde8eXOVLVvWJB4XF6evvvpKycnJTv2ZNWuWYV1t27bVww8/7Oyn7zRXr17V/v37TeKhoaGZ7n775sTFxRnGa9So4bA5/P391bp1a4flg+u4ah/x8/NzWK5ChQoZxo8cOeKwOVq0aGF3ju+//94w3r59e7tze5rt27dr0qRJhmOlS5c2e3+srMrTe5KMTJgwQX/88Yfh2LvvvuvQfd0V6MU9S2buh9nWbGdrr7Jx40bDeMeOHR1+rOrSpYthfNu2bTbfb88TufIYv2LFCsPvBPn7tW7WrJnJ9wesWrXK4vwrV640ibVt21b+/v7KkSOHwsPDTcaNvhslI97Ss7raDz/8YBhv1qyZawvxEC1atHD4tQlznze+++47h85jTmbb9r2tv82IK8+NUtY5PyLz4Dqybbz92JIZ+k4AAAAAwF983V0AAAAAAAAAAAAAAAD/dvToUVWrVk1RUVHatWuXRevkzJlTzZo106uvvqqdO3fqxIkT6t27t5MrTa9Lly7q2rWrS+c0MmTIkHT/wPfGjRsO+Yf4DRo0UN26dSVJ+/btU/ny5dW3b1+tWLFC586dU1JSktLS0nT16lXt2bNH48aNU4kSJTRlypR0eYKCgvT5558re/bsdtf0IJ7yngAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALFe5tRSc074cNTpJfgGOqSczCQ0N1YYNG1S5cuUMl6tQoYLGjx/voqqkXr16qVChQibxmzdvqmvXrkpMTLQr/4oVKzRr1iyTeGBgoAYPHmxRjk8//dQw3qtXL/n7+9tVX6VKlQzfk9WrV+vq1at25bZWt27dVLZsWcOxZ599Vj/88INd+WNjYzVs2DBJ0g8//KCuXbuqSpUqSk5OtiuvpyldurRhfP78+XbnTklJUf/+/XXnzh0tWLBAVatWVevWrbVx40a7c7tC48aN1bBhQ8Ox4cOH2/084uPj1b17d/3xxx8mYz4+PhoxYoRd+Y1ERUXp9OnTNq379ttvKy4u7oHLTZo0SevXr7dpjs2bN5tdt02bNlbl8objtTmPPPLI/f+/fv266tevb/H3J2ckK+zvV69e1XPPPaeSJUvq3XffVUJCgq5fv66+ffvanXvhwoX65ZdfDMdatmxpd37JOe+9N+8L7uQNr5u5nu/JJ5+0qzZJ6t+/v1Vz/lNGr50nvG7mOGP/85ZjUlRUlPLmzWs49vzzz+vHH3+0ur5/unjxonr37q179+7ZlcddxowZo+XLl9uVo1+/frp7967hWOfOna3Kxftlu6SkJEVGRhp+pgsNDdXChQvl6+vrhspMLVy4UElJSSbxvHnzqm3btjbnDQwMVM+ePU3iiYmJ+uKLL2zOm5XcunXLMB4cHOziSiyTK1cu9ejRwyR+8eJFrVu3zuI8RudfSYqOjra5Nmfx5M89zrzO4I5rDPBcme2alif1Y558jMksMtv2awlv+ezoyt/JSNb/XsbT6/OGa02O4s3P1dHXh7xl/3Ynb95eAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMCb/O9//9PmzZsNx0aOHKmiRYu6uKK/nD59Wlu2bDGJFy5cWC1btjR7/7TNmzfrzJkzrigx05gxY4bZe7ts375dMTExLq4oPXP3NVu4cKFL7gv/5ZdfGt5rztfXVwMHDnT6/JJUsGBBp+S9cOGCYTxXrlxOmc/THD582DBesGBBlSlTxiFzdO/eXfny5XNILmTMGfuJI/eRhIQEw3hoaKjVuczJnTu3Ydzee7X8zdfXVwMGDLA7j7nvG3j00Ue96h45lho1apT27t1rONanTx898cQTLq7Ic3l6T5KR+Ph4jRkzxnCsfPnyeuaZZ1xckX3oxT1LZu6Hs8q25kn9/LZt2wz7kmLFiumxxx5zVGkKCAjQ888/bzi2atUqh83jSq7o5x7kxo0b2rRpk0m8Q4cO8vf3V0REhMnYypUrLc6/a9cuk++Zy5kzpxo1aqQ2bdooKCgo3VhycrLV76e39KyuZq7P6dSpU5b8TJkvXz795z//cVi+vHnzqlevXoZjtn6XmrW8ddv3hGOfs7nq3ChlzvMjPIsn9Z1ZnbcfWzJD3wkAAAAA+ItnfAsvAAAAAAAAAAAAAAD/kpaWps8++0wNGzZU0aJF9dhjj+mdd97Rhg0bdOnSpQeuX6pUKS1YsEAxMTHKmTOnTTVcvXpVW7duNfnZs2ePjh8/rtTU1HTLFylSRF988YU++ugj+fj42DSnvXLmzKk33ngjXWzixImKi4uzO7ev719/ZrBr1y41bNhQJ06ceOA6ycnJGj58uJ577rl08ZIlS9r0D+y98T0BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFinTD37cwQGSw9XsT9PZhIcHKxvvvlGtWvXtmj5F198UU2aNHFyVX8ZMmSIYXzatGk6deqUQ+aYOHGiyfceSlLfvn0tWv+7777Tr7/+ahJ/6KGH1KFDB7tq6927t2F8zpw5duW1xdChQw3jq1at0vz58x0yx6effqpmzZqpbt26WrFihdLS0hyS15MULlzYMG7J94Fa4rffflOBAgXUt29fxcbGOiSnq7z88suG8U2bNun99993yBwXLlzQgAEDDMc6deqksmXLOmQeSVq5cqW++eYbm9e/deuWli1bluEy58+f17hx42yeQzJ/PKlataqCgoIszuMNx2tLPPnkkzp+/LhDcmWl/f3SpUt6+eWXVbx4cXXq1ElXr151SN5PPvnEMN64cWOH5P8nR733mWVfcDVveN127dqlw4cPm8TLly+vOnXq2FxXzpw51aVLF5P47t27Def7t4xeO0fwtmOv5PnHpMGDBxvG161bp3nz5llblqE9e/Zo+vTpDsnlSgcOHNDEiRPtznPq1CmtWLHCcKxRo0ZW5eL9sk9sbKxGjBhhONagQQOzY652/fp1ff3114ZjUVFRNuft1KmTcuXKZRL/+uuvdf36dZvzZiWJiYmG8cDAQPn6+rq4mgfr27evgoODTeLz58/XvXv3LM6zcOFCw+depkwZtWjRwq4aHc2TP/c4+zqDK68xwLNlpmtantaPefIxJrPITNuvtTz9s6OrficzY8YMm34v4+n1ecO1JkfJLM/VkdeHPH3/dqfMsr0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAgDfo27ev4uLiTOJ+fn4KCQlxQ0V/mT17tmE8KipKHTt2VO7cuS1eB6Z8fHz08ccf6+mnnzYcT0pK0jPPPOPiqtLLmzev4b1QJWnWrFkuqeH27dtavHix4dhTTz0lPz8/p81dtGhRzZgxQ2fOnFHnzp0dnj8wMNAwfufOHYfP5YmOHj1q9n4f/fr1szu/v7+/3nzzTbvzIGPO3E8cuY9cu3bNMF68eHGrc5kTHx9vGM+XL59D8kdGRqp06dJ257l48aJ27txpOPb666/bnf+fBg4cqKpVqzo0p7Xu3bunyMhI3bp1y3B8xowZKlWqlIur8ize0JNY4tNPPzV7r/a33nrL8N6/noxe3DNkhX44M29rntjPJycn68svvzQce+ONNxQQEOCQ2gYOHGh4r9akpCR99dVXDpnD1VzRz1liyZIlJrGwsDA1bdpUERER6eLx8fHaunWrxblTU1O1du1ak3hERIThsWjTpk26ceOGxfn/rsmIp/Wsrnby5En98ssvJvHAwECz98q1VVhYmAoWLOjQnM7w8ssvO+yay7Bhw5QtWzaTeEJCgmJiYhwyx4N467bvKcc+Z3LVuVHKnOdHeAZP7DuzusxwbPH2vhMAAAAA8BfP+xZVAAAAAAAAAAAAAAD+5fz581q2bJleeeUVtW3bVh06dLg/9u2332rKlCmKiYkx/KPiVq1aafPmzWb/8D0j33//vZo3b27yU79+fZUtW1a5c+dW7969Tf7h1zPPPKNJkyZZ/0Qd4JVXXlGePHnuPz537pzef/99h+WPj49X165dlZSUZNV6H3zwgRYtWpQuNmTIEKvn98b3BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgnbzFHZPnoYcdkyczCAwM1IoVK9S4cWPD8Tt37pjEfH19NX/+fIWEhDi1tocffljVq1c3id++fVvvvfeew+Y5efKkNm3aZBIvXry4Hn30UYtyzJw50zDer18/e0pTZGSkSezSpUtav369XXmtlT9/fjVs2NBwzJHfC5mWlqZt27Y5LJ8nCgoKMoynpaU5bI74+HiH5XKV0NBQtWvXznBs4sSJDp1r1apVOnTokEncx8dHjz32mMPmGTdunN05li1bluH41KlTDY/T1lizZo2Sk5NN4gEBAYbHYCPedLzOyNdff62vv/7a7jx/y4r7+9WrV7Vjxw6H5duyZYthvHr16vLz83PYPI567zPLvuBq3vS6mev5+vfvb3Ndjz/+uIKDg03in3766QPXdcVr523H3n/yxGPSI488YvZ1Gz9+vM21GXn33Xd17949h+Z0tlGjRjms5rlz5xrGa9SooezZs1uUg/fLMd59912z+8+YMWNcXI15s2fPNoxHREQoV65cNuWMioqyai6YSklJMTvm7+/vwkosM2jQIMO4te/5jRs3tHz5csOx6Ohoq+tyJk/93OOq6wyuusYAz5XZrml5Wj/mqceYzCKzbb+28sTPjq78ncyzzz5r9e9lPL0+b7rWZK/M8lyddX3IE/dvd8os2wsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeIsLFy5o4MCB7i7DxPLly3X9+nWTeLdu3TR48GCT+PXr151238jMpmDBgtq8ebPZe5JJ0siR/4+9+w6Polz7OP5LCAmQUIWA9A4eBaUFEBAEQkcQRY90FCEogu2ISjtyFFE5IuoRpEuVJkgR6V3pvUjvNRACiSEJJPv+4SWvcWch2Z3d2d18P9fFpbmfmfu5d8qzM88mswN18OBBD1Zlr3v37goODraLb9++XXv37vVYHePHjzeMFypUSE899ZTp/RUtWlTffPONjh8/rqioKAUHB+vLL79Uvnz5TO2nbNmydrGEhIRM9byjX375xTD+8ssvO/18xz+9//77qlixoks54JgnzhMzz5Hz588bxsuVK6eCBQtmOJ+Rq1evGsZr167tcu4iRYqY+uyXMWPGGMYbNWqkfv36mdJH9erVNXr0aO3evVuLFi1SRESEKXmdcfz4cfXp08ewLWfOnPr++++98tmlnuAr1yTpkZqaqrffftuwLV++fF71fOP04FrcO2SG62F/PNa8/Xp+xIgRhs9LrVSpkr744guX66pSpYpGjBhh2DZlyhRduXLF5T6s4InrufRYsGCBbt++bRcfNGiQSpRI+6WJy5YtM1z2Xn788Ue7WJs2bdSqVSu7+Jw5czKUW/Kta1ZPc/QdMwMGDFC5cuVM62fkyJE6fPiw+vbtq8DAQNPymq1SpUr67LPPXM5Tv359vfPOO4ZtU6dO9dgciK8e+94y9rmbu98bJf99f4S1vP26M7Pz9bHF1687AQAAAAB/8N5ZYAAAAAAAAAAAAAAA0mHHjh3617/+paZNmyp//vxq3bq1tm3blmaZ6tWra9iwYab3ffPmTU2fPl1Vq1bV//73vzRt//rXv1SvXj3T+7yXvHnz2j2M4d///rcSExNN6+Orr75y+hfR33///TS/RF+yZEk98sgjZpUmyfv2CQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAg47LnMidPaF5z8vi6rFmzavbs2WrSpIlh+4cffqh//vOfhm0lS5bUF1984cbqpMjISMP4ypUrFRMTY2pfa9euNYw3aNAgXet/9913Sk5Otou3bNlS+fPnd6qmevXqqXjx4nbxqVOnKiUlxamczmrWrJkCAgLs4rt27dIvv/zi0Vp8XWxsrGG8VKlSni3EyzRp0kRZs2a1i+/fv1+rV682vT9H41fr1q1Nyb9nzx7t2LHD5Tz3ypGamqrvvvvO5T5u3bql3377zbAtvcelL43X92L2+xrnu+t+++03xcfH28WDgoKUN695F3Rm7Xt/ORc8zZe225QpU5SUlGQXf+GFFxQSEuJUTd27d7eL3bx5U7Nnz77vup7adr409rqTGWNSs2bNDON79uzRpk2bXKrv786dO6clS5aYmtOdTp8+rUWLFpmWb9OmTbLZbHbxoKAglShRIl052F/m6dKli65fv24XDwoKUmhoqAUV2Vu5cqVOnz5tFw8JCdFzzz2X4XwFChQwPIZOnz6tVatWOVUjvFudOnX0j3/8wy6+bt06HTt2LMP5xo0bZxhv27atwsPDM5zPXbz1vseT8wzunmOAd/OnOS1vvB7z1jHGX/jT8etNzLp39ObPZLy9Pl+aa3KVv7xWX5kf8tR8tbv4y/ECAAAAAAAAAAAAAAAAAAAAAAAAAAAAAL5k3rx5pjxD2ExJSUmaMWOGXTxHjhxq2LChXXz69OmGz+LE/wsNDdU777yjI0eO6Mknn3S43KxZszRixAgPVmasV69ehvHx48d7tI4tW7bowIEDhm1RUVGm9zdmzBj17t1bwcHBd2PFixfXnDlzlD17dlP6iIiIUNmyZe3i586dMyW/r3D0XN3w8HCNHDnS6bxt2rTRkCFDnF4f9+fu88Tsc+T8+fMO133llVecyvl3R44cMYw7GkvTK0eOHJo7d64KFCjgUp6/mjlzpo4ePWrY9tlnn6lFixYu5S9UqJDmzJmjwMBASVKrVq20ZcsWrVixwrLnZH733XcOx5waNWroww8/9HBF1vK1a5L0Wrp0qVauXGnY9uqrr6pcuXIersh5XIt7h8xwPeyPx5q3X88fOnTI4XvSK6+8ojfeeMPpusqVK6f58+crW7Zsdm2JiYkaPny407mt5onrufS4ceOG4XtN/fr17WI//vhjhvMvW7bM7rvtypQpY/ccwzt37jiV35euWT1twoQJio6OtovnyJFD06dPN+V7Enr06KHu3bsrV65cGjVqlHbu3KnatWu7nNdd3njjDb388stOr//QQw/p+++/V5YsWeza7ty549FnjPrqse8tY5+7ufO9UfLv90dYy9uvOzM7Xx9bfP26EwAAAADwh0CrCwAAAAAAAAAAAAAAwCx37tzR4sWLVatWLY0ZMyZN26uvvuq2BwncuXNHffr00dy5c9PEP/roI7f050i/fv0UFhZ29+ejR49q0qRJpvYxZ84cp9c9deqUduzYkSZWrVo1V0sy5C37BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQcbcTzcmTfMucPL5u2LBhatOmjWHbqFGjNGjQIC1cuFBTpkwxXOall15S69at3VZf3bp1DePLli0zva/Nmzcbxh9++OF0rX/t2jUtWLDALp41a1a98MILTtXUqVMnw7jZ30mZHvXq1TOMu2Nf+LuLFy8axp09TvzFk08+aRj/+eef3dKfo7w1a9ZUSEiIy/nNOjeuXr2q6Ohow7bdu3c7bMuoAwcOGMbz5MmTrvV9abx25LffftP69etdyvF3nO+us9lsDrdjvnz5TOnDzH3vD+eCFXxpu8XExGj+/Pl28dy5c6tt27YZrqds2bJ6/PHH7eIzZsxQQkLCfdf31LbzpbHXncwYk2rXrm0YX7x4sdN13Yu78rqD2bXevHlTx48fN2zLmzdvunKwv8xz/vx59ezZ07Dtiy++8Gwx9zB58mTDeNeuXTOcq0OHDgoKCrKLT5w4McO54BuioqIM4+PHj3cq39q1a3XixAm7eNasWdW9e3encrqDt973eHKewd1zDPBu/jSn5Y3XY946xvgLfzp+vYkZ947e/pmMt9fnS3NNrvKH1+pL80OemK92J384XgAAAAAAAAAAAAAAAAAAAAAAAAAAAADAF/Xp08fwmVJWmjBhgluWzUyCgoLUoEEDffXVVzp//rw++eQT5cyZ0+Hy69atc+q5dmZr1KiRypQpYxdPSEjQzJkzPV6Po2e1RUZGqnTp0qb2NWjQINlsNrt4w4YNtWrVKhUrVsyl/Hny5HF4vixdutSl3L7m+++/14ULFwzbunXrpmHDhmU458svv6y5c+cqMDDwbuzIkSNO1whj7jxP3HWOrF271jD+7rvv6oknnnA6758cPZ8lMjJSL730klM5CxcurI0bN6pWrVp3Yzt37nQq11+lpKTorbfeMmzLmjWrFi5cqH79+jmVu2LFilq/fr1Klixp11aoUCHTvjPBGT179tSZM2cM29555x01atTIwxV5lq9ek2TUm2++qdTUVLt41qxZNWLECAsqch7X4tbKTNfD/nas+cL1fL9+/XTjxg3Dts8//1xjxoxRcHBwhuqKjIzU1q1bVaJECcP2Dz74wOvmHDLK3ddz6TV79uz7LpOSkqKffvopw7nj4+Mdvs6/WrVqla5fv57h/L50zeppCQkJGjJkiGFbjRo1tH79eoWHhzudv2/fvvr222/TxB599FFt2rRJTZs2dTqvu40dO1aff/65smTJkqH1WrZsqc2bN6tQoUKG7V9//bUOHz5sRonp4svHvreMfe7mjvdGKXO8P8I6vnDdmdn5+tjiy9edAAAAAIA/BN5/EQAAAAAAAAAAAAAAfEtqaqpeffVV7dix424sW7ZsateunVv7ff3119P8EXm9evVUtGhRt/b5p+DgYL3yyitpYsOHDzf8o/b0SkpKSvNzamqq9u7d63Q+yf6Pm9y9fazcJwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA58RdNSfPzWhz8vi64sWLG8bHjRun119//e7Pffv21fnz5w2XHT9+vPLnz++O8lSxYkXD+K+//mp6XxcvXjSMly9fPt05xo4daxjv1q1bhuvJmjWrnn32Wbv4li1bdOjQoQznc9VDDz1kGP/ll188XInv27hxo2G8S5cuat++vYer8R7/+Mc/DOOOtperzp07p7Nnz9rFAwMDVaFCBZfzm3luXLp0yTC+ZcsWt/eRJ0+edK3va+O1kbVr17q0vhHOd3PcuHHDMJ4vXz5T8pu57/3hXLCCr223b7/91jDevXv3DNfj6DrR0XXl33lq2/nS2Oturo5JjvbZpk2bnK7pXsy8XnC39evXm57T6HpPYn9ZZe7cuZoyZYpdvEePHmrbtq3nCzIwadIk2Ww2u/jjjz+uMmXKZChX165d7WI2m02TJ092trxMKSAgwGGb0b6ySt68eQ3ncW7cuKG5c+c6nXfChAmG8V69ejmd02zeet/jyXkGd88xwLv505yWN16PeesY4y/86fj1Nq7eO3r7ZzLeXp+vzTW5wh9eq6/ND7l7vtqd/OF4AQAAAAAAAAAAAAAAAAAAAAAAAAAAAABfFB8fr44dOyolJcXqUu7auXOn9uzZc9/l9uzZo127dnmgIs9p0qSJevbsmaF/r7zyit5++2199NFHmjJlijZv3qz4+HitWbNGffr0Ue7cue/Z508//aRmzZopKSnJQ6/SsaioKMP43LlzdfPmTQ9XI02dOlXJycl28YCAAPXs2dPUvnbt2qXRo0cbttWuXVsHDx7UoEGDnPrehaZNm2rr1q165JFHDNvnzJmT4Zy+7M6dOxo5cqTD9vfee09LlixRuXLl7puratWqWrp0qcaOHaugoKC78W3btmnBggVmlIu/cNd54s5zZMyYMYbx4OBgrVy5UsOHD1eJEiWczr9hwwZdvWr8RTljx47VoEGD0hyb9xIcHKy+fftqz549qlKlyt14bGysBg8e7HSNf7Vo0SKHzz7NkiWLvvjiC23fvl1NmjRJV76wsDANHDhQO3bsMDxnbTabXn/9dUufEXrjxg117NhRqampdm0BAQGaOnWq275TxxWZ/Zoko/bt26dJkyYZtj311FN68sknPVyR83zpWrx27dpq166d2/958vnUmel62JeOtfTwhev5y5cvOzzGpD+eK33kyBF16tTpvtcPDz/8sObPn6/ly5c7/O6gjRs36rPPPktXbd7M3ddz6bVgwQLdvn37nsv88ssviomJcSr/jz/+eN9lZs+e7VRuX7tm9bTRo0dr3bp1hm1Vq1bV/v379corr6R7G0lSpUqVtHTpUo0aNUqBgYF27du2bdOKFSucrtkddu7cmebnN954QwcPHtSzzz57z+8D+FOlSpW0ePFi5cqVy7D91KlTHj9GfPnY95axz93MfG+UMtf7I6zjC9edmZ2vjy2+fN0JAAAAAPhD+meTAQAAAAAAAAAAAADwIampqfriiy80derUu7H69es7/EMYM5w/f15bt25VrVq17sZq1qypc+fOua3PPz3zzDMqUKDA3Z+jo6M1bdo0l3Jev37d7mejByFkRHR0dJqfHf2Bl1ms3CcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOec2iXlL+F6ntO7XM/hr2bMmKFevXqlid24cUMvvviili1bZrd8eHi4vv32Wz3zzDOm11K+fHnD+OnTp03v6+/f1finvHnzpjvHqlWrdOLECZUuXTpNvGrVqnrkkUe0f//+dOdq3ry58uXLZxefOHFiunOYqUKFCobxXbs4mTJq48aNunbtmh544IE08cDAQM2aNUutWrXS559/rj179lhUoTUeeughw/jOnTvd1ueOHTtUrFgxw1r27t3rUu6jR4+6tP5fxcXFGcaPHDni9j7y5MmTrvV9bbw2smXLFpfWN8L57rxChQqpTJkyKl26tOH7oSQFBweb0peZ+94fzgUr+Np2W7t2rY4dO6ayZcumiUdGRqpIkSI6f/58uvIEBASoS5cudvGdO3em+xrLU9vOl8ZedzBzTPr7cfMnd11X79+/X8nJyaaNme506NAh03PeuHHDMJ7eaxz2l/leffVV1atXT6VKlUoTHz9+vDZv3qxLly5ZVNkfTp8+rVWrVqlx48Z2bV26dNGQIUPSlefhhx9WlSpV7OIrV67UmTNnXK4zM8mWLZthPDU1Vbdv3/ZwNY517drVsNaZM2cqMTHR6byTJ0/W0KFDlSVLljTxUqVKqUmTJlq+fLnTuc3irfc9np5ncOccA7ybP81peeP1mLeOMf7Cn45fb2DmvaO3fybj7fX52lyTK/zhtfrC/JAn56vdyR+OFwAAAAAAAAAAAAAAAAAAAAAAAAAAAADwVZs3b9ZHH32kwYMHW13KXRMmTNCXX355z2XGjx/voWo856WXXtJLL73kkb5sNps+/vhjDR48WCkpKR7p817Cw8PVpk0bwzar9vW1a9e0cOFCPfvss3Zt3bt316BBg0x97twbb7yhiIgIVa9e3a4tLCxMQ4cO1aBBg/TLL79o7dq1OnTokE6dOqW4uDglJCQoICBAoaGhypMnj8qUKaMqVaqoRYsWKleunMM+Fy1apE2bNpn2GnzFyJEj1aZNG9WtW9ewvUWLFmrWrJk2b96sZcuW6cyZM4qOjlZAQIDy5cunSpUqKTIyUo8++qjduklJSXrxxRfVsWNHd7+MTCkj58no0aMtP0c2bdqkjRs3Gh5rWbNmVf/+/dW/f3+dP39eZ86cUVxcnFJTU+2WvXz5srp162YXT0pK0kcffaSRI0fatQUGBmro0KGKiorS1KlTtX79eh0+fFixsbFKTExU7ty5FR4errJly6pp06Zq2bKlHnzwwTQ5bDabunbtqujoaKe3wd9FRUWpfPnyevzxxw3bq1WrpmXLlik6OlrLly/Xrl27dOXKFV27dk2SlDt3bpUqVUoRERFq0qSJsmfP7rCvjz/+WKtWrTKtdmdt3LhRH3/8sQYMGGDX9uCDD2ry5Mlq1aqVBZU5lpmvSZw1cOBA/fOf/1RoaKhd28iRI1WlShXZbDYLKss4X7kWf/311/X666+7vZ/ExMR7jjVmyYzXw75yrKWXL1zPf//993rkkUcM35MkqUSJEpo6daq+/vprLVu2TFu3btWlS5eUmJioggULqly5cmrevLnD5z7+6cSJE2rbtq1Pj+t/cvf1XHrFxsZq1apVatasmcNlfvzxR6fzL1q0SP/73/8ctt+5c0cLFixwKrcvXrN62nPPPadt27apePHidm0FChTQ//73Pw0ePFhLly7VypUrdfbsWV25ckUJCQkKDg5Wzpw5Vbx4cVWuXFktWrRQrVq1HPZ18eJFtW/f3vA4tVL37t21detWhYSE3I2VL19ec+bM0dWrV/Xzzz9rx44dunTpkq5fv66cOXPeHZeaNWt2z3Hp1q1batu2rcPvQHMXXz72vWXs8wRn3xuvXbum0NDQTPv+CGv5wnVnZufLY4svX3cCAAAAAP4QZHUBAAAAAAAAAAAAAAC4yy+//JLm56JFi7q9z+PHj6f5g61ChQq5vU9J6tKlS5qfJ0+erOTkZJdy3rx5UykpKcqSJYskmfJHZlb8oZpV+wQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4JwDK6VqbaSAAOdznN4txV8zrSS/smDBAnXp0kU2m82ubfny5Ro7dqx69uxp19auXTt16tRJ06ZNM7WevHnz2sVu3bqlmJgYU/uRpPj4eMN4zpw5M5Rn/PjxGjZsmF28W7duevvtt9Odp1OnTnaxW7du6fvvv89QPWbJly+fYTw6OtrDlfi+27dv6+OPP9aIESPs2gICAtSlSxd16dJF586d07Zt23TgwAEdO3bs7r/Lly9bULX7FShQwDDuzmPs6tWrhvH8+fO7nPvChQsu5/iTo/Hp0qVLpvURFxdnGA8MDEzX+r44Xv/dnj17XFrfCOe7YyEhISpZsqTKlCmj0qVLq2zZsipduvTdf9mzZ/dYLWbue384F6zgi9tt3Lhx+uSTT9LEAgMD1blzZw0fPjxdORo2bKhixYrZxceOHZvuOjy17Xxp7HWGp8akwMBAhYWFGbY5ui5xVWpqqmJiYnziO9zPnz9ves6bN28axtNzjcP+co/4+Hh17NhRGzZsUJYsWe7GH3jgAX333Xdq2rSphdX9YcKECWrcuLFdvHPnzhoyZEi6cnTt2tVhbmSMozH41q1bHq7k3nr16mUYHz9+vEt5L1y4oGXLlqlFixZ2bVFRUVq+fLlL+c3grfc9np5ncOccA7ybP81pedv1mOS9Y4y/8Kfj1xM8OZ/l7Z/JeHt9vjjX5Cx/eK3eMD/kTfPV7uQPxwsAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+LKhQ4eqadOmqlmzptWlSJKmT5+uESNGKDg42LA9KSlJ06dP93BV/uPgwYPq06eP1qxZY3Upd3Xv3l1Zs2a1ix89elQbNmywoKI/jBs3Ts8++6xdPDw8XG3bttWcOXNM6ys5OVnNmzfXsmXLVLVqVcNlsmbNqvr166t+/fou93f16lX17t3b5Ty+KCUlRc8//7x2797t8HlHgYGBevzxx/X444+nO6/NZlNUVJT2799vVqn4G0+eJ2adI126dNGePXvu+XyTIkWKqEiRIg7bT5065bDtm2++UZcuXVSlShXD9sKFC6t///7q379/umv+U//+/bVw4UJFRERkeF1HkpKS1KJFCy1ZskR16tRxuFyBAgXUsWNHdezY0al+xo8fr4EDBzpbpumGDBmixo0bG15rtWzZUq+99pq++uorCyqzljdekzjr0qVLGj58uP7zn//YtT366KN68cUXfeb5v1yLWyMzXg/727HmK9fzAwcOVEBAgN5//32Hy+TOnVvPPfecnnvuuQznP3jwoJo1a6Zr1/znS/jcfT2XXrNnz1azZs0cti9atMjp3GfPntWePXv06KOPGravWbPGpWcD+to1q6dduXJFjRs31urVq1W0aFHDZQoWLKhu3bqpW7duTvdz+fJlNW3aVGfOnHE6h7vs3btXnTt31qxZsxTwty8BzZ8/vzp16mT4vYn3c+vWLbVr186y54v68rHvLWOfJ7j7vVHyz/dHWMdXrjszO18eW3z5uhMAAAAAIAVZXQAAAAAAAAAAAAAAAO5y9erVND/ny5fP7X3Gx8en+TkkJMTtfYaEhKhhw4ZpYjNmzDAl9/Hjx1W+fHlJUt68eV3Olz9//jQ/x8bGupzzfqzYJwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA510+Jh3eIFV8wrn1banSuonm1uQvli9frueee04pKSkOl3nzzTcVGRmpUqVK2bV9/fXXWrt2rc6dO2dKPTly5FBAQIBdPHv27Lp165YpffyVUV9Sxr/rcNKkSRo6dKiCgoLSxDt27Kh33nlHqamp982RM2dOtW7d2i4+f/583bx5M0P1mCFHjhwKDAy0iyclJSkpKcnj9fiDr776Sk8//bTq1KnjcJmiRYuqaNGievrpp9PEf//9dx0/flzHjh3TsWPHdPToUe3Zs0d79+712f2RPXt2ZcmSxS6elJSkxMREt/V7/fp1w3jOnDldzv3777+7nONPjsYNT/SRHr46Xv/dtWvXXFrfkcx+vhcuXFjVqlVT5cqVVbZsWZUuXVplypRR4cKFHe5LTzNr3/vLueBpvrrdJk+erA8//FBZs2ZNE3/xxRc1fPjwdOXo3r27XSwhISHd30PuyW3na2OvI1aPSY6uMeLj43Xnzh239RsbG6tChQq5Lb9Z4uLiTM/pyjUO+8t9fv31Vw0bNkyDBg1KE2/SpIn69u2rL7/80qLK/jB//nxdv35defPmTRMvVaqU6tSpo02bNt1z/cDAQHXq1Mkufv36dc2fP9/UWjOD/PnzG8atmB9xpF69eqpYsaJdfO/evdqxY4fL+ceNG6cWLVrYxVu3bq0HH3xQFy9edLkPV3nbfY8V8wzunGOA9/K3OS1vux77k7eNMf7C345fM1l97+jtn8n4Qn2+ONfkDH95rZ6cH7L6/LaSvxwvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAODLUlJS1LFjR+3evVthYWFWl6OYmBj9+OOPat++vWH7jz/+6PB5IXDs2LFj+u9//6tx48bd85n/VujZs6dhfPz48R6uJK0VK1bozJkzKl68uF1bVFSU5syZY2p/V69eVYMGDTRlyhS1bdvW1Nx/de7cOTVu3Fjnz593Wx/e7sKFC6pXr56WLFmiMmXKuJwvNTVVr732miZPnux6cbgnT5wnZp4jJ0+eVLt27TR37lzlzp3bhOrSSk5OVvPmzfXrr78afleLM27fvq0+ffpo7NixpuT7uxs3bqhx48b63//+pxdffNHU3KmpqRo+fLgGDBhgal5XpaSkqEOHDtq9e7fhs80+++wzrVu3Tnv37rWgOs/z5msSV/z3v/9VVFSUihQpYtf20UcfadasWYqPj7egsozhWtwamfF62B+PNV+5nh8wYIBOnDihUaNGKTQ01LS6lixZok6dOik2Nta0nN7A3ddz6bVgwQJ9++23dt9DIklHjhzRkSNHXMq/cOFCPfroo4Ztrt77+uI1q6cdPXpUtWvX1rx58xQREWF6/p07d6pNmzamfYejO8yZM0cBAQH67rvvlC1bNpfzXb58Wc8++6w2btxoQnXO8eVj31vGPk9x13uj5L/vj7CWr1x3Zna+Orb48nUnAAAAAECy//YuAAAAAAAAAAAAAAAs1LhxY9WvX9+UXCEhIWl+TkxMNCXvveTNmzfNz574A5Hq1asrODj47s8xMTHavXu3Kbk3bdp09/+DgoJUoUIFl/L94x//SPPzqVOnXMqXHlbsEwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAa5Z9KcWcd27ddROlS0fMrccfbNiwQW3bttXt27fvudzvv/+ubt26yWaz2bXlzp1bkydPNq2m0NBQh23ZsmUz/d/fv+vSWZcuXdJPP/1kFy9UqJCaNm2arhzt2rVTtmzZ7OITJ050uT5nONoXN2/e9HAl/iM5OVlt2rTRrl27MrxuaGioKleurHbt2umdd97RuHHjtHXrVsXHx2vlypXq3r27smfP7oaq3ceqY+z69euG8Vy5crmc+37jqRmSk5Pd3kd6+Op4/Xc3btxwS97MeL4//PDD+uSTT3Tq1CmdP39eCxcu1Icffqhu3brpiSeeUJEiRRQQEGB1mXeZte/95VzwNF/dbleuXNGiRYvs4uXKlVPt2rXvu37OnDn19NNP28VnzZqluLi4dNXgyW3na2PvX3nTmORoO/7+++9u7ddXrts9cf2UEewv9/rggw+0detWu/inn36qhx9+2IKK/l9SUpJmzJhh2Na1a9f7rt+4cWM9+OCDdvHp06d7zTW8LylcuLBh/Ny5cx6uxLGoqCjD+Lhx40zJv3jxYl25csUuHhQUpBdffNGUPlzlbfc9VswzuHOOAd7L3+a0vO167E/eNsb4C387fl3lTfeO3v6ZjK/WJ3n3XJMz/OW1unt+yJvObyv5y/ECAAAAAAAAAAAAAAAAAAAAAAAAAAAAAL7u+PHj6tevn9Vl3DV+/Hin2pBWTEyMpkyZopYtW6p8+fIaM2aMUlJSrC4rjcjISJUuXdoufufOHX333XcWVPT/bDabw+84ePLJJ1W2bFnT+4yLi9PTTz+t9u3b68yZM6bmttlsmjZtmmrUqKHDhw+bmtsXHT58WBEREVq6dKlLeaKjo9WsWTN98803JlWG+3HXeeKuc2TlypWKiIjQhg0bTMv5V5cvX1bNmjW1ZMkSl3Pt3btXERERGjt2rAmVOZaYmKiXXnpJTz31lE6cOGFKzuPHjysyMlIDBgwwJZ/ZTpw4oT59+hi2hYSEaNasWX79/DlfuCZx1a1bt/T+++8bthUsWNBhmzfiWtyzMvP1sD8ea75yPT9hwgRVqlRJP//8s8t1Xbx4UZ07d1arVq0UGxvrcj5v5O7rufS4fv26Vq9ebdi2cOFCl/P/+OOPhvGUlBTNnz/f5fy+eM3qaefOnVPdunU1YMAAJSQkmJIzISFB/fv3V0REhFc9P9+R2bNnq1atWtq9e7dLeebMmaOHH35YGzduNKcwF/jyse8NY58nmfneKGWO90dYy1euOzM7XxxbfP26EwAAAAAyu0CrCwAAAAAAAAAAAAAAQJLq1aun9evXa8WKFRo5cqQCAgJczlmuXLk0P1+8eNHlnPdTqVKlND9fvnzZ7X0+/vjjaX7esmWLabnXrVuX5ue2bds6neuBBx5QnTp10sS2bt3qdL70smKfAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABckxQvzR0oxZzL2HpbZktb57qnJl+2bds2tWjRQrdu3UrX8uvXr9eXX35p2NaoUSP16dPHlLrM+P5Kq4wdO9Yw3q1bt3St36lTJ7vYmTNntHr1alfKcpqjfZGSkuLhSvzLtWvXVLt2bX3zzTembMugoCA1atRIEydO1LFjx9S9e3cTqvSMwMBAw7i7jzFH+X1l/LHZbFaXIMl3ttf93Lx50225M8v5XqJECc2YMUP79u3TO++8oxIlSlhdUrqYte/95VzwNF/ebo6u+dJzTrZv3145cuRId04jvrzt/uTOsdeXxiR3v6enpqa6NX9mw/4yR0pKijp06KDff/89TTwkJEQzZ85UcHCwRZX9YcKECYbx5557TiEhIfdct2vXrhnKiXsrX768YfzcuQxODLpJvnz59Mwzz9jFk5KSNH36dFP6uHPnjqZMmWLY1rNnT6+5JvCm+x4r5hl8fY4BzmFOy3O8aYzxFxy/f/DGe0dv/0zGV+vzR/7yWt01P+SN57eV/OV4AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAB/MHHiRM2fP9/qMiRJK1as0NmzZ+3iZ8+e1cqVKy2oyDulpKQoLi5OV65c0aFDh/Tzzz/r22+/Va9evVSlShWFh4era9eu+umnn7zmudF/FxUVZRhfsmSJLl++7OFq7E2YMMFw2wUEBKhXr15u63fu3LkqVaqU2rdvr5UrVyopKcnpXNevX9fEiRNVs2ZNde7cWZcuXTKxUt8WExOjFi1aqGHDhvr1118ztG5sbKw+++wzlS1bVitWrHBThbgXs84TT5wjR44c0RNPPKGaNWvq22+/1d69e0191mt0dLRatWql9u3ba+PGjRlef+fOnfrnP/+pxx57TLt37zatrvtZtGiRKlSooI4dO2rTpk1OvVft2bNHvXr1UoUKFSz73pT0mjJlir7//nvDtooVK2rUqFEersg8/nBNYoYpU6Zo165dhm1vvPGGihcv7uGKnMO1uGdl5uthfz7WfOF6/uTJk2revLlq1Kih2bNnKyEhIUPr7969W7169VLJkiU1bdo0U2ryZu6+nkuP2bNnG8Z//PFHl3Pv2LFDFy9etIuvW7dOV69edTm/5LvXrJ50+/ZtDRs2TKVKldJHH33k9DPvz549q8GDB6tYsWL69NNPvebZrOmxZ88eVa9eXV27dtWhQ4fSvV5iYqLmzJmjqlWr6rnnntO1a9fcWGXG+PKx7w1jnye5+t4oZb73R1jPF647MztfHFt8/boTAAAAADKzIKsLAAAAAAAAAAAAAAAgODhY8+bNU4ECBSRJVapU0RtvvKHPP//cpbwdOnRI8/O9/tAmT5486tmzp77++munfolbkiIiIvTQQw/d/dlms2n79u1O5cqIChUqpPl5x44dpuWeO3euRo0apdy5c0uS3nrrLX3zzTeKi4vLcK6BAwcqKOj/f1Vh9+7dOn78uMPlfXmfAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABcF3tRmvq6FPmq9FADKSDA8bLxMdKab6VD6zxVne/Yt2+fmjZtqvj4+Ayt9+6776p58+YqX768Xdunn36q5cuX68iRI2aV6XOWLl2qc+fOqWjRomnibdq0UZ48eRQbG+tw3UKFCqlhw4Z28e+++042m83sUmGxpKQkvfrqqxo1apTee+89tWvXTrly5XI5b+HChTVx4kRFRkaqe/fuSkpKMqFawL+5e4z19/O9cePGmjNnjvLkyeN0jpiYGB09elRHjx7V4cOH7/7///73P9WqVcu8Yv+G91c4a/ny5Tp9+rRKlCiRJv7888+rX79+unXrlsN1u3fvbhc7cOCANm/ebHqd3sxd55+3jkmOXm9gYKDTdaZH1qxZ3ZrfX7G/3O/48ePq16+fxo8fnyZeqVIlDR8+XG+++aZFlUm7du3S7t279dhjj6WJ586dW0899ZTmzJljuF5YWJiefvppu/ju3bu1e/duN1Tq/x599FHD+MGDBz1cibGuXbsqJCTELr5t2zaVK1fOtH727dtnGC9evLiaNWumpUuXmtaXK/z9vgeAtRhjYDZvvXcEMht3zA9xfgMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjJQqVcrqEu5q166d1SVI+uPv/osXL251GZLM3z/etL/N5OzreuaZZ0yuxFxnzpxx+/MeHUlNTdXcuXM1d+5c5ciRQ/Xr11flypVVsWJFlSlTRjlz5lRYWJhCQ0Nls9kUHx+vuLg43bx5U8ePH9fevXu1d+9ebdq0SXfu3LHkNaTH0KFDNXToUEtrWLNmjR5//HEVK1ZMTZs2VYMGDVS4cGEVKFBA+fLl0507dxQbG6srV65o165d2rRpk5YuXark5GTDfO+9957ee+89l+sKuNeXnViQxxs5Ok9atmzplefI1q1btXXrVklSaGioHnzwQeXJk0d58+Z1+OzXez1P+u/+3BYVKlRQ3bp1Vbt2bZUtWzZNH3FxcYqNjdWhQ4e0a9cuLVmyRMeOHbtnze48hu7cuaMZM2ZoxowZKlSokBo0aKBatWqpbNmyKlasmMLCwpQ9e3alpqbqxo0bio2N1W+//aadO3dq9erVOnTokCl1eOo8eeGFF/TCCy94pK/78ddrEsna11a1alWn1/WWfeLP1+LeKDNfD3vTseYOvnI9v337dj3//PPKli2bIiMjFRERocqVK6tIkSLKnTu3smbNqhs3bigmJkYHDhzQnj177n4fhid4w/3CX7n7eu5eJk6cqIkTJ5qSy0jhwoXdlvuvvPma1Vvuna5cuaKBAwdq4MCBql69uurWratq1aqpRIkSCg8PV2hoqIKCgpScnKybN28qNjZWhw8f1oEDB7Rq1Srt3bvX6pfgkpSUFE2ZMkVTpkzRI488ohYtWuixxx5T+fLllStXLoWFhSkxMVE3btzQpUuXtHfvXg0dOlS///67qXWYfTx487F/P54c+7xh3L/fe2NYWJiSkpI89v5o1djkiX6bN2/u9j4+//xzff75527vJ73csV195bozozx57Hfv3t3we9vM5G1jy734y3Wn2Xxxvt4TxzYAAAAA7xJkdQEAAAAAAAAAAAAAACQnJ6tIkSLaunWrHnvsMUnSf//7X3322Wf64IMPNHz4cIcP6zDSuXNnffPNNwoLC7sbW7x4sQYOHGi3bI0aNe7+EYwkffLJJ/r222/11ltvpfuPjypWrKgZM2aoSpUqaeLNmjXT5cuXHa63aNEitWrVKk3MmV8eLl++fJqfDxw4kOEcjvz+++8qXbq09u7dqyJFiqhAgQK6efOmFi1apM6dO+vGjRv3zfHSSy/p66+/VrZs2e7GfvnlF9WtW9dweSv3CQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAuyTFS4s/+eMfnPPhhx/q+vXrGV4vMTFRFSpU0Mcff6x33303TVv27Nl1+PBhDRo0SB9++KHTtd26dcswfu7cORUrVszpvJ6QmpqqOnXq6OTJkwoMDLwbDwkJ0dKlS1W7dm2H6y5evDjNOpK0bt06DR482G313k9CQoJh/IEHHvBwJdbLkSOHW/IeOXJE3bt3V/fu3e3aAgICVLRoUZUtW1Zly5ZVuXLl7v5/2bJllT17dod5X3jhBb3wwgsaMGCAhg0b5pbazeDoe1Dz58/v1n4LFixoGHdmXMzMfHm8toK/ne8lS5bUrl27lCdPHsP2a9euad68eVqxYoW2bdum06dPZ7iPpKQkF6v0DM4F5/jydrPZbKpTp45Onz6tLFmy3I3nypVLCxcuVGRkpOF6Q4cOtfse76SkJNWrVy9D/fvytnMXbx+ToqOjZbPZ7L6zPjw8XNmyZVNiYqLTue+lZMmSbsnr79hfnjFhwgT95z//0YMPPpgm/sYbb+j5559XpUqVFBMTY0ltDRs21MWLFxUSEpImPmPGDK1du1bR0dF26yxevNjumi0pKUkNGzZ0a63+qlmzZqpVq5Zh2+jRoz1cjb369evr888/N2yrW7eutmzZ4pE6Fi1apJIlS+rcuXMe6S89rL7vsWKeIbPNMbhrjszXMKdlDavHGH+RmY9fb7939PbPZLy9vsw0X5KZXmt6efv5bSWOFwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgPtLSEjQ0qVLtXTpUqtL8Wtnz57V+PHjNX78eKtLgRP+ep588on3f1nM77//rmPHjrkl9+HDh3X48GFNmDDBLfnd5dKlS/r+++/1/fffW10KAACm8oXr+cTERC1atEiLFi2yuhSf4c7ruczAV69ZPW379u3avn271WVYZv/+/dq/f7/VZZjK14/9zDT28d4IX+QL152ZHWMLAAAAAMCdAq0uAAAAAAAAAAAAAAAASbp9+7aef/55RUdH340FBgbqgw8+0LFjxzRo0CBVqVJFgYH2H3WHhITo0Ucf1euvv669e/dqypQpCgsLu9t+5coV9enTx7Dfbdu2ady4cWlivXr10vHjxzV8+HA1aNBA+fLls1svf/78atGihaZNm6Y9e/aoSpUqadqnT5+u5cuXZ2gbOCt79uxpfo6LizM1f0xMjDp27KjU1NS7sdatW+v48eMaOHCgHn74Ybt18uXLp+eee06//PKLxo8fr2zZst1tu3Llijp27CibzWbYnz/sEwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/MXgwYO1f/9+w7YhQ4aoatWqTudOSEgw/H5Do+8t9EZnzpzRihUr7OK1atVS+fLlDdcpX768qlWrZhefOHGi6fVlhKN9kTVrVrvvzvQ2WbJkMTVfzpw5Tc2XHjabTWfPntWaNWs0btw4vfPOO2rXrp0qV66s0NBQVahQQf369dOhQ4cc5njvvfe8+txJSkrSnTt37OJBQUEKDQ11W7958+Y1jJv9HbD+ztfHa2/ii+f7sGHDlCdPHrt4fHy8XnvtNRUuXFi9evXS3Llzdfr0aaf6+Ot3UnszzgXn+Pp2O3/+vJYuXWoXb9SokYoVK2a4TpcuXexi8+bN0/Xr1zPUt69vO3fwhTHp6tWrhvFChQq5lNeR0NBQh9c8uD/2l2d069bNcDwrXLiwxo0bZ0FFf7h+/boWLFhgFw8KCtILL7xgFy9evLieeOIJu/j8+fMzPMbjDx07djSM79+/X+fPn/dwNfaioqKsLkHSH3MfPXr0sLqMdPPEfY8V8wzePsfgD3Nk3og5Le/ji3MrVsnMx6+33zt6+2cyvlqfP57Xmem1ppe3n99W4ngBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMB5gVYXAAAAAAAAAAAAAADAn44cOaJGjRrp7NmzaeLFihXT0KFDtXPnTiUlJWnp0qV321577TXdunVLu3fv1siRI1WpUqU06165ckWNGjXS6dOnHfbbp08fLVu2LE2sYMGC6t+/v9asWaNr167p1q1bunbtmq5cuaKkpCRFR0dryZIl6tixo4KDg9Osu3jxYnXr1s3JreA6m81mes5169bp+eefV1JS0t3YAw88oP/85z/av3+/EhISdPr0aR09elTXrl3T1atXNWvWLNWuXTtNnkuXLqlp06Y6derUPfvzt30CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICvun37tjp37qzbt2/btQUFBWnatGkKCQlxKndKSoqio6Pt4jly5FC2bNmcyulpY8eONYw7+h7FTp062cXi4uI0d+5cM8vKsNTUVF2+fNmwrWDBgh6uxlhKSophPGfOnKb2U6xYMVPzucpms+nIkSP68ssv9fDDD+uDDz4wXC4sLEw9evTwcHUZc/78ecN4oUKF3Nano9yXLl1yW5/+yB/Ga1/gjed7yZIl9fzzz9vFk5KS1LhxY3399ddKTk52uZ/8+fO7nMMTOBec4w/bzeiaLyAgQF26dLGLP/nkkypRokS6ctyPP2w7M/nKmHT48GHDeEREhEt5HalevboCAwPdkjszYH95xvLly/XVV18ZtrVr187hPbQnTJgwwTDetWtXu1jnzp0VEBCQ7hy4t3z58qldu3aGbUuWLPFwNfby58/vsD4r9OjRwy/GDzPvezw9z+AtcwyZdY7MSsxp+Q5vnFuxWmY8fn3h3tHbP5Px9voy03xJZnqt6eEL57eVOF4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHCe739rKAAAAAAAAAAAAADAr+zbt0+PPfaYZs6cKZvNZtceFBSk8PDwuz+HhIQoICDAMNe8efP0yCOPaP/+/ffsMzk5WS1bttSwYcOUnJxsuEy2bNmUL18+FShQQMHBwYbLJCUl6b333lObNm10586de/bpi+bOnatGjRrp+PHjdm3Zs2dX8eLFVbZsWeXLl89wn/z888+qVq2adu/efd++2CcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHiP3bt368MPPzRse+ihhzRs2DCnc585c8Yw/sgjjzid05MWLlyoy5cv28U7d+5s+P2OHTp0sIvNnj1bCQkJbqkvI06fPm0Yr1atmocrMXb9+nXDeK5cuUztp0KFCqbmM5PNZtO///1vffPNN4btTZs29XBFGXPw4EHDeM2aNd3WZ0REhGH8wIEDbuvTX/n6eO1rvOV8b9GihQIDA+3i33zzjbZs2WJKH4GBgWm+t9rbcS44x9e325IlS3ThwgW7ePfu3e1i3bp1s4sdPXpU69atc6pvX992ZvKVMenQoUOG8bp167qU1xF3XktlBuwvz3nnnXe0f/9+w7avvvpKpUuX9nBFf1i5cqXhWFu1alU9/PDDaWJdu3a1W+7MmTNatWqV2+rzZ//617+UI0cOw7bJkyd7thgDXbt2VXBwsNVl3FWkSBG1bNnS6jJM5ep9j6fnGbxljoE5Ms9jTss3ecvcitUy4/HrK/eO3v6ZjLfXl5nmSzLTa70fXzm/rcTxAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAc+y/IQkAAAAAAAAAAAAAAIvFxMSoQ4cOeuyxxzRmzBhdvXo13eteuXJFEydOVJUqVfTss88qOjo6XeulpKRowIABqlixoj799FOdOXMm3X1GR0fr008/VcWKFTV8+HClpqame11fs2nTJlWsWFG9e/fW/v3777t8SkqKVqxYoebNm6t58+a6cOFCuvtinwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4D0++ugj7dixw7DtjTfeUP369Z3Ku2/fPsN4zZo1ncrnaXfu3NF3331nFy9atKgaNmyYJlazZk2VKVPGbtmJEye6rb6M2L17t2G8du3ani3EgevXrxvGS5UqZWo/zh7LnjR48GDduXPHLl6jRg0Lqkk/R9+HWrduXbf0V6FCBT3wwAN28aSkJB0/ftwtffozXx+vfZXV5/sTTzxhGP/+++9N66NatWrKnj27afncjXPBOb6+3VJTUzVp0iS7eJkyZdK8j4WGhuqZZ56xW27cuHFO9+3r285MvjImrVmzxjDerl07ZcmSxaXcRjp06GB6zsyE/eU5SUlJ6tChg5KSkuzawsLCNH36dLds8/ux2WyaPHmyYVuXLl3u/n/NmjVVrlw5u2UmTZokm83mrvL8VpkyZdSvXz/Dtg0bNui3337zcEX2evXqZRjv1KmTQkJC3Prvl19+Mew7KirKnS/ZMs7e93hynsGb5hiYI/M85rR8m9VzK1bLjMevr9w7evtnMt5eX2aaL8lMr/V+fOX8thLHCwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzgm0ugAAAAAAAAAAAAAAABzZu3evevfurfDwcP3jH/9Q586d9d5772nGjBl3l9myZYveeOMNtW/fXg899JAKFiyol156Sbt373aqz5MnT6p///4qUaKESpUqpbZt2+qtt97Sxx9/rC+//FKjR4/Wp59+qvfee0+dO3dWhQoVFB4erv79++vUqVMZ6qt169YKCAjQBx984FStf6pRo4YCAgLu/vvpp59cync/d+7c0ZgxY1SpUiUVKVJEHTp00Ntvv61PP/1Uo0eP1ogRI9S/f3+1bt1a4eHhatKkiX7++Wen+/PkPgEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMZSUlLUpUsXJSUl2bUFBATou+++U86cOTOcd+vWrYbxBg0aZDiXVcaNG2cY79atW5qfO3XqZLfM0aNH9csvv7ijrAzbsmWLYbxFixYersRYTEyMYbxq1aqm9REUFKQmTZqYls9drl27Zvj9rTlz5lRwcLApfWTJksWUPH+1YsUKw3irVq3c0l/btm0N4+vWrVNKSorp/fk7fxivfZEnzvd7efDBBw3jhw4dMq2Phg0bmpbLEzgXnOMP223cuHGy2Wx28e7du9/9//bt2ys0NDRN++3btzV58mSn+/WHbWcWXxmTVqxYYXisFClSRO3atXM5/1/VqlVLjz76qKk5Mxv2l2ft27dP77//vmFbrVq1NGjQIA9X9IdJkyYZHgedOnVSQECAJPt7fEmy2WyaNGmSu8vzO0FBQfruu++UPXt2w/YPP/zQwxXZe/LJJ1WuXDm7eExMjObMmaPk5GS3/hs/frxhXc2aNVPx4sXd/fI9ztn7Hk/OM3jTHIO/zpG5Y27ILMxp+Tar51YyyuxjKjMev75y7+jtn8l4e32Zab4kM73W+/GV8zu93DEOc7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOCcIKsLAAAAAAAAAAAAAADgfmw2mw4dOqRDhw5JkqpWraoOHTpIkjZs2KAvvvjCLf2eOnVKp06dckvuvwoLC5Mk3bp1y+19me3ChQuaOXOmx/rz1D4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2Dh48qEGDBunTTz+1aytRooRGjRqlF198MUM5ly9fbhh/6qmnVKBAAUVHRztVqycdO3ZMa9euVYMGDdLE27Vrp969eys+Pl5ZsmTRc889Z7fuxIkTPVTl/f3888+G8YceekiNGjXSqlWrPFxRWgcPHjSMFypUSGXLltWxY8dc7uOZZ55RgQIFXM7zV4UKFdKlS5dMzSn98b2iRvLkyaMrV66kO8/vv/9uGM+ZM6dTdd3LunXr9Pvvvys0NDRNvFixYnr22Wc1a9Ys0/rKmjWr+vbta9i2cOFC0/rJTPxhvHY3bz/fnZE3b17DeGJioin5AwMD9fLLL5uSy1M4F5zjD9vt9OnTWrlypSIjI9PEn3vuOb322mtKSEhQt27d7NZbuHChS6/PH7adWXxlTLp69arhsSJJQ4YM0Y8//qjk5GSX+5Gk//znP6bkyczYX573+eefq0WLFmrUqJFd28CBA3Xr1i2P13Tq1CmtXr3arqbChQurUaNGWr9+vZ5//nm79VatWqXTp097qky/MXr0aNWpU8ewbf369Q7f+zwpKirKMD59+nTTxoR7mTVrlr788kuFhYWliQcGBqpnz54aOHCg22twxJvuezw1z+Btcwy+Okf2J0/ORZmFOS3P8aYxxt08dS5kxuPXV+4dvf0zGW+vLzPNl2Sm13o/vnJ+/50nr384XgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcE6g1QUAAAAAAAAAAAAAAJDZ1alTR5J0/vx5iysBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC4txEjRujXX381bOvevbueeuqpDOU7ceKE9u3bZxcPDg7Wyy+/7FSNjuTOnVuFChUyNeefxo0bZxfLkSOH2rdvL0mKjIxUeHh4mvbU1FRNmTLFLfU44+LFi9q0aZNh23vvvWdqX48++miG1zly5IiuXbtm2NatWzcXK5KCgoL073//2+U8fypatKhGjx6t06dPq02bNqbl/VNwcLBh/NatWxnKc/36dcN4iRIlMlzT/SQnJ2vWrFmGbQMGDFDWrFlN66tnz54qXLiwXTwpKUlz5swxrZ/MxF/Ga3fwlfPdGXFxcYbxAgUKmJL/hRdeUJkyZUzJ5SmcC87xl+02duxYu1hYWJieeeYZlSpVSk888US61skIT207XzjefGlM+uqrrwzjDz/8sD766CNT+ujZs6caN25sSq7Mjv3leV26dFFMTIxdPEuWLAoLC7OgImnChAmG8a5du6pVq1bKmzdvuteBsYCAAI0ZM0Y9evQwbE9KSlLv3r09XJW9/Pnzq23btoZt48eP90gNCQkJ+v777w3bXnrpJWXJksUjdfyVN973eGqewdvmGHxtjuzvPDkXZRbmtNzPG8cYd/PUuZAZj19fuXf05GcyPXv2zPDnMt5en7/MNaVHZnqt9+Mr5/ffefL6h+MFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADnBFpdAAAAAAAAAAAAAAAAmVVAQIC++OIL1apVS5K0dOlSiysCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC4N5vNpi5duighIcGwfdy4ccqfP3+Gco4bN84wPmDAAJUrVy7DNToycuRIHT58WH379lVgYKBpeSVp3rx5iomJsYt369ZNktSpUye7tuXLl+vChQum1uGqMWPGGMYbNWqkfv36mdJH9erVtXv3bi1atEgREREZWveXX34xjL/88svKkyePS3W9//77qlixoks5JKlo0aL65ptvdPz4cUVFRSk4OFhffvml8uXL53LuvypbtqxdLCEhQXFxcRnKc/78ecN4uXLlVLBgQadqu5cRI0bIZrPZxStVqqQvvvjClD6qVKmiESNGGLZNmTJFV65cMaWfzMgfxmsz+dr57oyrV68axmvXru1y7iJFimjkyJEu57EC54Jz/GG7LViwwPB9pHv37uratasCAgLSxE+fPq0VK1a43O+9tp1ZfOF486UxafHixdq7d69h25tvvqkePXq4lD8yMtK0ayewv6xw4cIF9ezZ0+oy0vjhhx8UGxtrF2/Xrp1effVVu3hsbKzmz5/vgcr8Q6FChbRq1Sr16tXL4TIDBw7UwYMHPViVse7duys4ONguvn37dodjhTuMHz/eMF6oUCE99dRTHqvD2+973D3P4K1zDL4wR+aIp+eizMKclnt4+xjjTp48FzLb8etL946e+kxm9OjRTn0u4+31+cNcU3plptd6L750fv+Vp69/OF4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMg4vokHAAAAAAAAAAAAAAAL5M2bV0uXLlW/fv0kSadOndIHH3xgcVUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD3d+zYMfXv39+wLTw8XOPGjctQvgkTJig6OtouniNHDk2fPl2hoaFO1flXPXr0UPfu3ZUrVy6NGjVKO3fuVO3atV3O+6ekpCRNmzbNLl6vXj098sgjatu2rV3bxIkTTevfLDNnztTRo0cN2z777DO1aNHCpfyFChXSnDlzJEmtWrXSli1btGLFCoWHh6dr/dmzZxvGw8PDNXLkSKfratOmjYYMGeL0+n81ZswY9e7dW8HBwXdjxYsX15w5c5Q9e3ZT+oiIiFDZsmXt4ufOnctwrvPnzztc75VXXslwvvs5dOiQw/34yiuv6I033nApf7ly5TR//nxly5bNri0xMVHDhw93KX9m5w/jtZl87Xx3xpEjRwzjvXr1cilvjhw5NHfuXBUoUMClPFbhXHCOP2y3O3fu6LvvvrOLN2jQQL1797aLjx8/XjabzeV+77XtfGG7mcWXxiSbzaa+ffsatgUGBmrcuHEaMGCAAgMDM5z7n//8pxYtWmTaew3YX1aZN2+e4ZhqlaSkJM2YMcMuniNHDjVs2NAuPn36dCUlJXmiNJ8WGhqqd955R0eOHNGTTz7pcLlZs2ZpxIgRHqzMMUfvK+PHj/doHVu2bNGBAwcM26KiojxWh7ff97hznsGb5xh8YY7MEU/PRZmFOS338PYxxp08eS5ktuPXl+4dPfWZzJ/3Mhn9XMbb6/OHuab0ykyv9V586fz+K09f/3C8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQcRn/9mIAAAAAAAAAAAAAACx24cIFDRkyREOGDNGyZcusLscpDz/8sBo3bixJ2rdvn+rVq6dr165ZXBUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAED6fP3111qzZo1hW9u2bdW5c+d050pISNCQIUMM22rUqKH169crPDzcqTolqW/fvvr222/TxB599FFt2rRJTZs2dTrv340dO9YuFhAQoBkzZig0NDRN/Pr16/rxxx9N69ssKSkpeuuttwzbsmbNqoULF6pfv35O5a5YsaLWr1+vkiVLpokXKlRI0dHR6crx/fff68KFC4Zt3bp107BhwzJc18svv6y5c+cqMDDwbuzIkSMZzvOnQYMGyWaz2cUbNmyoVatWqVixYk7nlqQ8efJowoQJhm1Lly51KufatWsN4++++66eeOIJp3LeS79+/XTjxg3Dts8//1xjxoxRcHBwhvNGRkZq69atKlGihGH7Bx98oBMnTmQ4L/6fv4zXZvHF8z2jHH2HdGRkpF566SWnchYuXFgbN25UrVq17sZ27tzpVC6rcC44x1+227hx4+xiAQEBdrWnpKRo4sSJpvR5r23nK9vNDL42Jq1bt05jxoxx2P7hhx9qz549atGiRZprUUeqVq2q5cuXa+bMmQoJCbkbv3jxouLj402pOTNjf1mjT58+XnWN7ujay9VlM5ugoCA1aNBAX331lc6fP69PPvlEOXPmdLj8unXr1LVrVw9W6FijRo1UpkwZu3hCQoJmzpzp8XrGjx9vGI+MjFTp0qU9UoMv3Pe4Y57B2+cYfGGO7F48PRdlFua0zOcLY4w7efJcyEzHry/dO1rxmYyU/s9lvL0+f5lrSo/M9FrvxZfO77/z5JjP8QIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQMbd/1uLAQAAAAAAAAAAAADwMpcuXdLQoUM1dOhQrVy50upynLJx40a9//77mjZtmmrXrq1z585ZXRIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECGdO/eXXFxcYZtX3/9tYoVK5buXKNHj9a6desM26pWrar9+/frlVdeUVBQULpzVqpUSUuXLtWoUaMUGBho175t2zatWLEi3fnu58CBA9q8ebNhHX83Y8YMJScnm9a3mRYtWqTJkycbtmXJkkVffPGFtm/friZNmqQrX1hYmAYOHKgdO3aoXLlyadpsNptef/112Wy2dOW6c+eORo4c6bD9vffe05IlS+z6MVK1alUtXbpUY8eOTXNcbdu2TQsWLEhXPUZ27dql0aNHG7bVrl1bBw8e1KBBg5Q/f/4M527atKm2bt2qRx55xLB9zpw5Gc4pSWPGjDGMBwcHa+XKlRo+fLhKlCjhVG4jly9fVlRUlMP2Xr166ciRI+rUqVO6zvmHH35Y8+fP1/Lly5UnTx7DZTZu3KjPPvvM2ZLxF/4wXpvFF8/3jNqwYYOuXr1q2DZ27FgNGjQo3fs6ODhYffv21Z49e1SlSpW78djYWA0ePNiUej2Jc8E5/rDdjh496vA1/NXSpUt14cIF0/p1tO18ZbuZwRfHpL59+2rLli0O2x955BEtWbJEV69e1fTp0zVw4EC9/PLLevbZZ9W1a1f1799fo0eP1smTJ7Vjxw5FRkba5YiKilJiYqJpNWdm7C/Pi4+PV8eOHZWSkmJ1KZKknTt3as+ePfddbs+ePdq1a5cHKvKsJk2aqGfPnhn698orr+jtt9/WRx99pClTpmjz5s2Kj4/XmjVr1KdPH+XOnfueff70009q1qyZkpKSPPQq783RvercuXN18+ZND1cjTZ061XD+KCAgQD179vRIDb5w32PmPIOvzDH4whzZvXh6LsoszGmZzxfGGHfy5LmQmY5fX7t39ORnMlLGP5fx9vr8Ya4pvTLTa3XE187vv/L09Q/HCwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGRNgS+c3aAUEBLi7FgA+qnLlyqpcubKkP76c78SJE9q8eXO6v6APAAAAAAAAAAAAAAAAzuk3TwoJtboK+LNz+6UZb1tdBQDAkYCAAFWvXl3ly5e/+/vee/fu1d69ey2uLHPid2oBAAAAAAAAAAAAAAAAAAA8KyAgQDVq1FC5cuX4fVoA6ebK73jzrHYAjvB3JQAAAAAAAAAAAAAAAPBXUVOkXOFWVwE49kU7KTnB6ioAWIVntXsXfqcW8C4nT55UyZIl7eLPP/+8Zs+e7bZ+e/TooXHjxhm2rV69Wo0aNUp3rvDwcG3btk3Fixd3uMzly5e1dOlSrVy5UmfPntWVK1eUkJCg4OBg5cyZU8WLF1flypXVokUL1apVy2GeixcvqlatWjpz5ky660uP7t27a+LEifddrlq1atq5c6epfZspJCREq1ev1uOPP37P5aKjo7V8+XLt2rVLV65c0bVr1yRJuXPnVqlSpRQREaEmTZooe/bshusPGzZMAwYMyFBtWbJk0dq1a1W3bl2Hy6Smpmrz5s1atmyZzpw5o+joaAUEBChfvnyqVKmSIiMj9eijj9qtl5SUpOrVq6tjx456991307TFx8crZ86c6aoxODhYmzZtUvXq1R0uc/v2bf3yyy9au3atDh06pFOnTikuLk4JCQkKCAhQaGio8uTJozJlyqhKlSpq0aKFypUr5zDfokWL9NRTT6WrPiMbNmy45zaVpPPnz+vMmTOKi4tTamqqXfvly5fVrVu3dPf54Ycf3nf/37hxQ8uWLdPWrVt16dIlXbt2TaGhoSpYsKDKlSun5s2bq0KFCvfMceLECUVERNw9PjPK0bWNmX9/uHTpUjVr1swu3rRpUy1fvtyUPt58803997//tYuPGDFC//rXvzKUy9vHa0/ssz/54vmeUa+//rpGjhzpsP3ChQuaOnWq1q9fr8OHDys2NlaJiYnKnTu3wsPDVbZsWTVt2lQtW7bUgw8+mGZdm82mtm3b6tKlS9qyZYtd7vr162v9+vXprtWT+17y/nPBTGZuW3/Ybh06dND06dPvucxTTz2lRYsWmdrv/bZdZhh7fWlM+lOePHm0YsWKe75XOOvDDz/UoEGDFB0drfz589u116xZU1u3bk13PrP2oyfH40mTJhleg3bt2lVTpkzJcD5f2l9mczSvUKJECbe//3zwwQcaPHjwPZd54IEHFBMT49Y6JOm1117Tl19+ed9lvv76a7fXIrlnvsdRTk+y2Wz6+OOPNXjwYKWkpJiS09VtFR4ernPnzilr1qx2bU888YQ2bNhgRpkZNmfOHD377LN28StXrqho0aK6ffu222vwlfseV+cZ+vbt61NzDL4wR3YvnpyLMvvaxBfmtHzpesxXxhh3cfVc8Nc5WVf52r2jpz6TkZz7XMbb6/P2uabMNq9m9HrNfP/xtfP7rzz9WZwvHC8AANfwrHYAzuBZ7QDcgb8rAQAAAAAAAMzVvEVzNWzY0OoykMn8tOQnrVmzxuoyAMAjeK+FVX6Y94N+/fVXq8sAAI+I7CNVaWV1Fchsln8l7V5idRUA4Fk8q9278Du1AAAAAAAAAADAUzz9/UwAAAAAAADeime1A3BGen7HO8CWzt8EZ2IWgCP8oQkAAAAAAAAAAAAAAIA1+s2TQkKtrgL+7Nx+acbbVlcBAHCEh7d7F36nFgAAAAAAAAAAAAAAAAAAwLN4eDsAZ7jyO948qx2AI/xdCQAAAAAAAAAAAAAAAPxV1BQpV7jVVQCOfdFOSk6wugoAVuFZ7d6F36kFvMvJkydVsmRJu/jzzz+v2bNnu7Xvn376Sc2bNzds69u3r7766qt05ypXrpxWr16tokWLmlWencuXLysyMlL79u0zPXeOHDl08eJF5cqVy+Ey+/btuzt+erPcuXNryZIlqlOnjlvyjx8/Xj179nTqfaNw4cLavXu3ChQoYFo9NptNL774oiZPnqyPP/5Y7777bpr2+Ph45cyZM9358ufPr2XLlqlq1aqm1ejI1atX9dhjj+n8+fNO5yhVqpT27NmTodf4d6dOnVKpUqUytM5HH32k999/3+k+7+fgwYNq1qyZzp4963QOR8eomX9/uHTpUjVr1swu3rRpUy1fvtyUPt58803997//tYuPGDFC//rXvzKcz5vHa0/ss7/ytfM9o4KDg7V582ZVqVLF9NzvvPOOPvvsM0VERGjLli127fXr19f69evTnc/T+17y7nPBTGZvW1/fbiEhIbpw4YLy5ctn2H7hwgUVK1ZMqamppvft7m3n7WOvL41Jf5UrVy5NmTJFbdq0cbXMu/76Hh4dHa38+fPbLVOzZk1t3bo13TnN2o+eHI8nTZqkbt262cW7du2qKVOmOJXTV/aX2RzNK5QoUUJnzpxxa99ZsmTRpk2bVLNmTYfLPPDAA4qJiXFrHZKUL18+Xbx4UcHBwYbtSUlJevDBB3X9+nW31yK5Z77HUU5POXjwoPr06aM1a9aYmtfVbdW/f38NHz7cLn706FGVL1/ejBKd0qRJEy1btsyw7bnnntOcOXM8Uoev3Pe4c57BG+cYfGGOzBFPzkW549rE2+e0fO16zFfGGHdw9Vzw1zlZV/nivaO7P5ORXPtcxtvr8+a5psw2r2b0es18//HF8/tPVnwW5+3HCwDANTyrHYAzeFY7AHfg70oAAAAAAAAAczVv0VwNGza0ugxkMj8t+cn0v/MAAG/Fey2s8sO8H/Trr79aXQYAeERkH6lKK6urQGaz/Ctp9xKrqwAAz+JZ7d6F36kFAAAAAAAAAAAAAAAAAADwLJ7VDsAZ6fkd70AP1AEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPzUSy+9pNjYWMO2Tz75RBUqVEh3rqNHj6p27draunWrSdWltXPnTlWvXl379u1zS/6EhATNnDnznstMnDjRLX2b7caNG2rcuLFb6h02bJhefvll2Ww2p9a/cOGC6tWrp+PHj5tST2pqqvr06aPJkyebkk+Srl69qgYNGmjBggWm5TRy7tw51a1bV+fPn3cpz8mTJ9WuXTvduHHDpMrSZ8CAAerRo4d+//1303MvWbJEderU0dmzZ03PDd8fr83ka+d7RiUnJ6t58+Y6efKkaTlv376tXr166bPPPjMtp1U4F5zj69stKSlJ06ZNc9g+adIkpaamuqVvd247XzjefHVMunnzptq2batevXrp2rVrLuW6du2aOnbsqH/9618mVYe/Y395XkpKijp27Kj4+HirS1FMTIx+/PFHh+0//vijrl+/7sGK/MexY8fUu3dvVa5cWWvWrLG6HDs9e/Y0jI8fP97DlaS1YsUKnTlzxrAtKirKY3X4yn2Pu+YZvHWOwRfmyByxai7KLMxpmctXxhh3sOJcyAzHry/eO7rzM5nU1FSXP5fx9vp8fa4pIzLTazXii+f3n6wY8zP78QIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQHoFWl0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADwXRcvXlSfPn0M27Jnz65p06YpS5Ys6c537tw51a1bVwMGDFBCQoIpNSYkJKh///6KiIjQuXPnTMnpyNixYx223b59W9OmTXNr/2ZKTEzUSy+9pKeeekonTpwwJefx48c1YMAAl/McPnxYERERWrp0qUt5oqOj1axZM33zzTcu1/R3cXFxevrpp9W+fXudOXPG1Nw2m03Tpk1TjRo1dPjwYVNyrly5UhEREdqwYYMp+dJrwoQJqlSpkn7++WdT8l28eFGdO3dWq1atFBsba0pOGPP18dpMvna+Z9Tly5dVs2ZNLVmyxOVce/fuVURExD3fL30N54JzfH27OTqGbTabxo8f79a+/7rtzOBrx5svj0ljx45VyZIlNWDAAB0/fjxD6165ckVDhw5VhQoVNGPGDDdViL9if3nW8ePH1a9fP6vLkKR7juPuHuP9TUxMjKZMmaKWLVuqfPnyGjNmjFJSUqwuy05kZKRKly5tF79z546+++47Cyr6fzabTZMnTzZse/LJJ1W2bFmP1eIr9z1mzjP4whyDL8yROWLVXJRZmNMyl6+MMe5gxbmQGY5fX7x3dNdnMpGRkabMIXh7fb4+15QRmem1GvHF8/tPVoz5mf14AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgPQKtLgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPi26dOna8GCBYZt1atX1/vvv5+hfLdv39awYcNUqlQpffTRRzp37pxTdZ09e1aDBw9WsWLF9OmnnyolJcWpPBmxc+dO7dq1y7BtyZIlunr1qttrMNuiRYtUoUIFdezYUZs2bZLNZstwjj179qhXr16qUKGCaXXFxMSoRYsWatiwoX799dcMrRsbG6vPPvtMZcuW1YoVK0yrycjcuXNVqlQptW/fXitXrlRSUpLTua5fv66JEyeqZs2a6ty5sy5dumRipdKRI0f0xBNPqGbNmvr222+1d+9epaammtqHkZMnT6p58+aqUaOGZs+erYSEhAzn2L17t3r16qWSJUtq2rRpbqgSRnx5vHYHXzrfMyo6OlqtWrVS+/bttXHjxgyvv3PnTv3zn//UY489pt27d5tfoMU4F5zjy9vtwIED2rx5s118xYoVOnXqlNv7/3Pb+dp2M4svj0nx8fEaNmyYypYtq6pVq6pPnz6aOHGiVq5cqW3btunQoUPatWuX1q9fr6lTp+q9995T7dq19eCDD2rIkCG6du2aXc6QkBDDvu7cuePul+P32F+eNXHiRM2fP9/qMrRixQqdPXvWLn727FmtXLnSgoq8V0pKiuLi4nTlyhUdOnRIP//8s7799lv16tVLVapUUXh4uLp27aqffvrJqbkET4mKijKML1myRJcvX/ZwNfYmTJhguP0CAgLUq1cvj9fjC/c9rs4z+Nocg6/MkRmxai7KLMxpmc8Xxhh3sOJcyAzHr6/eO5r9mczq1aszTX2+PNeUUZnptRrx1fNbsmbMz+zHCwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA9xNgS+e3cgUEBLi7FgA+qnLlyqpcubIkyWaz6cSJE9q8ebNXf7kzAAAAAAAAAAAAAACAP+g3TwoJtboK+LNz+6UZb1tdBQDAkYCAAFWvXl3ly5e/+/vee/fu1d69ey2uLHPid2oBAAAAAAAAAAAAAAAAAAA8KyAgQDVq1FC5cuX4fVoA6ebK73jzrHYAjvB3JQAAAAAAAAAAAAAAAPBXUVOkXOFWVwE49kU7KTnB6ioAWIVntXsXfqcWgKdVr15ddevWVbVq1VSiRAmFh4crNDRUQUFBSk5O1s2bNxUbG6vDhw/rwIEDWrVqlWXvEStXrlSjRo3s4k899ZQWLVpkQUXmKlSokBo0aKBatWqpbNmyKlasmMLCwpQ9e3alpqbqxo0bio2N1W+//aadO3dq9erVOnTokNvrKlasmJo2baoGDRqocOHCKlCggPLly6c7d+4oNjZWV65c0a5du7Rp0yYtXbpUycnJbq/JSI4cOVS/fn1VrlxZFStWVJkyZZQzZ06FhYUpNDRUNptN8fHxiouL082bN3X8+PG71zybNm3SnTt3PFpvaGioHnzwQeXJk0d58+ZV1qxZDZe7deuW1qxZY0qf2bJlU2RkpCIiIlS5cmUVKVJEuXPnVlhYmJKSknTjxg3FxMTowIED2rNnj5YvX67Tp0+b0jdc50vjtbv52vmeERUqVFDdunVVu3ZtlS1bNs0YERcXp9jYWB06dEi7du3SkiVLdOzYMatL9jjOBeew3ZyT2bdbZh6TAgMDlZKSYtj2j3/8wyPX4Ug/9hcAf+QL9z3pmWfYsGGD38wx+MocmSNWzEWZhTkt8/nCGOMu6TkXmJPNGF+9d/TWz2R8pb7MNGeSmV7r3/nq+f0nK65/MvPxAgD+gme1A3AGz2oH4A78XQkAAAAAAABgruYtmqthw4ZWl4FM5qclP3nd72YDgLvwXgur/DDvB/36669WlwEAHhHZR6rSyuoqkNks/0ravcTqKgDAs3hWu3fhd2oBAAAAAAAAAAAAAAAAAAA8i2e1A3BGen7HO8CWzt8E5+HtABzhD00AAAAAAAAAAAAAAACs0W+eFBJqdRXwZ+f2SzPetroKAIAjPLzdu/A7tQAAAAAAAAAAAAAAAAAAAJ7Fw9sBOMOV3/HmWe0AHOHvSgAAAAAAAAAAAAAAAOCvoqZIucKtrgJw7It2UnKC1VUAsArPavcu/E4tABgrUqSIzpw5o8DAwDTxy5cvq0iRIkpJSbGoMgAAAAD+Jk+ePLp+/bphW6FChXT58mUPV4R7YX8BAAAAAAAAAMzAs9oBOINntQNwB/6uBAAAAAAAADBX8xbN1bBhQ6vLQCbz05KftGbNGqvLAACP4L0WVvlh3g/69ddfrS4DADwiso9UpZXVVSCzWf6VtHuJ1VUAgGfxrHbvwu/UAgAAAAAAAAAAAAAAAAAAeBbPagfgjPT8jnegB+oAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADIFLp06aLAwEC7+LRp05SSkmJBRQAAAAD8VYUKFQzjt2/f1uXLlz1cDe6H/QUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgHcJtLoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfxAQEKCePXsato0dO9bD1QAAAADwdxEREYbx3377zcOVID3YXwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeJdAqwsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADwB61atVLJkiXt4uvXr9eRI0c8XxAAAAAAv9a4cWPD+I4dOzxcCdKD/QUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgHcJtLoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfzBkyBDD+KhRozxcCQAAAABvEhoaanrOIkWKqGXLloZty5YtM72/zIT9BQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABA5hBodQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC+rnPnzqpWrZpd/MSJE5o/f74FFQEAAACwWmBgoAYPHqyjR48qPDzc1NzvvvuusmTJYhdPTEzUzz//bGpfmQX7CwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAzCXI6gIAAAAAAAAAAAAAAAAAAAAAAAAApLVmzRrD+JNPPunhSjI39gPSy6xjhWMOAAAAAAAAgKcwHwl/wHEMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAb1O2bFmNGjXKsG3o0KGy2WwerggAAACA1YoVK6YZM2aobt26kqQffvhBjRs3VmJiosu5GzVqpFdffdWwbdasWYqNjXW5j8yG/QUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQObzv//9T//4xz/s4r1799Zvv/1mQUUAAADAH9asWWMYf/LJJz1cieeZ9doz8zYEAAAAAAAAAAAAkDFBVhcAAAAAAAAAAAAAAAAAAAAAAAAAIK0GDRpYXQLEfkD6mXWseOMxFxwcbBhPTk72cCVA5sQ5CPiWkJAQPfLIIypatKhy586tXLlyKUeOHLp9+7Zu3rypmzdvKiYmRgcPHtTFixetLhcAAK/ANa81ChcurDJlyqh48eIKCwtTaGiogoKClJycrPPnz+vKlSvav3+/rl27ZnWpANzIG+cjgYziOAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIA3iYiI0Jw5c5Q3b167tkOHDmnq1KkWVAUAAADASk8//bQmTpyoPHny3I3VqVNHy5cvV7t27XT16lWnczds2FDz5s1TQECAXdudO3f00UcfOZ07s2J/AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQOVWtWlW1atWyi+fKlcuCamC14OBgw3hycrKHKwEA92K8A3xDgwYNrC4hw8waX8x67WblYdyEt+BYBAAAAABr+MP9mD+8BgAAAMDdgqwuAAAAAAAAAAAAAAAAAAAAAAAAADBT3759lSdPHtPyJScnKzExUVevXtWlS5d07NgxnT59WjabzbQ+AMAblS9fXocPHzZsq1Chgo4cOeLhioDMhXMQ8H6BgYGqX7++nnvuOdWtW1cVK1ZUUFD6/oQ/Ojpau3bt0sKFCzVv3jxdunTJzdV6P7Pv5TJq48aNWr16tWX9A2YwOo+OHj2qmTNneryWV155Rfnz57eLf/rpp0pMTPR4PfBOXPN6Tr58+fTcc8+pSZMmqlevnuH5aeTy5cvaunWrFixYoIULF+rq1aturhQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMC7BQQEKGvWrAoICFBoaKjCw8NVtWpVtW/fXq1bt1aWLFkM1+vdu7dSU1M9XC0AAAAAq5UvX97wGez16tXTgQMH9O6772ratGm6fft2unPmy5dPb7/9tt5++21lzZrVcJlRo0bp6NGjzpadabG/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMrfy5cvr8OHDhm0VKlTQkSNHPFwRALgH4x0Ad/HX8cVfXxd8D8ciAAAAAFjDH+7H/OE1AAAAAJ4QZHUBAAAAAAAAAAAAAAAAAAAAAAAAgJneeOMNlSxZ0q19xMfHa9u2bVqxYoV++OEHh3/cDgAAAMD/5MqVS2+//bZ69uypggULOpWjQIECatKkiZo0aaIvv/xSa9as0dChQ7V+/XqTq/UdnriXu5fhw4dr9erVlvUPmMHoPEpNTdX58+c9Pr689tprqlixol3866+/VmJiokdrATKzSpUqafDgwWrTpo2yZs2a4fULFiyo1q1bq3Xr1kpNTdWCBQv04YcfateuXW6oFgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwPu1b99es2bNytA6X3/9tdatW+emigAAAAB4sxEjRujpp59WzZo17drCw8M1ceJEDR8+XIsXL9b69et15MgRnTt3Tr///ruSkpIUFBSkfPny6YEHHlCVKlXUsGFDtWzZUjlz5nTY565du/T++++782X5LfYXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACZU5DVBQAAAAAAAAAAAAAA8KeaNWtaXQIygdjYWB0+fNjqMgAAAAAAAODjwsLC9OSTT+rJJ5/UsGHDtGnTJn388cdasmSJ1aUBAAAAcJOgoCC9/fbbeuedd5Q3b17T8gYGBqpRo0Zq1KiRVqxYoddff10HDx40LT+AzC0wMFBTp05V5cqVdePGDavLAeAhefLk0ahRo9S5c2cFBASYkjMwMFDt2rVTu3bttGDBAkVFReny5cum5AYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPBXa9as0Ztvvml1GQAAAAAskpKSolatWumXX35RuXLlDJcJDw/Xiy++qBdffNHl/k6cOKEWLVooOTnZ5VyZEfsLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDMKcjqAgAAAAAAAAAAAAAA+NOz7Z+1ugRkAocOHtLhw4etLgMAAAAAAAB+pk6dOlq8eLFWrlypF198UWfPnrW6JAAAAPiJOnXqaODAgXbxDRs2aNiwYRZUlDmVLl1a33//vWrUqOHWfiIjI7V9+3a9+uqrmjRpklv7ApB5FC9eXKNHj1aHDh2sLgWAB9SuXVvz5s3Tgw8+6LY+2rZtq3r16qlHjx5asGCB2/qB87iPAGAFxh4Ansa4AwAAAAAAAAAAAAAAAAAAAAAAAAAAAADwdj/99JPat2+v27dvW10KAAAAAAtdvXpVTzzxhObNm6fHH3/cbf1s375drVq10uXLl93WR2bA/gIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPAuderU0cCBA+3iGzZs0LBhwyyoCAAAAAAAAAAAwDE+20B6cJwAAAAA3inI6gIAAAAAAAAAAAAAAAAAAAAAAAAAf9G4cWPt2rVLbdq00aZNm6wuBwAAAH6gYMGCatasmV08Pj7egmoypxYtWmjWrFkKCwvzSH/Zs2fXxIkTFRERod69e3ukTwD+74UXXtDixYs1Y8YMq0sB4EatWrXS7NmzlT17drf39cADD+iHH37Qq6++qtGjR7u9P2QM9xEArMDYA8DTGHcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN7q8uXL+ve//60xY8ZYXQoAAAAAL3Hp0iU1aNBA7733nvr3768cOXKYljspKUn//e9/NWTIEN25c8e0vJkZ+wsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMB7FCxYUM2aNbOLx8fHW1ANAAAAAAAAAADAvfHZBtKD4wQAAADwTkFWFwAAAAAAAAAAAAAAAAAAAAAAAAB4wrlz5xQbG5uhdbJkyaIcOXIoLCxMefPmVWBg4H3XeeCBB7Rs2TI1bNhQW7dudbJaAAAAAN6gTZs2mj17toKDg++5XGxsrFauXKn169frt99+05kzZxQXF6ekpCQFBQUpZ86cyps3r8qXL6/KlSurUaNGqlat2j1zRkVFKSkpSa+//rqJr8j3OHMv54xLly65vQ/Aat988402btyoM2fOWF0KADeoWbOm5syZo2zZsjlcxmazadOmTVq2bJl2796tQ4cOKTY2Vjdv3tTt27eVNWtWlSxZUhUqVFDlypXVvHlz1a5dW1myZDHMFxAQoG+++ebufwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADKT1NRU3bp1SzExMTp16pR27NihlStXatmyZbpz547V5QEAAADwMrdv39bQoUM1fvx4vfLKK+revbsKFy7sdL4bN25o8uTJ+vzzz3n2tBuwvwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyDyCrC4AAAAAAAAAAAAAAAAAAAAAAAAA8IS33npLs2fPdnr9kJAQlStXTlWqVFHr1q3VvHlzhYWFGS4bGhqqH374QZUrV1ZMTIzTfQKAlRITE7V9+3aHbQDci3MQsF6zZs00d+5cBQU5/rP8vXv3atiwYVqwYIGSkpIcLnf58mVJ0rZt2zR9+nRJUqlSpdSvXz9FRUUpJCTEcL1+/frp/Pnz+uyzz1x4Jb7N1Xs5AP8vd+7cmjZtmurXry+bzWZ1OQDXvCbKmTOnfvjhB2XLls2wPSUlRWPGjNEnn3yis2fPOsxz+/ZtHT16VEePHtXixYs1bNgwFSpUSG+++aZeeeUVhYaGGq43atQo7dy5U5s3bzbl9QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHir2bNn85xEAAAAAC65cOGCBg4cqMGDB6tq1apq0KCBatSoodKlS6tkyZLKlSuXgoOD06xz69YtnT9/XsePH9eOHTu0Zs0arVu3Trdv37boVWQe7C8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDMIzExUdu3b3fYBgD+gvEOgLv46/jir68LvodjEQAAAACs4Q/3Y/7wGgAAAABPCLK6AAAAAAAAAAAAAAAAAAAAAAAAAMAXJCUlaf/+/dq/f7+mTp2qPHny6L333tMbb7yhrFmz2i1fpEgRffTRR+rdu7cF1QKA686cOaMaNWpYXQaQaXEOAtYqXry4pk+frqAg4z/Jj4+P11tvvaWxY8c63cfJkyf1+uuv6/PPP9eMGTNUp04dw+U+/PBD/fTTTzpw4IDTfQHAn+rVq6f+/ftr+PDhVpcCcM1rov/85z8qXLiwYdvp06fVunVr7du3z6ncly5d0jvvvKPRo0dr+vTpql27tt0yQUFBmjlzpipXrqy4uDin+gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAzCQ1NVXbt2/X9u3b7dqyZMmikJAQ2Ww2JSYmymazWVAh/or9BQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4P/OnDmjGjVqWF0GALgd4x0Ad/HX8cVfXxd8D8ciAAAAAFjDH+7H/OE1AAAAAJ4QaHUBAAAAAAAAAAAAAAAAAAAAAAAAgC+KjY1V//791axZM928edNwmR49eujBBx/0cGUAAAAAXBEUFKS5c+cqX758hu0nT55U9erVNXbsWFP6O3PmjOrXr69JkyYZtgcHB2vy5MkKDOTxAADMMXToUFWrVs3qMgCYJG/evOrVq5dh2/Hjx1WrVi3t27fP5X5Onjyp+vXra8mSJYbtJUuW1BtvvOFyPwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQ2aWkpCghIUG3bt2SzWazuhzcB/sLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADfFmh1AQAAAAAAAAAAAAAAAAAAAAAAAIAvW716taKiogzbgoKC1KFDBw9XBAAAAMAVvXv3Vo0aNQzbTp06pTp16ujw4cOm9pmSkqIePXpo/vz5hu3Vq1fXs88+a2qfADKvrFmzasaMGcqePbvVpQAwQceOHZUtWza7eGpqqjp37qxLly6Z1tft27fVrl077dixw7D9zTffVO7cuU3rDwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAdwq0ugAAAAAAAAAAAAAAAAAAAAAAAADA182cOVO//vqrYVvTpk09XA0AAAAAZ+XJk0f//ve/Ddvi4+PVtGlTXbx40S19p6amqmvXrrpw4YJh+zvvvOOWfgFkTuXLl9fIkSOtLgOACRo1amQYX7JkicM5S1ckJyerc+fOSkpKShNPTEzUDz/8oNDQUNP7BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAHQKtLgAAAAAAAAAAAAAAAAAAAAAAAADwBzNnzjSMV65c2cOVAAAAAHDWu+++q3z58hm2vfrqqzpy5Ihb+4+Li1O/fv0M20qXLq1SpUq5tX8A/mnt2rWG8V69eql169aeLQaA6WrUqGEYdzRfaYZDhw7pu+++kySdPXtW7777rooWLaoXX3xRFy5ccFu/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYKdDqAgAAAAAAAAAAAAAAAAAAAAAAAAB/sHv3bsN4wYIFFRwc7NliAAAAAGRYcHCwevToYdi2YcMGTZkyxSN1zJ07V8eOHZMkxcXFadq0aWrZsqXCw8N18uRJj9QAwL/07dtXp06dMmybMGGCChYs6NmCAJgqPDzcMH7o0CG39vvxxx+rXbt2KlmypD755BNdu3bNrf0BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGC2IKsLAAAAAP6PvfuOj6rK/z/+Tg8kAUKXIkWaIE2pUkR6SSCAyMIqCquggKKuYqG40vziFhFXXcGGHQSEgAgBCyBFUBciRekoUqQnIY2Q/P7wB0uYO8mUO5N7J6/n48FD+Jy5n/uZzDnnnjtjzgAAAAAAAAAAAAAAAAAAAASC48ePO22LiYnR6dOn/ViNZ0qUKKESJUooNzdX58+fV15eXlGX5FRYWJiio6OVm5urlJQUS9cK/4uJiVFoaKjS0tJ08eLFoi4HbgoJCVFMTIyCgoKKxWto9fksIiJCYWFhSktLK+pSXHL5Wpaenq7MzEyfnCM0NFQxMTHKzMxURkaGT85hRREREYqKivLpz9Zbl2vMyMgoVq+NlVx+DbKzs20zb1xt4MCBKleunGHbk08+6ddaxo0bp4iICK1YsUJZWVl+PbfEesosdh8TvmT1NVCgjYHz58/rz3/+s9atW6eQkJB8bRUqVNDbb7+t3r17F1F1vsMYhLvssOa9VokSJRQWFmbYduLECZ+e+9ChQzp06JBPz2HEjnN0eHi4oqOjlZmZqfT09KIux3Ls9JryvoMju/RvO/Uz+J9d1gDFtR8z99rj3qa4fbYDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwBMeHq7o6GhlZmYqPT29qMuxjIiICEVFRSk7O1tpaWlFXU6BLteakZGhjIyMoi4nIIWFhSk6Olq5ublKSUlRXl5eUZcUcOw05q51ufb09HRlZmYWdTm2YNfX2y7XzJiYGIWGhiotLU0XL14s6nIKVZzHkB2eO+sM+7LLnOVL/AwCg13XDZJ15/mQkBDFxMQoKCjINusFq7Hqa+svdnn+dlsXw3roQ56z28/OLvOa3ditH3jLrutWO9432aVmu/YJ2APXLvux6nWR9wgAAABwtdCiLgAAAAAAAAAAAAAAAAAAAAAAAAAIBFlZWU7bQkJC/FhJ4cLCwnT77berZ8+eatKkiRo1aqQKFSrkqzMvL0/nzp3TmTNntH37dq1du1Zr167V9u3b/V5vs2bNFBcXpxYtWqhx48aqWrWqIiIi8tWakpKiXbt26fvvv9eKFSuUlJSkS5cu+b1Wd0REROiGG24wbEtNTdWvv/7qEK9bt67CwsIc4seOHdPZs2e9rikmJkbVq1d3iO/evduUDdpr1aqlEiVKOMT37t3r0eYHERER6tGjh3r06KGmTZvqxhtvVGxsrIKCgq48Jjs7W4cPH9aOHTu0ceNGLVmyRPv27fPqeRQnDRs2NIzv2rXLlPytWrVSly5d1KpVKzVr1kzly5dXdHR0vsdkZ2frt99+044dO/Tf//5Xy5cv19atW005v79ZfT676aab1K9fP7Vq1UpNmjRR1apVr8w5eXl5Onv2rHbu3Knk5GQlJSUpKSnJ9I1wjPrciRMndPr0acPHd+7cWYMHD1bbtm1Vv359hYeHX2nLycnRL7/8om3btunLL7/UJ598ot9//93tmpo3b66hQ4fq1ltvVePGjRUTE3OlLT09XSdPnlRycrI+//xzrVixQocPH3b7HM6YNQbd/bmWLVtWgwYNUufOndW8eXPVqFEj38/28vPevXu3Vq9eraSkJO3YscOtmrxVpUoV3XHHHWrfvr2aN2+u66+/Pl+Nly5d0tGjR7Vz505t3LhRiYmJTtcxoaGhKlu2rEP8zJkzysnJ8dlzuKx8+fKqWLGi0/brr7/eMF66dGmnfcSZ7Oxs066DBc0Zkv/mDTONGDHCML5582Zt2rTJr7WsWLHCL+dhPWUeK40Jd+d96Y++0KRJE9WpU0elS5e+slHZZbNnz/a4ViuvgYrTGNi4caOef/55TZw40aGtV69eGjNmjF555ZUiqMwcRTEGuUc3B2te7xTUF66ey+zIKnO0u30rNjZW/fv3V7du3dS0aVPVrl0733Xv0qVLOn78uJKTk7V161Z9+umn2rZtm9t12fE+wgqvKe87eCcmJkZ9+vRR79691axZM9WrV88n/dsbduxnl+v21XrcTHace64VGxurfv36qVevXmrSpIluuOGGfGs6K6wBrNCPzcTc6x4rvb/gjD8/2wmEeQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC+17BhQ4fYiRMndPr0acPHx8bGqn///urWrZuaNm2q2rVrKyIi4kr7pUuXdPz4cSUnJ2vr1q369NNPtW3btiKvW5IiIiLUpEkT1alTR6VLl1ZMTIyCgoKutM+ePVuZmZke1XPTTTepX79+atWqlZo0aaKqVasqLCzsSnteXp7Onj2rnTt3Kjk5WUlJSUpKSvL4fN6oWrWq+vfvr44dO6pp06aqWbOmwsPDr7Tn5OTo0KFDV+pcsmSJTpw44bN6KlasqPLlyzvEC3s93REUFKQbb7zRIZ6bm6uffvrJlHNcrVmzZoqLi1OLFi3UuHFjVa1aNd84ycvLU0pKinbt2qXvv/9eK1asUFJSki5duuTWecqXL6+KFSs6bb/++usN46VLlzYcQwXJzs7Wvn37CnyMs5y7du1y61yusNKYc3c+Klu2rAYNGqTOnTurefPmqlGjRr4xmJ6erpMnT2r37t1avXq1kpKStGPHDtPrthO7vt5WuWYWJCIiQj169FCPHj3UtGlT3XjjjYqNjc13fczOztbhw4e1Y8cObdy4UUuWLCl0PnCHHceQWfOdHZ97YapUqaI77rhD7du3V/PmzXX99dfnq/HSpUs6evSodu7cqY0bNyoxMVHbt283zBUaGqqyZcs6xM+cOaOcnByfPQdn/LFmkcxdtwTanOVrMTEx6tOnj3r37q1mzZqpXr16fv8Z+HM95U+sE//HjvN8q1at1KVLF7Vq1UrNmjVT+fLlFR0dne8x2dnZ+u2337Rjxw7997//1fLly7V161af1+YuruHmCMTnXxTr4rp16+abny47duyYzp4963Hey2JiYlS9enWH+O7du5WXl+d1/lq1aqlEiRIO8b179+rixYte53eVVd4jLIo+VKVKFZUpU8YhfvbsWR07dszjvAUpW7asKleu7BA/ffq0x+8fcl/qPjvemxTGCv3A36yybrXjZ0R2rNkVdu0TkvvXVqt9tmHHedVu1y5nNUvO78es1k8k/72/YeXrYiC9RwAAAADfCMpz8R3oqxe4AHC1Jk2aqEmTJpL+eFPswIED2rx5sykfcAEAAAAAAAAAAKB4+fs//l7UJaAY2L1rt956662iLgMATDFukRQRVdRVIJAd2SF9+HhRVwEAcCYoKEgtWrRQvXr1rvz/3snJyUpOTi7iyoon/p9awFoOHjyomjVrOsQHDx6sBQsW+Oy8NWvW1MGDBw3bKlSooFOnTrmcy9n84e3v+FSuXFmPP/647r//fpUqVcqjHFu3btXzzz+vJUuW+HSeK1mypO6//36NGzdOtWrVcvv4kydPatasWXrxxReVkZHhUQ2+eh2kPzZb+Oyzz9SuXTuHtl9++UXdu3fXzz//7ND26aefKiEhwSH+5ptv6r777vO6rsmTJ+u5555ziN96663atGmTV7lDQ0N16tQplS5dOl/87Nmzqlixolsb11avXl1PP/207r77bodNFFyxdetWzZgxQ0uWLHH7WCNm9RVf9jlP+aKmsLAwPfDAA3rggQfc3nTksiNHjmj27Nl6/fXXlZKS4nEt/mCF+awgYWFhuueee/T444+rfv36bh174cIFvf/++5o5c6bTa6C7jPrck08+qRdeeCFfrEePHpo1a5YaNGjgcu5Lly7p3Xff1aRJk/Tbb78V+vg2bdpo1qxZat26tcvnyM3N1YcffqiJEyfq8OHDLh/njC/nF6Ofa5UqVTRlyhQNGzbMcPPNgqxfv16TJ0/W119/7dZx7mrVqpWmTp2qbt26uf1z+O677zR16lQlJibmi3fs2FFr1651eHzr1q21ZcsWr+p1hbPrry+sX79eHTt29Ph4b+YMyTfzhlkiIyN17ty5fJveXTZy5EjNnTu3CKryHautp6Siu5fzhlXHhKvzfnBwsAYNGqT7779ft912m0JDQ53mLFeunM6cOeNyDVZfA1lxDJjB2TiqUaOGfvnlF4WEhGjTpk1q2bKlw2MyMzN18803a/fu3abUsnv3bsO1mrt9qSBFPQa5RzcHa17vZWRkKDIy0iHeuHFjS395gjNWm6Nd7VvVqlXTpEmTNHz4cLf71k8//aQZM2bogw8+UG5urkvH2Ok+wkqvKe875OfqHBwbG6unnnpKo0ePdvs19KR/e8KO/cyX63FfseLc42o/rlixoiZOnKiRI0ca3vsXVos/1gBW6sdmYu4tXFHf27iiqD7bseK8AwCwnqCgILVs2VJ169bl/6cF4DJv/t9H9moH4Ay/VwIAAAAAAAAAAAAAAIBA9cC7UqmKRV0F4NysAVJ2elFXAaCosFe7tfD/1AIAAAAAAAAAAAAAAAAAAPgXe7UD8AR7tQPwBX6vBAAAAAAAADBXr9691Llz56IuA8XMis9W6KuvvirqMgDAL7jWoqgsXrRYmzZtKuoyAMAvuo2VmscVdRUobpJelrZ9VtRVAIB/sVe7tfD/1ALWYTTunnzySb3wwgv5YtWqVdOkSZM0fPhwhYWFuXWOn376STNmzNAHH3yg3Nxcr+q9zNW6g4ODNWjQIN1///267bbbFBoa6jRnuXLldObMGZdrCAsL0z333KPHH39c9evXd734/+/ChQt6//33NXPmTB08eNDt493VoUMHTZo0SV27dnXrd59ycnL0/vvv67nnntOhQ4fytW3atElt2rRxOKZ169basmWLS/mff/55PfXUUw5xo9fTUyVLltSFCxcc4mlpaYqJiTHtHPfff7/GjRunWrVquX38yZMnNWvWLL344ovKyMhw6ZjJkyfrueeec/tcnli/fr06duxY4GOcXcfN+l07q445V+ejKlWqaMqUKRo2bJjb8+j69es1efJkff31196Uait2f71ff/11y1wzjVSvXl1PP/207r77bkVHR7t9/NatWzVjxgwtWbLE61rsOIbMmu/s+NydadWqlaZOnapu3bq5/XP47rvvNHXqVCUmJuaLd+zYUWvXrnV4vDvrDDP5Y80imbtucaWPWW2dbyZXx2psbKyeeuopjR492u050eyfgS/nl0DI44zd1w1WnOfDwsL0wAMP6IEHHlDDhg09ynHkyBHNnj1br7/+ulJSUkytz1Ncw80RSM+/KNfFn376qRISEhzib775pu677z63813L2XsGt956q9f/T1ZoaKhOnTql0qVL54ufPXtWFStWVE5Ojlf53WGF9wirV6+uXbt2+b0P/eUvf9Ebb7zhEN+5c6duuukmt/O54uOPP9bgwYMd4gMHDtTixYvdysV9qefseG/ijJX6gT9Ycd1qx8+I7FizM3buE95cW6322YYd51W7Xbsk9+/HrNZPJN+/v2HV62KgvkcAAMUde7UD8IQr/493sB/qAAAAAAAAAAAAAAAAAAAAAAAAAAJehQoVnLYV9S9tBwUF6fHHH9fBgwf117/+VaVKlfI4V8uWLbV48WJt2LBB1113nYlV/s+QIUN06NAhzZo1y6ONw6U/Xo/p06dr7969lvtSz+uuu07r169Xu3btHNp27Nihtm3b6ueffzY8dsGCBYbx+Ph4UzZT6Nu3r9P83rrtttscNkKTpCVLlri8EVpYWJimT5+u/fv368EHH/Roswfpj3786aefav369apdu7ZHOeCZdu3aadu2bZo9e7bHm2JIf2xW9MILL+jQoUO65557TKzQXFafz7p37669e/dq7ty5Hm2oFBUVpVGjRmnv3r3617/+pcjISFPrMxISEqKXX35ZK1euVIMGDdw+dvjw4dq5c6f69Onj9HHBwcH6xz/+oY0bN6p169ZunSM4OFh33XWX9uzZo3vvvdetY4va0KFDtWfPHv3lL39xe/Mj6Y8vVvnqq6+0cOFCRUVFmV5fTEyM3n//fX377bfq3r27R9e9Fi1aaOnSpVq0aJHKli1reo12sHPnTo+P9XbOkIpm3nBVu3btFBER4RDPzc3Vp59+WgQV+QbrKfPYfUw0aNBAmzdv1scff6wuXboUuDmhu6y8BiruY+DSpUsaOnSo4SaLkZGR+uijjzxaBxQFK4zB4n6PbkdWX/N66tSpU4bxy186axd2nqPvvfde7d69WyNHjvSobzVo0EDvvvuutm3bZsnXzdP7CDu+przv4Cg+Pl67d+/W+PHjPXoNfd2/7djPJN+uxwOFN+9hXKt///7atWuXHnroIcN7/8L4eg1g135sluI+91rh3qYwxeWzHTPnHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjPvffeq927d2vkyJEKCwtz+/gGDRro3Xff1bZt29SkSRMfVOj8vJs3b9bHH3+sLl26KDQ01LTc3bt31969ezV37lzVr1/foxxRUVEaNWqU9u7dq3/961+KjIw0rb6rVahQQYsXL9a6devUrVs3BQUFuXV8aGio7r33Xu3YsUOjR4/2SY12N2TIEB06dEizZs1SrVq1PMpRoUIFTZ8+XXv37lXnzp1NrtB7O3fuLNLz22nMGRk6dKj27Nmjv/zlLx7Nox06dNBXX32lhQsXKioqygcVWovdX+97773XstfMsLAwTZ8+Xfv379eDDz6o6Ohoj/K0bNlSn376qdavX6/atWubXKWj4jyGrP7cY2Ji9P777+vbb79V9+7d3V5nSFKLFi20dOlSLVq0SGXLljW9Rjhn13W+meLj47V7926NHz/eozkxEH4Gdmf3dYMV5/l27dpp27Ztmj17tho2bOhxnmrVqumFF17QoUOHdM8995hSm51Y8bX1J6s/fyusixcsWGAYj4+P92hNda2+ffs6ze+t2267TaVLl3aIL1myRDk5OV7nN5uv3iO8uh8VRR/6+OOPlZqa6hBv1KiRbrnlFo/qKUjp0qXVr18/h/jvv/+uxMREl/NYYfx5wurzmt3YtR94w87rVjveO9qhZjv3CV9+/ma2ov5soyhx7XJdUfcTK18XeY8AAAAA7gou6gIAAAAAAAAAAAAAAAAAAAAAAADgnlIVpcbdpVuHSreNkFoOkGreIoW4/3vqMJGzXxo/c+aMsrOz/VzN/5QqVUpffvml/v73v5u60UXbtm31ww8/qHXr1qblLFGihBYuXKgPP/xQFSpUMCVn1apVtXr1ao0fP96UfN6qW7euNm3apMaNGzu0rV+/Xu3bt9fRo0edHr9s2TJlZmY6xCtWrKg2bdp4VVvlypV18803G7bFxcV5lVuS+vfvbxh3tsHbtapVq6YtW7bomWee8WhjDiPt27dXcnKy+vTpY0o+FOyee+7R2rVrvdoQ41qxsbF65513tHjxYkVERJiW11tWn8+Cg4P1yiuvaNWqVapRo4bX+UJCQvToo48qOTlZDRo08DqfM8HBwVq0aJHGjh3rVZ7SpUtr2bJl+tOf/uTQFh4ers8++0x//etfvdpkMjw8XG+//bYmTZrkTal+M23aNH3wwQembFw0cOBAbd68WTVr1vS+sP+vYcOG2r59u/785z+bkm/AgAHasGGDrrvuOlPy2YknmzeZPWdI/ps33NGlSxfD+Pbt23Xq1Ck/V+MbrKfMEQhjonXr1tq0aZNatmxpal6rr4EYA3/Yt2+fHnnkEcO2pk2bavr06f4tyE1WGoPF+R7djqy+5vXG3r17DePOXmcrsvMcPWvWLL399tseb0x6tcaNG2vr1q269957vS/MRJ7cR9jxNeV9B0dPPPGEli5dqkqVKnmdyxf92479TPLdejzQmLUB9fjx47V48WKVK1fO61y+WAPYtR+bpTjPvVa6tylIcfpsp6g3vgcAAAAAAAAAAAAAAAAAAAAAAAAAAACAQPHVV18Z/gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAojRr1iy9/fbbio6O9jpX48aNtXXrVt17773eF1aI1q1ba9OmTWrZsqWpeYODg/XKK69o1apVqlGjhik5Q0JC9Oijjyo5OVkNGjQwJedlrVq10o4dO9S/f3+vc0VFRemVV17RnDlzFBwcbEJ19leiRAktXLhQH374oSpUqGBKzqpVq2r16tUaP368KfnMsnPnziI5r93GnJFp06bpgw8+UFRUlNe5Bg4cqM2bN6tmzZreF2ZBgfB6X75uessX18xq1appy5YteuaZZxQWFmZKzvbt2ys5OVl9+vQxJZ+R4jyGrP7cGzZsqO3bt+vPf/6zKfkGDBigDRs26LrrrjMlHwpnx3W+mZ544gktXbpUlSpV8jqXXX8GdhYI6wYrzvP33HOP1q5dq4YNG3pd02WxsbF65513tHjxYkVERJiW18qs+Nr6k9Wfv1XWxcuWLVNmZqZDvGLFimrTpo1X9VSuXFk333yzYVtcXJxXuSU5fZ9pwYIFXuc2m6/eIzS7H3nShy5cuKCPP/7YsG348OFe13StwYMHKzIy0iH+zjvvKCcnx6UcVhl/7rL6vGY3du0HnrL7utWOnxFZvWa79wlfXVt9pag+2yhqXLvcU5T9xMrXRd4jAAAAgCf4vwoBAAAAAAAAAAAAAAAAAAAAAABsompDacg/pAfelXo9JrUfJrW+U7p9pHTndOmhBVLH4VJ4yaKutHgaMGCAYfyHH37wcyX/Exsbq6+//lqdOnVy6fG5ubm6cOGCyxsUVa5cWcuXL1f16tW9qPIPZcuW1ddff62BAwd6netawcHBmjlzpiZMmGB6bnfccsst2rBhg+EGJkuXLlW3bt10/vz5AnOkpaVp1apVhm0JCQle1RcXF6egoCDDtsaNG+v666/3Kn/fvn0dYufOndMXX3xR6LF169bVxo0b1axZM5fOlZOTo4yMDJceGxUVpSVLlmjw4MEuPR6eGT58uN5++22FhIS49PiMjAylp6crLy/Ppcf3799fq1atssTmGFafzyIjI7V06VKNHj3axMr+cHmstmvXzvTckvTaa6+pX79+puQKCgrSvHnz1Lp163zxjz/+WD179jTlHJI0ZcoU3XXXXabl84UJEyaYfo286aablJSUpJiYGK9zNW3aVGvXrlWtWrVMqOx/GjRooC+++MKUTZ/sxN3Nm3w5Z0i+nzfc0aRJE8P4N9984+dKfIP1lDkCYUzUrl1bK1euVJkyZUzNa/U1EGMgvzfeeENLly41bHv88cd1++23+7ki11htDBbXe3Q7svqa11tr1qwxjA8cOFDNmzf3czXus/McPWvWLI0bN87UnOHh4Xrrrbf08MMPm5rXG+7eR9j1NeV9h/wefvhhvfDCC06vR54ws3/btZ/5aj0eiMzYgHrMmDGaOXOmCdX8j5lrALv2YzMV17nXavc2zhSnz3ak4vsFCQAAAAAAAAAAAAAAAAAAAAAAAAAAAABgtk6dOhn+gXfCw8MN/wBAUWN+AgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADYwaxZszRu3DhTc4aHh+utt97Sww8/bGreq9WuXVsrV65UmTJlTM0bGRmppUuXavTo0abmvaxu3brauHGj2rVrZ0q+2267TV988YUqVqxoSr7L7r//fr3++uum5rSjsmXL6uuvv9bAgQNNzx0cHKyZM2dqwoQJpuf21M6dO/1+TruNOSMTJkww/XW86aablJSUpJiYGFPzFrVAeL3Nvm6aec28/PybNWvm0uNzcnKUkZHh0mOjoqK0ZMkSDR482IsKjRXnMWT15960aVOtXbtWtWrVMqGy/2nQoIG++OILRUVFmZoXjmbNmmVqPn+s88308MMP64UXXlBQUJBpOe32M7CzQFg3WHGeHz58uN5++22FhIS49PiMjAylp6crLy/Ppcf3799fq1atUkREhEf12YUVX1t/svrzt9K6OC0tTatWrTJsS0hIcCmHM3FxcU6vcY0bN9b111/vVf6+ffs6xM6dO6cvvvjCq7xm89V7hO70I1/fW82ZM8cwPnToUNO/F2348OGG8blz57p0vJXGnzusPq/ZjV37gafsvm6142dEVq/Z7n3CV9dWXyqKzzaKGtcu9xVVP7HydZH3CAAAAOCp0KIuAAAAAAAAAAAAAAAAAAAAAAAAAIVrd7d061CpoL34wktIbQZLN3aSFj0rnTrkr+rQsGFD9evXz7Bt6dKlfq7mfz744AM1b97cafv69eu1cOFCbdiwQXv27FFqauqVtpiYGNWqVUudOnXSsGHDdMsttxjmKF++vBYtWqR27drp4sWLHtUZHh6uZcuWqVWrVk4fc+nSJW3YsEErVqzQd999pxMnTuj06dMKCgpS6dKlVbduXXXs2FFDhgxRlSpVDHNMmzZN+/bt0/z58z2q0xtdunTRkiVLFB0d7dA2d+5cPfDAA8rNzXUp1/z58w37W0JCgp588kmPazTarOxqffr00WuvveZR7ubNm6t69eoO8aVLlxbab8qWLaukpCTD4y9LTk7W/PnzlZSUpP379+vs2bOS/uhb5cuXV4sWLdS9e3f9+c9/NtyIJTQ0VPPmzdOhQ4f07bffuvfkUKjatWvr3//+t9PN9o4ePaoPP/xQq1at0o4dO/T777/nGw9ly5ZVvXr11L59ew0cOFBt2rQxzHPbbbdp9uzZGjVqlE+ehyvsMJ+99957iouLc9qem5urTZs2admyZdq6dauOHz+uzMxMVapUSXXq1FHv3r3Vs2dPp5saxcbG6rPPPlPbtm21e/dut+tzZsCAARo5cqRD/MCBA5o3b57Wrl2rw4cPKzMzU2XLltV1112nzp0764477lC9evUMc4aHh+vNN99Us2bNlJOTo7/+9a/q37+/w+POnTunjz/+WCtWrNBPP/2k1NRURUdHq1KlSmrRooX69++v2267zWntr776qjZs2KCDBw96/gPwka5du2rKlCkO8by8PK1bt05LlizRd999p99++03p6ekqVaqUKlSooObNm6t3797q0aOH0w1v6tatq3nz5mnAgAEe11e5cmWtXLlS5cuXd/qYzMxMffnll1q2bJl2796tEydO6OzZs4qKilKlSpVUo0YN9erVS3369FG5cuXyHXvjjTfqtdde0xtvvOFxjWY4cuSINm/e7LS9XLlyqlu3rkP8zJkz2rNnj1vn2rFjh1uP92TOOHPmjEqWLFnk84a7jH7GkrR9+3Y/V2I+1lPmsfuYCAkJ0eLFi03fnNDqayDGgLG//OUvat26tSpXrpwvHhQUpHfffVeNGzfWuXPniqY4J6w4BovbPbodWX3Na4bPP/9c06dPd4gHBQVpyZIlat++vX799dciqKxwdp6jhw0bZripcnZ2tlatWqXPP/9c27Zt0/Hjx5Wenn7lHqVu3brq2bOnevXq5XQuCgoK0qxZs3TgwAEtX77c8DFWvY+w62vK+w75dezYUS+++KJD3F/92xV27Ge+Wo/7k1XnHiNt2rTRSy+95BC3yhrArvOlmYrz3GvFe5trWeWzHTvNOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+Eq9evX0888/G7bVr1/f7d+xBwCzMD8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOxg2LBhGjdunEM8Oztbq1at0ueff65t27bp+PHjSk9PV1RUlCpVqqS6deuqZ8+e6tWrl8qUKWOYOygoSLNmzdKBAwe0fPlyU+sOCQnR4sWLnZ7bG++9957i4uKctufm5mrTpk1atmyZtm7dquPHj+vMmTMqWbKkKlWqpDp16qh3797q2bOn0/piY2P12WefqW3bttq9e7fHtd5www1asmSJoqOjnT4mKytLX375pVasWKHk5GSdOHFC586dU0REhMqVK6fGjRura9eu6tevn0qVKpXv2Pvuu0/bt2/3uD67Cw8P17Jly9SqVSunj7l06ZI2bNigFStW6LvvvtOJEyd0+vRpBQUFqXTp0qpbt646duyoIUOGqEqVKoY5pk2bpn379mn+/PmG7UeOHNHmzZud1lCuXDnVrVvXIX7mzBm398TesWOHW483g53GnJGuXbtqypQpDvG8vDytW7dOS5Ys0XfffafffvtN6enpKlWqlCpUqKDmzZurd+/e6tGjh0JCQgxz161bV/PmzdOAAQNMrbko2f31NrpuWuWaWbZsWSUlJal69epOH5OcnKz58+crKSlJ+/fv19mzZyX9Md+VL19eLVq0UPfu3fXnP//ZsNbQ0FDNmzdPhw4d0rfffutRndcqzmPI6s+9cuXKWrlypcqXL+/0MZmZmfryyy+1bNky7d69WydOnNDZs2ev9P8aNWqoV69e6tOnj8qVK5fv2BtvvFGvvfaa3njjDY9rRMGsPGf5Q8eOHfXiiy86xIvTz8Du7L5usOI8X7t2bf373/9WUFCQYfvRo0f14YcfatWqVdqxY4d+//135ebmXmkvW7as6tWrp/bt22vgwIFq06aNYZ7bbrtNs2fP1qhRo9yqzy6s+Nr6k9WfvxXXxfPnz1e/fv0c4gkJCXryySddf3LX6Nu3b4Htffr00WuvveZR7ubNmxv+DJcuXaqLFy96lNMXfPUeYWH9yN996LvvvtO2bdvUrFmzfPHY2Fj17dtXCxcudPs5Gqlfv77h3P71119r3759hR5vxfHnCqvPa3Zj137gDTuvW+34GZEdarZznzDz2hron20UpUC6dgV6P7HydZH3CAAAAOCNoLy8vDyXHuhkwQkATZo0UZMmTST98abGgQMHtHnzZrk4vQAAAAAAAAAAAABX/P0ffy/qElAM7N61W2+99VZRlwEAphi3SIqIKuoqEMiO7JA+fLyoqwAAOBMUFKQWLVqoXr16V/5/7+TkZCUnJxdxZcUT/08tfK3rGOnmePeOyU6X3n9MOnXIJyVZ2sGDB1WzZk2H+ODBg7VgwQLTz1e6dGl99dVXat68uUNbamqqatasqTNnzriV09n84c7v+Dz00EOaPXu2YdsPP/ygBx98UFu2bHE534ABA/T22287bHx+2ciRIzV37lyX813tzTff1IgRI5y2L1y4UBMmTHBpc4LQ0FCNHTtWM2bMUIkSJRzaz58/r5tuuklHjhwpNJcZr4MkDRo0SO+//77Cw8Md2qZOnarJkye7lS86OlonT55UZGSkQ1uDBg30888/u5VPkiIiIq5smuLM559/rt69e7udW5KmTJmiSZMmOcTj4uL02WefFXjs6tWr1bVrV8O2X3/9VY899pjLm3eVKlVKTz75pJ566ikFBwc7tB85ckQNGjTQhQsXXMp3mVl9xaw8ZjKjpsTERMXHO17IcnNzNXnyZP3jH/9QVlaWy/luvfVWvfbaa1fWX9fq3r27Vq9e7XI+M1l1Prts0qRJhpvdXLZy5UqNHz9eP/74Y4F5oqKi9Nhjj2n8+PFOv1jj4MGDatasmVJSUlyuTzLuc88995zuv//+fF8OkZqaqr/+9a968803822kcq3g4GCNGTNGf//73xUREWH4mFGjRumLL77Qrl278s3VeXl5mjVrlv72t78V+jy6deumuXPnqkaNGobtixcv1sCBAwvMYcSX88uzzz6rESNGONT82Wef6cknn9TOnTsLzduwYUPNnj1bXbp0cfqYO++8U5988olb9Up/PMd169apffv2hu25ubl68803NWHCBJ08ebLQfOHh4Xr00Uc1ceJEh347ceJETZs2zeGY1q1bu7Ve8pUBAwZo0aJFDvGFCxdq0KBBPjuvWXOG5Nt5wwzBwcHKzMxUWFiYQ1uHDh30zTff+L0mM9lhPSX5/17OXXYaE0bz/pNPPqmsrCzNmjXLoe3s2bNaunSpli9frh9//FEnTpzQ+fPnXT6f1ddAdhkDZnA2jmrUqKFffvnFId6jRw99/vnnhmuLBQsWaPDgwR7Xsnv3bjVo0MAhXq5cObffJ5GsOwaL2z26LxTnNa+ZvvjiC3Xu3Nmw7fTp0xo9erQlrqfXssMcbdS3XnzxRY0YMUKlS5fO97jXXntN06dP19GjRwvNGxUVpUcffVRPPPGE0/dcU1JS1KhRI7eue5cV1X2E1V9T3nfIz9kcvHfv3nybCFutfxdUu1X7mS/X41ZSFHOPs77w448/qnHjxvliVloDWH2+NBNzb35Wvbe5ll0+2ymqNQ8AwFqCgoLUsmVL1a1bl/+fFoDLvPl/vNmrHYAz/F4JAAAAAAAAAAAAAAAAAtUD70qlKhZ1FYBzswb8sQcrgOKJvdqthf+nFsBlVtxn2e7q1avndF+z+vXru7TXHwD4AvMTAAAAAAAAAAAAAABFi73aAXiCvdoB+AK/VwIAAAAAAACYq1fvXurcuXNRl4FiZsVnK/TVV18VdRkA4Bdca1FUFi9arE2bNhV1GQDgF93GSs3jiroKFDdJL0vbPivqKgDAv9ir3Vr4f2oB6zAady+++KJGjBih0qVL53vca6+9punTp+vo0aOF5o2KitKjjz6qJ554QqVKlTJ8TEpKiho1aqQjR46YUveTTz6prKwszZo1y6Ht7NmzWrp0qZYvX64ff/xRJ06c0Pnz510+36RJkzRlyhSn7StXrtT48eP1448/FporKipKjz32mMaPH6/o6GjDxxw8eFDNmjVTSkqKyzVeFhoaqu+///7KPHutS5cu6a233tJzzz2n3377rdB8MTExevjhhzVx4kRFRkZeiaenp+vMmTOqVq2awzGtW7fWli1bXKr3+eef11NPPeUQf/LJJ/XCCy+4lKMwJUuW1IULFxziaWlpiomJcTvfm2++qREjRjhtX7hwoSZMmODSvtOhoaEaO3asZsyYoRIlSji0nz9/XjfddJNH42TAgAFatGiRYX2DBg1yO19hzPzuBTuNOaPn/eyzz2rEiBGqUaNGvvhnn32mJ598Ujt37iw0b8OGDTV79mx16dLF6WPuvPNOffLJJ27XbDV2f72NrpuvvvqqZa6Zq1evVteuXQ3bfv31Vz322GNauHChS7lKlSqlJ598Uk899ZSCg4Md2o8cOaIGDRoYzrnO2HEMmTXf2fG5BwUFad26dWrfvr1he25urt58801NmDBBJ0+eLDRfeHi4Hn30UU2cONFhzE6cOFHTpk1zOMaddYaZ/LFmkcxdt7gyZ1ltnW8mZ2N17969qlu3br7HWeVn4Mv5JRDySPZfN1h1nk9MTFR8fLxDPDc3V5MnT9Y//vEPZWVluZzv1ltv1Wuvveb0vrR79+5avXq1y/nMUpyv4Way6/O34ro4OjpaJ0+ezPd+y2UNGjRw+l1XBYmIiNCZM2dUsmRJp4/5/PPP1bt3b7dzS9KUKVM0adIkh3hcXJw++8z/H0D7+z1CZ/2oKO+tHnzwQb366qsO8RUrVqhPnz4u1VMYZ2vhoUOH6qOPPir0eCuOv6vZbV6z472JZP1+YDa7rFvt+BmRHWuW7N0nfHltNeLvzzbsOK/a7drlrGbJ8/0a/d1PJHOfg5Wvi8XlPQIAKO7Yqx2AJ1z5f7wdV6QAAAAAAAAAAAAAAAAAAAAAAACwjCY9pZsdf5e4UOElpYHP/fFf+E69evX0zTffqHnz5obt06dP15kzZ/xc1R+/1P7ss88atr3//vtq1aqV25uELl68WO3atXO6ScUTTzzh0S/zd+3a1enG4RkZGRo0aJAGDRrk0sbhkpSTk6NZs2bp1ltvNdxktXTp0nruuefcrtNTDz74oD7++GOFh4c7tF3eFMBdaWlpWrVqlWFbv3793M4nSV26dClwIzRJ6ty5c6GPccaorpSUFCUlJRV43F133eV0s4cNGzbolltucXmzh8vnnDBhgvr06aPU1FSH9mrVqvm1fxQHFSpUUK9evQzbhgwZounTp7u1KYYkbdy4US1bttTixYsN2wvaNMiXrD6f3XTTTYabEl4+16hRo9SrVy+XNlS6cOGCpk6dqqZNm2r37t2Gj6lVq5ZpmwH95S9/UZUqVa78+9ChQ7r55ps1d+5c5ebmFnhsbm6uXn75ZQ0aNEg5OTmGj3n00Uc1derUfHN1RkaG+vTpo8cee8ylTaFWr16t2267zekXifTr18/wC0KK0n333Zdv86PL/SAuLs6lzY8kadeuXerevbvefvttp48ZP368x/U521Q9LS1NXbt21ciRI13aVF2SsrOzNXPmTDVp0kQHDhzI12a0oVVxZ+acIfl/3nBXlSpVFBYWZtjmyhcEWRnrKXMEwpgoWbKkJk6cmC+WlZWlmTNnqlatWho+fLgWLVqkPXv2uLU5odXXQIyBgq1atUr//ve/DdvuvPNO3X333X6uyJiVx2Bxuke3I6uvec00efJkp5sNlStXTvPnz1dycrLGjBmjypUr+7k6Y3aeox988MF8myqfP39eXbp00ZgxY1zaVFn6Yy6aNm2abr75ZqdzUalSpfTiiy+aUrM/2PU15X0HR1d/QZQV+/ddd91lGLdyP/PVehzONW7c+MrfrbYGsOt8aabiOvda+d7masXpsx0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAErgcffFClS5e+8u/z58+rS5cuGjNmjI4ePepSjgsXLmjatGm6+eabtXv3bsPHlCpVSi+++KIpNUtSyZIlNXHixHyxrKwszZw5U7Vq1dLw4cO1aNEi7dmzR+fPn3c570033aRJkyYZtuXk5GjUqFHq1auXfvzxR5fyXbhwQVOnTlXTpk2d/mxq1aqlF154weUarzZu3Dg1adLEsO3s2bPq3r27Ro4cqd9++82lfKmpqZo+fbqaN2+ugwcPXomXLFlS1apV86hGO+vatatGjBhh2JaRkaFBgwZp0KBB2rNnj0v5cnJyNGvWLN166606efKkQ3vp0qX13HPPeVWz3dhtzBm57777VKNGjSv/vlx3XFycdu7c6VKOXbt2qXv37nr77bedPmb8+PFe11rUAuH1NrpuWuWaedddd6lr166GbRs2bNAtt9yihQsXupwvJSVFEyZMUJ8+fZSamurQXq1aNVPmrOI8hqz+3O+77z61b9/esC0tLU1du3bVyJEjDa9pRrKzszVz5kw1adJEBw4cyNf21FNPeVQjCnb1nGWXdb7Z6tate+XvxfVnYFeBsG6w4jxfoUIF9erVy7BtyJAhmj59urKyslzOJ0kbN25Uy5YttXjxYsP2KVOmuJXPDqz42vqT1Z+/VdfFaWlpWrVqlWFbv379XK7nal26dFHJkiULfEznzp0LfYwzRnWlpKQoKSnJo3y+4Kv3CAvqR0V5b/XBBx8oPT3dId6jRw9dd911LtfkTFBQkO6++26H+JkzZ7Ro0aJCj7fq+CuM1ec1u7FrP/CU3detdvyMyOo1271P+OraCnNx7bIPK18XeY8AAAAA3gou6gIAAAAAAAAAAAAAAAAAAAAAAABgLLykdJvxnsouKV1JajPYvHrwP02bNtUrr7yinTt36qabbjJ8zKpVq0zdFM8dYWFh+uijj5SZmZkvvmLFCt199926dOmSR3l37NihMWPGGLbVrVvX6S+/OxMcHKxXX33VsC09PV2dOnVy65f5r7Zt2zZ17drVcLOnVq1aKTw83KO87vjb3/6mV199VcHBjr/GlZWVpTvvvNPj3AsWLDCMJyQkeJQvPj6+0MdEREQ43XyhIDVr1jTcgD8xMVEXL150elxkZKTTMbR9+3Z17drV5c10r7Vy5UoNGzbMsO2hhx5SpUqVPMoLR/Hx8QoNDXWIz58/32k/dkV2drYGDx6sTZs25YuvXr1akydP9jivp+wwn/3nP/9RWFiYQ/zixYvq3bu35syZ43ZtBw4cUOvWrbV582bD9pEjR6pVq1Zu573W1V+ucfr0ad1+++3at2+fWzmWLVumf/7zn4ZtDRo00JAhQ678Ozc3VwMGDNDnn3/u1jkOHz6se+65x7AtJCREDzzwgFv5fK169epX/p6bm6vBgwd71A9yc3M1YsQIrVu3zrC9RYsW6tixo1s5o6OjNWPGDMO21NRU3X777frqq6/crlWSDh48qPbt22v//v35zof8fDFnSP6bN9wVExPjtO3EiRN+rMRcrKfMEwhjYsiQISpfvvyVf586dUqdO3fWU0895fGGhFZfAzEGXPPEE09o165dhm2vvPKKatas6d+CDFh9DBaHe3S7svKa12wbNmwodKPIxo0b69///reOHj2qXbt26c0339TYsWPVuXNnVa5c2U+V/sHuc3RkZOSVv6enp6tz584e36Ps379frVu31g8//GDYfscdd6hdu3Ye5fYnO7+mvO/gnBX7t7O+ZvV+5ov1OFxjtTWAnedLMxXXudfq9zaXFZfPdgAAAAAAAAAAAAAAAAAAAAAAAAAAAACgOGjXrp0+//xzhz/PPPNMUZcGAPAB5n0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPKLjIy88vf09HR17txZX331lUe59u/fr9atW+uHH34wbL/jjjvUrl07j3Jfa8iQISpfvvyVf586dUqdO3fWU089pfPnz3uc9z//+Y/CwsIc4hcvXlTv3r01Z84cj/IeOHBArVu31ubNmw3bR44cqVatWrmVs0yZMnr22WcN286cOaPWrVvryy+/dLtWSfrpp5/Url07HTlyxKPjA0FwcLBeffVVw7b09HR16tRJCxcu9Cj3tm3b1LVrV6Wnpzu0tWrVSuHh4R7ltSM7jTlnqlevfuXvubm5Gjx4sEd15+bmasSIEVq3bp1he4sWLdSxY0eP67SCQHi9ja6bnjD7mhkZGakXXnjBsG379u3q2rWrTp486VGtK1eu1LBhwwzbHnroIVWqVMmjvJcV5zFk5eceHR2tGTNmGLalpqbq9ttv93jNePDgQbVv31779+/Pdz6Y7+o5yy7rfF+x070O/hAI6wYrzvPx8fEKDQ11iM+fP18LFixwu7bLsrOzNXjwYG3atClffPXq1Zo8ebLHea3Kiq+tP1n5+Vt9XexsnCUkJHhUU3x8fKGPiYiIUNeuXd3OXbNmTTVp0sQhnpiYqIsXL7qdz1d88R5hYf2oKPtQSkqKPvnkE4d4SEiI7rrrLo/qulrXrl1VtWpVh/h7772n7OzsAo+1+vgriJXnNbuxcz/wlN3XrXb8jMjqNdu9T/jq8zeYi2uXPVj9ush7BAAAAPBWcFEXAAAAAAAAAAAAAAAAAAAAAAAAAGONu0slSnmX4+a+Uojj/gnFUqNGjdSxY0e3/nTp0kX9+vXTXXfdpQkTJuijjz7S/v37tW3bNo0ePdrwl72lP34xu3///srLy/Pzs/zD6dOn9dBDD6lWrVr65z//qQsXLujcuXNOf8HdHR988IF+/PFHw7YuXbq4lWvAgAGqW7euYdvo0aO1ZcsWt+u7WnJysh577LEr/96yZYv69++vJk2aFLoZkzeCgoL02muvOd14PiUlRT179tSiRYs8PkdiYqKysrIc4m3atFHFihXdzhcXF5fv3zk5Ofrmm28cHufKpmnX6tevn2G8sE0Rhg4dquuuu84hnpKSov79+yszM9PtWq62ZMkSvfHGGw7x8PBwjRkzxqvc+J8bbrjBMD5v3jyvc+fk5Gj48OHKyMjQe++9p6ZNm6p79+5avXq117ndZfX5rEOHDk43YXriiSe8+pmlpqZq4MCB+v333x3agoKC9Mwzz3ic28g999yjQ4cOeXTstGnTdObMmUIfN3PmTK1cudKjc3zxxRdOj+3Ro4dHOf3h2Wef1eLFi73Kce+99zrd5NLZtcCZe+65J98mWld7+OGH9d1337ld39WOHTumu+66S5cuXfIqT6Dy5Zwh+X/ecEVUVJRhPC8vz/DLaOyC9ZQ5AmVM1KtX78rfz507p7Zt22rjxo1e5bT6Gogx4JqsrCwNGTLE8GcaExOjDz74QMHBRbc9iR3GYHG4Rw8EVlvz+sLf/vY3ffTRR4U+LigoSDfeeKNGjBihl19+WV988YWOHTums2fPasOGDXrkkUfUrVs3w03OzRJIc/To0aOdborsqstz0dmzZw3bH3nkEa/y+0OgvKa875CfFfu3UV+zQz/zxXocrrHaGiBQ5kszFZe51w73NpcVl892AAAAAAAAAAAAAAAAAAAAAAAAAAAAAKA4qFSpknr27Onwp3nz5kVdGgDAB5j3AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwbvTo0frhhx+8ypGamqqBAwfq7Nmzhu2PPPKIV/kvq1ev3pW/nzt3Tm3bttXGjRu9ytmhQwe1a9fOsO2JJ57Q6tWrvcp/+Wfz+++/O7QFBQXpmWeecSvfiBEjFBMT4xDPy8vTXXfdpb1793pcqyQdO3ZMAwcO1KVLl7zKY1cDBgxQ3bp1DdtGjx6tLVu2eJU/OTlZjz322JV/b9myRf3791eTJk2UnZ3tVW67sNuYc8Wzzz6rxYsXe5Xj3nvv1cWLFw3b+vXr51XuohSIr7e3100zr5lDhw7Vdddd5xBPSUlR//79lZmZ6WmZkqQlS5bojTfecIiHh4drzJgxXuW+WnEeQ1Z77vfcc4/Kly9v2Pbwww/ru+++c7u+qx07dkx33XVXsV1nFAW7rPN9xU73OgjMdYNV5vkbbrjBMD5v3jyP67osJydHw4cPV0ZGht577z01bdpU3bt39/r1sjqrvLZFxWrP3+rr4sTERGVlZTnE27Rpo4oVK7pdT1xcXL5/5+Tk6JtvvnF4XHx8vNu5nf3sFyxY4HYuX/LFe4SF9SNvmHFvNWfOHMP4iBEjvKpNkoYPH+7WOa9m9fHnKqvNa3YTKP3AVYG2brXjfZPVag6EPuGLayt8i2uXdVn9ush7BAAAAPBWcFEXAAAAAAAAAAAAAAAAAAAAAAAAAGN12nifI7yEdH0T7/MEgsmTJ2vt2rVu/VmzZo2WLFmi9957T9OmTdOf/vQn1a5d2+k5cnJy9Nxzz6lXr17KyMjw47Mzdvz4cT3++OOqUaOG+vbtq9OnT5uS9/XXXzeMd+jQwa0848aNM4wnJiaa8kvz0h8bL7322mvq1KmTWrdurSVLligvL8+U3EbCw8O1YMECPfDAA4btx48fV8eOHfX11197dZ60tDStWrXKIR4UFOT2hmXNmjVTtWrV8sXWrl1r+Br06dPHvUIlJSQkOMRSU1OVlJRU4HFjx441jM+ePVsHDx50uw4jzz//vHJzcx3iw4YNMyU/pCpVqhjG9+/fb0r+n3/+WZUqVdKwYcOUnJxsSk5PWH0+e/zxxw3ja9as0UsvveR1bUePHtX9999v2Na3b1+nXxThrqVLl+qzzz7z+Pi0tDQtWrSowMf89ttvmjp1qsfnkKS33nrLMN60aVNFRER4ldsXtm/frueff97rPAcPHtSSJUsM29q3b+9WLmcb73z++ed655133KzM2ObNm/Xyyy+bkivQ+HrOkPw3b7gqKirKMG60+aydBMp66oYbbtDNN99s6p9r178FCcQxMWLECO3bt8/rPFZfAwXKGPCH5ORkpxth3nrrrT7Z8N9VdhiDxeEe3e6suOb1laFDh+rZZ5/16P2vMmXK6NZbb9WLL76opKQkHTlyRGfPntWqVav0t7/9TV27dlVISIgpdQbKHL1+/XrTrnmHDh3S+PHjDdsSEhJUuXJlU87jK4HwmvK+Q35W7d9Gfc1O/Uwybz2OwllxDRAI86WZitPca4d7m8uKy2c7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKB7Wr1+vefPmmZLr0KFDGj9+vGFbQkKCKleubMp5LhsxYoT27dvndZ7HH3/cML5mzRq99NJLXueXpKNHj+r+++83bOvbt6/q1q3rcq4HH3zQMP7OO+/o888/96i+a23ZskWvv/66KbnsZty4cYbxxMRE08bKnDlz9Nprr6lTp05q3bq1lixZory8PFNy24Hdxlxhtm/frueff97rPAcPHtSSJUsM29q3b+91/qISaK+3WddNs66ZY8eONYzPnj1bBw8e9Li+qz3//PPKzc11iA8bNsyU/MV5DFnxuY8ZM8Yw/vnnn+udd95xszJjmzdv1ssvv2xKLhRs/fr1puTx9zrfLHa+1ymuAm3dYKV5vkqVKobx/fv3e1pWPj///LMqVaqkOSs6MgABGRRJREFUYcOGKTk52ZScVmal17YoWPH5W31dnJaWplWrVjnEg4KCFB8f71YdzZo1U7Vq1fLF1q5da3jN69Onj1u5pT+ua9dKTU1VUlKS27n8xaz3CH3dj7y9t9q4caN27drlEG/QoIFatWrlcV2lSpUyfN03bdpkeL5rWX38ucKK85rdBEI/cEcgrVvteN9kxZoDqU9I5l1b4Ttcu6zN6tdF3iMAAACAt4KLugAAAAAAAAAAAAAAAAAAAAAAAAAYK1/DnDzlrjcnDwr2888/q2HDhvrb3/6mS5cuFXU5+Zw+fdq0DS0l6csvvzSMN2/eXCEhIS7lqFixotq1a2fYNnPmTI9ru1ZeXp5Gjx6ttWvXmpbTmejoaH3++ee64447DNv37dunW2+9Vdu3bzflfAsWLDCMG21CVZC4uDiHWGJiopYvX+6w0fp1112nm2++2eXcsbGx6tChg0N82bJlysrKcnrc9ddfr+bNmzvE09PT9eKLL7p8/sIcOHBAa9ascYjXqFFDN954o2nnKc4iIiIM42Zu4p+ammpaLk9YfT6LiYlRr169DNvM2PTmssTERO3cudMhHhQU5HRedNfUqVO9zrFo0aIC22fNmqWMjAyvzrF8+XJlZ2c7xMPCwgzntqI2adIk09Yub7/9tmH85ptvVsmSJV3KUa9ePadz8PTp0z2uzcg///lPy63bipq/5gzJP/OGq5xdr3Jyckw7xw033KDevXub8seV8RRI66kZM2bo+++/N/XPXXfd5dK5A3FMfPrpp/r000+9zmP1NVAgjQF/+ec//+n0fv/ZZ5/1asNkT9lpDAbyPXogsNqa19emTJmiTp066bvvvvM6V5kyZdS9e3c9++yzWr16tY4dO6YXX3xRjRo18jhnIM3RZtynXu29997TyZMnHeKhoaHq2bOnqecyU6C8przvkJ8V+7dRX7NbPzNrPQ7XWG0NECjzpZmKy9xrp3sbqXh8tgMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJ1kZmbqu+++M/yTmZlZ1OUBKMaYnwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAdjF16lRT87333ns6efKkQzw0NFQ9e/Y07TyffvqpPv30U6/zxMTEqFevXoZtzz//vNf5r5aYmKidO3c6xIOCgnTHHXe4lKNevXqqU6eOYds///lPr+q71rRp05STk2NqTqurWLGi2rVrZ9g2c+ZM086Tl5en0aNHa+3atabltAu7jTlXTJo0SZcuXTIl19tvv20Yv/nmm1WyZElTzuFPgfh6m3nd9Paaef3116t58+YO8fT0dL344oum1ChJBw4c0Jo1axziNWrU0I033uh1/uI8hqz23OvVq+f0NZ0+fbrHtRn55z//adpzh3NWmrOKgl3vdYqrQFw3WGmej4iIMIzn5eV5VdfVUlNTTctldVZ6bYuC1Z6/XdbFCxYsMIwnJCS4VUdcXJxDLDExUcuXL3cY09ddd51uvvlml3PHxsaqQ4cODvFly5YpKyvLrTr9xaz3CP3Rj8y4t5o7d65hfPjw4R7Xdeedd6pEiRIO8Tlz5hR6rF3GX2GsNq/ZTaD0A1cF2rrVjvdNVqs50PqEWddW+BbXLuuyw3WR9wgAAADgreCiLgAAAAAAAAAAAAAAAAAAAAAAAADGSpQyJ09UrDl5ULD69etr1apVGj9+vCIjI4u6HJ/66aeflJaW5hAPDQ1VbKxrHa5nz54KCgpyiP/3v//Vxo0bva7R3ypUqKC1a9eqc+fOhu3ff/+9br31Vh08eNC0cyYmJhpuKNa1a1e3Npno27evQ2zZsmU6fvy4vvvuO4c2o83TnImLi1NISIhD/JNPPinwuG7duhnG16xZozNnzrh8fld8/fXXhvFOnTqZep7i6ty5c4bxWrVq+bcQH7L6fNa9e3eFhYU5xHfs2KEvv/zS1HPNmjXLMB4fH+917u3bt+v777/3Ok9BOXJzczVv3jyvz5GRkaGffvrJsM1qff/w4cNatmyZafk2bNhguPFNaGioatSo4VIOZ5uFbd++XRs2bPCqvmsdOXJEn332mak57c6fc4bk23nDah5++GF99tlnpvypVq1aoedjPVWwffv2ufS4QBwTzs7hLquvgRgDnhk2bJjOnj3rEA8NDdUHH3ygqKgov9ZjpzEYyPfodmfFNa8/rFu3Ti1bttQdd9yhlStXmrbpaYUKFfTII48oOTlZb775pipWrOh2jkCZow8fPqzVq1d7nedqWVlZevPNNw3brPwlOoHwmvK+Q35W7d9Gfc1O/Uwybz2OwllxDRAI86WZitPca6d7G6l4fLYDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICd/PLLL2rZsqXhn19++aWoywNQjDE/AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADs4PDhw1q9erWpObOysvTmm28atvXs2dO088yaNcuUPN27d1dYWJhDfMeOHfryyy9NOcfVnNUdHx/v0vHdu3c3jK9bt047d+70tCxDx44d0/Lly03NaXU9e/ZUUFCQQ/y///2vNm7cWAQVBR67jbnCHD58WMuWLTMllyRt2LBBeXl5DvHQ0FDVqFHDtPP4SyC+3mZeN729Znbr1s0wvmbNGp05c8ar2q719ddfG8Y7derkVd7iPIas+Nyd9bvt27drw4YNXtV3rSNHjuizzz4zNSfys9qc5W92vtcprgJx3WClef7cuXOG8Vq1anlbWrFjtdfW36z4/O2yLk5MTFRWVpZDvGvXripZsqTLNfTt29chtmzZMh0/flzfffedQ1tcXJzLuePi4hQSEuIQ/+STT1zO4W9mvUfor37k7b3Vu+++a9iPhgwZooiICI9qGj58uEMsJSVFCxYsKPRYu4y/glhxXrObQOgH7gikdasd75usWHMg9YmC8sM6uHZZmx2ui7xHAAAAAG8FF3UBAAAAAAAAAAAAAAAAAAAAAAAAMHYx05w82Rnm5EHhatWqpZkzZ2rv3r2GG0wFiry8PB07dsywrWzZsi7l6NChg2F81apVHtdVVGrUqKENGzbo5ptvNmxfvXq1brvtNp08edLU86ampiopKckhHhkZqR49eriUo1KlSmrRokW+2I4dO3Tw4EFJ0tKlSx2OcWdjlISEBIfYhQsXtHLlygKPa9++vWHcF/1j8+bNhvFGjRqZfq7iyNlcMWTIED9X4jtWn89uv/12w3hh49ATznK2bt3a4831LjPr53nq1Cmn8/G2bdtMm6udfdFImTJlTMlvFrO/vCQlJUX79+83bIuNjXUpR9u2bQ3jvvqileL2BS6F8eecUVBeM+YNq6lbt65fz8d6qmD79u1z6XGBNiZ++uknrVu3zus8kvXXQIwBz/z2228aOXKkYVudOnX8vsGlncZgIN+j250V17z+tGjRIvXq1UtVq1bVgw8+qPfff99p/e4IDg7WiBEjtHfvXvXu3dutYwNljjYa82ZwtgFyy5YtfXI+MwTCa8r7DvlZtX8b9TU79TMz1+MonBXXAIEwX5qpOM29drq3kYrHZzsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoHpKSknyS98svvzSMt2zZ0pT8P/30k9atW2dKrttvv90wvnLlSlPyu5q3devWioiIKPT41q1bG8a/+uorr+pyZsWKFT7Ja1UdOnQwjK9atcrPlQQuu425wixfvtzrHFdLSUnR/v37DdtiY2NNPZc/BNrr7YvrpjfXzPbt2xvGfTFnbd682TDeqFEjr/IW5zFkxefetm1bw7jZtfo6L/5gtTnL3+x6r1OcBdq6wWrz/LFjxwzjQ4YM8aqu4shqr62/WfH522VdnJqaanh9ioyMVI8ePVw6f6VKldSiRYt8sR07dujgwYOSpKVLlzocEx8f71JuSUpISHCIXbhwwWdzsbfMfI/QX/3I23urM2fO6NNPP3WIly5d2vD1K0ydOnV06623OsQ//PBDpaenF3q8XcZfQaw4r9lNIPQDdwTSutWO901WrDmQ+oSZ11b4Dtcua7PDdZH3CAAAAOCt4KIuAAAAAAAAAAAAAAAAAAAAAAAAAMZST5mTJ+WkOXnsLjU1VadOnfLoz9mzZ5WVleXyuapVq6YlS5Zo+vTpPnxGRev8+fOG8bJly7p0/I033mgY37hxo8c1FYXGjRtr06ZNqlu3rmH7Rx99pD59+ujChQs+Of+CBQsM465uYtWnTx8FBQXliy1btszw75fdcsstqly5cqG5IyIiDDdlW758uTIzMws8tkGDBobxTZs2FXpedznbuKFevXqmn6s4+uabbwzjw4YN06BBg/xcjW9YfT5r2LChYdzZa+ONI0eO6Ndff3WIBwcHq379+l7lNvPnefz4ccP4t99+6/NzlClTxrRzmMEXm1QZ9QHJ9TWCs2vAhg0bPK6pIGa+7oHAn3OG5Nt5wwzXrpO8UadOHdNyuYL1VMGcbdZ2rUAbE19//bXXOS6z+hqIMeC5hQsX6t133zVsu++++zzaNNlTdhuDgXqPbndWXPMWhRMnTug///mP7r77btWpU0fly5fXbbfdpgcffFCvvPKKvvrqK504ccLtvKVKlVJiYqJGjRrl8jGBMkevX7/e6xxGtmzZory8PId4zZo1FR4e7pNzeisQXlPed8jPqv3bqK/ZqZ+ZuR5H4ay4BgiE+dJMxWnutdu9TXH4bAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADFw/r1632Sd8uWLcrLy3OI16xZU+Hh4V7n//rrr73OcVnDhg0N4998841p57jakSNH9OuvvzrEg4ODVb9+/UKPd/aYTZs2eV2bEV/1Eau68cYbDeMbN270cyWBy25jrjDr1q3zOse1jOqVpLJly5p+Ll8LtNfbF3OiN9fMBg0aGMZ9cU04duyYYbxevXpe5S3OY8iKz91Zn9qwYYPHNRXk22+/9Ule/MFqc5a/2fVepzgLtHWD1eZ5Zz/HYcOGadCgQV7VVdxY7bX1Nys+fzutixcsWGAYT0hIcOn4Pn36KCgoKF9s2bJlhn+/7JZbblHlypULzR0REaEePXo4xJcvX67MzEyX6vM3M98j9Fc/MuPe6vXXXzeMDx8+3O167r33XsP4nDlzXDreTuPPGSvOa3YTCP3AHYG0brXjfZMVaw6kPmHmtRW+w7XL2uxwXeQ9AgAAAHgruKgLAAAAAAAAAAAAAAAAAAAAAAAAgLFD/zUnz2GT8tjdfffdpwoVKnj0p2zZsoqMjFRYWJiqVq2q7t27a/z48dqwYYPhJheSFBQUpGeeeUbPPfecn5+p71SuXFnt2rXT3Xff7XQTA1c3JHG2scZ//2ufDtu+fXutW7dO1113nWF7WlqaxowZo4sXL/qshqVLlyorK8shHhcXp+Dgwn99rG/fvoY5L0tOTtYvv/ySrz0oKEh9+vQpNHfXrl0VFRXlEP/kk08KPdbZZguHDx8u9Fh3nT171jAeGxtr+rmKo2+++UanT592iAcHB2v+/PmaN2+emjZtWgSVmcfq85mzL2v44YcffHK+77//3q06XLV3716vjr9aamqqYXzPnj0+P0eZMmVMO4cZdu/ebXrO8+fPG8Zdfe516tQxjPtqTO3YsUPZ2dk+yW1H/p4zJN/NG+4wWk9JUmhoqCn5Q0JCVLNmTVNyuYr1lHO///6703n6WoE2Jsz8Mgmrr4EYA94ZM2aMDh48aNj2xhtvuLRBthnsNgYD9R7d7qy45rWC06dPa926dfrPf/6jsWPHqnPnzqpcubLKlSunkSNH6qWXXtK6deuUkZFRaK6QkBC99tpriouLc+ncgTJHm3mferXz588b/iyCg4NVu3Ztn5zTW4HwmvK+Q35W7d9Gfc1O/Ywvd/MvK64BAmG+NFNxmnvtdm9THD7bAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQPGwd+9en+Q9f/68Dh8+7BAPDg5W7dq1vc7/7bffep3jshtvvNEw/sMPP5h2jmt9//33btVytbp16xrGk5OTvarJmf379ys3N9cnua2ofv36hvH//ve/fq4kcNltzBVm9+7dXue41vnz5w3jZcqUMf1cvhZor7cvrpveXDPr1atnGDfK562zZ88axmNjY73KW5zHkBWfe506dQzjvroO7tixQ9nZ2T7JDevNWf5m13ud4izQ1g1Wm+e/+eYbnT592iEeHBys+fPna968eWratKm3JRYLVntt/c2Kz99O6+KlS5cqKyvLIR4XF6fg4OBCj+/bt69hzsuSk5P1yy+/5GsPCgpSnz59Cs3dtWtXRUVFOcQ/+eSTQo8tKma+R+ivfmTGvdXXX3+tffv2OcS7deumqlWrupwnKChIw4YNc4j/8MMPLt8D2Gn8OWPFec1uAqEfuCOQ1q12vG+yYs2B1CfMvLbCd7h2WZsdrou8RwAAAABvFf5uNgAAAAAAAAAAAAAAAAAAAAAAAIrEzjVSXp53OQ5vk9Icfx8ZHsrJydHRo0e1evVq/f3vf1f79u1Vu3btAjd3mjx5suLi4vxYpeciIiJUv3599e7dW2PHjtWsWbOUmJioHTt2KD09XceOHdM333yjd9991+uNR8qWLWsYP3nypFd5/SU+Pl6rV68ucDOH6Ohovf766z6tIzU1VUlJSQ7xsmXLqn379gUeGx4erq5du+aL/f7779qyZUu+WGJiosOx8fHxhdaWkJDgEEtPT9eKFSsKPdZos4WMjAydOXOm0GPdlZaWZhiPiYkx/VzF0cWLF/X8888btl3ePG3btm369ddftXjxYk2dOlX33HOP2rVrp0qVKvm5Ws9YfT6rUKGCYdxX9Z06dcowXr58ea/yHj161Kvjr+Zs3B8/fty0c6SmphrGXdmo0p9+++0303OmpKQYxl157sHBwYqOjjZsc9a3vJWbm+uT64td+XvOkHw3b7gjMzPTMB4REWFK/urVqysrK0tpaWlu/cnz4oYwkNZTY8eOVY0aNUz706xZM5fPHWhjYvv27V7nuMzqa6BAGgNFIS0tTX/+85916dIlh7Zy5cpp3rx5fqnDbmMwUO/R7c5qa16rO3PmjObOnatHHnlEt912m0qVKqWOHTtqzpw5Tu9zpD/u8d99911df/31hZ4jUOZoX2xMepmzn4U/N+52RyC8przvkJ9V+/e1j7FbPzNzPY7CWXENEAjzpZmK09xrt3ub4vDZDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIqHw4cP+yz3mTNnDOOxsbFe596+fbvXOS6rUKGCYfzkyZOmneNap06dMoyXL1++0GNLly5tGD99+rRXNTlz8eJFHT161Ce5rahs2bKGcV/2h+LGbmOuML/99pvXOa6VkpJiGA8ODjb9XL4WaK+3r66bnl4zjdozMjKc5vNGWlqaYTwmJsarvMV5DFntuQcHBys6Otqwzdm48lZubq5P+iv+YLU5y9/seq9TnAXausFq8/zFixf1/PPPG7YFBQVp2LBh2rZtm3799VctXrxYU6dO1T333KN27dqpUqVKXtUdaKz22vqbFZ+/ndbFqampSkpKcoiXLVtW7du3L/DY8PBwde3aNV/s999/15YtW/LFEhMTHY6Nj48vtLaEhASHWHp6ulasWFHosUXFzPcI/dWPzLq3mjt3rkMsODhYd999t8s5OnfurOrVqzvE58yZ43IOO40/Z6w4r9lNIPQDdwTSutWO901WrDmQ+oSZ11b4Dtcua7PDdZH3CAAAAOCt0KIuAAAAAAAAAAAAAAAAAAAAAAAAAMZO7JN+Xi816OjZ8Xm50tq3zK0Jjg4dOqQ777xTd999t95++22FhIQ4PObf//631qxZo8zMzCKo0FGVKlV0yy23qEmTJqpTp45q166tG264QVWqVFFQUJDPz1+yZEnDTRCysrKUlZXl8/N7a/jw4Zo7d67ha32tQYMGacSIEXrrLd8NxgULFhhuTpaQkKB169Y5Pa5z586KiorKF1u+fLny8vLyxRITEzV27Nh8sW7duikiIsLp6xUUFGRY04oVK5SRkeG0JumP/mHUD0uUKFHosZ5w1ucjIiJMP1dx9fLLL6t///5q166d08dUq1ZN1apVU//+/fPFL1y4oP3792vfvn3at2+f9u7dq+3btys5OdkS84XV57MSJUoYzlVZWVk+uyadPXvWMO7t5mIXLlzw6vir5ebmFtk5rCY1NdX0nN48d2f9JC0tTTk5OR7nLcy5c+dUuXJln+W3i6KYMyTfzRvuSE9Pd9oWFRXl9fxw6NAhj57P7t271aBBA7ePC7T11MmTJ/XLL7+YkssdgTgmzPoyLKuvgQJtDBSVTZs2acaMGZo0aZJDW/fu3fXwww9r9uzZPju/XcdgoN2jBwKrrXntJicnR+vXr9f69es1YcIETZs2TaNGjTJ8bGxs7JUNL50JpDna2eavZjh37pxh3NkXURWlQHlNed8hPyv2b6O+Zrd+5qsvp4Uxq60BAmW+NFNxmXvtem8TyJ/tAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoPhISUnxWe5z584ZxqOjo73Offr0aa9zSFKJEiUUEhLiEM/KylJmZqYp5zBy9uxZw3hMTEyBx5UsWVJBQUEO8aysLGVnZ5tSm5HU1FSf5baSkiVLKjg42CGelZWlrKysIqgo8NhtzLnCF+MjNzfX9JxFIRBfb19dNz25Zjq7JpQoUUIZGRlmlXaF0bkkKSIiwqu8xXkMWe25OxsjaWlpysnJ8ThvYc6dO6fKlSv7LH9xZqU5qyjY9V6nuArEdYPV5nlJevnll9W/f3+1a9fO6WOqVaumatWqqX///vniFy5c0P79+7Vv3z7t27dPe/fu1fbt25WcnFzs7pes+Nr6k9Wevx3XxQsWLFB8fLxDPCEhQevWrXN6XOfOnRUVFZUvtnz5cuXl5eWLJSYmauzYsfli3bp1U0REhNPxGhQUZFjTihUrfPJzNItZ7xH6sx+ZdW/1zjvvaNq0aQoLC8sXHzFihP7v//7PpRzDhw93iKWnp+vDDz906Xg7jj8jVpvX7CZQ+oGrAm3dasf7JqvVHGh9wqxrK3yLa5d12em6yHsEAAAA8EZoURcAAAAAAAAAAAAAAAAAAAAAAAAA51bNlireIJWt6v6xa9+Sju8xvyYYe++99xQTE6NXXnnFoa1GjRoaNGiQ3nvvvSKo7A+NGjXSsGHDNHjwYNWoUaPI6pDksAHXZb7cjMRMb731lluPf/nll7Vhwwb9/PPPPqknMTFR2dnZCg8Pzxfv16+fHnvsMafHGW1WtnTpUofY119/rdTU1HyboZQsWVKdOnXSqlWrDHO3adNGlSpVcogvWLDAaT2XOesfkhQZGVno8bCe7Oxs9evXT6tXr1bz5s3dOjYqKkpNmjRRkyZN8sVzcnK0du1affDBB/r444+LbJM9q89nRVGfsw2VSpUq5VXeixcvenW8K3z5BSFW5Y+fqzucbbZz4cIFn57XKmO2qBXVnOarecMdJ06ccNpWqVIlHThwwG+1mIH1lDkCcUycP3/e6xySfddAEmPAXc8995x69OihVq1aObS98MIL+uKLL7Rz506fnNuuYzDQ7tEDgdXWvHZ26tQpPfDAA9q0aZPeeustwy8HHDp0qCZNmqRffvnFMEcgzdHp6ek+y+3smm3FL9EJlNeU9x3ys2L/dtbX7NTPzFqPwzVWWwMEynxppuIy99r13iaQP9sBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFhfRESEoqKilJ6erszMzKIux6mYmBiFhoYqLS3NcvtdIL/LfSo7O1tpaWlFXY5bwsPDFR0drczMTJ/uD+QtxsP/lChRQiVKlFBubq7Onz+vvLy8oi4poNlxfFv5OhcSEqKYmBgFBQUxngEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDF/u8Xz+/HnDeHR0tM9yuysqKsownpKSYkp+Z86ePWsYL1WqVIHHFVW9Fy5c8Gl+qyiqn29xYrcx5wr2rHYuEF9vX103PblmOvv5SlJkZKTXNflLcR5DVnvuERERhnFfrwO4zvqOleasomDXe53iKhDXDVab5yUpOztb/fr10+rVq9W8eXO3jo2KilKTJk3UpEmTfPGcnBytXbtWH3zwgT7++GNlZGSYWbIlWfG19SerPX87rosTExOVnZ2t8PDwfPF+/frpsccec3pcfHy8Q2zp0qUOsa+//lqpqamKiYm5EitZsqQ6deqkVatWGeZu06aNKlWq5BBfsGCB03qswNfvEUrW7Ue///67li1bpgEDBuSL161bV23bttWmTZsKPD4mJkb9+/d3iM+fP1+pqaku1WDHn5sRq81rdhMo/cBVgbZuteN9k9VqDrQ+Yda1Fb7Ftcu67HRd5D0CAAAAeCO0qAsAAAAAAAAAAAAAAAAAAAAAAACAc1lp0sKJ0h1TpbLVXD/u2wXSloW+qwvGXn31VQ0bNkytW7d2aBsxYoTee+89v9dUo0YNPf/88/rTn/6koKAgv5/fiLM6Ll265OdKzPPFF1/opZde0pIlSxQcHJyvrWTJkpo/f75atWql7Oxs08+dkpKipKQkxcXF5YvXrl1bjRo10s6dOw2Pu/bxmZmZWr16tcPjLl68qJUrV2rQoEH54vHx8U43Q0tISHCIZWRkaMWKFQU9FUnO+wfs7fTp02rbtq3+9a9/adSoUQoJCfEqX2hoqLp06aIuXbpo2rRpmjhxot5++22TqnWd1eeza+ejy3xZn7PcdhjbeXl5RV0CnPD1a5Obm+vT/HZRFHNGQfn9OW+cPHlSOTk5Cg11/PX7atWq6cCBA36rxQx2mHPtIBDHhFkbK1p9DcQYMM+lS5c0dOhQbd++3WFzvoiICH300Udq0aKFT+517ToGA+0eHTAyb948XX/99ZoyZYpDW2hoqO69917DNimw5mhf3qdYYY3sKivWZFV2et/Biv07EPoaX+xWvAVCH7YjK8y9dr23kQL3sx0AAAAAAAAAAAAAAAAAAAAAAAAAAAAACCTly5dXxYoVnbZff/31hvHSpUurYcOGbp0rOztb+/btc+sYV8TGxqpfv37q1auXmjRpohtuuEFhYWFX2tPT03Xy5Ent3r1bq1evVlJSknbs2GF6HQWJiIhQjx491KNHDzVt2lQ33nijYmNj8/0ef3Z2tg4fPqwdO3Zo48aNWrJkiak/L2ev165du7zOc+LECZ0+fdrpMREREWrSpInq1Kmj0qVLKyYmJt9znz17tjIzM92qw5duuukm9evXT61atVKTJk1UtWrVfH0qLy9PZ8+e1c6dO5WcnKykpCQlJSX55Dm4+/OOjY1V//791a1bNzVt2lS1a9dWRETElfZLly7p+PHjSk5O1tatW/Xpp59q27ZtptddEKuOh6Lox2FhYbr99tvVs2dPNWnSRI0aNVKFChXy7dORl5enc+fO6cyZM9q+fbvWrl2rtWvXavv27W6d6zIrzvtmzU+usML4drf/lS1bVoMGDVLnzp3VvHlz1ahRQ+Hh4Vfai/I616pVK3Xp0kWtWrVSs2bNVL58eUVHR+d7THZ2tn777Tft2LFD//3vf7V8+XJt3brVL/UBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgFny8vJ8lvvSpUuG8av3QfZUSkqK1zkkKTg42DDurHazePqzcdbu63pzcnJ8mt8qiurnW5zYbczBO4H4evvquulJzfRf+Isv14uSlJub69P8xZmV5qyiYNd7neIqENcNVnX69Gm1bdtW//rXvzRq1Kh83ynkidDQUHXp0kVdunTRtGnTNHHiRL399tsmVQsUzo7jNSUlRUlJSYqLi8sXr127tho1aqSdO3caHnft4zMzM7V69WqHx128eFErV67UoEGD8sXj4+O1atUqw9wJCQkOsYyMDK1YsaKgp1LkzHqP0I79SJLmzJmjAQMGOMSHDx+uTZs2FXjsoEGDVLJkScOcrrLrzw3mKm79INDWrXa8b7JazYHWJ8y6tgLFld2ui7xHAAAAAE+FFnUBAAAAAAAAAAAAAAAAAAAAAAAAKNi5Y9J7j0jdxkg3dpIK+l3otDPSV69Lu9f6qzpc67XXXlPr1q0d4m3btlVYWJguXrzot1q6du2qTz75RGXKlPE4x5kzZ7R3717t3btXP//885W/v/LKK2rTpo15xdrY/Pnzdffdd+vixYv6+9//rieffNLhMU2bNtULL7ygRx55xCc1LFiwwGFzM+mPTcmMNkNr0qSJrr/++nyxL774QhkZGYb5ExMTDTdDGzt2rOHj+/Xr5xD7/PPPdeHCBafPAYEvKytLY8aM0UsvvaSnn35aAwYMUKlSpbzOW6VKFb311lvq1q2bhg8frqysLBOqBVAUnG1M5myDMLOEhYX5ND+sLy8vT0eOHFHNmjUd2ho0aKB169b5vyjAB3z9RRUITPv379e4ceP0xhtvOLQ1btxY//d//6fHHnusCCqzLu7RURzMmDFDw4cPV61atRzabr/9dk2ZMqUIqgIAa2M9DsCO+GwHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKxt9OjReu6559w+rlu3bob7YhVk/fr16tixo9vncqZixYqaOHGiRo4cqYiICKePK1mypGrUqKEaNWqoZ8+eV2qZPHmyvv76a9PqMVK9enU9/fTTuvvuuxUdHV3gY8PDw1W3bl3VrVtX/fv319///ndt3bpVM2bM0JIlS7yuxdnrFVTQFxe4mOfJJ5/UCy+8kC8WHBysQYMG6f7779dtt92m0NBQpznfeOMNZWZmulWH2cLCwnTPPffo8ccfV/369Qt8bFBQkMqWLasOHTqoQ4cOGjNmjC5cuKD3339fM2fO1MGDB02ry9Wfd7Vq1TRp0iQNHz68wL1yQ0JCVLVqVVWtWlW9evXS5MmT9dNPP2nGjBn64IMPlJuba1rt17L6ePBnP65cubIef/xx3X///YXuxREUFKTY2FjFxsbqhhtu0IABAyRJW7du1fPPP68lS5a4tT+RFed9s+YnZ6w2vl3tf1WqVNGUKVM0bNiwAse1v69zYWFheuCBB/TAAw+oYcOGhT4+PDxctWrVUq1atRQfH6/JkyfryJEjmj17tl5//XWlpKSYXiMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4A/u7GEMAACAwjlbXwUHB/v0vAV9bwEAwDeysrI0ZswYvfTSS3r66ac1YMCAQr9vyBVVqlTRW2+9pW7dumn48OHKysoyoVogMC1YsEBxcXEO8YSEBMPvgmrSpImuv/76fLEvvvhCGRkZhvkTExM1aNCgfLH4+HiNHTvW8PH9+vVziH3++ee6cOGC0+dgBcX9PcKkpCQdPnxYNWrUyBcfPHiwxo0b57R/SNLw4cMdYjt37tTmzZtNrxMAYB/F/doKFEe8RwAAAABPhBZ1AQAAAAAAAAAAAAAAAAAAAAAAAChcVpq0fKa0ZaHUsLNUs7kUU14Ki5TSz0knD0n7Nku7vpAu8vvARWrFihWG8YiICDVs2FDbt2/3Sx29evXSsmXLFBISUuhj09LStGfPHu3Zs0d79+7N99+zZ88aHpOZmelxbbm5uYbx0FD7/brTv//9bz388MNXNvqYOHGiunTpohYtWjg8dty4cUpKSnLaR7yxdOlSZWdnKzw8PF88ISFB06dPd3i80cZpS5cudZp/xYoVunTpUr7+dP3116tRo0YOm63Vr19f9evXd8jxySefFPo8JOebppw7d04ff/yxSznMcPr0ab+dq7jZs2ePhg8frlGjRqlTp05q2bKlbrnlFjVo0EC1a9dWRESER3mHDBmimJgYxcfHm1yxc1afzy5dumQY92V9zjaodlYLcLX09HTDuBmb6BSkTJkyPs1vF0UxZ0jWmTd+/PFH1axZ0yHetGlTv9ZhBtZT5ijuY6IgVl8DMQbM9+abbyouLk4JCQkObY888ohWrFihNWvWmHpOO4/BQLpHB5y5dOmSXn31Vf397393aGvbtq3CwsJ08eJFh7ZAmqOdPUczXDt/XGal9cBlgfSa4n+s2L+N+hr9DHbCfFl82fne5mqB9NkOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAz1+5z5Y3+/ftr7ty5KleunEfHd+jQQV999ZUWLVqke+65RxcuXDCtNumP39v/29/+pieeeMLp7/C7omXLlvr000/1zTff6J577tGBAwdMrNJ3GjRooHfffVctW7Ys6lJc0r17d82ZM0c1atTwOEdUVJRGjRql++67T7Nnz9Yzzzzj1V787rj33nv18ssvKzo62qPjL79eTzzxhO666y4lJyebWp9dx4Mv+nFQUJD++te/aurUqYqMjPQqV8uWLbV48WJt2rRJAwcO1LFjx0yq0jxmzvuesuv4Hjp0qObMmaOoqCiPjvfVda5du3aaM2eOGjZs6FWeatWq6YUXXtDTTz+tRx99VPPmzTOlPgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADwlbCwMF28eNEnucPDww3jly5d8sn5POGsltDQUJ+e19ne1oX9bJy1e7NXtit8nd8sQUFBXh2fm5trGPd1fyhO7Dbm4J1AfL19dd305JqZl5dnGD937pw+/vhjU+pyxenTp/12LvhWenq6YbxUqVI+PW+ZMmV8mt+qvF23uMJKc1ZRKO73OnYTiOsGO9izZ4+GDx+uUaNGqVOnTmrZsqVuueUWNWjQQLVr11ZERIRHeYcMGaKYmBjFx8ebXDHgyK7r4qVLlyo7O9vhmpKQkKDp06c7PD4uLs4whzMrVqzQpUuXFBISciV2/fXXq1GjRg7fwVW/fn3Vr1/fIccnn3xS6PMIFFboR57cW+Xl5enNN9/UlClT8sVLlSql/v3768MPPzQ8rnbt2mrfvr1DfM6cOW6f34jVxx/y8/bepLj1g0Bbt9rxvslqNQdan4D3/PGeD6zLztdF3iMAAACAO/i/6QAAAAAAAAAAAAAAAAAAAAAAAGzk9/1//IF1nTx5UpmZmYqMjHRoq1Chgl9qqFmzpj788MN8G1dd7fTp01q0aJFWr16trVu36vDhw26fw5tNGTIzMw3jpUuX9jhnUXjmmWf0/PPP54vl5ORoyJAh2rZtm6KiohyOeeedd9SkSRMdP37c1FpSUlK0evVq9enTJ1/8lltuUZUqVXT06NF88b59++b7d15enpYvX+40/5kzZ7RhwwZ17NgxXzw+Pt5hM7R+/fo5HJ+ZmVlg/msfayQtLU0PPvigSzlgD9nZ2UpKSlJSUtKVWFBQkKpVq6Y6deqoTp06qlu37pW/16lTRyVKlCgwZ1xcnJ555hnNmDHD1+VLsv58lpaWZhj35SbSZcuWNYynpKT47JwIHBcuXFBeXp7DOiMyMlKRkZFOx5y3iuvG6tcqijlDss68kZycbLi5UocOHfxahxlYT5mjuI+Jglh9DcQY8I377rtPrVu31nXXXZcvHhQUpHnz5qlx48Y6c+aMaeez8xgMpHt0oCBr1qwxjEdERKhy5cr69ddfHdoCaY4uXbq0Tp065ZPczuY6Z3NjUQqk1xT/Y8X+bdTX6GewE+bL4svO9zZGAuGzHQAAAAAAAAAAAAAAAAAAAAAAAAAAAACAZ67d58pT48eP18yZM03JNXDgQNWvX1/x8fE6dOiQKTmrVaumZcuWqVmzZqbkk6T27dsrOTlZgwcP1meffWZaXl9o3bq1Vq5caYv9WoODg/Xyyy9r9OjRpuUMCQnRo48+qri4OPXt21c//fSTabmNzJo1S+PGjTMlV+PGjbV161aNGjVK77zzjik57ToefNGPS5UqpaVLl6pTp06m5ZSktm3b6ocfflBCQoK+/fZbU3N7y6x53xN2Ht/Tpk3ThAkTTMll5nXunnvu0Ztvvun0O0w8ERsbq3feeUf9+vXTkCFDlJWVZVpuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADBT6dKlderUKZ/kdrYfclpamk/O5wlntfh6T/KyZcsaxlNSUgo87sKFC4bx0qVLe11TQaKionya3ywlSpTw6vjMzEzDuK9/vsWJ3cYcvBOIr7evrpueXDOdzVlpaWl68MEHzSgLxcyFCxeUl5enoKCgfPHIyEhFRkY67XPessN3wfiCt+sWV1hpzioKxf1ex24Ccd1gJ9nZ2UpKSlJSUtKVWFBQkKpVq6Y6deqoTp06qlu37pW/16lTp9B5LC4uTs8884xmzJjh6/JRzNl1XZySkqLVq1erT58++eK33HKLqlSpoqNHj+aL9+3bN9+/8/LytHz5cqf5z5w5ow0bNqhjx4754vHx8Q7fwdWvXz+H4zMzMwvMH2js2o8k6a233tKzzz7r8B1cw4cP14cffmh4zL333usQy8rK0nvvvefWue38c8P/+Oo91UDtB4G2brXjfZPVag60PgHv+eM9H1hXIFwXeY8AAAAArggu6gIAAAAAAAAAAAAAAAAAAAAAAACAQHPy5EnDuL827ZwxY4bhudLS0vTQQw+pSpUqGjVqlBYuXKjDhw97dI7o6GiP60tPT1deXp5DPCwszBabPVy6dEl/+ctf9Pzzzxu279u3Tw899JBhW4UKFdzeIMpVCxYscIgFBQU5bHxWoUIFtWrVKl/s+++/17FjxwrMn5iY6BCLj493iCUkJDjEVq1a5fJmNc76h7NNWhBY8vLy9Ouvv+qrr77S3LlzNX78eA0YMEBNmjRRVFSU6tevr3Hjxmn37t1Oczz99NN+6y9Wn8+ysrKUk5PjEA8NDfXZF1bExsYaxlNTU31yPgQeZxuTVa5c2Sfni4qKctpvi5uimDMk68wb33zzjWH8pptu8ln/8xXWU+Yo7mOiIFZfAzEGfOP06dO69957DX+2VapU0dy5c009n93HYKDcowMF2bNnj9O2cuXKGcYDaY725Xu9dvoSnUB6TfE/VuzfRn2NfgY7Yb4svux+b+MKu322AwAAAAAAAAAAAAAAAAAAAAAAAAAAAADwzM6dO73OMWbMGM2cOdOEav7npptuUlJSkmJiYrzOVbduXW3cuFHNmjVz6fE5OTnKyMhw6bFRUVFasmSJBg8e7EWFvlW7dm2tXLnSb/vpeyMyMlJLly7V6NGjfZL/cl9o166dT/JL0qxZszRu3DhTc4aHh+utt97Sww8/7HUuu44HX/Tj2NhYff311+rUqZNLj8/NzdWFCxcM9x0xUrlyZS1fvlzVq1f3okrzmTHve8LO43vChAmaMGGCqTnNuM4NHz5cb7/9tkJCQlx6fEZGhtN9k4z0799fq1atUkREhMc1AgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAv+XL/bWe509LSfHZOd2VlZRnumxwaGqqoqCifnTc2NtYwnpqaWuBxmZmZys3NdYiHhoaqZMmSptRmpHTp0j7L7eoewa7wdm9+Z3sQh4WFqUSJEl7lxh/sNubgnUB8vX113fTkmulszipbtqxZZaEYOnXqlGG8cuXKPjlfVFSU0zFrNWauWSTv1y2usNKcVRSK+72O3QTiusHu8vLy9Ouvv+qrr77S3LlzNX78eA0YMEBNmjRRVFSU6tevr3Hjxmn37t1Oczz99NOsTeBzdl4XL1iwwCEWFBSkvn375otVqFBBrVq1yhf7/vvvdezYsQLzJyYmOsTi4+MdYgkJCQ6xVatWFavrmp370W+//abPP//cId6lSxen3/82bNgwh9iiRYt09uxZt85t55+bnVnt3qS49YNAW7fa8b7JajUHWp8ojqw2r8LeAvW6yHsEAAAAuFZwURcAAAAAAAAAAAAAAAAAAAAAAAAABJpLly4ZxoODff/rPDVr1tTgwYMd4llZWeratav+/e9/Kzs72+vzlC9f3uNjc3NzdeLECcO2SpUqeZzXXwYMGKC33nqrwMe8/fbbWrhwoWFb165d9cQTT5he19KlSw1f22s3J+vTp4+CgoIcji2M0WZobdq0Ubly5a78u1KlSmrTpo3D44w2anPm0qVLOnnypEO8ZMmSioyMdDkPAk9eXp727Nmj2bNnq1GjRnruuecMHxcdHa377rvPLzXZYT777bffDOO+2qTaWd7jx4/75HwIPD///LNh/NqNPM3SokULv6zR7MLfc0ZBuf09b6xdu9ZwLRUUFKRBgwb5tRZvsZ4yT3EeEwWx+hqIMeA7SUlJevnllw3bBgwYoHvvvdfU89l5DAbKPTpQkPT0dGVlZRm2Xd0XrxZIc7Qvr3nOcjv7IqqiFEivKf7Hiv3bqK/Rz2AnzJfFm53vbbxlxc92AAAAAAAAAAAAAAAAAAAAAAAAAAAAACCQHDlyRJs3b3b6Z+/evYbHnTlzpsDjjP7s2LHDq1rbtGmjl156ySGel5entWvX6tFHH1WHDh1Uu3ZtVa5cWfXq1VO7du00duxYrVixwune75JUt25dzZs3z6v6ypYtq6SkJFWvXt3pY5KTkzVhwgS1bNlSZcuWVVhYmEqWLKmIiAhVrVpV/fr10yuvvKJz584ZHh8aGqp58+apdevWXtXqCyEhIVq8eLHKlClT1KW45L333lNcXJzT9tzcXG3YsEFPPfWUunTpokaNGum6667TDTfcoFtvvVXDhg3Txx9/7PS1kqTY2Fh99tlnuvHGG02vf9iwYRo3bpxDPDs7W8uWLdPo0aN16623XhkPl+u+55579NFHHxVYd1BQkGbNmlXgz6cwdh0PvurHH3zwgZo3b+60ff369Ro3bpxatGihUqVKKSQkRNHR0QoLC1OpUqXUtGlTjRs3Tt9//73THOXLl9eiRYsUFhZWYC12mvc9Zdfx3bVrV02ZMsUhXtTXudq1a+vf//63w96Xlx09elT/+Mc/1K1bN1133XUKCQlRyZIlFRUVpeDgYJUrV05t27bVE088oc2bNzs9z2233abZs2d7VCMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+FqlSpX8nvvUqVM+O6cnfvvtN8N45cqVfXZOZ7mPHz9e6LEnTpwwjPvqtYyMjDTlZ+Fsv+GYmBivc19W0B7irsjNzfX7z7c4stuYg3cC7fX21VzgyTXz0qVLOnnypEO8ZMmSioyMNK02FC8///yzYbxVq1Y+OV+LFi0UHBzsk9ye8seaRfJ+3eIKK81ZRYF7HfsJtHVDIMvLy9OePXs0e/ZsNWrUSM8995zh46Kjo3Xffff5uToUN3ZeFy9dulTZ2dkO8YSEhHz/7tOnj8P3LC1durTQ/ImJiQ6xNm3aqFy5clf+XalSJbVp08bhcQsWLCg0fyCxcz+SpDlz5jjEgoKCNGzYMIf47bffrho1ariUozB2/7lZnV3uTYpjPwikdasd75usWHMg9YlAZpd5FfZWHK+LvEcAAABQPFnrU34AAAAAAAAAAAAAAAAAAAAAAAAgAISFhRnGc3NzfX7u3r17G24O+uqrr+rbb7815RzBwcGqWLGiVzkOHz5sGL/lllu8yusPRpuCGbn//vv166+/GrZNnz5dLVq0MLMsnT9/XmvWrHGI33777fk25ejbt6/DY1x5Tnv37nXY7DY4OFi9evW68u/4+HiHjdaysrK0bNmyQvNf7ZdffjGM33TTTW7lQeDKy8vT3/72N7366quG7T169PBbLVafz3bt2mUYb926tU/O52zz6507d/rkfAg8u3fvNoy3b9/eJ+fz1ViwK3/PGZJ15o2MjAytXbvWsO3+++/3ay1mYD1ljuI8Jgpj9TUQY8B3xo8frx07dhi2vfzyy6pdu7Zp57LzGAyke3TYS1RUlF/Pl5eXZxgv6MuLAmWONvu9vcuqVq1quLHyxYsXdfDgQZ+c01uB8prif6zav436Gv0MdsJ8WXzZ+d7GTFb6bAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsVbb72ltm3bOv3z1FNPGR735ZdfFnic0Z+TJ096VeucOXMUEhKSL/bZZ5+pcePG6tSpk2bNmqVvvvlGBw8e1IkTJ7R3715t3LhRr7zyivr06aMmTZroiy++cJq/f//+GjRokMf1zZ8/XzVr1jRs+/XXXzVo0CA1bdpUM2bM0HfffaezZ89eac/OztbRo0eVmJiosWPHqkaNGpoxY4bhvvQRERFauHCh3/eMKszYsWPVtGlTh/jZs2f1zjvv6I477lD9+vVVpkwZBQUF5ftz5swZv9Y6adIk3XHHHU7bV65cqWbNmql9+/aaOXOmvvzyS+3atUvHjx/XgQMHtGnTJr333nsaMmSIqlWrpsmTJystLc0wV+nSpfXZZ5+pVKlSptVfuXJlzZ49O18sLy9Pr776qmrVqqW+ffvqtdde06ZNm66Mh8t1v/vuuxo6dKiqVaumSZMmKSUlxfAcQUFB+uCDD1StWjWParTrePBFP37ooYfy7fN3tR9++EGtW7dWx44dNXv2bH3//fdKTU3N95jU1FQlJydr9uzZatGihQYOHOj0dWvZsqXuvffeAp+jneZ9T9h1fEdGRuqNN95w2IfPCte5WbNmqWTJkg7x3NxcTZw4UbVr19YTTzyhNWvW6Pjx4w5j9cyZM9q8ebP+8Y9/qG3btmrXrp2Sk5MNzzVy5Eh169bN7RoBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwNdatGjhk7xVq1ZVpUqVHOIXL17UwYMHfXJOT+3atcsw3rp1a5+ds1WrVobxnTt3Fnrsnj17DOO+ei3r1aunoKAgr/NcvW/31czc77x+/fpe5zh8+LBh/JZbbvE6N/5gtzEH7wTa6+2Ludaba+Yvv/xiGL/ppptMqQ3Fz+7duw3j7du398n5fDkXeMofaxbJnHVLYaw2Z/kb9zr2E2jrhuIiLy9Pf/vb3/Tqq68atvfo0cPPFaE4suu6+Pz581qzZo1D/Pbbb1dMTMyVf/ft29fhMYmJiYXm37t3r37++ed8seDg4HzfPRYfH+/wvk9WVpaWLVtWaP5AY9d+JP3xnWBHjx51iA8fPtwhZvR9cHv37tXatWs9Oredf25WZ6d7k+LWDwJp3WrH+yYr1hxIfSKQ2Wlehb0Vt+vi1XiPAAAAoPgILuoCAAAAAAAAAAAAAAAAAAAAAAAAgEBToUIFw3haWprPz92xY0fD+Mcff2zaOW655RaVKFHCqxzbtm0zjLdt29arvFZy7tw53XXXXcrNzXVoCwsLM/U1uWzBggUOsfDwcPXs2fPK37t165av/ddff1VycrJL+Y02NYuPj7/y94SEBIf2pKQkpaamupT/sh9//NEwbsXNb1G0Jk+erJycHId4y5Yt/VaD1eezHTt2GMZ9sUl1/fr1Va5cOYd4VlaW9u/fb/r5EJi++uorw/iAAQMUEhJi+vmGDh1qek478+ecIVlv3pg3b55hvHHjxurdu7efq/EO6ylzFPcxURCrr4EYA76TlZWloUOHKisry6EtOjpaH3zwgWnXbLuPwUC5R4c9VKpUSS+//LKOHDni9L1Js5UqVUqRkZGGbQW9Dxooc7Svrnlt2rQxjO/fv9/wfUYrCJTXFP9j1f5t1NfoZ7AT5sviy+73Nmazwmc7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/a9y48ZW/5+TkaNSoUYqLi9POnTtdOn7Xrl3q3r273n77baePGT9+vEe13XXXXeratath24YNG3TLLbdo4cKFLudLSUnRhAkT1KdPH8O9v6pVq6bnnnvOo1p9oWTJkpo4cWK+WFZWlmbOnKlatWpp+PDhWrRokfbs2aPz588XUZV/uOmmmzRp0iTDtsv9qlevXk73+rjWhQsXNHXqVDVt2lS7d+82fEytWrX0wgsveFzztR588EGVLl36yr/Pnz+vLl26aMyYMTp69KhLOS5cuKBp06bp5ptvdlp3qVKl9OKLL7pdn13Hgy/6calSpfTss88atr3//vtq1aqVtmzZ4ladixcvVrt27ZzW8MQTTygoKMitnIHCzuP7vvvuU40aNRzqLerrXIUKFdSrVy/DtiFDhmj69OmG+4sWZOPGjWrZsqUWL15s2D5lyhS38gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAP7Rt29Ynedu0aWMY379/v3Jzc31yTk/t2LHDMN6+fXufnK9+/foqV66cQzwrK0v79+8v9Piff/7ZMO6r1/K2224zJc/Zs2cN47Vq1TIlv2ROrdu2bTOM++rnWxzZbczBO4H2evtiLvDmmulsj/rWrVt7XReKp6+++sowPmDAAIWEhJh+vqFDh5qe01v+WLNI5q2xCmK1OcvfuNexn0BbNxQ3kydPVk5OjkO8ZcuWRVANihs7r4sXLFjgEAsPD1fPnj2v/L1bt2752n/99VclJye7lH/ZsmUOsfj4+Ct/T0hIcGhPSkoy/F61QGfnfpSbm2v4HV833HBDvutoVFSUBg4c6PC4uXPnenxuO//crM5O9ybFrR8E0rrVjvdNVqw5kPpEILPTvAp7K27XRSO8RwAAABD4gou6AAAAAAAAAAAAAAAAAAAAAAAAACCQ1KxZU+Hh4YZtv/32m8/Pf9111xnGd+/ebdo5Onfu7HWOb7/91jDeu3dvr3Nbybp16zRz5kzDthtuuMH08y1ZskTZ2dkO8cublHXq1EnR0dH52hITE13Ov3TpUodYz549FRoaqqioKHXt2tWh/ZNPPnE5/2VbtmwxjHfq1MntXAhsp0+fNvwygpiYGKdzsdmsPp+tXr3aMB4XF2f6JtVGGyJK0tq1a3Xp0iVTz4XAtXr1auXl5TnEq1atqgEDBph6rjZt2qhp06am5vQnX2w07885Q7LevLF48WKdP3/esO2f//ynQkND/VyR51hPmaO4j4mCWH0NxBjwrR9//FHPPPOMYVubNm00adIkU85j9zEYKPfosLbY2Fj93//9nw4cOKCxY8eqTJkyGj9+vF/OXbt2badtJ06ccNoWKHN0586dffLeg7Nr6TfffGNKfl/Mn4HymuJ/rNq/jfoa/cwefDH32BHzZfFl93sbs/njsx3mHQAAAAAAAAAAAAAAAAAAAAAAAAAAAACwrtzcXA0ePFhz5szx6NgRI0Zo3bp1hu0tWrRQx44d3coZGRmpF154wbBt+/bt6tq1q06ePOl2rZK0cuVKDRs2zLDtoYceUqVKlTzKa7YhQ4aofPnyV/596tQpde7cWU899ZTTfTqLyn/+8x+FhYU5xC9evKjevXt71K8k6cCBA2rdurU2b95s2D5y5Ei1atXKo9zXioyMvPL39PR0de7cWV999ZVHufbv36/WrVvrhx9+MGy/44471K5dO7dqs+t48EU/DgsL00cffaTMzMx88RUrVujuu+/2eC+PHTt2aMyYMYZtdevWVa9evTzKa3d2Ht/Vq1e/8ncrXefi4+MN91SeP3++FixY4HZ9l2VnZ2vw4MHatGlTvvjq1as1efJkj/MCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgK907txZ4eHhpuft3bu3Yfybb74x/VzeWr16tWE8Li5OISEhpp8vISHBML527VqX9nhev369YdxX+zjHx8ebkufMmTOG8ZtvvtmU/KGhoerevbvXeb799lvDuLM+bWW+6L9msNuYg3cC7fX2xXXTm2vmli1bDOOdOnXypiQUY6tXr1ZeXp5DvGrVqhowYICp52rTpo2aNm1qak4z+HrNIpm3bimM1eYsf+Nex34Cbd1Q3Jw+fVrbtm1ziMfExPhkLAJXs/O6eMmSJcrOznaIX56jOnXqpOjo6HxtiYmJLudfunSpQ6xnz54KDQ1VVFSUunbt6tD+ySefuJw/kNi5H0nS3LlzDdfyw4cPv/L3QYMGKSoqKl/7xYsX9c4773h8Xrv/3KzMTvcmxa0fBNK61Y73TVasOZD6hBX46rMNO82rKJxVPwOTit910QjvEQAAAAS+4KIuAAAAAAAAAAAAAAAAAAAAAAAAAAgk/fv3N4xfvHhRe/fu9fn5Y2NjDeOZmZmm5A8ODtb999/vdZ6VK1caxm+88UZ16dLF6/xWMmnSJG3dutWw7c9//rOp5zp//rzWrFnjEO/Tp49CQ0MNN6k32uDMmY0bN+r06dP5YqVKlVL79u3Vo0cPRURE5GvLzs52a7O1y5KSkgzjffv2VYUKFdzOB2uoXLmyT/IePXrUMF6mTBmfnO9aVp/P1q5dqwsXLjjEq1evrjvuuMO084SFhenhhx82bPNkHkDxderUKcNrmSQ9++yzpm56M3XqVNNy+ZLRGJb+2ATIbP6aMyRrzhsZGRmaPXu2YVuDBg00ZcoUP1fkOdZT5ijuY6IgVl8DMQZ871//+pe++OILw7aJEyeqWrVqXp/D7mMwUO7RYV39+/fXwYMH9eSTT6pkyZJX4uPGjVOzZs18fn5nX3yUmZmpQ4cOOT0uUOboChUq6E9/+pOpOcuXL6+hQ4catjm79jrjz/uIQHlN8T9W7d9GfY1+Zi3+nHvsiPmy+LLzvY3VP9th3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+3n22We1ePFir3Lce++9unjxomFbv3793Mo1dOhQXXfddQ7xlJQU9e/f3+v93ZcsWaI33njDIR4eHq4xY8Z4ldss9erVu/L3c+fOqW3bttq4cWMRVmSsQ4cOateunWHbE088odWrV3uVPzU1VQMHDtTvv//u0BYUFKRnnnnGq/xGRo8erR9++MGrHJfrPnv2rGH7I4884nIuO48HX/Tj06dP66GHHlKtWrX0z3/+UxcuXNC5c+c0bNgwr/JK0gcffKAff/zRsM0K+3r6WyCNbytd52644QbD+Lx58zyq62o5OTkaPny4MjIy9N5776lp06bq3r27168VAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPhChQoV9Kc//cnUnOXLl9fQoUMN21auXGnqucywdu1aXbhwwSFevXp13XHHHaaeKywsTA8//LBhW2Jioks5nO1326BBA3Xt2tXj2ozUrl3btJy7du0yjFeuXFl16tTxOv/AgQNVoUIFr/M466M33nijZffKNuq/khQTE+PnSlxjtzEH7wTa6232ddPba2ZSUpJhvG/fvqbMiSh+Tp06pTVr1hi2PfvsswoPDzftXFOnTjUtl5l8vWaRzFu3FMZqc5a/ca9jP4G2brCyypUr+yTv0aNHDeNlypTxyfmAy+y8Lj5//rzh+qtPnz4KDQ1VfHy8Q9vSpUtdzr9x40adPn06X6xUqVJq3769evTooYiIiHxt2dnZxWIeNGLnfiRJhw8fNuxLd955p0qWLCnpj+8Au1ZiYqJOnjzp8Xnt/nOzMjvdmxS3fhBI61Y73jdZseZA6hP+5O/PNuw0r+J/7PYZmGS/6yLvEQAAAMATwUVdAAAAAAAAAAAAAAAAAAAAAAAAABAooqOj9de//tWwbfPmzcrMzPR5DampqYZxs35JfsiQIbrhhhu8znPs2DFt2LDBsO3pp5/2Ov/VRo4cqaZNm5qa0x2XLl3SkCFDlJaW5tD22muvqXbt2qaeb8GCBQ6x0qVL67bbbnPYDC01NVVff/21y7lzc3O1YsUKh3h8fLwSEhIc4mvWrNH58+ddzn/ZgQMH9OOPPzrEw8PDdf/997udryClS5f22YYN+EO1atX02muv6fDhw+rXr5/p+Z1tspyRkWH6uYxYfT7Lzs7W/PnzDdsmTJigsLAwM0rTyJEjVaVKFYd4VlaWPvnkE1POgeLj5ZdfNow3atRI06dPN+UcI0eONP0LYXzl7NmzhvEaNWqYfi5/zRmSdeeNf/3rX07XL0899ZTuvPNOP1fkGdZT5mBMOGf1NRBjwD+GDRumM2fOOMRDQkIUHR3tdf5AGIOBcI8O6/rpp58MN/QMCwvTBx98YMo4dCY6OlrDhw83bPvmm2+Um5vr9NhAmqMff/xxhYSEmJbvscceU2RkpEP8woULTjdIdcaf9xGB9Jrif6zYv436Gv3MWvw599gR82XxZcd7G7t8tsO8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2sn37dj3//PNe5zl48KCWLFli2Na+fXu3co0dO9YwPnv2bB08eNDd0gw9//zzhnszDRs2zJT8ZhoxYoT27dtX1GUYevzxxw3ja9as0UsvvWTKOY4ePep0L5C+ffuqbt26ppxHktavX6958+aZkuvQoUMaP368YVtCQoLLe5EEyngwux8fP35cjz/+uGrUqKG+ffvq9OnTpuR9/fXXDeMdOnQwJb+dBMr4ttp1zmgvGknav3+/J2U5+Pnnn1WpUiUNGzZMycnJpuQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAF95/PHHFRISYlq+xx57TJGRkQ7xCxcuKCkpybTzmCU7O1vz5883bJswYYLCwsJMO9fIkSP/H3v3HR5Vtf5//5NKSaiGGnoL0qQGUAQORbogP0A8UlWkCCh6FCQU5QuIghTpKMgBCxIQJCK9Nw0QSGgCgrRIIAESEpKQNs8fPuYYM4Fk+iTv13Vx6b7X3ve6Z2avXWYya4zOkfvw4UMFBgZmK8etW7d0+PBho23jx483q75/+r//+z+5uLhYJNeFCxeynMt60KBBZuV2d3fXBx98YFaOv9y8eVOHDh0y2vb+++9bpI+/vP7663rqqafMznPv3j2j8YoVK5qd2xqcbczBPLnx9bbkedPcc+bly5d16tSpTHFPT88s56A3VZEiRbL9Gw9wbvPnzzcar127tqZNm2aRPl5//XW1a9fOIrkszZrXLJJlr1uyI6vfvTCFs13nS9zrOJvceN3gaMqVK6fFixfr6tWr6t69u8Xze3p6Go0nJCRYvC/g75z9unjt2rVG+2nVqpW6deuWIR4bG6u9e/dmO3daWpp++umnTPFu3bqpR48emeI7d+5UTExMtvPnJrbaj6x5b7Vs2bJMMW9vb/2///f/VLlyZbVs2TJb2+SEs48/R+ZM9yZ5bT/Ibdetznjf5Gg157Z9wlZs/dmGMx1X8T/O9hmY5DznRd4jAAAAgDlc7V0AAAAAAAAAAAAAAAAAAAAAAAAAkBu4urrq888/l6+vr9H2b775xiZ1REVFGY03b97c7Ny+vr6aM2eO2Xn+smTJEqPxtm3b6s0337RIH40bN9bixYt18uRJBQUFyd/f3yJ5c+rSpUsaOXJkpnihQoW0Zs0aubu7W6yvjRs3Kjk5OVN84sSJmSZ52LZtm9F1H+WHH37IFOvevbu6du2aKW7OJCqff/650XhAQICqV69uct5/mjNnjs6fP6/Ro0fL1ZWv3FlSuXLltGjRIl26dEnDhg2Tp6enPvvsMxUvXtyi/VSrVi1TLD4+XrGxsRbt51Ec/Xg2a9YsGQyGTPG6detq7ty5ZtfWoEEDzZo1y2jbqlWrdPv2bbP7QN7y448/KiwszGjb22+/rddee82s/O3bt7fIvm8r4eHhRuPVq1dXqVKlLN6ftY8ZkmMfN6KjozV27FijbS4uLvr666/Vt29fG1dlGq6nLCOvj4lHcfRrIMaA9f3xxx96/fXXrdqHs4/B3HKPDsd07ty5LCfRrVWrln766ScVKFDAKn3PnTtX5cqVM9qWnX0ttxyj69atq5kzZ1okV6tWrfTee+8ZbVu9enWO3+ew9X1EbnlN8T+Oun8b29fYzxyHrY89zojjZd7lLPc2zvbZDscdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAuEydOVGpqqkVyffnll0bjDRs2VMGCBbOVo0KFCmrQoEGmeHx8vEXnY798+bJ27tyZKV6xYkU9+eSTFuvHXBs2bNCGDRvsXYZRhQoVUqdOnYy2ffTRRxbta9OmTTpz5kymuIuLi3r16mWxfv7v//7PYrmkP+fziYyMzBR3d3dXx44dH7t9bhkP1tyP79y5owMHDlgs3+7du43GGzRoIDc3N4v14+hy0/h2tPNcvnz5jMaNzYVjKlv+HgAAAAAAAAAAAAAAAAAAAAAAAADwl/r16ys2NlaxsbGaNm2avcsBAAAAAAAAAAAAAACAk6hbt65mzpxpkVytWrXSe++9Z7Rt9erVDjt366xZs4zOUVu3bl3NnTvXIn00aNBAs2bNMtq2atUq3b59O9u5Fi5caDT+r3/9S++8845J9f1Tx44d9e9//9siuf5y+PBho/EhQ4aoaNGiJucdP368atasafL2/7RkyRKj8bZt2+rNN9+0SB+NGzfW4sWLdfLkSQUFBcnf39/kXOHh4Ubj1atXV6lSpUzOa03ONuZgntz2elvqvGmpc+bnn39uNB4QEKDq1aubXN8/zZkzR+fPn9fo0aPl6upqsbxwPD/++KPCwsKMtr399tt67bXXzMrfvn17i419a7HWNYtk+euWx6lbt65F8jjrdT73Os4nt103OIpy5cpp0aJFunTpkoYNGyZPT0999tlnKl68uEX7qVatWqZYfHw84wM24czXxRs3blRycnKm+MSJE1WxYsUMsW3bthld91F++OGHTLHu3bura9eumeKBgYE5yp3b2GI/sua91caNG42exwYPHqyBAwfKxcUlQ/zq1avasWOH2f068/hzdM50b5LX9oPcdN3qjPdNjlhzbtonbMUen20403EVf3LGz8Akxz4v8h4BAAAALCFvvDsHAAAAAAAAAAAAAAAAAAAAAAAAWJGPj4++//579e3b12j77du3tXr1apvUcuHCBaPxoUOHmpW3YMGCWrdunUqUKGFWnr/79ttvdfHiRaNtM2fOVOfOnc3KX7p0aQUGBqZ/ib9r16765ZdftGPHDpUsWdKs3Kb473//q7Vr12aKN2nSRFOnTrVYPzExMdq5c2emeKtWrTLFjE1s9jjbtm1TUlJShljVqlVVrFixDLGUlBST8v9l+fLlioyMzBQvWLCgvv76a3l5eZmc+y+vvfaaBg8erMKFC2vevHkKCQlR8+bNzc6LPy1ZskTDhw+Xp6dneqxChQoKDAxUgQIFLNKHv7+/0Ykxbty4YZH82eXox7Nz584ZPf5I0ogRIzRmzBiTa6tevbo2bNig/PnzZ2pLTEzUjBkzTM6NvMtgMGj06NFG21xdXfX5558rICDApAns+vbtq6CgIIsdh2whPDw8y+PaiBEjLN6fNY8ZknMcN5YuXao9e/YYbXN3d9e3336rOXPmGH0MlvKvf/3L7GtWrqcsgzGRNUe/BmIM2Mb69ev13//+12r5nX0M5pZ7dDiu8ePHZzkx5LPPPqv9+/erSpUqFuvPxcVFn332mV599VWj7Xfv3tU333zz2Dy56Rg9ZswYDRkyxKwcTz75pNasWSM3N7dMbSkpKSZNiGzr+4jc9Jrifxxx/za2r+Wl/czDw0Pz58/P8p+92frY44w4XuZdznJv42yf7XDcAQAAAAAAAAAAAAAAAAAAAAAAAAAAAADncfXqVQUFBVks36FDh2QwGDLF3d3dVbFixWzlaN++vdH4zp07dffuXbPq+6e9e/cajbdu3dqi/ZjDlPmObOW5556Th4dHpvjp06e1e/dui/eX1XPRrVs3i+S/evWqduzYYZFcf3n48KGWL19utK1jx46P3T63jAdH3o//6ddff1VcXFymuLu7e6Y5BXOz3DK+HfE8Fx0dbTReuXJlc0oDAAAAAAAAAAAAAAAAAAAAAAAA7M7V1VXe3t7y9vbO8HvMAAAAAAAAAAAAAAAAwOOMGTNGQ4YMMSvHk08+qTVr1sjNzS1TW0pKikPPlXzu3DmtXbvWaNuIESM0ZswYs/JXr15dGzZsUP78+TO1JSYmasaMGTnKFxgYqGvXrhltmzFjhtlzC9eqVUvffPONWTmMyeo5LlmypObMmWNSzu7du2vy5MnmlJXJt99+q4sXLxptmzlzpjp37mxW/tKlSyswMFCurq6SpK5du+qXX37Rjh07VLJkyRznCw8P140bN4y2jRgxwqxarcXZxpyz8fDw0Pz587P8Z2u58fU297xpyXPm8uXLFRkZmSlesGBBff311/Ly8jK5zr+89tprGjx4sAoXLqx58+YpJCREzZs3NzsvHJPBYNDo0aONtrm6uurzzz9XQEBA+nksJ/r27augoCAVKFDA3DKtyhrXLJJ1rluyIy9f50vc6zib3Hjd4AiWLFmi4cOHZ/iuSYUKFRQYGGixY7K/v7+qVauWKZ7VvQpgac58XRwTE6OdO3dmirdq1SpT7Icffshx/m3btikpKSlDrGrVqpl+DywlJcWk/LnJ4/Yjc1n73iolJUX//e9/M8Vbt26t4cOHZ4p/8cUXRn8PLKecefw5Ome6N8lr+0Fuu251xvsmR6s5t+0TtmCPzzac6biKPznjZ2CSY58XeY8AAAAAlpDzvxYAAAAAAAAAAAAAAAAAAAAAAAAAIEmqVq2aJk2apN9++03du3fPcr1x48bpwYMHNqlp27ZtRuPt27fXq6++alLOsmXL6uDBg2rWrFl6LCQkxKRcf5eamqp33nnHaJuHh4c2bdqkN99806TcNWvW1P79+1WpUqVMbaVLlzY6kYAtvP7660YnpH/vvffUtm1bi/WT1cQcf5eamqqffvopx7nj4uK0d+/ex663a9cu3bt3L8f5/xIfH5/lJCBNmjTR/v37TZoE/i+jR4/W0qVLM8SeeuopHTp0SB06dDA5L/5n4sSJRidHa9OmjXbt2qXy5cublb9o0aJavny50bYtW7aYlTunnOF49uabbyomJsZo2+zZs7VkyZIMk5hkR/v27RUcHKyKFSsabf/www91+fLlHOUE/rJv3z4tWbIky/apU6cqNDRUnTt3ztYE6w0bNtT27dv17bffKl++fOnxmzdvKi4uziI1W1NW595x48apZcuWFu/PGscMybmOGy+++GKWPyQkSW+99ZbOnz+vgQMHysPDwyJ9enh4qGvXrjp06JB2796t4sWLm5WP6ynLYUwY5+jXQIwB2xk5cqRV91VnH4O54R4djuvKlSsaNmxYlu2NGzfWyZMn9c4775g9SWWDBg20Z88ejRo1Kst1Jk+enK3r69x2jF62bJlmz55tdGLkx+nSpYt+/vlnlS5d2mj7ggULdP78eZPqsuV9RG57TfOyP/74I8Oyo+3fWe1reWU/8/Dw0MiRI7P85whs/R6Gs+F4mbc5w72NM362w3EHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJzDjz/+aNF89+/f16VLl4y2FStWLFs5WrRoYTSe1Vzv5vj555+NxmvXrm3xvkzx66+/av/+/fYuI0v/+te/jMa3bt1qlf6yytu0adMMc9uaavv27WbnMGb37t1G402aNHnstrlhPDj6fvxPBoNBN2/eNNpm7ry0ziS3jG9HPM9ltX+99NJLJtcFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM5u2bJlmj17ttzc3HK8bZcuXfTzzz+rdOnSRtsXLFig8+fPm1uiVb355puKiYkx2jZ79mwtWbJEnp6eOc7bvn17BQcHq2LFikbbP/zwQ12+fDlHOZOTk/X2228bbXN3d9fGjRv17rvv5rhWSWrbtq0OHDiQYc7f8PBwk3L905o1a/THH38YbRs0aJCmT5+eo3xDhgzRunXr5Orqmh67cOGCWTVKUmpqqt555x2jbR4eHtq0aZPefPNNk3LXrFlT+/fvV6VKlTK1lS5dWpGRkSbl3bt3r9H4uHHj1LJlS5NyWpszjTln4+HhoZEjR2b5zx5y4+u9bNkyhzhnxsfHa/LkyUbbmjRpov3796tkyZI5rvMvo0eP1tKlSzPEnnrqKR06dEgdOnQwOS8c2759+7RkyZIs26dOnarQ0FB17tw5w3k4Kw0bNtT27dv17bffZvj9g5s3byouLs4iNVuSpa9ZJOtdt2RHXrzO/+frlxefA2eWG68b7G3ixIkyGAyZ4m3atNGuXbtUvnx5s/IXLVpUy5cvN9q2ZcsWs3ID2eXs18Vr16597Dqpqan66aefcpw7Li4uy/cN/m7Xrl26d+9ejvPnJo/bjxx5H/rL559/ninm4uKSqfbU1FStWLHCIn06+/hzZM50b5IX94Pcdt3qjPdNjlZzbtsnbMHWn20403EV/+OMn4E58nmR9wgAAABgCY//KwEAAAAAAAAAAAAAAAAAAAAAAAAgF2jevLl69uxp0r9evXpp4MCBGjlypD744AOtXbtWv/76qy5evKgPP/xQRYoUybLf7777Tl9++aXNHueBAwcUFRVltG3ZsmWaOHGi3N3ds5XL09NTo0ePVmhoqBo0aJAej46O1qRJkyxSb1BQkFauXGm0zc3NTXPnztWxY8f03HPPZSuft7e3JkyYoOPHj6t69eqZ2g0Gg9566y2jX9a3hZiYGL388stKS0vLEHdxcdHq1avl4+NjkX42btyo5OTkR65z+PBh3b1716T8P/zww2PXyc6EbI+zePFi7du3z2hbw4YNdfr0aY0YMSLb+7Qk1a1bV1u2bNG8efOMTsR79OhR7dixw+Sa8T8nTpzQ4sWLjbY1b95cZ8+e1cSJE03a7zt06KDg4GDVqVPHaHtgYGCOc5rL0Y9nt27d0rBhw7JsHzp0qC5cuKB+/fo9dkzVrl1bGzZs0Pbt21W0aFGj6xw8eFAzZ87MVm1AVkaPHq1ffvkly/Y6depo8+bNioqK0tdff60JEyZoyJAh6dduY8eO1eLFi/X777/r+PHjat++faYcw4YNU2JiojUfhkVkNcm8p6endu7cqRkzZmQ5uZkpLHnMkJzzuBEZGamuXbvqzp07Wa5ToUIFrVy5UtevX9fChQv13HPPPfLe4J88PDxUu3Ztvfzyy1qzZo2ioqIUFBSkp59+2hIPQRLXU5bCmMiao18DMQZsIy4uTi+//LJSU1Otkt/Zx2BuuUeH4/rmm28yTWr5d4UKFdKsWbN09epVzZkzRy1btsz2BMDFixfXgAED9NNPP+n48eNq1apVluvu2rVLCxcuzHbdzn6MDgkJybA8ZswYnT17Vr169ZKLi0u2at20aZN+/PFHFS5c2Og6V65cMet9WFvfRzj7a4o/LV26VL/99luGmKPt31m958h+5hhsfexxRhwv8y5nuLdxxs92OO4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAgHPYv3+/xXNev37daLx48eLZ2r5mzZpG40eOHDG5pqzcvHnTaLxGjRoW78sUe/futXcJj1SrVi2j8YMHD1qlvxs3bhjdv1xdXeXn52d2/gMHDpidw5jg4GCj8zVWqlRJnp6ej9w2N4wHR9+PjYmJiTEaz+5xLDfILePbEc9zWT2HAwYMUO/evU2uCwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACcTUhISIblMWPG6OzZs+rVq5dcXFweu33dunW1adMm/fjjjypcuLDRda5cuaJJkyZZpF5runXrloYNG5Zl+9ChQ3XhwgX169dP7u7uj81Xu3ZtbdiwQdu3b1fRokWNrnPw4EHNnDnTpHrXr1+vH3/80Wibq6urPvnkE4WEhKhDhw7ZylezZk2tWrVKO3bsyDDfb2JioiZMmGBSjf+UkpKiOXPmZNn+/vvva/Pmzapevfoj8zRs2FBbtmzRsmXLMrwWR48e1caNGy1Sa1BQkFauXGm0zc3NTXPnztWxY8f03HPPZSuft7e3JkyYoOPHjxt9fAaDQW+99ZbROdWzY8mSJUbjnp6e2rlzp2bMmKGKFSualNtanG3MwTy55fX+53nTUc6Zixcv1r59+4y2NWzYUKdPn9aIESOy9dz+vd4tW7Zo3rx5cnV1zdR+9OhR7dixI8e1wnmMHj1av/zyS5btderU0ebNmxUVFaWvv/5aEyZM0JAhQ9SrVy8NHDhQY8eO1eLFi/X777/r+PHjat++faYcw4YNU2JiojUfhkksdc0i2ea6JSt/P2bltev8pUuX6rfffssQy2vPgTPLLdcNjuTEiRNavHix0bbmzZvr7Nmzmjhxonx8fHKcu0OHDgoODladOnWMtgcGBuY4J2AqZ74u3rhxo5KTkx+5zuHDh3X37l2T8v/www+PXWft2rUm5c5tHrUfOfI+9JeLFy9mWf/fbdmyRX/88YfF+nXm8efInO3eJK/tB7nhutUZPyNy5Jpzwz5ha7b+bMPZjqv4kzN+BiY57nmR9wgAAABgCdm/igUAAAAAAAAAAAAAAAAAAAAAAACc2FtvvaW33nrLpn1u3bpVAwYMsGmfDx8+1LRp04xOyuDq6qopU6Zo2LBhWr16tfbv36/z588rOjpaiYmJKlKkiEqWLKlq1aqpQ4cO6tKli8qUKZMhh8Fg0MCBAxUZGWmxmocNG6YaNWro6aefNtreqFEjbdu2TZGRkdq+fbtOnDih27dv686dO5KkIkWKqHLlyvL399dzzz2nAgUKZNnXRx99pF27dlmsdlMcPHhQH330kQICAjLEy5Qpo5UrV6pr165m9xEdHa1du3apY8eOWa6TnQnNshIUFKSFCxdm2Z6SkmKxSTv69Omjo0ePqkKFCpnaSpQooYULF2rSpEnasmWLdu7cqevXr+v27duKj4+Xp6enChUqpAoVKqhevXrq3LmzmjVrlmVfN2/eVO/evZWWlmaR2vHnpEL+/v5q3LhxpjZvb29NmTJFEydO1OHDh7V3716dO3dOV65cUWxsrOLj4+Xi4iIvLy8VLVpUVatWVYMGDdS5c+dHTioTFBSkQ4cOWfNhZcnRj2dr1qxRnTp1Mh1//lKxYkWtXr1aCxYs0LZt2xQcHKyIiAglJiaqVKlSql69ujp16iQ/P79H9nP58mX16NFDqampOaoP+Kfk5GR17NhRO3bsMHoc+UuxYsX073//O8f5p06dqk2bNplTos0cOnRIBw8eVIsWLTK1eXh4aOzYsRo7dqzCw8N17do1xcbGGj2f3bp1S4MGDcpWn6YeM+7cuSMvL69ccdw4deqUWrZsqZ07d2a6Lv67UqVKacSIERoxYoQMBoOuXr2qq1ev6ubNm3rw4IESExPl5uYmb29vFSpUSIUKFVLZsmVVrVq1HE1cJUk7duzI8QSkXE9ZBmMia45+DcQYsI2ff/5Z06ZNs9qPPTjzGMxN9+hwXMOGDZOLi4tef/31LNcpUaJE+nukSUlJOn/+vM6dO6e7d+8qLi5ODx48kLu7u8qWLauyZcuqTp068vX1zVb/p06dUq9evXL8g33OfIwePHiwgoODlS9fvvRYjRo1FBgYqKioKG3dulXHjx9XRESE7t27p0KFCqUfizp27PjYY1FCQoJ69Oih2NhYk2u0x32EM7+m+FNiYqL69++vffv2ydPTMz3uaPv3tWvX2M8clD2OPc6I42Xe5Qz3Ns722Q7HHQAAAAAAAAAAAAAAAAAAAAAAAAAAAABwDufOnbN4zpiYGKPxokWLZmv7GjVqGI1fvXrV1JKydO/ePaPxYsWKWbwvU/zyyy/2LuGRnnzySaPxkJAQq/V5/PhxlS9f3mgtYWFhZuW+ePGiWdtnJSYmRlevXlWlSpUyxF1dXVWlShX9+uuvWW6bG8aDo+/HfyldurSqVq2qKlWqqHjx4kbX+fscULldbhnfjnieO3jwoO7cuaMnnngiQ9zV1VXfffedunbtqtmzZys0NNTcUgEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAoQ0ePFjBwcHKly9feqxGjRoKDAxUVFSUtm7dquPHjysiIkL37t1ToUKFVKpUKVWvXl0dO3aUn5/fI/MnJCSoR48eio2NtfZDsYg1a9aoTp06CggIMNpesWJFrV69WgsWLNC2bdsUHBysiIgI3blzR15eXunPTadOnR773Fy+fFk9evRQamqqyfX269dPx44dU7Vq1Yy2N2jQQFu3blVERIS2bNmisLAw3bp1S/fu3VO+fPlUvHhx1alTR//617/UoEEDoznefPNNXb582eQa/2nOnDnq3r27WrRoYbS9c+fO6tixoz788ENdu3ZNkZGRcnFxUfHixVW3bl21b99eTz31VKbtHj58qFdeeUUvv/yyxWodNmyYatSooaefftpoe6NGjbRt2zZFRkZq+/btOnHihG7fvq07d+5IkooUKaLKlSvL399fzz33nAoUKJBlXx999JF27dplcq2HDh3SwYMHjT6vHh4eGjt2rMaOHavw8HBdu3ZNsbGxSktLy7TurVu3NGjQIJPryClnG3MwT254vf953nSkc2afPn109OhRVahQIVNbiRIltHDhQk2aNElbtmzRzp07df36dd2+fVvx8fHy9PRUoUKFVKFCBdWrV0+dO3dWs2bNsuzr5s2b6t27t9HjCHKP5ORkdezYUTt27FDjxo2zXK9YsWL697//neP8U6dO1aZNm8wp0aqye83y888/a9u2bXa/bjHGkY9Z1paYmKj+/ftr3759GX7rJC89B84uN1w3OJoxY8bI39/f6DHd29tbU6ZM0cSJE3X48GHt3btX586d05UrVxQbG6v4+Hi5uLjIy8tLRYsWVdWqVdWgQQN17txZ1atXz7LPoKAgHTp0yJoPC8jEWa+Lo6OjtWvXLnXs2DHLdX744QeT8wcFBWnhwoVZtqekpGjjxo0m589tstqPHHkf+rtly5apVatWj13H0px1/Dk6Z7s3yWv7gbNftzrjZ0SOXrOz7xO2Zo/PNpztuArn/QxMctzzIu8RAAAAwFzu9i4AAAAAAAAAAAAAAAAAAAAAAAAAyI0WLFigMWPGKCUlxeZ9L1q0SAMGDMhyovKyZcumf8E/p8aOHatNmzbJ39/f3DLTPXz4UJ07d9bmzZv1zDPPZLleiRIl9PLLL5s8GcQXX3yhCRMmmFqmRU2ePFnt2rVT06ZNM8S7dOmiUaNGaf78+Wb3sXbt2kdOhhYUFGRy7uvXrys0NNTopB2StGfPHt29e9fk/H93+/ZttWvXTrt371a5cuWMrlOqVCkNGjTIrMkobt26pQ4dOujatWsm50BmSUlJ6tSpk7Zt26aGDRsaXcfDw0OtWrV67IRr2REVFaXhw4ebncdUznA8mzBhglxcXDR+/Pgs1ylSpIj69OmjPn365Dj/2bNn1bFjx/QfeADMFR0drbZt22rVqlXq3r27xfLOmjVLEydOtFg+WxgwYIBCQ0NVqFChLNfx9fWVr69vlu1XrlzJUZ/WPmZIjn/cOHv2rBo1aqRvv/02W+cqFxcXVapUSZUqVbJoHXfv3lVAQICWLFmS4225nrIcxoRxjn4NxBiwnSlTpqhDhw6Z7nUtxZnHYG65R4djGzp0qKKiojRu3Di5uro+cl1PT0/VrVtXdevWNbvfgwcPqnv37oqOjs7xts58jA4LC1P//v313XffycXFJUObj4+P+vXrp379+pmUOyEhQT179lRoaKjZddr6PsKZX1P8z88//6xhw4Zp+fLlDrt/s585Nnu8h+FsOF7mbY5+b+OMn+1w3AEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxxceHm7xnPfv3zcaf9w8TH8pVqxYplhCQoJV5u6Ki4szGn/Ud+VtyRJzHllTiRIljMYjIyOt1mdUVJTRuI+Pj9m5r169anaOrNy9e9fovKjG9vfHtTvbeHCU/ThfvnyqVKmSqlatqipVqqhatWqqUqVK+r8CBQrYu0SHklvGtyOe55KTk/XRRx9p1qxZmdpcXFw0YMAADRgwQDdu3NDRo0d15swZ/fbbb+n/bt26ZVb9AAAAAAAAAAAAAAAAAAAAAAAAgKU0aNBAvXr1Ur169VSlSpUM36MbOXKkunXrpkuXLunw4cPasmWLQkJCbFpf3bp11bx58/Tls2fP6uDBg07Xb40aNfTCCy+oVatWql27tnx8fFSwYEE9ePBAkZGRunnzpvbv36+tW7dq//79SktLs8TDAAAAAAAAAAAAAAAAsImwsDD1799f3333nVxcXDK0+fj4qF+/furXr59JuRMSEtSzZ0+HmSc5uyZMmCAXFxeNHz8+y3WKFCmiPn36qE+fPib1cfbsWXXs2FF37twxtUxJUkxMjDp27Khdu3apYsWKWa5XunRpDR48OMf5P/vsMy1btkwtW7Y0p8wMUlNT9eKLL+rkyZNZzsXs6uqqDz/8MNs5DQaDhg0bptOnT1uqTEnSw4cP1blzZ23evFnPPPNMluuVKFFCL7/8sl5++WWT+vniiy80YcIEU8tMN2DAAIWGhj5ybnNfX1/5+vpm2X7lyhWz68gpZxpzMJ+zv95ZnTcd4Zx5+/ZttWvXTrt371a5cuWMrlOqVCkNGjRIgwYNMrmfW7duqUOHDrp27ZrJOeA8oqOj1bZtW61atUrdu3e3WN5Zs2Zp4sSJFstnDdm9Znn66af19NNPZzuvta5bjPnrmLV27doMcUc4ZtnCzz//rGHDhmn58uXc6zgpZ79ucDRJSUnq1KmTtm3bpoYNGxpdx8PDQ61atVKrVq3M7i8qKkrDhw83Ow+QU858Xbx27Vp17Ngxy/agoCCTc1+/fl2hoaF66qmnjLbv2bPHKr/L5qwetx856j70l/Xr12v+/PkqXry40fY//vhDmzdvtni/zjz+HJmz3Zvkxf3Ama9bnfEzImeo2Zn3CXuw9WcbznZcxZ+c9TMwRz0v8h4BAAAAzOVq7wIAAAAAAAAAAAAAAAAAAAAAAACA3CQsLExt27bVqFGjlJKSYpca/voi+u+//26xnMnJyRo6dKhmzpxpsZx/FxMTo3bt2mnFihUWz52Wlqbp06dryJAhMhgMFs9vitTUVP373/822jZz5kzVq1fP7D42btyo5ORko20XLlzQhQsXzMq/adOmLNsCAwPNyv1PFy9eVPPmzRUcHGzRvH8JCQlR48aNderUKavkz+uioqLUunVrbdy40ar93LhxQy1atFB4eLhV+3kcZzieBQQE6LXXXtODBw8sWJ3SfwTi+vXrFs0L3L9/Xz169NDQoUPNnqzrzp07evnll/Xuu+9aqDrb+f3339WzZ0/FxMTYtF9rHTMk5zlu3Lx5U23atNHbb79t8+c/Li5On376qapWraolS5aYnIfrKcthTBjn6NdAjAHbSE1N1csvv6y4uDir9eGsYzA33aPDsQUEBKhly5a6dOmS1fuKj4/XuHHj9K9//cusSfGd+RgdGBiovn37KjEx0WI5b926peeee05bt261SD573Ec482uK//nyyy81aNCgLM9fprDk/s1+5tjs9R6Gs2E/ztsc/d7G2T7b4bgDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI4vNjbW4jnT0tJM3rZgwYJycXHJFC9QoIASEhIs/i+rOVXz5ctn8mOwJHPnfLWmAgUKyM3NLVP84cOHFp0D6p/u3btnNF6oUCGzc9+/f9/sHFmJjo42Gvf29s5ym9wyHmy9H5ctW1bdunVTQECAvvzyS+3bt083btxQQkKCfv31V23evFnz58/Xm2++qW7duql27doqUKCATWt0dLlpfDvaee4v8+fP16FDhx65Trly5fTCCy9owoQJWrlypQ4ePKiIiAjFxcUpNDRU69ev18cff6zXXntNTZo0cZhzFwAAAAAAAAAAAAAAAAAAAAAAAHI3d3d3jRw5Ur/99ptCQkI0fvx4de3aVbVq1VLBggXT18ufP7/8/PzUuXNnTZ06VcePH1doaKheeOEFm9Tp4+OjLVu2aOnSpen/Xn75Zafqt1atWtq8ebN+/fVXzZgxQ506dVKFChXSn2cvLy9VqlRJzZs319ixY7Vnzx6dOXPGZs8xAAAAAAAAAAAAAACApQQGBqpv374Wnf/21q1beu6557R161aL5bSlgIAAvfbaa3rw4IHFc2/evFnPPPOMrl+/bpF8ly5d0jPPPKOQkBCL5PvLjBkz9Oabb1o051/++OMPPfvss7p06ZLZudLS0jRy5EitXLnS/MKMiImJUbt27bRixQqL505LS9P06dM1ZMgQGQwGs/P9/vvv6tmzp2JiYixQnW0505iD+Zz99bb0edOS58yLFy+qefPmCg4OtkBlmYWEhKhx48Y6deqUVfLDMd2/f189evTQ0KFDzf79izt37ujll1/Wu+++a6HqrMuS1yyS9a9bjAkMDMzT1/lffvmlBg0apOTkZIvldLbnwNk5+3WDo4mKilLr1q21ceNGq/Zz48YNtWjRQuHh4VbtB8iKs14Xb9y4Mctz1oULF3ThwgWz8m/atCnLtsDAQLNy50bW3I+sfW/18OFDffXVV1m2f/nllxb5HTBjnHX8OTpnuzfJi/uBM1+3OuNnRM5QszPvE7Zmj882nO24Cuf+DMxRz4u8RwAAAABzuNq7AAAAAAAAAAAAAAAAAAAAAAAAAMDZJSQkaMOGDerYsaOeeuop7d69294l6datW2ratKk2b95sdq6wsDD5+/tr2bJlFqgsa4mJiXr11Vf1/PPP6/LlyxbJeenSJbVv314BAQEWyWdJWT3GfPny6bvvvlOBAgXMyn/v3r0s98VHTWSWXT/88IPReGpqqjZs2GB2/n/6a9KDgIAAxcfHWyRnfHy8xo4dK39/f924ccMiOWFcbGysXnjhBfXu3VvXrl2zaG6DwaCvvvpKTZo00fnz5y2a21TOcDxbvny56tata5GJmm7evKn+/fura9euio6ONr84IAvLli1TpUqVFBAQkONJp27fvq0pU6bIz89P33zzjZUqtL6dO3fK399fBw4csGm/ljxmSM553EhLS9OcOXNUrVo1ffLJJ7p3755V+/v111/17rvvqly5cvrPf/5jkeeJ6ynLYUwY5+jXQIwB27h06ZLVfiTtL844BnPbPToc26FDh1SnTh2NHDlSV65csXj+1NRUrV+/Xk8++aQ+/vhjpaSkmJ3TmY/Ra9euVbNmzXTy5EmzcwUGBqp27do6ePCg+YX9jT3uI5z5NcX/rFq1Sk8//bQuXrxodi5r7N/sZ47NXu9hOBv247zN0e9tnO2zHY47AAAAAAAAAAAAAAAAAAAAAAAAAAAAAODYkpOT7V1CBl5eXlm25c+f3+L/8uXLZ8NHl3MxMTH2LiFLWb1W9+/ft2q/Wc09WrhwYbNzW2quEWOyei29vb2z3Ca3jAdb7Me1a9fWxx9/rCtXrig8PFybNm3S1KlTNWjQILVs2VK+vr5ycXGxeh25RW4a3452nvtLUlKSunfvrhMnTuR4Wy8vL9WrV089e/bUe++9p88//1zBwcGKi4vTzp07NXjwYLN/UwMAAAAAAAAAAAAAAAAAAAAAAAAwplq1ajp69Kjmz5+vqlWr5nj7evXq6fvvv9ePP/6oYsWKWaHC//nqq6/k6+tr1T6s2e9//vMfhYaGqnPnzjn6flzNmjX1/fff69tvv5Wnp6fZdQAAAAAAAAAAAAAAANjK2rVr1axZM508edLsXIGBgapdu7YOHjxofmF2tHz5ctWtW1dbt261SL6bN2+qf//+6tq1q6Kjoy2S8y/h4eFq2rSppkyZoocPH5qVKyoqSt27d9f7779voeqMO3/+vPz9/bVlyxaTc0RGRqpjx45atGiRBSvLLDExUa+++qqef/55Xb582SI5L126pPbt2ysgIMAi+f6yc+dO+fv768CBAxbNawvONOZgPmd/vf86b5rLGufMGzduqEWLFgoICLDYb0DEx8dr7Nix8vf3140bNyySE85n2bJlqlSpkgICAnTp0qUcbXv79m1NmTJFfn5++uabb6xUoXVY4ppFst11izF5/Tp/1apVevrpp3Xx4kWzcznrc+DsnP26wdHExsbqhRdeUO/evXXt2jWL5jYYDPrqq6/UpEkTnT9/3qK5gZxyxuvie/fuaffu3UbbNm3aZHb+H374wWg8NTVVGzZsMDt/bmTp/ciW91bLli0zGjcYDPriiy+s2rczjj9n4Gz3JnlxP3Dm61Zn/IzIGWp25n3C1uzx2YazHVfh3J+BOep5kfcIAAAAYCpXexcAAAAAAAAAAAAAAAAAAAAAAAAAOIOkpCTFxsbqypUr+uWXX/T1118rICBAbdu2lY+Pj3r27Klt27bZu8wMIiMj1bVrV/Xu3dukyThCQkLUt29f1a9f3yITg2RXUFCQ/Pz89PLLL+vQoUMyGAw5zhEaGqqhQ4fKz88vywnBHMGaNWuMxmvWrKl58+aZnX/t2rVG41lNZJYTx48f182bNzPF9+3bp6ioKLPzG5OcnKzp06ercuXKmjZtmsmTNFy/fl2TJk1S+fLl9cknnyg1NdXClSIr69atU+XKldW7d2/t3LnTrB9iuHfvnlasWKGmTZuqf//+ioiIsGClluHox7Pff/9dnTp1UpMmTbR27docT6Zy8uRJDR06VJUqVdJXX31l0dqArMTFxWn69OmqVq2aGjZsqJEjR2rFihXauXOnjh49qnPnzunEiRPav3+/Vq9erffff1/NmzdXmTJlNHnyZN25cydTznz58hntKyUlxdoPxyQXLlxQy5Yt1bRpUy1dulRhYWFKS0uzer/mHjOk3HHciIqK0tixY+Xr66v+/fvr+++/14MHD8zOm5aWpqNHj2ratGlq3LixnnzySc2aNUsxMTEWqPp/uJ6yHMZE1hz5GogxYBsrVqyw+iTZzjgGc9s9OhxbYmKiFi5cqGrVqqlnz55atWqVIiMjzcp55swZ/ec//5Gvr6969epl8YkvnfkYHRoaqsaNG2vgwIE6d+5cjrZNTExUYGCgGjZsqD59+hi9Z7EEe9xHOPNriv85duyYateureHDh+f4Rz9tsX+znzk2e72H4WzYj/M2Z7i3cabPdjjuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACyy8XFxd4lOJT79+/bu4Qsubq6Go1be36NrPJbYt8xZZ7G7DKl7twyHqy5H1esWFHffPONTp06pffee08VK1a0Wl95SW4c347ozp07at68uRYtWmSR59bd3V1t27bVihUr9Ntvv2nw4MEWqBIAAAAAAAAAAAAAAAAAAAAAAAD4U61atXTkyBHVr18/Q9xgMOjUqVNavXq1Vq1alR4PDQ3Vrl27FBMTkylXly5ddOTIEZUsWdIqtY4bN04dOnSwSm5b9DtnzhzNnDlT7u7uGeL37t3Txo0b9fHHH2vs2LGaMGGCPvvsMx0+fFgpKSkZ1u3bt6+2bdsmT09Ps+sBAAAAAAAAAAAAAACwldDQUDVu3FgDBw7UuXPncrRtYmKiAgMD1bBhQ/Xp00d37tyxUpW29fvvv6tTp05q0qSJ1q5dq/j4+BznOHnypIYOHapKlSrpq6++skKVf0pJSdHkyZNVqVIlffrpp4qMjMzR9rdv39aUKVNUpUoVbdq0yUpVZnT37l117txZbdq00ZEjR7K9XXR0tGbOnKlq1appx44dVqwwo6CgIPn5+enll1/WoUOHTJpbPTQ0VEOHDpWfn592795thSqlCxcuqGXLlmratKmWLl2qsLAwpaWlWaUvS3OmMQfzOfvrHRoa6rDnzOTkZE2fPl2VK1fWtGnTdOPGDZPyXL9+XZMmTVL58uX1ySefWH2+fDi+uLg4TZ8+XdWqVVPDhg01cuRIrVixQjt37tTRo0d17tw5nThxQvv379fq1av1/vvvq3nz5ipTpowmT55sdH/Ply+f0b7++fe59mTqNYtkv+uWv+M6Xzp27Jhq166t4cOH6/LlyznaNrc8B87O2a8bHNG6detUuXJl9e7dWzt37tTDhw9NznXv3j2tWLFCTZs2Vf/+/RUREWHBSgHTOeN18dq1a43Gf/jhB7NzHz9+XDdv3swU37dvn6KioszOn1v9fT9yhn3oL2fOnNHPP/+cKb5jxw5duXLF6v074/hzBs52b5IX9wNnvm51xntHZ6jZmfcJW7PHZxvOdlyFc38G5sjnRd4jAAAAQE65GLL5l3MuLi7WrgWAk6pXr57q1asn6c/JFC9fvqyff/7ZpD/MBQAAAAAAAAAAQN42c9ZMe5eAPODc2XNasWKFvcsAAIt4c72Uz8veVSA3u3Fa+uY/9q4CAJAVFxcXNW7cWDVq1Ej/e++wsDCFhYXZubK8ib+pBeAs/Pz81KJFCzVv3lzVqlVT0aJFVaxYMXl4eCg2NlbR0dHpk5Fu3rxZv/32m71LliSVLl1arVu3VrNmzVStWjWVL19e3t7eKlCggNLS0hQTE6Po6Gj9+uuvCgkJ0e7du3M8gQmcV+PGjdWiRQs1atRIFStWVMmSJeXl5SV3d3clJSXp/v37io6O1vnz53XmzBnt2rWLayYHUrBgQbVq1Ur16tVTzZo1VbVqVRUqVEje3t7y8vKSwWBQXFycYmNjdf/+fV26dCn9uvfQoUMONelxdjj68Sx//vxq3769/P39Va9ePfn6+qpIkSLy8PBQTEyM7t69qzNnzig0NFTbt2/X1atXbVYbYC2urq5ZTvxTq1Ytp7mm8PLyUpkyZTJc3xmTkJCgPXv2WKTPrI4Z3t7eevjwYZ46bri7u6tOnTpq0qSJnnzySZUvXz79GF+wYEHlz59f0p/Pf2JiomJjYxUeHq7w8HBdvHhRJ0+eVGhoqO7fv2+X+rmesgzGRNYc/RqIMZA7MAaBx3NxcVH9+vVVu3Zt1apVSzVr1pSPj0+G+/C0tDRdv349fcyEhoYqJCREISEhdvlxF0c4Rmf1Wc+j5mOqU6eOOnfurPr166tGjRoqXLiwvL29lZiYqJiYGEVERCgsLEzBwcHaunWrHjx4YNGas8se9xGO8JrCPI0aNVL79u1Vv359Va1aNf1860j7d17az/bs2aPWrVunLzvDXHH2OPY4o7y0HyMjZ7i3cbbPdjjuAEDu5+LioiZNmqh69er8PS2AbDPnb7yd4f4bgH3wvRIAAAAAAAAAAAAAAADkVsNWSYVL2rsKIGtze0pJ8fauAoC9MFe7Y+FvagHH1LNnT61fvz5TfN26derdu7dV+jRl3h5Tffnllxo0aFCm+MCBA7Vq1apHbluyZEndunXL4jXl1JUrV1S5cuXHrmep59WWr4+lZPVaRUREqEyZMlbr97333tPHH3+cKT5jxgy9//772cphj+c7MDBQvXr1yhT/f//v/+n77783uk1eHQ/Z1a5dOwUGBqpo0aIm57h7964uXryoixcv6vz58+n/v3DhQjVr1izT+q1atdL+/ftz3I+zHfedcXw7y3kuKzVq1ND777+vnj17qnDhwmZW+D/ffvutBg8erIcPH1osJwAAAAAAAAAAAADg8ZirHYApmKsdgDXwvRIAAAAAllKgQAGdPn1aVapUSY+lpKRo/vz5mjt3rq5duyZJatiwoY4fPy5JmjVrlt59911JUtu2bTV58mQ9++yzGfIeP35czZo1s+jvK7do0UJ79+6Vm5tbprYlS5Zo+PDhFuvLGv2OGDFCCxcuzBCLiIjQ+PHjtXr16iyfqzJlymj8+PF64403MrxfNH/+fI0ePToHjwQA8CidOndSmzZt7F0G8pifNv+kPXv22LsMALAJzrWwl+/Xf68jR47YuwwAsIn2I6UGXe1dBfKa7fOlk5vtXQUA2BZztTsW/qYWcBymzCFbp04dde7cWfXr11eNGjVUuHBheXt7KzExUTExMYqIiFBYWJiCg4O1detWPXjwwFrlO4z8+fOrffv28vf3V7169eTr66siRYrI29tbDx8+VExMjO7evaszZ84oNDRU27dv19WrV+1Sq6urq1q2bKkWLVroqaeeUqVKldJrjY+P1/3793X9+nWdPHlS+/fv1549e5SWlmaXWv9Svnx5dejQQa1bt9ZTTz2l4sWLKyUlRdHR0bp9+7ZOnDihQ4cOacuWLUpKSrJrrZJUunRptW7dWs2aNVO1atVUvnx5eXt7q0CBAkpLS1NMTIyio6P166+/KiQkRLt379a5c+fsUquXl5fKlCmjokWLqlixYvLw8DC6XkJCgkN9RupMY86R7dmzR61bt05fdtTvRTrS653T86YznDMbN26sFi1aqFGjRqpYsaJKliwpLy8vubu7KykpSffv31d0dLTOnz+vM2fOaNeuXdxHwepcXV2VmppqtK1WrVp2O28+zt+vWcqWLasSJUrY9bolNx6zrK1Ro0Zq37696tevr6pVq6afb/LSc+DsHOm6IbcoWLCgWrVqpXr16qlmzZqqWrWqChUqJG9vb3l5eclgMCguLk6xsbG6f/++Ll26lP6+66FDhyz63RTAmrguhrnYh0zHc2d5jnZvkh15bT9wlOtWZ/yMyBlrzg5H2Secha0/23DG4yqc9zMwyXHPi7xHAAC5B3O1AzBFdv7G290GdQAAAAAAAAAAAAAAAAAAAAAAAABwAOfPn9f58+e1fPlye5eSIxEREVqzZo3WrFlj71LggI4dO6Zjx47ZuwyYKD4+Xlu2bNGWLVvsXYpNOPrxLDExUUFBQQoKCrJ3KYDNFC5cOMu2u3fv2rAS8zx48EC//fabTfvkmPE/KSkpOnnypE6ePGnvUkzC9ZRlMCay5ujXQIyB3IExCDyewWDQiRMndOLECXuXkm3Oeow+ffq0Tp8+be8yHsse9xHO+prif44fP67jx4/bu4xHykv7mZubW/r/Z/XDcY7GHsceZ5SX9mNk5Az3Ns722Q7HHQAAAAAAAAAAAAAAAAAAAAAAAAAAAACAMQaDwWg8OjrapnPn3blzx2Z9Oaus5lZxd3e3ar8eHh5G45aY68XDw0PJyclm5zHG09PTaPxRdTMestapUycFBQVlmO8nK3Fxcbpw4YIuXLigixcvZvjvvXv3jG6TmJho6ZKdSm4c347uwoULGjx4sIYOHarWrVurSZMmatSokWrWrKkqVaooX758JuV96aWXVKhQIXXr1s3CFQMAAAAAAAAAAAAAAAAAAAAAACAveeedd1SlSpX05djYWHXp0kUHDhzI1va7du3Srl27NGLECC1YsEAuLi6SpEaNGmnSpEmaNGmSRer08fHRmjVrsvXdM0uyVL/ly5fXrFmzMsSOHj2qbt266datW4/c9ubNmxo1apS2bt2qdevWKX/+/JKkUaNGadOmTdq5c6dZtQEAAAAAAAAAAAAAANjD6dOndfr0aXuX4VASExMVFBSkoKAge5fyWGlpadq7d6/27t1r71Ky7fr16/riiy/0xRdf2LuUbImIiNCaNWtsOm+5qR48eKDffvvN3mXkmDONOUf297+vc+R5x5359XaGc+axY8d07Ngxe5cBZFC4cOEs2+7evWvDSnLG2a5Z/skZjlnWdvz4cR0/ftzeZcAMznzd4Kji4+O1ZcsWbdmyxd6lAFbFdTHMxT5kOp47y3PGe5O8th8483WrM947OkPNzrxP2IOtP9twxuMqnPczMMlxz4u8RwAAAIDHcbd3AQAAAAAAAAAAAAAAAAAAAAAAAAAAAABgD35+fkbjycnJunXrlo2rAQAAAAAAyL6iRYum///9+/ftVwgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgZBITE43G4+LiNHz4cBtXg0eJi4szGv/7/CvWULx4caNxS8z1UqRIEUVFRZmdx5isnpesnkeJ8ZCVSpUq6ZtvvpGbm5vR9jt37mj9+vXasWOHjh49qqtXr+a4DxcXF3PLdGq5cXw7i6SkJG3fvl3bt29Pj7m4uKhcuXKqVq2aqlWrpurVq6f/f7Vq1VSgQIFH5uzatavGjx+v6dOnW7t8AAAAAAAAAAAAAAAAAAAAAAAA5FJDhgzJsDxq1CgdOHAgx3kWLVqktLQ0LV68OD329ttva/78+YqMjDS7zq+++kq+vr7py3PmzNGYMWPMzmurfgMCAjJ8X+jatWvq3Llzjr77uHnzZr366qv6+uuvM+TduXNnjusBAAAAAAAAAAAAAAAAAMAS/j7HeV6adxyA4/Pz8zMaT05O1q1bt2xcDQAAAAAAAAAAAAAAeBxXexcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPbg7+9vNP7rr7/auBIAAAAAAIDs8/b2zvCDcREREXasBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAu8fHxMhgMmeLFixe3QzV4lIcPHyolJSVT3N3dXV5eXlbrt1ixYkbjsbGxZucuWrSo2TlymjsuLi7LbRgPxk2fPt3o8xkXF6dRo0apbNmyGjp0qNatW6erV6+a1Ie3t7eZVTq33Di+nZnBYND169e1Z88eff7553rvvffUs2dP1atXT15eXvLz89Obb76pc+fOZZnj/fffz/PHDgAAAAAAAAAAAAAAAAAAAAAAAJimfPnyqlChQvpyZGSkVq9ebXK+JUuW6Oeff5YkHT16VK+99pru3r1rdp3jxo1Thw4d0pc//fRTbdy40ey8turX09NTL730UobYu+++q6ioqBzn+uabb7R79+705datW+upp57KcR4AAAAAAAAAAAAAAAAAAMzl7e0tPz+/9OWIiAg7VgMAGfn7+xuN//rrrzauBAAAAAAAAAAAAAAAZIervQsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHto166d0fjx48dtXAkAAAAAAED2ffrpp/L09ExfDg4OtmM1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgHNJTU1VZGRkpnjBggWVP39+O1SERwkPDzcaL126tNX6zCp3RESE2blLlSpldo6c5o6KispyG8ZDZpUqVdKLL76YKf7w4UO1a9dOCxYsUFJSktn9+Pj4mJ3D2eW28Z1bGQwGXbhwQZ999plq166tDz/80Oh63t7eeu2112xcHQAAAAAAAAAAAAAAAAAAAAAAAHIDX1/fDMunT59WWlqaWTmHDh2qZ555Rv7+/lqzZo1SU1PNyteiRQtNnTo1ffnnn3/WuHHjzMpp636bNWumwoULpy9HRkYqMDDQ5NoWLlyYYblbt24m5wIAAAAAAAAAAAAAAAAAwFSffvqpPD0905eDg4PtWA0AZNSuXTuj8ePHj9u4EgAAAAAAAAAAAAAAkB2u9i4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB7Fy8vL4jl9fX3VpUsXo23btm2zeH8AAAAAAADmcnd315IlS/T6669niK9cudI+BQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABO6tq1a0bjderUsXEleJyzZ88ajTdt2tRqffr7+xuNnzlzxuzcjRs3NjuHMb6+vipVqlSmeHJysn7//fdHbst4yKhz585ydXXNFF+0aJF++eUXi/Th6uqqkiVLWiSXM8tt4zsvMBgM+uCDD7Ro0SKj7R06dLBxRQAAAAAAAAAAAAAAAAAAAAAAAMgNPDw8MiwnJiaanTMsLEyHDx82O48k+fj4aM2aNXJzc5Mk3b17V3369FFKSopF8tuq33r16mVY3rNnjwwGg8n17d69O8NyixYtTM4FAAAAAAAAAAAAAAAAAEBOubu7a8mSJXr99dczxFeuXGmfggA4NS8vL4vn9PX1VZcuXYy2bdu2zeL9AQAAAAAAAAAAAAAA87nauwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMMbV1VWTJk3SxYsXVbJkSYvmHjdunNzc3DLFExMTtXXrVov2BQAAAAAAYK5SpUpp9+7dGjp0aIb4t99+q71799qnKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBJnTp1ymi8adOmNq4Ej3P69Gmj8RYtWlilPz8/Pz3xxBOZ4g8fPtSlS5fMzt+8eXOzcxjTrFkzo/FLly4pLS3tkdsyHjJq2bKl0fiaNWss1kejRo1UoEABi+VzVrltfOclkyZNUkpKSqZ4kyZN7FANAAAAAAAAAAAAAAAAAAAAAAAAnN29e/cyLJcsWdJOlRj31VdfydfXV5JkMBg0YMAAXb9+3en6/efzau5jiI6OVnx8fPqyv7+/WfkAAAAAAAAAAAAAAAAAAMiuUqVKaffu3Ro6dGiG+Lfffqu9e/fapygATsnV1VWTJk3SxYsXLf53zOPGjZObm1umeGJiorZu3WrRvgAAAAAAAAAAAAAAgGW42rsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPin8uXLa9++ffrwww9VpkwZff/998qfP79Fcrdt21ZvvPGG0bbvvvtO0dHRFukHAAAAAADAEnx9fXXixAk9++yzGeJbt27VK6+8YqeqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4Izc3NzsXYJDCA4ONhpv3bq1bQvBY+3YscNovGvXrlbZn3v06GE0vm/fPqWmppqdv02bNvL09DQ7zz917tzZaPzgwYOP3ZbxkFGZMmWMxs+dO2exPtq0aWOxXI/jyMf93Da+85I7d+7o5MmTmeKFChWyyjEOAAAAAAAAAAAAAAAAAAAAAAAAuVt4eLgMBkP68lNPPaXixYvbsaL/GTdunDp06JC+/Omnn2rz5s1O2W+BAgUyLMfFxZmVT5JiY2PT/79YsWJyd3c3OycAAAAAAAAAAAAAAAAAAI/i6+urEydO6Nlnn80Q37p1q1555RU7VQXAGZUvX1779u3Thx9+qDJlyuj7779X/vz5LZK7bdu2euONN4y2fffdd4qOjrZIPwAAAAAAAAAAAAAAwLJc7V0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPzdCy+8oLCwMLVo0SI99swzz2j79u3y8fExK3ebNm20fv16ubi4ZGpLSUnRtGnTzMoPAAAAAABgaeHh4Tpy5EiG2BdffKHnn39eiYmJdqoKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjuzBgwdG44UKFbJxJY5p+/btRuPPP/+8SpQoYeNq8Cj79u0zuj+XL19evXr1smhfHh4eGj16tNG2TZs2WaSPEiVKqG/fvhbJ9RcfHx/9+9//Ntq2devWx27PeMioWLFiRuOWmu/H1dVVQ4YMsUiuv3PG435uG9+OqnTp0lbJ+8cffxiNFy1a1Cr9AQAAAAAAAAAAAAAAAAAAAAAAIPe6d++ezpw5k77s7u6uKVOm2LGiP7Vo0UJTp05NXz5y5IjGjRvntP0mJSVlWPb29jY75z+/w8b3iwAAAAAAAAAAAAAAAAAA1hYeHq4jR45kiH3xxRd6/vnnLTanPIDc74UXXlBYWJhatGiRHnvmmWe0fft2+fj4mJW7TZs2Wr9+vVxcXDK1paSkaNq0aWblBwAAAAAAAAAAAAAA1uNq7wIAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4O9q1KihokWLZoo/++yzOnPmjAYPHiwPD48c5SxevLimT5+urVu3qkiRIkbXmTdvni5evGhKyQAAAAAAAFY1aNAgXbx4UYmJiRo2bJiGDBmi5ORke5cFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB3Xv3j2j8YoVK9q4Esd0+fJlnTp1KlPc09NTQ4YMsWhfRYoUUenSpS2aMy9JSkrSd999Z7QtICAgx/PUPsrrr7+usmXLZoo/fPhQgYGBFuvnP//5j9zc3CyW7+2331b+/PkzxR88eKDt27c/dnvGQ0axsbFG4yVKlLBI/pdeeklVq1a1SK6/c8bjfm4c346kXLlyWrx4sa5evaru3btbPL+np6fReEJCgsX7AgAAAAAAAAAAAAAAAAAAAAAAQO63cuXKDMtvvPGG/u///s+i38fLCR8fH61Zsya9/7t376pPnz5KTU112n7/+T20cuXKmZWvaNGiKliwYKYYAAAAAAAAAAAAAAAAAADWNmjQIF28eFGJiYkaNmyYhgwZouTkZHuXBcCJ1KhRw+jfvj777LM6c+aMBg8enOPfTChevLimT5+urVu3qkiRIkbXmTdvni5evGhKyQAAAAAAAAAAAAAAwAZc7V0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPzdrFmz9MsvvxhtK1mypFasWKEbN25o+fLlGjhwoJo3b67y5curePHi8vLyUpEiRVS5cmU1btxYQ4YM0bfffqsrV67o/fffz3JC9hMnTmj8+PHWfFgAAAAAAAAmi42NVY8ePeTv76+lS5fauxwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4uPDwcKPx6tWrq1SpUjauxjF9/vnnRuMBAQGqXr26xfqZM2eOzp8/r9GjR8vV1dViefOSWbNmyWAwZIrXrVtXc+fOtUgfDRo00KxZs4y2rVq1Srdv37ZIP9Kfdc+cOdMiuVq1aqX33nvPaNvq1asVGxubrTyMh/+JiooyGm/evLnZuX19fTVnzhyz8xjjrMf93Da+HUG5cuW0aNEiXbp0ScOGDZOnp6c+++wzFS9e3KL9VKtWLVMsPj4+28cdAAAAAAAAAAAAAAAAAAAAAAAA4O+WLFmi33//PUNswoQJOnPmjEaPHq2qVavatJ6vvvpKvr6+kiSDwaD+/fvrxo0bTt3vuXPnMiy3bt3arHxt2rTJFHPU7w4CAAAAAAAAAAAAAAAAAHKX2NhY9ejRQ/7+/lq6dKm9ywHghGbNmqVffvnFaFvJkiW1YsUK3bhxQ8uXL9fAgQPVvHlzlS9fXsWLF5eXl5eKFCmiypUrq3HjxhoyZIi+/fZbXblyRe+//748PDyM5j1x4oTGjx9vzYcFAAAAAAAAAAAAAADMxExaAAAAAAAAAAAAAAAAAAAAAAAAAAAAABxKamqqunbtqosXL2a5TsmSJfXKK69o5cqVOnz4sK5du6Y7d+4oLi5O0dHRunz5so4ePaply5apb9++KlSoUJa5Ll++rM6dOyspKckaDwcAAAAAAMAizp49q1OnTtm7DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADiB8PBw3bhxw2jbiBEjbFyNY1q+fLkiIyMzxQsWLKivv/5aXl5eZvfx2muvafDgwSpcuLDmzZunkJAQNW/e3Oy8ec25c+e0du1ao20jRozQmDFjzMpfvXp1bdiwQfnz58/UlpiYqBkzZpiV35gxY8ZoyJAhZuV48skntWbNGrm5uWVqS0lJ0dy5c7Odi/HwPxcuXDAaHzp0qFl5CxYsqHXr1qlEiRJm5cmKsx73c+P4trclS5Zo+PDh8vT0TI9VqFBBgYGBKlCggEX68Pf3V7Vq1TLFs9oHAQAAAAAAAAAAAAAAAAAAAAAAgMd58OCBevbsqejo6AxxPz8/zZs3T7/99pvu3LmjL7/8Mr2tTJkyKl26tMVrGTdunDp06JC+PHPmTP30008W78fW/R46dEgpKSnpy6VKldILL7xgcr433njDEmUBAAAAAAAAAAAAAAAAAGCSs2fP6tSpU/YuA4CTSk1NVdeuXXXx4sUs1ylZsqReeeUVrVy5UocPH9a1a9d0584dxcXFKTo6WpcvX9bRo0e1bNky9e3bV4UKFcoy1+XLl9W5c2clJSVZ4+EAAAAAAAAAAAAAAAALcbV3AQAAAAAAAAAAAAAAAAAAAAAAAAAAAADwT1FRUWrZsqUOHz5s1X6OHTump59+WhEREVbtBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALClvXv3Go2PGzdOLVu2tG0xDig+Pl6TJ0822takSRPt379fJUuWNDn/6NGjtXTp0gyxp556SocOHVKHDh1MzptXvfnmm4qJiTHaNnv2bC1ZskSenp45ztu+fXsFBwerYsWKRts//PBDXb58Ocd5s2PZsmWaPXu23Nzccrxtly5d9PPPP6t06dJG2xcsWKDz589nOx/j4X+2bdtmNN6+fXu9+uqrJuUsW7asDh48qGbNmqXHQkJCTMr1KM563M+N49ueJk6cKIPBkCnepk0b7dq1S+XLlzcrf9GiRbV8+XKjbVu2bDErNwAAAAAAAAAAAAAAAAAAAAAAAPK2kydPqmnTpgoLCzPaXrx4cdWrVy99+eWXX9bNmzcVExOjPXv2aMaMGXr66afNqqFFixaaOnVq+vLhw4c1fvx4s3I6Sr/R0dGZvkM3a9YsFS1aNMe5+vbtqzZt2lioMgAAAAAAAAAAAAAAAAAAAMD2oqKi1LJlSx0+fNiq/Rw7dkxPP/20IiIirNoPAAAAAAAAAAAAAAAwn6u9CwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYyIiItS6dWtNnjxZ8fHxFs398OFDTZ8+Xc2bN9etW7csmhsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwtyVLlhiNe3p6aufOnZoxY4YqVqxo46ocy+LFi7Vv3z6jbQ0bNtTp06c1YsQIubu7Zztn3bp1tWXLFs2bN0+urq6Z2o8ePaodO3aYXHNedevWLQ0bNizL9qFDh+rChQvq169ftl6v2rVra8OGDdq+fbuKFi1qdJ2DBw9q5syZppZsVEhISIblMWPG6OzZs+rVq5dcXFweu33dunW1adMm/fjjjypcuLDRda5cuaJJkybluDbGw58OHDigqKgoo23Lli3TxIkTs/0ceHp6avTo0QoNDVWDBg3S49HR0Sa9Ro/jrMf93DK+HcWJEye0ePFio23NmzfX2bNnNXHiRPn4+OQ4d4cOHRQcHKw6deoYbQ8MDMxxTgAAAAAAAAAAAAAAAAAAAAAAAODvLly4oPr162vgwIE6fPhwtrYpXLiwWrdurbFjx+rQoUO6dOmS+vXrl+O+fXx8tGbNGrm5uUmS7ty5oxdffFGpqak5zuWo/U6bNi3DcpUqVRQUFKTixYtnO0eHDh305ZdfWro0AAAAAAAAAAAAAAAAAAAAwOYiIiLUunVrTZ48WfHx8RbN/fDhQ02fPl3NmzfXrVu3LJobAAAAAAAAAAAAAABYh7u9CwAAAAAAAAAAAAAAAAAAAAAAAAAAAACArCQnJ2vKlCn64osvNGLECA0ePFhly5Y1OV9MTIxWrlyp2bNn69q1axasFAAAAAAAAAAAAAAAAAAAAAAAAAAAOLL69evrwIEDkqTPPvtMAQEBdq4IAAAAAAAAAAAAsK5Dhw7p4MGDatGiRaY2Dw8PjR07VmPHjlV4eLiuXbum2NhYpaWlZVr31q1bGjRokA0qto8+ffro6NGjqlChQqa2EiVKaOHChZo0aZK2bNminTt36vr167p9+7bi4+Pl6empQoUKqUKFCqpXr546d+6sZs2aZdnXzZs31bt3b6PPMx5vzZo1qlOnTpaf91asWFGrV6/WggULtG3bNgUHBysiIkJ37tyRl5eXSpUqperVq6tTp07y8/N7ZF+XL19Wjx49lJqaatHHMHjwYAUHBytfvnzpsRo1aigwMFBRUVHaunWrjh8/roiICN27d0+FChVKr7tjx46PrTshIUE9evRQbGysSfUxHqSHDx9q2rRpmjNnTqY2V1dXTZkyRcOGDdPq1au1f/9+nT9/XtHR0UpMTFSRIkVUsmRJVatWTR06dFCXLl1UpkyZDDkMBoMGDhyoyMhIi9fuzMf93DC+HcmYMWPk7++vxo0bZ2rz9vbWlClTNHHiRB0+fFh79+7VuXPndOXKFcXGxio+Pl4uLi7y8vJS0aJFVbVqVTVo0ECdO3dW9erVs+wzKChIhw4dsubDAgAAAAAAAAAAAAAAAAAAAAAAQB5hMBi0atUqrVq1Sr6+vmrWrJmaNm2qevXq6amnnlLp0qUfuX2VKlW0evVqDRgwQL169dL9+/ez1e9XX30lX1/f9Br69++vGzdumP14HKnfI0eO6PPPP9eQIUPSYy1atNCJEyf07rvvKjAwUAaDwei2Pj4+GjdunMaMGSNXV1clJycrMjJSZcuWtUqtAAAAAAAAAAAAAAAAAAAAgC0kJydrypQp+uKLLzRixAgNHjzYrL+RjYmJ0cqVKzV79mxdu3bNgpUCAAAAAAAAAAAAAABrc7d3AQAAAAAAAAAAAAAAAAAAAAAAAAAAAADwOH/88YcmTJigSZMmqWHDhmrdurWaNGmiKlWqqFKlSipcuLA8PT0zbJOQkKDw8HBdunRJx48f1549e7Rv3z4lJyfb6VEAAAAAcCYuLi72LgEAAAAAAAAAAAAAAAAAAACABbm6usrb21uSMn0nEQAAAAAAAAAAAMitBgwYoNDQUBUqVCjLdXx9feXr65tl+5UrV6xQmeO4ffu22rVrp927d6tcuXJG1ylVqpQGDRqkQYMGmdzPrVu31KFDB127ds3kHJAmTJggFxcXjR8/Pst1ihQpoj59+qhPnz4m9XH27Fl17NhRd+7cMbXMLIWFhal///767rvvMs115ePjo379+qlfv34m5U5ISFDPnj0VGhpqcn2Mhz8tWrRIAwYMUIMGDYy2ly1bVmPHjtXYsWNznHvs2LHatGmT/P39zS3TKGc+7jv7+HYkSUlJ6tSpk7Zt26aGDRsaXcfDw0OtWrVSq1atzO4vKipKw4cPNzsPAAAAAAAAAAAAAAAAAAAAAAAA8E/h4eFav3691q9fL0lq2LChjh8/Lknas2ePjh8/rnr16qlp06YqUqRIhm3bt2+vXbt26ZlnnlFSUtIj+xk3bpw6dOiQvvzJJ59oy5YtFn40jtHvqFGjVKtWLT3zzDPpsQoVKui7777T3LlztWvXLp0/f153796Vp6enSpUqpSZNmuiZZ55R/vz5M9T+/PPPq2zZsukxg8Fg1doBAAAAAAAAAAAAAAAe5Z/zPgMAgKxx3gQy++OPPzRhwgRNmjRJDRs2VOvWrdWkSRNVqVJFlSpVUuHCheXp6Zlhm4SEBIWHh+vSpUs6fvy49uzZo3379ik5OdlOjyJ34pgFAAAAAHgUZ7xvdMaaAQAAAADIK9ztXQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZFdaWpqOHTumY8eOZWpzc3NTvnz5ZDAYlJiYKIPBYIcKAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMfw+++/q2fPnlq3bp2KFCli73Ic1sWLF9W8eXOtX79e/v7+Fs8fEhKi7t2768aNGxbPnRcFBATo8uXLmjdvnry8vCyae/PmzerXr5+io6MtmvfvAgMD5eLiov/+97/Knz+/RXLeunVLvXr10sGDB83OxXiQkpKS1KlTJx05ckSVK1e2SM7k5GSNHDlSy5Yts0i+rDj7cd/Zx7cjiYqKUuvWrbVq1Sr16NHDav3cuHFD7dq1U3h4uNX6AAAAAAAAAAAAAAAAAAAAAAAAAIw5fvy43n33XUmSu7u7OnbsqEmTJqlJkybp6zRu3FjTp0/Xf/7znyzztGjRQlOnTk1fPnTokAICAqxXuJ37ffjwoTp06KBvvvlGzz//fIa2MmXKqF+/fo/c3mAwKCAgQLNnz1bfvn0ztMXFxVm8XgAAAAAAAAAAAAAAAAAAAMCW0tLSdOzYMR07dixTm5ubm/LlyyeDwaDExEQZDAY7VAgAAAAAAAAAAAAAAKzF1d4FAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAlpKamKj4+XgkJCUyqDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEjauXOn/P39deDAAXuX4tBu3LihFi1aKCAgQPHx8RbJGR8fr7Fjx8rf3183btywSE78afny5apbt662bt1qkXw3b95U//791bVrV0VHR1sk56OsXbtWzZo108mTJ83OFRgYqNq1a+vgwYPmF/b/YzxIt27dUtOmTbV582azc4WFhcnf31/Lli2zQGWP5+zHfWcf344kNjZWL7zwgnr37q1r165ZNLfBYNBXX32lJk2a6Pz58xbNDQAAAAAAAAAAAAAAAAAAAAAAAORUSkqKfvzxRzVr1kxLlizJ0PbGG2+oZMmSRrd74okntGbNGrm5uUmSoqKi9OKLLyo1NdWq9dqr3788ePBA3bt318CBA3P03aOTJ0+qVatW+uijjyRJ3t7eGdpjYmIsWicAAAAAAAAAAAAAAAAAAADgSFJTUxUfH6+EhAQZDAZ7lwMAAAAAAAAAAAAAACzM1d4FAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIA56tevr9jYWMXGxmratGn2LgcAAAAAAABwKBcuXFDLli3VtGlTLV26VGFhYUpLS7N3WQ4nOTlZ06dPV+XKlTVt2jTduHHDpDzXr1/XpEmTVL58eX3yySdKTU21cKWQpN9//12dOnVSkyZNtHbtWsXHx+c4x8mTJzV06FBVqlRJX331lRWqzFpoaKgaN26sgQMH6ty5cznaNjExUYGBgWrYsKH69OmjO3fuWLw+xoMUGRmprl27qnfv3jp48GCOtw8JCVHfvn1Vv359nTx50vIFPoKzH/edfXw7mnXr1qly5crq3bu3du7cqYcPH5qc6969e1qxYoWaNm2q/v37KyIiwoKVAgAAAAAAAAAAAAAAAAAAAAAAAOZJS0vTG2+8oePHj6fH8ufPr549expd/+uvv5avr68kyWAwqH///goPD7d6nfbq959WrVqlKlWq6Pnnn9fy5ct14sQJ3bt3T6mpqUpOTlZUVJR++eUXzZs3Ty1btlSDBg104MCB9O2LFCmS/v9paWkmfRcMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcATu9i4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACypQYMG6tWrl+rVq6cqVaqoUqVK6W0jR45Ut27ddOnSJR0+fFhbtmxRSEhIjvtwd3fXK6+8YrGaExIStHr1apO2bdWqlfz8/B65TmhoqH755ReT8jtavwAAGOPq6ipvb29Jkqenp52rAQAAAAAAABxTcHCwgoODJUleXl4qU6aMihYtqmLFisnDw8PoNgkJCdnK7eLiYrE6H2fw4MEaPHiw1fLfvn1bEyZM0IQJE9S4cWO1aNFCjRo1UsWKFVWyZEl5eXnJ3d1dSUlJun//vqKjo3X+/HmdOXNGu3btUlhYmMVqsdTzasvXx9aOHTumF198Ufnz51f79u3l7++vevXqydfXV0WKFJG3t7cePnyomJgY3b17V2fOnFFoaKi2b9+uq1ev2rX21NRUrVq1SqtWrVKdOnXUuXNn1a9fXzVq1FDhwoXl7e2txMRExcTEKCIiQmFhYQoODtbWrVv14MEDm9SYG8dDTq1bt07r1q2Tn5+fWrRooebNm6tatWoZjp+xsbGKjo7WuXPndOLECW3evFm//fZbljmDg4Nt8nic/bjvSOPb2c9zaWlp6ftywYIF1apVK9WrV081a9ZU1apVVahQIXl7e8vLy0sGg0FxcXGKjY3V/fv3denSJYWFhSksLEyHDh1SSkqKRWsDAAAAAAAAAAAAAAAAAAAAAAAALCktLU1z587NMM9rq1attGTJkgzrjRs3Th06dEhf3rZtm+Lj49WyZcts91W/fv0My2XLls20fVhYmKKjo+3eb1ZSU1MVFBSkoKCgbPcvSQUKFFCZMmXSl2/dupWj7QEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABH4m7vAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAXO7u7ho2bJjeeustVa1aNcv18ufPLz8/P/n5+alz586aOnWqwsLC9MEHH2jDhg3Z7q9YsWJaunSpJUqXJEVERGj16tUmbTt+/Hg999xzj1xn1qxZ+uWXX0zK72j9AgAAAAAAAAAAwHwPHjzQb7/9Zu8yHN6xY8d07Ngxe5eBbEhMTFRQUJCCgoLsXYpJTp8+rdOnT9u7jEfK6+Ph/PnzOn/+vJYvX27vUkzizMd9Zx/fjiY+Pl5btmzRli1b7F0KAAAAAAAAAAAAAAAAAAAAAAAAYBWHDx/OsFyuXLlM60ydOjXDcseOHdWxY0ez+n3++ef1/PPPZ4g1aNBAJ0+etHu/llazZk25uLikL1uzLwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDaXO1dAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYo1q1ajp69Kjmz5+vqlWr5nj7evXq6fvvv9ePP/6oYsWKZWsbb2/vHPdjLdWrV89T/QIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAMVFRURmWixcvnmkdNzc3m9Ty+++/O0S/lvb0009nWD5x4oRV+wMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACsydXeBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAqWrVqqUjR46ofv36GeIGg0GnTp3S6tWrtWrVqvR4aGiodu3apZiYmEy5unTpoiNHjqhkyZKP7dfLy8vs2i3B3d1dFSpUyDP9AgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMhd2rVrp1atWlkkV758+TIsJyYmWiRvTt29e9foHLi5od+ePXtmWD5y5IhV+wMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACsyd3eBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAKQoUKKCgoCD5+Pikx1JSUjR//nzNnTtX165dkyQ1bNhQAwYMkCTt2LFD7777riSpbdu2mjx5sp599tn07f38/PTTTz+pWbNmSklJybJvb2/vDMvvvfeedu3aZfJjeVRfj5KamqqyZctmin/wwQcaPny4yfU4ar8AAPylQYMG6tWrl+rVq6cqVaqoUqVK6W0jR45Ut27ddOnSJR0+fFhbtmxRSEhIjvtwd3fXK6+8YrGaExIStHr1apO2feKJJ9S7d2+1bdtWderUka+vr7y8vCRJDx48UHh4uE6dOqVdu3Zp3bp1unPnjkVqrlGjhl544QW1atVKtWvXlo+PjwoWLKgHDx4oMjJSN2/e1P79+7V161bt379faWlpFukXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQO737LPPatq0aXr22Wd14sQJNWrUSAaDwayc1atXz7B88+bNTOv4+fmZ1Yck+fv7Z5hf7rvvvtOkSZPSl5OTkx2mX0uqXLmyWrZsmb58584dbdu2zap9AgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANbkbu8CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAU77zzjqpUqZK+HBsbqy5duujAgQPZ2n7Xrl3atWuXRowYoQULFsjFxUWS1KhRI02aNEmTJk3Kcltvb+8My2fOnFFISIgJj8I8BoNBt2/fzhR/8OBBruwXAJC3ubu7a9iwYXrrrbdUtWrVLNfLnz+//Pz85Ofnp86dO2vq1KkKCwvTBx98oA0bNmS7v2LFimnp0qWWKF2SFBERodWrV+dom2LFimnatGl69dVX5enpaXSdQoUKqWbNmqpZs6Z69+6tefPm6YsvvtCECRMUHR1tUq21atXSzJkz1alTp/RrpL/z8vKSl5eXKlWqpObNm2vs2LH69ddfNX78+Bw9xwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADyJk9PT61fv14lSpSQJDVo0EBjxozR7Nmzzcr773//O8PyyZMnM61z4cIFs/qQpNKlS2dYvnfv3mPz2qvfv8ufP7969uwpDw8P/fe//81x/9OnT5e7u3v68rfffqvk5OQc5wEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAchfvjVwEAAAAAAAAAAAAAAAAAAAAAAAAA2IKrq6uKFSumokWLys3Nzeg6Fy5csHFVAAAAjulx107WvG7iug0AAAAA8HfcJwIAAAAAAAAAAAAAAAAAYF9DhgzJsDxq1CgdOHAgx3kWLVqktLQ0LV68OD329ttva/78+YqMjDS6jZeXV4blhISEHPcLAACyr1q1agoMDFT9+vVN2r5evXr6/vvvtXnzZvXv31/37t177Dbe3t4m9WUpzZs31/fff6/SpUvnaLt8+fLpjTfe0AsvvKAePXro6NGjOdr+P//5jz766CO5u7vnaLuaNWvq+++/15o1azRw4EAlJSXlaHsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeUdSUpJmzZqljz/+OD32ySef6PLly9q4caNJOVu0aKGhQ4dmiH3//ffmlJlreHp66rPPPlPfvn1VpEgRxcbGat++fbpy5Uq2cwwaNEh9+/ZNX05KStJnn31mhWoBAAAAAAAAAAAAAABsx9XVVcWKFVPRokXl5uZmdJ0LFy7YuCoAAAAAAAAAtsT7hAAAAAAAAAAAd3sXAAAAAAAAAAAAAAAAAAAAAAAAAAB5Vc2aNdWtWze1atVKzZo1U/HixeXi4vLIbdzc3JSWlmajCgEAMN3ChQvVsGHDTPHhw4fr5MmTti8ITi+n106WvG7iug0AAMA5HTlyxGi8efPmNq4EQG7DfSIAAAAAAAAAAAAAAAAAAI6jfPnyqlChQvpyZGSkVq9ebXK+JUuWaODAgWrWrJmOHj2q2bNn6+7du1mu7+3tnWE5ISHB5L4BAMCj1apVS/v27ZOPj0+GuMFg0OnTp3Xy5EkZDAYNGDBAkhQaGqqoqCg1btxYRYoUybBNly5ddOTIEbVs2VK3b99+ZL9eXl6WfSA50KpVK23dulX58+fP1HblyhWdPXtWERERkqTSpUurVq1aqlSpUob1ypYtq71796pdu3ZZfufqn+bMmaO33norU/zevXvat2+fzp8/r7t378rDw0MlS5ZU48aN5e/vL3d39/R1+/btq9KlS6tDhw5KSkrK/oMGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkKfMmTNHL730kurXry/pz9+FX79+vT788EPNmDEjR/OZ9e/fX4sWLcowN9qPP/6okJAQS5ftlJKSkuTn55c+R1+hQoX0008/qWPHjrp27dpjtx8xYoTmzZuXITZjxgxdvHjRKvUCAAAAAAAAAAAAAABYS82aNdWtWze1atVKzZo1U/HixeXi4vLIbdzc3JSWlmajCgEAyJ6sfq+2efPmNq7EtvLq4wYAAI/HdYLj4TWBI+N9QgB/t3DhQjVs2DBTfPjw4Tp58qTtCwIAAAAAAIBduD9+FQAAAAAAAAAAAAAAAAAAAAAAAADmcHFxUaFChYy2xcbGymAw2LgiPIqtXq969erp5MmTj50MLLvYzwAAjqZWrVpq1qxZpnjhwoXtUA2cWb169fTBBx+oR48eFrt2coa+8xquZwEAgDUYuycBAHNwnwgAAAAAAAAAAAAAAAAAgOPx9fXNsHz69GmlpaWZlXPo0KHy9vbW4cOHH7uut7d3huWEhASz+gYAAMYVKFBAQUFB8vHxSY+lpKRo/vz5mjt3rq5duyZJatiwoQYMGCBJ2rFjh959911JUtu2bTV58mQ9++yz6dv7+fnpp59+UrNmzZSSkpJl3/8837/33nvatWuXyY/lUX39XalSpbRhwwblz58/QzwoKEgffPCBQkJCjG7XsGFDffjhh+ratWt6rGDBgvrhhx9Us2ZN3b1795H9jhgxQm+99VaGWEREhMaPH6/Vq1dnWX+ZMmU0fvx4vfHGG+nfu2jdurVmzZql0aNHP+7hAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMijkpOT9eKLL+rgwYMqUaKEJMnV1VUffvihXnvtNX3++ef68ccfFRoammnbfPnyqWbNmvrXv/6lV155RXXr1s3Qfvv2bY0cOdImj8NZvPXWWwoODpanp6ck6cknn9Tp06f11Vdf6auvvtLp06d1//59SZKLi4vKlCmjTp066bXXXlOzZs0y5AoLC9O0adNs/hgAAAAAAAAAAAAAAABMVa9ePX3wwQfq0aNH+u/uAQDgzP75t32OzMXFRYUKFTLaFhsbK4PBkO1czvS4HYUln38AtsG4BUzjTNcJeWWcO9NrgryD9wkBGFOrVi2j563ChQvboRoAAAAAAADYi7u9CwAAAAAAAAAAAAAAAAAAAAAAAAByu8qVK+vSpUtG2/z8/HThwgUbV4RHscXr1a9fPy1fvtyiE4OxnwEAgNzor+smT0/PPNV3XsT1LN59910VL17c7DypqalKTExUXFycbt++rfDwcJ0/f14REREWqFIqW7asRo0aZZFclnbjxg0tXLgwfblw4cIaN26c0XtPg8Ggjz76SLGxsbYsUa1bt1aHDh2Mth08eFCbN2+2aT25XcmSJVWrVi1VrVpVTzzxhLy9veXh4aHk5GTFxcXpzp07unz5ss6ePatbt27Zu1xJUqVKlVS3bl0VL15cRYsWVbFixZQvXz49fPhQ0dHRio6O1t27d3Xq1Cn9/vvv9i5XknM+zwAA03CfCAAAAAAAAAAAAAAAAACAY/Lw8MiwnJiYaHbOsLCwbK/r5eWVYTkhIcHs/gEAQGbvvPOOqlSpkr4cGxurLl266MCBA9nafteuXdq1a5dGjBihBQsWpH//slGjRpo0aZImTZqU5bbe3t4Zls+cOaOQkBATHkXOLFq0SMWKFUtfNhgMGj58uJYuXfrI7UJCQtStWzeNGDEiw3dPS5Qooblz52rAgAFZblu+fHnNmjUrQ+zo0aPq1q3bY78jd/PmTY0aNUpbt27VunXrlD9/fknSqFGjtGnTJu3cufOR2wMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADIuy5cuKC2bdtq8+bNKl++fHq8fPnymjJliqZMmaKUlBTdvXs3vW3UqFF655130ueX+6fbt2+rbdu2unr1qtXrdyahoaEaPny4vvjii/TnrlChQho+fLiGDx8u6c95duPi4lS8eHG5ubkZzfPrr7+qY8eOSkpKslntAAAAAAAAAAAAAAAA5ujXr5+WL18uT09Pe5cCM7377rsqXrx4htj58+e1cuVKm9fy5ptvqnTp0pni06dPV2xs7CO3/eijjzLFkpOTH/kbm7bQtWtXPfPMM5ni4eHhWrBgwSO3NfbaSNKaNWsUGhqa41qyymeKtLQ0xcfHKyEhQXfu3NG1a9d05coV/f777xbJn1OWfq7MMXbsWBUtWjRDzF5jCrlb5cqVdenSJaNtfn5+unDhgo0rylt4/gHnw7gFcj/GOWAfvE8IAAAAAAAAAHgUd3sXAAAAAAAAAAAAAAAAAAAAAAAAAAB5yYgRI7Rw4UJ7lwEAAODw7HndxDUbYHsjRoxQpUqVrJY/KipKhw4d0rZt27Rx40bdvHnTpDylS5fWuHHjLFydZRw7dizDsev+/fsqWLCg3nzzTaPrlytXTgMGDLBVeSpdurTWrVunJ554IlNbVFSU5s6da7Na/q5///5q06aNzfv9/PPPdfjwYYvnbdy4sQYMGKCOHTuqevXq2d7ut99+07Zt27Rq1SoFBwdbvK6sFCxYUH379lXPnj3l7++vEiVKZHvbO3fuKDg4WN9//72+/fZbPXjwwIqVZuRszzMAwHzcJwIAAAAAAAAAAAAAAAAA4Lju3buXYblkyZI27d/b2zvDckJCgk37BwAgrxgyZEiG5VGjRunAgQM5zrNo0SKlpaVp8eLF6bG3335b8+fPV2RkpNFtvLy8Mizb4nzfrl079ezZM0Ns/PjxWrp0abZzLFq0SE888YSmTJmSHuvfv78WL16sI0eOGN0mICBABQoUSF++du2aOnfurKioqGz3u3nzZr366qv6+uuvM+TduXNntnMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyHtOnTql+vXra8GCBerbt69cXFwytLu7u2eYfzZfvnxZ5lq/fr2GDx+e5Txzed2KFSv04MEDLV26VEWKFMnUXqBAgQxz0/3Thg0b9Oqrr2aaHxgAAAAAAAAAAAAAAMBRjRgxQgsXLrR3GbCQESNGqFKlShliBoNB165d0+7du21ay2uvvaY6depkis+fP1+xsbGP3HbcuHFG4zt37tT+/fstUp8pPv30U9WoUSNT/O+/j5kVY6+N9Offh4WGhua4lqzyWVJMTIyOHTum3bt3a+PGjTp79qxV+/uLpZ8rUzVo0EAzZszIFI+Pj9eGDRsUExNjs1oAAAAAALA23icEAAAAAAAAADyOu70LAAAAAAAAAAAAAAAAAAAAAAAAAIC8on79+pozZ85j14uPj1dSUpINKgIAAHBM2b1ukix/7WTPvgFYj4+Pj7p3767u3btrwYIF2rx5s2bOnKkDBw7YuzSreu+999S2bVujPzrWv39//fjjj1q7dq1Navnvf/+rJ554wmjbK6+8olu3btmkjn9q166dBgwYYPN+9+zZo8OHD1ssX4cOHTRlyhT5+/ubtH21atVUrVo1vfHGGzp69KgmTZqkrVu3Wqy+fypRooQmT56s/v37q3DhwibleOKJJ9SpUyd16tRJs2fP1tdff63Jkyfr9u3bFq72f5zteQYAWAb3iQAAAAAAAAAAAAAAAAAAOLbw8HAZDAa5uLhIkp566ikVL15cd+/etUn/3t7eGZYTEhJs0i8AAHlJ+fLlVaFChfTlyMhIrV692uR8S5Ys0cCBA9WsWTMdPXpUs2fPfuS1gz3O98OGDcuwHBoaqo8//jjHeaZNm6Y+ffpk+K7p0KFDdeTIkUzrenp66qWXXsoQe/fddxUVFZXjfr/55hu9+uqratOmjSSpdevWeuqppxQaGprjXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADyjrt37+rf//63ZsyYoeHDh6tXr17y8fHJ1ra3b9/Wjz/+qPnz5+vkyZPWLTQX+O6777R//369++67GjBggJ544olHrp+WlqadO3dq5syZ2rlzp42qBAAAAAAAAAAAAAAAMF/9+vU1Z86cbK0bHx+vpKQkK1cEa3BxcdGqVatUt25d3bt3z97lZEtqaqrc3NwyxQcOHKj9+/fboSLJ399fNWrUyBQ3GAz68ssv7VCR9RUpUkRt27ZV27ZtNW3aNJ09e1afffaZVq1alSd+s/yfv6H6l4IFC6pfv35auHChjSsCAAAAAMA6eJ8QAAAAAAAAAJAd7vYuAAAAAAAAAAAAAAAAAAAAAAAAAADyii+//FKenp6Z4hEREZo3b562bNmis2fPKjk52Q7VAX96+umnNW3atEzxgwcPauLEiXaoCACQF2V13SRZ/9rJnn0DsA1XV1d169ZN3bp1U1BQkIYNG6Y//vjD3mVZRVJSkl566SUdO3ZM+fLly9S+dOlSHTlyRNevX7dqHaNGjdJzzz1ntG3p0qUKCgqyav+P4uXlZbe+LeGJJ57Q4sWL1bt3b4vlbNKkibZs2aLAwECNGDFCUVFRFsstSX379tX8+fPl4+NjsZyFChXSsGHD1KdPH40ePVpff/21xXJLzvk8AwAsh/tEAAAAAAAAAAAAAAAAAAAc271793TmzBnVqVNHkuTu7q4pU6Zo5MiRNunf29s7w3JCQoJN+gUAIC/x9fXNsHz69GmlpaWZlXPo0KHy9vbW4cOHH7uurc/3JUqU0PPPP58hFhAQIIPBkONcaWlpCggI0A8//JAe6927t0aPHq379+9nWLdZs2YqXLhw+nJkZKQCAwNz3OdfFi5cqDZt2qQvd+vWTaGhoSbnAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJB3hIWFafjw4RoxYoRq1qypRo0a/X/s3Xd0FGX7//FPKiWh994EFCGA9CYdKYJUQVoQCyIq4KOPIjyoICiCCnakdwTpvSgQkKLU0IsggtSQUFKAkOT3hz/yNexssmV2sxver3M4h73umeu+dnd25p7J7j0qWrSoKlWqpO7du0uSdu3apfnz5+v8+fM6dOiQjh075vY6w8LC5OPj47X9Xrx4UW+++abeeustVa9eXZUqVVKpUqUUHByswMBAxcbG6tKlSzp+/Li2bdumqKgoE6oHAAAAAAAAAAAAAABwr2nTpikwMNCw7dKlS5owYYLWrFmjI0eOKD4+3s3VwUxFihTRDz/8oC5duqR3KTZZt26dWrdubRHv0qWLBgwYoNu3b7u9ptDQUMP4L7/8oj///NO9xaSTChUq6Pvvv9eIESM0bNgwTZ482aF7inqDoKCg5O/kGenfv7+++eYbN1YEAAAAAIDrcJ0wpbp162rUqFEpYtu2bdP//ve/dKoIANzLaD8osS8EAAAAAACSf3oXAAAAAAAAAAAAAAAAAAAAAAAAAAAPg8aNG6tKlSoW8VWrVqlr166KiYlxf1GAgbx586pRo0YW8evXr7u9FgDAw8nauEly/dgpPfsGkD7atm2r+vXrq1u3blq/fn16l+MShw4d0jvvvKPx48dbtOXMmVOzZs1S48aNXXbTqgoVKujTTz81bDt+/LgGDx7skn5tFRwcnK79O+Pxxx/X6tWrVbx4cZfk79Kli2rWrKnWrVvryJEjTufz8/PT5MmT1adPH+eLsyJ37tyaPXu2WrZsqeeff1737t1zOqe3vc4AAHNxnggAAAAAAAAAAAAAAAAAgHeYPn26xo0bl/x4wIABioqK0gcffKCEhASX9v3gbxPi4uIs2gsUKJC8XHR0tP7++2/dvn3bpXUBAJCRBAQEpHhsxnE0PDzc5mWDgoJSPH7weG+2Fi1apHjO165d09q1ax3Ot3r1akVGRip37tySpKxZs6px48ZatmxZiuVCQkJSPN60aZNTvz/95ZdfUjyuX7++w7kAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPJySkpJ09OhRHT16VJL0xBNPqHv37pKkrVu3avz48elYXcaRmJio3377Tb/99lt6lwIAAAAAAAAAAAAAAGCqxo0bq0qVKoZtq1atUteuXRUTE+PeouBSnTt3VmhoqGbMmJHepaRpypQpat26tUU8W7Zsat++vebPn+/WegICAtStWzfDtilTpri1Fk+QP39+/fDDD3rxxRfVtWtX/fnnn+ldkum6d+9ucZ/2f3v88cdVt25dbd++3Y1VAQAAAABgPq4TWsqbN68aNWqUInb9+vV0qQUA0oPRflBiXwgAAAAAACT/9C4AAAAAAAAAAAAAAAAAAAAAAAAAAB4Gr732mkXsyJEj6tSpk+7cuZMOFQEAAHgmo3GT5J6xU3r2DcDYmTNndO3aNZuW9fHxUaZMmZQtWzZlz55duXLlsmm9XLlyadWqVXruuef0008/pbpsbGysdu/ebVNea32VKVPGIn7v3j3t37/f4bySdPToUattEyZMUOvWrdWiRQuLtoYNG+rtt9/Wp59+6lT/RgICAjRv3jxlzpzZoi0+Pl7du3dXXFyc6f3aIygoKF37d1TlypW1ZcsW5ciRw6blY2Njdf36dd29e1eBgYHKmTOnsmbNmuZ6JUqU0K+//qqGDRsqPDzcqZpnz55t9aZxD7p69aouXryoGzduKDY2VlmyZFGOHDlUqFAh5c+fP831e/bsqcyZM+vZZ59VUlKSwzV74+sMADAX54kAAAAAAAAAAAAAAAAAAHiH77//XgMGDFCpUqWSY8OGDVOXLl307bffatWqVfrjjz9c0ve/f5sQHx8vf39/dezYUc8884zq16+vokWLWqyTlJSk06dP6+eff9asWbO0bds2l9QGAEBGERUVleKxLb8zM1NwcHCKx67+bWSNGjVSPF65cqUSEhIcznfv3j2tXLlSvXv3To5Vr15dy5YtS7Hcg6/ruXPnHO5Tkq5fv67Y2Njk39nVrFnTqXwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANjjtddeM4wfOXJEnTp10p07d9xcEdzh66+/VlhYmM6cOZPepaRqxYoVioiIUN68eS3aQkNDNX/+fLfW8/TTTyt37twW8evXr2vx4sVurSUtERERio6OtmsdPz8/ZcmSRdmzZ1dgYKDN69WsWVP79+/Xc889pzVr1thbqkd75ZVXbFpm+/btbqgGAAAAAADX4TohAAAAAAAAAMBW/uldAAAAAAAAAAAAAAAAAAAAAAAAAJDR3b59W9u2bTNsi4uLc3M1SIur3q/GjRtbxIYMGWLaxGBsZwAAIKMwGjdJ5o6dPLHvhx3jWVgzbNgwzZ0716F1c+TIoccff1w1atRQx44dVb9+ffn6+hou6+/vrzlz5ujvv//Wjh07rOY8duyYatSo4VA9ktSuXTstW7bMIn79+nWn8toiNDRUBw8eNLyB2EcffaSNGzdq7969pvY5evRohYSEGLYNGzbM9P4cERwcbBE7f/68/vzzT5f2e+XKFYfXLVGihNavX68cOXJYXebOnTtauHChlixZop07d+rChQsWyxQsWFC1a9dWhw4d1KVLF2XJksUwV86cObVu3TrVqFFD58+fd6jmd999V926dbPanpiYqHXr1mn69On69ddf9ffff1tdtlChQqpfv75CQ0PVsmVL+fn5GS7XuXNnDRs2TCNHjnSoZm98nQEA5uM8EQAAAAAAAAAAAAAAAAAA7xATE6OOHTtq06ZNypkzZ3K8fPnymjBhgiZMmKDIyMgU39cuVKiQChYsqEuXLjnV979/m+Dr66tz584pf/78qa7j4+OjMmXKqEyZMnr55Ze1c+dODRgwwCN+awEAgCf6+++/lZSUJB8fH0lS5cqVlTt3bkVGRrql/wd/i+jq3z9Xr149xePdu3c7nXPPnj3q3bu31T4kWfz+LTo62ul+b926paxZs0qScuXKJX9/f927d8/pvAAAAAAAAADgDe5f1wYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAED6aNy4sWF8yJAhunPnjpurgbsEBwdrzpw5ql+/vhITE9O7HKvi4+M1a9YsDR482KKtefPmptyD2x6hoaGG8blz53rc52XgwIGaO3euw+vnz59f5cuXV7Vq1dSsWTM1a9ZMmTJlsrp8jhw5tGzZMvXq1Us//vijw/16kmrVqumJJ55Ic7kuXbpo4MCBioqKckNVyOhu376tbdu2Gba5+p7B4PUHvBGfWyDj43MOuA/XCQEAAAAAAAAAtvJP7wIAAAAAAAAAAAAAAAAAAAAAAACAjO7ChQtq0KBBepcBG7ni/apQoYJy5cplEV+5cqVpfbCdAQCAjMDauCkyMtLUsZOn9Q3Gs3CNGzduaPv27dq+fbsmTJigYsWKacSIEerdu7d8fX0tlg8MDNScOXNUsWJFxcbGpkPFrnXp0iW98MILWrZsmUVbQECA5s6dq6pVq5o2aXzjxo31n//8x7Bty5YtGjt2rCn9OCsoKMgiNmXKFH3wwQfuL8YGfn5++vHHH5U/f36ry0yfPl3vvvuuLl++nGquS5cuaenSpVq6dKneeustjR49Wi+++KLhsgULFtS8efPUsGFDu2+UV7ZsWY0YMcJq++7du9W3b18dPHjQpnwXL17UwoULtXDhQlWoUEHTpk1TzZo1DZcdPny4fvrpJx09etSumr3xdQYAmI/zRAAAAAAAAAAAAAAAAAAAvMv+/ftVq1YtLVy4UCEhIRbtuXPnVu7cuZMf9+jRQz169NDNmze1d+9e7dq1S8uXL9f27dvt6vffv03w8/NL9bvo1tSuXVs7d+7U66+/rokTJ9q9PgAAGV1UVJQOHz6sihUrSpL8/f01YsQIvfbaa27pPzg4OMVjs36LaU3ZsmVTPD506JDTOR/8Dd+DfUjS3bt3Uzx+8Hk7Ilu2bCke58yZUxEREU7nBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgNRUqVFCuXLks4pGRkVq5cmU6VAR3qlOnjoYNG6YRI0akdympmjJligYPHmwR9/PzU/fu3fX555+7pY48efKodevWhm1TpkxxSw3udOXKFV25ckVbt27V+PHjlS1bNvXu3Vv/+c9/VKpUKcN1AgICNHfuXN26dUurV692c8Xme+WVV2xaLnPmzOrdu7cmTJjg4orwMLhw4YIaNGiQ3mU8tHj9Ae/D5xbI+PicA+7BdUIAAAAAAAAAgD1807sAAAAAAAAAAAAAAAAAAAAAAAAAAMjoKlSoYBhPTEx0cyUAAACezdq46bfffnP52Ck9+wbgHufOndPzzz+vxo0b6/r164bLlCpVSoMGDXJrXe60fPly/fDDD4Zt5cuXN+0GYjlz5tTMmTPl4+Nj0Xb9+nX17NlTSUlJpvTlrODgYItYbGxsOlRim3feeUe1atUybLt7966ee+45Pf/887p8+bJdea9evaqXXnpJnTt31p07dwyXqV+/vt588027a37//fcVEBBg2LZo0SLVrl1bBw8etDuvJB05ckR16tTRggULDNv9/f314Ycf2p3XG19nAID5OE8EAAAAAAAAAAAAAAAAAMD7nDhxQlWqVFFoaKi2b99u0zrZs2dXo0aN9M477+jXX3/VH3/8oZ49e9rcp9FvEy5evKjZs2dr4MCB6tSpk5o1a6bmzZurc+fO+u9//6ulS5fq9u3bKdYJCAjQ999/r5deesnmvgEAeJhMnz49xeMBAwZo5MiR8vPzc3nfDx7v4+LiLNrLlCmjypUrq3LlyipTpowyZ87scH85cuRI8fjvv/92ONd9Fy5cSLUPSYqKikrxuGjRok71mTNnTmXNmtUiBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACOunDhgt5//329//77WrduXXqXAwAAAAAAAAAAAAAAAA9WoUIFw/hvv/2mxMREN1eD9DB8+HDVqlUrvctI1eHDh/X7778btvXp08dtdTz33HMKCAiwiIeHh2vv3r1uqyO93Lp1S998840effRRvfvuu7pz547hcr6+vvrxxx9VsWJFN1doruDgYD333HMW8TNnzhgu379/f1eXBAAAAACAy3CdEAAAAAAAAABgD9/0LgAAAAAAAAAAAAAAAAAAAAAAAAAAMrpcuXKldwkAAABewdq4ydoNRjJK3wDcKywsTA0aNFBMTIxh+6BBg+Tv7+/mqtxn0KBBOnHihGHbK6+8oqefftrpPiZOnKiiRYsatvXr10/nz593ug+zBAcHW8Ti4uLSoZK0FS5cWO+9955hW2Jiojp16qT58+c71ceiRYv0zDPPKCEhwbD9f//7n/Lnz29zvpw5c6pz586GbTt37lS3bt2s9mWrxMREde/eXdu2bTNsb9++vfLmzWtzPm98nQEArsF5IgAAAAAAAAAAAAAAAAAA3ikpKUkzZ85UvXr1VLRoUXXu3Fljx47VunXrdOnSpTTXL126tGbNmqX169cre/bsaS4/bNgw7du3T5K0ZcsWtWjRQkWKFFGvXr305ZdfavHixfr555+1ceNGLVq0SGPHjlWHDh1UpEgRffrppxbfLf/6668VEhLi2JMHACAD+/777y2+0z9s2DAdPnxYb7zxhsqUKeOyvoOCgpL/Hx8fL39/f3Xr1k3z5s3TuXPndOvWLZ06dUr79+/X/v37derUKcXGxurUqVOaOHGi6tevb3NfgYGBypQpU4pYdHS008/h1q1bKR7nyJHDYpmjR4+meNyoUSOn+mzSpIlFzNfX16mcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5uly5d0ogRIzRixAht3LgxvcsBAAAAAAAAAAAAAACAB8uVK5dh/MF7IyLj8vPz05w5c1Lcl9ITTZ482TBeqVIlt93vOjQ01DBurbaM6u7duxozZozq1Kmjv/76y3CZ4OBgzZ07VwEBAW6uzjw9evQw/FwMGTJE4eHhFvHy5cvrySefdEdpAAAAAACYjuuEAAAAAAAAAAB7+KZ3AQAAAAAAAAAAAAAAAAAAAAAAAACQ0eXOnTu9SwAAAPAK1sZNN2/ezNB9A3C/Q4cO6b333jNsy5cvn1q0aOHmitwnLi5O3bt3V3x8vGH71KlTlT9/fofz9+zZU88++6xh28yZM7VgwQKHc7uC0Y2t4uLi0qGStA0ZMsTqDeo++OADrVy50pR+1q1bpyFDhhi2Zc+eXf/5z39sztWsWTNlypTJIp6UlKR+/frp3r17Dtf5bwkJCerXr58SExMt2gICAuz6THvj6wwAcA3OEwEAAAAAAAAAAAAAAAAA8H5///23Fi1apP/+979q2bKl2rRpk9y2adMmjRs3TuvXr9eNGzcs1m3evLl+/vlnBQYGptrHypUr9cQTT6hChQpq1KiRNmzYoKSkpDRri4yM1DvvvKOWLVvq9u3byfHAwEB99tlndjxLAAAeDjExMerYsaOuX7+eIl6+fHlNmDBBp06d0rVr1zRt2rTktkKFCqlgwYJO9x0cHJz8f19fX507d07z5s1Tt27dVLRoUcN1fHx8VKZMGb388svaunWrduzYoSeeeCLNvrJnz24Ri46Odrz4/+/WrVspHgcEBChz5swpYr/++muK3/0VKFBAHTp0cLjPAQMGOLwuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADOyJ07t2H85s2bbq4E6alMmTL68ssv07uMVM2fP19xcXGGbaGhoS7v/7HHHlP16tUt4nfv3tWcOXNc3r8n2rdvn+rVq6c//vjDsL1SpUoaNmyYm6syzyuvvGIRi4yM1JIlSzR58mSb1wEAAAAAwBtwnRAAAAAAAAAAYA/f9C4AAAAAAAAAAAAAAAAAAAAAAAAAADK6TJkypXcJAAAAXsHauCk+Pj5D9w0gfXz99de6evWqYVvz5s3dXI177dmzR//73/8M2/Lly6cZM2Y4lLdEiRL65ptvDNvOnDmjAQMGOJTXVTJnzixfX8vpV6zdYC095cyZU88//7xh2+nTp/XJJ5+Y2t/nn3+u48ePG7a9/PLLCgoKsilPzZo1DeM7d+5UeHi4w/UZOXLkiLZu3WrYVqtWLZtyeOvrDABwDc4TAQAAAAAAAAAAAAAAAADI2Pbs2aO3335bTz31lPLmzau2bdvq999/T7FM9erVNXr0aJvyHT161KE6Nm7cqP79+6eINWvWTOXLl3coHwAAGdn+/ftVq1Ytq79Py507t0JCQpIf9+jRQxcvXtSNGze0adMmffLJJ6pbt67d/f77t15+fn7Knz+/3Tlq166tnTt3ql+/fqkuZ/S7x4SEBLv7syXHg31dv35d69atSxEbN26ccubMaXd/3bp1U5MmTexeDwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM2TKlMkwHh8f7+ZK4C4bNmwwjPft21cdO3Z0czW2u3nzpn766SfDth49ehje69JMoaGhhvGlS5cqMjLSpX17svPnz6tVq1aKiooybH/rrbdUsGBBN1flvBo1aqhKlSoW8Tlz5uju3buaPXu27ty5Y9HeqVMn5cmTxw0VAgAAAABgLq4TAgAAAAAAAADs4dpv7AEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeKDExUUuWLDFsq1q1qpurcb9PP/1UW7ZsMWxr2bKlBgwYYFc+Hx8fzZ49W9mzZ7doS0hIUI8ePRQdHe1Qra4SFBRkGI+Li3NzJWl79tlnrdb79ttvmz4JeUJCgv7zn/8YtuXMmVPt27e3KU/p0qUN4+vXr3e0tFStXbvWrjoe5K2vMwAAAAAAAAAAAAAAAAAAAADAOffu3dPKlStVu3Ztff/99ynaBgwYoPz587u0/+nTp+vgwYMpYu3atXNpnwAAeKsTJ06oSpUqCg0N1fbt221aJ3v27GrUqJHeeecd/frrr/rjjz/Us2dPm/sMDg62iF28eFGzZ8/WwIED1alTJzVr1kzNmzdX586d9d///ldLly7V7du3U6wTEBCg77//Xi+99JLNfbvbqFGjUjwuXbq0VqxYody5c9uc46mnntK0adPMLg0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMCq//znPzpx4oRh26RJk1SoUCE3V2S7KVOmGMYLFCig5s2bu6xfHx8fq/f4tFbTw+TkyZN65ZVXDNuyZs2qYcOGubki51l7PpMnT5YkRUVFaenSpRbtgYGB6tOnjwsrAwAAAAAAAAAAAAAAAID055veBQAAAAAAAAAAAAAAAAAAAAAAAADpITAwUHnz5lW+fPmUNWvW9C7HpbJmzap8+fIpW7Zs8vHxSe9yHBIUFKT8+fMrODg4vUtBKrJkyaJ8+fIpT5488vf3T+9yJP0zOX22bNmUP39+5c2b12PqsgXbPWxxfx+fPXt2j93HZ4TjkKt4yz7KW99DX19f5cyZ86EY75nl/rEnZ86c8vPzS+9y8P+xLacPTx+Leeu+2RPt2bPHMF6mTBk3V+J+SUlJ6tmzp65fv27YPm7cOFWoUMHmfO+++67q169v2PbRRx9px44djpTpUtY+43FxcW6uJG3dunUzjB87dkyLFy92SZ+rVq1SeHi4XfU8KEeOHIbxv/76y+G6UnPu3Dm76niQt77O3sgTryOZxdPP9Tz52rgn1+Zq3nCNh3MTz8N5vH3u75uzZcvmsj4yZ86c/Fn2FJ5+XEqNp5+b3+ep4xr22wAAAAAAAAAAAAAAAIBjEhMTNWDAgBS/OcmcObM6duzo8r4XLlyY4vETTzzh8j4BAPBWSUlJmjlzpurVq6eiRYuqc+fOGjt2rNatW6dLly6luX7p0qU1a9YsrV+/3qbvgA8bNkz79u2TJG3ZskUtWrRQkSJF1KtXL3355ZdavHixfv75Z23cuFGLFi3S2LFj1aFDBxUpUkSffvqpEhISUuT7+uuvFRIS4tiTd7EdO3Zo0qRJKWL169fXvn379Oyzz6b625e8efNq3LhxWr16tTJnzqz4+HhduHDB1SUDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOB1goKClD9/fuXMmVN+fn7pXU6GEBMTo+7duys+Pt6iLXfu3Jo5c2Y6VGWbLVu26I8//jBsCw0NdVm/TZo0UZEiRSzi586d04YNG1zWrzdZsGCB1qxZY9gWGhqq4OBgN1fkuGzZsqlbt24W8d27dys8PDz58YP3Nr2vX79+LqsN6ev+Mcmbtuf05Ovrq5w5cypfvnzKmjVrepfjlbJly6b8+fMrW7ZsLusjc+bMypcvn033sPYUWbNmTa45tXtJP0wYM3sWbzhe3P8cZcuWjc+Rh/DW46Y3bO9myZIli/Lly6c8efLI398/vcsxnbdug44IDAxU3rx5Pe65+vj4JI//8ubNmyG3M2c8TNsoUvLmz4Y3HCcf1nGhN29XSJ23nh97w/5C8s7Xl+trAAAAAOBaXFUBAAAAAAAAAAAAAAAAAAAAAABAhle3bl01bdpUNWvWVJUqVZQ3b15lzpw5xTIJCQm6ePGiDh8+rH379mnVqlXavn27EhMTTanhiSeeMIzv3bvXlPz3FStWTJ07d1b9+vVVtWpVFStWLMXkLElJSbp8+bIOHz6sHTt2aNmyZdq9e7dhrsDAQBUsWNAifunSJd29e9fmmoye+4ULF3Tp0iXD5fPly6cuXbqoSZMmqlq1qkqUKJFiooy7d+8qIiJCR48e1YYNG7R+/Xrt27fP5nocrVmy/n7lz59fRYsWtZrPaHL01PpJTWrbjLu2M0mqXr262rZtq2rVqqlSpUoqUqSIxYQmMTExOnr0qPbs2aPVq1drzZo1hhPrmyVTpkxq2rSpWrZsqZCQED3++OPKkyePxeRMt27dUmRkpA4cOKCwsDBt2bLF6ufAUZ683RcsWFCFCxe22v7II48YxnPlymX3Nnv37l0dOnTIrnUcVahQIRUqVMgintrr7iij1yEpKcnu98Te7SRPnjzq2LGjmjdvripVqqh06dIptpOkpCRdvXpVBw8e1O+//66lS5dq165ddtXkrIxwHJKk4OBgVa1aVY888oiyZ8+ubNmyydfXN7l93Lhxio2NtbkGybP2UakpXry4OnbsqCeffFKVK1e22B8lJSXp7NmzCg8P14YNG7RkyRL9/fffbqvPmixZsqhVq1Zq0aKFKleurAoVKlhMKpWQkKBz587p4MGD2rFjh5YuXaqjR4+mU8Xpr3LlynrmmWdUs2ZNhYSEqEiRIim2c0m6efOmjhw5ovDwcK1fv15r1qyxe9t/kKPjpsKFC9t9HHpwDOTOvo36t4WnbMvpte80azzryWMxR3ji8TUjsbZd5MiRw82VpI/z58+rX79++vHHHy3aMmfOrLlz56pmzZppbh9PPPGEPvzwQ8O2nTt3auTIkabUa7agoCDDuLPHO7MFBQWpQYMGhm1G752Z5s+fr5CQEIt406ZNFRAQkOZ5vrVJg2/cuGFKfQ+6fv26YTwgICDNdb35dfZ0nngdySyefq7nCdfGvbE2e2XEazzeem5i73mJN5wn3pde5/FGPOmc0Vq/Pj4+atasmbp27ao6deqofPnyFp+z8+fPa//+/frll1+0YMECXbhwIdX+rdXUo0cP1a1bVyEhISluxHL/XPLQoUNas2aNVq9erRMnTtjdhz086biU0c7N77NnXDNy5Ei3jWk8Zb8NAAAAAAAAAAAAAAAAZBSJiYkaP368Zs2alRxr2LChvv/+e5f2e+TIkRSPjX4HBAAALP39999atGiRFi1aJOmf7zPv2bNHkrRp0ybt2bNHISEhqlWrlsXvR5s3b66ff/5Z9erVS/W3lCtXrtTKlSv12GOP2fU93MjISL3zzjvasGGDVqxYkfz7mcDAQH322Wdq3ry5TXke/F64I+zJ8frrr6tChQqqV69ecqx48eL68ccfNX78eP388886fvy4IiMjFRgYqAIFCqhGjRqqV69eit8Ivfvuu2rXrl2KuW6SkpKcfi4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOTPn19Fixa12l6kSBHDeOHChfXEE0/Y3d/evXvtXue+ypUr65lnnlHNmjUVEhKiIkWKyNfXN8UyN2/e1JEjRxQeHq7169drzZo1io2NdbhPa4ye+4ULF3Tp0iWr6wQHB6tq1ap65JFHlD17dmXLli1F/ePGjXNJrY7Ys2eP3n//fY0ePdqirVmzZho0aJDGjx/v/sJsMHXqVI0aNcoi3r59e2XLlk23bt0yvc/Q0FDD+PTp07kH5b8MHTpUrVq1sogHBwfrueee06RJk9KhKvv17NlTWbNmtYhPnjw5xeOff/5Zf/75p0qWLJkiXrZsWTVp0kS//PKLK8t0WMWKFRUYGGgRP3funK5evep0/hw5cqhMmTIW8f379ysxMdHp/OXKlVNwcLBF/PDhw7pz547T+e/Lmzev2rdvr5YtWyokJESlS5eWn59fcvvdu3cVERGho0ePasOGDRozZoxpfUvGxyHJueOsK2XJkkWtWrVSixYtVLlyZVWoUEHZs2dPsUxCQoLOnTungwcPaseOHVq6dKld90F2J7Nef3vGEz4+PmrWrJm6du2qOnXqqHz58im2uaSkJJ0/f1779+/XL7/8ogULFujChQt21XO/ph49eqhu3boKCQlJsb+7v10fOnRIa9as0erVq3XixAm7+0ir/welNsbKkyePOnbsqObNm6tKlSoWn8WkpCRdvXpVBw8e1O+//66lS5dq165d6Vqz5NpxoTvHzCVKlFCePHks4hEREfrrr78cqj8tefPmVfHixS3iV69e1blz56yulx6fW0nKly+funTpoiZNmqhq1aoqUaJEqseL9evXa9++fXbV5KxixYqpc+fOql+/vqpWrapixYrJ398/uT0pKUmXL1/W4cOHtWPHDi1btky7d+82zBUYGKiCBQtaxC9duqS7d++67Dnc503bZGq89bhp7/jI7O3dneOj6tWrq23btqpWrZoqVaqkIkWKpHiukhQTE6OjR49qz549Wr16tdasWaP4+HjTa3EFb90GHVG3bl01bdpUNWvWVJUqVZQ3b15lzpw5xTIJCQm6ePGiDh8+rH379mnVqlXavn27Kecv1mTKlElNmzZN/jw9/vjjypMnj3x8fFIsd+vWLUVGRurAgQMKCwvTli1brO6jbeEt1wndvY0WLFhQhQsXttr+yCOPWMRy5cpl92ty9+5dHTp0KEXM2rEtJiZGx48ftyu/rfz9/RUSEmIRT0xM1P79+13Sp63S67NhJCOOC4sXL66OHTvqySefVOXKlS1qTEpK0tmzZxUeHq4NGzZoyZIl+vvvv91aoyt4ynZVqFAhFSpUyCKe1vmlIx7cfpOSklLd3hzZD0rm7Qsd5Sl/U8qI+wvJO1/fjHR9jTECAAAAAG/hk2Tjt+cevBgDAPeFhIQkX5RISkrS6dOntXPnTr6cCwAAAAAAAAAAALuNHTc2vUvAQ+DokaOaOnVqepcBAKYYuEjKFJTeVSAjO39ImvtWelcBALDGx8dH1atXV7ly5ZK/7x0eHq7w8PB0ruzhxHdqAc8UGBioAQMGqF+/fipfvrxDOa5evarvvvtOX331lSIiIpyqx9o+wazf7dSpU0cjR45UkyZN7M4ZHh6ujz76SAsXLkwRr1u3rn799VeL5Rs2bKiwsDCb8xs996FDh1pMrl6sWDF99NFH6tGjh8XEcWnZuXOn3n//fa1fv96u9ayx9/1688039dlnn5nSd2ouX75sOKHkfa7ezoKDg9WvXz8NHDhQxYoVs3v9yMhIff311/r0008VExNjSk3SPxOwvf3223rhhRcMJ762xf79+/XJJ59o4cKFpkxi58nb/fDhw/Xhhx/atY6jtm/frnr16rmlr5EjR2rYsGEWcaPX3RmBgYGGE6nfvn1bWbJksSuXPdvJ8OHD1adPnxQT0tri9OnTGjNmjKZNm+bSCTczwnHIz89PPXv21AsvvKB69epZTNj0bwUKFNCVK1ds6t8T91FGmjRpomHDhqlx48Z2rZeQkKAff/xR77//vk6dOpWibdOmTWrUqJHFOva+h6kpUaKEhgwZol69ehnenCItBw4c0KhRo/TTTz89FOdwgYGB6tOnj9566y2VLVvW7vVv376tuXPn6pNPPtHJkycdqiE9x03u6tta/6nxtG05vfadZo1nPXksZg9PPr66wpkzZyxuHiRJPXr00Ny5c13Wb8OGDbV582aL+L179xQQEGB6f+3atdOyZcss4hEREcqXL5/p/dlq5syZ6tWrl2HbZ599prfesv6HwyxZsmjfvn2G119u3bqlKlWq6PTp06bVaqaaNWsa3hylVq1a+u2339KhImMtWrTQunXrDNsqVKjg0snnS5curT/++MOwrV69etq+fXuq669bt04tWrSwiPfs2VNz5swxpcZ/69Spk3766SeL+JYtWwzHpv/mza+zJ/KU60iuul7myed6nnZt3Ftqc0ZGusbjjecmzpyXePJ5ouQZ5/FGPOmc0ajfli1basKECSpXrlyq+f4tMTFR8+bN09ChQ3X27Nk0l69du7bGjx+vWrVq2dyHJC1evFhDhgwx/aaCnnhcyijn5pJz4xpX/W3sPk/bbwMAkB58fHxUo0YNlS1blu/TArCZM+Nf5moHYA2/KwEAAAAAAAC8xxNPPKE9e/ZIksaNG6e3337bcLkHv+e9bds2NWjQwKW1NWrUSJs2bUp+vHv3btWoUcPpvGPHjk3x25DUnreZ0qtfAACsHe/9/f3VsmVLDR8+3OIYm9ZvKc3Qp08fTZs2LUXs0Ucf1fHjx1PEcuTIoevXr6eI5c6dW1FRUU71nydPHovf4/j7+yshIcFw+aCgIM2dO1ft2rWzu6+kpCQNHTpUH3/8sX777bcUr3fhwoV18eJFu3MCANLPKzOl7PnTuwrAuvEdpbux6V0FgPTCXO2ehe/UAgAAAAAAAAAAAAAAAAAAuBdztQNwBHO1A3AFflcCAAAAAAAAmKtV61Zq0qRJepeBh8zqVatTzJUPABkZx1qkl8WLFmvHjh3pXQYAuEXz16SqT6d3FXjYrP9K2r8qvasAAPdirnbPwndqgfTz5ptv6rPPPnNLX5cvX1bBggXtWicwMFB9+vTRW2+9pbJly9rd5+3btzV37lx98sknOnnypN3rW2O0fxo6dKhGjx6dIubn56eePXvqhRdeUL169eTr62s1Z4ECBXTlyhXTakzLmTNnVLJkSYt4mTJldPr0afn4+GjLli2G96W+c+eOatSooYMHD5pSy8GDB1WxYkWLeJEiRXThwgW7chUpUkR//fWX4Wvdt29fi/tiOisoKEiXL19WUFBQinhSUpLKlCmjM2fO2J3T2nvTo0cPzZ07N93zOSMsLMxwm1q3bp1atmxpd770eG4HDhxIHrfcFxcXp4IFC+rmzZsp4v/73/80YsQIixwLFy7Us88+65L6nPXTTz+pU6dOFvHp06fr+eefdzq/tdekUaNG2rJli1O5fX19deXKFeXJkydF/ObNm8qbN6/i4+Otrmtt3Pngb0MLFiyo4cOH64UXXlBgYKDNte3cuVPvv/++1q9fb/M6qbG1XnflsaZEiRIaMmSIevXqpaxZs9q9/oEDBzRq1Cj99NNPHnVu4MrX32g80bJlS02YMEHlypWzOXdiYqLmzZunoUOH6uzZs2kuX7t2bY0fP161atWyuQ9JWrx4sYYMGaITJ07YtZ41tr4mxYoV0/Dhw9WnTx/5+/vb1cfp06c1ZswYTZs2LdX9gq08YVxo1pj5hRdesGs9o3uOS9KxY8f02GOP2V2HLWbNmqWePXtaxLt166Yff/zR6nru/twWK1ZMH330kXr06CE/Pz+7+jD7mGFNnTp1NHLkSDVp0sTu1yE8PFwfffSRFi5cmCJet25d/frrrxbLN2zYUGFhYU7Vawtv2iaNeNpx09XjI8nc7d3V45rg4GD169dPAwcOVLFixexePzIyUl9//bU+/fRTxcTEOFQDYzdzBAYGasCAAerXr5/Kly/vUI6rV6/qu+++01dffaWIiAjTaitSpIjefvttvfDCCwoODnYox/79+/XJJ59o4cKFSkxMtGtdT79OmF7b6PDhw/Xhhx/a3Z+9tm/frnr16qWIWTu2RUdHq0CBAoqNNf/G5J06ddJPP/1kEd+4caOaN29uen+2SO/PhpGMNC5s0qSJhg0bpsaNG9u1XkJCgn788Ue9//77OnXqVIq2TZs2qVGjRhbruGtcaAtP265GjhypYcOGWcSNtitnBAYG6s6dOylit2/fVpYsWayu4679oGS8L7SHJ/5NKSPtL7z59c1o19cYIwAAALMxVzsAR9hyndX6X8UBAAAAAAAAAAAAAAAAAAAAAAAAL9WwYUOFh4fr888/d3giK0nKly+fhg8frj///FOvv/66aROKmSlHjhyaP3++tm/frqZNmzpUY0hIiBYsWKBVq1Ypf/78Lqgybb1799axY8fUu3dvuyf2kP6ZVGLdunVasWKFsmfP7oIKPcPx48fTre9evXrp7NmzGjdunEOT/UlS7ty5NXz4cP3xxx9q1aqV0zX5+vpqyJAhOn36tAYOHOjwREWSVKVKFc2fP1+7du1y+PnZ62HY7g8fPpzeJXi9vn376ujRo3rxxRftnuRZkkqXLq2JEyfq8OHDql27tun1ZZTjUEhIiPbs2aPp06erQYMGqU5MbStv2UcVLFhQK1eu1M8//2z3ZHfSP5N6d+/eXQcPHtTgwYNNrS01AQEBGj16tE6ePKl+/fo5NAGmJFWuXFkLFizQzp077ZoAyxs99dRTOnXqlCZOnOjQJGWSlDlzZvXt21fHjh3TN998Y3EDGE+SnuMme/r35m3ZFftOd/LksVhGOb56C0+eqNudBgwYYPUGXm+++aaaNGlidd3Urr+89tprOn36tCk1uoK1Y1lcXJybK0mdtbH8n3/+qaNHj7q079OnT1s9rtlyjhEVFWUYL1SokFN1WWMtb2RkZJrrevPr7Gk88TqSWTz9XM+Tr417cm3u4OnXeLz13MSbzkvsPU/19vP49Hhv/Pz89NVXX2nNmjV2b3++vr7q0aOHDh06pI4dO6a63Keffqrt27fbPdG5JHXs2FFHjhzRG2+8Yfe61urx5ONSWjz53Pw+Z8c1rhrTeOt+GwAAAAAAAAAAAAAAAPAmERERKR7nzp3b5X0GBASkeHz37l2X9wkAwMPk3r17WrlypWrXrq3vv/8+RduAAQNc/pvc6dOn6+DBgyli7dq1s1ju5s2bFr9/zZYtm9P9P5gjJiZGCQkJVpePiYnRM888o9DQUP31118297N//341bNhQH3/8sSRZfNf9xo0bdlQNAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAED6O378uF3LP/XUUzp16pQmTpyosmXLOtRn5syZ1bdvXx07dkzffPONgoKCHMrjiJCQEO3Zs0fTp09XgwYN5Ovr67a+zZCUlKSePXvq5s2bFm2ZMmXS3LlzFRgYmA6Vpe7vv//W+vXrDdtCQ0NN769Tp06G29XmzZt15swZ0/vzdtOmTTOMN2rUSFmzZnVzNfarVauWQkJCLOI//fST4Wdl2rRpSkxMtIi3b9/e5feBddSCBQsM408//bQp+7G2bdvaFbdH/fr1lSdPHov48uXLFR8f73T+Ll266MiRI+rfv7/d+7/atWtr3bp1WrFihbJnz+50LZ4uICBAo0eP1smTJ9WvXz+HP9+VK1fWggULtHPnTpUrV87kKj2fn5+fvvrqK61Zs8bu5+/r66sePXro0KFD6tixY6rLffrpp9q+fbtq1apld40dO3bUkSNH9MYbb9i9rqP69u2ro0eP6sUXX5S/v7/d65cuXVoTJ07U4cOHVbt2bRdUaMmV40Izx8z2jpd//PFHw+Pfo48+qpo1azpUS2qCg4MNt+dr165pyZIlpvfnqN69e+vYsWPq3bu3/Pz87F7f1ceMHDlyaP78+dq+fbuaNm0qHx8fu3OEhIRowYIFWrVqlUeNabx1m/Tm46Yz4yPJe8ZIvXr10tmzZzVu3DgVK1bMoRy5c+fW8OHD9ccff6hVq1YmV+gcb94G7dWwYUOFh4fr888/V/ny5R3Oky9fPg0fPlx//vmnXn/9dYf2pf/m6+urIUOG6PTp0xo4cKCCg4MdzlWlShXNnz9fu3btcnh7dQd7rhM+LNvo4cOHLWLWjm3WjkFm6Nmzp2F8ypQpLukvNd7+2fD0cWHBggW1cuVK/fzzz2rcuLHd6/v5+al79+46ePCgBg8ebHp9ruLt21VGZ7QvtJU3/03J0/cXkve+vhn1+trDPkYAAAAA4D286xuTAAAAAAAAAAAAAAAAAAAAAAAAQBr69u2rX375xalJrB4UFBSkL7/8UuvWrXNqMhSzVaxYUeHh4eratasp+Vq3bq3t27e7faKWTz75RDNmzDBl8uunn35au3bt0iOPPGJCZZ7H3psImCFr1qxaunSpZs6cqdy5c5uSs0CBAlq1apU+/PBDh3PkzJlTYWFhGj16tKkT8VevXl179uxR/fr1Tctp5GHZ7g8dOpTeJXi1L7/8UlOmTDFlIqCyZctq27Ztev31102o7B8Z5ThUr149bdu2TZUrVzYtp7fso+rWratDhw6pTZs2TufKnDmzPv/8c82cOdOhScntUbRoUf3+++8aMmSIAgICTMlZs2ZN7d+/Xx06dDAlnyfx8/PTt99+q7Vr15r2+fL19dWrr76qQ4cOqVKlSqbkNFt6jJvs7d+bt2VX7DvdyZPHYhnl+OpNMmfObBiPjY11cyXp69atW+rRo4cSEhIs2nx8fDRz5kzlypXLoq1NmzZ65ZVXDHMuXLhQM2fONL1WM1m7zhMXF+fmSlL3+OOPG8bDw8Pd0r+1fqzV9W9HjhwxjNepU8epmqypW7euYfzo0aNpruvNr7On8NTrSGbx9HM9T7427sm1uYOnX+Px1nMTbzsvsfU8NSOcx6fHe+Pn56dFixbptddecypPcHCwFi1apD59+li0BQQEaPny5Xr77bedugGOn5+fJkyYoM8++8yJSj3/uJQWTz43l8wf15g5pvHW/TYAAAAAAAAAAAAAAADgDs2aNVPDhg1NyZUpU6YUj2/fvm1K3tQULlw4xePLly+7vE8AAB5GiYmJGjBggPbs2ZMcy5w5szp27OjyvhcuXJji8RNPPGGxTFJSkqKjo1PEcuTI4XTfD+a4fv26TevNnDlTpUuXVrt27TRlyhTt27dPUVFRSkhIUHx8vCIiIrRr1y5NmDBBTz75pKpWraqtW7ca9puYmPjQ/YYXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOD9jh8/btNyfn5++vbbb7V27VoVK1bMlL59fX316quv6tChQ6pUqZIpOVNTr149bdu2TZUrV3Z5X670119/6dVXXzVsq1ixosaMGePmimwzefJkw/iTTz6pEiVKmNpXaGioXTU87FatWqWkpCSLeKZMmVSnTp10qMg+r7zyimHc2vt9/vx5bdiwwSIeEBCg559/3tTazLJy5UrFxcVZxPPmzau6des6lbtAgQKqXr26YdvTTz/tVG5Jat++vWH8wfvhOuK9997TggULlCtXLqfyPP3009q1a5ceeeQRp2vyVEWLFtXvv/+uIUOGKCAgwJScNWvW1P79+9WhQwdT8nkDPz8/LVq0SK+99ppTeYKDg7Vo0SL16dPHoi0gIEDLly/X22+/LR8fH4f78PPz04QJE/TZZ585UaltvvzyS02ZMkVBQUFO5ypbtqy2bdum119/3YTKrHPVuNAVY2Z7x8txcXGaO3euYZsrjnNdunRR1qxZLeIzZ87U3bt3Te/PEZ988olmzJhhWKe9XHHMqFixosLDw9W1a1dT8rVu3Vrbt283bRt0ljduk9583DRrfCR57hgpa9asWrp0qWbOnKncuXObkrNAgQJatWqVPvzwQ1PyOcubt0F79e3bV7/88ovKly9vWs6goCB9+eWXWrdunYKDgx3KkTNnToWFhWn06NEKDAw0rbbq1atrz549ql+/vmk5zWTrdcKHaRs9dOiQRSy1Y5vRGN9ZOXPmVOvWrS3iN27c0JIlS0zvL61avPmz4enjwrp16+rQoUNq06aN07kyZ86szz//XDNnzpS/v78J1bmOt29XDwOjfWFavP1vSp6+v/Dm1zcjX197mMcIAAAAALyLb3oXAAAAAAAAAAAAAAAAAAAAAAAAAJilb9++mjx5snx90/7ZTHx8vKKiohQZGWk40a+R5s2ba9OmTQ5PaGWmqlWrasuWLSpevLipecuUKaNffvlF2bJlMzWvNcOHD9c777xjas5HH31U69evV86cOU3N6wmOHTvm1v7y5s2rLVu26JlnnjE9t4+Pj4YPH67Ro0fbvW6ePHkUFhamevXq2bR8bGysrl27pujoaJuWz5cvn5YvX66SJUvaXZstHqbt/vDhw+ldgteaMGGC6ZMy+/n56csvv9R7773ndK6MchwqW7asVq9ebWp/3rKPatq0qTZs2KA8efI4ledBvXr10rRp00zN+W/lypXT9u3bbZ5MPDY2VlFRUUpMTExz2SxZsuinn35S7969nS3TY2TOnFnLli1T//79XZK/ZMmS2rZtmxo1auSS/M5w97jJ3v69eVt2xb7TnTx5LJZRjq/epmDBgobxyMhIN1eS/nbs2KFRo0YZthUpUkSTJk1KEcuXL5+mTp1quPz58+f18ssvm16j2azdVMXWa0Xu8thjjxnGDx486Jb+rfXz6KOPprnu9u3bDeOtWrUy5QYK/xYcHGx1MmdrdfybN7/OnsBTryOZxdPP9Tz52rgn1+YOnn6Nx1vPTbzxvMSW89SMcB6fXu/Nt99+a+oxaNKkSWrQoEGK2Ny5c025ccR9b775pgYMGODQup5+XEqLJ5+bS64b15gxpvHW/TYAAAAAAAAAAAAAAADgag0aNFBYWJg2bNigL774Qj4+Pk7nLFu2bIrHFy9edDpnWho3bpzi8V9//eXyPgEAeFglJiZq/PjxKWINGzZ0eb9HjhxJ8dja71wjIiJSPH5wbOKIB3Ncu3bN5nUTEhK0YsUKvfjii3riiSeUO3du+fv7KzAwUPny5VPt2rU1aNAgbd26NcV6WbJkUaFChZIfX7582bknAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAOjh27Fiay2TOnFnLli1T//79XVJDyZIltW3bNjVq1Mgl+aV/7n24evVqZcuWzWV9uNOcOXM0f/58w7aBAweqefPmbq4obcuXL7e4r6Uk+fj4qGfPnqb1U6xYMYv7akvSjRs3tHjxYtP6yUiuXLlicW/S+6pWrermauyTPXt2PfvssxbxU6dOKSwszOp6kydPNoz369fPtNrMFBsbqzVr1hi2tW/f3qncTz/9tHx8fAzbypcvr0ceecSp/Eb13bp1S+vWrXMq78CBAzVq1Cincvzbo48+qvXr1ytnzpym5fQU5cqV0/bt21W5cmWblo+NjVVUVJQSExPTXDZLliz66aef1Lt3b2fL9ArffvutnnnmGdPyTZo0SQ0aNEgRmzt3rtq0aWNaH2+++aYGDBhgWr4HTZgwQa+//rqpOf38/PTll1/qvffeMzXvfa4aF7pyzGzveHnixImG8eeee06ZMmUysTLp+eefN4z/8MMPpvbjqOHDh+udd94xNaeZx4yqVatqy5YtKl68uPOF/UuZMmX0yy+/eMz5jzdtk9583DR7fCR53hgpb9682rJli6nH4/t8fHw0fPhwjR492vTc9vDmbdBeffv21eTJk+Xr65vmsvHx8YqKilJkZKTi4uJsyt+8eXNt2rRJwcHBdtWVJ08ehYWFqV69ejYtHxsbq2vXrik6Otqm5fPly6fly5erZMmSdtXlDrZcJ3yYtlFJOnz4sGHc2nGlSZMmKlasmKk1dO7cWYGBgRbxefPm6c6dO6b2lRpv/2x4+riwadOm2rBhg/LkyeN8Yf/Sq1cvTZs2zdScZvL27ephYW1faI23/03J0/cX3v76ZvTraw/jGAEAAACA9/FP7wIAAAAAAAAAAAAAAAAAAAAAAAAAM5QuXVpfffWV1Yl1//rrL82aNUvr1q3TwYMHdf369RTtWbJkUfny5VWvXj116tTJcFJrSapevbomTZqk5557zuynYLPChQtrzZo1yp07t9Vl4uLitHHjRq1YsUJHjhzRlStXFBUVpaxZs6pAgQIqXry4WrZsqbZt26pAgQIp1n3kkUc0ZcoUjR8/3qXPo3nz5vrggw8s4omJifrll1+0bNky7dmzR3///bdiYmKUPXt25cuXT1WqVFHr1q3Vpk0b+fsb/0SqVKlSmjt3rlq3bu3S53DfuXPntHnzZqvtJUuWNJz4JrV1jPz222/2FeaETJkyacWKFapevbrVZe7du6etW7dq9erV+v3333X58mVdu3ZNPj4+ypEjh8qWLasGDRroueeeU4kSJQxzDBkyRMePH9eMGTNsqsvHx0fz5s1TpUqVrC6zceNG/fTTT/r111914sQJ3b17N7ktICBAJUuWVKNGjdSrVy+LyUruy5Url5YsWaLatWubOnmHJ2z3f/75Z6rbXt68eVWxYkWLeEREhA4dOpRq7gcdPHjQruXxj9DQUL3xxhsW8Tt37mjt2rVavXq19u3bp0uXLik2NlZBQUHKnz+/ypYtq5YtW6p169bKmzev1fyjRo3SqVOntGDBAofqyyjHIX9/fy1atEjZs2dPc9mEhAQlJSWluZy37KPKlSunRYsWKWvWrFaXuX37tjZu3KjVq1frwIEDye9hYGBg8n6iWbNm6tChg3LlypVi3Z49eyo8PNzuutKSO3durVu3LtUJnHbv3q358+dr/fr1OnXqVIpJS3Pnzq1q1aqpRYsWCg0NVb58+SzW9/X11eTJk3XmzBlt3brV9OfgbrNmzUp1Eq7ExERt3bpVK1as0O7du3Xp0iVdu3Yt+bNapkwZtWrVSm3atLE6OWL27Nm1YsUK1atXz6b33dFx09mzZ3XmzJk0899nNG5yV9/W+r/Pm7dlV+w73ckTxmLWZJTjqzeydhOeK1euuLkSzzBixAi1aNFCtWvXtmjr1KmT+vTpo+nTp0uSpk6dqvz581ssl5iYqF69ellce/FE1iYst3Xic3cpUqSIYdzeczRHWevHWl3/tmnTJl29etXieJUlSxaNGTNGL7/8sik1StLIkSMNj1FRUVFav359mut78+uc3jz1OpJZPP1cz5OvjXtybe7g6dd4vPncxKzzEk85T7zPE8/j7ZFe54wdOnQwHFOcPHlS06dP15YtW3T27Fndvn1buXLlUuHChdWwYUN17dpVFSpUMMzp7++vKVOmqGLFirp7964GDx6szp07WywXGRmpOXPmaO3atTp27Jhu3rypoKAgFShQQNWqVVP79u3VokULq7WPGzdOmzdvtmvyf08/LqXFk8/NJXPHNe+++67h+o6Oabx5vw0AAAAAAAAAAAAAAAC4UmBgoBYtWpT8nZiqVatq8ODB+vzzz53K27179xSP9+/fb3XZKlWq6L333tOlS5cMvz9qi8KFC1t8V23dunUO5QIAALbZvn17isdFixZ1eZ/Xrl1L8dja7xz379+vUqVKJT8OCQnR4sWLneo7JCTEog9Xe/TRR1P8tsgdfQIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHg7nzp3T5s2brbaXLFlSJUuWtIifPXtWZ86csauv3377Lc1lZs2apTZt2lhtT0xM1NatW7VixQrt3r1bly5d0rVr15Q1a1YVKFBAZcqUUatWrdSmTRvlyZPHMEf27Nm1YsUK1atXT+Hh4XY9h7T4+/tr0aJFyp49e5rLJiQkKCkpydT+XeWVV15RvXr1VKxYsRRxHx8fzZgxQxUrVlRkZGQ6VWcpPj5es2fP1qBBgyzaQkNDNWrUKFP66dmzZ4p7Tt43d+5c3b5925Q+MqJ9+/bp8ccft4g/8cQT6VCN7Xr16qWsWbNaxKdMmZLqesuWLVNERITy5s2bIl6qVCk1b95cGzZsMLVOMyxYsEAdO3a0iD/zzDN66623HM7brl27VNvbtGmjCRMmOJS7YsWKKe5le9/KlSt1584dh3JKUt26dfXZZ59ZxBMTE/XLL79o2bJl2rNnj/7++2/FxMQoe/bsypcvn6pUqaLWrVurTZs28vf3t1i/VKlSmjt3rlq3bu1wbZ4md+7cWrduncWx4t92796t+fPna/369Tp16pTi4uJSrF+tWjW1aNFCoaGhypcvn8X6vr6+mjx5ss6cOaOtW7e65Hl4gg4dOujll1+2iJ88eVLTp0/Xli1bdPbsWd2+fVu5cuVS4cKF1bBhQ3Xt2lUVKlQwzOnv768pU6aoYsWKunv3rgYPHqzOnTtbLBcZGak5c+Zo7dq1OnbsmG7evKmgoCAVKFBA1apVU/v27dWiRQurtY8bN06bN2/W4cOHHX8BDISGhuqNN96wiN+5c0dr167V6tWrtW/fPl26dEmxsbEKCgpS/vz5VbZsWbVs2VKtW7e22A//26hRo3Tq1CktWLDAtJpdOS509ZjZnvHy/v37tWfPHlWrVi1FPEeOHGrfvr1+/PFHm59XakqXLq0GDRpYxLdt26Zjx46Z0oczmjdvrg8++MAi7uzxQjLnmFG4cGGtWbNGuXPntrpMXFycNm7cqBUrVujIkSO6cuWKoqKikreb4sWLq2XLlmrbtq0KFCiQYt1HHnlEU6ZM0fjx4x2u0Szesk1683HTVeMjyXPGSJkyZdKKFStUvXp1q8vcu3dPW7du1erVq/X777/r8uXLunbtmnx8fJQjRw6VLVtWDRo00HPPPacSJUoY5hgyZIiOHz+uGTNmuOqpWOXN26C9Spcura+++srw/F2S/vrrL82aNUvr1q3TwYMHdf369RTtWbJkUfny5VWvXj116tRJjRs3NsxTvXp1TZo0Sc8995xNdfn4+GjevHmqVKmS1WU2btyon376Sb/++qtOnDihu3fvJrcFBASoZMmSatSokXr16mW4T5KkXLlyacmSJapdu3aa50aedJ3Qk7bRP//8M9XXJW/evKpYsWKKWEREhA4dOpTKM7R08OBBw/i+ffu0d+9ei+smPj4+6tmzpz7++GO7+klNjx49DONTp041rY+0eOJnwx6ePi4sV66cFi1aZHiN677bt29r48aNWr16tQ4cOJA8LgwMDEze3ps1a6YOHTooV65cKdbt2bOn6dfczeDt21V6c2Q/KJm7L7TGm/+m5On7C8m7X9+H4frawzZGAAAAAOCdfJJs/Eu4tYv4ABASEqKQkBBJUlJSkk6fPq2dO3d6zRewAQAAAAAAAAAA4DnGjhub3iXgIXD0yFG+aA0gwxi4SMoUlN5VICM7f0ia6/h8ZgAAF/Px8VH16tVVrly55O97h4eHe+SEAg8DvlMLeIZly5YZTqybkJCgoUOH6vPPP1d8fLzN+apWraqJEyeqRo0ahu2dOnXS4sWLbc5nbZ9g7+92fH19tXXrVtWtW9ewPSEhQZMnT9awYcMUERGRZj5/f38NGDBAH374oXLkyJGi7f3339eHH35osU7Dhg0VFhZmc81Gz/2jjz5Sr169LCaBW7x4sYYMGaITJ06kmbds2bKaMGGCWrVqZXWZXr16afbs2TbXmlrNkuO/sxo+fLjha2n277bMrHv69OkKDQ212s/ChQs1bNgwnTx5Ms1cfn5+evnllzV27FgFBVle0IiOjlZISIhNk6UNHjxYn3/+uWHbrl271K9fPx04cCDNPPe1bNlSs2fPtjr5ymuvvaZvvvnG5nz3eeN2f1+7du20bNkyi/jSpUvVoUMHh/O62siRIzVs2DCL+NChQzV69GjT+gkMDDScwOr27dvKkiWLXbmMtpOvvvpKvXv3TrFPTkxM1LfffqtRo0bp0qVLaebNkiWLXn/9dQ0ZMkQ5c+Y0XCY2NlaVKlXS6dOn7ao5oxyHhg4dqtjYWH3xxRcWbZGRkVqyZIlWrlyp8PBwXb58WTExMTb15Q37qICAAO3fv9/qRE7338MRI0bowoULaebLmjWrBgwYoA8++CDFBHp37tzR5cuXVbx4cYt17H0P79uwYYOaNWtm2HbmzBkNGjRIy5cvtylX1qxZNXDgQI0YMcJwsrDLly+rfPnyunHjht11egpr44/7Vq5cqXfffdemyeozZ86sgQMHasiQIRaf1fvOnTunypUrKyoqyuGaJet1f/TRR/rf//7nVG5P6dsbtmV37jvT6leyfzzrbWMxbzy+usKZM2cMJ1bu0aOH5s6d67J+Dxw4kHxt79+++eYbvfbaa6b3Z228HRERYThBc3ooXbq0Dhw4oODgYIu26OhoValSRc2aNdP3339vuP6nn36qd955x9VlmmLQoEGG+7WsWbOmmEw7Pfn7++vu3buG+8JGjRppy5YtLq+hdu3a2rFjh0Xc1vOgDz74QO+//75h2yuvvKKJEyc6XWOPHj00c+ZM+fr6WrR98sknGjJkSKrrZ4TXOT156nWk+/0bsWd84ennep58bdyTazOTN17jkbz73MToJqdmnZf8mzvPUb3pPN6TzhlHjRqlPn36qEiRIsmxGzduaNCgQZoxY0aqf7P38fHRyy+/rC+++MLqsXbgwIFasWKFjh07psDAwOR4YmKixo0bp5EjRyo6OjrVuuvXr69p06bpkUceMWzfuHGjmjdvnmqOf/P049J93nZufp+Z45r+/fubNqaRvGO/DQBAevDx8VGNGjVUtmxZvk8LwGbOfMebudoBWMPvSgAAAAAAAID09d///ldjxoxJfpyQkKDOnTtr6dKlFss+8cQT2rNnjyRp3Lhxevvtty2WqV+/vjZt2pTi+zXVqlXT3r17LZZdvHhx8m+wExIS9NRTT+nnn3+2q/6AgACtXr06xXeEIiMjVaRIEd2+fduuXEbGjh2rt976v0nlrD1vs6VXvwAA2HK8l6Ts2bOn+M7skSNH9Pjjj7u0tubNm2v9+vXJj7dv36569epZLDdkyJAU86Vs3rxZjRs3dqrvLVu26Mknn0x+/Prrr+vrr792KmdaBgwYkKKP0aNHa+jQoS7tEwBgvldmStnzp3cVgHXjO0p3Y9O7CgDphbnaPQvfqQUAAAAAAAAAAAAAAAAAAHAv5moH4AjmagfgCvyuBAAAAAAAADBXq9at1KRJk/QuAw+Z1atWa9OmTeldBgC4BcdapJfFixZrx44d6V0GALhF89ekqk+ndxV42Kz/Stq/Kr2rAAD3Yq52z8J3agHPNXz4cH344YcW8Y8++kj/+9//3NLXfStXrtS7776rw4cPp5krc+bMGjhwoIYMGaIcOXIYLnPu3DlVrlxZUVFRdtdqtH8aOnSoYmNj9cUXX1i0RUZGasmSJVq5cqXCw8N1+fJlxcTE2N2vmc6cOaOSJUtaxMuUKaPTp09bxBs2bKhffvlFvr6+Fm1LlixRx44dHa7l4MGDqlixokW8SJEiunDhgkM5K1asqIMHDxq21a5dW7t27XIo778dO3ZM5cuXt4hXr149+b6gjrD23vTo0UNz585N93zOeuedd/TJJ59YxK3dozQ17nxuRttpQkKCihUrposXL6a67ueff67BgwdbxJ397LhKUFCQrl69qixZsli0VahQQUePHrU7Z6ZMmRQZGamsWbNaXebnn39Oca96ewwbNkwjR460iHfo0EFLly5Nc31r484jR46oQoUKKWKLFy/WkCFDdOLEiTTzli1bVhMmTFCrVq0M23v16qXZs2enmcfWeu39LatZeSRpw4YNVt+/M2fOaNCgQVq+fLlNubJmzaqBAwdqxIgR8vf3t2i/fPmyypcvn+Leyu7kytd/1KhR6tOnj4oUKZIcu3HjhgYNGqQZM2akeo7k4+Ojl19+WV988YXh51eSBg4cqBUrVujYsWMKDAxMjicmJmrcuHEaOXKkoqOjU627fv36mjZtmh555BHD9o0bN6p58+ap5rDG6Pl99dVX6t27d4oxXWJior799luNGjVKly5dSjNvlixZ9Prrr2vIkCHKmTOn4TKxsbGqVKmS4TjI3ppdOS5055jZ1vHyyy+/rIkTJ1rE169fr6eeeirNOmwxYsQIw/OP3r17a9asWWmu78rP7UcffaRevXqpRIkSKeJmHi8kx48Zvr6+2rp1q+rWrWvYnpCQoMmTJ2vYsGGKiIhIM5+/v78GDBigDz/80GK7ef/99w23z4YNGyosLMzu2h3lDdukNxw302t8JDm2vZs5rpk+fbpCQ0Ot9rNw4UINGzZMJ0+eTDOXn5+fXn75ZY0dO1ZBQUEW7dHR0QoJCdGZM2fSzMXYzTHLli1Tu3btLOIJCQkaOnSoPv/8c8XHx9ucr2rVqpo4caJq1Khh2N6pUyctXrw4zTyDBw/W559/bti2a9cu9evXTwcOHLC5rpYtW2r27NnKkyePYftrr72mb775xuZ8Rtx5ndCbttF27dpp2bJlKWJLly5Vhw4dHMpnpF+/fvr+++8t4idPnlS5cuVM6aNIkSI6d+6cxT7lyJEjevzxx03pwxbe8tnwxnFhQECA9u/fb3Ecv+/+uHDEiBE2XZPNmjWrBgwYoA8++CDF9Z47d+7o8uXLKl68uMU67h4X3ucN29XIkSM1bNgwi/jQoUM1evRou3KlJjAwUHfu3EkRu337ttXrCLYw2g9K5u8LH+Qtf1Pyxv2F5N2v78N0fe1hGiMAAADXYq52AI6w5Tvelt80BAAAAAAAAAAAAAAAAAAAAAAAALxMnjx51Lp1a8O2rl27asyYMXZNZCVJ+/btU926da1OoPzBBx/YW6YpXnrpJasTF966dUvNmzfXK6+8YtPEhZJ07949TZgwQY8//riOHz+eou2///2v0y0JevoAARkUSURBVPVa07dv3xQTe8THxys0NFSdOnWyaWIP6Z/JG9q0aWM4scN977zzjtO1PoxatGhhdbK/uLg4Pfvss+ratatNk/1J/0ye9N1336lWrVqGE4UHBwcbTlz9oBw5clidUG3atGmqW7euXRMVSdLatWtVp04dXbt2zbD9rbfeMpz03xFs97DFSy+9lGISoBs3bqhp06Z6/fXXbZrkWfrnc/rpp5+qSpUqVn+QnjVrVk2YMMGh+jLCcShr1qwaOnRoitjt27c1evRolSpVSi+++KKWLl2q06dP2zwxtbfsowYPHmx1srvIyMjk99DWG5DExsZq7NixCgkJSXFcyJQpk+Fkd47q1auX1Qkww8LCVKNGDZsnwJT+qfvjjz9W06ZNDSfWKlCggKkTzLlbpUqVrG6P8fHxeuGFF9S2bVubJimT/vl8jBkzRpUqVbK6XylWrJjVCQXxf7x5W3bFvtOdPHksllGOr96oVq1ayTdlfNCvv/7q5mo8x+nTp/Xaa68ZtgUHB2vx4sVW9/l79+41nLzVUxlNSi/9s3/7typVquj555/X2LFjtWjRIm3cuFG7du3Svn37tGPHDm3YsEE//vijPvroI3Xv3l1FixY1rcZcuXJZneT+1q1bpvWTGmv9ZM6c2aYJcz///HNduXLFsO27777TqFGjUkweag8/Pz+9++67mjFjhuHY+Nq1axo7dmyaeTLC65xePPU6klk8/VzPk6+Ne3Jt7uDp13i8/dzk37zpvMSajHAen17njH379k0x0fnp06dVtWpVTZ8+Pc2J+JKSkjRx4kS1b99ed+/eNVxm4MCBGj16dIqxSlxcnFq1aqV33nknzYnOJWnbtm1q2LCh1ZseNWvWzPBmu0Y8/biUFk8+N5fMH9eYOabx5v02AAAAAAAAAAAAAAAA4A5ffPGF9u/fn/zYz89PixYt0vDhw+3+vnqvXr20Zs0a+fv7J8dWrlypvXv3Gi5//vz5FP2uWLFCPXv2tLm/QoUKac2aNRbfEXr//fctft8AAAD++Q52w4YNTcmVKVOmFI/dcewtXLhwiseXL182XG7nzp0pHj/55JPKnz+/w/0WKlRI9evXTxHbtWuXw/ls1bFjxxSPd+zY4fI+AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwp0qVKul///ufYVt8fLxeeOEFtW3bVocPH7Yp3+3btzVmzBhVqlRJ4eHhhssUK1ZMn3/+ucM1Pyhr1qwaOnSoRR2jR49WqVKl9OKLL2rp0qU6ffq0YmJiTOvXXbZs2aJx48YZtnXo0EF9+/Z1c0WpO3TokHbv3m3YFhoa6nT+GjVqqHz58hbxgwcPas+ePU7nz8jOnTtnGC9WrJibK7FdnTp1VLFiRYv46tWrdfHixTTXnzx5smG8bdu2KlSokNP1mS0mJkZr1641bHvmmWccytmkSRNlzZo11WWefPJJZcuWzaH87du3t4il9jxsVaFCheT/x8fHKzQ0VJ06ddKJEydsWv/kyZNq06aN1fZ33nnHqfo8Ra9evdSsWTPDtrCwMNWoUUPLly+3OV9sbKw+/vhjNW3aVFFRURbtBQoU0OjRox2u15P17dtXRYoUSX58+vRpVa1aVdOnT1dSUlKq6yYlJWnixIlq37697t69a7jMwIEDNXr0aAUGBibH4uLi1KpVK73zzjuKjo5Os8Zt27apYcOGOnPmjGF7s2bNDI+RjnrppZeUI0eO5Mc3btxQ06ZN9frrr+vSpUs25YiLi9Onn36qKlWqWB0bZs2aVRMmTDClZleNC909ZrZ1vDx37lzD59GsWbMU27MzevfubRG7fv26Fi5caEp+Z/Tt21clSpRIfuzM8eL777+3uoyjx4yXXnpJdevWNWy7deuWmjdvrldeeUURERE25bt3754mTJigxx9/XMePH0/R9t///tehGs3m6duktx83zRofuWJ7N0OLFi2snjPGxcXp2WefVdeuXXXy5Emb8iUkJOi7775TrVq1DM8dgoODNXLkSKdqtpe3b4P2yJMnj1q3bm3Y1rVrV40ZM0bx8fF25dy3b5/q1q2ruXPnGrZ/8MEHaebIkSOH1WP6tGnTVLduXR04cMCuutauXas6dero2rVrhu1vvfWWfH197cqZXh6mbdRW1o5tZcuWVe3atU3p47nnnpOPj49FfOrUqabkt4W3fzY8fVw4ePDgFMfxf4uMjEweF164cMGmfLGxsRo7dqxCQkJSHBczZcqk4sWLO1SjK3j7dgVj3v43JU/fX2SE1/dhub72sIwRAAAAAHgvrpAAAAAAAAAAAAAAAAAAAAAAAADA6z399NPy9/e3iM+bN0+LFi1yOO+9e/fUq1cvbdmyJUV8zZo1GjhwoMN5HZUtWzaNGjXKsO3WrVtq0qSJNm3a5FDuv//+Ww0aNNDRo0eTY0FBQQ7lskXhwoWT/5+YmKhOnTpp5syZdudJSkpS//79tXHjRsP2ihUr6qmnnnK4zoeRn5+fvv32W8O2uLg4NWrUSD/99JNDuQ8fPqymTZvq1q1bFm1VqlRR5syZ06xtxowZiouLSxFfsWKF+vbtq8TERIfqOnnypPr162fYVrJkSbVt29ahvA9iu4ct/v05iI2NVZMmTbR582aHcp09e1Z169bVrl27DNuffvppNW7c2OZ8Gek41LVrV+XNmzf58ZUrV9SoUSMNHTpUN2/edCinN+yjcuXKpeHDhxu2RUZGqnbt2g6/h3/88Yfq16+vP//806H1U5MlSxaNHTvWsG3fvn1q0aKF1Unn0hIWFqbu3bsbTn7Vr18/j5q0zx4TJ040HB/Hx8erZcuWDk9Qde7cOdWtW1dhYWGG7X369FH9+vUdyv0w8PZt2RX7Tnfy1LFYRjq+epvAwEBNmTLFsO3WrVtasWKFmyvyLDNmzLB67hcSEmJ4c6O4uDh1797d7gnF05PRDZhu376tpKQk1atXT9OmTdOlS5e0b98+TZ06VW+99ZY6duyopk2bqmbNmqpSpYpq166tZs2a6dlnn9XQoUM1Z84cnTt3TkePHtXQoUNVoEABp2pM7VzZ6PzaFVLrJ1OmTGmuf/PmTas3zvPx8dF7772ngwcP6tVXX01x45vUBAUF6YUXXtC+ffv08ccfy8/Pz3C5l19+WZGRkWnmywivc3rw5OtIZvH0cz1PvjbuybW5gydf48kI5yb3edt5iTUZ4Tw+vc4Z/32D0YiICDVu3NjqpOLWrF+/XmPGjDFsK126tLp165b8ODExUR07dtT69evt6uPChQvq2bOn1fZXX33VpjyeflxKi6eem0uuG9eYMabx9v02AAAAAAAAAAAAAAAA4A7x8fHq2rWrrl69mhzz9fXVhx9+qFOnTul///ufqlatKl9fy1u4ZsqUSZUrV9agQYMUHh6umTNnKjg4OLn9ypUreu2116z2PXToUJ06dSr5cZYsWTRr1izt3r1bAwYMUIUKFRQQEJBinaCgIDVu3Fhff/21Tpw4oaZNm6Zo37Jli7777ju7XwcAADKyBg0aKCwsTBs2bNAXX3whHx8fp3OWLVs2xeOLFy86nTMtD/4G5K+//jJcbvPmzTp37lzyY19fXw0YMMDhfl977bUUY6ETJ07o999/dzifLUqVKqUnn3wy+fG1a9e0bt06l/YJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIC7TZw4Uf7+/hbx+Ph4tWzZUlOnTnUo77lz51S3bl2FhYUZtvfp00f169d3KPeDunbtqrx58yY/vnLliho1aqShQ4fq5s2bpvSR3oYOHap9+/YZtn355ZcqU6aMmytK3eTJkw3j3bp1s7hvtr369OljV5/4P5cuXTKMFyhQwM2V2O6VV14xjNv6fh85ckS7du2yiPv7+6tv375O1eYqCxYsMIy3b9/eoXzt2rVLc5mAgAC1aNHC7txFihRRtWrVLOKrVq3S7du37c5nJDExUZ06ddLMmTPtXjcpKUkbN240bKtYsaKeeuopZ8tLV1myZNHYsWMN2/bt26cWLVro2rVrDuUOCwtT9+7dlZSUZNHWr18/FS9e3KG8nqxQoULJ/4+IiFDjxo115swZu3KsX79eY8aMMWwrXbq0unXrlvw4MTFRHTt21Pr16+3q48KFC+rZs6fV9ldffdWufKnJnDlz8v9jY2PVpEkTbd682aFcZ8+eVd26dQ33yZL09NNPW9xD2xGuGhe6esxsxJbxcnR0tH788UeLuK+vr3r16uVQTf/WqFEjlShRwiI+Z84c0/bzzihcuHDy/509XvTv39/UY0a2bNk0atQow7Zbt26pSZMm2rRpk921StLff/+tBg0a6OjRo8mxoKAgh3KZzZO3yYx03PS07d0Mfn5++vbbbw3b4uLi1KhRI/30008O5T58+LCaNm2qW7duWbRVqVIlxfHOlTLSNmiLp59+2vDYOW/ePC1atMjhvPfu3VOvXr20ZcuWFPE1a9Zo4MCBaa7v5+enGTNmKC4uLkV8xYoV6tu3rxITEx2q6+TJk+rXr59hW8mSJdW2bVuH8rrTw7aN2urWrVtWz9OtXaOyl9H4/t69e5o1a5Yp+W3h7Z8NTx4X5sqVS8OHDzdsi4yMVO3atR0eF/7xxx+qX7++/vzzT4fWdzVv365gzNv/puTJ+wvJ+1/fh+n62sMyRgAAAADgvXzTuwAAAAAAAAAAAAAAAAAAAAAAAADAWdYm3XZksogHJSYmqm/fvoqOjtb06dNVsWJFtW7d2uHJYJwRGhqqPHnyGLa98cYb2r17t1P5r169queee07x8fFO5bHX0KFDtWLFCqdy9O3bV3fu3DFss2XSZfyfjh07Wv1Mvfrqq/rtt9+cyn/06FG99tpryY937dqlZ555RhUrVkxzssjIyEgNHjxYJUqU0JgxYxQdHa2oqCiFhoY6VZMkLVq0yOpnqGnTpk7nfxDbPWzRv39/7d2716kcMTEx6ty5syIiIgzbbZmc8b6MdBx65JFHkv8fFRWlOnXqWJ0Q21besI964YUXDCcnTkpKUo8ePXTy5EmHa5T+meS7Y8eOunfvnlN5HtSjRw/Dm2TcuHFDHTp0sLovtNXatWv19ddfW8T9/Pz0xhtvOJU7PTRs2FB16tQxbHvzzTf1yy+/OJU/JiZGXbp00YULFwzb33vvPafyZ2Tevi27Yt+ZXjxpLJaRjq/eJDg4WKtWrdLjjz9u2D5jxgxFR0e7uSrP89JLL+n8+fM2Lz948GAdP37chRWZz2hs5Ovrqz179mjbtm3q06ePwzfrevTRR/XRRx/p3LlzmjBhgnLkyOFQnkyZMlltM5pQ3xVS6ye1+v5t1apVGjx4sNX2cuXK6ZtvvlFERIQOHDigadOmafTo0frvf/+rAQMG6O2339bo0aM1ZcoU7d27V1FRUZo8ebIqVapkNee7776rxYsX21RfRnmd3c2TryOZxdPP9Tz52rgn1+ZunnaNJ6Ocm3j7ecl9GeU83hPOGUNDQ/XXX385tO4nn3yiq1evprnc2LFjtXbtWof62L59u9Wxia0T1Xv6cckennRuLrl2XOPsmMbb99sAAAAAAAAAAAAAAACAu5w4cUJNmzbVuXPnUsSLFSumESNGaO/evbpz547WrFmT3Pb6668rLi5O+/fv1xdffGHxHfUrV66oadOmOnv2rNV+b926pZYtW+rMmTMp4tWqVdPXX3+tw4cP6/bt27p+/bouX76s2NhYRUdH65dfftGAAQMUHBycYr09e/aobdu2SkhIcPSlAAAgwwkMDNSiRYvUoEEDSVLVqlVT/b2arbp3757i8f79+60uW6VKFS1YsEBffvmlw/0VLlxYnTt3ThFbt26d4bJJSUmaNm1aithbb72lokWL2t1v8eLF9eabb6aITZo0Kc31MmfOrO7duzv8nfXRo0fL398/+fG8efP4zTMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIENp2LCh6tSpY9j25ptv6pdffnEqf0xMjLp06aILFy4Ytr/33ntO5b/vkUceSf5/VFSU6tSpo127dpmS21Pcu3dPzz33nOLi4izagoKCNHfuXPn5+aVDZcbmzZtnWGuuXLn09NNPO5w3ICBA3bp1s4jfvXtXc+bMcTjvwyI6OtowHhgYKB8fHzdXk7YcOXKoS5cuFvHLly9r1apVNueZPHmyYfzll1/2yOe9YsUK3b592yJes2ZNFSxY0O58D37m7t27py1btlgs17ZtW7tzP/PMM4bxBQsW2J3LmqFDh2rFihUOr9+3b1/duXPHsK1du3YO5/UEPXr0UIECBSziN27cUIcOHaw+b1utXbtWX3/9tUXcz89Pb7zxhlO5PV1oaKj++usvh9b95JNPdPXq1TSXGzt2rNauXetQH9u3b9fixYsN25566imHcqalf//+2rt3r1M5YmJi1LlzZ0VERBi2Dxw40Kn8kmvGhe4YMzszXv7hhx8M43379nWqLkl6/vnn7eozPTl7vJDMPWaEhoYqT548hm1vvPGGdu/ebXd9/3b16lU999xzHnnvdU/dJjPScdPTtnczdOzYUWXKlDFse/XVV/Xbb785lf/o0aN67bXXkh/v2rVLzzzzjCpWrGg49naFjLQN2sLa+zlz5kyncycmJqpv376Kjo7W9OnTVbFiRbVu3VqbNm1Kc93IyEgNHjxYJUqU0JgxYxQdHa2oqCiFhoY6XdeiRYus7t+bNm3qdH5Xe9i2UXtMmjTJMN61a1dlypTJqdwVKlRQ5cqVLeKrV6/WlStXnMptj4z02fC04+QLL7ygoKAgi3hSUpJ69OihkydPOlTjfVeuXFHHjh117949p/K4QkbarvCPjPI3pfs8bX+R0V7fh+H62sMwRgAAAADgvXzTuwAAAAAAAAAAAAAAAAAAAAAAAADAWYULFzaMnz592pT8p0+fVsGCBfX888/r8OHDpuR0xL8nSfu3NWvWaPr06ab0ceDAAX366aem5LLFvn37TOnv3LlzWrRokWFb/fr1nc7/MBk0aJBhfPny5aZtZzNnztSECRPUsGFD1a5dW8uXL7dr/atXr+rdd99V8eLF9fTTTysqKsqUuqxNWNmgQQNT8t/Hdg9bhIWFmTIpoySdP39e//nPfwzb2rZtqyJFitiUJyMeh6R/JrE1a8wgefY+qn///obx6dOnOzxJ04P27dunr776ypRc9w0YMMAwPmHCBJ09e9aUPsaOHWs4UV/Pnj1Nye9Ob731lmF8/fr1hpN9OuLKlSt64YUXDNtatWqlxx57zJR+MpqMtC2bve90J08bi2XU46sna9WqlX777Tc1a9bMsD0qKkqjRo1yc1We6fr16+rVq5cSExPTXHbFihWaOHGiG6oyV3BwsEUsMDBQTzzxhGl9BAQE6I033tDJkyfVvHlzu9f39bU+Pczdu3edKc1mqU06bs+N8MaPH68+ffoY3qzuPn9/f4WEhKhPnz4aMmSIxowZo6+//lqffvqphgwZor59+6pq1aoKCAiwmuP27dt6+eWXNWbMGJtry0ivszt5w3Uks3jquZ4nXxv35NrcyROv8WSUcxNvPi/5t4x4Hp8e783y5cu1evVqh9ePjY1N84aaFy5c0IgRIxzuQ5KmTp1qGC9Xrpxy5sxpcx5PPS7ZytPOzSXXj2ucGdNklP02AAAAAAAAAAAAAAAA4A4HDx5UlSpVNG/ePCUlJVm0+/v7K3/+/MmPM2XKJB8fH8NcixYtUsWKFXXo0KE0+/3jjz9Us2ZNzZ4927Dd19dXOXLkUP78+ZUlSxbDZZKSkjR+/HjVq1dPt27dSrNPAAAeJnfv3tW4ceNSxD799FO1b9/e4Zz169dXv379UsQWL15suOzixYu1b98+denSRa+++qqaNm1qd38BAQGaMWOGgoKCkmORkZHatGmT1XW+++473bx5M/lx1qxZtXz5cmXLls3mfrNnz64VK1Yoc+bMybFr165Z/X679M/vLL///ntdunRJc+bM0VdffaWSJUva3Kck9enTR926dUt+fPfuXX355Zd25QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwNO99dZbhvH169fr66+/NqWPK1eu6IUXXjBsa9WqlR577DFT+rnv+eef1+nTp03N6SmOHz9u9T2rWbOmhg8f7uaKrLt586bVe22GhoY6nLdNmzbKnTu3RXz58uW6du2aw3kfFrdv37ba9u/7h3qK3r17G95bfcaMGUpISLA5z/z58xUTE2MRL168uFq2bOlUja4QExOjtWvXWsR9fHzUtm1bu3JVrlxZRYsWTRHbtm2bpk2bZrFsmzZt5OPjY1d+o3v0xsbGas2aNXblsWbfvn369NNPncpx7tw5LVq0yLCtfv36TuVObwMGDDCMT5gwQWfPnjWlj7Fjx+revXsW8Z49e5qS3xMtX75cq1evdnj92NhYLViwINVlLly4oBEjRjjchySr93kuV66ccubM6VTuB4WFhWnmzJmm5Dp//rz+85//GLa1bdtWRYoUMaUfybxxoTvGzM6Ml3ft2qWDBw9axMuWLas6deo4XFNQUJA6depkEf/9998VHh7ucF5XMON4IZl7zHjttdcM42vWrNH06dPtLc3QgQMHTHneZvPUbTKjHDc9cXs3w6BBgwzjy5cvN+0zM3PmTE2YMEENGzZU7dq1tXz5clPy2iqjbIO2Kly4sGHcrGs2p0+fVsGCBfX888/r8OHDdq9/9epVvfvuuypevLiefvppRUVFmVLXDz/8YBhv0KCBKfld6WHbRu2xY8cOw+0sZ86cateunVO5rT13a+N9V/P2z4YnHif79+9vGJ8+fbrh9R9H7Nu3T1999ZUpuVzB27cr/J+M9DclT9xfZKTX92G5vvYwjREAAAAAeB/f9C4AAAAAAAAAAAAAAAAAAAAAAAAAcFZgYKBhPCkpybQ+jCYtdqfy5curfPnyhm2jRo0yta8JEybo7t27pua0Zvjw4UpMTDQll7XJFipWrKgcOXKY0kdGV7BgQauTQY4ZM8bUvgYNGqSwsDCnckRFRWn79u0mVSRt2rTJMB4SEmJ1P+MItnvYwtlJcx40d+5cXbx40SLu6+ur1q1bp7l+Rj0OLVq0SMuWLXNJbk/bR5UvX16lS5c2bPvss8+cqu1BH3/8sWnvYYkSJVSlShWLeExMjMaPH29KH9I/E4UZ3TShQIECqlatmmn9uFr27Nmt3lTj448/NrWvtWvX6sCBA4ZtXbp0MbWvjCAjbcuu3He6gyeNxTLq8dUTFStWTG+88YZ27Nih1atXpzqh4sCBA3Xp0iU3VufZNm/enOZY4fLly+rbt6+bKjJXUFCQ2/rKly+f1q5da3Wi/YfFjBkzVKlSJS1ZssQl+VesWKHKlStr0qRJLsmP/+Nt15HM4mnnep58bdyTa3MnT7vGk1HOTbz9vOS+jHgen17vzciRI53OYe2GuvdNmDBBsbGxTvWxfv16w32Xj4+PatSoYXc+Tzsu2cqTzs0l941rHBnTZJT9NgAAAAAAAAAAAAAAAOBOkZGR6t69u6pUqaLvv/9eERERNq975coVTZ06VVWrVlXnzp119epVm9eNiIhQr169VLVqVU2bNk2RkZE2rRcdHa3JkyerUqVKGjx4sO7cuWNznwAAPEy++OIL7d+/P/mxn5+fFi1apOHDh9v9fedevXppzZo18vf3T46tXLlSe/fuNVz+/PnzKfpdsWKFevbsaXN/hQoV0po1a9SsWbMU8ffff1+3b9+2ut6lS5f01ltvpYhVrVpVmzZt0uOPP55mv48//rg2b96skJCQFPGBAwemOla5e/euypcvn/yd7GzZsmn16tUqXrx4mn1K0quvvmrxG79PPvlEJ0+etGl9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJ4tW7ZsKlKkCP/459Z/2bNnT+9NHwAAAAAAAAAAAAAAwEL27NnVsmVLw7aPP/7Y1L7Wrl2rAwcOGLZ16dLFtH4WLVqkZcuWmZbPE3377bdavXq1YdvQoUNVp04dN1dk3eTJkw3jrVu3Vp48eRzK2adPH7v6Qkr37t2z2hYQEODGSmzzyiuvGManTJliV57o6GgtXLjQsK1///521+UOCxYsMIy3b9/erjxt27a1iC1btkyrVq1SYmJiinjevHlVq1Ytm3Nnz55djRo1soivXr1asbGxdtVpzfDhwy3qdMTUqVMN4xUrVky+D663KVGihKpUqWIRj4mJ0fjx403r59y5c1qzZo1FvECBAqpWrZpp/XiSkSNHOp1j8eLFqbZPmDDB6c/J+vXrFRMTYxH38fFRjRo1nMr9oBEjRpiab+7cubp48aJF3NfXV61btzalD7PGhe4aMzs7Xv7hhx8M43379nW4pi5duigoKMgiPnHiRIdzuopZxwvJnGNG+fLlVb58ecO2UaNGOVybkQkTJuju3bum5jSDp22TGem46WnbuxkKFixo9Vx2zJgxpvY1aNAghYWFmZrTFhlpG7RVYGCgYTwpKcm0PozGQvaKiorS9u3bTajmH5s2bTKMh4SEWH1NPMHDuI3aa9KkSYZxa9eqbNW9e3eL2NWrV7Vq1Sqn8jrLWz8bnnacLF++vEqXLm3Y9tlnnzlcm5GPP/7YI8eF/+at2xX+kdH+puRp+4uM9vo+TNfXHrYxAgAAAADv4Z/eBQAAAAAAAAAAAAAAAAAAAAAAAADOioqKMoyXLl1aJ0+edHM1rmFtwokDBw7o119/NbWvq1evavHixerWrZupeR/0559/auXKlabl27lzpxITE+Xr65si7uvrq1KlSmn//v2m9ZVRtWzZUj4+PhbxvXv3mjopkKc6deqUbty4YTEZjK+vr3Lnzq1Lly453QfbPWzx559/6ueffzY157179zRp0iQNHz7coq1ly5ZWJ8j59zJGvPk4JMnUSRRdzdl9VIsWLQzjYWFhOnz4sGl1Sv+8h0uWLFHXrl2dztW8eXPD+MaNG62OAR0VFhZmeMOGhg0bas+ePab25SotWrSQv7/lT8jDw8O1efNm0/v7/PPPNWPGDIt4u3btTJ+w3ttlpG3Zm/adD/K0sVhGPb6arUOHDipZsqRNy/r4+ChLlizKli2bsmXLptKlS+vxxx9X3rx5bVp/9OjRmjVrlhPVZkyXL19OtT06OlpxcXFuqsZcwcHBaS5z9+5dHThwQHv27NGFCxd0/fp13bhxQz4+PsqRI4dy5syp0qVLq1atWipfvrzhefV9vr6++uKLL5SQkKCvvvrKzKfiNXx8fPTkk0+qcuXKLslfqVIlPfnkkzp58qSpE93D0sN+Hckszp7refK1cU+uzV088RpPRjk38ebzkn/LiOfx6fHehIeHa/fu3U7n2bt3r9W2pKQkTZ8+3ek+4uPjdejQIcObgNp63uNKD+vfSTx5XJNR9tsAAAAAAAAAAAAAAABAeggPD1f//v316quv6tFHH1W1atVUtGhRVapUSd27d5ck7dq1S/Pnz9f58+d16NAhHTt2zOl+9+/fr759+8rX11dVqlRRhQoVVLp0aWXPnl1BQUGKjY1VZGSkrly5ot9//13h4eFKTEx0ut/UvP3223r77bdd2ocn9QsAyJji4+PVtWtXbdu2Tfny5ZP0z/eGP/zwQ7344ouaNGmSVq5cqQMHDlismylTJj366KNq3Lix+vbtq0qVKqVov3Llil577TWrfQ8dOlStWrXSI488IknKkiWLZs2apUGDBmnatGnatGmTTp48qfj4+OR1goKCVLNmTXXq1EmhoaEWv2fcsmWLvvvuuzSf96RJk9ShQwe1atUqOVatWjXt3btXixcv1sKFC3X06NHk73sXLFhQFSpUUOfOndWxY0cFBgamyLdkyRLNmTMnzX4HDRqk3377LXn9xx57TIcOHdLs2bM1e/ZsHTp0SDdv3pT0z+8GCxUqpFatWunFF19U7dq1U+QKDw/XqFGj0uwTAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgHeoXr26Wrdpnd5l4CHzyy+/aM3qNeldBgAAAAAAAAAAAAAAQAotWrSQv7+/RTw8PFybN282vb/PP/9cM2bMsIi3a9dOI0aMMKWP8ePHm5LH0z3//PM6ePCg8ufPnyLu5+enOXPmKCQkRNHR0elU3f/ZvHmzTp8+rdKlS6eIBwQEqGvXrvr222/typcnTx61bm35/a/z589r/fr1TtUKz1OvXj1VqFDBIr5161adOHHC7nyTJk1Snz59LOKtW7dW0aJFdf78eUfKdJkVK1bo9u3bypw5c4p406ZNFRQUpJiYGJvytG3b1jB3RESEduzYoXr16lksv3PnTptyt27dWgEBARbxhQsX2rR+Wv7880+tXLnSlFw7d+5UYmKifH19U8R9fX1VqlQp7d+/35R+3Kl58+aG8Y0bNyoqKsrUvsLCwgy3pYYNG2rPnj2m9pXewsPDtXv3bqfz7N2712pbUlKSpk+f7nQf8fHxOnTokGrVqmXRVrJkSafz3/fnn3/q559/Ni2fJN27d0+TJk3S8OHDLdpatmypSZMmOd2HWeNCd46ZnRkvz549W2PHjrU4bnTt2lVvvPGG4uLi7K7H6LgZHR2t+fPn253Llcw8XkjmHDNatmxpGD9w4IB+/fVXM8pMdvXqVS1evFjdunUzNa+zPG2bzCjHTU/c3s3QsmVL+fj4WMT37t2r7du3u6UGV8so26A9rD2v0qVL6+TJk26rw91OnTqlGzduKEeOHCnivr6+yp07ty5dupROlaXuYdxG7TVz5kyNGTNGmTJlShF/6qmnVLBgQYfe23r16qlEiRIW8dmzZ+vevXsO1+qJ3PHZ8MTjZIsWLQzjYWFhOnz4sBllJrt69aqWLFmirl27mprXk3nrPtdbZaS/KXnq/iKjvL4P2/U1xggAAAAAPJXlWSYAAAAAAAAAAAAAAAAAAAAAAADgZS5evGgY7969u9atW+fmalyjdu3ahnEzJ8f4t1WrVrl88kKza4+JidHx48f12GOPWbTlzp3b1L4yqvr16xvGH6aJ3S9cuGAxWZEk0yYrYruHLVz1mdu0aZPhRM81atRIc92MeBw6evSotm3b5tI+zObMPspoAiXpn+3CFVavXm3KhHfWjk2uGONZu/GC0Y0wPFWjRo0M464aE1vL+8QTTyhr1qyKjY11Sb/eKKNsy9647/w3TxuLZcTjqyt07txZnTt3dmkfSUlJGj16tIYNG+bSfrxR5cqVNXr06FSXKVOmjCZMmKAXX3zRTVWZx9qN26Kjo7Vo0SLNmjVLYWFhio+Ptylfnjx51Lt3b/Xv319ly5a1utz48eN16NAhl43FPFWRIkU0e/Zsq2MWM5QsWVKTJk1S79691bNnT/31118u6+thx3Uk8zhzrufJ18Y9uTZ38cRrPBnl3MSbz0v+LaOdx6fXOePatWtNyXP9+nVduHBBhQsXtmgLDw/XlStXTOnn8OHDhtfqcubMaUp+Zz2Mfyfx5HFNRtlvAwAAAAAAAAAAAAAAAOkpKSlJR48e1dGjRyX987257t27S5K2bt2q8ePHu6TfxMRE7d27V3v37nVJfgAAHkYnTpxQ06ZNtWrVKhUrViw5XqxYMY0YMUIjRozQvXv3FBkZmdz2+uuv6z//+Y98fHwMc165ckVNmzbV2bNnrfZ769YttWzZUhs2bFCpUqWS49WqVVO1atUk/XPsv3Xrlu7cuaNs2bIpS5YsVvPt2bNHbdu2VUJCgk3Pu3Pnzlq9erUaNmyYHAsMDFS3bt3s+u3wxo0bk8dBaTlw4ID69++vyZMnJ7922bJlU//+/dW/f39JUlxcnKKjo5U7d275+fkZ5jl27Jhatmypu3fv2lwnAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADeoFGjRobxdevWuaQ/a3mfeOIJZc2aVbGxsU7lP3r0qLZt2+ZUDm9x5coV9e3bVytXrrRoK1WqlL7++mv16dPH/YUZmDp1qj766COLeGhoqL799lu7cnXr1k0BAQEW8enTpyspKcnhGuGZXnnlFcP45MmTHcq3fft2HTt2TI8++miKuJ+fn1588UV98MEHDuV1lejoaK1bt07PPPNMinimTJnUsmVLLVq0KM0cBQoUUI0aNVLEjh49qj/++EOStHz5ctWrVy9F+9NPP62hQ4faVGP79u0tYrdv39aqVatsWj8tRvs4R8XExOj48eN67LHHLNpy585tWj/uVL9+fcO4K47jO3fuNIxXqFDB9L7S29q1a03Jc/36dV24cEGFCxe2aAsPD9eVK1dM6efw4cOqVauWRTxnzpym5Jek9evXm5br3zZt2qThw4dbxB/cbznCzHGhO8fMzoyXr1+/rp9++kk9e/ZMEc+WLZs6dOiguXPn2lVLqVKl9OSTT1rE582bp5iYGLtyuZqZxwvJnGNG7dq1DeNm13rfqlWr7LpnvDt42jaZUY6bnri9m8Ha++OqY1B6yCjboD0uXrxoGO/evbvLrj15igsXLihHjhwW8dy5c+vSpUvpUFHaHsZt1F5RUVFavHixnnvuuRRxPz8/9ejRQ5999pndOR88Tt43depUh2r0dK7+bHjicdLofE3653zIFVavXq2uXbu6JLen8sZ9rrfKSH9T8sT9RUZ6fR+262uMEQAAAAB4Kt/0LgAAAAAAAAAAAAAAAAAAAAAAAABwlrWJJXv27OlxE/A56sHJku/79ddfXdLfrl27XJL338LCwkzPef78ecO4t04s7G7u3s480Y0bNwzjZm1DbPewhatupPH7778rISHBIl60aFFlyZIl1XUz4nFoy5YtLu/DbM7so8qVK2cY37Fjh1M1WWPW/q58+fKGcVfUbW1SOms1eCJrE3a66rN6+fJlnTlzxiLu4+Njdb/xsMoo27I37jv/zdPGYhnx+OqNLl++rFatWmnYsGHpXYrHyZw5s+bNm6fAwMA0l33hhRfUsWNHN1RlrmeffVYdO3bUgQMHJEm3bt3SsGHDVKBAAfXp00c///yz4uPjbc537do1ffHFFypfvrzefPNN3b5923A5X19fzZo1S9mzZzfleXiDcuXKadeuXVYnVv23iIgIbd26VStWrNDs2bM1efJkzZo1S8uXL1dYWJhNE402aNBAO3fuNJwENqNo2LChjh49avo/W3EdyTzOnOt58rVxT67NXTzxGk9GOTfJKDLaeXx6nTOauf1a225/++03l/eRK1cu0/pwxsP4dxJPHtew3wYAAAAAAAAAAAAAAAAAAABSOnjwoKpUqaJ58+YpKSnJot3f31/58+dPfpwpUyb5+PgY5lq0aJEqVqyoQ4cOpdnvH3/8oZo1a2r27NmG7b6+vsqRI4fy589v9fcdSUlJGj9+vOrVq6dbt26l2ed9sbGxat68ucaPH6/ExESb17svMTFR48aNU6tWraz+7tHI1KlT9dxzz1n9nnmWLFmUL18++fn5GbYvWbJEdevW1cWLF+2uGQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAT1ehQgXD+K+//uqS/i5fvqwzZ85YxH18fPToo486nX/Lli1O5/Amq1at0sSJEw3bQkND1blzZzdXZGzGjBmG97OsWbOmypcvb1eu0NBQi1hSUpKmTZvmcH0PG2v3SZVkeK/V9JIrVy7DbfjmzZtauHChw3mnTJliGH/xxRfl6+vrcF5XWbBggWG8ffv2Nq3fpk0bi/d8xYoVyf9fvny5xTohISEqVqxYmrkDAgLUqlUri/iaNWsUExNjU31pCQsLMyXPfefPnzeM586d29R+3MXaPnTHjh2m93Xp0iW7avBmZr5+1l633377zeV95MqVy7Q+tm3bZlquf/v999+VkJBgES9atKjV+2zbysxxoTvHzM6Ol3/44QfDeN++fe2uJTQ01HDcYK2P9GT28UJy/phh7f1y1bnWrl27XJLXWZ60TWaU46Ynbu9mcPdnJj1klG3QHtbGED179lS3bt3cWou73bhxwzDuyeceD+M26ghrx50+ffrYncvf319dunSxiO/evVuHDh2yO583cPVnwxOPk+XKlTOMu+KzJbnmNfB03rjP9VYZ6W9Knri/yEiv78N4fY0xAgAAAABP5HnfhAIAAAAAAAAAAAAAAAAAAAAAAADstGPHDl25csUi7uvrq3nz5mnOnDmqXr16OlRmnrJlyxrG9+3b55L+Tp48qejoaJfkvu/YsWOm57Q20UzOnDlN7ysjsjbJl6u2M0/g4+OjokWL6sknn1SfPn2UL18+w+UCAwNN6Y/tHrY4ceKES/LGxMRYnVCoTJkyqa6bEY9DO3fudGl+M5i5j7L2HoaHhztVozVnz57VnTt3nM5jbaK+v/76y+ncD4qKijKMe9P+1NpEZXv27HFZn9ZyW6vlYZVRtmVv2HemxtPGYhnx+OpNIiIi9M4776hMmTJat25depfjkT777DM99thjNi8/adIkFS5c2IUVucaSJUtUpUoVPfXUUypdurRGjRql2NhYp3ImJSXpiy++UPXq1Q2vWUlSkSJF9OabbzrVj7coUKCANm/erCJFilhd5sCBA3rllVdUqlQp5cuXT08++aTatWunXr166aWXXlLv3r31zDPPqGHDhipQoICKFy+u559/PtUbcBQqVEibNm1SoUKFXPG00l1QUJAeffRR0//Z6mG8jmQWM8/1PPnauCfX5i6eeI0no5ybZBQZ7Tw+vc4Zjx8/bloua+dMZn6eb926ZRjPkSOHaX3Yg7+TePa4hv02AAAAAAAAAAAAAAAAAAAAYCkyMlLdu3dXlSpV9P333ysiIsLmda9cuaKpU6eqatWq6ty5s65evWrzuhEREerVq5eqVq2qadOmKTIy0qb1oqOjNXnyZFWqVEmDBw92aC6G+Ph4DR48WJUrV9acOXNs+h1kbGysZs+erZCQEL399tu6d++e3f3++OOPeuyxx/TFF1/o2rVraS6fmJio9evXq3nz5urYsaPV7ykDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAODtKlSoYBjfs2ePy/q0lttaLfbYuXOn0zm8zeDBg3X8+HHDth9++EFFihRxc0WWzp8/rw0bNhi29e7d2+Y8jz76qGrUqGER37Jli06fPu1wfQ+bzJkzW22Li4tzYyWp6927t2Gt8+fPd6rOmTNnGt4jtUiRImrTpo3DeV1l+fLlhveSbdOmjfz8/NJcv23bthaxZcuWJf//2LFjOnXqlGH+tDRu3FjZs2e3iC9cuDDNdW117Ngx03JJ0o0bNwzjOXPmNLUfdylXrpxh/K+//jK9L2v3+fXW1y411o6rjoiOjjaMnzhxwrQ+bt26ZRjPkSOHaX2YWe+/xcTE6MyZMxZxHx8flSlTxqncZo4L3T1mdma8vHXrVsNtuEmTJipevLhddYSGhlrEDhw4oN27d9uVxx3MPl5Izh8zypYtaxjft2+foyWl6uTJk1b3OenJk7bJjHLc9MTt3Qzly5c3jLvqM5MeMso2aI8dO3boypUrFnFfX1/NmzdPc+bMUfXq1d1ak6v4+PioaNGievLJJ9WnTx/ly5fPcLnAwEA3V2a7h3EbdcTmzZsNz6MrVqyoqlWr2pXrqaeeUp48eSziU6dOdbg+T+Puz4YnHietjQvDw8MdLSlVZ8+eNbyWlJFkhH2ut8pIf1PyxP1FRnp9H8bra4wRAAAAAHgi//QuAAAAAAAAAAAAAAAAAAAAAAAAAHBWQkKCPvroI3355ZeG7d27d1f37t116dIl7d69W4cPH9bJkyf1xx9/6NSpUzp//rybK7aPr6+vgoKCDNsiIiJc1m9ERISCg4Ndlv/vv/82PefNmzcN476+vqb3lRHlzp3bMO7K7cwdsmTJotKlS6t06dIqU6aMypQpk/z/kiVLKlOmTG6rhe0etjh79qzLckdGRhrGc+XKZXWdjHocctVEb/Zy1z7K2mRJ165dMyX/g5KSknTu3Dk98sgjTuUx2jbj4uKsbsvOsDaZVbZs2Uzvy1Xy5s1rGHf1Z9WeWh5WGWVb9pR9p6M8aSyWUY+vni4hIUE//vijFixYoLVr12b4yVmd0aZNG7366quGbZcvX1aBAgUs4rlz59asWbPUtGlTV5fnEuvXrzc95+HDh9WsWTOFhYUZTjz65ptvauzYsYqJiXEov7vO+1LrJykpKc31f/zxRxUqVMiw7cqVK3rxxRe1YsUKu2o6d+6cpk+frunTp6tJkyaaMWOGihYtarFcgQIFtGDBAj355JM21WrEW15nd8uo15HM4q5zPU++Nu7JtbmLp13jsdbujecmGUVGO49Pr3PGixcvmpbL2nZ76dIll/fhyjEHfydJnSePa9hvAwAAAAAAAAAAAAAAAAAAANaFh4erf//+evXVV/Xoo4+qWrVqKlq0qCpVqqTu3btLknbt2qX58+fr/PnzOnTokI4dO+Z0v/v371ffvn3l6+urKlWqqEKFCipdurSyZ8+uoKAgxcbGKjIyUleuXNHvv/+u8PBwJSYmOt2vJB06dEg9e/ZU5syZVbt2bVWsWFHFihVL/t1yTEyMzp07p0OHDmnnzp26ffu2031evHhRb775pt566y1Vr15dlSpVUqlSpRQcHKzAwEDFxsbq0qVLOn78uLZt26aoqCin+wQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwNPlzZvXMB4REeGyPq3ltlaLPcLDw53O4W3i4uLUvXt37dy5UwEBASnacuXKpVmzZqlJkybpVN3/mTx5sp566imLeK9evTR06FCbcoSGhlrNDdtlyZLFMJ6QkKB79+65uRrr+vXrZxh39v2+cuWKVq5cqfbt21u0vfLKK1qxYoVT+c0WHR2tdevWqV27diniuXLlUoMGDbR582ar6wYGBqp58+YpYhEREdqxY0eK2PLly/Xmm2+miLVt21bff/99qrUZvYZ37twx9TX8+++/TcslSTdv3jSM+/r6mtqPu+TKlcsiFhcXp8jISNP7io6ONoxny5bN9L7S28WL/4+9+w6Pomr/P/5JhZBAKKFJkRLpYOhFwIAgLVQBG/XxoQkKYgEUQRFFRQRBkQdpUhUEKdKlCAgIUkKRjlIl1ISant8f/szXdWdDkp1t4f26Lq6Lvc/Mfe5sZuecmd2c/dO0XLaet0uXLjm8DzOP6zNnzpiW699sHa9Gx3dGmDkvdPac2d758ldffaVPPvnEIubl5aVu3bpp9OjR6crRsGFDlShRwio+derUdO3vbGaPF5J9Y4a3t3fq97b/m6OvtYKCghyWP7Pc5ZjMKuOmux3vZsmbN69h3JGvGWfLKsdgRiQlJWn06NGaOHGiYftzzz2n5557TpcuXdKvv/6qw4cP68SJEzp16pROnjyp8+fPO7Xe+wkICFCpUqVUqlQplS5dWqVLl079f4kSJZQtWzZXl2iXB/EYzayvvvpKH330kVW8R48e2rdvX7rzdOnSxSoWFxenBQsW2FWfs7nTa8Mdx8ng4GDD+LVr1zJdU1pSUlJ07tw5hYaGOiS/s7jTcYX/k5XeU3LH80VWen4f1PtrzBEAAAAAuBtfVxcAAAAAAAAAAAAAAAAAAAAAAAAAmOHLL79Uhw4dFB4ebnObQoUKKSIiQhERERbx2NhYnT59OnVxqxMnTigyMlL79+/X3bt3HVz5/dlaeOn27dsOXSw6OjraYbkl6datW6bnTE5ONj3ngyJHjhyGC2nExcUpLi7OBRVlXPHixVWtWjVVqVJFoaGhqYsSFSpUyNWlpeK4R3o44jj5240bNwzjaS1Wm1XHIUct9GaLK89RgYGB8vLysorHxcUpPj7eYf3aWnQrvWzVHRAQoISEBLtyGzHqS5LHLGoXEBAgHx8fq3hcXJxiY2Md1q+tBUk9ZfFQZ8hKx7Kzz51mc6e5WFYdXx3hzz//VExMTIb2yZkzp4oUKWIV9/Hx0Zdffqlt27aZVV6WVKBAAc2cOdOw7fLlywoLC9N3332nxx57zKq9cePGevXVVzVu3DhHl+kxDh48qDfeeMPwCxNy5sypNm3apLmQZFrX5P/+IjpH8ff3t9l2v3sGXbt21eOPP27YdvDgQTVp0kSXL1+2q76NGzeqcuXKWrt2rWrVqmXVXr9+ffXo0cPmcS15/vPsbFnhPpJZ3OF+lDvfG3fn2pzB3e7xZKVrk6wgK17Hu+qa8c6dO6blsnWN54w+zOAO49L9uNO1ueTe8xrO2wAAAAAAAAAAAAAAAIBjXLx4USNHjpQkbd++3cXVAAAAM6SkpOjIkSM6cuSIJKlatWp67rnnJElbt27VhAkTHNJvcnKy9u7dq7179zokf1piY2O1efNmbd682Wl9Jicna9euXdq1a5fT+gQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwB0FBATIx8fHKh4XF6fY2FiH9Xv9+nXDeM6cOe3Ofe3aNbtzeKK9e/dq5MiR+uCDD6zaGjVqpFdffVXjxo1zQWX/Z9myZbp27Zry5ctnES9WrJjCw8Pv+/2WXl5e6tKli1U8JiZGixcvNrPULC8kJMQwHhMT4+RKbGvQoIHKly9vFT906JB2795td/5p06apXbt2VvHmzZurePHiOnv2rN19mGnhwoVq06aNVbxdu3ZpvnYaN26swMBAi9jKlSuVkpJiEVu+fLkGDx5stW9AQIDu3btnM3/btm2tYmvXrtXt27dt7pNRt27dMi2X9Nf322YVgYGB8vLysooHBAQoISHB9P6M+pKkbNmymd6Xq925c8e0XLaOOWf0YSazX4v/dOPGDcN4UFCQXXnNmhe6Ys5s73z566+/1gcffCB/f3+LeM+ePTV69Oh05ejZs6dV7N69e5o3b1669nc2Rxyj9ry2bP2ubt++rcTExEznvZ/o6GiH5baHOxyTWWncdLfj3Qw5cuSQt7e3VTwuLk5xcXEuqMh8WekYzKgvv/xSHTp0UHh4uM1tChUqpIiICEVERFjEY2Njdfr0aZ06dUonT57UiRMnFBkZqf379+vu3bsOq7l48eKqVq2aqlSpotDQUJUuXVqlSpVSoUKFHNanqz3Ix2hmzJo1S6NHj5afn59F/LnnntOrr76arvE+MDDQ8Fp/6dKlbjume8Jrw93GSVuvrbi4OMXHx9tTVppu3rzpsNxm84TjCn/Jau8pudv5Iqs9vw/q/bUHdY4AAAAAwH35uroAAAAAAAAAAAAAAAAAAAAAAAAAwAyJiYlq166d1q1bp1q1amVo3+zZs6tChQqqUKGCRTw5OVnbtm3T3LlzNX/+fFMXMsgIWwsvOboeRy9S44jFq5B5/16k+m/uvlhRlSpV1K1bNz399NMqWrSoq8u5L457pIcjF1K09ZpOa6HnrDoOOWOxHnc5R+XIkcMw7ujn2N5j2VbdkuTry59J/5urxnJbryUzvlwoq8hKx7KnL3TmTnOxrDq+OsJrr72m+fPnZ2if4OBgnT59Wnnz5rVqmzBhgmrUqGFWeVnSrFmzlD9/fsO2nj176tKlS+rSpYsiIyOVK1cuq20++OADbdiwQfv373dwpZ5j2rRp6t+/vx599FGrtqeeekoLFiywuW9ai/AHBASYUt/9pNVPWvV5e3vr/fffN2w7e/asnnzySV2+fNnu+qS/xqiWLVtq586dCg0NtWofPXq05syZY3PRT09+nl3BU+8jmcVdrvX+5s73xt25Nmdwt3s8WenaJCvIitfxrrpmdMa1niO/NMJe7jYu3Y87XZtL7j2v4bwNAAAAAAAAAAAAAAAAOMalS5c0atQoV5cBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8VGBgoGH85s2bDu03OjraMJ4zZ06H5X4QfPjhh2rRooUaNGhg1fbBBx9o/fr1OnDggAsq+0tCQoLmzp2rgQMHWrV1795dmzdvTnP/Ro0aqWjRolbxBQsWKDY21qwyHwgPPfSQYfz8+fNOrsS2vn37GsanTZtmSv7Vq1fr4sWLVs+Ft7e3evfureHDh5vSj1mWL1+uuLg4ZcuWzSLetm1bDRo0yOZ+bdq0sYotW7bMKrZt2zbduHFDefLkSY1lz55dTzzxhH744QfD3DVq1DA8lhYtWmSznsxISEgwNV9WkiNHDpttvr6+Tqwk63HGcRcfH+/wPsx09+5dh+W2NfcMCgqyK69Z80JXzJntnS9fvXpVS5cuVefOnS3ipUqVUv369bVt27Y098+RI4c6duxoFV+4cKFiYmLSVYOzudt48e8x+2937txxaL+OvpbLLHc4JrPSuOlux7sZXHV/wpmy0jGYUYmJiWrXrp3WrVunWrVqZWjf7Nmzq0KFCqpQoYJFPDk5Wdu2bdPcuXM1f/58U86vVapUUbdu3fT0008b3n/I6h7kYzQzLl++rBUrVqhDhw4W8ZCQELVs2VLLly+/b4727dsbPu8zZswwrU4zeNprw93GSVuvLUePcY68hjODpx1X+EtWe0/J3c4XPL8Z54731x6kOQIAAAAAz+Dt6gIAAAAAAEDWFhYWplu3bun99993dSkAAAAAAAAAAAAAAAB4AMTExKh+/fqaMGGCEhMT7c7n7e2thg0baurUqTp16pR69eplQpXmSUlJcWj+5ORkh+aHe/Hy8jKMJyUlObmS9ClZsqQWLlyoyMhIvfrqqyxUhCzFked3W69pW+eAtHj6OHTr1i2H5Xa3c5SrzvH2zscyc1w+yLy9jf903NG/ZzPPK1lVVnouHHnuxF88fXx1FzExMXrnnXcM26pXr66uXbs6tyAP0r9/f7Vo0cKwbfLkyVq1apUk6Y8//lD//v0Nt/P399f8+fOVPXt2h9XpaVJSUjR79mzDtho1aqS5b1rn3n9+iZQj5c2b1zCenJyc5iLHzZs3V7FixQzb+vfvr0uXLplS39+uXbum3r17G7Y99NBDatWqlc19PfF5jo6O1s6dO03/lx6edh/JLO52rfdP7nxv3J1rczR3u8eTla5NsoKseB2fla8ZHX2tlhnuPC55Enee13DeBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANyPt7e3YTwpKcmh/drK7+XlZXfuW7du2Z3DU6WkpKhLly6KiYmxavP399eCBQuULVs2F1T2f6ZPn24Y79ixowICAtLct0ePHhnKCdvKli1rGD9//ryTKzGWN29ePfXUU1bx+Ph4zZkzx5Q+kpOTNWvWLMO2F154QT4+Pqb0Y5Zbt25p3bp1VvESJUqocuXKNveLiIiweBwXF2eYJykpSatWrbKKt27d2mbu9u3bW8Xi4+O1fPlym/vAXGaMm3CdlJQUV5eQIY6s11FzQ7Pmha6YM5vxnEydOtUw/p///Oe++3bs2FFBQUHpzon0c/RrPzk52aH57eHqY5Jx073Z+v04+v6EMz3ox2BMTIzq16+vCRMmKDEx0e583t7eatiwoaZOnapTp06pV69emc5VsmRJLVy4UJGRkXr11VdVtGhRu+vzRA/6MZoZtsahnj17pmv/Ll26WMXOnz+v9evX21WXWXhtmMNVY5wZ51pH4LjybFnxPSV3wvObce56fy2rzxEAAAAAeBZfVxcAAAAAAACyNm9vbwUFBcnf39/VpQAAAAAAAAAAAAAAAOABkZCQoFdeeUWTJk3SsGHD9NRTTylPnjx25y1YsKCmTp2qpk2bqlu3boqNjTWh2vSxtYCCrcUozOLn5+fQ/EBmNW/eXN9++61y5cqV6RzXrl3TiRMndOLECR0/fjz1/5999pnq169vYrWA58uq45CjFijiHAUgK3PXxd08UVYdX93Jl19+qQEDBqhMmTJWbWPGjNF3332ne/fuuaAy91WhQgV98sknhm1HjhzRq6++ahGbO3euIiIi9PTTT1ttX758eY0bN079+/d3SK2eaMWKFRo3bpxV/OGHH1bOnDltfnnKnTt3dPfuXeXIkcOqrWDBgqbXacRWP1euXElzbOjYsaNhfPv27frhhx9Mqe3fNm3apA0bNuiJJ56wauvcubOWLVtmuJ8nPs/bt29X3bp1HV0W/j9PuNZz53vj7lwbAPNwzeg8njAuAQAAAAAAAAAAAICnCgsL09atWyVJEydO1FtvveXiigAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwrJSXF1SW41NmzZ/Xiiy9q3rx5Vm0VKlTQ2LFj9fLLL7ugsr8cPHhQe/bsUfXq1S3iQUFBat++vebPn2+4X2BgoDp06GAVP3TokH799VeH1JqVValSxTB++PBhJ1dirHv37sqWLZtVfM+ePSpXrpxp/Rw7dswwXqhQIbVp00bff/+9aX2ZYeHChWrdurVVvG3btjp48KBVvEqVKipWrJhFbNOmTbpz545h/mXLlun555+3iEVERNisp23btlax9evX6+bNmzb3AQBnetDnhRs2bNDp06dVqlQpi3inTp00YMAA3b171+a+PXr0sIodOXJE27dvN7vMLMvW8eft7e3Qfv38/Bya3x4ckwASEhL0yiuvaNKkSRo2bJieeuop5cmTx+68BQsW1NSpU9W0aVN169ZNsbGx6d63efPm+vbbb5UrV65M93/t2jWdOHFCJ06c0PHjx1P//9lnn6l+/fqZzgv3t27dOp05c0YPP/ywRbxVq1bKly+frl27ZnPfAgUKqEmTJlbxr7/+2i3msbw24AgcVwAeFFl5jgAAAADA8/i6ugAAAAAAAAAAAAAAAAAAAAAAAADAEU6fPq1evXqpX79+atiwoWrWrKlq1aqpfPnyKl26tHLkyJGpvJ06dVLOnDnVsmVLp/2hv62F+IKDgx3ab+7cuR2aH+4lOTnZMO7r615/hhYREaGlS5fKx8fnvtvevHlTx44dM1yUKDo62nCfjCxUhweTl5eXw/vw8/NTQkKCQ3L7+/sbxpOSkmzuwziUfu56jrL1+3X0QsX25rc114qOjtY333xjV+6M8JQvVrD1e3b0WG7r95zWeeVBw7EMI4yvjpeYmKjXX39dy5Yts2orUqSIXn/9dY0aNcoFlbknf39/LViwQNmzZ7dqi4+P13PPPWc4F+nTp4/q1q2r4sWLW7W9+OKLWrVqlVauXOmQmj3NqVOnlJycbPhlFCEhIbp165bNfS9dumT1BQ6SDGOOYKufS5cupblf3bp1DeOOHv8WLlyoJ554wipep06dNPfz1OfZFTzlPpJZ3PVazxZ3vjfuzrU5grvd4+HaxL1wHY/M8rRxyd2587yG8zYAAAAAAAAAAADgGt7e3goKCpJk+zMaAAAAAADAvV28eFEjR46UJG3fvt3F1QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgKwmKSnJMO7r6+vQfv38/AzjtupBxsyfP18RERF69tlnrdpeeuklrVy5UmvXrnVBZX+ZNm2aqlevbhXv3r275s+fb7hPhw4dFBgYaJgLGePn56eaNWsatu3du9fJ1Rjr06ePYbxu3br6+eefnVJD37599f333zulr/Ravny54uPj5e/vbxFv166dRo8ebbV969atrWLLli2zmX/NmjVKSEiwOEc/9NBDCgsL0/79+y22LV26tCpWrGiVY9GiRff7MWCilJQUw3h0dLS++eYbp9Vx8+ZNp/UF1/Hz81NCQoJDcv/7vPY3d5kbumLObNZ8edq0afrggw8sYkFBQerYsaNmz55tuM/DDz+s8PBwq/jUqVMz1PeD7u7du4bx4OBgh/abO3duh+a3lyuPScZN95acnGwYd/T9CWfiGPw/p0+fVq9evdSvXz81bNhQNWvWVLVq1VS+fHmVLl1aOXLkyFTeTp06KWfOnGrZsqXN5/ufIiIitHTpUvn4+Nx325s3b+rYsWM6ceKETpw4oePHj6f+Pzo62nCf2NjYjP4ILsUxmnEpKSmaPn26Ro0aZRH38/PTs88+q88//9zmvk8//bThsTdz5kzT68woXhvmsjWHtzXnN4uj82cUx9X/8fLycnUJmcZ7So7F85t1ZNU5AgAAAADPlHXeaQEAAAAAAAAAAAAAAAAAAAAAAAAMJCYmauPGjdq4caNFvFChQgoNDVVoaKgeeeSR1P+XKVNGQUFBaeZs3ry5Ro4cqXfeeceBlf+fO3fuKCUlxWphkmzZsil79uwOW1wlT548DskL92TrOHL0IpkZUapUKc2bN8/mQkWXL1/Wd999p/Xr1+vXX3/V+fPnM9yHJy8ABOcICAhweB/BwcG6evWqQ3LbWpj29u3bNvdhHEofdz5H3blzxzDu6HO80ZeHZIStY+v27dvq16+fXbmzIluvY0cvSJ03b17DuCctHupoHMswwvjqHMuXL9fmzZsNF7EfMmSIpk2bposXLzq/MDf04YcfqkqVKoZtb731ltWXEv0tJiZGXbt21aZNm+Tt7W3VPnPmTFWqVEmXL182s1yPlJycrCtXrqhgwYJWbfeblx0/flylSpWyipcvX960+tJiq5/jx4+nud8jjzxiGN+xY4fdNaVl+/bthvFSpUrJ19dXiYmJhu2e+jy7gifcRzKLO1/r3Y873xt359rM5G73eLg2cS9cxyMzPHlcclfuPK/hvA0AAAAAAAAAAAAAAAAAAABkzqVLlzRq1ChXlwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALKo27dvG8Zz587t0H7z5s1rGL9586ZD+32Q9OvXT4899piKFy9u1TZr1ixVrlxZV69edUFl0oIFCzR+/Hhlz57dIt6kSRMVLlxYf/75p9U+PXr0sIolJCRo7ty5jiozy6pfv74CAwMN23755RcnV2Pt8ccfV9myZV1dhpo2bapSpUrp9OnTri4l1c2bN7Vu3TpFRERYxKtXr64iRYrowoULFvHWrVtb5fjhhx9s5r9165Z++uknNWnSxCIeERGh/fv3W8Tatm1rtX9CQoKWLVt2vx8DJoqNjTWM3759W/369XNyNcjqgoODHTZ3sDX3tDVXdTZXzJnNmi/PnDlTo0aNkq+vr0W8Z8+emj17tuE+3bp1k5eXl0UsLi7O5vYwdufOHaWkpFg9l9myZVP27NltnsPtlSdPHofkNYsrj0nGTfdm6/cTHBzs5Eoch2PQWmJiojZu3KiNGzdaxAsVKqTQ0FCFhobqkUceSf1/mTJlFBQUlGbO5s2ba+TIkXrnnXfS3K5UqVKaN2+efHx8DNsvX76s7777TuvXr9evv/6q8+fPZ+hnk2R17nJ3HKOZM2PGDI0cOdLqWOrRo4c+//xzm/t16dLFKrZ161adOnXK9BozgteG+e7cuWMYd/QYZ+v+nytwXFkKCAhwdQmZxntKjsXzm7VktTkCAAAAAM/l7eoCAAAAAAAAAAAAAAAAAAAAAAAAAFe4dOmStm3bplmzZumtt97S008/rerVqytnzpwqXbq0+vXrp4MHD9rc/4033lDBggWdVq+tBT8LFy7skP78/f2VP39+h+SGe7p7965SUlKs4n5+fm6zKM4HH3ygXLlyWcVv3rypfv36qWjRourfv7+WLl2aqYWKJN13MTt4HluLW2VWzpw5Tc1nxJGLCmV2oWfGoftz53NUbGyskpOTreK+vr7KkSNHpnKmh70L6tkam2wtjPWgi4uLU2JiolXc19fXoYsP2lrw+tatWw7r09NwLMMWxlfnGDx4sOFrMEeOHBozZowLKnI/TZs21aBBgwzbNm3apHHjxqW5/5YtWzR27FjDtvz58+vrr7+2t8Qsw9a829/fP839fvvtN8N4jRo17K4pPWz1Y6suScqVK5fN67GLFy+aUpctRl9u97e0xl9PfJ5dxRPuI5nFna/1Msud7427c22Z4W73eLg2cS9cxyMzsuK45GruPK/hvA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC4n7i4OCUmJlrFfX19FRgY6LB+8+TJYxi/deuWw/p80MTExKhr165KTk62aitUqJCmT5/ugqr+EhMToyVLlljFvb299dxzz1nFixYtqvDwcKv48uXLde3aNUeUmKUZPceSdPz4cf3+++9OrsZa3759XV2CJMnLy0u9e/d2dRlWFi5caBhv06aNxeMCBQqoVq1aFrF9+/bp/PnzaeZftmyZVax169ZWsXbt2lnFNmzYoOjo6DTzw1x3795VSkqKVTxv3rwuqAZZXe7cuZ2e+/bt2w7rMyNcMWc2a7586dIlrVy50ir++OOPq0SJEob79OjRwyr2/fff6/r16xnqG9LVq1cN44ULF3ZIf/7+/sqfP79DcpvFlcck46Z7s/X78fPzU0BAgAsqMh/HYPpdunRJ27Zt06xZs/TWW2/p6aefVvXq1ZUzZ06VLl1a/fr108GDB23u/8Ybb6hgwYJp9vHBBx8oV65cVvGbN2+qX79+Klq0qPr376+lS5fe9zrKlqCgoEzt5yoco5lz4cIFrVmzxipevXp1VaxY0XCf0qVLW12zS9KMGTNMry+jeG2YLzY21vAera+vr3LkyOGwfoODgx2WO6M8/bjy8fExNV/OnDlNzedMvKfkWDy/WUtWmyMAAAAA8Fzeri4AAAAAAABkLVWrVtX777+vFStW6PDhw9q6daskacCAATp69KhWrlypt956S9WqVTOlv6JFi6pPnz5asGCB9u/fr6tXryo2NlYpKSm6e/euzp8/r02bNumDDz5Q7dq1TekzM0qUKKFXXnlFixcv1pEjR3T9+nUlJCQoOTlZt2/f1okTJ7Rs2TINGjQoUx8mL1WqlHr37u2Qf5n5XZUpU0ZDhgzRqlWrdObMGd25c0cpKSm6ffu2fv/9d23fvl0ffvihwsPD5e3NLSoAAAAAAAAAAAAAAOB+Tp8+rSlTpqhKlSp68803DbcJCAhw6uLER48eNYwbLURghqpVq8rPz88hueGekpOTFRUVZdh2v4XbnKFkyZLq1KmTVTw2NlZNmjTRlClTlJCQYHc/ISEhdueAayQlJRnGzV7UqXjx4qbmM1KoUCGH5bb1era1SO7fGIfS5gnnKGef4318fFSsWDG7ciQlJenKlStW8Rw5cih79ux25c6qLly4YBh35HnFVu5Lly45rE9Pw7EMWxhfnWPfvn2aM2eOYVvXrl1VvXp1J1fkXvLly6evv/5aXl5eVm03btxQ165dDRel/rfhw4drz549hm3NmzfXgAED7K41K7D1GjRanPifbD23VatWdfhCtgEBAapRo4Zh2969e23ul9YY5+gvmklrwdS06vLE59lV3P0+klk84VrPbO54b/xv7lybLe52j4drE/fDdTwy4kEcl5zBnec1nLcBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA93ThwgXDeKFChRzWp63cly5dclifD6ItW7Zo7Nixhm1t2rRRr169nFzR/5k2bZphvEePHlaxLl26yNvbO905YFuuXLn09NNPG7atXLnSydVYy5cvnzp06ODqMlL17NlTfn5+ri7DwrJlyxQfH28Vb9++vcXjVq1aycvLyyK2fPny++ZfsWKFVaxmzZoqWLBg6uN8+fKpXr16VtstXLjwvvlhrqSkJF25csUqniNHDmXPnt0FFSErc+Tc8J/nmH+6evWqw/rMKGfPmc2cL0+dOtUq5uXlZTjvql+/vkqVKpWuHLi/o0ePGsZr1arlkP6qVq3qdnMXI646Jhk33VtycrKioqIM22yNE56GY9Acp0+f1pQpU1SlShW9+eabhtsEBASod+/eNnOULFlSnTp1sorHxsaqSZMmmjJlihISEuyuNSQkxO4czsQxmnm2xqXu3bsbxp977jmr2O3bt7Vo0SJT68ooXhuO4+wxzsfHR8WKFXNI7ozypOMqKSnJMJ4zZ067c/9T8eLFTc3nbLyn5Fg8v1lLVpkjAAAAAPBs1p+6AwAAAAAAyCBfX18NGDBAJ0+e1N69e/Xmm28qIiJCFSpUUI4cOSRJ2bNnV9myZdWyZUuNHj1ae/bsUWRkpNUfPKVXuXLl9N133+nMmTOaMmWKnnnmGT366KPKly+fsmXLJumvDwsWKVJE4eHhGjZsmHbu3Km9e/fqiSeeMO1nv58yZcpo8eLFOn36tD799FN16NBB5cqVU548eeTr6ysvLy8FBgYqNDRUbdq00fjx43Xu3DnNmDFDBQoUSHc/NWrU0P/+9z+H/IuIiEh3HRUqVNDKlSt19OhRffjhh2rRooWKFy+eehwEBgaqRIkSqlu3roYMGaJNmzbp8OHDmT4OAAAAAAAAAAAAAAAAnGHMmDH67LPPDNuaN2/utDqOHDliGK9fv75D+qtTp45D8sK9nTlzxjBevXp1J1dirWXLloYL0U+ePFm7d+82pQ8vL68ss7jhg+jGjRuG8eDgYFP7KVOmjKn5jNSoUcMheQsWLKgiRYpYxZOSknTq1Kk092UcSpsnnKOOHz9uGHfU8RYaGipfX1+785w9e9YwXrlyZbtzZ0W//fabYbx27doO69PWYtqHDx92WJ+eiGMZRhhfnWfYsGG6e/euVdzLy0sTJkxwfkFuZPr06SpcuLBhW58+fWwugvlviYmJeu655wyfZ0kaO3asKlasmOk6swpbfy90586dNPf76aefDON+fn568skn7a4rLU2aNDFcgDwlJUVbt261uV9KSorNtr///stR0sqfnJxss80Tn2dXcuf7SGbxhGs9R3KXe+NG3Lm2f3LHezxcm7gXruOREQ/6uORI7jyv4bwNAAAAAAAAAAAAOF7VqlX1/vvva8WKFTp8+LDFZ7YGDBigo0ePauXKlXrrrbdUrVo1p9ZWuXJl9e7dO/WfvZ8zrlChgt566y0tX75cJ0+e1LVr15SYmKjExERdu3ZNJ0+e1PLly/XWW2+pQoUKJv0UfylVqpSGDh2qVatW6fTp07pz546Sk5MVHx+v69eva9++ffr666/1zDPPKDAw0NS+AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAw22+//WYYr127tsP6rFWrlmH88OHDDuvzQTV8+HDt27fPsG3ChAl65JFHnFzRXzZt2qTff//dKl6pUiU9+uijFrHu3btbbXfhwgWtW7fOYfVlVYMGDVLOnDkN22bOnOnkaqz16NFD/v7+ri4jVYECBdSuXTtXl2Hh5s2bWr9+vVU8PDxcuXLlSn3cunVrq22WL19+3/xnzpzRgQMHLGJeXl5q0aKFRW4fHx+LbRITE7Vs2bL75of5zp49axivXLmykytBVlejRg2H5C1YsKCKFCliFU9KStKpU6cc0mdmOHvObOZ8efXq1Tp37pxV3GiO1bNnT6vYyZMntWnTpgz3C+nIkSOG8fr16zukvzp16jgkr9lceUwybrq3M2fOGMarV6/u5Eoch2PQXGPGjNFnn31m2Na8eXOb+7Vs2VLe3t5W8cmTJ2v37t2m1Obl5aWCBQuaksuZOEYzZ+XKlfrzzz+t4l27djU81rp06WIVW7Roke7cueOQ+tKL14bjHD9+3DDuqOus0NBQ+fr6OiR3RnnScXXjxg3DeHBwsN25/6lMmTKm5nM23lNyLJ7frCWrzBEAAAAAeDbrqw8AAAAAAIAMCA0N1e7duzVp0iSVLl06Q/tWqVJFS5Ys0Q8//KA8efKke79BgwYpMjJSTz31lOGbq2mpWrWqfvzxR40bNy5D+2VGly5dtG/fPnXo0EFeXl7p3s/Hx0c9e/bUwYMHVbduXQdWaK7XXntNkZGRatmyZYZ+3nLlymnJkiVasGCBW/3hIAAAAAAAAAAAAAAAwD+98847io+Pt4o7aoEYI7YW2OvQoYNDFpN59tlnTc8J97d//37DuDt8lqlhw4aG8W+++ca0PsLCwhQUFGRaPjiXrUWiSpQoYWo/jz/+uKn5jDjqNWdrYdrff/9diYmJae7LOJQ2TzhHHTt2zDBer169TOdMi1mvlX9/KcLfbC2O9aA7dOiQYdxRC16XLl3acKG/hIQEnThxwiF9eiqOZRhhfHWeixcv2vxbkvr16+upp55yckXuoVevXmrbtq1h29dff61FixZlKN/x48f1yiuvGLZlz579gf/bkXz58il79uyGbVeuXElz3wsXLticz3Xr1s3u2tJiK/++fftsXodJ0t27d222FSpUyO660lK4cGGbbWkt4OmJz7MrufN9JLN4wrWeo7nDvXFb3Lm2v7njPR6uTdwL1/HICMYlx3HneQ3nbQAAAAAAAAAAAMAxfH19NWDAAJ08eVJ79+7Vm2++qYiICFWoUEE5cuRI3S579uwqW7asWrZsqdGjR2vPnj2KjIxU+/btHV5jSEiIVq9erf/973+p/55//vlM5apVq5a2bdumw4cPa/To0WrdurVKly6tvHnzysfHRz4+PsqbN69Kly6t1q1ba/To0Tp8+LC2bt1q9/uToaGhWrp0qU6dOqUxY8aoRYsWKlmypHLkyCEvLy/5+fkpT548CgsLU7du3bRgwQKdPXtWr732WobXoAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwFkOHTpkGK9fv75D+itdurQKFixoFU9ISNCJEycc0ueDLDExUc8++6zu3btn1ZYjRw7Nnz9fvr6+LqhMmjFjhmG8e/fuqf+vWbOmypUrZ7XNrFmzlJyc7LDasqLixYvr9ddfN2zbuXOnDh486OSKrPXp08cw/uyzz8rHx8eh/zZs2GDYd9++fR35I2fKwoULrWJ+fn5q0aKFJMnf319Nmza1aL9w4YL27t2brvwrVqywirVu3Tr1/+3atbNq37Rpk65fv56u/DDXgQMHDOO1atVyciXI6urWreuQvHXq1DGM//7770pMTHRIn5nhzDmz2fPllJQUw3lXiRIlFB4envo4ICBAnTp1struq6++ynCf+MumTZsM4x06dHDIHPzZZ581PacjuPKYZNx0b/v37zeMO2oMcgWOQfO98847io+Pt4rXqFHD5j4NGzY0jH/zzTem1RUWFqagoCDT8jkLx2jmJCUladasWVbxQoUK6cknn7SIVa9eXWXKlLHa1tZ9MmfiteE4x44dM4zXq1fPIf09/vjjDsmbGZ50XN24ccMwXqJECbtz/5M7/X4yg/eUHIvnN2vJKnMEAAAAAJ7N29UFAAAAAAAAz1WhQgXt2LFDYWFhFvGUlBQdPHhQc+bM0ezZsyVJkZGR2rBhg2JiYqzytGrVSjt27FCBAgXu2+eIESM0fvx4+fv7W8SvXbumlStXatKkSXr//fc1evRoTZw4UatWrTL80MfgwYM1adKkDPy0GdO1a1fNnj1bOXLksIjfvHlTa9asSa3z/fff15dffqkdO3YoKSnJYtsCBQpo/fr1qlKlisPqTI/0/OHG+PHjNXbsWKsPwd+4cUNLly7VRx99pCFDhmj48OGaOHGitm/fbpX3mWee0dq1a61+twAAAAAAAAAAAAAAAO4gOjracOFef39/5cqVyyk1rF+/3nDB7YceekhPPfWUqX2FhYWpdu3apuaEZ9i5c6dhvGXLlk6uxFrhwoUN40ePHjWtj8aNG5uWKyvy8fFxdQlpsrUAerVq1Uzrw8fHR82bNzctny2NGzd2yOfpbL2Wt23bdt99GYfS5gnnqK1btxrG//7yArP984sL7LF7927DeKNGjUzJn9WsX7/eMB4REeGQ87jRl1JI0pYtW5SQkGB6f56MYxlGGF+d68MPP9Sff/5p2DZ27NgH7u8ZypQpowkTJhi2nT59WgMGDMhU3qlTp2r58uWGbZUrV9ZHH32UqbxZwb8XmfzbrVu3dPXq1fvub/RlVNJf8/ySJUvaVZstxYoVU9u2bTNUz9/u3LmjO3fuGLZVrlzZ7trSUqlSJcN4XFycoqOj09zX055nV3Ln+0hm8YRrPUdzh3vjtrhzbX9zx3s8XJu4F67jkRGMS47jzvMaztsAAAAAAAAAAACA+UJDQ7V7925NmjRJpUuXzvD+VapU0ZIlS/TDDz8oT548DqjwL3PnzlWRIkXszvPOO+9ox44deuyxxzK8b/369bVjxw698847mer72WefVWRkpM3PyNmSN29ejR07Vhs2bFBgYGCm+gYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwJHWr19vGI+IiJCPj4/p/bVr184wvmXLFiUkJJjeH6Rjx47p1VdfNWyrUaOG3nnnHecW9P/NmjVLycnJVvHnn38+9djr3r274b4zZ850aG1Zjbe3t2bOnKmgoCDD9tGjRzu5ImuNGjXSI488YhW/fv26lixZouTkZIf+mzZtWobqcqVly5YpPj7eKv73+bVRo0ZWv+sVK1ZkKP+/Pfnkk/Lz81P27Nn15JNPWrUvXLgw3flhrt27dxvGGzVq5ORKkNU1btxY/v7+pudt2bKlYXzbtm2m92UPZ86ZHTFfnjZtmuG8q2fPnqn/f+qpp5QzZ06L9oSEBM2aNStTfeKv48boeX/ooYf01FNPmdpXWFiYateubWpOR3LVMcm46d527txpGLc1VngijkHzRUdHa+/evVZxf39/5cqVy3CfwoULG8aPHj1qWl2NGzc2LZczZaVj1BH3NdPy1VdfKSUlxSreo0cPi8ddunSx2ubkyZNuMf/lteE4W7duNYy3aNHCIf21bt3aIXkzw5OOq+vXrxvGq1WrZkp+6a9zU/PmzU3Ll57+zMZ7So7F85v1ZIU5AgAAAADP5u3qAgAAAAAAgGcKCAjQihUrFBISkhpLTEzU+PHjVaJECVWpUkXdunXTZ599JumvN7ybNGmi3Llzq0mTJlYfmClbtqxWrVolX19fm302a9bM6g8d9+zZo2bNmil//vyKiIjQyy+/rOHDh+vtt9/WwIED1apVKxUsWFDPPfeczp8/b7HvgAED1KZNGzufCWvlypXT1KlT5eXllRq7cOGCunTpopCQELVo0SK1zuHDh+vFF19UvXr19PDDD2v69OkWuQIDA7VgwYL7fihg3bp1ql69ut3/Pv/8c4u8cXFxmjt3bpp9v/jiixo0aJBF7NKlS/rPf/6jAgUKqH379ho6dKg+/vhjvf/++xo4cKAee+wxFS9eXJ9//rnFm+bh4eH65JNP0uwPAAAAAAAAAAAAAADgfgoVKuSQvBcvXjSM586d2yH9/du1a9dsLjwxcuRIZcuWzbS+3GExarjGmjVrDBfCKF++vJ544gkXVPR/8uTJYxiPjY01Jb+Xl5d69+5tSi5Pd+fOHcP4vxcAdTe//fabYTwkJETly5c3pY/27durYMGCpuRKS0hIiJ599llTc+bNm1ddu3Y1bFuzZs1992ccSpsnnKNs/f7Kli1r+MUC9ihWrJhpC+mtXbvWMN6mTRsVKFDAlD6yks2bN+v27dtW8WLFiqljx46m9uXj42P1OeK/LV++3NS+sgKOZRhhfHWuu3fvavjw4YZtJUuW1MCBA51ckev4+vpq/vz5ypEjh1VbUlKSunTpYjiepNcLL7ygS5cuGbYNHDhQTZs2zXRuRylVqpRatWrl0D46d+5sGP/ll1/Stf/cuXMNr9l9fX0d9uVyI0aMkJ+fn1U8OTlZ33zzzX33P3bsmGG8Q4cOdteWFltf9HHixAnD5/CfPPF5dhV3vo9kFk+41vsnd7437s61OZI73uPh2sS9cB2PjPC0ccmTuPO8hvM2AAAAAAAAAAAAYK4KFSpox44dCgsLs4inpKTo4MGDmjNnjmbPnp0aj4yM1IYNGxQTE2OVq1WrVtqxY4dD3rsbOnSomjVrZneeMWPGaOTIkfL2tvyqupiYGK1du1aTJk3S+++/r/fff1+TJk3S2rVrrX5Wb29vjRw5Uh988EGG+u7Ro4fmzZtn9XnVO3fu6IcfftDkyZP13nvvacyYMZo2bZp27dql5ORki23Dw8O1YsUKi/XeAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwB5s3b9bt27et4sWKFVPHjh1N7cvHx0eDBg0ybFu+fLmpfcHSl19+qVWrVhm2DRs2TA8//LCTK5LOnz+vH3/80SpeoEABPfnkk/Lz89Mzzzxj1f7TTz/p1KlTzigxy/jss8/UuHFjw7bt27dr5cqVTq7IWt++fQ3jc+bMUXx8vMP7X7Jkia5fv24V9/LyUp8+fRzef0bExMQYvnZatGghX19ftWnTxqotI+fY3bt369KlSxaxoKAgPf7443ryyScVEBBg0ZaUlKSlS5emOz/MtXbtWsN4mzZtVKBAASdXg6wsJCREzz77rKk58+bNq65duxq2rVmzxtS+7OWsObOj5svnz583PF907NhRQUFBkqQePXpYta9YsUKXL1/OdL8PumvXrmn9+vWGbSNHjlS2bNlM62v06NGm5XIGVx2TjJvubc2aNUpJSbGKly9fXk888YQLKjLfg34MFipUyCF5L168aBjPnTu3YTxPnjyG8djYWFPq8fLyUu/evU3J5WyeeozeuXPHKpYzZ06n1vD7779r48aNVvG2bdsqODhYkuTt7W14r2vmzJkOry89eG04jq05YdmyZfXkk0+a2lexYsXUokULU3Paw5OOq99++80wHhISovLly5vSR/v27VWwYEFTcv2T0XlQcsy5kPeUHIvnN+vJCnMEAAAAAJ7N29UFAAAAAAAAz/Tqq6+qVKlSqY9v3bqlxo0ba/DgwTp79mya+27YsEENGzZU//79LT4YWr16dY0YMcJwHy8vL40bN05eXl6psZkzZ6pWrVpat26d4QdM/5aQkKAFCxYoLCxM+/fvt2gbM2ZMmrVmxueff67s2bOnPj5w4IAeffRRzZs3TwkJCTb3u3Dhgv773/+qX79+FvEKFSqoc+fOafYZHR2tvXv32vXv2LFj6tSpk0XeSZMmpfn7LFasmD755BOL2O7duxUWFqaZM2cqMTHR5r5//vmnXnrpJbVu3driw0IvvfSSmjRpkubPCwAAAAAAAAAAAAAAYKRo0aL68ssvdebMGbVt29b0/P7+/obxu3fvmt6XLZ9//rlhvHz58qZ9FqZ79+5q1aqVKbngeS5duqRt27YZtg0bNszUvvr27auaNWume/ubN28axvPnz29KPZ07d1aZMmVMyeXpjBZil6QSJUo4t5AMOn36tKKiogzbjBYwzSgfHx+98847dudJr9dee02+vr6m5Rs0aJDV4vGSdO/evXQv9Mw4ZJsnnKOioqK0fft2wzazz/GjRo2Sj4+PKbl+//13RUZGWsX9/PxMX7wwZ86cKly4sKk5nS0hIUHffvutYdtbb70lPz8/0/r673//q6JFi1rF4+PjtXDhQtP6ySo4lmEL46tzzZw50/C1KEnDhw9XSEiIkytyjffee0/Vq1c3bBs9erR27NhhV/6rV6+qR48ehn/v4+XlpdmzZytfvnx29WGWihUrat68eTp+/LjmzZtnc6Fce9WrV0/t2rUzbLO1MPG/HT9+3OYC4d26dVOjRo0yW56hxx57TC+88IJh29KlS3XmzJn75rB1j6Ft27aqUKGCXfXZEhoaanOBVlv1/JMnPs+u4s73kcziCdd6knvfG3fn2pzF3e7xcG3iXriOR0Z4yrjkiZw1r8nMnIbzNgAAAAAAAAAAAGCegIAArVixwuLzoomJiRo/frxKlCihKlWqqFu3bvrss89S29evX68mTZood+7catKkibZu3WqRs2zZslq1apWpnw+pX7++Ro8ebXeeRo0aaejQoRaxK1euqGfPnipYsKCaN2+ul19+WcOHD9fw4cP18ssvq3nz5ipYsKB69uypK1euWOw7bNiwdH+GrlKlSpo6darFmvLXr1/XCy+8oJCQELVu3Vr9+/fXiBEj9Oabb6pXr16qXbu2Hn74Yc2bN8/q5xg8eHAmnwUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwjISFB3377rWHbW2+9JT8/P9P6+u9//6uiRYtaxePj47Vw4ULT+oGxnj176vLly1Zxb29v5cyZ0wUVSdOmTTOMd+/eXa1atVK+fPnSvQ+seXl5aeLEiRowYIBhe3x8vPr27evkqqyFhISoXbt2hm3O+n3Hx8dr3rx5hm09evSQv7+/U+pIL6NzZnBwsMLDwxUREWERv3PnjjZu3Jih/CtWrLCKtWnTxvD3tHnzZl29ejVD+WGe33//XZGRkVZxPz8/9e7d29S+cubMqcKFC5uaE57ltddek6+vr2n5Bg0apICAAKv4vXv3tGbNGtP6MYOz5syOnC9PnTrVKpYjRw516tRJxYoVU+PGjdO1DzLm888/N4yXL19eY8aMMaWPv+fOnsYVxyTjpnu7dOmStm3bZtg2bNgwU/vq27evatasaWrO9HhQj8GiRYvqyy+/1JkzZ9S2bVvT89u6Xrt7965h/ObNm4bx/Pnzm1JP586dVaZMGVNyOZunHqPXr1+3ipUoUcKU3BlhNE5lz55dnTt3liQ1btxYhQoVsmhPTk7W7NmznVLf/fDacJyoqCht377dsM3sMW7UqFHy8fExNac9POm4On36tKKiogzbevToYXd+Hx8fvfPOO3bnMWJ0HpQccy7kPSXH4vnNmjx9jgAAAADAs3m7ugAAAAAAAOCZevXqZfH4pZde0tatWzOUY/LkyXrxxRctYoMHDzb84EhKSooGDRqkH3/8UZK0e/du9erVS8nJyenu79q1a+rcubPi4+NTYxUqVFBYWFiG6k5LmTJlLD7kfPPmTUVEROjatWvpzjFlyhQtXrzYIvbMM8+YVqMtgwcPVsGCBVMf37hxQ++//36a+7z11lsWf/Rx9uxZtWzZ0uaHbIysXLlSL7zwglVeAAAAAAAAAAAAAACA9CpatKgmT56sU6dOqW/fvvL399fEiROVN29eU/sJDQ21iiUmJjp10d2VK1dq//79hm2DBg2yeyHp8PBwffHFF3blgOf78ssvDeNPPPGEBg4caEof1apV0+eff65du3Zp3bp1atCgwX33sfVaq1evnt31FC5cWJ999pndebKKCxcuGMZLlCihIkWKOLmajLG1mNd//vMfu8eFIUOGqGLFinblyIhKlSpp7NixpuSqX7++zQXN5s2bp5iYmHTlYRyyzVPOUbae3/DwcL3xxhum9NG4cWN1797dlFx/++qrrwzjb775pqkLGI4bN07Hjh3T4MGD3WrBvowaN26cUlJSrOKVK1fWhAkTTOmjSpUqGj9+vGHbnDlzdOnSJVP6yWo4lmGE8dW5UlJSNHjwYMO2XLly6b333nNyRc73+OOP2xz3d+7cadpzsHbtWptfwlCoUCFNnz7dlH4yq2LFilq6dKkOHjyo5557Tj4+PgoODtaMGTNM7ys4ONjmGJCcnKwFCxakO1daf+szf/58067ZChYsqG+//VZeXl5WbSkpKfrwww/TlWfJkiWGcV9fX02ZMsXUL7eR/lrcd8qUKTYXpbdVz7952vPsSu56H8ks7n6t5873xt25Nmdzx3s8XJu4F67jkV7uPi55OkfPa+yZ03DeBgAAAAAAAAAAAMzx6quvqlSpUqmPb926pcaNG2vw4ME6e/bsffffsGGDGjZsqP79+1u811+9enWNGDHClBpDQkL0zTffmPKe3SeffGLx+PTp06patapmzZqluLg4m/vFxcVp1qxZqlq1qk6fPm3Rlt7PwUydOtXii9aPHTumChUqaMaMGYqNjbW53/nz59WlSxd9/PHHFvE333xTgYGB6eobAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABnGTdunFJSUqzilStX1oQJE0zpo0qVKho/frxh25w5c3Tp0iVT+oFtly9f1n/+8x9Xl2Fh2bJlun79ulW8bdu2evnll63iN2/e1OLFi51RmscrUKCA1q5dq5deesnmNu+8844OHjzoxKqM9ezZU/7+/lbx3bt369ChQ06rY9q0aYbxfPny6amnnnJaHemxdOlSJSQkWMVHjBih4sWLW8TWr1+vuLi4DOVfvny5Vax169Zq3bq1VXzRokUZyg3zffXVV4bxN998U2XKlDGtn3HjxunYsWMaPHiwfHx8TMsLz1GpUiWNHTvWlFz169fXsGHDDNvmzZunmJgYU/oxkzPmzI6cL69YscIwR8+ePdWtWzd5eXlZxM+ePat169bZ1SeklStXav/+/YZtgwYNUt++fe3KHx4eri+++MKuHK7iqmOScdO9ffnll4bxJ554QgMHDjSlj2rVqunzzz/Xrl27tG7dOjVo0MCUvOn1IB2DRYsW1eTJk3Xq1Cn17dtX/v7+mjhxovLmzWtqP6GhoVaxxMREXb161XB7W/F69erZXUvhwoX12Wef2Z3HlTzxGL1w4YJVrESJEipSpIhdeTPq+++/Nzy+evToIUnq0qWLVdv69et1/vx5R5eWLrw2HMvWnC08PFxvvPGGKX00btxY3bt3NyWXWTztuNq+fbth/D//+Y/d49eQIUNUsWJFu3LYYnQelBx3LuQ9Jcfi+c16PH2OAAAAAMCzebu6AAAAAAAA4HmKFStm8cdJV65c0Zw5czKVa8qUKdq5c6ekv/5Q7L///a/hHxNK0o8//qimTZuqevXq6tOnj5KSkjLc34kTJ6w+cFy7du2MF27D8ePHValSJU2dOlX37t3TBx98oHPnzmU4z+TJky0eV6tWzawSDeXPn1+vv/66Rez9999XdHS0zX38/f317LPPWsRef/11mx8ISsv8+fO1cePG1Mfh4eF69NFHM5wHAAAAAAAAAAAAAAA8mKZMmaJ+/fpZLF5cvHhxLVq0SAEBAab0Ua1aNZUrV84qbmtRD0dJSUkxXJRbkry8vPTll19qxIgRmVq0qUOHDlq1apUCAwPtLRMe7ttvv9WxY8cM28aOHauWLVvalb9AgQL67rvvUo/Tpk2basuWLdqyZYseeughm/vZqqlPnz521RMQEKBFixapYMGCduXJSi5fvqw//vjDsO3FF190bjEZtHDhQsN4SEiIXQtSRUREaNSoUZneP7MGDRqkXr162ZWjbNmy+vbbb+Xr62vVlpSUZHOhISOMQ7Z5yjlq0aJFOnv2rGHbBx98oHbt2tmVv0yZMvr222+tFg2214wZMxQVFWUVDwgI0IIFCxQUFGR3Hz169FCvXr2UM2dOjRs3TpGRkelakNbPz0+TJk2y+c8Vjhw5YvN8+OKLL+qVV16xK3/p0qW1dOlSw7l2XFycxowZY1f+rMydj2W4DuOr823cuFErV640bOvVq5fDFgZ1B7lz59acOXPk7W293Mjt27f1/PPPZ+rvdWx5/fXXbX6pVNu2be2e69ojd+7catu2rdW8pV27dqaO4UFBQVq9erUqVKhg2L5w4cIM/e3Rtm3b9N133xm2FSpUSJs2bVKxYsUyVevfHnroIW3atMnmgrXz58/X7t2705Xrp59+0tGjRw3bGjRooDlz5pg6d5w+fbqeeOIJw7bTp0/rxx9/TFceT3ueXcld7yOZxd2v9dz53rg71+YK7naPh2sT98J1PNLL3cclT+fIeY29cxp3Pm+74/1RAAAAAAAAAAAAwJZ/f37jpZde0tatWzOcZ/LkyVZ/YzV48GDlz5/frvokae7cuRafK8vIZ0L+qXTp0lbrmj///PMZ+mzNhQsX9Pzzz1vEqlevrlKlSqW537PPPqu6deumPr5+/bqefPJJw/c9bRk2bJj279+vGzduaPLkyWrevLnu3LmT7v0BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHCGI0eOaOHChYZtL774ol555RW78pcuXVpLly5VQECAVVtcXJzGjBljV36k38qVKzVlyhRXl5EqPj5e8+bNs4pnz55djRo1sop/8803unfvnjNK81g5cuTQq6++quPHj6tp06Y2t1u8eLHbvPZ69+5tGJ82bZpT6zhw4ID27Nlj2Na3b1+n1nI/MTEx+vHHH63iDRo0sIotW7Ysw/l//PFHq9daiRIlFBISYhFLTk7W999/n+H8MNeMGTMUFRVlFQ8ICNCCBQsUFBRkdx89evRQr169lDNnTo0bN06RkZGGxxuyvkGDBqlXr1525Shbtqy+/fZb+fr6WrUlJSVp/PjxduV3FGfMmR05X05KStKsWbOs4g0aNNBLL71kFZ82bZpSUlLs7vdBl5KSopdfftmwzcvLS19++aVGjBghHx+fDOfu0KGDVq1apcDAQHvLdAlXHZOMm+7t22+/1bFjxwzbxo4dq5YtW9qVv0CBAvruu+9SX3NNmzbVli1btGXLFj300EN25U6vB+kYnDJlivr16yd/f//UWPHixbVo0SLDMS8zqlWrpnLlylnFL1y4YHMfW8dYnz597KolICBAixYtUsGCBe3K42qeeIxevnxZf/zxh1X8xRdftKPKjEtISNDs2bOt4vXq1VOVKlXUoUMHq7YZM2Y4o7R04bXhWIsWLdLZs2cN2z744AO1a9fOrvxlypTRt99+Ky8vL7vymM3Tjitb13whISH67LPPMp03IiJCo0aNyvT+92PrPCg55lzIe0qOxfOb9Xj6HAEAAACAZ/N2dQEAAAAAAMDzFClSxOLxoUOHlJycnOl8ffr00WOPPaZatWrpm2++UVJSUprb7927V/v27ct0f/v377d4/O+fx16//fab+vTpo6JFi2rSpEmZynHo0CGLxwUKFDCjNJtGjBihnDlzpj4+e/bsfWuvU6eOcuXKlfr4ypUrWrRoUaZr+OKLLywet27dOtO5AAAAAAAAAAAAAADAg+Xtt982XISucePG2rBhg4oVK2ZX/uDgYM2cOdOwbfXq1XblzoytW7dafdbin959910dOHBAERER6VrE8NFHH9WqVau0ePFii8UmoqKidPPmTVNqhmdJTk62uYCJn5+fli9froEDB2Yqd5kyZbRlyxaVLFnSqi1//vyGC5z9be3atYbxJk2a6L///W+m6ilUqJC2bt2qxx57LDW2d+/eTOXKajZv3mwYf/311w2/HMBdLFq0SOfOnTNs69Kliz766KMM5+zZs6eWLFlicU61tXiWI0ydOlXjx4/P1MK0zZs31y+//GJzMc0pU6bot99+y1BOxiFjnnKOSkhI0ODBgw3bfHx8tGTJEg0dOjRTucPDw7Vt2zaLLyo4f/58pnL927179/T2228btlWrVk1bt261a9G5/v37a/r06RaxihUrasuWLWrVqlWa+/r5+WnAgAE2/7nKwIEDFR0dbdj26aefasqUKRaLwabXE088oV27dhmO5ZI0atQonTp1KsN5HxTufCzDtRhfne+1115TYmKiVdzHx0effvqpCypyjv/9738275O89NJLOn36tKn9xcXF6bnnnlNcXJxh+4QJE1SmTBlT+0yvn3/+WevXrzdsGzBggFatWmX3PaV69eopMjJSdevWNWy/d++ehg8fnuG8AwcO1PXr1w3bHnnkEe3du1ft27fPcF7prwVy9+3bp/Llyxu2X7lyRa+++mqGctoa+yTpmWee0caNG+1+rh966CGtX79e3bt3T7OOjHyRhac9z67irveRzOLu13rufG/cnWtzFXe6x8O1ifvhOh7p4e7jkqdz1LzGjDmNO5+33fX+KAAAAAAAAAAAAPBvxYoVU/HixVMfX7lyRXPmzMl0vilTpmjnzp2SpN27d+u///2vzc+cpdfQoUPVrFmz1Mfjxo3T0qVLM5WrTp06Fo9//fXX1HozYufOndqzZ0+auf+tV69eFo9HjRqls2fPZqjf5ORkRUREqFChQurfv792796dof0BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHCWgQMHKjo62rDt008/1ZQpU+Tv75/hvE888YR27dqlkiVLGraPGjVKp06dynBeZN7gwYN17NgxV5eRatq0aQ7Z9kHi6+urxx9/XBMnTtSFCxf0ySefKDg42Ob227ZtU5cuXZxYoW1PPPGEQkNDreJ3797VggULnF6PrWOsYcOGKleunJOrSdvChQvvu01ycrJWrlyZ4dyxsbFav379fbfbsmWLLl++nOH8MNe9e/f09ttvG7ZVq1ZNW7duVcGCBTOdv3///po+fbpFrGLFitqyZYtatWqV6bzwXFOnTtX48ePl4+OT4X2bN2+uX375RQ899JBh+5QpU/Tbb7/ZW6LDOHrObMTM+fJXX32llJQUq/i/zxFJSUmaMWOGKX1C2rp1q7744gub7e+++64OHDigiIiIdL2uHn30Ua1atUqLFy9WQEBAajwqKko3b940pWZnccUxybjp3pKTk/XKK68Ytvn5+Wn58uUaOHBgpnKXKVNGW7ZsMbw/kT9/fkVFRWUqb0Y9SMfg22+/bfgab9y4sTZs2KBixYrZlT84OFgzZ840bFu9erXN/dauXWsYb9Kkif773/9mqpZChQpp69ateuyxx1Jje/fuzVQuV/PUY3Tz5s1Wsddff12NGjXKdM7MmDp1qmF87ty5ypkzp0Xsxo0bWrp0qROqSh9eG46VkJCgwYMHG7b5+PhoyZIlGjp0aKZyh4eHa9u2bQoJCUmNnT9/PlO5zOZpx9WiRYt07tw5w7YuXbroo48+ynDOnj17asmSJRZzfUfcnzc6D0qOOxfynpJj8fxmPZ48RwAAAADg2bxdXQAAAAAAAPA8fn5+Fo9jY2PtynfgwAFt377drhwZ8e833P/5gWszXb9+XXfv3s3Uvv/eLzMfAkivUqVKqU+fPhax4cOHKz4+Ps39qlSpYvF406ZNhh8KTa+NGzdaPK5fv36mcwEAAAAAAAAAAAAAgAfLvn379OWXXxq21a1bV7/99pvefvtt5c+fP8O5mzZtql9++cXqsxJ/W7RoUYZzmuGVV17Rjh07bLZXqFBBK1as0JUrVzR//nwNHz5cvXv3VseOHdW9e3e98cYbmjx5sk6fPq39+/erRYsWVjlefPHFTH/+BZ5v9erVNhfD8PHx0YQJE/Trr7/qySefTFe+wMBADRs2THv37lXZsmWt2lNSUjRo0CAlJSXZzLFt2zZdvXrVsO1///uf3n77bfn6+qarHj8/Pw0YMEAHDhxQ9erVU+MxMTEaPnx4unJkdbbOq35+flq3bp3GjRun0qVLO7mq+0tKStKnn35qs/2NN97QqlWrVKZMmfvmCgsL08qVKzVjxgyLz04eOHAgXYu/22PPnj0WjwcNGqQjR46oU6dO8vLyuu/+FStW1NKlS7V69WqbX0Zw7ty5TB/vjEPWPOkctXjxYv3www+GbV5eXhozZoz27dtn+HsxUqZMGc2cOVMbN260mG/FxsbqzTfftLvev3311Vf68ccfDdvCwsJ06NAhDRgwIN3PsyRVqlRJP/zwgz7//HN5e1v/2fXu3bvTXLzUnUVFRVl9Rvif+vTpo+PHj6tLly7pes7Kly+vxYsX68cff1TevHkNt9m+fbs+/vjjTNf8oOBYhi2Mr8519OhRm9c8Tz75ZLrHQU/SrVs3de7c2bBt8eLFmjVrlkP6PXjwoIYNG2bYliNHDi1YsCBD5zwz9erVSzdu3DBsa9GihY4ePaopU6ZYzMnSo1GjRlq6dKm2bt2qUqVK2dxu6NChmVrg8+LFi+rRo4fNv+MJCQnRkiVLtHXrVnXu3FlBQUFp5gsMDFTHjh21efNmrVixQgUKFDDcLjk5Wd27d8/wYv3fffedli9fbrM9PDxchw8f1qRJk1ShQoUM5S5btqwmTJigI0eOqEmTJja3W716tebPn5+h3J72PLuSO95HMou7X+u5871xd67Nmdz5Hg/XJu6F63ikh7uPS1mB2fMaM+c0nLcBAAAAAAAAAAAA+xQpUsTi8aFDh5ScnGxXzj59+uixxx5TrVq19M0339j1mab69etr9OjRqY937typoUOHZjpf4cKFLR7v27cv07n+ve+/c/9TsWLFFB4envr4ypUrmjx5cqb6vXDhwn3XSQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwNWioqLUp08fm+19+vTR8ePH1aVLF/n6+t43X/ny5bV48WL9+OOPyps3r+E227dv18cff5zpmpE59+7d03PPPaeEhARXlyJJOnDggPbu3Xvf7Q4fPqzdu3c7oSLnadKkiXr37p2hfy+++KJeffVVjR49Wl9//bV27NihW7duafPmzXrppZeUO3fuNPtcu3atnnzyScXGxjrnh7yPvn37GsYXLVqkW7duObkaaf78+bp3755hW1rnSFdYunTpfV/Hv/zyi65cuZKp/MuWLbvvNosWLcpUbpjvq6++0o8//mjYFhYWpkOHDmnAgAHpGsP/VqlSJf3www/6/PPP5e3tbdW+e/durV69OtM1w7Ps2bPH4vGgQYN05MgRderUSV5eXvfdv2LFilq6dKlWr16t4OBgw23OnTun4cOHm1Kvozh7zmz2fPn06dPauHHjfbdbvXq1Lly4YFq/kF555RXt2LHDZnuFChW0YsUKXblyRfPnz9fw4cPVu3dvdezYUd27d9cbb7yhyZMn6/Tp09q/f79atGhhlePFF1/U3bt3HfljmM5VxyTjpntbvXq1pk6datjm4+OjCRMm6Ndff9WTTz6ZrnyBgYEaNmyY9u7dq7Jly1q1p6SkaNCgQUpKSrKr7ox4UI7Bffv26csvvzRsq1u3rn777Te9/fbbyp8/f4ZzN23aVL/88ouqVKli2J7Wtcq2bdt09epVw7b//e9/evvtt9P93Pv5+WnAgAE6cOCAqlevnhqPiYlx+3lNWjzxGDU61vz8/LRu3TqNGzdOpUuXznTujDh27Ji2bdtmFa9cubJVbMGCBYqPj3dGWenCa8PxFi9erB9++MGwzcvLS2PGjNG+ffsM53pGypQpo5kzZ2rjxo0W59LY2Fi9+eabptRsL087rpKSkvTpp5/abH/jjTe0atUqlSlT5r65wsLCtHLlSs2YMUN+fn6p8QMHDmjhwoWm1PtPtsZcR50LeU/JsXh+sx5PniMAAAAA8Gzpv4sLAAAAAADw/924ccPicYECBVxUSebkyZPH4rEr/kDtfvLly2fx+ObNmw7ra8yYMRYfXomMjNTcuXPvu9+/f+/nzp2zq47o6GjdvXtXOXLkkCTVqlXLrnwAAAAAAAAAAAAAAODB8sorr6hWrVqqUaOGVVtQUJBGjRqlt99+Wzt27NCmTZt05MgR/fHHH7p165bu3r0rLy8vBQYGKjg4WKVLl1ZYWJhatWqV5iIia9asSddCeY6QkJCgFi1aaO3atapdu7bN7fLkyaNnn302w/k//PBDLVmyRF988YU9ZcLDDRgwQGXLltXjjz9u2F69enWtXbtWV65c0bp167Rv3z5dvnxZ165dkyQFBwerRIkSqlWrlpo1a6aAgACbfY0dO1Zr165Ns564uDi9//77Gj9+vFWbt7e3Ro0apb59+2rOnDnaunWrjh49qujoaMXGxio4OFgFChRQaGiomjVrplatWqlw4cIWOVJSUtSjRw9FRUXd76l5IOzatUubNm1So0aNrNp8fX01ePBgDR48WFFRUTp37pxu3ryp5ORkq22vXr2aqfOQPSZOnKi2bdsqPDzcsL1FixZq1qyZfvnlF61bt05//PFH6iLt+fLlU6VKldSkSRNVrVrVat/4+Hj16NFDrVu3duSPoJ49e2rXrl3Knj17auyRRx7RwoULde3aNa1Zs0a//vqroqKidP36deXMmVMFChTQI488oubNm6tcuXJp5o+Li1OHDh0UHR2dqfoYh6x52jmqS5cu+vXXXxUaGmrYHhYWplWrVikqKkpr1qzR/v37FRUVpRs3bihbtmzKmzevKlasqEaNGqlatWqGOQYOHKhTp06ZUu/fnnnmGe3evVslS5a0agsJCdGkSZM0fPhwrVmzRuvXr9e5c+d0+fJl3b17V/7+/sqZM6eKFy+uypUrq0WLFqpbt67NxdMvXbqkzp07G57bPMXChQtVsWJFjRgxwrD94Ycf1pw5c/T5559r7dq12rVrl6KionT16lUFBgaqYMGCCg0NVfPmzVW+fPk0+/rjjz/Utm1bJSYmOuJHyXI4lmGE8dX5Ro4cqS5duihXrlxWbZ9++qnWrVvn1EXJHalUqVL6/PPPDdsuXLigXr16ObT/8ePHq0WLFmratKlVW7Vq1TR69GgNHTrUoTUYOXPmjJ5//nktW7bM4m9r/pYjRw716dNHffr00dWrV7Vz506dOHFCZ8+e1Z07d3T37t3UuVG+fPkUFhamOnXq3PeLwSRp+vTpmjhxYqZrX7FihV555RVNmDDB5jb169dX/fr1lZiYqEOHDunkyZOKjo5WXFyc/P39lTt3boWGhqpSpUqGP/+/vfzyy5leILxbt27auXOnzWuVnDlzasCAARowYIAuXryo3bt36/Dhw7p+/XrqvDl79uzKnTu38uTJowoVKqhmzZoqWrToffs+fvy4nnvuuUzV7WnPsyu5230ks3jCtZ473xt359qcxd3v8XBt4l64jsf9eMK4lBWYOa9p166dzX4yM6fhvA0AAAAAAAAAAABk3r8/vxUbG2t3zgMHDtidQ/rr/b5vvvlGPj4+kqTr16+rc+fOdr2v//c633+zZ43zmJgYi8eBgYE2t42IiLB4H3LZsmVKSEjIdN8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHiChQsXqmLFihoxYoRh+8MPP6w5c+bo888/19q1a7Vr1y5FRUXp6tWrCgwMVMGCBRUaGqrmzZurfPnyafb1xx9/qG3btkpMTHTEj4L72Lt3r0aMGKExY8a4uhRJ0rRp0zR58uT7bpPV9OzZUz179nRKXykpKfr444/11ltvKSkpySl93k+BAgXUtm1bwzZX/b5v3ryp7777Tl27drVq6969u4YNG6bY2FgXVGYtOjpaGzZsUPPmzW1us2zZskzn/+GHH5SSkiIvLy/D9uTkZC1ZsiTT+WG+Z555Rrt371bJkiWt2kJCQjRp0iQNHz5ca9as0fr163Xu3DldvnxZd+/elb+/v3LmzKnixYurcuXKatGiherWrWvz93/p0iV17txZycnJjv6x4CZ69uypXbt2KXv27KmxRx55RAsXLtS1a9e0Zs0a/frrr4qKitL169eVM2dOFShQQI888oiaN2+ucuXKpZk/Li5OHTp0UHR0tIN/Evs5a87sqPny1KlT9cQTT9x3G5grISFBLVq00Nq1a1W7dm2b2+XJk0fPPvtshvN/+OGHWrJkib744gt7ynQJVx2TjJvubcCAASpbtqwef/xxw/bq1atr7dq1unLlitatW6d9+/bp8uXLunbtmiQpODhYJUqUUK1atdSsWTMFBATY7Gvs2LFau3atQ36OtDwox+Arr7yiWrVqqUaNGlZtQUFBGjVqlN5++23t2LFDmzZt0pEjR/THH3/o1q1bunv3rry8vBQYGKjg4GCVLl1aYWFhatWqlcqUKWOzzzVr1mjjxo022+Pi4vT+++9r/PjxVm3e3t4aNWqU+vbtqzlz5mjr1q06evSooqOjFRsbq+DgYBUoUEChoaFq1qyZWrVqpcKFC1vkSElJUY8ePRQVFZWBZ8r9eNoxumvXLm3atEmNGjWyiPv6+mrw4MEaPHiwoqKidO7cOd28edOwr6tXr2ZqHP63qVOnqn79+vfdbsaMGXb3ZSZeG87RpUsX/frrrwoNDTVsDwsL06pVqxQVFaU1a9Zo//79ioqK0o0bN5QtWzblzZtXFStWVKNGjVStWjXDHAMHDtSpU6cc+WOkmyceVxMnTlTbtm0VHh5u2N6iRQs1a9ZMv/zyi9atW6c//vhDV65ckSTly5dPlSpVUpMmTVS1alWrfePj49WjRw+1bt3atHr/Zus8KDnuXMh7So7F85v1eOocAQAAAIBn83V1AQAAAAAAwPNcuHDB4g+KHn30UeXNm1fXr193cWXpU716dYvHx48fd1ElttWpU8fi8cWLFx3ST/Xq1dWpUyeL2BtvvKGUlJT77vvvD9/evn3b7npu3bqlHDlySPrrg/O+vr58WAEAAAAAAAAAAAAAAKRLfHy8WrRooTVr1lh9PuRvfn5+atiwoRo2bGh3f9euXVPfvn3tzmOPmJgYNWnSRLNmzdJTTz1lWt7x48dr2LBhpuWD50pISFBERIRWrFhhc7EdScqfP7+ef/55Pf/885nqZ9asWRo6dGi6tp08ebK6detmuHiPJD300EMaMmSIhgwZkuE6hgwZoqVLl9pcuOlB1LNnT0VGRio4ONjmNgULFlTBggVttp8/f94RpaUpOTlZzz77rPbv32+zNm9vb9WtW1d169bNUO4BAwZo3759Dlkk6p8OHjyoLl26aOHChfL29rZoy5cvn12vubi4OHXq1Em//vqrXTUyDlnzpHNUTEyMmjVrpg0bNqhEiRI2tytYsKC6d++u7t27Zyj/xIkTNXXqVNWrV8/OSi1du3ZNTzzxhDZu3Giz7szW/E+XL19W8+bN9ccff2Q6h7sYOXKkvLy89Pbbb9vcJjg4WJ07d1bnzp0z1cfRo0fVrFkzXb16NbNlPnA4lmEL46tzXb16VaNHj9bHH39s1VauXDn17dvXIxf1/zcfHx/NmzdPOXPmtGpLSUlRt27ddOPGDYfX0b17dx08eFD58uWzanv99de1Zs0abd682eF1/Nvq1asVERGhxYsXKygoyOZ2ISEhioiIMKXPadOmqXfv3nbn+eyzz+Tt7a1x48bZXNhb+mvR2bCwMIWFhWWqn+TkZL366qt2vR5iYmLUuHFjrV+/XhUrVkxz24ceekht27a1+YVlGXHkyBE1adLEri+58aTn2ZXc8T6SWdz9Ws+d7427c23O4u73eLg2cT9cx+N+3H1cygqcMa/J7JyG8zYAAAAAAAAAAACQef/+rGSBAgVcVIm1uXPnqkiRIpL+77Od586dsyvnnTt3LB7nyZMn07ny5s1r8fjWrVs2t/33e84rVqzIdL8AgKyhY8eOqlylsqvLAGyaN3eeW35nDQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADA84wcOVJeXl56++23bW4THByszp07q3Pnzpnq4+jRo2rWrJmuXr2a2TJhgo8++kgtW7ZUgwYNXF2K5s+fr08//VTZs2c3bE9ISNDcuXOdXFXWcfToUQ0YMEAbNmxwdSkWevbsKT8/P6v48ePHtW3bNhdU9Jdp06apa9euVvE8efKoU6dOmjNnjguqMrZw4UI1b97cZvvy5csznfvy5cvatWuXateubdj+888/69KlS5nOD/Ndu3ZNTzzxhDZu3KgSJUoYblOwYEF1795d3bt3z3Q/ly9fVvPmzfXHH39kOgc8z8GDB9WlSxctXLhQ3t7eFm358uXT888/r+effz5TuePi4tSpUyf9+uuvZpTqFI6eMztyvvz999/r6tWrCgkJMWy/ePGiVq5caXq/kGJiYtSkSRPNmjVLTz31lGl5x48fr2HDhpmWz9lcdUwybrq3hIQERUREaMWKFQoPD7e5Xf78+e0ag2bNmqWhQ4dmskr7PCjHYHx8vFq0aKE1a9aoevXqhtv4+fmpYcOGatiwod39Xbt2TX379r3vdpMnT1a3bt1UtWpVw/aHHnpIQ4YM0ZAhQzJcw5AhQ7R06VJVq1Ytw/u6E088Rnv27KnIyEgFBwcbthcsWFAFCxa0uf/58+ftrkGSFi1apIkTJyp37tw2tzl06JD27NljSn9m4rXheDExMWrWrJk2bNhg87UlZf71NXHiRE2dOlX16tWzs1LzeNpxlZycrGeffVb79++3ec7w9vZW3bp1Vbdu3QzlHjBggPbt26fWrVubUaqV+50HJfPPhbyn5Fg8v1mLJ88RAAAAAHgu7/tvAgAAAAAAYOnGjRs6fPhw6mNfX1+NGjXKhRWlX7ly5dSkSZPUxwkJCVq/fr0LKzLWv39/i8e7du1ySD9jx46Vl5dX6uMNGzZo3bp16do3Pj7e4nFQUJDd9eTMmdPicVpvoAMAAAAAAAAAAAAAAPzb1atXFR4eru+//96h/Vy8eFENGjTQmTNnHNpPety+fVsdO3bUCy+8oCtXrtiV6/r16+rWrZsGDx5sUnXICm7fvq1mzZppypQppudOSUnRRx99pJ49eyolJSVd+/y9cN3vv/9uWh0JCQnq06ePxo4da1rOrOLMmTNq3769oqOjXV1Khl26dEkNGjTQiRMnTMmXnJysgQMH6quvvjIlX3osXrxYnTt31r1790zLeeXKFTVv3lwrVqwwJR/jkCVPO0edPn1ajz32mOkLGn344YcaOHCgqTn/6ffff1e9evX0888/OyT//v37VaNGDUVGRjokvyuMGDFC//nPf3T79m3Tc69atUr16tXT2bNnTc+d1XEswxbGV+f67LPPbC56/O6772aJv2sYMWKE6tSpY9j26aefauPGjU6p488//1SvXr0M27y9vTVnzhyXPd/r1q1T3bp1Hf5lKLGxsRowYIB69eqV7uvg+xk/frzatWuna9eumZLv365du6b27dtrwoQJduf6888/VbduXS1atMj+wtJh6tSpqlWrli5evGh3Lk96nl3J3e4jmcUTrvXc+d64O9fmLO5+j4drE/fDdTzS4gnjUlbgqHmNGXMaztsAAAAAAAAAAABA5ly4cMHifbpHH31UefPmdWFFfxk6dKiaNWuW+njcuHFauXKl3XmPHTtm8bh27dqZzvXvfY8fP25z27CwMIvHvPcIAPD391eOHDn4xz+3/eftw1f6AgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADMM2LECP3nP//R7du3Tc+9atUq1atXT2fPnjU9NzImJSVFXbp0UUxMjKtLUUxMjL7//nub7StWrNDVq1edWFHWcOrUKfXv31+VKlXShg0bXF2Old69exvGp0+f7uRKLG3ZskUnT540bOvbt6+Tq0nb0qVLlZCQYNh2+vRpHTlyxK78y5Yts9m2aNEiu3LDMX7//XfVq1dPP//8s0Py79+/XzVq1FBkZKRD8sO9LV68WJ07d9a9e/dMy3nlyhU1b95cK1asMC2nszhqzuzo+XJCQoJmz55ts33mzJlKTk52SN+Qbt++rY4dO+qFF17QlStX7Mp1/fp1devWTYMHDzapOtdw5THJuOnebt++rWbNmmnKlCmm505JSdFHH32knj17KiUlxfT86fWgHINXr15VeHh4mtf9Zrh48aIaNGigM2fO3Hfb+Ph4tWjRQr///rtp/SckJKhPnz4aO3asaTldzdOO0TNnzqh9+/aKjo42JV9mxcbGat68eWlu4+p7H7bw2nCO06dP67HHHtOePXtMzfvhhx9q4MCBpuY0gyceV5cuXVKDBg104sQJU/IlJydr4MCB+uqrr0zJZ4urzoO8p+RYPL9ZhyfPEQAAAAB4Lm9XFwAAAAAAADzTrFmzLB73799f7733nnx8fFxTUDrkz59f3333nXx9fVNjM2fO1LVr11xYlbXevXurQYMGFrH58+eb3k+zZs3UqFGj1McpKSl6/fXX073/jRs3LB4XLVrUrnpy586tHDlyWMUAAAAAAAAAAAAAAAAy4vbt2+rQoYM6duzokMUS5s+frxo1ati9oK/ZZsyYoZIlS2ro0KEZXhDlypUreu+991S2bFnNmTPHQRXCk8XHx6tfv35q0aKFjh8/bkrO06dPq1mzZho6dGiG942KilLt2rW1cuVKu+uIjIxUzZo1NXXqVLtzZVWbNm1SzZo19dNPP7m6lAw7ceKEKcfK1atX1apVK02cONGkytJv8eLFqlOnjvbu3WtKrooVK2rz5s32F/YvjEP/x9POURcvXlTt2rU1cuRIxcbG2pXrypUratOmjYYNG2ZSdbb9+eefevzxx/XGG2/ozp07puS8d++ehg0bppo1a+rcuXOm5HQnM2fOVKVKlbRq1SpT8l26dEk9evRQq1atrD5XjPTjWEZaGF+dIz4+XkOGDDFsy5cvn0aMGOHkisxVr149vfXWW4ZtkZGRThm3/+n777+3uaBi0aJFHb4oa1oOHTqkWrVqqX///qafP1NSUrRs2TJVrFhRX3zxham5JWn58uWqUKGC5syZY9oXNiQnJ2vu3LmqUKGCli9fbkpOSbp165Y6d+6sNm3a6OjRo6bl/afDhw+radOm6tOnj6kLtXrS8+xK7nYfySyecK3nzvfG3bk2Z3H3ezxcm7gfruORFk8Yl7ICs+c1Zs5pOG8DAAAAAAAAAAAAGXfjxg0dPnw49bGvr69GjRrlwoqk+vXra/To0amPd+zYYdrnpDZv3mzxdyIVK1ZU8+bNM5ynWbNmqlChQurje/fupfl3ZuXLl0/9/927d3XmzBmrbXLkyKH69eurR48eevnllzVo0CC98MILatKkiUJCQjJcIwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA7mTmzJmqVKmSVq1aZUq+S5cuqUePHmrVqpVu3LhhSk7Y7+zZs3rxxRddXYYkadq0aZlqg6UbN25ozpw5ioiI0COPPKLJkycrKSnJ1WVZadq0qUqVKmUVT0xM1Ndff+2CiixNnz7dMF6vXj1VqlTJydXYduPGDW3cuNGwbfny5Xbnt5UjJSVFixcvtjs/HOPPP//U448/rjfeeEN37twxJee9e/c0bNgw1axZU+fOnTMlJzzT4sWLVadOHe3du9eUXBUrVtTmzZvtL8xFzJ4zO2u+PHXqVMN4SkoK8y4nmTFjhkqWLKmhQ4fqxIkTGdr3ypUreu+991S2bFnNmTPHQRU6lyuPScZN9xYfH69+/fqpRYsWOn78uCk5T58+rWbNmmno0KGm5LPXg3IM3r59Wx06dFDHjh119uxZ0/PPnz9fNWrU0JEjR9K9T1RUlGrXrq2VK1fa3X9kZKRq1qxp83zmyTztGN20aZNq1qxpas7MSOtYSEhI0Ny5c51YTcbw2nCOixcvqnbt2ho5cqRiY2PtynXlyhW1adNGw4YNM6k683nicXXixAlTar569apatWqliRMnmlRZ2v4+D/70009O6e9vvKfkWDy/WYcnzxEAAAAAeCZvVxcAAAAAAAA805QpU/T7779bxIYPH67Dhw/r5ZdfVunSpV1UmbWgoCD17t1bhw4dUsWKFVPjhw8f1muvvebCyqw9/fTT+uKLLyxiv/76q9atW2dqP15eXvr4448tYgsWLNC+ffvSnePfH8gMDw+3q6bGjRtbxby9uX0FAAAAAAAAAAAAAAAyZ/HixSpZsqQ6duyo9evXKy4uLtO5oqOjNXPmTNWpU0fPP/+8/vzzTxMrNc+dO3f00UcfqUyZMgoLC1P//v01ffp0rV+/Xrt379aRI0e0b98+bdmyRXPmzNGwYcNUr149FSpUSCNGjNDVq1etcmbLls2wr8TEREf/OHBDa9asUYUKFfTMM89o69atSk5OznCOgwcPql+/fipbtqzWr1+f6VquXLmiiIgIderUSdu2bcvw/nv27FHnzp1VtWpVRUZGZrqOB8XJkycVHh6uWrVq6csvv1RkZKRbLmpv5MaNG4qIiFB4eLh+/vnnDO0bExOjcePGKTQ0VGvWrHFQhfd34MAB1axZU127dtXhw4cztG9sbKy+++47Va9eXR07dtSVK1ccVCXj0D952jkqKSlJo0aNUokSJTR27Fhdvnw5Q/tHRUVp5MiRKlWqlFasWOGgKq0lJSVp7NixKlGihN59991ML2R6/vx5vfvuuypWrJg+/PBDtz++7HHmzBm1atVK1atX1zfffJOpBUQjIyPVr18/lShRwi2+MCQr4FhGWhhfnWPhwoXauXOnYduAAQMUGhrq5IrMkTNnTs2bN08+Pj5WbbGxsXr22WeVkJDg9LpefvllnTx50rCtY8eO6t69u5Mr+j8pKSmaPHmySpYsqc6dO2vlypW6e/dupvNdvXpVX3zxhR599FG1a9dOp0+fNrFaS5cvX1a3bt1UoUIFTZw40fD1nx7Xrl3T559/rooVK6pr164Znhum14oVK1S+fHlFRERo0aJFdj3PknT37l3NmTNHjz32mCpVqqQff/zRpEotedrz7ErudB/JLJ5yrefO98bduTZncPd7PFybuB+u45EWTxmXsgJ75zWOmtNw3gYAAAAAAAAAAAAybtasWRaP+/fvr/fee8/ws5aOFhISom+++Sa17+vXr6tz586m/c3W7du3rT4rMHv2bIs12u+nfPnymj17tkXs66+/1u3btw239/HxUWBgYOrjf3+mp0mTJvrhhx9048YNbd26VTNnztRnn32m8ePHa9q0aVq/fr0uX76snTt3qnv37vL19U13rQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuJMzZ86oVatWql69ur755hvduXMnwzkiIyPVr18/lShRQl9//bUDqoS95s+frwULFri6DG3cuFF//PGHVfzixYtau3at8wtyU8nJybp9+7YuX76so0ePau3atZo6dar69u2ratWqKX/+/OrWrZtWrlyplJQUV5drU9++fQ3jK1euVFRUlJOrsTZr1iwlJSUZtvXp08fJ1aRt4cKFhvFly5bZnfvw4cP6/fffreI7duzQxYsX7c4Px0lKStLYsWNVokQJvfvuuzp79mym8pw/f17vvvuuihUrpg8//FCJiYkmVwpPdODAAdWsWVNdu3bV4cOHM7RvbGysvvvuO1WvXl0dO3bUlStXHFSl85g5Z3bWfPnYsWPatm2bVXz9+vWG8zE4xp07d/TRRx+pTJkyCgsLU//+/TV9+nStX79eu3fv1pEjR7Rv3z5t2bJFc+bM0bBhw1SvXj0VKlRII0aM0NWrV61yZsuWzbAvdz9/u/qYZNx0f2vWrFGFChX0zDPPaOvWrUpOTs5wjoMHD6pfv34qW7as1q9f74AqM+9BOgYXL16skiVLqmPHjlq/fr3i4uIynSs6OlozZ85UnTp19Pzzz+vPP//McI4rV64oIiJCnTp1MjwP3c+ePXvUuXNnVa1aVZGRkRne31N42jF68uRJ1apVS19++aUiIyNtXt870oEDB7R7927DtpUrVxqO4+6E14ZzJCUladSoUSpRooTGjh2ry5cvZ2j/qKgojRw5UqVKldKKFSscVKV5PPG4unHjhiIiIhQeHq6ff/45Q/vGxMRo3LhxCg0N1Zo1axxUobGTJ08qPDzc6edC3lNyLJ7frMHT5wgAAAAAPI9XSjo/Qebl5eXoWgB4qCpVqqhKlSqSpJSUFJ0+fVo7d+506w+oAgAAADBHWFiYNm3apNy5cxu2X79+XefPn1eVKlU0b948vfbaa7p06ZLpddSoUUMjR460iHl5eSkgIEAFCxZUuXLl5OPjY9F+6tQpNW7cONMfdjNbjhw59MEHH+jll1+2uA9z584d1atXTwcOHDC1v65du2r27Nmpj+Pj41W2bNkMfTA7d+7cunLlinx9fVNjHTp00Pfff5+pmjZs2KDGjRtbxMqWLavjx49nKh8AAAAAzzT2k7GuLgEPgCO/HdGMGTNcXQYAmGLgYilboKurQFZ2/pA0/zVXVwEAsMXLy0s1atRQmTJlUt9nPHDggOnvLyJ9+Ewt4P4CAgL0+OOP69FHH1W5cuVUqlQp5cqVS0FBQQoMDFRKSopu376tW7du6ebNmzp16pQOHDiggwcP6ueff1ZCQoKrfwSXSEpKkre3t1W8WrVq2rdvnwsqgjspUKCAwsPDVadOHYWGhqp48eLKmTOnAgIClJycrJiYGEVHR+vo0aPat2+fNm7cqN9++80htZQtW1b169dX3bp1FRoaqty5cytPnjzy8/PTzZs3U+vYu3evVq1apZMnTzqkjgdJYGCgChUqpDx58qQ+10ZiY2O1ceNGJ1dnW9GiRdWsWTM1atRIhQsXVoECBZQ3b14lJiYqJiZGUVFR2r9/v37++WetXr3arsUQ08PWfDGtv+msWLGiWrZsqbCwMJUpU0bBwcEKCgpSbGxs6s9w4MAB7dq1S2vWrNHt27cdVb7DZZVxyNPOUV5eXmrQoIEaNGigsLAwlShRIvU4u3v3rmJiYnTu3DlFRkbqp59+0ubNmzO1CKwjVK9eXfXr11e1atVUsmRJFShQQIGBgfL19VV8fLxu3bql6OhoHTt2TIcOHdKmTZu0f/9+U2vYtGmTwsPDUx+7899oZ8+eXU2aNFGtWrX06KOPqkiRIqm/6/j4eMXExOj69es6fPiwIiMjtX79esMvpYD53OFYRtaVVcZXwFmyZcum+vXrq0qVKipfvrweeeSR1PEyKChI0l/XPXfu3NHFixf1xx9/KDIyUjt37tS+fftcdo/Yx8dH1apVU8OGDVWpUiWVLl1a+fLlU1BQkPz9/RUfH687d+7o2rVrOnXqlA4fPqwtW7bo119/dcli3X5+fqpZs6Zq1KihSpUqqVixYipcuLCCgoKUPXt2+fj4KD4+XtHR0YqOjlZMTIwuXLig3bt3a/fu3frtt99cUrenPc+u5E73kcziKdd67nxv3J1ry6iseo+HaxP3wnU80uIp41JWkJF5zbhx45w6p3GH87Yn3R8FAGQdXl5eqlmzph555BE+Twsg3ey5f888F4At/F0JAAAA4P4CAwN18OBBlSxZ0iJ+7NgxTZ48WStXrtSpU6dUrVo17dmzR5L0ySef6PXXXze9ljVr1qhZs2aS/rqGiIiI0KpVq6y2a9iwoX766afUx1OmTFG/fv3S1UdISIgOHTqkggULpsbu3bun999/X1OnTtWVK1cM98uXL5969eqlt99+Wzly5EiNR0VFqVKlSja/XDtPnjy6fv166uPIyEiFhYUpb968mjVrllq3bp2uuv926NAhde/eXXv37s3QfgAA9/Lcc8+parWqri4DsGn69Ok6euSoq8sAAI82+NXBKly4sKvLANI07pNxDvnuPAB4kPSdLeUq4OoqANsmdJDi77q6CgCuwlrt7oXP1AIAAAAAAAAAAAAAAAAAADgXa7UDyAzWagfgCPxdCQAAAPDgadSokVq2aunqMvCA2bhxo1avWu3qMgDAKVq0bKHGjRu7ugw8YFatXKVNmza5ugwAcArGWrjKksVLtGPHDleXAQBO0XSAVDXC1VXgQbNukrR/paurAADnYq1298JnagGkR/bs2dWkSRPVqlVLjz76qIoUKaLg4GAFBQUpPj5eMTExun79ug4fPqzIyEitX79ev//+u6vLBgAAkqpXr6769eurWrVqKlmypAoUKKDAwED5+voqPj5et27dUnR0tI4dO6ZDhw5p06ZN2r9/v6vLhpPZugZM6++0K1asqJYtWyosLExlypRJnR/GxsYqJiZGUVFROnDggHbt2qU1a9bo9u3bjirfLTBnhislJSXJ29vbKl6tWjXt27fPBRV5LsZN91agQAGFh4erTp06Cg0NVfHixZUzZ04FBAQoOTlZMTExio6O1tGjR7Vv3z5t3LhRv/32m6vLzpAH5RgMCAjQ448/rkcffVTlypVTqVKllCtXLgUFBSkwMFApKSm6ffu2bt26pZs3b+rUqVM6cOCADh48qJ9//lkJCQmm1lO2bFnVr19fdevWVWhoqHLnzq08efLIz89PN2/eTD2u9u7dq1WrVunkyZOm9u9JPOkYDQwMVKFChZQnT57U36eR2NhYbdy40bR+16xZo2bNmlnF27RpoxUrVpjWjzPw2nAOLy8vNWjQQA0aNFBYWJhKlCiRei1x9+5dxcTE6Ny5c4qMjNRPP/2kzZs3Kzk52dVlZ5onHldFixZVs2bN1KhRIxUuXFgFChRQ3rx5lZiYmHr9u3//fv38889avXq14uLiXF1yKlecC7k+diyeX8+VleYIAADAPKzVDiAz0vMZb6+UdH4SnMXbAdjCH5oAAAAAD7YyZcpo0aJFqdcF93Pz5k3t3btXv/zyi5YvX67t27fbXUPLli21cmX6V2P54osv9Nprryk2Ntbuvu3l7e2tbt26afTo0SpSpIhF2927d9W+fXutW7fO1D79/f114sQJFS9ePDU2fvx4DR48OMO5fvjhB7Vq1Sr18enTp1W9enVFR0dnKM8zzzyjBQsWWMXLli2r48ePZ7guAAAAAJ5r7CdjXV0CHgBHfjuiGTNmuLoMADDFwMVStkBXV4Gs7Pwhaf5rrq4CAGALi7e7Fz5TCyArCgoK0q1btwzbSpQooTNnzji5IgDIejKz0PODgnEInmrLli1q0KCBJCk5OVk+Pj4urggA/g/jKwAAgGNwjwcAgL9wfxQA4Aos3g4gM+z5jDf3fADYwt+VAAAAAJ4hLCxMmzZtUu7cuQ3br1+/rvPnz6fO7+fNm6fXXntNly5dMq2GoUOHasyYMamPP/74Yw0ZMsRw24YNG+qnn35KfTxlyhT169cv3X1Vr15d69evV548eSziSUlJ+u2333T8+HHFxMQoJSVFwcHBKlOmjCpWrGj1Xt+NGzfUtGlT7dmzx2ZfJUqUsPhy9O3bt+upp57S1q1bFRoamu6a/+nevXt65plntHz58kztDwBwveeee05Vq1V1dRmATdOnT9fRI0ddXQYAeLTBrw5W4cKFXV0GkKZxn4wz9f4OADyI+s6WchVwdRWAbRM6SPF3XV0FAFdhrXb3wmdqAQAAAAAAAAAAAAAAAAAAnIu12gFkBmu1A3AE/q4EAAAAePA0atRILVu1dHUZeMBs3LhRq1etdnUZAOAULVq2UOPGjV1dBh4wq1au0qZNm1xdBgA4BWMtXGXJ4iXasWOHq8sAAKdoOkCqGuHqKvCgWTdJ2r/S1VUAgHOxVrt74TO1AAAAAABb14D8nTbg/oKCgnTr1i3DthIlSujMmTNOrggAgAdXoUKFdP78efn4+FjEo6KiVKRIESUlJbmoMgAA4ErMEQAAgC2s1Q4gM9LzGW9vJ9QBAAAAAACysOPHjyssLEzdu3fX9u3b77t9rly5FB4eriFDhujnn3/WqVOn1KVLFydU+n/atWun9u3bO7VPI506ddJvv/2mmTNnqkiRIhZtf/zxhxo2bKh169aZ3u+AAQNUvHjx1McxMTEaPXp0pnK9//77Fo9LlSqlFStWKG/evOnO0axZM82cOTNT/QMAAAAAAAAAAAAAAMBxypYtaxhPSUnRhQsXnFwNAOBBwzgET5U7d+7U/9+8edN1hQCAAcZXAAAAAADgSNwfBQAAAAAAAAAAgLvbv3+/ateubfMLIPPmzasqVaqkPn7++ef1559/KiYmRps2bdKHH36oevXqZbr/+vXrW6wHvn37dr355puZznc/e/bsUbVq1bRq1SqLuI+PjypXrqynnnpK//nPf/TCCy+oY8eOqlKlitWXaq9atUpVq1bVnj170uzL39/f4nFycrKWLl2q0NBQSVJiYqLmzJmj9u3bq1ixYsqePbu8vb0VEhKiunXrasSIEfrzzz8tcgQEBGjhwoV2PecAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYKRs2bKG8ZSUFF24cMHJ1QAA8GDr2rWrfHx8rOJz585VUlKSCyoCAADugDkCAAAAAGfzdnUBAAAAAADA86WkpGj27Nl67LHHVLRoUXXs2FFjx47V2rVrdenSpTT3LVWqlObMmaN169YpV65cmer/2rVr2rx5s9W/nTt36uTJk0pOTrbYvkiRIpo/f74mT54sLy+vTPVpj5YtW2rfvn1auHCh1Qe8k5OTNXXqVFWuXFl79uwxve9cuXLprbfesoiNGTNG169fz1S+HTt26KuvvrKI1a9fX/v27VPnzp3TfH5DQkL0ySefaNWqVcqePbsSEhJ08eLFTNUBAAAAAAAAAAAAAAAA89WqVcswfvLkSSUmJjq5GgDAg4ZxCJ4oKCjI4vPB9/ssNQA4G+MrAAAAAABwFO6PAgAAAAAAAAAAwFMcP35cYWFh6t69u7Zv356ufXLlyqXw8HANGTJEP//8s06dOqUuXbpkqN+QkBB98803qV9cfe3aNT399NMO/8Lq0NBQFS1aNNP7Fy1aVI888kiG96tXr55q164tSdqzZ4/KlSunbt26aenSpTp//rzi4uKUkpKia9euaefOnXrvvfdUokQJffLJJxZ5smXLprlz5ypHjhyZ/hkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4N9q1aplGD958qQSExOdXA0AAA+2Pn36GMa/+uorJ1cCAADcCXMEAAAAAM7m6+oCAAAAAABA1nLhwgUtXrxYixcvliRVq1ZNe/bs0aZNm7Rnzx5VqVJFtWvXVnBwsMV+TZs21YYNG/TYY48pPj4+Q33+8ssvatSokc32XLlyqXXr1hoyZIgqV66cGu/Xr59u376tN954I0P9ZVbDhg01ZswY1atXz7D9xx9/1GuvvabIyEiH1fDGG28ob968qY/Pnz+vzz77zK6cL730kipUqKDHHnssNVa8eHF9++23mjBhgjZs2KBjx47p+vXr8vf3V8GCBVWzZk099thjyp49e+o+Q4cOVZs2bfTQQw+lxlJSUuyqDQAAAAAAAAAAAAAAAJnXpEkTw/iePXucXAkA4EHEOARPNG7cOPn7+6c+/vXXX11YDQBYY3wFAAAAAACOwv1RAAAAAAAAAAAAeJKUlBTNnj1bs2fPVpEiRVSnTh3Vrl1bVapU0aOPPqpChQqluX+pUqU0Z84cdevWTR07dtTNmzfv2+fcuXNVpEiR1P67du2q8+fPm/Lz2PLuu+/q7bfflpeXl1XbtWvXdP78+dTac+XKpSJFiigkJMRiuypVqmjdunV67733NHLkyHT37e3tLUnavn27GjdurLi4uPvuEx8fr9dff11nzpzRpEmTUuMlS5ZUv379NG7cuHT3DwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABpadKkiWF8z549Tq4EAIAHW4sWLVS6dGmr+NatW3Xs2DEXVAQAANwBcwQAAAAAruDt6gIAAAAAAMCDYc+ePXr99dfVrFkzhYSEqHXr1tq9e7fFNjVq1NAHH3xget83b97UvHnzVK1aNX3xxRcWba+//roaNGhgep//VKxYMS1ZskQ//fST6tWrZ9W+bds2Pf7442ratKkiIyMdVkeePHk0cOBAi9g777yj2NhYu/LGxcWpWbNmWr58uVVb4cKF1aVLF7333nv64osvNH78eA0dOlRPPPGEsmfPLklKSUnRm2++qU8//VQ5cuSw2P/27dt21QYAAAAAAAAAAAAAAPAgCAwMND1noUKF1KZNG8O2tWvXmt4fAMBzMQ4Bkq+vr6ZMmaLevXtbxL/++msXVQTA0zG+AgAAAAAAT8H9UQAAAAAAAAAAAHi6CxcuaPHixXrjjTfUvHlztWrVKrVt06ZN+uSTT7Ru3TrFxMRY7du0aVNt2LBB/v7+9+2nWbNmqf//+OOPtXr1anN+ABteffVVjRgxQl5eXqmxqKgovfnmmypdurRCQkIUFhamhg0bqmHDhgoLC1P+/PlVsmRJDR06VJcuXUrdz8vLSyNGjNCrr76aoRpu3bql9u3bKy4uLkP7ff7551qwYIFFbMCAARnKAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBrCAwMND1noUKF1KZNG8O2tWvXmt4fAACw7d133zWMf/bZZ06uBAAAuBPmCAAAAABcwdvVBQAAAAAAgAdPYmKifvjhB9WpU0dTpkyxaOvfv78KFCjgsH4HDBig7777ziL+/vvvO6Q/SWrRooUiIyPVvn17q7bdu3frySefVIMGDbRlyxaH1fC3gQMHKigoKPXxiRMnNHPmTFNy37lzR23btlX37t119uzZdO+3f/9+Pf744xozZowkWdQnSTExMabUBwAAAAAAAAAAAAAAkBV5eXlp+PDhOnHihPLnz29q7iFDhsjX19cqHh8frx9++MHUvgAAnolxCPhLwYIFtXHjRvXp08civmjRIv34448uqgqAp2J8BQAAAAAAnoT7owAAAAAAAAAAAMjq9uzZo9dff13NmjVTSEiIWrdurd27d1tsU6NGDX3wwQdp5qlfv37q/3/++We99dZbDqn3bxUqVNCHH35oEdu4caMqVqyoMWPG6PTp0zb3/eOPP/TRRx+pYsWKVu/7ffjhh6pQoUK665g0aZIuX76cseL/vzfffFMpKSmpj0uUKKFKlSplKhcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAz+Pl5aXhw4frxIkTyp8/v6m5hwwZIl9fX6t4fHy8fvjhB1P7AgAAtj3//POqWbOmVfyPP/7Q999/74KKAACAO2COAAAAAMBVvF1dAAAAAAAAeHAlJyerf//+2rNnT2ose/bs6tChg0P7HTRokJKTk1MfN2jQQEWLFjW9n06dOmnFihXKkyePRTwyMlJt2rRRrVq1tH79etP7NeLv768XX3zRIvbhhx9aPA9mmD17tkqVKqU2bdpo+vTp2rdvn27cuKGkpCQlJCTo6tWr+uWXX/TZZ5+pYcOGqlq1qrZu3Zq6f3BwcOr/k5OTdffuXVPrAwAAAAAAAAAAAAAAyCqKFCmizZs367333lPhwoW1ZMkSZcuWzZTc4eHhGjhwoGHbkiVLdPXqVVP6AQB4LsYh4C9FihT5f+zdd3gUVfv/8U86JQkJTaqiSBEI0kVQutK7CESKIEr1QUBBH1SkWbChfhUVRBEERECUDgoCUgRBuoBUBemhhBDSf3/4M49xZ0OyO7s7k7xf18Wle5+Z+9y7O+XM7OasfvnlF91///0Z4qtXr1bv3r19VBUAu+L8CgAAAAAA7IT7owAAAAAAAAAAAMhtkpOTtWTJEtWtW1cffvhhhrbBgweraNGihusVKlRIc+fOlSRduHBBXbt2VUpKikdrHTdunAIDA9Mf79mzR23bttXFixeznCMmJkbt2rXT7t2702OBgYF66aWXspzjq6++yvKy/3b8+PEM89dLUs2aNV3OBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMA+SpYsqR9++EHjx49X8eLFtXDhQoWEhJiSu1GjRho6dKhh28KFC3XhwgVT+gEAAJm744479O677xq2jR8/XqmpqV6uCAAAWAFjBAAAAAC+5O/rAgAAAAAAQO6WmpqqyZMnZ4g1bNjQo32eOnVKW7duzRC75557TO2jZs2a+uKLLxQQEJAeu3Llivr27atq1app8eLFpvZ3M507d1aRIkXSH58/f16zZs3ySF8pKSlavHix+vXrpxo1aqhgwYIKDAxUcHCwihQporp16+qpp57Shg0bMqyXN29eFS9ePP3x2bNnPVIfAAAAAAAAAAAAAACA3bVr1067d+9WgwYN0mP33XefVq5cqYIFC7qVu1GjRlq4cKH8/Pwc2lJTUzV+/Hi38gMA7I/zEPA/p06d0ubNmzPEPv30U7Vu3Vrx8fE+qgqAHXF+BQAAAAAAdsP9UQAAAAAAAAAAAORWqampGjx4sLZv354ey5Mnjzp16mS4/BdffKGSJUsqLS1NPXv21KlTpzxaX3h4uNq1a5ch9tRTT+n69evZzhUfH6+nnnoqQ6x9+/YKCwtzWDYhISHD49TUVO3evTvbff7Tjh07MjwuVaqUW/kAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWF+7du20e/duNWjQID123333aeXKlSpYsKBbuRs1aqSFCxfKz8/PoS01NVXjx493Kz8AAMiamjVr6vvvvzc8tx88eFAzZszwQVUAAMDXGCMAAAAA8DV/XxcAAAAAAACwadOmDI9LlSrl8T6PHDmS4XGxYsVMy+3v769Zs2YpKCgoPXbmzBnVqVNHn376qWn9ZEevXr0yPP7ss8+UmJjok1qcqVixYoYvve/cudN3xQAAAAAAAAAAAAAAAFhY5cqVDScpaNiwofbt26devXopMDAwWzkjIiI0YcIErVq1SpGRkYbLvP/++9q/f79LNQMAcg7OQ0BGjz76qH777TclJCRo8ODB6tu3r5KSknxdFgCb4fwKAAAAAADsiPujAAAAAAAAAAAAyK1SU1M1efLkDLGGDRs6LPfss8+qefPmkqSVK1fq+vXratCgQZb/VatWLUO+EiVKOCwTERGRYZnatWs7zI++Zs0al5/r2rVrdebMmfTHwcHBql27tsNyly5dcnicmprqcr+SdP78+QyPw8PD3coHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwPoqV66sggULOsQbNmyoffv2qVevXgoMDMxWzoiICE2YMEGrVq1SZGSk4TLvv/++9u/f71LNAADAmL+/vwICAhQeHq4777xTDz/8sL766itt2bJFZcqUMVxn0KBBSklJ8W6hAADAqxgjAAAAALCq7H0KCQAAAAAA4AEXLlzI8Njoi9Vmu3btWobHISEhpuXu2bOnKlasmP44NTVVHTt21KFDh0zrIztCQkLUpEmTDLHZs2f7pJbM1KtXL8PjX375xUeVAAAAAAAAAAAAAAAAWNukSZPUoUMH1alTx6GtWLFimjFjhiZNmqQlS5Zo/fr1+u2333Ty5EnFxcUpISFBgYGBKliwoAoVKqRq1aqpSZMmat26tcLDw532uXv3bo0cOdKTTwsAYBOch4CMYmNj1aFDBwUGBmr37t2+LgeATXF+BQAAAAAAdsT9UQAAAAAAAAAAAORmmzZtyvC4VKlSDstMmDAh/f9btGihFi1auNVnu3bt1K5duwyx6tWra+fOnemPS5YsmaH9wIEDbvUpSYcOHVKxYsXSH5coUcJhmatXryolJUUBAQGS/pqb3V1m5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgL5MmTVKHDh1Up04dh7ZixYppxowZmjRpkpYsWaL169frt99+08mTJxUXF6eEhAQFBgaqYMGCKlSokKpVq6YmTZqodevWCg8Pd9rn7t27NXLkSE8+LQAAcp2HH35YX375ZbbW+fDDD7VmzRoPVQQAAKyAMQIAAAAAKwv0dQEAAAAAAMC+mjVrpqSkJK1bt86tPCEhIRke37hxw618WREZGZnh8eXLl03L3a9fvwyPv/zyS23ZssW0/NlVq1YtBQcHpz+OiYnRzp07fVaPM506dcrwePPmzT6qBAAAAAAAAAAAAAAAwNpSUlLUpk0bbdq0SXfeeafhMrfccosee+wxPfbYY273d/z4cbVs2dIr3+sBAFgf5yHA0f79+31dAgCb4/wKAAAAAADsivujAAAAAAAAAAAAyK0uXLiQ4XHBggUdlgkICPB4HceOHcvwOE+ePBkex8XFud1HbGxshsf58uUzXO7IkSMqX768JMd54F1RuHDhDI/NnEseAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgDWlpKSoTZs22rRpk+68807DZW655RY99thjeuyxx9zu7/jx42rZsqVu3Ljhdi4AAOC69evXa+jQob4uAwAAWAxjBAAAAADe5O/rAgAAAAAAgP3cf//9Wr9+vVavXq23335bfn5+buUrV65chsenT592K19WREVFZXh89uxZU/JGRkaqfv36GWLTpk0zJber6tWrl+HxTz/95KNKnLv99tvVoEGD9McXL17UypUrfVgRAAAAAAAAAAAAAACAtZ0/f14NGjTQli1bPNrPL7/8onr16unPP//0aD8AAHvhPAQAgPk4vwIAAAAAAAAAAAAAAAAAAACe1axZMzVs2NCUXCEhIRke37hxw5S82RETE6MrV65kiF27di3D4wIFCrjdT0RERIbHV69eNVxu48aN6f8fGBioChUquNVvpUqVMjw+fvy4W/kAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2MP58+fVoEEDbdmyxaP9/PLLL6pXr57+/PNPj/YDAAAyt2LFCrVq1UqJiYm+LgUAAFgIYwQAAAAA3ubv6wIAAAAAAIC9BAcHa8GCBbr//vslSdWrV9ewYcPcyhkdHZ3h8c6dO50uGxERoZEjRypfvnwu91enTh3ddddd6Y/T0tL0888/u5zvn6pVqyY/P7/0x0lJSfrxxx9Nye2qChUqZHi8fft20/vIkyePoqOj1bt3b5fWf/nllxUYGJj+eM6cOUpKSjKrPAAAAAAAAAAAAAAAgBzp9OnTatCggcaNG6f4+HhTcycmJmrSpEmqW7euTp8+bWpuAEDOwHkIAADzcX4FAAAAAAAAAAAAAAAAAAAAzHf//fdr/fr1Wr16td5+++0M84i7qly5chkeG31Ht0KFCm7969mzZ4Z8X375ZYb2WrVqOfR55syZDI8rV66sgIAAl59nYGCgKlWqlGkff1u3bl2Gxx06dHC530KFCql+/foZYlu3bnU5HwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB7OX36tBo0aKBx48YpPj7e1NyJiYmaNGmS6tatq9OnT5uaGwAAZN3Zs2c1aNAgtWzZUnFxcb4uBwAAWARjBAAAAAC+EujrAgAAAAAAgL0kJibqjTfe0GuvvZYemzRpko4ePapFixZlO999992n/v37Z4gtXLjQYbnChQtrxIgRGjRokMLDw3X77bdr4MCB2e4vPDxc06ZNyxDbvHmzzp4963SdkJAQBQQEZIhdv37dcNnbbrstw+Njx44pMTEx23WaqVChQhkem/ll8uDgYL377rvq1q2bChQooNjYWK1bt07Hjx/Pco5HH31U3bp1S3+cmJiod99917QaAQAAAAAAAAAAAAAAcrKkpCSNGTNGH3/8sYYMGaJHH31UxYoVczlfbGysZs6cqTfeeEPHjh0zsVIAQE7EeQgAAPNxfgUAAAAAAAAAAAAAAAAAAADMExwcrAULFqhIkSKSpOrVq2vYsGF666233MobHR2d4fHOnTsdljl06JBbffz7e8SXLl26ac5du3YpNTVV/v7+kqTIyEh17txZ8+bNc6mGTp06KTIyMv1xSkqK9uzZY7js/Pnz9c4776hAgQKSpBEjRuiDDz5QbGxstvt9/vnnFRj4v5/Y27lzp44cOZLtPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADsKykpSWPGjNHHH3+sIUOG6NFHH1WxYsVczhcbG6uZM2fqjTfe0LFjx0ysFAAA3ExCQoJiYmJ0/Phx/fzzz1q1apVWrlyppKQkX5cGAAB8iDECAAAAACsJ9HUBAAAAAADAft5++211795d1apVkyQFBARowYIFGjt2rF599VUlJiZmKU/Pnj31wQcfKDDwf7colixZoh07djgse/vtt+vZZ59NfzxgwAD5+flpxIgRiouLy1J/FStW1OzZsxUVFZUhPnbs2EzXmz9/vtq0aZMh5ufnZ7hseHh4hscXL17MUm2eVKhQoQyPY2JiTMudmJioChUqqECBApKksLAwLVu2TC1atNDvv/9+0/UHDRqkd955J0Ps1Vdf1W+//WZajQAAAAAAAAAAAAAAALnBqVOn9Nxzz+n5559XrVq11LhxY9WqVUtly5ZVmTJlFB4eLn9//wzrJCUl6dSpUzp69Ki2b9+utWvXas2aNUpISPDRswCA3CcgIMDXJZiC8xAAAObj/AoAAGAfOeUeDwAAAAAAAAAAAAAAQE6UmJioN954Q6+99lp6bNKkSTp69KgWLVrkUs777rtP/fv3zxBbuHChO2Wa5uLFi9q4caPuv//+9Nibb76p9evX68yZM9nKVbx4cb311lsZYj/++KPTudfj4uI0bdo0jRgxQpJUpEgRzZo1Sx06dFBaWlqW+23btq3+85//ZIi9/vrr2aodAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAGwICAnxdApArnDp1Ss8995yef/551apVS40bN1atWrVUtmxZlSlTRuHh4fL398+wTlJSkk6dOqWjR49q+/btWrt2rdasWaOEhAQfPQsAAHKXefPmaf78+ZKktLQ0paWl+bgiAABgBYwRAAAAAFhZoK8LAAAAAAAA9pOUlKSuXbvqxx9/VJEiRSRJ/v7+Gjt2rPr166epU6dqyZIl2rVrV4b1QkJCVLFiRTVu3Fh9+/ZVVFRUhvZz585pyJAhhn1u27ZNU6dO1eOPP54e69+/vzp06KDPPvtMK1as0O7duxUTE5NhvcKFC6tOnTqKjo5Wly5dFBwcnKH9iy++0KpVq1x+Lf4tMDDj7ZYyZcpoypQppuR++eWX9ccff2R7vbx582Z4HBsba0o9f3vqqae0devW9Nf2rrvu0t69ezVr1izNmjVLe/fu1dWrVyVJfn5+Kl68uFq2bKl+/fqpbt26GXLt3r1bEydONLU+AAAAAAAAAAAAAACA3CQlJUU//fSTfvrpJ4e2kJAQhYSEKC0tTTdu3FBSUpIPKgQA/FNqaqqvSzAV5yEAAMzH+RUAAMD6cto9HgAAAAAAAAAAAAAAgJzm7bffVvfu3VWtWjVJUkBAgBYsWKCxY8fq1VdfVWJiYpZz9ezZUx988EGG+ciXLFmiHTt2mF22yyZOnKgVK1akPy5VqpTWrl2rhx56SPv27ctSjipVquirr75SyZIlHXJn5uWXX1a3bt3S12vXrp2++eYb9ezZU1euXLlpv4899pj+7//+T/7+/umxTZs2ac6cOVmqGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwJtSU1N9XQKQq6SkpOinn37STz/95NAWEhKikJAQpaWl6caNG0pKSvJBhQAA4J8YLwMAACOMEQAAAABYVaCvCwAAAAAAAPZ06NAhNW3aVEuXLlXp0qXT46VLl9a4ceM0btw4JScnKyYmRpL05JNPasSIEfLz8zPMd+7cOTVt2lQnTpxw2ueQIUN06623qnnz5umxW265RaNGjdKoUaMkSTdu3ND169eVkpKiAgUKKDg42Gm+JUuW6NFHH83O08624sWLa8CAAabkmjp1qv744w+386SlpZlQzf/s2rVLAwcO1LRp09Lf37CwMA0cOFADBw6UJMXHx+vatWsqWLCgAgICDPMcOHBALVq0UGJioqn1AQAAAAAAAAAAAAAA4C8JCQlKSEjwdRkAgFyK8xAAAObj/AoAAAAAAAAAAAAAAAAAAADcXFJSkrp27aoff/xRRYoUkST5+/tr7Nix6tevn6ZOnaolS5Zo165dDuuGhISoYsWKaty4sfr27auoqKgM7efOndOQIUO88jyyauXKlZo7d666deuWHqtYsaJ27Nih+fPna/bs2dq2bZvOnTuXYb2iRYuqdu3aio6O1kMPPeQwx/sXX3yh1atXZ9p3TEyMHnnkEa1Zs0b+/v6SpLZt2+rIkSOaPHmyvv76a+3bty/DOgULFlSzZs301FNP6d57783Qdu7cOT3yyCOmz60OAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIGdJSEhQQkKCr8sAAAAAAAAAAAAAYFP+vi4AAAAAAADY1549e1StWjXNmTNHaWlpDu2BgYEqWrSoJCkkJER+fn6GeRYsWKAqVapo7969mfaXmJio1q1b6+WXX1ZiYqLhMnny5FHBggVVpEgRBQcHGy6TkJCg5557Tu3bt1dycnKmfSJrpk+fru7du+vKlSuG7Xnz5lWRIkUUEBBg2P7111+rXr16On36tCfLBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQC5z6NAhNW3aVH/88UeGeOnSpTVu3Djt2LFDCQkJWr58eXrbk08+qfj4eO3cuVNvv/22oqKiMqx77tw5NW3aVCdOnPDKc8iO3r17a/Xq1RliwcHBio6O1pIlS3T27FklJibq/PnzOn/+vBITE3X27FktWbJE0dHRDnO8r1ixQn369MlS3+vWrVPXrl2VkJCQHitUqJDGjx+vvXv36vr16zpx4oR+++03Xbx4URcuXNCXX36pe++9N0OeM2fOqHnz5jp+/LhrLwIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAW+Pu6AAAAAAAAYG8xMTGKjo5WtWrV9OGHH+rChQtZWu/cuXOaPn26qlevroceekjnz5/P0nopKSkaPXq0KlasqEmTJun333/Pcq3nz5/XpEmTVLFiRb366qtKTU3N8rq4uS+//FJ33XWX3n77bV28ePGmy6empmrVqlV64IEH1KlTJ126dMkLVQIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACC32bNnj6pVq6Y5c+YoLS3NoT0wMFBFixZNfxwSEiI/Pz/DXAsWLFCVKlW0d+9ej9XrjsTERLVu3Vrjxo1TcnKy4TJBQUEqXLiwChcurKCgIMNlkpKSNGbMGLVt21ZJSUlZ7n/+/Plq2rSpjhw54tCWN29e3XrrrbrzzjtVsGBBw9d4xYoVqlmzpnbu3JnlPgEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFwR6OsCAAAAAABAzrB7924NHDhQgwYNUsWKFVWzZk2VKlVKUVFRio6O1k8//aS5c+fq5MmT2rt3rw4cOOBWf8eOHdOoUaM0atQolSlTRnfffbfKli2rwoULK3/+/AoKClJsbKwuXbqkkydPauvWrTp06JBLfbVt21aS9NJLL2nMmDGZLvvWW2/prbfecqkfT6ldu7bX+jp9+rSGDx+up59+WrVq1VJUVJRuv/12hYaGKjg4WNevX9eZM2d08OBB/fjjj7p06ZLXagMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDuFRMTo+joaL366qsaOHCgHnroIRUuXDhL6547d05LlizRe++9p507d3q2UBMkJSVpzJgxmjVrlvr3769evXqpSJEiWVr3/PnzmjFjhj788EMdOXLEpf43btyoihUrql+/fho8eLCqVKmS6fIpKSlas2aN3nrrLa1YscKlPgEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALIr0NcFAAAAAACAnCUtLU2//vqrfv31V0lSjRo1FB0drQ0bNmjy5Mke6fP48eM6fvy4R3L/U2hoqCQpPj7e433ZXWpqqrZu3aqtW7f6uhQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAg3e7duzVw4EANGjRIFStWVM2aNVWqVClFRUUpOjpakvTTTz9p7ty5OnnypPbu3asDBw54tcb169fLz8/P7Ty//fabnn76aT399NO68847Vbt2bZUuXVoREREqUKCAJOnKlSu6fPmy/vjjD23btk2HDx92u19JSk5O1ocffqgPP/xQJUqUUMOGDVWiRAkVLVpUYWFhiouL0/nz57V//35t2rRJMTExpvQLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQVYG+LgAAAAAAAMAu6tevL0k6deqUjysBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4I60tDT9+uuv+vXXXyVJNWrUUHR0tCRpw4YNmjx5sg+rM9/hw4d1+PBhn/T9559/as6cOT7pGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwBl/XxcAAAAAAABgdX5+fpo8ebLq1q0rSVq+fLmPKwIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuCrQ1wUAAAAAAABYWWRkpObMmaPmzZtLko4fP66xY8f6uCoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgKsCfV0AAAAAAADI2f7880+NGTNGmzZt8nUpLqlcubKaNWsmSdqzZ49atWqlixcv+rgqAAAAAAAAAAAAAAAAAAAAAAAAAACQk+XPn18REREKCAgwbP/999+9XBEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5CyBvi4AAAAAAADkbGfOnNG4ceN8XYbLfvzxR/33v/9VVFSUBgwYoLi4OF+XBAAAAAAAAAAAAAAAAABwYu3atYbxxo0be7mS/7FiTQAA63n//fdVqVIlh/jAgQN14MABH1QEAMYY3wIA4Blly5ZV69at1bBhQ91zzz0qWrSogoKCMl3Hz8/PS9UBAADg37inCwAAAAAAAAAAkHP9+eefGjNmjCRp06ZNPq4GAAAAAAAAAAAAAAAAAADAGpiTFHCO+WgAAMi5GAcDAICbYbwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADlHoK8LAAAAAAAAsLpJkyb5ugQAAAAAAAAAAAAAAADAJcHBwYbxxMREL1fifbn5uedmjRo18nUJDqxYEwDAemrUqKG6des6xMPDw31QDQA4x/jW+7i+BYCcrVKlSnrxxRfVpUsX+fv7+7ocAAAAZBH3dAEAAAAAAAAAAHKuM2fOaNy4cb4uAwAAAAAAAAAAAAAAAAAylZPnqcvJz03K+c8POZdZc5KyDyAnYj4aAAByLubmR07EdRkAmIvxAgDAUxi7AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgfYG+LgAAAAAAAAAAAAAAAAAAAAAAAACA+cqXL6+DBw8atlWoUEGHDh3yckXek5ufOwAAQG72n//8RxEREQ7x+fPna//+/R7tu3Dhwho0aJDT9l27dumbb77xaA0Ach6ubwG4KiwsTJUrV9Ydd9yh8PBwhYWFKW/evEpOTlZcXJwuX76so0eP6tChQzp79qyvy1VERITuuusu3XHHHSpUqJDy58+voKAgJSUlKS4uThcvXtTRo0f166+/6vLly74u1zRdu3bVjBkzFBIS4utSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQJA0bNkxhYWEZYgcPHtSXX37po4rwbzl5nrqc/NyknP/84JyzeXNdlZiYqBs3bujChQs6c+aMDh8+rBMnTigtLc20PjyBfQAA4CqzzqUpKSlKSEhQbGyszp07p1OnTungwYO6cuWK+0VKKlasmJ544glTcnnCyZMnNX369Ayx8PBwPfXUU4bLp6Wl6a233lJcXJwXqvufhg0bqmHDhoZtmzZt0nfffefVegAgJ+G6DAAAALAHxu4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPhGoK8LAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYT7du3dSwYUOv9ztt2jRt37492+sNGzZMZcqUcYgfOHBA+/fvN6EyYwUKFNDq1atVrVo1w/a9e/fq/fff91j/AADAfJMnT1ZISEi21jl16pQmTJjgoYoyFxAQoEaNGqlTp05q1aqV4ZjImSNHjui7777TzJkztXHjRs8V+S9RUVHq1auXmjdvripVqsjPz++m66SlpWnv3r1asWKFPv/8c+3du9cLlXpG//79NWXKlCw9bwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAvKFGjRp66623HOKxsbFasmSJ4uLifFAVANifs3lzzXTt2jVt27ZNq1ev1sKFC3Xw4EGP9gcAgDd5+lz6xx9/aOPGjVqxYoUWL16smJgYl/KUKFFCY8eONbk682zZskXTp0/PELt69aqKFSumgQMHGq5z2223qV+/ft4oT9Jfr+HChQtVsGBBh7bz58/rww8/9FotAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgdwn0dQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOtp0aKFevfu7fV+165dq+3bt3u9X1fkz59fK1asULVq1QzbDx48qKZNm+rixYveLQwAALisQIECGjp0aLbX27t3ryZMmOCBipwLCAhQr1699MILL+j22293KUfZsmVVtmxZ9e/fX3v27FHVqlVNrjKjhg0baty4cWrQoEG21/Xz81NUVJSioqL0zDPP6IcfftCLL76oDRs2eKBSz4mKitI777wjPz+/my6bkpKipKQkL1QFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMjt+vfvbxgPCwtT9+7dNW3aNC9XBADIqtDQUDVu3FiNGzfWyy+/rI0bN+qVV17R0qVLfV0aAACWV7p0aXXr1k3dunVTUlKSFixYoNdff107duzwdWleMXz4cDVu3FgVK1Z0aHvssce0dOlSff31116pZcaMGSpYsKBhW58+fXTu3Dmv1AEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHKfQF8XAAAAAAAAAAAAAAAAAAAAAAAAAAAAco769evr+eefd4hv2LBBL7/8sg8qAgC4KjQ01NclWFqePHm0ZMkS1a1b17D9yJEjatKkic6dO+flygB4EuNd4C85eV+48847fV1Cltx111368ssvFRUVZVrOqKgoffvtt+rTp48uXrxoWl5JioiI0HvvvacePXqYlrNRo0Zav369Pv30Uz311FO6evWqabk96bPPPlNISIhh24ULF/TBBx9o6dKl+vXXXxUbG+vl6gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuVFoaKiio6Odtg8cOFDTpk3zYkX2kZPn5QJgX/Xr19eSJUv03XffqW/fvvrjjz98XRIAALYQFBSkbt26qWvXrpozZ47+85//mD5Pq9XcuHFD3bt3108//aTg4GCH9mnTpmnLli06ffq0R+sYOnSomjVrZtg2ZcoULV261KP9A/AM7ptkjtcHYD8AAAD2wbgFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICcL9DXBQAAAAAAAAAAAAAAAAAAAAAAAAAAgJzjlltuUYsWLRzi165d80E1AAB3hIaG+roEywoKCtLChQvVqFEjw/YTJ06ocePG+vPPP71bGACPY7wL/CUn7wvlypXzdQk39fDDD+uzzz5T3rx5Tc/dtm1b7dixQ02bNtXhw4dNyVm+fHktW7ZMZcuWNSXfv/Xp00f16tVTy5YtdezYMY/0YZaGDRuqRo0ahm2rV6/WQw89pKtXr3q5KgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAbhcdHZ3pPJQ1atRQzZo1tX37di9WZQ85eV4uAPbXrFkz/fLLL2rfvr02btzo63IAALANPz8/RUdHq2nTpurcuXOOP4/u3LlTo0eP1uuvv+7QVrBgQX3++ed64IEHPNZ/lSpV9Nprrxm2HThwQMOHD/dY3wA8i/smmeP1AdgPAACAfTBuAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAg5wv0dQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOsJDQ31dQmW5O/vr7lz56ply5aG7adOnVKTJk30xx9/eLkyAABghnLlyvm6hEx16tRJs2fPVkBAwE2XvXbtmn7//XfFxsbqxo0byps3ryIjI3XrrbcqJCTE6Xq33nqrNmzYoDp16rg9pqlcubLWr1+vggULZmn55ORkXb16VYmJiQoODlZ4eLgCA28+TVKFChW0ZcsW1a9fX4cPH3arZk8aMmSIYfzgwYNq166dbty44eWKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQBgwYkKVlHn/8cS9UAwC5w8mTJ3X58uVsrRMQEKB8+fIpNDRUkZGR8vf3v+k6hQoV0sqVK9WkSRNt3brVxWoBALCe7JxL/fz8FBISorCwMIWHhytv3rxZWu+WW27R999/rw4dOmjFihWZLnvjxg3t3bs3S3mdKVCggEqXLu0QT05O1oEDB9zKffTo0Uzb33zzTbVq1UqNGzd2aGvWrJmeeuopTZ482a0ajAQHB2v27NmG8+UmJiaqe/fuzNkKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8LtDXBQAAAAAAAAAAAAAAAAAAAAAAAAAw340bN/Tzzz87bcvJcvNzBwAAMFP+/PkdYmfOnNHJkyc92u+lS5c8mt9dn332mTp16mTYdvbsWTVp0kRHjx71clUAciKubwHfOHPmjObOneu0vXTp0qpfv74XK/qfWrVqae7cuQoICDBsT0tL0/Lly/XVV19pzZo1+v333w2XCwoKUvXq1fXQQw+pb9++KlSokMMyxYoV04IFC1SvXj0lJye7VG+pUqW0atUqFSxY0OkySUlJ+vrrr7Vo0SJt2bJFx48fV1paWnq7n5+fypQpo7p166pjx47q0KGDgoKCDHMVLVpUq1evVp06dXT+/HmXava0Jk2aGMZHjRrFsR0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4BO1atVS9erVb7pc9+7dNXz4cMXGxnqhKjiTk+epy8nPTcr5zw/ZN2LECM2bN8/l9UNCQlSuXDlVr15dbdu2VcuWLRUaGmq4bP78+bVw4UJVrVpVMTExLvfpDvYBAIDZ3DmX3nLLLapcubJq166tTp06qU6dOk6XDQkJSZ+nddeuXU6X279/v6Kiolyq52+dOnXSggULHOIXLlxwO/fNpKWlqWfPntqzZ48iIyMd2l999VV9//332rNnj6n9vvLKK06f2+jRo7Vz505T+wOA3IzrMgAAAMAeGLsDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOAbgb4uAAAAAAAAAAAAAAAAAAAAAAAAAID5fv/9d9WuXdvXZfhEbn7uAAAAZgoNDXWIffTRR3rppZe8X4xFTJkyRT179jRsu3Dhgpo2bapDhw55uSoAORXXt4BvTJ06VVOnTnXa3qlTJ9WvX9+LFf0lJCREn3/+uYKCggzbN23apAEDBmjPnj03zZWUlKStW7dq69ateumll/Taa69p8ODB8vPzy7Bc7dq1NXDgQL333nvZrtff319z585ViRIlnC4ze/ZsjRw5UqdOnXK6TFpamo4dO6Zjx45pzpw5KlWqlCZNmqTu3bsbLl+mTBnNnDlTLVq0yHbNnnbXXXepYMGCDvGLFy9q8eLFPqgIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACpf//+WVouf/78euSRR/Thhx96uCJkJifPU5eTn5uU858fvC8hIUF79+7V3r17NXPmTEVEROi5557TsGHDDOetK1mypCZOnKiBAwf6oFr2AQCAtZw9e1Znz57VmjVr9Nprr+nOO+/UhAkT1LVrV8Pl8+XLpzlz5qhatWpKTEz0crXec+rUKT3++OOaP3++Q1tISIjmzJmjmjVrKiEhwZT+mjZtqmHDhhm2rV27Vm+++aYp/QAA/sJ1GQAAAGAPjN0BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPANf18XAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwntDQUIfY9evXfVCJNbzxxhsaMGCAYdulS5f0wAMPaN++fV6uCgAA5BYjR47UXXfdZdg2depUNWjQQHv27Ml23uvXr+vJJ59U7969lZqa6tD+4osvKigoKNt5n376adWvX9+wLSkpSb169dIjjzyiU6dOZSvvyZMnFR0drUcffVTJycmGyzRv3lz9+/fPds2eVqlSJcP4Tz/9ZPjaAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgaWFhYerevbtD/I8//jBcfuDAgZ4uCQDgosuXL2vUqFFq0aKFrl69arhMv379VLx4cS9XBgCA9R0+fFjdunVT8+bNde3aNcNl7rrrLqdz1eckCxYs0GeffWbYVrlyZU2aNMmUfiIjIzVjxgz5+fk5tF26dEk9e/ZUWlqaKX0BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADcjL+vCwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWE/+/PkdYtevX/dBJb730ksvacSIEYZtsbGxat68uXbu3OndogAAQK6RL18+PfXUU4ZtX331lfr376+UlBS3+pg5c6ZGjx7tEC9cuLDatGmTrVzFihXTCy+8YNiWmpqqLl26aObMmS7V+bcZM2aoW7duSktLM2yfOHGiIiIi3OrDbAULFjSMHz161MuVAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADwl0ceecRw/smnn35aBw4ccIhXrVpVderU8UZpAAAXrVmzRgMGDDBsCwwMVHR0tJcrAgDAPlatWqXGjRsrISHBsP2ZZ56Rn5+fl6vyviFDhujIkSOGbU8++aSaN2/udh8fffSRSpYsadj2xBNP6NSpU273AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkFX+vi4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGA9+fPnd4jFx8f7oBLfGjFihMaMGWPYFhcXp5YtW2rbtm1ergoAAOQmDz74oCIjIx3iJ0+e1GOPPaa0tDRT+nn99dcN4y1btsxWnmeffVahoaGGbWPHjtU333yT7dqMLFiwQC+//LJhW6FChfTkk0+a0o9ZjN5DSbpy5YqXKwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4C8DBgxwiMXExGjRokX65JNPDNcZOHCgp8sCALhpzpw52rx5s2Fb8+bNvVwNAAD28vPPP2vs2LGGbaVKlVLDhg29XJH3xcXF6ZFHHlFycrJDm5+fnz777DMVKlTI5fw9e/ZUly5dDNs+++wzzZ8/3+XcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArvD3dQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGvJmzev/P0d/xw9Pj7eB9X4zoABA/TGG28YtsXHx6tt27bauHGjl6sCAAC5zaJFi1SxYkV98MEHiouLS48//fTTio2NNa2flJQUw3itWrWynCM8PFyPPfaYYduxY8f06quvulSbM+PHj9eJEycM24YMGaKQkBBT+3NHnjx5DOOJiYlergQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKl27dq6++67HeKzZs1SYmKiZsyYoaSkJIf2rl27qkCBAt4oEQDghjlz5hjGq1at6uVKAACwnzfffFNXr141bHvwwQe9XI1v/PTTTxo/frxhW7FixfTJJ5+4lLdMmTJ6//33DduOHj2qJ5980qW8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA7vD3dQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGsJDQ01jF+/ft3LlfhOz5499cEHHxi2JSQkqEOHDlq7dq2XqwIAALnVoUOHNHjwYJUsWVIjRozQ999/r6+++sorfZcqVSrLyz788MNOx5LPPPOMEhMTzSpL0l/jsmeffdawrWjRomrVqpWp/QEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkFMMGDDAMD5t2jRJ0vnz57VkyRKH9rx586pnz54erQ0A4L6dO3caxm+55RYFBwd7txgAAGwmMTFR3377rWFb9erVvVyN70yYMEGbNm0ybGvfvr0ef/zxbOXz9/fXrFmzFBYW5tCWkpKiRx55RNeuXXOpVgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHf4+7oAAAAAAAAAAAAAAAAAAAAAAAAAwCry5s2rggULKk+ePB7rIzAwUJGRkcqbN6/H+rCikJAQj7+2VuTpbcrK29Pfzz0iIkJ+fn6+LifX4fXPmrCwMEVGRiooKMjXpWSJHY6lQUFBioyMVIECBdj2LMyuxwg77AN/12jFc3N25c+f3zAeHx/v5Up8o3Pnzvr0008N95GkpCR16dJFq1at8kFlOYtVz8UBAQGKiIiwZG3/9PcxJzQ01NelIAez63Zmh3GDWew6toPrrly5orfeekvNmjVTamqqV/qMiIjI8rLdunUzjB88eFALFiwwqaKM5s6dq8OHD2erHviWHY9dfH7wFyuO4e0yfveU4OBgFSxYUPny5fN1KZmy4raTU9hhH7DL+2/V+9t2vS6T7HFtlpPu6QIAAAAAAAAAAAAAAAAAAAAAAAAAAABAdoSHhxvO0bNt2zbt2bMn/fG0adMM1x8wYIDHanOHVecPgLXZYQ4Ps9h1Lgs7zGNhRWfOnHHaFhYW5sVKYDV2nA/OG5iPxh7scN626txbdnjtrObnn382jN95551ersR3UlNT9cgjj+jq1auG7ZMnT1a5cuWynO/ZZ59V/fr1DdvGjh2rLVu2uFQnvM+u1xa5GecB5xgfe5cdjx9Wvi/Bvu1ddtx+zWDVaxxnrLzPOmPlmu16nrTya/pPVv5cy277vhms/H54m5Xff7sel2AOK2+bAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICcIdDXBQAAAAAAAAAAAAAAAAAAAAAAAABmqVSpkkPs7NmzunjxouHyTZo0UdeuXXXvvfeqQoUKCg4OTm9LTk7W77//rp07d2rNmjX66quvdO7cuWzXVL16dUVHR6tevXqKiopSWFhYetv169d1/vx57d69W8uXL9eyZct04sSJbPfhjNHrIUn79+93O09mr2vBggXVpUsXNWnSRNWrV9dtt92W4bX9+3n/+uuvWr16tVatWqW9e/dmqyZXapY8/9w9vU35cntyJigoSI0bN1aLFi1UtWpVVa5cWUWKFFFAQED6Mmlpabp8+bJiYmK0a9curVu3TuvWrdOuXbs8Xl9O54vXv3DhwipatKjT9ltvvdUwXqBAAaf7pjOJiYk6fPhwttYxEhISoubNm6t58+a6++67dddddykyMlJ+fn4Z+jpx4oT27t2rTZs2adGiRab0/Tc7Hktvplq1amrTpo1q1aqlqKgolSxZUiEhIentaWlpunr1qvbv36/t27dr2bJlWrVqlVJSUrLVT4kSJRQREeEQj4uL89hxLjAwUOXLl3eIp6am6sCBAx7p0xOsdIzOiftAyZIl1bFjRzVo0EB33323ypQp43DuP378uHbv3q1Vq1Zp0aJFOnv2rFdrdEdoaKhhPD4+3suVeF/Lli01Z86cDPvK31JSUtS9e3ctXrzYB5VlXXb3Oemv82XVqlV15513qkCBAgoLC8twrnz33Xd148YNl+qxwrnYmTp16qhp06aqU6eOqlWrpsKFCzts/4mJiTp16pT27t2rX375RUuWLNG2bds8Xts/ValSRe3bt1edOnVUtWpVlSxZUkFBQentaWlpunTpkvbt25d+3Fm1apXL75knFS1aVIULF3aI32wbzS4/Pz/dddddDvGbnc+9Nd7N6ljXrOvbrLDKdpYTxw1m8PbYzo7XfvCcfx4LMpMvXz41bNjQsO3LL780syTD/KNHj3aIN2/eXH5+fkpLS/No/9Jfx6NixYo5bb/lllucxrO730iZnwusMh6083VpTv/84GasPoZ/7rnnLD1+z6rsbpeRkZHq2LGjHnjgAd1999264447MtyPS0lJ0ZkzZ7R7925t27ZNX3/9tXbu3Omp8g1ZYduxyjHQE6x+DWuF9z+rvHV/O7uscl0m5cxrs5x+TxcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsqNHjx7Kly+fQ3zatGkZHq9YsUKnTp1SyZIlM8QrV66sevXqadOmTR6tMzPemj/AivNyuTJPnbN5fi9duqTTp09nucbscDY308WLF53+Tb+n5+Dz9RwezDH4F7vPY2EXCQkJTtuM5t71Bnf2gdKlS2eYr8vTzp07pwsXLli2jqyw83xwkmfnh8rJ89FYff7f7PD1eftmrDz3ltVfO7twNk4uUKCAlyvxrePHj2vIkCH6/PPPHdry5cun2bNn695771VycnKmeWrVqqWxY8catm3evFkTJ040pV53lStXznA+3tOnT+vSpUtu5w8LC1Pp0qUd4r/++qspc+jefvvtyps3r0P8t99+U1JSkks57XptIVl/vsmQkBCVLVvWaXtsbKz++OOPbOf15nnAivdNnOG3vv7CvYm/ZHb86N+/vyXvS9h1jGfF/SArrLL9epMVrnFyw73EyMhItW/fXi1btlTVqlVVtmzZDNuWr2q2830ku2wHVp0X2wr7vi/46v2w2nWNld9/xu85+zPhm7HytgkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyNn80rL4S8P//FEdAPinqlWrqmrVqpL++tG1o0ePasuWLab8kDkAAAAAawoJCdG99e71dRnI4X4/8buOHj3q6zIAAAAAeNnrb7zu6xKQC/y6/1dNnz7d12UAgCmGLpBC8vu6CuRkJ/dKs5/2dRUAAGf8/PxUq1YtlS9fPv373rt379bu3bt9XFnuxHdqAesw2u9GjRqlSZMmZYg1b95ckydPVsWKFbOcOyUlRZ9//rleeOEFnTp16qbL161bV5MnT9Y999yT5T5SU1M1e/ZsPf/88zpx4kSW13PG2XEou38rlNXXtUSJEho3bpx69eqloKCgbPWxYcMGvfjii/rhhx+ytZ4z3n7urm5Tt912m222p38rVqyYnn76aT3++OMKDw93Kce2bdv0yiuvaNGiRaacN816383kqZp8+fq/+OKLGjt2rEt9ZteGDRvUoEEDl9cvXbq0nnvuOfXs2VOhoaHZXn/btm16+eWXtWjRIpdr+Jsdj6VG8uXLp8cff1xDhw7V7bffnu31z58/r8mTJ+vtt99WfHx8ltZ57LHHNG3aNIf45cuXVaxYMSUkJGS7jpt56KGH9NVXXznEly9frlatWpnen9nscoy24z4gSffff79eeOEFNWvWLFvH8+TkZM2aNUtjx47V8ePHM7Rt3rxZdevWdVjnnnvu0datW90t2SV169bV5s2bHeK1a9fWzz//7IOKbu7YsWMqU6aMQ7xr166aN29elnI0atRIy5cvV548eRzaUlNT1bNnT82ePdvdUj0uq/ucv7+/unTposcff1wNGzZUYGCg05yFChVSTExMtuqw0rn4n4KCgjRgwAANGDBAlSpVcinHyZMn9e677+qjjz7S1atXTa3vb0FBQerdu7eefvppVahQIdvrx8XFadasWXrttdd07NgxU2oyY3z7yiuv6Nlnn3WIG22j7siXL5/i4uIc4teuXVNYWJjT9bw13s3qWNfT1zl22c7sOm4wg6/Gdna69vO2Tp06acGCBQ7xvXv3KioqygcVmctoG7lx44by5s1703WbNWum1atXG7ZVrlxZ+/fvd7s+Z6pUqaI9e/YYtlWvXl07d+70WN9/Gz58uN58802P9yNJf/75p0qWLOm03dfjQTtfl+aWzw+cyaljeG+M312R1e2yVKlSeuGFF9SnT59sj3sOHDigl19+WV988YVSU1PdqjczVtp2fH0MNJsdrmGt9P5nxhf3t7PCitdlUs66Nsst93QBILfy8/NT7dq1Va5cOb5PCyDL3LnfxFztAJzh70oAAAAAAAAAR9HR0apeo7qvywCc+uSTT3Tg1wO+LgMAbG34iOEqXry4r8sAMvXmG2/qzJkzvi4DAGxtwOdSeFFfVwE4N7mTlHjd11UA8BXmarcWvlML2M+uXbvS99u/Xb9+XcWKFVNsbGyG+MSJE/Xf//7XIcfMmTPVq1cvj9b5b76YP8CK83K5Mk+ds3l+9+3bpypVqmS9yGyYO3euunbt6hDv3LmzFi5caLiOJ+bgs9IcHswx+Be7zmPhKjPmzXVFmTJlnL6PRYoU0YULF7Kcy5O//5DVPIsXL1abNm2y1Z87xowZo3Hjxlm2jszYeT44T88PlRvmo7H6/L83Y6XztjNWnXvLDq+dq3x1Lm3evLlWrFjhEHd3O8+Ms7lvz5w54/PvaTgb30vSyy+/rNGjRztdN2/evNq5c6fKly/v0BYbG6u7777b1LnU3PH111+rQ4cODvFPPvlE/fr1czu/s2vMevXqGf4+RHYEBgbqwoULKlCgQIb4pUuXVLRoUSUnJ2c5l52vLcwcT3jyGq5AgQJaunSp6tevb9j++++/68EHH9TBgwezlM9X5wEr3jf5N37rKyPuTfwls3sTjz32WLbye/K+RE4Y41lxP3DGituvN1jpGseO9xKzelwtWrSonn/+eT3xxBMKCQnJVh+ePM7Y+T6SlbYDZ6w6L7ZkrX3fW6zwfljlPqmV33/G7/+Tkz8TdsbK2yYAWBlztQNwBXO1A/AE/q4EAAAAyH0aN26sVq1b+boM5DJr1qzR8mXLfV0GAHhFy1Yt1aRJE1+XgVxm2dJlWrt2ra/LAACv4FwLX1m4YKHbf1MMAHbxwBCpuvemagIkSavek3Yu9XUVAOBdzNVuLXynFgAAAAAAAAAAAAAAAAAAwLuYqx2AK7LyHW/nvxoFAAAAAADgRN68edW6dWtfl4Ecbs2aNTp69KivywAAAAAAAAAAAAAAADlMQECAJk+erCFDhri0bp8+fdSpUyc98sgjWrrU+BeE/P39NWnSJA0fPjz9DwKzyt/fXz169NDDDz+s/v3767PPPst2nb4SHR2tjz/+WPnz53dp/fvvv19r167VggUL1Lt3b8XFxZlcoWe4u03t27fPdtuTn5+fRowYofHjxytPnjxu5apdu7YWLvzrxy87d+6s06dPm1JjTpbbXv99+/a5tF5QUJBeeuklPfPMMwoKCnK5/9q1a+vrr7/Wjz/+qN69e3v8e21WP5Z2795d77zzjooUKeJyjiJFimjixIkaNGiQevXqpTVr1tx0nblz52ry5MkKDQ3NEI+IiFC7du301VdfuVyPMz169DCMT58+3fS+zGT3Y4TV94EiRYroo48+UseOHV1aPzAwUI8++qi6dOmikSNH6oMPPjC1PrM5ex/i4+O9XIn31K1bV4sXLzbcf9LS0tSvXz/Nnj3bB5V5RsWKFfX555+rdu3apue28rm4fv36+vjjj1WpUiW38pQqVUqTJk3Sc889p2HDhmnGjBlu1/ZPDz74oD7++GPddtttLufInz+/+vfvr379+undd9/Vf//7X924ccPEKuEOV8e6ZrLzdmb1cYMZ7D62yw4r7A/I3KVLl7K03L333msYP3HihPbv329mSQ727t2rP/74Q6VLlzasa+fOnR7t39sOHjzodg5PjAftfOzK7Z8f5PQxvKfH75706KOP6r333nO4N5ZVf+/rzzzzjHr06GH6BJZW3nYy48lrYjNZ/RrWTu+/r+5v34ydr8sk61+b5bZ7ugAAAAAAAPCOatWqacOGDZKkd999V6NHj/ZxRQAA2FehQoUUWTDS12UATp0/d15XrlzxdRkAAAAAAAAAAAAAAAAecc8996hq1aoO8fnz5ys2NtYh/sknn+i5555zmDelS5cuGjp0aJbnKXKXVecPMJMn5+WaO3eu3n77bYWFhWWIV65cWTVr1tT27dtN7a9AgQJq3769Q/zcuXP69ttvTe0rM1afw8NMdp7LwurzWNhVZsfLq1everESeIud54OTPDs/FPPR2IPVz9tWn3tr586dln3t7CotLc3XJVhK//79Va9ePcP5X5999lmtWLEi/W8w/+3tt99W+fLlDdsGDx6sY8eOmVqrO+bNm6cOHTo4xNu2bSs/Pz+3t4t27doZxtu2bavNmze7lbthw4YqUKCAQ3zRokVKTk7Och47X1vYZb7J4sWLa+XKlYqKijJs37t3r5o3b64///wzS/msfg41S3bvm9h9fJxdVpjv3c7HD3fuTXjqvkRu2bfN5M5+YOft11VWv8Zxxo73Ejt27KipU6eqUKFCLq3viZrtfp60w3Zg1c+17Lrvu8uq74eR3PrbcnY/LmWXp8bvdv1M2MrbJgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgdwn0dQEAAAAAAAAAAAAAAAAAAAAAAACAN/j7+2vBggVq3769W3kKFCigxYsXKzo6WnPnzs3QFhwcrG+++UYtWrRwq4/g4GB9+umnKl26tMaPH+9WLm+YMGGCRo8ebUquzp07q0KFCmrbtq2OHz9uSk5PMWObstv2FB4erm+++UaNGjVyK8+/3XvvvdqxY4c6dOign376ydTcOUlufP337duX7XVKlSqlxYsXq1q1aqbVcd9992n37t3q2rWrli5dalref7LysTRv3ryaOXOmOnfu7H5x/1/JkiW1evVqPffcc5o0aVKmy8bFxWnOnDl6/PHHHdoeffRRffXVV6bVJUkRERFq2bKlQzwmJkbffvutqX2Zye7HCCvvA5JUp04dLV68WEWLFnU7V/78+fX++++rWrVqGjBggFJTU02o0HyhoaGG8fj4eC9X4h3VqlXT8uXLnT7vwYMH69NPP/VyVZ5zzz33aMWKFYqIiDA9t5XPxb1799Ynn3yigIAA02qLjIzUZ599pvbt26t79+5KSEhwK5+/v7/ee+89DRo0yKQKpYCAAA0bNkxt2rRRu3btdODAAdNyw3WujHXNYvftzOrjBjPYfWyXXb7cH5A1Z8+ezdJylStXNozv2rXLzHKc2r17t0qXLu0Qd1aXnR08eNCt9T0xHrTzsSu3f36Qm8bwZo/fPW3y5MkaOnSoKbmioqK0bds29e/fX5999pkpOa287WTGk9fEZrL6Naxd3n9f3992xu7XZZL1r81y4z1dAAAAAAAAeIe/v3/698yCg4N9XA0AAPZW5546atKkia/LAJxauGChNm/e7OsyAAAAAAAAAAAAAACAE+FFpduqSWGFpaA80vXL0vkT0h+7pZQkX1dnfQMGDDCMT5061TB+9OhR/fDDD2rcuHGGeJ48edS7d29NnjzZ7BIzsOr8AZ7gyXm54uLiNHfuXMN5fvv06aPt27eb2l/Xrl2VJ08eh/hnn32m5ORkU/tyxupzeJjF7nNZWH0eCzu74447DOMxMTFKTEz0cjXwNDvPByd5dn4o5qOxB6uft60+91bv3r1VqVIlkyqz5pjHF4zGs1LOna//Zq5cuaIePXpo7dq18vf3z9Dm7++vWbNmKSoqSlevXs3Q1qZNG/Xv398w55dffqmZM2d6rGZXLF68WDdu3HB4/4sWLaq6deu69bcGxYoVU40aNQzb2rRpo//+978u55akjh07GsbnzZuXpfXtfm1hl/kmy5Urp9WrV+u2224zbN+wYYPatm2rK1euZCmf1c+hZsrOfRO7j49dwe8fuM6sexNm3pfITfu2mVzZD+y+/brK6tc4ztjxXuLIkSP12muvmZLLrJrtfp60+nZg5c+17Lrvu8PK74eR3PrbcnY/LrnCU+N3O34mbOVtEwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQ+/jffBEAAAAAAAAAAAAAAAAAAAAAAADA/qZMmaL27dubksvPz08zZszQPffckyE+d+5ctWjRwpQ+JGncuHHq0aOHafk8YfTo0Ro9erSpOatUqaJVq1YpLCzM1LxmM2ubssv2FBkZqR9++EGNGjXK0vKpqamKi4tTcnJylpYvVqyYlixZotKlS7tcY06WW1//ffv2ZWv5cuXKadOmTapWrVqWlk9OTlZ8fHyWls2fP78WLVqkrl27ZqumrLD6sfSHH35Q586dTagqI39/f7322mtZeu4ff/yxYbx58+YqVqyYqXV16dJFwcHBDvHZs2crMTHR1L7MYvdjhNX3gYYNG+r7779X0aJFTajsfx5//HF99NFHpuY0U2hoqGH8+vXrXq7E8ypWrKhVq1YpIiLCsH3YsGGaMmWKd4vyoDvuuEMrVqxw+nzdYeVzcZ8+ffTpp58qICAgS8vHx8fr+vXrSktLy9LyHTt21MqVKxUSEuJSfZKUJ08effPNNxo0aJDLOTLz9/tTv359j+RH9mR3rGsWu29nVh83mMHuYztX+Gp/QNb9/PPPWVrurrvuMozv3bvXzHKc2rNnj2G8YsWKXunfmw4ePOjyup4YD9r92JWbPz/IKWN4X4zfPW3y5MkaOnSoqTmDg4M1ffp0/ec//3E7l5W3ncx48prYTFa/hrXL+1+wYEFL3N/+N7tfl0nWvzbLrfd0AQAAAAAAAAAAAAAAAAAAAAAAAAAAgNygZCWp+xvSgM+llsOl+3pJ9zwsNX5Cenii9OQ8qUEfKTifryu1rgIFChj+Xf9vv/2mH3/80el606ZNM4wPGDDAtNqMWHX+AE/x9Lxczub5jY6ONpyT1x19+vQxjE+dOtXUfjLr38pzeJjF7nNZWH0eC7vr1KmTYXzHjh1ergSeZvf54Dw5PxTz0diD1c/bVp976+/XLyvsOubxFWe/hXHx4kUvV2Id69ev1+uvv27Yduutt+rDDz/MECtatKimT59uuPwff/yh/v37m16ju65du6aVK1catnXo0MGt3G3atJGfn59hW1RUlG699Va38rdr184hdvnyZX3//fc3Xddb1xaeYpf5JmvWrKmNGzfqtttuM2z/5ptv9MADD+jKlStZymf1c6jZsnrfxO7jY1fx+weuMfvehBn3JXLbvm2m7O4Hdt9+XWX1axxn7HgvcfDgwXrttddMzfl3za6y+3nS6tuBlT/Xsuu+7w4rvx9Gcutvy9n9uOQqT47f7fSZsJW3TQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABA7hTo6wIAAAAAAAAAAAAAAAAAAAAAAAAAT+vUqZOeeOIJh/jRo0c1Y8YMrVu3TidOnNCNGzdUsGBBFS9eXE2aNNFDDz2k8uXLG+YMDg7WJ598omrVqik5OVkjRoxQx44dHZa7fPmy5s6dq2XLlunAgQOKjY1VaGiobrnlFtWqVUsdO3ZUw4YNndb+wQcfaOPGjTp27JjrL4CHNGvWTOPGjXOIp6Wlaf369Vq0aJF+/vlnnTp1StevX1d4eLiKFCmi6tWrq1WrVmrevLkCAgIMc5crV04zZsxQp06dPP00XGL2NmWH7emLL75Q9erVnbZv2LBB8+fP18aNG3Xo0CHFxsamt4WFhen2229Xo0aN1KtXL9WsWdMwR+HChbVgwQLVr19fSUlJ2a4xJ7PS63/y5Elt2bLFaXuhQoVUrlw5h3hMTIwOHTrkdD0je/fuzfKyBQsW1KpVq1S6dGmny+zevVtffvmlVq1apSNHjujSpUuS/toHCxcurFq1aunBBx/UI488ooiICIf1AwMDNWPGDB0/flw//fRTtp6LM1Y/lgYHB6tOnTpO21NSUrRx40YtW7ZMP//8s86ePauLFy/Kz89PBQoUULly5dSgQQN1795dJUqUMMwxYcIEHT58WF9++aXTfn7++Wft2rVLd999d4Z4QECAHnnkEb355puuPUEDPXr0MIxPnz7dtD7MZqVjRHZZfR8oW7asFi1apNDQUKfLJCQkaM2aNVq2bJl2796ts2fP6vLlywoJCVGhQoUUFRWlZs2aqX379goPD8+wbr9+/bRr1y6X6/Ok/PnzG8bj4+O9XIln3XHHHfr+++9VpEgRw/bnnntOkydP9m5RHhQQEKCFCxcanufcZeVz8R133KH/+7//k5+fn2H7n3/+qdmzZ2vlypXau3evzp07p9TU1AzPrXz58rrvvvvUuXNn1a1b1zBPw4YN9e6776p///5Zru2fZs6cqTZt2jhtT01N1ebNm7V48WJt27ZNZ86cUUxMjPLly6dbbrlFd955p1q1aqUWLVo4fY8jIyO1dOlS3Xvvvfr1119dqjOn89Z4NztjXTPZeTuz+rjBLFYZ21n12g+e9cADDxjGN23alKX1S5YsaRjfs2ePyzVlx+7duw3jzuoy2+nTpzPdb0qVKqVSpUo5xE+ePKmTJ09mq6+ff/452/VJnhsPWuXY5Yrc/PmBncfwb7zxhs/H757Uq1cvDR061CGemJiolStXavny5dq5c6fOnDmj69evK3/+/LrllltUrlw5tWjRQi1btnS6n/v5+Wny5Mk6evSolixZ4lJ9Vt52MuPJa2IzWf0a1i7vf3BwsBYvXmyJ+9v/ZufrMsn612a5+Z4uAAAAAAAAAAAAAAAAAAAAAAAAAAAAkNPV7ynVi5ac/Em+JCk4r1S3q3RXI2nBGOnCcW9VZx89e/ZU3rx5HeLTpk3LdL0FCxbo/fffd/hb9woVKqhBgwZav369mWVKss78ATlpXq6ff/5ZO3fuVLVq1TLEIyMj1a5dO82fP9+UfipUqGA478UPP/ygw4cPm9JHZqw+h4eZ7DyXhdXnsbC7SpUqqX379oZt33zzjZerMcfJkyd14MABU3PecccdCg4ONmxzNseXVer4JzvPB+fJ+aGYj8YerH7etvrcW5m9fr5+7XKCsmXLGsbPnz/v5Uqs5fnnn1ezZs0Mzxndu3fX4sWLNWfOHEnSp59+avg7AKmpqerZs6euXLni8Xpd8eWXXxqOpTp06KBRo0a5nLddu3aZtrdu3VpTpkxxKXf16tUNj1XffPNNls7d3rq2uOuuu0yfI88u8002bdo007HJ1KlTNWDAgAzH6sxY5RxqxfsmVhofW/H1MVtOvDexbt06n92XsMq+bSYr7wd23n5dZfVrHGfseC+xbt26eueddzxWs6usdJ7MLqtvB1b5XMuIXfd9d1j5/TCSW39bTrLWccnK45bssMtnwlbfNgEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuZNfWlpaWpYWdPLjkwBQtWpVVa1aVdJfP7p49OhRbdmyRVk8vAAAAACwoYiICI1+frSvy0AOt2bNGi1fttzXZQAAAADwstffeN3XJSAX+HX/r5o+fbqvywAAUwxdIIXk93UVyMlO7pVmP+3rKgAAzvj5+alWrVoqX758+ve9d+/erd27d/u4styJ79QC1mG0340dO1aPP/64SpQokR6LjY3ViBEj9Mknnyg1NdVpPn9/fw0ePFivv/66QkJCDJfp37+/vv/+e+3fv1/BwcEZapk8ebJeeuklXb16NdO6H3jgAU2dOlW33XabYfvChQvVuXPnTHMYcXYcyu7fChnlGTNmjPr27etQ89KlSzVq1Cjt27fvpnkrVaqkd999V02bNnW6zMMPP6yvvvoqW/U6q1ky57l7cpuy6vb05JNP6t133zVs27FjhwYOHKitW7dmOV+nTp306aefKjw83LD9iSee0NSpU7NVo2Te+24mM2qyy+v/z/wLFixwiM+fP19dunRxOe/NrF69Ws2aNTNs++OPPzR8+HDNnz8/S7nCw8M1atQoPfvss/L393doP3nypCpWrKi4uLgs12fHY6kkffLJJ+rbt69h2/z58zV69GgdOnTopnkCAwM1ZMgQvfzyy8qbN69D+5UrV1SlShWdPHnSaY7Bgwfr//7v/xzie/fuVVRU1E1ryIpSpUrp999/d9hHd+3apWrVqpnSh9nscoyw4z4QGBio7du3p1/v/VtKSoqmT5+usWPH6tSpUzfNFxYWpv/85z96/vnnlSdPnvT49evXFRMTo1KlSjmsc88992Tr/TPT8OHD9eabbzrEg4ODlZSU5IOKbu7YsWMqU6aMQ7xr166aN2+eQ7xkyZL68ccfDdeRpHHjxmnMmDEmV+kdRvvcqFGjlJCQoMmTJzu0Xbp0Sd98842WLFmiPXv26OzZs7py5Uq2+rTyufjbb79V27ZtHeKpqal68cUX9cYbbyghISFLuSSpXr16mjJlitPjw4MPPqjVq1dnOZ8kvfDCCxo3bpzT9hUrVmjkyJHas2fPTXPlz59fw4cP18iRIxUaGmq4zLFjx1StWrWbXl/8mxnj21deeUXPPvusQ3zUqFGaNGlSturJTL58+Qy3kWvXriksLMzlvN4e75p5nWPn7czq4waz2GVs93duX1z7WYGz527mtYkvhIaGaufOnSpbtmyGeHx8vIoXL37TsUFgYKASExMNj0+NGjXSunXrTK3XSOPGjbVmzRqH+OXLlxUZGenx/m/mxRdf1NixYx3iY8aMyfT47Apvjgftcuzi8wNHdh7DT5w4MUt5JM+M381itF2+/fbb6tu3rwoUKJBhuSlTpmjixIn6888/b5o3f/78GjZsmJ555hmn+9LVq1dVuXLlTO/HOWPlbUfyzTWxmax+DWv19/9vmd3blrx/f/tvdrkuk+x5bZbb7+kCQG7l5+en2rVrq1y5cnyfFkCWufMdb+ZqB+AMf1cC5B41atTQ9u3bJUlvvPGGnnnmGR9XBACAfbVs1VJNmjTxdRmAUwsXLNTmzZt9XQYA2Fp0dLSq16ju6zIApz755BMd+PWAr8sAAFsbPmK4ihcv7usygEy9+cabOnPmjK/LAABbG/C5FF7U11UAzk3uJCVe93UVAHyFudqthe/UwtOaDZZqOP45fqYSr0uzhksXjnukJNvas2ePqlSpkiGWnJysUqVK6ezZs5mu+/7772vQoEEO8Tlz5ig6OtrUOiXrzh/wb76Yl8udeeoGDhyoDz74wCG+bNkytW7OK84uAAEZFElEQVTd2u3aJOfzDkZHR2vOnDmZrmvGHHxWnsODOQb/YvV5LMyW3Xlz3VWgQAGtXbtW1as7fncjNjZWZcqUUUxMTLZyevL3H1zJY4YHH3xQK1asMOz766+/VqdOnWxRh53ng/Pk/FC5eT4au83/a+XztmT9ubeMXj+rvHZm8va59G+//vqrKlas6BB/6623NGLECI/06ez64syZM5b6nkb58uX1yy+/KF++fA5tV65cUdWqVdWqVStNmTLFcP1XX31Vzz33nKfLdFloaKjOnz+f4Zj/t4oVK+rgwYPZzhkSEqKYmBjD1+xvy5cvV6tWrbKdW/rrtxVeeOEFh3ibNm20dOnSTNf15rWF2XPkeXq+SbPGr126dNGsWbMyzFH7T+PHj9eLL76YrZxWP4f+zdv3TewyPv5nfjvdV/q3nHpvok2bNjfN6an7EnbZt83kq989sMv2azarX+PY8V6is+Pqnj17HH6/wsyaXanXLudJO24HkrU/17L6vu8JVn0/+G25jOxyXPpnfrv8dpnVPxOWrL1tAoDdMFc7AFcwVzsAT+DvSgAAAIDcp3HjxmrV2rXvvgKuWrNmjZYvW+7rMgDAK/hdF/jCsqXLtHbtWl+XAQBewbkWvsJvowHITR4YIlW/+Z/tAqZa9Z60M/NpNgAgx2GudmvhO7UAAAAAAAAAAAAAAAAAAADexVztAFyRle94O/4KDgAAAAAAAAAAAAAAAAAAAAAAAJCDPPbYYypRokT64+PHj6tGjRqaOnWqUlNTM103NTVV7733nrp06aLk5GTDZYYNG6bx48crODg4PRYfH6/WrVtr+PDhunr16k1rXL16tRo2bKhTp04Ztrdv316lSpW6aR5v6tevn2677bb0x8nJyerfv7/atGmjffv2ZSnH/v379eCDD+rTTz91uszIkSPdrtVsntymrLg9hYeHa8yYMYZts2bNUp06dbR169Ys55OkhQsXqn79+rpy5Yph+zPPPJP+B7W5Ha9/1vTo0UPNmjUzbNu4caNq1qyp+fPnZznf1atXNXr0aLVu3VqxsbEO7aVKldLYsWNdrvdvVj+WNmvWTH379nWIx8fHq0uXLurSpYsOHTqUpVzJycmaPHmy6tWrp/Pnzzu0FyhQ4Kav6axZsxQfH+8Qr1KliqpXr56lOm4mOjracPufPn26KfnNZvdjhNX3gaFDh6b/UNe/Xbp0SQ8++KCeeOIJp+fcf4uNjdXEiRNVvXp1HTt2LD2eL18+y431JCk0NNQhlpqaqqSkpAyxqKgo9ezZU6+++qrmzZunFStWaOPGjdq2bZs2bNig5cuX64svvtCLL76oLl26qFixYt56CpkqWrSo1qxZozJlyhi2T5061en+ZVf58uXT888/nyGWkJCg1157Tbfffrv69OmjBQsW6NChQ06PAc5Y+VxcpEgRtWzZ0rCte/fumjhxohISErJcmyRt2rRJtWvX1sKFCw3bx40bl618VapU0QsvvGDY9vexsWXLltqzZ0+W8sXFxWn8+PG6++679euvvxouc/vtt2vSpEnZqhP2ZvftzOrjBjPYfWwHewsMDNSCBQtUtmxZh7a5c+dmaWwQGRnpdHsyOp97grN7ZxEREWzr8sx40O7Hrtz8+YHdx/DZYfb43dMGDhyoAgUKpD++cuWKmjZtqsGDB+vPP//MUo64uDhNmDBBNWrUcDpWCw8P19tvv53t+qy87WTGk9fEZrL6Naxd3n9n97Yl393flux/XSZZ/9ost9/TBQAAAAAAgGdUr15dEydO1OLFi7Vv3z5t2LAhvW3IkCE6cOCAli5dqtGjR6tGjRpery8qKkpPPPFE+r/77rsvS+sFBgZmWM/dfz179vTwM3X9uQIAAAAAAAAAAAAAAAAAAPur2kKq0Tb76wXnkzqP/eu/+Mu9996rKlWqOMSXLVums2fP3nT9adOmGcY7d+6sQoUKuV3fP1l1/oCc4IsvvtD169cd4s2bN1fx4sXdzu/n52f4HeOYmBgtWLDA7fw3Y/U5PMxi97ksrD6PhZ2VL19eP/74o9N5uydOnKiYmBgvV2U9xYsX16xZswznNTtx4oT69OljizrsPh+cJ+eHYj4ae7D6edvqc285e/2s8NrlBPfdd58qVqxo2LZx40YvV2M9hw4d0rBhwwzbChQooK+//lpvvfWWYfv27dudjmWt4tq1a1q5cqVhW/v27V3K2bRpU+XLl/lNiiZNmtx0GWeM6rp69apWrVqV6XrevrYwe448O8w3OXDgQM2dOzfDHLV/S01N1eDBg/Xiiy9mK6fVz6G+Yvfxsd3k5HsTWeGJ+xLs295j9+3XVVa/xnHGrvcSo6Ki0v/fEzVnt167nyetvh1Y+XMtu+777rDy+2Ekt/62nN2PS1Zn9c+ErbxtAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAByN39fFwAAAAAAAAAAAAAAAAAAAAAAAAB4UqlSpdL//+LFi2rcuLEOHz6crRyLFy/Wm2++adhWsWJFde/ePf1xamqqOnXqpOXLl2erjxMnTqh3796GbQEBARowYEC28nla6dKl0/8/NTVVXbt21ccff5ztPKmpqerbt6/Wr19v2F6rVi01aNDA5To9wZPblBW3p6CgIM2ZM0c3btzIEF+2bJl69uyplJSUbNX2t71792rw4MGGbeXKlVPLli1dypvT8PrfXJ48eTRp0iTDtl27dqlZs2Y6f/68S7lXrFihXr16GbY9+eSTuuWWW1zK+zcrH0v9/f31wQcfOMSvX7+uRo0aaf78+dmuU5J27typZs2a6fr16w5tderUUXBwsNN1r1y54rTfPn36uFTPv/Xo0cMhlpSUpC+++MKU/Gaz+zHCyvtARESExowZY9gWExOje+65R2vWrMl2rZJ04MAB1a9fXydPnnRpfW8JCwtziMXHx0uS6tatq2nTpunUqVPavXu3Pv/8c40aNUpdunRR8+bNVa9ePdWqVUv33XefWrRooejoaI0dO1bz5s3T6dOntWvXLj399NMqWLCgt5+WJCkyMlLfffedypcv73SZ+vXrKyQkxItVeV737t1VuHDh9McXLlxQkyZN9Oyzz+rKlSsu57X6ubht27YKDAx0iH/55ZeaN2+eS3VJUmJiorp27arNmzdniK9evVovvvhitnJ9+OGHCgoKcognJSWpVatWLh0bJeno0aO65557tGXLFsP2J554QnXq1HEpN+zH7tuZlccNZrH72A72FRoaqmXLlunBBx90aLt27Zqef/75LOXJbOwUGxvrcn3ZkVk/mV1v5haeGA/a/diVWz8/yI1jeDPH756WJ0+e9P+/fv26mjRporVr17qU68iRI7rnnnu0Y8cOw/aHHnpI9evXz1ZtVt52MuOpa2KzWfka1i7vv7N725Jv729L9r8uk6x9bcY9XQAAAAAAAJgpMDBQQ4YM0eHDh7Vjxw7997//VZs2bVSpUiXly5cvfbk8efKoQoUKatWqlSZMmKDt27dr165d6tixo1fqLFy4sJYvX66PPvoo/d8jjzySpXUjIyMzrOfuP2f3kK3wXAEAAAAAAAAAAAAAAAAAgL0F55Ma9nV9/QK3SHW7mleP3Tmbq2Tq1KlZWv+XX37RL7/84hAPDg7Wo48+6k5pGVh5/oCc4OrVq/rqq68c4gEBAYbz82ZXs2bNVLJkSYf4zJkzlZiY6Hb+m7HyHB5msvtcFlaex8Ku7r77br3//vvat2+fqlSpYrjMypUrPf43AHbg7++vOXPmqEiRIg5tSUlJevjhh70yN5EZddh9PjhPzQ/FfDT2YeXzth3m3jJ6/azw2uUEISEhmjZtmmHb5cuXsz2vZE718ccf69tvvzVsq1GjhvLmzesQv379uqKjo5WcnOzp8tzmbF/q0KGDS/natm1702VCQkLUrFmzbOcuU6aMqlat6hD/9ttvlZSUlOm6vri2MHOOPKvPN/nSSy/pgw8+kL+/v0NbQkKCHn74Yaf3QDJj5XOoL9l9fGw33Jsw/74E+7b32H37dYUdrnGcsfu9RE/VnN167X6etPJ2YOXPtey877vKyu+HM7n1t+XsflyyOit/Jmz1bRMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkLs5/hItAAAAAAAAAAAAAAAAAAAAAAAAkEP17t1bx48fd2ndCRMmKCYm5qbLvfbaa1qxYoVLfXz//fdO123evLlLOb1hzJgxWrhwoVs5Hn30USUlJRm2tW/f3q3cnuTuNnUzVtieLl68qCeffFK333673nzzTcXFxeny5cvq1auXS3X90xdffKE9e/YYtjVt2tTt/DkBr//NRUdHq3jx4g7xq1evqmPHjrpx44Zb+RctWqRp06Y5xIODgzV48GC3cv+T1Y6lnTp1Urly5RzigwYN0tatW12q72+7d+/W8OHD0x9v3bpVHTt2VNWqVZWYmJjpuh9//LFhPDo6WoGBgW7VVaVKFUVFRTnEFy9erIsXL7qV21Ny0jHCavtA3759FRYW5hBPS0tTjx499Ntvv7lU499Onz6tzp07KyUlxa08npQ/f36HWGBgoLZt26bNmzfrscceU4kSJVzKXbVqVb3++us6deqUXn31VcO+PCUsLEwrV6403N//qVKlSpo4caKXqvKO8uXLp///5cuXde+992rTpk1u57X6ubhs2bKG8RkzZrhVlyQlJyerT58+io+P18yZM3X33XfrwQcf1OrVq7Oc4/7771f9+vUN25555pls5TISGxurzp0769y5cw5tfn5++u9//+tWfthDTtvOrDZuMEtOGtvBPmrVqqXt27frgQceMGwfOXKk/vzzzyzlypMnj9O22NhYl+rLrsz6yay+3MIT48GcdOzKTZ8f5NYxvBnjd28bNGiQduzY4VaOv8dqly5dMmx/6qmnspzL6ttOZjx1TWw2K1/D2uX9d3ZvW/Lt/e2cdl0mWe/ajHu6AAAAAAAAMMudd96pbdu26b333nN63zYzVatW1cKFC7VkyRJFRkZ6oML/mTVrlkqWLOnSuqGhoSZX41nuPFcAAAAAAAAAAAAAAAAAAGBvUQ9KecPdy1GjnRQQZE49dhYREaEuXbo4xE+fPq3ly5dnOY/R/ACSNGDAAJdr+zerzh+Qkzib57dv375u5+7Tp0+2+jSblefwMEtOm8vCavNYeFPlypXVoEGDbP1r2rSp2rdvrx49emj06NGaM2eOjhw5op07d2rQoEFO5+pevXq1OnbsqLS0NC8/S+sZM2aMGjZsaNj27LPPun2e8WYddp8PzlPzQzEfjX1Y+bxth7m3jF4/K7x2dhceHq7ly5erQoUKhu3Tp09XfHy8l6uyrr59++rMmTNZXn7YsGE6dOiQBysyz7fffquEhASHeN26dVW0aNFs52vTpk2Gx8nJyfrxxx8dlmvbtm22czsb886bNy/T9Xx1bWHmdYVV55v08/PTlClTNGbMGMP2q1evqkWLFlqwYIFL+a18DvUlu4+P7YR7ExmZdV+Cfds7ctr2m1V2uMbJCjveS/RkzdmpNyedJ622HVj5c62csu9nh5XfD2dy62/L5aTjklVZ9TNhq2+bAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDczd/XBQAAAAAAAAAAAAAAAAAAAAAAAADe8M0332jp0qUur3/t2jUtWLAg02VOnTql8ePHu9yHJE2fPt0wfvfddyskJMSt3J6wa9cuvfLKK27nOXbsmBYtWmTYdt9997md3xPM2KYyY7Xt6cyZM3r66ad12223qV27drp48aJbtf3to48+Mozff//9puTPKXj9nRsyZIhh/N1339WxY8dM6eOVV15RamqqQ7xXr16m5LfisXTo0KEOsW+//VYzZsxwpTQHH3/8saZMmaJGjRrpnnvu0aJFi5SWlnbT9X788UcdOHDAIV6oUCG1bt3arZp69OhhGHd2LLUSux8jrLgPDBw40DD+2Wefafny5dktzdDWrVudvsZWEBoa6hALCQlRrVq1TOsjT548GjVqlA4dOuSVc0/evHm1dOlS1a5dO0vLDxs2TA0aNPBwVb7Rt29fHT582JRcVj8XlyhRwjB+5MgRt+uSpIMHD+qWW25Rr169tHv37myv//TTTxvGv/vuO73zzjvulidJ+vPPP/X4448btrVr107lypUzpR9YV07azqw4bjCb3cd2sIeIiAhNnjxZmzdvVvny5Q2Xee+99zRlypQs5/T3dz6VUWJiYrZrdEVCQoLTtoCAAK/UYBdmjgcl+x+7ctvnB7l5DO/u+N2bNmzYYNq9uOPHj2vkyJGGbR06dFCxYsWylMfq205WmX0MNJOVr2Ht8v4b3duWfH9/Oyddl0nWvDbjni4AAAAAAADMUKlSJW3evFnVqlXLEE9LS9OePXs0c+ZMff755+nxXbt26fvvv9eVK1cccrVu3VqbN29W0aJFPVLrs88+q+bNm7u8fv78+U2sxrPcfa4AAAAAAAAAAAAAAAAAAMDe7qzrfo7gvNKtVd3PY3e9evVS3rx5HeIzZsxQSkpKlvN88cUXunHjhkP8zjvvVJMmTdyq8W9WnT8gJ9m0aZP279/vEK9YsaLq1Knjct7w8HB16NDBIb5582bD/jzBynN4mCUnzWVhxXksvOnFF1/UunXrsvXvu+++06JFizRz5kxNmDBB3bp10x133OG0j+TkZI0dO1YtW7ZUfHy8F5+dNTVp0kTPP/+8YdvSpUv11ltv2bIOu88HJ5k7PxTz0diHlc/bdph7y+j1s8JrZ2ctW7bUTz/9pMaNGxu2X7x4Ua+++qqXq7K2ixcvqnfv3lm6nvr222/18ccfe6Eqc1y7dk0rV650iPv5+alt27bZylWtWjWVKlUqQ2zdunWG17iu/PaK0XVYbGysVq1alel6vry28MQc+VaZbzI4OFjz5s3TgAEDDNvPnDmjBg0a6IcffnC5DyufQ60gJ4yPrY57ExmZdV+Cfds7ctL2mx12uMa5GTveS/R0za7Ua/fzpBW3Ayt/rpUT9v3ssvL7kRW56bfl/mb345KVWfUzYbtsmwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA3Mnf1wUAAAAAAAAAAAAAAAAAAAAAAAAA3jB+/Hi3cyxYsCDT9smTJys+Pt6tPpYsWaLExESHeFBQkKpXr+5Wbk944YUXlJKSYkquTz/91DBeo0YN5cuXz5Q+zGTGNpUZq25PFy9e1IYNG9yq65/WrFljGK9evboCAgJM6yen4PXP6NZbbzXclq9fv663337btH6OHj2q7777ziF+22236a677nI7v9WOpUWLFlX9+vUd4q+99ppbtf1TWlqaBg0apHXr1mV73alTpxrGH330Ubdq6t69u0PszJkzWrFihVt5vcmuxwir7QPly5fXnXfeadj25ptvulybkQkTJig5OdnUnGYJDQ31Wl8lSpTQmjVr9Pjjj3usj+DgYC1atEj333+/YbvRuMvf318zZszw6mvhDV9//bW+/vprU3LZ4VwcEhJiGE9LSzOlNkmKjY11ab2wsDC1bNnSsO2VV15xpyQH3377rfbt2+cQ9/Pz00MPPWRqX7CWnLadWW3c4El2HdvB2vLmzauRI0fq6NGjGjp0qAIDAw2XmzJlioYOHerl6uAtZo4H/82ux67c9PkBY3jXx+/eZvZnEDNnztT58+cd4oGBgWrRosVN17fDtpMVnjwGmsGq17B2ef+d3duWfHt/O6ddl0nWuzbjni4AAAAAAADMkDdvXi1evFiFCxdOjyUnJ+vtt99WmTJlVLVqVfXq1UvvvPNOevvq1avVrFkzRUREqFmzZg6flVWoUEHLli1z+tmsq+677z5NmDDBrRz//l7cyJEjVbNmTZf/NW/e3K16nDHjuQIAAAAAAAAAAAAAAAAAAHsrfJs5eQrdak4eO+vfv79h/JNPPslWnitXrmjhwoWGbQMGDMh2Xf9m1fkDciJn8/z26dPH5ZwPP/yw8ubN6xD/+OOPXc6ZXVadw8MsOW0uC6vNY5HTHDx4UJUqVdJLL71k2utsZ0WLFtUXX3whf39/h7aTJ0+qV69etq/DrvPBmTk/FPPR2ItVz9t2mXvL6PXz9WtnRyVLltSQIUO0adMmLVu2TBUrVnS67JAhQwzn9cvtVq1apffeey/TZc6cOaO+fft6qSLzzJs3zzDeoUOHbOVp06aNQ+zbb7/VkiVLHPbb4sWLq0aNGlnOHRkZafgbDIsXL1ZCQoLT9Xx9bWH2HHlWmW8yNDRUy5cvd/rcDh8+rHr16mnXrl1u9WPVc6jV2HV8bHW+Pn5I1rw3YcZ9CfZtz8tp229W2eUa52bseC/R0zW7U69dz5NW2w6s/LlWTtn3s8PK70dW5Lbflvs3ux6XrM5qnwnbcdsEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOQu/r4uAAAAAAAAAAAAAAAAAAAAAAAAAPC0Xbt2afv27W7nySxHamqqZsyY4XYf8fHxOnDggGHb7bff7nZ+M504cUKLFy82Ld/GjRuVlpbmEA8MDNRtt91mWj9mMGubciY3bU8HDhzQtWvXHOKBgYGKjIz0QUW5i91f/wceeMAw/t133ykmJsbUvn744QfDeKNGjdzKa8VjaYsWLeTn55ch9ssvv2jTpk2m1OiuGTNmKDEx0SHeunVrFS5c2KWc999/v2699VaH+MyZM5WSkuJSzpzAG8cIK+4DDz74oGF8/fr12rdvn1v1/dvp06e1ZMkSU3OaJX/+/DddJikpSb/88oumTZum8ePHa9iwYXrsscfUr18/jRgxQhMnTtTs2bN15MiRm+YKDAzURx99pD59+phRfgZBQUGaN2+e0/d2woQJ6tatm2FbmTJlNHnyZNNr8iUzn48dzsWXL182jFthPPzggw8qKCjIIb53716tWbPG9P6cvfdt27Y1vS9YR07azqw4brATu1//wT1BQUEaNGiQjh49qtdeey3T9/yZZ57RoEGDDPcP5Ax2Gt9649iV2z4/YAxvDydOnNDq1atNzZmQkKBPPvnEsK1FixY3Xd8O205WWP0YaNXt3y7vv9G9bcn397dz0nWZZM1rM+7pAgAAAAAAwAwjRozQHXfckf44NjZWTZo00fDhw/X777/fdP3vv/9eDRo00ODBgzPc86pZs6ZefPFF0+osXLiw5s6dq4CAALfyhIaGZni8b98+7dixw+V/u3fvdqseI2Y9VwAAAAAAAAAAAAAAAAAAYG95w83Jkz+XT7VUv359VapUySG+bt06HT58ONv5pk6dahjv0KGDihYtmu18/2TV+QNyos8//1wJCQkO8e7duyskJMSlnEbzil69elXz5s1zKZ8rrDqHh1ly0lwWVpzHIqepUKGCVq5cqZEjRypPnjy+Lsen/Pz8NHv2bBUrVsyhLSUlRd26dTN9Ph0r15FV3prL0sz5oZiPxl6set62y9xbRq+fr187b+vQoYNGjhyZpX+jRo3SSy+9pDfffFMff/yxvv/+e505c0YnT57Ue++9p3vvvTfTvsaNG6e5c+d66ZnZz8mTJzNtv3LliuLi4rxUjXm+/fZbw+umZs2aKV++fFnO065dO4fY4sWLdebMGf38888ObW3atMly7jZt2hj+LeZXX32V6XpWuLYwc458K8w3WaRIEa1bt05NmjQxbN++fbvq1aunY8eOud2XVc+hOR1zvf/FCscPyXr3Jsy4L8G+7Xk5afvNDrtc42TGjvcSvVGzle595tbfu7Py51o5Yd/PLiu/H1mR235bztMYv//Fap8Js20CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzO39cFAAAAAAAAAAAAAAAAAAAAAAAAAJ62cuVKU/JcuHBB58+fN2zbuXOn07bs2rdvn2E8IiLClPxmWbJkian5rl69qiNHjhi2RUZGmtqXu8zaptiepLS0NJ0+fdqwrWDBgl6uJvex++t/3333GcbN2kf/acuWLYbxypUru5XXisfS+++/3yHmidfUVRcvXtSiRYsc4kFBQerevbtLOXv06GEY//TTT13Kl1N44xhhxX3gnnvuMYyvXbvW5boys2zZMo/kdVd8fLxhPC4uTrNmzVLz5s0VFhamGjVq6PHH/x97dx6v5Zg/DvxzTrsWaSqRtcW+L2Ema1IkYmStlCHZxvKdwVhnDL4MxjLWJEshZStLlDVCjCTbKAwSaZX29fz+8NPX8TynTuc8233O+/169eL5XPd9XZ/nXq/rfp5zPafEZZddFjfddFMMHDgw7rnnnvjnP/8Zl1xySZxwwgnRpk2b2GCDDeLCCy+ML7/8ssw2i4qKon///rHnnntm9L1cffXVcfjhh6ctu/nmm+PSSy+NESNGxAMPPJB2mT/84Q/RtWvXjOaUL//5z39izJgxGasvCffisq5jFb1nZNL++++fNv7cc89lpb2y6t1jjz2iTp06WWmT/KtKx1kh9huSJOnjPyqmuLg4TjzxxJg0aVLcdttt0aJFi9UuP3ny5Lj++utzlB35kOn+YLbl4tpV3T4/0IdPhlGjRmWl3pdeeiltfPfdd1/jukk4dtYkCdfAQj3+k7L/0z3bjsj/8+2qNC6LKMyxmWe6AAAAAGTCKaecUur1WWedFa+99tpa13P77bfH6aefXip23nnnRbNmzSqV388GDx4cLVu2XPX6xhtvrFA99evXL/W6rO8M5lOm3isAAAAAAAAAAACQbMsWZ6aepYX3dcmc6tevX9r4gAEDKlTfK6+8El988UVKvFatWtGnT58K1fmzQp0/oCqaPXt2PPHEEynxddddN7p167bW9bVp0yZ++9vfpsQfeuihWLhwYUVSrJBCncMjU6rSXBaFOI9FVbT55pvHtddeG5MnT47DDjss3+nkzcUXXxwdOnRIW3bppZfG2LFjq1Ue5ZWL+eAyPT+U+WiSpVDv20mZeyvd9sv3tsu14447Lq699tpy/bvmmmvi8ssvj/POOy9OOeWUOOCAA2L99ddfYxslJSVxxRVXxOWXX56Dd5RMO+20U1x55ZWrXWbLLbeMG264IUcZZc68efPSzhFZt27d6NSpU7nqWH/99WO33XYrFfvwww/jv//9b0REDB8+PGWdtflthHTjtwULFqxxjFAIY4tMzZFXCPNNbrrppjF27NjYZZdd0paPHj069t1334zNUVuo99CqzlzvPymE60dE4T2byMRzCed29lWl43dtJGWMszpJfJaYq5wL5dlndf29u0L+XKsqnPtrq5D3x5pUx9+Wyzb9958U2mfCjk0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACl1xvhMAAAAAAAAAAAAAAACAbHvjjTcyVte0adPSxseNG5f1Nho3bpyxNjJhzJgxGa9zypQpaeNNmjTJeFuVkaljyvH0k7lz56aNF9p+r6qSvP232mqrtPE333wz42199913aeNbbLFFpeotxGvp1ltvnRLL5L00E/r375823rt377Wuq1atWnHUUUelxMeNGxeffPLJWtdX1WT7GlGI58CWW26ZNp6Na0tExGuvvZaVeivriCOOiGOPPTY++uijiIiYP39+XH755dGiRYvo2bNnjBo1KpYsWVLu+qZNmxbXXntttG7dOv7yl7/E0qVL0y5Xs2bNeOihh6JevXoZeR8REZtsskna+N133x3nnHPOqtd//OMfY+rUqWmXHTBgQDRt2jRjOeXLK6+8ktH6knAvfv3119PGe/XqFd27d690XpWxzTbbpI2XlXNlffPNN2mvkcXFxWVe+0i+qnScFWK/IWmSPP5j7f3+97+Pjz76KO67777YbLPNVrvs0qVL4/rrr48dd9wxN8mRN5nuD+ZCtq9d1e3zA334ZMjWs4K33347SkpKUuKbbbZZ1K5de7XrJuHYWZMkXAML9fhPyv5P92w7Iv/Pt6vSuCyiMMdmnukCAAAAUFkbb7xxqe+ZzZgxIwYNGlTh+u6888546623IiLinXfeiZNPPjlmz55d6TwvvPDC6NSp06rXN9xwQzz55JMVqqtBgwalXi9atKgyqWVcJt8rAAAAAAAAAAAAkGzzZmamnh9nZKaeJFpvvfXSzr06d+7cePTRRytc7z333JM2fuqpp1a4zojCnT+gqrrrrrvSxvv06bPWdZU1N3BZcwlnS6HO4ZEpVWkui0KcxyLX5s2bFzNnzqzQvzlz5qzV/MAbbbRRPPnkk3HVVVdl8R0Vpr333jv++te/pi0bPXp0XHPNNdUqj7WV7fngMj0/lPlokqVQ79tJmXsr3fbL97araqZNmxadOnWKyy+/PN+pFKy6devGww8/vMY5DSMiTj/99OjSpUsOssqsoUOHpo1369atXOt36dIlioqKSsWeeuqptP//s1133TVatGixxrrr1KlT6u8xf/b000/H4sWLV7tuIYwtMjVHXr7nm9x+++3jzTffjLZt26Ytf/jhh6NLly6xYMGCjLVZqPfQ6sBc74Vx/YgozGcTlX0u4dzOvqp0/K6NpIxxVieJzxJzlXMh3YOq4+/dFfLnWlXh3F9bhbw/1qQ6/rZcLui//6SQPhN2bAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQ6IrznQAAAAAAAAAAAAAAAABk2+TJkzNW17x589LGJ02alPU2GjdunLE2MuGTTz7JeJ1z585NGy+0956pY6o6H08tWrSI3/3ud9GzZ89o0qRJ2mVq166d46yqj6qy/bfYYou08a+++irjbc2ZMydtfL311qtUvYV4Ld1yyy1TYu+9915lUsq4F198Mb744ouU+C677BLbbbfdWtV18MEHpz0PBg4cWOH8ki6X14hCPAfatm2bNj5x4sSKprRan3/+eaxcuTIrdVdGSUlJPPLII7HddttFly5donXr1nHFFVfE/PnzK1XvypUr45prrok999wzZs+enXaZzTffPM4666xKtbMmDz30UJx66qmlYnPnzo2TTjop7fLNmzePu+66K6s55cK4ceMyWl8S7sWvv/56zJo1KyVeXFwcjzzySNx///2x4447ZiTHtbX11lunjY8fPz5rbb777rtrlQvJV5WOs0LsNyRBVRn/UX6dO3eOd999Nx599NHYaqut1rj8z8v9+c9/jkWLFuUgQ/Ip0/3BbMnltau6fX5QVfrwVV0mj8tfmjt3btp9XVxcHK1atVrtukk4dtYkCdfAQh3DJmX/p3u2HZH/59tVaVwWUZhjM890AQAAAKisli1blnr94YcfVvoZ0Kmnnhq/+93vol27djFkyJBYsWJFpepr3759XHnllatev/XWW3HhhRdWuL4GDRqUel1Inxdn+r0CAAAAAAAAAAAAyfZlhv5k/KvCmlo1p0488cSoW7duSvzhhx+OxYsXV7je++67L+33ZDfffPM46KCDKlxvoc4fUFW98sor8dlnn6XEO3bsmPJd69UpKiqKXr16pcTHjx+f831XqHN4ZEpVmsuiEOexyLWTTz45mjVrVqF/TZo0ibp160atWrWiZcuWcdBBB8X5558fY8eOjZKSkrTtFRUVxUUXXRR/+9vfcvxO86dp06YxZMiQqFGjRkrZtGnT4oQTTihze1XFPMorl/PBZXp+KPPRJEuh3reTMvdWuu2X721XVcycOTMuuOCCaNOmTYwePTrf6RS0f/7zn+WaA/dn9957bzRv3jyLGWXe8OHDY8mSJSnxQw89NIqLi9e4/mGHHZa2zp9NnDgxvv7661LlRUVF0aVLlzXWfeCBB0b9+vVT4sOGDVvjuoUytsjEHHn5nG+yffv2MWbMmNhggw3Sls+fPz/OOOOMWLZsWUbbLdR7aFVlrvfSCuX6sbpcyivTzyYq+1zCuZ19Ven4XRtJGeOsThKfJeYq53w/+6zuv3dXyJ9rVYVzf20V8v5Yk+r423LZov+eqpA+E67OxyYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyVAz3wkAAAAAAAAAAAAAAABAtn377bcZq2v+/Plp49OmTctYG/PmzUsbLy4uzlgbmTB16tSM1/njjz+mjRfae8/UMVWVj6c6derEZpttFq1bt45WrVpFmzZtolWrVqv+1atXL6vtV3fVZfuvt956KbFFixbF7NmzM95WWedrw4YNK1VvIV5LmzRpkhKbMWNGpXLKhgEDBsTVV1+dEu/du3f86U9/Knc9PXr0SIktWrQohgwZUqn8ClkhXSMK8RxYd91108ZnzZpV4ZxWZ9myZfHtt9/GRhttlJX6M+HZZ5/NeJ3vvfdedOzYMV5++eVo1KhRSvmFF14Yt9xySyxevDjjbT/55JPRq1evKCkpSSkbNWpU9O/fP/r27ZtSduSRR0aPHj1i8ODBGc8pV95///2M1peEe/GyZcvif//3f+P6669PKSsqKopevXpFr1694ptvvol33nknPvroo/jss89W/fv+++8zkn86zZo1SxvP5n135syZaeNNmzbNWpvkV1U6zgqx31AICqlvR37ttNNOccstt8Tee+9druVHjRoVF198cfz73//Ocma5O6dW1066vl91lOn+YEUV0rWrun1+UFX68AcccEDO+++59NVXX2Wt7tmzZ8dmm22WEk93bKypvNCOnTUplGvg6hTqGDYp+z/ds+2I/D/frkrjsojCHJt5pgsAAABAZdWqVavU60x8b23ixImVruNnTZs2jSFDhkSNGjUi4qfn/UcffXQsX768wnXWr1+/1OtFixZVKsdMycZ7BQAAAAAAAAAAAJLtoxcidj08oqio4nV8NSFifnb+/DgRTj311LTxAQMGVKreb7/9Np5//vk45JBDUsr69esXo0aNqlC9hTp/QFV29913x7XXXlsqVlxcHD179oxrrrmmXHUccMABsfHGG6fE+/fvn5Ec10ahzuGRKVVpLotCnMciiZYvXx7ffvttfPvttzF69Oi47rrrYrPNNot//OMf0b1797TrXHbZZfHOO+/E008/neNsc2/QoEGx4YYbpsRXrlwZxx9/fM7uL4WSx88KaT64TM8PZT6aZCnU+3ZS5t4qa/tVhT5PPixfvjweffTReOSRR+K5557Lyhz5Vc2hhx4ap512WtqyGTNmpO27NmvWLO6///44+OCDs51exsybNy9GjRoVXbt2LRVv0qRJtG/fPsaMGVPmurVr144DDzywVGz69Onx9ttvl4qNGDEizjzzzFKxrl27xj333LPa3Lp165YSW7hwYbl+X6JQxhaZmCMvX/NNdu3aNYYOHRp169Ytc5kGDRrEXXfdFUcffXRG2y7Ue2hSFVL/OAkK5foRUXjPJir7XMK5nX1V6fhdG0kZ46xOEp8l5irn6vSbpIV4HBTy51pV4dxfW4W8P9akOv62XEUV0nUpSQrlM+GqfGwCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUDXUzHcCAAAAAAAAAAAAAAAAkG0LFizIWF0rV67MWxuFZt68eRmvMynvPVP7uyocTxtuuGHsuuuuscMOO0SbNm2iVatW0bp169hwww2jqKgoq21Tvbf/Ouusk/Y91qtXLxYtWpTx9srannXq1KlUvYV2LV1nnXWiuLi4VGzJkiWxZMmSyqaVcffee29cccUVUbNm6T+XPeGEE+L8888v13Zo2LBhdO3aNSX+xBNPxI8//pixXPMlCdeIQjwH0m2bJUuWxNKlSyuT1mplYzskwfjx4+Oiiy6KW2+9NaVsvfXWi0MOOSQef/zxjLY5atSoOProo2PFihVlLnPeeedFx44dY/PNN08pu/XWW+OVV16Jb775JqN55cqsWbMyVleS7sX/+te/4ogjjojf/e53ZS6z0UYbxUYbbRRHHHFEqfiCBQvi888/j88++yw+++yzmDx5crz//vsxceLESt0f69WrFzVq1EiJL1myJBYvXlzhetdkzpw5aeMNGzbMWpvkT1U7zgqt35BrSejbkR+NGjWKa6+9Nvr27ZsynktnzJgxcfHFF8frr7+e0TxWd1+sVatWRtsqS+3atcssK8RxbT5ksj9YHkm4dlWnzw+qUh8+1/33XMvmc6kffvghbbxBgwZlrpOkY2d1cn0NrKhCG8MmZf+ne7Ydkf/n21VtXBZReGMzz3QBAAAAyIRfP1Nr3rx5njJJb/DgwdGyZcuIiCgpKYlevXrFlClTKlXnrz8byMYz34rIxnsFAAAAAAAAAAAAku37zyI+fS1iq30qtn7JyohXB2Y2pyTZe++9Y6uttkqJT5w4Md59991K13/33XfHIYcckhLv2rVrbLDBBvHdd9+tVX2FOn9AVXfffffFlVdemTJf1EknnRTXXHNNuero06dPSmzhwoXx0EMPZSTHtVVoc3hkSlWby6LQ5rGoSr788ss4+uijo2fPnnHvvfemPW5uvfXWeOGFF7J67OTbBRdcEJ07d05bduWVV8bLL79c5fNIwnxwuZgz2Xw0ha3Q7ttJmXvrZ9V97r5vv/12refva9SoUWy44YYp8Ro1asT111+fkbFSddC8efMYODD9gPv777+PnXfeOYYPHx677757Snnnzp3jzDPPTPsbBYVq6NChaX/bpFu3bjFmzJgy1zvggAOifv36pWJPP/10lJSUlIqNGDEizjzzzFKxjh07Rp06dco8J4uKitLm9Oyzz67xelVIY4tMzJGXj/km+/TpE3fffXfa7fhr3bt3j5NOOqnMc6aiCu0emgRJ6B8XukK6fkQU3rOJTDyXcG5nT1U7fssraWOcsiTxWWLSck7CfbLQtmkhf65VVc79tVHI+6M8qutvy61OEq5LSVIInwlXlWMTAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgKqtZr4TAAAAAAAAAAAAAAAAgGxbtmxZ1ttYunRp1tsoNLnYroUq2++90I+nbbfdNnr16hXHHHNMbLrppvlOp9qx/X9Sv379Msvq1q2bw0wqp9Cupem2648//piHTNZs2rRp8eyzz8Zhhx1WKt6iRYvo1KlTjBw5co11HHnkkWmPl4EDB2Ysz1xL2jUiCedARPbPgwULFmS1/kJ2xx13xOmnnx7bbLNNStlRRx0Vjz/+eMbaeu2116Jbt25rPO4WLFgQvXv3jldeeSWKiopKla277rpx3333xYEHHpixvHJp7ty5GasrSffipUuXxuGHHx6jR4+OnXfeea3WrV+/fuywww6xww47lIovX748Xn311XjwwQdjyJAhsWjRorWuN51sX2/mzJmTNt6oUaOstkt+VLXjrND6DbmQtL4dubfddtvF448/Hm3btl3jsm+//XZcfPHF8cILL2QllyVLlpRZlqu+Qb169cosW11+1Ukm+4NlSdq1qzp9flAd+vDZ6r/n2sKFC7NWd1nXgQYNGpS5TpKOndXJxTUwEwptDJuU/Z+v8c+aVLVxWUThjc080wUAAAAgE6ZOnRolJSWrvi+24447RpMmTWL27Nl5ziziwgsvjE6dOq16fcMNN8QzzzxT6Xp//dlAIXx+kq33CgAAAAAAAAAAACTf87dENG8d0aTl2q/76sCIaZMyn1NS9OvXL2387rvvzkj9Tz/9dEyfPj2aN29eKl6zZs046aST4qqrrlqr+gp1/oCqbvr06fHUU0/FkUceWSretm3b2GuvveLNN99c7foNGzaMI444IiX+yCOPxLx58zKaa3kV2hwemVLV5rIotHksqqJBgwZFw4YN47bbbksp23TTTaN79+4xaNCgPGSWfb/97W/jyiuvTFv26quvxt/+9rcqm0fS5oPLxZzJ5qMpbIV2307K3Fs/q+5z95177rkxdOjQtVpnvfXWiy+++CIaN25cKl5UVBQ33XRT7L333hnMsOq6//77o1mzZmnL+vTpE999910cf/zxMWHChLTn1XXXXRcvv/xyfPTRR9lONSNGjBgRS5cujdq1a5eKH3744XHeeeeVuV7Xrl1TYsOHD0+JvfLKKzFv3rxo2LDhqtg666wT++23Xzz//PNp695zzz1j/fXXT4mX55wopLFFJubIy8d8k2v7uzb/+te/YuzYsfHpp59mLIdCu4cWqqT1jwtdIV0/IqrmswnndvZUteO3vJI2xilLIZ6va5KEnJN2nyy0bVrIn2tVlXN/bRTy/iiP6vrbcr+WtOtSkhTCZ8JJPjYBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqD6K850AAAAAAAAAAAAAAAAAVAUlJSX5ToEqpFCPp0033TQeeuih+OCDD+L888+PTTfdNN8pVSu2f2lFRUX5TqFKSrddV6xYkYdMyqd///5p47179y7X+j169EiJff311/HSSy9VJq28cI3IjLKuLdk+D5YvX57V+gvZypUrY9CgQWnLdtttt4y1884778QhhxwSixYtKtfyY8aMiVtuuSVtWYcOHeLMM8/MWG659OOPP2asrqTdi2fNmhV77bVX3H777Rk5p2vWrBkdOnSIgQMHxmeffRZ9+vRZq/WLi9NP95Dt601Z9Sdtf1I+jrPk0rejPA466KAYN25ctG3bdrXLvf/++9G1a9fYY4894oUXXshaPvPmzSuzrEmTJllrtzztLFmypKDHtrmUyf7gr7l2la1Qnvcm7V6cyT58ZfvvuZbNY6YifbWkHTtlyeY1MNMKaQyblP2fr+d6a2Jcln2e6QIAAACQCXPmzImPPvpo1euaNWvGFVdckceMftK+ffu48sorV71+880348ILL8xI3Q0aNCj1urzfrcuWbL5XAAAAAAAAAAAAIPmWzI949JKI2d+s3Xrjhka8/Wh2ckqCJk2axO9///uU+JIlS+LBBx/MSBvLly+PBx54IG1Z37591/rv3At1/oDqoKx5fsszT0X37t1jnXXWKXeduVJIc3hkirksqIjbb789xo0bl7bspJNOynE2ubHeeuvFkCFDombNmillM2bMiOOOOy5WrlxZ5fJI6nxwuZgz2Xw0ha+Q7ttJvL/9vP3yve2SYs6cOWX+DWH79u3TjqMo7cwzz4zOnTunLbvtttti5MiRERHx2Wefxdlnn512ubp168bDDz8ctWvXzlqemfTjjz/GqFGjUuKtWrWKbbfdtsz1Dj300FKvFy9eHKNHj05ZbtmyZfHcc8+lxLt27Vpm3d26dUuJLVq0KJ599tky1/lZIY0tMnHdLZT5Jl988cU47LDD0vbx1llnnXjkkUcyfswX0j200CS1f1zoCun6EZHMvlt5OLezo7oev1X1PKFy3Cczo5A/16qO534h74/yqM6/LRfhupQr+f5MOInHJgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADVT/pfPwQAAAAAAAAAAAAAAACAXzjwwANjwoQJcdxxx0VRUVGF6pg9e3aMGzcuBg8eHJdeemkce+yxseuuu8Zbb72V4WyrHtsf0hs5cmR88803KfHDDz88GjduvNp1W7RoEQcccEBK/P7774+SkpJMpZgTrhEk3YgRI9LG27RpE+uss06l6//ggw+iU6dOMX/+/LVa78ILL4xJkyalLfvHP/4RW2yxRaVzy7WkXd8ybcmSJXHGGWfENttsE/fdd1/8+OOPGal3ww03jIEDB8ZDDz0UderUyUidQPWlb0d57L///vHkk0+utq/0n//8J7p37x477bRTPP3001nPacGCBbFw4cK0Zeuvv37W24+IaN68edr4tGnTctJ+EmSrP+jaRbZkow+v/159JW1MbAwLAAAAAJBb9913X6nXZ5xxRvz973+PGjVq5CWfpk2bxpAhQ1a1P3v27Dj66KNjxYoVGam/QYMGpV4vWrQopbx169ax4447xo477hitW7eOunXrZqTtX8v2ewUAAAAAAAAAAACqhh++ixh0TsTHL0esaQqB+bMjnvrfiFcH5iS1gnXiiSemnVvgnXfeibZt20a7du0y8u+DDz5I2/4mm2wSnTt3zvbbJENGjRoVX331VUr8mGOOiXr16q123T59+qTEPvroo4KYP8gcHvCTO+64I218r732ilq1auU4m+x74IEHYuONN06Jl5SURI8ePeK7776rcnkkeT64pM0PRfa4b1fOkiVLbLu1cOutt8bnn3+etuy6666L2rVr5zij5Nh2223juuuuS1v2ySefxJ/+9KdSsXvuuSeeeOKJtMtvv/32cc0112Q8x2wZOnRo2ni3bt3SxnfYYYfYZJNNSsVefPHFlL/p/Fm632zo2rVrmfkcfvjhKbGRI0fGggULylynqiqE/sQjjzwSBx98cDz11FNlniM77rhj/OMf/8h42+6hqZLcP4afObeBbHGfhMJUCOOafHFdyp2q+pkwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGRSzXwnAAAAAAAAAAAAAAAAAEBhO/jgg+Opp56KGjVqrHHZ+fPnx6RJk2LSpEkxefLkUv+dM2dO2nUWL16c6ZSrFNs/vZKSkrTxH374IYYMGZKzPGbNmpWztnJh5cqVKbGaNQv3z1FXrlwZ9957b1x66aWl4nXq1Iljjjkm7rrrrjLXPfbYY6O4uLhUrKSkJO69996s5JotrhGZtWLFirTxWrVqZbXdbNdf6CZPnhwlJSVRVFRUKl5UVBS/+c1vYuHChZWq/6qrrirzGF+dxYsXR69evWLs2LEp51i9evVi8ODBsddee5V53FR1Sb4XT5o0Kfr06ROnnnpq7LfffrH77rvHrrvuGltttVW0atUq6tSpU6FcjjvuuGjYsGF07dp1jcuWddxk+75b1vWmKh7Hv76mVEeOs+TRt6M8WrVqFcOHD4969eqlLZ89e3Zccsklcdddd6Ud42XTtGnTolWrVinxzTffPCftp2s74qe8yB7XruSoSn34fv365bT/nmu1atWKZcuWZaXu2rVrp42vrq+W5GOnKsj3GDYp+7+sfk++n28bl2WfZ7oAAAAAZMqdd94ZZ5xxRqnPNy+55JLo3r173H777fHMM8/E559/nrN8Bg8eHC1btoyIn57V9uzZM7755puM1V+/fv1V/79s2bKoWbNmHHnkkXH44YdH+/btY6ONNkpZp6SkJL744ot48cUXY9CgQfH6669nJJdsv1cAAAAAAAAAAACg6lgyP+LpayPefjRimwMiNts5omHTiFp1Ixb+EDHjy4jP3or4+MWIZUvynW3+nXrqqWnj7du3j3HjxuUkh9NOOy1GjhxZ7uULdf6A6qCkpCTuueeeuOKKK0rFGzVqFEcccUQ89NBDaddr1apVtG/fPiXev3//rORZUfmewyNTzGVBRT377LNp43Xq1Iltttkm3n///RxnlD3nnXdeHHrooWnLrr322hg1alSVy8N8cP/HfDS5la35f/N9307K3Fvp5HvbJcmyZcviggsuiEcffTSlbPPNN4+zzz47rrvuujxkVthq164dDz/8cNStWzelbOnSpXHcccelvW+cfPLJsccee8SGG26YUnbOOefEyJEjY/To0VnJOZOGDx8eS5cuTZnXsVu3bnHVVVelLJ+uLzB8+PAy63/22WdjxYoVpe7pm2yySWy77bbx0UcflVp2yy23jC233DKljmHDhq3xfUQU1tiiKowrbr311vjjH/+46h5yySWXRIcOHWK33XZLWfbss8+OUaNGldlHrwz3gZ/oH2dXIV0/IqrGNWRNnNuZU12P3ySPccg898nMKuTPtarjuV/I+yPXkrT/XZdyK9+fCSfp2AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACg+qp+v34FAAAAAAAAAAAAAAAAQLltttlm8dBDD0WNGjXSls+aNSsee+yxGD16dLzzzjvx1VdfrXUbRUVFlU2zyrL9y7Z48eK08fnz58dpp52W42yqjnTbdd11181DJuU3YMCAuPjii6O4uLhUvHfv3nHXXXeVuV6PHj1SYmPGjIn//ve/Gc8xW1wjMm/BggVp49k+D+rXr5/V+gvdsmXLYvbs2fGb3/wmpWzdddeNKVOmVKr+kpKSCq87bty4uO666+LCCy9MKdt9993jL3/5S1x55ZWVSS+xqsK9eOnSpTFq1KgYNWrUqlhRUVFstNFG0aZNm2jTpk20bdt21f+3adMm6tWrt9o6Dz300Ljooovi6quvXu1y8+fPTxtv3LjxWr+PtdGkSZO08R9//DGr7ebDmvZVdeA4SxZ9O8qjRo0a8fDDD0fDhg3Tlr/77rvRrVu3+Oabb3Kc2U8mTZoUrVq1SolvvfXWOWm/rHYmT56ck/arI9euZKmKffhc9d9zbd11142ZM2dmpe6y+oJl9R0jqsaxUxXkawyblP1fVp75fr5tXJZ9nukCAAAAkCkLFiyII488Ml5++eVSz/C23HLLuPnmm+Pmm2+O2bNnl/o8doMNNogWLVrEtGnTMprLhRdeGJ06dVr1+rrrrotnn302o200aNBg1f8XFxfHlClTonnz5qtdp6ioKFq3bh2tW7eOvn37xltvvRVnnHFGjB8/vsJ55OK9AgAAAAAAAAAAAFXP9M9/+kfZ9t1339hyyy3znUYccsghsdFGG5V7XqRCnT+guhg4cGBcfvnlKXMK9enTJx566KG06/Tu3TsltmTJkhg0aFA2Uqy0fM5DmQnmsqCiZsyYEYsXL466deumlDVr1iwPGWVHu3bt4pprrklb9sYbb8Qll1xS5fIwH1xp5qPJrWzP/2vurYpLep8nVx577LEYO3Zs/O53v0spu+SSS+K+++6LGTNm5CGzwnXttdfG9ttvn7bsoosuivfffz9t2ezZs+PEE0+MUaNGpdxXioqK4v7774/tt98+Zs2alfGcM+nHH3+M0aNHR5cuXUrFd91119hwww3j22+/LRU/7LDDSr0uKSmJp59+usz6Z8+eHWPHjo199tmnVLxr167x0UcflYodfvjhKesvXrx4tfX/UiGNLZI+rrjooovif//3f0vFli9fHscdd1xMmDAhbT/hvvvuix122CHjf6P8s+p8H9A/zr5Cun5EJP8asjaq87mdKdX1+K0KYxwyw30y8wr5c63qeO4X8v7ItaTsf9el/MjnZ8JJOTYBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqN5q5jsBAAAAAAAAAAAAAAAAAArX1VdfHY0bN06Jz58/P/7yl79E//79Y+nSpZVqo0GDBpVavyqz/cu2cOHCKCkpiaKiolLxJk2a5CmjqiHddq1Vq1bUq1cvFi1alMfMyvb111/H6NGjo1OnTqXie+65Z2yxxRYxadKklHW22GKL2HXXXVPiAwcOzFqe2eAakXmLFy+OlStXRnFxcal4zZo1Y5111omFCxdmpd111103K/Umyfz58+M3v/lNSrx27dp5yKa0yy67LA499NDYbrvtUsouv/zyePbZZ2P8+PF5yCy/quq9uKSkJKZMmRJTpkyJl19+uVRZUVFRtG3bNjp37hz9+vWLrbfeOm0df/nLX+LOO++M2bNnl9nOkiVLYvny5VGzZulpH2rWrBn169ePBQsWVP7NpLHeeuuljc+bNy8r7a2NGjVqZLS+hg0bZrS+JHKcJYu+HeXRr1+/aNeuXdqycePGxQEHHJC1Pmt5fPzxx9G5c+eU+G677ZaT9stq56OPPspJ+9WRa1eyVMU+fK7677nWuHHjmDlzZtbqTmf+/PllrlMVj52qIhfnQFL2f1l55vv5tnFZ9nmmCwAAAEAmTZgwIfbYY48YNmxY7LDDDinlTZo0KfV89IQTTogTTjghfvzxxxg/fnyMGzcuRowYEW+88UaFc2jfvn1ceeWVq16/8cYbcdFFF1W4vrLUr19/1f/XqFEjmjdvvtZ17LnnnvHWW2/FWWedFXfddddar5+r9woAAAAAAAAAAABQHfXr1y/fKUTET99VPfnkk+Ovf/1ruZYv1PkDqoupU6fGyJEj49BDDy0V79ChQ2y88cYxZcqUlHV69eqVEnvsscdizpw5Wcsz05I0j425LKiMGTNmxMYbb5wSL2teoqRZd91145FHHolatWqllM2ePTuOOeaYWLFiRZXLw3xwpZmPZvWqwvy/5t6quCT1eXLp3HPPjXHjxqXs70aNGsXf//73ghlbFYKDDjoozj777LRlL730Utxwww2rXf+FF16Im2++Oc4555yUsg022CDuueee6NatWwYyza6hQ4dGly5dSsWKiorisMMOizvvvHNVrFmzZinzCL/77rvx3Xffrbb+ESNGxD777FMq1rVr17jmmmtKxdJtq+eff361c0v+UiGNLZI6rlixYkX07du3zN+5+eyzz+Kss85KW96sWbMYNGhQdOzYMdtprlJd7gP6x9lXSNePiOReQzKlupzbmVJdj9+qOsZh7blPZl4hf65VHc/9Qt4fuZaU/e+6lB/5/Ew4KccmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANVbcb4TAAAAAAAAAAAAAAAAAKAwbbbZZnHMMcekxJcsWRIHHnhg3HrrrbF06dJKt9O0adNK11EV2f6rt2LFipgxY0ZKfJ111om6devmIaOqYeXKlfH999+nxNdff/08ZFN+/fv3Txvv3bt32niPHj1SYvPmzYtHH300k2lllWtE9qQ7ByKydx7UrVs3WrRokZW6k6RmzZpp4ytXrsxxJqmWLVsWPXv2jGXLlqWU1axZMwYPHhx16tTJQ2b5VR3vxSUlJTFp0qS45ZZbYtttt42//e1vaZdr0KBBnHzyyWusb+rUqWnj2bwmlFX3tGnTstbmr61YsSJtvGHDhhltZ+ONN85ofUlVXY+zpNG3ozzq1q0bF198cdqy77//Prp06RILFy7McValvfvuu2nju+yySzRo0CCrbTds2DB22mmntGXvvfdeVtuurly7kqe69eEz3X/PpWw+iyur7pkzZ5a5TnU7dqqKTJ0DSdn/ZT3bjsj/823jsuzzTBcAAACATJo0aVLstNNOceKJJ8Ybb7xRrnUaNWoU++23X1xwwQUxduzY+Pzzz9N+V3VNmjZtGkOGDIkaNWpERMSsWbPimGOOKfP7NpWR7jPc7777LgYPHhxnn312/P73v48DDzwwOnbsGEcddVScf/758eSTT8bixYtLrVOrVq24884745RTTlmr9nP5XgEAAAAAAAAAAACqm6ZNm8aRRx6Z7zRWOfnkk6O4uLhcyxby/AHVRbp5fouKiqJXr14p8f333z823XTTctWRVIU4j425LKiosr6zX95rdKG79957Y7PNNktbduKJJ8Y333xT5fIwH1x65qOpvvP/Vre5tzKpEPs8ufLOO+/EkCFD0padfPLJse222+Y4o8L0m9/8Ju6///4oKipKKZszZ07a8UI6F1xwQUycODFt2eGHH77Wf6uYD8OHD097f+3WrVup1126dEnZXsOHD19j/SNGjEiJ7bnnnvGb3/xm1ev1118/9txzz5Tlhg4dusb6f6lQxhZJHVcceeSRMXDgwNUuc++995b5OzgHHnhg/PnPf85GamutqtwH9I9zp1CuHxHJvYbkQlU5tzOtOh6/1XGMQyr3yewo5M+1quO5X8j7I9eSsP9dl/IrX58JJ+HYBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDifCcAAAAAAAAAAAAAAAAAQGE65JBDorg49c/Qbr/99hg3blxG2iguLo7mzZtnpK6qxvZfs6+//jptfLvttstxJlXLV199lRLbdddd85BJ+Y0YMSK+//77lHjPnj2jqKgoJX788cenxIYOHRoLFy7MSn7Z4BqRPZMmTUob32233bLS3hZbbJH2OK1umjVrlja+YMGCHGeS3oQJE+LKK69MW7b11lvH1VdfneOMCkN1vheXlJTEX//617j99tvTlnfq1GmNdXz88cdp43vssUelcluddu3apY1/9NFHWWvz1+bMmZM23qhRo4y2s+WWW2a0vqSqrsdZ0ujbUR7HHXdcbLDBBmnLzjnnnJg1a1aOM0r16quvpo3XqlUrOnbsmNW2O3XqFLVq1UqJr1ixIsaOHZvVtqsr165kqq59+Ez033MpW88gWrZsGeuvv35KfNmyZfHf//53tetW12OnqqjsOZCU/Z/u2XZE/p9vG5dln2e6AAAAAGRaSUlJPPDAA/G73/0uNtpoozjqqKPiuuuui+effz6mTZu2xvVbtWoVgwYNilGjRq3Vd2IGDx4cLVu2XJVDz54945tvvqnw+1idSy65JN57772I+Omz3oMOOihatmwZPXv2jFtuuSUef/zxePHFF+OFF16Ixx57LK677ro44ogjomXLlvGPf/wjVqxYUaq+W2+9NXbYYYdyt5/L9woAAAAAAAAAAABQ3Zx44olRu3btfKexSsuWLaNLly7lXr5Q5w+oLp555pn49ttvU+J9+vRJifXu3TslNnny5DLno0q6QpnHxlwWVFS6udoiIlauXJnjTDLvrLPOiiOOOCJt2Y033hhPP/10lczDfHDpmY/G/L8R1WfurWwolD5PLl144YWxePHilHiNGjXixhtvzENGheeee+6JFi1apC3r27dvTJ06tVz1LF26NI4//vi02zsi4qabbootttiiwnnmwty5c+OFF15Iie+///7RsGHDVa8PO+ywlGVGjBixxvonT54cn376aalYcXFxHHzwwated+3aNeXes2TJknjqqafWWP8vFcrYIqnjivLsz4iIU045JaZMmZK27KqrrspaH6Wiknwf0D/OnUK5fkQk9xqSa0k+tzOtuh6/1XmMw0/cJ7OnkD/Xqo7nfiHvj1wr9P3vupRf+fxMuNCPTQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABI/YUlAAAAAAAAAAAAAAAAAIiIffbZJ218yJAhGWtj1113jXr16mWsvqrE9l+zDz74IG18jz32yHEmVcuECRNSYnvttVfuE1kLy5cvj/vvvz8lvtFGG8UBBxxQKrbHHntE69atU5YdOHBg1vLLBteI7Pn000/TxrN1Huy7775ZqTdJmjdvHrVr105bNnPmzBxnU7arrroq3n333bRl5557brXcl+7FEZdddlksX748Jb777ruvcd0PP/wwbbx9+/aVziudLbfcMn7zm9+kxJcsWRKff/55VtpMZ86cOWnjm2++eUbbqY7nZDrV9ThLGn07yuOYY45JG588eXJGj5XKmDp1apn96Z49e2a17V69eqWNv/322zF//vystl1duXYlU3Xvw1em/55L2XoGseeee6aNf/7557Fy5crVrlvdj52qoqLnQFL2f7pn2xH5f75tXJZ9nukCAAAAkE1Tp06Nxx57LM4///zo3LlzdOnSZVXZyy+/HNdff32MGjUq5s6dm7Jux44d48UXXyzz+3G/dOGFF0anTp1Wvf7HP/4RI0eOzMybSOPpp5+OXXbZJbbZZpvYb7/9YvTo0VFSUrLG9WbPnh0XXHBBdO7cORYvXrwqXrt27bjhhhvK1Xau3ysAAAAAAAAAAABAdXPqqaemjffo0SPq1KmT1X9vvPFG2rb79etX7vwLdf6A6mLlypVx7733psRbt25daq6E+vXrx+9///uU5e6+++6s5lcI8j2PjbksqKhmzZqljSd9rrZddtklrr/++rRl77zzTpx//vlVNg/zwaVnPhrz//5SVZ97K5vy3efJpa+//jpuuummtGUdO3aMQw45JLcJFZhTTjklDj/88LRl999/fzz66KNrVd9HH30UF1xwQdqyddZZJx566KGoWbPmWueZS0OHDk2J1a5dOzp37rzq/zt27FiqfMqUKTFx4sRy1f/UU0+lxLp27brq/7t165ZSPmrUqJg3b1656v9ZIYwtqsO44ocffogePXqknfezVq1aMWTIkGjQoEEeMlu9JN4H9I9zpxCuHxHV4xqSaUk8tzOtuh6/xji4T2ZPIX+uVR3P/ULeH7lW6PvfdSm/8vmZcKEfmwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQnO8EAAAAAAAAAAAAAAAAAChMG2ywQdr4J598krE2DjjggIzVVdVUte1fo0aNjNf59ttvp43vt99+GW+rOhk3blxK7JBDDslDJmvn7rvvThvv3bt3qdc9evRIWWby5MnxxhtvZCOtrKlq14hC8tprr6WNH3zwwVlpr2vXrlmpN0kOOuigtPE5c+bEnDlzcpxN2VasWBG9evWKJUuWpJQVFRXF/fffHw0bNsxDZvnjXhwxa9asmDBhQkq8YcOGUbt27dWuO3r06LTxQw89NCt9p27duqWNv/rqq7FixYqMt1eW2bNnp43vsssuGWujZs2aZV5bsiUb+ywTqutxljRVqW9XqOdC0jVs2DA6dOiQtmzAgAE5zmb1hg0bljbetWvX2HTTTbPSZqtWrcoctz7yyCNZaZOqde2qTqp7H74y/fdcOuCAA7KST1nXytdff32N61b3Y6eqqOg5kJT9n+7ZdkT+n28bl2WfZ7oAAAAA5Mu7774bf/7zn6NTp07RtGnT6Nq1a7zzzjulltltt93i6quvXm097du3jyuvvHLV67Fjx8bFF1+clZx/raKf773wwgtx2mmnlYodeOCBseWWW652vXy+VwAAAAAAAAAAAIDqYP/994+2bdumxGfPnh3Dhg2LpUuXZvVfWXMide7cOTbZZJNyvYdCnT+gIpI6L9fdd98dJSUlKfE+ffqs+v/u3btH/fr1S5UvW7Ys7rvvvmynl3f5nsfGXBZUxGabbVbm8Tl16tQcZ5M5DRs2jGHDhqV9b3Pnzo2jjz46li9fXmXzMB9ceuajqbrz/1ZEVZ97K5vy3efJtauvvjqmT5+etuyGG25IbN++srbYYou46aab0pZ98cUXceaZZ1ao3ltuuSWef/75tGW77rpr/P3vf69Qvbny5JNPxtKlS1PiP/ed99tvv2jQoEGpshEjRpS7/uHDh6fEOnfuHDVr1oz69evHgQcemFJe1pzAq1MIY4vqMq4YM2ZMXHvttWnLWrduHbfffnuOM1qzXNwHMn2cVbX+cSHfewrh+hFRfa4hmZS0Pl42jqfqevwa41DV7pOFpJA/16qO534h749cK/T9X9WuS4Xcfy9Lvj4TLvRjEwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACK850AAAAAAAAAAAAAAAAAAIVpvfXWSxtfvHhxRuovLi6OU045JSN1VUVJ3f4LFixIG2/YsGHG2xo1alTa+GGHHRbNmjXLeHvVxXPPPZcS23rrraNDhw55yKb8Pvvss3jllVdS4kceeWQ0aNAgIiJq1KgRRx99dMoyAwcOzHZ6GZfUa0QSjB49Om18q622igMPPDCjbbVq1SrjdWZaq1atokuXLlltI915GRExbty4rLZbER9//HFceumlacs23XTTuPnmm3OcUX4l7V7cokWLrNT77bffpo03btx4teu9+uqraftOG2+8cRx11FGZSG2VWrVqxR//+Me0ZSNGjMhoW2vy8ccfp423aNEi2rRpk5E2fv/732ftGMxlfzcTqutxljRJ7Nsl7VxIuh133DFq1qyZtmzkyJE5zmb1Bg8eHCUlJSnxmjVrxuWXX56VNv/6179GjRo1UuLLly+PoUOHZqVNknntQh8+ouL991xq1qxZHHvssRmts2nTpnH88cenLUv3PPDXknbsVAWFNIZNyv4v61jO9/Nt47Ls80wXAAAAgEKwfPnyePrpp2PPPfeMO++8s1TZGWecEc2bN0+73m9+85sYMmTIqs88Z86cGcccc0ysWLEi6zlX1n333RcffPBBqdhhhx1W5vJJfq8AAAAAAAAAAAAASdGvX7+08QcffDCWLl2a9fYfeeSRmD9/fkq8uLg4+vbtW646CnX+gNWpavNyffXVV/HCCy+kxI8++uhYZ511IiKid+/eKeUjRoyIGTNmZDu9tVJIc3hkirksqIgjjjgibXzZsmUxefLkHGeTOffcc0+0atUqbdlJJ50UX375ZZXOw3xw6ZmPJrnz/xbSfTspc2/9UnWduy9T5s2bV+a8qVtttVWcdtppOc4o/2rWrBkPPfTQqjHAL61YsSJOOOGEtOO/8jrxxBNj5syZacvOP//82HfffStcd7bNnTs37ZipS5cuUbNmzejatWtK2fDhw8td/xtvvBGzZs0qFWvUqFG0b98+OnXqFHXq1ClVtnTp0gr1zwthbFGdxhWXXnppvPPOO2nLevbsGSeccEKF6y6ke2g6uXpuktT+cRKfKxXC9SOi6l9DCv3czqRcngfV9fhN4hiHzErqfTIJCvlzrep47hfy/si1Qt//Sb0uJbH/XpZ8fSZc6McmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABTnOwEAAAAAAAAAAAAAAAAACtO8efPSxps1a5aR+o877rho3bp1RuqqipK6/efMmZM2vummm2a8rS+++CI++OCDlHjt2rXjlFNOyWhb6667brRo0SKjdRaq7777LsaOHZsS/8tf/pLRdvr27Rs77rhjRuu8++67U2LrrLNOdO/ePSIiOnbsGM2bNy9VvnLlynjggQcymkcuJPUakQTff/99vPHGG2nLLrroooy29fe//z2KiooyWmembLvttvHggw/GpEmT4sEHH4z11lsvK+20b98+unbtmrZs1KhRWWmzsq6//vp4880305b16dMnDjvssBxnlD9JuRdvtNFGcccdd8RXX30Vhx9+eEbzivjp/aazaNGi1a63dOnSeOSRR9KWXXzxxVGrVq1K5/azvn37xoYbbpgSX7JkSQwbNixj7ZTHpEmTYtasWWnLevfuXen6a9asGX/9618rXU9ZctnfzYTqepwlTRL7dkk7F5Jup512ShtfsGBB2ntxPn366afx/PPPpy3r3bt37LPPPhltb//994+ePXumLRs6dGh89913GW2P/5PEaxf68BEV77/n2p/+9KeoUaNGxuo777zzom7duinxBQsWlGv8nZRjpyooxDFsUvZ/Wc+2I/L7fNu4LPs80wUAAACgkKxcuTLOOOOMePfdd1fF6tatG0ceeWTa5R988MFo2bJlRESUlJREz549Y+rUqTnJNRN+/exxl112KXPZpL9XAAAAAAAAAAAAgELXtGnT6NatW9qyAQMG5CSHhQsXxpAhQ9KW/eEPfyjXfBqFOn/A6lTFebn69++fEmvQoEH8/ve/j8033zztfFLp1smXQpzDI1PMZcHaatCgQfzP//xP2rK33norFi9enOOMMqNfv36r5h7/tdtuuy0ef/zxKp+H+eDSMx9N8ub/LcT7dlLm3ooovf0yLSlz92VK//794+OPP05b9re//S0aN26c24Ty7Morr4xdd921zLK33nqrUvV///338Yc//CFtWXFxcQwePLigt/nQoUNTYuuuu27su+++Kb+9MG/evHjllVfKXffKlSvj2WefTYl37do17bj/hRdeiLlz55a7/p/le2xR3cYVK1asiOOOOy7mz5+ftvyOO+6IVq1arVWdhXgPTSdXz02S2j9O4nOlfF8/Iqr2NSQp53Ym5fI8qK7Hb5LGOGRHUu+TSVDIn2tVx3O/kPdHrhX6/k/qdSmJ/ffVycdnwoV+bAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAcb4TAAAAAAAAAAAAAAAAAKAwzZw5M218r732qnTdLVu2jBtvvLHS9VRlSd3+U6dOTRtv27ZtrL/++hlv7+67704bv/jii6Nt27YZa+fGG2+MTz/9NP74xz9GcXHV//PMO++8MyXWoUOHOPvsszNS/2677RZ33HFHTJgwIZ566qlo165dRup97LHHYvbs2Snx3r17R0REjx49UspGjRoV3377bUbaz6WkXiOS4rbbbksb33///eN//ud/MtJG586d4/jjj89IXZm07bbbxpNPPhkffPBBHH/88VGjRo1Yd91145577sl4W40bN47+/funLVuxYkUMGTIk421mQklJSfTq1SsWLlyYtvzuu++Opk2b5jir/Cnke/FGG20Ut99+e3z++efRr1+/qF27dtxyyy3RpEmTjOUVEdGmTZuU2MKFC2PevHlrXPf666+PkpKSlPj2228fN910UybSi5133jmuv/76tGUPPPBATJ8+PSPtrI033ngjbfyUU06Jxo0bV6ruiy66KLbaaqtK1bE6ue7vZkJ1Pc6SJIl9uySeC0m22WabpY1PmjQpt4mU01VXXZU2XlRUFA8//HBssMEGGWmnZcuW8fDDD6ctW7lyZVx77bUZaYf0knjt4ifVvQ9fmf57Lm2//fZx3XXXZaSufffdN84///y0ZYMGDSr3ey/kY6cqKPQxbFL2f7pn2xH5f75tXJZ91fmZLgAAAACFZ+XKlSnP/vbdd9+U5S688MLo1KnTqtfPP/98LFy4MPbZZ59y/9tpp51K1bnhhhumLFPZ7+Oszscff1zqdYsWLdIuVxXeKwAAAAAAAAAAAECh69OnT9SuXTsl/u9//zsmTpyYszwGDBiQNt6iRYs47LDDylVHoc4fUJaqOC/Xk08+mXaugj59+sSJJ54YRUVFpeJfffVVjB49OlfplanQ5/DIFHNZUF7FxcVx9913R8uWLdOWP/TQQznOKDN23HHHMo/1CRMmxHnnnVct8jAfXNnMR5OM+X8L/b5d6HNvpdt+hbLtkmrlypXxpz/9KW1ZkyZN4vLLL89xRvmz7777xp///Oe0ZW+99Vb8/e9/z0g7I0aMKPO3CjbaaKMyywrBk08+GcuWLUuJX3rppbHpppuWij3//PNpl12d4cOHp8QOP/zwOPTQQ1Piw4YNW6u6fymfY4vqOK74/PPP48wzz0xb1rBhwxgyZEjUrFlzjfUU+j3013L13CSp/eOkPlfybCLzknZuZ1Kuz4PqevwW+hiH7ErqfTIpCvlzrep47hfy/si1Qt7/Sb0uJbX/XpZ8fSZcyMcmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPjFGwAAAAAAAAAAAAAAAADSmjRpUtr4qaeeWql611lnnXj00UejWbNmlaqnqkvq9p86dWp88803actOP/30jLd3zz33xIwZM1Li66yzTjz44INRv379Srdx8sknR58+faJRo0Zx8803x/jx42OvvfaqdL2F7OGHH47JkyenxK+77ro45JBDKlV3ixYtYtiwYVFc/NOfuR566KExbty4GD16dDRv3rxSdS9ZsiQGDx6cEt97771ju+22i27duqWUDRw4cK3aqFWrVvzrX/8q81+uJPUakRTDhg2Lr7/+Om3ZNddcE127dq1U/dtss0089NBDlaojWxo3bhyHH354FBUVlYofccQRcdNNN2Wsnfr168ezzz4bW2+9ddryhx56KL777ruMtZdpn332WVxwwQVpy5o3bx533313jjPKn0K+F995551x2mmnRe3atVfFNtlkkxg2bFjUq1ev0nlFRLRr1y7atGmTEi+rP/Rrn3zySQwdOjRt2emnnx7nnntupfJr27ZtPPHEE1G3bt2UssWLF8c111xTqforqqz33Lx587jxxhsrXO/hhx8el19+eYXXL49c93czoboeZ0mSxL5dEs+FJGvUqFHa+NSpU3OcSfm8/vrr8eijj6Yt23DDDePll1+Oli1bVqqNjTfeOF5++eVYf/3105bfe++9MXHixEq1weol8drFT6pzH76y/fdcO/fcc+OUU06pVB1bb711DBkyJGrUqJFStnz58rUa6xfysVMVFPoYNin7v6xn2xH5fb5tXJZ91fmZLgAAAACF6Y033ij1eqONNkpZ5sorryz1unPnzvHqq6+u1b+bb765VB2HHXZYyjKbbbZZxt/fz2bNmlXqdYMGDdIuVxXeKwAAAAAAAAAAAEChK2vulwEDBuQ0j3HjxsVHH32Utqxfv37lqqNQ5w8oS1Wcl2v58uVx//33p8T322+/OO2001LiAwYMiJKSklyktlqFPodHppjLgvJo2rRpPP7443HsscemLZ8+fXoMGjQox1lVXv369WPYsGFRp06dlLJ58+ZF9+7dY+nSpdUiD/PBlc18NMmY/7fQ79uFPvdWuu1XKNsuyUaOHBkvvPBC2rIzzjgj2rZtm+OMcq9x48YxePDgVeOlX5o/f36ccMIJsWLFioy1d84555R5T+vevXv06tUrY21l0ty5c9MeK/vuu29KbPjw4Wtd//PPP5/Sl2jdunWst956pWLLly+vUP0/y9fYojqPK+6///4yt/nuu++e8je56RT6PfTXcvXcJKn946Q+V/JsIvOSdm5nUq7Pg+p6/Bb6GIfsSup9MikK+XOt6njuF/L+yLVC3v9JvS4ltf9elnx9JlzIxyYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApP66MwAAAAAAAAAAAAAAAABExPPPP5823rFjx/jDH/5QoTo33HDDeP3112PPPfdcFRs/fnyF6qrqkrz9X3nllbTxCy+8MPbZZ5+MtrVw4cK4/PLL05btvvvuMWbMmGjevHmF6//jH/8Yd911V6nYjjvuGGPHjo1OnTpVuN5Ct2LFivif//mflHitWrVixIgRcfbZZ1eo3q222irGjBkTm222WUpZixYtYsaMGRWq95f69++fEisqKoqHHnoo6tevXyo+Z86cGD58+FrVX6tWrTjzzDPL/JcrSb5GJMGyZcvivPPOS1tWs2bNePLJJ+PPf/5zheru0KFDvPbaa7Heeuutik2dOrVCdWXD2LFjY/To0WnLzj777Hj66aejZcuWlWpjr732ivfffz/22muvtOULFiyISy+9tFJt5MKtt94aL7/8ctqybt26Rc+ePXOcUX4U8r340ksvjZKSkpT4AQccEC+++GJsvPHGFc4rIqJx48Zxzz33pC0bOXJkues5++yzY+7cuWnL/vnPf8add94ZtWvXXuv8OnbsGG+//XZsuummacv/9re/xRdffLHW9WbCkCFD4ttvv01b1rt377j66qvXus5TTjklHn300Sgu/r+pNCZNmlThHFcnl/3dTKmOx1mSJLVvl8RzIakaNWqUNj5//vwcZ1J+Z599dsyePTtt2ZZbbhnvvfdeHHbYYRWqu1u3bjF+/Pho27Zt2vLvvvsuLrjgggrVTfkl9dpF9e3DZ6r/nmv9+/ePf/7zn1GjRo21XrdLly7x1ltvRYsWLdKW33rrrfHpp5+Wu75CPnaqgkIfwyZl/5f1bDsi/8+3jcuyqzo/0wUAAACgMM2cObPU6yZNmqQsU5Hn/xXx3//+N2t116pVq9TrpUuXpl2uKrxXAAAAAAAAAAAAgELWoUOHaN26dUp84cKF8fDDD+c8nwEDBqSNd+zYMVq1arXG9Qt5/oCyVMV5ue6+++6UWFFRUcocEytWrIiBAwfmKq3VKvQ5PDLJXBaUpU2bNnHZZZfFZ599FocffniZy1144YWxYMGCHGaWGf379y9zHrq+ffvGZ599Vm3yMB9c2cxHk4z5fwv9vl3oc2+l236Fsu2S7rzzzouVK1emxGvVqhXXX399HjLKrbvuuis22mijtGVnnXVWxvuCixYtiuOPPz6WLVuWtvzWW2+NzTffPKNtZsrQoUPXuMyKFSvi2WefXeu658+fX+Y485defPHFmDNnzlrX/0v5GFtU93FF37594+uvv05bdv7550eHDh1Wu36h30PTycVzkyT3j5P6XMmzicxK4rmdSbk+D6rj8VvoYxyyK8n3ySQo5M+1quO5X8j7I9cKef8n+bqU1P57WfLxmXAhH5sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAULzmRQAAAAAAAAAAAAAAAACojl577bWYOXNm2rL+/fvHpZdeGjVr1ixXXbVr144//vGP8f7778fOO++8Kv7DDz/EZZddlpF8q5okb/8777yzzDxeeOGFuOaaa2LTTTfNWHt33HFHvPrqq2nLdtlll/jwww/j9NNPL/f2iojYfvvtY+TIkXHzzTdHcXHqn2O+8847MXr06ArnnARPPfVU3HfffSnxGjVqxE033RT//ve/46CDDipXXQ0aNIhLLrkk3n333Wjbtm1KeUlJSZxzzjlRUlJS2bTjo48+irfeeislvv3226fEHnrooVi6dGml28yHJF8jkuKxxx6Lp59+Om1ZcXFx/OMf/4jx48dHp06dylXfVlttFQ888ECMHj06mjRpsiq+ePHiuOSSSzKSc6accsopMWfOnLRlXbp0iU8//TRuu+222HHHHdeq3n333Tcee+yxeP3116N169ZlLvenP/0pvvrqq7WqO1/69OkT8+bNS1t26623xsYbb5zjjPKjUO/F7733Xtxxxx1py/baa6/4+OOP49JLL42mTZuWO6+fderUKd5+++3Ybrvt0pYPGzas3HV9//330a9fvzLLTz311Jg0aVL06NGjXNtw2223jSeeeCJGjRoVjRs3TrvM66+/Htddd125c8y05cuXx4033lhm+V/+8pd45pln0vYbfm2XXXaJkSNHRv/+/Uttn3feeSeefPLJTKSbItf93UyojsdZkiS1b5fEcyGpatSokTa+2WabRd++fXPyb237Nd9++2307t27zHFes2bNYvjw4fHqq69G9+7do379+qutr0GDBtG9e/cYM2ZMPPHEE2Xev1esWBE9evSIWbNmrVW+rL2kXrv4SdL78Gsrk/33XBg/fnyp1+eee258/PHHcdRRR0VRUdEa199+++1jxIgR8fTTT0ejRo3SLvPll19W6Pwq1GOnKkjCGDYp+7+sZ9sR+X2+bVyWfdX5mS4AAAAAmXHggQfGvvvum5G66tSpU+r14sWLM1Lv2po9e3bMnTs3a/VvuOGGpV5///33WWtrTbL9XgEAAAAAAAAAAAAKWVl/z/7oo4/Gjz/+mONsIgYNGpR2zteioqLo27dvueoo1PkDylIV5+WaPHlymXNN/NLIkSPj22+/zUFGa5aEOTwyxVwWVcNee+0VRx55ZIX+HXXUUXHiiSfGmWeeGX/9619j6NCh8Z///CcmT54cf/vb32Ldddcts91HHnkk7r333hy+08z4wx/+EMcff3zasgEDBsSQIUOqVR7mg1u96j4fTRLm/03CfbuQ594qa/sVyrZLsg8++KDM++Rhhx0W+++/f44zyp1evXrF0Ucfnbbs0UcfLXOMVlnvvvtumfebhg0bxkMPPVTm/Lz59OSTT8ayZctWu8wbb7wRs2fPrlD9w4cPX+MyQ4cOrVDdv5TrsYVxRcTcuXPjhBNOiJUrV6aUFRUVxaBBg1Z7DU/CPfTXcvHcJMn946Q+V/JsIrOSeG5nUq7Pg+p6/BbyGIfsSvJ9MikK+XOt6njuF/L+yLVC3f9Jvi4ltf9elnx9JlyoxyYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlP+XcwAAAAAAAAAAAAAAAACoVpYsWRJXXXVV3HjjjSllxcXFccUVV0S/fv1i0KBBMWbMmPj000/jhx9+iMWLF8e6664bzZs3jzZt2kSnTp2iS5cuscEGG5Sqo6SkJE488cSYMWNGrt5SoiR5+48dOzZef/31aN++fUpZrVq14oILLogLLrggpk6dGl9//XXMmzcvVq5cmbLs999/H7179y5Xm0cffXS88847sckmm6SUNWvWLG677ba47LLLYuTIkfHCCy/ElClTYvr06bFw4cKoXbt2NGzYMDbZZJPYYYcd4pBDDok999yzzLa+++676N69e9qcq5p+/fqVuQ923XXXeP7552PGjBkxatSoeO+992L69Okxa9asiIhYd911Y/PNN4927drFQQcdFPXq1Suznf/93/+NF198MWN59+/ff7X78GcDBw7MWJu5luRrRJL06NEj/v3vf0ebNm3Slu+8887x3HPPxbRp02LkyJExceLE+P7772POnDlRp06daNKkSWy33Xax//77x84775y2jrPPPju++OKLbL6NtfbVV1/FCSecEMOHD49atWqllNevXz9OP/30OP3002PatGnx5ptvxuTJk2PKlCmxYMGCWLhwYdStWzfWW2+9aNq0aey0006x1157RZMmTdbY9u233x533nlnNt5WVnz11Vdx3nnnxd13351S1qhRo7jvvvuiQ4cOecgs9wr1XnzuuedGu3btYrfddkspa9CgQVxxxRVx6aWXxhtvvBGvvPJKfPLJJ/Hll1/GvHnzYuHChVFUVBT169ePxo0bR+vWrWPnnXeOQw45JNq2bVtmm0899VSMHTt2jbn90pAhQ2K77baLiy++OG35pptuGoMGDYpbb701nn/++Xj77bdj2rRpMWvWrKhfv36sv/760bZt2zj44INjyy23XG1bX3zxRXTr1i1WrFixVjlm2o033hiHH3542j5jRMQhhxwSnTt3jrfeeiuef/75+Prrr2PGjBlRVFQUTZo0ie233z46duwYO+64Y8q6S5YsiZNOOilOOOGErOSeif7u2vR1M6U6HmdJkdS+XT7GfpS25557lmvskwldunSJKVOmrNU6Tz31VJx77rlx0003lbnMPvvsE/vss08sW7YsPvroo5g8eXL88MMPsXTp0qhTp040btw42rRpE9tuu23avumv9evXL1566aW1ypOKSeq1i/+T5D58hw4d8tp/z7Y+ffrE22+/HXXq1FkV22KLLWLYsGExc+bMeO655+Ldd9+NadOmxZw5c6Jhw4ar+mqdO3deY19t0aJF0a1bt5g3b16F8ivUY6cqSMIYNin7v1+/frHFFlvEb3/727Tl+Xq+bVyWfdX1mS4AAAAAlbP33nvHVVddFXvvvXe89957seuuu0ZJSUml6vz1s9nvvvsuZZk1Pecrj3bt2sWgQYNWvX7kkUfisssuW/V62bJllW5jdfbff/9Sr7/++uu0y1WF9woAAAAAAAAAAABQqJo3bx6HH3542rIBAwbkOJufzJo1K0aMGBFHHXVUSlmfPn3i0ksvLdf3Pwt1/oB0quq8XP3794999913jcsUkiTM4ZEp5rJIvnPOOSfOOeecnLb53HPPRa9evXLaZibUr18//vWvf5VZfsIJJ8Sxxx6b0Ta//vrr2HbbbQsyjwjzwZVHdZ+PJgnz/ybhvl3Ic2+Vtf0KZdsl2SWXXBLHHnts1K9fP6XsxhtvjJ133rnSf4dYaFq1ahW33npr2rKpU6dG3759s9r+tddeGwcffHDss88+KWV77rlnXHrppfHXv/41qzmsrR9++CFefPHF6Ny5c5nLDB8+vML1P/XUU3HbbbeVWb58+fJ48sknK1z/L+VybGFc8ZPXX389/vd//zftNt9ggw3ivvvui0MPPbTM9ZNwD/2lXDw3SXL/OMnPlTybyKyknduZlI/zoLoev4U8xiF7knyfTJJC/lyrOp77hbw/cq0Q93+Sr0tJ7r+XJV+fCRfisQkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANfOdAAAAAAAAAAAAAAAAAACF6/bbb49evXrFzjvvnLZ8ww03jAsuuCAuuOCCta77ggsuiBEjRkS7du0qm2aVleTt36tXr3j//fejYcOGZS7TsmXLaNmyZZnlX375Zbnbmz59ehx44IHx0ksvxUYbbZR2mfXXXz969+4dvXv3Lne9v/b9999Hp06d4uuvv65wHUmyZMmSGDt2bPzud78rc5lmzZrFCSecECeccEKF2hgwYEBccsklFU0xrUceeSRuuummaNSoUZnLfPDBBzF+/PiMtptrSb5GJMXcuXOjc+fO8eKLL8amm25a5nItWrSIPn36rHX9t9xyS/Tv3z/22WefyqSZFSNHjoxDDz00HnvssWjQoEGZy7Vo0SKOOOKIjLR52223xZlnnpmRunJpwIABceSRR8bBBx+cUnbAAQfEWWedFf/617/ykFluFeq9eOnSpXHwwQfH888/H7vsskvaZWrVqhX77rtv7LvvvhXO62czZ86M0047rULrXnLJJVFUVBQXXXRRmcusu+66cfTRR8fRRx9doTY+/vjj6Ny5c8yaNatC62fSihUr4phjjokJEyZEs2bN0i5TXFwcv/3tb+O3v/1tuestKSmJfv36xYcffpipVNOqbH93bfq6mVTdjrMkSWrfLtdjP5Ln5ptvjuLi4rjhhhuiqKiozOVq1aoVO+20U+y0004VamfFihVx1llnxYABAyqYKRWR1GsXP0lyH74Q+u/ZNHHixOjZs2c88sgjKdfOpk2bRo8ePaJHjx4VqnvRokVx5JFHxvvvv1/h/Ar12KkKkjCGTcr+X7JkSRxyyCHxzDPPFNzzbeOy7KrOz3QBAAAAqJjatWvHY489tur7KzvvvHOce+658c9//rNS9R5//PGlXk+YMCFlmUmTJlWqjYifnnX90pw5c8pV70477RQXXXRRTJs2Lf74xz9WqO0NN9wwjjrqqFKx559/Pu2y+XyvAAAAAAAAAAAAAFVdnz59olatWinxyZMnx2uvvZaHjH5y9913p3zfNCKiefPm0a1btxg2bNga6yjk+QPSqYrzcj322GPxr3/9K5o0aZK2/Ntvv41nnnkmx1mtXhLm8Mgkc1mwNm699dY499xzY/ny5flOZa3VqVMn6tWrV2b56soqap111inYPH5mPrjVq+7z0SRh/t8k3LcLee6tNW2/fG+7JJs2bVpcc8018fe//z2lbMcdd4yTTjop7rnnnjxklh01atSIBx98MO1YpqSkJHr16hVz5szJag4lJSXRo0eP+OCDD2LddddNKb/kkkti1KhR8cYbb2Q1j7U1dOjQ6Ny5c5nlTz31VIXrnjJlSrz//vux4447pi1/+eWXY/bs2RWu/9dyNbYwrvg/l19+eRx44IGxxx57pJR16dJltb9zkYR76K/l4rlJkvvHSX6u5NlE5iTx3M6kfJwH1fH4LeQxDtmV5PtkUhTy51rV8dwv5P2Ra4W6/5N8XUpy/z2dfH0mXKjHJgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADVW3G+EwAAAAAAAAAAAAAAAACgcC1dujQOPvjg+O9//5uxOpctWxannnpqXHfddRmrs6pK8vb/73//G0ceeWTMnTs3q+380uTJk2OvvfaKt99+Oyv1jx8/Pnbbbbf44IMPslJ/oTrwwANj4MCBGa935cqVcfXVV8cpp5wSJSUlGa174cKF8fDDD692mWy8p1xL8jUiST7//PP43e9+F+PHj89ovddcc02cffbZGa0z00aNGhV77bVX/Pvf/85qOwsXLoy+ffvGmWeemdV2sukPf/hD/PDDD2nLrr322thyyy1zm1CeFOq9eObMmbHffvvFk08+mZW8fvbNN99E+/btY+rUqRWu4+KLL46TTz45FixYkMHMfvLMM8/E7373u5gyZUrG666ob7/9Nvbee+/4/PPPM1LfypUr48wzz4z77rsvI/WtTj76u5lS3Y6zpEhq3y7J5wK5c+ONN8YRRxwRs2bNykr906dPj65du8Ydd9yRlfopW1KvXfyf6tyHz0T/PZuGDRsWxx57bCxevDhjdX7//fdx0EEHxXPPPVfpugr12KkKkjCGTcr+nzt3bsE+3zYuy67q/EwXAAAAgLW3dOnSuP7660vF/vGPf0S3bt0qXGf79u3j1FNPLRV7/PHHK1xfpj3++OPx3nvvRffu3eP000+PDh06rHUdtWrVivvvvz/q16+/KjZ79ux4+eWXM5kqAAAAAAAAAAAAAOXQt2/ftPEBAwbkOJPSRo8eHV9//XXasn79+pW7nkKeP+DXquK8XEuWLInBgweXWX7vvffGypUrc5hR+SRhDo9MMpcFazJx4sTo0KFDnHXWWbF8+fJ8p0MGmQ9uzar7fDRJmP83CfftQp57y9x92XPDDTeU+Z6vuuqqaNCgQY4zyp7LLrss9txzz7Rl//znP+Oll17KSR5Tpkwpc7xYo0aNGDx4cDRs2DAnuZTXk08+GcuWLUtbNmnSpJg0aVKl6h8xYkSZZcOGDatU3enkYmzB/1mxYkUcf/zxMW/evLTl1113Xeywww5lrp+Ee+gv5eK5SZL7x0l/ruTZROYk7dzOpHydB9Xx+C3kMQ7Zk+T7ZJIU8uda1fHcL+T9kWuFuP+TfF1Kev/91/L5mXAhHpsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVG/F+U4AAAAAAAAAAAAAAAAAgML2/fffxx577BHPPPNMpeuaOHFitGvXLvr375+BzKqHJG//F154Idq1axevvfZaTtqLiPjmm2+iffv2cfHFF8fChQszUufChQvjggsuiHbt2sU333yTkTqTZPHixfGHP/whDjvssPjiiy8yUufnn38eHTt2jIsvvjgj9aWzuuN82bJlMXjw4Ky1nUtJvkYkydSpU2OPPfaIK664IpYsWVKpumbOnBmHH354/OUvf8lQdtn14YcfRrt27eKMM86IKVOmZLTukpKSeOyxx2KbbbaJu+++O6N159p3330XZ555ZtqyevXqxeDBg6NGjRo5zio/CvVePG/evDjiiCOie/fu8fXXX2ckr5+VlJTE4MGDY/fdd49PP/200vXdc889sf3228dzzz2Xgex+Oj579uwZhx56aPzwww8ZqTOTPv3002jXrl2MHDmyUvXMmDEjOnfuHLfffnuGMluzfPR3M6W6HWdJkdS+XZLPBXJn+PDhsc0228SgQYNi5cqVGalzxYoVcd9998U222xT6fsIFZfUaxf/p7r14TPdf8+moUOHxp577hkTJkyodF3Dhg2LbbfdNl5//fXKJ/b/FeqxUxUkYQyblP1fyM+3jcuyqzo/0wUAAABg7d14442lnsfXqFEjHnvssbjsssuidu3aa1VXz549Y+TIkVGzZs1VsaeffjrGjx+fqXQr7ZfPYGvUqBFPPfVU9OjRo9zrb7DBBjFy5Mg48MADS8Uvv/zyWLx4ccbyBAAAAAAAAAAAAGDNOnbsGK1atUqJL1++PO6///48ZPR/SkpK4r777ktbtv/++0ebNm3KXVchzx/wa1VxXq6y5gQqKSmJAQMG5Dib8kvCHB6ZZC4Lfm3RokXxxBNPROfOnWPHHXeMl156Kd8pkSXmg1uz6j4fTRLm/03CfbuQ5976efsV6rZLqkWLFsVFF12Utmz99dcvsyxpfvvb35Y5Lnr//fdzfr0bMmRIPPjgg2nLNt9887jttttyms+azJkzp8x+1ogRIypd//Dhw9PGV6xYEU888USl60/H2CK3vvjiizJ/56JOnTrxyCOPRL169cpcPwn30F/KxXOTJPePk/5cyfUjc5J2bmdSvs6D6nj8FvIYh+xJ8n0ySQr5c63qeO4X8v7ItULc/0m+LiW9//5r+fxMuBCPTQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACqr+J8JwAAAAAAAAAAAAAAAABA4ZsxY0Yceuih0b1793j99dfXev3x48fHscceGzvttFNMmDAh8wlWcUne/pMmTYp99tkn9thjj7jrrrti4sSJsXLlyqy2uWzZsrj66qtj8803j6uuuiq++eabCtUzZcqUuOyyy2LjjTeOf/zjH7FixYoMZ5osTz31VGy55ZZxwgknxNixY6OkpGSt63j//ffj1FNPjS233DJeeumlLGT5f8aPHx/vvfde2rJnnnkmZs6cmdX2cynJ14gkWb58eVx++eWx2WabxQ033BAzZsxYq/WnT58eV1xxRbRq1SpGjBiRpSyzo6SkJG6//fbYfPPN4+ijj45nnnkmFi5cWOH6pk+fHrfccktst912cdRRR8VXX32VwWzz58EHH4wnn3wybdluu+0WF110UW4TyqNCvhc/+uijsfnmm0f37t3jhRdeiCVLllS4rjlz5sTAgQNjjz32iJ49e8a0adMqnd/P/vvf/8bBBx8cu+++ewwdOrRC59yECRPi1FNPjc022ywGDx6csdyyYfbs2XHIIYfEAQccEG+++eZarfvDDz/EddddF23atInRo0dnKcOy5aO/mynV7ThLiqT27ZJ8LpA706dPj169esU222wT//rXvyo8LpsxY0bccsstsc0220SfPn1i1qxZGc6UtZXUaxf/pzr04bPZf8+m999/P3bbbbc48cQT45NPPlmrdRcvXhzDhg2LXXbZJY4++uisXC8L+dipCgp9DJuk/V+oz7eNy7KrOj/TBQAAAGDtLFu2LI455phSz5CKi4vjb3/7W3z22Wdx6aWXxs477xzFxak/8VKnTp3Ycccd45xzzomJEyfGAw88EA0aNFhVPn369DjzzDNz8j7K6+KLL47PPvts1et69erFoEGD4t///necccYZsc0220StWrVKrVO/fv3Yf//949Zbb41JkyZFhw4dSpW/+uqrcccdd+QkfwAAAAAAAAAAAAD+T79+/dLGn3nmmfj+++9znE2qe+65J+3f+BcVFcWpp5661vUV6vwBv1bV5uX66KOP4q233kqJjx49Or788svcJ7SWCn0Oj0wyl0X1s3Tp0pg3b158+eWXMW7cuHjwwQfj4osvjg4dOkTTpk3jyCOPjOeffz7faZID5oNbs+o+H01S5v8t9Pt2oc+9VcjbLqkeeOCBMn/z4txzz41NNtkkxxllVsOGDePBBx+MGjVqpJQtXrw4jjvuuFi2bFnO8zrttNPK/P2Cnj17xjHHHJPjjFZv6NChaePDhw+vdN3vvvtufPfddynxV199Nau/uWJskVsPPPBADBkyJG3ZVlttFTfffPMa6yj0e+gv5eK5SZL7x0l/ruT6kVlJOrczKV/nQXU8fgt9jEN2JPk+mTSF+rlWdT33C3V/5Foh7v8kX5eS3n//pXx/JlyIxyYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1VNRSTl/6aqoqCjbuQAJtcMOO8QOO+wQERElJSXxxRdfxFtvvVWhH9IDAACSoXHjxnHxJRfnOw2quJdeeilGPjsy32kAAAA5dt311+U7BaqBTz7+JAYOHJjvNAAy4uzHIurUz3cWVGXffBjx0J/ynQUAZSkqKorddtsttthii1Xf9544cWJMnDgxz5lVT75TC0B1tOWWW0b79u1jr732ijZt2kTjxo1jvfXWi1q1asW8efPihx9+iE8++STee++9eOaZZ+Kzzz7Ld8pVStK3f/369WODDTYolXc6ixYtipdffjkjbe62227Rvn372HXXXWPTTTeN5s2bR/369aNmzZqxdOnS+PHHH+OHH36ITz/9ND766KN48cUX9a/XoEWLFrHffvvFnnvuGW3atImNN944GjRoEPXq1YuVK1fG3Llz44cffoj//Oc/MX78+HjppZfik08+yWmOL7zwQnTo0CElfthhh8VTTz2VkTZefvnl2G+//Va9LoS/yU36NSIpiouLY5999on27dvHjjvuGJtttlmsu+660aBBg1i4cGH8+OOPMWXKlJgwYUKMGTMmXn755Vi5cmW+086YOnXqRPv27WOHHXaIrbfeOtq2bbvq/Tdo0CAiIhYvXhzz58+P7777Lr788suYMGFCvPXWW/Hee+/lOXvyoVDvxeuss07su+++scMOO8RWW20VrVu3joYNG0aDBg2ifv36UVJSEvPnz4958+bFjz/+GJ9//vmq53Bjx46N5cuXZz3HiIi6detGx44do127drHDDjtEy5YtV51zS5Ysiblz58bs2bPjo48+ivfffz9GjRoVX331VU5yy4aNN944OnXqFPvtt19suOGG0axZs2jSpEksX748fvjhh5g+fXq89957MXbs2Bg5cmQsXbo03ymXUp7+bib7uplS3Y6zpEhy3y4fYz+SpUaNGrHrrrvGPvvsE9tuu220bt06fvOb30SDBg2idu3asXTp0pg/f37MmjUrPv/88/jwww9jzJgxMX78+FixYkW+02c1knzt4v8Uch/+rLPOKuj+e3mV9Xny6p4vbbfddnHIIYfETjvtFFtssUU0atQoGjRoEIsXL465c+fGtGnTYuLEifH222/Hc889FwsWLMhW+mUq1GOnKkjCGDYp+79Qn28bl2VXdX+mC1BVFRUVxe677x5t27b1fVqg3CrzHe9C+F4IUJj8XQlUDdtvv30888wzsfHGG6ctX758ecyePTuaN28eERFLliyJ2rVrl9lHmD59enTo0CE+/PDDrOW8zz77xKuvvrrq9Z133hmnnXbaGtdr3bp1jB49OjbffPO05StXrox58+bFkiVLomHDhlGvXr0y63r33Xdj//33j3nz5q39G1gLFX2vABSugw85OA444IB8pwFlevyxx+PNN9/MdxoAiXb88cfHzrvsnO80oEz33HNP/OeT/+Q7DYBEO+9/zosNNtgg32nAat1w/Q0xbdq0fKcBkGj9Hoho1DzfWUDZbjoyYunCfGcB5Iu52guL79QC+VCo8wekY16uwpGEOTwyxVwWUH2ZD27Nqvt8NEmZ/zcJ9+1CnXsrCdsOSA5ji+RJ2n0g289Nkt4/TvJzJdePzErauZ1J+TgPquvxW6hjHLIn6ffJJCnkz7Wq47lfyPsj1wpt/yf9upTk/nuhKbRjE6CQmasdqAhztQPZ4O9KAACg+tl///3jkC6H5DsNqpmXXnopRj47Mt9pAOSE33UhH5595lnfbQKqDfda8sVvowHVScczI3Y+NN9ZUN2M+lfEhGfynQVAbpmrvbD4Ti0AAAAAAAAAAABAbpmrHaiI8nzHu6iknN8EN3k7UBZ/aAIAANVP48aN4+JLLs53GlRxJmsHAIDq6brrr8t3ClQDn3z8SQwcODDfaQBkxNmPRdSpn+8sqMq++TDioT/lOwsAymLy9sLiO7UAAFB4WrZsGV9//XUUFxeXin///ffRsmXLWLFiRUbaGTNmTOy9994REbFixYqoWbNmRuoFAAAAoGor6/Nkc74BAED5mbwdqIjKfMfbuB0oi78rgaqjSZMmceutt8axxx5bqXv/Y489FqeddlrMmDEjg9ml2meffeLVV19d9frOO++M0047rVzrNm3aNG688cbo0aNHhdouKSmJm2++OS688MJYsmRJhepYG5V5rwAUpoMPOTgOOOCAfKcBZXr8scfjzTffzHcaAIl2/PHHx8677JzvNKBM99xzT/znk//kOw2ARDvvf86LDTbYIN9pwGrdcP0NMW3atHynAZBo/R6IaNQ831lA2W46MmLpwnxnAeSLudoLi+/UAgAAAAAAAAAAAOSWudqBijBXO5AN/q4EAACqn/333z8O6XJIvtOgmnnppZdi5LMj850GQE74XRfy4dlnno2XX34532kA5IR7Lfnit9GA6qTjmRE7H5rvLKhuRv0rYsIz+c4CILfM1V5YfKcWAAAAAAAAAAAAILfM1Q5URHm+412cgzwAAAAAAAAAAAAAAAAAACCnevXqFcXFqX9KO3jw4FixYkXG2mncuPGq///xxx8zVi8AAAAAAAAAAAAAuTV79uw4/vjjY6eddoo777wzZs6cWe51p0+fHgMHDoydd945jjrqqJgxY0YWM628mTNnRs+ePWPnnXeOe++9N2bPnl2u9ebPnx8DBgyI7bffPs4999xYsmRJljMFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMiemvlOAAAAAAAAAAAAAAAAAAAAMqmoqCj69u2btqx///4Za6dBgwax5ZZbrno9bdq0jNUNAAAAAAAAAAAAQH5MnDgxTjvttDj99NNjq622il133TU22mij2H777eP444+PiIhx48bFkCFD4ptvvokPP/ww/vOf/+Q8zzFjxkRRUVGl6pgwYUKcdNJJUVxcHDvttFNss8020apVq2jUqFHUr18/Fi5cGLNnz47p06fHO++8ExMnToyVK1dm6B2UXybeKwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAr9XMdwIAAAAAAAAAAAAAAAAAAJBJhx56aGy22WYp8TFjxsSkSZMy1s4NN9wQtWvXXvX67bffzljdAAAAAAAAAAAAAORXSUlJfPLJJ/HJJ59ERMQuu+wSxx9/fEREvPbaa3HTTTflMbvMWrlyZYwfPz7Gjx+f71QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHKmON8JAAAAAAAAAAAAAAAAAABAJl1++eVp4zfffHNG6q9Zs2bceeed0bdv31Lx++67LyP1AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANlVM98JAAAAAAAAAAAAAAAAAABApvTs2TN23XXXlPgXX3wRTzzxRKXrX3/99WPYsGGx9957l4o//PDD8corr1S6fgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACD7auY7AQAAAAAAAAAAAAAAAAAAyIQ2bdrEzTffnLbsiiuuiJKSkkrV37Jly3jnnXdigw02KBV/7rnn4qSTTqpU3QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDu1Mx3AgAAAAAAAAAAAAAAAAAAUFnt2rWLYcOGxXrrrZdS9sknn8SgQYMq3cbUqVPjzTffjCOPPHJVbMCAAXH66afHsmXLKl0/AAAAAAAAAAAAAIXr22+/jcsvvzwiIt544408ZwMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQGXVzHcCAAAAAAAAAAAAAAAAAABQHkVFRVGrVq0oKiqK+vXrR/PmzWOXXXaJ7t27R9euXaNGjRpp1zvttNNi5cqVGcmhd+/esf3228fGG28c55xzTtx1110ZqRcAAAAAAAAAAACAwjZt2rS44oor8p0GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZUjPfCQAAAAAAAAAAAAAAAAAAQHl07949HnnkkbVa59Zbb41XX301YznMmzcvunXrFjVq1IgPPvggY/UCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuVMz3wkAAAAAAAAAAAAAAAAAAEA2vPzyy3HeeedlvN6PP/4443UCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuVOc7wQAAAAAAAAAAAAAAAAAACDTnn322Tj00ENj2bJl+U4FAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKDDF+U4AAAAAAAAAAAAAAAAAAAAy5fvvv4/TTjstunTpEgsXLsx3OgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEABqpnvBAAAAAAAAAAAAAAAAAAAYG2tXLkyFi1aFLNnz44vv/wy3n333XjhhRfi+eefj+XLl+c7PQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKCA1cx3AgAAAAAAAAAAAAAAAAAAUB5Dhw6NoUOH5jsNAAAAAKi0oqKifKcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCtFec7AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMiV4nwnAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALlSnO8EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIFeK850AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5EpxvhMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAXCnOdwIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQK8X5TgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABypTjfCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECuFOc7AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMiVmvlOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFanfv360bhx46hRo0ba8q+//jrHGQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAElWM98JAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOy///5xSJdD8p0GrNZLL70UI58dme80AAAAAAAAAAAAACCtl19+OW18//33z3Emlde6devo0qVL7LvvvrHHHntE8+bNo1atWqtdp6ioqMyyqrRtgPSq63leXd832eOYAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKqTmvlOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMrZb7/98p1CpW2zzTZx2WWXRffu3aO4uDhj9VaFbQOsXtLO89q1a6eNL126dK3qSdr7pvA5pqqmTF1zyC/7EYBfcl8AAAqd/goAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/D/27jtMqupsAPi7Cyy9SlNUREUUFSmKBewoSBMLMTaURATFaDRGjT0qGqOJLUEF7B0bXQE7ggULIFiwF2wISJW+3x/fI3GZWdgyuzuz+/s9zz5y33PPe96ZOXNuYeUCmaJyWRcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAxXbcccfFfffdF1WrVi3rUgBK1E477RQfffRR0rZWrVrF3LlzS7kioDyz5pQPPkeA0nf22WdHvXr1ymz8V199NV544YWkbY4LkDrnnntu1K5dO0/so48+iscee6zUa8lv3XniiSfi/fffL/V6AIrD+QoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJmkclkXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQMU1cODAuP322yMrK6usSwEAAACIc889N7bbbrsyG/8f//hHvPDCC2U2PlQE7du3j3//+98J8aVLl8a4ceNi+fLlpVpPfuvOhx9+GO+//36p1gIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVSXZZFwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDFtPvuu8ctt9wSWVlZm9133bp1sXLlyqQ/AAAAAAAFNXDgwKTx2rVrx/HHH1/K1QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABlpXJZFwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDFdO+990bVqlWTtv30008xdOjQGD9+fHzwwQexdOnSUq4OACD1OnXqFJdeemlCfMqUKXHttdeWQUUAFIZ1HCDz1apVK0444YR8288444wYMWJEKVYEQEE4FwcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoCRULusCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqHgOPPDAaN++fdK2yZMnx7HHHhtLliwp5aoAAEpWkyZNolu3bgnxZcuWlUE1ABSWdRwg851wwglRq1atfNvbt28fHTp0iLfffrsUqwJgc5yLAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQEiqXdQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUPGeddVbS+EcffRS9e/eOlStXlnJFAAAAAPn75ptv4ueffy7xcb7//vsSHwMqskGDBhVonwEDBpRCNQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBZqlzWBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFDxHHLIIUnjF154YaxcubKUqwEoHStXroy33nor3zaAVLLmlA8+R4D08Ze//CVGjhxZpjU4LkDx7LnnntGuXbvN7nf88cfHeeedF0uXLi2FqgDKF+crAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABkksplXQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVyy677BINGjRIiC9YsCDGjh1bBhUBlI6vvvoq9tprr7IuA6ggrDnlg88RgN9yXIDiGThwYIH2q1mzZpx44olxxx13lHBFAOWP8xUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADJJdlkXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQMXSunXrpPE33ngj1q9fX8rVAAAAAADlXe3ateP4449PiH/99ddJ9z/jjDNKuiQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgjGWXdQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABULA0aNEga/+yzz0q5EgAAAACgIjjxxBOjZs2aCfHzzz8/Pvzww4R4mzZtomPHjqVRGgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFBGssu6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACqW+vXrJ40vXry4lCsBAAAAACqCQYMGJcQWLlwYo0aNirvuuitpnzPOOKOkywIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADKUHZZFwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDFUq1ataTx1atXl3IlAAAAAEB5t9dee8Uee+yREH/wwQdj9erVcd9998WaNWsS2o877rioW7duaZQIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlIHssi4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABKwqBBg5LGR4wYERER8+fPj3HjxiW0V69ePU4++eQSrQ0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoO9llXQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBJqFq1ajRo0CBq1apV1qVQgZmHZatSpUpRr169qF+/flSpUqWsyyGN/fpdrVatWlmXkjFq167tu1WCMvX4kZOTEw0aNIgaNWqUdSmblanvcaapUqVK1K9fP+rWrRtZWVllXY5zgxTIxGNmptRsXSqc6tWrR4MGDaJevXppsb6kI3OKkvDrvKpevXpZl0KKVIRruzp16sTvf//7hPj06dPjvffe27A9YsSIpP0HDRpUYrVVBK4TKYyKsCYVhmvYzOLzAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADITJXLugAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKDgWrZsGVWqVEmIf/fdd7Fo0aJi569du3Zss802CfEPPvggcnNzi52/RYsWUb169YT4xx9/HGvWrCly3t122y2OPPLI6NixY7Rp0yaaNWuW533Kzc2NRYsWxZw5c2LWrFkxadKkmDRpUqxcubLIYybTunXrhNgPP/wQCxYsyLdP1apVo02bNrHjjjtG3bp1o3bt2pGVlbWh/dZbb015nYVVtWrV2GGHHfJtX7p0aXz99dd5Yg0aNIimTZsm3b9Jkyb5xpO9h5vz/vvvF7pPSSiLeWhN+J+OHTvGoYceGh07doy2bdtGw4YNo1atWnn2Wb16dcybNy9mz54d7777bowbNy6mT59erNeQTsyHgqlfv34ceeSRccQRR0SbNm1ihx12yPO+rVixIl555ZWYPHlyTJo0KWbPnp2ysSOSHysi0mct21jVqlWja9eu0bVr19hjjz1il112ifr16+c5Vq1evTq+/PLLmD17dkybNi1GjRoVn3zySRlWvWnpdrxOl/OYwqpdu3b06NEjunfvHm3bto2ddtopqlatuqF93bp18f3338esWbNi+vTp8fTTT8eMGTPKpNbSfI8bNmwYjRs3zrd92223TRqvW7duoc+DCrJulOaa07Zt2+jZs2fsueeesfvuu0ezZs3yzInc3NxYsmRJvP/++/H222/HhAkTYtKkSbFu3bqU1xJRvs4NUvU5Fnb9a9CgQfTt2zcOOeSQaNeuXTRv3jxycnI2tK9YsSLmz58fH3zwQakeN9O95oIo7bV/q622inr16iXEFy1aFN99911RX8YmJbsmXLBgQfzwww+FylOlSpU4+OCDo1u3btGmTZvYddddo1GjRlGpUqUN++Tm5sbPP/8cCxcujJkzZ8bLL78cL7/8csycObPQdZfmOr569eqUnTOl0/lEup1rlUeldXzfaqut4thjj43OnTtHu3btYtttt82zpq5bty6+/fbbmDNnTkybNi3GjBmT7/eucuXK0aBBg4T4woULY+3atQWqp3HjxtGwYcOE+ObmV2FkZWXFLrvskhBfv359fPjhh4XKlW7fhfJ4bVdQJ510UtSoUSMhPmLEiDzbzz77bMybNy+aNWuWJ77rrrvGfvvtF9OmTSvROtNRYedx/fr146ijjorDDjss9thjj9h+++1dJ/5GSd67y7T7dumyJqXTWl2ermEjina+kknn4uXt8wIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqMiycgv41LffPrgM4LfatGkTbdq0iYj/fyjmZ599Fq+//npKHioJAACkp3r16sUll15S1mVQzr3wwgvxzIRnyroMAACglN1w4w1lXQIVwAfvfxB33313WZcBkBLnPBlRtWZZV0F59s3siIfPL+sqAMhPVlZW7LnnnrHTTjtt+H3vWbNmxaxZs8q4sorJ79QCAAAAAAAAAAAAlK6srKzYa6+9omXLln6fFiiw4vyOt3+rHciP/68EUuvggw+O7j26l3UZsEn+3VSA4jui+xFxyCGHlHUZkK+nnnwqXnvttbIuAyCjnXDCCdGufbuyLgPyddddd8WHH3xY1mUAZLTz/nJebLnllmVdBmzSv278V3z//fdlXQZARht0f0SdxmVdBeTv5qMjVq8o6yqAsuLfak8vfqcWys7TTz8dffr0SYjfddddcdpppxU7/+WXXx5///vfE+L77bdfsX+/onLlyvHTTz9F3bp188QXLVoUjRs3jrVr1xYqX5UqVeKUU06J888/P1q1alXoepYvXx4PPvhgXH/99fH5558Xun8yydbBCy+8MP75z3/miWVnZ0ffvn1jwIABceCBB0blypXzzbnFFlvEwoULCz1uRGr+H6m6devG+PHjo1OnTknbv/rqqzj88MPjo48+yhM/77zz4l//+lexx9+cb7/9Npo1a5Zve0m+NxFlPw8r+ppQpUqVGDRoUAwaNChat25dpDq++eabuPXWW+POO++MJUuWFClHuqio86Gg3/PGjRvHpZdeGqeffnpUrVq1wLVNmTIlLr/88njppZcK3GdTUrUulfT6ts0228Tf/va3OPnkk6NWrVqF7j99+vS49tprY9SoUSmpJ5XK6nj9W2V9/EimoHOqfv36cdFFF8WZZ55Z6Lnx4YcfxrXXXhsPPfRQrF+/vsi1FkRZvcf5rZUloSDf95JeK2rUqBEDBgyIc845J1q0aFHo/vPnz4+bb745brrppvjll1+KXU95PTcoyWNHsvVvq622iquuuir69esXVapUKdQYpXHcTPea81OWa/8f//jHGDFiREJ8zpw5sdtuuxW6loJ49NFH47jjjssTO+aYY+Kpp54qUP+mTZvG+eefHwMGDIg6deoUqYbp06fHddddF6NGjSrwfcvSXMenTJkSBxxwQJH7p+P5RER6nGsV1+effx7bbbddQvy4446LkSNHllod+Snp43vHjh3j6quvjsMOO6zQOd966624+uqrY8yYMXniBxxwQLz88ssJ+++9997x5ptvFij3ddddFxdddFFCPNn8KqoaNWrE8uXLE+LLli2L2rVrFypXunwXyvO1XUHNnDlzw99p/WrFihXRtGnTWLp0aZ74kCFD4uKLL07I8cADD0S/fv1KrMZ0XXcKOo+33nrruOyyy6J///6FPherCNeJvyrJe3fpet9uY+m2JpX1Wl1er2Ejina+ku7n4uX58wIAMo9/qx0oCv9WO1AS/H8lAABQ8Xi+DGXB82KAisRzXSgLE8ZPiBdffLGsywAoFY61lBXPRgMqksPOimjXs6yroKKZdFvEjPFlXQVA6fJvtacXv1MLAAAAAAAAAAAAULr8W+1AURTkd7yzS6EOAIBypW3btrF06dJYunRpDBkypKzLAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoIIZOXJk0nivXr0iKyur2Pl79+6db/7iOvDAA6Nu3boJ8VGjRsXatWsLlevwww+Pjz/+OIYPHx6tWrUqUj01a9aMgQMHxscffxz//ve/o1q1akXKU1g777xzvP766/Hoo4/GoYceGpUrVy6VcYtiyy23jClTpkSnTp2Sts+ePTv23Xff+Oijj0q5sv8py7HTYR5W5DWhU6dOMWPGjLj11lujdevWRa5j6623jn/+85/xxRdfxCmnnFLkPOmgIs+HzTnqqKPi/fffjz/96U9RtWrVQvXdf//948UXX4wnnngiatasWexa0l2VKlViyJAh8emnn8YZZ5wRtWrVKlKevfbaK55++umYMmVKbL/99imusuSV5PE6HY4fRdWrV6/44IMP4oILLijS3Nh5553j/vvvjxkzZkSbNm1KoML/l8nvcSY5/vjj44svvoibb745WrRoUaQcjRo1iiFDhsTHH38chxxySLHqcW6QGieccELMnTs3/vjHP0aVKlUK3b8sjpuZUHNZr0uPPvpoLF26NCG+6667RocOHYpUz6bUrVs3jjzyyDyxH3/8McaMGbPZvllZWXH++efH559/Hn/5y1+iTp06Ra5jr732iqeeeiqmTp0aW265ZZHzlJQ5c+YUuW9Zz6niyqR7IxVJ7dq148EHH4w33ngjDj/88CJdR+65554xevToePLJJ6NBgwYlUGX5UpLfBdd2/2/vvfdOeu3xxBNPJD023nXXXZGbm5sQ79u3b9SvX79Easx0p556anzwwQdx+umnF+lcrCJdJ5bkvbt0v2+XyWtSSa3VrmHLVmHPxX1eAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADlV3ZZFwAAkGmys7OjVq1aUatWrcjJySnrcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKhgxo4dGytXrkyIN27cOPbZZ59i5W7atGm0b98+aVvPnj2LlTsi4qijjkoaHzlyZIFzZGdnx3//+9+YOHFiNG/evNg1RURUqlQpzj333Jg1a1bsvPPOKcmZn7333jtee+212GuvvUp0nFRo2bJlvPbaa7H77rsnbZ8yZUp07tw5vv3221KuLK+PPvqo1MdMp3lYUdeEU045JV5++eVo3bp1sev4Vf369ePee++Np556KqpWrZqyvKWpos6Hzbngggviqaeeii222KJYeY455ph4/fXXY7vttit2Telq6623jjfffDMuvvjiqFKlSkpydu7cOWbNmhU9evRISb7SUFLH63Q6fhTFX//61xg9enQ0adKk2Ll23333mD59epx66qnFL+w3Mv09zhTVq1ePJ554Ih5++OFo1KhRSnI2a9YsJk+eHBdccEGR+js3SI1rrrkmHnrooahZs2axc5XWcTPda06XdWn58uXx6KOPJm3r379/Sur6reOOOy6qVauWJ3bvvffG2rVrN9mvTp068cILL8QNN9yQ0L849t1333jnnXdi7733TlnOVJgzZ06h+6TLnCqOTLo3UpG0bt06Zs6cGSeeeGJK8h199NExderU2HLLLVOSrzwqye+Ca7v/GTRoUNL48OHDk8Y/++yzeOmllxLi1apVi1NOOSWVpZULN998c9xzzz1Rq1atYueqCNeJJXXvLt3v22XymlRSa7Vr2LJXmHNxnxcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQPmWXdYFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABbds2bKYOHFi0rY+ffoUK3fPnj0jKysradvuu+8e2267bbHy9+7dOyH2888/x/PPP1+g/tWqVYvRo0fHmWeeWaw68tOyZcuYNm1adOrUqUTyb7/99vHss89GvXr1SiR/KnXo0CGmTp0azZs3T9o+evToOOyww2Lx4sWlXFmijz76qFTHS7d5WBHXhP79+8c999wTlSpVKtA4v/zyS6xYsSJyc3MLtP9RRx0VEydOjKpVqxZo/3RSEefD5gwePDiuv/76YuX4rd122y0mTZoUtWvXTlnOdPHr+tO2bdsC7b927dr45ZdfCrRvzZo1Y9SoUXHccccVo8LSUVLH63Q7fhTW2WefHf/85z/zXQeKIicnJ+6+++44++yzU5Iv09/jTNGgQYN46aWX4phjjkl57uzs7Lj++uvjkksuKVQ/5wapcckllxT6vd+ckj5upnvN6bYuDRs2LGn8hBNOiJycnFSWFv3790+IDR8+fJN96tevHy+99FIcdNBBBRpj/fr1sXz58li7dm2B9m/atGmMGzcuttlmmwLtXxrmzJlTqP3TbU4VRSbdG6lI9thjj3j55ZejRYsWKc278847x/PPPx81a9ZMad7yoCS/C67t/qdu3bpJa/3444/j1VdfzbffiBEjksYHDRqUstrKg5tvvjnOOeeclOYs79eJJXXvLp3v22XymlRSa7Vr2PRQ0HNxnxcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQPlXuawLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACuexxx6LI488MiHep0+fuPDCC4uct3fv3pts79GjR9x+++1Fyt2uXbvYZpttEuKjR4+ONWvWFCjHAw88ED179sy3ff369fHaa6/F2LFjY/r06fH999/HwoULo0aNGtGkSZPYcccdo3v37tGtW7eoV69e0hz169eP8ePHx7777hsffPBBgeoqiEqVKsVTTz2V77jp5NBDD41Ro0ZFrVq1krYPHz48Bg0aFOvXr99knu+++y5ef/31pG1bb711bL311gnxb775Jr755ptC1fvWW28Vav/iSsd5WJHWhO233z7+85//RFZWVtL2b7/9Nh5++OGYOHFizJ49O3788cc8c7VBgwax0047RefOneOYY46JffbZJ2meAw88MG699dYYOHBgIV9Z2atI82Fz9tlnn7jlllsS4rm5ufHKK6/EqFGj4q233op58+bFihUrok6dOtGoUaNo165d3HLLLVGpUqWkeVu2bBn33XdfHH300UWuLd00aNAgJk2alPRz+NWsWbPisccei0mTJsWnn34aixYtioiInJycaNiwYey5555x+OGHx4knnph0fatcuXLcd9998cUXX8Qbb7xRUi+lWEryeJ2Ox4+COuCAA+Kmm25KiK9evTomTpwYzzzzTMyYMSO+//77WLFiRdSsWTOaNGkSLVu2jG7dusURRxyRb81ZWVlx8803x2effRbjxo0rVp3p8h5/8803+Z4DRURsscUW0bJly4T4woULY+7cuZt+kWUsJycnxo4dGx07dsx3n3Xr1sXUqVNjwoQJ8dZbb8UPP/wQCxYsiKysrKhbt260bNkyDjjggDj++ONjq622SprjmmuuiU8++SQee+yxzdbk3CA1unTpEldddVVCvCDHzO7du0fXrl1L/biZCTWny7r0q7feeitmzJgRbdu2TcjRu3fveOKJJwr7EpNq1apVwnfppZdeik8++WST/R566KFo165dvu1TpkyJJ554IqZOnRpz586NpUuXbmirXbt2tGjRIg466KDo169fdOjQIWmOhg0bxpNPPhmdOnXK9zyzNNfx2bNnF2r/dJtThZVJ90YqkqZNm8azzz4bDRs2zHeflStXxgsvvBBjx46NDz74IH744YdYtGjRhvO+5s2bxxFHHBE9evSILbbYIk/fXXbZJW6//fYYMWJESb+UjFGS3wXXdnmdfPLJUb169YT45ubjk08+Gf/9738TXn+rVq3igAMOiFdeeSWVZWakfv36xTnnnJMQd51YNvdy0/W+XSavSSW1VruG3bR0Oxf3eQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVAyVy7oAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgcMaOHRsrV66MatWq5YnvtNNO0apVq/joo48KnbNq1apx6KGHbnKfXr16xe23317o3BERRx11VNL4448/XqD+l112WRx77LH5tj/77LNxwQUXxHvvvZe0/bPPPovXXnstHnjggahZs2acd955ccEFF0StWrUS9q1bt26MHz8+2rZtG0uWLClQfZtz1llnxR577JEQX7RoUYwePTrGjRsX7733Xvzwww+xePHilIxZFH379o0HH3wwcnJykrZfffXVcfnllxco1yOPPBKPPPJI0rbLL788/v73vyfEhw8fHldddVXBCy5l6ToPK9KacPPNN0eNGjUS4uvXr4/LL788brzxxli1alW+/RcuXBivv/56vP7663HjjTfGfvvtF7fffnu0adMmYd/TTz89nnjiiZg8efJmXk16qUjzYXOGDRsWlSpVyhMbP358XHjhhTFnzpyE/X/44Yf4+OOPY9q0afHiiy/Grbfemu/rPuqoo6Jv377FrjFdPPbYY7Hddtslbfv666/jvPPOiyeeeCJp++rVq+Pbb7+NMWPGxJgxY+Liiy+OCy+8MC666KLIzs7Os2/VqlXjiSeeiJ133jmWL1+e6pdRbCV1vE7X40dBjRgxIs9nmZubG7fffnsMGTIkvv32203WfP/990fNmjXj3HPPjb/+9a9Rp06dhH2zsrLioYceil133TW++eabItWYTu/x3XffHXfffXe+tRx99NHx5JNPJsRfeOGF6Nu3b7790sHtt98e++23X77tTzzxRFxyySUxd+7cpO3ffvttfPDBBzFmzJi46KKL4qyzzoprr702qlevnrDvnXfeGVOnTt3snHBuUHzVqlVL+J5HFPyY+d///jdat25dqsfNTKg5ndal3xo2bFgMHTo0Id6/f/98j/WFdeqppyYdd1P+9Kc/xRFHHJG07Z133okzzjgj3nzzzXz7L126NGbNmhWzZs2KW2+9NY4++ui45557kh539tprrzj11FNj+PDhSXOl6zqernOqMDLl3khFkpWVFY8//ng0bdo0afv69evjrrvuiksuuSTmz5+fdJ9f59ajjz4aOTk5ce6558all16aZ26dfPLJRboWLa9K8rvg2i6vgQMHJsTWrl0b99133yb7rVq1Kh5++OE488wzE9oGDRoUr7zySspqzERNmzaNiy++OE/MdWLZ3ctN5/t2mbwmldRa7Rp209LtXNznBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQMWRvfhcAgIqtXbt2MWTIkBg7dmzMmTMnpkyZsqHtrLPOig8//DDGjx8fl1xySbRv3z5l42633XZx7rnnxpNPPhkffPBBLFy4MNasWRPr16+PZcuWxccffxyjR4+OP//5z7HlllumbNzCaN26dVxyySUxZsyY+OSTT2LBggWxdu3aWLt2bSxYsCA++eSTGDNmTFxyySXRunXrjB93iy22iEGDBsXjjz8eH3zwQSxZsiTWrVsX69atiyVLlsQHH3wQI0eOjIEDB8YWW2yRsnEBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2tmzZspg4cWLStiOPPLJIOQ899NCoUaPGJvc55JBDNrtPfpLVtWTJkpg0adJm++62225x2WWXJW1bu3ZtDBw4MI444oh47733ClTL8uXL4+qrr4499tgjPvjgg6T7tGjRIv75z38WKN/m1KhRIy699NI8sVWrVsX1118fLVq0iP79+8eTTz4Zc+fOjcWLF6dkzKI444wz4tFHH42cnJyEtvXr18fgwYPj8ssvL4PK0kM6z8OKsiY0atQojjjiiKRtxx9/fAwZMiRWrVpVqDqmTZsWe+21Vzz11FNJ26+66qpC5UsHFWU+FMTuu+++4c+/fk979uwZc+bM2Wzf999/Pw4//PC455578t3nggsuKFZ96eKkk06KLl26JG2bOnVqdOjQIZ544okC51uyZElccskl0aNHj1i6dGlC+9Zbbx1///vfi1xvSSmp43U6Hz8KqmXLlhv+vHjx4jj00ENj8ODB8e233xao//Lly+Oaa66J9u3b51tznTp14qabbipSfeXhPc4EXbp0iT/84Q9J23755Zfo27dv9O3bN+bOnVugfGvXro2bb7459ttvv5g/f35Ce926dTe7Vjg3SI3TTjstmjdvvmG7sMfMiNI/bqZ7zem8Lj300EOxYsWKhHjXrl1jyy23LFA9m5KVlRUnn3xyntjChQvjySefzLdPnTp14oorrkja9uCDD0bHjh3jzTffLFQdTz31VHTq1CnfY/Zf//rXyMrKKlTOspTOc6qgMuXeSEVz2mmnRefOnZO2LVu2LLp06RKnn3560mN1MqtXr47rr78+2rRpE5999lmetosuuqjY9ZYHJfldcG2X17777hu77bZbQnzChAnxww8/bLb/iBEjksaPOeaY2GKLLYpdXyY744wzom7duhu2XSf+v7K6l5uu9+0yeU0qqbXaNWxm8XkBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFQc2WVdAABAOqpcuXKcddZZ8cknn8Q777wTF198cfTs2TNat26d54G51apVi1atWkX37t3jmmuuibfffjtmzpwZRx11VJHH3mmnneLJJ5+Mzz77LP7973/H0UcfHTvvvHPUr18/KleuHFlZWVGzZs3Ycccdo3fv3nHTTTfF119/HXfffXc0btw4FS9/szp27BivvvpqzJkzJ6655pro1atX7LDDDtGgQYOoVKlSVKpUKRo0aBA77LBD9OrVK6655pqYM2dOTJkyJTp27Jhx49avXz+GDh0a3377bdx+++1x7LHHxs477xy1a9eO7OzsyM7Ojtq1a8fOO+8cffv2jTvuuCPmzZsX//nPf6JevXpFHhcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBTRo4cmTTep0+fIuXr1avXZvepWrVqdOnSpdC5t9tuu2jTpk1CfMyYMbFmzZrN9r/jjjuiSpUqCfE1a9ZE9+7dY9iwYYWuKSLis88+i7333jtef/31pO2nn356dOzYsUi5f+v444+Phg0bbtj+6aef4pBDDomLLrooFi9eXOz8qXDllVfG0KFDIzs7O6Ft1apV8bvf/S6GDh1aBpWlj3SfhxVhTejVq1dUrlw5If7YY4/l+/oLYvXq1XHcccfFa6+9lic+efLkuPzyy4uctyxVhPlQGOvXr4/jjjuu0N/T9evXxx/+8Id45ZVXkrbvueeeccABB6SixDJTrVq1+Oc//5m0bebMmdGlS5eYP39+kXI/++yz0a9fv6Rtf/rTn6JJkyZFyltSSup4ne7Hj8JYsWJFHHLIIfHiiy8Wqf+nn34ae++9d7zzzjtJ24899tjo1KlTofOWp/c4XWVnZ+d7LrhixYo46KCD4oknnihS7hkzZkSXLl1ixYoVCW0dO3aMnJycfPs6N0iNbbbZZsOfi3rM/LVvaR03073mdF6XlixZEo8//nhCvFKlSnHSSScVqa7f6tKlSzRr1ixP7IEHHojVq1fn26dKlSrxyCOPxMqVK/PEJ0yYECeffHKsW7euSLXMnj07Bg8enLStZcuWccQRRxQpb1lI5zlVUJlwb6SiqVWrVlx77bVJ25YuXRoHH3xwkc/7Pv/88+jcuXN8+umnecaj5L4Lru0SDRo0KGl8+PDhBer/7rvvxrvvvpsQz8nJiVNPPbU4pWW8atWqbfiz68S8yuJebjret8v0Namk1mrXsJnF5wUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUHFkl3UBAADpZscdd4zp06fHbbfdFjvssEOh+7dp0yaeeuqpGDduXNSvX79QfU866aR499134+ijj46srKwC96tUqVL0798/3nvvvdh3330LW3KhXHnllfHaa68V6QHMnTt3jtdeey2uvPLKjBl33333jffffz/OOOOMyMnJKXC/qlWrxuDBg2POnDmx1157FXpcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAzRkzZkysWrUqIb7PPvtE48aNC52vZ8+eebbXrl0br776asJ+vXr1KnTuI488Mml85MiRm+27//77R6dOnZK2/fWvf43JkycXup7fWrp0aRxzzDHx448/JrRlZWXFxRdfXKz8ERE77bTThj///PPPse+++8a0adOKnTcVsrKy4vbbb48rrrgiafuSJUuiW7du8eSTT5ZyZeklE+ZhRVgTdthhh6Tx++67r9A1bGzt2rXRv3//+OWXX+KBBx6IPfbYIw4//PBif7ZlpSLMh8K44oor4qmnnipy/1NPPTXWrFmTtC2/+jPFCSecEFtuuWVCfMmSJXHUUUfFypUri5V/1KhRMWLEiIR4Tk5ODB48uFi5U60kjteZcPwojDPPPDPeeeedYuX4teZFixYlbf/zn/9cqHzl7T1OV0cffXS0bNkyaduZZ54Zb775ZrHyz5o1K84777wN22+++WYcddRR0aZNm1i9enW+/ZwbpF5xj5kRpX/cTLeaM2FdGjZsWNL4H/7wh2LVFhHRv3//Ao/3qwULFsSf/vSnaNGiRfzrX/+K5cuXx88//xz9+vUrdj0PPfRQvPfee0nbDj300GLnLw2ZMKcKIp3vjVRUp5xySjRs2DBp29lnnx1vvfVWsfJ/9913cdJJJ8W6deuKlae8Kanvgmu7vOrVqxd9+/ZNiH/33XfxzDPPFDhPstccETFo0KAi11beuE7Mqyzu5abjfbtMX5NKaq12DZtZfF4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABVHdlkXAACQTlq3bh2vvfZatG3bNk88Nzc33nvvvXjggQfi/vvv3xCfOXNmPP/887F48eKEXD169IjXXnutwA/uPfnkk+P++++PGjVq5IkvWbIknn322bjttttiyJAhMWTIkLj99tvjtddeS3iYeuPGjWPy5MnRpk2bAr7iwrnuuuviiiuuiOzsvKeRixcvjokTJ+ap8bbbbouJEycmvDfZ2dlxxRVXxLXXXpv24x544IHxwgsvRNOmTRPavvjii5gwYULcfffdcffdd8eECRPiiy++SNhvq622ipdeein23XffAo8LAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQEMuWLYuJEycmxLOysqJXr16FytW2bdvYeuut88RefvnluO+++xL27dGjR+EKjYg+ffokxJYuXRqTJk3abN/zzz8/afy5556LW265pdC1JPPtt9/GgAEDkrb17t07WrZsmZJxIiL+8Ic/xCeffJKyfMWRk5MTI0eOjEGDBiVt//777+OAAw6Il156qXQLS0OZMA8rwpqw1VZbJY1/+umnha4hmY8++iiaNGkS/fr1i1mzZqUkZ1mpCPOhoGbOnBnXXXddsXJ8/vnnMWrUqKRtnTt3LlbusnbWWWcljd96663x+eefp2SM6667LtavX58Q79evX0ryl4RUHa8z4fhRUFOmTEn6vS+KL774Ii644IKkbX369ImmTZsWOFd5eo/T2TnnnJM0PmbMmJTNi2HDhsXtt98eBx10UOy9994xatSoyM3N3WQf5waplYpjZkTpHjfTseZMWJemTZsW77//fkJ85513jo4dOxa5rjp16iQ9t0s2VjLff/99nH/++dG8efPo3bt3LFiwoMi1/Nadd96ZNL7//vunJH9Jy4Q5VVjpdG+ksHbYYYdo3759Sn82vt4qLYMHD04af+aZZ+Lee+9NyRivv/563HbbbSnJVR6l8rvg2i6vfv36RfXq1RPi9913X6xbt67AeR566KFYuXJlQnzHHXeMQw45pFg1lgeuE8v+Xm663rcrT2tSKtdq17CZxecFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFBxZJd1AQAA6aJ69eoxduzYaNiw4YbY2rVr46abbortttsu2rRpE/369cvzsODJkydHly5dol69etGlS5eYMmVKnpytWrWKCRMmROXKlTc59s477xzDhg2LrKysDbF58+bFSSedFA0bNowjjjgizj777Lj00kvj0ksvjTPPPDP222+/aN68edx11115ctWsWTMeeeSRqFSpUnHejgQHH3xwXHTRRXli8+fPj/79+0eTJk2iW7dueWo8++yzo1u3btGkSZPo379/zJ8/P0/fv/3tb3HwwQen7bhNmjSJp59+OqpVq5YnPnbs2OjQoUO0aNEievToEX/84x/jj3/8Y/To0SNatGgRHTp0iHHjxuXpU6NGjRg9enQ0aNBgs+MCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUxsiRI5PG+/TpU6g8PXv2TIiNGTMmxo0bF7m5uXniW265ZbRv377AuevXrx/7779/Qnzs2LGxatWqTfatXbt2HHHEEUnbrrvuugLXUBBjxoyJOXPmJMSzsrLi2GOPTckYTz/9dDz99NMpyVVctWrVimeeeSbf1/bJJ5/EfvvtFzNnzizlytJPJs3D8r4mVK1aNWl845qKY+nSpSnLVdbK+3woqMsuuyzWrVtX7Dz33HNP0nj79u2jRo0axc5fFrbddtto165dQnzFihVx0003pWyczz77LJ577rmEePPmzWOXXXZJ2TipkqrjdSYdPwri6quvTkmeXz3wwAMxf/78hHjlypWjW7duBcpR3t7jdNW4cePo1KlT0rbrr78+ZePk5ubGmWeeGS+//HKB+zg3SK1UHTMjSu+4mW41Z9K6NHz48KTx/v37F7mm3/3ud1G9evUi9//VggULYsqUKcXO86sXXnghabxdu3ZRqVKllI1TEjJpThVUOt0bKYprr7023n777ZT+nHTSSaX+Onbaaad8z8WHDBmS0rH+9a9/pWytLk9S+V1wbZdo4MCBSeN33XVXofIsXrw4nnrqqaRtgwYNKnRd5Y3rxLK/l5uO9+3K05qU6vMW17CZxecFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFBxZJd1AQAA6eIvf/lLbL/99hu2ly5dGoccckicd9558dVXX222//PPPx8HHHBADB48OM+DQDt06BCXX375Jvv+5z//iWrVqm3YnjVrVuyxxx7x0EMPxZo1a/LtN2/evDjttNPijDPOyBNv3bp1/O53v9tszYVx44035tn+7LPPol27dnHvvfdu8sG/q1atinvvvTfatWsXn332WZ62G264IW3HHTp0aNSvX3/Ddm5ubgwaNCh69+4d77zzTr793nnnnejVq1cMHjw4T7xRo0Zx8803b3ZcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwhgzZkysWrUqId6lS5eoUaNGgfP07t07ITZ27Nj4/vvv46233kpo69mzZ4Fz9+zZMypVqpQQf/zxxzfb9/DDD48qVaokxGfPnh0vvPBCgWsoqJtvvjlpvFevXiWav7Q1atQoXn755TjkkEOStr/99tux3377xeeff17KlaWnTJqH5X1N+Pnnn5PGW7RoUeDxK5LyPh8K4ssvv4yxY8emJNfUqVMjNzc3IV65cuVo3rx5SsYobYcddljS+HPPPRcLFy5M6VgvvfRS0vhBBx2U0nFSIVXH60w6fmzOl19+GZMnTy52nt9atWpV3HXXXUnbunXrVqAc5ek9TmfdunWLrKyshPi7774b06ZNK4OK/se5Qeqk8pgZUTrHzXSsOZPWpfvvvz/pueLxxx8fVatWLVI9/fv3T4gtWbKkSLlS6cMPP4xly5YlxCtXrhz169cvg4oKLpPmVHHHqMg++eSTUh8zv/OtmTNnxtSpU1M61jfffBPjx49Pac7yIJXfBdd2eXXq1Clat26dEH/55ZeL9H0bPnx40nifPn2icePGhc5XXrhO/H9lfS83He/blac1KdXnLa5hM4vPCwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACg4sgu6wIAANLFgAED8mz/6U9/iilTphQ6z9ChQ+PMM8/MEzvvvPOiUaNGSfffaaed4pBDDtmwvWTJkujZs2csWLCgwGPecccd8eSTT+aJ/f73vy9E1Zu2ww47RPv27fPETjzxxJg3b16Bc8ybNy9OPPHEPLEOHTrE9ttvn3bjdunSJY4++ug8sYsvvjjuvPPOAo87dOjQuPzyy/PETj755Nh3330LnAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBzli5dGpMmTUqIV6tWLbp27VqgHE2aNIk999wzT2z27Nnx+eefR0TE6NGjE/r06tWrwDX26dMnIbZ8+fJ49tlnN9v34IMPThovSN+iyC/v3nvvHVWrVi1W7g8//DBeeeWVYuVIhebNm8fUqVOjffv2SdsnT54cBx54YMyfP7+UK0tfmTQPy/ua8N133yWNH3/88QUevyIp7/OhIMaNG5eSPBERS5YsiU8//TRpW/369VM2Tmnq3Llz0vjEiRNTPtbrr7+eNL7rrrumfKziSOXxOpOOH5uTbC1JhRdeeCFpfK+99ipQ//L0Hqez/fffP2m8JNaKwnJukDqpPGZGlM5xMx1rzqR1aeHChfH0008nxOvWrZv0HG1zdtxxx9hvv/0S4g8//HChc6Vabm5uvutFgwYNSrmawsmkOVUQ6XJvJN188sknpT7mvvvumzSe6rW1pPNmqlR/F1zb5TVo0KCk8REjRhQp30svvRSfffZZQrxKlSrRv3//IuUsD1wnbjpvadzLTdf7duVlTSqJ8xbXsJnF5wUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUHFkl3UBAADpYJtttoltt912w/b8+fPjgQceKHK+O+64Y8NDaKdPnx6nnXZaLFy4MOm+c+fOjd122y2GDRsWv/zyS1x77bXx9ddfF3rMoUOH5tlu37594QvPxz777JNn+6233sr3Ibub8vrrr8fbb7+9ydzpMO7GDwyfOXNmXH/99YUed8iQITF79uw8sYEDBxY6DwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwKaMHDkyabxPnz4F6t+jR4/IysrKExs7dmzSP/+qQ4cO0bRp083mrlq1anTt2jUhPm7cuFi5cuVm+7du3Tpp/NVXX91s36L45ptv4uuvv06IZ2dnR6tWrYqV+6WXXipW/1TYfffd47XXXouWLVsmbX/kkUeiR48esXz58lKuLL1l2jwsz2tCfu95v379om/fvpvtXxGV5/lQEK+88kpK8vwq2XczIqJBgwYpHae07Lzzzknjr732WsrH+u6775LGd9ppp5SPVRypPF5n2vFjU6ZMmVKs/vl58803Izc3NyG+3XbbRU5Ozmb7l6f3OJ3tsssuSePTpk0r5UoSOTdInVQfMyNK/riZjjVn2rp05513Jo3379+/0LWceuqpSePDhg0rdK6SsHjx4qTxdD+Py7Q5tTnpcG8kHX366aelPmZ+1wJTp04tkfHeeOONEsmbqVL9XXBt9z/169ePY489NiG+ePHieOKJJ4qc96677koaHzhwYJFzZjrXif+vLO/lput9u/KyJpXEeYtr2Mzi8wIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqDiyy7oAAIB00KxZszzbs2fPjvXr1xcr58CBA6NTp07RsWPHePTRR2PdunX57vv+++/HwIEDY+utt47bbrutSOPNnj07z3bjxo2LlCeZLbfcMs/2u+++W+RcG/fdOHdZj9uoUaPo3bt3ntgll1yS9AHUm7N+/fq45JJL8sT69u0bderUKXQuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA/IwePTpWrVqVEO/Zs2dkZ2dvtn/v3r2T5vzVrFmz4quvvsrTnpWVFT169Nhs7i5dukTNmjUT4o8//vhm+0ZE7LLLLknj77zzToH6F8Xbb79dqFoK6o033ihW/+Lq3LlzvPLKK7HlllsmbV+2bFkMHjw41qxZU8qVpb9Mm4fleU149dVXY8GCBQnx7OzseOyxx+K+++6LPfbYo0C5KoryPB8K4oMPPkhZroiIxYsXJ43Xq1cvpeOUlp122ilp/Msvv0z5WIsWLUoar1+/fsrHKo5UHq8z7fixKR9//HGx+udn8eLFSedbdnZ2bL/99pvtX57e43TWqlWrpPF33323lCtJ5NwgdVJ9zIwo+eNmOtacaevSSy+9FJ988klC/LDDDotmzZoVuIasrKzo169fQvydd94p07WiadOm0alTpzj55JOjQYMGSffJyckp5aoKJ9Pm1OaU9b2RdPTjjz/G0qVLS33cHXfcMWm8pL6zs2fPjtWrV5dI7kyU6u+Ca7v/OeWUU6JatWoJ8UceeSRWrlxZ5Lz33ntvrFu3LiHeokWLOPzww4ucN5O5TvyfsrqXm6737crLmlQS5y2uYTOLzwsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoOLY9NPjAAAqiCpVquTZLs6DoX81a9asmDZtWqH6LFy4MFasWFGk8Tbul5OTU6Q8ydSoUSPP9pIlS4qca/HixXm2kz1QuCzHPfzww/PMhwULFsSzzz5b5HEnTJgQCxcu3LBdo0aNOPjgg4ucDwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGNLly6NSZMmJcQbNGgQnTt33mTfnJyc6NKlS57Yjz/+GG+++Wae2JgxYxL69urVa7O19enTJyG2YsWKmDBhwmb7RkQ0atQoaXz+/PkF6l8UP/30U9J4w4YNi5V35syZxepfHL169YrJkydHvXr18t2nVq1aceedd5ZeURkk0+ZheV4T1qxZE9ddd13StqysrOjXr1/MmDEjvv7663jqqafi6quvjlNOOSU6deoUTZo0KdAY5U15ng8FMW/evJTliohYsmRJ0nh2dnZKxykt9evXT4j98ssvsXDhwpSPtWzZsqTx2rVrp3ys4kjl8TrTjh+b8uWXXxar/6bkN9+Szc+Nlaf3OJ01aNAgabwk3+eCcm6QOqk+ZkaU/HEzHWvOxHVp+PDhCbHs7Ow4+eSTC1zDIYccEttss01CfNiwYQXOURRVq1aNVq1aRffu3eOss86Km2++OcaMGROzZ8+OFStWxHfffRevvvpq3H///bH99tuXaC0lJRPn1KaU5b2RVDnrrLOiefPmKftp27Ztqb+G7OzsqFWrVtK2/D7/4lq/fn2JXGdkqlR/F1zb/c/AgQOTxkeMGFGsvN9++21MnDgxadugQYOKlTtTuU78n7K4l5vO9+3Ky5pUEuctrmEzi88LAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKDiqFzWBQAApINFixbl2W7cuHEZVVJ0W2yxRZ7tJUuWpCz38uXL82wX5KHL+WnQoEGe7aVLl6bVuHvttVee7XHjxsW6deuKPO7atWtj3Lhx0a9fvw2xPffcM0aPHl3knAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABsbOXJk9OrVKyHep0+feOWVV/Ltd8ghh0TNmjXzxMaNGxe5ubl5YmPGjImzzjorT+ywww6LqlWrxqpVq5LmzsrKSlrThAkT4pdffsm3pl9Vr149KlWqlBBftWpVrFy5crP9i2rRokVJ47Vr1y5W3gULFhSrf1H1798/hg8fnvS93Fjfvn3jD3/4Q9x9992lUFlmyNR5WB7XhF/ddtttcdRRR0WnTp3y3WfrrbeOrbfeOo466qg88eXLl8enn34an3zySXzyySfx8ccfx8yZM2PWrFn51l0elOf5sDlLly5NWa6IiPXr16c0X1mqUaNGZGVlJcSrV6+e0s/gV8nGioioWrVqyscqjlQdrzP1+JGfJUuWFKv/pvz8889J47Vq1dpkv/L2HqerGjVqRHZ2dkJ81apVaXPsdG6QGqk+ZkaU/HEz3WrO1HXp3nvvjWuuuSaqVKmSJ/6HP/wh/vGPfxQoR//+/RNiK1asiIcffrhA/Tdnq622ig4dOkSbNm1ixx13jO233z522GGH2GqrrfI9xygPMnVObUpZ3RtJpfnz58dXX31V1mUUS36f5bJly2Lt2rUlNu7PP/8cTZs2LbH8mSSV3wXXdv+z//77x84775wQnzVrVrz99tvFzj98+PDo3r17QrxXr16x5ZZbxnfffVfsMTKJ68T/KYt7uel63648rUkldd7iGjaz+LwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACqGymVdAABAOpg3b17k5uZueHDsHnvsEQ0aNIiFCxeWcWUFt88+++TZ/vbbb1OW+6OPPsqzvffeexc518Z9586dm1bj7rnnnnm233rrrSKP+au33347+vXrl+8YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxTVmzJhYvXp15OTk5IkfeeSRcd555+Xbr1evXgmx0aNHJ8ReeumlWLp0adSuXXtDrEaNGnHQQQfFxIkTk+beZ599okmTJgnxkSNH5lvPb9WsWTNpfMmSJQXqX1SLFi1KGq9Tp06x8i5evLhY/Yvq7rvvLtT+t912W0ydOjU++uijEqoos2TqPCyPa8KvVq9eHUceeWRMnjw52rVrV6i+NWvWjDZt2kSbNm3yxNeuXRsvv/xyPPTQQ/Hoo4/GL7/8Uqi86a48z4fNWbNmTUrzlSf5rW8REdWqVSvFStJLqo7XmXr8yM+KFSuK1X9T8nvPa9Wqtcl+5e09Tldl9T4XhnOD1MjEY2a61Zyp69KPP/4YY8eOjaOPPjpPvGXLlrHvvvvGa6+9tsn+tWvXjqOOOioh/thjj8XSpUsLVEMyu+66a/Tr1y+OO+64aN68eZHzZLJMnVObUlb3RsiratWqSePLly8v0XHT6fyhrKXyu+Da7n8GDRqUND58+PCU5B83blz8+OOP0bhx4zzxypUrxx/+8IcYMmRISsbJFK4T/6cs7uWm63278rQmldR5i2vYzOLzAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACoGLLLugAAgHSwaNGimDNnzobtypUrx1VXXVWGFRXe4MGD82y/+eabKcv90ksvxcqVKzds77rrrtGtW7dC5+natWu0bt16w/Yvv/wSL7/8clqN27Jlyzzbs2fPLvR4G3vvvfc2OQYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBxLVmyJCZNmpQQ33777WPXXXfNt1/Pnj3zbK9cuTImT56csN+aNWvi2WefTYj36tUr39x9+vRJiP3yyy8xYcKEfPv8VnZ2dtL4unXrCtS/qPLLn5WVVay8S5YsKVb/VHr++eejd+/esX79+oS2GjVqxGOPPRY5OTllUFn6ydR5WB7XhN9asGBB7LvvvjF06NCUfBaVK1eOQw89NO6+++745JNPon///sXOmU7K+3ygaIp7XCuvUnW8ztTjR35yc3OL1X9TilpzeXuP01V+r6uk3+fCcm5AOsjkdWnYsGFJ4wWZ+3379o0aNWoUOOfmNG/ePB5++OF477334oILLojmzZsXKU95kMlzKj/pdG+ERCV5zhcRSe9DVVSp/C6U1/PQwmrQoEEcc8wxCfFVq1bFQw89lJIx1q5dG/fff3/SttNPP73CfRauEzefvyTv5abrfbvy9D0oyfMW17CZxecFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFD+JX8aHgBABXTvvffm2R48eHBcffXVUalSpbIpqBBOP/302H///fPEHn744ZTlX7ZsWdx33315Yvfff3++DyJOZpdddkl4WPZ9990Xy5YtS6tx69atm2d73rx5BR4rP99+++0mxwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEiFkSNHJo336dMnabxNmzax7bbb5ok9//zz8csvvyTdf8yYMQmxXr165VvPkUcemRB75plnYvny5fn2Kc9yc3PLuoSIiHjsscfiiCOOiLFjx8YNN9yQdJ899tgj/vnPf5ZyZaRaeV8TVq1aFYMHD47WrVvHvffeG0uWLClSno1ttdVWcffdd8fDDz8cVatWTUnOdFDe5wOkSrocr4HCc24ARTdp0qT48ssvE+LHHXdcVK9efZN9+/fvnxCbM2dOvP7664Wuo0uXLjFjxow4/vjjIysrq9D9IyIWLlwYb7zxRjz44INx2WWXxe9///vo0KFDkeoh9ZxrpYf8Pofs7OwSHbdKlSolmj+T+C6k3imnnJL0XG369OnRsmXL6NixY0p+3nvvvaTjb7vtttGtW7eSfpmUY4W5d+e+Xeko6bXaNWxm8XkBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJRvlcu6AACAdHHHHXfE4MGDo0WLFhtil156afTt2zeGDh0a48ePj08//bQMK0zuuOOOi//+9795Ym+99VZMmjQppeNceuml0adPn2jSpElERDRq1CimT58eQ4YMiWHDhsX8+fOT9ttiiy1iwIABcdlll0WNGjU2xH/44Ye47LLL0mrcnJychIetLlu2bLM1bs7SpUvzbNetW7fYOQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADY2evToWL16deTk5OSJ9+nTJ4YMGZKwf8+ePZPmyM+ECRNi3bp1UalSpQ2xbbfdNnbdddeYM2dOnn1btWoVrVq1Ssjx+OOPb/Z1/GrdunVJ45UrVy5wjqKoUqVK0nh+9WSS//znP3H22WdHbm5uRERceumlceihh8aee+6ZsO8555wTkyZNigkTJpR2mWklk+dheVsT8jN37tzo379/DBw4MA466KDYa6+9okOHDrHzzjvH9ttvH1WrVi1S3uOPPz5q164dvXr1KnaN6aCizAcK7tdjwcZ+/vnnePTRR0utjgULFpTaWKUpk48f+eVds2ZNsXLkZ+N16Vebq7m8vcfpav369UnjJf0+F4dzA8pKJq9Lubm5cdddd8VVV12VJ16nTp046qij4uGHH07ab/vtt4/OnTsnxIcNG1bgsX91xBFHxNixY/OcT+Zn2bJlMXfu3Jg7d258/PHHef67aNGipH1WrlxZ6JrKWibPKdLbihUrksbr1KlTouPWq1evRPOnSlZWVlmXUCiu7f7fwIEDk8Y7d+4cb7zxRqnUcMYZZ8QzzzxTKmOlA9eJ/1Pa93LT+b6dNanwXMNmFp8XAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAED5lL5P7QYAKGXLly+P7bffPnbaaad4/PHHo02bNhHx/w+/veWWW+KWW25J6HP++efH+eefH0uWLIl33nkn3njjjRgzZkxMmzatxOrMzs6Ofv36xTXXXBPNmjXL07ZixYo46qijYtKkSSkf96effoqmTZvGdtttF//973+je/fuUb169bjmmmvimmuuKXCeCRMmxJlnnhlffvll2o2b7KH0ixcvLvAY+fn555/zbFepUiVq1KgRK1asKHZuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAXy1ZsiQGDBgQ9913X574nnvuGYMGDYo77rhjQ6xRo0ZxzTXX5NnvrbfeiuHDh+ebf+HChXHhhRfGjTfemCc+bNiw6NSpU57YPffck9B/9OjR8eijjxb49SxYsCDWrl0blStXzhNv2LBh1KxZM5YvX17gXIWxww47JI3PmzevRMYraevWrYvTTz897r777oS2tWvXxl577RX9+/dP2j5+/Ph47rnn4rDDDiuNUtNSJs/D8rYmbM7q1atj0qRJMWnSpALtn5WVFS1btoxu3brFoEGDYpdddknYp2fPnrF06dJo3rx5LFy4MGW1loWKNh/YvIULF0Zubm5kZWXliefk5MQZZ5xRRlWVH5l8/EimefPm8cknnxQrR3622267pPHvv/9+k/3K23ucrvJbKxo2bBjVq1ePX375pYwq2zznBpS2TF+Xrr766ujYsWP07NkzT/zBBx+MKVOmxNdff53Q54UXXkiIPfzww3HrrbcWauyHH344jj/++IT4smXL4m9/+1sMGzYsVq9eXaicG6tdu3ax+peFTJ9TpK/ly5fH/Pnzo1GjRnni1apVi+222y6++OKLlI9Zs2bNaNGiRcrz/qpSpUopy9W4ceOU5SoNru0iHnnkkWjVqlVZlxG9evWKK6+8Mq688sqyLqVUuE78n9K8l5vu9+2sSUXnGjaz+LwAAAAAANiU9u3bx9tvvx0RETfeeGP89a9/LeOKAAAAAAAAAAAAAAAAAAAAAAAAAACAzcku6wIAANLN3Llzo23btnHKKafEtGnTCtSnTp06cdBBB8WFF14YU6dOjU8//TROOumklNfWt2/feP/99+Oee+6JZs2a5Wn74osv4oADDijwg0eLascdd4ytt966yP233nrraNmyZcaMCwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkElGjx4dq1evToj36dMnz3aPHj0iKysroe/mjBkzJiG2zz77xBZbbLFhu0mTJrHPPvsk7Ddy5MjN5t/YvHnzksabNm1a6FwFlV/u77//vsTGLElHH3103H333Zvc55577oknnngiaVuXLl3ir3/9a0mUljEyeR6WtzUhlXJzc2Pu3Llx6623xq677hp///vfk+5Xq1atOO2000q5upJhPvBb69ati/nz5yfEa9SoEdWqVSuDisqfTD5+bKxJkybF6l+U3D/99NNm+5an9zhdrV+/Pn744YekbSU5L8pCRTw3IPUyfV0aNmxYQiwrKyv69euXED/44IOjefPmBcqxKdttt10cd9xxCfFVq1ZFly5d4j//+U/Sc9jCatiwYbFzlIVMn1Okr48++ihpvGPHjiUy3p577hnZ2dnFzrNu3bqk8dq1axc796+22WablOUqDRX92q5hw4Zx9NFHl3UZG5x22mkpmeuZwHXi5nOXxL3cdL9vV9HXpNLkGjaz+LwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANJbxXgSIQBAIeXm5sb9998fnTp1iq233jqOPfbYuOGGG2LixIkFeoDv9ttvHw888EBMmjQp6tSpU+x6unfvHu+++26MHDkyWrVqladt/fr1MWzYsNh9993j7bffLvZYm/L3v/89Jk2aFG3atEloW7BgQcycOTOmTJkSU6ZMiZkzZyZ9OHObNm1i0qRJ+T7oNJ3GBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyDSLFy+O5557LiF+8MEHR+3atTds9+7dO2GfMWPGbDb/xx9/HB999FGeWHZ2dhxxxBEbtnv16hVZWVl59lm1alWMHTt2s/k39v777yeN77333oXOVVAdO3ZMGp8zZ06JjVmSCvK5RkQMGDAgvv7666RtQ4YMiT333DOVZWWUTJ6H5W1NKCm5ublx5ZVXxtChQ5O2d+3atZQrKhnmAxv76quvksZ32223Uq6kfMrk48fGSuo8oFmzZtGkSZOE+Jo1a+Lzzz/fbP/y9B6nsy+//DJpvEOHDqVcSempKOcGpF6mr0vjx4+Pb7/9NiHev3//hNipp56aEPv444/j5ZdfLtSY3bt3j+zs7IT40KFD44033ihUrvxkZ2dH48aNU5KrtGX6nCJ9ffDBB0njnTt3LpHxUjVnFy1alDRep06dlOSPiGjVqlXKcpWWinxtd8opp0ROTk5Zl7FBs2bNokePHmVdRqlwnfg/pXkvNxPu21XkNamsuIbNLD4vAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAID0k/iEXQAA8pg3b148+eSTccEFF0S3bt3yPMz5xRdfjBtvvDEmTZoUixcvTuh72GGHxfPPP1/kB1IfcMABMXXq1Bg/fny0bds2of25556L9u3bx8CBA2PZsmVFGqOg/vKXv8Tll1+e52HAP/zwQ1x88cWxww47RMOGDaNt27ZxwAEHxAEHHBBt27aNRo0aRYsWLeKiiy6K77//fkO/rKysuPzyy+Mvf/lL2o772z7FlYocAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABTVy5MiEWE5OTnTr1m3Dnw877LA87V9//XXMmjWrQPnHjh2bEOvVq9eGP/fp0yehfdKkSbF06dIC5f+t2bNnJ4137ty50LkKolWrVrHFFlskxFetWhWffvppiYyZLn7++ec46aSTYv369QltVapUiUcffTRq1apVBpWVvUyfh+VpTShpl19+eaxduzYhvtdee5VBNSXDfOC33nvvvaTxvffeu5QrKZ8y/fjxW/vuu2+x+udnn332SRr/9NNPk56TbKw8vcfpbMaMGUnjJTUv0klFODcgtTJ9XVq/fn3cc889CfEddtghz2uoWbNmHHPMMQn7DR8+vNBjHnDAAUnjjz76aKFz5adDhw5RvXr1lOUrTZk+p0hfL774YtL40UcfHZUqVUr5eCeccEJK8ixatChpvEWLFinJHxFx4IEHpixXaanI13YDBw5MGj/ppJOiatWqJfozbdq0pGMPGjSoJF9y2nCd+P9K+15uJty3q8hrUllzDZtZfF4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOkju6wLAADIZG+//Xb89a9/ja5du0bDhg2jV69eMX369Dz77LnnnnHttdcWKu8222wTTz31VLz88sux3377JbS/+uqrceCBB8Zhhx0WM2fOLNZrKIjWrVvHP/7xjzyxF154IXbddde47rrr4rPPPsu37xdffBHXX3997LrrrvHcc8/lafvHP/4RrVu3TptxV61alRDLycnJd4yCqlatWoHGAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASIVRo0bF6tWrE+J9+vSJiIiDDjooatWqladtzJgxBc4/evTohFi3bt2icuXKUbNmzejSpUtC++OPP17g/L81efLkpPGePXtGpUqVipRzU359jzb28ssvx7p161I+Xrp55ZVX4vrrr0/atsMOO8TQoUNLuaL0kOnzsDytCSVtwYIFMWPGjIR47dq1Iycnp/QLKgHmA7/15ptvJo0fdNBBpVtIOZXpx4/fOuSQQ0pkHezevXvS+Kuvvlqg/uXpPY6IEqk5Fd54442k8fw+v/KkIpwbkFrlYV0aPnx45ObmJsT79++/4c99+/aNmjVr5mlfs2ZN3HvvvYUeb8stt0wa/+CDDwqdKz+HHHJIynJtSkl8xuVhTpGeJk+enPS73qxZszj66KNTOtY+++wTe+yxR0pyLVy4MGm8ffv2KclfuXLlOPzww1OSqzRV1Gu7gw8+OFq2bJkQX7hwYTz++OOxevXqEv0ZMWJE0rq6desW2267bUm//DLnOvH/lfa93Ey4b1dR16R0UJGvYdP1nsqmVOTPCwAAAACgvGnXrl0MGTIkxo4dG3PmzIkpU6ZsaDvrrLPiww8/jPHjx8cll1ySsr/f3nrrrWPgwIHxyCOPxIwZM+Knn36KlStXRm5ubqxYsSK++eabePHFF+Paa6+NvffeOyVjFtbuu+8ep59++oafzp07Fzvn9ttvHxdddFFMmDAhPvvss1i+fHmsX78+Vq9eHQsXLox333037rvvvvj973+f8PtNAAAAAAAAAAAAAAAAAAAAAAAAAACwKdllXQAAQHmxdu3aGDduXOyzzz5xxx135GkbPHhwNG7cuEB5jjjiiJg5c2YcddRRCW3Tp0+Pww8/PPbff/945ZVXUlJ3QVx11VVRuXLlDdvvvfde9OrVKxYsWFDgHAsXLozevXvHrFmzNsQqV64cV155ZdqMu2TJksjNzc0Tq127doHHys/GOZYvX16kB0EDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUxOLFi+O5555LiPfo0SMqV64cvXr1SmgbPXp0gfNPmzYtFixYkCdWp06d6Ny5c3Tt2jWqVq2ap2316tUxZsyYAuf/rZdffjmWL1+eEN9mm23i2GOPLVLO/FSpUiXOPvvspG1FrT8TXXbZZTF9+vSkbSeffHKceOKJpVxR2cv0eVie1oTfatq0abFzJPPtt98mjderV69Exitt5XU+UDSTJk1KGu/du3c0atSolKspfzL9+PFbjRo1it///vfFzvNbDRs2jBNOOCFp27PPPlugHJn6HierOSKidu3aha6rNOT3eeyyyy5x6KGHlnI1+XNuQDrI1HXpt7788suk54u/+93vokaNGhERceqppyYdc/78+YUer379+knjK1euLHSuZLKzs2PAgAEpyfWr0lzHy8OcIj399NNPSb/rERFXXHFF5OTkpGysq6++OmW53n///aTxpk2bxo477ljs/Mccc0xGXgtV1Gu7QYMGJY0/9NBDsXr16hIf/7HHHotly5YlxLOzs+P0008v8fHLmuvEsrmXu7F0vG9XUdekwnINWzRldU/F5wUAAAAAwMYqV64cZ511VnzyySfxzjvvxMUXXxw9e/aM1q1bb/gdm4iIatWqRatWraJ79+5xzTXXxNtvvx0zZ86Mo446qkjj7rzzzvHEE0/El19+GXfccUf8/ve/jz322CO22GKLDX/fU7169WjWrFkcdNBB8be//S1ef/31eOedd0r19/0aNmwYzzzzTNx5550bforz/6LsuOOOMWrUqPj000/juuuuiyOOOCJatGgRNWrUiKysrKhSpUrUr18/2rZtG/369YtHHnkkvvrqqzj//PMjOzs7ha8MAAAAAAAAAAAAAAAAAAAAAAAAAIDyyr9iCQCQYuvXr4/BgwfH22+/vSFWrVq1OProozfbt2/fvjF27NioX79+nvjMmTOjd+/e0bFjx5g8eXLKa96UOnXqRO/evfPE/vznP8eKFSsKneuXX36JP//5z3liRx55ZNKHtJbFuLm5uQkP8K5bt26hx9vYxjl+/vnnYucEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADYlJEjRybE6tatGwceeGD06tUrT3zp0qXx0ksvFTj3+vXrY8KECQnxXr16RZ8+fRLizz33XCxevLjA+X9r9erV8dhjjyVtu+SSS6JKlSpFypvM6aefHltttVVCfNWqVfH444+nbJx0t27dujj++ONj2bJlSdtvv/322H777Uu5qrJVHuZheVkTIiK23nrruP322+PLL7+MI488ssh58pOTk5M0/ssvv6R8rLJSnuYDxfPZZ5/Fe++9lxDPycmJAQMGpHSsunXrRtOmTVOaM92Vh+PHb51//vlRqVKllOSKiDjvvPOiWrVqCfHly5fHpEmTCpQjU9/jRYsWJY03b968SLWVtO+++y6mTp2atO1vf/tbSsc6/fTTY4899ihUH+cGpJNMXZc2NmzYsIRYrVq14phjjokWLVrEAQccUKA+BbF06dKk8UaNGhUp38aOP/742GGHHVKS61eluY6XlzlFerrtttuSxnfdddcYMmRISsY4/fTTo0uXLinJFRExd+7cWLBgQdK2U089tVi5K1euHFdeeWWxcpSVinht17Bhw6T3GSIiRowYUSo1rFixIh599NGkbX/84x9Tev2Urlwnlv693N9K1/t2FXFNKgzXsMVT2vdUfF4AAAAAACSz4447xvTp0+O2224r0u+ltGnTJp566qkYN25c1K9fv8D9/vznP8fMmTPjmGOOiezs7EKN2a5du3juuefiX//6V2HLLZIHH3wwmjVrlpJcxx9/fMycObPQ9+obNGgQN9xwQzz//PNRs2bNlNQCAAAAAAAAAAAAAAAAAAAAAAAAAED5Vbh/8RMAgAJZv3593HzzzXliGz+od2MdOnSIhx56KM/DkxcvXhx/+MMfom3btjF27NiSKHWz9tprrzwPSP7+++/jhRdeKHK+F198Mb7//vsN2zk5ObHXXnulzbg//fRTnu2WLVsWecz8cuT30HoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBUGTVqVKxZsyYhftlll0Xz5s3zxCZOnJh0300ZPXp0QuzII4+Mnj17JsQff/zxQuXe2I033hi5ubkJ8d133z1uvvnmYuX+Vbt27eLGG29M2nb//ffHjz/+mJJxMsWnn34aZ511VtK22rVrx6OPPhqVK1cu5arKVqbPw/KwJmy99dYxdOjQ+PTTT2PQoEGRk5MTt956azRo0KBI+fKz4447JsRWrFgRS5cuTek4Zak8zAdSZ/jw4Unjl1xySbRs2TJl49x0003x0Ucfxdlnnx3Z2dkpy5vuMv348Vu777573HDDDSnJdeCBB8YFF1yQtO2BBx4o1Jqbie/xvHnzksZbtmwZTZo0KXR9peGOO+5IGj/00EPjnHPOSckYe+65Z9x+++0xY8aMGDt2bHTs2HGT+zs3IF1l4rq0sVGjRiXN0b9//zjllFMiKysrT/zLL7+MyZMnF2msn376KWl83333LVK+32rWrFncdNNNxc6zsdJex8vDnCI9jRs3LmbNmpW07bzzzovTTjutWPkPO+ywlM3R35o2bVrS+IABA6JevXpFznvxxRfHzjvvXOT+Za2iXdv1798/cnJyEuJvvfVWvvO6JIwYMSJpvGnTptG7d+9Sq6OsuE4s/Xu5v5XO9+0q2ppUEK5hU6O0zsV9XgAAAAAA5Kd169bx2muvRdu2bfPEc3Nz47333osHHngg7r///g3xmTNnxvPPPx+LFy9OyNWjR4947bXXonHjxpsd9/LLL4+bbrop4e9JFyxYEOPHj4/bbrsthgwZEtdcc03ceuutMWHChFi0aFFCnvPOOy9uu+22Ar7aornooouia9euKcl16qmnxkMPPRQ1atTIE1++fHmMGzcuhg4dGldffXVcd911MWLEiHjzzTdj/fr1efY96KCDYuzYsQm/8wQAAAAAAAAAAAAAAAAAAAAAAAAAAL+V3k9DAwDIYBs/mHzrrbfOd9/s7Ox48MEHo0qVKhti33//fXTs2DHuueeeEquxIJo1a5Zn+8MPPyx2zrlz5+bZ3mqrrdJm3BkzZuTZbtOmTbHH3TjHxmMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACk2uLFi+O5555LiB944IEJsdGjRxc6/8SJE2P16tV5YjvssEPUr18/T2zt2rVFyv9bH3zwQYwcOTJp25lnnhnnnntusfK3bNkynn766ahWrVpC28qVK+Mf//hHsfJnqvvuuy/f932vvfaKa665ppQrKluZPg/Lw5pwxx13xBlnnBE5OTkbYttuu208/vjjUb169SLl3FjHjh1jxx13TIh/8803m+xXpUqVuO222/L9STflYT6QOnfddVfMnz8/IV6jRo146KGHombNmsUe47TTTov+/ftHnTp14pZbbol33nkn9t1332LnzQSZfvzY2LnnnhsDBgwoVo5ddtklHn300ahUqVJC29q1a+Pmm28uVL5MfI/nzZuX77HlzDPPLHS+0vDII4/Exx9/nLTthhtuiO7duxcrf9OmTePxxx+P7OzsiIjo2bNnvPHGGzF58uRo3Lhx0j7pfG5AxZaJ69LG1q5dG/fdd19C/KCDDoozzjgjIT5ixIjIzc0t0lhz585NGh84cGCR8v2qRo0a8cQTT0SjRo2KlSeZ0l7Hy8OcIj3l5ubG2WefnbQtOzs7hg8fHpdccsmG43Nh/P73v4+xY8em7Jj8W/l9Hxo3bhw33XRTkfNeccUVRe6bDiratV1+x4kRI0aUah1vvPFGzJkzJ2nboEGDSrWWsuI6Ma/SvJebzvftKtqaVBCuYVOjtM7FfV4AAAAAACRTvXr1GDt2bDRs2HBDbO3atXHTTTfFdtttF23atIl+/frFLbfcsqF98uTJ0aVLl6hXr1506dIlpkyZkidnq1atYsKECVG5cuV8x+3atWtceeWVeWJvv/12dO3aNRo1ahQ9e/aMs88+Oy699NK47LLL4pxzzokePXpEkyZN4oQTTki493zWWWdF7969i/FO5K9z584p+39Ndttttxg2bFhkZWVtiC1cuDD++Mc/RsOGDaNXr14xePDguPzyy+Piiy+OAQMGxN577x3NmzePhx56KE+ugw8+OM4777yU1AUAAAAAAAAAAAAAAAAAAAAAAAAAQPlU+Kd3AgBQID/99FOe7QYNGuS778knnxw777zzhu3169fHUUcdFXPnzi2x+gpq4wcaL1++vNg5ly5dmme7Ro0aaTPu9OnT82xv/IDlotg4x8ZjAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlISRI0dudp9169bFhAkTCp172bJl8dJLL212v+effz4WLVpU6PwbO+ecc2Lx4sVJ2/7973/HHXfcETk5OYXOe9hhh8Wbb74ZzZs3T9r+97//PT777LNC5y0vTj/99Pjqq6+Stl1wwQVx6KGHlnJFZSvT52GmrwmXXXZZ5ObmJsQPOeSQeP7552ObbbYpUt5f1atXL+66666kbc8888wm+1apUiXOOuusfH/SUabPB1JnxYoVccUVVyRt22uvveKVV16Jxo0bFzn/2WefHXfeeWee2B577BFTp06Nrl27FjlvJsn048e3336bZ3vYsGHx73//OypVqlToXD169IjXX389mjZtmrT9P//5T3z00UeFzpuJ73F+6+RFF10UBxxwQJFylqR169bFX/7yl6RtVapUiTFjxsQ555xTpNw777xzvPLKK7HddtsltDVt2jTmz5+ftF86nxtAJq5LGxs+fHhCLCsrK+G8YN26dXH33XcXeZyJEycmjR922GHxxz/+sUg5t9pqq3j11Vdjn3322RB75513ipQrP6W9jpeHOUV6evnll+OOO+7It/2aa66JmTNnRvfu3SM7O3uz+dq3bx+TJk2KRx55JKpWrboh/t1338WyZctSUvOjjz6acI76q1NPPTWuvfbaQuccMGBAntc3d+7cItdXVirStd2hhx4aO+ywQ0J8xYoV8cgjj5RqLRERI0aMSBo/7LDDYvvtty/lasqG68T/Ka17uel+364irUkF5Ro2dUrjXNznBQAAAABAMn/5y1/y/B3g0qVL45BDDonzzjsv3//v4reef/75OOCAA2Lw4MF57kN36NAhLr/88qR9srKy4l//+ldkZWVtiN1zzz3RsWPHmDRpUtL72b9as2ZNPPLII9G2bduYMWNGnrbrrrtus/UWVsOGDePRRx8t0t8bJjNs2LCoUqXKhu2PPvooWrduHXfffXesXLky337ffPNNnHTSSfHPf/4zT/ziiy+OmjVrpqQ2AAAAAAAAAAAAAAAAAAAAAAAAAADKn80/tRMAoALp0qVLHHjggSnJ9dsHnkfEJv+x8dNOOy3P9mOPPRavv/56Suooro0f1F63bt1i56xXr16e7SVLlqTNuBu/7wcccECxHkq85ZZbRufOnfPE3njjjSLnAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKKhRo0bFmjVrNrnPtGnTYuHChUXKP3r06M3uM3LkyCLl3tgPP/wQgwYNyrd94MCBMXfu3DjppJOicuXKm8236667xtNPPx2TJk2KevXqJd3n1VdfjRtuuKGoJZcLixcvjhNPPDHWr1+f0JaVlRUPPPBANGzYsAwqKxuZPg8zfU1499134/bbb0/atu+++8b7778fl112WZHmZNeuXePNN9+M3XbbLWn7448/Xuic6S7T5wOpdfvtt8fLL7+ctK19+/Yxe/bsOPPMMwu0tv1q9913j2eeeSZuueWWyM7OTmifPn16TJ48ucg1Z5JMP37ceeed8cknn+SJnXvuufH+++/HscceG1lZWZvNsfvuu8eYMWNi3LhxUadOnaT7fPHFF3H55ZcXqcZMfI/vuOOOpPGcnJx47rnn4h//+Ec0b968yPlLwtixY+Pee+9N2lapUqW4+eab46233orDDz+8QPlq1aoVl156abz99tvRsmXLhPbc3Nz485//HLm5uUn7OzcgnWXiurSxjz/+ON/zg9965pln4ttvvy3yOFOmTImffvopaduwYcPisssuK/A5SE5OTpx99tkxc+bMaNeu3Yb4zz//XORjTH5Kex0vD3OK9HX22WfHG2+8kW/7brvtFuPHj4+ffvopHnroobj00ktjwIABceyxx8Ypp5wSF154Ydx+++3x+eefx9tvvx2HHXZYQo5BgwbFypUrU1Lv2rVr46abbsq3/W9/+1uMHz8+6fnFxtq3bx/PPPNMDBs2bENs+vTpMWrUqFSUWuoqyrVdfuvhE088EUuWLCnVWiIiHnjggVi9enVCPCsrK04//fRSr6e0vPPOO3m2XSeW7r3cTLhvV1HWpIJyDZs6pXEu7vMCAAAAACCZAQMG5Nn+05/+FFOmTCl0nqFDh8aZZ56ZJ3beeedFo0aNEvb99ffonnvuuYj4/78PGTBgQNL/xyM/CxYsiN/97nd5/l6zdevW0bZt20LXvikPPvhgNGvWbMP2pv5uf3OOP/742HfffTdsL1y4MA4//PD44YcfCpzjb3/7W8yYMSMWLVoUQ4cOjW7dusXy5cuLXBMAAAAAAAAAAAAAAAAAAAAAAAAAAOVbwZ+qBgBQju2///4xZMiQ2H///ePdd9+NDh06RG5ubrFybvzA8e+++y7pfvXr149OnTrliY0YMaJYY6fS999/n2d71113jUqVKsW6deuKlK9y5crRunXrTY5RluO+9NJL8fXXX8c222wTERHZ2dkxePDguOKKK4o07llnnZXnocRz586N6dOnFykXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAYfz888/x/PPPR7du3fLdZ/To0UXOP3bs2Pjvf/+bb/vatWtj1KhRRc6/sUcffTR22223uOSSS5K2N2/ePB544IH4z3/+ExMnTow333wzvv/++1iwYEHUrFkzmjRpEi1btowjjjgiWrVqtcmxPvvss+jTp0+sW7cuZfVnqldffTWuu+66pO/7lltuGffee2/07NmzDCorG5k8D8vDmnDuuedGx44dY88990xoq1WrVlx11VVx2WWXxbRp0+Kll16KDz74IL744otYunRprFixIrKysqJmzZpRr1692GGHHaJdu3bRvXv3aNmy5SZf19SpU4tVdzoqD/OB1Prd734X06dPj2233TahrVGjRvHf//43Lr/88njmmWfiueeei6+//jp+/PHHWLFiReTk5ETt2rVj2223jTZt2kT37t1jn332yXes7777Lvr27Rvr168vyZeUVjL5+LFy5co4+eST4+WXX46cnJwN8Z122ikef/zx+Omnn+LZZ5+Nt99+O77//vtYtGhR1K5de0PN3bp122zNv/zyS/Tp0yeWLl1a5Doz7T2eOnVqvPrqq9G5c+eEtipVqsSFF14YF154YcybNy+++uqrWLp0adLvzBFHHFHkGopi0KBBsdNOO8V+++2XtL1Dhw4xceLEmD9/fkyaNCnefffd+PHHH2PBggUREVG3bt1o0aJFdOzYMQ4//PCoXr16vmNdd9118fzzz2+yHucGpLNMW5eSGTZsWBx44IGb3ac4Vq1aFUOGDImbbropoS07OzuuuuqqGDRoUDzwwAPxyiuvxEcffRQ///xzrFy5MurWrRuNGzeOHXfcMbp27Ro9evSILbfcMk+O3NzcOOWUU2L+/PnFqnNjqVrHf/jhhzj11FMLNGZ5mFOkpzVr1kS3bt1i8uTJSY+pv6pfv36ccMIJhc5/zTXXxJgxY4pTYoKbbropjjzyyKTfwYiI7t27R7du3eL111+PiRMnxldffRXz58+PrKysaNCgQey+++5x2GGHxR577JGn36pVq+IPf/hDnHjiiSmttzSV92u7xo0bx5FHHpm0bcSIEaVWx28tWLAgxowZE8cee2xCW//+/eOyyy6LNWvWlEFlJat///7x5ptvRtWqVTfEXCeW3r3cTLlvV97XpMJyDZsapXUu7vMCAAAAAOC3ttlmmzx/5zF//vx44IEHipzvjjvuiFNOOSX22WefmD59evz73/+OhQsXJt33ueeei+eeey7at28fubm5Rfo7qY8//jgmTZqU5//92HvvvWPGjBlFfQl5XHTRRdG1a9cN2//6179izJgxce655xYp34ABA/JsX3XVVfHVV18VKsf69eujZ8+eMX/+/Fi9enWR6gAAAAAAAAAAAAAAAAAAAAAAAAAAoOKoXNYFAACUtZycnHjyySejUaNGERHRrl27OPfcc+Pf//53sfJu/HD0/P6R9LZt20ZWVtaG7TVr1sSrr75arLFTaebMmbF+/frIzs6OiP9/8PsxxxwTI0eOLFK+o48+OurXr79he926dfHee++lzbi5ublxzz33xOWXX74hdv7558fw4cPjm2++KdSY2267bZx33nl5YsOHDy9k5QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEU3cuTI6NatW77tY8eOLXLur7/+OmbOnBl77LFH0vYXX3wxFi5cWOT8yVx66aWRlZUVF198cb771K1bN373u9/F7373uyKN8f7770e3bt1iwYIFRS2z3LniiiuiS5cusffeeye09ejRI/70pz/FbbfdVgaVlY1MnoeZviasXr06jjjiiJg4cWK0b98+6T5VqlSJAw88MA488MBijRUR8dNPP8UZZ5xR7DzpKtPnA6n1448/RpcuXeKFF16IrbfeOuk+TZo0iVNPPTVOPfXUIo/zww8/RNeuXeOrr74qco5MlcnHj9dffz0GDRoUd911V2RlZeVpa9iwYZx00klx0kknFSn3L7/8EkcffXTMnDmz2HVm2nvcr1+/mDlzZtSuXTvffZo1axbNmjUr9lipsmrVqujevXuMHz8+OnXqlO9+jRo1ihNPPDFOPPHEIo0zYsSIuPTSSze7n3MD0l2mrUsbe/LJJ+O2226LBg0aJG3/9ttvY/z48cUeZ+jQodGvX79o165d0vatttoqLrzwwrjwwgsLnfvCCy+MMWPGRMeOHYtbZoJUrONffPFFocbM9DlF+vr555/j0EMPjfvvvz+OPPLIlOW98cYb47LLLktZvl+tW7cujjvuuJgxY0Y0atQo6T7Z2dmx3377xX777VegnLm5uTFo0KCYPXt2KkstdeX92q5///5RpUqVhPjHH38cU6ZMKdVafmv48OFx7LHHJsQbN24cffr0iccff7wMqipZs2bNipNPPjkee+wx14llcC83U+7blfc1qbBcw6ZOaZyL+7wAAAAAAPitje85z549O9avX1+snAMHDoxatWrFtGnTCrT/O++8U6zxZsyYET179tywnarfTezcuXNcc801G7Zff/31uOiiiwr89/Ub22abbeKggw7asD1//vwYOnRokXLNmzevSP0AAAAAAAAAAAAAAAAAAAAAAAAAAKh4ssu6AACAsrZ69eq48cYb88T++c9/Rp8+fYqcs3PnzjFw4MA8saeeeirpvs2bN8+z/fnnn8fq1auLPHZBVa1aNWrUqJHnJ5kFCxbE1KlT88T+9a9/RdOmTQs95pZbbhn//ve/88ReffXVpA9JLqtxIyJuv/32WLJkyYbtGjVqxJgxYzb5UNmN1alTJ8aOHRvVqlXbEFuwYEHcfffdhaweAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACg6EaNGhVr1qxJ2jZ37tyYO3dusfKPGTMm37bHH3+8WLnzc8kll8Rpp50Wy5cvT3nu8ePHR6dOneLrr79Oee5Mtm7dujjhhBNi6dKlSdtvuOGGaNOmTSlXVbYydR6WhzXhp59+ioMOOihGjRqVknz5+eabb6Jz584xb968Eh2nLJWH+UBqffzxx7HvvvvGm2++WSL533nnndhzzz3jvffeK5H8mSBTjx8REf/H3n2HR1Gubxy/NwkJkBAghCJF6aD0jhRRWugCilIExUIRFFSQKIqHqmBDjwUREJEuvRcFBCnSCaFKE0MJJYQkhDSS3x/nIj/jTiDJzrbk+7kuruM+78zz3rvMvjOzJ2x++OEHvfDCC+muG1kRHh6u1q1ba926dab1dKfX+OzZs+ratatu3rxpSj9HuXnzplq2bKkZM2aY3js5OVkTJkzQK6+8opSUlAztw7UBXJ07rUv/Fh8fr9mzZ6c7/sMPPyg5OdnmeRISEtS2bVudPXvW5l53JSYmqn///vr4449N6/lvzlrH3fmYgmuLiopS586d1b9/f12/ft2mXtevX1evXr00fPhwk9JZu3jxopo2barTp0+b0m/w4MGaOXOmKb2cLTvf2/Xr18+wPm3aNAcnSWvjxo06f/684diAAQMcnMZxfv75Z3Xv3l1xcXGm9czp94n/lN5nd+72uV12XpOygntYczjqWpy/LwAAAAAAAADAXbly5Urz2Iz/jywkJEQ7duywuU9GRUZGpnmcJ08em3sGBgZq/vz58vT0lCRFRETomWeeUVJSUpZ7dujQQRaLJfXx8uXLTf3ZVQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMCIh7MDAAAAuILPP/9cBw8eTH3s6empxYsXa9SoUfL29s5Ur969e2vt2rXy8vJKra1atUr79+833N7f3z/NY1t/2XpGLVq0SLdu3UrzJz3jx49P87hkyZLavHmzqlSpkuH5qlatqk2bNqlEiRL37O0K816+fFnDhg1LU6tVq1aG565SpYq2bNmi6tWrp6kPGTJEERERGc4OAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALa6ceOGNm3aZDi2YsUKm/svX77csH7nzh0tXbrU5v7pmT59uqpVq6Z169aZ0u/SpUvq3bu3OnTooMjISFN6ZjdnzpzR4MGDDcd8fHy0YMEC5cmTx8GpnMsdj8PssiZER0erS5cu6tatm86fP29aX0lKSUnR7NmzVa9ePZ04ccLU3q4muxwPMFdYWJiaNGmikSNHKjY21pSesbGxGjFihOrXr6+wsDBTerozdzx/3DVr1iw1atRIf/75p829fv75Z1WpUkW///67CcnScqfX+JdfflH9+vW1bds2U/vaW1xcnF566SV16tRJZ86cMaXn6dOn1apVK40cOTLT+3JtAFfnTuvSv02dOtWwnpKSomnTppk2T3h4uBo0aKDVq1fb3CskJET169dPN7uZnLWOu/MxBdc3depUlS5dWiNHjtTp06czte+VK1c0ZswYVapUSXPnzrVTwv934sQJ1a9fX2vXrrWpz9WrV/XNN9+YlMo1ZMd7u1atWqls2bJW9aSkJP34448Oz/NPKSkpmjlzpuHYE088ofLlyzs2kAMtXLhQDRs21MGDB23uxX1iWul9dueOn9tlxzXJFtzDmsNR1+L8fQEAAAAAAAAApP/9fzf/VKRIESclybqCBQumeRwdHW1zz9mzZ6tEiRKS/ve5d58+ffT333/b1LN27dppHq9cudKmfgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBGeDg7AAAAgCtITEzUs88+q6tXr6bWPDw8NHr0aJ06dUrvv/++atWqJQ8P68snHx8f1ahRQ0OHDlVISIhmzZolPz+/1PErV65o8ODB6c7t5eWV5nHp0qX17bffmvKnVKlSJrw60vr16zV//vw0tcqVK2v//v2aM2eO2rdvb/hl9kWKFFH79u01Z84c7du3T5UrV04zPmfOHG3cuNHl5pWk77//3uoXydepU0f79+/XvHnz1LVrVz388MMqWLCgChYsqIcfflhPPfWU5s2bp/3796tWrVpp9l26dKnmzJlzzzkBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwB4WLlxoWF++fLnNvfft26dLly5Z1X/77Tddu3bN5v73cvbsWbVt21b16tXTwoULFRsbm+keBw8eVP/+/VW6dGnNnj3bDimzl1mzZmn+/PmGY5UrV9YXX3zh4ETO547HYXZaExYtWqQyZcqoW7du+uWXXxQfH5/lXjdu3NCMGTPUoEED9e7dW5cvXzYxqevKTscDzJOYmKgJEyaoTJkyGj9+vMLCwrLU5++//9aoUaNUqlQpTZo0SXfu3DE5qftyx/PHXXv37lWVKlU0cOBAnTlzJlP7xsXF6eeff1bt2rX1zDPP6Pr163ZK6V6v8cmTJ/XYY4+pQYMG+u677xQSEqLk5GS7zWemlStXqlKlSurVq5e2b9+ulJSUTPc4dOiQ+vfvr0qVKmnTpk025eHaAK7Mndalfzpy5Ih27dplVd+4caPOnTtn6lxXr15Vhw4d1K1bN/3++++Z3n///v3q3r27atasqYMHD5qa7V6ctY676zEF9xATE6MJEyaofPnyql27tgYPHqwZM2bol19+0Z49e3Ts2DEdOHBAW7du1U8//aR33nlHjz76qB544AF98MEHhtd5Pj4+hnMlJSXZlDUiIkLt2rVT8+bNtXPnzkztGxkZqY8//ljly5e3KYOrym73dgMGDDCsr169WuHh4Q5OY2369OmG18MWi0X9+/d3QiLHOXTokOrWravnn39ex44dy9S+3Cfem9Fnd+76uV12W5PMwD2s7Rx5Lc7fFwAAAAAAAADkbBcuXEjz/wfWqFFDAQEBTkyUeXXq1Enz+OTJkzb1Cw4OVlBQUOrjTz/9VKtXr7appyTVrFkzzeNDhw7Z3BMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC4H0tKBn9Dt8VisXcWAG6qevXqql69uiQpJSVFZ86c0a5duwx/4SkAuLpq1app9erVKlWqlOF4UlKSIiIiVKRIEUlSfHy8vL29071WunLlilq0aKHQ0NB053zzzTf16aef2h7eQJ06dbR//37DsZUrV6pDhw5pave65vP29taqVavUqlWrdLdJTEzUzZs3JUn58+dXrly50t123bp16tSpkxITE+/1FJw2ryTlzZtXa9asUbNmze677b388ssv6tixo+Li4mzqAwCupECBAhr53khnx0A2t2nTJq1ds9bZMQAAAAA42MeffOzsCMgBjh09phkzZjg7BgCYYshiycfX2SmQnYWFSnOHOTsFACA9FotFdevWVcWKFVN/9ickJEQhISFOTpYz8TO1AAAAAAAAAAAAAAAAAAAAjmWxWFSvXj1VqFCBn6cFkGG2/Iw339UOID38uxLAXE888YTatW/n7BjAPfG9qQBgu7bt2qp58+bOjgGka8niJdq5c6ezYwCAW+vZs6dq1a7l7BhAuqZPn67jx447OwYAuLU333pTDzzwgLNjAPf06Sef6vLly86OAQBubcAsyb+Is1MA6ZvcVUqIdXYKAM7Cd7W7Fn6mFoCryZ07t1q1aqX69eurevXqKlGihPLnzy8/Pz/Fx8fr5s2bioiI0JEjR3To0CFt2LBBf/31l7NjI5vhOHSuvHnzqlmzZqpevboqV66scuXKKV++fPLz85Ovr69SUlIUExOj6OhoRUVF6fTp06nXk9u3b1dSUpIpOTZv3qzHH3889TH/VhHZQd26ddWkSRPVqVNHDz30kIoUKSJfX195eXkpISFBUVFRioyM1IkTJ3TkyBH9+uuv3KtlgjufP+rUqaNWrVqpZs2aKleuXGruuLg43bx5U5cvX1ZISIh2796tdevW6datW07J6W6vsa+vrx544AEVKFBABQsWVK5cuQy3W7NmjYOT3VuxYsX0+OOPq2HDhipfvrxKlSolPz8/5cmTR8nJybp586YiIyN1/Phx7d+/X5s2bdKxY8fslsdVrg0AI+62LjlDpUqV1KRJEz366KMqX758mjUxOjpakZGROnbsmA4cOKDVq1fr1KlTzo6cKqPr+O3bt7V582ZT5uSYgivz8PDQnTt3DMceeeQRU68HSpUqpaCgID3++OMqXry4ChcurICAACUlJSkyMlJXrlzRgQMHtH37dq1du1YJCQmmze0OuLdDZqX3//vd6/OuqlWrql27dqpZs6YqVqwof39/7hNhiDUpLe5hzeGoa3H+vgAAgLPxXe0AsoLvagdgD/y7EgA5yeHDh1W1atXUx19//bUGDx5stV3t2rW1b98+SdInn3yi4cOHOyxjeipXrqzDhw/Ly8tLkpSYmKgHHnhA169fz1K/Jk2aaMuWLfL09JQk7dy5U02bNk3zswGPPfaYfvvtt9THU6ZM0cCBA+/bOyYmRr6+vpKk2NjY1P/+p7x586p27doqX768/P395eHhoejoaP311186ePCgrl27lqXnBQDIGH6/DJyB3xcDICfh97rAGdasXmPav28BAFfHuRbOwu9GA5CTtBos1erg7BTIaTb8Vzq42tkpAMCx+K5218LP1AIAAAAAAAAAAAAAAAAAADgW39UOICsy8jPeXg7IAQAA4DYOHz6smjVr6quvvlL37t2tfoGNl5eXihQpkvrYx8cn3V6LFy/WwIEDdfXqVbvldaSEhAS1b99e7733nt59993UL4H/p1y5cikwMPCefRITEzVu3DhNmDAhQ7/o1FnzSv/74vhWrVpp0qRJev311+Xh4ZGh/e5KTk7WZ599pnfeeYdf6goAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAdhYXF6eVK1dq5cqVzo6CHIzj0LliY2O1du1arV271qk5PD09U//7zp07TkwCmGfv3r3au3evs2NkW+58/ti3b5/27dvn7Bj35W6v8a1bt3Tq1Clnx8i0y5cva/78+Zo/f76zo0hynWsDwIi7rUvOcOLECZ04cULTp093dpRMc8Y6zjEFV+bv75/uWEREhKlz/f3335o2bZqmTZtmat/sgns7OEJoaKhCQ0OdHeO+OHc6H2tSWtzDmsNR1+L8fQEAAAAAAABAzjNz5kx98sknqY8HDRqkGzdu6D//+Y9L/8x44cKFtWjRInl5eaXWfvjhB12/fj1L/QIDAzV//vzUn5mPiIjQM888Y8pr4OnpKV9f39THly5dSjPesmVLDR06VK1atZK3t7dhj5SUFO3evVvffvut5syZo6SkJJtzAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARLVoXAABGRRJREFUIPvzcHYAAAAAVxMREaGePXuqZs2amjJliq5du5bhfa9cuaIZM2aoVq1aevrpp3X16lU7JnW8xMREffDBB3rkkUf06aefZur5Xb16VZ988okefvhhjRkzJlNfqO6see/O/cYbb6hGjRqaM2eOYmNj77tPbGysZs+ererVq2v48OF8eTwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAOUqBAgdT/joqKcl4QAAAAAABcQKVKlQzriYmJCg8Pd3AaAAAAAAAAAAAAAAAyb8qUKTp79mya2nvvvacjR47o9ddfV7ly5ZyUzJifn5/69eun0NBQValSJbV+5MgRDRs2LMt9Z8+erRIlSkiSUlJS1Lt3b4WFhdmcV5L8/f3TPI6JiZEkBQQEaMWKFdq4caPat28vb2/vdHtYLBY1aNBAM2fO1IEDB1S7dm1TsgEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACB783J2AAAAAFcVEhKigQMH6tVXX1XlypVVp04dlSxZUtWqVVPPnj0lSX/88Yfmz5+vsLAwhYaG6vjx45me57PPPtNnn31mdvz76tixoyTpP//5jz744INM7fvnn39q2LBhGjZsmMqXL6969eqpVKlSKlCggPLnzy9JunnzpiIjI/X3339rz549OnXqlM2ZnTWvJIWGhuq5555T7ty51bBhQ1WtWlWlSpWSr6+vJOnWrVv6+++/FRoaql27dikuLs6UeQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOA+/Pz8VKlSpdTHly9fdmIaAAAAAACcr379+ob148ePOzgJAAAAAAAAAAAAAABZc+vWLXXt2lWbN29WgQIFUuuVKlXSF198oS+++EIREREKCwtLHXvggQdUrFgxu/xMed26dfXBBx+kqVksFuXJk0dFixZV5cqV5enpmWb89OnTateunaKjo7M0Z3BwsIKCglIff/zxx1qzZk2WehnJnz9/mse3bt1SsWLFtG3bNpUvXz7T/apWrarff/9d3bt314oVK8yKCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgGzIy9kBAAAAXF1KSoqOHTumY8eOSZJq166tnj17SpK2bdumyZMnOzGd7fz8/CRJt2/fztL+p06d0qlTp8yM5NLzxsXFacuWLdqyZYvD5wYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBr+/TTT+Xt7Z36ePfu3U5MAwAAAACA87Vs2dKwvm/fPgcnAQAAAAAAAAAAAAAg6w4ePKgGDRro559/VvXq1a3GAwICFBAQkPq4V69e6tWrl6KiorR//3798ccfWrFihXbs2GFzliJFiqhDhw4Z3v7rr7/WsGHDFBcXl6X5mjRponHjxqU+3rFjh959990s9UrPP38OX5KSk5O1bNkylS9fXpKUlJSkefPmacmSJdq7d6+uXr2qhIQEBQQEqEKFCmrVqpUGDhyoBx54ILVHnjx5tHDhQjVv3tyU1x0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADZk4ezAwAAAMC5GjduLEm6cOGCk5MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA7snLy0tTpkxRv3790tRnzpzpnEAAAAAAAGSSr6+v6T1LlCih9u3bG46tX7/e9PkAAAAAAAAAAAAAALCnkydPqmbNmnr++ee1Y8eODO3j7++vxx9/XCNGjND27dt1+vRpPffcc3ZOmlbnzp3VpUuXLO0bGBio+fPny9PTU5J0/fp1Pfvss7pz546ZEa00atRIDRo0kCTt27dPlStXVp8+fbRs2TKFhYUpPj5eKSkpun79unbt2qWxY8eqdOnS+uSTT9L08fHx0ezZs5U3b1675gUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAID78nB2AAAAADiHxWLR5MmT1bBhQ0nS2rVrnZwIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcD9FixbVpk2b1L9//zT1efPmacuWLc4JBQAAAABABnl4eGjUqFH6888/VaRIEVN7BwcHy9PT06oeFxendevWmToXAAAAAAAAAAAAAACOkJKSolmzZqlx48YqWbKknn76aX388cdav369Ll++fN/9y5Ytq59++kkbNmyQv79/ljJcv35dW7Zssfqza9cunTp1SsnJyWm2L1GihObOnatvvvlGFoslU3PNnj1bJUqUkPS/5967d2+FhYVlKXdmeHh4SJJ27Nihxo0b6/Tp0/fdJyEhQcOHD9drr72Wpl6mTBkNHDjQLjkBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADg/rycHQAAAACOV7BgQc2bN09BQUGSpHPnzmn06NFOTgUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC4lxIlSmjPnj164IEH0tTXrVunF1980UmpAAAAAADImFKlSmnu3Llq0qSJJGnJkiVq2bKl4uLibO7dokULDRo0yHBswYIFioyMtHkOAAAAAAAAAAAAAACc6cKFC1q8eLEWL14sSapdu7b27dsnSdq8ebP27dun6tWrq0GDBsqfP3+afVu1aqVff/1VjRs3VkJCQqbm/eOPP/TEE0+kO+7v76+OHTtqxIgRqlatWmp94MCBiomJ0dtvv52heYKDgxUUFJT6eNKkSVq7dm2mstoiOjpaXbp0UXx8fKb2++qrr9SoUSP16NEjtTZ48GB9+umnZkcEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABANuDl7AAAAADu5uLFi/rggw8kSTt27HBymqypUqWKWrZsKUk6fPiw2rVrp+vXrzs5FQAAAAAAAAAAAAAAAAAAAAAAAJDW5s2bDetPPPGEg5Mgu/n666/1yCOPWNUHDhyo48ePOyER/s0d3//umBkAAACwBdfAcDUck66PvyMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2dWFCxe0c+dOde3aNbU2bdo0vfrqq0pMTHRiMgAAAAAA7q1Lly6aMWOGChQokFpr3LixNmzYoK5du+ratWtZ7t28eXMtXrxYFovFaiwpKUnjx4/Pcm8AAAAAAAAAAAAAANzBvn37NHz4cEmSl5eX2rRpo1GjRqlevXqp29StW1cTJkzQsGHDTJ07KipKc+bM0YIFCzR58mQNGjQodWz48OFauXKltm3bds8eTZo00bhx41Ifb9++XSNHjjQ15/3897//1ZUrV7K077vvvqvu3bun/uxC6dKlVbVqVYWGhpoZEQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANmAl7MDAAAAuJvLly9rzJgxzo5hk99//13vvvuuqlWrpgEDBujWrVvOjgQAAAAAAAAAAAAAAAAAAOASfHx8VLVqVZUsWVL58+eXv7+/8ubNq8TEREVFRSkqKkoRERE6evSoLl265Oy4AAAA2d7jjz/u7AjIpmrXrq2GDRta1f39/Z2QBkbc8f1vVmZvb2/DekJCgin9AQAA4Bqyw3WfO163I3vjmHR9/B0BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyM5eeOEFVatWTaVKldLQoUP13XffOTsSAAAAAAD3VbFiRRUoUMCq3rRpUx05ckTBwcGaPXu2EhMTM9wzICBAw4YN07Bhw5QrVy7Dbb744gv9+eefWY0NAAAAAAAAAAAAAIDbSUpK0qpVq7RmzRp9/fXXGjBgQOrYoEGDNGnSJF25csUu8w4ePFhFixbV008/nVofP368HnvssXT3K1SokObPny9PT09J0rVr1/Tss8/qzp07pme8l59//jnL+547d0779u1T3bp1U2t16tRRaGioGdEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQjXg5OwAAAACcY9KkSc6OAAAAAAAAAAAAAAAAAAAA4HQeHh5q1qyZnnnmGTVp0kSVK1eWl1fG/snN1atXdeDAAa1YsUKLFy/W5cuX7ZzW9b3++usqUKCA0+b//ffftWnTJqfND5jF6L30559/at68eQ7P8uqrryowMNCqPmnSJMXFxTk8DwAAQHZXsWJFnThxwnCsUqVKOnnypIMTAQAAsxUoUEAPP/ywypYtq0KFCsnX11e5cuVSYmKibt26pevXr+vMmTM6duyYIiMjnR1XkntmdnVc9wEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGQ/0dHR6ty5szw9PXX48GFnxwEAAAAAIEM++eQTdenSRQ0aNLAaK1KkiGbMmKGPPvpIq1at0tatW3Xy5EmFhYXp1q1bio+Pl5eXlwICAlSoUCHVqlVLzZs3V/v27ZUvX7505zxw4IDeffddez4tAAAAAAAAAAAAAABcVnJysgYNGqR69eqpTp06kqTcuXOra9eumjJlit3mHTp0qLp27SoPDw9JUtOmTVWyZEmFhYUZbj9nzhyVKFFCkpSSkqLevXvrwoULdssnSfHx8WkeJycnKyQkxKae+/fvV926dVMflyxZ0qZ+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyJ68nB0AAAAAAAAAAAAAAAAAAAAAAAAAcDR/f38NGzZM/fr1U9GiRbPUo3DhwmrdurVat26tL7/8Ups3b9aYMWO0detWk9O6jzfeeEOlS5d22vwfffSRNm3a5LT5AbMYvZeSk5N14cIFh68xr732mipXrmxV/+qrrxQXF+fQLAAAAAAAwFz9+vVTrVq10tTmzJmj33//3UmJ/l/37t3VrFkzh887bdo07du3z/S+1apVU58+fRQUFKSqVavKYrHcd5+UlBSFhoZq3bp1mjVrlkJDQ03PdS/umBkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwtqNHjzo7AgAAAAAAmXLnzh116NBBO3bsUIUKFQy3KVKkiF588UW9+OKLNs935swZtWvXTgkJCTb3AgAAAAAAAAAAAADAXSUnJ2vy5Mn66aefUmvNmjXTlClT7DbnhQsXtHv3bjVs2DC11qBBA4WFhVltGxwcrKCgoNTH69evV2xsrB577LEMz1ezZs00j4sXL261f0hIiCIjI1Mf37hxI834jRs3lJycnOE5jVy9ejXNY39/f5v6AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIHvycnYAAAAAAAAAAAAAAAAAAAAAAAAAwFG8vLw0bNgwvf322ypYsKBpfT08PNSiRQu1aNFCGzdu1NChQ3X06FHT+gOAh4eHfvrpJ1WvXl03b950dhwAAAAAAODmgoKCNGXKFFksljT1AwcO6Pfff3dSqv/Xpk0bPf/88w6fd/Pmzdq3b59p/Zo1a6YxY8bosccey/S+FotF1apVU7Vq1TR8+HBt2bJFo0aN0rZt20zLZ8QdMwMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACDrrl27pscee0yLFy9Wo0aN7DbP3r171aFDB4WHh9ttDgAAAAAAAAAAAAAA3MWOHTvSPC5ZsqTd5zx9+rQaNmyY+rhYsWKG240bNy7N4zZt2qhNmzY2zd2pUyd16tQpTa1WrVo6ePBg6uOoqCjduXNHnp6ekqTk5GSb5jSrBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALI/L2cHAAAAAAAAAAAAAAAAAAAAAAAAAByhbNmymj9/vurVq2fXeVq1aqW9e/dq0KBB+uGHH+w6F4Cc5cEHH9S3336rnj17OjsKADto3Lix3nvvPav6tm3bNGHCBCckAgAAzsS1AQB7Kl68uGbPni2LxeLsKOny8/NzdgSbFChQQP/973/13HPPmdbz8ccf19atW/XDDz9o6NChioqKMq235J6ZzZKdzrvZ6bnA/XE8AoD9sdYCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACzXL58WY8//rjeeecdjRgxQnnz5jWtd3x8vD799FN98MEHSkpKMq0vAAAAAAAAAAAAAADu7Nq1a2keBwQE2H3OmJiYNI99fHwMt/P09LR7Fkk6e/asVe306dOqWLGiJKlgwYI2zxEYGJjmcWRkpM09AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkP14OTsAAAAAAAAAAAAAAAAAAAAAAAAAYG/t2rXTggUL5Ofn55D58uTJoxkzZqh+/foaOHCgQ+YEkDP06NFDq1at0ty5c50dBYDJihYtqjZt2ljVY2JinJAGAAA4G9cGAOzFw8ND8+fPV2BgoLOj3JOjPsu1h4oVK2rNmjUqV66cXfr37dtXjRo1Utu2bXX27FlTerpjZjNlp/NudnoucH8cjwBgf6y1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADATImJiRozZoymTZumV199VX379lXx4sWz3O/mzZuaOXOmPvvsM50/f97EpAAAAAAAAAAAAAAAOEfLli2VmJio3377zeZePj4+aR7HxcXZ3PN+ChYsmOZxZGSk3edMT0REhG7evGlV3759uypWrChJ8vLyUqVKlXTixIksz/PII4+keXzu3Lks9wIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAED25eXsAAAAAAAAAAAAAAAAAAAAAAAAAIA9Pfnkk1q4cKG8vb3vuV1kZKR++eUXbd26VcePH9f58+cVHR2t+Ph4eXl5KV++fCpYsKAqVqyo6tWrq0WLFqpTp849ew4YMEDx8fEaOnSoic/I/YSFhSkyMtLu81y+fNnucwCu4JtvvtHvv/+u8+fPOzsKAAAAAABwM+PGjVPTpk2dHeO+/Pz8nB0hS6pUqaKtW7cqICAgQ9snJSUpKipKCQkJ8vb2lr+/v7y87v+1UJUqVdKuXbvUuHFjnTp1KsdlBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgP1cvHhR7733nkaNGqXatWvr8ccfV7169VS2bFmVLl1a/v7+Vr8f8vbt27pw4YJOnz6tffv2afPmzfrtt9+UmJjopGcBwCwWi8XZEQAAAAAAAAAAAACna9q0qcaPH6+mTZvqwIEDqlOnjlJSUmzqWaFChTSPL126ZFO/jKhWrVqax+Hh4YbbVapUyea56tevr59++in18YIFCzRq1KjUx+n9TMFvv/2mvn37pj7u3LmzJk6cmKUMhQoVUuPGjdPUdu/enaVeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyN68nB0AAAAAAAAAAAAAAAAAAAAAAAAAsJc2bdpo0aJF8vJK/5/RhISEaMKECVq2bJni4+PT3S48PFyStGfPHs2ZM0eSVKZMGQ0ZMkQDBgyQj4+P4X5DhgzRhQsX9PHHH9vwTNzbW2+9pYULFzo7BpBt5M+fX7Nnz1azZs2UkpLi7DgAAAAwUVxcnPbu3ZvuGAAAtggKClJwcLCzY2SIr6+vVe3y5csKCwuz67w3btzI8r4lS5bUhg0bFBAQkO42iYmJWrp0qZYtW6Zdu3bp3LlzaT7fsVgsKl26tBo2bKguXbqoc+fOypUrl2GvIkWKaOPGjapfv76uXr2aYzJnF1z3AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAV5ecnKy9e/cafqeyp6enfHx8lJKSori4OH6nGgAAAAAAAAAAAAAg2/L29tbixYtVuHBhSVKtWrX0xhtv6LPPPrOpb8+ePdM8PnjwYLrbFihQQP369dNXX32l2NjYLM1Xv359Pfzww6mPU1JS0v09yydPnszSHP9UrFixNI9v3LiRob6LFi3SF198ofz580uS3nrrLX3zzTeKjo7OdIb33ntPXl5eqY8PHjyo06dPZ7oPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsj+v+28CAAAAAAAAAAAAAAAAAAAAAAAAuJ8HH3xQc+bMkZeX8T+hiYmJ0VtvvaWpU6dmeY6zZ89q6NCh+uyzzzR37lw1btzYcLtx48ZpzZo1OnLkSJbnAoB/atq0qUaMGKGPPvrI2VEAAABgovPnz6tevXrOjgEAyIaKFy+u2bNny2KxODtKhvj5+VnVvvvuO/3nP/9xfJgM8PDw0Pz581W8ePF0t5k7d67efvttXbhwId1tUlJSdPbsWZ09e1bz5s1TyZIlNWnSJPXo0cNw+9KlS+unn35SmzZtckTm7ITrPgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4M7u3Lmj2NhYZ8cAAAAAAAAAAAAAAMDuEhIS9Mknn2jixImptUmTJunMmTNatmxZlno2adJE/fv3T1NbsmSJ1XaBgYF666239Oqrr8rf319lypTRwIEDMz2fv7+/pk2blqa2c+dOhYeHZ7qXvd26dUvTpk3TW2+9JUkqXLiwZs+erc6dOyslJSXDfTp27KjXX389Te3jjz82NSsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACyDw9nBwAAAAAAAAAAAAAAAAAAAAAAAADM5uXlpUWLFikgIMBw/OzZs6pbt66mTp1qynznz59Xs2bN9MMPPxiOe3t7a+bMmfLw4J/zADDPmDFjVKdOHWfHAAAAAAAALs7Dw0Pz589XYGCgs6NkmJ+fn1UtNjbWCUkyZtiwYWrcuLHhWGJiovr06aNevXrpwoULmeobFhamnj176oUXXlBSUpLhNkFBQerfv3+OyAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOBon3/+uQ4ePJj62NPTU4sXL9aoUaPk7e2dqV69e/fW2rVr5eXllVpbtWqV9u/fb7VtmTJlFBwcLH9/f0nSgAEDNGXKFPn6+mZ4vsqVK2vLli2qVq1amvro0aMzlduRJkyYkOb3a3fq1EnLly9X/vz5M7T/Sy+9pIULF8rDwyO1tmPHDs2bN8/0rAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMgePO6/CQAAAAAAAAAAAAAAAAAAAAAAAOBeBg4cqHr16hmOnTt3To0bN9aJEydMnfPOnTt6+eWXtXTpUsPxunXr6umnnzZ1TgA5W65cuTR37lzlyZPH2VEAAAAAAIALGzdunJo2bWpVP3bsmBPSZIyvr69VLTY21glJ7q9YsWJ6//33DceSk5PVrVs3/fTTTzbN8eOPP6p79+5KSUkxHB8/frwKFCiQ4X7umBkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAZEhMT9eyzz+rq1aupNQ8PD40ePVqnTp3S+++/r1q1asnDw8NqXx8fH9WoUUNDhw5VSEiIZs2aJT8/v9TxK1euaPDgwYbz7tmzR99//32aWv/+/XX69Gl99NFHevzxxxUQEGC1X2BgoNq1a6fZs2fr0KFDqlWrVprxOXPmaMOGDZl6DRwpIiJCvXr1UnJycmqtY8eOOn36tN577z1VqVLFap+AgAA988wz2rFjh6ZNm6bcuXOnjl25ckW9evVK93duAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANbfLAoAAAAAAAAAAAAAAAAAAAAAAAC4sQIFCug///mP4VhMTIyCgoJ06dIlu8ydnJys559/XhcvXjQcf/vtt+0yL4Ccq2LFivr888+dHQMAAAAAALiooKAgBQcHW9U3b96sjz/+2AmJMsbX19eqdvv2bSckub/g4GD5+fkZjo0ePVrLly83ZZ7FixdrwoQJhmOFChXSa6+9luFe7pgZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAWU6ePKkWLVro77//TlMvVaqUxowZo/379ys+Pl5r165NHXvttdd0+/ZtHTx4UJ9//rmqVauWZt8rV66oRYsW+uuvv9Kdd/DgwVq/fn2aWtGiRTVixAht3rxZ169f1+3bt3X9+nVduXJF8fHxunr1qlavXq1evXrJ29s7zb6rVq3SCy+8kMVXwXF+++03Pfvss4qPj0+tFSpUSGPHjlVoaKhiY2P1119/6c8//9T169d17do1LViwQI8++miaPpcvX1ZQUJDOnTvn4GcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAd+Lh7AAAAAAAAAAAAAAAAAAAAAAAAACAmYKDgxUQEGA4NmjQIJ08edKu80dHR2vIkCGGY2XLllWZMmXsOj+A7GvLli2G9f79+6tjx46ODQMAAAAAAFxe8eLFNXv2bFksljT18PBw9ejRQ3fu3HFSsnvLkyePPDysvxrp9u3bTkhzb/7+/nrppZcMx86ePauPPvrI1PnGjh2rv/76y3Bs8ODB8vHxuW8Pd8wMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgbIcPH1bNmjU1b948paSkWI17eXmpSJEiqY99fHysfs/4XYsXL1bVqlUVGhp6zzkTEhLUvn17TZgwQQkJCYbb5M6dWwEBASpcuLC8vb0Nt4mPj9c777yjJ598UklJSfec01UsWrRILVq00OnTp63G8uTJowcffFDly5dXQECA4eu8bt061alTRwcPHnRAWgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALgzD2cHAAAAAAAAAAAAAAAAAAAAAAAAAMzi7e2tl19+2XBs27ZtmjVrlkNyLFq0SKdOnZIkRUdHa/bs2Wrfvr2KFCmis2fPOiQDgOzn9ddf17lz5wzHpk+frqJFizo2EAAAAAAAcFkeHh5asGCBAgMD09STk5PVs2dPhYeHOynZ/fn5+RnWY2NjHZzk/p555pl08w4fPlwJCQmmzhcfH6/g4GDDsSJFiqhdu3b37eGOmQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFxBRESEevbsqZo1a2rKlCm6du1ahve9cuWKZsyYoVq1aunpp5/W1atXM7TfnTt3NHLkSFWuXFmTJk3S+fPnMzzn1atXNWnSJFWuXFkfffSRkpOTM7yvK9i+fbsqV66sgQMHKjQ09L7b37lzRxs3blTbtm3Vtm1bXbx40QEpAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4O68nB0AAAAAAAAAAAAAAAAAAAAAAAAAMMtTTz2lQoUKGY6NGDHCoVmGDBkiHx8frVmzRvHx8Q6d+658+fLJy8tLMTExSkxMdEqG7MDHx0e+vr5KSEhQTEyMs+O4jFy5csnPz0/JycmKiopSSkqKsyOlkR2P/5s3b6pXr17aunWrPD0904wVLlxYP/zwg9q1a+ekdPbDezD7csV1JE+ePMqTJ4+Sk5N18+ZNl8jkSnLi6+Mua9DdnLdv39bt27edHcfhfHx85OHh4VbP3V2OLXfn7e0tPz8/xcXFKTY21tlx3NLdYzU2NlZxcXHOjmMop6+BriCnrmk59XmbITves7uicePGqUmTJlb1sWPHatOmTU5IlHG+vr6GdVdc57t3725YP3HihBYvXmyXOefPn6+xY8eqfPnyhnmWLl16z/3dMTNgxJXPJ56ensqXL58sFotL5sO9ucN9kCsf/64qJ362eS/ufC/tqsc/az8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADlLSEiIBg4cqFdffVWVK1dWnTp1VLJkSVWrVk09e/aUJP3xxx+aP3++wsLCFBoaquPHj9s059mzZzVixAiNGDFCpUuXVo0aNVSuXDkFBgbK19dXuXLlUnR0tG7cuKGwsDDt3r1bJ0+eNOPpZtrWrVtlsVhM6ZWUlKQpU6ZoypQpKl68uJo1a6bixYurSJEiypcvn27duqWrV6/q6NGj2rFjhyIiIkyZFwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADmHl7MDAAAAAAAAAAAAAAAAAAAAAAAAAGZ58cUXDeu7du3Szp07HZplzZo1DpvLx8dHQUFBCgoKUo0aNfTwww+rYMGCslgsqdskJCTor7/+UmhoqHbs2KFly5bp1KlTDsvoLqpWraonn3xS9evXV/Xq1VWiRAnlypUrdTwlJUU3btzQkSNHFBISog0bNmjDhg2Ki4szLcMjjzxiVQsPD9f169fT3cfHx0fVq1dX+fLllT9/fuXLly/N3/+XX35pU8aaNWuqQ4cOqlu3rqpVq6YSJUrIx8cndTwlJUVRUVE6evSo9u3bpzVr1mjDhg26c+dOlufMqJx2/O/YsUMffvih3nvvPauxtm3batCgQfr666+dkMwczngPVqhQIc0cd126dEk3btzIct+78uXLp1KlSlnVjx07ppSUFJv7lylTRnny5LGq//nnn0pMTLS5v1lcbR3JlSuXnnjiCbVp00bVq1dXlSpVVLhwYXl6eqbJFBkZqYiICB06dEi//fabfvvtNx06dChLcwYGBqpIkSLpjj/44IOG9fz58xueG+4lISHBpnXOGa+PK3CF64CMKF68uJ5++mk1adJEtWrV0oMPPihvb+/U8Tt37ujixYs6cuSIduzYoRUrVqT79+Ll5aWAgACrekREhJKSkuz2HGxRokQJdenSRY899phq1Kih0qVLpz7/pKQknTt3LvXvZ9myZQoPD3dyYtc4tooUKaLAwECr+v2uMzPLYrHo4YcftqonJyfr+PHjps1jJF++fGrfvr3atWunmjVrqmLFimnONXfu3NHly5cVEhKiPXv2aOnSpTp48KBdM2VVeuv+0aNHbe5zr7/zgIAAdevWTc2bN1etWrX00EMPpVlfYmNjdfXqVR07dkwbN27Uhg0bFBoamqlMtspOa6A7XRv8kyusac7g6OddvHhxFShQwKp+48YNXbp0KatP454CAgJUrFgxq/r169ezfD51hXt2V/ycxRGCgoIUHBxsVd+8ebNGjx7thESZ4+fnZ1i/ffu2g5PcW968edWsWTPDsQULFth17gULFmjkyJFW9aCgIFkslnQ/c3DHzGZw1fNuVq77XPW52Nu/zymNGjVymc+A69evrxYtWqh+/fqqWbOmAgMDrdaxhIQEXbhwQaGhoTpw4IBWrVqlPXv2OCSfPWWH47FgwYJ68skn1bZtW1WvXl3lypVLc53n7PsgV7iecjeu9Nnmv49zZ12Huuu9tCsf/45c+7PDWgsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQHaWkpKiY8eO6dixY5Kk2rVrq2fPnpKkbdu2afLkyXaZ99y5czp37pxderuyixcvat68ec6OAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgGzGkpKSkpKhDS0We2cB4KaqV6+u6tWrS/rflxefOXNGu3btUgaXFwBwCd7e3nrwoQedHQM5wPVr13Xjxg1nxwAAmxUoUEAj3xvp7BjI5jZt2qS1a9Y6OwYAAAAAB/v4k4+dHQE5wLGjxzRjxgxnxwAAUwxZLPn4OjsFsrOwUGnuMGenAACkx2KxqG7duqpYsWLqz3uHhIQoJCTEyclyJn6mFnANuXPnVmRkpHx8fKzG+vXrp++//94JqeyrVKlSeuedd9S7d2/5+fllev89e/ZowoQJWrZsmSl5zp49q9KlS1vVn332WS1cuNCUOewhV65cev755zVs2DBVqlQp0/vfunVLs2fP1sSJE3X27Fmb8xidP0aMGKFJkyalqXl4eKhbt2565ZVX1KxZM3l5eaXbs1ChQoqIiMhUjrx58+qVV17RkCFDVKZMmUztK0lXr17V5MmT9fnnn+v27duZ3v9+XO34N1N676WHHnpI58+fl6enp3bu3Kl69epZbRMXF6fatWvr2LFjpmQ5duyYKleubFXPyjGVHme/B5cuXarOnTtb1adPn66XX3450/3+bdSoURo9erRVvVGjRtq5c6dNvb28vHTt2jXlz58/Tf3GjRsqUqSIkpKSbOpvK1dcR4oVK6Zhw4bplVdekb+/f5Z67NmzRx9++KGWLVuWqWv+9I4Fe9i2bZsee+yxTO/nzNcnPen1MOvfPjt7DcqM+vXra+zYsWrVqlWmn//evXs1duxYrVixIk39scce02+//Wa1fYMGDbR7926b8pqtadOmev/999WyZcsMP/+kpCTNnj1bo0eP1rlz59KM7dy5Uw0bNrTax6zn7mrH1ocffqjg4GCrutF1pi3y5s2rW7duWdVjYmKUL1++TPXK6Pu/YMGCCg4O1quvvprp68Ljx49rwoQJmjNnjpKTkzO1rxGz1ix79jH6Oy9evLjGjBmjPn36KFeuXJmaY9u2bRo1apS2bNmSqf0yKzuuge5wbXCXq61pjuLM5/3SSy9p2rRpVvUjR46oatWqmc6SEfPnz9ezzz5rVX/qqae0ZMmSTPVypXt2V/mcxZGKFy+uQ4cOKTAwME09PDxcNWrUUHh4eGqtT58++vHHH9Ns179/f02dOtUhWdPTsGFDw3vmevXqae/evU5IZKxly5bauHGj4ViVKlV09OhRu81dtWpVHT582HCsVq1aOnjwoOGYO2Y2g6ued7Ny3edqz8Xe9+22nFPs+Rlwrly5NGDAAA0YMECPPPJIlnqEhYXpyy+/1HfffaeoqCiTEzqGqx2PUsaPySJFiui9995Tv379DP+/xftlsfd9kCtdT5nNXuuGO3y26ejrUHe9l3bV499Za78rrrUA4GosFovq1aunChUq8PO0ADLMlmt+vqsdQHr4dyWAuZ544gm1a9/O2TGAe+J7UwHAdm3btVXz5s2dHQNI15LFS2z+918AkNP17NlTtWrXcnYMIF3Tp0/X8WPHnR0DANzam2+9qQceeMDZMYB7+vSTT3X58mVnxwAAtzZgluRfxNkpgPRN7iolxDo7BQBn4bvaXQs/UwsAAAAAAAAAAAAAAAAAAOBYfFc7gKzgu9oB2AP/rgQArNWuXVv79u2TJH3yyScaPny4kxMBAGAufr8MnIHfFwMgJ+H3usAZ1qxeo82bNzs7BgA4BOdaOAu/Gw1ATtJqsFSrg7NTIKfZ8F/p4GpnpwAAx+K72l0LP1MLAAAAAAAAAAAAAAAAAADgWHxXO4CsyMjPeHs5IAcAAIDLCwgIUP/+/Z0dAzkAX4QHAAAAAAAAAAAAAAAAAID9NG7cWD4+Plb15ORkLV261AmJ7CdXrlz6z3/+o+HDhytXrlxZ7lOvXj0tXbpUv//+u55//nmdOXPGxJTuoXXr1po6daoeeuihLPfw9fVV//799fLLL+vLL7/Uu+++q7i4OBNTWqtcubJmzZqlevXq2aV/jx499MUXX6hw4cJZ7lG4cGGNHz9er776qvr06aNNmzaZko3jX7pz54569uypgwcPytfXN81Y7ty5NW/ePNWrV0+JiYlOSphxrvAeXLhwoTp37mxV79ixoywWi82/kKdTp06G9Y4dO9r8i1+bNWum/PnzW9WXLVumpKQkm3rbytXWEYvForfeektjx45V7ty5s9xH+t/6sWTJ/35x71NPPaVLly7Z1M8ejhw5kqntc9rrc5crrEEZkS9fPn377bfq1atXlnvUrVtXy5cv15IlS/TKK68oIiLCxIT2VbhwYX333Xfq0qVLpvf18vLSCy+8oG7duuntt9/WN998Y4eE1tzl2MoOOnbsqO+//15FixbN0v53r6uHDx+u5557Lkd+kUvPnj01depUq+vKjGratKk2b96sxYsX6/nnn9etW7dMzZfT10CzZPba4J9y6prm7Oc9f/58ff7558qXL1+aepUqVVSnTh3t27cvy7mM5M+fX08++aRV/cqVK1qxYkWG+7jrPbu9P2dxJA8PDy1YsECBgYFp6snJyerZs6fCw8OdlCxz0jsv3b5928FJ7u3RRx81rP/11186evSoXecODQ3V33//rVKlShnmOnjwoOF+7pjZ3dhy3nU1znwuZpxT7HU+ady4saZOnapHHnnEpj4lS5bUpEmT9M477+iNN97Qjz/+aEq+7MrM47FLly76/vvvVahQoSztb8/7IHe9nnImd/5s017Xoe56L+3Kx39OWfuz03UMAAAAAAAAAAAAAAAAAAAAAAAAAAAAkJNt3rzZsP7EE084OAkAuKavv/7a8HskBg4cqOPHjzshEe6F8xoAR2CtAYCMY810b+56P+SuuV0drysAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQlpezAwAAAAAAAAAAAAAAAAAAAAAAACBz/ItID9WU8gVKuXJLsZHS1b+kv0OkO4nOTuc8LVq0MKwfOnRI165dc3Aa+ylZsqRWrlypmjVrmtazSZMmCgkJ0bPPPqvVq1eb1teVeXh46L///a9effVV03p6enrqjTfeUIcOHdSpUycdP37ctN7/1KBBA61bt04FChQwvXeePHn0008/6amnnjKtZ4kSJbRx40a98847mjRpkk29OP7/36lTpzR06FB9//33VmM1atTQ+PHj9fbbbzshWca40ntw5cqViouLU+7cudPUixQpooYNG2rnzp1ZzlSsWDHVrl3bcKxDhw569913s9xbkrp06WJYX7hwoU19beGK64i/v7+WL1+uxx9/3LRMkvToo49q//796ty5s/744w9Te9vqyJEjGd42J74+rrQG3c8jjzyiVatWqUyZMqb069q1qx555BE1b95cly5dMqWnPdWvX18rV65UkSJFbOrj6+urr7/+WjVr1tSAAQOUnJxsUsK03OnYyg6GDx+uiRMnymKx2NyrWrVq2rNnj/r376+ZM2faHs5NjBs3TiNHjjSl11NPPaVKlSqpY8eOOnfunCk9c/oaaKbMXBvclVPXNFd53rdu3dL8+fP1yiuvWI317dtX+/btMy2fJD377LNW90SSNHPmTCUlJWWoh7ves9vzcxZnGDdunJo0aWJVHzt2rDZt2uSERFnj5+dnWL99+7aDk9xblSpVDOuHDh1yyPwhISEqVaqUVT29XPcac+XM7iYr511X5aznYvY5xczzyfPPP6/p06fL09PTlGySVLBgQc2cOVNPPvmkevToofj4eNN6ZydmHY9vv/22Jk6caEovs++D3PV6ypnc+bNNe12Huuu9tCsf/zlp7c9O1zEAAAAAAAAAAAAAAAAAAAAAAAAAAABATmb2v8MHgHvx9vY2rCckJDg4ScbVrl1bDRs2tKr7+/s7IQ3uh/Ma4Nrc8TxghLUGADKONdO9uev9kLvmdnXZ9XX18fFR1apVVbJkSeXPn1/+/v7KmzevEhMTFRUVpaioKEVEROjo0aM57vdWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4N68nB0AAAAAAAAAAAAAAAAAAAAAAAAAGVPiEemxF6VSVY3HE25L+1dIuxZICbGOzeYKqlevblj//fffHZzEfipUqKBff/1VpUqVytD2SUlJSkxMVJ48ee67ra+vr5YtW6bnnntOCxYssDWqS8udO7d+/vlndejQwS79K1SooB07dqhjx47avn27qb3Lli2rdevWqUCBAqb2laSAgACtXbtW9evXN723h4eHJk6cqFy5cmn8+PFZ6sHxb23atGnq0KGDnnzySauxYcOGae3atdq8ebMTkt2bq70HY2JitH79esPXsXPnztq5c2eWs3To0EEWi8VwrFq1anrwwQd1/vz5LPfv1KmTVS0yMlK//vprlnvawhXXkYIFC+rXX39VrVq1MrR9cnKybt++LR8fH3l53f+f4RYrVkyrVq1S7dq19ffff2c4l70dOXIkQ9vlxNfH1dage6lRo4Z++eUXBQYGmpTufypXrqxff/1V9erVM7Wv2Zo1a6ZVq1bJz8/PtJ6vvPKKLBaLXnnlFdN63uVOx1Z28Prrr2vSpEmm9vT29taMGTPk7++vL7/80tTermjkyJEaOXKkqT2rVq2qDRs2qE6dOoqOjrapV05fA82W0WuDu3LqmuZqz3vq1KmG56yePXvqzTffVEJCgmnZ+vbta1j//vvvM7S/u96z2/NzFmcICgpScHCwVX3z5s0aPXq0ExJlXXrXgLGxrvXB98MPP2xYDw0Ndcj8hw8fVvv27a3qlStXTncfd8zsbjJ73nVlzngumTmnOPp80rdvX02fPj3dz/v+7fbt20pJSVGePHkytE+XLl20fv16BQUFKT4+PksZszMzjsdBgwZp4sSJJqT5f2bdB7nr9ZQzufNnm/a6DnXXe2lXPv5z2tqfna5jAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA/VWsWFEnTpwwHKtUqZJOnjzp4EQAAEfiPJB9vP7666Z8L9adO3cUHx+v6OhoXblyRRcuXNCJEyd08+ZN20Pqf98P1q9fP1N62UNYWJhmzJiR+tjf319Dhw413DYlJUWfffaZbt265aB0/9OsWTM1a9bMcGzHjh365ZdfHJoHAAAzeHh4qFmzZnrmmWfUpEkTVa5cOUPfPSpJV69e1YEDB7RixQotXrxYly9ftktGs663UlJSFBMTo5s3byoyMlKRkZE6duyYLl26ZHvIdDRv3lxNmjSxqp88eVLz58+327xGevbsqfLly1vVt2zZoq1btzo0CwAAAAAAAAAAAABkxMWLF/XBBx9I+t/PaAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwfRn7rZgAAAAAAAAAAAAAAAAAAAAAAABwqsa9pUY9JYsl/W2880gNn5Ueflxa/IF07Zyj0rmGChUqGNYPHTrk4CT2ERAQoA0bNqhUqVLpbhMSEqIFCxZow4YNOn36tG7cuCFJ8vb2VmBgoOrWravWrVurV69eKlCggNX+Xl5e+vHHH3Xu3Dn98ccf9noqTvfTTz+pQ4cO6Y4nJydr586dWrlypfbs2aPLly8rIiJCefPmVdGiRVW+fHm1a9dObdq0MXwdJalgwYJavXq1Hn30UR07dsyU3J6enlqyZEm6c9rC29tbK1euVP369dPd5s6dO9q+fbvWrFmjvXv3Kjw8XNevX5fFYlH+/PlVoUIFPfbYY+rRo4eKFy9u2GPcuHE6deqUFixYkKl8HP/pe+mll9SgQQMVK1YsTd1isWjWrFmqVq2aIiMjnRMuHa74HlywYIGefPJJq3rnzp01YsSIDD+3f+vUqdM9x9u3b69vv/02S71r1apl+J5Yvny5EhMTs9TTFq66jsyZM0e1atVKd3zbtm1atGiRtm/frpMnTyo6Ojp1LF++fCpTpowef/xx9enTR3Xq1DHsERgYqMWLF6tx48b3fO3DwsK0a9eudMcLFSpkeD0TERGhkydPprufkdDQ0Axt50qvj6O44hpkpFixYlq3bp0CAwPT3SYuLk6bNm3SypUrdezYMYWHh+vGjRvy9fVV0aJF9dBDD6lt27Zq3769ChUqlGbfhx9+WN9++62mTZuWpXz2Vq5cOS1btkx+fn7pbhMfH69NmzZpzZo1CgkJ0YkTJ+Tj46NChQqpWrVqatmypZ588kn5+/un2e/ll1+2yz2Cuxxb2cFjjz2mzz//3KqekJCg9evXa+3atTp48KAuX76s2NjY1PdEhQoV1KZNG7Vt2zbd19hisWjy5Mk6c+aMVq1aZedn4jwtW7bUmDFjrOopKSnaunWrli1bpr179+rChQuKjY2Vv7+/ChcurFq1aqldu3YKCgqSp6enYe8KFSroxx9/VNeuXbOcL6esga54bXBXTl3TXO157927VwcPHlTNmjWtenTq1EmLFi3K7FM0VKlSJTVs2NCqvmXLFp06deq++7vrPbs9P2dxhuLFi2v27Nmy/OsD5PDwcPXo0UMpKSlOSpY1vr6+hvXbt287OMm9lShRwrB++PBhh8wfEhJiWE8v173GXDmzGVz5vJtZ2em5/FtmzinffvutQ88nZcuW1VdffWW1zt518eJFzZ07V+vXr1doaKiuXLmi5OTkNM+tYsWKatKkiZ566inDc68kNWvWTF9++aX69++fqXzO4k7HY8OGDfXFF19Y1V3hPshdr6eczV0/27TXdai73ku78vHvKmu/O621AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADA/bzxxhsqXbq03fr//fff2r59u9atW6eVK1cqIiIiS32KFy+u0aNHm5zOPLt27dKMGTNSH0dFRalYsWIaOHCg4fYPPfSQXn75ZUfFU/HixbVkyRIFBARYjV29elVTpkxxWBYAAMzg7++vYcOGqV+/fipatGiWehQuXFitW7dW69at9eWXX2rz5s0aM2aMtm7dampWe19vXbp0SXv37tX27ds1Z84chYWFmda7VatWCg4OtqqvWrVK8+fPN22ejOjdu7fatGljVf/ggw9M/zsDAAAAAAAAAAAAADNcvnxZY8aMcXYMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJng5ewAAAAAAAAAAAAAAAAAAAAAAAAAuLeWg6TaHTO+ff6i0nOfSbPflK6ds1ssl+Lh4aEyZcoYjp04ccLBaexjwYIFKl26tOHY33//rTfffFOLFi0yHE9ISNDFixe1YsUKrVixQu+++65GjBih4OBgeXh4pNnWx8dHixYtUuXKlXXr1i2zn4bTvf/++3r66afTHV+3bp3efvttHT582HD8zJkz2rlzp3766Sf5+vrqzTff1Ntvvy0/Pz+rbfPnz6/Vq1erZs2aioqKsjn74MGDVaNGDav6jRs3tHz5cq1atUqHDx9WeHi4bt68mane3377rRo1apTu+KJFizRy5EidPHnScPzixYs6duyYVqxYoeDgYA0ePFgTJkxQnjx5rLb97rvvtH37doWFhWU4H8d/+q5fv64XXnhBa9eulcViSTNWsmRJfffdd3r22WedlM6aq74HV65cqbi4OOXOnTtNvWLFiqpUqVKWziU+Pj5q0aLFPbfp2LGjvv3220z3lqQuXboY1n/++ecs9bOVK64jr732mtq2bWs4tn//fg0cOFC7d+9Od//o6GiFhIQoJCREX375pbp27aoffvhB/v7+VtvWq1dPL7zwgr7//vt0+82YMUMzZsxId7xr165avHixVX3Tpk3q1q1buvtllau9Po7gqmvQv1ksFv38888qVqyY4XhycrKmT5+ukSNH6urVq/fMOn/+fHl7e+uNN97Qe++9lyZr7969XfJa2cvLS0uWLFGBAgUMx+/cuaMZM2Zo9OjRunDhgtX4+fPndeDAAc2aNUv58uXT66+/rvfeey/NGj9x4kRFRESYltldjq3sYtq0aWmu41JSUvTtt99q/PjxunjxouE+d1/jWbNmydfXV2+88YaGDx9uuGZZLBbNmTNHVapUydQ1q7vInTu31WsoSatXr9aIESN05MgRq33Cw8P1559/aseOHfr666/1yCOP6Msvv0z3WqdLly7q1q1blq5LctIa6GrXBnfl1DXNVZ/31KlT9c0331jV+/btm+59cGa98MIL6c6dEe56z27Pz1kczcPDQwsWLFBgYGCaenJysnr27Knw8HAnJcs6o/eOJMXGxjo4Sfq8vLwUEBBgOHbp0iWHZLh8+bJhPb3zqDtmNournnezIjs9l3/L6jnFEeeTyZMnK2/evFb15ORkjRo1Sp988oni4+PT3T8iIkK7du3Srl279Mknn6hRo0b69ttvVb16datt+/Xrp0WLFmnjxo0Zzucs7nQ8Tp06VZ6enmlqrnIf5K7XU87kzp9t2uM61J3vpV35+HeVtd+d1loAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIB/K1WqlLp3767u3bsrMTFRixcv1scff6z9+/c7O5rdvfnmm3riiSdUuXJlq7GXXnpJq1ev1tKlSx2S5ccff0z3e0n79u2rK1euOCQHAAC28vLy0rBhw/T222+rYMGCpvX18PBQixYt1KJFC1WpUkVHjx41rbe9PfDAA+rYsaM6duyoCRMmaP369ZoyZYpWrFjh7GgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABuxcPZAQAAAAAAAAAAAAAAAAAAAAAAAJC+6m2k2h0zv593Xump0f/735ygePHiypUrl+HYhQsXHJzGfM8995xatmxpOLZ9+3bVqVNHixYtynC/qKgojRw5Uu3bt1d0dLTVeMmSJTV69Ogs53VVVatW1fvvv284lpSUpP79+6tt27Y6fPhwhvrdunVLY8eOVY0aNXTs2DHDbcqUKaNJkyZlOfNdefPm1XvvvZemFh8fr4kTJ6pMmTLq27evFi9erJMnT+rmzZuZ6t2yZUu9+OKLhmO3b99Wt27d1K1bN508eTJD/ZKSkjR58mQ1atRIV69etRrPnz9/po4vjv/7W79+vb766ivDsWeeeUa9e/d2cCJjrvwejImJ0fr16w3HnnzyyQzl+bcWLVoob957n4ibN29+323SY5QrKipKGzZsyFI/W7jiOuLv768PPvjAcGz27NmqX7++du/enaE8dy1ZskSNGzdOd50dPny4LBZLpno6S058fVx5Dfq3l19+WU2aNDEci4mJUcuWLdWvXz/D94eRhIQETZw4UdWrV9eZM2fSjAUHB2c6n70NGTJE1atXNxy7ceOGWrdurX79+mXoOj86Olrjx49XrVq1dPbs2dR63rx5VbJkSVPyutOxlV1UqFAh9b9v3rypFi1aaNCgQbp48WKG9r9165bGjRun2rVrp/sa+/v76/PPPzclr6t5+eWX9dBDD6U+vnucdujQQUeOHMlQj6NHj6p169b64Ycf0t3m7bffznK+nLwGOltOXdNc+XnPmTNHsbGxVvWgoCA98MADGcpzLxaLxfCeMSIiQosXL77v/u56z27Pz1mcYdy4cYZr59ixY7Vp0yYnJLKdn5+fVS05OVmJiYlpatWqVVPv3r310UcfaeHChVq3bp22b9+uPXv2aNu2bVq7dq3mzJmjUaNGqVu3bipWrJhpGQsWLJjuPY7R8WsPUVFRhvUCBQoYZnPHzMg5zDynmH0+KVy4sNq2bWs41qNHD40fP17x8fEZ7idJO3bsUL169bRkyRLD8TFjxmSqH+6vWrVqqf/tSvdB7no95Uzu/Nmmva5D3fVe2pWPf9Z+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADlF48aNtXbtWqs/7777rrOjIYfimMzecuXKpe7du2vv3r2aM2eOChUq5OxIdhUXF6cePXooISHBcHzatGmmfM/w/QwZMiTd7/369ttvtXr1artnAADADGXLltWOHTv04YcfqmDBgnabZ+/everbt6/d+tuTh4eH2rZtq+XLl2vdunV68MEHnR0JAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAbXg4OwAAAAAAAAAAAAAAAAAAAAAAAACMeeeVmr2Y9f3zF5UaPmteHleWL1++dMfCw8MdmMR8uXPn1qRJkwzHDh06pJYtW+rq1atZ6r1u3Tr16dPHcOy1115T0aJFs9TXVU2ZMkW5cuWyqicmJqpdu3aaOnVqlvqeOXNGDRo00K5duwzH+/Xrp/r162ep9109evRQYGBg6uNr166pefPmCg4O1s2bN7Pc18PDQ998843hWGxsrB5//HEtWrQoS70PHjyoli1bKjY21mqsfv368vb2vm8Pjv+MGz58uI4ePWo49vXXX6t06dKODWTA1d+DCxcuNKx37tw5S7k6dux43218fHzUsmXLTPcuXbq0qlevblVfsWKFEhMTM93PFq66juTKlUvz5s1TXFxcmvqaNWvUu3dv3blzJ0uZQkNDNWjQIMOxChUqqG3btlnq62g58fVx9TXoLj8/P02YMMFwLDo6Wk888YQ2b96cpaxnz55VkyZNdPr06TTzuZICBQrogw8+MByLiIhQgwYNtGnTpkz3PX78uBo3bqywsDBbI1pxl2MrO4qNjVXz5s2z/J44ffq0GjRooP379xuOP/3002rcuLEtEV1SqVKlUv87OTlZzz77bJaO0+TkZL344ovaunWr4XjdunX12GOPZapnTl8DXUFOXdNc+XlHRUXp559/tqp7enrqueeey1Kuf2rZsqVKlChhVf/pp5+UkJBwz33d+Z7dXp+zOENQUJCCg4Ot6ps2bdLo0aOdkMgcRp/33r59W5LUsGFDTZs2TRcuXFBISIhmzZqlESNGqFu3bgoKClKjRo1Ut25dNWnSRG3atFHPnj01evRoLVy4UJcuXdKhQ4c0bNgwBQQE2JTRx8cn3bHo6GibemfUveYxumd2x8zIGex1TjHrfNKxY0d5eXlZ1RcsWJDuZ4oZkZCQoGeffVY7d+5MU9+4caNGjRqV5b64N1e6D3Ln6ylncufPNu1xHequ99Kufvyz9gMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADIKYoWLao2bdpY/alVq5azoyGH4pjMGSwWi3r27KkjR45ky+8C/6eDBw9q5MiRhmMBAQGaNWuWXeevWrWqJk6caDh2/Phxvfnmm3adHwAAs7Rr106HDh1SvXr17D5Xnjx5NGPGDH377bd2n8uegoKCdOTIET3//PPOjgIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOAWPJwdAAAAAAAAAAAAAAAAAAAAAAAAAMaqtZby+NvWo3YnyTOXOXlcma+vr2E9JSVFsbGxDk5jrp49e+qBBx6wqkdFRalLly6Ki4uzqf+yZcs0bdo0q7q3t7cGDRpkU29X0rRpUzVu3NhwbPjw4dq4caNN/aOjo/XUU0/pypUrVmMWi0XvvvuuTf0rVqyY+t+RkZF69NFHtWPHDpt6SlLXrl1VoUIFw7FXX31Vu3fvtql/SEiI3nzzzdTHu3fvVpcuXVS9enUlJCTcd3+O/4yLj49Xjx49DF/XfPnyac6cOfLwcN4/KXSH9+CKFSsUHx9vVW/YsKGKFCmS6UwdOnRI8zgpKUm///671XYdO3bMdO8nn3zSsL5w4cJM97KVq64j169f12uvvaYyZcro008/1a1btxQZGak+ffrYlEeS5syZo8OHDxuOtWjRwub+jpDTXh93WIPuev755xUYGGg49vrrr2vv3r1ZzilJly5d0nPPPac7d+7Y1MdeXnzxReXLl8+qnpKSoueee05//vlnlntfunRJTz31lKnP3Z2Orezo1Vdf1f79+23qcfc1vnHjhuH40KFDberv6j744AMtWbLEph4vvPCCEhMTDcfSu2ZJT05fA50tp65p7vC8p06dalh/8cUXbcomSX379s3UnP/kzvfs9vqcxdGKFy+u2bNny2KxpKmHh4erZ8+eSklJcVIy2xl93uvl5aU9e/Zo586deumll1S8ePEs9a5evbo+/vhjXbhwQR999FG6ny3fT+7cudMdi46OzlLPzLrXPEb53DEzcgZ7nlPMOJ+UK1fOsP7jjz9mOdddSUlJ6tu3r27fvq2ffvpJNWrUUOvWrW2+BkH6XOk+yJ2vp5zJnT/btMd1qLveS7v68c/aDwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcrqwsDCFhoZm6M+RI0d06tQphYeH6/bt2xmeo2jRovr111/Vpk2b+24bFxeX4Tzp/fn7778NeyclJdnc+8yZM+lm//TTT7V582bDsZYtW9rt+9C9vb01d+5c+fj4WI0lJCSoR48eNn/vFwAAjvDkk09q6dKl8vPzu+d2kZGRWrRokV5//XW1bt1alStXVokSJRQYGKhixYqpQoUKql+/vp577jlNmjRJ+/btu2e/AQMGaPLkySY+k7Qyc70VGhqqo0eP6q+//tKNGzeUnJycoTn8/Pw0c+ZMDR8+3G7PAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAILvwcnYAAAAAAAAAAAAAAAAAAAAAAAAAGCvf0PYe3nmkB6tLZ/fZ3suV+fr6Gtbj4+MdnMR8gwcPNqx/+eWXOnv2rClzfPjhh3rxxRfl4eGRpt6nTx+NGjXK5v7lypVT7dq1be7zT1euXFFYWFiGtx82bJhh/ZdfftEXX3xhSqaLFy/qlVde0fLly63GOnXqpAoVKujPP/+0eZ4XX3xRp06dsrmPJA0ZMsSwvmLFCv3444+mzDF16lTVqFFDCxYs0G+//ZapfbPD8e9IISEhevfdd/XJJ59YjTVq1Ejvvvuuxo0b54Rk7vEejImJ0fr169WpU6c0dYvFoo4dO2r69OkZzlKzZk2VLFkyTe23337T/Pnz1aRJkzT19u3bZ7jvXZ07d7aqRUdHa8OGDZnuZStXX0cuX76sYcOG6cMPP9Qjjzyi69evm5Lpu+++01dffWVVb9q0qSn9HSWnvD7usAbdNWjQIMP62rVrNXPmTFtjSpJ27dql//73vxo6dKgp/cw0cOBAw/rMmTO1du1am/vv3r1b3333nV599VWbe0nudWxlN9u2bTPtPHPu3Dm9/fbb+v77763GOnfurGLFiuny5cumzOVKDh06pA8//NDmPmfPntWyZcvUrVs3q7F/X/fcT05fA50tp65p7vC8d+zYoaNHj+qRRx5JU69cubLq16+v3bt3ZymXv7+/4b3Fzp07dfTo0fvun13u2c38nMWRPDw8tGDBAgUGBqapJycnq0ePHgoPD3dSMnP4+flZ1Xx8fFS3bl3T5sidO7dGjBih3r17q3v37tq2bVum9v/3cflPCQkJtsbLkHt9/u3p6WlVc8fMyBnsfU6x9XxSvHhxw/rp06dtziZJJ06cUNGiRRUdHW1KP6TP1e6Dssv1lLO4+2ebZl2Huuu9tKsf/6z9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA9xcXF6e9e/emOwYAyN44D2R/b731lhYuXJilfYsWLaoqVaqoXr166tq1q+rXr5/utj4+Plq8eLEaNWqkQ4cOpbvd0aNHVa1atSzluatr165avHixVf3atWs2976XlJQU9e7dW4cPH1bBggWtxj/66CP9+uuvOnz4sKnzfvjhh+k+r5EjR+rgwYOmzgcAgD20adNGixYtkpeXV7rbhISEaMKECVq2bNk9vwf77ve379mzR3PmzJEklSlTRkOGDNGAAQPk4+Njtc+QIUN04cIFffzxxzY+E2u2XG95e3urSpUqqlmzpjp16qR27drJ29s73e0nTZqkCxcuaO7cuVmNCwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkO15ODsAAAAAAAAAAAAAAAAAAAAAAAAAjAU+ZE6fQg+a08eV+fj4GNaTkpJMm6NcuXJq166dKX/y5s2boTkffPBB1apVy6oeGxurzz//3LTndubMGf3yyy9W9YceekgPP/ywzf0nTJigffv2mfrnueeey/D8+fLlU9u2bQ3HPvzwQ5uf3z+tWLFCR44csapbLBY9/fTTNvdfunSpli5danMfSSpSpIgaN25sODZx4kRT5pCklJQUvfrqq/rtt98ytV92Of4d7dNPP9WmTZsMxz744APVr1/fwYnc6z24cOFCw3rnzp0zlaNDhw6G2VatWqWUlJQ09QceeEC1a9fOcO+CBQuqadOmVvWVK1cqPj4+Uzlt5erryD9dv35d27ZtMy1Teu+zWrVqydPT07R5HCU7vz7utAZVrFgx3XPP+PHjbc73T59++qnu3Lljak9bVaxYUeXLlzcc+/TTT02bZ9y4cabcJ7jTsZUdjR071tR+P/30k65evWpV9/LyUps2bUydy1W8//77pq0DP/zwg2G9du3aGb7/zelroLPl1DXNnZ73999/b1jv27dvljM988wzypMnj1V96tSp9903u9yzm/k5i6ONGzdOTZo0saqPHj1amzdvdkIic/n5+TlsruLFi2vTpk165ZVXHDYngP/niHOKreeT9P4/qH9/zmeL6Oho03ohfa50H5RdrqdcgTt+tmnWdai73ku7w/HP2g8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHB/58+fV7169Qz/nD9/3tnxAAB2xnkA9xIeHq5NmzZp4sSJatCggSpUqKAFCxaku33evHk1b948eXt7OzClY124cCHd7z/18fHRvHnz0v0OrKxo0aKF3njjDcOxzZs3m/r9/wAA2MuDDz6oOXPmyMvLy3A8JiZG/fv3V40aNbRgwYIs/f6us2fPaujQoapYsaK2b99uuM24ceNUpUqVTPe2p4SEBB04cEA//PCDunTpoqJFi2rChAlKSEhId5/vvvtODz6YA36xKQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQBZ5ODsAAAAAAAAAAAAAAAAAAAAAAAAAjOXxN6ePb0Fz+uR0r7/+ulavXm3Kn5IlS2ZozlatWhnWf/nlF0VERJj59LRlyxbD+uOPP27qPGY5depUhrdt3bq1cuXKZVUPDQ3Vpk2bzIwlSZo8ebJhvWPHjnbrnRVt2rSRxWKxqh84cEA7duwwbZ6s4vjPuj59+ujGjRtWdS8vL82ZM0e+vr4OzeNO78EVK1YoPj7eqt6yZUvlzZs3wxk6depkVVu5cqUuX76svXv3Wo116NAhw707dOggT09Pq/rPP/+c4R5mcfV1xJ6OHz+umJgYq7qXl5cKFuTiy5VeH3dag9q0aWNYP3TokLZv325LLCthYWFavXq1qT1t1bp1a8P61q1bdeTIEdPmuXTpklatWmVzH3c6trKbv/76Sxs3bjS1Z3x8vKZPn244lt5705399ddfWrlypWn9tm/frpSUFKu6l5eXHnrooQz1yOlroLPl1DXNnZ73rFmzDO9VevToIR8fnyzl6du3r1UtKipKCxcuvO++2eWe3czPWRwpKChIwcHBVvVNmzZp7NixTkhkvox8dpGYmKgDBw5o2rRpGjt2rN544w299NJLevnll/XWW29p/Pjxmjt3rk6fPn3fXl5eXvruu+8M3xcA7MtR5xRbzieRkZGG9TJlymQ9EBzO1e6Dssv1VHbkiM82zboOddd7aXc4/ln7AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzHPq1Cl1795dQUFBht/1JUkPP/ywBgwY4OBkjrV48WLNnDnTcKxKlSqaNGmSKfMULFhQP/74o+HvE7lx44Z69+5t+H16AAC4Ei8vLy1atEgBAQGG42fPnlXdunU1depUU+Y7f/68mjVrph9++MFqzNvbWzNnzpSHh4cpc9lDZGSkRo4cqWrVquns2bOG2/j5+Zl2vQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJAdue5vrwQAAAAAAAAAAAAAAAAAAAAAAMjhEuPM6ZNw25w+OV2FChUcPmeTJk0M6+vXrzd9rl27dhnWq1SpYvpcZjh16lSGt33iiScM6+vWrTMrTob6NmjQQD4+Plnue/z4cW3dujXL+/9b06ZNDev2OL6yguM/6y5cuKB+/foZjpUvX16TJ092aB53eg9GR0drw4YNVvXcuXMrKCgoQ/MXLVpUdevWTVMLDQ3V2bNnJUnLly+32qdjx44Z6i1JnTt3tqrdunXLbq/nvbj6OmJPKSkpunTpkuFYQECAg9O4Hld6fdxpDXr00UcN66tWrbI5lyP7ZlWDBg0M65s3bzZ9rjVr1tjcw52OrezG6Fxthk2bNhnW69WrZ5f5nMns939UVJROnz5tOFawYMEM9cjpa6Cz5dQ1zZ2ed0REhJYuXWpVz58/v+E9wv2UL19ejRo1sqrPnTtXsbGx990/O9yzm/05i6MUL15cs2fPlsViSVO/fPmyevTooZSUFCclM9ft28Yfat+6dUuzZ89WUFCQ8uXLp9q1a+uVV17RqFGjNHnyZM2YMUPTp0/XZ599pvfee0+9evVS+fLl9cADDyg4OFjnzp1Ld06LxaKpU6eqYcOGdnpWAIw46pxiy/kkvc84evToYVMmOJar3Qdlh+up7Mren22aeR3qrvfS7nD8s/YDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACYb8OGDXriiScUHx9vOD58+HCr713NbgYPHpzud9m99tprGf7dKPfy3XffqUSJEoZj/fr104ULF2yeAwAAexs4cGC6vy/k3Llzaty4sU6cOGHqnHfu3NHLL79sOFa3bl09/fTTps5nDydPnlTTpk3T/U72Z555RuXLl3dsKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADfh4ewAAAAAAAAAAAAAAAAAAAAAAAAAMBZ9zZw+UVfN6eOOLBaLab3Kly9vWq+Mqly5smF9586dps916dIlw3rFihVNn8sMp0+fzvC2jzzyiGH9999/NytOGmFhYfr777+t6h4eHqpUqVKW+27ZssWGVNYefvhhw/qOHTtMnSerOP5ts2jRIs2aNctw7OWXX1bnzp0dlsXd3oMLFy40rGf0NWvfvr3V+WflypWG/31XnTp1VKxYsfv29vHxUVBQkFV91apViouLy1A+M7n6OmJvN2/eNKwHBAQ4OIlrcpXXx53WoPTOfdu3bzcl27/98ccfdumbVem9PvY492/bts3mHu50bGU3Zvz9Gdm9e7dSUlKs6qVLl5a3t7dd5nSWrVu3mt7T6PiUMr7u5/Q10Nly6prmbs/7u+++M6z37ds301leeOEFw/rUqVMztH92uGc3+3MWR/Dw8NCCBQsUGBiYpp6cnKyePXvqypUrTkpmvi5duqh79+46cuSIJCkmJkYffPCBihUrpt69e2vDhg2Kj4/PcL/Lly9r4sSJKleunN555x0lJCQYbufl5aW5c+cqT548pjwPAPfnqHOKLeeT9K4N+vTpo27dutmUC47javdB2eF6Kjuz52ebZl6Huuu9tDsc/6z9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA9rF3716NHj3acKxkyZJq1qyZgxM51q1bt9SrVy8lJSVZjVksFs2cOVOFChXKcv/evXun+31ZM2fO1KJFi7LcGwAARylQoID+85//GI7FxMQoKCgo3e+ctFVycrIuXrxoOPb222/bZU6zXbhwQf379zccs1gs6tOnj4MTAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuAcPZwcAAAAAAAAAAAAAAAAAAAAAAACAsXMHzOnzl0l9XFl8fLxh3cvLy5T+np6eKl26tCm9MqNixYqG9b/++sv0uW7cuGFYL1iwoOlz2erKlSuKjo7O8PYPP/ywYX3//v1mRbKyb9++TGXJiD/++CPL+xqpVKmSYf3AAddYNDj+bTdo0CCdPXvWcGzatGkqVqyYQ3K423tw+fLlhueVDh06yMPj/v8ss1OnToY97woJCdH58+fTjFssFrVv3/6+vVu2bClfX1+r+s8//3zffe3B1dcReyhWrJgaN26s3r17KyAgwHAbb29vB6dyHa74+rjTGlS+fHnDur3eU6GhoUpISLBL76yoUKGCYT0kJMT0uU6fPq3k5GSberjTsZXd/Pnnn3bpe/PmTcNrTQ8PD5UtW9YuczrLsWPHTO958+ZNw3qBAgUytH9OXwOdLaeuae72vLds2aJTp05Z1Vu1aqUSJUpkOIPFYlGfPn2s6vv378/wey473LOb/TmLI4wbN05NmjSxqo8ePVqbN292QiL7SUlJ0YIFC1S1alW1b99e5cqV05gxYxQTE2NT3+TkZH300Udq2LChIiIiDLcpU6aMXnvtNZvmAZBxjjqn2HI++f3333X9+nWruoeHhxYsWKAff/xRNWrUsDkj7MvV7oOyw/VUduOozzbNvA5113tpdzj+WfsBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADs59NPP1VUVJThWOvWrR2cxvH++OMPjR071nCsWLFimj59epb6li5dWl9//bXh2JkzZ/jOVQCA2wgODk73+0EHDRqkkydP2nX+IUOGGNbLli2rMmXK2HVus2zYsEG//PKL4Vjbtm0dnAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMA9eDk7AAAAAAAAAAAAAAAAAAAAAAAAAIwd+UWq86RksWS9x18HpZjrpkVyWXFxcYZ1Hx8fU/qXKlVK8fHxio+Pz9R+vr6+stjwF1iwYEGr2u3btxUREZHlnumJiYkxrOfLl8/m3oMHD9bKlStt7nNXYmJiprYvXLiwYf3q1atmxDF07do1w3pgYGCWex46dCjL+xoJCAgwrNvzdcmM7HL8O1NMTIx69eqlbdu2ydPTM81YoUKF9OOPPyooKMjuOdztPRgdHa0NGzaoY8eOaeoBAQFq0qSJtm7dmu6+3t7eatmyZZralStXtHv37jS1FStWaPDgwWlqHTt21PTp0++ZrXPnzla12NhYrVmz5p772YurryNZ4ePjo9KlS6tcuXIqW7asypcvr7Jly6b+yZMnj7MjOpU7vj7usgZ5eHjIz88vU/1slZycrIiICBUrVswu/TMrf/78hvXr182/oUlMTNTFixdVsmTJLPdwl2MrO/rrr7/s1jsiIkKlS5e2qhtdm7qzCxcumN4zKirKsO7h4XHffVkDnS+nrmnu+Ly///57TZw4MU3Nw8NDvXv31kcffZShHs2bN1epUqWs6lOnTs3Q/lL2uGc3+3MWewsKClJwcLBVfdOmTRo7dqwTEjmOPe55Dxw4oFatWmnz5s3y9/e3Gg8ODtaXX36Z7ufO95OR858Z7jVPSkqKab3MZGZmZA+OOqfYcj5JTEzUhx9+qE8++cRqzGKxqE+fPurTp4/CwsK0Z88eHTlyRKdOnUr9Ex4ebnN+2M7V7oOyw/WUu3GVzzbNug5153tpdzj+WfsBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADsJyEhQStWrNBzzz1nNVarVi0nJHK8cePGKSgoSI0aNbIae/LJJ/XKK6/o+++/z3A/Dw8PzZ492/B7tu7cuaNevXql+91cAAC4Em9vb7388suGY9u2bdOsWbPsnmHRokU6deqUypcvr+joaC1fvlzz5s3Thg0blJSUZPf5zbJw4UKr36cm/e96K3fu3Fn+HnYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDsysvZAQAAAAAAAAAAAAAAAAAAAAAAAGAs/JR0YptU+bGs7Z+SLP02w9xMrio2NjbdMV9fX926dcum/ufOnVO+fPkyvd+xY8dUuXLlLM2ZN29eWSwWq3qePHl0+/btLPW8F6O5JMnHx8fm3levXtX58+dt7pMVefLkkaenp1U9Pj5ecXFxdpv3xo0bhvWsHEd3Xb9+Pcv7/lvevHnl4eFhVY+Pj1d8fLxp82RVdjr+nW3nzp2aMGGC3n//faux1q1b6/XXX9eXX35pt/nd9T24cOFCdezY0areuXNnbd26Nd39mjdvLl9f3zS1VatWKSUlJU1txYoVGjx4cJpaq1at5OPjk+570GKxGGZas2aNXd4X9+Pq68j9FC9eXHXq1FH16tVVvnx5lS1bVuXKlVPx4sXTXRNykuzy+rjTGpTeWExMjJKSkkzJZSQyMlLFihWzW/+MSu/cHx8fr4SEBLvMGR0dneV93enYyo6ioqLs1jsyMtKw7ufnZ7c5ncGW4z89ycnJWd43p6+BzpZT1zR3fd4zZ87UuHHjlCtXrjT1F198UR999FGGevTt29eqFhsbq7lz52Zo/+xyz27m5yz2Vrx4cc2ePdvqtbh8+bJ69Ohhdc+JjNm/f7/effddffXVV1ZjBQsWVLt27bRkyZJ097/Xve+/36P24u3tne6YUT53zIzszZHnFFvPJ//973/VpUsXNW7cON1tSpYsqZIlS6pLly5p6rdu3dLp06d16tQpnTp1Sn/++acOHTqkkJAQjnsHcqX7oOxyPeWqXP2zTbOuQ931Xtqdjn/WfgAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5mY+Pj3x9fRUbG2vX7+bKqfLkyaM8efLY9fX18vJSvnz5FBcX55TvL76Xu88/OTlZN2/edIvv0nKX98TdnAkJCYqJiXF2HLu7+3xv377tcsd5duWux5i3t7f8/PwUFxd3z99t4mzu+vram6enp/LlyyeLxaKYmBglJiY6OxJgyF2uF1zJ3r179dxzz1nVy5cv74Q0jpecnKxevXrp0KFD8vf3txqfPHmytmzZoj///DND/YKDg9P93qzRo0dr165dNuV1Jfny5ZOXl5fbnBdy+j3gv7nLtZmrH2fuej/krrk5HhzrqaeeUqFChQzHRowY4bAcQ4YMkY+Pj9asWeO23yW5ceNGw7qnp6fKlCmjY8eOOTiR++GeFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAnMXL2QEAAAAAAAAAAAAAAAAA/B979x0dVbX2cfyXSgkhgDTpHZQmHRTpnQQCigWU4hVBRb14FVRAFAUrglhAFARBpCok1FAUBKRIbxJ6r6ElQHreP1zyEudMysyZyZzk+1mLdeHZ5zz7OSd79jk7d7kHAAAAAAD7VkyQilaUCpXM/Llrp0rnI82vyRNduHDBbluxYsV09OhRN1ZjjoCAALttuXPndmMl1mbvPt64ccOl/V69etUwnj9/fodzXr9+3eFz/y2r7ktGMf7N9e6776p9+/Zq2LChTdvHH3+s1atXa9++fS7p26qfwbCwMMXHx8vf3z9VvGvXrnr11VftnhcSEmITW7RokU3st99+U3R0tAIDA+/E8ubNqxYtWmjFihWGuRs3bqxixYrZxOfOnWu3Hlfy9HnESPXq1dW7d289/vjjKlu2bFaX43Gy4/2x0hyUK1cuw/jNmzdNqckeT/nMZsXPypl7a6WxlR3dunXLZbntvXPny5fPZX1mhYSEhKwuIZWcPgdmtZw6p1n1ui9evKjw8HB17949Vbxy5cpq0qSJ/vjjjzTPDwwMVLdu3Wzic+bMUXR0dIZqyC5rdjN/z+JK3t7emjNnjgoXLpwqnpycrJ49e+rixYtZVFn2MHHiRL3wwgu6//77bdoeffRR/fzzz3bPjYuLs9vmrs9Cnjx57LYZ1WfFmpG9WemZEh8fr65du2rlypWqU6dOps4NCAhQrVq1VKtWrVTxxMRErV27Vj/++KNmz56t27dvm1ky/sWT1kFWGvtWYaXfbZr1HmrVtbSVxj9zPwAAAAAAAAAAAAAAAAAAAAAAAAAAAICcomDBguratas6duyoWrVqqWLFivLz87vTfuvWLV26dEkHDhzQypUrFRERob1795rWf9GiRW32WZL+3ns+KirKtH68vLx033332cSTk5P1119/ZSqX0b5FadXbqlUrPf7442rSpImqVq2aat/jxMREnTx5Ujt37tSaNWs0b948h/aXqlOnjnr27KkHH3xQNWvWTLX38T8/w927d2vZsmVaunSpTpw4kek+MsvPz08tW7ZUhw4dVKtWLVWvXl1FihSRj4/PnWNSUlJ09OhR7dq1S2vXrtXatWu1a9cuU+vI7M+rUKFC6tGjh1q1aqU6deqobNmyqX5mrv5MZFSNGjXUtWtXNWzYULVq1VLJkiVTfXZTUlJ09epV7du3T7t371ZERIQiIiIUGxtrah1G91eS9u/fb2o/JUuWVLdu3dSsWTPVrl1b5cqVs/ksHT9+/M61Lly4MM3vsPA0mR2n0t97kNSqVUuVKlVSUFCQAgMD5eXldad9woQJTv28PWWMZVZgYKA6d+6sTp066YEHHlCVKlVS7deSlJSk8+fPa/fu3dq6dat++eUX7dy50+11uvP+Fi5cWEWLFrXbXqZMGcN4UFCQ3c+4PfHx8Tp8+HCmzrlbw4YN1bp1azVs2FAPPPCAChcubLM3cHx8vM6cOaO9e/dqx44dWrx4sbZu3epwn2apXLlyqp/hP86dO2d3P9LMCAwMVOnSpW3iBw4cUEpKitP5y5cvb7hf4KFDh9Lcx8uR54CVxqQ9Wf0OnV2cO3fOMB4UFOTmSrLO8ePHNWjQIP3www82bXnz5tWsWbPUpEkTJSYmppmnfv36evfddw3b/vjjD40ePdqUet0tV65cat++vdq3b6/atWvrvvvuU8GCBVO988THx+vEiRPau3evNm7cqIULF5r+uWcN6Jx/v5/VrFnzTpsnvJt5yjhLi1XXQ1asm/HgGZ555hnD+KZNm9Ldi99MS5cudVtfrnLmzBm7bSVKlNCBAwfcWI3ns/KaFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmMM3qwsAAAAAAAAAAAAAAAAAAAAAAACAfXEx0vzh0qPvSYVKZfy8zXOlLfNdV5enuXTpkhITE+Xra/ufy5QqVUpHjx7Ngqqc4+XlldUlZAve3t6G8aSkJJf2ay+/Mz/XGzduOHxuRutw9X3JKMa/uZKSktSzZ0/t2rVLAQEBqdpy5cqln376SfXr11d8fLzpfVv1M3jjxg1FREQoODg4VbxChQqqXr269u3bZ3jev4+PjY3VypUrbY5LSEjQ8uXL1aNHj1TxkJAQrVixwjB3aGioTez27dtaunRpWpfiMp4+j9ytbNmy+uCDD/TEE08wvxjIzvfHqnPQ3VJSUpwtJ03JyckuzZ9RWTGnJCYmOnxudhhbVubKzwX32LPklDkwq+XUOc3K1z158mR1797dJt6vXz/98ccfaZ7bo0cP5c2b1zBnRmWXOdHM37O40vvvv6+mTZvaxN999139+uuvWVBR9pKcnKwZM2bogw8+sGmrX79+mudGR0fbbStUqJCOHTvmdH3pKVSokGE8Li7OcL6xYs3I3qz2TImKilKTJk302WefacCAAfLx8XEqn6+vr1q3bq3WrVvr/fff1/Dhw/X999+bVC08mdXGviez4u82Xf0e6ulraav8nP7B3A8AAAAAAAAAAAAAAAAAAAAAAAAAAAAgOytatKiGDx+u5557Trly5bJ7XN68eVW2bFmVLVtWHTp0kCT9/vvvevvtt/Xbb785XcfgwYP1xhtv2MSHDh2qjz/+2On8/8iTJ4/hvsIxMTEKDAzMVC6jPEb1tm/fXuPHj1e1atXs5vL19VWFChVUoUIFde/eXZ9//rl++OEHjRgxQmfOnEm3lsaNG2v8+PFq1KiR3WPu/hmGhIQoOTlZs2bN0vDhw3XixIl0+8is4sWL67XXXlP//v2VP3/+NI/18vJSxYoVVbFixTt7rG3dulUffPCBFi5caMpeChn9eZUoUUKjRo1S79695efnZzefqz8TafHz81OfPn302muvqWrVqmke6+XlpUKFCunhhx/Www8/rBdffFE3b97UzJkz9dFHH5m275S9/brN2mfi4Ycf1ogRI9SmTZs0c/r6+qpSpUqqVKmSunfvri+//FIzZ87Uu+++q+PHj5tSiytldJx6e3urR48e6t+/v5o3b274/Rz/+O677xQbG5upOjxxjGVUwYIF9cYbb+iFF15Qvnz57B7n4+OjkiVLqmTJkurYsaPefvtt/fXXXxozZox+/PFHl+5XmlX394UXXtC7776b6Xrbtm1r9zNuz++//65mzZpl6hw/Pz8NHDhQAwcO1P3335/u8f7+/ipfvrzKly+vkJAQvf322zp9+rQmTJigb775Jsv2m/z4448Nv09gypQpevbZZ53OP3jwYMOf44MPPpjufqTp8fX11Y4dOxQUFJQqfvXqVRUtWjTNcx15Dnj6mEyLp7xDZxfXr183jOfJk8fNlWStGTNmqHPnznr88cdt2urXr693331Xw4YNs3t+njx59OOPPxq+F0RHR6tXr16W24+7dOnSevPNN/X000+n+VyX/n4uVK5cWZUrV1a3bt30ySefaOvWrRozZowWLlxoSj2sAR2TkfezrHw387RxZsSq6yEr1s148By5c+fWww8/bNg2depUN1djfQkJCbp27ZoKFChg0/bv77LLqbLLmhQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJjDO6sLAAAAAAAAAAAAAAAAAAAAAAAAQNqunZNm/Ffa/6uUkpL2sTFXpPAPpLVT3VKax0hJSdHp06cN26pVq+bmagDXSElvAgDScOTIEb3yyiuGbTVr1tSHH37o5oo839y5cw3joaGhhvFatWqpTJkyqWKrV6/W7du3DY8PCwuziYWEhNitp2vXrjaxZcuW6ebNm3bPgdSmTRvt3LlTTz75pLy8vBzKceXKFW3evFkzZ87UiBEj9MQTT6hevXratGmTydW6H/fHc9h7znt7u/Y/B/fz83NpfgDICOZAIHMiIiJ04sQJm/jjjz+uPHnypHluv379bGL79u3Lke9uVvg9S/v27fXGG2/YxNesWaP33nsvCyrKnozW55JUqVIl5c2b1+55N2/e1K1btwzbihUrZkpt6SlatKhh/Pz584ZxK9YMeJq4uDi9+OKLuv/++zVt2jTduHHDlLwlSpTQ1KlTNWvWLOXKlcuUnEB2Z9XfbZr1Hspa2n2Y+wEAAAAAAAAAAAAAAAAAAAAAAAAAAABkR926ddP+/fv10ksvOfTfPD/88MP69ddfNX/+fAUEBLigQmvz8fHRF198oeXLl2d6n3wfHx/169dP+/btU+fOne0e5+3trU8//VQbN25Uo0aNMtWHt7e3nnrqKUVGRqpv376ZOjctXl5eeu2113Ts2DH973//U/78+R3K06BBA/3888/asGGD7r33XtPqS0vPnj0VGRmp//znPw7tr+COz0S7du106NAhffvtt6patapDOQICAjRgwAAdOnRIn332mXLnzm1yleYpUqSIfv75Z61bt05t27bN9B4jvr6+6tu3r/bu3asXXnjBRVW6V7Vq1bRp0ybNnj1brVu3lq+vr6n5rTzGQkJCdODAAQ0ZMkT58uXL9PnVqlXTDz/8oJ07d6pWrVouqNDa9zcz9u3bl6njH3roIe3cuVMTJkzQ/fff73C/pUqV0scff6zjx4+rT58+Dudxhr3vNggJCXF4n6S7denSxW5+ZzVv3lxBQUE28YULFyoxMdHp/Fkps2MyLbxDm88K+8O6y4ABA3Tq1CnDtjfeeEMPP/yw3XPHjRunKlWqGLa9+OKLOnbsmCk1uoOfn59Gjx6tI0eO6Pnnn3fouS79vab45Zdf9Pvvv6tChQomV2krp64B0+LM+5mr382sMM6suh6yYt2MB8/z0EMPGb5rJScn65dffsmCiqwvNjbWMG727xWsKDutSQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgDn4xkcAAAAAAAAAAAAAAAAAAAAAAAALiIuRFn8kbZkv3d9KKldHCiws+eWWbl2TLh2XDm+S9q+WEuKyutqssWfPHpUrV84mXrt2bfcXY4KUlBTD+LVr1zR79my31REVFeW2vlwhKSnJMO7r69r/tMrPz88wbq8ed0tOTjaMu/q+ZBTj3zWmTJmi4OBghYaG2rT997//1dKlS7Vq1SpT+7TyZ3DRokWKj4+Xv79/qnhoaKhGjx5tc3xwcLBhDnuWLl2qpKQk+fj43ImVKVNG1atX1759+1IdW7VqVVWtWtUmx7x589K9Dlfx9HlEkjp27Kjw8PBU99iemJgYRUZGKjIyUocOHUr1v1evXjU8JzY21uyS3Son3B8rzUG3bt0yjOfPn9+UmuwpUKCAS/NnlL17Y+9emsGZ3FYaW+7m5eXl8j78/PyUkJDgktz/fu7/w5PucXaU0+fArJZT5zQrX3dKSoqmTJmiUaNGpYrnz59f3bp106xZswzPq1Chgpo2bWoTnzx5cob7/qd/I6zZzVWiRAnNnDnT5tl6/vx5Pfnkk3Z/Dsi8Q4cOKSUlxeZee3l56Z577rH7nJL+/nlUqFDBJl6+fHnT6zRi1Lf0d132WLFmZF+e8Exx9HkSGRmpfv36acCAAWrRooUaNGigevXqqVq1aqpQoYJy5crlUN4nn3xSgYGBCgkJceh8WIMnjH3J2u9TOeF3m+mx6lrayuOfuR8AAAAAAAAAAAAAAAAAAAAAAAAAAABAdjFkyBB99NFHpuR65JFHVLVqVYWEhOj48eOm5LQ6b29vLViwQF27dnUqT1BQkMLDw9WzZ0+b/ybf399fixYtUocOHZzqw9/fX99//71Kly6t9957z6lc+fPn16JFi9SiRQun8tytSZMm2r59u0JDQ7V582bT8v7b+++/r2HDhpmSyxWfCW9vb33xxRd64YUXTMknST4+Pho8eLCCg4PVpUsX/fXXX6blNkPDhg0VHh6uokWLOp0rICBAX331lR544AENHDjQ7t7anq5Ro0Zavny5S/bStPoYe/311/XRRx+Zsi9uzZo1tXXrVg0YMEDTpk1zvjhZ//5m1r/32E9Lnz59NGXKlAztJZRRBQsW1LRp09S1a1c9+eSTiotz3xf4hIeHKzY2Vrlz504VL1q0qBo3bqw//vjD4dzFixdX3bp1DduCg4P11ltvOZxbkrp162YYnzt3rlN5PUFmxmRaeId2jX9/Xv5x+/ZtN1eS9a5fv66nnnpKv/76q7y9vVO1eXt7a+bMmapZs6Zu3LiRqi04OFgDBgwwzDlnzhzNmDHDZTWbrVSpUgoPD9cDDzxgWs6mTZtq9+7devzxx7VkyRLT8t4tp64B02LW+5kr3s2sMM6suh6yYt2MB89cH7du3dowvmvXLl2+fNnN1WQP7vgeGSvKbmtSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgDt+sLgAAAAAAAAAAAAAAAAAAAAAAAAAZd/HI339ga/fu3QoJCbGJP/zww1lQjfNiY2MN4zExMXr++efdXI11xcTEGMYLFCjg0n4LFSpkGL9x44ZL+80oe+MrKCjIzZUYY/y7zrPPPqtGjRrp3nvvTRX38vLS9OnTVbNmTV25csW0/qz8Gbxx44ZWrlypzp07p4rXq1dPJUqU0NmzZ1PFu3TpkurfKSkpWrx4sd38V65c0YYNG9SsWbNU8ZCQEO3bty9VrGvXrjbnx8bGppnf1Tx9HilXrpxmzZolHx8fw/aoqCgtWLBAK1eu1NatW3XixIlM9+Hl5eVsmVkmp9wfK81BN2/eVEpKis19y507t3Lnzm33M+csV9+LjLp586Zh3JVzSkBAgMPnWmlsuVuePHlc3kdQUJAuX77sktz2fob2fuYwR06fA7NaTp3TrH7dU6dO1ciRI23e5/r166dZs2YZntO3b1+bWFxcnGbMmJGpvlmzu8ecOXNUuHBhm3hAQIA2b95sWj/58uWziY0ZM0Zvvvmm4fFvvPGG5syZY1r/niAhIUFXrlzRPffcY9MWFBSkU6dO2T03MjJSFSpUsInfd999ptZoj71+Dh06ZPccK9aM7Cs7PFPi4+MVERGhiIiIOzEvLy+VKlVKlSpVUqVKlVS5cuU7f69UqVK666bg4GC99dZbGjNmjKvLRxbJDmM/K+WU322mx6pr6eww/pn7AQAAAAAAAAAAAAAAAAAAAAAAAAAAAFjZiy++qI8++sjUnDVq1FBERITq1aun6OhoU3Nb0cSJEw33E3bEP/tGHzt2LNX+U7Nnz1aHDh1M6UOSRo0apWPHjmnmzJkOnV+wYEGtXr1aderUydDxycnJun37tnLlyiVfX980jy1evLgWL16sunXrprknlKOGDRumYcOGmZrTzM9E7ty5NW/ePAUHB5tUXWqVK1fWxo0bFRISog0bNrikj8xq3ry5Fi9ebLhPmjP69+8vLy8v9e/f39S87lChQgUtX77cJfslWn2Mvfzyy/r4449Nzenv76+pU6cqf/78mjBhglO5rH5/HfHvPfbt6devn6ZMmZLh/X5u376tlJQU5cmTJ0PndOvWTStWrFD79u0VFxeXoT6cFRMToxUrVhi+B4SGhuqPP/5wOHdwcLDd665Zs6bKlCmjkydPOpz/39+zIEnXrl3T6tWrHc7pKTI6JtPCO7TrFC9e3DAeFRXl5ko8w7p16/TJJ59o6NChNm1lypTRpEmT1LNnzzuxokWLaurUqYa5Tp06pQEDBrisVrNVrlxZq1evVunSpTN0fGJiohISEjK0L35AQIAWLlyop556yiX76ubENWBazH4/M/PdzArjzKrrISvWzXjw3PVxrVq1DOPr1693cyXZh73v/rl9+7abK/Ec2XFNCgAAAAAAAAAAAMBW7Qdqq1HDRlldBnKgHTt3aOuWrVldBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABzkm9UFAAAAAAAAAAAAAAAAAAAAAAAAAGZYv369YbxGjRoqXry4zp8/7+aKnHPr1i2lpKTIy8srVbxQoUJZVJE1xcXFKTExUb6+qf9TKl9fXwUEBOjmzZsu6bdgwYKG8ejoaJf0l1n2xpefn5/y5Mmj27dvZ1Flf2P8u05UVJT69u2r5cuX29zfEiVK6Ntvv9UjjzxiWn9W/wzOnTtXnTt3ThXz8vJSly5dNGnSpDuxIkWKqGHDhqmO27Ztm86dO5dm/rCwMDVr1ixVLCQkRB9++GGqWGhoqM25K1asUExMTEYuwyU8fR4ZM2aMChQoYBOPiYnRm2++qcmTJys+Pt6pPvLly+fU+Vkpp9wfq81Bly9fVpEiRWzixYsX1/Hjx80oLZWAgAC7tbpbbGyskpOT5e3tnSru6+urvHnz6tatW6b3GRQU5PC5VhtbafHx8XH4XCOBgYGm5jNSoEABXb582WW5jWTlMzenyMlzYFbLTnNaZlj9us+cOaNly5YpODg4Vbx169YqXbq0Tp06ZXNO7969bWILFizQ1atXM9U3a3b3aNq0qWE8MDDQ5c/be+65R/fcc49hm6uewVktJibG8Jr9/f3TPG///v3q0KGDTbx+/fqm1ZYWe/3s27fP7jlWrBnZV3Z9pqSkpOjUqVM6deqUfv3111RtXl5eqly5sjp06KCBAwfqvvvuM8zx5ptvatKkSbpy5Yo7SoabZdex7y455XebGWHFtXR2Hf/M/QAAAAAAAAAAAAAAAAAAAAAAAAAAAACsoHHjxvr8889t4ikpKVq3bp0WLlyoP//8U2fOnNGtW7eUP39+FSlSRHXq1FGnTp3Uvn17u3sYVq5cWdOnT1f37t1dfRkerXv37nruueds4kePHtX06dO1du1anThxQrGxsSpUqJDuvfdetWrVSo8++qiqVKlimNPf319TpkzRAw88oMTERP3vf/9Tt27dbI67du2aZs+eraVLl+qvv/5SdHS08uXLp2LFiql+/frq1q2bmjdvbrf2r7/+Whs2bNCxY8cyfd0//vij6tSpY7f9999/1/z587VhwwZFRkam2nstMDBQ/fr1U+/evVWvXj3D8wsXLqwFCxbooYceUkJCQqbrs6dNmzYaNWqUTdyTPhMzZsyw2XPubsnJyfrjjz8UHh6urVu36vz587py5Yry5s2rYsWKqVKlSurUqZM6dOhgd8/NggULasmSJWrSpIkOHDjgVL3OqlixohYuXJjm/h9xcXFas2aNli5dqt27d+vChQu6du2acuXKpXvuuUc1a9ZUmzZt1LVrV+XPnz/Vuc8++6x27drl6sswlY+Pj37++We7Pz9nWXmMNWvWTOPGjbOJx8fHa8WKFVq2bJl27typ8+fP69atWwoICFCxYsXu7AXSsWNHuzV7eXlp/PjxOnr0qBYvXuxwjZ5yf0+fPq1NmzbZreOee+5R5cqVbeJXrlxRZGRk2hf5L3v37k33mAoVKujLL7+02YfmH2fPntWsWbO0YsUK7d27VxcvXlRycvKd9kKFCqlKlSpq2rSpHnnkETVu3NgwT/PmzTVhwgQNGDAgU9fgjDlz5qhr16428dDQUA0dOtThvF26dEmzvXPnzpo4caJDuevUqaPSpUvbxBctWmTqc/dunjYm08I7tGtVrFjRMH7p0iU3V+I5hg8frjZt2hi+Gz/55JMKDw/XTz/9JEn6/vvvDfciS05O1tNPP63r16+7vF4zFCpUSBEREYZz0T92796tOXPmKCIiQkeOHLmzp7K/v78KFy6s+vXrq127durVq5fhM9PX11fTp0/X8ePHtXnzZtNqz6lrQHsy+n529OhRt7+bWWGcWXU9ZMW6GQ+evT42eg+U5LH1errAwEDlzp3bsM0q7wpmy85rUgAAAAAAAAAAAACpFSpYSJWrGP//0IArnTp9KqtLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgBN8s7oAAAAAAAAAAAAAAAAAAAAAAAAAwAxr165VfHy8/P39U8W9vLzUo0cPffHFF1lUmWOSkpJ06dIlFS1aNFU8b968yp07t2JjY7OoMus5c+aMypYtaxMvXry4jhw54pI+ixcvbhg/f/68S/rLrOTkZF24cMGwzmLFiun48ePuL+oujH/XioiI0BdffKGXX37Zpq179+7q27evpk2bZlp/Vv4MLlq0yPDZEhoaqkmTJt35d+fOneXl5WVzbnrCwsL06aefpoo1btxY99xzj6KioiT9/Zls3Lixzblz587N8HW4gifPI+XKldPjjz9uE4+Li1ObNm20efNmU/opXLiwKXncLafdHyvNQQcPHlSRIkVs4g0bNnTJZ6p+/fry9vY2Pa+jLly4oHvvvdcmXqxYMR07dszUvnLnzm3355RRVhpb0t/vV0YCAwOdqunfSpcubWo+I8WKFdPhw4ddltvI5cuXXdIf/l9OnwOzmtXmNLNY/bonT56s4ODgVDEvLy/17t1bo0ePThVv2bKl4bVOnjw50/2yZs/Zjh49mtUluISvr/E2TMnJyWmet23bNsN43bp1lS9fPsXExDhdmz2BgYF64IEHDNt27Nhh9zwr1ozsKyc+U1JSUhQZGanIyEh98cUXGjlypEaOHGlzXL58+fTss8/q448/zoIq4Wo5ceybJaf9bjM9VlxL58Txz9wPAAAAAAAAAAAAAAAAAAAAAAAAAAAAwFNMnjxZPj4+qWJLlizR0KFDtW/fPpvjL1y4oEOHDmnjxo366quvdP/992vChAlq3bq1Yf5u3bqpR48emjdvnkvq93R58+a12Qs/Ojpa//vf/zRlyhSbPY3Onz+v/fv3a/Xq1RoxYoRefPFFffLJJ8qVK5dN7urVq+uZZ57R6tWrNWbMmFRtKSkpGj9+vN555x3duHHD5tzDhw9rw4YN+vzzz9W2bVt9++23hvuSBQYG6tNPP9UjjzySqet+6aWX1LFjR8O27du36/nnn9eWLVvsnh8dHa0JEyZowoQJ6t69u77//nvlz5/f5rgGDRqob9+++vbbbzNVnz25c+fWd999Z7OXgid9JkaMGKFHH33Ubvvy5cs1ZMgQ7dmzx7D96NGj+uOPPzRjxgwFBATo1Vdf1ZAhQ5QvXz6bY4OCgrRkyRI98MADhuPIHXx9ffXzzz+rQIEChu1JSUmaOnWq3n33XZ05c8bwmJMnT2rHjh364YcfFBgYqJdfflnDhw9X7ty57xzz0Ucf6cqVK664BJcYNGiQateubRO/evWqFi1apMWLF2vPnj26cOGCrl+/nqncVh9j//4Mp6SkaOLEiRo9erTOnj2bZs0//PCDAgICNHjwYL3++uuG846Xl5d+/PFHVa9eXadPn850fZ50f6dOnaqpU6faraV79+5asGCBTXzNmjXq0aOH3fMcNX78eOXNm9cmnpycrLfffluffvqp4uLi7J5/5coVbdq0SZs2bdKnn36qBx98UBMnTlStWrVsjn3uuec0f/58rVy50tRrsCc8PFyxsbGp5h1JqlKliqpWraqDBw9mOmeuXLnsPmv+ERISookTJ2Y6t/T388qIK9/pPG1MpoV3aNfq0qWLYXzr1q1ursRzJCYmqmfPntqxY4fhXDlx4kRt2LBBnTp1UqdOnQxzfPzxx1q7dq2rSzXNnDlzVK5cOcO2U6dO6dVXX9X8+fMN2+Pj43X27FmFhYUpLCxMb731loYOHao33njD5l0/V65cmj9/vqpVq6abN286XXdOXQOmJbPvZ+58N/P0cWbV9ZBV62Y8/M0T18fe3t4qX768YZsj79KQ7rvvPrttZn8XkFVk5zUpAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwnnf6hwAAAAAAAAAAAAAAAAAAAAAAAACe7/bt21q7dq1hW//+/d1cjTlOnjxpGK9Ro4abK7G2/fv3G8YbNWrksj4bNmxoGN+3b5/L+sysEydOGMbr1avn5kqMMf5da8iQIdq7d69h2xdffKEKFSqY1peVP4PXr1/XqlWrbOItW7ZUYGDgnX936dLF5piwsLB08x86dEgHDx5MFfP29lbHjh3v/DskJEReXl6pjomLi1N4eHi6+V3NU+eRTp06ydvb9j+h/frrr7V582ZT+vD29lbRokVNyeVuOe3+WGkOOnDggGG8adOmTtdkxJX3wBGRkZGG8fr165veV5UqVWzm1syy0tiSpKtXrxrG8+fP71RN/1a1alVT8xlxxZiQpJIlS6pYsWI28YSEBB07dswlfeL/5fQ5MKtZbU4zi9Wve8mSJTp79qxNvF+/fjaxvn372sQOHTpk93dp6WHNnjMlJSXp1KlTWV2GSxQpUsQwfvPmzTTPs/cZ8vPzU9u2bZ2uKy3t27eXn5+fTTwpKUkbNmywe54Va0b2lpOfKSkpKXrnnXf09ddfG7a3b9/ezRXBnXLy2HdGTvvdZnqsupbOyeOfuR8AAAAAAAAAAAAAAAAAAAAAAAAAAABAVqpZs+advycmJmrAgAEKDg7O8D5Y+/fvV7t27fT999/bPWbIkCFO12lV//nPf1SiRIk7/z5+/Ljq1q2rb7/9VsnJyWmem5ycrC+++EI9evRQYmKi4TGDBw/We++9J39//zux27dvq3Pnznr11Vd148aNdGtcuXKlmjdvrjNnzhi2d+3aVaVKlUo3zz/y58+vkSNHGrbNnDlTDRs21JYtWzKc7+eff9ZDDz2k69evG7a//vrrTu8n+o9nn31WZcuWvfNvT/tM1KhRQyNGjDBs+6fWjh07as+ePRnKd/PmTb333nuqXbu23T0rypcvr48//tihes3wyiuvqFatWoZtV69eVbt27fTcc8/ZHb//Fh0drdGjR6tOnTqp9hXNmzdvpsZ5VsqbN6+GDx+eKhYXF6ePPvpI5cuXV79+/bRgwQJFRkba/dzYkx3GWOXKle/8/fr162rdurVefPFFw30ajdy8eVPvv/++6tata7fm/Pnza9y4cZmuLTvcX1cpUqRIqn347/bkk09q9OjRiouLy1TOjRs3qkGDBvr5558N20eNGpXpOh0VExOjFStWGLZ17drVoZytW7dW3rx50zymVatW6R5jj1FdN27cUEREhEP5shveoV2nadOmqlatmmFbTt+jMjIyUoMHDzZsCwoK0i+//KLPPvvMsH3btm12n0Ge6KmnnlKbNm0M2zZs2KB69epp/vz5Gc5348YNDRs2TJ07d1Z0dLRNe6lSpfTuu+86XO/dcuIaMD3OvJ+58t3MCuPMqushK9bNePDs9XGJEiUM97CWlOHrRWpG36smSZcvX9a5c+fcXE3Wy+5rUgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4DzvrC4AAAAAAAAAAAAAAAAAAAAAAAAAMMv06dMN4zVr1lSnTp3cXI3z9uzZYxhv1KiRmyuxtr179xrGmzZt6pL+qlatqnvuuccmHhcXpyNHjrikT0fs3LnTMN6kSRP3FmIH49+14uLi1LNnT8XFxdm05cuXTz/++KN8fHxM6cvqn8G5c+faxPz9/dWhQ4c7f2/btm2q9lOnTmn37t0Zyh8eHm4TCwkJufP30NBQm/aIiAhFR0dnKL8reeo80qxZM8P47NmzTeujXr16ypMnj2n53Cmn3R8rzUG//vqrYbx79+6mzcl369mzp+k5nXHw4EHDuCvmlObNmzudw0pjS5KuXr1qGC9fvrzTtd3NjHubHlc9Zxo3bmwYP3LkiJKTk13SJ/5fTp8Ds5rV5jSzWP26k5OT9f3339vEK1asmOoaAgIC9Mgjj9gc9+2332a6z3+wZs+ZTp06pcTExKwuw3RFixaVv7+/Ydvly5fTPPfMmTN232Offvppp2tLS+/evQ3jW7ZsUUxMjN3zrFgzsjeeKdLbb79tOL82aNAgC6qBuzD2HZPTfreZHquupRn/zP0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAslZycrIef/xxTZ482aFzn3nmGa1bt86wvX79+nb3B8juSpUqdefvUVFRatmypQ4fPpypHOHh4Ro7dqxhW7Vq1fTkk0/e+XdycrK6d++uZcuWZaqPEydOqE+fPoZtPj4+GjhwYIZz+fn56aefflJsbGyq+NKlS/X0008rKSkpU7VJf+8R9+KLLxq2Va5cWR07dsx0TiOlS5e+83dP/ExMmjRJfn5+NvGEhAR16tTJoVol6ejRo2rUqJE2bdpk2P7cc8+pYcOGDuV2RoECBTRy5EjDtitXrqhRo0Zas2aNQ7n/+usvPfTQQzp9+rQzJWaJJ598UoULF77z78uXL6tVq1Z64403dP36dadyZ6cxduvWLbVq1crufizpOXLkiBo1aqTt27cbtj/66KN66KGHMpUzO91fs4WEhMjX19cmPmfOHMPvBMio+Ph4Pf744/rjjz9SxVeuXKm3337b4byOsHcdRt85kBF3f2+BPbly5VKbNm0ynbtcuXKqVauWTTwsLEwJCQmZzpedeeL7gpXlypVL3333nWHbtWvXMv2Omx1NnjxZYWFhhm1169Y13C/t1q1b6tmzp2X2j82dO7c+/vhjw7Zdu3apTZs2unTpkkO5ly9fbncf1JdeeknFihVzKO/dcuIaMKOceT8z+93MCuPMqushK9bNePD89XFgYKDdtgsXLrixkuwhd+7ceuqppwzb1q5d6+ZqPENOWJMCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADneGd1AQAAAAAAAAAAAAAAAAAAAAAAAIBZfv75Z12/ft2wbezYsfL19XVzRc7ZsmWLYbxFixbuLcTiVq5caRgPDg6Wj4+P6f2FhoYaxteuXaukpCTT+3PU5s2bDeOdOnVycyXGGP+ut2fPHr311luGbY0bN9aIESNM6cfqn8GFCxcqPj7ebj8tWrRQvnz5UrWFhYVlOP+iRYtsYh06dJCvr68CAgLUpk0bm/Z58+ZlOL8reeo8cu+99xrGDxw4YFofrVq1Mi1Xesz+nGS3+5MeK81BK1euVEpKik28ZMmS6t69uxnl3dG4cWPVrl3b1JzO+v333w3jHTt2NL2vkJAQp3NYaWxJ0pUrVwzjdevWdaasVHx9fdWuXTvT8tnTqlUr+fv7m57X3vNr/fr1pvcFWzl9DswMV8wxVpvTzJIdrvvbb781/Oz069fvzt979OihgICAVO0JCQmaNm2aQ31KrNndoVGjRm75895779n0/fHHHxseGxwcnAV3wvXsvb9cvXpVV69eTfd8e2v0kJAQlS1b1qna7KlQoYLdd5c5c+ake74Va84qrngeZBVPvRaeKVJUVJR27txpEw8MDHTJ2scTeOp4dCfGvmNy2u8202PVtTTj3z1zP3MtAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHtGjhypn3/+2akcffv2VUJCgmFb165dncqdHfTp00fHjx936Nz333/f7h6Sd/voo4+0fPlyh/pYvXq13XPbt2+f4TxRUVF66aWXVL58eY0dO1Y3b97UtWvX1Lt3b4fq+sePP/6oPXv2GLa1bt3aqdxGPO0z8fDDD+uhhx4ybHv99dft7qOXUdHR0XrkkUd08eJFmzYvLy+7+5a70jPPPKPAwECbeEpKip566ikdOnTIqfznzp3TI4884lHfE5ARVapUufP3a9euqUmTJtq4caPTebPbGHvhhRe0fft2p3L8U7O9/ef++9//ZjhXdru/ZqtYsaJhfPr06U7nTkxMVL9+/XT79m3NmDFDtWvXVrt27Zy+55kVFhamuLg4m3jjxo1VtGjRTOf7916QiYmJhnsmO7Lvtr1n1Ny5czOdK7vztPcFK8ufP7+WLVumqlWrGrZPnTpVt2/fdnNVnumZZ57R+fPnM3z84MGDFRkZ6cKKzNWzZ0/D/eVu3Lihbt26KTY21qn8Cxcu1HfffWcT9/f314svvuhU7n/LKWvAjHL2/czMdzMrjDOrroesWDfjwfPXx//eT/8fKSkpunXrlpursb5hw4bZ3XN89uzZbq7GM+SENSkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHCOd1YXAAAAAAAAAAAAAAAAAAAAAAAAAJjl9u3bmjBhgmFbtWrVNGrUKDdX5JyIiAjDeJcuXVSkSBE3V2Nda9eu1c2bN23ipUuX1qOPPmpqX35+fnr55ZcN28LCwkzty1nLly83jN93331q3bq1m6uxxfh3j88++0yrV682bBs+fLhKlSrldB9W/wxev35dq1atsol37txZvr6+CgkJsWlbtGhRhvNv3LhRUVFRqWL58+dX06ZN1b59e+XKlStVW3x8vMfMJ546jxQsWNAwHhsba0p+b29v9e/f35RcdzP6nEhSYGCgqf1Y9f44ykpz0OXLlw3nG0kaOXKk/P39narvbu+9955pucyycuVKw3i1atXUpk0b0/qpUKGCKfmsNLYkaf/+/Ybx4sWLq1KlSg7XdrdHHnnELe9pRYoU0RNPPGFqzsKFC6tnz56GbfaedzBXTp8Djbjr3UCy3pxmluxw3SdOnDD87Dz22GPKmzevJKlv376GfV66dMnhflmzu96WLVvc8ufw4cM2fR85csTw2H379rn9PlSoUEGdO3d2aR+PPfaYYXzz5s0ZOn/mzJlKSUmxifv6+mrkyJFO1WbPO++8Ix8fH5t4YmKi5s6dm+75VqzZ1dz53HU1q12L1Z4pxYsXd0nes2fPGsYLFCjgkv7cxWrj0Z2sNvY9RU773WZ6rLqWttr49/S5n7kWAAAAAAAAAAAAAAAAAAAAAAAAAAAAQGbs2rVLH3zwgdN5jh07poULFxq2NW3a1On8VrZo0SItWbLE4fNjYmK0YMGCNI85c+aM03sBTJ061TBeu3Ztmz2R03P+/Hm99tprKlu2rLp06WKz37IjvvnmG8P4ww8/7HTuu3niZ+K1114zjK9atUqff/55ZkszdPbsWbv7bHTp0kWVK1c2pZ+Mev755w3j06ZN07Jly0zpY8uWLXbHlRU888wzhnvHOSI7jbHff/9d06dPNyXX8ePHNWTIEMO20NDQDOfJTvfXFUqUKGEYP3LkiCn5Dx48qGLFiql3797avXu3KTkzKyYmRitWrLCJe3l5GX6vQVoeeOABm++LWLt2reG4d2TvRqOxHR0dbXefoJzKE98XrKpjx47avHmzWrZsadgeFRWlDz/80M1Vea6oqCj16dPHcA/RfwsLC9PkyZPdUJV5Bg0aZBifMGGCjh07ZkofH3zwgZKTk23ivXv3NiW/lDPXgGkx6/0svXezjO4RZ4VxZtX1kBXrZjz8zZPXxwEBAYbxuLg4N1difX369NFbb71l2HbmzBmP+f4zd8sJa1IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOAc76wuAAAAAAAAAAAAAAAAAAAAAAAAADDTZ599puvXrxu2vfHGG3rsscfcXJHjjh49qj179tjE/f391b9/f1P7CgoKUvHixU3N6Sni4+M1Z84cw7Zhw4bJz8/PtL6ee+45lShRwiYeFxenefPmmdaPGc6dO6cNGzYYtr355pum9vXcc8+pdu3amTqH8e8+vXv31pUrV2ziPj4+ypcvn9P5s8NncO7cuTaxoKAgNW/eXCEhIani0dHR+u233zKcOzk5WUuXLrWJh4SEKDQ01Ca+atUqu885d/PUeSQ6OtowXqRIEVNqefLJJ1WxYkVTct3t6tWrhvGyZcua2o9V74+jrDYHffHFF4bx6tWra/To0U7V94/nnntObdq0MSWXmS5cuKCNGzcatr311lum9fPee+/Jy8vL6TxWG1uRkZGKiooybOvbt68z5UmSfH199c477zidJ6Nee+01+fj4mJbv1VdfVe7cuW3iN2/eVEREhGn9IG05eQ404q53A8l6c5pZsst1T5482SaWL18+PfLIIypfvryaNWuWoXMygzU7XK169er68ccfFRkZqR9//FEFCxZ0ST9Nmza1Wdf/I6PvAAcPHtSKFSsM2/r27Wv4GXRGy5Yt9fTTTxu2zZ07V+fOnUs3hxVrdjV3PnddzWrX4q5nirPPk1KlSmnixIk6ceKEunbtalpd//D39zeM37592/S+3Mlq49GdeJ9yTE773WZGWHEtbZXxb5W5n7kWAAAAAAAAAAAAAAAAAAAAAAAAAAAAQGaMGDFCSUlJpuT6/vvvDeN169ZV3rx5TenDit577z2ncyxYsCDN9vHjxzu9N8nixYsVHx9vE/fz81OdOnUcyhkVFaXff//dqbr+sWbNGsN4nTp1TN2P0tM+E4GBgerYsaNh2wcffOBwbUbCwsK0b98+m7iXl5ceffRRU/tKS5UqVVSpUiXDtrFjx5ra1/vvv6/ExERTc7rDL7/8ol9++cWUXNltjJkx595txowZunTpkk3c19c3Q+dnt/vrCrly5TKMp6SkmNaHvb2K3Mnouw0kGX73QFqCg4NtYmFhYVq8eLHNPbv33ntVt27dDOcuWLCgHn74YZt4eHi44uLiMlVndudp7wtWU7JkSQ0aNEgbN27U0qVLVa1aNbvHDho0yHAezskiIiLs7jf2j/Pnz+uZZ55xU0XmKFOmjOG649atWxo3bpxp/Rw9elSrVq2yiZctW1b33XefKX3k5DWgETPfz9J6N+vQoUO651thnFl1PWTFuhkPqXnq+tjeesHMWitWrKhOnTo5/cdT391y586t999/X99//728vb0Nj3nnnXcMnwk5QU5ZkwIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMcZfyMkAAAAAAAAAAAAAAAAAAAAAAAAYFHXrl3T0KFDDdu8vLz0448/6oknnnBzVY779ttvDePDhg1T5cqVTetn3LhxOnjwoF5++WV5e2e//+zo008/VUpKik28Zs2aGj9+vCl91KlTR59++qlh2w8//KCLFy+a0o+ZJk2aZBhv3bq1XnnlFVP6qF+/viZOnKidO3cqPDxcDRs2zPC5jH/3OHv2rJ577jmX9mH1z+DChQuVkJBgEx8xYoTKli2bKrZixQrDY9OyaNEim1jXrl0VHBxsE583b16mcruaJ84jly9fNow3adLE6VpKliypcePGOZ3HyJkzZwzjlStXVrFixUzrx6r3xxlWmoMWL16s3bt3G7a9+uqrevbZZx2uUZLatm1r2jW7wldffWUYb9mypf73v/85nb9Dhw7q2bOn03n+YaWxJUkbN240jPfv318FChRwpLw73nrrLVWrVs2pHJlRs2ZNffLJJ6bkat68uYYMGWLYNmPGDEVHR5vSD9KX0+fAf3PXu8E/rDanmSU7XPfChQsNc/Tr1099+vSRl5dXqviJEye0cuVKp/qUWLPDNapXr66FCxdqz5496tmzp3x8fBQUFKQpU6aY3leBAgU0efJkw7akpCTNnj07w7lGjx5tGPfy8tJPP/2ke++916Ea/61kyZL66aefDNuSk5P10UcfZTiXFWt2JXc/d13JitfijmeKo8+TUqVK6euvv9aRI0c0cOBA+fv7a8KECSpUqJApdf2jUqVKNrFbt25Zfj1ixfHoTrxPZV5O/N1meqy6lvbk8W+1uZ+5FgAAAAAAAAAAAAAAAAAAAAAAAAAAAEBGnThxQuHh4abl27Bhg+E+Xr6+vjZ79uYUu3bt0rZt25zOk1aO5ORkTZ8+3ek+bt++rb/++suwrXz58k7nd9Zff/2lmJgYm7ivr68KFixoSh+e+Jlo166d/Pz8bOJ79+7VmjVrnK7x3+ztKxESEmJ6X/a0a9fOML5u3Trt27fP1L7OnTunxYsXm5rTHczc/yM7jTGz9la8W1xcnFN732Wn++sq165dM4x7wrPHTGFhYYqLi7OJt2nTRnnz5s1wni5dutjEwsPDdf78ef355582bUbfbWBPcHCwfHx8bOKe9l0IWc0T3xfcKTQ0VEOGDMnQn6FDh+qdd97R2LFjNXnyZK1evVrnz5/X6dOn9cUXX6S7X9ioUaMytRdoTnL69Ok0269fv66bN2+6qRpztG3b1jC+atUqXblyxdS+fvvtN8N4ixYtnM7NGjA1s9/P0no369ChQ7rnW2GcWXU9ZMW6GQ+pWXV9bIaXX35ZS5YscfpPqVKlsvpSUilSpIheeukl/fXXXxo2bJjN9xP8Y82aNfruu+/cXJ3nyClrUgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4DjvrC4AAAAAAAAAAAAAAAAAAAAAAAAAMNs333yjX3/91bDN19dXP/30k8aNG6fcuXO7rIaWLVuqaNGiTueZMmWKLl26ZBPPmzevfvzxRwUEBDjdx7PPPqt+/fopf/78+vzzz7V9+3Y1adLE6bye5MCBA5o7d65h2wsvvKDBgwc7lb9y5cr65ZdfDMdUbGysPvzwQ6fyu8pPP/2kQ4cOGbZ98skn6tSpk1P5ixcvrnnz5snb++//lC04OFibN2/WypUrM/T5YPy7z4IFCzR9+nSX5bf6Z/D69etatWqVTbx58+Y2sUWLFmU6/4oVKxQfH58qVrFiRRUsWDBVLDEx0aH8ruSJ80hkZKRhfMCAAU7VkjdvXs2fP19FihRxKo89Z86c0enTpw3bXnjhBdP6ser9cYaV5qCUlBS9/PLLhm3e3t769ttvNWzYsDuficx44oknFB4erjx58mT6XHeZN2+eTp48adj24YcfKiQkxOHc999/v2bNmuXw+UasNLYk2a21aNGiGjdunEM1SlLXrl01cuRIh8931ODBg9W/f3+nctx3332aPXu2fHx8bNoSExM1fvx4p/Ijc3L6HPhv7no3+IfV5jSzZIfrTkxMNFzPtWjRQs8//7xN/LvvvlNKSorT/bJmx7/5+fnpiy++sPsnIwoUKKCuXbvKy8srVbxbt26mPpcDAgK0dOlS3XfffYbts2bN0rlz5zKcb/369Zo/f75hW4kSJfTrr7+qZMmSDtX6j9KlS+vXX39VsWLFDNu///577d69O8P5rFizK7n7uetKVrwWVz9TnHmeTJo0Sc8//7z8/f3vxMqUKaN58+aZ9m7ZsGFDVapUySZu7+f4DzPmXVez4nh0J96nMi8n/m4zPVZdS3vy+Pfkud8Icy0AAAAAAAAAAAAAAAAAAAAAAAAAAACAjFq8eLGp+W7cuKEjR44Ytv17X92cYsWKFabkuXz5suF/ly9JO3futNuWWfv27TOMFyhQwJT8zkhJSbG7F1ShQoVM6cMTPxMtW7Y0jC9fvtzhutJiL2+jRo2UK1cul/Rp1JcRe9814aylS5e6JK+r/PXXX1q3bp1p+bLTGIuIiHDqfHvWrFnj8LnZ6f66ir25/cknn3RzJa4VHR1tOEZz586t9u3bZyhHsWLFVL9+/VSxvXv36tixY5KMvxMhM3t4h4aG2sRu3rzpsvFqVZ74vuBOTz75pD766KMM/fnwww81cuRIvfrqq+rfv79atWpldz/Ku6WkpGjUqFFZss+5FTzwwAN6//330zymatWqGjt2rJsqMkfTpk0N42atqe62adMmw3j16tWdzs0aMDVXvJ/Zezdr0KBBuudaYZxZdT1kxboZD7astj42S+XKlbO6hFQqVqyounXrZvhP/fr11bJlS3Xt2lX9+/fXl19+qfXr1+vs2bOaMGGCypYta7evI0eO6PHHH3fj1XmenLImBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjvPO6gIAAAAAAAAAAAAAAAAAAAAAAAAAV3j88cd18uRJu+3//e9/dfDgQfXp00d+fn6m9Onn56fg4GBt2LBBa9asUaFChZzOeevWLY0cOdKwrUGDBlq3bp2KFi3qcP6XX35Z33zzTapY7dq1tWHDBrVv397hvJ7olVde0fXr1w3bPvvsM02aNEn+/v6Zztu2bVtt2bJFZcuWNWx/9913dfTo0UzndYekpCT973//M2zz8/NTWFiYXnnlFYdyV6tWTevWrVO5cuVs2ooXL65Lly6lm4Px716DBg1y6Vi1+mdw7ty56R6TlJSkpUuXZjp3TEyMfvvtt3SPW716ta5evZrp/K7kifPIihUrDONt27bVf/7zH4dqKVGihNavX6/GjRvfiW3fvt2hXGmxNw7eeOMNNWvWzJQ+rHx/nGGlOWjt2rWaNGmS3fb3339fu3btUqdOneTtnf5/Ll63bl1FRETop59+Uq5cue7Ez507p5iYmEzV5moJCQl69dVXDdt8fX21cOFCvf7665nO27p1a/3+++8qWLDgndiZM2ccrvNuVhpbs2fP1tmzZw3b+vbtqzFjxmS6zv79+2v+/PmpxmJkZGSm82TUv+ufPHmyPvvsM/n4+GQ6V+fOnbVp0yYVL17csP3LL7/UwYMHHaoTjsvJc6ARd7wb3M1Kc5qZssN1f/vttzYxLy8vmzVzUlKSpk6dakqfrNnxb35+fho0aJDdPxmxYcMGrVy50rDtlVde0eLFi1WyZEmn6mzSpIl27dqlJk2aGLbfvHlTI0aMyHTeV155RVeuXDFsq1q1qnbs2KEuXbpkOq8khYaGavv27apcubJh+7lz5zR06NBM57Viza7k7ueuK1ntWlz5THH2eTJixAilpKTYxFu1aqXVq1erdOnSDtX1jwIFCmjKlCmGbcuWLUvzXDPmXXew2nh0J96nMi+n/m4zPVZcS3vy+Pfkud8e5loAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGbFu3TrTc546dcowbsb+7Fa0ceNG03KdP3/eML5582aX91GgQAHT+nCGvT3izBpfnviZuP/++w3j69evd7imtJw+fdqwZm9vb1WtWtUlff6bvX7++OMPl/T3+++/uySvq2Rk7/LMyE5jzFU/yy1bthjuP5KRfSmz0/11FXv3onfv3urRo4ebq3Ete99tEBoamqHzO3fuLC8vr1Sx8PBww7//o169enb3W75brly5DPfiWbx4sWJjYzNUX07hie8L2cn58+fVvn17u3tS5XS5c+fWTz/9lKFn0AsvvKDOnTu7oSpzVKtWzTDuinfAc+fOGcarVKnidG7WgKm54v3M3rtZuXLl0v1sWGGcWXU9ZMW6GQ+2rLQ+/vd7sTMqVapkWi4zjBkzRtu2bcvwn61bt2rNmjVauHChJk+erBdffFEPPfSQfH190+znr7/+UsuWLXX58mU3XZlnyklrUgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4BjvrC4AAAAAAAAAAAAAAAAAAAAAAAAAcIVLly4pODhYUVFRdo8pU6aMpk2bplOnTumrr75Su3btFBQUlOE+/Pz8VL16dfXq1UuzZ8/W5cuXFR4ergcffNCMS7hj4sSJWrt2rWFb3bp1tXfvXr3wwgvy9fXNcM6aNWtq2bJl+vzzz+XtbfufGW3dulUrV650uGZPdOHCBQ0cONBu+4ABAxQZGamnnnoqQ/eyevXq+uWXXxQREaECBQoYHrN+/Xp98sknjpbsFuHh4Zo2bZphm4+Pj8aPH68///xT7dq1y1C+fPnyafjw4dq2bZsqV65s056SkqL//ve/SklJyVA+xr/7xMTEqFevXkpKSnJJfqt/BhcuXKiEhIQ0j9m4caOuXLniUP5Fixale8zcuXMdyu1qnjaP/P7777p8+bJh2+TJkzVixIgMzxn+/v56+eWXtWvXLtWpU+dO/Nq1a3r77bczlCMzJk2aZLeOVatW6cMPP1TZsmWd6sPK98cZVpuDXn75ZW3evNlue40aNbRkyRJdvnxZP/74o4YPH67+/fvr0UcfVZ8+fTR06FBNnDhRx44d07Zt29S2bVubHAMHDlRsbKxD9bnSggULtHjxYsM2b29vffzxx9q+fbvat2+fbq5q1arphx9+0MqVK1WoUKE78djYWA0fPtyUeq00thITEzVu3Di77W+++aaWLFliOPf+W926dbVs2TJNnjw51XVt3bpVCxcuzHRtGfXNN9/o8OHDqWKDBw/W/v379eijj8rLyyvdHDVr1lRYWJgWL16s/PnzGx5z/Phxj5vHcpKcPAf+mzveDe5mpTnNTNnhug8dOmR37Xy3ZcuW6ezZs6b1y5odrtC/f39dvXrVsK1z5846ePCgvvrqK9WuXTtTeZs3b64FCxZo/fr1qlixot3jXnvtNZ04cSJTuSXp7Nmz6tu3r921apEiRbRo0SKtXbtWPXr0UEBAQJr58uXLpx49emjdunX65ZdfVLhwYcPjkpKS9NRTT6X5e/DsVLMrufu560pWvBaznylmPU927NihiRMnGrY1adJE+/fv14gRI+yO97S0b99eW7ZsUY0aNQzb582bl+mcnsiK49GdeJ/KnJz6u82MsOJa2lPHvxXnfuZaAAAAAAAAAAAAAAAAAAAAAAAAAAAAABlx4MAB03Nev37dMG5vD67s7tChQ6blio6ONoxHRka6vI+s/PkVL15cDz30kJ5++ulUe4nezd/f35S+PPEzcd999xnGt2/f7mhJ6dq2bVumajGbvX1Qd+/e7ZL+jhw5ouTkZJfkdoW09hRxRHYaY2bOuXe7fv264X50FSpUSPfc7HR/XWX9+vWG+9B5e3trzpw5mj59eqb3GvRUixYtUlxcnE08ODjYcH+cf+vSpYthzn/s3r1bJ0+eTNXu5eWlzp07p5u7TZs2hvsLZpf9z8zkie8L2cHly5c1dOhQVapUybL7ornDZ599pmrVqmX4+O+//15FixZ1YUXmqVKlimHckT1h02Nvn9uCBQs6nZs1YGqueD+z927m7e2d7vuZFcaZVddDVqyb8WDLE9fHRu/PkjK1L2VafHx8VK5cOVNyWcmUKVPUuHFjnTp1KqtLyXI5aU0KAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcY843aQIAAAAAAAAAAAAAAAAAAAAAAAAeaM+ePWrWrJlWrVqle++91+5xxYoV0wsvvKAXXnhBKSkpOnHihE6cOKFz587p5s2bio2NlY+Pj/Lly6fAwEAFBgaqRIkSqlSpknx9M/ef6KxcuVJnz57N9LU89thj2rp1q8qUKWPTVqRIEX311Vd6++23tWzZMq1atUqnTp3SxYsXdevWLfn7+yswMFBlypRRrVq11KlTJzVu3NhuX+fOnVOPHj2UnJyc6To93ezZs1WjRg0NGzbMsL1s2bKaMWOGvvzyS61YsUJbtmzR+fPnFRUVpYCAABUrVkyVK1dWx44dVbVq1TT7Onr0qEJDQ5WUlOSKSzHVwIEDVaVKFT344IOG7fXq1dOKFSt06dIlRUREaMeOHbp48aKioqIkSUFBQSpfvrwaNmyodu3aKU+ePHb7+uCDD7R69epM1cf4d59NmzZp9OjRevvtt12S38qfwWvXrmn16tXq0KGD3WMWLVrkcP7w8HB99dVXdtsTExO1cOFCh/O7mifNI3FxcRo9erTGjRtn0+bt7a1Ro0Zp4MCBmjFjhtatW6eDBw/q2rVrio2NVVBQkIoWLapKlSqpffv26ty5s807REpKivr06aNLly5l5NZkyoYNG7R+/Xo1bdrUps3Pz09Dhw7V0KFDdebMGZ08eVLR0dGG89WFCxfUt29fwz6sfH+cZaU5KCEhQR06dNDKlStVv359u8cVLFhQPXv2zHT+999/X2FhYQ7V5g5PPfWU/vzzT1WqVMmwvU6dOlq+fLnOnz+vZcuWaffu3frrr7+UK1cuFSpUSDVq1FDLli1Vp04dw/NfeeUVHT161LR6rTS2xo0bp65duxrOM5LUqVMndejQQZs2bdKKFSt08uRJXbp0SV5eXipUqJBq1qyptm3bqnbt2jbnxsXF6ZlnnlGvXr0cqi0jYmNj9fTTT2vt2rXy9/e/E69SpYrmzZuny5cva/ny5dq2bZvOnz+vq1evKjAw8M497tChQ7r3+Pbt2woNDVV0dLTLrgNpy+lz4N3c8W7wb1aa08yUHa578uTJat68ebrHmI01O8x24sQJ9erVS4sWLZKfn59Ne0BAwJ3f5Z4/f15//PGHDh06pFOnTunmzZu6deuWcufOrYIFC6pw4cJ64IEH1KRJExUqVCjdvr/++mtNmjTJ4drDw8M1ePBgjR8/3u4xzZo1U7NmzZSQkKB9+/bp0KFDunbtmuLj45UrVy4VKFBAlSpVUvXq1Q2v/98GDhyoNWvW5KiaXSUrnruuYtVrycwz5fvvv3fb82Tw4MFq2LCh4btpvnz5NGrUKI0YMUIbN27Ub7/9pgMHDuj48eOKjo7WrVu35OXlpYCAABUoUEAVK1ZUnTp11KlTJ1WuXNlun+Hh4dqwYUOG6vN0Vh2P7sT7VMbl5N9tpseqa2lPHf9Wm/uZawEAAAAAAAAAAAAAAAAAAAAAAAAAAABkxJkzZ0zPeePGDcO4t7e36X1ZgSP7z9sTExNjGD9//rxpfdjbd9HVP79cuXKpXLlyqlixoipUqKB27dqpQoUKqlChQpr7EpvNEz8TRYoUMYy7cj+My5cvG8YLFy7ssj7vFhQUZBj/Z+9qsyUkJOjs2bMqVaqUS/KbbdeuXabmy05j7MSJE06dn5YrV66oXLlyqWIFCxZM97zsdH9dJSEhQR988IE+/fRTmzYvLy/17t1bvXv31unTp7V161bt27dPhw8fvvPnwoULWVC1Y6KjoxUREaGQkJBU8UKFCqlp06Zat26d3XP9/f3Vpk2bVLGLFy9qy5YtqWJhYWEaNGhQqlhISIimTJmSZm2hoaE2sVu3bmnp0qVpnpcTeeL7glUlJiZq/vz5mjNnjpYvX67Y2NisLsmjBQcH6/nnnzdsu3TpkuEzp0iRIpo+fbo6duzo6vKcZvRcvX37tq5cuWJ6X/bWVoGBgU7nZg2Ymqvez4zezaT038+sMM6suh6yYt2MB1ueuD62936QK1cuU/KXLl1acXFxiouLy/A5AQEB8vLyMqV/dzt8+LAGDBjgkfuBZ5WctCYFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACO8c3qAgAAAAAAAAAAAAAAAAAAAAAAAABX2r9/v+rVq6effvpJzZs3T/d4Ly8vlStXTuXKlTO1jitXrmjYsGGaNGmSQ+dfvHhRbdq00Zo1a1SqVCnDY4oVK6a+ffuqb9++Dtd54cIFtW/fXidPnnQ4h6cbPny4vLy89NZbb9k9JigoSI899pgee+wxh/rYv3+/OnTooKioKEfLdKu4uDh16tRJS5Ys0UMPPWT3uCJFiqhXr17q1auXQ/189913Gj58eKbPY/y716hRo9S+fXs1atTIJfmt/BmcO3euOnToYLc9PDzc4dynTp3Srl27VLt2bcP2X3/9VVeuXHE4v6t52jzy9ddfq3fv3qpTp45he4kSJTR06FANHTo00zUMHTpUYWFhatiwYabPzYjevXtr165dCgwMtHtMyZIlVbJkSbvtx48fT7MPK98fZ1lpDrp27Zpat26tH374QV27dnUq190+/fRTjRgxwrR8rnD9+nV16NBBq1evVtmyZe0eV7x4cfXr1y9TuSdMmKDJkyerWbNmzpaZilXGVlJSkh5//HHt3LlTRYoUMTzG29tbDz74oB588MEM501JSdHAgQO1d+9eh2vLqE2bNmngwIGaMmWKvLy8UrUVLlxYTz31lJ566imHct++fVvdu3fXrl27zCgVTsjJc+C/uePd4N+sMqeZzerXvWDBAn3xxRcqVKiQYfvZs2e1ZMkS0/tlzQ5XWLZsmYKDg7VgwQLly5fP7nHFixdXt27dTOnzq6++0qBBg5zO8/nnn8vb21tjx461eVe5m5+fnx544AE98MADDvWTlJSkl156Sd99952Dlf4/K9bsKlnx3HUVK16LO54pjjxP4uPj1bFjR61YsUJ169Y1PMbPz0/NmzfP0P8PlZ7Lly/r+eefdzqPJ7HieHQn3qcyJyf/bjM9VlxLe+r4t+Lcz1wLAAAAAAAAAAAAAAAAAAAAAAAAAAAAID3R0dGm50xOTjY9p5XdvHnTtFz27q07+jBLiRIlVK9ePdWqVUuVKlVShQoVVLFiRZUoUSLN/Y7cxdM+E3ny5JGPj49NPC4uTrGxsc6UlaarV68axtPaw8AsefPmNRwLcXFxio+Pd1m/rvjZu4qZexdmtzF248YNp85Py7Vr12xiae2LJ2W/++tKX3zxhbp165bmfvalSpVSqVKlbPYbvHnzpo4cOaLDhw/r8OHDOnTokHbt2qXdu3crLi7O1aVn2ty5cxUSEmITDw0N1bp16+ye16pVKwUEBKSKLV68WCkpKaliYWFhNvsotm3bVrly5bJ7P7y8vAxrWrp0qW7fvm23ppzK094X3O3s2bOZnm/z58+vEiVK2MR9fHz06aefatu2bWaVl20VLVpUU6dONWy7cOGC6tSpo0WLFqlBgwY27R06dNCgQYP05ZdfurpMh9l7B8yTJ49L5iF7a49cuXI5nZs1YGquej8zejeT0n4/s8I4s+p6yIp1Mx7s87T18a1bt+y2BQQEOD0nHj9+PNNrpQMHDqhatWpO9etOCQkJCgsL0+TJk7Vy5UqbNQRy1poUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABknndWFwAAAAAAAAAAAAAAAAAAAAAAAAC42rlz59SqVSu9+uqrun79ulv7jomJ0dixY1WxYkVNmjTJqVyHDh1SkyZNtGXLFpOqS2379u2qX7++9uzZ45L8nmTYsGF69tlndfPmTdNzL1myRA899JBOnTplem5Xun79utq0aaOpU6eanjs5OVljxoxR//79lZKS4lAOxr/7JCUlqVevXoqJiXFZH1b9DC5cuFAJCQmGbZGRkYqMjHQqf1hYmN22efPmOZXbHTxpHomPj1fHjh117Ngx02pISEjQgAED9Mknn5iW08ixY8fUvXt3l76zWPn+mMFKc9CNGzcUGhqqAQMGKCoqyqlcUVFR6tWrl15//XVTanO1I0eO6KGHHtL27dtNy/nhhx/qlVdeMS3fv1llbJ09e1YPP/ywjhw5YkJlf8/RgwYN0rRp00zJlxHff/+9+vbta/e57IgLFy6oXbt2Wr58uWk54ZycPAfezR3vBkasMqeZzcrXHRcXp5kzZ9pt//7775WcnOySvlmzwxUiIiLUpEkT/fnnny7t59atW3ruuec0aNAg03KOGzdO3bp1c/r5Zc/FixcVEhKiiRMnmpbTijW7QlY9d13BqtfiymeKM8+Ty5cvq0WLFlq4cKHpdd3t9OnTatq0qc6cOePSftzNquPRnXifyric/rvN9FhxLe2p499qcz9zLQAAAAAAAAAAAAAAAAAAAAAAAAAAAID0mLl/H4y54x7Hx8e7vA9nVK9eXR999JGOHz+uM2fOKCwsTO+//7769u2rZs2aqWTJkvLy8srqMiV53mciICDAMH7jxg2X9nv16lXDeP78+V3ar5R11+yK/QZdxcy9JLLbGLt165ZT56fF6L7ny5cvzXOy2/11pfj4eHXt2lU7duzI9LkBAQGqVauWunfvriFDhujbb7/Vli1bFBMTo1WrVqlfv37KkyePC6p2TFhYmOGzu2vXrmmeFxISYhNbtGiRTey3335TdHR0qljevHnVokULu7kbN26sYsWK2cTnzp2bZk05lae9L7jb4MGDdd9992XqT40aNXTt2jWbXF5eXho/frzbr8GKpk+friJFihi29evXT+fOnVPPnj3tvtN88sknql69uitLdIq9Z6Yk5c6d2/Q/uXLlctm1sAZMzVXvZ/beidN6P7PCOLPqesiKdTMe7PO09fGFCxfsthm9w+ZkKSkpunHjhk6cOKGlS5fq3XffVefOnVW8eHE9+uijioiIcPi7Ao36MuLt7W1K/syw12dmrjUnrUkBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDmuf8bGwEAAAAAAAAAAAAAAAAAAAAAAIAskJycrHHjxqlSpUr6+OOPdfXqVZf299dff+n1119XqVKl9Nprr+natWum5D19+rSaNm2qYcOG6datW6bkvHXrloYOHaqGDRvq9OnTpuS0gilTpqhmzZpavny5KfnOnTunp59+WsHBwab9vN0tNjZW//nPf9SlSxcdPXrUlJxHjhxR27ZtNWzYMKdzMf7d58iRI3rllVdc2ocVP4NXr17VmjVrDNvCwsKczr9o0SLDeFJSkn755Ren87uDJ80jFy5cUKNGjbRkyRKna9i9e7caNmyoyZMnO50rI1atWqWGDRvq999/d1kfVr4/ZrDaHDR58mSVK1dOw4YN05EjRzJ17sWLFzVq1ChVrVpVs2bNMr02Vzpz5owaNWqkUaNGKS4uzuE8ly9fVteuXfXmm2+aWJ0xq4ytgwcPqmHDhlq2bJlTeS5duqQOHTro66+/NqmyjPvhhx/04IMP6tChQ07nmjdvnqpXr67169ebUBnMllPnwLu5493AiFXmNLNZ+brtvY+lpKTou+++c2nfrNnhCnv37lXDhg314osv6tSpU6bmTklJ0YIFC3T//ffr22+/NTW39Pca//7779eMGTOUnJxsSs6kpCRNmzZN999/v9PvcUasWLMrZNVz1xWsei1mP1PMep5ER0erW7du6tGjh06ePOl0XXdLSUnRzJkz1aBBAx08eNDU3J7CquPRnXifyric/rvNjLDaWtpTx7/V5n7mWgAAAAAAAAAAAAAAAAAAAAAAAAAAAADI/lJSUrK6BENly5bVrFmztGfPHg0ZMkRly5bN6pIsx9vb2zCelJTk0n7t5ffy8nJpv2n14eprTkxMdGl+M924ccO0XNltjLlyPjSqOb16s9v9dbWoqCg1adJEX3/9tSn3yNfXV61bt9bUqVN1+PBh9evXz4QqnXfjxg1FRETYxCtUqKDq1avbPS84ODjVv2NjY7Vy5Uqb4xISEgz3Tw0JCbGbOzQ01CZ2+/ZtLV261O45QGZcvXpVo0aNMmxr2rSpHnnkETdXZC2DBg1Shw4dDNu++uqrO3t7Hj582O53yuTOnVs//fST/P39XVanMzz9GeVpPHUNaMRVtTryvmOFcWbV9ZAV62Y82Odp6+NLly7ZralUqVJursY9Bg0apLJly2b4T5kyZVSgQAH5+PgoKChI5cqVU+fOnfXOO+9o6dKlunLliuk1xsbGGsbz5ctnel/pCQwMNIzbq9GenLImBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmeed1QUAAAAAAAAAAAAAAAAAAAAAAAAA7nT58mUNHTpUJUuW1NNPP62ff/5ZN2/edDpvcnKytm7dqtGjR6t+/fq677779Omnn+r69esmVJ1aQkKCxowZo/Lly2v06NE6ffq0Q3lOnTqlt99+W6VLl9bHH3+spKQkkyv1fMeOHVPHjh3VoEEDzZ07V7du3cp0jp07d2rAgAEqV66cZs6c6YIq3S88PFxVq1ZVr169tGHDBqWkpGQ6x65duzRgwABVrVpVa9asMa02xr/7TJ06Vb/88otL+7DiZ3Du3LmG8UWLFjmde9u2bTp37pxNfO3atbp8+bLT+d3JU+aRS5cuKTg4WD169ND69eszff727dv1xBNP6IEHHtDOnTsdqsFRkZGRatasmRo1aqRvvvlGu3fvVnJysql9WPn+mMFqc1BMTIzGjBmjSpUqqW7duho0aJCmTp2qVatWaevWrTpw4IB27NihdevWacaMGXrzzTfVpEkT3XvvvRo5cqSioqJscubKlcuwr8TERJdeS2YkJiZq5MiRKleunMaOHatLly5l+NyLFy9q1KhRqlChgsLCwlxYZWpWGVtXrlxRp06d1KpVK/3xxx+ZOvfatWv65JNPVKlSJa1cudIl9WXEn3/+qerVq+v555/X0aNHM3VubGys5s2bp7p16+qxxx4z/IzAc+TUOfBu7ng3MGKVOc1sVr3uffv2adOmTTbxlStX6vjx4y7vnzU7XCElJUVff/21ypcvr8cee0xLlixx6DP5j4sXL2rChAmqUaOGHn30UZ04ccLEam376t27t+6//3598cUXDq/tL126pAkTJuj+++9Xv379XPreYsWaXSGrnruuYNVrMeOZ4qrnyfz581W+fHn16NFDq1atUlxcnMO5rl69qqlTp6pRo0Z6+umndf78eVNq9FRWHY/uxPtUxuX0321mhNXW0p48/q009zPXAgAAAAAAAAAAAAAAAAAAAAAAAAAAAADcrU2bNtq5c6eefPJJeXl5Zfr8K1euaPPmzZo5c6ZGjBihJ554QvXq1TPcVw3IaRzZ2xuwiri4OL344ou6//77NW3aNN24ccOUvCVKlNDUqVM1a9Ysu3vmuJO97zYIDQ01jNeqVUtlypRJFVu9erVu375teLzR3tshISF26+natatNbNmyZaZ8bw/wjy+//FJHjhwxbPvkk0/k7+/v5oqsoXr16vrkk08M2w4cOKDXXnstVWzKlCl2v1OmZs2a+vDDD02vEQAAV0pJSbG7F2W1atXcXI17XLp0SSdPnszwn1OnTun69etu/X1BbGysYTwoKMhtNaTXp70a05JT1qQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBzfLO6AAAAAAAAAAAAAAAAAAAAAAAAACAr3L59WzNnztTMmTPl6+urGjVqqEGDBrrvvvtUunRplS5dWvny5VPevHmVO3fuO+fExsYqOjpaZ86c0ZkzZ3To0CHt3LlTu3bt0o0bN9x6DRcvXtTw4cM1fPhw1a9fX02bNlW9evVUtmxZFS1aVAEBAfL19VV8fLxu3Liha9eu6eDBg9q3b59Wr16t3bt3m1pP+fLlTc3nTn/++acef/xx5c6dW23btlXDhg1Vq1YtlSxZUkFBQcqXL5/i4uJ0/fp1XblyRfv27dOuXbsUERGhEydOmFqLl5eXqfkclZiYqFmzZmnWrFkqXry4WrRoocaNG6tSpUp3Ph958uRRcnKyrl+/rmvXrumvv/7S9u3btWbNGh04cMCl9Xna+DeTJ32Wunfv7pZ+POkzmJ6pU6dq6tSpLstfokQJl+V2N0+aR+bPn6/58+eratWqatq0qZo0aaJKlSqpQIECKliwoPz8/BQdHa1r167pwIED2rFjh5YsWaLDhw/bzbllyxa3zNlbtmzRli1bJEkBAQG69957U9Vt5Pbt25nqw5PvjzvusZXmoH/s2LFDO3bscCqHt7e3AgMDDdsyO4bc4fz583rttdc0ZMgQNWvWTE2bNlXt2rVVrlw5BQUFydvbWzdu3NCpU6e0c+dOrVu3Tr/++quSk5MN861bt87l48sqY+vXX3/Vgw8+qNKlS6t9+/Zq0aKFSpQooSJFiqhQoUJKTEzUtWvXdPHiRe3YsUMbNmzQsmXLFB8fb5jvzTff1Jtvvul0XRn9+SQkJGjSpEmaNGmS6tWrp7Zt2+qBBx5QxYoV79zn2NhYXb9+XefPn9fu3bu1ZcsWLV++XDdv3nS6TkdqtlqejOjXr5/69evnlr5y4hx4N3e8GxixypxmNited5MmTbKk37t50prdU37P4ql++OEH/fDDD6bkunXrVqr7/euvv6pFixam5JakpKQkzZs3T/PmzVOuXLnUtGlT1apVS/fdd58qV6585zOZL18+SVJsbKxiYmJ07tw5HT9+XDt37tSmTZucfoY44uDBg3r55Zc1ePBg1atXT82aNVP16tVVsWJF3XPPPcqXL5/8/f0VHx+vmJgYRUVF6ciRI9q7d6/WrVun7du3KykpiZqzgKufu+6co1x1La6+BnvPlAYNGmTp74CTk5Pv/D4lb968at68uWrVqqVq1aqpYsWKCgwMVL58+RQQEKCUlBTFxMQoOjpaN27c0JEjR7R7927t3r1bGzZsUGJiokM1uHredSVXfrayyzrIk96nzGb2zyin/24zo6y0lvbU8e8Jc39mZNXvDwAAAAAAAAAAAAAAAAAAAAAAAAAAAADAU3nSPgDZSceOHRUeHi4fH590j42JiVFkZKQiIyN16NChO/+7efNmw+NjY2PNLtej2du3ydfX16X92tuHwB37SNnrw15NZnF1fk+V3caYn5+fEhISnMphj7+/v00svXqz2/11p8jISPXr108DBgxQixYt1KBBA9WrV0/VqlVThQoVlCtXLofyPvnkkwoMDFRISIjJFWfOokWLFB8fbzOuQkNDNXr0aJvjg4ODDXPYs3TpUiUlJaV6FpcpU0bVq1fXvn37Uh1btWpVVa1a1SbHvHnz0r0OIDMSEhI0dOhQzZ8/36atfPnyeuWVV/TJJ59kQWWey9/fXz/99NOd78i6W3x8vJ588knD9+Nnn31WjRo1Mvyek//+979atmyZVq5c6ZKaHZWSkmIYv3btmmbPnu22OqKiotzWV07hqvczo3czKe33HSuMM6uuh6xYN+PBPk9cH+/Zs0flypWzideuXdv9xUCS/bEbFBTk5kqkAgUKGMYvX77scM7sviYFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACZ45vVBQAAAAAAAAAAAAAAAAAAAAAAAABZLTExUTt37tTOnTuzuhSH/fnnn/rzzz+zugzLi42NVXh4uMLDw7O6FI9y/vx5zZ49W7Nnz87qUgwx/rMPPoPZl6fMIwcPHtTBgwc1ZcqULK3DUTdv3tThw4ddlt/q98dZOW0Oyp8/v922K1euuLGSzElOTtZvv/2m3377LatLyTCrjK1Tp07pu+++03fffZfVpThs27Zt2rZtW1aXAQuw6hz4b65+NzBilTnNbDn1us3Amj3n8vHxufP3pKQkU3PHxcVp9erVWr16tal5XS0pKUlbtmzRli1bsrqUDLNiza6SFc9dV7HqtXjqM+XWrVtatmyZli1blqV1uHLedSWrjkd38tSx72ly+u823SEr1tKeOv49Ze7PKOZaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJDy5MmT1SVkO+XKldOsWbNS7X1yt6ioKC1YsEArV67U1q1bdeLEiUzl9/LyMqNMy4iJiTGMFyhQwKX9FipUyDB+48YNl/Yr/b0ngpGgoCCX9hsQEODS/J4qu42xoKAgXb582akc9hjdE3v3L712q97frBAfH6+IiAhFRETciXl5ealUqVKqVKmSKlWqpMqVK9/5e6VKldJ9vgcHB+utt97SmDFjXF2+XTdu3NDKlSvVuXPnVPF69eqpRIkSOnv2bKp4ly5dUv07JSVFixcvtpv/ypUr2rBhg5o1a5YqHhISon379qWKde3a1eb82NjYNPMDjlqwYIE2bNighx56yKZt+PDhmjZtmi5dupQFlXmmjz76SDVr1jRse+utt7Rr1y7DtitXrqhPnz6KiIiweX/28vLS9OnTVbNmTUVFRZles6NiY2MN4zExMXr++efdXA3M5Kr3M3vvU2m9n1lhnFl1PWTFuhkP9nni+nj37t0KCQmxiT/88MNZUA0k6cyZM4bxYsWKydvbW8nJyW6pw9fXV4ULFzZss1djZmTXNSkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMgc76wuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgXlWrVjWMJyQk6MKFC26uBgDcizkQAFyvQIECd/5+48aNrCsEAHII5l0ArsZaGgAAAAAAAAAAAAAAAAAAAAAAAAAAAADgTj4+PqbmCwwMNDUfpDFjxqTa9+QfMTExeumll1SiRAkNGDBA8+fP14kTJzKdP1++fCZUaR1xcXFKTEy0ifv6+iogIMBl/RYsWNAwHh0d7bI+/xEbG6vk5GSbuK+vr/LmzeuyfoOCglyW25NltzFmNP+Yxd7clpbsdn89RUpKik6dOqVff/1V3377rYYMGaLu3burVq1aCggIUNWqVfXKK6/owIEDdnO8+eabKlSokBurtjV37lybmJeXl7p06ZIqVqRIETVs2DBVbNu2bTp37lya+cPCwmxiISEhNrHQ0FCb2IoVK9Id34CjBg8erJSUFJt4/vz59d5772VBRZ6pXbt2euWVVwzb1qxZo7Fjx6Z5/qpVq/T5558btt17772aMmWK0zWa6datW4bjIqvnajjPVe9n9vKm9fyywjiz6nrIinUzHuzzxPXx+vXrDeM1atRQ8eLF3VwNJOn48eOG8Tx58uj+++93Wx21atWSv7+/YZu9Gp2VXdakAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAg47yzugAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgHs1bNjQMP7XX3+5uRIAcD/mQABwrXz58qlq1ap3/n3+/PksrAYAsj/mXQDuwFoaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOAKSUlJhvHAwEBT+yldurSp+XK6cuXK6fHHH7eJx8XFqU2bNvryyy8VHx/vVB+FCxd26nwrOnPmjGG8ePHiLuvTXm537WNz4cIFw3ixYsVc0l/u3Lldej89XXYaY64aI/ZyX758Od3zstP9tYKUlBRFRkZqwoQJql69ut59913D4/Lly6dnn33WzdWltmjRIsPnYmhoaKp/d+7cWV5eXjbnpicsLMwm1rhxY91zzz13/l2sWDE1btzY5ri5c+emmx9w1NatWzV79mzDtmeffVbVq1d3c0We55577tH06dNtPvuSdPXqVfXu3TtDeYYOHardu3cbtnXt2lX9+/d3qk4zJSUl6dKlSzbxvHnzKnfu3FlQEcziqvcze3nTej+zyjiz6nrIanUzHox56vp47dq1hu/OXl5e6tGjRxZUhMjISN2+fduwrUGDBm6rw15f165d08mTJ91Wxz+stCYFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZ553VBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA3KtNmzaG8W3btrm5EgBwP+ZAAHCtsWPHyt/f/86/t2zZkoXVAED2x7wLwB1YSwMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXOHq1auG8fz585vaT9WqVU3Nl9N16tRJ3t7eNvGvv/5amzdvdjq/t7e3ihYt6nQeq9m/f79hvFGjRi7rs2HDhobxffv2uazPu0VGRhrG69ev75L+qlSpIi8vL5fktoLsNMZcNUZKliypYsWK2cSPHTuW7rnZ6f5aTUpKit555x19/fXXhu3t27d3c0WpXb9+XatWrbKJt2zZUoGBgXf+3aVLF5tjwsLC0s1/6NAhHTx4MFXM29tbHTt2vPPvkJAQm/kvLi5O4eHh6eYHnPHGG28oNjbWJu7j46Nx48ZlQUWeZcqUKSpevLhh23PPPaczZ85kKE98fLx69uxpeK8lafz48apSpYrDdZrt5MmThvEaNWq4uRKYyRXvZ/bezRISEtJ9P7PCOLPqesiKdTMebHnq+vj27dtau3atYVv//v3dXA0kKTk5WTt37jRse/jhh91Wh72+PGFfVE9fkwIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIzzzuoCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADGAgICTM9ZsmRJde7c2bBtxYoVpvcHAI5iDgQAa/H19dWkSZP03HPPpYpPmzYtawoCgGyOeReAEdbSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAruXr1qmG8fPnypvbTvHlzU/PldM2aNTOMz54925T89erVU548eUzJZSV79+41jDdt2tQl/VWtWlX33HOPTTwuLk5HjhxxSZ//dvDgQcN4kyZNXNJfTp8LstMYc9UYady4sWE8OTk53XOz0/21qrfffluJiYk28QYNGmRBNanNnTvXJubv768OHTrc+Xvbtm1TtZ86dUq7d+/OUP7w8HCbWEhIyJ2/h4aG2rRHREQoOjo6Q/kBR508eVLjx483bGvbtq06derk3oI8SP/+/dW1a1fDtunTp2v+/PmZyrdv3z4NHTrUsC1v3ryaNWuWfH19M12nK+zZs8cw3qhRIzdXAjO54v3M3rvZkSNH0n0/s8I4s+p6yIp1Mx5sefL6ePr06YbxmjVr5uh3h6y0cuVKw3iPHj2UL18+l/dfoEABde/e3bAtIiLC5f1nlCevSQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQMZ4Z3UBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDUvL299fbbb+vQoUMqWrSoqbnfeOMN+fj42MRjY2O1fPlyU/sCAEcwBwKA9RQrVkxr1qzRgAEDUsV/+ukn/fbbb1lTFABkY8y7AP6NtTQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwIquXLliGK9bt65pffj6+qpdu3am5YN07733GsYPHDhgSv5WrVqZksdqVq5caRgPDg423PvBWaGhoYbxtWvXKikpyfT+jPz++++G8Y4dO7qkv5CQEJfktYrsNMZatWolf39/p3IY6dSpk8PnZqf7K8klNbtaVFSUdu7caRMPDAx0yXjJjIULFyo+Pt4m/s/PsUWLFsqXL1+qtrCwsAznX7RokU2sQ4cO8vX1VUBAgNq0aWPTPm/evAzn9wRWHJP425gxY3Tx4kXDtrFjx+bIn22VKlU0fvx4w7ajR49q0KBBDuWdMGGCVqxYYdhWr149vffeew7lNduWLVsM4y1atHBvITCVK97P7L2brV+/Pt1zrTDOrLoesmLdjAdbnrw+/vnnn3X9+nXDtrFjx8rX19fNFWHx4sWG8Xz58qlXr14u7793797KkyePYduyZctc3n9GefKaFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZIx3VhcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPh/pUuX1tq1a/Xuu+/q3nvv1c8//6zcuXObkrt169Z68cUXDdvmzJmja9eumdIPADiKORAArKdkyZLasWOHHn744VTx5cuX65lnnsmiqgAg+2LeBfBvrKUBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFa1f/9+w3jx4sVVqVIlU/p45JFHVKRIEVNy4W8FCxY0jMfGxjqd29vbW/3793c6jxWtXbtWN2/etImXLl1ajz76qKl9+fn56eWXXzZsCwsLM7WvtKxcudIwXq1aNbVp08bUvipUqGB6TqvJTmOsSJEieuKJJ5zOc7fChQurZ8+eDp9v1ftrVLMkBQYGZrquzChevLhL8p49e9YwXqBAAZf0l1HXr1/XqlWrbOKdO3eWr6+vQkJCbNoWLVqU4fwbN25UVFRUqlj+/PnVtGlTtW/fXrly5UrVFh8f79b5PjOyakzCdaKjozVy5EjDtmrVqun55593c0VZy9fXV7NmzVLevHlt2pKSktSrVy/FxMQ4nL9Pnz66fPmyYduQIUPUvHlzh3ObJSIiwjDepUsX1m4WZvb7WVrvZsuXL0/3fCuMM6uuh6xYN+MhNU9fH9++fVsTJkwwbKtWrZpGjRrl5oqwdetW/fXXX4ZtQ4YMMXyvMUtgYKBee+01w7YdO3Zoz549DuXNaWtSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQMd5ZXQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4G/dunXT7t271bRp0zuxhx56SBERESpcuLBTuVu1aqUFCxbIy8vLpi0xMVGjR492Kj8AOIs5EACs6cyZM/rjjz9Sxb777jt16dJFsbGxWVQVAGRfzLsA7sZaGgAAAAAAAAAAAAAAAAAAAAAAAAAAAABgZZGRkYqKijJs69u3r9P5fX199c477zidB6lFR0cbxosUKeJ07ieffFIVK1Z0Oo8VxcfHa86cOYZtw4YNk5+fn2l9PffccypRooRNPC4uTvPmzTOtn/RcuHBBGzduNGx76623TO3rvffeM9xHIyfJbmPstddek4+Pjym5JOnVV19V7ty5beI3b97M0PlWvb9Xr141jJctW9ah2tJTqlQpTZw4USdOnFDXrl1Nz+/v728Yv337tul9ZdbcuXNtYkFBQWrevLlCQkJSxaOjo/Xbb79lOHdycrKWLl1qEw8JCVFoaKhNfNWqVbp+/XqG87uTu8ck3GPy5Mnav3+/Ydu7776rAgUKuLegLPT++++rXr16dts2bdrkVP4LFy7oP//5j2Gbt7e3Zs6cmeX3++jRo9qzZ49N3N/fX/379ze1r6CgIBUvXtzUnLDPzPeztN7NIiIi0j3fCuPMqushK9bNeEjNCuvjzz77zO776htvvKHHHnvMzRVh4sSJhvEKFSpo7NixLuv3iy++UOnSpQ3bvv7660zny8lrUgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkD7vrC4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPC3KlWqqECBAjbxhx9+WPv27VO/fv3k5+eXqZyFChXSmDFjtHz5cgUFBRke8/nnn+vQoUOOlAwApmEOBADr6tu3rw4dOqTY2FgNHDhQ/fv3V0JCQlaXBQDZFvMugH+wlgYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWN3GjRsN4/379zf8b+oz46233lK1atWcygFbly9fNow3adLEqbwlS5bUuHHjnMphdZ9++qlSUlJs4jVr1tT48eNN6aNOnTr69NNPDdt++OEHXbx40ZR+Muqrr74yjLds2VL/+9//TOmjQ4cO6tmzpym5rC47jbGaNWvqk08+MSVX8+bNNWTIEMO2GTNmZDiPFe/vmTNnDOOVK1dWsWLFMl2fPaVKldLXX3+tI0eOaODAgfL399eECRNUqFAh0/qQpEqVKtnEbt26pejoaFP7ccTChQsN9wsbMWKEypYtmyq2YsWKTO8ttmjRIptY165dFRwcbBOfN29epnK7k7vGJNwrOTlZr732mmFboUKFNHLkSDdXlDWaN2+u119/3bBt06ZNeu+990zpJywsTJMnTzZsK1WqlN02d/r2228N48OGDVPlypVN62fcuHE6ePCgXn75ZXl7e5uWF8bMej9L790so891K4wzq66HrFg34+FvVlkfX7t2TUOHDjVs8/Ly0o8//qgnnnjCzVXlbJMnT9b58+cN2wYOHKhevXqZ3ud//vMf9enTx7Dt5MmTmj59eoZzsSYFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZwTchAwAAAAAAAAAAAAAAAAAAAAAAAAAAAICH+PTTT7V582bDtqJFi2rq1Kk6ffq0pkyZoj59+qhJkyYqXbq0ChUqpICAAAUFBal8+fKqX7+++vfvr59++knHjx/Xm2++KT8/P8O8O3bs0FtvveXKywKADGEOBADrio6OVmhoqBo2bKhvvvkmq8sBgGyPeRfAP1hLAwAAAAAAAAAAAAAAAAAAAAAAAAAAAACsbu7cuYbxokWLaty4cQ7n7dq1q0aOHOnw+bAvMjLSMD5gwACHc+bNm1fz589XkSJFHM6RHRw4cMDuZ+KFF17Q4MGDncpfuXJl/fLLL8qdO7dNW2xsrD788EOn8jti3rx5OnnypGHbhx9+qJCQEKfy33///Zo1a5ZTObKT7DbGBg8erP79+zuV47777tPs2bPl4+Nj05aYmKjx48dnOJcV7++ZM2d0+vRpw7YXXngh0/nsmTRpkp5//nn5+/vfiZUpU0bz5s1Tnjx5TOmjYcOGqlSpkk3c3vW52/Xr17Vq1SqbePPmzW1iixYtynT+FStWKD4+PlWsYsWKKliwYKpYYmKiQ/ndxV1jEu63bNkyw8+AJL344ouqXLmymytyrwIFCmjmzJny9va2aYuJiVGvXr2UlJRkWn///e9/7b639+jRQ7179zatL0dMmTJFly5dsonnzZtXP/74owICApzu49lnn1W/fv2UP39+ff7559q+fbuaNGnidF6kzdn3MzPfzawwzqy6HrJi3YwH662Pv/nmG/3666+Gbb6+vvrpp580btw4w/WRGVq2bKmiRYu6JLcVxcbGprkX6YwZM/Tqq6+a1t9bb72l7777zm77kCFDlJCQkOF8rEkBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBG2H4LNQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgSyQlJSk4OFiHDh2ye0zRokX1zDPPaNq0adq4caNOnjypqKgoxcTE6Nq1azp69Ki2bt2qyZMn64knnlBgYKDdXEePHlWnTp0UHx/vissBgExhDgQAa9u/f7/27NmT1WUAQI7BvAtAYi0NAAAAAAAAAAAAAAAAAAAAAAAAAAAAALC+2bNn6+zZs4Ztffv21ZgxYzKds3///po/f768vb3vxCIjIx2uEamtWLHCMN62bVv95z//yXS+EiVKaP369WrcuPGd2Pbt2x2uz+peeeUVXb9+3bDts88+06RJk+Tv75/pvG3bttWWLVtUtmxZw/Z3331XR48ezXReZyUkJOjVV181bPP19dXChQv1+uuvO5S7devW+v3331WwYME7sTNnzjiUKzux+hj79zNj8uTJ+uyzz+Tj45PpXJ07d9amTZtUvHhxw/Yvv/xSBw8ezFROK97f3377zTD+xhtvqFmzZg7l/LcRI0YoJSXFJt6qVSutXr1apUuXdip/gQIFNGXKFMO2ZcuWOZXbTHPnzk33mKSkJC1dujTTuWNiYuz+LO+2evVqXb16NdP53ckdYxJZ49VXX1VycrJN3M/PT59++mkWVOQ+33zzjUqVKmXY9tJLL5n+Hnb79m317NlTCQkJhu1ffvmlypcvb2qfmXHr1i2NHDnSsK1BgwZat26dihYt6nD+l19+Wd98802qWO3atbVhwwa1b9/e4bwwZtb7mdnvZlYYZ1ZdD1mxbsaDNdfHjz/+uE6ePGm3/b///a8OHjyoPn36yM/Pz5Q+/fz8tGHDBq1Zs0aFChUyJWd28f3332vlypWGbV5eXho7dqx+/vlnVatWzeE+qlevrvDwcI0ePdruMWFhYZozZ06m8rImBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGeGd1QUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP7f5cuX1axZM23cuNGl/fz555968MEHdf78eZf2AwCZwRwIAAAAAEDmsJYGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFhZYmKixo0bZ7f9zTff1JIlS1S5cuV0c9WtW1fLli3T5MmT5evreye+detWLVy40IxyIen333/X5cuXDdsmT56sESNGpLr/aXn55Ze1a9cu1alT507s2rVrevvtt02p1YouXLiggQMH2m0fMGCAIiMj9dRTT2XoPlevXl2//PKLIiIiVKBAAcNj1q9fr08++cTRkp22YMECLV682LDN29tbH3/8sbZv36727dtnKF+1atX0ww8/aOXKlSpUqNCdeGxsrIYPH25KzVZm9TH2zTff6PDhw6ligwcP1v79+/Xoo4/Ky8sr3Rw1a9ZUWFiYFi9erPz58xsec/z4cYfmIive30mTJhnG/f39tWrVKn344YcqW7asw/klaceOHZo4caJhW5MmTbR//36NGDFChQsXznTu9u3ba8uWLapRo4Zh+7x58zKd01UWLlyohISENI/ZuHGjrly54lD+RYsWpXvM3LlzHcrtTu4Yk8gae/bs0ffff2/Y1qVLF7Vs2dLNFblH79699dhjjxm2zZ8/X9OmTXNJv9u2bbP7LAsMDNSsWbPk4+Pjkr4zYuLEiVq7dq1hW926dbV371698MILGV5bSH8/45ctW6bPP/9c3t7eNu1bt27VypUrHa4Zxpx9P3Plu5kVxplV10NWrJvxYL318aVLlxQcHKyoqCi7x5QpU0bTpk3TqVOn9NVXX6ldu3YKCgrKcB9+fn6qXr26evXqpdmzZ+vy5ct68MEHzSg/W+rZs6dOnDhht71bt27au3evfvzxRz366KMqWLBgujnvuecePfbYY5o9e7Z2796t4OBgu8cePnxYffr0yXTdrEkBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBGZPybTQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbnH+/Hm1aNFCb775poYOHaq8efOaljsuLk5jx47VyJEjlZiYaFpeADALcyAAAAAAAJnDWhoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGXjxo1T165d1bRpU8P2Tp06qUOHDtq0aZNWrFihkydP6tKlS/Ly8lKhQoVUs2ZNtW3bVrVr17Y5Ny4uTs8884x69erl6svIMeLi4jR69GiNGzfOps3b21ujRo3SwIEDNWPGDK1bt04HDx7UtWvXFBsbq6CgIBUtWlSVKlVS+/bt9eyzz6Y6PyUlRX369NGlS5fcdTkeafbs2apRo4aGDRtm2F62bFnNmDFDX375pVasWKEtW7bo/PnzioqKUkBAgIoVK6bKlSurY8eOqlq1app9HT16VKGhoUpKSnLFpWTYU089pT///FOVKlUybK9Tp46WL1+u8+fPa9myZdq9e7cuXLigq1evKleuXCpUqJBq1Kihli1bqk6dOoY5XnnlFR09etSVl2EZVh5jsbGxevrpp7V27Vr5+/vfiVepUkXz5s3T5cuXtXz5cm3btk3nz5/X1atXFRgYeKfmDh06pFvz7du3FRoaqujoaIdqtNr93bBhg9avX2/4HPbz89PQoUM1dOhQnTlzRidPnlR0dLSSk5Ntjr1w4YL69u1rt5/BgwerYcOGql+/vk1bvnz5NGrUKI0YMUIbN27Ub7/9pgMHDuj48eOKjo7WrVu35OXlpYCAABUoUEAVK1ZUnTp11KlTJ1WuXNlun+Hh4dqwYUPGboQbXLt2TatXr1aHDh3sHrNo0SKH84eHh+urr76y256YmKiFCxc6nN9d3DUmkTWGDx+uJ554QgEBATZt48aNU506dZSSkpIFlblGhQoV9OWXXxq2nTlzRs8995xL+//oo4/UsWNHNWvWzKatcePGGjFihN555x2X1pCWxx57TFu3blWZMmVs2ooUKaKvvvpKb7/9tpYtW6ZVq1bp1KlTunjxom7duiV/f38FBgb+H3v3HWZVeTUOe02hzlAFRYGANBEVERQs2BAFrAFFlAABY+wxb2IssUYsiS32hl1RsRtQUbChgtgBQRSwIEWUXoc68/2RT35O5oxMOWcK3Pd1cTl7PXuvtc6Z59mFOYPxm9/8Jtq3bx9HHnlk7LvvvoXW+uGHH6Jv374JzxeUTnHuz6ZPn17m92aVYZ5V1uehyti3+fBflen5+PPPP4+DDjooXn/99dhxxx0L3W+HHXaIs846K84666zIy8uL2bNnx+zZs+OHH36I1atXx9q1ayMjIyOys7OjVq1aUatWrdhpp52iVatWkZmZWeR+xo4dG/Pnz0/GS6uUFi1aFEceeWS89dZbsf322yfcJyMjI/r37x/9+/eP3Nzc+PLLL+PHH3+MhQsXxpIlSyIiYrvttosGDRpEo0aNom3btpGWlrbF2vPnz48jjzwyli1bVqLePZMCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAW1L0/8slAAAAAAAAAAAAAAAAAAAAZWbDhg0xdOjQuP/+++Oss86KIUOGxE477VTifMuXL4+HH344/v3vf8f333+fxE4Bks85EAAAAIrHszQAAAAAAAAAAAAAAAAAAACV1aZNm6Jfv34xadKkaNiwYcJ90tPTY//994/999+/yHnz8vLijDPOiKlTpyarVf5/d911VwwaNCj22muvhOM77bRTXHjhhXHhhRcWK++FF14YI0eOjM6dOyejzUrt0ksvjbS0tLj44osL3adOnTpx4oknxoknnliiGl988UX07NkzFi9eXNI2k2b58uXRs2fPeOONN6JZs2aF7teoUaMYMmRIsfPfdtttMWzYsDjooINK0+ZWpTLPsYkTJ8YZZ5wRDzzwQKSlpeUba9CgQQwYMCAGDBhQotw5OTnRp0+fmDx5cql6rGzv76BBg2Ly5MlRq1atQvdp3LhxNG7cuNDx77777ldrrF+/Pnr16hWvvfZadOzYMeE+VapUiYMPPjgOPvjgIvX9axYtWhRnnnlmqfMk29NPPx09e/YsdHzUqFElzj1nzpyYPHly7LnnngnH33rrrViyZEmJ85elspiTlI8FCxbEv/71r7jqqqsKjO25555xyimnxAMPPFAOnSVfRkZGPP744wnncV5eXgwaNCiWLl2a0h7y8vJiwIAB8fnnn0edOnUKjF966aUxZsyYmDBhQkr7KMxPP/0U3bt3jzfffDOaNGmScJ8ddtghBg8eHIMHDy5xnR9//DF69Ojh31RLoVTdnyXj3qwyzLPK+jxUGfs2Hyrn8/EXX3wRnTp1iieffLJIzwppaWnRvHnzaN68edJ6WLJkSVxyySVxzz33JC1nZfXFF1/EwQcfHKNHj97ie5yenh7t2rWLdu3alarmrFmzomfPnvH111+XOIdnUgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBL0su7AQAAAAAAAAAAAAAAAAAAAAo3f/78uPTSS6Np06axzz77xPnnnx9PP/10fPzxx7Fo0aJYv359gWNycnJi1qxZ8dprr8W1114bhx9+eDRs2DD+7//+L77//vtyeBUAJeMcCAAAAMXjWRoAAAAAAAAAAAAAAAAAAIDKaP78+XHggQfG119/nZR8ubm5cc4558TDDz+clHzkt379+ujVq1d8++23Scm3YcOGOP300+OGG25ISr6txSWXXBKnnnpqrF69Oum5X3755TjggANizpw5Sc9dUl9//XUccMAB8emnnyY177/+9a/485//nNScW4vKPMceeuihGDx4cGzYsCFpOX/88cc44ogj4tVXX01Kvsr0/n777bfRp0+fWL58eVLyFWbRokVxyCGHxIsvvpjSOnPnzo2uXbvGvHnzUlqnJF588cVC5+2MGTNixowZpco/cuTIQseeeeaZUuUuS2U1JykfN910U6Hr85prrons7Owy7ig1Lr/88th3330Tjv373/+ON998s0z6mDNnTpxxxhkJxzIyMmL48OFRq1atMuklkZkzZ8Z+++0XH374YUryf/rpp7H33nvH559/npL8/D/Jvj9L5r1ZZZhnlfV5qDL2bT5UzufjH374Ibp16xZ//etfy/QecdWqVXHTTTdFy5Yt45577imzuhXdl19+GXvttVfKn+0iIp5++uno2LFjUv7e2DMpAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8GvSy7sBAAAAAAAAAAAAAAAAAAAAtiw3Nzc+/vjjuPHGG6Nfv36xzz77RMOGDaNatWqRmZkZWVlZUbNmzUhPT4+aNWtG69ato2fPnnHJJZfE66+/Hhs2bCjvlwBQYs6BAAAAUDyepQEAAAAAAAAAAAAAAAAAAKhsvvrqq+jcuXOMHj26VHkWLlwYPXv2jLvuuitJnZHIjz/+GF26dImXX365VHmmTJkSnTt3jmHDhiWps63LAw88EHvssUe8+uqrScn3ww8/xMCBA+Poo4+OZcuWJSVnMs2bNy+6dOkSQ4cOjXXr1pUq16JFi+K4446Lv//970nqbutUmefYo48+Gvvvv3/MnDmz1LmeeeaZ2G233eK9995LQmf/T2V6f19//fXo3LlzvPvuu0nN+79WrlwZvXv3jr59+8b333+f1Nx5eXkxfPjw2GeffeKrr75Kau5kWbp0abz55psJx0aOHFnq/P/5z38Sxjdt2hQvvPBCqfOXpbKak5S9nJycuPjiixOO7bDDDoWOVSb7779/XHLJJQnHJk+eXOb3JyNGjIjHH3884djOO+8cd955Z5n287/mzp0bXbt2jUsuuSTWrFmTlJxr1qyJCy+8MDp37hxz585NSk62LFn3Z6m4N6sM86yyPg9Vxr7Nh8opNzc3br755mjVqlVcf/31sXTp0pTV+vLLL+P888+PJk2axN/+9rcK+Xco5W3ZsmXRu3fvOOqoo+KLL75Iev7PP/88evToEf369YuVK1cmLe+2/kwKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFC69vBsAAAAAAAAAAAAAAAAAAACgdDZt2hRr1qyJnJycyMvLK+92AMqUcyAAAAAUj2dpAAAAAAAAAAAAAAAAAAAAKqolS5bEkUceGd26dYv333+/WMcuW7YsbrjhhmjVqlWMHTs2RR3ySwsXLoyjjz46+vbtG++9916xjz/ppJOiQ4cOMWnSpOQ3txX59ttvo1evXrHPPvvE008/HWvWrCl2jkmTJsXpp58ezZs3j+HDh6egy+TZuHFjXHHFFdG8efO46aabYuHChcU6/qeffoqhQ4dGixYtYuTIkSnqcutSmefYxx9/HLvttluceeaZ8c033xTr2LVr18YzzzwTHTt2jBNPPDEWL16ckh4r0/s7Y8aMOOigg6JLly5x7733xpQpUyI3NzcltZ599tnYeeedo2/fvvH666/HunXrSpxr6dKl8eCDD0aXLl1i4MCBsWDBgiR2mnxPP/10wvh//vOfUuf+5JNP4ocffigQHzduXCxatKjU+ctaWc5Jytajjz4an332WcKxv/zlL/Gb3/ymjDtKnlq1asXjjz8eGRkZBcbWrl0bJ598cmzYsKHM+zrzzDNj9uzZCccGDhwY/fr1K+OO8tuwYUNce+21sfPOO8c111wTc+fOLVGeOXPmxOWXXx5NmzaN66+/PjZt2pTkTtmSkt6flcW9WWWYZ5X1eagy9m0+VF6LFi2KCy+8MBo3bhwDBw6M559/PlavXl3qvLm5ufHRRx/F3nvvHbvuumvceOONsXz58iR0vHV75ZVXYrfddotevXrF008/HatWrSpxrpUrV8aIESPiiCOOiPbt28eYMWOS2Gl+2/IzKQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJBYWl5eXl6RdkxLS3UvQCXVvn37aN++fURE5OXlxTfffBMTJ06MIp5eACqERo0axXl/O6+822Ab8MrLr8Rbb71V3m0AlFrdunXjkksvKe822Mq9+eabMfqV0eXdBgAAUMZuuPGG8m6BbcD0L6bHgw8+WN5tACTFn5+LqJZV3l2wNZs7NeKJv5V3FwAUJi0tLfbee+9o06bN5s97T5kyJaZMmVLOnW2bfKYWAAAAAAAAAAAAoGylpaXFPvvsE61bt/Z5WqDISvMZb/9WO1AYv1cCyXXooYfGkUcdWd5twK/y76YClF6vI3tFt27dyrsNKNTzzz0f77//fnm3AVCp9e/fP/bquFd5twGFeuCBB+LL6V+WdxsAldpfz/tr7LjjjuXdBvyqm268KRYsWFDebQBUamc8GlF7+/LuAgp3S5+I9WvKuwugvPi32isWn6kFUqlp06bRo0ePOOSQQ2KnnXaKhg0bRv369WPjxo2xbNmy+Omnn+Kzzz6L8ePHx+jRo2P9+vXl3fI2bZdddomuXbvGfvvtF61atYq6detGvXr1okqVKrFy5cpYtmxZTJ8+PT777LN4+eWXY9asWeXdcqVUvXr1OPzww6Nz587Rvn37aNy4cdSpUyeys7Nj3bp1sXz58liyZElMmzYtJk+eHGPGjInZs2eXd9sllp6eHgcddFB07do19txzz2jevPnm17tmzZpYsWJFzJkzJyZNmhTvvPNOvPXWW5Gbm1vebVdqlXmOderUKQ4//PDo0KFDtGzZcnPfa9eujeXLl8eCBQtiypQp8eGHH8arr74aq1evLvMeK9v7m5WVFTvuuGO+c3oiOTk58dZbb5W4Ts2aNePggw+O9u3bR9u2baNly5ZRq1atyM7OjqysrMjLy4tVq1bFypUrY8WKFfH1119vfg4cP358bNy4scS1qVzKak4C5W/vvfeOrl27RqdOnaJZs2ax/fbbR1ZWVmRmZsb69etjxYoVsWzZsvjqq69i2rRp8cYbb/j7wQrol/dnHTt2rHD3ZhV9nlXW56HK2rf5UHllZmbG7rvvHvvss0/suuuu0bRp02jatGlkZ2dHzZo1o3r16hHx33vEtWvXxsqVK2PevHkxb968mDlzZkyaNCkmT54cK1asKOdXUvlVq1Yt9t5779h3332jXbt20axZs2jUqFHUqFEjatSoERERa9asiZycnFiwYEHMnj07pk2bFh988EF8/PHH5fb3u55JAQAAqKz8W+1ASfi32oFU8HslQEXj37unvPg37IFtiest5cG1FtiW+P+6UB5eefkVv5cJbDNcaykv/t9owLbk8HMi9jq6vLtgWzPm9ohJL5d3FwBly7/VXrH4TC0AAAAAAAAAAABA2fJvtQMlUZTPeGeWQR8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABFNmfOnLj//vvj/vvvL+9WKIKvvvoqvvrqq3jggQfKu5Wt2tq1a2PUqFExatSo8m6lTOTm5sbbb78db7/9dnm3ss2ozHPsk08+iU8++aS82/hVle39Xb16dcyaNSvlddasWROjR4+O0aNHp7wWlVtZzUmg/H388cfx8ccfl3cblFJFvz+r6POssj4PVda+zYfKa+PGjTFp0qSYNGlSebeyzVu3bl2MHz8+xo8fX96tFItnUgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACC9vBsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAspJe3g0AAAAAAAD/1aFDh1i5cmWsXLkyrrnmmvJuBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALZKmeXdAAAAAAAA8F/p6emRnZ0dERFVq1Yt524AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABg65Re3g0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAWUkv7wYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgrGSWdwMAAAAAAAAAAAAAAAAAsC3IysqKunXrRkZGRsLx77//vow7AgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBtU2Z5NwAAAAAAANuqvfbaK0444YRo3759tGjRIpo3b7557Jxzzoljjjkmvv7665gwYUKMHj06Pv3006TUbd68efTu3Tu6du0a7dq1ix122CFq1aoVGRkZsWbNmvjhhx/iiy++iLfeeiueeuqp+OGHH5JStzCZmZlxyimnJC1fTk5OPPbYY0nLl8gee+wR++233+btL774It57772U1oyIOO2008q8JgAAAAAAQGXz1ltvJYwfeuihZdzJf1W0foCy07JlyzjqqKPi4IMPji5dusT2228fVapU+dVj0tLSyqg72Lq43vJLd955Z7Rr165A/Mwzz4wvv/yyHDoCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgIsos7wYAAAAAAGBbkpmZGWeccUb83//9X7Rs2bLQ/apXrx677LJL7LLLLnHkkUfG1VdfHVOmTIl//OMf8cILL5Sodps2beKf//xn9O7dO9LS0hLuk5WVFa1atYpWrVrFscceGzfeeGM8+uijcdFFF8VPP/1UorpbUq9evbj33nuTlm/BggXx2GOPJS3f/2rQoEGMHj06GjduvDl2zz33xHvvvZeymj/X/eX7VBY1AQAAAAAAKqNDDjkkKXmqVq2aML5+/fpi5UlWP0Dl0a5du7j88sujb9++kZ6eXt7twDbB9ZZf6tixY+y7774F4rVr1y6HbqBsJOv5Bdi2OZcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsK1JL+8GAAAAAABgW9GqVav46KOP4vbbb4+WLVsW+/j27dvH888/Hy+99FLUq1evWMcOGDAgPvvss+jTp0+kpaUV+biMjIwYMmRIfP7557HffvsVt+Uiyc7OTkneVBk+fHg0bty4XOoCAAAAAABQNtq0aRPr1q1L+KdNmzbl3R5QgfXr1y8+/fTT6NevX6Sn+/U9ACD1PL8AyeBcAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMC2KLO8GwAAAAAAgG1Bu3btYty4cdGgQYN88by8vJg6dWpMmjQp8vLyYtCgQRERMXny5Fi0aFHsvffeUadOnXzHHHXUUfH+++/HQQcdFD/99NMWaw8cODAeeeSRSEtLyxdfsWJFTJgwIWbOnBkrVqyIiIj69etHhw4donPnzpGRkbF53+233z7Gjh0b+++/f0yZMqVE70FhsrKykpovlS666KLo0aPHNlMXAAAAAAAAgKI7/fTT4+677y7w83kAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoOLJLO8GAAAAAABga1ejRo0YNWpUNGjQYHNs48aNcfvtt8ctt9wS33//fUREdOzYMQYNGhQREWPHjo3zzz8/IiIOO+ywuOKKK+LAAw/cfPwuu+wSr7zySuy7776xcePGQmu3bds2hg0bFmlpaZtj8+bNiwsvvDCefvrp2LBhQ8LjGjduHFdeeWX84Q9/2BzLysqKJ598Mtq3bx+bNm0qwTuRWHZ2dr7tCy64IN54440S5/u196M0unbtGldffXVKclfEugAAAAAAAAAU3R577BG33nprvp/PF2bTpk2F/rweAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgbmeXdAAAAAAAAbO3OO++8aNGixebtlStXxlFHHRXvvvtukY5/44034o033oizzjor7rjjjkhLS4uIiE6dOsXll18el19+eaHH3nHHHVG9evXN21OmTIlu3brF4sWLf7XmvHnz4tRTT42PP/447r777s3xdu3axYknnhhPPvlkkXoviuzs7Hzb06ZNi08//TRp+ZOhQYMGMWLEiMjIyNgm6gIAAAAAAABQPA8//HBUq1Yt4diiRYvirrvuipdffjmmT58eK1euLOPuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAID/lV7eDQAAAAAAwNbuj3/8Y77tP/3pT/Huu+8WO89dd90VZ511Vr7YX//612jYsGHC/du0aRPdunXbvL1ixYo4+uijY/HixUWuec8998Rzzz2XL3bSSScVo+sty8rKyredk5OT1PzJMHz48GjcuPHm7Ztvvrlc6gIAAAAAAABQ8Rx88MHRsWPHhGNjx46Nli1bxhVXXBEffvhhrFy5soy7AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASSS/vBgAAAAAAYGvWtGnT+M1vfrN5e+HChfHYY4+VON8999wTEydOjIiIjz76KE499dRYsmRJwn1nzJgRu+++ewwbNixycnLi2muvjTlz5hS75l133ZVvu2PHjsVv/FdkZ2fn287JyUlq/tK66KKLokePHpu3b7rppnjxxRfLpS4AAAAAAAAAFc8555yTMP7VV1/FscceGytWrCjjjgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACALcks7wYAAAAAAGBr1rhx43zbU6dOjdzc3FLlPP300yM7OzsmTJiwxX2/+OKLOP300+Pvf/97rF27tkT1pk6dmm97++23L1GewmRnZ+fbzsnJSWr+0ujatWtcffXVm7cnTpwYF110Uey///7lUve8885LaV0AAAAAAAD+a+3atfHxxx8XOgbwS926dUsYv/DCC50zAICU8/wCJINzCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADboszybgAAAAAAALZmVapUybe9du3aUuecMmVKsY9ZsmRJieutWbMm33bVqlVLnCuRrKysfNs5OTlJzV9SDRo0iBEjRkRGRkZE/Pc9PPHEE2Pjxo1bZV0AAAAAAAD+n++//z722Wef8m4DqAR23XXXqF+/foH44sWLY9SoUeXQEQCwrfH8AiSDcwkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA26L08m4AAAAAAAC2ZkuXLs23vf3225dTJyW33Xbb5dtesWJFUvNnZ2fn287JyUlq/pIaPnx4NG7cOCIi8vLyYtCgQTFnzpytti4AAAAAAAAAxdeuXbuE8Q8++CByc3PLuBsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoKjSy7sBAAAAAADYms2bNy/y8vI2b++5555Rv379cuyo+Pbdd9982/Pnz09q/uzs7HzbOTk5Sc1fEhdddFH06NFj8/ZNN90UL7/88lZbFwAAAAAAAICSKewzAN98800ZdwIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFEd6eTcAAAAAAABbs6VLl8a0adM2b2dmZsbQoUPLsaPiO/vss/Ntf/jhh0nNn52dnW87JycnqfmLq2vXrnH11Vdv3n7//ffjoosu2mrrAgAAAAAAAFBy9erVSxhfvnx5GXcCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABRHenk3AAAAAAAAW7uHH3443/bZZ58dV111VWRkZJRPQ8Vw2mmnxYEHHpgv9sQTTyS1RnZ2dr7tnJycAuMtW7aMPffcM/bcc89o2bJlVK9ePak9/KxBgwYxYsSIzd+bJUuWxIknnhibNm1KSb3yrgsAAAAAAABA6RT28+v169eXcScAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQHGkl3cDAAAAAACwtbvnnnvi22+/zRe79NJLY9q0aXHuuedGy5Yty6mzX9evX7+4884788U+/vjjGDNmTFLrZGVlbf56w4YNkZmZGSeddFI8+eSTMWfOnFi5cmXMmjUrJk2aFJMmTYpZs2bFmjVrYtasWXHvvfdG165dk9bL8OHDo3HjxhERkZeXFwMHDoy5c+cmLX9FqwsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAtyizvBgAAAAAAYGu3evXq6NOnT7z11ltRt27dzfFddtklbr311rj11ltjyZIlMXfu3M1jO+64YzRq1CgWLFhQ5v3WrFkzrr322jj33HMjLS1tc3z16tXxhz/8IfLy8pJaLzs7e/PX6enpMWfOnNh+++1/9Zi0tLRo2bJltGzZMk477bSYOHFinH322fHpp5+WuI+LLrooevTosXn7hhtuiFdeeaXE+Sp6XQAAAAAAACqPqlWrRnZ2dqxduzbWrFlT3u2Uuxo1akSNGjUiNzc3li9fnvSfYVI5VKtWLbKysmL9+vWxatWq8m5nq1dZ193P82TNmjWxdu3a8m5nm1SlSpXIzs6O3NzcWLFiRaWZO8XlnJQaP7+vOTk5kZOTU97tlLnK9vor27Xi535TeY3IzMyMWrVqxdq1ayvF9zBZKsP1t7Ktr2TKyMiIWrVqRVpaWqxatSo2bNhQ3i0VUKtWrcjMzKyw/ZE6Ff3e0dwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2PpklncDAAAAAACwLZg0aVJ06dIlnnnmmWjfvn2B8fr160f9+vU3b//ud7+L3/3ud7FixYr49NNP44MPPoiRI0fGhAkTUtZjenp6DBo0KK6++upo3LhxvrE1a9ZEnz59YsqUKUmvm5WVtfnrjIyM2H777YudY999942JEyfGn/70p7j33nuLfXzXrl3j6quv3rw9YcKEuPjii4udp7LUBQAAAAAAYMvatWuXMP7FF1+ktG6tWrXiqKOOiiOPPDI6dOgQbdq0iWrVqm0e37RpUyxYsCCmTJkSH330UbzwwgsxadKkpPeR6PX/+OOPsXjx4kKPqVatWrRv3z5atWoVderUiVq1akVaWtrm8dtuuy3Wrl1b5B6qVKkShx56aPTs2TPat28fu+22WzRs2DAyMjI275OXlxfLli2LJUuWxOTJk2PcuHExbty4mDx5cpHrFEVZvB877bRT1K1bt0Ce1atXx+zZs0v3AgqRmZkZbdq0KRDPzc2NL7/8MiU1S2L33XeP4447Ljp37hzt27ePxo0bR5UqVTaP5+XlxdKlS2PatGkxZcqUGDNmTIwZM6ZY860w9evXj0aNGhU6vsMOOxQaL+w88mtSfY7Zksq87urXrx99+/aNbt26xV577RXNmjWLqlWrbh5fs2ZNLFy4MKZPnx5jx46NMWPGxNSpU4vdl7VauA4dOsTRRx8de++9d+yxxx7RuHHjfNewvLy8WLFiRXzxxRfxySefxCuvvBJjxoyJTZs2lWPXxVee56Sfbb/99tGgQYMC8S1dm4orLS0tdt111wLxVMy9xo0bR+/eveOggw6KPffcM5o3b55vDW/cuDG+++67ze/piy++GD/++GNSeyhPO+20U5xwwgnRtWvX2GuvveI3v/lNvte/adOmmD9/fkybNi0mTJgQI0eOLPS8m5mZme+zaD9bsmRJbNy4sdS9VuRrxa+tgW7dukW/fv1iv/32i1122aXA/Pr+++9j0qRJ8eabb8YzzzwTP/30U7H72WuvvaJ///6x//77xx577BG1atXaPPbzdWjKlCkxevToeOWVV5J63UjW80tFvf6WRmVaX8nWuXPnOOyww6Jz587RoUOHaNCgQWRnZ+fbZ/369TFv3ryYOnVqfPbZZ/HSSy/FRx99VCb9VatWLXr06BE9evSIPffcM3bdddeoV69evuem9evXx+zZs2Pq1KkxYcKEePHFF2PWrFlJ66Gsnn0T3UMuXbo0fvjhh9K9gEIU9hyzePHiX71+luXfhVTke8eKMDcBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKBuZ5d0AAAAAAABsK2bMmBEdOnSIgQMHxumnnx7777//Fo+pXbt2HHLIIXHIIYfEhRdeGN98801cccUVMXz48KT21rdv37jqqqtil112KTD23XffxQknnBCffPJJUmv+LDs7u0Dshx9+iDfeeCM++uijmDt3bixfvjzS0tKiTp060aJFi9h///2jZ8+eUb169c3HVKlSJe65557Izc2N++67r8j1GzRoECNGjIiMjIyIiFi8eHH069cvNm3aVPoXVwHrAgAAAAAAUDTTpk1LGE9LS0tJvXr16sVFF10UZ511VsKfof0sIyMjGjduHI0bN45evXrF5ZdfHl9++WVce+218fjjj0dubm5S+kn0+i+88MK4/vrr88XS09Ojb9++8cc//jEOPvjgyMws/NeV7r///li7du0Wazdq1Cj+9re/xR//+MeoXbv2r+6blpYW9erVi3r16kXLli2jT58+ERHx0UcfxT//+c948cUXIy8vb4s1t6Qs3o9evXrF/fffX2C/ZcuWRaNGjWLdunWleAWJ/fa3v41nnnmmQHz06NFx5JFHJr1ecVSpUiV+//vfx9/+9reEP8v+pbS0tKhfv34ceOCBceCBB8bZZ58dq1evjuHDh8d1110X3377bYn7GDx4cNx0003FPu6ss86Ks846q1jHzJ8/Pxo3blzsWslQmdfdTjvtFEOHDo1BgwZFlSpVCs1Xs2bNaNasWTRr1ix69uwZERHvvvtuXH755fH2228XuS9rNb+aNWvGH//4x/jzn/8cO++886/u+/NnP/bbb7/Yb7/94pxzzomFCxfGLbfcEjfffHPk5OSUUdfFV1HOST/7y1/+EhdddFGBeKI1Uho1atRIuBZXrVoVtWrVSkqNAw88MC677LLo3r37r95nZWZmRqtWraJVq1bRp0+fuOOOO2L48OFx5ZVXxnfffZeUXspD586d46qrrorDDz/8V19/RkZGNG3aNJo2bRo9e/aMoUOHxscffxxXXXVVjBw5Mt+++++/f4wbN65Aji5dusSHH35Y4l4rw7Ui0Rro0aNH3HLLLdG2bdtC82RmZkaLFi2iRYsW0adPn7j11lvj0UcfjcsuuyzmzZu3xT723XffuOWWW6JLly6F7vPL69AxxxwTubm58cQTT8Sll14as2fP3mKNLUnW80tFvf6WRGVaX8lUpUqVOOOMM+KMM86Idu3abXH/qlWrxs477xw777xzHHPMMXH55ZfH3Llz47bbbot77703VqxYkfQemzZtGn//+99j4MCBv/r8+3N/rVu3jtatW0fv3r3jhhtuiI8++iiuvfbaePHFF0vdS1k9+ya6h5w2bVrsvvvupei+cHfddVf069evQPz444+P559/vtDjUv13IRX93rEizU0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAykZ6eTcAAAAAAADbkry8vHj00UfjgAMOiCZNmsQJJ5wQN9xwQ7z22muxYMGCLR7fokWLeOyxx2LMmDFRu3btUvdz5JFHxmeffRZPP/107LLLLvnGcnNzY9iwYbHHHnvEJ598Uupahbn00kvjs88+i4iIcePGxRFHHBGNGzeOgQMHxm233RbPP/98vPHGG/H666/Hc889FzfccEP07t07GjduHNdff31s2rQpX7477rgj2rdvX+T6w4cPj8aNG0fEf78/AwcOjLlz5ybvBVawugAAAAAAAFQ8xxxzTEyfPj0uuOCCyM7OLvbxbdu2jUcffTQmTZpUrJ+VlVbbtm1j4sSJMWLEiDjssMMiMzOzVPnS0tLib3/7W3z77bdx3nnnlepnovvss088//zzMX78+Nhxxx1L1VdRlfb9GDFiRKxatapAvG7dunHssccmq818BgwYkDD+4IMPpqReUR1xxBExc+bMuO+++wr8LLuosrKy4vTTT4+ZM2fGv//976hevXqSu0y+r776qsxrVvZ1179//5gxY0b84Q9/iCpVqhT7+AMPPDDeeuutePbZZyMrK6tIx1ir/8/JJ58c3333Xdxyyy2x8847lyhHw4YN45prromZM2dGt27dktxhcmyr56RUa9iwYTz//PPxzjvvxOGHHx5paWnFOj4zMzMGDx4cU6dOjbPOOitFXaZOrVq1Yvjw4fHBBx/EEUccUezXHxGx9957x3/+85947rnnon79+ino8r8q67UiIyMjbr/99nj11Vejbdu2xT52yJAhMW3atDjqqKMK3S89PT1uvPHGmDBhQnTp0qVYNdLT02PAgAExY8aMGDx4cLGOLW/lcf0tjsq0vpLtgAMOiEmTJsVtt90W7dq1K3GeJk2axPXXXx/fffdd/P73v09af1WqVIlrrrkmvv766zjzzDNL9Pwb8d9zyQsvvBDvvvtutGjRImn9FSYZz74jRoyIlStX5ovttttu0alTp2S1uVmdOnXiuOOOKxD/6aefYuTIkUmvV1QV+d6xss5NAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEovvbwbAAAAAACAbdW8efPiueeeiwsuuCB69uwZRx111Oaxt956K2688cYYM2ZMLF++vMCxhx9+eLzxxhtRtWrVEtU+6KCDYvz48fHyyy9Hhw4dCoy//vrr0bFjxzj99NNj1apVJapRVC+99FJ07Ngx2rVrF4ccckiMHTs28vLytnjckiVL4sILL4yePXvG2rVrN8erVq0aN910U5FqX3TRRdGjR4/N29dff32MHj26+C+imMqrLgAAAAAAABXP+eefH//5z39ihx12KHWuPfbYIz766KMYPHhw6Rvbgi5dusT7778f++yzT1Ly1a5dO95888244YYbonr16knJGRGx3377xaeffhpdunRJWs5EkvF+rF69Op588smEY6n4ntatWzd69epVIL5kyZIYOXJk0usVRXp6etx5553x2muvRbNmzZKSMyMjI/7yl7/ElClTom3btknJmSpfffVVmdar7Ovu6quvjscffzyysrJKnev444+PiRMnRvPmzbe4r7UaUaNGjXj22WfjiSeeiIYNGyYlZ+PGjWPs2LFxwQUXJCVfMmzr56RU6ty5c0ydOjV69+5d6lxZWVlx5513xrBhwyI9vXL82nS7du1i8uTJ8bvf/S4p+fr06RPjx4+PHXfcMSn5fqmyXivS09Pjueeei3POOadUeerUqROjRo2Kk046qcBY1a1W9ggAARkUSURBVKpV4+WXX47zzjsv0tLSSlyjatWq8dBDD8Vll11WmlbLTHldf4uqMq2vZPv9738f48aNi3bt2iUtZ7169eLhhx+O559/PqpVq1aqXE2aNIkPP/wwLr744qhSpUpS+uvatWtMmTIl3+dvky1Zz76rV6+OESNGFIgPGTKkVHkT6devX8Jz9sMPPxwbN25Mer0tqej3jpV1bgIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQHOnl3QAAAAAAAFDQJ598Eueff3706NEjGjRoEMccc0x89NFH+fbZe++949prry1W3qZNm8bzzz8f48aNi/3337/A+HvvvRcHH3xwHH744TF58uRSvYbimj59eomOe/311+PMM8/MF+vevXvssssuv3pc165d4+qrr968PX78+LjkkktK1ENxlFddAAAAAAAAKp5zzz03rr/++khLS0tazqpVq8aDDz4Y5557btJy/q8WLVrEq6++GnXr1k1Kvnr16sXbb78dhxxySJH2z83NjdWrV8fGjRuLtH+jRo3ipZdeiqZNm5aiy8Il8/0YNmxYwniPHj2iUaNGpc7/S3379o2qVasWiD/xxBOxfv36pNYqiurVq8d//vOfOOuss1KSv3Xr1jFhwoQ44IADUpI/Gb766qsyq1XZ190ll1yS9J+177777jFmzJioVavWFvfdltdq/fr14+23347jjz8+6bnT09PjuuuuqxCfo3BOSp2DDz443njjjdh+++2TmvePf/xj3HvvvUnNmQp77rlnjBs3Lnbeeeek5m3btm288cYbkZWVlbSclflacffdd8dxxx2XlFxpaWnxyCOPRJcuXfLFR4wYET179kxKjYiIoUOHxoABA5KWLxXK+/q7JZVpfSXbkCFD4qGHHoqMjIwi7Z+TkxNr1qyJvLy8Iu3fu3fveO2116JatWol6u/n616HDh2KtP/GjRsjJyenSPtmZWXFiy++GP369StRb78m2c++ie4h+/fvn/BerzSGDBmSMH7fffcltU5RVPR7x8o6NwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABInszybgAAAAAAAPh1GzdujJdeeileeeWVuPPOO+OMM87YPHb22WfH9ddfHz/99NMW8/Tq1Ssef/zxqFevXoGxjz76KC655JIYO3ZsUnsvKw8//HD89a9/jT322GNz7Nhjj40bbrgh4f7bbbddjBgxIjIyMiIiYtGiRdGvX7/YtGlTSvssr7oAAAAAAABUPAcddFDcfPPNBeLr16+P1157LUaPHh2TJk2KBQsWxJo1ayIrKyt22GGHaN26dfTs2TN69eoVdevWTZg7LS0tbrnllvjmm2/ipZdeSmrfGRkZ8fzzzxdauyQef/zx2GuvvQodf/fdd+PZZ5+N8ePHx4wZM2LlypWbx2rVqhU777xzHHLIITFo0KDo1KlTwhwNGjSI5557Lg444IDYsGFD0npP9vvx8ccfx+TJk2PPPfcsUOd3v/td3HTTTUmpExExYMCAhPEHH3wwaTWK47HHHoujjz660PHc3Nx4//33Y9SoUfHRRx/FggULYsmSJVGzZs3YYYcdolWrVnHkkUdGz549C/1+1KtXL15++eXYb7/9Yvr06UXq64cffoiJEycWOt6kSZNo0qRJgfjcuXNj7ty5Rarxs48//rhY+5dGZV533bt3j6FDhxaI5+XlxTvvvBMvvvhifPzxxzFv3rxYs2ZN1K5dOxo2bBh77bVXHHnkkdGjR4/NP7f/X61bt45HHnkk+vTp86s9bKtrtWrVqjFq1Kjo3Llzofts2rQpxo8fH6+88kp8/PHH8eOPP8bixYsjLS0t6tSpE61bt46DDjooTj755Nhpp50S5rj66qtj1qxZ8dRTT6XqpWxRRT0nVXYtW7aMF198MbKzswvdZ926dfHmm2/GK6+8ElOmTIkff/wxli1bFtWqVYvtttsu9thjj+jevXscd9xxUbt27XzHnnrqqTF58uRUv4wSa9SoUbz66qvRoEGDQvdZu3ZtvPnmmzFq1KiYPn16/Pjjj7F06dLN94LNmjWLXr16xVFHHRXbbbddvmN33XXXuPvuu+P+++9PSr+V9VrRp0+fOO200wrEv/nmm3jkkUdi3LhxMXv27Fi7dm3Ur18/dtxxx+jWrVuccMIJ0aZNm4Q5q1atGg888EB06NAhNm7cGOedd1707t27wH7Lli2LESNGxCuvvBJffvllrFy5MrKzs2OHHXaIvffeO3r37h0HH3xwob3fddddMX78+Pj2229L/gakSEW4/v6ayra+kqlFixZxxx13RFpaWsLx+fPnxxNPPBGvvfZaTJ06NX766afIzc3dPF6/fv1o06ZNdO3aNY4//vjYd999E+Y5+OCD47bbbovTTz+9WP3Vr18/xowZE02bNi10nylTpsRTTz0VY8aMia+//jqWLl0aEf9dew0aNIi99947jjjiiPjd736X8LqamZkZjzzySHz33XfxwQcfFKu/wqTi2ffjjz+OSZMmRYcOHTbH6tWrF8cee2w8++yzSamxyy67JPwevv322zFr1qyk1Ciqin7vWFnnJgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADJlVneDQAAAAAAAEWTm5sbZ599duyzzz7RqVOniIioXr169OnTJ+65555fPbZv377x5JNPRkZGRr745MmT47LLLotRo0alrO+y8swzz8Qee+yxebtjx46F7vv4449H48aNIyIiLy8vBg4cGPPmzUt5j+VVFwAAAAAAgIrn/vvvj/T09M3beXl5cffdd8c111wT8+fPT3jMN998E++//348+uijkZWVFX/5y1/i/PPPj9q1axfYNy0tLR5//PHYbbfdYu7cuUnr+5xzzok999yzQHzp0qXxn//8J1566aX4/PPP48cff4zly5dvMd+f/vSn6NWrV8KxTz/9NM4888z48MMPCz1+5cqVMWXKlJgyZUrcdttt0adPn3jooYcSvif77LNPDB48OO67774t9lVUyX4/IiLuu+++uOOOOwrEBw8eHDfddFOpe46IaNKkSRx44IEF4pMnT47PPvssKTWK47LLLosTTjih0PFXX301Lrjggvj8888Tjv+8Nh577LHIysqKv/71r3HBBRdEdnZ2gX3r1KkTL7/8cnTo0CFWrFixxd6efPLJePLJJwsdv/zyy+PKK68sEL/vvvti6NChW8xfHirzuqtevXqB82dExMsvvxwXXnhhTJs2rcAxP/74Y8ycOTMmTJgQd955Z7Rr1y5uu+22OOywwxLW6N27d/Tt2zeeeeaZX+1lW1yrd999d+y///6Fjj/77LNxySWXxIwZMxKOz58/P6ZPnx4jR46Miy66KM4555y49tpro0aNGgX2vffee2P8+PFJvYYVVUU+J1VmmZmZ8fzzz0fdunUTjm/atCkefPDBuPLKKwv9PM33338fn332WTz66KNRq1atOPfcc+PSSy+N6tWrb97nuuuuiyVLlqTiJZRKWlpaPPPMM9GoUaOE47m5ufHAAw/EJZdcEgsXLky4z89za8SIEVG1atX4y1/+Epdeemm+uTVw4MD46quvSt1vZb1W1KxZM26//fYCvZx33nnxwAMPRG5ubr6xBQsWxBdffBFvvPFGXHbZZXH22WfHDTfcENWqVSuQe7fddotTTjkl3njjjbj22mvzjeXl5cUtt9wS//jHPxKu5VmzZsX48ePj1ltvjcMPPzzuu+++aNasWYH9atWqFTfeeGMcf/zxJXn5KVORrr+JVLb1lWy33HJL1KxZs0A8Nzc3Lr/88rjxxhtj3bp1hR6/ZMmSmDhxYkycODFuvPHG2H///ePuu++O9u3bF9j3tNNOi2effTbGjh1b5P6eeuqpaN68ecKxOXPmxF//+td49tlnE46vX78+5s+fHyNHjoyRI0fGxRdfHBdeeGFcdNFFBeZjtWrV4tlnn422bdvG6tWri9xfYVLxrBcRMWzYsLjrrrvyxYYMGVLoe1BcgwcPLrRuWavo946VdW4CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkFzp5d0AAAAAAABQdLm5uXHLLbfkix188MG/ekynTp3i8ccfj4yMjM2x5cuXxymnnBIdOnSIUaNGpaLVMvfFF1/k227UqFHC/S666KLo0aPH5u3XXnst1qxZEwcddFCR/3To0CFfzp122qnAPnXr1k163eLWBAAAAAAAoOJq3br15q+XL18ehx12WJx99tkxf/78Ih2/evXquPrqq6Njx44xffr0hPvUrl07br755qT0GxFRs2bNuPTSS/PF1q1bF9ddd13svPPOMWTIkHjuuedixowZsXz58i3mq127dlxxxRUJx4YPHx6dO3eODz/8sFg9Pv/883HAAQcUWv/888+PtLS0YuUsTLLfj58NHz48cnJyCsR333332GuvvUrdd0RE//79E74PDz74YFLyF8fuu+8el112WcKxjRs3xumnnx69evWKzz//vEj5Vq9eHVdddVXsueeeha6NnXfeOa6//voS91yZVfZ1d+qpp0azZs02b/88R44++uiYNm1akXJ88cUXccQRR8RDDz1U6D4XXHDBFvNsa2u1e/fuccoppyQcy8nJib59+0bfvn1jxowZRcq3cePGuOWWW2L//fePhQsXFhivU6dOXHnllaXquSSck1Lnz3/+c7Rv3z7h2NKlS+OII46I0047LebNm1ekfCtXroxrrrkm9tprr/j22283x2vWrBlNmjRJSs/JdOqpp0bXrl0Tjq1atSq6d+8ep512WsL1kMj69evjuuuui/bt28c333yTb+yiiy4qVa+V+Vrxhz/8IXbaaafN299991107Ngx7rvvvsjNzf3VY3Nzc+P222+Pvn37xsaNGxPu85e//CWuuuqqqFq16uZYTk5OHHXUUfHXv/41VqxYscUex44dGwcffHChc/24446rcHO4Il1/C+uvsqyvZGvYsGH06tUr4djJJ58c11xzTaxbt65YOSdMmBD77LNPPP/88wnHhw4dWuRcAwYMiO7duyccGz9+fHTq1CmeffbZIudbsWJFXHLJJXHUUUfFypUrC4w3adIkKfcPqXrWi4h4/PHHC8R69OgRO+64Y6l6johIS0uLgQMHFogvWbIknnvuuVLnL46Kfu9YWecmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMmXXt4NAAAAAAAAxTNhwoR8202aNCl03/T09Bg+fHhUqVJlc2zBggXRuXPneOihh1LWY3lYvHhxvu3s7OyE+1199dX5tnv27Bnjxo0r1p9bb701X45jjz22wD7NmzdPet3i1gQAAAAAAKDiW7NmTXTr1i3eeuutEh3/9ddfR5cuXeLTTz9NOH7CCSfEAQccUJoWNzv55JOjQYMGm7cXLVoU3bp1i4suuiiWL19e7HxVqlSJJ598MtauXZsv/sorr8TAgQNj06ZNJepz6tSpcfbZZycca926dfTq1atEef9Xst+Pny1fvjyeffbZhGNDhgwpcd5fGjBgQIHYhg0b4vHHH09K/uK455578v1M+5f9HHnkkTFs2LAS5f3mm2+iS5cuMXHixITjp512WnTu3LlEuSuzyr7umjZtuvnr3Nzc6NevX4nmSG5ubpxyyinxzjvvJBzfe++946CDDvrVHNvaWr3rrrsSxtesWROHHHJIoe/FlkyaNCm6d+8ea9asKTDWuXPnqFq1aonylpRzUmrUrVs3rrjiioRjS5YsiS5dusSbb75ZotxffvllHHDAATF37tzStJhS2dnZce211yYcW7lyZRx66KElvhf89ttvo2vXrvH111/nq1calfla8cvP0i1evDgOPfTQmDVrVrFyjBo1Km666aaEY23bto2TTz5583Zubm706dMnRo8eXawas2fPjt///vcJxzIyMuKMM84oVr5Uq0jX3/9V2dZXsh1zzDGRmZlZIP7UU0/F008/XeK869evj379+sX777+fLz527Ni4/PLLi5SjevXqcf311yccmzx5cnTv3j0WLlxYov5effXVGDRoUMKxP/3pT7HDDjuUKO/PUvWsFxGxYsWKArGMjIyE933F1b1792jcuHGB+GOPPRbr168vdf6iSk9Pr9D3jpV5bgIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQfOnl3QAAAAAAAFA8ixYtyrddv379QvcdOHBgtG3bdvN2bm5u9O7dO2bMmJGy/spLlSpV8m2vX78+4X4ZGRll0U58++23ZV73f2sCAAAAAABQ8Z111lnx6aeflirHypUr4/jjj4+lS5cmHP+///u/UuX/WZs2bTZ/vWzZsthvv/1iwoQJJc63ePHi+NOf/hQ777xz3HTTTbF69epYtmxZDBo0qNS9Pv744/H5558nHDvssMNKnT8i+e/HLw0bNixhvH///pGZmVmq3LvvvnvsscceBeKjRo2KxYsXlyp3cR144IFxwAEHJBw7//zzY+zYsaXK//Pa+OmnnwqMpaWlxcUXX1yq/JVRZV93v3TFFVfE888/X6ocgwcPjg0bNiQcO+6447Z4/LayViMiWrdunTB+1llnxYcffliq3FOmTIm//vWvm7c//PDD6N27d7Rv377Qz3+kgnNS6pxyyilRq1atAvG8vLwYMGBAzJw5s1T5f/jhhzj++ONj06ZNpcqTKr///e+jQYMGCcfOPffc+Pjjj0uV/4cffogBAwYk7fVvLdeK3//+9/Hdd9+V6Nirr746lixZssX9rrvuunj11VdLVOONN94o9NgePXqUKGdZqAjX31+qbOsr2Vq2bJkw/sgjj5Q698aNG2PIkCGRk5MTjz32WOy5555xxBFHFPl62L9//9hxxx0LxFesWBG9e/eOtWvXlqq/F198Me6///4C8apVq8bZZ59dqtypfNYrzCmnnFLqHEOGDEkYL+yeNVX69OlToe8dK/PcBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACD50su7AQAAAAAA2BZ07949Dj744KTkqlatWr7ttWvXFrrvqaeemm/7qaeeiokTJyalj4pmp512yrf9448/llMnEUuWLInly5dv9TUBAAAAAAAonXfffTceeeSRpOT67rvv4oILLkg49tvf/jYaNWqUlDo/O+WUU2LWrFlJybVgwYL429/+Fs2aNYtjjz02Fi9enJS89957b8L4gQcemJT8v5TM9yMi4r333osvv/yyQHy77baLo446qlS5BwwYkDD+4IMPlipvSfztb39LGH/99dfj1ltvTUqN+fPnxx//+MeEY8cee2y0bt06KXUqm8q+7iZPnhz//Oc/S53n22+/jRdffDHhWNeuXbd4/LayVgszcuTIpF3Hhg0bFnfffXcccsgh0aVLl3jxxRcjLy8vKbmLyjkpdc4888yE8YcffjhGjx6dlBoffvhhoeeg8nb22WcnjI8ePToefvjhpNSYOHFi3H777UnJ9bPKfK34z3/+Ey+//HKJj1+1alU899xzv7rPvHnz4qqrripxjYjCz+l77rlngc8JVgQV5fr7S5V1fSXL/35u8mdff/11UvJ/9dVXscMOO8SgQYNiypQpxTr2nHPOSRi/7bbb4ttvv01Ge/HPf/4zcnNzC8QHDRqUlPwRyX/Wi4j44osvCsTatm0bnTt3LnHO2rVrx29/+9sC8ffffz9hvVT685//nDBeUe4dt5a5CQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBypJd3AwAAAAAAsDU78MAD45133omxY8fGzTffHGlpaaXO2bp163zbP/zwQ8L96tWrFwcccEC+2P3331/q+hXVoYcemm/7+++/T7jfLrvsUuo/AwcOzJfzqaeeyje+9957p6RucWsCAAAAAABQsV111VVJzffYY4/FwoULC8QzMzOjZ8+eSavzwgsvxAsvvJC0fD9bvHhxvPvuu0nL9+abbyaM77XXXpGRkZG0Oql6P+67776E8cGDB5cq78knn1wgtmDBgnj11VdLlbe4atWqFb169Uo49s9//jOptUaOHBnTpk0rEE9LS4sTTjghqbUqm8q67i677LLYtGlTUnI99NBDCeMdO3aMmjVrbvH4rX2tRkRsv/32CePXXXdd0mrk5eXFWWedFePGjUtazuJwTkqdNm3aRKtWrRKO3XTTTUmtdfXVV8fGjRuTmrO02rRpE7vuumvCsWuuuSaptW666aaknRt/qTJeK5Jxn/3cc8/96vgtt9wSOTk5parx0ksvxfr16wvEq1SpEnvttVepcqdCRbr+Rmwd66u0qlWrljCel5eXtBorV64s9jG/+c1vEs7hNWvWxM0335yMtiIi4ptvvonXX3+9QLxZs2aFzo3iKOtnvSFDhpQ454knnhg1atQoEB82bFiJc5bE9ttvX+Czyz+rCPeOW8vcBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACB50su7AQAAAAAA2FpVrVo1nnvuuTjwwAMjImKvvfaKv/zlL6XO279//3zbkyZNSrhfhw4dIi0tbfP2hg0b4r333it1/WTr0KFDPP3003HbbbeVOMdOO+0UJ5xwQr7Ya6+9lnDfGTNmlPrP999/ny/n0qVL841/++23Kalb3JoAAAAAAABUXLNnz46xY8cmNee6devigQceSDjWs2fPpNW55ZZbkpYrlb788stYtWpVgXhmZmbUq1cvaXVS9X488sgjsX79+gLxo446Kho0aFCinAceeGD85je/KRB/7LHHYtOmTSXKWVJHHHFEVKlSpUB86tSp8eabbya9XmHfp2OOOSbptbZlZbHuZs+eHaNGjUpKroiI8ePHR15eXoF4ZmZmNGvWbIvHb+1rNSLxNeSzzz6LCRMmlHkvqeKclDpHHHFEwvg777wT06ZNS2qtH374IV566aWk5iytwu7BJk+eHOPHj09qrblz58bLL7+c1JypkOprxeTJk+OTTz4pdZ5fy5GbmxuPPPJIqWvk5OTEl19+mXBs5513LnX+ZKpo198I6ysiYtmyZQnj5T1/Dj/88ITx119/PZYsWZLUWm+//XbC+CGHHFLq3Kl61nv00Udj3bp1BeInn3xyVKtWrUQ5hwwZUiC2YsWKePrpp0uUr6R69uyZ77PLP6so945by9wEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIHnSy7sBAAAAAADYWq1fvz5uvPHGfLHrr78+fvvb35Y4Z9euXeP000/PF3v++ecT7tusWbN8299++22sX7++xLWLqlq1alGzZs18fwrz/PPPx2effRZ9+/aNs846Kw477LBi16tSpUo88sgjkZWVtTm2ZMmSeOutt0rUPwAAAAAAAJSFMWPGpCTvm2++mTC+zz77JCX/l19+Ge+8805ScqVaXl5e/PDDDwnH6tevn5QaqXw/Fi9eHC+++GKBeJUqVeLkk08uUc4BAwYkjD/00EMlylcahx56aML4q6++mpJ6heXt0qVLVKtWLSU1t0Vlse5eeumlpOT52YoVK+Lrr79OOFavXr0tHr+1r9WIiAMPPLBA7LXXXiuHTlLHOSl1unTpkjCeqs/2vPLKKynJW1L77bdfwniyz2WpzptMqb5WJOv8tGjRoli4cGHCsUmTJhU6VlzTpk1LGK9bt25S8idLRbv+RlhfEVHoWirpPUiydO3aNWE8FfcPEydOTBjfbbfdSpU3lc96S5YsiRdeeKFAvE6dOiX6jHGrVq1i//33LxB/4oknYs2aNSVpscQS3TdGVJx7x61hbgIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQXOnl3QAAAAAAAGzNbr755pg0adLm7YyMjHjuuefi8ssvj6pVqxYr18CBA2P06NGRmZm5OfbSSy/Fp59+mnD/2rVr59tevHhxseqV1LPPPhurV6/O96cwc+fO3fx1RkZGjBo1KgYMGFDkWjvuuGOMHj06unfvni9+xRVXxNq1a4vfPAAAAAAAAJSRd999NyV5P/zww8jLyysQb968ebF/RpnI22+/XeocZWn58uUJ4/Xr109K/lS/H8OGDUsYHzx4cLFzValSJU444YQC8Q8++CCmT59e7Hyl1a5du4Tx9957LyX15s6dG3PmzCkQT09Pj1122SUlNbdVqV5377zzTlLy/FKiuRFR9J635rUaEbHrrrsWiE2YMKEcOkkd56TUKez1vP/++ympl6p7rJJq27Ztwvj48eNTUu+DDz5ISd5kS+W1IpnnpwULFiSMJ/N9LqxG3bp1k1YjGSri9df6Kvw6NWjQoOjbt28Zd/P/FPa9ScW5/4cffkgYb9OmTanypvpZ7957700YHzJkSLFzFXbPWdg9aiolum+MqDj3jlvD3AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAguTLLuwEAAAAAANiabdiwIfr16xfvvfdeNGzYMCIi0tPT48orr4xTTz017rvvvnjppZdi8uTJBY6tVq1atG3bNg499NA45ZRTYo899sg3/tNPP8U555xTaO3MzPw/BmjevHncfffdSXhVEddee23MmTOn1HkuueSS6NWrV7Rq1SoiImrUqBGPPfZY/N///V889NBD8dZbb8XMmTNjw4YNm4/JysqKzp07x/HHHx+///3vIzs7O1/OcePGJe11AgAAAAAAQKrMnDkzJXmXL18es2fPjubNm+eLp6enR4sWLeLLL78sVf4PPvigVMeXhUaNGkXLli2jRYsWUb9+/YT7VK1aNSm1Uv1+vPHGG/HNN99EixYt8sU7duwYu+++e0ydOrXIuXr16pXw/XjwwQdL3WdJ7Lrrrgnjn376acpqfvLJJ9G0adOEvUyZMiVldbcFZbnupk+fnpQ8v7R8+fKE8bp16xbp+K15rUZE7LLLLgVin332WTl0kjrOSanTunXrhPFUvcavv/46cnNzIz09PSX5i+vnz0X9r1StoalTp8b69euTds5NprK6ViTzPnvlypUJ4zNmzEh5jaJeg8pKRbz+Wl8R7733XixevDi22267fPH09PR46qmn4uijj45///vfCT+jmkpt2rRJGJ89e3bSay1dujRhvF69eqXKm+pnvbfffjtmzZpVYB4ffvjh0bhx45g3b16R8qSlpcWgQYMKxD/99NNyuV9LdN8YUXHuHbeGuQkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAcmWWdwMAAAAAALC1mzFjRhx22GHx8ssvR9OmTTfHmzZtGkOHDo2hQ4fGxo0bY8mSJZvH/vSnP8V5550XaWlpCXP+9NNPcdhhh8Xs2bOL3MeOO+4YZ5xxRslfyC/cd999MWfOnFLnWblyZfTs2TPGjh0bO++88+Z4p06dolOnThERkZubGytXrox169ZFrVq1okaNGoXm++STT+KYY46JTZs2lbo3AAAAAAAASKXi/KyvuJYsWRLNmzcvEK9Xr16pc0+ePLnUOUqrWrVq0bx582jZsmW0aNEiWrVqFS1atNj859d+pphsZfF+3H///XHttdcWiA8ePDj+9re/FTnPgAEDCsRycnJixIgRpeqvpBo2bJgwvnDhwpTVXLRoUcJ4gwYNUlZza1GR1t28efOSnnPFihUJ4+np6UXOsbWu1YiI+vXrF4ilcq2WB+ek1KlTp07C+OLFi1NSb8OGDTF//vxo0qRJSvIXR3p6emRnZyccK+z7X1q5ubmxZMmSaNSoUUry/5qKcq2YP39+0nKtWrUqYXzBggVJq7Fy5cqE8eJcg8pCRbv+bmvrqzAbNmyIf/7zn3HjjTcWGEtLS4tBgwbFoEGDYu7cufHRRx/FtGnTYtasWZv//PjjjynpK9GzZ05OTr7PySZLYeu0Vq1apcpbFs969913X1x33XX5Yunp6TFw4MD417/+VaQc3bp1y/fZ5J8NGzYsKT0WV6L7xoiKc++4NcxNAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJIrs7wbAAAAAACAbcHnn38eHTp0iDvuuCNOOumkSEtLyzeemZkZ22+//ebtatWqFZrrueeeizPPPDMWLlyYsn7L0tdffx2dO3eOm2++OQYMGFBgPD09PerUqfOrOfLy8uLWW2+Niy66KNatW5eqVgEAAAAAACBpVqxYkbLcy5YtSxjPzs4ude7FixeXOkdR7bTTTtGpU6do3759tGrVKlq0aBEtW7aMnXbaqcDPXMtLWbwfDz30UAwdOjQyM/P/Ktjvfve7uOCCCyI3N3eLOWrVqhXHHHNMgfgLL7yQ0rlYmBo1akRGRkaB+Lp162Lt2rUpq7t06dKE8Vq1aqWsZmVTGdbdypUrk56zKOtoS7bGtRoRUbNmzUhPT88XW7du3Vb1+QznpNSpWbNmwnPHunXrYv369Smrm4rzREkU9r1ctWpVbNy4MWV1ly1bFo0aNUpZ/op+rVi9enXSchV27i6LGhVNRbv+bq3rqyRuv/326N27dxxwwAGF7tOkSZNo0qRJ9O7dO1989erV8fXXX8esWbNi1qxZMXPmzJg8eXJMmTKlxNf6ws79NWrUiJycnBLl/DWFnXd+7XO4RVEWz3oPP/xwXH311VGlSpV88VNOOSX+9a9/FSnHkCFDCsTWrFkTTzzxRFJ6LI5E940RFefecWuZmwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkV2Z5NwAAAAAAANuKJUuWRP/+/eNf//pXnHnmmXHCCSdEgwYNinTsTz/9FC+99FLcfvvtMWnSpNQ2Wg4WLVoUAwcOjJtuuinOPffcOO6446J+/fpbPG7VqlUxYsSIuOWWW2LatGll0CkAAAAAAAAkx5o1a1KWe/ny5Qnj2dnZKcudLLvttlsMGjQo+vXrF82aNUtprWRI9fsREbFgwYJ45ZVX4thjj80Xb9SoUfTo0SNGjx69xRx9+vSJ6tWrF4g/+OCDSeuzOLKyshLGV6xYkdK6S5cuTRivXbt2SutWdJVt3W3YsKG8W0hoa1yrEYnXa6rXallzTkqd8npvV69endL8RVWtWrWE8VT3l4r3tzJdK8riOrF+/fqU16hoKtr1d2taX6W1fv36OO6442Ls2LGx1157FevYrKysaN++fbRv3z5ffOPGjTFu3Lh4/PHHY8SIEZGTk1OsnIVJdJ9TUZXFs95PP/0Uo0aNij59+uSLt27dOvbbb794//33f/X4WrVqRe/evQvEn3rqqVi5cmVSey2K8rruF9XWMjcBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASK7M8m4AAAAAAAC2NVOmTIkzzzwzzjrrrGjbtm106tQpmjRpEnvssUf0798/IiI++OCDGDFiRMydOzemTp0aX375ZbHr/Pvf/45///vfyW5/i4455piIiPjHP/4RV1xxRbGOnTRpUpxyyimRnp4eHTp0iHbt2kWLFi2idu3akZWVFWvWrIklS5bETz/9FB999FFMmTIlcnNzU/EyftU777wTaWlpZV63PGoCAAAAAACQGnl5eSnLvWnTpoTxZPy8acWKFaXOkUizZs3in//8Z5x00kmV6udiqXo//tewYcPi2GOPLRAfPHhwjB49eovHDxgwoEDs+++/jzfffDMp/RVXenp6wnhhczdZUrk2KqPKuu4qsq1trUYkXh+pXqtlzTkpdQp7Lal+bzdu3JjS/KWVyvvAiEjq56lcKxJL9feQkqtM6yuZFi9eHPvtt1/8+9//jtNPPz0yMjJKlS8zMzMOO+ywOOyww+Lqq6+OSy+9NB566KEiHbu1nCvK8lmvT58+BeJDhgyJ999//1eP7du3b9SsWTNhzvJQXtf9otpa5iYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyZVZ3g0AAAAAAMC2Ki8vL6ZPnx7Tp0+PiIiOHTtG//79IyLi3XffjVtuuaUcuyu97OzsiIjIyckp9rG5ubnx6aefxqeffprstgAAAAAAAIBSyMvLS3rO7t27xzPPPBN169YtcY4lS5bEzJkzY+bMmfHVV19t/vrOO++MfffdN3nN/o9UvB+JjB49OubOnRtNmjTJFz/uuOOibt26sWzZskKPbdSoUXTr1q1A/JFHHimz/ql4KvO6q8isVeCXClu76enpKa1bpUqVpORxraAiq+zrKxXWrVsXZ599dtx6663x97//Pfr06RO1a9cudd6ddtopHnzwwTj88MNjyJAhsW7duiR0W/GV1f3XmDFjYvbs2dGsWbN88X79+sWf//znX/0M7pAhQwrEpk2bFhMnTkx6nwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwtcos7wYAAAAAAICt0wEHHBAREfPmzSvnTgAAAAAAAKDiqVKlSmzYsCEluatWrZowvmnTppTUK41evXrFqFGjIiMjY4v7rlq1KmbMmBEzZsyImTNn5vvv0qVLEx6zdu3aZLdcLnJzc+Ohhx6Kyy67LF+8WrVq0a9fv7j33nsLPfakk06K9PT0fLG8vLx46KGHUtJrURQ2FzMzU/vrblWqVEkYr4hrI5Wsu9TZ2tZqxH9f0/9K9Vota85JhUtLSyvV8YW9lsJee7KkOn9RrVmzJmG8du3aKa1bt27dUudwraCiq8zrK9VmzJgRQ4YMidNPPz0OOeSQ2GeffaJTp07Rtm3baNGiRVSrVq1EeU8++eSoVatWHHPMMb+6X15eXsL4smXLYsSIESWqXRKLFy8us1qlkZeXFw888EAMHTo0X7x27drRu3fveOKJJxIe16JFi+jatWuB+LBhw1LSZ1Ekum+MqDj3juYmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIlklncDAAAAAADA1iUtLS1uvvnm2HfffSMiYvTo0eXcEQAAAAAAAFQ8derUiUWLFqUkd926dRPGV61alZJ6JdW8efN44oknIiMjI+H44sWL47nnnouxY8fGRx99FLNnzy52jbS0tNK2WWHcf//9cckll0R6enq++ODBg+Pee+8t9LgBAwYUiL3zzjvx7bffJr3HoipsLhY2d5Olfv36CeMrVqxIad2KxLpLva1prUZErF27tkCsTp065dBJ6jgnFa5GjRqlOn716tUJ46meQ1lZWSnNX1SrV6+OvLy8AufF6tWrR/Xq1ROur2Qo7dx1raAyqKzrqyytX78+xowZE2PGjNkcS0tLiyZNmkSrVq2iVatW0bp1681ft2rVaovn/aOPPjouvvjiuPbaawvdp7D3ftWqVXHmmWeW7MVs5R588MG44oorCpx3hwwZEk888UTCYwYPHlwgtm7dunjsscdS0WKRFPa9ryj3juYmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIlklncDAAAAAADA1qNevXrx5JNPRo8ePSIi4rvvvosrr7yynLsCAAAAAACAiqdu3bqxaNGilOVOZNWqVSmpV1LXXnttwl5XrVoVf//732PYsGGxfv36UtXIzs4u1fEVyffffx9jx47d/PPYn+27777Rpk2bmDFjRoFj2rRpE506dSoQf/DBB1PWZ1GsW7cuNm7cGJmZ+X+9LTMzM7KysmL16tUpqVuvXr2E8ZUrV6akXkVk3aXe1rRWIyLWrFkTeXl5kZaWtjlWpUqVqFGjRuTk5JRjZ8mzNZ2TMjIySnxsIrVq1SrV8WvXro3c3NxIT0/PF8/MzIyaNWvGmjVrSpW/MHXq1ElJ3pJYtGhRNGzYsEC8UaNG8d133yW9XlZWVqFzq6hcK6gsKuP6Km95eXkxZ86cmDNnTrz11lv5xtLS0qJ169bRs2fPOOOMM2LXXXdNmOPvf/973HPPPbFkyZKE44nuHSIi6tevn5wXsRWaN29ejB49Oo4++uh88cMOOyyaNm0ac+bMKXDMoEGDCsSee+65WLp0acr63JLCvvcV5d7R3AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgkfTybgAAAAAAAPiv+fPnxxVXXBFXXHFFvPbaa+XdTonstttu0b1794iI+Pzzz+PAAw+MxYsXl3NXAAAAAAAAUPHssMMOZZ570aJFKatZXM2bN49+/foViK9bty66d+8ed9xxR6xfv77UdRo0aFDqHBXJsGHDEsYHDx6cMD5gwIACsZUrV8azzz6bzLZKZN68eQnjjRo1SlnNwnIvWLAgZTUrEuuu7GxNazU3Nzd+/PHHAvFUXsfKQ2U7J23atClhvFatWqXq6X81bdq01DkSzZ+I1M2h6tWrp/T7VlxfffVVwnjnzp1TUm/vvfeO9PSS//q4awWVSWVbXxVdXl5ezJgxI2677bbYbbfd4sorr0y4X3Z2dpx66qmF5tm0aVMsXLiwQLxmzZpRvXr1pPW7tUl0/5iWlhaDBg0qED/00EOjWbNmRcpRlgq7b4yoGPeO5iYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiaSXdwMAAAAAAMB/LViwIIYOHRpDhw6N119/vbzbKZH33nsvLr744hg+fHjst99+MXfu3PJuCQAAAAAAACqkvffeOyV5GzduHDvssEOB+IYNG+Lbb79NSc2SOPLIIyM9veCvNt11113xwQcfJKVGenp6bL/99knJVVGMHDkyfvzxxwLxgQMHRlpaWoF4//79C8SefvrpWLNmTUr6K44vvvgiYbxLly4pq9m5c+eE8WnTpqWsZkVi3ZWdrWmtRkTMnj27QKxTp07l0EnqVLZz0tKlSxPGa9euXaqe/tcuu+xS6hwzZsxIGE/VvVCbNm0SrrPyMn369ITxrl27pqReaeesawWVSWVbX5VJXl5e/OMf/4i77ror4XiPHj1+9fjvv/8+YXz33XcvdW9bq5dffjnmz59fID5kyJACscGDBxeIzZw5M8aNG5eK1ool0X1jRMW5dzQ3AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPhf6eXdAAAAAAAAsHW5/vrrY+DAgbF69erybgUAAAAAAAAqrP322y8leffdd9+E8a+//jpyc3NTUrMkDjrooITxESNGJK1Gp06dokaNGknLVxFs3LgxHnnkkQLxJk2aRLdu3fLFunTpEi1btiyw74MPPpiy/opj6tSpCeNdu3ZNSb1ddtkltttuuwLxdevWxddff52SmhWNdVd2tqa1GhExadKkArFUXcfKS2U7Jy1dujRhfOeddy51b7908MEHlzrHV199lTCeqjmUjJ6T6a233koY79OnT2RkZCS9Xv/+/Ut1vGsFlUllW1+V0eWXXx4bN24sEN9nn31+9bjPP/88YbxLly5J6WtrlJubGw899FCBeMuWLfPdj2RlZcXxxx9fYL/77rsvpf0VVaL7xoiKc+9obgIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADwv9LLuwEAAAAAAAAAAAAAAADY1nTr1i2qVq2a9LxHHnlkwvh7772X9FqlseOOOyaMT58+PWk1unXrlrRcFcl9992XMD548OB82wMGDCiwz8yZM2PChAmpaKvYxo4dmzB+9NFHR0ZGRtLr/fa3v00YHzduXGzatCnp9Soi665sbS1rNSLigw8+KBAr7HpTWVW2c9KSJUsSxjt27FiatvLJzMyMI444otR53n333YTxXr16lTp3Isccc0xK8pbU2LFjIy8vr0C8cePG0adPn6TW2nfffWPPPfcsVQ7XCiqTyra+KqPFixfHpEmTCsRr1ar1q8+zH374YcL4IYcckqTOtk733Xdfwjk9ZMiQzV/37ds3srKy8o1v2LAhHn744VS3VySJ7hsjKs69o7kJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwP9KL+8GAAAAAAAAAAAAAAAAYFvTsGHDOOmkk5Kas0GDBtG/f/+EY6+++mpSa5VWvXr1EsbXrl2blPzp6enxxz/+MSm5KppZs2bF22+/XSDep0+fyM7OjoiIjIyMOPHEEwvs8+CDD6a6vSIbN25crF69ukC8adOmccIJJyS1VpUqVeLcc89NODZy5Mik1qrIrLuytbWs1YjE15Bdd901DjvssHLoJjUq2znpiy++SBhv1KhRtGrVqsS9/dLxxx8fDRs2LHWesWPHJoy3bds2unfvXur8v9SiRYuk5yytRYsWxeuvv55w7IorroiqVasmrdZVV11V6hyuFVQmlW19pVqjRo1Sknf+/PkJ43Xr1i30mDFjxiSMH3vssUm5tmytZs+enXBOn3jiiVGzZs2IiBg8eHCB8ZEjR8bChQtT3V6RFPZ3DxXl3tHcBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+P/YudM4rcrzfuDXPCwurFIhiBtGEFtFA+ooiIILskiLtsGkLhGMCNh8oJrFIiAJjdRPsKKJETIisUgQBasVCZsbRKhBdqMECKiA7CCIDjMMzPxf5F+jzkNkZp55zgx8v++8r3Ou+3cez3XO4QUAAAAAAAAAAAAAAAAAAAAAAAAA8GWppAMAAAAAAAAAAAAAAADA0egHP/hB1KhRI2P97r777jj22GNLrX/66acxe/bsjO2TCXv37k273rhx44z0/+d//uc488wzM9KrKnr88cdLrR1//PHRq1eviIjo3LlzNGnS5Av14uLimDBhQlbyHY79+/fHM888k7Y2ZMiQqFWrVsb2uuOOO6JZs2al1gsLC2PKlCkZ26eqM3fZdyTMakTE5s2b064PHjw4o/vccccdcf7552e05+Gqbs+k1atXx86dO9PWevfuXZF4ERFRs2bN+PGPf1zhPhERW7dujQULFqSt3XvvvRnZ4//8+7//e+Tk5GS0Zyb84he/SLt+zjnnxP3335+RPe644464+uqrK9zHu4LqpjrNV2U55ZRTYsyYMfHBBx9Ez549M96/du3aadf37dt3yHPWrVsXb7/9dtpeffv2zVi2iIgGDRpE06ZNM9ozSXl5eaXW6tatG//0T/8UZ5xxRlx++eWHdU5SNm/eHPPnz09bqwrfju5NAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAL4slXQAAAAAAAAAAAAAAAAAOBq1bt06Ro0alZFeHTt2jB/96Edpa0899VTs3bs3I/tkyo4dO9Kut2vXrsK9Tz755Bg9enSF+1Rlzz33XOzatavUeu/evSMi4uabby5Vmz17dmzatKmyo5XJgw8+GCUlJaXWW7duHQ8//HBG9mjTpk08+OCDaWsTJkyIbdu2ZWSf6sDcZd+RMquHctVVV8WgQYMy0uvCCy+MMWPGxLJly2LatGmRm5ubkb5lUd2eSQsWLEi73rdv32jYsGF54n3m3nvvjbPPPrtCPT7vl7/8Zdr1K664Ir7//e9nZI+uXbvGjTfemJFemfbSSy/FihUr0tbuvvvuuP322yvUv3Pnzhm7R70rqG6q03xl2imnnBKPPfZYrF27Nvr37x+1a9eOn//859GoUaOM7tOiRYtSa/n5+V/5Z8zHH3887fqQIUOiZcuWGckWETF69OhYtWpVDBw4MFKp6v/PZ7zwwgtpvwf69OkTt956a+Tk5Hxh/YMPPog5c+ZkK95hGTt2bNr1qvLt6N4EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4PNSSQcAAAAAAAAAAAAAAACAo9Vdd90Vffv2rVCPv/3bv43JkydHjRo1StUOHDgQDz/8cIX6V4bVq1enXe/Xr1+F+h5//PExderUaNy4cYX6VHWFhYUxceLEUuuXXXZZnHvuuXHdddeVqo0fPz4Lycpm5cqV8eyzz6at3XnnnXHXXXdVqH/Lli3j+eefj2OPPbZUraCgIB544IEK9a9uzF32HSmzGhGxZs2atOujRo2K7t27V6h306ZNY8qUKZFK/fmvvPbo0SN+//vfx5w5c6JJkyYV6l0W1e2ZdKisTZo0idGjR5crY0REz549Y/jw4eU+P50pU6bE+vXr09YeeOCB+Pu///sK9f+7v/u7mDRpUoV6VKaSkpIYOHBg2loqlYrHH388hgwZ8tkMlMW3v/3tmDZtWhx33HEVjRkR3hVUP9VpvjJt7NixMWDAgKhdu/Zna6eddlpMmTIlY5lzc3OjRYsWpdY3btz4lec+8cQTsX379lLrxx9/fPzmN7+JOnXqVDjf7bffHn369In69evHI488EkuWLIl27dpVuG+SDhw4EP/1X/9Var1Tp04xYMCAUuvjxo2LkpKSbEQ7bE8//XSV/nZ0bwIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADweamkAwAAAAAAAAAAAAAAAMDRZNOmTV/477y8vHjooYeiRo0aZe517bXXxptvvhlNmzZNW3/00Udj1apV5cpZmWbNmpV2vXPnzvHd7363XD2bNWsWb7zxRlxyySWfrS1ZsqRcvaqDvLy8Ums5OTkxadKkqFOnzhfWP/roo/if//mfbEUrk0GDBsWePXvS1h566KEYO3Zs1K5du8x9O3fuHAsXLozTTz89bf0nP/lJrFu3rsx9qzNzl4wjZVa///3vp12vVatWvPjiizFo0KBy9T377LNj3rx50bx581K1pk2bxvbt28vVt7yq0zNp8uTJpb4p/k/v3r1j5MiRZc7Zt2/fmDp1aqRSf/nrx6tXry5zny8rKiqKu+++O22tZs2a8cILL8QPf/jDcvW+6qqr4ne/+12ccMIJn619+OGH5epVmebOnRtjx449ZP2nP/1pLF++PLp37/6F3/9Q2rZtG7Nnz46nn346jjnmmM/WN2/eHJ988km5c3pXUB1Vl/nKtGHDhkVJSUmp9SuvvDJeeeWVOPXUUyvUv2HDhvHEE0+krc2YMeMrz8/Pz4/hw4enrV100UUxb968aNKkSbnzDRw4MH71q199Ye3888+P+fPnR5cuXcrdtyp4/PHHS63l5OSU+r0OHjwY48ePz1asw3bw4MEq/e3o3gQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADg81JJBwAAAAAAAAAAAAAAAICjya9+9av405/+9IW1u+66K95999345je/GTk5OV/Zo3Xr1vHiiy/GSy+9FPXr1097zPvvvx/33XdfRjJn2u9+97vYsWNH2lpeXl4MGzYsataseVi9ateuHQMHDozly5dHmzZtPlvfvXt3lb3+THjnnXfizTffLLXeunXrUmuTJk2K/fv3ZyNWmW3dujX69+9/yHq/fv1i9erVcfPNNx/WPXHOOefE888/H7Nnz46GDRumPeaNN96IUaNGlTdytWXuknGkzOq0adPiySefTFurUaNGPPzww7Fo0aK45pprDqtf3bp1Y+jQobF48eJo2bJlqXpJSUn867/+a5SUlFQkdplVp2fSgQMHYvTo0YesDx48OKZPn5729/2ytm3bxowZMyIvL+8L1/XWW2/FCy+8UOZs6Tz33HPx0ksvpa2lUqn42c9+FkuWLIkuXbocVr+zzz47JkyYEHPmzIlGjRp9tl5QUBBDhw7NSOZMGzhwYPz+978/ZP3cc8+N6dOnx44dO+I3v/lNDB06NPr27Rvf/OY349Zbb4177rknxowZE++9914sXrw4OnfuXKpH//79o6CgoNwZvSuorqrDfGXa0qVLY8yYMWlr7dq1i3fffTeGDRsWJ554Ypl7d+nSJRYuXBjnnntu2vqUKVMOq8+YMWNi7ty5aWtt27aNP/zhD3HnnXce9nMl4s/fUDNmzIhHHnkkUqnS/1zGW2+9FXPmzDnsflXRmjVrDvm7fd6MGTNi06ZNWUhUdlX929G9CQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMD/qZl0AAAAAAAAAAAAAAAAADiaFBQUxC233BJz586N2rVrf7Z+1llnxZQpU2LHjh0xc+bMWLx4cWzZsiU++uijqFevXnzta1+Lli1bRteuXaNVq1Z/dY99+/bFddddF3v37q3syymXwsLCuP/++2P06NGlaqlUKkaMGBH9+/ePp556KubNmxerVq2K3bt3R0FBQTRo0CCaNGkSLVq0iC5dusS1114bJ5100hd6lJSUxK233hrbt2/P1iUlIi8vLy655JKvPG78+PFZSFN+kydPjnPPPTeGDBmStn766afHU089FY8++mjMmjUrFi5cGFu2bImdO3dGnTp1PpuNbt26feVsrFu3Lq677ro4ePBgZVxKlWbuknOkzGr//v3jrLPOivbt26etX3DBBTFr1qzYvn17zJ49O5YuXRrbtm2LnTt3RkREgwYN4owzzojc3Ny45ppr4rjjjjvkXv/xH/8Rr7zySqVcx1epTs+k0aNHR8+ePaNDhw5p6927d4+uXbvGm2++GbNmzYr169fH9u3bIycnJxo1ahStW7eOzp07x/nnn1/q3MLCwrjtttvipptuKle2dG6++eZYtGhRtGjRIm29TZs2MXPmzNiyZUvMmDEjVqxYEVu3bo2PPvoojjnmmGjUqFGce+65ccUVV0SbNm3S9hg0aFCsW7cuY5kzqaioKLp27Rpz5syJCy+88JDHnXDCCXHjjTeWuf9Pf/rTePHFFysS0buCaqs6zFdluOuuuyI3NzftNdetWzdGjBgRw4YNiwULFsTrr78eK1eujPfffz/27t0b+fn5kZOTE3Xq1ImGDRvGmWeeGW3atInu3btHy5YtD7nntGnTYv78+Yed8YYbboi33norTjvttFK1xo0bxy9/+cu47777YsaMGfHyyy/Hhg0bYtu2bZGfnx+1a9eOevXqxWmnnRbnnXdedO/e/a9+U23evDl69eoVxcXFh52vqsrLy4uOHTt+5TFVWVX/dnRvAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABARUTPpAAAAAAAAAAAAAAAAAHC0efPNN6N///7xxBNPRE5OzhdqJ554Ytx8881x8803l6v3vn374h//8R9j+fLlmYhaaR577LH4zne+E23atElbb9asWdxzzz1xzz33lLn3PffcEy+++GLk5uZWNGaV9swzz8TDDz8c9evXP+Qxb7/9dixZsiSLqcpn6NChkZOTE/fee+8hj2nQoEHccMMNccMNN5Rrj3fffTe6du0aO3fuLG/Mas/cJeNImdXCwsLo3r17TJ8+PS699NJDHte4ceO46aab4qabbirXPuPGjYuhQ4eWN2ZGVJdn0sGDB+Nb3/pWLFu2LBo3bpz2mFQqFe3bt4/27dsfdt+SkpLo379//OEPfyh3tnT27NkTXbt2jVdeeSVOP/30Qx7XtGnT6NOnT5n7//znP4+8vLy4/PLLKxKzUu3evTuuuuqqmDBhQvTs2TNjfR988MEYNmxYRnp5V1BdVYf5yrT9+/dHt27dYtasWdG2bdu0x9SqVSs6duwYHTt2rPB+O3bsiAEDBpTpnG3btsXVV18dr776apxyyilpj/na174WvXv3jt69e5c729atW6NLly6xfv36cveoSp577rn4xS9+EY0aNUpb37RpU0yfPj3Lqcqmqn87ujcBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiIhIJR0AAAAAAAAAAAAAAAAAjka//vWvo3fv3lFUVJSxnlu3bo1rrrkmZs6cmbGelWX//v3RrVu3eO+99zLWs6ioKPr16xejRo3KWM+qLD8/P55++um/esz48eOzlKbihgwZErfffnt8+umnGe89ffr0uPTSS2PDhg0Z712dmLtkHEmzumfPnrj66qsrJW9xcXGMHDky+vbtGyUlJRnvX1bV5Zm0adOmuOyyy2Lt2rUZSPbn/w/f+9734sknn8xIvy9bu3ZtXHrppbFkyZKM9n3ggQdi0KBBGe1ZWT7++OO47rrrol+/frFz584K9dq5c2fcdNNN8cMf/jBD6bwrqN6q+nxVhh07dkSnTp3ihRdeqNR9Nm7cGB06dIgPP/ywzOeuWbMm2rVrFwsXLqyEZBFLliyJCy+8MN5+++1K6Z+EwsLCmDhx4iHrv/71r6O4uDiLicqnqn87ujcBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASCUdAAAAAAAAAAAAAAAAAI5WEyZMiPbt28eaNWsq3GvKlClxzjnnxBtvvJGBZNmxdevWuPjii2P69OkV7rVixYrIzc2NvLy8DCSrPv7a9RYVFcXEiROzmKbinnjiiWjdunXMnDkzI/02b94ct9xyS/To0SN2796dkZ7VnblLxpE0qwUFBfHd7343/uEf/iHWrVuXkZ5r166Nzp07x5AhQzLSL1OqyzNp1apVkZubGzNmzKhQn+3bt0fXrl3jsccey1Cy9D788MO4+OKLY8SIEVFYWFihXjt27IiePXvG4MGDM5Que/Ly8qJ58+YxZMiQWLt2bZnO3bZtW4wYMSJatWoVkyZNyng27wqqu6o8X5Vh7969cf3110evXr1i/fr1Ge1dUlISEydOjIsuuihWrVpV7j4bN26MDh06xJAhQyI/Pz8j2fLz8+Oee+6J3Nzc2LhxY0Z6ViWHem6WlJTEuHHjspym/Kr6t6N7EwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAODolko6AAAAAAAAAAAAAAAAABzNFi1aFOecc04MGDAg1q1bV6ZzCwoKYsqUKdG2bdu44YYbYufOnZWUsvJs3749evToEb169Yo33nijzOcvWbIkvv3tb8c3vvGNWLZsWeYDVnFLliyJpUuXpq1Nnz49duzYkeVEFffee+9Ft27d4qKLLopnn3028vPzy9xj2bJl0a9fv2jevHlMnDixElJWb+Yu+47EWZ02bVq0atUqbrrpppg/f36UlJSUucfy5cujX79+0apVq3j11VcrIWXFVZdn0q5du6J79+5x5ZVXxv/+7/+W6dzdu3fHqFGjokWLFjFnzpxKyfdlBw4ciOHDh0fz5s3jP//zP2P79u1lOn/btm0xYsSI+PrXvx4vvvhiJaWsfJ988kmMHDkyWrRoEW3bto3vfe97MX78+Hj55ZfjrbfeipUrV8bSpUtj3rx58dRTT8XgwYOjXbt2cdJJJ8Xw4cPTfvsdc8wxafc6cOBAmbJ5V1DdVeX5qixTp06NM844I3r16hUvv/xyFBYWlrvXRx99FOPHj4+LL744brnlltiyZUuF8xUVFcXIkSPjjDPOiPvvvz82btxYrj4bNmyI++67L0499dT42c9+FgcPHqxwtqronXfeiTfffLPU+pw5c+L999/PfqAKqsrfju5NAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgKNXzaQDAAAAAAAAAAAAAAAAQKbk5ORUyz5FRUUxduzYGDt2bFxwwQXRuXPn+MY3vhFnnnlmNGjQIOrWrRsFBQWxZ8+e2LJlS6xYsSIWLlwYM2fOjE8//TQjWcuTO5OmTp0aU6dOjVatWkWHDh2iXbt20aJFi2jYsGGccMIJUatWrdi7d2/s3r07Vq5cGUuXLo3p06fHn/70p0P2XLhwYUauJYnfoyx27dqVdn38+PFZTpJZixYtim9961tx7LHHRufOnSM3NzfOO++8OPnkkz+bi8LCwtizZ0/s2rUr3nnnnVi+fHnMnj07Pvjgg6xkHDFiRIwYMSIre1UGc/dnffr0iT59+lT6PkfirB44cCAmTZoUkyZNiqZNm0anTp3ikksuiRYtWsSpp54adevWjeOOOy6Ki4tjz549sXv37vjjH/8YS5YsiVdffTVWrlyZkRzZuF+qwzMpIuK1116L9u3bx6mnnhpdunSJTp06RbNmzaJx48bRqFGjOHDgQOzevTu2bdsWS5cujfnz58eMGTNi//79afsNHjw4Bg8eXGl5t2zZEj/4wQ/iRz/6UVx++eXRoUOHOP/886N58+af/a75+fnx8ccfx4YNG2LZsmUxb968eO2116K4uDhtz3nz5lX5d3c6S5cujaVLl1aoRyqVinr16qWt7du3r1w9j+Z3Rbdu3Sq1f0TEQw89FA899FCF+1S1Pwcdjmy9fyOq7nxVhuLi4s/m9vjjj4+OHTvGeeedF2effXaceeaZUa9evahbt27UqVMnSkpK4pNPPom9e/fGxx9/HGvXro0VK1bEihUrYv78+XHgwIFKybht27YYOnRoDB06NC688MLo0KFDXHDBBXH66adHkyZNok6dOlGzZs3Yv39/fPzxx7F79+5YtWpVvPPOO/HKK6/EihUrMpalqr8v2rVrl9X9Kvv3qCrfjodSle5NAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALKjZtIBAAAAAAAAAAAAAAAAgL9YvHhxLF68OOkYiVm1alWsWrUqnnjiiaSjVAsnn3xyXHHFFaXWt27dGr/97W8TSJR5BQUFMW3atJg2bVrSUY5Y5q7yHQ2zumXLlpg8eXJMnjw56SiVqro8kzZs2BDjxo2LcePGJR3lsBQXF8frr78er7/+etJRqrX69esfsrZr164K9fau4GhXmfNVWfLz82PGjBkxY8aMpKMc0qJFi2LRokVJxyABVf3b0b0JAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcHRIJR0AAAAAAAAAAAAAAAAAgPL5zne+E6lU6b8mNnHixDh48GACiYB0zCqQDa1atUq7XlRUFFu3bs1yGjiymC8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgCNPzaQDAAAAAADAkax27dox4M4BScfgCLfqj6ti5syZSccAAAAAAAAAsiwnJyfuuOOOtLW8vLwspwEOxawC2ZKbm5t2/Y9//GOWk8CRx3wBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABx5aiYdAAAAAAAAjmSpVCpOOeWUpGNwhNu+bXvSEQAAAAAAAIAE9OjRI5o3b15qfd68ebF69ersBwLSMqtAtlx99dVp1xcvXpzlJHDkMV8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEeeVNIBAAAAAAAAAAAAAAAAACi74cOHp11/5JFHspwE+GvMKvBlderUyXjPk08+Oa699tq0tVmzZmV8P6iqzBcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIcrlXQAAAAAAAAAAAAAAAAAAMrmlltuiQsuuKDU+rp16+L5559PIBGQjlkFPi+VSsV9990Xa9asiSZNmmS097/9279FjRo1Sq0XFBTEzJkzM7oXVEXmCwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAskolHQAAAAAAAAAAAAAAAACAw9eiRYt45JFH0tZGjBgRJSUlWU4EpGNWgc879dRTY+7cufGTn/wkTjrppPjv//7vOPbYYzPS+6qrrop/+Zd/SVt75plnYvfu3RnZB6oq8wUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQHmkkg4AAAAAAAAAAAAAAAAAwOHJzc2NV155JU444YRStZUrV8ZTTz2VQCrgy8wq8HnXX399rFixIjp06PDZ2qWXXhqzZ8+OE088sUK9r7zyynjuueciJyenVO3AgQNx//33V6g/VHXmCwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA8kolHQAAAAAAAAAAAAAAAACAv8jJyYnatWvHMcccE40aNYqzzz47brzxxnj++edjwYIFcdppp6U9b8CAAVFcXJzltHD0MqvA4TrrrLOiYcOGpdYvu+yyeOedd6JPnz5Rq1atMvVs1KhRjBw5MmbOnBkNGjRIe8wjjzwSa9asKU9kqDbMFwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5VUz6QAAAAAAAAAAAAAAAAAA/EWvXr3imWeeKdM5jz76aMydO7eSEgHpmFXgcD344INx/fXXx8UXX1yq1qRJkxg/fnw88MAD8dJLL8W8efNi9erVsXHjxvj000+jsLAwatasGY0aNYq/+Zu/iTZt2sSVV14Z1157bdSrV++Qey5dujTuvffeyrwsqBLMFwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5VUz6QAAAAAAAAAAAAAAAAAAlN9rr70Wd999d9IxgK9gVuHodfDgwejRo0csWLAgWrZsmfaYJk2axG233Ra33XZbhfdbt25ddO/ePfbv31/hXlDVmS8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMorlXQAAAAAAAAAAAAAAAAAAMrnt7/9bfTo0SOKioqSjgL8FWYV2LFjR1x++eWxYMGCSt1n0aJF0b59+9iyZUul7gNVifkCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKA8UkkHAAAAAAAAAAAAAAAAAKBstm7dGgMGDIhrr7028vPzk44DHIJZBT5vy5Yt0alTpxg+fHjGnwmFhYUxcuTIaNeuXWzdujWjvaE6MF8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJRVzaQDAAAAAAAAAAAAAAAAAJBecXFx7Nu3L3bt2hXvv/9+LF68OF5++eWYNWtWHDhwIOl4wP9nVoHDVVRUFCNGjIhx48bFnXfeGX369IlmzZqVu9+ePXviySefjIceeijWr1+fwaRQ/ZgvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADKombSAQAAAAAAAAAAAAAAAAD4i2effTaeffbZpGMAX8GsAhWxadOmGDp0aNx3333Rtm3b6NSpU1x00UXx9a9/PZo3bx7169eP2rVrf+Gcffv2xYcffhhr166NxYsXx2uvvRZz586NoqKihK4CqibzBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADA4aiZdAAAAAAAAAAAAAAAAAAAAICjUXFxcSxatCgWLVpUqlajRo045phjoqSkJAoKCqKkpCSBhFB9mS8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP6amkkHAAAAAAAAAAAAAAAAAAAA4IsOHjwY+fn5SceAI5L5AgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAglXQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyJZU0gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgW1JJBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBsSSUdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALIllXQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyJZU0gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgW1JJBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBsSSUdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALIllXQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyJZU0gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgW1JJBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBsSSUdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALIllXQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyJZU0gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgW1JJBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBsSSUdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALIllXQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyJZU0gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgW1JJBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBsSSUdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALIllXQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyJZU0gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgW1JJBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBsSSUdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALIllXQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyJZU0gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgW1JJBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBsSSUdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALIllXQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyJZU0gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgW1JJBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBsSSUdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALIllXQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyJZU0gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgW1JJBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBsSSUdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALIllXQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyJZU0gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgW1JJBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBsSSUdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALIllXQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyJZU0gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgW1JJBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBsSSUdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALIllXQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyJZU0gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgW1JJBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBsSSUdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALIllXQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyJZU0gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgW1JJBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBsSSUdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALIllXQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyJZU0gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgW1JJBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBsSSUdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALIllXQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyJZU0gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgW1JJBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBsSSUdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALIllXQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyJZU0gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgW1JJBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBsSSUdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALIllXQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyJZU0gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgW1JJBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBsSSUdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALIllXQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyJZU0gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+H/s3XeUVeX1MOA9Awy9KoiIYkOxQUAFC3ZUUBDsNbaooLF8lmhiiYldUyQmaqIYWzQKFgREARsqxq6goIKKDRHpvc98f7jkJ94zMOXeuffOPM9aWWH2e85+9zmct9zDzAgAQFWpne0CAAAAAAAAAAAAAAAAAIDMu/3222P77bdPiZ999tnx8ccfZ6Ei8smLL76YGN9vv/2quBIAACCX+ewAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5Iva2S4AAAAAAAAAAAAAAAAAAMi8Ll26xG677ZYSb9KkSRaqqVmKiooS4ytWrKjiSipu3333zXYJeW+rrbaK9u3bR9OmTaNp06bRuHHjKCwsjEWLFsWCBQti/vz58fXXX8ekSZNi5cqV2S4XAPJCddhn5Rr3lMry2SFzjE8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABIr9rZLgAAAAAAAAAAAAAAAADS6fzzz49mzZpVOk9JSUksWrQo5s+fH/PmzYt58+bFRx99FNOnT698kQDUGNtss0188skniW3bbrttTJ48uYoroqrsuOOOcdxxx8W+++4bnTp1ikaNGpXpvJUrV8akSZPi9ddfj8GDB8dLL70UxcXFGa4W0ufCCy+Mxo0brxX75JNP4tFHH63SOkr7XPDYY4/FpEmTqrQWIDPss9LPPYXcZXwCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABA+tXOdgEAAAAAAAAAAAAAAACQThdeeGFsvvnmGcs/ffr0ePvtt2PcuHHx0EMPxTfffJOxvgCA/FK7du0488wz4/zzz48OHTpUKEedOnWiU6dO0alTp+jfv398//33cf/998fNN98cs2fPTnPFkF5dunSJv/71rynxhQsXxogRI2Lx4sVVVktpnws+/vjjmDRpUpXVAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5KbCbBcAAAAAAAAAAAAAAAAA+WTjjTeOPn36xE033RRffvlljBw5Mg477LBslwUAZNlJJ50UU6ZMiTvuuCM6dOiQtrytWrWK3/zmNzF16tT4wx/+EPXr109bbki3/v37J8YbN24cxx9/fBVXAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAULra2S4AAAAAAAAAAAAAAAAA8lVhYWH06tUrevXqFaNGjYqzzjorvvrqq2yXVS3tueeeceWVV6bEX3nllbjhhhuyUBFAdpkXc0fz5s3j3nvvjb59+2a0n8aNG8fVV18dRx99dBx77LHx4YcfZrQ/KK9GjRrFCSecUGr72WefHYMGDarCivKD+ZzqxPMMucnYBACAzLHfBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMhvtbNdAAAAAAAAAAAAAAAAAFQHBx98cEycODHOPffcuP/++7NdTrWz0UYbRc+ePVPiixYtykI1ANlnXswNXbp0iaeeeiratm1bZX1uv/328dZbb0X//v3jgQceqLJ+YX1OOOGEaNSoUantXbp0iZ133jneeeedKqwq95nPqU48z5CbjE0AAMgc+20AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA/FY72wUAAAAAAAAAAAAAAABAVfjmm29i3rx5ZT6+sLAwGjZsGE2aNImmTZtGYWHhes9p1KhR3HfffdGqVav405/+VIlqAYBc17Vr1xg9enQ0bdp0ncetXr06Xn311Rg7dmyMHz8+Pv/885g7d24sWbIkiouLo379+tGkSZPYbLPNYrvttovu3btHjx49okmTJqXmrFevXtx3331Rv379+Ne//pXuS4MKGTBgQJmOOfPMM6ugGgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgHWrne0CAAAAAAAAAAAAAAAAoCpcfPHFMXjw4AqdW1RUFDvssEP84he/iMMOOywOOeSQKCoqKvX4W265JaZNmxYPP/xwRcsFoJpYtmxZvP3226W2kZ+6dOkSY8aMiSZNmpR6zIwZM+Ivf/lL3HfffTFz5sz15pw0aVI8++yzceutt0bdunWjb9++8dvf/jY6d+6ceHxBQUHceeedUVxcHHfffXeFrwXSYZdddin1Wf2p448/Pi666KJYuHBhFVQFVHf2WennnkLuMj4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAg/WpnuwAAAAAAAAAAAAAAAADIdStWrIj33nsv3nvvvbj33nujWbNm8Zvf/CYuueSSKCoqSjznX//6V7z66qvx1VdfVXG1AOSSr776Knbddddsl0EaNW/ePJ544olo0qRJYntxcXHceuutcdVVV8XSpUsr1Mfy5ctj8ODBMXjw4DjppJPib3/7W7Ro0SLluIKCgrj99ttj/Pjx8eabb1aoL0iH/v37l+m4hg0bxoknnhj//Oc/M1wRUBPYZ6Wfewq5y/gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA9CvMdgEAAAAAAAAAAAAAAACQb+bNmxdXXHFF7LTTTjF16tTEYxo1ahS33HJLFVcGAGTaAw88EO3atUtsmz9/fhx88MFxySWXxNKlS9PS33/+85/o1KlTTJgwIbG9Tp06MWTIkGjevHla+oPyaty4cRx//PEp8a+//jrx+LPPPjvTJQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKxXYbYLAAAAAAAAAAAAAAAAgHw1efLk2GuvveKLL75IbD/mmGNi6623rtqiAICMOeGEE6J3796JbfPnz4999tknnnvuubT3+80330T37t3j3XffTWzfbLPN4uabb057v1AWJ554YjRs2DAlfskll8THH3+cEu/YsWN07dq1KkoDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoVWG2CwAAAAAAAAAAAAAAAIB8Nm3atOjfv39iW0FBQZx88slVXBEAkAl169aNG2+8MbFt9erVcdhhh8X48eMz1v/ChQvj4IMPjq+//jqx/fTTT48ddtghY/1DaQYMGJASmzNnTgwdOjTuueeexHPOPvvsTJcFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwToXZLgAAAAAAAAAAAAAAAADy3ejRo+O5555LbOvVq1cVVwMAZMJ5550Xm222WWLb1VdfHS+//HLGa5g1a1Ycf/zxUVxcnNJWq1atuOWWWzJeA/zUrrvuGp06dUqJ/+c//4kVK1bE/fffHytXrkxpP/bYY6Np06ZVUSIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECiwmwXAAAAAAAAAAAAAAAAANXB4MGDE+OdO3eOevXqVXE1AEA6FRQUxPnnn5/YNmnSpLjpppuqrJZx48bFoEGDEtt69eoVW2+9dZXVAgMGDEiM//iMzpw5M0aMGJHSXr9+/fjlL3+Z0doAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADWpTDbBQAAAAAAAAAAAAAAAEB1MGbMmMR4rVq1YosttkhbP/Xr148WLVpEs2bNoqCgIG15yYy6detGixYtol69etkuJVHjxo2jefPmUadOnWyXklNy/b78+FzVr18/26VAueT6nLguPXv2jE033TSx7bLLLovVq1dXaT1XXHFFLF26NCVeUFAQZ5xxRpXW8qOioqJo0aJFNGjQICv9l0euz/M/l6tjp0mTJnHcccelxN9666344IMP1nw9aNCgxPMHDBiQsdrIjB+fxUaNGmW7lCqVr9edT/NydfDjZ/VMzdW1a9eO5s2b+wxQxfJtz1Cd5Or+5+c8I/kjX9fziPxZ0/NtPOTLPJMttWrVimbNmuX032k+j2vWVqdOnWjevHk0bdo05/7dK9/mtsqqDv/2kC/rZk2T63N2rq57uVoXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVDe1s10AAAAAAAAAAAAAAAAAVAfTpk0rta1Nmzbx0UcflStfnTp1Yr/99ouePXtGx44dY4cddoiWLVtGrVq11hxTUlIS8+bNizlz5sT48eNj7NixMXbs2Bg/fnyFryPJ9ttvnxKbMWNGzJ49u9Rz6tatGx07doytt946mjZtGo0bN46CgoI17bfddlssW7ZszdcbbrhhtGrVqtR8m222WWK8adOmifWty4oVK+LTTz9d73Hlve4WLVrE0UcfHfvvv3907tw52rVrF0VFRWvalyxZEjNnzoyPPvooxowZE6NHj44PP/ywXLVXVN26dePggw+Ogw8+ODp16hTbbbddNG/efK2/kxUrVsSXX34ZH374Ybz22msxdOjQMt2n8qiKZ6k8cuW+rMsmm2wShx9+eOy9997RqVOn2Hzzzdd6rlatWhVffPFFTJgwIUaPHh1Dhw6NGTNmVFl95dW+ffuoU6dOSnz69Okxd+7cSudv3LhxbLrppinxjz76KEpKSiqdf4sttoj69eunxKdMmRIrV64s9bzS5qlJkyaVek4uzovl0bx58+jbt2/06tUrOnbsGFtttdVaf/fZnBMr4owzzkiMT5o0KUaMGFHF1UTMmjUr7r333jjnnHNS2k499dS4/PLLo7i4uMz5yjs/N2/ePA4//PA48MADo1OnTrHllltG3bp117SvXr06vvvuu5gwYUK89dZb8eSTT8b7779f5nrSJRfm+eq0n/i5k046KRo0aJASHzRo0FpfP/vsszFt2rTYZJNN1orvsMMOsccee8Rrr72W0TqzLV/n8x133DH69u0bXbt2jY4dO8Ymm2yy1jxeUlISc+fOjYkTJ67Zh4wePbrC+7JckSvXnavzci4+zxXZZ5U1z7ru+f777x/HHnts7L777rHtttum7NG/+uqreP/99+OFF16IIUOGxPfff1+uejp37hwnnHBC7LHHHrHTTjtF48aN17T9uBZMmDAhnnnmmRg5cmR8+eWX5cq/LpW5p5tuuulatWba999/H7Nmzap0nlzYM1RGLo7N8siHzw658oxka87L5LuZTMiV9Twid9f0ysiF8VCdP2dlQ9euXeOAAw6Irl27xi9+8YvYcMMNo1GjRmsds2LFipg2bVp8+OGH8d5778WIESPirbfeqtI6fz62N9988zVtVTGuW7VqFRtuuGFKfH3vt8uroKAgtttuu5R4cXFxfPzxx+XKlWvv4yMifvGLX0Tv3r1jl112iZ122ik22WSTtea5kpKSWLBgQUyaNCneeeedGDlyZIwePTpWr15d4T7LIhfmtqrWpk2bOOqoo6J79+7RuXPn2GyzzdaaG1evXh3ffvttTJw4MV577bUYNmxYqf/+WLt27WjRokVKfM6cObFq1aoy15Sr62ZV7bczsdfOhlzaiyXJ1XUvV+sCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAmqCgpKSkpEwHFhRkuhYgT3Xs2DE6duwYERElJSXx+eefx+uvvx5lnF4AckLr1q3j4ksuznYZ1AAjnx4ZL774YrbLAKi0Zs2axRVXXpHtMqjmXnjhhXhm5DPZLgOg0urVqxfXXndttsugmnvv3ffi4YcfznYZAGnxpz//KdslUAN8NOmj+Pe//53tMgDS4oLHI+o2zHYVVGfffBjx8CXZrgKA0hQUFMQuu+wS22yzzZrv954wYUJMmDAhy5XVTL6nFnLL1KlTY/PNN0+JH3vssTF48OCM9j137txo1qxZSrxv374xbNiwMuVo3bp1XHLJJXHmmWdGkyZNKlTHW2+9FTfeeGMMHTo0LXNRUo7LLrssbrnllrVihYWFcfTRR8eZZ54Z++yzT9SuXbvUnBtssEHMmTNnzde///3v449//GOlay2LV155Jfbee+/1HlfW627Tpk1cc801cfLJJ0edOnXKVct+++0XL730UrnOKY9NN900fve738Uvf/nLaNSoUbnPf+utt+KGG26IoUOHpqWeqniWyiLX7kuSvfbaK6666qro0aNHuX6+b9WqVfGf//wn/vjHP8YXX3yxVtv//ve/2G233VLO6datW7z55puVLblMnnzyyejXr19K/J577okzzjij0vlLm0v22GOP+N///lep3LVr145Zs2ZF06ZN14rPnTs3WrVqFatWrSr13NLm4nX93ebavFjWa2jVqlVceeWVcdZZZ0XdunXLXcfvf//7jM6LFVG7du2YO3du4nzx//7f/4u//e1vWagqolOnTvH+++8ntpV3XJd1fm7btm1cddVVcdppp5V7zfv444/jhhtuiIceeiiKi4vLdW555dI8XxX7iWyNnfHjx6/5LPyjJUuWROvWrWPhwoVrxa+//vq4/PLLU3I8+OCDcfLJJ2ekvmx+LvipXJvP16VOnTpxyimnxCWXXBLbbrttuc9fvHhx/Oc//4mbb745pk6dWuE6qlouXneuzsu5+DxXZJ9V1jxJ9/zggw+OgQMHRocOHcqce/Xq1fHAAw/EVVddFdOmTVvnsbvttlsMHDgwunXrVub8xcXF8fDDD8eVV14ZX375ZZnPK01l7unw4cOjd+/ela6hrK6++uq45pprKnx+Lu0ZKiPXxmZ1+uyQa89IVc55mX43k265uJ5H5O6aXhG5NB6q8+esqlKnTp0YMGBADBgwILbffvsK5fjmm2/itttui3/961+xYMGCNFf4g8qM7XSP6xtvvDF++9vfpsSTnr3KaNCgQSxevDglvmjRomjcuHG5cuXK+/gGDRrEmWeeGRdccEFsscUW5To3ImLmzJkxcODAuPXWW2Pp0qXlPn9dcmluqypdu3aNa6+9Ng488MBy7yHefvvtuPbaa1P+zXPvvfeOsWPHphxfXd5RVtV+u7LvdbIpV/diP60vF9e9XK0LIB8VFBTErrvuGu3bt/f9tECZVeb7Kv2udqA0fq4E0mu//faLQw49JNtlwDr5vakAldfrkF6x//77Z7sMKNUTjz9R6Z9JA6jpTjjhhOjcpXO2y4BS3XPPPfHxRx9nuwyAvHbRxRfFxhtvnO0yYJ3+8ue/xHfffZftMgDy2oAHIpq0ynYVULqBR0SsWJLtKoBs8bvac4vvqQUAAAAAAAAAAACoWn5XO1ARflc7kAl+rgTINX7fPdnid9gDNYn1lmyw1gI1if+uC9kw8umR8eKLL2a7DIAqYa0lW/y30YCa5MBzIzr3znYV1DSj/x7x/tPZrgKgavld7bnF99QCAAAAAAAAAAAAVC2/qx2oiLJ8j3dhFdQBAAAAAAAAAAAAAAAANcKyZcsS47Vr117vuQUFBXHJJZfE1KlT4+KLL44mTZpUuI5dd901nnjiiRg3blxsvPHGFc5THh06dIjXX389HnnkkTjggAPKdM3ZMnHixLTlOuGEE2Ly5Mnxq1/9KurUqVPu81988cV47LHHomHDhmmrKSKiTp06cf3118dnn30WZ599djRq1KhCeXbdddd48skn45VXXoktt9wyrTWWJpPPUj7cl5YtW8YTTzwRL7/8chx44IFrfrC4rGrXrh2nnnpqfPjhh3HOOeektbZ0GDx4cGK8T58+5b7WJIcddlip+Strn332iaZNm6bEhw4dGqtWrap0/mxK17x4+OGHx6RJk+K8886LunXrlvv8vfbaK2PzYmV069Ytcb4oKSkp9ZmuCuPHj49PPvkkse2AAw5Ie3+nnnpqfPTRR3HWWWdVaM3r0KFDPPDAA/H++++v+Y9fpVs+zPNJKrufyMbY6datW+Lf42OPPRYLFy5Mid9zzz2JP/x+9NFHR/PmzTNSY01Umfn8oIMOiilTpsTdd98d2267bYVyNGzYMPr37x9TpkyJv/71r1GvXr0K11NV8vm682Ferox0fm5Lh1q1asXf//73ePbZZ6NDhw7lPve0005b5zUVFhbGn//853jttdeiW7du5cpfWFgYJ510UkyePDlOPfXUcp1bU+XrniEX1JTPDjX9Gcmn93wR+b2eR+T+mp6v4yEfP2dVlT333DPef//9uO2222L77bevcJ62bdvGLbfcEl988UWccsopaazwB5Ud2/n4+SQbMj3nH3/88fHFF1/EwIEDY4sttqhQjpYtW8b1118fU6ZMif333z8tdeXr3FYZjRs3jv/85z/xxhtvxEEHHVSh9/G77LJLPPXUU/H4449HixYtMlDl+uX6ulkZufY5uKxyfS+Wq+tertYFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANVFhtgsAAAAAAAAAAAAAAACgfJq0itjpoIg9TojY5/SIXY+I2HzniFp1sl0ZBQUFFTqvSZMm8cILL8Sf/vSnqFevXtrq2X333ePdd9+Nbt26pS1nkm7dusX//ve/2HXXXTPaT7pMnDgxLXmuu+66eOihh6Jhw4aVynPkkUfG66+/Hptvvnla6mrbtm28+eabcfnll0edOumZGLp37x4TJkyIQw89NC35SpPJZykf7kvXrl3jww8/jMMPP7zSuRo2bBi333573HXXXVFYmDs/Sjh8+PBYtmxZSrxVq1ax2267VSp369ato0uXLoltvXv3rlTuiCj172Xw4MGVzp1t6ZgXL7300njiiSdigw02qHSudM+LlbX//vsnxj/88MOYPn16FVeztjFjxiTGe/TokdZ+Bg4cGPfee280atSo0rl22mmneOutt+LUU0+tfGE/kQ/zfJJ07SciqnbsDBgwIDF+9913J8Y///zzeOmll1Li9erVi1NOOSWdpdVoFZnPCwsL4/bbb49Ro0ZFu3bt0lJHrVq14sILL4wJEyZEhw4d0pIz3fL9uvNhXq6sdH1uS4fCwsJ4/PHH49xzz61UnqZNm8Zxxx2XEi8qKoqnn346Lr744gq/V/gxz7333htXXXVVZcqs9vJ1z5ArasJnB89I5M17vnxfzyNyf03P1/GQr5+zqsIpp5wSY8eOje233z5tOZs3bx733XdfPPHEE1G3bt1K50v32M6HzyfZksn38fXr14/HHnssHn744WjZsmVacm6yySYxZsyYuPTSSyuVJ1/ntsrYfvvtY/z48XHiiSemJd8RRxwR48aNi4033jgt+coq19fNysqlz8FlkQ97sVxd93K1LgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKipCrNdAAAAAAAAAAAAAAAAAGWzyfYRx/85YsADEb0uiuh+ckS3YyL2OyvimOsjzhscsfdpEUUNsl1pzdW0adPE+NKlS0s9p3nz5vHSSy/FvvvuW6Y+iouLY/HixbFq1aoyHd+6desYMWJEbLrppmU6vry23HLLePbZZ6NZs2YZyZ8JEydOrHSOK664Iq644oo0VPODHXfcMUaPHh2NGzeuVJ727dvHa6+9Fr/4xS/KdPyqVavW+Xz+VMOGDWPo0KFx7LHHVqLC0mXyWcqH+7LPPvvE888/H61atapUnp8788wz41//+ldac1bGokWLYtSoUYlt/fr1q1Tu3r17R0FBQWLbTjvtFJtttlml8h922GEpsXnz5sXzzz9fqby5oLLz4q9//eu4+eab01TND9I1L6bDzjvvnBh/+eWXq7iSVC+99FJivEuXLmnrY+DAgXHBBRekLV9ERFFRUfz73/+O888/Py358mGeT5Lu/URE1Yydpk2bJt6PKVOmxKuvvlrqeYMGDUqMDxgwIG211XTlnc/r1asXTz31VJxzzjkZqefHsbnnnntmJH9F5ft158O8nA7p+NyWLnfeeWf07ds3Lbnuv//+6Nat21qxRx55JHr27JmW/BER11xzTZx00klpy1ed5OueIZdU988OnpEf3s/kw3u+fF/PI3J/Tc/X8ZCvn7OqwmmnnRb33ntv1KpVq0zHL126NJYsWRIlJSVlOv7www+PUaNGRd26dStcYybHdq5+PsmWTL6Pb9GiRbz00ktx5JFHpj13YWFh3HzzzRUe5/k6t1VGp06dYuzYsbHFFlukNW+HDh3i+eefj4YNG6Y1b2lyfd1Mh1z6HLw++bAXy9V1L1frAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJqsdrYLAAAAAAAAAAAAAAAAYP32/GXEHidEFBSUfkxR/Yjdjo3Ybt+Ix6+OmPVFVVVHRETjxo2jXr16iW3z588v9byHHnooOnfuXGr7K6+8Eo899liMGzcuJk+eHAsXLlyrzy222CL23XffOPnkk2PnnXdOzLHhhhvG448/HnvuuWesXLmyjFe0frVq1YonnngimjVrVulc33zzTbz++uultm+wwQbRvn37lPicOXNi8uTJ5errww8/LHd9P9WjR4+45pprUuIlJSXx8ssvx9ChQ+Ptt9+OadOmxZIlS6JJkybRsmXL6Ny5cxxyyCFx8MEHR61atVLOb9++fdx///1xxBFHVKiuFi1axOjRo2PTTTct9ZgJEybEo48+GqNHj47PPvss5s6dGxERRUVFseGGG8Yuu+wSBx10UJx44omJf6+1a9eO+++/P7744ot44403KlRnknQ+Sz+XD/dlq622iqFDh0ajRo1KPWb58uXxwgsvxMiRI2PChAkxY8aMmDdvXtStWzc22GCD2GmnnaJHjx7Rt2/faNKkyVrnnnHGGTF+/Phy15Upjz76aPTt2zcl3q9fv7jssssqnPewww5bZ/uhhx4ad955Z4Vyd+7cOfEZeuqpp9I6r/5UvsyLu+22W/ztb39LiVd2Toyo/LyYLttss01i/P3336/aQhJMmDAhMd6sWbPYYIMNYvbs2ZXKf/LJJ8cFF1yQEl+xYkWMGjUqnnnmmXj//ffju+++iyVLlkTDhg1jo402ivbt20fPnj2jV69epc7tBQUFMXDgwPj8889jxIgRFa4xH+b5JJnaT0Rkfuz88pe/jPr166fEBw0atM7zHn/88bj99ttT7vG2224be++9d7z88svpLDNn5PJ8/uCDD0bv3r1LbS8uLo7//e9/MXz48Hjrrbfiu+++izlz5kSDBg1io402iq233joOOeSQ6NmzZ6ljvXnz5vH000/H7rvvHh999FG56suUfL7ubM/Lufw8Z8oRRxwRZ511Vkr8888/j/vvvz/Gjh0bX375ZSxbtixatGgRG2+8cey///5x1FFHJe4hioqK4p577olf/OIXsWrVqrj44ovj8MMPTzlu3rx58cgjj8TIkSPj448/joULF0ajRo1io402il122SUOP/zw2GeffUqt+4477ohx48bF1KlTK3cDyumbb76Jjz/+OK05t9xyyygqKkpsK8/15eueoSzyZWzm+meH6vyMlNWP72fyQT6v5xHZX9PXJ1/HQz5/zsq0LbfcMv7xj39EQSn/yPTtt9/Gww8/HKNGjYoPP/wwvv/++yguLl7T3qJFi9hmm22ie/fuceSRR8Zuu+2WmGefffaJ2267Lfr371+hOssztocPH55T4zqfZPJ9fFFRUQwfPjy6du1a6jGrV6+OcePGxciRI+Ptt9+OGTNmxOzZs6OgoCCaNm0a7du3j7333juOP/74aNOmTWKO6667Lj799NN49NFHy1xbvs5tldG6det49tlnY8MNNyz1mGXLlsULL7wQw4cPj48++ihmzJgRc+fOXbP2tGvXLnr16hWHHnpobLDBBmudu91228Wdd9653ndClZXtdbOq9tu58jm4LHJ9L5ar616u1gUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1XUFJSUlJmQ4sKMh0LUCe6tixY3Ts2DEiIkpKSuLzzz+P119/Pco4vQDkhNatW8fFl1yc7TKoAUY+PTJefPHFbJcBUGnNmjWLK668IttlUM298MIL8czIZ7JdBkCl1atXL6697tpsl0E1996778XDDz+c7TIA0uJPf/5TtkugBvho0kfx73//O9tlAKTFBY9H1G2Y7Sqozr75MOLhS7JdBQClKSgoiF122SW22WabNd/vPWHChJgwYUKWK6uZfE8tmdbj1xFd+pTvnBVLIv5zUcSsLzJSUk6bOnVqbL755inxY489NgYPHpyxfrt27RpvvPFGYlubNm1i+vTpKfHzzjsvbrvttsRz3n333Tj77LPjzTffLHMNRxxxRNx7773RpEmTxPazzjor7r777jLn+1HSfHbZZZfF8uXLY+DAgSltc+fOjaeeeipGjBgRH3zwQcyYMSPmz59f7n5/6ogjjojHH388Jf7YY4/F0UcfXancpUm67quvvjpOP/30aNeu3Vrxp59+Oi677LKYOHHievNuv/32cdttt8UBBxyQ2H7MMcfEkCFDyl3vmDFjokePHoltX3/9dVx00UXx2GOPlSlXkyZN4rLLLovf/va3UVhYmNL+zTffRIcOHWLx4sXlqjEbz1Ku35fatWvHO++8s2Yv8XOrV6+Of//73/HHP/4xpk2btt58jRs3jvPPPz+uvPLKqFev3pr4kiVLYs6cOdG2bduUc7p161auuaayGjVqFDNnzlyrvh916NAhPvnkk3LnrFu3bsyZMycaNGhQ6jHPPPNMHHLIIeXOHRFxzTXXxFVXXZUS7927dzz99NPrPb+0fWFlfnazqufF0q7hgw8+iJ122mmtWDrnxIiKz4vpUFBQEEuXLo26deumtHXv3j3GjRuXhar+T2FhYSxdujSKiopS2vbYY4/43//+V6Y8SX+/t956a5x++unRtGnTtY6788474/rrr49vv/12vXkbNmwYF154YfzmN78pdX+yYMGC2GGHHeKbb74pU60/l+vzfLb2ExGZGzsffPBB7LjjjmvFVq1aFW3bto0ZM2as89zbb789zjnnnJT4f//73zjhhBPSWme2PheUVzb2uRERV111VVxzzTWltj/77LNx6aWXxgcffLDeXA0bNoyLLrooLr300mjUqFHiMVOnTo1f/OIXsWDBggrXnA75ct35Oi/nyue2iPLvs5Ly/PGPf4wzzzwz2rRpsya2cOHCuPjii+Oee+6J4uLiUvMVFhbGr3/96/jTn/6UuI/o379/PP/88zFp0qS11vGSkpIYOHBg/OEPf1jvc3PggQfG3XffnbKe/OiJJ56II488cp05kmRi71pRBx10UDz77LOJfT/55JNxxBFHlDlXru8ZMslnh7LJh2ckk3Neae9nMvGer7LyZT2PyN81PdfHQ3X8nJVpw4YNiz59Uv+hqbi4OH7/+9/Hn//851i+fHmZ8+2xxx5x5513lvpO86CDDooxY8aUq8Z0je1Mjesbb7wxfvvb36bEL7vssrjlllvKnGd9GjRokDgeFi1aFI0bNy5Xrmy8j7/nnnvi9NNPL7X9scceiyuuuCImT5683ly1a9eOc889N2644YaoX79+Svv8+fNjxx13LPM8l+tzW7oVFBTEyy+/HN27d09sLy4ujnvuuSeuuOKKmDlz5nrzFRUVxYUXXhhXXnllyti68sor47rrrks5p7z/9pCv62a23u1kSz7sxXJ13cvVugCqg4KCgth1112jffv2vp8WKLPKfI+339UOlMbPlUB67bfffnHIoRX7vl+oKn5vKkDl9TqkV+y///7ZLgNK9cTjT5T5Z3MASHbCCSdE5y6ds10GlOqee+6Jjz/6ONtlAOS1iy6+KDbeeONslwHr9Jc//yW+++67bJcBkNcGPBDRpFW2q4DSDTzih9/BCtRMfld7bvE9tQAAAAAAAAAAAABVy+9qByrC72oHMsHPlQC5xu+7J1v8DnugJrHekg3WWqAm8d91IRtGPj0yXnzxxWyXAVAlrLVki/82GlCTHHhuROfe2a6Cmmb03yPefzrbVQBULb+rPbf4nloAAAAAAAAAAACAquV3tQMVUZbv8S6sgjoAAAAAAAAAAAAAAACooI49I7r0Kf95RQ0ijvzjD/9P1TjssMMS47NmzYrp06enxJs0aRJXX3114jn/+c9/omvXrvHmm2+Wq4Ynnngi9txzz5g/f35i+29+85s1P6RYWQ0aNIgrr7xyrdjy5cvj5ptvji222CJOO+20ePzxx2Py5Mml1pOPzjjjjGjXrt2ar1etWhX9+/eP3r17x8SJE8uUY9KkSXHQQQfFvffem9h+6aWXlruuk046KXr06JHYNm7cuNh5553jscceK3O+BQsWxBVXXBGHHnpoLFy4MKW9bdu28cc//rHcdSbJ5LOUD/flggsuWPMfgfm5uXPnxkEHHRRnnXVWTJs2rUz5Fi5cGNdff3107tw5pk6duibeoEGDaNu2bblqy5RFixbFqFGjEtv69u1boZwHHHBANGiw7kVv//33X+8xpUmqa8GCBTF69OgK5atOdtpppzV/zsScGFGxeTFd2rRpE3Xr1k1s++abb6q4mlTFxcXx3XffJbZtscUWlcp99tlnR9OmTdd8PX/+/DjggAPi17/+dXz77bdlyrF48eK47rrrokuXLvHRRx8lHtOkSZO49dZbK1RjPszzSapiPxGRmbGz++67x4477pgSHzlyZMyYMWO95w8aNCgxfuSRR8YGG2xQ6foomx133DGuuuqqxLYfn8devXrFBx98UKZ8ixcvjmuvvTY6depU6ljfYost4pZbbqlwzemQ79edD/NydfOrX/0q2rRps+brL774Irp06RJ33313FBcXr/Pc4uLi+Pvf/x5HH310rFq1KqX9wgsvjGuvvTaKiorWxJYuXRqHHnpoXHTRRbFgwYL11jdmzJjYZ599Sv2s0Ldv35z5DFARG2+8cfznP/9JfI/x5ZdfxmmnnVbmXPm6Z6hucvmzg2ck9f1Mrr7ny/f1PCL31/R8HQ/5/Dkr01q2bBm9evVKbDv++OPj+uuvj+XLl5cr52uvvRa77rprPPHEE4nt11xzTbnypXNs58vnk2zJ5Pv4Hj16xOmnn57YtnTp0jj66KPj6KOPjsmTJ5cp36pVq2LgwIGxxx57xMyZM1PamzZtWub5I1/ntso444wzonv37oltixYtih49esRZZ52VeG+TrFixIm6++ebo2LFjfP7552u1/fa3v610vaXJ9XWzpsmHvViurnu5WhcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQUZjtAgAAAAAAAAAAAAAAAEhW1CBin9Mrfn7TjSJ2OzZ99VC6evXqxUknnZTYNnbs2MR4nTp14r///W8sW7ZsrfjIkSPjl7/8ZaxevbpCtXz44Yfx61//OrGtffv20atXrwrl/bnjjz8+NtxwwzVfz5o1K/bff//47W9/G/Pnz09LH7lo0003XfPn4uLiOPbYY+Ouu+4qd57i4uI4/fTkAb7LLrvE3nvvXeZc9erVi1tuuSWxbfz48dGjR4+YOXNmuWuMiHj22Wfj5JNPTmw777zzYqONNqpQ3p/K1LOUD/elWbNmcfXVVye2zZkzJ7p16xYvvPBChWr8+OOPY88994xvvvmmQudn2uDBgxPj/fr1q1C+Pn36rPeYunXrRo8ePcqde/PNN4+OHTumxIcNGxYrV64sd77qKh1z4ssvv5zYXt55MZ2aNGlSatuMGTOqsJLSlVZH48aNK5W3Xr16a/68ZMmS2H///ePFF1+sUK7PPvssunXrFu+++25i+1FHHRV77rlnuevL9Xm+NOneT1Tl2BkwYEBi/O677y7T+e+991689957KfGioqI49dRTK1Ma5fDPf/4z6tSpkxJfuXJlHHLIIRV6HiMiPv/88+jWrVu8/vrrie1nnXVWdO3atUK50yHfrzvX5+XqqG3btmv+PHv27Nhvv/3i008/LVeO4cOHx1/+8peUeIcOHeL4449f83VxcXEcccQR8cwzz5Qr/5dffhmnnHJKYlutWrVKnbdzXWFhYfz3v/+Nli1bprStXLkyjjnmmDJ/XsznPUN1lWv7H8/ID376fiaX3/Pl+3oekdtrej6Ph3z+nJVpffr0idq1a6fEH3300VLf0ZXFihUr4thjj43//e9/a8XHjBkTv//978uVKxNjO9c/n2RLpt7HFxYWxh133JHYtmTJkth3333jscceq1Du999/P3r06BFLlixJaevatWsUFRWt8/x8ntsqqlGjRnHDDTckti1cuDD222+/Cq89U6dOje7du8dnn322Vn+ZksvrZk2UD3uxXF33crUuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIKIw2wUAAAAAAAAAAAAAAACQbKeDIuo3qVyOLodF1KqTnnoo3RVXXBHt2rVLbHvkkUcS47Nnz47zzjsvtthii/jLX/4Sixcvjnnz5sXJJ59c6Xoeeuih+OCDDxLbDjjggErnj4jYZptt1vx53rx5sfvuu8drr72Wltz54uqrr44nnniiUjlWrlyZGO/bt2+Zc5xwwgmx8cYbp8QXLFgQhx9+eCxbtqzC9UVEDB06NAYNGpQSLyoqil//+teVyh2RuWcpH+7L6aefHo0bN06Jl5SUxEknnRRTpkypVI3Tp0+PI488MlavXl2pPJkwbNiwWL58eUp8t912i1atWpU7X+/evdf6etWqVfHqq6+mHNenT59y5y5tPA4ePLjcuaqzdMyJp556alrmxXRq2LBhYry4uLjS80i6LF68ODHeqFGjtPVxzjnnxLvvvlupHAsXLowjjzwy5s6dm9j+//7f/ytXvnyY58sin8ZOs2bN4uijj06JT58+PZ555pky50m6rxERAwYMqHBtlN1ee+0Ve+65Z2Lbb37zmxgzZkyl8v841r///vuUtoKCgrj88ssrlb+iqtt15+K8XN2dcsop8cUXX1To3Ouuuy7mzJmzzmNuvvnmePbZZyuU//nnny/13IMPPrhCObPt6quvjn322Sex7be//W28+eabZc5VXfYM1Umu7X88Iz/46fuZXH3PV93W84jcW9Ory3jItXkm27baaqvE+P3331/p3KtWrYrTTjstli5dGg8++GB06tQpDjrooHKNx0yO7Vz9fJJNmXoff8QRR0T79u0T284555xy7d+STJgwIS666KI1X7/55ptx+OGHR8eOHWPFihXrPLe6zG3lccopp8SGG26Y2Hb++efH22+/Xan806dPj5NOOqnK/+0h19bNmiZf9mK5uu7lal0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABARGG2CwAAAAAAAAAAAAAAACDZ1rtVPkdR/YjNOlY+D6U75ZRT4vLLL09smzZtWgwbNmyd53/33XdxySWXRLt27eKwww6L2bNnp6Wuf/3rX4nxvfbaKy35f+r000+PTz/9NO15c9n48ePjxhtvrHSeoUOHJsa7d+9e5hznnntuYvy2226LqVOnVqSsFDfeeGMUFxenxE8++eS05P9ROp+lfLgvZ599dmL8vvvui2eeeaZStf3ozTffLHU+yKZFixbFqFGjUuIFBQXRp0+fcuX6xS9+EW3btl0rNnbs2Lj//vtTjj300EPLV2hE9OvXLyW2cOHCGD16dLlzVVfpmhOnTp2alnkxnRo1apQYX758eRVXUrply5Ylxhs3bpyW/K+88krieKqIL774Ii699NLEtn79+kXr1q3LnCsf5vn1ybexc/LJJ0f9+vVT4vfff3+sXr26zHkeeuihxOd26623jv33379SNbJ+l1xySWL8ueeei7/97W9p6ePbb7+NM888M7HtsMMOi/bt26eln/KoTtedq/NydfbUU0/F008/XeHzFy1aFI8//nip7dOmTYtrr722wvkjIv79738nxjt16hR169atVO6qtv/++8eVV16Z2Pb000/HX//613Llqw57huokF/c/npFUufqerzqt5xG5uaZXh/GQi/NMtrVp0yYx/tlnn6Ul/yeffBIbbbRRnHzyyTFhwoRyn5/psZ2Ln09yRTrfx19wwQWJ8WHDhqVtrrvrrrvizjvvjH333Te6desWQ4cOjZKSkvWeVx3mtvL69a9/nRh/5pln4r777ktLH6+//nr8/e9/T0uussjFdbOmyZe9WK6ue7laFwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBRmO0CAAAAAAAAAAAAAAAASLZhu/Tk2WCz9ORhbfXq1Yvrrrsu7r333igsTP4xnT/84Q+xYsWKMuWbPXt2vPLKK2mr74UXXkiMd+7cOWrVqpW2fp588sl48skn05YvX1x11VWxevXqSue59957E+NdunSJBg0arPf8zTbbLDp37pwSX7JkSdx6662Vru9Hn3/+eTz33HMp8Xbt2sV2222Xlj7S+Szlw33ZZpttYuutt05s+8tf/pKW+n503XXXxapVq9KaMx0GDx6cGO/Xr1+58vTu3TslNmzYsBgxYkSUlJSsFd94442jS5cuZc7dvHnz2GuvvVLiw4cPj+XLl5erzuosXXNiROXnxXQrKipKjKfretOhtPFdt27dtOS/9tpr05LnRw8++GDMnDkzJV67du3o2bNnmXLkwzxfFvk2dvr3758Yv+eee8qVZ/78+fHEE08ktg0YMKDcdVF2jRs3jl69eiW23XjjjWnta9iwYTFx4sSUeEFBQRx11FFp7Wt9qtt15+K8XN2l454//vjjpbYNHDgwli5dWqn8I0aMSHz/UKdOncQ1M1e1atUqHnroocT3LN98802cfPLJ5cpXXfYM1Umu7X88I6ly9T1fdVvPI3JvTa8u4yHX5plcUNr7gZ+/N6uMhQsXVui8qhrbufT5JFek8318q1atYs8990xsu/nmm9PSR8QPz+w555wTY8eOLfM51WVuK49tttmm1D6vv/76tPb1l7/8pcrek+baulnT5NNeLFfXvVytCwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIgozHYBAAAAAAAAAAAAAAAAJKvfJD15GjZPTx5+0LJlyzjvvPPi448/jiuuuCIKCgoSj3vhhRdi0KBBVVzd//n4449j0aJFKfHatWtH8+bpeygGDhyYtlz54ssvv4zhw4enJde4ceOipKQkJV67du1o167des8/8MADE+PPPfdczJkzp9L1/dRLL72UGN93333Tkj+dz1I+3JeDDjooMf7yyy/HxIkTK1nV2qZPnx4jRoxIa850GDZsWCxfvjwl3qNHj2jQoEGZ8xx22GEpseHDh8d3330Xb7/9dkpb7969y5y7d+/eUatWrZT4kCFDypyjukvnnBhR+XmR9Pryyy9jzJgxac25fPnyuOeeexLbevbsWaYc+TDPr0++jZ0999wztt9++5T42LFj49NPPy13vrvvvjsx3q9fv2jVqlW581E2Bx10UNSpUycl/uGHH8YLL7yQ9v5K29/16dMn7X2tS3W67lydl6uz8ePHxzvvvFPpPKXlKC4ujvvvv7/S+ZcuXRoff/xxYtsWW2xR6fxVoaCgIB5++OFo3bp1Stvq1avjuOOOK/c6Xx32DNVJLu5/PCOpcvVdX3VazyNyc02vDuMhF+eZXDBv3rzEeC7sEapybOfK55Nckc75vmfPnon/Vvbee+/Fa6+9lrZ+KqI6zG3lVdqcP378+Bg3blxa+/rmm2/i6aefTmvOJLm4btY0+bQXy9V1L1frAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACIKs10AAAAAAAAAAAAAAAAAyVYuS0+eFUvTkyffbbXVVtGlS5cy/2+XXXaJ/fbbL/r27Rtnnnlm/OMf/4hXX301vv3227jtttuiXbt2pfb12WefxbHHHluFV5eqpKQkpk+fntjWokWLtPTx8ccfx8svv5yWXPlkxIgRacu1YMGC+OyzzxLbmjdvvt7zu3fvnhgfNWpUpepK8vrrryfGd9hhh0rnTvezlA/3pVu3bonxF198sdI1JRk5cmRG8lbGwoULY/To0SnxevXqxcEHH1ymHBtttFHssssua8U+/PDDmDp1akREPPXUUynn9OnTp8w19uvXLyW2ePHiePbZZ8uco7pL55wYUfl5kfRKGqPp8MILLyTGd9111zKdnw/z/Prk29gZMGBAYnzQoEEVyvfSSy/F559/nhKvU6dOnHbaaRXKyfrtt99+ifFMrWul5e3WrVvUrVs3I30mqU7XnavzcnWWrrVl1qxZMXPmzJT4+++/nxiviIkTJybGmzVrlpb8mXbFFVfEAQcckNh21VVXxbhx48qdszrsGaqTXNz/eEbWlsvv+qrTeh6Rm2t6dRgPuTjP5ILS/p3g+OOPr+JKUlXl2M6Vzye5IN3z/V577ZUYz8T8UV7VYW4rr9133z0xnu45MtN5fyoX182aJp/2Yrm67uVqXQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBE7WwXAAAAAAAAAAAAAAAAQLKFsyLqNqx8ngUzK5+jOrjhhhvihhtuyHg/H3/8cRx00EExa9asjPe1PvPnz0+Mt2jRIi35X3rppbTkyTcvv/xyWvN9/fXXsfXWW6fEy/L31KFDh8T4//73v0rX9XPTp09PjG+zzTaVzp3uZykf7su2226bGM9EjRERr7zySkbyVtbgwYOjT58+KfF+/frFk08+ud7zDz300CgoKFgrNnz48LX+fN11163VvvPOO0fr1q3ju+++W2fuunXrxsEHH5wSHzFiRCxbtmy9tdUU6Z4TIyo3L6ZbSUlJYvznz102lVZLcXFxpXNnau548803o6SkJKX2zTffPIqKimLFihXrPD8f5vn1yaex07x58zjqqKNS4vPnz4/HHnuswnnvueeeuP7661Pi/fv3j5tvvrnCeSnd9ttvnxh/9dVXM9LfN998E19//XVsuumma8ULCwtj2223jQkTJmSk35+rTtedq/Nydfbaa6+lLdd3330XLVu2XCv2xhtvpDV/kmbNmqWtj0zZa6+94g9/+ENi25gxY+Kmm26qUN7qsGeoTnJx/+MZWVsuv+urTut5RG6u6dVhPOTiPBPxwzp3xx13pLOsiIg44YQT4oMPPljvcaWNk5NPPjlGjhwZQ4YMSXdpZVaVYztXPp/kgnTP99ttt11iPJ176YqqDnNbeZV2zePGjctIf+n8TFOaXFw3q1K215GI/NqL5eq6l6t1AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABG1s10AAAAAAAAAAAAAAAAAyb54L2LDdpXP8+V7lc9B2dxzzz1x8cUXx/z587NWQ+vWrWOrrbaKLbfcMlq0aJF4TFFRUVr6euONN9KSJ9989NFHac1X2vPSrFmz9Z67zTbbJMa//PLLypSUaO7cuYnx5s2bVzp3up+lfLgv7du3T4xPmDCh0jUl+eyzz6K4uDgKCwszkr+innrqqVi+fHnUrVt3rXjv3r2jsLAwiouL13n+YYcdlpjzRxMmTIivvvoqNttsszWxgoKCOPTQQ+Oee+5ZZ+4ePXpEw4YNU+JDhgxZ53k1TbrnxIjKzYvptnjx4sR4utbSdPj5+PnRokWLKp17ypQplc6RZP78+fHll1/G5ptvvla8sLAwttxyy/j444/XeX4+zPPrk09j55RTTol69eqlxP/73//GsmXLKpz3vvvui2uuuSZq1aq1VnyLLbaIgw46KEaPHl3h3CTbbrvtEuPvvvtuxvp85513YtNNN02sJVP7nqS+kuTjdefqvFydpfOeL1y4MCU2efLkjOaPyM4eqjw23HDDeOSRR1LWg4iI7777Lk488cQoKSmpUO7qsGeoTnJx/+MZWVsuv+urTut5RG6u6dVhPOTiPBMR0bhx49hxxx3TVNH/qV+/fpmOe/XVV2P27NmxwQYbrBUvLCyMRx99NHr37h1//etfY/z48WmvcX2qemznwueTXJDu+X7bbbdNjL/3Xvb/gbI6zG3ltfXWWyfGM/X38eGHH8aKFSsy+r40F9fNqpTtdSQiv/Ziubru5WpdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQERhtgsAAAAAAAAAAAAAAAAg2cTnIkpKKpfjy/cjFs1OSzmsw6effhoHHHBAnHHGGTF//vyM9lW3bt3Ydttt45BDDolzzz03Bg4cGMOGDYsPP/wwlixZEtOnT49XX301Hnjggdhyyy0zWsv48eMzmj9XTZs2La35FixYkBgvLFz/j381b948JbZ06dKYM2dOpev6uUWLFiXGGzduXOnc6X6W8uG+NG3aNDE+e3ZmJu2VK1fGt99+m5HclbFw4cIYPXp0SrxFixbRvXv3dZ5bVFQUPXr0WCv2/fffx5tvvrlWbNiwYSnn9unTZ7219evXLyW2ZMmSGDly5HrPrUnSPSdGVG5eTLfSxnidOnWyUk+S+vXrJ8ZLq708vvzyy0rnKE1pc3LSHF6WY3Jtnl+ffBo7/fv3T4wPGjSoUnm//fbbGDVqVGLbgAEDKpWbZC1btkyMz5w5M2N9zpo1KzG+4YYbZqzPn6tO152r83J1ls49dNKa8t1336Ut/8KFCxPjubJnKc2DDz4Ybdq0SYkXFxfHCSecUKmxWh32DNVJLu5/PCNry+V3fdVpPY/IzTW9OoyHXJxncsHKlSvjxhtvTGwrKCiIk08+Od5///34+uuv44knnohrr702TjnllNhzzz1jo402ymhtVT22c+HzSS5I93zfokWLxHgm5+iyqg5zW3kUFhZGo0aNEttKe/4rq7i4OCP386dycd2safJpL5ar616u1gUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABE1M52AQAAAAAAAAAAAAAAACSb8WnEJ69EdNi7YueXFEeM/Xd6a+L/rFy5MoYNGxZ33XVXjBkzJkpKStKav02bNrHzzjtHx44dY+utt44tt9wyttpqq2jTpk0UFBSkta+Kmj17drZLyIqFCxemNV9xcXGFzmvQoEHis1C/fv1YunRpZctKUdpzV7du3UrnTuezlA/3pbQaly9fHitWrEhbbT+X7mc3XQYPHhx9+vRJiffr1y9efvnlUs/bf//9o2HDhmvFRowYkTIfDxs2LM4999y1YgceeGDUrVs3li9fnpi7oKAgsaaRI0dm5DnKZ5l4rio6L2bC4sWLS23bYIMNYubMmVVYTel1JFm0aFGlcy9YsKDSOUozb968xHijRo3WeV4+zPNlkS9jZ6+99ooOHTqkxCdMmBDvvPNOpfPffffdccghh6TE+/TpExtvvHFMnz690n3wg/r160etWrVS4suXL49ly5ZlrN+5c+cmxhs3bpyxPn+qul13Ls7L1d269gLllTRPZzp/rrvsssuiZ8+eiW3XXXddvPjiixXOXV32DNVJru1/PCOpcvVdX3VbzyNyb02vLuMh1+aZXPL3v/89Dj/88Nhzzz1LPaZt27bRtm3bOPzww9eKL168OD777LP49NNP49NPP40pU6bE+PHjY8KECaW+WyuLbIztbH8+yRXpfh9fWFiYEl++fHmlno90qC5zW3mU9iwvWrQoVq1albF+582bF61bt85Y/lxbN2uafNyL5eK6l8t1AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQE1XO9sFAAAAAAAAAAAAAAAAULpRt0W02iqixSblP3fsvyO+m5z+mmqakpKSWLhwYcydOzcmTpwYb731Vrz55pvx+uuvx5w5c9La1w477BAnn3xyHHvssdGuXbu05s6E+fPnZ7uErFi5cmW2S4iIiIYNG5baVq9evSqspPLS+Szlw30prcYFCxZktN/FixdnNH9FDRs2LFasWBFFRUVrxfv27RsXXXRRqef16dMnJfbUU0+lxF566aVYuHBhNG7ceE2sQYMGse+++8aoUaMSc++2226x0UYbpcQHDx5caj01Va7MiZny/fffl9q28cYbx8yZM6uwmtLrSLKu2stqyZIllc5RmtLm/kaNGq3zvHyY58siX8bOgAEDEuN33313WvKPGDEivv/++2jVqtVa8dq1a8fpp58e119/fVr6IXv7j7lz5ybGmzRpktF+f1TdrjsX5+XqLtPz9YoVKzKaP5ftsccecd111yW2jR07Nv74xz9WKn912TNUJ7m2//GMpMrVd33VbT2PyL01vbqMh1ybZ3LJihUrom/fvjFmzJjo3Llzuc5t2LBhdOzYMTp27LhWfNWqVTF27Nh46KGH4pFHHomlS5eWO2+STI7tbH8+yRVV8T4+03N0WVSXua086tatmxjP9L8NZPrvO9fWzZomH/diubju5XJdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUNPVznYBAAAAAAAAAAAAAAAAlG75oojHrow46tqIFm3Lft4bgyPefCxzdeWjc889N4YPH17m40tKSmLBggWxYMGCKCkpyWBlEe3atYsbb7wxjjvuuCgoKMhoX+m0YMGCbJdQo+XTs7I+6XyW8uG+lFbj6tWrM9rvqlWrMpq/ohYsWBCjR4+O3r17rxXfcsstY4cddoiJEycmnvfz45ctWxZjxoxJOW7lypXx7LPPxtFHH71WvE+fPjFq1KjE3P369UuJLV26NEaOHLmuS6EaWrhwYcyYMSM22mijlLatttoqJkyYkIWq/k+LFi2iadOmiW1TpkypdP5M7oFKm/PWN4/nwzxfXbRo0SKOPPLIlPjy5cvjoYceSksfq1atigceeCAuueSSlLazzjorbrjhhozvxWuKwsLCxHim9x8VHevpUt2uOxfnZSqnps5xzZs3j0ceeSRq1079tSczZ86M448/PoqLiyvVh2eX9fGMpMrVd33VbT2PyL013XjIrPnz58fbb7+d9ryLFy8u1/GzZ8+O3XffPf76179G//79o1atWpXqv3bt2nHAAQfEAQccENddd11ceeWVce+995b5/GyMbXveH1TF+/hMz9FlUdP+Xtcl0587Krt3X59cWzerWrbXkXzdi+XaupfrdQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBNVjvbBQAAAAAAAAAAAAAAALBu86ZHPPj/Ig78dcR2+0YUFJR+7KI5ES/+K+KjsVVVXf6YOXNmfPXVV9kuI0WPHj1iyJAh0axZswrnmDNnTkyZMiWmTJkSn3zyyZo/33777bHbbrulr9ifKSkpyVhuahbPEoMHD47evXunxPv16xcTJ05MiXfs2DE222yztWLPP/98LF26NDH/sGHD4uijj14r1qdPnzj33HMTj+/bt29K7JlnnonFixeXeg1UX1OmTImNNtooJb7jjjvGk08+mYWK1q4hyerVq2Pq1KlVXA3VzSmnnBJ169ZNib/11lvRvn37tPXzwQcfJMY322yz6NmzZzzzzDNp6wuA3PDAAw/EpptumhIvKSmJk046KaZPn56FqgDvZyAzxo0bF7vuumu2y4iIiOXLl8evf/3r+Nvf/ha/+93v4ogjjogmTZpUOm+bNm3i3//+dxx44IFx2mmnxfLly9NQLZlivq++Svu7LSwszGi/derUyWj+mi6X1pF8k6vrXq7WBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADVV7WwXAAAAAAAAAAAAAAAAwPotXxQx4uaINx+L2H7/iM07RzTeMKJOvYgl8yJmfhHx6esRk56PWLk829VSVr169Yrhw4dHrVq11nvsokWLYvLkyTF58uSYMmXKWv8/d+7cxHOWLVuW7pLJISUlJYnxefPmxSOPPFJldcyePbvK+iqLfLgvq1evTozXqVMnU+VUSf7KeOqpp2LFihVRVFS0Vrxfv35x/fXXpxzfu3fvxBylGTlyZKxevXqt+XazzTaLHXbYISZOnLjWsdtuu21su+22KTmGDBmy3uugevr444+je/fuKfHdd989C9WsbbfddkuMf/7557Fy5cpK569Tp05a8iT5+Xj/UWlz5I/yYZ6vLvr3758Y7969e7zxxhtVUsPZZ58dzzzzTJX0Vd2VNrZq187srxwobf+xvrGeLtXtunNxXobyuuiiixL38xERN998c4wePTot/dgzsD6ekfxR3dbzH3Pn0ppuPNQ8kydPjtNOOy369+8f++67b+y6666x8847R4cOHWLLLbeMunXrVijv8ccfH40bN44+ffqs99hsjO1sfz4pi4KCgmyXUC7FxcWJ8UzP0WVRE+e2JUuWJMabNGmS0X6bNWuW0fy5tm7WNNVhL5YL614+1QUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1Te1sFwAAAAAAAAAAAAAAAEDZff/ZD/8j/22++ebx8MMPR61atRLbZ8+eHY8//niMGTMm3nrrrfjyyy/L3UdBQUFlyySHLVu2LDG+aNGiOPvss6u4mtyRD/dl8eLFifGmTZtmtN+GDRtmNH9lLFiwIMaMGROHHnroWvGdd9452rRpE99+++1a8cMOO2ytr0tKSmLEiBGl5p8zZ06MGzcu9t5777Xiffr0iYkTJ64V69u3b8r5y5YtW2d+qrexY8fGGWeckRLfa6+9onbt2rFq1aosVPWD/fffPzE+duzYtORv2rRpzJo1Ky25fq5Zs2aJ8UWLFq3zvHyY56uDffbZJ7bddttslxGHHHJItG3bNr755ptsl5L3ShtbpY3FdGnRokVifMGCBRnt90fV7bpzcV6G8ujatWvcdNNNiW2vvfZaXHnllWnry56B9fGM5I/qtp5H5N6abjzUXCtWrIjRo0fH6NGj18QKCgqibdu2sfXWW8fWW28d7du3X/PnrbfeOurXr7/OnL17947LL788brjhhnUel42xne3PJ2Wxvvuba0qbPzL9rrssauLctnjx4igpKUn598F69epFvXr1Sr0nlZXpNTnX1s2apjrtxbK57uVjXQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFBTFGa7AAAAAAAAAAAAAAAAAKiJbrjhhmjWrFlKfNGiRXHeeedFmzZton///vHYY4/Fl19+WaE+GjVqVMkqyWVLliyJkpKSlHiLFi2yUE3uyIf7smzZsiguLk6J165dOxo0aJCxfps2bZqx3OkwePDglFhBQUEcdthha8VatmwZXbt2XSv2zjvvxPTp09eZf9iwYSmxPn36pMT69euXEhs1alQsWrRonfmpvp5//vnEeKNGjaJHjx5VXM3/adq0aey3336Jbc8991xa+kjaq6RLabnXN9byYZ6vDgYMGJDtEiIiolatWnHGGWdku4xqYfny5bFq1aqUeO3ataNhw4YZ67d58+aJ8YULF2asz5+qbtedi/MylFXTpk3j0UcfjTp16qS0zZkzJ4499thYvXp12vqzZ2B9PCP5o7qt5xG5t6YbD/xUSUlJfP311/Hiiy/G3XffHZdeemkcccQR0bFjx2jYsGFsu+22ccEFF8RHH31Uao7f/e53631+sjG2MzGua9WqVeFzkzRu3Dit+TKttPmjTp06Ub9+/SxU9H9q6tw2a9asxHjr1q0z0l/Dhg1LHVvpkmvrZk1THfdiP1VV6151qQsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACqo8JsFwAAAAAAAAAAAAAAAAA1zeabbx7HHntsSnz58uXRo0eP+Mc//hErVqyodD8bbrhhpXOQu1avXh0zZ85MiTdo0CDq1auXhYpyQ77clxkzZiTGN9poo4z0V69evWjdunVGcqfLU089lTj39evXb62vDz300CgoKEg5d32GDRuWEtttt91igw02WPP1RhttFLvttlvKcYMHD15vfqqv6dOnx0cffZTYdvLJJ1dxNf/nmGOOiaKiopR4SUlJvPDCC2npI1Nz0rpyz5o1a53n5cs8n8823HDDOOKII7JdxhpnnHFGFBb6sfh0mDZtWmI8k3uE0nJ/9913Gevz56rTdefivAxlde+998bmm2+e2HbKKafEN998k9b+7BlYH89IfqlO63lE7q3pxgNlVVJSEpMnT47bbrstdthhh/jjH/+YeFyjRo3ijDPOWG++qh7blRnXq1evTow3bty4UjX93KabbprWfJlWXFxc5e+6y6qmzm2ffPJJYrxr164Z6W+XXXbJ+HubXFs3a6Lqthcrq3Sve9W9LgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMhXhdkuAAAAAAAAAAAAAAAAAGqaQw45JAoLU3+054477og33ngjLX0UFhZGq1at0pKL3PXVV18lxnfccccqriS35MN9mTx5cmJ8l112yUh/22yzTRQUFGQkd7rMnz8/nnvuuZT4fvvtF40bN17z9WGHHZZyzLBhw9abf8qUKfHJJ5+sFSssLIxevXqt+bpPnz4p92n58uUxfPjw9eanevvPf/6TGD/qqKOibdu2VVzNDy688MLE+HPPPRczZ85MSx+ZmpM22WST2GijjVLiK1eujKlTp673/HyY5/PZKaecEkVFRdkuY41NNtkkDj300GyXUS1MmjQpMd6tW7eM9dm1a9fE+MSJEzPW589Vp+vO1XkZ1ue8886Lww8/PLHt1ltvjREjRmSkX3sG1sczkj+q03oekZtruvFAeZWUlMQf/vCHuOOOOxLbDz744PXmqOqxXZlxPXfu3MR4kyZNKlXTz2277bZpzVcVvvzyy8T4zjvvXMWVpKqJc9tHH32UGO/evXtG+svkWvyjXFw3a5rqtheriHSse5mQq3UBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAPinMdgEAAAAAAAAAAAAAAABQ0+y9996J8UceeSRtfey8885Rv379tOUjN33wwQeJ8W7dulVxJbklH+7LJ598khjffffdM9LfPvvsk5G86TZ48OCUWFFRUfTs2XPNnw888MC12r/++uuYMGFCmfIPHz48JdanT581f+7Xr19K++jRo2PhwoVlyk/1de+998bq1atT4nXq1Ikrr7yyyus55phjYrvttkts+9e//pW2fjI1J+22226J8c8++yyKi4vXe34+zPP5rH///onxk046KerWrZvR/7322muJfQ8YMCCTl1xjfPjhh4nx7t27Z6S/bbfdNjbYYIOU+PLly+Ozzz7LSJ9JqtN15+q8DOvSpUuX+POf/5zY9tZbb8Wll16asb7tGVgfz0j+qE7reURurunGAxX1+9//PlatWpUS33XXXdd7blWO7cqO67lz5ybGt9hii0rX9lP58h73p95///3EeKbmuvKoiXPbiy++mBg/4ogjolatWmnv74QTTkh7zp/LxXWzpqlue7HKqMy6l0m5WhcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADkg8JsFwAAAAAAAAAAAAAAAAA1zcYbb5wY/+ijj9LWx/7775+2XLmsVq1a2S4hq958883E+L777lu1heSYfLgvr7zySmK8V69eGemvT58+GcmbbkOHDo0VK1akxPv16xcRP/wdNmrUaK22YcOGlTn/U089lRLr2bNn1K5dOxo2bBg9evRIaR8yZEiZ8+eCmj4vZsr06dNj+PDhiW1nnnlmdOnSpcpqadCgQfz5z39ObPv+++8Tn/OK2n///aOoqCht+X50yCGHJMZfffXVMp2fD/N8vtpvv/2iffv2KfE5c+bEkCFDYsWKFRn936BBgxLr6tmzZ2y22WaZvvyckon5fMyYMYnx3r17Z6S/H9fvnxs7dmysXr067f2Vpjpdd67Oy+tjf1JzNW7cOIYMGZL43M6fPz+OOeaYWLVqVcb6t2dYN2PTM5JPqtN6HpGba7rxQEXNnj073n///ZR448aN1/ucV+XYruy4njNnTmI8ne+EateuHQcddFDa8lWVN954IzFe2pxUlWri3DZmzJgoKSlJiW+yySZxxBFHpLWv3XbbLTp16pTWnElycd0si+q0365ue7HKqMy6l0m5WhcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADkg8JsFwAAAAAAAAAAAAAAAAA1TfPmzRPjy5YtS0v+wsLCOPPMM9OSK1csXrw4Md64ceMqriS3jB49OjF+2GGHRcuWLau4mtyRD/dlzJgxifEOHTpEjx490trXlltumfacmTJ//vx47rnnUuKHHnpo1K5dO/r06ZPS9tRTT5U5/2uvvRazZ89eK9akSZPo3r17HHzwwVG3bt212lasWBHDhg0rc/6qZF6sen/4wx+iuLg4JV5YWBgPP/xwNGjQoErquOOOO2LTTTdNbLv22mtj1apVaeurZcuWcdxxx6UtX0TEhhtuGCeccEJi27PPPlumHPkwz+erAQMGJMYfeuihWLFiRcb7f/TRR2PRokUp8cLCwjjrrLMy3n82VOV8Pnbs2MT+Nt100zjqqKPS2ledOnXi/PPPT2yr6rW1Ol13rs7LP7I/4efuueee2HLLLRPbTj/99Pjiiy8y2r89ww+MzdJ5RvJHdVrPI3JzTTceaobWrVtnJO+3336bGG/WrNk6z6uqsZ2OcT1p0qTEeOvWrWPrrbeucG0/deSRR+bleCttjtluu+3igAMOqOJq1lYT57ZZs2YlvmOPiLj66qujqKgobX1de+21acu1Lrm4bv5UTdhv5+teLNfWvR/lal0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQUxVmuwAAAAAAAAAAAAAAAACoaRYuXJgYb9myZVryH3/88bHVVlulJVeumDt3bmK8Xbt2VVxJbvn888/jgw8+SIkXFRXFmWeemda+mjZtGq1bt05rzkzJh/syY8aMeO211xLbLr/88sqWtZZrr702CgoK0pozkwYPHpwSa9q0aeyzzz7Rp0+fteILFy6Ml156qcy5i4uLY+TIkSnxPn36RL9+/VLizz33XMyfP7/M+auSebHqjR8/Ph588MHEtm233TYefvjhKCzM7I/uXnDBBXHKKacktk2ZMiX++c9/pr3PSy65JGrVqpW2fBdddFHUq1cvJb548eIYPXp0mXLkwzyfjzbccMPEuTAiYtCgQVVSw5IlS+KRRx5JbPvVr36V1mcxV1TlfL5ixYp49NFHE9uuuOKKqFOnTtr6Ouuss6JNmzYp8eXLl8eQIUPS1k9ZVLfrzsV5+Uf2J/zUgAED4uijj05su/322+OJJ57IeA32DD8wNkvnGckf1W09j8i9Nd14qN7atm0bd955Z3z55ZfRt2/ftOcvKipKjC9dunSd51XV2E7HuJ48eXLMnj07se3UU0+tTHkREVG7du34wx/+UOk82TB9+vQYN25cYtvvfve7tPZ11llnRadOncp8fE2d2/7+978nxnfYYYe4/vrr09LHWWedFT169EhLrrLItXXzp2rCfjvf9mK5uu7lal0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQ0xVmuwAAAAAAAAAAAAAAAACoaWbNmpUY33333Sude5NNNolbb7210nlyzbRp0xLj7du3j4022qiKq8ktd999d2L8iiuuiPbt26etn1tvvTU++eSTOP/886OwMPd/NC0f7svtt9+eGN9vv/3i4osvTkd50bNnzzjhhBPSkquqDB06NFauXJkSv+qqq6Jdu3ZrxUaNGpV47Lo89dRTKbG+fftG7969U+JDhgwpV+6qZF7Mjssvvzzmz5+f2Na3b9946KGHok6dOhnp++yzz17nGn/hhRfGqlWr0t7vTjvtFH/605/SkmufffaJSy+9NLHtwQcfjIULF5Y5Vz7M8/nmtNNOi6KiopT422+/HRMmTKiyOgYNGpQYb926dRx22GFVVkdVqer5/M9//nOUlJSkxHfaaacYOHBgWvro3Llz/PnPf05se+CBB+L7779PSz/lUZ2uO1fn5Qj7E/5Pp06dSh1b77//flx00UVVVos9g7G5Pp6R/FGd1vOI3FzTjYfqp23btnHHHXfEZ599FgMGDIiioqK47bbbokWLFmntZ+utt06JLVmypEzPXqbHdjrH9WuvvZYYP/PMM6NZs2YVKW+Nyy+/PDp06FCpHNn0z3/+MzF+wAEHxAUXXJCWPnbZZZe488474/3334/hw4dH165dy3ReTZzbRowYUeq7nIsuuijOOOOMSuU/8MAD07b2llUurps/Wtd+uzrJh71Yrq57uVoXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8IPCbBcAAAAAAAAAAAAAAAAANc3kyZMT4/37969U3gYNGsRjjz0WLVu2rFSeXDRt2rT45ptvEtvOOeecKq4mt9xzzz0xc+bMlHiDBg3ioYceioYNG1a6jzPOOCNOO+20aNKkSfztb3+Ld999N3bfffdK582kfLgvQ4YMia+++iqx7aabboo+ffpUqr7tt98+Hn744UrlyIb58+fHc889lxLfZ599UmJPPfVUufOPGjUqVqxYsVZsq622iubNm68VW7VqVYXyVxXzYnZ8++23ceqpp5baftxxx8WLL74Ym222Wdr6rFevXvz973+PO+64IwoKChKP+dvf/hZPP/102vr8uQsvvDDOPPPMSuXYbrvt4pFHHolatWqltK1atSoGDhxYrnz5MM/nm9L2ooMGDarSOt54442YOHFiYtuAAQOqtJaqUNXz+UcffRSDBw8utb8LL7ywUvnbt28fTz75ZNSrVy+lbdmyZXHTTTdVKn9FVbfrzsV5OcL+hB80bNgwhgwZEnXr1k1pW7hwYRx99NEp+/FMsmcwNtfHM5I/qtt6HpF7a7rxUP3885//jLPPPjuKiorWxDbbbLMYMmRI1K9fPy19dO3aNbbeeuuUeGlrz89lcmyne1yXVmerVq3i1ltvrVCNERF9+/aNq6++usLn54L//ve/MWXKlMS2P/3pT3HIIYdUKn/r1q1jyJAhUVj4w6/N6927d7zxxhsxZsyYaNWq1TrPrYlzW0lJSZx//vmJbYWFhXH33XfHFVdcseZ+lsdxxx0Xw4cPT9scUh65tm7+aF377eokH/Ziubru5WpdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwA8Ks10AAAAAAAAAAAAAAAAA1DSjRo1KjB944IHxq1/9qkI527RpE6+++mrstttua2LvvvtuhXLlqpdeeikx/tvf/jb23nvvqi0mhyxZsiSuvvrqxLZdd901Xn755WjVqlWF859//vnxr3/9a61Yp06dYty4cXHwwQdXOG+m5cN9WblyZVx00UWJbbVr146hQ4fGb37zmwrVd8ABB8Qrr7wSzZs3XxObNm1ahXJlw+DBg9d7zOrVq2PkyJHlzr1o0aJS55Ofev7552Pu3Lnlzl+VzIvZMXTo0Bg4cGCp7XvuuWdMnDgxLrvssmjYsGGl+jriiCNiwoQJce6555Z6zBtvvBGXXHJJpfopi7vuuiv++te/Rq1atcp97qGHHhqvv/56tG7dOrH9H//4R3zyySflypkP83w+OeCAA2KrrbZKiS9ZsiT++9//Vnk9gwYNSowfeOCBseWWW1ZxNZlX1fP5BRdcEPPnz09s++tf/xr//Oc/o6ioqNx5DzzwwHjzzTejXbt2ie1//OMf4/PPPy933nSpbteda/Pyj+xPuOuuu6J9+/aJbWeddVZ8+umnVVqPPcMPjM3SeUbyS3VbzyNya003Hqqfq666KkpKSlLi+++/fzz//POx6aabVip/s2bN4p577klse+aZZ8qcJxNjOxPj+pFHHolvv/02se3UU0+NG264oVz5IiLOPPPMeOyxx6Kw8P9+HdzkyZPLnSfbVq9eHRdffHFiW506dWLYsGFxwQUXVCh3hw4d4uWXX47NN988pa1169Yxc+bMdZ5fU+e2sWPHxj//+c9S26+77roYP358HHLIIWs9f6Xp0qVLjB49Ov773/9G3bp118SnT58eixYtSkvNZZFL6+ZPlbbfrm577Vzfi+XquperdQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/KMx2AQAAAAAAAAAAAAAAAFDTvPLKKzFr1qzEtrvuuiuuuuqqqF27dplyFRUVxfnnnx/jx4+Pzp07r4nPmzcvfv/736el3lzxz3/+MzFeVFQUzz33XNx0003Rrl27Kq4qN9x5550xduzYxLYuXbrEhx9+GOecc06Zn6uIiJ122imeeeaZ+Nvf/haFhak/ivbWW2/FmDFjKlxzVciH+/L444/HiBEjEtsKCwvjlltuiXfffTcOPvjgMuXr0KFDPPDAAzFmzJho0aLFmviyZcviyiuvLHNd2TZ06NBYuXLlOo957bXXYs6cORXK/9RTT633mMGDB1cod1UyL2bPRRddFA888ECp7Y0aNYqbbropvvrqq7jjjjtiv/32i3r16q03b0FBQXTq1CmuuOKK+OSTT+Lxxx+P9u3bl3r8+PHj49BDD41Vq1ZV6DrW5913313r6wsvvDAmTZoURx11VBQUFKz3/J122imGDRsWI0aMiCZNmiQe88UXX1R4z5IP83y+GDBgQGL8scceiwULFlRxNREPPvhgrFixIiVeUFAQZ511VpXXk2lVPZ/PmDGj1L/ziIj+/fvH5MmT46STTirT+Nlhhx3iySefjNGjR0ezZs0Sj3n11VfjT3/6U0VLTovqcN25Pi9H2J/UdL/61a/ihBNOSGwbNGhQPPLII1Vc0Q/sGYzN9fGM5I/qsJ5H5PaabjxUL++9917ceeediW277757TJo0Ka666qrYcMMNy5374IMPjjfffDN23HHHxPYhQ4aUOVc6x3Ymx/WqVavi1ltvLbX9d7/7XTz99NPrfJfzoy5dusQzzzwTd91111rX9NZbb8XQoUPLXVsuGD58eNx3332JbbVq1YqBAwfG22+/HQcddFCZ8jVq1CiuvPLKeOeddxLvaUlJSfy///f/oqSkZL25aurcdv7558cbb7xRavuOO+4YTz/9dMyaNSseeuihuPLKK+PMM8+Mo446Kk455ZS47LLL4s4774ypU6fGO++8EwceeGBKjgEDBsSyZcsyeRk5vW7+qLT9dnXba+f6XixX171crQsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD4Qe1sFwAAAAAAAAAAAAAAAAA1zfLly+P666+PW2+9NaWtsLAwrrnmmhgwYEA8+OCD8fLLL8cnn3wS8+bNi2XLlkXTpk2jVatWsfXWW8fBBx8chx56aGy88cZr5SgpKYlTTjklZs6cWVWXVCXGjRsXr776anTv3j2lrU6dOnHZZZfFZZddFtOmTYuvvvoqFi5cGMXFxSnHzpgxI0499dQqqLhqHXPMMfHWW2/FZpttltLWsmXLuP322+P3v/99PPPMM/Hcc8/F119/Hd9//30sWbIkioqKonHjxrHZZptFx44d45BDDonddtut1L6mT58eRx99dOL9zTX5cF9OOumkePvtt2PrrbdObO/cuXM8++yz8d1338UzzzwTEyZMiBkzZsTcuXOjbt260aJFi9hxxx1jv/32i86dOyfmuOCCC+Lzzz8vV13ZNG/evHj++eejZ8+epR7z1FNPVTj/8OHD4/bbby+1fdWqVTF06NAK568q5sXsKSkpiVNPPTVWrVoVp59+eqnHtWjRIs4+++w4++yzY+XKlTFlypT4/PPPY86cObF48eIoKSmJ+vXrR5MmTWLzzTePbbbZJho3blymGt59993o0aNHzJ07N12XleK0006LN998M+rWrbsmts0228SQIUNi1qxZ8eyzz8Y777wT3333XcydOzcaN24cG220UbRv3z569uwZ22677TrzL126NPr16xcLFy6scI35MM/nulatWkXfvn0T2wYNGlTF1fxg9uzZMWzYsDjqqKNS2k477bS46qqrYuXKlVmoLDOyMZ8/8sgjseOOO8YVV1yR2N6uXbt48MEH4x//+EeMGjUq3nzzzfjuu+9i9uzZ0bBhwzVjvVevXusd659//nn069cvVq9eXabaMinfrzsf5mX7k5qrYcOG8fe//73U9hNPPDGOO+64tPb51VdfxQ477FCmY2v6nsHYXL+a/ozkk3xfzyNyf003HqqXCy+8MLp27Rq77LJLSlujRo3immuuiauuuipee+21eOmll+Kjjz6KL774IhYuXBhLliyJgoKCaNiwYTRr1iy22mqr6Ny5cxxyyCHRvn37UvscPnx4jBs3rlx1lndsDxs2LCvj+tZbb42+ffsmrqkREYccckj07NkzXn/99Rg1alR89dVXMXPmzCgoKIgWLVrETjvtFAceeGB06tQp5dzly5fH6aefHieeeGKFassFAwYMiG222Sb22GOPxPadd945Ro0aFTNnzozRo0fHe++9F99//33Mnj07IiKaNm0aW2yxRXTt2jUOOuigqF+/fql93XjjjfH888+XubaaOLetXLkyevbsGWPGjEmcA37UvHnzOOGEE8qd/7rrrothw4ZVpsQyyfV1M6L0/XZ13Gvn+l4sV9e9XK0LAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiKid7QIAAAAAAAAAAAAAAACgJrrjjjvi5JNPjs6dOye2t2nTJi677LK47LLLyp37sssui2HDhkXXrl0rW2bOOfnkk2P8+PHRuHHjUo/ZZJNNYpNNNim1/YsvvshAZdn3/fffR48ePeKFF16Itm3bJh6z0UYbxamnnhqnnnpqhfuZMWNGHHzwwfHVV19VOEdVyof7Mn/+/OjZs2c8//zz0a5du1KPa926dZx22mnlzn/bbbfFXXfdFXvvvXe5z82mwYMHR8+ePUttHz58eIVzf/311zF+/Pjo1KlTYvuLL74Yc+bMqXD+qmRezJ6SkpL41a9+FePHj49bbrkl6tatu87j69SpE9tvv31sv/32le773//+d5x33nmxZMmSSudalwkTJsQvf/nLePTRR6OgoGCttg033DBOOumkOOmkkyqUe+nSpXHEEUfE+PHjK1VjPszzue60006LOnXqpMSnTJkSr7zyShYq+sHdd98dRx11VEq8VatW0a9fvxgyZEgWqsqcbMznV155ZRQUFMTll19e6jFNmzaNY445Jo455phy5f7RpEmTomfPnjF79uwKnZ8J+Xzd+TAvR9if1FR169aN+vXrl9q+rraKatCgQZmPtWcwNtfHM5Jf8nk9j8j9Nd14qF5WrFgRvXr1ilGjRkWXLl0Sj6lTp07ss88+sc8++1S6v1mzZsXZZ59doXMzPbbTMa5Xr14dxx57bLz//vvRsmXLxGMKCwtjjz32iD322KPMeUtKSmLAgAHx4YcfVri2XLB8+fI45JBD4umnn44999yz1ONatmwZJ554Ypx44okV6mfQoEFx5ZVXluucmjq3zZs3Lw444IB44IEHom/fvmnL++c//zmuuuqqtOVbl1xfN3+0vv12ddpr5/JeLFfXvVytCwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIgozHYBAAAAAAAAAAAAAAAAUBOtWLEievXqFVOnTk1bzpUrV0b//v3jT3/6U9py5pqpU6fGEUccEfPnz892KTlpypQpsfvuu8ebb76Zkfzvvvtu7LLLLvHBBx9kJH+m5MN9+eyzz2LPPfeMd999N42VRdx0001xwQUXpDVnVRk6dGisXLkysW3y5MkxefLkSuUfNmxYqW1DhgypVO6qZF7Mvttuuy26detWJXPjrFmz4rjjjotf/epXsWTJkoz3F/HDeDjuuONi2bJlacs5Y8aMOOigg+LZZ59NS758mOdz2VlnnZUYHzRoUBVXsrYxY8bEV199ldg2YMCAKq4m87I1n19xxRVxxhlnxOLFi9Oe++mnn44999wzvv7667Tnrqx8vu58mJftT8hVNX3PYGyuX01/RvJNPq/nEbm/phsP1cusWbNi3333jaFDh2a0n2+++Sa6d+8e06ZNq3COTI3tdI7rb7/9Nvbaa6/47LPP0lBZRHFxcZx77rlx3333pSVfts2fPz969OgR//73v9Oeu7i4OG644YY488wzo6SkpNzn19S5bcGCBdGvX7/o379/zJ49u1K5Zs+eHSeeeGL85je/SVN1ZZPr62ZEzdtv5/JeLFfXvVytCwAAAAAAAAAAAAAAAAAAAAAAAAAAgP/P3p1HWVVeiQLfVRSTDAIqImJUBESiKCqgERURB9ToA7WNhjglahKTzmq1YyIO7fxMtNuYTtIxitoxRuMQojIEFESDI1FAEEHFCRWizHMBVe+PLHli3aKGe26dO/x+a2VF97lnf/ve803n3KoSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAUleedgEAAAAAAAAAAAAAAABQqhYvXhwDBw6MsWPHZp1r1qxZMWDAgLjzzjsTqCy/PfXUUzFgwIB47rnn0i4lLy1cuDAGDRoUo0aNirVr1yaSc+3atXH55ZfHgAEDYuHChYnkbGqF8Ll89NFHMXDgwLjuuutiw4YNWeX67LPP4pRTTomf/vSnWdeVlmXLlsXkyZMzHnv88cezzv+Xv/wlY3zz5s3x5z//Oev8Tcm8mL6ZM2fG/vvvH2eddVa8/fbbiedfvnx5jBo1KvbYY4946KGHEs9flz/96U9xyCGHxIwZM7LO9fDDD8dXv/rV+Nvf/pZ9YV9QCPN8PjrmmGOie/fuNeKbNm2K++67L4WK/r/q6uq49957Mx476qijokePHk1bUBNIaz6/++67Y7/99osJEyYkku+TTz6Jb33rW3HSSSfF8uXLE8mZC4X8vgthXrY/IV+V+p7B2KxbqfeRQlPI63lE/q/pxkNxWbVqVQwfPjxOP/30+OCDDxLNXV1dHffff3/0798/5s2bl3W+JMd2rsb1vHnzYsCAATF+/Pis8nz66adx/PHHx69//euEKssP69evj29/+9tx8sknx4IFCxLJ+c4778QxxxwTo0aNyipPKc9td955Z+yxxx4xatSoeOeddxp07j/+8Y+47rrrYu+9944HHnggRxVuW76vmxGlt9/O571Yvq57+VoXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlLLytAsAAAAAAAAAAAAAAACAUvbpp5/GSSedFKeffnr87W9/a/D5r776anzjG9+IAw44IGbMmJF8gXlq/vz5ccQRR8TAgQPjt7/9bcyaNSuqqqrSLitvbNy4MW666abYc88948Ybb4yFCxc2Ks+HH34YV199dey2227xs5/9LDZv3pxwpU2rED6XTZs2xTXXXBN77LFH3HbbbfHpp5826Px//OMfcd1110X37t3j8ccfT6yutPzpT3/KGP/LX/6Sde6///3v8cknn9SIT506NT777LOs8zc182L6qqur449//GP07t07hg0bFvfee28sX7680fk2btwY48aNi3POOSe+8pWvxE033RRr1qxJruAGmjlzZhx88MFxzjnnxNy5cxt07vr16+Phhx+OAw88MP7lX/4llixZkpMaC2Gezzff/e53M8bHjh0bixcvbuJqarr77rujurq6RrysrCwuuuiiFCrKvbTm83fffTeGDRsW/fv3jz/96U+xdu3aBueYMWNGXHTRRbHHHnvE/fffn4Mqk1fI77sQ5mX7E/JVqe8ZjM26lXofKTSFvJ5H5P+abjwUn0ceeST23HPPOP300+Opp56KDRs2NDrXsmXLYvTo0TFw4MD41re+FYsWLUqszmzHdlOM66VLl8YJJ5wQQ4YMiRdeeKFB5y5fvjx+/vOfR48ePWLSpEk5qS8fPPHEE7H33nvHN7/5zZg2bVrGe/y6zJw5My666KLYe++9Y/LkyYnUVcpz2+rVq+Omm26KHj16xIEHHhg/+MEPYvTo0fHUU0/FK6+8EnPnzo3XXnstnn322fj9738fP/3pT+PQQw+NXXbZJa655pqMa03Lli0ztrVp06bE68/3dTNi6/12Key1830vlq/rXr7WBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKWorLq6urpeLywry3UtQIHq27dv9O3bNyIiqqurY8GCBfHiiy9GPacXgLzQpUuXuPSyS9MugxIwbuy4mDJlStplAGStQ4cOMerKUWmXQZGbPHlyjB83Pu0yALLWqlWruP6G69MugyL32quvxQMPPJB2GQCJ+PmtP0+7BErA3DfmxujRo9MuAyARP3o0omWbtKugmC2cHfHAZWlXAUBtysrK4uCDD45evXpt+XnvWbNmxaxZs1KurDT5mVogSXvvvXcMGjQoDj300OjRo0d06NAhOnbsGM2bN49Vq1bF8uXLY+7cufHaa6/F2LFj4+2330675LzRpk2b2GWXXbb6zDJZt25dSf5M58EHHxyDBg2Kgw46KHbffffo3LlztGnTJioqKqKysjJWrlwZy5cvj3nz5sWcOXPi6aefLom9Rb5/LuXl5XHEEUfEoEGDYv/994899tgjtt9++2jbtm2sXbs2Vq5cGR9++GHMmDEjnn322ZgyZUpUVVU1WX3kN/Ni+po3bx77779/HHDAAXHAAQdEz549o3379rH99ttH+/bto7y8PFatWhUrV66MFStWxMKFC2PGjBkxY8aMePXVV2PlypVNUmdt9y7b+v3ifffdN0444YQ44IADolevXtG+ffto27ZtrF+/PlasWBGLFi2KWbNmxcsvvxwTJkyINWvW5Kr8bcr3eR7qI435vFWrVnHMMcfEgAEDom/fvrHrrrtu2YNs2LAhVqxYEUuXLo05c+bEzJkzY+LEifH+++8n0naa8uV9F/O8bH9Cvir1PYOxWbdS7yOFJF/W84jiXdONh+Ky3XbbxZFHHhl9+/aN3r17x1577RXt2rWLtm3bRps2baK6ujpWr1695fnFO++8s+V76WnTpsWmTZuapM4vj+0+ffrk3f3JbrvtFscdd1wMHjw4unbtGjvttFN06tQpNm3aFMuXL49//OMf8dprr8W0adNi/PjxUVlZ2eQ1pq1Lly4xePDgOOSQQ6JHjx6x2267Rdu2baN169ZRVVUVK1asiOXLl8ebb74Zr776akyePDnmzp3bJLWZ2xqnvLw8Nm/enPFYnz59GnT9inXdLLW9dj7txTLJ13UvX+sCKBRlZWXRv3//6Nmzp5+nBeotm5/x9rfagdr4vRJI1lFHHRUnnHhC2mXANvm7qQDZG3bCsBgyZEjaZUCtHnv0sXjhhRfSLgOgoJ111lnR78B+aZcBtbr77rvjzblvpl0GQEG75NJLYpdddkm7DNim2269LRYtWpR2GQAF7bv/G9G+c9pVQO1uHxFRuTbtKoC0+Fvt+cXP1AIAAAAAAAAAAAA0LX+rHWgMf6sdyAW/VwLkG3/vnrT4G/ZAKbHekgZrLVBK/HddSMO4seNiypQpaZcB0CSstaTFfxsNKCXH/CCi30lpV0GpmfjLiBlj064CoGn5W+35xc/UAgAAAAAAAAAAADQtf6sdaIz6/Ix3RRPUAQAAAAAAAAAAAAAAANTTvHnzYt68eXH33XenXUrBWbNmTbz99ttpl5G3pk+fHtOnT0+7jLyT759LVVVVPPPMM/HMM8+kXQoFyLyYvo0bN+b9PNNYs2fPjtmzZ6ddRp2K9fOntKQxn69fvz6eeOKJeOKJJ5q03bQV8vsulHnZ/oR8Vep7BmOzbqXeRwpJIa/nEYWxphsPxWXt2rUxfvz4GD9+fNqlbFMhjO0PP/ww7rrrrrjrrrvSLiVvLVq0KB588MF48MEH0y6lBnNb47Rv377WY0uXLs15+4WwbpbaXjvf5+t8XffytS4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoBeVpFwAAAAAAAAAAAAAAAAAAAAAAAAAAFI699947Y3zjxo2xePHiJq4GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABquPO0CAAAAAAAAAAAAAAAAAAAAAAAAAIDCccUVV2SM/+EPf2jiSgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgccrTLgAAAAAAAAAAAAAAAAAAAAAAAAAASF6bNm0Sz7nrrrvGiSeemPHYX//618TbAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBcKE+7AAAAAAAAAAAAAAAAAAAAAAAAAAAgOeXl5XH11VfHW2+9FZ07d040909+8pNo1qxZjfj69etjwoQJibYFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALlSnnYBAAAAAAAAAAAAAAAAAAAAAAAAAEAydtttt5g6dWpce+21scsuu8Rjjz0WrVq1SiT30UcfHRdffHHGYw899FAsX748kXYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAINfK0y4AAAAAAAAAAAAAAAAAAAAAAAAAAMje8OHDY9asWTFo0KAtscMOOywmTpwYO+64Y1a5hwwZEo8++miUlZXVOLZp06a48cYbs8oPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE2pPO0CAAAAAAAAAAAAAAAAAAAAAAAAAIDs9erVKzp06FAjfvjhh8ecOXPivPPOi+bNmzcoZ6dOneKmm26KCRMmxPbbb5/xNb/4xS/irbfeakzJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJCKirQLAAAAAAAAAAAAAAAAAAAAAAAAAACyd+utt8bw4cNj4MCBNY517tw5Ro8eHf/3//7fePLJJ+PZZ5+N+fPnx8KFC2PNmjWxYcOGqKioiE6dOsUOO+wQ/fr1iyFDhsSJJ54Y7dq1q7XN1157La644opcvi0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASFxF2gUAAAAAAAAAAAAAAAAAAAAAAAAAANnbvHlznHTSSfH8889Hz549M76mc+fOcf7558f555+fdXsLFiyIE044ISorK7POBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABNqTztAgAAAAAAAAAAAAAAAAAAAAAAAACAZHz22WdxxBFHxPPPP5/TdqZPnx5f+9rXYtGiRTltBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAByoTztAgAAAAAAAAAAAAAAAAAAAAAAAACA5CxatCgGDx4c11xzTaxduzbR3Bs2bIibbropDj300Fi8eHGiuQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgqZSnXQAAAAAAAAAAAAAAAAAAAAAAAAAAkKyNGzfGddddFz179owbb7wxPv7446zyrVixIn7xi19Er169YtSoUbFp06aEKgUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACApleRdgEAAAAAAAAAAAAAAAAAAEB6ysrK0i4BgC8wLwNAcbCmA5BPPv7447jyyivj6quvjgMPPDAGDx4c/fv3j+7du8cee+wR7du3jxYtWmx1zrp16+Kjjz6Kd955J/7+97/HlClTYurUqbFx48bE67NuAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJCGirQLAAAAAAAAAAAAAAAAAAAAAAAAAAByq6qqKqZPnx7Tp0+vcaxZs2bRsmXLqK6ujvXr10d1dXUKFQIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABA06lIuwAAAAAAAAAAAAAAAAAAAAAAAAAAID2bN2+OtWvXpl0GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADSZ8rQLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgKZSnnYBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0FTK0y4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmkp52gUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAUylPuwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABoKuVpFwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABNpTztAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKCpVKRdAAAAAAAAAAAAAAAAAAAUgzZt2kSHDh2iWbNmGY9/8MEHTVwRAEDy7HkACkva83ba7QM0hrkLAADqZt8MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUg4q0CwAAAAAAAAAAAAAAAABoar/61a+iT58+NeLf+9734s0330yhotyYMmVKxvhRRx3VxJUUn7322itOPPHEOPLII2PgwIHRuXPnaN68+TbPKSsra6Lq2BbjonC4VtB4xg9JsecBklQq9+JpSnveTrt9gMYwdwFA4yT1DNKzTCgM9s0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECxqki7AAAAAAAAAAAAAAAAAICmduCBB8YhhxxSI96+ffsUqsmdwYMHp11C0enTp09cffXVcfrpp0d5eXna5dAIhTguWrRokTFeWVnZxJU0rUK8VpAvkho/pTr/YM8D5Eap3IunIe15O1ftl8pepFTeJ+nRxzJLe+4EgLQktTdI6hmkZ5mQ3+ybAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAYleedgEAAAAAAAAAAAAAAAAAUAjOOOOMePXVV+OMM86I8nK/nkfT6NWrV2zYsCHj/3r16pV2eUARM/+ULnsegMKS9rydq/ZLZS9SKu+T9OhjmaU9dwJAWop1b1Cs7wvSZt8MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUgvK0CwAAAAAAAAAAAAAAAACAfHfRRRfFH//4x2jZsmXapQAA5Iw9D0BhSXveTrt9gMYwdwEAQN3smwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgFJRkXYBAAAAAAAAAAAAAAAAAJDP9ttvv/jFL34RZWVldb528+bNsXHjxiaoCgAgWfY8AIUl7Xk77fYBGsPcBQAAdbNvBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASklF2gUAAAAAAAAAAAAAAAAAQD679957o2XLlhmPffbZZ/HrX/86xo4dG3Pnzo1Vq1Y1cXUAUFgOO+ywuPLKK2vEn3vuubjppptSqIjP2fMUBmMI+Fza83ba7UNTsv4WD3MXAADUzb4ZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoJRVpFwAAAAAAAAAAAAAAAAAA+erII4+MAw88MOOxSZMmxWmnnRYrV65s4qoAoHDtvPPOcfzxx9eIr169OoVq+Jw9T+EwhoCI9OfttNuHpmb9LQ7mLgAAqJt9MwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUGoq0i4AAAAAAAAAAAAAAAAAAPLVD37wg4zxefPmxcknnxzr169v4ooAAJJnzwNQWNKet9NuH6AxzF0AAFA3+2YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKDUVKRdAAAAAAAAAAAAAAAAAADkqyFDhmSMX3755bF+/fomroZStH79+pg+fXqtxwByxfxTWux5AApL2vN2U7RfKnuRUnmfpEcf+//SnjsBIB8U696gWN8XpMG+GQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKDUVaRcAAAAAAAAAAAAAAAAAAPlon332iU6dOtWIL1myJJ544okUKqIUffDBB9G/f/+0ywBKkPmndNjzABSWtOftpmq/VPYipfI+SY8+9k9pz50AkC+KdW9QrO8Lmpp9MwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUIrK0y4AAAAAAAAAAAAAAAAAAPJRnz59MsZfeumlqKqqauJqAAByw54HoLCkPW+n3T5AY5i7AACgbvbNAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAKSpPuwAAAAAAAAAAAAAAAAAAyEedOnXKGF+wYEETVwIAkDv2PACFJe15O+32ARrD3AUAAHWzbwYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEpRedoFAAAAAAAAAAAAAAAAAEA+6tixY8b4ihUrmrgSAIDcsecBKCxpz9tptw/QGOYuAACom30zAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQisrTLgAAAAAAAAAAAAAAAAAA8lGrVq0yxisrK5u4EgCA3LHnASgsac/babcP0BjmLgAAqJt9MwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUIrK0y4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmkpF2gUAAAAAAAAAAAAAAABAvmjdunW0bt061q5dG+vXr89JGxUVFdGuXbtYv359rFu3LidtZKtly5bRpk2bqKysjNWrV6ddzjZ9Xuu6devy9vPMpF27dlFRURHLli1Lu5TENWvWLNq1axdlZWWxevXq2LhxY9olFa1CGqvF5vPPPpfrRb5o2bJllJeXF9Qc+0WldK2y4XPKrc/3mFVVVbFixYqorq5OuyQoCPk+dux7C0e+96UvK4R1uVDvxZP2+b29OaB4NW/ePNq2bRtVVVWxcuXKvJ8/GquQ+nIhzJFsm2uYWSGNw6ZSSJ9JofTrfF/XCumaJ6FQn+8XSn/PhVx/j1wI3yGzbYU6riPyd2yX4vO3Qu5HAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAhaoi7QIAAAAAAAAAAAAAAAAgKX369KkRW7x4cSxZsiTj64cMGRJnnHFGHHroobH33ntHixYtthzbtGlTfPDBBzFjxoyYPHlyPPzww/GPf/yjwTX169cvzjrrrPja174W++23X7Rr127LsbVr18ann34as2bNivHjx8e4cePi/fffb3Ab2dh3333jlFNOiQEDBkTfvn1j1113jebNm285Xl1dHcuWLYs5c+bErFmzYuLEiTFx4sRYv359k9YZEbHrrrvG8OHD44gjjoj9998/9thjjxrX7L333ttS55gxY2Lx4sVNXucXtWzZMo477rg47rjjYv/994999tknOnbsGGVlZRERUVlZGe+//37Mnj07nn/++RgzZky8/fbbqdbcEAMGDIijjz46BgwYEAcccEDsuOOO0bZt261eU1lZGR999FHMnj07XnvttXjyySfjlVdeSanirXXq1Cm6dOlS6/Gdd9651nim+aYub7zxRoPP+Vy+jNWGzrMR/xwHffv2jR49esT2228f7dq12zIGIiLuuOOOVOaU+urYsWOccsopMWzYsOjbt2/stddeW332n8/lc+fOjUmTJsXEiRNj9uzZidZQW3/Lpk9l0rVr1zjttNNi0KBB0a9fv/jKV76yZZ7dvHlzfPzxxzFnzpx4/vnn4/HHH4+ZM2dmzFNRURGdOnWqEV+6dGls2rQp0Zq/KB+uVSGoaz3duHFjfPjhhzFz5syYOnVqPPzww/Hxxx9nzNW6devYc889a8QXLFhQ73HduXPn2HHHHWvE65pbGqqsrCz22WefGvGqqqp48803E2mjefPmcdRRR8Xxxx8fffv2ja9+9aux0047RbNmzba8prq6OpYvXx5Lly7d8hlPnTq11vGUtsbMPzvuuGN07ty51uNf+cpXMsa33377Bq+vlZWVW+2dunbtGh06dKjxujVr1uRsn11RURG9evWqEU+yb2Ur3/c8hTB2mnLfm+YYKnT50pcasmfu1KlTnH766TFkyJDo169f7L777luty/mwfynEe/Gk1XVvH5Hs/X3a83ba7X9RU90LRUQccMABcdJJJ8XBBx8c++23X+y6667RsmXLLcerq6tj5cqV8cYbb8Tf//73GDduXEycODE2b96cddtN9T7r25fHjh2bk+dUDX2m0JRzZLGvv0n1sXy+hvk0d21LU68pmeTb8720P5N87tfZSHNdq0va1zwNhfp8v1D6e33l2/fIaX6H3JT77KbUlO8rX8Z1RPGM7UL/3rkx0upH29o758u+GQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoCmVVVdXV9frhWVlua4FKFB9+/aNvn37RkREdXV1LFiwIF588cWo5/QCkBe6dOkSl152adplUALGjR0XU6ZMSbsMgKx16NAhRl05Ku0yKHKTJ0+O8ePGp10GQNZatWoV199wfdplUORee/W1eOCBB9IuAyARP7/152mXQAmY+8bcGD16dNplACTiR49GtGyTdhUUs4WzIx64LO0qAKhNWVlZHHzwwdGrV68tP+89a9asmDVrVsqVlSY/Uwv5I9O4u/zyy+NnP/vZVrHjjjsubr/99ujdu3e9c2/evDn+93//N6666qr46KOP6nz9IYccErfffnsMHDiw3m1UVVXFAw88EFdeeWW8//779T6voZo3bx7nnHNOXHbZZbH33ns3+Pw1a9bE/fffH7fccku8++67Oahwa4cffnhcddVVMXTo0Ab9ntOmTZvi/vvvj2uvvTbee++9rY698MILccghh9Q4Z+DAgfHyyy9nW3Lstttu8dOf/jS+9a1vRdu2bRt07iuvvBI33XRTjBkzJus6aluLsvl9sebNm8d3v/vd+O53vxt9+vRpVI6FCxfGHXfcEb/97W9j5cqVja4lW5dcckncdtttTdLWxx9/HLvuumuDzsnHsVrfeba8vDxOP/30uOCCC+LII4+MioqKWnPusMMOsXTp0kTqq4/6jovOnTvHlVdeGRdeeGG0bNmyQW0899xzcfXVV8czzzzT2DK3koux/EUDBgyI66+/Po455pgG5Zw+fXpcf/318fjjj28VP+KII2Lq1Kk1Xt/QObYQr1U+a+x6Wl1dHX/+85/jyiuvjLlz5251LIlrffPNN8dPfvKTGvFMc0s2tttuu1izZk2N+OrVq6Ndu3ZZ5e7SpUtcdtllccEFF0T79u0bleOVV16Jm2++OcaMGZPIvWRS80Zj8lx99dVx7bXXNqidxnruuefiiCOO2PLv3/72t+Ouu+6q8brly5dHly5dYsOGDYnXcNppp8XDDz9cIz5+/Pg44YQTEm+vMfJ1z5OPY+eL0tr3pjmGClW+9aX67Jm7du0a1113XZx99tnRvHnzBuVvqv1LId6LJy2be/uIxt/fpz1vp93+F+X6Xmi77baLCy64IH70ox/Fnnvu2eDzP/3007j99tvjv/7rv2LdunWNriPX7zOfn1Nl2venMUcW+/qby/uDfLmG+TR3ZZLWmpJJvjzfy/YzGT58eNHPTQ2VL+tabfJpHDSFQn6+Xwj9vTHy5XvkfPgOOc1nh4WQpzb5OK4jCntsF9P3zvWVD/2oqfbOjdk3Q2OVlZVF//79o2fPnn6eFqi3bL4P8rfagdr4vRJI1lFHHRUnnJgfP38FtfF3UwGyN+yEYTFkyJC0y4BaPfboY/HCCy+kXQZAQTvrrLOi34H90i4DanX33XfHm3PfTLsMgIJ2yaWXxC677JJ2GbBNt916WyxatCjtMgAK2nf/N6J957SrgNrdPiKicm3aVQBp8bfa84ufqQUAAAAAAAAAAABoWv5WO9AY/lY7kAt+rwTIN/7ePWnxN+yBUmK9JQ3WWqCU+O+6kIZxY8fFlClT0i4DoElYa0mL/zYaUEqO+UFEv5PSroJSM/GXETPGpl0FQNPyt9rzi5+pBQAAAAAAAAAAAGha/lY70Bj1+Rnv8iaoAwAAAAAAAAAAAAAAAPJCs2bN4pe//GVMmDAhevfu3eBzzzvvvJgzZ06ceOKJtb6uvLw8br311nj++edj4MCBDWqjvLw8Ro4cGfPnz49zzz23QefW17HHHhtvvfVW/O53v4u99967UTnatGkTF110Ubz11lvxn//5n9GqVauEq/ynnXbaKR577LF49tln45hjjtnyC5b1VVFREeeee27Mnj07vv/97+ekxi9r3rx53HjjjfHOO+/E9773vWjbtm2Dc/Tv3z/+/Oc/x3PPPRfdu3fPQZWNd9hhh8WMGTPijjvuiD59+jQ6T7du3eJnP/tZvPfee3HOOeckWGH+mjdvXoNeX0hj9ct69+4dL774Yjz44INx9NFHR0VFRZO0m6Thw4fHG2+8ET/84Q+jZcuWDT7/8MMPjylTpsQjjzwSbdq0yUGFyWjXrl3cf//98dJLL8Wxxx7b4Hn24IMPjr/85S/x6KOPRqdOnXJU5baVyrXKRrbraVlZWYwYMSJmzZoVV1xxRYPPL2ZlZWVx2WWXxbvvvhuXXnpptG/fvtG5+vfvH4899lhMmzYtdtlllwSrLG5z5szZ6t8ffPDBWL16dY3XdejQIU4++eSc1DBy5MiM8dGjR+ekvXxXnz1PIYydUtn3fnkMFZpC6EuZnHXWWTF//vz49re/Hc2bN2/w+bnevxTivXjSkri3j8jv+/vPNfRetZjaP/PMM+O9996L22+/Pfbcc89G5dhpp53ixhtvjLfeeiuGDBmScIXZK8TnVPk+Ryah0NffupTCNWzI3FWoa0oun+8l9ZmYm7aWz+taoY6DbBTy8/1C6O+5kuvvkfP9O2S2rZDHdUR+ju1Sef72RYXejxoq7WcOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA9VWedgEAAAAAAAAAAAAAAADQFMrLy+PRRx+NH/zgB1nl2X777eOJJ56Ib3zjGzWOtWjRIsaOHRuXXnpplJWVNbqNFi1axD333BNXXXVVNqVupby8PH71q1/FX//619h9990TydmsWbP4t3/7t5g1a1b07t07kZyfGzBgQMyePTuGDx+eda42bdrEr371q7jzzjujvDx3v1LVrVu3ePnll+OKK66I5s2bZ51v0KBBMWvWrDjxxBMTqC5755xzTkydOjX69OmTWM6OHTvGvffeG4899li0bNkysbz5aN68efV6XaGN1S8bOHBgvPDCC9G/f/+ctpNLP/7xj+Oxxx6LHXbYIetcp556arz44ouxxx57ZF9Ywvr06RMzZ86Mb37zm1nnGjFiREybNi122WWXBCqrv1K5VtlIcj2tqKiIG2+8McaMGRMtWrRIoLrC1r59+5g8eXL8/Oc/j1atWiWW99BDD41XX301Bg4cmFjOYjZnzpyt/n3NmjXxxz/+MeNrzz333MTb79ChQwwbNqxGfOnSpfH4448n3l4hqGvPUwhjp5T2vV8eQ4WkEPpSJjfccEP84Q9/iDZt2mSdKxf7l0K8F09a0vf2Efl3f/9F9b1XLab2W7duHY888kg88MADsdNOOyWSc9ddd41JkybFj3/840TyJaEQn1Pl+xyZlEJef+tSKtewvnNXoa4puXy+Z25Kvl/n+7pWqOOgsQr9+X6+9/dcyvX3yPn8HTLbVujjOiI/x3YpPX+LKI5+1BhpP3MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACor/K0CwAAAAAAAAAAAAAAAICm8Jvf/CZOOeWURHKVlZXFfffdFwMHDtwq/uCDD8bxxx+fSBsREdddd12MHDky6zytWrWKv/zlL/H9738/gapq6tmzZzz//PNx2GGHJZLvyCOPjKeffjo6d+6cSL7PXXDBBfHb3/420Zyf+/wzOOCAA+r1+k2bNsW6devqfF2bNm1izJgxccYZZ2RZYXbOO++8uOeee6JZs2b1ev26deti7dq1UV1dXa/XDx8+PP76179Gy5Ytsykzr82bN6/O1xTaWP2y7t27x4QJE6JDhw45yd8ULr744rjlllsSzbnvvvvGxIkTo127donmzcb+++8fU6dOjT333DOxnL17946nn3462rRpk1jObSmVa5WNXK2nJ598cowZMybKy0v315Q7duwYzzzzTAwePLher6+qqoo1a9bEpk2b6vX6Ll26xJNPPhm77bZbFlWWhjlz5tSI3XnnnRlfe9xxx0WXLl0Sbf/000+PFi1a1Ig/8MADUVlZmWhbhWJbe55CGDultu/NNIYKQSH0pdqMGjUq0XxJ7l8K8V48abm6t4/In/v7L6vPvWoxtd+pU6d45pln4tRTT008d3l5edxyyy2Jj/PGKMTnVKNGjcrrOTJJhbr+1qWUrmF95q5CXVNy+XzP3PRPSfbrfF/XCnUcNFahP9/P9/6ea7n+Hjlfv0Nm2wp9XEfk59gutedvxdCPGivtZw4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD1VZF2AQAAAAAAAAAAAAAAAJBrI0aMiAsvvLBGfMGCBXHffffF1KlT4/3334/169dHp06dYpdddokhQ4bEaaedFr169cqYs0WLFnH33XfHAQccEJs2bYpLL700hg8fXuN1y5cvjwcffDDGjRsXb775ZqxatSratm0bO++8cxx88MExfPjwOPLII2ut/de//nVMmzYt3n333Ua//9///vdx0kkn1Xq8qqoqXnjhhXjiiSfilVdeiUWLFsXSpUtju+22i5133jl69OgRJ5xwQhx//PHRoUOHjDk6duwYY8eOjUMPPTTmzp3b6Fr32muvGDNmTLRt27bW12zYsCEmT54c48aNi1mzZsXixYtj+fLl0bJly9hhhx1iv/32i6FDh8Ypp5wS7du33+rc73znOzFz5sxG15dJp06dYuLEibHbbrvV+ppZs2bFQw89FBMnTox33nknli1bFhERXbt2jYMPPjiOPfbY+OY3v5nx862oqIj77rsv3nvvvXjppZcSrb0+unfvHv/93/8dZWVlGY9//PHH8cADD8Rf//rXmD17dvzjH/+IqqqqLcc7deoUvXr1ikGDBsWpp54ahxxySMY8Rx55ZNxxxx1x0UUX5eR9ZPLJJ5/Eiy++WOvxbt26Rbdu3WrEFy5cGAsXLmxQW9OnT6/zNYU0Vr+sWbNm8dhjj9XabiE45JBD4he/+EWNeHV1dTz77LMxZsyYmD59enz00Uexdu3aaN++fey0007Rr1+/OOGEE+K4446LZs2aZczds2fPuO+++2LEiBG5fht16tKlS0yYMCF23HHHWl+zfv36mDx5cjzxxBMxd+7cePPNN6NNmzax8847x+677x7Dhg2LE088MXbYYYetzttnn33iN7/5Tdx11105fQ+lcq2yUZ/1tLKyMiZPnhxjx45t8Ho6bNiwuPnmm2Ps2LG5fit56Q9/+EP069ev1uPPPfdcPPLIIzFt2rSYP39+rFq1asuxdu3axZ577hmDBw+Os88+Ow466KCMOXbcccd49NFH47DDDouNGzcm/h5yaeHChdtcX3fYYYfo2bNnjfjSpUtj/vz5DWpr9uzZNWLTp0+PmTNnxv77779VvFmzZvHNb34zbrvttga1sS0jR47MGB89enRibSQhX/Y8+T528mXfm/YYKgT53pdqM3To0BqxfNm/FOK9eNKyubdv0aJF7Ljjjond36c9b6fdfq60aNEinnjiiRgwYECtr9m8eXNMmzYtxo0bF9OnT4/FixfHkiVLoqysLLbffvvo2bNnHHHEEXHmmWdG165dM+a44YYb4u23346HHnooV29lm5Loy1dccUWTPqcaOnRoXHfddTXiTTlHWn+zkw/XMJ/mrnxaUxoil8/3cv2ZFOvctC35vq4V6jjIRiE/38/3/p5rufweed99983r75DZtkIe1xH5Obbz5flbU8rHfrStvXOh3vMDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABko6y6urq6Xi8sK8t1LUCB6tu3b/Tt2zciIqqrq2PBggXx4osvRj2nF4C80KVLl7j0skvTLoMSMG7suJgyZUraZQBkrUOHDjHqylFpl0GRmzx5cowfNz7tMgCy1qpVq7j+huvTLoMi99qrr8UDDzyQdhkAifj5rT9PuwRKwNw35sbo0aPTLgMgET96NKJlm7SroJgtnB3xwGVpVwFAbcrKyuLggw+OXr16bfl571mzZsWsWbNSrqw0+ZlayB+Zxt21114bF1xwQXTt2nVLbNWqVXHppZfG3XffHVVVVbXmKy8vj4svvjh+/vOfR8uWLTO+5qKLLoqnn3463njjjWjRosVWtdx+++3xH//xH7Fy5cpt1n3MMcfE7373u9h9990zHn/sscfi1FNP3WaO2lx11VVx3XXX1Xp8woQJ8eMf/zhef/31OnO1adMmLrnkkvjxj38cbdu2zfiad999Nw444IA633MmFRUV8fe//33LnPplmzdvjtGjR8e1114bH330UZ352rVrF//6r/8aV155ZbRq1WpLfO3atbF06dLo1q1bjXMGDhwYL7/8coPqnjRpUgwdOjTjsQ8//DAuueSSeOSRR+rM0759+7j88svjJz/5SZSXl9c4vnDhwujdu3esWbOm3rXVthY15PfFHn/88fj6179eI15VVRVXX3113HrrrbFhw4Z65/va174Wv/nNb2q9zscee2xMmjSp3vly6eqrr45rr722Rvyaa67Z5rhqjEIZq5n61OWXXx4bNmyI22+/vcaxZcuWxV/+8pd48skn4/XXX4/FixfHihUrGtRm0mobF6+//nrst99+W8XGjh0bl19+ecyZM6fOvH369Ik77rgjjj766Fpf8y//8i/x8MMPN6zgSGYsf/76Z599NgYNGpTxeFVVVdx9990xatSo+PTTT7eZq0WLFvFv//ZvceWVV9boZ1deeWXccMMNNc5p6BxbiNcqH9S1nlZVVcW9994b//Ef/xEffvhhnflqW0+rqqri8ssvj5//vOb3vA251jfffHP85Cc/qRG//PLL42c/+1m9ctTHdtttl3ENXb16dbRr167eeX74wx/GHXfckfHYq6++Gt/73vca1M9HjBgR99xzT7Rv3z7j8QsvvDB+97vf1Tvf55KaN5LK80UjRoyIRx99tEb8kUceidNPP73Reb/o4osvjv/+7/+uEZ89e3aN+aOxunXrFh988EGNz2LmzJlxwAEHJNJGU2mKPU8hjJ1C2fc2xRjKZ4XQlzLNnddcc02cf/75W93358v+pVDvxZOW1L19RG7u77+oKe9V024/yb3I3XffHeeff36txx955JEYNWpUzJ8/v85cFRUV8YMf/CBuuummaN26dY3jK1asiH333TcWLlxYr9qSfJ+F9pwq0/wYkT9z5OcKff3N5f1BoVzDppy78n1NSeP5Xi4+kyuuuKLGsVKam/J5XYvI/3GQtEJ+vl8I/T0paXyP3KNHj7z8Djnfnh3mW56IwhnXEYU1tgvl+VtSCqkffS7tZw7QWGVlZdG/f//o2bOnn6cF6i2bn/H2t9qB2vi9EkjWUUcdFSeceELaZcA2+bupANkbdsKwGDJkSNplQK0ee/SxeOGFF9IuA6CgnXXWWdHvwH5plwG1uvvuu+PNuW+mXQZAQbvk0ktil112SbsM2Kbbbr0tFi1alHYZAAXtu/8b0b5z2lVA7W4fEVG5Nu0qgLT4W+35xc/UAgAAAAAAAAAAADQtf6sdaAx/qx3IBb9XAuQbf++etPgb9kApsd6SBmstUEr8d11Iw7ix42LKlClplwHQJKy1pMV/Gw0oJcf8IKLfSWlXQamZ+MuIGWPTrgKgaflb7fnFz9QCAAAAAAAAAAAANC1/qx1ojPr8jHd5E9QBAAAAAAAAAAAAAAAAqfn2t78dXbt23fLv7733Xhx44IHxu9/9LqqqqrZ5blVVVfzyl7+M008/PTZt2pTxNf/2b/8W119/fbRo0WJLbN26dXHiiSfGJZdcEitXrqyzxkmTJsWRRx4ZH330Ucbjp5xySnTr1q3OPF+27777xlVXXZXx2KZNm+Kiiy6KYcOGxeuvv16vfGvWrIkSIDHWAAEZFElEQVTrr78+9t9//5g7d27G1+y5557xs5/9rMG1RkT86Ec/2vIfw/iyZcuWxbHHHhsXXnhhrZ/Tl61atSpuvPHG6NevX7z77rtb4tttt12jPs9MRo4cGUOHDs14bNq0aXHQQQfFI488Uq9cK1eujFGjRsWJJ54Yq1atqnG8W7duce2112ZVb0PttNNOMWzYsIzHzjzzzLjxxhtjw4YNDcr5/PPPR//+/eOxxx7LePy6665rcJ2FrtDG6pdtt912ceWVV24V27BhQ9xyyy2x5557xnnnnRePPvpozJ8/P1asWJFIm7mw3377bfnnzz/3k046KebMmVOv899444049thj45577qn1NT/+8Y+zrjMb3/nOd2LQoEEZj61evTqGDh0aF154YXz66ad15qqsrIxbbrkl+vbtGwsWLNjq2E9+8pNE6q1NKVyrbGxrPV2xYkUMGzYsvv3tb8eHH35Yr3y1rafl5eVx9dVXJ1JzoWjfvn1cc801GY/df//9MWDAgHj55ZcblPOxxx6Lww47rNb58d///d+3/JEJ6u/++++PdevW1Yjvu+++0a9fv0TaOOusszJem9GjRyeSv5gUwtix7y0MhdCXavOd73wndt9994jIv/1LId6LJy3Je/uI/Ly/L3VDhw6N888/P+OxdevWxemnnx6nn356zJ8/v175Nm3aFLfffnt87Wtfy3j/tP3226dyjQvxOdUX58eI/JsjqZtruLVCXVNy+XwvV59JKc9N+b6uFeo4aKxCf76f7/0913L9PXK+fofMthX6uI7Iz7Fdas/fiqEfAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlIrytAsAAAAAAAAAAAAAAACAXOrWrduWf16yZEkcddRR8fbbbzcoxxNPPBG33XZbxmO9e/eOM888c8u/V1VVxYgRI2L8+PENauP999+Pc845J+OxZs2axXe/+90G5YuI+J//+Z9o3rx5jfjGjRvjhBNOiDvvvLPBOSMiFixYEAMHDowXX3wx4/ELL7wwBgwY0KCcHTp0iGuuuSbjsaVLl8bAgQNj8uTJDa41IuLNN9+Mww47LBYuXNio82vTqlWr+NnPfpbx2MyZM2Po0KHx6aefNjjvhAkT4uyzz8547Ic//GHsvPPODc7ZWF//+tejoqKiRvyhhx6KP/3pT43OW1lZGWeccUa88MILW8UnTZoUV199daPzFqpCGquZnHnmmbHjjjtu+ffPPvsshgwZEj/5yU9ixYoVWedvalVVVXHGGWc06nOvqqqK888/P5599tmMxw8++OA44ogjsi2xUdq2bRs33XRTxmOrVq2Ko446KqZMmdLgvO+++24MGjQo3nnnna3aagrFeq2ysa31dPny5XHooYfGxIkTG5U703rarl27RuUqVM2bN48//vGPsX79+q3i48aNi29961uxefPmRuWdPXt2XHzxxRmP9ezZM4YNG9aovKVsxYoV8cgjj2Q8dt555yXSxsiRI2vENm7cGH/4wx8SyV9MCmHs2PcWhkLoS7XZbbfdIiL/9i+FeC+etFzd20fk1/19KSsvL49f//rXGY+tXbs2Bg8eXOu+oS4zZsyIoUOHxtq1a2scGzBgQLRo0aJReRujUJ9TfT4/RuTfHEn9uIb/XyGvKbl6vpfLz6RU56Z8X9cKeRw0VqE/38/n/t4Ucv09cr5+h8y2Ffq4jsjPsV1qz9+KoR8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUivK0CwAAAAAAAAAAAAAAAICmcs4558R7773XqHNvuOGGWLp0aZ2vu+WWW2LChAmNauPpp5+u9dzjjjuuQbkOP/zwOOywwzIe+/d///eYNGlSg+v7olWrVsWpp54a//jHP2ocKysriyuuuKJB+c4///xo165djXh1dXWMHDky3nrrrUbXGhHxySefxKmnnhqbN2/OKs8XnXXWWbHLLrvUiK9cuTKGDx8e69evb3TuMWPGxF133VUj3qJFi7j44osbnbeh9tprr4zx++67L+vcmzZtivPOOy/WrVsXv//972P//fePY489Nuu+WWgKbaxm0qtXry3/vHz58jj00EPj+eefzzpvWq655pp47LHHsspx7rnnxsaNGzMeO+WUU7LK3VjnnHNO7LjjjhmP/eu//mtMnz690bk/+eSTGDlyZKJzbH0U67XKRm3raUTEeeedF3Pnzs0qfy7W00KyZMmS+OEPfxh77rln3HbbbbFmzZpYvnx5nH322Vnn/sMf/hCvv/56xmNHH3101vlL0Z133pkxftZZZ0VFRUVWuffdd9/Yb7/9asSfeOKJWLJkSVa5i1EhjB373sJQCH2pLvm2fynEe/Gk5fLePiJ/7u9L2YgRI6Jnz54Zj33/+9+Pl19+Oav8s2bNiksuuWTLv7/88ssxfPjw6Nu3b1RWVmaVuyGK4TlVvs2RNFypX8NCXlNy9XzP3PRPSfbrfF/XCnkcNEYxPN//onzr700t198j58t3yGxbsY3riPwZ26X0/K0Y+xEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAxK0+7AAAAAAAAAAAAAAAAAGgKf/nLX2Ls2LGNPn/16tXx6KOPbvM1H330UVx//fWNbiMiYvTo0Rnj+++/f7Rs2bLeeS677LKM8aeeeip+8YtfNKq2L/v444/jggsuyHjs5JNPjp49e9Y71/e+972M8XvvvTfGjx/fqPq+7OWXX47f/va3ieSKiPjBD36QMX7HHXfEu+++m3X+m2++OaqqqmrEzz777Kxz11fXrl0zxt95551E8s+bNy923nnnOPvss2PWrFmJ5Cw0hTZW63L++efH22+/nVi+pjZz5sy4+eabs87z7rvvxpgxYzIeGzRoUNb5G+Piiy/OGB8/fnzce++9Wed/8cUX45e//GXWeeqrmK9VNmpbTx944IFa32dDJb2eFqJFixbFZZddFrvvvnucfPLJsWTJkkTy1va5Hn744YnkLzV/+9vf4s0336wR32GHHeLEE0/MKvfIkSMzxmvby/NP+Tx27HsLSz73pbrk2/6lEO/Fk5bre/uI/Li/L2U/+tGPMsYff/zxuO+++xJp484774zf/OY3MXjw4Bg4cGCMGTMmqqurE8ldX4X+nMo9XuFzDYtnTUny+Z656Z+S7Nf5vq4Vyzior2J6vp+P/b0p5fp75Hz6DpltK6ZxHZFfY7uUnr8VWz8CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoduVpFwAAAAAAAAAAAAAAAABN4frrr886x6OPPrrN47fffnusW7cuqzaefPLJqKysrBFv3rx59OvXr1452rVrF8OGDct47Oabb86qvi97/PHHY86cOTXiZWVlcdppp9UrR69evaJHjx4Zj912221Z1fdlN9xwQ2zatCnrPF/5ylcyXo+1a9fGf/3Xf2WdPyJiwYIF8dRTT9WI77777rHPPvsk0kZdWrZsmTFeXV2dWBurVq1KLFehKbSxWpc///nP8ec//zmRXGm56qqrYvPmzYnkuueeezLGDzzwwNhuu+0SaaO+evXqVeu8ceONNybWzm233ZbY51eXYr1W2djWenrrrbcm2lZS62mhW7JkSTz33HOJ5Zs8eXLGeL9+/aJZs2aJtVNKfve732WMn3vuuVnlPfPMM2vEFi1aFBMmTMgqb6nIx7Fj31uY8rEv1SWf9i+FeC+etKa4t4/Ij/v7UtW5c+c47LDDMh675ZZbEmunuro6vv/978fUqVMTy9kQxfCcyj1e4Sv1a1gsa0qSz/fMTVtLol/n+7pWLOOgvort+X6+9femluvvkfPlO2S2rdjGdUR+je1Sef5WjP0IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACg2JWnXQAAAAAAAAAAAAAAAADk2syZM+Pvf/971nm2laOqqiruu+++rNtYt25dvPnmmxmP7bnnnvXKceyxx0bz5s1rxGfPnh2TJ0/Oqr5Mbr/99ozxr3/96/U6/9hjj80Yf/bZZ2POnDmNLSujTz75JJ588sms8xxzzDEZ40899VQsXbo06/yfe+aZZzLGBw8enFgb27J8+fKM8fr2Rbat0MZqY/MXivfffz+eeOKJxPJNmzYtqqura8QrKipi9913T6yd+jj++OMzxmfOnBnTpk1LrJ2FCxfG2LFjE8tXm2K+VtmobT198cUX47XXXku0raTWU7b25ptvxurVq2vEKyoqomPHjilUVPjuu+++qKysrBE/8cQTY8cdd2xUzsMPPzy+8pWv1Ij//ve/j82bNzcqJ9lJYuzY9xKR+3n4/fffzzrH55LYvxTivXjSmurePiL9+/tSdfzxx0dZWVmN+GuvvRbPP/98ChXlRqE/p3KPV/hcw+JZU5J8vmdu2loS/Trf17ViGQf1VUzP9/OxvzelXH+PnE/fIbNtxTSuI/JvbJfK87di60cAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACloDztAgAAAAAAAAAAAAAAACDX/vrXvyaS57PPPotPP/0047EZM2bUeqyh5syZkzHeoUOHep1/1FFHZYxPmDChsSVtU215Bw4cGC1btqzz/IEDB2aMT5kyJau6ajNu3LiscwwaNChjPKm+9rkXX3wxY/yrX/1qou3U5pNPPskYP/PMM5uk/WJXaGN1W95888149tlns8qRtieffDLRfCtXrox33nkn47GOHTsm2lZdDj300IzxpN9zrnLmuo18ulbZGDBgQMb4008/nZP2klhP2Vp1dXWta2+nTp2auJrisGTJkhgzZkyNePPmzRu9nxk5cmTG+D333NOofGQvibFj30tE7ufhJPcwSexfCvFePGlNdW8fkf79fak6/PDDM8ZzcY3TVOjPqdzjFT7XsDjWlKSf75mbtpZEv873da0YxkFDFNPz/Xzs700p198j59N3yGxbMY3riPwb26Xy/K3Y+hEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEApKE+7AAAAAAAAAAAAAAAAAMi1559/PrFcixYtyhh/6aWXct5Ghw4d6nV+nz59Msb/9re/NbakbVq4cGF8+OGHNeLl5eWx995713l+ba954YUXsq4tk+eeey7rHL17984YT7rmTz75JGO8V69eibZTm9r6zNlnnx2nn356k9RQzAptrG7LM888k9X5+eDZZ59NPGemzzsiolOnTom3tS21zVnTpk1LvK0k18Pa5OO1Ovzww+P1119P/H/77bdfvd9DIa6n1LRixYqM8aaeN4rJnXfemTF+7rnnNjhX8+bN47TTTqsRf+mll2Lu3LkNzkdysh079r18LpfzcNJ7mGz3L/YOTXdvH5H+/X2p2meffTLGk3xWmA8K/TlVPt7j0TCuYXGsKUk/3zM31ZRtv873da0YxkFDFNPz/Xzs700p198j59N3yGxbMY3riPwb26Xy/K3Y+hEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEApqEi7AAAAAAAAAAAAAAAAAMi1t956K7Fcq1atyhifP39+ztvo0KFDvc7fZ599MsZfffXVxpZUp7///e+x2267Zaxl1qxZ2zy3Z8+eGeN1nddY77zzTlRVVUV5eXmjc/Tq1Stj/P333290zkyWLVuWMd6xY8dE26nN3/72t1iyZEnssMMOW8XLy8vjoYceipNOOin+8z//M2bOnNkk9RSbQhur2/LSSy9lU1ZemDt3buI5V6xYkTFe3/k8KT169MgYf+211xJva/bs2VFZWRktWrRIPPfn8vFatWvXLvbdd98EK/qn1q1b1/u1ta2nM2bMSKiarSWxnvJPXbp0ib322iu6d+8enTp1yviaXI6pYvf000/HggULonv37lvFDzzwwNh3331j9uzZ9c41bNiwjNdo9OjRWddJwyU5dux7S1tTzcNJ72Gy3b8U4r140prq3j4i/fv7UrX33ntnjOfiXihNhf6cKh/v8WgY17A41pSkn++Zm2rKtl/n+7pWDOOgIYrp+X4+9vemlOvvkfPpO2S2rZjGdUT+je1Sef5WbP0IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgFFSkXQAAAAAAAAAAAAAAAADk2scff5xYrtWrV2eML1q0KLE2Vq1alTFeXl5er/N32mmnjPFPP/200TXV5bPPPssY33HHHes8d/vtt88YX7JkSVY11Wbjxo3x8ccfR7du3Rqdo2PHjjVi69ati6VLl2ZTWg219bd27dol2k5tNm7cGDfffHPceuutNY6VlZXF2WefHWeffXYsXLgwXnnllZgzZ068/fbbW/63ePHiJqmzUBXaWN2WmTNnZnV+Pvjoo48Sz7ly5cqM8frO50koLy+Ptm3bZjxWW3/IRlVVVSxdujS6dOmSeO7PFeu1ylaHDh0yxnNxnSOSWU9LRcuWLWOPPfaIvfbaK7p37x49evSI7t27b/lf69at0y6x6N11111x00031Yife+65cdlll9U7z8iRI2vE1q1bFw8++GBW9ZFZU44d+97ili/zcNJ7mGz3L4V4L560prq3j0j//r5UderUKWM8l/fdaSj051Tu8Qqfa1gca0rSz/fMTTVl26/zfV0rhnHQEMX0fD8f+3tTyvX3yPn0HTLbVkzjOiL/xnapPH8rtn4EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQCirSLgAAAAAAAAAAAAAAAABybc2aNYnlqqqqSq2N+mjdunU0a9asRnzDhg2xfv36bMrapmXLlmWMt2vXbpvnbbfddlFWVlYjvmHDhqisrEyktkxWrVrV6HNrq7l169axbt26bMqqIVM7EREtW7ZMtJ1t+eUvfxnDhw+Pww47rNbXdOvWLbp16xbDhw/fKr5mzZp455134u23346333473nrrrZg5c2bMmjUrNmzYkOvS81qhjdW6LFmyJKvz80E280JtspnPk1LbtV29enVs2rQpJ20uX748unTpkpPcEcV7rbJR29pUWVmZ0/k2F9eikHXt2jUOOuig6Nu3b/To0SO6d+8ee+21V3Tt2rXWNZ2mcc8998R1110XFRVb/3r9N7/5zfjxj39crzmgXbt28fWvf71G/M9//nOsXLkysVpLUb6MHfvewpcvfak2Sa+b2exfCvFePGlNeW8fkR/396Vmu+22i/Ly8hrxDRs2FNXcXAzPqdzjFb5Sv4bFsqYk+XzP3JRZtvu3fF7XimUc1FexPd/Pt/7e1HL9HW++fIfMthXbuI7Iz7Fd7M/firEfAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlIKKtAsAAAAAAAAAAAAAAACAXNu4cWPO26isrMx5G/XRpk2bjPGVK1fmtN1ly5ZljLdv336b56VV75o1axp9bm01R0S0atWq0XnzVWVlZZxyyikxadKk6NevX4PObdOmTfTt2zf69u27VXzTpk0xderU+MMf/hAPPvhgrFu3LsmSC0KhjdW6rFixIqvz80FTrBVpaNmyZcZ4NvNgXXLdj4v1WmWjtjkl12Mzl/2oUHz1q1+Ns88+O84444zYfffd0y6HWixatCjGjRsXJ5988lbxLl26xHHHHRfjx4+vM8eIESMy7vVGjx6dWJ2lJB/Hjn1vYcrHvlSbfNrDFOK9eNJK7d6+FKXVz5taMfTlfJofaZxSv4bFMA4jkn2GUAyfSb7163xf14rhmjdEsT3fz7f+3tRy/f7z5Ttktq3YxnVEfo7tYn/+Voz9CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoBRUpF0AAAAAAAAAAAAAAAAAFIPq6uq0S4iIiPLy8ozxzZs357Td2vKXlZVt87zajue63k2bNjX63LreUzFasmRJHHroofGf//mfcdFFF0WzZs2yyldRURFHH310HH300XHDDTfElVdeGffcc09C1RaGQhurdVm5cmVW59P0crluVVVV5Sx3vlqxYkVMnz498bxr1qyp1+sKcT0tdLvvvnvcfPPN8Y1vfKMk9waF6M4774yTTz65Rvzcc8+N8ePH13n+yJEja8Q++OCDmDx5ciL1lYp8Hzv2vYUj3/tSvrN3KM17+1KTVj9vavoypK9YxmGSz/eK5TPJJ/m+rpXaNS+25/vkVr58h8y2GddNp5ifv+lHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAhaki7QIAAAAAAAAAAAAAAAAAyH8bNmyIiy++OH7xi1/ET3/60xgxYkS0b98+67xdu3aN0aNHxzHHHBPnnXdebNiwIYFqaWrV1dVpl0Atars25eXlOWuzefPmOcudr6ZNmxb9+/dPuwyayNChQ+Phhx+ODh06NDrH0qVL46233oq33nor5s2bt+Wff/WrX8UhhxySXLFsMX78+Fi4cGF069Ztq/gpp5wSHTp0iOXLl9d6bpcuXWLIkCE14vfdd581sAEKZezY9+a/QulLAACFxL0NANBUPH8DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgn1SkXQAAAAAAAAAAAAAAAACQnM2bN2eMV1Tk9leJmjdvnjFeWz11Ha8tX1KyyV9dXZ0xvnz58njwwQcbnbchlixZ0iTtZDJ//vw477zz4qKLLorBgwdH//7946CDDorevXtH9+7do2XLlo3Ke+aZZ0a7du3i61//esIV56dCG6sUrrVr12aMt2/fPmdtdujQIWe5yayqqipjPK05JR+VlZUlkmfYsGHxxBNPRLNmzep87erVq2P+/Pkxf/78eOutt7b6/2XLlmU8Z/369YnUSU1VVVVxzz33xFVXXbVVvGXLlnHGGWfEb3/721rP/cY3vhHl5eVbxaqrq+Oee+7JSa3FqBDHjn1vfirEvpSPCvFePGn5cG8fke79fbFLa4/c1PKhL+vHlLp8GIcR+TUW8+EzyafPIwn5vq7lwzWPaLrr7vk+FB/jOh3F9vxNPwIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAChMFWkXAAAAAAAAAAAAAAAAACRn9erVGeMdOnTIabudOnXKGF+5cuU2z1uzZk3G+Pbbb591TdvSpk2bRp+7fv36jPHVq1fH9773vUbnLTSVlZUxceLEmDhx4pZYWVlZdOvWLXr06BE9evSInj17bvnnHj16ROvWrbeZ86STToorrrgibrrpplyXn7pCG6sUrjVr1kR1dXWUlZVtFW/VqlW0atWq1jktG7nux9RU25ySz+tpU6trDaqPPfbYIx544IFo1qxZxuNLliyJRx99NCZNmhSvvPJKvP/++w1u48tjlWTdddddMWrUqCgvL98qfu6558Zvf/vbWs8bOXJkjdizzz4b7777buI1FqNCHzv2vfmj0PtSPinEe/GkubcvfrVd41z386amL0P6jMOafCbJy/d1rdSuuef7UHyM63QVy/M3/QgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAwVaRdAAAAAAAAAAAAAAAAAJCcDRs2xKZNm6KiYutfHaqoqIg2bdrEmjVrctJux44dM8ZXrVq1zfPWr18fVVVVUV5evlW8oqIitttuu1i7dm1iNX7R9ttv3+hz165dG9XV1VFWVrZVvFOnTtmWVfCqq6vjww8/jA8//DCmTJmy1bGysrLo2bNnHH/88fHd73439tlnn4w5fvrTn8b//M//xNKlS5ui5NQU2lilsH322Wex00471Yh36dIl3nvvvUTbatOmTa39jNypbT1t3rx53q6ndWnWrFmi+dq1a5d1jptuuik6dOhQI7569er46U9/GnfeeWdUVlZm1Ubbtm2zOp9t++CDD2LSpElx3HHHbRU/5JBDolevXjF//vwa5/Tq1SsOOuigGvHRo0fnrM5iU4xjx743HcXYl9JSiPfiSXNvX/xqu8bNmzeP1q1bx7p161KqLFn6MqTPOKzJZ5K8fF/XSu2ae74Pxce4zj+F+PxNPwIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAChM5WkXAAAAAAAAAAAAAAAAACTro48+yhjv0qVLztqsLfeiRYvqPHfx4sUZ4zvvvHNWNdWmVatWWX0Wmzdvjk8//bRGfLvttotWrVplU1pRq66ujvnz58cdd9wRX/3qV+Paa6/N+Lq2bdvGd77znSauLh2FNlYpXPPmzcsYHzBgQOJtHXzwwVFe7tdX0/DZZ59ljHfu3Dkn7WW7nn5u8+bNGePt2rXLOvcX7bbbblmdv8cee8QZZ5xRI75hw4YYOnRo/Pd//3dUVlZm1UZExI477ph1DrbtzjvvzBg/99xzM8ZHjhxZI7Zq1ap45JFHkiyraJXi2LHvzY1S7Eu5Vmj34klzb1/8qqqqmryfp0FfhvQZhzX5TJKX7+taKV5zz/eh+BjXhSOfn7/pRwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIWnPO0CAAAAAAAAAAAAAAAAgGS98cYbGeMDBw7MWZsDBgzIGJ8zZ06d586fPz9j/OCDD86qptr06tUrysrKssrxwQcfZIzvu+++WeUtFdXV1fEf//Ef8etf/zrj8eOOO66JK0pHoY1VCtfcuXMzxgcNGpR4W7nsv2xbbevpQQcdlJP2evfunfV6GhGxbNmyjPH27dtnnfuL9t5776zOP+GEE6K8vOavZv/617+Ol156KavcnysvL4/OnTsnkovaPf7447F48eIa8W9961sZ+/RZZ51VI/anP/0p1q5dm5P6ik2pjx373uSUel/KhUK8F0+ae/vi9/7772eM52qPnBZ9GdJnHNbkM0levq9rpXbNPd+H4mNcF6Z8e/6mHwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABSe8rQLAAAAAAAAAAAAAAAAAJI1e/bsjPFBgwblpL299947dthhhxrxDRs2xDvvvFPn+fPmzcsYP/TQQ7OuLZMjjzwy6xyvv/56xvjAgQOzzl1Krr766ti0aVONeP/+/VOopukV2lilcE2ZMiVjfMSIEdGsWbNE2zrrrLMSzUf91baefu1rX8tJe4MHD04kz7JlyzLG99xzz0Tyfy7b9f+II47IGH/wwQezyvtFBx10ULRu3TqxfGS2adOmuO+++2rEu3XrFkOGDNkqNnDgwNhrr71qvHb06NE5q6/YGDv/VOr73iToS8krxHvxpLm3L34zZszIGM9VP0+LvgzpMw5r8pkkL9/XtVK75p7vQ/Exrgtbvjx/048AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKT3naBQAAAAAAAAAAAAAAAADJmjRpUsb4SSedFM2aNUu8vf/zf/5PxvjUqVNj8+bNdZ7/3HPPZYwPGzYsm7Jq9fWvfz3rHC+//HLG+ODBg7POXUqWLFkSM2bMqBFv165dtGjRoukLamKFNlYpXJMmTYrq6uoa8V133TVGjBiRWDuHHHJI7L///onlo2H+9re/ZYwff/zxOWnvlFNOSSTP0qVLM8YPPPDARPJHRFRUVMSxxx6bVY5ddtklY3zu3LlZ5f2iIUOGJJarEOVi7avN7373u4zxc889d6t/HzlyZI3XvPXWW/H888/noqyiZOz8U1Pse5tyDKVBX0peId6LJ829ffF76aWXMsZPOOGEJq4kt/Tl9BT7+kv9GYc1+UySl+/rWqldc8/3ofgY14UtX7531o8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKT3naBQAAAAAAAAAAAAAAAADJmjp1aqxZs6ZGfLfddovTTjst0baaN28e//qv/5rx2OOPP16vHJMmTcoY7927dwwdOrTRtWXSvXv3RHJOnDgxY/zkk0+OnXbaKev8+ahLly45yfvxxx9njHfo0CEn7eWTQhurFK7PPvssnnrqqYzHrrnmmmjRokUi7Vx//fWJ5KFxalub+vTpE0cffXSibfXu3TsGDx6cSK433ngjY7xLly7Ro0ePRNo49dRTs16fO3bsmDG+fv36rPJ+rry8PC644IJEcuW7TGtfRES7du2arIa33347nnnmmRrxESNGRNu2bSMiolmzZvEv//IvNV4zevToXJdXVApx7OT7vjcfxlAaCrEv5btCvBdPWine25eaCRMmZIzvs88+ie+R06Qv516prr/Un3FYk88kefm+rpXaNfd8H4qPcd108v35Wzb0IwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMJTnnYBAAAAAAAAAAAAAAAAQLIqKyvjoYceynhs1KhR0bx588TauvDCC6Nr16414hs2bIiHH364XjkWL14czz//fMZjV1xxRVb1fdn1118fZWVlWedZsGBBvP766zXiLVq0iAsuuCDr/J/bfvvto0uXLonla4xu3brFb37zm3j//ffjlFNOSTx/ixYtMsbXrVuXeFv5ptDGKoXtl7/8Zcb4V7/61bjx/7F332FSlef/gJ9dmvRiQBQRVBALoqCACNjoy6JoQuwFY9doNBpNsHw19q6JDUuMXVRAEBAERVQ0ioiIFcUGCiJdkLr7+yOX/IIzC7s7szs7cN/XxRV43nOe97Oz73vOnAmL11yTcv/TTjstunfvnnIfSu+7776Ld955J+lYuu+n1113Xdp6ffbZZ7FgwYKkYyeddFLK/StXrhz/93//l3KfZcuWJa03bNgw5d4REUcffXTsvPPOaelV0S1atChpvVmzZuWa4/7770+o1ahRIwYMGBARET169IhGjRptMF5QUBCPPPJIueTbXGTT3smW970VZQ+Vt2xaS9kiG5/F0628nu0jKsbz/Zbo+++/jzfeeCPp2F//+te0znXaaafFXnvtldaexbUlfU6VKVvq/Zfic09J5NqUfhX9vral7QOf78Pmx74ue9ny+VsqrCMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDsk5vpAAAAAAAAAAAAAAAAAED63XzzzVFYWJhQ33PPPeP2229Pyxxt27aNm2++OenYI488Ej/88EOxe911111J6wcffHD8+c9/LlW+X+vdu3ccc8wxaekVEXH//fcnrQ8aNChatmyZljluu+22+PTTT+Pcc8+N3Nzy/XGw7bffPu6+++744osv4owzzoiqVavGnXfeGQ0aNEjrPC1atEiorVixIpYtW5bWeSqqbNurZK8XXnghpk+fnnTsggsuiFNOOaXUvXv06JG29Upq/vnPfyatH3LIIXHBBRekZY7f/e530b9//7T0+sXkyZOT1k899dSoV69eSr3/9re/xa677ppSj4iIH3/8MWm9U6dOKfdu0qRJ3HbbbSn3yRZz5sxJWm/ZsmVss8025Zbjueeei4ULFybUTzrppIiIOO644xLGxo0bF999911ZR9usZMPeybb3vRVlD5W3bFhL2Sgbn8XTrTye7SMy+3y/pbv33nuT1rt16xbnnXdeWubYd99945577olp06bFyJEjo0OHDmnpWxKb++dUmbal3n8pGfeURK5N6VfR72tb2j7w+T5sfuzrspFtn7+lyjoCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADILrmZDgAAAAAAAAAAAAAAAACk38cffxxDhgxJOnbWWWfF+eefn1L/li1bxrBhw2KrrbZKGFu5cmVcf/31Jer3zDPPxDfffJN07Prrr49+/fqVKucvdt9993jiiSdS6vFrDz74YMyfPz+hXqNGjXj88cejZs2aKfU/5ZRTYuDAgVGnTp244447YurUqdGpU6eUepbEvffeG2eeeWZUrVp1fW2HHXaIZ555JqpXr56WOTp06BAtWrRIqM+ePTst/bNBtu1VsldhYWGce+65Scdyc3Pj/vvvj0GDBkVubsl+9PSoo46KkSNHpu26QGqeeuqpmDNnTtKxG264IeX76T777BP/+te/UuqRTFHXwUaNGsVtt91W6r6HHXZYXHHFFaU+/3999tlnSeunn356Sn1r1KgRzz77bDRs2DClPtlkzpw5Rd7rzzrrrHLLsWrVqnjssccS6l27do3WrVtH//79E8YeeuihEs1RpUqV+Mc//lHkry1BNuydbHvfW557qCKt4WxYS9koG5/F062sn+0jMv98v6V78sknY+bMmUnHbrrppsjLy0upf+PGjeOZZ55Z/yyVn58f//nPf+Kll16KRo0apdS7JDb3z6kyraK8h6Vic09J5NqUfhX9vral7QOf78Pmx74uG9n2+VuqrCMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDskpvpAAAAAAAAAAAAAAAAAEDZOO+882LJkiVJx2699da49957o2rVqiXu26NHj3j77bejWbNmScevvPLKmDVrVol6rlmzJi644IKkY5UrV47hw4fHRRddVOKsERHdunWL1157LerXr7++NmfOnFL1+l8rVqyIK664IulY+/btY9KkSdGoUaNS9T733HPjvvvu26C21157xRtvvBG9evUqVc+Suuyyy6KwsDChfsghh8SECROiadOmKfWvV69ePPjgg0nHxowZk1LvbJNNe5Xs9uqrr8a9995b5PjVV18d77//fuTl5UVu7sZ/BLVdu3Yxbty4ePLJJ6NatWrr699//3389NNPactMyaxevTr+/Oc/Jx1L9X562GGHxcSJE6NWrVqpREzqqaeeiu+++y7p2EknnRTXXnttiXueeuqp8eyzz26wlj/77LNSZxw7dmzSeo8ePeIPf/hDqXput9128frrr8d+++23vjZ16tRS9co2EydOTFq/5JJL4oADDii3HIMHD06o5eTkxBNPPBE1a9bcoL5o0aJ4/vnnS9S/SpUqcc455xT5a0uQDXsnG9/3ltceqkhrOBvWUjbKxmfxdCvLZ/uIivF8v6Vbt25dke+Rq1SpEiNGjIjzzjuvVL133XXXmDRpUjRv3jxhrHHjxjF//vxS9S2Nzf1zqoqgoryHpeJyT0nk2pR+Ff2+tiXuA5/vw+bHvk6/bPz8LVXWEQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQPbIzXQAAAAAAAAAAAAAAAAAoGzMmzcvzjjjjCLHTz/99Pjss8/iuOOOi8qVK2+y3x577BHDhg2LcePGRb169ZIe8/rrr8dNN91UqrzPPfdcvPDCC0nHcnNz48Ybb4ypU6dGr169itVv1113jUceeSReeumlaNCgwfr6ypUr49JLLy1Vxl+755574tVXX0061q5du5gxY0acddZZxXp9IyL23HPPGDNmTNxxxx2Rm5v441/vvPNOvPTSSyllLq733nsv7rnnnqRjnTp1io8++iguu+yy+M1vflPi3r169Yq33347WrdunXT8mWeeKXHPbJZte5Xsdu6558Z//vOfIsdbt24do0aNih9//DEef/zxuPTSS+N3v/tdnHjiiXHxxRfHPffcE19++WW8++670aNHj4TzzzjjjFi5cmVZfglswtNPPx2jR49OOlaa++lee+0Vzz77bAwfPjxq1aq1vr5w4cKYNWtWWjKvXbs2brvttiLH//rXv8aoUaOiZcuWm+zVrl27GDNmTAwePHiDa+Y777wTw4cPL3XG1157LX788cekY4MHD47LLrus2Pf7qlWrxrnnnhvvv/9+tG3bdn198eLFcfnll5c6Yza59957k9arVq0a48ePj+uvvz6aNWtW5jk+/PDDeOuttxLqe+65Z0LtiSeeiNWrV5d5ps1NNuydbHzfW1H2UHnKhrWUrbLxWTzd0v1sH1Gxnu+JGDlyZDz88MNJxypVqhS33357TJkyJXr27FmsfrVq1YpLL7003n333aTvUQsLC+NPf/pTFBYWphK7xDbnz6kqgi3x/kvJuackKqvXJFtfj3So6Pe1LW0f+HwfNj/2dfpl4+dvqbKOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAskflTAcAAAAAAAAAAAAAAAAAys5TTz0VrVu3jkGDBiUdb9asWTz66KPxz3/+M8aOHRtvv/12zJ07NxYsWBA1a9aMbbbZJlq2bBl9+vSJVq1abXSuWbNmRf/+/WPdunWlznvcccfFlClTokWLFknH27ZtGy+++GLMnTs3xowZE9OnT4958+bFokWLolq1atGgQYNo3bp1HHzwwdG2bdukPc4777yYNWtWqTP+2u9///t45513YocddkgYa9iwYdx1111x+eWXx5gxY2L8+PHx7bffxg8//BArVqyIrbfeOnbYYYdo06ZN5OXlxX777VfkPN9//30MGDAgCgoK0pZ9U84///zo0KFD7LvvvgljtWrViquuuiouu+yymDx5ckycODE+/vjj+Oqrr2LZsmWxYsWKyMnJiZo1a0a9evVi5513jrZt20ZeXl60bNmyyDlHjhwZb7zxRll+WRVStu1VsteaNWuid+/e8dJLLyXd27+oX79+HHPMMSXqffXVV8eIESNSjUgaHHvssTFlypTYeeedk45v6n669dZbx5577hk9evSIPfbYI2mPM888M84///zYaaed0pL5tttui8MOOyy6dOmSdDwvLy969+4db731VowdOza++eabmD9/fuTk5ESDBg3W591rr70Szl21alWcfPLJceyxx5Y636pVq+Kaa66J2267LWEsNzc3rrrqqjjjjDPi0UcfjUmTJsWnn34aixcvjpUrV0bdunWjUaNG0aJFi+jVq1f07ds3tt122w16FBYWxoknnhjz588vdcZs8sYbb8Trr7+e9PtdpUqVuPjii+Piiy+OOXPmxDfffBPLli1L+h5o3rx5cdJJJ6WUZfDgwRt9D/aLhx56KKV5tlTZsney7X1vRdpD5SVb1lK2ysZn8XRL5dm+atWqUbt27Qr9fE/EGWecEbvsskvsv//+Scf32WefGDt2bMyfPz/GjRsX7733Xvzwww+xYMGCiIioW7du7LjjjtGhQ4fo2bNnVK9evci5rrvuupgwYUKZfB2bko61nJ+fbx0nsSXefykd95RE5fWaZMvrkQ4V/b62pe0Dn+/D5se+Tr9s+/wtHawjAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA7FA50wEAAAAAAAAAAAAAAACAsnXppZdGTk5O/O1vfyvymLp168bvf//7+P3vf1+qOT766KPo3bt3LFiwoLQxIyJiyZIl0bt375gwYUI0a9asyOMaN24cAwcOLHH/O++8MwYPHhwHHHBAKjE38MMPP0T37t3j5Zdfju233z7pMdtss02cdNJJcdJJJ5Vqjnnz5kWvXr3im2++SSFpya1evTr69OkTY8eOjXbt2iU9pkqVKnHggQfGgQcemPJ8P/74Y5x55pkp98lW2bRXyW6LFy+Obt26xSOPPBKHHXZYWnrefPPNcdlll6WlF6lbvHhx9O7dO8aPH18m99Mrr7wyhgwZEueff34qMTewbt26OPLII2PatGnRsGHDpMfk5ubG/vvvH/vvv3+x+xYWFsYZZ5wRM2bMSDnj3XffHSeccEK0bds26fh2220XF198cVx88cUl7n3xxRfHiBEjokOHDqnGzBonnHBCvP/++1G7du0ij2nSpEk0adKkyPGvvvoq5RxPP/103H777VGnTp0ij/nggw9i6tSpKc+1pcqGvZON73sryh4qT9mwlrJVNj6Lp1t5PNtHZO75nohVq1ZFXl5ejBo1Kjp37lzkcQ0bNoxjjz02jj322FLN88ADD8Sll15a2pgp25w/p6oItsT7LyXnnpLItSn9Kvp9bUvcBz7fh82PfZ1e2fj5WzpYRwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABVfbqYDAAAAAAAAAAAAAAAAAGVv0KBBccopp8Ty5cvT3nvUqFHRuXPn+Pbbb9PS74svvojOnTvH1KlT09LvF9dff32cd955ae35i5kzZ0anTp3i7bffTnvvqVOnxr777hsffPBB2nsXx48//hgHHXRQDB8+vEznmT17dnTp0iXmzJlTpvNUdNm0V8luS5cujf79+8fpp58eCxYsKHWfBQsWxLHHHhsXXXRRGtORDp9//nna76eFhYXx17/+Nf7v//4vbT3/13fffRddu3aNL774Ii39CgoK4pxzzomHH344Lf1Wr14dffr0iS+//DIt/SIi1qxZE6effnrcdNNNaeuZLb788ss44ogjYsmSJRnNsWLFinjyySc3esxDDz1UTmk2T9myd7LtfW9F2UPlKVvWUrbKxmfxdCvLZ/uIzD/fE7FkyZLo3r17mdzbCwoK4tprr41TTz01CgsL096/JDbnz6kybUu8/1I67imJXJvSr6Lf17bEfeDzfdj82NfplW2fv6WLdQQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCx5WY6AAAAAAAAAAAAAAAAAFA+Hnzwwdhzzz3jxRdfTEu/77//Po4//vjIz8+PxYsXp6XnL+bMmRMdO3aMq666KlatWpVSrx9//DEOO+yw+Otf/5qmdMnNnj07unTpEoMGDYoVK1ak3G/FihVx8cUXR4cOHWL27NlpSFh6y5Yti8MPPzwGDBgQ33zzTVp7FxYWxmOPPRbt27ePTz/9NK29s1U27VWy3+DBg6N58+YxaNCg+OKLL4p93g8//BBXXXVVtGrVKp544okyTEgq0nk//fbbb6N3795x/fXXpyldcp9++ml06NAhxowZk1Kf+fPnR+/evePuu+9OU7L/mjdvXnTs2DFGjRqVcq/p06dHhw4dYvDgwWlIlp3Gjx8fHTp0iNdeey2jOTb2PVizZk089thj5Zhm85Qteyfb3vdWlD1UnrJlLWWrbHwWT7d0P9tHVKzneyJWrlwZf/jDH+LQQw+NWbNmpaXnF198ET169IhBgwalpV86bM6fU2Xalnj/pXTcUxK5NqVfRb+vbYn7wOf7sPmxr9Mr2z5/SxfrCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoOLKzXQAAAAAAAAAAAAAAAAAoPx8+eWX0adPn2jfvn0MGTIkVqxYUeIe06ZNi9NPPz2aN28ejz32WBmk/K+1a9fGFVdcEc2bN49bbrkl5s+fX6Lzf/jhh7jqqqtip512ihEjRpRRyg2tWbMmrr322thxxx3jmmuuidmzZ5e4x7fffhuXX355NG3aNG688cZYt25dGSQtnWeffTZ23HHHGDBgQIwfPz5WrVpV6l6LFi2Khx56KDp27BjHH398zJ07N41Js1827VWy308//RTXXntttGjRItq1axfnnHNOPPTQQzF+/Ph455134r333otJkybFo48+Gn/961+jU6dOse2228YVV1wRCxYsSOhXrVq1pPOsXbu2rL8Ukkj1fvr999/HRRddFLvttluMGzeujFJuaOHChZGXlxeHHHJIvPnmmyU6d/HixXHTTTdFixYt4qWXXiqTfPPnz4/8/PwYMGBAvP766yU+f+rUqXHUUUfF3nvvHdOmTUt/wCzz2WefxQEHHBAdO3aM++67L6ZPnx4FBQXlmmHq1Knx3nvvJR0bNWpU/Pjjj+WaZ3OVTXsnm973VoQ9VN6yaS1lo2x8Fk+3dDzbR1Ts53siRo4cGa1atYpjjz023njjjSgsLCxxj/fffz9OP/30aNWqVbz88stlkDI1m/vnVJm0Jd5/KR33lETpek02l9cjXSryfW1L3Ac+34fNj32dftn0+Vu6WEcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVU05hYWFhsQ7MySnrLECWatOmTbRp0yYiIgoLC2PWrFnx1ltvRTEvLwAVQuPGjePPF/450zHYAoweNTpeeeWVTMcASFm9evVi0KWDMh2DzdzLL78cY0aPyXQMgJRttdVW8fer/57pGGzm3pv6XjzxxBOZjgGQFjfdfFOmI7AF+Pijj+Ohhx7KdAyAtDjvuYhqNTOdgs3Z7BkRT1yY6RQAFCUnJyf23Xff2GWXXdb/fe/p06fH9OnTM5xsy+Tv1ALZbKuttooePXpEhw4dok2bNtGkSZOoW7du1KpVK1atWhVLliyJhQsXxocffhjvv/9+jBs3Lr7++uuMZM3NzY0DDjggunTpEnvttVc0b958fdYVK1bE0qVL49tvv41p06bFpEmT4pVXXomCgoKMZP1f++67b3Tp0iX22WefaNasWTRq1Chq1qwZlStXjh9//DEWL14cn376aXz44YcxYcKErLqf16hRIw488MBo06ZN7LrrrrHzzjtH7dq1o1atWlGzZs0oLCyMn376KZYtWxZLly6NL774Yv17ljfeeCPWrl2b6S8ha2TTXmXLlpubG+vWrUs6tvvuu8fHH39czon4tY3dT3/++edYunRpfPnll/HBBx/EuHHjYvLkyUU+27z55pux3377JdQ7duwYb7/9dtoyN23aNHr16hUHHXRQbLfddtGwYcNo0KBBrF27NhYvXhw//PBDvPfee/HGG2/EmDFjYvXq1WmbuzhatWoVXbp0iU6dOkWLFi2iXr16Ub9+/ahSpUosW7YsFi9eHB9//HG89957MWrUqPj888/LNV82qlmzZmy77bYbvJbJ/Pzzz2n7WZ3x48dHt27dEuqHHnpojBw5Mi1zvPLKK3HQQQet//OW/jP82bR3su19b1ntoYq6hrNpLWWjbH0WT7eNPduvXr06li5dmtXP9/z3580POuig2G+//aJFixbRtGnTqFWrVlSvXj0KCgpiyZIlsXjx4vjkk09i6tSp8fLLL2fl801x1vJ//vMf67gUMvEeluzknpLIa5J+Ff2+tqV9z32+D5sf+zr9su3zt3SwjiB9cnJyon379tGyZUt/nxYotlT+jndF+f/IgIrHz5VAeh188MGR1zcv0zFgo/y7qQCp65PXJw455JBMx4AiDX1uaLz55puZjgGQ1Y455pho265tpmNAkR588MH45ONPMh0DIKtd8OcLYtttt810DNioW26+JebOnZvpGABZ7YxHIuo0ynQKKNrtR0SsXpHpFECm+LfaKxZ/pxYAAAAAAAAAAACgfPm32oHS8G+1A2XBz5UAFY1/755M8W/YA1sS91sywb0W2JL477qQCaNHjY5XXnkl0zEAyoV7LZniv40GbEl6nBPRNj/TKdjSjPtHxLRRmU4BUL78W+0Vi79TCwAAAAAAAAAAAFC+/FvtQGkU5+94Vy6HHAAAAAAAAAAAAAAAAEAFtXLlyhg5cmSMHDky01E2qaCgICZOnBgTJ07MdJQSmTJlSkyZMiXTMcrEihUrYsyYMTFmzJhMR9nsZdNeZctWp06dIscWLlxYjkkoSjbeT7/99tt44IEH4oEHHsh0lKQ+/fTT+PTTT+PBBx/MdJTNxvLly+Pzzz8vt/maNGkSBx98cEJ93rx5MXr06LTNU6lSpfW/X7duXdr6Zqts2jvZ9r63rPZQRV3D2bSWslE2vncoC5vzsz3/NXfu3HjqqafiqaeeynSUMmUtl53yfg9L9rIPE3lN0q+i39e2tO+5z/dh82Nfp1+2ff6WDtYRAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAxZCb6QAAAAAAAAAAAAAAAAAAAGweWrVqlbS+Zs2amDdvXjmnASieE044IXJzE3/0/rHHHot169albZ569eqt//3SpUvT1hfKizUMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGxOcjMdAAAAAAAAAAAAAAAAAACAzUOHDh2S1j/55JNyTgJQPDk5OXHaaaclHRs8eHDa5qlVq1a0atVq/Z/nzp2btt5QHqxhAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBzk5vpAAAAAAAAAAAAAAAAAAAAbB66d++etP7uu++WcxKA4snPz4/mzZsn1CdNmhSfffZZ2ua55ZZbomrVquv//Pbbb6etN5QHaxgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2NzkZjoAAAAAAAAAAAAAAAAAAADlr2bNmmnt16RJk+jbt2/SsbFjx6Z1LoB0ueKKK5LW77jjjrT0r1y5ctx7771x2mmnbVB/+OGH09Ifypo1DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABsrnIzHQAAAAAAAAAAAAAAAAAAgPKTm5sbl19+ecycOTMaNWqUtr6XXHJJVKpUKaG+cuXKePHFF9M2D0C6HH/88bHPPvsk1GfNmhXDhg1Luf8222wTL7/8cpx++ukb1J988smYOHFiyv2hrFnDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDmrHKmAwAAAAAAAAAAAAAAAAAAUD6aNm0aTzzxRHTp0iUiIoYOHRrdu3ePlStXptS3W7ducfbZZycde/rpp2Px4sUp9QdItxYtWsQdd9yRdOyqq66KwsLClPo3adIk3nnnndh22203qL/44otx8sknp9QbyoM1DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABs7nIzHQAAAAAAAAAAAAAAAAAAgLJ3+OGHx/Tp06NLly7ra507d45x48bFb37zm1L3PeSQQ+K5556LnJychLG1a9fGNddcU+reAGWhQ4cOMWHChKhfv37C2McffxyPPvpoynPMmTMn3nzzzQ1qDzzwQBx66KGxcuXKlPtDWbOGAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDNXW6mAwAAAAAAAAAAAAAAAAAAUPZ22WWXqFevXkK9a9eu8eGHH8bAgQOjSpUqxe7XoEGDuPbaa+PFF1+MunXrJj3mjjvuiJkzZ5Y2MkCp5eTkRNWqVaNatWrRoEGD2HXXXeOYY46JYcOGxeTJk2OHHXZIet6ZZ54ZBQUFaclw0kknxcyZM2PlypVxxhlnxKmnnhpr1qxJS28oD9YwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALA5q5zpAAAAAAAAAAAAAAAAAAAAlL2bb745Dj/88OjYsWPCWKNGjeKhhx6K66+/Pl544YWYNGlSfPbZZzF79uxYuHBhVK5cORo0aBBbb711tG3bNg455JDo27dv1K5du8j53nvvvfjb3/5Wll8SQJEGDBgQTz/9dInO+ec//xmvvvpq2jIsW7Ys+vfvH5UqVYoPPvggbX2hvFjDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDmrHKmAwAAAAAAAAAAAAAAAAAAUPbWrVsX+fn5MXny5GjZsmXSYxo1ahQnn3xynHzyySnNNWvWrMjLy4vVq1en1AegvLzyyitxwQUXpL3vRx99lPaeUJ6sYQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgc5Wb6QAAAAAAAAAAAAAAAAAAAJSPH3/8MQ444ICYPHlymc0xZcqU2H///WPu3LllNgdAOo0ePTry8/NjzZo1mY4CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUk9xMBwAAAAAAAAAAAAAAAAAAoPzMnTs3DjrooLjiiitixYoVaeu7atWquPbaa6NTp04xb968tPUFKCvz5s2LM888M/r27ZvW6yEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFDxVc50AAAAAAAAAAAAAAAAAAAAyteaNWviqquuigceeCDOOuusGDhwYGy33Xal6rVkyZJ4+OGH49Zbb41vvvkmzUkBUldQUBA///xzLFy4ML766qt49913Y/z48TF27NhYu3ZtpuMBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZUDnTAQAAAAAAAAAAAAAAAAAAyIzvvvsuLr300rj88sujXbt2cdBBB0X79u1jp512iubNm0edOnWiatWq64//+eefY86cOfHFF1/Eu+++G6+88kq8+uqrsWbNmgx+FWRKp06dMh0BijRkyJAYMmRIpmMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVVOVMBwAAAAAAAAAAAAAAAAAAILMKCgpiypQpMWXKlISxGjVqRGFhYaxcuTIKCwszkA4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgvSpnOgAAAAAAAAAAAAAAAAAAABXXihUrMh0BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIK1yMx0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyktupgMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAecnNdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoL7mZDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADlJTfTAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKC85GY6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJSX3EwHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgPKSm+kAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUF4qZzoAAAAAAAAAAAAAAAAAAGwJXnnllaT1gw8+uJyTFF82Zs4Gd911V+y+++4J9TPPPDM++eSTDCSCisUegY2zRwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIHWVMx0AAAAAAAAAAAAAAAAAALYEBx10UKYjlFg2Zs4G7dq1i/322y+hXqdOnQykoSSqVq2atL569epyTrJ5s0dg4+yRzHM/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADIfpUzHQAAAAAAAAAAAAAAAADS6dxzz4169eql3GfdunWxatWqWLZsWfzwww8xZ86c+PTTT2PJkiWph4yIxo0bx2mnnZaWXmVh9uzZ8dBDD21Qq1OnTvzpT39KenxhYWHceuutsXz58nJI9/8deOCBceCBByYdmzx5cowfP75c8wBkkzZt2kT//v2Tjg0fPjymT59eZnMfd9xxsdNOOyXUR40aFe+++26ZzRsRkZ+fH+3atUuof/PNN/Hwww8Xed4uu+wSn376adKxVq1axWeffZauiABUYO4HAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACbh8qZDgAAAAAAAAAAAAAAAADpdP7550fz5s3LrP+3334bb7zxRrz44osxcuTIWLhwYan6bLfddnHllVemOV36vPXWW/HQQw9tUFu6dGk0btw4zjzzzKTnNGvWLE455ZTyiBcR/30Nhw4dGg0aNEgYmz9/ftx7773llgUgG/30009F3osaN24cZ511VpnMm5ubG3fccUfS6/dOO+0UJ510UpnM+4vrrrsuWrdunbQOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbBlyMx0AAAAAAAAAAAAAAAAAsknTpk3jqKOOiocffjjmzp0bTz75ZLRr1y7TscrNBRdcEJ988knSsT/84Q9x+OGHl1uWf//739GgQYOkYwMHDowffvih3LIAZKNZs2bFjBkzko7l5+eX2bwdOnQo8vrdu3fvMps3IqJZs2bRunXrpGPDhg0r07kBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAiiM30wEAAAAAAAAAAAAAAAAgW1WpUiWOOuqomDJlSjz++OOx9dZbZzpSmVu5cmUcffTRsXr16qTjDzzwQGy77bZlnuO8886L7t27Jx275557YtSoUWWeAWBzMGzYsKT1pk2bRuvWrctkzry8vCLHttlmm9h7773LZN6IiL59+yatf/fdd/HOO++U2bwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAxZKb6QAAAAAAAAAAAAAAAACQ7XJycuKYY46JDz/8MDp37pzpOGVu2rRpMWjQoKRjDRo0iEceeaRM52/dunXccMMNScc++eSTuOCCC8p0foDNybBhw4oc69u3b5nM2adPn5TGU5Gfn5+0/vzzz5fZnAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDFUznTAQAAAAAAAAAAAAAAAKA8zJ49OxYvXlysY3NycqJatWpRu3btqFOnTlSvXr1Y522zzTYxYcKE6N+/f7z44osbPXblypUxY8aMYvUtSt26daNp06YJ9bVr18Ynn3ySUu9Zs2ZtdPyWW26JvLy8OPjggxPGunfvHn/605/i9ttvTylDMlWrVo0nnngiqlWrljC2evXqOProo2PlypVpnxdgc/Xee+/FN998EzvssEPCWL9+/eKGG25I63wNGzaMffbZZ6PH9OnTJ6677rq0zhsRUb169aT3rYiIYcOGpX0+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoOKqnOkAAAAAAAAAAAAAAAAAUB7+/Oc/x5AhQ0p17jbbbBN77LFHtG/fPo444ojo0KFDkcdWq1Ytnnvuudh///3j/fffL/K4jz76KPbcc89S5fnFEUccEc8991xC/ccff0y596YUFhbG8ccfHx988EHUr18/Yfz666+PCRMmxAcffJDWea+77roiv7ZBgwbFtGnT0jofwJZg+PDhce655ybU99tvv2jQoEEsXLgwbXP17NkzcnJyNnpMp06dom7durFkyZK0zRsR0b1799hqq60S6kuXLo2JEydu8vyVK1fGlClTihwDYMvgfgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsHmonOkAAAAAAAAAAAAAAAAAUNHNmzcv5s2bFy+//HLccMMN0aJFi7j66qvjyCOPTHp8jRo14sknn4y99947Vq9eXc5py8+cOXPi1FNPjWeffTZhrFq1avHkk0/GPvvsE6tWrUrLfN26dYvzzz8/6dgrr7wSt9xyS1rmAdjSDBs2LM4999yEeqVKlaJ3797xxBNPpG2uvLy8TR5TuXLl6N69ezz33HNpmzciIj8/P2l91KhRsWbNmk2e/80330T79u3TmgmA7ON+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwecjNdAAAAAAAAAAAAAAAAADINp9//nkcddRR0atXr/jpp5+SHrPbbrvFGWecUc7Jyt9zzz0XDz/8cNKxPfbYI2688ca0zFO/fv3497//HTk5OQljixYtiuOPPz4KCwvTMhfAlmbSpEmxYMGCpGP5+flpmycnJyd69uxZrGPz8vLSNu8v+vbtm7Q+bNiwtM8FAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVGy5mQ4AAAAAAAAAAAAAAAAA2WrcuHFx8MEHx6pVq5KOX3TRRZGTk1POqcrfOeecE1988UXSsT/+8Y/Rq1evlOe47777okmTJknHTjvttJgzZ07KcwBsqQoKCuKFF15IOta7d++0zbPvvvvGb37zm4T63Llzy3TeiIi999476X1k9erVMWbMmLTOBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFR8uZkOAAAAAAAAAAAAAAAAANlsypQpceWVVyYd23777ePAAw8s50Tlb/ny5XHsscfG2rVrE8ZycnLi4Ycfjq233rrU/Y8//vgYMGBA0rGHH344nn322VL3BuC/hg4dmrRev379tM3Rp0+fhNqyZcviuuuuS6hvt912seeee6Zt7r59+yatT5gwIX766ae0zQMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABkh9xMBwAAAAAAAAAAAAAAAIBsd8stt8TSpUuTjvXs2bOc02TGf/7zn/j73/+edKxx48bx4IMPlqpv8+bN46677ko6NmvWrPjjH/9Yqr4AbGjcuHGxYsWKMp0jLy8voTZ+/Ph4/vnnkx7fp0+ftM3dr1+/pPVhw4albQ4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAge+RmOgAAAAAAAAAAAAAAAABku9WrV8eIESOSjrVt27ac02TO1VdfHZMnT046dthhh8Wpp55aon65ubnx2GOPRe3atRPG1q1bF8cee2z89NNPpcoKwIZWrlwZY8eOLbP+DRo0iPbt2yfUR40aFV9//XV88sknCWN5eXlpmbthw4bRoUOHhHphYWGR928AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABg85ab6QAAAAAAAAAAAAAAAACwOZgyZUrSeosWLco5SeYUFBTEscceG0uXLk06fvvtt0fLli2L3e+SSy6Jzp07Jx278sor46233ipVzmxVu3btqF+/flSpUiXTUYqlWrVq0aBBg9hqq60yHSWp6tWrR4MGDaJevXqRk5OT6TjFVrVq1WjQoEHUqFEj01HKRUVf97+s8+rVq2c6SloMGzYsab1Zs2Yp9+7Zs2fk5ib+WOuYMWM2+N//tf/++0ft2rVTnrtPnz5J9/lbb70V8+bNS7l/plT062xE9u6RX3LXqlUr01G2SJUqVYp69epV6Ot/umTrHqno9+ctQZUqVaJ+/fpRt27dCvletiKvkS3pGgMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbFzlTAcAAAAAAAAAAAAAAACAzcH333+ftF63bt1yTpJZX331VZxzzjnxyCOPJIzVqFEjnnjiiejUqVOsXbt2o3323XffuPLKK5OOvfnmm3HNNdekJW9FVK1atejVq1f06tUr9tprr9htt92ifv36kZOTs/6Y1atXx9dffx0zZsyIyZMnx/Dhw+Pzzz9PW4bdd989oTZv3rxYsGBB0uMbNGgQAwYMiEMOOSTatm0bzZo1i6pVq64fX7FiRcyfPz8+/vjjeOmll2LcuHExY8aMtOXdmCpVqsTBBx8cvXv3jjZt2sQee+wRDRs2jEqVKq0/prCwMBYvXhwLFy6M999/P1599dV49dVX4/333y+XjEWpXbt29O3bN/Ly8mLvvfeOXXbZJapVq7Z+fN26dTF37tyYPn16vPPOOzFs2LCYNm1a5gKnoCKs+01p0qRJHH744XHAAQfEXnvtFc2bN99gna9duza++uqrmD59eowbNy6GDx8e8+bNK7d86fDCCy/E2rVro3LlDX/8tG/fvnH33Xen1DsvLy+hNn369Pjuu+8iImL06NFx/vnnbzBepUqV6NatWwwfPjylufv165e0PnTo0BL3SnZ9jIj46KOPUu6TrdfZX2TrHmndunUcdthh0aFDh2jTpk00adIkqlSpsn68sLAwFi1aFB9++OH67OPGjYuVK1eWes6WLVtuMMcvvv/++1i0aFGp+/6idu3a0bRp04T6xx9/HIWFhSn333HHHaN69eoJ9ZkzZ8aaNWtK1KtDhw7RrVu36NChQ+y9997xm9/8JmrVqrXBMatXr445c+bEjBkz4r333osXXngh3nnnnZS+hkzIxj1S3vfn7bbbLurVq5dQX7RoUZHPW6lq0KBBNG7cOKG+YMGCjb7+6bofFMfee+8d+fn5se+++8aee+4ZTZo02eA9YWFhYSxdujQ++uijePfdd2P06NExbty4WLduXdqz/FpFfw+3JV1jAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICSq5zpAAAAAAAAAAAAAAAAALA5WLJkSdJ69erVyzlJ5j366KPRt2/fOPLIIxPG9t1337jyyitj0KBBRZ5fvXr1ePzxx6Ny5cQff1q2bFkce+yxUVBQkNbMFUHTpk3jr3/9axx//PFRq1atjR5btWrVaNmyZbRs2TIOP/zwuOmmm+Kdd96Ja6+9NoYPH55ylg8//DChdvHFF8eNN964QW277baLq666Kk444YSoUqVKkf1q1KgRzZo1i2bNmkXv3r0jIuK1116Lyy+/PCZOnJhy3mQaN24cF154YZx66qlRp06djR6bk5MT9evXj/r168fOO+8cRxxxREREvPPOO3HdddfF8OHDo7CwsExyJlO/fv245JJL4qyzztroWqhUqVI0adIkmjRpEn369InLL788Pvnkk7j22mvj8ccfz4p9UpHWfVG6du0al112WXTv3j1ycnKKPK5y5crRokWLaNGiRRxxxBHxz3/+Mx577LG48sor46uvviqzfOm0aNGimDRpUhxyyCEb1PPz8+Puu+9OqXevXr0SaqNHj17/+0mTJsXy5cujZs2aGxyTl5eX0ve3cuXK0bNnz6Rjzz//fIn7Jbs+RsRG10Zx+2TbdfYX2bhHqlSpEieeeGJceOGF0apVq40em5OTEw0aNIiuXbtG165d4+yzz47ly5fHY489FjfccEN8+eWXJZ7/xhtvjP79+yfUH3zwwTjllFNK3O/Xzj///LjyyisT6vvvv3+8+eabKfWuXLlyvPfee1G3bt0N6osWLYpGjRoVq0eVKlXijDPOiDPOOCN23333TR5ftWrV2HHHHWPHHXeMfv36xeWXXx6zZ8+OO++8M+67775YunRpqb6W8pKNeyRT9+c+ffrEAw88kFD/8MMPo3Xr1iXqVVx333130ueW3/72tzF06NAiz0vX/aAoNWrUiFNPPTXOO++82HHHHTd6bE5OTtStWzc6deoUnTp1inPOOSfmz58ft99+e9x2223x888/pyXT/6rI7+G2tGsMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFB6uZkOAAAAAAAAAAAAAAAAAJuDwsLCTEeoUE4//fT49ttvk45dcskl0bVr1yLPve2222KXXXZJOnb22WfHl19+mZaMFUWVKlXimmuuiS+++CLOPPPMqFWrVqn6tG/fPoYNGxavvfZa7LTTTmlOmeiYY46Jzz77LP7whz9ElSpVSnx+165d45VXXolnn302atasmbZcOTk5ceGFF8aXX34Zf/7zn6NOnTql7tW+ffsYOnRovPHGG7HtttumLePG9OvXLz7++OP4y1/+Uqq1sOuuu8YjjzwS06ZNizZt2pRBwvTIhnXfsGHDGDp0aEyaNCl69OgROTk5JTq/cuXKcdJJJ8WMGTPirLPOSmu2sjR06NCE2sEHHxzVq1cvdc999tknGjVqlFAfPXr0+t+vXr06XnnllYRj+vTpU+p5I/57rUl2Hfjoo49i5syZKfUuaxX1OvuLbN0jPXv2jJkzZ8b9998frVq1KlWPmjVrxumnnx4zZ86MW2+9NbbaaqsSnT9kyJCk9X79+pX4dUzm0EMPLbJ/qg488MCoW7duQn348OGxdu3aTZ7fuXPnmDZtWtx5552x++67lzrH9ttvHzfeeGN89dVXceKJJ5a6T1nKxj2S6fvzU089FcuWLUuo77HHHrHPPvuUKsvG1K1bNw477LCE+g8//BAjRoxI+3zFdfTRR8dXX30Vt99+e+y4446l6tGwYcO45pprYubMmXHIIYekLVum18imbEnXGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgdbmZDgAAAAAAAAAAAAAAAACbg6222ipp/eeffy7nJBXDkiVL4rjjjouCgoKEsdzc3HjssceiTp06CWP5+flx+umnJ+359NNPx6OPPpr2rJm0/fbbx9tvvx1/+9vfokqVKmnp2aVLl5g+fXr07ds3Lf2Sufrqq+Pxxx+PmjVrptzrt7/9bbz11lvRvHnzlHvVqVMnXn755bjpppuK3JOl0alTp5g6dWp07NgxbT2Tueiii+L555+PbbbZJuVee+65Z7zzzjtx0kknpR4szbJh3Xfo0CFmzJgRhx9+eMq9atasGXfddVcMHjw4cnMr/o91Pv/88wm1rbbaKrp161bqnr17906oLVmyJCZPnrxBbfTo0QnHbb/99rH77ruXeu5+/folrQ8fPrzUPctDRb3O/iIb90hubm7cddddMXbs2GjWrFlaelaqVCnOP//8mD59euy6667FPm/kyJGxcuXKhHqjRo1iv/32SylT48aNo127dknH8vPzU+odEUV+z4cMGbLJc0888cR49dVXU9rTv1a/fv14+OGHY+jQoWnrmQ7ZuEcqwv15+fLl8dRTTyUdGzhwYFoy/a8jjzwy6XvGhx9+ONauXZv2+TalevXq8eyzz8YTTzwRDRs2TEvPJk2axEsvvRR/+ctfUu5VEdbIxpT1NaZatWpp6wsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVAy5mQ4AAAAAAAAAAAAAAAAAm4PGjRsnrS9YsKCck1QckyZNiptuuinp2A477BD33nvvBrVGjRrFQw89lPT4b7/9Nk4//fS0Z8y0yZMnx957712sY9euXRs///xzsY6tWbNmDB8+PI488sgU0iU3aNCgGDRoUFp7tm7dOsaNGxe1a9cudY/69evHxIkT46CDDirW8QUFBbF8+fJYu3ZtsY5v3LhxvPDCC9G0adNSZ9yYc889N2688cbIyclJW8+qVavGQw89FOeee27aeqaqZcuWFX7dH3jggTFhwoRo1KhRSn1+7dRTT4377rsvrT3LwuzZs+Pdd99NqOfn55e6Z15eXkJt3LhxsW7dug1qY8aMSXp+nz59Sj13UbmHDRtW6p5lraJeZ3+RjXtkq622iueffz7OOuusMun/y7Wtc+fOxTr+p59+irFjxyYd69+/f0pZ8vPzi7yX7LnnnrHDDjuk1P/QQw9NqC1evDgmTJiw0fMGDhwY//rXv6JSpUrFmufnn3+OFStWRGFhYbGOP/zww6NatWrFOrasZeMeqUj358GDByetH3PMMVG1atVi9SiugQMHJq3ff//9aZ2nOBo0aBATJ06M3/72t2nvnZubGzfccENK95aKtEaSKY9rzNixYyvMdQYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASI/cTAcAAAAAAAAAAAAAAACAzcHOO++ctD5//vxyTlKxXHrppfHuu+8mHTv66KPj6KOPXv/nf/3rX9GwYcOE4woKCuL444+PJUuWlFnOTGjQoEE0bdq0yPHp06fHoEGDon379tGgQYOoUqVK1KhRI6pVqxZNmjSJww47LO66665YvHhx0vMrV64c//73v6Njx45py9y9e/e46qqrEuqFhYXx6quvxvnnnx9du3aNnXbaKRo3bhy77LJLdO7cOc4555wYPXp0rFu3rsjeLVu2jH//+9+lzvb4449H27Ztixx/7bXX4rzzzot999036tSpE5UqVYpatWpFlSpVok6dOrHXXnvFeeedV+R6jYj4zW9+E88991xUqVKl1DmTOeCAA+K2225LqK9evTpGjhwZZ511Vuy///7rX9edd9459t9//zjxxBPjySefLHINRETk5OTE7bffHvn5+WnNXBoNGjSIcePGVeh1v/POO8fw4cOjVq1aRR6zatWqGDNmTPzxj3+MAw88MHbddddo3LhxNGvWLNq1axcnnnhiPProo7F06dKEc0855ZQ455xzSpWtPA0dOjShVto1VK9evaTfj9GjRyfUvvrqq/j0008T6nl5eaWau0WLFtGyZcuE+pw5c2LKlCml6lnWKvJ1NiJ798ijjz660TVcUFAQb7zxRlxyySXRrVu32GOPPWLbbbddf7094YQT4qmnntro9bZ+/foxatSo2G233YqV6emnn05a79+/f7HOL8qhhx660fG+ffuWunfbtm2TXsOff/75WLNmTZHn7bTTTvHPf/4zcnJyko5/9913cfPNN0ePHj1i2223jUqVKkWNGjWiZs2akZubG1tvvXV06tQpLrroonjrrbeKnOfOO+8s+ReVZtm4Ryra/XnKlCkxbdq0hHr9+vU3ub5LolWrVrHffvsl1CdOnBiff/552uYpjqpVq8bIkSOjQ4cORR6zbt26mDRpUlxyySXRvXv32HPPPWO77baLJk2axO677x6HHXZY3HLLLfHdd98V2ePqq6+OI488ssT5Ktoa+bXyusYceOCBFeI6AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACkT26mAwAAAAAAAAAAAAAAAMDm4NBDD01af+edd8o5ScWydu3aOOaYY2LFihVJx++5557YYYcd4owzzoi8vLykx9x4443x6quvlmXMjHj66aeT1r/99tsYMGBA7LXXXnHttdfGlClTYtGiRevHV69eHd99912MGDEizjnnnGjWrFlce+21UVBQkNCrWrVq8eyzz0bNmjVTzrvVVlvFAw88ELm5G/5Y2qhRo2LPPfeMgw46KG6//fZ4/fXX48svv4x58+bFzJkzY/LkyXHXXXdF3759o02bNjFhwoQi5zj88MNjwIABJc72xz/+Mfr06ZN0bOrUqdGxY8c44IAD4s4774x33303li1btsExy5Yti+nTp8edd94Z++67b/z2t7+NpUuXJu3Xvn37OOmkk0qccWN+/boWFhbG3XffHTvuuGMceuihcc8998Sbb765/nWdNWtWvPnmm/HII4/EMcccE9tvv31cdtllRWbOycmJxx9/PLbffvu05i6pp59+Opo3b550rCKs+8qVK8fQoUOjXr16ScfXrVsX999/f+y8886Rl5cX//znP2PSpEnx6aefxrx58+Kbb76J9957Lx555JE44YQTYvvtt49LL700Vq5cuUGfG264IePfi00ZPnx4Qq1JkybRpk2bEvfq2bNnVKpUaYNaYWFhvPjii0mPHzNmTEKtS5cupbqO5efnJ60///zzJe5VHirydTYie/fIZZddFr/73e+KHH/xxRdj7733ji5dusQNN9wQL7/8cnz00Ucxd+7c9dfbRx99NI4++ujYfvvt4/LLL4+ffvopaa+6devGqFGjok6dOpvMNXLkyISvPSJil112iVatWhX/C/wf1apVi27dum30mH79+pWqd8R/108yzzzzzEbPu/3226NGjRoJ9YKCgrj00ktjp512iosuuijGjx8fc+fOTbi2L1y4MN566624+eabo1OnTtG5c+eYPn16Qr/TTjstevToUYKvKL2ydY9UxPvz4MGDk9YHDhxYvC+qGIp6P1fU3GXpnnvuif3337/I8WeffTZ23333OPDAA+OGG26ICRMmxIwZM+L777+P7777Lj7++OMYMWJEXHjhhdGsWbM4//zz4+eff07a67777ivx+qmIa+R/ldc1JiLz1xkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIL1yMx0AAAAAAAAAAAAAAAAAsl2XLl1i1113TTr2xhtvlHOaiuezzz6L888/P+lY3bp1Y9iwYXHrrbcmHX/33XfjsssuK8t4GXHcccdF9+7dE+pvvPFG7LPPPvHss88Wu9fSpUtj0KBB0bdv31i2bFnC+Pbbbx9XXnllSnkjIk455ZRo1qzZ+j+vXbs2Tj/99MjPz48PP/ywWD0++uij6NmzZ/zrX/8q8pi//OUvJcpVp06duOKKK5KOPfbYY9GhQ4d4++23S9Rz6NCh0blz51iyZEnS8YsuuihycnJK1HNjWrZsuf73S5YsiW7dusXZZ58d3333XbHOX758eVx99dXRrl27+Pjjj5MeU6dOnbjtttvSkrc0ilrzERVn3Z933nnRpk2bpGOLFi2Knj17xmmnnRZz5swpVr9ly5bFNddcE23bto0vv/xyfb1GjRqx/fbblyhbefvoo49i5syZCfW+ffuWuFefPn0SatOmTYu5c+cmPX7UqFEJtapVq8YhhxxS4rn79euXtD5s2LAS9yoPFfU6+4ts3COtW7cu8n3EL69vnz594oMPPihWv+XLl8ff//732GuvvYq83u64445x4403brLXTz/9FGPHjk06dthhhxUrz69169YtatSosdFjDjnkkE0eU5RkuZYuXRrjxo0r8pyGDRsmvQ5ERBx99NFxzTXXxKpVq0qUY/LkydG+ffsYOnRowthVV11Vol7plI17pKLenx9//PFYsWJFQr1Xr16x7bbbFjtPUXJycuL4449PqC9cuDCee+65lPuXRPfu3ePkk09OOvbzzz/HgAEDYsCAAfHZZ58Vq9/atWvj9ttvj/333z/mz5+fMF63bt0SvUeqqGvkF+V9jYnI7HUGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEiv3EwHAAAAAAAAAAAAAAAAgGxWrVq1eOCBB5KOLV68OMaMGVPOiSqmwYMHx4gRI5KOtWvXLqpXr55QX7FiRRxzzDGxdu3aso5Xrrbaaqu48cYbE+rvv/9+dO/ePebPn1+qvi+++GKccMIJScf++Mc/xjbbbFOqvr9o2rTp+t8XFBTEkUceGYMHDy5xn4KCgjj55JNj0qRJScf33XffOOCAA4rdr0qVKvHkk0/GypUrN6iPHj06jj/++Fi3bl2JM0ZEzJgxI84+++ykYy1btow+ffqUqu/GrFixIg455JB45ZVXSnX+F198ER07doypU6cmHf/d734XnTt3TiViqRS15iMqzrqvV69eXHHFFUnHFi5cGB07doyXX365VBk/+eST6Ny5c8yePbtU52fK8OHDE2r9+vUrcZ/evXsn1EaPHl3k8ZMmTYrly5cn1PPy8ko0b+3ataNr164J9SVLlsTEiRNL1Ku8VNTrbET27pF77703qlSpklBfs2ZN5OXller1jYiYNWtWdOzYMd56662k46eddlp06NBhk32GDBmStN6/f/9S5SrOHq1WrVp07969xL2bN28ebdq0SaiPGDEi1qxZs9FMlStXTqg//fTTRX79xbF69eo48sgj480331xfe+mll+Lyyy8vdc9UZOMeqcj356VLl8YzzzyTUK9UqVIcd9xxpcr0v7p37x5NmjRJqD/66KOxevXqlPsXV25ubtx9991Jx1asWBEHHXRQPPvss6XqPW3atOjevXusWLEiYaxDhw5RtWrVTfaoyGvkF+V5jYnI7HUGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEi/3EwHAAAAAAAAAAAAAAAAgGxVp06dGDNmTLRq1Srp+EMPPRQ///xzOaequE4++eSYO3dusY8///zz47PPPivDRJlxzDHHxLbbbrtBbenSpXH44YfHypUrU+o9fPjweOCBBxLqVatWjbPPPjul3v/riiuuiKFDh6bU46STToo1a9YkHTvssMOK3WfBggXxxz/+MXbccce45ZZbYvny5bF48eI44YQTUsoXEfH444/HBx98kHSsW7duKff/tbPOOiumTp2aUo9ly5bFb3/721i0aFHS8T/96U8p9S+NZGs+omKt+5NPPjlq166dUC8sLIzjjjsuZs6cmVLG77//Pn7729/GunXrUupTnpLt8Y4dO8bWW29d7B577713NG7cOKE+atSoIs9ZvXp1vPLKKwn1Pn36FHveiIiePXtGlSpVks69du3aEvXKhIp0nY3Izj3StWvX6Ny5c9Kxiy66KF566aWU+v9yvf3hhx8SxnJycuJvf/vbJnuMGDEiVq1alVDfb7/9olGjRiXOlJ+fv8Gf165dG6+//nrCcf369Stx76LWzJAhQzZ63s4775y0/u9//7vEGX5t7dq1MXDgwPj555/j0UcfjZ49e6b8fS2tbNwjFf3+PHjw4KT1k08+OaVcEREDBw4s0Zxl5YgjjoiWLVsmHTvrrLPi7bffTqn/9OnT44ILLlj/57fffjsOP/zwaNOmTaxevXqT51f0NRJRvteYvfbaK6PXGQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAg/XIzHQAAAAAAAAAAAAAAAACyUZ8+feI///lPHHzwwUnHFyxYENdff305p6rYFixYECeeeGIUFhZu8tgRI0bE4MGDyyFV+TvnnHMSanfeeWd8+eWXael/3XXXRUFBQUL9hBNOSEv/999/P6677rqU+3z55ZcxfPjwpGNdunQpcb+5c+fGhRdeGM2aNYtDDz00FixYkGLC/7rvvvuS1rt27ZqW/r947bXX4t///ndaen311Vfxl7/8JelY//79o3HjxmmZp7iSrfmIirXuzzzzzKT1hx9+OMaMGZNStl+8/fbbRa6niuitt96KuXPnblDLzc2NPn36FLtH7969E2qLFi2K//znPxs9b/To0Qm1Zs2aRatWrYo9d79+/ZLWhw0bVuwemVIRr7PZuEcuvPDCpPXx48fHHXfckZY5vvvuuzj11FOTjh166KHRsmXLjZ7/008/xdixYxPqOTk5Ra7houy9996x/fbbb1B79dVXk95b+vbtW6LeEf+9f/zasmXLYty4cRs9b7vttkta/+KLL0qcIZlPP/00ttlmm7S9zymtbNwjFf3+PHny5Pjoo48S6rvuumt06NCh1Jnq1KmTdD2/+eabSecrS+edd17S+ogRI9L2vnDw4MFxzz33xEEHHRQdO3aM4cOHF+t5LKLir5GI8r3GTJ8+PS09AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICKIzfTAQAAAAAAAAAAAAAAACBbNGnSJM4555yYPHlyjB49Onbdddcijz3nnHNi/vz55ZguO4wbNy7+8Y9/bPSYuXPnxsknn1xOicrXDjvsEG3btt2gtmLFirjtttvSNsesWbNi/PjxCfVmzZrFbrvtlnL/yy67LNatW5dyn4iIf/3rX0nr7dq1ixo1apSq54IFC+K1115LJdYGXn755aT1tm3bRqVKldI2z9///ve09YqIePTRR5NegypXrhy9e/dO61wbk2zNR1Ssdb/LLrtEixYtko7dcsstacn3i6uvvjrWrl2b1p5l6fnnn0+o5efnF/v8vLy8hNrYsWOjoKBgo+eNGTMmab1Pnz7FmjcnJyfp3KtWrYoXX3yxWD0yqaJdZ7Nxj9SuXbvI9XLdddel3P9/jRgxIj788MOEek5OTvzud7/b5PlDhgxJWu/fv3+JciTbmyNGjIgXXnghCgsLN6hvu+220a5du2L3rl+/fnTt2jWhPnLkyFi1atVGz61WrVrS+q8zpWLZsmVp61Ua2bhHsuH+HBFx//33J60PHDiw1Jl+//vfR/Xq1RPqgwcPLnXP0mjUqFF07tw56dgNN9yQtnkKCwvjrLPOildffbVE52XLGtkSrjEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQNnJzXQAAAAAAAAAAAAAAAAAKA/9+/ePv/zlL8X6dfHFF8f//d//xS233BKDBw+OCRMmxNy5c2P27Nnxj3/8Izp16rTRua666qp46qmnyukryz6zZ8/e6PiSJUti+fLl5ZSmfPXo0SOhNn78+Fi4cGFa55k4cWLS+kEHHZRS36+//jpGjhyZUo//9cYbb0RhYWFCvXLlytGsWbO0zZOKTz75JH766aeEeuXKlaN+/fppmePrr7+Ol156KS29frFq1ap48MEHk4717t07rXNtTLI1H1Gx1n3Pnj2T1idNmhQffvhhiqk29P3338cLL7yQ1p5ladiwYQm13r17R6VKlTZ5bp06dZLeL0eNGrXJc7/66qv49NNPE+p5eXmbPDcion379tGwYcOE+oQJE5Lu54qkIl5ns3GP9OzZM6pUqZJQnzFjRrz88ssp9/+122+/PWm9X79+mzx3xIgRsWrVqoR69+7do0aNGsXOcOihhybURo4cGXPnzo0pU6YkjOXn5xe7d35+ftJ9/8wzz2zy3MWLFyet77jjjsWev6LLxj2SDffniIhHHnkk6f44+uijo1q1aqXKM3DgwITa0qVLY8iQIaXqV1q9e/eOnJychPp7770XkydPLtcsyWTLGtkSrjEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQNmpnOkAAAAAAAAAAAAAAAAAUB6OPvroOProo8t0jsLCwvj73/8eV1xxRZnOk8323nvvuPrqqzd6TKtWreKWW26Js88+u5xSlZ8uXbok1MaOHZv2ed56662k9T322COlvi+88EJK5//a0qVL44svvogWLVokjNWvXz+tc5VWYWFhfP/999GyZcuEsQYNGsSPP/6Y8hzjxo1LuUcyL7/8clxyySUJ9fbt25fJfMkkW/MRFWvdd+zYMWn9lVdeSTlTMqNHj47+/fuXSe90e/nll2Pp0qVRp06d9bW6detG586dY9KkSRs9t0ePHlG58oY/xlpYWFjs7/2YMWOiVatWG9QOOOCAqF69evz8888bPbdfv35J60OHDi3W3JlUEa+z2bhHDj744KT1F198MaW+RSmqb8eOHaNatWqxatWqIs9dtmxZjBs3LmHdbrXVVtGrV68YNmzYJuffZpttYt99992gNmPGjPjyyy8jIuL5559PuPb369cvrrrqqk32joik34/ly5cX6/X8/vvvk9aPPvroMrv/lbds3CPZcH+OiFi4cGEMGzYsjjrqqA3qdevWjf79+8fTTz9doiwtWrSI/fffP6H+xBNPxIoVK0rUK1Vdu3ZNWi+L70FpZMsa2RKuMQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABA2cnNdAAAAAAAAAAAAAAAAADYHMydOzd69eoVV1xxRaajVFhbbbVVPPnkk1G1atVNHnvWWWdF37590zp/165d44MPPkj7rz333LPYGXbdddeE2ptvvpnOLzMiIr7//vuk9V122SWlvpMmTUrp/GS+/fbbpPUGDRqkfa7SWrJkSdJ6ujK+9tpraenza2+//XYUFhYm1Js3b16sfZgOydZ8RMVa961atUpaL4uMEWX3/S4La9asidGjRyfU8/PzN3lunz59EmpTpkyJ+fPnF2vuZPNWq1YtDj744E2emyxfQUFBjBw5slhzZ1JFvM5m4x7Zfffdk9Zff/31lHsnM3v27KSvc25ubpGv3/8aMmRI0nr//v2LNX/fvn0jJydng9r/rvdka3+fffaJxo0bb7J3tWrVolevXgn1F154IVauXLnJ84t6zU844YQYMGDAJs/PBtm4R7Lh/vyL++67L2l94MCBJc5y0kknJa0PHjy4xL1StdtuuyWtT548uZyTJJcta2RLuMYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGWncqYDAAAAAAAAAAAAAAAAQDb78ccf46abboq77rorli9fnuk4Fdqtt94au+66a7GP/9e//hWtW7eOH374IS3z165dO1q3bp2WXv+revXqxT52l112Sah9/fXX6YwTERGLFi1KWq9fv35KfT/++OOUzk9myZIlSev16tVL+1wl0bhx49h5551jp512igYNGiQ9pmrVqmmZa+bMmWnp82tLliyJr7/+Opo3b75BPTc3N3baaaf45JNPymTe/5VszUdUrHXfsmXLpPXp06ennCmZL774IgoKCiI3N7dM+qfb0KFD46ijjtqglp+fH3/5y182el7v3r0TamPGjCn2vK+++mqsWLEiatSosUE9Ly8vRo8eXeR52223Xey9994J9TfffDNt95OyVBGvs9m4R3bbbbek9alTp5a656a8++670bRp06RZNvVaPf/887Fq1aqoVq3aBvX8/PzIzc2NgoKCjZ5/6KGHJu35i+nTp8c333wTO+yww/paTk5O9O3bNx588MGN9u7evXvUrFkzof7MM89s9LxfvP7667FgwYLYeuutN6jn5ubG008/Hfn5+XHrrbfG+++/X6x+FVE27pFsuD//YuLEifH5559HixYtNqj36NEjmjRpEnPmzPl/7Nt5eJblmTf+Mw/7JktFKVURBLGlaCmKUBlBxcoq2I5aN5SpVp1xpHY6+lZRpzp1nGqrbdFaLFStUgZQIEgQcAErjkVBQNEXECyCyio7JCzJ74/30F/j8wSyPEse+/kch4fJed73eX2TXPd1hz9SqTkFBQUxfPjwpPqiRYvizTffrNSMdOrcuXPKei6ypJIve+Tv4YwBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADInkesAAAAAAAAAAAAAAAAAkG8OHDgQEyZMiAsuuCCOPfbY+PnPfx67d+/OdaxabfDgwXH99den7G3atCllvXXr1vH4449nMlbWtWzZstzne/fujU8++STt6+zatStlvVmzZjWa++GHH9bo/lR27NiRsp5IZPbP3xo0aBCdO3eOgQMHxg033BAPPvhgFBYWxttvvx179uyJjz/+OF555ZV44oknokOHDhnNsmbNmozNrmh/fX4vZkqqdWrbvm/evHnK+pYtW2qcKZX9+/fHRx99lJHZmTBz5syk2le/+tVo3759hfd07do1vvKVryTVZ8yYUel19+3bFy+99FJSfcCAAYe8b9CgQSnrU6ZMqfTauVQbz9l8fEZat26dsl7R7xzpsHnz5pT1I4888rD37ty5M2bPnp1Ub9WqVfTu3fuQ99avXz/69etXrrZx48ZYsGBBuVphYWHSvUOGDDlstmHDhiXV9uzZE0VFRYe9N+L//Tz/67/+K2WvoKAghg8fHosXL461a9fGM888E3fffXdceeWVccYZZ8TRRx9dqTVyLR+fkXx4P/+tRx99NKmWSCTiiiuuqPSMs88+O4499tik+pgxYyo9I51atWqVsp7Jc6oq8mWP/D2cMQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABA5tTNdQAAAAAAAAAAAAAAAADIho8++ih27NhRpXuOOOKIaNu2bVK9Tp06cf/998fChQvTFe8L7aijjopx48al7G3YsCG6desW06ZNi9NOOy2p379//7jhhhti9OjRmY6ZcY0bN46CgoJytUaNGsXevXvTvtbn1/lUgwYNajR3586dNbo/ldLS0rTP/Ftt27aN7t27x8knnxwdO3aMDh06xAknnBBt27at8PuUbVU9m6pi27ZtKetNmzbN2JqfSrXnI2rXvq8oY0lJSezbty9t2T4vE89SpuzatStlfdCgQRWezQMGDEiqbd68OV5//fUqrV1UVBSDBg0qV+vQoUN07Ngx3nvvvZT3DBkyJGV92rRpVVo7V2rbOZuPz0ijRo2iTp06SfWSkpIoLi6uSaxD2rp1a8p6s2bNKnX/xIkTU+7fYcOGxcsvv1zhfWeffXY0adKkXO3ZZ5+NsrKycrXCwsK44YYbytXOPffcaNCgQZSUlKScXVBQkDJTUVFRlc7x3/zmN3HBBRfEGWecUeE1xxxzTBxzzDFxwQUXlKvv3r07Vq1aFe+991689957sXLlyliyZEksXbq0wtzZlI/PSD68nz/vsccei//8z/+MevXqlav/0z/9U9x7772VmjFixIik2p49e2L8+PGVzpEujRs3jkQikVQvKSmp1fu6tu6RL/IZAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABkVt1cBwAAAAAAAAAAAAAAAIBsuOmmm2LixIlVuqdly5axevXqaNGiRbl6QUFBPPjgg/EP//APaUz4xfX4449H69atU/ZGjBgRH3/8cVx66aWxePHiaNKkSdI19913X7z00kuxbNmyTEfNqFRfW0REw4YNs5yk+vbv35/rCJXSpUuXGD58eFx88cXRrl27XMc5rD179mRs9vbt21PWmzZtmrE1P1XRno+oPfu+oow7duzI6Lq7d+/O6PxsGDx4cIwePTplb8CAAUm1WbNmRVlZWZXWmDlzZoXzf/Ob3yTVGzRoEOecc05SfdmyZfHee+9Vae1cqW3nbD4+I7nKvHXr1pT1I444olL3FxYWxr59+6J+/frl6kOHDo0f/ehHFd43ZMiQpNq0adOSanPnzo2dO3dGs2bNPqs1btw4+vbtG7NmzUo5u2fPnnH00Ucn1av6O/W+ffti6NChMWfOnOjWrVuV7m3SpEmcfPLJcfLJJ5erHzhwIObNmxdPPfVUTJgwIfbu3VuluenyRXpGImrP+/nzNm7cGNOnT4/vfOc75eqdOnWKXr16xf/+7/8e8v5mzZrFBRdckFT/n//5n9i5c2das1ZGrvZNZeXbHvkinzEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQGYlch0AAAAAAAAAAAAAAAAAaqutW7fGXXfdlbLXu3fv+O53v5vlRPnnhhtuiP79+6fsPfTQQzFz5syIiHjvvfdi5MiRKa9r2LBh/OlPf4r69evXKMv27dvjjTfeSPt/u3fvrtT6BQUFNcrP4bVr1y7Gjx8fb731Vtx8883Rrl27XEeqlLKysozNPnjwYMp6NvZjPuz5ijJW9H1LlwMHDmR0frqVlpYm1fr27RuNGzdOqjdt2jTOOOOMpPqMGTOqvO77778fK1asSKoPHDgw5fVnnXVWykxTp06t8tr8P/n4jCQSqf98OtOZa3re7tixI2bPnp1U79ChQ3Tp0qXC+wYPHlzu8+Li4pgzZ07Sdfv374/nnnsuqT5kyJAKZw8bNiyptnfv3igqKqrwnops2bIlevXqFQ8//HBafhZ169aNc845J8aNGxfvvfdejBgxosYzqyMfn5F8eD+nMmbMmJT1yvzsL7zwwpTvh4pmZlqu9k1l5eMe+aKeMQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAZiVyHQAAAAAAAAAAAAAAAABqs9GjR8eqVatS9u67776oX79+lhPljy5dusR9992Xsvfuu+/Gj3/843K1sWPHxpQpU1Je37Vr17j33ntrlGf+/Plx2mmnpf2/ZcuW1SgX6dGvX79YvHhxXHLJJVFQUFCtGZ988kn85S9/iSeffDJuv/32+N73vhfdu3eP1157Lc1pIb/87//+b1KtQYMG0a9fv6R6v379ol69euVqpaWlMXv27GqtPXPmzKRa3759o2HDhkn1IUOGpJxR0bsFapuJEyemrA8bNixl/eSTT47jjjuuXO2FF16IvXv3pry+sLAwqVbRcxMRMXTo0KTazJkzY/fu3RXecyglJSXxL//yL/G1r30tHnvssdixY0e15nxe27ZtY9y4cdGgQYO0zKN2mj17dqxZsyapfvHFF0ejRo0Oee+IESOSasuWLfM73hdMps+Y8ePHO2cAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4Aumbq4DAAAAAAAAAAAAAAAAQG22f//+uOWWW2Ly5MlJvfbt28fIkSPjvvvuy0Gy2q1+/frxpz/9KRo2bJjU27dvX1xyySVRXFyc1Lv66qvj9NNPj7Zt2yb1fvjDH8bMmTNjzpw5GcmcaWVlZUm1bdu2xYQJE7KWYcuWLVlbK5sGDBgQ06dPjzp16hz22l27dsWKFStixYoVsXLlynL/37p1a8p7Uu3VdKpXr17s378/I7Pr16+fsn7w4MGMrPe3Uu35iNq17yv6PtSrVy9TcbIyP92mTJkSZ5xxRlJ98ODBUVhYWK42cODApOsWLFhQ7fOnqKgoRo4cWa7WsGHD6NOnT8yaNatcfdCgQUn3r1u3LhYuXFittcnPZ6SizHXrZvbPqivKXJXzdtq0abFv376ks3vYsGHxs5/9LOn6wYMHp5xRkaKiojh48GC59+Vxxx0XXbp0iWXLlpW7tnPnztG5c+ekGZMmTTrs13E4K1asiBEjRsS1114bffv2jdNOOy26d+8eJ510UnTo0CEaNGhQrbmTJ0+OIUOG1DhfVeTjM5IP7+dUysrKYuzYsXHXXXeVqx9xxBFxwQUXxPjx41Pe16FDh+jdu3dSfcyYMVVaP51KS0tT1jN9TlVWvu6RT2XqjLnkkkuiWbNmWT9nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDMqZvrAAAAAAAAAAAAAAAAAFDbPf300zF//vw444wzknqjRo2Kxx57LDZt2pSDZLXXf//3f0fXrl1T9m699dZYsmRJyt4nn3wSV155ZcyePTsKCgrK9QoKCuLxxx+Prl27xpYtW9KeOdOKi4uTart27Yrrr78+B2m+OI4//vgYP3581KlTJ2V/y5Yt8fTTT8ecOXPi9ddfjzVr1lR5jc/vxXRr3rx5bN68OSOzW7RokbK+a9eujKz3t1Lt+U/Xri37fvfu3SnrzZs3z+i6TZo0yej8dJsyZUrcf//9SfVBgwYl1fr3759UmzFjRrXXnjdvXuzZsycaN25crj5w4MCYNWvWZ5936dIl2rVrl3T/tGnTqr02+fmMVHS+VXQepkurVq1S1nfs2FHpGTt27Ig5c+YkPVvdu3ePtm3bxkcffVSufv7555f7vKysLJ599tkK53/yyScxf/78OPPMM8vVhwwZEsuWLStXGzp0aNL9xcXFh5xfVfv27YvZs2fH7NmzP6sVFBTEMcccEx07doyOHTtGp06dPvu4Y8eO0ahRowrnDR48OG699da455570pbxcPLxGcmH93NFxo0bF3feeWfS730jRoyI8ePHp7znqquuSqqVlJTEH//4x0xErJSKfgaZ3jeVlc975G+l+4yJyM05AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABkTiLXAQAAAAAAAAAAAAAAACAf3HTTTVFWVpZUP+KII+Luu+/OQaLa69vf/naMHDkyZe/FF1+MX/ziF4e8//nnn49f/epXKXtf/vKXY+zYsTXOmAt79uxJ2kOtWrXKUZovjnvuuSdatGiRVN+1a1f867/+a7Rt2zauvfbamDx5cqxZs6ZaazRt2rSGKQ8tVf5Mz961a1fG1vxUqj0fUbv2fXFxcZSWlibV69atG40bN87Yus2bN8/Y7ExYvXp1vP3220n1tm3bxje+8Y3PPv/a174Wxx57bNJ1M2fOrPbaJSUl8dJLLyXVBwwYUO7zwYMHp7x/ypQp1V6b/HxGSkpK4sCBA0n1unXrRpMmTWoS65BatmyZsr5z584qzZk4cWJSraCgIM4///xytdatW0ePHj3K1RYuXBgff/zxIecXFhYm1YYMGZJUGzZsWFJt1qxZGX9/lJWVxdq1a+Oll16KRx99NG6++eb4zne+EyeffHI0adIkOnfuHCNHjox333035f0/+clPsvqeycdnJB/ezxX58MMPU75TzjnnnJTvn4iI4cOHJ9Wefvrp2Lp1a9rzVVZFP4N69epFo0aNcpCovHzeI4dT0zMmIvvnDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQOYlcBwAAAAAAAAAAAAAAAIB88Prrr8eECRNS9q6++uro0qVLlhPVTl/60pfi8ccfj4KCgqTe1q1bY/jw4ZWac8stt8TSpUtT9oYOHRrXXHNNjXLmwsGDB2PTpk3lao0bN46GDRvmKFH+O/744+Piiy9OqpeUlES/fv1i9OjRsW/fvhqvc+SRR9Z4xqEcffTRWZ+9efPmjK35qVR7PqL27fsNGzakrGfq59KwYcNo06ZNRmZn0pQpU1LWBw8e/NnHAwYMSOpv3LgxFi5cWKO1i4qKkmqdOnWKDh06pMzxqW3btsW8efNqtDb5+Yx8+OGHKeuZfPYqmr1+/foqzZk2bVrKd9ewYcPKfT5o0KCk37emTZt22PmFhYVJtZ49e8aXvvSlzz4/+uijo2fPnknXTZw48bDzM6msrCxWrFgRv/71r6NLly7x05/+NOmapk2bxtVXX53VXPn2jOTL+7kiY8aMSaoVFBSk/HfGWWedFe3atavUjGwqLS3N+r6pinzfI9VVmTMmIjfnDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQGYlcBwAAAAAAAAAAAAAAAIB88X/+z/+J4uLipHqdOnXigQceyEGi2mfs2LHRpk2blL0f/OAH8eGHH1Zqzr59++LSSy9N+f2OiHjwwQfjxBNPrHbOXPnggw+Sal//+tdzkOSLYeDAgZFIJP+Z3MMPPxx/+ctf0rJGIpGIo446Ki2zKnLqqadmZO5XvvKVOProo5Pq+/fvj/fffz8ja35eqj0fUbv2/YoVK1LWM/VzOfHEE6OgoCAjszNpypQpKeuDBw/+7OMBAwYk9WfOnFnjtSua0b9//4iIaNmyZfTq1SupP2PGjDhw4ECN1/97l4/PyDvvvJOyfvrpp9do7qH06NEjZX3ZsmVVmrN9+/Z4/vnnk+pnnXVWNGvW7LPPzz///KRrCgsLDzt/5cqVsXz58nK1RCJR7vkdMmRI0s+gpKQkpk+fftj52VJWVhb/8R//EQ8//HBS77zzzstqlnx8RvLh/VyRGTNmxEcffZRUHzFiRFLtqquuSqqtXLky5s2bl4loVbJmzZqU9e7du2c5SWr5vEfS4VBnTET2zxkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDMSuQ4AAAAAAAAAAAAAAAAA+eKDDz6IBx98MGXv3HPPjYEDB2Y3UC1zzTXXxNChQ1P2Hn/88Zg8eXKV5i1btixuueWWlL3GjRvH+PHjo27dulXOmUtvvfVWUu3000/PQZIvhjPPPDNlfcKECWlbo3v37tGoUaO0zUulV69eGZnbs2fPlPVVq1ZFaWlpRtb8vFR7PqJ27fvly5enrGfq59KnT5+MzM20N998Mz744IOk+mmnnRatW7eOJk2axD/8wz8k9YuKimq89vvvvx8rVqxIqn/63h0wYEDUqVMnqf/MM8/UeG3y8xl5++23U9Z79+5d49mpdO7cOb70pS8l1UtKSmLVqlVVnjdx4sSkWv369aN///6ffXzuueeW669duzaWLl1aqfnTp09Pqg0ZMuSzj4cNG5bUnz17duzcubNS87PpjjvuiAMHDpSrnXbaaVnNkI/PSD68nytSWloaf/jDH5LqJ5xwQrlnvEmTJvHd73436bpHH300o/kqa/HixSnrmdo3VZXPeySdUp0xEdk/ZwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAzEjkOgAAAAAAAAAAAAAAAADkk3vuuSc2btyYsveLX/wi6tSpk+VEtcOJJ54YDz74YMre6tWr44YbbqjW3F//+tcxa9aslL3u3bvH3XffXa25ubJgwYKkWt++fbMf5Aviy1/+csr6u+++m7Y1zj777LTNOtQa9evXT/vcgQMHpqy/8soraV+rIqn2fETt2vd//vOfU9YHDBiQkfWGDBmSkbnZMHXq1KRaIpGIAQMGpNzHBw8ejNmzZ6dl7ZkzZybVzjrrrKhfv34MHjw4qVdSUlLh+4OqycdnZM6cOSnrgwcPzsjvasOGDUtZnzdvXhw8eLDK86ZOnRr79u2rcJ2+fftG06ZNy/UKCwsrPX/atGlJtf79+0fdunWjSZMm0a9fv6T+pEmTKj0/m7Zs2RKLFy8uV2vWrFlG3qsVycdnJB/ez4fy6KOPRllZWVJ9xIgRn3184YUXRpMmTcr19+/fH4899lim41XKX/7yl5T1in5/y7Z83yPpkuqMicj+OQMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZEYi1wEAAAAAAAAAAAAAAAAgn+zcuTPuvPPOlL2TTjoprr/++iwnyr26devG+PHjo3Hjxkm9gwcPxmWXXRa7du2q9vwrr7wyNm/enLJ38803R58+fao9O9tmz56dVDv//POjdevWOUiT/1q2bJmyXlxcnJb5iUQirrnmmrTMOpTWrVvH9773vbTOPPLII+PSSy9N2XvuuefSutahpNrzEbVr38+ZMydl/aSTTop+/fqlda0OHTqkfWY2TZkyJWV98ODBMXDgwKT6a6+9Ftu2bUvL2kVFRUm1xo0bx9lnnx39+/dP6s2ZMyd2796dlrX/3uXjMzJv3ryUP/9jjz02/vEf/7HG8/9WvXr14sYbb0zZKywsrNbM7du3x/PPP59UHzRoUNStWzeGDBmS1Js2bVql57/66quxZcuWcrUjjjgievfuHeedd140aNCgXG/fvn3V/lr+Vps2bWo8I5WPPvooqdaiRYuMrJVKPj4j+fB+PpQ1a9akfEYuuuiiz/5NctVVVyX1CwsLY9OmTZmOVykV/T721a9+Nc4555wsp0mWj3skm2dMRHbPGQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMxK5DgAAAAAAAAAAAAAAAAD5ZsyYMfHOO++k7P30pz+NFi1aZDdQjv3nf/5ndO/evcLea6+9VqP5GzZsiO9///spe4lEIp588sm8+Z6vXr063nrrrXK1+vXrxzXXXJPWdZo3bx5t2rRJ68zaaOfOnSnrrVu3Tsv8Sy65JE444YS0zDqcH//4x1GnTp20zfvRj34UDRs2TKrv3r07Zs+enbZ1DifVno+oXft+w4YN8eqrr6bs3XrrrTWNVc7dd98dBQUFaZ2ZTS+//HJs2bIlqX7eeefFwIEDk+ozZsxI29rz5s2LPXv2JNXvvvvuaNmyZVJ9ypQpaVv7710+PiP79u2L//mf/0nZu+2226JevXo1XuNTP/jBD6Jt27ZJ9ZKSkpg0aVK1506cODGp1rx58+jTp08MGTKkXH3nzp0xd+7cSs8uLS2NoqKipPqQIUNi2LBhSfXnn38+tm/fXun5n3fMMcfEb3/721izZk0MHTq02nMqUr9+/aTa3r17075ORfLxGcmH9/PhjBkzJqnWtGnT+O53vxvt27ePM888s1L35MrHH38c8+fPT9n7yU9+kta1fvCDH8Qpp5xSpXvyaY/k4oyJyO45AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABkRiLXAQAAAAAAAAAAAAAAACDflJaWxo9//OOUvVatWsWdd96Z5US506dPn/j3f//3lL3XXnst7r777rSsU1hYGGPGjEnZO+aYYyrs1UaPPvpoUu22226LTp06pW2NBx54IJYvXx433nhjJBJf3D8j27x5c8p6r169ajz7K1/5SjzwwAM1nlNZXbt2jfvuuy8ts/r06RM333xzyt4f//jH2LlzZ1rWqaxUez6idu37hx56KGX9rLPOin/7t39LR7zo379/XHrppWmZlSulpaXx7LPPJtWPOOKIOO6445LqRUVFaVu7pKQk5s6dm1Q/9dRTk2qlpaUxffr0tK1Nfj4j999/f5SVlSXVu3btGg8++GBa1ujWrVvcf//9KXtPPPFEbNy4sdqzp06dGvv370+q33777dGuXbtytVmzZqW89lCmTZuWVBs6dGgMHjw4qT5p0qQqzf7UMcccEw8//HCsWrUqrrvuuqhfv378+te/jlatWlVrXkU6duxY7vM9e/Zk/V2Xj89IPryfD2Xq1Kkpn7ERI0bElVdeGQUFBeXqa9asiTlz5qRt/XR45JFHUtbPOeecGDlyZFrWOPXUU+O3v/1tLF68OKZPnx49evSo9L21fY/k6oyJyM05AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACkXyLXAQAAAAAAAAAAAAAAACAfzZw5M55//vmUvX/5l3+JTp06ZTlR9rVo0SKefPLJSCSS/0xp165dcdlll8XBgwfTtt4Pf/jDWLFiRcrehRdeGMOHD0/bWpk0duzY2LRpU7la48aN46mnnoomTZrUeP7VV18dI0aMiCOOOCJ+9atfxaJFi6JXr141nlsbVbQfrr322hrNbdy4cUyePDlat25dozlVddNNN8U111xToxlf/epXY8KECVGnTp2k3oEDB+LBBx+s0fzqSLXnI2rXvp80aVJ88MEHKXv33ntvDBkypEb5vva1r8X48eNrNKO2eOaZZyp13ccffxxLlixJ69pFRUWVuu7VV19Nueeovnx8Rt59992YOHFiyt4///M/x0033VSj+Z06dYopU6ZEw4YNk3rFxcVx77331mj+9u3bU/6u2adPn6TatGnTqjx/1qxZsW/fvnK1E044IVq2bFmuduDAgWrNj4h45JFH4vrrr4/69et/VjvuuONi0qRJ0ahRo2rN/LwePXpEx44dy9XWrVuXltlVkY/PSD68nw/lwIED8fjjjyfV+/btG9dff31S/fe//32UlZWlZe10+dOf/hQrV65M2bvvvvti4MCBNZrfpk2bmDRp0mf/Xhs8eHD85S9/iTlz5sRRRx112Ptr+x7J1RkTkZtzBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABIv0SuAwAAAAAAAAAAAAAAAEC++tGPfhSlpaVJ9Xr16sX999+fg0TZ9bvf/S6OOeaYlL1//dd/jdWrV6d1vb1798all14a+/fvT9kfPXp0tG/fPq1rZsKePXvizjvvTKqfdtpp8fLLL8dRRx1V7dk33nhj/O53vytXO+WUU2L+/Plx3nnnVXtubTVr1qyU9XPPPTe+//3vV2tm27Zt45VXXomePXt+Vlu0aFG1ZlXGRx99VO7zMWPGxC9/+cuoU6dOlWcNGjQoXnvttWjTpk3K/ujRo2P58uXVylkTFe35iNqz7/fv3x8/+tGPUvbq1q0bU6dOjX//93+vVr5zzjkn/vznP0fLli0/q3344YfVmlUbzJ49O/bs2XPY62bOnJn2tSs7c8qUKWlf++9dvj4jI0eOjO3bt6fs/fKXv4xHHnkk6tevX+W55557bixYsCDatWuXsv/Tn/40Lb8HTZw48bDXHDx4MIqKiqo8e9euXTF37tzDXvfCCy/E1q1bqzw/IuL222+PsrKypPrZZ58dL7zwQhx77LHVmvupFi1axNixY5PqmTh/Dicfn5F8eD8fzqOPPppUKygoSMp98ODBGDduXFrWTKeDBw/Gv/3bv6Xs1atXLwoLC2PkyJHVmn3SSSfFyy+/HMcff3xSr02bNrFp06bDzqjteyRXZ0xEbs4ZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACD9ErkOAAAAAAAAAAAAAAAAAPnqrbfeij/84Q8pe+eff36cddZZWU6UPcOHD4+LLrooZW/y5Mnx2GOPZWTdhQsXxh133JGy16xZsxg/fnzUqVMnI2un029/+9uYN29eUv2b3/xmvP322/HP//zPUbdu3UrP69q1a8ycOTN+9atfRSKR/Gdjr7/+esyZM6dGmWujP//5z7F58+aUvTFjxsTtt99e6e9j/fr148Ybb4wlS5ZEt27dPqtv27atwj2XDr/73e/ivffeK1e76aab4p133ol//Md/jIKCgsPO6Nq1axQWFsazzz4bRxxxRMpr/vrXv2b06zicivZ8RO3Z908//XQ8++yzKXuJRCJ+/vOfx6JFi+K8886r1LyTTjopnnjiiZgzZ060atXqs3pxcXGMGjWq0rlqm+Li4pg1a9ZhrysqKkr72qtXr46VK1ce9rpp06alfW3y8xnZsGFDXHfddRX2r7322lixYkVcfvnllTp/unTpElOmTInZs2dHixYtUl7zyiuvxH333VfdyOVMnTo19u/ff8hrXn311fjkk0+qNb8yz8rEiROrNTsi4s0334zf/va3KXu9evWKd955J26//fY48sgjqzz7vPPOiwULFsTXv/71pN6kSZOqPC8d8vEZyYf386GsXLmywvx/a+bMmfHRRx+lZc10mz59eoX/dqpTp048+OCD8cYbb8S3v/3tSs1r2rRpjBo1KhYuXBidOnVK6peVlcUPf/jDKCsrq9S82rxHcnXGROTunAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0qturgMAAAAAAAAAAAAAAABAPhs1alR873vfiyZNmiT1HnjggejWrVuUlZXlIFnmdOjQIUaPHp2y9+GHH8YPfvCDjK7/3//93zFgwIA488wzk3o9e/aM22+/Pf7jP/4joxnS4aKLLooNGzYk1Vu3bh0PPfRQ3HHHHTFz5sx4/vnnY+3atbFx48bYs2dP1K9fP5o1axbHHXdcnHzyyTFw4MDo2bNnhet8/PHHceGFF0ZpaWkmv5ycKCkpiZ/97GfxwAMPJPUSiUTcddddcd1118Uf//jHePnll2P58uWxbdu2KC4ujubNm8dRRx0VHTt2jPPOOy8GDRoUX/7yl8vNKCsriyuvvDI2bdqUsa+huLg4rrjiipg3b17Ur1//s/qJJ54YkyZNis2bN8dzzz0XCxcujPXr18fWrVujWbNmcfTRR0enTp2if//+0blz50OusXfv3hg2bFjs3LkzY19HZVx00UXx+uuvx3HHHZfUqy37/vLLL4833ngjOnbsmLLfrVu3eO6552L9+vUxc+bMWLp0aWzYsCG2bt0aDRo0iFatWsXXv/71OOuss6Jbt24pZ4wcOTJWr15dpVy1zZQpU+KCCy6osH/gwIGYM2dORtaeOXNmdOrUqcL+22+/HatWrcrI2uTnMzJhwoT4+te/HrfddlvKfrt27eKPf/xjjB49OmbNmhULFiyI9evXx5YtW6JJkyafnbcDBgw47Hm7evXqGDZsWBw8eDAt2bdt2xYvvPBC9O/fv8Jrpk2bVu3506dPj4ceeqjC/oEDB2Lq1KnVnh8RcdNNN0WPHj3i1FNPTeo1bdo07rrrrrj99tvj1Vdfjblz58a7774bf/3rX2Pnzp2xZ8+eKCgoiCZNmkSLFi3ihBNOiG7dusXAgQMrPAemT58e8+fPr1HmmsjHZyQf3s+HMmbMmOjTp89hr6nNrrvuujjxxBPjW9/6Vsp+9+7dY9asWbFp06aYPXt2vPnmm7Fx48bYsmVLREQ0b9482rdvHz169Ihvf/vb0ahRowrX+q//+q944YUXqpSvNu+RbJ8xEbk/ZwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA9Kmb6wAAAAAAAAAAAAAAAACQz9avXx/33ntv3H333Um9U045Jf7pn/4pxo4dm4NkmVGnTp146qmnolmzZkm9srKyGD58eGzdujWjGcrKyuLyyy+Pt956K5o3b57UHzVqVMyePTteffXVjOaoqY0bN8a6devimGOOSdk/+uij46qrroqrrrqq2mts2LAhzjvvvPjggw+qPaO2e/jhh2P48OHRrVu3lP22bdvGLbfcErfcckuVZ99yyy1RWFgYPXr0qGnMQ3rttdfiuuuui7Fjx0ZBQUG53pFHHhmXX355XH755dWavXfv3vjOd74TS5YsSUfUGtm4cWP069cvXnzxxVq777dv3x79+/ePF154Idq1a1fhdW3atIkRI0ZUef6vf/3rGDNmTJx55plVvrc2efbZZ+PAgQNRt27qP1OdP39+7NixIyNrFxUVxY033lhhf+rUqRlZl/8nX5+RUaNGRUFBQdx6660VXtO8efO46KKL4qKLLqrWGu+88070798/tmzZUt2YKU2cODH69+9fYX/69OnVnr127dpYsmRJnHLKKSn7L730UnzyySfVnh8RsW/fvhgwYEDMmjUrvvnNb6a8pl69etGnT5/o06dPjdbavHlzXH/99TWaUVP5+Izkw/v5UJ5++un4zW9+E61atUrZ/+ijj2LGjBlpXTPdSkpKYuDAgTFjxow444wzKryudevWcdlll8Vll11WrXV+//vfx6hRo6p8X23eI9k8YyJqxzkDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKRPItcBAAAAAAAAAAAAAAAAIN/94he/iA8//DBl72c/+1k0bdo0y4ky54477oiePXum7P3yl7+MF198MSs51q5dG9ddd13KXp06deLJJ5+MZs2aZSVLTfTq1SsWLFiQkdmLFi2KU089Nd56662MzK8t9u3bFwMGDIj3338/bTP3798f1157bdx3331pm3k4f/jDH+Kqq66K/fv3p23mhg0b4tvf/nY899xzaZtZUytXrqz1+37VqlVxxhlnxKJFi9KYLOLee++NkSNHpnVmrmzdujVefvnlCvtFRUUZW3vu3Lmxd+/eCvtTpkzJ2Nr8P/n6jNx2221x9dVXx+7du9M+e8aMGXHGGWfE2rVr0z576tSpFb4bVqxYEStWrKjR/MLCwgp7kyZNqtHsT23evDn69u0bU6dOTcu8ivTu3bvC38mzKR+fkXx4P1ekpKQknnzyyQr7f/jDH6K0tDTt66bb9u3bo1+/fjFu3Li0zy4tLY177rknrrnmmigrK6vWjNq8R7J1xqxbt67WnDMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQHokch0AAAAAAAAAAAAAAAAA8t3evXvj1ltvTdk7+uijK+zlm29961tx2223pewtWbIkfvKTn2Q1z4QJE+Kpp55K2Wvfvn089NBDWc1THevWrYvevXvHbbfdFnv27EnLzD179sQtt9wSPXr0iHXr1qVlZm23YcOGOP3002PGjBk1nrV06dLo0aNHjBkzJg3JquaJJ56Ib33rW7Fy5coaz5o0aVJ06dIlXnnllTQkS6982PcffvhhnH766XHXXXdFSUlJjWZt3rw5hg4dmvUzMtOeeeaZCntFRUUZW7ekpCTmzp2bsrdu3bpYtGhRxtbm/5evz8jYsWOja9eu8dxzz6Vl3scffxxXXHFFDB48OLZt25aWmZ+3devWePHFF1P2CgsLazx/2rRpKesHDx6MKVOm1Hj+p3bu3BkXXHBBXHjhhfHBBx+kbW5ERFlZWTz55JOxfPnytM6tiXx8RvLh/VyRin5vKysri9///vcZWzfdiouL4/vf/36cf/75sXr16rTMXLVqVZx77rkV/juuKmrzHsnGGXPaaafVqnMGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKi5RK4DAAAAAAAAAAAAAAAAwBfBE088EW+++WbK3k033RTHHXdclhOlV7NmzeKpp56KOnXqJPWKi4vjkksuif3792c91/XXXx9r1qxJ2bviiivi4osvznKiqtu/f3/cc8890b59+/jZz34W69atq9actWvXxh133BHHHnts/PznP4+DBw+mOWnttmnTphg8eHBceOGF8corr1T5/kWLFsX3vve9+MY3vhGLFy9Of8BKeuONN6JLly5x/fXXx+rVq6t0b3FxcUyaNCm++c1vxkUXXRRbtmzJUMqay4d9f+DAgbjzzjvj+OOPj1/84hexadOmKt2/cePGuOuuu6JDhw5RWFiYtly1xbRp01LW161bF2+//XZG1y4qKkpZnzp1akbXpbx8fUbef//9GDBgQJx22mkxceLE2LNnT5VnLF68OK699to4/vjj48knn8xAyvImTpyYsl7Rc1gVCxcujI8//jipPm/evNi8eXON53/e5MmTo3379nHhhRfG888/HyUlJdWetXXr1hg3blycfvrpccUVV6QxZXrk4zOSD+/nVJYtWxavvfZaUn3OnDnx17/+NaNrZ8L06dOjc+fOcdlll8X8+fOjrKysyjOWLFkS1157bXTu3DlefPHFtGWr7Xskk2fM+vXr05IRAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKg96uY6AAAAAAAAAAAAAAAAAKRT+/btc7b2N7/5zayu98wzz0RBQUFW1tq5c2dOv7cV2blzZxx//PG5jpEWGzdujFGjRsWoUaPi1FNPjd69e0f37t2jXbt2cdRRR0WTJk2ibt26sW/fvtixY0ds27Ytli9fHsuWLYsXXnghli5dmrYs2dpXEREjRoyIESNGpG3e5MmTY/LkydG5c+fo3bt39OrVKzp27BgtWrSIli1bRr169WLnzp2xbdu2ePfdd+PNN9+MGTNmxHvvvVfhzAULFqTle1LZGfv3749HHnkkHnnkkejevXuce+658Y1vfCNOOOGEaN68eTRt2jSKi4tj+/btsX79+li6dGksWLAgnnvuudi9e3eNc1Ync3XVpn1fkfXr18ePf/zjuPnmm+PMM8+M3r17xymnnBLHH3/8Zz+PPXv2xI4dO2Lt2rWxePHiePnll+Oll16K0tLSlDNffvnlrD5nmbBu3bqcfQ2jR4+O0aNH52TtdH3N+XzOfl6+PiNvvPFGXHzxxdGwYcM499xzo0ePHnHyySfHV77ylc9yl5SUxPbt2+OTTz6JZcuWxZIlS2L27NmxZs2ajGb7vHHjxsW4ceMyNr9t27YZm51KaWnpZ+/rxo0bR58+feLkk0+Ok046KU444YRo1qxZNG3aNJo0aRJlZWWxa9eu2LlzZ+zYsSNWrVoVS5cujaVLl8b8+fPjwIEDWc1eHfn4jOTD+/nzevXqldX1Mn1GHThwIMaPHx/jx4+PNm3aRN++faNnz57RsWPHOPbYY6Np06bRqFGjKC0tje3bt8e2bdvi//7f/xuLFi2KF198Md59992M5qvNe+Tv7YwBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKqvbq4DAAAAAAAAAAAAAAAAAFDeG2+8EW+88UauY+S15cuXx/Lly2Ps2LG5jlIjCxcujIULF+Y6RlbU9n1fWloac+fOjblz5+Y6CtRK+fqMFBcXx/Tp02P69Om5jvJ3ac+ePTFz5syYOXNmrqNkXL4+I7X9/fz3YP369TFhwoSYMGFCrqOkVJv3yN/TGQMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVF0i1wEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgWxK5DgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADZksh1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMiWRK4DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQLYkch0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsiWR6wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQLYlcBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBsSeQ6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGRLItcBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIFsSuQ4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2ZLIdQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADIlkSuAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEC2JHIdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALIlkesAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkC2JXAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAbEnkOgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABkSyLXAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBbErkOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANmSyHUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyJZErgMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAtiRyHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACyJZHrAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJAtiVwHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgGxJ5DoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZEsi1wEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgWxK5DgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADZksh1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMiWRK4DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQLYkch0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsiWR6wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQLYlcBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBsSeQ6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGRLItcBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIFsSuQ4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2ZLIdQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADIlkSuAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEC2JHIdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALIlkesAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkC2JXAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAbEnkOgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABkSyLXAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBbErkOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANmSyHUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyJZErgMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAtiRyHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACyJZHrAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJAtiVwHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgGxJ5DoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZEsi1wEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgWxK5DgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADZksh1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMiWRK4DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQLYkch0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsiWR6wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQLYlcBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBsSeQ6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGRLItcBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIFsSuQ4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2ZLIdQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADIlkSuAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEC2JHIdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgP+P3TmmAQAAQAC02T+0LfSBBAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICyO8c0AAAACIA2+4e2hT6QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAFD262An6jOM4vDHO3+FMqJlFhKTBleu6gXAvokbN96it9Eb0O5NDHFFwsZEhC4sAdL0CkSTwnuYmee5gt/u5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQpdIBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0KXSAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANCl0gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQpdIBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0KXSAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANCl0gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQpdIBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0KXSAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANCl0gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQpdIBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0KXSAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANCl0gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQpdIBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0KXSAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANCl0gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQpdIBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0KXSAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANCl0gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQpdIBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0KXSAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANCl0gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQpdIBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0KXSAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANCl0gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQpdIBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0KXSAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANCl0gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQpdIBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0KXSAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANCl0gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQpdIBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0KXSAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANCl0gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQpdIBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0KXSAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANCl0gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQpdIBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0KXSAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANCl0gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQpdIBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0KXSAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANCl0gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQpdIBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0KXSAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANCl0gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQpdIBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0KXSAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANCl0gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQpdIBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0KXSAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANCl0gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQpdIBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0KXSAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANCl0gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAH1+a8gABGRRJREFUAAAAAAAAAAAAAAAAAADQpdIBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0KXSAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANCl0gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQpdIBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0KXSAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANCl0gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQpdIBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0KXSAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANCl0gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQpdIBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0KXSAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANCl0gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQpdIBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0KXSAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANCl0gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQpdIBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0KXSAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANCl0gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQpdIBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0KXSAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANCl0gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQpdIBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0KXSAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANCl0gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQZUoHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcPc2NzfHfD5PZ8B3PXjwYPzz7Z90Btxomk1jsVikMwCW2jSbbD732ubmpr0HuAX2nvtse3vb3gP8T9dX1/aee29nZ2dcXl6mMwCW2r9/j3E1pSvg+3Z/HeNqK10B33d6eppOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADgB6Z0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHfv+fPn4+DgIJ0BN/r06VM6AW60u7s7Xr9+nc4AWHo2n/tsf39/7O/vpzMAlp695z57+fvL8fL3l+kMgKV2dnY2zs7O0hlwo8PDw3QCwNK7+GuMi3QE3ODVH+kCuNnbt2/TCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/EClAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKBLpQMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgS6UDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoEulAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKDLlA4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADg7h0dHY2jo6N0BgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQFylAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKBLpQMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgy5QOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlt+TJ0/G06dP0xmsmfl8Pk6/nKYzWENbm1vjxYsX6QyAFvaWBFsLrJOtzS1bS7v5fG5rgbVha0l5/PixvQXWxi+XY3z7lK5g3Sw2xzC1JHz+/Hmcn5+nMwAAAAAAAAAAAAAAALglUzoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYfnt7e+Pg4CCdwRo6OTlJJ7CGdnZ2xuHhYToDoI29pZutBdaNraXbYrGwtcBasbUk7O3tjb29vXQGQI+LMf7+Kx3Buvnt0Ri/ubYEvHv3bpyfn6czAAAAAAAAAAAAAAAAuCWVDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAulQ4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACALpUOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgC5TOgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFh+FxcX48uXL+kMAAAAAAAAAACAO3FxcZFOAAAAAAAAAAAAAAAA4BZN6QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGD5HR8fj+Pj43QGAAAAAAAAAAAAAAAAAAAAAAAAAAAA/FClAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKBLpQMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgS6UDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoEulAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKBLpQMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgS6UDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoMuUDgCAn/Hq1auxvb2dzmCFzWaz8fHjx3QGa+DZs2fjzZs36QyA/62qbCd3brG7sJvAStjY2LCb3LnZbGY3gZVhN+lwfX1tO4GVcf7nGBsb6QpW2exqDLNJhw8fPoyjo6N0BgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwJqZ0AAD8jPl8Ph49epTOYMVdXV6lE1gD0zSNnZ2ddAbArbCd3LXZbGY3gZVhN7lrGxsbdhNYGXaTLrYTWBX/fksXsOo2xhhmkw4PHz5MJwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAa6TSAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANCl0gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQpdIBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0GVKBwDAz3j//v2YJrMFAAAAAAAAAACr6OvXr+kEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGCNTOkAAPgZJycn6QQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYAVUOgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC6VDoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAulQ6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALpUOgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC6VDoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAulQ6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALpUOgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC6VDoAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+I+9Ow+Psrz3x/9JCJuJC4sggksVATlIES2KUuoC4oI7ohZQa49aKlqqUlBbN6ieilSPVVHbr7YFBTeqxXOqAsfaKqi4AEWtIq4oFQ0qS4IBMr8//HV0CEgymWRmktfrut7X5f3MPPd9Tx7kzTDJAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUF8Ks70BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqC+F2d4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1JfCbG8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA6kthtjcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA9aUw2xsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA+lKY7Q0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAfSnM9gYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgvhRmewMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQXwqzvQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACoL4XZ3gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADUl8JsbwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADqS2G2NwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD1pSjbGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAat6ZNm0bv3r2jV69e0blz59h+++2jpKQk1q9fH6tWrYoVK1bEokWL4oUXXogPPvgg29sFANKk8wGg4dP3ANCw6XoAaBx0PgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI1FUbY3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADROvXv3jgsvvDBOOOGE2H777at1zgsvvBBTpkyJO++8M9atW5exvey+++5x4oknRr9+/aJ79+7Rvn372HbbbaNJkyZRVlYWy5cvj1dffTWefPLJuO+++2L58uUZW/ub9O/fP5566qmMz3vqqafG/fffHxER3bt3j4ULF0ZR0Vf/nM2VV14Z11xzTUbWatWqVSxZsiTatGmTPHbFFVfE+PHjt3pufVyXoqKiOPvss2t83paUl5fHlClTMjYfQEOQK53fqVOnOOaYY+KQQw6JvffeOzp16hQlJSXRvHnzKC8vj5UrV8aSJUti3rx58cgjj8Rzzz2XkXW3Rt/re4CGIFf6vib22Wef6Nu3b3L86quvxtNPP11n6+n8uu18fQ9Qt3Kt67/3ve9F165dv/E5CxcurLf39v+m77P3Wcsee+wRQ4cOjf79+0e3bt2iffv20bJly9iwYUOsWbMm3n333Vi0aFH85S9/iZkzZ8batWsztjZAQ5JLne8zfH2/KX0PAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADUhYJEIpGo1hMLCup6L0Ce6tmzZ/Ts2TMiIhKJRLz11lvx7LPPRjV/ewEAAAAAAAAAAAAgDQUFBbH//vtHly5dkt/vvWjRoli0aFGWd9Y4+Z5aAAAAAAAAAAAAgPpVUFAQ3/nOd2Kvvfby/bRAtdXme7zdqx3YEj9XAulr37593HLLLTFkyJC051i+fHn87Gc/i6lTp9ZqL126dInrrrsuTjzxxGr3/saNG+OPf/xjjBs3LlasWFGr9bemf//+8dRTT2V83lNPPTXuv//+5PiGG26Iiy++ODkuLy+Pbt26xXvvvVfrtSZPnhw/+tGPkuM333wz/uM//iMqKiq2eE59Xpcdd9wxo9fxX//6V3To0CFj8wHks1zp/G7dusWECRPixBNPjMLCwmqf9/LLL8eYMWNizpw5aa9dHfpe3wPks1zp+5pq27ZtLFiwIDp27Jg8dvvtt8fIkSPrbE2dX7edr+8B6kaudv3jjz8eRxxxxDc+54YbbogxY8ZkbM3q0Pf1/1lL586d44Ybbojjjz++2uesXLkyrrvuuvj1r38dlZWVaa8N0JDkWuc/9NBDPsPX90n6HtgS92rPLb6nFgAAAAAAAAAAAKB+uVc7kA73agfqgp8rAQAAAAAAAAAAAKh/7tWeW3xPLQAAAAAAAAAAAED9cq92IB3V+R7vwnrYBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBERBx22GGxaNGiGDJkSK3m6dChQ0yZMiWmTJkSzZs3T2uO4cOHx8svvxwnnXRS8h+Hqo4mTZrED37wg/jHP/4Rffv2TWvtXHPVVVfFhx9+mBy3bNkybrzxxlrP26tXrzj33HNTjo0aNSoqKiq2eE59X5eSkpJqPxeA6suVzh89enQsXLgwTj755CgsrNk/3bbvvvvG7NmzY9KkSTVeNxfpewAyLVf6Ph1Tp06Njh071sta9a2xdr6+B8i8XO76vfbaKyPz5KvG2vebOv3002PhwoVx/PHH1+i81q1bx8SJE2POnDlRXFyc1toADUmudf7w4cN9hh/6/t/0PQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUNeKsr0BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoHE4+uijY8aMGdG8efOU4+vWrYtZs2bFzJkzY8GCBbFixYpYuXJltGjRInbcccfo1KlTHH744XHcccdFt27dUs4dPnx4tG/fPo477rhYt25dtfcyYsSI+MMf/hAFBQUpx1etWhVz586NJUuWxKpVqyIionXr1tGrV6/o06dPNGnSJPncdu3axaxZs+Kggw6KRYsW1fTLkZaysrK47bbbaj3P66+/njJes2ZNXHTRRTF9+vTksZNOOikGDBgQs2fPTnudW265JQoLC5PjGTNmxOOPP77F52fjuhQXF9f0ZQGwFbnS+VdccUVcffXVVY6XlpbGs88+G2+99VasWrUqEolEbLfddtG5c+fo27dvtGrVKuX5F110UTRr1iwuuOCCGn4l0qPv9T1APsiVvk/HuHHjYtCgQXU2f3Xp/Mx2vr4HyKxc7vqioqLYdddd0z6/Pun7uvus5ayzzoq77rqrytpr166NJ598Mt57770oLS2NoqKi2HHHHaNnz56x//77p7y+Qw45JGbOnBmHH354JBKJaq8N0JDkWuf/u1u+zmf4+l7fAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAdakgkUgkqvXEgoK63guQp3r27Bk9e/aMiIhEIhFvvfVWPPvss1HN314AAAAAAAAAAAAASENBQUHsv//+0aVLl+T3ey9atCgWLVqU5Z01Tr6nFgAAAAAAAAAAAKB+FRQUxHe+853Ya6+9fD8tUG21+R5v92oHtsTPlUDN7LvvvjFv3rxo3rx58lgikYh77rknxo4dGx9++GG15hkyZEjccMMNsdtuu6Ucf+CBB2Lo0KHVmqNbt27x8ssvR4sWLZLHPvjggxg7dmzcf//9sX79+s2e17Fjx7j66qvjhz/8YcrxV199NXr27BkbN26s1vo10b9//3jqqaeS43/961/RoUOHjK/zb//3f/8Xhx56aHL8z3/+M/bZZ5/YsGFDjecaPnx4TJkyJTkuKyuLrl27xrJlyzb7/GxdlwMPPDDmzZuXHP/sZz+LOXPmbPX1bcmGDRu8RwUatVzp/EGDBsVf/vKXlPf1L774Ylx22WUxa9asLf65vWnTpjFkyJC4/vrro1OnTimPHX/88fHnP/+5WvuvCX2v7wHyTa70fTr69esXf/3rX6NJkyZVHrv99ttj5MiRdbJuhM6vbef/x3/8xzfuUd8DZE6ud31BQUHsuOOOVY5fddVVKV1+ww03xJgxY9JeJx36vn4+a+nRo0e89NJL0bRp0+SxlStXxpgxY+Lee++NdevWbfa8Tp06xX/913/FsGHDUo5fcsklMWnSpK2uC9DQ5Frnb9otPsP/kr7X98CWuVd7bvE9tQAAAAAAAAAAAAD1y73agXS4VztQF/xcCQAAAAAAAAAAAED9c6/23OJ7agEAAAAAAAAAAADql3u1A+mozvd4F9bDPgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBGrLi4OB588MFo3rx58tiGDRvi+9//fowYMSI+/PDDas/14IMPRo8ePeJvf/tbyvFTTjklfvSjH1VrjltuuSVatGiRHC9atCi+/e1vxz333BPr16/f4nkffPBB/Od//meMHDky5Xj37t1j6NCh1X4NuezHP/5xytegW7duceGFF9Z4npKSkrj++utTjl1zzTWxbNmyLZ6TretSUlKSMn7llVfipZdeSjv+cTGgMcuVzi8oKIhJkyYl//HHiIi77747+vTpE0888cQ3/iNv69evj2nTpkWvXr1iwYIFKY9dd9111d5/LtP3+h6gNnKl79PRtm3bmD59ejRp0iTjc+eihtb51dnn1+l7gPTkQ9cnEolYsWJFlaxduzbtOfNVQ+v76n7Wcuedd0bTpk2T49dffz26d+8ed911V6xbt26L5y1btiyGDx9e5bVedtllUVxcXK21ARqKXOz8r3eLz/C/ou+/pO8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIC6UpjtDQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAN29ixY2OPPfZIjhOJRAwdOjSmT5+e1nxr1qyJI488Mp5++umU49ddd120atXqG8/t0qVLHHbYYcnxqlWrYvDgwVFaWlrt9W+//fZ46KGHUo6ddtpp1T4/l/3zn/+Mm266KeXYVVddFTvttFON5rnyyiujQ4cOKfNOmjRpi8/P5nUpLi5OGZeXl1d7TQBS5UrnJxKJGD16dMyePTsiIubPnx/nnHNOVFZWVnvt0tLSGDp0aFRUVCSPde/ePXr16lWzF5GD9L2+B6iNXOn7dEydOjU6duyYHN94440ZnT/XNLTO3xp9D5AZ+dz1jVFD6/vqvMc//fTTo2/fvsnxypUr44gjjoiPPvqo2mtfeumlsWDBgvj000/jtttuiyOPPDLWrl1b7fMBGoJc6/xNu8Vn+F/R9/oeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACoW4XZ3gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQcLVt2zYuvvjilGN33HFH/OlPf6rVvOXl5TFixIhYu3Zt8tgOO+wQl1566Tee98Ybb0SPHj3izjvvjPLy8rj22mvj/fffr/H6t912W8q4d+/eNZ4jV1199dXxwQcfJMfbbrttXH/99dU+v2vXrvGTn/wk5diPf/zj2LBhwxbPyeZ1KSkpSRmXl5fXeF0Acq/zZ8+eHQMHDoz99tsvzjvvvNi4cWON116yZEk88cQTKccOOOCAGs+Ti/S9vgdIR671fU2MGzcuBg0alBxPmjQpHn744YzNn6saUudvjb4HqL187vrGrCH1fXXe459zzjkp42uuuSbee++9Gq1bWVkZgwcPjp122inOP//8mD9/fo3OB8h3udj5m3aLz/BT6Xt9DwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1J2ibG8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaLjOPPPM2GabbZLjFStWxJgxYzIy9zvvvBNXX311XH/99cljZ599dvz85z+PioqKLZ736quvxnnnnReXXnpprFu3Lq21Fy9enDJu165dWvPkorVr18ZPf/rTuP/++5PHhg8fHpMnT4558+Zt9fzf/OY30bRp0+R4+vTp8eSTT271vGxdl5KSkpRxeXl5WmsDNHa52PkRES+99FKt1l6wYEEMHjw4Oe7YsWOt5ssV+l7fA6QjV/t+a/r16xcTJkxIjp999tkYN25cHHTQQbWaNx80pM7fGn0PUHv52vWNXUPq+629x99ll13ikEMOSY4//vjjuO2229Ja+4MPPkjrPICGIFc7/+vdkg6f4W+ZvgcAAAAAAAAAAAAAAAAAABqSpk2bRu/evaNXr17RuXPn2H777aOkpCTWr18fq1atihUrVsSiRYvihRde8HPHAJAmfQsAdUvXAkDd0rUAUPf0LQAAAAAAAAAAAAAAAAANUVG2NwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0XGeffXbK+K677oo1a9ZkbP4777wzrr766mjZsmVERLRp0yYGDx4cM2bM2Oq5K1euTHvdsrKylHGzZs3SnisXPfDAAzFnzpw4/PDDIyKioKAgbr311thvv/0ikUhs8bwTTjghBg4cmByvXr06LrroohqtXd/Xpbi4OGVcXl6e9voAjVkud35tfPbZZynjf6/fEOh7AGoqH/u+bdu2MX369GjSpElEfNlBQ4cOjQ0bNmRkz/mgoXT+1uh7gNrLx67nSw2l77f2Hn/w4MFRUFCQHD/yyCOxfv36tNcHaKxyvfPT7Raf4W+evgcAAAAAAAAAAAAAAAAAABqK3r17x4UXXhgnnHBCbL/99tU654UXXogpU6bEnXfeGevWrcvofnbfffc48cQTo1+/ftG9e/do3759bLvtttGkSZMoKyuL5cuXx6uvvhpPPvlk3HfffbF8+fKMrr8l/fv3j6eeeirj85566qlx//33R0RE9+7dY+HChVFUVJR8/Morr4xrrrkmI2u1atUqlixZEm3atEkeu+KKK2L8+PFbPbc+rktRUVGV+zfURnl5eUyZMiVj8wHURq70badOneKYY46JQw45JPbee+/o1KlTlJSURPPmzaO8vDxWrlwZS5YsiXnz5sUjjzwSzz33XEbWrQ5dq2sBaiNXuram9tlnn+jbt29y/Oqrr8bTTz9dZ+vp28337RdffKFrAbYi17r2e9/7XnTt2vUbn7Nw4cJ6fV8boWuz+ff7e+yxRwwdOjT69+8f3bp1i/bt20fLli1jw4YNsWbNmnj33Xdj0aJF8Ze//CVmzpwZa9euzdjaAJmSa33bmD631bVbp2sBAAAAAAAAAAAAAACAWktUU0SIiGw2PXv2TAwfPjwxfPjwxLBhwxJ9+/ZNFBQUZH1fIiIiIiIiIiIiIiIiIiIiIiIiIiINOQUFBYnvfOc7iWHDhiW/l7Nnz55Z31djje+pFRERERERERERERERERERERERERGp3xQUFCT69Onj+2lFpEapjWzvXURyN36uRGTr2Xnnnat067e+9a2Mr/OHP/whZY077rijzl/bbrvtlrLm559/Xifr9O/fP2Wd5cuX19v169q1a+KLL75IWf/cc8/d4vNbtGiRePvtt1Oe/9Of/rRef82lc12uuOKKlHN22WWXet2ziEhDSEPu/AkTJqSsecUVV2R8DX1fs+h7EZHsJF/7/rHHHkvOVVlZmTjmmGOSj23awZMnT67Tr6HOr1k27fytPV/fi4jULvna9V/PxIkTU+aeOHFivX8d9X3NUtP3+L/97W9Tnn/cccfV+zUWEcn3NITO31J8hl81+l5EGnrcqz234ntqRURERERERERERERERERERERERETqN+7VLiLppDayvXcRyd34uRIRqY+0b98+8cADD9TqzzMffvhhYvjw4RnZT5cuXRIPPfRQorKystrrb9iwIXHXXXcl2rVrV+dfr01/Lj5Thg4dmrLODTfckPJ4WVlZYtddd83Ia5g8eXLK3EuWLEk0a9YsZ67LjjvumJGv6b/V570LRES2lFzp227duiUefPDBxMaNG2u09ksvvZQ4/PDD6+VrpWt1rYhIOsmVrk0nbdu2TSxbtixlL/V9T/dMaWh9q2tFRL5Krnbt448/vtV1c+F+6pnS0Lo2kcjc3+937tw58fDDD9fo61laWpq45JJLEoWFhVn/f0xEJCL3+rYxfm6ra7ccXSsijTXu1Z5b8T21IiIiIiIiIiIiIiIiIiIiIiIiIiL1G/dqF5F0Uh2FAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAHDjnkkJTxW2+9FW+//XbG15k1a1bK+NBDD834Gps68MADU8Yffvhhna9Z315//fX49a9/nXLs2muvjVatWm32+ePGjYvdd989OV68eHHcfPPNdbnFKtK5LiUlJSnj8vLyjO4JoDFoyJ2/3377pYzfeOONOl+zPul7AKorH/t+3LhxMWjQoOR40qRJ8T//8z9pz5fPGkLnb42+B6idfOx6UjWEvt/ae/xevXqljBcuXJjpLQE0eA25832GX5W+BwAAAAAAAAAAAAAAAAAA8t1hhx0WixYtiiFDhtRqng4dOsSUKVNiypQp0bx587TnGT58eLz88stx0kknRUFBQbXPa9KkSfzgBz+If/zjH9G3b9+0188lV111VcrPkLds2TJuvPHGWs/bq1evOPfcc1OOjRo1KioqKrZ4Tn1fl03vfQeQ73Klb0ePHh0LFy6Mk08+OQoLC2t07r777huzZ8+OSZMm1XjdXKVrARqOXOnadE2dOjU6duxYb+vVp3zvW10L8KVc7tq99torI/Pkq3zv2ojM/P3+6aefHgsXLozjjz++Rue1bt06Jk6cGHPmzIni4uK01gbIlFzrW5/bfknXfknXAgAAAAAAAAAAAAAAAJlUlO0NAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1Tjx49UsbPPfdcnawzf/78lPGee+4ZzZo1i4qKijpZLyLi/PPPTxk///zzdbZWNo0fPz6GDRsWu+yyS0REtGnTJn75y1/Gj3/845Tn7bbbbjF27NiUYyNHjoyNGzfW214j0rsuJSUlKePy8vKM7gmgMWiond+tW7cYMGBAcrx+/fqYNWtWnayVTfoegOrIt77v169fTJgwITmeN29ejBs3LiN7zFf53vlbo+8Baiffup7Ny/e+39p7/L333jv532VlZfHuu+9Wec4222wTvXv3js6dO8d2220XhYWFsXr16nj33XdjwYIF8cknn2Rm8wB5qiF3vs/w9b2+BwAAAAAAAAAAAAAAAACAhuXoo4+OGTNmRPPmzVOOr1u3LmbNmhUzZ86MBQsWxIoVK2LlypXRokWL2HHHHaNTp05x+OGHx3HHHRfdunVLOXf48OHRvn37OO6442LdunU12s+IESPiD3/4QxQUFKQcX7VqVcydOzeWLFkSq1atioiI1q1bR69evaJPnz7RpEmT5HPbtWsXs2bNioMOOigWLVpUo/XTVVZWFrfddlut53n99ddTxmvWrImLLroopk+fnjx20kknxYABA2L27Nlpr3PLLbdEYWFhcjxjxox4/PHHt/j8bFyX4uLimr4sgJyVK317xRVXxNVXX13leGlpaTz77LPx1ltvxapVqyKRSMR2220XnTt3jr59+0arVq1Snn/RRRdFs2bN4oILLqjhVyJ9ulbXAnyTXOnadI0bNy4GDRpUp2tUh779sm91LUBVudy1RUVFseuuu6Z9fn3StXX39/tnnXVW3HXXXVXWXrt2bTz55JPx3nvvRWlpaRQVFcWOO+4YPXv2jP333z/l9R1yyCExc+bMOPzwwyORSFR7bYBMybW+bcyf2+raqnQtAAAAAAAAAAAAAAAAkGlF2d4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0DB16dIlZbxo0aI6Wef111+PioqKaNasWUREFBYWxp577hmvvfZanax37rnnxne/+92UY/fee2+drJVtZWVlMXr06HjooYeSx84777y48847Y8GCBcljN954Y7Ro0SI5/uMf/xhPP/10fW417etSUlKSMi4vL6/yePv27ZPPW7NmTXzwwQexbt26Wu4YoOFoiJ2/4447xoMPPhhFRV/9c2933313lJaWZnytbNP3+h6gOvKp79u2bRvTp0+PJk2aRETEypUrY+jQobFx48Y62XO+yPfO3xp9D1A7+dT1bFm+9/03vcdv0qRJFBcXJ8fLly9PeXzAgAExevToGDhwYPLX16YSiUQ8//zzMXny5Ljnnntiw4YNtXgFAPmpoXa+z/D1/b/pewAAAAAAAAAAAAAAAAAAaBj23XffmDFjRjRv3jx5LJFIxD333BNjx46NDz/8sMo5q1evjo8//jheffXVeOKJJ2Ls2LExZMiQuOGGG2K33XZLPm/gwIHxxz/+MYYOHVrt/XTr1i3uvPPOKCgoSB774IMPYuzYsXH//ffH+vXrN3tex44d4+qrr44f/vCHyWPFxcUxbdq06NmzZ73cI2/VqlUxZsyYOpn7vvvui/POOy8OPfTQ5LHf/OY3sc8++6T1897Dhw+Pgw8+ODkuKyuLn/zkJ1t8frauy6b3vvvZz34Wc+bM+cZzvomfjQeyJVf6dtCgQXHVVVelHHvxxRfjsssui1mzZkUikdjseU2bNo0hQ4bE9ddfH506dUoeHzVqVMyaNSv+/Oc/b3XtTNC1VelagC/lStemq1+/fjFhwoQ6m78m9G0qXQvwpVzv2o0bN8bOO+9c5fhVV10VI0eOTHveuqBrq8rE3+/36NGjytorV66MMWPGxL333rvFfy+lU6dO8V//9V8xbNiw5LFDDz00Lrroopg0adJW1wXIpFzrW5/bVqVrdS0AAAAAAAAAAAAAAACQWYXZ3gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQMLVr1y5lXFpaWmdrffrpp9+4dqaceuqpceutt6Yce+GFF+KJJ56ok/VywYwZM1JeX2FhYdxyyy3J8cCBA+PEE09Mjj///PO45JJL6nWPtbkuxcXFyf9ev359FBUVxWmnnRbTpk2L999/P1avXh1vvvlmLFiwIBYsWBBvvvlmlJWVxZtvvhl33HFH9OvXL+OvByDfNKTOLykpiXPPPTcWL14c//Ef/5E8/sorr9R7v9Unfa/vAbYmn/p+6tSp0bFjx4iISCQSMWLEiFi2bFnG9pfP8rnzt0bfA9ROPnU93yyf+/6b3uNvt912KeM1a9ZERETr1q3jz3/+c8yaNSuOOeaYaNas2RbnKCgoiAMOOCB+//vfx8svvxy9e/euxasAyE8NsfN9hq/vv07fAwAAAAAAAAAAAAAAAABA/isuLo4HH3wwmjdvnjy2YcOG+P73vx8jRoyIDz/8sNpzPfjgg9GjR4/429/+lnL8lFNOiR/96EfVnueWW26JFi1aJMeLFi2Kb3/723HPPffE+vXrt3jeBx98EP/5n/8ZI0eOTDnevXv3GDp0aLXXz2U//vGPU74G3bp1iwsvvLDG85SUlMT111+fcuyaa675xnsJZuu6lJSUpIxfeeWVeOmll9LOokWLtromQKblSt8WFBTEpEmToqCgIHns7rvvjj59+sQTTzwRiURii+euX78+pk2bFr169YoFCxakPHbddddVe/+5TtfqWiA/5UrXpqtt27Yxffr0aNKkSZ3Mn2vyrW91LUB+dG0ikYgVK1ZUydq1a9OeM1/lW9dGZObv9++8885o2rRpcvz6669H9+7d46677op169Zt8bxly5bF8OHDq7zWyy67LOXfZgGoa7nYtz633Txd+yVdCwAAAAAAAAAAAAAAAGRCYbY3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADRMJSUlKePPPvusztbadO5N166tbbbZJm666aaYNm1aFBUVJY+vXbs2fvjDH0Yikcjoerlm1KhRUVFRkRwffPDBMWzYsCgqKoqbb7455bmXX355fPzxx/Wyr0xcl6//WiksLIz3338/pk2bFqeddlp06tRps+cUFBTEnnvuGeeee278/e9/j3nz5kXv3r1r/4IA8lQ+df7+++8fM2fOTMmjjz4ac+bMicWLF8dnn30Wd9xxR7Rr1y55ztKlS+Poo4+O1atXZ+Il5Cx9n0rfA6TKl74fN25cDBo0KDmeOHFi/O///m+mttYg5Gvnb42+B6idfOl6qidf+/6b3uNvv/32KeO1a9fGTjvtFM8991wce+yxNd5Ljx494umnn47jjjuuxucC5LOG1Pk+w9f3W6PvAQAAAAAAAAAAAAAAAAAgP40dOzb22GOP5DiRSMTQoUNj+vTpac23Zs2aOPLII+Ppp59OOX7ddddFq1attnp+ly5d4rDDDkuOV61aFYMHD47S0tJq7+H222+Phx56KOXYaaedVu3zc9k///nPuOmmm1KOXXXVVbHTTjvVaJ4rr7wyOnTokDLvpEmTtvj8bF6X4uLilHF5eXm11wTIFfXZt98kkUjE6NGjY/bs2RERMX/+/DjnnHOisrKy2muXlpbG0KFDU+7H0r179+jVq1f1X0AO07W6FshPufbetqamTp0aHTt2TI5vvPHGjK+RS/K1b3Ut0Jjle9c2NvnatRHp9+3pp58effv2TY5XrlwZRxxxRHz00UfVXvvSSy+NBQsWxKeffhq33XZbHHnkkbF27dpqnw9QW7nWtz633TJdq2sBAAAAAAAAAAAAAACAzCnK9gYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAhqlly5Yp47Kysjpba82aNSnjbbbZJiPzFhYWxhlnnBETJkyIjh07pjxWVlYWJ510UixatCgja1VH27ZtY/78+TU+b+PGjXHggQemve6SJUvihhtuiMsuuyx5bOLEidG1a9fo1q1b8tjLL78ckydPTnud6srkdSkuLk7+d5MmTaJdu3Y13s+BBx4Yzz77bFxwwQVxxx131Ph8gHyXT53frl27GDx4cLWff+utt8Yll1wS69atq9E6taHvv6TvAXJLPvR9v379YsKECcnx3LlzU3ot1+j8L2Wq8/U9QO3kQ9fnI33/pUz0fbNmzVLGlZWV8fDDD0fnzp0jImLDhg0xbdq0mDFjRrzwwgvx8ccfR0VFRbRu3Tr22muvGDhwYIwcOTI6dOiQnKNly5Zx//33x2GHHRZz587N0KsFyG0NofN9hv8lfa/vAQAAAAAAAAAAAAAAAACgIWrbtm1cfPHFKcfuuOOO+NOf/lSrecvLy2PEiBGxePHi5H3Ldthhh7j00kvjZz/72Tee+8Ybb0SPHj3iJz/5SYwYMSKuvfbaeP/992u8h9tuuy1OPvnk5Lh37941niNXXX311fH9738/+fPm2267bVx//fVxxhlnVOv8rl27xk9+8pOUYz/+8Y9jw4YNWzwnm9elpKQkZVxeXl7jdQGyqb77dmtmz54ds2fPjt69e0cikYiNGzfWeO0lS5bEE088kXIP+gMOOCAWLFhQ47lyka7VtUB+ycX3tjUxbty4GDRoUHI8adKk+POf/xw//elPM7ZGLsrXvtW1QGOU713bWOVr10ak17fnnHNOyviaa66J9957r0brVlZWxuDBg5P3YAWoT7nYtz63/Wa6VtcCAAAAAAAAAAAAAAAAmVGU7Q0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjUMikai3uQsKCmo95ymnnBLjx4+Prl27VnnsnXfeiSFDhsSLL75Y63VqoqioKPbff/8an7d06dJarz1hwoQYPnx47LrrrhER0aFDh/jFL36RfDyRSMTIkSOjsrKy1mt9k0xfl5KSkirHli9fHnPmzIn58+fHsmXL4vPPP4+CgoLYfvvtY4899oiDDjoojjzyyGjRokXynKZNm8btt98elZWV8dvf/ja9FwfQQORb53+TE044IZ555pmYNm1ana7zdfpe3wPkg1zr+7Zt28b06dOjSZMmERFRWloap556amzcuLFO9pgJOj+zna/vATIr17o+X+n7uvus5aCDDorCwsKIiHjxxRfj1FNP3ezXrbS0NEpLS+PZZ5+NX/3qV/HLX/4yLrnkkuTjzZs3j6lTp0aPHj2irKysxvsAyHf51vk+w0+l77+k7wEAAAAAAAAAAAAAAAAAoOE488wzY5tttkmOV6xYEWPGjMnI3O+8805cffXVcf311yePnX322fHzn/88KioqvvHcV199Nc4777y49NJLY926dWmtv3jx4pRxu3bt0ponF61duzZ++tOfxv333588Nnz48Jg8eXLMmzdvq+f/5je/iaZNmybH06dPjyeffHKr52Xrumx677vy8vK01gbIlvru22bNmm21ayMiXnrppVqtvWDBghg8eHBy3LFjx1rNl0t0ra4F8kuuvretjn79+sWECROS42effTbGjRsXBx10UK3nznX52re6FmiM8rlrG7N87dqImvftLrvsEoccckhy/PHHH8dtt92W1toffPBBWucB1Fau9q3PbbdM1+paAAAAAAAAAAAAAAAAIDMKs70BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoHEoKCjIi7mPPvroePnll+P++++Prl27pjxWWVkZd955Z+yzzz7x4osvZmzNuvbmm2/Weo7y8vL4yU9+ssXH/9//+3/x3HPP1XqdLamr6/Lzn/88Xn755YiIeOqpp+KII46Ijh07xogRI+Lmm2+OGTNmxJw5c2L27Nnx0EMPxcSJE+PEE0+Mjh07xvXXXx8bN25Mme+WW26Jnj171u7FAuS5XO780tLS+Otf/1olzz77bLz55ptRWVmZ8vyOHTvGvffeG7fddludvq5M0Pdbpu8BMi/X+n7q1KnRsWPHiIhIJBIxYsSIWLZsWaa3lhN0/ubpe4DMyrWub2z0/dYVFhZGRMTcuXPj4IMPjqVLl271nIqKihgzZkxccMEFKce/9a1vxciRI9PaB0C+y5fO9xn+5un7qvQ9AAAAAAAAAAAAAAAAAADkt7PPPjtlfNddd8WaNWsyNv+dd94Z5eXlyXGbNm1i8ODB1T5/5cqVUVZWltbam57XrFmztObJVQ888EDMmTMnOS4oKIhbb711q/cfOOGEE2LgwIHJ8erVq+Oiiy6q0dr1fV2Ki4tTxl//NQWQD+q7b2vStbXx2WefpYxbtmxZL+vWF10LkD9y/b3tlrRt2zamT58eTZo0iYgvf/8fOnRobNiwodZz54t87FtdCzRG+dq15GfXRtS8bwcPHpzymh555JFYv359WmsDZEuu963PbTdP1wIAAAAAAAAAAAAAAADUXlG2NwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0TOXl5Snj4uLiOlurpKQkZbxu3boaz9G/f/+47rrr4qCDDtrs47Nnz45LLrkkFi5cmNYeM6GioiLmzp1b4/OeeOKJjKz/8MMPx2OPPRZHHnlkyvGVK1fG2LFjM7LGpur6ujz66KPx6KOPxt577x2vvfZatc/792ueNWtWzJw5M1q0aBEREc2aNYtJkybFwIED09oPQD7Kp85/7rnn4tBDD93i49ttt10ce+yxMXbs2Nhnn32Sx0eOHBlr1qyJn/3sZzXbcBr0fVX6HiD7crnvx40bF4MGDUqOr7/++vjLX/5SJ3vLJJ1fVW06X98D1E4ud30+0/dVZfKzltWrV8eJJ54YX3zxRY3Ou+WWW+Kggw6K008/PXls1KhRMWnSpFrvCSDX5Vvn+wx/6/T95ul7AAAAAAAAAAAAAAAAAADIPzvvvHN079495didd96Z0TU+//zzeOCBB+KMM85IHhs0aFDMmDEjo+tsTps2bVLGq1atqvM169v5558fixYtimbNmkVExL777hvnnHPOFq9jixYt4sYbb0w5duWVV8by5cvrfK//ls512fSeCpvezwEgl2Wjb+ura1u1apUyXr16dZ2vWd90LUDuy+f3tlOnTo2OHTtGREQikYgzzjgj3n///VrNmY/yrW91LdDY5HPX8qV869qImvdt7969U8YzZ87M+J4A6lJD79uG/rmtrgUAAAAAAAAAAAAAAAConaJsbwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABomNasWZMy3mGHHepsrVatWqWMy8rKqn3uLrvsEv/93/8dJ5544mYff/rpp+Pyyy+Pv/3tb7XaYyasXLkyDj300KzuYdSoUfHaa69F06ZNk8d+8YtfxMqVKzO6Tn1fl9deey2t82bPnh0jR46Mu+++O3lswIAB0bVr13j99dczsjeAXJcvnV8dq1atinvuuSfuu+++uOmmm+L8889PPjZmzJiYOXNm/P3vf8/ompvS91/R9wC5I1f7vl+/fjFhwoTk+JlnnonLL7+8zvaWSTr/K5nsfH0PkJ5c7fp8p++/UheftfzmN7+JFStWpHXuZZddFqeddloUFBRERMTuu+8ePXr0iMWLF2dsfwC5KF8632f4NaPvN0/fAwAAAAAAAAAAAAAAAABAfjnkkENSxm+99Va8/fbbGV9n1qxZccYZZyTH9fUz4wceeGDK+MMPP6yXdevT66+/Hr/+9a9j3LhxyWPXXnttPPDAA/Hpp59Wef64ceNi9913T44XL14cN998c31sNSmd61JSUpIyLi8vz+ieAOpSNvq2vrp2v/32Sxm/8cYb9bJufdK1ALkvX9/bjhs3LgYNGpQcT5o0Kf7nf/6nVnPmq3zrW10LNDb52rV8Jd+6NqLmfdurV6+U8cKFCzO9JYA61dD7tqF/bqtrAQAAAAAAAAAAAAAAAGqnKNsbAACoa02bNo3evXtHr169onPnzrH99ttHSUlJrF+/PlatWhUrVqyIRYsWxQsvvBAffPBBtrcLAFmnOwGgZnQnAFSf3gSAmtGdAAAAAAAAAAAAAAAAAAAANAQfffRRyrht27Z1ttYOO+yQMv7www+rdd5RRx0V99xzT7Rq1arKY/Pnz4/LL788Zs2alYktNhhLly6N0tLS2GmnnZLHFi9enNE18u26/P73v4+LLroo9tlnn+Sx4447LiZOnJjFXQHUn3zo/JrasGFDjBo1Ktq3bx9DhgxJHv/lL38Z/fv3r5M1c4m+r0rfA41dLvZ9mzZtYvr06dGkSZOIiPjkk0/i1FNPjY0bN9bZ3hoanZ9K3wONWS52PZnRkPv+gQceSPvcd955J1588cXYf//9k8f222+/jH9tAHJNvnT+woUL8+J9ZK7Q95un7wEAAAAAAAAAAAAAAAAAIL/06NEjZfzcc8/VyTrz589PGe+5557RrFmzqKioqJP1/u38889PGT///PN1ul62jB8/PoYNGxa77LJLRHx538Bf/vKX8eMf/zjlebvttluMHTs25djIkSPr/X6C6VyXkpKSlHF5eXlG9wRQl7LRt/XRtd26dYsBAwYkx+vXr2+w96nRtQC5LR/f2/br1y8mTJiQHM+bNy/GjRtX6z3ms3zqW10LNDb52LVUlU9dG1Hzvt17772T/11WVhbvvvtuledss8020bt37+jcuXNst912UVhYGKtXr4533303FixYEJ988klmNg+Qhobet43hc1tdq2sBAAAAAAAAAAAAAACA9BVlewMAAHWld+/eceGFF8YJJ5wQ22+/fbXOeeGFF2LKlClx5513xrp16zK6n9133z1OPPHE6NevX3Tv3j3at28f2267bTRp0iTKyspi+fLl8eqrr8aTTz4Z9913Xyxfvjyj629J//7946mnnsr4vKeeemrcf//9ERHRvXv3WLhwYRQVffXHzyuvvDKuueaajKzVqlWrWLJkSbRp0yZ57Iorrojx48dv9dz6uC5FRUVx9tln1/i8LSkvL48pU6ZkbD6Af8uV7uzUqVMcc8wxccghh8Tee+8dnTp1ipKSkmjevHmUl5fHypUrY8mSJTFv3rx45JFH6uymQZujN/UmwNflSnfWxD777BN9+/ZNjl999dV4+umn62w93Vm33ak3gXySS735ve99L7p27fqNz1m4cGG9vt+M0JvZ/Dv0PfbYI4YOHRr9+/ePbt26Rfv27aNly5axYcOGWLNmTbz77ruxaNGi+Mtf/hIzZ86MtWvXZmxtgC3Jpe70OWfudafeBAAAAAAAAAAAAAAAAAAA8s2SJUtSxt/+9rfTmqdfv37feP+0bt26RbNmzVKOvffee1ud95RTTolp06ZFkyZNUo4vXLgwfvGLX8TMmTPT2i+1k6/X5YEHHoh99tknOe7du3cWdwNQv3K982tj9OjRcdJJJ0VhYWFERHz3u9+NTp06xbJly+p03YZO3wPkn1zs+3vuuSc6duwYERGJRCJGjBgRH3zwQVr7om7kY+fre6CxysWuJz/UV99/8cUXKePKyspYtGhRreZ86aWXYv/990+OO3XqVKv5APJBPnT+KaecEq1atUo5lsvvIxsDfQ8AAAAAAAAAAAAAAAAAANSHLl26pIxr+/PGW/L6669HRUVF8ufiCwsLY88994zXXnutTtaLiDj33HPju9/9bsqxe++9t87Wy6aysrIYPXp0PPTQQ8lj5513Xtx5552xYMGC5LEbb7wxWrRokRz/8Y9//MZ7GdSFdK9LSUlJyri8vLzK4+3bt08+b82aNfHBBx/EunXrarljgNrLRt/WddfuuOOO8eCDD0ZRUVHy2N133x2lpaV1sl626VpdC+S2fHtv27Zt25g+fXryPmMrV66MoUOHxsaNGzO+53ySL32ra4HGKN+6ls3Ll66NqHnfNmnSJIqLi5Pj5cuXpzw+YMCAGD16dAwcOLDK/Xv/LZFIxPPPPx+TJ0+Oe+65JzZs2FCLVwBQcw25bxvL57a6VtcCAAAAAAAAAAAAAAAAtZCopogQEdlsevbsmRg+fHhi+PDhiWHDhiX69u2bKCgoyPq+RKTxpn379okHHnigun/M2awPP/wwMXz48Izsp0uXLomHHnooUVlZWe31N2zYkLjrrrsS7dq1q/OvV//+/Wv1tdqSoUOHpqxzww03pDxeVlaW2HXXXTPyGiZPnpwy95IlSxLNmjXLmeuy4447ZuRr+m/Lly/P+v9nItKwkivd2a1bt8SDDz6Y2LhxY43WfumllxKHH354vXyt9KbeFBGJyJ3urGnatm2bWLZsWco+Jk+eXKdr6s667U69KSL5kFzszccff3yra06cOLHev1Z6s/7/Dr1z586Jhx9+uEZfz9LS0sQll1ySKCwszPr/XyLSMJNL3elzzi+TS92pN0VEZHMpKChIfOc730kMGzYs+b2cPXv2zPq+Gmt8T62IiIiIiIiIiIiIiIiIiIiIiIiISP2moKAg0adPH99PKyI1Sm1ke+8ikrvxcyUiW8/3v//9lF595513ajzHyJEjE5WVlYmbb755i88544wzUtZ58803tzrvfvvtl6ioqEg577PPPkv84Ac/yPrX7evZ9Ofsc+XeYcuXL0/ZV//+/TMyb75cl83l5JNPTtn3k08+mfU9iYjUV3K58zORefPmpax78sknZ3R+fa/vRUTyIbnW9+PGjUt53l/+8pdE//79a5QLL7wwZY5HHnmkynN22GGHjH0NdX5+dL6+F5HGmlzr+nQyceLElLlz4b7z+j5z2W677VLW+eSTT2o954QJE1Lm/NWvfpX1ayUiUtfJ9c7ftFty8X2kvtf3IpI7ca/23IrvqRURERERERERERERERERERERERERqd+4V7uIpJPayPbeRSR34+dKRCST+dvf/pbyZ5Bzzjmnztb617/+lbLW9773vTpb69RTT02sX78+Zb358+fX2e+XufJz8Y8//njKPp5++unkYwMHDkx57LPPPkvsuOOO9bq/2lyXhx56KHlORUVFolmzZonTTjstMW3atMT777+/2T9TV1ZWJt58883EHXfckejXr19WromISET2+rYuurakpCRx7rnnJj766KOU17R48eLEtttuW2evS9dWL7pWRBpr8u297WOPPZbye+nRRx+92edt2n+TJ0+u06+jvt16dK2INNbkW9duLu6n/lVyuWsj0uvbVq1apTx/wYIFiYhItG7dOvHnP/95sz37Tf7xj38kevfunZXrIyKNNw2hbzeXxvi5ra7dOl0rIvke92rPrfieWhERERERERERERERERERERERERGR+o17tYtIOqmOwgAAaEAOO+ywWLRoUQwZMqRW83To0CGmTJkSU6ZMiebNm6c9z/Dhw+Pll1+Ok046KQoKCqp9XpMmTeIHP/hB/OMf/4i+ffumvX4uueqqq+LDDz9Mjlu2bBk33nhjreft1atXnHvuuSnHRo0aFRUVFVs8p76vS0lJSbWfC1DfcqU7R48eHQsXLoyTTz45Cgtr9tcV++67b8yePTsmTZpU43Vzld4EyF250p3pmDp1anTs2LFe1qpvjbU79SaQ63K1N/faa69az5HPGmtvbur000+PhQsXxvHHH1+j81q3bh0TJ06MOXPmRHFxcVprA2xJLnWnzzm/kivdqTcBAAAAAAAAAAAAAAAAAIB89uSTT6aMd9ttt+jSpUu1zx87dmzcdtttUVBQEBdccEH8/Oc/3+zzBgwYkDKeN2/eN85bWFgYU6dOjaZNmyaP/etf/4o+ffrE3XffXe39kVn5fl1KS0tTxu4bBzQmudr5mbJ06dKU8U477VQv6zZE+h4gf+Va30+YMCFlfOSRR8ZTTz1Vo/z3f/93yhzHHXdclefsvvvu1X6NfCWfO1/fA41VrnU9ua+++37VqlWxcePG5LiysrLWc2ZiDoB8k8udv2m35Mv7yIZM3wMAAAAAAAAAAAAAAAAAAPVp0/t+ffbZZ3W21qZz18U9x7bZZpu46aabYtq0aVFUVJQ8vnbt2vjhD38YiUQi42vmklGjRkVFRUVyfPDBB8ewYcOiqKgobr755pTnXn755fHxxx/Xy74ycV2+/uulsLAw3n///Zg2bVqcdtpp0alTp82eU1BQEHvuuWece+658fe//z3mzZsXvXv3rv0LAqihbPVtOl27//77x8yZM1Py6KOPxpw5c2Lx4sXx2WefxR133BHt2rVLnrN06dI4+uijY/Xq1Zl4CTlN16bStUCuyKf3tuPGjYtBgwYlxxMnToz//d//zcTWGoxc7FtdCzR2+dS1bF0udm1E7fp2++23TxmvXbs2dtppp3juuefi2GOPrfFeevToEU8//XQcd9xxNT4XIF0NrW8b8+e2unbrdC0AAAAAAAAAAAAAAACwqaKtPwUAID8cffTRMWPGjGjevHnK8XXr1sWsWbNi5syZsWDBglixYkWsXLkyWrRoETvuuGN06tQpDj/88DjuuOOiW7duKecOHz482rdvH8cdd1ysW7euRvsZMWJE/OEPf4iCgoKU46tWrYq5c+fGkiVLYtWqVRER0bp16+jVq1f06dMnmjRpknxuu3btYtasWXHQQQfFokWLarR+usrKyuK2226r9Tyvv/56ynjNmjVx0UUXxfTp05PHTjrppBgwYEDMnj077XVuueWWKCwsTI5nzJgRjz/++Bafn43rUlxcXNOXBVAvcqU7r7jiirj66qurHC8tLY1nn3023nrrrVi1alUkEonYbrvtonPnztG3b99o1apVyvMvuuiiaNasWVxwwQU1/EqkT2/qTaBxyZXuTMemN2nPFt2Z2e7Um0Auy9XeLCoqil133TXt11Wf9Gbd/R36WWedFXfddVeVtdeuXRtPPvlkvPfee1FaWhpFRUWx4447Rs+ePWP//fdPeX2HHHJIzJw5Mw4//PAGfcNfoP7kUnf6nDP3ulNvAgAAAAAAAAAAAAAAAAAA+W758uXxyiuvxH/8x38kj5133nlx8cUXV+v8ioqKlPH48ePj448/jjvuuCN5bIcddohTTjkl5XmPPvroN847YsSIlJ/Xr6ysjBNPPDHeeOONau2LupHv16Vp06Yp401//QI0ZLna+ZmyZs2alPGm9wyi+vQ9QP7Ktb7/+j3X6tLbb79dL+s0NPnc+foeaKxyrevJfdno+6VLl0aXLl0iIqr8W3bpaNu2bcr4s88+q/WcALkulzv/692ST+8jGzJ9DwAAAAAAAAAAAAAAAAAA1KeWLVumjMvKyupsrU3vN7vNNttkbO7CwsI444wzYsKECdGxY8eUx8rKyuKkk06KRYsWZWy9rWnbtm3Mnz+/xudt3LgxDjzwwLTXXbJkSdxwww1x2WWXJY9NnDgxunbtmvKz7C+//HJMnjw57XWqK5PXpbi4OPnfTZo0iXbt2tV4PwceeGA8++yzccEFF6TctwGgrmWrb9Pp2nbt2sXgwYOr/fxbb701Lrnkkli3bl2N16oNXfslXQvwpXx5b9uvX7+YMGFCcjx37tyUTsk1+vZLZ511lq4FGr186dp8o2u/lIn3ts2aNUsZV1ZWxsMPPxydO3eOiIgNGzbEtGnTYsaMGfHCCy/Exx9/HBUVFdG6devYa6+9YuDAgTFy5Mjo0KFDco6WLVvG/fffH4cddljMnTs3Q68WYMsaSt82hM9tdW1VuhYAAAAAAAAAAAAAAACoc4lqiggRkc2mZ8+eieHDhyeGDx+eGDZsWKJv376JgoKCrO9LRBpX9t1338S6detS/vxSWVmZmDJlSmLnnXeu9jxDhgxJvPPOO1X+LHT//ffXaD/dunVLlJeXp8yxbNmyxLBhwxJNmzbd4nkdO3ZM/O53v6uy/iuvvJJo0qRJnXzt+vfvn7LW8uXL6/Ra/d///V/Keq+99lqiqKgorbmGDx+eMtfatWsTnTp1yrnrcuCBB6acN2bMmETv3r3TTs+ePev8/ykRafjJle4cNGhQorKyMuXcF154IXHEEUd84/uKpk2bJk4//fTE+++/X2Xt4447rs6+bnpTb4pI402udGc66devX2LDhg1V1kwkEonJkyfX6ddNd9Ztd+pNEcnV5HJvFhQUJNq1a1clt912W8oaEydOrPevm96sn79D79GjR6KioiLl/NLS0sTZZ5+daNGixRbP69SpU2Lq1KlV1r744ovr/deKiDS85FJ3+pxzy8lWd+pNERHZWgoKChLf+c53EsOGDUt+L6e/68tefE+tiIiIiIiIiIiIiIiIiIiIiIiIiEj9pqCgINGnTx/fTysiNUptZHvvIpK78XMlItXLRRddVOXnl3fYYYdqn3/ttdemnL9x48bEkCFDko+PGTMm5fHPP/88sc0223zjnH//+99Tzrn33nuz/nXaUur75+yrm+XLl6fsq3///rWeM5+uy+Zy5plnpux/xowZWd+TiEh9Jhc7P1O57777UtY+++yzMzq/vs/+a61u9L2INPbkUt/Xh9LS0ox+/XR+9l9rdaLvRaQxJ5e6Pp1MnDgxZf7GcN/56qah9P1dd92VsmbXrl1rNd9f//rXlPlOP/30rF8rEZH6SK52/te7JZffR+r7un0d+l5EahL3as+t+J5aEREREREREREREREREREREREREZH6jXu1i0g6qY1s711Ecjd+rkREMpnXXnst5c8gRx99dJ2tNX/+/JS1hg4dmpF5TznllMQ///nPzf6Z6u23307st99+df513PTn4tP15ptv1novLVu2TLz77rtbXKOysjJxwAEH1PnXJNPXZcGCBVXm+fDDDxNTpkxJXHjhhYmTTjopcfjhhycGDBiQOPnkkxNjxoxJ/OlPf0qUl5dvdg/nnHNOnX8NRET+nWz1bTpde/TRR1enspKWLVtWL/cX0bVVo2tFRL5KPry3bdu2bWLZsmXJ8z755JNEp06dvvGcTftv8uTJdfp11LdVc8opp2x2fV0rIo0t+dC1W0su3k89XQ2tazPx3rZLly4p527cuDH53y+88EJizz333OoczZo1q/LrJJFIJN566616+3f7RKRxpyH0bUP53FbXVo2uFRFJjXu151Z8T62IiIiIiIiIiIiIiIiIiIiIiIiISP3GvdpFJJ1UR7Xv6J7tFyMiuRs/aCIi2U5xcXFi6dKlKX92Wb9+feK0005La76SkpLEU089VeXPQz/60Y+qPcfs2bNTzl24cGGiTZs21T7/Rz/6UZX16+pGtJveMGD58uV1er26deuWqKioSFnzoosuSus6ffjhhynzjB07Nievy4ABA1LOqcubW4iIVCe50p0FBQWJxYsXp5xz1113JQoLC6u9dps2bRIvv/xyyhyvvPJKnX3t9KbeFJHGmVzpznSy6U3aN1XfN2DXnVtOOt2pN0UkV5OPvZmLN1PXm1tObf4Ofe7cuSnn/fOf/0y0b9++2mv/6le/Sjm/tLQ0UVxcXO+/XkSk4STX3nP6nHPLyVZ36k0REdla3Lw9t+J7akVERERERERERERERERERERERERE6jdu3i4i6aQ2sr13Ecnd+LkSkeqlTZs2iTVr1qT06+9///sazXH77bennP/FF18kDj/88MQee+xRZe4bb7zxG+dq1apVorKyMuWcww47LOtfpy2lvn/OvrpZvnx5yr769+9fq/ny7bpsLr///e9T9n/TTTdlfU8iIvWZXOv8TObVV19NWfuYY47J6Pz6PvuvtbrR9yLS2JNLfd+lS5daZ/jw4SnrTZ8+PeXxb33rWxn9+un87L/W6kTfi0hjTi51fTppjPedr24aSt+feeaZKWtu7d7435Q2bdok1q9fnzLfnnvumfVrJSJSH8nFzt+0W3L5faS+r9vXoe9FpCZxr/bciu+pFRERERERERERERERERERERERERGp37hXu4ikk9rI9t5FJHfj50pEJJN57bXXUv4Mkul7wH49L7zwQspaQ4cOrdV8Rx99dOLll1/e7J+lNm7cmLjjjjsSJSUl9fJ13PTn4tP12GOPZWQ/J5xwwhbX+O1vf1unX4u6ui6DBw9OvPTSS4lEIpH461//mhg4cGC1+q9169aJX/3qV4kNGzak7OWLL77wvl5E6i3Z6tt0uvaAAw5IPPnkk1Uyb968xJIlSxIbN27c7O/xt912W52+L9G1X0XXiohUTT68t33ssceS51RWViaOOuqorZ6zaf9Nnjy5Tr+O+varbKlvda2INNbkQ9duLbl4P/V0NeSuTSTS69suXbpsdq5nnnkm0bx58xrtbdSoUVXmufjii+v914uINL7kc982tM9tdW3V6FoRkdS4V3tuxffUioiIiIiIiIiIiIiIiIiIiIiIiIjUb9yrXUTSSXUUBgBAnhs7dmzsscceyXEikYihQ4fG9OnT05pvzZo1ceSRR8bTTz+dcvy6666LVq1abfX8Ll26xGGHHZYcr1q1KgYPHhylpaXV3sPtt98eDz30UMqx0047rdrn57J//vOfcdNNN6Ucu+qqq2KnnXaq0TxXXnlldOjQIWXeSZMmbfH52bwuxcXFKePy8vJqrwlQF3KlOxOJRIwePTpmz54dERHz58+Pc845JyorK6u9dmlpaQwdOjQqKiqSx7p37x69evWq2YvIUXpTbwK5IVe6Mx1Tp06Njh07Jsc33nhjRufPNY2tO/UmkKvytTcbm8bWmxERp59+evTt2zc5XrlyZRxxxBHx0UcfVXvtSy+9NBYsWBCffvpp3HbbbXHkkUfG2rVrq30+wKZy6T2nzzm/WTa6U28CAAAAAAAAAAAAAAAAAAANSWlpadxwww0px84888wYNmxYtecYOXJkPPDAA8lxs2bN4uGHH46HHnoo5d5ca9asiWuvvfYb5+rVq1cUFBQkx+vXr6/y8/rUv2xel169esX9998fN998c9pz7LzzzjFkyJCUY48//nhttwaQV3Kt8yMidthhh/jZz34W22yzTbX3sKk+ffrE3nvvnRwnEol44YUX0p6vMdP3APkvl/r+jTfeqHXee++9lDk//fTTlMfffvvtar8uvpKtztf3ALWXS11PbstW3z/44IPx+eefJ8cXX3xxbLvttmnN9fOf/zyKioqS4wULFsTSpUtrvUeAfJCLnb9pt/gMP/v0PQAAAAAAAAAAAAAAAAAAUN/Ky8tTxl//+fVMKykpSRmvW7curXn69+8fzzzzTPzP//xP9OrVq8rjs2fPjt69e8d5550Xa9asSWuN2qqoqIi//vWvNc4TTzyRkfUffvjheOyxx6ocX7lyZYwdOzYja2yqrq/Lo48+Gr17947u3bvHIYccErNmzYpEIrHV8/79mo888siUX3PNmjWLSZMm1XgfAOnIVt+m07XPPfdcHHrooVXSt2/f2GuvvaJVq1YxfPjw+Mc//pFy3siRI+NXv/pVrfdfXbq2V5XHdS3QmOX6e9tx48bFoEGDkuPrr78+/vKXv2R8b5mmb3ulPKZrgcYs17s2X+naXlUez+Tf769evTpOPPHE+OKLL2p03i233BLTpk1LOTZq1Kha7QWgOvKxbxvq57a6tnp0LQAAAAAAAAAAAAAAAJBRiWqKCBGRzaZnz56J4cOHJ4YPH54YNmxYom/fvomCgoKs70tEGkcuvvjilD+zfPTRR4mSkpKMzT9mzJiU+T/55JNEs2bNqn1+69atE9tss01aa7dr1y5l7S+++KJOvob9+/dPWWf58uX1cu1OOeWUlHUrKysTffv2rda5TzzxRMq506ZNq9Ha9X1dzjvvvJRzvv3tb9fL11hEZHPJ9e5MN+PHj09Z95prrqmTdfRmzaI3RaQhJF+7s1+/fokNGzYk5503b16iqKioSpdNnjy5Tr9+urNmqWl36k0RycV8vTvzpTcjIjFx4sSUuSdOnFjvXzu9WbPUtDd32WWXRGVlZfL5K1asSDRt2rTer7OIyNeTy+85fc655WSrO/WmiIhsKQUFBYnvfOc7iWHDhiW/l7Nnz55Z31djje+pFRERERERERERERERERERERERERGp3xQUFCT69Onj+2lFpEapjWzvXURyN36uRKRm+fa3v50oLy+v0rX33XdfYpdddqnWHCUlJYl33nlns519//33V2uOCy+8MOW8uXPnZv1r803J1s/Zby3Lly9P2Vf//v1rNV+2rsvNN9+csm5ZWVli+PDh1T6/Q4cOidmzZ1f59Thq1KisXyMRkWwlFzr/O9/5TpXzbr/99kRxcXG1X0e3bt0SL730UpV5jjjiiIx/zfR93Ubfi4hkPrnQ95lIY7l/+9bSEDpf34uIZDb52vWN+b7zW0tD6Pt/p3Xr1olly5alrP/nP/85sf3221fr/B/+8IdVfn0/88wzPucVkUaZXOr8Tbsl21+bb4q+r/voexGpbtyrPbfie2pFREREREREREREREREREREREREROo37tUuIumkNrK9dxHJ3fi5EhHJZB544IGUP4NcdtlldbbWF198kbJW9+7dq33uUUcdlVi5cuVm/9z0/PPPJwYOHJjVr2Nj+bn4fLsum8uiRYtS9jlmzJis70lEGn6y1bc16dpMvba//e1vdbKOrtW1IiLflFx9b9umTZuU+3t9/PHHiY4dO1Z7Lfd0/zLZ7ttsv/5No2tFJBvJ1a6tSdxPfcvJdtdm4r1tly5dqszdq1evWs05f/78lPnOPPPMrF8rEWnYyZe+zfW/s8zFvtW1m4+uFZF8jnu151Z8T62IiIiIiIiIiIiIiIiIiIiIiIiISP3GvdpFJJ1UR1EAAOSxs88+O2V81113xZo1azI2/5133hlXX311tGzZMiIi2rRpE4MHD44ZM2ZU6/yVK1emvXZZWVnKuFmzZmnPlYseeOCBmDNnThx++OEREVFQUBC33npr7LfffpFIJLZ43gknnBADBw5MjlevXh0XXXRRjdau7+tSXFycMi4vL097fYDayvXuTNdnn32WMv73+g2F3gTInnzszrZt28b06dOjSZMmEfHl7+VDhw6NDRs2ZGTP+aCxdKfeBHLR17szH3qTxtObgwcPjoKCguT4kUceifXr16e9PkAm5PJ7Tp9zblm2ulNvAgAAAAAAAAAAAAAAAAAADcXChQvjhBNOiIcffjhatGiRPD506NA4/vjjY86cOfHnP/85FixYECtWrIhPPvkkioqKolWrVtGlS5f43ve+F0OGDInddtutytwVFRVx4YUXVmsfRUWp/2TL7rvvHpMnT67di/v/XXvttfH+++9nZK7GJlvX5fLLL4+jjjoqOnfuHBFf3t92ypQpMXr06Lj77rvjySefjCVLlqT8/H1xcXH06dMnTj755DjzzDOjpKQkZc6nnnoqY3sHyEe50Pnz58+P3/72t3HOOeckj5133nlxwgknxO9///t47LHHYtGiRVXu79K2bdvo06dPfP/7349TTjmlyj1b7rnnnnjiiSdq+iXh/6fvARqOXOh7cldddb6+B6g/up6tyeZnLStXroxhw4bF//3f/0VhYWFERBx77LGxdOnSuOmmm+JPf/pTvPLKKynntG7dOgYMGBCjR4+Ovn37pjy2YsWKGDZs2DfeYxigocqlzt+0W3yGn336HgAAAAAAAAAAAAAAAAAAqG9LlixJGX/7299Oa55+/frF008/vcXHu3XrVuW+s++991615j7llFNi2rRp0aRJk5TjCxcujF/84hcxc+bMmm+YWsvX6/LAAw/EPvvskxz37t07i7sBGots9W11u7Y2Ro8eHSeddFLyniXf/e53o1OnTrFs2bI6X7uh07UA1Zer723vueee6NixY0REJBKJGDFiRHzwwQdp7Y26kY99q2uBbMjVriX31VfXfvHFFynjysrKWLRoUa3mfOmll2L//fdPjjt16lSr+QC2Jh/6Nh/fQzV0uhYAAAAAAAAAAAAAAABoKIqyvQEAgHTtvPPO0b1795Rjd955Z0bX+Pzzz+OBBx6IM844I3ls0KBBMWPGjIyuszlt2rRJGa9atarO16xv559/fixatCh5Q4Z99903zjnnnC1exxYtWsSNN96YcuzKK6+M5cuX1/le/y2d61JSUpIyLi8vz+ieAKqrIXdnq1atUsarV6+u0/WyQW8C1L987c6pU6em3KT9jDPOiPfff7/We803jaE79SaQazbtznzoTb7UGHpz039gxA19gWzL1/ec1eFzzqqy3Z16EwAAAAAAAAAAAAAAAAAAyDWPP/54HHHEETF9+vTYeeedk8ebN28eRx99dBx99NFpzdusWbN48MEHY8CAAbFu3boanduhQ4f40Y9+lNa6m/rtb3/bKO8BVxfq67qsXr06jjzyyJg1a1Z861vfSh7fb7/9Yr/99ouIiMrKyli9enV88cUXse2220bLli23uNaLL74Yxx57bGzcuDEjewfIV7nQ+aNGjYpdd901Bg0alDzWvn37GDt2bIwdOzYiItatWxdlZWWxcePG2H777ZP3ltmcRx99NM4666y09s3m6XuA/JYLfU9+yFTn63uA+qXrqYn6/qzlqaeeilNPPTWmTp0azZs3j4gv78U7fvz4GD9+fJSXl8fHH38cFRUV0bp162jVqlUUFBRUmedf//pXHHXUUfHOO+9kZO8A+ShXO99n+LlH3wMAAAAAAAAAAAAAAAAAAHVt8eLFKeMDDjigxnOMHDkybr311rjlllviwgsv3Oxz+vTpkzJeunRprFmzZqtz77fffnHPPfdEkyZNksc+//zz+OlPfxp33313jfdKZuTzdXn11VdTxjvttFOWdgI0Jtno2+p2bW198MEH8fzzz8eBBx6YPHbAAQfEsmXL6nzthkzXAtRMLr63HTduXMq/3fL4449HWVlZ9O/fv9p76tWrV8p45513rnL+okWL4rPPPqv2nHwlX/tW1wLZkItdS+6rz6799NNPq4wrKytrNefHH3+cMt5uu+1qNR/A1uR63+bre6iGTNcCAAAAAAAAAAAAAAAADUlhtjcAAJCuQw45JGX81ltvxdtvv53xdWbNmpUyPvTQQzO+xuZ8/aazEREffvhhvaxbn15//fX49a9/nXLs2muvjVatWm32+ePGjYvdd989OV68eHHcfPPNdbnFKtK5LiUlJSnj8vLyjO4JoLoacnfut99+KeM33nijztesb3oToP7lY3duepP2SZMmxf/8z/+kPV8+awzdqTeBXPP17syH3uQrjaE3N/2HaBYuXJjpLQHUSD6+56wun3NWle3u1JsAAAAAAAAAAAAAAAAAAEAu+vvf/x49e/aMKVOmRGVlZdrzLFu2LD799NPk+OCDD44HH3wwmjRpkolt0ogsXbo0+vTpE1OnTt3s44WFhbH99ttHu3btomXLlpt9TiKRiJtuuikOPvjgWL16dV1uFyBvZLvzKyoq4phjjolrr702KioqNvucFi1aROvWrWPHHXeMZs2abfY5X3zxRVx66aVx/PHHx4YNG9J+HWSXvgeoG9nue/g6fQ+QebqeXPbggw/G4YcfHkuXLq3yWMuWLWPXXXeNzp07R+vWraOgoKDKcx577LHYb7/9YsGCBfWwW4DcpvPJVfoeAAAAAAAAAAAAAAAAAAAalyeffDJlvNtuu0WXLl2qff7YsWPjtttui4KCgrjgggvi5z//+WafN2DAgJTxvHnztjp3YWFhTJ06NZo2bZo89q9//Sv69OkTd999d7X3SGbl+3UpLS1NGZeUlGRpJ0Bjko2+rU7XZsqm9yrZaaed6m3thkjXAtRcLr63nTBhQsr4yCOPjKeeeqpG+e///u+UOY477rgqz9l9992r/Tr5Sj73ra4FsiEXu5bcVt9du2rVqti4cWNyXJv7/WZyDoCayOW+zef3UA2VrgUAAAAAAAAAAAAAAAAamsJsbwAAIF09evRIGT/33HN1ss78+fNTxnvuuWc0a9asTtb6uvPPPz9l/Pzzz9f5mtkwfvz4eP/995PjNm3axC9/+csqz9ttt91i7NixKcdGjhyZ8kP59SGd67LpjevKy8szuieA6spmd9albt26pdzgZ/369TFr1qw6XTNb9CZA/cq39539+vVLuUn7vHnzYty4cbXeXz5r6N2pN4Fc8/XuzPXepKqG3pt777138r/Lysri3XffrfKcbbbZJvr16xdnnXVWXHjhhTF69Oj44Q9/GAMGDIi2bdtmZuMA/798e89ZEz7nTJUL3ak3AQAAAAAAAAAAAAAAAACAXFVaWhpnnHFG9OjRI37zm9/E8uXLq3Xehg0bYs6cOfGDH/wg9thjjzjqqKNi7dq1ycePOeaYuPvuu+tq2zRgn3zySYwYMSL23XffuPvuu2PlypXVOm/NmjXxu9/9LvbZZ5/46U9/Gl988UUd7xQgv2S78zdu3BiXX355dOvWLa6//vp47733qr33jz/+OK6//vro1q1b/Nd//VdUVlZW+1xyk74HqBvZ7nv4On0PkHm6nlz2zDPPRLdu3WLkyJGxePHirT5/48aNMWvWrDjqqKPiqKOOig8//LAedgmQH3Q+uUrfAwAAAAAAAAAAAAAAAABA47F8+fJ45ZVXUo6dd9551T6/oqIiZTx+/Pgq5++www5xyimnpBx79NFHtzr3iBEjolu3bslxZWVlnHjiifHGG29Ue39kXr5fl6ZNm6aMN/01DFAXstG31enaTFmzZk3KuHnz5vW2dkOkawFqLhff2zZp0qTa69fG22+/XS/rNDT53Le6FsiGXOxacls2unbp0qXJ/27VqlWt52vbtm3K+LPPPqv1nADfJJf7Np/fQzVUuhYAAAAAAAAAAAAAAABoaIqyvQEAgHR16dIlZbxo0aI6Wef111+PioqKaNasWUREFBYWxp577hmvvfZanawXEXHuuefGd7/73ZRj9957b52tl01lZWUxevToeOihh5LHzjvvvLjzzjtjwYIFyWM33nhjtGjRIjn+4x//GE8//XR9bjXt61JSUpIyLi8vr/J4+/btk89bs2ZNfPDBB7Fu3bpa7hggVTa7s67suOOO8eCDD0ZR0Vd/xXH33XdHaWlpna2ZTXpTbwL1K5/ed7Zt2zamT5+evEn7ypUrY+jQobFx48Y62XO+aOjdqTeBXPP17szl3mTzGnJvNmnSJIqLi5Pj5cuXpzw+YMCAGD16dAwcODD5a2tTiUQinn/++Zg8eXLcc889sWHDhlq8AoD8es9ZEz7nzL3u1JsAAAAAAAAAAAAAAAAAAEA+eO211+LCCy+Mn/zkJ9G1a9f49re/HXvssUfssMMOse2228b69evj888/j48++igWL14cCxYsiM8//zx5/nPPPRcnnnhiPProo8mfhR4xYkSUlpbGT3/6082u+etf/zp+/etf18vry4S//e1vUVBQkO1tVNGhQ4eMzpcr12XBggVx9tlnR2FhYfTq1Su6d+8ee+yxR2y33XZRXFwcZWVlsXLlylixYkXMnz8/Fi1aFJWVldneNkDOy0bnf93bb78dY8eOjbFjx8buu+8e3/72t2PPPfeMtm3bRnFxcTRt2jRWr14dn376aSxbtiyef/75eOONN+rs67EpfV+/9D1A3ch236ejvjtY59cffQ+QefnQ9WPGjIkxY8ZkZK506fv6t2HDhrj99tvj9ttvj5133jm+973vxc477xzt2rWLbbfdNtauXRsff/xxvPrqqzF37txYuXJltrcMkNOy1fm51C1bo+/rn74HAAAAAAAAAAAAAAAAAIDG46677opJkyYlx2eddVaMHz8+Pvvss62ee+ONN8aOO+4Yl156afLYbbfdFqWlpfHggw9GRMQ555wTLVq0SD6+atWqmDlz5lbn/s///M+U8X333RfPPvvsVs+jbuX7ddl5551Txh999FGWdgI0NvXdt9Xp2kxp1apVyrg6r4kt07UA6cnV97Z1aeXKlSn3paP68rlvdS2QLY2xa0lfNrr2mWeeiS5dukRERFFRUXTt2jVef/31tOfr3r17yvidd96pzfYAqiVX+zaf30M1VLoWAAAAAAAAAAAAAAAAaGiKsr0BAIB0tWvXLmVcWlpaZ2t9+umn0b59+5S1X3vttTpZ69RTT41bb7015dgLL7wQTzzxRJ2slwtmzJgRTzzxRBxxxBEREVFYWBi33HJL9OvXLyIiBg4cGCeeeGLy+Z9//nlccskl9brH2lyX4uLi5H+vX78+ioqK4qSTTorjjz8++vXrF506dapyTiKRiLfeeivmzJkTU6ZMiaeffrr2LwJo9LLZnZlWUlIS3//+92P8+PEpr+uVV16p946ob3pTbwL1J5/ed06dOjU6duwYEV/+vjhixIhYtmxZxveZjxpyd+pNINd8vTtzuTfZsobam9ttt13KeM2aNRER0bp16/j9738fxx577FbXLSgoiAMOOCAOOOCAuOSSS+LMM8+Ml156KY1XAPClfHrPWV0+58y97tSbAAAAAAAAAAAAAAAAAABAvkkkEvHPf/4z/vnPf9b43FmzZsWIESNi2rRpUVhYGBERxxxzTFx55ZWxatWqTG+VRqKysjJeeuklPzcPkGG50PnvvPNOvPPOOzVen4ZH3wPUjVzoe/g3fQ+QebqeXPbhhx/GtGnTsr0NgAZB55Or9D0AAAAAAAAAAAAAAAAAADRsf/jDH+Kaa66J4uLiiIho3bp13HTTTXHWWWdV6/zLLrssWrduHeedd15ERBQWFsY999wTn376abz99ttx5ZVXpjz/rrvuirKysm+cs1WrVnHwwQenHPvd735XzVdEXWkI1+XQQw9NGb/33ntZ2gnQ2NR3326tazNpn332SRl/9NFH9bZ2Q6NrAdKXa+9tu3btmt4L+Zo+ffrElClTkuP77rsvrrjiiuR4/fr1tV6jMcr3vtW1QLbkWteSu7LVtU899VT84Ac/SI5POOGE+NWvfpXWXG3atKnyGp5//vla7Q+gOnKxb/P9PVRDpGsBAAAAAAAAAAAAAACAhqgw2xsAAEhXSUlJyvizzz6rs7U2nXvTtTNhm222iZtuuimmTZsWRUVFyeNr166NH/7wh5FIJDK+Zi4ZNWpUVFRUJMcHH3xwDBs2LIqKiuLmm29Oee7ll18eH3/8cb3sKxPX5eu/XgoLC+P999+PadOmxWmnnRadOnXa7DkFBQWx5557xrnnnht///vfY968edG7d+/avyCgUctmd9bU/vvvHzNnzkzJo48+GnPmzInFixfHZ599FnfccUe0a9cuec7SpUvj6KOPjtWrV9dy97lPb6bSm0BdyZf3nePGjYtBgwYlxxMnToz//d//zdTWGoSG2p16E8g1X/99KVd7k61riL25/fbbp4zXrl0bO+20Uzz33HNx7LHH1ngvPXr0iKeffjqOO+64Gp8L8G/58p6zOnzOmXvdqTcBAAAAAAAAAAAAAAAAAIDG6v77748f//jHERGxYMGCOPjgg2PVqlVZ3hUAkGk6HwAaPn0PAA2brgeAxkHnAwAAAAAAAAAAAAAAAAAAkI7S0tK44YYbUo6deeaZMWzYsGrPMXLkyHjggQeS42bNmsXDDz8cDz30UBQXFyePr1mzJq699tqtzterV68oKChIjtevXx9PP/10tfdD3cjmdenVq1fcf//9cfPNN6c9x8477xxDhgxJOfb444/XdmsA1VLffVsdO+ywQ/zsZz+LbbbZptp72FSfPn1i7733To4TiUS88MILac/X2OlagPTl2nvbN954o9Z57733Uub89NNPUx5/++23q/3a+Eq2+lbXAvku17qW3JWtrn3wwQfj888/T44vvvji2HbbbdOa6+c//3kUFRUlxwsWLIilS5fWeo8AW5OLfetz29yjawEAAAAAAAAAAAAAAICGqGjrTwEAyE0tW7ZMGZeVldXZWpvedLY2N5XdVGFhYZxxxhkxYcKE6NixY8pjZWVlcdJJJ8WiRYsytt7WtG3bNubPn1/j8zZu3BgHHnhg2usuWbIkbrjhhrjsssuSxyZOnBhdu3aNbt26JY+9/PLLMXny5LTXqa5MXpev33iiSZMm0a5duxrv58ADD4xnn302LrjggrjjjjtqfD5ARHa7s6batWsXgwcPrvbzb7311rjkkkti3bp1tVq3pvTml/Qm0FDlw/vOfv36xYQJE5LjuXPnpvRDrtGdX8pUd+pNINd8vTtzsTfzjd78UiZ6s1mzZinjysrKePjhh6Nz584REbFhw4aYNm1azJgxI1544YX4+OOPo6KiIlq3bh177bVXDBw4MEaOHBkdOnRIztGyZcu4//7747DDDou5c+dm6NUCjUk+vOfcGp9zfimXulNvAgAAAAAAAAAAAAAAAAAARNxxxx1RVlYWjzzySKxatSrb2wEA6ojOB4CGT98DQMOm6wGgcdD5AAAAAAAAAAAAAAAAAAAApOP666+PYcOGRefOnZPH/vjHP0bTpk3j97///VbPTyQSMWzYsNh+++3jiCOOiIiIkpKS6NWrV8rzLrnkkvj444+3Ot9uu+2WMn777bejoqJi6y+EOpWt6zJjxow48cQTIyJi48aN8cgjj8ScOXNqNEfTpk3jD3/4QxQXFyePrVy5Mp588smM7hXgm9Rn336Ttm3bxsUXXxw//vGPY7vttotvfetbMXLkyBq/nu222y5+97vfpRybN29efPTRRzWeiy/pWoDaybX3tuSmbPStrgUaCl1LdWTrve3atWvjd7/7XVx88cUREbHjjjvG1KlT44QTTohEIlHteY499ti48MILU45NnDgxo3sF+Ca51rc+t809uhYAAAAAAAAAAAAAAABoiIqyvQEAgEypyQ9g13bugoKCjMx7yimnxPjx46Nr165VHnvnnXdiyJAh8eKLL2ZkreoqKiqK/fffv8bnLV26tNZrT5gwIYYPHx677rprRER06NAhfvGLXyQfTyQSMXLkyKisrKz1Wt8k09elpKSkyrHly5fHnDlzYv78+bFs2bL4/PPPo6CgILbffvvYY4894qCDDoojjzwyWrRokTynadOmcfvtt0dlZWX89re/Te/FAXxNfXZnXTvhhBPimWeeiWnTptXrunpTbwKNS66972zbtm1Mnz49mjRpEhERpaWlceqpp8bGjRvrZI+ZoDsz2516E8hludab+Uhv1t3foR900EFRWFgYEREvvvhinHrqqZv9upWWlkZpaWk8++yz8atf/Sp++ctfpvwjdc2bN4+pU6dGjx49oqysrMb7APi6fOtOn3OmyoXu1JsAAAAAAAAAAAAAAAAAAABfmTJlSra3AADUA50PAA2fvgeAhk3XA0DjoPMBAAAAAAAAAAAAAAAAAACoqbKyshgyZEg8++yz0aJFi4iIKCwsjLvvvjuOOuqouOSSS+L999//xjnWr18fJ598cixevDh22223Ko8/8MADcccdd1RrP9ttt13KuLS0tJqvhLqUreuybNmy5H83adIkZs6cGeeee25MnTq1Wud36NAhpkyZEocffnjK8SuvvDLWrVuX0b0CfJNc6dtvfetbMW7cuOT4Rz/6URQUFMTFF18ca9eurdZr6datW9x7772xzz77pBy/+uqrq3U+m6drAWonV7qW3JaNvtW1QEOha6mObP79/rXXXhunnXZadOzYMSIijjvuuHjkkUdixIgR8fnnn2/1/B/+8Idxyy23RGFhYfLY3LlzY9q0aXW2Z4BN5Vrf+tw29+haAAAAAAAAAAAAAAAAoCEqyvYGAAAypaCgIG/mPvroo+OXv/xl9OrVq8pjlZWV8bvf/S4uvvjiWLNmTUbXrUtvvvlmrecoLy+Pn/zkJ/GnP/1ps4//v//3/+K5556r9TpbUlfX5ec//3lcc801se+++8ZTTz0Vv/zlL2P27NmRSCS+8bzWrVvH2LFj4+KLL44mTZokj99yyy3x3HPPxaJFi2q0D4BN5XJ3lpaWxl//+tcqx1u0aBFt27aNPfbYI+VmKh07dox77703vvvd78b555+/1d9js01vbpneBHJZrnXn1KlTkzcnSyQSMWLEiJSbcjckunPz9CaQy3KtNxsTvbl1//47hblz58Zhhx0WX3zxxVbPqaioiDFjxsS7774bv/nNb5LHv/Wtb8XIkSNj0qRJae0F4N/ypTt9zrl52exOvQkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEOycOHCOOGEE+Lhhx+OFi1aJI8PHTo0jj/++JgzZ078+c9/jgULFsSKFSvik08+iaKiomjVqlV06dIlvve978WQIUNit912qzJ3RUVFXHjhhdXeS1FRUcp49913j8mTJ6f/4r7m2muvjffffz8jczU22boul19+eRx11FHRuXPniIho2bJlTJkyJUaPHh133313PPnkk7FkyZJYv3598pzi4uLo06dPnHzyyXHmmWdGSUlJypxPPfVUxvYOUBO50Lfz58+P3/72t3HOOeckj5133nlxwgknxO9///t47LHHYtGiRbFy5cqU89q2bRt9+vSJ73//+3HKKadEs2bNUh6/55574oknnqjpl4Sv0bUAtZcLXUtuq6u+1bVAY6Fr2Zps/v3+ypUrY9iwYfF///d/UVhYGBERxx57bCxdujRuuumm+NOf/hSvvPJKyjmtW7eOAQMGxOjRo6Nv374pj61YsSKGDRsWiUQiI/sHqK5c6luf2+YeXQsAAAAAAAAAAAAAAAA0REVbfwoAQG4qLy9PGRcXF9fZWpvekGzdunVpzdO/f/+47rrr4qCDDtrs47Nnz45LLrkkFi5cmNb8mVBRURFz586t8XmZujnuww8/HI899lgceeSRKcdXrlwZY8eOzcgam6rr6/Loo4/Go48+GnvvvXe89tpr1T7v36951qxZMXPmzOTNMJo1axaTJk2KgQMHprUfoPHKZnfW1HPPPReHHnroFh/fbrvt4thjj42xY8fGPvvskzw+cuTIWLNmTfzsZz+r1frVpTer0ptAQ5LL7zvHjRsXgwYNSo6vv/76+Mtf/lIne8sk3VlVbbpTbwK55uvdmUu9ma/0ZlWZ/Dv01atXx4knnhhffPFFjc675ZZb4qCDDorTTz89eWzUqFExadKkWu8JaFxy+T3n5vicc+vquzv1JgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADdXjjz8eRxxxREyfPj123nnn5PHmzZvH0UcfHUcffXRa8zZr1iwefPDBGDBgQKxbt67G53fo0CF+9KMfpbX2pn7729/G+++/n5G5Grv6ui6rV6+OI488MmbNmhXf+ta3ksf322+/2G+//SIiorKyMlavXh1ffPFFbLvtttGyZcstrvXiiy/GscceGxs3bszI3gFqKhf6dtSoUbHrrrvGoEGDksfat28fY8eOjbFjx0ZExLp166KsrCw2btwY22+/fTRr1myL8z366KNx1llnpbVvtkzXAqQnF7qW/JGpvtW1QGOia6mJ+v77/aeeeipOPfXUmDp1ajRv3jwiItq0aRPjx4+P8ePHR3l5eXz88cdRUVERrVu3jlatWkVBQUGVef71r3/FUUcdFe+8805G9g5QU7natz63zT26FgAAAAAAAAAAAAAAAGgIirK9AQCAdK1ZsyZlvMMOO9TZWq1atUoZl5WV1ej8XXbZJf77v/87TjzxxM0+/vTTT8fll18ef/vb39LeY6asXLkyDj300KzuYdSoUfHaa69F06ZNk8d+8YtfxMqVKzO6Tn1fl9deey2t82bPnh0jR46Mu+++O3lswIAB0bVr13j99dczsjegcchmd2baqlWr4p577on77rsvbrrppjj//POTj40ZMyZmzpwZf//73+t0DxF68+v0JtAQ5er7zn79+sWECROS42eeeSYuv/zyOttbJunOr2SyO/UmkCu+3p250pv5TG9+pS7+Dv03v/lNrFixIq1zL7vssjjttNOSN37dfffdo0ePHrF48eKM7Q9o+HL1PeemfM5ZM/XRnXoTAAAAAAAAAAAAAAAAAP4/9u49yOqy/gP4Z7/ACq1cRVMyL2iyOXIxDG3ImN9I6kqiJuRMiJfMURwjmTQsa6gsNSqh7AIjIxIwKFBpMpPKmHk3SFoJjcE2EBGEhUWuyW3390fTyhGVZffs9/vd3ddrhpl9nnOe5/s+HIY3z56zBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAteOaZZ6Jfv34xadKkGDVqVCRJ0qh91qxZE2VlZdG9e/eIiBg8eHDMnz8/Lrrooti3b18xI9MGVFVVxaBBg2LSpElx+eWXH3B7kiTRtWvXD92jrq4ufv7zn8ett94au3btaq6oAA3S3H37hS984UPX7d69O4YNGxY/+MEP4uabb47S0tID7tOxY8fo2LHjh+6za9eu+N73vhcTJ06M2traRj0G8kHXAq2Nsy15o2uB1kbXkmfz58+PdevWxYwZM+Kkk04quK1Tp05x3HHHfej6Rx99NK655ppYu3Ztc8YEOCh9S17pWgAAAAAAAAAAAAAAAKDYGvcTdAAAObB+/fqCcc+ePZvtWt26dSsYH8oPbVdUVMTLL78cl1xyyQG3LV68OM4999w4++yz4+mnn25qzFajqqoqNm3aVDC3bNmyol6jpT0v999/f/zjH/8omBs+fHhGaYCWKsvubC579+6NG2+8MebPn18w/6Mf/SiV6+eB3jyQ3gSKJY/nziOOOCIeeOCBaNeuXUREbNy4MS677DIfbncIdGchvQkU0/7dmYfepOlac2/Omzev0WtXrVoVL730UsHcwIEDmxoJaGPyeOZ8r5Z0tsmL5u5OvQkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQFuyadOmuOKKK+K0006Le+65J9atW9egdXv37o0nnngirr766ujdu3dUVFTEjh076m8fNmxYTJ8+vbli08pt3LgxRo8eHaeffnpMnz49ampqGrRu+/btMW3atOjbt2+MGzcudu3a1cxJARqmOfu2Ifbt2xe33XZblJeXx8SJE2P16tUNzl5dXR0TJ06M8vLyuOuuu6K2trbBa8kvXQu0Ns625I2uBVobXUuePffcc1FeXh5jxoyJZcuWHfT++/bti4ULF0ZFRUVUVFTE2rVrU0gJcHD6lrzStQAAAAAAAAAAAAAAAEAxtc86AABAY7322msF4/79+zdqn89+9rPx7LPPfuDt5eXlUVpaWjDX0A+THTlyZMyZMyfatWtXMP/yyy/Hd7/73XjkkUcOPTBN1lKfl3nz5kXfvn3rx5/61KcyTAO0RFl2Z3O76aab4otf/GIkSRIREWeffXYce+yxsWbNmlRztEZ6E2jL8njunD17dnzsYx+LiIi6uroYPXp0vPnmm43KRfNoid2pN4Fi2b8789Cb5F9avfne/2iktrY2li5d2qQ9lyxZEmeccUb9+Nhjj23SfkDbk8cz5/5a4tmmtdObAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC0Vf/85z9j7Nix8fWvfz369OkT/fv3j969e0e3bt2ic+fOsWfPntiyZUusX78+li1bFpWVlbFly5b69X/961/jkksuiQULFkRpaWlERIwePTo2bdoU48aN+8Dr3n333XH33Xc3++MrlqeffjpKSkqyjnGAY445pqj75eV5qaysjK985SuRJEkMGDAgTj311Ojdu3d06dIlysrKYufOnVFTUxMbNmyIxYsXx9KlS6O2tjbr2AAfqDn6dtKkSR/atftbuXJljB8/PsaPHx8nnHBC9O/fP0466aTo2bNnlJWVRYcOHWLbtm2xefPmWLNmTSxatChWrFjRLL8XH0TXpkvXAq1NVmfbpkq7//RtenQt0Nq0hK695ZZb4pZbbinKXo2la9O3d+/emDJlSkyZMiV69eoVQ4YMiV69esVRRx0VnTt3jh07dkR1dXW8+uqr8fzzz0dNTU3WkQE+kNdtGyaPfatrdS0AAAAAAAAAAAAAAABwcO2zDgAA0FjLli0rGJ955pmHvMeYMWPiV7/6Vfzyl7+MsWPHvu99Bg0aVDCuqqqK7du3H3TvgQMHxuzZs6Ndu3b1c1u2bIlx48bF9OnTDzkrxdGSn5dXX321YHz00UdnlARoqbLszub25ptvxqJFi+Kss86qnzvzzDNjzZo1zX7t1kxvAm1d3s6dt956a5x33nn148ceeyx27twZn/vc5xqcZ8CAAQXjXr16HbB+6dKl8fbbbzd4T97VUrtTbwLFsn93Zt2b5F+avbl58+YDxk39j0iqq6sLxl26dGnSfkDbk7cz5/5a6tmmNdObAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQUVdXF8uXL4/ly5cf8tqFCxfG6NGjY86cOZEkSUREDBs2LCZMmBBbt24tdlTakNra2liyZEksWbIk6ygARVHMvm1s165atSpWrVp1yNenddK1QGvjbEve6FqgtdG15NnatWtjzpw5WccAaDJ9S17pWgAAAAAAAAAAAAAAAKAp2mcdAACgsZ588smC8fHHHx+nnHJKrFixokHrx48fH3fddVdERHzta1+LDRs2xA9/+MMD7jd06NCC8QsvvHDQvZMkiVmzZkWHDh3q5956660YMmRIg/NRfC39edm0aVPB+PDDD88oCdBS5bk7i6GqqirOOuus+vHRRx+dynVbK70JkL/ufO/a888/P84///wGZfkgw4cPj+HDhxfMnX766VFZWdmkfduiltydehMolv27M+veJN/S7s2tW7fGvn37ol27dhHx3/+wpKmKsQfQtuXtzPk/Lfls01rpTQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKI65c+dG9+7dY8qUKVFZWRnnnntubN26NetYANCq7N+3gwcP1rUAUGTOtgDQvHQtADQ/fQsAAAAAAAAAAAAAAABAHiVZBwAAaKx169bFK6+8UjB33XXXNXj97t27C8a33377Aeu7desWI0eOLJhbsGDBQfcePXp0lJeX149ra2vjkksuiRUrVjQ4H8XX0p+XDh06FIzf+2cY4GDy3J3FsH379oLxYYcdlsp1Wyu9CZC/7mzXrl2Dr90UK1euTOU6rU1L7k69CRTLe7uzNZ05Ka4serOqqqr+6+7duzd5v549exaM33777SbvCbQteTtz/k9LPtu0VnoTAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACKZ+rUqXHFFVfEkCFDorq6Ous4ANAq/a9vdS0ANA9nWwBoXroWAJqfvgUAAAAAAAAAAAAAAAAgb5KsAwAANMV9991XML7qqquiW7duDVo7adKkuPPOOwvmfv3rX8eIESPqx9dee2107Nixfrx169Z45JFHDrr3V7/61YLxgw8+GC+++GKDctF8Wvrz0qtXr4Lx+vXrM0oCtGR57c5i6N69e8H47bffTuW6rZXeBPiv1tyd76empia2bNmS2fVbspbcnXoTKKb9u7O19yaNl0VvPvfcc/Vft2/fPvr06dOk/U499dSC8apVq5q0H9A25fHM2ZLPNq2V3gQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgOKaOXNmbN26NesYANCqzZw5M+sIANCqOdsCQPPStQDQ/PQtAAAAAAAAAAAAAAAAAHmSZB0AAKApZsyYETt27Kgf9+jRIyZPntzg9d/+9rdj6tSp9eMkSWL27NlxzjnnRO/evWPChAkF97/vvvti586dH7pn9+7dY/DgwQVz06ZNa3AmmkdreF7+7//+r2C8evXqjJIALVkeu7NY+vbtWzBev359KtdtjfQmwLvy1J19+vRp8q/Ro0cX7Pnggw8W3H7GGWc0+LHxrpbenXoTKKYZM2bUf92azpwUT1a9+dRTTxWML7744kbvdcQRRxzwGBYtWtTo/YC2K09nzoiWf7ZpjfQmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0nyTrAAAATbFp06b46U9/WjB35ZVXxqhRoxq8x5gxY2LevHn149LS0njooYfid7/7XZSVldXPb9++Pe64446D7jdgwIAoKSmpH+/ZsyeeffbZBueheWT5vAwYMCDmzp0bv/jFLxq9R69evWLEiBEFc4899lhTowFtUB67s1u3bvHNb34zPvKRjzQ4w3sNGjQoPvnJT9aP6+rq4m9/+1uj92vr9CbAu/LUnStWrGjyr9WrVxfsuXnz5oLbV65c2eDHxbuy6k69CeTRpk2bCsZZnznJn6x6c/78+bFly5b68Te+8Y3o3Llzo/b6zne+E+3bt68fV1ZWRlVVVZMzAm1Pns6cEV7nzCO9CQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzSfJOgAAQFNNnDgx/vWvfxXM/fa3v42rrrqqQevr6upi1KhR8fjjj9fPHX744TFgwICC+918881RXV190P2OP/74gvHKlStj9+7dDcpC88nqefn9738ff//732PkyJFxww03xDnnnHPIe3To0CFmzJgRZWVl9XM1NTXx5JNPFjMq0IbkpTt79uwZd955Z7z++uvx4x//OH72s581+DHsr0uXLjFt2rSCuRdeeCHWr1/fqP3QmwDvlZfuJL+y6E69CeSZ3uTDZHXm3LFjR8H3D4488siYNWtWlJSUHNI+F154YYwdO7Zg7ic/+UlRMgJtU57OnF7nzB+9CQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzSfJOgAAQFPt3LkzRowYEe+88079XJIkMX369HjwwQfj4x//+EH32LNnT1x66aXx+uuvv+/t8+bNi6lTpzYoT5cuXQrGmzZtatA6mldWz8uaNWvqv27Xrl088sgjcfnllzd4/THHHBN/+tOfYujQoQXzEyZMKPgzD3Ao8tKdJ554Ytx66631f0dff/31MWXKlCgrK2vwYykvL4+//OUv0bdv34L573//+w3egwPpTYBCeelO8iuL7tSbQJ7pTT5Mlt9Dv+OOO+LNN9+sHw8fPjwefvjh6Nq1a4PWX3PNNTF37txIknffavH888/HnDlzip4VaDvydOb0Omf+6E0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGg+7bMOAABQDC+//HJcfPHF8dBDD0XHjh3r57/0pS/FRRddFE888UT88Y9/jMrKytiwYUNs3Lgx2rdvH927d49TTjklhgwZEiNGjIjjjz/+gL13794dY8eObXCW9u0L/4l1wgknxG9+85vGP7j93HHHHfHGG28UZa+2Jqvn5bbbbouKioo4+eSTIyKiU6dOMXPmzLjpppti+vTp8eSTT8Zrr70We/bsqV9TVlYWgwYNiksvvTSuvPLKOPzwwwv2fOqpp4qWHWi78tCdixcvjnvvvTeuvfba+rnrrrsuLr744rj//vvj0UcfjaVLl0ZNTU3Bup49e8agQYPiy1/+cowcOTJKS0sLbp89e3Y8/vjjh/pbwn70JsCB8tCd5FcW3ak3gTzTm3yYLL+HXlNTE6NGjYo///nPkSRJRERceOGFUVVVFZMnT44//OEP8corrxSs6dGjRwwdOjRuuumm+MxnPlNw24YNG2LUqFFRV1dXlPxA25WX7vQ6Z/7oTQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaD7tsw4AAFAsjz32WJx77rnxwAMPRK9evernDzvssLjgggviggsuaNS+paWlMX/+/Bg6dGi88847h7z+mGOOieuvv75R136ve++9N954442i7NXWpfW8bNu2Lc4///xYuHBhnHjiifXzAwcOjIEDB0ZERG1tbWzbti127doVnTt3jk6dOn3gtV566aW48MILY9++fUXJDrRteejOG2+8MY477rg477zz6uc++tGPxvjx42P8+PEREfHOO+/Ezp07Y9++fdG1a9coLS39wP0WLFgQV111VaNy88H0JsB/5aE7aRnS6E69CeSd3qSh0v4e+lNPPRWXXXZZzJo1Kw477LCIiDjiiCPi9ttvj9tvvz3+85//RHV1dezevTt69OgR3bt3j5KSkgP2eeutt6KioiJWrVpVlOwAeexOr3Pmj94EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDiSbIOAABQTM8880z069cvZs6cGbW1tY3eZ82aNbF58+b68eDBg2P+/PnRrl27YsSkjamqqopBgwbFrFmz3vf2JEmia9eucdRRR0WnTp3e9z51dXUxefLkGDx4cGzbtq054wJtTNbduXv37hg2bFjccccdsXv37ve9T8eOHaNHjx5x5JFHRmlp6fveZ9euXfGtb30rLrrooti7d2+jHwfZ05tA3mXdnbA/vQnknd4kr+bPnx/nnHNOVFVVHXBbp06d4rjjjouTTz45evToESUlJQfc59FHH42BAwdGZWVlCmmBtkR3kkd6EwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA1irJOgAAQLFt2rQprrjiijjttNPinnvuiXXr1jVo3d69e+OJJ56Iq6++Onr37h0VFRWxY8eO+tuHDRsW06dPb67YtHIbN26M0aNHx+mnnx7Tp0+PmpqaBq3bvn17TJs2Lfr27Rvjxo2LXbt2NXNSoC3Kujv37dsXt912W5SXl8fEiRNj9erVDc5eXV0dEydOjPLy8rjrrruitra2wWvJL70J5F3W3Qn705tA3ulN8uq5556L8vLyGDNmTCxbtuyg99+3b18sXLgwKioqoqKiItauXZtCSqAt0p3kkd4EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKA1Kqmrq6tr0B1LSpo7C9BC9evXL/r16xcREXV1dfHvf/87XnzxxWjgXy8Aza6kpCT69OkT/fv3j969e0e3bt2ic+fOsWfPntiyZUusX78+li1bFpWVlbFly5aCtZ///OdjwYIFUVpaWj83efLkGDduXNoPg1YmSZIYMGBAnHrqqdG7d+/o0qVLlJWVxc6dO6OmpiY2bNgQixcvjqVLl0ZtbW3WcYE2Jg/decIJJ0T//v3jpJNOip49e0ZZWVl06NAhtm3bFps3b441a9bEokWLYsWKFUV5zOSb3gTyLg/dCf+jN4G805vkVa9evWLIkCHRq1evOOqoo6Jz586xY8eOqK6ujldffTWef/75qKmpyTom0AbpTvJIbwLkS0lJSZxxxhlxyimn1L/fe+nSpbF06dKMk7VN3lMLAAAAAAAAAAAAkK6SkpL49Kc/HZ/4xCe8nxZosKa8x9tntQMfxM+VAAAAAAAAAAAAAKTPZ7Xni/fUAgAAAAAAAAAAAKTLZ7UDjeGz2oHm4OdKAAAAAAAAAAAAANLns9rzxXtqAQAAAAAAAAAAANLls9qBxmjIe7zbp5ADACBTdXV1sXz58li+fPkhr124cGGMHj065syZE0mSRETEsGHDYsKECbF169ZiR6UNqa2tjSVLlsSSJUuyjgJwgOboznHjxh3SPqtWrYpVq1Yd8vVpnfQmkHfOneSJ3gTyTm+SV2vXro05c+ZkHQPgALqTPNKbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC0BknWAQAA8m7u3Llxww03REREZWVlDB48OLZu3ZpxKgDIr/frTgDggzl3AkDD6U0AODS6EwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4P21zzoAAEBLMHXq1Ni5c2c8/PDDsXXr1qzjAEDu6U4AODS6EwAaTm8CwKHRnQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAdqn3UAAICWYubMmVlHAIAWRXcCwKHRnQDQcHoTAA6N7gQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACiUZB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0pJkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADSkmQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANKSZB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0pJkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADSkmQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANKSZB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0pJkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADSkmQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANKSZB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0pJkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADSkmQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANKSZB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0pJkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADSkmQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANKSZB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0pJkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADSkmQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANKSZB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0pJkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADSkmQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANKSZB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0pJkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADSkmQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANKSZB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0pJkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADSkmQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANKSZB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0pJkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADSkmQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANKSZB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0pJkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADSkmQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANKSZB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0pJkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADSkmQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANKSZB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0pJkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADSkmQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANKSZB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0pJkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADSkmQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANKSZB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0pJkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADSkmQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANKSZB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0pJkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADSkmQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANKSZB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0pJkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADSkmQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANKSZB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0pJkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADSkmQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANKSZB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0pJkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADSkmQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANKSZB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0pJkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADSkmQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANKSZB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0pJkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADSkmQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANKSZB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0pJkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADSkmQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANKSZB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0pJkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADSkmQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANKSZB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0pJkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADSkmQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANKSZB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0pJkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADSkmQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANKSZB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0pJkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADSkmQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANKSZB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0pJkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADSkmQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANKSZB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0pJkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADSkmQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANKSZB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPh/du7nxerqj+P4+x5vCi2yJtTCFCrEhbqJwKgI0z9AhGhXRBAMkrRoU+muRQTNgJvmD0iIoiCIliFWi5AgMLMoQsrIpvJXgUbOzP3uvpTM3PmMM5/z/szM4wFtxjP3PhdBUee8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBaSnYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1FKyAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKCWkh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtZTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKilZAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABALSU7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGop2QEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQS8kOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgFpKdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADUUrIDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoJaSHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC1lOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqKVkBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAtJTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAainZAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFBLyQ4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAWkp2AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANRSsgMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACglpIdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALWU7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACopWQHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQC0lOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABqKdkBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUEvJDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBaSnYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1FKyAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKCWkh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtZTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKilZAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABALSU7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGop2QEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQS8kOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgFpKdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADUUrIDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoJaSHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC1lOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqKVkBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAtJTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAainZAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFBLyQ4AVp5SSqxZsyY7AwAAAAAAAAAAAGBFK6VEKa6Ed5U7tQAAAAAAAAAAAADtcp8WAOgq70oAAAAAAAAAAAAA2udtSbe5UwsAAAAAAAAAAADQLvdpAYCu8q4EAAAAAAAAAAAAoH3elnSbO7UAAAAAAAAAAAAA7XKfFmhLPzsAWFl6vV6MjIzEgw8+GNPT09k5AAAAAAAAAAAAACvO1NRUlFKi3+/Hhg0botfrZSdxA3dqAQAAAAAAAAAAANrjPi0A0GXelQAAAAAAAAAAAAC0y9uS7nOnFgAAAAAAAAAAAKA97tMCAF3mXQkAAAAAAAAAAABAu7wt6T53agEAAAAAAAAAAADa4z4t0LZ+dgCw8qxfvz5uu+227AwAAAAAAAAAAACAFc9Dk+5ypxYAAAAAAAAAAACgfe7TAgBd5F0JAAAAAAAAAAAAQB3elnSXO7UAAAAAAAAAAAAA7XOfFgDoIu9KAAAAAAAAAAAAAOrwtqS73KkFAAAAAAAAAAAAaJ/7tEAb+tkBwPI3NTUV09PTsWbNmv//zL+4AAAAAAAAAAAAANQ1MzMTg8EgO2PVcqcWAAAAAAAAAAAAIJf7tABAFu9KAAAAAAAAAAAAAPJ5W5LLnVoAAAAAAAAAAACAXO7TAgBZvCsBAAAAAAAAAAAAyOdtSS53agEAAAAAAAAAAAByuU8LLJWSHQAsf3/88UdcuXIlZmZmslMAAAAAAAAAAAAAVq2//vor/vzzz+yMVcudWgAAAAAAAAAAAIBc7tMCAFm8KwEAAAAAAAAAAADI521JLndqAQAAAAAAAAAAAHK5TwsAZPGuBAAAAAAAAAAAACCftyW53KkFAAAAAAAAAAAAyOU+LbBUeoPBYNDoYK/XdguwTPV6vbj77rtjZGQkSinZOQAAAAAAAAAAAACrzszMTFy6dCnOnz9vPDyJO7UAAAAAAAAAAAAAedynBZpqOMs+K1vtwFy8KwEAAAAAAAAAAADI5W1JPndqAQAAAAAAAAAAAPK4Tws0ZasdaIN3JQAAAAAAAAAAAAC5vC3J504tAAAAAAAAAAAAQB73aYGmmmy19wYNF92NtwMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAy1XDWfZZ2WoHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJYrW+0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAwGrUZKu9VOgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACATijZAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFBLyQ4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAWkp2AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANRSsgMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACglpIdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALWU7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACopWQHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQC0lOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABqKdkBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUEvJDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBaSnYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1FKyAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKCWkh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtZTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKilZAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABALSU7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGop2QEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQS8kOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgFpKdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADUUrIDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoJaSHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC1lOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqKVkBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAtJTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAainZAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFBLyQ4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAWkp2AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANRSsgMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACglpIdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALWU7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACopWQHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQC0lOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABqKdkBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUEvJDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBaSnYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1FKyAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKCWkh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtZTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKilZAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABALSU7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGop2QEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQS8kOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgFpKdgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADUUrIDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoJaSHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC1lOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqKVkBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAtJTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAainZAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFBLyQ4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAWkp2AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANRSsgMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACglpIdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALWU7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACopZ8dAAAAAAAAAF23b9++OHLkyH9+9vvvv8eTTz6ZVAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0D5b7QAAAAAAAAAAAAAAAAAAAAAAAAAAAADAamSrHQAAAAAAAAAAAAAAAAAAAGB16GcHAAAAAAAAQNdt2rQp9uzZ85+f/fzzzzkxAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACV2GoHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFYjW+0AAAAAAAAAAAAAAAAAAAAAq0M/OwAAAAAAAADms3HjxqF/Pj09HRcuXKhUQ1eNjIxEvz/8f4H+9ttvlWoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYPFstdOErXYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVhpb7TRhqx0AAAAAAAAAAAAAAAAAAABYrJIdAAAAAAAAAMMcOHAgJicnh/714osvZmfSAc8999y8f6889dRT2ZkAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0Iitdpqy1Q4AAAAAAAAAAAAAAAAAAAAAAAAAAADASmKrnaZstQMAAAAAAAAAAAAAAAAAAACLVbIDAAAAAAAAYC7r16+PN998c+iZH3/8MV599dVKRXTZ2NhYfPvtt0PPHD16NDZt2lSpCAAAAAAAAAAAAAAAAAAAAAAAAAAAAABujq12FsJWOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAArha12FsJWOwAAAAAAAAAAAAAAAAAAALBYJTsAAAAAAAAA5jI+Ph533XXX0DOHDh2Ka9euVSqiy6ampuLgwYNDz9xxxx0xMTFRqQgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAbo6tdhbCVjsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK4WtdhbCVjsAAAAAAAAAAAAAAAAAAACwWCU7AAAAAAAAAGazd+/eePbZZ4ee+eijj+LDDz+sVMRycPz48XjnnXeGnjlw4EA88cQTlYoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYGFstXMzbLUDAAAAAAAAAAAAAAAAAAAAAAAAAAAAsNzZaudm2GoHAAAAAAAAAAAAAAAAAAAAFqNkBwAAAAAAAMCNer1eHD16dOiZwWAQL730UqUilpPDhw/H1NTU0DNjY2Oxbt26SkUAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0IytdhbDVjsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAy5WtdhbDVjsAAAAAAAAAAAAAAAAAAABws/rZAQAAAAAAXbB3794l/bzBYBD//PNP/P3333Hx4sWYnJyMq1evLul3AKxkTz/9dOzcuXPomffffz9Onz7dasfatWvjnnvuie3bt8/6Z5s3b45ffvklBoNBqx3/tn379ti8eXOjs9PT03HixImWi25Or9eLxx9/vPH5zz//vPE/S3/44Yc4duxYPPPMM3Oe2bp1azz//PMxNjbWuAEAAAAAAAAAAAAAAAAAAAAAAAAAAGAlstUO0C222udmq31+ttoBAAAAAAAAAAAAAAAAAAAAAAAAAACas9UO0C222udmq31+ttoBAAAAAAAAAAAAAAAAAACAm9UbNFyS6PV6bbcAAAAAAKSpMbp74cKF+Oabb+LUqVPx6aefxvHjx2NycrL17wVYbtatWxfff/99bNmyZc4zg8Egdu3aFV9//fWSfu8jjzwS+/btiz179sS2bdtiw4YN8/7e9evX46efforTp0/HiRMn4pNPPokvv/wyZmZmlqzt3yYmJmJ0dLTx+d27d8fJkydbaVmM/fv3xwcffND4/I4dO+LMmTONz997773x3XffRb/fn/PM5cuX47777otLly41/lwAAAAAAAAAAAAAAAAAAABg+VrM1pCtdgAAAABgJbPVDtAdttqHs9XejK12AAAAAAAAAAAAAAAAAAAA4Ea22gEAAAAAZmerHaA7bLUPZ6u9GVvtAAAAAAAAAAAAAAAAAAAAwI2abA2VCh0AAAAAAETEnXfeGY8++mgcPHgw3n777Th//nx89tlnMTo6Grfeemt2HkBnHDp0aOhwe0TEe++9t2TD7Q888EAcO3Ysrly5Eh9//HG88sor8fDDDzcabo+IuOWWW+L++++P/fv3x/j4eHzxxRdx7ty5eO2112Lbtm1L0rgYL7zwQnbCrNruOnv2bLz11ltDz9x+++1x+PDhVjsAAAAAAAAAAAAAAAAAAAAAAAAAAACw1Q7QlK32pWWrfW622gEAAAAAAAAAAAAAAAAAAAAAAAAAAOqw1Q7QjK32pWWrfW622gEAAAAAAAAAAAAAAAAAAIAb9QaDwaDRwV6v7RYAAAAAgDQN/1Npay5fvhzj4+PxxhtvxLVr11JbADKtXbs2zp07Fxs3bhx6bvfu3XHy5MlFfddDDz0Ur7/+ejz22GOL+pxhBoNBvPvuu/Hyyy/H2bNnl+QzJyYmYnR0tPH569evx9atW+PXX39dku9fCjt37oyvvvpqQb+zY8eOOHPmzIJ+Z9euXXHq1KmhZ65evRpbtmyJixcvLuizAQAAAAAAAAAAAAAAAAAAgOVnMVtDttoBAAAAgJXMVjtAN9hqn5+t9uZstQMAAAAAAAAAAAAAAAAAAAD/ZqsdAAAAAGB2ttoBusFW+/xstTdnqx0AAAD4H3t3HqX3fPYP/Jo7kz1BQyQmIZZQj5DaGrEHaaOhVUWF5PmhJSgVxcOjFRWUerRNUDxIIpaHkJSithS1S2OJNbXX3kRiSyKTdeb3R44mkcz9/d733NvMvF7nXKc19/W9Ptd880mcE+e8BwAAAAAAAAAAAAAAYGVpsoYyJdgDAAAAAIAE66yzTpx77rnx+uuvx8CBA8u9DkDZDBs2LDG4ffr06Y0Kbm/dunVceOGF8fjjjxc1uD1i+Q9IPvTQQ+PVV1+N888/PzKZ0v/nudatW8fxxx9f8nOzOemkk0pyzksvvRRPPPFE1p4OHTrEscceW5J9AAAAAAAAAAAAAAAAAAAAAAAAAAAAWJ2sdoDlZLUXnqx2We0AAAAAAAAAAAAAAAAAAAAAAAAAAACVTFY7wHKy2gtPVrusdgAAAAAAAAAAAAAAAAAAACC90qdDAAAAAADQoJ49e8aUKVNi1KhR5V4FoCxOPfXUxJ4//vGPec/fcMMN45lnnon//u//jlatWuU9J1dt2rSJX/3qV/Hwww9HTU1Nyc79ynHHHRdt2rQp+blr8o1vfCOGDRtWsvOuuOKKxJ6f//zn0bp16xJsAwAAAAAAAAAAAAAAAAAAAAAAAAAAQENktQMtnaz24pDVnp2sdgAAAAAAAAAAAAAAAAAAAAAAAAAAgPKT1Q60dLLai0NWe3ay2gEAAAAAAAAAAAAAAAAAAICvZMq9AAAAAAAAq6qqqoqzzz47rr766nKvAlBSgwYNiq222iprzxdffBE333xzXvM33njjeOKJJ6Jv3755PV8Iu+++e0ydOjU23njjkp67/vrrx49//OOSntmQo48+Otq3b1+y8yZPnhyzZ8/O2rPBBhvEkCFDSrQRAAAAAAAAAAAAAAAAAAAAAAAAAAAADZHVDrRUstqLR1a7rHYAAAAAAAAAAAAAAAAAAAAAAAAAAICmQFY70FLJai8eWe2y2gEAAAAAAAAAAAAAAAAAAIB0MuVeAAAAAACANTvmmGPi/PPPL/caACVz4oknJvZMnDgxamtrc5691lprxX333RcbbrhhPqsV1IYbbhgPP/xwbLTRRiU99+STTy7peWuSyWRS/ToX0uLFi+Omm25K7Cv1XgAAAAAAAAAAAAAAAAAAAAAAAAAAADRMVjvQ0shqLy5Z7dnJagcAAAAAAAAAAAAAAAAAAAAAAAAAAKgcstqBlkZWe3HJas9OVjsAAAAAAAAAAAAAAAAAAAAQEZEp9wIAAAAAAE3FwoULU9eyZcsKcuYvf/nLGDhwYEFmAVSyddddN/bdd9/EvltvvTWv+VdccUV885vfzPm5pUuXxttvvx2vvfbaap8tWbIkPv7447z26dWrV9x+++3RunXrvJ7Pxw477BD9+/cv2XlrcsABB5Q8tD4iYtKkSYk9/fr1i969e5dgGwAAAAAAAAAAAAAAAAAAAAAAAAAAgKZHVjtA8chqLz5Z7dnJagcAAAAAAAAAAAAAAAAAAAAAAAAAAGiYrHaA4pHVXnyy2rOT1Q4AAAAAAAAAAAAAAAAAAABERGTKvQAAAAAAQFOwdOnSaN++feqqrq6Odu3axfrrrx/9+vWLo446Kq666qqYOXNmTudWVVXFNddcU9JwX4ByOPTQQ6O6ujprz5w5c+KRRx7Jefbuu+8eQ4cOTd0/d+7cuPTSS2OfffaJTp06xWabbRbnnnvuan2zZs2Kbt26RdeuXePHP/5x3HzzzbF48eLU52y//fZxwQUXpO4vhBEjRpT0vEo5/4knnoiPPvoose/www8vwTYAAAAAAAAAAAAAAAAAAAAAAAAAAABNi6x2gOKS1V4astqzk9UOAAAAAAAAAAAAAAAAAAAAAAAAAACwOlntAMUlq700ZLVnJ6sdAAAAAAAAAAAAAAAAAAAAyJR7AQAAAACA5mrRokUxe/bsePrpp2PChAlx3HHHRU1NTQwaNCiefvrp1HM23njjOOaYY4q4KUD5/ed//mdiz+233x7Lli3LefY555yTqq+uri7+8Ic/RI8ePWLEiBHx0EMPxaJFixKfmzNnTkyaNCkOP/zw6NWrV1xzzTVRX1+f6sxTTz01+vbtm6q3EA4++OCoqakp2Xkr69u3b+y5555lOTsi4rbbbkvsSXMPAQAAAAAAAAAAAAAAAAAAAAAAAAAASCarHSA9We2lIas9O1ntAAAAAAAAAAAAAAAAAAAAAAAAAAAAhSGrHSA9We2lIas9O1ntAAAAAAAAAAAAAAAAAAAAQKbcCwAAAAAAtCT19fUxZcqU6NevX5xyyilRV1eX6rkTTjihyJsBlM8mm2wS/fv3T+ybPHlyzrM33XTT2GuvvRL7lixZEgceeGCceuqpMX/+/JzP+crMmTNj+PDhse+++8bcuXMT+6uqquLcc8/N+7xcVVdXx/HHH1+y81Z20kknleXcr0yaNCmxp3fv3rHjjjuWYBsAAAAAAAAAAAAAAAAAAAAAAAAAAICWR1Y7wOpktctqLwVZ7QAAAAAAAAAAAAAAAAAAAAAAAAAAAOUlqx1gdbLaZbWXgqx2AAAAAAAAAAAAAAAAAAAAII1MuRcAAAAAAGipRo8eHUcddVSq3q222iq22WabIm8EUB777bdfYs+iRYvikUceyXn24MGDo6qqKrHvxBNPjDvvvDPn+Q2ZMmVK7LPPPrFgwYLE3pqammjfvn3Bzk5y7LHHRps2bUp2XkREly5dYujQoSU98+uefPLJ+PLLLxP7Bg8eXIJtAAAAAAAAAAAAAAAAAAAAAAAAAAAAWjZZ7QDLyWqX1V4KstoBAAAAAAAAAAAAAAAAAAAAAAAAAAAqh6x2gOVktctqLwVZ7QAAAAAAAAAAAAAAAAAAAEAamXIvAAAAAADQkl1//fUxefLkVL177713kbcBKI999903seepp56KRYsW5Tx71113Tex57rnn4uqrr855dpJnnnkmjj766AY/f+ihh2LgwIHRr1+/qK2tLfj5DenatWsMGTKkZOdFRBxzzDHRrl27kp75dUuXLo3HHnsssW/QoEEl2AYAAAAAAAAAAAAAAAAAAAAAAAAAAABZ7QCy2mW1l4asdgAAAAAAAAAAAAAAAAAAAAAAAAAAgMoiqx1AVrus9tKQ1Q4AAAAAAAAAAAAAAAAAAACkkSn3AgAAAAAALd3FF1+cqq9fv35F3gSg9Fq3bh0DBgxI7HvwwQfzmv/Nb34zsee6667La3YaN998c9x///3//uf6+vq44447Yqeddop99tkn7++rsUaMGFGyszKZTJxwwgklOy+bNO97p512irXWWqsE2wAAAAAAAAAAAAAAAAAAAAAAAAAAACCrHWjJZLXLai8lWe0AAAAAAAAAAAAAAAAAAAAAAAAAAACVRVY70JLJapfVXkqy2gEAAAAAAAAAAAAAAAAAAIAk1eVeAAAAAACgpZs2bVp88MEH0bNnz6x9m2++eVHOX2eddaJ///6x7bbbxiabbBI1NTXRsWPHaN++fdTV1cWCBQviiy++iHfeeSdee+21mDp1arz88stRX19flH2ak+b2btu1axcDBgyIbbfdNvr06RNdunSJtdZaK6qrq2PhwoUxd+7ceO+99+Lll1+OJ554Il5++eVyr9wsrHyPdt111yZ9h9Zkt912i44dOyb2PfTQQ3nNX3fddRN7pk+fntfstEaNGhUDBw6MiRMnxoUXXhivvPJKUc9LY/vtt49ddtklnnzyyaKfdeCBB8aGG25Y9HPSSHOPWrVqFXvvvXf8+c9/Lv5CAAAAAAAAAAAAAAAAAAAAAAAAAAAALZys9uarub1bWe3lIat9OVnthSWrvWGy2gEAAAAAAAAAAAAAAAAAAAAAAAAAAEpHVnvz1dzeraz28pDVvpys9sKS1d4wWe0AAAAAAAAAAAAAAAAAAADQslWXewEAAAAAACLefPPNxPD2rl27Fuy8zp07xxFHHBFDhgyJXXbZJaqqqnJ6/uOPP44//elPcdVVV8ULL7yQ1w4///nPo2/fvll7FixYECNGjMhrfjbdunWL888/P2vP3Llz49RTT815diW824aMHj06OnXq1ODnZ511VsyaNWu1r2+33XZxxhlnxP77758qZPsr77zzTlx33XXxxz/+MebMmZPXzl+3//77xwEHHJC1Z9q0aXHNNdcU5LwuXbrERRddlNh33HHHxbJlywpyZkTj7lEx71Ax7L333ok9ixYtimnTpuU1v0OHDok9s2fPzmt2Wk899VT06tUrPvzww6Kes7IPP/wwevTokbVnxIgRJQlvT/pzvLa2Ntq1a5fzn5f5mD59esyfPz/rn4URIbwdAAAAAAAAAAAAAAAAAAAAAAAAAACghGS1r5msdlntXyerPZms9lXJam+YrPaGyWoHAAAAAAAAAAAAAAAAAAAAAAAAAAAoHVntayarXVb718lqTyarfVWy2hsmq71hstoBAAAAAAAAAAAAAAAAAACgBatPKSKUUkoppZRSSimllFKq2VaSJUuWFPX8m266KXGH2bNnN/qcjh071l9wwQX1X3zxRdq/Hk5077331m+55ZY573LMMcekmt+vX7+Cv+8RI0YknnvVVVc12XfbUM2ePTvreVtsscUq/V27dq2fNGlSo7+PefPm1Z9xxhn1rVq1avT3cPbZZyeed/PNNxfsnW200Uapvsc2bdoU5LxC36NC36Fi1N133534fTz33HN5z581a1bi/D59+iTOOfzww1d77v333y/LO7vyyisTv6eLLrqofu7cuVl7lixZUt+jR4+i7vqtb30rcderrrqqfsmSJYl9W221VUF2euKJJxLPevzxx8v+e0MppZRSSimllFJKKaWUUkoppZRSSimllFJKKaWUUkoppZRSSimllFKFr8Yo9+5KKaWUUkoppZRSSilVzEoiq71hstor7902VLLacy9Z7cUvWe25l6z2xpWsdqWUUkoppZRSSimllFJKKaWUUkoppZRSSimllFJKKaWUUkoppZRSquVWY5R7d6WUUkoppZRSSimllCpmJZHV3jBZ7ZX3bhsqWe25l6z24pes9txLVnvjSla7UkoppZRSSimllFJKKaWUUkoppZRSSimllFJKKaWUUkoppZRSSinVciuNTAAAAAAAUHaLFi1K7Kmurm7UGd/97nfj9ddfjzPPPDPWWmutRs1a2b777hsvvvhi/PKXv8zpuYkTJ8aCBQsS+4YOHZrvao2aOW7cuNTzKu3dFsKAAQNixowZcfDBBzd6VqdOneK3v/1tPPzww9GtW7cCbNc8FeMelfMOpbX99tsn9rzwwgt5z//ss88Se7p27Zr3/Er1xRdfxLXXXpu1p7q6On72s58VdY8RI0Yk9lx66aVF3eHr0tynb33rW1FVVVWCbQAAAAAAAAAAAAAAAAAAAAAAAAAAAJDV3jBZ7bLaWwpZ7Q2T1Z47We0Nk9UOAAAAAAAAAAAAAAAAAAAAAAAAAABQWWS1N0xWu6z2lkJWe8NktedOVnvDZLUDAAAAAAAAAAAAAAAAAAAA2WTKvQAAAAAAAJEqILa+vj7v+SNHjoz77rsvampq8p6RTevWreM3v/lN/PnPf462bdumembevHkxadKkxL5DDz00MpnC/XV2796949vf/nbWnhkzZsS0adNSzavEd9tYP/rRj+L++++P9dZbr6Bzd9ttt3j88cejZ8+eBZ3bHBTzHpXjDqXVvXv36N69e2Lf888/n/cZc+bMSezZYYcd8p5fyS699NLEf3cMHz68aPdi3XXXjcMOOyxrz0MPPRSvvPJKUc5vyPTp0xN7OnXqFJtvvnkJtgEAAAAAAAAAAAAAAAAAAAAAAAAAAEBWe8NktctqbwlktWcnqz0/strXTFY7AAAAAAAAAAAAAAAAAAAAAAAAAABAZZHV3jBZ7bLaWwJZ7dnJas+PrPY1k9UOAAAAAAAAAAAAAAAAAAAAZFO4tBsAAAAAAPK29tprJ/bMnTs3r9mXXnppnHvuuakC4hvrgAMOiL/85S/Rpk2bVP1jx45N7OnWrVvss88+jV3t3w4//PDEnjR7RVT2u83XbrvtFjfffHPRzundu3fce++90alTp6LMb4pKdY9KdYdysf3226fqe+GFF/I+Y9asWYk9SQHjTdVbb70V99xzT9ae9dZbr2jf//Dhw6Ndu3ZZe8aMGVOUs7NJe5/S3k8AAAAAAAAAAAAAAAAAAAAAAAAAAAAaR1Z7w2S1LyervfmS1Z5MVnt+ZLWvmax2AAAAAAAAAAAAAAAAAAAAAAAAAACAyiKrvWGy2peT1d58yWpPJqs9P7La10xWOwAAAAAAAAAAAAAAAAAAAJBNptwLAAAAAAAQscEGGyT2fPbZZznPHTlyZPz85z/PZ6W8DRw4MMaNG5eq9/HHH4/XX389sW/o0KGNXSv1rCVLlsSNN96YOKfS320+unbtGrfddlvRw7233nrruPTSS4t6RlNR6ntU7DuUqy222CJVX5o/JxryxBNPJPbssMMOqX6wQ1N0ySWXJPaMGDGi4Oe2atUqTjjhhKw9//znP+Mvf/lLwc9OkvY+bb755kXeBAAAAAAAAAAAAAAAAAAAAAAAAAAAgAhZ7UlktS8nq735kdUuq73YZLWvTlY7AAAAAAAAAAAAAAAAAAAAAAAAAABAZZHVnp2s9uVktTc/stpltRebrPbVyWoHAAAAAAAAAAAAAAAAAAAAssmUewEAAAAAgJauffv2sfXWWyf2zZo1K6e5+++/f4waNSrnff75z3/G1KlT4957742//vWv8dxzz8WcOXNymjFs2LA4+uijU/WmCZL+0Y9+FO3atctphzXZfvvtE8Oi77rrrpg9e3bWnqbybnM1ZsyY6Nq1a1Fmf91RRx0Vu+++e0nOqlT53KNKv0O56tWrV2LPsmXLYubMmXmf8eCDD6bqGzt2bOy99955n1Op/vrXv8Y//vGPrD3bbrtt7LbbbgU990c/+lH06NEja8+ll14a9fX1BT03jc8//zy+/PLLxL6NNtqoBNsAAAAAAAAAAAAAAAAAAAAAAAAAAAC0bLLaZbXnQlZ78yGrXVZ7KchqX52sdgAAAAAAAAAAAAAAAAAAAAAAAAAAgMohq11Wey5ktTcfstpltZeCrPbVyWoHAAAAAAAAAAAAAAAAAAAAssmUewEAAAAAgJbu+9//fnTs2DGx75lnnkk9s0uXLjF27NioqqpK1f/yyy/HkUceGd27d49NN900dt555xg8eHB897vfjR122CG6du0affr0ibPPPjs+/fTTVDP/8Ic/RE1NTWLf9ddfH0uXLs3a07lz59hvv/1SnZvN0KFDE3uSwuSb0rvN1Y477tjgZ7W1tXHLLbfET37yk+jXr19sttlm0bt37+jfv38ccsgh8b//+785B2yff/75jV25ycr3HlX6HcpVmnDsjz76KOrq6vI+44UXXoj3338/sa99+/YxZcqUuPjii6NLly55n1eJLr300sSeESNGFPTMpHnz58+P8ePHF/TMXHzwwQeJPcLbAQAAAAAAAAAAAAAAAAAAAAAAAAAAik9Wu6z2SsnZltVeOrLal5PVXhqy2lcnqx0AAAAAAAAAAAAAAAAAAAAAAAAAAKAyyGqX1V4pOduy2ktHVvtystpLQ1b76mS1AwAAAAAAAAAAAAAAAAAAAA3JlHsBAAAAAICWrH379vGb3/wmVe9TTz2Veu6vf/3r6NatW2LfokWLYvjw4dG3b9+47rrrYtasWQ32zpgxI84777zo1atX3HTTTYmzO3fuHOecc05i38yZM+Pee+9N7Bs2bFhiTzZVVVUxZMiQrD0fffRR3HfffVl7mtK7LYRly5bF6NGjY6ONNoohQ4bEtddeG08//XS8/fbb8dZbb8Xf//73mDx5chx//PGx6aabxtlnnx3Lli1LNXuPPfaIPn36FPk7qEz53qOGVPIdyiZNOHaakO0kF110Uaq+Vq1axWmnnRbvv/9+TJo0KY444ojYZpttonXr1o3eoZyuv/76+Pzzz7P2HHjggdGzZ8+CnLfddtvFrrvumrXnuuuui7lz5xbkvHwIbwcAAAAAAAAAAAAAAAAAAAAAAAAAACg/We2y2iMqO2dbVntxyGpfTlZ7achqX52sdgAAAAAAAAAAAAAAAAAAAAAAAAAAgPKT1S6rPaKyc7ZltReHrPblZLWXhqz21clqBwAAAAAAAAAAAAAAAAAAABqSKfcCAAAAAAAtVevWrWP8+PHRu3fvxN758+fHI488kmpuz54947jjjks1c8CAAXHNNddEfX19qtlfPTd06NC4+OKLE3uPOuqoqKmpSewbO3ZsYs/gwYNj7bXXTrXjmgwYMCBxl+uuuy7q6uoa/LwpvtvG+Pzzz2PvvfeOU045JebMmZPYX1tbG+edd14ccsghsWTJklRnNDaUvykq5j2qtDuUJE1Y+Icfftjoc8aOHRv/+te/Uvd36NAhDj744JgwYUK8+OKLsXDhwrjyyitX66uuro527do1er9iW7BgQYwfPz5rT6tWreJnP/tZQc476aSTsn5eX18fl112WUHOylea8PYePXqUYBMAAAAAAAAAAAAAAAAAAAAAAAAAAICWSVb7CrLaVzxXSTnbstqLQ1b7CrLaS0NW++pktQMAAAAAAAAAAAAAAAAAAAAAAAAAAJSXrPYVZLWveK6ScrZltReHrPYVZLWXhqz21clqBwAAAAAAAAAAAAAAAAAAABqSKfcCAAAAAAAt0aabbhoPPPBADBkyJFX/TTfdFPPnz0/VO3z48GjTpk1i35FHHhlTp05NNXNNzjjjjHjwwQez9lRXV8fRRx+dOOvuu++OmTNnZu1p06ZNHHTQQTntuLKhQ4cm9owbNy7r503x3eartrY2Bg4cGI8++mjOz95+++1x/vnnp+rdd999c57f1JXiHlXCHUqjU6dOiT1z585t9DmLFi2KI444IusPZ8gmk8nEWmuttdrXu3fvHgsWLIh33nkn7rvvvvj9738fw4YNi6233jpatWrV2LUL6rLLLkv8/ocPH97oMPr11lsvDjvssKw9U6ZMiddee61R5zTWvHnzEnvS3E8AAAAAAAAAAAAAAAAAAAAAAAAAAAByJ6t9VbLaV1UJOduy2otHVvsKstpLR1b7qmS1AwAAAAAAAAAAAAAAAAAAAAAAAAAAlI+s9lXJal9VJeRsy2ovHlntK8hqLx1Z7auS1Q4AAAAAAAAAAAAAAAAAAAA0JFPuBQAAAAAAWoqqqqrYbbfdYuzYsfHaa6/FHnvskeq5ZcuWxWWXXZb6nJ/85CeJPRMnTow//elPqWeuSX19fZx00kmJfUkhvhHLv8frr78+sS9NAPuapAl+f/TRR+Ott97K2tMU322+TjzxxHj22Wfzfv7CCy+Md999N7Gvb9++0aFDh7zPaYpKcY8q4Q6lkebXvra2tiBn/fWvf42RI0cWZNbKqqqqolevXjFo0KA45ZRT4oYbboiXXnop5s+fH3fccUcMGTKkIu74O++8E3fddVfWnnXXXbfRd2L48OHRtm3brD1jxoxp1BmFkOZeVVVVJX4vAAAAAAAAAAAAAAAAAAAAAAAAAAAApCOrvWGy2ldVCTnbstqLR1b7CrLaS0dW+6pktQMAAAAAAAAAAAAAAAAAAAAAAAAAAJSWrPaGyWpfVSXkbMtqLx5Z7SvIai8dWe2rktUOAAAAAAAAAAAAAAAAAAAANKS63AsAAAAAADQFmUwmBg8enLq/devW0blz5+jcuXNsuumm0adPn9hxxx2ja9euOZ992WWXxcsvv5yqd4cddogePXpk7amrq4tzzjkn5z3WZMaMGTFlypT47ne/22DPlltuGZtsskn885//zDpr7Nixcfrpp2ftGTBgQNTU1MRHH32U056DBw+OddZZJ/H8bJryu83VE088EePHj2/UjCVLlsT48eNj1KhRWfsymUxsvfXWMW3atEad11SU8h6V8w6l0aZNm8hkMol9hQpvj4i44IILorq6OvFeFkK7du3iBz/4QfzgBz+IBQsWxDXXXBOjRo2Kzz77rOhnN+SSSy6JAw44IGvPySefHNdee21e81u1ahUnnHBC1p7XX3897rvvvrzmF9KCBQtS9XXo0CEWLVpU5G0AAAAAAAAAAAAAAAAAAAAAAAAAAAAqm6z2NZPVvqpKfbe5ktVePLLaV5DVXnqy2leQ1Q4AAAAAAAAAAAAAAAAAAAAAAAAAAJCerPY1k9W+qkp9t7mS1V48stpXkNVeerLaV5DVDgAAAAAAAAAAAAAAAAAAADSkutwLAAAAAAA0BZlMJu6+++6Sn/v222/HWWedlbp/3333Tex5+OGH47XXXmvMWqv4y1/+kjUcOiJi1113TQyHfuONN+Lxxx+P3XbbrcGeTCYThx56aIwePTqnHYcOHZr187lz58bkyZOz9jTld5urCy+8sCBzbr311lQh2b169Wox4e2lvkflukNpdOjQIVVf2pDttM4999x49dVXY/z48dGxY8eCzm5Ihw4dYsSIEXHEEUfEqFGjYsyYMSU59+v+9re/xcsvvxxbb711gz19+/aN3XffPR577LGc5x900EFRU1OTtefSSy/NeW4xfPnll6n6OnToUNbAfQAAAAAAAAAAAAAAAAAAAAAAAAAAgEogq71hstpXqNR3mytZ7cUjq30FWe2lJ6t9BVntAAAAAAAAAAAAAAAAAAAAAAAAAAAA6clqb5is9hUq9d3mSlZ78chqX0FWe+nJal9BVjsAAAAAAAAAAAAAAAAAAADQkEy5FwAAAAAAYM3mzJkTgwYNSh0wGxHRr1+/xJ477rijMWut5oknnkjs2XHHHVPNGjt2bGJPUhD713Xu3Dn233//rD0TJ06M2trarD1N/d2m9cknn8Q999xTkFmvvvpqzJs3L7EvKey5OSn1PSrHHUqrTZs2qfoWL15c8LNvvfXW6N27d1xzzTWxbNmygs9vyDrrrBOjR4+OW265Jdq2bVuyc1eWJjx9xIgRec1Oem7u3Llx3XXX5TW70NLeq3L9OgEAAAAAAAAAAAAAAAAAAAAAAAAAALR0strXTFb7qmS1Ny2y2leQ1S6rvZxktQMAAAAAAAAAAAAAAAAAAAAAAAAAAFQ2We1rJqt9VbLamxZZ7SvIapfVXk6y2gEAAAAAAAAAAAAAAAAAAICGZMq9AAAAAAAAq/v4449j3333jTfffDOn57bddtvEngcffDDPrdbsnXfeSezp3bt3qlmTJk1KDPveYYcdYosttkg1LyLiwAMPjHbt2mXtGTduXOKcpv5u03rwwQejvr6+YPNeeeWVxJ5OnToV7LxKV+p7VI47VGiFvI8rmzlzZgwfPjz69OkTF198cbz33ntFOWdNfvzjH8ff/va3stz9G2+8MT799NOsPT/84Q9jww03zGnuDjvsELvsskvWnvHjx8f8+fNzmlssxbpXAAAAAAAAAAAAAAAAAAAAAAAAAAAANJ6s9obJal+VrPamRVZ77mS1F5as9uVktQMAAAAAAAAAAAAAAAAAAAAAAAAAAFQuWe0Nk9W+KlntTYus9tzJai8sWe3LyWoHAAAAAAAAAAAAAAAAAAAAGpIp9wIAAAAAAKzq2WefjR122CGeffbZnJ5r1apV9OzZM2tPXV1dvPHGG41ZbzWff/55Yghu2hDgBQsWxMSJExP7hg4dmmpeRMSwYcOyfj5jxoyYNm1a1p7m8G7Tev755ws6LykkOiKiQ4cOBT2zUpXjHpXjDjU1r732Wpx++unRq1ev2HnnneO///u/49Zbb40333yzqAHfO++8c1xzzTVFm9+Q2traGDt2bNaeVq1axQknnJDT3JNOOinr53V1dXHZZZflNBMAAAAAAAAAAAAAAAAAAAAAAAAAAICWR1a7rPavyGpvXmS1VyZZ7auT1Q4AAAAAAAAAAAAAAAAAAAAAAAAAAEC5yGqX1f4VWe3Ni6z2yiSrfXWy2gEAAAAAAAAAAAAAAAAAAICWrLrcCwAAAAAAsNy8efPiN7/5TYwePToWL16c8/M1NTWRyWSy9vzrX/9KDI/Ox8KFC6N9+/YNft6lS5fUs8aOHRvHHHNM1p7DDz88fv3rXyfOWn/99WPvvfdOPC9Jc3m3abz11lsFnffFF18k9iS92+aiXPeo1HeoKZs6dWpMnTr13//csWPH2GKLLWLLLbeMAw88MA455JCCnjdkyJB4+OGH46qrriro3CR//OMf49RTT41WrVo12HPMMcfEOeecEwsXLkyct/7668eQIUOy9txzzz3x9ttv57wrAAAAAAAAAAAAAAAAAAAAAAAAAAAALYOs9uVkta9KVnvzIau98slqX0FWOwAAAAAAAAAAAAAAAAAAAAAAAAAAAKUkq305We2rktXefMhqr3yy2leQ1Q4AAAAAAAAAAAAAAAAAAAC0VNXlXgAAAAAAoKWbM2dOTJgwIX73u9/FrFmz8p6TJoC5R48eBQ/nTiNbcPTXTZs2LV555ZXo06dPgz29e/eOHXfcMZ555pmssw499NCs4cRLliyJG264IXGn5vJu0/j8888LOm/RokUFndeUVeo9KvQdSqu+vj5VXznD/b/88suYPn16TJ8+PaqqqlYLb//kk0/i5z//efTu3Tu23Xbb6N+/f9TU1OR0xkUXXRQ33XRTzJs3r5CrZ/X+++/HHXfcET/60Y8a7OnSpUsMHTo0xo0blzhv+PDh0aZNm6w9Y8aMyXXNokp7r+rq6oq8CQAAAAAAAAAAAAAAAAAAAAAAAAAAQMsmq31VstpzI6u96ajUeySrvWGy2mW1y2oHAAAAAAAAAAAAAAAAAAAAAAAAAAAoLlntq5LVnhtZ7U1Hpd4jWe0Nk9Uuq11WOwAAAAAAAAAAAAAAAAAAALQ85Uu7AAAAAAAgLr/88ujRo0f813/9V6OC2yMi2rVrV6CtCq9t27Y59Y8dOzaxZ+jQoYk9w4YNy/r5XXfdFXPmzEmc05zebZIFCxYUdB4rVOo9KvQdSivtXUsKBS+n2trauPnmm+O8886Lgw46KHr06BG77rpr3HLLLanD6ddee+047rjjirzp6tKEqZ988smJPdXV1fGzn/0sa8+MGTPiwQcfTLlZaaS9V/5MBAAAAAAAAAAAAAAAAAAAAAAAAAAAKB5Z7Wsmqz09We1NR6XeI1nt+ZPVLqsdAAAAAAAAAAAAAAAAAAAAAAAAAACA/MlqXzNZ7enJam86KvUeyWrPn6x2We0AAAAAAAAAAAAAAAAAAABA85Mp9wIAAAAAAE3Fm2++mbree++9VDMHDRqUOuA3SbkCmIvhhhtuiMWLF2ftGTJkSGQyDf8192abbRb9+vXLOiNNSHxE83q3Serq6sq9QrPVku5RGrW1tan6mtp7e/LJJ2PIkCGx++67x8cff5zqmVNOOSWqqqqKvNmqHnvssXjhhRey9my99dax5557Zu05+OCDY4MNNsjac8kll+S8X7GlvVfC2wEAAAAAAAAAAAAAAAAAAAAAAAAAAJaT1V46strLR1Z78bSke5SGrPYVZLWXnqx2AAAAAAAAAAAAAAAAAAAAAAAAAACA3MhqLx1Z7eUjq714WtI9SkNW+wqy2ktPVjsAAAAAAAAAAAAAAAAAAADQkIZTbQAAAAAA+LelS5fG5ptvnro22WSTmDFjRuLc3r17x4knnliC76Bp+eSTT+LOO+/M2tO9e/fYa6+9Gvz8sMMOy/r8Rx99FPfff39e+wGNV1dXl/hDGiIi2rdvX4JtCu+JJ56InXfeOT799NPE3u7du0ffvn1LsNWq0oSqjxgxolGff/bZZ3HDDTfktFcpdOjQIVVf2h8yAAAAAAAAAAAAAAAAAAAAAAAAAAAA0JzJai8tWe3Q/MlqX0FWe+nJagcAAAAAAAAAAAAAAAAAAAAAAAAAAEhPVntpyWqH5k9W+wqy2ktPVjsAAAAAAAAAAAAAAAAAAADQkEy5FwAAAAAAaI7q6uritNNOS9V79tlnR5cuXYq8UdMzduzYxJ6hQ4fm9VlExIQJE6Kuri7nvYDCWbBgQWJPU/7z8e23345jjjkmVe+AAQOKu8wa3HTTTTFnzpysPQcccED06tVrjZ99+9vfjv79+2d9fuzYsRUZgJ7mXi1ZsiSWLVtWgm0AAAAAAAAAAAAAAAAAAAAAAAAAAACaF1ntjSerHZo/We0ryGovLVntAAAAAAAAAAAAAAAAAAAAAAAAAAAAxSOrvfFktUPzJ6t9BVntpSWrHQAAAAAAAAAAAAAAAAAAAGhIptwLAAAAAAA0V/fee2888MADiX3rrLNOjBo1qtHnNbeA2SlTpsT777+fteeggw6Ktm3brvb17bbbLrbccsusz44fPz71Ls3t3ZJeVVVVwWa5R6tLCg6PiFh33XVLsEnx3HbbbTF9+vTEvt12260E26xq0aJFcfXVV2ftyWQyccIJJ6zxs5NOOinrs8uWLYvLL7887/2KKc29+uSTT0qwCQAAAAAAAAAAAAAAAAAAAAAAAAAAQPMkq71xZLVTCWS1F5es9hVktZeWrHYAAAAAAAAAAAAAAAAAAAAAAAAAAIDiktXeOLLaqQSy2otLVvsKstpLS1Y7AAAAAAAAAAAAAAAAAAAA0JDqci8AAAAAANCcnXrqqTF9+vTIZDJZ+4477ri4/PLL49VXX837rIULFyb2vPLKK4lhu8WQT2h1fX19TJgwIUaOHNlgz1prrRX77bdf3Hbbbat8fejQoVlnP/roo/HWW2+l3qW5vVvSW9MPB8hXpd6jct6h9957L3r37p21Z/311y/RNsVzyy23xHbbbZe1p3v37iXaZlVXXHFFnH766VFd3fB/Njz66KPj17/+ddTW1v77a926dYsf//jHWWffeeed8e677xZs10Lq2rVrYs97771Xgk0AAAAAAAAAAAAAAAAAAAAAAAAAAACaL1nty8lqLx5Z7cUlq724ZLWvIKu9tGS1AwAAAAAAAAAAAAAAAAAAAAAAAAAAFJ+s9uVktRePrPbiktVeXLLaV5DVXlqy2gEAAAAAAAAAAAAAAAAAAICGNJzCAAAAAABAo7344otx3XXXxVFHHZW1r7q6On7/+9/Hfvvtl/dZCxYsSOxp3bp1PPTQQ3mfUWrjx4+Ps846K6qqqhrsGTp06Crh7VVVVTFkyJCsc8eOHZvTHs3x3TZnrVq1Ktiszp07F2yWe7S6NOHYG220UQk2Ka6pU6cm9qy77rol2GR1H374Ydx2221Zg9i/8Y1vxLBhw+Kaa67599eOPfbYaNOmTdbZY8aMKdSaBderV6/EHuHtAAAAAAAAAAAAAAAAAAAAAAAAAAAAjSOrvXFktZMPWe1Nh6z2FWS1l5asdgAAAAAAAAAAAAAAAAAAAAAAAAAAgOKT1d44strJh6z2pkNW+wqy2ktLVjsAAAAAAAAAAAAAAAAAAADQkEy5FwAAAAAAaO5+9atfpQptHjx4cHznO9/J+5yZM2cm9mywwQZ5zy+Hd955J/72t79l7dlvv/1irbXW+vc/77HHHtGjR48G++fOnRuTJ0/OaY/m+G6bs06dOhVsVs+ePQs2yz1aXZpw7PXWWy86duxYgm2KZ9asWYk96623Xgk2WbNLLrkksWfEiBH//v+tW7eO448/Pmv/iy++GI8++mijdyuGVq1apfq9LbwdAAAAAAAAAAAAAAAAAAAAAAAAAACg8WS1509WO/mQ1d50yGpfQVZ76chqBwAAAAAAAAAAAAAAAAAAAAAAAAAAKB1Z7fmT1U4+ZLU3HbLaV5DVXjqy2gEAAAAAAAAAAAAAAAAAAIBsMuVeAAAAAACgufvXv/4Vv/vd71L1jh49OjKZ/P7q9rPPPova2tqsPZ07d471118/r/nlMnbs2Kyft23bNg466KB///OwYcOy9k+cODHxPX1dc323TdHixYsTe1YO82+sLbfcsmCz3KPVvfPOO6n6Ntlkk4Keu9NOO8XAgQMLOjObNH/mtG7dugSbrNmTTz4Zzz77bNaePn36xF577RUREYccckh07949a/+YMWMKtV7BbbjhhtGqVavEvnfffbcE2wAAAAAAAAAAAAAAAAAAAAAAAAAAADRvstobR1Y7K5PV3rzIal9BVnvpyGoHAAAAAAAAAAAAAAAAAAAAAAAAAAAoHVntjSOrnZXJam9eZLWvIKu9dGS1AwAAAAAAAAAAAAAAAAAAANnklwAEAAAAAEBOLrroopg5c2ZiX58+feLoo4/O+5x//OMfiT277bZb3vPL4bbbbovPPvssa8/QoUMjYnn48cEHH5y1d9y4cXnt0RzfbVO0cOHCxJ5NN920YOd9FVZdKO7Rql588cVUff/xH/9RkPN22GGHuPvuu2Pq1Knx+9//viAz01h77bUTe9Lc7WK65JJLEntGjBixyv82ZM6cOXHTTTcVZK9i2GqrrVL1pb2fAAAAAAAAAAAAAAAAAAAAAAAAAAAAZCerPX+y2lmZrPbmRVb7CrLaS0dWOwAAAAAAAAAAAAAAAAAAAAAAAAAAQGnJas+frHZWJqu9eZHVvoKs9tKR1Q4AAAAAAAAAAAAAAAAAAABkkyn3AgAAAAAALcGCBQvirLPOStV7/vnnR+fOnfM65/nnn0/sGTBgQF6zy2XRokWJIcB77bVXdO/ePb73ve/FOuus02DfjBkzYtq0aXnt0RzfbVM0e/bsxJ4NNtgg1ltvvUaftfbaa8eee+7Z6Dkrc49W9dJLL8WSJUsS+7bZZptGnfOtb30r7rjjjnjmmWdi8ODBERHRt2/f+N73vteouWnV1NQk9sydO7cEmzTslltuiY8//jhrz/e///0YMmRI9OvXL2vf1VdfHYsWLSrkegW19dZbp+pL8/sVAAAAAAAAAAAAAAAAAAAAAAAAAACAZLLa8yernZXJam9eZLWvIKu9dGS1AwAAAAAAAAAAAAAAAAAAAAAAAAAAlJas9vzJamdlstqbF1ntK8hqLx1Z7QAAAAAAAAAAAAAAAAAAAEA2mXIvAAAAAADQUlx77bXx0ksvJfZ17do1ddD71z322GOJPYcddli0bds2r/nlMnbs2KyfZzKZOPTQQ2Po0KGNmpNNc323Tc0HH3yQqm/vvfdu9FlHH310tGvXrtFzVuYerWrx4sUxY8aMxL6+ffvmNb9Pnz4xefLkmD59evzgBz9Y7fPLLrusJO964MCBiT3vvPNO0ffIZvHixXHVVVdl7clkMjFhwoSsPUuXLo0rrriigJsVXpr79M9//jM+//zz4i8DAAAAAAAAAAAAAAAAAAAAAAAAAADQQshqz5+sdr4iq715kdW+gqz20pHVDgAAAAAAAAAAAAAAAAAAAAAAAAAAUHqy2vMnq52vyGpvXmS1ryCrvXRktQMAAAAAAAAAAAAAAAAAAADZZMq9AAAAAABAS1FXVxennXZaqt4RI0bEJptskvMZ9913X2LPeuutF4cddljOs7PZZJNNolevXgWdubLnn38+pk+fnrXnmGOOie9///sNfr5kyZK44YYb8t6hub7bpiZN0HdEJAb5J+nSpUuceeaZjZqxJuW4R5V+h5599tnEnm9/+9s5zx08eHC89NJLcdBBB0VVVdUaezbbbLO4/PLLc56diw4dOqT69XzllVeKukcaV1xxRSxZsiRrT1LY/W233RYffvhhIdcquDT36bnnnivBJgAAAAAAAAAAAAAAAAAAAAAAAAAAAC2HrPb8yWqv3JztUpPVnrtKv0Oy2peT1V46stoBAAAAAAAAAAAAAAAAAAAAAAAAAABKT1Z7/mS1V27OdqnJas9dpd8hWe3LyWovHVntAAAAAAAAAAAAAAAAAAAAQDaZci8AAAAAANCSTJkyJe6///7EvrZt28ZFF12U8/yZM2fGY489lth34YUXxnrrrZfz/DVp1apV3HTTTfHyyy/HiSee2GBIcmONHTs26+d9+vSJ9u3bN/j5XXfdFXPmzMn7/Ob8bpuS2bNnx0cffZTYt//++8d2222X9zlXXXVVrLvuunk/35BS36OmcIemTp2a2FNTUxM9e/bMae7f/va3+PTTTxP7fvrTn8ZZZ52V0+xcjBo1KmpqahL7Hn744aLtkNbMmTNj0qRJjZoxZsyYwixTJN/4xjdiiy22SOz7+9//XoJtAAAAAAAAAAAAAAAAAAAAAAAAAAAAWhZZ7fmT1V6ZOdulJqs9N03hDslqX05We2nIagcAAAAAAAAAAAAAAAAAAAAAAAAAACgfWe35k9VemTnbpSarPTdN4Q7Jal9OVntpyGoHAAAAAAAAAAAAAAAAAAAAkmTKvQAAAAAAQEtz2mmnxbJlyxL7DjnkkNh1111znn/NNdck9nTv3j2uv/76qK6uznn+yqqqqmLcuHHRv3//6NSpU1x22WXx2GOPxTe/+c1GzV2T//u//4uFCxfm/XxS+HsazfXdNjUPPPBAYk8mk4mrr746a6B/Qy666KI4+OCD81ktlVLdo6Zyh/7617+m6tt5551zmltbWxuXX355qt7zzjsvrrrqqmjbtm1OZyQ57bTT4rTTTkvsmzdvXkyZMqWgZ+frkksuyfvZZ599Np566qkCblN4O+20U6q+tPcSAAAAAAAAAAAAAAAAAAAAAAAAAACA3Mhqz4+s9srM2S4HWe3pNJU7JKtdVnspyWoHAAAAAAAAAAAAAAAAAAAAAAAAAAAoL1nt+ZHVXpk52+Ugqz2dpnKHZLXLai8lWe0AAAAAAAAAAAAAAAAAAABAkky5FwAAAAAAaGlefvnluPbaa1P1jhkzJuf5EydOjHfffTex73vf+17cd999sdZaa+V8RkTEN77xjbj99tvjiCOOWOXru+66a7zwwgtx5plnRqtWrfKavSZffPFF3HbbbXk9+9FHH8X999/f6B2a67ttav785z+n6ttxxx3jL3/5S6yzzjqp+tdZZ52YOHFinH766fkvl0Ip7lFTukPvvPNOvPHGG4l9AwYMyHn26NGjY+bMmal6hw8fHq+88kr84Ac/yPmcr9tiiy3i7rvvjosvvjhV/w033NCoH05RSNOmTYu///3veT2bz7+zSm2vvfZK7Jk9e3Y8//zzxV8GAAAAAAAAAAAAAAAAAAAAAAAAAACgBZLVnh9Z7ZWZs10OstqTNaU7JKtdVnspyWoHAAAAAAAAAAAAAAAAAAAAAAAAAAAoL1nt+ZHVXpk52+Ugqz1ZU7pDstpltZeSrHYAAAAAAAAAAAAAAAAAAAAgSabcCwAAAAAAtEQjR46ML7/8MrFvxx13jGHDhuU0e8mSJXH22Wen6t1nn33itddei+OPPz7atGmT6pm11lorTj755HjttdfigAMOWGNP27Zt44ILLohnnnkm/uM//iP17knGjh2b13MTJkyIurq6Rp/fnN9tU3LXXXfFxx9/nKp37733jjfeeCN+8YtfxIYbbrjGns022yxGjRoVb7/9dhx66KGFXHWNinmPmuodmjJlSmLPd77znZznfv755zF8+PDU/Ztttlnccccd8dZbb8XIkSNjl112ierq6lTP9u7dO4499ti477774tVXX43Bgwenem7hwoVx4YUXpt6xFC655JKcn5k1a1bccsstRdimsNLcowceeKAEmwAAAAAAAAAAAAAAAAAAAAAAAAAAALRcstrzI6u9MnO2S01We8Oa6h2S1S6rvVRktQMAAAAAAAAAAAAAAAAAAAAAAAAAAJSfrPb8yGqvzJztUpPV3rCmeodktctqLxVZ7QAAAAAAAAAAAAAAAAAAAECSqvr6+vpUjVVVxd4FAAAAAKBskv6qdOnSpdG6deuCnjly5Mg499xzE/s+/PDD2HzzzaO2tjan+VOmTMkp7PjLL7+Mhx9+OKZNmxYff/xxfPLJJ1FXVxft27ePtddeOzbbbLPYfvvtY5dddkn9LubNmxfbbLNNvPvuuzntns1bb70Vm266aU7P9O7dO956662C7dBU3+3s2bNjvfXWy9qz6667xpNPPpl6ZpJrr702jjzyyKw9v/3tb+PMM8/Mae5//dd/xf/8z//kvM8HH3wQs2bNis8//zw6deoUG2+8cXTr1i3rM7W1tdG+ffusPW3bto3FixfntEs+9+h//ud/Kvr3Z77233//uOuuuxL7Nt5447z2nTBhQhxxxBH5rBZLly6NDz74IJYsWRKbb775Kp8tWrQoXn/99ejdu3fiHWnIqaeeGn/4wx9yeubKK6+M4447LmvPr371q7jgggvy2qm6ujree++92GCDDVI/M2rUqDjnnHPyOi9i+Q81SArK79OnT8yYMSPvM9Zdd92YPbb0AocAAL/kSURBVHt24n/3POqoo2LChAl5nwMAAAAAAAAAAAAAAAAAAABUrpSx7Gskqx0AAAAAaM5ktVdOnngSWe3LyWqX1V6Jvz/zJatdVrusdgAAAAAAAAAAAAAAAAAAAKAUZLUDAAAAAKyZrPbKyRNPIqt9OVntstor8fdnvmS1y2qX1Q4AAAAAAAAAAAAAAAAAAACUQpqs9uwJCAAAAAAAFM3vfve7OO6446KmpiZrX48ePeK0006L8847L6f5RxxxRDzzzDOJ87/SsWPH2G+//WK//fbL6ZxsTjjhhIIHQ48fPz7OP//81P2PPPJIQYPbI5rvu21K/vjHP8axxx4bm222WU7P9ezZM3r27JnTM2effXZcfPHFOT2TRj73aNSoUQU7v5Lu0AMPPBDz5s2Lzp07Z+0bPHhwXHnllTnPP+aYY6J79+4xaNCgnJ+trq6OjTfeeI2ftW3bNrbZZpucZ37ljjvuiNGjR+f9fLEsXbo0rrzyylQ/YCRiefB6Pr8upfa9730vMbh96dKlqX6QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI0jqz0/stqXq6Sc7XKQ1d54lXSHZLVXFlntstoBAAAAAAAAAAAAAAAAAAAAAAAAAACKTVZ7fmS1L1dJOdvlIKu98SrpDslqryyy2mW1AwAAAAAAAAAAAAAAAAAAQEuWKfcCAAAAAAAtVW1tbfzqV79K1XvGGWfEBhtskNP8f/3rX7H//vvH3Llz81mv0X75y1/GDTfcUPC5EyZMiLq6utT948aNK/gOzfXdNiW1tbVx5JFHxtKlS4t6zo033hiTJk0qyuxy3qNKu0MLFy6M2267LbHvoIMOymv+kiVL4oc//GE88sgjeT1fDA8++GAcdthhUV9fX+5V1uiqq66KxYsXp+q99dZbY9asWUXeqPHS3J/7778/PvnkkxJsAwAAAAAAAAAAAAAAAAAAAAAAAAAA0LLJas+PrPbKy9kuB1ntjVNpd0hWe+WR1Q4AAAAAAAAAAAAAAAAAAAAAAAAAAEAxyWrPj6z2ysvZLgdZ7Y1TaXdIVnvlkdUOAAAAAAAAAAAAAAAAAAAAtFSZci8AAAAAANCSXXfddfHCCy8k9nXs2DEuvPDCnOdPnz49BgwYELNnz85nvbzU1dXF6aefnte+aXz44Ydx//33p+qdO3duTJ48uSh7NMd329Q8/vjjcdxxxxUt/Pqxxx6Ln/70p0UN1y71ParkO3TjjTcm9uy5557RpUuXvOYvXLgwBg4cGJdccklezxfSddddF4MHD47a2tpyr9Kgjz/+OCZOnJiqtxLeaZIOHTrEoEGDEvvS3EMAAAAAAAAAAAAAAAAAAAAAAAAAAAAKQ1Z77mS1V2bOdjnIas9dJd8hWe2VRVY7AAAAAAAAAAAAAAAAAAAAAAAAAAAAxSarPXey2iszZ7scZLXnrpLvkKz2yiKrHQAAAAAAAAAAAAAAAAAAAGipMuVeAAAAAACgJauvr49TTz01Ve//+3//L7bffvucz5g+fXpst9128fjjj+f8bK5mzpwZgwYNiosvvrio54wdOzZV38SJE4sajtwc321TM27cuPjpT38aS5YsKejce+65JwYNGhSLFy8u6Nw1KdU9qvQ79NBDD8XMmTOz9lRXV8dBBx2U9xlLly6Nk08+OQ488MD44IMP8p6Tr1mzZsXhhx8eRx55ZEnuVmOlCWWfOnVqPP300yXYpnEOOOCAaN++fdaeL7/8Mu68884SbQQAAAAAAAAAAAAAAAAAAAAAAAAAAICs9vzIaucrstrTq/Q7JKu98shqBwAAAAAAAAAAAAAAAAAAAAAAAAAAoJhktedHVjtfkdWeXqXfIVntlUdWOwAAAAAAAAAAAAAAAAAAANASZcq9AAAAAABAS/fggw/Gvffem9hXVVUVY8aMyeuMDz/8MPbcc8849thjY86cOXnNyGbx4sXx+9//PjbffPN44IEHCj7/6+68886YPXt2Yl/akPfGaG7vtim69tprY4899og333yz0bMWL14cZ555Znz/+98vavD/1xXzHjWVO1RXVxc33nhjYt+RRx7Z6LP+/Oc/R+/eveMXv/hFUX7fft1nn30Wv/71r2OLLbaIm2++uejnFcpzzz0XTz75ZNaefP+9VGpp7s2f/vSnWLBgQfGXAQAAAAAAAAAAAAAAAAAAAAAAAAAA4N9ktedOVjsrk9WeXVO5Q7LaK4+sdgAAAAAAAAAAAAAAAAAAAAAAAAAAAIpNVnvuZLWzMlnt2TWVOySrvfLIagcAAAAAAAAAAAAAAAAAAABaoky5FwAAAAAAIOLUU0+NZcuWJfbtvvvuceCBB+Z1Rl1dXVx99dXRq1evOP744+OFF17Ia87K3nvvvRg5cmRsuOGGcdppp8X8+fMbPTONpUuXxg033JC155VXXomnn366JPs0p3fbVE2dOjX69OkTv/jFL+L999/P+flly5bFjTfeGFtvvXX89re/jbq6uiJsmV2h71FTvEOXXXZZ4p+Fu+yyS/Tu3bvRZy1atCjGjBkTPXr0iAMPPDAmT54cCxcubPTcryxYsCDuuuuuOPzww6OmpibOPffcmDt3bsHml8oll1zS4GcfffRR/OlPfyrhNvmpqamJgQMHJvY1lSB6AAAAAAAAAAAAAAAAAAAAAAAAAACA5kZWe25ktfN1stpX1xTvkKz2yiOrHQAAAAAAAAAAAAAAAAAAAAAAAAAAgGKT1Z4bWe18naz21TXFOySrvfLIagcAAAAAAAAAAAAAAAAAAABamqr6+vr6VI1VVcXeBQAAAACAEtt4443jO9/5Tuy0006x9dZbR69evaJbt26r/Z3wsmXLYu7cufHmm2/Ga6+9Fs8991zcd9998Y9//KNMm1c+77Z8MplM7LHHHrHffvtF//79Y/PNN49u3bqt0rNkyZJ4++2348UXX4wHHnggbr/99pg9e3aZNm7Y1+9Rv379mv0dmjRpUhx88MFZe0aPHh2nnHJKwc9u3759bLfddvHtb387+vXrF5tttll07949unfvHm3btl3jM/PmzYuPP/44Pvzww3jjjTfi5Zdfjr///e/x7LPPxuLFiwu+I7k777zz4qyzzsra8+ijj8aee+5Zoo0AAAAAAAAAAAAAAAAAAACAckkZy75GstoBAAAAAJofeeLF492Wj6z2pn2HZLVTaLLaAQAAAAAAAAAAAAAAAAAAgK/IagcAAAAAYGXyxIvHuy0fWe1N+w7JaqfQZLUDAAAAAAAAAAAAAAAAAAAAX0mT1V5VnzLRXXg7AAAAAEDL0a5du2jfvn1UVVXFggULYuHCheVeqdnwbsujVatW0aFDh2jdunXMnz+/SYdqN/c71L9//3jqqaey9syfPz969uwZX3zxRYm2ivjJT34S48aNW+VrH3zwQWy44YYl24HctW/fPt5///1Yd911s/b98Ic/jDvuuKNEWwEAAAAAAAAAAAAAAAAAAADlkjKWfY1ktQMAAAAAtBzNPQu6nLzb8pDV3nTIaqeQZLUDAAAAAAAAAAAAAAAAAAAAK5PVDgAAAABAGs09C7qcvNvykNXedMhqp5BktQMAAAAAAAAAAAAAAAAAAAArS5PVninBHgAAAAAANDELFy6Mzz77LD799NNmFwxdbt5teSxbtizmzZsXn376aZMObo9o/ndo6tSpMXXq1Kw9nTp1iuHDh5doo+Wa47tuCY488sjE4Pa33nor7rzzzhJtBAAAAAAAAAAAAAAAAAAAAAAAAAAAQKVr7lnQ5eTdloes9qZDVjuFJKsdAAAAAAAAAAAAAAAAAAAAAAAAAACAXDX3LOhy8m7LQ1Z70yGrnUKS1Q4AAAAAAAAAAAAAAAAAAADkKlPuBQAAAAAAAGBlI0eOTOwZMWJEVFdXl2Abmqqqqqo45ZRTEvvOPvvsqK+vL8FGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJCdrHYKQVY7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAE2NrHYKQVY7AAAAAAAAAAAAAAAAAAAAkI9MuRcAAAAAAACAlT3wwAPx4IMPZu3p0aNHDBkypEQb0RQdcMAB0bt376w9L7zwQtx0000l2ggAAAAAAAAAAAAAAAAAAAAAAAAAAAAAspPVTiHIagcAAAAAAAAAAAAAAAAAAAAAAAAAAACgqZHVTiHIagcAAAAAAAAAAAAAAAAAAADykSn3AgAAAAAAAPB1Z5xxRtTX12ftOf3006OqqqpEG9HUnHHGGYk9p59+egk2AQAAAAAAAAAAAAAAAAAAAAAAAAAAAID0ZLXTWLLaAQAAAAAAAAAAAAAAAAAAAAAAAAAAAGiKZLXTWLLaAQAAAAAAAAAAAAAAAAAAgHxkyr0AAAAAAAAAfN2zzz4bkydPztqzzTbbxBFHHFGijWhKDj744Ojfv3/WnoceeiimTJlSoo0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAIB1Z7TSGrHYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAmipZ7TSGrHYAAAAAAAAAAAAAAAAAAAAgX5lyLwAAAAAAAABrcsopp8T8+fOz9vz2t7+Nzp07l2gjmoK2bdvG7373u6w9ixYtihNOOKFEGwEAAAAAAAAAAAAAAAAAAAAAAAAAAABAbmS1kw9Z7QAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0dbLayYesdgAAAAAAAAAAAAAAAAAAAKAxMuVeAAAAAAAAANbkgw8+iDPPPDNrT7du3WLkyJEl2oim4LTTTotevXpl7TnvvPPi1VdfLdFGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJAbWe3kQ1Y7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAE2drHbyIasdAAAAAAAAAAAAAAAAAAAAaIyq+vr6+lSNVVXF3gUAAAAAAABWUVVVFU8++WT079+/wZ7FixdHnz594s033yzaHn369IkDDjhgla/NmzcvLrvssqKdSe5qamri9ddfj44dOzbY89JLL8X2228fS5cuLeFmAAAAAAAAAAAAAAAAAAAAQCVIGcu+RrLaAQAAAAAAKDVZ7eRCVjsAAAAAAAAAAAAAAAAAAACQjax2AAAAAAAAmhJZ7eRCVjsAAAAAAAAAAAAAAAAAAACQTZqs9qr6lInuwtsBAAAAAAAoh6222ipuueWWrD333HNPnHHGGSXaiEp11llnxaGHHpq156ijjopnnnmmRBsBAAAAAAAAAAAAAAAAAAAAlSRlLPsayWoHAAAAAACgHGS1k5asdgAAAAAAAAAAAAAAAAAAACAbWe0AAAAAAAA0NbLaSUtWOwAAAAAAAAAAAAAAAAAAAJBNmqz2qvqUie7C2wEAAAAAAAAAAAAAAAAAAAAAAAAAAACApiplLPsayWoHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJoqWe0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEuUJqs9U4I9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoCJkyr0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlEqm3AsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAqWTKvQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUSqbcCwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECpZMq9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJRKptwLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQKlkyr0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlEqm3AsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAqWTKvQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUSqbcCwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECpZMq9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJRKptwLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQKlkyr0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlEqm3AsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAqWTKvQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUSqbcCwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAECpZMq9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8P/ZnWMaAAAABECb/UPbQh9IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABld45pAAAAEABt9g9tC30gAQAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABW8g4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADASt4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWMk7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACt5BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAl7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACs5B0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAlbwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsJJ3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFbyDgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBK3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYyTsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK3kHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYCXvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKzkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICVvAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwkncAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVvIOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwEreAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFjJOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAreQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgJe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArOQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgJW8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCSdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKDs3XmQXeV9JuD3ntuL1FpYJLQgCRCLQLIMBIQMBgVMTNkYhBNjg2KisROwwwzgGi/Y8WSc8pKQcbyUqWSIt9SUa8AYj6WJiUhJDGGxgWgEslmNDLZwgpDFLqGlW73d+aOHRfSqhXO7W89T1SX6fL/vO2/fe7r5770AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQlqLeAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAsRb0DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQFmKegcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAshT1DgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABlKeodAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMpS1DsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlKWodwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoS1HvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCWot4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoCxFvQMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAWYp6BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICyFPUOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGUp6h0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAylLUOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUpah3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAChLUe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUJai3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgLEW9AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBZinoHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgLIU9Q4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZSnqHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADKUtQ7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJSlqHcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKEtR7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQlqLeAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAsRb0DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQFmKegcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAshT1DgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABlKeodAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMpS1DsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlKWodwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoS1HvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCWot4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoCxFvQMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAWYp6BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICyFPUOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGUp6h0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAylLUOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUpah3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAChLUe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUJai3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgLEW9AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBZinoHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgLIU9Q4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZSnqHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADKUtQ7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJSlqHcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKEtR7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQlqLeAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAsRb0DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQFmKegcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAshT1DgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABlKeodAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMpS1DsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlKWodwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoS1HvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFCWot4BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoCxFvQMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAWYp6BwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICyFPUOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGUp6h0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAylLUOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUpah3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAChLUe8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUJai3gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACgLEW9AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBZinoHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgLIU9Q4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZSnqHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADKUtQ7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJSlqHcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKEtDvQMAAAAAAAAAAAAAAAAAAAAAAAAAAADAaFapJk1j651i73XuTLo66p0CGI1mvTWZfly9UwAAAAAAAAAAAAAAAAAAAAAAAAAAAAD7mq52gIHpagcAAAAAAAAAAAAAAAAAAAAAAAAAAIDRSVc7wMCGU1d7Q70DAAAAAAAAAAAAAAAAAAAAAAAAAAAAwGh2wLHJ+z+ZpFLvJHtn9Y3JI/+n3imA0Wj2guTUi+udAgAAAAAAAAAAAAAAAAAAAAAAAAAAANjXdLUDDExXOwAAAAAAAAAAAAAAAAAAAAAAAAAAAIxOutoBBjacutob6h0AAAAAAAAAAAAAAAAAAAAAAAAAAAAARrNqc3LQjKQywsvbm8fXOwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMJLoagcAAAAAAAAAAAAAAAAAAAAAAAAAAAAA9ke62gFGjqLeAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAsRb0DAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQFmKegcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAshT1DgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABlaah3AAAAAAAAAAAAAAAAAAAAAAAAAAAAABjNGhuS7S8mHe1JaklDc9LQlDQ0JkU1SaXn30ql3kkBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPYdXe0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAwP5IVzvAyNFQ7wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwGhTVpHFMcuD0ZMb8ZNoxydRjksfuTK774BuGK0m1MRk7IZk4JZl2bDJjXnLQjOSAqcmY8crcAQAAAAAAAAAAAAAAAAAAAAAAAAAAAICRQVc7AAAAAAAAAAAAAAAAAAAAAAAAAAAAALA/0tUOMPI11DsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjFRNLT2F64fOT44+JTl0XtI0Ztfi9XW1PjbWkq72ZNsLPV8bH0t+9o9J8/jkgOk9Re7zzk6mHZ1UNQkDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMOMrnYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYH+kqx1gdPEnFwAAAAAAAAAAAAAAAAAAAAAAAAAAAHbTAdOSY85Ijjw5mTYnaR63a2H7ntq5LXn2ieTZXyWP3pYcclTytg8kR52yb84vW7VazaRJk1IUxV6dU6vV0t3dne7u7nR0dKS1tTUdHR17dNaECRPS1NQ06Fxra2t27NixR/dIksbGxkycOHHQue3bt6etre3V74uiyEEHHTTovm3btmXnzp17fN++vPI6d3V1ZefOneno6Eit1tenD+y+hoaGHHDAAYPObdmyJZ2dnXt1rwkTJqRarQ55vlarZevWrenu7t6r+wIAAAAAAAAAAAAAAAAAAAAAAAAAAADsD3S1D42udl3tr9DVDgAAAAAAAAAAAAAAAAAAAAAAAAAAADA66GofGl3tutpfoaudkaKh3gEAAAAAAAAAAAAAAAAAAAAAAAAAAABgJCiqydQ5yelLk0PnJM0tSeUN/dC1WtLdmbRtTXbuSHa2JrWGpHn8/y9fryVdXUlXR1Lr7vnqUy1p3548/VCy/OHkkNnJaX+YHH5iMnbPernrYtasWVm5cuWQysiHoru7O7VaLe3t7dm8eXMefvjhrFixIj/5yU/y3HPPDan0+9Of/nQuu+yyQefWrl2b888/f4+zfuhDH8oXvvCFAYvra7VaFi9enLVr1756bdq0aVmzZs2A5eOdnZ25+uqr84Mf/KDX2qJFi3LDDTfsce5arZZarZaOjo60t7fnt7/9bR544IH89Kc/zd13353nn39+j8rV3/a2t+Wmm24atFT93HPPzQMPPLCH6ZMZM2bkrrvuSktLy5D3tLW15eKLL8599923x/cFAAAAAAAAAAAAAAAAAAAAAAAAAAAAGM10te8+Xe262l+hqx0AAAAAAAAAAAAAAAAAAAAAAAAAAABg5NLVvvt0tetqf4WudkaKhnoHAAAAAAAAAAAAAAAAAAAAAAAAAAAAgOGsoTmZfmLytvclR7y1p8T9jXbuSDY8kmxclzz/ZPLCU0nrlp7rU05OrrwpqTYk3d09xe07d/TMPLkm2firZPO/Jzs2J91dfQSoJc+tT/7pr5OpRyenfCCZ8/ae84a7arWaSZMmZdKkSfv87MMOOyzHH398LrnkkrS3t+e+++7LV7/61dx+++3ZunVrv/tuu+22XH311Wlqahrw/AULFuTAAw/M5s2bdztbtVrN4sWLM3369AHnnnrqqaxbt67X3qlTpw5a3j5mzJg+15qamjJ16tTdztyfo48+OosWLcpVV12Vjo6OPPTQQ/nmN7+Zm2++Oc8999yQz3kl12Dl7Q0Ne/dg/8mf/EmOPPLI3d530UUXZe3atenu7u8TFQAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2P7ra95yudl3tb8ylqx0AAAAAAAAAAAAAAAAAAAAAAAAAAABg5NDVvud0tetqf2MuXe0MdyPgTysAAAAAAAAAAAAAAAAAAAAAAAAAAACUr1Ik045NTn5vcszpSeMbur5rtWTLpuSBFcn6+5ItzyQdO5PUdp3raH+t8L0okqI5aWxOxh+UHH58T2H7SxuTf/95su6nycbHegre36jWnWx6PFn5tWT96mTRh5OJU96Mn3zkaWpqyumnn54FCxZk1apVueaaa7JmzZo+Z++///5s27YtBx988IBnTpw4MSeddFJuv/323c4zderUzJkzZ9C5m2++OTt27Njt8+ulsbExJ598cr71rW/lIx/5SL7xjW9k+fLlaW9vr3e0JElzc3MuvfTSPdq7ZMmSXHPNNXnppZf2cSoAAAAAAAAAAAAAAAAAAAAAAAAAAACAkUdX+8ihq70cutoBAAAAAAAAAAAAAAAAAAAAAAAAAAAA9g+62kcOXe3l0NXO/qCodwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYbsZPThZ/NvnAXyZzz9q1uL29Ldn0RPLjLyf/8JFkzY+S5/8t6WhLr+L2oSiqyaRZyYmLk/d9Ifng15Oj3/5a4fsbdbQlj/5Lcv3HkyfvTzr7KHrfXzU3N2fx4sVZsWJFli5d2ufM9u3bc9tttw3prHPOOWePcsyfPz9HHHHEgDOdnZ1Zvnx5arU9eGjqrCiKLFy4MN/97ndz/fXXp6Wlpd6RkiSLFi3KzJkz92jvjBkzct555+3jRAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAjj672kUlXezl0tQMAAAAAAAAAAAAAAAAAAAAAAAAAAACMXrraRyZd7eXQ1c5oVtQ7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwXjS3J/Pckl347Oe53kzHjk0qlZ63WnTz1y+Sfvpzc8PHk8TuSrn1YnF6pJM0tyfQ5yR/8RXLxf0umzUkq/TQJb3s+WfYXyR3fTba+sO9yjHSVSiWTJ0/OddddlwsuuCCVV97A17nuuusGLU2vVCo56aSTMmHChN26f7VazRlnnJHm5uYB537xi1/kkUce2a2zh5uWlpZceOGF+f73v7/br9O+VhRFLr/88hTFnldvf+Yzn0lDQ8M+TAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAwcuhqH/l0tZdHVzsAAAAAAAAAAAAAAAAAAAAAAAAAAADA6KGrfeTT1V4eXe2MRp4AAAAAAAAAAAAAAAAAAAAAAAAAAAAASHLI7OS0DyVHL0gaGndda9uW/Owfk7UrktaXhnBYJWkam4w5IDlwUrL88z1F77Va0tCUHDgtmXx4MntBMn5y8sa+6UolmXV8cuGXkrXLk/t/nHS29b5Nd1fywM3Jc79Ozrs6OWDqHv7wo9C4ceNyzTXX5JFHHsn69et3WXvwwQfz7LPPZurUgV+wefPmZcaMGVm3bt2Q79vS0pLzzjtv0Lm77rorL700lIdpeKtUKjn33HPzmc98Jl/4whfS0bEPP9FgNxx22GE5+eSTB5zp7u4esNz9qKOOygknnJC1a9fu63gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAw5qu9tFFV3s5dLUDAAAAAAAAAAAAAAAAAAAAAAAAAAAAjHy62kcXXe3l0NXOaNNQ7wAAAAAAAAAAAAAAAAAAAAAAAAAAAABQT0U1mf/u5PQ/7ClSr1ReW6vVkpc2Jrd8Jdm0ruf7/lQqPaXshy9IjjwlmTg5aZ6YPLgiWX1b3/NFQzL5iOStv58cd0oydkJSeV239LgDk9P/QzJ9fvIv/z15eVPvc2rdyYaHkxs/nbz/L5NJM3f9GfZnc+fOzac+9alcddVV6erqevX6tm3b8qMf/ShXXHHFgPunTZuW448/frfK22fPnp358+cPOLNz587ceeed6ezsHPK5+1p7e3uv+1er1Ve/KrvxEDU2NuZjH/tY7r777qxcuXJfRx2Sd7/73ZkxY0a/65s3b86jjz6a0047rd8C9+bm5nz4wx/Oz372s9QG+mUHAAAAAAAAAAAAAAAAAAAAAAAAAAAAGCV0tY9eutr7p6u9N13tAAAAAAAAAAAAAAAAAAAAAAAAAAAAwP5GV/vopau9f7rae9PVTpI01DsAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1Mu4ycmZ/ymZd2pPifvrdXYm69ckq76RtG7p/4zmccnhJyZvX9pTnF407Fqe3l8Hdq2WdHUkzzyRPPOV5F8PThZ+IJl7ZjLu4Nf2VRuSYxYmUw5PVnw9efqBvs97eVNy4yeTd30sOerUnn0jxUsvvZSNGzfuUrD+ekVRpKWlJdOmTcvYsWOHXCxeqVTyx3/8x/nKV76SJ5988tXrXV1dueWWW3LZZZelubm53/3VajWLFy/O8uXLh1y0vnjx4jQ2Ng44s2HDhvzkJz8Z0nlvhtbW1lx99dV56KGHdrk+fvz4zJo1K0cccUTmzZuXhQsXZvr06UM6c/z48bn22mtzwgknpK2t7c2I3a8JEybkfe97Xxoa+n/oV69enT//8z/P9ddfn7lz5/Y5U6lUcs455+TQQw/N008//WbFBQAAAAAAAAAAAAAAAAAAAAAAAAAAABgWdLUPD7ray6WrXVc7AAAAAAAAAAAAAAAAAAAAAAAAAAAAgK724UFXe7l0tetqp38j6E8nAAAAAAAAAAAAAAAAAAAAAAAAAAAA7DtT5iTv+kQyfXbvtc6OZO2K5F//Z9K+ve/9jWOTo09LTvr9ZPrRvcvfd9f2F5M7v5OsuzN5x0eTmfN3XT9ganLh55Kbr0l+s7bvM1q3JKuuTc5tTI5a2H9x/HBz00035Wtf+1paW1v7nRkzZkymTJmSE044IVdccUXmzZuXoigGPbu5uTl/9Ed/lC996Uu7XH/kkUfyxBNPZP78+f3s7HHWWWelpaUlL7/88qD3qlarufjiiwede/TRR/Piiy8OOvdmaWtry/Lly7Np06Z+Z8aMGZNjjjkmH/3oR7N06dJMnDhx0HOPOeaYvPOd78yKFSv2ZdxBHXvssVm0aFG/693d3bnpppvy8MMPZ9WqVTnuuOP6/QCA2bNn59RTT82yZcverLgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAdaerffjQ1V4uXe262gEAAAAAAAAAAAAAAAAAAAAAAAAAAID9m6724UNXe7l0tetqp3+D/1UBAAAAAAAAAAAAAAAAAAAAAAAAAACAUaRSJHMWJe/7fN/F7bVa8uDK5Kff7ae4vZLMPCH5g88n530ymXHsa8XttVrS1Zlsfyn59X3JfcuTHa1J09iefYOpdSe//WWy/PPJY3cl3V27ro8Zn7zn6mT2Kf2f0fpycsuXk42/7MkzEjz++ONZv359Nm7c2O/X+vXrs3r16nz729/OO97xjlx77bXp6OgY0vkXXXRRr7LuTZs2Ze3aflrwX+fQQw/NscceO6T7TJs2LXPnzh107sYbb0xtmL85bW1tefjhh/OJT3wil1566ZDL5i+//PJ+i9HfDJVKJVdeeWWam5v7nWltbc2Pf/zjdHZ2ZuXKldmxY0e/s42NjVmyZMmA5wEAAAAAAAAAAAAAAAAAAAAAAAAAAACMVLrahx9d7cOPrnZd7QAAAAAAAAAAAAAAAAAAAAAAAAAAAMDoo6t9+NHVPvzoatfVvr8q6h0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAylJtTE77YHL+p5OJk3qvd3YkP1+R3H5d0t3Ze71hXHL2f0wu+qvkiBOTouG1tR1bkodWJTdenVx3SbLsvyZ3fCt5+t+Sy29ILv1uctL7kzETBs/ZtjX5568k91yfdOzcdW38QcnizyazF/S/f+f2ZPnnkt8+NnIK3IeqVqvlhRdeyGc/+9l873vfG1IJ+qGHHppJk3Z9wzs7O7Nq1aq0t7cPuLdSqeSiiy4aUrb3v//9qVarA860tbXl1ltvHdJ5w0FHR0eWLVuWK6+8ctDXKknmzp2byZMnl5Csx+TJk3PxxRcPOPPDH/4wmzdvTpLce++92bBhw4Dz559/fubNm7evIgIAAAAAAAAAAAAAAAAAAAAAAAAAAAAMC7raRz5d7eXS1Q4AAAAAAAAAAAAAAAAAAAAAAAAAAAAwOuhqH/l0tZdLVzv7m6LeAQAAAAAAAAAAAAAAAAAAAAAAAAAAAKAMlUry9qXJ2y9JGpp6r9e6k1/ckdz13Z7/fqOJ05L3fS5Z8N6koXHXtd8+nvzvLyW3Xpts/EVS63rduUmaW5JJM5Pfuyz54DeSWSclqQyct6sjWfO/kl+v6b02ZlxPgfuBM/vf3/pyctu3ktYtA99npGpvb88Xv/jFbNky+A/Y2NiYGTNm9Lp+xx13DGn/hRdeOGgpe6VSybve9a5Bz7r99ttfLRIfSX74wx9m2bJlg84dcsghectb3lJCoh5Lly5Nc3Nzv+s7d+7M3/3d3736/bZt27Jy5coBz2xubs6f/umf7rOMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPWmq3100dVeLl3tAAAAAAAAAAAAAAAAAAAAAAAAAAAAACOXrvbRRVd7uXS1s78o6h0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAylCrJVOPTIp+mnm3vtBTlt7R1nvt4JnJe/9LcviJvc9c96/JP34xefrhvkvfX69SSSbPTM7/ZHLESYNnHjMhGXdQ32tFQ9LdOfC9phyRNIwZ/D4j1YYNG3LPPfcMOletVjN58uRe15955pn86le/GnT/lClTMnPmAE35SSZPnpwjjzxy0LO+853vpFarDTo33HR3d+frX/962tvbB5xraWnJ3LlzS8nU3NycJUuWDDizevXqPPHEE7tc+/a3v53u7oF/WZcsWZLx48fvdUYAAAAAAAAAAAAAAAAAAAAAAAAAAACA4UBX++ijq708utoBAAAAAAAAAAAAAAAAAAAAAAAAAAAARi5d7aOPrvby6Gpnf9HP/yIAAAAAAAAAAAAAAAAAAAAAAAAAAABg9Fn9g/4L1ptbkjH9dDWfeEEybU5PIfrr/ftDycq/SbY+t3s5JkxOFv9ZMnFK/zOTDk/e/1fJzHm911q3Jiu+mry8qf/9834vOfvypGkUl7cnyd/+7d8OOtPU1JSjjz66z7W///u/H3R/c3NzzjvvvAFnTj755MyaNWvAmaeffjr333//oPcbrtatW5fVq1cPOFMURWbMmJGiv09J2IcWLlyYOXPm9Lve1dWVG264Idu3b9/l+hNPPJFHHnlkwLMnTJiQSy65ZJ/kBAAAAAAAAAAAAAAAAAAAAAAAAAAAABgOdLWPPrray6OrHQAAAAAAAAAAAAAAAAAAAAAAAAAAAGDk0tU++uhqL4+udvYHb/6TCwAAAAAAAAAAAAAAAAAAAAAAAAAAAMPExseSjb/se615XDJ3UVJUe6+t+0nS3bnrtVot2fZ80t66Z1nGTkzeeVVSbdz1eqWSHH5KcsnXk6lHJpU3NAnv3JHc+Q/Jr+/p/+yjT0/e9Z+TprF7lm0kWbduXWq12qBzY8f2/WKsWrUqra0Dv4nVajVnnnlmv4XkRVHk9NNP7/cer1i5cmWee243m/6Hkba2ttx9992Dzs2aNSuNjY2Dzu2NarWaCy64IBMmTOh35umnn85dd93V6/no7OzMtddeO+BzU6lU8sEPfjBNTU37LDMAAAAAAAAAAAAAAAAAAAAAAAAAAABAPelqH310tZdHVzsAAAAAAAAAAAAAAAAAAAAAAAAAAADAyKWrffTR1V4eXe3sD/r+LQcAAAAAAAAAAAAAAAAAAAAAAAAAAIBRqLsruff6nn/7csyiZNyk3tef/02y8Yldr1UqybQ5yfiD9zzPYW9NZi947fuimrzlncniTyVjxveer9WStbckj96a1Lr7OLCSzD45OeeKpOHN7c4eNrZs2ZIdO3YMOFOpVFKt9tHKn+TFF1/MHXfcMeh9jj322Eya1MfDkWT8+PE544wzBtzf2dmZO++8M+3t7YPea7jq6urKb37zm0HnJk+e/KaXnk+ZMiXnnntuKpVKvzMPPvhgnnzyyT7X7rjjjmzYsGHAe8ydOzdvectb9ionAAAAAAAAAAAAAAAAAAAAAAAAAAAAwHChq3300dVeHl3tAAAAAAAAAAAAAAAAAAAAAAAAAAAAACOXrvbRR1d7eXS1sz8o6h0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAyvTUw8nj9/a9NmFycuIf9L7evi158J+Tzo5drx80PTnqbUn6748eUNPY5O1Lk5aDkmpTctZHk3OuTFoO7D3b2ZH8fEVy7//op3y+ksw9Kzn/z5IJfXeMj0ptbW3ZsmXLHu/v6urK9773vdRqtQHnjjrqqMyZM6fPtSOOOCILFy4ccP/GjRtzzz337HHO4WL79u2DvlZjx45NUby5FdhnnXVWjjvuuH7Xu7q6cuONN6azs7PP9Y0bN+bWW28d8B6TJk3Ke97znjf9ZwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAoi6720UVXe7l0tQMAAAAAAAAAAAAAAAAAAAAAAAAAAACMXLraRxdd7eXS1c5o590GAAAAAAAAAAAAAAAAAAAAAAAAAABgv9K5M7lvWbJja++1SiVZcF5Pifsb/eqe5Jn1u14rGpJTLkzG70VZ+rSjkt+9NLn4r5MFv580juk9096W/N8fJrd/s+/i9ko1Of785D2fSsZO7Ps+3V3Jc08mne17nnU4qtVq2bRp016dsWbNmmzcuHHAmXHjxuW0007rs8j77LPPztixYwfc/9hjj2XDhg17lXM4GKy4PUmKokilsoefaDAETU1N+fjHPz5gqfrmzZtzyy239Lve3t6em2++Oa2trf3OVCqVLF26NIcccshe5QUAAAAAAAAAAAAAAAAAAAAAAAAAAAAYLnS173nW4UhXe7l0tQMAAAAAAAAAAAAAAAAAAAAAAAAAAACMXLra9zzrcKSrvVy62hnt+n+qAAAAAAAAAAAAAAAAAAAAAAAAAAAAYJTa9Hiy/udJXz3Ujc3JqRcneUP3dPuO5IFlSXf3rtcPnpmcuqT3/O44/pxk5vy+17o6k3u/n6y+Menu7L1ebUxOfm9y9qVJtaHvMzo7k5/9U/KjzyW3/E2yee+6zoeV7u7uvPDCC3t1xrPPPpt77rln0Lkzzzwzzc3Nu1wriiJLliwZNOOqVavS2dnHGzjCNDQ0DFrM3t3dPaSS9z01Z86c/M7v/M6AM8uWLcvWrX18QsPrrFmzJk899dSAM/+PvXsN0qsu8Dz+e066c2kaEpJOIFxFAoR4AWKICTKA0TIgW4LrgoLrsMi6tUtt1YhVuiszrrtbw6JObe1O7Y66WGrYDN4g4JDRYXQBBQQEiRAMgkRCyIVALhByo2/Psy+6MtAk3Z1OOud0uj+fqn7Bc/7nnF+aTr/8ZsaMGXnf+9436I0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAw5VW+/5vHW602sul1Q4AAAAAAAAAAAAAAAAAAAAAAAAAAABwaNNq3/+tw41We7m02hnpiqoHAAAAAAAAAAAAAAAAAAAAAAAAAAAAQNka3ckv/0/yeh9t59MuSI6dtefnT92fPPvQntH3My5MTj1niDc2kte3J//wzeSRHyXdnXueGdeSXPi55E/+VTJ2wt6f09WePHhL8otvJds2Js/cnyz+98mvFic7Xt17wP5Qc6Ch8F27duX+++9Pd3d3v+fOP//8TJs2rddn06ZNGzAkXq/Xc/vttx/QxuGgVqtl6tSpA55rb29P/a3/ysEQ+uxnP5sxY8b0eb2rqyvf+MY3BnzOSy+9lEceeaTfM0VR5Lrrruv3fQAAAAAAAAAAAAAAAAAAAAAAAAAAAACHEq12rfY302rfN1rtAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIc+rXat9jfTat83Wu2MBkXVAwAAAAAAAAAAAAAAAAAAAAAAAAAAAKAKOzYl/+/rSedeougtRyTzP5mMb+39eaOe/Ox/JS+u7B09H9OcLPh3ybSTh2ZbvTt5YXnyg+uTp5Ym2UubfOL05Iq/Tt6xIGket+f1RiN5ZUPy93+VPPy9pN71xrVd25Jf/W2y+LPJb3+abN8yMiLuB+LnP/95Nm/e3O+Z1tbWnHfeeb0+u/DCC9Pc3NzvfStWrMiaNWsOeGPVxo4dm7lz5w54btOmTenc21+sITB16tR8+MMf7vfMgw8+mKeffnqfnvf1r399wND8/Pnzc/rpp+/zRgAAAAAAAAAAAAAAAAAAAAAAAAAAAIDhTqtdq/3NtNoHptUOAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDJotWu1v5lW+8C02hkNiqoHAAAAAAAAAAAAAAAAAAAAAAAAAAAAQFX+8EDy5D09Ufa3etuZyeyPJKn1/nzXKz0B99de7v35EVOThX924AH3zvbksduTv/vL5OVn9rxeK5IZ70s+9pfJtBP2/oxGI9nwTHLnDckf7u/7Xa+9mNz9N8mS/5Q8+6tkgIb1iPbcc89l7dq1A5674oorev335ZdfPuA93/nOd9IYAXX8SZMmZf78+QOeW7duXTo6Og7KhosuuihTpkzp83q9Xs8tt9yyz+9ftmxZ1q1b1++Zoihy7bXXDmonAAAAAAAAAAAAAAAAAAAAAAAAAAAAwHCn1a7VvptW+8C02gEAAAAAAAAAAAAAAAAAAAAAAAAAAABGDq12rfbdtNoHptXOaNBU9QAAAAAAAAAAAAAAAAAAAAAAAAAAAACoSndn8vD/TY6bsWd0vRiTzL08WftU8sLjva+9/Ezyjzcll3w+GTf+jc+nn5Zc+qXknpuSlQ8ObktXZ7Lh6eQX305efGbvQfmxLckFn0lmnp+MP2zvz6l3J6t+k/z915L27QO/t9GdvPRscudXktM/kLz/mqTliMFtHwm6urry05/+NLNnz+733LnnnpsJEyZk165dOfLIIzNr1qx+z+/YsSNLly4dyqmVufjii3P88cf3e6bRaGTDhg2pH4R/CaClpSWXXHJJmpub+z13+eWX56STTtqnDePGjcv48eMHPLdw4cK0tbVl06ZN+7wXAAAAAAAAAAAAAAAAAAAAAAAAAAAAYDjTatdq302rfWBa7VrtAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMih1a7VvptW+8C02rXaR4OmqgcAAAAAAAAAAAAAAAAAAAAAAAAAAABAlbZvSn7618ll/zU5bFLva2MnJBd/Pvnhf0i2rO197fkHkju2Jws/m0w6OqnVej6fND35yPXJ0w8mD92STJjYE4lvGrvnuztfT7a+3BNPf/yuZP2TSaOx57kxzcmJc5IF/yY5cvob73qzRiN5bVPy8K3J8qV7j7/3p96ZPH13Mnl6Mu/je3/HSPfd7343119/fYqi6PNMS0tL5s+fn3vuuSfz5s1LW1tbv8/82c9+lhdffHGop5Zu+vTp+epXv5raAD8Y7e3tefrppw/KhlmzZmXBggX9nimKIgsWLBjw3JsN9GdKkuOOOy4XXXRRFi9evM/PBQAAAAAAAAAAAAAAAAAAAAAAAAAAABjutNp7aLVrtfdHq12rHQAAAAAAAAAAAAAAAAAAAAAAAAAAABh5tNp7aLVrtfdHq12rfbRoqnoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVO3lZ5Kf/U3y4euScS29r7VOSS78s2Tp15JtG3tfe+Hx5Pb/nHzw3yYnnPlG8LypOXnn+cmp702W/SS59cvJ5KOTwyYnY5qS7q5kx5bklbXJprXJrlf2Hm2vFcnkE5N5lyUzz++5ty/PPZrc951k4/NJ9vKsgYxrTeb+i+Tsfz46w+1JsmbNmqxcuTKnnnpqn2dqtVouueSS/PKXv8y5556bCRMm9Hm2Xq9n6dKlaW9vPxhzSzNlypR861vfyuTJkwc8u3nz5qxYsWLINxRFkUsvvTQTJ04c8Oy+xNgHq7m5ORdffHFuu+227Nq1a8ifDwAAAAAAAAAAAAAAAAAAAAAAAAAAAFAVrXat9kSrvS9a7VrtAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMil1a7Vnmi190WrXat9NOnn1ywAAAAAAAAAAAAAAAAAAAAAAAAAAACMHisfSB6Ykpz/6aRp7Buf12rJse9MLrwuWfqV5PXXet+3+fnkjv+SzPlYT/y8efwb8fOx45PObcmaZcma9MTYd2vU+98z+YTk3RcnM9+XHDG173PtO5LHbk8eWZJ07E9TupYcPTP5k6uSt53Re+No09XVlZtvvjk33HBDn2dqtVre8573ZObMmZk7d26/ofCNGzfmkUceORhTS1Gr1XLWWWflhhtuyAc+8IF9iqKvX78+69evH/Ithx12WK688sohf+5gLFiwIKecckqWL19e6Q4AAAAAAAAAAAAAAAAAAAAAAAAAAACAoabVrtWu1d6bVntvWu0AAAAAAAAAAAAAAAAAAAAAAAAAAADASKXVrtWu1d6bVntvWu2jQ1PVAwAAAAAAAAAAAAAAAAAAAAAAAAAAAGA4aNSTZX+XpJacd1VPhH23WpG8bXby8a8mt/15smNL73s7diUP/m2y4ufJWR9J3n52MnF60tS85zv6VOs5P+3k5Jx/mRw7Kxk74Y0Q/Fu170pW/zb5xbeSV/ezlT1hYnLunybv+EDv6Pxoduedd+aLX/xiWltb+zxz0kkn5XOf+1zmzJnT77OWL1+eVatWDfXEA1YURSZOnJiNGzf2+rxWq6UoihxxxBGZPXt2rr322rz//e9Pa2vrPoXbk2Tx4sXp7u4e8s0LFy7MiSeeOOTPHYy2trZ84hOfyJNPPplGo1HpFgAAAAAAAAAAAAAAAAAAAAAAAAAAAIChpNWu1Z5otWu1902rHQAAAAAAAAAAAAAAAAAAAAAAAAAAABiptNq12hOtdq32vmm1jw5NVQ8AAAAAAAAAAAAAAAAAAAAAAAAAAACA4aJRT5bdkTS6k/M//ZaAey2ZdlJy2X9Lfv6/k3Urkryl37z1pZ6Y+q9/mEw7ted8Z0fSNDapdyf1es89tSIpimTM2GT84cnEacmM9yYzzk0mHd1/RL2rM1m9PPntncnzj/Y8d7AOOzI55dzknE8mrUcO/v6RbPXq1XnggQdy4YUX9nnmqKOOyhVXXJFx48b1eaZer+f+++/Prl27DsbMA9La2pqbb745L7/8cq/PjznmmEyfPj1tbW1pbm7u4+6+vfzyy/ne9743VDP/SVEU+Yu/+IsBA/L1ev2AoupFUQz4jmuuuSZf+cpX8tprr+33ewAAAAAAAAAAAAAAAAAAAAAAAAAAAACGI612tNq12vuj1Q4AAAAAAAAAAAAAAAAAAAAAAAAAAACMVFrtaLVrtfdHq33ka6p6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwnjUby26VJR0ey4JqeuPpuuwPuH/mPycNLkieWJvWuPZ+x67Vk9W+S1Y8lR5+dXPi5pGNn0r6jJxDfNDYZ15ocPiU58vikdXIyZoBicL2evLI2+cW3kxeeSDr3owk+/vDkHR9MZi1Ijjo5KcYM/hkj3Y4dO3Lvvfdm4cKFfYa8i6LI+PHj93ptt46OjixduvRgTDxgY8aMydy5c4f0mY1GIzfeeGO2bNkypM9NktNOOy0nn3xyv2c2b96cyy67LBs3btzv91x33XW5+uqr+w24T506NQsXLsytt9663+8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAGK602kc3rfb9o9UOAAAAAAAAAAAAAAAAAAAAAAAAAAAAcOjTah/dtNr3j1Y7I8UAv4oBAAAAAAAAAAAAAAAAAAAAAAAAAABg9GnUk9/dlWxZ3RNen3JcT7h9t8OnJgv+dXLq/OSem5JNz/Xcs+eDks7O5PQLet+/r+rdya5tyYY/JL+5PVm3IunqGORDasnhbcnZH0tmzE+OaEsKdeI+NRqN3Hfffdm6dWsmTZq038956aWXsmLFiqEbNox1d3fntttuy7e//e2D8vyrrroqLS0t/Z655ZZbct9996Ve39tfxH3zta99LVdeeeWAYf7Pf/7zWbJkyR7vOuqoozJ79uzs3Lkzjz/+eLZu3brfWwAAAAAAAAAAAAAAAAAAAAAAAAAAAACqotU+emm1D55Wew+tdgAAAAAAAAAAAAAAAAAAAAAAAAAAAGAk0GofvbTaB0+rvYdW+8jg1yMAAAAAAAAAAAAAAAAAAAAAAAAAAADsTSNZ/1Ry658n513dE2pvflPTeUxTcuIZyZ/+z+SZB5NHb022rEk6Xz/A1zaSbZt6Qu1rVyTPP5a8sr5nzz6rJeMOS6aenMz+Z8kp5/TsZd+sWLEiq1atyllnnbXfz7j55pvT1dU1hKuGp0ajkSVLluTaa6/N9u3bh/z5bW1t+eAHP5haP//6wc6dO3P77bcfULg9SVauXJnnnnsus2bN6vfcqaeemne961154okn/umzc845J2eccUaef/75NDU15TOf+Ux+9KMf5YUXXjigTQAAAAAAAAAAAAAAAAAAAAAAAAAAAACV0GoftbTa951Wew+tdgAAAAAAAAAAAAAAAAAAAAAAAAAAAGBE0WoftbTa951Wew+t9pHDr0oAAAAAAAAAAAAAAAAAAAAAAAAAAADox7aXkn/8H8mqR5Pzr0kOn9L7+pjmZNb5yYyzk7W/S/74SE/0fcu6pLM9qRX9P79RT9p3Jhuf7wm1v/iHZMvaZOeWpKtjcFvHNCdTTkhOnJPMmJscc1rPZwzO9u3bs2zZsv2Ot3d1dWXJkiVDvGr46erqyqJFi/KFL3whr7766kF5x+zZszNz5sx+zzzxxBNZsWLFAb+rXq9n8eLFufHGG/s919ramo9+9KNZvnx5Go1Gxo0bl6OPPjr33XdfPvWpT+WFF17IHXfckU9+8pMDPgsAAAAAAAAAAAAAAAAAAAAAAAAAAABgONNqH3202veNVrtWOwAAAAAAAAAAAAAAAAAAAAAAAAAAADCyabWPPlrt+0arXat9JGqqegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMd13tyVN3J6ufSM67KjnlnGTcYUmt9saZsS3J2+cmb3tP0r4j2bY52bk1Wfv75Lbrk/GTkqbmnlh7V2eyY0uy85Vkx9ak8/Wk3tVzbbCKpmTS9ORdH0pOPCuZeFQyvnXgaDz9W7RoUa6++uoUxeC/kStWrMizzz57EFZVr9FoZOfOnVm5cmW+9KUv5a677kpXV9dBeVdzc3OuvPLKtLS09LvnnnvuyZYtW4bknT/4wQ/y5S9/OePHj+/zTFEUueSSS/LNb34zGzZsSHNzczZu3JitW7fmve99byZMmJBFixZl7NixKYoi9fp+/MUGAAAAAAAAAAAAAAAAAAAAAAAAAAAAGCa02kcfrfa902rXagcAAAAAAAAAAAAAAAAAAAAAAAAAAABGF6320Uerfe+02rXaR7qmqgcAAAAAAAAAAAAAAAAAAAAAAAAAAADAoWLHpuQf/nvy8A+Tdy9MTj03mXR071B6MSaZcETPV5KseTxZtWzoNoxpTsZOSI48Npl5XjLz/clhk3qH5IeTer0+YLy60Wgc0DsajUa/76jX64N+x2OPPZZNmzalra1t0Hu+//3vp729fdD37Vav11Pr539of3+egb4X+6rRaKS7uzsdHR157bXXsn79+jz33HP54x//mLvuuiu//vWv09HRMajnDfTneqtjjz02l156abq7u/s8s23btvzkJz854J+h3V588cXce++9+dCHPtTvuZkzZ2bevHn58Y9/nM7OzkydOjWbN2/OokWL0t7enra2tuzcuVO4HQAAAAAAAAAAAAAAAAAAAAAAAAAAABgxtNoHT6t98LTae2i1AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAwfWu2Dp9U+eFrtPbTaqUKtsY8/TYP5YQYAAAAAAAAAAAAAAAAAAAAAAAAAAICRrlZLjjg6Of6M5PTzkuPfnTQ173nu/kXJQ9/f//eMaUomTEwmHpNMPiY54czkuHcmh0/pCcWX5e5vJo/dMbh7WlpaMn/+/DQ37+Ub8ya///3vs3r16v3aVavVMmfOnEyZMqXfc88880xWrVo1qGfPmzcvkyZNGvSmxx57LBs3bhz0fUkyfvz4XHDBBf2eaTQa+d3vfpd169btca2trS1z5szZr3e/+fn1ej07duzItm3b8vrrr2fr1q3ZunVrOjo69iuUPnny5MydO3fAcw899FC2bt2aJJk2bVrOPPPMfs+3t7fnwQcfTGdn56A39WXGjBl5+9vfPuC5VatW5dlnn02SnH322Zk3b14effTRTJo0KXPnzs1NN92UDRs2DNmukey8q5N5Hz/47/nqwv2P/Gu1AwAAAAAAAAAAAAAAAAAAAAAAAAAAwBu02gem1T54Wu1a7aORVjsAAAAAAAAAAAAAAAAAAAAAAAAAAAAcWrTaB6bVPnha7Vrto9FwarXXGvv4Ey7eDgAAAAAAAAAAAAAAAAAAAAAAAAAAAHtXjElajkxOOCM5ZX5y7DuS5glJUUse+kHy8D7G22tjkvGtycRpybRTkmNmJhOPTlqnJIe3Jc3jeqLxVdifeDuMFrVaLZMnT84xxxyTrq6urFmzJtu3b6961iFjOMXb+6LVDgAAAAAAAAAAAAAAAAAAAAAAAAAAAHun1Q6jm1b7gdFqBwAAAAAAAAAAAAAAAAAAAAAAAAAAgEOXVjuMblrtB2Y4tdqbDv4MAAAAAAAAAAAAAAAAAAAAAAAAAAAAGNnq3cn2TclTd/d81Ypk3GFJy6RkyunJSfOT9leT9h0918a2JONakiOmJS2TkynHJdNmJK2Tk+axSWpJUfScBYa/RqORzZs3Z/PmzVVPAQAAAAAAAAAAAAAAAAAAAAAAAAAAACiVVjuMblrtAAAAAAAAAAAAAAAAAAAAAAAAAAAAwGil1Q6jm1b7yNFU9QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYaRr15PVtPV+1tuTTNya1WtWrAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOLq12AAAAAAAAAAAAAAAAAAAAAAAAAAAAAGA00moHODQVVQ8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAshRVDwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICyFFUPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgLIUVQ8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAsjRVPQAAAAAAAAAAAAAAAAAAAAAAAAAAAABGsh0vJHd/PUmt6iUHZu2TVS8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4lWu0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAwGik1Q5w6GiqegAAAAAAAAAAAAAAAAAAAAAAAAAAAACMZK9vTpbdWfUKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIByabUDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKORVjvAoaOoegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUpah6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJSlqHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlKWoegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUpah6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJSlqHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlKWoegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUpah6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJSlqHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlKWoegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUpah6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJSlqHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlKWoegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUpah6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJSlqHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlKWoegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUpah6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJSlqHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlKWoegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUpah6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJSlqHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlKWoegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUpah6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJSlqHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlKWoegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUpah6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJSlqHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlKWoegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUpah6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJSlqHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlKWoegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUpah6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJSlqHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlKWoegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUpah6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJSlqHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlKWoegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUpah6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJSlqHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlKWoegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUpah6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJSlqHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlKWoegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUpah6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJSlqHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlKWoegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUpah6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJSlqHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlKWoegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUpah6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJSlqHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlKWoegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUpah6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJSlqHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlKWoegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUpah6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJSlqHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlKWoegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUpah6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJSlqHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlKWoegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUpah6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJSlqHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlKWoegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUpah6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJSlqHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlKWoegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUpah6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJSlqHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlKWoegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUpah6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJSlqHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlKWoegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUpah6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJSlqHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlKWoegAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACUpah6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJSlqHoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlKWoesD/b+eObRAGABgICgMSBfuvG0aAAmyk3NUufgIDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAS9YBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0JJ1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALRkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtWQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAS9YBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0JJ1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALRkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtWQcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAS9YBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0JJ1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALRkHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtt0+Hj+fllx0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAld78c64S1f7QAAAAAAAAAAAAAAAAAAAAAAAAAAAADAt/lqBwAAAAAAAAAAAAAAAAAAAAAAAAAAAADO6J++2i/HcfxPDQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPxQ1gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQknUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtGQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC1ZBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBL1gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQknUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtGQdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC1ZBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBL1gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADQ8gLvUz6cVmfLlwAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import math\n", - "\n", - "pages_show = pages[4:10]\n", - "n = len(pages_show)\n", - "cols = 3\n", - "rows = math.ceil(n / cols)\n", - "\n", - "# PIL uses (width, height)\n", - "w, h = pages_show[0].size\n", - "\n", - "# Match figure size to image resolution\n", - "plt.figure(figsize=(w/100 * cols, h/100 * rows), dpi=100)\n", - "\n", - "for i, img in enumerate(pages_show, 1):\n", - " plt.subplot(rows, cols, i)\n", - " plt.imshow(img, interpolation='none') # no resampling\n", - " plt.axis('off')\n", - "\n", - "plt.tight_layout()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "BYg5RZp5F8vm" - }, - "source": [ - "> Best Practice: For simple extractive Questions, recommend turning OFF reasoning, and setting temperature=0.0" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "KRL9R6T086oK", - "outputId": "621979c6-2d75-4de7-9e6d-4c2a503c62b0" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Data Center business grew by 56% year-over-year (Y/Y) and 5% quarter-over-quarter (Q/Q) in Q2 FY26.\n" - ] - } - ], - "source": [ - "image_data_urls = [encode_pil_to_jpeg_data_url(page) for page in pages]\n", - "image_data_urls = image_data_urls[4:10]\n", - "text_prompt = \"How much did Data Center business grow in Q2 FY26?\"\n", - "reasoning_mode = False\n", - "temperature = 0.0\n", - "max_tokens=1024\n", - "\n", - "call_nemotron_nano_2_vl(image_urls=image_data_urls, video_urls=[], text_prompt=text_prompt, reasoning_mode=reasoning_mode, temperature=temperature, max_tokens=max_tokens)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "ijwKP9GUGFbc" - }, - "source": [ - "> Best Practice: For multi-step, multi-image reasoning, recommend turning ON reasoning, and setting temperature=0.6 (Always recommend to set temperature to 0.6 with reasoning)." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "SKJlbo5VLZrJ", - "outputId": "fc237909-8e48-409c-8897-a0c5b0615e61" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Okay, let's see. The user is asking which business unit had the most growth year-over-year (Y/Y). The text provided is from a document with different sections. Let me go through each section to find the Y/Y growth percentages.\n", - "\n", - "First, the Highlights section mentions \"Record quarter exceeded our outlook...\" with Data Center up 56% Y/Y and Gaming up 49% Y/Y. Then, the Data Center section says \"56% Y/Y\" again. The Gaming section states \"49% Y/Y\". The Professional Visualization section has \"32% Y/Y\" and Automotive \"69% Y/Y\". \n", - "\n", - "Wait, the Automotive section's Y/Y growth is 69%, which is higher than Data Center's 56% and Gaming's 49%. But I need to check if there are other business units mentioned. The Professional Visualization is 32%, so lower. The Automotive section's Y/Y is 69%, which is the highest among all listed. But wait, the user is asking for the business unit with the most growth. Let me confirm each section's Y/Y:\n", - "\n", - "- Data Center: 56% Y/Y\n", - "- Gaming: 49% Y/Y\n", - "- Professional Visualization: 32% Y/Y\n", - "- Automotive: 69% Y/Y\n", - "\n", - "So Automotive has the highest Y/Y growth at 69%. But wait, the user might be referring to the main business units. The initial Highlights mention Data Center and Gaming, but the other sections are separate. The answer should be Automotive with 69% Y/Y. However, I need to make sure that the Automotive section is considered a business unit here. The text lists \"Automotive\" as a section, so it's a business unit. Therefore, the answer is Automotive with 69% Y/Y.\n", - "] 9.96M --.-KB/s in 0.1s \n", - "\n", - "2025-10-20 15:41:08 (94.9 MB/s) - ‘test-00000-of-00001-56af6bd5ff7eb34d.parquet.1’ saved [10441675/10441675]\n", - "\n" - ] - } - ], - "source": [ - "import pyarrow.parquet as pq\n", - "import matplotlib.pyplot as plt\n", - "import io\n", - "\n", - "!wget https://huggingface.co/datasets/katanaml-org/invoices-donut-data-v1/resolve/main/data/test-00000-of-00001-56af6bd5ff7eb34d.parquet\n", - "\n", - "table = pq.read_table(\"test-00000-of-00001-56af6bd5ff7eb34d.parquet\")\n", - "df = table.to_pandas()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 1000 - }, - "id": "EOFp_E8E5Cwh", - "outputId": "c8ba6815-63c1-4b7f-fc26-49d0cd460849" - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from PIL import Image\n", - "import io\n", - "\n", - "img_bytes = df.loc[6, 'image']['bytes']\n", - "img1 = Image.open(io.BytesIO(img_bytes))\n", - "img1_url = encode_pil_to_jpeg_data_url(img1)\n", - "\n", - "img_bytes = df.loc[8, 'image']['bytes']\n", - "img2 = Image.open(io.BytesIO(img_bytes))\n", - "img2_url = encode_pil_to_jpeg_data_url(img2)\n", - "\n", - "img_bytes = df.loc[10, 'image']['bytes']\n", - "img3 = Image.open(io.BytesIO(img_bytes))\n", - "img3_url = encode_pil_to_jpeg_data_url(img3)\n", - "\n", - "img_bytes = df.loc[12, 'image']['bytes']\n", - "img4 = Image.open(io.BytesIO(img_bytes))\n", - "img4_url = encode_pil_to_jpeg_data_url(img4)\n", - "\n", - "# Display 4 images in a 2x2 grid with better quality\n", - "plt.figure(figsize=(10, 10), dpi=200)\n", - "\n", - "images = [img1, img2, img3, img4]\n", - "\n", - "for i, img in enumerate(images, 1):\n", - " plt.subplot(2, 2, i)\n", - " plt.imshow(img, interpolation='nearest') # disables blurring\n", - " plt.axis('off')\n", - "\n", - "plt.tight_layout()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "O5BulBejSuZL" - }, - "source": [ - "We are now ready to prompt the model.\n", - "\n", - "> Best Practice: For Multi-Image Reasoning, use reasoning with temperature 0.6" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "I8VWny905Bmb", - "outputId": "b53d9e0e-00c9-4bb8-bd87-c687bac1c8a0" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "To solve the problem, we need to sum up all the totals across the receipts provided in the images. Let's go through each receipt step by step and extract the total gross worth.\n", - "\n", - "### Receipt 1:\n", - "- **Invoice no:** 26343874\n", - "- **Date of issue:** 07/17/2013\n", - "- **Total Gross Worth:** $3,490.29\n", - "\n", - "### Receipt 2:\n", - "- **Invoice no:** 25698672\n", - "- **Date of issue:** 08/01/2015\n", - "- **Total Gross Worth:** $127.00\n", - "\n", - "### Receipt 3:\n", - "- **Invoice no:** 72455228\n", - "- **Date of issue:** 05/11/2021\n", - "- **Total Gross Worth:** $2,155.98\n", - "\n", - "### Receipt 4:\n", - "- **Invoice no:** 90508672\n", - "- **Date of issue:** 04/16/2020\n", - "- **Total Gross Worth:** $7,052.49\n", - "\n", - "### Summing Up the Totals:\n", - "Now, we add up all the total gross worth values from each receipt:\n", - "\n", - "\\[\n", - "3,490.29 + 127.00 + 2,155.98 + 7,052.49\n", - "\\]\n", - "\n", - "#### Step-by-Step Calculation:\n", - "1. \\( 3,490.29 + 127.00 = 3,617.29 \\)\n", - "2. \\( 3,617.29 + 2,155.98 = 5,773.27 \\)\n", - "3. \\( 5,773.27 + 7,052.49 = 12,825.76 \\)\n", - "\n", - "### Final Answer:\n", - "The sum of all the totals across the receipts is:\n", - "\n", - "\\[\n", - "\n", - "12825.76\n", - "\\]12825.76\n", - "\\\n" - ] - } - ], - "source": [ - "text_prompt = \"Sum up all the totals across the reciepts.\"\n", - "reasoning_mode = True\n", - "temperature = 0.6\n", - "max_tokens=32000\n", - "\n", - "call_nemotron_nano_2_vl([img1_url, img2_url, img3_url, img4_url], video_urls=[], text_prompt=text_prompt, reasoning_mode=reasoning_mode, temperature=temperature, max_tokens=max_tokens)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "BaLEVDKlGfSw" - }, - "source": [ - "You may want to audit your invoices, or insurance claims, and can ask the VLM to exactly do that." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "-Lb7TeP5RYyh" - }, - "outputs": [], - "source": [ - "text_prompt = \"Here are 4 invoices flagged as potential duplicates — are they actually the same document with minor layout differences?\"\n", - "reasoning_mode = True\n", - "temperature = 0.6\n", - "max_tokens=32000\n", - "\n", - "call_nemotron_nano_2_vl([img1_url, img2_url, img3_url, img4_url], video_urls=[], text_prompt=text_prompt, reasoning_mode=reasoning_mode, temperature=temperature, max_tokens=max_tokens)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "GXgvld5bMeUe" - }, - "source": [ - "### Video Understandig\n", - "\n", - "With long context, and enhanced reasoning capabilites, this model is now capable of providing high quality dense captions for videos.\n", - "\n", - "This model also introduces Efficient Video Sampling (EVS) method that identifies and prunes temporally static patches in video sequences. EVS reduces token redundancy, preserving essential semantics, for the model to process longer clips and deliver results more swiftly." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "J4-AWx3ZJQwO", - "outputId": "fa7e638c-ab0c-4819-c8e7-c3edeb9c6af8" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "This video demonstrates a 3D model of a hut surrounded by trees and snow. The hut is brown with a snow-covered roof. The surrounding area is covered in snow, with scattered logs and rocks. A person is standing outside the hut, and there is a table with a pot on it. The trees are tall and dark green, and the sky is overcast. The video is shot from a top-down perspective, and the model is rotating to show different angles.\n" - ] - } - ], - "source": [ - "text_prompt = \"Describe this video in detail\"\n", - "reasoning_mode = False\n", - "temperature = 0.0\n", - "max_tokens=4096\n", - "\n", - "call_nemotron_nano_2_vl(image_urls=[], video_urls=['https://blogs.nvidia.com/wp-content/uploads/2023/04/nvidia-studio-itns-wk53-scene-in-omniverse-1280w.mp4'], text_prompt=text_prompt, reasoning_mode=reasoning_mode, temperature=temperature, max_tokens=max_tokens)" - ] - } - ], - "metadata": { - "colab": { - "provenance": [] - }, - "kernelspec": { - "display_name": "Python 3", - "name": "python3" - }, - "language_info": { - "name": "python" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} diff --git a/usage-cookbook/Nemotron-Nano2-VL/vllm_cookbook.ipynb b/usage-cookbook/Nemotron-Nano2-VL/vllm_cookbook.ipynb deleted file mode 100644 index 887eeb5..0000000 --- a/usage-cookbook/Nemotron-Nano2-VL/vllm_cookbook.ipynb +++ /dev/null @@ -1,368 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Running NVIDIA Nemotron Nano 2 VL with vLLM\n", - "\n", - "This notebook will walk you through how to run the `nvidia/Nemotron-Nano-12B-v2-VL-BF16` model locally with vLLM.\n", - "\n", - "[vLLM](https://docs.vllm.ai) is a fast and easy-to-use library for LLM inference and serving. \n", - "\n", - "For more details on the model [click here](TODO)\n", - "\n", - "Prerequisites:\n", - "- NVIDIA GPU with recent drivers (≥ 24 GB VRAM recommended; BF16-capable) and CUDA 12.x \n", - "- Python 3.10+" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Prerequisites & environment\n", - "\n", - "Set up a clean Python environment for running vLLM locally.\n", - "\n", - "Create and activate a virtual environment. The sample here uses Conda but feel free to choose whichever tool you prefer.\n", - "Run these commands in a terminal before using this notebook:\n", - "\n", - "```bash\n", - "conda create -n nemotron-vllm-env python=3.10 -y\n", - "conda activate nemotron-vllm-env\n", - "```\n", - "\n", - "If running notebook locally, install ipykernel and switch the kernel to this environment:\n", - "- Installation\n", - "```bash\n", - "pip install ipykernel\n", - "```\n", - "- Kernel → Change kernel → Python (nemotron-vllm-env)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Install dependencies" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "!VLLM_USE_PRECOMPILED=1 pip install git+https://github.com/vllm-project/vllm.git@main" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Verify GPU\n", - "\n", - "Confirm CUDA is available and your GPU is visible to PyTorch.\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# GPU environment check\n", - "import torch\n", - "print(f\"CUDA available: {torch.cuda.is_available()}\")\n", - "print(f\"Num GPUs: {torch.cuda.device_count()}\")\n", - "if torch.cuda.is_available():\n", - " for i in range(torch.cuda.device_count()):\n", - " print(f\"GPU[{i}]: {torch.cuda.get_device_name(i)}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Load the model\n", - "Initialize the Nemotron model in vLLM with BF16 for efficient GPU inference." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from vllm import LLM\n", - "\n", - "vlm = LLM(\n", - " model=\"nvidia/Nemotron-Nano-12B-v2-VL-BF16\",\n", - " trust_remote_code=True,\n", - " dtype=\"bfloat16\",\n", - ")\n", - "\n", - "print(\"Model ready\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Generate responses\n", - "\n", - "Once the model is loaded successfully above, you can continue with text generation:\n", - "\n", - "### Single or batch prompts\n", - "\n", - "Send one prompt or a list to run batched generation." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from vllm import SamplingParams\n", - "from PIL import Image\n", - "import requests\n", - "from io import BytesIO\n", - "\n", - "params = SamplingParams(temperature=0.0, max_tokens=1024)\n", - "\n", - "image1 = Image.open(\"example_image1.png\")\n", - "\n", - "# Single prompt\n", - "single = vlm.generate({\n", - " \"prompt\": \"\\nDescribe the image in detail.\",\n", - " \"multi_modal_data\": {\"image\": image1}}, sampling_params=params)\n", - "print(single[0].outputs[0].text)\n", - "\n", - "\n", - "# Batch prompts\n", - "image2 = Image.open(\"example_image2.png\")\n", - "prompts = [\n", - " {\n", - " \"prompt\": \"\\nDescribe the image in detail.\",\n", - " \"multi_modal_data\": {\"image\": image1}\n", - " },\n", - " {\n", - " \"prompt\": \"\\nWhat color bars are used in the image?\",\n", - " \"multi_modal_data\": {\"image\": image2}\n", - " }\n", - "]\n", - "outputs = vlm.generate(prompts, sampling_params=params)\n", - "for i, out in enumerate(outputs):\n", - " print(f\"\\nPrompt {i+1}: {out.prompt!r}\")\n", - " print(out.outputs[0].text)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Streamed generation\n", - "\n", - "Printing characters as they are produced." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "def stream_like(prompt: str, llm: LLM, sampling_params: SamplingParams) -> None:\n", - " outputs = llm.generate([prompt], sampling_params=sampling_params)\n", - " text = outputs[0].outputs[0].text\n", - " print(\"Response:\", end=\" \")\n", - " for ch in text:\n", - " print(ch, end=\"\", flush=True)\n", - " print()\n", - "\n", - "stream_like(\"Write a haiku about GPUs.\", vlm, SamplingParams(temperature=0.7, max_tokens=80))\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## OpenAI-compatible server \n", - "\n", - "Serve the model via an OpenAI-compatible API using vLLM.\n", - "\n", - "Before starting the server:\n", - "- Restart the kernel to free GPU memory used by the in-process LLM\n", - "- Ensure you use the same virtual environment with installed dependancies in your terminal\n", - "- Use `--video-pruning-rate` to set EVS. The default EVS is 0." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "After restarting the kernel, run this in a terminal:\n", - "\n", - "```shell\n", - "git clone https://huggingface.co/nvidia/Nemotron-Nano-12B-v2-VL-BF16\n", - "git clone https://huggingface.co/nvidia/NVIDIA-Nemotron-Nano-9B-v2\n", - "\n", - "vllm serve nvidia/Nemotron-Nano-12B-v2-VL-BF16 --trust-remote-code --dtype bfloat16 --enable-auto-tool-choice --tool-parser-plugin \"NVIDIA-Nemotron-Nano-9B-v2/nemotron_toolcall_parser_no_streaming.py\" --tool-call-parser \"nemotron_json\"\n", - "```" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Your server is now running! " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Use the API\n", - "\n", - "Send chat and streaming requests to your local vLLM server using the OpenAI-compatible client." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Note: The model supports two modes - Reasoning ON (default) vs OFF. These can be toggled by passing /think vs /no_think as a part of the \"system\" message. \n", - "\n", - "The /think or /no_think keywords can also be provided in “user” messages for turn-level reasoning control." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Client: Standard chat and streaming\n", - "from openai import OpenAI\n", - "\n", - "client = OpenAI(base_url=\"http://127.0.0.1:8033/v1\", api_key=\"null\")\n", - "\n", - "# Simple chat completion\n", - "resp = client.chat.completions.create(\n", - " model=\"nvidia/Nemotron-Nano-12B-v2-VL-BF16\",\n", - " messages=[\n", - " {\"role\": \"system\", \"content\": \"/think\"},\n", - " {\"role\": \"user\", \"content\": [\n", - " {\"type\": \"text\", \"text\": \"Give me 3 interesting facts about this image.\"}, \n", - " {\"type\": \"image_url\", \"image_url\": {\"url\": \"https://blogs.nvidia.com/wp-content/uploads/2025/08/gamescom-g-assist-nv-blog-1280x680-1.jpg\"}\n", - " }\n", - " ]},\n", - " ],\n", - " temperature=0.6,\n", - " max_tokens=1024,\n", - ")\n", - "print(resp.choices[0].message.content)\n", - "\n", - "# Streaming chat completion\n", - "stream = client.chat.completions.create(\n", - " model=\"nvidia/Nemotron-Nano-12B-v2-VL-BF16\",\n", - " messages=[\n", - " {\"role\": \"system\", \"content\": \"/no_think\"},\n", - " {\"role\": \"user\", \"content\": [\n", - " {\"type\": \"text\", \"text\": \"Describe this video in detail.\"}, \n", - " {\"type\": \"video_url\", \"video_url\": {\"url\": \"https://blogs.nvidia.com/wp-content/uploads/2023/04/nvidia-studio-itns-wk53-scene-in-omniverse-1280w.mp4\"}\n", - " }\n", - " ]},\n", - " ],\n", - " temperature=0.0,\n", - " max_tokens=1024,\n", - " stream=True,\n", - ")\n", - "for chunk in stream:\n", - " delta = chunk.choices[0].delta\n", - " if delta and delta.content:\n", - " print(delta.content, end=\"\", flush=True)\n", - "print()\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Tool calling\n", - "\n", - "Call functions using the OpenAI Tools schema and inspect returned tool_calls." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Tool calling via OpenAI tools schema\n", - "TOOLS = [\n", - " {\n", - " \"type\": \"function\",\n", - " \"function\": {\n", - " \"name\": \"calculate_tip\",\n", - " \"parameters\": {\n", - " \"type\": \"object\",\n", - " \"properties\": {\n", - " \"bill_total\": {\n", - " \"type\": \"integer\",\n", - " \"description\": \"The total amount of the bill\"\n", - " },\n", - " \"tip_percentage\": {\n", - " \"type\": \"integer\",\n", - " \"description\": \"The percentage of tip to be applied\"\n", - " }\n", - " },\n", - " \"required\": [\"bill_total\", \"tip_percentage\"]\n", - " }\n", - " }\n", - " }\n", - "]\n", - "\n", - "completion = client.chat.completions.create(\n", - " model=\"nvidia/Nemotron-Nano-12B-v2-VL-BF16\",\n", - " messages=[\n", - " {\"role\": \"system\", \"content\": \"/think\"},\n", - " {\"role\": \"user\", \"content\": \"My bill is $50. What will be the amount for 15% tip?\"}\n", - " ],\n", - " tools=TOOLS,\n", - " temperature=0.6,\n", - " top_p=0.95,\n", - " max_tokens=32768,\n", - " stream=False\n", - ")\n", - "\n", - "print(completion.choices[0].message.content)\n", - "print(completion.choices[0].message.tool_calls)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "nemotron-vllm-env", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.19" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/usage-cookbook/Nemotron-Parse-v1.1/build_general_usage_cookbook.ipynb b/usage-cookbook/Nemotron-Parse-v1.1/build_general_usage_cookbook.ipynb deleted file mode 100644 index 3396bc0..0000000 --- a/usage-cookbook/Nemotron-Parse-v1.1/build_general_usage_cookbook.ipynb +++ /dev/null @@ -1,1365 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 14, - "id": "3596c634", - "metadata": { - "id": "I-rch2mj7m82" - }, - "outputs": [], - "source": [ - "# Copyright 2025 NVIDIA Corporation. All Rights Reserved.\n", - "#\n", - "# Licensed under the Apache License, Version 2.0 (the \"License\");\n", - "# you may not use this file except in compliance with the License.\n", - "# You may obtain a copy of the License at\n", - "#\n", - "# http://www.apache.org/licenses/LICENSE-2.0\n", - "#\n", - "# Unless required by applicable law or agreed to in writing, software\n", - "# distributed under the License is distributed on an \"AS IS\" BASIS,\n", - "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n", - "# See the License for the specific language governing permissions and\n", - "# limitations under the License.\n", - "# ==============================================================================" - ] - }, - { - "cell_type": "markdown", - "id": "68d0ba67", - "metadata": {}, - "source": [ - "\n", - "\n", - "# Nemotron Parse: From Complex Documents to Agent-Ready Data\n", - "\n", - "NVIDIA Nemotron Parse (also known as NeMo Retriever Parse) is a transformer-based VLM specialized for document parsing. Think of it as the ingestion backbone for your AI agent. Its job is to:\n", - "- Accurately extract text and formulas in correct reading order.\n", - "- Robustly parse complex tables into a structured format (like LaTeX).\n", - "- Perform semantic segmentation (labeling Title, Text, List-item, Figure, etc.).\n", - "- Provide spatial grounding (a bbox for every element).\n", - "\n", - "It's built to preserve meaning and structure at scale, so your agent can act on the right information with confidence.\n", - "![image](https://i.imgur.com/pYLFOAd.png)\n", - "\n", - "---\n", - "\n", - "### What you’ll learn in this notebook:\n", - "* How to call Nemotron Parse on a PDF page image and get structured JSON.\n", - "* How to visualize the model's layout understanding.\n", - "* How to convert the model's output (including complex tables) into clean HTML and Markdown for RAG or agentic workflows.\n", - "* How this model complements a separate visual reasoning model in a full document AI agent.\n", - "\n", - "Note: This notebook focuses only on Nemotron Parse. Its job is to find what elements are on the page and where they are. If your workflow also needs to understand the visual content inside a Picture or Figure block (e.g., analyze a chart, describe a photo), you would pair Parse with a visual reasoning model in a second stage.\n", - "\n", - "Parse tells you where the image is; a reasoning model tells you what the image means." - ] - }, - { - "cell_type": "markdown", - "id": "f087b4bc", - "metadata": {}, - "source": [ - "## 0. Setup\n", - "\n", - "Install minimal dependencies for PDF rendering (PyMuPDF), API calls (requests), and visualization (Pillow)." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "7921625c", - "metadata": { - "id": "install-deps" - }, - "outputs": [], - "source": [ - "%pip install --quiet requests pillow pymupdf pandas markdown bleach" - ] - }, - { - "cell_type": "markdown", - "id": "1f2ebcb2", - "metadata": {}, - "source": [ - "### Configure API Endpoint\n", - "\n", - "This notebook uses the call_nemotron_parse function to call the NVIDIA API-compatible endpoint via the Chat Completions API.\n", - "\n", - "Requirements:\n", - "1) Set your NVIDIA_API_KEY as an environment variable.\n", - "2) Optionally set NVAI_URL to your NVIDIA API Gateway or local NIM gateway.\n", - "\n", - "The model returns a list of layout blocks with:\n", - "- type: e.g., \"Title\", \"Text\", \"List-item\", \"Table\", etc.\n", - "- text: the block's textual content (for tables, a LaTeX tabular string)\n", - "- bbox: normalized coordinates {xmin, ymin, xmax, ymax} in [0,1]" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "9881a584", - "metadata": { - "id": "imports-config" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Using API URL: https://integrate.api.nvidia.com/v1\n", - "Output directory: ./parse_outputs\n" - ] - } - ], - "source": [ - "import os\n", - "import re\n", - "import json\n", - "import base64\n", - "import requests\n", - "import fitz # PyMuPDF\n", - "from typing import List, Dict, Any, Tuple\n", - "from PIL import Image, ImageDraw, ImageFont\n", - "from io import BytesIO\n", - "import pandas as pd\n", - "from IPython.display import display, Markdown, HTML\n", - "\n", - "# API configuration\n", - "API_KEY = os.environ.get(\"NVIDIA_API_KEY\", \"YOUR_API_KEY_HERE\")\n", - "NVAI_URL = os.environ.get(\"NVAI_URL\", \"https://integrate.api.nvidia.com/v1\")\n", - "\n", - "if API_KEY == \"YOUR_API_KEY_HERE\":\n", - " print(\"WARNING: NVIDIA_API_KEY not set. Please set it to run the notebook.\")\n", - "\n", - "# Output directory for artifacts\n", - "OUTPUT_DIR = \"parse_outputs\"\n", - "os.makedirs(OUTPUT_DIR, exist_ok=True)\n", - "print(f\"Using API URL: {NVAI_URL}\")\n", - "print(f\"Output directory: {os.path.abspath(OUTPUT_DIR)}\")\n", - "\n", - "# Class color mapping for visualization\n", - "CLASS_COLORS = {\n", - " 'Title': '#D32F2F',\n", - " 'Section-header': '#E91E63',\n", - " 'Text': '#4CAF50',\n", - " 'List-item': '#1976D2',\n", - " 'Caption': '#607D8B',\n", - " 'Table': '#03A9F4',\n", - " 'Figure': '#6D4C41',\n", - " 'Picture': '#6D4C41',\n", - " 'Formula': '#FF9800',\n", - " 'Page-header': '#9E9E9E',\n", - " 'Page-footer': '#9E9E9E',\n", - " 'Footnote': '#00BCD4',\n", - " 'Bibliography': '#512DA8',\n", - " 'TOC': '#FFC107',\n", - " 'DEFAULT': '#9E9E9E'\n", - "}\n", - "\n", - "def get_text_color(hex_color: str) -> str:\n", - " \"\"\"Return black or white for best contrast over a hex background color.\"\"\"\n", - " hex_color = hex_color.lstrip('#')\n", - " r, g, b = tuple(int(hex_color[i:i+2], 16) for i in (0, 2, 4))\n", - " luminance = (0.2126 * r + 0.7152 * g + 0.0722 * b)\n", - " return \"#000000\" if luminance > 140 else \"#FFFFFF\"" - ] - }, - { - "cell_type": "markdown", - "id": "e1d247be", - "metadata": {}, - "source": [ - "## 1. Helper Functions\n", - "\n", - "Helpers for:\n", - "1) PDF-to-Image rendering.\n", - "2) API call via Chat Completions.\n", - "3) Visualization.\n", - "4) LaTeX tables to HTML and page-to-Markdown assembly." - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "4046f1fe", - "metadata": { - "id": "helpers" - }, - "outputs": [], - "source": [ - "from markdown import markdown\n", - "import bleach\n", - "\n", - "# PDF page rendering\n", - "def pdf_page_to_image(pdf_path: str, page_index: int, dpi: int = 300,\n", - " target_size: Tuple[int, int] = (1536, 2048)) -> Image.Image:\n", - " \"\"\"Render a PDF page to an RGB image and center it on a fixed-size canvas.\"\"\"\n", - " doc = fitz.open(pdf_path)\n", - " page = doc.load_page(page_index)\n", - " zoom = dpi / 72.0\n", - " pix = page.get_pixmap(matrix=fitz.Matrix(zoom, zoom))\n", - " src = Image.frombytes(\"RGB\", [pix.width, pix.height], pix.samples)\n", - " doc.close()\n", - "\n", - " canvas = Image.new(\"RGB\", target_size, (255, 255, 255))\n", - " src.thumbnail(target_size, Image.Resampling.LANCZOS)\n", - " x = (target_size[0] - src.width) // 2\n", - " y = (target_size[1] - src.height) // 2\n", - " canvas.paste(src, (x, y))\n", - " return canvas\n", - "\n", - "# Image encoding\n", - "def encode_image_to_base64(image: Image.Image, fmt: str = \"PNG\") -> str:\n", - " \"\"\"Encode a PIL image to base64 for API submission.\"\"\"\n", - " buf = BytesIO()\n", - " image.save(buf, format=fmt)\n", - " return base64.b64encode(buf.getvalue()).decode('utf-8')\n", - "\n", - "# Nemotron Parse API call\n", - "def call_nemotron_parse(base64_image: str) -> List[Dict[str, Any]]:\n", - " \"\"\"Call the nemotron-parse model and return a list of blocks with type/text/bbox.\"\"\"\n", - " headers = {\"Authorization\": f\"Bearer {API_KEY}\", \"Accept\": \"application/json\"}\n", - " messages = [{\n", - " \"role\": \"user\",\n", - " \"content\": [{\n", - " \"type\": \"image_url\",\n", - " \"image_url\": {\"url\": f\"data:image/png;base64,{base64_image}\"}\n", - " }]\n", - " }]\n", - " tools = [{\"type\": \"function\", \"function\": {\"name\": \"markdown_bbox\"}}]\n", - " payload = {\n", - " \"model\": \"nvidia/nemotron-parse\",\n", - " \"messages\": messages,\n", - " \"max_tokens\": 3500,\n", - " \"temperature\": 0,\n", - " \"tools\": tools\n", - " }\n", - " try:\n", - " resp = requests.post(f\"{NVAI_URL}/chat/completions\", headers=headers, json=payload, timeout=180)\n", - " resp.raise_for_status()\n", - " response_json = resp.json()\n", - " except requests.exceptions.HTTPError as e:\n", - " print(f\"API Error for nvidia/nemotron-parse: {e.response.status_code} - {e.response.text}\")\n", - " return []\n", - " except Exception as e:\n", - " print(f\"Unexpected error calling nemotron-parse: {e}\")\n", - " return []\n", - "\n", - " tool_call = response_json.get(\"choices\", [{}])[0].get(\"message\", {}).get(\"tool_calls\", [{}])[0]\n", - " if not tool_call:\n", - " return []\n", - " arguments_str = tool_call.get(\"function\", {}).get(\"arguments\", \"[]\")\n", - " try:\n", - " parsed_args = json.loads(arguments_str)\n", - " if isinstance(parsed_args, list) and len(parsed_args) > 0 and isinstance(parsed_args[0], list):\n", - " return parsed_args[0]\n", - " return parsed_args if isinstance(parsed_args, list) else []\n", - " except json.JSONDecodeError:\n", - " print(f\"Error decoding JSON from arguments: {arguments_str}\")\n", - " return []\n", - "\n", - "# Visualization\n", - "def draw_layout(image: Image.Image, blocks: List[Dict[str, Any]]) -> Image.Image:\n", - " \"\"\"Draw bounding boxes and labels for each parsed block.\"\"\"\n", - " out = image.copy()\n", - " draw = ImageDraw.Draw(out)\n", - " W, H = out.size\n", - " box_thickness = max(2, int(W / 600))\n", - " font_size = max(14, int(W / 80))\n", - " try:\n", - " font = ImageFont.truetype(\"Arial.ttf\", font_size)\n", - " except Exception:\n", - " font = ImageFont.load_default()\n", - "\n", - " for i, b in enumerate(blocks):\n", - " bbox = b.get(\"bbox\") or {}\n", - " xmin, ymin = bbox.get(\"xmin\", 0.0), bbox.get(\"ymin\", 0.0)\n", - " xmax, ymax = bbox.get(\"xmax\", 0.0), bbox.get(\"ymax\", 0.0)\n", - " if xmax <= xmin or ymax <= ymin:\n", - " continue\n", - " x0, y0, x1, y1 = xmin * W, ymin * H, xmax * W, ymax * H\n", - " cat = b.get(\"type\", \"DEFAULT\")\n", - " color = CLASS_COLORS.get(cat, CLASS_COLORS[\"DEFAULT\"])\n", - " text_color = get_text_color(color)\n", - " draw.rectangle([x0, y0, x1, y1], outline=color, width=box_thickness)\n", - " label = f\"{i}:{cat}\"\n", - " try:\n", - " tb = draw.textbbox((0, 0), label, font=font)\n", - " tw, th = tb[2] - tb[0], tb[3] - tb[1]\n", - " except Exception:\n", - " tw, th = draw.textsize(label, font=font)\n", - " label_bg = (x0, max(0, y0 - th - 6), x0 + tw + 8, max(0, y0 - 6))\n", - " draw.rectangle(label_bg, fill=color)\n", - " draw.text((label_bg[0] + 4, label_bg[1] + 2), label, fill=text_color, font=font)\n", - " return out\n", - "\n", - "# Records and DataFrame\n", - "def blocks_to_dataframe(blocks: List[Dict[str, Any]]) -> pd.DataFrame:\n", - " rows = []\n", - " for i, b in enumerate(blocks):\n", - " txt = (b.get(\"text\") or \"\").replace(\"\\n\", \" \")\n", - " rows.append({\n", - " \"id\": i,\n", - " \"type\": b.get(\"type\"),\n", - " \"text\": txt[:200],\n", - " \"bbox\": b.get(\"bbox\")\n", - " })\n", - " return pd.DataFrame(rows)\n", - "\n", - "def blocks_to_records(blocks: List[Dict[str, Any]], page_number: int, page_size_px: Tuple[int, int]) -> List[Dict[str, Any]]:\n", - " W, H = page_size_px\n", - " records = []\n", - " for i, b in enumerate(blocks):\n", - " bbox = b.get(\"bbox\") or {\"xmin\": 0, \"ymin\": 0, \"xmax\": 0, \"ymax\": 0}\n", - " x0, y0 = int(bbox.get(\"xmin\", 0) * W), int(bbox.get(\"ymin\", 0) * H)\n", - " x1, y1 = int(bbox.get(\"xmax\", 0) * W), int(bbox.get(\"ymax\", 0) * H)\n", - " records.append({\n", - " \"page\": page_number,\n", - " \"id\": i,\n", - " \"type\": b.get(\"type\"),\n", - " \"text\": b.get(\"text\"),\n", - " \"bbox_norm\": bbox,\n", - " \"bbox_px\": [x0, y0, x1, y1]\n", - " })\n", - " return records\n", - "\n", - "# LaTeX table parsing\n", - "def _clean_latex_text(s: str) -> str:\n", - " s = s.strip()\n", - " s = re.sub(r\"\\\\textbf\\{(.*?)\\}\", r\"\\1\", s)\n", - " s = re.sub(r\"\\\\textit\\{(.*?)\\}\", r\"\\1\", s)\n", - " replacements = {\n", - " r\"\\$\": \"$\",\n", - " r\"\\%\": \"%\",\n", - " r\"\\\\&\": \"&\",\n", - " r\"\\\\_\": \"_\",\n", - " r\"\\\\#\": \"#\",\n", - " r\"\\\\textless\": \"<\",\n", - " r\"\\\\textgreater\": \">\",\n", - " r\"\\\\newline\": \" \"\n", - " }\n", - " for k, v in replacements.items():\n", - " s = re.sub(k, v, s)\n", - " return s\n", - "\n", - "def _parse_cell_spans(cell: str) -> Tuple[str, int, int]:\n", - " \"\"\"Parse a cell for \\multicolumn and \\multirow; return (content, colspan, rowspan).\"\"\"\n", - " content = cell.strip()\n", - " colspan, rowspan = 1, 1\n", - " changed = True\n", - " while changed:\n", - " changed = False\n", - " m = re.match(r\"\\\\multicolumn\\{(\\d+)\\}\\{[^}]*\\}\\{(.*)\\}\\s*$\", content, flags=re.DOTALL)\n", - " if m:\n", - " colspan = int(m.group(1))\n", - " content = m.group(2).strip()\n", - " changed = True\n", - " continue\n", - " m = re.match(r\"\\\\multirow\\{(\\d+)\\}\\{[^}]*\\}\\{(.*)\\}\\s*$\", content, flags=re.DOTALL)\n", - " if m:\n", - " rowspan = int(m.group(1))\n", - " content = m.group(2).strip()\n", - " changed = True\n", - " continue\n", - " content = _clean_latex_text(content)\n", - " return content, colspan, rowspan\n", - "\n", - "def latex_table_to_html(latex_str: str) -> str:\n", - " \"\"\"Convert a LaTeX tabular into HTML. Fallbacks to raw pre if parsing fails.\"\"\"\n", - " try:\n", - " if not latex_str:\n", - " return \"\"\n", - " m = re.search(r\"\\\\begin\\{tabular\\}\\{[^}]*\\}(.*?)\\\\end\\{tabular\\}\", latex_str, flags=re.DOTALL)\n", - " content = m.group(1) if m else latex_str\n", - " content = re.sub(r\"\\\\hline\", \"\", content)\n", - " rows_raw = [r.strip() for r in re.split(r\"(?{latex_str}\"\n", - "\n", - " occupied = set()\n", - " table_rows = []\n", - " for r_idx, row_str in enumerate(rows_raw):\n", - " parts = [p.strip() for p in re.split(r\"(?\"]\n", - " for r_idx, cells in enumerate(table_rows):\n", - " html.append(\" \")\n", - " tag = 'th' if r_idx == 0 else 'td'\n", - " for cell in cells:\n", - " attrs = []\n", - " if cell[\"colspan\"] > 1:\n", - " attrs.append(f\"colspan=\\\"{cell['colspan']}\\\"\")\n", - " if cell[\"rowspan\"] > 1:\n", - " attrs.append(f\"rowspan=\\\"{cell['rowspan']}\\\"\")\n", - " attr_str = (\" \" + \" \".join(attrs)) if attrs else \"\"\n", - " html.append(f\" <{tag}{attr_str}>{cell['content']}\")\n", - " html.append(\" \")\n", - " html.append(\"\")\n", - " return \"\\n\".join(html)\n", - " except Exception as e:\n", - " print(f\"Warning: Could not parse LaTeX table. Returning raw. Error: {e}\")\n", - " return f\"
{latex_str}
\"\n", - "\n", - "# Markdown assembly and rendering\n", - "def clean_md(text: str) -> str:\n", - " text = re.sub(r'\\\\([#>*_`~\\-+\\!\\[\\]\\(\\)])', r'\\1', text)\n", - " text = text.replace('•', '-')\n", - " return text.strip()\n", - "\n", - "def blocks_to_markdown_page(blocks: List[Dict[str, Any]]) -> str:\n", - " \"\"\"Build a Markdown string for the page. Tables are injected as raw HTML.\"\"\"\n", - " md_lines = []\n", - " in_list = False\n", - " for b in blocks:\n", - " cat = b.get(\"type\", \"Text\")\n", - " text = (b.get(\"text\") or \"\").strip()\n", - " if not text:\n", - " continue\n", - "\n", - " if cat == \"Table\":\n", - " if in_list:\n", - " md_lines.append(\"\")\n", - " in_list = False\n", - " html_tbl = latex_table_to_html(text)\n", - " md_lines.append(html_tbl)\n", - " md_lines.append(\"\")\n", - " continue\n", - "\n", - " if cat == \"Formula\":\n", - " if in_list:\n", - " md_lines.append(\"\")\n", - " in_list = False\n", - " md_lines.append(f\"
$$ {text} $$
\")\n", - " md_lines.append(\"\")\n", - " continue\n", - "\n", - " t = clean_md(text)\n", - "\n", - " if cat == \"Title\":\n", - " line = t if t.lstrip().startswith(\"#\") else f\"# {t}\"\n", - " if in_list:\n", - " md_lines.append(\"\")\n", - " in_list = False\n", - " md_lines.append(line)\n", - " md_lines.append(\"\")\n", - " continue\n", - "\n", - " if cat == \"Section-header\":\n", - " line = t if t.lstrip().startswith(\"##\") else f\"## {t}\"\n", - " if in_list:\n", - " md_lines.append(\"\")\n", - " in_list = False\n", - " md_lines.append(line)\n", - " md_lines.append(\"\")\n", - " continue\n", - "\n", - " if cat == \"List-item\":\n", - " md_lines.append(f\"- {t}\")\n", - " in_list = True\n", - " continue\n", - "\n", - " if cat == \"Caption\":\n", - " if in_list:\n", - " md_lines.append(\"\")\n", - " in_list = False\n", - " md_lines.append(f\"> Caption: {t}\")\n", - " md_lines.append(\"\")\n", - " continue\n", - "\n", - " if cat == \"Footnote\":\n", - " if in_list:\n", - " md_lines.append(\"\")\n", - " in_list = False\n", - " md_lines.append(f\"

[Footnote] {t}

\")\n", - " md_lines.append(\"\")\n", - " continue\n", - "\n", - " md_lines.append(t)\n", - " md_lines.append(\"\")\n", - "\n", - " if in_list:\n", - " md_lines.append(\"\")\n", - " return \"\\n\".join(md_lines).strip()\n", - "\n", - "def render_markdown_to_html(md_text: str) -> str:\n", - " \"\"\"Render Markdown to HTML, then sanitize while allowing table-related tags.\"\"\"\n", - " html = markdown(md_text, extensions=[\"extra\", \"sane_lists\"])\n", - " allowed_tags = [\n", - " \"h1\",\"h2\",\"h3\",\"h4\",\"h5\",\"h6\",\"p\",\"em\",\"strong\",\"code\",\"pre\",\"blockquote\",\"br\",\n", - " \"ul\",\"ol\",\"li\",\n", - " \"table\",\"thead\",\"tbody\",\"tr\",\"th\",\"td\"\n", - " ]\n", - " allowed_attrs = {\"table\": [\"border\", \"class\"], \"td\": [\"colspan\",\"rowspan\"], \"th\": [\"colspan\",\"rowspan\"]}\n", - " return bleach.clean(html, tags=allowed_tags, attributes=allowed_attrs, strip=True)" - ] - }, - { - "cell_type": "markdown", - "id": "adc2c212", - "metadata": {}, - "source": [ - "## 2. Quickstart: Parse a Sample PDF\n", - "\n", - "We’ll fetch a PDF that mixes text, a table, headers, lists, and a footnote. For each page, we will:\n", - "1) Render the page as an image.\n", - "2) Call Nemotron Parse.\n", - "3) Visualize the detected layout blocks.\n", - "4) Inspect the extracted data in a DataFrame.\n", - "5) Export the full data to a JSONL file for downstream use." - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "11e843a0", - "metadata": { - "id": "quickstart" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Using cached PDF: parse_outputs/corporate-nvidia-in-brief.pdf\n" - ] - }, - { - "data": { - "text/markdown": [ - "--- \n", - "### Processing Page 1..." - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/markdown": [ - "#### Page 1 — Annotated Layout" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/jpeg": "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", - "image/png": "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", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/markdown": [ - "Top blocks (id, type, text preview):" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
idtypetextbbox
00Title# NVIDIA in Brief{'xmin': 0.033710416666666666, 'ymin': 0.2602,...
11TextNVIDIA pioneered accelerated computing to tack...{'xmin': 0.033710416666666666, 'ymin': 0.3484,...
22Section-header## Company History{'xmin': 0.033710416666666666, 'ymin': 0.4078,...
33TextFounded in 1993, NVIDIA is the world leader in...{'xmin': 0.033710416666666666, 'ymin': 0.432, ...
44Section-header## Key Stats{'xmin': 0.033710416666666666, 'ymin': 0.5273,...
55List-item\\>\\> Founded in 1993{'xmin': 0.033710416666666666, 'ymin': 0.5547,...
66List-item\\>\\> Founder and CEO: **Jensen Huang**{'xmin': 0.033710416666666666, 'ymin': 0.5734,...
77List-item\\>\\> 36,000+ employees in 38 countries{'xmin': 0.033710416666666666, 'ymin': 0.5914,...
88List-item\\>\\> Record full-year revenue of $130.5 billio...{'xmin': 0.033710416666666666, 'ymin': 0.6102,...
99List-item\\>\\> 8,700+ granted and pending patent applica...{'xmin': 0.033710416666666666, 'ymin': 0.6289,...
\n", - "
" - ], - "text/plain": [ - " id type text \\\n", - "0 0 Title # NVIDIA in Brief \n", - "1 1 Text NVIDIA pioneered accelerated computing to tack... \n", - "2 2 Section-header ## Company History \n", - "3 3 Text Founded in 1993, NVIDIA is the world leader in... \n", - "4 4 Section-header ## Key Stats \n", - "5 5 List-item \\>\\> Founded in 1993 \n", - "6 6 List-item \\>\\> Founder and CEO: **Jensen Huang** \n", - "7 7 List-item \\>\\> 36,000+ employees in 38 countries \n", - "8 8 List-item \\>\\> Record full-year revenue of $130.5 billio... \n", - "9 9 List-item \\>\\> 8,700+ granted and pending patent applica... \n", - "\n", - " bbox \n", - "0 {'xmin': 0.033710416666666666, 'ymin': 0.2602,... \n", - "1 {'xmin': 0.033710416666666666, 'ymin': 0.3484,... \n", - "2 {'xmin': 0.033710416666666666, 'ymin': 0.4078,... \n", - "3 {'xmin': 0.033710416666666666, 'ymin': 0.432, ... \n", - "4 {'xmin': 0.033710416666666666, 'ymin': 0.5273,... \n", - "5 {'xmin': 0.033710416666666666, 'ymin': 0.5547,... \n", - "6 {'xmin': 0.033710416666666666, 'ymin': 0.5734,... \n", - "7 {'xmin': 0.033710416666666666, 'ymin': 0.5914,... \n", - "8 {'xmin': 0.033710416666666666, 'ymin': 0.6102,... \n", - "9 {'xmin': 0.033710416666666666, 'ymin': 0.6289,... " - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/markdown": [ - "--- \n", - "### Processing Page 2..." - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/markdown": [ - "#### Page 2 — Annotated Layout" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/jpeg": "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", - "image/png": "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", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/markdown": [ - "Top blocks (id, type, text preview):" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
idtypetextbbox
00Text**NVIDIA is the engine of the world’s AI infra...{'xmin': 0.183596875, 'ymin': 0.2555, 'xmax': ...
11Text**CUDA**<sup>®</sup>, our parallel computing m...{'xmin': 0.183596875, 'ymin': 0.3508, 'xmax': ...
22Text**Accelerated computing is sustainable computi...{'xmin': 0.183596875, 'ymin': 0.4375, 'xmax': ...
33Text**Blackwell** is one of the most important pro...{'xmin': 0.183596875, 'ymin': 0.5227, 'xmax': ...
44Text**NVIDIA NIM**<sup>TM</sup>, part of the NVIDI...{'xmin': 0.183596875, 'ymin': 0.6086, 'xmax': ...
55Section-header# Latest NVIDIA News{'xmin': 0.5230677083333333, 'ymin': 0.2562, '...
66Section-header**AI/Data Center**{'xmin': 0.5911979166666667, 'ymin': 0.2844, '...
77List-item\\>\\> NVIDIA DGX personal AI supercomputers bri...{'xmin': 0.5911979166666667, 'ymin': 0.3016, '...
88List-item\\>\\> NVIDIA Blackwell Ultra AI factory platfor...{'xmin': 0.5911979166666667, 'ymin': 0.3328, '...
99List-item\\>\\> NVIDIA Dynamo open-source inference softw...{'xmin': 0.5911979166666667, 'ymin': 0.3641, '...
\n", - "
" - ], - "text/plain": [ - " id type text \\\n", - "0 0 Text **NVIDIA is the engine of the world’s AI infra... \n", - "1 1 Text **CUDA**®, our parallel computing m... \n", - "2 2 Text **Accelerated computing is sustainable computi... \n", - "3 3 Text **Blackwell** is one of the most important pro... \n", - "4 4 Text **NVIDIA NIM**TM, part of the NVIDI... \n", - "5 5 Section-header # Latest NVIDIA News \n", - "6 6 Section-header **AI/Data Center** \n", - "7 7 List-item \\>\\> NVIDIA DGX personal AI supercomputers bri... \n", - "8 8 List-item \\>\\> NVIDIA Blackwell Ultra AI factory platfor... \n", - "9 9 List-item \\>\\> NVIDIA Dynamo open-source inference softw... \n", - "\n", - " bbox \n", - "0 {'xmin': 0.183596875, 'ymin': 0.2555, 'xmax': ... \n", - "1 {'xmin': 0.183596875, 'ymin': 0.3508, 'xmax': ... \n", - "2 {'xmin': 0.183596875, 'ymin': 0.4375, 'xmax': ... \n", - "3 {'xmin': 0.183596875, 'ymin': 0.5227, 'xmax': ... \n", - "4 {'xmin': 0.183596875, 'ymin': 0.6086, 'xmax': ... \n", - "5 {'xmin': 0.5230677083333333, 'ymin': 0.2562, '... \n", - "6 {'xmin': 0.5911979166666667, 'ymin': 0.2844, '... \n", - "7 {'xmin': 0.5911979166666667, 'ymin': 0.3016, '... \n", - "8 {'xmin': 0.5911979166666667, 'ymin': 0.3328, '... \n", - "9 {'xmin': 0.5911979166666667, 'ymin': 0.3641, '... " - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Download a sample PDF (replace with your own if desired)\n", - "pdf_url = \"https://www.nvidia.com/content/dam/en-zz/Solutions/about-nvidia/corporate-nvidia-in-brief.pdf\"\n", - "pdf_path = os.path.join(OUTPUT_DIR, pdf_url.split(\"/\")[-1].split(\"?\")[0])\n", - "if not os.path.exists(pdf_path):\n", - " print(f\"Downloading {pdf_url}...\")\n", - " r = requests.get(pdf_url, timeout=60)\n", - " r.raise_for_status()\n", - " with open(pdf_path, \"wb\") as f:\n", - " f.write(r.content)\n", - " print(f\"PDF saved to: {pdf_path}\")\n", - "else:\n", - " print(f\"Using cached PDF: {pdf_path}\")\n", - "\n", - "all_records: List[Dict[str, Any]] = []\n", - "page_images_and_blocks: List[Tuple[Image.Image, List[Dict[str, Any]]]] = []\n", - "\n", - "# Process up to 4 pages\n", - "try:\n", - " with fitz.open(pdf_path) as doc:\n", - " num_pages = min(4, len(doc))\n", - " for page_idx in range(num_pages):\n", - " display(Markdown(f\"--- \\n### Processing Page {page_idx+1}...\"))\n", - "\n", - " # 1) Render\n", - " img = pdf_page_to_image(pdf_path, page_idx, dpi=300, target_size=(1536, 2048))\n", - "\n", - " # 2) Parse\n", - " b64 = encode_image_to_base64(img)\n", - " blocks = call_nemotron_parse(b64)\n", - " if not blocks:\n", - " print(f\"No blocks found for page {page_idx+1}. Skipping.\")\n", - " continue\n", - " page_images_and_blocks.append((img, blocks))\n", - "\n", - " # 3) Visualize\n", - " annotated = draw_layout(img, blocks)\n", - " display(Markdown(f\"#### Page {page_idx+1} — Annotated Layout\"))\n", - " display(annotated.resize((900, int(900 * annotated.height / annotated.width))))\n", - "\n", - " # 4) Inspect\n", - " df = blocks_to_dataframe(blocks)\n", - " display(Markdown(\"Top blocks (id, type, text preview):\"))\n", - " display(df.head(10))\n", - "\n", - " # 5) Collect records\n", - " all_records.extend(blocks_to_records(blocks, page_idx+1, img.size))\n", - "except Exception as e:\n", - " print(f\"An error occurred while processing the PDF: {e}\")" - ] - }, - { - "cell_type": "markdown", - "id": "77d2b8ad", - "metadata": {}, - "source": [ - "### Export Agent-Ready Records\n", - "\n", - "This JSONL file is a structured input for downstream processes. Each record includes text, semantic type, and location on the page." - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "2a96f9fe", - "metadata": { - "id": "export-jsonl" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Exported 71 records to: parse_outputs/parsed_records.jsonl\n", - "\n", - "--- Sample Record --- \n", - "{\n", - " \"page\": 1,\n", - " \"id\": 0,\n", - " \"type\": \"Title\",\n", - " \"text\": \"# NVIDIA in Brief\",\n", - " \"bbox_norm\": {\n", - " \"xmin\": 0.033710416666666666,\n", - " \"ymin\": 0.2602,\n", - " \"xmax\": 0.32296875,\n", - " \"ymax\": 0.2828\n", - " },\n", - " \"bbox_px\": [\n", - " 51,\n", - " 532,\n", - " 496,\n", - " 579\n", - " ]\n", - "}\n" - ] - } - ], - "source": [ - "jsonl_path = os.path.join(OUTPUT_DIR, \"parsed_records.jsonl\")\n", - "with open(jsonl_path, \"w\", encoding=\"utf-8\") as f:\n", - " for rec in all_records:\n", - " f.write(json.dumps(rec, ensure_ascii=False) + \"\\n\")\n", - "print(f\"Exported {len(all_records)} records to: {jsonl_path}\")\n", - "if all_records:\n", - " print(\"\\n--- Sample Record --- \")\n", - " print(json.dumps(all_records[0], indent=2))\n", - "else:\n", - " print(\"No records to preview.\")" - ] - }, - { - "cell_type": "markdown", - "id": "cd0f8bf0", - "metadata": {}, - "source": [ - "## 3. Creating Usable Output: From Structure to Markdown & HTML\n", - "\n", - "The raw JSON is great for machines, but the real power comes from using the semantic type and text to build human-readable and RAG-friendly content.\n", - "\n", - "Tables are extracted as LaTeX to preserve structure. We convert them into clean HTML.\n", - "\n", - "Let's reconstruct each processed page into an HTML view with type-aware rendering." - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "a13974c3", - "metadata": { - "id": "reconstruct-html" - }, - "outputs": [ - { - "data": { - "text/markdown": [ - "--- \n", - "### Page 1 — Reconstructed HTML" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Saved reconstructed page to: parse_outputs/page_1_reconstructed.html\n" - ] - }, - { - "data": { - "text/html": [ - "

NVIDIA in Brief

\n", - "

NVIDIA pioneered accelerated computing to tackle challenges no one else can solve. Our work in AI and digital twins is transforming the world’s largest industries and profoundly impacting society. Learnmore.

\n", - "

Company History

\n", - "

Founded in 1993, NVIDIA is the world leader in accelerated computing. Our invention of the GPU in 1999 sparked the growth of the PC gaming market, redefined computer graphics, revolutionized accelerated computing, ignited the era of modern AI, and is fueling industrial digitalization across markets. NVIDIA is now a full-stack computing infrastructure company with data-center-scale offerings that are reshaping industry.

\n", - "

Key Stats

\n", - "
    \n", - "
  • \n", - "
    \n", - "
    \n", - "

    Founded in 1993

    \n", - "
    \n", - "
    \n", - "
  • \n", - "
  • \n", - "
    \n", - "
    \n", - "

    Founder and CEO: Jensen Huang

    \n", - "
    \n", - "
    \n", - "
  • \n", - "
  • \n", - "
    \n", - "
    \n", - "

    36,000+ employees in 38 countries

    \n", - "
    \n", - "
    \n", - "
  • \n", - "
  • \n", - "
    \n", - "
    \n", - "

    Record full-year revenue of $130.5 billion in FY25

    \n", - "
    \n", - "
    \n", - "
  • \n", - "
  • \n", - "
    \n", - "
    \n", - "

    8,700+ granted and pending patent applications worldwide

    \n", - "
    \n", - "
    \n", - "
  • \n", - "
  • \n", - "
    \n", - "
    \n", - "

    $1 trillion available market opportunity

    \n", - "
    \n", - "
    \n", - "
  • \n", - "
  • \n", - "
    \n", - "
    \n", - "

    6 million developers in the NVIDIA Developer Program

    \n", - "
    \n", - "
    \n", - "
  • \n", - "
  • \n", - "
    \n", - "
    \n", - "

    27,000 global startups in NVIDIA Inception

    \n", - "
    \n", - "
    \n", - "
  • \n", - "
  • \n", - "
    \n", - "
    \n", - "

    No. 1 \"America’s Best Companies 2025\" - Forbes

    \n", - "
    \n", - "
    \n", - "
  • \n", - "
  • \n", - "
    \n", - "
    \n", - "

    \"World’s Most Innovative Companies\" - Fast Company

    \n", - "
    \n", - "
    \n", - "
  • \n", - "
  • \n", - "
    \n", - "
    \n", - "

    \"Best Places to Work in 2025\" - Glassdoor

    \n", - "
    \n", - "
    \n", - "
  • \n", - "
\n", - "

# Impact by Industry

\n", - "

Automotive

\n", - "

NVIDIA powers all 30 of the 30 top autonomous vehicle data centers.

\n", - "

AI Factories

\n", - "

More than 40,000 companies use NVIDIA AI technology to power AI factories.

\n", - "

Digital Twins

\n", - "

NVIDIA OmniverseTM is used by thousands of developers, including leaders in industrial simulation, automation, and robotics.

\n", - "

Gaming

\n", - "

More than 200 million gamers and creators use NVIDIA GeForce® GPUs.

\n", - "

Healthcare

\n", - "

Over 4 million developers have downloaded the MONAI framework for AI in medical imaging.

\n", - "

Robotics

\n", - "

More than 1.7 million developers use the NVIDIA JetsonTM platform for edge AI.

\n", - "

NVIDIA in Brief 2025

\n", - "

!

\n", - "
\n", - "

Caption: NVIDIA

\n", - "
" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/markdown": [ - "--- \n", - "### Page 2 — Reconstructed HTML" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Saved reconstructed page to: parse_outputs/page_2_reconstructed.html\n" - ] - }, - { - "data": { - "text/html": [ - "

NVIDIA is the engine of the world’s AI infrastructure. Companies and countries around the world are building NVIDIA-powered AI factories to process, refine, and manufacture intelligence from data, creating new revenue opportunities for the world’s $100 trillion of industries.

\n", - "

CUDA®, our parallel computing model, offers developers a powerful toolkit with over 400 libraries, 600 AI models, numerous software development kits, and support for 3,700 GPU-accelerated applications. CUDA has more than 53 million downloads.

\n", - "

Accelerated computing is sustainable computing. If certain accelerated computing and AI workloads were switched from CPU infrastructure to DPU- and GPU- accelerated operations, we estimate the world could save nearly 30 trillion watt-hours of energy per year.

\n", - "

Blackwell is one of the most important products in our history, boasting technologies that power AI training and real-time large language model inference for models scaling up to 10 trillion parameters.

\n", - "

NVIDIA NIMTM, part of the NVIDIA AI Enterprise software platform, is a set of easy-to-use microservices designed for secure, reliable deployment of high-performance AI model inferencing across clouds, data centers, and workstations.

\n", - "

# Latest NVIDIA News

\n", - "

AI/Data Center

\n", - "
    \n", - "
  • \n", - "
    \n", - "
    \n", - "

    NVIDIA DGX personal AI supercomputers bring NVIDIA Grace Blackwell architecture to the desktop.

    \n", - "
    \n", - "
    \n", - "
  • \n", - "
  • \n", - "
    \n", - "
    \n", - "

    NVIDIA Blackwell Ultra AI factory platform paves the way for the age of AI reasoning.

    \n", - "
    \n", - "
    \n", - "
  • \n", - "
  • \n", - "
    \n", - "
    \n", - "

    NVIDIA Dynamo open-source inference software accelerates and scales AI reasoning models.

    \n", - "
    \n", - "
    \n", - "
  • \n", - "
  • \n", - "
    \n", - "
    \n", - "

    The NVIDIA GB200 NVL72 system set records in the latest MLPerf Inference benchmarks.

    \n", - "
    \n", - "
    \n", - "
  • \n", - "
\n", - "

# RTX/Graphics

\n", - "
    \n", - "
  • \n", - "
    \n", - "
    \n", - "

    New GeForce RTXTM 50 Series Desktop and Laptop GPUs announced.

    \n", - "
    \n", - "
    \n", - "
  • \n", - "
  • \n", - "
    \n", - "
    \n", - "

    NVIDIA DLSS 4, featuring Multi Frame Generation, now available.

    \n", - "
    \n", - "
    \n", - "
  • \n", - "
  • \n", - "
    \n", - "
    \n", - "

    GeForce NOWTM library features over 2,000 games.

    \n", - "
    \n", - "
    \n", - "
  • \n", - "
\n", - "

# Physical AI

\n", - "
    \n", - "
  • \n", - "
    \n", - "
    \n", - "

    Introduced NVIDIA CosmosTM platform for world model training and physical AI development.

    \n", - "
    \n", - "
    \n", - "
  • \n", - "
  • \n", - "
    \n", - "
    \n", - "

    Launched NIDA Halos, a full-stack, comprehensive safety system for autonomous vehicles.

    \n", - "
    \n", - "
    \n", - "
  • \n", - "
  • \n", - "
    \n", - "
    \n", - "

    Announced NVIDIA Isaac GR00T NI open foundation model for humanoid robots.

    \n", - "
    \n", - "
    \n", - "
  • \n", - "
  • \n", - "
    \n", - "
    \n", - "

    Unveiled NVIDIA Jetson Orin NanoTM Super Developer Kit.\n", - "NVIDIA in Brief 2025

    \n", - "
    \n", - "
    \n", - "
  • \n", - "
\n", - "
\n", - "

Caption: For more information

\n", - "
" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "for i, (img, blocks) in enumerate(page_images_and_blocks):\n", - " page_num = i + 1\n", - " display(Markdown(f\"--- \\n### Page {page_num} — Reconstructed HTML\"))\n", - "\n", - " md_text = blocks_to_markdown_page(blocks)\n", - " html_content = render_markdown_to_html(md_text)\n", - "\n", - " # Save for downstream use\n", - " html_path = os.path.join(OUTPUT_DIR, f\"page_{page_num}_reconstructed.html\")\n", - " with open(html_path, \"w\", encoding=\"utf-8\") as f:\n", - " f.write(html_content)\n", - " print(f\"Saved reconstructed page to: {html_path}\")\n", - "\n", - " # Display in the notebook\n", - " display(HTML(f\"
{html_content}
\"))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 4. Conclusion: The Foundation for AI Agents\n", - "\n", - "As we've seen, Nemotron Parse is far more than just OCR. It's a foundational document-to-structure engine. Specifically,\n", - "- 9K context = cross‑page coherence\n", - "- Industry‑leading table accuracy\n", - "- Structured, layout‑aware output with bboxes\n", - "\n", - "It solves the first-mile problem of document AI by transforming messy, complex files into a clean, structured, and spatially-aware format.\n", - "\n", - "This structured output is the essential first step for any advanced AI workflow:\n", - "1) Smarter RAG: Chunk documents by semantic meaning (e.g., index Text blocks and Table HTML, ignore Page-footers) to improve retrieval accuracy.\n", - "2) Building AI Agents: An agent can read the JSON and decide:\n", - " - \"Summarize the Text blocks.\"\n", - " - \"Extract key numbers from the Table's HTML.\"\n", - " - \"There is a Figure at [bbox]; send its crop to a visual reasoning model.\"\n", - "\n", - "Nemotron Parse provides the what and where (what is this element, and where is it?). Pair it with visual reasoners to provide the why and meaning for non-text elements.\n", - "\n", - "Together, they form a complementary stack for building agents that can understand and act on all parts of your documents." - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": ".venv", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.2" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/use-case-examples/RAG Agent with Nemotron RAG Models/RAG Agent with Nemotron RAG Models.ipynb b/use-case-examples/RAG Agent with Nemotron RAG Models/RAG Agent with Nemotron RAG Models.ipynb deleted file mode 100644 index f90c239..0000000 --- a/use-case-examples/RAG Agent with Nemotron RAG Models/RAG Agent with Nemotron RAG Models.ipynb +++ /dev/null @@ -1,742 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# RAG Agent with Hugging Face NVIDIA Models + NVIDIA AI Endpoints LLM\n", - "\n", - "This notebook demonstrates how to build a RAG (Retrieval-Augmented Generation) agent using:\n", - "- **Hugging Face versions** of NVIDIA's Llama 3.2 models for embeddings and reranking\n", - "- **NVIDIA AI Endpoints** for the LLM (through build.nvidia.com)\n", - "\n", - "## Models Used:\n", - "- **Embedding Model**: `nvidia/llama-3.2-nv-embedqa-1b-v2` (Hugging Face)\n", - "- **Reranking Model**: `nvidia/llama-3.2-nv-rerankqa-1b-v2` (Hugging Face)\n", - "- **LLM Model**: `nvidia/nvidia-nemotron-nano-9b-v2` (NVIDIA AI Endpoints)\n", - "\n", - "## Architecture:\n", - "- Local Hugging Face models for embedding and reranking (better performance, privacy)\n", - "- NVIDIA AI Endpoints for LLM (managed service, latest models)\n", - "- Complete LangGraph agent with retrieval tools\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 1. Installation and Setup\n" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "import os\n", - "import getpass\n", - "\n", - "os.environ[\"NVIDIA_API_KEY\"] = getpass.getpass(\"Enter your NVIDIA API key: \")" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Using device: cuda\n", - "✅ NVIDIA API key found!\n" - ] - } - ], - "source": [ - "import logging\n", - "import torch\n", - "import torch.nn.functional as F\n", - "from pathlib import Path\n", - "from typing import List, Dict, Any, Optional\n", - "import numpy as np\n", - "\n", - "from transformers import AutoTokenizer, AutoModel, AutoModelForSequenceClassification, AutoConfig\n", - "from langchain.embeddings.base import Embeddings\n", - "from langchain.text_splitter import RecursiveCharacterTextSplitter\n", - "from langchain.tools.retriever import create_retriever_tool\n", - "from langchain_community.document_loaders import DirectoryLoader, TextLoader\n", - "from langchain_community.vectorstores import FAISS\n", - "from langchain.retrievers import ContextualCompressionRetriever\n", - "from langchain.retrievers.document_compressors.base import BaseDocumentCompressor\n", - "from langchain.schema import Document\n", - "from langchain_nvidia_ai_endpoints import ChatNVIDIA\n", - "from langgraph.prebuilt import create_react_agent\n", - "\n", - "# Set up logging\n", - "logging.basicConfig(level=logging.INFO)\n", - "_LOGGER = logging.getLogger(__name__)\n", - "\n", - "# Check if CUDA is available\n", - "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", - "print(f\"Using device: {device}\")\n", - "\n", - "# Check for NVIDIA API key\n", - "if \"NVIDIA_API_KEY\" not in os.environ:\n", - " print(\"⚠️ Warning: NVIDIA_API_KEY not found in environment variables.\")\n", - " print(\"Please set your NVIDIA API key to use the LLM:\")\n", - " print(\"export NVIDIA_API_KEY='your_api_key_here'\")\n", - "else:\n", - " print(\"✅ NVIDIA API key found!\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 2. Configuration\n" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "# Data Ingestion Configuration\n", - "DATA_DIR = Path(\"../data/it-knowledge-base\")\n", - "CHUNK_SIZE = 800\n", - "CHUNK_OVERLAP = 120\n", - "\n", - "# Model Configuration\n", - "LLM_MODEL = \"nvidia/nvidia-nemotron-nano-9b-v2\" # NVIDIA AI Endpoints\n", - "RETRIEVER_EMBEDDING_MODEL = \"nvidia/llama-3.2-nv-embedqa-1b-v2\" # Hugging Face\n", - "RETRIEVER_RERANK_MODEL = \"nvidia/llama-3.2-nv-rerankqa-1b-v2\" # Hugging Face\n", - "\n", - "# Model parameters\n", - "MAX_LENGTH = 8192\n", - "EMBEDDING_DIM = 2048\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 3. Custom Hugging Face Embedding Class\n" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "class HuggingFaceNVIDIAEmbeddings(Embeddings):\n", - " \"\"\"Custom embedding class for NVIDIA Llama 3.2 embedding model from Hugging Face.\"\"\"\n", - " \n", - " def __init__(self, model_name: str, device: str = \"auto\", trust_remote_code: bool = True):\n", - " self.model_name = model_name\n", - " self.device = device if device != \"auto\" else (\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", - " \n", - " print(f\"Loading embedding model: {model_name}\")\n", - " \n", - " # Load tokenizer\n", - " self.tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=trust_remote_code)\n", - " \n", - " # Load model - the key is to use trust_remote_code=True for custom NVIDIA models\n", - " print(\"Loading model with trust_remote_code=True for custom NVIDIA architecture...\")\n", - " self.model = AutoModel.from_pretrained(\n", - " model_name, \n", - " trust_remote_code=trust_remote_code,\n", - " )\n", - " \n", - " self.model.to(self.device)\n", - " self.model.eval()\n", - " \n", - " # Add padding token if it doesn't exist\n", - " if self.tokenizer.pad_token is None:\n", - " self.tokenizer.pad_token = self.tokenizer.eos_token\n", - " \n", - " print(f\"✅ Embedding model loaded on {self.device}\")\n", - " \n", - " def average_pool(self, last_hidden_states: torch.Tensor, attention_mask: torch.Tensor) -> torch.Tensor:\n", - " \"\"\"Average pooling with attention mask.\"\"\"\n", - " last_hidden_states_masked = last_hidden_states.masked_fill(~attention_mask[..., None].bool(), 0.0)\n", - " embedding = last_hidden_states_masked.sum(dim=1) / attention_mask.sum(dim=1)[..., None]\n", - " embedding = F.normalize(embedding, dim=-1)\n", - " return embedding\n", - " \n", - " def embed_documents(self, texts: List[str]) -> List[List[float]]:\n", - " \"\"\"Embed a list of documents.\"\"\"\n", - " # Add document prefix as specified in the model documentation\n", - " prefixed_texts = [f\"passage: {text}\" for text in texts]\n", - " return self._embed_texts(prefixed_texts)\n", - " \n", - " def embed_query(self, text: str) -> List[float]:\n", - " \"\"\"Embed a single query.\"\"\"\n", - " # Add query prefix as specified in the model documentation\n", - " prefixed_text = f\"query: {text}\"\n", - " embeddings = self._embed_texts([prefixed_text])\n", - " return embeddings[0]\n", - " \n", - " def _embed_texts(self, texts: List[str]) -> List[List[float]]:\n", - " \"\"\"Internal method to embed texts.\"\"\"\n", - " embeddings = []\n", - " \n", - " # Process in batches to handle memory efficiently\n", - " batch_size = 8\n", - " for i in range(0, len(texts), batch_size):\n", - " batch_texts = texts[i:i + batch_size]\n", - " \n", - " # Tokenize\n", - " batch_inputs = self.tokenizer(\n", - " batch_texts,\n", - " padding=True,\n", - " truncation=True,\n", - " max_length=MAX_LENGTH,\n", - " return_tensors=\"pt\"\n", - " ).to(self.device)\n", - " \n", - " # Generate embeddings\n", - " with torch.no_grad():\n", - " outputs = self.model(**batch_inputs)\n", - " batch_embeddings = self.average_pool(\n", - " outputs.last_hidden_state, \n", - " batch_inputs[\"attention_mask\"]\n", - " )\n", - " \n", - " # Convert to list and add to results\n", - " embeddings.extend(batch_embeddings.cpu().numpy().tolist())\n", - " \n", - " return embeddings\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 4. Custom Hugging Face Reranker Class\n" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "class HuggingFaceNVIDIAReranker(BaseDocumentCompressor):\n", - " \"\"\"Custom reranker class for NVIDIA Llama 3.2 reranking model from Hugging Face.\"\"\"\n", - " \n", - " def __init__(self, model_name: str, device: str = \"auto\", trust_remote_code: bool = True, top_k: int = 3, max_length: int = 512):\n", - " # Initialize parent class first\n", - " super().__init__()\n", - " \n", - " # Store configuration\n", - " self._model_name = model_name\n", - " self._device = device if device != \"auto\" else (\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", - " self._top_k = top_k\n", - " self._max_length = max_length\n", - " \n", - " print(f\"Loading reranking model: {model_name}\")\n", - " \n", - " # Load tokenizer with proper configuration\n", - " self._tokenizer = AutoTokenizer.from_pretrained(\n", - " model_name, \n", - " trust_remote_code=trust_remote_code,\n", - " padding_side=\"left\"\n", - " )\n", - " if self._tokenizer.pad_token is None:\n", - " self._tokenizer.pad_token = self._tokenizer.eos_token\n", - " \n", - " # Load model for sequence classification (reranking)\n", - " model_kwargs = {\n", - " \"trust_remote_code\": trust_remote_code,\n", - " }\n", - " \n", - " from transformers import AutoModelForSequenceClassification\n", - " self._model = AutoModelForSequenceClassification.from_pretrained(\n", - " model_name,\n", - " **model_kwargs\n", - " ).eval()\n", - " \n", - " if self._model.config.pad_token_id is None:\n", - " self._model.config.pad_token_id = self._tokenizer.eos_token_id\n", - " \n", - " self._model.to(self._device)\n", - " \n", - " print(f\"✅ Reranking model loaded on {self._device}\")\n", - " \n", - " def _prompt_template(self, query: str, passage: str) -> str:\n", - " \"\"\"Format query and passage with the proper prompt template.\"\"\"\n", - " return f\"question:{query} \\n \\n passage:{passage}\"\n", - " \n", - " def compress_documents(\n", - " self,\n", - " documents: List[Document],\n", - " query: str,\n", - " callbacks: Optional[Any] = None,\n", - " ) -> List[Document]:\n", - " \"\"\"Compress documents by reranking them based on relevance to the query.\"\"\"\n", - " if not documents:\n", - " return documents\n", - " \n", - " # Calculate relevance scores for all documents in batch\n", - " scores = self._calculate_relevance_scores(query, [doc.page_content for doc in documents])\n", - " \n", - " # Pair documents with their scores\n", - " doc_scores = list(zip(documents, scores))\n", - " \n", - " # Sort by relevance score (descending) and return top_k\n", - " sorted_docs = sorted(doc_scores, key=lambda x: x[1], reverse=True)\n", - " return [doc for doc, _ in sorted_docs[:self._top_k]]\n", - " \n", - " def _calculate_relevance_scores(self, query: str, documents: List[str]) -> List[float]:\n", - " \"\"\"Calculate relevance scores for multiple documents efficiently.\"\"\"\n", - " # Apply prompt template to all query-document pairs\n", - " texts = [self._prompt_template(query, doc) for doc in documents]\n", - " \n", - " # Tokenize all texts in batch\n", - " batch_dict = self._tokenizer(\n", - " texts,\n", - " padding=True,\n", - " truncation=True,\n", - " return_tensors=\"pt\",\n", - " max_length=self._max_length,\n", - " )\n", - " \n", - " # Move to device\n", - " batch_dict = {k: v.to(self._device) for k, v in batch_dict.items()}\n", - " \n", - " # Generate relevance scores\n", - " with torch.inference_mode():\n", - " logits = self._model(**batch_dict).logits\n", - " scores = logits.view(-1).cpu().tolist()\n", - " \n", - " return scores" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 5. Initialize Models\n" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Loading embedding model: nvidia/llama-3.2-nv-embedqa-1b-v2\n", - "Loading model with trust_remote_code=True for custom NVIDIA architecture...\n", - "✅ Embedding model loaded on cuda\n", - "Loading reranking model: nvidia/llama-3.2-nv-rerankqa-1b-v2\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "A new version of the following files was downloaded from https://huggingface.co/nvidia/llama-3.2-nv-rerankqa-1b-v2:\n", - "- llama_bidirectional_model.py\n", - ". Make sure to double-check they do not contain any added malicious code. To avoid downloading new versions of the code file, you can pin a revision.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "✅ Reranking model loaded on cuda\n", - "Initializing LLM: nvidia/nvidia-nemotron-nano-9b-v2\n", - "✅ All models initialized successfully!\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/chris/Code/NVIDIA/workshop-build-an-agent/.venv/lib/python3.13/site-packages/langchain_nvidia_ai_endpoints/_common.py:229: UserWarning: Found nvidia/nvidia-nemotron-nano-9b-v2 in available_models, but type is unknown and inference may fail.\n", - " warnings.warn(\n" - ] - } - ], - "source": [ - "# Initialize the embedding model (Hugging Face)\n", - "embeddings = HuggingFaceNVIDIAEmbeddings(\n", - " model_name=RETRIEVER_EMBEDDING_MODEL,\n", - " device=device\n", - ")\n", - "\n", - "# Initialize the reranker model (Hugging Face)\n", - "reranker = HuggingFaceNVIDIAReranker(\n", - " model_name=RETRIEVER_RERANK_MODEL,\n", - " device=device,\n", - " top_k=3\n", - ")\n", - "\n", - "# Initialize the LLM (NVIDIA AI Endpoints)\n", - "print(f\"Initializing LLM: {LLM_MODEL}\")\n", - "llm = ChatNVIDIA(model=LLM_MODEL, temperature=0.6, top_p=0.95, max_completion_tokens=8192)\n", - "print(\"✅ All models initialized successfully!\")\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 6. Data Loading and Processing\n" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:__main__:Reading knowledge base data from ../data/it-knowledge-base\n", - "100%|██████████| 12/12 [00:00<00:00, 3230.74it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Loaded 12 documents\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "# Check if data directory exists\n", - "if not DATA_DIR.exists():\n", - " print(f\"Warning: Data directory {DATA_DIR} does not exist.\")\n", - " print(\"Creating sample documents for demonstration...\")\n", - " \n", - " # Create sample IT knowledge base documents\n", - " sample_docs = [\n", - " Document(\n", - " page_content=\"Password Policy: All employees must use passwords with at least 12 characters, including uppercase, lowercase, numbers, and special characters. Passwords must be changed every 90 days.\",\n", - " metadata={\"source\": \"password_policy.txt\"}\n", - " ),\n", - " Document(\n", - " page_content=\"VPN Access: To connect to the company VPN, use the Cisco AnyConnect client. Download it from the IT portal and use your employee credentials. Contact IT support if you experience connection issues.\",\n", - " metadata={\"source\": \"vpn_guide.txt\"}\n", - " ),\n", - " Document(\n", - " page_content=\"Email Setup: Configure your email client with IMAP settings: Server: mail.company.com, Port: 993, Security: SSL/TLS. For SMTP: Server: smtp.company.com, Port: 587, Security: STARTTLS.\",\n", - " metadata={\"source\": \"email_setup.txt\"}\n", - " ),\n", - " Document(\n", - " page_content=\"Software Installation: All software installations require IT approval. Submit requests through the IT portal. Unauthorized software installation may result in security violations.\",\n", - " metadata={\"source\": \"software_policy.txt\"}\n", - " ),\n", - " Document(\n", - " page_content=\"Backup Policy: All critical data must be backed up daily. Use the company-approved backup solution. Personal devices are not covered under the backup policy.\",\n", - " metadata={\"source\": \"backup_policy.txt\"}\n", - " )\n", - " ]\n", - " docs = sample_docs\n", - "else:\n", - " # Load documents from directory\n", - " _LOGGER.info(f\"Reading knowledge base data from {DATA_DIR}\")\n", - " data_loader = DirectoryLoader(\n", - " DATA_DIR,\n", - " glob=\"**/*\",\n", - " loader_cls=TextLoader,\n", - " show_progress=True,\n", - " )\n", - " docs = data_loader.load()\n", - "\n", - "print(f\"Loaded {len(docs)} documents\")\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 7. Create Vector Database and Retriever\n" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:__main__:Splitting documents into chunks\n", - "INFO:__main__:Creating FAISS vector database with 155 chunks\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Created 155 chunks\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:faiss.loader:Loading faiss with AVX512 support.\n", - "INFO:faiss.loader:Successfully loaded faiss with AVX512 support.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Vector database created successfully!\n", - "Retriever with reranking created successfully!\n" - ] - } - ], - "source": [ - "# Split the data into chunks\n", - "_LOGGER.info(f\"Splitting documents into chunks\")\n", - "splitter = RecursiveCharacterTextSplitter(\n", - " chunk_size=CHUNK_SIZE, \n", - " chunk_overlap=CHUNK_OVERLAP\n", - ")\n", - "chunks = splitter.split_documents(docs)\n", - "print(f\"Created {len(chunks)} chunks\")\n", - "\n", - "# Create FAISS vector database\n", - "_LOGGER.info(f\"Creating FAISS vector database with {len(chunks)} chunks\")\n", - "vectordb = FAISS.from_documents(chunks, embeddings)\n", - "print(\"Vector database created successfully!\")\n", - "\n", - "# Create base retriever\n", - "kb_retriever = vectordb.as_retriever(\n", - " search_type=\"similarity\", \n", - " search_kwargs={\"k\": 6}\n", - ")\n", - "\n", - "# Combine retriever with reranker\n", - "retriever = ContextualCompressionRetriever(\n", - " base_retriever=kb_retriever,\n", - " base_compressor=reranker,\n", - ")\n", - "\n", - "print(\"Retriever with reranking created successfully!\")\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 8. Create LangGraph Agent\n" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "✅ LangGraph ReAct agent created successfully!\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/chris/Code/NVIDIA/workshop-build-an-agent/.venv/lib/python3.13/site-packages/langchain_nvidia_ai_endpoints/chat_models.py:715: UserWarning: Model 'nvidia/nvidia-nemotron-nano-9b-v2' is not known to support tools. Your tool binding may fail at inference time.\n", - " warnings.warn(\n" - ] - } - ], - "source": [ - "# Create the retriever tool for agentic use\n", - "retriever_tool = create_retriever_tool(\n", - " retriever=retriever,\n", - " name=\"company_llc_it_knowledge_base\",\n", - " description=(\n", - " \"Search the internal IT knowledge base for Company LLC IT related questions and policies. \"\n", - " \"Use this tool to find information about passwords, VPN, email setup, software policies, and other IT topics.\"\n", - " ),\n", - ")\n", - "\n", - "# Define the system prompt for the agent\n", - "SYSTEM_PROMPT = (\n", - " \"You are an IT help desk support agent.\\n\"\n", - " \"- Use the 'company_llc_it_knowledge_base' tool for questions likely covered by the internal IT knowledge base.\\n\"\n", - " \"- Always write grounded answers. If unsure, say you don't know.\\n\"\n", - " \"- If the knowledge base doesn't contain sufficient information, clearly state what information is missing.\\n\"\n", - " \"- Keep answers brief, to the point, and conversational.\"\n", - ")\n", - "\n", - "# Create the ReAct agent\n", - "agent = create_react_agent(\n", - " model=llm,\n", - " tools=[retriever_tool],\n", - " prompt=SYSTEM_PROMPT,\n", - ")\n", - "\n", - "print(\"✅ LangGraph ReAct agent created successfully!\")\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 9. Test the Agent\n" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "============================================================\n", - "Query: What are the password requirements for employees?\n", - "============================================================\n", - "Agent Response:\n", - "The password requirements for employees are as follows: \n", - "- Minimum of **12 characters**. \n", - "- Must include at least one uppercase letter, one lowercase letter, one number, and one special character. \n", - "- Avoid common words, sequential numbers, or previously used passwords. \n", - "\n", - "Let me know if you need further clarification!\n", - "------------------------------------------------------------\n" - ] - } - ], - "source": [ - "# Test the agent with sample queries\n", - "test_queries = [\n", - " \"What are the password requirements for employees?\",\n", - " \"How do I set up VPN access?\",\n", - " \"What are the email server settings?\",\n", - " \"Can I install my own software?\",\n", - " \"What's the backup policy?\"\n", - "]\n", - "\n", - "def test_agent(query: str):\n", - " \"\"\"Test the agent with a single query.\"\"\"\n", - " print(f\"\\n{'='*60}\")\n", - " print(f\"Query: {query}\")\n", - " print(f\"{'='*60}\")\n", - " \n", - " try:\n", - " # Invoke the agent\n", - " response = agent.invoke({\"messages\": [(\"user\", query)]})\n", - " \n", - " # Extract the final message\n", - " final_message = response[\"messages\"][-1].content\n", - " print(f\"Agent Response:\\n{final_message}\")\n", - " \n", - " except Exception as e:\n", - " print(f\"Error: {str(e)}\")\n", - " \n", - " print(\"-\" * 60)\n", - "\n", - "# Test with the first query\n", - "test_agent(test_queries[0])\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Summary\n", - "\n", - "This notebook demonstrates a **hybrid approach** combining:\n", - "\n", - "### 🏠 Local Hugging Face Models:\n", - "- **Embedding**: `nvidia/llama-3.2-nv-embedqa-1b-v2`\n", - "- **Reranking**: `nvidia/llama-3.2-nv-rerankqa-1b-v2`\n", - "\n", - "### ☁️ NVIDIA AI Endpoints:\n", - "- **LLM**: `nvidia/nvidia-nemotron-nano-9b-v2`\n", - "\n", - "### Key Benefits:\n", - "\n", - "1. **Best of Both Worlds**:\n", - " - Local models for embedding/reranking (privacy, performance, cost)\n", - " - Managed LLM service (latest models, no infrastructure)\n", - "\n", - "2. **Performance Optimizations**:\n", - " - GPU acceleration for local models\n", - " - Efficient batching and memory management\n", - " - Proper query/passage prefixing as per model specs\n", - "\n", - "3. **Production Ready**:\n", - " - Complete LangGraph agent with tool integration\n", - " - Proper error handling and logging\n", - " - Interactive testing capabilities\n", - "\n", - "### Architecture Flow:\n", - "\n", - "1. **Document Processing**: Text splitting and chunking\n", - "2. **Embedding**: Local Hugging Face model generates embeddings\n", - "3. **Vector Search**: FAISS similarity search (k=6)\n", - "4. **Reranking**: Local Hugging Face model reranks to top 3\n", - "5. **Generation**: NVIDIA AI Endpoints LLM generates final response\n", - "\n", - "### Usage:\n", - "\n", - "- Run cells sequentially to set up the complete system\n", - "- Use `test_agent()` function for individual queries\n", - "- Use `chat_with_agent()` for interactive conversations\n", - "- Type 'test' in chat to run all predefined test queries\n", - "\n", - "### Requirements:\n", - "\n", - "- NVIDIA API key for LLM access\n", - "- GPU recommended for local models (falls back to CPU)\n", - "- Internet connection for model downloads and LLM API calls\n", - "\n", - "The models used are:\n", - "- [nvidia/llama-3.2-nv-embedqa-1b-v2](https://huggingface.co/nvidia/llama-3.2-nv-embedqa-1b-v2)\n", - "- [nvidia/llama-3.2-nv-rerankqa-1b-v2](https://huggingface.co/nvidia/llama-3.2-nv-rerankqa-1b-v2)\n" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": ".venv", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.13.4" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/use-case-examples/README.md b/use-case-examples/README.md index e59c57a..bd16749 100644 --- a/use-case-examples/README.md +++ b/use-case-examples/README.md @@ -6,7 +6,7 @@ This directory contains end-to-end examples demonstrating practical applications ## 📋 Overview -These examples showcase **complete implementations** of agentic workflows, RAG systems, and other advanced use cases. Unlike the [usage-cookbook](../usage-cookbook/) which focuses on deployment and basic model usage, these examples demonstrate how to build production-ready applications. +These examples showcase **complete implementations** of agentic workflows, RAG systems, and other advanced use cases. Unlike the {doc}`usage-cookbook ` which focuses on deployment and basic model usage, these examples demonstrate how to build production-ready applications. --- @@ -14,5 +14,5 @@ These examples showcase **complete implementations** of agentic workflows, RAG s | Example | Description | |---------|-------------| -| [RAG Agent with Nemotron RAG Models](./RAG%20Agent%20with%20Nemotron%20RAG%20Models/) | End-to-end example of a Retrieval-Augmented Generation (RAG) agent workflow using Nemotron RAG models through Hugging Face and Nemotron 9B hosted through build.nvidia.com models | -| [Data Science ML Agent](./Data%20Science%20ML%20Agent/) | End-to-end example of a natural language-driven data science and machine learning agent powered by NVIDIA GPUs. The agent allows users to perform data exploration, model training, and hyperparameter optimization interactively using RAPIDS cuDF and cuML for GPU acceleration.| +| {doc}`RAG Agent with Nemotron RAG Models ` | End-to-end example of a Retrieval-Augmented Generation (RAG) agent workflow using Nemotron RAG models through Hugging Face and Nemotron 9B hosted through build.nvidia.com models | +| {doc}`Data Science ML Agent ` | End-to-end example of a natural language-driven data science and machine learning agent powered by NVIDIA GPUs. The agent allows users to perform data exploration, model training, and hyperparameter optimization interactively using RAPIDS cuDF and cuML for GPU acceleration.| diff --git a/use-case-examples/Simple Nemotron-3-Nano Usage Example/simple_usage_notebook.ipynb b/use-case-examples/Simple Nemotron-3-Nano Usage Example/simple_usage_notebook.ipynb deleted file mode 100644 index 1d0f010..0000000 --- a/use-case-examples/Simple Nemotron-3-Nano Usage Example/simple_usage_notebook.ipynb +++ /dev/null @@ -1,1407 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "705e6f60", - "metadata": {}, - "source": [ - "# 🚀 NVIDIA Nemotron 3 Nano - Simple Usage Guide\n", - "\n", - "This notebook provides a streamlined guide to using **NVIDIA Nemotron 3 Nano**, including:\n", - "\n", - "1. **Basic Usage** - Simple API calls with the OpenAI-compatible endpoint\n", - "2. **Reasoning Modes** - Toggle thinking ON/OFF\n", - "3. **LangChain v1.0 Agent** - Build a research assistant with web search and conversation memory\n", - "4. **Multi-Agent System** - Coordinate multiple specialist agents (Search, Report Writer, Quality Reviewer)\n", - "\n", - "## Prerequisites\n", - "\n", - "- An OpenRouter key ([Get one here](https://openrouter.ai/settings/keys))\n", - "- Optional: Tavily API key for web search ([Get one here](https://tavily.com/))\n" - ] - }, - { - "cell_type": "markdown", - "id": "b526e9ab", - "metadata": {}, - "source": [ - "## 📦 Installation\n", - "\n", - "Install all required dependencies:\n" - ] - }, - { - "cell_type": "markdown", - "id": "ee2e3e70", - "metadata": {}, - "source": [ - "## 🔑 API Key Configuration\n", - "\n", - "Enter your OpenRouter API key when prompted. This key is used for both the OpenAI-compatible API and LangChain integration." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "8c29ec75", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "✅ OpenRouter API key configured!\n" - ] - } - ], - "source": [ - "import os\n", - "import getpass\n", - "\n", - "# Set OpenRouter API key (used by both OpenAI client and LangChain)\n", - "if not os.environ.get(\"OPENROUTER_API_KEY\"):\n", - " os.environ[\"OPENROUTER_API_KEY\"] = getpass.getpass(\"Enter your OpenRouter API Key: \")\n", - "\n", - "print(\"✅ OpenRouter API key configured!\")\n" - ] - }, - { - "cell_type": "markdown", - "id": "1678deeb", - "metadata": {}, - "source": [ - "---\n", - "\n", - "# Part 1: Basic Usage with OpenAI Client\n", - "\n", - "NVIDIA's API is OpenAI-compatible, making it easy to use with the standard OpenAI Python SDK.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "24714971", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "✅ Client configured for model: nvidia/nemotron-3-nano-30b-a3b\n" - ] - } - ], - "source": [ - "from openai import OpenAI\n", - "\n", - "# Create client pointing to OpenRouter's API\n", - "client = OpenAI(\n", - " base_url=\"https://openrouter.ai/api/v1\",\n", - " api_key=os.environ[\"OPENROUTER_API_KEY\"]\n", - ")\n", - "\n", - "# Model identifier (OpenRouter format)\n", - "MODEL = \"nvidia/nemotron-3-nano-30b-a3b\"\n", - "\n", - "print(f\"✅ Client configured for model: {MODEL}\")\n" - ] - }, - { - "cell_type": "markdown", - "id": "55ea6d3a", - "metadata": {}, - "source": [ - "### Simple Request\n", - "\n", - "Let's start with a basic request to the model:\n" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "82b5f73c", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "NVIDIA is a technology company best known for designing graphics processing units (GPUs) that accelerate computer graphics, gaming, and data‑intensive tasks. In recent years, it has expanded into AI, cloud computing, automotive, and edge computing, offering hardware and software platforms that power everything from supercomputing to deep‑learning inference.\n" - ] - } - ], - "source": [ - "# Simple non-streaming request\n", - "response = client.chat.completions.create(\n", - " model=MODEL,\n", - " messages=[\n", - " {\"role\": \"system\", \"content\": \"You are a helpful assistant. Be concise.\"},\n", - " {\"role\": \"user\", \"content\": \"What is NVIDIA? Answer in 2-3 sentences.\"}\n", - " ],\n", - " temperature=1,\n", - " top_p=1,\n", - " max_tokens=512\n", - ")\n", - "\n", - "print(response.choices[0].message.content)\n" - ] - }, - { - "cell_type": "markdown", - "id": "26228280", - "metadata": {}, - "source": [ - "---\n", - "\n", - "## 🧠 Reasoning Modes\n", - "\n", - "Nemotron Nano V3 supports two reasoning modes:\n", - "\n", - "| Mode | Description | Best For |\n", - "|------|-------------|----------|\n", - "| **Reasoning ON** | Outputs chain-of-thought wrapped in thinking tokens | Complex problems, math, logic |\n", - "| **Reasoning OFF** | Jumps directly to the final answer | Simple queries, faster responses |\n", - "\n", - "Use `enable_thinking` in `extra_body` to toggle modes.\n" - ] - }, - { - "cell_type": "markdown", - "id": "db04a75c", - "metadata": {}, - "source": [ - "### Reasoning ON (with thinking)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "2a8b540f", - "metadata": {}, - "outputs": [], - "source": [ - "# Helper function to display streaming response with reasoning\n", - "def stream_with_reasoning(completion):\n", - " \"\"\"Stream and display response, separating reasoning from final answer.\"\"\"\n", - " reasoning = \"\"\n", - " answer = \"\"\n", - " \n", - " for chunk in completion:\n", - " delta = chunk.choices[0].delta\n", - " \n", - " # Collect reasoning content (gray text)\n", - " if hasattr(delta, 'reasoning_content') and delta.reasoning_content:\n", - " reasoning += delta.reasoning_content\n", - " print(f\"\\033[90m{delta.reasoning_content}\\033[0m\", end=\"\", flush=True)\n", - " \n", - " # Collect answer content (normal text)\n", - " if delta.content:\n", - " answer += delta.content\n", - " print(delta.content, end=\"\", flush=True)\n", - " \n", - " print() # New line at end\n", - " return reasoning, answer\n" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "de0938db", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "🧠 Reasoning ON (gray = thinking, white = answer):\n", - "\n", - "\u001b[90mUser\u001b[0m\u001b[90m asks\u001b[0m\u001b[90m a\u001b[0m\u001b[90m simple\u001b[0m\u001b[90m math\u001b[0m\u001b[90m question\u001b[0m\u001b[90m:\u001b[0m\u001b[90m \"\u001b[0m\u001b[90mWhat\u001b[0m\u001b[90m is\u001b[0m\u001b[90m \u001b[0m\u001b[90m1\u001b[0m\u001b[90m5\u001b[0m\u001b[90m%\u001b[0m\u001b[90m of\u001b[0m\u001b[90m \u001b[0m\u001b[90m2\u001b[0m\u001b[90m4\u001b[0m\u001b[90m0\u001b[0m\u001b[90m?\"\u001b[0m\u001b[90m Compute\u001b[0m\u001b[90m \u001b[0m\u001b[90m0\u001b[0m\u001b[90m.\u001b[0m\u001b[90m1\u001b[0m\u001b[90m5\u001b[0m\u001b[90m*\u001b[0m\u001b[90m2\u001b[0m\u001b[90m4\u001b[0m\u001b[90m0\u001b[0m\u001b[90m =\u001b[0m\u001b[90m \u001b[0m\u001b[90m3\u001b[0m\u001b[90m6\u001b[0m\u001b[90m.\u001b[0m\u001b[90m Answer\u001b[0m\u001b[90m:\u001b[0m\u001b[90m \u001b[0m\u001b[90m3\u001b[0m\u001b[90m6\u001b[0m\u001b[90m.\n", - "\u001b[0m\n", - "15 % of 240 is \n", - "\n", - "\\[\n", - "0.15 \\times 240 = 36.\n", - "\\] \n", - "\n", - "So the result is **36**.\n" - ] - } - ], - "source": [ - "# Reasoning ON - The model thinks through the problem\n", - "# Best with temperature=1.0, top_p=1.0 for optimal performance\n", - "\n", - "completion = client.chat.completions.create(\n", - " model=MODEL,\n", - " messages=[\n", - " {\"role\": \"system\", \"content\": \"You are a helpful math assistant.\"},\n", - " {\"role\": \"user\", \"content\": \"What is 15% of 240?\"}\n", - " ],\n", - " extra_body={\n", - " \"chat_template_kwargs\": {\n", - " \"enable_thinking\": True,\n", - " }\n", - " },\n", - " temperature=1.0,\n", - " top_p=1.0,\n", - " max_tokens=2048,\n", - " stream=True\n", - ")\n", - "\n", - "print(\"🧠 Reasoning ON (gray = thinking, white = answer):\\n\")\n", - "reasoning, answer = stream_with_reasoning(completion)\n" - ] - }, - { - "cell_type": "markdown", - "id": "4c351122", - "metadata": {}, - "source": [ - "### Reasoning OFF (direct answer)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "00c1cc39", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "⚡ Reasoning OFF (direct answer):\n", - "\n", - "To find **15% of 240**, follow these steps:\n", - "\n", - "1. **Convert the percentage to a decimal**: \n", - " Divide 15 by 100 → **0.15**.\n", - "\n", - "2. **Multiply the decimal by the number**: \n", - " **0.15 × 240 = 36**.\n", - "\n", - "**Answer**: 15% of 240 is **36**. \n", - "\n", - "*Quick check*: \n", - "- 10% of 240 = 24 \n", - "- 5% of 240 = 12 \n", - "- 15% = 10% + 5% → 24 + 12 = **36**. ✅\n" - ] - } - ], - "source": [ - "# Reasoning OFF - Direct answer without thinking\n", - "# Best with temperature=0 for deterministic output\n", - "\n", - "completion = client.chat.completions.create(\n", - " model=MODEL,\n", - " messages=[\n", - " {\"role\": \"system\", \"content\": \"You are a helpful math assistant.\"},\n", - " {\"role\": \"user\", \"content\": \"What is 15% of 240?\"}\n", - " ],\n", - " extra_body={\n", - " \"chat_template_kwargs\": {\n", - " \"enable_thinking\": False,\n", - " }\n", - " },\n", - " temperature=0,\n", - " max_tokens=500,\n", - " stream=True\n", - ")\n", - "\n", - "print(\"⚡ Reasoning OFF (direct answer):\\n\")\n", - "_, answer = stream_with_reasoning(completion)\n" - ] - }, - { - "cell_type": "markdown", - "id": "e58420f8", - "metadata": {}, - "source": [ - "---\n", - "\n", - "# Part 2: LangChain Research Agent 🔍\n", - "\n", - "Now let's build something more powerful - a **research assistant** that can:\n", - "- 🌐 Search the web for current information\n", - "- 💬 Remember conversation history (memory)\n", - "- 🤖 Use NVIDIA Nemotron as its brain\n", - "\n", - "We'll use LangChain's agent framework with the NVIDIA integration.\n" - ] - }, - { - "cell_type": "markdown", - "id": "3fc91ce8", - "metadata": {}, - "source": [ - "## Setup LangChain with OpenRouter\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "fb0142f9", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/chris/Code/NVIDIA/Nemotron 3 Nano - Simple Usage Guide/.venv/lib/python3.13/site-packages/langchain_nvidia_ai_endpoints/_common.py:241: UserWarning: Model private/nvidia/nemotron-nano-3-30b-a3b is unknown, check `available_models`. Inference may fail.\n", - " warnings.warn(\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "✅ LangChain v1.0 + NVIDIA connected!\n", - "\n", - "Hello from NVIDIA!\n" - ] - } - ], - "source": [ - "from langchain_openai import ChatOpenAI\n", - "\n", - "# Initialize the model via LangChain using OpenRouter endpoint\n", - "# Using ChatOpenAI with OpenRouter's base_url for OpenAI-compatible access\n", - "llm = ChatOpenAI(\n", - " model=\"nvidia/nemotron-3-nano-30b-a3b\",\n", - " api_key=os.environ[\"OPENROUTER_API_KEY\"],\n", - " base_url=\"https://openrouter.ai/api/v1\",\n", - " temperature=1,\n", - " top_p=1,\n", - " max_tokens=4096,\n", - ")\n", - "\n", - "# Test the connection\n", - "test_response = llm.invoke(\"Say 'Hello from NVIDIA!' in exactly those words.\")\n", - "print(f\"✅ LangChain + OpenRouter connected!\\n{test_response.content}\")" - ] - }, - { - "cell_type": "markdown", - "id": "deac514c", - "metadata": {}, - "source": [ - "## 🌐 Web Search Tool\n", - "\n", - "We'll use **DuckDuckGo** for web search (free, no API key required). \n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "89ab7195", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "🔍 Search test result (truncated):\n", - "NVIDIA Nemotron ™ is a family of open models with open weights, training data, and recipes, delivering leading efficiency and accuracy for building specialized AI agents. So, what is Nemotron ? In short, Nemotron -4 340B is a decent-sized Large Language Model (LLM) that excels at crucial tasks in today’s world. A Predictable Architecture. What is Nemotron ? NVIDIA Nemotron ™ is a family of open, high-efficiency models with fully transparent training data, weights, and recipes. What Is NeMotron 3...\n" - ] - } - ], - "source": [ - "from langchain.tools import tool\n", - "from langchain_community.tools import DuckDuckGoSearchRun\n", - "\n", - "# Create a DuckDuckGo search instance\n", - "_ddg_search = DuckDuckGoSearchRun()\n", - "\n", - "# Wrap it with the @tool decorator for LangChain v1.0\n", - "@tool\n", - "def web_search(query: str) -> str:\n", - " \"\"\"Search the web for current information on any topic.\n", - " \n", - " Use this tool when you need up-to-date information about\n", - " recent events, news, technology, or any topic that may\n", - " have changed since your training data.\n", - " \n", - " Args:\n", - " query: The search query to look up on the web\n", - " \"\"\"\n", - " return _ddg_search.invoke(query)\n", - "\n", - "# Test the search tool\n", - "test_search = web_search.invoke(\"What is Nemotron?\")\n", - "print(\"🔍 Search test result (truncated):\")\n", - "print(test_search[:500] + \"...\" if len(test_search) > 500 else test_search)" - ] - }, - { - "cell_type": "markdown", - "id": "9d7b8ef3", - "metadata": {}, - "source": [ - "## 🤖 Create the Research Agent with Memory\n", - "\n", - "Now we'll create an agent that:\n", - "1. Uses NVIDIA Nemotron as its LLM\n", - "2. Can search the web for information\n", - "3. Remembers conversation history within a session\n" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "47943c69", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "✅ LangChain v1.0 Research Agent with memory created!\n" - ] - } - ], - "source": [ - "from langchain.agents import create_agent\n", - "from langgraph.checkpoint.memory import InMemorySaver\n", - "\n", - "# System prompt for our research assistant (LangChain v1.0 style)\n", - "SYSTEM_PROMPT = \"\"\"You are a helpful research assistant powered by NVIDIA Nemotron.\n", - "\n", - "Your capabilities:\n", - "- Search the web for current, up-to-date information\n", - "- Provide well-researched, accurate answers\n", - "- Remember our conversation context\n", - "\n", - "Guidelines:\n", - "- Always search the web when asked about recent events, news, or current information\n", - "- Cite your sources when providing factual information\n", - "- Be concise but thorough\n", - "- If you're unsure, say so and search for more information\"\"\"\n", - "\n", - "# Create memory checkpointer (LangChain v1.0 uses LangGraph's InMemorySaver)\n", - "checkpointer = InMemorySaver()\n", - "\n", - "# Create the agent using LangChain v1.0's create_agent\n", - "# This is the new, simplified API that replaces create_tool_calling_agent + AgentExecutor\n", - "agent = create_agent(\n", - " model=llm, # The NVIDIA model\n", - " tools=[web_search], # List of tools (using @tool decorated functions)\n", - " system_prompt=SYSTEM_PROMPT, # System instructions\n", - " checkpointer=checkpointer, # Memory/persistence\n", - ")\n", - "\n", - "print(\"✅ LangChain v1.0 Research Agent with memory created!\")\n" - ] - }, - { - "cell_type": "markdown", - "id": "a5fc7d27", - "metadata": {}, - "source": [ - "## 🔬 Research Session Demo\n", - "\n", - "Let's test our agent with a multi-turn research conversation. The agent will remember what we've discussed!\n" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "f659875a", - "metadata": {}, - "outputs": [], - "source": [ - "# Helper function for clean research queries (LangChain v1.0 style)\n", - "def research(query: str, thread_id: str = \"default\") -> str:\n", - " \"\"\"Send a query to the research agent and return the response.\n", - " \n", - " In LangChain v1.0, we use thread_id for conversation persistence\n", - " instead of session_id. The agent automatically manages message history.\n", - " \"\"\"\n", - " # LangChain v1.0 uses this config format for memory\n", - " config = {\"configurable\": {\"thread_id\": thread_id}}\n", - " \n", - " # Invoke with messages format\n", - " result = agent.invoke(\n", - " {\"messages\": [{\"role\": \"user\", \"content\": query}]},\n", - " config=config\n", - " )\n", - " \n", - " # Extract the final response from messages\n", - " # The last message contains the assistant's response\n", - " messages = result.get(\"messages\", [])\n", - " if messages:\n", - " return messages[-1].content\n", - " return \"No response generated.\"\n", - "\n", - "def print_response(query: str, response: str):\n", - " \"\"\"Pretty print a research query and response.\"\"\"\n", - " print(f\"\\n{'='*60}\")\n", - " print(f\"📝 Query: {query}\")\n", - " print(f\"{'='*60}\")\n", - " print(f\"\\n{response}\\n\")\n" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "de7399c0", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/chris/Code/NVIDIA/Nemotron 3 Nano - Simple Usage Guide/.venv/lib/python3.13/site-packages/langchain_nvidia_ai_endpoints/chat_models.py:842: UserWarning: Model 'private/nvidia/nemotron-nano-3-30b-a3b' is not known to support tools. Your tool binding may fail at inference time.\n", - " warnings.warn(\n", - "/home/chris/Code/NVIDIA/Nemotron 3 Nano - Simple Usage Guide/.venv/lib/python3.13/site-packages/langchain_nvidia_ai_endpoints/chat_models.py:842: UserWarning: Model 'private/nvidia/nemotron-nano-3-30b-a3b' is not known to support tools. Your tool binding may fail at inference time.\n", - " warnings.warn(\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "============================================================\n", - "📝 Query: What is Nemotron Nano 9B V2?\n", - "============================================================\n", - "\n", - "\n", - "**Nemotron‑Nano‑9B‑V2** is the second‑generation 9‑billion‑parameter language model in NVIDIA’s Nemotron‑Nano family. It is an open‑weight, general‑purpose LLM designed for both **reasoning** and **non‑reasoning** tasks, and it can be used in English as well as in several non‑English languages (German, French, Italian, Spanish, Japanese).\n", - "\n", - "### Key characteristics\n", - "| Aspect | Details |\n", - "|--------|---------|\n", - "| **Model size** | 9 billion parameters |\n", - "| **Purpose** | Unified model for reasoning‑oriented chat and standard language tasks |\n", - "| **Training** | Trained **from scratch** by NVIDIA Research; the complete training pipeline (pre‑training data, recipes, checkpoint) is publicly released |\n", - "| **Reasoning style** | Generates an internal “reasoning trace” before producing the final answer, improving accuracy on complex queries |\n", - "| **Deployment** | Available as an open‑weight checkpoint that can run on a single GPU; compatible with NVIDIA NIM™ microservices for easy integration |\n", - "| **Languages** | English (primary) plus German, French, Italian, Spanish, Japanese (and potentially others) |\n", - "| **Access** | Hosted on Hugging Face and documented on NVIDIA’s model hub; a playground UI is provided for quick experimentation |\n", - "\n", - "### Why it matters\n", - "- **Open ecosystem** – NVIDIA publishes the model weights, training data, and the recipes used to build and fine‑tune the model, allowing researchers and developers to inspect, reproduce, or adapt the model for their own use cases. \n", - "- **Efficiency** – At ~9 B parameters it fits comfortably on a single modern GPU, making it suitable for edge‑device or server‑side deployments where larger models (e.g., 15‑B or 30‑B) would be impractical. \n", - "- **Unified capability** – By handling both “reasoning” (step‑by‑step) and “non‑reasoning” (direct) tasks within a single architecture, the model simplifies the design of downstream AI agents that need a single, reliable language backbone.\n", - "\n", - "### Sources\n", - "- NVIDIA research documentation for **nemotron‑nano‑9b‑v2** (released 2025) – describes the model as a “general purpose reasoning and chat model” with the reasoning‑trace workflow [web search result]. \n", - "- Announcement and model card on Hugging Face / NVIDIA model hub, confirming open weights, training data, and multilingual support [web search result].\n", - "\n", - "In short, **Nemotron‑Nano‑9B‑V2** is an openly released, 9‑billion‑parameter LLM from NVIDIA that balances strong reasoning capabilities with efficient deployment, targeting both English and selected non‑English languages.\n", - "\n" - ] - } - ], - "source": [ - "# Research Query 1: Initial question\n", - "# In LangChain v1.0, we use thread_id to maintain conversation state\n", - "THREAD_ID = \"nvidia-research\"\n", - "\n", - "query1 = \"What is Nemotron Nano 9B V2?\"\n", - "response1 = research(query1, THREAD_ID)\n", - "print_response(query1, response1)\n" - ] - }, - { - "cell_type": "markdown", - "id": "35797f31", - "metadata": {}, - "source": [ - "### View Conversation History\n", - "\n", - "The agent stores the full conversation in memory. Let's peek at what's stored:\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "3d5a30bb", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Conversation History (LangChain v1.0):\n", - "----------------------------------------\n", - "\n", - "[1] Human:\n", - " What is Nemotron?\n", - "\n", - "[2] Ai:\n", - " \n", - "\n", - "[3] Tool:\n", - " The Nemotron model family, available as optimized NVIDIA NIM™ microservices , offers peak inference performance and flexible deployment options, ensuring superior security, privacy, and portability. 4...\n", - "\n", - "[4] Ai:\n", - " \n", - "**Nemotron** is NVIDIA’s family of open‑weight language models that are purpose‑built for high‑performance, flexible deployment — from data‑center GPUs to edge devices. \n", - "\n", - "- **Core idea:** A suite of...\n", - "\n", - "[5] Human:\n", - " What is Nemotron Nano 9B V2?\n", - "\n", - "[6] Ai:\n", - " \n", - "\n", - "[7] Tool:\n", - " NVIDIA- Nemotron - Nano - 9 B - v 2 is a general purpose reasoning and chat model intended to be used in English and coding languages. Other non-English languages (German, French, Italian, Spanish and...\n", - "\n", - "[8] Ai:\n", - " \n", - "**Nemotron‑Nano‑9B‑V2** is the second‑generation 9‑billion‑parameter language model in NVIDIA’s Nemotron‑Nano family. It is an open‑weight, general‑purpose LLM designed for both **reasoning** and **n...\n" - ] - } - ], - "source": [ - "config = {\"configurable\": {\"thread_id\": THREAD_ID}}\n", - "state = agent.get_state(config)\n", - "\n", - "print(\"Conversation History (LangChain v1.0):\")\n", - "print(\"-\" * 40)\n", - "\n", - "if state and state.values:\n", - " messages = state.values.get(\"messages\", [])\n", - " for i, msg in enumerate(messages):\n", - " role = msg.type.capitalize() if hasattr(msg, 'type') else \"Unknown\"\n", - " content = msg.content if hasattr(msg, 'content') else str(msg)\n", - " content = content[:200] + \"...\" if len(content) > 200 else content\n", - " print(f\"\\n[{i+1}] {role}:\")\n", - " print(f\" {content}\")\n", - "else:\n", - " print(\"No conversation history found.\")\n" - ] - }, - { - "cell_type": "markdown", - "id": "67ab40be", - "metadata": {}, - "source": [ - "---\n", - "\n", - "## Try Your Own Research!\n", - "\n", - "Use the cell below to try your own research queries. Change the `SESSION_ID` to start a fresh conversation.\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a47b15bb", - "metadata": {}, - "outputs": [], - "source": [ - "# Try your own research query!\n", - "# Change the thread_id to start a fresh conversation\n", - "\n", - "my_query = \"What are the latest breakthroughs in renewable energy?\"\n", - "my_thread = \"my-research\" # Use a different thread_id for a new conversation\n", - "\n", - "response = research(my_query, my_thread)\n", - "print_response(my_query, response)\n" - ] - }, - { - "cell_type": "markdown", - "id": "4c73a065", - "metadata": {}, - "source": [ - "---\n", - "\n", - "# Part 3: Multi-Agent Research System 🤝\n", - "\n", - "Now let's build a more sophisticated **multi-agent system** where specialized agents collaborate to produce high-quality research reports.\n", - "\n", - "Based on [LangChain's multi-agent patterns](https://docs.langchain.com/oss/python/langchain/multi-agent), we'll implement the **Tool Calling (Supervisor) pattern** where:\n", - "\n", - "| Agent | Role |\n", - "|-------|------|\n", - "| **Coordinator** | Orchestrates the workflow, decides which specialist to call |\n", - "| **Search Agent** | Specializes in finding relevant information from the web |\n", - "| **Report Writer** | Transforms research into well-structured reports |\n", - "| **Quality Reviewer** | Verifies helpfulness and suggests improvements |\n", - "\n", - "```\n", - "┌─────────────────┐\n", - "│ Coordinator │ ◄── User Query\n", - "│ (Supervisor) │\n", - "└────────┬────────┘\n", - " │\n", - " ┌────┴────┬──────────┐\n", - " ▼ ▼ ▼\n", - "┌───────┐ ┌────────┐ ┌──────────┐\n", - "│Search │ │Report │ │Quality │\n", - "│Agent │ │Writer │ │Reviewer │\n", - "└───────┘ └────────┘ └──────────┘\n", - "```\n" - ] - }, - { - "cell_type": "markdown", - "id": "d5b10bef", - "metadata": {}, - "source": [ - "## Step 1: Create Specialized Sub-Agents\n", - "\n", - "Each sub-agent is a focused specialist with its own system prompt and capabilities.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "id": "0055100a", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "✅ Three specialized sub-agents created:\n", - " - Search Agent (with web_search tool)\n", - " - Report Writer Agent (writing specialist)\n", - " - Quality Reviewer Agent (evaluation specialist)\n" - ] - } - ], - "source": [ - "# Create specialized sub-agents using LangChain v1.0's create_agent\n", - "# Each agent has a focused role and specialized prompt\n", - "\n", - "# 1. SEARCH AGENT - Expert at finding information\n", - "search_agent = create_agent(\n", - " model=llm,\n", - " tools=[web_search], # Has access to web search\n", - " system_prompt=\"\"\"You are a Search Specialist Agent.\n", - "\n", - "Your ONLY job is to search the web and gather relevant information.\n", - "\n", - "When given a research topic:\n", - "1. Formulate effective search queries\n", - "2. Search for multiple aspects of the topic\n", - "3. Compile the key findings\n", - "4. Return a structured summary of what you found\n", - "\n", - "Always include the sources of your information.\n", - "Be thorough but focused - gather facts, not opinions.\"\"\"\n", - ")\n", - "\n", - "# 2. REPORT WRITER AGENT - Expert at writing reports\n", - "report_writer_agent = create_agent(\n", - " model=llm,\n", - " tools=[], # No tools - pure writing capability\n", - " system_prompt=\"\"\"You are a Report Writer Specialist Agent.\n", - "\n", - "Your ONLY job is to transform raw research into well-written reports.\n", - "\n", - "When given research findings:\n", - "1. Organize information logically\n", - "2. Write clear, engaging prose\n", - "3. Include relevant sections (Overview, Key Points, Details, Conclusion)\n", - "4. Use markdown formatting for structure\n", - "5. Cite sources where appropriate\n", - "\n", - "Focus on clarity and readability. Make complex topics accessible.\"\"\"\n", - ")\n", - "\n", - "# 3. QUALITY REVIEWER AGENT - Expert at evaluating helpfulness\n", - "quality_reviewer_agent = create_agent(\n", - " model=llm,\n", - " tools=[], # No tools - pure evaluation capability\n", - " system_prompt=\"\"\"You are a Quality Reviewer Specialist Agent.\n", - "\n", - "Your ONLY job is to evaluate if a report is helpful and complete.\n", - "\n", - "When reviewing a report:\n", - "1. Check if it answers the original question\n", - "2. Verify key information is included\n", - "3. Assess clarity and readability\n", - "4. Identify any gaps or missing information\n", - "5. Provide a helpfulness score (1-10) with justification\n", - "\n", - "Be constructive - if improvements are needed, explain what's missing.\n", - "If the report is good, confirm it's ready for the user.\"\"\"\n", - ")\n", - "\n", - "print(\"✅ Three specialized sub-agents created:\")\n", - "print(\" - Search Agent (with web_search tool)\")\n", - "print(\" - Report Writer Agent (writing specialist)\")\n", - "print(\" - Quality Reviewer Agent (evaluation specialist)\")\n" - ] - }, - { - "cell_type": "markdown", - "id": "89494712", - "metadata": {}, - "source": [ - "## Step 2: Wrap Sub-Agents as Tools\n", - "\n", - "Following [LangChain's multi-agent pattern](https://docs.langchain.com/oss/python/langchain/multi-agent), we wrap each sub-agent as a tool that the coordinator can invoke.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "c3a8ae63", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "✅ Sub-agents wrapped as tools:\n", - " - call_search_agent: For gathering information\n", - " - call_report_writer: For creating reports\n", - " - call_quality_reviewer: For evaluating quality\n" - ] - } - ], - "source": [ - "# Wrap each sub-agent as a tool for the coordinator\n", - "# This is the \"Tool Calling\" multi-agent pattern from LangChain v1.0\n", - "\n", - "@tool(\"search_specialist\")\n", - "def call_search_agent(research_topic: str) -> str:\n", - " \"\"\"Call the Search Specialist to gather information from the web.\n", - " \n", - " Use this when you need to find current information, facts, or data\n", - " about a topic. The search specialist will search the web and return\n", - " a summary of findings.\n", - " \n", - " Args:\n", - " research_topic: The topic or question to research\n", - " \"\"\"\n", - " result = search_agent.invoke({\n", - " \"messages\": [{\"role\": \"user\", \"content\": f\"Research this topic: {research_topic}\"}]\n", - " })\n", - " return result[\"messages\"][-1].content\n", - "\n", - "\n", - "@tool(\"report_writer\")\n", - "def call_report_writer(research_findings: str) -> str:\n", - " \"\"\"Call the Report Writer to create a well-structured report.\n", - " \n", - " Use this after gathering research to transform raw findings into\n", - " a polished, readable report with proper structure and formatting.\n", - " \n", - " Args:\n", - " research_findings: The raw research data and findings to write about\n", - " \"\"\"\n", - " result = report_writer_agent.invoke({\n", - " \"messages\": [{\"role\": \"user\", \"content\": f\"Write a report based on these findings:\\n\\n{research_findings}\"}]\n", - " })\n", - " return result[\"messages\"][-1].content\n", - "\n", - "\n", - "@tool(\"quality_reviewer\")\n", - "def call_quality_reviewer(report_to_review: str) -> str:\n", - " \"\"\"Call the Quality Reviewer to evaluate a report's helpfulness.\n", - " \n", - " Use this to verify that a report is complete, helpful, and ready\n", - " for the user. The reviewer will score it and suggest improvements.\n", - " \n", - " Args:\n", - " report_to_review: The report content to evaluate\n", - " \"\"\"\n", - " result = quality_reviewer_agent.invoke({\n", - " \"messages\": [{\"role\": \"user\", \"content\": f\"Review this report for helpfulness and completeness:\\n\\n{report_to_review}\"}]\n", - " })\n", - " return result[\"messages\"][-1].content\n", - "\n", - "\n", - "print(\"✅ Sub-agents wrapped as tools:\")\n", - "print(\" - call_search_agent: For gathering information\")\n", - "print(\" - call_report_writer: For creating reports\")\n", - "print(\" - call_quality_reviewer: For evaluating quality\")\n" - ] - }, - { - "cell_type": "markdown", - "id": "3eef7e5d", - "metadata": {}, - "source": [ - "## Step 3: Create the Coordinator (Supervisor) Agent\n", - "\n", - "The coordinator orchestrates the workflow by deciding which specialist to call and when.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "id": "fe36faf7", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "✅ Multi-Agent Research System ready!\n", - "\n", - "Workflow: User → Coordinator → Search → Writer → Reviewer → User\n" - ] - } - ], - "source": [ - "# Create the Coordinator (Supervisor) Agent\n", - "# This agent orchestrates the multi-agent workflow\n", - "\n", - "COORDINATOR_PROMPT = \"\"\"You are a Research Coordinator managing a team of specialist agents.\n", - "\n", - "Your team consists of:\n", - "1. **Search Specialist** - Finds information from the web\n", - "2. **Report Writer** - Creates well-structured reports\n", - "3. **Quality Reviewer** - Evaluates helpfulness and completeness\n", - "\n", - "WORKFLOW for research requests:\n", - "1. First, call the Search Specialist to gather information\n", - "2. Then, call the Report Writer to create a report from the findings\n", - "3. Finally, call the Quality Reviewer to verify the report is helpful\n", - "4. If the reviewer suggests improvements, you may iterate\n", - "5. Present the final report to the user\n", - "\n", - "Always follow this workflow for research questions. Coordinate the specialists\n", - "efficiently and ensure the final output is high-quality and helpful.\n", - "\n", - "Remember: You are the coordinator. Delegate tasks to specialists - don't try\n", - "to search or write reports yourself.\"\"\"\n", - "\n", - "# Create coordinator with access to all specialist tools\n", - "multi_agent_checkpointer = InMemorySaver()\n", - "\n", - "coordinator = create_agent(\n", - " model=llm,\n", - " tools=[call_search_agent, call_report_writer, call_quality_reviewer],\n", - " system_prompt=COORDINATOR_PROMPT,\n", - " checkpointer=multi_agent_checkpointer,\n", - ")\n", - "\n", - "print(\"✅ Multi-Agent Research System ready!\")\n", - "print(\"\\nWorkflow: User → Coordinator → Search → Writer → Reviewer → User\")\n" - ] - }, - { - "cell_type": "markdown", - "id": "034d88fa", - "metadata": {}, - "source": [ - "## Step 4: Run the Multi-Agent System\n", - "\n", - "Let's test the full multi-agent workflow with a research question.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "id": "915388d0", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "============================================================\n", - "MULTI-AGENT RESEARCH DEMO\n", - "============================================================\n", - "🚀 Starting multi-agent research on: What are the key features and benefits of NVIDIA's Blackwell GPU architecture?\n", - "--------------------------------------------------\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/chris/Code/NVIDIA/Nemotron 3 Nano - Simple Usage Guide/.venv/lib/python3.13/site-packages/langchain_nvidia_ai_endpoints/chat_models.py:842: UserWarning: Model 'private/nvidia/nemotron-nano-3-30b-a3b' is not known to support tools. Your tool binding may fail at inference time.\n", - " warnings.warn(\n", - "/home/chris/Code/NVIDIA/Nemotron 3 Nano - Simple Usage Guide/.venv/lib/python3.13/site-packages/langchain_nvidia_ai_endpoints/chat_models.py:842: UserWarning: Model 'private/nvidia/nemotron-nano-3-30b-a3b' is not known to support tools. Your tool binding may fail at inference time.\n", - " warnings.warn(\n", - "/home/chris/Code/NVIDIA/Nemotron 3 Nano - Simple Usage Guide/.venv/lib/python3.13/site-packages/langchain_nvidia_ai_endpoints/chat_models.py:842: UserWarning: Model 'private/nvidia/nemotron-nano-3-30b-a3b' is not known to support tools. Your tool binding may fail at inference time.\n", - " warnings.warn(\n", - "/home/chris/Code/NVIDIA/Nemotron 3 Nano - Simple Usage Guide/.venv/lib/python3.13/site-packages/langchain_nvidia_ai_endpoints/chat_models.py:842: UserWarning: Model 'private/nvidia/nemotron-nano-3-30b-a3b' is not known to support tools. Your tool binding may fail at inference time.\n", - " warnings.warn(\n", - "/home/chris/Code/NVIDIA/Nemotron 3 Nano - Simple Usage Guide/.venv/lib/python3.13/site-packages/langchain_nvidia_ai_endpoints/chat_models.py:842: UserWarning: Model 'private/nvidia/nemotron-nano-3-30b-a3b' is not known to support tools. Your tool binding may fail at inference time.\n", - " warnings.warn(\n", - "/home/chris/Code/NVIDIA/Nemotron 3 Nano - Simple Usage Guide/.venv/lib/python3.13/site-packages/langchain_nvidia_ai_endpoints/chat_models.py:842: UserWarning: Model 'private/nvidia/nemotron-nano-3-30b-a3b' is not known to support tools. Your tool binding may fail at inference time.\n", - " warnings.warn(\n", - "/home/chris/Code/NVIDIA/Nemotron 3 Nano - Simple Usage Guide/.venv/lib/python3.13/site-packages/langchain_nvidia_ai_endpoints/chat_models.py:842: UserWarning: Model 'private/nvidia/nemotron-nano-3-30b-a3b' is not known to support tools. Your tool binding may fail at inference time.\n", - " warnings.warn(\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "============================================================\n", - "FINAL REPORT\n", - "============================================================\n", - "\n", - "**NVIDIA Blackwell GPU Architecture – Key Features, Benefits, and Expanded Details**\n", - "\n", - "---\n", - "\n", - "## 1. Overview\n", - "Blackwell is NVIDIA’s newest **GPU micro‑architecture**, succeeding Hopper and Ada Lovelace. It is purpose‑built for two primary workloads:\n", - "\n", - "| Workload | What Blackwell does |\n", - "|----------|----------------------|\n", - "| **AI training & inference** | Accelerates large‑scale model training (LLMs, diffusion, recommendation) and high‑throughput inference. |\n", - "| **High‑performance graphics** | Powers the upcoming **RTX 50‑series** graphics cards and the **RTX PRO 6000 Blackwell** workstation GPUs. |\n", - "\n", - "---\n", - "\n", - "## 2. Core Features (with technical specifics)\n", - "\n", - "| Feature | Technical Detail | Why It Matters |\n", - "|---------|-----------------|----------------|\n", - "| **5th‑Generation Tensor Cores** | • Up to **1,000 TFLOPs** of FP8/FP16/TF32 compute per GPU.
• New matrix‑multiply instructions that fuse attention kernels. | Delivers dramatically higher AI‑compute throughput and efficiency. |\n", - "| **AI Multi‑Frame Generation (DLSS 4)** | Generates **2 ×** frames per render pass; supports up to **8K** resolution with < 5 ms latency.
Works with RTX‑ON ray tracing. | Doubles frame rates in games/VR while preserving or improving image quality. |\n", - "| **AI Management Processor (AMP)** | Small RISC‑V core integrated on‑die; handles work‑graph scheduling, context switching, and VRAM orchestration. | Reduces CPU‑GPU overhead, improves effective VRAM bandwidth by ~30 %. |\n", - "| **Enhanced Transformer Engine** | • Optimized attention‑fusion kernels.
• Larger on‑chip scratchpad for KV‑cache reuse. | Cuts training/inference time for transformer‑based models (e.g., 30 B‑parameter LLMs). |\n", - "| **Performance‑Scale Metrics** | • **Base Blackwell GPU:** 10 petaFLOPS (NVFP4).
• **Blackwell Ultra:** up to 15 petaFLOPS (≈1.5× base, ~7.5× Hopper H100).
• **Training:** up to **3×** faster vs. H100.
• **Inference:** up to **15×** faster vs. H100.
• **GPU density:** up to **4×** Blackwell GPUs in a single workstation (e.g., 4× RTX PRO 6000) without thermal overload. | Quantifies real‑world speedups and scalability. |\n", - "| **Memory Subsystem** | • **Memory bandwidth:** up to **3.2 TB/s** (GDDR7).
• **Capacity:** 48 GB or 96 GB HBM3e per GPU.
• **L2 cache:** 120 MB shared. | Enables larger batch sizes and higher model parallelism. |\n", - "| **Power & Thermal Design** | • **TDP:** 350 W (standard), 450 W (Ultra).
• **Cooling:** Dual‑fan + vapor‑chamber; designed for up to **4‑GPU** packing in a 2U chassis. | Provides a balance of performance and power‑efficiency for data‑center and workstation use. |\n", - "| **Software Stack** | • Supports **CUDA 12.5**, **TensorRT 9**, ** cuDNN 9**.
• New APIs for **work‑graph scheduling** and **dynamic kernelRegistration**. | Ensures compatibility with existing AI frameworks (PyTorch, TensorFlow) and optimizations. |\n", - "\n", - "*Sources: Search results 1‑4 (NVIDIA blog, architecture briefings, performance tables).*\n", - "\n", - "---\n", - "\n", - "## 3. Key Benefits (with concrete numbers)\n", - "\n", - "| Benefit | Concrete Figure / Example | Impact |\n", - "|---------|---------------------------|--------|\n", - "| **Accelerated AI training** | 3× faster training of a 70 B LLM compared with H100 (≈ 2 days → 16 hours on a 8‑GPU Blackwell cluster). | Reduces time‑to‑market for new models. |\n", - "| **High‑speed inference** | 15× lower latency for a 175 B parameter model (≈ 30 ms → 2 ms per token). | Cuts **cost‑per‑token** by ~85 % for large‑scale serving. |\n", - "| **Graphics performance** | DLSS 4 can push **120 fps** in 4K gaming titles (e.g., *Cyberpunk 2077* RTX‑ON) vs. 60 fps with DLSS 3. | Enables smoother VR/AR experiences. |\n", - "| **VRAM efficiency** | Effective VRAM bandwidth ↑ 30 % thanks to AMP; allows **2×** larger batch sizes on the same memory footprint. | Larger models can be deployed on a single GPU. |\n", - "| **Scalable multi‑GPU configurations** | 4‑GPU workstation (e.g., 4× RTX PRO 6000) shows **2.9×** scaling efficiency on mixed‑precision training (MLPerf Training v2.0). | Facilitates dense AI clusters without extra rack space. |\n", - "| **Cost‑per‑token reduction** | Estimated **$0.00012 per token** for a 70 B model on Blackwell vs. **$0.0010** on H100 (≈ 88 % savings). | Makes large‑scale AI services economically viable. |\n", - "| **Future‑ready ecosystem** | Full CUDA 12.5 support; TensorRT 9 optimizations; planned roadmap through **2027** with “Blackwell‑X” prototype slated for 2026. | Protects developer investments and ensures longevity. |\n", - "\n", - "---\n", - "\n", - "## 4. Technical Specification Snapshot \n", - "\n", - "| Spec | Blackwell (Base) | Blackwell Ultra |\n", - "|------|------------------|-----------------|\n", - "| **FP8/TF32 Compute** | 1,000 TFLOPs | 1,500 TFLOPs |\n", - "| **CUDA Cores** | 18,432 | 23,040 |\n", - "| **Tensor Cores (5th‑Gen)** | 576 | 720 |\n", - "| **RT Cores (3rd‑Gen)** | 72 | 96 |\n", - "| **Memory** | 48 GB/96 GB HBM3e | 96 GB HBM3e |\n", - "| **Memory Bandwidth** | 3.2 TB/s | 3.5 TB/s |\n", - "| **L2 Cache** | 120 MB | 150 MB |\n", - "| **TDP** | 350 W | 450 W |\n", - "| **Process Node** | 5 nm (TSMC) | 5 nm (TSMC) |\n", - "| **Launch** | Q3 2024 | Q1 2025 |\n", - "\n", - "---\n", - "\n", - "## 5. Competitive Landscape (quick comparison)\n", - "\n", - "| Metric | NVIDIA Blackwell | AMD Instinct MI300X | Intel Xe‑HPC (3rd Gen) |\n", - "|--------|-------------------|--------------------|------------------------|\n", - "| **Peak TFLOPs (FP16)** | 1,000 | 900 | 800 |\n", - "| **Inference Speed (LLM token/sec)** | 15× vs. H100 | ~12× vs. MI250X | ~10× vs. Habana Gaudi 2 |\n", - "| **Memory Bandwidth** | 3.2 TB/s | 2.5 TB/s | 2.2 TB/s |\n", - "| **Power Efficiency (TFLOP/W)** | 2.9 TFLOP/W | 2.5 TFLOP/W | 2.2 TFLOP/W |\n", - "| **Software Ecosystem** | CUDA, TensorRT, cuDNN (mature) | ROCm (growing) | oneAPI (early adoption) |\n", - "\n", - "*Blackwell leads on raw performance, inference speed, and software maturity.*\n", - "\n", - "---\n", - "\n", - "## 6. Future Outlook\n", - "- **Blackwell‑X (prototype)** slated for 2026 with **doubling of Tensor Core count** and **support for FP4** precision.\n", - "- NVIDIA plans **continuous driver and CUDA updates** through **2027**, ensuring backward compatibility.\n", - "- Expect **more RTX 50‑series GPUs** (mobile, laptop, and data‑center form factors) to leverage Blackwell’s architecture.\n", - "\n", - "---\n", - "\n", - "## 7. Bottom Line\n", - "The **NVIDIA Blackwell GPU architecture** combines:\n", - "\n", - "- **5th‑generation Tensor Cores** for unmatched AI compute.\n", - "- **DLSS 4 multi‑frame generation** for double‑speed graphics.\n", - "- An **AI Management Processor** that optimizes VRAM scheduling.\n", - "- **Performance metrics** that translate to **3× faster training** and **15× faster inference** versus the previous H100 generation.\n", - "- **Scalable, power‑efficient designs** that enable dense multi‑GPU workstations and data‑center deployments.\n", - "\n", - "These capabilities make Blackwell the **go‑to platform for next‑generation AI development and high‑fidelity, low‑latency graphics**, delivering tangible speed, cost, and efficiency benefits across industries.\n", - "\n", - "---\n", - "\n", - "### References (source of the original research)\n", - "\n", - "1. *NVIDIA Blog – “Blackwell: 3× faster training, 15× faster inference, DLSS 4 frame‑rate gains”*【Search result 1】 \n", - "2. *Architecture Brief – “5th‑Gen Tensor Cores & RTX 50‑series support”*【Search result 2】 \n", - "3. *Performance Whitepaper – “10 → 15 petaFLOPS, Hopper comparison, MLPerf results”*【Search result 3】 \n", - "4. *Technical Deep‑Dive – “AI Management Processor, VRAM efficiency, memory specs”*【Search result 4】\n", - "\n", - "--- \n", - "\n", - "Feel free to let me know if you’d like any additional details (e.g., price estimates, specific benchmark numbers, or a deeper dive into the software stack).\n" - ] - } - ], - "source": [ - "# Helper function for multi-agent research\n", - "def multi_agent_research(topic: str, thread_id: str = \"multi-agent-default\") -> str:\n", - " \"\"\"Run a research query through the multi-agent system.\n", - " \n", - " The coordinator will orchestrate:\n", - " 1. Search Agent → gather information\n", - " 2. Report Writer → create report\n", - " 3. Quality Reviewer → verify helpfulness\n", - " \"\"\"\n", - " config = {\"configurable\": {\"thread_id\": thread_id}}\n", - " \n", - " print(f\"🚀 Starting multi-agent research on: {topic}\")\n", - " print(\"-\" * 50)\n", - " \n", - " result = coordinator.invoke(\n", - " {\"messages\": [{\"role\": \"user\", \"content\": topic}]},\n", - " config=config\n", - " )\n", - " \n", - " # Get the final response\n", - " final_response = result[\"messages\"][-1].content\n", - " return final_response\n", - "\n", - "# Demo: Run a multi-agent research query\n", - "MULTI_AGENT_THREAD = \"research-demo\"\n", - "\n", - "research_topic = \"What are the key features and benefits of NVIDIA's Blackwell GPU architecture?\"\n", - "\n", - "print(\"=\" * 60)\n", - "print(\"MULTI-AGENT RESEARCH DEMO\")\n", - "print(\"=\" * 60)\n", - "\n", - "final_report = multi_agent_research(research_topic, MULTI_AGENT_THREAD)\n", - "\n", - "print(\"\\n\" + \"=\" * 60)\n", - "print(\"FINAL REPORT\")\n", - "print(\"=\" * 60)\n", - "print(final_report)\n" - ] - }, - { - "cell_type": "markdown", - "id": "fd2a7162", - "metadata": {}, - "source": [ - "### View Multi-Agent Collaboration\n", - "\n", - "Let's see how the agents collaborated - which tools were called and in what order:\n" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "id": "007c6567", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Multi-Agent Collaboration Log:\n", - "==================================================\n", - "\n", - "[1] 👤 USER: What are the key features and benefits of NVIDIA's Blackwell GPU architecture?...\n", - "\n", - "[2] 🔧 TOOL CALL: search_specialist\n", - " Args: {'research_topic': 'NVIDIA Blackwell GPU architecture key features and benefits'}\n", - "\n", - "[3] 📥 TOOL RESULT (search_specialist):\n", - " \n", - "**NVIDIA Blackwell GPU Architecture – Key Features & Benefits** \n", - "\n", - "---\n", - "\n", - "### 1. Overview \n", - "Blackwell is NVIDIA’s latest graphics‑processing‑unit micro...\n", - "\n", - "[4] 🔧 TOOL CALL: quality_reviewer\n", - " Args: {'report_to_review': 'NVIDIA Blackwell GPU Architecture – Key Features & Benefits\\n\\n---\\n\\n### 1. O...\n", - "\n", - "[5] 📥 TOOL RESULT (quality_reviewer):\n", - " \n", - "**Overall helpfulness score: 8 / 10**\n", - "\n", - "---\n", - "\n", - "### ✅ What the report does well \n", - "\n", - "| Criterion | Evaluation | Why it earns points |\n", - "|-----------|--------...\n", - "\n", - "[6] 🤖 COORDINATOR: \n", - "**NVIDIA Blackwell GPU Architecture – Key Features, Benefits, and Expanded Details**\n", - "\n", - "---\n", - "\n", - "## 1. Overview\n", - "Blackwell is NVIDIA’s newest **GPU micro‑ar...\n" - ] - } - ], - "source": [ - "# View the multi-agent collaboration history\n", - "config = {\"configurable\": {\"thread_id\": MULTI_AGENT_THREAD}}\n", - "state = coordinator.get_state(config)\n", - "\n", - "print(\"Multi-Agent Collaboration Log:\")\n", - "print(\"=\" * 50)\n", - "\n", - "if state and state.values:\n", - " messages = state.values.get(\"messages\", [])\n", - " for i, msg in enumerate(messages):\n", - " msg_type = msg.type.upper() if hasattr(msg, 'type') else \"UNKNOWN\"\n", - " \n", - " # Check if it's a tool call\n", - " if msg_type == \"AI\" and hasattr(msg, 'tool_calls') and msg.tool_calls:\n", - " for tc in msg.tool_calls:\n", - " print(f\"\\n[{i+1}] 🔧 TOOL CALL: {tc.get('name', 'unknown')}\")\n", - " args = tc.get('args', {})\n", - " arg_preview = str(args)[:100] + \"...\" if len(str(args)) > 100 else str(args)\n", - " print(f\" Args: {arg_preview}\")\n", - " elif msg_type == \"TOOL\":\n", - " tool_name = msg.name if hasattr(msg, 'name') else \"unknown\"\n", - " content_preview = msg.content[:150] + \"...\" if len(msg.content) > 150 else msg.content\n", - " print(f\"\\n[{i+1}] 📥 TOOL RESULT ({tool_name}):\")\n", - " print(f\" {content_preview}\")\n", - " elif msg_type == \"HUMAN\":\n", - " print(f\"\\n[{i+1}] 👤 USER: {msg.content[:100]}...\")\n", - " elif msg_type == \"AI\":\n", - " content_preview = msg.content[:150] + \"...\" if len(msg.content) > 150 else msg.content\n", - " print(f\"\\n[{i+1}] 🤖 COORDINATOR: {content_preview}\")\n", - "else:\n", - " print(\"No collaboration history found.\")\n" - ] - }, - { - "cell_type": "markdown", - "id": "cc99fddb", - "metadata": {}, - "source": [ - "## Try Your Own Multi-Agent Research\n", - "\n", - "Run any research topic through the multi-agent system:\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "aa452c34", - "metadata": {}, - "outputs": [], - "source": [ - "# Try your own multi-agent research!\n", - "# Change the topic and thread_id as desired\n", - "\n", - "my_topic = \"What are the latest advancements in quantum computing in 2024?\"\n", - "my_thread = \"my-multi-agent-research\"\n", - "\n", - "report = multi_agent_research(my_topic, my_thread)\n", - "print(\"\\n\" + \"=\" * 60)\n", - "print(\"YOUR RESEARCH REPORT\")\n", - "print(\"=\" * 60)\n", - "print(report)\n" - ] - }, - { - "cell_type": "markdown", - "id": "b51e3823", - "metadata": {}, - "source": [ - "---\n", - "\n", - "# Summary\n", - "\n", - "In this notebook, we covered:\n", - "\n", - "### Part 1: Basic Usage\n", - "- Setting up the OpenAI-compatible client via **OpenRouter**\n", - "- **Reasoning ON**: Chain-of-thought reasoning (best for complex problems)\n", - "- **Reasoning OFF**: Direct answers (best for simple queries)\n", - "\n", - "### Part 2: LangChain v1.0 Single Agent\n", - "- Used the new **`create_agent`** API\n", - "- Integrated NVIDIA Nemotron via **OpenRouter** using `ChatOpenAI` with custom `base_url`\n", - "- Added **web search** capability with `@tool` decorator\n", - "- Implemented **conversation memory** using `InMemorySaver` checkpointer\n", - "\n", - "### Part 3: Multi-Agent System\n", - "- Created **specialized sub-agents** (Search, Report Writer, Quality Reviewer)\n", - "- Wrapped sub-agents as **tools** following [LangChain's multi-agent pattern](https://docs.langchain.com/oss/python/langchain/multi-agent)\n", - "- Built a **Coordinator (Supervisor)** agent to orchestrate the workflow\n", - "- Demonstrated the full **research pipeline**: Search → Write → Review\n", - "\n", - "## Multi-Agent Architecture\n", - "\n", - "```\n", - "┌─────────────────────────────────────────────────────┐\n", - "│ COORDINATOR │\n", - "│ (Decides which specialist to call and when) │\n", - "└─────────────┬─────────────┬─────────────┬───────────┘\n", - " │ │ │\n", - " ┌────────▼────┐ ┌─────▼──────┐ ┌───▼────────┐\n", - " │ SEARCH │ │ REPORT │ │ QUALITY │\n", - " │ AGENT │ │ WRITER │ │ REVIEWER |\n", - " │ (web_search)│ │ (writing) │ │(evaluation)│\n", - " └─────────────┘ └────────────┘ └────────────┘\n", - "```\n", - "\n", - "## Key LangChain v1.0 Patterns Used\n", - "\n", - "| Pattern | Description |\n", - "|---------|-------------|\n", - "| `create_agent` | New simplified agent creation API |\n", - "| `@tool` decorator | Define tools from functions |\n", - "| `InMemorySaver` | Thread-based conversation memory |\n", - "| **Tool Calling** | Sub-agents wrapped as tools for orchestration |\n", - "\n", - "## Resources\n", - "\n", - "- [OpenRouter Documentation](https://openrouter.ai/docs)\n", - "- [LangChain Chat Completions API (OpenRouter)](https://docs.langchain.com/oss/python/integrations/chat/index)\n", - "- [LangChain v1.0 Release Notes](https://docs.langchain.com/oss/python/releases/langchain-v1)\n", - "- [Multi-Agent Patterns](https://docs.langchain.com/oss/python/langchain/multi-agent)\n", - "- [Supervisor Agent Tutorial](https://docs.langchain.com/oss/python/langchain/supervisor)\n", - "- [LangGraph for Advanced Agents](https://langchain-ai.github.io/langgraph/)\n" - ] - }, - { - "cell_type": "markdown", - "id": "af0a8b75", - "metadata": {}, - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": ".venv", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.13.4" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/uv.lock b/uv.lock new file mode 100644 index 0000000..edb4618 --- /dev/null +++ b/uv.lock @@ -0,0 +1,4916 @@ +version = 1 +revision = 3 +requires-python = ">=3.10" +resolution-markers = [ + "python_full_version >= '3.14' and sys_platform == 'linux'", + "python_full_version == '3.13.*' and sys_platform == 'linux'", + "python_full_version == '3.12.*' and sys_platform == 'linux'", + "python_full_version == '3.11.*' and sys_platform == 'linux'", + "python_full_version >= '3.14' and sys_platform != 'linux'", + "python_full_version == '3.13.*' and sys_platform != 'linux'", + "python_full_version == '3.12.*' and sys_platform != 'linux'", + "python_full_version == '3.11.*' and sys_platform != 'linux'", + "python_full_version < '3.11' and sys_platform == 'linux'", + "python_full_version < '3.11' and sys_platform != 'linux'", +] + +[[package]] +name = "absl-py" +version = "2.3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/10/2a/c93173ffa1b39c1d0395b7e842bbdc62e556ca9d8d3b5572926f3e4ca752/absl_py-2.3.1.tar.gz", hash = "sha256:a97820526f7fbfd2ec1bce83f3f25e3a14840dac0d8e02a0b71cd75db3f77fc9", size = 116588, upload-time = "2025-07-03T09:31:44.05Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8f/aa/ba0014cc4659328dc818a28827be78e6d97312ab0cb98105a770924dc11e/absl_py-2.3.1-py3-none-any.whl", hash = "sha256:eeecf07f0c2a93ace0772c92e596ace6d3d3996c042b2128459aaae2a76de11d", size = 135811, upload-time = "2025-07-03T09:31:42.253Z" }, +] + +[[package]] +name = "accessible-pygments" +version = "0.0.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/bc/c1/bbac6a50d02774f91572938964c582fff4270eee73ab822a4aeea4d8b11b/accessible_pygments-0.0.5.tar.gz", hash = "sha256:40918d3e6a2b619ad424cb91e556bd3bd8865443d9f22f1dcdf79e33c8046872", size = 1377899, upload-time = "2024-05-10T11:23:10.216Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8d/3f/95338030883d8c8b91223b4e21744b04d11b161a3ef117295d8241f50ab4/accessible_pygments-0.0.5-py3-none-any.whl", hash = "sha256:88ae3211e68a1d0b011504b2ffc1691feafce124b845bd072ab6f9f66f34d4b7", size = 1395903, upload-time = "2024-05-10T11:23:08.421Z" }, +] + +[[package]] +name = "aiobotocore" +version = "2.26.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "aiohttp" }, + { name = "aioitertools" }, + { name = "botocore" }, + { name = "jmespath" }, + { name = "multidict" }, + { name = "python-dateutil" }, + { name = "wrapt" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/4d/f8/99fa90d9c25b78292899fd4946fce97b6353838b5ecc139ad8ba1436e70c/aiobotocore-2.26.0.tar.gz", hash = "sha256:50567feaf8dfe2b653570b4491f5bc8c6e7fb9622479d66442462c021db4fadc", size = 122026, upload-time = "2025-11-28T07:54:59.956Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/58/3bf0b7d474607dc7fd67dd1365c4e0f392c8177eaf4054e5ddee3ebd53b5/aiobotocore-2.26.0-py3-none-any.whl", hash = "sha256:a793db51c07930513b74ea7a95bd79aaa42f545bdb0f011779646eafa216abec", size = 87333, upload-time = "2025-11-28T07:54:58.457Z" }, +] + +[[package]] +name = "aiohappyeyeballs" +version = "2.6.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/26/30/f84a107a9c4331c14b2b586036f40965c128aa4fee4dda5d3d51cb14ad54/aiohappyeyeballs-2.6.1.tar.gz", hash = "sha256:c3f9d0113123803ccadfdf3f0faa505bc78e6a72d1cc4806cbd719826e943558", size = 22760, upload-time = "2025-03-12T01:42:48.764Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0f/15/5bf3b99495fb160b63f95972b81750f18f7f4e02ad051373b669d17d44f2/aiohappyeyeballs-2.6.1-py3-none-any.whl", hash = "sha256:f349ba8f4b75cb25c99c5c2d84e997e485204d2902a9597802b0371f09331fb8", size = 15265, upload-time = "2025-03-12T01:42:47.083Z" }, +] + +[[package]] +name = "aiohttp" +version = "3.13.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "aiohappyeyeballs" }, + { name = "aiosignal" }, + { name = "async-timeout", marker = "python_full_version < '3.11'" }, + { name = "attrs" }, + { name = "frozenlist" }, + { name = "multidict" }, + { name = "propcache" }, + { name = "yarl" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/1c/ce/3b83ebba6b3207a7135e5fcaba49706f8a4b6008153b4e30540c982fae26/aiohttp-3.13.2.tar.gz", hash = "sha256:40176a52c186aefef6eb3cad2cdd30cd06e3afbe88fe8ab2af9c0b90f228daca", size = 7837994, upload-time = "2025-10-28T20:59:39.937Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6d/34/939730e66b716b76046dedfe0842995842fa906ccc4964bba414ff69e429/aiohttp-3.13.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:2372b15a5f62ed37789a6b383ff7344fc5b9f243999b0cd9b629d8bc5f5b4155", size = 736471, upload-time = "2025-10-28T20:55:27.924Z" }, + { url = "https://files.pythonhosted.org/packages/fd/cf/dcbdf2df7f6ca72b0bb4c0b4509701f2d8942cf54e29ca197389c214c07f/aiohttp-3.13.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e7f8659a48995edee7229522984bd1009c1213929c769c2daa80b40fe49a180c", size = 493985, upload-time = "2025-10-28T20:55:29.456Z" }, + { url = "https://files.pythonhosted.org/packages/9d/87/71c8867e0a1d0882dcbc94af767784c3cb381c1c4db0943ab4aae4fed65e/aiohttp-3.13.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:939ced4a7add92296b0ad38892ce62b98c619288a081170695c6babe4f50e636", size = 489274, upload-time = "2025-10-28T20:55:31.134Z" }, + { url = "https://files.pythonhosted.org/packages/38/0f/46c24e8dae237295eaadd113edd56dee96ef6462adf19b88592d44891dc5/aiohttp-3.13.2-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6315fb6977f1d0dd41a107c527fee2ed5ab0550b7d885bc15fee20ccb17891da", size = 1668171, upload-time = "2025-10-28T20:55:36.065Z" }, + { url = "https://files.pythonhosted.org/packages/eb/c6/4cdfb4440d0e28483681a48f69841fa5e39366347d66ef808cbdadddb20e/aiohttp-3.13.2-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:6e7352512f763f760baaed2637055c49134fd1d35b37c2dedfac35bfe5cf8725", size = 1636036, upload-time = "2025-10-28T20:55:37.576Z" }, + { url = "https://files.pythonhosted.org/packages/84/37/8708cf678628216fb678ab327a4e1711c576d6673998f4f43e86e9ae90dd/aiohttp-3.13.2-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e09a0a06348a2dd73e7213353c90d709502d9786219f69b731f6caa0efeb46f5", size = 1727975, upload-time = "2025-10-28T20:55:39.457Z" }, + { url = "https://files.pythonhosted.org/packages/e6/2e/3ebfe12fdcb9b5f66e8a0a42dffcd7636844c8a018f261efb2419f68220b/aiohttp-3.13.2-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a09a6d073fb5789456545bdee2474d14395792faa0527887f2f4ec1a486a59d3", size = 1815823, upload-time = "2025-10-28T20:55:40.958Z" }, + { url = "https://files.pythonhosted.org/packages/a1/4f/ca2ef819488cbb41844c6cf92ca6dd15b9441e6207c58e5ae0e0fc8d70ad/aiohttp-3.13.2-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b59d13c443f8e049d9e94099c7e412e34610f1f49be0f230ec656a10692a5802", size = 1669374, upload-time = "2025-10-28T20:55:42.745Z" }, + { url = "https://files.pythonhosted.org/packages/f8/fe/1fe2e1179a0d91ce09c99069684aab619bf2ccde9b20bd6ca44f8837203e/aiohttp-3.13.2-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:20db2d67985d71ca033443a1ba2001c4b5693fe09b0e29f6d9358a99d4d62a8a", size = 1555315, upload-time = "2025-10-28T20:55:44.264Z" }, + { url = "https://files.pythonhosted.org/packages/5a/2b/f3781899b81c45d7cbc7140cddb8a3481c195e7cbff8e36374759d2ab5a5/aiohttp-3.13.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:960c2fc686ba27b535f9fd2b52d87ecd7e4fd1cf877f6a5cba8afb5b4a8bd204", size = 1639140, upload-time = "2025-10-28T20:55:46.626Z" }, + { url = "https://files.pythonhosted.org/packages/72/27/c37e85cd3ece6f6c772e549bd5a253d0c122557b25855fb274224811e4f2/aiohttp-3.13.2-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:6c00dbcf5f0d88796151e264a8eab23de2997c9303dd7c0bf622e23b24d3ce22", size = 1645496, upload-time = "2025-10-28T20:55:48.933Z" }, + { url = "https://files.pythonhosted.org/packages/66/20/3af1ab663151bd3780b123e907761cdb86ec2c4e44b2d9b195ebc91fbe37/aiohttp-3.13.2-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:fed38a5edb7945f4d1bcabe2fcd05db4f6ec7e0e82560088b754f7e08d93772d", size = 1697625, upload-time = "2025-10-28T20:55:50.377Z" }, + { url = "https://files.pythonhosted.org/packages/95/eb/ae5cab15efa365e13d56b31b0d085a62600298bf398a7986f8388f73b598/aiohttp-3.13.2-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:b395bbca716c38bef3c764f187860e88c724b342c26275bc03e906142fc5964f", size = 1542025, upload-time = "2025-10-28T20:55:51.861Z" }, + { url = "https://files.pythonhosted.org/packages/e9/2d/1683e8d67ec72d911397fe4e575688d2a9b8f6a6e03c8fdc9f3fd3d4c03f/aiohttp-3.13.2-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:204ffff2426c25dfda401ba08da85f9c59525cdc42bda26660463dd1cbcfec6f", size = 1714918, upload-time = "2025-10-28T20:55:53.515Z" }, + { url = "https://files.pythonhosted.org/packages/99/a2/ffe8e0e1c57c5e542d47ffa1fcf95ef2b3ea573bf7c4d2ee877252431efc/aiohttp-3.13.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:05c4dd3c48fb5f15db31f57eb35374cb0c09afdde532e7fb70a75aede0ed30f6", size = 1656113, upload-time = "2025-10-28T20:55:55.438Z" }, + { url = "https://files.pythonhosted.org/packages/0d/42/d511aff5c3a2b06c09d7d214f508a4ad8ac7799817f7c3d23e7336b5e896/aiohttp-3.13.2-cp310-cp310-win32.whl", hash = "sha256:e574a7d61cf10351d734bcddabbe15ede0eaa8a02070d85446875dc11189a251", size = 432290, upload-time = "2025-10-28T20:55:56.96Z" }, + { url = "https://files.pythonhosted.org/packages/8b/ea/1c2eb7098b5bad4532994f2b7a8228d27674035c9b3234fe02c37469ef14/aiohttp-3.13.2-cp310-cp310-win_amd64.whl", hash = "sha256:364f55663085d658b8462a1c3f17b2b84a5c2e1ba858e1b79bff7b2e24ad1514", size = 455075, upload-time = "2025-10-28T20:55:58.373Z" }, + { url = "https://files.pythonhosted.org/packages/35/74/b321e7d7ca762638cdf8cdeceb39755d9c745aff7a64c8789be96ddf6e96/aiohttp-3.13.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:4647d02df098f6434bafd7f32ad14942f05a9caa06c7016fdcc816f343997dd0", size = 743409, upload-time = "2025-10-28T20:56:00.354Z" }, + { url = "https://files.pythonhosted.org/packages/99/3d/91524b905ec473beaf35158d17f82ef5a38033e5809fe8742e3657cdbb97/aiohttp-3.13.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:e3403f24bcb9c3b29113611c3c16a2a447c3953ecf86b79775e7be06f7ae7ccb", size = 497006, upload-time = "2025-10-28T20:56:01.85Z" }, + { url = "https://files.pythonhosted.org/packages/eb/d3/7f68bc02a67716fe80f063e19adbd80a642e30682ce74071269e17d2dba1/aiohttp-3.13.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:43dff14e35aba17e3d6d5ba628858fb8cb51e30f44724a2d2f0c75be492c55e9", size = 493195, upload-time = "2025-10-28T20:56:03.314Z" }, + { url = "https://files.pythonhosted.org/packages/98/31/913f774a4708775433b7375c4f867d58ba58ead833af96c8af3621a0d243/aiohttp-3.13.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e2a9ea08e8c58bb17655630198833109227dea914cd20be660f52215f6de5613", size = 1747759, upload-time = "2025-10-28T20:56:04.904Z" }, + { url = "https://files.pythonhosted.org/packages/e8/63/04efe156f4326f31c7c4a97144f82132c3bb21859b7bb84748d452ccc17c/aiohttp-3.13.2-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:53b07472f235eb80e826ad038c9d106c2f653584753f3ddab907c83f49eedead", size = 1704456, upload-time = "2025-10-28T20:56:06.986Z" }, + { url = "https://files.pythonhosted.org/packages/8e/02/4e16154d8e0a9cf4ae76f692941fd52543bbb148f02f098ca73cab9b1c1b/aiohttp-3.13.2-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e736c93e9c274fce6419af4aac199984d866e55f8a4cec9114671d0ea9688780", size = 1807572, upload-time = "2025-10-28T20:56:08.558Z" }, + { url = "https://files.pythonhosted.org/packages/34/58/b0583defb38689e7f06798f0285b1ffb3a6fb371f38363ce5fd772112724/aiohttp-3.13.2-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ff5e771f5dcbc81c64898c597a434f7682f2259e0cd666932a913d53d1341d1a", size = 1895954, upload-time = "2025-10-28T20:56:10.545Z" }, + { url = "https://files.pythonhosted.org/packages/6b/f3/083907ee3437425b4e376aa58b2c915eb1a33703ec0dc30040f7ae3368c6/aiohttp-3.13.2-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a3b6fb0c207cc661fa0bf8c66d8d9b657331ccc814f4719468af61034b478592", size = 1747092, upload-time = "2025-10-28T20:56:12.118Z" }, + { url = "https://files.pythonhosted.org/packages/ac/61/98a47319b4e425cc134e05e5f3fc512bf9a04bf65aafd9fdcda5d57ec693/aiohttp-3.13.2-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:97a0895a8e840ab3520e2288db7cace3a1981300d48babeb50e7425609e2e0ab", size = 1606815, upload-time = "2025-10-28T20:56:14.191Z" }, + { url = "https://files.pythonhosted.org/packages/97/4b/e78b854d82f66bb974189135d31fce265dee0f5344f64dd0d345158a5973/aiohttp-3.13.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:9e8f8afb552297aca127c90cb840e9a1d4bfd6a10d7d8f2d9176e1acc69bad30", size = 1723789, upload-time = "2025-10-28T20:56:16.101Z" }, + { url = "https://files.pythonhosted.org/packages/ed/fc/9d2ccc794fc9b9acd1379d625c3a8c64a45508b5091c546dea273a41929e/aiohttp-3.13.2-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:ed2f9c7216e53c3df02264f25d824b079cc5914f9e2deba94155190ef648ee40", size = 1718104, upload-time = "2025-10-28T20:56:17.655Z" }, + { url = "https://files.pythonhosted.org/packages/66/65/34564b8765ea5c7d79d23c9113135d1dd3609173da13084830f1507d56cf/aiohttp-3.13.2-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:99c5280a329d5fa18ef30fd10c793a190d996567667908bef8a7f81f8202b948", size = 1785584, upload-time = "2025-10-28T20:56:19.238Z" }, + { url = "https://files.pythonhosted.org/packages/30/be/f6a7a426e02fc82781afd62016417b3948e2207426d90a0e478790d1c8a4/aiohttp-3.13.2-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:2ca6ffef405fc9c09a746cb5d019c1672cd7f402542e379afc66b370833170cf", size = 1595126, upload-time = "2025-10-28T20:56:20.836Z" }, + { url = "https://files.pythonhosted.org/packages/e5/c7/8e22d5d28f94f67d2af496f14a83b3c155d915d1fe53d94b66d425ec5b42/aiohttp-3.13.2-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:47f438b1a28e926c37632bff3c44df7d27c9b57aaf4e34b1def3c07111fdb782", size = 1800665, upload-time = "2025-10-28T20:56:22.922Z" }, + { url = "https://files.pythonhosted.org/packages/d1/11/91133c8b68b1da9fc16555706aa7276fdf781ae2bb0876c838dd86b8116e/aiohttp-3.13.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9acda8604a57bb60544e4646a4615c1866ee6c04a8edef9b8ee6fd1d8fa2ddc8", size = 1739532, upload-time = "2025-10-28T20:56:25.924Z" }, + { url = "https://files.pythonhosted.org/packages/17/6b/3747644d26a998774b21a616016620293ddefa4d63af6286f389aedac844/aiohttp-3.13.2-cp311-cp311-win32.whl", hash = "sha256:868e195e39b24aaa930b063c08bb0c17924899c16c672a28a65afded9c46c6ec", size = 431876, upload-time = "2025-10-28T20:56:27.524Z" }, + { url = "https://files.pythonhosted.org/packages/c3/63/688462108c1a00eb9f05765331c107f95ae86f6b197b865d29e930b7e462/aiohttp-3.13.2-cp311-cp311-win_amd64.whl", hash = "sha256:7fd19df530c292542636c2a9a85854fab93474396a52f1695e799186bbd7f24c", size = 456205, upload-time = "2025-10-28T20:56:29.062Z" }, + { url = "https://files.pythonhosted.org/packages/29/9b/01f00e9856d0a73260e86dd8ed0c2234a466c5c1712ce1c281548df39777/aiohttp-3.13.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:b1e56bab2e12b2b9ed300218c351ee2a3d8c8fdab5b1ec6193e11a817767e47b", size = 737623, upload-time = "2025-10-28T20:56:30.797Z" }, + { url = "https://files.pythonhosted.org/packages/5a/1b/4be39c445e2b2bd0aab4ba736deb649fabf14f6757f405f0c9685019b9e9/aiohttp-3.13.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:364e25edaabd3d37b1db1f0cbcee8c73c9a3727bfa262b83e5e4cf3489a2a9dc", size = 492664, upload-time = "2025-10-28T20:56:32.708Z" }, + { url = "https://files.pythonhosted.org/packages/28/66/d35dcfea8050e131cdd731dff36434390479b4045a8d0b9d7111b0a968f1/aiohttp-3.13.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c5c94825f744694c4b8db20b71dba9a257cd2ba8e010a803042123f3a25d50d7", size = 491808, upload-time = "2025-10-28T20:56:34.57Z" }, + { url = "https://files.pythonhosted.org/packages/00/29/8e4609b93e10a853b65f8291e64985de66d4f5848c5637cddc70e98f01f8/aiohttp-3.13.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ba2715d842ffa787be87cbfce150d5e88c87a98e0b62e0f5aa489169a393dbbb", size = 1738863, upload-time = "2025-10-28T20:56:36.377Z" }, + { url = "https://files.pythonhosted.org/packages/9d/fa/4ebdf4adcc0def75ced1a0d2d227577cd7b1b85beb7edad85fcc87693c75/aiohttp-3.13.2-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:585542825c4bc662221fb257889e011a5aa00f1ae4d75d1d246a5225289183e3", size = 1700586, upload-time = "2025-10-28T20:56:38.034Z" }, + { url = "https://files.pythonhosted.org/packages/da/04/73f5f02ff348a3558763ff6abe99c223381b0bace05cd4530a0258e52597/aiohttp-3.13.2-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:39d02cb6025fe1aabca329c5632f48c9532a3dabccd859e7e2f110668972331f", size = 1768625, upload-time = "2025-10-28T20:56:39.75Z" }, + { url = "https://files.pythonhosted.org/packages/f8/49/a825b79ffec124317265ca7d2344a86bcffeb960743487cb11988ffb3494/aiohttp-3.13.2-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:e67446b19e014d37342f7195f592a2a948141d15a312fe0e700c2fd2f03124f6", size = 1867281, upload-time = "2025-10-28T20:56:41.471Z" }, + { url = "https://files.pythonhosted.org/packages/b9/48/adf56e05f81eac31edcfae45c90928f4ad50ef2e3ea72cb8376162a368f8/aiohttp-3.13.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4356474ad6333e41ccefd39eae869ba15a6c5299c9c01dfdcfdd5c107be4363e", size = 1752431, upload-time = "2025-10-28T20:56:43.162Z" }, + { url = "https://files.pythonhosted.org/packages/30/ab/593855356eead019a74e862f21523db09c27f12fd24af72dbc3555b9bfd9/aiohttp-3.13.2-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:eeacf451c99b4525f700f078becff32c32ec327b10dcf31306a8a52d78166de7", size = 1562846, upload-time = "2025-10-28T20:56:44.85Z" }, + { url = "https://files.pythonhosted.org/packages/39/0f/9f3d32271aa8dc35036e9668e31870a9d3b9542dd6b3e2c8a30931cb27ae/aiohttp-3.13.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d8a9b889aeabd7a4e9af0b7f4ab5ad94d42e7ff679aaec6d0db21e3b639ad58d", size = 1699606, upload-time = "2025-10-28T20:56:46.519Z" }, + { url = "https://files.pythonhosted.org/packages/2c/3c/52d2658c5699b6ef7692a3f7128b2d2d4d9775f2a68093f74bca06cf01e1/aiohttp-3.13.2-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:fa89cb11bc71a63b69568d5b8a25c3ca25b6d54c15f907ca1c130d72f320b76b", size = 1720663, upload-time = "2025-10-28T20:56:48.528Z" }, + { url = "https://files.pythonhosted.org/packages/9b/d4/8f8f3ff1fb7fb9e3f04fcad4e89d8a1cd8fc7d05de67e3de5b15b33008ff/aiohttp-3.13.2-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:8aa7c807df234f693fed0ecd507192fc97692e61fee5702cdc11155d2e5cadc8", size = 1737939, upload-time = "2025-10-28T20:56:50.77Z" }, + { url = "https://files.pythonhosted.org/packages/03/d3/ddd348f8a27a634daae39a1b8e291ff19c77867af438af844bf8b7e3231b/aiohttp-3.13.2-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:9eb3e33fdbe43f88c3c75fa608c25e7c47bbd80f48d012763cb67c47f39a7e16", size = 1555132, upload-time = "2025-10-28T20:56:52.568Z" }, + { url = "https://files.pythonhosted.org/packages/39/b8/46790692dc46218406f94374903ba47552f2f9f90dad554eed61bfb7b64c/aiohttp-3.13.2-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:9434bc0d80076138ea986833156c5a48c9c7a8abb0c96039ddbb4afc93184169", size = 1764802, upload-time = "2025-10-28T20:56:54.292Z" }, + { url = "https://files.pythonhosted.org/packages/ba/e4/19ce547b58ab2a385e5f0b8aa3db38674785085abcf79b6e0edd1632b12f/aiohttp-3.13.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ff15c147b2ad66da1f2cbb0622313f2242d8e6e8f9b79b5206c84523a4473248", size = 1719512, upload-time = "2025-10-28T20:56:56.428Z" }, + { url = "https://files.pythonhosted.org/packages/70/30/6355a737fed29dcb6dfdd48682d5790cb5eab050f7b4e01f49b121d3acad/aiohttp-3.13.2-cp312-cp312-win32.whl", hash = "sha256:27e569eb9d9e95dbd55c0fc3ec3a9335defbf1d8bc1d20171a49f3c4c607b93e", size = 426690, upload-time = "2025-10-28T20:56:58.736Z" }, + { url = "https://files.pythonhosted.org/packages/0a/0d/b10ac09069973d112de6ef980c1f6bb31cb7dcd0bc363acbdad58f927873/aiohttp-3.13.2-cp312-cp312-win_amd64.whl", hash = "sha256:8709a0f05d59a71f33fd05c17fc11fcb8c30140506e13c2f5e8ee1b8964e1b45", size = 453465, upload-time = "2025-10-28T20:57:00.795Z" }, + { url = "https://files.pythonhosted.org/packages/bf/78/7e90ca79e5aa39f9694dcfd74f4720782d3c6828113bb1f3197f7e7c4a56/aiohttp-3.13.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:7519bdc7dfc1940d201651b52bf5e03f5503bda45ad6eacf64dda98be5b2b6be", size = 732139, upload-time = "2025-10-28T20:57:02.455Z" }, + { url = "https://files.pythonhosted.org/packages/db/ed/1f59215ab6853fbaa5c8495fa6cbc39edfc93553426152b75d82a5f32b76/aiohttp-3.13.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:088912a78b4d4f547a1f19c099d5a506df17eacec3c6f4375e2831ec1d995742", size = 490082, upload-time = "2025-10-28T20:57:04.784Z" }, + { url = "https://files.pythonhosted.org/packages/68/7b/fe0fe0f5e05e13629d893c760465173a15ad0039c0a5b0d0040995c8075e/aiohttp-3.13.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:5276807b9de9092af38ed23ce120539ab0ac955547b38563a9ba4f5b07b95293", size = 489035, upload-time = "2025-10-28T20:57:06.894Z" }, + { url = "https://files.pythonhosted.org/packages/d2/04/db5279e38471b7ac801d7d36a57d1230feeee130bbe2a74f72731b23c2b1/aiohttp-3.13.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1237c1375eaef0db4dcd7c2559f42e8af7b87ea7d295b118c60c36a6e61cb811", size = 1720387, upload-time = "2025-10-28T20:57:08.685Z" }, + { url = "https://files.pythonhosted.org/packages/31/07/8ea4326bd7dae2bd59828f69d7fdc6e04523caa55e4a70f4a8725a7e4ed2/aiohttp-3.13.2-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:96581619c57419c3d7d78703d5b78c1e5e5fc0172d60f555bdebaced82ded19a", size = 1688314, upload-time = "2025-10-28T20:57:10.693Z" }, + { url = "https://files.pythonhosted.org/packages/48/ab/3d98007b5b87ffd519d065225438cc3b668b2f245572a8cb53da5dd2b1bc/aiohttp-3.13.2-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a2713a95b47374169409d18103366de1050fe0ea73db358fc7a7acb2880422d4", size = 1756317, upload-time = "2025-10-28T20:57:12.563Z" }, + { url = "https://files.pythonhosted.org/packages/97/3d/801ca172b3d857fafb7b50c7c03f91b72b867a13abca982ed6b3081774ef/aiohttp-3.13.2-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:228a1cd556b3caca590e9511a89444925da87d35219a49ab5da0c36d2d943a6a", size = 1858539, upload-time = "2025-10-28T20:57:14.623Z" }, + { url = "https://files.pythonhosted.org/packages/f7/0d/4764669bdf47bd472899b3d3db91fffbe925c8e3038ec591a2fd2ad6a14d/aiohttp-3.13.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ac6cde5fba8d7d8c6ac963dbb0256a9854e9fafff52fbcc58fdf819357892c3e", size = 1739597, upload-time = "2025-10-28T20:57:16.399Z" }, + { url = "https://files.pythonhosted.org/packages/c4/52/7bd3c6693da58ba16e657eb904a5b6decfc48ecd06e9ac098591653b1566/aiohttp-3.13.2-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f2bef8237544f4e42878c61cef4e2839fee6346dc60f5739f876a9c50be7fcdb", size = 1555006, upload-time = "2025-10-28T20:57:18.288Z" }, + { url = "https://files.pythonhosted.org/packages/48/30/9586667acec5993b6f41d2ebcf96e97a1255a85f62f3c653110a5de4d346/aiohttp-3.13.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:16f15a4eac3bc2d76c45f7ebdd48a65d41b242eb6c31c2245463b40b34584ded", size = 1683220, upload-time = "2025-10-28T20:57:20.241Z" }, + { url = "https://files.pythonhosted.org/packages/71/01/3afe4c96854cfd7b30d78333852e8e851dceaec1c40fd00fec90c6402dd2/aiohttp-3.13.2-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:bb7fb776645af5cc58ab804c58d7eba545a97e047254a52ce89c157b5af6cd0b", size = 1712570, upload-time = "2025-10-28T20:57:22.253Z" }, + { url = "https://files.pythonhosted.org/packages/11/2c/22799d8e720f4697a9e66fd9c02479e40a49de3de2f0bbe7f9f78a987808/aiohttp-3.13.2-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:e1b4951125ec10c70802f2cb09736c895861cd39fd9dcb35107b4dc8ae6220b8", size = 1733407, upload-time = "2025-10-28T20:57:24.37Z" }, + { url = "https://files.pythonhosted.org/packages/34/cb/90f15dd029f07cebbd91f8238a8b363978b530cd128488085b5703683594/aiohttp-3.13.2-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:550bf765101ae721ee1d37d8095f47b1f220650f85fe1af37a90ce75bab89d04", size = 1550093, upload-time = "2025-10-28T20:57:26.257Z" }, + { url = "https://files.pythonhosted.org/packages/69/46/12dce9be9d3303ecbf4d30ad45a7683dc63d90733c2d9fe512be6716cd40/aiohttp-3.13.2-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:fe91b87fc295973096251e2d25a811388e7d8adf3bd2b97ef6ae78bc4ac6c476", size = 1758084, upload-time = "2025-10-28T20:57:28.349Z" }, + { url = "https://files.pythonhosted.org/packages/f9/c8/0932b558da0c302ffd639fc6362a313b98fdf235dc417bc2493da8394df7/aiohttp-3.13.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e0c8e31cfcc4592cb200160344b2fb6ae0f9e4effe06c644b5a125d4ae5ebe23", size = 1716987, upload-time = "2025-10-28T20:57:30.233Z" }, + { url = "https://files.pythonhosted.org/packages/5d/8b/f5bd1a75003daed099baec373aed678f2e9b34f2ad40d85baa1368556396/aiohttp-3.13.2-cp313-cp313-win32.whl", hash = "sha256:0740f31a60848d6edb296a0df827473eede90c689b8f9f2a4cdde74889eb2254", size = 425859, upload-time = "2025-10-28T20:57:32.105Z" }, + { url = "https://files.pythonhosted.org/packages/5d/28/a8a9fc6957b2cee8902414e41816b5ab5536ecf43c3b1843c10e82c559b2/aiohttp-3.13.2-cp313-cp313-win_amd64.whl", hash = "sha256:a88d13e7ca367394908f8a276b89d04a3652044612b9a408a0bb22a5ed976a1a", size = 452192, upload-time = "2025-10-28T20:57:34.166Z" }, + { url = "https://files.pythonhosted.org/packages/9b/36/e2abae1bd815f01c957cbf7be817b3043304e1c87bad526292a0410fdcf9/aiohttp-3.13.2-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:2475391c29230e063ef53a66669b7b691c9bfc3f1426a0f7bcdf1216bdbac38b", size = 735234, upload-time = "2025-10-28T20:57:36.415Z" }, + { url = "https://files.pythonhosted.org/packages/ca/e3/1ee62dde9b335e4ed41db6bba02613295a0d5b41f74a783c142745a12763/aiohttp-3.13.2-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:f33c8748abef4d8717bb20e8fb1b3e07c6adacb7fd6beaae971a764cf5f30d61", size = 490733, upload-time = "2025-10-28T20:57:38.205Z" }, + { url = "https://files.pythonhosted.org/packages/1a/aa/7a451b1d6a04e8d15a362af3e9b897de71d86feac3babf8894545d08d537/aiohttp-3.13.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:ae32f24bbfb7dbb485a24b30b1149e2f200be94777232aeadba3eecece4d0aa4", size = 491303, upload-time = "2025-10-28T20:57:40.122Z" }, + { url = "https://files.pythonhosted.org/packages/57/1e/209958dbb9b01174870f6a7538cd1f3f28274fdbc88a750c238e2c456295/aiohttp-3.13.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5d7f02042c1f009ffb70067326ef183a047425bb2ff3bc434ead4dd4a4a66a2b", size = 1717965, upload-time = "2025-10-28T20:57:42.28Z" }, + { url = "https://files.pythonhosted.org/packages/08/aa/6a01848d6432f241416bc4866cae8dc03f05a5a884d2311280f6a09c73d6/aiohttp-3.13.2-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:93655083005d71cd6c072cdab54c886e6570ad2c4592139c3fb967bfc19e4694", size = 1667221, upload-time = "2025-10-28T20:57:44.869Z" }, + { url = "https://files.pythonhosted.org/packages/87/4f/36c1992432d31bbc789fa0b93c768d2e9047ec8c7177e5cd84ea85155f36/aiohttp-3.13.2-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:0db1e24b852f5f664cd728db140cf11ea0e82450471232a394b3d1a540b0f906", size = 1757178, upload-time = "2025-10-28T20:57:47.216Z" }, + { url = "https://files.pythonhosted.org/packages/ac/b4/8e940dfb03b7e0f68a82b88fd182b9be0a65cb3f35612fe38c038c3112cf/aiohttp-3.13.2-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b009194665bcd128e23eaddef362e745601afa4641930848af4c8559e88f18f9", size = 1838001, upload-time = "2025-10-28T20:57:49.337Z" }, + { url = "https://files.pythonhosted.org/packages/d7/ef/39f3448795499c440ab66084a9db7d20ca7662e94305f175a80f5b7e0072/aiohttp-3.13.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c038a8fdc8103cd51dbd986ecdce141473ffd9775a7a8057a6ed9c3653478011", size = 1716325, upload-time = "2025-10-28T20:57:51.327Z" }, + { url = "https://files.pythonhosted.org/packages/d7/51/b311500ffc860b181c05d91c59a1313bdd05c82960fdd4035a15740d431e/aiohttp-3.13.2-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:66bac29b95a00db411cd758fea0e4b9bdba6d549dfe333f9a945430f5f2cc5a6", size = 1547978, upload-time = "2025-10-28T20:57:53.554Z" }, + { url = "https://files.pythonhosted.org/packages/31/64/b9d733296ef79815226dab8c586ff9e3df41c6aff2e16c06697b2d2e6775/aiohttp-3.13.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:4ebf9cfc9ba24a74cf0718f04aac2a3bbe745902cc7c5ebc55c0f3b5777ef213", size = 1682042, upload-time = "2025-10-28T20:57:55.617Z" }, + { url = "https://files.pythonhosted.org/packages/3f/30/43d3e0f9d6473a6db7d472104c4eff4417b1e9df01774cb930338806d36b/aiohttp-3.13.2-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:a4b88ebe35ce54205c7074f7302bd08a4cb83256a3e0870c72d6f68a3aaf8e49", size = 1680085, upload-time = "2025-10-28T20:57:57.59Z" }, + { url = "https://files.pythonhosted.org/packages/16/51/c709f352c911b1864cfd1087577760ced64b3e5bee2aa88b8c0c8e2e4972/aiohttp-3.13.2-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:98c4fb90bb82b70a4ed79ca35f656f4281885be076f3f970ce315402b53099ae", size = 1728238, upload-time = "2025-10-28T20:57:59.525Z" }, + { url = "https://files.pythonhosted.org/packages/19/e2/19bd4c547092b773caeb48ff5ae4b1ae86756a0ee76c16727fcfd281404b/aiohttp-3.13.2-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:ec7534e63ae0f3759df3a1ed4fa6bc8f75082a924b590619c0dd2f76d7043caa", size = 1544395, upload-time = "2025-10-28T20:58:01.914Z" }, + { url = "https://files.pythonhosted.org/packages/cf/87/860f2803b27dfc5ed7be532832a3498e4919da61299b4a1f8eb89b8ff44d/aiohttp-3.13.2-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:5b927cf9b935a13e33644cbed6c8c4b2d0f25b713d838743f8fe7191b33829c4", size = 1742965, upload-time = "2025-10-28T20:58:03.972Z" }, + { url = "https://files.pythonhosted.org/packages/67/7f/db2fc7618925e8c7a601094d5cbe539f732df4fb570740be88ed9e40e99a/aiohttp-3.13.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:88d6c017966a78c5265d996c19cdb79235be5e6412268d7e2ce7dee339471b7a", size = 1697585, upload-time = "2025-10-28T20:58:06.189Z" }, + { url = "https://files.pythonhosted.org/packages/0c/07/9127916cb09bb38284db5036036042b7b2c514c8ebaeee79da550c43a6d6/aiohttp-3.13.2-cp314-cp314-win32.whl", hash = "sha256:f7c183e786e299b5d6c49fb43a769f8eb8e04a2726a2bd5887b98b5cc2d67940", size = 431621, upload-time = "2025-10-28T20:58:08.636Z" }, + { url = "https://files.pythonhosted.org/packages/fb/41/554a8a380df6d3a2bba8a7726429a23f4ac62aaf38de43bb6d6cde7b4d4d/aiohttp-3.13.2-cp314-cp314-win_amd64.whl", hash = "sha256:fe242cd381e0fb65758faf5ad96c2e460df6ee5b2de1072fe97e4127927e00b4", size = 457627, upload-time = "2025-10-28T20:58:11Z" }, + { url = "https://files.pythonhosted.org/packages/c7/8e/3824ef98c039d3951cb65b9205a96dd2b20f22241ee17d89c5701557c826/aiohttp-3.13.2-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:f10d9c0b0188fe85398c61147bbd2a657d616c876863bfeff43376e0e3134673", size = 767360, upload-time = "2025-10-28T20:58:13.358Z" }, + { url = "https://files.pythonhosted.org/packages/a4/0f/6a03e3fc7595421274fa34122c973bde2d89344f8a881b728fa8c774e4f1/aiohttp-3.13.2-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:e7c952aefdf2460f4ae55c5e9c3e80aa72f706a6317e06020f80e96253b1accd", size = 504616, upload-time = "2025-10-28T20:58:15.339Z" }, + { url = "https://files.pythonhosted.org/packages/c6/aa/ed341b670f1bc8a6f2c6a718353d13b9546e2cef3544f573c6a1ff0da711/aiohttp-3.13.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c20423ce14771d98353d2e25e83591fa75dfa90a3c1848f3d7c68243b4fbded3", size = 509131, upload-time = "2025-10-28T20:58:17.693Z" }, + { url = "https://files.pythonhosted.org/packages/7f/f0/c68dac234189dae5c4bbccc0f96ce0cc16b76632cfc3a08fff180045cfa4/aiohttp-3.13.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e96eb1a34396e9430c19d8338d2ec33015e4a87ef2b4449db94c22412e25ccdf", size = 1864168, upload-time = "2025-10-28T20:58:20.113Z" }, + { url = "https://files.pythonhosted.org/packages/8f/65/75a9a76db8364b5d0e52a0c20eabc5d52297385d9af9c35335b924fafdee/aiohttp-3.13.2-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:23fb0783bc1a33640036465019d3bba069942616a6a2353c6907d7fe1ccdaf4e", size = 1719200, upload-time = "2025-10-28T20:58:22.583Z" }, + { url = "https://files.pythonhosted.org/packages/f5/55/8df2ed78d7f41d232f6bd3ff866b6f617026551aa1d07e2f03458f964575/aiohttp-3.13.2-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2e1a9bea6244a1d05a4e57c295d69e159a5c50d8ef16aa390948ee873478d9a5", size = 1843497, upload-time = "2025-10-28T20:58:24.672Z" }, + { url = "https://files.pythonhosted.org/packages/e9/e0/94d7215e405c5a02ccb6a35c7a3a6cfff242f457a00196496935f700cde5/aiohttp-3.13.2-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0a3d54e822688b56e9f6b5816fb3de3a3a64660efac64e4c2dc435230ad23bad", size = 1935703, upload-time = "2025-10-28T20:58:26.758Z" }, + { url = "https://files.pythonhosted.org/packages/0b/78/1eeb63c3f9b2d1015a4c02788fb543141aad0a03ae3f7a7b669b2483f8d4/aiohttp-3.13.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7a653d872afe9f33497215745da7a943d1dc15b728a9c8da1c3ac423af35178e", size = 1792738, upload-time = "2025-10-28T20:58:29.787Z" }, + { url = "https://files.pythonhosted.org/packages/41/75/aaf1eea4c188e51538c04cc568040e3082db263a57086ea74a7d38c39e42/aiohttp-3.13.2-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:56d36e80d2003fa3fc0207fac644216d8532e9504a785ef9a8fd013f84a42c61", size = 1624061, upload-time = "2025-10-28T20:58:32.529Z" }, + { url = "https://files.pythonhosted.org/packages/9b/c2/3b6034de81fbcc43de8aeb209073a2286dfb50b86e927b4efd81cf848197/aiohttp-3.13.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:78cd586d8331fb8e241c2dd6b2f4061778cc69e150514b39a9e28dd050475661", size = 1789201, upload-time = "2025-10-28T20:58:34.618Z" }, + { url = "https://files.pythonhosted.org/packages/c9/38/c15dcf6d4d890217dae79d7213988f4e5fe6183d43893a9cf2fe9e84ca8d/aiohttp-3.13.2-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:20b10bbfbff766294fe99987f7bb3b74fdd2f1a2905f2562132641ad434dcf98", size = 1776868, upload-time = "2025-10-28T20:58:38.835Z" }, + { url = "https://files.pythonhosted.org/packages/04/75/f74fd178ac81adf4f283a74847807ade5150e48feda6aef024403716c30c/aiohttp-3.13.2-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:9ec49dff7e2b3c85cdeaa412e9d438f0ecd71676fde61ec57027dd392f00c693", size = 1790660, upload-time = "2025-10-28T20:58:41.507Z" }, + { url = "https://files.pythonhosted.org/packages/e7/80/7368bd0d06b16b3aba358c16b919e9c46cf11587dc572091031b0e9e3ef0/aiohttp-3.13.2-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:94f05348c4406450f9d73d38efb41d669ad6cd90c7ee194810d0eefbfa875a7a", size = 1617548, upload-time = "2025-10-28T20:58:43.674Z" }, + { url = "https://files.pythonhosted.org/packages/7d/4b/a6212790c50483cb3212e507378fbe26b5086d73941e1ec4b56a30439688/aiohttp-3.13.2-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:fa4dcb605c6f82a80c7f95713c2b11c3b8e9893b3ebd2bc9bde93165ed6107be", size = 1817240, upload-time = "2025-10-28T20:58:45.787Z" }, + { url = "https://files.pythonhosted.org/packages/ff/f7/ba5f0ba4ea8d8f3c32850912944532b933acbf0f3a75546b89269b9b7dde/aiohttp-3.13.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:cf00e5db968c3f67eccd2778574cf64d8b27d95b237770aa32400bd7a1ca4f6c", size = 1762334, upload-time = "2025-10-28T20:58:47.936Z" }, + { url = "https://files.pythonhosted.org/packages/7e/83/1a5a1856574588b1cad63609ea9ad75b32a8353ac995d830bf5da9357364/aiohttp-3.13.2-cp314-cp314t-win32.whl", hash = "sha256:d23b5fe492b0805a50d3371e8a728a9134d8de5447dce4c885f5587294750734", size = 464685, upload-time = "2025-10-28T20:58:50.642Z" }, + { url = "https://files.pythonhosted.org/packages/9f/4d/d22668674122c08f4d56972297c51a624e64b3ed1efaa40187607a7cb66e/aiohttp-3.13.2-cp314-cp314t-win_amd64.whl", hash = "sha256:ff0a7b0a82a7ab905cbda74006318d1b12e37c797eb1b0d4eb3e316cf47f658f", size = 498093, upload-time = "2025-10-28T20:58:52.782Z" }, +] + +[[package]] +name = "aioitertools" +version = "0.13.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/fd/3c/53c4a17a05fb9ea2313ee1777ff53f5e001aefd5cc85aa2f4c2d982e1e38/aioitertools-0.13.0.tar.gz", hash = "sha256:620bd241acc0bbb9ec819f1ab215866871b4bbd1f73836a55f799200ee86950c", size = 19322, upload-time = "2025-11-06T22:17:07.609Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/10/a1/510b0a7fadc6f43a6ce50152e69dbd86415240835868bb0bd9b5b88b1e06/aioitertools-0.13.0-py3-none-any.whl", hash = "sha256:0be0292b856f08dfac90e31f4739432f4cb6d7520ab9eb73e143f4f2fa5259be", size = 24182, upload-time = "2025-11-06T22:17:06.502Z" }, +] + +[[package]] +name = "aiosignal" +version = "1.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "frozenlist" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/61/62/06741b579156360248d1ec624842ad0edf697050bbaf7c3e46394e106ad1/aiosignal-1.4.0.tar.gz", hash = "sha256:f47eecd9468083c2029cc99945502cb7708b082c232f9aca65da147157b251c7", size = 25007, upload-time = "2025-07-03T22:54:43.528Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fb/76/641ae371508676492379f16e2fa48f4e2c11741bd63c48be4b12a6b09cba/aiosignal-1.4.0-py3-none-any.whl", hash = "sha256:053243f8b92b990551949e63930a839ff0cf0b0ebbe0597b0f3fb19e1a0fe82e", size = 7490, upload-time = "2025-07-03T22:54:42.156Z" }, +] + +[[package]] +name = "alabaster" +version = "1.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a6/f8/d9c74d0daf3f742840fd818d69cfae176fa332022fd44e3469487d5a9420/alabaster-1.0.0.tar.gz", hash = "sha256:c00dca57bca26fa62a6d7d0a9fcce65f3e026e9bfe33e9c538fd3fbb2144fd9e", size = 24210, upload-time = "2024-07-26T18:15:03.762Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/b3/6b4067be973ae96ba0d615946e314c5ae35f9f993eca561b356540bb0c2b/alabaster-1.0.0-py3-none-any.whl", hash = "sha256:fc6786402dc3fcb2de3cabd5fe455a2db534b371124f1f21de8731783dec828b", size = 13929, upload-time = "2024-07-26T18:15:02.05Z" }, +] + +[[package]] +name = "annotated-doc" +version = "0.0.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/57/ba/046ceea27344560984e26a590f90bc7f4a75b06701f653222458922b558c/annotated_doc-0.0.4.tar.gz", hash = "sha256:fbcda96e87e9c92ad167c2e53839e57503ecfda18804ea28102353485033faa4", size = 7288, upload-time = "2025-11-10T22:07:42.062Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1e/d3/26bf1008eb3d2daa8ef4cacc7f3bfdc11818d111f7e2d0201bc6e3b49d45/annotated_doc-0.0.4-py3-none-any.whl", hash = "sha256:571ac1dc6991c450b25a9c2d84a3705e2ae7a53467b5d111c24fa8baabbed320", size = 5303, upload-time = "2025-11-10T22:07:40.673Z" }, +] + +[[package]] +name = "annotated-types" +version = "0.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081, upload-time = "2024-05-20T21:33:25.928Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" }, +] + +[[package]] +name = "antlr4-python3-runtime" +version = "4.9.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/3e/38/7859ff46355f76f8d19459005ca000b6e7012f2f1ca597746cbcd1fbfe5e/antlr4-python3-runtime-4.9.3.tar.gz", hash = "sha256:f224469b4168294902bb1efa80a8bf7855f24c99aef99cbefc1bcd3cce77881b", size = 117034, upload-time = "2021-11-06T17:52:23.524Z" } + +[[package]] +name = "anyio" +version = "4.9.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "exceptiongroup", marker = "python_full_version < '3.11'" }, + { name = "idna" }, + { name = "sniffio" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/95/7d/4c1bd541d4dffa1b52bd83fb8527089e097a106fc90b467a7313b105f840/anyio-4.9.0.tar.gz", hash = "sha256:673c0c244e15788651a4ff38710fea9675823028a6f08a5eda409e0c9840a028", size = 190949, upload-time = "2025-03-17T00:02:54.77Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a1/ee/48ca1a7c89ffec8b6a0c5d02b89c305671d5ffd8d3c94acf8b8c408575bb/anyio-4.9.0-py3-none-any.whl", hash = "sha256:9f76d541cad6e36af7beb62e978876f3b41e3e04f2c1fbf0884604c0a9c4d93c", size = 100916, upload-time = "2025-03-17T00:02:52.713Z" }, +] + +[[package]] +name = "astroid" +version = "3.3.11" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/18/74/dfb75f9ccd592bbedb175d4a32fc643cf569d7c218508bfbd6ea7ef9c091/astroid-3.3.11.tar.gz", hash = "sha256:1e5a5011af2920c7c67a53f65d536d65bfa7116feeaf2354d8b94f29573bb0ce", size = 400439, upload-time = "2025-07-13T18:04:23.177Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/af/0f/3b8fdc946b4d9cc8cc1e8af42c4e409468c84441b933d037e101b3d72d86/astroid-3.3.11-py3-none-any.whl", hash = "sha256:54c760ae8322ece1abd213057c4b5bba7c49818853fc901ef09719a60dbf9dec", size = 275612, upload-time = "2025-07-13T18:04:21.07Z" }, +] + +[[package]] +name = "async-timeout" +version = "5.0.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a5/ae/136395dfbfe00dfc94da3f3e136d0b13f394cba8f4841120e34226265780/async_timeout-5.0.1.tar.gz", hash = "sha256:d9321a7a3d5a6a5e187e824d2fa0793ce379a202935782d555d6e9d2735677d3", size = 9274, upload-time = "2024-11-06T16:41:39.6Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fe/ba/e2081de779ca30d473f21f5b30e0e737c438205440784c7dfc81efc2b029/async_timeout-5.0.1-py3-none-any.whl", hash = "sha256:39e3809566ff85354557ec2398b55e096c8364bacac9405a7a1fa429e77fe76c", size = 6233, upload-time = "2024-11-06T16:41:37.9Z" }, +] + +[[package]] +name = "attrs" +version = "25.4.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6b/5c/685e6633917e101e5dcb62b9dd76946cbb57c26e133bae9e0cd36033c0a9/attrs-25.4.0.tar.gz", hash = "sha256:16d5969b87f0859ef33a48b35d55ac1be6e42ae49d5e853b597db70c35c57e11", size = 934251, upload-time = "2025-10-06T13:54:44.725Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3a/2a/7cc015f5b9f5db42b7d48157e23356022889fc354a2813c15934b7cb5c0e/attrs-25.4.0-py3-none-any.whl", hash = "sha256:adcf7e2a1fb3b36ac48d97835bb6d8ade15b8dcce26aba8bf1d14847b57a3373", size = 67615, upload-time = "2025-10-06T13:54:43.17Z" }, +] + +[[package]] +name = "babel" +version = "2.17.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7d/6b/d52e42361e1aa00709585ecc30b3f9684b3ab62530771402248b1b1d6240/babel-2.17.0.tar.gz", hash = "sha256:0c54cffb19f690cdcc52a3b50bcbf71e07a808d1c80d549f2459b9d2cf0afb9d", size = 9951852, upload-time = "2025-02-01T15:17:41.026Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/b8/3fe70c75fe32afc4bb507f75563d39bc5642255d1d94f1f23604725780bf/babel-2.17.0-py3-none-any.whl", hash = "sha256:4d0b53093fdfb4b21c92b5213dba5a1b23885afa8383709427046b21c366e5f2", size = 10182537, upload-time = "2025-02-01T15:17:37.39Z" }, +] + +[[package]] +name = "bcrypt" +version = "5.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d4/36/3329e2518d70ad8e2e5817d5a4cac6bba05a47767ec416c7d020a965f408/bcrypt-5.0.0.tar.gz", hash = "sha256:f748f7c2d6fd375cc93d3fba7ef4a9e3a092421b8dbf34d8d4dc06be9492dfdd", size = 25386, upload-time = "2025-09-25T19:50:47.829Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/13/85/3e65e01985fddf25b64ca67275bb5bdb4040bd1a53b66d355c6c37c8a680/bcrypt-5.0.0-cp313-cp313t-macosx_10_12_universal2.whl", hash = "sha256:f3c08197f3039bec79cee59a606d62b96b16669cff3949f21e74796b6e3cd2be", size = 481806, upload-time = "2025-09-25T19:49:05.102Z" }, + { url = "https://files.pythonhosted.org/packages/44/dc/01eb79f12b177017a726cbf78330eb0eb442fae0e7b3dfd84ea2849552f3/bcrypt-5.0.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:200af71bc25f22006f4069060c88ed36f8aa4ff7f53e67ff04d2ab3f1e79a5b2", size = 268626, upload-time = "2025-09-25T19:49:06.723Z" }, + { url = "https://files.pythonhosted.org/packages/8c/cf/e82388ad5959c40d6afd94fb4743cc077129d45b952d46bdc3180310e2df/bcrypt-5.0.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:baade0a5657654c2984468efb7d6c110db87ea63ef5a4b54732e7e337253e44f", size = 271853, upload-time = "2025-09-25T19:49:08.028Z" }, + { url = "https://files.pythonhosted.org/packages/ec/86/7134b9dae7cf0efa85671651341f6afa695857fae172615e960fb6a466fa/bcrypt-5.0.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:c58b56cdfb03202b3bcc9fd8daee8e8e9b6d7e3163aa97c631dfcfcc24d36c86", size = 269793, upload-time = "2025-09-25T19:49:09.727Z" }, + { url = "https://files.pythonhosted.org/packages/cc/82/6296688ac1b9e503d034e7d0614d56e80c5d1a08402ff856a4549cb59207/bcrypt-5.0.0-cp313-cp313t-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:4bfd2a34de661f34d0bda43c3e4e79df586e4716ef401fe31ea39d69d581ef23", size = 289930, upload-time = "2025-09-25T19:49:11.204Z" }, + { url = "https://files.pythonhosted.org/packages/d1/18/884a44aa47f2a3b88dd09bc05a1e40b57878ecd111d17e5bba6f09f8bb77/bcrypt-5.0.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:ed2e1365e31fc73f1825fa830f1c8f8917ca1b3ca6185773b349c20fd606cec2", size = 272194, upload-time = "2025-09-25T19:49:12.524Z" }, + { url = "https://files.pythonhosted.org/packages/0e/8f/371a3ab33c6982070b674f1788e05b656cfbf5685894acbfef0c65483a59/bcrypt-5.0.0-cp313-cp313t-manylinux_2_34_aarch64.whl", hash = "sha256:83e787d7a84dbbfba6f250dd7a5efd689e935f03dd83b0f919d39349e1f23f83", size = 269381, upload-time = "2025-09-25T19:49:14.308Z" }, + { url = "https://files.pythonhosted.org/packages/b1/34/7e4e6abb7a8778db6422e88b1f06eb07c47682313997ee8a8f9352e5a6f1/bcrypt-5.0.0-cp313-cp313t-manylinux_2_34_x86_64.whl", hash = "sha256:137c5156524328a24b9fac1cb5db0ba618bc97d11970b39184c1d87dc4bf1746", size = 271750, upload-time = "2025-09-25T19:49:15.584Z" }, + { url = "https://files.pythonhosted.org/packages/c0/1b/54f416be2499bd72123c70d98d36c6cd61a4e33d9b89562c22481c81bb30/bcrypt-5.0.0-cp313-cp313t-musllinux_1_1_aarch64.whl", hash = "sha256:38cac74101777a6a7d3b3e3cfefa57089b5ada650dce2baf0cbdd9d65db22a9e", size = 303757, upload-time = "2025-09-25T19:49:17.244Z" }, + { url = "https://files.pythonhosted.org/packages/13/62/062c24c7bcf9d2826a1a843d0d605c65a755bc98002923d01fd61270705a/bcrypt-5.0.0-cp313-cp313t-musllinux_1_1_x86_64.whl", hash = "sha256:d8d65b564ec849643d9f7ea05c6d9f0cd7ca23bdd4ac0c2dbef1104ab504543d", size = 306740, upload-time = "2025-09-25T19:49:18.693Z" }, + { url = "https://files.pythonhosted.org/packages/d5/c8/1fdbfc8c0f20875b6b4020f3c7dc447b8de60aa0be5faaf009d24242aec9/bcrypt-5.0.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:741449132f64b3524e95cd30e5cd3343006ce146088f074f31ab26b94e6c75ba", size = 334197, upload-time = "2025-09-25T19:49:20.523Z" }, + { url = "https://files.pythonhosted.org/packages/a6/c1/8b84545382d75bef226fbc6588af0f7b7d095f7cd6a670b42a86243183cd/bcrypt-5.0.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:212139484ab3207b1f0c00633d3be92fef3c5f0af17cad155679d03ff2ee1e41", size = 352974, upload-time = "2025-09-25T19:49:22.254Z" }, + { url = "https://files.pythonhosted.org/packages/10/a6/ffb49d4254ed085e62e3e5dd05982b4393e32fe1e49bb1130186617c29cd/bcrypt-5.0.0-cp313-cp313t-win32.whl", hash = "sha256:9d52ed507c2488eddd6a95bccee4e808d3234fa78dd370e24bac65a21212b861", size = 148498, upload-time = "2025-09-25T19:49:24.134Z" }, + { url = "https://files.pythonhosted.org/packages/48/a9/259559edc85258b6d5fc5471a62a3299a6aa37a6611a169756bf4689323c/bcrypt-5.0.0-cp313-cp313t-win_amd64.whl", hash = "sha256:f6984a24db30548fd39a44360532898c33528b74aedf81c26cf29c51ee47057e", size = 145853, upload-time = "2025-09-25T19:49:25.702Z" }, + { url = "https://files.pythonhosted.org/packages/2d/df/9714173403c7e8b245acf8e4be8876aac64a209d1b392af457c79e60492e/bcrypt-5.0.0-cp313-cp313t-win_arm64.whl", hash = "sha256:9fffdb387abe6aa775af36ef16f55e318dcda4194ddbf82007a6f21da29de8f5", size = 139626, upload-time = "2025-09-25T19:49:26.928Z" }, + { url = "https://files.pythonhosted.org/packages/f8/14/c18006f91816606a4abe294ccc5d1e6f0e42304df5a33710e9e8e95416e1/bcrypt-5.0.0-cp314-cp314t-macosx_10_12_universal2.whl", hash = "sha256:4870a52610537037adb382444fefd3706d96d663ac44cbb2f37e3919dca3d7ef", size = 481862, upload-time = "2025-09-25T19:49:28.365Z" }, + { url = "https://files.pythonhosted.org/packages/67/49/dd074d831f00e589537e07a0725cf0e220d1f0d5d8e85ad5bbff251c45aa/bcrypt-5.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:48f753100931605686f74e27a7b49238122aa761a9aefe9373265b8b7aa43ea4", size = 268544, upload-time = "2025-09-25T19:49:30.39Z" }, + { url = "https://files.pythonhosted.org/packages/f5/91/50ccba088b8c474545b034a1424d05195d9fcbaaf802ab8bfe2be5a4e0d7/bcrypt-5.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f70aadb7a809305226daedf75d90379c397b094755a710d7014b8b117df1ebbf", size = 271787, upload-time = "2025-09-25T19:49:32.144Z" }, + { url = "https://files.pythonhosted.org/packages/aa/e7/d7dba133e02abcda3b52087a7eea8c0d4f64d3e593b4fffc10c31b7061f3/bcrypt-5.0.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:744d3c6b164caa658adcb72cb8cc9ad9b4b75c7db507ab4bc2480474a51989da", size = 269753, upload-time = "2025-09-25T19:49:33.885Z" }, + { url = "https://files.pythonhosted.org/packages/33/fc/5b145673c4b8d01018307b5c2c1fc87a6f5a436f0ad56607aee389de8ee3/bcrypt-5.0.0-cp314-cp314t-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:a28bc05039bdf3289d757f49d616ab3efe8cf40d8e8001ccdd621cd4f98f4fc9", size = 289587, upload-time = "2025-09-25T19:49:35.144Z" }, + { url = "https://files.pythonhosted.org/packages/27/d7/1ff22703ec6d4f90e62f1a5654b8867ef96bafb8e8102c2288333e1a6ca6/bcrypt-5.0.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:7f277a4b3390ab4bebe597800a90da0edae882c6196d3038a73adf446c4f969f", size = 272178, upload-time = "2025-09-25T19:49:36.793Z" }, + { url = "https://files.pythonhosted.org/packages/c8/88/815b6d558a1e4d40ece04a2f84865b0fef233513bd85fd0e40c294272d62/bcrypt-5.0.0-cp314-cp314t-manylinux_2_34_aarch64.whl", hash = "sha256:79cfa161eda8d2ddf29acad370356b47f02387153b11d46042e93a0a95127493", size = 269295, upload-time = "2025-09-25T19:49:38.164Z" }, + { url = "https://files.pythonhosted.org/packages/51/8c/e0db387c79ab4931fc89827d37608c31cc57b6edc08ccd2386139028dc0d/bcrypt-5.0.0-cp314-cp314t-manylinux_2_34_x86_64.whl", hash = "sha256:a5393eae5722bcef046a990b84dff02b954904c36a194f6cfc817d7dca6c6f0b", size = 271700, upload-time = "2025-09-25T19:49:39.917Z" }, + { url = "https://files.pythonhosted.org/packages/06/83/1570edddd150f572dbe9fc00f6203a89fc7d4226821f67328a85c330f239/bcrypt-5.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7f4c94dec1b5ab5d522750cb059bb9409ea8872d4494fd152b53cca99f1ddd8c", size = 334034, upload-time = "2025-09-25T19:49:41.227Z" }, + { url = "https://files.pythonhosted.org/packages/c9/f2/ea64e51a65e56ae7a8a4ec236c2bfbdd4b23008abd50ac33fbb2d1d15424/bcrypt-5.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:0cae4cb350934dfd74c020525eeae0a5f79257e8a201c0c176f4b84fdbf2a4b4", size = 352766, upload-time = "2025-09-25T19:49:43.08Z" }, + { url = "https://files.pythonhosted.org/packages/d7/d4/1a388d21ee66876f27d1a1f41287897d0c0f1712ef97d395d708ba93004c/bcrypt-5.0.0-cp314-cp314t-win32.whl", hash = "sha256:b17366316c654e1ad0306a6858e189fc835eca39f7eb2cafd6aaca8ce0c40a2e", size = 152449, upload-time = "2025-09-25T19:49:44.971Z" }, + { url = "https://files.pythonhosted.org/packages/3f/61/3291c2243ae0229e5bca5d19f4032cecad5dfb05a2557169d3a69dc0ba91/bcrypt-5.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:92864f54fb48b4c718fc92a32825d0e42265a627f956bc0361fe869f1adc3e7d", size = 149310, upload-time = "2025-09-25T19:49:46.162Z" }, + { url = "https://files.pythonhosted.org/packages/3e/89/4b01c52ae0c1a681d4021e5dd3e45b111a8fb47254a274fa9a378d8d834b/bcrypt-5.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:dd19cf5184a90c873009244586396a6a884d591a5323f0e8a5922560718d4993", size = 143761, upload-time = "2025-09-25T19:49:47.345Z" }, + { url = "https://files.pythonhosted.org/packages/84/29/6237f151fbfe295fe3e074ecc6d44228faa1e842a81f6d34a02937ee1736/bcrypt-5.0.0-cp38-abi3-macosx_10_12_universal2.whl", hash = "sha256:fc746432b951e92b58317af8e0ca746efe93e66555f1b40888865ef5bf56446b", size = 494553, upload-time = "2025-09-25T19:49:49.006Z" }, + { url = "https://files.pythonhosted.org/packages/45/b6/4c1205dde5e464ea3bd88e8742e19f899c16fa8916fb8510a851fae985b5/bcrypt-5.0.0-cp38-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:c2388ca94ffee269b6038d48747f4ce8df0ffbea43f31abfa18ac72f0218effb", size = 275009, upload-time = "2025-09-25T19:49:50.581Z" }, + { url = "https://files.pythonhosted.org/packages/3b/71/427945e6ead72ccffe77894b2655b695ccf14ae1866cd977e185d606dd2f/bcrypt-5.0.0-cp38-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:560ddb6ec730386e7b3b26b8b4c88197aaed924430e7b74666a586ac997249ef", size = 278029, upload-time = "2025-09-25T19:49:52.533Z" }, + { url = "https://files.pythonhosted.org/packages/17/72/c344825e3b83c5389a369c8a8e58ffe1480b8a699f46c127c34580c4666b/bcrypt-5.0.0-cp38-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:d79e5c65dcc9af213594d6f7f1fa2c98ad3fc10431e7aa53c176b441943efbdd", size = 275907, upload-time = "2025-09-25T19:49:54.709Z" }, + { url = "https://files.pythonhosted.org/packages/0b/7e/d4e47d2df1641a36d1212e5c0514f5291e1a956a7749f1e595c07a972038/bcrypt-5.0.0-cp38-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2b732e7d388fa22d48920baa267ba5d97cca38070b69c0e2d37087b381c681fd", size = 296500, upload-time = "2025-09-25T19:49:56.013Z" }, + { url = "https://files.pythonhosted.org/packages/0f/c3/0ae57a68be2039287ec28bc463b82e4b8dc23f9d12c0be331f4782e19108/bcrypt-5.0.0-cp38-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:0c8e093ea2532601a6f686edbc2c6b2ec24131ff5c52f7610dd64fa4553b5464", size = 278412, upload-time = "2025-09-25T19:49:57.356Z" }, + { url = "https://files.pythonhosted.org/packages/45/2b/77424511adb11e6a99e3a00dcc7745034bee89036ad7d7e255a7e47be7d8/bcrypt-5.0.0-cp38-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:5b1589f4839a0899c146e8892efe320c0fa096568abd9b95593efac50a87cb75", size = 275486, upload-time = "2025-09-25T19:49:59.116Z" }, + { url = "https://files.pythonhosted.org/packages/43/0a/405c753f6158e0f3f14b00b462d8bca31296f7ecfc8fc8bc7919c0c7d73a/bcrypt-5.0.0-cp38-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:89042e61b5e808b67daf24a434d89bab164d4de1746b37a8d173b6b14f3db9ff", size = 277940, upload-time = "2025-09-25T19:50:00.869Z" }, + { url = "https://files.pythonhosted.org/packages/62/83/b3efc285d4aadc1fa83db385ec64dcfa1707e890eb42f03b127d66ac1b7b/bcrypt-5.0.0-cp38-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:e3cf5b2560c7b5a142286f69bde914494b6d8f901aaa71e453078388a50881c4", size = 310776, upload-time = "2025-09-25T19:50:02.393Z" }, + { url = "https://files.pythonhosted.org/packages/95/7d/47ee337dacecde6d234890fe929936cb03ebc4c3a7460854bbd9c97780b8/bcrypt-5.0.0-cp38-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:f632fd56fc4e61564f78b46a2269153122db34988e78b6be8b32d28507b7eaeb", size = 312922, upload-time = "2025-09-25T19:50:04.232Z" }, + { url = "https://files.pythonhosted.org/packages/d6/3a/43d494dfb728f55f4e1cf8fd435d50c16a2d75493225b54c8d06122523c6/bcrypt-5.0.0-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:801cad5ccb6b87d1b430f183269b94c24f248dddbbc5c1f78b6ed231743e001c", size = 341367, upload-time = "2025-09-25T19:50:05.559Z" }, + { url = "https://files.pythonhosted.org/packages/55/ab/a0727a4547e383e2e22a630e0f908113db37904f58719dc48d4622139b5c/bcrypt-5.0.0-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:3cf67a804fc66fc217e6914a5635000259fbbbb12e78a99488e4d5ba445a71eb", size = 359187, upload-time = "2025-09-25T19:50:06.916Z" }, + { url = "https://files.pythonhosted.org/packages/1b/bb/461f352fdca663524b4643d8b09e8435b4990f17fbf4fea6bc2a90aa0cc7/bcrypt-5.0.0-cp38-abi3-win32.whl", hash = "sha256:3abeb543874b2c0524ff40c57a4e14e5d3a66ff33fb423529c88f180fd756538", size = 153752, upload-time = "2025-09-25T19:50:08.515Z" }, + { url = "https://files.pythonhosted.org/packages/41/aa/4190e60921927b7056820291f56fc57d00d04757c8b316b2d3c0d1d6da2c/bcrypt-5.0.0-cp38-abi3-win_amd64.whl", hash = "sha256:35a77ec55b541e5e583eb3436ffbbf53b0ffa1fa16ca6782279daf95d146dcd9", size = 150881, upload-time = "2025-09-25T19:50:09.742Z" }, + { url = "https://files.pythonhosted.org/packages/54/12/cd77221719d0b39ac0b55dbd39358db1cd1246e0282e104366ebbfb8266a/bcrypt-5.0.0-cp38-abi3-win_arm64.whl", hash = "sha256:cde08734f12c6a4e28dc6755cd11d3bdfea608d93d958fffbe95a7026ebe4980", size = 144931, upload-time = "2025-09-25T19:50:11.016Z" }, + { url = "https://files.pythonhosted.org/packages/5d/ba/2af136406e1c3839aea9ecadc2f6be2bcd1eff255bd451dd39bcf302c47a/bcrypt-5.0.0-cp39-abi3-macosx_10_12_universal2.whl", hash = "sha256:0c418ca99fd47e9c59a301744d63328f17798b5947b0f791e9af3c1c499c2d0a", size = 495313, upload-time = "2025-09-25T19:50:12.309Z" }, + { url = "https://files.pythonhosted.org/packages/ac/ee/2f4985dbad090ace5ad1f7dd8ff94477fe089b5fab2040bd784a3d5f187b/bcrypt-5.0.0-cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ddb4e1500f6efdd402218ffe34d040a1196c072e07929b9820f363a1fd1f4191", size = 275290, upload-time = "2025-09-25T19:50:13.673Z" }, + { url = "https://files.pythonhosted.org/packages/e4/6e/b77ade812672d15cf50842e167eead80ac3514f3beacac8902915417f8b7/bcrypt-5.0.0-cp39-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7aeef54b60ceddb6f30ee3db090351ecf0d40ec6e2abf41430997407a46d2254", size = 278253, upload-time = "2025-09-25T19:50:15.089Z" }, + { url = "https://files.pythonhosted.org/packages/36/c4/ed00ed32f1040f7990dac7115f82273e3c03da1e1a1587a778d8cea496d8/bcrypt-5.0.0-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:f0ce778135f60799d89c9693b9b398819d15f1921ba15fe719acb3178215a7db", size = 276084, upload-time = "2025-09-25T19:50:16.699Z" }, + { url = "https://files.pythonhosted.org/packages/e7/c4/fa6e16145e145e87f1fa351bbd54b429354fd72145cd3d4e0c5157cf4c70/bcrypt-5.0.0-cp39-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:a71f70ee269671460b37a449f5ff26982a6f2ba493b3eabdd687b4bf35f875ac", size = 297185, upload-time = "2025-09-25T19:50:18.525Z" }, + { url = "https://files.pythonhosted.org/packages/24/b4/11f8a31d8b67cca3371e046db49baa7c0594d71eb40ac8121e2fc0888db0/bcrypt-5.0.0-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:f8429e1c410b4073944f03bd778a9e066e7fad723564a52ff91841d278dfc822", size = 278656, upload-time = "2025-09-25T19:50:19.809Z" }, + { url = "https://files.pythonhosted.org/packages/ac/31/79f11865f8078e192847d2cb526e3fa27c200933c982c5b2869720fa5fce/bcrypt-5.0.0-cp39-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:edfcdcedd0d0f05850c52ba3127b1fce70b9f89e0fe5ff16517df7e81fa3cbb8", size = 275662, upload-time = "2025-09-25T19:50:21.567Z" }, + { url = "https://files.pythonhosted.org/packages/d4/8d/5e43d9584b3b3591a6f9b68f755a4da879a59712981ef5ad2a0ac1379f7a/bcrypt-5.0.0-cp39-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:611f0a17aa4a25a69362dcc299fda5c8a3d4f160e2abb3831041feb77393a14a", size = 278240, upload-time = "2025-09-25T19:50:23.305Z" }, + { url = "https://files.pythonhosted.org/packages/89/48/44590e3fc158620f680a978aafe8f87a4c4320da81ed11552f0323aa9a57/bcrypt-5.0.0-cp39-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:db99dca3b1fdc3db87d7c57eac0c82281242d1eabf19dcb8a6b10eb29a2e72d1", size = 311152, upload-time = "2025-09-25T19:50:24.597Z" }, + { url = "https://files.pythonhosted.org/packages/5f/85/e4fbfc46f14f47b0d20493669a625da5827d07e8a88ee460af6cd9768b44/bcrypt-5.0.0-cp39-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:5feebf85a9cefda32966d8171f5db7e3ba964b77fdfe31919622256f80f9cf42", size = 313284, upload-time = "2025-09-25T19:50:26.268Z" }, + { url = "https://files.pythonhosted.org/packages/25/ae/479f81d3f4594456a01ea2f05b132a519eff9ab5768a70430fa1132384b1/bcrypt-5.0.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:3ca8a166b1140436e058298a34d88032ab62f15aae1c598580333dc21d27ef10", size = 341643, upload-time = "2025-09-25T19:50:28.02Z" }, + { url = "https://files.pythonhosted.org/packages/df/d2/36a086dee1473b14276cd6ea7f61aef3b2648710b5d7f1c9e032c29b859f/bcrypt-5.0.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:61afc381250c3182d9078551e3ac3a41da14154fbff647ddf52a769f588c4172", size = 359698, upload-time = "2025-09-25T19:50:31.347Z" }, + { url = "https://files.pythonhosted.org/packages/c0/f6/688d2cd64bfd0b14d805ddb8a565e11ca1fb0fd6817175d58b10052b6d88/bcrypt-5.0.0-cp39-abi3-win32.whl", hash = "sha256:64d7ce196203e468c457c37ec22390f1a61c85c6f0b8160fd752940ccfb3a683", size = 153725, upload-time = "2025-09-25T19:50:34.384Z" }, + { url = "https://files.pythonhosted.org/packages/9f/b9/9d9a641194a730bda138b3dfe53f584d61c58cd5230e37566e83ec2ffa0d/bcrypt-5.0.0-cp39-abi3-win_amd64.whl", hash = "sha256:64ee8434b0da054d830fa8e89e1c8bf30061d539044a39524ff7dec90481e5c2", size = 150912, upload-time = "2025-09-25T19:50:35.69Z" }, + { url = "https://files.pythonhosted.org/packages/27/44/d2ef5e87509158ad2187f4dd0852df80695bb1ee0cfe0a684727b01a69e0/bcrypt-5.0.0-cp39-abi3-win_arm64.whl", hash = "sha256:f2347d3534e76bf50bca5500989d6c1d05ed64b440408057a37673282c654927", size = 144953, upload-time = "2025-09-25T19:50:37.32Z" }, + { url = "https://files.pythonhosted.org/packages/8a/75/4aa9f5a4d40d762892066ba1046000b329c7cd58e888a6db878019b282dc/bcrypt-5.0.0-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:7edda91d5ab52b15636d9c30da87d2cc84f426c72b9dba7a9b4fe142ba11f534", size = 271180, upload-time = "2025-09-25T19:50:38.575Z" }, + { url = "https://files.pythonhosted.org/packages/54/79/875f9558179573d40a9cc743038ac2bf67dfb79cecb1e8b5d70e88c94c3d/bcrypt-5.0.0-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:046ad6db88edb3c5ece4369af997938fb1c19d6a699b9c1b27b0db432faae4c4", size = 273791, upload-time = "2025-09-25T19:50:39.913Z" }, + { url = "https://files.pythonhosted.org/packages/bc/fe/975adb8c216174bf70fc17535f75e85ac06ed5252ea077be10d9cff5ce24/bcrypt-5.0.0-pp311-pypy311_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:dcd58e2b3a908b5ecc9b9df2f0085592506ac2d5110786018ee5e160f28e0911", size = 270746, upload-time = "2025-09-25T19:50:43.306Z" }, + { url = "https://files.pythonhosted.org/packages/e4/f8/972c96f5a2b6c4b3deca57009d93e946bbdbe2241dca9806d502f29dd3ee/bcrypt-5.0.0-pp311-pypy311_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:6b8f520b61e8781efee73cba14e3e8c9556ccfb375623f4f97429544734545b4", size = 273375, upload-time = "2025-09-25T19:50:45.43Z" }, +] + +[[package]] +name = "beautifulsoup4" +version = "4.14.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "soupsieve" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c3/b0/1c6a16426d389813b48d95e26898aff79abbde42ad353958ad95cc8c9b21/beautifulsoup4-4.14.3.tar.gz", hash = "sha256:6292b1c5186d356bba669ef9f7f051757099565ad9ada5dd630bd9de5fa7fb86", size = 627737, upload-time = "2025-11-30T15:08:26.084Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1a/39/47f9197bdd44df24d67ac8893641e16f386c984a0619ef2ee4c51fbbc019/beautifulsoup4-4.14.3-py3-none-any.whl", hash = "sha256:0918bfe44902e6ad8d57732ba310582e98da931428d231a5ecb9e7c703a735bb", size = 107721, upload-time = "2025-11-30T15:08:24.087Z" }, +] + +[[package]] +name = "botocore" +version = "1.41.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jmespath" }, + { name = "python-dateutil" }, + { name = "urllib3" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/90/22/7fe08c726a2e3b11a0aef8bf177e83891c9cb2dc1809d35c9ed91a9e60e6/botocore-1.41.5.tar.gz", hash = "sha256:0367622b811597d183bfcaab4a350f0d3ede712031ce792ef183cabdee80d3bf", size = 14668152, upload-time = "2025-11-26T20:27:38.026Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4e/4e/21cd0b8f365449f1576f93de1ec8718ed18a7a3bc086dfbdeb79437bba7a/botocore-1.41.5-py3-none-any.whl", hash = "sha256:3fef7fcda30c82c27202d232cfdbd6782cb27f20f8e7e21b20606483e66ee73a", size = 14337008, upload-time = "2025-11-26T20:27:35.208Z" }, +] + +[[package]] +name = "cachetools" +version = "6.2.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/fb/44/ca1675be2a83aeee1886ab745b28cda92093066590233cc501890eb8417a/cachetools-6.2.2.tar.gz", hash = "sha256:8e6d266b25e539df852251cfd6f990b4bc3a141db73b939058d809ebd2590fc6", size = 31571, upload-time = "2025-11-13T17:42:51.465Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e6/46/eb6eca305c77a4489affe1c5d8f4cae82f285d9addd8de4ec084a7184221/cachetools-6.2.2-py3-none-any.whl", hash = "sha256:6c09c98183bf58560c97b2abfcedcbaf6a896a490f534b031b661d3723b45ace", size = 11503, upload-time = "2025-11-13T17:42:50.232Z" }, +] + +[[package]] +name = "catalogue" +version = "2.0.10" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/38/b4/244d58127e1cdf04cf2dc7d9566f0d24ef01d5ce21811bab088ecc62b5ea/catalogue-2.0.10.tar.gz", hash = "sha256:4f56daa940913d3f09d589c191c74e5a6d51762b3a9e37dd53b7437afd6cda15", size = 19561, upload-time = "2023-09-25T06:29:24.962Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/96/d32b941a501ab566a16358d68b6eb4e4acc373fab3c3c4d7d9e649f7b4bb/catalogue-2.0.10-py3-none-any.whl", hash = "sha256:58c2de0020aa90f4a2da7dfad161bf7b3b054c86a5f09fcedc0b2b740c109a9f", size = 17325, upload-time = "2023-09-25T06:29:23.337Z" }, +] + +[[package]] +name = "certifi" +version = "2025.11.12" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a2/8c/58f469717fa48465e4a50c014a0400602d3c437d7c0c468e17ada824da3a/certifi-2025.11.12.tar.gz", hash = "sha256:d8ab5478f2ecd78af242878415affce761ca6bc54a22a27e026d7c25357c3316", size = 160538, upload-time = "2025-11-12T02:54:51.517Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/70/7d/9bc192684cea499815ff478dfcdc13835ddf401365057044fb721ec6bddb/certifi-2025.11.12-py3-none-any.whl", hash = "sha256:97de8790030bbd5c2d96b7ec782fc2f7820ef8dba6db909ccf95449f2d062d4b", size = 159438, upload-time = "2025-11-12T02:54:49.735Z" }, +] + +[[package]] +name = "cffi" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pycparser", marker = "implementation_name != 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", hash = "sha256:44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529", size = 523588, upload-time = "2025-09-08T23:24:04.541Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/93/d7/516d984057745a6cd96575eea814fe1edd6646ee6efd552fb7b0921dec83/cffi-2.0.0-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:0cf2d91ecc3fcc0625c2c530fe004f82c110405f101548512cce44322fa8ac44", size = 184283, upload-time = "2025-09-08T23:22:08.01Z" }, + { url = "https://files.pythonhosted.org/packages/9e/84/ad6a0b408daa859246f57c03efd28e5dd1b33c21737c2db84cae8c237aa5/cffi-2.0.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f73b96c41e3b2adedc34a7356e64c8eb96e03a3782b535e043a986276ce12a49", size = 180504, upload-time = "2025-09-08T23:22:10.637Z" }, + { url = "https://files.pythonhosted.org/packages/50/bd/b1a6362b80628111e6653c961f987faa55262b4002fcec42308cad1db680/cffi-2.0.0-cp310-cp310-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:53f77cbe57044e88bbd5ed26ac1d0514d2acf0591dd6bb02a3ae37f76811b80c", size = 208811, upload-time = "2025-09-08T23:22:12.267Z" }, + { url = "https://files.pythonhosted.org/packages/4f/27/6933a8b2562d7bd1fb595074cf99cc81fc3789f6a6c05cdabb46284a3188/cffi-2.0.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:3e837e369566884707ddaf85fc1744b47575005c0a229de3327f8f9a20f4efeb", size = 216402, upload-time = "2025-09-08T23:22:13.455Z" }, + { url = "https://files.pythonhosted.org/packages/05/eb/b86f2a2645b62adcfff53b0dd97e8dfafb5c8aa864bd0d9a2c2049a0d551/cffi-2.0.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:5eda85d6d1879e692d546a078b44251cdd08dd1cfb98dfb77b670c97cee49ea0", size = 203217, upload-time = "2025-09-08T23:22:14.596Z" }, + { url = "https://files.pythonhosted.org/packages/9f/e0/6cbe77a53acf5acc7c08cc186c9928864bd7c005f9efd0d126884858a5fe/cffi-2.0.0-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:9332088d75dc3241c702d852d4671613136d90fa6881da7d770a483fd05248b4", size = 203079, upload-time = "2025-09-08T23:22:15.769Z" }, + { url = "https://files.pythonhosted.org/packages/98/29/9b366e70e243eb3d14a5cb488dfd3a0b6b2f1fb001a203f653b93ccfac88/cffi-2.0.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fc7de24befaeae77ba923797c7c87834c73648a05a4bde34b3b7e5588973a453", size = 216475, upload-time = "2025-09-08T23:22:17.427Z" }, + { url = "https://files.pythonhosted.org/packages/21/7a/13b24e70d2f90a322f2900c5d8e1f14fa7e2a6b3332b7309ba7b2ba51a5a/cffi-2.0.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:cf364028c016c03078a23b503f02058f1814320a56ad535686f90565636a9495", size = 218829, upload-time = "2025-09-08T23:22:19.069Z" }, + { url = "https://files.pythonhosted.org/packages/60/99/c9dc110974c59cc981b1f5b66e1d8af8af764e00f0293266824d9c4254bc/cffi-2.0.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:e11e82b744887154b182fd3e7e8512418446501191994dbf9c9fc1f32cc8efd5", size = 211211, upload-time = "2025-09-08T23:22:20.588Z" }, + { url = "https://files.pythonhosted.org/packages/49/72/ff2d12dbf21aca1b32a40ed792ee6b40f6dc3a9cf1644bd7ef6e95e0ac5e/cffi-2.0.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:8ea985900c5c95ce9db1745f7933eeef5d314f0565b27625d9a10ec9881e1bfb", size = 218036, upload-time = "2025-09-08T23:22:22.143Z" }, + { url = "https://files.pythonhosted.org/packages/e2/cc/027d7fb82e58c48ea717149b03bcadcbdc293553edb283af792bd4bcbb3f/cffi-2.0.0-cp310-cp310-win32.whl", hash = "sha256:1f72fb8906754ac8a2cc3f9f5aaa298070652a0ffae577e0ea9bd480dc3c931a", size = 172184, upload-time = "2025-09-08T23:22:23.328Z" }, + { url = "https://files.pythonhosted.org/packages/33/fa/072dd15ae27fbb4e06b437eb6e944e75b068deb09e2a2826039e49ee2045/cffi-2.0.0-cp310-cp310-win_amd64.whl", hash = "sha256:b18a3ed7d5b3bd8d9ef7a8cb226502c6bf8308df1525e1cc676c3680e7176739", size = 182790, upload-time = "2025-09-08T23:22:24.752Z" }, + { url = "https://files.pythonhosted.org/packages/12/4a/3dfd5f7850cbf0d06dc84ba9aa00db766b52ca38d8b86e3a38314d52498c/cffi-2.0.0-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:b4c854ef3adc177950a8dfc81a86f5115d2abd545751a304c5bcf2c2c7283cfe", size = 184344, upload-time = "2025-09-08T23:22:26.456Z" }, + { url = "https://files.pythonhosted.org/packages/4f/8b/f0e4c441227ba756aafbe78f117485b25bb26b1c059d01f137fa6d14896b/cffi-2.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2de9a304e27f7596cd03d16f1b7c72219bd944e99cc52b84d0145aefb07cbd3c", size = 180560, upload-time = "2025-09-08T23:22:28.197Z" }, + { url = "https://files.pythonhosted.org/packages/b1/b7/1200d354378ef52ec227395d95c2576330fd22a869f7a70e88e1447eb234/cffi-2.0.0-cp311-cp311-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:baf5215e0ab74c16e2dd324e8ec067ef59e41125d3eade2b863d294fd5035c92", size = 209613, upload-time = "2025-09-08T23:22:29.475Z" }, + { url = "https://files.pythonhosted.org/packages/b8/56/6033f5e86e8cc9bb629f0077ba71679508bdf54a9a5e112a3c0b91870332/cffi-2.0.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:730cacb21e1bdff3ce90babf007d0a0917cc3e6492f336c2f0134101e0944f93", size = 216476, upload-time = "2025-09-08T23:22:31.063Z" }, + { url = "https://files.pythonhosted.org/packages/dc/7f/55fecd70f7ece178db2f26128ec41430d8720f2d12ca97bf8f0a628207d5/cffi-2.0.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:6824f87845e3396029f3820c206e459ccc91760e8fa24422f8b0c3d1731cbec5", size = 203374, upload-time = "2025-09-08T23:22:32.507Z" }, + { url = "https://files.pythonhosted.org/packages/84/ef/a7b77c8bdc0f77adc3b46888f1ad54be8f3b7821697a7b89126e829e676a/cffi-2.0.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:9de40a7b0323d889cf8d23d1ef214f565ab154443c42737dfe52ff82cf857664", size = 202597, upload-time = "2025-09-08T23:22:34.132Z" }, + { url = "https://files.pythonhosted.org/packages/d7/91/500d892b2bf36529a75b77958edfcd5ad8e2ce4064ce2ecfeab2125d72d1/cffi-2.0.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8941aaadaf67246224cee8c3803777eed332a19d909b47e29c9842ef1e79ac26", size = 215574, upload-time = "2025-09-08T23:22:35.443Z" }, + { url = "https://files.pythonhosted.org/packages/44/64/58f6255b62b101093d5df22dcb752596066c7e89dd725e0afaed242a61be/cffi-2.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:a05d0c237b3349096d3981b727493e22147f934b20f6f125a3eba8f994bec4a9", size = 218971, upload-time = "2025-09-08T23:22:36.805Z" }, + { url = "https://files.pythonhosted.org/packages/ab/49/fa72cebe2fd8a55fbe14956f9970fe8eb1ac59e5df042f603ef7c8ba0adc/cffi-2.0.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:94698a9c5f91f9d138526b48fe26a199609544591f859c870d477351dc7b2414", size = 211972, upload-time = "2025-09-08T23:22:38.436Z" }, + { url = "https://files.pythonhosted.org/packages/0b/28/dd0967a76aab36731b6ebfe64dec4e981aff7e0608f60c2d46b46982607d/cffi-2.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:5fed36fccc0612a53f1d4d9a816b50a36702c28a2aa880cb8a122b3466638743", size = 217078, upload-time = "2025-09-08T23:22:39.776Z" }, + { url = "https://files.pythonhosted.org/packages/2b/c0/015b25184413d7ab0a410775fdb4a50fca20f5589b5dab1dbbfa3baad8ce/cffi-2.0.0-cp311-cp311-win32.whl", hash = "sha256:c649e3a33450ec82378822b3dad03cc228b8f5963c0c12fc3b1e0ab940f768a5", size = 172076, upload-time = "2025-09-08T23:22:40.95Z" }, + { url = "https://files.pythonhosted.org/packages/ae/8f/dc5531155e7070361eb1b7e4c1a9d896d0cb21c49f807a6c03fd63fc877e/cffi-2.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:66f011380d0e49ed280c789fbd08ff0d40968ee7b665575489afa95c98196ab5", size = 182820, upload-time = "2025-09-08T23:22:42.463Z" }, + { url = "https://files.pythonhosted.org/packages/95/5c/1b493356429f9aecfd56bc171285a4c4ac8697f76e9bbbbb105e537853a1/cffi-2.0.0-cp311-cp311-win_arm64.whl", hash = "sha256:c6638687455baf640e37344fe26d37c404db8b80d037c3d29f58fe8d1c3b194d", size = 177635, upload-time = "2025-09-08T23:22:43.623Z" }, + { url = "https://files.pythonhosted.org/packages/ea/47/4f61023ea636104d4f16ab488e268b93008c3d0bb76893b1b31db1f96802/cffi-2.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6d02d6655b0e54f54c4ef0b94eb6be0607b70853c45ce98bd278dc7de718be5d", size = 185271, upload-time = "2025-09-08T23:22:44.795Z" }, + { url = "https://files.pythonhosted.org/packages/df/a2/781b623f57358e360d62cdd7a8c681f074a71d445418a776eef0aadb4ab4/cffi-2.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8eca2a813c1cb7ad4fb74d368c2ffbbb4789d377ee5bb8df98373c2cc0dee76c", size = 181048, upload-time = "2025-09-08T23:22:45.938Z" }, + { url = "https://files.pythonhosted.org/packages/ff/df/a4f0fbd47331ceeba3d37c2e51e9dfc9722498becbeec2bd8bc856c9538a/cffi-2.0.0-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:21d1152871b019407d8ac3985f6775c079416c282e431a4da6afe7aefd2bccbe", size = 212529, upload-time = "2025-09-08T23:22:47.349Z" }, + { url = "https://files.pythonhosted.org/packages/d5/72/12b5f8d3865bf0f87cf1404d8c374e7487dcf097a1c91c436e72e6badd83/cffi-2.0.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b21e08af67b8a103c71a250401c78d5e0893beff75e28c53c98f4de42f774062", size = 220097, upload-time = "2025-09-08T23:22:48.677Z" }, + { url = "https://files.pythonhosted.org/packages/c2/95/7a135d52a50dfa7c882ab0ac17e8dc11cec9d55d2c18dda414c051c5e69e/cffi-2.0.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:1e3a615586f05fc4065a8b22b8152f0c1b00cdbc60596d187c2a74f9e3036e4e", size = 207983, upload-time = "2025-09-08T23:22:50.06Z" }, + { url = "https://files.pythonhosted.org/packages/3a/c8/15cb9ada8895957ea171c62dc78ff3e99159ee7adb13c0123c001a2546c1/cffi-2.0.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:81afed14892743bbe14dacb9e36d9e0e504cd204e0b165062c488942b9718037", size = 206519, upload-time = "2025-09-08T23:22:51.364Z" }, + { url = "https://files.pythonhosted.org/packages/78/2d/7fa73dfa841b5ac06c7b8855cfc18622132e365f5b81d02230333ff26e9e/cffi-2.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3e17ed538242334bf70832644a32a7aae3d83b57567f9fd60a26257e992b79ba", size = 219572, upload-time = "2025-09-08T23:22:52.902Z" }, + { url = "https://files.pythonhosted.org/packages/07/e0/267e57e387b4ca276b90f0434ff88b2c2241ad72b16d31836adddfd6031b/cffi-2.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3925dd22fa2b7699ed2617149842d2e6adde22b262fcbfada50e3d195e4b3a94", size = 222963, upload-time = "2025-09-08T23:22:54.518Z" }, + { url = "https://files.pythonhosted.org/packages/b6/75/1f2747525e06f53efbd878f4d03bac5b859cbc11c633d0fb81432d98a795/cffi-2.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2c8f814d84194c9ea681642fd164267891702542f028a15fc97d4674b6206187", size = 221361, upload-time = "2025-09-08T23:22:55.867Z" }, + { url = "https://files.pythonhosted.org/packages/7b/2b/2b6435f76bfeb6bbf055596976da087377ede68df465419d192acf00c437/cffi-2.0.0-cp312-cp312-win32.whl", hash = "sha256:da902562c3e9c550df360bfa53c035b2f241fed6d9aef119048073680ace4a18", size = 172932, upload-time = "2025-09-08T23:22:57.188Z" }, + { url = "https://files.pythonhosted.org/packages/f8/ed/13bd4418627013bec4ed6e54283b1959cf6db888048c7cf4b4c3b5b36002/cffi-2.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:da68248800ad6320861f129cd9c1bf96ca849a2771a59e0344e88681905916f5", size = 183557, upload-time = "2025-09-08T23:22:58.351Z" }, + { url = "https://files.pythonhosted.org/packages/95/31/9f7f93ad2f8eff1dbc1c3656d7ca5bfd8fb52c9d786b4dcf19b2d02217fa/cffi-2.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:4671d9dd5ec934cb9a73e7ee9676f9362aba54f7f34910956b84d727b0d73fb6", size = 177762, upload-time = "2025-09-08T23:22:59.668Z" }, + { url = "https://files.pythonhosted.org/packages/4b/8d/a0a47a0c9e413a658623d014e91e74a50cdd2c423f7ccfd44086ef767f90/cffi-2.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:00bdf7acc5f795150faa6957054fbbca2439db2f775ce831222b66f192f03beb", size = 185230, upload-time = "2025-09-08T23:23:00.879Z" }, + { url = "https://files.pythonhosted.org/packages/4a/d2/a6c0296814556c68ee32009d9c2ad4f85f2707cdecfd7727951ec228005d/cffi-2.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:45d5e886156860dc35862657e1494b9bae8dfa63bf56796f2fb56e1679fc0bca", size = 181043, upload-time = "2025-09-08T23:23:02.231Z" }, + { url = "https://files.pythonhosted.org/packages/b0/1e/d22cc63332bd59b06481ceaac49d6c507598642e2230f201649058a7e704/cffi-2.0.0-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:07b271772c100085dd28b74fa0cd81c8fb1a3ba18b21e03d7c27f3436a10606b", size = 212446, upload-time = "2025-09-08T23:23:03.472Z" }, + { url = "https://files.pythonhosted.org/packages/a9/f5/a2c23eb03b61a0b8747f211eb716446c826ad66818ddc7810cc2cc19b3f2/cffi-2.0.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d48a880098c96020b02d5a1f7d9251308510ce8858940e6fa99ece33f610838b", size = 220101, upload-time = "2025-09-08T23:23:04.792Z" }, + { url = "https://files.pythonhosted.org/packages/f2/7f/e6647792fc5850d634695bc0e6ab4111ae88e89981d35ac269956605feba/cffi-2.0.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:f93fd8e5c8c0a4aa1f424d6173f14a892044054871c771f8566e4008eaa359d2", size = 207948, upload-time = "2025-09-08T23:23:06.127Z" }, + { url = "https://files.pythonhosted.org/packages/cb/1e/a5a1bd6f1fb30f22573f76533de12a00bf274abcdc55c8edab639078abb6/cffi-2.0.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:dd4f05f54a52fb558f1ba9f528228066954fee3ebe629fc1660d874d040ae5a3", size = 206422, upload-time = "2025-09-08T23:23:07.753Z" }, + { url = "https://files.pythonhosted.org/packages/98/df/0a1755e750013a2081e863e7cd37e0cdd02664372c754e5560099eb7aa44/cffi-2.0.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c8d3b5532fc71b7a77c09192b4a5a200ea992702734a2e9279a37f2478236f26", size = 219499, upload-time = "2025-09-08T23:23:09.648Z" }, + { url = "https://files.pythonhosted.org/packages/50/e1/a969e687fcf9ea58e6e2a928ad5e2dd88cc12f6f0ab477e9971f2309b57c/cffi-2.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d9b29c1f0ae438d5ee9acb31cadee00a58c46cc9c0b2f9038c6b0b3470877a8c", size = 222928, upload-time = "2025-09-08T23:23:10.928Z" }, + { url = "https://files.pythonhosted.org/packages/36/54/0362578dd2c9e557a28ac77698ed67323ed5b9775ca9d3fe73fe191bb5d8/cffi-2.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6d50360be4546678fc1b79ffe7a66265e28667840010348dd69a314145807a1b", size = 221302, upload-time = "2025-09-08T23:23:12.42Z" }, + { url = "https://files.pythonhosted.org/packages/eb/6d/bf9bda840d5f1dfdbf0feca87fbdb64a918a69bca42cfa0ba7b137c48cb8/cffi-2.0.0-cp313-cp313-win32.whl", hash = "sha256:74a03b9698e198d47562765773b4a8309919089150a0bb17d829ad7b44b60d27", size = 172909, upload-time = "2025-09-08T23:23:14.32Z" }, + { url = "https://files.pythonhosted.org/packages/37/18/6519e1ee6f5a1e579e04b9ddb6f1676c17368a7aba48299c3759bbc3c8b3/cffi-2.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:19f705ada2530c1167abacb171925dd886168931e0a7b78f5bffcae5c6b5be75", size = 183402, upload-time = "2025-09-08T23:23:15.535Z" }, + { url = "https://files.pythonhosted.org/packages/cb/0e/02ceeec9a7d6ee63bb596121c2c8e9b3a9e150936f4fbef6ca1943e6137c/cffi-2.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:256f80b80ca3853f90c21b23ee78cd008713787b1b1e93eae9f3d6a7134abd91", size = 177780, upload-time = "2025-09-08T23:23:16.761Z" }, + { url = "https://files.pythonhosted.org/packages/92/c4/3ce07396253a83250ee98564f8d7e9789fab8e58858f35d07a9a2c78de9f/cffi-2.0.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fc33c5141b55ed366cfaad382df24fe7dcbc686de5be719b207bb248e3053dc5", size = 185320, upload-time = "2025-09-08T23:23:18.087Z" }, + { url = "https://files.pythonhosted.org/packages/59/dd/27e9fa567a23931c838c6b02d0764611c62290062a6d4e8ff7863daf9730/cffi-2.0.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c654de545946e0db659b3400168c9ad31b5d29593291482c43e3564effbcee13", size = 181487, upload-time = "2025-09-08T23:23:19.622Z" }, + { url = "https://files.pythonhosted.org/packages/d6/43/0e822876f87ea8a4ef95442c3d766a06a51fc5298823f884ef87aaad168c/cffi-2.0.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:24b6f81f1983e6df8db3adc38562c83f7d4a0c36162885ec7f7b77c7dcbec97b", size = 220049, upload-time = "2025-09-08T23:23:20.853Z" }, + { url = "https://files.pythonhosted.org/packages/b4/89/76799151d9c2d2d1ead63c2429da9ea9d7aac304603de0c6e8764e6e8e70/cffi-2.0.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:12873ca6cb9b0f0d3a0da705d6086fe911591737a59f28b7936bdfed27c0d47c", size = 207793, upload-time = "2025-09-08T23:23:22.08Z" }, + { url = "https://files.pythonhosted.org/packages/bb/dd/3465b14bb9e24ee24cb88c9e3730f6de63111fffe513492bf8c808a3547e/cffi-2.0.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:d9b97165e8aed9272a6bb17c01e3cc5871a594a446ebedc996e2397a1c1ea8ef", size = 206300, upload-time = "2025-09-08T23:23:23.314Z" }, + { url = "https://files.pythonhosted.org/packages/47/d9/d83e293854571c877a92da46fdec39158f8d7e68da75bf73581225d28e90/cffi-2.0.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:afb8db5439b81cf9c9d0c80404b60c3cc9c3add93e114dcae767f1477cb53775", size = 219244, upload-time = "2025-09-08T23:23:24.541Z" }, + { url = "https://files.pythonhosted.org/packages/2b/0f/1f177e3683aead2bb00f7679a16451d302c436b5cbf2505f0ea8146ef59e/cffi-2.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:737fe7d37e1a1bffe70bd5754ea763a62a066dc5913ca57e957824b72a85e205", size = 222828, upload-time = "2025-09-08T23:23:26.143Z" }, + { url = "https://files.pythonhosted.org/packages/c6/0f/cafacebd4b040e3119dcb32fed8bdef8dfe94da653155f9d0b9dc660166e/cffi-2.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:38100abb9d1b1435bc4cc340bb4489635dc2f0da7456590877030c9b3d40b0c1", size = 220926, upload-time = "2025-09-08T23:23:27.873Z" }, + { url = "https://files.pythonhosted.org/packages/3e/aa/df335faa45b395396fcbc03de2dfcab242cd61a9900e914fe682a59170b1/cffi-2.0.0-cp314-cp314-win32.whl", hash = "sha256:087067fa8953339c723661eda6b54bc98c5625757ea62e95eb4898ad5e776e9f", size = 175328, upload-time = "2025-09-08T23:23:44.61Z" }, + { url = "https://files.pythonhosted.org/packages/bb/92/882c2d30831744296ce713f0feb4c1cd30f346ef747b530b5318715cc367/cffi-2.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:203a48d1fb583fc7d78a4c6655692963b860a417c0528492a6bc21f1aaefab25", size = 185650, upload-time = "2025-09-08T23:23:45.848Z" }, + { url = "https://files.pythonhosted.org/packages/9f/2c/98ece204b9d35a7366b5b2c6539c350313ca13932143e79dc133ba757104/cffi-2.0.0-cp314-cp314-win_arm64.whl", hash = "sha256:dbd5c7a25a7cb98f5ca55d258b103a2054f859a46ae11aaf23134f9cc0d356ad", size = 180687, upload-time = "2025-09-08T23:23:47.105Z" }, + { url = "https://files.pythonhosted.org/packages/3e/61/c768e4d548bfa607abcda77423448df8c471f25dbe64fb2ef6d555eae006/cffi-2.0.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:9a67fc9e8eb39039280526379fb3a70023d77caec1852002b4da7e8b270c4dd9", size = 188773, upload-time = "2025-09-08T23:23:29.347Z" }, + { url = "https://files.pythonhosted.org/packages/2c/ea/5f76bce7cf6fcd0ab1a1058b5af899bfbef198bea4d5686da88471ea0336/cffi-2.0.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7a66c7204d8869299919db4d5069a82f1561581af12b11b3c9f48c584eb8743d", size = 185013, upload-time = "2025-09-08T23:23:30.63Z" }, + { url = "https://files.pythonhosted.org/packages/be/b4/c56878d0d1755cf9caa54ba71e5d049479c52f9e4afc230f06822162ab2f/cffi-2.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7cc09976e8b56f8cebd752f7113ad07752461f48a58cbba644139015ac24954c", size = 221593, upload-time = "2025-09-08T23:23:31.91Z" }, + { url = "https://files.pythonhosted.org/packages/e0/0d/eb704606dfe8033e7128df5e90fee946bbcb64a04fcdaa97321309004000/cffi-2.0.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:92b68146a71df78564e4ef48af17551a5ddd142e5190cdf2c5624d0c3ff5b2e8", size = 209354, upload-time = "2025-09-08T23:23:33.214Z" }, + { url = "https://files.pythonhosted.org/packages/d8/19/3c435d727b368ca475fb8742ab97c9cb13a0de600ce86f62eab7fa3eea60/cffi-2.0.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:b1e74d11748e7e98e2f426ab176d4ed720a64412b6a15054378afdb71e0f37dc", size = 208480, upload-time = "2025-09-08T23:23:34.495Z" }, + { url = "https://files.pythonhosted.org/packages/d0/44/681604464ed9541673e486521497406fadcc15b5217c3e326b061696899a/cffi-2.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:28a3a209b96630bca57cce802da70c266eb08c6e97e5afd61a75611ee6c64592", size = 221584, upload-time = "2025-09-08T23:23:36.096Z" }, + { url = "https://files.pythonhosted.org/packages/25/8e/342a504ff018a2825d395d44d63a767dd8ebc927ebda557fecdaca3ac33a/cffi-2.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7553fb2090d71822f02c629afe6042c299edf91ba1bf94951165613553984512", size = 224443, upload-time = "2025-09-08T23:23:37.328Z" }, + { url = "https://files.pythonhosted.org/packages/e1/5e/b666bacbbc60fbf415ba9988324a132c9a7a0448a9a8f125074671c0f2c3/cffi-2.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6c6c373cfc5c83a975506110d17457138c8c63016b563cc9ed6e056a82f13ce4", size = 223437, upload-time = "2025-09-08T23:23:38.945Z" }, + { url = "https://files.pythonhosted.org/packages/a0/1d/ec1a60bd1a10daa292d3cd6bb0b359a81607154fb8165f3ec95fe003b85c/cffi-2.0.0-cp314-cp314t-win32.whl", hash = "sha256:1fc9ea04857caf665289b7a75923f2c6ed559b8298a1b8c49e59f7dd95c8481e", size = 180487, upload-time = "2025-09-08T23:23:40.423Z" }, + { url = "https://files.pythonhosted.org/packages/bf/41/4c1168c74fac325c0c8156f04b6749c8b6a8f405bbf91413ba088359f60d/cffi-2.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:d68b6cef7827e8641e8ef16f4494edda8b36104d79773a334beaa1e3521430f6", size = 191726, upload-time = "2025-09-08T23:23:41.742Z" }, + { url = "https://files.pythonhosted.org/packages/ae/3a/dbeec9d1ee0844c679f6bb5d6ad4e9f198b1224f4e7a32825f47f6192b0c/cffi-2.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0a1527a803f0a659de1af2e1fd700213caba79377e27e4693648c2923da066f9", size = 184195, upload-time = "2025-09-08T23:23:43.004Z" }, +] + +[[package]] +name = "charset-normalizer" +version = "3.4.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/13/69/33ddede1939fdd074bce5434295f38fae7136463422fe4fd3e0e89b98062/charset_normalizer-3.4.4.tar.gz", hash = "sha256:94537985111c35f28720e43603b8e7b43a6ecfb2ce1d3058bbe955b73404e21a", size = 129418, upload-time = "2025-10-14T04:42:32.879Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1f/b8/6d51fc1d52cbd52cd4ccedd5b5b2f0f6a11bbf6765c782298b0f3e808541/charset_normalizer-3.4.4-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:e824f1492727fa856dd6eda4f7cee25f8518a12f3c4a56a74e8095695089cf6d", size = 209709, upload-time = "2025-10-14T04:40:11.385Z" }, + { url = "https://files.pythonhosted.org/packages/5c/af/1f9d7f7faafe2ddfb6f72a2e07a548a629c61ad510fe60f9630309908fef/charset_normalizer-3.4.4-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4bd5d4137d500351a30687c2d3971758aac9a19208fc110ccb9d7188fbe709e8", size = 148814, upload-time = "2025-10-14T04:40:13.135Z" }, + { url = "https://files.pythonhosted.org/packages/79/3d/f2e3ac2bbc056ca0c204298ea4e3d9db9b4afe437812638759db2c976b5f/charset_normalizer-3.4.4-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:027f6de494925c0ab2a55eab46ae5129951638a49a34d87f4c3eda90f696b4ad", size = 144467, upload-time = "2025-10-14T04:40:14.728Z" }, + { url = "https://files.pythonhosted.org/packages/ec/85/1bf997003815e60d57de7bd972c57dc6950446a3e4ccac43bc3070721856/charset_normalizer-3.4.4-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f820802628d2694cb7e56db99213f930856014862f3fd943d290ea8438d07ca8", size = 162280, upload-time = "2025-10-14T04:40:16.14Z" }, + { url = "https://files.pythonhosted.org/packages/3e/8e/6aa1952f56b192f54921c436b87f2aaf7c7a7c3d0d1a765547d64fd83c13/charset_normalizer-3.4.4-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:798d75d81754988d2565bff1b97ba5a44411867c0cf32b77a7e8f8d84796b10d", size = 159454, upload-time = "2025-10-14T04:40:17.567Z" }, + { url = "https://files.pythonhosted.org/packages/36/3b/60cbd1f8e93aa25d1c669c649b7a655b0b5fb4c571858910ea9332678558/charset_normalizer-3.4.4-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9d1bb833febdff5c8927f922386db610b49db6e0d4f4ee29601d71e7c2694313", size = 153609, upload-time = "2025-10-14T04:40:19.08Z" }, + { url = "https://files.pythonhosted.org/packages/64/91/6a13396948b8fd3c4b4fd5bc74d045f5637d78c9675585e8e9fbe5636554/charset_normalizer-3.4.4-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:9cd98cdc06614a2f768d2b7286d66805f94c48cde050acdbbb7db2600ab3197e", size = 151849, upload-time = "2025-10-14T04:40:20.607Z" }, + { url = "https://files.pythonhosted.org/packages/b7/7a/59482e28b9981d105691e968c544cc0df3b7d6133152fb3dcdc8f135da7a/charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:077fbb858e903c73f6c9db43374fd213b0b6a778106bc7032446a8e8b5b38b93", size = 151586, upload-time = "2025-10-14T04:40:21.719Z" }, + { url = "https://files.pythonhosted.org/packages/92/59/f64ef6a1c4bdd2baf892b04cd78792ed8684fbc48d4c2afe467d96b4df57/charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:244bfb999c71b35de57821b8ea746b24e863398194a4014e4c76adc2bbdfeff0", size = 145290, upload-time = "2025-10-14T04:40:23.069Z" }, + { url = "https://files.pythonhosted.org/packages/6b/63/3bf9f279ddfa641ffa1962b0db6a57a9c294361cc2f5fcac997049a00e9c/charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:64b55f9dce520635f018f907ff1b0df1fdc31f2795a922fb49dd14fbcdf48c84", size = 163663, upload-time = "2025-10-14T04:40:24.17Z" }, + { url = "https://files.pythonhosted.org/packages/ed/09/c9e38fc8fa9e0849b172b581fd9803bdf6e694041127933934184e19f8c3/charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:faa3a41b2b66b6e50f84ae4a68c64fcd0c44355741c6374813a800cd6695db9e", size = 151964, upload-time = "2025-10-14T04:40:25.368Z" }, + { url = "https://files.pythonhosted.org/packages/d2/d1/d28b747e512d0da79d8b6a1ac18b7ab2ecfd81b2944c4c710e166d8dd09c/charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:6515f3182dbe4ea06ced2d9e8666d97b46ef4c75e326b79bb624110f122551db", size = 161064, upload-time = "2025-10-14T04:40:26.806Z" }, + { url = "https://files.pythonhosted.org/packages/bb/9a/31d62b611d901c3b9e5500c36aab0ff5eb442043fb3a1c254200d3d397d9/charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:cc00f04ed596e9dc0da42ed17ac5e596c6ccba999ba6bd92b0e0aef2f170f2d6", size = 155015, upload-time = "2025-10-14T04:40:28.284Z" }, + { url = "https://files.pythonhosted.org/packages/1f/f3/107e008fa2bff0c8b9319584174418e5e5285fef32f79d8ee6a430d0039c/charset_normalizer-3.4.4-cp310-cp310-win32.whl", hash = "sha256:f34be2938726fc13801220747472850852fe6b1ea75869a048d6f896838c896f", size = 99792, upload-time = "2025-10-14T04:40:29.613Z" }, + { url = "https://files.pythonhosted.org/packages/eb/66/e396e8a408843337d7315bab30dbf106c38966f1819f123257f5520f8a96/charset_normalizer-3.4.4-cp310-cp310-win_amd64.whl", hash = "sha256:a61900df84c667873b292c3de315a786dd8dac506704dea57bc957bd31e22c7d", size = 107198, upload-time = "2025-10-14T04:40:30.644Z" }, + { url = "https://files.pythonhosted.org/packages/b5/58/01b4f815bf0312704c267f2ccb6e5d42bcc7752340cd487bc9f8c3710597/charset_normalizer-3.4.4-cp310-cp310-win_arm64.whl", hash = "sha256:cead0978fc57397645f12578bfd2d5ea9138ea0fac82b2f63f7f7c6877986a69", size = 100262, upload-time = "2025-10-14T04:40:32.108Z" }, + { url = "https://files.pythonhosted.org/packages/ed/27/c6491ff4954e58a10f69ad90aca8a1b6fe9c5d3c6f380907af3c37435b59/charset_normalizer-3.4.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:6e1fcf0720908f200cd21aa4e6750a48ff6ce4afe7ff5a79a90d5ed8a08296f8", size = 206988, upload-time = "2025-10-14T04:40:33.79Z" }, + { url = "https://files.pythonhosted.org/packages/94/59/2e87300fe67ab820b5428580a53cad894272dbb97f38a7a814a2a1ac1011/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5f819d5fe9234f9f82d75bdfa9aef3a3d72c4d24a6e57aeaebba32a704553aa0", size = 147324, upload-time = "2025-10-14T04:40:34.961Z" }, + { url = "https://files.pythonhosted.org/packages/07/fb/0cf61dc84b2b088391830f6274cb57c82e4da8bbc2efeac8c025edb88772/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:a59cb51917aa591b1c4e6a43c132f0cdc3c76dbad6155df4e28ee626cc77a0a3", size = 142742, upload-time = "2025-10-14T04:40:36.105Z" }, + { url = "https://files.pythonhosted.org/packages/62/8b/171935adf2312cd745d290ed93cf16cf0dfe320863ab7cbeeae1dcd6535f/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8ef3c867360f88ac904fd3f5e1f902f13307af9052646963ee08ff4f131adafc", size = 160863, upload-time = "2025-10-14T04:40:37.188Z" }, + { url = "https://files.pythonhosted.org/packages/09/73/ad875b192bda14f2173bfc1bc9a55e009808484a4b256748d931b6948442/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d9e45d7faa48ee908174d8fe84854479ef838fc6a705c9315372eacbc2f02897", size = 157837, upload-time = "2025-10-14T04:40:38.435Z" }, + { url = "https://files.pythonhosted.org/packages/6d/fc/de9cce525b2c5b94b47c70a4b4fb19f871b24995c728e957ee68ab1671ea/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:840c25fb618a231545cbab0564a799f101b63b9901f2569faecd6b222ac72381", size = 151550, upload-time = "2025-10-14T04:40:40.053Z" }, + { url = "https://files.pythonhosted.org/packages/55/c2/43edd615fdfba8c6f2dfbd459b25a6b3b551f24ea21981e23fb768503ce1/charset_normalizer-3.4.4-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ca5862d5b3928c4940729dacc329aa9102900382fea192fc5e52eb69d6093815", size = 149162, upload-time = "2025-10-14T04:40:41.163Z" }, + { url = "https://files.pythonhosted.org/packages/03/86/bde4ad8b4d0e9429a4e82c1e8f5c659993a9a863ad62c7df05cf7b678d75/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d9c7f57c3d666a53421049053eaacdd14bbd0a528e2186fcb2e672effd053bb0", size = 150019, upload-time = "2025-10-14T04:40:42.276Z" }, + { url = "https://files.pythonhosted.org/packages/1f/86/a151eb2af293a7e7bac3a739b81072585ce36ccfb4493039f49f1d3cae8c/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:277e970e750505ed74c832b4bf75dac7476262ee2a013f5574dd49075879e161", size = 143310, upload-time = "2025-10-14T04:40:43.439Z" }, + { url = "https://files.pythonhosted.org/packages/b5/fe/43dae6144a7e07b87478fdfc4dbe9efd5defb0e7ec29f5f58a55aeef7bf7/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:31fd66405eaf47bb62e8cd575dc621c56c668f27d46a61d975a249930dd5e2a4", size = 162022, upload-time = "2025-10-14T04:40:44.547Z" }, + { url = "https://files.pythonhosted.org/packages/80/e6/7aab83774f5d2bca81f42ac58d04caf44f0cc2b65fc6db2b3b2e8a05f3b3/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:0d3d8f15c07f86e9ff82319b3d9ef6f4bf907608f53fe9d92b28ea9ae3d1fd89", size = 149383, upload-time = "2025-10-14T04:40:46.018Z" }, + { url = "https://files.pythonhosted.org/packages/4f/e8/b289173b4edae05c0dde07f69f8db476a0b511eac556dfe0d6bda3c43384/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:9f7fcd74d410a36883701fafa2482a6af2ff5ba96b9a620e9e0721e28ead5569", size = 159098, upload-time = "2025-10-14T04:40:47.081Z" }, + { url = "https://files.pythonhosted.org/packages/d8/df/fe699727754cae3f8478493c7f45f777b17c3ef0600e28abfec8619eb49c/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ebf3e58c7ec8a8bed6d66a75d7fb37b55e5015b03ceae72a8e7c74495551e224", size = 152991, upload-time = "2025-10-14T04:40:48.246Z" }, + { url = "https://files.pythonhosted.org/packages/1a/86/584869fe4ddb6ffa3bd9f491b87a01568797fb9bd8933f557dba9771beaf/charset_normalizer-3.4.4-cp311-cp311-win32.whl", hash = "sha256:eecbc200c7fd5ddb9a7f16c7decb07b566c29fa2161a16cf67b8d068bd21690a", size = 99456, upload-time = "2025-10-14T04:40:49.376Z" }, + { url = "https://files.pythonhosted.org/packages/65/f6/62fdd5feb60530f50f7e38b4f6a1d5203f4d16ff4f9f0952962c044e919a/charset_normalizer-3.4.4-cp311-cp311-win_amd64.whl", hash = "sha256:5ae497466c7901d54b639cf42d5b8c1b6a4fead55215500d2f486d34db48d016", size = 106978, upload-time = "2025-10-14T04:40:50.844Z" }, + { url = "https://files.pythonhosted.org/packages/7a/9d/0710916e6c82948b3be62d9d398cb4fcf4e97b56d6a6aeccd66c4b2f2bd5/charset_normalizer-3.4.4-cp311-cp311-win_arm64.whl", hash = "sha256:65e2befcd84bc6f37095f5961e68a6f077bf44946771354a28ad434c2cce0ae1", size = 99969, upload-time = "2025-10-14T04:40:52.272Z" }, + { url = "https://files.pythonhosted.org/packages/f3/85/1637cd4af66fa687396e757dec650f28025f2a2f5a5531a3208dc0ec43f2/charset_normalizer-3.4.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0a98e6759f854bd25a58a73fa88833fba3b7c491169f86ce1180c948ab3fd394", size = 208425, upload-time = "2025-10-14T04:40:53.353Z" }, + { url = "https://files.pythonhosted.org/packages/9d/6a/04130023fef2a0d9c62d0bae2649b69f7b7d8d24ea5536feef50551029df/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b5b290ccc2a263e8d185130284f8501e3e36c5e02750fc6b6bdeb2e9e96f1e25", size = 148162, upload-time = "2025-10-14T04:40:54.558Z" }, + { url = "https://files.pythonhosted.org/packages/78/29/62328d79aa60da22c9e0b9a66539feae06ca0f5a4171ac4f7dc285b83688/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74bb723680f9f7a6234dcf67aea57e708ec1fbdf5699fb91dfd6f511b0a320ef", size = 144558, upload-time = "2025-10-14T04:40:55.677Z" }, + { url = "https://files.pythonhosted.org/packages/86/bb/b32194a4bf15b88403537c2e120b817c61cd4ecffa9b6876e941c3ee38fe/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f1e34719c6ed0b92f418c7c780480b26b5d9c50349e9a9af7d76bf757530350d", size = 161497, upload-time = "2025-10-14T04:40:57.217Z" }, + { url = "https://files.pythonhosted.org/packages/19/89/a54c82b253d5b9b111dc74aca196ba5ccfcca8242d0fb64146d4d3183ff1/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2437418e20515acec67d86e12bf70056a33abdacb5cb1655042f6538d6b085a8", size = 159240, upload-time = "2025-10-14T04:40:58.358Z" }, + { url = "https://files.pythonhosted.org/packages/c0/10/d20b513afe03acc89ec33948320a5544d31f21b05368436d580dec4e234d/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:11d694519d7f29d6cd09f6ac70028dba10f92f6cdd059096db198c283794ac86", size = 153471, upload-time = "2025-10-14T04:40:59.468Z" }, + { url = "https://files.pythonhosted.org/packages/61/fa/fbf177b55bdd727010f9c0a3c49eefa1d10f960e5f09d1d887bf93c2e698/charset_normalizer-3.4.4-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ac1c4a689edcc530fc9d9aa11f5774b9e2f33f9a0c6a57864e90908f5208d30a", size = 150864, upload-time = "2025-10-14T04:41:00.623Z" }, + { url = "https://files.pythonhosted.org/packages/05/12/9fbc6a4d39c0198adeebbde20b619790e9236557ca59fc40e0e3cebe6f40/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:21d142cc6c0ec30d2efee5068ca36c128a30b0f2c53c1c07bd78cb6bc1d3be5f", size = 150647, upload-time = "2025-10-14T04:41:01.754Z" }, + { url = "https://files.pythonhosted.org/packages/ad/1f/6a9a593d52e3e8c5d2b167daf8c6b968808efb57ef4c210acb907c365bc4/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:5dbe56a36425d26d6cfb40ce79c314a2e4dd6211d51d6d2191c00bed34f354cc", size = 145110, upload-time = "2025-10-14T04:41:03.231Z" }, + { url = "https://files.pythonhosted.org/packages/30/42/9a52c609e72471b0fc54386dc63c3781a387bb4fe61c20231a4ebcd58bdd/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:5bfbb1b9acf3334612667b61bd3002196fe2a1eb4dd74d247e0f2a4d50ec9bbf", size = 162839, upload-time = "2025-10-14T04:41:04.715Z" }, + { url = "https://files.pythonhosted.org/packages/c4/5b/c0682bbf9f11597073052628ddd38344a3d673fda35a36773f7d19344b23/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:d055ec1e26e441f6187acf818b73564e6e6282709e9bcb5b63f5b23068356a15", size = 150667, upload-time = "2025-10-14T04:41:05.827Z" }, + { url = "https://files.pythonhosted.org/packages/e4/24/a41afeab6f990cf2daf6cb8c67419b63b48cf518e4f56022230840c9bfb2/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:af2d8c67d8e573d6de5bc30cdb27e9b95e49115cd9baad5ddbd1a6207aaa82a9", size = 160535, upload-time = "2025-10-14T04:41:06.938Z" }, + { url = "https://files.pythonhosted.org/packages/2a/e5/6a4ce77ed243c4a50a1fecca6aaaab419628c818a49434be428fe24c9957/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:780236ac706e66881f3b7f2f32dfe90507a09e67d1d454c762cf642e6e1586e0", size = 154816, upload-time = "2025-10-14T04:41:08.101Z" }, + { url = "https://files.pythonhosted.org/packages/a8/ef/89297262b8092b312d29cdb2517cb1237e51db8ecef2e9af5edbe7b683b1/charset_normalizer-3.4.4-cp312-cp312-win32.whl", hash = "sha256:5833d2c39d8896e4e19b689ffc198f08ea58116bee26dea51e362ecc7cd3ed26", size = 99694, upload-time = "2025-10-14T04:41:09.23Z" }, + { url = "https://files.pythonhosted.org/packages/3d/2d/1e5ed9dd3b3803994c155cd9aacb60c82c331bad84daf75bcb9c91b3295e/charset_normalizer-3.4.4-cp312-cp312-win_amd64.whl", hash = "sha256:a79cfe37875f822425b89a82333404539ae63dbdddf97f84dcbc3d339aae9525", size = 107131, upload-time = "2025-10-14T04:41:10.467Z" }, + { url = "https://files.pythonhosted.org/packages/d0/d9/0ed4c7098a861482a7b6a95603edce4c0d9db2311af23da1fb2b75ec26fc/charset_normalizer-3.4.4-cp312-cp312-win_arm64.whl", hash = "sha256:376bec83a63b8021bb5c8ea75e21c4ccb86e7e45ca4eb81146091b56599b80c3", size = 100390, upload-time = "2025-10-14T04:41:11.915Z" }, + { url = "https://files.pythonhosted.org/packages/97/45/4b3a1239bbacd321068ea6e7ac28875b03ab8bc0aa0966452db17cd36714/charset_normalizer-3.4.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e1f185f86a6f3403aa2420e815904c67b2f9ebc443f045edd0de921108345794", size = 208091, upload-time = "2025-10-14T04:41:13.346Z" }, + { url = "https://files.pythonhosted.org/packages/7d/62/73a6d7450829655a35bb88a88fca7d736f9882a27eacdca2c6d505b57e2e/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b39f987ae8ccdf0d2642338faf2abb1862340facc796048b604ef14919e55ed", size = 147936, upload-time = "2025-10-14T04:41:14.461Z" }, + { url = "https://files.pythonhosted.org/packages/89/c5/adb8c8b3d6625bef6d88b251bbb0d95f8205831b987631ab0c8bb5d937c2/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3162d5d8ce1bb98dd51af660f2121c55d0fa541b46dff7bb9b9f86ea1d87de72", size = 144180, upload-time = "2025-10-14T04:41:15.588Z" }, + { url = "https://files.pythonhosted.org/packages/91/ed/9706e4070682d1cc219050b6048bfd293ccf67b3d4f5a4f39207453d4b99/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:81d5eb2a312700f4ecaa977a8235b634ce853200e828fbadf3a9c50bab278328", size = 161346, upload-time = "2025-10-14T04:41:16.738Z" }, + { url = "https://files.pythonhosted.org/packages/d5/0d/031f0d95e4972901a2f6f09ef055751805ff541511dc1252ba3ca1f80cf5/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5bd2293095d766545ec1a8f612559f6b40abc0eb18bb2f5d1171872d34036ede", size = 158874, upload-time = "2025-10-14T04:41:17.923Z" }, + { url = "https://files.pythonhosted.org/packages/f5/83/6ab5883f57c9c801ce5e5677242328aa45592be8a00644310a008d04f922/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a8a8b89589086a25749f471e6a900d3f662d1d3b6e2e59dcecf787b1cc3a1894", size = 153076, upload-time = "2025-10-14T04:41:19.106Z" }, + { url = "https://files.pythonhosted.org/packages/75/1e/5ff781ddf5260e387d6419959ee89ef13878229732732ee73cdae01800f2/charset_normalizer-3.4.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc7637e2f80d8530ee4a78e878bce464f70087ce73cf7c1caf142416923b98f1", size = 150601, upload-time = "2025-10-14T04:41:20.245Z" }, + { url = "https://files.pythonhosted.org/packages/d7/57/71be810965493d3510a6ca79b90c19e48696fb1ff964da319334b12677f0/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f8bf04158c6b607d747e93949aa60618b61312fe647a6369f88ce2ff16043490", size = 150376, upload-time = "2025-10-14T04:41:21.398Z" }, + { url = "https://files.pythonhosted.org/packages/e5/d5/c3d057a78c181d007014feb7e9f2e65905a6c4ef182c0ddf0de2924edd65/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:554af85e960429cf30784dd47447d5125aaa3b99a6f0683589dbd27e2f45da44", size = 144825, upload-time = "2025-10-14T04:41:22.583Z" }, + { url = "https://files.pythonhosted.org/packages/e6/8c/d0406294828d4976f275ffbe66f00266c4b3136b7506941d87c00cab5272/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:74018750915ee7ad843a774364e13a3db91682f26142baddf775342c3f5b1133", size = 162583, upload-time = "2025-10-14T04:41:23.754Z" }, + { url = "https://files.pythonhosted.org/packages/d7/24/e2aa1f18c8f15c4c0e932d9287b8609dd30ad56dbe41d926bd846e22fb8d/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:c0463276121fdee9c49b98908b3a89c39be45d86d1dbaa22957e38f6321d4ce3", size = 150366, upload-time = "2025-10-14T04:41:25.27Z" }, + { url = "https://files.pythonhosted.org/packages/e4/5b/1e6160c7739aad1e2df054300cc618b06bf784a7a164b0f238360721ab86/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:362d61fd13843997c1c446760ef36f240cf81d3ebf74ac62652aebaf7838561e", size = 160300, upload-time = "2025-10-14T04:41:26.725Z" }, + { url = "https://files.pythonhosted.org/packages/7a/10/f882167cd207fbdd743e55534d5d9620e095089d176d55cb22d5322f2afd/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9a26f18905b8dd5d685d6d07b0cdf98a79f3c7a918906af7cc143ea2e164c8bc", size = 154465, upload-time = "2025-10-14T04:41:28.322Z" }, + { url = "https://files.pythonhosted.org/packages/89/66/c7a9e1b7429be72123441bfdbaf2bc13faab3f90b933f664db506dea5915/charset_normalizer-3.4.4-cp313-cp313-win32.whl", hash = "sha256:9b35f4c90079ff2e2edc5b26c0c77925e5d2d255c42c74fdb70fb49b172726ac", size = 99404, upload-time = "2025-10-14T04:41:29.95Z" }, + { url = "https://files.pythonhosted.org/packages/c4/26/b9924fa27db384bdcd97ab83b4f0a8058d96ad9626ead570674d5e737d90/charset_normalizer-3.4.4-cp313-cp313-win_amd64.whl", hash = "sha256:b435cba5f4f750aa6c0a0d92c541fb79f69a387c91e61f1795227e4ed9cece14", size = 107092, upload-time = "2025-10-14T04:41:31.188Z" }, + { url = "https://files.pythonhosted.org/packages/af/8f/3ed4bfa0c0c72a7ca17f0380cd9e4dd842b09f664e780c13cff1dcf2ef1b/charset_normalizer-3.4.4-cp313-cp313-win_arm64.whl", hash = "sha256:542d2cee80be6f80247095cc36c418f7bddd14f4a6de45af91dfad36d817bba2", size = 100408, upload-time = "2025-10-14T04:41:32.624Z" }, + { url = "https://files.pythonhosted.org/packages/2a/35/7051599bd493e62411d6ede36fd5af83a38f37c4767b92884df7301db25d/charset_normalizer-3.4.4-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:da3326d9e65ef63a817ecbcc0df6e94463713b754fe293eaa03da99befb9a5bd", size = 207746, upload-time = "2025-10-14T04:41:33.773Z" }, + { url = "https://files.pythonhosted.org/packages/10/9a/97c8d48ef10d6cd4fcead2415523221624bf58bcf68a802721a6bc807c8f/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8af65f14dc14a79b924524b1e7fffe304517b2bff5a58bf64f30b98bbc5079eb", size = 147889, upload-time = "2025-10-14T04:41:34.897Z" }, + { url = "https://files.pythonhosted.org/packages/10/bf/979224a919a1b606c82bd2c5fa49b5c6d5727aa47b4312bb27b1734f53cd/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74664978bb272435107de04e36db5a9735e78232b85b77d45cfb38f758efd33e", size = 143641, upload-time = "2025-10-14T04:41:36.116Z" }, + { url = "https://files.pythonhosted.org/packages/ba/33/0ad65587441fc730dc7bd90e9716b30b4702dc7b617e6ba4997dc8651495/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:752944c7ffbfdd10c074dc58ec2d5a8a4cd9493b314d367c14d24c17684ddd14", size = 160779, upload-time = "2025-10-14T04:41:37.229Z" }, + { url = "https://files.pythonhosted.org/packages/67/ed/331d6b249259ee71ddea93f6f2f0a56cfebd46938bde6fcc6f7b9a3d0e09/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d1f13550535ad8cff21b8d757a3257963e951d96e20ec82ab44bc64aeb62a191", size = 159035, upload-time = "2025-10-14T04:41:38.368Z" }, + { url = "https://files.pythonhosted.org/packages/67/ff/f6b948ca32e4f2a4576aa129d8bed61f2e0543bf9f5f2b7fc3758ed005c9/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ecaae4149d99b1c9e7b88bb03e3221956f68fd6d50be2ef061b2381b61d20838", size = 152542, upload-time = "2025-10-14T04:41:39.862Z" }, + { url = "https://files.pythonhosted.org/packages/16/85/276033dcbcc369eb176594de22728541a925b2632f9716428c851b149e83/charset_normalizer-3.4.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:cb6254dc36b47a990e59e1068afacdcd02958bdcce30bb50cc1700a8b9d624a6", size = 149524, upload-time = "2025-10-14T04:41:41.319Z" }, + { url = "https://files.pythonhosted.org/packages/9e/f2/6a2a1f722b6aba37050e626530a46a68f74e63683947a8acff92569f979a/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c8ae8a0f02f57a6e61203a31428fa1d677cbe50c93622b4149d5c0f319c1d19e", size = 150395, upload-time = "2025-10-14T04:41:42.539Z" }, + { url = "https://files.pythonhosted.org/packages/60/bb/2186cb2f2bbaea6338cad15ce23a67f9b0672929744381e28b0592676824/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:47cc91b2f4dd2833fddaedd2893006b0106129d4b94fdb6af1f4ce5a9965577c", size = 143680, upload-time = "2025-10-14T04:41:43.661Z" }, + { url = "https://files.pythonhosted.org/packages/7d/a5/bf6f13b772fbb2a90360eb620d52ed8f796f3c5caee8398c3b2eb7b1c60d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:82004af6c302b5d3ab2cfc4cc5f29db16123b1a8417f2e25f9066f91d4411090", size = 162045, upload-time = "2025-10-14T04:41:44.821Z" }, + { url = "https://files.pythonhosted.org/packages/df/c5/d1be898bf0dc3ef9030c3825e5d3b83f2c528d207d246cbabe245966808d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:2b7d8f6c26245217bd2ad053761201e9f9680f8ce52f0fcd8d0755aeae5b2152", size = 149687, upload-time = "2025-10-14T04:41:46.442Z" }, + { url = "https://files.pythonhosted.org/packages/a5/42/90c1f7b9341eef50c8a1cb3f098ac43b0508413f33affd762855f67a410e/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:799a7a5e4fb2d5898c60b640fd4981d6a25f1c11790935a44ce38c54e985f828", size = 160014, upload-time = "2025-10-14T04:41:47.631Z" }, + { url = "https://files.pythonhosted.org/packages/76/be/4d3ee471e8145d12795ab655ece37baed0929462a86e72372fd25859047c/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:99ae2cffebb06e6c22bdc25801d7b30f503cc87dbd283479e7b606f70aff57ec", size = 154044, upload-time = "2025-10-14T04:41:48.81Z" }, + { url = "https://files.pythonhosted.org/packages/b0/6f/8f7af07237c34a1defe7defc565a9bc1807762f672c0fde711a4b22bf9c0/charset_normalizer-3.4.4-cp314-cp314-win32.whl", hash = "sha256:f9d332f8c2a2fcbffe1378594431458ddbef721c1769d78e2cbc06280d8155f9", size = 99940, upload-time = "2025-10-14T04:41:49.946Z" }, + { url = "https://files.pythonhosted.org/packages/4b/51/8ade005e5ca5b0d80fb4aff72a3775b325bdc3d27408c8113811a7cbe640/charset_normalizer-3.4.4-cp314-cp314-win_amd64.whl", hash = "sha256:8a6562c3700cce886c5be75ade4a5db4214fda19fede41d9792d100288d8f94c", size = 107104, upload-time = "2025-10-14T04:41:51.051Z" }, + { url = "https://files.pythonhosted.org/packages/da/5f/6b8f83a55bb8278772c5ae54a577f3099025f9ade59d0136ac24a0df4bde/charset_normalizer-3.4.4-cp314-cp314-win_arm64.whl", hash = "sha256:de00632ca48df9daf77a2c65a484531649261ec9f25489917f09e455cb09ddb2", size = 100743, upload-time = "2025-10-14T04:41:52.122Z" }, + { url = "https://files.pythonhosted.org/packages/0a/4c/925909008ed5a988ccbb72dcc897407e5d6d3bd72410d69e051fc0c14647/charset_normalizer-3.4.4-py3-none-any.whl", hash = "sha256:7a32c560861a02ff789ad905a2fe94e3f840803362c84fecf1851cb4cf3dc37f", size = 53402, upload-time = "2025-10-14T04:42:31.76Z" }, +] + +[[package]] +name = "click" +version = "8.2.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/60/6c/8ca2efa64cf75a977a0d7fac081354553ebe483345c734fb6b6515d96bbc/click-8.2.1.tar.gz", hash = "sha256:27c491cc05d968d271d5a1db13e3b5a184636d9d930f148c50b038f0d0646202", size = 286342, upload-time = "2025-05-20T23:19:49.832Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/85/32/10bb5764d90a8eee674e9dc6f4db6a0ab47c8c4d0d83c27f7c39ac415a4d/click-8.2.1-py3-none-any.whl", hash = "sha256:61a3265b914e850b85317d0b3109c7f8cd35a670f963866005d6ef1d5175a12b", size = 102215, upload-time = "2025-05-20T23:19:47.796Z" }, +] + +[[package]] +name = "cloudpickle" +version = "3.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c8/72/42a6570fc61b1f8913529728ad314c7cf5961540728dcad22c33fb2db6b6/cloudpickle-3.0.0.tar.gz", hash = "sha256:996d9a482c6fb4f33c1a35335cf8afd065d2a56e973270364840712d9131a882", size = 21231, upload-time = "2023-10-16T12:51:26.352Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/96/43/dae06432d0c4b1dc9e9149ad37b4ca8384cf6eb7700cd9215b177b914f0a/cloudpickle-3.0.0-py3-none-any.whl", hash = "sha256:246ee7d0c295602a036e86369c77fecda4ab17b506496730f2f576d9016fd9c7", size = 20088, upload-time = "2023-10-16T12:51:24.415Z" }, +] + +[[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 = "contextlib2" +version = "21.6.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c7/13/37ea7805ae3057992e96ecb1cffa2fa35c2ef4498543b846f90dd2348d8f/contextlib2-21.6.0.tar.gz", hash = "sha256:ab1e2bfe1d01d968e1b7e8d9023bc51ef3509bba217bb730cee3827e1ee82869", size = 43795, upload-time = "2021-06-27T06:54:40.841Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/76/56/6d6872f79d14c0cb02f1646cbb4592eef935857c0951a105874b7b62a0c3/contextlib2-21.6.0-py2.py3-none-any.whl", hash = "sha256:3fbdb64466afd23abaf6c977627b75b6139a5a3e8ce38405c5b413aed7a0471f", size = 13277, upload-time = "2021-06-27T06:54:20.972Z" }, +] + +[[package]] +name = "coverage" +version = "7.13.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b6/45/2c665ca77ec32ad67e25c77daf1cee28ee4558f3bc571cdbaf88a00b9f23/coverage-7.13.0.tar.gz", hash = "sha256:a394aa27f2d7ff9bc04cf703817773a59ad6dfbd577032e690f961d2460ee936", size = 820905, upload-time = "2025-12-08T13:14:38.055Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/db/08/bdd7ccca14096f7eb01412b87ac11e5d16e4cb54b6e328afc9dee8bdaec1/coverage-7.13.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:02d9fb9eccd48f6843c98a37bd6817462f130b86da8660461e8f5e54d4c06070", size = 217979, upload-time = "2025-12-08T13:12:14.505Z" }, + { url = "https://files.pythonhosted.org/packages/fa/f0/d1302e3416298a28b5663ae1117546a745d9d19fde7e28402b2c5c3e2109/coverage-7.13.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:367449cf07d33dc216c083f2036bb7d976c6e4903ab31be400ad74ad9f85ce98", size = 218496, upload-time = "2025-12-08T13:12:16.237Z" }, + { url = "https://files.pythonhosted.org/packages/07/26/d36c354c8b2a320819afcea6bffe72839efd004b98d1d166b90801d49d57/coverage-7.13.0-cp310-cp310-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:cdb3c9f8fef0a954c632f64328a3935988d33a6604ce4bf67ec3e39670f12ae5", size = 245237, upload-time = "2025-12-08T13:12:17.858Z" }, + { url = "https://files.pythonhosted.org/packages/91/52/be5e85631e0eec547873d8b08dd67a5f6b111ecfe89a86e40b89b0c1c61c/coverage-7.13.0-cp310-cp310-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:d10fd186aac2316f9bbb46ef91977f9d394ded67050ad6d84d94ed6ea2e8e54e", size = 247061, upload-time = "2025-12-08T13:12:19.132Z" }, + { url = "https://files.pythonhosted.org/packages/0f/45/a5e8fa0caf05fbd8fa0402470377bff09cc1f026d21c05c71e01295e55ab/coverage-7.13.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7f88ae3e69df2ab62fb0bc5219a597cb890ba5c438190ffa87490b315190bb33", size = 248928, upload-time = "2025-12-08T13:12:20.702Z" }, + { url = "https://files.pythonhosted.org/packages/f5/42/ffb5069b6fd1b95fae482e02f3fecf380d437dd5a39bae09f16d2e2e7e01/coverage-7.13.0-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c4be718e51e86f553bcf515305a158a1cd180d23b72f07ae76d6017c3cc5d791", size = 245931, upload-time = "2025-12-08T13:12:22.243Z" }, + { url = "https://files.pythonhosted.org/packages/95/6e/73e809b882c2858f13e55c0c36e94e09ce07e6165d5644588f9517efe333/coverage-7.13.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:a00d3a393207ae12f7c49bb1c113190883b500f48979abb118d8b72b8c95c032", size = 246968, upload-time = "2025-12-08T13:12:23.52Z" }, + { url = "https://files.pythonhosted.org/packages/87/08/64ebd9e64b6adb8b4a4662133d706fbaccecab972e0b3ccc23f64e2678ad/coverage-7.13.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:3a7b1cd820e1b6116f92c6128f1188e7afe421c7e1b35fa9836b11444e53ebd9", size = 244972, upload-time = "2025-12-08T13:12:24.781Z" }, + { url = "https://files.pythonhosted.org/packages/12/97/f4d27c6fe0cb375a5eced4aabcaef22de74766fb80a3d5d2015139e54b22/coverage-7.13.0-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:37eee4e552a65866f15dedd917d5e5f3d59805994260720821e2c1b51ac3248f", size = 245241, upload-time = "2025-12-08T13:12:28.041Z" }, + { url = "https://files.pythonhosted.org/packages/0c/94/42f8ae7f633bf4c118bf1038d80472f9dade88961a466f290b81250f7ab7/coverage-7.13.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:62d7c4f13102148c78d7353c6052af6d899a7f6df66a32bddcc0c0eb7c5326f8", size = 245847, upload-time = "2025-12-08T13:12:29.337Z" }, + { url = "https://files.pythonhosted.org/packages/a8/2f/6369ca22b6b6d933f4f4d27765d313d8914cc4cce84f82a16436b1a233db/coverage-7.13.0-cp310-cp310-win32.whl", hash = "sha256:24e4e56304fdb56f96f80eabf840eab043b3afea9348b88be680ec5986780a0f", size = 220573, upload-time = "2025-12-08T13:12:30.905Z" }, + { url = "https://files.pythonhosted.org/packages/f1/dc/a6a741e519acceaeccc70a7f4cfe5d030efc4b222595f0677e101af6f1f3/coverage-7.13.0-cp310-cp310-win_amd64.whl", hash = "sha256:74c136e4093627cf04b26a35dab8cbfc9b37c647f0502fc313376e11726ba303", size = 221509, upload-time = "2025-12-08T13:12:32.09Z" }, + { url = "https://files.pythonhosted.org/packages/f1/dc/888bf90d8b1c3d0b4020a40e52b9f80957d75785931ec66c7dfaccc11c7d/coverage-7.13.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:0dfa3855031070058add1a59fdfda0192fd3e8f97e7c81de0596c145dea51820", size = 218104, upload-time = "2025-12-08T13:12:33.333Z" }, + { url = "https://files.pythonhosted.org/packages/8d/ea/069d51372ad9c380214e86717e40d1a743713a2af191cfba30a0911b0a4a/coverage-7.13.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4fdb6f54f38e334db97f72fa0c701e66d8479af0bc3f9bfb5b90f1c30f54500f", size = 218606, upload-time = "2025-12-08T13:12:34.498Z" }, + { url = "https://files.pythonhosted.org/packages/68/09/77b1c3a66c2aa91141b6c4471af98e5b1ed9b9e6d17255da5eb7992299e3/coverage-7.13.0-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:7e442c013447d1d8d195be62852270b78b6e255b79b8675bad8479641e21fd96", size = 248999, upload-time = "2025-12-08T13:12:36.02Z" }, + { url = "https://files.pythonhosted.org/packages/0a/32/2e2f96e9d5691eaf1181d9040f850b8b7ce165ea10810fd8e2afa534cef7/coverage-7.13.0-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:1ed5630d946859de835a85e9a43b721123a8a44ec26e2830b296d478c7fd4259", size = 250925, upload-time = "2025-12-08T13:12:37.221Z" }, + { url = "https://files.pythonhosted.org/packages/7b/45/b88ddac1d7978859b9a39a8a50ab323186148f1d64bc068f86fc77706321/coverage-7.13.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7f15a931a668e58087bc39d05d2b4bf4b14ff2875b49c994bbdb1c2217a8daeb", size = 253032, upload-time = "2025-12-08T13:12:38.763Z" }, + { url = "https://files.pythonhosted.org/packages/71/cb/e15513f94c69d4820a34b6bf3d2b1f9f8755fa6021be97c7065442d7d653/coverage-7.13.0-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:30a3a201a127ea57f7e14ba43c93c9c4be8b7d17a26e03bb49e6966d019eede9", size = 249134, upload-time = "2025-12-08T13:12:40.382Z" }, + { url = "https://files.pythonhosted.org/packages/09/61/d960ff7dc9e902af3310ce632a875aaa7860f36d2bc8fc8b37ee7c1b82a5/coverage-7.13.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7a485ff48fbd231efa32d58f479befce52dcb6bfb2a88bb7bf9a0b89b1bc8030", size = 250731, upload-time = "2025-12-08T13:12:41.992Z" }, + { url = "https://files.pythonhosted.org/packages/98/34/c7c72821794afc7c7c2da1db8f00c2c98353078aa7fb6b5ff36aac834b52/coverage-7.13.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:22486cdafba4f9e471c816a2a5745337742a617fef68e890d8baf9f3036d7833", size = 248795, upload-time = "2025-12-08T13:12:43.331Z" }, + { url = "https://files.pythonhosted.org/packages/0a/5b/e0f07107987a43b2def9aa041c614ddb38064cbf294a71ef8c67d43a0cdd/coverage-7.13.0-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:263c3dbccc78e2e331e59e90115941b5f53e85cfcc6b3b2fbff1fd4e3d2c6ea8", size = 248514, upload-time = "2025-12-08T13:12:44.546Z" }, + { url = "https://files.pythonhosted.org/packages/71/c2/c949c5d3b5e9fc6dd79e1b73cdb86a59ef14f3709b1d72bf7668ae12e000/coverage-7.13.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:e5330fa0cc1f5c3c4c3bb8e101b742025933e7848989370a1d4c8c5e401ea753", size = 249424, upload-time = "2025-12-08T13:12:45.759Z" }, + { url = "https://files.pythonhosted.org/packages/11/f1/bbc009abd6537cec0dffb2cc08c17a7f03de74c970e6302db4342a6e05af/coverage-7.13.0-cp311-cp311-win32.whl", hash = "sha256:0f4872f5d6c54419c94c25dd6ae1d015deeb337d06e448cd890a1e89a8ee7f3b", size = 220597, upload-time = "2025-12-08T13:12:47.378Z" }, + { url = "https://files.pythonhosted.org/packages/c4/f6/d9977f2fb51c10fbaed0718ce3d0a8541185290b981f73b1d27276c12d91/coverage-7.13.0-cp311-cp311-win_amd64.whl", hash = "sha256:51a202e0f80f241ccb68e3e26e19ab5b3bf0f813314f2c967642f13ebcf1ddfe", size = 221536, upload-time = "2025-12-08T13:12:48.7Z" }, + { url = "https://files.pythonhosted.org/packages/be/ad/3fcf43fd96fb43e337a3073dea63ff148dcc5c41ba7a14d4c7d34efb2216/coverage-7.13.0-cp311-cp311-win_arm64.whl", hash = "sha256:d2a9d7f1c11487b1c69367ab3ac2d81b9b3721f097aa409a3191c3e90f8f3dd7", size = 220206, upload-time = "2025-12-08T13:12:50.365Z" }, + { url = "https://files.pythonhosted.org/packages/9b/f1/2619559f17f31ba00fc40908efd1fbf1d0a5536eb75dc8341e7d660a08de/coverage-7.13.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:0b3d67d31383c4c68e19a88e28fc4c2e29517580f1b0ebec4a069d502ce1e0bf", size = 218274, upload-time = "2025-12-08T13:12:52.095Z" }, + { url = "https://files.pythonhosted.org/packages/2b/11/30d71ae5d6e949ff93b2a79a2c1b4822e00423116c5c6edfaeef37301396/coverage-7.13.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:581f086833d24a22c89ae0fe2142cfaa1c92c930adf637ddf122d55083fb5a0f", size = 218638, upload-time = "2025-12-08T13:12:53.418Z" }, + { url = "https://files.pythonhosted.org/packages/79/c2/fce80fc6ded8d77e53207489d6065d0fed75db8951457f9213776615e0f5/coverage-7.13.0-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:0a3a30f0e257df382f5f9534d4ce3d4cf06eafaf5192beb1a7bd066cb10e78fb", size = 250129, upload-time = "2025-12-08T13:12:54.744Z" }, + { url = "https://files.pythonhosted.org/packages/5b/b6/51b5d1eb6fcbb9a1d5d6984e26cbe09018475c2922d554fd724dd0f056ee/coverage-7.13.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:583221913fbc8f53b88c42e8dbb8fca1d0f2e597cb190ce45916662b8b9d9621", size = 252885, upload-time = "2025-12-08T13:12:56.401Z" }, + { url = "https://files.pythonhosted.org/packages/0d/f8/972a5affea41de798691ab15d023d3530f9f56a72e12e243f35031846ff7/coverage-7.13.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5f5d9bd30756fff3e7216491a0d6d520c448d5124d3d8e8f56446d6412499e74", size = 253974, upload-time = "2025-12-08T13:12:57.718Z" }, + { url = "https://files.pythonhosted.org/packages/8a/56/116513aee860b2c7968aa3506b0f59b22a959261d1dbf3aea7b4450a7520/coverage-7.13.0-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a23e5a1f8b982d56fa64f8e442e037f6ce29322f1f9e6c2344cd9e9f4407ee57", size = 250538, upload-time = "2025-12-08T13:12:59.254Z" }, + { url = "https://files.pythonhosted.org/packages/d6/75/074476d64248fbadf16dfafbf93fdcede389ec821f74ca858d7c87d2a98c/coverage-7.13.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:9b01c22bc74a7fb44066aaf765224c0d933ddf1f5047d6cdfe4795504a4493f8", size = 251912, upload-time = "2025-12-08T13:13:00.604Z" }, + { url = "https://files.pythonhosted.org/packages/f2/d2/aa4f8acd1f7c06024705c12609d8698c51b27e4d635d717cd1934c9668e2/coverage-7.13.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:898cce66d0836973f48dda4e3514d863d70142bdf6dfab932b9b6a90ea5b222d", size = 250054, upload-time = "2025-12-08T13:13:01.892Z" }, + { url = "https://files.pythonhosted.org/packages/19/98/8df9e1af6a493b03694a1e8070e024e7d2cdc77adedc225a35e616d505de/coverage-7.13.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:3ab483ea0e251b5790c2aac03acde31bff0c736bf8a86829b89382b407cd1c3b", size = 249619, upload-time = "2025-12-08T13:13:03.236Z" }, + { url = "https://files.pythonhosted.org/packages/d8/71/f8679231f3353018ca66ef647fa6fe7b77e6bff7845be54ab84f86233363/coverage-7.13.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1d84e91521c5e4cb6602fe11ece3e1de03b2760e14ae4fcf1a4b56fa3c801fcd", size = 251496, upload-time = "2025-12-08T13:13:04.511Z" }, + { url = "https://files.pythonhosted.org/packages/04/86/9cb406388034eaf3c606c22094edbbb82eea1fa9d20c0e9efadff20d0733/coverage-7.13.0-cp312-cp312-win32.whl", hash = "sha256:193c3887285eec1dbdb3f2bd7fbc351d570ca9c02ca756c3afbc71b3c98af6ef", size = 220808, upload-time = "2025-12-08T13:13:06.422Z" }, + { url = "https://files.pythonhosted.org/packages/1c/59/af483673df6455795daf5f447c2f81a3d2fcfc893a22b8ace983791f6f34/coverage-7.13.0-cp312-cp312-win_amd64.whl", hash = "sha256:4f3e223b2b2db5e0db0c2b97286aba0036ca000f06aca9b12112eaa9af3d92ae", size = 221616, upload-time = "2025-12-08T13:13:07.95Z" }, + { url = "https://files.pythonhosted.org/packages/64/b0/959d582572b30a6830398c60dd419c1965ca4b5fb38ac6b7093a0d50ca8d/coverage-7.13.0-cp312-cp312-win_arm64.whl", hash = "sha256:086cede306d96202e15a4b77ace8472e39d9f4e5f9fd92dd4fecdfb2313b2080", size = 220261, upload-time = "2025-12-08T13:13:09.581Z" }, + { url = "https://files.pythonhosted.org/packages/7c/cc/bce226595eb3bf7d13ccffe154c3c487a22222d87ff018525ab4dd2e9542/coverage-7.13.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:28ee1c96109974af104028a8ef57cec21447d42d0e937c0275329272e370ebcf", size = 218297, upload-time = "2025-12-08T13:13:10.977Z" }, + { url = "https://files.pythonhosted.org/packages/3b/9f/73c4d34600aae03447dff3d7ad1d0ac649856bfb87d1ca7d681cfc913f9e/coverage-7.13.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d1e97353dcc5587b85986cda4ff3ec98081d7e84dd95e8b2a6d59820f0545f8a", size = 218673, upload-time = "2025-12-08T13:13:12.562Z" }, + { url = "https://files.pythonhosted.org/packages/63/ab/8fa097db361a1e8586535ae5073559e6229596b3489ec3ef2f5b38df8cb2/coverage-7.13.0-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:99acd4dfdfeb58e1937629eb1ab6ab0899b131f183ee5f23e0b5da5cba2fec74", size = 249652, upload-time = "2025-12-08T13:13:13.909Z" }, + { url = "https://files.pythonhosted.org/packages/90/3a/9bfd4de2ff191feb37ef9465855ca56a6f2f30a3bca172e474130731ac3d/coverage-7.13.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:ff45e0cd8451e293b63ced93161e189780baf444119391b3e7d25315060368a6", size = 252251, upload-time = "2025-12-08T13:13:15.553Z" }, + { url = "https://files.pythonhosted.org/packages/df/61/b5d8105f016e1b5874af0d7c67542da780ccd4a5f2244a433d3e20ceb1ad/coverage-7.13.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f4f72a85316d8e13234cafe0a9f81b40418ad7a082792fa4165bd7d45d96066b", size = 253492, upload-time = "2025-12-08T13:13:16.849Z" }, + { url = "https://files.pythonhosted.org/packages/f3/b8/0fad449981803cc47a4694768b99823fb23632150743f9c83af329bb6090/coverage-7.13.0-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:11c21557d0e0a5a38632cbbaca5f008723b26a89d70db6315523df6df77d6232", size = 249850, upload-time = "2025-12-08T13:13:18.142Z" }, + { url = "https://files.pythonhosted.org/packages/9a/e9/8d68337c3125014d918cf4327d5257553a710a2995a6a6de2ac77e5aa429/coverage-7.13.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:76541dc8d53715fb4f7a3a06b34b0dc6846e3c69bc6204c55653a85dd6220971", size = 251633, upload-time = "2025-12-08T13:13:19.56Z" }, + { url = "https://files.pythonhosted.org/packages/55/14/d4112ab26b3a1bc4b3c1295d8452dcf399ed25be4cf649002fb3e64b2d93/coverage-7.13.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:6e9e451dee940a86789134b6b0ffbe31c454ade3b849bb8a9d2cca2541a8e91d", size = 249586, upload-time = "2025-12-08T13:13:20.883Z" }, + { url = "https://files.pythonhosted.org/packages/2c/a9/22b0000186db663b0d82f86c2f1028099ae9ac202491685051e2a11a5218/coverage-7.13.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:5c67dace46f361125e6b9cace8fe0b729ed8479f47e70c89b838d319375c8137", size = 249412, upload-time = "2025-12-08T13:13:22.22Z" }, + { url = "https://files.pythonhosted.org/packages/a1/2e/42d8e0d9e7527fba439acdc6ed24a2b97613b1dc85849b1dd935c2cffef0/coverage-7.13.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:f59883c643cb19630500f57016f76cfdcd6845ca8c5b5ea1f6e17f74c8e5f511", size = 251191, upload-time = "2025-12-08T13:13:23.899Z" }, + { url = "https://files.pythonhosted.org/packages/a4/af/8c7af92b1377fd8860536aadd58745119252aaaa71a5213e5a8e8007a9f5/coverage-7.13.0-cp313-cp313-win32.whl", hash = "sha256:58632b187be6f0be500f553be41e277712baa278147ecb7559983c6d9faf7ae1", size = 220829, upload-time = "2025-12-08T13:13:25.182Z" }, + { url = "https://files.pythonhosted.org/packages/58/f9/725e8bf16f343d33cbe076c75dc8370262e194ff10072c0608b8e5cf33a3/coverage-7.13.0-cp313-cp313-win_amd64.whl", hash = "sha256:73419b89f812f498aca53f757dd834919b48ce4799f9d5cad33ca0ae442bdb1a", size = 221640, upload-time = "2025-12-08T13:13:26.836Z" }, + { url = "https://files.pythonhosted.org/packages/8a/ff/e98311000aa6933cc79274e2b6b94a2fe0fe3434fca778eba82003675496/coverage-7.13.0-cp313-cp313-win_arm64.whl", hash = "sha256:eb76670874fdd6091eedcc856128ee48c41a9bbbb9c3f1c7c3cf169290e3ffd6", size = 220269, upload-time = "2025-12-08T13:13:28.116Z" }, + { url = "https://files.pythonhosted.org/packages/cf/cf/bbaa2e1275b300343ea865f7d424cc0a2e2a1df6925a070b2b2d5d765330/coverage-7.13.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:6e63ccc6e0ad8986386461c3c4b737540f20426e7ec932f42e030320896c311a", size = 218990, upload-time = "2025-12-08T13:13:29.463Z" }, + { url = "https://files.pythonhosted.org/packages/21/1d/82f0b3323b3d149d7672e7744c116e9c170f4957e0c42572f0366dbb4477/coverage-7.13.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:494f5459ffa1bd45e18558cd98710c36c0b8fbfa82a5eabcbe671d80ecffbfe8", size = 219340, upload-time = "2025-12-08T13:13:31.524Z" }, + { url = "https://files.pythonhosted.org/packages/fb/e3/fe3fd4702a3832a255f4d43013eacb0ef5fc155a5960ea9269d8696db28b/coverage-7.13.0-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:06cac81bf10f74034e055e903f5f946e3e26fc51c09fc9f584e4a1605d977053", size = 260638, upload-time = "2025-12-08T13:13:32.965Z" }, + { url = "https://files.pythonhosted.org/packages/ad/01/63186cb000307f2b4da463f72af9b85d380236965574c78e7e27680a2593/coverage-7.13.0-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:f2ffc92b46ed6e6760f1d47a71e56b5664781bc68986dbd1836b2b70c0ce2071", size = 262705, upload-time = "2025-12-08T13:13:34.378Z" }, + { url = "https://files.pythonhosted.org/packages/7c/a1/c0dacef0cc865f2455d59eed3548573ce47ed603205ffd0735d1d78b5906/coverage-7.13.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0602f701057c6823e5db1b74530ce85f17c3c5be5c85fc042ac939cbd909426e", size = 265125, upload-time = "2025-12-08T13:13:35.73Z" }, + { url = "https://files.pythonhosted.org/packages/ef/92/82b99223628b61300bd382c205795533bed021505eab6dd86e11fb5d7925/coverage-7.13.0-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:25dc33618d45456ccb1d37bce44bc78cf269909aa14c4db2e03d63146a8a1493", size = 259844, upload-time = "2025-12-08T13:13:37.69Z" }, + { url = "https://files.pythonhosted.org/packages/cf/2c/89b0291ae4e6cd59ef042708e1c438e2290f8c31959a20055d8768349ee2/coverage-7.13.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:71936a8b3b977ddd0b694c28c6a34f4fff2e9dd201969a4ff5d5fc7742d614b0", size = 262700, upload-time = "2025-12-08T13:13:39.525Z" }, + { url = "https://files.pythonhosted.org/packages/bf/f9/a5f992efae1996245e796bae34ceb942b05db275e4b34222a9a40b9fbd3b/coverage-7.13.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:936bc20503ce24770c71938d1369461f0c5320830800933bc3956e2a4ded930e", size = 260321, upload-time = "2025-12-08T13:13:41.172Z" }, + { url = "https://files.pythonhosted.org/packages/4c/89/a29f5d98c64fedbe32e2ac3c227fbf78edc01cc7572eee17d61024d89889/coverage-7.13.0-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:af0a583efaacc52ae2521f8d7910aff65cdb093091d76291ac5820d5e947fc1c", size = 259222, upload-time = "2025-12-08T13:13:43.282Z" }, + { url = "https://files.pythonhosted.org/packages/b3/c3/940fe447aae302a6701ee51e53af7e08b86ff6eed7631e5740c157ee22b9/coverage-7.13.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:f1c23e24a7000da892a312fb17e33c5f94f8b001de44b7cf8ba2e36fbd15859e", size = 261411, upload-time = "2025-12-08T13:13:44.72Z" }, + { url = "https://files.pythonhosted.org/packages/eb/31/12a4aec689cb942a89129587860ed4d0fd522d5fda81237147fde554b8ae/coverage-7.13.0-cp313-cp313t-win32.whl", hash = "sha256:5f8a0297355e652001015e93be345ee54393e45dc3050af4a0475c5a2b767d46", size = 221505, upload-time = "2025-12-08T13:13:46.332Z" }, + { url = "https://files.pythonhosted.org/packages/65/8c/3b5fe3259d863572d2b0827642c50c3855d26b3aefe80bdc9eba1f0af3b0/coverage-7.13.0-cp313-cp313t-win_amd64.whl", hash = "sha256:6abb3a4c52f05e08460bd9acf04fec027f8718ecaa0d09c40ffbc3fbd70ecc39", size = 222569, upload-time = "2025-12-08T13:13:47.79Z" }, + { url = "https://files.pythonhosted.org/packages/b0/39/f71fa8316a96ac72fc3908839df651e8eccee650001a17f2c78cdb355624/coverage-7.13.0-cp313-cp313t-win_arm64.whl", hash = "sha256:3ad968d1e3aa6ce5be295ab5fe3ae1bf5bb4769d0f98a80a0252d543a2ef2e9e", size = 220841, upload-time = "2025-12-08T13:13:49.243Z" }, + { url = "https://files.pythonhosted.org/packages/f8/4b/9b54bedda55421449811dcd5263a2798a63f48896c24dfb92b0f1b0845bd/coverage-7.13.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:453b7ec753cf5e4356e14fe858064e5520c460d3bbbcb9c35e55c0d21155c256", size = 218343, upload-time = "2025-12-08T13:13:50.811Z" }, + { url = "https://files.pythonhosted.org/packages/59/df/c3a1f34d4bba2e592c8979f924da4d3d4598b0df2392fbddb7761258e3dc/coverage-7.13.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:af827b7cbb303e1befa6c4f94fd2bf72f108089cfa0f8abab8f4ca553cf5ca5a", size = 218672, upload-time = "2025-12-08T13:13:52.284Z" }, + { url = "https://files.pythonhosted.org/packages/07/62/eec0659e47857698645ff4e6ad02e30186eb8afd65214fd43f02a76537cb/coverage-7.13.0-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:9987a9e4f8197a1000280f7cc089e3ea2c8b3c0a64d750537809879a7b4ceaf9", size = 249715, upload-time = "2025-12-08T13:13:53.791Z" }, + { url = "https://files.pythonhosted.org/packages/23/2d/3c7ff8b2e0e634c1f58d095f071f52ed3c23ff25be524b0ccae8b71f99f8/coverage-7.13.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:3188936845cd0cb114fa6a51842a304cdbac2958145d03be2377ec41eb285d19", size = 252225, upload-time = "2025-12-08T13:13:55.274Z" }, + { url = "https://files.pythonhosted.org/packages/aa/ac/fb03b469d20e9c9a81093575003f959cf91a4a517b783aab090e4538764b/coverage-7.13.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a2bdb3babb74079f021696cb46b8bb5f5661165c385d3a238712b031a12355be", size = 253559, upload-time = "2025-12-08T13:13:57.161Z" }, + { url = "https://files.pythonhosted.org/packages/29/62/14afa9e792383c66cc0a3b872a06ded6e4ed1079c7d35de274f11d27064e/coverage-7.13.0-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:7464663eaca6adba4175f6c19354feea61ebbdd735563a03d1e472c7072d27bb", size = 249724, upload-time = "2025-12-08T13:13:58.692Z" }, + { url = "https://files.pythonhosted.org/packages/31/b7/333f3dab2939070613696ab3ee91738950f0467778c6e5a5052e840646b7/coverage-7.13.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:8069e831f205d2ff1f3d355e82f511eb7c5522d7d413f5db5756b772ec8697f8", size = 251582, upload-time = "2025-12-08T13:14:00.642Z" }, + { url = "https://files.pythonhosted.org/packages/81/cb/69162bda9381f39b2287265d7e29ee770f7c27c19f470164350a38318764/coverage-7.13.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:6fb2d5d272341565f08e962cce14cdf843a08ac43bd621783527adb06b089c4b", size = 249538, upload-time = "2025-12-08T13:14:02.556Z" }, + { url = "https://files.pythonhosted.org/packages/e0/76/350387b56a30f4970abe32b90b2a434f87d29f8b7d4ae40d2e8a85aacfb3/coverage-7.13.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:5e70f92ef89bac1ac8a99b3324923b4749f008fdbd7aa9cb35e01d7a284a04f9", size = 249349, upload-time = "2025-12-08T13:14:04.015Z" }, + { url = "https://files.pythonhosted.org/packages/86/0d/7f6c42b8d59f4c7e43ea3059f573c0dcfed98ba46eb43c68c69e52ae095c/coverage-7.13.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:4b5de7d4583e60d5fd246dd57fcd3a8aa23c6e118a8c72b38adf666ba8e7e927", size = 251011, upload-time = "2025-12-08T13:14:05.505Z" }, + { url = "https://files.pythonhosted.org/packages/d7/f1/4bb2dff379721bb0b5c649d5c5eaf438462cad824acf32eb1b7ca0c7078e/coverage-7.13.0-cp314-cp314-win32.whl", hash = "sha256:a6c6e16b663be828a8f0b6c5027d36471d4a9f90d28444aa4ced4d48d7d6ae8f", size = 221091, upload-time = "2025-12-08T13:14:07.127Z" }, + { url = "https://files.pythonhosted.org/packages/ba/44/c239da52f373ce379c194b0ee3bcc121020e397242b85f99e0afc8615066/coverage-7.13.0-cp314-cp314-win_amd64.whl", hash = "sha256:0900872f2fdb3ee5646b557918d02279dc3af3dfb39029ac4e945458b13f73bc", size = 221904, upload-time = "2025-12-08T13:14:08.542Z" }, + { url = "https://files.pythonhosted.org/packages/89/1f/b9f04016d2a29c2e4a0307baefefad1a4ec5724946a2b3e482690486cade/coverage-7.13.0-cp314-cp314-win_arm64.whl", hash = "sha256:3a10260e6a152e5f03f26db4a407c4c62d3830b9af9b7c0450b183615f05d43b", size = 220480, upload-time = "2025-12-08T13:14:10.958Z" }, + { url = "https://files.pythonhosted.org/packages/16/d4/364a1439766c8e8647860584171c36010ca3226e6e45b1753b1b249c5161/coverage-7.13.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:9097818b6cc1cfb5f174e3263eba4a62a17683bcfe5c4b5d07f4c97fa51fbf28", size = 219074, upload-time = "2025-12-08T13:14:13.345Z" }, + { url = "https://files.pythonhosted.org/packages/ce/f4/71ba8be63351e099911051b2089662c03d5671437a0ec2171823c8e03bec/coverage-7.13.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:0018f73dfb4301a89292c73be6ba5f58722ff79f51593352759c1790ded1cabe", size = 219342, upload-time = "2025-12-08T13:14:15.02Z" }, + { url = "https://files.pythonhosted.org/packages/5e/25/127d8ed03d7711a387d96f132589057213e3aef7475afdaa303412463f22/coverage-7.13.0-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:166ad2a22ee770f5656e1257703139d3533b4a0b6909af67c6b4a3adc1c98657", size = 260713, upload-time = "2025-12-08T13:14:16.907Z" }, + { url = "https://files.pythonhosted.org/packages/fd/db/559fbb6def07d25b2243663b46ba9eb5a3c6586c0c6f4e62980a68f0ee1c/coverage-7.13.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:f6aaef16d65d1787280943f1c8718dc32e9cf141014e4634d64446702d26e0ff", size = 262825, upload-time = "2025-12-08T13:14:18.68Z" }, + { url = "https://files.pythonhosted.org/packages/37/99/6ee5bf7eff884766edb43bd8736b5e1c5144d0fe47498c3779326fe75a35/coverage-7.13.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e999e2dcc094002d6e2c7bbc1fb85b58ba4f465a760a8014d97619330cdbbbf3", size = 265233, upload-time = "2025-12-08T13:14:20.55Z" }, + { url = "https://files.pythonhosted.org/packages/d8/90/92f18fe0356ea69e1f98f688ed80cec39f44e9f09a1f26a1bbf017cc67f2/coverage-7.13.0-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:00c3d22cf6fb1cf3bf662aaaa4e563be8243a5ed2630339069799835a9cc7f9b", size = 259779, upload-time = "2025-12-08T13:14:22.367Z" }, + { url = "https://files.pythonhosted.org/packages/90/5d/b312a8b45b37a42ea7d27d7d3ff98ade3a6c892dd48d1d503e773503373f/coverage-7.13.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:22ccfe8d9bb0d6134892cbe1262493a8c70d736b9df930f3f3afae0fe3ac924d", size = 262700, upload-time = "2025-12-08T13:14:24.309Z" }, + { url = "https://files.pythonhosted.org/packages/63/f8/b1d0de5c39351eb71c366f872376d09386640840a2e09b0d03973d791e20/coverage-7.13.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:9372dff5ea15930fea0445eaf37bbbafbc771a49e70c0aeed8b4e2c2614cc00e", size = 260302, upload-time = "2025-12-08T13:14:26.068Z" }, + { url = "https://files.pythonhosted.org/packages/aa/7c/d42f4435bc40c55558b3109a39e2d456cddcec37434f62a1f1230991667a/coverage-7.13.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:69ac2c492918c2461bc6ace42d0479638e60719f2a4ef3f0815fa2df88e9f940", size = 259136, upload-time = "2025-12-08T13:14:27.604Z" }, + { url = "https://files.pythonhosted.org/packages/b8/d3/23413241dc04d47cfe19b9a65b32a2edd67ecd0b817400c2843ebc58c847/coverage-7.13.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:739c6c051a7540608d097b8e13c76cfa85263ced467168dc6b477bae3df7d0e2", size = 261467, upload-time = "2025-12-08T13:14:29.09Z" }, + { url = "https://files.pythonhosted.org/packages/13/e6/6e063174500eee216b96272c0d1847bf215926786f85c2bd024cf4d02d2f/coverage-7.13.0-cp314-cp314t-win32.whl", hash = "sha256:fe81055d8c6c9de76d60c94ddea73c290b416e061d40d542b24a5871bad498b7", size = 221875, upload-time = "2025-12-08T13:14:31.106Z" }, + { url = "https://files.pythonhosted.org/packages/3b/46/f4fb293e4cbe3620e3ac2a3e8fd566ed33affb5861a9b20e3dd6c1896cbc/coverage-7.13.0-cp314-cp314t-win_amd64.whl", hash = "sha256:445badb539005283825959ac9fa4a28f712c214b65af3a2c464f1adc90f5fcbc", size = 222982, upload-time = "2025-12-08T13:14:33.1Z" }, + { url = "https://files.pythonhosted.org/packages/68/62/5b3b9018215ed9733fbd1ae3b2ed75c5de62c3b55377a52cae732e1b7805/coverage-7.13.0-cp314-cp314t-win_arm64.whl", hash = "sha256:de7f6748b890708578fc4b7bb967d810aeb6fcc9bff4bb77dbca77dab2f9df6a", size = 221016, upload-time = "2025-12-08T13:14:34.601Z" }, + { url = "https://files.pythonhosted.org/packages/8d/4c/1968f32fb9a2604645827e11ff84a31e59d532e01995f904723b4f5328b3/coverage-7.13.0-py3-none-any.whl", hash = "sha256:850d2998f380b1e266459ca5b47bc9e7daf9af1d070f66317972f382d46f1904", size = 210068, upload-time = "2025-12-08T13:14:36.236Z" }, +] + +[package.optional-dependencies] +toml = [ + { name = "tomli", marker = "python_full_version <= '3.11'" }, +] + +[[package]] +name = "cryptography" +version = "42.0.8" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi", marker = "platform_python_implementation != 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/93/a7/1498799a2ea06148463a9a2c10ab2f6a921a74fb19e231b27dc412a748e2/cryptography-42.0.8.tar.gz", hash = "sha256:8d09d05439ce7baa8e9e95b07ec5b6c886f548deb7e0f69ef25f64b3bce842f2", size = 671250, upload-time = "2024-06-04T19:55:08.609Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f9/8b/1b929ba8139430e09e140e6939c2b29c18df1f2fc2149e41bdbdcdaf5d1f/cryptography-42.0.8-cp37-abi3-macosx_10_12_universal2.whl", hash = "sha256:81d8a521705787afe7a18d5bfb47ea9d9cc068206270aad0b96a725022e18d2e", size = 5899961, upload-time = "2024-06-04T19:53:57.933Z" }, + { url = "https://files.pythonhosted.org/packages/fa/5d/31d833daa800e4fab33209843095df7adb4a78ea536929145534cbc15026/cryptography-42.0.8-cp37-abi3-macosx_10_12_x86_64.whl", hash = "sha256:961e61cefdcb06e0c6d7e3a1b22ebe8b996eb2bf50614e89384be54c48c6b63d", size = 3114353, upload-time = "2024-06-04T19:54:12.171Z" }, + { url = "https://files.pythonhosted.org/packages/5d/32/f6326c70a9f0f258a201d3b2632bca586ea24d214cec3cf36e374040e273/cryptography-42.0.8-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e3ec3672626e1b9e55afd0df6d774ff0e953452886e06e0f1eb7eb0c832e8902", size = 3647773, upload-time = "2024-06-04T19:54:07.051Z" }, + { url = "https://files.pythonhosted.org/packages/35/66/2d87e9ca95c82c7ee5f2c09716fc4c4242c1ae6647b9bd27e55e920e9f10/cryptography-42.0.8-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e599b53fd95357d92304510fb7bda8523ed1f79ca98dce2f43c115950aa78801", size = 3839763, upload-time = "2024-06-04T19:54:30.383Z" }, + { url = "https://files.pythonhosted.org/packages/c2/de/8083fa2e68d403553a01a9323f4f8b9d7ffed09928ba25635c29fb28c1e7/cryptography-42.0.8-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:5226d5d21ab681f432a9c1cf8b658c0cb02533eece706b155e5fbd8a0cdd3949", size = 3632661, upload-time = "2024-06-04T19:54:32.955Z" }, + { url = "https://files.pythonhosted.org/packages/07/40/d6f6819c62e808ea74639c3c640f7edd636b86cce62cb14943996a15df92/cryptography-42.0.8-cp37-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:6b7c4f03ce01afd3b76cf69a5455caa9cfa3de8c8f493e0d3ab7d20611c8dae9", size = 3851536, upload-time = "2024-06-04T19:53:53.131Z" }, + { url = "https://files.pythonhosted.org/packages/5c/46/de71d48abf2b6d3c808f4fbb0f4dc44a4e72786be23df0541aa2a3f6fd7e/cryptography-42.0.8-cp37-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:2346b911eb349ab547076f47f2e035fc8ff2c02380a7cbbf8d87114fa0f1c583", size = 3754209, upload-time = "2024-06-04T19:54:55.259Z" }, + { url = "https://files.pythonhosted.org/packages/25/c9/86f04e150c5d5d5e4a731a2c1e0e43da84d901f388e3fea3d5de98d689a7/cryptography-42.0.8-cp37-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:ad803773e9df0b92e0a817d22fd8a3675493f690b96130a5e24f1b8fabbea9c7", size = 3923551, upload-time = "2024-06-04T19:54:16.46Z" }, + { url = "https://files.pythonhosted.org/packages/53/c2/903014dafb7271fb148887d4355b2e90319cad6e810663be622b0c933fc9/cryptography-42.0.8-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:2f66d9cd9147ee495a8374a45ca445819f8929a3efcd2e3df6428e46c3cbb10b", size = 3739265, upload-time = "2024-06-04T19:54:23.194Z" }, + { url = "https://files.pythonhosted.org/packages/95/26/82d704d988a193cbdc69ac3b41c687c36eaed1642cce52530ad810c35645/cryptography-42.0.8-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:d45b940883a03e19e944456a558b67a41160e367a719833c53de6911cabba2b7", size = 3937371, upload-time = "2024-06-04T19:55:04.303Z" }, + { url = "https://files.pythonhosted.org/packages/cf/71/4e0d05c9acd638a225f57fb6162aa3d03613c11b76893c23ea4675bb28c5/cryptography-42.0.8-cp37-abi3-win32.whl", hash = "sha256:a0c5b2b0585b6af82d7e385f55a8bc568abff8923af147ee3c07bd8b42cda8b2", size = 2438849, upload-time = "2024-06-04T19:54:27.39Z" }, + { url = "https://files.pythonhosted.org/packages/06/0f/78da3cad74f2ba6c45321dc90394d70420ea846730dc042ef527f5a224b5/cryptography-42.0.8-cp37-abi3-win_amd64.whl", hash = "sha256:57080dee41209e556a9a4ce60d229244f7a66ef52750f813bfbe18959770cfba", size = 2889090, upload-time = "2024-06-04T19:54:14.245Z" }, + { url = "https://files.pythonhosted.org/packages/60/12/f064af29190cdb1d38fe07f3db6126091639e1dece7ec77c4ff037d49193/cryptography-42.0.8-cp39-abi3-macosx_10_12_universal2.whl", hash = "sha256:dea567d1b0e8bc5764b9443858b673b734100c2871dc93163f58c46a97a83d28", size = 5901232, upload-time = "2024-06-04T19:54:52.722Z" }, + { url = "https://files.pythonhosted.org/packages/43/c2/4a3eef67e009a522711ebd8ac89424c3a7fe591ece7035d964419ad52a1d/cryptography-42.0.8-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c4783183f7cb757b73b2ae9aed6599b96338eb957233c58ca8f49a49cc32fd5e", size = 3648711, upload-time = "2024-06-04T19:54:44.323Z" }, + { url = "https://files.pythonhosted.org/packages/49/1c/9f6d13cc8041c05eebff1154e4e71bedd1db8e174fff999054435994187a/cryptography-42.0.8-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a0608251135d0e03111152e41f0cc2392d1e74e35703960d4190b2e0f4ca9c70", size = 3841968, upload-time = "2024-06-04T19:54:57.911Z" }, + { url = "https://files.pythonhosted.org/packages/5f/f9/c3d4f19b82bdb25a3d857fe96e7e571c981810e47e3f299cc13ac429066a/cryptography-42.0.8-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:dc0fdf6787f37b1c6b08e6dfc892d9d068b5bdb671198c72072828b80bd5fe4c", size = 3633032, upload-time = "2024-06-04T19:54:48.518Z" }, + { url = "https://files.pythonhosted.org/packages/fa/e2/b7e6e8c261536c489d9cf908769880d94bd5d9a187e166b0dc838d2e6a56/cryptography-42.0.8-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:9c0c1716c8447ee7dbf08d6db2e5c41c688544c61074b54fc4564196f55c25a7", size = 3852478, upload-time = "2024-06-04T19:54:50.599Z" }, + { url = "https://files.pythonhosted.org/packages/a2/68/e16751f6b859bc120f53fddbf3ebada5c34f0e9689d8af32884d8b2e4b4c/cryptography-42.0.8-cp39-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:fff12c88a672ab9c9c1cf7b0c80e3ad9e2ebd9d828d955c126be4fd3e5578c9e", size = 3754102, upload-time = "2024-06-04T19:54:46.231Z" }, + { url = "https://files.pythonhosted.org/packages/0f/38/85c74d0ac4c540780e072b1e6f148ecb718418c1062edcb20d22f3ec5bbb/cryptography-42.0.8-cp39-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:cafb92b2bc622cd1aa6a1dce4b93307792633f4c5fe1f46c6b97cf67073ec961", size = 3925042, upload-time = "2024-06-04T19:54:34.767Z" }, + { url = "https://files.pythonhosted.org/packages/89/f4/a8b982e88eb5350407ebdbf4717b55043271d878705329e107f4783555f2/cryptography-42.0.8-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:31f721658a29331f895a5a54e7e82075554ccfb8b163a18719d342f5ffe5ecb1", size = 3738833, upload-time = "2024-06-04T19:54:05.231Z" }, + { url = "https://files.pythonhosted.org/packages/fd/2b/be327b580645927bb1a1f32d5a175b897a9b956bc085b095e15c40bac9ed/cryptography-42.0.8-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:b297f90c5723d04bcc8265fc2a0f86d4ea2e0f7ab4b6994459548d3a6b992a14", size = 3938751, upload-time = "2024-06-04T19:54:37.837Z" }, + { url = "https://files.pythonhosted.org/packages/3c/d5/c6a78ffccdbe4516711ebaa9ed2c7eb6ac5dfa3dc920f2c7e920af2418b0/cryptography-42.0.8-cp39-abi3-win32.whl", hash = "sha256:2f88d197e66c65be5e42cd72e5c18afbfae3f741742070e3019ac8f4ac57262c", size = 2439281, upload-time = "2024-06-04T19:53:55.903Z" }, + { url = "https://files.pythonhosted.org/packages/a2/7b/b0d330852dd5953daee6b15f742f15d9f18e9c0154eb4cfcc8718f0436da/cryptography-42.0.8-cp39-abi3-win_amd64.whl", hash = "sha256:fa76fbb7596cc5839320000cdd5d0955313696d9511debab7ee7278fc8b5c84a", size = 2886038, upload-time = "2024-06-04T19:54:18.707Z" }, + { url = "https://files.pythonhosted.org/packages/a3/fe/1e21699f0a7904e8a30d4fc6db262958f1edf5e505a02e7d97a5b419e482/cryptography-42.0.8-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:ba4f0a211697362e89ad822e667d8d340b4d8d55fae72cdd619389fb5912eefe", size = 3014449, upload-time = "2024-06-04T19:54:40.379Z" }, + { url = "https://files.pythonhosted.org/packages/d5/f3/61b398b5ec61f4b6ffbf746227df7ebb421696458d9625d634043f236a13/cryptography-42.0.8-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:81884c4d096c272f00aeb1f11cf62ccd39763581645b0812e99a91505fa48e0c", size = 3558533, upload-time = "2024-06-04T19:54:42.123Z" }, + { url = "https://files.pythonhosted.org/packages/c1/e2/60b05e720766e185ef097d07068bd878a51d613ef91e4c241750f9c9192b/cryptography-42.0.8-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:c9bb2ae11bfbab395bdd072985abde58ea9860ed84e59dbc0463a5d0159f5b71", size = 3759330, upload-time = "2024-06-04T19:54:09.258Z" }, + { url = "https://files.pythonhosted.org/packages/10/38/2c8dae407d301eaf942e377a5b2b30485cfa0df03c6c2dcc2ac044054ed9/cryptography-42.0.8-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:7016f837e15b0a1c119d27ecd89b3515f01f90a8615ed5e9427e30d9cdbfed3d", size = 2801764, upload-time = "2024-06-04T19:54:25.455Z" }, +] + +[[package]] +name = "datasets" +version = "4.4.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "dill" }, + { name = "filelock" }, + { name = "fsspec", extra = ["http"] }, + { name = "httpx" }, + { name = "huggingface-hub" }, + { name = "multiprocess" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "numpy", version = "2.3.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "packaging" }, + { name = "pandas" }, + { name = "pyarrow" }, + { name = "pyyaml" }, + { name = "requests" }, + { name = "tqdm" }, + { name = "xxhash" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/93/bf/0dae295d6d1ba0b1a200a9dd216838464b5bbd05da01407cb1330b377445/datasets-4.4.1.tar.gz", hash = "sha256:80322699aa8c0bbbdb7caa87906da689c3c2e29523cff698775c67f28fdab1fc", size = 585341, upload-time = "2025-11-05T16:00:38.162Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3b/5e/6f8d874366788ad5d549e9ba258037d974dda6e004843be1bda794571701/datasets-4.4.1-py3-none-any.whl", hash = "sha256:c1163de5211e42546079ab355cc0250c7e6db16eb209ac5ac6252f801f596c44", size = 511591, upload-time = "2025-11-05T16:00:36.365Z" }, +] + +[[package]] +name = "decorator" +version = "5.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/43/fa/6d96a0978d19e17b68d634497769987b16c8f4cd0a7a05048bec693caa6b/decorator-5.2.1.tar.gz", hash = "sha256:65f266143752f734b0a7cc83c46f4618af75b8c5911b00ccb61d0ac9b6da0360", size = 56711, upload-time = "2025-02-24T04:41:34.073Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4e/8c/f3147f5c4b73e7550fe5f9352eaa956ae838d5c51eb58e7a25b9f3e2643b/decorator-5.2.1-py3-none-any.whl", hash = "sha256:d316bb415a2d9e2d2b3abcc4084c6502fc09240e292cd76a76afc106a1c8e04a", size = 9190, upload-time = "2025-02-24T04:41:32.565Z" }, +] + +[[package]] +name = "deprecated" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "wrapt" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/49/85/12f0a49a7c4ffb70572b6c2ef13c90c88fd190debda93b23f026b25f9634/deprecated-1.3.1.tar.gz", hash = "sha256:b1b50e0ff0c1fddaa5708a2c6b0a6588bb09b892825ab2b214ac9ea9d92a5223", size = 2932523, upload-time = "2025-10-30T08:19:02.757Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/84/d0/205d54408c08b13550c733c4b85429e7ead111c7f0014309637425520a9a/deprecated-1.3.1-py2.py3-none-any.whl", hash = "sha256:597bfef186b6f60181535a29fbe44865ce137a5079f295b479886c82729d5f3f", size = 11298, upload-time = "2025-10-30T08:19:00.758Z" }, +] + +[[package]] +name = "dill" +version = "0.4.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/12/80/630b4b88364e9a8c8c5797f4602d0f76ef820909ee32f0bacb9f90654042/dill-0.4.0.tar.gz", hash = "sha256:0633f1d2df477324f53a895b02c901fb961bdbf65a17122586ea7019292cbcf0", size = 186976, upload-time = "2025-04-16T00:41:48.867Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/50/3d/9373ad9c56321fdab5b41197068e1d8c25883b3fea29dd361f9b55116869/dill-0.4.0-py3-none-any.whl", hash = "sha256:44f54bf6412c2c8464c14e8243eb163690a9800dbe2c367330883b19c7561049", size = 119668, upload-time = "2025-04-16T00:41:47.671Z" }, +] + +[[package]] +name = "docker" +version = "7.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pywin32", marker = "sys_platform == 'win32'" }, + { name = "requests" }, + { name = "urllib3" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/91/9b/4a2ea29aeba62471211598dac5d96825bb49348fa07e906ea930394a83ce/docker-7.1.0.tar.gz", hash = "sha256:ad8c70e6e3f8926cb8a92619b832b4ea5299e2831c14284663184e200546fa6c", size = 117834, upload-time = "2024-05-23T11:13:57.216Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e3/26/57c6fb270950d476074c087527a558ccb6f4436657314bfb6cdf484114c4/docker-7.1.0-py3-none-any.whl", hash = "sha256:c96b93b7f0a746f9e77d325bcfb87422a3d8bd4f03136ae8a85b37f1898d5fc0", size = 147774, upload-time = "2024-05-23T11:13:55.01Z" }, +] + +[[package]] +name = "docstring-parser" +version = "0.17.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b2/9d/c3b43da9515bd270df0f80548d9944e389870713cc1fe2b8fb35fe2bcefd/docstring_parser-0.17.0.tar.gz", hash = "sha256:583de4a309722b3315439bb31d64ba3eebada841f2e2cee23b99df001434c912", size = 27442, upload-time = "2025-07-21T07:35:01.868Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/55/e2/2537ebcff11c1ee1ff17d8d0b6f4db75873e3b0fb32c2d4a2ee31ecb310a/docstring_parser-0.17.0-py3-none-any.whl", hash = "sha256:cf2569abd23dce8099b300f9b4fa8191e9582dda731fd533daf54c4551658708", size = 36896, upload-time = "2025-07-21T07:35:00.684Z" }, +] + +[[package]] +name = "docutils" +version = "0.21.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ae/ed/aefcc8cd0ba62a0560c3c18c33925362d46c6075480bfa4df87b28e169a9/docutils-0.21.2.tar.gz", hash = "sha256:3a6b18732edf182daa3cd12775bbb338cf5691468f91eeeb109deff6ebfa986f", size = 2204444, upload-time = "2024-04-23T18:57:18.24Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8f/d7/9322c609343d929e75e7e5e6255e614fcc67572cfd083959cdef3b7aad79/docutils-0.21.2-py3-none-any.whl", hash = "sha256:dafca5b9e384f0e419294eb4d2ff9fa826435bf15f15b7bd45723e8ad76811b2", size = 587408, upload-time = "2024-04-23T18:57:14.835Z" }, +] + +[[package]] +name = "exceptiongroup" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/50/79/66800aadf48771f6b62f7eb014e352e5d06856655206165d775e675a02c9/exceptiongroup-1.3.1.tar.gz", hash = "sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219", size = 30371, upload-time = "2025-11-21T23:01:54.787Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8a/0e/97c33bf5009bdbac74fd2beace167cab3f978feb69cc36f1ef79360d6c4e/exceptiongroup-1.3.1-py3-none-any.whl", hash = "sha256:a7a39a3bd276781e98394987d3a5701d0c4edffb633bb7a5144577f82c773598", size = 16740, upload-time = "2025-11-21T23:01:53.443Z" }, +] + +[[package]] +name = "fabric" +version = "3.2.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "decorator" }, + { name = "deprecated" }, + { name = "invoke" }, + { name = "paramiko" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0d/3f/337f278b70ba339c618a490f6b8033b7006c583bd197a897f12fbc468c51/fabric-3.2.2.tar.gz", hash = "sha256:8783ca42e3b0076f08b26901aac6b9d9b1f19c410074e7accfab902c184ff4a3", size = 183215, upload-time = "2023-08-31T01:42:05.55Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d6/1f/e99e23ee01847147fa194e8d41cfcf2535a2dbfcb51414c541cadb15c5d7/fabric-3.2.2-py3-none-any.whl", hash = "sha256:91c47c0be68b14936c88b34da8a1f55e5710fd28397dac5d4ff2e21558113a6f", size = 59417, upload-time = "2023-08-31T01:42:03.917Z" }, +] + +[[package]] +name = "fastapi" +version = "0.124.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "annotated-doc" }, + { name = "pydantic" }, + { name = "starlette" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/58/b7/4dbca3f9d847ba9876dcb7098c13a4c6c86ee8db148c923fab78e27748d3/fastapi-0.124.2.tar.gz", hash = "sha256:72e188f01f360e2f59da51c8822cbe4bca210c35daaae6321b1b724109101c00", size = 361867, upload-time = "2025-12-10T12:10:10.676Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/25/c5/8a5231197b81943b2df126cc8ea2083262e004bee3a39cf85a471392d145/fastapi-0.124.2-py3-none-any.whl", hash = "sha256:6314385777a507bb19b34bd064829fddaea0eea54436deb632b5de587554055c", size = 112711, upload-time = "2025-12-10T12:10:08.855Z" }, +] + +[[package]] +name = "fiddle" +version = "0.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "absl-py" }, + { name = "graphviz" }, + { name = "libcst" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/73/36/7a4fac76351619b36bbc7937abf59f7b601326dc4efc253b3c16819f782a/fiddle-0.3.0.tar.gz", hash = "sha256:5d083d3299a479868345513385a6c5546141bd92086c15d3dcbf8008a90075d3", size = 277884, upload-time = "2024-04-09T17:23:58.974Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3b/98/a38e949a91ff9e15874487fd8329ff53c25f3413c0cfc809eb6ff7eb7fa1/fiddle-0.3.0-py3-none-any.whl", hash = "sha256:f4824541c103a94a2f33f6c93eeddf6007c3a7300440087a95907f3e74362e61", size = 419830, upload-time = "2024-04-09T17:23:56.7Z" }, +] + +[[package]] +name = "filelock" +version = "3.20.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/58/46/0028a82567109b5ef6e4d2a1f04a583fb513e6cf9527fcdd09afd817deeb/filelock-3.20.0.tar.gz", hash = "sha256:711e943b4ec6be42e1d4e6690b48dc175c822967466bb31c0c293f34334c13f4", size = 18922, upload-time = "2025-10-08T18:03:50.056Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/76/91/7216b27286936c16f5b4d0c530087e4a54eead683e6b0b73dd0c64844af6/filelock-3.20.0-py3-none-any.whl", hash = "sha256:339b4732ffda5cd79b13f4e2711a31b0365ce445d95d243bb996273d072546a2", size = 16054, upload-time = "2025-10-08T18:03:48.35Z" }, +] + +[[package]] +name = "frozenlist" +version = "1.8.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/2d/f5/c831fac6cc817d26fd54c7eaccd04ef7e0288806943f7cc5bbf69f3ac1f0/frozenlist-1.8.0.tar.gz", hash = "sha256:3ede829ed8d842f6cd48fc7081d7a41001a56f1f38603f9d49bf3020d59a31ad", size = 45875, upload-time = "2025-10-06T05:38:17.865Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/83/4a/557715d5047da48d54e659203b9335be7bfaafda2c3f627b7c47e0b3aaf3/frozenlist-1.8.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:b37f6d31b3dcea7deb5e9696e529a6aa4a898adc33db82da12e4c60a7c4d2011", size = 86230, upload-time = "2025-10-06T05:35:23.699Z" }, + { url = "https://files.pythonhosted.org/packages/a2/fb/c85f9fed3ea8fe8740e5b46a59cc141c23b842eca617da8876cfce5f760e/frozenlist-1.8.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:ef2b7b394f208233e471abc541cc6991f907ffd47dc72584acee3147899d6565", size = 49621, upload-time = "2025-10-06T05:35:25.341Z" }, + { url = "https://files.pythonhosted.org/packages/63/70/26ca3f06aace16f2352796b08704338d74b6d1a24ca38f2771afbb7ed915/frozenlist-1.8.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a88f062f072d1589b7b46e951698950e7da00442fc1cacbe17e19e025dc327ad", size = 49889, upload-time = "2025-10-06T05:35:26.797Z" }, + { url = "https://files.pythonhosted.org/packages/5d/ed/c7895fd2fde7f3ee70d248175f9b6cdf792fb741ab92dc59cd9ef3bd241b/frozenlist-1.8.0-cp310-cp310-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:f57fb59d9f385710aa7060e89410aeb5058b99e62f4d16b08b91986b9a2140c2", size = 219464, upload-time = "2025-10-06T05:35:28.254Z" }, + { url = "https://files.pythonhosted.org/packages/6b/83/4d587dccbfca74cb8b810472392ad62bfa100bf8108c7223eb4c4fa2f7b3/frozenlist-1.8.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:799345ab092bee59f01a915620b5d014698547afd011e691a208637312db9186", size = 221649, upload-time = "2025-10-06T05:35:29.454Z" }, + { url = "https://files.pythonhosted.org/packages/6a/c6/fd3b9cd046ec5fff9dab66831083bc2077006a874a2d3d9247dea93ddf7e/frozenlist-1.8.0-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c23c3ff005322a6e16f71bf8692fcf4d5a304aaafe1e262c98c6d4adc7be863e", size = 219188, upload-time = "2025-10-06T05:35:30.951Z" }, + { url = "https://files.pythonhosted.org/packages/ce/80/6693f55eb2e085fc8afb28cf611448fb5b90e98e068fa1d1b8d8e66e5c7d/frozenlist-1.8.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8a76ea0f0b9dfa06f254ee06053d93a600865b3274358ca48a352ce4f0798450", size = 231748, upload-time = "2025-10-06T05:35:32.101Z" }, + { url = "https://files.pythonhosted.org/packages/97/d6/e9459f7c5183854abd989ba384fe0cc1a0fb795a83c033f0571ec5933ca4/frozenlist-1.8.0-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:c7366fe1418a6133d5aa824ee53d406550110984de7637d65a178010f759c6ef", size = 236351, upload-time = "2025-10-06T05:35:33.834Z" }, + { url = "https://files.pythonhosted.org/packages/97/92/24e97474b65c0262e9ecd076e826bfd1d3074adcc165a256e42e7b8a7249/frozenlist-1.8.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:13d23a45c4cebade99340c4165bd90eeb4a56c6d8a9d8aa49568cac19a6d0dc4", size = 218767, upload-time = "2025-10-06T05:35:35.205Z" }, + { url = "https://files.pythonhosted.org/packages/ee/bf/dc394a097508f15abff383c5108cb8ad880d1f64a725ed3b90d5c2fbf0bb/frozenlist-1.8.0-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:e4a3408834f65da56c83528fb52ce7911484f0d1eaf7b761fc66001db1646eff", size = 235887, upload-time = "2025-10-06T05:35:36.354Z" }, + { url = "https://files.pythonhosted.org/packages/40/90/25b201b9c015dbc999a5baf475a257010471a1fa8c200c843fd4abbee725/frozenlist-1.8.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:42145cd2748ca39f32801dad54aeea10039da6f86e303659db90db1c4b614c8c", size = 228785, upload-time = "2025-10-06T05:35:37.949Z" }, + { url = "https://files.pythonhosted.org/packages/84/f4/b5bc148df03082f05d2dd30c089e269acdbe251ac9a9cf4e727b2dbb8a3d/frozenlist-1.8.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:e2de870d16a7a53901e41b64ffdf26f2fbb8917b3e6ebf398098d72c5b20bd7f", size = 230312, upload-time = "2025-10-06T05:35:39.178Z" }, + { url = "https://files.pythonhosted.org/packages/db/4b/87e95b5d15097c302430e647136b7d7ab2398a702390cf4c8601975709e7/frozenlist-1.8.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:20e63c9493d33ee48536600d1a5c95eefc870cd71e7ab037763d1fbb89cc51e7", size = 217650, upload-time = "2025-10-06T05:35:40.377Z" }, + { url = "https://files.pythonhosted.org/packages/e5/70/78a0315d1fea97120591a83e0acd644da638c872f142fd72a6cebee825f3/frozenlist-1.8.0-cp310-cp310-win32.whl", hash = "sha256:adbeebaebae3526afc3c96fad434367cafbfd1b25d72369a9e5858453b1bb71a", size = 39659, upload-time = "2025-10-06T05:35:41.863Z" }, + { url = "https://files.pythonhosted.org/packages/66/aa/3f04523fb189a00e147e60c5b2205126118f216b0aa908035c45336e27e4/frozenlist-1.8.0-cp310-cp310-win_amd64.whl", hash = "sha256:667c3777ca571e5dbeb76f331562ff98b957431df140b54c85fd4d52eea8d8f6", size = 43837, upload-time = "2025-10-06T05:35:43.205Z" }, + { url = "https://files.pythonhosted.org/packages/39/75/1135feecdd7c336938bd55b4dc3b0dfc46d85b9be12ef2628574b28de776/frozenlist-1.8.0-cp310-cp310-win_arm64.whl", hash = "sha256:80f85f0a7cc86e7a54c46d99c9e1318ff01f4687c172ede30fd52d19d1da1c8e", size = 39989, upload-time = "2025-10-06T05:35:44.596Z" }, + { url = "https://files.pythonhosted.org/packages/bc/03/077f869d540370db12165c0aa51640a873fb661d8b315d1d4d67b284d7ac/frozenlist-1.8.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:09474e9831bc2b2199fad6da3c14c7b0fbdd377cce9d3d77131be28906cb7d84", size = 86912, upload-time = "2025-10-06T05:35:45.98Z" }, + { url = "https://files.pythonhosted.org/packages/df/b5/7610b6bd13e4ae77b96ba85abea1c8cb249683217ef09ac9e0ae93f25a91/frozenlist-1.8.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:17c883ab0ab67200b5f964d2b9ed6b00971917d5d8a92df149dc2c9779208ee9", size = 50046, upload-time = "2025-10-06T05:35:47.009Z" }, + { url = "https://files.pythonhosted.org/packages/6e/ef/0e8f1fe32f8a53dd26bdd1f9347efe0778b0fddf62789ea683f4cc7d787d/frozenlist-1.8.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:fa47e444b8ba08fffd1c18e8cdb9a75db1b6a27f17507522834ad13ed5922b93", size = 50119, upload-time = "2025-10-06T05:35:48.38Z" }, + { url = "https://files.pythonhosted.org/packages/11/b1/71a477adc7c36e5fb628245dfbdea2166feae310757dea848d02bd0689fd/frozenlist-1.8.0-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2552f44204b744fba866e573be4c1f9048d6a324dfe14475103fd51613eb1d1f", size = 231067, upload-time = "2025-10-06T05:35:49.97Z" }, + { url = "https://files.pythonhosted.org/packages/45/7e/afe40eca3a2dc19b9904c0f5d7edfe82b5304cb831391edec0ac04af94c2/frozenlist-1.8.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:957e7c38f250991e48a9a73e6423db1bb9dd14e722a10f6b8bb8e16a0f55f695", size = 233160, upload-time = "2025-10-06T05:35:51.729Z" }, + { url = "https://files.pythonhosted.org/packages/a6/aa/7416eac95603ce428679d273255ffc7c998d4132cfae200103f164b108aa/frozenlist-1.8.0-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:8585e3bb2cdea02fc88ffa245069c36555557ad3609e83be0ec71f54fd4abb52", size = 228544, upload-time = "2025-10-06T05:35:53.246Z" }, + { url = "https://files.pythonhosted.org/packages/8b/3d/2a2d1f683d55ac7e3875e4263d28410063e738384d3adc294f5ff3d7105e/frozenlist-1.8.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:edee74874ce20a373d62dc28b0b18b93f645633c2943fd90ee9d898550770581", size = 243797, upload-time = "2025-10-06T05:35:54.497Z" }, + { url = "https://files.pythonhosted.org/packages/78/1e/2d5565b589e580c296d3bb54da08d206e797d941a83a6fdea42af23be79c/frozenlist-1.8.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:c9a63152fe95756b85f31186bddf42e4c02c6321207fd6601a1c89ebac4fe567", size = 247923, upload-time = "2025-10-06T05:35:55.861Z" }, + { url = "https://files.pythonhosted.org/packages/aa/c3/65872fcf1d326a7f101ad4d86285c403c87be7d832b7470b77f6d2ed5ddc/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:b6db2185db9be0a04fecf2f241c70b63b1a242e2805be291855078f2b404dd6b", size = 230886, upload-time = "2025-10-06T05:35:57.399Z" }, + { url = "https://files.pythonhosted.org/packages/a0/76/ac9ced601d62f6956f03cc794f9e04c81719509f85255abf96e2510f4265/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:f4be2e3d8bc8aabd566f8d5b8ba7ecc09249d74ba3c9ed52e54dc23a293f0b92", size = 245731, upload-time = "2025-10-06T05:35:58.563Z" }, + { url = "https://files.pythonhosted.org/packages/b9/49/ecccb5f2598daf0b4a1415497eba4c33c1e8ce07495eb07d2860c731b8d5/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:c8d1634419f39ea6f5c427ea2f90ca85126b54b50837f31497f3bf38266e853d", size = 241544, upload-time = "2025-10-06T05:35:59.719Z" }, + { url = "https://files.pythonhosted.org/packages/53/4b/ddf24113323c0bbcc54cb38c8b8916f1da7165e07b8e24a717b4a12cbf10/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:1a7fa382a4a223773ed64242dbe1c9c326ec09457e6b8428efb4118c685c3dfd", size = 241806, upload-time = "2025-10-06T05:36:00.959Z" }, + { url = "https://files.pythonhosted.org/packages/a7/fb/9b9a084d73c67175484ba2789a59f8eebebd0827d186a8102005ce41e1ba/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:11847b53d722050808926e785df837353bd4d75f1d494377e59b23594d834967", size = 229382, upload-time = "2025-10-06T05:36:02.22Z" }, + { url = "https://files.pythonhosted.org/packages/95/a3/c8fb25aac55bf5e12dae5c5aa6a98f85d436c1dc658f21c3ac73f9fa95e5/frozenlist-1.8.0-cp311-cp311-win32.whl", hash = "sha256:27c6e8077956cf73eadd514be8fb04d77fc946a7fe9f7fe167648b0b9085cc25", size = 39647, upload-time = "2025-10-06T05:36:03.409Z" }, + { url = "https://files.pythonhosted.org/packages/0a/f5/603d0d6a02cfd4c8f2a095a54672b3cf967ad688a60fb9faf04fc4887f65/frozenlist-1.8.0-cp311-cp311-win_amd64.whl", hash = "sha256:ac913f8403b36a2c8610bbfd25b8013488533e71e62b4b4adce9c86c8cea905b", size = 44064, upload-time = "2025-10-06T05:36:04.368Z" }, + { url = "https://files.pythonhosted.org/packages/5d/16/c2c9ab44e181f043a86f9a8f84d5124b62dbcb3a02c0977ec72b9ac1d3e0/frozenlist-1.8.0-cp311-cp311-win_arm64.whl", hash = "sha256:d4d3214a0f8394edfa3e303136d0575eece0745ff2b47bd2cb2e66dd92d4351a", size = 39937, upload-time = "2025-10-06T05:36:05.669Z" }, + { url = "https://files.pythonhosted.org/packages/69/29/948b9aa87e75820a38650af445d2ef2b6b8a6fab1a23b6bb9e4ef0be2d59/frozenlist-1.8.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:78f7b9e5d6f2fdb88cdde9440dc147259b62b9d3b019924def9f6478be254ac1", size = 87782, upload-time = "2025-10-06T05:36:06.649Z" }, + { url = "https://files.pythonhosted.org/packages/64/80/4f6e318ee2a7c0750ed724fa33a4bdf1eacdc5a39a7a24e818a773cd91af/frozenlist-1.8.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:229bf37d2e4acdaf808fd3f06e854a4a7a3661e871b10dc1f8f1896a3b05f18b", size = 50594, upload-time = "2025-10-06T05:36:07.69Z" }, + { url = "https://files.pythonhosted.org/packages/2b/94/5c8a2b50a496b11dd519f4a24cb5496cf125681dd99e94c604ccdea9419a/frozenlist-1.8.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f833670942247a14eafbb675458b4e61c82e002a148f49e68257b79296e865c4", size = 50448, upload-time = "2025-10-06T05:36:08.78Z" }, + { url = "https://files.pythonhosted.org/packages/6a/bd/d91c5e39f490a49df14320f4e8c80161cfcce09f1e2cde1edd16a551abb3/frozenlist-1.8.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:494a5952b1c597ba44e0e78113a7266e656b9794eec897b19ead706bd7074383", size = 242411, upload-time = "2025-10-06T05:36:09.801Z" }, + { url = "https://files.pythonhosted.org/packages/8f/83/f61505a05109ef3293dfb1ff594d13d64a2324ac3482be2cedc2be818256/frozenlist-1.8.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96f423a119f4777a4a056b66ce11527366a8bb92f54e541ade21f2374433f6d4", size = 243014, upload-time = "2025-10-06T05:36:11.394Z" }, + { url = "https://files.pythonhosted.org/packages/d8/cb/cb6c7b0f7d4023ddda30cf56b8b17494eb3a79e3fda666bf735f63118b35/frozenlist-1.8.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3462dd9475af2025c31cc61be6652dfa25cbfb56cbbf52f4ccfe029f38decaf8", size = 234909, upload-time = "2025-10-06T05:36:12.598Z" }, + { url = "https://files.pythonhosted.org/packages/31/c5/cd7a1f3b8b34af009fb17d4123c5a778b44ae2804e3ad6b86204255f9ec5/frozenlist-1.8.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c4c800524c9cd9bac5166cd6f55285957fcfc907db323e193f2afcd4d9abd69b", size = 250049, upload-time = "2025-10-06T05:36:14.065Z" }, + { url = "https://files.pythonhosted.org/packages/c0/01/2f95d3b416c584a1e7f0e1d6d31998c4a795f7544069ee2e0962a4b60740/frozenlist-1.8.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d6a5df73acd3399d893dafc71663ad22534b5aa4f94e8a2fabfe856c3c1b6a52", size = 256485, upload-time = "2025-10-06T05:36:15.39Z" }, + { url = "https://files.pythonhosted.org/packages/ce/03/024bf7720b3abaebcff6d0793d73c154237b85bdf67b7ed55e5e9596dc9a/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:405e8fe955c2280ce66428b3ca55e12b3c4e9c336fb2103a4937e891c69a4a29", size = 237619, upload-time = "2025-10-06T05:36:16.558Z" }, + { url = "https://files.pythonhosted.org/packages/69/fa/f8abdfe7d76b731f5d8bd217827cf6764d4f1d9763407e42717b4bed50a0/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:908bd3f6439f2fef9e85031b59fd4f1297af54415fb60e4254a95f75b3cab3f3", size = 250320, upload-time = "2025-10-06T05:36:17.821Z" }, + { url = "https://files.pythonhosted.org/packages/f5/3c/b051329f718b463b22613e269ad72138cc256c540f78a6de89452803a47d/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:294e487f9ec720bd8ffcebc99d575f7eff3568a08a253d1ee1a0378754b74143", size = 246820, upload-time = "2025-10-06T05:36:19.046Z" }, + { url = "https://files.pythonhosted.org/packages/0f/ae/58282e8f98e444b3f4dd42448ff36fa38bef29e40d40f330b22e7108f565/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:74c51543498289c0c43656701be6b077f4b265868fa7f8a8859c197006efb608", size = 250518, upload-time = "2025-10-06T05:36:20.763Z" }, + { url = "https://files.pythonhosted.org/packages/8f/96/007e5944694d66123183845a106547a15944fbbb7154788cbf7272789536/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:776f352e8329135506a1d6bf16ac3f87bc25b28e765949282dcc627af36123aa", size = 239096, upload-time = "2025-10-06T05:36:22.129Z" }, + { url = "https://files.pythonhosted.org/packages/66/bb/852b9d6db2fa40be96f29c0d1205c306288f0684df8fd26ca1951d461a56/frozenlist-1.8.0-cp312-cp312-win32.whl", hash = "sha256:433403ae80709741ce34038da08511d4a77062aa924baf411ef73d1146e74faf", size = 39985, upload-time = "2025-10-06T05:36:23.661Z" }, + { url = "https://files.pythonhosted.org/packages/b8/af/38e51a553dd66eb064cdf193841f16f077585d4d28394c2fa6235cb41765/frozenlist-1.8.0-cp312-cp312-win_amd64.whl", hash = "sha256:34187385b08f866104f0c0617404c8eb08165ab1272e884abc89c112e9c00746", size = 44591, upload-time = "2025-10-06T05:36:24.958Z" }, + { url = "https://files.pythonhosted.org/packages/a7/06/1dc65480ab147339fecc70797e9c2f69d9cea9cf38934ce08df070fdb9cb/frozenlist-1.8.0-cp312-cp312-win_arm64.whl", hash = "sha256:fe3c58d2f5db5fbd18c2987cba06d51b0529f52bc3a6cdc33d3f4eab725104bd", size = 40102, upload-time = "2025-10-06T05:36:26.333Z" }, + { url = "https://files.pythonhosted.org/packages/2d/40/0832c31a37d60f60ed79e9dfb5a92e1e2af4f40a16a29abcc7992af9edff/frozenlist-1.8.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8d92f1a84bb12d9e56f818b3a746f3efba93c1b63c8387a73dde655e1e42282a", size = 85717, upload-time = "2025-10-06T05:36:27.341Z" }, + { url = "https://files.pythonhosted.org/packages/30/ba/b0b3de23f40bc55a7057bd38434e25c34fa48e17f20ee273bbde5e0650f3/frozenlist-1.8.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:96153e77a591c8adc2ee805756c61f59fef4cf4073a9275ee86fe8cba41241f7", size = 49651, upload-time = "2025-10-06T05:36:28.855Z" }, + { url = "https://files.pythonhosted.org/packages/0c/ab/6e5080ee374f875296c4243c381bbdef97a9ac39c6e3ce1d5f7d42cb78d6/frozenlist-1.8.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f21f00a91358803399890ab167098c131ec2ddd5f8f5fd5fe9c9f2c6fcd91e40", size = 49417, upload-time = "2025-10-06T05:36:29.877Z" }, + { url = "https://files.pythonhosted.org/packages/d5/4e/e4691508f9477ce67da2015d8c00acd751e6287739123113a9fca6f1604e/frozenlist-1.8.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:fb30f9626572a76dfe4293c7194a09fb1fe93ba94c7d4f720dfae3b646b45027", size = 234391, upload-time = "2025-10-06T05:36:31.301Z" }, + { url = "https://files.pythonhosted.org/packages/40/76/c202df58e3acdf12969a7895fd6f3bc016c642e6726aa63bd3025e0fc71c/frozenlist-1.8.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:eaa352d7047a31d87dafcacbabe89df0aa506abb5b1b85a2fb91bc3faa02d822", size = 233048, upload-time = "2025-10-06T05:36:32.531Z" }, + { url = "https://files.pythonhosted.org/packages/f9/c0/8746afb90f17b73ca5979c7a3958116e105ff796e718575175319b5bb4ce/frozenlist-1.8.0-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:03ae967b4e297f58f8c774c7eabcce57fe3c2434817d4385c50661845a058121", size = 226549, upload-time = "2025-10-06T05:36:33.706Z" }, + { url = "https://files.pythonhosted.org/packages/7e/eb/4c7eefc718ff72f9b6c4893291abaae5fbc0c82226a32dcd8ef4f7a5dbef/frozenlist-1.8.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f6292f1de555ffcc675941d65fffffb0a5bcd992905015f85d0592201793e0e5", size = 239833, upload-time = "2025-10-06T05:36:34.947Z" }, + { url = "https://files.pythonhosted.org/packages/c2/4e/e5c02187cf704224f8b21bee886f3d713ca379535f16893233b9d672ea71/frozenlist-1.8.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:29548f9b5b5e3460ce7378144c3010363d8035cea44bc0bf02d57f5a685e084e", size = 245363, upload-time = "2025-10-06T05:36:36.534Z" }, + { url = "https://files.pythonhosted.org/packages/1f/96/cb85ec608464472e82ad37a17f844889c36100eed57bea094518bf270692/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ec3cc8c5d4084591b4237c0a272cc4f50a5b03396a47d9caaf76f5d7b38a4f11", size = 229314, upload-time = "2025-10-06T05:36:38.582Z" }, + { url = "https://files.pythonhosted.org/packages/5d/6f/4ae69c550e4cee66b57887daeebe006fe985917c01d0fff9caab9883f6d0/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:517279f58009d0b1f2e7c1b130b377a349405da3f7621ed6bfae50b10adf20c1", size = 243365, upload-time = "2025-10-06T05:36:40.152Z" }, + { url = "https://files.pythonhosted.org/packages/7a/58/afd56de246cf11780a40a2c28dc7cbabbf06337cc8ddb1c780a2d97e88d8/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:db1e72ede2d0d7ccb213f218df6a078a9c09a7de257c2fe8fcef16d5925230b1", size = 237763, upload-time = "2025-10-06T05:36:41.355Z" }, + { url = "https://files.pythonhosted.org/packages/cb/36/cdfaf6ed42e2644740d4a10452d8e97fa1c062e2a8006e4b09f1b5fd7d63/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:b4dec9482a65c54a5044486847b8a66bf10c9cb4926d42927ec4e8fd5db7fed8", size = 240110, upload-time = "2025-10-06T05:36:42.716Z" }, + { url = "https://files.pythonhosted.org/packages/03/a8/9ea226fbefad669f11b52e864c55f0bd57d3c8d7eb07e9f2e9a0b39502e1/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:21900c48ae04d13d416f0e1e0c4d81f7931f73a9dfa0b7a8746fb2fe7dd970ed", size = 233717, upload-time = "2025-10-06T05:36:44.251Z" }, + { url = "https://files.pythonhosted.org/packages/1e/0b/1b5531611e83ba7d13ccc9988967ea1b51186af64c42b7a7af465dcc9568/frozenlist-1.8.0-cp313-cp313-win32.whl", hash = "sha256:8b7b94a067d1c504ee0b16def57ad5738701e4ba10cec90529f13fa03c833496", size = 39628, upload-time = "2025-10-06T05:36:45.423Z" }, + { url = "https://files.pythonhosted.org/packages/d8/cf/174c91dbc9cc49bc7b7aab74d8b734e974d1faa8f191c74af9b7e80848e6/frozenlist-1.8.0-cp313-cp313-win_amd64.whl", hash = "sha256:878be833caa6a3821caf85eb39c5ba92d28e85df26d57afb06b35b2efd937231", size = 43882, upload-time = "2025-10-06T05:36:46.796Z" }, + { url = "https://files.pythonhosted.org/packages/c1/17/502cd212cbfa96eb1388614fe39a3fc9ab87dbbe042b66f97acb57474834/frozenlist-1.8.0-cp313-cp313-win_arm64.whl", hash = "sha256:44389d135b3ff43ba8cc89ff7f51f5a0bb6b63d829c8300f79a2fe4fe61bcc62", size = 39676, upload-time = "2025-10-06T05:36:47.8Z" }, + { url = "https://files.pythonhosted.org/packages/d2/5c/3bbfaa920dfab09e76946a5d2833a7cbdf7b9b4a91c714666ac4855b88b4/frozenlist-1.8.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:e25ac20a2ef37e91c1b39938b591457666a0fa835c7783c3a8f33ea42870db94", size = 89235, upload-time = "2025-10-06T05:36:48.78Z" }, + { url = "https://files.pythonhosted.org/packages/d2/d6/f03961ef72166cec1687e84e8925838442b615bd0b8854b54923ce5b7b8a/frozenlist-1.8.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:07cdca25a91a4386d2e76ad992916a85038a9b97561bf7a3fd12d5d9ce31870c", size = 50742, upload-time = "2025-10-06T05:36:49.837Z" }, + { url = "https://files.pythonhosted.org/packages/1e/bb/a6d12b7ba4c3337667d0e421f7181c82dda448ce4e7ad7ecd249a16fa806/frozenlist-1.8.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:4e0c11f2cc6717e0a741f84a527c52616140741cd812a50422f83dc31749fb52", size = 51725, upload-time = "2025-10-06T05:36:50.851Z" }, + { url = "https://files.pythonhosted.org/packages/bc/71/d1fed0ffe2c2ccd70b43714c6cab0f4188f09f8a67a7914a6b46ee30f274/frozenlist-1.8.0-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b3210649ee28062ea6099cfda39e147fa1bc039583c8ee4481cb7811e2448c51", size = 284533, upload-time = "2025-10-06T05:36:51.898Z" }, + { url = "https://files.pythonhosted.org/packages/c9/1f/fb1685a7b009d89f9bf78a42d94461bc06581f6e718c39344754a5d9bada/frozenlist-1.8.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:581ef5194c48035a7de2aefc72ac6539823bb71508189e5de01d60c9dcd5fa65", size = 292506, upload-time = "2025-10-06T05:36:53.101Z" }, + { url = "https://files.pythonhosted.org/packages/e6/3b/b991fe1612703f7e0d05c0cf734c1b77aaf7c7d321df4572e8d36e7048c8/frozenlist-1.8.0-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3ef2d026f16a2b1866e1d86fc4e1291e1ed8a387b2c333809419a2f8b3a77b82", size = 274161, upload-time = "2025-10-06T05:36:54.309Z" }, + { url = "https://files.pythonhosted.org/packages/ca/ec/c5c618767bcdf66e88945ec0157d7f6c4a1322f1473392319b7a2501ded7/frozenlist-1.8.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5500ef82073f599ac84d888e3a8c1f77ac831183244bfd7f11eaa0289fb30714", size = 294676, upload-time = "2025-10-06T05:36:55.566Z" }, + { url = "https://files.pythonhosted.org/packages/7c/ce/3934758637d8f8a88d11f0585d6495ef54b2044ed6ec84492a91fa3b27aa/frozenlist-1.8.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:50066c3997d0091c411a66e710f4e11752251e6d2d73d70d8d5d4c76442a199d", size = 300638, upload-time = "2025-10-06T05:36:56.758Z" }, + { url = "https://files.pythonhosted.org/packages/fc/4f/a7e4d0d467298f42de4b41cbc7ddaf19d3cfeabaf9ff97c20c6c7ee409f9/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:5c1c8e78426e59b3f8005e9b19f6ff46e5845895adbde20ece9218319eca6506", size = 283067, upload-time = "2025-10-06T05:36:57.965Z" }, + { url = "https://files.pythonhosted.org/packages/dc/48/c7b163063d55a83772b268e6d1affb960771b0e203b632cfe09522d67ea5/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:eefdba20de0d938cec6a89bd4d70f346a03108a19b9df4248d3cf0d88f1b0f51", size = 292101, upload-time = "2025-10-06T05:36:59.237Z" }, + { url = "https://files.pythonhosted.org/packages/9f/d0/2366d3c4ecdc2fd391e0afa6e11500bfba0ea772764d631bbf82f0136c9d/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:cf253e0e1c3ceb4aaff6df637ce033ff6535fb8c70a764a8f46aafd3d6ab798e", size = 289901, upload-time = "2025-10-06T05:37:00.811Z" }, + { url = "https://files.pythonhosted.org/packages/b8/94/daff920e82c1b70e3618a2ac39fbc01ae3e2ff6124e80739ce5d71c9b920/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:032efa2674356903cd0261c4317a561a6850f3ac864a63fc1583147fb05a79b0", size = 289395, upload-time = "2025-10-06T05:37:02.115Z" }, + { url = "https://files.pythonhosted.org/packages/e3/20/bba307ab4235a09fdcd3cc5508dbabd17c4634a1af4b96e0f69bfe551ebd/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6da155091429aeba16851ecb10a9104a108bcd32f6c1642867eadaee401c1c41", size = 283659, upload-time = "2025-10-06T05:37:03.711Z" }, + { url = "https://files.pythonhosted.org/packages/fd/00/04ca1c3a7a124b6de4f8a9a17cc2fcad138b4608e7a3fc5877804b8715d7/frozenlist-1.8.0-cp313-cp313t-win32.whl", hash = "sha256:0f96534f8bfebc1a394209427d0f8a63d343c9779cda6fc25e8e121b5fd8555b", size = 43492, upload-time = "2025-10-06T05:37:04.915Z" }, + { url = "https://files.pythonhosted.org/packages/59/5e/c69f733a86a94ab10f68e496dc6b7e8bc078ebb415281d5698313e3af3a1/frozenlist-1.8.0-cp313-cp313t-win_amd64.whl", hash = "sha256:5d63a068f978fc69421fb0e6eb91a9603187527c86b7cd3f534a5b77a592b888", size = 48034, upload-time = "2025-10-06T05:37:06.343Z" }, + { url = "https://files.pythonhosted.org/packages/16/6c/be9d79775d8abe79b05fa6d23da99ad6e7763a1d080fbae7290b286093fd/frozenlist-1.8.0-cp313-cp313t-win_arm64.whl", hash = "sha256:bf0a7e10b077bf5fb9380ad3ae8ce20ef919a6ad93b4552896419ac7e1d8e042", size = 41749, upload-time = "2025-10-06T05:37:07.431Z" }, + { url = "https://files.pythonhosted.org/packages/f1/c8/85da824b7e7b9b6e7f7705b2ecaf9591ba6f79c1177f324c2735e41d36a2/frozenlist-1.8.0-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:cee686f1f4cadeb2136007ddedd0aaf928ab95216e7691c63e50a8ec066336d0", size = 86127, upload-time = "2025-10-06T05:37:08.438Z" }, + { url = "https://files.pythonhosted.org/packages/8e/e8/a1185e236ec66c20afd72399522f142c3724c785789255202d27ae992818/frozenlist-1.8.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:119fb2a1bd47307e899c2fac7f28e85b9a543864df47aa7ec9d3c1b4545f096f", size = 49698, upload-time = "2025-10-06T05:37:09.48Z" }, + { url = "https://files.pythonhosted.org/packages/a1/93/72b1736d68f03fda5fdf0f2180fb6caaae3894f1b854d006ac61ecc727ee/frozenlist-1.8.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:4970ece02dbc8c3a92fcc5228e36a3e933a01a999f7094ff7c23fbd2beeaa67c", size = 49749, upload-time = "2025-10-06T05:37:10.569Z" }, + { url = "https://files.pythonhosted.org/packages/a7/b2/fabede9fafd976b991e9f1b9c8c873ed86f202889b864756f240ce6dd855/frozenlist-1.8.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:cba69cb73723c3f329622e34bdbf5ce1f80c21c290ff04256cff1cd3c2036ed2", size = 231298, upload-time = "2025-10-06T05:37:11.993Z" }, + { url = "https://files.pythonhosted.org/packages/3a/3b/d9b1e0b0eed36e70477ffb8360c49c85c8ca8ef9700a4e6711f39a6e8b45/frozenlist-1.8.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:778a11b15673f6f1df23d9586f83c4846c471a8af693a22e066508b77d201ec8", size = 232015, upload-time = "2025-10-06T05:37:13.194Z" }, + { url = "https://files.pythonhosted.org/packages/dc/94/be719d2766c1138148564a3960fc2c06eb688da592bdc25adcf856101be7/frozenlist-1.8.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0325024fe97f94c41c08872db482cf8ac4800d80e79222c6b0b7b162d5b13686", size = 225038, upload-time = "2025-10-06T05:37:14.577Z" }, + { url = "https://files.pythonhosted.org/packages/e4/09/6712b6c5465f083f52f50cf74167b92d4ea2f50e46a9eea0523d658454ae/frozenlist-1.8.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:97260ff46b207a82a7567b581ab4190bd4dfa09f4db8a8b49d1a958f6aa4940e", size = 240130, upload-time = "2025-10-06T05:37:15.781Z" }, + { url = "https://files.pythonhosted.org/packages/f8/d4/cd065cdcf21550b54f3ce6a22e143ac9e4836ca42a0de1022da8498eac89/frozenlist-1.8.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:54b2077180eb7f83dd52c40b2750d0a9f175e06a42e3213ce047219de902717a", size = 242845, upload-time = "2025-10-06T05:37:17.037Z" }, + { url = "https://files.pythonhosted.org/packages/62/c3/f57a5c8c70cd1ead3d5d5f776f89d33110b1addae0ab010ad774d9a44fb9/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:2f05983daecab868a31e1da44462873306d3cbfd76d1f0b5b69c473d21dbb128", size = 229131, upload-time = "2025-10-06T05:37:18.221Z" }, + { url = "https://files.pythonhosted.org/packages/6c/52/232476fe9cb64f0742f3fde2b7d26c1dac18b6d62071c74d4ded55e0ef94/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:33f48f51a446114bc5d251fb2954ab0164d5be02ad3382abcbfe07e2531d650f", size = 240542, upload-time = "2025-10-06T05:37:19.771Z" }, + { url = "https://files.pythonhosted.org/packages/5f/85/07bf3f5d0fb5414aee5f47d33c6f5c77bfe49aac680bfece33d4fdf6a246/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:154e55ec0655291b5dd1b8731c637ecdb50975a2ae70c606d100750a540082f7", size = 237308, upload-time = "2025-10-06T05:37:20.969Z" }, + { url = "https://files.pythonhosted.org/packages/11/99/ae3a33d5befd41ac0ca2cc7fd3aa707c9c324de2e89db0e0f45db9a64c26/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:4314debad13beb564b708b4a496020e5306c7333fa9a3ab90374169a20ffab30", size = 238210, upload-time = "2025-10-06T05:37:22.252Z" }, + { url = "https://files.pythonhosted.org/packages/b2/60/b1d2da22f4970e7a155f0adde9b1435712ece01b3cd45ba63702aea33938/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:073f8bf8becba60aa931eb3bc420b217bb7d5b8f4750e6f8b3be7f3da85d38b7", size = 231972, upload-time = "2025-10-06T05:37:23.5Z" }, + { url = "https://files.pythonhosted.org/packages/3f/ab/945b2f32de889993b9c9133216c068b7fcf257d8595a0ac420ac8677cab0/frozenlist-1.8.0-cp314-cp314-win32.whl", hash = "sha256:bac9c42ba2ac65ddc115d930c78d24ab8d4f465fd3fc473cdedfccadb9429806", size = 40536, upload-time = "2025-10-06T05:37:25.581Z" }, + { url = "https://files.pythonhosted.org/packages/59/ad/9caa9b9c836d9ad6f067157a531ac48b7d36499f5036d4141ce78c230b1b/frozenlist-1.8.0-cp314-cp314-win_amd64.whl", hash = "sha256:3e0761f4d1a44f1d1a47996511752cf3dcec5bbdd9cc2b4fe595caf97754b7a0", size = 44330, upload-time = "2025-10-06T05:37:26.928Z" }, + { url = "https://files.pythonhosted.org/packages/82/13/e6950121764f2676f43534c555249f57030150260aee9dcf7d64efda11dd/frozenlist-1.8.0-cp314-cp314-win_arm64.whl", hash = "sha256:d1eaff1d00c7751b7c6662e9c5ba6eb2c17a2306ba5e2a37f24ddf3cc953402b", size = 40627, upload-time = "2025-10-06T05:37:28.075Z" }, + { url = "https://files.pythonhosted.org/packages/c0/c7/43200656ecc4e02d3f8bc248df68256cd9572b3f0017f0a0c4e93440ae23/frozenlist-1.8.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:d3bb933317c52d7ea5004a1c442eef86f426886fba134ef8cf4226ea6ee1821d", size = 89238, upload-time = "2025-10-06T05:37:29.373Z" }, + { url = "https://files.pythonhosted.org/packages/d1/29/55c5f0689b9c0fb765055629f472c0de484dcaf0acee2f7707266ae3583c/frozenlist-1.8.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:8009897cdef112072f93a0efdce29cd819e717fd2f649ee3016efd3cd885a7ed", size = 50738, upload-time = "2025-10-06T05:37:30.792Z" }, + { url = "https://files.pythonhosted.org/packages/ba/7d/b7282a445956506fa11da8c2db7d276adcbf2b17d8bb8407a47685263f90/frozenlist-1.8.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:2c5dcbbc55383e5883246d11fd179782a9d07a986c40f49abe89ddf865913930", size = 51739, upload-time = "2025-10-06T05:37:32.127Z" }, + { url = "https://files.pythonhosted.org/packages/62/1c/3d8622e60d0b767a5510d1d3cf21065b9db874696a51ea6d7a43180a259c/frozenlist-1.8.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:39ecbc32f1390387d2aa4f5a995e465e9e2f79ba3adcac92d68e3e0afae6657c", size = 284186, upload-time = "2025-10-06T05:37:33.21Z" }, + { url = "https://files.pythonhosted.org/packages/2d/14/aa36d5f85a89679a85a1d44cd7a6657e0b1c75f61e7cad987b203d2daca8/frozenlist-1.8.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92db2bf818d5cc8d9c1f1fc56b897662e24ea5adb36ad1f1d82875bd64e03c24", size = 292196, upload-time = "2025-10-06T05:37:36.107Z" }, + { url = "https://files.pythonhosted.org/packages/05/23/6bde59eb55abd407d34f77d39a5126fb7b4f109a3f611d3929f14b700c66/frozenlist-1.8.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2dc43a022e555de94c3b68a4ef0b11c4f747d12c024a520c7101709a2144fb37", size = 273830, upload-time = "2025-10-06T05:37:37.663Z" }, + { url = "https://files.pythonhosted.org/packages/d2/3f/22cff331bfad7a8afa616289000ba793347fcd7bc275f3b28ecea2a27909/frozenlist-1.8.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:cb89a7f2de3602cfed448095bab3f178399646ab7c61454315089787df07733a", size = 294289, upload-time = "2025-10-06T05:37:39.261Z" }, + { url = "https://files.pythonhosted.org/packages/a4/89/5b057c799de4838b6c69aa82b79705f2027615e01be996d2486a69ca99c4/frozenlist-1.8.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:33139dc858c580ea50e7e60a1b0ea003efa1fd42e6ec7fdbad78fff65fad2fd2", size = 300318, upload-time = "2025-10-06T05:37:43.213Z" }, + { url = "https://files.pythonhosted.org/packages/30/de/2c22ab3eb2a8af6d69dc799e48455813bab3690c760de58e1bf43b36da3e/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:168c0969a329b416119507ba30b9ea13688fafffac1b7822802537569a1cb0ef", size = 282814, upload-time = "2025-10-06T05:37:45.337Z" }, + { url = "https://files.pythonhosted.org/packages/59/f7/970141a6a8dbd7f556d94977858cfb36fa9b66e0892c6dd780d2219d8cd8/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:28bd570e8e189d7f7b001966435f9dac6718324b5be2990ac496cf1ea9ddb7fe", size = 291762, upload-time = "2025-10-06T05:37:46.657Z" }, + { url = "https://files.pythonhosted.org/packages/c1/15/ca1adae83a719f82df9116d66f5bb28bb95557b3951903d39135620ef157/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:b2a095d45c5d46e5e79ba1e5b9cb787f541a8dee0433836cea4b96a2c439dcd8", size = 289470, upload-time = "2025-10-06T05:37:47.946Z" }, + { url = "https://files.pythonhosted.org/packages/ac/83/dca6dc53bf657d371fbc88ddeb21b79891e747189c5de990b9dfff2ccba1/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:eab8145831a0d56ec9c4139b6c3e594c7a83c2c8be25d5bcf2d86136a532287a", size = 289042, upload-time = "2025-10-06T05:37:49.499Z" }, + { url = "https://files.pythonhosted.org/packages/96/52/abddd34ca99be142f354398700536c5bd315880ed0a213812bc491cff5e4/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:974b28cf63cc99dfb2188d8d222bc6843656188164848c4f679e63dae4b0708e", size = 283148, upload-time = "2025-10-06T05:37:50.745Z" }, + { url = "https://files.pythonhosted.org/packages/af/d3/76bd4ed4317e7119c2b7f57c3f6934aba26d277acc6309f873341640e21f/frozenlist-1.8.0-cp314-cp314t-win32.whl", hash = "sha256:342c97bf697ac5480c0a7ec73cd700ecfa5a8a40ac923bd035484616efecc2df", size = 44676, upload-time = "2025-10-06T05:37:52.222Z" }, + { url = "https://files.pythonhosted.org/packages/89/76/c615883b7b521ead2944bb3480398cbb07e12b7b4e4d073d3752eb721558/frozenlist-1.8.0-cp314-cp314t-win_amd64.whl", hash = "sha256:06be8f67f39c8b1dc671f5d83aaefd3358ae5cdcf8314552c57e7ed3e6475bdd", size = 49451, upload-time = "2025-10-06T05:37:53.425Z" }, + { url = "https://files.pythonhosted.org/packages/e0/a3/5982da14e113d07b325230f95060e2169f5311b1017ea8af2a29b374c289/frozenlist-1.8.0-cp314-cp314t-win_arm64.whl", hash = "sha256:102e6314ca4da683dca92e3b1355490fed5f313b768500084fbe6371fddfdb79", size = 42507, upload-time = "2025-10-06T05:37:54.513Z" }, + { url = "https://files.pythonhosted.org/packages/9a/9a/e35b4a917281c0b8419d4207f4334c8e8c5dbf4f3f5f9ada73958d937dcc/frozenlist-1.8.0-py3-none-any.whl", hash = "sha256:0c18a16eab41e82c295618a77502e17b195883241c563b00f0aa5106fc4eaa0d", size = 13409, upload-time = "2025-10-06T05:38:16.721Z" }, +] + +[[package]] +name = "fsspec" +version = "2025.10.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/24/7f/2747c0d332b9acfa75dc84447a066fdf812b5a6b8d30472b74d309bfe8cb/fsspec-2025.10.0.tar.gz", hash = "sha256:b6789427626f068f9a83ca4e8a3cc050850b6c0f71f99ddb4f542b8266a26a59", size = 309285, upload-time = "2025-10-30T14:58:44.036Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/eb/02/a6b21098b1d5d6249b7c5ab69dde30108a71e4e819d4a9778f1de1d5b70d/fsspec-2025.10.0-py3-none-any.whl", hash = "sha256:7c7712353ae7d875407f97715f0e1ffcc21e33d5b24556cb1e090ae9409ec61d", size = 200966, upload-time = "2025-10-30T14:58:42.53Z" }, +] + +[package.optional-dependencies] +http = [ + { name = "aiohttp" }, +] + +[[package]] +name = "gcsfs" +version = "2025.10.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "aiohttp" }, + { name = "decorator" }, + { name = "fsspec" }, + { name = "google-auth" }, + { name = "google-auth-oauthlib" }, + { name = "google-cloud-storage" }, + { name = "requests" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/27/62/e3131f4cb0e0a9b8d5a0586ba2cbef3a5ec05b5352d9bad50e1eb1417fed/gcsfs-2025.10.0.tar.gz", hash = "sha256:7ac9b16a145bcb1a69fa9cf770ccd3cee7b9a09236911dd586c1d9911b71583d", size = 85595, upload-time = "2025-10-30T15:16:30.08Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7d/f3/393d486f33bf78ce8af4ced1814e936d0e71c630e8d98c1257a06e511c9a/gcsfs-2025.10.0-py2.py3-none-any.whl", hash = "sha256:654457af3a524e03d86658c5d8c6f3887689d6aa0c2c6b1c3b2d8e1fe2b77c09", size = 36911, upload-time = "2025-10-30T15:16:29.044Z" }, +] + +[[package]] +name = "gitdb" +version = "4.0.12" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "smmap" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/72/94/63b0fc47eb32792c7ba1fe1b694daec9a63620db1e313033d18140c2320a/gitdb-4.0.12.tar.gz", hash = "sha256:5ef71f855d191a3326fcfbc0d5da835f26b13fbcba60c32c21091c349ffdb571", size = 394684, upload-time = "2025-01-02T07:20:46.413Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a0/61/5c78b91c3143ed5c14207f463aecfc8f9dbb5092fb2869baf37c273b2705/gitdb-4.0.12-py3-none-any.whl", hash = "sha256:67073e15955400952c6565cc3e707c554a4eea2e428946f7a4c162fab9bd9bcf", size = 62794, upload-time = "2025-01-02T07:20:43.624Z" }, +] + +[[package]] +name = "gitpython" +version = "3.1.45" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "gitdb" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9a/c8/dd58967d119baab745caec2f9d853297cec1989ec1d63f677d3880632b88/gitpython-3.1.45.tar.gz", hash = "sha256:85b0ee964ceddf211c41b9f27a49086010a190fd8132a24e21f362a4b36a791c", size = 215076, upload-time = "2025-07-24T03:45:54.871Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/01/61/d4b89fec821f72385526e1b9d9a3a0385dda4a72b206d28049e2c7cd39b8/gitpython-3.1.45-py3-none-any.whl", hash = "sha256:8908cb2e02fb3b93b7eb0f2827125cb699869470432cc885f019b8fd0fccff77", size = 208168, upload-time = "2025-07-24T03:45:52.517Z" }, +] + +[[package]] +name = "google-api-core" +version = "2.28.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "google-auth" }, + { name = "googleapis-common-protos" }, + { name = "proto-plus" }, + { name = "protobuf" }, + { name = "requests" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/61/da/83d7043169ac2c8c7469f0e375610d78ae2160134bf1b80634c482fa079c/google_api_core-2.28.1.tar.gz", hash = "sha256:2b405df02d68e68ce0fbc138559e6036559e685159d148ae5861013dc201baf8", size = 176759, upload-time = "2025-10-28T21:34:51.529Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ed/d4/90197b416cb61cefd316964fd9e7bd8324bcbafabf40eef14a9f20b81974/google_api_core-2.28.1-py3-none-any.whl", hash = "sha256:4021b0f8ceb77a6fb4de6fde4502cecab45062e66ff4f2895169e0b35bc9466c", size = 173706, upload-time = "2025-10-28T21:34:50.151Z" }, +] + +[[package]] +name = "google-auth" +version = "2.43.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cachetools" }, + { name = "pyasn1-modules" }, + { name = "rsa" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ff/ef/66d14cf0e01b08d2d51ffc3c20410c4e134a1548fc246a6081eae585a4fe/google_auth-2.43.0.tar.gz", hash = "sha256:88228eee5fc21b62a1b5fe773ca15e67778cb07dc8363adcb4a8827b52d81483", size = 296359, upload-time = "2025-11-06T00:13:36.587Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6f/d1/385110a9ae86d91cc14c5282c61fe9f4dc41c0b9f7d423c6ad77038c4448/google_auth-2.43.0-py2.py3-none-any.whl", hash = "sha256:af628ba6fa493f75c7e9dbe9373d148ca9f4399b5ea29976519e0a3848eddd16", size = 223114, upload-time = "2025-11-06T00:13:35.209Z" }, +] + +[[package]] +name = "google-auth-oauthlib" +version = "1.2.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "google-auth" }, + { name = "requests-oauthlib" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/fb/87/e10bf24f7bcffc1421b84d6f9c3377c30ec305d082cd737ddaa6d8f77f7c/google_auth_oauthlib-1.2.2.tar.gz", hash = "sha256:11046fb8d3348b296302dd939ace8af0a724042e8029c1b872d87fabc9f41684", size = 20955, upload-time = "2025-04-22T16:40:29.172Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ac/84/40ee070be95771acd2f4418981edb834979424565c3eec3cd88b6aa09d24/google_auth_oauthlib-1.2.2-py3-none-any.whl", hash = "sha256:fd619506f4b3908b5df17b65f39ca8d66ea56986e5472eb5978fd8f3786f00a2", size = 19072, upload-time = "2025-04-22T16:40:28.174Z" }, +] + +[[package]] +name = "google-cloud-core" +version = "2.5.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "google-api-core" }, + { name = "google-auth" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a6/03/ef0bc99d0e0faf4fdbe67ac445e18cdaa74824fd93cd069e7bb6548cb52d/google_cloud_core-2.5.0.tar.gz", hash = "sha256:7c1b7ef5c92311717bd05301aa1a91ffbc565673d3b0b4163a52d8413a186963", size = 36027, upload-time = "2025-10-29T23:17:39.513Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/89/20/bfa472e327c8edee00f04beecc80baeddd2ab33ee0e86fd7654da49d45e9/google_cloud_core-2.5.0-py3-none-any.whl", hash = "sha256:67d977b41ae6c7211ee830c7912e41003ea8194bff15ae7d72fd6f51e57acabc", size = 29469, upload-time = "2025-10-29T23:17:38.548Z" }, +] + +[[package]] +name = "google-cloud-storage" +version = "3.6.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "google-api-core" }, + { name = "google-auth" }, + { name = "google-cloud-core" }, + { name = "google-crc32c" }, + { name = "google-resumable-media" }, + { name = "requests" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f4/cd/7e112cf025b2b591067b599e4bfe965df0c12b0cc0afdb5556469bff126d/google_cloud_storage-3.6.0.tar.gz", hash = "sha256:29cc6b9a6c0fc9cdad071e375d540a5a50fbc9a7fad8300fa02fb904f6fe2ca2", size = 17251072, upload-time = "2025-11-17T10:18:29.81Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ae/ef/3b57bf617ee0c79450c1ff211d1eb888db8fc1050ac74b3e52cc6ed86e63/google_cloud_storage-3.6.0-py3-none-any.whl", hash = "sha256:5decbdddd63b7d1fc3e266a393ad6453d2e27d172bd982b1e2f15481668db097", size = 299039, upload-time = "2025-11-17T10:18:27.66Z" }, +] + +[[package]] +name = "google-crc32c" +version = "1.7.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/19/ae/87802e6d9f9d69adfaedfcfd599266bf386a54d0be058b532d04c794f76d/google_crc32c-1.7.1.tar.gz", hash = "sha256:2bff2305f98846f3e825dbeec9ee406f89da7962accdb29356e4eadc251bd472", size = 14495, upload-time = "2025-03-26T14:29:13.32Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/eb/69/b1b05cf415df0d86691d6a8b4b7e60ab3a6fb6efb783ee5cd3ed1382bfd3/google_crc32c-1.7.1-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:b07d48faf8292b4db7c3d64ab86f950c2e94e93a11fd47271c28ba458e4a0d76", size = 30467, upload-time = "2025-03-26T14:31:11.92Z" }, + { url = "https://files.pythonhosted.org/packages/44/3d/92f8928ecd671bd5b071756596971c79d252d09b835cdca5a44177fa87aa/google_crc32c-1.7.1-cp310-cp310-macosx_12_0_x86_64.whl", hash = "sha256:7cc81b3a2fbd932a4313eb53cc7d9dde424088ca3a0337160f35d91826880c1d", size = 30311, upload-time = "2025-03-26T14:53:14.161Z" }, + { url = "https://files.pythonhosted.org/packages/33/42/c2d15a73df79d45ed6b430b9e801d0bd8e28ac139a9012d7d58af50a385d/google_crc32c-1.7.1-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:1c67ca0a1f5b56162951a9dae987988679a7db682d6f97ce0f6381ebf0fbea4c", size = 37889, upload-time = "2025-03-26T14:41:27.83Z" }, + { url = "https://files.pythonhosted.org/packages/57/ea/ac59c86a3c694afd117bb669bde32aaf17d0de4305d01d706495f09cbf19/google_crc32c-1.7.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fc5319db92daa516b653600794d5b9f9439a9a121f3e162f94b0e1891c7933cb", size = 33028, upload-time = "2025-03-26T14:41:29.141Z" }, + { url = "https://files.pythonhosted.org/packages/60/44/87e77e8476767a4a93f6cf271157c6d948eacec63688c093580af13b04be/google_crc32c-1.7.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dcdf5a64adb747610140572ed18d011896e3b9ae5195f2514b7ff678c80f1603", size = 38026, upload-time = "2025-03-26T14:41:29.921Z" }, + { url = "https://files.pythonhosted.org/packages/c8/bf/21ac7bb305cd7c1a6de9c52f71db0868e104a5b573a4977cd9d0ff830f82/google_crc32c-1.7.1-cp310-cp310-win_amd64.whl", hash = "sha256:754561c6c66e89d55754106739e22fdaa93fafa8da7221b29c8b8e8270c6ec8a", size = 33476, upload-time = "2025-03-26T14:29:09.086Z" }, + { url = "https://files.pythonhosted.org/packages/f7/94/220139ea87822b6fdfdab4fb9ba81b3fff7ea2c82e2af34adc726085bffc/google_crc32c-1.7.1-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:6fbab4b935989e2c3610371963ba1b86afb09537fd0c633049be82afe153ac06", size = 30468, upload-time = "2025-03-26T14:32:52.215Z" }, + { url = "https://files.pythonhosted.org/packages/94/97/789b23bdeeb9d15dc2904660463ad539d0318286d7633fe2760c10ed0c1c/google_crc32c-1.7.1-cp311-cp311-macosx_12_0_x86_64.whl", hash = "sha256:ed66cbe1ed9cbaaad9392b5259b3eba4a9e565420d734e6238813c428c3336c9", size = 30313, upload-time = "2025-03-26T14:57:38.758Z" }, + { url = "https://files.pythonhosted.org/packages/81/b8/976a2b843610c211e7ccb3e248996a61e87dbb2c09b1499847e295080aec/google_crc32c-1.7.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ee6547b657621b6cbed3562ea7826c3e11cab01cd33b74e1f677690652883e77", size = 33048, upload-time = "2025-03-26T14:41:30.679Z" }, + { url = "https://files.pythonhosted.org/packages/c9/16/a3842c2cf591093b111d4a5e2bfb478ac6692d02f1b386d2a33283a19dc9/google_crc32c-1.7.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d68e17bad8f7dd9a49181a1f5a8f4b251c6dbc8cc96fb79f1d321dfd57d66f53", size = 32669, upload-time = "2025-03-26T14:41:31.432Z" }, + { url = "https://files.pythonhosted.org/packages/04/17/ed9aba495916fcf5fe4ecb2267ceb851fc5f273c4e4625ae453350cfd564/google_crc32c-1.7.1-cp311-cp311-win_amd64.whl", hash = "sha256:6335de12921f06e1f774d0dd1fbea6bf610abe0887a1638f64d694013138be5d", size = 33476, upload-time = "2025-03-26T14:29:10.211Z" }, + { url = "https://files.pythonhosted.org/packages/dd/b7/787e2453cf8639c94b3d06c9d61f512234a82e1d12d13d18584bd3049904/google_crc32c-1.7.1-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:2d73a68a653c57281401871dd4aeebbb6af3191dcac751a76ce430df4d403194", size = 30470, upload-time = "2025-03-26T14:34:31.655Z" }, + { url = "https://files.pythonhosted.org/packages/ed/b4/6042c2b0cbac3ec3a69bb4c49b28d2f517b7a0f4a0232603c42c58e22b44/google_crc32c-1.7.1-cp312-cp312-macosx_12_0_x86_64.whl", hash = "sha256:22beacf83baaf59f9d3ab2bbb4db0fb018da8e5aebdce07ef9f09fce8220285e", size = 30315, upload-time = "2025-03-26T15:01:54.634Z" }, + { url = "https://files.pythonhosted.org/packages/29/ad/01e7a61a5d059bc57b702d9ff6a18b2585ad97f720bd0a0dbe215df1ab0e/google_crc32c-1.7.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:19eafa0e4af11b0a4eb3974483d55d2d77ad1911e6cf6f832e1574f6781fd337", size = 33180, upload-time = "2025-03-26T14:41:32.168Z" }, + { url = "https://files.pythonhosted.org/packages/3b/a5/7279055cf004561894ed3a7bfdf5bf90a53f28fadd01af7cd166e88ddf16/google_crc32c-1.7.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b6d86616faaea68101195c6bdc40c494e4d76f41e07a37ffdef270879c15fb65", size = 32794, upload-time = "2025-03-26T14:41:33.264Z" }, + { url = "https://files.pythonhosted.org/packages/0f/d6/77060dbd140c624e42ae3ece3df53b9d811000729a5c821b9fd671ceaac6/google_crc32c-1.7.1-cp312-cp312-win_amd64.whl", hash = "sha256:b7491bdc0c7564fcf48c0179d2048ab2f7c7ba36b84ccd3a3e1c3f7a72d3bba6", size = 33477, upload-time = "2025-03-26T14:29:10.94Z" }, + { url = "https://files.pythonhosted.org/packages/8b/72/b8d785e9184ba6297a8620c8a37cf6e39b81a8ca01bb0796d7cbb28b3386/google_crc32c-1.7.1-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:df8b38bdaf1629d62d51be8bdd04888f37c451564c2042d36e5812da9eff3c35", size = 30467, upload-time = "2025-03-26T14:36:06.909Z" }, + { url = "https://files.pythonhosted.org/packages/34/25/5f18076968212067c4e8ea95bf3b69669f9fc698476e5f5eb97d5b37999f/google_crc32c-1.7.1-cp313-cp313-macosx_12_0_x86_64.whl", hash = "sha256:e42e20a83a29aa2709a0cf271c7f8aefaa23b7ab52e53b322585297bb94d4638", size = 30309, upload-time = "2025-03-26T15:06:15.318Z" }, + { url = "https://files.pythonhosted.org/packages/92/83/9228fe65bf70e93e419f38bdf6c5ca5083fc6d32886ee79b450ceefd1dbd/google_crc32c-1.7.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:905a385140bf492ac300026717af339790921f411c0dfd9aa5a9e69a08ed32eb", size = 33133, upload-time = "2025-03-26T14:41:34.388Z" }, + { url = "https://files.pythonhosted.org/packages/c3/ca/1ea2fd13ff9f8955b85e7956872fdb7050c4ace8a2306a6d177edb9cf7fe/google_crc32c-1.7.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6b211ddaf20f7ebeec5c333448582c224a7c90a9d98826fbab82c0ddc11348e6", size = 32773, upload-time = "2025-03-26T14:41:35.19Z" }, + { url = "https://files.pythonhosted.org/packages/89/32/a22a281806e3ef21b72db16f948cad22ec68e4bdd384139291e00ff82fe2/google_crc32c-1.7.1-cp313-cp313-win_amd64.whl", hash = "sha256:0f99eaa09a9a7e642a61e06742856eec8b19fc0037832e03f941fe7cf0c8e4db", size = 33475, upload-time = "2025-03-26T14:29:11.771Z" }, + { url = "https://files.pythonhosted.org/packages/b8/c5/002975aff514e57fc084ba155697a049b3f9b52225ec3bc0f542871dd524/google_crc32c-1.7.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:32d1da0d74ec5634a05f53ef7df18fc646666a25efaaca9fc7dcfd4caf1d98c3", size = 33243, upload-time = "2025-03-26T14:41:35.975Z" }, + { url = "https://files.pythonhosted.org/packages/61/cb/c585282a03a0cea70fcaa1bf55d5d702d0f2351094d663ec3be1c6c67c52/google_crc32c-1.7.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e10554d4abc5238823112c2ad7e4560f96c7bf3820b202660373d769d9e6e4c9", size = 32870, upload-time = "2025-03-26T14:41:37.08Z" }, + { url = "https://files.pythonhosted.org/packages/0b/43/31e57ce04530794917dfe25243860ec141de9fadf4aa9783dffe7dac7c39/google_crc32c-1.7.1-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a8e9afc74168b0b2232fb32dd202c93e46b7d5e4bf03e66ba5dc273bb3559589", size = 28242, upload-time = "2025-03-26T14:41:42.858Z" }, + { url = "https://files.pythonhosted.org/packages/eb/f3/8b84cd4e0ad111e63e30eb89453f8dd308e3ad36f42305cf8c202461cdf0/google_crc32c-1.7.1-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fa8136cc14dd27f34a3221c0f16fd42d8a40e4778273e61a3c19aedaa44daf6b", size = 28049, upload-time = "2025-03-26T14:41:44.651Z" }, + { url = "https://files.pythonhosted.org/packages/16/1b/1693372bf423ada422f80fd88260dbfd140754adb15cbc4d7e9a68b1cb8e/google_crc32c-1.7.1-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:85fef7fae11494e747c9fd1359a527e5970fc9603c90764843caabd3a16a0a48", size = 28241, upload-time = "2025-03-26T14:41:45.898Z" }, + { url = "https://files.pythonhosted.org/packages/fd/3c/2a19a60a473de48717b4efb19398c3f914795b64a96cf3fbe82588044f78/google_crc32c-1.7.1-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6efb97eb4369d52593ad6f75e7e10d053cf00c48983f7a973105bc70b0ac4d82", size = 28048, upload-time = "2025-03-26T14:41:46.696Z" }, +] + +[[package]] +name = "google-resumable-media" +version = "2.8.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "google-crc32c" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/64/d7/520b62a35b23038ff005e334dba3ffc75fcf583bee26723f1fd8fd4b6919/google_resumable_media-2.8.0.tar.gz", hash = "sha256:f1157ed8b46994d60a1bc432544db62352043113684d4e030ee02e77ebe9a1ae", size = 2163265, upload-time = "2025-11-17T15:38:06.659Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1f/0b/93afde9cfe012260e9fe1522f35c9b72d6ee222f316586b1f23ecf44d518/google_resumable_media-2.8.0-py3-none-any.whl", hash = "sha256:dd14a116af303845a8d932ddae161a26e86cc229645bc98b39f026f9b1717582", size = 81340, upload-time = "2025-11-17T15:38:05.594Z" }, +] + +[[package]] +name = "googleapis-common-protos" +version = "1.72.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "protobuf" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e5/7b/adfd75544c415c487b33061fe7ae526165241c1ea133f9a9125a56b39fd8/googleapis_common_protos-1.72.0.tar.gz", hash = "sha256:e55a601c1b32b52d7a3e65f43563e2aa61bcd737998ee672ac9b951cd49319f5", size = 147433, upload-time = "2025-11-06T18:29:24.087Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c4/ab/09169d5a4612a5f92490806649ac8d41e3ec9129c636754575b3553f4ea4/googleapis_common_protos-1.72.0-py3-none-any.whl", hash = "sha256:4299c5a82d5ae1a9702ada957347726b167f9f8d1fc352477702a1e851ff4038", size = 297515, upload-time = "2025-11-06T18:29:13.14Z" }, +] + +[[package]] +name = "graphviz" +version = "0.21" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f8/b3/3ac91e9be6b761a4b30d66ff165e54439dcd48b83f4e20d644867215f6ca/graphviz-0.21.tar.gz", hash = "sha256:20743e7183be82aaaa8ad6c93f8893c923bd6658a04c32ee115edb3c8a835f78", size = 200434, upload-time = "2025-06-15T09:35:05.824Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/91/4c/e0ce1ef95d4000ebc1c11801f9b944fa5910ecc15b5e351865763d8657f8/graphviz-0.21-py3-none-any.whl", hash = "sha256:54f33de9f4f911d7e84e4191749cac8cc5653f815b06738c54db9a15ab8b1e42", size = 47300, upload-time = "2025-06-15T09:35:04.433Z" }, +] + +[[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 = "h2" +version = "4.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "hpack" }, + { name = "hyperframe" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/1d/17/afa56379f94ad0fe8defd37d6eb3f89a25404ffc71d4d848893d270325fc/h2-4.3.0.tar.gz", hash = "sha256:6c59efe4323fa18b47a632221a1888bd7fde6249819beda254aeca909f221bf1", size = 2152026, upload-time = "2025-08-23T18:12:19.778Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/69/b2/119f6e6dcbd96f9069ce9a2665e0146588dc9f88f29549711853645e736a/h2-4.3.0-py3-none-any.whl", hash = "sha256:c438f029a25f7945c69e0ccf0fb951dc3f73a5f6412981daee861431b70e2bdd", size = 61779, upload-time = "2025-08-23T18:12:17.779Z" }, +] + +[[package]] +name = "hf-xet" +version = "1.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5e/6e/0f11bacf08a67f7fb5ee09740f2ca54163863b07b70d579356e9222ce5d8/hf_xet-1.2.0.tar.gz", hash = "sha256:a8c27070ca547293b6890c4bf389f713f80e8c478631432962bb7f4bc0bd7d7f", size = 506020, upload-time = "2025-10-24T19:04:32.129Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/a5/85ef910a0aa034a2abcfadc360ab5ac6f6bc4e9112349bd40ca97551cff0/hf_xet-1.2.0-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:ceeefcd1b7aed4956ae8499e2199607765fbd1c60510752003b6cc0b8413b649", size = 2861870, upload-time = "2025-10-24T19:04:11.422Z" }, + { url = "https://files.pythonhosted.org/packages/ea/40/e2e0a7eb9a51fe8828ba2d47fe22a7e74914ea8a0db68a18c3aa7449c767/hf_xet-1.2.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:b70218dd548e9840224df5638fdc94bd033552963cfa97f9170829381179c813", size = 2717584, upload-time = "2025-10-24T19:04:09.586Z" }, + { url = "https://files.pythonhosted.org/packages/a5/7d/daf7f8bc4594fdd59a8a596f9e3886133fdc68e675292218a5e4c1b7e834/hf_xet-1.2.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7d40b18769bb9a8bc82a9ede575ce1a44c75eb80e7375a01d76259089529b5dc", size = 3315004, upload-time = "2025-10-24T19:04:00.314Z" }, + { url = "https://files.pythonhosted.org/packages/b1/ba/45ea2f605fbf6d81c8b21e4d970b168b18a53515923010c312c06cd83164/hf_xet-1.2.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:cd3a6027d59cfb60177c12d6424e31f4b5ff13d8e3a1247b3a584bf8977e6df5", size = 3222636, upload-time = "2025-10-24T19:03:58.111Z" }, + { url = "https://files.pythonhosted.org/packages/4a/1d/04513e3cab8f29ab8c109d309ddd21a2705afab9d52f2ba1151e0c14f086/hf_xet-1.2.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:6de1fc44f58f6dd937956c8d304d8c2dea264c80680bcfa61ca4a15e7b76780f", size = 3408448, upload-time = "2025-10-24T19:04:20.951Z" }, + { url = "https://files.pythonhosted.org/packages/f0/7c/60a2756d7feec7387db3a1176c632357632fbe7849fce576c5559d4520c7/hf_xet-1.2.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:f182f264ed2acd566c514e45da9f2119110e48a87a327ca271027904c70c5832", size = 3503401, upload-time = "2025-10-24T19:04:22.549Z" }, + { url = "https://files.pythonhosted.org/packages/4e/64/48fffbd67fb418ab07451e4ce641a70de1c40c10a13e25325e24858ebe5a/hf_xet-1.2.0-cp313-cp313t-win_amd64.whl", hash = "sha256:293a7a3787e5c95d7be1857358a9130694a9c6021de3f27fa233f37267174382", size = 2900866, upload-time = "2025-10-24T19:04:33.461Z" }, + { url = "https://files.pythonhosted.org/packages/e2/51/f7e2caae42f80af886db414d4e9885fac959330509089f97cccb339c6b87/hf_xet-1.2.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:10bfab528b968c70e062607f663e21e34e2bba349e8038db546646875495179e", size = 2861861, upload-time = "2025-10-24T19:04:19.01Z" }, + { url = "https://files.pythonhosted.org/packages/6e/1d/a641a88b69994f9371bd347f1dd35e5d1e2e2460a2e350c8d5165fc62005/hf_xet-1.2.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:2a212e842647b02eb6a911187dc878e79c4aa0aa397e88dd3b26761676e8c1f8", size = 2717699, upload-time = "2025-10-24T19:04:17.306Z" }, + { url = "https://files.pythonhosted.org/packages/df/e0/e5e9bba7d15f0318955f7ec3f4af13f92e773fbb368c0b8008a5acbcb12f/hf_xet-1.2.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:30e06daccb3a7d4c065f34fc26c14c74f4653069bb2b194e7f18f17cbe9939c0", size = 3314885, upload-time = "2025-10-24T19:04:07.642Z" }, + { url = "https://files.pythonhosted.org/packages/21/90/b7fe5ff6f2b7b8cbdf1bd56145f863c90a5807d9758a549bf3d916aa4dec/hf_xet-1.2.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:29c8fc913a529ec0a91867ce3d119ac1aac966e098cf49501800c870328cc090", size = 3221550, upload-time = "2025-10-24T19:04:05.55Z" }, + { url = "https://files.pythonhosted.org/packages/6f/cb/73f276f0a7ce46cc6a6ec7d6c7d61cbfe5f2e107123d9bbd0193c355f106/hf_xet-1.2.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e159cbfcfbb29f920db2c09ed8b660eb894640d284f102ada929b6e3dc410a", size = 3408010, upload-time = "2025-10-24T19:04:28.598Z" }, + { url = "https://files.pythonhosted.org/packages/b8/1e/d642a12caa78171f4be64f7cd9c40e3ca5279d055d0873188a58c0f5fbb9/hf_xet-1.2.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:9c91d5ae931510107f148874e9e2de8a16052b6f1b3ca3c1b12f15ccb491390f", size = 3503264, upload-time = "2025-10-24T19:04:30.397Z" }, + { url = "https://files.pythonhosted.org/packages/17/b5/33764714923fa1ff922770f7ed18c2daae034d21ae6e10dbf4347c854154/hf_xet-1.2.0-cp314-cp314t-win_amd64.whl", hash = "sha256:210d577732b519ac6ede149d2f2f34049d44e8622bf14eb3d63bbcd2d4b332dc", size = 2901071, upload-time = "2025-10-24T19:04:37.463Z" }, + { url = "https://files.pythonhosted.org/packages/96/2d/22338486473df5923a9ab7107d375dbef9173c338ebef5098ef593d2b560/hf_xet-1.2.0-cp37-abi3-macosx_10_12_x86_64.whl", hash = "sha256:46740d4ac024a7ca9b22bebf77460ff43332868b661186a8e46c227fdae01848", size = 2866099, upload-time = "2025-10-24T19:04:15.366Z" }, + { url = "https://files.pythonhosted.org/packages/7f/8c/c5becfa53234299bc2210ba314eaaae36c2875e0045809b82e40a9544f0c/hf_xet-1.2.0-cp37-abi3-macosx_11_0_arm64.whl", hash = "sha256:27df617a076420d8845bea087f59303da8be17ed7ec0cd7ee3b9b9f579dff0e4", size = 2722178, upload-time = "2025-10-24T19:04:13.695Z" }, + { url = "https://files.pythonhosted.org/packages/9a/92/cf3ab0b652b082e66876d08da57fcc6fa2f0e6c70dfbbafbd470bb73eb47/hf_xet-1.2.0-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3651fd5bfe0281951b988c0facbe726aa5e347b103a675f49a3fa8144c7968fd", size = 3320214, upload-time = "2025-10-24T19:04:03.596Z" }, + { url = "https://files.pythonhosted.org/packages/46/92/3f7ec4a1b6a65bf45b059b6d4a5d38988f63e193056de2f420137e3c3244/hf_xet-1.2.0-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:d06fa97c8562fb3ee7a378dd9b51e343bc5bc8190254202c9771029152f5e08c", size = 3229054, upload-time = "2025-10-24T19:04:01.949Z" }, + { url = "https://files.pythonhosted.org/packages/0b/dd/7ac658d54b9fb7999a0ccb07ad863b413cbaf5cf172f48ebcd9497ec7263/hf_xet-1.2.0-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:4c1428c9ae73ec0939410ec73023c4f842927f39db09b063b9482dac5a3bb737", size = 3413812, upload-time = "2025-10-24T19:04:24.585Z" }, + { url = "https://files.pythonhosted.org/packages/92/68/89ac4e5b12a9ff6286a12174c8538a5930e2ed662091dd2572bbe0a18c8a/hf_xet-1.2.0-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:a55558084c16b09b5ed32ab9ed38421e2d87cf3f1f89815764d1177081b99865", size = 3508920, upload-time = "2025-10-24T19:04:26.927Z" }, + { url = "https://files.pythonhosted.org/packages/cb/44/870d44b30e1dcfb6a65932e3e1506c103a8a5aea9103c337e7a53180322c/hf_xet-1.2.0-cp37-abi3-win_amd64.whl", hash = "sha256:e6584a52253f72c9f52f9e549d5895ca7a471608495c4ecaa6cc73dba2b24d69", size = 2905735, upload-time = "2025-10-24T19:04:35.928Z" }, +] + +[[package]] +name = "hpack" +version = "4.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/2c/48/71de9ed269fdae9c8057e5a4c0aa7402e8bb16f2c6e90b3aa53327b113f8/hpack-4.1.0.tar.gz", hash = "sha256:ec5eca154f7056aa06f196a557655c5b009b382873ac8d1e66e79e87535f1dca", size = 51276, upload-time = "2025-01-22T21:44:58.347Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/07/c6/80c95b1b2b94682a72cbdbfb85b81ae2daffa4291fbfa1b1464502ede10d/hpack-4.1.0-py3-none-any.whl", hash = "sha256:157ac792668d995c657d93111f46b4535ed114f0c9c8d672271bbec7eae1b496", size = 34357, upload-time = "2025-01-22T21:44:56.92Z" }, +] + +[[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 = "httpx" +version = "0.27.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "certifi" }, + { name = "httpcore" }, + { name = "idna" }, + { name = "sniffio" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/78/82/08f8c936781f67d9e6b9eeb8a0c8b4e406136ea4c3d1f89a5db71d42e0e6/httpx-0.27.2.tar.gz", hash = "sha256:f7c2be1d2f3c3c3160d441802406b206c2b76f5947b11115e6df10c6c65e66c2", size = 144189, upload-time = "2024-08-27T12:54:01.334Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/56/95/9377bcb415797e44274b51d46e3249eba641711cf3348050f76ee7b15ffc/httpx-0.27.2-py3-none-any.whl", hash = "sha256:7bb2708e112d8fdd7829cd4243970f0c223274051cb35ee80c03301ee29a3df0", size = 76395, upload-time = "2024-08-27T12:53:59.653Z" }, +] + +[package.optional-dependencies] +http2 = [ + { name = "h2" }, +] + +[[package]] +name = "huggingface-hub" +version = "0.36.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "filelock" }, + { name = "fsspec" }, + { name = "hf-xet", marker = "platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'arm64' or platform_machine == 'x86_64'" }, + { name = "packaging" }, + { name = "pyyaml" }, + { name = "requests" }, + { name = "tqdm" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/98/63/4910c5fa9128fdadf6a9c5ac138e8b1b6cee4ca44bf7915bbfbce4e355ee/huggingface_hub-0.36.0.tar.gz", hash = "sha256:47b3f0e2539c39bf5cde015d63b72ec49baff67b6931c3d97f3f84532e2b8d25", size = 463358, upload-time = "2025-10-23T12:12:01.413Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cb/bd/1a875e0d592d447cbc02805fd3fe0f497714d6a2583f59d14fa9ebad96eb/huggingface_hub-0.36.0-py3-none-any.whl", hash = "sha256:7bcc9ad17d5b3f07b57c78e79d527102d08313caa278a641993acddcb894548d", size = 566094, upload-time = "2025-10-23T12:11:59.557Z" }, +] + +[[package]] +name = "hyperframe" +version = "6.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/02/e7/94f8232d4a74cc99514c13a9f995811485a6903d48e5d952771ef6322e30/hyperframe-6.1.0.tar.gz", hash = "sha256:f630908a00854a7adeabd6382b43923a4c4cd4b821fcb527e6ab9e15382a3b08", size = 26566, upload-time = "2025-01-22T21:41:49.302Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/48/30/47d0bf6072f7252e6521f3447ccfa40b421b6824517f82854703d0f5a98b/hyperframe-6.1.0-py3-none-any.whl", hash = "sha256:b03380493a519fce58ea5af42e4a42317bf9bd425596f7a0835ffce80f1a42e5", size = 13007, upload-time = "2025-01-22T21:41:47.295Z" }, +] + +[[package]] +name = "idna" +version = "3.11" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/0703ccc57f3a7233505399edb88de3cbd678da106337b9fcde432b65ed60/idna-3.11.tar.gz", hash = "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902", size = 194582, upload-time = "2025-10-12T14:55:20.501Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008, upload-time = "2025-10-12T14:55:18.883Z" }, +] + +[[package]] +name = "imagesize" +version = "1.4.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a7/84/62473fb57d61e31fef6e36d64a179c8781605429fd927b5dd608c997be31/imagesize-1.4.1.tar.gz", hash = "sha256:69150444affb9cb0d5cc5a92b3676f0b2fb7cd9ae39e947a5e11a36b4497cd4a", size = 1280026, upload-time = "2022-07-01T12:21:05.687Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ff/62/85c4c919272577931d407be5ba5d71c20f0b616d31a0befe0ae45bb79abd/imagesize-1.4.1-py2.py3-none-any.whl", hash = "sha256:0d8d18d08f840c19d0ee7ca1fd82490fdc3729b7ac93f49870406ddde8ef8d8b", size = 8769, upload-time = "2022-07-01T12:21:02.467Z" }, +] + +[[package]] +name = "importlib-metadata" +version = "8.7.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "zipp" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/76/66/650a33bd90f786193e4de4b3ad86ea60b53c89b669a5c7be931fac31cdb0/importlib_metadata-8.7.0.tar.gz", hash = "sha256:d13b81ad223b890aa16c5471f2ac3056cf76c5f10f82d6f9292f0b415f389000", size = 56641, upload-time = "2025-04-27T15:29:01.736Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/20/b0/36bd937216ec521246249be3bf9855081de4c5e06a0c9b4219dbeda50373/importlib_metadata-8.7.0-py3-none-any.whl", hash = "sha256:e5dd1551894c77868a30651cef00984d50e1002d06942a7101d34870c5f02afd", size = 27656, upload-time = "2025-04-27T15:29:00.214Z" }, +] + +[[package]] +name = "iniconfig" +version = "2.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" }, +] + +[[package]] +name = "inquirerpy" +version = "0.3.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pfzy" }, + { name = "prompt-toolkit" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/64/73/7570847b9da026e07053da3bbe2ac7ea6cde6bb2cbd3c7a5a950fa0ae40b/InquirerPy-0.3.4.tar.gz", hash = "sha256:89d2ada0111f337483cb41ae31073108b2ec1e618a49d7110b0d7ade89fc197e", size = 44431, upload-time = "2022-06-27T23:11:20.598Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ce/ff/3b59672c47c6284e8005b42e84ceba13864aa0f39f067c973d1af02f5d91/InquirerPy-0.3.4-py3-none-any.whl", hash = "sha256:c65fdfbac1fa00e3ee4fb10679f4d3ed7a012abf4833910e63c295827fe2a7d4", size = 67677, upload-time = "2022-06-27T23:11:17.723Z" }, +] + +[[package]] +name = "invoke" +version = "2.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/de/bd/b461d3424a24c80490313fd77feeb666ca4f6a28c7e72713e3d9095719b4/invoke-2.2.1.tar.gz", hash = "sha256:515bf49b4a48932b79b024590348da22f39c4942dff991ad1fb8b8baea1be707", size = 304762, upload-time = "2025-10-11T00:36:35.172Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/32/4b/b99e37f88336009971405cbb7630610322ed6fbfa31e1d7ab3fbf3049a2d/invoke-2.2.1-py3-none-any.whl", hash = "sha256:2413bc441b376e5cd3f55bb5d364f973ad8bdd7bf87e53c79de3c11bf3feecc8", size = 160287, upload-time = "2025-10-11T00:36:33.703Z" }, +] + +[[package]] +name = "jinja2" +version = "3.1.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markupsafe" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115, upload-time = "2025-03-05T20:05:02.478Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899, upload-time = "2025-03-05T20:05:00.369Z" }, +] + +[[package]] +name = "jmespath" +version = "1.0.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/00/2a/e867e8531cf3e36b41201936b7fa7ba7b5702dbef42922193f05c8976cd6/jmespath-1.0.1.tar.gz", hash = "sha256:90261b206d6defd58fdd5e85f478bf633a2901798906be2ad389150c5c60edbe", size = 25843, upload-time = "2022-06-17T18:00:12.224Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/31/b4/b9b800c45527aadd64d5b442f9b932b00648617eb5d63d2c7a6587b7cafc/jmespath-1.0.1-py3-none-any.whl", hash = "sha256:02e2e4cc71b5bcab88332eebf907519190dd9e6e82107fa7f83b1003a6252980", size = 20256, upload-time = "2022-06-17T18:00:10.251Z" }, +] + +[[package]] +name = "jsonschema" +version = "4.25.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "attrs" }, + { name = "jsonschema-specifications" }, + { name = "referencing" }, + { name = "rpds-py" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/74/69/f7185de793a29082a9f3c7728268ffb31cb5095131a9c139a74078e27336/jsonschema-4.25.1.tar.gz", hash = "sha256:e4a9655ce0da0c0b67a085847e00a3a51449e1157f4f75e9fb5aa545e122eb85", size = 357342, upload-time = "2025-08-18T17:03:50.038Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bf/9c/8c95d856233c1f82500c2450b8c68576b4cf1c871db3afac5c34ff84e6fd/jsonschema-4.25.1-py3-none-any.whl", hash = "sha256:3fba0169e345c7175110351d456342c364814cfcf3b964ba4587f22915230a63", size = 90040, upload-time = "2025-08-18T17:03:48.373Z" }, +] + +[[package]] +name = "jsonschema-specifications" +version = "2025.9.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "referencing" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/19/74/a633ee74eb36c44aa6d1095e7cc5569bebf04342ee146178e2d36600708b/jsonschema_specifications-2025.9.1.tar.gz", hash = "sha256:b540987f239e745613c7a9176f3edb72b832a4ac465cf02712288397832b5e8d", size = 32855, upload-time = "2025-09-08T01:34:59.186Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/41/45/1a4ed80516f02155c51f51e8cedb3c1902296743db0bbc66608a0db2814f/jsonschema_specifications-2025.9.1-py3-none-any.whl", hash = "sha256:98802fee3a11ee76ecaca44429fda8a41bff98b00a0f2838151b113f210cc6fe", size = 18437, upload-time = "2025-09-08T01:34:57.871Z" }, +] + +[[package]] +name = "ledoc-ui" +version = "0.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d8/e0/26d4b09c9d0dc718d9fd5b2b6ff506335cf2ccb43c85f91d083d7162a026/ledoc-ui-0.1.0.tar.gz", hash = "sha256:4f202c898e6c6219e06c1d77b83e03522872bb38b560c5d9b2bc9b41d73ca5ed", size = 2286587, upload-time = "2024-09-02T07:55:03.027Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/86/ab/6d5317ba39b3ffbf0428d8ee75d63611eb63fbc5fea30398c38e5a50ae6c/ledoc_ui-0.1.0-py3-none-any.whl", hash = "sha256:6ccf50c0d777cdabc7f1adfce716c488eeb1018da0e559b72e31666217ffe935", size = 2298422, upload-time = "2024-09-02T07:55:00.721Z" }, +] + +[[package]] +name = "leptonai" +version = "0.26.7" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "click" }, + { name = "cloudpickle" }, + { name = "contextlib2" }, + { name = "exceptiongroup" }, + { name = "fastapi" }, + { name = "httpx", extra = ["http2"] }, + { name = "huggingface-hub" }, + { name = "ledoc-ui" }, + { name = "loguru" }, + { name = "pillow" }, + { name = "prometheus-fastapi-instrumentator" }, + { name = "pydantic" }, + { name = "python-multipart" }, + { name = "pyyaml" }, + { name = "ray" }, + { name = "requests" }, + { name = "rich" }, + { name = "typing-extensions" }, + { name = "uvicorn" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/c2/4d/2b5ab13294b23326ba1d8ef6ad703b1d9535bf72a0617030ddd6238eb925/leptonai-0.26.7-py3-none-any.whl", hash = "sha256:74996da36bf177d2b148887dd349627ab8cd78b94623d543bc91ed9ad65ba0e2", size = 2452890, upload-time = "2025-11-07T20:07:14.99Z" }, +] + +[[package]] +name = "libcst" +version = "1.8.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pyyaml", marker = "python_full_version != '3.13.*'" }, + { name = "pyyaml-ft", marker = "python_full_version == '3.13.*'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/de/cd/337df968b38d94c5aabd3e1b10630f047a2b345f6e1d4456bd9fe7417537/libcst-1.8.6.tar.gz", hash = "sha256:f729c37c9317126da9475bdd06a7208eb52fcbd180a6341648b45a56b4ba708b", size = 891354, upload-time = "2025-11-03T22:33:30.621Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c4/52/97d5454dee9d014821fe0c88f3dc0e83131b97dd074a4d49537056a75475/libcst-1.8.6-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:a20c5182af04332cc94d8520792befda06d73daf2865e6dddc5161c72ea92cb9", size = 2211698, upload-time = "2025-11-03T22:31:50.117Z" }, + { url = "https://files.pythonhosted.org/packages/6c/a4/d1205985d378164687af3247a9c8f8bdb96278b0686ac98ab951bc6d336a/libcst-1.8.6-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:36473e47cb199b7e6531d653ee6ffed057de1d179301e6c67f651f3af0b499d6", size = 2093104, upload-time = "2025-11-03T22:31:52.189Z" }, + { url = "https://files.pythonhosted.org/packages/9e/de/1338da681b7625b51e584922576d54f1b8db8fc7ff4dc79121afc5d4d2cd/libcst-1.8.6-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:06fc56335a45d61b7c1b856bfab4587b84cfe31e9d6368f60bb3c9129d900f58", size = 2237419, upload-time = "2025-11-03T22:31:53.526Z" }, + { url = "https://files.pythonhosted.org/packages/50/06/ee66f2d83b870534756e593d464d8b33b0914c224dff3a407e0f74dc04e0/libcst-1.8.6-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:6b23d14a7fc0addd9795795763af26b185deb7c456b1e7cc4d5228e69dab5ce8", size = 2300820, upload-time = "2025-11-03T22:31:55.995Z" }, + { url = "https://files.pythonhosted.org/packages/9c/ca/959088729de8e0eac8dd516e4fb8623d8d92bad539060fa85c9e94d418a5/libcst-1.8.6-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:16cfe0cfca5fd840e1fb2c30afb628b023d3085b30c3484a79b61eae9d6fe7ba", size = 2301201, upload-time = "2025-11-03T22:31:57.347Z" }, + { url = "https://files.pythonhosted.org/packages/c2/4c/2a21a8c452436097dfe1da277f738c3517f3f728713f16d84b9a3d67ca8d/libcst-1.8.6-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:455f49a93aea4070132c30ebb6c07c2dea0ba6c1fde5ffde59fc45dbb9cfbe4b", size = 2408213, upload-time = "2025-11-03T22:31:59.221Z" }, + { url = "https://files.pythonhosted.org/packages/3e/26/8f7b671fad38a515bb20b038718fd2221ab658299119ac9bcec56c2ced27/libcst-1.8.6-cp310-cp310-win_amd64.whl", hash = "sha256:72cca15800ffc00ba25788e4626189fe0bc5fe2a0c1cb4294bce2e4df21cc073", size = 2119189, upload-time = "2025-11-03T22:32:00.696Z" }, + { url = "https://files.pythonhosted.org/packages/5b/bf/ffb23a48e27001165cc5c81c5d9b3d6583b21b7f5449109e03a0020b060c/libcst-1.8.6-cp310-cp310-win_arm64.whl", hash = "sha256:6cad63e3a26556b020b634d25a8703b605c0e0b491426b3e6b9e12ed20f09100", size = 2001736, upload-time = "2025-11-03T22:32:02.986Z" }, + { url = "https://files.pythonhosted.org/packages/dc/15/95c2ecadc0fb4af8a7057ac2012a4c0ad5921b9ef1ace6c20006b56d3b5f/libcst-1.8.6-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:3649a813660fbffd7bc24d3f810b1f75ac98bd40d9d6f56d1f0ee38579021073", size = 2211289, upload-time = "2025-11-03T22:32:04.673Z" }, + { url = "https://files.pythonhosted.org/packages/80/c3/7e1107acd5ed15cf60cc07c7bb64498a33042dc4821874aea3ec4942f3cd/libcst-1.8.6-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:0cbe17067055829607c5ba4afa46bfa4d0dd554c0b5a583546e690b7367a29b6", size = 2092927, upload-time = "2025-11-03T22:32:06.209Z" }, + { url = "https://files.pythonhosted.org/packages/c1/ff/0d2be87f67e2841a4a37d35505e74b65991d30693295c46fc0380ace0454/libcst-1.8.6-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:59a7e388c57d21d63722018978a8ddba7b176e3a99bd34b9b84a576ed53f2978", size = 2237002, upload-time = "2025-11-03T22:32:07.559Z" }, + { url = "https://files.pythonhosted.org/packages/69/99/8c4a1b35c7894ccd7d33eae01ac8967122f43da41325223181ca7e4738fe/libcst-1.8.6-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:b6c1248cc62952a3a005792b10cdef2a4e130847be9c74f33a7d617486f7e532", size = 2301048, upload-time = "2025-11-03T22:32:08.869Z" }, + { url = "https://files.pythonhosted.org/packages/9b/8b/d1aa811eacf936cccfb386ae0585aa530ea1221ccf528d67144e041f5915/libcst-1.8.6-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6421a930b028c5ef4a943b32a5a78b7f1bf15138214525a2088f11acbb7d3d64", size = 2300675, upload-time = "2025-11-03T22:32:10.579Z" }, + { url = "https://files.pythonhosted.org/packages/c6/6b/7b65cd41f25a10c1fef2389ddc5c2b2cc23dc4d648083fa3e1aa7e0eeac2/libcst-1.8.6-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:6d8b67874f2188399a71a71731e1ba2d1a2c3173b7565d1cc7ffb32e8fbaba5b", size = 2407934, upload-time = "2025-11-03T22:32:11.856Z" }, + { url = "https://files.pythonhosted.org/packages/c5/8b/401cfff374bb3b785adfad78f05225225767ee190997176b2a9da9ed9460/libcst-1.8.6-cp311-cp311-win_amd64.whl", hash = "sha256:b0d8c364c44ae343937f474b2e492c1040df96d94530377c2f9263fb77096e4f", size = 2119247, upload-time = "2025-11-03T22:32:13.279Z" }, + { url = "https://files.pythonhosted.org/packages/f1/17/085f59eaa044b6ff6bc42148a5449df2b7f0ba567307de7782fe85c39ee2/libcst-1.8.6-cp311-cp311-win_arm64.whl", hash = "sha256:5dcaaebc835dfe5755bc85f9b186fb7e2895dda78e805e577fef1011d51d5a5c", size = 2001774, upload-time = "2025-11-03T22:32:14.647Z" }, + { url = "https://files.pythonhosted.org/packages/0c/3c/93365c17da3d42b055a8edb0e1e99f1c60c776471db6c9b7f1ddf6a44b28/libcst-1.8.6-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:0c13d5bd3d8414a129e9dccaf0e5785108a4441e9b266e1e5e9d1f82d1b943c9", size = 2206166, upload-time = "2025-11-03T22:32:16.012Z" }, + { url = "https://files.pythonhosted.org/packages/1d/cb/7530940e6ac50c6dd6022349721074e19309eb6aa296e942ede2213c1a19/libcst-1.8.6-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f1472eeafd67cdb22544e59cf3bfc25d23dc94058a68cf41f6654ff4fcb92e09", size = 2083726, upload-time = "2025-11-03T22:32:17.312Z" }, + { url = "https://files.pythonhosted.org/packages/1b/cf/7e5eaa8c8f2c54913160671575351d129170db757bb5e4b7faffed022271/libcst-1.8.6-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:089c58e75cb142ec33738a1a4ea7760a28b40c078ab2fd26b270dac7d2633a4d", size = 2235755, upload-time = "2025-11-03T22:32:18.859Z" }, + { url = "https://files.pythonhosted.org/packages/55/54/570ec2b0e9a3de0af9922e3bb1b69a5429beefbc753a7ea770a27ad308bd/libcst-1.8.6-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:c9d7aeafb1b07d25a964b148c0dda9451efb47bbbf67756e16eeae65004b0eb5", size = 2301473, upload-time = "2025-11-03T22:32:20.499Z" }, + { url = "https://files.pythonhosted.org/packages/11/4c/163457d1717cd12181c421a4cca493454bcabd143fc7e53313bc6a4ad82a/libcst-1.8.6-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:207481197afd328aa91d02670c15b48d0256e676ce1ad4bafb6dc2b593cc58f1", size = 2298899, upload-time = "2025-11-03T22:32:21.765Z" }, + { url = "https://files.pythonhosted.org/packages/35/1d/317ddef3669883619ef3d3395ea583305f353ef4ad87d7a5ac1c39be38e3/libcst-1.8.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:375965f34cc6f09f5f809244d3ff9bd4f6cb6699f571121cebce53622e7e0b86", size = 2408239, upload-time = "2025-11-03T22:32:23.275Z" }, + { url = "https://files.pythonhosted.org/packages/9a/a1/f47d8cccf74e212dd6044b9d6dbc223636508da99acff1d54786653196bc/libcst-1.8.6-cp312-cp312-win_amd64.whl", hash = "sha256:da95b38693b989eaa8d32e452e8261cfa77fe5babfef1d8d2ac25af8c4aa7e6d", size = 2119660, upload-time = "2025-11-03T22:32:24.822Z" }, + { url = "https://files.pythonhosted.org/packages/19/d0/dd313bf6a7942cdf951828f07ecc1a7695263f385065edc75ef3016a3cb5/libcst-1.8.6-cp312-cp312-win_arm64.whl", hash = "sha256:bff00e1c766658adbd09a175267f8b2f7616e5ee70ce45db3d7c4ce6d9f6bec7", size = 1999824, upload-time = "2025-11-03T22:32:26.131Z" }, + { url = "https://files.pythonhosted.org/packages/90/01/723cd467ec267e712480c772aacc5aa73f82370c9665162fd12c41b0065b/libcst-1.8.6-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:7445479ebe7d1aff0ee094ab5a1c7718e1ad78d33e3241e1a1ec65dcdbc22ffb", size = 2206386, upload-time = "2025-11-03T22:32:27.422Z" }, + { url = "https://files.pythonhosted.org/packages/17/50/b944944f910f24c094f9b083f76f61e3985af5a376f5342a21e01e2d1a81/libcst-1.8.6-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:4fc3fef8a2c983e7abf5d633e1884c5dd6fa0dcb8f6e32035abd3d3803a3a196", size = 2083945, upload-time = "2025-11-03T22:32:28.847Z" }, + { url = "https://files.pythonhosted.org/packages/36/a1/bd1b2b2b7f153d82301cdaddba787f4a9fc781816df6bdb295ca5f88b7cf/libcst-1.8.6-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:1a3a5e4ee870907aa85a4076c914ae69066715a2741b821d9bf16f9579de1105", size = 2235818, upload-time = "2025-11-03T22:32:30.504Z" }, + { url = "https://files.pythonhosted.org/packages/b9/ab/f5433988acc3b4d188c4bb154e57837df9488cc9ab551267cdeabd3bb5e7/libcst-1.8.6-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:6609291c41f7ad0bac570bfca5af8fea1f4a27987d30a1fa8b67fe5e67e6c78d", size = 2301289, upload-time = "2025-11-03T22:32:31.812Z" }, + { url = "https://files.pythonhosted.org/packages/5d/57/89f4ba7a6f1ac274eec9903a9e9174890d2198266eee8c00bc27eb45ecf7/libcst-1.8.6-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:25eaeae6567091443b5374b4c7d33a33636a2d58f5eda02135e96fc6c8807786", size = 2299230, upload-time = "2025-11-03T22:32:33.242Z" }, + { url = "https://files.pythonhosted.org/packages/f2/36/0aa693bc24cce163a942df49d36bf47a7ed614a0cd5598eee2623bc31913/libcst-1.8.6-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:04030ea4d39d69a65873b1d4d877def1c3951a7ada1824242539e399b8763d30", size = 2408519, upload-time = "2025-11-03T22:32:34.678Z" }, + { url = "https://files.pythonhosted.org/packages/db/18/6dd055b5f15afa640fb3304b2ee9df8b7f72e79513814dbd0a78638f4a0e/libcst-1.8.6-cp313-cp313-win_amd64.whl", hash = "sha256:8066f1b70f21a2961e96bedf48649f27dfd5ea68be5cd1bed3742b047f14acde", size = 2119853, upload-time = "2025-11-03T22:32:36.287Z" }, + { url = "https://files.pythonhosted.org/packages/c9/ed/5ddb2a22f0b0abdd6dcffa40621ada1feaf252a15e5b2733a0a85dfd0429/libcst-1.8.6-cp313-cp313-win_arm64.whl", hash = "sha256:c188d06b583900e662cd791a3f962a8c96d3dfc9b36ea315be39e0a4c4792ebf", size = 1999808, upload-time = "2025-11-03T22:32:38.1Z" }, + { url = "https://files.pythonhosted.org/packages/25/d3/72b2de2c40b97e1ef4a1a1db4e5e52163fc7e7740ffef3846d30bc0096b5/libcst-1.8.6-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:c41c76e034a1094afed7057023b1d8967f968782433f7299cd170eaa01ec033e", size = 2190553, upload-time = "2025-11-03T22:32:39.819Z" }, + { url = "https://files.pythonhosted.org/packages/0d/20/983b7b210ccc3ad94a82db54230e92599c4a11b9cfc7ce3bc97c1d2df75c/libcst-1.8.6-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:5432e785322aba3170352f6e72b32bea58d28abd141ac37cc9b0bf6b7c778f58", size = 2074717, upload-time = "2025-11-03T22:32:41.373Z" }, + { url = "https://files.pythonhosted.org/packages/13/f2/9e01678fedc772e09672ed99930de7355757035780d65d59266fcee212b8/libcst-1.8.6-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:85b7025795b796dea5284d290ff69de5089fc8e989b25d6f6f15b6800be7167f", size = 2225834, upload-time = "2025-11-03T22:32:42.716Z" }, + { url = "https://files.pythonhosted.org/packages/4a/0d/7bed847b5c8c365e9f1953da274edc87577042bee5a5af21fba63276e756/libcst-1.8.6-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:536567441182a62fb706e7aa954aca034827b19746832205953b2c725d254a93", size = 2287107, upload-time = "2025-11-03T22:32:44.549Z" }, + { url = "https://files.pythonhosted.org/packages/02/f0/7e51fa84ade26c518bfbe7e2e4758b56d86a114c72d60309ac0d350426c4/libcst-1.8.6-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:2f04d3672bde1704f383a19e8f8331521abdbc1ed13abb349325a02ac56e5012", size = 2288672, upload-time = "2025-11-03T22:32:45.867Z" }, + { url = "https://files.pythonhosted.org/packages/ad/cd/15762659a3f5799d36aab1bc2b7e732672722e249d7800e3c5f943b41250/libcst-1.8.6-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:7f04febcd70e1e67917be7de513c8d4749d2e09206798558d7fe632134426ea4", size = 2392661, upload-time = "2025-11-03T22:32:47.232Z" }, + { url = "https://files.pythonhosted.org/packages/e4/6b/b7f9246c323910fcbe021241500f82e357521495dcfe419004dbb272c7cb/libcst-1.8.6-cp313-cp313t-win_amd64.whl", hash = "sha256:1dc3b897c8b0f7323412da3f4ad12b16b909150efc42238e19cbf19b561cc330", size = 2105068, upload-time = "2025-11-03T22:32:49.145Z" }, + { url = "https://files.pythonhosted.org/packages/a6/0b/4fd40607bc4807ec2b93b054594373d7fa3d31bb983789901afcb9bcebe9/libcst-1.8.6-cp313-cp313t-win_arm64.whl", hash = "sha256:44f38139fa95e488db0f8976f9c7ca39a64d6bc09f2eceef260aa1f6da6a2e42", size = 1985181, upload-time = "2025-11-03T22:32:50.597Z" }, + { url = "https://files.pythonhosted.org/packages/3a/60/4105441989e321f7ad0fd28ffccb83eb6aac0b7cfb0366dab855dcccfbe5/libcst-1.8.6-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:b188e626ce61de5ad1f95161b8557beb39253de4ec74fc9b1f25593324a0279c", size = 2204202, upload-time = "2025-11-03T22:32:52.311Z" }, + { url = "https://files.pythonhosted.org/packages/67/2f/51a6f285c3a183e50cfe5269d4a533c21625aac2c8de5cdf2d41f079320d/libcst-1.8.6-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:87e74f7d7dfcba9efa91127081e22331d7c42515f0a0ac6e81d4cf2c3ed14661", size = 2083581, upload-time = "2025-11-03T22:32:54.269Z" }, + { url = "https://files.pythonhosted.org/packages/2f/64/921b1c19b638860af76cdb28bc81d430056592910b9478eea49e31a7f47a/libcst-1.8.6-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:3a926a4b42015ee24ddfc8ae940c97bd99483d286b315b3ce82f3bafd9f53474", size = 2236495, upload-time = "2025-11-03T22:32:55.723Z" }, + { url = "https://files.pythonhosted.org/packages/12/a8/b00592f9bede618cbb3df6ffe802fc65f1d1c03d48a10d353b108057d09c/libcst-1.8.6-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:3f4fbb7f569e69fd9e89d9d9caa57ca42c577c28ed05062f96a8c207594e75b8", size = 2301466, upload-time = "2025-11-03T22:32:57.337Z" }, + { url = "https://files.pythonhosted.org/packages/af/df/790d9002f31580fefd0aec2f373a0f5da99070e04c5e8b1c995d0104f303/libcst-1.8.6-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:08bd63a8ce674be431260649e70fca1d43f1554f1591eac657f403ff8ef82c7a", size = 2300264, upload-time = "2025-11-03T22:32:58.852Z" }, + { url = "https://files.pythonhosted.org/packages/21/de/dc3f10e65bab461be5de57850d2910a02c24c3ddb0da28f0e6e4133c3487/libcst-1.8.6-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:e00e275d4ba95d4963431ea3e409aa407566a74ee2bf309a402f84fc744abe47", size = 2408572, upload-time = "2025-11-03T22:33:00.552Z" }, + { url = "https://files.pythonhosted.org/packages/20/3b/35645157a7590891038b077db170d6dd04335cd2e82a63bdaa78c3297dfe/libcst-1.8.6-cp314-cp314-win_amd64.whl", hash = "sha256:fea5c7fa26556eedf277d4f72779c5ede45ac3018650721edd77fd37ccd4a2d4", size = 2193917, upload-time = "2025-11-03T22:33:02.354Z" }, + { url = "https://files.pythonhosted.org/packages/b3/a2/1034a9ba7d3e82f2c2afaad84ba5180f601aed676d92b76325797ad60951/libcst-1.8.6-cp314-cp314-win_arm64.whl", hash = "sha256:bb9b4077bdf8857b2483879cbbf70f1073bc255b057ec5aac8a70d901bb838e9", size = 2078748, upload-time = "2025-11-03T22:33:03.707Z" }, + { url = "https://files.pythonhosted.org/packages/95/a1/30bc61e8719f721a5562f77695e6154e9092d1bdf467aa35d0806dcd6cea/libcst-1.8.6-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:55ec021a296960c92e5a33b8d93e8ad4182b0eab657021f45262510a58223de1", size = 2188980, upload-time = "2025-11-03T22:33:05.152Z" }, + { url = "https://files.pythonhosted.org/packages/2c/14/c660204532407c5628e3b615015a902ed2d0b884b77714a6bdbe73350910/libcst-1.8.6-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ba9ab2b012fbd53b36cafd8f4440a6b60e7e487cd8b87428e57336b7f38409a4", size = 2074828, upload-time = "2025-11-03T22:33:06.864Z" }, + { url = "https://files.pythonhosted.org/packages/82/e2/c497c354943dff644749f177ee9737b09ed811b8fc842b05709a40fe0d1b/libcst-1.8.6-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:c0a0cc80aebd8aa15609dd4d330611cbc05e9b4216bcaeabba7189f99ef07c28", size = 2225568, upload-time = "2025-11-03T22:33:08.354Z" }, + { url = "https://files.pythonhosted.org/packages/86/ef/45999676d07bd6d0eefa28109b4f97124db114e92f9e108de42ba46a8028/libcst-1.8.6-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:42a4f68121e2e9c29f49c97f6154e8527cd31021809cc4a941c7270aa64f41aa", size = 2286523, upload-time = "2025-11-03T22:33:10.206Z" }, + { url = "https://files.pythonhosted.org/packages/f4/6c/517d8bf57d9f811862f4125358caaf8cd3320a01291b3af08f7b50719db4/libcst-1.8.6-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8a434c521fadaf9680788b50d5c21f4048fa85ed19d7d70bd40549fbaeeecab1", size = 2288044, upload-time = "2025-11-03T22:33:11.628Z" }, + { url = "https://files.pythonhosted.org/packages/83/ce/24d7d49478ffb61207f229239879845da40a374965874f5ee60f96b02ddb/libcst-1.8.6-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6a65f844d813ab4ef351443badffa0ae358f98821561d19e18b3190f59e71996", size = 2392605, upload-time = "2025-11-03T22:33:12.962Z" }, + { url = "https://files.pythonhosted.org/packages/39/c3/829092ead738b71e96a4e96896c96f276976e5a8a58b4473ed813d7c962b/libcst-1.8.6-cp314-cp314t-win_amd64.whl", hash = "sha256:bdb14bc4d4d83a57062fed2c5da93ecb426ff65b0dc02ddf3481040f5f074a82", size = 2181581, upload-time = "2025-11-03T22:33:14.514Z" }, + { url = "https://files.pythonhosted.org/packages/98/6d/5d6a790a02eb0d9d36c4aed4f41b277497e6178900b2fa29c35353aa45ed/libcst-1.8.6-cp314-cp314t-win_arm64.whl", hash = "sha256:819c8081e2948635cab60c603e1bbdceccdfe19104a242530ad38a36222cb88f", size = 2065000, upload-time = "2025-11-03T22:33:16.257Z" }, +] + +[[package]] +name = "librt" +version = "0.7.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b3/d9/6f3d3fcf5e5543ed8a60cc70fa7d50508ed60b8a10e9af6d2058159ab54e/librt-0.7.3.tar.gz", hash = "sha256:3ec50cf65235ff5c02c5b747748d9222e564ad48597122a361269dd3aa808798", size = 144549, upload-time = "2025-12-06T19:04:45.553Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4d/66/79a14e672256ef58144a24eb49adb338ec02de67ff4b45320af6504682ab/librt-0.7.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:2682162855a708e3270eba4b92026b93f8257c3e65278b456c77631faf0f4f7a", size = 54707, upload-time = "2025-12-06T19:03:10.881Z" }, + { url = "https://files.pythonhosted.org/packages/58/fa/b709c65a9d5eab85f7bcfe0414504d9775aaad6e78727a0327e175474caa/librt-0.7.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:440c788f707c061d237c1e83edf6164ff19f5c0f823a3bf054e88804ebf971ec", size = 56670, upload-time = "2025-12-06T19:03:12.107Z" }, + { url = "https://files.pythonhosted.org/packages/3a/56/0685a0772ec89ddad4c00e6b584603274c3d818f9a68e2c43c4eb7b39ee9/librt-0.7.3-cp310-cp310-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:399938edbd3d78339f797d685142dd8a623dfaded023cf451033c85955e4838a", size = 161045, upload-time = "2025-12-06T19:03:13.444Z" }, + { url = "https://files.pythonhosted.org/packages/4e/d9/863ada0c5ce48aefb89df1555e392b2209fcb6daee4c153c031339b9a89b/librt-0.7.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1975eda520957c6e0eb52d12968dd3609ffb7eef05d4223d097893d6daf1d8a7", size = 169532, upload-time = "2025-12-06T19:03:14.699Z" }, + { url = "https://files.pythonhosted.org/packages/68/a0/71da6c8724fd16c31749905ef1c9e11de206d9301b5be984bf2682b4efb3/librt-0.7.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f9da128d0edf990cf0d2ca011b02cd6f639e79286774bd5b0351245cbb5a6e51", size = 183277, upload-time = "2025-12-06T19:03:16.446Z" }, + { url = "https://files.pythonhosted.org/packages/8c/bf/9c97bf2f8338ba1914de233ea312bba2bbd7c59f43f807b3e119796bab18/librt-0.7.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:e19acfde38cb532a560b98f473adc741c941b7a9bc90f7294bc273d08becb58b", size = 179045, upload-time = "2025-12-06T19:03:17.838Z" }, + { url = "https://files.pythonhosted.org/packages/b3/b1/ceea067f489e904cb4ddcca3c9b06ba20229bc3fa7458711e24a5811f162/librt-0.7.3-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:7b4f57f7a0c65821c5441d98c47ff7c01d359b1e12328219709bdd97fdd37f90", size = 173521, upload-time = "2025-12-06T19:03:19.17Z" }, + { url = "https://files.pythonhosted.org/packages/7a/41/6cb18f5da9c89ed087417abb0127a445a50ad4eaf1282ba5b52588187f47/librt-0.7.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:256793988bff98040de23c57cf36e1f4c2f2dc3dcd17537cdac031d3b681db71", size = 193592, upload-time = "2025-12-06T19:03:20.637Z" }, + { url = "https://files.pythonhosted.org/packages/4c/3c/fcef208746584e7c78584b7aedc617130c4a4742cb8273361bbda8b183b5/librt-0.7.3-cp310-cp310-win32.whl", hash = "sha256:fcb72249ac4ea81a7baefcbff74df7029c3cb1cf01a711113fa052d563639c9c", size = 47201, upload-time = "2025-12-06T19:03:21.764Z" }, + { url = "https://files.pythonhosted.org/packages/c4/bf/d8a6c35d1b2b789a4df9b3ddb1c8f535ea373fde2089698965a8f0d62138/librt-0.7.3-cp310-cp310-win_amd64.whl", hash = "sha256:4887c29cadbdc50640179e3861c276325ff2986791e6044f73136e6e798ff806", size = 54371, upload-time = "2025-12-06T19:03:23.231Z" }, + { url = "https://files.pythonhosted.org/packages/21/e6/f6391f5c6f158d31ed9af6bd1b1bcd3ffafdea1d816bc4219d0d90175a7f/librt-0.7.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:687403cced6a29590e6be6964463835315905221d797bc5c934a98750fe1a9af", size = 54711, upload-time = "2025-12-06T19:03:24.6Z" }, + { url = "https://files.pythonhosted.org/packages/ab/1b/53c208188c178987c081560a0fcf36f5ca500d5e21769596c845ef2f40d4/librt-0.7.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:24d70810f6e2ea853ff79338001533716b373cc0f63e2a0be5bc96129edb5fb5", size = 56664, upload-time = "2025-12-06T19:03:25.969Z" }, + { url = "https://files.pythonhosted.org/packages/cb/5c/d9da832b9a1e5f8366e8a044ec80217945385b26cb89fd6f94bfdc7d80b0/librt-0.7.3-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:bf8c7735fbfc0754111f00edda35cf9e98a8d478de6c47b04eaa9cef4300eaa7", size = 161701, upload-time = "2025-12-06T19:03:27.035Z" }, + { url = "https://files.pythonhosted.org/packages/20/aa/1e0a7aba15e78529dd21f233076b876ee58c8b8711b1793315bdd3b263b0/librt-0.7.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e32d43610dff472eab939f4d7fbdd240d1667794192690433672ae22d7af8445", size = 171040, upload-time = "2025-12-06T19:03:28.482Z" }, + { url = "https://files.pythonhosted.org/packages/69/46/3cfa325c1c2bc25775ec6ec1718cfbec9cff4ac767d37d2d3a2d1cc6f02c/librt-0.7.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:adeaa886d607fb02563c1f625cf2ee58778a2567c0c109378da8f17ec3076ad7", size = 184720, upload-time = "2025-12-06T19:03:29.599Z" }, + { url = "https://files.pythonhosted.org/packages/99/bb/e4553433d7ac47f4c75d0a7e59b13aee0e08e88ceadbee356527a9629b0a/librt-0.7.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:572a24fc5958c61431da456a0ef1eeea6b4989d81eeb18b8e5f1f3077592200b", size = 180731, upload-time = "2025-12-06T19:03:31.201Z" }, + { url = "https://files.pythonhosted.org/packages/35/89/51cd73006232981a3106d4081fbaa584ac4e27b49bc02266468d3919db03/librt-0.7.3-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:6488e69d408b492e08bfb68f20c4a899a354b4386a446ecd490baff8d0862720", size = 174565, upload-time = "2025-12-06T19:03:32.818Z" }, + { url = "https://files.pythonhosted.org/packages/42/54/0578a78b587e5aa22486af34239a052c6366835b55fc307bc64380229e3f/librt-0.7.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ed028fc3d41adda916320712838aec289956c89b4f0a361ceadf83a53b4c047a", size = 195247, upload-time = "2025-12-06T19:03:34.434Z" }, + { url = "https://files.pythonhosted.org/packages/b5/0a/ee747cd999753dd9447e50b98fc36ee433b6c841a42dbf6d47b64b32a56e/librt-0.7.3-cp311-cp311-win32.whl", hash = "sha256:2cf9d73499486ce39eebbff5f42452518cc1f88d8b7ea4a711ab32962b176ee2", size = 47514, upload-time = "2025-12-06T19:03:35.959Z" }, + { url = "https://files.pythonhosted.org/packages/ec/af/8b13845178dec488e752878f8e290f8f89e7e34ae1528b70277aa1a6dd1e/librt-0.7.3-cp311-cp311-win_amd64.whl", hash = "sha256:35f1609e3484a649bb80431310ddbec81114cd86648f1d9482bc72a3b86ded2e", size = 54695, upload-time = "2025-12-06T19:03:36.956Z" }, + { url = "https://files.pythonhosted.org/packages/02/7a/ae59578501b1a25850266778f59279f4f3e726acc5c44255bfcb07b4bc57/librt-0.7.3-cp311-cp311-win_arm64.whl", hash = "sha256:550fdbfbf5bba6a2960b27376ca76d6aaa2bd4b1a06c4255edd8520c306fcfc0", size = 48142, upload-time = "2025-12-06T19:03:38.263Z" }, + { url = "https://files.pythonhosted.org/packages/29/90/ed8595fa4e35b6020317b5ea8d226a782dcbac7a997c19ae89fb07a41c66/librt-0.7.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:0fa9ac2e49a6bee56e47573a6786cb635e128a7b12a0dc7851090037c0d397a3", size = 55687, upload-time = "2025-12-06T19:03:39.245Z" }, + { url = "https://files.pythonhosted.org/packages/dd/f6/6a20702a07b41006cb001a759440cb6b5362530920978f64a2b2ae2bf729/librt-0.7.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2e980cf1ed1a2420a6424e2ed884629cdead291686f1048810a817de07b5eb18", size = 57127, upload-time = "2025-12-06T19:03:40.3Z" }, + { url = "https://files.pythonhosted.org/packages/79/f3/b0c4703d5ffe9359b67bb2ccb86c42d4e930a363cfc72262ac3ba53cff3e/librt-0.7.3-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:e094e445c37c57e9ec612847812c301840239d34ccc5d153a982fa9814478c60", size = 165336, upload-time = "2025-12-06T19:03:41.369Z" }, + { url = "https://files.pythonhosted.org/packages/02/69/3ba05b73ab29ccbe003856232cea4049769be5942d799e628d1470ed1694/librt-0.7.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:aca73d70c3f553552ba9133d4a09e767dcfeee352d8d8d3eb3f77e38a3beb3ed", size = 174237, upload-time = "2025-12-06T19:03:42.44Z" }, + { url = "https://files.pythonhosted.org/packages/22/ad/d7c2671e7bf6c285ef408aa435e9cd3fdc06fd994601e1f2b242df12034f/librt-0.7.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c634a0a6db395fdaba0361aa78395597ee72c3aad651b9a307a3a7eaf5efd67e", size = 189017, upload-time = "2025-12-06T19:03:44.01Z" }, + { url = "https://files.pythonhosted.org/packages/f4/94/d13f57193148004592b618555f296b41d2d79b1dc814ff8b3273a0bf1546/librt-0.7.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a59a69deeb458c858b8fea6acf9e2acd5d755d76cd81a655256bc65c20dfff5b", size = 183983, upload-time = "2025-12-06T19:03:45.834Z" }, + { url = "https://files.pythonhosted.org/packages/02/10/b612a9944ebd39fa143c7e2e2d33f2cb790205e025ddd903fb509a3a3bb3/librt-0.7.3-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:d91e60ac44bbe3a77a67af4a4c13114cbe9f6d540337ce22f2c9eaf7454ca71f", size = 177602, upload-time = "2025-12-06T19:03:46.944Z" }, + { url = "https://files.pythonhosted.org/packages/1f/48/77bc05c4cc232efae6c5592c0095034390992edbd5bae8d6cf1263bb7157/librt-0.7.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:703456146dc2bf430f7832fd1341adac5c893ec3c1430194fdcefba00012555c", size = 199282, upload-time = "2025-12-06T19:03:48.069Z" }, + { url = "https://files.pythonhosted.org/packages/12/aa/05916ccd864227db1ffec2a303ae34f385c6b22d4e7ce9f07054dbcf083c/librt-0.7.3-cp312-cp312-win32.whl", hash = "sha256:b7c1239b64b70be7759554ad1a86288220bbb04d68518b527783c4ad3fb4f80b", size = 47879, upload-time = "2025-12-06T19:03:49.289Z" }, + { url = "https://files.pythonhosted.org/packages/50/92/7f41c42d31ea818b3c4b9cc1562e9714bac3c676dd18f6d5dd3d0f2aa179/librt-0.7.3-cp312-cp312-win_amd64.whl", hash = "sha256:ef59c938f72bdbc6ab52dc50f81d0637fde0f194b02d636987cea2ab30f8f55a", size = 54972, upload-time = "2025-12-06T19:03:50.335Z" }, + { url = "https://files.pythonhosted.org/packages/3f/dc/53582bbfb422311afcbc92adb75711f04e989cec052f08ec0152fbc36c9c/librt-0.7.3-cp312-cp312-win_arm64.whl", hash = "sha256:ff21c554304e8226bf80c3a7754be27c6c3549a9fec563a03c06ee8f494da8fc", size = 48338, upload-time = "2025-12-06T19:03:51.431Z" }, + { url = "https://files.pythonhosted.org/packages/93/7d/e0ce1837dfb452427db556e6d4c5301ba3b22fe8de318379fbd0593759b9/librt-0.7.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:56f2a47beda8409061bc1c865bef2d4bd9ff9255219402c0817e68ab5ad89aed", size = 55742, upload-time = "2025-12-06T19:03:52.459Z" }, + { url = "https://files.pythonhosted.org/packages/be/c0/3564262301e507e1d5cf31c7d84cb12addf0d35e05ba53312494a2eba9a4/librt-0.7.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:14569ac5dd38cfccf0a14597a88038fb16811a6fede25c67b79c6d50fc2c8fdc", size = 57163, upload-time = "2025-12-06T19:03:53.516Z" }, + { url = "https://files.pythonhosted.org/packages/be/ac/245e72b7e443d24a562f6047563c7f59833384053073ef9410476f68505b/librt-0.7.3-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:6038ccbd5968325a5d6fd393cf6e00b622a8de545f0994b89dd0f748dcf3e19e", size = 165840, upload-time = "2025-12-06T19:03:54.918Z" }, + { url = "https://files.pythonhosted.org/packages/98/af/587e4491f40adba066ba39a450c66bad794c8d92094f936a201bfc7c2b5f/librt-0.7.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d39079379a9a28e74f4d57dc6357fa310a1977b51ff12239d7271ec7e71d67f5", size = 174827, upload-time = "2025-12-06T19:03:56.082Z" }, + { url = "https://files.pythonhosted.org/packages/78/21/5b8c60ea208bc83dd00421022a3874330685d7e856404128dc3728d5d1af/librt-0.7.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8837d5a52a2d7aa9f4c3220a8484013aed1d8ad75240d9a75ede63709ef89055", size = 189612, upload-time = "2025-12-06T19:03:57.507Z" }, + { url = "https://files.pythonhosted.org/packages/da/2f/8b819169ef696421fb81cd04c6cdf225f6e96f197366001e9d45180d7e9e/librt-0.7.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:399bbd7bcc1633c3e356ae274a1deb8781c7bf84d9c7962cc1ae0c6e87837292", size = 184584, upload-time = "2025-12-06T19:03:58.686Z" }, + { url = "https://files.pythonhosted.org/packages/6c/fc/af9d225a9395b77bd7678362cb055d0b8139c2018c37665de110ca388022/librt-0.7.3-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:8d8cf653e798ee4c4e654062b633db36984a1572f68c3aa25e364a0ddfbbb910", size = 178269, upload-time = "2025-12-06T19:03:59.769Z" }, + { url = "https://files.pythonhosted.org/packages/6c/d8/7b4fa1683b772966749d5683aa3fd605813defffe157833a8fa69cc89207/librt-0.7.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:2f03484b54bf4ae80ab2e504a8d99d20d551bfe64a7ec91e218010b467d77093", size = 199852, upload-time = "2025-12-06T19:04:00.901Z" }, + { url = "https://files.pythonhosted.org/packages/77/e8/4598413aece46ca38d9260ef6c51534bd5f34b5c21474fcf210ce3a02123/librt-0.7.3-cp313-cp313-win32.whl", hash = "sha256:44b3689b040df57f492e02cd4f0bacd1b42c5400e4b8048160c9d5e866de8abe", size = 47936, upload-time = "2025-12-06T19:04:02.054Z" }, + { url = "https://files.pythonhosted.org/packages/af/80/ac0e92d5ef8c6791b3e2c62373863827a279265e0935acdf807901353b0e/librt-0.7.3-cp313-cp313-win_amd64.whl", hash = "sha256:6b407c23f16ccc36614c136251d6b32bf30de7a57f8e782378f1107be008ddb0", size = 54965, upload-time = "2025-12-06T19:04:03.224Z" }, + { url = "https://files.pythonhosted.org/packages/f1/fd/042f823fcbff25c1449bb4203a29919891ca74141b68d3a5f6612c4ce283/librt-0.7.3-cp313-cp313-win_arm64.whl", hash = "sha256:abfc57cab3c53c4546aee31859ef06753bfc136c9d208129bad23e2eca39155a", size = 48350, upload-time = "2025-12-06T19:04:04.234Z" }, + { url = "https://files.pythonhosted.org/packages/3e/ae/c6ecc7bb97134a71b5241e8855d39964c0e5f4d96558f0d60593892806d2/librt-0.7.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:120dd21d46ff875e849f1aae19346223cf15656be489242fe884036b23d39e93", size = 55175, upload-time = "2025-12-06T19:04:05.308Z" }, + { url = "https://files.pythonhosted.org/packages/cf/bc/2cc0cb0ab787b39aa5c7645cd792433c875982bdf12dccca558b89624594/librt-0.7.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1617bea5ab31266e152871208502ee943cb349c224846928a1173c864261375e", size = 56881, upload-time = "2025-12-06T19:04:06.674Z" }, + { url = "https://files.pythonhosted.org/packages/8e/87/397417a386190b70f5bf26fcedbaa1515f19dce33366e2684c6b7ee83086/librt-0.7.3-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:93b2a1f325fefa1482516ced160c8c7b4b8d53226763fa6c93d151fa25164207", size = 163710, upload-time = "2025-12-06T19:04:08.437Z" }, + { url = "https://files.pythonhosted.org/packages/c9/37/7338f85b80e8a17525d941211451199845093ca242b32efbf01df8531e72/librt-0.7.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f3d4801db8354436fd3936531e7f0e4feb411f62433a6b6cb32bb416e20b529f", size = 172471, upload-time = "2025-12-06T19:04:10.124Z" }, + { url = "https://files.pythonhosted.org/packages/3b/e0/741704edabbfae2c852fedc1b40d9ed5a783c70ed3ed8e4fe98f84b25d13/librt-0.7.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:11ad45122bbed42cfc8b0597450660126ef28fd2d9ae1a219bc5af8406f95678", size = 186804, upload-time = "2025-12-06T19:04:11.586Z" }, + { url = "https://files.pythonhosted.org/packages/f4/d1/0a82129d6ba242f3be9af34815be089f35051bc79619f5c27d2c449ecef6/librt-0.7.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:6b4e7bff1d76dd2b46443078519dc75df1b5e01562345f0bb740cea5266d8218", size = 181817, upload-time = "2025-12-06T19:04:12.802Z" }, + { url = "https://files.pythonhosted.org/packages/4f/32/704f80bcf9979c68d4357c46f2af788fbf9d5edda9e7de5786ed2255e911/librt-0.7.3-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:d86f94743a11873317094326456b23f8a5788bad9161fd2f0e52088c33564620", size = 175602, upload-time = "2025-12-06T19:04:14.004Z" }, + { url = "https://files.pythonhosted.org/packages/f7/6d/4355cfa0fae0c062ba72f541d13db5bc575770125a7ad3d4f46f4109d305/librt-0.7.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:754a0d09997095ad764ccef050dd5bf26cbf457aab9effcba5890dad081d879e", size = 196497, upload-time = "2025-12-06T19:04:15.487Z" }, + { url = "https://files.pythonhosted.org/packages/2e/eb/ac6d8517d44209e5a712fde46f26d0055e3e8969f24d715f70bd36056230/librt-0.7.3-cp314-cp314-win32.whl", hash = "sha256:fbd7351d43b80d9c64c3cfcb50008f786cc82cba0450e8599fdd64f264320bd3", size = 44678, upload-time = "2025-12-06T19:04:16.688Z" }, + { url = "https://files.pythonhosted.org/packages/e9/93/238f026d141faf9958da588c761a0812a1a21c98cc54a76f3608454e4e59/librt-0.7.3-cp314-cp314-win_amd64.whl", hash = "sha256:d376a35c6561e81d2590506804b428fc1075fcc6298fc5bb49b771534c0ba010", size = 51689, upload-time = "2025-12-06T19:04:17.726Z" }, + { url = "https://files.pythonhosted.org/packages/52/44/43f462ad9dcf9ed7d3172fe2e30d77b980956250bd90e9889a9cca93df2a/librt-0.7.3-cp314-cp314-win_arm64.whl", hash = "sha256:cbdb3f337c88b43c3b49ca377731912c101178be91cb5071aac48faa898e6f8e", size = 44662, upload-time = "2025-12-06T19:04:18.771Z" }, + { url = "https://files.pythonhosted.org/packages/1d/35/fed6348915f96b7323241de97f26e2af481e95183b34991df12fd5ce31b1/librt-0.7.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:9f0e0927efe87cd42ad600628e595a1a0aa1c64f6d0b55f7e6059079a428641a", size = 57347, upload-time = "2025-12-06T19:04:19.812Z" }, + { url = "https://files.pythonhosted.org/packages/9a/f2/045383ccc83e3fea4fba1b761796584bc26817b6b2efb6b8a6731431d16f/librt-0.7.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:020c6db391268bcc8ce75105cb572df8cb659a43fd347366aaa407c366e5117a", size = 59223, upload-time = "2025-12-06T19:04:20.862Z" }, + { url = "https://files.pythonhosted.org/packages/77/3f/c081f8455ab1d7f4a10dbe58463ff97119272ff32494f21839c3b9029c2c/librt-0.7.3-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:7af7785f5edd1f418da09a8cdb9ec84b0213e23d597413e06525340bcce1ea4f", size = 183861, upload-time = "2025-12-06T19:04:21.963Z" }, + { url = "https://files.pythonhosted.org/packages/1d/f5/73c5093c22c31fbeaebc25168837f05ebfd8bf26ce00855ef97a5308f36f/librt-0.7.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8ccadf260bb46a61b9c7e89e2218f6efea9f3eeaaab4e3d1f58571890e54858e", size = 194594, upload-time = "2025-12-06T19:04:23.14Z" }, + { url = "https://files.pythonhosted.org/packages/78/b8/d5f17d4afe16612a4a94abfded94c16c5a033f183074fb130dfe56fc1a42/librt-0.7.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d9883b2d819ce83f87ba82a746c81d14ada78784db431e57cc9719179847376e", size = 206759, upload-time = "2025-12-06T19:04:24.328Z" }, + { url = "https://files.pythonhosted.org/packages/36/2e/021765c1be85ee23ffd5b5b968bb4cba7526a4db2a0fc27dcafbdfc32da7/librt-0.7.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:59cb0470612d21fa1efddfa0dd710756b50d9c7fb6c1236bbf8ef8529331dc70", size = 203210, upload-time = "2025-12-06T19:04:25.544Z" }, + { url = "https://files.pythonhosted.org/packages/77/f0/9923656e42da4fd18c594bd08cf6d7e152d4158f8b808e210d967f0dcceb/librt-0.7.3-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:1fe603877e1865b5fd047a5e40379509a4a60204aa7aa0f72b16f7a41c3f0712", size = 196708, upload-time = "2025-12-06T19:04:26.725Z" }, + { url = "https://files.pythonhosted.org/packages/fc/0b/0708b886ac760e64d6fbe7e16024e4be3ad1a3629d19489a97e9cf4c3431/librt-0.7.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5460d99ed30f043595bbdc888f542bad2caeb6226b01c33cda3ae444e8f82d42", size = 217212, upload-time = "2025-12-06T19:04:27.892Z" }, + { url = "https://files.pythonhosted.org/packages/5d/7f/12a73ff17bca4351e73d585dd9ebf46723c4a8622c4af7fe11a2e2d011ff/librt-0.7.3-cp314-cp314t-win32.whl", hash = "sha256:d09f677693328503c9e492e33e9601464297c01f9ebd966ea8fc5308f3069bfd", size = 45586, upload-time = "2025-12-06T19:04:29.116Z" }, + { url = "https://files.pythonhosted.org/packages/e2/df/8decd032ac9b995e4f5606cde783711a71094128d88d97a52e397daf2c89/librt-0.7.3-cp314-cp314t-win_amd64.whl", hash = "sha256:25711f364c64cab2c910a0247e90b51421e45dbc8910ceeb4eac97a9e132fc6f", size = 53002, upload-time = "2025-12-06T19:04:30.173Z" }, + { url = "https://files.pythonhosted.org/packages/de/0c/6605b6199de8178afe7efc77ca1d8e6db00453bc1d3349d27605c0f42104/librt-0.7.3-cp314-cp314t-win_arm64.whl", hash = "sha256:a9f9b661f82693eb56beb0605156c7fca57f535704ab91837405913417d6990b", size = 45647, upload-time = "2025-12-06T19:04:31.302Z" }, +] + +[[package]] +name = "linkify-it-py" +version = "2.0.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "uc-micro-py" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/2a/ae/bb56c6828e4797ba5a4821eec7c43b8bf40f69cda4d4f5f8c8a2810ec96a/linkify-it-py-2.0.3.tar.gz", hash = "sha256:68cda27e162e9215c17d786649d1da0021a451bdc436ef9e0fa0ba5234b9b048", size = 27946, upload-time = "2024-02-04T14:48:04.179Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/04/1e/b832de447dee8b582cac175871d2f6c3d5077cc56d5575cadba1fd1cccfa/linkify_it_py-2.0.3-py3-none-any.whl", hash = "sha256:6bcbc417b0ac14323382aef5c5192c0075bf8a9d6b41820a2b66371eac6b6d79", size = 19820, upload-time = "2024-02-04T14:48:02.496Z" }, +] + +[[package]] +name = "loguru" +version = "0.7.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "win32-setctime", marker = "sys_platform == 'win32'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/3a/05/a1dae3dffd1116099471c643b8924f5aa6524411dc6c63fdae648c4f1aca/loguru-0.7.3.tar.gz", hash = "sha256:19480589e77d47b8d85b2c827ad95d49bf31b0dcde16593892eb51dd18706eb6", size = 63559, upload-time = "2024-12-06T11:20:56.608Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0c/29/0348de65b8cc732daa3e33e67806420b2ae89bdce2b04af740289c5c6c8c/loguru-0.7.3-py3-none-any.whl", hash = "sha256:31a33c10c8e1e10422bfd431aeb5d351c7cf7fa671e3c4df004162264b28220c", size = 61595, upload-time = "2024-12-06T11:20:54.538Z" }, +] + +[[package]] +name = "markdown-it-py" +version = "3.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "mdurl" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/38/71/3b932df36c1a044d397a1f92d1cf91ee0a503d91e470cbd670aa66b07ed0/markdown-it-py-3.0.0.tar.gz", hash = "sha256:e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb", size = 74596, upload-time = "2023-06-03T06:41:14.443Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/42/d7/1ec15b46af6af88f19b8e5ffea08fa375d433c998b8a7639e76935c14f1f/markdown_it_py-3.0.0-py3-none-any.whl", hash = "sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1", size = 87528, upload-time = "2023-06-03T06:41:11.019Z" }, +] + +[package.optional-dependencies] +linkify = [ + { name = "linkify-it-py" }, +] + +[[package]] +name = "markupsafe" +version = "3.0.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7e/99/7690b6d4034fffd95959cbe0c02de8deb3098cc577c67bb6a24fe5d7caa7/markupsafe-3.0.3.tar.gz", hash = "sha256:722695808f4b6457b320fdc131280796bdceb04ab50fe1795cd540799ebe1698", size = 80313, upload-time = "2025-09-27T18:37:40.426Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e8/4b/3541d44f3937ba468b75da9eebcae497dcf67adb65caa16760b0a6807ebb/markupsafe-3.0.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:2f981d352f04553a7171b8e44369f2af4055f888dfb147d55e42d29e29e74559", size = 11631, upload-time = "2025-09-27T18:36:05.558Z" }, + { url = "https://files.pythonhosted.org/packages/98/1b/fbd8eed11021cabd9226c37342fa6ca4e8a98d8188a8d9b66740494960e4/markupsafe-3.0.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e1c1493fb6e50ab01d20a22826e57520f1284df32f2d8601fdd90b6304601419", size = 12057, upload-time = "2025-09-27T18:36:07.165Z" }, + { url = "https://files.pythonhosted.org/packages/40/01/e560d658dc0bb8ab762670ece35281dec7b6c1b33f5fbc09ebb57a185519/markupsafe-3.0.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1ba88449deb3de88bd40044603fafffb7bc2b055d626a330323a9ed736661695", size = 22050, upload-time = "2025-09-27T18:36:08.005Z" }, + { url = "https://files.pythonhosted.org/packages/af/cd/ce6e848bbf2c32314c9b237839119c5a564a59725b53157c856e90937b7a/markupsafe-3.0.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f42d0984e947b8adf7dd6dde396e720934d12c506ce84eea8476409563607591", size = 20681, upload-time = "2025-09-27T18:36:08.881Z" }, + { url = "https://files.pythonhosted.org/packages/c9/2a/b5c12c809f1c3045c4d580b035a743d12fcde53cf685dbc44660826308da/markupsafe-3.0.3-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c0c0b3ade1c0b13b936d7970b1d37a57acde9199dc2aecc4c336773e1d86049c", size = 20705, upload-time = "2025-09-27T18:36:10.131Z" }, + { url = "https://files.pythonhosted.org/packages/cf/e3/9427a68c82728d0a88c50f890d0fc072a1484de2f3ac1ad0bfc1a7214fd5/markupsafe-3.0.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:0303439a41979d9e74d18ff5e2dd8c43ed6c6001fd40e5bf2e43f7bd9bbc523f", size = 21524, upload-time = "2025-09-27T18:36:11.324Z" }, + { url = "https://files.pythonhosted.org/packages/bc/36/23578f29e9e582a4d0278e009b38081dbe363c5e7165113fad546918a232/markupsafe-3.0.3-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:d2ee202e79d8ed691ceebae8e0486bd9a2cd4794cec4824e1c99b6f5009502f6", size = 20282, upload-time = "2025-09-27T18:36:12.573Z" }, + { url = "https://files.pythonhosted.org/packages/56/21/dca11354e756ebd03e036bd8ad58d6d7168c80ce1fe5e75218e4945cbab7/markupsafe-3.0.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:177b5253b2834fe3678cb4a5f0059808258584c559193998be2601324fdeafb1", size = 20745, upload-time = "2025-09-27T18:36:13.504Z" }, + { url = "https://files.pythonhosted.org/packages/87/99/faba9369a7ad6e4d10b6a5fbf71fa2a188fe4a593b15f0963b73859a1bbd/markupsafe-3.0.3-cp310-cp310-win32.whl", hash = "sha256:2a15a08b17dd94c53a1da0438822d70ebcd13f8c3a95abe3a9ef9f11a94830aa", size = 14571, upload-time = "2025-09-27T18:36:14.779Z" }, + { url = "https://files.pythonhosted.org/packages/d6/25/55dc3ab959917602c96985cb1253efaa4ff42f71194bddeb61eb7278b8be/markupsafe-3.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:c4ffb7ebf07cfe8931028e3e4c85f0357459a3f9f9490886198848f4fa002ec8", size = 15056, upload-time = "2025-09-27T18:36:16.125Z" }, + { url = "https://files.pythonhosted.org/packages/d0/9e/0a02226640c255d1da0b8d12e24ac2aa6734da68bff14c05dd53b94a0fc3/markupsafe-3.0.3-cp310-cp310-win_arm64.whl", hash = "sha256:e2103a929dfa2fcaf9bb4e7c091983a49c9ac3b19c9061b6d5427dd7d14d81a1", size = 13932, upload-time = "2025-09-27T18:36:17.311Z" }, + { url = "https://files.pythonhosted.org/packages/08/db/fefacb2136439fc8dd20e797950e749aa1f4997ed584c62cfb8ef7c2be0e/markupsafe-3.0.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1cc7ea17a6824959616c525620e387f6dd30fec8cb44f649e31712db02123dad", size = 11631, upload-time = "2025-09-27T18:36:18.185Z" }, + { url = "https://files.pythonhosted.org/packages/e1/2e/5898933336b61975ce9dc04decbc0a7f2fee78c30353c5efba7f2d6ff27a/markupsafe-3.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4bd4cd07944443f5a265608cc6aab442e4f74dff8088b0dfc8238647b8f6ae9a", size = 12058, upload-time = "2025-09-27T18:36:19.444Z" }, + { url = "https://files.pythonhosted.org/packages/1d/09/adf2df3699d87d1d8184038df46a9c80d78c0148492323f4693df54e17bb/markupsafe-3.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b5420a1d9450023228968e7e6a9ce57f65d148ab56d2313fcd589eee96a7a50", size = 24287, upload-time = "2025-09-27T18:36:20.768Z" }, + { url = "https://files.pythonhosted.org/packages/30/ac/0273f6fcb5f42e314c6d8cd99effae6a5354604d461b8d392b5ec9530a54/markupsafe-3.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0bf2a864d67e76e5c9a34dc26ec616a66b9888e25e7b9460e1c76d3293bd9dbf", size = 22940, upload-time = "2025-09-27T18:36:22.249Z" }, + { url = "https://files.pythonhosted.org/packages/19/ae/31c1be199ef767124c042c6c3e904da327a2f7f0cd63a0337e1eca2967a8/markupsafe-3.0.3-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc51efed119bc9cfdf792cdeaa4d67e8f6fcccab66ed4bfdd6bde3e59bfcbb2f", size = 21887, upload-time = "2025-09-27T18:36:23.535Z" }, + { url = "https://files.pythonhosted.org/packages/b2/76/7edcab99d5349a4532a459e1fe64f0b0467a3365056ae550d3bcf3f79e1e/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:068f375c472b3e7acbe2d5318dea141359e6900156b5b2ba06a30b169086b91a", size = 23692, upload-time = "2025-09-27T18:36:24.823Z" }, + { url = "https://files.pythonhosted.org/packages/a4/28/6e74cdd26d7514849143d69f0bf2399f929c37dc2b31e6829fd2045b2765/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:7be7b61bb172e1ed687f1754f8e7484f1c8019780f6f6b0786e76bb01c2ae115", size = 21471, upload-time = "2025-09-27T18:36:25.95Z" }, + { url = "https://files.pythonhosted.org/packages/62/7e/a145f36a5c2945673e590850a6f8014318d5577ed7e5920a4b3448e0865d/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f9e130248f4462aaa8e2552d547f36ddadbeaa573879158d721bbd33dfe4743a", size = 22923, upload-time = "2025-09-27T18:36:27.109Z" }, + { url = "https://files.pythonhosted.org/packages/0f/62/d9c46a7f5c9adbeeeda52f5b8d802e1094e9717705a645efc71b0913a0a8/markupsafe-3.0.3-cp311-cp311-win32.whl", hash = "sha256:0db14f5dafddbb6d9208827849fad01f1a2609380add406671a26386cdf15a19", size = 14572, upload-time = "2025-09-27T18:36:28.045Z" }, + { url = "https://files.pythonhosted.org/packages/83/8a/4414c03d3f891739326e1783338e48fb49781cc915b2e0ee052aa490d586/markupsafe-3.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:de8a88e63464af587c950061a5e6a67d3632e36df62b986892331d4620a35c01", size = 15077, upload-time = "2025-09-27T18:36:29.025Z" }, + { url = "https://files.pythonhosted.org/packages/35/73/893072b42e6862f319b5207adc9ae06070f095b358655f077f69a35601f0/markupsafe-3.0.3-cp311-cp311-win_arm64.whl", hash = "sha256:3b562dd9e9ea93f13d53989d23a7e775fdfd1066c33494ff43f5418bc8c58a5c", size = 13876, upload-time = "2025-09-27T18:36:29.954Z" }, + { url = "https://files.pythonhosted.org/packages/5a/72/147da192e38635ada20e0a2e1a51cf8823d2119ce8883f7053879c2199b5/markupsafe-3.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d53197da72cc091b024dd97249dfc7794d6a56530370992a5e1a08983ad9230e", size = 11615, upload-time = "2025-09-27T18:36:30.854Z" }, + { url = "https://files.pythonhosted.org/packages/9a/81/7e4e08678a1f98521201c3079f77db69fb552acd56067661f8c2f534a718/markupsafe-3.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1872df69a4de6aead3491198eaf13810b565bdbeec3ae2dc8780f14458ec73ce", size = 12020, upload-time = "2025-09-27T18:36:31.971Z" }, + { url = "https://files.pythonhosted.org/packages/1e/2c/799f4742efc39633a1b54a92eec4082e4f815314869865d876824c257c1e/markupsafe-3.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3a7e8ae81ae39e62a41ec302f972ba6ae23a5c5396c8e60113e9066ef893da0d", size = 24332, upload-time = "2025-09-27T18:36:32.813Z" }, + { url = "https://files.pythonhosted.org/packages/3c/2e/8d0c2ab90a8c1d9a24f0399058ab8519a3279d1bd4289511d74e909f060e/markupsafe-3.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d6dd0be5b5b189d31db7cda48b91d7e0a9795f31430b7f271219ab30f1d3ac9d", size = 22947, upload-time = "2025-09-27T18:36:33.86Z" }, + { url = "https://files.pythonhosted.org/packages/2c/54/887f3092a85238093a0b2154bd629c89444f395618842e8b0c41783898ea/markupsafe-3.0.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:94c6f0bb423f739146aec64595853541634bde58b2135f27f61c1ffd1cd4d16a", size = 21962, upload-time = "2025-09-27T18:36:35.099Z" }, + { url = "https://files.pythonhosted.org/packages/c9/2f/336b8c7b6f4a4d95e91119dc8521402461b74a485558d8f238a68312f11c/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:be8813b57049a7dc738189df53d69395eba14fb99345e0a5994914a3864c8a4b", size = 23760, upload-time = "2025-09-27T18:36:36.001Z" }, + { url = "https://files.pythonhosted.org/packages/32/43/67935f2b7e4982ffb50a4d169b724d74b62a3964bc1a9a527f5ac4f1ee2b/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:83891d0e9fb81a825d9a6d61e3f07550ca70a076484292a70fde82c4b807286f", size = 21529, upload-time = "2025-09-27T18:36:36.906Z" }, + { url = "https://files.pythonhosted.org/packages/89/e0/4486f11e51bbba8b0c041098859e869e304d1c261e59244baa3d295d47b7/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:77f0643abe7495da77fb436f50f8dab76dbc6e5fd25d39589a0f1fe6548bfa2b", size = 23015, upload-time = "2025-09-27T18:36:37.868Z" }, + { url = "https://files.pythonhosted.org/packages/2f/e1/78ee7a023dac597a5825441ebd17170785a9dab23de95d2c7508ade94e0e/markupsafe-3.0.3-cp312-cp312-win32.whl", hash = "sha256:d88b440e37a16e651bda4c7c2b930eb586fd15ca7406cb39e211fcff3bf3017d", size = 14540, upload-time = "2025-09-27T18:36:38.761Z" }, + { url = "https://files.pythonhosted.org/packages/aa/5b/bec5aa9bbbb2c946ca2733ef9c4ca91c91b6a24580193e891b5f7dbe8e1e/markupsafe-3.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:26a5784ded40c9e318cfc2bdb30fe164bdb8665ded9cd64d500a34fb42067b1c", size = 15105, upload-time = "2025-09-27T18:36:39.701Z" }, + { url = "https://files.pythonhosted.org/packages/e5/f1/216fc1bbfd74011693a4fd837e7026152e89c4bcf3e77b6692fba9923123/markupsafe-3.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:35add3b638a5d900e807944a078b51922212fb3dedb01633a8defc4b01a3c85f", size = 13906, upload-time = "2025-09-27T18:36:40.689Z" }, + { url = "https://files.pythonhosted.org/packages/38/2f/907b9c7bbba283e68f20259574b13d005c121a0fa4c175f9bed27c4597ff/markupsafe-3.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e1cf1972137e83c5d4c136c43ced9ac51d0e124706ee1c8aa8532c1287fa8795", size = 11622, upload-time = "2025-09-27T18:36:41.777Z" }, + { url = "https://files.pythonhosted.org/packages/9c/d9/5f7756922cdd676869eca1c4e3c0cd0df60ed30199ffd775e319089cb3ed/markupsafe-3.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:116bb52f642a37c115f517494ea5feb03889e04df47eeff5b130b1808ce7c219", size = 12029, upload-time = "2025-09-27T18:36:43.257Z" }, + { url = "https://files.pythonhosted.org/packages/00/07/575a68c754943058c78f30db02ee03a64b3c638586fba6a6dd56830b30a3/markupsafe-3.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:133a43e73a802c5562be9bbcd03d090aa5a1fe899db609c29e8c8d815c5f6de6", size = 24374, upload-time = "2025-09-27T18:36:44.508Z" }, + { url = "https://files.pythonhosted.org/packages/a9/21/9b05698b46f218fc0e118e1f8168395c65c8a2c750ae2bab54fc4bd4e0e8/markupsafe-3.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ccfcd093f13f0f0b7fdd0f198b90053bf7b2f02a3927a30e63f3ccc9df56b676", size = 22980, upload-time = "2025-09-27T18:36:45.385Z" }, + { url = "https://files.pythonhosted.org/packages/7f/71/544260864f893f18b6827315b988c146b559391e6e7e8f7252839b1b846a/markupsafe-3.0.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:509fa21c6deb7a7a273d629cf5ec029bc209d1a51178615ddf718f5918992ab9", size = 21990, upload-time = "2025-09-27T18:36:46.916Z" }, + { url = "https://files.pythonhosted.org/packages/c2/28/b50fc2f74d1ad761af2f5dcce7492648b983d00a65b8c0e0cb457c82ebbe/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a4afe79fb3de0b7097d81da19090f4df4f8d3a2b3adaa8764138aac2e44f3af1", size = 23784, upload-time = "2025-09-27T18:36:47.884Z" }, + { url = "https://files.pythonhosted.org/packages/ed/76/104b2aa106a208da8b17a2fb72e033a5a9d7073c68f7e508b94916ed47a9/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:795e7751525cae078558e679d646ae45574b47ed6e7771863fcc079a6171a0fc", size = 21588, upload-time = "2025-09-27T18:36:48.82Z" }, + { url = "https://files.pythonhosted.org/packages/b5/99/16a5eb2d140087ebd97180d95249b00a03aa87e29cc224056274f2e45fd6/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8485f406a96febb5140bfeca44a73e3ce5116b2501ac54fe953e488fb1d03b12", size = 23041, upload-time = "2025-09-27T18:36:49.797Z" }, + { url = "https://files.pythonhosted.org/packages/19/bc/e7140ed90c5d61d77cea142eed9f9c303f4c4806f60a1044c13e3f1471d0/markupsafe-3.0.3-cp313-cp313-win32.whl", hash = "sha256:bdd37121970bfd8be76c5fb069c7751683bdf373db1ed6c010162b2a130248ed", size = 14543, upload-time = "2025-09-27T18:36:51.584Z" }, + { url = "https://files.pythonhosted.org/packages/05/73/c4abe620b841b6b791f2edc248f556900667a5a1cf023a6646967ae98335/markupsafe-3.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:9a1abfdc021a164803f4d485104931fb8f8c1efd55bc6b748d2f5774e78b62c5", size = 15113, upload-time = "2025-09-27T18:36:52.537Z" }, + { url = "https://files.pythonhosted.org/packages/f0/3a/fa34a0f7cfef23cf9500d68cb7c32dd64ffd58a12b09225fb03dd37d5b80/markupsafe-3.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:7e68f88e5b8799aa49c85cd116c932a1ac15caaa3f5db09087854d218359e485", size = 13911, upload-time = "2025-09-27T18:36:53.513Z" }, + { url = "https://files.pythonhosted.org/packages/e4/d7/e05cd7efe43a88a17a37b3ae96e79a19e846f3f456fe79c57ca61356ef01/markupsafe-3.0.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:218551f6df4868a8d527e3062d0fb968682fe92054e89978594c28e642c43a73", size = 11658, upload-time = "2025-09-27T18:36:54.819Z" }, + { url = "https://files.pythonhosted.org/packages/99/9e/e412117548182ce2148bdeacdda3bb494260c0b0184360fe0d56389b523b/markupsafe-3.0.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3524b778fe5cfb3452a09d31e7b5adefeea8c5be1d43c4f810ba09f2ceb29d37", size = 12066, upload-time = "2025-09-27T18:36:55.714Z" }, + { url = "https://files.pythonhosted.org/packages/bc/e6/fa0ffcda717ef64a5108eaa7b4f5ed28d56122c9a6d70ab8b72f9f715c80/markupsafe-3.0.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4e885a3d1efa2eadc93c894a21770e4bc67899e3543680313b09f139e149ab19", size = 25639, upload-time = "2025-09-27T18:36:56.908Z" }, + { url = "https://files.pythonhosted.org/packages/96/ec/2102e881fe9d25fc16cb4b25d5f5cde50970967ffa5dddafdb771237062d/markupsafe-3.0.3-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8709b08f4a89aa7586de0aadc8da56180242ee0ada3999749b183aa23df95025", size = 23569, upload-time = "2025-09-27T18:36:57.913Z" }, + { url = "https://files.pythonhosted.org/packages/4b/30/6f2fce1f1f205fc9323255b216ca8a235b15860c34b6798f810f05828e32/markupsafe-3.0.3-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b8512a91625c9b3da6f127803b166b629725e68af71f8184ae7e7d54686a56d6", size = 23284, upload-time = "2025-09-27T18:36:58.833Z" }, + { url = "https://files.pythonhosted.org/packages/58/47/4a0ccea4ab9f5dcb6f79c0236d954acb382202721e704223a8aafa38b5c8/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9b79b7a16f7fedff2495d684f2b59b0457c3b493778c9eed31111be64d58279f", size = 24801, upload-time = "2025-09-27T18:36:59.739Z" }, + { url = "https://files.pythonhosted.org/packages/6a/70/3780e9b72180b6fecb83a4814d84c3bf4b4ae4bf0b19c27196104149734c/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:12c63dfb4a98206f045aa9563db46507995f7ef6d83b2f68eda65c307c6829eb", size = 22769, upload-time = "2025-09-27T18:37:00.719Z" }, + { url = "https://files.pythonhosted.org/packages/98/c5/c03c7f4125180fc215220c035beac6b9cb684bc7a067c84fc69414d315f5/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8f71bc33915be5186016f675cd83a1e08523649b0e33efdb898db577ef5bb009", size = 23642, upload-time = "2025-09-27T18:37:01.673Z" }, + { url = "https://files.pythonhosted.org/packages/80/d6/2d1b89f6ca4bff1036499b1e29a1d02d282259f3681540e16563f27ebc23/markupsafe-3.0.3-cp313-cp313t-win32.whl", hash = "sha256:69c0b73548bc525c8cb9a251cddf1931d1db4d2258e9599c28c07ef3580ef354", size = 14612, upload-time = "2025-09-27T18:37:02.639Z" }, + { url = "https://files.pythonhosted.org/packages/2b/98/e48a4bfba0a0ffcf9925fe2d69240bfaa19c6f7507b8cd09c70684a53c1e/markupsafe-3.0.3-cp313-cp313t-win_amd64.whl", hash = "sha256:1b4b79e8ebf6b55351f0d91fe80f893b4743f104bff22e90697db1590e47a218", size = 15200, upload-time = "2025-09-27T18:37:03.582Z" }, + { url = "https://files.pythonhosted.org/packages/0e/72/e3cc540f351f316e9ed0f092757459afbc595824ca724cbc5a5d4263713f/markupsafe-3.0.3-cp313-cp313t-win_arm64.whl", hash = "sha256:ad2cf8aa28b8c020ab2fc8287b0f823d0a7d8630784c31e9ee5edea20f406287", size = 13973, upload-time = "2025-09-27T18:37:04.929Z" }, + { url = "https://files.pythonhosted.org/packages/33/8a/8e42d4838cd89b7dde187011e97fe6c3af66d8c044997d2183fbd6d31352/markupsafe-3.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:eaa9599de571d72e2daf60164784109f19978b327a3910d3e9de8c97b5b70cfe", size = 11619, upload-time = "2025-09-27T18:37:06.342Z" }, + { url = "https://files.pythonhosted.org/packages/b5/64/7660f8a4a8e53c924d0fa05dc3a55c9cee10bbd82b11c5afb27d44b096ce/markupsafe-3.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c47a551199eb8eb2121d4f0f15ae0f923d31350ab9280078d1e5f12b249e0026", size = 12029, upload-time = "2025-09-27T18:37:07.213Z" }, + { url = "https://files.pythonhosted.org/packages/da/ef/e648bfd021127bef5fa12e1720ffed0c6cbb8310c8d9bea7266337ff06de/markupsafe-3.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f34c41761022dd093b4b6896d4810782ffbabe30f2d443ff5f083e0cbbb8c737", size = 24408, upload-time = "2025-09-27T18:37:09.572Z" }, + { url = "https://files.pythonhosted.org/packages/41/3c/a36c2450754618e62008bf7435ccb0f88053e07592e6028a34776213d877/markupsafe-3.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:457a69a9577064c05a97c41f4e65148652db078a3a509039e64d3467b9e7ef97", size = 23005, upload-time = "2025-09-27T18:37:10.58Z" }, + { url = "https://files.pythonhosted.org/packages/bc/20/b7fdf89a8456b099837cd1dc21974632a02a999ec9bf7ca3e490aacd98e7/markupsafe-3.0.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e8afc3f2ccfa24215f8cb28dcf43f0113ac3c37c2f0f0806d8c70e4228c5cf4d", size = 22048, upload-time = "2025-09-27T18:37:11.547Z" }, + { url = "https://files.pythonhosted.org/packages/9a/a7/591f592afdc734f47db08a75793a55d7fbcc6902a723ae4cfbab61010cc5/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ec15a59cf5af7be74194f7ab02d0f59a62bdcf1a537677ce67a2537c9b87fcda", size = 23821, upload-time = "2025-09-27T18:37:12.48Z" }, + { url = "https://files.pythonhosted.org/packages/7d/33/45b24e4f44195b26521bc6f1a82197118f74df348556594bd2262bda1038/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:0eb9ff8191e8498cca014656ae6b8d61f39da5f95b488805da4bb029cccbfbaf", size = 21606, upload-time = "2025-09-27T18:37:13.485Z" }, + { url = "https://files.pythonhosted.org/packages/ff/0e/53dfaca23a69fbfbbf17a4b64072090e70717344c52eaaaa9c5ddff1e5f0/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2713baf880df847f2bece4230d4d094280f4e67b1e813eec43b4c0e144a34ffe", size = 23043, upload-time = "2025-09-27T18:37:14.408Z" }, + { url = "https://files.pythonhosted.org/packages/46/11/f333a06fc16236d5238bfe74daccbca41459dcd8d1fa952e8fbd5dccfb70/markupsafe-3.0.3-cp314-cp314-win32.whl", hash = "sha256:729586769a26dbceff69f7a7dbbf59ab6572b99d94576a5592625d5b411576b9", size = 14747, upload-time = "2025-09-27T18:37:15.36Z" }, + { url = "https://files.pythonhosted.org/packages/28/52/182836104b33b444e400b14f797212f720cbc9ed6ba34c800639d154e821/markupsafe-3.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:bdc919ead48f234740ad807933cdf545180bfbe9342c2bb451556db2ed958581", size = 15341, upload-time = "2025-09-27T18:37:16.496Z" }, + { url = "https://files.pythonhosted.org/packages/6f/18/acf23e91bd94fd7b3031558b1f013adfa21a8e407a3fdb32745538730382/markupsafe-3.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:5a7d5dc5140555cf21a6fefbdbf8723f06fcd2f63ef108f2854de715e4422cb4", size = 14073, upload-time = "2025-09-27T18:37:17.476Z" }, + { url = "https://files.pythonhosted.org/packages/3c/f0/57689aa4076e1b43b15fdfa646b04653969d50cf30c32a102762be2485da/markupsafe-3.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:1353ef0c1b138e1907ae78e2f6c63ff67501122006b0f9abad68fda5f4ffc6ab", size = 11661, upload-time = "2025-09-27T18:37:18.453Z" }, + { url = "https://files.pythonhosted.org/packages/89/c3/2e67a7ca217c6912985ec766c6393b636fb0c2344443ff9d91404dc4c79f/markupsafe-3.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1085e7fbddd3be5f89cc898938f42c0b3c711fdcb37d75221de2666af647c175", size = 12069, upload-time = "2025-09-27T18:37:19.332Z" }, + { url = "https://files.pythonhosted.org/packages/f0/00/be561dce4e6ca66b15276e184ce4b8aec61fe83662cce2f7d72bd3249d28/markupsafe-3.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1b52b4fb9df4eb9ae465f8d0c228a00624de2334f216f178a995ccdcf82c4634", size = 25670, upload-time = "2025-09-27T18:37:20.245Z" }, + { url = "https://files.pythonhosted.org/packages/50/09/c419f6f5a92e5fadde27efd190eca90f05e1261b10dbd8cbcb39cd8ea1dc/markupsafe-3.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fed51ac40f757d41b7c48425901843666a6677e3e8eb0abcff09e4ba6e664f50", size = 23598, upload-time = "2025-09-27T18:37:21.177Z" }, + { url = "https://files.pythonhosted.org/packages/22/44/a0681611106e0b2921b3033fc19bc53323e0b50bc70cffdd19f7d679bb66/markupsafe-3.0.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f190daf01f13c72eac4efd5c430a8de82489d9cff23c364c3ea822545032993e", size = 23261, upload-time = "2025-09-27T18:37:22.167Z" }, + { url = "https://files.pythonhosted.org/packages/5f/57/1b0b3f100259dc9fffe780cfb60d4be71375510e435efec3d116b6436d43/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e56b7d45a839a697b5eb268c82a71bd8c7f6c94d6fd50c3d577fa39a9f1409f5", size = 24835, upload-time = "2025-09-27T18:37:23.296Z" }, + { url = "https://files.pythonhosted.org/packages/26/6a/4bf6d0c97c4920f1597cc14dd720705eca0bf7c787aebc6bb4d1bead5388/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:f3e98bb3798ead92273dc0e5fd0f31ade220f59a266ffd8a4f6065e0a3ce0523", size = 22733, upload-time = "2025-09-27T18:37:24.237Z" }, + { url = "https://files.pythonhosted.org/packages/14/c7/ca723101509b518797fedc2fdf79ba57f886b4aca8a7d31857ba3ee8281f/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5678211cb9333a6468fb8d8be0305520aa073f50d17f089b5b4b477ea6e67fdc", size = 23672, upload-time = "2025-09-27T18:37:25.271Z" }, + { url = "https://files.pythonhosted.org/packages/fb/df/5bd7a48c256faecd1d36edc13133e51397e41b73bb77e1a69deab746ebac/markupsafe-3.0.3-cp314-cp314t-win32.whl", hash = "sha256:915c04ba3851909ce68ccc2b8e2cd691618c4dc4c4232fb7982bca3f41fd8c3d", size = 14819, upload-time = "2025-09-27T18:37:26.285Z" }, + { url = "https://files.pythonhosted.org/packages/1a/8a/0402ba61a2f16038b48b39bccca271134be00c5c9f0f623208399333c448/markupsafe-3.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4faffd047e07c38848ce017e8725090413cd80cbc23d86e55c587bf979e579c9", size = 15426, upload-time = "2025-09-27T18:37:27.316Z" }, + { url = "https://files.pythonhosted.org/packages/70/bc/6f1c2f612465f5fa89b95bead1f44dcb607670fd42891d8fdcd5d039f4f4/markupsafe-3.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:32001d6a8fc98c8cb5c947787c5d08b0a50663d139f1305bac5885d98d9b40fa", size = 14146, upload-time = "2025-09-27T18:37:28.327Z" }, +] + +[[package]] +name = "mdit-py-plugins" +version = "0.5.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markdown-it-py" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b2/fd/a756d36c0bfba5f6e39a1cdbdbfdd448dc02692467d83816dff4592a1ebc/mdit_py_plugins-0.5.0.tar.gz", hash = "sha256:f4918cb50119f50446560513a8e311d574ff6aaed72606ddae6d35716fe809c6", size = 44655, upload-time = "2025-08-11T07:25:49.083Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fb/86/dd6e5db36df29e76c7a7699123569a4a18c1623ce68d826ed96c62643cae/mdit_py_plugins-0.5.0-py3-none-any.whl", hash = "sha256:07a08422fc1936a5d26d146759e9155ea466e842f5ab2f7d2266dd084c8dab1f", size = 57205, upload-time = "2025-08-11T07:25:47.597Z" }, +] + +[[package]] +name = "mdurl" +version = "0.1.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729, upload-time = "2022-08-14T12:40:10.846Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" }, +] + +[[package]] +name = "msgpack" +version = "1.1.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4d/f2/bfb55a6236ed8725a96b0aa3acbd0ec17588e6a2c3b62a93eb513ed8783f/msgpack-1.1.2.tar.gz", hash = "sha256:3b60763c1373dd60f398488069bcdc703cd08a711477b5d480eecc9f9626f47e", size = 173581, upload-time = "2025-10-08T09:15:56.596Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f5/a2/3b68a9e769db68668b25c6108444a35f9bd163bb848c0650d516761a59c0/msgpack-1.1.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0051fffef5a37ca2cd16978ae4f0aef92f164df86823871b5162812bebecd8e2", size = 81318, upload-time = "2025-10-08T09:14:38.722Z" }, + { url = "https://files.pythonhosted.org/packages/5b/e1/2b720cc341325c00be44e1ed59e7cfeae2678329fbf5aa68f5bda57fe728/msgpack-1.1.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a605409040f2da88676e9c9e5853b3449ba8011973616189ea5ee55ddbc5bc87", size = 83786, upload-time = "2025-10-08T09:14:40.082Z" }, + { url = "https://files.pythonhosted.org/packages/71/e5/c2241de64bfceac456b140737812a2ab310b10538a7b34a1d393b748e095/msgpack-1.1.2-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8b696e83c9f1532b4af884045ba7f3aa741a63b2bc22617293a2c6a7c645f251", size = 398240, upload-time = "2025-10-08T09:14:41.151Z" }, + { url = "https://files.pythonhosted.org/packages/b7/09/2a06956383c0fdebaef5aa9246e2356776f12ea6f2a44bd1368abf0e46c4/msgpack-1.1.2-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:365c0bbe981a27d8932da71af63ef86acc59ed5c01ad929e09a0b88c6294e28a", size = 406070, upload-time = "2025-10-08T09:14:42.821Z" }, + { url = "https://files.pythonhosted.org/packages/0e/74/2957703f0e1ef20637d6aead4fbb314330c26f39aa046b348c7edcf6ca6b/msgpack-1.1.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:41d1a5d875680166d3ac5c38573896453bbbea7092936d2e107214daf43b1d4f", size = 393403, upload-time = "2025-10-08T09:14:44.38Z" }, + { url = "https://files.pythonhosted.org/packages/a5/09/3bfc12aa90f77b37322fc33e7a8a7c29ba7c8edeadfa27664451801b9860/msgpack-1.1.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:354e81bcdebaab427c3df4281187edc765d5d76bfb3a7c125af9da7a27e8458f", size = 398947, upload-time = "2025-10-08T09:14:45.56Z" }, + { url = "https://files.pythonhosted.org/packages/4b/4f/05fcebd3b4977cb3d840f7ef6b77c51f8582086de5e642f3fefee35c86fc/msgpack-1.1.2-cp310-cp310-win32.whl", hash = "sha256:e64c8d2f5e5d5fda7b842f55dec6133260ea8f53c4257d64494c534f306bf7a9", size = 64769, upload-time = "2025-10-08T09:14:47.334Z" }, + { url = "https://files.pythonhosted.org/packages/d0/3e/b4547e3a34210956382eed1c85935fff7e0f9b98be3106b3745d7dec9c5e/msgpack-1.1.2-cp310-cp310-win_amd64.whl", hash = "sha256:db6192777d943bdaaafb6ba66d44bf65aa0e9c5616fa1d2da9bb08828c6b39aa", size = 71293, upload-time = "2025-10-08T09:14:48.665Z" }, + { url = "https://files.pythonhosted.org/packages/2c/97/560d11202bcd537abca693fd85d81cebe2107ba17301de42b01ac1677b69/msgpack-1.1.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:2e86a607e558d22985d856948c12a3fa7b42efad264dca8a3ebbcfa2735d786c", size = 82271, upload-time = "2025-10-08T09:14:49.967Z" }, + { url = "https://files.pythonhosted.org/packages/83/04/28a41024ccbd67467380b6fb440ae916c1e4f25e2cd4c63abe6835ac566e/msgpack-1.1.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:283ae72fc89da59aa004ba147e8fc2f766647b1251500182fac0350d8af299c0", size = 84914, upload-time = "2025-10-08T09:14:50.958Z" }, + { url = "https://files.pythonhosted.org/packages/71/46/b817349db6886d79e57a966346cf0902a426375aadc1e8e7a86a75e22f19/msgpack-1.1.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:61c8aa3bd513d87c72ed0b37b53dd5c5a0f58f2ff9f26e1555d3bd7948fb7296", size = 416962, upload-time = "2025-10-08T09:14:51.997Z" }, + { url = "https://files.pythonhosted.org/packages/da/e0/6cc2e852837cd6086fe7d8406af4294e66827a60a4cf60b86575a4a65ca8/msgpack-1.1.2-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:454e29e186285d2ebe65be34629fa0e8605202c60fbc7c4c650ccd41870896ef", size = 426183, upload-time = "2025-10-08T09:14:53.477Z" }, + { url = "https://files.pythonhosted.org/packages/25/98/6a19f030b3d2ea906696cedd1eb251708e50a5891d0978b012cb6107234c/msgpack-1.1.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7bc8813f88417599564fafa59fd6f95be417179f76b40325b500b3c98409757c", size = 411454, upload-time = "2025-10-08T09:14:54.648Z" }, + { url = "https://files.pythonhosted.org/packages/b7/cd/9098fcb6adb32187a70b7ecaabf6339da50553351558f37600e53a4a2a23/msgpack-1.1.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:bafca952dc13907bdfdedfc6a5f579bf4f292bdd506fadb38389afa3ac5b208e", size = 422341, upload-time = "2025-10-08T09:14:56.328Z" }, + { url = "https://files.pythonhosted.org/packages/e6/ae/270cecbcf36c1dc85ec086b33a51a4d7d08fc4f404bdbc15b582255d05ff/msgpack-1.1.2-cp311-cp311-win32.whl", hash = "sha256:602b6740e95ffc55bfb078172d279de3773d7b7db1f703b2f1323566b878b90e", size = 64747, upload-time = "2025-10-08T09:14:57.882Z" }, + { url = "https://files.pythonhosted.org/packages/2a/79/309d0e637f6f37e83c711f547308b91af02b72d2326ddd860b966080ef29/msgpack-1.1.2-cp311-cp311-win_amd64.whl", hash = "sha256:d198d275222dc54244bf3327eb8cbe00307d220241d9cec4d306d49a44e85f68", size = 71633, upload-time = "2025-10-08T09:14:59.177Z" }, + { url = "https://files.pythonhosted.org/packages/73/4d/7c4e2b3d9b1106cd0aa6cb56cc57c6267f59fa8bfab7d91df5adc802c847/msgpack-1.1.2-cp311-cp311-win_arm64.whl", hash = "sha256:86f8136dfa5c116365a8a651a7d7484b65b13339731dd6faebb9a0242151c406", size = 64755, upload-time = "2025-10-08T09:15:00.48Z" }, + { url = "https://files.pythonhosted.org/packages/ad/bd/8b0d01c756203fbab65d265859749860682ccd2a59594609aeec3a144efa/msgpack-1.1.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:70a0dff9d1f8da25179ffcf880e10cf1aad55fdb63cd59c9a49a1b82290062aa", size = 81939, upload-time = "2025-10-08T09:15:01.472Z" }, + { url = "https://files.pythonhosted.org/packages/34/68/ba4f155f793a74c1483d4bdef136e1023f7bcba557f0db4ef3db3c665cf1/msgpack-1.1.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:446abdd8b94b55c800ac34b102dffd2f6aa0ce643c55dfc017ad89347db3dbdb", size = 85064, upload-time = "2025-10-08T09:15:03.764Z" }, + { url = "https://files.pythonhosted.org/packages/f2/60/a064b0345fc36c4c3d2c743c82d9100c40388d77f0b48b2f04d6041dbec1/msgpack-1.1.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c63eea553c69ab05b6747901b97d620bb2a690633c77f23feb0c6a947a8a7b8f", size = 417131, upload-time = "2025-10-08T09:15:05.136Z" }, + { url = "https://files.pythonhosted.org/packages/65/92/a5100f7185a800a5d29f8d14041f61475b9de465ffcc0f3b9fba606e4505/msgpack-1.1.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:372839311ccf6bdaf39b00b61288e0557916c3729529b301c52c2d88842add42", size = 427556, upload-time = "2025-10-08T09:15:06.837Z" }, + { url = "https://files.pythonhosted.org/packages/f5/87/ffe21d1bf7d9991354ad93949286f643b2bb6ddbeab66373922b44c3b8cc/msgpack-1.1.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2929af52106ca73fcb28576218476ffbb531a036c2adbcf54a3664de124303e9", size = 404920, upload-time = "2025-10-08T09:15:08.179Z" }, + { url = "https://files.pythonhosted.org/packages/ff/41/8543ed2b8604f7c0d89ce066f42007faac1eaa7d79a81555f206a5cdb889/msgpack-1.1.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:be52a8fc79e45b0364210eef5234a7cf8d330836d0a64dfbb878efa903d84620", size = 415013, upload-time = "2025-10-08T09:15:09.83Z" }, + { url = "https://files.pythonhosted.org/packages/41/0d/2ddfaa8b7e1cee6c490d46cb0a39742b19e2481600a7a0e96537e9c22f43/msgpack-1.1.2-cp312-cp312-win32.whl", hash = "sha256:1fff3d825d7859ac888b0fbda39a42d59193543920eda9d9bea44d958a878029", size = 65096, upload-time = "2025-10-08T09:15:11.11Z" }, + { url = "https://files.pythonhosted.org/packages/8c/ec/d431eb7941fb55a31dd6ca3404d41fbb52d99172df2e7707754488390910/msgpack-1.1.2-cp312-cp312-win_amd64.whl", hash = "sha256:1de460f0403172cff81169a30b9a92b260cb809c4cb7e2fc79ae8d0510c78b6b", size = 72708, upload-time = "2025-10-08T09:15:12.554Z" }, + { url = "https://files.pythonhosted.org/packages/c5/31/5b1a1f70eb0e87d1678e9624908f86317787b536060641d6798e3cf70ace/msgpack-1.1.2-cp312-cp312-win_arm64.whl", hash = "sha256:be5980f3ee0e6bd44f3a9e9dea01054f175b50c3e6cdb692bc9424c0bbb8bf69", size = 64119, upload-time = "2025-10-08T09:15:13.589Z" }, + { url = "https://files.pythonhosted.org/packages/6b/31/b46518ecc604d7edf3a4f94cb3bf021fc62aa301f0cb849936968164ef23/msgpack-1.1.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4efd7b5979ccb539c221a4c4e16aac1a533efc97f3b759bb5a5ac9f6d10383bf", size = 81212, upload-time = "2025-10-08T09:15:14.552Z" }, + { url = "https://files.pythonhosted.org/packages/92/dc/c385f38f2c2433333345a82926c6bfa5ecfff3ef787201614317b58dd8be/msgpack-1.1.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:42eefe2c3e2af97ed470eec850facbe1b5ad1d6eacdbadc42ec98e7dcf68b4b7", size = 84315, upload-time = "2025-10-08T09:15:15.543Z" }, + { url = "https://files.pythonhosted.org/packages/d3/68/93180dce57f684a61a88a45ed13047558ded2be46f03acb8dec6d7c513af/msgpack-1.1.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1fdf7d83102bf09e7ce3357de96c59b627395352a4024f6e2458501f158bf999", size = 412721, upload-time = "2025-10-08T09:15:16.567Z" }, + { url = "https://files.pythonhosted.org/packages/5d/ba/459f18c16f2b3fc1a1ca871f72f07d70c07bf768ad0a507a698b8052ac58/msgpack-1.1.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fac4be746328f90caa3cd4bc67e6fe36ca2bf61d5c6eb6d895b6527e3f05071e", size = 424657, upload-time = "2025-10-08T09:15:17.825Z" }, + { url = "https://files.pythonhosted.org/packages/38/f8/4398c46863b093252fe67368b44edc6c13b17f4e6b0e4929dbf0bdb13f23/msgpack-1.1.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:fffee09044073e69f2bad787071aeec727183e7580443dfeb8556cbf1978d162", size = 402668, upload-time = "2025-10-08T09:15:19.003Z" }, + { url = "https://files.pythonhosted.org/packages/28/ce/698c1eff75626e4124b4d78e21cca0b4cc90043afb80a507626ea354ab52/msgpack-1.1.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:5928604de9b032bc17f5099496417f113c45bc6bc21b5c6920caf34b3c428794", size = 419040, upload-time = "2025-10-08T09:15:20.183Z" }, + { url = "https://files.pythonhosted.org/packages/67/32/f3cd1667028424fa7001d82e10ee35386eea1408b93d399b09fb0aa7875f/msgpack-1.1.2-cp313-cp313-win32.whl", hash = "sha256:a7787d353595c7c7e145e2331abf8b7ff1e6673a6b974ded96e6d4ec09f00c8c", size = 65037, upload-time = "2025-10-08T09:15:21.416Z" }, + { url = "https://files.pythonhosted.org/packages/74/07/1ed8277f8653c40ebc65985180b007879f6a836c525b3885dcc6448ae6cb/msgpack-1.1.2-cp313-cp313-win_amd64.whl", hash = "sha256:a465f0dceb8e13a487e54c07d04ae3ba131c7c5b95e2612596eafde1dccf64a9", size = 72631, upload-time = "2025-10-08T09:15:22.431Z" }, + { url = "https://files.pythonhosted.org/packages/e5/db/0314e4e2db56ebcf450f277904ffd84a7988b9e5da8d0d61ab2d057df2b6/msgpack-1.1.2-cp313-cp313-win_arm64.whl", hash = "sha256:e69b39f8c0aa5ec24b57737ebee40be647035158f14ed4b40e6f150077e21a84", size = 64118, upload-time = "2025-10-08T09:15:23.402Z" }, + { url = "https://files.pythonhosted.org/packages/22/71/201105712d0a2ff07b7873ed3c220292fb2ea5120603c00c4b634bcdafb3/msgpack-1.1.2-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:e23ce8d5f7aa6ea6d2a2b326b4ba46c985dbb204523759984430db7114f8aa00", size = 81127, upload-time = "2025-10-08T09:15:24.408Z" }, + { url = "https://files.pythonhosted.org/packages/1b/9f/38ff9e57a2eade7bf9dfee5eae17f39fc0e998658050279cbb14d97d36d9/msgpack-1.1.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:6c15b7d74c939ebe620dd8e559384be806204d73b4f9356320632d783d1f7939", size = 84981, upload-time = "2025-10-08T09:15:25.812Z" }, + { url = "https://files.pythonhosted.org/packages/8e/a9/3536e385167b88c2cc8f4424c49e28d49a6fc35206d4a8060f136e71f94c/msgpack-1.1.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:99e2cb7b9031568a2a5c73aa077180f93dd2e95b4f8d3b8e14a73ae94a9e667e", size = 411885, upload-time = "2025-10-08T09:15:27.22Z" }, + { url = "https://files.pythonhosted.org/packages/2f/40/dc34d1a8d5f1e51fc64640b62b191684da52ca469da9cd74e84936ffa4a6/msgpack-1.1.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:180759d89a057eab503cf62eeec0aa61c4ea1200dee709f3a8e9397dbb3b6931", size = 419658, upload-time = "2025-10-08T09:15:28.4Z" }, + { url = "https://files.pythonhosted.org/packages/3b/ef/2b92e286366500a09a67e03496ee8b8ba00562797a52f3c117aa2b29514b/msgpack-1.1.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:04fb995247a6e83830b62f0b07bf36540c213f6eac8e851166d8d86d83cbd014", size = 403290, upload-time = "2025-10-08T09:15:29.764Z" }, + { url = "https://files.pythonhosted.org/packages/78/90/e0ea7990abea5764e4655b8177aa7c63cdfa89945b6e7641055800f6c16b/msgpack-1.1.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:8e22ab046fa7ede9e36eeb4cfad44d46450f37bb05d5ec482b02868f451c95e2", size = 415234, upload-time = "2025-10-08T09:15:31.022Z" }, + { url = "https://files.pythonhosted.org/packages/72/4e/9390aed5db983a2310818cd7d3ec0aecad45e1f7007e0cda79c79507bb0d/msgpack-1.1.2-cp314-cp314-win32.whl", hash = "sha256:80a0ff7d4abf5fecb995fcf235d4064b9a9a8a40a3ab80999e6ac1e30b702717", size = 66391, upload-time = "2025-10-08T09:15:32.265Z" }, + { url = "https://files.pythonhosted.org/packages/6e/f1/abd09c2ae91228c5f3998dbd7f41353def9eac64253de3c8105efa2082f7/msgpack-1.1.2-cp314-cp314-win_amd64.whl", hash = "sha256:9ade919fac6a3e7260b7f64cea89df6bec59104987cbea34d34a2fa15d74310b", size = 73787, upload-time = "2025-10-08T09:15:33.219Z" }, + { url = "https://files.pythonhosted.org/packages/6a/b0/9d9f667ab48b16ad4115c1935d94023b82b3198064cb84a123e97f7466c1/msgpack-1.1.2-cp314-cp314-win_arm64.whl", hash = "sha256:59415c6076b1e30e563eb732e23b994a61c159cec44deaf584e5cc1dd662f2af", size = 66453, upload-time = "2025-10-08T09:15:34.225Z" }, + { url = "https://files.pythonhosted.org/packages/16/67/93f80545eb1792b61a217fa7f06d5e5cb9e0055bed867f43e2b8e012e137/msgpack-1.1.2-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:897c478140877e5307760b0ea66e0932738879e7aa68144d9b78ea4c8302a84a", size = 85264, upload-time = "2025-10-08T09:15:35.61Z" }, + { url = "https://files.pythonhosted.org/packages/87/1c/33c8a24959cf193966ef11a6f6a2995a65eb066bd681fd085afd519a57ce/msgpack-1.1.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:a668204fa43e6d02f89dbe79a30b0d67238d9ec4c5bd8a940fc3a004a47b721b", size = 89076, upload-time = "2025-10-08T09:15:36.619Z" }, + { url = "https://files.pythonhosted.org/packages/fc/6b/62e85ff7193663fbea5c0254ef32f0c77134b4059f8da89b958beb7696f3/msgpack-1.1.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5559d03930d3aa0f3aacb4c42c776af1a2ace2611871c84a75afe436695e6245", size = 435242, upload-time = "2025-10-08T09:15:37.647Z" }, + { url = "https://files.pythonhosted.org/packages/c1/47/5c74ecb4cc277cf09f64e913947871682ffa82b3b93c8dad68083112f412/msgpack-1.1.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:70c5a7a9fea7f036b716191c29047374c10721c389c21e9ffafad04df8c52c90", size = 432509, upload-time = "2025-10-08T09:15:38.794Z" }, + { url = "https://files.pythonhosted.org/packages/24/a4/e98ccdb56dc4e98c929a3f150de1799831c0a800583cde9fa022fa90602d/msgpack-1.1.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:f2cb069d8b981abc72b41aea1c580ce92d57c673ec61af4c500153a626cb9e20", size = 415957, upload-time = "2025-10-08T09:15:40.238Z" }, + { url = "https://files.pythonhosted.org/packages/da/28/6951f7fb67bc0a4e184a6b38ab71a92d9ba58080b27a77d3e2fb0be5998f/msgpack-1.1.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:d62ce1f483f355f61adb5433ebfd8868c5f078d1a52d042b0a998682b4fa8c27", size = 422910, upload-time = "2025-10-08T09:15:41.505Z" }, + { url = "https://files.pythonhosted.org/packages/f0/03/42106dcded51f0a0b5284d3ce30a671e7bd3f7318d122b2ead66ad289fed/msgpack-1.1.2-cp314-cp314t-win32.whl", hash = "sha256:1d1418482b1ee984625d88aa9585db570180c286d942da463533b238b98b812b", size = 75197, upload-time = "2025-10-08T09:15:42.954Z" }, + { url = "https://files.pythonhosted.org/packages/15/86/d0071e94987f8db59d4eeb386ddc64d0bb9b10820a8d82bcd3e53eeb2da6/msgpack-1.1.2-cp314-cp314t-win_amd64.whl", hash = "sha256:5a46bf7e831d09470ad92dff02b8b1ac92175ca36b087f904a0519857c6be3ff", size = 85772, upload-time = "2025-10-08T09:15:43.954Z" }, + { url = "https://files.pythonhosted.org/packages/81/f2/08ace4142eb281c12701fc3b93a10795e4d4dc7f753911d836675050f886/msgpack-1.1.2-cp314-cp314t-win_arm64.whl", hash = "sha256:d99ef64f349d5ec3293688e91486c5fdb925ed03807f64d98d205d2713c60b46", size = 70868, upload-time = "2025-10-08T09:15:44.959Z" }, +] + +[[package]] +name = "multidict" +version = "6.7.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/80/1e/5492c365f222f907de1039b91f922b93fa4f764c713ee858d235495d8f50/multidict-6.7.0.tar.gz", hash = "sha256:c6e99d9a65ca282e578dfea819cfa9c0a62b2499d8677392e09feaf305e9e6f5", size = 101834, upload-time = "2025-10-06T14:52:30.657Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a9/63/7bdd4adc330abcca54c85728db2327130e49e52e8c3ce685cec44e0f2e9f/multidict-6.7.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:9f474ad5acda359c8758c8accc22032c6abe6dc87a8be2440d097785e27a9349", size = 77153, upload-time = "2025-10-06T14:48:26.409Z" }, + { url = "https://files.pythonhosted.org/packages/3f/bb/b6c35ff175ed1a3142222b78455ee31be71a8396ed3ab5280fbe3ebe4e85/multidict-6.7.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:4b7a9db5a870f780220e931d0002bbfd88fb53aceb6293251e2c839415c1b20e", size = 44993, upload-time = "2025-10-06T14:48:28.4Z" }, + { url = "https://files.pythonhosted.org/packages/e0/1f/064c77877c5fa6df6d346e68075c0f6998547afe952d6471b4c5f6a7345d/multidict-6.7.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:03ca744319864e92721195fa28c7a3b2bc7b686246b35e4078c1e4d0eb5466d3", size = 44607, upload-time = "2025-10-06T14:48:29.581Z" }, + { url = "https://files.pythonhosted.org/packages/04/7a/bf6aa92065dd47f287690000b3d7d332edfccb2277634cadf6a810463c6a/multidict-6.7.0-cp310-cp310-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:f0e77e3c0008bc9316e662624535b88d360c3a5d3f81e15cf12c139a75250046", size = 241847, upload-time = "2025-10-06T14:48:32.107Z" }, + { url = "https://files.pythonhosted.org/packages/94/39/297a8de920f76eda343e4ce05f3b489f0ab3f9504f2576dfb37b7c08ca08/multidict-6.7.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:08325c9e5367aa379a3496aa9a022fe8837ff22e00b94db256d3a1378c76ab32", size = 242616, upload-time = "2025-10-06T14:48:34.054Z" }, + { url = "https://files.pythonhosted.org/packages/39/3a/d0eee2898cfd9d654aea6cb8c4addc2f9756e9a7e09391cfe55541f917f7/multidict-6.7.0-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e2862408c99f84aa571ab462d25236ef9cb12a602ea959ba9c9009a54902fc73", size = 222333, upload-time = "2025-10-06T14:48:35.9Z" }, + { url = "https://files.pythonhosted.org/packages/05/48/3b328851193c7a4240815b71eea165b49248867bbb6153a0aee227a0bb47/multidict-6.7.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4d72a9a2d885f5c208b0cb91ff2ed43636bb7e345ec839ff64708e04f69a13cc", size = 253239, upload-time = "2025-10-06T14:48:37.302Z" }, + { url = "https://files.pythonhosted.org/packages/b1/ca/0706a98c8d126a89245413225ca4a3fefc8435014de309cf8b30acb68841/multidict-6.7.0-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:478cc36476687bac1514d651cbbaa94b86b0732fb6855c60c673794c7dd2da62", size = 251618, upload-time = "2025-10-06T14:48:38.963Z" }, + { url = "https://files.pythonhosted.org/packages/5e/4f/9c7992f245554d8b173f6f0a048ad24b3e645d883f096857ec2c0822b8bd/multidict-6.7.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6843b28b0364dc605f21481c90fadb5f60d9123b442eb8a726bb74feef588a84", size = 241655, upload-time = "2025-10-06T14:48:40.312Z" }, + { url = "https://files.pythonhosted.org/packages/31/79/26a85991ae67efd1c0b1fc2e0c275b8a6aceeb155a68861f63f87a798f16/multidict-6.7.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:23bfeee5316266e5ee2d625df2d2c602b829435fc3a235c2ba2131495706e4a0", size = 239245, upload-time = "2025-10-06T14:48:41.848Z" }, + { url = "https://files.pythonhosted.org/packages/14/1e/75fa96394478930b79d0302eaf9a6c69f34005a1a5251ac8b9c336486ec9/multidict-6.7.0-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:680878b9f3d45c31e1f730eef731f9b0bc1da456155688c6745ee84eb818e90e", size = 233523, upload-time = "2025-10-06T14:48:43.749Z" }, + { url = "https://files.pythonhosted.org/packages/b2/5e/085544cb9f9c4ad2b5d97467c15f856df8d9bac410cffd5c43991a5d878b/multidict-6.7.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:eb866162ef2f45063acc7a53a88ef6fe8bf121d45c30ea3c9cd87ce7e191a8d4", size = 243129, upload-time = "2025-10-06T14:48:45.225Z" }, + { url = "https://files.pythonhosted.org/packages/b9/c3/e9d9e2f20c9474e7a8fcef28f863c5cbd29bb5adce6b70cebe8bdad0039d/multidict-6.7.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:df0e3bf7993bdbeca5ac25aa859cf40d39019e015c9c91809ba7093967f7a648", size = 248999, upload-time = "2025-10-06T14:48:46.703Z" }, + { url = "https://files.pythonhosted.org/packages/b5/3f/df171b6efa3239ae33b97b887e42671cd1d94d460614bfb2c30ffdab3b95/multidict-6.7.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:661709cdcd919a2ece2234f9bae7174e5220c80b034585d7d8a755632d3e2111", size = 243711, upload-time = "2025-10-06T14:48:48.146Z" }, + { url = "https://files.pythonhosted.org/packages/3c/2f/9b5564888c4e14b9af64c54acf149263721a283aaf4aa0ae89b091d5d8c1/multidict-6.7.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:096f52730c3fb8ed419db2d44391932b63891b2c5ed14850a7e215c0ba9ade36", size = 237504, upload-time = "2025-10-06T14:48:49.447Z" }, + { url = "https://files.pythonhosted.org/packages/6c/3a/0bd6ca0f7d96d790542d591c8c3354c1e1b6bfd2024d4d92dc3d87485ec7/multidict-6.7.0-cp310-cp310-win32.whl", hash = "sha256:afa8a2978ec65d2336305550535c9c4ff50ee527914328c8677b3973ade52b85", size = 41422, upload-time = "2025-10-06T14:48:50.789Z" }, + { url = "https://files.pythonhosted.org/packages/00/35/f6a637ea2c75f0d3b7c7d41b1189189acff0d9deeb8b8f35536bb30f5e33/multidict-6.7.0-cp310-cp310-win_amd64.whl", hash = "sha256:b15b3afff74f707b9275d5ba6a91ae8f6429c3ffb29bbfd216b0b375a56f13d7", size = 46050, upload-time = "2025-10-06T14:48:51.938Z" }, + { url = "https://files.pythonhosted.org/packages/e7/b8/f7bf8329b39893d02d9d95cf610c75885d12fc0f402b1c894e1c8e01c916/multidict-6.7.0-cp310-cp310-win_arm64.whl", hash = "sha256:4b73189894398d59131a66ff157837b1fafea9974be486d036bb3d32331fdbf0", size = 43153, upload-time = "2025-10-06T14:48:53.146Z" }, + { url = "https://files.pythonhosted.org/packages/34/9e/5c727587644d67b2ed479041e4b1c58e30afc011e3d45d25bbe35781217c/multidict-6.7.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:4d409aa42a94c0b3fa617708ef5276dfe81012ba6753a0370fcc9d0195d0a1fc", size = 76604, upload-time = "2025-10-06T14:48:54.277Z" }, + { url = "https://files.pythonhosted.org/packages/17/e4/67b5c27bd17c085a5ea8f1ec05b8a3e5cba0ca734bfcad5560fb129e70ca/multidict-6.7.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:14c9e076eede3b54c636f8ce1c9c252b5f057c62131211f0ceeec273810c9721", size = 44715, upload-time = "2025-10-06T14:48:55.445Z" }, + { url = "https://files.pythonhosted.org/packages/4d/e1/866a5d77be6ea435711bef2a4291eed11032679b6b28b56b4776ab06ba3e/multidict-6.7.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4c09703000a9d0fa3c3404b27041e574cc7f4df4c6563873246d0e11812a94b6", size = 44332, upload-time = "2025-10-06T14:48:56.706Z" }, + { url = "https://files.pythonhosted.org/packages/31/61/0c2d50241ada71ff61a79518db85ada85fdabfcf395d5968dae1cbda04e5/multidict-6.7.0-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:a265acbb7bb33a3a2d626afbe756371dce0279e7b17f4f4eda406459c2b5ff1c", size = 245212, upload-time = "2025-10-06T14:48:58.042Z" }, + { url = "https://files.pythonhosted.org/packages/ac/e0/919666a4e4b57fff1b57f279be1c9316e6cdc5de8a8b525d76f6598fefc7/multidict-6.7.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:51cb455de290ae462593e5b1cb1118c5c22ea7f0d3620d9940bf695cea5a4bd7", size = 246671, upload-time = "2025-10-06T14:49:00.004Z" }, + { url = "https://files.pythonhosted.org/packages/a1/cc/d027d9c5a520f3321b65adea289b965e7bcbd2c34402663f482648c716ce/multidict-6.7.0-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:db99677b4457c7a5c5a949353e125ba72d62b35f74e26da141530fbb012218a7", size = 225491, upload-time = "2025-10-06T14:49:01.393Z" }, + { url = "https://files.pythonhosted.org/packages/75/c4/bbd633980ce6155a28ff04e6a6492dd3335858394d7bb752d8b108708558/multidict-6.7.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f470f68adc395e0183b92a2f4689264d1ea4b40504a24d9882c27375e6662bb9", size = 257322, upload-time = "2025-10-06T14:49:02.745Z" }, + { url = "https://files.pythonhosted.org/packages/4c/6d/d622322d344f1f053eae47e033b0b3f965af01212de21b10bcf91be991fb/multidict-6.7.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0db4956f82723cc1c270de9c6e799b4c341d327762ec78ef82bb962f79cc07d8", size = 254694, upload-time = "2025-10-06T14:49:04.15Z" }, + { url = "https://files.pythonhosted.org/packages/a8/9f/78f8761c2705d4c6d7516faed63c0ebdac569f6db1bef95e0d5218fdc146/multidict-6.7.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3e56d780c238f9e1ae66a22d2adf8d16f485381878250db8d496623cd38b22bd", size = 246715, upload-time = "2025-10-06T14:49:05.967Z" }, + { url = "https://files.pythonhosted.org/packages/78/59/950818e04f91b9c2b95aab3d923d9eabd01689d0dcd889563988e9ea0fd8/multidict-6.7.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:9d14baca2ee12c1a64740d4531356ba50b82543017f3ad6de0deb943c5979abb", size = 243189, upload-time = "2025-10-06T14:49:07.37Z" }, + { url = "https://files.pythonhosted.org/packages/7a/3d/77c79e1934cad2ee74991840f8a0110966d9599b3af95964c0cd79bb905b/multidict-6.7.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:295a92a76188917c7f99cda95858c822f9e4aae5824246bba9b6b44004ddd0a6", size = 237845, upload-time = "2025-10-06T14:49:08.759Z" }, + { url = "https://files.pythonhosted.org/packages/63/1b/834ce32a0a97a3b70f86437f685f880136677ac00d8bce0027e9fd9c2db7/multidict-6.7.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:39f1719f57adbb767ef592a50ae5ebb794220d1188f9ca93de471336401c34d2", size = 246374, upload-time = "2025-10-06T14:49:10.574Z" }, + { url = "https://files.pythonhosted.org/packages/23/ef/43d1c3ba205b5dec93dc97f3fba179dfa47910fc73aaaea4f7ceb41cec2a/multidict-6.7.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:0a13fb8e748dfc94749f622de065dd5c1def7e0d2216dba72b1d8069a389c6ff", size = 253345, upload-time = "2025-10-06T14:49:12.331Z" }, + { url = "https://files.pythonhosted.org/packages/6b/03/eaf95bcc2d19ead522001f6a650ef32811aa9e3624ff0ad37c445c7a588c/multidict-6.7.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:e3aa16de190d29a0ea1b48253c57d99a68492c8dd8948638073ab9e74dc9410b", size = 246940, upload-time = "2025-10-06T14:49:13.821Z" }, + { url = "https://files.pythonhosted.org/packages/e8/df/ec8a5fd66ea6cd6f525b1fcbb23511b033c3e9bc42b81384834ffa484a62/multidict-6.7.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:a048ce45dcdaaf1defb76b2e684f997fb5abf74437b6cb7b22ddad934a964e34", size = 242229, upload-time = "2025-10-06T14:49:15.603Z" }, + { url = "https://files.pythonhosted.org/packages/8a/a2/59b405d59fd39ec86d1142630e9049243015a5f5291ba49cadf3c090c541/multidict-6.7.0-cp311-cp311-win32.whl", hash = "sha256:a90af66facec4cebe4181b9e62a68be65e45ac9b52b67de9eec118701856e7ff", size = 41308, upload-time = "2025-10-06T14:49:16.871Z" }, + { url = "https://files.pythonhosted.org/packages/32/0f/13228f26f8b882c34da36efa776c3b7348455ec383bab4a66390e42963ae/multidict-6.7.0-cp311-cp311-win_amd64.whl", hash = "sha256:95b5ffa4349df2887518bb839409bcf22caa72d82beec453216802f475b23c81", size = 46037, upload-time = "2025-10-06T14:49:18.457Z" }, + { url = "https://files.pythonhosted.org/packages/84/1f/68588e31b000535a3207fd3c909ebeec4fb36b52c442107499c18a896a2a/multidict-6.7.0-cp311-cp311-win_arm64.whl", hash = "sha256:329aa225b085b6f004a4955271a7ba9f1087e39dcb7e65f6284a988264a63912", size = 43023, upload-time = "2025-10-06T14:49:19.648Z" }, + { url = "https://files.pythonhosted.org/packages/c2/9e/9f61ac18d9c8b475889f32ccfa91c9f59363480613fc807b6e3023d6f60b/multidict-6.7.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:8a3862568a36d26e650a19bb5cbbba14b71789032aebc0423f8cc5f150730184", size = 76877, upload-time = "2025-10-06T14:49:20.884Z" }, + { url = "https://files.pythonhosted.org/packages/38/6f/614f09a04e6184f8824268fce4bc925e9849edfa654ddd59f0b64508c595/multidict-6.7.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:960c60b5849b9b4f9dcc9bea6e3626143c252c74113df2c1540aebce70209b45", size = 45467, upload-time = "2025-10-06T14:49:22.054Z" }, + { url = "https://files.pythonhosted.org/packages/b3/93/c4f67a436dd026f2e780c433277fff72be79152894d9fc36f44569cab1a6/multidict-6.7.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2049be98fb57a31b4ccf870bf377af2504d4ae35646a19037ec271e4c07998aa", size = 43834, upload-time = "2025-10-06T14:49:23.566Z" }, + { url = "https://files.pythonhosted.org/packages/7f/f5/013798161ca665e4a422afbc5e2d9e4070142a9ff8905e482139cd09e4d0/multidict-6.7.0-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:0934f3843a1860dd465d38895c17fce1f1cb37295149ab05cd1b9a03afacb2a7", size = 250545, upload-time = "2025-10-06T14:49:24.882Z" }, + { url = "https://files.pythonhosted.org/packages/71/2f/91dbac13e0ba94669ea5119ba267c9a832f0cb65419aca75549fcf09a3dc/multidict-6.7.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b3e34f3a1b8131ba06f1a73adab24f30934d148afcd5f5de9a73565a4404384e", size = 258305, upload-time = "2025-10-06T14:49:26.778Z" }, + { url = "https://files.pythonhosted.org/packages/ef/b0/754038b26f6e04488b48ac621f779c341338d78503fb45403755af2df477/multidict-6.7.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:efbb54e98446892590dc2458c19c10344ee9a883a79b5cec4bc34d6656e8d546", size = 242363, upload-time = "2025-10-06T14:49:28.562Z" }, + { url = "https://files.pythonhosted.org/packages/87/15/9da40b9336a7c9fa606c4cf2ed80a649dffeb42b905d4f63a1d7eb17d746/multidict-6.7.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a35c5fc61d4f51eb045061e7967cfe3123d622cd500e8868e7c0c592a09fedc4", size = 268375, upload-time = "2025-10-06T14:49:29.96Z" }, + { url = "https://files.pythonhosted.org/packages/82/72/c53fcade0cc94dfaad583105fd92b3a783af2091eddcb41a6d5a52474000/multidict-6.7.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:29fe6740ebccba4175af1b9b87bf553e9c15cd5868ee967e010efcf94e4fd0f1", size = 269346, upload-time = "2025-10-06T14:49:31.404Z" }, + { url = "https://files.pythonhosted.org/packages/0d/e2/9baffdae21a76f77ef8447f1a05a96ec4bc0a24dae08767abc0a2fe680b8/multidict-6.7.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:123e2a72e20537add2f33a79e605f6191fba2afda4cbb876e35c1a7074298a7d", size = 256107, upload-time = "2025-10-06T14:49:32.974Z" }, + { url = "https://files.pythonhosted.org/packages/3c/06/3f06f611087dc60d65ef775f1fb5aca7c6d61c6db4990e7cda0cef9b1651/multidict-6.7.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:b284e319754366c1aee2267a2036248b24eeb17ecd5dc16022095e747f2f4304", size = 253592, upload-time = "2025-10-06T14:49:34.52Z" }, + { url = "https://files.pythonhosted.org/packages/20/24/54e804ec7945b6023b340c412ce9c3f81e91b3bf5fa5ce65558740141bee/multidict-6.7.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:803d685de7be4303b5a657b76e2f6d1240e7e0a8aa2968ad5811fa2285553a12", size = 251024, upload-time = "2025-10-06T14:49:35.956Z" }, + { url = "https://files.pythonhosted.org/packages/14/48/011cba467ea0b17ceb938315d219391d3e421dfd35928e5dbdc3f4ae76ef/multidict-6.7.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:c04a328260dfd5db8c39538f999f02779012268f54614902d0afc775d44e0a62", size = 251484, upload-time = "2025-10-06T14:49:37.631Z" }, + { url = "https://files.pythonhosted.org/packages/0d/2f/919258b43bb35b99fa127435cfb2d91798eb3a943396631ef43e3720dcf4/multidict-6.7.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:8a19cdb57cd3df4cd865849d93ee14920fb97224300c88501f16ecfa2604b4e0", size = 263579, upload-time = "2025-10-06T14:49:39.502Z" }, + { url = "https://files.pythonhosted.org/packages/31/22/a0e884d86b5242b5a74cf08e876bdf299e413016b66e55511f7a804a366e/multidict-6.7.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:9b2fd74c52accced7e75de26023b7dccee62511a600e62311b918ec5c168fc2a", size = 259654, upload-time = "2025-10-06T14:49:41.32Z" }, + { url = "https://files.pythonhosted.org/packages/b2/e5/17e10e1b5c5f5a40f2fcbb45953c9b215f8a4098003915e46a93f5fcaa8f/multidict-6.7.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3e8bfdd0e487acf992407a140d2589fe598238eaeffa3da8448d63a63cd363f8", size = 251511, upload-time = "2025-10-06T14:49:46.021Z" }, + { url = "https://files.pythonhosted.org/packages/e3/9a/201bb1e17e7af53139597069c375e7b0dcbd47594604f65c2d5359508566/multidict-6.7.0-cp312-cp312-win32.whl", hash = "sha256:dd32a49400a2c3d52088e120ee00c1e3576cbff7e10b98467962c74fdb762ed4", size = 41895, upload-time = "2025-10-06T14:49:48.718Z" }, + { url = "https://files.pythonhosted.org/packages/46/e2/348cd32faad84eaf1d20cce80e2bb0ef8d312c55bca1f7fa9865e7770aaf/multidict-6.7.0-cp312-cp312-win_amd64.whl", hash = "sha256:92abb658ef2d7ef22ac9f8bb88e8b6c3e571671534e029359b6d9e845923eb1b", size = 46073, upload-time = "2025-10-06T14:49:50.28Z" }, + { url = "https://files.pythonhosted.org/packages/25/ec/aad2613c1910dce907480e0c3aa306905830f25df2e54ccc9dea450cb5aa/multidict-6.7.0-cp312-cp312-win_arm64.whl", hash = "sha256:490dab541a6a642ce1a9d61a4781656b346a55c13038f0b1244653828e3a83ec", size = 43226, upload-time = "2025-10-06T14:49:52.304Z" }, + { url = "https://files.pythonhosted.org/packages/d2/86/33272a544eeb36d66e4d9a920602d1a2f57d4ebea4ef3cdfe5a912574c95/multidict-6.7.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:bee7c0588aa0076ce77c0ea5d19a68d76ad81fcd9fe8501003b9a24f9d4000f6", size = 76135, upload-time = "2025-10-06T14:49:54.26Z" }, + { url = "https://files.pythonhosted.org/packages/91/1c/eb97db117a1ebe46d457a3d235a7b9d2e6dcab174f42d1b67663dd9e5371/multidict-6.7.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:7ef6b61cad77091056ce0e7ce69814ef72afacb150b7ac6a3e9470def2198159", size = 45117, upload-time = "2025-10-06T14:49:55.82Z" }, + { url = "https://files.pythonhosted.org/packages/f1/d8/6c3442322e41fb1dd4de8bd67bfd11cd72352ac131f6368315617de752f1/multidict-6.7.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:9c0359b1ec12b1d6849c59f9d319610b7f20ef990a6d454ab151aa0e3b9f78ca", size = 43472, upload-time = "2025-10-06T14:49:57.048Z" }, + { url = "https://files.pythonhosted.org/packages/75/3f/e2639e80325af0b6c6febdf8e57cc07043ff15f57fa1ef808f4ccb5ac4cd/multidict-6.7.0-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:cd240939f71c64bd658f186330603aac1a9a81bf6273f523fca63673cb7378a8", size = 249342, upload-time = "2025-10-06T14:49:58.368Z" }, + { url = "https://files.pythonhosted.org/packages/5d/cc/84e0585f805cbeaa9cbdaa95f9a3d6aed745b9d25700623ac89a6ecff400/multidict-6.7.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a60a4d75718a5efa473ebd5ab685786ba0c67b8381f781d1be14da49f1a2dc60", size = 257082, upload-time = "2025-10-06T14:49:59.89Z" }, + { url = "https://files.pythonhosted.org/packages/b0/9c/ac851c107c92289acbbf5cfb485694084690c1b17e555f44952c26ddc5bd/multidict-6.7.0-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:53a42d364f323275126aff81fb67c5ca1b7a04fda0546245730a55c8c5f24bc4", size = 240704, upload-time = "2025-10-06T14:50:01.485Z" }, + { url = "https://files.pythonhosted.org/packages/50/cc/5f93e99427248c09da95b62d64b25748a5f5c98c7c2ab09825a1d6af0e15/multidict-6.7.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:3b29b980d0ddbecb736735ee5bef69bb2ddca56eff603c86f3f29a1128299b4f", size = 266355, upload-time = "2025-10-06T14:50:02.955Z" }, + { url = "https://files.pythonhosted.org/packages/ec/0c/2ec1d883ceb79c6f7f6d7ad90c919c898f5d1c6ea96d322751420211e072/multidict-6.7.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f8a93b1c0ed2d04b97a5e9336fd2d33371b9a6e29ab7dd6503d63407c20ffbaf", size = 267259, upload-time = "2025-10-06T14:50:04.446Z" }, + { url = "https://files.pythonhosted.org/packages/c6/2d/f0b184fa88d6630aa267680bdb8623fb69cb0d024b8c6f0d23f9a0f406d3/multidict-6.7.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9ff96e8815eecacc6645da76c413eb3b3d34cfca256c70b16b286a687d013c32", size = 254903, upload-time = "2025-10-06T14:50:05.98Z" }, + { url = "https://files.pythonhosted.org/packages/06/c9/11ea263ad0df7dfabcad404feb3c0dd40b131bc7f232d5537f2fb1356951/multidict-6.7.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:7516c579652f6a6be0e266aec0acd0db80829ca305c3d771ed898538804c2036", size = 252365, upload-time = "2025-10-06T14:50:07.511Z" }, + { url = "https://files.pythonhosted.org/packages/41/88/d714b86ee2c17d6e09850c70c9d310abac3d808ab49dfa16b43aba9d53fd/multidict-6.7.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:040f393368e63fb0f3330e70c26bfd336656bed925e5cbe17c9da839a6ab13ec", size = 250062, upload-time = "2025-10-06T14:50:09.074Z" }, + { url = "https://files.pythonhosted.org/packages/15/fe/ad407bb9e818c2b31383f6131ca19ea7e35ce93cf1310fce69f12e89de75/multidict-6.7.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:b3bc26a951007b1057a1c543af845f1c7e3e71cc240ed1ace7bf4484aa99196e", size = 249683, upload-time = "2025-10-06T14:50:10.714Z" }, + { url = "https://files.pythonhosted.org/packages/8c/a4/a89abdb0229e533fb925e7c6e5c40201c2873efebc9abaf14046a4536ee6/multidict-6.7.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:7b022717c748dd1992a83e219587aabe45980d88969f01b316e78683e6285f64", size = 261254, upload-time = "2025-10-06T14:50:12.28Z" }, + { url = "https://files.pythonhosted.org/packages/8d/aa/0e2b27bd88b40a4fb8dc53dd74eecac70edaa4c1dd0707eb2164da3675b3/multidict-6.7.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:9600082733859f00d79dee64effc7aef1beb26adb297416a4ad2116fd61374bd", size = 257967, upload-time = "2025-10-06T14:50:14.16Z" }, + { url = "https://files.pythonhosted.org/packages/d0/8e/0c67b7120d5d5f6d874ed85a085f9dc770a7f9d8813e80f44a9fec820bb7/multidict-6.7.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:94218fcec4d72bc61df51c198d098ce2b378e0ccbac41ddbed5ef44092913288", size = 250085, upload-time = "2025-10-06T14:50:15.639Z" }, + { url = "https://files.pythonhosted.org/packages/ba/55/b73e1d624ea4b8fd4dd07a3bb70f6e4c7c6c5d9d640a41c6ffe5cdbd2a55/multidict-6.7.0-cp313-cp313-win32.whl", hash = "sha256:a37bd74c3fa9d00be2d7b8eca074dc56bd8077ddd2917a839bd989612671ed17", size = 41713, upload-time = "2025-10-06T14:50:17.066Z" }, + { url = "https://files.pythonhosted.org/packages/32/31/75c59e7d3b4205075b4c183fa4ca398a2daf2303ddf616b04ae6ef55cffe/multidict-6.7.0-cp313-cp313-win_amd64.whl", hash = "sha256:30d193c6cc6d559db42b6bcec8a5d395d34d60c9877a0b71ecd7c204fcf15390", size = 45915, upload-time = "2025-10-06T14:50:18.264Z" }, + { url = "https://files.pythonhosted.org/packages/31/2a/8987831e811f1184c22bc2e45844934385363ee61c0a2dcfa8f71b87e608/multidict-6.7.0-cp313-cp313-win_arm64.whl", hash = "sha256:ea3334cabe4d41b7ccd01e4d349828678794edbc2d3ae97fc162a3312095092e", size = 43077, upload-time = "2025-10-06T14:50:19.853Z" }, + { url = "https://files.pythonhosted.org/packages/e8/68/7b3a5170a382a340147337b300b9eb25a9ddb573bcdfff19c0fa3f31ffba/multidict-6.7.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:ad9ce259f50abd98a1ca0aa6e490b58c316a0fce0617f609723e40804add2c00", size = 83114, upload-time = "2025-10-06T14:50:21.223Z" }, + { url = "https://files.pythonhosted.org/packages/55/5c/3fa2d07c84df4e302060f555bbf539310980362236ad49f50eeb0a1c1eb9/multidict-6.7.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:07f5594ac6d084cbb5de2df218d78baf55ef150b91f0ff8a21cc7a2e3a5a58eb", size = 48442, upload-time = "2025-10-06T14:50:22.871Z" }, + { url = "https://files.pythonhosted.org/packages/fc/56/67212d33239797f9bd91962bb899d72bb0f4c35a8652dcdb8ed049bef878/multidict-6.7.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:0591b48acf279821a579282444814a2d8d0af624ae0bc600aa4d1b920b6e924b", size = 46885, upload-time = "2025-10-06T14:50:24.258Z" }, + { url = "https://files.pythonhosted.org/packages/46/d1/908f896224290350721597a61a69cd19b89ad8ee0ae1f38b3f5cd12ea2ac/multidict-6.7.0-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:749a72584761531d2b9467cfbdfd29487ee21124c304c4b6cb760d8777b27f9c", size = 242588, upload-time = "2025-10-06T14:50:25.716Z" }, + { url = "https://files.pythonhosted.org/packages/ab/67/8604288bbd68680eee0ab568fdcb56171d8b23a01bcd5cb0c8fedf6e5d99/multidict-6.7.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b4c3d199f953acd5b446bf7c0de1fe25d94e09e79086f8dc2f48a11a129cdf1", size = 249966, upload-time = "2025-10-06T14:50:28.192Z" }, + { url = "https://files.pythonhosted.org/packages/20/33/9228d76339f1ba51e3efef7da3ebd91964d3006217aae13211653193c3ff/multidict-6.7.0-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:9fb0211dfc3b51efea2f349ec92c114d7754dd62c01f81c3e32b765b70c45c9b", size = 228618, upload-time = "2025-10-06T14:50:29.82Z" }, + { url = "https://files.pythonhosted.org/packages/f8/2d/25d9b566d10cab1c42b3b9e5b11ef79c9111eaf4463b8c257a3bd89e0ead/multidict-6.7.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a027ec240fe73a8d6281872690b988eed307cd7d91b23998ff35ff577ca688b5", size = 257539, upload-time = "2025-10-06T14:50:31.731Z" }, + { url = "https://files.pythonhosted.org/packages/b6/b1/8d1a965e6637fc33de3c0d8f414485c2b7e4af00f42cab3d84e7b955c222/multidict-6.7.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d1d964afecdf3a8288789df2f5751dc0a8261138c3768d9af117ed384e538fad", size = 256345, upload-time = "2025-10-06T14:50:33.26Z" }, + { url = "https://files.pythonhosted.org/packages/ba/0c/06b5a8adbdeedada6f4fb8d8f193d44a347223b11939b42953eeb6530b6b/multidict-6.7.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:caf53b15b1b7df9fbd0709aa01409000a2b4dd03a5f6f5cc548183c7c8f8b63c", size = 247934, upload-time = "2025-10-06T14:50:34.808Z" }, + { url = "https://files.pythonhosted.org/packages/8f/31/b2491b5fe167ca044c6eb4b8f2c9f3b8a00b24c432c365358eadac5d7625/multidict-6.7.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:654030da3197d927f05a536a66186070e98765aa5142794c9904555d3a9d8fb5", size = 245243, upload-time = "2025-10-06T14:50:36.436Z" }, + { url = "https://files.pythonhosted.org/packages/61/1a/982913957cb90406c8c94f53001abd9eafc271cb3e70ff6371590bec478e/multidict-6.7.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:2090d3718829d1e484706a2f525e50c892237b2bf9b17a79b059cb98cddc2f10", size = 235878, upload-time = "2025-10-06T14:50:37.953Z" }, + { url = "https://files.pythonhosted.org/packages/be/c0/21435d804c1a1cf7a2608593f4d19bca5bcbd7a81a70b253fdd1c12af9c0/multidict-6.7.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:2d2cfeec3f6f45651b3d408c4acec0ebf3daa9bc8a112a084206f5db5d05b754", size = 243452, upload-time = "2025-10-06T14:50:39.574Z" }, + { url = "https://files.pythonhosted.org/packages/54/0a/4349d540d4a883863191be6eb9a928846d4ec0ea007d3dcd36323bb058ac/multidict-6.7.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:4ef089f985b8c194d341eb2c24ae6e7408c9a0e2e5658699c92f497437d88c3c", size = 252312, upload-time = "2025-10-06T14:50:41.612Z" }, + { url = "https://files.pythonhosted.org/packages/26/64/d5416038dbda1488daf16b676e4dbfd9674dde10a0cc8f4fc2b502d8125d/multidict-6.7.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:e93a0617cd16998784bf4414c7e40f17a35d2350e5c6f0bd900d3a8e02bd3762", size = 246935, upload-time = "2025-10-06T14:50:43.972Z" }, + { url = "https://files.pythonhosted.org/packages/9f/8c/8290c50d14e49f35e0bd4abc25e1bc7711149ca9588ab7d04f886cdf03d9/multidict-6.7.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:f0feece2ef8ebc42ed9e2e8c78fc4aa3cf455733b507c09ef7406364c94376c6", size = 243385, upload-time = "2025-10-06T14:50:45.648Z" }, + { url = "https://files.pythonhosted.org/packages/ef/a0/f83ae75e42d694b3fbad3e047670e511c138be747bc713cf1b10d5096416/multidict-6.7.0-cp313-cp313t-win32.whl", hash = "sha256:19a1d55338ec1be74ef62440ca9e04a2f001a04d0cc49a4983dc320ff0f3212d", size = 47777, upload-time = "2025-10-06T14:50:47.154Z" }, + { url = "https://files.pythonhosted.org/packages/dc/80/9b174a92814a3830b7357307a792300f42c9e94664b01dee8e457551fa66/multidict-6.7.0-cp313-cp313t-win_amd64.whl", hash = "sha256:3da4fb467498df97e986af166b12d01f05d2e04f978a9c1c680ea1988e0bc4b6", size = 53104, upload-time = "2025-10-06T14:50:48.851Z" }, + { url = "https://files.pythonhosted.org/packages/cc/28/04baeaf0428d95bb7a7bea0e691ba2f31394338ba424fb0679a9ed0f4c09/multidict-6.7.0-cp313-cp313t-win_arm64.whl", hash = "sha256:b4121773c49a0776461f4a904cdf6264c88e42218aaa8407e803ca8025872792", size = 45503, upload-time = "2025-10-06T14:50:50.16Z" }, + { url = "https://files.pythonhosted.org/packages/e2/b1/3da6934455dd4b261d4c72f897e3a5728eba81db59959f3a639245891baa/multidict-6.7.0-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:3bab1e4aff7adaa34410f93b1f8e57c4b36b9af0426a76003f441ee1d3c7e842", size = 75128, upload-time = "2025-10-06T14:50:51.92Z" }, + { url = "https://files.pythonhosted.org/packages/14/2c/f069cab5b51d175a1a2cb4ccdf7a2c2dabd58aa5bd933fa036a8d15e2404/multidict-6.7.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:b8512bac933afc3e45fb2b18da8e59b78d4f408399a960339598374d4ae3b56b", size = 44410, upload-time = "2025-10-06T14:50:53.275Z" }, + { url = "https://files.pythonhosted.org/packages/42/e2/64bb41266427af6642b6b128e8774ed84c11b80a90702c13ac0a86bb10cc/multidict-6.7.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:79dcf9e477bc65414ebfea98ffd013cb39552b5ecd62908752e0e413d6d06e38", size = 43205, upload-time = "2025-10-06T14:50:54.911Z" }, + { url = "https://files.pythonhosted.org/packages/02/68/6b086fef8a3f1a8541b9236c594f0c9245617c29841f2e0395d979485cde/multidict-6.7.0-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:31bae522710064b5cbeddaf2e9f32b1abab70ac6ac91d42572502299e9953128", size = 245084, upload-time = "2025-10-06T14:50:56.369Z" }, + { url = "https://files.pythonhosted.org/packages/15/ee/f524093232007cd7a75c1d132df70f235cfd590a7c9eaccd7ff422ef4ae8/multidict-6.7.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4a0df7ff02397bb63e2fd22af2c87dfa39e8c7f12947bc524dbdc528282c7e34", size = 252667, upload-time = "2025-10-06T14:50:57.991Z" }, + { url = "https://files.pythonhosted.org/packages/02/a5/eeb3f43ab45878f1895118c3ef157a480db58ede3f248e29b5354139c2c9/multidict-6.7.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7a0222514e8e4c514660e182d5156a415c13ef0aabbd71682fc714e327b95e99", size = 233590, upload-time = "2025-10-06T14:50:59.589Z" }, + { url = "https://files.pythonhosted.org/packages/6a/1e/76d02f8270b97269d7e3dbd45644b1785bda457b474315f8cf999525a193/multidict-6.7.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2397ab4daaf2698eb51a76721e98db21ce4f52339e535725de03ea962b5a3202", size = 264112, upload-time = "2025-10-06T14:51:01.183Z" }, + { url = "https://files.pythonhosted.org/packages/76/0b/c28a70ecb58963847c2a8efe334904cd254812b10e535aefb3bcce513918/multidict-6.7.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8891681594162635948a636c9fe0ff21746aeb3dd5463f6e25d9bea3a8a39ca1", size = 261194, upload-time = "2025-10-06T14:51:02.794Z" }, + { url = "https://files.pythonhosted.org/packages/b4/63/2ab26e4209773223159b83aa32721b4021ffb08102f8ac7d689c943fded1/multidict-6.7.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:18706cc31dbf402a7945916dd5cddf160251b6dab8a2c5f3d6d5a55949f676b3", size = 248510, upload-time = "2025-10-06T14:51:04.724Z" }, + { url = "https://files.pythonhosted.org/packages/93/cd/06c1fa8282af1d1c46fd55c10a7930af652afdce43999501d4d68664170c/multidict-6.7.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:f844a1bbf1d207dd311a56f383f7eda2d0e134921d45751842d8235e7778965d", size = 248395, upload-time = "2025-10-06T14:51:06.306Z" }, + { url = "https://files.pythonhosted.org/packages/99/ac/82cb419dd6b04ccf9e7e61befc00c77614fc8134362488b553402ecd55ce/multidict-6.7.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:d4393e3581e84e5645506923816b9cc81f5609a778c7e7534054091acc64d1c6", size = 239520, upload-time = "2025-10-06T14:51:08.091Z" }, + { url = "https://files.pythonhosted.org/packages/fa/f3/a0f9bf09493421bd8716a362e0cd1d244f5a6550f5beffdd6b47e885b331/multidict-6.7.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:fbd18dc82d7bf274b37aa48d664534330af744e03bccf696d6f4c6042e7d19e7", size = 245479, upload-time = "2025-10-06T14:51:10.365Z" }, + { url = "https://files.pythonhosted.org/packages/8d/01/476d38fc73a212843f43c852b0eee266b6971f0e28329c2184a8df90c376/multidict-6.7.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:b6234e14f9314731ec45c42fc4554b88133ad53a09092cc48a88e771c125dadb", size = 258903, upload-time = "2025-10-06T14:51:12.466Z" }, + { url = "https://files.pythonhosted.org/packages/49/6d/23faeb0868adba613b817d0e69c5f15531b24d462af8012c4f6de4fa8dc3/multidict-6.7.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:08d4379f9744d8f78d98c8673c06e202ffa88296f009c71bbafe8a6bf847d01f", size = 252333, upload-time = "2025-10-06T14:51:14.48Z" }, + { url = "https://files.pythonhosted.org/packages/1e/cc/48d02ac22b30fa247f7dad82866e4b1015431092f4ba6ebc7e77596e0b18/multidict-6.7.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:9fe04da3f79387f450fd0061d4dd2e45a72749d31bf634aecc9e27f24fdc4b3f", size = 243411, upload-time = "2025-10-06T14:51:16.072Z" }, + { url = "https://files.pythonhosted.org/packages/4a/03/29a8bf5a18abf1fe34535c88adbdfa88c9fb869b5a3b120692c64abe8284/multidict-6.7.0-cp314-cp314-win32.whl", hash = "sha256:fbafe31d191dfa7c4c51f7a6149c9fb7e914dcf9ffead27dcfd9f1ae382b3885", size = 40940, upload-time = "2025-10-06T14:51:17.544Z" }, + { url = "https://files.pythonhosted.org/packages/82/16/7ed27b680791b939de138f906d5cf2b4657b0d45ca6f5dd6236fdddafb1a/multidict-6.7.0-cp314-cp314-win_amd64.whl", hash = "sha256:2f67396ec0310764b9222a1728ced1ab638f61aadc6226f17a71dd9324f9a99c", size = 45087, upload-time = "2025-10-06T14:51:18.875Z" }, + { url = "https://files.pythonhosted.org/packages/cd/3c/e3e62eb35a1950292fe39315d3c89941e30a9d07d5d2df42965ab041da43/multidict-6.7.0-cp314-cp314-win_arm64.whl", hash = "sha256:ba672b26069957ee369cfa7fc180dde1fc6f176eaf1e6beaf61fbebbd3d9c000", size = 42368, upload-time = "2025-10-06T14:51:20.225Z" }, + { url = "https://files.pythonhosted.org/packages/8b/40/cd499bd0dbc5f1136726db3153042a735fffd0d77268e2ee20d5f33c010f/multidict-6.7.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:c1dcc7524066fa918c6a27d61444d4ee7900ec635779058571f70d042d86ed63", size = 82326, upload-time = "2025-10-06T14:51:21.588Z" }, + { url = "https://files.pythonhosted.org/packages/13/8a/18e031eca251c8df76daf0288e6790561806e439f5ce99a170b4af30676b/multidict-6.7.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:27e0b36c2d388dc7b6ced3406671b401e84ad7eb0656b8f3a2f46ed0ce483718", size = 48065, upload-time = "2025-10-06T14:51:22.93Z" }, + { url = "https://files.pythonhosted.org/packages/40/71/5e6701277470a87d234e433fb0a3a7deaf3bcd92566e421e7ae9776319de/multidict-6.7.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:2a7baa46a22e77f0988e3b23d4ede5513ebec1929e34ee9495be535662c0dfe2", size = 46475, upload-time = "2025-10-06T14:51:24.352Z" }, + { url = "https://files.pythonhosted.org/packages/fe/6a/bab00cbab6d9cfb57afe1663318f72ec28289ea03fd4e8236bb78429893a/multidict-6.7.0-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:7bf77f54997a9166a2f5675d1201520586439424c2511723a7312bdb4bcc034e", size = 239324, upload-time = "2025-10-06T14:51:25.822Z" }, + { url = "https://files.pythonhosted.org/packages/2a/5f/8de95f629fc22a7769ade8b41028e3e5a822c1f8904f618d175945a81ad3/multidict-6.7.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e011555abada53f1578d63389610ac8a5400fc70ce71156b0aa30d326f1a5064", size = 246877, upload-time = "2025-10-06T14:51:27.604Z" }, + { url = "https://files.pythonhosted.org/packages/23/b4/38881a960458f25b89e9f4a4fdcb02ac101cfa710190db6e5528841e67de/multidict-6.7.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:28b37063541b897fd6a318007373930a75ca6d6ac7c940dbe14731ffdd8d498e", size = 225824, upload-time = "2025-10-06T14:51:29.664Z" }, + { url = "https://files.pythonhosted.org/packages/1e/39/6566210c83f8a261575f18e7144736059f0c460b362e96e9cf797a24b8e7/multidict-6.7.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:05047ada7a2fde2631a0ed706f1fd68b169a681dfe5e4cf0f8e4cb6618bbc2cd", size = 253558, upload-time = "2025-10-06T14:51:31.684Z" }, + { url = "https://files.pythonhosted.org/packages/00/a3/67f18315100f64c269f46e6c0319fa87ba68f0f64f2b8e7fd7c72b913a0b/multidict-6.7.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:716133f7d1d946a4e1b91b1756b23c088881e70ff180c24e864c26192ad7534a", size = 252339, upload-time = "2025-10-06T14:51:33.699Z" }, + { url = "https://files.pythonhosted.org/packages/c8/2a/1cb77266afee2458d82f50da41beba02159b1d6b1f7973afc9a1cad1499b/multidict-6.7.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d1bed1b467ef657f2a0ae62844a607909ef1c6889562de5e1d505f74457d0b96", size = 244895, upload-time = "2025-10-06T14:51:36.189Z" }, + { url = "https://files.pythonhosted.org/packages/dd/72/09fa7dd487f119b2eb9524946ddd36e2067c08510576d43ff68469563b3b/multidict-6.7.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:ca43bdfa5d37bd6aee89d85e1d0831fb86e25541be7e9d376ead1b28974f8e5e", size = 241862, upload-time = "2025-10-06T14:51:41.291Z" }, + { url = "https://files.pythonhosted.org/packages/65/92/bc1f8bd0853d8669300f732c801974dfc3702c3eeadae2f60cef54dc69d7/multidict-6.7.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:44b546bd3eb645fd26fb949e43c02a25a2e632e2ca21a35e2e132c8105dc8599", size = 232376, upload-time = "2025-10-06T14:51:43.55Z" }, + { url = "https://files.pythonhosted.org/packages/09/86/ac39399e5cb9d0c2ac8ef6e10a768e4d3bc933ac808d49c41f9dc23337eb/multidict-6.7.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:a6ef16328011d3f468e7ebc326f24c1445f001ca1dec335b2f8e66bed3006394", size = 240272, upload-time = "2025-10-06T14:51:45.265Z" }, + { url = "https://files.pythonhosted.org/packages/3d/b6/fed5ac6b8563ec72df6cb1ea8dac6d17f0a4a1f65045f66b6d3bf1497c02/multidict-6.7.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:5aa873cbc8e593d361ae65c68f85faadd755c3295ea2c12040ee146802f23b38", size = 248774, upload-time = "2025-10-06T14:51:46.836Z" }, + { url = "https://files.pythonhosted.org/packages/6b/8d/b954d8c0dc132b68f760aefd45870978deec6818897389dace00fcde32ff/multidict-6.7.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:3d7b6ccce016e29df4b7ca819659f516f0bc7a4b3efa3bb2012ba06431b044f9", size = 242731, upload-time = "2025-10-06T14:51:48.541Z" }, + { url = "https://files.pythonhosted.org/packages/16/9d/a2dac7009125d3540c2f54e194829ea18ac53716c61b655d8ed300120b0f/multidict-6.7.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:171b73bd4ee683d307599b66793ac80981b06f069b62eea1c9e29c9241aa66b0", size = 240193, upload-time = "2025-10-06T14:51:50.355Z" }, + { url = "https://files.pythonhosted.org/packages/39/ca/c05f144128ea232ae2178b008d5011d4e2cea86e4ee8c85c2631b1b94802/multidict-6.7.0-cp314-cp314t-win32.whl", hash = "sha256:b2d7f80c4e1fd010b07cb26820aae86b7e73b681ee4889684fb8d2d4537aab13", size = 48023, upload-time = "2025-10-06T14:51:51.883Z" }, + { url = "https://files.pythonhosted.org/packages/ba/8f/0a60e501584145588be1af5cc829265701ba3c35a64aec8e07cbb71d39bb/multidict-6.7.0-cp314-cp314t-win_amd64.whl", hash = "sha256:09929cab6fcb68122776d575e03c6cc64ee0b8fca48d17e135474b042ce515cd", size = 53507, upload-time = "2025-10-06T14:51:53.672Z" }, + { url = "https://files.pythonhosted.org/packages/7f/ae/3148b988a9c6239903e786eac19c889fab607c31d6efa7fb2147e5680f23/multidict-6.7.0-cp314-cp314t-win_arm64.whl", hash = "sha256:cc41db090ed742f32bd2d2c721861725e6109681eddf835d0a82bd3a5c382827", size = 44804, upload-time = "2025-10-06T14:51:55.415Z" }, + { url = "https://files.pythonhosted.org/packages/b7/da/7d22601b625e241d4f23ef1ebff8acfc60da633c9e7e7922e24d10f592b3/multidict-6.7.0-py3-none-any.whl", hash = "sha256:394fc5c42a333c9ffc3e421a4c85e08580d990e08b99f6bf35b4132114c5dcb3", size = 12317, upload-time = "2025-10-06T14:52:29.272Z" }, +] + +[[package]] +name = "multiprocess" +version = "0.70.18" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "dill" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/72/fd/2ae3826f5be24c6ed87266bc4e59c46ea5b059a103f3d7e7eb76a52aeecb/multiprocess-0.70.18.tar.gz", hash = "sha256:f9597128e6b3e67b23956da07cf3d2e5cba79e2f4e0fba8d7903636663ec6d0d", size = 1798503, upload-time = "2025-04-17T03:11:27.742Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c8/f8/7f9a8f08bf98cea1dfaa181e05cc8bbcb59cecf044b5a9ac3cce39f9c449/multiprocess-0.70.18-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:25d4012dcaaf66b9e8e955f58482b42910c2ee526d532844d8bcf661bbc604df", size = 135083, upload-time = "2025-04-17T03:11:04.223Z" }, + { url = "https://files.pythonhosted.org/packages/e5/03/b7b10dbfc17b2b3ce07d4d30b3ba8367d0ed32d6d46cd166e298f161dd46/multiprocess-0.70.18-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:06b19433de0d02afe5869aec8931dd5c01d99074664f806c73896b0d9e527213", size = 135128, upload-time = "2025-04-17T03:11:06.045Z" }, + { url = "https://files.pythonhosted.org/packages/c1/a3/5f8d3b9690ea5580bee5868ab7d7e2cfca74b7e826b28192b40aa3881cdc/multiprocess-0.70.18-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:6fa1366f994373aaf2d4738b0f56e707caeaa05486e97a7f71ee0853823180c2", size = 135132, upload-time = "2025-04-17T03:11:07.533Z" }, + { url = "https://files.pythonhosted.org/packages/55/4d/9af0d1279c84618bcd35bf5fd7e371657358c7b0a523e54a9cffb87461f8/multiprocess-0.70.18-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:8b8940ae30139e04b076da6c5b83e9398585ebdf0f2ad3250673fef5b2ff06d6", size = 144695, upload-time = "2025-04-17T03:11:09.161Z" }, + { url = "https://files.pythonhosted.org/packages/17/bf/87323e79dd0562474fad3373c21c66bc6c3c9963b68eb2a209deb4c8575e/multiprocess-0.70.18-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:0929ba95831adb938edbd5fb801ac45e705ecad9d100b3e653946b7716cb6bd3", size = 144742, upload-time = "2025-04-17T03:11:10.072Z" }, + { url = "https://files.pythonhosted.org/packages/dd/74/cb8c831e58dc6d5cf450b17c7db87f14294a1df52eb391da948b5e0a0b94/multiprocess-0.70.18-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:4d77f8e4bfe6c6e2e661925bbf9aed4d5ade9a1c6502d5dfc10129b9d1141797", size = 144745, upload-time = "2025-04-17T03:11:11.453Z" }, + { url = "https://files.pythonhosted.org/packages/ba/d8/0cba6cf51a1a31f20471fbc823a716170c73012ddc4fb85d706630ed6e8f/multiprocess-0.70.18-py310-none-any.whl", hash = "sha256:60c194974c31784019c1f459d984e8f33ee48f10fcf42c309ba97b30d9bd53ea", size = 134948, upload-time = "2025-04-17T03:11:20.223Z" }, + { url = "https://files.pythonhosted.org/packages/4b/88/9039f2fed1012ef584751d4ceff9ab4a51e5ae264898f0b7cbf44340a859/multiprocess-0.70.18-py311-none-any.whl", hash = "sha256:5aa6eef98e691281b3ad923be2832bf1c55dd2c859acd73e5ec53a66aae06a1d", size = 144462, upload-time = "2025-04-17T03:11:21.657Z" }, + { url = "https://files.pythonhosted.org/packages/bf/b6/5f922792be93b82ec6b5f270bbb1ef031fd0622847070bbcf9da816502cc/multiprocess-0.70.18-py312-none-any.whl", hash = "sha256:9b78f8e5024b573730bfb654783a13800c2c0f2dfc0c25e70b40d184d64adaa2", size = 150287, upload-time = "2025-04-17T03:11:22.69Z" }, + { url = "https://files.pythonhosted.org/packages/ee/25/7d7e78e750bc1aecfaf0efbf826c69a791d2eeaf29cf20cba93ff4cced78/multiprocess-0.70.18-py313-none-any.whl", hash = "sha256:871743755f43ef57d7910a38433cfe41319e72be1bbd90b79c7a5ac523eb9334", size = 151917, upload-time = "2025-04-17T03:11:24.044Z" }, + { url = "https://files.pythonhosted.org/packages/3b/c3/ca84c19bd14cdfc21c388fdcebf08b86a7a470ebc9f5c3c084fc2dbc50f7/multiprocess-0.70.18-py38-none-any.whl", hash = "sha256:dbf705e52a154fe5e90fb17b38f02556169557c2dd8bb084f2e06c2784d8279b", size = 132636, upload-time = "2025-04-17T03:11:24.936Z" }, + { url = "https://files.pythonhosted.org/packages/6c/28/dd72947e59a6a8c856448a5e74da6201cb5502ddff644fbc790e4bd40b9a/multiprocess-0.70.18-py39-none-any.whl", hash = "sha256:e78ca805a72b1b810c690b6b4cc32579eba34f403094bbbae962b7b5bf9dfcb8", size = 133478, upload-time = "2025-04-17T03:11:26.253Z" }, +] + +[[package]] +name = "mypy" +version = "1.19.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "librt" }, + { name = "mypy-extensions" }, + { name = "pathspec" }, + { name = "tomli", marker = "python_full_version < '3.11'" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f9/b5/b58cdc25fadd424552804bf410855d52324183112aa004f0732c5f6324cf/mypy-1.19.0.tar.gz", hash = "sha256:f6b874ca77f733222641e5c46e4711648c4037ea13646fd0cdc814c2eaec2528", size = 3579025, upload-time = "2025-11-28T15:49:01.26Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/98/8f/55fb488c2b7dabd76e3f30c10f7ab0f6190c1fcbc3e97b1e588ec625bbe2/mypy-1.19.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:6148ede033982a8c5ca1143de34c71836a09f105068aaa8b7d5edab2b053e6c8", size = 13093239, upload-time = "2025-11-28T15:45:11.342Z" }, + { url = "https://files.pythonhosted.org/packages/72/1b/278beea978456c56b3262266274f335c3ba5ff2c8108b3b31bec1ffa4c1d/mypy-1.19.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a9ac09e52bb0f7fb912f5d2a783345c72441a08ef56ce3e17c1752af36340a39", size = 12156128, upload-time = "2025-11-28T15:46:02.566Z" }, + { url = "https://files.pythonhosted.org/packages/21/f8/e06f951902e136ff74fd7a4dc4ef9d884faeb2f8eb9c49461235714f079f/mypy-1.19.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:11f7254c15ab3f8ed68f8e8f5cbe88757848df793e31c36aaa4d4f9783fd08ab", size = 12753508, upload-time = "2025-11-28T15:44:47.538Z" }, + { url = "https://files.pythonhosted.org/packages/67/5a/d035c534ad86e09cee274d53cf0fd769c0b29ca6ed5b32e205be3c06878c/mypy-1.19.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:318ba74f75899b0e78b847d8c50821e4c9637c79d9a59680fc1259f29338cb3e", size = 13507553, upload-time = "2025-11-28T15:44:39.26Z" }, + { url = "https://files.pythonhosted.org/packages/6a/17/c4a5498e00071ef29e483a01558b285d086825b61cf1fb2629fbdd019d94/mypy-1.19.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:cf7d84f497f78b682edd407f14a7b6e1a2212b433eedb054e2081380b7395aa3", size = 13792898, upload-time = "2025-11-28T15:44:31.102Z" }, + { url = "https://files.pythonhosted.org/packages/67/f6/bb542422b3ee4399ae1cdc463300d2d91515ab834c6233f2fd1d52fa21e0/mypy-1.19.0-cp310-cp310-win_amd64.whl", hash = "sha256:c3385246593ac2b97f155a0e9639be906e73534630f663747c71908dfbf26134", size = 10048835, upload-time = "2025-11-28T15:48:15.744Z" }, + { url = "https://files.pythonhosted.org/packages/0f/d2/010fb171ae5ac4a01cc34fbacd7544531e5ace95c35ca166dd8fd1b901d0/mypy-1.19.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a31e4c28e8ddb042c84c5e977e28a21195d086aaffaf08b016b78e19c9ef8106", size = 13010563, upload-time = "2025-11-28T15:48:23.975Z" }, + { url = "https://files.pythonhosted.org/packages/41/6b/63f095c9f1ce584fdeb595d663d49e0980c735a1d2004720ccec252c5d47/mypy-1.19.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:34ec1ac66d31644f194b7c163d7f8b8434f1b49719d403a5d26c87fff7e913f7", size = 12077037, upload-time = "2025-11-28T15:47:51.582Z" }, + { url = "https://files.pythonhosted.org/packages/d7/83/6cb93d289038d809023ec20eb0b48bbb1d80af40511fa077da78af6ff7c7/mypy-1.19.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cb64b0ba5980466a0f3f9990d1c582bcab8db12e29815ecb57f1408d99b4bff7", size = 12680255, upload-time = "2025-11-28T15:46:57.628Z" }, + { url = "https://files.pythonhosted.org/packages/99/db/d217815705987d2cbace2edd9100926196d6f85bcb9b5af05058d6e3c8ad/mypy-1.19.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:120cffe120cca5c23c03c77f84abc0c14c5d2e03736f6c312480020082f1994b", size = 13421472, upload-time = "2025-11-28T15:47:59.655Z" }, + { url = "https://files.pythonhosted.org/packages/4e/51/d2beaca7c497944b07594f3f8aad8d2f0e8fc53677059848ae5d6f4d193e/mypy-1.19.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:7a500ab5c444268a70565e374fc803972bfd1f09545b13418a5174e29883dab7", size = 13651823, upload-time = "2025-11-28T15:45:29.318Z" }, + { url = "https://files.pythonhosted.org/packages/aa/d1/7883dcf7644db3b69490f37b51029e0870aac4a7ad34d09ceae709a3df44/mypy-1.19.0-cp311-cp311-win_amd64.whl", hash = "sha256:c14a98bc63fd867530e8ec82f217dae29d0550c86e70debc9667fff1ec83284e", size = 10049077, upload-time = "2025-11-28T15:45:39.818Z" }, + { url = "https://files.pythonhosted.org/packages/11/7e/1afa8fb188b876abeaa14460dc4983f909aaacaa4bf5718c00b2c7e0b3d5/mypy-1.19.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:0fb3115cb8fa7c5f887c8a8d81ccdcb94cff334684980d847e5a62e926910e1d", size = 13207728, upload-time = "2025-11-28T15:46:26.463Z" }, + { url = "https://files.pythonhosted.org/packages/b2/13/f103d04962bcbefb1644f5ccb235998b32c337d6c13145ea390b9da47f3e/mypy-1.19.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f3e19e3b897562276bb331074d64c076dbdd3e79213f36eed4e592272dabd760", size = 12202945, upload-time = "2025-11-28T15:48:49.143Z" }, + { url = "https://files.pythonhosted.org/packages/e4/93/a86a5608f74a22284a8ccea8592f6e270b61f95b8588951110ad797c2ddd/mypy-1.19.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b9d491295825182fba01b6ffe2c6fe4e5a49dbf4e2bb4d1217b6ced3b4797bc6", size = 12718673, upload-time = "2025-11-28T15:47:37.193Z" }, + { url = "https://files.pythonhosted.org/packages/3d/58/cf08fff9ced0423b858f2a7495001fda28dc058136818ee9dffc31534ea9/mypy-1.19.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6016c52ab209919b46169651b362068f632efcd5eb8ef9d1735f6f86da7853b2", size = 13608336, upload-time = "2025-11-28T15:48:32.625Z" }, + { url = "https://files.pythonhosted.org/packages/64/ed/9c509105c5a6d4b73bb08733102a3ea62c25bc02c51bca85e3134bf912d3/mypy-1.19.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:f188dcf16483b3e59f9278c4ed939ec0254aa8a60e8fc100648d9ab5ee95a431", size = 13833174, upload-time = "2025-11-28T15:45:48.091Z" }, + { url = "https://files.pythonhosted.org/packages/cd/71/01939b66e35c6f8cb3e6fdf0b657f0fd24de2f8ba5e523625c8e72328208/mypy-1.19.0-cp312-cp312-win_amd64.whl", hash = "sha256:0e3c3d1e1d62e678c339e7ade72746a9e0325de42cd2cccc51616c7b2ed1a018", size = 10112208, upload-time = "2025-11-28T15:46:41.702Z" }, + { url = "https://files.pythonhosted.org/packages/cb/0d/a1357e6bb49e37ce26fcf7e3cc55679ce9f4ebee0cd8b6ee3a0e301a9210/mypy-1.19.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:7686ed65dbabd24d20066f3115018d2dce030d8fa9db01aa9f0a59b6813e9f9e", size = 13191993, upload-time = "2025-11-28T15:47:22.336Z" }, + { url = "https://files.pythonhosted.org/packages/5d/75/8e5d492a879ec4490e6ba664b5154e48c46c85b5ac9785792a5ec6a4d58f/mypy-1.19.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:fd4a985b2e32f23bead72e2fb4bbe5d6aceee176be471243bd831d5b2644672d", size = 12174411, upload-time = "2025-11-28T15:44:55.492Z" }, + { url = "https://files.pythonhosted.org/packages/71/31/ad5dcee9bfe226e8eaba777e9d9d251c292650130f0450a280aec3485370/mypy-1.19.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fc51a5b864f73a3a182584b1ac75c404396a17eced54341629d8bdcb644a5bba", size = 12727751, upload-time = "2025-11-28T15:44:14.169Z" }, + { url = "https://files.pythonhosted.org/packages/77/06/b6b8994ce07405f6039701f4b66e9d23f499d0b41c6dd46ec28f96d57ec3/mypy-1.19.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:37af5166f9475872034b56c5efdcf65ee25394e9e1d172907b84577120714364", size = 13593323, upload-time = "2025-11-28T15:46:34.699Z" }, + { url = "https://files.pythonhosted.org/packages/68/b1/126e274484cccdf099a8e328d4fda1c7bdb98a5e888fa6010b00e1bbf330/mypy-1.19.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:510c014b722308c9bd377993bcbf9a07d7e0692e5fa8fc70e639c1eb19fc6bee", size = 13818032, upload-time = "2025-11-28T15:46:18.286Z" }, + { url = "https://files.pythonhosted.org/packages/f8/56/53a8f70f562dfc466c766469133a8a4909f6c0012d83993143f2a9d48d2d/mypy-1.19.0-cp313-cp313-win_amd64.whl", hash = "sha256:cabbee74f29aa9cd3b444ec2f1e4fa5a9d0d746ce7567a6a609e224429781f53", size = 10120644, upload-time = "2025-11-28T15:47:43.99Z" }, + { url = "https://files.pythonhosted.org/packages/b0/f4/7751f32f56916f7f8c229fe902cbdba3e4dd3f3ea9e8b872be97e7fc546d/mypy-1.19.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:f2e36bed3c6d9b5f35d28b63ca4b727cb0228e480826ffc8953d1892ddc8999d", size = 13185236, upload-time = "2025-11-28T15:45:20.696Z" }, + { url = "https://files.pythonhosted.org/packages/35/31/871a9531f09e78e8d145032355890384f8a5b38c95a2c7732d226b93242e/mypy-1.19.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:a18d8abdda14035c5718acb748faec09571432811af129bf0d9e7b2d6699bf18", size = 12213902, upload-time = "2025-11-28T15:46:10.117Z" }, + { url = "https://files.pythonhosted.org/packages/58/b8/af221910dd40eeefa2077a59107e611550167b9994693fc5926a0b0f87c0/mypy-1.19.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f75e60aca3723a23511948539b0d7ed514dda194bc3755eae0bfc7a6b4887aa7", size = 12738600, upload-time = "2025-11-28T15:44:22.521Z" }, + { url = "https://files.pythonhosted.org/packages/11/9f/c39e89a3e319c1d9c734dedec1183b2cc3aefbab066ec611619002abb932/mypy-1.19.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8f44f2ae3c58421ee05fe609160343c25f70e3967f6e32792b5a78006a9d850f", size = 13592639, upload-time = "2025-11-28T15:48:08.55Z" }, + { url = "https://files.pythonhosted.org/packages/97/6d/ffaf5f01f5e284d9033de1267e6c1b8f3783f2cf784465378a86122e884b/mypy-1.19.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:63ea6a00e4bd6822adbfc75b02ab3653a17c02c4347f5bb0cf1d5b9df3a05835", size = 13799132, upload-time = "2025-11-28T15:47:06.032Z" }, + { url = "https://files.pythonhosted.org/packages/fe/b0/c33921e73aaa0106224e5a34822411bea38046188eb781637f5a5b07e269/mypy-1.19.0-cp314-cp314-win_amd64.whl", hash = "sha256:3ad925b14a0bb99821ff6f734553294aa6a3440a8cb082fe1f5b84dfb662afb1", size = 10269832, upload-time = "2025-11-28T15:47:29.392Z" }, + { url = "https://files.pythonhosted.org/packages/09/0e/fe228ed5aeab470c6f4eb82481837fadb642a5aa95cc8215fd2214822c10/mypy-1.19.0-py3-none-any.whl", hash = "sha256:0c01c99d626380752e527d5ce8e69ffbba2046eb8a060db0329690849cf9b6f9", size = 2469714, upload-time = "2025-11-28T15:45:33.22Z" }, +] + +[[package]] +name = "mypy-extensions" +version = "1.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a2/6e/371856a3fb9d31ca8dac321cda606860fa4548858c0cc45d9d1d4ca2628b/mypy_extensions-1.1.0.tar.gz", hash = "sha256:52e68efc3284861e772bbcd66823fde5ae21fd2fdb51c62a211403730b916558", size = 6343, upload-time = "2025-04-22T14:54:24.164Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/79/7b/2c79738432f5c924bef5071f933bcc9efd0473bac3b4aa584a6f7c1c8df8/mypy_extensions-1.1.0-py3-none-any.whl", hash = "sha256:1be4cccdb0f2482337c4743e60421de3a356cd97508abadd57d47403e94f5505", size = 4963, upload-time = "2025-04-22T14:54:22.983Z" }, +] + +[[package]] +name = "myst-parser" +version = "4.0.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "docutils" }, + { name = "jinja2" }, + { name = "markdown-it-py" }, + { name = "mdit-py-plugins" }, + { name = "pyyaml" }, + { name = "sphinx", version = "8.1.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "sphinx", version = "8.2.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/66/a5/9626ba4f73555b3735ad86247a8077d4603aa8628537687c839ab08bfe44/myst_parser-4.0.1.tar.gz", hash = "sha256:5cfea715e4f3574138aecbf7d54132296bfd72bb614d31168f48c477a830a7c4", size = 93985, upload-time = "2025-02-12T10:53:03.833Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5f/df/76d0321c3797b54b60fef9ec3bd6f4cfd124b9e422182156a1dd418722cf/myst_parser-4.0.1-py3-none-any.whl", hash = "sha256:9134e88959ec3b5780aedf8a99680ea242869d012e8821db3126d427edc9c95d", size = 84579, upload-time = "2025-02-12T10:53:02.078Z" }, +] + +[[package]] +name = "nemo-run" +version = "0.7.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "catalogue" }, + { name = "cryptography" }, + { name = "fabric" }, + { name = "fiddle" }, + { name = "inquirerpy" }, + { name = "jinja2" }, + { name = "leptonai" }, + { name = "networkx", version = "3.4.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "networkx", version = "3.6.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "omegaconf" }, + { name = "packaging" }, + { name = "rich" }, + { name = "toml" }, + { name = "torchx" }, + { name = "typer" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e2/5d/ec53d87a698ef9a9d294d0e779c4c9fc0ee373882ee000200d755d02d473/nemo_run-0.7.0.tar.gz", hash = "sha256:7176cde88194eb699483191af66536843e016227c40bf49384556057a4fe8bfd", size = 2294069, upload-time = "2025-12-03T23:54:17.697Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c4/e9/65352abfd75df6f77a6b16617a3cae102cbe62b74778ffe50edbabe36547/nemo_run-0.7.0-py3-none-any.whl", hash = "sha256:f1b86a5675178c6207f2f32fdf2de879801daa8d3e1cf867aa5180a787d3771a", size = 243281, upload-time = "2025-12-03T23:54:16.603Z" }, +] + +[[package]] +name = "nemotron" +version = "0.1.0" +source = { editable = "." } +dependencies = [ + { name = "colorama" }, + { name = "datasets" }, + { name = "fsspec" }, + { name = "huggingface-hub" }, + { name = "jinja2" }, + { name = "nemo-run" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "numpy", version = "2.3.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "omegaconf" }, + { name = "pyarrow" }, + { name = "pydantic" }, + { name = "pyyaml" }, + { name = "ray" }, + { name = "rich" }, + { name = "textual" }, + { name = "tomli", marker = "python_full_version < '3.11'" }, + { name = "tomlkit" }, + { name = "transformers" }, + { name = "typer" }, + { name = "wandb" }, + { name = "xxhash" }, +] + +[package.optional-dependencies] +all = [ + { name = "gcsfs" }, + { name = "s3fs" }, + { name = "sentencepiece" }, + { name = "wandb" }, +] +dev = [ + { name = "mypy" }, + { name = "pytest" }, + { name = "pytest-cov" }, + { name = "ruff" }, +] +gcs = [ + { name = "gcsfs" }, +] +s3 = [ + { name = "s3fs" }, +] +sentencepiece = [ + { name = "sentencepiece" }, +] +wandb = [ + { name = "wandb" }, +] + +[package.dev-dependencies] +dev = [ + { name = "pytest" }, +] +docs = [ + { name = "myst-parser" }, + { name = "nvidia-sphinx-theme" }, + { name = "sphinx", version = "8.1.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "sphinx", version = "8.2.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "sphinx-autobuild", version = "2024.10.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "sphinx-autobuild", version = "2025.8.25", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "sphinx-autodoc2" }, + { name = "sphinx-copybutton" }, + { name = "sphinx-design" }, + { name = "sphinxcontrib-mermaid" }, +] +run = [ + { name = "nemo-run" }, +] + +[package.metadata] +requires-dist = [ + { name = "colorama", specifier = ">=0.4.6" }, + { name = "datasets", specifier = ">=2.14.0" }, + { name = "fsspec", specifier = ">=2024.0.0" }, + { name = "gcsfs", marker = "extra == 'all'", specifier = ">=2024.0.0" }, + { name = "gcsfs", marker = "extra == 'gcs'", specifier = ">=2024.0.0" }, + { name = "huggingface-hub", specifier = ">=0.20.0" }, + { name = "jinja2", specifier = ">=3.0.0" }, + { name = "mypy", marker = "extra == 'dev'", specifier = ">=1.0.0" }, + { name = "nemo-run", specifier = ">=0.4.0" }, + { name = "numpy", specifier = ">=1.24.0" }, + { name = "omegaconf", specifier = ">=2.3.0" }, + { name = "pyarrow", specifier = ">=14.0.0" }, + { name = "pydantic", specifier = ">=2.0.0" }, + { name = "pytest", marker = "extra == 'dev'", specifier = ">=7.0.0" }, + { name = "pytest-cov", marker = "extra == 'dev'", specifier = ">=4.0.0" }, + { name = "pyyaml", specifier = ">=6.0" }, + { name = "ray", specifier = "==2.49.2" }, + { name = "rich", specifier = ">=13.0.0" }, + { name = "ruff", marker = "extra == 'dev'", specifier = ">=0.1.0" }, + { name = "s3fs", marker = "extra == 'all'", specifier = ">=2024.0.0" }, + { name = "s3fs", marker = "extra == 's3'", specifier = ">=2024.0.0" }, + { name = "sentencepiece", marker = "extra == 'all'", specifier = ">=0.2.0" }, + { name = "sentencepiece", marker = "extra == 'sentencepiece'", specifier = ">=0.2.0" }, + { name = "textual", specifier = ">=0.70.0" }, + { name = "tomli", marker = "python_full_version < '3.11'", specifier = ">=2.0.0" }, + { name = "tomlkit", specifier = ">=0.12.0" }, + { name = "transformers", specifier = ">=4.36.0" }, + { name = "typer", specifier = ">=0.12.0" }, + { name = "wandb", specifier = ">=0.23.1" }, + { name = "wandb", marker = "extra == 'all'", specifier = ">=0.15.0" }, + { name = "wandb", marker = "extra == 'wandb'", specifier = ">=0.15.0" }, + { name = "xxhash", specifier = ">=3.4.0" }, +] +provides-extras = ["wandb", "s3", "gcs", "sentencepiece", "dev", "all"] + +[package.metadata.requires-dev] +dev = [{ name = "pytest", specifier = ">=9.0.2" }] +docs = [ + { name = "myst-parser", specifier = ">=4.0.1" }, + { name = "nvidia-sphinx-theme", specifier = ">=0.0.8" }, + { name = "sphinx", specifier = ">=8.1.3" }, + { name = "sphinx-autobuild", specifier = ">=2024.10.3" }, + { name = "sphinx-autodoc2", specifier = ">=0.5.0" }, + { name = "sphinx-copybutton", specifier = ">=0.5.2" }, + { name = "sphinx-design", specifier = ">=0.6.0" }, + { name = "sphinxcontrib-mermaid" }, +] +run = [{ name = "nemo-run", specifier = ">=0.4.0" }] + +[[package]] +name = "networkx" +version = "3.4.2" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11' and sys_platform == 'linux'", + "python_full_version < '3.11' and sys_platform != 'linux'", +] +sdist = { url = "https://files.pythonhosted.org/packages/fd/1d/06475e1cd5264c0b870ea2cc6fdb3e37177c1e565c43f56ff17a10e3937f/networkx-3.4.2.tar.gz", hash = "sha256:307c3669428c5362aab27c8a1260aa8f47c4e91d3891f48be0141738d8d053e1", size = 2151368, upload-time = "2024-10-21T12:39:38.695Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b9/54/dd730b32ea14ea797530a4479b2ed46a6fb250f682a9cfb997e968bf0261/networkx-3.4.2-py3-none-any.whl", hash = "sha256:df5d4365b724cf81b8c6a7312509d0c22386097011ad1abe274afd5e9d3bbc5f", size = 1723263, upload-time = "2024-10-21T12:39:36.247Z" }, +] + +[[package]] +name = "networkx" +version = "3.6.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.14' and sys_platform == 'linux'", + "python_full_version == '3.13.*' and sys_platform == 'linux'", + "python_full_version == '3.12.*' and sys_platform == 'linux'", + "python_full_version == '3.11.*' and sys_platform == 'linux'", + "python_full_version >= '3.14' and sys_platform != 'linux'", + "python_full_version == '3.13.*' and sys_platform != 'linux'", + "python_full_version == '3.12.*' and sys_platform != 'linux'", + "python_full_version == '3.11.*' and sys_platform != 'linux'", +] +sdist = { url = "https://files.pythonhosted.org/packages/6a/51/63fe664f3908c97be9d2e4f1158eb633317598cfa6e1fc14af5383f17512/networkx-3.6.1.tar.gz", hash = "sha256:26b7c357accc0c8cde558ad486283728b65b6a95d85ee1cd66bafab4c8168509", size = 2517025, upload-time = "2025-12-08T17:02:39.908Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/c9/b2622292ea83fbb4ec318f5b9ab867d0a28ab43c5717bb85b0a5f6b3b0a4/networkx-3.6.1-py3-none-any.whl", hash = "sha256:d47fbf302e7d9cbbb9e2555a0d267983d2aa476bac30e90dfbe5669bd57f3762", size = 2068504, upload-time = "2025-12-08T17:02:38.159Z" }, +] + +[[package]] +name = "numpy" +version = "2.2.6" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11' and sys_platform == 'linux'", + "python_full_version < '3.11' and sys_platform != 'linux'", +] +sdist = { url = "https://files.pythonhosted.org/packages/76/21/7d2a95e4bba9dc13d043ee156a356c0a8f0c6309dff6b21b4d71a073b8a8/numpy-2.2.6.tar.gz", hash = "sha256:e29554e2bef54a90aa5cc07da6ce955accb83f21ab5de01a62c8478897b264fd", size = 20276440, upload-time = "2025-05-17T22:38:04.611Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9a/3e/ed6db5be21ce87955c0cbd3009f2803f59fa08df21b5df06862e2d8e2bdd/numpy-2.2.6-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:b412caa66f72040e6d268491a59f2c43bf03eb6c96dd8f0307829feb7fa2b6fb", size = 21165245, upload-time = "2025-05-17T21:27:58.555Z" }, + { url = "https://files.pythonhosted.org/packages/22/c2/4b9221495b2a132cc9d2eb862e21d42a009f5a60e45fc44b00118c174bff/numpy-2.2.6-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8e41fd67c52b86603a91c1a505ebaef50b3314de0213461c7a6e99c9a3beff90", size = 14360048, upload-time = "2025-05-17T21:28:21.406Z" }, + { url = "https://files.pythonhosted.org/packages/fd/77/dc2fcfc66943c6410e2bf598062f5959372735ffda175b39906d54f02349/numpy-2.2.6-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:37e990a01ae6ec7fe7fa1c26c55ecb672dd98b19c3d0e1d1f326fa13cb38d163", size = 5340542, upload-time = "2025-05-17T21:28:30.931Z" }, + { url = "https://files.pythonhosted.org/packages/7a/4f/1cb5fdc353a5f5cc7feb692db9b8ec2c3d6405453f982435efc52561df58/numpy-2.2.6-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:5a6429d4be8ca66d889b7cf70f536a397dc45ba6faeb5f8c5427935d9592e9cf", size = 6878301, upload-time = "2025-05-17T21:28:41.613Z" }, + { url = "https://files.pythonhosted.org/packages/eb/17/96a3acd228cec142fcb8723bd3cc39c2a474f7dcf0a5d16731980bcafa95/numpy-2.2.6-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:efd28d4e9cd7d7a8d39074a4d44c63eda73401580c5c76acda2ce969e0a38e83", size = 14297320, upload-time = "2025-05-17T21:29:02.78Z" }, + { url = "https://files.pythonhosted.org/packages/b4/63/3de6a34ad7ad6646ac7d2f55ebc6ad439dbbf9c4370017c50cf403fb19b5/numpy-2.2.6-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fc7b73d02efb0e18c000e9ad8b83480dfcd5dfd11065997ed4c6747470ae8915", size = 16801050, upload-time = "2025-05-17T21:29:27.675Z" }, + { url = "https://files.pythonhosted.org/packages/07/b6/89d837eddef52b3d0cec5c6ba0456c1bf1b9ef6a6672fc2b7873c3ec4e2e/numpy-2.2.6-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:74d4531beb257d2c3f4b261bfb0fc09e0f9ebb8842d82a7b4209415896adc680", size = 15807034, upload-time = "2025-05-17T21:29:51.102Z" }, + { url = "https://files.pythonhosted.org/packages/01/c8/dc6ae86e3c61cfec1f178e5c9f7858584049b6093f843bca541f94120920/numpy-2.2.6-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:8fc377d995680230e83241d8a96def29f204b5782f371c532579b4f20607a289", size = 18614185, upload-time = "2025-05-17T21:30:18.703Z" }, + { url = "https://files.pythonhosted.org/packages/5b/c5/0064b1b7e7c89137b471ccec1fd2282fceaae0ab3a9550f2568782d80357/numpy-2.2.6-cp310-cp310-win32.whl", hash = "sha256:b093dd74e50a8cba3e873868d9e93a85b78e0daf2e98c6797566ad8044e8363d", size = 6527149, upload-time = "2025-05-17T21:30:29.788Z" }, + { url = "https://files.pythonhosted.org/packages/a3/dd/4b822569d6b96c39d1215dbae0582fd99954dcbcf0c1a13c61783feaca3f/numpy-2.2.6-cp310-cp310-win_amd64.whl", hash = "sha256:f0fd6321b839904e15c46e0d257fdd101dd7f530fe03fd6359c1ea63738703f3", size = 12904620, upload-time = "2025-05-17T21:30:48.994Z" }, + { url = "https://files.pythonhosted.org/packages/da/a8/4f83e2aa666a9fbf56d6118faaaf5f1974d456b1823fda0a176eff722839/numpy-2.2.6-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f9f1adb22318e121c5c69a09142811a201ef17ab257a1e66ca3025065b7f53ae", size = 21176963, upload-time = "2025-05-17T21:31:19.36Z" }, + { url = "https://files.pythonhosted.org/packages/b3/2b/64e1affc7972decb74c9e29e5649fac940514910960ba25cd9af4488b66c/numpy-2.2.6-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c820a93b0255bc360f53eca31a0e676fd1101f673dda8da93454a12e23fc5f7a", size = 14406743, upload-time = "2025-05-17T21:31:41.087Z" }, + { url = "https://files.pythonhosted.org/packages/4a/9f/0121e375000b5e50ffdd8b25bf78d8e1a5aa4cca3f185d41265198c7b834/numpy-2.2.6-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:3d70692235e759f260c3d837193090014aebdf026dfd167834bcba43e30c2a42", size = 5352616, upload-time = "2025-05-17T21:31:50.072Z" }, + { url = "https://files.pythonhosted.org/packages/31/0d/b48c405c91693635fbe2dcd7bc84a33a602add5f63286e024d3b6741411c/numpy-2.2.6-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:481b49095335f8eed42e39e8041327c05b0f6f4780488f61286ed3c01368d491", size = 6889579, upload-time = "2025-05-17T21:32:01.712Z" }, + { url = "https://files.pythonhosted.org/packages/52/b8/7f0554d49b565d0171eab6e99001846882000883998e7b7d9f0d98b1f934/numpy-2.2.6-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b64d8d4d17135e00c8e346e0a738deb17e754230d7e0810ac5012750bbd85a5a", size = 14312005, upload-time = "2025-05-17T21:32:23.332Z" }, + { url = "https://files.pythonhosted.org/packages/b3/dd/2238b898e51bd6d389b7389ffb20d7f4c10066d80351187ec8e303a5a475/numpy-2.2.6-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ba10f8411898fc418a521833e014a77d3ca01c15b0c6cdcce6a0d2897e6dbbdf", size = 16821570, upload-time = "2025-05-17T21:32:47.991Z" }, + { url = "https://files.pythonhosted.org/packages/83/6c/44d0325722cf644f191042bf47eedad61c1e6df2432ed65cbe28509d404e/numpy-2.2.6-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:bd48227a919f1bafbdda0583705e547892342c26fb127219d60a5c36882609d1", size = 15818548, upload-time = "2025-05-17T21:33:11.728Z" }, + { url = "https://files.pythonhosted.org/packages/ae/9d/81e8216030ce66be25279098789b665d49ff19eef08bfa8cb96d4957f422/numpy-2.2.6-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9551a499bf125c1d4f9e250377c1ee2eddd02e01eac6644c080162c0c51778ab", size = 18620521, upload-time = "2025-05-17T21:33:39.139Z" }, + { url = "https://files.pythonhosted.org/packages/6a/fd/e19617b9530b031db51b0926eed5345ce8ddc669bb3bc0044b23e275ebe8/numpy-2.2.6-cp311-cp311-win32.whl", hash = "sha256:0678000bb9ac1475cd454c6b8c799206af8107e310843532b04d49649c717a47", size = 6525866, upload-time = "2025-05-17T21:33:50.273Z" }, + { url = "https://files.pythonhosted.org/packages/31/0a/f354fb7176b81747d870f7991dc763e157a934c717b67b58456bc63da3df/numpy-2.2.6-cp311-cp311-win_amd64.whl", hash = "sha256:e8213002e427c69c45a52bbd94163084025f533a55a59d6f9c5b820774ef3303", size = 12907455, upload-time = "2025-05-17T21:34:09.135Z" }, + { url = "https://files.pythonhosted.org/packages/82/5d/c00588b6cf18e1da539b45d3598d3557084990dcc4331960c15ee776ee41/numpy-2.2.6-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:41c5a21f4a04fa86436124d388f6ed60a9343a6f767fced1a8a71c3fbca038ff", size = 20875348, upload-time = "2025-05-17T21:34:39.648Z" }, + { url = "https://files.pythonhosted.org/packages/66/ee/560deadcdde6c2f90200450d5938f63a34b37e27ebff162810f716f6a230/numpy-2.2.6-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:de749064336d37e340f640b05f24e9e3dd678c57318c7289d222a8a2f543e90c", size = 14119362, upload-time = "2025-05-17T21:35:01.241Z" }, + { url = "https://files.pythonhosted.org/packages/3c/65/4baa99f1c53b30adf0acd9a5519078871ddde8d2339dc5a7fde80d9d87da/numpy-2.2.6-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:894b3a42502226a1cac872f840030665f33326fc3dac8e57c607905773cdcde3", size = 5084103, upload-time = "2025-05-17T21:35:10.622Z" }, + { url = "https://files.pythonhosted.org/packages/cc/89/e5a34c071a0570cc40c9a54eb472d113eea6d002e9ae12bb3a8407fb912e/numpy-2.2.6-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:71594f7c51a18e728451bb50cc60a3ce4e6538822731b2933209a1f3614e9282", size = 6625382, upload-time = "2025-05-17T21:35:21.414Z" }, + { url = "https://files.pythonhosted.org/packages/f8/35/8c80729f1ff76b3921d5c9487c7ac3de9b2a103b1cd05e905b3090513510/numpy-2.2.6-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f2618db89be1b4e05f7a1a847a9c1c0abd63e63a1607d892dd54668dd92faf87", size = 14018462, upload-time = "2025-05-17T21:35:42.174Z" }, + { url = "https://files.pythonhosted.org/packages/8c/3d/1e1db36cfd41f895d266b103df00ca5b3cbe965184df824dec5c08c6b803/numpy-2.2.6-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd83c01228a688733f1ded5201c678f0c53ecc1006ffbc404db9f7a899ac6249", size = 16527618, upload-time = "2025-05-17T21:36:06.711Z" }, + { url = "https://files.pythonhosted.org/packages/61/c6/03ed30992602c85aa3cd95b9070a514f8b3c33e31124694438d88809ae36/numpy-2.2.6-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:37c0ca431f82cd5fa716eca9506aefcabc247fb27ba69c5062a6d3ade8cf8f49", size = 15505511, upload-time = "2025-05-17T21:36:29.965Z" }, + { url = "https://files.pythonhosted.org/packages/b7/25/5761d832a81df431e260719ec45de696414266613c9ee268394dd5ad8236/numpy-2.2.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fe27749d33bb772c80dcd84ae7e8df2adc920ae8297400dabec45f0dedb3f6de", size = 18313783, upload-time = "2025-05-17T21:36:56.883Z" }, + { url = "https://files.pythonhosted.org/packages/57/0a/72d5a3527c5ebffcd47bde9162c39fae1f90138c961e5296491ce778e682/numpy-2.2.6-cp312-cp312-win32.whl", hash = "sha256:4eeaae00d789f66c7a25ac5f34b71a7035bb474e679f410e5e1a94deb24cf2d4", size = 6246506, upload-time = "2025-05-17T21:37:07.368Z" }, + { url = "https://files.pythonhosted.org/packages/36/fa/8c9210162ca1b88529ab76b41ba02d433fd54fecaf6feb70ef9f124683f1/numpy-2.2.6-cp312-cp312-win_amd64.whl", hash = "sha256:c1f9540be57940698ed329904db803cf7a402f3fc200bfe599334c9bd84a40b2", size = 12614190, upload-time = "2025-05-17T21:37:26.213Z" }, + { url = "https://files.pythonhosted.org/packages/f9/5c/6657823f4f594f72b5471f1db1ab12e26e890bb2e41897522d134d2a3e81/numpy-2.2.6-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:0811bb762109d9708cca4d0b13c4f67146e3c3b7cf8d34018c722adb2d957c84", size = 20867828, upload-time = "2025-05-17T21:37:56.699Z" }, + { url = "https://files.pythonhosted.org/packages/dc/9e/14520dc3dadf3c803473bd07e9b2bd1b69bc583cb2497b47000fed2fa92f/numpy-2.2.6-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:287cc3162b6f01463ccd86be154f284d0893d2b3ed7292439ea97eafa8170e0b", size = 14143006, upload-time = "2025-05-17T21:38:18.291Z" }, + { url = "https://files.pythonhosted.org/packages/4f/06/7e96c57d90bebdce9918412087fc22ca9851cceaf5567a45c1f404480e9e/numpy-2.2.6-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:f1372f041402e37e5e633e586f62aa53de2eac8d98cbfb822806ce4bbefcb74d", size = 5076765, upload-time = "2025-05-17T21:38:27.319Z" }, + { url = "https://files.pythonhosted.org/packages/73/ed/63d920c23b4289fdac96ddbdd6132e9427790977d5457cd132f18e76eae0/numpy-2.2.6-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:55a4d33fa519660d69614a9fad433be87e5252f4b03850642f88993f7b2ca566", size = 6617736, upload-time = "2025-05-17T21:38:38.141Z" }, + { url = "https://files.pythonhosted.org/packages/85/c5/e19c8f99d83fd377ec8c7e0cf627a8049746da54afc24ef0a0cb73d5dfb5/numpy-2.2.6-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f92729c95468a2f4f15e9bb94c432a9229d0d50de67304399627a943201baa2f", size = 14010719, upload-time = "2025-05-17T21:38:58.433Z" }, + { url = "https://files.pythonhosted.org/packages/19/49/4df9123aafa7b539317bf6d342cb6d227e49f7a35b99c287a6109b13dd93/numpy-2.2.6-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1bc23a79bfabc5d056d106f9befb8d50c31ced2fbc70eedb8155aec74a45798f", size = 16526072, upload-time = "2025-05-17T21:39:22.638Z" }, + { url = "https://files.pythonhosted.org/packages/b2/6c/04b5f47f4f32f7c2b0e7260442a8cbcf8168b0e1a41ff1495da42f42a14f/numpy-2.2.6-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:e3143e4451880bed956e706a3220b4e5cf6172ef05fcc397f6f36a550b1dd868", size = 15503213, upload-time = "2025-05-17T21:39:45.865Z" }, + { url = "https://files.pythonhosted.org/packages/17/0a/5cd92e352c1307640d5b6fec1b2ffb06cd0dabe7d7b8227f97933d378422/numpy-2.2.6-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:b4f13750ce79751586ae2eb824ba7e1e8dba64784086c98cdbbcc6a42112ce0d", size = 18316632, upload-time = "2025-05-17T21:40:13.331Z" }, + { url = "https://files.pythonhosted.org/packages/f0/3b/5cba2b1d88760ef86596ad0f3d484b1cbff7c115ae2429678465057c5155/numpy-2.2.6-cp313-cp313-win32.whl", hash = "sha256:5beb72339d9d4fa36522fc63802f469b13cdbe4fdab4a288f0c441b74272ebfd", size = 6244532, upload-time = "2025-05-17T21:43:46.099Z" }, + { url = "https://files.pythonhosted.org/packages/cb/3b/d58c12eafcb298d4e6d0d40216866ab15f59e55d148a5658bb3132311fcf/numpy-2.2.6-cp313-cp313-win_amd64.whl", hash = "sha256:b0544343a702fa80c95ad5d3d608ea3599dd54d4632df855e4c8d24eb6ecfa1c", size = 12610885, upload-time = "2025-05-17T21:44:05.145Z" }, + { url = "https://files.pythonhosted.org/packages/6b/9e/4bf918b818e516322db999ac25d00c75788ddfd2d2ade4fa66f1f38097e1/numpy-2.2.6-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0bca768cd85ae743b2affdc762d617eddf3bcf8724435498a1e80132d04879e6", size = 20963467, upload-time = "2025-05-17T21:40:44Z" }, + { url = "https://files.pythonhosted.org/packages/61/66/d2de6b291507517ff2e438e13ff7b1e2cdbdb7cb40b3ed475377aece69f9/numpy-2.2.6-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:fc0c5673685c508a142ca65209b4e79ed6740a4ed6b2267dbba90f34b0b3cfda", size = 14225144, upload-time = "2025-05-17T21:41:05.695Z" }, + { url = "https://files.pythonhosted.org/packages/e4/25/480387655407ead912e28ba3a820bc69af9adf13bcbe40b299d454ec011f/numpy-2.2.6-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:5bd4fc3ac8926b3819797a7c0e2631eb889b4118a9898c84f585a54d475b7e40", size = 5200217, upload-time = "2025-05-17T21:41:15.903Z" }, + { url = "https://files.pythonhosted.org/packages/aa/4a/6e313b5108f53dcbf3aca0c0f3e9c92f4c10ce57a0a721851f9785872895/numpy-2.2.6-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:fee4236c876c4e8369388054d02d0e9bb84821feb1a64dd59e137e6511a551f8", size = 6712014, upload-time = "2025-05-17T21:41:27.321Z" }, + { url = "https://files.pythonhosted.org/packages/b7/30/172c2d5c4be71fdf476e9de553443cf8e25feddbe185e0bd88b096915bcc/numpy-2.2.6-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e1dda9c7e08dc141e0247a5b8f49cf05984955246a327d4c48bda16821947b2f", size = 14077935, upload-time = "2025-05-17T21:41:49.738Z" }, + { url = "https://files.pythonhosted.org/packages/12/fb/9e743f8d4e4d3c710902cf87af3512082ae3d43b945d5d16563f26ec251d/numpy-2.2.6-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f447e6acb680fd307f40d3da4852208af94afdfab89cf850986c3ca00562f4fa", size = 16600122, upload-time = "2025-05-17T21:42:14.046Z" }, + { url = "https://files.pythonhosted.org/packages/12/75/ee20da0e58d3a66f204f38916757e01e33a9737d0b22373b3eb5a27358f9/numpy-2.2.6-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:389d771b1623ec92636b0786bc4ae56abafad4a4c513d36a55dce14bd9ce8571", size = 15586143, upload-time = "2025-05-17T21:42:37.464Z" }, + { url = "https://files.pythonhosted.org/packages/76/95/bef5b37f29fc5e739947e9ce5179ad402875633308504a52d188302319c8/numpy-2.2.6-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8e9ace4a37db23421249ed236fdcdd457d671e25146786dfc96835cd951aa7c1", size = 18385260, upload-time = "2025-05-17T21:43:05.189Z" }, + { url = "https://files.pythonhosted.org/packages/09/04/f2f83279d287407cf36a7a8053a5abe7be3622a4363337338f2585e4afda/numpy-2.2.6-cp313-cp313t-win32.whl", hash = "sha256:038613e9fb8c72b0a41f025a7e4c3f0b7a1b5d768ece4796b674c8f3fe13efff", size = 6377225, upload-time = "2025-05-17T21:43:16.254Z" }, + { url = "https://files.pythonhosted.org/packages/67/0e/35082d13c09c02c011cf21570543d202ad929d961c02a147493cb0c2bdf5/numpy-2.2.6-cp313-cp313t-win_amd64.whl", hash = "sha256:6031dd6dfecc0cf9f668681a37648373bddd6421fff6c66ec1624eed0180ee06", size = 12771374, upload-time = "2025-05-17T21:43:35.479Z" }, + { url = "https://files.pythonhosted.org/packages/9e/3b/d94a75f4dbf1ef5d321523ecac21ef23a3cd2ac8b78ae2aac40873590229/numpy-2.2.6-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:0b605b275d7bd0c640cad4e5d30fa701a8d59302e127e5f79138ad62762c3e3d", size = 21040391, upload-time = "2025-05-17T21:44:35.948Z" }, + { url = "https://files.pythonhosted.org/packages/17/f4/09b2fa1b58f0fb4f7c7963a1649c64c4d315752240377ed74d9cd878f7b5/numpy-2.2.6-pp310-pypy310_pp73-macosx_14_0_x86_64.whl", hash = "sha256:7befc596a7dc9da8a337f79802ee8adb30a552a94f792b9c9d18c840055907db", size = 6786754, upload-time = "2025-05-17T21:44:47.446Z" }, + { url = "https://files.pythonhosted.org/packages/af/30/feba75f143bdc868a1cc3f44ccfa6c4b9ec522b36458e738cd00f67b573f/numpy-2.2.6-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ce47521a4754c8f4593837384bd3424880629f718d87c5d44f8ed763edd63543", size = 16643476, upload-time = "2025-05-17T21:45:11.871Z" }, + { url = "https://files.pythonhosted.org/packages/37/48/ac2a9584402fb6c0cd5b5d1a91dcf176b15760130dd386bbafdbfe3640bf/numpy-2.2.6-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:d042d24c90c41b54fd506da306759e06e568864df8ec17ccc17e9e884634fd00", size = 12812666, upload-time = "2025-05-17T21:45:31.426Z" }, +] + +[[package]] +name = "numpy" +version = "2.3.5" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.14' and sys_platform == 'linux'", + "python_full_version == '3.13.*' and sys_platform == 'linux'", + "python_full_version == '3.12.*' and sys_platform == 'linux'", + "python_full_version == '3.11.*' and sys_platform == 'linux'", + "python_full_version >= '3.14' and sys_platform != 'linux'", + "python_full_version == '3.13.*' and sys_platform != 'linux'", + "python_full_version == '3.12.*' and sys_platform != 'linux'", + "python_full_version == '3.11.*' and sys_platform != 'linux'", +] +sdist = { url = "https://files.pythonhosted.org/packages/76/65/21b3bc86aac7b8f2862db1e808f1ea22b028e30a225a34a5ede9bf8678f2/numpy-2.3.5.tar.gz", hash = "sha256:784db1dcdab56bf0517743e746dfb0f885fc68d948aba86eeec2cba234bdf1c0", size = 20584950, upload-time = "2025-11-16T22:52:42.067Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/43/77/84dd1d2e34d7e2792a236ba180b5e8fcc1e3e414e761ce0253f63d7f572e/numpy-2.3.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:de5672f4a7b200c15a4127042170a694d4df43c992948f5e1af57f0174beed10", size = 17034641, upload-time = "2025-11-16T22:49:19.336Z" }, + { url = "https://files.pythonhosted.org/packages/2a/ea/25e26fa5837106cde46ae7d0b667e20f69cbbc0efd64cba8221411ab26ae/numpy-2.3.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:acfd89508504a19ed06ef963ad544ec6664518c863436306153e13e94605c218", size = 12528324, upload-time = "2025-11-16T22:49:22.582Z" }, + { url = "https://files.pythonhosted.org/packages/4d/1a/e85f0eea4cf03d6a0228f5c0256b53f2df4bc794706e7df019fc622e47f1/numpy-2.3.5-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:ffe22d2b05504f786c867c8395de703937f934272eb67586817b46188b4ded6d", size = 5356872, upload-time = "2025-11-16T22:49:25.408Z" }, + { url = "https://files.pythonhosted.org/packages/5c/bb/35ef04afd567f4c989c2060cde39211e4ac5357155c1833bcd1166055c61/numpy-2.3.5-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:872a5cf366aec6bb1147336480fef14c9164b154aeb6542327de4970282cd2f5", size = 6893148, upload-time = "2025-11-16T22:49:27.549Z" }, + { url = "https://files.pythonhosted.org/packages/f2/2b/05bbeb06e2dff5eab512dfc678b1cc5ee94d8ac5956a0885c64b6b26252b/numpy-2.3.5-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3095bdb8dd297e5920b010e96134ed91d852d81d490e787beca7e35ae1d89cf7", size = 14557282, upload-time = "2025-11-16T22:49:30.964Z" }, + { url = "https://files.pythonhosted.org/packages/65/fb/2b23769462b34398d9326081fad5655198fcf18966fcb1f1e49db44fbf31/numpy-2.3.5-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8cba086a43d54ca804ce711b2a940b16e452807acebe7852ff327f1ecd49b0d4", size = 16897903, upload-time = "2025-11-16T22:49:34.191Z" }, + { url = "https://files.pythonhosted.org/packages/ac/14/085f4cf05fc3f1e8aa95e85404e984ffca9b2275a5dc2b1aae18a67538b8/numpy-2.3.5-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6cf9b429b21df6b99f4dee7a1218b8b7ffbbe7df8764dc0bd60ce8a0708fed1e", size = 16341672, upload-time = "2025-11-16T22:49:37.2Z" }, + { url = "https://files.pythonhosted.org/packages/6f/3b/1f73994904142b2aa290449b3bb99772477b5fd94d787093e4f24f5af763/numpy-2.3.5-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:396084a36abdb603546b119d96528c2f6263921c50df3c8fd7cb28873a237748", size = 18838896, upload-time = "2025-11-16T22:49:39.727Z" }, + { url = "https://files.pythonhosted.org/packages/cd/b9/cf6649b2124f288309ffc353070792caf42ad69047dcc60da85ee85fea58/numpy-2.3.5-cp311-cp311-win32.whl", hash = "sha256:b0c7088a73aef3d687c4deef8452a3ac7c1be4e29ed8bf3b366c8111128ac60c", size = 6563608, upload-time = "2025-11-16T22:49:42.079Z" }, + { url = "https://files.pythonhosted.org/packages/aa/44/9fe81ae1dcc29c531843852e2874080dc441338574ccc4306b39e2ff6e59/numpy-2.3.5-cp311-cp311-win_amd64.whl", hash = "sha256:a414504bef8945eae5f2d7cb7be2d4af77c5d1cb5e20b296c2c25b61dff2900c", size = 13078442, upload-time = "2025-11-16T22:49:43.99Z" }, + { url = "https://files.pythonhosted.org/packages/6d/a7/f99a41553d2da82a20a2f22e93c94f928e4490bb447c9ff3c4ff230581d3/numpy-2.3.5-cp311-cp311-win_arm64.whl", hash = "sha256:0cd00b7b36e35398fa2d16af7b907b65304ef8bb4817a550e06e5012929830fa", size = 10458555, upload-time = "2025-11-16T22:49:47.092Z" }, + { url = "https://files.pythonhosted.org/packages/44/37/e669fe6cbb2b96c62f6bbedc6a81c0f3b7362f6a59230b23caa673a85721/numpy-2.3.5-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:74ae7b798248fe62021dbf3c914245ad45d1a6b0cb4a29ecb4b31d0bfbc4cc3e", size = 16733873, upload-time = "2025-11-16T22:49:49.84Z" }, + { url = "https://files.pythonhosted.org/packages/c5/65/df0db6c097892c9380851ab9e44b52d4f7ba576b833996e0080181c0c439/numpy-2.3.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ee3888d9ff7c14604052b2ca5535a30216aa0a58e948cdd3eeb8d3415f638769", size = 12259838, upload-time = "2025-11-16T22:49:52.863Z" }, + { url = "https://files.pythonhosted.org/packages/5b/e1/1ee06e70eb2136797abe847d386e7c0e830b67ad1d43f364dd04fa50d338/numpy-2.3.5-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:612a95a17655e213502f60cfb9bf9408efdc9eb1d5f50535cc6eb365d11b42b5", size = 5088378, upload-time = "2025-11-16T22:49:55.055Z" }, + { url = "https://files.pythonhosted.org/packages/6d/9c/1ca85fb86708724275103b81ec4cf1ac1d08f465368acfc8da7ab545bdae/numpy-2.3.5-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:3101e5177d114a593d79dd79658650fe28b5a0d8abeb8ce6f437c0e6df5be1a4", size = 6628559, upload-time = "2025-11-16T22:49:57.371Z" }, + { url = "https://files.pythonhosted.org/packages/74/78/fcd41e5a0ce4f3f7b003da85825acddae6d7ecb60cf25194741b036ca7d6/numpy-2.3.5-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8b973c57ff8e184109db042c842423ff4f60446239bd585a5131cc47f06f789d", size = 14250702, upload-time = "2025-11-16T22:49:59.632Z" }, + { url = "https://files.pythonhosted.org/packages/b6/23/2a1b231b8ff672b4c450dac27164a8b2ca7d9b7144f9c02d2396518352eb/numpy-2.3.5-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0d8163f43acde9a73c2a33605353a4f1bc4798745a8b1d73183b28e5b435ae28", size = 16606086, upload-time = "2025-11-16T22:50:02.127Z" }, + { url = "https://files.pythonhosted.org/packages/a0/c5/5ad26fbfbe2012e190cc7d5003e4d874b88bb18861d0829edc140a713021/numpy-2.3.5-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:51c1e14eb1e154ebd80e860722f9e6ed6ec89714ad2db2d3aa33c31d7c12179b", size = 16025985, upload-time = "2025-11-16T22:50:04.536Z" }, + { url = "https://files.pythonhosted.org/packages/d2/fa/dd48e225c46c819288148d9d060b047fd2a6fb1eb37eae25112ee4cb4453/numpy-2.3.5-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b46b4ec24f7293f23adcd2d146960559aaf8020213de8ad1909dba6c013bf89c", size = 18542976, upload-time = "2025-11-16T22:50:07.557Z" }, + { url = "https://files.pythonhosted.org/packages/05/79/ccbd23a75862d95af03d28b5c6901a1b7da4803181513d52f3b86ed9446e/numpy-2.3.5-cp312-cp312-win32.whl", hash = "sha256:3997b5b3c9a771e157f9aae01dd579ee35ad7109be18db0e85dbdbe1de06e952", size = 6285274, upload-time = "2025-11-16T22:50:10.746Z" }, + { url = "https://files.pythonhosted.org/packages/2d/57/8aeaf160312f7f489dea47ab61e430b5cb051f59a98ae68b7133ce8fa06a/numpy-2.3.5-cp312-cp312-win_amd64.whl", hash = "sha256:86945f2ee6d10cdfd67bcb4069c1662dd711f7e2a4343db5cecec06b87cf31aa", size = 12782922, upload-time = "2025-11-16T22:50:12.811Z" }, + { url = "https://files.pythonhosted.org/packages/78/a6/aae5cc2ca78c45e64b9ef22f089141d661516856cf7c8a54ba434576900d/numpy-2.3.5-cp312-cp312-win_arm64.whl", hash = "sha256:f28620fe26bee16243be2b7b874da327312240a7cdc38b769a697578d2100013", size = 10194667, upload-time = "2025-11-16T22:50:16.16Z" }, + { url = "https://files.pythonhosted.org/packages/db/69/9cde09f36da4b5a505341180a3f2e6fadc352fd4d2b7096ce9778db83f1a/numpy-2.3.5-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:d0f23b44f57077c1ede8c5f26b30f706498b4862d3ff0a7298b8411dd2f043ff", size = 16728251, upload-time = "2025-11-16T22:50:19.013Z" }, + { url = "https://files.pythonhosted.org/packages/79/fb/f505c95ceddd7027347b067689db71ca80bd5ecc926f913f1a23e65cf09b/numpy-2.3.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:aa5bc7c5d59d831d9773d1170acac7893ce3a5e130540605770ade83280e7188", size = 12254652, upload-time = "2025-11-16T22:50:21.487Z" }, + { url = "https://files.pythonhosted.org/packages/78/da/8c7738060ca9c31b30e9301ee0cf6c5ffdbf889d9593285a1cead337f9a5/numpy-2.3.5-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:ccc933afd4d20aad3c00bcef049cb40049f7f196e0397f1109dba6fed63267b0", size = 5083172, upload-time = "2025-11-16T22:50:24.562Z" }, + { url = "https://files.pythonhosted.org/packages/a4/b4/ee5bb2537fb9430fd2ef30a616c3672b991a4129bb1c7dcc42aa0abbe5d7/numpy-2.3.5-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:afaffc4393205524af9dfa400fa250143a6c3bc646c08c9f5e25a9f4b4d6a903", size = 6622990, upload-time = "2025-11-16T22:50:26.47Z" }, + { url = "https://files.pythonhosted.org/packages/95/03/dc0723a013c7d7c19de5ef29e932c3081df1c14ba582b8b86b5de9db7f0f/numpy-2.3.5-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9c75442b2209b8470d6d5d8b1c25714270686f14c749028d2199c54e29f20b4d", size = 14248902, upload-time = "2025-11-16T22:50:28.861Z" }, + { url = "https://files.pythonhosted.org/packages/f5/10/ca162f45a102738958dcec8023062dad0cbc17d1ab99d68c4e4a6c45fb2b/numpy-2.3.5-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:11e06aa0af8c0f05104d56450d6093ee639e15f24ecf62d417329d06e522e017", size = 16597430, upload-time = "2025-11-16T22:50:31.56Z" }, + { url = "https://files.pythonhosted.org/packages/2a/51/c1e29be863588db58175175f057286900b4b3327a1351e706d5e0f8dd679/numpy-2.3.5-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ed89927b86296067b4f81f108a2271d8926467a8868e554eaf370fc27fa3ccaf", size = 16024551, upload-time = "2025-11-16T22:50:34.242Z" }, + { url = "https://files.pythonhosted.org/packages/83/68/8236589d4dbb87253d28259d04d9b814ec0ecce7cb1c7fed29729f4c3a78/numpy-2.3.5-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:51c55fe3451421f3a6ef9a9c1439e82101c57a2c9eab9feb196a62b1a10b58ce", size = 18533275, upload-time = "2025-11-16T22:50:37.651Z" }, + { url = "https://files.pythonhosted.org/packages/40/56/2932d75b6f13465239e3b7b7e511be27f1b8161ca2510854f0b6e521c395/numpy-2.3.5-cp313-cp313-win32.whl", hash = "sha256:1978155dd49972084bd6ef388d66ab70f0c323ddee6f693d539376498720fb7e", size = 6277637, upload-time = "2025-11-16T22:50:40.11Z" }, + { url = "https://files.pythonhosted.org/packages/0c/88/e2eaa6cffb115b85ed7c7c87775cb8bcf0816816bc98ca8dbfa2ee33fe6e/numpy-2.3.5-cp313-cp313-win_amd64.whl", hash = "sha256:00dc4e846108a382c5869e77c6ed514394bdeb3403461d25a829711041217d5b", size = 12779090, upload-time = "2025-11-16T22:50:42.503Z" }, + { url = "https://files.pythonhosted.org/packages/8f/88/3f41e13a44ebd4034ee17baa384acac29ba6a4fcc2aca95f6f08ca0447d1/numpy-2.3.5-cp313-cp313-win_arm64.whl", hash = "sha256:0472f11f6ec23a74a906a00b48a4dcf3849209696dff7c189714511268d103ae", size = 10194710, upload-time = "2025-11-16T22:50:44.971Z" }, + { url = "https://files.pythonhosted.org/packages/13/cb/71744144e13389d577f867f745b7df2d8489463654a918eea2eeb166dfc9/numpy-2.3.5-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:414802f3b97f3c1eef41e530aaba3b3c1620649871d8cb38c6eaff034c2e16bd", size = 16827292, upload-time = "2025-11-16T22:50:47.715Z" }, + { url = "https://files.pythonhosted.org/packages/71/80/ba9dc6f2a4398e7f42b708a7fdc841bb638d353be255655498edbf9a15a8/numpy-2.3.5-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:5ee6609ac3604fa7780e30a03e5e241a7956f8e2fcfe547d51e3afa5247ac47f", size = 12378897, upload-time = "2025-11-16T22:50:51.327Z" }, + { url = "https://files.pythonhosted.org/packages/2e/6d/db2151b9f64264bcceccd51741aa39b50150de9b602d98ecfe7e0c4bff39/numpy-2.3.5-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:86d835afea1eaa143012a2d7a3f45a3adce2d7adc8b4961f0b362214d800846a", size = 5207391, upload-time = "2025-11-16T22:50:54.542Z" }, + { url = "https://files.pythonhosted.org/packages/80/ae/429bacace5ccad48a14c4ae5332f6aa8ab9f69524193511d60ccdfdc65fa/numpy-2.3.5-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:30bc11310e8153ca664b14c5f1b73e94bd0503681fcf136a163de856f3a50139", size = 6721275, upload-time = "2025-11-16T22:50:56.794Z" }, + { url = "https://files.pythonhosted.org/packages/74/5b/1919abf32d8722646a38cd527bc3771eb229a32724ee6ba340ead9b92249/numpy-2.3.5-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1062fde1dcf469571705945b0f221b73928f34a20c904ffb45db101907c3454e", size = 14306855, upload-time = "2025-11-16T22:50:59.208Z" }, + { url = "https://files.pythonhosted.org/packages/a5/87/6831980559434973bebc30cd9c1f21e541a0f2b0c280d43d3afd909b66d0/numpy-2.3.5-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ce581db493ea1a96c0556360ede6607496e8bf9b3a8efa66e06477267bc831e9", size = 16657359, upload-time = "2025-11-16T22:51:01.991Z" }, + { url = "https://files.pythonhosted.org/packages/dd/91/c797f544491ee99fd00495f12ebb7802c440c1915811d72ac5b4479a3356/numpy-2.3.5-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:cc8920d2ec5fa99875b670bb86ddeb21e295cb07aa331810d9e486e0b969d946", size = 16093374, upload-time = "2025-11-16T22:51:05.291Z" }, + { url = "https://files.pythonhosted.org/packages/74/a6/54da03253afcbe7a72785ec4da9c69fb7a17710141ff9ac5fcb2e32dbe64/numpy-2.3.5-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:9ee2197ef8c4f0dfe405d835f3b6a14f5fee7782b5de51ba06fb65fc9b36e9f1", size = 18594587, upload-time = "2025-11-16T22:51:08.585Z" }, + { url = "https://files.pythonhosted.org/packages/80/e9/aff53abbdd41b0ecca94285f325aff42357c6b5abc482a3fcb4994290b18/numpy-2.3.5-cp313-cp313t-win32.whl", hash = "sha256:70b37199913c1bd300ff6e2693316c6f869c7ee16378faf10e4f5e3275b299c3", size = 6405940, upload-time = "2025-11-16T22:51:11.541Z" }, + { url = "https://files.pythonhosted.org/packages/d5/81/50613fec9d4de5480de18d4f8ef59ad7e344d497edbef3cfd80f24f98461/numpy-2.3.5-cp313-cp313t-win_amd64.whl", hash = "sha256:b501b5fa195cc9e24fe102f21ec0a44dffc231d2af79950b451e0d99cea02234", size = 12920341, upload-time = "2025-11-16T22:51:14.312Z" }, + { url = "https://files.pythonhosted.org/packages/bb/ab/08fd63b9a74303947f34f0bd7c5903b9c5532c2d287bead5bdf4c556c486/numpy-2.3.5-cp313-cp313t-win_arm64.whl", hash = "sha256:a80afd79f45f3c4a7d341f13acbe058d1ca8ac017c165d3fa0d3de6bc1a079d7", size = 10262507, upload-time = "2025-11-16T22:51:16.846Z" }, + { url = "https://files.pythonhosted.org/packages/ba/97/1a914559c19e32d6b2e233cf9a6a114e67c856d35b1d6babca571a3e880f/numpy-2.3.5-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:bf06bc2af43fa8d32d30fae16ad965663e966b1a3202ed407b84c989c3221e82", size = 16735706, upload-time = "2025-11-16T22:51:19.558Z" }, + { url = "https://files.pythonhosted.org/packages/57/d4/51233b1c1b13ecd796311216ae417796b88b0616cfd8a33ae4536330748a/numpy-2.3.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:052e8c42e0c49d2575621c158934920524f6c5da05a1d3b9bab5d8e259e045f0", size = 12264507, upload-time = "2025-11-16T22:51:22.492Z" }, + { url = "https://files.pythonhosted.org/packages/45/98/2fe46c5c2675b8306d0b4a3ec3494273e93e1226a490f766e84298576956/numpy-2.3.5-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:1ed1ec893cff7040a02c8aa1c8611b94d395590d553f6b53629a4461dc7f7b63", size = 5093049, upload-time = "2025-11-16T22:51:25.171Z" }, + { url = "https://files.pythonhosted.org/packages/ce/0e/0698378989bb0ac5f1660c81c78ab1fe5476c1a521ca9ee9d0710ce54099/numpy-2.3.5-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:2dcd0808a421a482a080f89859a18beb0b3d1e905b81e617a188bd80422d62e9", size = 6626603, upload-time = "2025-11-16T22:51:27Z" }, + { url = "https://files.pythonhosted.org/packages/5e/a6/9ca0eecc489640615642a6cbc0ca9e10df70df38c4d43f5a928ff18d8827/numpy-2.3.5-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:727fd05b57df37dc0bcf1a27767a3d9a78cbbc92822445f32cc3436ba797337b", size = 14262696, upload-time = "2025-11-16T22:51:29.402Z" }, + { url = "https://files.pythonhosted.org/packages/c8/f6/07ec185b90ec9d7217a00eeeed7383b73d7e709dae2a9a021b051542a708/numpy-2.3.5-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fffe29a1ef00883599d1dc2c51aa2e5d80afe49523c261a74933df395c15c520", size = 16597350, upload-time = "2025-11-16T22:51:32.167Z" }, + { url = "https://files.pythonhosted.org/packages/75/37/164071d1dde6a1a84c9b8e5b414fa127981bad47adf3a6b7e23917e52190/numpy-2.3.5-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:8f7f0e05112916223d3f438f293abf0727e1181b5983f413dfa2fefc4098245c", size = 16040190, upload-time = "2025-11-16T22:51:35.403Z" }, + { url = "https://files.pythonhosted.org/packages/08/3c/f18b82a406b04859eb026d204e4e1773eb41c5be58410f41ffa511d114ae/numpy-2.3.5-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2e2eb32ddb9ccb817d620ac1d8dae7c3f641c1e5f55f531a33e8ab97960a75b8", size = 18536749, upload-time = "2025-11-16T22:51:39.698Z" }, + { url = "https://files.pythonhosted.org/packages/40/79/f82f572bf44cf0023a2fe8588768e23e1592585020d638999f15158609e1/numpy-2.3.5-cp314-cp314-win32.whl", hash = "sha256:66f85ce62c70b843bab1fb14a05d5737741e74e28c7b8b5a064de10142fad248", size = 6335432, upload-time = "2025-11-16T22:51:42.476Z" }, + { url = "https://files.pythonhosted.org/packages/a3/2e/235b4d96619931192c91660805e5e49242389742a7a82c27665021db690c/numpy-2.3.5-cp314-cp314-win_amd64.whl", hash = "sha256:e6a0bc88393d65807d751a614207b7129a310ca4fe76a74e5c7da5fa5671417e", size = 12919388, upload-time = "2025-11-16T22:51:45.275Z" }, + { url = "https://files.pythonhosted.org/packages/07/2b/29fd75ce45d22a39c61aad74f3d718e7ab67ccf839ca8b60866054eb15f8/numpy-2.3.5-cp314-cp314-win_arm64.whl", hash = "sha256:aeffcab3d4b43712bb7a60b65f6044d444e75e563ff6180af8f98dd4b905dfd2", size = 10476651, upload-time = "2025-11-16T22:51:47.749Z" }, + { url = "https://files.pythonhosted.org/packages/17/e1/f6a721234ebd4d87084cfa68d081bcba2f5cfe1974f7de4e0e8b9b2a2ba1/numpy-2.3.5-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:17531366a2e3a9e30762c000f2c43a9aaa05728712e25c11ce1dbe700c53ad41", size = 16834503, upload-time = "2025-11-16T22:51:50.443Z" }, + { url = "https://files.pythonhosted.org/packages/5c/1c/baf7ffdc3af9c356e1c135e57ab7cf8d247931b9554f55c467efe2c69eff/numpy-2.3.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:d21644de1b609825ede2f48be98dfde4656aefc713654eeee280e37cadc4e0ad", size = 12381612, upload-time = "2025-11-16T22:51:53.609Z" }, + { url = "https://files.pythonhosted.org/packages/74/91/f7f0295151407ddc9ba34e699013c32c3c91944f9b35fcf9281163dc1468/numpy-2.3.5-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:c804e3a5aba5460c73955c955bdbd5c08c354954e9270a2c1565f62e866bdc39", size = 5210042, upload-time = "2025-11-16T22:51:56.213Z" }, + { url = "https://files.pythonhosted.org/packages/2e/3b/78aebf345104ec50dd50a4d06ddeb46a9ff5261c33bcc58b1c4f12f85ec2/numpy-2.3.5-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:cc0a57f895b96ec78969c34f682c602bf8da1a0270b09bc65673df2e7638ec20", size = 6724502, upload-time = "2025-11-16T22:51:58.584Z" }, + { url = "https://files.pythonhosted.org/packages/02/c6/7c34b528740512e57ef1b7c8337ab0b4f0bddf34c723b8996c675bc2bc91/numpy-2.3.5-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:900218e456384ea676e24ea6a0417f030a3b07306d29d7ad843957b40a9d8d52", size = 14308962, upload-time = "2025-11-16T22:52:01.698Z" }, + { url = "https://files.pythonhosted.org/packages/80/35/09d433c5262bc32d725bafc619e095b6a6651caf94027a03da624146f655/numpy-2.3.5-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:09a1bea522b25109bf8e6f3027bd810f7c1085c64a0c7ce050c1676ad0ba010b", size = 16655054, upload-time = "2025-11-16T22:52:04.267Z" }, + { url = "https://files.pythonhosted.org/packages/7a/ab/6a7b259703c09a88804fa2430b43d6457b692378f6b74b356155283566ac/numpy-2.3.5-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:04822c00b5fd0323c8166d66c701dc31b7fbd252c100acd708c48f763968d6a3", size = 16091613, upload-time = "2025-11-16T22:52:08.651Z" }, + { url = "https://files.pythonhosted.org/packages/c2/88/330da2071e8771e60d1038166ff9d73f29da37b01ec3eb43cb1427464e10/numpy-2.3.5-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:d6889ec4ec662a1a37eb4b4fb26b6100841804dac55bd9df579e326cdc146227", size = 18591147, upload-time = "2025-11-16T22:52:11.453Z" }, + { url = "https://files.pythonhosted.org/packages/51/41/851c4b4082402d9ea860c3626db5d5df47164a712cb23b54be028b184c1c/numpy-2.3.5-cp314-cp314t-win32.whl", hash = "sha256:93eebbcf1aafdf7e2ddd44c2923e2672e1010bddc014138b229e49725b4d6be5", size = 6479806, upload-time = "2025-11-16T22:52:14.641Z" }, + { url = "https://files.pythonhosted.org/packages/90/30/d48bde1dfd93332fa557cff1972fbc039e055a52021fbef4c2c4b1eefd17/numpy-2.3.5-cp314-cp314t-win_amd64.whl", hash = "sha256:c8a9958e88b65c3b27e22ca2a076311636850b612d6bbfb76e8d156aacde2aaf", size = 13105760, upload-time = "2025-11-16T22:52:17.975Z" }, + { url = "https://files.pythonhosted.org/packages/2d/fd/4b5eb0b3e888d86aee4d198c23acec7d214baaf17ea93c1adec94c9518b9/numpy-2.3.5-cp314-cp314t-win_arm64.whl", hash = "sha256:6203fdf9f3dc5bdaed7319ad8698e685c7a3be10819f41d32a0723e611733b42", size = 10545459, upload-time = "2025-11-16T22:52:20.55Z" }, + { url = "https://files.pythonhosted.org/packages/c6/65/f9dea8e109371ade9c782b4e4756a82edf9d3366bca495d84d79859a0b79/numpy-2.3.5-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:f0963b55cdd70fad460fa4c1341f12f976bb26cb66021a5580329bd498988310", size = 16910689, upload-time = "2025-11-16T22:52:23.247Z" }, + { url = "https://files.pythonhosted.org/packages/00/4f/edb00032a8fb92ec0a679d3830368355da91a69cab6f3e9c21b64d0bb986/numpy-2.3.5-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:f4255143f5160d0de972d28c8f9665d882b5f61309d8362fdd3e103cf7bf010c", size = 12457053, upload-time = "2025-11-16T22:52:26.367Z" }, + { url = "https://files.pythonhosted.org/packages/16/a4/e8a53b5abd500a63836a29ebe145fc1ab1f2eefe1cfe59276020373ae0aa/numpy-2.3.5-pp311-pypy311_pp73-macosx_14_0_arm64.whl", hash = "sha256:a4b9159734b326535f4dd01d947f919c6eefd2d9827466a696c44ced82dfbc18", size = 5285635, upload-time = "2025-11-16T22:52:29.266Z" }, + { url = "https://files.pythonhosted.org/packages/a3/2f/37eeb9014d9c8b3e9c55bc599c68263ca44fdbc12a93e45a21d1d56df737/numpy-2.3.5-pp311-pypy311_pp73-macosx_14_0_x86_64.whl", hash = "sha256:2feae0d2c91d46e59fcd62784a3a83b3fb677fead592ce51b5a6fbb4f95965ff", size = 6801770, upload-time = "2025-11-16T22:52:31.421Z" }, + { url = "https://files.pythonhosted.org/packages/7d/e4/68d2f474df2cb671b2b6c2986a02e520671295647dad82484cde80ca427b/numpy-2.3.5-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ffac52f28a7849ad7576293c0cb7b9f08304e8f7d738a8cb8a90ec4c55a998eb", size = 14391768, upload-time = "2025-11-16T22:52:33.593Z" }, + { url = "https://files.pythonhosted.org/packages/b8/50/94ccd8a2b141cb50651fddd4f6a48874acb3c91c8f0842b08a6afc4b0b21/numpy-2.3.5-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:63c0e9e7eea69588479ebf4a8a270d5ac22763cc5854e9a7eae952a3908103f7", size = 16729263, upload-time = "2025-11-16T22:52:36.369Z" }, + { url = "https://files.pythonhosted.org/packages/2d/ee/346fa473e666fe14c52fcdd19ec2424157290a032d4c41f98127bfb31ac7/numpy-2.3.5-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:f16417ec91f12f814b10bafe79ef77e70113a2f5f7018640e7425ff979253425", size = 12967213, upload-time = "2025-11-16T22:52:39.38Z" }, +] + +[[package]] +name = "nvidia-sphinx-theme" +version = "0.0.9.post1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pydata-sphinx-theme" }, + { name = "sphinx", version = "8.1.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "sphinx", version = "8.2.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/8c/79/017fab2f7167a9a9795665f894d04f77aafceca80821b51589bb4b23ff5c/nvidia_sphinx_theme-0.0.9.post1-py3-none-any.whl", hash = "sha256:21ca60206dff2f380d7783d64bbaf71a5b9cacae53c7d0686f089c16b5a3d45a", size = 143816, upload-time = "2025-11-09T23:16:55.719Z" }, +] + +[[package]] +name = "oauthlib" +version = "3.3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0b/5f/19930f824ffeb0ad4372da4812c50edbd1434f678c90c2733e1188edfc63/oauthlib-3.3.1.tar.gz", hash = "sha256:0f0f8aa759826a193cf66c12ea1af1637f87b9b4622d46e866952bb022e538c9", size = 185918, upload-time = "2025-06-19T22:48:08.269Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/be/9c/92789c596b8df838baa98fa71844d84283302f7604ed565dafe5a6b5041a/oauthlib-3.3.1-py3-none-any.whl", hash = "sha256:88119c938d2b8fb88561af5f6ee0eec8cc8d552b7bb1f712743136eb7523b7a1", size = 160065, upload-time = "2025-06-19T22:48:06.508Z" }, +] + +[[package]] +name = "omegaconf" +version = "2.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "antlr4-python3-runtime" }, + { name = "pyyaml" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/09/48/6388f1bb9da707110532cb70ec4d2822858ddfb44f1cdf1233c20a80ea4b/omegaconf-2.3.0.tar.gz", hash = "sha256:d5d4b6d29955cc50ad50c46dc269bcd92c6e00f5f90d23ab5fee7bfca4ba4cc7", size = 3298120, upload-time = "2022-12-08T20:59:22.753Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e3/94/1843518e420fa3ed6919835845df698c7e27e183cb997394e4a670973a65/omegaconf-2.3.0-py3-none-any.whl", hash = "sha256:7b4df175cdb08ba400f45cae3bdcae7ba8365db4d165fc65fd04b050ab63b46b", size = 79500, upload-time = "2022-12-08T20:59:19.686Z" }, +] + +[[package]] +name = "packaging" +version = "25.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a1/d4/1fc4078c65507b51b96ca8f8c3ba19e6a61c8253c72794544580a7b6c24d/packaging-25.0.tar.gz", hash = "sha256:d443872c98d677bf60f6a1f2f8c1cb748e8fe762d2bf9d3148b5599295b0fc4f", size = 165727, upload-time = "2025-04-19T11:48:59.673Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/20/12/38679034af332785aac8774540895e234f4d07f7545804097de4b666afd8/packaging-25.0-py3-none-any.whl", hash = "sha256:29572ef2b1f17581046b3a2227d5c611fb25ec70ca1ba8554b24b0e69331a484", size = 66469, upload-time = "2025-04-19T11:48:57.875Z" }, +] + +[[package]] +name = "pandas" +version = "2.3.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "numpy", version = "2.3.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "python-dateutil" }, + { name = "pytz" }, + { name = "tzdata" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/33/01/d40b85317f86cf08d853a4f495195c73815fdf205eef3993821720274518/pandas-2.3.3.tar.gz", hash = "sha256:e05e1af93b977f7eafa636d043f9f94c7ee3ac81af99c13508215942e64c993b", size = 4495223, upload-time = "2025-09-29T23:34:51.853Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3d/f7/f425a00df4fcc22b292c6895c6831c0c8ae1d9fac1e024d16f98a9ce8749/pandas-2.3.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:376c6446ae31770764215a6c937f72d917f214b43560603cd60da6408f183b6c", size = 11555763, upload-time = "2025-09-29T23:16:53.287Z" }, + { url = "https://files.pythonhosted.org/packages/13/4f/66d99628ff8ce7857aca52fed8f0066ce209f96be2fede6cef9f84e8d04f/pandas-2.3.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e19d192383eab2f4ceb30b412b22ea30690c9e618f78870357ae1d682912015a", size = 10801217, upload-time = "2025-09-29T23:17:04.522Z" }, + { url = "https://files.pythonhosted.org/packages/1d/03/3fc4a529a7710f890a239cc496fc6d50ad4a0995657dccc1d64695adb9f4/pandas-2.3.3-cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5caf26f64126b6c7aec964f74266f435afef1c1b13da3b0636c7518a1fa3e2b1", size = 12148791, upload-time = "2025-09-29T23:17:18.444Z" }, + { url = "https://files.pythonhosted.org/packages/40/a8/4dac1f8f8235e5d25b9955d02ff6f29396191d4e665d71122c3722ca83c5/pandas-2.3.3-cp310-cp310-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dd7478f1463441ae4ca7308a70e90b33470fa593429f9d4c578dd00d1fa78838", size = 12769373, upload-time = "2025-09-29T23:17:35.846Z" }, + { url = "https://files.pythonhosted.org/packages/df/91/82cc5169b6b25440a7fc0ef3a694582418d875c8e3ebf796a6d6470aa578/pandas-2.3.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:4793891684806ae50d1288c9bae9330293ab4e083ccd1c5e383c34549c6e4250", size = 13200444, upload-time = "2025-09-29T23:17:49.341Z" }, + { url = "https://files.pythonhosted.org/packages/10/ae/89b3283800ab58f7af2952704078555fa60c807fff764395bb57ea0b0dbd/pandas-2.3.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:28083c648d9a99a5dd035ec125d42439c6c1c525098c58af0fc38dd1a7a1b3d4", size = 13858459, upload-time = "2025-09-29T23:18:03.722Z" }, + { url = "https://files.pythonhosted.org/packages/85/72/530900610650f54a35a19476eca5104f38555afccda1aa11a92ee14cb21d/pandas-2.3.3-cp310-cp310-win_amd64.whl", hash = "sha256:503cf027cf9940d2ceaa1a93cfb5f8c8c7e6e90720a2850378f0b3f3b1e06826", size = 11346086, upload-time = "2025-09-29T23:18:18.505Z" }, + { url = "https://files.pythonhosted.org/packages/c1/fa/7ac648108144a095b4fb6aa3de1954689f7af60a14cf25583f4960ecb878/pandas-2.3.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:602b8615ebcc4a0c1751e71840428ddebeb142ec02c786e8ad6b1ce3c8dec523", size = 11578790, upload-time = "2025-09-29T23:18:30.065Z" }, + { url = "https://files.pythonhosted.org/packages/9b/35/74442388c6cf008882d4d4bdfc4109be87e9b8b7ccd097ad1e7f006e2e95/pandas-2.3.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:8fe25fc7b623b0ef6b5009149627e34d2a4657e880948ec3c840e9402e5c1b45", size = 10833831, upload-time = "2025-09-29T23:38:56.071Z" }, + { url = "https://files.pythonhosted.org/packages/fe/e4/de154cbfeee13383ad58d23017da99390b91d73f8c11856f2095e813201b/pandas-2.3.3-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b468d3dad6ff947df92dcb32ede5b7bd41a9b3cceef0a30ed925f6d01fb8fa66", size = 12199267, upload-time = "2025-09-29T23:18:41.627Z" }, + { url = "https://files.pythonhosted.org/packages/bf/c9/63f8d545568d9ab91476b1818b4741f521646cbdd151c6efebf40d6de6f7/pandas-2.3.3-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b98560e98cb334799c0b07ca7967ac361a47326e9b4e5a7dfb5ab2b1c9d35a1b", size = 12789281, upload-time = "2025-09-29T23:18:56.834Z" }, + { url = "https://files.pythonhosted.org/packages/f2/00/a5ac8c7a0e67fd1a6059e40aa08fa1c52cc00709077d2300e210c3ce0322/pandas-2.3.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37b5848ba49824e5c30bedb9c830ab9b7751fd049bc7914533e01c65f79791", size = 13240453, upload-time = "2025-09-29T23:19:09.247Z" }, + { url = "https://files.pythonhosted.org/packages/27/4d/5c23a5bc7bd209231618dd9e606ce076272c9bc4f12023a70e03a86b4067/pandas-2.3.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:db4301b2d1f926ae677a751eb2bd0e8c5f5319c9cb3f88b0becbbb0b07b34151", size = 13890361, upload-time = "2025-09-29T23:19:25.342Z" }, + { url = "https://files.pythonhosted.org/packages/8e/59/712db1d7040520de7a4965df15b774348980e6df45c129b8c64d0dbe74ef/pandas-2.3.3-cp311-cp311-win_amd64.whl", hash = "sha256:f086f6fe114e19d92014a1966f43a3e62285109afe874f067f5abbdcbb10e59c", size = 11348702, upload-time = "2025-09-29T23:19:38.296Z" }, + { url = "https://files.pythonhosted.org/packages/9c/fb/231d89e8637c808b997d172b18e9d4a4bc7bf31296196c260526055d1ea0/pandas-2.3.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6d21f6d74eb1725c2efaa71a2bfc661a0689579b58e9c0ca58a739ff0b002b53", size = 11597846, upload-time = "2025-09-29T23:19:48.856Z" }, + { url = "https://files.pythonhosted.org/packages/5c/bd/bf8064d9cfa214294356c2d6702b716d3cf3bb24be59287a6a21e24cae6b/pandas-2.3.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3fd2f887589c7aa868e02632612ba39acb0b8948faf5cc58f0850e165bd46f35", size = 10729618, upload-time = "2025-09-29T23:39:08.659Z" }, + { url = "https://files.pythonhosted.org/packages/57/56/cf2dbe1a3f5271370669475ead12ce77c61726ffd19a35546e31aa8edf4e/pandas-2.3.3-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ecaf1e12bdc03c86ad4a7ea848d66c685cb6851d807a26aa245ca3d2017a1908", size = 11737212, upload-time = "2025-09-29T23:19:59.765Z" }, + { url = "https://files.pythonhosted.org/packages/e5/63/cd7d615331b328e287d8233ba9fdf191a9c2d11b6af0c7a59cfcec23de68/pandas-2.3.3-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b3d11d2fda7eb164ef27ffc14b4fcab16a80e1ce67e9f57e19ec0afaf715ba89", size = 12362693, upload-time = "2025-09-29T23:20:14.098Z" }, + { url = "https://files.pythonhosted.org/packages/a6/de/8b1895b107277d52f2b42d3a6806e69cfef0d5cf1d0ba343470b9d8e0a04/pandas-2.3.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a68e15f780eddf2b07d242e17a04aa187a7ee12b40b930bfdd78070556550e98", size = 12771002, upload-time = "2025-09-29T23:20:26.76Z" }, + { url = "https://files.pythonhosted.org/packages/87/21/84072af3187a677c5893b170ba2c8fbe450a6ff911234916da889b698220/pandas-2.3.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:371a4ab48e950033bcf52b6527eccb564f52dc826c02afd9a1bc0ab731bba084", size = 13450971, upload-time = "2025-09-29T23:20:41.344Z" }, + { url = "https://files.pythonhosted.org/packages/86/41/585a168330ff063014880a80d744219dbf1dd7a1c706e75ab3425a987384/pandas-2.3.3-cp312-cp312-win_amd64.whl", hash = "sha256:a16dcec078a01eeef8ee61bf64074b4e524a2a3f4b3be9326420cabe59c4778b", size = 10992722, upload-time = "2025-09-29T23:20:54.139Z" }, + { url = "https://files.pythonhosted.org/packages/cd/4b/18b035ee18f97c1040d94debd8f2e737000ad70ccc8f5513f4eefad75f4b/pandas-2.3.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:56851a737e3470de7fa88e6131f41281ed440d29a9268dcbf0002da5ac366713", size = 11544671, upload-time = "2025-09-29T23:21:05.024Z" }, + { url = "https://files.pythonhosted.org/packages/31/94/72fac03573102779920099bcac1c3b05975c2cb5f01eac609faf34bed1ca/pandas-2.3.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:bdcd9d1167f4885211e401b3036c0c8d9e274eee67ea8d0758a256d60704cfe8", size = 10680807, upload-time = "2025-09-29T23:21:15.979Z" }, + { url = "https://files.pythonhosted.org/packages/16/87/9472cf4a487d848476865321de18cc8c920b8cab98453ab79dbbc98db63a/pandas-2.3.3-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e32e7cc9af0f1cc15548288a51a3b681cc2a219faa838e995f7dc53dbab1062d", size = 11709872, upload-time = "2025-09-29T23:21:27.165Z" }, + { url = "https://files.pythonhosted.org/packages/15/07/284f757f63f8a8d69ed4472bfd85122bd086e637bf4ed09de572d575a693/pandas-2.3.3-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:318d77e0e42a628c04dc56bcef4b40de67918f7041c2b061af1da41dcff670ac", size = 12306371, upload-time = "2025-09-29T23:21:40.532Z" }, + { url = "https://files.pythonhosted.org/packages/33/81/a3afc88fca4aa925804a27d2676d22dcd2031c2ebe08aabd0ae55b9ff282/pandas-2.3.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4e0a175408804d566144e170d0476b15d78458795bb18f1304fb94160cabf40c", size = 12765333, upload-time = "2025-09-29T23:21:55.77Z" }, + { url = "https://files.pythonhosted.org/packages/8d/0f/b4d4ae743a83742f1153464cf1a8ecfafc3ac59722a0b5c8602310cb7158/pandas-2.3.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:93c2d9ab0fc11822b5eece72ec9587e172f63cff87c00b062f6e37448ced4493", size = 13418120, upload-time = "2025-09-29T23:22:10.109Z" }, + { url = "https://files.pythonhosted.org/packages/4f/c7/e54682c96a895d0c808453269e0b5928a07a127a15704fedb643e9b0a4c8/pandas-2.3.3-cp313-cp313-win_amd64.whl", hash = "sha256:f8bfc0e12dc78f777f323f55c58649591b2cd0c43534e8355c51d3fede5f4dee", size = 10993991, upload-time = "2025-09-29T23:25:04.889Z" }, + { url = "https://files.pythonhosted.org/packages/f9/ca/3f8d4f49740799189e1395812f3bf23b5e8fc7c190827d55a610da72ce55/pandas-2.3.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:75ea25f9529fdec2d2e93a42c523962261e567d250b0013b16210e1d40d7c2e5", size = 12048227, upload-time = "2025-09-29T23:22:24.343Z" }, + { url = "https://files.pythonhosted.org/packages/0e/5a/f43efec3e8c0cc92c4663ccad372dbdff72b60bdb56b2749f04aa1d07d7e/pandas-2.3.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:74ecdf1d301e812db96a465a525952f4dde225fdb6d8e5a521d47e1f42041e21", size = 11411056, upload-time = "2025-09-29T23:22:37.762Z" }, + { url = "https://files.pythonhosted.org/packages/46/b1/85331edfc591208c9d1a63a06baa67b21d332e63b7a591a5ba42a10bb507/pandas-2.3.3-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6435cb949cb34ec11cc9860246ccb2fdc9ecd742c12d3304989017d53f039a78", size = 11645189, upload-time = "2025-09-29T23:22:51.688Z" }, + { url = "https://files.pythonhosted.org/packages/44/23/78d645adc35d94d1ac4f2a3c4112ab6f5b8999f4898b8cdf01252f8df4a9/pandas-2.3.3-cp313-cp313t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:900f47d8f20860de523a1ac881c4c36d65efcb2eb850e6948140fa781736e110", size = 12121912, upload-time = "2025-09-29T23:23:05.042Z" }, + { url = "https://files.pythonhosted.org/packages/53/da/d10013df5e6aaef6b425aa0c32e1fc1f3e431e4bcabd420517dceadce354/pandas-2.3.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:a45c765238e2ed7d7c608fc5bc4a6f88b642f2f01e70c0c23d2224dd21829d86", size = 12712160, upload-time = "2025-09-29T23:23:28.57Z" }, + { url = "https://files.pythonhosted.org/packages/bd/17/e756653095a083d8a37cbd816cb87148debcfcd920129b25f99dd8d04271/pandas-2.3.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:c4fc4c21971a1a9f4bdb4c73978c7f7256caa3e62b323f70d6cb80db583350bc", size = 13199233, upload-time = "2025-09-29T23:24:24.876Z" }, + { url = "https://files.pythonhosted.org/packages/04/fd/74903979833db8390b73b3a8a7d30d146d710bd32703724dd9083950386f/pandas-2.3.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:ee15f284898e7b246df8087fc82b87b01686f98ee67d85a17b7ab44143a3a9a0", size = 11540635, upload-time = "2025-09-29T23:25:52.486Z" }, + { url = "https://files.pythonhosted.org/packages/21/00/266d6b357ad5e6d3ad55093a7e8efc7dd245f5a842b584db9f30b0f0a287/pandas-2.3.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1611aedd912e1ff81ff41c745822980c49ce4a7907537be8692c8dbc31924593", size = 10759079, upload-time = "2025-09-29T23:26:33.204Z" }, + { url = "https://files.pythonhosted.org/packages/ca/05/d01ef80a7a3a12b2f8bbf16daba1e17c98a2f039cbc8e2f77a2c5a63d382/pandas-2.3.3-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6d2cefc361461662ac48810cb14365a365ce864afe85ef1f447ff5a1e99ea81c", size = 11814049, upload-time = "2025-09-29T23:27:15.384Z" }, + { url = "https://files.pythonhosted.org/packages/15/b2/0e62f78c0c5ba7e3d2c5945a82456f4fac76c480940f805e0b97fcbc2f65/pandas-2.3.3-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ee67acbbf05014ea6c763beb097e03cd629961c8a632075eeb34247120abcb4b", size = 12332638, upload-time = "2025-09-29T23:27:51.625Z" }, + { url = "https://files.pythonhosted.org/packages/c5/33/dd70400631b62b9b29c3c93d2feee1d0964dc2bae2e5ad7a6c73a7f25325/pandas-2.3.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c46467899aaa4da076d5abc11084634e2d197e9460643dd455ac3db5856b24d6", size = 12886834, upload-time = "2025-09-29T23:28:21.289Z" }, + { url = "https://files.pythonhosted.org/packages/d3/18/b5d48f55821228d0d2692b34fd5034bb185e854bdb592e9c640f6290e012/pandas-2.3.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:6253c72c6a1d990a410bc7de641d34053364ef8bcd3126f7e7450125887dffe3", size = 13409925, upload-time = "2025-09-29T23:28:58.261Z" }, + { url = "https://files.pythonhosted.org/packages/a6/3d/124ac75fcd0ecc09b8fdccb0246ef65e35b012030defb0e0eba2cbbbe948/pandas-2.3.3-cp314-cp314-win_amd64.whl", hash = "sha256:1b07204a219b3b7350abaae088f451860223a52cfb8a6c53358e7948735158e5", size = 11109071, upload-time = "2025-09-29T23:32:27.484Z" }, + { url = "https://files.pythonhosted.org/packages/89/9c/0e21c895c38a157e0faa1fb64587a9226d6dd46452cac4532d80c3c4a244/pandas-2.3.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:2462b1a365b6109d275250baaae7b760fd25c726aaca0054649286bcfbb3e8ec", size = 12048504, upload-time = "2025-09-29T23:29:31.47Z" }, + { url = "https://files.pythonhosted.org/packages/d7/82/b69a1c95df796858777b68fbe6a81d37443a33319761d7c652ce77797475/pandas-2.3.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:0242fe9a49aa8b4d78a4fa03acb397a58833ef6199e9aa40a95f027bb3a1b6e7", size = 11410702, upload-time = "2025-09-29T23:29:54.591Z" }, + { url = "https://files.pythonhosted.org/packages/f9/88/702bde3ba0a94b8c73a0181e05144b10f13f29ebfc2150c3a79062a8195d/pandas-2.3.3-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a21d830e78df0a515db2b3d2f5570610f5e6bd2e27749770e8bb7b524b89b450", size = 11634535, upload-time = "2025-09-29T23:30:21.003Z" }, + { url = "https://files.pythonhosted.org/packages/a4/1e/1bac1a839d12e6a82ec6cb40cda2edde64a2013a66963293696bbf31fbbb/pandas-2.3.3-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2e3ebdb170b5ef78f19bfb71b0dc5dc58775032361fa188e814959b74d726dd5", size = 12121582, upload-time = "2025-09-29T23:30:43.391Z" }, + { url = "https://files.pythonhosted.org/packages/44/91/483de934193e12a3b1d6ae7c8645d083ff88dec75f46e827562f1e4b4da6/pandas-2.3.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:d051c0e065b94b7a3cea50eb1ec32e912cd96dba41647eb24104b6c6c14c5788", size = 12699963, upload-time = "2025-09-29T23:31:10.009Z" }, + { url = "https://files.pythonhosted.org/packages/70/44/5191d2e4026f86a2a109053e194d3ba7a31a2d10a9c2348368c63ed4e85a/pandas-2.3.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:3869faf4bd07b3b66a9f462417d0ca3a9df29a9f6abd5d0d0dbab15dac7abe87", size = 13202175, upload-time = "2025-09-29T23:31:59.173Z" }, +] + +[[package]] +name = "paramiko" +version = "4.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "bcrypt" }, + { name = "cryptography" }, + { name = "invoke" }, + { name = "pynacl" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/1f/e7/81fdcbc7f190cdb058cffc9431587eb289833bdd633e2002455ca9bb13d4/paramiko-4.0.0.tar.gz", hash = "sha256:6a25f07b380cc9c9a88d2b920ad37167ac4667f8d9886ccebd8f90f654b5d69f", size = 1630743, upload-time = "2025-08-04T01:02:03.711Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a9/90/a744336f5af32c433bd09af7854599682a383b37cfd78f7de263de6ad6cb/paramiko-4.0.0-py3-none-any.whl", hash = "sha256:0e20e00ac666503bf0b4eda3b6d833465a2b7aff2e2b3d79a8bba5ef144ee3b9", size = 223932, upload-time = "2025-08-04T01:02:02.029Z" }, +] + +[[package]] +name = "pathspec" +version = "0.12.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ca/bc/f35b8446f4531a7cb215605d100cd88b7ac6f44ab3fc94870c120ab3adbf/pathspec-0.12.1.tar.gz", hash = "sha256:a482d51503a1ab33b1c67a6c3813a26953dbdc71c31dacaef9a838c4e29f5712", size = 51043, upload-time = "2023-12-10T22:30:45Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cc/20/ff623b09d963f88bfde16306a54e12ee5ea43e9b597108672ff3a408aad6/pathspec-0.12.1-py3-none-any.whl", hash = "sha256:a0d503e138a4c123b27490a4f7beda6a01c6f288df0e4a8b79c7eb0dc7b4cc08", size = 31191, upload-time = "2023-12-10T22:30:43.14Z" }, +] + +[[package]] +name = "pfzy" +version = "0.3.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d9/5a/32b50c077c86bfccc7bed4881c5a2b823518f5450a30e639db5d3711952e/pfzy-0.3.4.tar.gz", hash = "sha256:717ea765dd10b63618e7298b2d98efd819e0b30cd5905c9707223dceeb94b3f1", size = 8396, upload-time = "2022-01-28T02:26:17.946Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8c/d7/8ff98376b1acc4503253b685ea09981697385ce344d4e3935c2af49e044d/pfzy-0.3.4-py3-none-any.whl", hash = "sha256:5f50d5b2b3207fa72e7ec0ef08372ef652685470974a107d0d4999fc5a903a96", size = 8537, upload-time = "2022-01-28T02:26:16.047Z" }, +] + +[[package]] +name = "pillow" +version = "12.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5a/b0/cace85a1b0c9775a9f8f5d5423c8261c858760e2466c79b2dd184638b056/pillow-12.0.0.tar.gz", hash = "sha256:87d4f8125c9988bfbed67af47dd7a953e2fc7b0cc1e7800ec6d2080d490bb353", size = 47008828, upload-time = "2025-10-15T18:24:14.008Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5d/08/26e68b6b5da219c2a2cb7b563af008b53bb8e6b6fcb3fa40715fcdb2523a/pillow-12.0.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:3adfb466bbc544b926d50fe8f4a4e6abd8c6bffd28a26177594e6e9b2b76572b", size = 5289809, upload-time = "2025-10-15T18:21:27.791Z" }, + { url = "https://files.pythonhosted.org/packages/cb/e9/4e58fb097fb74c7b4758a680aacd558810a417d1edaa7000142976ef9d2f/pillow-12.0.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:1ac11e8ea4f611c3c0147424eae514028b5e9077dd99ab91e1bd7bc33ff145e1", size = 4650606, upload-time = "2025-10-15T18:21:29.823Z" }, + { url = "https://files.pythonhosted.org/packages/4b/e0/1fa492aa9f77b3bc6d471c468e62bfea1823056bf7e5e4f1914d7ab2565e/pillow-12.0.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d49e2314c373f4c2b39446fb1a45ed333c850e09d0c59ac79b72eb3b95397363", size = 6221023, upload-time = "2025-10-15T18:21:31.415Z" }, + { url = "https://files.pythonhosted.org/packages/c1/09/4de7cd03e33734ccd0c876f0251401f1314e819cbfd89a0fcb6e77927cc6/pillow-12.0.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c7b2a63fd6d5246349f3d3f37b14430d73ee7e8173154461785e43036ffa96ca", size = 8024937, upload-time = "2025-10-15T18:21:33.453Z" }, + { url = "https://files.pythonhosted.org/packages/2e/69/0688e7c1390666592876d9d474f5e135abb4acb39dcb583c4dc5490f1aff/pillow-12.0.0-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d64317d2587c70324b79861babb9c09f71fbb780bad212018874b2c013d8600e", size = 6334139, upload-time = "2025-10-15T18:21:35.395Z" }, + { url = "https://files.pythonhosted.org/packages/ed/1c/880921e98f525b9b44ce747ad1ea8f73fd7e992bafe3ca5e5644bf433dea/pillow-12.0.0-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d77153e14b709fd8b8af6f66a3afbb9ed6e9fc5ccf0b6b7e1ced7b036a228782", size = 7026074, upload-time = "2025-10-15T18:21:37.219Z" }, + { url = "https://files.pythonhosted.org/packages/28/03/96f718331b19b355610ef4ebdbbde3557c726513030665071fd025745671/pillow-12.0.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:32ed80ea8a90ee3e6fa08c21e2e091bba6eda8eccc83dbc34c95169507a91f10", size = 6448852, upload-time = "2025-10-15T18:21:39.168Z" }, + { url = "https://files.pythonhosted.org/packages/3a/a0/6a193b3f0cc9437b122978d2c5cbce59510ccf9a5b48825096ed7472da2f/pillow-12.0.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:c828a1ae702fc712978bda0320ba1b9893d99be0badf2647f693cc01cf0f04fa", size = 7117058, upload-time = "2025-10-15T18:21:40.997Z" }, + { url = "https://files.pythonhosted.org/packages/a7/c4/043192375eaa4463254e8e61f0e2ec9a846b983929a8d0a7122e0a6d6fff/pillow-12.0.0-cp310-cp310-win32.whl", hash = "sha256:bd87e140e45399c818fac4247880b9ce719e4783d767e030a883a970be632275", size = 6295431, upload-time = "2025-10-15T18:21:42.518Z" }, + { url = "https://files.pythonhosted.org/packages/92/c6/c2f2fc7e56301c21827e689bb8b0b465f1b52878b57471a070678c0c33cd/pillow-12.0.0-cp310-cp310-win_amd64.whl", hash = "sha256:455247ac8a4cfb7b9bc45b7e432d10421aea9fc2e74d285ba4072688a74c2e9d", size = 7000412, upload-time = "2025-10-15T18:21:44.404Z" }, + { url = "https://files.pythonhosted.org/packages/b2/d2/5f675067ba82da7a1c238a73b32e3fd78d67f9d9f80fbadd33a40b9c0481/pillow-12.0.0-cp310-cp310-win_arm64.whl", hash = "sha256:6ace95230bfb7cd79ef66caa064bbe2f2a1e63d93471c3a2e1f1348d9f22d6b7", size = 2435903, upload-time = "2025-10-15T18:21:46.29Z" }, + { url = "https://files.pythonhosted.org/packages/0e/5a/a2f6773b64edb921a756eb0729068acad9fc5208a53f4a349396e9436721/pillow-12.0.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:0fd00cac9c03256c8b2ff58f162ebcd2587ad3e1f2e397eab718c47e24d231cc", size = 5289798, upload-time = "2025-10-15T18:21:47.763Z" }, + { url = "https://files.pythonhosted.org/packages/2e/05/069b1f8a2e4b5a37493da6c5868531c3f77b85e716ad7a590ef87d58730d/pillow-12.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a3475b96f5908b3b16c47533daaa87380c491357d197564e0ba34ae75c0f3257", size = 4650589, upload-time = "2025-10-15T18:21:49.515Z" }, + { url = "https://files.pythonhosted.org/packages/61/e3/2c820d6e9a36432503ead175ae294f96861b07600a7156154a086ba7111a/pillow-12.0.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:110486b79f2d112cf6add83b28b627e369219388f64ef2f960fef9ebaf54c642", size = 6230472, upload-time = "2025-10-15T18:21:51.052Z" }, + { url = "https://files.pythonhosted.org/packages/4f/89/63427f51c64209c5e23d4d52071c8d0f21024d3a8a487737caaf614a5795/pillow-12.0.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5269cc1caeedb67e6f7269a42014f381f45e2e7cd42d834ede3c703a1d915fe3", size = 8033887, upload-time = "2025-10-15T18:21:52.604Z" }, + { url = "https://files.pythonhosted.org/packages/f6/1b/c9711318d4901093c15840f268ad649459cd81984c9ec9887756cca049a5/pillow-12.0.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:aa5129de4e174daccbc59d0a3b6d20eaf24417d59851c07ebb37aeb02947987c", size = 6343964, upload-time = "2025-10-15T18:21:54.619Z" }, + { url = "https://files.pythonhosted.org/packages/41/1e/db9470f2d030b4995083044cd8738cdd1bf773106819f6d8ba12597d5352/pillow-12.0.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bee2a6db3a7242ea309aa7ee8e2780726fed67ff4e5b40169f2c940e7eb09227", size = 7034756, upload-time = "2025-10-15T18:21:56.151Z" }, + { url = "https://files.pythonhosted.org/packages/cc/b0/6177a8bdd5ee4ed87cba2de5a3cc1db55ffbbec6176784ce5bb75aa96798/pillow-12.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:90387104ee8400a7b4598253b4c406f8958f59fcf983a6cea2b50d59f7d63d0b", size = 6458075, upload-time = "2025-10-15T18:21:57.759Z" }, + { url = "https://files.pythonhosted.org/packages/bc/5e/61537aa6fa977922c6a03253a0e727e6e4a72381a80d63ad8eec350684f2/pillow-12.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:bc91a56697869546d1b8f0a3ff35224557ae7f881050e99f615e0119bf934b4e", size = 7125955, upload-time = "2025-10-15T18:21:59.372Z" }, + { url = "https://files.pythonhosted.org/packages/1f/3d/d5033539344ee3cbd9a4d69e12e63ca3a44a739eb2d4c8da350a3d38edd7/pillow-12.0.0-cp311-cp311-win32.whl", hash = "sha256:27f95b12453d165099c84f8a8bfdfd46b9e4bda9e0e4b65f0635430027f55739", size = 6298440, upload-time = "2025-10-15T18:22:00.982Z" }, + { url = "https://files.pythonhosted.org/packages/4d/42/aaca386de5cc8bd8a0254516957c1f265e3521c91515b16e286c662854c4/pillow-12.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:b583dc9070312190192631373c6c8ed277254aa6e6084b74bdd0a6d3b221608e", size = 6999256, upload-time = "2025-10-15T18:22:02.617Z" }, + { url = "https://files.pythonhosted.org/packages/ba/f1/9197c9c2d5708b785f631a6dfbfa8eb3fb9672837cb92ae9af812c13b4ed/pillow-12.0.0-cp311-cp311-win_arm64.whl", hash = "sha256:759de84a33be3b178a64c8ba28ad5c135900359e85fb662bc6e403ad4407791d", size = 2436025, upload-time = "2025-10-15T18:22:04.598Z" }, + { url = "https://files.pythonhosted.org/packages/2c/90/4fcce2c22caf044e660a198d740e7fbc14395619e3cb1abad12192c0826c/pillow-12.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:53561a4ddc36facb432fae7a9d8afbfaf94795414f5cdc5fc52f28c1dca90371", size = 5249377, upload-time = "2025-10-15T18:22:05.993Z" }, + { url = "https://files.pythonhosted.org/packages/fd/e0/ed960067543d080691d47d6938ebccbf3976a931c9567ab2fbfab983a5dd/pillow-12.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:71db6b4c1653045dacc1585c1b0d184004f0d7e694c7b34ac165ca70c0838082", size = 4650343, upload-time = "2025-10-15T18:22:07.718Z" }, + { url = "https://files.pythonhosted.org/packages/e7/a1/f81fdeddcb99c044bf7d6faa47e12850f13cee0849537a7d27eeab5534d4/pillow-12.0.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:2fa5f0b6716fc88f11380b88b31fe591a06c6315e955c096c35715788b339e3f", size = 6232981, upload-time = "2025-10-15T18:22:09.287Z" }, + { url = "https://files.pythonhosted.org/packages/88/e1/9098d3ce341a8750b55b0e00c03f1630d6178f38ac191c81c97a3b047b44/pillow-12.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:82240051c6ca513c616f7f9da06e871f61bfd7805f566275841af15015b8f98d", size = 8041399, upload-time = "2025-10-15T18:22:10.872Z" }, + { url = "https://files.pythonhosted.org/packages/a7/62/a22e8d3b602ae8cc01446d0c57a54e982737f44b6f2e1e019a925143771d/pillow-12.0.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:55f818bd74fe2f11d4d7cbc65880a843c4075e0ac7226bc1a23261dbea531953", size = 6347740, upload-time = "2025-10-15T18:22:12.769Z" }, + { url = "https://files.pythonhosted.org/packages/4f/87/424511bdcd02c8d7acf9f65caa09f291a519b16bd83c3fb3374b3d4ae951/pillow-12.0.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b87843e225e74576437fd5b6a4c2205d422754f84a06942cfaf1dc32243e45a8", size = 7040201, upload-time = "2025-10-15T18:22:14.813Z" }, + { url = "https://files.pythonhosted.org/packages/dc/4d/435c8ac688c54d11755aedfdd9f29c9eeddf68d150fe42d1d3dbd2365149/pillow-12.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:c607c90ba67533e1b2355b821fef6764d1dd2cbe26b8c1005ae84f7aea25ff79", size = 6462334, upload-time = "2025-10-15T18:22:16.375Z" }, + { url = "https://files.pythonhosted.org/packages/2b/f2/ad34167a8059a59b8ad10bc5c72d4d9b35acc6b7c0877af8ac885b5f2044/pillow-12.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:21f241bdd5080a15bc86d3466a9f6074a9c2c2b314100dd896ac81ee6db2f1ba", size = 7134162, upload-time = "2025-10-15T18:22:17.996Z" }, + { url = "https://files.pythonhosted.org/packages/0c/b1/a7391df6adacf0a5c2cf6ac1cf1fcc1369e7d439d28f637a847f8803beb3/pillow-12.0.0-cp312-cp312-win32.whl", hash = "sha256:dd333073e0cacdc3089525c7df7d39b211bcdf31fc2824e49d01c6b6187b07d0", size = 6298769, upload-time = "2025-10-15T18:22:19.923Z" }, + { url = "https://files.pythonhosted.org/packages/a2/0b/d87733741526541c909bbf159e338dcace4f982daac6e5a8d6be225ca32d/pillow-12.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:9fe611163f6303d1619bbcb653540a4d60f9e55e622d60a3108be0d5b441017a", size = 7001107, upload-time = "2025-10-15T18:22:21.644Z" }, + { url = "https://files.pythonhosted.org/packages/bc/96/aaa61ce33cc98421fb6088af2a03be4157b1e7e0e87087c888e2370a7f45/pillow-12.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:7dfb439562f234f7d57b1ac6bc8fe7f838a4bd49c79230e0f6a1da93e82f1fad", size = 2436012, upload-time = "2025-10-15T18:22:23.621Z" }, + { url = "https://files.pythonhosted.org/packages/62/f2/de993bb2d21b33a98d031ecf6a978e4b61da207bef02f7b43093774c480d/pillow-12.0.0-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:0869154a2d0546545cde61d1789a6524319fc1897d9ee31218eae7a60ccc5643", size = 4045493, upload-time = "2025-10-15T18:22:25.758Z" }, + { url = "https://files.pythonhosted.org/packages/0e/b6/bc8d0c4c9f6f111a783d045310945deb769b806d7574764234ffd50bc5ea/pillow-12.0.0-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:a7921c5a6d31b3d756ec980f2f47c0cfdbce0fc48c22a39347a895f41f4a6ea4", size = 4120461, upload-time = "2025-10-15T18:22:27.286Z" }, + { url = "https://files.pythonhosted.org/packages/5d/57/d60d343709366a353dc56adb4ee1e7d8a2cc34e3fbc22905f4167cfec119/pillow-12.0.0-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:1ee80a59f6ce048ae13cda1abf7fbd2a34ab9ee7d401c46be3ca685d1999a399", size = 3576912, upload-time = "2025-10-15T18:22:28.751Z" }, + { url = "https://files.pythonhosted.org/packages/a4/a4/a0a31467e3f83b94d37568294b01d22b43ae3c5d85f2811769b9c66389dd/pillow-12.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:c50f36a62a22d350c96e49ad02d0da41dbd17ddc2e29750dbdba4323f85eb4a5", size = 5249132, upload-time = "2025-10-15T18:22:30.641Z" }, + { url = "https://files.pythonhosted.org/packages/83/06/48eab21dd561de2914242711434c0c0eb992ed08ff3f6107a5f44527f5e9/pillow-12.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:5193fde9a5f23c331ea26d0cf171fbf67e3f247585f50c08b3e205c7aeb4589b", size = 4650099, upload-time = "2025-10-15T18:22:32.73Z" }, + { url = "https://files.pythonhosted.org/packages/fc/bd/69ed99fd46a8dba7c1887156d3572fe4484e3f031405fcc5a92e31c04035/pillow-12.0.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:bde737cff1a975b70652b62d626f7785e0480918dece11e8fef3c0cf057351c3", size = 6230808, upload-time = "2025-10-15T18:22:34.337Z" }, + { url = "https://files.pythonhosted.org/packages/ea/94/8fad659bcdbf86ed70099cb60ae40be6acca434bbc8c4c0d4ef356d7e0de/pillow-12.0.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a6597ff2b61d121172f5844b53f21467f7082f5fb385a9a29c01414463f93b07", size = 8037804, upload-time = "2025-10-15T18:22:36.402Z" }, + { url = "https://files.pythonhosted.org/packages/20/39/c685d05c06deecfd4e2d1950e9a908aa2ca8bc4e6c3b12d93b9cafbd7837/pillow-12.0.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0b817e7035ea7f6b942c13aa03bb554fc44fea70838ea21f8eb31c638326584e", size = 6345553, upload-time = "2025-10-15T18:22:38.066Z" }, + { url = "https://files.pythonhosted.org/packages/38/57/755dbd06530a27a5ed74f8cb0a7a44a21722ebf318edbe67ddbd7fb28f88/pillow-12.0.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f4f1231b7dec408e8670264ce63e9c71409d9583dd21d32c163e25213ee2a344", size = 7037729, upload-time = "2025-10-15T18:22:39.769Z" }, + { url = "https://files.pythonhosted.org/packages/ca/b6/7e94f4c41d238615674d06ed677c14883103dce1c52e4af16f000338cfd7/pillow-12.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:6e51b71417049ad6ab14c49608b4a24d8fb3fe605e5dfabfe523b58064dc3d27", size = 6459789, upload-time = "2025-10-15T18:22:41.437Z" }, + { url = "https://files.pythonhosted.org/packages/9c/14/4448bb0b5e0f22dd865290536d20ec8a23b64e2d04280b89139f09a36bb6/pillow-12.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:d120c38a42c234dc9a8c5de7ceaaf899cf33561956acb4941653f8bdc657aa79", size = 7130917, upload-time = "2025-10-15T18:22:43.152Z" }, + { url = "https://files.pythonhosted.org/packages/dd/ca/16c6926cc1c015845745d5c16c9358e24282f1e588237a4c36d2b30f182f/pillow-12.0.0-cp313-cp313-win32.whl", hash = "sha256:4cc6b3b2efff105c6a1656cfe59da4fdde2cda9af1c5e0b58529b24525d0a098", size = 6302391, upload-time = "2025-10-15T18:22:44.753Z" }, + { url = "https://files.pythonhosted.org/packages/6d/2a/dd43dcfd6dae9b6a49ee28a8eedb98c7d5ff2de94a5d834565164667b97b/pillow-12.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:4cf7fed4b4580601c4345ceb5d4cbf5a980d030fd5ad07c4d2ec589f95f09905", size = 7007477, upload-time = "2025-10-15T18:22:46.838Z" }, + { url = "https://files.pythonhosted.org/packages/77/f0/72ea067f4b5ae5ead653053212af05ce3705807906ba3f3e8f58ddf617e6/pillow-12.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:9f0b04c6b8584c2c193babcccc908b38ed29524b29dd464bc8801bf10d746a3a", size = 2435918, upload-time = "2025-10-15T18:22:48.399Z" }, + { url = "https://files.pythonhosted.org/packages/f5/5e/9046b423735c21f0487ea6cb5b10f89ea8f8dfbe32576fe052b5ba9d4e5b/pillow-12.0.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:7fa22993bac7b77b78cae22bad1e2a987ddf0d9015c63358032f84a53f23cdc3", size = 5251406, upload-time = "2025-10-15T18:22:49.905Z" }, + { url = "https://files.pythonhosted.org/packages/12/66/982ceebcdb13c97270ef7a56c3969635b4ee7cd45227fa707c94719229c5/pillow-12.0.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:f135c702ac42262573fe9714dfe99c944b4ba307af5eb507abef1667e2cbbced", size = 4653218, upload-time = "2025-10-15T18:22:51.587Z" }, + { url = "https://files.pythonhosted.org/packages/16/b3/81e625524688c31859450119bf12674619429cab3119eec0e30a7a1029cb/pillow-12.0.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:c85de1136429c524e55cfa4e033b4a7940ac5c8ee4d9401cc2d1bf48154bbc7b", size = 6266564, upload-time = "2025-10-15T18:22:53.215Z" }, + { url = "https://files.pythonhosted.org/packages/98/59/dfb38f2a41240d2408096e1a76c671d0a105a4a8471b1871c6902719450c/pillow-12.0.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:38df9b4bfd3db902c9c2bd369bcacaf9d935b2fff73709429d95cc41554f7b3d", size = 8069260, upload-time = "2025-10-15T18:22:54.933Z" }, + { url = "https://files.pythonhosted.org/packages/dc/3d/378dbea5cd1874b94c312425ca77b0f47776c78e0df2df751b820c8c1d6c/pillow-12.0.0-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7d87ef5795da03d742bf49439f9ca4d027cde49c82c5371ba52464aee266699a", size = 6379248, upload-time = "2025-10-15T18:22:56.605Z" }, + { url = "https://files.pythonhosted.org/packages/84/b0/d525ef47d71590f1621510327acec75ae58c721dc071b17d8d652ca494d8/pillow-12.0.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:aff9e4d82d082ff9513bdd6acd4f5bd359f5b2c870907d2b0a9c5e10d40c88fe", size = 7066043, upload-time = "2025-10-15T18:22:58.53Z" }, + { url = "https://files.pythonhosted.org/packages/61/2c/aced60e9cf9d0cde341d54bf7932c9ffc33ddb4a1595798b3a5150c7ec4e/pillow-12.0.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:8d8ca2b210ada074d57fcee40c30446c9562e542fc46aedc19baf758a93532ee", size = 6490915, upload-time = "2025-10-15T18:23:00.582Z" }, + { url = "https://files.pythonhosted.org/packages/ef/26/69dcb9b91f4e59f8f34b2332a4a0a951b44f547c4ed39d3e4dcfcff48f89/pillow-12.0.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:99a7f72fb6249302aa62245680754862a44179b545ded638cf1fef59befb57ef", size = 7157998, upload-time = "2025-10-15T18:23:02.627Z" }, + { url = "https://files.pythonhosted.org/packages/61/2b/726235842220ca95fa441ddf55dd2382b52ab5b8d9c0596fe6b3f23dafe8/pillow-12.0.0-cp313-cp313t-win32.whl", hash = "sha256:4078242472387600b2ce8d93ade8899c12bf33fa89e55ec89fe126e9d6d5d9e9", size = 6306201, upload-time = "2025-10-15T18:23:04.709Z" }, + { url = "https://files.pythonhosted.org/packages/c0/3d/2afaf4e840b2df71344ababf2f8edd75a705ce500e5dc1e7227808312ae1/pillow-12.0.0-cp313-cp313t-win_amd64.whl", hash = "sha256:2c54c1a783d6d60595d3514f0efe9b37c8808746a66920315bfd34a938d7994b", size = 7013165, upload-time = "2025-10-15T18:23:06.46Z" }, + { url = "https://files.pythonhosted.org/packages/6f/75/3fa09aa5cf6ed04bee3fa575798ddf1ce0bace8edb47249c798077a81f7f/pillow-12.0.0-cp313-cp313t-win_arm64.whl", hash = "sha256:26d9f7d2b604cd23aba3e9faf795787456ac25634d82cd060556998e39c6fa47", size = 2437834, upload-time = "2025-10-15T18:23:08.194Z" }, + { url = "https://files.pythonhosted.org/packages/54/2a/9a8c6ba2c2c07b71bec92cf63e03370ca5e5f5c5b119b742bcc0cde3f9c5/pillow-12.0.0-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:beeae3f27f62308f1ddbcfb0690bf44b10732f2ef43758f169d5e9303165d3f9", size = 4045531, upload-time = "2025-10-15T18:23:10.121Z" }, + { url = "https://files.pythonhosted.org/packages/84/54/836fdbf1bfb3d66a59f0189ff0b9f5f666cee09c6188309300df04ad71fa/pillow-12.0.0-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:d4827615da15cd59784ce39d3388275ec093ae3ee8d7f0c089b76fa87af756c2", size = 4120554, upload-time = "2025-10-15T18:23:12.14Z" }, + { url = "https://files.pythonhosted.org/packages/0d/cd/16aec9f0da4793e98e6b54778a5fbce4f375c6646fe662e80600b8797379/pillow-12.0.0-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:3e42edad50b6909089750e65c91aa09aaf1e0a71310d383f11321b27c224ed8a", size = 3576812, upload-time = "2025-10-15T18:23:13.962Z" }, + { url = "https://files.pythonhosted.org/packages/f6/b7/13957fda356dc46339298b351cae0d327704986337c3c69bb54628c88155/pillow-12.0.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:e5d8efac84c9afcb40914ab49ba063d94f5dbdf5066db4482c66a992f47a3a3b", size = 5252689, upload-time = "2025-10-15T18:23:15.562Z" }, + { url = "https://files.pythonhosted.org/packages/fc/f5/eae31a306341d8f331f43edb2e9122c7661b975433de5e447939ae61c5da/pillow-12.0.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:266cd5f2b63ff316d5a1bba46268e603c9caf5606d44f38c2873c380950576ad", size = 4650186, upload-time = "2025-10-15T18:23:17.379Z" }, + { url = "https://files.pythonhosted.org/packages/86/62/2a88339aa40c4c77e79108facbd307d6091e2c0eb5b8d3cf4977cfca2fe6/pillow-12.0.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:58eea5ebe51504057dd95c5b77d21700b77615ab0243d8152793dc00eb4faf01", size = 6230308, upload-time = "2025-10-15T18:23:18.971Z" }, + { url = "https://files.pythonhosted.org/packages/c7/33/5425a8992bcb32d1cb9fa3dd39a89e613d09a22f2c8083b7bf43c455f760/pillow-12.0.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f13711b1a5ba512d647a0e4ba79280d3a9a045aaf7e0cc6fbe96b91d4cdf6b0c", size = 8039222, upload-time = "2025-10-15T18:23:20.909Z" }, + { url = "https://files.pythonhosted.org/packages/d8/61/3f5d3b35c5728f37953d3eec5b5f3e77111949523bd2dd7f31a851e50690/pillow-12.0.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6846bd2d116ff42cba6b646edf5bf61d37e5cbd256425fa089fee4ff5c07a99e", size = 6346657, upload-time = "2025-10-15T18:23:23.077Z" }, + { url = "https://files.pythonhosted.org/packages/3a/be/ee90a3d79271227e0f0a33c453531efd6ed14b2e708596ba5dd9be948da3/pillow-12.0.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c98fa880d695de164b4135a52fd2e9cd7b7c90a9d8ac5e9e443a24a95ef9248e", size = 7038482, upload-time = "2025-10-15T18:23:25.005Z" }, + { url = "https://files.pythonhosted.org/packages/44/34/a16b6a4d1ad727de390e9bd9f19f5f669e079e5826ec0f329010ddea492f/pillow-12.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:fa3ed2a29a9e9d2d488b4da81dcb54720ac3104a20bf0bd273f1e4648aff5af9", size = 6461416, upload-time = "2025-10-15T18:23:27.009Z" }, + { url = "https://files.pythonhosted.org/packages/b6/39/1aa5850d2ade7d7ba9f54e4e4c17077244ff7a2d9e25998c38a29749eb3f/pillow-12.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:d034140032870024e6b9892c692fe2968493790dd57208b2c37e3fb35f6df3ab", size = 7131584, upload-time = "2025-10-15T18:23:29.752Z" }, + { url = "https://files.pythonhosted.org/packages/bf/db/4fae862f8fad0167073a7733973bfa955f47e2cac3dc3e3e6257d10fab4a/pillow-12.0.0-cp314-cp314-win32.whl", hash = "sha256:1b1b133e6e16105f524a8dec491e0586d072948ce15c9b914e41cdadd209052b", size = 6400621, upload-time = "2025-10-15T18:23:32.06Z" }, + { url = "https://files.pythonhosted.org/packages/2b/24/b350c31543fb0107ab2599464d7e28e6f856027aadda995022e695313d94/pillow-12.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:8dc232e39d409036af549c86f24aed8273a40ffa459981146829a324e0848b4b", size = 7142916, upload-time = "2025-10-15T18:23:34.71Z" }, + { url = "https://files.pythonhosted.org/packages/0f/9b/0ba5a6fd9351793996ef7487c4fdbde8d3f5f75dbedc093bb598648fddf0/pillow-12.0.0-cp314-cp314-win_arm64.whl", hash = "sha256:d52610d51e265a51518692045e372a4c363056130d922a7351429ac9f27e70b0", size = 2523836, upload-time = "2025-10-15T18:23:36.967Z" }, + { url = "https://files.pythonhosted.org/packages/f5/7a/ceee0840aebc579af529b523d530840338ecf63992395842e54edc805987/pillow-12.0.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:1979f4566bb96c1e50a62d9831e2ea2d1211761e5662afc545fa766f996632f6", size = 5255092, upload-time = "2025-10-15T18:23:38.573Z" }, + { url = "https://files.pythonhosted.org/packages/44/76/20776057b4bfd1aef4eeca992ebde0f53a4dce874f3ae693d0ec90a4f79b/pillow-12.0.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b2e4b27a6e15b04832fe9bf292b94b5ca156016bbc1ea9c2c20098a0320d6cf6", size = 4653158, upload-time = "2025-10-15T18:23:40.238Z" }, + { url = "https://files.pythonhosted.org/packages/82/3f/d9ff92ace07be8836b4e7e87e6a4c7a8318d47c2f1463ffcf121fc57d9cb/pillow-12.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:fb3096c30df99fd01c7bf8e544f392103d0795b9f98ba71a8054bcbf56b255f1", size = 6267882, upload-time = "2025-10-15T18:23:42.434Z" }, + { url = "https://files.pythonhosted.org/packages/9f/7a/4f7ff87f00d3ad33ba21af78bfcd2f032107710baf8280e3722ceec28cda/pillow-12.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7438839e9e053ef79f7112c881cef684013855016f928b168b81ed5835f3e75e", size = 8071001, upload-time = "2025-10-15T18:23:44.29Z" }, + { url = "https://files.pythonhosted.org/packages/75/87/fcea108944a52dad8cca0715ae6247e271eb80459364a98518f1e4f480c1/pillow-12.0.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5d5c411a8eaa2299322b647cd932586b1427367fd3184ffbb8f7a219ea2041ca", size = 6380146, upload-time = "2025-10-15T18:23:46.065Z" }, + { url = "https://files.pythonhosted.org/packages/91/52/0d31b5e571ef5fd111d2978b84603fce26aba1b6092f28e941cb46570745/pillow-12.0.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d7e091d464ac59d2c7ad8e7e08105eaf9dafbc3883fd7265ffccc2baad6ac925", size = 7067344, upload-time = "2025-10-15T18:23:47.898Z" }, + { url = "https://files.pythonhosted.org/packages/7b/f4/2dd3d721f875f928d48e83bb30a434dee75a2531bca839bb996bb0aa5a91/pillow-12.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:792a2c0be4dcc18af9d4a2dfd8a11a17d5e25274a1062b0ec1c2d79c76f3e7f8", size = 6491864, upload-time = "2025-10-15T18:23:49.607Z" }, + { url = "https://files.pythonhosted.org/packages/30/4b/667dfcf3d61fc309ba5a15b141845cece5915e39b99c1ceab0f34bf1d124/pillow-12.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:afbefa430092f71a9593a99ab6a4e7538bc9eabbf7bf94f91510d3503943edc4", size = 7158911, upload-time = "2025-10-15T18:23:51.351Z" }, + { url = "https://files.pythonhosted.org/packages/a2/2f/16cabcc6426c32218ace36bf0d55955e813f2958afddbf1d391849fee9d1/pillow-12.0.0-cp314-cp314t-win32.whl", hash = "sha256:3830c769decf88f1289680a59d4f4c46c72573446352e2befec9a8512104fa52", size = 6408045, upload-time = "2025-10-15T18:23:53.177Z" }, + { url = "https://files.pythonhosted.org/packages/35/73/e29aa0c9c666cf787628d3f0dcf379f4791fba79f4936d02f8b37165bdf8/pillow-12.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:905b0365b210c73afb0ebe9101a32572152dfd1c144c7e28968a331b9217b94a", size = 7148282, upload-time = "2025-10-15T18:23:55.316Z" }, + { url = "https://files.pythonhosted.org/packages/c1/70/6b41bdcddf541b437bbb9f47f94d2db5d9ddef6c37ccab8c9107743748a4/pillow-12.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:99353a06902c2e43b43e8ff74ee65a7d90307d82370604746738a1e0661ccca7", size = 2525630, upload-time = "2025-10-15T18:23:57.149Z" }, + { url = "https://files.pythonhosted.org/packages/1d/b3/582327e6c9f86d037b63beebe981425d6811104cb443e8193824ef1a2f27/pillow-12.0.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:b22bd8c974942477156be55a768f7aa37c46904c175be4e158b6a86e3a6b7ca8", size = 5215068, upload-time = "2025-10-15T18:23:59.594Z" }, + { url = "https://files.pythonhosted.org/packages/fd/d6/67748211d119f3b6540baf90f92fae73ae51d5217b171b0e8b5f7e5d558f/pillow-12.0.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:805ebf596939e48dbb2e4922a1d3852cfc25c38160751ce02da93058b48d252a", size = 4614994, upload-time = "2025-10-15T18:24:01.669Z" }, + { url = "https://files.pythonhosted.org/packages/2d/e1/f8281e5d844c41872b273b9f2c34a4bf64ca08905668c8ae730eedc7c9fa/pillow-12.0.0-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:cae81479f77420d217def5f54b5b9d279804d17e982e0f2fa19b1d1e14ab5197", size = 5246639, upload-time = "2025-10-15T18:24:03.403Z" }, + { url = "https://files.pythonhosted.org/packages/94/5a/0d8ab8ffe8a102ff5df60d0de5af309015163bf710c7bb3e8311dd3b3ad0/pillow-12.0.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:aeaefa96c768fc66818730b952a862235d68825c178f1b3ffd4efd7ad2edcb7c", size = 6986839, upload-time = "2025-10-15T18:24:05.344Z" }, + { url = "https://files.pythonhosted.org/packages/20/2e/3434380e8110b76cd9eb00a363c484b050f949b4bbe84ba770bb8508a02c/pillow-12.0.0-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:09f2d0abef9e4e2f349305a4f8cc784a8a6c2f58a8c4892eea13b10a943bd26e", size = 5313505, upload-time = "2025-10-15T18:24:07.137Z" }, + { url = "https://files.pythonhosted.org/packages/57/ca/5a9d38900d9d74785141d6580950fe705de68af735ff6e727cb911b64740/pillow-12.0.0-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bdee52571a343d721fb2eb3b090a82d959ff37fc631e3f70422e0c2e029f3e76", size = 5963654, upload-time = "2025-10-15T18:24:09.579Z" }, + { url = "https://files.pythonhosted.org/packages/95/7e/f896623c3c635a90537ac093c6a618ebe1a90d87206e42309cb5d98a1b9e/pillow-12.0.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:b290fd8aa38422444d4b50d579de197557f182ef1068b75f5aa8558638b8d0a5", size = 6997850, upload-time = "2025-10-15T18:24:11.495Z" }, +] + +[[package]] +name = "platformdirs" +version = "4.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cf/86/0248f086a84f01b37aaec0fa567b397df1a119f73c16f6c7a9aac73ea309/platformdirs-4.5.1.tar.gz", hash = "sha256:61d5cdcc6065745cdd94f0f878977f8de9437be93de97c1c12f853c9c0cdcbda", size = 21715, upload-time = "2025-12-05T13:52:58.638Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cb/28/3bfe2fa5a7b9c46fe7e13c97bda14c895fb10fa2ebf1d0abb90e0cea7ee1/platformdirs-4.5.1-py3-none-any.whl", hash = "sha256:d03afa3963c806a9bed9d5125c8f4cb2fdaf74a55ab60e5d59b3fde758104d31", size = 18731, upload-time = "2025-12-05T13:52:56.823Z" }, +] + +[[package]] +name = "pluggy" +version = "1.6.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" }, +] + +[[package]] +name = "prometheus-client" +version = "0.23.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/23/53/3edb5d68ecf6b38fcbcc1ad28391117d2a322d9a1a3eff04bfdb184d8c3b/prometheus_client-0.23.1.tar.gz", hash = "sha256:6ae8f9081eaaaf153a2e959d2e6c4f4fb57b12ef76c8c7980202f1e57b48b2ce", size = 80481, upload-time = "2025-09-18T20:47:25.043Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b8/db/14bafcb4af2139e046d03fd00dea7873e48eafe18b7d2797e73d6681f210/prometheus_client-0.23.1-py3-none-any.whl", hash = "sha256:dd1913e6e76b59cfe44e7a4b83e01afc9873c1bdfd2ed8739f1e76aeca115f99", size = 61145, upload-time = "2025-09-18T20:47:23.875Z" }, +] + +[[package]] +name = "prometheus-fastapi-instrumentator" +version = "7.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "prometheus-client" }, + { name = "starlette" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0e/42/eeb55ea9b0eae7d6854bef6aef3ecd34674f85813bc3877efdaeb582ab7e/prometheus_fastapi_instrumentator-7.0.0.tar.gz", hash = "sha256:5ba67c9212719f244ad7942d75ded80693b26331ee5dfc1e7571e4794a9ccbed", size = 20077, upload-time = "2024-03-13T16:25:08.564Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/59/66/2e93a8f56adb51ede41d0ef5f4f0277522acc4adc87937f5457b7b5692a8/prometheus_fastapi_instrumentator-7.0.0-py3-none-any.whl", hash = "sha256:96030c43c776ee938a3dae58485ec24caed7e05bfc60fe067161e0d5b5757052", size = 19005, upload-time = "2024-03-13T16:25:03.687Z" }, +] + +[[package]] +name = "prompt-toolkit" +version = "3.0.52" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "wcwidth" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a1/96/06e01a7b38dce6fe1db213e061a4602dd6032a8a97ef6c1a862537732421/prompt_toolkit-3.0.52.tar.gz", hash = "sha256:28cde192929c8e7321de85de1ddbe736f1375148b02f2e17edd840042b1be855", size = 434198, upload-time = "2025-08-27T15:24:02.057Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/84/03/0d3ce49e2505ae70cf43bc5bb3033955d2fc9f932163e84dc0779cc47f48/prompt_toolkit-3.0.52-py3-none-any.whl", hash = "sha256:9aac639a3bbd33284347de5ad8d68ecc044b91a762dc39b7c21095fcd6a19955", size = 391431, upload-time = "2025-08-27T15:23:59.498Z" }, +] + +[[package]] +name = "propcache" +version = "0.4.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/9e/da/e9fc233cf63743258bff22b3dfa7ea5baef7b5bc324af47a0ad89b8ffc6f/propcache-0.4.1.tar.gz", hash = "sha256:f48107a8c637e80362555f37ecf49abe20370e557cc4ab374f04ec4423c97c3d", size = 46442, upload-time = "2025-10-08T19:49:02.291Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3c/0e/934b541323035566a9af292dba85a195f7b78179114f2c6ebb24551118a9/propcache-0.4.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:7c2d1fa3201efaf55d730400d945b5b3ab6e672e100ba0f9a409d950ab25d7db", size = 79534, upload-time = "2025-10-08T19:46:02.083Z" }, + { url = "https://files.pythonhosted.org/packages/a1/6b/db0d03d96726d995dc7171286c6ba9d8d14251f37433890f88368951a44e/propcache-0.4.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:1eb2994229cc8ce7fe9b3db88f5465f5fd8651672840b2e426b88cdb1a30aac8", size = 45526, upload-time = "2025-10-08T19:46:03.884Z" }, + { url = "https://files.pythonhosted.org/packages/e4/c3/82728404aea669e1600f304f2609cde9e665c18df5a11cdd57ed73c1dceb/propcache-0.4.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:66c1f011f45a3b33d7bcb22daed4b29c0c9e2224758b6be00686731e1b46f925", size = 47263, upload-time = "2025-10-08T19:46:05.405Z" }, + { url = "https://files.pythonhosted.org/packages/df/1b/39313ddad2bf9187a1432654c38249bab4562ef535ef07f5eb6eb04d0b1b/propcache-0.4.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9a52009f2adffe195d0b605c25ec929d26b36ef986ba85244891dee3b294df21", size = 201012, upload-time = "2025-10-08T19:46:07.165Z" }, + { url = "https://files.pythonhosted.org/packages/5b/01/f1d0b57d136f294a142acf97f4ed58c8e5b974c21e543000968357115011/propcache-0.4.1-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5d4e2366a9c7b837555cf02fb9be2e3167d333aff716332ef1b7c3a142ec40c5", size = 209491, upload-time = "2025-10-08T19:46:08.909Z" }, + { url = "https://files.pythonhosted.org/packages/a1/c8/038d909c61c5bb039070b3fb02ad5cccdb1dde0d714792e251cdb17c9c05/propcache-0.4.1-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:9d2b6caef873b4f09e26ea7e33d65f42b944837563a47a94719cc3544319a0db", size = 215319, upload-time = "2025-10-08T19:46:10.7Z" }, + { url = "https://files.pythonhosted.org/packages/08/57/8c87e93142b2c1fa2408e45695205a7ba05fb5db458c0bf5c06ba0e09ea6/propcache-0.4.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2b16ec437a8c8a965ecf95739448dd938b5c7f56e67ea009f4300d8df05f32b7", size = 196856, upload-time = "2025-10-08T19:46:12.003Z" }, + { url = "https://files.pythonhosted.org/packages/42/df/5615fec76aa561987a534759b3686008a288e73107faa49a8ae5795a9f7a/propcache-0.4.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:296f4c8ed03ca7476813fe666c9ea97869a8d7aec972618671b33a38a5182ef4", size = 193241, upload-time = "2025-10-08T19:46:13.495Z" }, + { url = "https://files.pythonhosted.org/packages/d5/21/62949eb3a7a54afe8327011c90aca7e03547787a88fb8bd9726806482fea/propcache-0.4.1-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:1f0978529a418ebd1f49dad413a2b68af33f85d5c5ca5c6ca2a3bed375a7ac60", size = 190552, upload-time = "2025-10-08T19:46:14.938Z" }, + { url = "https://files.pythonhosted.org/packages/30/ee/ab4d727dd70806e5b4de96a798ae7ac6e4d42516f030ee60522474b6b332/propcache-0.4.1-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:fd138803047fb4c062b1c1dd95462f5209456bfab55c734458f15d11da288f8f", size = 200113, upload-time = "2025-10-08T19:46:16.695Z" }, + { url = "https://files.pythonhosted.org/packages/8a/0b/38b46208e6711b016aa8966a3ac793eee0d05c7159d8342aa27fc0bc365e/propcache-0.4.1-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:8c9b3cbe4584636d72ff556d9036e0c9317fa27b3ac1f0f558e7e84d1c9c5900", size = 200778, upload-time = "2025-10-08T19:46:18.023Z" }, + { url = "https://files.pythonhosted.org/packages/cf/81/5abec54355ed344476bee711e9f04815d4b00a311ab0535599204eecc257/propcache-0.4.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:f93243fdc5657247533273ac4f86ae106cc6445a0efacb9a1bfe982fcfefd90c", size = 193047, upload-time = "2025-10-08T19:46:19.449Z" }, + { url = "https://files.pythonhosted.org/packages/ec/b6/1f237c04e32063cb034acd5f6ef34ef3a394f75502e72703545631ab1ef6/propcache-0.4.1-cp310-cp310-win32.whl", hash = "sha256:a0ee98db9c5f80785b266eb805016e36058ac72c51a064040f2bc43b61101cdb", size = 38093, upload-time = "2025-10-08T19:46:20.643Z" }, + { url = "https://files.pythonhosted.org/packages/a6/67/354aac4e0603a15f76439caf0427781bcd6797f370377f75a642133bc954/propcache-0.4.1-cp310-cp310-win_amd64.whl", hash = "sha256:1cdb7988c4e5ac7f6d175a28a9aa0c94cb6f2ebe52756a3c0cda98d2809a9e37", size = 41638, upload-time = "2025-10-08T19:46:21.935Z" }, + { url = "https://files.pythonhosted.org/packages/e0/e1/74e55b9fd1a4c209ff1a9a824bf6c8b3d1fc5a1ac3eabe23462637466785/propcache-0.4.1-cp310-cp310-win_arm64.whl", hash = "sha256:d82ad62b19645419fe79dd63b3f9253e15b30e955c0170e5cebc350c1844e581", size = 38229, upload-time = "2025-10-08T19:46:23.368Z" }, + { url = "https://files.pythonhosted.org/packages/8c/d4/4e2c9aaf7ac2242b9358f98dccd8f90f2605402f5afeff6c578682c2c491/propcache-0.4.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:60a8fda9644b7dfd5dece8c61d8a85e271cb958075bfc4e01083c148b61a7caf", size = 80208, upload-time = "2025-10-08T19:46:24.597Z" }, + { url = "https://files.pythonhosted.org/packages/c2/21/d7b68e911f9c8e18e4ae43bdbc1e1e9bbd971f8866eb81608947b6f585ff/propcache-0.4.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c30b53e7e6bda1d547cabb47c825f3843a0a1a42b0496087bb58d8fedf9f41b5", size = 45777, upload-time = "2025-10-08T19:46:25.733Z" }, + { url = "https://files.pythonhosted.org/packages/d3/1d/11605e99ac8ea9435651ee71ab4cb4bf03f0949586246476a25aadfec54a/propcache-0.4.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:6918ecbd897443087a3b7cd978d56546a812517dcaaca51b49526720571fa93e", size = 47647, upload-time = "2025-10-08T19:46:27.304Z" }, + { url = "https://files.pythonhosted.org/packages/58/1a/3c62c127a8466c9c843bccb503d40a273e5cc69838805f322e2826509e0d/propcache-0.4.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3d902a36df4e5989763425a8ab9e98cd8ad5c52c823b34ee7ef307fd50582566", size = 214929, upload-time = "2025-10-08T19:46:28.62Z" }, + { url = "https://files.pythonhosted.org/packages/56/b9/8fa98f850960b367c4b8fe0592e7fc341daa7a9462e925228f10a60cf74f/propcache-0.4.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a9695397f85973bb40427dedddf70d8dc4a44b22f1650dd4af9eedf443d45165", size = 221778, upload-time = "2025-10-08T19:46:30.358Z" }, + { url = "https://files.pythonhosted.org/packages/46/a6/0ab4f660eb59649d14b3d3d65c439421cf2f87fe5dd68591cbe3c1e78a89/propcache-0.4.1-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2bb07ffd7eaad486576430c89f9b215f9e4be68c4866a96e97db9e97fead85dc", size = 228144, upload-time = "2025-10-08T19:46:32.607Z" }, + { url = "https://files.pythonhosted.org/packages/52/6a/57f43e054fb3d3a56ac9fc532bc684fc6169a26c75c353e65425b3e56eef/propcache-0.4.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fd6f30fdcf9ae2a70abd34da54f18da086160e4d7d9251f81f3da0ff84fc5a48", size = 210030, upload-time = "2025-10-08T19:46:33.969Z" }, + { url = "https://files.pythonhosted.org/packages/40/e2/27e6feebb5f6b8408fa29f5efbb765cd54c153ac77314d27e457a3e993b7/propcache-0.4.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:fc38cba02d1acba4e2869eef1a57a43dfbd3d49a59bf90dda7444ec2be6a5570", size = 208252, upload-time = "2025-10-08T19:46:35.309Z" }, + { url = "https://files.pythonhosted.org/packages/9e/f8/91c27b22ccda1dbc7967f921c42825564fa5336a01ecd72eb78a9f4f53c2/propcache-0.4.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:67fad6162281e80e882fb3ec355398cf72864a54069d060321f6cd0ade95fe85", size = 202064, upload-time = "2025-10-08T19:46:36.993Z" }, + { url = "https://files.pythonhosted.org/packages/f2/26/7f00bd6bd1adba5aafe5f4a66390f243acab58eab24ff1a08bebb2ef9d40/propcache-0.4.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:f10207adf04d08bec185bae14d9606a1444715bc99180f9331c9c02093e1959e", size = 212429, upload-time = "2025-10-08T19:46:38.398Z" }, + { url = "https://files.pythonhosted.org/packages/84/89/fd108ba7815c1117ddca79c228f3f8a15fc82a73bca8b142eb5de13b2785/propcache-0.4.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:e9b0d8d0845bbc4cfcdcbcdbf5086886bc8157aa963c31c777ceff7846c77757", size = 216727, upload-time = "2025-10-08T19:46:39.732Z" }, + { url = "https://files.pythonhosted.org/packages/79/37/3ec3f7e3173e73f1d600495d8b545b53802cbf35506e5732dd8578db3724/propcache-0.4.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:981333cb2f4c1896a12f4ab92a9cc8f09ea664e9b7dbdc4eff74627af3a11c0f", size = 205097, upload-time = "2025-10-08T19:46:41.025Z" }, + { url = "https://files.pythonhosted.org/packages/61/b0/b2631c19793f869d35f47d5a3a56fb19e9160d3c119f15ac7344fc3ccae7/propcache-0.4.1-cp311-cp311-win32.whl", hash = "sha256:f1d2f90aeec838a52f1c1a32fe9a619fefd5e411721a9117fbf82aea638fe8a1", size = 38084, upload-time = "2025-10-08T19:46:42.693Z" }, + { url = "https://files.pythonhosted.org/packages/f4/78/6cce448e2098e9f3bfc91bb877f06aa24b6ccace872e39c53b2f707c4648/propcache-0.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:364426a62660f3f699949ac8c621aad6977be7126c5807ce48c0aeb8e7333ea6", size = 41637, upload-time = "2025-10-08T19:46:43.778Z" }, + { url = "https://files.pythonhosted.org/packages/9c/e9/754f180cccd7f51a39913782c74717c581b9cc8177ad0e949f4d51812383/propcache-0.4.1-cp311-cp311-win_arm64.whl", hash = "sha256:e53f3a38d3510c11953f3e6a33f205c6d1b001129f972805ca9b42fc308bc239", size = 38064, upload-time = "2025-10-08T19:46:44.872Z" }, + { url = "https://files.pythonhosted.org/packages/a2/0f/f17b1b2b221d5ca28b4b876e8bb046ac40466513960646bda8e1853cdfa2/propcache-0.4.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:e153e9cd40cc8945138822807139367f256f89c6810c2634a4f6902b52d3b4e2", size = 80061, upload-time = "2025-10-08T19:46:46.075Z" }, + { url = "https://files.pythonhosted.org/packages/76/47/8ccf75935f51448ba9a16a71b783eb7ef6b9ee60f5d14c7f8a8a79fbeed7/propcache-0.4.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:cd547953428f7abb73c5ad82cbb32109566204260d98e41e5dfdc682eb7f8403", size = 46037, upload-time = "2025-10-08T19:46:47.23Z" }, + { url = "https://files.pythonhosted.org/packages/0a/b6/5c9a0e42df4d00bfb4a3cbbe5cf9f54260300c88a0e9af1f47ca5ce17ac0/propcache-0.4.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f048da1b4f243fc44f205dfd320933a951b8d89e0afd4c7cacc762a8b9165207", size = 47324, upload-time = "2025-10-08T19:46:48.384Z" }, + { url = "https://files.pythonhosted.org/packages/9e/d3/6c7ee328b39a81ee877c962469f1e795f9db87f925251efeb0545e0020d0/propcache-0.4.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ec17c65562a827bba85e3872ead335f95405ea1674860d96483a02f5c698fa72", size = 225505, upload-time = "2025-10-08T19:46:50.055Z" }, + { url = "https://files.pythonhosted.org/packages/01/5d/1c53f4563490b1d06a684742cc6076ef944bc6457df6051b7d1a877c057b/propcache-0.4.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:405aac25c6394ef275dee4c709be43745d36674b223ba4eb7144bf4d691b7367", size = 230242, upload-time = "2025-10-08T19:46:51.815Z" }, + { url = "https://files.pythonhosted.org/packages/20/e1/ce4620633b0e2422207c3cb774a0ee61cac13abc6217763a7b9e2e3f4a12/propcache-0.4.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0013cb6f8dde4b2a2f66903b8ba740bdfe378c943c4377a200551ceb27f379e4", size = 238474, upload-time = "2025-10-08T19:46:53.208Z" }, + { url = "https://files.pythonhosted.org/packages/46/4b/3aae6835b8e5f44ea6a68348ad90f78134047b503765087be2f9912140ea/propcache-0.4.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:15932ab57837c3368b024473a525e25d316d8353016e7cc0e5ba9eb343fbb1cf", size = 221575, upload-time = "2025-10-08T19:46:54.511Z" }, + { url = "https://files.pythonhosted.org/packages/6e/a5/8a5e8678bcc9d3a1a15b9a29165640d64762d424a16af543f00629c87338/propcache-0.4.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:031dce78b9dc099f4c29785d9cf5577a3faf9ebf74ecbd3c856a7b92768c3df3", size = 216736, upload-time = "2025-10-08T19:46:56.212Z" }, + { url = "https://files.pythonhosted.org/packages/f1/63/b7b215eddeac83ca1c6b934f89d09a625aa9ee4ba158338854c87210cc36/propcache-0.4.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:ab08df6c9a035bee56e31af99be621526bd237bea9f32def431c656b29e41778", size = 213019, upload-time = "2025-10-08T19:46:57.595Z" }, + { url = "https://files.pythonhosted.org/packages/57/74/f580099a58c8af587cac7ba19ee7cb418506342fbbe2d4a4401661cca886/propcache-0.4.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:4d7af63f9f93fe593afbf104c21b3b15868efb2c21d07d8732c0c4287e66b6a6", size = 220376, upload-time = "2025-10-08T19:46:59.067Z" }, + { url = "https://files.pythonhosted.org/packages/c4/ee/542f1313aff7eaf19c2bb758c5d0560d2683dac001a1c96d0774af799843/propcache-0.4.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:cfc27c945f422e8b5071b6e93169679e4eb5bf73bbcbf1ba3ae3a83d2f78ebd9", size = 226988, upload-time = "2025-10-08T19:47:00.544Z" }, + { url = "https://files.pythonhosted.org/packages/8f/18/9c6b015dd9c6930f6ce2229e1f02fb35298b847f2087ea2b436a5bfa7287/propcache-0.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:35c3277624a080cc6ec6f847cbbbb5b49affa3598c4535a0a4682a697aaa5c75", size = 215615, upload-time = "2025-10-08T19:47:01.968Z" }, + { url = "https://files.pythonhosted.org/packages/80/9e/e7b85720b98c45a45e1fca6a177024934dc9bc5f4d5dd04207f216fc33ed/propcache-0.4.1-cp312-cp312-win32.whl", hash = "sha256:671538c2262dadb5ba6395e26c1731e1d52534bfe9ae56d0b5573ce539266aa8", size = 38066, upload-time = "2025-10-08T19:47:03.503Z" }, + { url = "https://files.pythonhosted.org/packages/54/09/d19cff2a5aaac632ec8fc03737b223597b1e347416934c1b3a7df079784c/propcache-0.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:cb2d222e72399fcf5890d1d5cc1060857b9b236adff2792ff48ca2dfd46c81db", size = 41655, upload-time = "2025-10-08T19:47:04.973Z" }, + { url = "https://files.pythonhosted.org/packages/68/ab/6b5c191bb5de08036a8c697b265d4ca76148efb10fa162f14af14fb5f076/propcache-0.4.1-cp312-cp312-win_arm64.whl", hash = "sha256:204483131fb222bdaaeeea9f9e6c6ed0cac32731f75dfc1d4a567fc1926477c1", size = 37789, upload-time = "2025-10-08T19:47:06.077Z" }, + { url = "https://files.pythonhosted.org/packages/bf/df/6d9c1b6ac12b003837dde8a10231a7344512186e87b36e855bef32241942/propcache-0.4.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:43eedf29202c08550aac1d14e0ee619b0430aaef78f85864c1a892294fbc28cf", size = 77750, upload-time = "2025-10-08T19:47:07.648Z" }, + { url = "https://files.pythonhosted.org/packages/8b/e8/677a0025e8a2acf07d3418a2e7ba529c9c33caf09d3c1f25513023c1db56/propcache-0.4.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:d62cdfcfd89ccb8de04e0eda998535c406bf5e060ffd56be6c586cbcc05b3311", size = 44780, upload-time = "2025-10-08T19:47:08.851Z" }, + { url = "https://files.pythonhosted.org/packages/89/a4/92380f7ca60f99ebae761936bc48a72a639e8a47b29050615eef757cb2a7/propcache-0.4.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:cae65ad55793da34db5f54e4029b89d3b9b9490d8abe1b4c7ab5d4b8ec7ebf74", size = 46308, upload-time = "2025-10-08T19:47:09.982Z" }, + { url = "https://files.pythonhosted.org/packages/2d/48/c5ac64dee5262044348d1d78a5f85dd1a57464a60d30daee946699963eb3/propcache-0.4.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:333ddb9031d2704a301ee3e506dc46b1fe5f294ec198ed6435ad5b6a085facfe", size = 208182, upload-time = "2025-10-08T19:47:11.319Z" }, + { url = "https://files.pythonhosted.org/packages/c6/0c/cd762dd011a9287389a6a3eb43aa30207bde253610cca06824aeabfe9653/propcache-0.4.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:fd0858c20f078a32cf55f7e81473d96dcf3b93fd2ccdb3d40fdf54b8573df3af", size = 211215, upload-time = "2025-10-08T19:47:13.146Z" }, + { url = "https://files.pythonhosted.org/packages/30/3e/49861e90233ba36890ae0ca4c660e95df565b2cd15d4a68556ab5865974e/propcache-0.4.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:678ae89ebc632c5c204c794f8dab2837c5f159aeb59e6ed0539500400577298c", size = 218112, upload-time = "2025-10-08T19:47:14.913Z" }, + { url = "https://files.pythonhosted.org/packages/f1/8b/544bc867e24e1bd48f3118cecd3b05c694e160a168478fa28770f22fd094/propcache-0.4.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d472aeb4fbf9865e0c6d622d7f4d54a4e101a89715d8904282bb5f9a2f476c3f", size = 204442, upload-time = "2025-10-08T19:47:16.277Z" }, + { url = "https://files.pythonhosted.org/packages/50/a6/4282772fd016a76d3e5c0df58380a5ea64900afd836cec2c2f662d1b9bb3/propcache-0.4.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4d3df5fa7e36b3225954fba85589da77a0fe6a53e3976de39caf04a0db4c36f1", size = 199398, upload-time = "2025-10-08T19:47:17.962Z" }, + { url = "https://files.pythonhosted.org/packages/3e/ec/d8a7cd406ee1ddb705db2139f8a10a8a427100347bd698e7014351c7af09/propcache-0.4.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:ee17f18d2498f2673e432faaa71698032b0127ebf23ae5974eeaf806c279df24", size = 196920, upload-time = "2025-10-08T19:47:19.355Z" }, + { url = "https://files.pythonhosted.org/packages/f6/6c/f38ab64af3764f431e359f8baf9e0a21013e24329e8b85d2da32e8ed07ca/propcache-0.4.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:580e97762b950f993ae618e167e7be9256b8353c2dcd8b99ec100eb50f5286aa", size = 203748, upload-time = "2025-10-08T19:47:21.338Z" }, + { url = "https://files.pythonhosted.org/packages/d6/e3/fa846bd70f6534d647886621388f0a265254d30e3ce47e5c8e6e27dbf153/propcache-0.4.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:501d20b891688eb8e7aa903021f0b72d5a55db40ffaab27edefd1027caaafa61", size = 205877, upload-time = "2025-10-08T19:47:23.059Z" }, + { url = "https://files.pythonhosted.org/packages/e2/39/8163fc6f3133fea7b5f2827e8eba2029a0277ab2c5beee6c1db7b10fc23d/propcache-0.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9a0bd56e5b100aef69bd8562b74b46254e7c8812918d3baa700c8a8009b0af66", size = 199437, upload-time = "2025-10-08T19:47:24.445Z" }, + { url = "https://files.pythonhosted.org/packages/93/89/caa9089970ca49c7c01662bd0eeedfe85494e863e8043565aeb6472ce8fe/propcache-0.4.1-cp313-cp313-win32.whl", hash = "sha256:bcc9aaa5d80322bc2fb24bb7accb4a30f81e90ab8d6ba187aec0744bc302ad81", size = 37586, upload-time = "2025-10-08T19:47:25.736Z" }, + { url = "https://files.pythonhosted.org/packages/f5/ab/f76ec3c3627c883215b5c8080debb4394ef5a7a29be811f786415fc1e6fd/propcache-0.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:381914df18634f5494334d201e98245c0596067504b9372d8cf93f4bb23e025e", size = 40790, upload-time = "2025-10-08T19:47:26.847Z" }, + { url = "https://files.pythonhosted.org/packages/59/1b/e71ae98235f8e2ba5004d8cb19765a74877abf189bc53fc0c80d799e56c3/propcache-0.4.1-cp313-cp313-win_arm64.whl", hash = "sha256:8873eb4460fd55333ea49b7d189749ecf6e55bf85080f11b1c4530ed3034cba1", size = 37158, upload-time = "2025-10-08T19:47:27.961Z" }, + { url = "https://files.pythonhosted.org/packages/83/ce/a31bbdfc24ee0dcbba458c8175ed26089cf109a55bbe7b7640ed2470cfe9/propcache-0.4.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:92d1935ee1f8d7442da9c0c4fa7ac20d07e94064184811b685f5c4fada64553b", size = 81451, upload-time = "2025-10-08T19:47:29.445Z" }, + { url = "https://files.pythonhosted.org/packages/25/9c/442a45a470a68456e710d96cacd3573ef26a1d0a60067e6a7d5e655621ed/propcache-0.4.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:473c61b39e1460d386479b9b2f337da492042447c9b685f28be4f74d3529e566", size = 46374, upload-time = "2025-10-08T19:47:30.579Z" }, + { url = "https://files.pythonhosted.org/packages/f4/bf/b1d5e21dbc3b2e889ea4327044fb16312a736d97640fb8b6aa3f9c7b3b65/propcache-0.4.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:c0ef0aaafc66fbd87842a3fe3902fd889825646bc21149eafe47be6072725835", size = 48396, upload-time = "2025-10-08T19:47:31.79Z" }, + { url = "https://files.pythonhosted.org/packages/f4/04/5b4c54a103d480e978d3c8a76073502b18db0c4bc17ab91b3cb5092ad949/propcache-0.4.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f95393b4d66bfae908c3ca8d169d5f79cd65636ae15b5e7a4f6e67af675adb0e", size = 275950, upload-time = "2025-10-08T19:47:33.481Z" }, + { url = "https://files.pythonhosted.org/packages/b4/c1/86f846827fb969c4b78b0af79bba1d1ea2156492e1b83dea8b8a6ae27395/propcache-0.4.1-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c07fda85708bc48578467e85099645167a955ba093be0a2dcba962195676e859", size = 273856, upload-time = "2025-10-08T19:47:34.906Z" }, + { url = "https://files.pythonhosted.org/packages/36/1d/fc272a63c8d3bbad6878c336c7a7dea15e8f2d23a544bda43205dfa83ada/propcache-0.4.1-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:af223b406d6d000830c6f65f1e6431783fc3f713ba3e6cc8c024d5ee96170a4b", size = 280420, upload-time = "2025-10-08T19:47:36.338Z" }, + { url = "https://files.pythonhosted.org/packages/07/0c/01f2219d39f7e53d52e5173bcb09c976609ba30209912a0680adfb8c593a/propcache-0.4.1-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a78372c932c90ee474559c5ddfffd718238e8673c340dc21fe45c5b8b54559a0", size = 263254, upload-time = "2025-10-08T19:47:37.692Z" }, + { url = "https://files.pythonhosted.org/packages/2d/18/cd28081658ce597898f0c4d174d4d0f3c5b6d4dc27ffafeef835c95eb359/propcache-0.4.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:564d9f0d4d9509e1a870c920a89b2fec951b44bf5ba7d537a9e7c1ccec2c18af", size = 261205, upload-time = "2025-10-08T19:47:39.659Z" }, + { url = "https://files.pythonhosted.org/packages/7a/71/1f9e22eb8b8316701c2a19fa1f388c8a3185082607da8e406a803c9b954e/propcache-0.4.1-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:17612831fda0138059cc5546f4d12a2aacfb9e47068c06af35c400ba58ba7393", size = 247873, upload-time = "2025-10-08T19:47:41.084Z" }, + { url = "https://files.pythonhosted.org/packages/4a/65/3d4b61f36af2b4eddba9def857959f1016a51066b4f1ce348e0cf7881f58/propcache-0.4.1-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:41a89040cb10bd345b3c1a873b2bf36413d48da1def52f268a055f7398514874", size = 262739, upload-time = "2025-10-08T19:47:42.51Z" }, + { url = "https://files.pythonhosted.org/packages/2a/42/26746ab087faa77c1c68079b228810436ccd9a5ce9ac85e2b7307195fd06/propcache-0.4.1-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:e35b88984e7fa64aacecea39236cee32dd9bd8c55f57ba8a75cf2399553f9bd7", size = 263514, upload-time = "2025-10-08T19:47:43.927Z" }, + { url = "https://files.pythonhosted.org/packages/94/13/630690fe201f5502d2403dd3cfd451ed8858fe3c738ee88d095ad2ff407b/propcache-0.4.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6f8b465489f927b0df505cbe26ffbeed4d6d8a2bbc61ce90eb074ff129ef0ab1", size = 257781, upload-time = "2025-10-08T19:47:45.448Z" }, + { url = "https://files.pythonhosted.org/packages/92/f7/1d4ec5841505f423469efbfc381d64b7b467438cd5a4bbcbb063f3b73d27/propcache-0.4.1-cp313-cp313t-win32.whl", hash = "sha256:2ad890caa1d928c7c2965b48f3a3815c853180831d0e5503d35cf00c472f4717", size = 41396, upload-time = "2025-10-08T19:47:47.202Z" }, + { url = "https://files.pythonhosted.org/packages/48/f0/615c30622316496d2cbbc29f5985f7777d3ada70f23370608c1d3e081c1f/propcache-0.4.1-cp313-cp313t-win_amd64.whl", hash = "sha256:f7ee0e597f495cf415bcbd3da3caa3bd7e816b74d0d52b8145954c5e6fd3ff37", size = 44897, upload-time = "2025-10-08T19:47:48.336Z" }, + { url = "https://files.pythonhosted.org/packages/fd/ca/6002e46eccbe0e33dcd4069ef32f7f1c9e243736e07adca37ae8c4830ec3/propcache-0.4.1-cp313-cp313t-win_arm64.whl", hash = "sha256:929d7cbe1f01bb7baffb33dc14eb5691c95831450a26354cd210a8155170c93a", size = 39789, upload-time = "2025-10-08T19:47:49.876Z" }, + { url = "https://files.pythonhosted.org/packages/8e/5c/bca52d654a896f831b8256683457ceddd490ec18d9ec50e97dfd8fc726a8/propcache-0.4.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:3f7124c9d820ba5548d431afb4632301acf965db49e666aa21c305cbe8c6de12", size = 78152, upload-time = "2025-10-08T19:47:51.051Z" }, + { url = "https://files.pythonhosted.org/packages/65/9b/03b04e7d82a5f54fb16113d839f5ea1ede58a61e90edf515f6577c66fa8f/propcache-0.4.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:c0d4b719b7da33599dfe3b22d3db1ef789210a0597bc650b7cee9c77c2be8c5c", size = 44869, upload-time = "2025-10-08T19:47:52.594Z" }, + { url = "https://files.pythonhosted.org/packages/b2/fa/89a8ef0468d5833a23fff277b143d0573897cf75bd56670a6d28126c7d68/propcache-0.4.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:9f302f4783709a78240ebc311b793f123328716a60911d667e0c036bc5dcbded", size = 46596, upload-time = "2025-10-08T19:47:54.073Z" }, + { url = "https://files.pythonhosted.org/packages/86/bd/47816020d337f4a746edc42fe8d53669965138f39ee117414c7d7a340cfe/propcache-0.4.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c80ee5802e3fb9ea37938e7eecc307fb984837091d5fd262bb37238b1ae97641", size = 206981, upload-time = "2025-10-08T19:47:55.715Z" }, + { url = "https://files.pythonhosted.org/packages/df/f6/c5fa1357cc9748510ee55f37173eb31bfde6d94e98ccd9e6f033f2fc06e1/propcache-0.4.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ed5a841e8bb29a55fb8159ed526b26adc5bdd7e8bd7bf793ce647cb08656cdf4", size = 211490, upload-time = "2025-10-08T19:47:57.499Z" }, + { url = "https://files.pythonhosted.org/packages/80/1e/e5889652a7c4a3846683401a48f0f2e5083ce0ec1a8a5221d8058fbd1adf/propcache-0.4.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:55c72fd6ea2da4c318e74ffdf93c4fe4e926051133657459131a95c846d16d44", size = 215371, upload-time = "2025-10-08T19:47:59.317Z" }, + { url = "https://files.pythonhosted.org/packages/b2/f2/889ad4b2408f72fe1a4f6a19491177b30ea7bf1a0fd5f17050ca08cfc882/propcache-0.4.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8326e144341460402713f91df60ade3c999d601e7eb5ff8f6f7862d54de0610d", size = 201424, upload-time = "2025-10-08T19:48:00.67Z" }, + { url = "https://files.pythonhosted.org/packages/27/73/033d63069b57b0812c8bd19f311faebeceb6ba31b8f32b73432d12a0b826/propcache-0.4.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:060b16ae65bc098da7f6d25bf359f1f31f688384858204fe5d652979e0015e5b", size = 197566, upload-time = "2025-10-08T19:48:02.604Z" }, + { url = "https://files.pythonhosted.org/packages/dc/89/ce24f3dc182630b4e07aa6d15f0ff4b14ed4b9955fae95a0b54c58d66c05/propcache-0.4.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:89eb3fa9524f7bec9de6e83cf3faed9d79bffa560672c118a96a171a6f55831e", size = 193130, upload-time = "2025-10-08T19:48:04.499Z" }, + { url = "https://files.pythonhosted.org/packages/a9/24/ef0d5fd1a811fb5c609278d0209c9f10c35f20581fcc16f818da959fc5b4/propcache-0.4.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:dee69d7015dc235f526fe80a9c90d65eb0039103fe565776250881731f06349f", size = 202625, upload-time = "2025-10-08T19:48:06.213Z" }, + { url = "https://files.pythonhosted.org/packages/f5/02/98ec20ff5546f68d673df2f7a69e8c0d076b5abd05ca882dc7ee3a83653d/propcache-0.4.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:5558992a00dfd54ccbc64a32726a3357ec93825a418a401f5cc67df0ac5d9e49", size = 204209, upload-time = "2025-10-08T19:48:08.432Z" }, + { url = "https://files.pythonhosted.org/packages/a0/87/492694f76759b15f0467a2a93ab68d32859672b646aa8a04ce4864e7932d/propcache-0.4.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:c9b822a577f560fbd9554812526831712c1436d2c046cedee4c3796d3543b144", size = 197797, upload-time = "2025-10-08T19:48:09.968Z" }, + { url = "https://files.pythonhosted.org/packages/ee/36/66367de3575db1d2d3f3d177432bd14ee577a39d3f5d1b3d5df8afe3b6e2/propcache-0.4.1-cp314-cp314-win32.whl", hash = "sha256:ab4c29b49d560fe48b696cdcb127dd36e0bc2472548f3bf56cc5cb3da2b2984f", size = 38140, upload-time = "2025-10-08T19:48:11.232Z" }, + { url = "https://files.pythonhosted.org/packages/0c/2a/a758b47de253636e1b8aef181c0b4f4f204bf0dd964914fb2af90a95b49b/propcache-0.4.1-cp314-cp314-win_amd64.whl", hash = "sha256:5a103c3eb905fcea0ab98be99c3a9a5ab2de60228aa5aceedc614c0281cf6153", size = 41257, upload-time = "2025-10-08T19:48:12.707Z" }, + { url = "https://files.pythonhosted.org/packages/34/5e/63bd5896c3fec12edcbd6f12508d4890d23c265df28c74b175e1ef9f4f3b/propcache-0.4.1-cp314-cp314-win_arm64.whl", hash = "sha256:74c1fb26515153e482e00177a1ad654721bf9207da8a494a0c05e797ad27b992", size = 38097, upload-time = "2025-10-08T19:48:13.923Z" }, + { url = "https://files.pythonhosted.org/packages/99/85/9ff785d787ccf9bbb3f3106f79884a130951436f58392000231b4c737c80/propcache-0.4.1-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:824e908bce90fb2743bd6b59db36eb4f45cd350a39637c9f73b1c1ea66f5b75f", size = 81455, upload-time = "2025-10-08T19:48:15.16Z" }, + { url = "https://files.pythonhosted.org/packages/90/85/2431c10c8e7ddb1445c1f7c4b54d886e8ad20e3c6307e7218f05922cad67/propcache-0.4.1-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:c2b5e7db5328427c57c8e8831abda175421b709672f6cfc3d630c3b7e2146393", size = 46372, upload-time = "2025-10-08T19:48:16.424Z" }, + { url = "https://files.pythonhosted.org/packages/01/20/b0972d902472da9bcb683fa595099911f4d2e86e5683bcc45de60dd05dc3/propcache-0.4.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:6f6ff873ed40292cd4969ef5310179afd5db59fdf055897e282485043fc80ad0", size = 48411, upload-time = "2025-10-08T19:48:17.577Z" }, + { url = "https://files.pythonhosted.org/packages/e2/e3/7dc89f4f21e8f99bad3d5ddb3a3389afcf9da4ac69e3deb2dcdc96e74169/propcache-0.4.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:49a2dc67c154db2c1463013594c458881a069fcf98940e61a0569016a583020a", size = 275712, upload-time = "2025-10-08T19:48:18.901Z" }, + { url = "https://files.pythonhosted.org/packages/20/67/89800c8352489b21a8047c773067644e3897f02ecbbd610f4d46b7f08612/propcache-0.4.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:005f08e6a0529984491e37d8dbc3dd86f84bd78a8ceb5fa9a021f4c48d4984be", size = 273557, upload-time = "2025-10-08T19:48:20.762Z" }, + { url = "https://files.pythonhosted.org/packages/e2/a1/b52b055c766a54ce6d9c16d9aca0cad8059acd9637cdf8aa0222f4a026ef/propcache-0.4.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5c3310452e0d31390da9035c348633b43d7e7feb2e37be252be6da45abd1abcc", size = 280015, upload-time = "2025-10-08T19:48:22.592Z" }, + { url = "https://files.pythonhosted.org/packages/48/c8/33cee30bd890672c63743049f3c9e4be087e6780906bfc3ec58528be59c1/propcache-0.4.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4c3c70630930447f9ef1caac7728c8ad1c56bc5015338b20fed0d08ea2480b3a", size = 262880, upload-time = "2025-10-08T19:48:23.947Z" }, + { url = "https://files.pythonhosted.org/packages/0c/b1/8f08a143b204b418285c88b83d00edbd61afbc2c6415ffafc8905da7038b/propcache-0.4.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8e57061305815dfc910a3634dcf584f08168a8836e6999983569f51a8544cd89", size = 260938, upload-time = "2025-10-08T19:48:25.656Z" }, + { url = "https://files.pythonhosted.org/packages/cf/12/96e4664c82ca2f31e1c8dff86afb867348979eb78d3cb8546a680287a1e9/propcache-0.4.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:521a463429ef54143092c11a77e04056dd00636f72e8c45b70aaa3140d639726", size = 247641, upload-time = "2025-10-08T19:48:27.207Z" }, + { url = "https://files.pythonhosted.org/packages/18/ed/e7a9cfca28133386ba52278136d42209d3125db08d0a6395f0cba0c0285c/propcache-0.4.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:120c964da3fdc75e3731aa392527136d4ad35868cc556fd09bb6d09172d9a367", size = 262510, upload-time = "2025-10-08T19:48:28.65Z" }, + { url = "https://files.pythonhosted.org/packages/f5/76/16d8bf65e8845dd62b4e2b57444ab81f07f40caa5652b8969b87ddcf2ef6/propcache-0.4.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:d8f353eb14ee3441ee844ade4277d560cdd68288838673273b978e3d6d2c8f36", size = 263161, upload-time = "2025-10-08T19:48:30.133Z" }, + { url = "https://files.pythonhosted.org/packages/e7/70/c99e9edb5d91d5ad8a49fa3c1e8285ba64f1476782fed10ab251ff413ba1/propcache-0.4.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ab2943be7c652f09638800905ee1bab2c544e537edb57d527997a24c13dc1455", size = 257393, upload-time = "2025-10-08T19:48:31.567Z" }, + { url = "https://files.pythonhosted.org/packages/08/02/87b25304249a35c0915d236575bc3574a323f60b47939a2262b77632a3ee/propcache-0.4.1-cp314-cp314t-win32.whl", hash = "sha256:05674a162469f31358c30bcaa8883cb7829fa3110bf9c0991fe27d7896c42d85", size = 42546, upload-time = "2025-10-08T19:48:32.872Z" }, + { url = "https://files.pythonhosted.org/packages/cb/ef/3c6ecf8b317aa982f309835e8f96987466123c6e596646d4e6a1dfcd080f/propcache-0.4.1-cp314-cp314t-win_amd64.whl", hash = "sha256:990f6b3e2a27d683cb7602ed6c86f15ee6b43b1194736f9baaeb93d0016633b1", size = 46259, upload-time = "2025-10-08T19:48:34.226Z" }, + { url = "https://files.pythonhosted.org/packages/c4/2d/346e946d4951f37eca1e4f55be0f0174c52cd70720f84029b02f296f4a38/propcache-0.4.1-cp314-cp314t-win_arm64.whl", hash = "sha256:ecef2343af4cc68e05131e45024ba34f6095821988a9d0a02aa7c73fcc448aa9", size = 40428, upload-time = "2025-10-08T19:48:35.441Z" }, + { url = "https://files.pythonhosted.org/packages/5b/5a/bc7b4a4ef808fa59a816c17b20c4bef6884daebbdf627ff2a161da67da19/propcache-0.4.1-py3-none-any.whl", hash = "sha256:af2a6052aeb6cf17d3e46ee169099044fd8224cbaf75c76a2ef596e8163e2237", size = 13305, upload-time = "2025-10-08T19:49:00.792Z" }, +] + +[[package]] +name = "proto-plus" +version = "1.26.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "protobuf" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f4/ac/87285f15f7cce6d4a008f33f1757fb5a13611ea8914eb58c3d0d26243468/proto_plus-1.26.1.tar.gz", hash = "sha256:21a515a4c4c0088a773899e23c7bbade3d18f9c66c73edd4c7ee3816bc96a012", size = 56142, upload-time = "2025-03-10T15:54:38.843Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4e/6d/280c4c2ce28b1593a19ad5239c8b826871fc6ec275c21afc8e1820108039/proto_plus-1.26.1-py3-none-any.whl", hash = "sha256:13285478c2dcf2abb829db158e1047e2f1e8d63a077d94263c2b88b043c75a66", size = 50163, upload-time = "2025-03-10T15:54:37.335Z" }, +] + +[[package]] +name = "protobuf" +version = "6.33.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/34/44/e49ecff446afeec9d1a66d6bbf9adc21e3c7cea7803a920ca3773379d4f6/protobuf-6.33.2.tar.gz", hash = "sha256:56dc370c91fbb8ac85bc13582c9e373569668a290aa2e66a590c2a0d35ddb9e4", size = 444296, upload-time = "2025-12-06T00:17:53.311Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bc/91/1e3a34881a88697a7354ffd177e8746e97a722e5e8db101544b47e84afb1/protobuf-6.33.2-cp310-abi3-win32.whl", hash = "sha256:87eb388bd2d0f78febd8f4c8779c79247b26a5befad525008e49a6955787ff3d", size = 425603, upload-time = "2025-12-06T00:17:41.114Z" }, + { url = "https://files.pythonhosted.org/packages/64/20/4d50191997e917ae13ad0a235c8b42d8c1ab9c3e6fd455ca16d416944355/protobuf-6.33.2-cp310-abi3-win_amd64.whl", hash = "sha256:fc2a0e8b05b180e5fc0dd1559fe8ebdae21a27e81ac77728fb6c42b12c7419b4", size = 436930, upload-time = "2025-12-06T00:17:43.278Z" }, + { url = "https://files.pythonhosted.org/packages/b2/ca/7e485da88ba45c920fb3f50ae78de29ab925d9e54ef0de678306abfbb497/protobuf-6.33.2-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:d9b19771ca75935b3a4422957bc518b0cecb978b31d1dd12037b088f6bcc0e43", size = 427621, upload-time = "2025-12-06T00:17:44.445Z" }, + { url = "https://files.pythonhosted.org/packages/7d/4f/f743761e41d3b2b2566748eb76bbff2b43e14d5fcab694f494a16458b05f/protobuf-6.33.2-cp39-abi3-manylinux2014_aarch64.whl", hash = "sha256:b5d3b5625192214066d99b2b605f5783483575656784de223f00a8d00754fc0e", size = 324460, upload-time = "2025-12-06T00:17:45.678Z" }, + { url = "https://files.pythonhosted.org/packages/b1/fa/26468d00a92824020f6f2090d827078c09c9c587e34cbfd2d0c7911221f8/protobuf-6.33.2-cp39-abi3-manylinux2014_s390x.whl", hash = "sha256:8cd7640aee0b7828b6d03ae518b5b4806fdfc1afe8de82f79c3454f8aef29872", size = 339168, upload-time = "2025-12-06T00:17:46.813Z" }, + { url = "https://files.pythonhosted.org/packages/56/13/333b8f421738f149d4fe5e49553bc2a2ab75235486259f689b4b91f96cec/protobuf-6.33.2-cp39-abi3-manylinux2014_x86_64.whl", hash = "sha256:1f8017c48c07ec5859106533b682260ba3d7c5567b1ca1f24297ce03384d1b4f", size = 323270, upload-time = "2025-12-06T00:17:48.253Z" }, + { url = "https://files.pythonhosted.org/packages/0e/15/4f02896cc3df04fc465010a4c6a0cd89810f54617a32a70ef531ed75d61c/protobuf-6.33.2-py3-none-any.whl", hash = "sha256:7636aad9bb01768870266de5dc009de2d1b936771b38a793f73cbbf279c91c5c", size = 170501, upload-time = "2025-12-06T00:17:52.211Z" }, +] + +[[package]] +name = "pyarrow" +version = "22.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/30/53/04a7fdc63e6056116c9ddc8b43bc28c12cdd181b85cbeadb79278475f3ae/pyarrow-22.0.0.tar.gz", hash = "sha256:3d600dc583260d845c7d8a6db540339dd883081925da2bd1c5cb808f720b3cd9", size = 1151151, upload-time = "2025-10-24T12:30:00.762Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d9/9b/cb3f7e0a345353def531ca879053e9ef6b9f38ed91aebcf68b09ba54dec0/pyarrow-22.0.0-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:77718810bd3066158db1e95a63c160ad7ce08c6b0710bc656055033e39cdad88", size = 34223968, upload-time = "2025-10-24T10:03:31.21Z" }, + { url = "https://files.pythonhosted.org/packages/6c/41/3184b8192a120306270c5307f105b70320fdaa592c99843c5ef78aaefdcf/pyarrow-22.0.0-cp310-cp310-macosx_12_0_x86_64.whl", hash = "sha256:44d2d26cda26d18f7af7db71453b7b783788322d756e81730acb98f24eb90ace", size = 35942085, upload-time = "2025-10-24T10:03:38.146Z" }, + { url = "https://files.pythonhosted.org/packages/d9/3d/a1eab2f6f08001f9fb714b8ed5cfb045e2fe3e3e3c0c221f2c9ed1e6d67d/pyarrow-22.0.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:b9d71701ce97c95480fecb0039ec5bb889e75f110da72005743451339262f4ce", size = 44964613, upload-time = "2025-10-24T10:03:46.516Z" }, + { url = "https://files.pythonhosted.org/packages/46/46/a1d9c24baf21cfd9ce994ac820a24608decf2710521b29223d4334985127/pyarrow-22.0.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:710624ab925dc2b05a6229d47f6f0dac1c1155e6ed559be7109f684eba048a48", size = 47627059, upload-time = "2025-10-24T10:03:55.353Z" }, + { url = "https://files.pythonhosted.org/packages/3a/4c/f711acb13075c1391fd54bc17e078587672c575f8de2a6e62509af026dcf/pyarrow-22.0.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:f963ba8c3b0199f9d6b794c90ec77545e05eadc83973897a4523c9e8d84e9340", size = 47947043, upload-time = "2025-10-24T10:04:05.408Z" }, + { url = "https://files.pythonhosted.org/packages/4e/70/1f3180dd7c2eab35c2aca2b29ace6c519f827dcd4cfeb8e0dca41612cf7a/pyarrow-22.0.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:bd0d42297ace400d8febe55f13fdf46e86754842b860c978dfec16f081e5c653", size = 50206505, upload-time = "2025-10-24T10:04:15.786Z" }, + { url = "https://files.pythonhosted.org/packages/80/07/fea6578112c8c60ffde55883a571e4c4c6bc7049f119d6b09333b5cc6f73/pyarrow-22.0.0-cp310-cp310-win_amd64.whl", hash = "sha256:00626d9dc0f5ef3a75fe63fd68b9c7c8302d2b5bbc7f74ecaedba83447a24f84", size = 28101641, upload-time = "2025-10-24T10:04:22.57Z" }, + { url = "https://files.pythonhosted.org/packages/2e/b7/18f611a8cdc43417f9394a3ccd3eace2f32183c08b9eddc3d17681819f37/pyarrow-22.0.0-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:3e294c5eadfb93d78b0763e859a0c16d4051fc1c5231ae8956d61cb0b5666f5a", size = 34272022, upload-time = "2025-10-24T10:04:28.973Z" }, + { url = "https://files.pythonhosted.org/packages/26/5c/f259e2526c67eb4b9e511741b19870a02363a47a35edbebc55c3178db22d/pyarrow-22.0.0-cp311-cp311-macosx_12_0_x86_64.whl", hash = "sha256:69763ab2445f632d90b504a815a2a033f74332997052b721002298ed6de40f2e", size = 35995834, upload-time = "2025-10-24T10:04:35.467Z" }, + { url = "https://files.pythonhosted.org/packages/50/8d/281f0f9b9376d4b7f146913b26fac0aa2829cd1ee7e997f53a27411bbb92/pyarrow-22.0.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:b41f37cabfe2463232684de44bad753d6be08a7a072f6a83447eeaf0e4d2a215", size = 45030348, upload-time = "2025-10-24T10:04:43.366Z" }, + { url = "https://files.pythonhosted.org/packages/f5/e5/53c0a1c428f0976bf22f513d79c73000926cb00b9c138d8e02daf2102e18/pyarrow-22.0.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:35ad0f0378c9359b3f297299c3309778bb03b8612f987399a0333a560b43862d", size = 47699480, upload-time = "2025-10-24T10:04:51.486Z" }, + { url = "https://files.pythonhosted.org/packages/95/e1/9dbe4c465c3365959d183e6345d0a8d1dc5b02ca3f8db4760b3bc834cf25/pyarrow-22.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8382ad21458075c2e66a82a29d650f963ce51c7708c7c0ff313a8c206c4fd5e8", size = 48011148, upload-time = "2025-10-24T10:04:59.585Z" }, + { url = "https://files.pythonhosted.org/packages/c5/b4/7caf5d21930061444c3cf4fa7535c82faf5263e22ce43af7c2759ceb5b8b/pyarrow-22.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:1a812a5b727bc09c3d7ea072c4eebf657c2f7066155506ba31ebf4792f88f016", size = 50276964, upload-time = "2025-10-24T10:05:08.175Z" }, + { url = "https://files.pythonhosted.org/packages/ae/f3/cec89bd99fa3abf826f14d4e53d3d11340ce6f6af4d14bdcd54cd83b6576/pyarrow-22.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:ec5d40dd494882704fb876c16fa7261a69791e784ae34e6b5992e977bd2e238c", size = 28106517, upload-time = "2025-10-24T10:05:14.314Z" }, + { url = "https://files.pythonhosted.org/packages/af/63/ba23862d69652f85b615ca14ad14f3bcfc5bf1b99ef3f0cd04ff93fdad5a/pyarrow-22.0.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:bea79263d55c24a32b0d79c00a1c58bb2ee5f0757ed95656b01c0fb310c5af3d", size = 34211578, upload-time = "2025-10-24T10:05:21.583Z" }, + { url = "https://files.pythonhosted.org/packages/b1/d0/f9ad86fe809efd2bcc8be32032fa72e8b0d112b01ae56a053006376c5930/pyarrow-22.0.0-cp312-cp312-macosx_12_0_x86_64.whl", hash = "sha256:12fe549c9b10ac98c91cf791d2945e878875d95508e1a5d14091a7aaa66d9cf8", size = 35989906, upload-time = "2025-10-24T10:05:29.485Z" }, + { url = "https://files.pythonhosted.org/packages/b4/a8/f910afcb14630e64d673f15904ec27dd31f1e009b77033c365c84e8c1e1d/pyarrow-22.0.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:334f900ff08ce0423407af97e6c26ad5d4e3b0763645559ece6fbf3747d6a8f5", size = 45021677, upload-time = "2025-10-24T10:05:38.274Z" }, + { url = "https://files.pythonhosted.org/packages/13/95/aec81f781c75cd10554dc17a25849c720d54feafb6f7847690478dcf5ef8/pyarrow-22.0.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:c6c791b09c57ed76a18b03f2631753a4960eefbbca80f846da8baefc6491fcfe", size = 47726315, upload-time = "2025-10-24T10:05:47.314Z" }, + { url = "https://files.pythonhosted.org/packages/bb/d4/74ac9f7a54cfde12ee42734ea25d5a3c9a45db78f9def949307a92720d37/pyarrow-22.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:c3200cb41cdbc65156e5f8c908d739b0dfed57e890329413da2748d1a2cd1a4e", size = 47990906, upload-time = "2025-10-24T10:05:58.254Z" }, + { url = "https://files.pythonhosted.org/packages/2e/71/fedf2499bf7a95062eafc989ace56572f3343432570e1c54e6599d5b88da/pyarrow-22.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ac93252226cf288753d8b46280f4edf3433bf9508b6977f8dd8526b521a1bbb9", size = 50306783, upload-time = "2025-10-24T10:06:08.08Z" }, + { url = "https://files.pythonhosted.org/packages/68/ed/b202abd5a5b78f519722f3d29063dda03c114711093c1995a33b8e2e0f4b/pyarrow-22.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:44729980b6c50a5f2bfcc2668d36c569ce17f8b17bccaf470c4313dcbbf13c9d", size = 27972883, upload-time = "2025-10-24T10:06:14.204Z" }, + { url = "https://files.pythonhosted.org/packages/a6/d6/d0fac16a2963002fc22c8fa75180a838737203d558f0ed3b564c4a54eef5/pyarrow-22.0.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:e6e95176209257803a8b3d0394f21604e796dadb643d2f7ca21b66c9c0b30c9a", size = 34204629, upload-time = "2025-10-24T10:06:20.274Z" }, + { url = "https://files.pythonhosted.org/packages/c6/9c/1d6357347fbae062ad3f17082f9ebc29cc733321e892c0d2085f42a2212b/pyarrow-22.0.0-cp313-cp313-macosx_12_0_x86_64.whl", hash = "sha256:001ea83a58024818826a9e3f89bf9310a114f7e26dfe404a4c32686f97bd7901", size = 35985783, upload-time = "2025-10-24T10:06:27.301Z" }, + { url = "https://files.pythonhosted.org/packages/ff/c0/782344c2ce58afbea010150df07e3a2f5fdad299cd631697ae7bd3bac6e3/pyarrow-22.0.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:ce20fe000754f477c8a9125543f1936ea5b8867c5406757c224d745ed033e691", size = 45020999, upload-time = "2025-10-24T10:06:35.387Z" }, + { url = "https://files.pythonhosted.org/packages/1b/8b/5362443737a5307a7b67c1017c42cd104213189b4970bf607e05faf9c525/pyarrow-22.0.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:e0a15757fccb38c410947df156f9749ae4a3c89b2393741a50521f39a8cf202a", size = 47724601, upload-time = "2025-10-24T10:06:43.551Z" }, + { url = "https://files.pythonhosted.org/packages/69/4d/76e567a4fc2e190ee6072967cb4672b7d9249ac59ae65af2d7e3047afa3b/pyarrow-22.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:cedb9dd9358e4ea1d9bce3665ce0797f6adf97ff142c8e25b46ba9cdd508e9b6", size = 48001050, upload-time = "2025-10-24T10:06:52.284Z" }, + { url = "https://files.pythonhosted.org/packages/01/5e/5653f0535d2a1aef8223cee9d92944cb6bccfee5cf1cd3f462d7cb022790/pyarrow-22.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:252be4a05f9d9185bb8c18e83764ebcfea7185076c07a7a662253af3a8c07941", size = 50307877, upload-time = "2025-10-24T10:07:02.405Z" }, + { url = "https://files.pythonhosted.org/packages/2d/f8/1d0bd75bf9328a3b826e24a16e5517cd7f9fbf8d34a3184a4566ef5a7f29/pyarrow-22.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:a4893d31e5ef780b6edcaf63122df0f8d321088bb0dee4c8c06eccb1ca28d145", size = 27977099, upload-time = "2025-10-24T10:08:07.259Z" }, + { url = "https://files.pythonhosted.org/packages/90/81/db56870c997805bf2b0f6eeeb2d68458bf4654652dccdcf1bf7a42d80903/pyarrow-22.0.0-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:f7fe3dbe871294ba70d789be16b6e7e52b418311e166e0e3cba9522f0f437fb1", size = 34336685, upload-time = "2025-10-24T10:07:11.47Z" }, + { url = "https://files.pythonhosted.org/packages/1c/98/0727947f199aba8a120f47dfc229eeb05df15bcd7a6f1b669e9f882afc58/pyarrow-22.0.0-cp313-cp313t-macosx_12_0_x86_64.whl", hash = "sha256:ba95112d15fd4f1105fb2402c4eab9068f0554435e9b7085924bcfaac2cc306f", size = 36032158, upload-time = "2025-10-24T10:07:18.626Z" }, + { url = "https://files.pythonhosted.org/packages/96/b4/9babdef9c01720a0785945c7cf550e4acd0ebcd7bdd2e6f0aa7981fa85e2/pyarrow-22.0.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:c064e28361c05d72eed8e744c9605cbd6d2bb7481a511c74071fd9b24bc65d7d", size = 44892060, upload-time = "2025-10-24T10:07:26.002Z" }, + { url = "https://files.pythonhosted.org/packages/f8/ca/2f8804edd6279f78a37062d813de3f16f29183874447ef6d1aadbb4efa0f/pyarrow-22.0.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:6f9762274496c244d951c819348afbcf212714902742225f649cf02823a6a10f", size = 47504395, upload-time = "2025-10-24T10:07:34.09Z" }, + { url = "https://files.pythonhosted.org/packages/b9/f0/77aa5198fd3943682b2e4faaf179a674f0edea0d55d326d83cb2277d9363/pyarrow-22.0.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:a9d9ffdc2ab696f6b15b4d1f7cec6658e1d788124418cb30030afbae31c64746", size = 48066216, upload-time = "2025-10-24T10:07:43.528Z" }, + { url = "https://files.pythonhosted.org/packages/79/87/a1937b6e78b2aff18b706d738c9e46ade5bfcf11b294e39c87706a0089ac/pyarrow-22.0.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:ec1a15968a9d80da01e1d30349b2b0d7cc91e96588ee324ce1b5228175043e95", size = 50288552, upload-time = "2025-10-24T10:07:53.519Z" }, + { url = "https://files.pythonhosted.org/packages/60/ae/b5a5811e11f25788ccfdaa8f26b6791c9807119dffcf80514505527c384c/pyarrow-22.0.0-cp313-cp313t-win_amd64.whl", hash = "sha256:bba208d9c7decf9961998edf5c65e3ea4355d5818dd6cd0f6809bec1afb951cc", size = 28262504, upload-time = "2025-10-24T10:08:00.932Z" }, + { url = "https://files.pythonhosted.org/packages/bd/b0/0fa4d28a8edb42b0a7144edd20befd04173ac79819547216f8a9f36f9e50/pyarrow-22.0.0-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:9bddc2cade6561f6820d4cd73f99a0243532ad506bc510a75a5a65a522b2d74d", size = 34224062, upload-time = "2025-10-24T10:08:14.101Z" }, + { url = "https://files.pythonhosted.org/packages/0f/a8/7a719076b3c1be0acef56a07220c586f25cd24de0e3f3102b438d18ae5df/pyarrow-22.0.0-cp314-cp314-macosx_12_0_x86_64.whl", hash = "sha256:e70ff90c64419709d38c8932ea9fe1cc98415c4f87ea8da81719e43f02534bc9", size = 35990057, upload-time = "2025-10-24T10:08:21.842Z" }, + { url = "https://files.pythonhosted.org/packages/89/3c/359ed54c93b47fb6fe30ed16cdf50e3f0e8b9ccfb11b86218c3619ae50a8/pyarrow-22.0.0-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:92843c305330aa94a36e706c16209cd4df274693e777ca47112617db7d0ef3d7", size = 45068002, upload-time = "2025-10-24T10:08:29.034Z" }, + { url = "https://files.pythonhosted.org/packages/55/fc/4945896cc8638536ee787a3bd6ce7cec8ec9acf452d78ec39ab328efa0a1/pyarrow-22.0.0-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:6dda1ddac033d27421c20d7a7943eec60be44e0db4e079f33cc5af3b8280ccde", size = 47737765, upload-time = "2025-10-24T10:08:38.559Z" }, + { url = "https://files.pythonhosted.org/packages/cd/5e/7cb7edeb2abfaa1f79b5d5eb89432356155c8426f75d3753cbcb9592c0fd/pyarrow-22.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:84378110dd9a6c06323b41b56e129c504d157d1a983ce8f5443761eb5256bafc", size = 48048139, upload-time = "2025-10-24T10:08:46.784Z" }, + { url = "https://files.pythonhosted.org/packages/88/c6/546baa7c48185f5e9d6e59277c4b19f30f48c94d9dd938c2a80d4d6b067c/pyarrow-22.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:854794239111d2b88b40b6ef92aa478024d1e5074f364033e73e21e3f76b25e0", size = 50314244, upload-time = "2025-10-24T10:08:55.771Z" }, + { url = "https://files.pythonhosted.org/packages/3c/79/755ff2d145aafec8d347bf18f95e4e81c00127f06d080135dfc86aea417c/pyarrow-22.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:b883fe6fd85adad7932b3271c38ac289c65b7337c2c132e9569f9d3940620730", size = 28757501, upload-time = "2025-10-24T10:09:59.891Z" }, + { url = "https://files.pythonhosted.org/packages/0e/d2/237d75ac28ced3147912954e3c1a174df43a95f4f88e467809118a8165e0/pyarrow-22.0.0-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:7a820d8ae11facf32585507c11f04e3f38343c1e784c9b5a8b1da5c930547fe2", size = 34355506, upload-time = "2025-10-24T10:09:02.953Z" }, + { url = "https://files.pythonhosted.org/packages/1e/2c/733dfffe6d3069740f98e57ff81007809067d68626c5faef293434d11bd6/pyarrow-22.0.0-cp314-cp314t-macosx_12_0_x86_64.whl", hash = "sha256:c6ec3675d98915bf1ec8b3c7986422682f7232ea76cad276f4c8abd5b7319b70", size = 36047312, upload-time = "2025-10-24T10:09:10.334Z" }, + { url = "https://files.pythonhosted.org/packages/7c/2b/29d6e3782dc1f299727462c1543af357a0f2c1d3c160ce199950d9ca51eb/pyarrow-22.0.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:3e739edd001b04f654b166204fc7a9de896cf6007eaff33409ee9e50ceaff754", size = 45081609, upload-time = "2025-10-24T10:09:18.61Z" }, + { url = "https://files.pythonhosted.org/packages/8d/42/aa9355ecc05997915af1b7b947a7f66c02dcaa927f3203b87871c114ba10/pyarrow-22.0.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:7388ac685cab5b279a41dfe0a6ccd99e4dbf322edfb63e02fc0443bf24134e91", size = 47703663, upload-time = "2025-10-24T10:09:27.369Z" }, + { url = "https://files.pythonhosted.org/packages/ee/62/45abedde480168e83a1de005b7b7043fd553321c1e8c5a9a114425f64842/pyarrow-22.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:f633074f36dbc33d5c05b5dc75371e5660f1dbf9c8b1d95669def05e5425989c", size = 48066543, upload-time = "2025-10-24T10:09:34.908Z" }, + { url = "https://files.pythonhosted.org/packages/84/e9/7878940a5b072e4f3bf998770acafeae13b267f9893af5f6d4ab3904b67e/pyarrow-22.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:4c19236ae2402a8663a2c8f21f1870a03cc57f0bef7e4b6eb3238cc82944de80", size = 50288838, upload-time = "2025-10-24T10:09:44.394Z" }, + { url = "https://files.pythonhosted.org/packages/7b/03/f335d6c52b4a4761bcc83499789a1e2e16d9d201a58c327a9b5cc9a41bd9/pyarrow-22.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:0c34fe18094686194f204a3b1787a27456897d8a2d62caf84b61e8dfbc0252ae", size = 29185594, upload-time = "2025-10-24T10:09:53.111Z" }, +] + +[[package]] +name = "pyasn1" +version = "0.6.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ba/e9/01f1a64245b89f039897cb0130016d79f77d52669aae6ee7b159a6c4c018/pyasn1-0.6.1.tar.gz", hash = "sha256:6f580d2bdd84365380830acf45550f2511469f673cb4a5ae3857a3170128b034", size = 145322, upload-time = "2024-09-10T22:41:42.55Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c8/f1/d6a797abb14f6283c0ddff96bbdd46937f64122b8c925cab503dd37f8214/pyasn1-0.6.1-py3-none-any.whl", hash = "sha256:0d632f46f2ba09143da3a8afe9e33fb6f92fa2320ab7e886e2d0f7672af84629", size = 83135, upload-time = "2024-09-11T16:00:36.122Z" }, +] + +[[package]] +name = "pyasn1-modules" +version = "0.4.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pyasn1" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e9/e6/78ebbb10a8c8e4b61a59249394a4a594c1a7af95593dc933a349c8d00964/pyasn1_modules-0.4.2.tar.gz", hash = "sha256:677091de870a80aae844b1ca6134f54652fa2c8c5a52aa396440ac3106e941e6", size = 307892, upload-time = "2025-03-28T02:41:22.17Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/47/8d/d529b5d697919ba8c11ad626e835d4039be708a35b0d22de83a269a6682c/pyasn1_modules-0.4.2-py3-none-any.whl", hash = "sha256:29253a9207ce32b64c3ac6600edc75368f98473906e8fd1043bd6b5b1de2c14a", size = 181259, upload-time = "2025-03-28T02:41:19.028Z" }, +] + +[[package]] +name = "pycparser" +version = "2.23" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/fe/cf/d2d3b9f5699fb1e4615c8e32ff220203e43b248e1dfcc6736ad9057731ca/pycparser-2.23.tar.gz", hash = "sha256:78816d4f24add8f10a06d6f05b4d424ad9e96cfebf68a4ddc99c65c0720d00c2", size = 173734, upload-time = "2025-09-09T13:23:47.91Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a0/e3/59cd50310fc9b59512193629e1984c1f95e5c8ae6e5d8c69532ccc65a7fe/pycparser-2.23-py3-none-any.whl", hash = "sha256:e5c6e8d3fbad53479cab09ac03729e0a9faf2bee3db8208a550daf5af81a5934", size = 118140, upload-time = "2025-09-09T13:23:46.651Z" }, +] + +[[package]] +name = "pydantic" +version = "2.12.5" +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/69/44/36f1a6e523abc58ae5f928898e4aca2e0ea509b5aa6f6f392a5d882be928/pydantic-2.12.5.tar.gz", hash = "sha256:4d351024c75c0f085a9febbb665ce8c0c6ec5d30e903bdb6394b7ede26aebb49", size = 821591, upload-time = "2025-11-26T15:11:46.471Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5a/87/b70ad306ebb6f9b585f114d0ac2137d792b48be34d732d60e597c2f8465a/pydantic-2.12.5-py3-none-any.whl", hash = "sha256:e561593fccf61e8a20fc46dfc2dfe075b8be7d0188df33f221ad1f0139180f9d", size = 463580, upload-time = "2025-11-26T15:11:44.605Z" }, +] + +[[package]] +name = "pydantic-core" +version = "2.41.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/71/70/23b021c950c2addd24ec408e9ab05d59b035b39d97cdc1130e1bce647bb6/pydantic_core-2.41.5.tar.gz", hash = "sha256:08daa51ea16ad373ffd5e7606252cc32f07bc72b28284b6bc9c6df804816476e", size = 460952, upload-time = "2025-11-04T13:43:49.098Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c6/90/32c9941e728d564b411d574d8ee0cf09b12ec978cb22b294995bae5549a5/pydantic_core-2.41.5-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:77b63866ca88d804225eaa4af3e664c5faf3568cea95360d21f4725ab6e07146", size = 2107298, upload-time = "2025-11-04T13:39:04.116Z" }, + { url = "https://files.pythonhosted.org/packages/fb/a8/61c96a77fe28993d9a6fb0f4127e05430a267b235a124545d79fea46dd65/pydantic_core-2.41.5-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:dfa8a0c812ac681395907e71e1274819dec685fec28273a28905df579ef137e2", size = 1901475, upload-time = "2025-11-04T13:39:06.055Z" }, + { url = "https://files.pythonhosted.org/packages/5d/b6/338abf60225acc18cdc08b4faef592d0310923d19a87fba1faf05af5346e/pydantic_core-2.41.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5921a4d3ca3aee735d9fd163808f5e8dd6c6972101e4adbda9a4667908849b97", size = 1918815, upload-time = "2025-11-04T13:39:10.41Z" }, + { url = "https://files.pythonhosted.org/packages/d1/1c/2ed0433e682983d8e8cba9c8d8ef274d4791ec6a6f24c58935b90e780e0a/pydantic_core-2.41.5-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e25c479382d26a2a41b7ebea1043564a937db462816ea07afa8a44c0866d52f9", size = 2065567, upload-time = "2025-11-04T13:39:12.244Z" }, + { url = "https://files.pythonhosted.org/packages/b3/24/cf84974ee7d6eae06b9e63289b7b8f6549d416b5c199ca2d7ce13bbcf619/pydantic_core-2.41.5-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f547144f2966e1e16ae626d8ce72b4cfa0caedc7fa28052001c94fb2fcaa1c52", size = 2230442, upload-time = "2025-11-04T13:39:13.962Z" }, + { url = "https://files.pythonhosted.org/packages/fd/21/4e287865504b3edc0136c89c9c09431be326168b1eb7841911cbc877a995/pydantic_core-2.41.5-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6f52298fbd394f9ed112d56f3d11aabd0d5bd27beb3084cc3d8ad069483b8941", size = 2350956, upload-time = "2025-11-04T13:39:15.889Z" }, + { url = "https://files.pythonhosted.org/packages/a8/76/7727ef2ffa4b62fcab916686a68a0426b9b790139720e1934e8ba797e238/pydantic_core-2.41.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:100baa204bb412b74fe285fb0f3a385256dad1d1879f0a5cb1499ed2e83d132a", size = 2068253, upload-time = "2025-11-04T13:39:17.403Z" }, + { url = "https://files.pythonhosted.org/packages/d5/8c/a4abfc79604bcb4c748e18975c44f94f756f08fb04218d5cb87eb0d3a63e/pydantic_core-2.41.5-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:05a2c8852530ad2812cb7914dc61a1125dc4e06252ee98e5638a12da6cc6fb6c", size = 2177050, upload-time = "2025-11-04T13:39:19.351Z" }, + { url = "https://files.pythonhosted.org/packages/67/b1/de2e9a9a79b480f9cb0b6e8b6ba4c50b18d4e89852426364c66aa82bb7b3/pydantic_core-2.41.5-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:29452c56df2ed968d18d7e21f4ab0ac55e71dc59524872f6fc57dcf4a3249ed2", size = 2147178, upload-time = "2025-11-04T13:39:21Z" }, + { url = "https://files.pythonhosted.org/packages/16/c1/dfb33f837a47b20417500efaa0378adc6635b3c79e8369ff7a03c494b4ac/pydantic_core-2.41.5-cp310-cp310-musllinux_1_1_armv7l.whl", hash = "sha256:d5160812ea7a8a2ffbe233d8da666880cad0cbaf5d4de74ae15c313213d62556", size = 2341833, upload-time = "2025-11-04T13:39:22.606Z" }, + { url = "https://files.pythonhosted.org/packages/47/36/00f398642a0f4b815a9a558c4f1dca1b4020a7d49562807d7bc9ff279a6c/pydantic_core-2.41.5-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:df3959765b553b9440adfd3c795617c352154e497a4eaf3752555cfb5da8fc49", size = 2321156, upload-time = "2025-11-04T13:39:25.843Z" }, + { url = "https://files.pythonhosted.org/packages/7e/70/cad3acd89fde2010807354d978725ae111ddf6d0ea46d1ea1775b5c1bd0c/pydantic_core-2.41.5-cp310-cp310-win32.whl", hash = "sha256:1f8d33a7f4d5a7889e60dc39856d76d09333d8a6ed0f5f1190635cbec70ec4ba", size = 1989378, upload-time = "2025-11-04T13:39:27.92Z" }, + { url = "https://files.pythonhosted.org/packages/76/92/d338652464c6c367e5608e4488201702cd1cbb0f33f7b6a85a60fe5f3720/pydantic_core-2.41.5-cp310-cp310-win_amd64.whl", hash = "sha256:62de39db01b8d593e45871af2af9e497295db8d73b085f6bfd0b18c83c70a8f9", size = 2013622, upload-time = "2025-11-04T13:39:29.848Z" }, + { url = "https://files.pythonhosted.org/packages/e8/72/74a989dd9f2084b3d9530b0915fdda64ac48831c30dbf7c72a41a5232db8/pydantic_core-2.41.5-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:a3a52f6156e73e7ccb0f8cced536adccb7042be67cb45f9562e12b319c119da6", size = 2105873, upload-time = "2025-11-04T13:39:31.373Z" }, + { url = "https://files.pythonhosted.org/packages/12/44/37e403fd9455708b3b942949e1d7febc02167662bf1a7da5b78ee1ea2842/pydantic_core-2.41.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7f3bf998340c6d4b0c9a2f02d6a400e51f123b59565d74dc60d252ce888c260b", size = 1899826, upload-time = "2025-11-04T13:39:32.897Z" }, + { url = "https://files.pythonhosted.org/packages/33/7f/1d5cab3ccf44c1935a359d51a8a2a9e1a654b744b5e7f80d41b88d501eec/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:378bec5c66998815d224c9ca994f1e14c0c21cb95d2f52b6021cc0b2a58f2a5a", size = 1917869, upload-time = "2025-11-04T13:39:34.469Z" }, + { url = "https://files.pythonhosted.org/packages/6e/6a/30d94a9674a7fe4f4744052ed6c5e083424510be1e93da5bc47569d11810/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e7b576130c69225432866fe2f4a469a85a54ade141d96fd396dffcf607b558f8", size = 2063890, upload-time = "2025-11-04T13:39:36.053Z" }, + { url = "https://files.pythonhosted.org/packages/50/be/76e5d46203fcb2750e542f32e6c371ffa9b8ad17364cf94bb0818dbfb50c/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6cb58b9c66f7e4179a2d5e0f849c48eff5c1fca560994d6eb6543abf955a149e", size = 2229740, upload-time = "2025-11-04T13:39:37.753Z" }, + { url = "https://files.pythonhosted.org/packages/d3/ee/fed784df0144793489f87db310a6bbf8118d7b630ed07aa180d6067e653a/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:88942d3a3dff3afc8288c21e565e476fc278902ae4d6d134f1eeda118cc830b1", size = 2350021, upload-time = "2025-11-04T13:39:40.94Z" }, + { url = "https://files.pythonhosted.org/packages/c8/be/8fed28dd0a180dca19e72c233cbf58efa36df055e5b9d90d64fd1740b828/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f31d95a179f8d64d90f6831d71fa93290893a33148d890ba15de25642c5d075b", size = 2066378, upload-time = "2025-11-04T13:39:42.523Z" }, + { url = "https://files.pythonhosted.org/packages/b0/3b/698cf8ae1d536a010e05121b4958b1257f0b5522085e335360e53a6b1c8b/pydantic_core-2.41.5-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c1df3d34aced70add6f867a8cf413e299177e0c22660cc767218373d0779487b", size = 2175761, upload-time = "2025-11-04T13:39:44.553Z" }, + { url = "https://files.pythonhosted.org/packages/b8/ba/15d537423939553116dea94ce02f9c31be0fa9d0b806d427e0308ec17145/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:4009935984bd36bd2c774e13f9a09563ce8de4abaa7226f5108262fa3e637284", size = 2146303, upload-time = "2025-11-04T13:39:46.238Z" }, + { url = "https://files.pythonhosted.org/packages/58/7f/0de669bf37d206723795f9c90c82966726a2ab06c336deba4735b55af431/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:34a64bc3441dc1213096a20fe27e8e128bd3ff89921706e83c0b1ac971276594", size = 2340355, upload-time = "2025-11-04T13:39:48.002Z" }, + { url = "https://files.pythonhosted.org/packages/e5/de/e7482c435b83d7e3c3ee5ee4451f6e8973cff0eb6007d2872ce6383f6398/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:c9e19dd6e28fdcaa5a1de679aec4141f691023916427ef9bae8584f9c2fb3b0e", size = 2319875, upload-time = "2025-11-04T13:39:49.705Z" }, + { url = "https://files.pythonhosted.org/packages/fe/e6/8c9e81bb6dd7560e33b9053351c29f30c8194b72f2d6932888581f503482/pydantic_core-2.41.5-cp311-cp311-win32.whl", hash = "sha256:2c010c6ded393148374c0f6f0bf89d206bf3217f201faa0635dcd56bd1520f6b", size = 1987549, upload-time = "2025-11-04T13:39:51.842Z" }, + { url = "https://files.pythonhosted.org/packages/11/66/f14d1d978ea94d1bc21fc98fcf570f9542fe55bfcc40269d4e1a21c19bf7/pydantic_core-2.41.5-cp311-cp311-win_amd64.whl", hash = "sha256:76ee27c6e9c7f16f47db7a94157112a2f3a00e958bc626e2f4ee8bec5c328fbe", size = 2011305, upload-time = "2025-11-04T13:39:53.485Z" }, + { url = "https://files.pythonhosted.org/packages/56/d8/0e271434e8efd03186c5386671328154ee349ff0354d83c74f5caaf096ed/pydantic_core-2.41.5-cp311-cp311-win_arm64.whl", hash = "sha256:4bc36bbc0b7584de96561184ad7f012478987882ebf9f9c389b23f432ea3d90f", size = 1972902, upload-time = "2025-11-04T13:39:56.488Z" }, + { url = "https://files.pythonhosted.org/packages/5f/5d/5f6c63eebb5afee93bcaae4ce9a898f3373ca23df3ccaef086d0233a35a7/pydantic_core-2.41.5-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:f41a7489d32336dbf2199c8c0a215390a751c5b014c2c1c5366e817202e9cdf7", size = 2110990, upload-time = "2025-11-04T13:39:58.079Z" }, + { url = "https://files.pythonhosted.org/packages/aa/32/9c2e8ccb57c01111e0fd091f236c7b371c1bccea0fa85247ac55b1e2b6b6/pydantic_core-2.41.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:070259a8818988b9a84a449a2a7337c7f430a22acc0859c6b110aa7212a6d9c0", size = 1896003, upload-time = "2025-11-04T13:39:59.956Z" }, + { url = "https://files.pythonhosted.org/packages/68/b8/a01b53cb0e59139fbc9e4fda3e9724ede8de279097179be4ff31f1abb65a/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e96cea19e34778f8d59fe40775a7a574d95816eb150850a85a7a4c8f4b94ac69", size = 1919200, upload-time = "2025-11-04T13:40:02.241Z" }, + { url = "https://files.pythonhosted.org/packages/38/de/8c36b5198a29bdaade07b5985e80a233a5ac27137846f3bc2d3b40a47360/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ed2e99c456e3fadd05c991f8f437ef902e00eedf34320ba2b0842bd1c3ca3a75", size = 2052578, upload-time = "2025-11-04T13:40:04.401Z" }, + { url = "https://files.pythonhosted.org/packages/00/b5/0e8e4b5b081eac6cb3dbb7e60a65907549a1ce035a724368c330112adfdd/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:65840751b72fbfd82c3c640cff9284545342a4f1eb1586ad0636955b261b0b05", size = 2208504, upload-time = "2025-11-04T13:40:06.072Z" }, + { url = "https://files.pythonhosted.org/packages/77/56/87a61aad59c7c5b9dc8caad5a41a5545cba3810c3e828708b3d7404f6cef/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e536c98a7626a98feb2d3eaf75944ef6f3dbee447e1f841eae16f2f0a72d8ddc", size = 2335816, upload-time = "2025-11-04T13:40:07.835Z" }, + { url = "https://files.pythonhosted.org/packages/0d/76/941cc9f73529988688a665a5c0ecff1112b3d95ab48f81db5f7606f522d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eceb81a8d74f9267ef4081e246ffd6d129da5d87e37a77c9bde550cb04870c1c", size = 2075366, upload-time = "2025-11-04T13:40:09.804Z" }, + { url = "https://files.pythonhosted.org/packages/d3/43/ebef01f69baa07a482844faaa0a591bad1ef129253ffd0cdaa9d8a7f72d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d38548150c39b74aeeb0ce8ee1d8e82696f4a4e16ddc6de7b1d8823f7de4b9b5", size = 2171698, upload-time = "2025-11-04T13:40:12.004Z" }, + { url = "https://files.pythonhosted.org/packages/b1/87/41f3202e4193e3bacfc2c065fab7706ebe81af46a83d3e27605029c1f5a6/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:c23e27686783f60290e36827f9c626e63154b82b116d7fe9adba1fda36da706c", size = 2132603, upload-time = "2025-11-04T13:40:13.868Z" }, + { url = "https://files.pythonhosted.org/packages/49/7d/4c00df99cb12070b6bccdef4a195255e6020a550d572768d92cc54dba91a/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:482c982f814460eabe1d3bb0adfdc583387bd4691ef00b90575ca0d2b6fe2294", size = 2329591, upload-time = "2025-11-04T13:40:15.672Z" }, + { url = "https://files.pythonhosted.org/packages/cc/6a/ebf4b1d65d458f3cda6a7335d141305dfa19bdc61140a884d165a8a1bbc7/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:bfea2a5f0b4d8d43adf9d7b8bf019fb46fdd10a2e5cde477fbcb9d1fa08c68e1", size = 2319068, upload-time = "2025-11-04T13:40:17.532Z" }, + { url = "https://files.pythonhosted.org/packages/49/3b/774f2b5cd4192d5ab75870ce4381fd89cf218af999515baf07e7206753f0/pydantic_core-2.41.5-cp312-cp312-win32.whl", hash = "sha256:b74557b16e390ec12dca509bce9264c3bbd128f8a2c376eaa68003d7f327276d", size = 1985908, upload-time = "2025-11-04T13:40:19.309Z" }, + { url = "https://files.pythonhosted.org/packages/86/45/00173a033c801cacf67c190fef088789394feaf88a98a7035b0e40d53dc9/pydantic_core-2.41.5-cp312-cp312-win_amd64.whl", hash = "sha256:1962293292865bca8e54702b08a4f26da73adc83dd1fcf26fbc875b35d81c815", size = 2020145, upload-time = "2025-11-04T13:40:21.548Z" }, + { url = "https://files.pythonhosted.org/packages/f9/22/91fbc821fa6d261b376a3f73809f907cec5ca6025642c463d3488aad22fb/pydantic_core-2.41.5-cp312-cp312-win_arm64.whl", hash = "sha256:1746d4a3d9a794cacae06a5eaaccb4b8643a131d45fbc9af23e353dc0a5ba5c3", size = 1976179, upload-time = "2025-11-04T13:40:23.393Z" }, + { url = "https://files.pythonhosted.org/packages/87/06/8806241ff1f70d9939f9af039c6c35f2360cf16e93c2ca76f184e76b1564/pydantic_core-2.41.5-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:941103c9be18ac8daf7b7adca8228f8ed6bb7a1849020f643b3a14d15b1924d9", size = 2120403, upload-time = "2025-11-04T13:40:25.248Z" }, + { url = "https://files.pythonhosted.org/packages/94/02/abfa0e0bda67faa65fef1c84971c7e45928e108fe24333c81f3bfe35d5f5/pydantic_core-2.41.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:112e305c3314f40c93998e567879e887a3160bb8689ef3d2c04b6cc62c33ac34", size = 1896206, upload-time = "2025-11-04T13:40:27.099Z" }, + { url = "https://files.pythonhosted.org/packages/15/df/a4c740c0943e93e6500f9eb23f4ca7ec9bf71b19e608ae5b579678c8d02f/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0cbaad15cb0c90aa221d43c00e77bb33c93e8d36e0bf74760cd00e732d10a6a0", size = 1919307, upload-time = "2025-11-04T13:40:29.806Z" }, + { url = "https://files.pythonhosted.org/packages/9a/e3/6324802931ae1d123528988e0e86587c2072ac2e5394b4bc2bc34b61ff6e/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:03ca43e12fab6023fc79d28ca6b39b05f794ad08ec2feccc59a339b02f2b3d33", size = 2063258, upload-time = "2025-11-04T13:40:33.544Z" }, + { url = "https://files.pythonhosted.org/packages/c9/d4/2230d7151d4957dd79c3044ea26346c148c98fbf0ee6ebd41056f2d62ab5/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dc799088c08fa04e43144b164feb0c13f9a0bc40503f8df3e9fde58a3c0c101e", size = 2214917, upload-time = "2025-11-04T13:40:35.479Z" }, + { url = "https://files.pythonhosted.org/packages/e6/9f/eaac5df17a3672fef0081b6c1bb0b82b33ee89aa5cec0d7b05f52fd4a1fa/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:97aeba56665b4c3235a0e52b2c2f5ae9cd071b8a8310ad27bddb3f7fb30e9aa2", size = 2332186, upload-time = "2025-11-04T13:40:37.436Z" }, + { url = "https://files.pythonhosted.org/packages/cf/4e/35a80cae583a37cf15604b44240e45c05e04e86f9cfd766623149297e971/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:406bf18d345822d6c21366031003612b9c77b3e29ffdb0f612367352aab7d586", size = 2073164, upload-time = "2025-11-04T13:40:40.289Z" }, + { url = "https://files.pythonhosted.org/packages/bf/e3/f6e262673c6140dd3305d144d032f7bd5f7497d3871c1428521f19f9efa2/pydantic_core-2.41.5-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b93590ae81f7010dbe380cdeab6f515902ebcbefe0b9327cc4804d74e93ae69d", size = 2179146, upload-time = "2025-11-04T13:40:42.809Z" }, + { url = "https://files.pythonhosted.org/packages/75/c7/20bd7fc05f0c6ea2056a4565c6f36f8968c0924f19b7d97bbfea55780e73/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:01a3d0ab748ee531f4ea6c3e48ad9dac84ddba4b0d82291f87248f2f9de8d740", size = 2137788, upload-time = "2025-11-04T13:40:44.752Z" }, + { url = "https://files.pythonhosted.org/packages/3a/8d/34318ef985c45196e004bc46c6eab2eda437e744c124ef0dbe1ff2c9d06b/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:6561e94ba9dacc9c61bce40e2d6bdc3bfaa0259d3ff36ace3b1e6901936d2e3e", size = 2340133, upload-time = "2025-11-04T13:40:46.66Z" }, + { url = "https://files.pythonhosted.org/packages/9c/59/013626bf8c78a5a5d9350d12e7697d3d4de951a75565496abd40ccd46bee/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:915c3d10f81bec3a74fbd4faebe8391013ba61e5a1a8d48c4455b923bdda7858", size = 2324852, upload-time = "2025-11-04T13:40:48.575Z" }, + { url = "https://files.pythonhosted.org/packages/1a/d9/c248c103856f807ef70c18a4f986693a46a8ffe1602e5d361485da502d20/pydantic_core-2.41.5-cp313-cp313-win32.whl", hash = "sha256:650ae77860b45cfa6e2cdafc42618ceafab3a2d9a3811fcfbd3bbf8ac3c40d36", size = 1994679, upload-time = "2025-11-04T13:40:50.619Z" }, + { url = "https://files.pythonhosted.org/packages/9e/8b/341991b158ddab181cff136acd2552c9f35bd30380422a639c0671e99a91/pydantic_core-2.41.5-cp313-cp313-win_amd64.whl", hash = "sha256:79ec52ec461e99e13791ec6508c722742ad745571f234ea6255bed38c6480f11", size = 2019766, upload-time = "2025-11-04T13:40:52.631Z" }, + { url = "https://files.pythonhosted.org/packages/73/7d/f2f9db34af103bea3e09735bb40b021788a5e834c81eedb541991badf8f5/pydantic_core-2.41.5-cp313-cp313-win_arm64.whl", hash = "sha256:3f84d5c1b4ab906093bdc1ff10484838aca54ef08de4afa9de0f5f14d69639cd", size = 1981005, upload-time = "2025-11-04T13:40:54.734Z" }, + { url = "https://files.pythonhosted.org/packages/ea/28/46b7c5c9635ae96ea0fbb779e271a38129df2550f763937659ee6c5dbc65/pydantic_core-2.41.5-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:3f37a19d7ebcdd20b96485056ba9e8b304e27d9904d233d7b1015db320e51f0a", size = 2119622, upload-time = "2025-11-04T13:40:56.68Z" }, + { url = "https://files.pythonhosted.org/packages/74/1a/145646e5687e8d9a1e8d09acb278c8535ebe9e972e1f162ed338a622f193/pydantic_core-2.41.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1d1d9764366c73f996edd17abb6d9d7649a7eb690006ab6adbda117717099b14", size = 1891725, upload-time = "2025-11-04T13:40:58.807Z" }, + { url = "https://files.pythonhosted.org/packages/23/04/e89c29e267b8060b40dca97bfc64a19b2a3cf99018167ea1677d96368273/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:25e1c2af0fce638d5f1988b686f3b3ea8cd7de5f244ca147c777769e798a9cd1", size = 1915040, upload-time = "2025-11-04T13:41:00.853Z" }, + { url = "https://files.pythonhosted.org/packages/84/a3/15a82ac7bd97992a82257f777b3583d3e84bdb06ba6858f745daa2ec8a85/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:506d766a8727beef16b7adaeb8ee6217c64fc813646b424d0804d67c16eddb66", size = 2063691, upload-time = "2025-11-04T13:41:03.504Z" }, + { url = "https://files.pythonhosted.org/packages/74/9b/0046701313c6ef08c0c1cf0e028c67c770a4e1275ca73131563c5f2a310a/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4819fa52133c9aa3c387b3328f25c1facc356491e6135b459f1de698ff64d869", size = 2213897, upload-time = "2025-11-04T13:41:05.804Z" }, + { url = "https://files.pythonhosted.org/packages/8a/cd/6bac76ecd1b27e75a95ca3a9a559c643b3afcd2dd62086d4b7a32a18b169/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2b761d210c9ea91feda40d25b4efe82a1707da2ef62901466a42492c028553a2", size = 2333302, upload-time = "2025-11-04T13:41:07.809Z" }, + { url = "https://files.pythonhosted.org/packages/4c/d2/ef2074dc020dd6e109611a8be4449b98cd25e1b9b8a303c2f0fca2f2bcf7/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:22f0fb8c1c583a3b6f24df2470833b40207e907b90c928cc8d3594b76f874375", size = 2064877, upload-time = "2025-11-04T13:41:09.827Z" }, + { url = "https://files.pythonhosted.org/packages/18/66/e9db17a9a763d72f03de903883c057b2592c09509ccfe468187f2a2eef29/pydantic_core-2.41.5-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2782c870e99878c634505236d81e5443092fba820f0373997ff75f90f68cd553", size = 2180680, upload-time = "2025-11-04T13:41:12.379Z" }, + { url = "https://files.pythonhosted.org/packages/d3/9e/3ce66cebb929f3ced22be85d4c2399b8e85b622db77dad36b73c5387f8f8/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:0177272f88ab8312479336e1d777f6b124537d47f2123f89cb37e0accea97f90", size = 2138960, upload-time = "2025-11-04T13:41:14.627Z" }, + { url = "https://files.pythonhosted.org/packages/a6/62/205a998f4327d2079326b01abee48e502ea739d174f0a89295c481a2272e/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:63510af5e38f8955b8ee5687740d6ebf7c2a0886d15a6d65c32814613681bc07", size = 2339102, upload-time = "2025-11-04T13:41:16.868Z" }, + { url = "https://files.pythonhosted.org/packages/3c/0d/f05e79471e889d74d3d88f5bd20d0ed189ad94c2423d81ff8d0000aab4ff/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:e56ba91f47764cc14f1daacd723e3e82d1a89d783f0f5afe9c364b8bb491ccdb", size = 2326039, upload-time = "2025-11-04T13:41:18.934Z" }, + { url = "https://files.pythonhosted.org/packages/ec/e1/e08a6208bb100da7e0c4b288eed624a703f4d129bde2da475721a80cab32/pydantic_core-2.41.5-cp314-cp314-win32.whl", hash = "sha256:aec5cf2fd867b4ff45b9959f8b20ea3993fc93e63c7363fe6851424c8a7e7c23", size = 1995126, upload-time = "2025-11-04T13:41:21.418Z" }, + { url = "https://files.pythonhosted.org/packages/48/5d/56ba7b24e9557f99c9237e29f5c09913c81eeb2f3217e40e922353668092/pydantic_core-2.41.5-cp314-cp314-win_amd64.whl", hash = "sha256:8e7c86f27c585ef37c35e56a96363ab8de4e549a95512445b85c96d3e2f7c1bf", size = 2015489, upload-time = "2025-11-04T13:41:24.076Z" }, + { url = "https://files.pythonhosted.org/packages/4e/bb/f7a190991ec9e3e0ba22e4993d8755bbc4a32925c0b5b42775c03e8148f9/pydantic_core-2.41.5-cp314-cp314-win_arm64.whl", hash = "sha256:e672ba74fbc2dc8eea59fb6d4aed6845e6905fc2a8afe93175d94a83ba2a01a0", size = 1977288, upload-time = "2025-11-04T13:41:26.33Z" }, + { url = "https://files.pythonhosted.org/packages/92/ed/77542d0c51538e32e15afe7899d79efce4b81eee631d99850edc2f5e9349/pydantic_core-2.41.5-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:8566def80554c3faa0e65ac30ab0932b9e3a5cd7f8323764303d468e5c37595a", size = 2120255, upload-time = "2025-11-04T13:41:28.569Z" }, + { url = "https://files.pythonhosted.org/packages/bb/3d/6913dde84d5be21e284439676168b28d8bbba5600d838b9dca99de0fad71/pydantic_core-2.41.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b80aa5095cd3109962a298ce14110ae16b8c1aece8b72f9dafe81cf597ad80b3", size = 1863760, upload-time = "2025-11-04T13:41:31.055Z" }, + { url = "https://files.pythonhosted.org/packages/5a/f0/e5e6b99d4191da102f2b0eb9687aaa7f5bea5d9964071a84effc3e40f997/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3006c3dd9ba34b0c094c544c6006cc79e87d8612999f1a5d43b769b89181f23c", size = 1878092, upload-time = "2025-11-04T13:41:33.21Z" }, + { url = "https://files.pythonhosted.org/packages/71/48/36fb760642d568925953bcc8116455513d6e34c4beaa37544118c36aba6d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:72f6c8b11857a856bcfa48c86f5368439f74453563f951e473514579d44aa612", size = 2053385, upload-time = "2025-11-04T13:41:35.508Z" }, + { url = "https://files.pythonhosted.org/packages/20/25/92dc684dd8eb75a234bc1c764b4210cf2646479d54b47bf46061657292a8/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5cb1b2f9742240e4bb26b652a5aeb840aa4b417c7748b6f8387927bc6e45e40d", size = 2218832, upload-time = "2025-11-04T13:41:37.732Z" }, + { url = "https://files.pythonhosted.org/packages/e2/09/f53e0b05023d3e30357d82eb35835d0f6340ca344720a4599cd663dca599/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bd3d54f38609ff308209bd43acea66061494157703364ae40c951f83ba99a1a9", size = 2327585, upload-time = "2025-11-04T13:41:40Z" }, + { url = "https://files.pythonhosted.org/packages/aa/4e/2ae1aa85d6af35a39b236b1b1641de73f5a6ac4d5a7509f77b814885760c/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2ff4321e56e879ee8d2a879501c8e469414d948f4aba74a2d4593184eb326660", size = 2041078, upload-time = "2025-11-04T13:41:42.323Z" }, + { url = "https://files.pythonhosted.org/packages/cd/13/2e215f17f0ef326fc72afe94776edb77525142c693767fc347ed6288728d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d0d2568a8c11bf8225044aa94409e21da0cb09dcdafe9ecd10250b2baad531a9", size = 2173914, upload-time = "2025-11-04T13:41:45.221Z" }, + { url = "https://files.pythonhosted.org/packages/02/7a/f999a6dcbcd0e5660bc348a3991c8915ce6599f4f2c6ac22f01d7a10816c/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:a39455728aabd58ceabb03c90e12f71fd30fa69615760a075b9fec596456ccc3", size = 2129560, upload-time = "2025-11-04T13:41:47.474Z" }, + { url = "https://files.pythonhosted.org/packages/3a/b1/6c990ac65e3b4c079a4fb9f5b05f5b013afa0f4ed6780a3dd236d2cbdc64/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:239edca560d05757817c13dc17c50766136d21f7cd0fac50295499ae24f90fdf", size = 2329244, upload-time = "2025-11-04T13:41:49.992Z" }, + { url = "https://files.pythonhosted.org/packages/d9/02/3c562f3a51afd4d88fff8dffb1771b30cfdfd79befd9883ee094f5b6c0d8/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:2a5e06546e19f24c6a96a129142a75cee553cc018ffee48a460059b1185f4470", size = 2331955, upload-time = "2025-11-04T13:41:54.079Z" }, + { url = "https://files.pythonhosted.org/packages/5c/96/5fb7d8c3c17bc8c62fdb031c47d77a1af698f1d7a406b0f79aaa1338f9ad/pydantic_core-2.41.5-cp314-cp314t-win32.whl", hash = "sha256:b4ececa40ac28afa90871c2cc2b9ffd2ff0bf749380fbdf57d165fd23da353aa", size = 1988906, upload-time = "2025-11-04T13:41:56.606Z" }, + { url = "https://files.pythonhosted.org/packages/22/ed/182129d83032702912c2e2d8bbe33c036f342cc735737064668585dac28f/pydantic_core-2.41.5-cp314-cp314t-win_amd64.whl", hash = "sha256:80aa89cad80b32a912a65332f64a4450ed00966111b6615ca6816153d3585a8c", size = 1981607, upload-time = "2025-11-04T13:41:58.889Z" }, + { url = "https://files.pythonhosted.org/packages/9f/ed/068e41660b832bb0b1aa5b58011dea2a3fe0ba7861ff38c4d4904c1c1a99/pydantic_core-2.41.5-cp314-cp314t-win_arm64.whl", hash = "sha256:35b44f37a3199f771c3eaa53051bc8a70cd7b54f333531c59e29fd4db5d15008", size = 1974769, upload-time = "2025-11-04T13:42:01.186Z" }, + { url = "https://files.pythonhosted.org/packages/11/72/90fda5ee3b97e51c494938a4a44c3a35a9c96c19bba12372fb9c634d6f57/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-macosx_10_12_x86_64.whl", hash = "sha256:b96d5f26b05d03cc60f11a7761a5ded1741da411e7fe0909e27a5e6a0cb7b034", size = 2115441, upload-time = "2025-11-04T13:42:39.557Z" }, + { url = "https://files.pythonhosted.org/packages/1f/53/8942f884fa33f50794f119012dc6a1a02ac43a56407adaac20463df8e98f/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-macosx_11_0_arm64.whl", hash = "sha256:634e8609e89ceecea15e2d61bc9ac3718caaaa71963717bf3c8f38bfde64242c", size = 1930291, upload-time = "2025-11-04T13:42:42.169Z" }, + { url = "https://files.pythonhosted.org/packages/79/c8/ecb9ed9cd942bce09fc888ee960b52654fbdbede4ba6c2d6e0d3b1d8b49c/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:93e8740d7503eb008aa2df04d3b9735f845d43ae845e6dcd2be0b55a2da43cd2", size = 1948632, upload-time = "2025-11-04T13:42:44.564Z" }, + { url = "https://files.pythonhosted.org/packages/2e/1b/687711069de7efa6af934e74f601e2a4307365e8fdc404703afc453eab26/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f15489ba13d61f670dcc96772e733aad1a6f9c429cc27574c6cdaed82d0146ad", size = 2138905, upload-time = "2025-11-04T13:42:47.156Z" }, + { url = "https://files.pythonhosted.org/packages/09/32/59b0c7e63e277fa7911c2fc70ccfb45ce4b98991e7ef37110663437005af/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:7da7087d756b19037bc2c06edc6c170eeef3c3bafcb8f532ff17d64dc427adfd", size = 2110495, upload-time = "2025-11-04T13:42:49.689Z" }, + { url = "https://files.pythonhosted.org/packages/aa/81/05e400037eaf55ad400bcd318c05bb345b57e708887f07ddb2d20e3f0e98/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:aabf5777b5c8ca26f7824cb4a120a740c9588ed58df9b2d196ce92fba42ff8dc", size = 1915388, upload-time = "2025-11-04T13:42:52.215Z" }, + { url = "https://files.pythonhosted.org/packages/6e/0d/e3549b2399f71d56476b77dbf3cf8937cec5cd70536bdc0e374a421d0599/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c007fe8a43d43b3969e8469004e9845944f1a80e6acd47c150856bb87f230c56", size = 1942879, upload-time = "2025-11-04T13:42:56.483Z" }, + { url = "https://files.pythonhosted.org/packages/f7/07/34573da085946b6a313d7c42f82f16e8920bfd730665de2d11c0c37a74b5/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:76d0819de158cd855d1cbb8fcafdf6f5cf1eb8e470abe056d5d161106e38062b", size = 2139017, upload-time = "2025-11-04T13:42:59.471Z" }, + { url = "https://files.pythonhosted.org/packages/e6/b0/1a2aa41e3b5a4ba11420aba2d091b2d17959c8d1519ece3627c371951e73/pydantic_core-2.41.5-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:b5819cd790dbf0c5eb9f82c73c16b39a65dd6dd4d1439dcdea7816ec9adddab8", size = 2103351, upload-time = "2025-11-04T13:43:02.058Z" }, + { url = "https://files.pythonhosted.org/packages/a4/ee/31b1f0020baaf6d091c87900ae05c6aeae101fa4e188e1613c80e4f1ea31/pydantic_core-2.41.5-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:5a4e67afbc95fa5c34cf27d9089bca7fcab4e51e57278d710320a70b956d1b9a", size = 1925363, upload-time = "2025-11-04T13:43:05.159Z" }, + { url = "https://files.pythonhosted.org/packages/e1/89/ab8e86208467e467a80deaca4e434adac37b10a9d134cd2f99b28a01e483/pydantic_core-2.41.5-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ece5c59f0ce7d001e017643d8d24da587ea1f74f6993467d85ae8a5ef9d4f42b", size = 2135615, upload-time = "2025-11-04T13:43:08.116Z" }, + { url = "https://files.pythonhosted.org/packages/99/0a/99a53d06dd0348b2008f2f30884b34719c323f16c3be4e6cc1203b74a91d/pydantic_core-2.41.5-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:16f80f7abe3351f8ea6858914ddc8c77e02578544a0ebc15b4c2e1a0e813b0b2", size = 2175369, upload-time = "2025-11-04T13:43:12.49Z" }, + { url = "https://files.pythonhosted.org/packages/6d/94/30ca3b73c6d485b9bb0bc66e611cff4a7138ff9736b7e66bcf0852151636/pydantic_core-2.41.5-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:33cb885e759a705b426baada1fe68cbb0a2e68e34c5d0d0289a364cf01709093", size = 2144218, upload-time = "2025-11-04T13:43:15.431Z" }, + { url = "https://files.pythonhosted.org/packages/87/57/31b4f8e12680b739a91f472b5671294236b82586889ef764b5fbc6669238/pydantic_core-2.41.5-pp310-pypy310_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:c8d8b4eb992936023be7dee581270af5c6e0697a8559895f527f5b7105ecd36a", size = 2329951, upload-time = "2025-11-04T13:43:18.062Z" }, + { url = "https://files.pythonhosted.org/packages/7d/73/3c2c8edef77b8f7310e6fb012dbc4b8551386ed575b9eb6fb2506e28a7eb/pydantic_core-2.41.5-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:242a206cd0318f95cd21bdacff3fcc3aab23e79bba5cac3db5a841c9ef9c6963", size = 2318428, upload-time = "2025-11-04T13:43:20.679Z" }, + { url = "https://files.pythonhosted.org/packages/2f/02/8559b1f26ee0d502c74f9cca5c0d2fd97e967e083e006bbbb4e97f3a043a/pydantic_core-2.41.5-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:d3a978c4f57a597908b7e697229d996d77a6d3c94901e9edee593adada95ce1a", size = 2147009, upload-time = "2025-11-04T13:43:23.286Z" }, + { url = "https://files.pythonhosted.org/packages/5f/9b/1b3f0e9f9305839d7e84912f9e8bfbd191ed1b1ef48083609f0dabde978c/pydantic_core-2.41.5-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:b2379fa7ed44ddecb5bfe4e48577d752db9fc10be00a6b7446e9663ba143de26", size = 2101980, upload-time = "2025-11-04T13:43:25.97Z" }, + { url = "https://files.pythonhosted.org/packages/a4/ed/d71fefcb4263df0da6a85b5d8a7508360f2f2e9b3bf5814be9c8bccdccc1/pydantic_core-2.41.5-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:266fb4cbf5e3cbd0b53669a6d1b039c45e3ce651fd5442eff4d07c2cc8d66808", size = 1923865, upload-time = "2025-11-04T13:43:28.763Z" }, + { url = "https://files.pythonhosted.org/packages/ce/3a/626b38db460d675f873e4444b4bb030453bbe7b4ba55df821d026a0493c4/pydantic_core-2.41.5-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58133647260ea01e4d0500089a8c4f07bd7aa6ce109682b1426394988d8aaacc", size = 2134256, upload-time = "2025-11-04T13:43:31.71Z" }, + { url = "https://files.pythonhosted.org/packages/83/d9/8412d7f06f616bbc053d30cb4e5f76786af3221462ad5eee1f202021eb4e/pydantic_core-2.41.5-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:287dad91cfb551c363dc62899a80e9e14da1f0e2b6ebde82c806612ca2a13ef1", size = 2174762, upload-time = "2025-11-04T13:43:34.744Z" }, + { url = "https://files.pythonhosted.org/packages/55/4c/162d906b8e3ba3a99354e20faa1b49a85206c47de97a639510a0e673f5da/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:03b77d184b9eb40240ae9fd676ca364ce1085f203e1b1256f8ab9984dca80a84", size = 2143141, upload-time = "2025-11-04T13:43:37.701Z" }, + { url = "https://files.pythonhosted.org/packages/1f/f2/f11dd73284122713f5f89fc940f370d035fa8e1e078d446b3313955157fe/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:a668ce24de96165bb239160b3d854943128f4334822900534f2fe947930e5770", size = 2330317, upload-time = "2025-11-04T13:43:40.406Z" }, + { url = "https://files.pythonhosted.org/packages/88/9d/b06ca6acfe4abb296110fb1273a4d848a0bfb2ff65f3ee92127b3244e16b/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:f14f8f046c14563f8eb3f45f499cc658ab8d10072961e07225e507adb700e93f", size = 2316992, upload-time = "2025-11-04T13:43:43.602Z" }, + { url = "https://files.pythonhosted.org/packages/36/c7/cfc8e811f061c841d7990b0201912c3556bfeb99cdcb7ed24adc8d6f8704/pydantic_core-2.41.5-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:56121965f7a4dc965bff783d70b907ddf3d57f6eba29b6d2e5dabfaf07799c51", size = 2145302, upload-time = "2025-11-04T13:43:46.64Z" }, +] + +[[package]] +name = "pydata-sphinx-theme" +version = "0.16.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "accessible-pygments" }, + { name = "babel" }, + { name = "beautifulsoup4" }, + { name = "docutils" }, + { name = "pygments" }, + { name = "sphinx", version = "8.1.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "sphinx", version = "8.2.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/00/20/bb50f9de3a6de69e6abd6b087b52fa2418a0418b19597601605f855ad044/pydata_sphinx_theme-0.16.1.tar.gz", hash = "sha256:a08b7f0b7f70387219dc659bff0893a7554d5eb39b59d3b8ef37b8401b7642d7", size = 2412693, upload-time = "2024-12-17T10:53:39.537Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e2/0d/8ba33fa83a7dcde13eb3c1c2a0c1cc29950a048bfed6d9b0d8b6bd710b4c/pydata_sphinx_theme-0.16.1-py3-none-any.whl", hash = "sha256:225331e8ac4b32682c18fcac5a57a6f717c4e632cea5dd0e247b55155faeccde", size = 6723264, upload-time = "2024-12-17T10:53:35.645Z" }, +] + +[[package]] +name = "pygments" +version = "2.19.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631, upload-time = "2025-06-21T13:39:12.283Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload-time = "2025-06-21T13:39:07.939Z" }, +] + +[[package]] +name = "pynacl" +version = "1.6.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi", marker = "platform_python_implementation != 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b2/46/aeca065d227e2265125aea590c9c47fbf5786128c9400ee0eb7c88931f06/pynacl-1.6.1.tar.gz", hash = "sha256:8d361dac0309f2b6ad33b349a56cd163c98430d409fa503b10b70b3ad66eaa1d", size = 3506616, upload-time = "2025-11-10T16:02:13.195Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/75/d6/4b2dca33ed512de8f54e5c6074aa06eaeb225bfbcd9b16f33a414389d6bd/pynacl-1.6.1-cp314-cp314t-macosx_10_10_universal2.whl", hash = "sha256:7d7c09749450c385301a3c20dca967a525152ae4608c0a096fe8464bfc3df93d", size = 389109, upload-time = "2025-11-10T16:01:28.79Z" }, + { url = "https://files.pythonhosted.org/packages/3c/30/e8dbb8ff4fa2559bbbb2187ba0d0d7faf728d17cb8396ecf4a898b22d3da/pynacl-1.6.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:fc734c1696ffd49b40f7c1779c89ba908157c57345cf626be2e0719488a076d3", size = 808254, upload-time = "2025-11-10T16:01:37.839Z" }, + { url = "https://files.pythonhosted.org/packages/44/f9/f5449c652f31da00249638dbab065ad4969c635119094b79b17c3a4da2ab/pynacl-1.6.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3cd787ec1f5c155dc8ecf39b1333cfef41415dc96d392f1ce288b4fe970df489", size = 1407365, upload-time = "2025-11-10T16:01:40.454Z" }, + { url = "https://files.pythonhosted.org/packages/eb/2f/9aa5605f473b712065c0a193ebf4ad4725d7a245533f0cd7e5dcdbc78f35/pynacl-1.6.1-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b35d93ab2df03ecb3aa506be0d3c73609a51449ae0855c2e89c7ed44abde40b", size = 843842, upload-time = "2025-11-10T16:01:30.524Z" }, + { url = "https://files.pythonhosted.org/packages/32/8d/748f0f6956e207453da8f5f21a70885fbbb2e060d5c9d78e0a4a06781451/pynacl-1.6.1-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dece79aecbb8f4640a1adbb81e4aa3bfb0e98e99834884a80eb3f33c7c30e708", size = 1445559, upload-time = "2025-11-10T16:01:33.663Z" }, + { url = "https://files.pythonhosted.org/packages/78/d0/2387f0dcb0e9816f38373999e48db4728ed724d31accdd4e737473319d35/pynacl-1.6.1-cp314-cp314t-manylinux_2_34_aarch64.whl", hash = "sha256:c2228054f04bf32d558fb89bb99f163a8197d5a9bf4efa13069a7fa8d4b93fc3", size = 825791, upload-time = "2025-11-10T16:01:34.823Z" }, + { url = "https://files.pythonhosted.org/packages/18/3d/ef6fb7eb072aaf15f280bc66f26ab97e7fc9efa50fb1927683013ef47473/pynacl-1.6.1-cp314-cp314t-manylinux_2_34_x86_64.whl", hash = "sha256:2b12f1b97346f177affcdfdc78875ff42637cb40dcf79484a97dae3448083a78", size = 1410843, upload-time = "2025-11-10T16:01:36.401Z" }, + { url = "https://files.pythonhosted.org/packages/e3/fb/23824a017526850ee7d8a1cc4cd1e3e5082800522c10832edbbca8619537/pynacl-1.6.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e735c3a1bdfde3834503baf1a6d74d4a143920281cb724ba29fb84c9f49b9c48", size = 801140, upload-time = "2025-11-10T16:01:42.013Z" }, + { url = "https://files.pythonhosted.org/packages/5d/d1/ebc6b182cb98603a35635b727d62f094bc201bf610f97a3bb6357fe688d2/pynacl-1.6.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:3384a454adf5d716a9fadcb5eb2e3e72cd49302d1374a60edc531c9957a9b014", size = 1371966, upload-time = "2025-11-10T16:01:43.297Z" }, + { url = "https://files.pythonhosted.org/packages/64/f4/c9d7b6f02924b1f31db546c7bd2a83a2421c6b4a8e6a2e53425c9f2802e0/pynacl-1.6.1-cp314-cp314t-win32.whl", hash = "sha256:d8615ee34d01c8e0ab3f302dcdd7b32e2bcf698ba5f4809e7cc407c8cdea7717", size = 230482, upload-time = "2025-11-10T16:01:47.688Z" }, + { url = "https://files.pythonhosted.org/packages/c4/2c/942477957fba22da7bf99131850e5ebdff66623418ab48964e78a7a8293e/pynacl-1.6.1-cp314-cp314t-win_amd64.whl", hash = "sha256:5f5b35c1a266f8a9ad22525049280a600b19edd1f785bccd01ae838437dcf935", size = 243232, upload-time = "2025-11-10T16:01:45.208Z" }, + { url = "https://files.pythonhosted.org/packages/7a/0c/bdbc0d04a53b96a765ab03aa2cf9a76ad8653d70bf1665459b9a0dedaa1c/pynacl-1.6.1-cp314-cp314t-win_arm64.whl", hash = "sha256:d984c91fe3494793b2a1fb1e91429539c6c28e9ec8209d26d25041ec599ccf63", size = 187907, upload-time = "2025-11-10T16:01:46.328Z" }, + { url = "https://files.pythonhosted.org/packages/49/41/3cfb3b4f3519f6ff62bf71bf1722547644bcfb1b05b8fdbdc300249ba113/pynacl-1.6.1-cp38-abi3-macosx_10_10_universal2.whl", hash = "sha256:a6f9fd6d6639b1e81115c7f8ff16b8dedba1e8098d2756275d63d208b0e32021", size = 387591, upload-time = "2025-11-10T16:01:49.1Z" }, + { url = "https://files.pythonhosted.org/packages/18/21/b8a6563637799f617a3960f659513eccb3fcc655d5fc2be6e9dc6416826f/pynacl-1.6.1-cp38-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:e49a3f3d0da9f79c1bec2aa013261ab9fa651c7da045d376bd306cf7c1792993", size = 798866, upload-time = "2025-11-10T16:01:55.688Z" }, + { url = "https://files.pythonhosted.org/packages/e8/6c/dc38033bc3ea461e05ae8f15a81e0e67ab9a01861d352ae971c99de23e7c/pynacl-1.6.1-cp38-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7713f8977b5d25f54a811ec9efa2738ac592e846dd6e8a4d3f7578346a841078", size = 1398001, upload-time = "2025-11-10T16:01:57.101Z" }, + { url = "https://files.pythonhosted.org/packages/9f/05/3ec0796a9917100a62c5073b20c4bce7bf0fea49e99b7906d1699cc7b61b/pynacl-1.6.1-cp38-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5a3becafc1ee2e5ea7f9abc642f56b82dcf5be69b961e782a96ea52b55d8a9fc", size = 834024, upload-time = "2025-11-10T16:01:50.228Z" }, + { url = "https://files.pythonhosted.org/packages/f0/b7/ae9982be0f344f58d9c64a1c25d1f0125c79201634efe3c87305ac7cb3e3/pynacl-1.6.1-cp38-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4ce50d19f1566c391fedc8dc2f2f5be265ae214112ebe55315e41d1f36a7f0a9", size = 1436766, upload-time = "2025-11-10T16:01:51.886Z" }, + { url = "https://files.pythonhosted.org/packages/b4/51/b2ccbf89cf3025a02e044dd68a365cad593ebf70f532299f2c047d2b7714/pynacl-1.6.1-cp38-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:543f869140f67d42b9b8d47f922552d7a967e6c116aad028c9bfc5f3f3b3a7b7", size = 817275, upload-time = "2025-11-10T16:01:53.351Z" }, + { url = "https://files.pythonhosted.org/packages/a8/6c/dd9ee8214edf63ac563b08a9b30f98d116942b621d39a751ac3256694536/pynacl-1.6.1-cp38-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:a2bb472458c7ca959aeeff8401b8efef329b0fc44a89d3775cffe8fad3398ad8", size = 1401891, upload-time = "2025-11-10T16:01:54.587Z" }, + { url = "https://files.pythonhosted.org/packages/0f/c1/97d3e1c83772d78ee1db3053fd674bc6c524afbace2bfe8d419fd55d7ed1/pynacl-1.6.1-cp38-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:3206fa98737fdc66d59b8782cecc3d37d30aeec4593d1c8c145825a345bba0f0", size = 772291, upload-time = "2025-11-10T16:01:58.111Z" }, + { url = "https://files.pythonhosted.org/packages/4d/ca/691ff2fe12f3bb3e43e8e8df4b806f6384593d427f635104d337b8e00291/pynacl-1.6.1-cp38-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:53543b4f3d8acb344f75fd4d49f75e6572fce139f4bfb4815a9282296ff9f4c0", size = 1370839, upload-time = "2025-11-10T16:01:59.252Z" }, + { url = "https://files.pythonhosted.org/packages/30/27/06fe5389d30391fce006442246062cc35773c84fbcad0209fbbf5e173734/pynacl-1.6.1-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:319de653ef84c4f04e045eb250e6101d23132372b0a61a7acf91bac0fda8e58c", size = 791371, upload-time = "2025-11-10T16:02:01.075Z" }, + { url = "https://files.pythonhosted.org/packages/2c/7a/e2bde8c9d39074a5aa046c7d7953401608d1f16f71e237f4bef3fb9d7e49/pynacl-1.6.1-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:262a8de6bba4aee8a66f5edf62c214b06647461c9b6b641f8cd0cb1e3b3196fe", size = 1363031, upload-time = "2025-11-10T16:02:02.656Z" }, + { url = "https://files.pythonhosted.org/packages/dd/b6/63fd77264dae1087770a1bb414bc604470f58fbc21d83822fc9c76248076/pynacl-1.6.1-cp38-abi3-win32.whl", hash = "sha256:9fd1a4eb03caf8a2fe27b515a998d26923adb9ddb68db78e35ca2875a3830dde", size = 226585, upload-time = "2025-11-10T16:02:07.116Z" }, + { url = "https://files.pythonhosted.org/packages/12/c8/b419180f3fdb72ab4d45e1d88580761c267c7ca6eda9a20dcbcba254efe6/pynacl-1.6.1-cp38-abi3-win_amd64.whl", hash = "sha256:a569a4069a7855f963940040f35e87d8bc084cb2d6347428d5ad20550a0a1a21", size = 238923, upload-time = "2025-11-10T16:02:04.401Z" }, + { url = "https://files.pythonhosted.org/packages/35/76/c34426d532e4dce7ff36e4d92cb20f4cbbd94b619964b93d24e8f5b5510f/pynacl-1.6.1-cp38-abi3-win_arm64.whl", hash = "sha256:5953e8b8cfadb10889a6e7bd0f53041a745d1b3d30111386a1bb37af171e6daf", size = 183970, upload-time = "2025-11-10T16:02:05.786Z" }, +] + +[[package]] +name = "pyre-extensions" +version = "0.0.32" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, + { name = "typing-inspect" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a7/53/5bc2532536e921c48366ad1047c1344ccef6afa5e84053f0f6e20a453767/pyre_extensions-0.0.32.tar.gz", hash = "sha256:5396715f14ea56c4d5fd0a88c57ca7e44faa468f905909edd7de4ad90ed85e55", size = 10852, upload-time = "2024-11-22T19:26:44.152Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a4/7a/9812cb8be9828ab688203c5ac5f743c60652887f0c00995a6f6f19f912bd/pyre_extensions-0.0.32-py3-none-any.whl", hash = "sha256:a63ba6883ab02f4b1a9f372ed4eb4a2f4c6f3d74879aa2725186fdfcfe3e5c68", size = 12766, upload-time = "2024-11-22T19:26:42.465Z" }, +] + +[[package]] +name = "pytest" +version = "9.0.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "exceptiongroup", marker = "python_full_version < '3.11'" }, + { name = "iniconfig" }, + { name = "packaging" }, + { name = "pluggy" }, + { name = "pygments" }, + { name = "tomli", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/d1/db/7ef3487e0fb0049ddb5ce41d3a49c235bf9ad299b6a25d5780a89f19230f/pytest-9.0.2.tar.gz", hash = "sha256:75186651a92bd89611d1d9fc20f0b4345fd827c41ccd5c299a868a05d70edf11", size = 1568901, upload-time = "2025-12-06T21:30:51.014Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3b/ab/b3226f0bd7cdcf710fbede2b3548584366da3b19b5021e74f5bde2a8fa3f/pytest-9.0.2-py3-none-any.whl", hash = "sha256:711ffd45bf766d5264d487b917733b453d917afd2b0ad65223959f59089f875b", size = 374801, upload-time = "2025-12-06T21:30:49.154Z" }, +] + +[[package]] +name = "pytest-cov" +version = "7.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "coverage", extra = ["toml"] }, + { name = "pluggy" }, + { name = "pytest" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/5e/f7/c933acc76f5208b3b00089573cf6a2bc26dc80a8aece8f52bb7d6b1855ca/pytest_cov-7.0.0.tar.gz", hash = "sha256:33c97eda2e049a0c5298e91f519302a1334c26ac65c1a483d6206fd458361af1", size = 54328, upload-time = "2025-09-09T10:57:02.113Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ee/49/1377b49de7d0c1ce41292161ea0f721913fa8722c19fb9c1e3aa0367eecb/pytest_cov-7.0.0-py3-none-any.whl", hash = "sha256:3b8e9558b16cc1479da72058bdecf8073661c7f57f7d3c5f22a1c23507f2d861", size = 22424, upload-time = "2025-09-09T10:57:00.695Z" }, +] + +[[package]] +name = "python-dateutil" +version = "2.9.0.post0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "six" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432, upload-time = "2024-03-01T18:36:20.211Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892, upload-time = "2024-03-01T18:36:18.57Z" }, +] + +[[package]] +name = "python-multipart" +version = "0.0.20" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f3/87/f44d7c9f274c7ee665a29b885ec97089ec5dc034c7f3fafa03da9e39a09e/python_multipart-0.0.20.tar.gz", hash = "sha256:8dd0cab45b8e23064ae09147625994d090fa46f5b0d1e13af944c331a7fa9d13", size = 37158, upload-time = "2024-12-16T19:45:46.972Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/45/58/38b5afbc1a800eeea951b9285d3912613f2603bdf897a4ab0f4bd7f405fc/python_multipart-0.0.20-py3-none-any.whl", hash = "sha256:8a62d3a8335e06589fe01f2a3e178cdcc632f3fbe0d492ad9ee0ec35aab1f104", size = 24546, upload-time = "2024-12-16T19:45:44.423Z" }, +] + +[[package]] +name = "pytz" +version = "2025.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f8/bf/abbd3cdfb8fbc7fb3d4d38d320f2441b1e7cbe29be4f23797b4a2b5d8aac/pytz-2025.2.tar.gz", hash = "sha256:360b9e3dbb49a209c21ad61809c7fb453643e048b38924c765813546746e81c3", size = 320884, upload-time = "2025-03-25T02:25:00.538Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/81/c4/34e93fe5f5429d7570ec1fa436f1986fb1f00c3e0f43a589fe2bbcd22c3f/pytz-2025.2-py2.py3-none-any.whl", hash = "sha256:5ddf76296dd8c44c26eb8f4b6f35488f3ccbf6fbbd7adee0b7262d43f0ec2f00", size = 509225, upload-time = "2025-03-25T02:24:58.468Z" }, +] + +[[package]] +name = "pywin32" +version = "311" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7b/40/44efbb0dfbd33aca6a6483191dae0716070ed99e2ecb0c53683f400a0b4f/pywin32-311-cp310-cp310-win32.whl", hash = "sha256:d03ff496d2a0cd4a5893504789d4a15399133fe82517455e78bad62efbb7f0a3", size = 8760432, upload-time = "2025-07-14T20:13:05.9Z" }, + { url = "https://files.pythonhosted.org/packages/5e/bf/360243b1e953bd254a82f12653974be395ba880e7ec23e3731d9f73921cc/pywin32-311-cp310-cp310-win_amd64.whl", hash = "sha256:797c2772017851984b97180b0bebe4b620bb86328e8a884bb626156295a63b3b", size = 9590103, upload-time = "2025-07-14T20:13:07.698Z" }, + { url = "https://files.pythonhosted.org/packages/57/38/d290720e6f138086fb3d5ffe0b6caa019a791dd57866940c82e4eeaf2012/pywin32-311-cp310-cp310-win_arm64.whl", hash = "sha256:0502d1facf1fed4839a9a51ccbcc63d952cf318f78ffc00a7e78528ac27d7a2b", size = 8778557, upload-time = "2025-07-14T20:13:11.11Z" }, + { url = "https://files.pythonhosted.org/packages/7c/af/449a6a91e5d6db51420875c54f6aff7c97a86a3b13a0b4f1a5c13b988de3/pywin32-311-cp311-cp311-win32.whl", hash = "sha256:184eb5e436dea364dcd3d2316d577d625c0351bf237c4e9a5fabbcfa5a58b151", size = 8697031, upload-time = "2025-07-14T20:13:13.266Z" }, + { url = "https://files.pythonhosted.org/packages/51/8f/9bb81dd5bb77d22243d33c8397f09377056d5c687aa6d4042bea7fbf8364/pywin32-311-cp311-cp311-win_amd64.whl", hash = "sha256:3ce80b34b22b17ccbd937a6e78e7225d80c52f5ab9940fe0506a1a16f3dab503", size = 9508308, upload-time = "2025-07-14T20:13:15.147Z" }, + { url = "https://files.pythonhosted.org/packages/44/7b/9c2ab54f74a138c491aba1b1cd0795ba61f144c711daea84a88b63dc0f6c/pywin32-311-cp311-cp311-win_arm64.whl", hash = "sha256:a733f1388e1a842abb67ffa8e7aad0e70ac519e09b0f6a784e65a136ec7cefd2", size = 8703930, upload-time = "2025-07-14T20:13:16.945Z" }, + { url = "https://files.pythonhosted.org/packages/e7/ab/01ea1943d4eba0f850c3c61e78e8dd59757ff815ff3ccd0a84de5f541f42/pywin32-311-cp312-cp312-win32.whl", hash = "sha256:750ec6e621af2b948540032557b10a2d43b0cee2ae9758c54154d711cc852d31", size = 8706543, upload-time = "2025-07-14T20:13:20.765Z" }, + { url = "https://files.pythonhosted.org/packages/d1/a8/a0e8d07d4d051ec7502cd58b291ec98dcc0c3fff027caad0470b72cfcc2f/pywin32-311-cp312-cp312-win_amd64.whl", hash = "sha256:b8c095edad5c211ff31c05223658e71bf7116daa0ecf3ad85f3201ea3190d067", size = 9495040, upload-time = "2025-07-14T20:13:22.543Z" }, + { url = "https://files.pythonhosted.org/packages/ba/3a/2ae996277b4b50f17d61f0603efd8253cb2d79cc7ae159468007b586396d/pywin32-311-cp312-cp312-win_arm64.whl", hash = "sha256:e286f46a9a39c4a18b319c28f59b61de793654af2f395c102b4f819e584b5852", size = 8710102, upload-time = "2025-07-14T20:13:24.682Z" }, + { url = "https://files.pythonhosted.org/packages/a5/be/3fd5de0979fcb3994bfee0d65ed8ca9506a8a1260651b86174f6a86f52b3/pywin32-311-cp313-cp313-win32.whl", hash = "sha256:f95ba5a847cba10dd8c4d8fefa9f2a6cf283b8b88ed6178fa8a6c1ab16054d0d", size = 8705700, upload-time = "2025-07-14T20:13:26.471Z" }, + { url = "https://files.pythonhosted.org/packages/e3/28/e0a1909523c6890208295a29e05c2adb2126364e289826c0a8bc7297bd5c/pywin32-311-cp313-cp313-win_amd64.whl", hash = "sha256:718a38f7e5b058e76aee1c56ddd06908116d35147e133427e59a3983f703a20d", size = 9494700, upload-time = "2025-07-14T20:13:28.243Z" }, + { url = "https://files.pythonhosted.org/packages/04/bf/90339ac0f55726dce7d794e6d79a18a91265bdf3aa70b6b9ca52f35e022a/pywin32-311-cp313-cp313-win_arm64.whl", hash = "sha256:7b4075d959648406202d92a2310cb990fea19b535c7f4a78d3f5e10b926eeb8a", size = 8709318, upload-time = "2025-07-14T20:13:30.348Z" }, + { url = "https://files.pythonhosted.org/packages/c9/31/097f2e132c4f16d99a22bfb777e0fd88bd8e1c634304e102f313af69ace5/pywin32-311-cp314-cp314-win32.whl", hash = "sha256:b7a2c10b93f8986666d0c803ee19b5990885872a7de910fc460f9b0c2fbf92ee", size = 8840714, upload-time = "2025-07-14T20:13:32.449Z" }, + { url = "https://files.pythonhosted.org/packages/90/4b/07c77d8ba0e01349358082713400435347df8426208171ce297da32c313d/pywin32-311-cp314-cp314-win_amd64.whl", hash = "sha256:3aca44c046bd2ed8c90de9cb8427f581c479e594e99b5c0bb19b29c10fd6cb87", size = 9656800, upload-time = "2025-07-14T20:13:34.312Z" }, + { url = "https://files.pythonhosted.org/packages/c0/d2/21af5c535501a7233e734b8af901574572da66fcc254cb35d0609c9080dd/pywin32-311-cp314-cp314-win_arm64.whl", hash = "sha256:a508e2d9025764a8270f93111a970e1d0fbfc33f4153b388bb649b7eec4f9b42", size = 8932540, upload-time = "2025-07-14T20:13:36.379Z" }, +] + +[[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/f4/a0/39350dd17dd6d6c6507025c0e53aef67a9293a6d37d3511f23ea510d5800/pyyaml-6.0.3-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:214ed4befebe12df36bcc8bc2b64b396ca31be9304b8f59e25c11cf94a4c033b", size = 184227, upload-time = "2025-09-25T21:31:46.04Z" }, + { url = "https://files.pythonhosted.org/packages/05/14/52d505b5c59ce73244f59c7a50ecf47093ce4765f116cdb98286a71eeca2/pyyaml-6.0.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:02ea2dfa234451bbb8772601d7b8e426c2bfa197136796224e50e35a78777956", size = 174019, upload-time = "2025-09-25T21:31:47.706Z" }, + { url = "https://files.pythonhosted.org/packages/43/f7/0e6a5ae5599c838c696adb4e6330a59f463265bfa1e116cfd1fbb0abaaae/pyyaml-6.0.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b30236e45cf30d2b8e7b3e85881719e98507abed1011bf463a8fa23e9c3e98a8", size = 740646, upload-time = "2025-09-25T21:31:49.21Z" }, + { url = "https://files.pythonhosted.org/packages/2f/3a/61b9db1d28f00f8fd0ae760459a5c4bf1b941baf714e207b6eb0657d2578/pyyaml-6.0.3-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:66291b10affd76d76f54fad28e22e51719ef9ba22b29e1d7d03d6777a9174198", size = 840793, upload-time = "2025-09-25T21:31:50.735Z" }, + { url = "https://files.pythonhosted.org/packages/7a/1e/7acc4f0e74c4b3d9531e24739e0ab832a5edf40e64fbae1a9c01941cabd7/pyyaml-6.0.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9c7708761fccb9397fe64bbc0395abcae8c4bf7b0eac081e12b809bf47700d0b", size = 770293, upload-time = "2025-09-25T21:31:51.828Z" }, + { url = "https://files.pythonhosted.org/packages/8b/ef/abd085f06853af0cd59fa5f913d61a8eab65d7639ff2a658d18a25d6a89d/pyyaml-6.0.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:418cf3f2111bc80e0933b2cd8cd04f286338bb88bdc7bc8e6dd775ebde60b5e0", size = 732872, upload-time = "2025-09-25T21:31:53.282Z" }, + { url = "https://files.pythonhosted.org/packages/1f/15/2bc9c8faf6450a8b3c9fc5448ed869c599c0a74ba2669772b1f3a0040180/pyyaml-6.0.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5e0b74767e5f8c593e8c9b5912019159ed0533c70051e9cce3e8b6aa699fcd69", size = 758828, upload-time = "2025-09-25T21:31:54.807Z" }, + { url = "https://files.pythonhosted.org/packages/a3/00/531e92e88c00f4333ce359e50c19b8d1de9fe8d581b1534e35ccfbc5f393/pyyaml-6.0.3-cp310-cp310-win32.whl", hash = "sha256:28c8d926f98f432f88adc23edf2e6d4921ac26fb084b028c733d01868d19007e", size = 142415, upload-time = "2025-09-25T21:31:55.885Z" }, + { url = "https://files.pythonhosted.org/packages/2a/fa/926c003379b19fca39dd4634818b00dec6c62d87faf628d1394e137354d4/pyyaml-6.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:bdb2c67c6c1390b63c6ff89f210c8fd09d9a1217a465701eac7316313c915e4c", size = 158561, upload-time = "2025-09-25T21:31:57.406Z" }, + { url = "https://files.pythonhosted.org/packages/6d/16/a95b6757765b7b031c9374925bb718d55e0a9ba8a1b6a12d25962ea44347/pyyaml-6.0.3-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:44edc647873928551a01e7a563d7452ccdebee747728c1080d881d68af7b997e", size = 185826, upload-time = "2025-09-25T21:31:58.655Z" }, + { url = "https://files.pythonhosted.org/packages/16/19/13de8e4377ed53079ee996e1ab0a9c33ec2faf808a4647b7b4c0d46dd239/pyyaml-6.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:652cb6edd41e718550aad172851962662ff2681490a8a711af6a4d288dd96824", size = 175577, upload-time = "2025-09-25T21:32:00.088Z" }, + { url = "https://files.pythonhosted.org/packages/0c/62/d2eb46264d4b157dae1275b573017abec435397aa59cbcdab6fc978a8af4/pyyaml-6.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:10892704fc220243f5305762e276552a0395f7beb4dbf9b14ec8fd43b57f126c", size = 775556, upload-time = "2025-09-25T21:32:01.31Z" }, + { url = "https://files.pythonhosted.org/packages/10/cb/16c3f2cf3266edd25aaa00d6c4350381c8b012ed6f5276675b9eba8d9ff4/pyyaml-6.0.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:850774a7879607d3a6f50d36d04f00ee69e7fc816450e5f7e58d7f17f1ae5c00", size = 882114, upload-time = "2025-09-25T21:32:03.376Z" }, + { url = "https://files.pythonhosted.org/packages/71/60/917329f640924b18ff085ab889a11c763e0b573da888e8404ff486657602/pyyaml-6.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b8bb0864c5a28024fac8a632c443c87c5aa6f215c0b126c449ae1a150412f31d", size = 806638, upload-time = "2025-09-25T21:32:04.553Z" }, + { url = "https://files.pythonhosted.org/packages/dd/6f/529b0f316a9fd167281a6c3826b5583e6192dba792dd55e3203d3f8e655a/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37d57ad971609cf3c53ba6a7e365e40660e3be0e5175fa9f2365a379d6095a", size = 767463, upload-time = "2025-09-25T21:32:06.152Z" }, + { url = "https://files.pythonhosted.org/packages/f2/6a/b627b4e0c1dd03718543519ffb2f1deea4a1e6d42fbab8021936a4d22589/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:37503bfbfc9d2c40b344d06b2199cf0e96e97957ab1c1b546fd4f87e53e5d3e4", size = 794986, upload-time = "2025-09-25T21:32:07.367Z" }, + { url = "https://files.pythonhosted.org/packages/45/91/47a6e1c42d9ee337c4839208f30d9f09caa9f720ec7582917b264defc875/pyyaml-6.0.3-cp311-cp311-win32.whl", hash = "sha256:8098f252adfa6c80ab48096053f512f2321f0b998f98150cea9bd23d83e1467b", size = 142543, upload-time = "2025-09-25T21:32:08.95Z" }, + { url = "https://files.pythonhosted.org/packages/da/e3/ea007450a105ae919a72393cb06f122f288ef60bba2dc64b26e2646fa315/pyyaml-6.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:9f3bfb4965eb874431221a3ff3fdcddc7e74e3b07799e0e84ca4a0f867d449bf", size = 158763, upload-time = "2025-09-25T21:32:09.96Z" }, + { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" }, + { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" }, + { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" }, + { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" }, + { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" }, + { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" }, + { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" }, + { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" }, + { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" }, + { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" }, + { 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 = "pyyaml-ft" +version = "8.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5e/eb/5a0d575de784f9a1f94e2b1288c6886f13f34185e13117ed530f32b6f8a8/pyyaml_ft-8.0.0.tar.gz", hash = "sha256:0c947dce03954c7b5d38869ed4878b2e6ff1d44b08a0d84dc83fdad205ae39ab", size = 141057, upload-time = "2025-06-10T15:32:15.613Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/68/ba/a067369fe61a2e57fb38732562927d5bae088c73cb9bb5438736a9555b29/pyyaml_ft-8.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8c1306282bc958bfda31237f900eb52c9bedf9b93a11f82e1aab004c9a5657a6", size = 187027, upload-time = "2025-06-10T15:31:48.722Z" }, + { url = "https://files.pythonhosted.org/packages/ad/c5/a3d2020ce5ccfc6aede0d45bcb870298652ac0cf199f67714d250e0cdf39/pyyaml_ft-8.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:30c5f1751625786c19de751e3130fc345ebcba6a86f6bddd6e1285342f4bbb69", size = 176146, upload-time = "2025-06-10T15:31:50.584Z" }, + { url = "https://files.pythonhosted.org/packages/e3/bb/23a9739291086ca0d3189eac7cd92b4d00e9fdc77d722ab610c35f9a82ba/pyyaml_ft-8.0.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3fa992481155ddda2e303fcc74c79c05eddcdbc907b888d3d9ce3ff3e2adcfb0", size = 746792, upload-time = "2025-06-10T15:31:52.304Z" }, + { url = "https://files.pythonhosted.org/packages/5f/c2/e8825f4ff725b7e560d62a3609e31d735318068e1079539ebfde397ea03e/pyyaml_ft-8.0.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cec6c92b4207004b62dfad1f0be321c9f04725e0f271c16247d8b39c3bf3ea42", size = 786772, upload-time = "2025-06-10T15:31:54.712Z" }, + { url = "https://files.pythonhosted.org/packages/35/be/58a4dcae8854f2fdca9b28d9495298fd5571a50d8430b1c3033ec95d2d0e/pyyaml_ft-8.0.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:06237267dbcab70d4c0e9436d8f719f04a51123f0ca2694c00dd4b68c338e40b", size = 778723, upload-time = "2025-06-10T15:31:56.093Z" }, + { url = "https://files.pythonhosted.org/packages/86/ed/fed0da92b5d5d7340a082e3802d84c6dc9d5fa142954404c41a544c1cb92/pyyaml_ft-8.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:8a7f332bc565817644cdb38ffe4739e44c3e18c55793f75dddb87630f03fc254", size = 758478, upload-time = "2025-06-10T15:31:58.314Z" }, + { url = "https://files.pythonhosted.org/packages/f0/69/ac02afe286275980ecb2dcdc0156617389b7e0c0a3fcdedf155c67be2b80/pyyaml_ft-8.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:7d10175a746be65f6feb86224df5d6bc5c049ebf52b89a88cf1cd78af5a367a8", size = 799159, upload-time = "2025-06-10T15:31:59.675Z" }, + { url = "https://files.pythonhosted.org/packages/4e/ac/c492a9da2e39abdff4c3094ec54acac9747743f36428281fb186a03fab76/pyyaml_ft-8.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:58e1015098cf8d8aec82f360789c16283b88ca670fe4275ef6c48c5e30b22a96", size = 158779, upload-time = "2025-06-10T15:32:01.029Z" }, + { url = "https://files.pythonhosted.org/packages/5d/9b/41998df3298960d7c67653669f37710fa2d568a5fc933ea24a6df60acaf6/pyyaml_ft-8.0.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:e64fa5f3e2ceb790d50602b2fd4ec37abbd760a8c778e46354df647e7c5a4ebb", size = 191331, upload-time = "2025-06-10T15:32:02.602Z" }, + { url = "https://files.pythonhosted.org/packages/0f/16/2710c252ee04cbd74d9562ebba709e5a284faeb8ada88fcda548c9191b47/pyyaml_ft-8.0.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:8d445bf6ea16bb93c37b42fdacfb2f94c8e92a79ba9e12768c96ecde867046d1", size = 182879, upload-time = "2025-06-10T15:32:04.466Z" }, + { url = "https://files.pythonhosted.org/packages/9a/40/ae8163519d937fa7bfa457b6f78439cc6831a7c2b170e4f612f7eda71815/pyyaml_ft-8.0.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8c56bb46b4fda34cbb92a9446a841da3982cdde6ea13de3fbd80db7eeeab8b49", size = 811277, upload-time = "2025-06-10T15:32:06.214Z" }, + { url = "https://files.pythonhosted.org/packages/f9/66/28d82dbff7f87b96f0eeac79b7d972a96b4980c1e445eb6a857ba91eda00/pyyaml_ft-8.0.0-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:dab0abb46eb1780da486f022dce034b952c8ae40753627b27a626d803926483b", size = 831650, upload-time = "2025-06-10T15:32:08.076Z" }, + { url = "https://files.pythonhosted.org/packages/e8/df/161c4566facac7d75a9e182295c223060373d4116dead9cc53a265de60b9/pyyaml_ft-8.0.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bd48d639cab5ca50ad957b6dd632c7dd3ac02a1abe0e8196a3c24a52f5db3f7a", size = 815755, upload-time = "2025-06-10T15:32:09.435Z" }, + { url = "https://files.pythonhosted.org/packages/05/10/f42c48fa5153204f42eaa945e8d1fd7c10d6296841dcb2447bf7da1be5c4/pyyaml_ft-8.0.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:052561b89d5b2a8e1289f326d060e794c21fa068aa11255fe71d65baf18a632e", size = 810403, upload-time = "2025-06-10T15:32:11.051Z" }, + { url = "https://files.pythonhosted.org/packages/d5/d2/e369064aa51009eb9245399fd8ad2c562bd0bcd392a00be44b2a824ded7c/pyyaml_ft-8.0.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:3bb4b927929b0cb162fb1605392a321e3333e48ce616cdcfa04a839271373255", size = 835581, upload-time = "2025-06-10T15:32:12.897Z" }, + { url = "https://files.pythonhosted.org/packages/c0/28/26534bed77109632a956977f60d8519049f545abc39215d086e33a61f1f2/pyyaml_ft-8.0.0-cp313-cp313t-win_amd64.whl", hash = "sha256:de04cfe9439565e32f178106c51dd6ca61afaa2907d143835d501d84703d3793", size = 171579, upload-time = "2025-06-10T15:32:14.34Z" }, +] + +[[package]] +name = "ray" +version = "2.49.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "click" }, + { name = "filelock" }, + { name = "jsonschema" }, + { name = "msgpack" }, + { name = "packaging" }, + { name = "protobuf" }, + { name = "pyyaml" }, + { name = "requests" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/e4/99/517f224ffd073689c4905bdb185c21d9d8936d75066a96d454878f9e1e47/ray-2.49.2-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:08bec467576bc030d8bd0638004e1b8e075588929349112988a4bd4928684e8c", size = 66869076, upload-time = "2025-09-19T19:14:37.371Z" }, + { url = "https://files.pythonhosted.org/packages/61/c5/c2ceba832fe3f47cfd7e11cd7cc7a1bbc2c028424c5bca70435aa4ca1dec/ray-2.49.2-cp310-cp310-macosx_12_0_x86_64.whl", hash = "sha256:3e441bf2acd7f368cf45132752066c5c3b83d88cd5f85762e703774bba4f2b6d", size = 69263514, upload-time = "2025-09-19T19:14:45.519Z" }, + { url = "https://files.pythonhosted.org/packages/63/0e/830df5a0f7e2b582422ee8ad0cdf2a2a9563aa63bb8e60be9ceec494981c/ray-2.49.2-cp310-cp310-manylinux2014_aarch64.whl", hash = "sha256:eae07b3fed45f5b041a8bf9795cd26fad2464be5126efd447e4484905a29b677", size = 69125462, upload-time = "2025-09-19T19:14:51.029Z" }, + { url = "https://files.pythonhosted.org/packages/c0/85/a340eba596db3f66d3a338aff43942d8bac32732fb4cf4a20ed4bbbd07eb/ray-2.49.2-cp310-cp310-manylinux2014_x86_64.whl", hash = "sha256:74566876af7bf4e48ea4b9b3b75b34db053d1064cc4d4b1670dc4ce78f6894af", size = 69935752, upload-time = "2025-09-19T19:14:56.191Z" }, + { url = "https://files.pythonhosted.org/packages/ac/e6/809730d87cdf762e76728ea6bb3f96e38fa2dc7ef7d572a49c0d7ebcde95/ray-2.49.2-cp310-cp310-win_amd64.whl", hash = "sha256:e6becc2026d900ca0ba07eff12a130c9d651a91290bb24d43594842b575cc4e5", size = 26246695, upload-time = "2025-09-19T19:15:00.9Z" }, + { url = "https://files.pythonhosted.org/packages/b5/63/27c7fb49513c816b825c809dd33a8570b35d511d1b5e568a4b33b0557997/ray-2.49.2-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:4fb9f9bf62fd5c92d22da20cd2aacb4ade1fb23033765fa9274f0a0c50bc42f6", size = 66869606, upload-time = "2025-09-19T19:15:05.838Z" }, + { url = "https://files.pythonhosted.org/packages/52/9a/9728d1e9dc5473acf0e4f67081dc323d3333c8c87a1e9260ea8878720017/ray-2.49.2-cp311-cp311-macosx_12_0_x86_64.whl", hash = "sha256:9ece957a13985f7bbf4077f4ff0204314d7e99a941f95dff2a16b453d5376dc3", size = 69273124, upload-time = "2025-09-19T19:15:11.348Z" }, + { url = "https://files.pythonhosted.org/packages/38/67/93f0d6d558874a730581059eb6dfa8860991a5410502ea0685dba5e788e4/ray-2.49.2-cp311-cp311-manylinux2014_aarch64.whl", hash = "sha256:eada9dd89ccda643a3c6c2cba7016b59898432d126e10b38fed52d74165364f4", size = 69266231, upload-time = "2025-09-19T19:15:16.92Z" }, + { url = "https://files.pythonhosted.org/packages/c1/2b/f2efd0e7bcef06d51422db1af48cc5695a3f9b40a444f9d270a2d4663252/ray-2.49.2-cp311-cp311-manylinux2014_x86_64.whl", hash = "sha256:54077dde338c5ffba349a4ab61b72352a3c3be69ea5b4f1b436d98d40b312763", size = 70070382, upload-time = "2025-09-19T19:15:22.048Z" }, + { url = "https://files.pythonhosted.org/packages/d7/b5/dfe1240e13d88dc68de03ee7c617f7578ef026e8569a42f7eeeb4729c5e3/ray-2.49.2-cp311-cp311-win_amd64.whl", hash = "sha256:41e11802ebbc487380e6c21dc041cb405e69fdda717a4eafdfeea294c6c3f9ca", size = 26243798, upload-time = "2025-09-19T19:15:26.405Z" }, + { url = "https://files.pythonhosted.org/packages/01/66/0d4e518d611486244b357a6cf58a31d7d184f5558e03d5e482c335749616/ray-2.49.2-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:d6d612de5c6341b776fc75edeee5b698bb4af7ee84a2ff30552b32a9e6e4a772", size = 66857495, upload-time = "2025-09-19T19:15:31.427Z" }, + { url = "https://files.pythonhosted.org/packages/1a/4c/76f2c7c0946645fdd8d286a3e00e2c42130d676286de206be5d60d271218/ray-2.49.2-cp312-cp312-macosx_12_0_x86_64.whl", hash = "sha256:6784e076e4418222ef8ee3b6a8bfeb867d8797803b25bcfcce3bf3bc5414bef1", size = 69262599, upload-time = "2025-09-19T19:15:36.732Z" }, + { url = "https://files.pythonhosted.org/packages/da/99/23b732c0b7b2ee2ffd28bf632257fb98924a03251d251810cb637512fcab/ray-2.49.2-cp312-cp312-manylinux2014_aarch64.whl", hash = "sha256:dd0d8d8641d142fafe6d83e87d3c19bd5637d21e34608d3ff69ad71ea3e2f462", size = 69287193, upload-time = "2025-09-19T19:15:42.093Z" }, + { url = "https://files.pythonhosted.org/packages/69/ca/94791be5c3b68ed0df85589a8ca558334818a47bf2978000f85533245aed/ray-2.49.2-cp312-cp312-manylinux2014_x86_64.whl", hash = "sha256:2ecaaa51f588ccdda2b61563a8be3843bf65dfaaa83a240588a307f4ebb82471", size = 70114942, upload-time = "2025-09-19T19:15:47.536Z" }, + { url = "https://files.pythonhosted.org/packages/e0/22/3f4b77498eefb3152a5946f9f544fcf336e7b9970c5c8af8e2d5eed13f0b/ray-2.49.2-cp312-cp312-win_amd64.whl", hash = "sha256:cba59684f031c9e778c588bc925777967e1b49bab3f00c638e4980bfdab07aec", size = 26223595, upload-time = "2025-09-19T19:15:51.803Z" }, + { url = "https://files.pythonhosted.org/packages/99/dc/a7e569bf7030e0ec50163aed731189e744ca857d74f51b24361ce426697a/ray-2.49.2-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:2e2fe20fa90562e73630da9ff7932d3ed6507e73291c4d9bdf566537ae9deddf", size = 66803846, upload-time = "2025-09-19T19:15:56.928Z" }, + { url = "https://files.pythonhosted.org/packages/4e/cf/6667e01f39cd28637f082273e9147f16d5f8fff34e2fb0ca60cc5da76e22/ray-2.49.2-cp313-cp313-macosx_12_0_x86_64.whl", hash = "sha256:b2f4f0fed936faf688e87ffdcc9356c034513c00259a2f1a8589e345fcfbdbc0", size = 69208426, upload-time = "2025-09-19T19:16:02.085Z" }, + { url = "https://files.pythonhosted.org/packages/c5/84/5361bcdc9c9fb9f4abbf836801803b7df75c76c16a56493413eb154b8a34/ray-2.49.2-cp313-cp313-manylinux2014_aarch64.whl", hash = "sha256:b4c7869688c518e902f7b6288edec2365ab4d28a464291e6d0a7040c7d01b5f7", size = 69198140, upload-time = "2025-09-19T19:16:07.413Z" }, + { url = "https://files.pythonhosted.org/packages/b0/0c/9e49c3da7502f18483e4deb3273a3104d501c5e9cf1664a136b8ea36df48/ray-2.49.2-cp313-cp313-manylinux2014_x86_64.whl", hash = "sha256:b7d8214cff86df044fec727eeeabccc3bfc9b0271d28d61ba92c09f0d127d01d", size = 70027331, upload-time = "2025-09-19T19:16:12.968Z" }, +] + +[[package]] +name = "referencing" +version = "0.37.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "attrs" }, + { name = "rpds-py" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/22/f5/df4e9027acead3ecc63e50fe1e36aca1523e1719559c499951bb4b53188f/referencing-0.37.0.tar.gz", hash = "sha256:44aefc3142c5b842538163acb373e24cce6632bd54bdb01b21ad5863489f50d8", size = 78036, upload-time = "2025-10-13T15:30:48.871Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2c/58/ca301544e1fa93ed4f80d724bf5b194f6e4b945841c5bfd555878eea9fcb/referencing-0.37.0-py3-none-any.whl", hash = "sha256:381329a9f99628c9069361716891d34ad94af76e461dcb0335825aecc7692231", size = 26766, upload-time = "2025-10-13T15:30:47.625Z" }, +] + +[[package]] +name = "regex" +version = "2025.11.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cc/a9/546676f25e573a4cf00fe8e119b78a37b6a8fe2dc95cda877b30889c9c45/regex-2025.11.3.tar.gz", hash = "sha256:1fedc720f9bb2494ce31a58a1631f9c82df6a09b49c19517ea5cc280b4541e01", size = 414669, upload-time = "2025-11-03T21:34:22.089Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8a/d6/d788d52da01280a30a3f6268aef2aa71043bff359c618fea4c5b536654d5/regex-2025.11.3-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:2b441a4ae2c8049106e8b39973bfbddfb25a179dda2bdb99b0eeb60c40a6a3af", size = 488087, upload-time = "2025-11-03T21:30:47.317Z" }, + { url = "https://files.pythonhosted.org/packages/69/39/abec3bd688ec9bbea3562de0fd764ff802976185f5ff22807bf0a2697992/regex-2025.11.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:2fa2eed3f76677777345d2f81ee89f5de2f5745910e805f7af7386a920fa7313", size = 290544, upload-time = "2025-11-03T21:30:49.912Z" }, + { url = "https://files.pythonhosted.org/packages/39/b3/9a231475d5653e60002508f41205c61684bb2ffbf2401351ae2186897fc4/regex-2025.11.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:d8b4a27eebd684319bdf473d39f1d79eed36bf2cd34bd4465cdb4618d82b3d56", size = 288408, upload-time = "2025-11-03T21:30:51.344Z" }, + { url = "https://files.pythonhosted.org/packages/c3/c5/1929a0491bd5ac2d1539a866768b88965fa8c405f3e16a8cef84313098d6/regex-2025.11.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5cf77eac15bd264986c4a2c63353212c095b40f3affb2bc6b4ef80c4776c1a28", size = 781584, upload-time = "2025-11-03T21:30:52.596Z" }, + { url = "https://files.pythonhosted.org/packages/ce/fd/16aa16cf5d497ef727ec966f74164fbe75d6516d3d58ac9aa989bc9cdaad/regex-2025.11.3-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b7f9ee819f94c6abfa56ec7b1dbab586f41ebbdc0a57e6524bd5e7f487a878c7", size = 850733, upload-time = "2025-11-03T21:30:53.825Z" }, + { url = "https://files.pythonhosted.org/packages/e6/49/3294b988855a221cb6565189edf5dc43239957427df2d81d4a6b15244f64/regex-2025.11.3-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:838441333bc90b829406d4a03cb4b8bf7656231b84358628b0406d803931ef32", size = 898691, upload-time = "2025-11-03T21:30:55.575Z" }, + { url = "https://files.pythonhosted.org/packages/14/62/b56d29e70b03666193369bdbdedfdc23946dbe9f81dd78ce262c74d988ab/regex-2025.11.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cfe6d3f0c9e3b7e8c0c694b24d25e677776f5ca26dce46fd6b0489f9c8339391", size = 791662, upload-time = "2025-11-03T21:30:57.262Z" }, + { url = "https://files.pythonhosted.org/packages/15/fc/e4c31d061eced63fbf1ce9d853975f912c61a7d406ea14eda2dd355f48e7/regex-2025.11.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2ab815eb8a96379a27c3b6157fcb127c8f59c36f043c1678110cea492868f1d5", size = 782587, upload-time = "2025-11-03T21:30:58.788Z" }, + { url = "https://files.pythonhosted.org/packages/b2/bb/5e30c7394bcf63f0537121c23e796be67b55a8847c3956ae6068f4c70702/regex-2025.11.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:728a9d2d173a65b62bdc380b7932dd8e74ed4295279a8fe1021204ce210803e7", size = 774709, upload-time = "2025-11-03T21:31:00.081Z" }, + { url = "https://files.pythonhosted.org/packages/c5/c4/fce773710af81b0cb37cb4ff0947e75d5d17dee304b93d940b87a67fc2f4/regex-2025.11.3-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:509dc827f89c15c66a0c216331260d777dd6c81e9a4e4f830e662b0bb296c313", size = 845773, upload-time = "2025-11-03T21:31:01.583Z" }, + { url = "https://files.pythonhosted.org/packages/7b/5e/9466a7ec4b8ec282077095c6eb50a12a389d2e036581134d4919e8ca518c/regex-2025.11.3-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:849202cd789e5f3cf5dcc7822c34b502181b4824a65ff20ce82da5524e45e8e9", size = 836164, upload-time = "2025-11-03T21:31:03.244Z" }, + { url = "https://files.pythonhosted.org/packages/95/18/82980a60e8ed1594eb3c89eb814fb276ef51b9af7caeab1340bfd8564af6/regex-2025.11.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:b6f78f98741dcc89607c16b1e9426ee46ce4bf31ac5e6b0d40e81c89f3481ea5", size = 779832, upload-time = "2025-11-03T21:31:04.876Z" }, + { url = "https://files.pythonhosted.org/packages/03/cc/90ab0fdbe6dce064a42015433f9152710139fb04a8b81b4fb57a1cb63ffa/regex-2025.11.3-cp310-cp310-win32.whl", hash = "sha256:149eb0bba95231fb4f6d37c8f760ec9fa6fabf65bab555e128dde5f2475193ec", size = 265802, upload-time = "2025-11-03T21:31:06.581Z" }, + { url = "https://files.pythonhosted.org/packages/34/9d/e9e8493a85f3b1ddc4a5014465f5c2b78c3ea1cbf238dcfde78956378041/regex-2025.11.3-cp310-cp310-win_amd64.whl", hash = "sha256:ee3a83ce492074c35a74cc76cf8235d49e77b757193a5365ff86e3f2f93db9fd", size = 277722, upload-time = "2025-11-03T21:31:08.144Z" }, + { url = "https://files.pythonhosted.org/packages/15/c4/b54b24f553966564506dbf873a3e080aef47b356a3b39b5d5aba992b50db/regex-2025.11.3-cp310-cp310-win_arm64.whl", hash = "sha256:38af559ad934a7b35147716655d4a2f79fcef2d695ddfe06a06ba40ae631fa7e", size = 270289, upload-time = "2025-11-03T21:31:10.267Z" }, + { url = "https://files.pythonhosted.org/packages/f7/90/4fb5056e5f03a7048abd2b11f598d464f0c167de4f2a51aa868c376b8c70/regex-2025.11.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:eadade04221641516fa25139273505a1c19f9bf97589a05bc4cfcd8b4a618031", size = 488081, upload-time = "2025-11-03T21:31:11.946Z" }, + { url = "https://files.pythonhosted.org/packages/85/23/63e481293fac8b069d84fba0299b6666df720d875110efd0338406b5d360/regex-2025.11.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:feff9e54ec0dd3833d659257f5c3f5322a12eee58ffa360984b716f8b92983f4", size = 290554, upload-time = "2025-11-03T21:31:13.387Z" }, + { url = "https://files.pythonhosted.org/packages/2b/9d/b101d0262ea293a0066b4522dfb722eb6a8785a8c3e084396a5f2c431a46/regex-2025.11.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:3b30bc921d50365775c09a7ed446359e5c0179e9e2512beec4a60cbcef6ddd50", size = 288407, upload-time = "2025-11-03T21:31:14.809Z" }, + { url = "https://files.pythonhosted.org/packages/0c/64/79241c8209d5b7e00577ec9dca35cd493cc6be35b7d147eda367d6179f6d/regex-2025.11.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f99be08cfead2020c7ca6e396c13543baea32343b7a9a5780c462e323bd8872f", size = 793418, upload-time = "2025-11-03T21:31:16.556Z" }, + { url = "https://files.pythonhosted.org/packages/3d/e2/23cd5d3573901ce8f9757c92ca4db4d09600b865919b6d3e7f69f03b1afd/regex-2025.11.3-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6dd329a1b61c0ee95ba95385fb0c07ea0d3fe1a21e1349fa2bec272636217118", size = 860448, upload-time = "2025-11-03T21:31:18.12Z" }, + { url = "https://files.pythonhosted.org/packages/2a/4c/aecf31beeaa416d0ae4ecb852148d38db35391aac19c687b5d56aedf3a8b/regex-2025.11.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4c5238d32f3c5269d9e87be0cf096437b7622b6920f5eac4fd202468aaeb34d2", size = 907139, upload-time = "2025-11-03T21:31:20.753Z" }, + { url = "https://files.pythonhosted.org/packages/61/22/b8cb00df7d2b5e0875f60628594d44dba283e951b1ae17c12f99e332cc0a/regex-2025.11.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:10483eefbfb0adb18ee9474498c9a32fcf4e594fbca0543bb94c48bac6183e2e", size = 800439, upload-time = "2025-11-03T21:31:22.069Z" }, + { url = "https://files.pythonhosted.org/packages/02/a8/c4b20330a5cdc7a8eb265f9ce593f389a6a88a0c5f280cf4d978f33966bc/regex-2025.11.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:78c2d02bb6e1da0720eedc0bad578049cad3f71050ef8cd065ecc87691bed2b0", size = 782965, upload-time = "2025-11-03T21:31:23.598Z" }, + { url = "https://files.pythonhosted.org/packages/b4/4c/ae3e52988ae74af4b04d2af32fee4e8077f26e51b62ec2d12d246876bea2/regex-2025.11.3-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:e6b49cd2aad93a1790ce9cffb18964f6d3a4b0b3dbdbd5de094b65296fce6e58", size = 854398, upload-time = "2025-11-03T21:31:25.008Z" }, + { url = "https://files.pythonhosted.org/packages/06/d1/a8b9cf45874eda14b2e275157ce3b304c87e10fb38d9fc26a6e14eb18227/regex-2025.11.3-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:885b26aa3ee56433b630502dc3d36ba78d186a00cc535d3806e6bfd9ed3c70ab", size = 845897, upload-time = "2025-11-03T21:31:26.427Z" }, + { url = "https://files.pythonhosted.org/packages/ea/fe/1830eb0236be93d9b145e0bd8ab499f31602fe0999b1f19e99955aa8fe20/regex-2025.11.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ddd76a9f58e6a00f8772e72cff8ebcff78e022be95edf018766707c730593e1e", size = 788906, upload-time = "2025-11-03T21:31:28.078Z" }, + { url = "https://files.pythonhosted.org/packages/66/47/dc2577c1f95f188c1e13e2e69d8825a5ac582ac709942f8a03af42ed6e93/regex-2025.11.3-cp311-cp311-win32.whl", hash = "sha256:3e816cc9aac1cd3cc9a4ec4d860f06d40f994b5c7b4d03b93345f44e08cc68bf", size = 265812, upload-time = "2025-11-03T21:31:29.72Z" }, + { url = "https://files.pythonhosted.org/packages/50/1e/15f08b2f82a9bbb510621ec9042547b54d11e83cb620643ebb54e4eb7d71/regex-2025.11.3-cp311-cp311-win_amd64.whl", hash = "sha256:087511f5c8b7dfbe3a03f5d5ad0c2a33861b1fc387f21f6f60825a44865a385a", size = 277737, upload-time = "2025-11-03T21:31:31.422Z" }, + { url = "https://files.pythonhosted.org/packages/f4/fc/6500eb39f5f76c5e47a398df82e6b535a5e345f839581012a418b16f9cc3/regex-2025.11.3-cp311-cp311-win_arm64.whl", hash = "sha256:1ff0d190c7f68ae7769cd0313fe45820ba07ffebfddfaa89cc1eb70827ba0ddc", size = 270290, upload-time = "2025-11-03T21:31:33.041Z" }, + { url = "https://files.pythonhosted.org/packages/e8/74/18f04cb53e58e3fb107439699bd8375cf5a835eec81084e0bddbd122e4c2/regex-2025.11.3-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:bc8ab71e2e31b16e40868a40a69007bc305e1109bd4658eb6cad007e0bf67c41", size = 489312, upload-time = "2025-11-03T21:31:34.343Z" }, + { url = "https://files.pythonhosted.org/packages/78/3f/37fcdd0d2b1e78909108a876580485ea37c91e1acf66d3bb8e736348f441/regex-2025.11.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:22b29dda7e1f7062a52359fca6e58e548e28c6686f205e780b02ad8ef710de36", size = 291256, upload-time = "2025-11-03T21:31:35.675Z" }, + { url = "https://files.pythonhosted.org/packages/bf/26/0a575f58eb23b7ebd67a45fccbc02ac030b737b896b7e7a909ffe43ffd6a/regex-2025.11.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3a91e4a29938bc1a082cc28fdea44be420bf2bebe2665343029723892eb073e1", size = 288921, upload-time = "2025-11-03T21:31:37.07Z" }, + { url = "https://files.pythonhosted.org/packages/ea/98/6a8dff667d1af907150432cf5abc05a17ccd32c72a3615410d5365ac167a/regex-2025.11.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:08b884f4226602ad40c5d55f52bf91a9df30f513864e0054bad40c0e9cf1afb7", size = 798568, upload-time = "2025-11-03T21:31:38.784Z" }, + { url = "https://files.pythonhosted.org/packages/64/15/92c1db4fa4e12733dd5a526c2dd2b6edcbfe13257e135fc0f6c57f34c173/regex-2025.11.3-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:3e0b11b2b2433d1c39c7c7a30e3f3d0aeeea44c2a8d0bae28f6b95f639927a69", size = 864165, upload-time = "2025-11-03T21:31:40.559Z" }, + { url = "https://files.pythonhosted.org/packages/f9/e7/3ad7da8cdee1ce66c7cd37ab5ab05c463a86ffeb52b1a25fe7bd9293b36c/regex-2025.11.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:87eb52a81ef58c7ba4d45c3ca74e12aa4b4e77816f72ca25258a85b3ea96cb48", size = 912182, upload-time = "2025-11-03T21:31:42.002Z" }, + { url = "https://files.pythonhosted.org/packages/84/bd/9ce9f629fcb714ffc2c3faf62b6766ecb7a585e1e885eb699bcf130a5209/regex-2025.11.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a12ab1f5c29b4e93db518f5e3872116b7e9b1646c9f9f426f777b50d44a09e8c", size = 803501, upload-time = "2025-11-03T21:31:43.815Z" }, + { url = "https://files.pythonhosted.org/packages/7c/0f/8dc2e4349d8e877283e6edd6c12bdcebc20f03744e86f197ab6e4492bf08/regex-2025.11.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:7521684c8c7c4f6e88e35ec89680ee1aa8358d3f09d27dfbdf62c446f5d4c695", size = 787842, upload-time = "2025-11-03T21:31:45.353Z" }, + { url = "https://files.pythonhosted.org/packages/f9/73/cff02702960bc185164d5619c0c62a2f598a6abff6695d391b096237d4ab/regex-2025.11.3-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:7fe6e5440584e94cc4b3f5f4d98a25e29ca12dccf8873679a635638349831b98", size = 858519, upload-time = "2025-11-03T21:31:46.814Z" }, + { url = "https://files.pythonhosted.org/packages/61/83/0e8d1ae71e15bc1dc36231c90b46ee35f9d52fab2e226b0e039e7ea9c10a/regex-2025.11.3-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:8e026094aa12b43f4fd74576714e987803a315c76edb6b098b9809db5de58f74", size = 850611, upload-time = "2025-11-03T21:31:48.289Z" }, + { url = "https://files.pythonhosted.org/packages/c8/f5/70a5cdd781dcfaa12556f2955bf170cd603cb1c96a1827479f8faea2df97/regex-2025.11.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:435bbad13e57eb5606a68443af62bed3556de2f46deb9f7d4237bc2f1c9fb3a0", size = 789759, upload-time = "2025-11-03T21:31:49.759Z" }, + { url = "https://files.pythonhosted.org/packages/59/9b/7c29be7903c318488983e7d97abcf8ebd3830e4c956c4c540005fcfb0462/regex-2025.11.3-cp312-cp312-win32.whl", hash = "sha256:3839967cf4dc4b985e1570fd8d91078f0c519f30491c60f9ac42a8db039be204", size = 266194, upload-time = "2025-11-03T21:31:51.53Z" }, + { url = "https://files.pythonhosted.org/packages/1a/67/3b92df89f179d7c367be654ab5626ae311cb28f7d5c237b6bb976cd5fbbb/regex-2025.11.3-cp312-cp312-win_amd64.whl", hash = "sha256:e721d1b46e25c481dc5ded6f4b3f66c897c58d2e8cfdf77bbced84339108b0b9", size = 277069, upload-time = "2025-11-03T21:31:53.151Z" }, + { url = "https://files.pythonhosted.org/packages/d7/55/85ba4c066fe5094d35b249c3ce8df0ba623cfd35afb22d6764f23a52a1c5/regex-2025.11.3-cp312-cp312-win_arm64.whl", hash = "sha256:64350685ff08b1d3a6fff33f45a9ca183dc1d58bbfe4981604e70ec9801bbc26", size = 270330, upload-time = "2025-11-03T21:31:54.514Z" }, + { url = "https://files.pythonhosted.org/packages/e1/a7/dda24ebd49da46a197436ad96378f17df30ceb40e52e859fc42cac45b850/regex-2025.11.3-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:c1e448051717a334891f2b9a620fe36776ebf3dd8ec46a0b877c8ae69575feb4", size = 489081, upload-time = "2025-11-03T21:31:55.9Z" }, + { url = "https://files.pythonhosted.org/packages/19/22/af2dc751aacf88089836aa088a1a11c4f21a04707eb1b0478e8e8fb32847/regex-2025.11.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:9b5aca4d5dfd7fbfbfbdaf44850fcc7709a01146a797536a8f84952e940cca76", size = 291123, upload-time = "2025-11-03T21:31:57.758Z" }, + { url = "https://files.pythonhosted.org/packages/a3/88/1a3ea5672f4b0a84802ee9891b86743438e7c04eb0b8f8c4e16a42375327/regex-2025.11.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:04d2765516395cf7dda331a244a3282c0f5ae96075f728629287dfa6f76ba70a", size = 288814, upload-time = "2025-11-03T21:32:01.12Z" }, + { url = "https://files.pythonhosted.org/packages/fb/8c/f5987895bf42b8ddeea1b315c9fedcfe07cadee28b9c98cf50d00adcb14d/regex-2025.11.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5d9903ca42bfeec4cebedba8022a7c97ad2aab22e09573ce9976ba01b65e4361", size = 798592, upload-time = "2025-11-03T21:32:03.006Z" }, + { url = "https://files.pythonhosted.org/packages/99/2a/6591ebeede78203fa77ee46a1c36649e02df9eaa77a033d1ccdf2fcd5d4e/regex-2025.11.3-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:639431bdc89d6429f6721625e8129413980ccd62e9d3f496be618a41d205f160", size = 864122, upload-time = "2025-11-03T21:32:04.553Z" }, + { url = "https://files.pythonhosted.org/packages/94/d6/be32a87cf28cf8ed064ff281cfbd49aefd90242a83e4b08b5a86b38e8eb4/regex-2025.11.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f117efad42068f9715677c8523ed2be1518116d1c49b1dd17987716695181efe", size = 912272, upload-time = "2025-11-03T21:32:06.148Z" }, + { url = "https://files.pythonhosted.org/packages/62/11/9bcef2d1445665b180ac7f230406ad80671f0fc2a6ffb93493b5dd8cd64c/regex-2025.11.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4aecb6f461316adf9f1f0f6a4a1a3d79e045f9b71ec76055a791affa3b285850", size = 803497, upload-time = "2025-11-03T21:32:08.162Z" }, + { url = "https://files.pythonhosted.org/packages/e5/a7/da0dc273d57f560399aa16d8a68ae7f9b57679476fc7ace46501d455fe84/regex-2025.11.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:3b3a5f320136873cc5561098dfab677eea139521cb9a9e8db98b7e64aef44cbc", size = 787892, upload-time = "2025-11-03T21:32:09.769Z" }, + { url = "https://files.pythonhosted.org/packages/da/4b/732a0c5a9736a0b8d6d720d4945a2f1e6f38f87f48f3173559f53e8d5d82/regex-2025.11.3-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:75fa6f0056e7efb1f42a1c34e58be24072cb9e61a601340cc1196ae92326a4f9", size = 858462, upload-time = "2025-11-03T21:32:11.769Z" }, + { url = "https://files.pythonhosted.org/packages/0c/f5/a2a03df27dc4c2d0c769220f5110ba8c4084b0bfa9ab0f9b4fcfa3d2b0fc/regex-2025.11.3-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:dbe6095001465294f13f1adcd3311e50dd84e5a71525f20a10bd16689c61ce0b", size = 850528, upload-time = "2025-11-03T21:32:13.906Z" }, + { url = "https://files.pythonhosted.org/packages/d6/09/e1cd5bee3841c7f6eb37d95ca91cdee7100b8f88b81e41c2ef426910891a/regex-2025.11.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:454d9b4ae7881afbc25015b8627c16d88a597479b9dea82b8c6e7e2e07240dc7", size = 789866, upload-time = "2025-11-03T21:32:15.748Z" }, + { url = "https://files.pythonhosted.org/packages/eb/51/702f5ea74e2a9c13d855a6a85b7f80c30f9e72a95493260193c07f3f8d74/regex-2025.11.3-cp313-cp313-win32.whl", hash = "sha256:28ba4d69171fc6e9896337d4fc63a43660002b7da53fc15ac992abcf3410917c", size = 266189, upload-time = "2025-11-03T21:32:17.493Z" }, + { url = "https://files.pythonhosted.org/packages/8b/00/6e29bb314e271a743170e53649db0fdb8e8ff0b64b4f425f5602f4eb9014/regex-2025.11.3-cp313-cp313-win_amd64.whl", hash = "sha256:bac4200befe50c670c405dc33af26dad5a3b6b255dd6c000d92fe4629f9ed6a5", size = 277054, upload-time = "2025-11-03T21:32:19.042Z" }, + { url = "https://files.pythonhosted.org/packages/25/f1/b156ff9f2ec9ac441710764dda95e4edaf5f36aca48246d1eea3f1fd96ec/regex-2025.11.3-cp313-cp313-win_arm64.whl", hash = "sha256:2292cd5a90dab247f9abe892ac584cb24f0f54680c73fcb4a7493c66c2bf2467", size = 270325, upload-time = "2025-11-03T21:32:21.338Z" }, + { url = "https://files.pythonhosted.org/packages/20/28/fd0c63357caefe5680b8ea052131acbd7f456893b69cc2a90cc3e0dc90d4/regex-2025.11.3-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:1eb1ebf6822b756c723e09f5186473d93236c06c579d2cc0671a722d2ab14281", size = 491984, upload-time = "2025-11-03T21:32:23.466Z" }, + { url = "https://files.pythonhosted.org/packages/df/ec/7014c15626ab46b902b3bcc4b28a7bae46d8f281fc7ea9c95e22fcaaa917/regex-2025.11.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:1e00ec2970aab10dc5db34af535f21fcf32b4a31d99e34963419636e2f85ae39", size = 292673, upload-time = "2025-11-03T21:32:25.034Z" }, + { url = "https://files.pythonhosted.org/packages/23/ab/3b952ff7239f20d05f1f99e9e20188513905f218c81d52fb5e78d2bf7634/regex-2025.11.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:a4cb042b615245d5ff9b3794f56be4138b5adc35a4166014d31d1814744148c7", size = 291029, upload-time = "2025-11-03T21:32:26.528Z" }, + { url = "https://files.pythonhosted.org/packages/21/7e/3dc2749fc684f455f162dcafb8a187b559e2614f3826877d3844a131f37b/regex-2025.11.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:44f264d4bf02f3176467d90b294d59bf1db9fe53c141ff772f27a8b456b2a9ed", size = 807437, upload-time = "2025-11-03T21:32:28.363Z" }, + { url = "https://files.pythonhosted.org/packages/1b/0b/d529a85ab349c6a25d1ca783235b6e3eedf187247eab536797021f7126c6/regex-2025.11.3-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7be0277469bf3bd7a34a9c57c1b6a724532a0d235cd0dc4e7f4316f982c28b19", size = 873368, upload-time = "2025-11-03T21:32:30.4Z" }, + { url = "https://files.pythonhosted.org/packages/7d/18/2d868155f8c9e3e9d8f9e10c64e9a9f496bb8f7e037a88a8bed26b435af6/regex-2025.11.3-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0d31e08426ff4b5b650f68839f5af51a92a5b51abd8554a60c2fbc7c71f25d0b", size = 914921, upload-time = "2025-11-03T21:32:32.123Z" }, + { url = "https://files.pythonhosted.org/packages/2d/71/9d72ff0f354fa783fe2ba913c8734c3b433b86406117a8db4ea2bf1c7a2f/regex-2025.11.3-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e43586ce5bd28f9f285a6e729466841368c4a0353f6fd08d4ce4630843d3648a", size = 812708, upload-time = "2025-11-03T21:32:34.305Z" }, + { url = "https://files.pythonhosted.org/packages/e7/19/ce4bf7f5575c97f82b6e804ffb5c4e940c62609ab2a0d9538d47a7fdf7d4/regex-2025.11.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:0f9397d561a4c16829d4e6ff75202c1c08b68a3bdbfe29dbfcdb31c9830907c6", size = 795472, upload-time = "2025-11-03T21:32:36.364Z" }, + { url = "https://files.pythonhosted.org/packages/03/86/fd1063a176ffb7b2315f9a1b08d17b18118b28d9df163132615b835a26ee/regex-2025.11.3-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:dd16e78eb18ffdb25ee33a0682d17912e8cc8a770e885aeee95020046128f1ce", size = 868341, upload-time = "2025-11-03T21:32:38.042Z" }, + { url = "https://files.pythonhosted.org/packages/12/43/103fb2e9811205e7386366501bc866a164a0430c79dd59eac886a2822950/regex-2025.11.3-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:ffcca5b9efe948ba0661e9df0fa50d2bc4b097c70b9810212d6b62f05d83b2dd", size = 854666, upload-time = "2025-11-03T21:32:40.079Z" }, + { url = "https://files.pythonhosted.org/packages/7d/22/e392e53f3869b75804762c7c848bd2dd2abf2b70fb0e526f58724638bd35/regex-2025.11.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:c56b4d162ca2b43318ac671c65bd4d563e841a694ac70e1a976ac38fcf4ca1d2", size = 799473, upload-time = "2025-11-03T21:32:42.148Z" }, + { url = "https://files.pythonhosted.org/packages/4f/f9/8bd6b656592f925b6845fcbb4d57603a3ac2fb2373344ffa1ed70aa6820a/regex-2025.11.3-cp313-cp313t-win32.whl", hash = "sha256:9ddc42e68114e161e51e272f667d640f97e84a2b9ef14b7477c53aac20c2d59a", size = 268792, upload-time = "2025-11-03T21:32:44.13Z" }, + { url = "https://files.pythonhosted.org/packages/e5/87/0e7d603467775ff65cd2aeabf1b5b50cc1c3708556a8b849a2fa4dd1542b/regex-2025.11.3-cp313-cp313t-win_amd64.whl", hash = "sha256:7a7c7fdf755032ffdd72c77e3d8096bdcb0eb92e89e17571a196f03d88b11b3c", size = 280214, upload-time = "2025-11-03T21:32:45.853Z" }, + { url = "https://files.pythonhosted.org/packages/8d/d0/2afc6f8e94e2b64bfb738a7c2b6387ac1699f09f032d363ed9447fd2bb57/regex-2025.11.3-cp313-cp313t-win_arm64.whl", hash = "sha256:df9eb838c44f570283712e7cff14c16329a9f0fb19ca492d21d4b7528ee6821e", size = 271469, upload-time = "2025-11-03T21:32:48.026Z" }, + { url = "https://files.pythonhosted.org/packages/31/e9/f6e13de7e0983837f7b6d238ad9458800a874bf37c264f7923e63409944c/regex-2025.11.3-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:9697a52e57576c83139d7c6f213d64485d3df5bf84807c35fa409e6c970801c6", size = 489089, upload-time = "2025-11-03T21:32:50.027Z" }, + { url = "https://files.pythonhosted.org/packages/a3/5c/261f4a262f1fa65141c1b74b255988bd2fa020cc599e53b080667d591cfc/regex-2025.11.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:e18bc3f73bd41243c9b38a6d9f2366cd0e0137a9aebe2d8ff76c5b67d4c0a3f4", size = 291059, upload-time = "2025-11-03T21:32:51.682Z" }, + { url = "https://files.pythonhosted.org/packages/8e/57/f14eeb7f072b0e9a5a090d1712741fd8f214ec193dba773cf5410108bb7d/regex-2025.11.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:61a08bcb0ec14ff4e0ed2044aad948d0659604f824cbd50b55e30b0ec6f09c73", size = 288900, upload-time = "2025-11-03T21:32:53.569Z" }, + { url = "https://files.pythonhosted.org/packages/3c/6b/1d650c45e99a9b327586739d926a1cd4e94666b1bd4af90428b36af66dc7/regex-2025.11.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c9c30003b9347c24bcc210958c5d167b9e4f9be786cb380a7d32f14f9b84674f", size = 799010, upload-time = "2025-11-03T21:32:55.222Z" }, + { url = "https://files.pythonhosted.org/packages/99/ee/d66dcbc6b628ce4e3f7f0cbbb84603aa2fc0ffc878babc857726b8aab2e9/regex-2025.11.3-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4e1e592789704459900728d88d41a46fe3969b82ab62945560a31732ffc19a6d", size = 864893, upload-time = "2025-11-03T21:32:57.239Z" }, + { url = "https://files.pythonhosted.org/packages/bf/2d/f238229f1caba7ac87a6c4153d79947fb0261415827ae0f77c304260c7d3/regex-2025.11.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6538241f45eb5a25aa575dbba1069ad786f68a4f2773a29a2bd3dd1f9de787be", size = 911522, upload-time = "2025-11-03T21:32:59.274Z" }, + { url = "https://files.pythonhosted.org/packages/bd/3d/22a4eaba214a917c80e04f6025d26143690f0419511e0116508e24b11c9b/regex-2025.11.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bce22519c989bb72a7e6b36a199384c53db7722fe669ba891da75907fe3587db", size = 803272, upload-time = "2025-11-03T21:33:01.393Z" }, + { url = "https://files.pythonhosted.org/packages/84/b1/03188f634a409353a84b5ef49754b97dbcc0c0f6fd6c8ede505a8960a0a4/regex-2025.11.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:66d559b21d3640203ab9075797a55165d79017520685fb407b9234d72ab63c62", size = 787958, upload-time = "2025-11-03T21:33:03.379Z" }, + { url = "https://files.pythonhosted.org/packages/99/6a/27d072f7fbf6fadd59c64d210305e1ff865cc3b78b526fd147db768c553b/regex-2025.11.3-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:669dcfb2e38f9e8c69507bace46f4889e3abbfd9b0c29719202883c0a603598f", size = 859289, upload-time = "2025-11-03T21:33:05.374Z" }, + { url = "https://files.pythonhosted.org/packages/9a/70/1b3878f648e0b6abe023172dacb02157e685564853cc363d9961bcccde4e/regex-2025.11.3-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:32f74f35ff0f25a5021373ac61442edcb150731fbaa28286bbc8bb1582c89d02", size = 850026, upload-time = "2025-11-03T21:33:07.131Z" }, + { url = "https://files.pythonhosted.org/packages/dd/d5/68e25559b526b8baab8e66839304ede68ff6727237a47727d240006bd0ff/regex-2025.11.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:e6c7a21dffba883234baefe91bc3388e629779582038f75d2a5be918e250f0ed", size = 789499, upload-time = "2025-11-03T21:33:09.141Z" }, + { url = "https://files.pythonhosted.org/packages/fc/df/43971264857140a350910d4e33df725e8c94dd9dee8d2e4729fa0d63d49e/regex-2025.11.3-cp314-cp314-win32.whl", hash = "sha256:795ea137b1d809eb6836b43748b12634291c0ed55ad50a7d72d21edf1cd565c4", size = 271604, upload-time = "2025-11-03T21:33:10.9Z" }, + { url = "https://files.pythonhosted.org/packages/01/6f/9711b57dc6894a55faf80a4c1b5aa4f8649805cb9c7aef46f7d27e2b9206/regex-2025.11.3-cp314-cp314-win_amd64.whl", hash = "sha256:9f95fbaa0ee1610ec0fc6b26668e9917a582ba80c52cc6d9ada15e30aa9ab9ad", size = 280320, upload-time = "2025-11-03T21:33:12.572Z" }, + { url = "https://files.pythonhosted.org/packages/f1/7e/f6eaa207d4377481f5e1775cdeb5a443b5a59b392d0065f3417d31d80f87/regex-2025.11.3-cp314-cp314-win_arm64.whl", hash = "sha256:dfec44d532be4c07088c3de2876130ff0fbeeacaa89a137decbbb5f665855a0f", size = 273372, upload-time = "2025-11-03T21:33:14.219Z" }, + { url = "https://files.pythonhosted.org/packages/c3/06/49b198550ee0f5e4184271cee87ba4dfd9692c91ec55289e6282f0f86ccf/regex-2025.11.3-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:ba0d8a5d7f04f73ee7d01d974d47c5834f8a1b0224390e4fe7c12a3a92a78ecc", size = 491985, upload-time = "2025-11-03T21:33:16.555Z" }, + { url = "https://files.pythonhosted.org/packages/ce/bf/abdafade008f0b1c9da10d934034cb670432d6cf6cbe38bbb53a1cfd6cf8/regex-2025.11.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:442d86cf1cfe4faabf97db7d901ef58347efd004934da045c745e7b5bd57ac49", size = 292669, upload-time = "2025-11-03T21:33:18.32Z" }, + { url = "https://files.pythonhosted.org/packages/f9/ef/0c357bb8edbd2ad8e273fcb9e1761bc37b8acbc6e1be050bebd6475f19c1/regex-2025.11.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:fd0a5e563c756de210bb964789b5abe4f114dacae9104a47e1a649b910361536", size = 291030, upload-time = "2025-11-03T21:33:20.048Z" }, + { url = "https://files.pythonhosted.org/packages/79/06/edbb67257596649b8fb088d6aeacbcb248ac195714b18a65e018bf4c0b50/regex-2025.11.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bf3490bcbb985a1ae97b2ce9ad1c0f06a852d5b19dde9b07bdf25bf224248c95", size = 807674, upload-time = "2025-11-03T21:33:21.797Z" }, + { url = "https://files.pythonhosted.org/packages/f4/d9/ad4deccfce0ea336296bd087f1a191543bb99ee1c53093dcd4c64d951d00/regex-2025.11.3-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:3809988f0a8b8c9dcc0f92478d6501fac7200b9ec56aecf0ec21f4a2ec4b6009", size = 873451, upload-time = "2025-11-03T21:33:23.741Z" }, + { url = "https://files.pythonhosted.org/packages/13/75/a55a4724c56ef13e3e04acaab29df26582f6978c000ac9cd6810ad1f341f/regex-2025.11.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f4ff94e58e84aedb9c9fce66d4ef9f27a190285b451420f297c9a09f2b9abee9", size = 914980, upload-time = "2025-11-03T21:33:25.999Z" }, + { url = "https://files.pythonhosted.org/packages/67/1e/a1657ee15bd9116f70d4a530c736983eed997b361e20ecd8f5ca3759d5c5/regex-2025.11.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7eb542fd347ce61e1321b0a6b945d5701528dca0cd9759c2e3bb8bd57e47964d", size = 812852, upload-time = "2025-11-03T21:33:27.852Z" }, + { url = "https://files.pythonhosted.org/packages/b8/6f/f7516dde5506a588a561d296b2d0044839de06035bb486b326065b4c101e/regex-2025.11.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:d6c2d5919075a1f2e413c00b056ea0c2f065b3f5fe83c3d07d325ab92dce51d6", size = 795566, upload-time = "2025-11-03T21:33:32.364Z" }, + { url = "https://files.pythonhosted.org/packages/d9/dd/3d10b9e170cc16fb34cb2cef91513cf3df65f440b3366030631b2984a264/regex-2025.11.3-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:3f8bf11a4827cc7ce5a53d4ef6cddd5ad25595d3c1435ef08f76825851343154", size = 868463, upload-time = "2025-11-03T21:33:34.459Z" }, + { url = "https://files.pythonhosted.org/packages/f5/8e/935e6beff1695aa9085ff83195daccd72acc82c81793df480f34569330de/regex-2025.11.3-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:22c12d837298651e5550ac1d964e4ff57c3f56965fc1812c90c9fb2028eaf267", size = 854694, upload-time = "2025-11-03T21:33:36.793Z" }, + { url = "https://files.pythonhosted.org/packages/92/12/10650181a040978b2f5720a6a74d44f841371a3d984c2083fc1752e4acf6/regex-2025.11.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:62ba394a3dda9ad41c7c780f60f6e4a70988741415ae96f6d1bf6c239cf01379", size = 799691, upload-time = "2025-11-03T21:33:39.079Z" }, + { url = "https://files.pythonhosted.org/packages/67/90/8f37138181c9a7690e7e4cb388debbd389342db3c7381d636d2875940752/regex-2025.11.3-cp314-cp314t-win32.whl", hash = "sha256:4bf146dca15cdd53224a1bf46d628bd7590e4a07fbb69e720d561aea43a32b38", size = 274583, upload-time = "2025-11-03T21:33:41.302Z" }, + { url = "https://files.pythonhosted.org/packages/8f/cd/867f5ec442d56beb56f5f854f40abcfc75e11d10b11fdb1869dd39c63aaf/regex-2025.11.3-cp314-cp314t-win_amd64.whl", hash = "sha256:adad1a1bcf1c9e76346e091d22d23ac54ef28e1365117d99521631078dfec9de", size = 284286, upload-time = "2025-11-03T21:33:43.324Z" }, + { url = "https://files.pythonhosted.org/packages/20/31/32c0c4610cbc070362bf1d2e4ea86d1ea29014d400a6d6c2486fcfd57766/regex-2025.11.3-cp314-cp314t-win_arm64.whl", hash = "sha256:c54f768482cef41e219720013cd05933b6f971d9562544d691c68699bf2b6801", size = 274741, upload-time = "2025-11-03T21:33:45.557Z" }, +] + +[[package]] +name = "requests" +version = "2.32.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "charset-normalizer" }, + { name = "idna" }, + { name = "urllib3" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c9/74/b3ff8e6c8446842c3f5c837e9c3dfcfe2018ea6ecef224c710c85ef728f4/requests-2.32.5.tar.gz", hash = "sha256:dbba0bac56e100853db0ea71b82b4dfd5fe2bf6d3754a8893c3af500cec7d7cf", size = 134517, upload-time = "2025-08-18T20:46:02.573Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1e/db/4254e3eabe8020b458f1a747140d32277ec7a271daf1d235b70dc0b4e6e3/requests-2.32.5-py3-none-any.whl", hash = "sha256:2462f94637a34fd532264295e186976db0f5d453d1cdd31473c85a6a161affb6", size = 64738, upload-time = "2025-08-18T20:46:00.542Z" }, +] + +[[package]] +name = "requests-oauthlib" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "oauthlib" }, + { name = "requests" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/42/f2/05f29bc3913aea15eb670be136045bf5c5bbf4b99ecb839da9b422bb2c85/requests-oauthlib-2.0.0.tar.gz", hash = "sha256:b3dffaebd884d8cd778494369603a9e7b58d29111bf6b41bdc2dcd87203af4e9", size = 55650, upload-time = "2024-03-22T20:32:29.939Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3b/5d/63d4ae3b9daea098d5d6f5da83984853c1bbacd5dc826764b249fe119d24/requests_oauthlib-2.0.0-py2.py3-none-any.whl", hash = "sha256:7dd8a5c40426b779b0868c404bdef9768deccf22749cde15852df527e6269b36", size = 24179, upload-time = "2024-03-22T20:32:28.055Z" }, +] + +[[package]] +name = "rich" +version = "14.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markdown-it-py" }, + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/fb/d2/8920e102050a0de7bfabeb4c4614a49248cf8d5d7a8d01885fbb24dc767a/rich-14.2.0.tar.gz", hash = "sha256:73ff50c7c0c1c77c8243079283f4edb376f0f6442433aecb8ce7e6d0b92d1fe4", size = 219990, upload-time = "2025-10-09T14:16:53.064Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/25/7a/b0178788f8dc6cafce37a212c99565fa1fe7872c70c6c9c1e1a372d9d88f/rich-14.2.0-py3-none-any.whl", hash = "sha256:76bc51fe2e57d2b1be1f96c524b890b816e334ab4c1e45888799bfaab0021edd", size = 243393, upload-time = "2025-10-09T14:16:51.245Z" }, +] + +[[package]] +name = "roman-numerals" +version = "4.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ae/f9/41dc953bbeb056c17d5f7a519f50fdf010bd0553be2d630bc69d1e022703/roman_numerals-4.1.0.tar.gz", hash = "sha256:1af8b147eb1405d5839e78aeb93131690495fe9da5c91856cb33ad55a7f1e5b2", size = 9077, upload-time = "2025-12-17T18:25:34.381Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/04/54/6f679c435d28e0a568d8e8a7c0a93a09010818634c3c3907fc98d8983770/roman_numerals-4.1.0-py3-none-any.whl", hash = "sha256:647ba99caddc2cc1e55a51e4360689115551bf4476d90e8162cf8c345fe233c7", size = 7676, upload-time = "2025-12-17T18:25:33.098Z" }, +] + +[[package]] +name = "roman-numerals-py" +version = "4.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "roman-numerals", marker = "python_full_version >= '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/cb/b5/de96fca640f4f656eb79bbee0e79aeec52e3e0e359f8a3e6a0d366378b64/roman_numerals_py-4.1.0.tar.gz", hash = "sha256:f5d7b2b4ca52dd855ef7ab8eb3590f428c0b1ea480736ce32b01fef2a5f8daf9", size = 4274, upload-time = "2025-12-17T18:25:41.153Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/27/2c/daca29684cbe9fd4bc711f8246da3c10adca1ccc4d24436b17572eb2590e/roman_numerals_py-4.1.0-py3-none-any.whl", hash = "sha256:553114c1167141c1283a51743759723ecd05604a1b6b507225e91dc1a6df0780", size = 4547, upload-time = "2025-12-17T18:25:40.136Z" }, +] + +[[package]] +name = "rpds-py" +version = "0.30.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/20/af/3f2f423103f1113b36230496629986e0ef7e199d2aa8392452b484b38ced/rpds_py-0.30.0.tar.gz", hash = "sha256:dd8ff7cf90014af0c0f787eea34794ebf6415242ee1d6fa91eaba725cc441e84", size = 69469, upload-time = "2025-11-30T20:24:38.837Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/06/0c/0c411a0ec64ccb6d104dcabe0e713e05e153a9a2c3c2bd2b32ce412166fe/rpds_py-0.30.0-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:679ae98e00c0e8d68a7fda324e16b90fd5260945b45d3b824c892cec9eea3288", size = 370490, upload-time = "2025-11-30T20:21:33.256Z" }, + { url = "https://files.pythonhosted.org/packages/19/6a/4ba3d0fb7297ebae71171822554abe48d7cab29c28b8f9f2c04b79988c05/rpds_py-0.30.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:4cc2206b76b4f576934f0ed374b10d7ca5f457858b157ca52064bdfc26b9fc00", size = 359751, upload-time = "2025-11-30T20:21:34.591Z" }, + { url = "https://files.pythonhosted.org/packages/cd/7c/e4933565ef7f7a0818985d87c15d9d273f1a649afa6a52ea35ad011195ea/rpds_py-0.30.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:389a2d49eded1896c3d48b0136ead37c48e221b391c052fba3f4055c367f60a6", size = 389696, upload-time = "2025-11-30T20:21:36.122Z" }, + { url = "https://files.pythonhosted.org/packages/5e/01/6271a2511ad0815f00f7ed4390cf2567bec1d4b1da39e2c27a41e6e3b4de/rpds_py-0.30.0-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:32c8528634e1bf7121f3de08fa85b138f4e0dc47657866630611b03967f041d7", size = 403136, upload-time = "2025-11-30T20:21:37.728Z" }, + { url = "https://files.pythonhosted.org/packages/55/64/c857eb7cd7541e9b4eee9d49c196e833128a55b89a9850a9c9ac33ccf897/rpds_py-0.30.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f207f69853edd6f6700b86efb84999651baf3789e78a466431df1331608e5324", size = 524699, upload-time = "2025-11-30T20:21:38.92Z" }, + { url = "https://files.pythonhosted.org/packages/9c/ed/94816543404078af9ab26159c44f9e98e20fe47e2126d5d32c9d9948d10a/rpds_py-0.30.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:67b02ec25ba7a9e8fa74c63b6ca44cf5707f2fbfadae3ee8e7494297d56aa9df", size = 412022, upload-time = "2025-11-30T20:21:40.407Z" }, + { url = "https://files.pythonhosted.org/packages/61/b5/707f6cf0066a6412aacc11d17920ea2e19e5b2f04081c64526eb35b5c6e7/rpds_py-0.30.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0c0e95f6819a19965ff420f65578bacb0b00f251fefe2c8b23347c37174271f3", size = 390522, upload-time = "2025-11-30T20:21:42.17Z" }, + { url = "https://files.pythonhosted.org/packages/13/4e/57a85fda37a229ff4226f8cbcf09f2a455d1ed20e802ce5b2b4a7f5ed053/rpds_py-0.30.0-cp310-cp310-manylinux_2_31_riscv64.whl", hash = "sha256:a452763cc5198f2f98898eb98f7569649fe5da666c2dc6b5ddb10fde5a574221", size = 404579, upload-time = "2025-11-30T20:21:43.769Z" }, + { url = "https://files.pythonhosted.org/packages/f9/da/c9339293513ec680a721e0e16bf2bac3db6e5d7e922488de471308349bba/rpds_py-0.30.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e0b65193a413ccc930671c55153a03ee57cecb49e6227204b04fae512eb657a7", size = 421305, upload-time = "2025-11-30T20:21:44.994Z" }, + { url = "https://files.pythonhosted.org/packages/f9/be/522cb84751114f4ad9d822ff5a1aa3c98006341895d5f084779b99596e5c/rpds_py-0.30.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:858738e9c32147f78b3ac24dc0edb6610000e56dc0f700fd5f651d0a0f0eb9ff", size = 572503, upload-time = "2025-11-30T20:21:46.91Z" }, + { url = "https://files.pythonhosted.org/packages/a2/9b/de879f7e7ceddc973ea6e4629e9b380213a6938a249e94b0cdbcc325bb66/rpds_py-0.30.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:da279aa314f00acbb803da1e76fa18666778e8a8f83484fba94526da5de2cba7", size = 598322, upload-time = "2025-11-30T20:21:48.709Z" }, + { url = "https://files.pythonhosted.org/packages/48/ac/f01fc22efec3f37d8a914fc1b2fb9bcafd56a299edbe96406f3053edea5a/rpds_py-0.30.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:7c64d38fb49b6cdeda16ab49e35fe0da2e1e9b34bc38bd78386530f218b37139", size = 560792, upload-time = "2025-11-30T20:21:50.024Z" }, + { url = "https://files.pythonhosted.org/packages/e2/da/4e2b19d0f131f35b6146425f846563d0ce036763e38913d917187307a671/rpds_py-0.30.0-cp310-cp310-win32.whl", hash = "sha256:6de2a32a1665b93233cde140ff8b3467bdb9e2af2b91079f0333a0974d12d464", size = 221901, upload-time = "2025-11-30T20:21:51.32Z" }, + { url = "https://files.pythonhosted.org/packages/96/cb/156d7a5cf4f78a7cc571465d8aec7a3c447c94f6749c5123f08438bcf7bc/rpds_py-0.30.0-cp310-cp310-win_amd64.whl", hash = "sha256:1726859cd0de969f88dc8673bdd954185b9104e05806be64bcd87badbe313169", size = 235823, upload-time = "2025-11-30T20:21:52.505Z" }, + { url = "https://files.pythonhosted.org/packages/4d/6e/f964e88b3d2abee2a82c1ac8366da848fce1c6d834dc2132c3fda3970290/rpds_py-0.30.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:a2bffea6a4ca9f01b3f8e548302470306689684e61602aa3d141e34da06cf425", size = 370157, upload-time = "2025-11-30T20:21:53.789Z" }, + { url = "https://files.pythonhosted.org/packages/94/ba/24e5ebb7c1c82e74c4e4f33b2112a5573ddc703915b13a073737b59b86e0/rpds_py-0.30.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:dc4f992dfe1e2bc3ebc7444f6c7051b4bc13cd8e33e43511e8ffd13bf407010d", size = 359676, upload-time = "2025-11-30T20:21:55.475Z" }, + { url = "https://files.pythonhosted.org/packages/84/86/04dbba1b087227747d64d80c3b74df946b986c57af0a9f0c98726d4d7a3b/rpds_py-0.30.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:422c3cb9856d80b09d30d2eb255d0754b23e090034e1deb4083f8004bd0761e4", size = 389938, upload-time = "2025-11-30T20:21:57.079Z" }, + { url = "https://files.pythonhosted.org/packages/42/bb/1463f0b1722b7f45431bdd468301991d1328b16cffe0b1c2918eba2c4eee/rpds_py-0.30.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:07ae8a593e1c3c6b82ca3292efbe73c30b61332fd612e05abee07c79359f292f", size = 402932, upload-time = "2025-11-30T20:21:58.47Z" }, + { url = "https://files.pythonhosted.org/packages/99/ee/2520700a5c1f2d76631f948b0736cdf9b0acb25abd0ca8e889b5c62ac2e3/rpds_py-0.30.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:12f90dd7557b6bd57f40abe7747e81e0c0b119bef015ea7726e69fe550e394a4", size = 525830, upload-time = "2025-11-30T20:21:59.699Z" }, + { url = "https://files.pythonhosted.org/packages/e0/ad/bd0331f740f5705cc555a5e17fdf334671262160270962e69a2bdef3bf76/rpds_py-0.30.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:99b47d6ad9a6da00bec6aabe5a6279ecd3c06a329d4aa4771034a21e335c3a97", size = 412033, upload-time = "2025-11-30T20:22:00.991Z" }, + { url = "https://files.pythonhosted.org/packages/f8/1e/372195d326549bb51f0ba0f2ecb9874579906b97e08880e7a65c3bef1a99/rpds_py-0.30.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:33f559f3104504506a44bb666b93a33f5d33133765b0c216a5bf2f1e1503af89", size = 390828, upload-time = "2025-11-30T20:22:02.723Z" }, + { url = "https://files.pythonhosted.org/packages/ab/2b/d88bb33294e3e0c76bc8f351a3721212713629ffca1700fa94979cb3eae8/rpds_py-0.30.0-cp311-cp311-manylinux_2_31_riscv64.whl", hash = "sha256:946fe926af6e44f3697abbc305ea168c2c31d3e3ef1058cf68f379bf0335a78d", size = 404683, upload-time = "2025-11-30T20:22:04.367Z" }, + { url = "https://files.pythonhosted.org/packages/50/32/c759a8d42bcb5289c1fac697cd92f6fe01a018dd937e62ae77e0e7f15702/rpds_py-0.30.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:495aeca4b93d465efde585977365187149e75383ad2684f81519f504f5c13038", size = 421583, upload-time = "2025-11-30T20:22:05.814Z" }, + { url = "https://files.pythonhosted.org/packages/2b/81/e729761dbd55ddf5d84ec4ff1f47857f4374b0f19bdabfcf929164da3e24/rpds_py-0.30.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d9a0ca5da0386dee0655b4ccdf46119df60e0f10da268d04fe7cc87886872ba7", size = 572496, upload-time = "2025-11-30T20:22:07.713Z" }, + { url = "https://files.pythonhosted.org/packages/14/f6/69066a924c3557c9c30baa6ec3a0aa07526305684c6f86c696b08860726c/rpds_py-0.30.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:8d6d1cc13664ec13c1b84241204ff3b12f9bb82464b8ad6e7a5d3486975c2eed", size = 598669, upload-time = "2025-11-30T20:22:09.312Z" }, + { url = "https://files.pythonhosted.org/packages/5f/48/905896b1eb8a05630d20333d1d8ffd162394127b74ce0b0784ae04498d32/rpds_py-0.30.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3896fa1be39912cf0757753826bc8bdc8ca331a28a7c4ae46b7a21280b06bb85", size = 561011, upload-time = "2025-11-30T20:22:11.309Z" }, + { url = "https://files.pythonhosted.org/packages/22/16/cd3027c7e279d22e5eb431dd3c0fbc677bed58797fe7581e148f3f68818b/rpds_py-0.30.0-cp311-cp311-win32.whl", hash = "sha256:55f66022632205940f1827effeff17c4fa7ae1953d2b74a8581baaefb7d16f8c", size = 221406, upload-time = "2025-11-30T20:22:13.101Z" }, + { url = "https://files.pythonhosted.org/packages/fa/5b/e7b7aa136f28462b344e652ee010d4de26ee9fd16f1bfd5811f5153ccf89/rpds_py-0.30.0-cp311-cp311-win_amd64.whl", hash = "sha256:a51033ff701fca756439d641c0ad09a41d9242fa69121c7d8769604a0a629825", size = 236024, upload-time = "2025-11-30T20:22:14.853Z" }, + { url = "https://files.pythonhosted.org/packages/14/a6/364bba985e4c13658edb156640608f2c9e1d3ea3c81b27aa9d889fff0e31/rpds_py-0.30.0-cp311-cp311-win_arm64.whl", hash = "sha256:47b0ef6231c58f506ef0b74d44e330405caa8428e770fec25329ed2cb971a229", size = 229069, upload-time = "2025-11-30T20:22:16.577Z" }, + { url = "https://files.pythonhosted.org/packages/03/e7/98a2f4ac921d82f33e03f3835f5bf3a4a40aa1bfdc57975e74a97b2b4bdd/rpds_py-0.30.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:a161f20d9a43006833cd7068375a94d035714d73a172b681d8881820600abfad", size = 375086, upload-time = "2025-11-30T20:22:17.93Z" }, + { url = "https://files.pythonhosted.org/packages/4d/a1/bca7fd3d452b272e13335db8d6b0b3ecde0f90ad6f16f3328c6fb150c889/rpds_py-0.30.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6abc8880d9d036ecaafe709079969f56e876fcf107f7a8e9920ba6d5a3878d05", size = 359053, upload-time = "2025-11-30T20:22:19.297Z" }, + { url = "https://files.pythonhosted.org/packages/65/1c/ae157e83a6357eceff62ba7e52113e3ec4834a84cfe07fa4b0757a7d105f/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ca28829ae5f5d569bb62a79512c842a03a12576375d5ece7d2cadf8abe96ec28", size = 390763, upload-time = "2025-11-30T20:22:21.661Z" }, + { url = "https://files.pythonhosted.org/packages/d4/36/eb2eb8515e2ad24c0bd43c3ee9cd74c33f7ca6430755ccdb240fd3144c44/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a1010ed9524c73b94d15919ca4d41d8780980e1765babf85f9a2f90d247153dd", size = 408951, upload-time = "2025-11-30T20:22:23.408Z" }, + { url = "https://files.pythonhosted.org/packages/d6/65/ad8dc1784a331fabbd740ef6f71ce2198c7ed0890dab595adb9ea2d775a1/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f8d1736cfb49381ba528cd5baa46f82fdc65c06e843dab24dd70b63d09121b3f", size = 514622, upload-time = "2025-11-30T20:22:25.16Z" }, + { url = "https://files.pythonhosted.org/packages/63/8e/0cfa7ae158e15e143fe03993b5bcd743a59f541f5952e1546b1ac1b5fd45/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d948b135c4693daff7bc2dcfc4ec57237a29bd37e60c2fabf5aff2bbacf3e2f1", size = 414492, upload-time = "2025-11-30T20:22:26.505Z" }, + { url = "https://files.pythonhosted.org/packages/60/1b/6f8f29f3f995c7ffdde46a626ddccd7c63aefc0efae881dc13b6e5d5bb16/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:47f236970bccb2233267d89173d3ad2703cd36a0e2a6e92d0560d333871a3d23", size = 394080, upload-time = "2025-11-30T20:22:27.934Z" }, + { url = "https://files.pythonhosted.org/packages/6d/d5/a266341051a7a3ca2f4b750a3aa4abc986378431fc2da508c5034d081b70/rpds_py-0.30.0-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:2e6ecb5a5bcacf59c3f912155044479af1d0b6681280048b338b28e364aca1f6", size = 408680, upload-time = "2025-11-30T20:22:29.341Z" }, + { url = "https://files.pythonhosted.org/packages/10/3b/71b725851df9ab7a7a4e33cf36d241933da66040d195a84781f49c50490c/rpds_py-0.30.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a8fa71a2e078c527c3e9dc9fc5a98c9db40bcc8a92b4e8858e36d329f8684b51", size = 423589, upload-time = "2025-11-30T20:22:31.469Z" }, + { url = "https://files.pythonhosted.org/packages/00/2b/e59e58c544dc9bd8bd8384ecdb8ea91f6727f0e37a7131baeff8d6f51661/rpds_py-0.30.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:73c67f2db7bc334e518d097c6d1e6fed021bbc9b7d678d6cc433478365d1d5f5", size = 573289, upload-time = "2025-11-30T20:22:32.997Z" }, + { url = "https://files.pythonhosted.org/packages/da/3e/a18e6f5b460893172a7d6a680e86d3b6bc87a54c1f0b03446a3c8c7b588f/rpds_py-0.30.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:5ba103fb455be00f3b1c2076c9d4264bfcb037c976167a6047ed82f23153f02e", size = 599737, upload-time = "2025-11-30T20:22:34.419Z" }, + { url = "https://files.pythonhosted.org/packages/5c/e2/714694e4b87b85a18e2c243614974413c60aa107fd815b8cbc42b873d1d7/rpds_py-0.30.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:7cee9c752c0364588353e627da8a7e808a66873672bcb5f52890c33fd965b394", size = 563120, upload-time = "2025-11-30T20:22:35.903Z" }, + { url = "https://files.pythonhosted.org/packages/6f/ab/d5d5e3bcedb0a77f4f613706b750e50a5a3ba1c15ccd3665ecc636c968fd/rpds_py-0.30.0-cp312-cp312-win32.whl", hash = "sha256:1ab5b83dbcf55acc8b08fc62b796ef672c457b17dbd7820a11d6c52c06839bdf", size = 223782, upload-time = "2025-11-30T20:22:37.271Z" }, + { url = "https://files.pythonhosted.org/packages/39/3b/f786af9957306fdc38a74cef405b7b93180f481fb48453a114bb6465744a/rpds_py-0.30.0-cp312-cp312-win_amd64.whl", hash = "sha256:a090322ca841abd453d43456ac34db46e8b05fd9b3b4ac0c78bcde8b089f959b", size = 240463, upload-time = "2025-11-30T20:22:39.021Z" }, + { url = "https://files.pythonhosted.org/packages/f3/d2/b91dc748126c1559042cfe41990deb92c4ee3e2b415f6b5234969ffaf0cc/rpds_py-0.30.0-cp312-cp312-win_arm64.whl", hash = "sha256:669b1805bd639dd2989b281be2cfd951c6121b65e729d9b843e9639ef1fd555e", size = 230868, upload-time = "2025-11-30T20:22:40.493Z" }, + { url = "https://files.pythonhosted.org/packages/ed/dc/d61221eb88ff410de3c49143407f6f3147acf2538c86f2ab7ce65ae7d5f9/rpds_py-0.30.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:f83424d738204d9770830d35290ff3273fbb02b41f919870479fab14b9d303b2", size = 374887, upload-time = "2025-11-30T20:22:41.812Z" }, + { url = "https://files.pythonhosted.org/packages/fd/32/55fb50ae104061dbc564ef15cc43c013dc4a9f4527a1f4d99baddf56fe5f/rpds_py-0.30.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:e7536cd91353c5273434b4e003cbda89034d67e7710eab8761fd918ec6c69cf8", size = 358904, upload-time = "2025-11-30T20:22:43.479Z" }, + { url = "https://files.pythonhosted.org/packages/58/70/faed8186300e3b9bdd138d0273109784eea2396c68458ed580f885dfe7ad/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2771c6c15973347f50fece41fc447c054b7ac2ae0502388ce3b6738cd366e3d4", size = 389945, upload-time = "2025-11-30T20:22:44.819Z" }, + { url = "https://files.pythonhosted.org/packages/bd/a8/073cac3ed2c6387df38f71296d002ab43496a96b92c823e76f46b8af0543/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:0a59119fc6e3f460315fe9d08149f8102aa322299deaa5cab5b40092345c2136", size = 407783, upload-time = "2025-11-30T20:22:46.103Z" }, + { url = "https://files.pythonhosted.org/packages/77/57/5999eb8c58671f1c11eba084115e77a8899d6e694d2a18f69f0ba471ec8b/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:76fec018282b4ead0364022e3c54b60bf368b9d926877957a8624b58419169b7", size = 515021, upload-time = "2025-11-30T20:22:47.458Z" }, + { url = "https://files.pythonhosted.org/packages/e0/af/5ab4833eadc36c0a8ed2bc5c0de0493c04f6c06de223170bd0798ff98ced/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:692bef75a5525db97318e8cd061542b5a79812d711ea03dbc1f6f8dbb0c5f0d2", size = 414589, upload-time = "2025-11-30T20:22:48.872Z" }, + { url = "https://files.pythonhosted.org/packages/b7/de/f7192e12b21b9e9a68a6d0f249b4af3fdcdff8418be0767a627564afa1f1/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9027da1ce107104c50c81383cae773ef5c24d296dd11c99e2629dbd7967a20c6", size = 394025, upload-time = "2025-11-30T20:22:50.196Z" }, + { url = "https://files.pythonhosted.org/packages/91/c4/fc70cd0249496493500e7cc2de87504f5aa6509de1e88623431fec76d4b6/rpds_py-0.30.0-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:9cf69cdda1f5968a30a359aba2f7f9aa648a9ce4b580d6826437f2b291cfc86e", size = 408895, upload-time = "2025-11-30T20:22:51.87Z" }, + { url = "https://files.pythonhosted.org/packages/58/95/d9275b05ab96556fefff73a385813eb66032e4c99f411d0795372d9abcea/rpds_py-0.30.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a4796a717bf12b9da9d3ad002519a86063dcac8988b030e405704ef7d74d2d9d", size = 422799, upload-time = "2025-11-30T20:22:53.341Z" }, + { url = "https://files.pythonhosted.org/packages/06/c1/3088fc04b6624eb12a57eb814f0d4997a44b0d208d6cace713033ff1a6ba/rpds_py-0.30.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5d4c2aa7c50ad4728a094ebd5eb46c452e9cb7edbfdb18f9e1221f597a73e1e7", size = 572731, upload-time = "2025-11-30T20:22:54.778Z" }, + { url = "https://files.pythonhosted.org/packages/d8/42/c612a833183b39774e8ac8fecae81263a68b9583ee343db33ab571a7ce55/rpds_py-0.30.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ba81a9203d07805435eb06f536d95a266c21e5b2dfbf6517748ca40c98d19e31", size = 599027, upload-time = "2025-11-30T20:22:56.212Z" }, + { url = "https://files.pythonhosted.org/packages/5f/60/525a50f45b01d70005403ae0e25f43c0384369ad24ffe46e8d9068b50086/rpds_py-0.30.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:945dccface01af02675628334f7cf49c2af4c1c904748efc5cf7bbdf0b579f95", size = 563020, upload-time = "2025-11-30T20:22:58.2Z" }, + { url = "https://files.pythonhosted.org/packages/0b/5d/47c4655e9bcd5ca907148535c10e7d489044243cc9941c16ed7cd53be91d/rpds_py-0.30.0-cp313-cp313-win32.whl", hash = "sha256:b40fb160a2db369a194cb27943582b38f79fc4887291417685f3ad693c5a1d5d", size = 223139, upload-time = "2025-11-30T20:23:00.209Z" }, + { url = "https://files.pythonhosted.org/packages/f2/e1/485132437d20aa4d3e1d8b3fb5a5e65aa8139f1e097080c2a8443201742c/rpds_py-0.30.0-cp313-cp313-win_amd64.whl", hash = "sha256:806f36b1b605e2d6a72716f321f20036b9489d29c51c91f4dd29a3e3afb73b15", size = 240224, upload-time = "2025-11-30T20:23:02.008Z" }, + { url = "https://files.pythonhosted.org/packages/24/95/ffd128ed1146a153d928617b0ef673960130be0009c77d8fbf0abe306713/rpds_py-0.30.0-cp313-cp313-win_arm64.whl", hash = "sha256:d96c2086587c7c30d44f31f42eae4eac89b60dabbac18c7669be3700f13c3ce1", size = 230645, upload-time = "2025-11-30T20:23:03.43Z" }, + { url = "https://files.pythonhosted.org/packages/ff/1b/b10de890a0def2a319a2626334a7f0ae388215eb60914dbac8a3bae54435/rpds_py-0.30.0-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:eb0b93f2e5c2189ee831ee43f156ed34e2a89a78a66b98cadad955972548be5a", size = 364443, upload-time = "2025-11-30T20:23:04.878Z" }, + { url = "https://files.pythonhosted.org/packages/0d/bf/27e39f5971dc4f305a4fb9c672ca06f290f7c4e261c568f3dea16a410d47/rpds_py-0.30.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:922e10f31f303c7c920da8981051ff6d8c1a56207dbdf330d9047f6d30b70e5e", size = 353375, upload-time = "2025-11-30T20:23:06.342Z" }, + { url = "https://files.pythonhosted.org/packages/40/58/442ada3bba6e8e6615fc00483135c14a7538d2ffac30e2d933ccf6852232/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cdc62c8286ba9bf7f47befdcea13ea0e26bf294bda99758fd90535cbaf408000", size = 383850, upload-time = "2025-11-30T20:23:07.825Z" }, + { url = "https://files.pythonhosted.org/packages/14/14/f59b0127409a33c6ef6f5c1ebd5ad8e32d7861c9c7adfa9a624fc3889f6c/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:47f9a91efc418b54fb8190a6b4aa7813a23fb79c51f4bb84e418f5476c38b8db", size = 392812, upload-time = "2025-11-30T20:23:09.228Z" }, + { url = "https://files.pythonhosted.org/packages/b3/66/e0be3e162ac299b3a22527e8913767d869e6cc75c46bd844aa43fb81ab62/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1f3587eb9b17f3789ad50824084fa6f81921bbf9a795826570bda82cb3ed91f2", size = 517841, upload-time = "2025-11-30T20:23:11.186Z" }, + { url = "https://files.pythonhosted.org/packages/3d/55/fa3b9cf31d0c963ecf1ba777f7cf4b2a2c976795ac430d24a1f43d25a6ba/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:39c02563fc592411c2c61d26b6c5fe1e51eaa44a75aa2c8735ca88b0d9599daa", size = 408149, upload-time = "2025-11-30T20:23:12.864Z" }, + { url = "https://files.pythonhosted.org/packages/60/ca/780cf3b1a32b18c0f05c441958d3758f02544f1d613abf9488cd78876378/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:51a1234d8febafdfd33a42d97da7a43f5dcb120c1060e352a3fbc0c6d36e2083", size = 383843, upload-time = "2025-11-30T20:23:14.638Z" }, + { url = "https://files.pythonhosted.org/packages/82/86/d5f2e04f2aa6247c613da0c1dd87fcd08fa17107e858193566048a1e2f0a/rpds_py-0.30.0-cp313-cp313t-manylinux_2_31_riscv64.whl", hash = "sha256:eb2c4071ab598733724c08221091e8d80e89064cd472819285a9ab0f24bcedb9", size = 396507, upload-time = "2025-11-30T20:23:16.105Z" }, + { url = "https://files.pythonhosted.org/packages/4b/9a/453255d2f769fe44e07ea9785c8347edaf867f7026872e76c1ad9f7bed92/rpds_py-0.30.0-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:6bdfdb946967d816e6adf9a3d8201bfad269c67efe6cefd7093ef959683c8de0", size = 414949, upload-time = "2025-11-30T20:23:17.539Z" }, + { url = "https://files.pythonhosted.org/packages/a3/31/622a86cdc0c45d6df0e9ccb6becdba5074735e7033c20e401a6d9d0e2ca0/rpds_py-0.30.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:c77afbd5f5250bf27bf516c7c4a016813eb2d3e116139aed0096940c5982da94", size = 565790, upload-time = "2025-11-30T20:23:19.029Z" }, + { url = "https://files.pythonhosted.org/packages/1c/5d/15bbf0fb4a3f58a3b1c67855ec1efcc4ceaef4e86644665fff03e1b66d8d/rpds_py-0.30.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:61046904275472a76c8c90c9ccee9013d70a6d0f73eecefd38c1ae7c39045a08", size = 590217, upload-time = "2025-11-30T20:23:20.885Z" }, + { url = "https://files.pythonhosted.org/packages/6d/61/21b8c41f68e60c8cc3b2e25644f0e3681926020f11d06ab0b78e3c6bbff1/rpds_py-0.30.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:4c5f36a861bc4b7da6516dbdf302c55313afa09b81931e8280361a4f6c9a2d27", size = 555806, upload-time = "2025-11-30T20:23:22.488Z" }, + { url = "https://files.pythonhosted.org/packages/f9/39/7e067bb06c31de48de3eb200f9fc7c58982a4d3db44b07e73963e10d3be9/rpds_py-0.30.0-cp313-cp313t-win32.whl", hash = "sha256:3d4a69de7a3e50ffc214ae16d79d8fbb0922972da0356dcf4d0fdca2878559c6", size = 211341, upload-time = "2025-11-30T20:23:24.449Z" }, + { url = "https://files.pythonhosted.org/packages/0a/4d/222ef0b46443cf4cf46764d9c630f3fe4abaa7245be9417e56e9f52b8f65/rpds_py-0.30.0-cp313-cp313t-win_amd64.whl", hash = "sha256:f14fc5df50a716f7ece6a80b6c78bb35ea2ca47c499e422aa4463455dd96d56d", size = 225768, upload-time = "2025-11-30T20:23:25.908Z" }, + { url = "https://files.pythonhosted.org/packages/86/81/dad16382ebbd3d0e0328776d8fd7ca94220e4fa0798d1dc5e7da48cb3201/rpds_py-0.30.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:68f19c879420aa08f61203801423f6cd5ac5f0ac4ac82a2368a9fcd6a9a075e0", size = 362099, upload-time = "2025-11-30T20:23:27.316Z" }, + { url = "https://files.pythonhosted.org/packages/2b/60/19f7884db5d5603edf3c6bce35408f45ad3e97e10007df0e17dd57af18f8/rpds_py-0.30.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:ec7c4490c672c1a0389d319b3a9cfcd098dcdc4783991553c332a15acf7249be", size = 353192, upload-time = "2025-11-30T20:23:29.151Z" }, + { url = "https://files.pythonhosted.org/packages/bf/c4/76eb0e1e72d1a9c4703c69607cec123c29028bff28ce41588792417098ac/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f251c812357a3fed308d684a5079ddfb9d933860fc6de89f2b7ab00da481e65f", size = 384080, upload-time = "2025-11-30T20:23:30.785Z" }, + { url = "https://files.pythonhosted.org/packages/72/87/87ea665e92f3298d1b26d78814721dc39ed8d2c74b86e83348d6b48a6f31/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ac98b175585ecf4c0348fd7b29c3864bda53b805c773cbf7bfdaffc8070c976f", size = 394841, upload-time = "2025-11-30T20:23:32.209Z" }, + { url = "https://files.pythonhosted.org/packages/77/ad/7783a89ca0587c15dcbf139b4a8364a872a25f861bdb88ed99f9b0dec985/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3e62880792319dbeb7eb866547f2e35973289e7d5696c6e295476448f5b63c87", size = 516670, upload-time = "2025-11-30T20:23:33.742Z" }, + { url = "https://files.pythonhosted.org/packages/5b/3c/2882bdac942bd2172f3da574eab16f309ae10a3925644e969536553cb4ee/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4e7fc54e0900ab35d041b0601431b0a0eb495f0851a0639b6ef90f7741b39a18", size = 408005, upload-time = "2025-11-30T20:23:35.253Z" }, + { url = "https://files.pythonhosted.org/packages/ce/81/9a91c0111ce1758c92516a3e44776920b579d9a7c09b2b06b642d4de3f0f/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:47e77dc9822d3ad616c3d5759ea5631a75e5809d5a28707744ef79d7a1bcfcad", size = 382112, upload-time = "2025-11-30T20:23:36.842Z" }, + { url = "https://files.pythonhosted.org/packages/cf/8e/1da49d4a107027e5fbc64daeab96a0706361a2918da10cb41769244b805d/rpds_py-0.30.0-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:b4dc1a6ff022ff85ecafef7979a2c6eb423430e05f1165d6688234e62ba99a07", size = 399049, upload-time = "2025-11-30T20:23:38.343Z" }, + { url = "https://files.pythonhosted.org/packages/df/5a/7ee239b1aa48a127570ec03becbb29c9d5a9eb092febbd1699d567cae859/rpds_py-0.30.0-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:4559c972db3a360808309e06a74628b95eaccbf961c335c8fe0d590cf587456f", size = 415661, upload-time = "2025-11-30T20:23:40.263Z" }, + { url = "https://files.pythonhosted.org/packages/70/ea/caa143cf6b772f823bc7929a45da1fa83569ee49b11d18d0ada7f5ee6fd6/rpds_py-0.30.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:0ed177ed9bded28f8deb6ab40c183cd1192aa0de40c12f38be4d59cd33cb5c65", size = 565606, upload-time = "2025-11-30T20:23:42.186Z" }, + { url = "https://files.pythonhosted.org/packages/64/91/ac20ba2d69303f961ad8cf55bf7dbdb4763f627291ba3d0d7d67333cced9/rpds_py-0.30.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:ad1fa8db769b76ea911cb4e10f049d80bf518c104f15b3edb2371cc65375c46f", size = 591126, upload-time = "2025-11-30T20:23:44.086Z" }, + { url = "https://files.pythonhosted.org/packages/21/20/7ff5f3c8b00c8a95f75985128c26ba44503fb35b8e0259d812766ea966c7/rpds_py-0.30.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:46e83c697b1f1c72b50e5ee5adb4353eef7406fb3f2043d64c33f20ad1c2fc53", size = 553371, upload-time = "2025-11-30T20:23:46.004Z" }, + { url = "https://files.pythonhosted.org/packages/72/c7/81dadd7b27c8ee391c132a6b192111ca58d866577ce2d9b0ca157552cce0/rpds_py-0.30.0-cp314-cp314-win32.whl", hash = "sha256:ee454b2a007d57363c2dfd5b6ca4a5d7e2c518938f8ed3b706e37e5d470801ed", size = 215298, upload-time = "2025-11-30T20:23:47.696Z" }, + { url = "https://files.pythonhosted.org/packages/3e/d2/1aaac33287e8cfb07aab2e6b8ac1deca62f6f65411344f1433c55e6f3eb8/rpds_py-0.30.0-cp314-cp314-win_amd64.whl", hash = "sha256:95f0802447ac2d10bcc69f6dc28fe95fdf17940367b21d34e34c737870758950", size = 228604, upload-time = "2025-11-30T20:23:49.501Z" }, + { url = "https://files.pythonhosted.org/packages/e8/95/ab005315818cc519ad074cb7784dae60d939163108bd2b394e60dc7b5461/rpds_py-0.30.0-cp314-cp314-win_arm64.whl", hash = "sha256:613aa4771c99f03346e54c3f038e4cc574ac09a3ddfb0e8878487335e96dead6", size = 222391, upload-time = "2025-11-30T20:23:50.96Z" }, + { url = "https://files.pythonhosted.org/packages/9e/68/154fe0194d83b973cdedcdcc88947a2752411165930182ae41d983dcefa6/rpds_py-0.30.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:7e6ecfcb62edfd632e56983964e6884851786443739dbfe3582947e87274f7cb", size = 364868, upload-time = "2025-11-30T20:23:52.494Z" }, + { url = "https://files.pythonhosted.org/packages/83/69/8bbc8b07ec854d92a8b75668c24d2abcb1719ebf890f5604c61c9369a16f/rpds_py-0.30.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:a1d0bc22a7cdc173fedebb73ef81e07faef93692b8c1ad3733b67e31e1b6e1b8", size = 353747, upload-time = "2025-11-30T20:23:54.036Z" }, + { url = "https://files.pythonhosted.org/packages/ab/00/ba2e50183dbd9abcce9497fa5149c62b4ff3e22d338a30d690f9af970561/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0d08f00679177226c4cb8c5265012eea897c8ca3b93f429e546600c971bcbae7", size = 383795, upload-time = "2025-11-30T20:23:55.556Z" }, + { url = "https://files.pythonhosted.org/packages/05/6f/86f0272b84926bcb0e4c972262f54223e8ecc556b3224d281e6598fc9268/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5965af57d5848192c13534f90f9dd16464f3c37aaf166cc1da1cae1fd5a34898", size = 393330, upload-time = "2025-11-30T20:23:57.033Z" }, + { url = "https://files.pythonhosted.org/packages/cb/e9/0e02bb2e6dc63d212641da45df2b0bf29699d01715913e0d0f017ee29438/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9a4e86e34e9ab6b667c27f3211ca48f73dba7cd3d90f8d5b11be56e5dbc3fb4e", size = 518194, upload-time = "2025-11-30T20:23:58.637Z" }, + { url = "https://files.pythonhosted.org/packages/ee/ca/be7bca14cf21513bdf9c0606aba17d1f389ea2b6987035eb4f62bd923f25/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e5d3e6b26f2c785d65cc25ef1e5267ccbe1b069c5c21b8cc724efee290554419", size = 408340, upload-time = "2025-11-30T20:24:00.2Z" }, + { url = "https://files.pythonhosted.org/packages/c2/c7/736e00ebf39ed81d75544c0da6ef7b0998f8201b369acf842f9a90dc8fce/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:626a7433c34566535b6e56a1b39a7b17ba961e97ce3b80ec62e6f1312c025551", size = 383765, upload-time = "2025-11-30T20:24:01.759Z" }, + { url = "https://files.pythonhosted.org/packages/4a/3f/da50dfde9956aaf365c4adc9533b100008ed31aea635f2b8d7b627e25b49/rpds_py-0.30.0-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:acd7eb3f4471577b9b5a41baf02a978e8bdeb08b4b355273994f8b87032000a8", size = 396834, upload-time = "2025-11-30T20:24:03.687Z" }, + { url = "https://files.pythonhosted.org/packages/4e/00/34bcc2565b6020eab2623349efbdec810676ad571995911f1abdae62a3a0/rpds_py-0.30.0-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:fe5fa731a1fa8a0a56b0977413f8cacac1768dad38d16b3a296712709476fbd5", size = 415470, upload-time = "2025-11-30T20:24:05.232Z" }, + { url = "https://files.pythonhosted.org/packages/8c/28/882e72b5b3e6f718d5453bd4d0d9cf8df36fddeb4ddbbab17869d5868616/rpds_py-0.30.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:74a3243a411126362712ee1524dfc90c650a503502f135d54d1b352bd01f2404", size = 565630, upload-time = "2025-11-30T20:24:06.878Z" }, + { url = "https://files.pythonhosted.org/packages/3b/97/04a65539c17692de5b85c6e293520fd01317fd878ea1995f0367d4532fb1/rpds_py-0.30.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:3e8eeb0544f2eb0d2581774be4c3410356eba189529a6b3e36bbbf9696175856", size = 591148, upload-time = "2025-11-30T20:24:08.445Z" }, + { url = "https://files.pythonhosted.org/packages/85/70/92482ccffb96f5441aab93e26c4d66489eb599efdcf96fad90c14bbfb976/rpds_py-0.30.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:dbd936cde57abfee19ab3213cf9c26be06d60750e60a8e4dd85d1ab12c8b1f40", size = 556030, upload-time = "2025-11-30T20:24:10.956Z" }, + { url = "https://files.pythonhosted.org/packages/20/53/7c7e784abfa500a2b6b583b147ee4bb5a2b3747a9166bab52fec4b5b5e7d/rpds_py-0.30.0-cp314-cp314t-win32.whl", hash = "sha256:dc824125c72246d924f7f796b4f63c1e9dc810c7d9e2355864b3c3a73d59ade0", size = 211570, upload-time = "2025-11-30T20:24:12.735Z" }, + { url = "https://files.pythonhosted.org/packages/d0/02/fa464cdfbe6b26e0600b62c528b72d8608f5cc49f96b8d6e38c95d60c676/rpds_py-0.30.0-cp314-cp314t-win_amd64.whl", hash = "sha256:27f4b0e92de5bfbc6f86e43959e6edd1425c33b5e69aab0984a72047f2bcf1e3", size = 226532, upload-time = "2025-11-30T20:24:14.634Z" }, + { url = "https://files.pythonhosted.org/packages/69/71/3f34339ee70521864411f8b6992e7ab13ac30d8e4e3309e07c7361767d91/rpds_py-0.30.0-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:c2262bdba0ad4fc6fb5545660673925c2d2a5d9e2e0fb603aad545427be0fc58", size = 372292, upload-time = "2025-11-30T20:24:16.537Z" }, + { url = "https://files.pythonhosted.org/packages/57/09/f183df9b8f2d66720d2ef71075c59f7e1b336bec7ee4c48f0a2b06857653/rpds_py-0.30.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:ee6af14263f25eedc3bb918a3c04245106a42dfd4f5c2285ea6f997b1fc3f89a", size = 362128, upload-time = "2025-11-30T20:24:18.086Z" }, + { url = "https://files.pythonhosted.org/packages/7a/68/5c2594e937253457342e078f0cc1ded3dd7b2ad59afdbf2d354869110a02/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3adbb8179ce342d235c31ab8ec511e66c73faa27a47e076ccc92421add53e2bb", size = 391542, upload-time = "2025-11-30T20:24:20.092Z" }, + { url = "https://files.pythonhosted.org/packages/49/5c/31ef1afd70b4b4fbdb2800249f34c57c64beb687495b10aec0365f53dfc4/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:250fa00e9543ac9b97ac258bd37367ff5256666122c2d0f2bc97577c60a1818c", size = 404004, upload-time = "2025-11-30T20:24:22.231Z" }, + { url = "https://files.pythonhosted.org/packages/e3/63/0cfbea38d05756f3440ce6534d51a491d26176ac045e2707adc99bb6e60a/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9854cf4f488b3d57b9aaeb105f06d78e5529d3145b1e4a41750167e8c213c6d3", size = 527063, upload-time = "2025-11-30T20:24:24.302Z" }, + { url = "https://files.pythonhosted.org/packages/42/e6/01e1f72a2456678b0f618fc9a1a13f882061690893c192fcad9f2926553a/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:993914b8e560023bc0a8bf742c5f303551992dcb85e247b1e5c7f4a7d145bda5", size = 413099, upload-time = "2025-11-30T20:24:25.916Z" }, + { url = "https://files.pythonhosted.org/packages/b8/25/8df56677f209003dcbb180765520c544525e3ef21ea72279c98b9aa7c7fb/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58edca431fb9b29950807e301826586e5bbf24163677732429770a697ffe6738", size = 392177, upload-time = "2025-11-30T20:24:27.834Z" }, + { url = "https://files.pythonhosted.org/packages/4a/b4/0a771378c5f16f8115f796d1f437950158679bcd2a7c68cf251cfb00ed5b/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_31_riscv64.whl", hash = "sha256:dea5b552272a944763b34394d04577cf0f9bd013207bc32323b5a89a53cf9c2f", size = 406015, upload-time = "2025-11-30T20:24:29.457Z" }, + { url = "https://files.pythonhosted.org/packages/36/d8/456dbba0af75049dc6f63ff295a2f92766b9d521fa00de67a2bd6427d57a/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:ba3af48635eb83d03f6c9735dfb21785303e73d22ad03d489e88adae6eab8877", size = 423736, upload-time = "2025-11-30T20:24:31.22Z" }, + { url = "https://files.pythonhosted.org/packages/13/64/b4d76f227d5c45a7e0b796c674fd81b0a6c4fbd48dc29271857d8219571c/rpds_py-0.30.0-pp311-pypy311_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:dff13836529b921e22f15cb099751209a60009731a68519630a24d61f0b1b30a", size = 573981, upload-time = "2025-11-30T20:24:32.934Z" }, + { url = "https://files.pythonhosted.org/packages/20/91/092bacadeda3edf92bf743cc96a7be133e13a39cdbfd7b5082e7ab638406/rpds_py-0.30.0-pp311-pypy311_pp73-musllinux_1_2_i686.whl", hash = "sha256:1b151685b23929ab7beec71080a8889d4d6d9fa9a983d213f07121205d48e2c4", size = 599782, upload-time = "2025-11-30T20:24:35.169Z" }, + { url = "https://files.pythonhosted.org/packages/d1/b7/b95708304cd49b7b6f82fdd039f1748b66ec2b21d6a45180910802f1abf1/rpds_py-0.30.0-pp311-pypy311_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:ac37f9f516c51e5753f27dfdef11a88330f04de2d564be3991384b2f3535d02e", size = 562191, upload-time = "2025-11-30T20:24:36.853Z" }, +] + +[[package]] +name = "rsa" +version = "4.9.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pyasn1" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/da/8a/22b7beea3ee0d44b1916c0c1cb0ee3af23b700b6da9f04991899d0c555d4/rsa-4.9.1.tar.gz", hash = "sha256:e7bdbfdb5497da4c07dfd35530e1a902659db6ff241e39d9953cad06ebd0ae75", size = 29034, upload-time = "2025-04-16T09:51:18.218Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/64/8d/0133e4eb4beed9e425d9a98ed6e081a55d195481b7632472be1af08d2f6b/rsa-4.9.1-py3-none-any.whl", hash = "sha256:68635866661c6836b8d39430f97a996acbd61bfa49406748ea243539fe239762", size = 34696, upload-time = "2025-04-16T09:51:17.142Z" }, +] + +[[package]] +name = "ruff" +version = "0.14.8" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ed/d9/f7a0c4b3a2bf2556cd5d99b05372c29980249ef71e8e32669ba77428c82c/ruff-0.14.8.tar.gz", hash = "sha256:774ed0dd87d6ce925e3b8496feb3a00ac564bea52b9feb551ecd17e0a23d1eed", size = 5765385, upload-time = "2025-12-04T15:06:17.669Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/48/b8/9537b52010134b1d2b72870cc3f92d5fb759394094741b09ceccae183fbe/ruff-0.14.8-py3-none-linux_armv6l.whl", hash = "sha256:ec071e9c82eca417f6111fd39f7043acb53cd3fde9b1f95bbed745962e345afb", size = 13441540, upload-time = "2025-12-04T15:06:14.896Z" }, + { url = "https://files.pythonhosted.org/packages/24/00/99031684efb025829713682012b6dd37279b1f695ed1b01725f85fd94b38/ruff-0.14.8-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:8cdb162a7159f4ca36ce980a18c43d8f036966e7f73f866ac8f493b75e0c27e9", size = 13669384, upload-time = "2025-12-04T15:06:51.809Z" }, + { url = "https://files.pythonhosted.org/packages/72/64/3eb5949169fc19c50c04f28ece2c189d3b6edd57e5b533649dae6ca484fe/ruff-0.14.8-py3-none-macosx_11_0_arm64.whl", hash = "sha256:2e2fcbefe91f9fad0916850edf0854530c15bd1926b6b779de47e9ab619ea38f", size = 12806917, upload-time = "2025-12-04T15:06:08.925Z" }, + { url = "https://files.pythonhosted.org/packages/c4/08/5250babb0b1b11910f470370ec0cbc67470231f7cdc033cee57d4976f941/ruff-0.14.8-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a9d70721066a296f45786ec31916dc287b44040f553da21564de0ab4d45a869b", size = 13256112, upload-time = "2025-12-04T15:06:23.498Z" }, + { url = "https://files.pythonhosted.org/packages/78/4c/6c588e97a8e8c2d4b522c31a579e1df2b4d003eddfbe23d1f262b1a431ff/ruff-0.14.8-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2c87e09b3cd9d126fc67a9ecd3b5b1d3ded2b9c7fce3f16e315346b9d05cfb52", size = 13227559, upload-time = "2025-12-04T15:06:33.432Z" }, + { url = "https://files.pythonhosted.org/packages/23/ce/5f78cea13eda8eceac71b5f6fa6e9223df9b87bb2c1891c166d1f0dce9f1/ruff-0.14.8-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1d62cb310c4fbcb9ee4ac023fe17f984ae1e12b8a4a02e3d21489f9a2a5f730c", size = 13896379, upload-time = "2025-12-04T15:06:02.687Z" }, + { url = "https://files.pythonhosted.org/packages/cf/79/13de4517c4dadce9218a20035b21212a4c180e009507731f0d3b3f5df85a/ruff-0.14.8-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:1af35c2d62633d4da0521178e8a2641c636d2a7153da0bac1b30cfd4ccd91344", size = 15372786, upload-time = "2025-12-04T15:06:29.828Z" }, + { url = "https://files.pythonhosted.org/packages/00/06/33df72b3bb42be8a1c3815fd4fae83fa2945fc725a25d87ba3e42d1cc108/ruff-0.14.8-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:25add4575ffecc53d60eed3f24b1e934493631b48ebbc6ebaf9d8517924aca4b", size = 14990029, upload-time = "2025-12-04T15:06:36.812Z" }, + { url = "https://files.pythonhosted.org/packages/64/61/0f34927bd90925880394de0e081ce1afab66d7b3525336f5771dcf0cb46c/ruff-0.14.8-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4c943d847b7f02f7db4201a0600ea7d244d8a404fbb639b439e987edcf2baf9a", size = 14407037, upload-time = "2025-12-04T15:06:39.979Z" }, + { url = "https://files.pythonhosted.org/packages/96/bc/058fe0aefc0fbf0d19614cb6d1a3e2c048f7dc77ca64957f33b12cfdc5ef/ruff-0.14.8-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cb6e8bf7b4f627548daa1b69283dac5a296bfe9ce856703b03130732e20ddfe2", size = 14102390, upload-time = "2025-12-04T15:06:46.372Z" }, + { url = "https://files.pythonhosted.org/packages/af/a4/e4f77b02b804546f4c17e8b37a524c27012dd6ff05855d2243b49a7d3cb9/ruff-0.14.8-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:7aaf2974f378e6b01d1e257c6948207aec6a9b5ba53fab23d0182efb887a0e4a", size = 14230793, upload-time = "2025-12-04T15:06:20.497Z" }, + { url = "https://files.pythonhosted.org/packages/3f/52/bb8c02373f79552e8d087cedaffad76b8892033d2876c2498a2582f09dcf/ruff-0.14.8-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:e5758ca513c43ad8a4ef13f0f081f80f08008f410790f3611a21a92421ab045b", size = 13160039, upload-time = "2025-12-04T15:06:49.06Z" }, + { url = "https://files.pythonhosted.org/packages/1f/ad/b69d6962e477842e25c0b11622548df746290cc6d76f9e0f4ed7456c2c31/ruff-0.14.8-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:f74f7ba163b6e85a8d81a590363bf71618847e5078d90827749bfda1d88c9cdf", size = 13205158, upload-time = "2025-12-04T15:06:54.574Z" }, + { url = "https://files.pythonhosted.org/packages/06/63/54f23da1315c0b3dfc1bc03fbc34e10378918a20c0b0f086418734e57e74/ruff-0.14.8-py3-none-musllinux_1_2_i686.whl", hash = "sha256:eed28f6fafcc9591994c42254f5a5c5ca40e69a30721d2ab18bb0bb3baac3ab6", size = 13469550, upload-time = "2025-12-04T15:05:59.209Z" }, + { url = "https://files.pythonhosted.org/packages/70/7d/a4d7b1961e4903bc37fffb7ddcfaa7beb250f67d97cfd1ee1d5cddb1ec90/ruff-0.14.8-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:21d48fa744c9d1cb8d71eb0a740c4dd02751a5de9db9a730a8ef75ca34cf138e", size = 14211332, upload-time = "2025-12-04T15:06:06.027Z" }, + { url = "https://files.pythonhosted.org/packages/5d/93/2a5063341fa17054e5c86582136e9895db773e3c2ffb770dde50a09f35f0/ruff-0.14.8-py3-none-win32.whl", hash = "sha256:15f04cb45c051159baebb0f0037f404f1dc2f15a927418f29730f411a79bc4e7", size = 13151890, upload-time = "2025-12-04T15:06:11.668Z" }, + { url = "https://files.pythonhosted.org/packages/02/1c/65c61a0859c0add13a3e1cbb6024b42de587456a43006ca2d4fd3d1618fe/ruff-0.14.8-py3-none-win_amd64.whl", hash = "sha256:9eeb0b24242b5bbff3011409a739929f497f3fb5fe3b5698aba5e77e8c833097", size = 14537826, upload-time = "2025-12-04T15:06:26.409Z" }, + { url = "https://files.pythonhosted.org/packages/6d/63/8b41cea3afd7f58eb64ac9251668ee0073789a3bc9ac6f816c8c6fef986d/ruff-0.14.8-py3-none-win_arm64.whl", hash = "sha256:965a582c93c63fe715fd3e3f8aa37c4b776777203d8e1d8aa3cc0c14424a4b99", size = 13634522, upload-time = "2025-12-04T15:06:43.212Z" }, +] + +[[package]] +name = "s3fs" +version = "2025.10.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "aiobotocore" }, + { name = "aiohttp" }, + { name = "fsspec" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/bb/ee/7cf7de3b17ef6db10b027cc9f8a1108ceb6333e267943e666a35882b1474/s3fs-2025.10.0.tar.gz", hash = "sha256:e8be6cddc77aceea1681ece0f472c3a7f8ef71a0d2acddb1cc92bb6afa3e9e4f", size = 80383, upload-time = "2025-10-30T15:06:04.647Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2d/fc/56cba14af8ad8fd020c85b6e44328520ac55939bb1f9d01444ad470504cb/s3fs-2025.10.0-py3-none-any.whl", hash = "sha256:da7ef25efc1541f5fca8e1116361e49ea1081f83f4e8001fbd77347c625da28a", size = 30357, upload-time = "2025-10-30T15:06:03.48Z" }, +] + +[[package]] +name = "safetensors" +version = "0.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/29/9c/6e74567782559a63bd040a236edca26fd71bc7ba88de2ef35d75df3bca5e/safetensors-0.7.0.tar.gz", hash = "sha256:07663963b67e8bd9f0b8ad15bb9163606cd27cc5a1b96235a50d8369803b96b0", size = 200878, upload-time = "2025-11-19T15:18:43.199Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fa/47/aef6c06649039accf914afef490268e1067ed82be62bcfa5b7e886ad15e8/safetensors-0.7.0-cp38-abi3-macosx_10_12_x86_64.whl", hash = "sha256:c82f4d474cf725255d9e6acf17252991c3c8aac038d6ef363a4bf8be2f6db517", size = 467781, upload-time = "2025-11-19T15:18:35.84Z" }, + { url = "https://files.pythonhosted.org/packages/e8/00/374c0c068e30cd31f1e1b46b4b5738168ec79e7689ca82ee93ddfea05109/safetensors-0.7.0-cp38-abi3-macosx_11_0_arm64.whl", hash = "sha256:94fd4858284736bb67a897a41608b5b0c2496c9bdb3bf2af1fa3409127f20d57", size = 447058, upload-time = "2025-11-19T15:18:34.416Z" }, + { url = "https://files.pythonhosted.org/packages/f1/06/578ffed52c2296f93d7fd2d844cabfa92be51a587c38c8afbb8ae449ca89/safetensors-0.7.0-cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e07d91d0c92a31200f25351f4acb2bc6aff7f48094e13ebb1d0fb995b54b6542", size = 491748, upload-time = "2025-11-19T15:18:09.79Z" }, + { url = "https://files.pythonhosted.org/packages/ae/33/1debbbb70e4791dde185edb9413d1fe01619255abb64b300157d7f15dddd/safetensors-0.7.0-cp38-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8469155f4cb518bafb4acf4865e8bb9d6804110d2d9bdcaa78564b9fd841e104", size = 503881, upload-time = "2025-11-19T15:18:16.145Z" }, + { url = "https://files.pythonhosted.org/packages/8e/1c/40c2ca924d60792c3be509833df711b553c60effbd91da6f5284a83f7122/safetensors-0.7.0-cp38-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:54bef08bf00a2bff599982f6b08e8770e09cc012d7bba00783fc7ea38f1fb37d", size = 623463, upload-time = "2025-11-19T15:18:21.11Z" }, + { url = "https://files.pythonhosted.org/packages/9b/3a/13784a9364bd43b0d61eef4bea2845039bc2030458b16594a1bd787ae26e/safetensors-0.7.0-cp38-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:42cb091236206bb2016d245c377ed383aa7f78691748f3bb6ee1bfa51ae2ce6a", size = 532855, upload-time = "2025-11-19T15:18:25.719Z" }, + { url = "https://files.pythonhosted.org/packages/a0/60/429e9b1cb3fc651937727befe258ea24122d9663e4d5709a48c9cbfceecb/safetensors-0.7.0-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dac7252938f0696ddea46f5e855dd3138444e82236e3be475f54929f0c510d48", size = 507152, upload-time = "2025-11-19T15:18:33.023Z" }, + { url = "https://files.pythonhosted.org/packages/3c/a8/4b45e4e059270d17af60359713ffd83f97900d45a6afa73aaa0d737d48b6/safetensors-0.7.0-cp38-abi3-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1d060c70284127fa805085d8f10fbd0962792aed71879d00864acda69dbab981", size = 541856, upload-time = "2025-11-19T15:18:31.075Z" }, + { url = "https://files.pythonhosted.org/packages/06/87/d26d8407c44175d8ae164a95b5a62707fcc445f3c0c56108e37d98070a3d/safetensors-0.7.0-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:cdab83a366799fa730f90a4ebb563e494f28e9e92c4819e556152ad55e43591b", size = 674060, upload-time = "2025-11-19T15:18:37.211Z" }, + { url = "https://files.pythonhosted.org/packages/11/f5/57644a2ff08dc6325816ba7217e5095f17269dada2554b658442c66aed51/safetensors-0.7.0-cp38-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:672132907fcad9f2aedcb705b2d7b3b93354a2aec1b2f706c4db852abe338f85", size = 771715, upload-time = "2025-11-19T15:18:38.689Z" }, + { url = "https://files.pythonhosted.org/packages/86/31/17883e13a814bd278ae6e266b13282a01049b0c81341da7fd0e3e71a80a3/safetensors-0.7.0-cp38-abi3-musllinux_1_2_i686.whl", hash = "sha256:5d72abdb8a4d56d4020713724ba81dac065fedb7f3667151c4a637f1d3fb26c0", size = 714377, upload-time = "2025-11-19T15:18:40.162Z" }, + { url = "https://files.pythonhosted.org/packages/4a/d8/0c8a7dc9b41dcac53c4cbf9df2b9c83e0e0097203de8b37a712b345c0be5/safetensors-0.7.0-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:b0f6d66c1c538d5a94a73aa9ddca8ccc4227e6c9ff555322ea40bdd142391dd4", size = 677368, upload-time = "2025-11-19T15:18:41.627Z" }, + { url = "https://files.pythonhosted.org/packages/05/e5/cb4b713c8a93469e3c5be7c3f8d77d307e65fe89673e731f5c2bfd0a9237/safetensors-0.7.0-cp38-abi3-win32.whl", hash = "sha256:c74af94bf3ac15ac4d0f2a7c7b4663a15f8c2ab15ed0fc7531ca61d0835eccba", size = 326423, upload-time = "2025-11-19T15:18:45.74Z" }, + { url = "https://files.pythonhosted.org/packages/5d/e6/ec8471c8072382cb91233ba7267fd931219753bb43814cbc71757bfd4dab/safetensors-0.7.0-cp38-abi3-win_amd64.whl", hash = "sha256:d1239932053f56f3456f32eb9625590cc7582e905021f94636202a864d470755", size = 341380, upload-time = "2025-11-19T15:18:44.427Z" }, + { url = "https://files.pythonhosted.org/packages/a7/6a/4d08d89a6fcbe905c5ae68b8b34f0791850882fc19782d0d02c65abbdf3b/safetensors-0.7.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f4729811a6640d019a4b7ba8638ee2fd21fa5ca8c7e7bdf0fed62068fcaac737", size = 492430, upload-time = "2025-11-19T15:18:11.884Z" }, + { url = "https://files.pythonhosted.org/packages/dd/29/59ed8152b30f72c42d00d241e58eaca558ae9dbfa5695206e2e0f54c7063/safetensors-0.7.0-pp310-pypy310_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:12f49080303fa6bb424b362149a12949dfbbf1e06811a88f2307276b0c131afd", size = 503977, upload-time = "2025-11-19T15:18:17.523Z" }, + { url = "https://files.pythonhosted.org/packages/d3/0b/4811bfec67fa260e791369b16dab105e4bae82686120554cc484064e22b4/safetensors-0.7.0-pp310-pypy310_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0071bffba4150c2f46cae1432d31995d77acfd9f8db598b5d1a2ce67e8440ad2", size = 623890, upload-time = "2025-11-19T15:18:22.666Z" }, + { url = "https://files.pythonhosted.org/packages/58/5b/632a58724221ef03d78ab65062e82a1010e1bef8e8e0b9d7c6d7b8044841/safetensors-0.7.0-pp310-pypy310_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:473b32699f4200e69801bf5abf93f1a4ecd432a70984df164fc22ccf39c4a6f3", size = 531885, upload-time = "2025-11-19T15:18:27.146Z" }, +] + +[[package]] +name = "sentencepiece" +version = "0.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/15/15/2e7a025fc62d764b151ae6d0f2a92f8081755ebe8d4a64099accc6f77ba6/sentencepiece-0.2.1.tar.gz", hash = "sha256:8138cec27c2f2282f4a34d9a016e3374cd40e5c6e9cb335063db66a0a3b71fad", size = 3228515, upload-time = "2025-08-12T07:00:51.718Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/af/31/5b7cccb307b485db1a2372d6d2980b0a65d067f8be5ca943a103b4acd5b3/sentencepiece-0.2.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:e10fa50bdbaa5e2445dbd387979980d391760faf0ec99a09bd7780ff37eaec44", size = 1942557, upload-time = "2025-08-12T06:59:12.379Z" }, + { url = "https://files.pythonhosted.org/packages/1f/41/0ac923a8e685ad290c5afc8ae55c5844977b8d75076fcc04302b9a324274/sentencepiece-0.2.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:2f27ae6deea72efdb6f361750c92f6c21fd0ad087445082770cc34015213c526", size = 1325384, upload-time = "2025-08-12T06:59:14.334Z" }, + { url = "https://files.pythonhosted.org/packages/fc/ef/3751555d67daf9003384978f169d31c775cb5c7baf28633caaf1eb2b2b4d/sentencepiece-0.2.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:60937c959e6f44159fdd9f56fbdd302501f96114a5ba436829496d5f32d8de3f", size = 1253317, upload-time = "2025-08-12T06:59:16.247Z" }, + { url = "https://files.pythonhosted.org/packages/46/a5/742c69b7bd144eb32b6e5fd50dbd8abbbc7a95fce2fe16e50156fa400e3b/sentencepiece-0.2.1-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d8b1d91545578852f128650b8cce4ec20f93d39b378ff554ebe66290f2dabb92", size = 1316379, upload-time = "2025-08-12T06:59:17.825Z" }, + { url = "https://files.pythonhosted.org/packages/c8/89/8deeafbba2871e8fa10f20f17447786f4ac38085925335728d360eaf4cae/sentencepiece-0.2.1-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:27e38eee653abc3d387862e67bc5c8b6f428cd604e688b85d29170b7e725c26c", size = 1387926, upload-time = "2025-08-12T06:59:19.395Z" }, + { url = "https://files.pythonhosted.org/packages/c3/ca/67fe73005f0ab617c6a970b199754e28e524b6873aa7025224fad3cda252/sentencepiece-0.2.1-cp310-cp310-win32.whl", hash = "sha256:251874d720ac7f28024a168501f3c7bb15d1802245f6e66de565f18bbb9b5eaa", size = 999550, upload-time = "2025-08-12T06:59:20.844Z" }, + { url = "https://files.pythonhosted.org/packages/6d/33/dc5b54042050d2dda4229c3ce1f862541c99966390b6aa20f54d520d2dc2/sentencepiece-0.2.1-cp310-cp310-win_amd64.whl", hash = "sha256:e52144670738b4b477fade6c2a9b6af71a8d0094514c9853ac9f6fc1fcfabae7", size = 1054613, upload-time = "2025-08-12T06:59:22.255Z" }, + { url = "https://files.pythonhosted.org/packages/fa/19/1ea47f46ff97fe04422b78997da1a37cd632f414aae042d27a9009c5b733/sentencepiece-0.2.1-cp310-cp310-win_arm64.whl", hash = "sha256:9076430ac25dfa7147d9d05751dbc66a04bc1aaac371c07f84952979ea59f0d0", size = 1033884, upload-time = "2025-08-12T06:59:24.194Z" }, + { url = "https://files.pythonhosted.org/packages/d8/15/46afbab00733d81788b64be430ca1b93011bb9388527958e26cc31832de5/sentencepiece-0.2.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:6356d0986b8b8dc351b943150fcd81a1c6e6e4d439772e8584c64230e58ca987", size = 1942560, upload-time = "2025-08-12T06:59:25.82Z" }, + { url = "https://files.pythonhosted.org/packages/fa/79/7c01b8ef98a0567e9d84a4e7a910f8e7074fcbf398a5cd76f93f4b9316f9/sentencepiece-0.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:8f8ba89a3acb3dc1ae90f65ec1894b0b9596fdb98ab003ff38e058f898b39bc7", size = 1325385, upload-time = "2025-08-12T06:59:27.722Z" }, + { url = "https://files.pythonhosted.org/packages/bb/88/2b41e07bd24f33dcf2f18ec3b74247aa4af3526bad8907b8727ea3caba03/sentencepiece-0.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:02593eca45440ef39247cee8c47322a34bdcc1d8ae83ad28ba5a899a2cf8d79a", size = 1253319, upload-time = "2025-08-12T06:59:29.306Z" }, + { url = "https://files.pythonhosted.org/packages/a0/54/38a1af0c6210a3c6f95aa46d23d6640636d020fba7135cd0d9a84ada05a7/sentencepiece-0.2.1-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0a0d15781a171d188b661ae4bde1d998c303f6bd8621498c50c671bd45a4798e", size = 1316162, upload-time = "2025-08-12T06:59:30.914Z" }, + { url = "https://files.pythonhosted.org/packages/ef/66/fb191403ade791ad2c3c1e72fe8413e63781b08cfa3aa4c9dfc536d6e795/sentencepiece-0.2.1-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4f5a3e0d9f445ed9d66c0fec47d4b23d12cfc858b407a03c194c1b26c2ac2a63", size = 1387785, upload-time = "2025-08-12T06:59:32.491Z" }, + { url = "https://files.pythonhosted.org/packages/a9/2d/3bd9b08e70067b2124518b308db6a84a4f8901cc8a4317e2e4288cdd9b4d/sentencepiece-0.2.1-cp311-cp311-win32.whl", hash = "sha256:6d297a1748d429ba8534eebe5535448d78b8acc32d00a29b49acf28102eeb094", size = 999555, upload-time = "2025-08-12T06:59:34.475Z" }, + { url = "https://files.pythonhosted.org/packages/32/b8/f709977f5fda195ae1ea24f24e7c581163b6f142b1005bc3d0bbfe4d7082/sentencepiece-0.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:82d9ead6591015f009cb1be1cb1c015d5e6f04046dbb8c9588b931e869a29728", size = 1054617, upload-time = "2025-08-12T06:59:36.461Z" }, + { url = "https://files.pythonhosted.org/packages/7a/40/a1fc23be23067da0f703709797b464e8a30a1c78cc8a687120cd58d4d509/sentencepiece-0.2.1-cp311-cp311-win_arm64.whl", hash = "sha256:39f8651bd10974eafb9834ce30d9bcf5b73e1fc798a7f7d2528f9820ca86e119", size = 1033877, upload-time = "2025-08-12T06:59:38.391Z" }, + { url = "https://files.pythonhosted.org/packages/4a/be/32ce495aa1d0e0c323dcb1ba87096037358edee539cac5baf8755a6bd396/sentencepiece-0.2.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:57cae326c8727de58c85977b175af132a7138d84c764635d7e71bbee7e774133", size = 1943152, upload-time = "2025-08-12T06:59:40.048Z" }, + { url = "https://files.pythonhosted.org/packages/88/7e/ff23008899a58678e98c6ff592bf4d368eee5a71af96d0df6b38a039dd4f/sentencepiece-0.2.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:56dd39a3c4d6493db3cdca7e8cc68c6b633f0d4195495cbadfcf5af8a22d05a6", size = 1325651, upload-time = "2025-08-12T06:59:41.536Z" }, + { url = "https://files.pythonhosted.org/packages/19/84/42eb3ce4796777a1b5d3699dfd4dca85113e68b637f194a6c8d786f16a04/sentencepiece-0.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:d9381351182ff9888cc80e41c632e7e274b106f450de33d67a9e8f6043da6f76", size = 1253645, upload-time = "2025-08-12T06:59:42.903Z" }, + { url = "https://files.pythonhosted.org/packages/89/fa/d3d5ebcba3cb9e6d3775a096251860c41a6bc53a1b9461151df83fe93255/sentencepiece-0.2.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:99f955df238021bf11f0fc37cdb54fd5e5b5f7fd30ecc3d93fb48b6815437167", size = 1316273, upload-time = "2025-08-12T06:59:44.476Z" }, + { url = "https://files.pythonhosted.org/packages/04/88/14f2f4a2b922d8b39be45bf63d79e6cd3a9b2f248b2fcb98a69b12af12f5/sentencepiece-0.2.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0cdfecef430d985f1c2bcbfff3defd1d95dae876fbd0173376012d2d7d24044b", size = 1387881, upload-time = "2025-08-12T06:59:46.09Z" }, + { url = "https://files.pythonhosted.org/packages/fd/b8/903e5ccb77b4ef140605d5d71b4f9e0ad95d456d6184688073ed11712809/sentencepiece-0.2.1-cp312-cp312-win32.whl", hash = "sha256:a483fd29a34c3e34c39ac5556b0a90942bec253d260235729e50976f5dba1068", size = 999540, upload-time = "2025-08-12T06:59:48.023Z" }, + { url = "https://files.pythonhosted.org/packages/2d/81/92df5673c067148c2545b1bfe49adfd775bcc3a169a047f5a0e6575ddaca/sentencepiece-0.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:4cdc7c36234fda305e85c32949c5211faaf8dd886096c7cea289ddc12a2d02de", size = 1054671, upload-time = "2025-08-12T06:59:49.895Z" }, + { url = "https://files.pythonhosted.org/packages/fe/02/c5e3bc518655d714622bec87d83db9cdba1cd0619a4a04e2109751c4f47f/sentencepiece-0.2.1-cp312-cp312-win_arm64.whl", hash = "sha256:daeb5e9e9fcad012324807856113708614d534f596d5008638eb9b40112cd9e4", size = 1033923, upload-time = "2025-08-12T06:59:51.952Z" }, + { url = "https://files.pythonhosted.org/packages/ba/4a/85fbe1706d4d04a7e826b53f327c4b80f849cf1c7b7c5e31a20a97d8f28b/sentencepiece-0.2.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:dcd8161eee7b41aae57ded06272905dbd680a0a04b91edd0f64790c796b2f706", size = 1943150, upload-time = "2025-08-12T06:59:53.588Z" }, + { url = "https://files.pythonhosted.org/packages/c2/83/4cfb393e287509fc2155480b9d184706ef8d9fa8cbf5505d02a5792bf220/sentencepiece-0.2.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:c6c8f42949f419ff8c7e9960dbadcfbc982d7b5efc2f6748210d3dd53a7de062", size = 1325651, upload-time = "2025-08-12T06:59:55.073Z" }, + { url = "https://files.pythonhosted.org/packages/8d/de/5a007fb53b1ab0aafc69d11a5a3dd72a289d5a3e78dcf2c3a3d9b14ffe93/sentencepiece-0.2.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:097f3394e99456e9e4efba1737c3749d7e23563dd1588ce71a3d007f25475fff", size = 1253641, upload-time = "2025-08-12T06:59:56.562Z" }, + { url = "https://files.pythonhosted.org/packages/2c/d2/f552be5928105588f4f4d66ee37dd4c61460d8097e62d0e2e0eec41bc61d/sentencepiece-0.2.1-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d7b670879c370d350557edabadbad1f6561a9e6968126e6debca4029e5547820", size = 1316271, upload-time = "2025-08-12T06:59:58.109Z" }, + { url = "https://files.pythonhosted.org/packages/96/df/0cfe748ace5485be740fed9476dee7877f109da32ed0d280312c94ec259f/sentencepiece-0.2.1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c7f0fd2f2693309e6628aeeb2e2faf6edd221134dfccac3308ca0de01f8dab47", size = 1387882, upload-time = "2025-08-12T07:00:00.701Z" }, + { url = "https://files.pythonhosted.org/packages/ac/dd/f7774d42a881ced8e1739f393ab1e82ece39fc9abd4779e28050c2e975b5/sentencepiece-0.2.1-cp313-cp313-win32.whl", hash = "sha256:92b3816aa2339355fda2c8c4e021a5de92180b00aaccaf5e2808972e77a4b22f", size = 999541, upload-time = "2025-08-12T07:00:02.709Z" }, + { url = "https://files.pythonhosted.org/packages/dd/e9/932b9eae6fd7019548321eee1ab8d5e3b3d1294df9d9a0c9ac517c7b636d/sentencepiece-0.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:10ed3dab2044c47f7a2e7b4969b0c430420cdd45735d78c8f853191fa0e3148b", size = 1054669, upload-time = "2025-08-12T07:00:04.915Z" }, + { url = "https://files.pythonhosted.org/packages/c9/3a/76488a00ea7d6931689cda28726a1447d66bf1a4837943489314593d5596/sentencepiece-0.2.1-cp313-cp313-win_arm64.whl", hash = "sha256:ac650534e2251083c5f75dde4ff28896ce7c8904133dc8fef42780f4d5588fcd", size = 1033922, upload-time = "2025-08-12T07:00:06.496Z" }, + { url = "https://files.pythonhosted.org/packages/4a/b6/08fe2ce819e02ccb0296f4843e3f195764ce9829cbda61b7513f29b95718/sentencepiece-0.2.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:8dd4b477a7b069648d19363aad0cab9bad2f4e83b2d179be668efa672500dc94", size = 1946052, upload-time = "2025-08-12T07:00:08.136Z" }, + { url = "https://files.pythonhosted.org/packages/ab/d9/1ea0e740591ff4c6fc2b6eb1d7510d02f3fb885093f19b2f3abd1363b402/sentencepiece-0.2.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0c0f672da370cc490e4c59d89e12289778310a0e71d176c541e4834759e1ae07", size = 1327408, upload-time = "2025-08-12T07:00:09.572Z" }, + { url = "https://files.pythonhosted.org/packages/99/7e/1fb26e8a21613f6200e1ab88824d5d203714162cf2883248b517deb500b7/sentencepiece-0.2.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:ad8493bea8432dae8d6830365352350f3b4144415a1d09c4c8cb8d30cf3b6c3c", size = 1254857, upload-time = "2025-08-12T07:00:11.021Z" }, + { url = "https://files.pythonhosted.org/packages/bc/85/c72fd1f3c7a6010544d6ae07f8ddb38b5e2a7e33bd4318f87266c0bbafbf/sentencepiece-0.2.1-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b81a24733726e3678d2db63619acc5a8dccd074f7aa7a54ecd5ca33ca6d2d596", size = 1315722, upload-time = "2025-08-12T07:00:12.989Z" }, + { url = "https://files.pythonhosted.org/packages/4a/e8/661e5bd82a8aa641fd6c1020bd0e890ef73230a2b7215ddf9c8cd8e941c2/sentencepiece-0.2.1-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0a81799d0a68d618e89063fb423c3001a034c893069135ffe51fee439ae474d6", size = 1387452, upload-time = "2025-08-12T07:00:15.088Z" }, + { url = "https://files.pythonhosted.org/packages/99/5e/ae66c361023a470afcbc1fbb8da722c72ea678a2fcd9a18f1a12598c7501/sentencepiece-0.2.1-cp313-cp313t-win32.whl", hash = "sha256:89a3ea015517c42c0341d0d962f3e6aaf2cf10d71b1932d475c44ba48d00aa2b", size = 1002501, upload-time = "2025-08-12T07:00:16.966Z" }, + { url = "https://files.pythonhosted.org/packages/c1/03/d332828c4ff764e16c1b56c2c8f9a33488bbe796b53fb6b9c4205ddbf167/sentencepiece-0.2.1-cp313-cp313t-win_amd64.whl", hash = "sha256:33f068c9382dc2e7c228eedfd8163b52baa86bb92f50d0488bf2b7da7032e484", size = 1057555, upload-time = "2025-08-12T07:00:18.573Z" }, + { url = "https://files.pythonhosted.org/packages/88/14/5aee0bf0864df9bd82bd59e7711362908e4935e3f9cdc1f57246b5d5c9b9/sentencepiece-0.2.1-cp313-cp313t-win_arm64.whl", hash = "sha256:b3616ad246f360e52c85781e47682d31abfb6554c779e42b65333d4b5f44ecc0", size = 1036042, upload-time = "2025-08-12T07:00:20.209Z" }, + { url = "https://files.pythonhosted.org/packages/24/9c/89eb8b2052f720a612478baf11c8227dcf1dc28cd4ea4c0c19506b5af2a2/sentencepiece-0.2.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:5d0350b686c320068702116276cfb26c066dc7e65cfef173980b11bb4d606719", size = 1943147, upload-time = "2025-08-12T07:00:21.809Z" }, + { url = "https://files.pythonhosted.org/packages/82/0b/a1432bc87f97c2ace36386ca23e8bd3b91fb40581b5e6148d24b24186419/sentencepiece-0.2.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:c7f54a31cde6fa5cb030370566f68152a742f433f8d2be458463d06c208aef33", size = 1325624, upload-time = "2025-08-12T07:00:23.289Z" }, + { url = "https://files.pythonhosted.org/packages/ea/99/bbe054ebb5a5039457c590e0a4156ed073fb0fe9ce4f7523404dd5b37463/sentencepiece-0.2.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c83b85ab2d6576607f31df77ff86f28182be4a8de6d175d2c33ca609925f5da1", size = 1253670, upload-time = "2025-08-12T07:00:24.69Z" }, + { url = "https://files.pythonhosted.org/packages/19/ad/d5c7075f701bd97971d7c2ac2904f227566f51ef0838dfbdfdccb58cd212/sentencepiece-0.2.1-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1855f57db07b51fb51ed6c9c452f570624d2b169b36f0f79ef71a6e6c618cd8b", size = 1316247, upload-time = "2025-08-12T07:00:26.435Z" }, + { url = "https://files.pythonhosted.org/packages/fb/03/35fbe5f3d9a7435eebd0b473e09584bd3cc354ce118b960445b060d33781/sentencepiece-0.2.1-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:01e6912125cb45d3792f530a4d38f8e21bf884d6b4d4ade1b2de5cf7a8d2a52b", size = 1387894, upload-time = "2025-08-12T07:00:28.339Z" }, + { url = "https://files.pythonhosted.org/packages/dc/aa/956ef729aafb6c8f9c443104c9636489093bb5c61d6b90fc27aa1a865574/sentencepiece-0.2.1-cp314-cp314-win32.whl", hash = "sha256:c415c9de1447e0a74ae3fdb2e52f967cb544113a3a5ce3a194df185cbc1f962f", size = 1096698, upload-time = "2025-08-12T07:00:29.764Z" }, + { url = "https://files.pythonhosted.org/packages/b8/cb/fe400d8836952cc535c81a0ce47dc6875160e5fedb71d2d9ff0e9894c2a6/sentencepiece-0.2.1-cp314-cp314-win_amd64.whl", hash = "sha256:881b2e44b14fc19feade3cbed314be37de639fc415375cefaa5bc81a4be137fd", size = 1155115, upload-time = "2025-08-12T07:00:32.865Z" }, + { url = "https://files.pythonhosted.org/packages/32/89/047921cf70f36c7b6b6390876b2399b3633ab73b8d0cb857e5a964238941/sentencepiece-0.2.1-cp314-cp314-win_arm64.whl", hash = "sha256:2005242a16d2dc3ac5fe18aa7667549134d37854823df4c4db244752453b78a8", size = 1133890, upload-time = "2025-08-12T07:00:34.763Z" }, + { url = "https://files.pythonhosted.org/packages/a1/11/5b414b9fae6255b5fb1e22e2ed3dc3a72d3a694e5703910e640ac78346bb/sentencepiece-0.2.1-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:a19adcec27c524cb7069a1c741060add95f942d1cbf7ad0d104dffa0a7d28a2b", size = 1946081, upload-time = "2025-08-12T07:00:36.97Z" }, + { url = "https://files.pythonhosted.org/packages/77/eb/7a5682bb25824db8545f8e5662e7f3e32d72a508fdce086029d89695106b/sentencepiece-0.2.1-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:e37e4b4c4a11662b5db521def4e44d4d30ae69a1743241412a93ae40fdcab4bb", size = 1327406, upload-time = "2025-08-12T07:00:38.669Z" }, + { url = "https://files.pythonhosted.org/packages/03/b0/811dae8fb9f2784e138785d481469788f2e0d0c109c5737372454415f55f/sentencepiece-0.2.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:477c81505db072b3ab627e7eab972ea1025331bd3a92bacbf798df2b75ea86ec", size = 1254846, upload-time = "2025-08-12T07:00:40.611Z" }, + { url = "https://files.pythonhosted.org/packages/ef/23/195b2e7ec85ebb6a547969f60b723c7aca5a75800ece6cc3f41da872d14e/sentencepiece-0.2.1-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:010f025a544ef770bb395091d57cb94deb9652d8972e0d09f71d85d5a0816c8c", size = 1315721, upload-time = "2025-08-12T07:00:42.914Z" }, + { url = "https://files.pythonhosted.org/packages/7e/aa/553dbe4178b5f23eb28e59393dddd64186178b56b81d9b8d5c3ff1c28395/sentencepiece-0.2.1-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:733e59ff1794d26db706cd41fc2d7ca5f6c64a820709cb801dc0ea31780d64ab", size = 1387458, upload-time = "2025-08-12T07:00:44.56Z" }, + { url = "https://files.pythonhosted.org/packages/66/7c/08ff0012507297a4dd74a5420fdc0eb9e3e80f4e88cab1538d7f28db303d/sentencepiece-0.2.1-cp314-cp314t-win32.whl", hash = "sha256:d3233770f78e637dc8b1fda2cd7c3b99ec77e7505041934188a4e7fe751de3b0", size = 1099765, upload-time = "2025-08-12T07:00:46.058Z" }, + { url = "https://files.pythonhosted.org/packages/91/d5/2a69e1ce15881beb9ddfc7e3f998322f5cedcd5e4d244cb74dade9441663/sentencepiece-0.2.1-cp314-cp314t-win_amd64.whl", hash = "sha256:5e4366c97b68218fd30ea72d70c525e6e78a6c0a88650f57ac4c43c63b234a9d", size = 1157807, upload-time = "2025-08-12T07:00:47.673Z" }, + { url = "https://files.pythonhosted.org/packages/f3/16/54f611fcfc2d1c46cbe3ec4169780b2cfa7cf63708ef2b71611136db7513/sentencepiece-0.2.1-cp314-cp314t-win_arm64.whl", hash = "sha256:105e36e75cbac1292642045458e8da677b2342dcd33df503e640f0b457cb6751", size = 1136264, upload-time = "2025-08-12T07:00:49.485Z" }, +] + +[[package]] +name = "sentry-sdk" +version = "2.47.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "urllib3" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/4a/2a/d225cbf87b6c8ecce5664db7bcecb82c317e448e3b24a2dcdaacb18ca9a7/sentry_sdk-2.47.0.tar.gz", hash = "sha256:8218891d5e41b4ea8d61d2aed62ed10c80e39d9f2959d6f939efbf056857e050", size = 381895, upload-time = "2025-12-03T14:06:36.846Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bd/ac/d6286ea0d49e7b58847faf67b00e56bb4ba3d525281e2ac306e1f1f353da/sentry_sdk-2.47.0-py2.py3-none-any.whl", hash = "sha256:d72f8c61025b7d1d9e52510d03a6247b280094a327dd900d987717a4fce93412", size = 411088, upload-time = "2025-12-03T14:06:35.374Z" }, +] + +[[package]] +name = "shellingham" +version = "1.5.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/58/15/8b3609fd3830ef7b27b655beb4b4e9c62313a4e8da8c676e142cc210d58e/shellingham-1.5.4.tar.gz", hash = "sha256:8dbca0739d487e5bd35ab3ca4b36e11c4078f3a234bfce294b0a0291363404de", size = 10310, upload-time = "2023-10-24T04:13:40.426Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e0/f9/0595336914c5619e5f28a1fb793285925a8cd4b432c9da0a987836c7f822/shellingham-1.5.4-py2.py3-none-any.whl", hash = "sha256:7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686", size = 9755, upload-time = "2023-10-24T04:13:38.866Z" }, +] + +[[package]] +name = "six" +version = "1.17.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload-time = "2024-12-04T17:35:28.174Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" }, +] + +[[package]] +name = "smmap" +version = "5.0.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/44/cd/a040c4b3119bbe532e5b0732286f805445375489fceaec1f48306068ee3b/smmap-5.0.2.tar.gz", hash = "sha256:26ea65a03958fa0c8a1c7e8c7a58fdc77221b8910f6be2131affade476898ad5", size = 22329, upload-time = "2025-01-02T07:14:40.909Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/04/be/d09147ad1ec7934636ad912901c5fd7667e1c858e19d355237db0d0cd5e4/smmap-5.0.2-py3-none-any.whl", hash = "sha256:b30115f0def7d7531d22a0fb6502488d879e75b260a9db4d0819cfb25403af5e", size = 24303, upload-time = "2025-01-02T07:14:38.724Z" }, +] + +[[package]] +name = "sniffio" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc", size = 20372, upload-time = "2024-02-25T23:20:04.057Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235, upload-time = "2024-02-25T23:20:01.196Z" }, +] + +[[package]] +name = "snowballstemmer" +version = "3.0.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/75/a7/9810d872919697c9d01295633f5d574fb416d47e535f258272ca1f01f447/snowballstemmer-3.0.1.tar.gz", hash = "sha256:6d5eeeec8e9f84d4d56b847692bacf79bc2c8e90c7f80ca4444ff8b6f2e52895", size = 105575, upload-time = "2025-05-09T16:34:51.843Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c8/78/3565d011c61f5a43488987ee32b6f3f656e7f107ac2782dd57bdd7d91d9a/snowballstemmer-3.0.1-py3-none-any.whl", hash = "sha256:6cd7b3897da8d6c9ffb968a6781fa6532dce9c3618a4b127d920dab764a19064", size = 103274, upload-time = "2025-05-09T16:34:50.371Z" }, +] + +[[package]] +name = "soupsieve" +version = "2.8" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6d/e6/21ccce3262dd4889aa3332e5a119a3491a95e8f60939870a3a035aabac0d/soupsieve-2.8.tar.gz", hash = "sha256:e2dd4a40a628cb5f28f6d4b0db8800b8f581b65bb380b97de22ba5ca8d72572f", size = 103472, upload-time = "2025-08-27T15:39:51.78Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/14/a0/bb38d3b76b8cae341dad93a2dd83ab7462e6dbcdd84d43f54ee60a8dc167/soupsieve-2.8-py3-none-any.whl", hash = "sha256:0cc76456a30e20f5d7f2e14a98a4ae2ee4e5abdc7c5ea0aafe795f344bc7984c", size = 36679, upload-time = "2025-08-27T15:39:50.179Z" }, +] + +[[package]] +name = "sphinx" +version = "8.1.3" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11' and sys_platform == 'linux'", + "python_full_version < '3.11' and sys_platform != 'linux'", +] +dependencies = [ + { name = "alabaster", marker = "python_full_version < '3.11'" }, + { name = "babel", marker = "python_full_version < '3.11'" }, + { name = "colorama", marker = "python_full_version < '3.11' and sys_platform == 'win32'" }, + { name = "docutils", marker = "python_full_version < '3.11'" }, + { name = "imagesize", marker = "python_full_version < '3.11'" }, + { name = "jinja2", marker = "python_full_version < '3.11'" }, + { name = "packaging", marker = "python_full_version < '3.11'" }, + { name = "pygments", marker = "python_full_version < '3.11'" }, + { name = "requests", marker = "python_full_version < '3.11'" }, + { name = "snowballstemmer", marker = "python_full_version < '3.11'" }, + { name = "sphinxcontrib-applehelp", marker = "python_full_version < '3.11'" }, + { name = "sphinxcontrib-devhelp", marker = "python_full_version < '3.11'" }, + { name = "sphinxcontrib-htmlhelp", marker = "python_full_version < '3.11'" }, + { name = "sphinxcontrib-jsmath", marker = "python_full_version < '3.11'" }, + { name = "sphinxcontrib-qthelp", marker = "python_full_version < '3.11'" }, + { name = "sphinxcontrib-serializinghtml", marker = "python_full_version < '3.11'" }, + { name = "tomli", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/be0b61178fe2cdcb67e2a92fc9ebb488e3c51c4f74a36a7824c0adf23425/sphinx-8.1.3.tar.gz", hash = "sha256:43c1911eecb0d3e161ad78611bc905d1ad0e523e4ddc202a58a821773dc4c927", size = 8184611, upload-time = "2024-10-13T20:27:13.93Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/26/60/1ddff83a56d33aaf6f10ec8ce84b4c007d9368b21008876fceda7e7381ef/sphinx-8.1.3-py3-none-any.whl", hash = "sha256:09719015511837b76bf6e03e42eb7595ac8c2e41eeb9c29c5b755c6b677992a2", size = 3487125, upload-time = "2024-10-13T20:27:10.448Z" }, +] + +[[package]] +name = "sphinx" +version = "8.2.3" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.14' and sys_platform == 'linux'", + "python_full_version == '3.13.*' and sys_platform == 'linux'", + "python_full_version == '3.12.*' and sys_platform == 'linux'", + "python_full_version == '3.11.*' and sys_platform == 'linux'", + "python_full_version >= '3.14' and sys_platform != 'linux'", + "python_full_version == '3.13.*' and sys_platform != 'linux'", + "python_full_version == '3.12.*' and sys_platform != 'linux'", + "python_full_version == '3.11.*' and sys_platform != 'linux'", +] +dependencies = [ + { name = "alabaster", marker = "python_full_version >= '3.11'" }, + { name = "babel", marker = "python_full_version >= '3.11'" }, + { name = "colorama", marker = "python_full_version >= '3.11' and sys_platform == 'win32'" }, + { name = "docutils", marker = "python_full_version >= '3.11'" }, + { name = "imagesize", marker = "python_full_version >= '3.11'" }, + { name = "jinja2", marker = "python_full_version >= '3.11'" }, + { name = "packaging", marker = "python_full_version >= '3.11'" }, + { name = "pygments", marker = "python_full_version >= '3.11'" }, + { name = "requests", marker = "python_full_version >= '3.11'" }, + { name = "roman-numerals-py", marker = "python_full_version >= '3.11'" }, + { name = "snowballstemmer", marker = "python_full_version >= '3.11'" }, + { name = "sphinxcontrib-applehelp", marker = "python_full_version >= '3.11'" }, + { name = "sphinxcontrib-devhelp", marker = "python_full_version >= '3.11'" }, + { name = "sphinxcontrib-htmlhelp", marker = "python_full_version >= '3.11'" }, + { name = "sphinxcontrib-jsmath", marker = "python_full_version >= '3.11'" }, + { name = "sphinxcontrib-qthelp", marker = "python_full_version >= '3.11'" }, + { name = "sphinxcontrib-serializinghtml", marker = "python_full_version >= '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/38/ad/4360e50ed56cb483667b8e6dadf2d3fda62359593faabbe749a27c4eaca6/sphinx-8.2.3.tar.gz", hash = "sha256:398ad29dee7f63a75888314e9424d40f52ce5a6a87ae88e7071e80af296ec348", size = 8321876, upload-time = "2025-03-02T22:31:59.658Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/31/53/136e9eca6e0b9dc0e1962e2c908fbea2e5ac000c2a2fbd9a35797958c48b/sphinx-8.2.3-py3-none-any.whl", hash = "sha256:4405915165f13521d875a8c29c8970800a0141c14cc5416a38feca4ea5d9b9c3", size = 3589741, upload-time = "2025-03-02T22:31:56.836Z" }, +] + +[[package]] +name = "sphinx-autobuild" +version = "2024.10.3" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11' and sys_platform == 'linux'", + "python_full_version < '3.11' and sys_platform != 'linux'", +] +dependencies = [ + { name = "colorama", marker = "python_full_version < '3.11'" }, + { name = "sphinx", version = "8.1.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "starlette", marker = "python_full_version < '3.11'" }, + { name = "uvicorn", marker = "python_full_version < '3.11'" }, + { name = "watchfiles", marker = "python_full_version < '3.11'" }, + { name = "websockets", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a5/2c/155e1de2c1ba96a72e5dba152c509a8b41e047ee5c2def9e9f0d812f8be7/sphinx_autobuild-2024.10.3.tar.gz", hash = "sha256:248150f8f333e825107b6d4b86113ab28fa51750e5f9ae63b59dc339be951fb1", size = 14023, upload-time = "2024-10-02T23:15:30.172Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/18/c0/eba125db38c84d3c74717008fd3cb5000b68cd7e2cbafd1349c6a38c3d3b/sphinx_autobuild-2024.10.3-py3-none-any.whl", hash = "sha256:158e16c36f9d633e613c9aaf81c19b0fc458ca78b112533b20dafcda430d60fa", size = 11908, upload-time = "2024-10-02T23:15:28.739Z" }, +] + +[[package]] +name = "sphinx-autobuild" +version = "2025.8.25" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.14' and sys_platform == 'linux'", + "python_full_version == '3.13.*' and sys_platform == 'linux'", + "python_full_version == '3.12.*' and sys_platform == 'linux'", + "python_full_version == '3.11.*' and sys_platform == 'linux'", + "python_full_version >= '3.14' and sys_platform != 'linux'", + "python_full_version == '3.13.*' and sys_platform != 'linux'", + "python_full_version == '3.12.*' and sys_platform != 'linux'", + "python_full_version == '3.11.*' and sys_platform != 'linux'", +] +dependencies = [ + { name = "colorama", marker = "python_full_version >= '3.11'" }, + { name = "sphinx", version = "8.2.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "starlette", marker = "python_full_version >= '3.11'" }, + { name = "uvicorn", marker = "python_full_version >= '3.11'" }, + { name = "watchfiles", marker = "python_full_version >= '3.11'" }, + { name = "websockets", marker = "python_full_version >= '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e0/3c/a59a3a453d4133777f7ed2e83c80b7dc817d43c74b74298ca0af869662ad/sphinx_autobuild-2025.8.25.tar.gz", hash = "sha256:9cf5aab32853c8c31af572e4fecdc09c997e2b8be5a07daf2a389e270e85b213", size = 15200, upload-time = "2025-08-25T18:44:55.436Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d7/20/56411b52f917696995f5ad27d2ea7e9492c84a043c5b49a3a3173573cd93/sphinx_autobuild-2025.8.25-py3-none-any.whl", hash = "sha256:b750ac7d5a18603e4665294323fd20f6dcc0a984117026d1986704fa68f0379a", size = 12535, upload-time = "2025-08-25T18:44:54.164Z" }, +] + +[[package]] +name = "sphinx-autodoc2" +version = "0.5.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "astroid" }, + { name = "tomli", marker = "python_full_version < '3.11'" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/17/5f/5350046d1aa1a56b063ae08b9ad871025335c9d55fe2372896ea48711da9/sphinx_autodoc2-0.5.0.tar.gz", hash = "sha256:7d76044aa81d6af74447080182b6868c7eb066874edc835e8ddf810735b6565a", size = 115077, upload-time = "2023-11-27T07:27:51.407Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/19/e6/48d47961bbdae755ba9c17dfc65d89356312c67668dcb36c87cfadfa1964/sphinx_autodoc2-0.5.0-py3-none-any.whl", hash = "sha256:e867013b1512f9d6d7e6f6799f8b537d6884462acd118ef361f3f619a60b5c9e", size = 43385, upload-time = "2023-11-27T07:27:49.929Z" }, +] + +[[package]] +name = "sphinx-copybutton" +version = "0.5.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "sphinx", version = "8.1.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "sphinx", version = "8.2.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/fc/2b/a964715e7f5295f77509e59309959f4125122d648f86b4fe7d70ca1d882c/sphinx-copybutton-0.5.2.tar.gz", hash = "sha256:4cf17c82fb9646d1bc9ca92ac280813a3b605d8c421225fd9913154103ee1fbd", size = 23039, upload-time = "2023-04-14T08:10:22.998Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/48/1ea60e74949eecb12cdd6ac43987f9fd331156388dcc2319b45e2ebb81bf/sphinx_copybutton-0.5.2-py3-none-any.whl", hash = "sha256:fb543fd386d917746c9a2c50360c7905b605726b9355cd26e9974857afeae06e", size = 13343, upload-time = "2023-04-14T08:10:20.844Z" }, +] + +[[package]] +name = "sphinx-design" +version = "0.6.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "sphinx", version = "8.1.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "sphinx", version = "8.2.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/2b/69/b34e0cb5336f09c6866d53b4a19d76c227cdec1bbc7ac4de63ca7d58c9c7/sphinx_design-0.6.1.tar.gz", hash = "sha256:b44eea3719386d04d765c1a8257caca2b3e6f8421d7b3a5e742c0fd45f84e632", size = 2193689, upload-time = "2024-08-02T13:48:44.277Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c6/43/65c0acbd8cc6f50195a3a1fc195c404988b15c67090e73c7a41a9f57d6bd/sphinx_design-0.6.1-py3-none-any.whl", hash = "sha256:b11f37db1a802a183d61b159d9a202314d4d2fe29c163437001324fe2f19549c", size = 2215338, upload-time = "2024-08-02T13:48:42.106Z" }, +] + +[[package]] +name = "sphinxcontrib-applehelp" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ba/6e/b837e84a1a704953c62ef8776d45c3e8d759876b4a84fe14eba2859106fe/sphinxcontrib_applehelp-2.0.0.tar.gz", hash = "sha256:2f29ef331735ce958efa4734873f084941970894c6090408b079c61b2e1c06d1", size = 20053, upload-time = "2024-07-29T01:09:00.465Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5d/85/9ebeae2f76e9e77b952f4b274c27238156eae7979c5421fba91a28f4970d/sphinxcontrib_applehelp-2.0.0-py3-none-any.whl", hash = "sha256:4cd3f0ec4ac5dd9c17ec65e9ab272c9b867ea77425228e68ecf08d6b28ddbdb5", size = 119300, upload-time = "2024-07-29T01:08:58.99Z" }, +] + +[[package]] +name = "sphinxcontrib-devhelp" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f6/d2/5beee64d3e4e747f316bae86b55943f51e82bb86ecd325883ef65741e7da/sphinxcontrib_devhelp-2.0.0.tar.gz", hash = "sha256:411f5d96d445d1d73bb5d52133377b4248ec79db5c793ce7dbe59e074b4dd1ad", size = 12967, upload-time = "2024-07-29T01:09:23.417Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/35/7a/987e583882f985fe4d7323774889ec58049171828b58c2217e7f79cdf44e/sphinxcontrib_devhelp-2.0.0-py3-none-any.whl", hash = "sha256:aefb8b83854e4b0998877524d1029fd3e6879210422ee3780459e28a1f03a8a2", size = 82530, upload-time = "2024-07-29T01:09:21.945Z" }, +] + +[[package]] +name = "sphinxcontrib-htmlhelp" +version = "2.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/43/93/983afd9aa001e5201eab16b5a444ed5b9b0a7a010541e0ddfbbfd0b2470c/sphinxcontrib_htmlhelp-2.1.0.tar.gz", hash = "sha256:c9e2916ace8aad64cc13a0d233ee22317f2b9025b9cf3295249fa985cc7082e9", size = 22617, upload-time = "2024-07-29T01:09:37.889Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0a/7b/18a8c0bcec9182c05a0b3ec2a776bba4ead82750a55ff798e8d406dae604/sphinxcontrib_htmlhelp-2.1.0-py3-none-any.whl", hash = "sha256:166759820b47002d22914d64a075ce08f4c46818e17cfc9470a9786b759b19f8", size = 98705, upload-time = "2024-07-29T01:09:36.407Z" }, +] + +[[package]] +name = "sphinxcontrib-jsmath" +version = "1.0.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b2/e8/9ed3830aeed71f17c026a07a5097edcf44b692850ef215b161b8ad875729/sphinxcontrib-jsmath-1.0.1.tar.gz", hash = "sha256:a9925e4a4587247ed2191a22df5f6970656cb8ca2bd6284309578f2153e0c4b8", size = 5787, upload-time = "2019-01-21T16:10:16.347Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c2/42/4c8646762ee83602e3fb3fbe774c2fac12f317deb0b5dbeeedd2d3ba4b77/sphinxcontrib_jsmath-1.0.1-py2.py3-none-any.whl", hash = "sha256:2ec2eaebfb78f3f2078e73666b1415417a116cc848b72e5172e596c871103178", size = 5071, upload-time = "2019-01-21T16:10:14.333Z" }, +] + +[[package]] +name = "sphinxcontrib-mermaid" +version = "1.2.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pyyaml" }, + { name = "sphinx", version = "8.1.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "sphinx", version = "8.2.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f5/49/c6ddfe709a4ab76ac6e5a00e696f73626b2c189dc1e1965a361ec102e6cc/sphinxcontrib_mermaid-1.2.3.tar.gz", hash = "sha256:358699d0ec924ef679b41873d9edd97d0773446daf9760c75e18dc0adfd91371", size = 18885, upload-time = "2025-11-26T04:18:32.43Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/39/8b54299ffa00e597d3b0b4d042241a0a0b22cb429ad007ccfb9c1745b4d1/sphinxcontrib_mermaid-1.2.3-py3-none-any.whl", hash = "sha256:5be782b27026bef97bfb15ccb2f7868b674a1afc0982b54cb149702cfc25aa02", size = 13413, upload-time = "2025-11-26T04:18:31.269Z" }, +] + +[[package]] +name = "sphinxcontrib-qthelp" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/68/bc/9104308fc285eb3e0b31b67688235db556cd5b0ef31d96f30e45f2e51cae/sphinxcontrib_qthelp-2.0.0.tar.gz", hash = "sha256:4fe7d0ac8fc171045be623aba3e2a8f613f8682731f9153bb2e40ece16b9bbab", size = 17165, upload-time = "2024-07-29T01:09:56.435Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/27/83/859ecdd180cacc13b1f7e857abf8582a64552ea7a061057a6c716e790fce/sphinxcontrib_qthelp-2.0.0-py3-none-any.whl", hash = "sha256:b18a828cdba941ccd6ee8445dbe72ffa3ef8cbe7505d8cd1fa0d42d3f2d5f3eb", size = 88743, upload-time = "2024-07-29T01:09:54.885Z" }, +] + +[[package]] +name = "sphinxcontrib-serializinghtml" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/3b/44/6716b257b0aa6bfd51a1b31665d1c205fb12cb5ad56de752dfa15657de2f/sphinxcontrib_serializinghtml-2.0.0.tar.gz", hash = "sha256:e9d912827f872c029017a53f0ef2180b327c3f7fd23c87229f7a8e8b70031d4d", size = 16080, upload-time = "2024-07-29T01:10:09.332Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/52/a7/d2782e4e3f77c8450f727ba74a8f12756d5ba823d81b941f1b04da9d033a/sphinxcontrib_serializinghtml-2.0.0-py3-none-any.whl", hash = "sha256:6e2cb0eef194e10c27ec0023bfeb25badbbb5868244cf5bc5bdc04e4464bf331", size = 92072, upload-time = "2024-07-29T01:10:08.203Z" }, +] + +[[package]] +name = "starlette" +version = "0.50.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ba/b8/73a0e6a6e079a9d9cfa64113d771e421640b6f679a52eeb9b32f72d871a1/starlette-0.50.0.tar.gz", hash = "sha256:a2a17b22203254bcbc2e1f926d2d55f3f9497f769416b3190768befe598fa3ca", size = 2646985, upload-time = "2025-11-01T15:25:27.516Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d9/52/1064f510b141bd54025f9b55105e26d1fa970b9be67ad766380a3c9b74b0/starlette-0.50.0-py3-none-any.whl", hash = "sha256:9e5391843ec9b6e472eed1365a78c8098cfceb7a74bfd4d6b1c0c0095efb3bca", size = 74033, upload-time = "2025-11-01T15:25:25.461Z" }, +] + +[[package]] +name = "tabulate" +version = "0.9.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ec/fe/802052aecb21e3797b8f7902564ab6ea0d60ff8ca23952079064155d1ae1/tabulate-0.9.0.tar.gz", hash = "sha256:0095b12bf5966de529c0feb1fa08671671b3368eec77d7ef7ab114be2c068b3c", size = 81090, upload-time = "2022-10-06T17:21:48.54Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/40/44/4a5f08c96eb108af5cb50b41f76142f0afa346dfa99d5296fe7202a11854/tabulate-0.9.0-py3-none-any.whl", hash = "sha256:024ca478df22e9340661486f85298cff5f6dcdba14f3813e8830015b9ed1948f", size = 35252, upload-time = "2022-10-06T17:21:44.262Z" }, +] + +[[package]] +name = "textual" +version = "6.8.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markdown-it-py", extra = ["linkify"] }, + { name = "mdit-py-plugins" }, + { name = "platformdirs" }, + { name = "pygments" }, + { name = "rich" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c8/8f/aeccf7459e3d71cbca912a27a97f1fcb00735326f90714d22fa540d3848e/textual-6.8.0.tar.gz", hash = "sha256:7efe618ec9197466b8fe536aefabb678edf30658b9dc58a763365d7daed12b62", size = 1581639, upload-time = "2025-12-07T17:53:46.681Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/47/34/4f1bad936ac3ad94c8576b15660d4ce434f7dbd372baa53566a490bcdce3/textual-6.8.0-py3-none-any.whl", hash = "sha256:074d389ba8c6c98c74e2a4fe1493ea3a38f3ee5008697e98f71daa2cf8ab8fda", size = 714378, upload-time = "2025-12-07T17:53:44.501Z" }, +] + +[[package]] +name = "tokenizers" +version = "0.22.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "huggingface-hub" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/1c/46/fb6854cec3278fbfa4a75b50232c77622bc517ac886156e6afbfa4d8fc6e/tokenizers-0.22.1.tar.gz", hash = "sha256:61de6522785310a309b3407bac22d99c4db5dba349935e99e4d15ea2226af2d9", size = 363123, upload-time = "2025-09-19T09:49:23.424Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bf/33/f4b2d94ada7ab297328fc671fed209368ddb82f965ec2224eb1892674c3a/tokenizers-0.22.1-cp39-abi3-macosx_10_12_x86_64.whl", hash = "sha256:59fdb013df17455e5f950b4b834a7b3ee2e0271e6378ccb33aa74d178b513c73", size = 3069318, upload-time = "2025-09-19T09:49:11.848Z" }, + { url = "https://files.pythonhosted.org/packages/1c/58/2aa8c874d02b974990e89ff95826a4852a8b2a273c7d1b4411cdd45a4565/tokenizers-0.22.1-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:8d4e484f7b0827021ac5f9f71d4794aaef62b979ab7608593da22b1d2e3c4edc", size = 2926478, upload-time = "2025-09-19T09:49:09.759Z" }, + { url = "https://files.pythonhosted.org/packages/1e/3b/55e64befa1e7bfea963cf4b787b2cea1011362c4193f5477047532ce127e/tokenizers-0.22.1-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:19d2962dd28bc67c1f205ab180578a78eef89ac60ca7ef7cbe9635a46a56422a", size = 3256994, upload-time = "2025-09-19T09:48:56.701Z" }, + { url = "https://files.pythonhosted.org/packages/71/0b/fbfecf42f67d9b7b80fde4aabb2b3110a97fac6585c9470b5bff103a80cb/tokenizers-0.22.1-cp39-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:38201f15cdb1f8a6843e6563e6e79f4abd053394992b9bbdf5213ea3469b4ae7", size = 3153141, upload-time = "2025-09-19T09:48:59.749Z" }, + { url = "https://files.pythonhosted.org/packages/17/a9/b38f4e74e0817af8f8ef925507c63c6ae8171e3c4cb2d5d4624bf58fca69/tokenizers-0.22.1-cp39-abi3-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d1cbe5454c9a15df1b3443c726063d930c16f047a3cc724b9e6e1a91140e5a21", size = 3508049, upload-time = "2025-09-19T09:49:05.868Z" }, + { url = "https://files.pythonhosted.org/packages/d2/48/dd2b3dac46bb9134a88e35d72e1aa4869579eacc1a27238f1577270773ff/tokenizers-0.22.1-cp39-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e7d094ae6312d69cc2a872b54b91b309f4f6fbce871ef28eb27b52a98e4d0214", size = 3710730, upload-time = "2025-09-19T09:49:01.832Z" }, + { url = "https://files.pythonhosted.org/packages/93/0e/ccabc8d16ae4ba84a55d41345207c1e2ea88784651a5a487547d80851398/tokenizers-0.22.1-cp39-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:afd7594a56656ace95cdd6df4cca2e4059d294c5cfb1679c57824b605556cb2f", size = 3412560, upload-time = "2025-09-19T09:49:03.867Z" }, + { url = "https://files.pythonhosted.org/packages/d0/c6/dc3a0db5a6766416c32c034286d7c2d406da1f498e4de04ab1b8959edd00/tokenizers-0.22.1-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e2ef6063d7a84994129732b47e7915e8710f27f99f3a3260b8a38fc7ccd083f4", size = 3250221, upload-time = "2025-09-19T09:49:07.664Z" }, + { url = "https://files.pythonhosted.org/packages/d7/a6/2c8486eef79671601ff57b093889a345dd3d576713ef047776015dc66de7/tokenizers-0.22.1-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:ba0a64f450b9ef412c98f6bcd2a50c6df6e2443b560024a09fa6a03189726879", size = 9345569, upload-time = "2025-09-19T09:49:14.214Z" }, + { url = "https://files.pythonhosted.org/packages/6b/16/32ce667f14c35537f5f605fe9bea3e415ea1b0a646389d2295ec348d5657/tokenizers-0.22.1-cp39-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:331d6d149fa9c7d632cde4490fb8bbb12337fa3a0232e77892be656464f4b446", size = 9271599, upload-time = "2025-09-19T09:49:16.639Z" }, + { url = "https://files.pythonhosted.org/packages/51/7c/a5f7898a3f6baa3fc2685c705e04c98c1094c523051c805cdd9306b8f87e/tokenizers-0.22.1-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:607989f2ea68a46cb1dfbaf3e3aabdf3f21d8748312dbeb6263d1b3b66c5010a", size = 9533862, upload-time = "2025-09-19T09:49:19.146Z" }, + { url = "https://files.pythonhosted.org/packages/36/65/7e75caea90bc73c1dd8d40438adf1a7bc26af3b8d0a6705ea190462506e1/tokenizers-0.22.1-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:a0f307d490295717726598ef6fa4f24af9d484809223bbc253b201c740a06390", size = 9681250, upload-time = "2025-09-19T09:49:21.501Z" }, + { url = "https://files.pythonhosted.org/packages/30/2c/959dddef581b46e6209da82df3b78471e96260e2bc463f89d23b1bf0e52a/tokenizers-0.22.1-cp39-abi3-win32.whl", hash = "sha256:b5120eed1442765cd90b903bb6cfef781fd8fe64e34ccaecbae4c619b7b12a82", size = 2472003, upload-time = "2025-09-19T09:49:27.089Z" }, + { url = "https://files.pythonhosted.org/packages/b3/46/e33a8c93907b631a99377ef4c5f817ab453d0b34f93529421f42ff559671/tokenizers-0.22.1-cp39-abi3-win_amd64.whl", hash = "sha256:65fd6e3fb11ca1e78a6a93602490f134d1fdeb13bcef99389d5102ea318ed138", size = 2674684, upload-time = "2025-09-19T09:49:24.953Z" }, +] + +[[package]] +name = "toml" +version = "0.10.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/be/ba/1f744cdc819428fc6b5084ec34d9b30660f6f9daaf70eead706e3203ec3c/toml-0.10.2.tar.gz", hash = "sha256:b3bda1d108d5dd99f4a20d24d9c348e91c4db7ab1b749200bded2f839ccbe68f", size = 22253, upload-time = "2020-11-01T01:40:22.204Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/44/6f/7120676b6d73228c96e17f1f794d8ab046fc910d781c8d151120c3f1569e/toml-0.10.2-py2.py3-none-any.whl", hash = "sha256:806143ae5bfb6a3c6e736a764057db0e6a0e05e338b5630894a5f779cabb4f9b", size = 16588, upload-time = "2020-11-01T01:40:20.672Z" }, +] + +[[package]] +name = "tomli" +version = "2.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/52/ed/3f73f72945444548f33eba9a87fc7a6e969915e7b1acc8260b30e1f76a2f/tomli-2.3.0.tar.gz", hash = "sha256:64be704a875d2a59753d80ee8a533c3fe183e3f06807ff7dc2232938ccb01549", size = 17392, upload-time = "2025-10-08T22:01:47.119Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b3/2e/299f62b401438d5fe1624119c723f5d877acc86a4c2492da405626665f12/tomli-2.3.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:88bd15eb972f3664f5ed4b57c1634a97153b4bac4479dcb6a495f41921eb7f45", size = 153236, upload-time = "2025-10-08T22:01:00.137Z" }, + { url = "https://files.pythonhosted.org/packages/86/7f/d8fffe6a7aefdb61bced88fcb5e280cfd71e08939da5894161bd71bea022/tomli-2.3.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:883b1c0d6398a6a9d29b508c331fa56adbcdff647f6ace4dfca0f50e90dfd0ba", size = 148084, upload-time = "2025-10-08T22:01:01.63Z" }, + { url = "https://files.pythonhosted.org/packages/47/5c/24935fb6a2ee63e86d80e4d3b58b222dafaf438c416752c8b58537c8b89a/tomli-2.3.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d1381caf13ab9f300e30dd8feadb3de072aeb86f1d34a8569453ff32a7dea4bf", size = 234832, upload-time = "2025-10-08T22:01:02.543Z" }, + { url = "https://files.pythonhosted.org/packages/89/da/75dfd804fc11e6612846758a23f13271b76d577e299592b4371a4ca4cd09/tomli-2.3.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a0e285d2649b78c0d9027570d4da3425bdb49830a6156121360b3f8511ea3441", size = 242052, upload-time = "2025-10-08T22:01:03.836Z" }, + { url = "https://files.pythonhosted.org/packages/70/8c/f48ac899f7b3ca7eb13af73bacbc93aec37f9c954df3c08ad96991c8c373/tomli-2.3.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0a154a9ae14bfcf5d8917a59b51ffd5a3ac1fd149b71b47a3a104ca4edcfa845", size = 239555, upload-time = "2025-10-08T22:01:04.834Z" }, + { url = "https://files.pythonhosted.org/packages/ba/28/72f8afd73f1d0e7829bfc093f4cb98ce0a40ffc0cc997009ee1ed94ba705/tomli-2.3.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:74bf8464ff93e413514fefd2be591c3b0b23231a77f901db1eb30d6f712fc42c", size = 245128, upload-time = "2025-10-08T22:01:05.84Z" }, + { url = "https://files.pythonhosted.org/packages/b6/eb/a7679c8ac85208706d27436e8d421dfa39d4c914dcf5fa8083a9305f58d9/tomli-2.3.0-cp311-cp311-win32.whl", hash = "sha256:00b5f5d95bbfc7d12f91ad8c593a1659b6387b43f054104cda404be6bda62456", size = 96445, upload-time = "2025-10-08T22:01:06.896Z" }, + { url = "https://files.pythonhosted.org/packages/0a/fe/3d3420c4cb1ad9cb462fb52967080575f15898da97e21cb6f1361d505383/tomli-2.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:4dc4ce8483a5d429ab602f111a93a6ab1ed425eae3122032db7e9acf449451be", size = 107165, upload-time = "2025-10-08T22:01:08.107Z" }, + { url = "https://files.pythonhosted.org/packages/ff/b7/40f36368fcabc518bb11c8f06379a0fd631985046c038aca08c6d6a43c6e/tomli-2.3.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d7d86942e56ded512a594786a5ba0a5e521d02529b3826e7761a05138341a2ac", size = 154891, upload-time = "2025-10-08T22:01:09.082Z" }, + { url = "https://files.pythonhosted.org/packages/f9/3f/d9dd692199e3b3aab2e4e4dd948abd0f790d9ded8cd10cbaae276a898434/tomli-2.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:73ee0b47d4dad1c5e996e3cd33b8a76a50167ae5f96a2607cbe8cc773506ab22", size = 148796, upload-time = "2025-10-08T22:01:10.266Z" }, + { url = "https://files.pythonhosted.org/packages/60/83/59bff4996c2cf9f9387a0f5a3394629c7efa5ef16142076a23a90f1955fa/tomli-2.3.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:792262b94d5d0a466afb5bc63c7daa9d75520110971ee269152083270998316f", size = 242121, upload-time = "2025-10-08T22:01:11.332Z" }, + { url = "https://files.pythonhosted.org/packages/45/e5/7c5119ff39de8693d6baab6c0b6dcb556d192c165596e9fc231ea1052041/tomli-2.3.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4f195fe57ecceac95a66a75ac24d9d5fbc98ef0962e09b2eddec5d39375aae52", size = 250070, upload-time = "2025-10-08T22:01:12.498Z" }, + { url = "https://files.pythonhosted.org/packages/45/12/ad5126d3a278f27e6701abde51d342aa78d06e27ce2bb596a01f7709a5a2/tomli-2.3.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e31d432427dcbf4d86958c184b9bfd1e96b5b71f8eb17e6d02531f434fd335b8", size = 245859, upload-time = "2025-10-08T22:01:13.551Z" }, + { url = "https://files.pythonhosted.org/packages/fb/a1/4d6865da6a71c603cfe6ad0e6556c73c76548557a8d658f9e3b142df245f/tomli-2.3.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:7b0882799624980785240ab732537fcfc372601015c00f7fc367c55308c186f6", size = 250296, upload-time = "2025-10-08T22:01:14.614Z" }, + { url = "https://files.pythonhosted.org/packages/a0/b7/a7a7042715d55c9ba6e8b196d65d2cb662578b4d8cd17d882d45322b0d78/tomli-2.3.0-cp312-cp312-win32.whl", hash = "sha256:ff72b71b5d10d22ecb084d345fc26f42b5143c5533db5e2eaba7d2d335358876", size = 97124, upload-time = "2025-10-08T22:01:15.629Z" }, + { url = "https://files.pythonhosted.org/packages/06/1e/f22f100db15a68b520664eb3328fb0ae4e90530887928558112c8d1f4515/tomli-2.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:1cb4ed918939151a03f33d4242ccd0aa5f11b3547d0cf30f7c74a408a5b99878", size = 107698, upload-time = "2025-10-08T22:01:16.51Z" }, + { url = "https://files.pythonhosted.org/packages/89/48/06ee6eabe4fdd9ecd48bf488f4ac783844fd777f547b8d1b61c11939974e/tomli-2.3.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5192f562738228945d7b13d4930baffda67b69425a7f0da96d360b0a3888136b", size = 154819, upload-time = "2025-10-08T22:01:17.964Z" }, + { url = "https://files.pythonhosted.org/packages/f1/01/88793757d54d8937015c75dcdfb673c65471945f6be98e6a0410fba167ed/tomli-2.3.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:be71c93a63d738597996be9528f4abe628d1adf5e6eb11607bc8fe1a510b5dae", size = 148766, upload-time = "2025-10-08T22:01:18.959Z" }, + { url = "https://files.pythonhosted.org/packages/42/17/5e2c956f0144b812e7e107f94f1cc54af734eb17b5191c0bbfb72de5e93e/tomli-2.3.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c4665508bcbac83a31ff8ab08f424b665200c0e1e645d2bd9ab3d3e557b6185b", size = 240771, upload-time = "2025-10-08T22:01:20.106Z" }, + { url = "https://files.pythonhosted.org/packages/d5/f4/0fbd014909748706c01d16824eadb0307115f9562a15cbb012cd9b3512c5/tomli-2.3.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4021923f97266babc6ccab9f5068642a0095faa0a51a246a6a02fccbb3514eaf", size = 248586, upload-time = "2025-10-08T22:01:21.164Z" }, + { url = "https://files.pythonhosted.org/packages/30/77/fed85e114bde5e81ecf9bc5da0cc69f2914b38f4708c80ae67d0c10180c5/tomli-2.3.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a4ea38c40145a357d513bffad0ed869f13c1773716cf71ccaa83b0fa0cc4e42f", size = 244792, upload-time = "2025-10-08T22:01:22.417Z" }, + { url = "https://files.pythonhosted.org/packages/55/92/afed3d497f7c186dc71e6ee6d4fcb0acfa5f7d0a1a2878f8beae379ae0cc/tomli-2.3.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ad805ea85eda330dbad64c7ea7a4556259665bdf9d2672f5dccc740eb9d3ca05", size = 248909, upload-time = "2025-10-08T22:01:23.859Z" }, + { url = "https://files.pythonhosted.org/packages/f8/84/ef50c51b5a9472e7265ce1ffc7f24cd4023d289e109f669bdb1553f6a7c2/tomli-2.3.0-cp313-cp313-win32.whl", hash = "sha256:97d5eec30149fd3294270e889b4234023f2c69747e555a27bd708828353ab606", size = 96946, upload-time = "2025-10-08T22:01:24.893Z" }, + { url = "https://files.pythonhosted.org/packages/b2/b7/718cd1da0884f281f95ccfa3a6cc572d30053cba64603f79d431d3c9b61b/tomli-2.3.0-cp313-cp313-win_amd64.whl", hash = "sha256:0c95ca56fbe89e065c6ead5b593ee64b84a26fca063b5d71a1122bf26e533999", size = 107705, upload-time = "2025-10-08T22:01:26.153Z" }, + { url = "https://files.pythonhosted.org/packages/19/94/aeafa14a52e16163008060506fcb6aa1949d13548d13752171a755c65611/tomli-2.3.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:cebc6fe843e0733ee827a282aca4999b596241195f43b4cc371d64fc6639da9e", size = 154244, upload-time = "2025-10-08T22:01:27.06Z" }, + { url = "https://files.pythonhosted.org/packages/db/e4/1e58409aa78eefa47ccd19779fc6f36787edbe7d4cd330eeeedb33a4515b/tomli-2.3.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:4c2ef0244c75aba9355561272009d934953817c49f47d768070c3c94355c2aa3", size = 148637, upload-time = "2025-10-08T22:01:28.059Z" }, + { url = "https://files.pythonhosted.org/packages/26/b6/d1eccb62f665e44359226811064596dd6a366ea1f985839c566cd61525ae/tomli-2.3.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c22a8bf253bacc0cf11f35ad9808b6cb75ada2631c2d97c971122583b129afbc", size = 241925, upload-time = "2025-10-08T22:01:29.066Z" }, + { url = "https://files.pythonhosted.org/packages/70/91/7cdab9a03e6d3d2bb11beae108da5bdc1c34bdeb06e21163482544ddcc90/tomli-2.3.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0eea8cc5c5e9f89c9b90c4896a8deefc74f518db5927d0e0e8d4a80953d774d0", size = 249045, upload-time = "2025-10-08T22:01:31.98Z" }, + { url = "https://files.pythonhosted.org/packages/15/1b/8c26874ed1f6e4f1fcfeb868db8a794cbe9f227299402db58cfcc858766c/tomli-2.3.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:b74a0e59ec5d15127acdabd75ea17726ac4c5178ae51b85bfe39c4f8a278e879", size = 245835, upload-time = "2025-10-08T22:01:32.989Z" }, + { url = "https://files.pythonhosted.org/packages/fd/42/8e3c6a9a4b1a1360c1a2a39f0b972cef2cc9ebd56025168c4137192a9321/tomli-2.3.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:b5870b50c9db823c595983571d1296a6ff3e1b88f734a4c8f6fc6188397de005", size = 253109, upload-time = "2025-10-08T22:01:34.052Z" }, + { url = "https://files.pythonhosted.org/packages/22/0c/b4da635000a71b5f80130937eeac12e686eefb376b8dee113b4a582bba42/tomli-2.3.0-cp314-cp314-win32.whl", hash = "sha256:feb0dacc61170ed7ab602d3d972a58f14ee3ee60494292d384649a3dc38ef463", size = 97930, upload-time = "2025-10-08T22:01:35.082Z" }, + { url = "https://files.pythonhosted.org/packages/b9/74/cb1abc870a418ae99cd5c9547d6bce30701a954e0e721821df483ef7223c/tomli-2.3.0-cp314-cp314-win_amd64.whl", hash = "sha256:b273fcbd7fc64dc3600c098e39136522650c49bca95df2d11cf3b626422392c8", size = 107964, upload-time = "2025-10-08T22:01:36.057Z" }, + { url = "https://files.pythonhosted.org/packages/54/78/5c46fff6432a712af9f792944f4fcd7067d8823157949f4e40c56b8b3c83/tomli-2.3.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:940d56ee0410fa17ee1f12b817b37a4d4e4dc4d27340863cc67236c74f582e77", size = 163065, upload-time = "2025-10-08T22:01:37.27Z" }, + { url = "https://files.pythonhosted.org/packages/39/67/f85d9bd23182f45eca8939cd2bc7050e1f90c41f4a2ecbbd5963a1d1c486/tomli-2.3.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:f85209946d1fe94416debbb88d00eb92ce9cd5266775424ff81bc959e001acaf", size = 159088, upload-time = "2025-10-08T22:01:38.235Z" }, + { url = "https://files.pythonhosted.org/packages/26/5a/4b546a0405b9cc0659b399f12b6adb750757baf04250b148d3c5059fc4eb/tomli-2.3.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a56212bdcce682e56b0aaf79e869ba5d15a6163f88d5451cbde388d48b13f530", size = 268193, upload-time = "2025-10-08T22:01:39.712Z" }, + { url = "https://files.pythonhosted.org/packages/42/4f/2c12a72ae22cf7b59a7fe75b3465b7aba40ea9145d026ba41cb382075b0e/tomli-2.3.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c5f3ffd1e098dfc032d4d3af5c0ac64f6d286d98bc148698356847b80fa4de1b", size = 275488, upload-time = "2025-10-08T22:01:40.773Z" }, + { url = "https://files.pythonhosted.org/packages/92/04/a038d65dbe160c3aa5a624e93ad98111090f6804027d474ba9c37c8ae186/tomli-2.3.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5e01decd096b1530d97d5d85cb4dff4af2d8347bd35686654a004f8dea20fc67", size = 272669, upload-time = "2025-10-08T22:01:41.824Z" }, + { url = "https://files.pythonhosted.org/packages/be/2f/8b7c60a9d1612a7cbc39ffcca4f21a73bf368a80fc25bccf8253e2563267/tomli-2.3.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:8a35dd0e643bb2610f156cca8db95d213a90015c11fee76c946aa62b7ae7e02f", size = 279709, upload-time = "2025-10-08T22:01:43.177Z" }, + { url = "https://files.pythonhosted.org/packages/7e/46/cc36c679f09f27ded940281c38607716c86cf8ba4a518d524e349c8b4874/tomli-2.3.0-cp314-cp314t-win32.whl", hash = "sha256:a1f7f282fe248311650081faafa5f4732bdbfef5d45fe3f2e702fbc6f2d496e0", size = 107563, upload-time = "2025-10-08T22:01:44.233Z" }, + { url = "https://files.pythonhosted.org/packages/84/ff/426ca8683cf7b753614480484f6437f568fd2fda2edbdf57a2d3d8b27a0b/tomli-2.3.0-cp314-cp314t-win_amd64.whl", hash = "sha256:70a251f8d4ba2d9ac2542eecf008b3c8a9fc5c3f9f02c56a9d7952612be2fdba", size = 119756, upload-time = "2025-10-08T22:01:45.234Z" }, + { url = "https://files.pythonhosted.org/packages/77/b8/0135fadc89e73be292b473cb820b4f5a08197779206b33191e801feeae40/tomli-2.3.0-py3-none-any.whl", hash = "sha256:e95b1af3c5b07d9e643909b5abbec77cd9f1217e6d0bca72b0234736b9fb1f1b", size = 14408, upload-time = "2025-10-08T22:01:46.04Z" }, +] + +[[package]] +name = "tomlkit" +version = "0.13.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cc/18/0bbf3884e9eaa38819ebe46a7bd25dcd56b67434402b66a58c4b8e552575/tomlkit-0.13.3.tar.gz", hash = "sha256:430cf247ee57df2b94ee3fbe588e71d362a941ebb545dec29b53961d61add2a1", size = 185207, upload-time = "2025-06-05T07:13:44.947Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bd/75/8539d011f6be8e29f339c42e633aae3cb73bffa95dd0f9adec09b9c58e85/tomlkit-0.13.3-py3-none-any.whl", hash = "sha256:c89c649d79ee40629a9fda55f8ace8c6a1b42deb912b2a8fd8d942ddadb606b0", size = 38901, upload-time = "2025-06-05T07:13:43.546Z" }, +] + +[[package]] +name = "torchx" +version = "0.7.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "docker" }, + { name = "docstring-parser" }, + { name = "filelock" }, + { name = "fsspec" }, + { name = "importlib-metadata" }, + { name = "pyre-extensions" }, + { name = "pyyaml" }, + { name = "tabulate" }, + { name = "urllib3" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ed/a9/e07e64222e59f44eb18b333bc8db942a295c0d9c16f04c8703fe106a8fd5/torchx-0.7.0.tar.gz", hash = "sha256:933b800849c69ddff9feda931f0ae2c4083638eafc73abfdf361158667c68ad6", size = 196142, upload-time = "2024-07-16T22:06:57.222Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a0/8d/282b884cef8f26b240e1ac8e60513a25a68e3463dc1c68771191a2c8a209/torchx-0.7.0-py3-none-any.whl", hash = "sha256:815c2628c30de1f5938c14c4427cfe280fdf93473b171be906ab7c1ea5971824", size = 256100, upload-time = "2024-07-16T21:16:01.849Z" }, +] + +[[package]] +name = "tqdm" +version = "4.67.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a8/4b/29b4ef32e036bb34e4ab51796dd745cdba7ed47ad142a9f4a1eb8e0c744d/tqdm-4.67.1.tar.gz", hash = "sha256:f8aef9c52c08c13a65f30ea34f4e5aac3fd1a34959879d7e59e63027286627f2", size = 169737, upload-time = "2024-11-24T20:12:22.481Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d0/30/dc54f88dd4a2b5dc8a0279bdd7270e735851848b762aeb1c1184ed1f6b14/tqdm-4.67.1-py3-none-any.whl", hash = "sha256:26445eca388f82e72884e0d580d5464cd801a3ea01e63e5601bdff9ba6a48de2", size = 78540, upload-time = "2024-11-24T20:12:19.698Z" }, +] + +[[package]] +name = "transformers" +version = "4.57.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "filelock" }, + { name = "huggingface-hub" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "numpy", version = "2.3.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "packaging" }, + { name = "pyyaml" }, + { name = "regex" }, + { name = "requests" }, + { name = "safetensors" }, + { name = "tokenizers" }, + { name = "tqdm" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/dd/70/d42a739e8dfde3d92bb2fff5819cbf331fe9657323221e79415cd5eb65ee/transformers-4.57.3.tar.gz", hash = "sha256:df4945029aaddd7c09eec5cad851f30662f8bd1746721b34cc031d70c65afebc", size = 10139680, upload-time = "2025-11-25T15:51:30.139Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6a/6b/2f416568b3c4c91c96e5a365d164f8a4a4a88030aa8ab4644181fdadce97/transformers-4.57.3-py3-none-any.whl", hash = "sha256:c77d353a4851b1880191603d36acb313411d3577f6e2897814f333841f7003f4", size = 11993463, upload-time = "2025-11-25T15:51:26.493Z" }, +] + +[[package]] +name = "typer" +version = "0.20.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "click" }, + { name = "rich" }, + { name = "shellingham" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/8f/28/7c85c8032b91dbe79725b6f17d2fffc595dff06a35c7a30a37bef73a1ab4/typer-0.20.0.tar.gz", hash = "sha256:1aaf6494031793e4876fb0bacfa6a912b551cf43c1e63c800df8b1a866720c37", size = 106492, upload-time = "2025-10-20T17:03:49.445Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/78/64/7713ffe4b5983314e9d436a90d5bd4f63b6054e2aca783a3cfc44cb95bbf/typer-0.20.0-py3-none-any.whl", hash = "sha256:5b463df6793ec1dca6213a3cf4c0f03bc6e322ac5e16e13ddd622a889489784a", size = 47028, upload-time = "2025-10-20T17:03:47.617Z" }, +] + +[[package]] +name = "typing-extensions" +version = "4.15.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" }, +] + +[[package]] +name = "typing-inspect" +version = "0.9.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "mypy-extensions" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/dc/74/1789779d91f1961fa9438e9a8710cdae6bd138c80d7303996933d117264a/typing_inspect-0.9.0.tar.gz", hash = "sha256:b23fc42ff6f6ef6954e4852c1fb512cdd18dbea03134f91f856a95ccc9461f78", size = 13825, upload-time = "2023-05-24T20:25:47.612Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/65/f3/107a22063bf27bdccf2024833d3445f4eea42b2e598abfbd46f6a63b6cb0/typing_inspect-0.9.0-py3-none-any.whl", hash = "sha256:9ee6fc59062311ef8547596ab6b955e1b8aa46242d854bfc78f4f6b0eff35f9f", size = 8827, upload-time = "2023-05-24T20:25:45.287Z" }, +] + +[[package]] +name = "typing-inspection" +version = "0.4.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", hash = "sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464", size = 75949, upload-time = "2025-10-01T02:14:41.687Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611, upload-time = "2025-10-01T02:14:40.154Z" }, +] + +[[package]] +name = "tzdata" +version = "2025.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5e/a7/c202b344c5ca7daf398f3b8a477eeb205cf3b6f32e7ec3a6bac0629ca975/tzdata-2025.3.tar.gz", hash = "sha256:de39c2ca5dc7b0344f2eba86f49d614019d29f060fc4ebc8a417896a620b56a7", size = 196772, upload-time = "2025-12-13T17:45:35.667Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c7/b0/003792df09decd6849a5e39c28b513c06e84436a54440380862b5aeff25d/tzdata-2025.3-py2.py3-none-any.whl", hash = "sha256:06a47e5700f3081aab02b2e513160914ff0694bce9947d6b76ebd6bf57cfc5d1", size = 348521, upload-time = "2025-12-13T17:45:33.889Z" }, +] + +[[package]] +name = "uc-micro-py" +version = "1.0.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/91/7a/146a99696aee0609e3712f2b44c6274566bc368dfe8375191278045186b8/uc-micro-py-1.0.3.tar.gz", hash = "sha256:d321b92cff673ec58027c04015fcaa8bb1e005478643ff4a500882eaab88c48a", size = 6043, upload-time = "2024-02-09T16:52:01.654Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/37/87/1f677586e8ac487e29672e4b17455758fce261de06a0d086167bb760361a/uc_micro_py-1.0.3-py3-none-any.whl", hash = "sha256:db1dffff340817673d7b466ec86114a9dc0e9d4d9b5ba229d9d60e5c12600cd5", size = 6229, upload-time = "2024-02-09T16:52:00.371Z" }, +] + +[[package]] +name = "urllib3" +version = "1.26.20" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e4/e8/6ff5e6bc22095cfc59b6ea711b687e2b7ed4bdb373f7eeec370a97d7392f/urllib3-1.26.20.tar.gz", hash = "sha256:40c2dc0c681e47eb8f90e7e27bf6ff7df2e677421fd46756da1161c39ca70d32", size = 307380, upload-time = "2024-08-29T15:43:11.37Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/33/cf/8435d5a7159e2a9c83a95896ed596f68cf798005fe107cc655b5c5c14704/urllib3-1.26.20-py2.py3-none-any.whl", hash = "sha256:0ed14ccfbf1c30a9072c7ca157e4319b70d65f623e91e7b32fadb2853431016e", size = 144225, upload-time = "2024-08-29T15:43:08.921Z" }, +] + +[[package]] +name = "uvicorn" +version = "0.38.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "click" }, + { name = "h11" }, + { name = "typing-extensions", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/cb/ce/f06b84e2697fef4688ca63bdb2fdf113ca0a3be33f94488f2cadb690b0cf/uvicorn-0.38.0.tar.gz", hash = "sha256:fd97093bdd120a2609fc0d3afe931d4d4ad688b6e75f0f929fde1bc36fe0e91d", size = 80605, upload-time = "2025-10-18T13:46:44.63Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ee/d9/d88e73ca598f4f6ff671fb5fde8a32925c2e08a637303a1d12883c7305fa/uvicorn-0.38.0-py3-none-any.whl", hash = "sha256:48c0afd214ceb59340075b4a052ea1ee91c16fbc2a9b1469cca0e54566977b02", size = 68109, upload-time = "2025-10-18T13:46:42.958Z" }, +] + +[[package]] +name = "wandb" +version = "0.23.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "click" }, + { name = "gitpython" }, + { name = "packaging" }, + { name = "platformdirs" }, + { name = "protobuf" }, + { name = "pydantic" }, + { name = "pyyaml" }, + { name = "requests" }, + { name = "sentry-sdk" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0a/cc/770ae3aa7ae44f6792f7ecb81c14c0e38b672deb35235719bb1006519487/wandb-0.23.1.tar.gz", hash = "sha256:f6fb1e3717949b29675a69359de0eeb01e67d3360d581947d5b3f98c273567d6", size = 44298053, upload-time = "2025-12-03T02:25:10.79Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/12/0b/c3d7053dfd93fd259a63c7818d9c4ac2ba0642ff8dc8db98662ea0cf9cc0/wandb-0.23.1-py3-none-macosx_12_0_arm64.whl", hash = "sha256:358e15471d19b7d73fc464e37371c19d44d39e433252ac24df107aff993a286b", size = 21527293, upload-time = "2025-12-03T02:24:48.011Z" }, + { url = "https://files.pythonhosted.org/packages/ee/9f/059420fa0cb6c511dc5c5a50184122b6aca7b178cb2aa210139e354020da/wandb-0.23.1-py3-none-macosx_12_0_x86_64.whl", hash = "sha256:110304407f4b38f163bdd50ed5c5225365e4df3092f13089c30171a75257b575", size = 22745926, upload-time = "2025-12-03T02:24:50.519Z" }, + { url = "https://files.pythonhosted.org/packages/96/b6/fd465827c14c64d056d30b4c9fcf4dac889a6969dba64489a88fc4ffa333/wandb-0.23.1-py3-none-manylinux_2_28_aarch64.whl", hash = "sha256:6cc984cf85feb2f8ee0451d76bc9fb7f39da94956bb8183e30d26284cf203b65", size = 21212973, upload-time = "2025-12-03T02:24:52.828Z" }, + { url = "https://files.pythonhosted.org/packages/5c/ee/9a8bb9a39cc1f09c3060456cc79565110226dc4099a719af5c63432da21d/wandb-0.23.1-py3-none-manylinux_2_28_x86_64.whl", hash = "sha256:67431cd3168d79fdb803e503bd669c577872ffd5dadfa86de733b3274b93088e", size = 22887885, upload-time = "2025-12-03T02:24:55.281Z" }, + { url = "https://files.pythonhosted.org/packages/6d/4d/8d9e75add529142e037b05819cb3ab1005679272950128d69d218b7e5b2e/wandb-0.23.1-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:07be70c0baa97ea25fadc4a9d0097f7371eef6dcacc5ceb525c82491a31e9244", size = 21250967, upload-time = "2025-12-03T02:24:57.603Z" }, + { url = "https://files.pythonhosted.org/packages/97/72/0b35cddc4e4168f03c759b96d9f671ad18aec8bdfdd84adfea7ecb3f5701/wandb-0.23.1-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:216c95b08e0a2ec6a6008373b056d597573d565e30b43a7a93c35a171485ee26", size = 22988382, upload-time = "2025-12-03T02:25:00.518Z" }, + { url = "https://files.pythonhosted.org/packages/c0/6d/e78093d49d68afb26f5261a70fc7877c34c114af5c2ee0ab3b1af85f5e76/wandb-0.23.1-py3-none-win32.whl", hash = "sha256:fb5cf0f85692f758a5c36ab65fea96a1284126de64e836610f92ddbb26df5ded", size = 22150756, upload-time = "2025-12-03T02:25:02.734Z" }, + { url = "https://files.pythonhosted.org/packages/05/27/4f13454b44c9eceaac3d6e4e4efa2230b6712d613ff9bf7df010eef4fd18/wandb-0.23.1-py3-none-win_amd64.whl", hash = "sha256:21c8c56e436eb707b7d54f705652e030d48e5cfcba24cf953823eb652e30e714", size = 22150760, upload-time = "2025-12-03T02:25:05.106Z" }, + { url = "https://files.pythonhosted.org/packages/30/20/6c091d451e2a07689bfbfaeb7592d488011420e721de170884fedd68c644/wandb-0.23.1-py3-none-win_arm64.whl", hash = "sha256:8aee7f3bb573f2c0acf860f497ca9c684f9b35f2ca51011ba65af3d4592b77c1", size = 20137463, upload-time = "2025-12-03T02:25:08.317Z" }, +] + +[[package]] +name = "watchfiles" +version = "1.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c2/c9/8869df9b2a2d6c59d79220a4db37679e74f807c559ffe5265e08b227a210/watchfiles-1.1.1.tar.gz", hash = "sha256:a173cb5c16c4f40ab19cecf48a534c409f7ea983ab8fed0741304a1c0a31b3f2", size = 94440, upload-time = "2025-10-14T15:06:21.08Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a7/1a/206e8cf2dd86fddf939165a57b4df61607a1e0add2785f170a3f616b7d9f/watchfiles-1.1.1-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:eef58232d32daf2ac67f42dea51a2c80f0d03379075d44a587051e63cc2e368c", size = 407318, upload-time = "2025-10-14T15:04:18.753Z" }, + { url = "https://files.pythonhosted.org/packages/b3/0f/abaf5262b9c496b5dad4ed3c0e799cbecb1f8ea512ecb6ddd46646a9fca3/watchfiles-1.1.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:03fa0f5237118a0c5e496185cafa92878568b652a2e9a9382a5151b1a0380a43", size = 394478, upload-time = "2025-10-14T15:04:20.297Z" }, + { url = "https://files.pythonhosted.org/packages/b1/04/9cc0ba88697b34b755371f5ace8d3a4d9a15719c07bdc7bd13d7d8c6a341/watchfiles-1.1.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8ca65483439f9c791897f7db49202301deb6e15fe9f8fe2fed555bf986d10c31", size = 449894, upload-time = "2025-10-14T15:04:21.527Z" }, + { url = "https://files.pythonhosted.org/packages/d2/9c/eda4615863cd8621e89aed4df680d8c3ec3da6a4cf1da113c17decd87c7f/watchfiles-1.1.1-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f0ab1c1af0cb38e3f598244c17919fb1a84d1629cc08355b0074b6d7f53138ac", size = 459065, upload-time = "2025-10-14T15:04:22.795Z" }, + { url = "https://files.pythonhosted.org/packages/84/13/f28b3f340157d03cbc8197629bc109d1098764abe1e60874622a0be5c112/watchfiles-1.1.1-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3bc570d6c01c206c46deb6e935a260be44f186a2f05179f52f7fcd2be086a94d", size = 488377, upload-time = "2025-10-14T15:04:24.138Z" }, + { url = "https://files.pythonhosted.org/packages/86/93/cfa597fa9389e122488f7ffdbd6db505b3b915ca7435ecd7542e855898c2/watchfiles-1.1.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e84087b432b6ac94778de547e08611266f1f8ffad28c0ee4c82e028b0fc5966d", size = 595837, upload-time = "2025-10-14T15:04:25.057Z" }, + { url = "https://files.pythonhosted.org/packages/57/1e/68c1ed5652b48d89fc24d6af905d88ee4f82fa8bc491e2666004e307ded1/watchfiles-1.1.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:620bae625f4cb18427b1bb1a2d9426dc0dd5a5ba74c7c2cdb9de405f7b129863", size = 473456, upload-time = "2025-10-14T15:04:26.497Z" }, + { url = "https://files.pythonhosted.org/packages/d5/dc/1a680b7458ffa3b14bb64878112aefc8f2e4f73c5af763cbf0bd43100658/watchfiles-1.1.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:544364b2b51a9b0c7000a4b4b02f90e9423d97fbbf7e06689236443ebcad81ab", size = 455614, upload-time = "2025-10-14T15:04:27.539Z" }, + { url = "https://files.pythonhosted.org/packages/61/a5/3d782a666512e01eaa6541a72ebac1d3aae191ff4a31274a66b8dd85760c/watchfiles-1.1.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:bbe1ef33d45bc71cf21364df962af171f96ecaeca06bd9e3d0b583efb12aec82", size = 630690, upload-time = "2025-10-14T15:04:28.495Z" }, + { url = "https://files.pythonhosted.org/packages/9b/73/bb5f38590e34687b2a9c47a244aa4dd50c56a825969c92c9c5fc7387cea1/watchfiles-1.1.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:1a0bb430adb19ef49389e1ad368450193a90038b5b752f4ac089ec6942c4dff4", size = 622459, upload-time = "2025-10-14T15:04:29.491Z" }, + { url = "https://files.pythonhosted.org/packages/f1/ac/c9bb0ec696e07a20bd58af5399aeadaef195fb2c73d26baf55180fe4a942/watchfiles-1.1.1-cp310-cp310-win32.whl", hash = "sha256:3f6d37644155fb5beca5378feb8c1708d5783145f2a0f1c4d5a061a210254844", size = 272663, upload-time = "2025-10-14T15:04:30.435Z" }, + { url = "https://files.pythonhosted.org/packages/11/a0/a60c5a7c2ec59fa062d9a9c61d02e3b6abd94d32aac2d8344c4bdd033326/watchfiles-1.1.1-cp310-cp310-win_amd64.whl", hash = "sha256:a36d8efe0f290835fd0f33da35042a1bb5dc0e83cbc092dcf69bce442579e88e", size = 287453, upload-time = "2025-10-14T15:04:31.53Z" }, + { url = "https://files.pythonhosted.org/packages/1f/f8/2c5f479fb531ce2f0564eda479faecf253d886b1ab3630a39b7bf7362d46/watchfiles-1.1.1-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:f57b396167a2565a4e8b5e56a5a1c537571733992b226f4f1197d79e94cf0ae5", size = 406529, upload-time = "2025-10-14T15:04:32.899Z" }, + { url = "https://files.pythonhosted.org/packages/fe/cd/f515660b1f32f65df671ddf6f85bfaca621aee177712874dc30a97397977/watchfiles-1.1.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:421e29339983e1bebc281fab40d812742268ad057db4aee8c4d2bce0af43b741", size = 394384, upload-time = "2025-10-14T15:04:33.761Z" }, + { url = "https://files.pythonhosted.org/packages/7b/c3/28b7dc99733eab43fca2d10f55c86e03bd6ab11ca31b802abac26b23d161/watchfiles-1.1.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6e43d39a741e972bab5d8100b5cdacf69db64e34eb19b6e9af162bccf63c5cc6", size = 448789, upload-time = "2025-10-14T15:04:34.679Z" }, + { url = "https://files.pythonhosted.org/packages/4a/24/33e71113b320030011c8e4316ccca04194bf0cbbaeee207f00cbc7d6b9f5/watchfiles-1.1.1-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f537afb3276d12814082a2e9b242bdcf416c2e8fd9f799a737990a1dbe906e5b", size = 460521, upload-time = "2025-10-14T15:04:35.963Z" }, + { url = "https://files.pythonhosted.org/packages/f4/c3/3c9a55f255aa57b91579ae9e98c88704955fa9dac3e5614fb378291155df/watchfiles-1.1.1-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b2cd9e04277e756a2e2d2543d65d1e2166d6fd4c9b183f8808634fda23f17b14", size = 488722, upload-time = "2025-10-14T15:04:37.091Z" }, + { url = "https://files.pythonhosted.org/packages/49/36/506447b73eb46c120169dc1717fe2eff07c234bb3232a7200b5f5bd816e9/watchfiles-1.1.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5f3f58818dc0b07f7d9aa7fe9eb1037aecb9700e63e1f6acfed13e9fef648f5d", size = 596088, upload-time = "2025-10-14T15:04:38.39Z" }, + { url = "https://files.pythonhosted.org/packages/82/ab/5f39e752a9838ec4d52e9b87c1e80f1ee3ccdbe92e183c15b6577ab9de16/watchfiles-1.1.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9bb9f66367023ae783551042d31b1d7fd422e8289eedd91f26754a66f44d5cff", size = 472923, upload-time = "2025-10-14T15:04:39.666Z" }, + { url = "https://files.pythonhosted.org/packages/af/b9/a419292f05e302dea372fa7e6fda5178a92998411f8581b9830d28fb9edb/watchfiles-1.1.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:aebfd0861a83e6c3d1110b78ad54704486555246e542be3e2bb94195eabb2606", size = 456080, upload-time = "2025-10-14T15:04:40.643Z" }, + { url = "https://files.pythonhosted.org/packages/b0/c3/d5932fd62bde1a30c36e10c409dc5d54506726f08cb3e1d8d0ba5e2bc8db/watchfiles-1.1.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:5fac835b4ab3c6487b5dbad78c4b3724e26bcc468e886f8ba8cc4306f68f6701", size = 629432, upload-time = "2025-10-14T15:04:41.789Z" }, + { url = "https://files.pythonhosted.org/packages/f7/77/16bddd9779fafb795f1a94319dc965209c5641db5bf1edbbccace6d1b3c0/watchfiles-1.1.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:399600947b170270e80134ac854e21b3ccdefa11a9529a3decc1327088180f10", size = 623046, upload-time = "2025-10-14T15:04:42.718Z" }, + { url = "https://files.pythonhosted.org/packages/46/ef/f2ecb9a0f342b4bfad13a2787155c6ee7ce792140eac63a34676a2feeef2/watchfiles-1.1.1-cp311-cp311-win32.whl", hash = "sha256:de6da501c883f58ad50db3a32ad397b09ad29865b5f26f64c24d3e3281685849", size = 271473, upload-time = "2025-10-14T15:04:43.624Z" }, + { url = "https://files.pythonhosted.org/packages/94/bc/f42d71125f19731ea435c3948cad148d31a64fccde3867e5ba4edee901f9/watchfiles-1.1.1-cp311-cp311-win_amd64.whl", hash = "sha256:35c53bd62a0b885bf653ebf6b700d1bf05debb78ad9292cf2a942b23513dc4c4", size = 287598, upload-time = "2025-10-14T15:04:44.516Z" }, + { url = "https://files.pythonhosted.org/packages/57/c9/a30f897351f95bbbfb6abcadafbaca711ce1162f4db95fc908c98a9165f3/watchfiles-1.1.1-cp311-cp311-win_arm64.whl", hash = "sha256:57ca5281a8b5e27593cb7d82c2ac927ad88a96ed406aa446f6344e4328208e9e", size = 277210, upload-time = "2025-10-14T15:04:45.883Z" }, + { url = "https://files.pythonhosted.org/packages/74/d5/f039e7e3c639d9b1d09b07ea412a6806d38123f0508e5f9b48a87b0a76cc/watchfiles-1.1.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:8c89f9f2f740a6b7dcc753140dd5e1ab9215966f7a3530d0c0705c83b401bd7d", size = 404745, upload-time = "2025-10-14T15:04:46.731Z" }, + { url = "https://files.pythonhosted.org/packages/a5/96/a881a13aa1349827490dab2d363c8039527060cfcc2c92cc6d13d1b1049e/watchfiles-1.1.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:bd404be08018c37350f0d6e34676bd1e2889990117a2b90070b3007f172d0610", size = 391769, upload-time = "2025-10-14T15:04:48.003Z" }, + { url = "https://files.pythonhosted.org/packages/4b/5b/d3b460364aeb8da471c1989238ea0e56bec24b6042a68046adf3d9ddb01c/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8526e8f916bb5b9a0a777c8317c23ce65de259422bba5b31325a6fa6029d33af", size = 449374, upload-time = "2025-10-14T15:04:49.179Z" }, + { url = "https://files.pythonhosted.org/packages/b9/44/5769cb62d4ed055cb17417c0a109a92f007114a4e07f30812a73a4efdb11/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2edc3553362b1c38d9f06242416a5d8e9fe235c204a4072e988ce2e5bb1f69f6", size = 459485, upload-time = "2025-10-14T15:04:50.155Z" }, + { url = "https://files.pythonhosted.org/packages/19/0c/286b6301ded2eccd4ffd0041a1b726afda999926cf720aab63adb68a1e36/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:30f7da3fb3f2844259cba4720c3fc7138eb0f7b659c38f3bfa65084c7fc7abce", size = 488813, upload-time = "2025-10-14T15:04:51.059Z" }, + { url = "https://files.pythonhosted.org/packages/c7/2b/8530ed41112dd4a22f4dcfdb5ccf6a1baad1ff6eed8dc5a5f09e7e8c41c7/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f8979280bdafff686ba5e4d8f97840f929a87ed9cdf133cbbd42f7766774d2aa", size = 594816, upload-time = "2025-10-14T15:04:52.031Z" }, + { url = "https://files.pythonhosted.org/packages/ce/d2/f5f9fb49489f184f18470d4f99f4e862a4b3e9ac2865688eb2099e3d837a/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:dcc5c24523771db3a294c77d94771abcfcb82a0e0ee8efd910c37c59ec1b31bb", size = 475186, upload-time = "2025-10-14T15:04:53.064Z" }, + { url = "https://files.pythonhosted.org/packages/cf/68/5707da262a119fb06fbe214d82dd1fe4a6f4af32d2d14de368d0349eb52a/watchfiles-1.1.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1db5d7ae38ff20153d542460752ff397fcf5c96090c1230803713cf3147a6803", size = 456812, upload-time = "2025-10-14T15:04:55.174Z" }, + { url = "https://files.pythonhosted.org/packages/66/ab/3cbb8756323e8f9b6f9acb9ef4ec26d42b2109bce830cc1f3468df20511d/watchfiles-1.1.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:28475ddbde92df1874b6c5c8aaeb24ad5be47a11f87cde5a28ef3835932e3e94", size = 630196, upload-time = "2025-10-14T15:04:56.22Z" }, + { url = "https://files.pythonhosted.org/packages/78/46/7152ec29b8335f80167928944a94955015a345440f524d2dfe63fc2f437b/watchfiles-1.1.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:36193ed342f5b9842edd3532729a2ad55c4160ffcfa3700e0d54be496b70dd43", size = 622657, upload-time = "2025-10-14T15:04:57.521Z" }, + { url = "https://files.pythonhosted.org/packages/0a/bf/95895e78dd75efe9a7f31733607f384b42eb5feb54bd2eb6ed57cc2e94f4/watchfiles-1.1.1-cp312-cp312-win32.whl", hash = "sha256:859e43a1951717cc8de7f4c77674a6d389b106361585951d9e69572823f311d9", size = 272042, upload-time = "2025-10-14T15:04:59.046Z" }, + { url = "https://files.pythonhosted.org/packages/87/0a/90eb755f568de2688cb220171c4191df932232c20946966c27a59c400850/watchfiles-1.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:91d4c9a823a8c987cce8fa2690923b069966dabb196dd8d137ea2cede885fde9", size = 288410, upload-time = "2025-10-14T15:05:00.081Z" }, + { url = "https://files.pythonhosted.org/packages/36/76/f322701530586922fbd6723c4f91ace21364924822a8772c549483abed13/watchfiles-1.1.1-cp312-cp312-win_arm64.whl", hash = "sha256:a625815d4a2bdca61953dbba5a39d60164451ef34c88d751f6c368c3ea73d404", size = 278209, upload-time = "2025-10-14T15:05:01.168Z" }, + { url = "https://files.pythonhosted.org/packages/bb/f4/f750b29225fe77139f7ae5de89d4949f5a99f934c65a1f1c0b248f26f747/watchfiles-1.1.1-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:130e4876309e8686a5e37dba7d5e9bc77e6ed908266996ca26572437a5271e18", size = 404321, upload-time = "2025-10-14T15:05:02.063Z" }, + { url = "https://files.pythonhosted.org/packages/2b/f9/f07a295cde762644aa4c4bb0f88921d2d141af45e735b965fb2e87858328/watchfiles-1.1.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:5f3bde70f157f84ece3765b42b4a52c6ac1a50334903c6eaf765362f6ccca88a", size = 391783, upload-time = "2025-10-14T15:05:03.052Z" }, + { url = "https://files.pythonhosted.org/packages/bc/11/fc2502457e0bea39a5c958d86d2cb69e407a4d00b85735ca724bfa6e0d1a/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:14e0b1fe858430fc0251737ef3824c54027bedb8c37c38114488b8e131cf8219", size = 449279, upload-time = "2025-10-14T15:05:04.004Z" }, + { url = "https://files.pythonhosted.org/packages/e3/1f/d66bc15ea0b728df3ed96a539c777acfcad0eb78555ad9efcaa1274688f0/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f27db948078f3823a6bb3b465180db8ebecf26dd5dae6f6180bd87383b6b4428", size = 459405, upload-time = "2025-10-14T15:05:04.942Z" }, + { url = "https://files.pythonhosted.org/packages/be/90/9f4a65c0aec3ccf032703e6db02d89a157462fbb2cf20dd415128251cac0/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:059098c3a429f62fc98e8ec62b982230ef2c8df68c79e826e37b895bc359a9c0", size = 488976, upload-time = "2025-10-14T15:05:05.905Z" }, + { url = "https://files.pythonhosted.org/packages/37/57/ee347af605d867f712be7029bb94c8c071732a4b44792e3176fa3c612d39/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bfb5862016acc9b869bb57284e6cb35fdf8e22fe59f7548858e2f971d045f150", size = 595506, upload-time = "2025-10-14T15:05:06.906Z" }, + { url = "https://files.pythonhosted.org/packages/a8/78/cc5ab0b86c122047f75e8fc471c67a04dee395daf847d3e59381996c8707/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:319b27255aacd9923b8a276bb14d21a5f7ff82564c744235fc5eae58d95422ae", size = 474936, upload-time = "2025-10-14T15:05:07.906Z" }, + { url = "https://files.pythonhosted.org/packages/62/da/def65b170a3815af7bd40a3e7010bf6ab53089ef1b75d05dd5385b87cf08/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c755367e51db90e75b19454b680903631d41f9e3607fbd941d296a020c2d752d", size = 456147, upload-time = "2025-10-14T15:05:09.138Z" }, + { url = "https://files.pythonhosted.org/packages/57/99/da6573ba71166e82d288d4df0839128004c67d2778d3b566c138695f5c0b/watchfiles-1.1.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:c22c776292a23bfc7237a98f791b9ad3144b02116ff10d820829ce62dff46d0b", size = 630007, upload-time = "2025-10-14T15:05:10.117Z" }, + { url = "https://files.pythonhosted.org/packages/a8/51/7439c4dd39511368849eb1e53279cd3454b4a4dbace80bab88feeb83c6b5/watchfiles-1.1.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:3a476189be23c3686bc2f4321dd501cb329c0a0469e77b7b534ee10129ae6374", size = 622280, upload-time = "2025-10-14T15:05:11.146Z" }, + { url = "https://files.pythonhosted.org/packages/95/9c/8ed97d4bba5db6fdcdb2b298d3898f2dd5c20f6b73aee04eabe56c59677e/watchfiles-1.1.1-cp313-cp313-win32.whl", hash = "sha256:bf0a91bfb5574a2f7fc223cf95eeea79abfefa404bf1ea5e339c0c1560ae99a0", size = 272056, upload-time = "2025-10-14T15:05:12.156Z" }, + { url = "https://files.pythonhosted.org/packages/1f/f3/c14e28429f744a260d8ceae18bf58c1d5fa56b50d006a7a9f80e1882cb0d/watchfiles-1.1.1-cp313-cp313-win_amd64.whl", hash = "sha256:52e06553899e11e8074503c8e716d574adeeb7e68913115c4b3653c53f9bae42", size = 288162, upload-time = "2025-10-14T15:05:13.208Z" }, + { url = "https://files.pythonhosted.org/packages/dc/61/fe0e56c40d5cd29523e398d31153218718c5786b5e636d9ae8ae79453d27/watchfiles-1.1.1-cp313-cp313-win_arm64.whl", hash = "sha256:ac3cc5759570cd02662b15fbcd9d917f7ecd47efe0d6b40474eafd246f91ea18", size = 277909, upload-time = "2025-10-14T15:05:14.49Z" }, + { url = "https://files.pythonhosted.org/packages/79/42/e0a7d749626f1e28c7108a99fb9bf524b501bbbeb9b261ceecde644d5a07/watchfiles-1.1.1-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:563b116874a9a7ce6f96f87cd0b94f7faf92d08d0021e837796f0a14318ef8da", size = 403389, upload-time = "2025-10-14T15:05:15.777Z" }, + { url = "https://files.pythonhosted.org/packages/15/49/08732f90ce0fbbc13913f9f215c689cfc9ced345fb1bcd8829a50007cc8d/watchfiles-1.1.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3ad9fe1dae4ab4212d8c91e80b832425e24f421703b5a42ef2e4a1e215aff051", size = 389964, upload-time = "2025-10-14T15:05:16.85Z" }, + { url = "https://files.pythonhosted.org/packages/27/0d/7c315d4bd5f2538910491a0393c56bf70d333d51bc5b34bee8e68e8cea19/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ce70f96a46b894b36eba678f153f052967a0d06d5b5a19b336ab0dbbd029f73e", size = 448114, upload-time = "2025-10-14T15:05:17.876Z" }, + { url = "https://files.pythonhosted.org/packages/c3/24/9e096de47a4d11bc4df41e9d1e61776393eac4cb6eb11b3e23315b78b2cc/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:cb467c999c2eff23a6417e58d75e5828716f42ed8289fe6b77a7e5a91036ca70", size = 460264, upload-time = "2025-10-14T15:05:18.962Z" }, + { url = "https://files.pythonhosted.org/packages/cc/0f/e8dea6375f1d3ba5fcb0b3583e2b493e77379834c74fd5a22d66d85d6540/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:836398932192dae4146c8f6f737d74baeac8b70ce14831a239bdb1ca882fc261", size = 487877, upload-time = "2025-10-14T15:05:20.094Z" }, + { url = "https://files.pythonhosted.org/packages/ac/5b/df24cfc6424a12deb41503b64d42fbea6b8cb357ec62ca84a5a3476f654a/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:743185e7372b7bc7c389e1badcc606931a827112fbbd37f14c537320fca08620", size = 595176, upload-time = "2025-10-14T15:05:21.134Z" }, + { url = "https://files.pythonhosted.org/packages/8f/b5/853b6757f7347de4e9b37e8cc3289283fb983cba1ab4d2d7144694871d9c/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:afaeff7696e0ad9f02cbb8f56365ff4686ab205fcf9c4c5b6fdfaaa16549dd04", size = 473577, upload-time = "2025-10-14T15:05:22.306Z" }, + { url = "https://files.pythonhosted.org/packages/e1/f7/0a4467be0a56e80447c8529c9fce5b38eab4f513cb3d9bf82e7392a5696b/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3f7eb7da0eb23aa2ba036d4f616d46906013a68caf61b7fdbe42fc8b25132e77", size = 455425, upload-time = "2025-10-14T15:05:23.348Z" }, + { url = "https://files.pythonhosted.org/packages/8e/e0/82583485ea00137ddf69bc84a2db88bd92ab4a6e3c405e5fb878ead8d0e7/watchfiles-1.1.1-cp313-cp313t-musllinux_1_1_aarch64.whl", hash = "sha256:831a62658609f0e5c64178211c942ace999517f5770fe9436be4c2faeba0c0ef", size = 628826, upload-time = "2025-10-14T15:05:24.398Z" }, + { url = "https://files.pythonhosted.org/packages/28/9a/a785356fccf9fae84c0cc90570f11702ae9571036fb25932f1242c82191c/watchfiles-1.1.1-cp313-cp313t-musllinux_1_1_x86_64.whl", hash = "sha256:f9a2ae5c91cecc9edd47e041a930490c31c3afb1f5e6d71de3dc671bfaca02bf", size = 622208, upload-time = "2025-10-14T15:05:25.45Z" }, + { url = "https://files.pythonhosted.org/packages/c3/f4/0872229324ef69b2c3edec35e84bd57a1289e7d3fe74588048ed8947a323/watchfiles-1.1.1-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:d1715143123baeeaeadec0528bb7441103979a1d5f6fd0e1f915383fea7ea6d5", size = 404315, upload-time = "2025-10-14T15:05:26.501Z" }, + { url = "https://files.pythonhosted.org/packages/7b/22/16d5331eaed1cb107b873f6ae1b69e9ced582fcf0c59a50cd84f403b1c32/watchfiles-1.1.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:39574d6370c4579d7f5d0ad940ce5b20db0e4117444e39b6d8f99db5676c52fd", size = 390869, upload-time = "2025-10-14T15:05:27.649Z" }, + { url = "https://files.pythonhosted.org/packages/b2/7e/5643bfff5acb6539b18483128fdc0ef2cccc94a5b8fbda130c823e8ed636/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7365b92c2e69ee952902e8f70f3ba6360d0d596d9299d55d7d386df84b6941fb", size = 449919, upload-time = "2025-10-14T15:05:28.701Z" }, + { url = "https://files.pythonhosted.org/packages/51/2e/c410993ba5025a9f9357c376f48976ef0e1b1aefb73b97a5ae01a5972755/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:bfff9740c69c0e4ed32416f013f3c45e2ae42ccedd1167ef2d805c000b6c71a5", size = 460845, upload-time = "2025-10-14T15:05:30.064Z" }, + { url = "https://files.pythonhosted.org/packages/8e/a4/2df3b404469122e8680f0fcd06079317e48db58a2da2950fb45020947734/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b27cf2eb1dda37b2089e3907d8ea92922b673c0c427886d4edc6b94d8dfe5db3", size = 489027, upload-time = "2025-10-14T15:05:31.064Z" }, + { url = "https://files.pythonhosted.org/packages/ea/84/4587ba5b1f267167ee715b7f66e6382cca6938e0a4b870adad93e44747e6/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:526e86aced14a65a5b0ec50827c745597c782ff46b571dbfe46192ab9e0b3c33", size = 595615, upload-time = "2025-10-14T15:05:32.074Z" }, + { url = "https://files.pythonhosted.org/packages/6a/0f/c6988c91d06e93cd0bb3d4a808bcf32375ca1904609835c3031799e3ecae/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:04e78dd0b6352db95507fd8cb46f39d185cf8c74e4cf1e4fbad1d3df96faf510", size = 474836, upload-time = "2025-10-14T15:05:33.209Z" }, + { url = "https://files.pythonhosted.org/packages/b4/36/ded8aebea91919485b7bbabbd14f5f359326cb5ec218cd67074d1e426d74/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5c85794a4cfa094714fb9c08d4a218375b2b95b8ed1666e8677c349906246c05", size = 455099, upload-time = "2025-10-14T15:05:34.189Z" }, + { url = "https://files.pythonhosted.org/packages/98/e0/8c9bdba88af756a2fce230dd365fab2baf927ba42cd47521ee7498fd5211/watchfiles-1.1.1-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:74d5012b7630714b66be7b7b7a78855ef7ad58e8650c73afc4c076a1f480a8d6", size = 630626, upload-time = "2025-10-14T15:05:35.216Z" }, + { url = "https://files.pythonhosted.org/packages/2a/84/a95db05354bf2d19e438520d92a8ca475e578c647f78f53197f5a2f17aaf/watchfiles-1.1.1-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:8fbe85cb3201c7d380d3d0b90e63d520f15d6afe217165d7f98c9c649654db81", size = 622519, upload-time = "2025-10-14T15:05:36.259Z" }, + { url = "https://files.pythonhosted.org/packages/1d/ce/d8acdc8de545de995c339be67711e474c77d643555a9bb74a9334252bd55/watchfiles-1.1.1-cp314-cp314-win32.whl", hash = "sha256:3fa0b59c92278b5a7800d3ee7733da9d096d4aabcfabb9a928918bd276ef9b9b", size = 272078, upload-time = "2025-10-14T15:05:37.63Z" }, + { url = "https://files.pythonhosted.org/packages/c4/c9/a74487f72d0451524be827e8edec251da0cc1fcf111646a511ae752e1a3d/watchfiles-1.1.1-cp314-cp314-win_amd64.whl", hash = "sha256:c2047d0b6cea13b3316bdbafbfa0c4228ae593d995030fda39089d36e64fc03a", size = 287664, upload-time = "2025-10-14T15:05:38.95Z" }, + { url = "https://files.pythonhosted.org/packages/df/b8/8ac000702cdd496cdce998c6f4ee0ca1f15977bba51bdf07d872ebdfc34c/watchfiles-1.1.1-cp314-cp314-win_arm64.whl", hash = "sha256:842178b126593addc05acf6fce960d28bc5fae7afbaa2c6c1b3a7b9460e5be02", size = 277154, upload-time = "2025-10-14T15:05:39.954Z" }, + { url = "https://files.pythonhosted.org/packages/47/a8/e3af2184707c29f0f14b1963c0aace6529f9d1b8582d5b99f31bbf42f59e/watchfiles-1.1.1-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:88863fbbc1a7312972f1c511f202eb30866370ebb8493aef2812b9ff28156a21", size = 403820, upload-time = "2025-10-14T15:05:40.932Z" }, + { url = "https://files.pythonhosted.org/packages/c0/ec/e47e307c2f4bd75f9f9e8afbe3876679b18e1bcec449beca132a1c5ffb2d/watchfiles-1.1.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:55c7475190662e202c08c6c0f4d9e345a29367438cf8e8037f3155e10a88d5a5", size = 390510, upload-time = "2025-10-14T15:05:41.945Z" }, + { url = "https://files.pythonhosted.org/packages/d5/a0/ad235642118090f66e7b2f18fd5c42082418404a79205cdfca50b6309c13/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3f53fa183d53a1d7a8852277c92b967ae99c2d4dcee2bfacff8868e6e30b15f7", size = 448408, upload-time = "2025-10-14T15:05:43.385Z" }, + { url = "https://files.pythonhosted.org/packages/df/85/97fa10fd5ff3332ae17e7e40e20784e419e28521549780869f1413742e9d/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6aae418a8b323732fa89721d86f39ec8f092fc2af67f4217a2b07fd3e93c6101", size = 458968, upload-time = "2025-10-14T15:05:44.404Z" }, + { url = "https://files.pythonhosted.org/packages/47/c2/9059c2e8966ea5ce678166617a7f75ecba6164375f3b288e50a40dc6d489/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f096076119da54a6080e8920cbdaac3dbee667eb91dcc5e5b78840b87415bd44", size = 488096, upload-time = "2025-10-14T15:05:45.398Z" }, + { url = "https://files.pythonhosted.org/packages/94/44/d90a9ec8ac309bc26db808a13e7bfc0e4e78b6fc051078a554e132e80160/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:00485f441d183717038ed2e887a7c868154f216877653121068107b227a2f64c", size = 596040, upload-time = "2025-10-14T15:05:46.502Z" }, + { url = "https://files.pythonhosted.org/packages/95/68/4e3479b20ca305cfc561db3ed207a8a1c745ee32bf24f2026a129d0ddb6e/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a55f3e9e493158d7bfdb60a1165035f1cf7d320914e7b7ea83fe22c6023b58fc", size = 473847, upload-time = "2025-10-14T15:05:47.484Z" }, + { url = "https://files.pythonhosted.org/packages/4f/55/2af26693fd15165c4ff7857e38330e1b61ab8c37d15dc79118cdba115b7a/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8c91ed27800188c2ae96d16e3149f199d62f86c7af5f5f4d2c61a3ed8cd3666c", size = 455072, upload-time = "2025-10-14T15:05:48.928Z" }, + { url = "https://files.pythonhosted.org/packages/66/1d/d0d200b10c9311ec25d2273f8aad8c3ef7cc7ea11808022501811208a750/watchfiles-1.1.1-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:311ff15a0bae3714ffb603e6ba6dbfba4065ab60865d15a6ec544133bdb21099", size = 629104, upload-time = "2025-10-14T15:05:49.908Z" }, + { url = "https://files.pythonhosted.org/packages/e3/bd/fa9bb053192491b3867ba07d2343d9f2252e00811567d30ae8d0f78136fe/watchfiles-1.1.1-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:a916a2932da8f8ab582f242c065f5c81bed3462849ca79ee357dd9551b0e9b01", size = 622112, upload-time = "2025-10-14T15:05:50.941Z" }, + { url = "https://files.pythonhosted.org/packages/ba/4c/a888c91e2e326872fa4705095d64acd8aa2fb9c1f7b9bd0588f33850516c/watchfiles-1.1.1-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:17ef139237dfced9da49fb7f2232c86ca9421f666d78c264c7ffca6601d154c3", size = 409611, upload-time = "2025-10-14T15:06:05.809Z" }, + { url = "https://files.pythonhosted.org/packages/1e/c7/5420d1943c8e3ce1a21c0a9330bcf7edafb6aa65d26b21dbb3267c9e8112/watchfiles-1.1.1-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:672b8adf25b1a0d35c96b5888b7b18699d27d4194bac8beeae75be4b7a3fc9b2", size = 396889, upload-time = "2025-10-14T15:06:07.035Z" }, + { url = "https://files.pythonhosted.org/packages/0c/e5/0072cef3804ce8d3aaddbfe7788aadff6b3d3f98a286fdbee9fd74ca59a7/watchfiles-1.1.1-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:77a13aea58bc2b90173bc69f2a90de8e282648939a00a602e1dc4ee23e26b66d", size = 451616, upload-time = "2025-10-14T15:06:08.072Z" }, + { url = "https://files.pythonhosted.org/packages/83/4e/b87b71cbdfad81ad7e83358b3e447fedd281b880a03d64a760fe0a11fc2e/watchfiles-1.1.1-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0b495de0bb386df6a12b18335a0285dda90260f51bdb505503c02bcd1ce27a8b", size = 458413, upload-time = "2025-10-14T15:06:09.209Z" }, + { url = "https://files.pythonhosted.org/packages/d3/8e/e500f8b0b77be4ff753ac94dc06b33d8f0d839377fee1b78e8c8d8f031bf/watchfiles-1.1.1-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:db476ab59b6765134de1d4fe96a1a9c96ddf091683599be0f26147ea1b2e4b88", size = 408250, upload-time = "2025-10-14T15:06:10.264Z" }, + { url = "https://files.pythonhosted.org/packages/bd/95/615e72cd27b85b61eec764a5ca51bd94d40b5adea5ff47567d9ebc4d275a/watchfiles-1.1.1-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:89eef07eee5e9d1fda06e38822ad167a044153457e6fd997f8a858ab7564a336", size = 396117, upload-time = "2025-10-14T15:06:11.28Z" }, + { url = "https://files.pythonhosted.org/packages/c9/81/e7fe958ce8a7fb5c73cc9fb07f5aeaf755e6aa72498c57d760af760c91f8/watchfiles-1.1.1-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ce19e06cbda693e9e7686358af9cd6f5d61312ab8b00488bc36f5aabbaf77e24", size = 450493, upload-time = "2025-10-14T15:06:12.321Z" }, + { url = "https://files.pythonhosted.org/packages/6e/d4/ed38dd3b1767193de971e694aa544356e63353c33a85d948166b5ff58b9e/watchfiles-1.1.1-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3e6f39af2eab0118338902798b5aa6664f46ff66bc0280de76fca67a7f262a49", size = 457546, upload-time = "2025-10-14T15:06:13.372Z" }, +] + +[[package]] +name = "wcwidth" +version = "0.2.14" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/24/30/6b0809f4510673dc723187aeaf24c7f5459922d01e2f794277a3dfb90345/wcwidth-0.2.14.tar.gz", hash = "sha256:4d478375d31bc5395a3c55c40ccdf3354688364cd61c4f6adacaa9215d0b3605", size = 102293, upload-time = "2025-09-22T16:29:53.023Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/af/b5/123f13c975e9f27ab9c0770f514345bd406d0e8d3b7a0723af9d43f710af/wcwidth-0.2.14-py2.py3-none-any.whl", hash = "sha256:a7bb560c8aee30f9957e5f9895805edd20602f2d7f720186dfd906e82b4982e1", size = 37286, upload-time = "2025-09-22T16:29:51.641Z" }, +] + +[[package]] +name = "websockets" +version = "15.0.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/21/e6/26d09fab466b7ca9c7737474c52be4f76a40301b08362eb2dbc19dcc16c1/websockets-15.0.1.tar.gz", hash = "sha256:82544de02076bafba038ce055ee6412d68da13ab47f0c60cab827346de828dee", size = 177016, upload-time = "2025-03-05T20:03:41.606Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1e/da/6462a9f510c0c49837bbc9345aca92d767a56c1fb2939e1579df1e1cdcf7/websockets-15.0.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:d63efaa0cd96cf0c5fe4d581521d9fa87744540d4bc999ae6e08595a1014b45b", size = 175423, upload-time = "2025-03-05T20:01:35.363Z" }, + { url = "https://files.pythonhosted.org/packages/1c/9f/9d11c1a4eb046a9e106483b9ff69bce7ac880443f00e5ce64261b47b07e7/websockets-15.0.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:ac60e3b188ec7574cb761b08d50fcedf9d77f1530352db4eef1707fe9dee7205", size = 173080, upload-time = "2025-03-05T20:01:37.304Z" }, + { url = "https://files.pythonhosted.org/packages/d5/4f/b462242432d93ea45f297b6179c7333dd0402b855a912a04e7fc61c0d71f/websockets-15.0.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:5756779642579d902eed757b21b0164cd6fe338506a8083eb58af5c372e39d9a", size = 173329, upload-time = "2025-03-05T20:01:39.668Z" }, + { url = "https://files.pythonhosted.org/packages/6e/0c/6afa1f4644d7ed50284ac59cc70ef8abd44ccf7d45850d989ea7310538d0/websockets-15.0.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0fdfe3e2a29e4db3659dbd5bbf04560cea53dd9610273917799f1cde46aa725e", size = 182312, upload-time = "2025-03-05T20:01:41.815Z" }, + { url = "https://files.pythonhosted.org/packages/dd/d4/ffc8bd1350b229ca7a4db2a3e1c482cf87cea1baccd0ef3e72bc720caeec/websockets-15.0.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4c2529b320eb9e35af0fa3016c187dffb84a3ecc572bcee7c3ce302bfeba52bf", size = 181319, upload-time = "2025-03-05T20:01:43.967Z" }, + { url = "https://files.pythonhosted.org/packages/97/3a/5323a6bb94917af13bbb34009fac01e55c51dfde354f63692bf2533ffbc2/websockets-15.0.1-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ac1e5c9054fe23226fb11e05a6e630837f074174c4c2f0fe442996112a6de4fb", size = 181631, upload-time = "2025-03-05T20:01:46.104Z" }, + { url = "https://files.pythonhosted.org/packages/a6/cc/1aeb0f7cee59ef065724041bb7ed667b6ab1eeffe5141696cccec2687b66/websockets-15.0.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:5df592cd503496351d6dc14f7cdad49f268d8e618f80dce0cd5a36b93c3fc08d", size = 182016, upload-time = "2025-03-05T20:01:47.603Z" }, + { url = "https://files.pythonhosted.org/packages/79/f9/c86f8f7af208e4161a7f7e02774e9d0a81c632ae76db2ff22549e1718a51/websockets-15.0.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:0a34631031a8f05657e8e90903e656959234f3a04552259458aac0b0f9ae6fd9", size = 181426, upload-time = "2025-03-05T20:01:48.949Z" }, + { url = "https://files.pythonhosted.org/packages/c7/b9/828b0bc6753db905b91df6ae477c0b14a141090df64fb17f8a9d7e3516cf/websockets-15.0.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:3d00075aa65772e7ce9e990cab3ff1de702aa09be3940d1dc88d5abf1ab8a09c", size = 181360, upload-time = "2025-03-05T20:01:50.938Z" }, + { url = "https://files.pythonhosted.org/packages/89/fb/250f5533ec468ba6327055b7d98b9df056fb1ce623b8b6aaafb30b55d02e/websockets-15.0.1-cp310-cp310-win32.whl", hash = "sha256:1234d4ef35db82f5446dca8e35a7da7964d02c127b095e172e54397fb6a6c256", size = 176388, upload-time = "2025-03-05T20:01:52.213Z" }, + { url = "https://files.pythonhosted.org/packages/1c/46/aca7082012768bb98e5608f01658ff3ac8437e563eca41cf068bd5849a5e/websockets-15.0.1-cp310-cp310-win_amd64.whl", hash = "sha256:39c1fec2c11dc8d89bba6b2bf1556af381611a173ac2b511cf7231622058af41", size = 176830, upload-time = "2025-03-05T20:01:53.922Z" }, + { url = "https://files.pythonhosted.org/packages/9f/32/18fcd5919c293a398db67443acd33fde142f283853076049824fc58e6f75/websockets-15.0.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:823c248b690b2fd9303ba00c4f66cd5e2d8c3ba4aa968b2779be9532a4dad431", size = 175423, upload-time = "2025-03-05T20:01:56.276Z" }, + { url = "https://files.pythonhosted.org/packages/76/70/ba1ad96b07869275ef42e2ce21f07a5b0148936688c2baf7e4a1f60d5058/websockets-15.0.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678999709e68425ae2593acf2e3ebcbcf2e69885a5ee78f9eb80e6e371f1bf57", size = 173082, upload-time = "2025-03-05T20:01:57.563Z" }, + { url = "https://files.pythonhosted.org/packages/86/f2/10b55821dd40eb696ce4704a87d57774696f9451108cff0d2824c97e0f97/websockets-15.0.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d50fd1ee42388dcfb2b3676132c78116490976f1300da28eb629272d5d93e905", size = 173330, upload-time = "2025-03-05T20:01:59.063Z" }, + { url = "https://files.pythonhosted.org/packages/a5/90/1c37ae8b8a113d3daf1065222b6af61cc44102da95388ac0018fcb7d93d9/websockets-15.0.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d99e5546bf73dbad5bf3547174cd6cb8ba7273062a23808ffea025ecb1cf8562", size = 182878, upload-time = "2025-03-05T20:02:00.305Z" }, + { url = "https://files.pythonhosted.org/packages/8e/8d/96e8e288b2a41dffafb78e8904ea7367ee4f891dafc2ab8d87e2124cb3d3/websockets-15.0.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:66dd88c918e3287efc22409d426c8f729688d89a0c587c88971a0faa2c2f3792", size = 181883, upload-time = "2025-03-05T20:02:03.148Z" }, + { url = "https://files.pythonhosted.org/packages/93/1f/5d6dbf551766308f6f50f8baf8e9860be6182911e8106da7a7f73785f4c4/websockets-15.0.1-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8dd8327c795b3e3f219760fa603dcae1dcc148172290a8ab15158cf85a953413", size = 182252, upload-time = "2025-03-05T20:02:05.29Z" }, + { url = "https://files.pythonhosted.org/packages/d4/78/2d4fed9123e6620cbf1706c0de8a1632e1a28e7774d94346d7de1bba2ca3/websockets-15.0.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8fdc51055e6ff4adeb88d58a11042ec9a5eae317a0a53d12c062c8a8865909e8", size = 182521, upload-time = "2025-03-05T20:02:07.458Z" }, + { url = "https://files.pythonhosted.org/packages/e7/3b/66d4c1b444dd1a9823c4a81f50231b921bab54eee2f69e70319b4e21f1ca/websockets-15.0.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:693f0192126df6c2327cce3baa7c06f2a117575e32ab2308f7f8216c29d9e2e3", size = 181958, upload-time = "2025-03-05T20:02:09.842Z" }, + { url = "https://files.pythonhosted.org/packages/08/ff/e9eed2ee5fed6f76fdd6032ca5cd38c57ca9661430bb3d5fb2872dc8703c/websockets-15.0.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:54479983bd5fb469c38f2f5c7e3a24f9a4e70594cd68cd1fa6b9340dadaff7cf", size = 181918, upload-time = "2025-03-05T20:02:11.968Z" }, + { url = "https://files.pythonhosted.org/packages/d8/75/994634a49b7e12532be6a42103597b71098fd25900f7437d6055ed39930a/websockets-15.0.1-cp311-cp311-win32.whl", hash = "sha256:16b6c1b3e57799b9d38427dda63edcbe4926352c47cf88588c0be4ace18dac85", size = 176388, upload-time = "2025-03-05T20:02:13.32Z" }, + { url = "https://files.pythonhosted.org/packages/98/93/e36c73f78400a65f5e236cd376713c34182e6663f6889cd45a4a04d8f203/websockets-15.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:27ccee0071a0e75d22cb35849b1db43f2ecd3e161041ac1ee9d2352ddf72f065", size = 176828, upload-time = "2025-03-05T20:02:14.585Z" }, + { url = "https://files.pythonhosted.org/packages/51/6b/4545a0d843594f5d0771e86463606a3988b5a09ca5123136f8a76580dd63/websockets-15.0.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:3e90baa811a5d73f3ca0bcbf32064d663ed81318ab225ee4f427ad4e26e5aff3", size = 175437, upload-time = "2025-03-05T20:02:16.706Z" }, + { url = "https://files.pythonhosted.org/packages/f4/71/809a0f5f6a06522af902e0f2ea2757f71ead94610010cf570ab5c98e99ed/websockets-15.0.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:592f1a9fe869c778694f0aa806ba0374e97648ab57936f092fd9d87f8bc03665", size = 173096, upload-time = "2025-03-05T20:02:18.832Z" }, + { url = "https://files.pythonhosted.org/packages/3d/69/1a681dd6f02180916f116894181eab8b2e25b31e484c5d0eae637ec01f7c/websockets-15.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0701bc3cfcb9164d04a14b149fd74be7347a530ad3bbf15ab2c678a2cd3dd9a2", size = 173332, upload-time = "2025-03-05T20:02:20.187Z" }, + { url = "https://files.pythonhosted.org/packages/a6/02/0073b3952f5bce97eafbb35757f8d0d54812b6174ed8dd952aa08429bcc3/websockets-15.0.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e8b56bdcdb4505c8078cb6c7157d9811a85790f2f2b3632c7d1462ab5783d215", size = 183152, upload-time = "2025-03-05T20:02:22.286Z" }, + { url = "https://files.pythonhosted.org/packages/74/45/c205c8480eafd114b428284840da0b1be9ffd0e4f87338dc95dc6ff961a1/websockets-15.0.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0af68c55afbd5f07986df82831c7bff04846928ea8d1fd7f30052638788bc9b5", size = 182096, upload-time = "2025-03-05T20:02:24.368Z" }, + { url = "https://files.pythonhosted.org/packages/14/8f/aa61f528fba38578ec553c145857a181384c72b98156f858ca5c8e82d9d3/websockets-15.0.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:64dee438fed052b52e4f98f76c5790513235efaa1ef7f3f2192c392cd7c91b65", size = 182523, upload-time = "2025-03-05T20:02:25.669Z" }, + { url = "https://files.pythonhosted.org/packages/ec/6d/0267396610add5bc0d0d3e77f546d4cd287200804fe02323797de77dbce9/websockets-15.0.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d5f6b181bb38171a8ad1d6aa58a67a6aa9d4b38d0f8c5f496b9e42561dfc62fe", size = 182790, upload-time = "2025-03-05T20:02:26.99Z" }, + { url = "https://files.pythonhosted.org/packages/02/05/c68c5adbf679cf610ae2f74a9b871ae84564462955d991178f95a1ddb7dd/websockets-15.0.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:5d54b09eba2bada6011aea5375542a157637b91029687eb4fdb2dab11059c1b4", size = 182165, upload-time = "2025-03-05T20:02:30.291Z" }, + { url = "https://files.pythonhosted.org/packages/29/93/bb672df7b2f5faac89761cb5fa34f5cec45a4026c383a4b5761c6cea5c16/websockets-15.0.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3be571a8b5afed347da347bfcf27ba12b069d9d7f42cb8c7028b5e98bbb12597", size = 182160, upload-time = "2025-03-05T20:02:31.634Z" }, + { url = "https://files.pythonhosted.org/packages/ff/83/de1f7709376dc3ca9b7eeb4b9a07b4526b14876b6d372a4dc62312bebee0/websockets-15.0.1-cp312-cp312-win32.whl", hash = "sha256:c338ffa0520bdb12fbc527265235639fb76e7bc7faafbb93f6ba80d9c06578a9", size = 176395, upload-time = "2025-03-05T20:02:33.017Z" }, + { url = "https://files.pythonhosted.org/packages/7d/71/abf2ebc3bbfa40f391ce1428c7168fb20582d0ff57019b69ea20fa698043/websockets-15.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:fcd5cf9e305d7b8338754470cf69cf81f420459dbae8a3b40cee57417f4614a7", size = 176841, upload-time = "2025-03-05T20:02:34.498Z" }, + { url = "https://files.pythonhosted.org/packages/cb/9f/51f0cf64471a9d2b4d0fc6c534f323b664e7095640c34562f5182e5a7195/websockets-15.0.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ee443ef070bb3b6ed74514f5efaa37a252af57c90eb33b956d35c8e9c10a1931", size = 175440, upload-time = "2025-03-05T20:02:36.695Z" }, + { url = "https://files.pythonhosted.org/packages/8a/05/aa116ec9943c718905997412c5989f7ed671bc0188ee2ba89520e8765d7b/websockets-15.0.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5a939de6b7b4e18ca683218320fc67ea886038265fd1ed30173f5ce3f8e85675", size = 173098, upload-time = "2025-03-05T20:02:37.985Z" }, + { url = "https://files.pythonhosted.org/packages/ff/0b/33cef55ff24f2d92924923c99926dcce78e7bd922d649467f0eda8368923/websockets-15.0.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:746ee8dba912cd6fc889a8147168991d50ed70447bf18bcda7039f7d2e3d9151", size = 173329, upload-time = "2025-03-05T20:02:39.298Z" }, + { url = "https://files.pythonhosted.org/packages/31/1d/063b25dcc01faa8fada1469bdf769de3768b7044eac9d41f734fd7b6ad6d/websockets-15.0.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:595b6c3969023ecf9041b2936ac3827e4623bfa3ccf007575f04c5a6aa318c22", size = 183111, upload-time = "2025-03-05T20:02:40.595Z" }, + { url = "https://files.pythonhosted.org/packages/93/53/9a87ee494a51bf63e4ec9241c1ccc4f7c2f45fff85d5bde2ff74fcb68b9e/websockets-15.0.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3c714d2fc58b5ca3e285461a4cc0c9a66bd0e24c5da9911e30158286c9b5be7f", size = 182054, upload-time = "2025-03-05T20:02:41.926Z" }, + { url = "https://files.pythonhosted.org/packages/ff/b2/83a6ddf56cdcbad4e3d841fcc55d6ba7d19aeb89c50f24dd7e859ec0805f/websockets-15.0.1-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0f3c1e2ab208db911594ae5b4f79addeb3501604a165019dd221c0bdcabe4db8", size = 182496, upload-time = "2025-03-05T20:02:43.304Z" }, + { url = "https://files.pythonhosted.org/packages/98/41/e7038944ed0abf34c45aa4635ba28136f06052e08fc2168520bb8b25149f/websockets-15.0.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:229cf1d3ca6c1804400b0a9790dc66528e08a6a1feec0d5040e8b9eb14422375", size = 182829, upload-time = "2025-03-05T20:02:48.812Z" }, + { url = "https://files.pythonhosted.org/packages/e0/17/de15b6158680c7623c6ef0db361da965ab25d813ae54fcfeae2e5b9ef910/websockets-15.0.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:756c56e867a90fb00177d530dca4b097dd753cde348448a1012ed6c5131f8b7d", size = 182217, upload-time = "2025-03-05T20:02:50.14Z" }, + { url = "https://files.pythonhosted.org/packages/33/2b/1f168cb6041853eef0362fb9554c3824367c5560cbdaad89ac40f8c2edfc/websockets-15.0.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:558d023b3df0bffe50a04e710bc87742de35060580a293c2a984299ed83bc4e4", size = 182195, upload-time = "2025-03-05T20:02:51.561Z" }, + { url = "https://files.pythonhosted.org/packages/86/eb/20b6cdf273913d0ad05a6a14aed4b9a85591c18a987a3d47f20fa13dcc47/websockets-15.0.1-cp313-cp313-win32.whl", hash = "sha256:ba9e56e8ceeeedb2e080147ba85ffcd5cd0711b89576b83784d8605a7df455fa", size = 176393, upload-time = "2025-03-05T20:02:53.814Z" }, + { url = "https://files.pythonhosted.org/packages/1b/6c/c65773d6cab416a64d191d6ee8a8b1c68a09970ea6909d16965d26bfed1e/websockets-15.0.1-cp313-cp313-win_amd64.whl", hash = "sha256:e09473f095a819042ecb2ab9465aee615bd9c2028e4ef7d933600a8401c79561", size = 176837, upload-time = "2025-03-05T20:02:55.237Z" }, + { url = "https://files.pythonhosted.org/packages/02/9e/d40f779fa16f74d3468357197af8d6ad07e7c5a27ea1ca74ceb38986f77a/websockets-15.0.1-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:0c9e74d766f2818bb95f84c25be4dea09841ac0f734d1966f415e4edfc4ef1c3", size = 173109, upload-time = "2025-03-05T20:03:17.769Z" }, + { url = "https://files.pythonhosted.org/packages/bc/cd/5b887b8585a593073fd92f7c23ecd3985cd2c3175025a91b0d69b0551372/websockets-15.0.1-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:1009ee0c7739c08a0cd59de430d6de452a55e42d6b522de7aa15e6f67db0b8e1", size = 173343, upload-time = "2025-03-05T20:03:19.094Z" }, + { url = "https://files.pythonhosted.org/packages/fe/ae/d34f7556890341e900a95acf4886833646306269f899d58ad62f588bf410/websockets-15.0.1-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:76d1f20b1c7a2fa82367e04982e708723ba0e7b8d43aa643d3dcd404d74f1475", size = 174599, upload-time = "2025-03-05T20:03:21.1Z" }, + { url = "https://files.pythonhosted.org/packages/71/e6/5fd43993a87db364ec60fc1d608273a1a465c0caba69176dd160e197ce42/websockets-15.0.1-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f29d80eb9a9263b8d109135351caf568cc3f80b9928bccde535c235de55c22d9", size = 174207, upload-time = "2025-03-05T20:03:23.221Z" }, + { url = "https://files.pythonhosted.org/packages/2b/fb/c492d6daa5ec067c2988ac80c61359ace5c4c674c532985ac5a123436cec/websockets-15.0.1-pp310-pypy310_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b359ed09954d7c18bbc1680f380c7301f92c60bf924171629c5db97febb12f04", size = 174155, upload-time = "2025-03-05T20:03:25.321Z" }, + { url = "https://files.pythonhosted.org/packages/68/a1/dcb68430b1d00b698ae7a7e0194433bce4f07ded185f0ee5fb21e2a2e91e/websockets-15.0.1-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:cad21560da69f4ce7658ca2cb83138fb4cf695a2ba3e475e0559e05991aa8122", size = 176884, upload-time = "2025-03-05T20:03:27.934Z" }, + { url = "https://files.pythonhosted.org/packages/fa/a8/5b41e0da817d64113292ab1f8247140aac61cbf6cfd085d6a0fa77f4984f/websockets-15.0.1-py3-none-any.whl", hash = "sha256:f7a866fbc1e97b5c617ee4116daaa09b722101d4a3c170c787450ba409f9736f", size = 169743, upload-time = "2025-03-05T20:03:39.41Z" }, +] + +[[package]] +name = "win32-setctime" +version = "1.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b3/8f/705086c9d734d3b663af0e9bb3d4de6578d08f46b1b101c2442fd9aecaa2/win32_setctime-1.2.0.tar.gz", hash = "sha256:ae1fdf948f5640aae05c511ade119313fb6a30d7eabe25fef9764dca5873c4c0", size = 4867, upload-time = "2024-12-07T15:28:28.314Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e1/07/c6fe3ad3e685340704d314d765b7912993bcb8dc198f0e7a89382d37974b/win32_setctime-1.2.0-py3-none-any.whl", hash = "sha256:95d644c4e708aba81dc3704a116d8cbc974d70b3bdb8be1d150e36be6e9d1390", size = 4083, upload-time = "2024-12-07T15:28:26.465Z" }, +] + +[[package]] +name = "wrapt" +version = "1.17.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/95/8f/aeb76c5b46e273670962298c23e7ddde79916cb74db802131d49a85e4b7d/wrapt-1.17.3.tar.gz", hash = "sha256:f66eb08feaa410fe4eebd17f2a2c8e2e46d3476e9f8c783daa8e09e0faa666d0", size = 55547, upload-time = "2025-08-12T05:53:21.714Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3f/23/bb82321b86411eb51e5a5db3fb8f8032fd30bd7c2d74bfe936136b2fa1d6/wrapt-1.17.3-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:88bbae4d40d5a46142e70d58bf664a89b6b4befaea7b2ecc14e03cedb8e06c04", size = 53482, upload-time = "2025-08-12T05:51:44.467Z" }, + { url = "https://files.pythonhosted.org/packages/45/69/f3c47642b79485a30a59c63f6d739ed779fb4cc8323205d047d741d55220/wrapt-1.17.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e6b13af258d6a9ad602d57d889f83b9d5543acd471eee12eb51f5b01f8eb1bc2", size = 38676, upload-time = "2025-08-12T05:51:32.636Z" }, + { url = "https://files.pythonhosted.org/packages/d1/71/e7e7f5670c1eafd9e990438e69d8fb46fa91a50785332e06b560c869454f/wrapt-1.17.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:fd341868a4b6714a5962c1af0bd44f7c404ef78720c7de4892901e540417111c", size = 38957, upload-time = "2025-08-12T05:51:54.655Z" }, + { url = "https://files.pythonhosted.org/packages/de/17/9f8f86755c191d6779d7ddead1a53c7a8aa18bccb7cea8e7e72dfa6a8a09/wrapt-1.17.3-cp310-cp310-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:f9b2601381be482f70e5d1051a5965c25fb3625455a2bf520b5a077b22afb775", size = 81975, upload-time = "2025-08-12T05:52:30.109Z" }, + { url = "https://files.pythonhosted.org/packages/f2/15/dd576273491f9f43dd09fce517f6c2ce6eb4fe21681726068db0d0467096/wrapt-1.17.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:343e44b2a8e60e06a7e0d29c1671a0d9951f59174f3709962b5143f60a2a98bd", size = 83149, upload-time = "2025-08-12T05:52:09.316Z" }, + { url = "https://files.pythonhosted.org/packages/0c/c4/5eb4ce0d4814521fee7aa806264bf7a114e748ad05110441cd5b8a5c744b/wrapt-1.17.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:33486899acd2d7d3066156b03465b949da3fd41a5da6e394ec49d271baefcf05", size = 82209, upload-time = "2025-08-12T05:52:10.331Z" }, + { url = "https://files.pythonhosted.org/packages/31/4b/819e9e0eb5c8dc86f60dfc42aa4e2c0d6c3db8732bce93cc752e604bb5f5/wrapt-1.17.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:e6f40a8aa5a92f150bdb3e1c44b7e98fb7113955b2e5394122fa5532fec4b418", size = 81551, upload-time = "2025-08-12T05:52:31.137Z" }, + { url = "https://files.pythonhosted.org/packages/f8/83/ed6baf89ba3a56694700139698cf703aac9f0f9eb03dab92f57551bd5385/wrapt-1.17.3-cp310-cp310-win32.whl", hash = "sha256:a36692b8491d30a8c75f1dfee65bef119d6f39ea84ee04d9f9311f83c5ad9390", size = 36464, upload-time = "2025-08-12T05:53:01.204Z" }, + { url = "https://files.pythonhosted.org/packages/2f/90/ee61d36862340ad7e9d15a02529df6b948676b9a5829fd5e16640156627d/wrapt-1.17.3-cp310-cp310-win_amd64.whl", hash = "sha256:afd964fd43b10c12213574db492cb8f73b2f0826c8df07a68288f8f19af2ebe6", size = 38748, upload-time = "2025-08-12T05:53:00.209Z" }, + { url = "https://files.pythonhosted.org/packages/bd/c3/cefe0bd330d389c9983ced15d326f45373f4073c9f4a8c2f99b50bfea329/wrapt-1.17.3-cp310-cp310-win_arm64.whl", hash = "sha256:af338aa93554be859173c39c85243970dc6a289fa907402289eeae7543e1ae18", size = 36810, upload-time = "2025-08-12T05:52:51.906Z" }, + { url = "https://files.pythonhosted.org/packages/52/db/00e2a219213856074a213503fdac0511203dceefff26e1daa15250cc01a0/wrapt-1.17.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:273a736c4645e63ac582c60a56b0acb529ef07f78e08dc6bfadf6a46b19c0da7", size = 53482, upload-time = "2025-08-12T05:51:45.79Z" }, + { url = "https://files.pythonhosted.org/packages/5e/30/ca3c4a5eba478408572096fe9ce36e6e915994dd26a4e9e98b4f729c06d9/wrapt-1.17.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5531d911795e3f935a9c23eb1c8c03c211661a5060aab167065896bbf62a5f85", size = 38674, upload-time = "2025-08-12T05:51:34.629Z" }, + { url = "https://files.pythonhosted.org/packages/31/25/3e8cc2c46b5329c5957cec959cb76a10718e1a513309c31399a4dad07eb3/wrapt-1.17.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:0610b46293c59a3adbae3dee552b648b984176f8562ee0dba099a56cfbe4df1f", size = 38959, upload-time = "2025-08-12T05:51:56.074Z" }, + { url = "https://files.pythonhosted.org/packages/5d/8f/a32a99fc03e4b37e31b57cb9cefc65050ea08147a8ce12f288616b05ef54/wrapt-1.17.3-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b32888aad8b6e68f83a8fdccbf3165f5469702a7544472bdf41f582970ed3311", size = 82376, upload-time = "2025-08-12T05:52:32.134Z" }, + { url = "https://files.pythonhosted.org/packages/31/57/4930cb8d9d70d59c27ee1332a318c20291749b4fba31f113c2f8ac49a72e/wrapt-1.17.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8cccf4f81371f257440c88faed6b74f1053eef90807b77e31ca057b2db74edb1", size = 83604, upload-time = "2025-08-12T05:52:11.663Z" }, + { url = "https://files.pythonhosted.org/packages/a8/f3/1afd48de81d63dd66e01b263a6fbb86e1b5053b419b9b33d13e1f6d0f7d0/wrapt-1.17.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d8a210b158a34164de8bb68b0e7780041a903d7b00c87e906fb69928bf7890d5", size = 82782, upload-time = "2025-08-12T05:52:12.626Z" }, + { url = "https://files.pythonhosted.org/packages/1e/d7/4ad5327612173b144998232f98a85bb24b60c352afb73bc48e3e0d2bdc4e/wrapt-1.17.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:79573c24a46ce11aab457b472efd8d125e5a51da2d1d24387666cd85f54c05b2", size = 82076, upload-time = "2025-08-12T05:52:33.168Z" }, + { url = "https://files.pythonhosted.org/packages/bb/59/e0adfc831674a65694f18ea6dc821f9fcb9ec82c2ce7e3d73a88ba2e8718/wrapt-1.17.3-cp311-cp311-win32.whl", hash = "sha256:c31eebe420a9a5d2887b13000b043ff6ca27c452a9a22fa71f35f118e8d4bf89", size = 36457, upload-time = "2025-08-12T05:53:03.936Z" }, + { url = "https://files.pythonhosted.org/packages/83/88/16b7231ba49861b6f75fc309b11012ede4d6b0a9c90969d9e0db8d991aeb/wrapt-1.17.3-cp311-cp311-win_amd64.whl", hash = "sha256:0b1831115c97f0663cb77aa27d381237e73ad4f721391a9bfb2fe8bc25fa6e77", size = 38745, upload-time = "2025-08-12T05:53:02.885Z" }, + { url = "https://files.pythonhosted.org/packages/9a/1e/c4d4f3398ec073012c51d1c8d87f715f56765444e1a4b11e5180577b7e6e/wrapt-1.17.3-cp311-cp311-win_arm64.whl", hash = "sha256:5a7b3c1ee8265eb4c8f1b7d29943f195c00673f5ab60c192eba2d4a7eae5f46a", size = 36806, upload-time = "2025-08-12T05:52:53.368Z" }, + { url = "https://files.pythonhosted.org/packages/9f/41/cad1aba93e752f1f9268c77270da3c469883d56e2798e7df6240dcb2287b/wrapt-1.17.3-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:ab232e7fdb44cdfbf55fc3afa31bcdb0d8980b9b95c38b6405df2acb672af0e0", size = 53998, upload-time = "2025-08-12T05:51:47.138Z" }, + { url = "https://files.pythonhosted.org/packages/60/f8/096a7cc13097a1869fe44efe68dace40d2a16ecb853141394047f0780b96/wrapt-1.17.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:9baa544e6acc91130e926e8c802a17f3b16fbea0fd441b5a60f5cf2cc5c3deba", size = 39020, upload-time = "2025-08-12T05:51:35.906Z" }, + { url = "https://files.pythonhosted.org/packages/33/df/bdf864b8997aab4febb96a9ae5c124f700a5abd9b5e13d2a3214ec4be705/wrapt-1.17.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6b538e31eca1a7ea4605e44f81a48aa24c4632a277431a6ed3f328835901f4fd", size = 39098, upload-time = "2025-08-12T05:51:57.474Z" }, + { url = "https://files.pythonhosted.org/packages/9f/81/5d931d78d0eb732b95dc3ddaeeb71c8bb572fb01356e9133916cd729ecdd/wrapt-1.17.3-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:042ec3bb8f319c147b1301f2393bc19dba6e176b7da446853406d041c36c7828", size = 88036, upload-time = "2025-08-12T05:52:34.784Z" }, + { url = "https://files.pythonhosted.org/packages/ca/38/2e1785df03b3d72d34fc6252d91d9d12dc27a5c89caef3335a1bbb8908ca/wrapt-1.17.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3af60380ba0b7b5aeb329bc4e402acd25bd877e98b3727b0135cb5c2efdaefe9", size = 88156, upload-time = "2025-08-12T05:52:13.599Z" }, + { url = "https://files.pythonhosted.org/packages/b3/8b/48cdb60fe0603e34e05cffda0b2a4adab81fd43718e11111a4b0100fd7c1/wrapt-1.17.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0b02e424deef65c9f7326d8c19220a2c9040c51dc165cddb732f16198c168396", size = 87102, upload-time = "2025-08-12T05:52:14.56Z" }, + { url = "https://files.pythonhosted.org/packages/3c/51/d81abca783b58f40a154f1b2c56db1d2d9e0d04fa2d4224e357529f57a57/wrapt-1.17.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:74afa28374a3c3a11b3b5e5fca0ae03bef8450d6aa3ab3a1e2c30e3a75d023dc", size = 87732, upload-time = "2025-08-12T05:52:36.165Z" }, + { url = "https://files.pythonhosted.org/packages/9e/b1/43b286ca1392a006d5336412d41663eeef1ad57485f3e52c767376ba7e5a/wrapt-1.17.3-cp312-cp312-win32.whl", hash = "sha256:4da9f45279fff3543c371d5ababc57a0384f70be244de7759c85a7f989cb4ebe", size = 36705, upload-time = "2025-08-12T05:53:07.123Z" }, + { url = "https://files.pythonhosted.org/packages/28/de/49493f962bd3c586ab4b88066e967aa2e0703d6ef2c43aa28cb83bf7b507/wrapt-1.17.3-cp312-cp312-win_amd64.whl", hash = "sha256:e71d5c6ebac14875668a1e90baf2ea0ef5b7ac7918355850c0908ae82bcb297c", size = 38877, upload-time = "2025-08-12T05:53:05.436Z" }, + { url = "https://files.pythonhosted.org/packages/f1/48/0f7102fe9cb1e8a5a77f80d4f0956d62d97034bbe88d33e94699f99d181d/wrapt-1.17.3-cp312-cp312-win_arm64.whl", hash = "sha256:604d076c55e2fdd4c1c03d06dc1a31b95130010517b5019db15365ec4a405fc6", size = 36885, upload-time = "2025-08-12T05:52:54.367Z" }, + { url = "https://files.pythonhosted.org/packages/fc/f6/759ece88472157acb55fc195e5b116e06730f1b651b5b314c66291729193/wrapt-1.17.3-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a47681378a0439215912ef542c45a783484d4dd82bac412b71e59cf9c0e1cea0", size = 54003, upload-time = "2025-08-12T05:51:48.627Z" }, + { url = "https://files.pythonhosted.org/packages/4f/a9/49940b9dc6d47027dc850c116d79b4155f15c08547d04db0f07121499347/wrapt-1.17.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:54a30837587c6ee3cd1a4d1c2ec5d24e77984d44e2f34547e2323ddb4e22eb77", size = 39025, upload-time = "2025-08-12T05:51:37.156Z" }, + { url = "https://files.pythonhosted.org/packages/45/35/6a08de0f2c96dcdd7fe464d7420ddb9a7655a6561150e5fc4da9356aeaab/wrapt-1.17.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:16ecf15d6af39246fe33e507105d67e4b81d8f8d2c6598ff7e3ca1b8a37213f7", size = 39108, upload-time = "2025-08-12T05:51:58.425Z" }, + { url = "https://files.pythonhosted.org/packages/0c/37/6faf15cfa41bf1f3dba80cd3f5ccc6622dfccb660ab26ed79f0178c7497f/wrapt-1.17.3-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:6fd1ad24dc235e4ab88cda009e19bf347aabb975e44fd5c2fb22a3f6e4141277", size = 88072, upload-time = "2025-08-12T05:52:37.53Z" }, + { url = "https://files.pythonhosted.org/packages/78/f2/efe19ada4a38e4e15b6dff39c3e3f3f73f5decf901f66e6f72fe79623a06/wrapt-1.17.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0ed61b7c2d49cee3c027372df5809a59d60cf1b6c2f81ee980a091f3afed6a2d", size = 88214, upload-time = "2025-08-12T05:52:15.886Z" }, + { url = "https://files.pythonhosted.org/packages/40/90/ca86701e9de1622b16e09689fc24b76f69b06bb0150990f6f4e8b0eeb576/wrapt-1.17.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:423ed5420ad5f5529db9ce89eac09c8a2f97da18eb1c870237e84c5a5c2d60aa", size = 87105, upload-time = "2025-08-12T05:52:17.914Z" }, + { url = "https://files.pythonhosted.org/packages/fd/e0/d10bd257c9a3e15cbf5523025252cc14d77468e8ed644aafb2d6f54cb95d/wrapt-1.17.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e01375f275f010fcbf7f643b4279896d04e571889b8a5b3f848423d91bf07050", size = 87766, upload-time = "2025-08-12T05:52:39.243Z" }, + { url = "https://files.pythonhosted.org/packages/e8/cf/7d848740203c7b4b27eb55dbfede11aca974a51c3d894f6cc4b865f42f58/wrapt-1.17.3-cp313-cp313-win32.whl", hash = "sha256:53e5e39ff71b3fc484df8a522c933ea2b7cdd0d5d15ae82e5b23fde87d44cbd8", size = 36711, upload-time = "2025-08-12T05:53:10.074Z" }, + { url = "https://files.pythonhosted.org/packages/57/54/35a84d0a4d23ea675994104e667ceff49227ce473ba6a59ba2c84f250b74/wrapt-1.17.3-cp313-cp313-win_amd64.whl", hash = "sha256:1f0b2f40cf341ee8cc1a97d51ff50dddb9fcc73241b9143ec74b30fc4f44f6cb", size = 38885, upload-time = "2025-08-12T05:53:08.695Z" }, + { url = "https://files.pythonhosted.org/packages/01/77/66e54407c59d7b02a3c4e0af3783168fff8e5d61def52cda8728439d86bc/wrapt-1.17.3-cp313-cp313-win_arm64.whl", hash = "sha256:7425ac3c54430f5fc5e7b6f41d41e704db073309acfc09305816bc6a0b26bb16", size = 36896, upload-time = "2025-08-12T05:52:55.34Z" }, + { url = "https://files.pythonhosted.org/packages/02/a2/cd864b2a14f20d14f4c496fab97802001560f9f41554eef6df201cd7f76c/wrapt-1.17.3-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:cf30f6e3c077c8e6a9a7809c94551203c8843e74ba0c960f4a98cd80d4665d39", size = 54132, upload-time = "2025-08-12T05:51:49.864Z" }, + { url = "https://files.pythonhosted.org/packages/d5/46/d011725b0c89e853dc44cceb738a307cde5d240d023d6d40a82d1b4e1182/wrapt-1.17.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:e228514a06843cae89621384cfe3a80418f3c04aadf8a3b14e46a7be704e4235", size = 39091, upload-time = "2025-08-12T05:51:38.935Z" }, + { url = "https://files.pythonhosted.org/packages/2e/9e/3ad852d77c35aae7ddebdbc3b6d35ec8013af7d7dddad0ad911f3d891dae/wrapt-1.17.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:5ea5eb3c0c071862997d6f3e02af1d055f381b1d25b286b9d6644b79db77657c", size = 39172, upload-time = "2025-08-12T05:51:59.365Z" }, + { url = "https://files.pythonhosted.org/packages/c3/f7/c983d2762bcce2326c317c26a6a1e7016f7eb039c27cdf5c4e30f4160f31/wrapt-1.17.3-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:281262213373b6d5e4bb4353bc36d1ba4084e6d6b5d242863721ef2bf2c2930b", size = 87163, upload-time = "2025-08-12T05:52:40.965Z" }, + { url = "https://files.pythonhosted.org/packages/e4/0f/f673f75d489c7f22d17fe0193e84b41540d962f75fce579cf6873167c29b/wrapt-1.17.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dc4a8d2b25efb6681ecacad42fca8859f88092d8732b170de6a5dddd80a1c8fa", size = 87963, upload-time = "2025-08-12T05:52:20.326Z" }, + { url = "https://files.pythonhosted.org/packages/df/61/515ad6caca68995da2fac7a6af97faab8f78ebe3bf4f761e1b77efbc47b5/wrapt-1.17.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:373342dd05b1d07d752cecbec0c41817231f29f3a89aa8b8843f7b95992ed0c7", size = 86945, upload-time = "2025-08-12T05:52:21.581Z" }, + { url = "https://files.pythonhosted.org/packages/d3/bd/4e70162ce398462a467bc09e768bee112f1412e563620adc353de9055d33/wrapt-1.17.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:d40770d7c0fd5cbed9d84b2c3f2e156431a12c9a37dc6284060fb4bec0b7ffd4", size = 86857, upload-time = "2025-08-12T05:52:43.043Z" }, + { url = "https://files.pythonhosted.org/packages/2b/b8/da8560695e9284810b8d3df8a19396a6e40e7518059584a1a394a2b35e0a/wrapt-1.17.3-cp314-cp314-win32.whl", hash = "sha256:fbd3c8319de8e1dc79d346929cd71d523622da527cca14e0c1d257e31c2b8b10", size = 37178, upload-time = "2025-08-12T05:53:12.605Z" }, + { url = "https://files.pythonhosted.org/packages/db/c8/b71eeb192c440d67a5a0449aaee2310a1a1e8eca41676046f99ed2487e9f/wrapt-1.17.3-cp314-cp314-win_amd64.whl", hash = "sha256:e1a4120ae5705f673727d3253de3ed0e016f7cd78dc463db1b31e2463e1f3cf6", size = 39310, upload-time = "2025-08-12T05:53:11.106Z" }, + { url = "https://files.pythonhosted.org/packages/45/20/2cda20fd4865fa40f86f6c46ed37a2a8356a7a2fde0773269311f2af56c7/wrapt-1.17.3-cp314-cp314-win_arm64.whl", hash = "sha256:507553480670cab08a800b9463bdb881b2edeed77dc677b0a5915e6106e91a58", size = 37266, upload-time = "2025-08-12T05:52:56.531Z" }, + { url = "https://files.pythonhosted.org/packages/77/ed/dd5cf21aec36c80443c6f900449260b80e2a65cf963668eaef3b9accce36/wrapt-1.17.3-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:ed7c635ae45cfbc1a7371f708727bf74690daedc49b4dba310590ca0bd28aa8a", size = 56544, upload-time = "2025-08-12T05:51:51.109Z" }, + { url = "https://files.pythonhosted.org/packages/8d/96/450c651cc753877ad100c7949ab4d2e2ecc4d97157e00fa8f45df682456a/wrapt-1.17.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:249f88ed15503f6492a71f01442abddd73856a0032ae860de6d75ca62eed8067", size = 40283, upload-time = "2025-08-12T05:51:39.912Z" }, + { url = "https://files.pythonhosted.org/packages/d1/86/2fcad95994d9b572db57632acb6f900695a648c3e063f2cd344b3f5c5a37/wrapt-1.17.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5a03a38adec8066d5a37bea22f2ba6bbf39fcdefbe2d91419ab864c3fb515454", size = 40366, upload-time = "2025-08-12T05:52:00.693Z" }, + { url = "https://files.pythonhosted.org/packages/64/0e/f4472f2fdde2d4617975144311f8800ef73677a159be7fe61fa50997d6c0/wrapt-1.17.3-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:5d4478d72eb61c36e5b446e375bbc49ed002430d17cdec3cecb36993398e1a9e", size = 108571, upload-time = "2025-08-12T05:52:44.521Z" }, + { url = "https://files.pythonhosted.org/packages/cc/01/9b85a99996b0a97c8a17484684f206cbb6ba73c1ce6890ac668bcf3838fb/wrapt-1.17.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:223db574bb38637e8230eb14b185565023ab624474df94d2af18f1cdb625216f", size = 113094, upload-time = "2025-08-12T05:52:22.618Z" }, + { url = "https://files.pythonhosted.org/packages/25/02/78926c1efddcc7b3aa0bc3d6b33a822f7d898059f7cd9ace8c8318e559ef/wrapt-1.17.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e405adefb53a435f01efa7ccdec012c016b5a1d3f35459990afc39b6be4d5056", size = 110659, upload-time = "2025-08-12T05:52:24.057Z" }, + { url = "https://files.pythonhosted.org/packages/dc/ee/c414501ad518ac3e6fe184753632fe5e5ecacdcf0effc23f31c1e4f7bfcf/wrapt-1.17.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:88547535b787a6c9ce4086917b6e1d291aa8ed914fdd3a838b3539dc95c12804", size = 106946, upload-time = "2025-08-12T05:52:45.976Z" }, + { url = "https://files.pythonhosted.org/packages/be/44/a1bd64b723d13bb151d6cc91b986146a1952385e0392a78567e12149c7b4/wrapt-1.17.3-cp314-cp314t-win32.whl", hash = "sha256:41b1d2bc74c2cac6f9074df52b2efbef2b30bdfe5f40cb78f8ca22963bc62977", size = 38717, upload-time = "2025-08-12T05:53:15.214Z" }, + { url = "https://files.pythonhosted.org/packages/79/d9/7cfd5a312760ac4dd8bf0184a6ee9e43c33e47f3dadc303032ce012b8fa3/wrapt-1.17.3-cp314-cp314t-win_amd64.whl", hash = "sha256:73d496de46cd2cdbdbcce4ae4bcdb4afb6a11234a1df9c085249d55166b95116", size = 41334, upload-time = "2025-08-12T05:53:14.178Z" }, + { url = "https://files.pythonhosted.org/packages/46/78/10ad9781128ed2f99dbc474f43283b13fea8ba58723e98844367531c18e9/wrapt-1.17.3-cp314-cp314t-win_arm64.whl", hash = "sha256:f38e60678850c42461d4202739f9bf1e3a737c7ad283638251e79cc49effb6b6", size = 38471, upload-time = "2025-08-12T05:52:57.784Z" }, + { url = "https://files.pythonhosted.org/packages/1f/f6/a933bd70f98e9cf3e08167fc5cd7aaaca49147e48411c0bd5ae701bb2194/wrapt-1.17.3-py3-none-any.whl", hash = "sha256:7171ae35d2c33d326ac19dd8facb1e82e5fd04ef8c6c0e394d7af55a55051c22", size = 23591, upload-time = "2025-08-12T05:53:20.674Z" }, +] + +[[package]] +name = "xxhash" +version = "3.6.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/02/84/30869e01909fb37a6cc7e18688ee8bf1e42d57e7e0777636bd47524c43c7/xxhash-3.6.0.tar.gz", hash = "sha256:f0162a78b13a0d7617b2845b90c763339d1f1d82bb04a4b07f4ab535cc5e05d6", size = 85160, upload-time = "2025-10-02T14:37:08.097Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/34/ee/f9f1d656ad168681bb0f6b092372c1e533c4416b8069b1896a175c46e484/xxhash-3.6.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:87ff03d7e35c61435976554477a7f4cd1704c3596a89a8300d5ce7fc83874a71", size = 32845, upload-time = "2025-10-02T14:33:51.573Z" }, + { url = "https://files.pythonhosted.org/packages/a3/b1/93508d9460b292c74a09b83d16750c52a0ead89c51eea9951cb97a60d959/xxhash-3.6.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f572dfd3d0e2eb1a57511831cf6341242f5a9f8298a45862d085f5b93394a27d", size = 30807, upload-time = "2025-10-02T14:33:52.964Z" }, + { url = "https://files.pythonhosted.org/packages/07/55/28c93a3662f2d200c70704efe74aab9640e824f8ce330d8d3943bf7c9b3c/xxhash-3.6.0-cp310-cp310-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:89952ea539566b9fed2bbd94e589672794b4286f342254fad28b149f9615fef8", size = 193786, upload-time = "2025-10-02T14:33:54.272Z" }, + { url = "https://files.pythonhosted.org/packages/c1/96/fec0be9bb4b8f5d9c57d76380a366f31a1781fb802f76fc7cda6c84893c7/xxhash-3.6.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:48e6f2ffb07a50b52465a1032c3cf1f4a5683f944acaca8a134a2f23674c2058", size = 212830, upload-time = "2025-10-02T14:33:55.706Z" }, + { url = "https://files.pythonhosted.org/packages/c4/a0/c706845ba77b9611f81fd2e93fad9859346b026e8445e76f8c6fd057cc6d/xxhash-3.6.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b5b848ad6c16d308c3ac7ad4ba6bede80ed5df2ba8ed382f8932df63158dd4b2", size = 211606, upload-time = "2025-10-02T14:33:57.133Z" }, + { url = "https://files.pythonhosted.org/packages/67/1e/164126a2999e5045f04a69257eea946c0dc3e86541b400d4385d646b53d7/xxhash-3.6.0-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a034590a727b44dd8ac5914236a7b8504144447a9682586c3327e935f33ec8cc", size = 444872, upload-time = "2025-10-02T14:33:58.446Z" }, + { url = "https://files.pythonhosted.org/packages/2d/4b/55ab404c56cd70a2cf5ecfe484838865d0fea5627365c6c8ca156bd09c8f/xxhash-3.6.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8a8f1972e75ebdd161d7896743122834fe87378160c20e97f8b09166213bf8cc", size = 193217, upload-time = "2025-10-02T14:33:59.724Z" }, + { url = "https://files.pythonhosted.org/packages/45/e6/52abf06bac316db33aa269091ae7311bd53cfc6f4b120ae77bac1b348091/xxhash-3.6.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:ee34327b187f002a596d7b167ebc59a1b729e963ce645964bbc050d2f1b73d07", size = 210139, upload-time = "2025-10-02T14:34:02.041Z" }, + { url = "https://files.pythonhosted.org/packages/34/37/db94d490b8691236d356bc249c08819cbcef9273a1a30acf1254ff9ce157/xxhash-3.6.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:339f518c3c7a850dd033ab416ea25a692759dc7478a71131fe8869010d2b75e4", size = 197669, upload-time = "2025-10-02T14:34:03.664Z" }, + { url = "https://files.pythonhosted.org/packages/b7/36/c4f219ef4a17a4f7a64ed3569bc2b5a9c8311abdb22249ac96093625b1a4/xxhash-3.6.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:bf48889c9630542d4709192578aebbd836177c9f7a4a2778a7d6340107c65f06", size = 210018, upload-time = "2025-10-02T14:34:05.325Z" }, + { url = "https://files.pythonhosted.org/packages/fd/06/bfac889a374fc2fc439a69223d1750eed2e18a7db8514737ab630534fa08/xxhash-3.6.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:5576b002a56207f640636056b4160a378fe36a58db73ae5c27a7ec8db35f71d4", size = 413058, upload-time = "2025-10-02T14:34:06.925Z" }, + { url = "https://files.pythonhosted.org/packages/c9/d1/555d8447e0dd32ad0930a249a522bb2e289f0d08b6b16204cfa42c1f5a0c/xxhash-3.6.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:af1f3278bd02814d6dedc5dec397993b549d6f16c19379721e5a1d31e132c49b", size = 190628, upload-time = "2025-10-02T14:34:08.669Z" }, + { url = "https://files.pythonhosted.org/packages/d1/15/8751330b5186cedc4ed4b597989882ea05e0408b53fa47bcb46a6125bfc6/xxhash-3.6.0-cp310-cp310-win32.whl", hash = "sha256:aed058764db109dc9052720da65fafe84873b05eb8b07e5e653597951af57c3b", size = 30577, upload-time = "2025-10-02T14:34:10.234Z" }, + { url = "https://files.pythonhosted.org/packages/bb/cc/53f87e8b5871a6eb2ff7e89c48c66093bda2be52315a8161ddc54ea550c4/xxhash-3.6.0-cp310-cp310-win_amd64.whl", hash = "sha256:e82da5670f2d0d98950317f82a0e4a0197150ff19a6df2ba40399c2a3b9ae5fb", size = 31487, upload-time = "2025-10-02T14:34:11.618Z" }, + { url = "https://files.pythonhosted.org/packages/9f/00/60f9ea3bb697667a14314d7269956f58bf56bb73864f8f8d52a3c2535e9a/xxhash-3.6.0-cp310-cp310-win_arm64.whl", hash = "sha256:4a082ffff8c6ac07707fb6b671caf7c6e020c75226c561830b73d862060f281d", size = 27863, upload-time = "2025-10-02T14:34:12.619Z" }, + { url = "https://files.pythonhosted.org/packages/17/d4/cc2f0400e9154df4b9964249da78ebd72f318e35ccc425e9f403c392f22a/xxhash-3.6.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b47bbd8cf2d72797f3c2772eaaac0ded3d3af26481a26d7d7d41dc2d3c46b04a", size = 32844, upload-time = "2025-10-02T14:34:14.037Z" }, + { url = "https://files.pythonhosted.org/packages/5e/ec/1cc11cd13e26ea8bc3cb4af4eaadd8d46d5014aebb67be3f71fb0b68802a/xxhash-3.6.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2b6821e94346f96db75abaa6e255706fb06ebd530899ed76d32cd99f20dc52fa", size = 30809, upload-time = "2025-10-02T14:34:15.484Z" }, + { url = "https://files.pythonhosted.org/packages/04/5f/19fe357ea348d98ca22f456f75a30ac0916b51c753e1f8b2e0e6fb884cce/xxhash-3.6.0-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:d0a9751f71a1a65ce3584e9cae4467651c7e70c9d31017fa57574583a4540248", size = 194665, upload-time = "2025-10-02T14:34:16.541Z" }, + { url = "https://files.pythonhosted.org/packages/90/3b/d1f1a8f5442a5fd8beedae110c5af7604dc37349a8e16519c13c19a9a2de/xxhash-3.6.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8b29ee68625ab37b04c0b40c3fafdf24d2f75ccd778333cfb698f65f6c463f62", size = 213550, upload-time = "2025-10-02T14:34:17.878Z" }, + { url = "https://files.pythonhosted.org/packages/c4/ef/3a9b05eb527457d5db13a135a2ae1a26c80fecd624d20f3e8dcc4cb170f3/xxhash-3.6.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6812c25fe0d6c36a46ccb002f40f27ac903bf18af9f6dd8f9669cb4d176ab18f", size = 212384, upload-time = "2025-10-02T14:34:19.182Z" }, + { url = "https://files.pythonhosted.org/packages/0f/18/ccc194ee698c6c623acbf0f8c2969811a8a4b6185af5e824cd27b9e4fd3e/xxhash-3.6.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4ccbff013972390b51a18ef1255ef5ac125c92dc9143b2d1909f59abc765540e", size = 445749, upload-time = "2025-10-02T14:34:20.659Z" }, + { url = "https://files.pythonhosted.org/packages/a5/86/cf2c0321dc3940a7aa73076f4fd677a0fb3e405cb297ead7d864fd90847e/xxhash-3.6.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:297b7fbf86c82c550e12e8fb71968b3f033d27b874276ba3624ea868c11165a8", size = 193880, upload-time = "2025-10-02T14:34:22.431Z" }, + { url = "https://files.pythonhosted.org/packages/82/fb/96213c8560e6f948a1ecc9a7613f8032b19ee45f747f4fca4eb31bb6d6ed/xxhash-3.6.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:dea26ae1eb293db089798d3973a5fc928a18fdd97cc8801226fae705b02b14b0", size = 210912, upload-time = "2025-10-02T14:34:23.937Z" }, + { url = "https://files.pythonhosted.org/packages/40/aa/4395e669b0606a096d6788f40dbdf2b819d6773aa290c19e6e83cbfc312f/xxhash-3.6.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:7a0b169aafb98f4284f73635a8e93f0735f9cbde17bd5ec332480484241aaa77", size = 198654, upload-time = "2025-10-02T14:34:25.644Z" }, + { url = "https://files.pythonhosted.org/packages/67/74/b044fcd6b3d89e9b1b665924d85d3f400636c23590226feb1eb09e1176ce/xxhash-3.6.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:08d45aef063a4531b785cd72de4887766d01dc8f362a515693df349fdb825e0c", size = 210867, upload-time = "2025-10-02T14:34:27.203Z" }, + { url = "https://files.pythonhosted.org/packages/bc/fd/3ce73bf753b08cb19daee1eb14aa0d7fe331f8da9c02dd95316ddfe5275e/xxhash-3.6.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:929142361a48ee07f09121fe9e96a84950e8d4df3bb298ca5d88061969f34d7b", size = 414012, upload-time = "2025-10-02T14:34:28.409Z" }, + { url = "https://files.pythonhosted.org/packages/ba/b3/5a4241309217c5c876f156b10778f3ab3af7ba7e3259e6d5f5c7d0129eb2/xxhash-3.6.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:51312c768403d8540487dbbfb557454cfc55589bbde6424456951f7fcd4facb3", size = 191409, upload-time = "2025-10-02T14:34:29.696Z" }, + { url = "https://files.pythonhosted.org/packages/c0/01/99bfbc15fb9abb9a72b088c1d95219fc4782b7d01fc835bd5744d66dd0b8/xxhash-3.6.0-cp311-cp311-win32.whl", hash = "sha256:d1927a69feddc24c987b337ce81ac15c4720955b667fe9b588e02254b80446fd", size = 30574, upload-time = "2025-10-02T14:34:31.028Z" }, + { url = "https://files.pythonhosted.org/packages/65/79/9d24d7f53819fe301b231044ea362ce64e86c74f6e8c8e51320de248b3e5/xxhash-3.6.0-cp311-cp311-win_amd64.whl", hash = "sha256:26734cdc2d4ffe449b41d186bbeac416f704a482ed835d375a5c0cb02bc63fef", size = 31481, upload-time = "2025-10-02T14:34:32.062Z" }, + { url = "https://files.pythonhosted.org/packages/30/4e/15cd0e3e8772071344eab2961ce83f6e485111fed8beb491a3f1ce100270/xxhash-3.6.0-cp311-cp311-win_arm64.whl", hash = "sha256:d72f67ef8bf36e05f5b6c65e8524f265bd61071471cd4cf1d36743ebeeeb06b7", size = 27861, upload-time = "2025-10-02T14:34:33.555Z" }, + { url = "https://files.pythonhosted.org/packages/9a/07/d9412f3d7d462347e4511181dea65e47e0d0e16e26fbee2ea86a2aefb657/xxhash-3.6.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:01362c4331775398e7bb34e3ab403bc9ee9f7c497bc7dee6272114055277dd3c", size = 32744, upload-time = "2025-10-02T14:34:34.622Z" }, + { url = "https://files.pythonhosted.org/packages/79/35/0429ee11d035fc33abe32dca1b2b69e8c18d236547b9a9b72c1929189b9a/xxhash-3.6.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b7b2df81a23f8cb99656378e72501b2cb41b1827c0f5a86f87d6b06b69f9f204", size = 30816, upload-time = "2025-10-02T14:34:36.043Z" }, + { url = "https://files.pythonhosted.org/packages/b7/f2/57eb99aa0f7d98624c0932c5b9a170e1806406cdbcdb510546634a1359e0/xxhash-3.6.0-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:dc94790144e66b14f67b10ac8ed75b39ca47536bf8800eb7c24b50271ea0c490", size = 194035, upload-time = "2025-10-02T14:34:37.354Z" }, + { url = "https://files.pythonhosted.org/packages/4c/ed/6224ba353690d73af7a3f1c7cdb1fc1b002e38f783cb991ae338e1eb3d79/xxhash-3.6.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:93f107c673bccf0d592cdba077dedaf52fe7f42dcd7676eba1f6d6f0c3efffd2", size = 212914, upload-time = "2025-10-02T14:34:38.6Z" }, + { url = "https://files.pythonhosted.org/packages/38/86/fb6b6130d8dd6b8942cc17ab4d90e223653a89aa32ad2776f8af7064ed13/xxhash-3.6.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2aa5ee3444c25b69813663c9f8067dcfaa2e126dc55e8dddf40f4d1c25d7effa", size = 212163, upload-time = "2025-10-02T14:34:39.872Z" }, + { url = "https://files.pythonhosted.org/packages/ee/dc/e84875682b0593e884ad73b2d40767b5790d417bde603cceb6878901d647/xxhash-3.6.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f7f99123f0e1194fa59cc69ad46dbae2e07becec5df50a0509a808f90a0f03f0", size = 445411, upload-time = "2025-10-02T14:34:41.569Z" }, + { url = "https://files.pythonhosted.org/packages/11/4f/426f91b96701ec2f37bb2b8cec664eff4f658a11f3fa9d94f0a887ea6d2b/xxhash-3.6.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:49e03e6fe2cac4a1bc64952dd250cf0dbc5ef4ebb7b8d96bce82e2de163c82a2", size = 193883, upload-time = "2025-10-02T14:34:43.249Z" }, + { url = "https://files.pythonhosted.org/packages/53/5a/ddbb83eee8e28b778eacfc5a85c969673e4023cdeedcfcef61f36731610b/xxhash-3.6.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:bd17fede52a17a4f9a7bc4472a5867cb0b160deeb431795c0e4abe158bc784e9", size = 210392, upload-time = "2025-10-02T14:34:45.042Z" }, + { url = "https://files.pythonhosted.org/packages/1e/c2/ff69efd07c8c074ccdf0a4f36fcdd3d27363665bcdf4ba399abebe643465/xxhash-3.6.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:6fb5f5476bef678f69db04f2bd1efbed3030d2aba305b0fc1773645f187d6a4e", size = 197898, upload-time = "2025-10-02T14:34:46.302Z" }, + { url = "https://files.pythonhosted.org/packages/58/ca/faa05ac19b3b622c7c9317ac3e23954187516298a091eb02c976d0d3dd45/xxhash-3.6.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:843b52f6d88071f87eba1631b684fcb4b2068cd2180a0224122fe4ef011a9374", size = 210655, upload-time = "2025-10-02T14:34:47.571Z" }, + { url = "https://files.pythonhosted.org/packages/d4/7a/06aa7482345480cc0cb597f5c875b11a82c3953f534394f620b0be2f700c/xxhash-3.6.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:7d14a6cfaf03b1b6f5f9790f76880601ccc7896aff7ab9cd8978a939c1eb7e0d", size = 414001, upload-time = "2025-10-02T14:34:49.273Z" }, + { url = "https://files.pythonhosted.org/packages/23/07/63ffb386cd47029aa2916b3d2f454e6cc5b9f5c5ada3790377d5430084e7/xxhash-3.6.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:418daf3db71e1413cfe211c2f9a528456936645c17f46b5204705581a45390ae", size = 191431, upload-time = "2025-10-02T14:34:50.798Z" }, + { url = "https://files.pythonhosted.org/packages/0f/93/14fde614cadb4ddf5e7cebf8918b7e8fac5ae7861c1875964f17e678205c/xxhash-3.6.0-cp312-cp312-win32.whl", hash = "sha256:50fc255f39428a27299c20e280d6193d8b63b8ef8028995323bf834a026b4fbb", size = 30617, upload-time = "2025-10-02T14:34:51.954Z" }, + { url = "https://files.pythonhosted.org/packages/13/5d/0d125536cbe7565a83d06e43783389ecae0c0f2ed037b48ede185de477c0/xxhash-3.6.0-cp312-cp312-win_amd64.whl", hash = "sha256:c0f2ab8c715630565ab8991b536ecded9416d615538be8ecddce43ccf26cbc7c", size = 31534, upload-time = "2025-10-02T14:34:53.276Z" }, + { url = "https://files.pythonhosted.org/packages/54/85/6ec269b0952ec7e36ba019125982cf11d91256a778c7c3f98a4c5043d283/xxhash-3.6.0-cp312-cp312-win_arm64.whl", hash = "sha256:eae5c13f3bc455a3bbb68bdc513912dc7356de7e2280363ea235f71f54064829", size = 27876, upload-time = "2025-10-02T14:34:54.371Z" }, + { url = "https://files.pythonhosted.org/packages/33/76/35d05267ac82f53ae9b0e554da7c5e281ee61f3cad44c743f0fcd354f211/xxhash-3.6.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:599e64ba7f67472481ceb6ee80fa3bd828fd61ba59fb11475572cc5ee52b89ec", size = 32738, upload-time = "2025-10-02T14:34:55.839Z" }, + { url = "https://files.pythonhosted.org/packages/31/a8/3fbce1cd96534a95e35d5120637bf29b0d7f5d8fa2f6374e31b4156dd419/xxhash-3.6.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7d8b8aaa30fca4f16f0c84a5c8d7ddee0e25250ec2796c973775373257dde8f1", size = 30821, upload-time = "2025-10-02T14:34:57.219Z" }, + { url = "https://files.pythonhosted.org/packages/0c/ea/d387530ca7ecfa183cb358027f1833297c6ac6098223fd14f9782cd0015c/xxhash-3.6.0-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:d597acf8506d6e7101a4a44a5e428977a51c0fadbbfd3c39650cca9253f6e5a6", size = 194127, upload-time = "2025-10-02T14:34:59.21Z" }, + { url = "https://files.pythonhosted.org/packages/ba/0c/71435dcb99874b09a43b8d7c54071e600a7481e42b3e3ce1eb5226a5711a/xxhash-3.6.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:858dc935963a33bc33490128edc1c12b0c14d9c7ebaa4e387a7869ecc4f3e263", size = 212975, upload-time = "2025-10-02T14:35:00.816Z" }, + { url = "https://files.pythonhosted.org/packages/84/7a/c2b3d071e4bb4a90b7057228a99b10d51744878f4a8a6dd643c8bd897620/xxhash-3.6.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ba284920194615cb8edf73bf52236ce2e1664ccd4a38fdb543506413529cc546", size = 212241, upload-time = "2025-10-02T14:35:02.207Z" }, + { url = "https://files.pythonhosted.org/packages/81/5f/640b6eac0128e215f177df99eadcd0f1b7c42c274ab6a394a05059694c5a/xxhash-3.6.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4b54219177f6c6674d5378bd862c6aedf64725f70dd29c472eaae154df1a2e89", size = 445471, upload-time = "2025-10-02T14:35:03.61Z" }, + { url = "https://files.pythonhosted.org/packages/5e/1e/3c3d3ef071b051cc3abbe3721ffb8365033a172613c04af2da89d5548a87/xxhash-3.6.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:42c36dd7dbad2f5238950c377fcbf6811b1cdb1c444fab447960030cea60504d", size = 193936, upload-time = "2025-10-02T14:35:05.013Z" }, + { url = "https://files.pythonhosted.org/packages/2c/bd/4a5f68381939219abfe1c22a9e3a5854a4f6f6f3c4983a87d255f21f2e5d/xxhash-3.6.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f22927652cba98c44639ffdc7aaf35828dccf679b10b31c4ad72a5b530a18eb7", size = 210440, upload-time = "2025-10-02T14:35:06.239Z" }, + { url = "https://files.pythonhosted.org/packages/eb/37/b80fe3d5cfb9faff01a02121a0f4d565eb7237e9e5fc66e73017e74dcd36/xxhash-3.6.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:b45fad44d9c5c119e9c6fbf2e1c656a46dc68e280275007bbfd3d572b21426db", size = 197990, upload-time = "2025-10-02T14:35:07.735Z" }, + { url = "https://files.pythonhosted.org/packages/d7/fd/2c0a00c97b9e18f72e1f240ad4e8f8a90fd9d408289ba9c7c495ed7dc05c/xxhash-3.6.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:6f2580ffab1a8b68ef2b901cde7e55fa8da5e4be0977c68f78fc80f3c143de42", size = 210689, upload-time = "2025-10-02T14:35:09.438Z" }, + { url = "https://files.pythonhosted.org/packages/93/86/5dd8076a926b9a95db3206aba20d89a7fc14dd5aac16e5c4de4b56033140/xxhash-3.6.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:40c391dd3cd041ebc3ffe6f2c862f402e306eb571422e0aa918d8070ba31da11", size = 414068, upload-time = "2025-10-02T14:35:11.162Z" }, + { url = "https://files.pythonhosted.org/packages/af/3c/0bb129170ee8f3650f08e993baee550a09593462a5cddd8e44d0011102b1/xxhash-3.6.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:f205badabde7aafd1a31e8ca2a3e5a763107a71c397c4481d6a804eb5063d8bd", size = 191495, upload-time = "2025-10-02T14:35:12.971Z" }, + { url = "https://files.pythonhosted.org/packages/e9/3a/6797e0114c21d1725e2577508e24006fd7ff1d8c0c502d3b52e45c1771d8/xxhash-3.6.0-cp313-cp313-win32.whl", hash = "sha256:2577b276e060b73b73a53042ea5bd5203d3e6347ce0d09f98500f418a9fcf799", size = 30620, upload-time = "2025-10-02T14:35:14.129Z" }, + { url = "https://files.pythonhosted.org/packages/86/15/9bc32671e9a38b413a76d24722a2bf8784a132c043063a8f5152d390b0f9/xxhash-3.6.0-cp313-cp313-win_amd64.whl", hash = "sha256:757320d45d2fbcce8f30c42a6b2f47862967aea7bf458b9625b4bbe7ee390392", size = 31542, upload-time = "2025-10-02T14:35:15.21Z" }, + { url = "https://files.pythonhosted.org/packages/39/c5/cc01e4f6188656e56112d6a8e0dfe298a16934b8c47a247236549a3f7695/xxhash-3.6.0-cp313-cp313-win_arm64.whl", hash = "sha256:457b8f85dec5825eed7b69c11ae86834a018b8e3df5e77783c999663da2f96d6", size = 27880, upload-time = "2025-10-02T14:35:16.315Z" }, + { url = "https://files.pythonhosted.org/packages/f3/30/25e5321c8732759e930c555176d37e24ab84365482d257c3b16362235212/xxhash-3.6.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:a42e633d75cdad6d625434e3468126c73f13f7584545a9cf34e883aa1710e702", size = 32956, upload-time = "2025-10-02T14:35:17.413Z" }, + { url = "https://files.pythonhosted.org/packages/9f/3c/0573299560d7d9f8ab1838f1efc021a280b5ae5ae2e849034ef3dee18810/xxhash-3.6.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:568a6d743219e717b07b4e03b0a828ce593833e498c3b64752e0f5df6bfe84db", size = 31072, upload-time = "2025-10-02T14:35:18.844Z" }, + { url = "https://files.pythonhosted.org/packages/7a/1c/52d83a06e417cd9d4137722693424885cc9878249beb3a7c829e74bf7ce9/xxhash-3.6.0-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:bec91b562d8012dae276af8025a55811b875baace6af510412a5e58e3121bc54", size = 196409, upload-time = "2025-10-02T14:35:20.31Z" }, + { url = "https://files.pythonhosted.org/packages/e3/8e/c6d158d12a79bbd0b878f8355432075fc82759e356ab5a111463422a239b/xxhash-3.6.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:78e7f2f4c521c30ad5e786fdd6bae89d47a32672a80195467b5de0480aa97b1f", size = 215736, upload-time = "2025-10-02T14:35:21.616Z" }, + { url = "https://files.pythonhosted.org/packages/bc/68/c4c80614716345d55071a396cf03d06e34b5f4917a467faf43083c995155/xxhash-3.6.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:3ed0df1b11a79856df5ffcab572cbd6b9627034c1c748c5566fa79df9048a7c5", size = 214833, upload-time = "2025-10-02T14:35:23.32Z" }, + { url = "https://files.pythonhosted.org/packages/7e/e9/ae27c8ffec8b953efa84c7c4a6c6802c263d587b9fc0d6e7cea64e08c3af/xxhash-3.6.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0e4edbfc7d420925b0dd5e792478ed393d6e75ff8fc219a6546fb446b6a417b1", size = 448348, upload-time = "2025-10-02T14:35:25.111Z" }, + { url = "https://files.pythonhosted.org/packages/d7/6b/33e21afb1b5b3f46b74b6bd1913639066af218d704cc0941404ca717fc57/xxhash-3.6.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fba27a198363a7ef87f8c0f6b171ec36b674fe9053742c58dd7e3201c1ab30ee", size = 196070, upload-time = "2025-10-02T14:35:26.586Z" }, + { url = "https://files.pythonhosted.org/packages/96/b6/fcabd337bc5fa624e7203aa0fa7d0c49eed22f72e93229431752bddc83d9/xxhash-3.6.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:794fe9145fe60191c6532fa95063765529770edcdd67b3d537793e8004cabbfd", size = 212907, upload-time = "2025-10-02T14:35:28.087Z" }, + { url = "https://files.pythonhosted.org/packages/4b/d3/9ee6160e644d660fcf176c5825e61411c7f62648728f69c79ba237250143/xxhash-3.6.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:6105ef7e62b5ac73a837778efc331a591d8442f8ef5c7e102376506cb4ae2729", size = 200839, upload-time = "2025-10-02T14:35:29.857Z" }, + { url = "https://files.pythonhosted.org/packages/0d/98/e8de5baa5109394baf5118f5e72ab21a86387c4f89b0e77ef3e2f6b0327b/xxhash-3.6.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:f01375c0e55395b814a679b3eea205db7919ac2af213f4a6682e01220e5fe292", size = 213304, upload-time = "2025-10-02T14:35:31.222Z" }, + { url = "https://files.pythonhosted.org/packages/7b/1d/71056535dec5c3177eeb53e38e3d367dd1d16e024e63b1cee208d572a033/xxhash-3.6.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:d706dca2d24d834a4661619dcacf51a75c16d65985718d6a7d73c1eeeb903ddf", size = 416930, upload-time = "2025-10-02T14:35:32.517Z" }, + { url = "https://files.pythonhosted.org/packages/dc/6c/5cbde9de2cd967c322e651c65c543700b19e7ae3e0aae8ece3469bf9683d/xxhash-3.6.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:5f059d9faeacd49c0215d66f4056e1326c80503f51a1532ca336a385edadd033", size = 193787, upload-time = "2025-10-02T14:35:33.827Z" }, + { url = "https://files.pythonhosted.org/packages/19/fa/0172e350361d61febcea941b0cc541d6e6c8d65d153e85f850a7b256ff8a/xxhash-3.6.0-cp313-cp313t-win32.whl", hash = "sha256:1244460adc3a9be84731d72b8e80625788e5815b68da3da8b83f78115a40a7ec", size = 30916, upload-time = "2025-10-02T14:35:35.107Z" }, + { url = "https://files.pythonhosted.org/packages/ad/e6/e8cf858a2b19d6d45820f072eff1bea413910592ff17157cabc5f1227a16/xxhash-3.6.0-cp313-cp313t-win_amd64.whl", hash = "sha256:b1e420ef35c503869c4064f4a2f2b08ad6431ab7b229a05cce39d74268bca6b8", size = 31799, upload-time = "2025-10-02T14:35:36.165Z" }, + { url = "https://files.pythonhosted.org/packages/56/15/064b197e855bfb7b343210e82490ae672f8bc7cdf3ddb02e92f64304ee8a/xxhash-3.6.0-cp313-cp313t-win_arm64.whl", hash = "sha256:ec44b73a4220623235f67a996c862049f375df3b1052d9899f40a6382c32d746", size = 28044, upload-time = "2025-10-02T14:35:37.195Z" }, + { url = "https://files.pythonhosted.org/packages/7e/5e/0138bc4484ea9b897864d59fce9be9086030825bc778b76cb5a33a906d37/xxhash-3.6.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:a40a3d35b204b7cc7643cbcf8c9976d818cb47befcfac8bbefec8038ac363f3e", size = 32754, upload-time = "2025-10-02T14:35:38.245Z" }, + { url = "https://files.pythonhosted.org/packages/18/d7/5dac2eb2ec75fd771957a13e5dda560efb2176d5203f39502a5fc571f899/xxhash-3.6.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:a54844be970d3fc22630b32d515e79a90d0a3ddb2644d8d7402e3c4c8da61405", size = 30846, upload-time = "2025-10-02T14:35:39.6Z" }, + { url = "https://files.pythonhosted.org/packages/fe/71/8bc5be2bb00deb5682e92e8da955ebe5fa982da13a69da5a40a4c8db12fb/xxhash-3.6.0-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:016e9190af8f0a4e3741343777710e3d5717427f175adfdc3e72508f59e2a7f3", size = 194343, upload-time = "2025-10-02T14:35:40.69Z" }, + { url = "https://files.pythonhosted.org/packages/e7/3b/52badfb2aecec2c377ddf1ae75f55db3ba2d321c5e164f14461c90837ef3/xxhash-3.6.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4f6f72232f849eb9d0141e2ebe2677ece15adfd0fa599bc058aad83c714bb2c6", size = 213074, upload-time = "2025-10-02T14:35:42.29Z" }, + { url = "https://files.pythonhosted.org/packages/a2/2b/ae46b4e9b92e537fa30d03dbc19cdae57ed407e9c26d163895e968e3de85/xxhash-3.6.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:63275a8aba7865e44b1813d2177e0f5ea7eadad3dd063a21f7cf9afdc7054063", size = 212388, upload-time = "2025-10-02T14:35:43.929Z" }, + { url = "https://files.pythonhosted.org/packages/f5/80/49f88d3afc724b4ac7fbd664c8452d6db51b49915be48c6982659e0e7942/xxhash-3.6.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3cd01fa2aa00d8b017c97eb46b9a794fbdca53fc14f845f5a328c71254b0abb7", size = 445614, upload-time = "2025-10-02T14:35:45.216Z" }, + { url = "https://files.pythonhosted.org/packages/ed/ba/603ce3961e339413543d8cd44f21f2c80e2a7c5cfe692a7b1f2cccf58f3c/xxhash-3.6.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0226aa89035b62b6a86d3c68df4d7c1f47a342b8683da2b60cedcddb46c4d95b", size = 194024, upload-time = "2025-10-02T14:35:46.959Z" }, + { url = "https://files.pythonhosted.org/packages/78/d1/8e225ff7113bf81545cfdcd79eef124a7b7064a0bba53605ff39590b95c2/xxhash-3.6.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c6e193e9f56e4ca4923c61238cdaced324f0feac782544eb4c6d55ad5cc99ddd", size = 210541, upload-time = "2025-10-02T14:35:48.301Z" }, + { url = "https://files.pythonhosted.org/packages/6f/58/0f89d149f0bad89def1a8dd38feb50ccdeb643d9797ec84707091d4cb494/xxhash-3.6.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:9176dcaddf4ca963d4deb93866d739a343c01c969231dbe21680e13a5d1a5bf0", size = 198305, upload-time = "2025-10-02T14:35:49.584Z" }, + { url = "https://files.pythonhosted.org/packages/11/38/5eab81580703c4df93feb5f32ff8fa7fe1e2c51c1f183ee4e48d4bb9d3d7/xxhash-3.6.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:c1ce4009c97a752e682b897aa99aef84191077a9433eb237774689f14f8ec152", size = 210848, upload-time = "2025-10-02T14:35:50.877Z" }, + { url = "https://files.pythonhosted.org/packages/5e/6b/953dc4b05c3ce678abca756416e4c130d2382f877a9c30a20d08ee6a77c0/xxhash-3.6.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:8cb2f4f679b01513b7adbb9b1b2f0f9cdc31b70007eaf9d59d0878809f385b11", size = 414142, upload-time = "2025-10-02T14:35:52.15Z" }, + { url = "https://files.pythonhosted.org/packages/08/a9/238ec0d4e81a10eb5026d4a6972677cbc898ba6c8b9dbaec12ae001b1b35/xxhash-3.6.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:653a91d7c2ab54a92c19ccf43508b6a555440b9be1bc8be553376778be7f20b5", size = 191547, upload-time = "2025-10-02T14:35:53.547Z" }, + { url = "https://files.pythonhosted.org/packages/f1/ee/3cf8589e06c2164ac77c3bf0aa127012801128f1feebf2a079272da5737c/xxhash-3.6.0-cp314-cp314-win32.whl", hash = "sha256:a756fe893389483ee8c394d06b5ab765d96e68fbbfe6fde7aa17e11f5720559f", size = 31214, upload-time = "2025-10-02T14:35:54.746Z" }, + { url = "https://files.pythonhosted.org/packages/02/5d/a19552fbc6ad4cb54ff953c3908bbc095f4a921bc569433d791f755186f1/xxhash-3.6.0-cp314-cp314-win_amd64.whl", hash = "sha256:39be8e4e142550ef69629c9cd71b88c90e9a5db703fecbcf265546d9536ca4ad", size = 32290, upload-time = "2025-10-02T14:35:55.791Z" }, + { url = "https://files.pythonhosted.org/packages/b1/11/dafa0643bc30442c887b55baf8e73353a344ee89c1901b5a5c54a6c17d39/xxhash-3.6.0-cp314-cp314-win_arm64.whl", hash = "sha256:25915e6000338999236f1eb68a02a32c3275ac338628a7eaa5a269c401995679", size = 28795, upload-time = "2025-10-02T14:35:57.162Z" }, + { url = "https://files.pythonhosted.org/packages/2c/db/0e99732ed7f64182aef4a6fb145e1a295558deec2a746265dcdec12d191e/xxhash-3.6.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:c5294f596a9017ca5a3e3f8884c00b91ab2ad2933cf288f4923c3fd4346cf3d4", size = 32955, upload-time = "2025-10-02T14:35:58.267Z" }, + { url = "https://files.pythonhosted.org/packages/55/f4/2a7c3c68e564a099becfa44bb3d398810cc0ff6749b0d3cb8ccb93f23c14/xxhash-3.6.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1cf9dcc4ab9cff01dfbba78544297a3a01dafd60f3bde4e2bfd016cf7e4ddc67", size = 31072, upload-time = "2025-10-02T14:35:59.382Z" }, + { url = "https://files.pythonhosted.org/packages/c6/d9/72a29cddc7250e8a5819dad5d466facb5dc4c802ce120645630149127e73/xxhash-3.6.0-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:01262da8798422d0685f7cef03b2bd3f4f46511b02830861df548d7def4402ad", size = 196579, upload-time = "2025-10-02T14:36:00.838Z" }, + { url = "https://files.pythonhosted.org/packages/63/93/b21590e1e381040e2ca305a884d89e1c345b347404f7780f07f2cdd47ef4/xxhash-3.6.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:51a73fb7cb3a3ead9f7a8b583ffd9b8038e277cdb8cb87cf890e88b3456afa0b", size = 215854, upload-time = "2025-10-02T14:36:02.207Z" }, + { url = "https://files.pythonhosted.org/packages/ce/b8/edab8a7d4fa14e924b29be877d54155dcbd8b80be85ea00d2be3413a9ed4/xxhash-3.6.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b9c6df83594f7df8f7f708ce5ebeacfc69f72c9fbaaababf6cf4758eaada0c9b", size = 214965, upload-time = "2025-10-02T14:36:03.507Z" }, + { url = "https://files.pythonhosted.org/packages/27/67/dfa980ac7f0d509d54ea0d5a486d2bb4b80c3f1bb22b66e6a05d3efaf6c0/xxhash-3.6.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:627f0af069b0ea56f312fd5189001c24578868643203bca1abbc2c52d3a6f3ca", size = 448484, upload-time = "2025-10-02T14:36:04.828Z" }, + { url = "https://files.pythonhosted.org/packages/8c/63/8ffc2cc97e811c0ca5d00ab36604b3ea6f4254f20b7bc658ca825ce6c954/xxhash-3.6.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:aa912c62f842dfd013c5f21a642c9c10cd9f4c4e943e0af83618b4a404d9091a", size = 196162, upload-time = "2025-10-02T14:36:06.182Z" }, + { url = "https://files.pythonhosted.org/packages/4b/77/07f0e7a3edd11a6097e990f6e5b815b6592459cb16dae990d967693e6ea9/xxhash-3.6.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:b465afd7909db30168ab62afe40b2fcf79eedc0b89a6c0ab3123515dc0df8b99", size = 213007, upload-time = "2025-10-02T14:36:07.733Z" }, + { url = "https://files.pythonhosted.org/packages/ae/d8/bc5fa0d152837117eb0bef6f83f956c509332ce133c91c63ce07ee7c4873/xxhash-3.6.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:a881851cf38b0a70e7c4d3ce81fc7afd86fbc2a024f4cfb2a97cf49ce04b75d3", size = 200956, upload-time = "2025-10-02T14:36:09.106Z" }, + { url = "https://files.pythonhosted.org/packages/26/a5/d749334130de9411783873e9b98ecc46688dad5db64ca6e04b02acc8b473/xxhash-3.6.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:9b3222c686a919a0f3253cfc12bb118b8b103506612253b5baeaac10d8027cf6", size = 213401, upload-time = "2025-10-02T14:36:10.585Z" }, + { url = "https://files.pythonhosted.org/packages/89/72/abed959c956a4bfc72b58c0384bb7940663c678127538634d896b1195c10/xxhash-3.6.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:c5aa639bc113e9286137cec8fadc20e9cd732b2cc385c0b7fa673b84fc1f2a93", size = 417083, upload-time = "2025-10-02T14:36:12.276Z" }, + { url = "https://files.pythonhosted.org/packages/0c/b3/62fd2b586283b7d7d665fb98e266decadf31f058f1cf6c478741f68af0cb/xxhash-3.6.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5c1343d49ac102799905e115aee590183c3921d475356cb24b4de29a4bc56518", size = 193913, upload-time = "2025-10-02T14:36:14.025Z" }, + { url = "https://files.pythonhosted.org/packages/9a/9a/c19c42c5b3f5a4aad748a6d5b4f23df3bed7ee5445accc65a0fb3ff03953/xxhash-3.6.0-cp314-cp314t-win32.whl", hash = "sha256:5851f033c3030dd95c086b4a36a2683c2ff4a799b23af60977188b057e467119", size = 31586, upload-time = "2025-10-02T14:36:15.603Z" }, + { url = "https://files.pythonhosted.org/packages/03/d6/4cc450345be9924fd5dc8c590ceda1db5b43a0a889587b0ae81a95511360/xxhash-3.6.0-cp314-cp314t-win_amd64.whl", hash = "sha256:0444e7967dac37569052d2409b00a8860c2135cff05502df4da80267d384849f", size = 32526, upload-time = "2025-10-02T14:36:16.708Z" }, + { url = "https://files.pythonhosted.org/packages/0f/c9/7243eb3f9eaabd1a88a5a5acadf06df2d83b100c62684b7425c6a11bcaa8/xxhash-3.6.0-cp314-cp314t-win_arm64.whl", hash = "sha256:bb79b1e63f6fd84ec778a4b1916dfe0a7c3fdb986c06addd5db3a0d413819d95", size = 28898, upload-time = "2025-10-02T14:36:17.843Z" }, + { url = "https://files.pythonhosted.org/packages/93/1e/8aec23647a34a249f62e2398c42955acd9b4c6ed5cf08cbea94dc46f78d2/xxhash-3.6.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:0f7b7e2ec26c1666ad5fc9dbfa426a6a3367ceaf79db5dd76264659d509d73b0", size = 30662, upload-time = "2025-10-02T14:37:01.743Z" }, + { url = "https://files.pythonhosted.org/packages/b8/0b/b14510b38ba91caf43006209db846a696ceea6a847a0c9ba0a5b1adc53d6/xxhash-3.6.0-pp311-pypy311_pp73-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:5dc1e14d14fa0f5789ec29a7062004b5933964bb9b02aae6622b8f530dc40296", size = 41056, upload-time = "2025-10-02T14:37:02.879Z" }, + { url = "https://files.pythonhosted.org/packages/50/55/15a7b8a56590e66ccd374bbfa3f9ffc45b810886c8c3b614e3f90bd2367c/xxhash-3.6.0-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:881b47fc47e051b37d94d13e7455131054b56749b91b508b0907eb07900d1c13", size = 36251, upload-time = "2025-10-02T14:37:04.44Z" }, + { url = "https://files.pythonhosted.org/packages/62/b2/5ac99a041a29e58e95f907876b04f7067a0242cb85b5f39e726153981503/xxhash-3.6.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c6dc31591899f5e5666f04cc2e529e69b4072827085c1ef15294d91a004bc1bd", size = 32481, upload-time = "2025-10-02T14:37:05.869Z" }, + { url = "https://files.pythonhosted.org/packages/7b/d9/8d95e906764a386a3d3b596f3c68bb63687dfca806373509f51ce8eea81f/xxhash-3.6.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:15e0dac10eb9309508bfc41f7f9deaa7755c69e35af835db9cb10751adebc35d", size = 31565, upload-time = "2025-10-02T14:37:06.966Z" }, +] + +[[package]] +name = "yarl" +version = "1.22.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "idna" }, + { name = "multidict" }, + { name = "propcache" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/57/63/0c6ebca57330cd313f6102b16dd57ffaf3ec4c83403dcb45dbd15c6f3ea1/yarl-1.22.0.tar.gz", hash = "sha256:bebf8557577d4401ba8bd9ff33906f1376c877aa78d1fe216ad01b4d6745af71", size = 187169, upload-time = "2025-10-06T14:12:55.963Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/43/a2204825342f37c337f5edb6637040fa14e365b2fcc2346960201d457579/yarl-1.22.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:c7bd6683587567e5a49ee6e336e0612bec8329be1b7d4c8af5687dcdeb67ee1e", size = 140517, upload-time = "2025-10-06T14:08:42.494Z" }, + { url = "https://files.pythonhosted.org/packages/44/6f/674f3e6f02266428c56f704cd2501c22f78e8b2eeb23f153117cc86fb28a/yarl-1.22.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:5cdac20da754f3a723cceea5b3448e1a2074866406adeb4ef35b469d089adb8f", size = 93495, upload-time = "2025-10-06T14:08:46.2Z" }, + { url = "https://files.pythonhosted.org/packages/b8/12/5b274d8a0f30c07b91b2f02cba69152600b47830fcfb465c108880fcee9c/yarl-1.22.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:07a524d84df0c10f41e3ee918846e1974aba4ec017f990dc735aad487a0bdfdf", size = 94400, upload-time = "2025-10-06T14:08:47.855Z" }, + { url = "https://files.pythonhosted.org/packages/e2/7f/df1b6949b1fa1aa9ff6de6e2631876ad4b73c4437822026e85d8acb56bb1/yarl-1.22.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e1b329cb8146d7b736677a2440e422eadd775d1806a81db2d4cded80a48efc1a", size = 347545, upload-time = "2025-10-06T14:08:49.683Z" }, + { url = "https://files.pythonhosted.org/packages/84/09/f92ed93bd6cd77872ab6c3462df45ca45cd058d8f1d0c9b4f54c1704429f/yarl-1.22.0-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:75976c6945d85dbb9ee6308cd7ff7b1fb9409380c82d6119bd778d8fcfe2931c", size = 319598, upload-time = "2025-10-06T14:08:51.215Z" }, + { url = "https://files.pythonhosted.org/packages/c3/97/ac3f3feae7d522cf7ccec3d340bb0b2b61c56cb9767923df62a135092c6b/yarl-1.22.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:80ddf7a5f8c86cb3eb4bc9028b07bbbf1f08a96c5c0bc1244be5e8fefcb94147", size = 363893, upload-time = "2025-10-06T14:08:53.144Z" }, + { url = "https://files.pythonhosted.org/packages/06/49/f3219097403b9c84a4d079b1d7bda62dd9b86d0d6e4428c02d46ab2c77fc/yarl-1.22.0-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d332fc2e3c94dad927f2112395772a4e4fedbcf8f80efc21ed7cdfae4d574fdb", size = 371240, upload-time = "2025-10-06T14:08:55.036Z" }, + { url = "https://files.pythonhosted.org/packages/35/9f/06b765d45c0e44e8ecf0fe15c9eacbbde342bb5b7561c46944f107bfb6c3/yarl-1.22.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0cf71bf877efeac18b38d3930594c0948c82b64547c1cf420ba48722fe5509f6", size = 346965, upload-time = "2025-10-06T14:08:56.722Z" }, + { url = "https://files.pythonhosted.org/packages/c5/69/599e7cea8d0fcb1694323b0db0dda317fa3162f7b90166faddecf532166f/yarl-1.22.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:663e1cadaddae26be034a6ab6072449a8426ddb03d500f43daf952b74553bba0", size = 342026, upload-time = "2025-10-06T14:08:58.563Z" }, + { url = "https://files.pythonhosted.org/packages/95/6f/9dfd12c8bc90fea9eab39832ee32ea48f8e53d1256252a77b710c065c89f/yarl-1.22.0-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:6dcbb0829c671f305be48a7227918cfcd11276c2d637a8033a99a02b67bf9eda", size = 335637, upload-time = "2025-10-06T14:09:00.506Z" }, + { url = "https://files.pythonhosted.org/packages/57/2e/34c5b4eb9b07e16e873db5b182c71e5f06f9b5af388cdaa97736d79dd9a6/yarl-1.22.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:f0d97c18dfd9a9af4490631905a3f131a8e4c9e80a39353919e2cfed8f00aedc", size = 359082, upload-time = "2025-10-06T14:09:01.936Z" }, + { url = "https://files.pythonhosted.org/packages/31/71/fa7e10fb772d273aa1f096ecb8ab8594117822f683bab7d2c5a89914c92a/yarl-1.22.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:437840083abe022c978470b942ff832c3940b2ad3734d424b7eaffcd07f76737", size = 357811, upload-time = "2025-10-06T14:09:03.445Z" }, + { url = "https://files.pythonhosted.org/packages/26/da/11374c04e8e1184a6a03cf9c8f5688d3e5cec83ed6f31ad3481b3207f709/yarl-1.22.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:a899cbd98dce6f5d8de1aad31cb712ec0a530abc0a86bd6edaa47c1090138467", size = 351223, upload-time = "2025-10-06T14:09:05.401Z" }, + { url = "https://files.pythonhosted.org/packages/82/8f/e2d01f161b0c034a30410e375e191a5d27608c1f8693bab1a08b089ca096/yarl-1.22.0-cp310-cp310-win32.whl", hash = "sha256:595697f68bd1f0c1c159fcb97b661fc9c3f5db46498043555d04805430e79bea", size = 82118, upload-time = "2025-10-06T14:09:11.148Z" }, + { url = "https://files.pythonhosted.org/packages/62/46/94c76196642dbeae634c7a61ba3da88cd77bed875bf6e4a8bed037505aa6/yarl-1.22.0-cp310-cp310-win_amd64.whl", hash = "sha256:cb95a9b1adaa48e41815a55ae740cfda005758104049a640a398120bf02515ca", size = 86852, upload-time = "2025-10-06T14:09:12.958Z" }, + { url = "https://files.pythonhosted.org/packages/af/af/7df4f179d3b1a6dcb9a4bd2ffbc67642746fcafdb62580e66876ce83fff4/yarl-1.22.0-cp310-cp310-win_arm64.whl", hash = "sha256:b85b982afde6df99ecc996990d4ad7ccbdbb70e2a4ba4de0aecde5922ba98a0b", size = 82012, upload-time = "2025-10-06T14:09:14.664Z" }, + { url = "https://files.pythonhosted.org/packages/4d/27/5ab13fc84c76a0250afd3d26d5936349a35be56ce5785447d6c423b26d92/yarl-1.22.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:1ab72135b1f2db3fed3997d7e7dc1b80573c67138023852b6efb336a5eae6511", size = 141607, upload-time = "2025-10-06T14:09:16.298Z" }, + { url = "https://files.pythonhosted.org/packages/6a/a1/d065d51d02dc02ce81501d476b9ed2229d9a990818332242a882d5d60340/yarl-1.22.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:669930400e375570189492dc8d8341301578e8493aec04aebc20d4717f899dd6", size = 94027, upload-time = "2025-10-06T14:09:17.786Z" }, + { url = "https://files.pythonhosted.org/packages/c1/da/8da9f6a53f67b5106ffe902c6fa0164e10398d4e150d85838b82f424072a/yarl-1.22.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:792a2af6d58177ef7c19cbf0097aba92ca1b9cb3ffdd9c7470e156c8f9b5e028", size = 94963, upload-time = "2025-10-06T14:09:19.662Z" }, + { url = "https://files.pythonhosted.org/packages/68/fe/2c1f674960c376e29cb0bec1249b117d11738db92a6ccc4a530b972648db/yarl-1.22.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3ea66b1c11c9150f1372f69afb6b8116f2dd7286f38e14ea71a44eee9ec51b9d", size = 368406, upload-time = "2025-10-06T14:09:21.402Z" }, + { url = "https://files.pythonhosted.org/packages/95/26/812a540e1c3c6418fec60e9bbd38e871eaba9545e94fa5eff8f4a8e28e1e/yarl-1.22.0-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3e2daa88dc91870215961e96a039ec73e4937da13cf77ce17f9cad0c18df3503", size = 336581, upload-time = "2025-10-06T14:09:22.98Z" }, + { url = "https://files.pythonhosted.org/packages/0b/f5/5777b19e26fdf98563985e481f8be3d8a39f8734147a6ebf459d0dab5a6b/yarl-1.22.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ba440ae430c00eee41509353628600212112cd5018d5def7e9b05ea7ac34eb65", size = 388924, upload-time = "2025-10-06T14:09:24.655Z" }, + { url = "https://files.pythonhosted.org/packages/86/08/24bd2477bd59c0bbd994fe1d93b126e0472e4e3df5a96a277b0a55309e89/yarl-1.22.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:e6438cc8f23a9c1478633d216b16104a586b9761db62bfacb6425bac0a36679e", size = 392890, upload-time = "2025-10-06T14:09:26.617Z" }, + { url = "https://files.pythonhosted.org/packages/46/00/71b90ed48e895667ecfb1eaab27c1523ee2fa217433ed77a73b13205ca4b/yarl-1.22.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4c52a6e78aef5cf47a98ef8e934755abf53953379b7d53e68b15ff4420e6683d", size = 365819, upload-time = "2025-10-06T14:09:28.544Z" }, + { url = "https://files.pythonhosted.org/packages/30/2d/f715501cae832651d3282387c6a9236cd26bd00d0ff1e404b3dc52447884/yarl-1.22.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:3b06bcadaac49c70f4c88af4ffcfbe3dc155aab3163e75777818092478bcbbe7", size = 363601, upload-time = "2025-10-06T14:09:30.568Z" }, + { url = "https://files.pythonhosted.org/packages/f8/f9/a678c992d78e394e7126ee0b0e4e71bd2775e4334d00a9278c06a6cce96a/yarl-1.22.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:6944b2dc72c4d7f7052683487e3677456050ff77fcf5e6204e98caf785ad1967", size = 358072, upload-time = "2025-10-06T14:09:32.528Z" }, + { url = "https://files.pythonhosted.org/packages/2c/d1/b49454411a60edb6fefdcad4f8e6dbba7d8019e3a508a1c5836cba6d0781/yarl-1.22.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:d5372ca1df0f91a86b047d1277c2aaf1edb32d78bbcefffc81b40ffd18f027ed", size = 385311, upload-time = "2025-10-06T14:09:34.634Z" }, + { url = "https://files.pythonhosted.org/packages/87/e5/40d7a94debb8448c7771a916d1861d6609dddf7958dc381117e7ba36d9e8/yarl-1.22.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:51af598701f5299012b8416486b40fceef8c26fc87dc6d7d1f6fc30609ea0aa6", size = 381094, upload-time = "2025-10-06T14:09:36.268Z" }, + { url = "https://files.pythonhosted.org/packages/35/d8/611cc282502381ad855448643e1ad0538957fc82ae83dfe7762c14069e14/yarl-1.22.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b266bd01fedeffeeac01a79ae181719ff848a5a13ce10075adbefc8f1daee70e", size = 370944, upload-time = "2025-10-06T14:09:37.872Z" }, + { url = "https://files.pythonhosted.org/packages/2d/df/fadd00fb1c90e1a5a8bd731fa3d3de2e165e5a3666a095b04e31b04d9cb6/yarl-1.22.0-cp311-cp311-win32.whl", hash = "sha256:a9b1ba5610a4e20f655258d5a1fdc7ebe3d837bb0e45b581398b99eb98b1f5ca", size = 81804, upload-time = "2025-10-06T14:09:39.359Z" }, + { url = "https://files.pythonhosted.org/packages/b5/f7/149bb6f45f267cb5c074ac40c01c6b3ea6d8a620d34b337f6321928a1b4d/yarl-1.22.0-cp311-cp311-win_amd64.whl", hash = "sha256:078278b9b0b11568937d9509b589ee83ef98ed6d561dfe2020e24a9fd08eaa2b", size = 86858, upload-time = "2025-10-06T14:09:41.068Z" }, + { url = "https://files.pythonhosted.org/packages/2b/13/88b78b93ad3f2f0b78e13bfaaa24d11cbc746e93fe76d8c06bf139615646/yarl-1.22.0-cp311-cp311-win_arm64.whl", hash = "sha256:b6a6f620cfe13ccec221fa312139135166e47ae169f8253f72a0abc0dae94376", size = 81637, upload-time = "2025-10-06T14:09:42.712Z" }, + { url = "https://files.pythonhosted.org/packages/75/ff/46736024fee3429b80a165a732e38e5d5a238721e634ab41b040d49f8738/yarl-1.22.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:e340382d1afa5d32b892b3ff062436d592ec3d692aeea3bef3a5cfe11bbf8c6f", size = 142000, upload-time = "2025-10-06T14:09:44.631Z" }, + { url = "https://files.pythonhosted.org/packages/5a/9a/b312ed670df903145598914770eb12de1bac44599549b3360acc96878df8/yarl-1.22.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f1e09112a2c31ffe8d80be1b0988fa6a18c5d5cad92a9ffbb1c04c91bfe52ad2", size = 94338, upload-time = "2025-10-06T14:09:46.372Z" }, + { url = "https://files.pythonhosted.org/packages/ba/f5/0601483296f09c3c65e303d60c070a5c19fcdbc72daa061e96170785bc7d/yarl-1.22.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:939fe60db294c786f6b7c2d2e121576628468f65453d86b0fe36cb52f987bd74", size = 94909, upload-time = "2025-10-06T14:09:48.648Z" }, + { url = "https://files.pythonhosted.org/packages/60/41/9a1fe0b73dbcefce72e46cf149b0e0a67612d60bfc90fb59c2b2efdfbd86/yarl-1.22.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e1651bf8e0398574646744c1885a41198eba53dc8a9312b954073f845c90a8df", size = 372940, upload-time = "2025-10-06T14:09:50.089Z" }, + { url = "https://files.pythonhosted.org/packages/17/7a/795cb6dfee561961c30b800f0ed616b923a2ec6258b5def2a00bf8231334/yarl-1.22.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:b8a0588521a26bf92a57a1705b77b8b59044cdceccac7151bd8d229e66b8dedb", size = 345825, upload-time = "2025-10-06T14:09:52.142Z" }, + { url = "https://files.pythonhosted.org/packages/d7/93/a58f4d596d2be2ae7bab1a5846c4d270b894958845753b2c606d666744d3/yarl-1.22.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:42188e6a615c1a75bcaa6e150c3fe8f3e8680471a6b10150c5f7e83f47cc34d2", size = 386705, upload-time = "2025-10-06T14:09:54.128Z" }, + { url = "https://files.pythonhosted.org/packages/61/92/682279d0e099d0e14d7fd2e176bd04f48de1484f56546a3e1313cd6c8e7c/yarl-1.22.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f6d2cb59377d99718913ad9a151030d6f83ef420a2b8f521d94609ecc106ee82", size = 396518, upload-time = "2025-10-06T14:09:55.762Z" }, + { url = "https://files.pythonhosted.org/packages/db/0f/0d52c98b8a885aeda831224b78f3be7ec2e1aa4a62091f9f9188c3c65b56/yarl-1.22.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:50678a3b71c751d58d7908edc96d332af328839eea883bb554a43f539101277a", size = 377267, upload-time = "2025-10-06T14:09:57.958Z" }, + { url = "https://files.pythonhosted.org/packages/22/42/d2685e35908cbeaa6532c1fc73e89e7f2efb5d8a7df3959ea8e37177c5a3/yarl-1.22.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1e8fbaa7cec507aa24ea27a01456e8dd4b6fab829059b69844bd348f2d467124", size = 365797, upload-time = "2025-10-06T14:09:59.527Z" }, + { url = "https://files.pythonhosted.org/packages/a2/83/cf8c7bcc6355631762f7d8bdab920ad09b82efa6b722999dfb05afa6cfac/yarl-1.22.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:433885ab5431bc3d3d4f2f9bd15bfa1614c522b0f1405d62c4f926ccd69d04fa", size = 365535, upload-time = "2025-10-06T14:10:01.139Z" }, + { url = "https://files.pythonhosted.org/packages/25/e1/5302ff9b28f0c59cac913b91fe3f16c59a033887e57ce9ca5d41a3a94737/yarl-1.22.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:b790b39c7e9a4192dc2e201a282109ed2985a1ddbd5ac08dc56d0e121400a8f7", size = 382324, upload-time = "2025-10-06T14:10:02.756Z" }, + { url = "https://files.pythonhosted.org/packages/bf/cd/4617eb60f032f19ae3a688dc990d8f0d89ee0ea378b61cac81ede3e52fae/yarl-1.22.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:31f0b53913220599446872d757257be5898019c85e7971599065bc55065dc99d", size = 383803, upload-time = "2025-10-06T14:10:04.552Z" }, + { url = "https://files.pythonhosted.org/packages/59/65/afc6e62bb506a319ea67b694551dab4a7e6fb7bf604e9bd9f3e11d575fec/yarl-1.22.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a49370e8f711daec68d09b821a34e1167792ee2d24d405cbc2387be4f158b520", size = 374220, upload-time = "2025-10-06T14:10:06.489Z" }, + { url = "https://files.pythonhosted.org/packages/e7/3d/68bf18d50dc674b942daec86a9ba922d3113d8399b0e52b9897530442da2/yarl-1.22.0-cp312-cp312-win32.whl", hash = "sha256:70dfd4f241c04bd9239d53b17f11e6ab672b9f1420364af63e8531198e3f5fe8", size = 81589, upload-time = "2025-10-06T14:10:09.254Z" }, + { url = "https://files.pythonhosted.org/packages/c8/9a/6ad1a9b37c2f72874f93e691b2e7ecb6137fb2b899983125db4204e47575/yarl-1.22.0-cp312-cp312-win_amd64.whl", hash = "sha256:8884d8b332a5e9b88e23f60bb166890009429391864c685e17bd73a9eda9105c", size = 87213, upload-time = "2025-10-06T14:10:11.369Z" }, + { url = "https://files.pythonhosted.org/packages/44/c5/c21b562d1680a77634d748e30c653c3ca918beb35555cff24986fff54598/yarl-1.22.0-cp312-cp312-win_arm64.whl", hash = "sha256:ea70f61a47f3cc93bdf8b2f368ed359ef02a01ca6393916bc8ff877427181e74", size = 81330, upload-time = "2025-10-06T14:10:13.112Z" }, + { url = "https://files.pythonhosted.org/packages/ea/f3/d67de7260456ee105dc1d162d43a019ecad6b91e2f51809d6cddaa56690e/yarl-1.22.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8dee9c25c74997f6a750cd317b8ca63545169c098faee42c84aa5e506c819b53", size = 139980, upload-time = "2025-10-06T14:10:14.601Z" }, + { url = "https://files.pythonhosted.org/packages/01/88/04d98af0b47e0ef42597b9b28863b9060bb515524da0a65d5f4db160b2d5/yarl-1.22.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:01e73b85a5434f89fc4fe27dcda2aff08ddf35e4d47bbbea3bdcd25321af538a", size = 93424, upload-time = "2025-10-06T14:10:16.115Z" }, + { url = "https://files.pythonhosted.org/packages/18/91/3274b215fd8442a03975ce6bee5fe6aa57a8326b29b9d3d56234a1dca244/yarl-1.22.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:22965c2af250d20c873cdbee8ff958fb809940aeb2e74ba5f20aaf6b7ac8c70c", size = 93821, upload-time = "2025-10-06T14:10:17.993Z" }, + { url = "https://files.pythonhosted.org/packages/61/3a/caf4e25036db0f2da4ca22a353dfeb3c9d3c95d2761ebe9b14df8fc16eb0/yarl-1.22.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b4f15793aa49793ec8d1c708ab7f9eded1aa72edc5174cae703651555ed1b601", size = 373243, upload-time = "2025-10-06T14:10:19.44Z" }, + { url = "https://files.pythonhosted.org/packages/6e/9e/51a77ac7516e8e7803b06e01f74e78649c24ee1021eca3d6a739cb6ea49c/yarl-1.22.0-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e5542339dcf2747135c5c85f68680353d5cb9ffd741c0f2e8d832d054d41f35a", size = 342361, upload-time = "2025-10-06T14:10:21.124Z" }, + { url = "https://files.pythonhosted.org/packages/d4/f8/33b92454789dde8407f156c00303e9a891f1f51a0330b0fad7c909f87692/yarl-1.22.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5c401e05ad47a75869c3ab3e35137f8468b846770587e70d71e11de797d113df", size = 387036, upload-time = "2025-10-06T14:10:22.902Z" }, + { url = "https://files.pythonhosted.org/packages/d9/9a/c5db84ea024f76838220280f732970aa4ee154015d7f5c1bfb60a267af6f/yarl-1.22.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:243dda95d901c733f5b59214d28b0120893d91777cb8aa043e6ef059d3cddfe2", size = 397671, upload-time = "2025-10-06T14:10:24.523Z" }, + { url = "https://files.pythonhosted.org/packages/11/c9/cd8538dc2e7727095e0c1d867bad1e40c98f37763e6d995c1939f5fdc7b1/yarl-1.22.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bec03d0d388060058f5d291a813f21c011041938a441c593374da6077fe21b1b", size = 377059, upload-time = "2025-10-06T14:10:26.406Z" }, + { url = "https://files.pythonhosted.org/packages/a1/b9/ab437b261702ced75122ed78a876a6dec0a1b0f5e17a4ac7a9a2482d8abe/yarl-1.22.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:b0748275abb8c1e1e09301ee3cf90c8a99678a4e92e4373705f2a2570d581273", size = 365356, upload-time = "2025-10-06T14:10:28.461Z" }, + { url = "https://files.pythonhosted.org/packages/b2/9d/8e1ae6d1d008a9567877b08f0ce4077a29974c04c062dabdb923ed98e6fe/yarl-1.22.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:47fdb18187e2a4e18fda2c25c05d8251a9e4a521edaed757fef033e7d8498d9a", size = 361331, upload-time = "2025-10-06T14:10:30.541Z" }, + { url = "https://files.pythonhosted.org/packages/ca/5a/09b7be3905962f145b73beb468cdd53db8aa171cf18c80400a54c5b82846/yarl-1.22.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:c7044802eec4524fde550afc28edda0dd5784c4c45f0be151a2d3ba017daca7d", size = 382590, upload-time = "2025-10-06T14:10:33.352Z" }, + { url = "https://files.pythonhosted.org/packages/aa/7f/59ec509abf90eda5048b0bc3e2d7b5099dffdb3e6b127019895ab9d5ef44/yarl-1.22.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:139718f35149ff544caba20fce6e8a2f71f1e39b92c700d8438a0b1d2a631a02", size = 385316, upload-time = "2025-10-06T14:10:35.034Z" }, + { url = "https://files.pythonhosted.org/packages/e5/84/891158426bc8036bfdfd862fabd0e0fa25df4176ec793e447f4b85cf1be4/yarl-1.22.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e1b51bebd221006d3d2f95fbe124b22b247136647ae5dcc8c7acafba66e5ee67", size = 374431, upload-time = "2025-10-06T14:10:37.76Z" }, + { url = "https://files.pythonhosted.org/packages/bb/49/03da1580665baa8bef5e8ed34c6df2c2aca0a2f28bf397ed238cc1bbc6f2/yarl-1.22.0-cp313-cp313-win32.whl", hash = "sha256:d3e32536234a95f513bd374e93d717cf6b2231a791758de6c509e3653f234c95", size = 81555, upload-time = "2025-10-06T14:10:39.649Z" }, + { url = "https://files.pythonhosted.org/packages/9a/ee/450914ae11b419eadd067c6183ae08381cfdfcb9798b90b2b713bbebddda/yarl-1.22.0-cp313-cp313-win_amd64.whl", hash = "sha256:47743b82b76d89a1d20b83e60d5c20314cbd5ba2befc9cda8f28300c4a08ed4d", size = 86965, upload-time = "2025-10-06T14:10:41.313Z" }, + { url = "https://files.pythonhosted.org/packages/98/4d/264a01eae03b6cf629ad69bae94e3b0e5344741e929073678e84bf7a3e3b/yarl-1.22.0-cp313-cp313-win_arm64.whl", hash = "sha256:5d0fcda9608875f7d052eff120c7a5da474a6796fe4d83e152e0e4d42f6d1a9b", size = 81205, upload-time = "2025-10-06T14:10:43.167Z" }, + { url = "https://files.pythonhosted.org/packages/88/fc/6908f062a2f77b5f9f6d69cecb1747260831ff206adcbc5b510aff88df91/yarl-1.22.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:719ae08b6972befcba4310e49edb1161a88cdd331e3a694b84466bd938a6ab10", size = 146209, upload-time = "2025-10-06T14:10:44.643Z" }, + { url = "https://files.pythonhosted.org/packages/65/47/76594ae8eab26210b4867be6f49129861ad33da1f1ebdf7051e98492bf62/yarl-1.22.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:47d8a5c446df1c4db9d21b49619ffdba90e77c89ec6e283f453856c74b50b9e3", size = 95966, upload-time = "2025-10-06T14:10:46.554Z" }, + { url = "https://files.pythonhosted.org/packages/ab/ce/05e9828a49271ba6b5b038b15b3934e996980dd78abdfeb52a04cfb9467e/yarl-1.22.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:cfebc0ac8333520d2d0423cbbe43ae43c8838862ddb898f5ca68565e395516e9", size = 97312, upload-time = "2025-10-06T14:10:48.007Z" }, + { url = "https://files.pythonhosted.org/packages/d1/c5/7dffad5e4f2265b29c9d7ec869c369e4223166e4f9206fc2243ee9eea727/yarl-1.22.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4398557cbf484207df000309235979c79c4356518fd5c99158c7d38203c4da4f", size = 361967, upload-time = "2025-10-06T14:10:49.997Z" }, + { url = "https://files.pythonhosted.org/packages/50/b2/375b933c93a54bff7fc041e1a6ad2c0f6f733ffb0c6e642ce56ee3b39970/yarl-1.22.0-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2ca6fd72a8cd803be290d42f2dec5cdcd5299eeb93c2d929bf060ad9efaf5de0", size = 323949, upload-time = "2025-10-06T14:10:52.004Z" }, + { url = "https://files.pythonhosted.org/packages/66/50/bfc2a29a1d78644c5a7220ce2f304f38248dc94124a326794e677634b6cf/yarl-1.22.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ca1f59c4e1ab6e72f0a23c13fca5430f889634166be85dbf1013683e49e3278e", size = 361818, upload-time = "2025-10-06T14:10:54.078Z" }, + { url = "https://files.pythonhosted.org/packages/46/96/f3941a46af7d5d0f0498f86d71275696800ddcdd20426298e572b19b91ff/yarl-1.22.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6c5010a52015e7c70f86eb967db0f37f3c8bd503a695a49f8d45700144667708", size = 372626, upload-time = "2025-10-06T14:10:55.767Z" }, + { url = "https://files.pythonhosted.org/packages/c1/42/8b27c83bb875cd89448e42cd627e0fb971fa1675c9ec546393d18826cb50/yarl-1.22.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9d7672ecf7557476642c88497c2f8d8542f8e36596e928e9bcba0e42e1e7d71f", size = 341129, upload-time = "2025-10-06T14:10:57.985Z" }, + { url = "https://files.pythonhosted.org/packages/49/36/99ca3122201b382a3cf7cc937b95235b0ac944f7e9f2d5331d50821ed352/yarl-1.22.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:3b7c88eeef021579d600e50363e0b6ee4f7f6f728cd3486b9d0f3ee7b946398d", size = 346776, upload-time = "2025-10-06T14:10:59.633Z" }, + { url = "https://files.pythonhosted.org/packages/85/b4/47328bf996acd01a4c16ef9dcd2f59c969f495073616586f78cd5f2efb99/yarl-1.22.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:f4afb5c34f2c6fecdcc182dfcfc6af6cccf1aa923eed4d6a12e9d96904e1a0d8", size = 334879, upload-time = "2025-10-06T14:11:01.454Z" }, + { url = "https://files.pythonhosted.org/packages/c2/ad/b77d7b3f14a4283bffb8e92c6026496f6de49751c2f97d4352242bba3990/yarl-1.22.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:59c189e3e99a59cf8d83cbb31d4db02d66cda5a1a4374e8a012b51255341abf5", size = 350996, upload-time = "2025-10-06T14:11:03.452Z" }, + { url = "https://files.pythonhosted.org/packages/81/c8/06e1d69295792ba54d556f06686cbd6a7ce39c22307100e3fb4a2c0b0a1d/yarl-1.22.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:5a3bf7f62a289fa90f1990422dc8dff5a458469ea71d1624585ec3a4c8d6960f", size = 356047, upload-time = "2025-10-06T14:11:05.115Z" }, + { url = "https://files.pythonhosted.org/packages/4b/b8/4c0e9e9f597074b208d18cef227d83aac36184bfbc6eab204ea55783dbc5/yarl-1.22.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:de6b9a04c606978fdfe72666fa216ffcf2d1a9f6a381058d4378f8d7b1e5de62", size = 342947, upload-time = "2025-10-06T14:11:08.137Z" }, + { url = "https://files.pythonhosted.org/packages/e0/e5/11f140a58bf4c6ad7aca69a892bff0ee638c31bea4206748fc0df4ebcb3a/yarl-1.22.0-cp313-cp313t-win32.whl", hash = "sha256:1834bb90991cc2999f10f97f5f01317f99b143284766d197e43cd5b45eb18d03", size = 86943, upload-time = "2025-10-06T14:11:10.284Z" }, + { url = "https://files.pythonhosted.org/packages/31/74/8b74bae38ed7fe6793d0c15a0c8207bbb819cf287788459e5ed230996cdd/yarl-1.22.0-cp313-cp313t-win_amd64.whl", hash = "sha256:ff86011bd159a9d2dfc89c34cfd8aff12875980e3bd6a39ff097887520e60249", size = 93715, upload-time = "2025-10-06T14:11:11.739Z" }, + { url = "https://files.pythonhosted.org/packages/69/66/991858aa4b5892d57aef7ee1ba6b4d01ec3b7eb3060795d34090a3ca3278/yarl-1.22.0-cp313-cp313t-win_arm64.whl", hash = "sha256:7861058d0582b847bc4e3a4a4c46828a410bca738673f35a29ba3ca5db0b473b", size = 83857, upload-time = "2025-10-06T14:11:13.586Z" }, + { url = "https://files.pythonhosted.org/packages/46/b3/e20ef504049f1a1c54a814b4b9bed96d1ac0e0610c3b4da178f87209db05/yarl-1.22.0-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:34b36c2c57124530884d89d50ed2c1478697ad7473efd59cfd479945c95650e4", size = 140520, upload-time = "2025-10-06T14:11:15.465Z" }, + { url = "https://files.pythonhosted.org/packages/e4/04/3532d990fdbab02e5ede063676b5c4260e7f3abea2151099c2aa745acc4c/yarl-1.22.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:0dd9a702591ca2e543631c2a017e4a547e38a5c0f29eece37d9097e04a7ac683", size = 93504, upload-time = "2025-10-06T14:11:17.106Z" }, + { url = "https://files.pythonhosted.org/packages/11/63/ff458113c5c2dac9a9719ac68ee7c947cb621432bcf28c9972b1c0e83938/yarl-1.22.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:594fcab1032e2d2cc3321bb2e51271e7cd2b516c7d9aee780ece81b07ff8244b", size = 94282, upload-time = "2025-10-06T14:11:19.064Z" }, + { url = "https://files.pythonhosted.org/packages/a7/bc/315a56aca762d44a6aaaf7ad253f04d996cb6b27bad34410f82d76ea8038/yarl-1.22.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f3d7a87a78d46a2e3d5b72587ac14b4c16952dd0887dbb051451eceac774411e", size = 372080, upload-time = "2025-10-06T14:11:20.996Z" }, + { url = "https://files.pythonhosted.org/packages/3f/3f/08e9b826ec2e099ea6e7c69a61272f4f6da62cb5b1b63590bb80ca2e4a40/yarl-1.22.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:852863707010316c973162e703bddabec35e8757e67fcb8ad58829de1ebc8590", size = 338696, upload-time = "2025-10-06T14:11:22.847Z" }, + { url = "https://files.pythonhosted.org/packages/e3/9f/90360108e3b32bd76789088e99538febfea24a102380ae73827f62073543/yarl-1.22.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:131a085a53bfe839a477c0845acf21efc77457ba2bcf5899618136d64f3303a2", size = 387121, upload-time = "2025-10-06T14:11:24.889Z" }, + { url = "https://files.pythonhosted.org/packages/98/92/ab8d4657bd5b46a38094cfaea498f18bb70ce6b63508fd7e909bd1f93066/yarl-1.22.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:078a8aefd263f4d4f923a9677b942b445a2be970ca24548a8102689a3a8ab8da", size = 394080, upload-time = "2025-10-06T14:11:27.307Z" }, + { url = "https://files.pythonhosted.org/packages/f5/e7/d8c5a7752fef68205296201f8ec2bf718f5c805a7a7e9880576c67600658/yarl-1.22.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bca03b91c323036913993ff5c738d0842fc9c60c4648e5c8d98331526df89784", size = 372661, upload-time = "2025-10-06T14:11:29.387Z" }, + { url = "https://files.pythonhosted.org/packages/b6/2e/f4d26183c8db0bb82d491b072f3127fb8c381a6206a3a56332714b79b751/yarl-1.22.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:68986a61557d37bb90d3051a45b91fa3d5c516d177dfc6dd6f2f436a07ff2b6b", size = 364645, upload-time = "2025-10-06T14:11:31.423Z" }, + { url = "https://files.pythonhosted.org/packages/80/7c/428e5812e6b87cd00ee8e898328a62c95825bf37c7fa87f0b6bb2ad31304/yarl-1.22.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:4792b262d585ff0dff6bcb787f8492e40698443ec982a3568c2096433660c694", size = 355361, upload-time = "2025-10-06T14:11:33.055Z" }, + { url = "https://files.pythonhosted.org/packages/ec/2a/249405fd26776f8b13c067378ef4d7dd49c9098d1b6457cdd152a99e96a9/yarl-1.22.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:ebd4549b108d732dba1d4ace67614b9545b21ece30937a63a65dd34efa19732d", size = 381451, upload-time = "2025-10-06T14:11:35.136Z" }, + { url = "https://files.pythonhosted.org/packages/67/a8/fb6b1adbe98cf1e2dd9fad71003d3a63a1bc22459c6e15f5714eb9323b93/yarl-1.22.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:f87ac53513d22240c7d59203f25cc3beac1e574c6cd681bbfd321987b69f95fd", size = 383814, upload-time = "2025-10-06T14:11:37.094Z" }, + { url = "https://files.pythonhosted.org/packages/d9/f9/3aa2c0e480fb73e872ae2814c43bc1e734740bb0d54e8cb2a95925f98131/yarl-1.22.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:22b029f2881599e2f1b06f8f1db2ee63bd309e2293ba2d566e008ba12778b8da", size = 370799, upload-time = "2025-10-06T14:11:38.83Z" }, + { url = "https://files.pythonhosted.org/packages/50/3c/af9dba3b8b5eeb302f36f16f92791f3ea62e3f47763406abf6d5a4a3333b/yarl-1.22.0-cp314-cp314-win32.whl", hash = "sha256:6a635ea45ba4ea8238463b4f7d0e721bad669f80878b7bfd1f89266e2ae63da2", size = 82990, upload-time = "2025-10-06T14:11:40.624Z" }, + { url = "https://files.pythonhosted.org/packages/ac/30/ac3a0c5bdc1d6efd1b41fa24d4897a4329b3b1e98de9449679dd327af4f0/yarl-1.22.0-cp314-cp314-win_amd64.whl", hash = "sha256:0d6e6885777af0f110b0e5d7e5dda8b704efed3894da26220b7f3d887b839a79", size = 88292, upload-time = "2025-10-06T14:11:42.578Z" }, + { url = "https://files.pythonhosted.org/packages/df/0a/227ab4ff5b998a1b7410abc7b46c9b7a26b0ca9e86c34ba4b8d8bc7c63d5/yarl-1.22.0-cp314-cp314-win_arm64.whl", hash = "sha256:8218f4e98d3c10d683584cb40f0424f4b9fd6e95610232dd75e13743b070ee33", size = 82888, upload-time = "2025-10-06T14:11:44.863Z" }, + { url = "https://files.pythonhosted.org/packages/06/5e/a15eb13db90abd87dfbefb9760c0f3f257ac42a5cac7e75dbc23bed97a9f/yarl-1.22.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:45c2842ff0e0d1b35a6bf1cd6c690939dacb617a70827f715232b2e0494d55d1", size = 146223, upload-time = "2025-10-06T14:11:46.796Z" }, + { url = "https://files.pythonhosted.org/packages/18/82/9665c61910d4d84f41a5bf6837597c89e665fa88aa4941080704645932a9/yarl-1.22.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:d947071e6ebcf2e2bee8fce76e10faca8f7a14808ca36a910263acaacef08eca", size = 95981, upload-time = "2025-10-06T14:11:48.845Z" }, + { url = "https://files.pythonhosted.org/packages/5d/9a/2f65743589809af4d0a6d3aa749343c4b5f4c380cc24a8e94a3c6625a808/yarl-1.22.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:334b8721303e61b00019474cc103bdac3d7b1f65e91f0bfedeec2d56dfe74b53", size = 97303, upload-time = "2025-10-06T14:11:50.897Z" }, + { url = "https://files.pythonhosted.org/packages/b0/ab/5b13d3e157505c43c3b43b5a776cbf7b24a02bc4cccc40314771197e3508/yarl-1.22.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1e7ce67c34138a058fd092f67d07a72b8e31ff0c9236e751957465a24b28910c", size = 361820, upload-time = "2025-10-06T14:11:52.549Z" }, + { url = "https://files.pythonhosted.org/packages/fb/76/242a5ef4677615cf95330cfc1b4610e78184400699bdda0acb897ef5e49a/yarl-1.22.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:d77e1b2c6d04711478cb1c4ab90db07f1609ccf06a287d5607fcd90dc9863acf", size = 323203, upload-time = "2025-10-06T14:11:54.225Z" }, + { url = "https://files.pythonhosted.org/packages/8c/96/475509110d3f0153b43d06164cf4195c64d16999e0c7e2d8a099adcd6907/yarl-1.22.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c4647674b6150d2cae088fc07de2738a84b8bcedebef29802cf0b0a82ab6face", size = 363173, upload-time = "2025-10-06T14:11:56.069Z" }, + { url = "https://files.pythonhosted.org/packages/c9/66/59db471aecfbd559a1fd48aedd954435558cd98c7d0da8b03cc6c140a32c/yarl-1.22.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:efb07073be061c8f79d03d04139a80ba33cbd390ca8f0297aae9cce6411e4c6b", size = 373562, upload-time = "2025-10-06T14:11:58.783Z" }, + { url = "https://files.pythonhosted.org/packages/03/1f/c5d94abc91557384719da10ff166b916107c1b45e4d0423a88457071dd88/yarl-1.22.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e51ac5435758ba97ad69617e13233da53908beccc6cfcd6c34bbed8dcbede486", size = 339828, upload-time = "2025-10-06T14:12:00.686Z" }, + { url = "https://files.pythonhosted.org/packages/5f/97/aa6a143d3afba17b6465733681c70cf175af89f76ec8d9286e08437a7454/yarl-1.22.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:33e32a0dd0c8205efa8e83d04fc9f19313772b78522d1bdc7d9aed706bfd6138", size = 347551, upload-time = "2025-10-06T14:12:02.628Z" }, + { url = "https://files.pythonhosted.org/packages/43/3c/45a2b6d80195959239a7b2a8810506d4eea5487dce61c2a3393e7fc3c52e/yarl-1.22.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:bf4a21e58b9cde0e401e683ebd00f6ed30a06d14e93f7c8fd059f8b6e8f87b6a", size = 334512, upload-time = "2025-10-06T14:12:04.871Z" }, + { url = "https://files.pythonhosted.org/packages/86/a0/c2ab48d74599c7c84cb104ebd799c5813de252bea0f360ffc29d270c2caa/yarl-1.22.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:e4b582bab49ac33c8deb97e058cd67c2c50dac0dd134874106d9c774fd272529", size = 352400, upload-time = "2025-10-06T14:12:06.624Z" }, + { url = "https://files.pythonhosted.org/packages/32/75/f8919b2eafc929567d3d8411f72bdb1a2109c01caaab4ebfa5f8ffadc15b/yarl-1.22.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:0b5bcc1a9c4839e7e30b7b30dd47fe5e7e44fb7054ec29b5bb8d526aa1041093", size = 357140, upload-time = "2025-10-06T14:12:08.362Z" }, + { url = "https://files.pythonhosted.org/packages/cf/72/6a85bba382f22cf78add705d8c3731748397d986e197e53ecc7835e76de7/yarl-1.22.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:c0232bce2170103ec23c454e54a57008a9a72b5d1c3105dc2496750da8cfa47c", size = 341473, upload-time = "2025-10-06T14:12:10.994Z" }, + { url = "https://files.pythonhosted.org/packages/35/18/55e6011f7c044dc80b98893060773cefcfdbf60dfefb8cb2f58b9bacbd83/yarl-1.22.0-cp314-cp314t-win32.whl", hash = "sha256:8009b3173bcd637be650922ac455946197d858b3630b6d8787aa9e5c4564533e", size = 89056, upload-time = "2025-10-06T14:12:13.317Z" }, + { url = "https://files.pythonhosted.org/packages/f9/86/0f0dccb6e59a9e7f122c5afd43568b1d31b8ab7dda5f1b01fb5c7025c9a9/yarl-1.22.0-cp314-cp314t-win_amd64.whl", hash = "sha256:9fb17ea16e972c63d25d4a97f016d235c78dd2344820eb35bc034bc32012ee27", size = 96292, upload-time = "2025-10-06T14:12:15.398Z" }, + { url = "https://files.pythonhosted.org/packages/48/b7/503c98092fb3b344a179579f55814b613c1fbb1c23b3ec14a7b008a66a6e/yarl-1.22.0-cp314-cp314t-win_arm64.whl", hash = "sha256:9f6d73c1436b934e3f01df1e1b21ff765cd1d28c77dfb9ace207f746d4610ee1", size = 85171, upload-time = "2025-10-06T14:12:16.935Z" }, + { url = "https://files.pythonhosted.org/packages/73/ae/b48f95715333080afb75a4504487cbe142cae1268afc482d06692d605ae6/yarl-1.22.0-py3-none-any.whl", hash = "sha256:1380560bdba02b6b6c90de54133c81c9f2a453dee9912fe58c1dcced1edb7cff", size = 46814, upload-time = "2025-10-06T14:12:53.872Z" }, +] + +[[package]] +name = "zipp" +version = "3.23.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e3/02/0f2892c661036d50ede074e376733dca2ae7c6eb617489437771209d4180/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166", size = 25547, upload-time = "2025-06-08T17:06:39.4Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2e/54/647ade08bf0db230bfea292f893923872fd20be6ac6f53b2b936ba839d75/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e", size = 10276, upload-time = "2025-06-08T17:06:38.034Z" }, +]