From b8c5f31c8966401ff86928fa84d935dba040e7a8 Mon Sep 17 00:00:00 2001 From: Sam Calder-Mason Date: Mon, 2 Jun 2025 10:47:40 +1000 Subject: [PATCH] icerberg meta --- .github/workflows/export-chunked.yml | 63 + .github/workflows/export-daily.yml | 72 + .github/workflows/export-hourly.yml | 72 + .github/workflows/export-manual.yml | 95 + .gitignore | 95 +- Makefile | 70 + README_EXPORTER.md | 240 +++ ai_plans/convert-export-scripts.md | 1006 +++++++++++ .../blob-bump-prediction/prediction.ipynb | 1489 ++++++++-------- config/environments.yaml | 47 + config/tables.yaml | 849 +++++++++ pyproject.toml | 33 + requirements.txt | 8 + scripts/__init__.py | 1 + scripts/backfill_iceberg.py | 243 +++ scripts/export_all.py | 147 ++ scripts/export_table.py | 81 + src/__init__.py | 3 + src/clickhouse.py | 160 ++ src/exporter.py | 452 +++++ src/iceberg_manager.py | 480 +++++ src/storage.py | 202 +++ uv.lock | 1552 +++++++++++++++++ 23 files changed, 6746 insertions(+), 714 deletions(-) create mode 100644 .github/workflows/export-chunked.yml create mode 100644 .github/workflows/export-daily.yml create mode 100644 .github/workflows/export-hourly.yml create mode 100644 .github/workflows/export-manual.yml create mode 100644 Makefile create mode 100644 README_EXPORTER.md create mode 100644 ai_plans/convert-export-scripts.md create mode 100644 config/environments.yaml create mode 100644 config/tables.yaml create mode 100644 pyproject.toml create mode 100644 requirements.txt create mode 100644 scripts/__init__.py create mode 100755 scripts/backfill_iceberg.py create mode 100755 scripts/export_all.py create mode 100755 scripts/export_table.py create mode 100644 src/__init__.py create mode 100644 src/clickhouse.py create mode 100644 src/exporter.py create mode 100644 src/iceberg_manager.py create mode 100644 src/storage.py create mode 100644 uv.lock diff --git a/.github/workflows/export-chunked.yml b/.github/workflows/export-chunked.yml new file mode 100644 index 00000000..788291e9 --- /dev/null +++ b/.github/workflows/export-chunked.yml @@ -0,0 +1,63 @@ +name: Export Chunked Tables + +on: + schedule: + - cron: '0 */6 * * *' # Every 6 hours + workflow_dispatch: + inputs: + environment: + description: 'Environment to use' + required: true + type: choice + options: + - production + - staging + default: production + dry_run: + description: 'Dry run only' + type: boolean + default: false + +jobs: + export: + runs-on: ubuntu-latest + timeout-minutes: 120 + + steps: + - uses: actions/checkout@v4 + + - name: Set up Python + uses: actions/setup-python@v5 + with: + python-version: '3.11' + cache: 'pip' + + - name: Install dependencies + run: | + pip install -r requirements.txt + + - name: Export chunked tables + env: + # Production secrets + CLICKHOUSE_PASSWORD: ${{ secrets.CLICKHOUSE_PASSWORD }} + EXPERIMENTAL_CLICKHOUSE_PASSWORD: ${{ secrets.EXPERIMENTAL_CLICKHOUSE_PASSWORD }} + AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }} + AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }} + # Staging secrets + CLICKHOUSE_STAGING_PASSWORD: ${{ secrets.CLICKHOUSE_STAGING_PASSWORD }} + EXPERIMENTAL_CLICKHOUSE_STAGING_PASSWORD: ${{ secrets.EXPERIMENTAL_CLICKHOUSE_STAGING_PASSWORD }} + STAGING_AWS_ACCESS_KEY_ID: ${{ secrets.STAGING_AWS_ACCESS_KEY_ID }} + STAGING_AWS_SECRET_ACCESS_KEY: ${{ secrets.STAGING_AWS_SECRET_ACCESS_KEY }} + run: | + ENVIRONMENT="${{ github.event.inputs.environment || 'production' }}" + DRY_RUN_FLAG="${{ github.event.inputs.dry_run == 'true' && '--dry-run' || '' }}" + + python scripts/export_all.py -e $ENVIRONMENT -g chunked -p 8 $DRY_RUN_FLAG + + - name: Export summary + if: always() + run: | + echo "### Export Summary" >> $GITHUB_STEP_SUMMARY + echo "- Environment: ${{ github.event.inputs.environment || 'production' }}" >> $GITHUB_STEP_SUMMARY + echo "- Type: Chunked tables" >> $GITHUB_STEP_SUMMARY + echo "- Dry Run: ${{ github.event.inputs.dry_run || 'false' }}" >> $GITHUB_STEP_SUMMARY \ No newline at end of file diff --git a/.github/workflows/export-daily.yml b/.github/workflows/export-daily.yml new file mode 100644 index 00000000..bc5a30bc --- /dev/null +++ b/.github/workflows/export-daily.yml @@ -0,0 +1,72 @@ +name: Export Daily Tables + +on: + schedule: + - cron: '0 4 * * *' # 4 AM UTC + workflow_dispatch: + inputs: + date: + description: 'Date to export (YYYY-MM-DD)' + required: false + type: string + environment: + description: 'Environment to use' + required: true + type: choice + options: + - production + - staging + default: production + dry_run: + description: 'Dry run only' + type: boolean + default: false + +jobs: + export: + runs-on: ubuntu-latest + timeout-minutes: 60 + + steps: + - uses: actions/checkout@v4 + + - name: Set up Python + uses: actions/setup-python@v5 + with: + python-version: '3.11' + cache: 'pip' + + - name: Install dependencies + run: | + pip install -r requirements.txt + + - name: Export daily tables + env: + # Production secrets + CLICKHOUSE_PASSWORD: ${{ secrets.CLICKHOUSE_PASSWORD }} + EXPERIMENTAL_CLICKHOUSE_PASSWORD: ${{ secrets.EXPERIMENTAL_CLICKHOUSE_PASSWORD }} + AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }} + AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }} + # Staging secrets + CLICKHOUSE_STAGING_PASSWORD: ${{ secrets.CLICKHOUSE_STAGING_PASSWORD }} + EXPERIMENTAL_CLICKHOUSE_STAGING_PASSWORD: ${{ secrets.EXPERIMENTAL_CLICKHOUSE_STAGING_PASSWORD }} + STAGING_AWS_ACCESS_KEY_ID: ${{ secrets.STAGING_AWS_ACCESS_KEY_ID }} + STAGING_AWS_SECRET_ACCESS_KEY: ${{ secrets.STAGING_AWS_SECRET_ACCESS_KEY }} + run: | + ENVIRONMENT="${{ github.event.inputs.environment || 'production' }}" + DATE="${{ github.event.inputs.date || '' }}" + DRY_RUN_FLAG="${{ github.event.inputs.dry_run == 'true' && '--dry-run' || '' }}" + + if [ -n "$DATE" ]; then + python scripts/export_all.py -e $ENVIRONMENT -g daily -d $DATE $DRY_RUN_FLAG + else + python scripts/export_all.py -e $ENVIRONMENT -g daily $DRY_RUN_FLAG + fi + + - name: Export summary + if: always() + run: | + echo "### Export Summary" >> $GITHUB_STEP_SUMMARY + echo "- Environment: ${{ github.event.inputs.environment || 'production' }}" >> $GITHUB_STEP_SUMMARY + echo "- Date: ${{ github.event.inputs.date || 'yesterday' }}" >> $GITHUB_STEP_SUMMARY + echo "- Dry Run: ${{ github.event.inputs.dry_run || 'false' }}" >> $GITHUB_STEP_SUMMARY \ No newline at end of file diff --git a/.github/workflows/export-hourly.yml b/.github/workflows/export-hourly.yml new file mode 100644 index 00000000..b56f708c --- /dev/null +++ b/.github/workflows/export-hourly.yml @@ -0,0 +1,72 @@ +name: Export Hourly Tables + +on: + schedule: + - cron: '15 * * * *' # 15 minutes past every hour + workflow_dispatch: + inputs: + date: + description: 'Date to export (YYYY-MM-DD)' + required: false + type: string + environment: + description: 'Environment to use' + required: true + type: choice + options: + - production + - staging + default: production + dry_run: + description: 'Dry run only' + type: boolean + default: false + +jobs: + export: + runs-on: ubuntu-latest + timeout-minutes: 30 + + steps: + - uses: actions/checkout@v4 + + - name: Set up Python + uses: actions/setup-python@v5 + with: + python-version: '3.11' + cache: 'pip' + + - name: Install dependencies + run: | + pip install -r requirements.txt + + - name: Export hourly tables + env: + # Production secrets + CLICKHOUSE_PASSWORD: ${{ secrets.CLICKHOUSE_PASSWORD }} + EXPERIMENTAL_CLICKHOUSE_PASSWORD: ${{ secrets.EXPERIMENTAL_CLICKHOUSE_PASSWORD }} + AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }} + AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }} + # Staging secrets + CLICKHOUSE_STAGING_PASSWORD: ${{ secrets.CLICKHOUSE_STAGING_PASSWORD }} + EXPERIMENTAL_CLICKHOUSE_STAGING_PASSWORD: ${{ secrets.EXPERIMENTAL_CLICKHOUSE_STAGING_PASSWORD }} + STAGING_AWS_ACCESS_KEY_ID: ${{ secrets.STAGING_AWS_ACCESS_KEY_ID }} + STAGING_AWS_SECRET_ACCESS_KEY: ${{ secrets.STAGING_AWS_SECRET_ACCESS_KEY }} + run: | + ENVIRONMENT="${{ github.event.inputs.environment || 'production' }}" + DATE="${{ github.event.inputs.date || '' }}" + DRY_RUN_FLAG="${{ github.event.inputs.dry_run == 'true' && '--dry-run' || '' }}" + + if [ -n "$DATE" ]; then + python scripts/export_all.py -e $ENVIRONMENT -g hourly -d $DATE $DRY_RUN_FLAG + else + python scripts/export_all.py -e $ENVIRONMENT -g hourly $DRY_RUN_FLAG + fi + + - name: Export summary + if: always() + run: | + echo "### Export Summary" >> $GITHUB_STEP_SUMMARY + echo "- Environment: ${{ github.event.inputs.environment || 'production' }}" >> $GITHUB_STEP_SUMMARY + echo "- Date: ${{ github.event.inputs.date || 'last hour' }}" >> $GITHUB_STEP_SUMMARY + echo "- Dry Run: ${{ github.event.inputs.dry_run || 'false' }}" >> $GITHUB_STEP_SUMMARY \ No newline at end of file diff --git a/.github/workflows/export-manual.yml b/.github/workflows/export-manual.yml new file mode 100644 index 00000000..b967f91a --- /dev/null +++ b/.github/workflows/export-manual.yml @@ -0,0 +1,95 @@ +name: Manual Table Export + +on: + workflow_dispatch: + inputs: + environment: + description: 'Environment' + required: true + type: choice + options: + - staging + - production + table: + description: 'Table name' + required: true + type: string + network: + description: 'Network' + required: true + type: choice + options: + - mainnet + - holesky + - sepolia + date: + description: 'Date (YYYY-MM-DD) for daily/hourly tables' + required: false + type: string + force: + description: 'Force re-export even if file exists' + type: boolean + default: false + dry_run: + description: 'Dry run only' + type: boolean + default: false + +jobs: + export: + runs-on: ubuntu-latest + timeout-minutes: 30 + + steps: + - uses: actions/checkout@v4 + + - name: Set up Python + uses: actions/setup-python@v5 + with: + python-version: '3.11' + cache: 'pip' + + - name: Install dependencies + run: | + pip install -r requirements.txt + + - name: Export single table + env: + # Production secrets + CLICKHOUSE_PASSWORD: ${{ secrets.CLICKHOUSE_PASSWORD }} + EXPERIMENTAL_CLICKHOUSE_PASSWORD: ${{ secrets.EXPERIMENTAL_CLICKHOUSE_PASSWORD }} + AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }} + AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }} + # Staging secrets + CLICKHOUSE_STAGING_PASSWORD: ${{ secrets.CLICKHOUSE_STAGING_PASSWORD }} + EXPERIMENTAL_CLICKHOUSE_STAGING_PASSWORD: ${{ secrets.EXPERIMENTAL_CLICKHOUSE_STAGING_PASSWORD }} + STAGING_AWS_ACCESS_KEY_ID: ${{ secrets.STAGING_AWS_ACCESS_KEY_ID }} + STAGING_AWS_SECRET_ACCESS_KEY: ${{ secrets.STAGING_AWS_SECRET_ACCESS_KEY }} + run: | + ARGS="-e ${{ inputs.environment }} -t ${{ inputs.table }} -n ${{ inputs.network }}" + + if [ -n "${{ inputs.date }}" ]; then + ARGS="$ARGS -d ${{ inputs.date }}" + fi + + if [ "${{ inputs.force }}" = "true" ]; then + ARGS="$ARGS --force" + fi + + if [ "${{ inputs.dry_run }}" = "true" ]; then + ARGS="$ARGS --dry-run" + fi + + echo "Running: python scripts/export_table.py $ARGS" + python scripts/export_table.py $ARGS + + - name: Export summary + if: always() + run: | + echo "### Export Summary" >> $GITHUB_STEP_SUMMARY + echo "- Environment: ${{ inputs.environment }}" >> $GITHUB_STEP_SUMMARY + echo "- Table: ${{ inputs.table }}" >> $GITHUB_STEP_SUMMARY + echo "- Network: ${{ inputs.network }}" >> $GITHUB_STEP_SUMMARY + echo "- Date: ${{ inputs.date || 'latest' }}" >> $GITHUB_STEP_SUMMARY + echo "- Force: ${{ inputs.force }}" >> $GITHUB_STEP_SUMMARY + echo "- Dry Run: ${{ inputs.dry_run }}" >> $GITHUB_STEP_SUMMARY \ No newline at end of file diff --git a/.gitignore b/.gitignore index 01871d52..2e994698 100644 --- a/.gitignore +++ b/.gitignore @@ -1,7 +1,98 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ +cover/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +.python-version + +# Environments .env .venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# IDEs +.idea/ +.vscode/ +*.swp +*.swo +*~ .cursorrules + +# Local configuration +config/dev-override.yaml +config/local.yaml + +# Temporary files +*.tmp +*.temp +*.parquet .DS_Store parquet-cache -__pycache__ -.ipynb_checkpoints + +# Local data +data/ +exports/ +temp/ diff --git a/Makefile b/Makefile new file mode 100644 index 00000000..fc54f2dc --- /dev/null +++ b/Makefile @@ -0,0 +1,70 @@ +.PHONY: install test lint format export-local export-all-local export-dev clean help + +# Default target +.DEFAULT_GOAL := help + +# Python interpreter +PYTHON := python3 + +# Install dependencies +install: ## Install dependencies + $(PYTHON) -m pip install -e ".[dev]" + +# Run tests +test: ## Run tests + pytest tests/ -v + +# Lint code +lint: ## Run linting + ruff check src/ scripts/ tests/ + mypy src/ scripts/ --ignore-missing-imports + +# Format code +format: ## Format code + black src/ scripts/ tests/ + ruff check src/ scripts/ tests/ --fix + +# Export single table locally (example) +export-local: ## Export single table locally (dry-run) + $(PYTHON) scripts/export_table.py \ + -e staging \ + -t beacon_api_eth_v1_events_block \ + -n mainnet \ + -d 2024-05-30 \ + --dry-run + +# Test export all for yesterday +export-all-local: ## Export all daily tables locally (dry-run) + $(PYTHON) scripts/export_all.py \ + -e staging \ + -g daily \ + --dry-run + +# Run with local config override +export-dev: ## Export with dev config (TABLE=table_name NETWORK=network) + XATU_CONFIG_PATH=config/dev-override.yaml \ + $(PYTHON) scripts/export_table.py -e staging -t $(TABLE) -n $(NETWORK) + +# Clean up +clean: ## Clean up temporary files + find . -type f -name "*.pyc" -delete + find . -type d -name "__pycache__" -delete + find . -type d -name "*.egg-info" -exec rm -rf {} + + rm -rf .pytest_cache + rm -rf .mypy_cache + rm -rf .ruff_cache + +# Development setup +dev-setup: ## Set up development environment + $(PYTHON) -m venv venv + . venv/bin/activate && $(PYTHON) -m pip install --upgrade pip + . venv/bin/activate && $(PYTHON) -m pip install -e ".[dev]" + @echo "Run 'source venv/bin/activate' to activate the virtual environment" + +# Help +help: ## Show this help message + @echo 'Usage:' + @echo ' make [target]' + @echo '' + @echo 'Targets:' + @awk 'BEGIN {FS = ":.*?## "} /^[a-zA-Z_-]+:.*?## / {printf " %-20s %s\n", $$1, $$2}' $(MAKEFILE_LIST) \ No newline at end of file diff --git a/README_EXPORTER.md b/README_EXPORTER.md new file mode 100644 index 00000000..30b7c8fa --- /dev/null +++ b/README_EXPORTER.md @@ -0,0 +1,240 @@ +# Xatu Data Exporter + +Python-based pipeline for exporting data from ClickHouse to Parquet files with Iceberg metadata generation. + +## Overview + +This exporter replaces the Kubernetes CronJob-based export pipeline with a GitHub Actions CI-based solution. It exports data from ClickHouse to Parquet files stored in R2/S3, with automatic Iceberg metadata generation for efficient querying. + +## Features + +- **Environment-based configuration**: Separate configurations for staging and production +- **Multiple partition strategies**: Daily, hourly, and integer-chunked exports +- **Iceberg metadata generation**: Automatic metadata creation for Apache Iceberg compatibility +- **Column redaction**: Automatic redaction of sensitive columns (IP addresses, geo data) +- **Parallel execution**: Concurrent exports for better performance +- **Dry-run mode**: Test exports without uploading files +- **GitHub Actions integration**: Automated scheduled exports via CI + +## Installation + +```bash +# Install dependencies +pip install -r requirements.txt + +# Or install as editable package with dev dependencies +pip install -e ".[dev]" +``` + +## Configuration + +### Environment Configuration (`config/environments.yaml`) + +Defines ClickHouse and storage endpoints for each environment: + +```yaml +environments: + production: + clickhouse: + default: + host: clickhouse.example.com + port: 8123 + user: exporter + password_env: CLICKHOUSE_PASSWORD + storage: + endpoint: https://r2.cloudflarestorage.com + bucket: xatu-public + access_key_env: AWS_ACCESS_KEY_ID + secret_key_env: AWS_SECRET_ACCESS_KEY + public_url: https://data.ethpandaops.io +``` + +### Table Configuration (`config/tables.yaml`) + +Defines tables to export, their partitioning strategies, and network configurations: + +```yaml +table_groups: + daily: + - name: beacon_api_eth_v1_events_block + database: default + networks: + - name: mainnet + start_date: "2020-12-01" + partition: + column: slot_start_date_time + type: daily + redacted_columns: + meta_client_ip: "CAST('0.0.0.0' AS IPv6)" +``` + +## Usage + +### Export Single Table + +```bash +# Export yesterday's data for a daily table +python scripts/export_table.py -e production -t beacon_api_eth_v1_events_block -n mainnet + +# Export specific date +python scripts/export_table.py -e production -t beacon_api_eth_v1_events_block -n mainnet -d 2024-05-30 + +# Dry run +python scripts/export_table.py -e production -t beacon_api_eth_v1_events_block -n mainnet --dry-run + +# Force re-export +python scripts/export_table.py -e production -t beacon_api_eth_v1_events_block -n mainnet --force +``` + +### Export All Tables + +```bash +# Export all daily tables +python scripts/export_all.py -e production -g daily + +# Export all hourly tables with high parallelism +python scripts/export_all.py -e production -g hourly -p 10 + +# Export all table groups +python scripts/export_all.py -e production -g all +``` + +### Backfill Iceberg Metadata + +For existing Parquet files without Iceberg metadata: + +```bash +# Backfill all tables +python scripts/backfill_iceberg.py -e production + +# Backfill specific table +python scripts/backfill_iceberg.py -e production -t beacon_api_eth_v1_events_block + +# Backfill date range +python scripts/backfill_iceberg.py -e production --start-date 2024-01-01 --end-date 2024-01-31 +``` + +## Development + +### Local Development + +```bash +# Set up development environment +make dev-setup + +# Run local export (dry-run) +make export-local + +# Run with custom config +XATU_CONFIG_PATH=config/dev-override.yaml make export-dev TABLE=my_table NETWORK=mainnet + +# Run tests +make test + +# Lint code +make lint + +# Format code +make format +``` + +### Environment Variables + +Required environment variables for each environment: + +**Production:** +- `CLICKHOUSE_PASSWORD` +- `EXPERIMENTAL_CLICKHOUSE_PASSWORD` +- `AWS_ACCESS_KEY_ID` +- `AWS_SECRET_ACCESS_KEY` + +**Staging:** +- `CLICKHOUSE_STAGING_PASSWORD` +- `EXPERIMENTAL_CLICKHOUSE_STAGING_PASSWORD` +- `STAGING_AWS_ACCESS_KEY_ID` +- `STAGING_AWS_SECRET_ACCESS_KEY` + +## GitHub Actions + +The pipeline runs via GitHub Actions workflows: + +- **Daily exports**: Runs at 4 AM UTC (`export-daily.yml`) +- **Hourly exports**: Runs 15 minutes past each hour (`export-hourly.yml`) +- **Chunked exports**: Runs every 6 hours (`export-chunked.yml`) +- **Manual exports**: Triggered manually via workflow dispatch (`export-manual.yml`) + +## File Structure + +Exported files follow this structure: + +``` +xatu/ +└── {network}/ + └── databases/ + └── {database}/ + └── {table}/ + ├── partition_date={YYYY-MM-DD}/ + │ └── {table}.parquet + ├── partition_hour={HH}/ + │ └── {table}.parquet + └── partition_chunk={chunk_id}/ + └── {table}.parquet +``` + +## Iceberg Metadata + +Iceberg metadata is stored alongside data files: + +``` +xatu/ +└── {network}/ + └── databases/ + └── {database}/ + └── {table}/ + └── metadata/ + ├── version-hint.text + ├── v1.metadata.json + ├── current.metadata.json + └── snap-{id}-manifest-list.json +``` + +## Monitoring + +Export logs are available in: +- GitHub Actions run logs +- Application logs (when run locally) + +Key metrics tracked: +- Export duration +- File sizes +- Row counts +- Failed exports + +## Migration from Kubernetes + +To migrate from the existing Kubernetes CronJob setup: + +1. **Parallel run**: Enable GitHub Actions while keeping Kubernetes running +2. **Validation**: Compare outputs between both systems +3. **Cutover**: Disable Kubernetes CronJobs after validation +4. **Backfill**: Run backfill script to generate Iceberg metadata for historical data + +## Troubleshooting + +Common issues: + +1. **Authentication errors**: Check environment variables are set correctly +2. **Network timeouts**: Increase timeout settings in ClickHouse client +3. **Memory issues**: Reduce parallel workers or export smaller date ranges +4. **Missing files**: Check Iceberg metadata is up to date + +## Contributing + +1. Create a feature branch +2. Make changes and add tests +3. Run `make lint` and `make test` +4. Submit a pull request + +## License + +See LICENSE file in the repository root. \ No newline at end of file diff --git a/ai_plans/convert-export-scripts.md b/ai_plans/convert-export-scripts.md new file mode 100644 index 00000000..725fac30 --- /dev/null +++ b/ai_plans/convert-export-scripts.md @@ -0,0 +1,1006 @@ +# Xatu Iceberg Migration Plan + +## Overview +Migrate Xatu's ClickHouse → Parquet export pipeline from Kubernetes CronJobs to GitHub Actions CI, adding Iceberg metadata generation while maintaining existing file structure. All implemented in Python with environment-based configuration. + +## Phase 1: Project Structure Setup + +### 1.1 Create Python Project Structure +- [ ] Create directory structure: + ``` + xatu-data/ + ├── config/ + │ ├── environments.yaml # Environment configurations + │ ├── tables.yaml # Table definitions + │ └── schedules.yaml # Export schedules + ├── src/ + │ ├── __init__.py + │ ├── exporter.py # Main export logic + │ ├── iceberg_manager.py # Iceberg metadata handling + │ ├── clickhouse.py # ClickHouse client + │ └── storage.py # R2/S3 operations + ├── scripts/ + │ ├── export_table.py # CLI for single table export + │ ├── export_all.py # Export all tables + │ └── backfill.py # Historical data migration + ├── tests/ + │ └── ... + ├── requirements.txt + └── pyproject.toml + ``` + +### 1.2 Environment Configuration +- [ ] Create `config/environments.yaml`: + ```yaml + environments: + staging: + clickhouse: + default: + host: clickhouse.staging.example.com + port: 8123 + user: exporter_staging + password_env: CLICKHOUSE_STAGING_PASSWORD # From env var + experimental: + host: clickhouse.experimental-staging.example.com + port: 8123 + user: exporter_staging + password_env: EXPERIMENTAL_CLICKHOUSE_STAGING_PASSWORD + storage: + endpoint: https://xxx.r2.cloudflarestorage.com + bucket: xatu-staging + access_key_env: STAGING_AWS_ACCESS_KEY_ID + secret_key_env: STAGING_AWS_SECRET_ACCESS_KEY + public_url: https://staging-data.ethpandaops.io + + production: + clickhouse: + default: + host: chendpoint-xatu-clickhouse + port: 8123 + user: exporter + password_env: CLICKHOUSE_PASSWORD + experimental: + host: clickhouse.xatu-experimental.ethpandaops.io + port: 8123 + user: default + password_env: EXPERIMENTAL_CLICKHOUSE_PASSWORD + storage: + endpoint: https://xxx.r2.cloudflarestorage.com + bucket: xatu-public + access_key_env: AWS_ACCESS_KEY_ID + secret_key_env: AWS_SECRET_ACCESS_KEY + public_url: https://data.ethpandaops.io + + # Define which ClickHouse clusters export to which storage + export_mappings: + - source: staging.default + destination: staging + - source: production.experimental + destination: staging + - source: production.default + destination: production + ``` + +### 1.3 Table Configuration +- [ ] Create `config/tables.yaml` (migrate from Helm values): + ```yaml + table_groups: + daily: + - name: beacon_api_eth_v1_events_block + database: default + networks: + - name: mainnet + start_date: "2020-12-01" + - name: holesky + start_date: "2023-12-24" + - name: sepolia + start_date: "2023-12-24" + partition: + column: slot_start_date_time + type: daily + lag_days: 0 + redacted_columns: + meta_client_ip: "CAST('0.0.0.0' AS IPv6)" + meta_client_geo_longitude: "CAST(0 AS Float64)" + # ... etc + + hourly: + - name: beacon_api_eth_v1_events_attestation + # ... similar structure + + chunked: + - name: canonical_execution_block + database: default + networks: + - name: mainnet + start_index: 21010000 + # ... + partition: + column: block_number + type: integer + chunk_size: 1000 + lag_interval: 0 + ``` + +## Phase 2: Core Python Implementation + +### 2.1 Main Exporter Class +- [ ] Create `src/exporter.py`: + ```python + import yaml + from datetime import datetime, timedelta + from pathlib import Path + import logging + from typing import Optional, Dict, Any, List, Tuple + import tempfile + + from .clickhouse import ClickHouseClient + from .storage import R2Storage + from .iceberg_manager import IcebergManager + + class XatuExporter: + def __init__(self, environment: str, dry_run: bool = False): + self.environment = environment + self.dry_run = dry_run + self.config = self._load_config() + self.setup_clients() + self.logger = logging.getLogger(__name__) + + def _load_config(self) -> Dict[str, Any]: + """Load environment and table configurations""" + with open('config/environments.yaml') as f: + env_config = yaml.safe_load(f) + with open('config/tables.yaml') as f: + table_config = yaml.safe_load(f) + return { + 'env': env_config['environments'][self.environment], + 'tables': table_config['table_groups'], + 'mappings': env_config['export_mappings'] + } + + def setup_clients(self): + """Initialize ClickHouse and storage clients""" + self.clickhouse_clients = {} + self.storage_clients = {} + self.iceberg_managers = {} + + # Set up based on export mappings + for mapping in self.config['mappings']: + source_env, source_cluster = mapping['source'].split('.') + if source_env == self.environment: + # Initialize ClickHouse client + ch_config = self.config['env']['clickhouse'][source_cluster] + self.clickhouse_clients[source_cluster] = ClickHouseClient(ch_config) + + # Initialize storage client + storage_config = self.config['env']['storage'] + self.storage_clients[mapping['destination']] = R2Storage(storage_config) + + # Initialize Iceberg manager + self.iceberg_managers[mapping['destination']] = IcebergManager( + storage_config, dry_run=self.dry_run + ) + + def export_table(self, table_name: str, network: str, + date: Optional[datetime] = None, + force: bool = False) -> bool: + """Export a single table/network/date combination""" + table_config = self._get_table_config(table_name) + if not table_config: + self.logger.error(f"Table {table_name} not found in config") + return False + + # Determine which files need to be exported based on Iceberg metadata + files_to_export = self._get_missing_files( + table_name, network, date, table_config, force + ) + + if not files_to_export: + self.logger.info(f"No files to export for {table_name}/{network}") + return True + + # Export each missing file + success = True + for file_info in files_to_export: + try: + self._export_single_file( + table_config, network, file_info + ) + except Exception as e: + self.logger.error(f"Failed to export {file_info}: {e}") + success = False + + # Update Iceberg catalog after all exports + if success and not self.dry_run: + self._update_iceberg_catalog() + + return success + + def _get_missing_files(self, table_name: str, network: str, + date: Optional[datetime], table_config: Dict, + force: bool) -> List[Dict[str, Any]]: + """Determine which files need to be exported based on Iceberg metadata""" + iceberg_manager = self._get_iceberg_manager_for_table(table_name) + + # Get list of existing files from Iceberg metadata + existing_files = iceberg_manager.get_existing_files( + table_name, network + ) if not force else set() + + # Generate list of files that should exist + if table_config['partition']['type'] == 'daily': + expected_files = self._generate_daily_files( + table_name, network, date, table_config + ) + elif table_config['partition']['type'] == 'hourly': + expected_files = self._generate_hourly_files( + table_name, network, date, table_config + ) + else: # chunked + expected_files = self._generate_chunked_files( + table_name, network, table_config + ) + + # Return files that don't exist in Iceberg + return [f for f in expected_files if f['path'] not in existing_files] + + def _export_single_file(self, table_config: Dict, network: str, + file_info: Dict[str, Any]) -> None: + """Export a single file with column redaction""" + ch_client = self._get_clickhouse_client_for_network(network) + storage = self._get_storage_for_network(network) + iceberg = self._get_iceberg_manager_for_network(network) + + # Build query with redacted columns + query = self._build_export_query( + table_config, network, file_info, + table_config.get('redacted_columns', {}) + ) + + # Export to temporary file + with tempfile.NamedTemporaryFile(suffix='.parquet', delete=False) as tmp: + metadata = ch_client.export_to_parquet(query, tmp.name) + + # Upload to storage + remote_path = file_info['path'] + storage.upload_file(tmp.name, remote_path, dry_run=self.dry_run) + + # Register with Iceberg + iceberg.register_file( + table_config['name'], network, remote_path, + file_info['partition_value'], metadata + ) + + # Clean up + Path(tmp.name).unlink() + + def _build_export_query(self, table_config: Dict, network: str, + file_info: Dict, redacted_columns: Dict) -> str: + """Build ClickHouse query with column redaction""" + # Get all columns from table + all_columns = self._get_table_columns( + table_config['database'], table_config['name'] + ) + + # Build SELECT with redacted columns + select_parts = [] + for col in all_columns: + if col in redacted_columns: + select_parts.append(f"{redacted_columns[col]} AS {col}") + else: + select_parts.append(col) + + select_clause = ", ".join(select_parts) + + # Build WHERE clause based on partition type + where_clause = self._build_where_clause( + table_config, network, file_info + ) + + # Determine if FINAL is needed + final_clause = self._get_final_clause( + table_config['database'], table_config['name'] + ) + + return f""" + SELECT {select_clause} + FROM {table_config['database']}.{table_config['name']} {final_clause} + WHERE {where_clause} + ORDER BY {table_config['partition']['column']} + """ + + def export_all_daily(self, date: Optional[datetime] = None): + """Export all daily tables for a given date""" + if date is None: + date = datetime.now() - timedelta(days=1) + + for table in self.config['tables']['daily']: + for network in table['networks']: + self.export_table(table['name'], network['name'], date) + ``` + +### 2.2 ClickHouse Client +- [ ] Create `src/clickhouse.py`: + ```python + import os + import clickhouse_connect + from typing import Dict, Any, Optional + import pandas as pd + + class ClickHouseClient: + def __init__(self, config: Dict[str, Any]): + self.config = config + self.client = self._connect() + + def _connect(self): + password = os.environ.get(self.config['password_env']) + if not password: + raise ValueError(f"Password not found in {self.config['password_env']}") + + return clickhouse_connect.get_client( + host=self.config['host'], + port=self.config['port'], + username=self.config['user'], + password=password + ) + + def export_to_parquet(self, query: str, output_path: str, + compression: str = 'zstd') -> Dict[str, Any]: + """Export query results to Parquet file""" + # Use ClickHouse's native Parquet export + query_with_format = f"{query} FORMAT Parquet SETTINGS output_format_parquet_compression_method='{compression}'" + + with open(output_path, 'wb') as f: + for chunk in self.client.query_iter(query_with_format): + f.write(chunk) + + # Return metadata about the export + return { + 'row_count': self._get_row_count(query), + 'file_size': os.path.getsize(output_path), + 'export_time': datetime.now().isoformat() + } + ``` + +### 2.3 Storage Handler +- [ ] Create `src/storage.py`: + ```python + import os + import boto3 + from typing import Dict, Any, Optional + from pathlib import Path + + class R2Storage: + def __init__(self, config: Dict[str, Any]): + self.config = config + self.client = self._create_client() + self.bucket = config['bucket'] + self.public_url = config['public_url'] + + def _create_client(self): + return boto3.client( + 's3', + endpoint_url=self.config['endpoint'], + aws_access_key_id=os.environ.get(self.config['access_key_env']), + aws_secret_access_key=os.environ.get(self.config['secret_key_env']), + region_name='auto' + ) + + def upload_file(self, local_path: str, remote_key: str, + dry_run: bool = False) -> str: + """Upload file to R2 and return public URL""" + if dry_run: + print(f"[DRY RUN] Would upload {local_path} to {remote_key}") + return f"{self.public_url}/{remote_key}" + + self.client.upload_file(local_path, self.bucket, remote_key) + return f"{self.public_url}/{remote_key}" + + def file_exists(self, remote_key: str) -> bool: + """Check if file exists in R2""" + try: + self.client.head_object(Bucket=self.bucket, Key=remote_key) + return True + except: + return False + + def get_file_content(self, remote_key: str) -> Optional[str]: + """Get file content as string""" + try: + response = self.client.get_object(Bucket=self.bucket, Key=remote_key) + return response['Body'].read().decode('utf-8') + except: + return None + + def list_files(self, prefix: str) -> List[str]: + """List all files under a prefix""" + files = [] + paginator = self.client.get_paginator('list_objects_v2') + + for page in paginator.paginate(Bucket=self.bucket, Prefix=prefix): + if 'Contents' in page: + files.extend([obj['Key'] for obj in page['Contents']]) + + return files + ``` + +### 2.4 Iceberg Manager +- [ ] Create `src/iceberg_manager.py`: + ```python + from pyiceberg.catalog import Catalog + from pyiceberg.table import Table + from pyiceberg.schema import Schema + from pyarrow import parquet as pq + import json + import uuid + from typing import Dict, Any, Optional, Set, List + from datetime import datetime + import logging + + class IcebergManager: + def __init__(self, storage_config: Dict[str, Any], dry_run: bool = False): + self.storage_config = storage_config + self.dry_run = dry_run + self.catalog_url = f"{storage_config['public_url']}/xatu/catalog.json" + self.storage = R2Storage(storage_config) # Reuse storage client + self.logger = logging.getLogger(__name__) + self._metadata_cache = {} # Cache loaded metadata + + def get_existing_files(self, table_name: str, network: str) -> Set[str]: + """Get set of existing file paths from Iceberg metadata""" + try: + metadata = self._load_table_metadata(table_name, network) + if not metadata: + return set() + + # Extract file paths from current snapshot + current_snapshot_id = metadata.get('current-snapshot-id') + if not current_snapshot_id: + return set() + + # Find current snapshot + current_snapshot = None + for snapshot in metadata.get('snapshots', []): + if snapshot['snapshot-id'] == current_snapshot_id: + current_snapshot = snapshot + break + + if not current_snapshot: + return set() + + # Load manifest list + manifest_list = self._load_manifest_list( + current_snapshot['manifest-list'] + ) + + # Extract all data file paths + file_paths = set() + for manifest in manifest_list: + manifest_content = self._load_manifest(manifest['manifest_path']) + for entry in manifest_content.get('entries', []): + if entry['status'] == 'ADDED': + file_paths.add(entry['data_file']['file_path']) + + return file_paths + + except Exception as e: + self.logger.warning(f"Could not load existing files for {table_name}/{network}: {e}") + return set() + + def register_file(self, table_name: str, network: str, file_path: str, + partition_value: Any, file_metadata: Dict[str, Any]) -> None: + """Register a new Parquet file with Iceberg metadata""" + metadata_path = self._get_metadata_path(table_name, network) + + # Load or create table metadata + metadata = self._load_table_metadata(table_name, network) + if not metadata: + metadata = self._create_initial_metadata( + table_name, network, file_path, partition_value + ) + + # Add file to metadata + new_metadata = self._add_file_to_metadata( + metadata, file_path, partition_value, file_metadata + ) + + if not self.dry_run: + # Save new metadata version + self._save_metadata(metadata_path, new_metadata) + + # Update version hint + self._update_version_hint(metadata_path, new_metadata['version']) + + def _load_table_metadata(self, table_name: str, network: str) -> Optional[Dict]: + """Load current table metadata from storage""" + cache_key = f"{network}/{table_name}" + if cache_key in self._metadata_cache: + return self._metadata_cache[cache_key] + + try: + metadata_path = self._get_metadata_path(table_name, network) + version_hint_key = f"{metadata_path}/version-hint.text" + + # Get current version + version_hint = self.storage.get_file_content(version_hint_key) + if not version_hint: + return None + + current_version = int(version_hint.strip()) + + # Load metadata file + metadata_key = f"{metadata_path}/v{current_version}.metadata.json" + metadata_content = self.storage.get_file_content(metadata_key) + + if metadata_content: + metadata = json.loads(metadata_content) + self._metadata_cache[cache_key] = metadata + return metadata + + except Exception as e: + self.logger.debug(f"No existing metadata for {table_name}/{network}: {e}") + + return None + + def _create_initial_metadata(self, table_name: str, network: str, + first_file: str, partition_value: Any) -> Dict: + """Create initial Iceberg metadata for a new table""" + # Read schema from the first Parquet file + # This would need to download the file temporarily + # For now, we'll assume a known schema structure + + table_uuid = str(uuid.uuid4()) + location = f"{self.storage_config['public_url']}/xatu/{network}/databases/default/{table_name}" + + return { + "format-version": 2, + "table-uuid": table_uuid, + "location": location, + "last-sequence-number": 0, + "last-updated-ms": int(datetime.now().timestamp() * 1000), + "last-column-id": 100, # Reserve space for columns + "current-schema-id": 0, + "schemas": [self._get_table_schema(table_name)], + "default-spec-id": 0, + "partition-specs": [self._get_partition_spec(table_name)], + "last-partition-id": 1000, + "default-sort-order-id": 0, + "sort-orders": [{"order-id": 0, "fields": []}], + "properties": { + "created-by": "xatu-exporter", + "created-at": datetime.now().isoformat() + }, + "snapshots": [], + "snapshot-log": [], + "metadata-log": [], + "version": 1 + } + + def _add_file_to_metadata(self, metadata: Dict, file_path: str, + partition_value: Any, file_metadata: Dict) -> Dict: + """Add a new file to existing metadata, creating a new snapshot""" + # Clone metadata for new version + new_metadata = json.loads(json.dumps(metadata)) + + # Update version and timestamp + new_metadata['version'] = metadata.get('version', 1) + 1 + new_metadata['last-updated-ms'] = int(datetime.now().timestamp() * 1000) + new_metadata['last-sequence-number'] += 1 + + # Create new snapshot + snapshot_id = new_metadata['last-sequence-number'] + snapshot = { + "sequence-number": snapshot_id, + "snapshot-id": snapshot_id, + "timestamp-ms": new_metadata['last-updated-ms'], + "summary": { + "operation": "append", + "added-data-files": "1", + "added-records": str(file_metadata.get('row_count', 0)), + "added-files-size": str(file_metadata.get('file_size', 0)), + "total-data-files": str(self._count_total_files(metadata) + 1), + "total-records": str(self._count_total_records(metadata) + file_metadata.get('row_count', 0)), + "total-files-size": str(self._count_total_size(metadata) + file_metadata.get('file_size', 0)) + }, + "manifest-list": f"{self._get_metadata_path_from_metadata(metadata)}/snap-{snapshot_id}-manifest-list.avro" + } + + # Add snapshot + new_metadata['snapshots'].append(snapshot) + new_metadata['current-snapshot-id'] = snapshot_id + + # Update snapshot log + new_metadata['snapshot-log'].append({ + "timestamp-ms": snapshot['timestamp-ms'], + "snapshot-id": snapshot_id + }) + + # Create manifest entry for the new file + # In practice, this would be written as Avro files + # For now, we'll store as JSON for simplicity + self._create_manifest_for_file( + metadata, snapshot, file_path, partition_value, file_metadata + ) + + return new_metadata + + def _get_metadata_path(self, table_name: str, network: str) -> str: + """Get the metadata path for a table""" + return f"xatu/{network}/databases/default/{table_name}/metadata" + + def _get_table_schema(self, table_name: str) -> Dict: + """Get Iceberg schema for a table (would be generated from actual Parquet schema)""" + # This would be table-specific + # For now, return a generic schema structure + return { + "type": "struct", + "schema-id": 0, + "fields": [ + # This would be populated from actual table schema + ] + } + + def _get_partition_spec(self, table_name: str) -> Dict: + """Get partition spec for a table""" + # This would be loaded from table configuration + return { + "spec-id": 0, + "fields": [ + # Populated based on table config + ] + } + ``` + +## Phase 3: CLI Scripts + +### 3.1 Single Table Export Script +- [ ] Create `scripts/export_table.py`: + ```python + #!/usr/bin/env python3 + import click + import logging + from datetime import datetime + from src.exporter import XatuExporter + + @click.command() + @click.option('--environment', '-e', required=True, + type=click.Choice(['staging', 'production']), + help='Environment to export from/to') + @click.option('--table', '-t', required=True, help='Table name to export') + @click.option('--network', '-n', required=True, help='Network to export') + @click.option('--date', '-d', type=click.DateTime(['%Y-%m-%d']), + help='Date to export (for daily tables)') + @click.option('--force', '-f', is_flag=True, + help='Force export even if file exists') + @click.option('--dry-run', is_flag=True, + help='Show what would be done without doing it') + def export_table(environment, table, network, date, force, dry_run): + """Export a single table/network combination""" + logging.basicConfig(level=logging.INFO) + + exporter = XatuExporter(environment, dry_run=dry_run) + success = exporter.export_table(table, network, date, force) + + if success: + click.echo(f"✓ Successfully exported {table}/{network}") + else: + click.echo(f"✗ Failed to export {table}/{network}", err=True) + raise click.Abort() + + if __name__ == '__main__': + export_table() + ``` + +### 3.2 Batch Export Script +- [ ] Create `scripts/export_all.py`: + ```python + #!/usr/bin/env python3 + import click + from datetime import datetime, timedelta + from concurrent.futures import ThreadPoolExecutor + from src.exporter import XatuExporter + + @click.command() + @click.option('--environment', '-e', required=True, + type=click.Choice(['staging', 'production'])) + @click.option('--table-group', '-g', + type=click.Choice(['daily', 'hourly', 'chunked', 'all']), + default='all') + @click.option('--date', '-d', type=click.DateTime(['%Y-%m-%d'])) + @click.option('--parallel', '-p', default=4, help='Number of parallel exports') + @click.option('--dry-run', is_flag=True) + def export_all(environment, table_group, date, parallel, dry_run): + """Export all tables for a given date/group""" + exporter = XatuExporter(environment, dry_run=dry_run) + + if table_group == 'all': + groups = ['daily', 'hourly', 'chunked'] + else: + groups = [table_group] + + with ThreadPoolExecutor(max_workers=parallel) as executor: + # Submit export jobs + futures = [] + for group in groups: + if group == 'daily': + futures.extend(exporter.submit_daily_exports(executor, date)) + # ... handle other groups + + # Wait for completion and report results + # ... + ``` + +## Phase 4: GitHub Actions Configuration + +### 4.1 Workflow for Daily Tables +- [ ] Create `.github/workflows/export-daily.yml`: + ```yaml + name: Export Daily Tables + + on: + schedule: + - cron: '0 4 * * *' # 4 AM UTC + workflow_dispatch: + inputs: + date: + description: 'Date to export (YYYY-MM-DD)' + required: false + environment: + description: 'Environment to use' + required: true + type: choice + options: + - production + - staging + default: production + + jobs: + export: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + + - name: Set up Python + uses: actions/setup-python@v4 + with: + python-version: '3.11' + + - name: Install dependencies + run: | + pip install -r requirements.txt + + - name: Export daily tables + env: + # Production secrets + CLICKHOUSE_PASSWORD: ${{ secrets.CLICKHOUSE_PASSWORD }} + EXPERIMENTAL_CLICKHOUSE_PASSWORD: ${{ secrets.EXPERIMENTAL_CLICKHOUSE_PASSWORD }} + AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }} + AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }} + # Staging secrets + CLICKHOUSE_STAGING_PASSWORD: ${{ secrets.CLICKHOUSE_STAGING_PASSWORD }} + EXPERIMENTAL_CLICKHOUSE_STAGING_PASSWORD: ${{ secrets.EXPERIMENTAL_CLICKHOUSE_STAGING_PASSWORD }} + STAGING_AWS_ACCESS_KEY_ID: ${{ secrets.STAGING_AWS_ACCESS_KEY_ID }} + STAGING_AWS_SECRET_ACCESS_KEY: ${{ secrets.STAGING_AWS_SECRET_ACCESS_KEY }} + run: | + ENVIRONMENT="${{ github.event.inputs.environment || 'production' }}" + DATE="${{ github.event.inputs.date || '' }}" + + if [ -n "$DATE" ]; then + python scripts/export_all.py -e $ENVIRONMENT -g daily -d $DATE + else + python scripts/export_all.py -e $ENVIRONMENT -g daily + fi + ``` + +### 4.2 Manual Trigger Workflow +- [ ] Create `.github/workflows/export-manual.yml`: + ```yaml + name: Manual Table Export + + on: + workflow_dispatch: + inputs: + environment: + description: 'Environment' + required: true + type: choice + options: + - staging + - production + table: + description: 'Table name' + required: true + network: + description: 'Network' + required: true + date: + description: 'Date (YYYY-MM-DD) for daily/hourly tables' + required: false + dry_run: + description: 'Dry run only' + type: boolean + default: false + + jobs: + export: + runs-on: ubuntu-latest + steps: + # ... similar setup steps + + - name: Export single table + env: + # ... environment variables + run: | + ARGS="-e ${{ inputs.environment }} -t ${{ inputs.table }} -n ${{ inputs.network }}" + + if [ -n "${{ inputs.date }}" ]; then + ARGS="$ARGS -d ${{ inputs.date }}" + fi + + if [ "${{ inputs.dry_run }}" = "true" ]; then + ARGS="$ARGS --dry-run" + fi + + python scripts/export_table.py $ARGS + ``` + +## Phase 5: Local Development & Testing + +### 5.1 Local Development Setup +- [ ] Create `Makefile`: + ```makefile + .PHONY: install test export-local + + install: + pip install -e ".[dev]" + + test: + pytest tests/ + + # Export single table locally + export-local: + python scripts/export_table.py \ + -e staging \ + -t beacon_api_eth_v1_events_block \ + -n mainnet \ + -d 2024-05-30 \ + --dry-run + + # Test export all for yesterday + export-all-local: + python scripts/export_all.py \ + -e staging \ + -g daily \ + --dry-run + + # Run with local config override + export-dev: + XATU_CONFIG_PATH=config/dev-override.yaml \ + python scripts/export_table.py -e staging -t $(TABLE) -n $(NETWORK) + ``` + +### 5.2 Development Configuration Override +- [ ] Create `config/dev-override.yaml` (git-ignored): + ```yaml + # Local development overrides + environments: + staging: + clickhouse: + default: + host: localhost + port: 9000 + user: default + password_env: LOCAL_CLICKHOUSE_PASSWORD + storage: + endpoint: http://localhost:9001 # MinIO + bucket: xatu-dev + access_key_env: LOCAL_MINIO_ACCESS_KEY + secret_key_env: LOCAL_MINIO_SECRET_KEY + public_url: http://localhost:9001/xatu-dev + ``` + +### 5.3 Testing Framework +- [ ] Create `tests/test_exporter.py`: + ```python + import pytest + from unittest.mock import Mock, patch + from src.exporter import XatuExporter + + @pytest.fixture + def mock_environment(): + with patch.dict('os.environ', { + 'CLICKHOUSE_STAGING_PASSWORD': 'test123', + 'STAGING_AWS_ACCESS_KEY_ID': 'test-key', + 'STAGING_AWS_SECRET_ACCESS_KEY': 'test-secret' + }): + yield + + def test_export_table_dry_run(mock_environment): + exporter = XatuExporter('staging', dry_run=True) + + # Test that dry run doesn't actually upload + with patch.object(exporter.storage_clients['staging'], 'upload_file') as mock_upload: + exporter.export_table('test_table', 'mainnet', datetime.now()) + mock_upload.assert_not_called() + ``` + +## Phase 6: Monitoring & Logging + +### 6.1 Structured Logging +- [ ] Add logging configuration: + ```python + import structlog + + def setup_logging(): + structlog.configure( + processors=[ + structlog.stdlib.filter_by_level, + structlog.stdlib.add_logger_name, + structlog.stdlib.add_log_level, + structlog.stdlib.PositionalArgumentsFormatter(), + structlog.processors.TimeStamper(fmt="iso"), + structlog.processors.StackInfoRenderer(), + structlog.processors.format_exc_info, + structlog.processors.UnicodeDecoder(), + structlog.processors.JSONRenderer() + ], + context_class=dict, + logger_factory=structlog.stdlib.LoggerFactory(), + cache_logger_on_first_use=True, + ) + ``` + +### 6.2 Export Metrics +- [ ] Track and report: + - Export duration + - File sizes + - Row counts + - Failed exports + - Iceberg metadata generation time + +## Phase 7: Migration Process + +### 7.1 Parallel Run Phase +- [ ] Run GitHub Actions in staging environment +- [ ] Compare outputs with Kubernetes exports +- [ ] Monitor for discrepancies + +### 7.2 Production Rollout +- [ ] Enable GitHub Actions for production +- [ ] Run in parallel with Kubernetes for 1 week +- [ ] Disable Kubernetes CronJobs +- [ ] Monitor and validate + +### 7.3 Historical Backfill +- [ ] Create `scripts/backfill_iceberg.py`: + ```python + @click.command() + @click.option('--table', '-t', help='Specific table to backfill') + @click.option('--start-date', type=click.DateTime(['%Y-%m-%d'])) + @click.option('--end-date', type=click.DateTime(['%Y-%m-%d'])) + @click.option('--parallel', '-p', default=10) + def backfill_iceberg(table, start_date, end_date, parallel): + """Generate Iceberg metadata for existing Parquet files""" + # List existing files in R2 + # Generate Iceberg metadata + # Update catalog + ``` + +## Success Criteria + +- [ ] All exports can run locally with staging configuration +- [ ] GitHub Actions successfully export to correct environments +- [ ] Iceberg metadata is queryable via PyIceberg/DuckDB +- [ ] Export times are comparable to Kubernetes implementation +- [ ] No data loss or corruption during migration +- [ ] Clear logging and error reporting + +## Benefits of This Approach + +1. **Configuration as Code**: All environment configs in YAML +2. **Local Testing**: Can test entire pipeline locally +3. **Environment Flexibility**: Easy to add new environments +4. **Pure Python**: Easier to maintain and debug than bash scripts +5. **Dry Run Support**: Test changes without affecting production +6. **Parallel Execution**: Built-in support for concurrent exports +7. **Structured Logging**: Better observability \ No newline at end of file diff --git a/analysis/mainnet/blob-bump-prediction/prediction.ipynb b/analysis/mainnet/blob-bump-prediction/prediction.ipynb index db8156a8..91d87917 100644 --- a/analysis/mainnet/blob-bump-prediction/prediction.ipynb +++ b/analysis/mainnet/blob-bump-prediction/prediction.ipynb @@ -23,19 +23,9 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "start_date: 2024-10-04T22:00:00Z\n", - "end_date: 2024-11-25T02:00:00Z\n", - "hours: 1228.0\n" - ] - } - ], + "outputs": [], "source": [ "import dotenv\n", "import os\n", @@ -107,30 +97,9 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " slot\n", - "0 10104599\n", - "1 10104600\n", - "2 10104601\n", - "3 10104602\n", - "4 10104603\n", - "... ...\n", - "337584 10472993\n", - "337585 10472995\n", - "337586 10472996\n", - "337587 10472997\n", - "337588 10472998\n", - "\n", - "[337589 rows x 1 columns]\n" - ] - } - ], + "outputs": [], "source": [ "# Query for MEV relay delivered slots\n", "block_query = text(\"\"\"\n", @@ -173,22 +142,9 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Getting block sizes...\n", - "Getting proposer entities...\n", - "Getting blob sidecar data...\n", - "Getting first seen in p2p data...\n", - "Getting first seen attestation for block in p2p data...\n", - "Getting arrival times...\n" - ] - } - ], + "outputs": [], "source": [ "# Query to get block sizes for all slots\n", "print(\"Getting block sizes...\")\n", @@ -432,7 +388,7 @@ "# # Calculate median delay and 95th/5th percentiles per bucket\n", "# bucket_stats = pd.DataFrame({\n", "# 'median': processing_delay.groupby('slot_bucket')['delay'].median(),\n", - "# 'p95': processing_delay.groupby('slot_bucket')['delay'].apply(lambda x: x.quantile(0.95)),\n", + "# 'p98': processing_delay.groupby('slot_bucket')['delay'].apply(lambda x: x.quantile(0.95)),\n", "# 'p5': processing_delay.groupby('slot_bucket')['delay'].apply(lambda x: x.quantile(0.05))\n", "# })\n", "\n", @@ -442,7 +398,7 @@ "# # Plot median and percentiles for each bucket\n", "# plt.bar(range(len(bucket_ranges)), bucket_stats['median'], \n", "# alpha=0.7, color='#3498db', label='Median delay')\n", - "# plt.plot(range(len(bucket_ranges)), bucket_stats['p95'], \n", + "# plt.plot(range(len(bucket_ranges)), bucket_stats['p98'], \n", "# color='#e74c3c', label='95th percentile', linewidth=2)\n", "# plt.plot(range(len(bucket_ranges)), bucket_stats['p5'],\n", "# color='#2ecc71', label='5th percentile', linewidth=2)\n", @@ -468,17 +424,9 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Getting head arrival times...\n" - ] - } - ], + "outputs": [], "source": [ "# Get head arrival times per client\n", "print(\"Getting head arrival times...\")\n", @@ -501,17 +449,9 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Getting block arrival times...\n" - ] - } - ], + "outputs": [], "source": [ "# Get block arrival times per client\n", "print(\"Getting block arrival times...\")\n", @@ -534,17 +474,9 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Getting blob arrival times...\n" - ] - } - ], + "outputs": [], "source": [ "# Get blob arrival times per client\n", "print(\"Getting blob arrival times...\")\n", @@ -567,56 +499,9 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " slot head_arrival_time \\\n", - "0 10236340 3005.0 \n", - "1 10427608 2641.0 \n", - "2 10412216 4266.0 \n", - "3 10407717 2245.0 \n", - "4 10323359 2809.0 \n", - "... ... ... \n", - "8739753 10278462 NaN \n", - "8739754 10304762 NaN \n", - "8739755 10281650 NaN \n", - "8739756 10460650 NaN \n", - "8739757 10370934 NaN \n", - "\n", - " meta_client_name \\\n", - "0 pub-asn-city/impulsecanopener30/hashed-776f28d8 \n", - "1 pub-asn-city/simplefrog47/hashed-aee32110 \n", - "2 pub-asn-city/impulsecanopener30/hashed-776f28d8 \n", - "3 ethpandaops/mainnet/sigma-mainnet-nimbus-besu-001 \n", - "4 ethpandaops/mainnet/xatu-sentry-syd1-mainnet-p... \n", - "... ... \n", - "8739753 ethpandaops/mainnet/sigma-mainnet-teku-geth-001 \n", - "8739754 ethpandaops/mainnet/sigma-mainnet-teku-geth-001 \n", - "8739755 ethpandaops/mainnet/sigma-mainnet-teku-geth-001 \n", - "8739756 ethpandaops/mainnet/sigma-mainnet-teku-geth-001 \n", - "8739757 ethpandaops/mainnet/utility-mainnet-teku-erigo... \n", - "\n", - " block_arrival_time last_blob_arrival_time arrival_time \n", - "0 2988.0 NaN 3005.0 \n", - "1 2626.0 NaN 2641.0 \n", - "2 4246.0 3244.0 4266.0 \n", - "3 2245.0 NaN 2245.0 \n", - "4 2809.0 1873.0 2809.0 \n", - "... ... ... ... \n", - "8739753 NaN 2528.0 2528.0 \n", - "8739754 NaN 2295.0 2295.0 \n", - "8739755 NaN 2847.0 2847.0 \n", - "8739756 NaN 2783.0 2783.0 \n", - "8739757 NaN 2295.0 2295.0 \n", - "\n", - "[8739758 rows x 6 columns]\n" - ] - } - ], + "outputs": [], "source": [ "# Merge all arrival times into one dataframe\n", "raw_arrival_data = pd.merge(head_arrival_times, block_arrival_times, on=['slot', 'meta_client_name'], how='outer')\n", @@ -635,71 +520,9 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Query done.. merging everything together...\n", - "Found arrival times for 8621865 slots\n", - " slot head_arrival_time \\\n", - "0 10236340 3005.0 \n", - "1 10427608 2641.0 \n", - "2 10412216 4266.0 \n", - "3 10407717 2245.0 \n", - "4 10323359 2809.0 \n", - "... ... ... \n", - "8739753 10278462 NaN \n", - "8739754 10304762 NaN \n", - "8739755 10281650 NaN \n", - "8739756 10460650 NaN \n", - "8739757 10370934 NaN \n", - "\n", - " meta_client_name \\\n", - "0 pub-asn-city/impulsecanopener30/hashed-776f28d8 \n", - "1 pub-asn-city/simplefrog47/hashed-aee32110 \n", - "2 pub-asn-city/impulsecanopener30/hashed-776f28d8 \n", - "3 ethpandaops/mainnet/sigma-mainnet-nimbus-besu-001 \n", - "4 ethpandaops/mainnet/xatu-sentry-syd1-mainnet-p... \n", - "... ... \n", - "8739753 ethpandaops/mainnet/sigma-mainnet-teku-geth-001 \n", - "8739754 ethpandaops/mainnet/sigma-mainnet-teku-geth-001 \n", - "8739755 ethpandaops/mainnet/sigma-mainnet-teku-geth-001 \n", - "8739756 ethpandaops/mainnet/sigma-mainnet-teku-geth-001 \n", - "8739757 ethpandaops/mainnet/utility-mainnet-teku-erigo... \n", - "\n", - " block_arrival_time last_blob_arrival_time arrival_time country \\\n", - "0 2988.0 NaN 3005.0 Bulgaria \n", - "1 2626.0 NaN 2641.0 Australia \n", - "2 4246.0 3244.0 4266.0 Bulgaria \n", - "3 2245.0 NaN 2245.0 Australia \n", - "4 2809.0 1873.0 2809.0 Australia \n", - "... ... ... ... ... \n", - "8739753 NaN 2528.0 2528.0 Australia \n", - "8739754 NaN 2295.0 2295.0 Australia \n", - "8739755 NaN 2847.0 2847.0 Australia \n", - "8739756 NaN 2783.0 2783.0 Australia \n", - "8739757 NaN 2295.0 2295.0 Finland \n", - "\n", - " observed_by_group \n", - "0 home users \n", - "1 home users \n", - "2 home users \n", - "3 ethpandaops \n", - "4 ethpandaops \n", - "... ... \n", - "8739753 ethpandaops \n", - "8739754 ethpandaops \n", - "8739755 ethpandaops \n", - "8739756 ethpandaops \n", - "8739757 ethpandaops \n", - "\n", - "[8621865 rows x 8 columns]\n" - ] - } - ], + "outputs": [], "source": [ "# Add country and group info\n", "query = text(\"\"\"\n", @@ -744,19 +567,13 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[{'label': 'Historical p99 block size', 'value': 0.101185}, {'label': 'Worst case with EIP7623', 'value': 0.72}]\n" - ] - } - ], + "outputs": [], "source": [ "worst_case_block_w_eip_7623=0.72\n", + "worst_case_block_w_eip_7623_36m=0.864\n", + "worst_case_block_w_eip_7623_60m=1.43\n", "\n", "# Calculate p99 block size from data\n", "base_size = combined_data['block_total_bytes_compressed'].quantile(0.99) / 1_000_000 # Convert to MB\n", @@ -767,8 +584,16 @@ " 'value': base_size\n", " },\n", " {\n", - " 'label': 'Worst case with EIP7623',\n", + " 'label': 'Worst case with EIP7623 (30M Gas Limit)',\n", " 'value': worst_case_block_w_eip_7623\n", + " },\n", + " {\n", + " 'label': 'Worst case with EIP7623 (36M Gas Limit)',\n", + " 'value': worst_case_block_w_eip_7623_36m\n", + " },\n", + " {\n", + " 'label': 'Worst case with EIP7623 (60M Gas Limit)',\n", + " 'value': worst_case_block_w_eip_7623_60m\n", " }\n", "]\n", "\n", @@ -778,7 +603,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -789,20 +614,9 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Slots: 366384\n", - "Arrival events: 75945392\n", - "Countries: 9\n", - "Countries: Australia, Bulgaria, Czechia, Germany, Italy, Spain, The Netherlands, United Kingdom, United States\n" - ] - } - ], + "outputs": [], "source": [ "all_data = (arrival_data\n", " .merge(combined_data[['slot', 'block_total_bytes_compressed', 'total_blob_size', 'entity']], on='slot'))\n", @@ -817,184 +631,9 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Creating plot for MEV: True Historical p99 block size with solo_stakers and observed by home users\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Creating plot for MEV: False Historical p99 block size with solo_stakers and observed by home users\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Creating plot for MEV: None Historical p99 block size with solo_stakers and observed by home users\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Creating plot for MEV: True Historical p99 block size with kiln and observed by home users\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Creating plot for MEV: False Historical p99 block size with kiln and observed by home users\n", - "Skipping kiln observed by home users (MEV: False) due to low block count: 35\n", - "Creating plot for MEV: None Historical p99 block size with kiln and observed by home users\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Creating plot for MEV: True Worst case with EIP7623 with solo_stakers and observed by home users\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABI4AAAMkCAYAAADeS2ufAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOyddXgU19uG71mJuzsJETQEd6dIi5XSYqVFC3X7Vai7C3WhQqHQYgUKFC0OwV0SIsSIu27WZr4/liwJCRAotP3oua+LdnfmzDlnZmczs8+87/NKiqIoCAQCgUAgEAgEAoFAIBAIBBeh+qcnIBAIBAKBQCAQCAQCgUAg+HcihCOBQCAQCAQCgUAgEAgEAkGDCOFIIBAIBAKBQCAQCAQCgUDQIEI4EggEAoFAIBAIBAKBQCAQNIgQjgQCgUAgEAgEAoFAIBAIBA0ihCOBQCAQCAQCgUAgEAgEAkGDCOFIIBAIBAKBQCAQCAQCgUDQIEI4EggEAoFAIBAIBAKBQCAQNIgQjgQCgUAgEAgEAoFAIBAIBA2i+acnIBAIBAKBQCAQCAQCgUBwvSgpKWHn7lg2bd/JsbgEUtMz0FXrUalU+Hh5EtU0lB6dOjCwb2+aN2+GRiOkkcshKYqi/NOTEAgEAoFAIBAIBAKBQPDX+WnhrwwfMghPT89/eip/O5WVlSxdvpIff11KYmoaZrPMpSQPSQJnJyf6devMQ9Mn0zYmBkmS/uYZ/3MUFhayZsMmJk0Yd8W2IlVNIBAIBAKBQCAQCASCm4Tc3FzGTn+QTZu3YDKZ/unp/G0kJiUx9ZEneO6dD4lLOovJZL6kaASgKFBWXsGqTVsZP+NRPvnyawoLCy+7zc2AyWRi0+YtjJv+ILm5uY3aRkQcCQQCgUAgEAiuCyaT6aYI979Z9kMgEPw3SU/PYPjEqZSUlTH8lr7cP2USLVs0R6W6eeNGDh85ykOzXiIpJe2atpckCUmSCA0OpHuHtvTs2pn2bWMIDAjAxsbmOs/2n0GWZeLiz/D1j/NY/edW3F1dWb3gR4KDg6647c175ggEAoFA8C/np59+st6oXPxPo9Hg5OREeHg4U6ZMITk5ud7227Ztu3CjExr6t8//Ro1fWVmJi4uLte/27dtft74vR9++fa1j/vTTT3/LmDWEhoZax962bdsV27/66qsNnjdqtRpnZ2eioqKYNGkS+/fvb3D72ude3759//L8q6ureeONN3jssceuetva+zJ58uQbNsfGkJCQwLBhw9i9e3ed5ZMnT7bO5dVXX/1b5iIQCATXSnBwEHcNG4Kuqpolq9czevJMHnn6OXbH7kGn0/3T07vuJCQm8tCsF0lKSb/mPhRFQZZlzqZlsHDFGh6c9Qq3jr2XsVNm8NlX33A6Lv7/bfSWTqdjd+weHnn6Oe6YNIMlq9dRVaVjzPBbCQoKbFQfQjgSCAQCgeBfiNlsprKykrNnz/LTTz/RsWNHjh8//k9P629hyZIllJeXW98fOXKEAwcO/IMz+v+DLMtUVFSQmJjI/Pnz6dq1K2+//fYNHXPXrl20aNGCl19+mcrKyhs61o3k5ZdfpnXr1vzxxx83fZqCQCC4uZEkiYlj78TPxwtFUSgqLWXpmvWMv/8xRt87jS+//Y74M2cwGAz/9FT/MhUVFbz09gfnRaPr87e7RkQqLC5h98EjvP35t0x59Cm+mPM9FRUV12WMG43RaORMQgJfzvme0fdOY/z9j7FkzXqKSktRFIUAXx/uvmt0oz2dRAyuQCAQCAT/AlxcXHjggQcAyw2LyWQiLy+PlStXUlFRQUlJCQ8++CC7du36h2d64/nhhx/qLZszZw6dOnW6oeNOmDCBrl27AhAdHX1Dx7qeBAcHM2HCBBRFwWAwkJuby8aNG60+DS+88AIhISFMnDjRuk10dDTPPvssAE2bNv1L4//555+kpqZe8/Y9e/a0zqVDhw5/aS5/hfnz52M0GhtcN3ToUPz8/ADLfAUCgeDfTpOQEEYPHcwXcxcAlnsLXXU1B4+f4sCxk3w8Zy5tmkfRr0dXevfoTmREOI6Ojv/wrK+epctXsmNfAw+XJAkXJ0e8PNxJzchEluWr6leSJBwd7OnTtRO33zqIDu3a4ePjja2t7XWa+fWnsrKSpOSz7Ngdy5bdezkRn0BpWTmSJNV7IDL6tkGEhAQ3um8hHAkEAoFA8C/A3d2dd999t97yzZs3c8sttwCwe/duysrKcHFx+bun97dx5swZa5qQu7s7xcXFACxatIiPP/4YZ2fnGzb2jBkzbljfN5KmTZvWO3cqKiq444472LRpEwD/+9//uPPOO7GzswMsAs0/KdLU5pZbbrGe4/9W7rrrLu66665/ehoCgUDQaCRJYsJdd7Bo5RoKikusy2sEhLLyCnYdOMyuA4dxnPMTYcEBdG4XQ8+unYlp3Qo/P79/vbdPcXExP/yyFJPJbF0mSRL29nbcedsgpkwYh4eHO/c88Bgn4hPqiCeSJKHVaPDz8SIzJw+z2Vyn77Ytm/PyU4/RtUvnf63nXc3DomMnTrFr3372HznG2fRMKquq6rS7WDTy9nBnwpjGRxuBSFUTCAQCgeBfTffu3eu8v5onZiaTie+++47evXvj7e2Nvb09UVFRPP7442RmZl5yu+XLlzNokKWMr729PZGRkUyaNInTp083atzc3Nw6nj39+/dvdDj8999/b3390EMP0blzZ8AihPzyyy8NblPbC2fWrFn8+OOPBAcHY2dnR+vWramsrKzjUbNmzRoef/xxXF1dcXZ25u677wYa9jhq3769ddncuXPrjb1kyRLr+toRUXq9nnfeeYd27drh5OSEWq3G3d2dHj168PPPPzfqWPwVnJycmDdvHlqtFoC8vDx+++036/rL+QedPXuW++67j4iICOzt7bGxsSEoKIg777yTffv21WkbGhrKa6+9Zn0/b968Ol5FjflsLuVxdDHZ2dnce++9eHh44OTkRK9evVizZk29dpfzqmpov2u8utLSLhiq9uvXr47f1JU8jtLS0nj66adp0aIFjo6OuLm50atXL+bMmdOgJ0bt70d1dTUrV66ke/fuODo64uXlxcSJE0lPv3avDoFAIAAIb9qUgX2uHCVZWVXFyTNJzF28nPv+9zyD75rInZOm8+rb77J2w0bS09PR6/V/w4yvju27dpPcwN/KMcOG8P4br9K6dSsCAgL47J3X6d2lI3a2tkgqFVqNhjYtm/P526/wwSvPo1Gr62zfq0sHfvpyNj17dP9XiUZ6vZ709HTWbdzEa++8x+h7pjHozruZ/r/n+HHRb5yIT6wnGjXEwN49aBoWdlVj/3uOgkAgEAgEgnqsX7/e+jomJgY3N7dGbVdYWMjIkSPrmfwmJiby6aefMm/ePJYvX06/fv3qrJ85cyZz5sypsywpKYmkpCSWLFnC+vXr6dOnzyXH1el0jBgxwvojvG3btqxcubJRTy2NRiPz58+3vp88eTIhISFWg+c5c+Ywc+bMy/axbt063nvvPet7Nze3eqH3L774IseOHbO+D7vMzdO0adN4+OGHAfjll1+YMmVKnfW1RaCpU6cCFnFv/PjxrFixok7bkpISYmNjiY2NJSkpqY7gciPw9/enR48eVvFj+/btVpHsUsTFxdG9e3dKSkrqLM/MzOS3335j9erVrFmzhoEDB171fBrz2VyKnJwcunTpQkZGhnXZrl272LVrF7Nnz+bxxx+/6vlcL9avX8+4ceMoLS2ts7xmfgsXLmTVqlW4uro2uP17771XR4yqqqpi4cKF7Nixg5MnT97UEYYCgeDGolKpePi+KRw5GUdiSmq9qJqLURQFs9lMQXEJhYePsffwMb75eTFuzs6EBPnTpkUzOsRE06pFC5qEBFsfjPwTKIrCxq3bMZvrP1BzsLevM69WLVvw87dfcPT4cdIzMvHz9aF92xicnZ35bu4868MtSZII8vfl/VdfJCAg4G/bl4Ywm81UVFSQlp7Bqbg4jpw4xbHTZ0jLyKSkvNz6IPFqPPnUKjVR4aE8PGPqVVfYE8KRQCAQCAT/AoqLi5k1a5b1vclkIi0tjd9//x0AGxsbPvvss0b3N2XKFKtopNVqGT58OJ6enqxfv56MjAxKSkoYNWoUhw8ftnrcfP/993VEo4EDB9K8eXO2bdvGiRMnqK6uZuzYsaSlpTWY468oSp1KXmFhYaxbt67RP3zXrFlDXl4eAL169SI8PBwfHx+eeOIJKisrOXz4MIcOHbpsitXx48dxdXVl/PjxpKenM3To0Hptjh07RmRkJIMHDyY2NpZx48Zdsr+7776bp556iurqarZs2UJ2djb+/v4AFBQUsGHDBgDs7OwYP348AH/88YdVNHJ2dmbMmDE4OjqyY8cOjh49CsAnn3xijbS5kbRs2dIqHDUmYuyNN96wikbNmzenf//+aDQaNm3aRFxcHAaDgZkzZ5KUlIRKpeKBBx5g9erV1nOtdevWDB06tMHPqDGfzaU4c+YMYPEaCgoKYu3atVYR6emnn2bIkCE0b9680f3VJiQkhGeffZavv/6asrIyAMaPH09ISAghISGX3TY1NZWxY8datwsODmbIkCEUFRWxatUqjEYjO3bsYOLEiaxevbrBPl599VUiIiIYMmQIR48etfqYZWRksHjxYu67775r2i+BQCAAiIqMZNncb1i/aTMr1m7k6Ol4Kqt0XMlIukaQMJvNFJaUUFhSwtFT8cxf9jv29nb4uLsTFRFGdPMoolu2ICoyAn8/PxwcHK5alLgWdDodcYnJDQonKekZmM3mOuKRvb093bp0oVuXC+2MRiN/7tgNkgTn+5k2fgwR4eE3fP61kWUZnU5Hdk4OCYlJnDwdz/H4MyQkpZBbVIReb0CW5Wss3GDxaoppGcUdtw1hyMAB+Pr6XnUvQjj6j6IoCpIkUVpSiaRSo1aDg4PtDb+Bbcy8dFV6FAUUWcHJxf4fnY9AIBD8XZSVldWJxriYr776it69ezeqr9jYWOuPVLVazebNm+nVq5d1nFtuuYUDBw5QWlrK66+/bk3nef/99619fPjhh/zvf/8DLDn07du359SpU0iSxL59+xqcy0svvcTSpUsB8PLyYsOGDVZD4cZQ2xS7JrLH2dmZu+66yzrHOXPm8O233162n/nz5zNixIhLrre3t2fnzp2NunFyc3Pjjjvu4JdffkGWZRYtWsQTTzwBwOLFi61mynfccYc1GszOzo7p06dz/PhxXn/9dQYPHgxYbnK9vb2prKykrKyMgoICvL29rziHv0Jt0a7GL+pynD171vp6zZo1hJ+/edbr9UycOBF3d3datWpFRUUFLi4uPPvss5Yyv+eFow4dOjTo1VXDlT6by/HFF1/w0EMPWfele/fuxMdbyiP/8MMPfPDBB9fUb41H1KJFi6wC0IwZM+ql8DXE22+/bd2mU6dO/Pnnn9ZjvnPnTvr164fZbGbNmjVs27atwT7bt2/Prl27sLe3R5ZlOnfuzKFDhwA4derUNe2TQCAQ1MbX15dJEycw7q7RnI6LZ/2fW9i8I5aE1DSqz6egNUaUqGlTVaUjtUpHamYWm3bEolKrcbS3w8/bi4gmIbRqHknrFs0JbxqGn68vzs7O111MqqioIL+o/nVNURQOHj9FSmrqFQWgk6dOc/D4Set++Xp5MXLokOs6z4upqX6ak5tL8tkUTsbFc/pMEgkpqeQWFFJZpcNsNl9zdU9JklAAe1tbIkJDGNCrO7fd0p+WLVv8JWNvIRz9x0hOPkdBVgmSQUatUaNRbGnZtgm71h7AOcQbnyAPQkI8r+uYNSLVlcjKLqIgs5jyxGw6D+vM6cPnwNZItU6Pyazg5udEq+i/V/0VCASCfwvTp09n9+7dzJkz54r59kuWLLG+Hj9+vFU0AouQ8M4771jNiH///XdkWSY7O5vExETAEqFU8wMdLNFOq1atwsnJCR8fnwbHzMzM5K233rK+f/HFF4mMjGz0/mVmZlrT8hwdHesYEU+bNs0qHP3666989NFHODk5NdiPs7Mzw4YNu+xY/fr1u6qnbdOmTbP6Ky1cuNAqHC1YsMDapiZNDSyRWrVTuaqrqzl06BCbN2+ucyOo0+kaPYdrpfb1tyGvnYtp37691ceoW7duDB8+nL59+9KzZ0+rKHitNOazuRSenp7cf//91vfu7u7MnDnT+llc7L30d1H7u/bOO+/UEep69erF+PHjrefJihUrGhSO7r//fuztLQ/KVCoVvXr1sgpH5eXlN3D2AoHgv0R1dTWyLNOubQzt2sbw6AMziIuPZ9PWHWzZtYektAwqKisbrMB1ORRFwWwyUVZeQVl5BYkpaazdthOVJOHo4IC3pzshAf60bt6M5pFNiQxvSlBgIK6urn9JyDCZzZhMDfs+5hcVM/urb/nwzdesf18vpqKigk+/+Z6y8grrsjYto6xRxdcDvV5PWVkZ5zIzSUw+S3xiMqfiE0jNzCK/sJjKqirrsb5WoQiwfmaODg5EhobQt0dXBvbtTauWLawp4VVVVej1+ms+5kI4+g9RVVWNuVTGvVzFS499SHxpKoH+fvTs2Qn/1sH8+uHXvPTSQ5QUltKmXeNK81440S3vJQUUFCSV5Ua1xvjxShw7noYuq4i3PvycO+4YwJ4XD7N71xFSMrMIdHTjsy9fo6pCoaSkHDe3G1dRRyAQCP4pmjRpUqekucFgoLCwkHXr1vHwww+j0+mYO3cuUVFRdVLaGiIpKcn6un379vXW115WUlJCYWEh586dsy7z8fGxVt+q4Uol2y8WJb744gsefPBBqznzlfjpp5+s3gsajYbbb7+9zvqam6Ly8nJ+/fXXS6bvBAcHX/GpZmhoaKPmVEO/fv0ICwsjJSWFQ4cOkZCQgFqtZu/evdb++vfvX2ebjIwMvv32WzZs2MDRo0cbFG2utjTwtVATDQMWseVKvP766+zZs4ejR4+Sn5/Pjz/+yI8//ghYUg/vvvtuHn/8cTw9r/4hU2M+m0vRtGnTej4atVPTcnNzG9XP9TzmBQUFdXyNLvVdqxGOan8vaxMcXLcccu3KgVfyIxEIBILGUlFRwWvvfUTXDm0ZfMsAPD096dihAx07dODxh+4nKfksu/buY1vsXk7GJ1JYXHJN6VE17WVFobyigvKKCs6mZbB97wFU542p3V1dCPT3JSw4kJbNoohsGkZYaBN8fXwa7Zuk1WjQXupBmqKwfN0mbGy0PPPow/j5+Vl/kyqKQkpKKm9//Cnrt++ybiJJEjEtW1yTZ1NNFFFuXh6pqekkpqRwKv4MZ9PPkZWbR1FxKUajEVlR/pJAVBtJklCpVHi6u9EqKoI+3bvQq1tXIiPC64hlhYWFbPhzM3sPHeGVZ58SwpHg0hiNJk4cS4ISA7HrdrFp+y6O5cZTbqMjL6+ILd/uR6NR4RAawNBxM5g3+01UiorW7UPr9aUoCkq1jCmnisriatAY0OmqKTCY0djaICkyumodtmo1Hu7O2Ds54+CiQuVoj1qralBESk7IpiA+jbFTH0QV5MLWJ3ZgNsm4eDljVhQqCot4/o0PGdC/F0ZdB/S2Cm3bR2Fvf+0KtUAgEPzbsbGxwd/fn6lTp5KYmGhN//nhhx+uKBxdSay5+Kbl4r/NjYlMuRSBgYFkZmaSlJTEl19+2SjTYkVRrOIEQGlpKZs3b75k+zlz5lxSOGqMn9LVmg1LksTUqVN56aWXAEuKWm0BpKbiVg2xsbEMHjyYiooKJEmiZ8+e9OnTh+7duzN9+nSysrKuavy/Qo03EEBUVNQV23t5eXHgwAGWL1/OsmXL2Lx5M0VFRQCkpKTw5ptv8vPPP3Po0KGrFo/+islzQ1X5ap+nl4rCu1goamx1v8bQGFH04tLPDXGxSPt3eIMIBIL/Hl5eXvTu1pmnXn+Xz36Yz5C+vRg6aACtWrbE0dGR6NatiG7divsm30tOTg5Hj59gx559HDh6nLMZmeh01cC1R8bUGG+bzWay8/LJzsvn4LGTSH9sRKNRY2tjg6+PN83CmtC1Qzv69OxOZETEJf/WOjs74+fjRU5+foPrTSYzC5evYde+w/Tr3pXmUeGYTCaOn45j+56D9bZTqVQ0CQ5s9P4YjUYSk5LYEbuHvQePcOZsKjl5+egNBkyma081uxQ1D9AcHOwJDQygc7s29OrWhfYxbfDz86tzHayqquLkqVOs2fAnG7bvIie/gI9eee6aHvrUIISjm5ySknLSj2ew6Yff+WLpIqrsymnWrz2denfFy82W0GBHmrgH8d7Lv3DqRAaKSsU9jzzNsf3rMZoVtGrLTY4sK5gLFfS5Oo4lnmLL7n3s2bWPM6mplFZUYjSZcXJyBLWKirJy1CoJVycnIps0oWe3Dgwe2JvAyAjsvJ3wcNOgOh+RVGmQkUurGTPxfsqNOjhTTsvoEGbOGkWhoYzS3DIMlXqy0nN54cu3cf7EmSl3jcaO2wmI8MXX1+OfPLwCgUDwt1A7IqF2ZNClaNKkifX1kSNH6q2vvczd3R1PT886ZXbz8vIoKSmpU8Ft9erVHDhwgFatWtGlS5cGo3beeust+vbtS48ePQCL0fKkSZOuGOmybdu2Ot46V+LgwYMcPXqUtm3b1lvXmOptjWlzMZMnT+aVV15BlmVWrVplFQFUKlW9EvJPPPEEFRWW0PeFCxdaTbMBqyfS30FFRQV79uyxvr84KupSaDQa+vTpw5gxY1AUhVOnTrFz507eeecdMjIySEtL47vvvruigHkx13Lca0hOTqaqqgoHBwfrsprUSqBO9ZvaT4urLipLXFBQcM1zuBhXV1dcXV2tUUdHjhypd4xrf9euJnVTIBAIbgS3Dx/G3oOHWbB8FV/N+4W5i5cTERpM766d6NerJ61btsDd3Z2goCCCgoIYdtutVFZWcjYlhb0HDrF7/0GOxyWQm1+AwWi86rS2hlAUBaPRhNFooiIljbOp6azdsgOXb36gY5vWTBo7mv59+9QT2e3s7OgY05pjp+MvOQdFUUg9l8lPS5ejKCABSA2LX5Ik4e3ldcX5VldXs3X7DuYt/o0Dx05QVl5xXY5DQ/NRFAUbrRYfL0+im0fSq2tnunRsT3jTpnWqksqyTFFRESdPx7F15y527D1AYko6uupqVJKKe+8aychhjS9I0RBCOLqJkWWZ8pwK0ledZunS33GPcKLb6I6kekZx4pgR46FKtFo9QW3yGLVwLC73Lyd2Twp6k5Hbh01lxdkthKsU8qrN6FPLWblwBT/8sojEjFTMipmevTtz6x39MBjNRESFU15RhtbOEU83Z44dPIaDgz1xcWd568uveO/rOTRrEsrUiWMZNnYULn6uuLlIpBXouHfkTCqMekBFq+6B3PrpDBb+nEHBqVJkPRibetMxJoyJoUHErt7L/F8WEW72x+ulIRg9TGi14jQWCAQ3L7IsWyurAVaz4ssxYsQIPv30U8DiCTRz5kyrmFNeXs7zzz9vbTtq1CgkSSIwMJCIiAiSkpJQFIWPP/6Y119/HbBEdrz66qscPnwYgM8++4xHHnmkzpjBwcHWfkeOHMnvv/9OUVERb775Jh999NFl5/v9999bXz/66KPWuV/MwIED+fPPPwH49ttv+frrr+u1aUx69LUUgggKCmLw4MGsW7fO6j8DFjGmtlAHlqptNdR+urdhwwbyaz3hvJGparIs8/TTT1NZWQlY0g8vVz0OLIbTQ4YM4fTp01RVVXHkyBHatGlD69atad26NUeOHOG7774DsFY0g7pCzeWEsb9SgKOiooIPP/yQl19+GbCk4H355ZfW9T179rS+ri1U1jaXNhqNrFy58pJjNHY/ajNixAh+/vlnAJ5//nk2bdpkTTXbvXs3v/76q7XtHXfc0ag+BQKB4Eah1Wp57snHSEhOZe+RY+iqqzkRn8jJM0l8t3Apfj5etG3Zgp5dO9GpfVtCmzQ5H43UmujWrZk26R6Kioo4FRfP7r372XvIEmlTUlZuyUy5DuJJTR9l5RVsjd3H7gOH6d21E88++iBtolvXuZYMHTiABb+tshp8X6lPxfqf+kgSl03jUhSFEydP8u6nX7Fj7wEMRuN18SeqOweLzYubizORoU3o1rEdPbp2tgp6NdcpRVGoqKggLT2d/YcOs3v/IY6ePE12XgFGk6nOfLq0i2bWE4822jrgUohf3Dcxhw/Eo8qt4Mnv38ertTMdprZl/wE7SnbkoCvIx1hajsbOmaL0dBLj/Oj1TCc0Y5Mw6zWcyUrFPa2AeDdH9n63gnc//Yq0wnNo3DVE9o2iXVQrOrRozq233kJ40ybnb34li4yrgOr+cZw7l8PK5esJbenD3hNHSDhxlqfeeIPPv53HS089QLsRI/EyVnA6JwkFFSqtEb+HevLTE4cwZaejtXfEVFmCtsSBY+k+JPraEjYiBhUHeWbFBywf15KUjGx692v3Tx9qgUAg+MsUFxfXieBQFAWdTsfOnTutJdwBJk2adMW++vbtS69evdi5cycmk4l+/foxYsQIPD09Wb9+Penp6YClYljND3GwlDWfOXMmYIkW2rlzJ9HR0XXm4O7uzj333FNvzNrpNe+88w5r1qzBbDZbK2FdyiOppKSE5cuXW9/XNsW+mPHjx1uFo19++YUPP/ywzhO3G820adNYt25dnRuy2qbYNfj7+1v9qsaNG8e4cePIyclh1apVddpdL3Pss2fPWs8dWZYpLS1lx44dxMfHW9t89NFH9Z7WXkxN9FlNtFSvXr0YOXIknp6enDlzhg0bNljb1hZqaqegrV69moceeojAwMA6AuX14JVXXiE2NpaIiAjWrl1LSkoKYKmSV/tziImJ4bfffgMsoqSrqyuhoaHMnz+/juh3MbX347nnnmPRokXcd999dO3a9ZLbPP300yxdupTq6mr27dtH69atGTJkCEVFRfz+++9Wj6Lbb7+9jkm9QCAQ/FN4eXnxwesvcu9DT5Kacc4q+BiMRtIzs0nPzGbN5m3Y29kR5O9Lu9Yt6NqhPW3btKZJSAienp706dWTPr16YjAYOJeZyf6Dh9i8M5Z9h4+RW1B4XUUkvcHAnzt3c+x0PC8/+Qh33XG79Z6jQ/t2dGzTit0Hj1yXyKdLperLssyS35bzxuwvyC8svq7RRTVika+XJ53btWFArx506dSBwIAAq5ClKAqVlZWkZ5zj6PET7D10hCMnT3MuO5dKnQ6lgQdRkgRhISG8/9qLfylFrQYhHN2kFBeX4a6yof+dMxjQqwvtXunAZ4tS0McZLB5FxZVUZicgm6tx8g2nYOdpVh1W4X9vG859dwoJiY1fr+a3Pbv448BWvFq4MeXZiYwcfSvhPsF423jiqrbcrEuS1KCJWFCQHw8/Opkys46c6gLOFCSzZvkm1v64gemzXuSO1VvpEdMGWQEVEHB7OLuf3IxcZkDr5k7p2UNoNY44+YVj0hoo16s5pnZm/OzRFM0+ytBRY4ndtZGcnEL8/K5vJTiBQCD4uykrK+O99967bJtevXrx2GOPXbEvlUrF4sWLGT58OIcOHcJoNFp/SNfg7u7OypUr60TLzJgxg3379ln9hrZt28a2bdus621sbJg/f36dFLaGaNGiBZMnT+aHH37AYDAwa9asOtWnarNw4UKqqy2+CQEBAdbIqIa44447eOCBBzAYDJSVlbFo0SKmTZt22blcT0aMGIG3t7c1asjd3Z1Ro0bVa/f000/XKRtfOzKqdmpTYmIirVq1+svzysjIuOS5o1KpePPNN5k4cWKj+vrpp5/o27cvcXFxlJWVWaNpanPnnXfWiV6qLSKVl5fz1Vdf0bt37+sqHI0dO5bt27ezYcOGOgKWSqXiq6++qpPOOW3aND7++GNKSkowmUx1js2DDz7IV1991eAYPXv2tAqkhw4d4tChQ/Ts2fOywlF0dDQLFixgypQplJeXk56ezpw5c+q06du3L/PmzbuW3RYIBIIbQvNmzfj49Re4/+kXyTsv9NRGlmUqq6o4k5xCwtlUFq9ah6ODA0F+PrRuHkmX9m1pF9OGpmFhhIWG0jQsjDGj7yAnJ4d1mzaz8LeVnE48e03m2g2hKJBfWMRzb3+I2Wxm3F2jUalU2Nvb88h9kzlyKp7Ki1KTrxZZUSipVfDAulyW+XXJMl58b3adKmh/lRpz65aR4dw9egS3DrwFPz8/VCqVNaLoTEICh48d58CRY5yISyAjO9e6n5ebhyRJ+Hp78fHrL9C8WbPrMl/hvneTkp2Uz+fjPqWJ2p2+7/Xi3XXp6OPBXK2jKi+Jypw4zKYqFEWmPCcBk06HoUyHOcSNmuC/R758n02pu3jwy6ns3ruWr558k8FNehDp0AQ3jdMVK6bVrHfVONDMKYThTfryzRNvsWfvHzz4+VTWxW/jpTlfcj7bFE1rH8zlVZgNFVRlJ4MCRmM5pblJlOekoOgNqM7B0hUm2j7WnYGuMbxx9yvkpBbd+AMqEAgEfzOSJKHVanF1daVTp0689957bNy4sdE+Mf7+/uzZs4dvvvmGPn364Onpia2tLRERETz++OOcPHmS3r1719vuhx9+YPHixfTv3x83Nzc0Gg0BAQFMmDCBAwcONLqc+muvXSiBu3Tp0jpeOxePV8Po0aMve11xc3Pj1ltvtb6/+Af6jUar1daJtho/fnyDUTwPPvggS5YsoVOnTjg5OeHo6EiXLl1YsGBBnbS9i8W864EkSTg5OdG8eXNmzJjB4cOHee655xq9vY+PD/v372f27Nl06dIFX19fNBoNnp6e9O/fn59++oklS5bU+Zw6dOjA119/TdOmTdFqtfj7+9OmTZvrul+hoaEcPnyYyZMn4+XlhYODA71792bjxo31PKYCAgLYs2cPI0eOxNXVFWdnZ/r168eGDRvqpVjW5o033mDixIm4ublhb29Py5Yt8fHxueLcRo8ezfHjx3nqqado0aIFDg4OODs706NHD+bMmcOmTZv+kjG4QCAQ3Ah6du/Ox68+j5eH22WvvTXRQxWVlcQnp/Db2k08+9aHjLhnOoPuHM+jzzzH6j/WUlpaSkBAANMm3cOKn3/kszdfolNMa2xtbP5SqnLteVRUVvL8Ox/x4/wF1uigPr16MW386GuqhlZ3AMjNy6uzyGQy8eP8Bbzw7sfXTTSSJAlbGxs6xbTmszdfZsXPPzBt0r0EBARQWlrKH+vW8+gzzzH4zvEMv2c6z7zxAUvXbCAu6SwVlZVXjOaSJAkvD3c+euU5enTr9pfna+1Xud4uToJ/HL3egLFAz5iW9yBpJVL7RFCeLSPrdFQVnKW6KAOzoRrZZAQkan+NPYc3o2h1AqAieEBT5n7/Lj2bdLguX/bayIrC9rSjTJ78LDk7kpEUcBvRlJJVCbXmY8l7k9VqtHbO2Lr44uTXFLWtPZKzkd5pRVAt8+mOb9F42+LgcPkQfIFAIBAIBAKBQCAQWFAUhU1/buZ/r71DTl4BlzQAugyW7BMVTUOCGXf7MO4YPpSAgAAkSaKqqopdsXv4adEydh88TFXV9UnRtrez46HJE3jswfuxs7OjqqqKV95+nwXLf8dkMl9TnzZaLe+/9Cx3jxsDWEywP/3qG7786Rd05yOj/yoODvb06NieSWNH06tHdxwcHFAUhaysLFasXsuvK1dzNj0Ds/naIrUsKW9efPza89wyoP91/Q0vhKObkFPHkyk/kcuDDz5NYIfWnDA4oxhkjGV5lOecobosFxQZUNWSjSz/l1ztoUxPVP+ufPnr5wQ6uNLUQX3dhSNFUUjRGTlXVcbDU5/lzJqtqF1tkEuqUQGS9Y+WhBkFWZLQOrnjFtgCrYsPkkqiadg5ytfHM2/pIvSuWtp2vHKZYYFAIBAIBAKBQCAQXGDPvn3875U3STybds191PxeDPTz5c6hg5hw152EhjZBkiSMRiOHDh9h3qKl/LkrlpLS8r88Z41GzejbBvPyM0/i4+NDdXU1P8z7mS9/WkB+YfFV9eXl7sYTM6Yw5d6JaLVa8vLyeO29D1m+btM1C1G1cXN15pae3Zk07i46tG+HVqtFURTS0tJZuGQpy/7YSGZOLvDXjLajmoby0Wsv0rVL578854sRwtFNyLEDp3ngtifo6RrMvpHBpO+rQldWhC4nEX1pDiZDJSpUVslIqSUeSSo1oYNuY8Rr7xDuqmJ0qC1eNpdPSbsWZEUhV29mcbqZknIzf7z9BidWLkWRTahQauVQWiQkGUCrxt4jGPuASGycvWh/iz/ey/aSUFDIO798QNc+1zcsXiAQCAQCgUAgEAj+C6SkpPLaex+xccdujJcwiW4sNZEvo4YM4J5xdxEeHo5KpcJsNnM6Lp6fFy9lzaYtFBSX/iWhRJIk2rZqzuvPPkmXzhaxJC4+nh9+/oUN23eTX1h06dQuCVydnOjfsxsPT59CdOtWKIrC/gMHePm9jzl6Kv4vzg083dwYPmgA94y9k5YtmqNWq5FlmeTkZBYs+Y3lazeRW1Dwl1PgtBoNg3r34NVZTxEa2uTKG1wDQji6CclMSaFN0+HcPSyS1epIzPlgMFRizE9Dl5+BSVcKilInJUxBQbKxwbdTb8LveR63sCDGREr091PjY6e6IRFHudUm/sypZk2ylrwzaSTM/5yCIxvAaDgfdcT5/0qYJVDZO2HvG4FDcDNUihq1m4lhLuksXHiM42fXERh2Y74kAoFA8F/n9+M5vPxHQp1lEzoG8OzAiDrLzLJC709iqdDXfTp37LkLXkrTFh7jYHp988lLsfOJ7uxJKeaZlXEX5jOjI6GeDg2235dazIxfT1jf/3F/J4Lc7Rs93vXgpTVnWHXC8uTw/p4hPNAr9G8dvyFqH/fXh0Yxso1fo7aLeWeH9fXaBzoT6Pb3poX/0+MLBALBfwmdTseylb/zzbyFJKeduy7m1k39PZg2sh89B44kqkVrNBoNsiyTlJzM3IW/snL9nxQUlVxz/zXl66eOv5Pp907Ey8sLWZY5dy6THbtj2b3/IMnpGRQXFWOWZZydnAj096Vr+7YM6NubZlFRaDQaCgoK+GH+An74dRklZeV/ab+9PNwYNWQQkyaMITIiApVKhclkIiHuJLs2/c73v28lJfuv+fTWmGs3bRLEA5Pu5s7bR1q9JW8EoqraTYiNpGDCzMAJgaz41oQka6BKh1mvw1RdjiSpURQjSu1ENQkcAwJoevtkfCKCmByl5pZANVoVwPUVjSzjSfjaaxnbRI2XjZFFUijy6AlU5ZymMiPl/Be15p+EhAa5uhJzZT5yoQs4+2Islbj3gZb8uPAw9nbC510gEAj+TvamltRbdiq7vJ5odD3oE+GBo42aSoOl7/Vx+dzfs+GHBZviC6yvYwJd/nbRSCAQCASC/6/Y29tzz/hx3DZoIFu27WDT9p0cPR1PVk4eeoMBSZKuWlBJzirk1e+W02PrVkb27UJ0n1G0jOlAVGQkb7/yEpPGj2XOvAWs2riZ0rKKq56zoigUl5bx8bdz+WPTNqZNuJPht91KSEgwE0PGcve4MRgMBqqrq1EUBa1Wi729PSqV5fdjYWEha9Zt4PtflnAmOcXa57Xg6uLEiEEDmDHpHppFRVrT9E4c3s/JHStYuXUfu5OKMZjkqw7MqDn2tjY2+Pt607ZlCwb27cmAvpYCKDcaIRzdhCiAGYU33zmNKjgGs07GVFWCviQHZPP51DTpfEsVaq2a0Nsn0fTux/FwteOxaGjqBFrV9ReMaiMBGpVEDx81vvYy39l2xDVqBYnzPiFlzc/IJhNW8UgxoihQXZyNWq3BwckHjbMN7zzyOyBhVv5aOKVAIBAIro6zBVXkV+jxdrK1LtvXgJh0OdoGudAuyPWybWw1Kmw1KgY087JG8Wy4hHAkKwpbEi4IR7e1unJFLIFAIBAIBJCXl4ednR0uLi54enpy1+hRjB41ktLSUuLPJBC7/wB7Dh4mLimFopKSRhs4S5KEwaywNb6Iw6kbGXH4ALf07Exw51G0aNOe5s2a8cEbr3L3naP49Nsf2LJ7Hwaj8arFG0VRiE8+y6y3P+KbnxcxuE9PBvXvQ7PISGuFTQCz2UxRURFnEpPYtHU767ftJDUj85qjqyRJwkarpX+PLjw2cxptY2JQq9UYjUbijh/mbOwytu87xKpjxZRWm0Gi0aJRjfG4u6srLSLC6NaxPd07d6J5syjc3Nys4hdAWVkZer0eb2/vq96HxiCEo5sQnVlGhYZTp7IZMXEQO5cVYKoux1RdUUsykpBQcAgIosVj7+PTrgsaCfoFGMjTQTsP7d8yVwkJB42aIp2BDn4S+UYHWj70Ih5t+3Pi6xeozssAa/QRyEY9CjYoZjP9Bjixcm0BYIvOKIQjgUAg+Duw06qoNsoA7E0pYXi0r3XdvjSLGaW9VoXufJvL0TXUrdFpXLe18rEKR2cLqkjMryTS27FOm8MZpRRWGgHLg4lBLbwa1bdAIBAIBP91cnJzeemdD+nXoytDBw+kaVgYarUad3d3unXtQreuXTAajeTm5nLi1Gn2HDjI/qPHOZueSWlZOYqsoFyiKpt0/j+l1WYW7C9gZ+Im7j19lLy2nWnSfQzhzVrSoX17vvusFes2buLjr78nPjnlmoQcs9lMcmo6X6f9yg+/LsPHyxNfLw98vS33BDl5+eQVFpNXUHhNAlWd/ZIkmoWH8b8HpnProIHY2toiyzKJcSdJj13KqaP7mL8vn7RioyWP5gp6kYSEpJJwdXGmaXAwHWNa06NLR6JbtcTX1xettu5vdLPZzNmUFP7YsIltsft447mnhHAkaDxZuSX4qdzIUHKoPnsUrToYk66EC5KRgkqtxq1ZW0LGP0VU545UyRIqSWZXjoYpzaQbkJxWlws10yw4aCR256twtJUpN0pE9exMleEt0pd8QkXKEWSz6bzopaCYZLQqBTl5G0YkAjVOZKQVEtIk8gbPWiAQCARtA12saWr7UoutwpHeJHPsXJmlTZAre1KurqLJlegS6oa3kw35FQYANpzOJ7JPXeGodppatzB3PBxsrthvjYeOp6OWuRPb8vKaM5zKKcfVTstzg8K5pbnlBiwup5zvYzM4lF5KhcGEj7MtPcLcmd49BF8X28sNUYf8Cj3f7U4n9mwxueV6zLKCm4OW1v7OTOsWQkyQCwDLjmTzxvpEACK8Hfhtesc6/ZRUGRnw+V5MsoJGJbHhoS54OV15f2vYnVzE17vSSMirxMlWTY+mHjzUuwl+LlfnIbT7bBFLj2RzKruc4iojbvZaOgS7ck/nIFoHODe4TVxOBfP2ZXAwvZQSnREPBy0R3o7c3TGQHuEeVxzTLCs8tuwUO5Mt/hDeTjbMv7ctAa6WuR9IK2HhwUxOZlnmpFZJ+Drb0i3MjWndQ/B1bvznJRAIBP8VWrdqRfvoVrzz+bd8Pe8XOreNZujA/vTo1hV/Pz80Gg1arZagoCCCgoK4dfAg9Ho9WdnZnDwdx/7DRzl68jRn089RUlqGwWisl9pWI5ykFht4a2MWHU6vZ0rqMbKj+9O89xh8/Py5ffgwunXuxCdff8svK/9Ap6u+JnFHURT0BgMZWdlkZGVfr8N0fj8k7O3tuPv2YTz2wAx8fS33Qnk52Zzcupi8U1v5eU82B89VY5YVJKn+72vLsQEbrQY3VxeaNgmmbcsWdGofQ3SrlgT4+2NrW/96ZTKZyM7OZvfefazZuJkDR09SUl7OQ5PvplXLltd1P2sjhKObEJNR4cm+d/Dkli850705hp2xaBw9MZRabqgVFNROjni0602nXu0oU6lBVnC3gQeaQ7SHuk743MUiz/VGJUFXHzu0GgOfn1FhlFUYbCRuvy2aBYm90OUkY64oOj8HNWo7e6qLEzno64xKgWeHjKe8wniDZicQCASC2vg42xLibkd6cTX70kqsy4+eK8VgtlwxOoVcf+FIJUkMbuHNggOZgCVd7eE+odb1iqKw+cwF4WjoVaap6U0y9y86TlapHoCCSgNRPk4ArDuVx4trzmCSL9y4ZpZUs+RINhvi8vl6XDSt/BsWSWpTVGVg6oLjpBfr6iwvrDSyPamIXclFfDU2mq5h7gxp6c0Hm5OpNsok5VeRXFBJuNcFoezPMwXW+XQLc78q0WjtqTz2pZZYr+96k8yqE7nsSi5i7sSYSxqP10ZRFN7ekMSSI3VvxvMrDKyPy2djfD6P92vKpC5BddavOp7Da+sS6xzL3HIDueUGdp8t5tG+oUzrFnLZsT/4M9kqGjnbqvl6bLRVNFp3Ko/nVsXXeeZtkhXSi3WkF+vYkVTET/fEXLVAJhAIBDc7KpWKR2ZOZ/+RYxw4dpIN23ezcUcsnh7utG4WQbcO7Yhp3YrwsDB8fX2wtbXF1taWsNBQwkJDGX7brRiNRvLz80lOSeFU/BlOnI4nKTWdgqISCouL0RsMmM2WiGRZgf3pOk5kpzLgxBJGpxzCt/MY2vYYhK+vL2++9AI9u3Tm9Y8/52xaxj98dOoSFhLEy08+wpBBA1Gr1RgMBo7u3kju/iX8tieZzQkV6Iyy1cAaQKNRY6O1wcPNFS8PNyJCQ2jTsgUtmzcjomkYXl5e2NjUvZYrioJerycvL5+ks2c5fiqOPQcPcyL+DIW1KtJ1bhvNIzOn10ldu94I4egmpGPnNri8pCFi20pSZv2G+y2tUG3KPm+KLYMkEzRgDAOmP0C5Wku1QaKNh5mHW6px1UoYZQWtSqoXSlf7Jux6iEjWPhQwydDBw4aPOsh8cMpMfImafAcHJj16Dz9Um8lY87mlEpxKg8lYjs1AH859eJg2miC6zOpHeNsbp64KBAKBoC4dQ9xIL84hr9xASmEVYZ4OdfyNOoa4Naqfb3al882u9Euuf3pAUyZ2viA8DG3lYxWO0ot1xOVU0MLPIu4czSyzRiM52KjpG3V1RpEVejMVejO9IzzwdrIhs6SaEA97UgureGVtglXoaO3vTCt/Z45nlRGXU0FptYlnVsax/L6O2Gouf8P2454Mq2gU6GZHnwgPDGaF7YmF5FcYMCuw8GAmXcPccbLVMKi5tzU9b/3pfB7qfUE42hifb309ola6YGPYm1qCu72WPpEeVBnMbEkoxCQrFFUZeWVtAvPuaXvFPn4+kFlHNGof7EKktyPHs8qJy6lAVuDjLWcJdLW1Rm0lF1Ty+voLolGUjyPtglxJL9ZZhcbPtqXSo6kHzX2dGhx30aEsfj2UBYCNWuKTO1sR6XPhuHy05az1fqVTE1eivJ2oNpnZcqaQYp2R7DI9X2xP5c3hza/qmAkEAsF/AQ8PD958/hnuefBJ8goLkGWZ/IJCthYUsi12Pxq1GhcnJwL9vWkWHkGrZhFERYQT2iQETw8PXFxc8Pf3JyAggF49eqAoCgaDgcrKSvLy88nKziY1PZ30c9mkZWRQUVZBSfZZ0vKr+HFDPLdlfkZV2iGaDZyGf2AQQ28dQrOoSJ5/4x227z2ILF85Db4hFEVBrZJQAFm+csrYpVCpVPTp2pG3X3qOiPBwALIyM0j4cy5Jh3bxx8kSSvQyzf1ccfVrirOrEyFBQYQEBRAaEkJggD/eXl44OTlhY2NjDdZQFAWz2UxxcTEFhYWkpmeQkJTMqTOJJCQlk5mTR2l5JSaz6aIILgkfL0/efP5p3N3dr22nGokQjm5C7O1tKVPJzH7yGaZ89BIFi/eidnICRUZChUebrvR7+HGyZS2SUSLM1czUZipctRIlRpmcKj3N3RwsJ6UkYTDLHEzMxKwotAnzx9VWcz5H8/w3zlL4rEFqn9hFeiMnUnPRSmo6RvpjW8t8+1yFAV8HLZ42Ku6PkvnktInsChWVkjMTHp/Etwn7KT2zDxQzilxA+bxUQvHho+eepcQg4+goquYIBALB30XHEFeWH8sBYG9KcR3hyF6rotUlUpT+Ki39nQnztCel0CK+rI/LswpHf9ZKU+sX6Ym9Vn3V/feP8mT26FZ1lv1yMBO9yXKjeltLb94e0RxJkpAVS7rUjqQizpVU82d8PkNbX17ACXG359aW3qQV6fhiTGs8HS1PFoe28mHKgmMAnCuptrYfFeNXxxD8od6hgCVy6eD5aC8XOw19I69OJHO207B4antrit2u5CIeWnISgKPnykjKryTiIv+o2uiMZubsSrO+f7RPKNO6W6KE5PORSEvPi0ofbTnLgGZeSJLEwgOZGM9HpfWL8uTDUS3RnL8XeG1tAsuP5eBkq2ZfanGDwlFsShHvb0oCLNHK74xoXkek1Jtkq3jo52LLd+PbWO9VJnfR8c7GJJp6OVxSlBIIBAIBtI1pwxMzJvHS+59gNF3wkVUUBaPJRGFJCYUlJZyIT2LZHxYxxcHeHjcXJwJ8fGgSHEintm3o0LIpdrZaqquqqCgvobykELVZR7i6nGDPYro6gYvWHrtqd1TmC9ccVeE+Upenktt5CjGdexERHs6cTz7kjQ8+5pcVqzGZrqV6q8TwmACKy8vYnnT1ldvAEjE0YdRwXn7mf7i6uqIoCsf270S3fy4ehlw6hqjpGGK5HssqG6ps7SkzgcauBFuNhLmgkvTCsxS7e+Hk7Ia9gyPVBiMHTyVz8NgJ0s9lkpWbT1FpGVU6HWZZthjNXCZNT6NW87+ZU2kbE3NN+3RV+3/DRxD8I/Ts1Z71ZTv4Vf0+L33yEQeLLDdaao2KpiOncK5KS4dgM2klCuND1fjZqThRbGJlWgkvtfVCAmSgzCSzp0wmy2zL6bgzPDb7N154dCxhId60d9Y0yhH+RHk1cak5vPz+rwwaPoC2MREYKhVi7BXc1RKSJBHqYsMPceV087enuZuGCU2NfH1aJswZdibb0GTkVE7NPoRiNKLO09HFPoJ3H3mWnE5qbu3b8YpzEAgEAsH1o2MTN+vrfaklDGvtS1xOOWDxN9I0sirnlaqqNSRA3dbKhy93WESLjXH5PNGvKcBfSlOr4daW9berHUl1V/sA63VPJUmMiPZlR5IlZWpvaskVhaMx7QMY0z7A+r5UZ+R4ZnmdSnA1IhVA+2BXmnjYk1akI61IR1xOOS38nPkzvoDz+gtDWnhjc4VIp4sZGe1bx5epZ7gHzXwcOZNXCcCJrPLLCkd7Uoop11tu3ANcbZncNdi6TiVJPNEvjNUnc6k2ymSV6onPraSFnxMHaqU2ju8QUOc8eaRvKFO7BRPkZnfJe4t3NyZb97tPpKc1kqkGW42Kpp4OnC2sIqdMz+1zDtI7wpP2wZbz7Otx0Y07QAKBQPAfRpIkJoy9ix1797N2y45LtqsRNMxmM+UVFZRXVJCRlcP+YydY+scGfJ00DGnmwNAWTng4SDieby9JtaIOanSpi+4bHI15mPZ+yp6CdDoOHIObmxtvvfQ8Hq6ufD3/V/QGQ6P3R1EU/F0dmDogiuKsRI6fq6K42tzoymYAtjY2PHDvOP736MPY2dlhMBg4uGkpdknLcTJXgwTqWv2pMeKqT8MVoBKoVFCU8+vTJQqrZP44Xcn6BB25FUZQlAYFois5Ow3q04Nxd41u9H78FYRwdJMiSRIDh/Rkt+0hfhn0PVt+3MiTCz+g0tYW2cWFu1vCtiwTb3W0xdVGxdwzRk4UGXi3s6f1SeqZCjNf5Rg4WgXJFW74uXfArq8Pk6a9wSeLPqBcr9DH24bagUdQN/hof7mJuHI1D054lmbPPscm32Z8n2tDa5VMK6WaxwJtaeuoAQkmRDny7EEdLVxMTIjU8moHhfePmpjZTsvHp+3Q2jthZzLw1b1P0+PuPpyhkIF9213Vl14gEAgEfx3fWj5HB9NL2JdWYv1B36nJpYWgi7maqmo13NbygnCUVarneKbFkDu7zOJN5OmopWvYtYVr1/jk1CbnfL+ANSqoIc4WVDVqjBNZZaw4lsOBtNJ6XkdQ/8ni7W38+HRbCgDr4/Jp4edcJ01t+FWmqYEl8uliQj0drMJRUeXlb8gzas07yscJ9cU3/LYaQtztSTjfX0axjhZ+TuSWX+jX/yKPIQ8HGzyuYK1U2xdpZ1IRqYVV9fyYXhsaxSNLT1KiM5FapCN1/znm77fcm7T0d2ZUjC+jYvwbLW4KBALBfxF7e3tem/U06ZlZnDqTdEUBozaKooCikF2qZ+5+Axviy7m3gwvdQ+2pCQaWFQVFsQQqKIqCWQGzDIps+VtvkhVkxUCgvIQ9FYV0Gn4fDg4OPPPEo2jUKj77cQEG45U9bhUsDzQm943Cz90BF52GO2Oc+X5/aaP3x0ar5dGpE3nikYfQarVUVVVxYNUcXLK3kFWoQ5IslVw1KglJDRrJooOpzhtiq6Sa1DgFoxliU3XMP1RGVpkZUK7tt6wE0c0ieW3WU9jb/z2ZN0I4uonRaNT0vqUTR3bFYR/tRpVKwrlTH14b15bPThh5OkZDQRV8eNSAixbe7OSArcZy4mZUyfyYa+ZMtY7Co1nYxJ0jYec6ZJ8mqPya8eov+4jo2o5t/d1Bkhr8Y6IoCo8dlck7fAqbNl04tfQAmqyvkdr1paBDBHLnID4pcuVdtQo/exX2GhVvdrDj/ZNGnj9k4t4INdOaq/nkmJG3pnbl4SNjOLvqR2zauZOprqRPv45CNBIIBIJ/iA7nfY7K9WZ+2nvBtLJTI/2NrpUgd3tiAl04dl4w2hCXX0e4GNzCu56Q0VicbOunt5lrCTnu9lou5TupUV95zIUHMvngz2QUwE6rol+kJ+2CXfBzseOZlXENbjMi2pcvd6RikhU2xuVzT6cgDqdbbnjDPO1pE+hy5R27CKO5vkeEuZYoc6Xjp2mE+WZt/auhS7X5MqH3l8PX2YbccgMmWeGTrSl8cmfd1MI2gS6svr8za07msjWh0GrargCnsss5lV3OzqQiPr2zlbiHEAgEgssQGtqErz98h0eefYmjp+Ovevuav7FZZSbe31aMj1MZNmpLlW+zQq1/CmYZjGbAqKBI4GKrYkpXF4LdNZC0gU8/yGXKzEfx8/PjiUceQqc38s3Pv2I2XyFtTVFoH+bNbR2CARkkGN7Kie3JVSQUGK54HVCr1cyYOM4qGuXk5PDTnM/orj6Kyk7hdJ6BufvKKK+WLdc6jYSNGtQqSwSS+ryIpD4vIunNCnkVZmSlRjC6tutQu5Yt+Ozd12nSpMk1bX8tCOHoJic1ORNNmZ5HXngX2dGVL+e+wRcnZSY103AsDw7kmhgYAmMitdiqJCQkTLLCy0fMZLma2FOcgbwtFvOOzajKcjEd3gCeHahOjsXY5juqFbA/f77rzGbUkgobleWLYVDAPkuNacm3VBYrqM5uQnYKRM7PoLCgC7vt+xLSpi3PZKv5sZMtahU4a9W80EZicaqRz89IdPGQGRoi8dVpme++eILbdvzOlKeeZ9vqXzl5NJHodlH/6PEVCASC/yodQ1xZcd7n6ESWJU3NwUZNy0ZUF/ur3NbKxyocbYqvKxzddo1patCw+OPjbEvmed+hT+9sRUzQBaHGLCuNFqnKdEY+2WoxbtaqJZZP70igmyXqJrmg8pLbeTnZ0DPcg22JhWSV6vloy1lrdNe1RBsBJOTXH6929JP3FSq0+bteSHNLyKtAVhRUtW6+K/UmMkou9FcT4eTrbEN6seVYpp43Va8hrUjH0iNZhHs50tzXkRZ+9c+jXuEevDmsGbfPOUixzsjWxEIOpZfQ4SKx0sFGza0tfZjQMRCDSeZUTjn7Ukv4PjYdo1lhe1IRJ7LKr0l0EwgEgv8SzZs1Y/7Xn/L2x5+xauNmdNX6y3ruNIR0Psggt+LyIs95e11aeNnwWC83wjy17Dqr44f9ZWSWreXkuWLmfvkpNjY2TLtnAr+t3UBOXv5l+lNw0Gq4f3AL7Gw1KCZL1KuzrcTUzq68vKEAg3x56cbH04Np90xAq9ViMBh48oVX2bxrL0tdVEzr7MKASAfC3LV8uquE+HwDil5B14jbgmt5cCFJEvZ2towY1J/nn3wMf3//q+7jr3Dj6rUJ/nGMBiMVRVVMHvMMhXI1j/7wAYsSHegbILH7nMSeHBVuWoWO3mpsVSrLl1qBxaky5dUq0mPTMN/3HKZFszGn7MVYkIJcXQFZ+9ClJaCpVHG8QrZEGykK63JK2V1ksORoAidKDdjJCmWJx5CSt6IY9JiLUpAzjqNbM5ecV16h5Eg8JRUSP8cbQLF8ce1UKjq5KQTYmdiRp2ZvkYb2vgrfJGn5asm3VJgrGT1mBma9iqrK+mH+AoFAILjxNBRZ1DbQ5W9JARrcwts6Tm65gaxSSzpZiLs90QHXLgZIDdw+dgy5kHq38GAmcq0b5qdXxtHv0z1M/+UYG+IuffMKkFqkw3Be8VGrJJztLjy7W3Myz/pabuB+fFSMn/X12lOWtioJhrW6NuFoQ1x+ndS6HUmF1rQyCYtP1eXoGuqOndZyC5lVqmfevnPWdYqi8Om2FKqNlqimYDc7os5XPattZL3oUFadyKdFhzL5eX8mr65N4LvYhssuzxoYjpuDlundL3gqfbT5rPVHzKH0Eu747iBdP9zF3fOOUKk3YaNR0S7IlZk9QgislYpYOwVRIBAIBJfG39+fj99+ne8/fpc+XTvh4HD9U6MURUGjgqHNHHn7Nk+c7VR8tLWYNzcXkV5iRFZk2ke3wsbGBkVRWPTbCvIKCq/Qq8Twjk1o08SjztVdkiQ6htjRu6nDFU2EcgsKWbx8BYqiYGNjQ7vWLZEVmbQSI29sLuKjbcW42qt4+zZPbotyQKO6vJn1teLgYE+frp34/uN3+fjtN/520QhExNFNzeH98Xzz5BdkVefj2aYFae6dMZkgsVhNuV7C297MI220RLiqrXHkZkVhTaqMTWUeut++wZR0CkUGsITvW9IzTaCYMJ5K4GC7FnR0tkdWYHmKCm97M309wSgrHMgzUpabj9lkRjEaAO15kUmFYlLQZ6SQ+/U7tH7ufdbITbinOWgkCUlSaOlhx0wbE5/EyWTo1FSYJPL0KrbZtSayfUfyjp3hvf+9y5PvP0GnHq0a3H+BQCAQ3Dh8XWwJdrMjo1YVsI5X4W8EFkNpvSnlsm0GNfeqF8Xk7qClW5g7O5OL6iy/VlPsy3F3x0DWnMjFrFgEl9SiKtoHuXK2sMpqnF2SXsqsgRGX7cerVhRPtVHm3vlH6BrqTlxOBUfPR08B6I3108h6hnvg5WhDQS3voc5N3OoYXF8N1UaZe+YfYVBzb6qNZjbVMhbvFeFhjYS6FA42au7pFGgVeD7ZmsKu5CLCvRw5kVXG6ZwLFWueHNDU+mR1QqdAVp3IxSQr7E0t4a4fDtG5iRuZJdXsOlts3WZ8hwAaoqafsR0CWHgwk6xSPadyKlh7Ko+hrX1p6e9MYaUBo1khs6SaO384RI+mHmhUEkczy0gtsjxs0qgkom9Q5T+BQCC4GdFqtQwc0J/ePXtw6vRpNm7Zxp6DR0jLzKakrJxqvR6z2Xw+EOHqhBNFUbDXqpjeyYUhLRzZcVbHTwfLyC2/4AHk6ebGyKG3AnA2JYV5S1cgy/Wvl7X7DHR3ZFLfSFQNPNDSqCQmdXTh8LlqinSXNsqWZZl5S1YwavhQmoaFcfvw2/j+l6UUlZZiNCtsSKjiWLaeyZ1ceKCnG009tXx3oIxqo3zVUUXW4hsqFXa2trg6OxEaFEC3ju0Y2K8PrVu1wtb22q771wMhHN2knDqaROKmQzifrcQgGWky6130JgmNSoXOKNMv0MyYCA2O2gtBZ4qisKfIjKToSdl9kOzNK1AUFaA6/xRWQUJBQUZRzCjlhUTYKxzMN+DvqKGy2g5Z1pBYKpNYLhPqYIOxPBez2YyCCmr1AoAskXf4IMlbttFp7FgO5qno6msD58WjcCcN77ZTmHfWyM5cFbYqhdRSmQ5PfcCae4fgnKInbusRJEmhY/fW/8BRFggEgv82HZu4kVGSY31/tf5GR8+VcfRc2WXbhHnaN5j+NrSVTz3h6K+kqV2KZr5OzBoUwdsbLOagZ3IrOZN7IdVLAp4bFHHZKmRgMd4e1NyLjfEWkSalUEdK4QUhQ6OWqDbKlOiMlOmMuNhrrdtqVBLDo32ZW8tLamQbP66VuzsGsvBgJsuP5dRZ7u9iy4uDIxvVxwO9Qsku01ujpQ6ml3Iw/YLZqEqCpwaE0z/Ky7os0tuRF4dE8sa6BMxK3WNQw7RuwXSqVbWvIbRqFQ/1DuWF1WcA+Hx7Krc098Zeq+bTO1vxwOKTVBnMZJXqWXoku862EvC/AU3xb8AIXSAQCASXx9bWlvbt2tG+XTtMJhMlJSUUFhWTlp7OkeMn2XfkGKcTkiguLUeWr+A/hOX3p4+jhif6uOHrpOHdLUXEplVjlut6AMW0akboeT+fRb+tIDe/4DK9glpSMa1fM7wv87c+yE3D2LbOfLP38kbZ2Xn5LP5tJc899QShTZrQpmUztu3ZbxV6cspNfLCtmNgUHZM7ufKyq4ZPdpSQV2lqlHikUqlxd3WmRWQ4XdrH0C66NU1CQvD0cMfd3R2N5t8h2fw7ZiG4rpQWlxPi74uqaSs+Ns+nOrwVwSG+UCGhwkyUm5E+wRqctCprpJFF0AFnWxW6ShVxP31iKRmoqEBSIak1aF0dMZVXoBgMmKpK0ag1zP11I0F9b6PEqOBnpwKVwvsnVTjLZs5s34xaL2EsLwC0qGxs0Dg5YiqrRDYbQZFAVnP858/wvu0uHGxU52dx/o+EBI4auMVfwmA2sztbhY1GRY6TO6rIHhzOjmdak5mEBwaSl1OIj5/nP3bMBQKB4L9IbZ+jv8vfqIa+UZ442KipMlhuTFv7OxPicWMqi4xpH0AzHycWHDjHkXNllOiMeDhoaeHnzKQuQbQPblyk1VvDm9PM9xxrTuaSWVKNg42a6AAXZvQIYdGhLP44lYcC/JlQwB0xdcPQYwIvHFtHGzX9o679mndXe3+6N3Xnu9h04nMqcLBR0y/Kk4d6h+LpeHl/oxrUKom3hjfn1pY+LD+Ww4msMoqrjLjZa+kQ7MqkLkENng+jYvyI8nHkp33nOJxeSonOaDl3/JwY1yGAfrWEpssxtJUP8/ef40xuJdllehYcOMe0biG0DXJlxX0dWHggiz0pxeSU69EZzHg4aokJdGFCx8BGf14CgUAguDQajQYvLy+8vLxoFhXJoFsGYDQayczKYteefaz9cysHj52guLT+AyLl/H/CPLU82sONM3lG3t9aTPH56J/agoskSXTv1AGNRkNZWRnrt+y47LwURaFTuDeD2gVeVriRJImhLZ3YmqwjPk9/2bbrt+7g4ZnTcXZ2pnun9mzfs/9CRXFJQlZgR4qOEzkGxrV15rkB7ny2q4SUIlPNz9p6uLk40zEmmttu6UfPbl0ICgxEq9U20PLfgaTciCQ8wT9KSXE5uUl5HFm5m8nvvUfrHxYQ2rQ5VXkK9rYSj3dQ08lHja1abT2JFRSKDPDqxgyWPfUC+Qk7kBQFBTUqOw9GLP6CU1+uolyXQs7O/UjocQ9rQ9fPFhPh5ciwJgpdvCRkJI4WmlmXIXE6p5xdj99BScpZQINvv+442AQRMm04u6e8iKkiBZCRJBMuoa0Z9NHnfDssEmdt3a+WwWxmb6HCJycUdGVGHPzV6ONy2Di9J1898zzDJt+JydZEcOjfn+spEAgEAsGNRlEUZi46YU2NGxHtyxvDmv2zkxIIBAKB4DKYTCaSz57ljw2b+H39nySmpGE0mSxhAgpE+9owpIUja+MrOZVrQFEaLk2v0aj55etP6denN4ePHOH2STPRVVfXHxDL9dLRRsuX07vTuolHnXWyyUBV9imoleKmKAoHM6p5YV0hBvOl08sc7O1YOW8O7dq2ZfPWbdz94BMNVnSr2YdWvjbc1tyRdXGVnMw1oEiWHB6NRk1kWBNGDB7A0MEDiQgP/9dEFF2J/x+zFFwVzi4OEOTJUx98imvHzjRvG0XacQMuWpnuLewpr6rGVuVsFY1MZjN7Dsfx+le/sGfZH1RXFiMpYEktU3AIakvTyEgOF7nz4MYXeNmjFSDhGmpPdLgD/bzNRDtrcNBYemzjqcZOpcPX0Zm4EC9KU84CMH35HBbc8jldesdwqEkPKk5ZfC0URU1p6ilW3jOc0jGjefmhiXSIaYZGY/FV0qpU6KvL6RZgy9ZymZJkE006eOPfaRhPfzybsU/cjb2b2996jAUCgUBwY7jUjeN/kR9i06kymjmYXlonpW/cJTyA/kuYZBmNStR4EQgEgn8rGo2GZlFRNIuKYvqke9gVu4dflv9O7MGjSCYdzrYqPttVQrVJrhdlVBtHBweCAi3XvbgziZcUjcDy63VUpya0DHa3LlMUBdlkpKI4j9IyHS72WtQqyTpmuyA7BkTYs+5M1SX7rdJVE5eQSLu2bQkKDMDRwZ6y8op67Wr24WSOnqRCIx0DbHGxV6No7OnesS0T7ridnt274uLy/6+qp7ji3oQknkxj7ecrKTDp6D3nLU7GllN+Jp472tpxKsvEgFAna1nEKr2J79cfYNQdj7J1/gKqK4sttRCBmpSxVrl6clNyGfv9Pex84lckyUzo0DaM/epbZoRL9PfU4m2rsn75XLQqOno7MDYMHv56Dk1v74kKmT1P/sod300i93A6YWlHrMKVhCUlzlipY8O8nxk0eBI//LYDndGi4koS9Apy5FhuNcOjNFSkp5IUW0yfr1+jymxg8exFHD+Y+A8caYFA8E/z008/Wf/21P6nUqnw8PCgc+fOvP/+++j19SsohYaGIkkSSUlJf8tct23bhiRJ9OzZ828Z7/8jGzduZNCgQTd0jBdffBFJknj11Vev2Paf/sz2ppbwfWxGHdFodFs/Wl2HlMBFScfxnfc2vvPeZtT6BX+5v7+LUkM1L+3fxOcn9/ylfnbnpFn3v+OyL6/T7AQCgUDQEC4uLtw2ZDBzv/yU5XO/ZtTwESTqHNGbr/ywyMHeDg93ixCUlJJyyfaKohDs6cjEPhGoVBaTbqNeR0lOKtmJRyjITCY9r4wzmcXkllShN5rPV3OTmNjRBS9H9SWNvSVJ4mxKGgCeHh442F8+NV6SJPQmhYQqR0YNH87yuV8z98tPuW3IoP+XohGIiKObEmcXR1799CvswpuRdByUqhS8QoLJqlDh7yFhU8tZXpagOCsHg6HS4jmkyEioqRGNJBSO6/YQcs8cqmyDMFZtwz7Ijve+n0cHNw9CtKp6X14JQJLwtVdzb7gLUd9+zt3xQ9As+w3zunNUGrJJ0MWfb1lTrc2EgoKkSJgVIznZOXWSQW0lFa3cFaplBdcmTSjITSb+hA+uLTvwxmdfs3PayBt8VAUCwb8ZHx8fBg4caH1vNpspLi5m//79PPvss/z+++9s2bLlH61GIbg86enpDB48mMDAwH96Kv8aWvo7EZdbgdEsE+Bix/BoXyZ1Cfqnp/WPsTbtDE/tXUdhdRVPxQgBViAQCP6/odVqaRsTQ0ybNjyUlsbi31awbM0G0rMshQxqCzeW1xIeDlqr909pWXmD/SqKglpScV//Zni62KKvKqe8MJuqkgJks9HaF0C1wURWUSV5pTrcnWzxcrYnwEXD+LbOfBlbgqxYbYDrUDO2VqvFw1FL9nmjpov9mABCAvwZPXQQY0ePIuz8g8r/7wjh6CbDaDDhorEhXVdK+5c+wlSwk4xFK4l5dQ4nCjQMjTCjcCEVwGwykZVdjr3Wnmq1LYpJweJ4VFP7TEZvMrG8aAVqSY1ZpWfujkWsLLRllG990ag2EhIuGhWHy2yYu/5H7oy6la2VpzHJssV0+3zAm4KEJGlRKSYUCezs1JQWl2HQG7FXq6zGY+28bPkmTkOzAIkz38/H8dbuBLzzKvEjRuJmZ4O+2oCtXeNMPQUCwc1FixYtWLCgftREeXk5Q4YMITY2ls8++4ynn376H5idoDFcrqzuf5Un+jXliX5N/+lp/GtYn5FAYfWlUwkEAoFA8P8DSZIICw1l1v+eYNKEcfz2+2p+WbGa5LQMzGYzakki2F1L/3AHerd2twpKMtIlo4K6hnvSrakD+alx6MqLUGQzisKFNDjlwtgARpOZ/FIdheXVuDrY0DPUli1JNpzK1XOxnbWiKJgvvOGp3m7s9KhgS3IVGSUmzIqCWq2maUgQE0YN587bR+Dvf3P57wrh6CYj+1weh77biUolofrlV45s3sSgZRtwspWoqFaIKzVhkjVUmBXcbdTIiorWXVpzKHUQR1aswVhqKauLAhara+V8xTUJs2Km2yP9qHLrzDMemoal2IuRYEqQPSuyoxj27t2sfvIXUBRLehoyNZFNChIKWmycvGjWfwQ9+vdAe94orEgv42Kj4lCuHmQtfo4G2j3xIutGdaJFv/5IKGz4ejUd7ulDePMmN+jICgSC/484Ozvz0ksvceutt7JixQohHAkEAoFAIBD8i/D39+fh+2cwdvQoVqz+g9jNq+njW0pLHxscbECx11plHO15b6L64pGEo1pPRtIpnLQ1UUDSZX+u1ghIsqxQVF5NepEeO03N79P6bbXns3YkCZp4agnt5MLoGBdO5xnYlu1C91uGc8eIYXh7e//lY/JvRHgc3WSU5Zexev5Gnho7js65KlQ2thg9/EnIMWEyKFRUqvkyoRR3rQoUhapqA3sPnOLkH2swlucCCpICKmvEkXRe2gGVnYovX/+K5dnQ0lHd6Dn52qhYlanw3vRXsHWyRap12kkoqJBRKZbxjGUFxK39nc3b91ButIQUetqq+DFehyLboRjNHMk1Y9Y4YefiScfMKp64625W/PQbRTlF1/NQCgSCm4SgIEtqT3l5w+HNF6PT6XjrrbeIjo7G3t4eFxcXevXqxcKFCy+5zbZt27j99tvx9/fHycmJ6Oho3nrrLSorK684XlxcHN7e3kiSxOeff25dXlJSwlNPPUV0dDSOjo64urrSvXt3vvzyS0wmU6P2BcBgMDB79mw6dOiAs7MzPj4+9O/fn/Xr19dpN3nyZCRJYvv27YwePRp7e3u8vb355JNPrG2ys7N55JFHCAsLw9bWFl9fX8aNG8fJkycbHDshIYH777+fqKgoHB0dsbe3Jzw8nIceeoisrCxru1dffZWwsDAAMjMzkSSJ0NDQOn1d7djZ2dk89NBDNGnSBHt7ezp27MjKlSsbfdwu5vjx4wwZMgQnJyfc3d0ZOXIkBw4cqNMmOjoaSZLYuHFjg33cf//9SJLEvHnzrjje7pw0Jm9ZRpslnxH087s0WfA+3VZ8w6y968mubPhcXplymrGbfiV6yaeE/PweHZd9yROxf5BUWnjV+1tpNPDNqX0MXjOXqF8/JnThB/T5/TvePbKdEr3uqvtriJNFuTyw43c6LPuC4J/fs8z5ty95eOcqEksL6rT1nfc2i5NPWN9/eGwXvvPe5oOjF8oy51ZVMGvveros/5qQn98jYP47tF78KfdsXsqBvHONmlOeroKOy760+h/dsWEhhlqVc6rNJr44uYe+q76jyYL3ifr1Y0atX8BvZ0/V+yFT20dpxvYVbMxIpOvyrwn++T26LP+atPISa7ur/awFAoHgZsPb25sZUyfz0affENbrbtQu3iCpUEsyZrPlvifQ3x+FBiKOJNicWMGLm8qITTdhMDe+cLzBrHAgS+azfQaOZjd8f6UoEOjvB4DJaESNYpmbkxdhve7m48+/Zea0KTetaAQi4uimw83NhZfmPk2TflH427XB564RVOpVZKz4ldbjphFmDx52tuTqTPjaa/Bxs2dEl2as/c6EXqtCQoWsl8+H8lmkI4t8IzHmhal8mmRPU1vFKiZdCQkJRYJIR3jvlA0Pvvcssx9807p1jSylQgW2ajDLeAd70qddBG52akChzCAT5qrFQ2tgX7pE4pqleN02gZh7x7H8qzkUHl/IyfXHcPP0vBGHVCAQ/D/n0KFDAHTr1u2KbQsLC+nXrx8nTpzA09OTIUOGUFVVxfbt29m1axcbN260GnLX8MEHH/Dss88iSRI9evTAy8uLPXv28OKLL7J+/Xr+/PPPS3ornT17lltuuYWCggJmz57NI488AljEq969e3PixAnCw8MZPHiwdR579uzhwIED/PTTT1fcn4qKCgYOHMjevXtxd3dnwIABVFZWsm3bNrZu3cqXX37Jgw8+WGebGTNmkJeXx5AhQzh16hRt2rQBLMLJwIEDycvLIyIigqFDh5KZmcnixYv5/fffWb58Obfeequ1n507d1qPX4cOHYiJiaGoqIi9e/fy1VdfsWbNGk6ePImzszNt2rTh9ttvZ+XKlTg4ODBq1Kg6N19XO3Zqaiq9e/cmIyODyMhIhg0bxunTpxk1ahQtW7a84nG7mNTUVHr27ImdnR1DhgwhIyODVatWsXbtWn777TdGjBgBwLRp03jiiSeYP39+PZNvvV7P4sWLcXZ25q677rrseMvPnuLBnb/XuTU2InO2rIizZUVsOpfEqlvvJdDRYrBZbTYxc/tK1mck1Okno7KUXxKP8VvyST7tOYxRYa0at7/lxdyzeQkJFwlO8SX5xJfkszjpOAtvGUtLd59G9dcQsTlpjNu0CL1ct5xxRkUpGRWlbDyXxIrBd9PKw7dR/RVUV3L7hgWcLav7ECm/upKN5xLZnJnEr7eMo09A2CX70JmM3LtlGRmVpQC09vBlXr87sVFbHpZVGPWM2bSIQ/mZ1m2qzSZic9OJzU1ne9ZZPu0xrME0/tPFeUzbthzD+f01ymZCnFyv+rMWCASCmx1PL2/6jppCXs4Qzuxbh13hCap1VYAnLZpFolapMZvrXjtQFFoGuOHuZMdX+/NomapmbGt7mnqoUF0i7EhWFNJKFNYmmcksU+gcYkdmqYnkQmO9thqNihZRkQBUV+vQ2XhR7duXqG5D8fG7uVLSLoWIOLrJ0Bn15NvoyYvLpFTWEfbEZCrKKzGc3oLeZOZUvoleHjasT60kt9oMkkRuXjozH52MZ7fmOIW5YevnBBLn08ckUEm4BAYyYcoTZJWrGOx1eW+ji5GAgX5qcqpU3Dbybtz8QyxnnqRCkSQUlYRdkDMOIa4E9W/G/VNux9NBhVYtkVttZmVyFZ291Rw9Z8RsMlN0YhfG6goip4+hwmwk/2wOJ1IzKGqgJKJAIPhvYjabKSwsZPHixTz55JN4eHjw/PPPX3G7GTNmcOLECUaMGEFqaiorVqxgw4YNnDx5kqZNmzJ//ny++OILa/uDBw8ya9YsnJ2d2bFjBzt27GD58uUkJyfTp08fdu3axZdfNlyx6dy5cwwYMICsrCw++ugjHn/8ceu6ZcuWceLECe6++24SExNZvnw569ev5+TJk7i7uzNv3jxSUlKuuD8vvPACe/fupX///qSkpLBy5Uo2bdpEbGwsDg4OPPbYY+Tl5dXZJisri8OHD7NixQrOnDlDv379MBqNjB49mry8PGbPnk1CQgLLly9n3759rFq1ClmWufvuu8nPz7f289BDD1FVVcWSJUs4ePAgS5cuZfPmzSQnJ9OkSRPS09NZtWoVAHfccQezZ88GwN3dnQULFljfX8vYjzzyCBkZGTz44IPExcWxdOlSTp48yUsvvcTp06eveNwuJjMzk44dO5KcnMyyZcvYt28fP/74IyaTiWnTplmj2SZOnIiNjQ0rVqygoqLuNen333+npKSEMWPG4ODgcNnxXj242Sok9PBrwn0tOjExsi2etpYqLucqy3j3yHZr+9cPbrGKRhIwIDCcSVHtiHDxAEAvm3lk12oO1hI8LoVRNjNj+wqraOSosWFUWEvGhbexjp9VVc7EzUsoNVy6JPKVeOvwNqto1NbTn2nNOzKlWXuCzgskpYZqXth/IXLr4dbdaO52QUzs7BPEw6270dknGIDPT+yxikYhTm5Mb9GRe6Pa4WvvBIBZUfgurm6EWG0UReHRXas5UpBl7ePXW8bibHNB9H1x/59W0chBo2VceBvGhEdjr7Y8h12cfIKfE4822H9iaSESMC6iDSOaNOeOsFaW6n5X+VkLBALBfwUfP396jZxK8ztfw8vHEu3TumULPN3dGmwfn1NKn9b+vDWuI5Vme97YWs7PR6sp0snUDghVFIUincLyODNzDhux0Wh4bbAn0X62pBTXF40APN3dadWyBQDevv40u/N1eo6a/p8RjUAIRzcdka3DcPVwZuWnv6OgwrV9OBnbjlORkURVYS4pOQrvbqymZ4ADkqxQZjIz6a4RhPq4c/+QAXQe3AsPV3tsvBywdbfD1lbL1OefoOX/PuaHZDu0skQ7twuRSIqiICsySp1/CrKioCgXAgljXCUkWeHrM7a0nvUZ9z/9GFqtGjtfB2z8tbi4etJ7cDTTBwzE3dWBXr26k19tpFwv0z3Ali8OVnH0nJrSjCwKTx8nfut6bKMCkRSFZbOX0SymKW27X/1TZIFAcHOwfft2q/mhJEloNBq8vLwYN24cer2eDRs21Et9upi0tDSWL1+Oq6srP//8M05OTtZ1ERER/PjjjwC8//771uXffvstsizzwgsv0KNHD+tyBwcHPv74Y8LDw8nJyak3Vl5eHrfccgupqam8//77PPnkk3XWZ2dbqosEBwfXEerDw8P58ccf+fnnn3F2vnxJdr1ez48//ohGo+Hnn3/G1dXVuq5Tp048/PDDREdH10v1GjZsmDVtrOZ4Ll++nKSkJIYPH87jjz9eZ07Dhw9n5syZFBcX88MPPwCWSKcOHTowderUetE1fn5+jBo1CqBR4tfVjn3u3DnWrFmDr68vs2fPRn0+WkSSJF577TVrBNXVoNFomDNnTp1jPmXKFIYPH05BQQFLly4FwMvLixEjRlBVVcWyZcvq9FGTnjZlypTLjlVtNpGrs4hOgY4u/DZoAm92HshH3W/jj9sm0S+gKTNadKK3fygAmZVlzD1zyLr9V71G8sstY3m/261sGTGdQUGWJ6RGWeatQ1uvuK+rUuM5Vmg5Z521tmwYNplvet/Opz2HsXXEfQQ7uVrHnXN6/xX7uxQ1aVo2KjUrh0zk7S6DeLfrEP4cPo0BgeFMbdaB20NbYj5vmv5Sh37EePpZt+/tH8pLHfpZI4iaungwKqwlMZ5+rL1tEm91HsQH3W5lTp/brduknx+zId49sp1VafEAeNras3jgOHzsL/wNyK2qYEnyceuc19w6iU97DuPznsNZNvhu6xPtr0/tu+QYL3Xsz6c9hvFd3zt4sUO/q/6sBQKB4L+Is4uLtaqan58fnWJa1/PalSQJo1nm241xNPFx5pv7ezKlXwt2Zyi89Gc5m88a0JsUqk0KuzNkPt9vILEIZnRx48MR3rjZq1lwuAxZVur5IkmSROeYaHx9LRGwWq0WZ5f/XhSoSFW7CTHqjWzZuBskCcmk4JK8k1yTgdLso7j49yHNoGXV0XKaRTpxa4ANCZUm7p04jpLScgLWrMWhrT/pKSn4HKzgwacfYUFROG5qG8xGNVq1jIvWYki2Y9cBfl6+GU2IF117hBAW5QaKipQEA7H70lDnFnL7oG4M6t0BV42CColqk4R7WHOKQyNYNKAXc2Z/TnVfH7w9XOnjEMGoWwfj7upCuVHBy07F2TIDSYV6diYqqGUJY34JZlmHtjwVncGEGonVqzbQbUL/f/qwCwSCfxAfHx8GDhxofS/LMuXl5Zw6dYqUlBRuueUWFi5cyNChQy/Zx44dFq+UgQMH4tLADUGfPn3w8/Pj3LlzJCcnEx4ezrZt2wCsqUq1ad++PUlJSfWWl5WVMWjQIM6cOcOtt97aoGF37969AYtIdfbsWUaOHMnAgQPx9vbm9ttvv+yxqOHgwYNUVFTQpUsXAgIC6q1/7733eO+99+otj4mJqbds61aL4NCvX78GxxoyZAiff/4527ZtY9asWTg5OTF37tx67TIzMzl69CjHjh0DLOLWlbjasbdvt0RnDBgwABubupU2JUli5MiRHD9+/Irj1qZz585ERETUWz5ixAhWr17Ntm3bmDp1KgBTp05l2bJlzJ8/n8mTJwOQk5PDhg0biIyMrCMwNoSdWkOUqycJpYVkVpbRc+W3DAyKpItvMF18glg0cFyd9mvS4pHPP0rt4hPEHU0vpKPZqjW80ekWNp5LBGBPbjpF1VV42F064mlVapz19fQWHYl09bK+93Vw4ok2PXgydi0Aa9MTeLpt78vuz6Vo4+nH5sxkDLKZHiu/ZXBQJF39guniE8wvt4y96v4mNWvPpGbtre+L9ToO5WeyNv1C+p7O3LB3RXZVOZ+ciLW+f7xND5qej9aqITY3DfP549zZJ4hWHhfS9Dp6BxLp6smZkgLOlhWRXlFCiJNbvXFGhdV9wHW1n7VAIBD811Gr1YwZOYxNO2IxGOtGB0mSRF65jtmrTvDevZ2Z1D+S/tH+fL85gXlHstiWoqfKKJNfqTAw0pHx7V3wc1ZToVf4fGcxpdXmBrNqtBoNd40can0Q9V9FCEc3IY5OdiTnZGFj70D86EfI3rAO+8AWaLu2xHBKj8ZJYecZHUfVTmjMBnoG2HCuyoiPkyMTxt3JiIoK8nIKKJgcwNwTEhVmBYwyWgfwtpHRSFBZqeeBIU8xIqQ/J6u28OwrCdj5ByBLEqacHHoExBDuEsrTXzxJ++TVaO1t8LRVU1KtRW9UMMlaVmiiefzLOfjo0/F0d8XD0x1JUlFiAjetis0Z1SxJkinNKsdUZYtZUVA1CUPrrqZoxVx2V2WjdfQmOz8PF5fLP3kXCAQ3Ny1atGDBggUNrps3bx5Tp05l9OjRJCQkEBIS0mC7GrPmy0UmhYWFkZOTQ3Z2NuHh4dbIoEv12RAnTlgMfjUaDRs3buTQoUN06NChTpuuXbsye/ZsZs2axZIlS1iyZAmSJNGhQwfuvPNOZsyYgbu7+2XHuZa5AXh4eNRblp6eDsCTTz5ZLzqqNhkZGXXex8bGMmfOHA4fPkxSUhI6ncVUuebG7FIldf/K2DWfY2BgYIPtaqKproZLnRPBwZY0qczMCylggwcPJigoiG3btpGRkUFwcDALFy7EbDZfMdqohk96DGPi5iUU6XUklRWRdHofX5/ehwTEePpzd2QMEyLbolGpSC0rtm4XXSsixzp3F3ectbaUG/UoQFpFyWWFo5TyCx5BbTzq91d7WUp5cb31jeWtzgNJ2FRARkUpmZVl/HjmED+ej5xq5ubFmPBopjbviING2+g+D+dn8UvSUXbnpNfzOoJLn28mRa7z/sf4Q0xp3gGt6sKPhMzKMuvrXedNry9FYklhPeHIXqPFy86xXtur+awFAoFAAH169aRd6xbsP3qi3t91SZLYm5zHol3JTOoXRYiPMy+Pacew5GC+3RiPg00lT/d1oaWfLWqVhFlWWHi4jFN5hgZFI0mS6BDdij69ev5du/evRQhHNyFOzk4YTQZ62fuxd8OfSFobtDYSjv6+lB2rwrWkjGKzEaOPiR/K1DR3M2GjUXGm3IAiS+j0DixODySzQg2SRNbeIwR1jibY3siAENCoNbz7/mxC7P34JXsDtloHmroHIJeYUBQJW7cgjhalcKAgntYqX774+AtefOM5RofpWZWmIqdCTfaBk2i6xPDNMRNBTv5M87GlSK9CK5tw0apJq5T5/qSEvgpKMg0oahlZktAFO6JyMKGozGRt2MBA13YkV6Th4up05QMjEAj+k0yaNIlly5axZs0aFixYcEmvo8aIGDVmjDVm11dT3aw2L7/8Mo6Ojjz77LNMnz6dAwcOoNHUvSQ//vjjTJgwgRUrVrBu3Tq2b9/OwYMHOXjwILNnz2bXrl0NRsHUcK1zUzXwA7Vmv/v169dg9FINtQ2tH3roIb766itUKhUxMTGMGTOGli1b0qVLFzZu3Mjbb1/6h/dfGftKHnwXH+fGYGdnd9n1NSH0YDl+kydP5s0332ThwoXMmjWLn3/+GZVKxb333tuo8Tp4B7L3jgdYmnyCdekJHMg7h142owBHC7M5WpjNpnPJzO9/Z6MEhdoVaKQrlLaoLZY03NcFGu92WJ8wFw92jpzBypTT/JF+hticdCpNBgDOlBTwxqGtrEqNY9Wt92KnvvJnNuf0fl4+8CcKFpFmSHAUXXyCCHRyYcb2lY2ak7+DM9lV5aSUF/Nj/CFmtuxsXWeu9ffBTq3BWduw4T2AXq7/3XPW2jTQ8uo+66vxlxQIBIKbFUdHRx67byrT/zeLKl19rz1ZUfhpeyIxoZ60a+qJRq2ic5QP0cHO6HLisFFZ/p4risK+tGpWnKxAUZQG/8ba29vxyH2Tr+hN+F9ACEc3ITa2Wro4RjL7l7fwHt4Dyc6bgFtvR63TYCwtQrZRoaBgLtVjcHbg0/1VDG1hh4+dhoxyhbmHZBRFjWKWyT2ZhGIEfVk12mAtXrYWdVZXXUW6XR45WbmoJBUV5XYU6stBUuNv60quoQxFkXHz0tBar0OjkvBxkvB0MJJWacas05N/+DSe0RGklap4dUc1T3bX4G6r4UyxmRUnK0HviLm8ClO1CY2TGn1hISZ/NY79AqlelE5VlYGF6+bwfL/H0Nr+t0MHBQLB5WnVqhVr1qypFxFTmxpRIjU19ZJtajx5avLc/f39SU1N5dy5c0RFRdVr/+233xIQEMDw4cOtyzp27Mhrr72GyWRiwYIFHD16lA8//JBZs2bV297Hx4eZM2cyc+ZMZFlm9+7dPPnkkxw8eJB3332X77///pJz9fe3GDaeO9dwGfKEhAR27dpFp06diI6OvmQ/tfuaMGEC06dPv2xbsHhOffXVVwQHB7N+/fp6lcyWL19+xT6udeyaSKO0tLQG19dEJF0Nl9qm5ly5OKprypQpvPXWW/z222/ceeedHDt2jCFDhlwyCqohLKbUrZjeohN6s4ljhdnszE7lk+OxGGQzG88lcqggiyCnC95VJwtz68+xrJgKo0WQUUkSTZzdLjtukKMrJ4ss/ZwoyuG2Js3qrD9RdMGz6+J0rqvFVq3hlqAIxkfGYJJlThXnEpuTzuzjuyk1VHOsMId16WeuWA2uRK/jzUNbUbD4D+0YeZ814udMSf5lt63huXZ96OHXhGHr5gMw+/huxoZH43bepNrf4UJkc1ffYBYPHF9ne7Mso76MiGdzGUGusZ91R+/Gnz8CgUBwM9Ovb2/uGnYr85etbDDqqFJv5KNVJ/h8ejc8nC0Pf2y1aswaCWRL+7xyM1/FlqA3yZeMNhozbAj9+lxbSvbNhoh7vQmRzQrvLH8HY1MbFBQUg5GgiSOpPFlB/tbvQKNCURQq84pQTJCQr2XhSSPL482sOGXGZASz3sip+d9QXVqJm5MjZrOCr8pEtIcGFfDWuy/z8DOTCGvij6Q2MtG7PyokUMyM8+iDWiMTFRnMI69P5p0PXgcJWjjZ4CaBYjLjorWlurScxGULUUwyJoOKVWcMLI0zs/yMTGqOgqRXKMnJRzaZkCUTmWt/wCYpjaAJ7TEbjShImN1VvLTsHcwNPN0TCASCGhITLR4vNalFDdGrVy8kSWLjxo2UlZXVW79161by8/MJCwuzCgU1fjVr166t1z4+Pp7777+fl156qc7ymmgljUbDN998YzVtrpkjWNKy/P39rb5LYIlk6dWrFy+++CJQPy3sYjp06ICtrS0HDx6sVzkN4Mcff2TatGls3rz5sv2Axd/pUvsJ8NlnnxEdHc0bb7wBwJ49ewAYPXp0PdHIbDZbx5TlCylCl4qmuNqx+/fvj0qlYtOmTfUqmwH88ccfDe/kZYiNjbVWTqvNb7/9BkDfvn3rLG/atCl9+/bl4MGDfP7558CVTbFr2JOTTu/f5xC28AOG/PETFUY9tmoNnX2CebJNT0JqCUVZlWUMPm9+DbA3L4PfUy9UjTOYzbxy8MLn2903BPfzQsilGBx8ob/v4w6SfL66GkCeroJPjl/wAhoaUldUaixJpYUMWP0DTRd+QLcV35BTVY5GpSLG058HWnWhreeFKjVZlReOu0q6cNtqrHXuJJUVWSu0qVUqXG0uRIgtTb5g/i7TcFRhoKMLj7fpQSefIIYEWwTgYr2O2cd3W9t08w2xRljF5qRbxTWAU0W5hC38gD6/f8f9O1aiM9WvytNQpNfVftYCgUAgsKDRaHj28YfpFNPwgy9JkkjIKeWbDfGYzHK99QaTwjd7SjhXarrk/UfnmGieffyRa4pUvhkRwtFNSH5WIWcN+ZRkFiEhoeir8GvujqmwipKT63ByUSGbjGhcjRiKypGNEkXlKlIKzeSVSWCGjP0nKDq1GVlfjNFkxMHZju3pthjMCmYFJJWKBx6ZzIFj69m6bSnrIswokuVL+nukgV2xq9h7eD3TZt6LpFIhK6A3K+xOU+Gk0qCSQdGVkrnzZ/KPxaNWaUjM1ZCYI3OuQIUKLVWFJai0ZjCa0dpBadx2VCYdo0ObYDDIqBSJ4vRCThbkkZ1R/0eRQCAQAKxcuZKVK1ei0WgYM2bMJduFhYUxcuRIysrKuOeee+qIDmfPnrVGuzz88MPW5Q899BCSJPH6669z5MgR6/KKigoeeughwFKi/VJ0796d++67j+rqambMmGF9ahYSEkJOTg7PP/98HRHLZDKxePFiwGLYfDmcnJyYPHkyRqORqVOnUlVVZV1XI2jY29szevToy/YDMHbsWPz9/VmxYgUff/xxnad7+/fv5+WXX+bkyZPWimU1aWObN2+uM25VVRUzZszg1KlTAFRXXwgxr0kHq6ioqCMoXe3Yvr6+jB8/nuLiYqZNm1bHgHv27Nns3Lnzivt7MWVlZdx3330Yaxlxfvrpp2zatIkmTZo0eAxrzLK/+OIL3N3dGTlyZKPGivHyJ19XiUE2k15RQt/fv+eZPet4ft9GBq2ZS9J57x6NpKK9VwChLu6MrmWIPXP7Su7+czHP7l1P/9Xfsz7DYg5to1LzYoeGDcZrMzK0BeHnI4nKjHoGrpnLAzt+57Hda+i76nvSK0oACHZ05b4WnRq1TxcT7uKB0WxGZzZRbtTTf/UPPBH7By/u38So9QvYnn2h2l5nnyDr69rpXr8mHWPW3vXMTziCb63qZzqTkaFr5/H8vo0MWzufz0/usa6rbkDQASwPvs7zQvu+qM//iPgx/hCp532cgp1cGXo++sogmxm6dh4P7vydZ/eu566Nv6CXzcSX5GNWFOwb6ct0tZ+1QCAQCC7g7e3Nh6+/SERow16OCgqrD6ex+XhmnXsHRVFYF1fBjrO6BreTkIgMa8KHb7yEl5dXg23+iwj57CbEp4kX1Xo9VRnVqFAjy2Y0DmpMtipMBh3hUS7sTcvFxqyl4MQZnFtG4uLkTHGlCoNJQV2hw1BVjW+nCZxZ8Ai2nmG8EPIa2/w6MWuHkXEtZHwdNQQ6aLBxcMIhqh0Rj7TFiCMVZcXEPP4J2iYqNHZqdGY4pzOSWQmrE0CFigGnU3ljzXuUnDtB08GPoSutQl9agcbRgXKjgo2NieqSSnLOpGDn64piMBLoq8FsLEejVTHBx52XFTUaJCqzyjBpqvEJCv2nD7tAIPgHiYuLqyfQGI1G4uPjrRW0Pvjgg8t6AoEltSwhIYFVq1YRFhZGr169qKqqYtu2bej1eiZMmMDjjz9ubd+tWzfeeOMNXnzxRTp37kzv3r1xdnZmz5495OXlMXDgwMsaOgO8++67rFy5km3btvH9999z3333cf/997No0SJ2795NaGgoXbt2xdbWlsOHD5Oenk7z5s2v2C9YqrIdOHCAP/74g9DQUHr16kVxcTE7duzAbDYzf/78y0Zh1eDg4MCyZcu47bbb+N///scXX3xBmzZtKCwsZPfu3SiKwuOPP24VR+666y5effVVTpw4QdOmTenWrRt6vZ7Y2FhKS0tp1aoVp06dIifnQtqTt7c3bm5ulJSU0L17dyIiIliwYMFVjw3wySefcOzYMZYsWUJsbCxdu3YlOTmZI0eO0K1bN2tEVGNp164dK1euJCIigs6dO5OUlMTRo0dxdXVlyZIl1iiy2owePZqHH36Y0tJSJkyY0GCbBo+1Rsv8/ncxdtMiKk0GMipLmZdwpE4bCXit0wBrmtoHXW+lsLqKbVkpKMCfmcl12tupNXzeczjtGiE+OGptmNtvNPduWUZqeTGVJgPLU07VaRPk6MKCAWNwtmncPl2MJEnM7Tea2zcsIE9XSWF1Fb8kHqvX7oGWXehUSzjq4hvMnLgDAOTpKpl75jBjwqO5N6odI5o0Z1VaPACJpYUkno+U0qpUaFRqdCYjRXodJXqdNf2sIaLcvBgb0YZfEo9hkM28dWgr3/W9A4D3u95KYmkhZ0oKqDab+O1s3ePSwt2bd7sMbvRxuJbPWiAQCAQXaNG8OV+9/xYzn3qe1PRzdT39JAmjWebTtadpHuhGsIflmpWYb2TugTLMDfgaSZJEWHAQX3/wNs2bXVtU7c2KiDi6CXHzdKFpyxDs3RzQokUC0g8loNhLIKmwU1IoTzpO+YlSZFmm+HQC5rJM3B3NmI0SecnnUKlUaN19Cex0L1VZcXz68jSic4vJq9Ly5REN7++XeXS7ice2mnk1FmQkXIMjcfIOwqzS8NY+FU/tkHlih5l39ip8c0RFWpmKdrl6vvzmPgqSD+IXMwzHgFYgqck5nYZskkEBQ34GWQmpKEB1bhklZ47hr+SgYEbnZKbwdClIoEaLnZM9kR3C8A3yvtJhEQgENzF5eXksXLiwzr9Vq1ZRWVnJhAkT2LFjR6OEFh8fH/bu3curr76Kj48P69at48CBA3Tv3p3FixezcOHCeubRL7zwAmvXrqVfv34cPnyYtWvX4u7uzhtvvMHq1asbNJuujbu7Ox9//DEAzzzzDNnZ2djZ2bFhwwZmzZqFr68vW7duZcOGDTg5OfHCCy+wb9++K1ZVA3BxcWHnzp28+eab+Pj48Mcff3DgwAH69u3Lhg0buOeee67YRw3du3fn6NGj3H///ZandevWkZSURL9+/VixYgWzZ8+uM+7evXuZOnUq9vb2/PHHH+zbt4/27duzaNEitm3bhiRJbNiwwRrFo1Kp+OWXX2jRogVHjhxh48aNFBcXX/XYAF5eXuzatYtZs2ZhY2PD6tWr0ev1/PDDD8yYMaPR+1xD+/bt2bJlCyEhIfzxxx9kZGQwfvx4Dh48eMnIL3t7e2u1vMamqdXQySeInbfP4IGWXWjh7o2rjR1alQp/B2eGN2nOyiETmV4r2sdRa8OiW8bxda+R9A9siredIzYqNUGOLkyIjGHL8GmMCG3R6PGbuXmzZfg0Xu04gHZeAbja2GGv1tDMzYsn2/Rgy4jpNHf/a9fdcFdPto+4j2fa9qKNhx+etvZoJBXedo7cEhTBvH538mqnAXW2GRrSjGfa9sLfwRmtSkXg/7F31+FRnFsAh3+7G3cPgQARIgRCgkNxK+7u0mKl9CIFilNaHAoVrFiLFClaoC1t0aJFkk2wAAluEQhx3b1/pFnYJkixQPe898lzyc7MN2fmbJPM2U8sbXS9o76p0YLRZWvhY+uIqVKFg6k59d1LsK1Rd92QOi2w81rEU2MbGVQT878n5P7p6nmOR+fME+ZoZsGvTXszumwtAh1csTQywdLIhJL2znxSthbbG/XA8Qkr1uXn3+ZaCCGEvrLBQcyfPpkihV3zLQRFJ6Qwb/tp0jKySErX8vXB+8SnZee7r3vhQnwzfTJBZZ4896MhUmifZRkZ8dbJSM8g7VYSvl41SFSkYlm5Cn5TvuJo/fIUK1Uam2LtcSvjT/StFDKNlWg0UCTYGWMrb7SxV7hx6S5KhQaFVkP63Utc2f0NPmZ2tG03hTuVy3LPzpwMpRKFVotJeiYO5y7x/Yx2aDTZdJ2wifSS/qQbGZGNApVGg/2DdNxPhPHzhk8JSb6OZ+2+WBYLQqMwQqtUUaioA9jbk3rzNPGx5mRla1AqQKnJJvn0cUg5TFTICTpunc+NmdM5cuQW5lpzrpzfD84m2DrYFPQtF0IIIXSio6Nxd3cnMDCQkydPFnQ4QgghxH9KbhkjtwB08PARBo0ax+3o2LwTZgMD6/lw/14Ma0Pi87SlUCgo5OLEwpmfU61q1XzbN3RSOPoPy0rPxN+sEgE2buxKiqDdtVP8WDQIBVr6LvyRExuXkXhHiVHF1mg1Kq78PJnZv+7gwPZfOXurEFptFgq0KNCiTU/mxp8ryLgRRpBtCbyLlMLCvhBZWencvn2eYzeOcz8jDS1gZ2JGJfcKFHH2wcLUgtTE+1y4dZpT989jUiSQYtW6obS0Q4sSjcIIhcKIEm4PcKz4Dmu6N8Or/TSyMrPIvBpCckwUDXu2Z+WQHmgVWv6ImEsDv+E0sirFiaQbXE3+C6Wp6qmf6AshhBCvWlZWzkINmZmZ9OjRg40bN7JixQp69epVsIG9QvtvXebA7Sv/6pjuvsF4WD+9x5wQQgjxOLdu3+bPQ0do17olKlXOypV79u1n8NhJxMTeyzOvkYmRCo1WS1a2/ipqCoUCFydHvp46SbeCWnZ2Nlt+2kHliuUp6u6OkMLRf1r01Rh6lOzB1InDqTZmIEXbNeHapl/I1qThXLQYto7+XD99hJFTv+XrJV+h1FgRUNqciItK6vfuzYlDZzBzcEOryUJpbIQCSL55jntnd5Ny9xKazBRQKjC2sMW6aBDGTp4oFEoy428TH3WcrOT4nMKTiTmWrp44l26IhZsPWi1kZ2SiMDEl88Fd3H1KErptAT4+dlxSXyULWxoPHcj64d3xLl6R2AcXuX/nJsYWRlQs587RQ9c5NGgpQ5fPYMOZ73H1cCnoWy2EEEJw4cIFSpXKmag6KyuL4OBgjh8//p9ekWVW6AFmqw/+q2M2N+xKtULFX1FEQgghDEHU5cu07P4+A3t0pl+fXhgZGaHVavnt9z8YMuEz4u4/yNPz6J8UCgWO9rZ8+dkEGtSvh0KhICsrixWr1vDVspVsWrEIXx+fJ7ZhKP67f8kIom/F0rtnF0r2qELRT+y5sfEXjGxsyY7PIPb6dcxMrNBkZ7J01nD8fRtwJjKUgz+FEdikH2e2fUnKLRWmtToTf/YAloX9MHEphnnR0hTzKIONSQba7GSyFUaYWNuRpTRCaWKJkUKJUXYmmowupMbfBzJRGFmRkWWKRqNFg5bkW9dIvR2JY9la3Dv+E0a3/6REaTeO/rAaO7cSFC9eit0zRkBWFvEPLnH/zk20KLCyM+fIwet4YkvpkRUZbNqNqHPXpHAkhHjlvvvuu3znqVEoFNjZ2VGiRAnatWvH//73vzyTIHt4eHD16lUuXrz41Mm5X4Z9+/ZRp04dqlWrxsGD/+6BXujLzXvXrl1ZvXr1U/cvVqwYhQsXJiYmhrp167Js2bLnKhqF777Ez1/lLAVftLQrXaY0+tdtCCGEEP91ySmpTP/mW9LS0hg8sD/Gxsa826A+MzMzGT5pKvEJiY8tHikUCuxsrJk14RNd0SgzM5NFS5cze9EylEoV0sXmISkc/Yf5lS+BW6FCxF24Tzv3ynx/4xBx8fEoUIAWbl06Byi5G30Xv6LxpESfQaHRcvbnJWi0GlwKBeB05ypXrh6nRGB1rql/xzy4EVpU9G/rjYebOcWdLDAzNiI6MZ2L9xVkZmRRpogZjhYq0jKziYxNIep2Ogt+uIRKoeD+sXU4VWnL3dAfcbtfjMz4u5yJPI5SpUWLhqToSFTuXty9FoUCiLlzHf5eJjf+VhLOWNOhyDvEnrxNg4+aYOr87yahFEKIF+Hi4kKDBg1032dnZ3P//n3++usvRo0axbZt29izZ88zr6Al/lvMzMy4evVqQYfxWo0IrsmI4JoFHYYQQggDk1sQSk1L44tvvyM1LY2P/zcYU1NTmjVpTEZmJqM+n0lCYlLeOY8UCmysrZg2dgRNGzdGoVCQkZHBvG8W8vWK1aSlp2NlaVkQl/XGksLRf5ixiTG3Y+5y+fxlBs3/iL9anuEkGaSiQUsmbsZ23M5MwtjWnj9PbsfI2IaM7AQ0GgAF0bfPkhA3myCPRtw+sAxTi+IYH/8FKjRhxo+3eb+JC+6OVliaKvEys8DLGUCLEgUaLWRpIfxGOqvXR2GRBUbhv3MlLZH0P5fj6+xN+JZZpGWkAwqys3POaaw04+SJn1FaWEFKCq7GttzNTAQUWGJKIE70XfwRf50+h49bCUoVe/ZVYoQQ4kWVLFky354niYmJNGrUiMOHD/PVV18xYsSIAohOCCGEEMLwpGdkMP+7H0jPzGL0sP9hbm5Om5YtyMjIZMy0OSSnpOhNdm1pYcHno4bRpmULFAoFaWlpzJj7Jd+u3kDG36u9Ak8d6mZIpHD0H1e6kj8BFXwJO3KObiVqkHxpP6e5TRaZNLOtwJLYvWiy0zG2syUjPh7InWRagUIBaRmpRFz/k/vpD3i3aiEOhe6hflICZhW6snT7XbYdjqdmkDnlSjiiQIFSARrggDqO89cyuHs1nuJJWZiHbmNd1A78arci/JcNJJlZkP530SjH3xXjrBRU1g4YkU4WWlq4lOfbm3tRoaKkwoF2vrW4bZ5Is2GNMTKWt68Q4s1gbW3N+PHjady4MVu2bJHCkRBCCCHEK/TPok5mVhZL1qwnNSWVSWNGYmlpScd2bUhLT2fSnK9ISUkFwNzcjInDPqRD29YoFApSUlL4fNZcVqzfSFZWtl77Ujh6SJ68DYBSqaRQMScqL+4A7VKZdP8PYknjveItcgpHyYkUGjGU+0d2kXLwHFqtAgVKlEolChsn4u/fBQX8fngnjjaubL/wEzVjbtC+ZHfOerixKzqJn/fdBwVoNRoUGjDO0OCRkE2F27fYe3Yl++LOYG7lRNgv61AACWmpGLu4kXU/Fk1mBvxddLIMKoll1WBiF61Gi5a+RVuz5OZeCiusGGhfl8BvmuMR7C1FIyHEG8f971U3EhMTn2n/1NRUvvjiC9atW8elS5cwNjYmKCiIAQMG0LVr13yP2bdvH/PmzePYsWMkJibi6elJp06dGDJkCJZP6VJ97tw5atasSWxsLF999RWDBw8GID4+ns8//5xdu3YRFRWFkZERpUqVomvXrvTv3/+Z5ujRaDTMnz+fNWvWcOHCBdLS0vD09KR58+aMGDECR0fHPMds2LCBBQsWEBISQmZmJr6+vvTq1YtBgwZhbGycZ/+LFy8yZcoU/vjjD6Kjo3FxcaFRo0aMHz+e4sX1J1r28PAgPj6eu3fvMm3aNNasWcO1a9dwcXGhdevWTJw4Md+YnmT//v2MHTuWU6dOYWVlRYMGDZg4cSK+vr4AZGRkULhwYeLi4oiIiNC9/qhGjRqxa9cu9u3bR61atZ753OkpGfz5QygRB6+QlpyBY1FbKrYoRanaXvnuH3XqJqG/RnD7UhypD9IwtzGlaClXKrYshZuPk96+B9eGcmidOie+QVVx83Vi/8pT3DgbjdJIiXf5ItR9ryIWNmZcPHaNIz+GE3P1PqaWJnhXcKd2z/KYW+cdmnn+0BVO7TzP3ah7aDVa7NysKVndgwotAjA2fbbf4Qv7biQhOhmAzp83pFhgoXzjLl3Xm6b/q67bFn8nkSMbw7kWfoekeyloNFosbM0o7OtM5dalKOznnOdcWRnZnNxxjjP7orh/OwGVsQoXT3uC3/WlZE1PvRV4roXfYe24XQD4V/egVG0v9iw7TkJMMtZOlnSc3AA7V2uuhd/hxPaz3L4QS0piOkqlAmsnSzyC3KjaPhBrRxkGIYQQzyu/mk5WVjYrN20jNS2NKRPGYGtrS48unUhPT2fqV4tQKGDM4AF079IJpVJJYmIiE6bOYO3WnWRnZz/bSQyUPH0biEJFXYm+EUODTf1QdTFj6J2VeKQXw1ZpygNNGknxF7Ho1xFN+OekPtDk/Deiycal3UBur/gUbbYW0BL34A6g5MC9Uxw/oqbG6TJUcwrG1LEo2aaWaFQKzJLTyIy/SXjcSWYmhJGclQUoSU28hyJnhiUUCg1u/YZxbcowQAEKUNoYYzmpNdrtx9FqVViqFHhnOGOKkqmOHai6vj1ZbsbYONgU5K0UQoh8nTx5EoCqVas+dd+4uDjq1KlDeHg4jo6ONGrUiJSUFPbv38/Bgwf57bff+O677/QeVmfNmsWoUaNQKBRUq1YNJycnjhw5wrhx4/j111/5448/Hju3UlRUFPXr1yc2Npa5c+fqikapqanUrFmT8PBwvL29adiwoS6OI0eOcPz4cb777runXk+/fv1YtmwZjo6OvPPOOxgZGXH06FFmzJjBtm3bCAkJwczMTLf/gAEDWLx4Mebm5lSqVAk7Ozv+/PNPhg4dys8//8yOHTswMTHR7b97925atmxJcnIypUuXpkqVKly4cIFly5axZcsWfvvtN8qXL68Xk0ajoVmzZuzbt4933nmHgIAA9uzZw9dff83Bgwf566+/nnni6qNHj7J+/XoKFy5M06ZNOX/+PD/88AM//fQTu3fvplKlSpiYmNCtWze+/PJLVq5cyeeff67Xxq1bt/jjjz/w9vamZs1nnxMoPTmD1Z/8QuzVeN1rdyPvsWPun2RmZBH87sMClVar5ffFxwj5JUKvjaR7qZz78wrnD12lds/yVGpVKt9zXT9zlz+W/EVWxsM/ns/siyLm6n383vHgzzUhutezMlIJ+/0idyPj6DG7KUqVUrft98VHOfWzfgwxV+4Tc+U+5w9dpdNn7+ZbbHoZYq/Hs3rUL6QnZ+i9nhSXwoUjV4k8fp224+vhGVxYty09JZMNk37nVkTMI9eXzfXTd7l++i6XQ2/R5KNqev895oq+cp+L0/eRnaUBIDtLg62LFWcPRLH9iz9zO1QDOT2y799K4P6tBCJP3KDrtMbYOEvxSAghnk/+PYI0Gg0/7txFeno60z8dj6OjI+/36kF2VhZa4L2e3VGpVNy/f5/Rk6ew5Zc/0OTM1SKeQPn0XcR/RZmqpbmjTOLdre8xqWhnrpa+y2fF3scEU5K+/wXTOplU/6EbCmVOIUejUJBmmYp92/YoFFpsvOzIecsoACWpGi2/PVAzJ/I7Zv71GfMOjuWrA6OZenIi0y8tZue9U6RkZf9dKsphWsgEhQJs69chy0qDFi0oFCgUWRTb0B7PMtnEfr8bY1RMLdydO1VS+NS3DTW3dSfJJhvPkrJ8rxDizZGdnU1cXBzr169n2LBhODg4MGbMmKce169fP8LDw2nRogVXrlxhy5Yt7Nq1i9OnT+Pl5cXKlSv55ptvdPufOHGCTz75BGtraw4cOMCBAwfYvHkzkZGR1KpVi4MHDzJ//vx8z3Xjxg3q1avHrVu3mDNnDkOGDNFt27hxI+Hh4XTt2pWLFy+yefNmfv31V06fPo29vT3ff/89ly9ffuK1XLt2jWXLluHr68vly5fZsWMHW7du5fLly1SpUoXz58+zbt063f7fffcdixcvpkyZMpw9e5Z9+/bp9m/YsCG///47kydP1u0fFxdHx44dSUtLY8OGDYSHh7Nx40bCwsJYvHgx9+7do0OHDmRk6BcKEhMTOXPmDKdOnWL//v1s27aN06dP4+DgQEhICLt27XpqnnJFRkbSoUMHLl68yI8//kh4eDiTJk0iKSmJXr166f5w7dOnDwCrV6/O88fs6tWryc7OplevXvkWIB4n+vJ97t1MwL+6B2Ub+2Fm9bCgdvTHcL19j/90Vq9o5B7gQtnGfrh6OwCg1WjZu+IEEYfzn8D7zL4ojExUBDf0pXiQm14Mf64JwcLWjLKN/XAPeLia6d2oe1wOvaX7/vTeyIdFIwWUqFSU4Ea+WDla/N3WPX7/9tgzX/+/dXhDmK5o5OBuS9nGfpRvVhJHd1sgp7Cza8ERtJqH+dm97C9d0cjYzIjSdb0pXccbIxNVzjXtiUT928V8z3fvxgNQQGC9EvhVK06pWjm9k/YuP6ErGhULLET55iUJetcHc5ucgllCTLJeIU4IIcS/86TOQBqNhm2/7+WjUWOJjo7GyMiIgf3e54N+72NkZERsbCxDx0x4atFIhqo9JIUjA1O+VjB3MxLp/NNQMlKg69BevKN0xyTdhAetV3C5WlHKdS6fUxvSannw7VfUmvUxKKBK/2By/gpS6L5y/qciCyVGVubYujqQpVWg1SrR6vbLpaHUh+UADe/On8zdyZP+Pl6Lc/tilKvhyLWW32OWpaKSshA9P3yfGIcMem4fSZpdNiUr+L3u2yWEEHr279+PQqHQfRkZGeHk5ESnTjndoHft2oWHh8cT27h69SqbN2/G1taWVatWYWVlpdtWokQJli9fDsDMmTN1ry9evBiNRsPYsWOpVq2a7nULCwu++OILvL29uXPnTp5zRUdHU79+fa5cucLMmTMZNmyY3vbbt28DULRoUb1ihre3N8uXL2fVqlVYW1s/8Xpyz+vo6Ki3r7m5OV9//TVLliyhSpUqutdnzJgBwIoVK/TulY2NDStWrMDExIRvvvmG9PR0AJYuXUpcXBwffPAB7du31zt3v379aN68OVFRUWzevDlPbJ988gmBgYG674sXL07Lli0BOH369BOv61F2dnbMnz9frxfUhAkTCAoK4ty5c+zduxeAMmXKUKFCBa5evcr+/fv12vj+++9RKpX07Nnzmc+bq/mwGrQcUYt3B1Sh1ajautcfRCeRnpIziWdmehaH16t122p2L0fXaY15d0AVes5uRnCjhz2T9q44ke8fw0qVgq7TGtPwg6p0mvwuLp72um3GZkb0nNOUdwdUocuURjgWtdVti7vxQPfvo5seFrMaDqhC27F1aTiwKu991UJXPDp/8AoJMcn/+j48i/g7D4eKthtXl3cHVKF+30r0mtccv3eKE/SuDxWalyQjLee+Jd1L4fSeSABURkq6zWhM0/9Vp+mQ6nT6vGHOh2nAX1vPPPactXtWoMlH1Wg1sja1epQnKyObpPs5c2lYO1nS6bN3qf9+JRoNeofuM5vgWbYwFZqX1CvOCSGE+HeeVtTRarX8/ucRBn38CdHR0SiVOVOxxMbG8uGIMfy858CTi0aP6dFkqKRwZIDK1ChNslk6xh3cuFnxHnP6fEKgwgVOxPFgwAZsv6yOjasJWgVkp6VwfOg0bLz9uf7HZey8Lf5uRTfoTFceWr5qFqs2fgvkFo3+/g/u73+ZFzYm+VgsFp7FODnhKzQpyaDVYuxiRNNF9bnVYw8J4fGUxpkvuo8hsnIiqd7GpKoy8QiQnkZCiILn4uJC165ddV+dO3emWbNmeHp6kpycTP369dm5c+cT2zhw4AAADRo0wMYm79DbWrVqUahQIW7cuEFkZM4D7b59+wBo0aJFnv3LlSvHpUuX9ApNAAkJCbz77rtERETQuHHjfCfszh0yNXPmTDp27MgPP/xATExOz4tWrVrRrVs3nJyc8hz3qNKlS+Pg4MCRI0eoXr06X3/9NRcv5vTOqFChAu+//z7+/v5ATpHp/Pnz2NraUq5cuTxtubm5ERQUxIMHDwgJyemNkVuUqVOnTr7nb9Sokd49etSjBatchQvnDFFKTn72wkWTJk2ws7PTe02hUNCsWbM8587tdbRy5UrdaydOnODs2bPUq1ePokWLPvN5ASxszfCv5qH73s1XPx8ZqTm9ay6H3CI9OacYYuNiSeXWD4ejKZQKavesoJtb6EF0EtGX7+U5l5uPE07FHl6nQ5GHxSGvckWwcbbStedc7GFRKTM1C4Ck+6nEXc8pIqmMlJRp4KPbx8zKFN/KOdeu1Wi5Gnb7Ge/Av1PI++HcVatH/cLPXx/i9N5Iku6l0GpUbRoNeocKzQMwtcgpAl47fVfX+8g9wAUXDwfd8UX8nHU9le7fSuDB3aR8zxlQ01PveyMTle64xNhklg7ayp4Vx7l47BpmliZ0mNSAeu9XonQd75d34UIIYWCepaij1Wq5n5Ck1ys5IyOD+wkJUhT6l2SOIwNVzL8oxfyLkpacRvQHpoxL78/UVYs5t+4aV5W/0OLnNqyttBpNloqbm7fgUqYc5/acY/Lv3ZlYdxVarfKRspEWL59iFG1wi4WpjahSNYgjR9T6/QcVGtov6cSqlt/jXLYyUes2AqA0ghZbmnJl4EnObLxMEI78r30vLAaWwMbNFt8qJTA2zTtJqhBCFISSJUuyevXqfLd9//339OnTh7Zt23LhwgWKFSuW7363buUM63lSzyRPT0/u3LnD7du38fb21vUMelyb+QkPz+n5YWRkxG+//cbJkyfzzANUpUoV5s6dyyeffMKGDRvYsGEDCoWC8uXL065dO/r164e9vX1+zetYWFiwceNGunTpwqFDhzh06BAAXl5etGzZkgEDBugmir527RoADx48eOpwrevXr1OlShXdMW3atHnq/v+UX+y58xr9m/kMHper3CLQzZs3da916dKF4cOHs3HjRubPn4+5uTnff/89AL17937mc+aydbHS+/6fE0trsnN+196/naB7zcXDQW/OIQBTC2Ps3KyJuXL/7/0TcfXSnyD8n5M1GxmrHsbhqh+HkenDbbl/fCfEPCysZGdpmNVm1WOv69FeSs/j0aFmj6reJZib52OIvnyPlAdphP9xifA/LgE51xBQy4uKzUtibpMz51Zi7MMC4tWwO8xo+f1jzxl7Iz7PfTA2NcLC1izPvk0+qsbGz3aTmpjOvZsJ3Lt5luNbz4IC3Eo4Uqa+D2Ua+OTJkxBCiJcn0N+HhbOn6hYwgZwPkBbMmkr/YZ8QdvY8TyofSXHpISkcGTgzSzOcfVzIGFyRIdpMvlm9nPNrrnP4bgoNP6vNL2P2gcaIu+oQUCj5fth2Kr0XyLGl4Wh1HdayWL1tKucUy/n5QR9+WPstDb2qoPl7ZnqFAvxa+HB4+j602Qpij5/Qnb/OxDJETjjNzT9iqUwh+nfvgUefsjh7u2DrZJs3YCGEeEP17NmTjRs3smPHDlavXv3YuY6e5Y+Q3JU9cie7zsrKeq6YJkyYgKWlJaNGjeL999/n+PHjeSaEHjJkCF26dGHLli388ssv7N+/nxMnTnDixAnmzp3LwYMHKVGixBPPU6dOHaKioti5cyc7d+5kz549REVFMXfuXL755hvWr19P69atddeVOyH4kxQqVEjvXjRr1gxb28f/XggICMjz2r+ZS+hJHp3YOz+PrgJna2tL27ZtWb16Ndu2baNdu3asXbsWOzs7Wrdu/a/P/WiBBvK5pr/fTiqjZyhAPOWt989zPTra3Mjk6X8yPlrMUSgVWNg8fgLsf/vH+D/3z52M+p8sbMzoOacpEUeuEXH4ClfD7pCWmDPs8cHdJI5sCOPMvkh6zWmGuY0ZmkdiNjJRYWrx+A+rsjPzntPkMfsX9nOm36I2nNkXycVj17hxLjrneC3cvhjH7YtxRJ64QZuxdV/a+1QIIQzNk36XlPYrwcLZ0/ApUQKNRqP7wEipVOLt5cWiOdMYMOwTws5fkALRM5DCkcDcyhz3gGJoPtTysUrBNyu/48wfsZw49wAnX1vizv/9CaIWokLiMbWzxczemLT72SgUGuq9W50bfjsg24jUDBiQ7UD/D3qx4JslKLRajK3N0SZlcenPa3rD2xz9LAhbdB2Tmyqq4Eqf7t1w7x2Es4cUjYQQb6dSpUqxY8eOfHu/5ModKnXlypXH7pM7IbWrqyuQM4TrypUr3LhxI99l3hcvXkzhwoVp3ry57rUKFSrw6aefkpWVxerVqwkNDWX27Nl88skneY53cXGhf//+9O/fH41Gw6FDhxg2bBgnTpxg+vTpLF269KnXbm5uTrt27WjXrh0A58+fZ8qUKaxevZoRI0bQunVr3Nxy5nQxMzN7bM+tf3Jzc+PChQv873//o379+s90zMuW20vsn3Jz+M+eYH369GH16tVs2rQJJycn4uLiGDBgwFMLUC8idxgZ5KxgptVodfPzQM7KYY/O/+NQ+N+tUPostQ1rRwvdv1VGSgat6KAXgyZb86962CgfOTYzXb94mpqQ/vjjVEqKlXalZHUPtFotsdfiuXH2Lkc2niYxNpmE6GTUv12kSrtArB0exuwe4ErHTxvotfW0mJ9UsDMxN6JkTU/KNytJVmY2dy7FcVV9myM/hpGdpeHS8RvcuhBLET/nx7YhhBAif08q9gT4eLNg1lT8fH3RaDSs37gZnxJeaDRaoi5foUPb1pTw9mbB7KkMGP4J4efzXwBB+7RPXAyI9I8VQE7Po2Kli1Gif1U+7tuPcgpXLG4qSI1IQ/n320Tx98xF5/deITsdQINSpeGLNYOIU9xAq9SiVcKlDAXvjB+JhblFzl+aWXBxd9TfbeQUjVSoSL2gwfqmEVVwou97PfEZWAVHd0cKeRQqqNsghBAvJHdunyfNY1OjRg0UCgW//fYbCQkJebbv3buXmJgYPD09dQWJ3Amxf/755zz7nz9/ngEDBjB+/Hi913N7KxkZGbFo0SIUCgWffvqpLkaAYcOG4ebmppt3CXI+iatRowbjxo0D8h8C9qg1a9ZQokSJPMvP+/v761aGy23Dw8ODYsWKcfPmTdRqdZ62UlJSCAoKombNmrqiTK1atR577QAjR46kbNmyLFmy5Ilxvog//si76kp2djZbt24FoHbt2nrbateujZeXF7/++itr164Fnm+Y2r/hEeSmN4fRo5M5a7Va9q88qSu+2BWyxtnjyUMQn4eNs5VuKFdWRjYhvz5c4S0jLZPFAzazqN8mNn6+Wzdk7knMLB/2WIq9Fq/7d3pKJpdDbubZPy0pnZUf72RuxzXM7/0j0VfuoVAocC5uT9nG/niVK6zbN+HvIWpFS7vqelZdP32Hu1EP536KvnyPLzquYdlH2/hpzoE8xStAfw2Qv10/c4dlg7fxRYc1rPx4J+kpmRgZq3Av6cI7HcvoDXd7dKicEEKIF+fv7cnC2VMp6e+PVqtlw6atTJz9JcnJKSQnJzNh1jx+3LwVrVaLr48PC2dPo5Tvk3tWCykciUeYWZpTtEwx3HuV56P+fSmrcMFVa4UZxqjIKRzlUJCdkoVCoWHspI8It1+LRqsAjTFmymxQwMAEE+bMnwYKBZkpGYASBTnzIhmhxBJjimotKY8Tffr2pNT/auFV0ZsiPu6PD1AIId5gW7duZevWrRgZGdGhQ4fH7ufp6UnLli1JSEige/fuJCU9nBcmKiqK999/H4APP/xQ9/qgQYNQKBRMnjxZN2k0QFJSEoMGDQKgW7dujz3nO++8Q9++fUlLS6Nfv366T+mKFSvGnTt3GDNmjF4RKysri/Xr1wNQqVKlJ153qVKliIyM5MsvvyQiIkJvW26vokfbGDp0KAA9evTQTf4NOZNVDhw4kLCwMJKSknTzCvXr1w9LS0u+/vpr1q1bp9f+9u3bmTdvHmq1mooVKz4xzhdx6dIlRowYobtvGo2GkSNHcv78eapUqcI777yjt79CoaB3794kJSXx3XffERAQ8NT7+KJMzI2p0KKk7vt935/kh7G/8vvio6wcvpOQXx7mpk7vCq9seFTFlg+HDP6++BgbPv2DP5b8xcrhO0mITubB3SSiL9/HocjTezw5P7Kq2+ENYRzeoObkjnOsGrmTxLiUPPubWZlibmNKRloWWo2WNaN/ZcfcP9m99C9+nPwHYX/PdQQ5E2FDzhxSvlVyFuDIztKwetTPbP/iT35bdJR1E34jO1ND7NV4tNnaPPNLPU6hEk4k308lO0vDg7tJLP/fNnYtPMIf3x7j++E7uHcz5781pUpBYd8nTz4vhBDiMfLpceTn5cGiOdMIKFkSrVbLpi1bGTd9NonJybrhaglJyYydNovNW7eh1Wrx8/Vl4eypBPjkXbBAhrA9JEPVhB4zSzOKBRUjq3Mm/bJ7smDpCjTaOGKBdNLRoEFDzgdsdo62NBtZhDDO4aYpTVp2AN1ORxNRxondGSYcbdwST485XLl8E7Q5pSMjlFhhRmHMKIkDPft0wbd/dQqXKoxSKXVMIcSb7dy5c3kKNJmZmZw/f56wsDAAZs2a9dQ5gRYvXsyFCxf46aef8PT0pEaNGqSkpLBv3z7S09Pp0qULQ4YM0e1ftWpVPvvsM8aNG0elSpWoWbMm1tbWHDlyhOjoaBo0aMCwYcOeeM7p06ezdetW9u3bx9KlS+nbty8DBgxg3bp1HDp0CA8PD6pUqYKpqSmnTp3i2rVr+Pv7P7Xd4OBg/ve///Hll19SunRpqlevjpOTExcvXkStVmNpacncuXN1+3/00UccPXqU9evXU7p0aSpWrIijoyN//fUXt27dwsXFRa9AVKRIEVauXEnnzp3p3LkzkydPxt/fn+vXr3PiRM6cefPmzSM4OPiJcb6IypUrM3fuXHbu3ElgYCBhYWFcuHABd3d31qxZk+8xvXr1YuLEiWg0mlfe2yhX9c7BJMQkc2ZfTi/f66fvcv30Xd12hVJB3T4V8K3y7JOs/1vlGvtz83wM5w7kDLe8fOoml0897B1kamlMq1G1UBmrHteEToVmJTm7L4rsLA2ZaVn8uSYUyCm4BDX0Rb3rQp5jmnxUjbVjdxF34wEZKZm6e/Eov3eKU7LGw5XQGn5QhXs3HxB7LZ6sjGzO7tc/xrm4PQ0GVH6m64ecCbPbjK3Lj5N+JyMti4ToZEJ//UesCqjbp6LeEEMhhBDPz9erOAtnT6VUQABarZZt23cwZtpsEpKSURkp0Wq1aLVaFGhJSEphzNTZGBsb07xpE0r6+7Nw9lQGDB/NuUt//w6QopEeeVIXeZhamOFVwRv37mV5v2dXSioccMYcc4xRktvzSMOa9XO5pbyGS3ZjNmSZMZlQvvsmlbuTrzDocjRX07OZv2XF3xMjKFChwhwTXDHHF3u6d+1AxQktKFq22FMn7BRCiDdBdHQ0a9as0fv66aefSE5OpkuXLhw4cOCphRbImVPo6NGjTJo0CRcXF3755ReOHz/OO++8w/r161mzZk2eYvrYsWP5+eefqVOnDqdOneLnn3/G3t6ezz77jO3btz+1+G5vb88XX3wB5Azvun37NmZmZuzatYtPPvkEV1dX9u7dy65du7CysmLs2LEcO3bsqauqAXzxxRcsXLiQ8uXLc+LECbZt28a9e/fo06cParWaChUq6PZVKpWsXbuW77//nooVK6JWq9m1axe2trYMGzaM0NDQPPM4tWnThhMnTtCtWzcePHjAjh07uHPnDs2aNWPv3r3873//e2qML6JZs2Zs27YNS0tLtm/fTkJCAv369eP48eN4eXnle4y7uzseHh4YGRnRvXv3VxpfLqVKSbOhNWg3oR6+VYth5WiBykiJlb05JWt40GNWUyo0zzuJ+MukUCpoPqwGzYbWoHiZQphZm6IyVmLvZk1wQ196zW1OYd9nm9PHxdOBzlMaUryMGyZmRphamlCiojvdZjR5bPHL0s6cHrObUve9irj5OmFpZ4ZSpcDc2pTiZQrR5H/VaDmyll6PKwsbM3rMbkrNbmVx9XLAxMwIEzMjnIvbU6NrWbpOb4SFzb+bn8q9pAvvfdOKiq0CcC5uj6mlCUojJVaOFvi9U5wuUxpRvlnJpzckhBAiX4/2BvLxLM6i2dMILF0arVbLL7t+Y/SUWdxPSPq7WKTQFY5yj72fkMioz2aw6/c/AAgoWZKFs6fi7+2Z7/kMnUIr/a/EY6SnpHFTfZ3wBftZ9sM6IjRxxJJMGhn4l/Jn48m5fKvdyxYuk5INNgpb7rToRnJqOipNBpUCjenTw5FVk/7Hvt3HsMaUwlgQgAPdurSl2pT22BW3z5l4UqnUm0BTCCGEeJuFhIRQrlw52rRpw6ZNmwo6HCGEEOI/5ezZczTp0hs3FycWz5lGmcBAAP7Ys5ePxn5K7L37ukKRsZGKVfPnotFo6DH4Y91qtQqFAmdHe76aMol6dWoDcPrMGQYMH83123f4adVSgsqUKYjLe+NIjyPxWKYWZhQOdKd0/+r06twRb4Uj9lhgjAn37ifw228h3MiCjOycJXiztdnk1H4UZGlVZKRpuXLkLyIv3cAYFU6Y4YMdXdq1oeKY5tgVt0er0aJUSdFICCHE2y89PR2NRsP9+/f56KOPABg8eHABRyWEEEL8N5XwKMai2VN1RaM/Dx5i2ITP9YpGgN7SoI+ulKbVaomJu8/Q8Z/x56HDAJQuVYqFs6fi4+khg2IeIYUj8URmVuYUCS5OpRHv0qdjJ4or7LHBAnNjM9Z9sY347icYGFWRYtigVGhBmY2jHYzsoqV41hK2/rAQG3NrHDGjBHZ0a92WwGF1cSmZsySzUqV8ZRN0CiGEEK/T/v37MTc3x8nJiYMHD9K0adM8K64JIYQQ4sU5OjrwzYzPdT2Cjh0/zkdjP+VOTGzeSa0frSH9ox2tVsudmBj+N3YSx0+eBCCwdGnmz/wcV+dnG1ptCKRwJJ7KzMqcwqWLUnlEfbo2bUFhhQ3x1+KY//VUKpYtzRfvzqTSHBUdkoLoXA/6VDnCdzPfx97BgTXrv+b6hZsUV9jQvnELKo5rTLEKXiiUCikYCSGE+E/x8fHB3t4ec3NzOnbs+NiJs4UQQgjxYlxdXfH3y5kTMSQ0lMGfTOTmnbv5roSmJWdYmkKhyLcXkVYL12/dZdCoCaj/XuzEz9cXNze3V3gFbxeZ40g8M012NrdDb7L+k7Ws+OMnTDxtWXt+KJF/JTH6g0UoFGBsYkVSYiLDJ0zEvmgAMwb1I/X0LbrVbkj7KZ0pXskbpUrqlUIIIYQQQgghXszZc+foO3QkF6KuPnYfY2Mj1iyYh0ajoesHw8jOznrsvn5eHiyZN5OS/v6vIty3ljzBi2emVKkoXNad1uPb0K52Q4xuJHN4aSyZlf/k24N9qFa9LJWrVuD9T1czb5c/8Rf+5PbpuzSqVIMO07tSrIKXFI2EEEIIIYQQQryw27dv89EnE55YNMqV2+NIoXxyv5mIqCsM/mQCd+7ceVlh/ifIU7z4VxRKJcXe8aL7p52oVbkKB2ZvJyihB2fN19H8CzOuWfZh/CIN0/pl89WIb6gVWIbBCwdQrLwHKmNVQYcvhBBCCCGEEOI/wNzcHDsbaxR5Zi7Sp9U+LBzlneVIn0KhwM7GGjMzs5cY6dtPCkfiX1MZqfCoVoIPZvYnIKgUu8YcoER2be4pzvNniILODRSELVtOoIc3U1aNxD24OEqVFI2EEEIIIYQQQrwcdnZ2TJ80Fm/Pok+eP1ehfdjj6ElrpSkUeHsUZcaksdjZ2b30eN9mRgUdgHg7KZQKilfxpP3Yzlw4dhafW0HEFbmAvQN81sGIrLRO2Ls5YelgKZNgCyGEEEIIIYR46Up4ezN93Cf0Gzaa+wkJ+U6OrUCBQsHfk2Pn/2yqUChwsLVlxvjReHt5veqw3zrS40g8l9xiULHyntTp2wgXD3dqaUaxZow5LsXtKFraAytHKykaCSGEEEIIIYR4ZWpWr8aQfj1RPWU+XYVCgeIxHY5UKiVD+vWkRrV3XkGEbz8pHInnltvdT6lSolAqsMKN4KLGqIxVaLKyCzo8IYQQQgghhBD/cQqFgh5dOlOtQrl8Oy5oAYVCiUIB2nwqRwqFgmoVytG9cyfp+PAYUjgSLyx3pTQjc2PMbM3QZGtQGsmcRkIIIYQQQgghXj1LS0tGDh6IjZVl3o3av+c4Iv/JsW2srBj10QdYWuZzrACkcCReAeVTuggKIYQQQgghhBAvU4Xy5WjfrFGe13N6Gyke25uoQ4vGlC9X9lWH91aTJ3zx2uQ3UZkQQgghhBBCCPGilEol/Xr1wM3FWe91/XKR/jNpYRdn+vXqjlIppZEnkbsjXgutRivjRYUQQgghhBBCvDIeHsXp1LLpP549tSj/7nGkeKSMpFAo6Ny6GcWLFXv9gb5lpHAkXguFUopGQgghhBBCCCFeHYVCQfdO7fP0OtJCno4MhV1d6NqhnXRweAZSOBJCCCGEEEIIIcR/gru7O22bNtQVhLTaR+Y3+nukmkIBbZs1wt3dvYCifLtI4UgIIYQQQgghhBD/CQqFgo5tWuJga/v3949uzPk/Rzs7OrZuIb2NnpEUjoQQQgghhBBCCPGfUcLbm/o13vm7TvSPRZoUCurXrEYJb+8CiOztJIUjIYQQQgghhBBC/GeoVCr6dOuEtbVVnm02Vpb06dpJVlL7F+ROCSGEEEIIIYQQ4j8lqEwgjWvXQPtohyOtgiZ1alImsHSBxfU2ksKREEIIIYQQQggh/lNUKhV9e3bDztYGrVaLVqvF3s6Gfr26oVKpCjq8t4oUjoQQQgghhBBCCPGfE1i6FK0a1QdyJs1u1bAepQICCjiqt49Cq9Vqn76bEEIIIYQQQgghxNvl6rVraDQatFotRkZGFCtatKBDeutI4UgIIYQQQgghhBBC5EuGqgkhhBBCCCGEEEKIfEnhSAghhBBCCCGEEELkSwpHb4Hk5GTWrFmj+/7rr7/Gz8+PZcuWFWBUeb2pceU6duwYfn5+9O/fv6BDEUIIIYQQQoi3hp+fn95XcHAw7du3Z//+/f+qnYyMDFasWPHcccTGxtK9e3cCAwOpUaMG169ff+62XsSGDRvw8/OjRo0apKam6l7/6KOP8PPzY/jw4c/UjlarZd26dSQlJb2qUF8KKRy94eLj42nSpAlr164t6FDeevb29tSrV4/g4OCCDkUIIYQQQggh3ioqlYp69epRp04dPDw8CAsLY8CAARw4cOCZ22jVqhVfffXVc8ewYcMG/vrrL2xsbPDx8cHFxeW523oR7dq1o1SpUkRHR7N06VIAQkJC2LVrF+bm5owYMeKZ2unXrx8TJ04kIyPjVYb7wqRw9IZLSkrizp07BR3Gf4Kvry8LFixg4MCBBR2KEEIIIYQQQrxVTE1NWbBgAYsWLWLr1q2MGDECjUbD9OnTn7mNyMjIF4rh3r17AAwZMoTly5djamr6Qu09L6VSydixYwFYtmwZd+7cYcaMGQD07duXQoUKPVM7L3o/XhcpHL0h7t69y4ABAwgKCqJatWrMnj2b7Oxs6tWrB8DFixfx8/Pjxo0bumMSExP56KOPKFOmDE2bNiUkJES3zc/Pj5YtW7J161aqV69OpUqV+PLLL8ldRC8rK4spU6ZQvXp1SpcuTd26dXWVUoDu3bvj5+fHkSNHaNOmDYGBgXTv3l2viHX06FGaNWtGYGAgH3zwAQ8ePNC7pqSkJEaOHEmVKlUoXbo0DRs2ZOvWrbrtWVlZfPPNN9SpU4fAwEBatmzJH3/8odu+efNm/Pz8+Pbbbxk+fDhBQUE0bdqUEydO6PbZv38/rVq1Ijg4mCpVqjB8+HASEhLyvcf5DVU7c+YMvXv3pmzZslSuXJmxY8c+9nghhBBCCCGEEDl69uyJpaUlkZGRXL58GYBLly7Rs2dPypUrR3BwMB07diQ8PByAunXrApCSkoKfnx/Hjh0DYOHChdSpU4fSpUtTvXp1ZsyYgUajyXO+Tz75hFWrVgEwbtw4unfvrnvG+/jjj+nUqRMVKlTg4MGDAKxZs4aGDRvqnkV//PFHXVu5z5oLFy7kf//7H0FBQbRq1YrLly8za9YsypcvT/Xq1dmyZctjr798+fI0a9aM1NRUevfuTUhICEWKFOH999/X7XP37l0++OADKlWqRJkyZWjRogV//vknkPPMffPmTQCqVq3K5s2b831m/eSTT/Dz8+PXX3/9lxl6eaRw9AbQarV8+OGH7N27F39/f2xtbVmyZAlz586lWrVqAFhaWlKvXj3Mzc11xy1dupTr16/j4uLCpUuXmDBhgl67165d49NPP8XT05P09HQWLFigK9wsXbqUlStXYmxsTKVKlYiJiWHWrFmcOXNGr42PPvoICwsLTE1N+euvv1iwYAGQM4Ru0KBBXLx4ER8fHyIjI/XmYQKYMWMG27Ztw87OjnLlynHt2jXGjBmjqxJPnjyZr7/+mrS0NIKDg4mMjOTDDz9k9+7deu0sWrSIkJAQSpQowaVLlxg4cCCJiYncu3ePwYMHc/XqVcqXL4+DgwM7duxg8uTJz3Tfr169Srdu3Th8+DB+fn7Y2NiwceNG3nvvPbKzs5+pDSGEEEIIIYQwRMbGxnh4eAAQFRWle649evQovr6+eHh4EBoaypgxYwB0z7a5Q97s7e3Zvn078+bNIz09ncqVK5Oamsry5cv1OhTkCggIwN3dXffvcuXK6bbt2LGDhIQE3NzcKFOmDN9++y2TJ08mNjaWcuXKER0dzbhx43SFp1wLFy7k8uXLODg4cO7cOdq3b8+mTZvw8fEhJiaG8ePHc//+/cfeg5EjR2JhYUFUVJTu+0d7QY0ePZrdu3dTuHBhAgICiIiIYPjw4WRnZ1OuXDnMzMwAqFmzJm5ubv82Ba+NFI7eAEePHiUsLIzWrVuzfv16tm/fjre3N2vXrtUVgwoXLsyCBQtwdHTUHVe5cmW2bNnC1q1bMTMz48KFC6Slpem2p6SkMHfuXFatWsW8efMAWL16NQBBQUEMGDCA7du3s3z5cjp27AjkFFMe1alTJ1avXs2sWbMAOH36NADbt28nKSmJhg0bsnnzZl3Mj6pVqxaDBg1i586drFy5klq1apGdnc3169e5ffs2GzZswM7Ojp07d7Jq1Sq++uortFqtLtZcufts2rSJhg0bkpCQwE8//UR0dDTp6elUrFiRL7/8ki1btjBq1Cjatm37TPd9yZIlpKSkMGjQINatW8fOnTsJDg4mLCwsT/FKCCGEEEIIIYS+3MJHcnIy6enp9O7dm8mTJ7Nu3To2btyIra2t7hnzs88+Ax4OefP19aV48eJ8+OGHbNiwgWXLlvHhhx8CcOXKlTzn6tGjB7Vq1QJyeusMHTpUt83S0pKNGzeyfft2TExMWLRoEcbGxmzYsIGVK1eyZs0aVCoV33zzDVlZWbrj3N3d2bRpEwsXLgRyRvWsWbOGdevW4e/vT2ZmZr6x5HJ1daVEiRIAmJubU6NGDb3tzZs35+OPP2br1q2sW7cOX19fHjx4wP379xk6dKju+X7GjBlUrVr1me/76yaFozfApUuXANiyZQt+fn4EBAQQGRlJUlKS3pv6n8qXLw+AlZUVdnZ2AHozuqtUKmrWrAlAjRo1UCqVuv9oq1SpQnBwMLNnz6Z58+a6ymt6erreOXLf+F5eXgBkZmYCOb2ZAOrUqQOAiYkJ77zzjt6xtWrVwtvbm3HjxtGwYUP27t2rO0dYWBharZYaNWrg4OAA5HRdtLa2zlMAq1y5sq6nVe4PiitXruDj40OlSpXYv38/VapUoXfv3mRlZREYGPjYe/YotVoNQMuWLXXX0LhxY71tQgghhBBCCCHyl/vcZm5ujpmZGQ0bNiQzM5PBgwdTs2ZNHjx4kOcZ81FlypShcuXKrFq1inbt2jFz5kyAfz1ZtI+PDxYWFkDO83VycjKBgYG6zg0BAQH4+PgQHx+v11mibNmyGBsb4+zsDICDg4PumNyJt58Uy88//0xYWBiQ8yyeO0InV6NGjbC3t2f48OHUrl2bCxcuAHmfu58kd7qZgiSFozdAbnHI29ubevXq6X0pFIrHHvdoFziVSgXov6k0Go2u7dx2cvebMmUKAwYM4N69ewwcOJCuXbvmOR4eVpD/2X5ue4/ur1Tqv50GDx7MsGHDMDIyYsSIETRo0EB3zD/3fZL8/kNVqVSoVCpWrFjBV199RbNmzbhz5w5z5syhbdu2ugLXkzzp3j5pmxBCCCGEEEIYuuzsbF2HAi8vLxISEmjVqhVz587Fx8eHefPm4erq+sQ2VqxYQffu3blw4QJdu3Zl8ODBwL8vllhZWen+/W+eNXOfqXOf/x6dGuZp7aSkpOgmxG7ZsiUKhYLvv/9eN+F1dnY2Xbp0YdKkSbi4uPDZZ58RFBQEPP36Hp3j6U1YcU0KR2+A3Iqml5cXCxYs4Ouvv8bd3V2vp01+k4M9jVar5ffffwfg8OHDaDQa3RjUTZs2oVQqmTFjBk2aNOH69ev5tvG4AoqnpyeArhdRRkaG3jKM9+7dY+/evTg7OzN58mRq1aql+6EC4O/vD8DBgwd1cx7t2bOHxMRESpYsqStYARw5coTExEQADh06BKA3XvbOnTtMnz6dPXv2UKpUKa5cucLt27efen8CAgIA2LZtm+4afvnlFwCCg4OferwQQgghhBBCGKrNmzeTmJiIj48P3t7eHD58mNu3b1OzZk0++ugjihQpkmd+IIVCofdsu2nTJiBnsuvWrVtz9+7d54olt6MD5DyrmpubEx4erivinDt3josXL2Jvb697Jn5RixYt4s6dO3h7ezN16lSaNWtGZmYmn3/+OQBnz57l7NmzBAQEMGrUKIKDg7l165ZeG//skJH7HBwdHQ3kjPg5d+7cS4n3RRgVdAACqlevjqenJ7///jutW7cmNTWVy5cvU6tWLdq2bYtKpeLy5ct07dqVKVOmPHO7CoWC0aNHs27dOt3cRN27dwdy5ky6dOkSbdu2xcjIiIiICCCnavosmjdvzrx58/jtt99o1aoVKSkpxMTE6Lbb2NhgbW1NTEwMbdu2JSkpSdclMCUlhaJFi9K8eXO2b99O06ZN8fHx4dSpUyiVSr2xqpAzEXezZs1wcXEhLCwMOzs7mjVrRnx8PL///jvbt2/n999/JzMzkzNnzlC4cGEKFy5MXFwc48ePp3DhwowbNy7PNfTu3Zuff/6Z+fPnc/jwYeLi4rh27RrlypXTzfgvhBBCCCGEECJneNUHH3yAVqslNjaWsLAwFAoFI0aMAHKeMQF+/fVX4uLiiIiI0PWWSU5OxtLSEgcHB+Li4ujUqRNDhw6lcOHCXLx4kb59++Lk5KSbMuRZn0vzY25uTs+ePVm0aBEdOnSgdOnShIWFkZ2dzZAhQ/SKTM/r6tWrrFixAoAxY8boRtns3r2bw4cP88svv1C+fHmMjIxQq9V07tyZmzdv6p6Zc6/PwcGBGzdu0K9fP3r16kXt2rUxMTHh/Pnz9O/fnwcPHjx3Me1lkh5HbwClUsmSJUuoU6cOV65cIS4ujubNmzN79mysrKzo27cvlpaWXL58WW/un6cxNzdn8uTJREVFYWxszODBg2nWrBkA06ZNw8/Pj5s3b6JQKPjggw+AZ5/bx8rKisWLF+Pn50dUVBQ+Pj4MGTJEt93IyIg5c+ZQvHhxoqKisLe3p1evXnrnmDp1KgMHDsTc3JxTp05RokQJFi5cqJvHKFerVq2oWLEiERER+Pj4sHDhQqysrHB3d2fp0qWUL1+es2fPcuXKFWrWrMmSJUswMjIiNTWV3bt3c/To0Xyvwc/Pj9WrV1O1alUiIiJISEigQ4cOLFmy5F91bxRCCCGEEEKI/7rs7Gx2797Nnj17uHTpEuXLl2fp0qW657cyZcowdOhQ7OzsOHfuHJUqVaJevXoAunmABg0ahJ2dHZGRkaSlpTFmzBjKlStHXFwcDx48YPjw4cCLzzk7ZMgQRo8ejZOTEydPnsTV1ZVp06bRqVOnF2o319SpU8nIyKBOnTpUr14dyJkou3///gBMnz4dKysrJk+eTKFChYiIiMDb21u3kFPu9fXr1w9nZ2eioqJIS0vD2tqaKVOm4OrqyvHjx/Hz86NHjx4vJeYXodC+CTMtiZfOz88PCwsLQkJCCjqU57Z582ZGjx5N165ddavLCSGEEEIIIYQQ4vWRbhVCCCGEEEIIIYQQIl9SOBJCCCGEEEIIIYQQ+ZKhakIIIYQQQgghhBAiX9LjSAghhBBCCCGEEELkSwpHQgghhBBCCCGEECJfUjgSQgghhBBCCCGEEPmSwpEQQgghhBBCCCGEyJcUjoQQQgghhBBCCCFEvqRwJIQQQgghhBBCCCHyJYUjIYQQQgghhBBCCJEvKRwJIYQQQgghhBBCiHxJ4UgIIYQQQgghhBBC5EsKR0IIIYQQQgghhBAiX0YFHcCbLC4uCY1GW9BhiNdEqVRIvg2I5NuwSL4Ni+TbsEi+DYvk27A4O1sXdAivzACFTYGcd5E2oUDOK95u0uNICCGEEEIIIYQQQuRLehw9gXyaYVgk34ZF8m1YJN+GRfJtWCTfhkXyLf4rpAeHeJvI+/UJFIqCjkC8TpJvwyL5NiySb8Mi+TYskm/DIvkWQojXTwpHT6BSye0xJJJvwyL5NiySb8Mi+TYskm/DIvkWQojXT4aqCSGEEEIIIYQQr5FSus+Jt4iU7IUQQgghhBBCCCFEvqTHkRBCCCGEEEII8RpJDw7xNpH36xNoZdEGgyL5NiySb8Mi+TYskm/DIvk2LJJvIYR4/aRw9ATZ2ZqCDkG8RpJvwyL5NiySb8Mi+TYskm/DIvkW4u1y+fJlypUrV9BhiBckQ9WEEEIIIYQQQojXSGkAc2OnpqYyY8YMTE1NCzoU8YKkx9ETyHKfhkXybVgk34ZF8m1YJN+GRfJtWCTfQrw9pkyZwqBBgzA3Ny/oUMQLkh5HTyArJBoWybdhkXwbFsm3YZF8GxbJt2GRfIv/iv96CXT9+vX4+/sTGBhY0KGIl+C//n4VQgghhBBCCCHEa/TTTz+xa9cuunfvTkxMDO+//35BhyRegPQ4EkIIIYQQQgghXiPlf7z73Jo1a3T/rlu3LkuXLi3AaMSLkh5HQgghhBBCCCGEeKyMjAyaNWvGsWPHdK+lp6czZswYKlSoQPXq1Vm+fHkBRiheJelx9ASy3KdhkXwbFsm3YZF8GxbJt2GRfBsWybcQr196ejrDhw/n4sWLeq/PnDmT06dP8/3333Pr1i1GjRpF4cKFadSokd5+e/bseZ3hildACkdPoNUWdATidZJ8GxbJt2GRfBsWybdhkXwbFsm3+K94W4b+XLp0ieHDh6P9x398KSkp/PjjjyxZsoRSpUpRqlQpLl68yJo1a/IUjsTb7215vxYIpfK/Pe5U6JN8GxbJt2GRfBsWybdhkXwbFsm3EK/XX3/9ReXKlVm/fr3e6+fPnycrK4uyZcvqXitfvjxqtRqNRnoG/tdIj6MnUCoVaDTysYahkHwbFsm3YZF8GxbJt2GRfBsWybf4r3hbaqBdunTJ9/WYmBjs7e0xMTHRvebk5ER6ejrx8fE4ODi8rhDFayA9joQQQgghhBBCCPHMUlNT9YpGgO77jIyMgghJvEJSOBJCCCGEEEIIIcQzMzU1zVMgyv3ezMysIEISr5AMVRNCCCGEEEIIIV6jt70Hh6urK/fv3ycrKwsjo5yyQkxMDGZmZtjY2BRwdOJle9vfr6+UjJ82LJJvwyL5NiySb8Mi+TYskm/DIvkW4s1QsmRJjIyMCA0N1b128uRJAgMDUSqlzPBfIz2OnkB+MRkWybdhkXwbFsm3YZF8G5bXke/s7GwePIh/5ecRwhDZ2tqhUqkKOozXTqF4S2bHfgxzc3NatWrFpEmTmDp1KtHR0Sxfvpxp06YVdGjiFZDCkRBCCCGEEE/w4EE82dmp2NnZF3QoQvynxMff58EDcHBwLOhQxHMYPXo0kyZNomfPnlhZWTF48GDefffdgg5LvAIKrVYrH8s9hvbi8YIOQU+snX9Bh5CHs6WmoEMQ/4Lm/LGCDkFPXNGqBXZuIyMlWVny/jUUkm/DIvk2LK8j3/fuxWFtbYazs/MrPY94OoUC5OnlvyMmJobExLTHFo6cna1fc0Svz3iTgilEf5Zxv0DOK95uMvhQCCGEEEIIIYQQQuRLCkdCCCGEEEIIIYQQIl8yx5EQQgghhBBCCPEaKd/uubGFgZEeR0IIIYQQQgghhBAiX1I4EkIYJJk417BIvg2L5NuwvCn5jo+PZ+TIjylRwgtbW2uCg4NYsuRb/s06NEWLFmHz5s0AVK/+DnPnfvFSY0xOTsbMzIRTp06+1HafZvz4cbRq1fK5jk1LS8PCwoyTJ08A4OFRXHePXsTBg39y5MjhF27nVfvqqy+pUqVygZ0/JOQU3t6e2NhY8d13Kwosjv8iZQF9CfE8ZKiaEEIIIYQQLyA6Opp69eri4uLM6tVr8PPz5+jRI7z3Xh+SkpIYOnTYU9u4ffs2d+/eJSgoCI1Gw+nTp5k8+bOXGmd4eBhKpZJSpUq/1HafZsKEiSgUzzcu58yZ0wC6mM+di8DU1PSF4klISKB+/XqEhKhfqJ3XQa1WExQUVGDnnzFjBtWr12DWrNkvfN+FEG8vKToKIQySSiU//gyJ5NuwSL4Ny5uQ7/79+2FlZcUvv+yiSpWq2Nvb07hxEz7/fAqzZs1Eo3l6ryi1OhQbGxu8vLyIiIggJSWF4OCyLzVOtVqNv3/J114AMDY2xsjo+T6vVqvV+Pr6YWZmBoC5udlzF6FyhYaGYGZmhp+f3wu18zoUdOHor7+O0axZc1xcXLC1tS2wOP6LlApFgXwJ8TwK/jetAeg2fDxK30oFHcYbK+LCRUztXZj3zYKCDkXnTYvpTYrnaPg5KnX7EJvqLWkz/FNSUtMKOqTnIr83DYvk27BIvg1LQec7JCSEnTt38Pnnn2NiYqK3rXXrNsyb9xWZmZkA7N27h2rVqmJnZ0PFihU4cGC/bt/Q0FDKlCmDQqEgNDSUokWL4uDgkOd89va2HDz4p+77jIwMSpTw0g0jWrRoIQEBJbG1taZs2WB++uknvXPkFiG+//47AgP1ex4FBZVh+fJlAKSmpjJ06BCKFHGjcOFCDB78IWlpD3/n//bbLsqUCcTW1ppKlSry558H8r0/iYmJmJoac/p0Ts8hHx9vtm7dSrduXbGzs6Fy5UrcuHFDt//PP++kTJlAHBzs+OSTUXqFkwUL5lO58sNhW+vWrSM4OAg7Oxvq1atDZGSkbtvj7sPixYuoX78eKSkp2Nvbkp2d/dRrfVRGRgaWlub8+ecBmjVrgq2tNQ0a1CMxMRGAffv2Ym9vq1csbNmyORMmjAdgwoTxNG3amOnTp1GokAs+Pt6cOnWS5cuX4eXlgYuLEytWLNed69y5s9y+fZuyZYNxc3NlxozpevH8+OOPlC0bjL29LbVr1yQsLEy3bfLkTxk06AM++GAgdnY2+ebo8OFD1KhRDRsbKwICSrJu3Togp2BlYmLEjRs36Nq1M5MmTcz3fgghDIMUjl6xDT//zg/bdxV0GG+sX3b9Tt0mLcjIyCjoUHTetJjepHjuPUig8aAxFC3kwtyPB/Lzwb/4cu2Wgg5LCCGEKDA//bQNLy8v6tWrn2ebvb09HTp0wNTUlMOHD9GhQ3sGDRpMZORlhgwZSvv27YiLiwNye5YE//3vUMqUyb+XSYkSPkRFRem+/+67FZiYmNK9ew9WrFjO1KlT+Pbbb7l69TpDhgyhc+eO3L9/X9dubhEmJCSE4OBgXTspKSlcuBCh296xY3uioiLZs2cfR44cIzw8jGnTpgI58w517tyJKVOmcvnyVVq3bk379u3yLbaEhakxNTXF39+f+Ph4rl69ysyZ0+nevTsXL0aiVCpZunQJAAcO7Kdr1y5MmvQpZ8+e5/Lly6xatVIX06NFpE2bNvHRRx8ya9YsLl6MpFAhNz788AOAJ96H9957n44dO9Gnz3tER8eiUqmeeK3/dPbsWbKzs/n8888YM2Ys585FEBUVxaZNG3X3NTAwEKXy4WNWSEiILrdhYWpOnjyJsbExoaFhFC9enLZt2xAeHs7Bg4d57733mTVrpu5cmZmZhIWp+emn7SxbtpxJkyZy7NhRADZs2MDQof9j6tSpXLoURdOmzejQoZ2uUKlWq/n111+oWvUdwsJOU716Db1rUavVNG7ciNat23D58lU+++xz3nuvN6dOnSQwMJDNm7dgZWXFgweJjB8/Id/7IYQwDFI4eoVu3Y3hg0kzKOXjVdChvJGuXrtGs3YdaVC3dkGHovOmxfSmxbPryEkSklOYMqgXfVo2JGTdQga2b17QYQkhhBAF5ty5c/j7l3zqfqNGjWTs2HF06dIFR0dHunbtirt7UY4ePQLkPMTnFnLCwtR6RZ1H+fj4cOnSJSCnR8rMmTMYP34CKpUKDw8PfvxxI9Wr18DOzo5GjRqTmZlJYmIi2dnZnDlzRtduaKh+4Sg8PAyFQkGpUqX57bddnDp1inXrNuDn50fx4sUZMmQYu3blfBialJREYmIilpYWODg4MGLESIYP/5iUlJQ88arVagICSmFkZIRaHQrAzJmzaNiwEc7Ozri6uuh654wZM5ohQ4bSpk0bChUqxNix40hKSsq3cDR+/FgmTJhIgwbv4uzszLhx46lSpSrAE++DkZER4eHhlCtXDlNT06de6z+FhalRKpUsXLiYd96pRuHChbG2ttFdQ2hoqN4Qwzt37nDnzh29a2jbth3Dh39MoUKFcHFxpXjx4sydO4/ChQtTvHhxzMzMdeeytrbm++9XUbRoUZo0aUrNmjU5cOAA2dnZjBo1gq+/nk/jxk1wdHRkxIiRxMbGEhERoTu+Q4eOdO/enWLFiuUZ4jd69Cjatm3HsGHDcXR0pG3bttSvX5+tW7eiVCo5d+4cgYGBmJubo1Kp8r0f4vnJ5NjibSKTY78iWq2WPqMnU6dyBUr5eHHmYtTTDzIwjg4OXFCfRKVS8v2atQUdDvDmxfSmxXP11l0Axnyzgl8OHadKoD+rp3yCnbVVAUcmhBBCFIykpETc3Ys+cZ/r169z7Ngxzp8/rzfU6MGDB6SmppGUlERk5CVdLyO1Wk2/fgPybcvHx0c3JOu771ZgbW1Dx44dAXBwcOTbbxczadJEUlNTuXv3LsbGxri5uXH+/HlSU1MJCgpGo9EQFham14skJCREN5fQpk2buH//Pl5eHrrtmZmZFCniDoCTkxPDhg2nceNGNG7cmEmTJjNixMh843202JM7X9GjPV9Onz5Nhw6duHXrFn/99RfLl3+Xp42goGCysrI4e/YMQUFBnDt3jkuXLtGuXXvdPiVLlmTixElPvQ+pqalERJzXFc2edq35XU/dunXx8sr5YDgjI4OLFy/g7++vu49Dhgx55L6ewtraGm9vb2JjY7l58ya9e/fWa2/QoEG670NDQwkMDNRta9WqNXZ2drrtFhaWJCYmcvToEW7evMnAgf354IOH75XExETS0lJ1vbt69uyV73UkJiayd+9edu/eo/e6ra3dIz3U1C99ni0hxNtJio6vyPzVP3LqTARzxw4lKzsbgLT09AKO6s1iZWWFt5dnQYeh502L6U2LR0vOksJuTg6smz6GsIuX+XjutwUc1fPJzn4zlm8Wr4fk27BIvg1LQefb3t6BO3du57utc+dOfPfdCi5fjsLExISQEDXHj5/UfV24cInmzZsTFqbGyMiIUqVKcfPmTWJiYh47IbKPjy9RUZG63kYTJkxEqVRy9uxZ6tatja2tLWPHjmP16h/o1KkzpUsHYmxsjFqtplixYtjb23Pp0qW/e/IE69o9dOiQ7pxRUZH8739D9GINDQ3jjz926/afPn0Ghw7lLGdftWplfvst/x46/ywcVatWTbctLi6Oa9euERwczNWrVzA2NqZEiRK67RERERQpUgQnJyfOnz9Peno6ZcoEERl5CXt7ewoVKpTnfE+7D6dPhwMQGFjmma9V/3pCeeedh9dw+nQ42dnZlCkTRGpqqt5wv9z7GhgYiEKhQK0OxcLCgrJlywGQnJxMZOQlqlSpone/cotaanUo5cqV0zv/6dPheHp6EhkZhZeXFydOnNKLPTLyMsHBZVGrQ3FxcdEVtP7p6tWrZGdn5+ktd/bsWYoXLw7oz4klXj6lomC+hHgeUjh6RTbt2kPs/XiK1WzO1IU5kxVaBNZ4ylFCvNmKuDgB8F6rRrSs/Q6VSvtxJvJKwQb1nLTago5AvE6Sb8Mi+TYsBZ3vGjVq8OeffxIbG6v3+m+/7WLbtq3UrFkLa2trMjIyMDY2xt3dHXd3d7Zt28r48eMwNTVFrVZTsmQAJiYmqNWh2NnZ4emZ/wdHvr4+XL9+nR9+WIOjoxOtWrUCcuZaCggIYOrUaVSvXoPChQuzZcsWypcvD0BYWKiuUBQREYGrqytOTjm/169cucKWLZt1RQIrK2sSEhJ0sdrb29OuXVuuXLnMnTt3KF26FLdv36ZChYps3foTTZs2Y+3avD2jH+0lBDlFkbJlH/ZgCQ0NwcLCAn9/f8zNLcjKyiL9kQ9aFy9eqHesl5cX1tbWmJub6+bxgZweQgEB/mzfvv2p90GtVuPj44u5uflTrzU/YWFh/7iGUEqU8MHKyoqLFy+i0WgICCgFQEJCAsuXL3tk7io1pUuX1g37yh32VqpUad39OnPm9CNDFsP0hv8dPnyIW7du0bhxE6ytrYmJicHV1VUX+4IF81m0aOHfwwIfP9wR0F1/bu8igGPHjhIeHkazZs1JSUnh0qWLUjgSQgBSOHpl5k8ayeENyzi8YRl92rUA4PCGZQUclRAvpmHVCliYmTJtxTrW/7aP42ciqBDgW9BhPZcXXcpXvF0k34ZF8m1YCjrfXbt2w9W1EG3btubkyRPExMSwatUqunfvxvz5C/Dy8qJMmSA8PT0ZO3YM0dHR/PDDD4wfP45u3boB+j07cldXexwfH19iYmKYPXs2kyZN0l1/0aLFuHTpEuHh4X8PYRrA2bNndD14Hj2HRqMhKSmJ8PBw3aTdCoVCt71Vq1asW7eWQ4cOEhUVRceO7bG1taF8+Qq4uLiQlpbK9OnTiImJISIigkuXLuW7tP2jvYRyVwh7tJgREhJCmTJlUCqV+Pv74+zszKefTiQ6OpqJEydw8OBB3fC9sLCHE4aXL18BlUrFwoULuHPnDv3798PExJSGDRs+9T5cuBCBg4M98fHxT73Wf7py5Qrx8fF6w7dCQkJ0haTceY5OnDhOaGgoLVo0IyMj4x9zND28/tDQUEqWDMDU1FR3v9LS0ggKCubKlStotVo2b95MREQEarWavn37Mnr0GAoVKkTt2rVRKpV89tlkoqOj+eqrL/n228V07NhJd67HTbAO4O3tTWBgGcaPH8edO3c4dOgg3bt3Y+DAD/D39yc8PEyvqCWEMGxSOHpFAkp4USU4kCrBgbgXcgGgSnBgAUclxItxdbRn29zJRFy5Tr/P5lG9bGlm/O/9gg7ruahU8mBpSCTfhkXybVgKOt+Wlpbs3r2H4sU9aNKkMf7+vnz33XLWrPmB3r37/B2jio0bNxMRcR4fH2/mzZvLhg0/6lZi++dwrkeLC/9kb2+Pg4MDjo4ONG7cRPd6x44dady4CbVq1aBWrRq4uLhQrVo1XQ+esLAwXbuNGjWiVq1aVK/+DmPHjmHOnDl/Fzhytvfo0ZMPPxxM+/btqFGjGh4enmzcuBmlUolSqWTz5q2cP38OX98S1K1bm/r16zF8+Md5Yn20l1DuamS5Q8Qgp3CSO2zLzMyM779fybZt2yhVqiRZWVkEBJTS660TFBSEQgF2dnasWfMDCxYsICDAn/v377N9+w5MTEyeeh9q167D+fPnadasyVOvNb/rcXV1xc3N7ZFreFg4Cg4Oplev3jRv3oy+fd9nwoSJGBsb5zu5d+71P1pIU6vVFC9eHAcHB12PodGjx9CwYQOaNWtCr169GDduvO59sGnTZnbs2IGvbwm2bNnMb7/9rjc/0pPeRwAbN27iwYN4/Px86NWrJ++99z5ffDFXd3zunFfi1ZDJscXbRKHVFmwH34yMDKZNm8aOHTswNjamXbt2DB06FIVCwdmzZ5k4cSIXLlygRIkSfPrpp5Qu/bDqvWPHDubNm0dMTAzVq1fns88+w8HBAciZnHrOnDls3LgRjUZDu3bt+Pjjj/P9JfA42ovHX/r1vohYu/zHKBckZ0uZR+Jtojl/rKBD0BNXtGqBndvISElWlrx/DYXk27BIvg3L68j3vXtxWFub4ezs/ErPI55OoSj44Yni5YmJiSExMQ0HB8d8tzs7W7/miF6fGeYOBXLeUan3CuS84u1W4EXHzz//nMOHD7Ns2TLmzJnDhg0bWL9+PSkpKfTr148KFSqwefNmypYtS//+/XXjfMPCwhg7diwffvgh69evJyEhgdGjR+vaXbFiBTt27OCbb77hq6++Yvv27axYsaKgLlMIIYQQQgghhABAiaJAvoR4HkYFefL4+Hg2bdrEihUrdGO5+/Tpg1qds7KEqakpI0eORKFQMHbsWA4cOMCvv/5KmzZtWL16NY0bN9ZNCDhz5kzq1KnD9evXKVq0KCtXruSjjz6iQoWc8ckff/wxX375Je+9915BXa4QQgghhBBCCCHEW6VAexydPHkSKysrKlWqpHutX79+TJs2DbVaTfny5XUT/ikUCsqVK0doaCiQM+42tygE4ObmRuHChVGr1dy9e5fbt29TsWJF3fby5ctz8+ZNoqOjX8/FCSHeaBqN9HM3JJJvwyL5NiySbyHE20ipKJgvIZ5HgRaOrl+/TpEiRdi6dSuNGjWiXr16zJ8/H41GQ0xMDC4uLnr7Ozo6cufOHQCio6Mfuz0mJgZAb3vucqO5xwshDJs8aBgWybdhkXwbFsm3YZH5jYQQ4vUr0KFqKSkpXL16lXXr1jFtWs6SnhMmTMDc3JzU1FRMTEz09jcxMSEjIwOAtLS0x25PS0vTff/oNkB3/NtKqVSg/EepODtbi1arRaEAlUq/FqjVQnZ2zoSRRkZ564S5k0nm165Go0WjeXq7Qjyv3Pfkk96Hz/r+VqmU/HNF5md5fz8ax7O2m52tQav99+0+GtOT2lUoFHlWCdJqtWRnP73dN/FnxJtyD5+9XUWe5b3fxHv4qt/fr+4eFsz7W35GyM+IR9v9t+/vR/f9Z5sAw4YN48aNG6xfvyHf7e7uRfjyy69p27ZNnm25hZD8jvvndnf3IixYsJAWLVo89dh/025+2y5evEhgYClu3LipNyn4o4WbZznvrl2/0rlzZ+Li7gGKpx73PNfzLNv+uf3gwT9RKlVUrfrOv2r3jz9+p3Pnzty5cxelUvWvjk1JSWH58uUMGvQhAMOHD+PmzZz3zb+9HoUCtm3bRsmSJfH19X3itf7bdvPb9scfv9OlS851q1Sql9Luo7E+6eesEKLgFWjhyMjIiKSkJObMmUORIkUAuHXrFmvXrqV48eJ5ijwZGRm6JSFNTU3z3W5ubq5XJDI1NdX9G8Dc3PyVXtOr9ugfNf+k1fLEVUWetO1F2hXief3zffUi78Mn/XGRX7tGRkrday+z3Uc9b7tarZasrOdr9038GfEm3MNH8/30drWA3MMXeR8++R6++vd3fqtsFcQ9fBNz81/8GfG4VdVe5j3MLcrlHJt3f7U6lLp16+W7/fbt29y9e5egoKAn9pZ5Wk+aW7dy2wnOs++LtPu47d7e3jx4kIipqelj93mW84aEhP49l6kiz7Z/G9PTtj/rcQkJCdSrV4+QEPUzHfvottq163Ljxi1d0ejfHDtp0kSuX7+hKxzlvm+e53rCw0/ToUN74uLu57vf874nHretTp2H1/0i74fHbTPEZ40CX6VKiH+hQN+vzs7OmJqa6opGAJ6enty+fRtXV1diY2P19o+NjdUNP3vcdmdnZ1xdXQF0Q9Ye/bcsoyqEEEIIIV6msLAwgoKC8t2mVodiY2ODl5fXC50jNDQEBwcHihUr9kLtPCulUqn7APZFqNVqgoPLvoSIXp7Q0BDMzMzw8/P718eqVKo8ox6e1alTpwgODtZ9/6T3zbO0VaKED5aWls91/L/1ItcthHj7FWjhKCgoiPT0dC5fvqx7LSoqiiJFihAUFERISAjav8vTWq2WU6dO6X64BgUFcfLkSd1xt2/f5vbt2wQFBeHq6krhwoX1tp88eZLChQvnmRdJCCGEEEKI53XlyhXi4+MJDw/H39+XYsXcWbnye9320NCcHje5wzeXL19GQEBJbG2tqVmzOiEhIbp9s7OzmThxAp6exXFycqB3716kpqbq2sktOqSlpdGgQT0aNKhHUlJSnpji4uLo3bsXhQsXwtnZkbZt23Djxg3ddh8fb9asWUPFihUoXboU+/btpWzZYBYvXoSrqzPTpk2lY8cOjBo1ghMnjmNpaU52drbu+LNnz2JlZcHFixdJS0tj6NAhFCvmjoODHe++W58zZ87oXf/jiiOxsbH06tUTFxcnPDyKMXHiBDSanJ4nLVs2Z8qUz/X279q1C7169QIgJCSEd9+tj729LaVKBbBp0ybdfvv378Pf35c9e3ZTrlxZ7O1tGTp0CACLFy+ifv16pKSkYG9vS3Z2NpGRkTRoUA87Oxt8fUuwePGi/JMNVKlSmQUL5gPw3nt9+PTTSUycOAE3N1c8PYuze/cf+R7n7l6Y/fv3M27cWKZPn6Z736SnZ/DOO1WwtbWmfft2ZGVlAaDRaPjss8mUKOGFnZ0N1apV5dChgwCMHv0J77/fhwsXIggIKJnv+f6ZY61Wy48//kjZssHY29tSu3ZNwsLCdPtnZWXxyScjKVTIBS8vD3788Ufq1avDDz/8kOe64+Pj6devL66uzri5uTJw4ACSk5P1zr1161a6deuKnZ0NlStX0nv/iRwyObZ4mxToUDUvLy9q167N6NGjmTRpEjExMXz77bcMHDiQRo0aMWfOHKZMmUKnTp1Yt24dqampNG7cGIDOnTvTvXt3goODCQwMZMqUKdSuXZuiRYvqts+ePZtChQoBMGfOHPr06fOv4tP8/MPLveAX5Fi1XkGHkIfW7cU+PXvZtDFv1i8l7bULBR2Cvrg3bFXBolULOgIhhBDihajVOcOdoqKi2LfvADt37uCDDwZSp05dihYtilqtJigoGIAlS75l3LixLF++gsqVqzBnzmxat27JmTPnsLS0ZPjwYRw6dIgdO37G3NycVq1aMm/eXEaPHvN3z51gMjMz6dixPSYmJmzcuDnfaRjatWuDi4srR4/+hbGxMYMGfcDHHw9n3br1xMfHc/XqVVat+p7vv1+JnZ0dGzf+SExMNJcuXUStDsfMzIyqVSvTokVLfHx8yczM5Pr163h4eAAwZcrndO7cBR8fH3r16sm1a1f5/ffdODo6MnHiBN5//z2OHDlKUlISUVGR+RaOMjMzadSoIcHBwZw4cYqkpCQ6dGiPh4cHvXv3wcfHh6ioKN3+Z8+e5aeftqFWhxEZGUnDhg0YP34CP/ywjpCQU3Tq1JFSpUrh7++PWq0mMTGRJUuWsH79BuLiYqlZswaDB3/Ee++9z8GDB7G0tOTLL79CpVLx4YcfULFiJTZs2MixY0fp0KE95cqVo2LFSnoxZ2VlcfbsGd31qNVq/vzzAMOGDScs7DRTpnzOlCmfU69e/TzX+9tvfxAcXIaLFyNxd3dnx44dAKxc+R3ffrsUCwsLypcvy549u3n33YZ8+ukktmzZwsaNmylevDgLFsynQ4f23Lx5m8mTP+Pw4UM0bNiIjz8ekedc+eX4xx9/ZNiwISxZspRKlSqzfPkyOnRoR3j4GYyNjenfvx+XLl3k8OGjxMffp3PnTsTExBAUFKR33dnZ2bRu3RIzMzMOHjyMVqulc+dOjB8/ji++mKs798yZ05k4cRJz586jRYvmLF26hEmTPn2G/6KEEG+iAh9aOXv2bIoVK0bnzp0ZNWoUXbt2pXv37lhZWbF48WJOnjxJmzZtUKvVfPvtt1hYWABQtmxZJk+ezPz58+ncuTO2trZMmzZN1+57771HkyZN+PDDD/nf//5Hy5YtdZ9QCCGEEEII8TKo1aF4enqyYMFCChUqxHvvvY+7uztHjhz5e3tOwSc5OZlx48Yyc+YsmjZthpOTE59/PoWkpCSOHj3C1atXWbx4EUuXLqNUqVJ4eXkxbdo03N2L6s5TunQZevXqiUKhYPPmrfkWjVJTU+nduw+LFi2mWLFiuLm5UbVqVe7di9O1o1Ao+OKLeQQEBFC4cGHUajUeHh7MmjWHQoUKoVKpiIqKIigoCFtbW1xcXIiMvATkFHC2b/+JsWPHodVqadiwEd99txI/Pz+cnJyoVau27lzh4WGoVCpKlSqdJ87vvlsBwJIlSylWrBgBAQH07duXX3/9FQAfH1/dOSGnWNWtW3e8vb2ZOHECXbt2Y/Dgj3BycqJBg3epVas2e/bs1t1ze3sHVq1ajY+PDyVK+AA5vXiMjIwIDw+nXLlyuqF4d+7cxdTUFDs7Oxo1asz8+QsxNs47LOv8+fOkp6dTpkwQGRkZnDt3lp49ezFgwECcnZ0pVqyYrsfUP507dw5XV1eKFy+OSqVCrQ7FycmJVavWULp0aTw9PVEoFCiVOY9nFSpUZO3adQQHB2Nvb0+DBg24f/++7hpOnz5N+fLl8x0+9s8cu7q6MmrUCL7+ej6NGzfB0dGRESNGEhsbS0REBH/9dYw1a1bz3Xcr8fLyoly58vTp8x7Z2dn4+/vrXfeGDRsIDw9n3boN+Pj44Ovry+jRY9iyZbPu3AAzZ86iYcNGf08j4vLY+yKEeDsUaI8jAGtra2bOnJnvtjJlyrBly5bHHtumTRvatMm7OgXkjMMdPXo0o0ePfilxCiH+WwxxEkZDJvk2LJJvw1LQ+Var1XTt2g0jo4d/VltYWJKUlEhSUhKRkZcoUyaIAwf2k5GRQadOnXX7qVQqrKysuHfvPr/++gve3iX0euc0bdoMyJnMOSoqiuXLl3L48GG++GLuY+cfMjMzQ6lU0a9fXx48iCc5OZmLFy/SokVLXbwVK1YkICBA7xr69eun+z4sTI2pqSn+/v4Aut4/9erlFHB69uyl631kbW3F6NGfEBsbQ3JyMleuXKFkyZzhU6Ghofj7l8y3uLFp00YuXIigcOFCutfS0tKoWbOm3jkhp1i1Y8d2Tp8+S0ZGJtu3/4SRkRHr1q3VHZuYmEi1atV019OjRw9dTk6fzulF5eHhQWpqKhER5/XmGpo4cRLdu3dl27ZtjB8/ge7du+d7b9VqNV5eXlhbWxMaGkpmZiZ9+ryn23769Gn8/fMfOhYaGqJ3TrVaTZs2bbG2tgbg8uXLJCUl6Yps9vZ2fPHFHG7evEFKSgo3btzA3d0dpVLJxYsXSUxMfOzcUf/M8dGjR7h58yYDB/bngw8G6N2ztLRUNm78kdq1a+Pp6anb5uTkRKlSpf4ucj287p9+2ka7du2xtbXV7WtnZ8u9e/d05/b19aN69Rp696VDh075xmrIlMi4MfH2KPDCkRBCCCGEEG+rsDA1vXv31n2flpbGpUsX8fDwICxMjZGREaVKleLIkcN4enrpFXzu37/P7du38fAozvHjx3QFl39Sq0PRarUUKuTGuHHjWbVqFR98MCjffT///DNWrFjOp59+RmBgIJ6enlSoUI6yZcv+3ZaaGjVq6vbP7Tnz6GtqtZqAgFK6wktO759Izp49y86dOzh79jwAK1euZMSI4Xz66WQqVqxI8eIedOrUQe9cj5vfKCoqihkzZtK8eQu913NHF/j4+HLnzh1SUlKYOnUKffq8R9GiRbl69SqpqakcO/YXzs76c5fa29vrrie3iAQ58yGVLl0aIyMjQkJOARAYWEa3vVWrVpw7F8GcObPp1q0LH388gk8/nZwn5rCwUMqUCfr732q8vb1xc3PTO0///v3zvV61OlQ3ZDH3+LZt2+m+Dw0NxdXVFTc3N/bu3UObNq0ZPXoM/fr1o3hxD8aOHUNiYqJuXzc3N92CQHnPpZ/jyMgovLy8+OOPPXn2LVSoELNnzyYgoJTe66dPn9YVph697suXL9Opk34R6OzZsxQv7qE796P3Pi4ujmvXrukVzYQQb58CH6omhBAFQaWST3kMieTbsEi+DUtB5jt3PpeUlFTda5s3b8bKyopq1aqjVqspWTIAExMTzM3NefAgXu/4JUu+pUiRIpQvXwEzM3MyMzN1286cOYObmyt3795FrVZTqlRpVq1aTdeu3Th58gRnz57NN6a1a9cyevQY3VygFy5EcPXqVcqXLw/kXeXs7NmzGBsb660w9s+Cj4+PD9evX2fWrJn07duXwoULA7Bu3Q+8/35fBgwYSPnyFUhPT+fw4cOUK1fhkXMF5xunlZU1SUlJuLu74+7uDkDTpk10kyy7u7tjYWHBnj27+fnnnYwa9QmQ08MJcuZIyj32xIkTvP9+HywsLDh79ixZWVl6RZrQ0FDKli2ni8nHx1c3zK9Jk0b89NNPuLu7M3fuPKZPn8Hq1avyjfnR+/LP+5iWlkZExHld0Sz/Y3Niyn3flCtXTrc9JOSU7tgNGzbQtGkzRo4cReXKVbC2tuaXX35+JIePn3A8v9isra2JiYnB1dVVd88WLJjPokULMTIywtHRUddjCCAlJYUff9ygd625/zY3N+P+/fu6fbOyslixYgUtWrTQ7fvoPQgNDcHCwkLXe008JJNji7eJFI6EEAYpd3UbYRgk34ZF8m1YCjLfanUoRYoUYeHC+Vy/fp2DB/9k5MiPmT59JqampnorijVo8C6xsbHMnfsFsbGxrF69milTPmfmzNkolUrq1q3L3r17OHr0CBEREfTp05uWLVvh6upKaGgolStXRqVS4enpSeXKlVm1amW+MRUrVpQ9e/YQGxvL0aNH6NmzJwAlSvjoeuM8WnQIC1NTunRp3dw6Odf1z8KRLyEhp9i5cwcjR36ie71o0WIcPnyI27dvEx4eTqdOHcjKysLHpwRZWVmcOXP6sQWOli1bsmjRQk6fPk14eDjt2rWlQoUKuoVuFAoF3t4lGDNmDP369dcteOPo6EiNGjX49NNJ3L59m19//YWBA/vTpUtXFAoFYWFqSpTwwcrKSneukJAQXTHjwoUIHBzsiY+PB8DZ2YW5c+cQGRnJ3bt3+euvv/SKaI8KCwt7pJgSqlcUCw8PQ6vV6nrmPCoxMZHbt29jaWlBamoqanUoFhYW+Pr6PnLPH/ZIKlq0KCEhIURFRREZGUm3bl2JjY3VzdV04cIFbGxsdT2QHpVfjmvXro1SqeSzzyYTHR3NV199ybffLqZjx5yeQ02bNmXbtq0cPPgnV69epUuXzkRHR+uu79HrbtmyFStWLOfEiePcuHGD997rw4MH8Xz88QjduR+9LyEhIZQpU0bv/SWEePvIf8FCCCGEEEI8B7VaTb169enSpSuVKlWgd+9eTJ06jR49eui25z5wu7u7s3nzFlavXo2XlwdffjmPlStX065dznCl2rXrMGHCRDp0aE+dOrWoVq0aX375FZB3SftOnTqzdu0PZGdn54lp1qw5XLx4kRIlvBg6dCjDhw8HID09Xde7SL9godbrnfPPlcMgp8fRpUuX6NevP87OzrrXx4+fgEKhoGRJP7p370bfvv0xNjYmPT2d8+fPk5aWptf2oz75ZDRNmjSldu2aNG/elAYNGrBw4SK9fXx8fLh58wYjRozUe/2773KKZv7+vowYMYIvvphHjx49ddfzaOEiJSWFCxcidIWj2rXrcP78eZo1awLA3Lnz8PDwpHr1dyhZ0o/U1FSWLFmWJ94bN24QGxuru56wsDC984SGhuLn55/vhOWWlpbUr1+fTp068scff6BW5y3WhYaG6noJffjhYHx8fChXLpjmzZtSu3ZtPDw8SE9PB6Bhw4b8/PNO+vfvl+dc+eXY3t6eTZs2s2PHDnx9S7Bly2Z+++13AgMDAWjSpCkffzyCjh070LRpE4KDg1GpVAQGlslz3YMHf0SPHj1p2bIFwcFlSE9PZ9++A9jZ2XH27Fmys7P1hgE+2ttL6FMW0JcQz0Oh1Wq1BR3Emyr7y6EFHYIeRdV6BR1CHgo3r4IOQY825kZBh6BHe+1CQYegLy66oCPQc69F3iVkXxcjI2WBT6gqXh/Jt2GRfBuW15Hve/fisLY20yuaiIKhUIA8vbxce/fuoXz5CtjY2AAwe/Ystm//if37/3zl546JiSExMQ0HB8d8tzs7W7/yGArKQiunAjnvwKTYAjmveLvJ5NivwPTf/2LRoTBSM7PoUSmAJgGeNJi/Kc9+WfOGvNa4Pl3yA5OXrtV7rXa5QHYvnPpa43jUtG+WsHDVOlLT0ujZvhWzxn5coF3Oj4af46MZ8zl/5Tr1K5dj9eejsDA3K5BYIm7epeyQ6Uzr0YL/Na/Dgp8P8NGSH3Xb3y1bkp8nfPDK45j+80G+2X2clIxMmgSWYHHPZiSkpjNw1U4OXLhGCWd7VvVrjV+hgvnlJ4QQQgghnl/nzp3o338AH330PyIizrNgwXymTJlW0GEJId4gUjh6yQ5E3mDczsOMfbcymdnZzNx9gmqehfl1YBsAEtLS6bH6V/pULv3aY+vepC7VgnKW5Tx+9gLjFq5iQLsmrz2OXAeOnWDszHmM+98AMjOzmLFgKdUqlKV1o/oFEs+9Bwk0HjSGupXK0r9dMwZN+5ov125hdJ/OTz/4Jfvl5Bn6L1hLRlaW7rW/Ll4hyKMI03u2QqEAJxurJ7Twcuw5d5lxm/cysvE7eDnb88Gqnynh6sCec1e4n5zKwu5NmLBlH//7YRe/Duv6yuN5mbKz5eNKQyL5NiySb8Mi+TYs0tvo5Vux4js+/fRTvvrqS+zs7Pjww8F07vz6//41NDJRtXibSOHoJavmWZjzY3vhbmfFulMRABirVNT3KwZA/3V/UNjGipkta7z22LyKFMKrSCEys7IY+sW3dHq3Ju3rVX/tceSqVqEsFw78jHuhQqz96WcATIyNCyyeXUdOkpCcwpRBvfDzKMo7QQG4OTm89jiuRt+j5dTFdKtVkZV7/9K9fvziVW7fT6D55wsJ9nRn9bBerzwWOwszJrSoySdNqmNipGLMpj0ci7rJ4UvXmd+tCR0qlqKKtzvGKtUrj+Vlk1G6hkXybVgk34ZF8i3Ei2ncuAmNGxfch8lCiDefzI/1kqmUSko42/H1gVDeX/s7zUp50bSUJwCRsfGsOHaGCY2qYGZccDW71b/s48K1W3w+sHuBxQCgUqko4VGcr1as5r2Px9G8fm2a1qtVYPFcvXUXgDHfrMCianM+mPoVyalprz0OR2tLzn0zngmdHv4Cz8zKxs7Sgq41K7JxVF9uxsXTf8HaJ7TycpQr7saEFrUwMVKxcO8J7iWnUq1EzmonP4VGYP/hTN6dvZpL0fee0tKbRxZdMiySb8Mi+TYskm8hxNtIiaJAvoR4HlI4ekValPbi+24N+fXcFebsOQnA/AOh2FuY0qlc/kt8vi5fr/+Jxu9UwLNwoQKNI1fLd+uyct50ftl3kNmLVxRYHFpyPrF0c3Jg3fQxhF28zMdzv33tcViZm+Ltpj/5prGRikMzhvN1/w40q1iaDtXLc+hcJFn5rKbyKiw7EMJHP/zCu6W8qeOfUwhNTMtg46D22FmY0WXx5rfuE1+VSn78GRLJt2GRfBsWybdhkUKhEEK8fvKb9iW7HPeAdSfP4+tiT9cKJfF0tGH/pZyVvrafiaJpgCdGBfgHzrU70agvXqZV7SoFFkOuy9dusHbbTny9POjWpjmeRYuw/8jxAouniEvO5M7vtWpEy9rvUKm0H2cirxRYPI+6G5/AjE2/cfb6bQCyNRpUSiXK1/DX0/eH1AxYtYMGAd5sGtSeog45K260LudP/QAv2pQvyZ0HScQlpb7yWIQQQgghhBBCvF4yx9FLdv7uPbqt+pXTd+Jws7HkUmw8vSqX4vaDZC7HJfBx3QoFGt8h9TkAqpQu2F5PAOcjL9N18EhOR1zCzcWJS1eu0btD6wKLp2HVCliYmTJtxTra1a/B8TMRtKhVtcDieZS5iTHTN/3O76Hn6dewGuv/PEmbqsEola+2CHnmZjQDV+3E1caKQfUqcujSdVysLSlf3I0VB0PwdLJjy6lzeDjZ4WRt8UpjEUIIIYQQ4r9CJscWbxMpHL1kjQM8+bzpO3x9IJTMbA2DqgczrE451DdjAShmb12g8d2KiQOgeCGXAo0DoHGdGkwZOYSvVqwiMzOLQT27MLxfrwKLx9XRnm1zJzNk9gL6fTaPOhWDmPG/9wssnkfZWJiz9uPefLx8M32+XkPdQF/mvdfulZ93yf5TZGRlc+dBEi2/WgdAi2BfNnzQjr7f7aDnsq34F3Ji/YBXH4sQQgghhBBCiNdPoX3bJiZ5jbK/HFrQIehRVK1X0CHkoXDzKugQ9GhjbhR0CHq01y4UdAj64qILOgI991qMKLBzq1RKsrM1BXZ+8XpJvg2L5NuwvI5837sXh7W1Gc7Ozk/fWbxSCgXI08t/R0xMDImJaTg4OOa73dm5YD90f5WW2xTMz5M+CTEFcl7xdpM5joQQBkkeKg2L5NuwSL4Ni+TbsEjRSAghXj8ZqiaEEEIIIYQQQrxGMseReJtIjyMhhEEyMpIff4ZE8m1YJN+GRfJtWF7DgrJCCCH+QX7TCiGEEEIIIYQQQoh8yVA1IYQQQgghhBDiNVIi3efE20N6HAkhhBBCCCGEEEKIfEmPIyGEEEIIIYQQ4jWSybHF20R6HAkhDFJWlizfbEgk34ZF8m1YJN+GRast6AiEEMLwSI+jJ7GxK+gI9GiTHhR0CHk9iC3oCPRok+4XdAhvtrTUgo5ACCGEEEIIgyc9OMTbRN6vQgiDpJT+wQZF8m1YJN+GRfJtWBSSbiGEeO2kcCSEMEjyoGFYJN+GRfJtWCTfQgghxKslQ9WEEEIIIYQQQojXSEre4m0iPY6EEEIIIYR4Ad9+uxgTEyPdl5WVBc2aNeHcuXN6+5QtG/xSzlWxYoVn2rdr1y4MGfI/AMaPH0erVi1f+Pz/lJycjJWVBadOnXyu4ydMGE+rVi0AWLZs6Uu5RykpKcyf/80Lt/M8li1bSnx8PABZWVl8+eU8tC9hRu9r166xbt26Z95/27ZtXLhwAYA//vgdFxcnsrOzXzgOIYRhksKREEIIIYQQLyA0NJTGjRuTkJBEQkISly9fxdHRiR49uuvtExQU9FLOFRwc/Mz75p5zwoSJbNy46YXP/08WFhbExt6jXLnyz3V8WJiaMmVyYuzZsxd//XX8hWP69NOJHDp06IXb+bd27tzBxIkTsLOzA3KKfBs2rEfxEiZm6tChPQ8exD/TvqdPn6Zjx/YUKVIEgDp16nLjxi1UKtULxyFeHqVCUSBfQjwPKRwJIQySRiPr+RoSybdhkXwbljch32p1KCVLBmBmZoaZmRnOzs588MEHqNWhPHjwQLfPsxZ8niQ0NOSZ2klOTiYy8pJuX2NjY4yMXv4sFQqFAjMzs+c+Xq1WExQUDICRkRHGxsYvHNOpU6deyr1+0fPmfF/2hdvNzMzk9OnwZ76mU6dOUaKED5aWlgCoVCpMTExeOA4hhOGSwpEQwiC9CQ8a4vWRfBsWybdhKeh8Z2dnc/r0aUqWLKn3elxcHGZmZlhaWur2ye39c/nyZdq2bYOLixOFCxeiT5/euuFNAKdOnaR+/brY29tSunQpfvttl965cgsIO3Zsx87Ohq1bt+aJKyxMjUqlIiCgFImJiZiaGnP69GkAfHy82bp1K926dcXOzobKlStx48YN3bF79+6hWrWq2NnZULFiBQ4c2P/Y6x81agQdO3YAYOXK72nYsAHr16+nZEk/nJwcmD17lm7fpKQk3nuvD46O9gQHB7Fv315u3rypuy+FCxdi584dAERHR9OjR3dcXZ0pVsxd145W++T75+5emP379zNu3FimT5/21OtJTU2lT5/euLg44e5emMGDPyQjIyPfa01LS2Po0CEUK+aOg4Md775bnzNnzgDQpUtnPvtsMr/99htNmjSiWrWqrFz5PUuWfMvAgQMACAkJ4d1362Nvb0upUgFs2vSwB5hWq2XkyI8pUsQNV1dnunXrSnx8POfOncPS0pyMjAxq1KjOkSOH0Wg0fPbZZEqU8MLOzoZq1apy6NBBAEaP/oT33+/DhQsRBATkvCerVKnMggXzAYiPj6dfv764ujrj5ubKwIEDSE5O1sXxtPeGEMIwSeFICGGQpKeuYZF8GxbJt2Ep6HxHRESQmpqqVzg6e/YsEyZMYODAgRgZGen2CQoKJiMjgyZNGuHu7k54+BkOHTrChQsRTJ8+FYCoqCjefbcBLVu24tKlKPr27UvXrl1ITk7m/PnzpKenU6ZMEHv37qF371788MNaWrVqlScutVqNn58/pqamhIWpMTU1xd/fn/j4eK5evcrMmdPp3r07Fy9GolQqWbp0CQCHDx+iQ4f2DBo0mMjIywwZMpT27dsRFxeX7/Xn9BgK0v37/Pnz/PnnAX777Q/mz1/IhAnjdYWYDh1y2jl5MoQvvviCLl06Y21tjbe3Nzdu3CA2NpagoGCys7Np2rQJSqWS0NAwVq9ew+TJn3L48KGn3r/ffvsDgIsXIxkxYuRTr2fevLncunWTsLDT/Prrb+zevZuvvvoy32sdMKA/anUov/++mwsXLuHj48v7778HwHfffU+RIkVYvvw7tm3bzi+/7MLIyIjdu/fw9dffEBkZScOGDWjevAUXL0Yyb948+vV7n/PnzwOwdu1afv/9Dw4fPsqRI8e4du0q48ePw8/Pj2++mY+Pjy8JCUlUqVKVTz+dxI8//sjGjZu5fPkqTZo0pUOH9gBMnvwZVatWZdKkTwkNVZOVlcXZs2cICgoiOzub1q1bcv36NQ4ePMz+/X/y119/MX78OICnvjfEy6UooC8hnocUjl6y6Tv/xH3obBwGTaPb4o0kp2ewYPdfGPWZpPtq8sWq1x5XxPVbWDTqxZebfgUg5OIVyvcbg0OLvvSevojU9Pw/WXnVOgybgCqwlu5rxtI1BRIH5HzSM3rxDxRq0Rfvjh+ydPvuAosFIOLmXSzaD+XL7XsBWPDzAYxaD9Z9NZm84LXEMX3XMTzGLcZ11HxGbN6HVqvllzNRBH6+HLvhX9Lm263EJqW8llheJpVKfvwZEsm3YZF8G5aCzrdarQagefNmuLm5YmtrTXBwGdzd3Zk6dbpun2LFiuHg4EBCQgKffDKa2bPn4OrqiqenJ8HBZYmLuwfAzJkzqFOnLoMHf4SjoyMDB35Anz59SExMJDQ0FG/vEpw7d5bu3buxdu06mjRp+ti4cnsmqdVqAgJKYWRkhFod+vd5ZtGwYSOcnZ1xdXVBo9EAMGrUSMaOHUeXLl1wdHSka9euuLsX5ejRI/meJyws7JHCUSglS5bkm2/mU7RoUUqU8Na1u2vXrxw/fpwVK77Dw8ODunXrUa1adQIDA1EoFKjVoTg5OeHu7s769eu5e/cO3367BDc3N2rWrMWUKTmFocTEJ9+/c+fO4erqSvHixVGpVE+9nrt372JkZISNjQ2lS5dm4cKF+Pn557lOrVZLw4aN+O67lfj5+eHk5EStWrW5dy+nAJWQkMDNmzepUKECxsbGXLx4AY1GQ/nyFTAyMmLixAl07dqNwYM/wsnJiQYN3qVWrdrs2bP77zjuoFKpsLa2xsvLiy+//JrKlaugVCo5c+YMwcHBmJmZoVAoqFChImvXriM4OBh7e3saNGjA/fv30Wg0GBkZcfr0acqXL4+JiYlesXHDhg2Eh4ezbt0GfHx88PX1ZfToMWzZslmXvye9N4QQhuvlD3Q2YHvORTFu025GNqmOl7M9H6zcQQlXR67E3CeoqCvTO7zL/9m77/CmyjaO49+T0UUXHZS2QBll77JfkL1liywBZciQISBDBGTLEJwMcbFkg4rsPQTZ0LI3lE0X3TPj/aMQqaBSbJLS3B+vXLbnnJzzS+7QNnee8xwF8HJxsmiuLUdC6Dv7e1LTdKZl3T+Zh2suJz57ryv9P/+RUgXzMaJTC4vmAjh65gLdWjXhrdcboSgKRQPyWTzDEyt3HuTT5b8xvd9bPIiKpt+s7yhZMB81yxa3eJYtJ87Rd94KUnV/1uzolZuUL+jP9LfboCjg5eps9hz7r95m7IbfGdO0Oml6AzN3HKVi/jy8t3IH9YsHMLxhVfqv3MHUrYf5vH19s+cRQgghspuQkFOULl2GDRvST7HS6XRcvnyJvn37MHv2LEaOHEVIyCnTBNCurq4kJibSocObJCTEEx8fz7lz5xg+fASQfvrZ7Nmfm/ZvZ2fHjBmfmo5lZ2dH69at0Gg01K1b729zBQcH06lTp8f3yzgqqFix4tSq9Zpp27Nnz9KhQydu377NkSNHuHjxIjNmTDetj4mJXwh2RgABAABJREFUISkp+ZljPD1KCNKbSF9/PTfDfgsXLoydnR3r16+nadNm5M6dO8M+ntw3JCSEcuXKmZ6Dli1bZZiXZ9CgwQCkpaX+4/P39BxQL/J4BgwYSOPGDSlWLJBhwz5gwICB2NvbP/NYFUXBxcWZ0aM/JCIinISEBG7evGkaaRYcfIpcuXJRrFgx0/NftGgxnJycSEtLY8OG39BoNKxcucK0z7i4OGrWrAlA167dWLJkCcWKBfLeewMYPnwEFStWNO27RYuWpvvlzu3OZ5/N5u7dOyQmJnLnzh3y5cuHSqXiypUrxMXFmeZWCgkJoXDhwri4uPDbb+tp3/5N3NzcTPtyd3cjKirKtO3fvTZE1pPRP+JVIo2jLOTu5MDHrevy4eu1sNNo+GjtTkIjojl24y73Y+Jp+cUyKuTPy09937BYptCHEbQeO4uuDWuxZPvvpmUXbt1j3pAevNO0Dt9v2svWoyEWbxw9iIjk9oMwNu79g1VbdtO6fi1+nPyhRTM87dC5yzjYaRneuSUGg4Gv123hl/1HLd44Cg2LovUnC+hapwpL9hw1LT92JZT7j2JpOWU+FQrl46dh75g9S83C/lwc34t87i6sPJ5+SWE3R3vOjeuJk52WW1GxqBUFrXy6L4QQwkaFhIRQsWJF8uX788OvggUL0qFDB1atWvW4cRRC9eo1AHjvvf4cP36cceM+pnjx4vj6+lKwYAEqVqxIXFwcYWFhz8yX9ERwcDC3b99i9eo1dOzYge3btz13xJFer+fcubMZmkXdu3c3ff2kWQHpczHdunWLChUqcOPGdezs7Dh1KuSZfXp7ez/nsf85SujmzZtER0dn2PepU6dMjaGbN29kaEhA+ml+zZo1M+V6kvfatWt069aN5+nf/++fvyeZnhzzRR5P0aJFOXv2PN9+u4BZsz5l06aN7Ny5+5kroS1ZsoQRIz5g4sRJVKlShYCAgnTq1OGp5k4wZcuWRaVSmb5/0sC6d+8eSUlJHDlyFG/vPBn2+6SR5u3tzdGjx/jpp6V88slU1q1bx7Fjx3FwcOD06dOMHTsOSJ+vqV27towe/RF9+vQhIKAgY8Z8RFxcnOm4vr6++Pj4AHD6dLCpaXnjxg1TM/GJ8+fPExBQ0FSDv3ttCCFsm7zby0JBAX583LoudhoN83cfJSohiQalCuOey5G3qpdj7YCO3H0US9/FGyyWydPVmQuLZ/Hx2+1My+5GRD1e5wKAh0su7kc+slimJ+6FRVK2aGE+7v8Oc8YOZe32vcxatNLiOZ7In8eL5NQ09p46x97g8+j1Bu6GP/98fnPydMnFhTnj+LhTc9OyNJ0e91xOvFW7CmtHvcvdyGj6zlvxD3vJGmqVikDv3Hy99yS9l22jRZkivF6mCP7uLlwJe0Sl6UvwcXViVKNqZs8ihBBCZEdPNzyedunSZfz9/UzbPBkBsnLlCmbOnMkbb7xBmTJl2L17NykpKVSqVBl7e3tUKhU6XZppP927d2P06PQP1k6fPs38+Qto0KAhrVu3YenS509/cPHiRZKTkylfvkKGOW6eZHnS7ID00SxOTk6UKFECFxcXUlNT0Wq15MuXj3z58rF+/a+MGzf2uaNwnh4lFBISgre3d4YGWnDwKdOxHB2dMkzCvG/fXi5evGDKdfp0COXKVXi8rQNpaX8+B99+u4A6dV771+fvz3qk7+ffHs/HH49j3Lix5MqVi6FDh7F581Z+//13bty48cxjXblyOb17v0u/fv2pVKkyKSkp/PHHHwQFPXvc9O+DTY/N2Tl9lHhaWpopx/Hjx+nduydOTk4sWPANvXr1RKvV0qNHTw4dOsKNG9c5cuQwV69eJSEhwbTv1atX8/rrLRg5chTVqlXHxcWFLVs2U6lSpWeO+2eu8qbn9dGjP//m1+l0LFy4kFatWv3ra0NkPZnjSLxKpHFkBj/sP8HgZZtpXKYIb9Uox8Exvfm62+u0qFCcDtXKcPDKLXR6vUWyODs6UMTPJ8My4+OLj1h7MsmgUsUI/nkhg7u2p1e716lQIpB9x05ZLU/f1g2pVLwwDYdM5p2pc3F2dHjm0yZLcHa0p4hvxk/1tBo1B2d8wNd9O9CiShk61KrEwQvXLPY6alUukMXdm7P1/A1m7zwGQEFPVza99wZGI/RYusUiObKSUS66ZFOk3rZF6m1brFnvJ6dqlShRguTkZJKTk7l//z6ffjqTrVu3MHTosKdO50p/854/f362b9/Go0eP2L59G8OGDSFXrlz4+vpiZ2dHzZo1+eqrrwgPD2fevLls3LiBd97pQWhoKFFRUaYRIR07dmTjxg0ZGgFPBAcHExAQQO7cuTPMcZOamsqFC+czjCA5deoU5cqVQ6VSUa5ceQoVKsSYMR8RFhbG8uXLGTduLF27dn3u4894Clxwhv0aDAZOnz5takTUrl2bRYsWcuHCBU6cOE7//v3QaDSULl2GuLg4rl+/btpXvXr1WbJkCaGhoezZs5uxY8fQt2//f33+4uLiuH//PrlyOZGUlPSvj6dgwYIsWrSQQ4f+IDo6mr179+Du7m4arfO0/PkL8McfB7l//z5nzpyhU6cO6HQ6ihYNBODy5cu4uLgQHx+f4fvExEQ8PT157bXXmDhxAvfv32fr1i3079+XLl3eQlEUAgMDWbduLZs3byImJoa9e/eiKAqFCxfh8uVLaLVaFEVBp9ORP39+Tp06xfXr17l27Rpdu75FREQEgYFFTcd1dXUzjUB6eg6q1q3bsHDhjxw/fow7d+7Qq1dPYmKiGT58xL++NoQQtk1+CmSxxQdO0W/xBhqVLsK6gZ0Ii01gxqbfOX83DAC93oBaUVBZsWvj6+EOQGRsvOn/vp65/+Ee5nHy/GUmzltIyuMrbeh0ejQa65096ZrLiS2zPiJk0aecXTIbg9FIAR8vq+V52sPoWGas28752/cB0BsMqFUqs7+ObkREs/L4BYrlyc1bVUtRyNONfVdu80vwZXR6I01KFaJRiYLsu3LbrDnMQa+XiR5tidTbtki9bYs16/1kMuGWLVvg6uqMq6szRYoUYtWqVaxZs4569eoTEhKMu7s7BQsWBOCbbxawefNmihQpxPTp0xg27AN0Op1pAuJvv/2eu3fvUKxYIEuXLuW33zZQvHhxgoPTTwvz9/cHoEGDhri5ubFmzepncj19etLTc9ycP38evV5P2bLlTNsGBwdTsWIQAGq1mrVrf+bSpYsULVqEL774nNWr19CgQcPnPv6nRwn9dcTNlStXiI+PN+27b99+NG7chJo1azBw4EA6duxEsWLFH5+K9edV3wBGjBhJUFAQlSsH0bdvHz75ZBpdunT51+cvV65cNGzYkE6dOrJz585/fTw9evSkT5++dO36Fvnz+7N69Sp+/XU9uXLleuaxjhv3MYqiULJkcbp168q77/ZFq9WSkpICQPPmzZk7dw5Tpkx+/JpoxYgRw1m0aCEAixYtAaBEiWKMGDGCzz77gu7d3zbVcsaMmQwf/gH58vkxdeoUVqxYRUBAAGXLliMgoCDFixclOjqagQMHUbRoUYKCKtCy5evUrVuXggULmnI0adKEzZs30bdvn2fmoBo0aDDdu79N69atqFChHCkpKezdux93d/d/fW0IIWybYjTK53J/R79wYqa2P3c3jCoTF+CRy5EF77TCXqMmj2su6kz7kUoF/ehTtzLvL9tMw9JFWNrnJeY5CgjM/H0eu/kgnMC3hjL7va68/0ZTincbhre7G+++Xo/+X/zIxHfav9QcR0qe/C+dac/RkzTsNZQBndtSNCAfQ6Z/zTfjh/Nu+5b/fue/YYy6//J5Tp6j0dDJjHqrNQajkVkrNnDomylULlHkpfdJVPhL3/VmWCSBfScwu2c7ejSoTkDvj6lUJD99mtTk/e/W0rBCCZYOfTtzO70bmqnNt5y7Tsv5P/Nh42r4uuViyNrdTHy9FtO2HaZB8QC6Vi3F+2t2UT5fHjYPaJ+5LEBUh48zfR8hhBDC0qKiInFxcXjuPD9CiJcXHh5OXFwyHh6ez13v7e1i4USWs84jr1WO+0bUA6scV7zaZHLsLPTd3uOk6vQ8iImn9ZfLAWhVsTgr+r/J8JXb6PnDr9QvWYgvujSzclJY+fFg3p31HUPnLaVD3eoMatfY4hnqVQ1ixrB+fL5kNQlJyQzt3oHeb1j+ym6mPEGlGfRGU+b9sp08uV1ZMmbAf2saZSFXJ0dWDO/B8B9/pufXy6hfthhf9Mp8oyazmpUuzJSWr/H13hOk6Q0MqF2REY2qUD6fNyN/2Uevn7ZSp2h+vuls+dfPf6VWq2RUgg2RetsWqbdtkXrbFkWR01GFEMLSZMTRP8jsiCOz+w8jjszlv4w4Mof/MuLILP7DiCOzyOSII3Oz5ogjjUaFTidvNGyF1Nu2SL1tiyXqLSOOsg9pHOUstjzi6GcrjThqJyOOxEuQOY6EEEIIIYQQQgghxHNJ40gIIYQQQgghhBBCPJc0joQQQgghhMhCycnJODk5cOLEcbPsv27d2nz22WwA3nqrC0OGvA/AuHFjadOmtVmO+W9++OF7oqOj/3W75ORkatSozrRpn5g/lBDZmMpKNyFehrx2hBA2SeY/sS1Sb9si9bYt2bHe586dBaB06TJZvm+j0ciZM2coX748kH7J9Cdff/zxeNauXZflx/w3mzZtZPz4j3F3d//Xbfv27cOJE8epUKHCSx1L5jcSQgjLk6uqCSGEEEIIkYVCQkIoVqw4Dg4OWb7va9euERcXR/nyFUhISODataumJoxWq83y472IkydPvlAjaPbsWezfvw+A8uX/fXshcjJFsXYCIV6cjDgSQtgklUp+W9sSqbdtkXrbluxQ782bN1GuXFk8PNz58MNRhISEmEYBAcyfP4+SJYvj6Zmbli1fJzT0z6ucRkZG0qPHO/j55cXb25M33mjHnTt3TOsvXbpE48YNcXd3pXXrlhw48Dv+/v54eXlx+nQIarWaUqVKExcXh729lrNn00c7FS1ahF9//ZWuXd/C3d2VatWqZtjvnj27qVmzBu7urlSpUtnU0Hme5ORkhg4dQoEC+fDwcKdx44acO3cOgC5dOjN58iS2b99O8+ZN/3Yf27dvY86crxkxYiR58uTBz88PSB9BNXLkcPz9ffHx8aZr17f+8ZQ3ebMthBCWJ40jIYRNyg5vNITlSL1ti9Tbtli73vv37+Ott7owYcJEzp+/yI0bN1i6dImpcTRr1qd8/fVXfPfd91y6dIUiRQJ5553upvu3b9+OxMREDh8+yunTZzEajQwf/gGQ3lRq1KgBNWvW4uLFy9SuXYdhw4aa9h0SEkLx4iWwt7fn9OkQ7O3tKVGiBNHR0YSGhjJz5nS6devGlSvXUKlUfP/9dwD88cdBOnR4kwEDBnHt2g2GDBnKm2+2JzIy8rmPsV+/voSEBLNjxy4uX75K0aLF6N27FwCLFi3G39+fH39cxPr1G557/ytXrtCzZw+WLVtOeHh4hqbaihUr2LFjJ3/8cZhDh45w61Yo48aN/Y9VESL7U6z0nxAvQxpHQgghhBBCvKSPPhrNkCFDadeuHXnz5mXMmLHEx8dTvnx5Hj16xOTJk1i2bDm1ar2Gl5cX48dP4ODBg8THx5OUlESPHj355psFFChQAF9fX2rUqEFUVHoDZ/bsWRQtWpTx4yeQN29ePvhgOHZ2dpQr92fj6MkpYiEhIZQqVRqNRkNISDAAM2d+SpMmTfH29sbHJw8GQ/p8UKNGjWTMmLF06dIFT09P3nrrLfLly8/hw4eeeXxGo5EmTZqyaNESihcvjpeXF3Xq1DVljI2N5e7du1SuXPm5p8rFxsbyxhvtGD9+Av/7X83Ho7EqmNY/fPgAtVqNi4sLhQsX5ssvv6ZatepZVR4hhBBZQOY4+icP71s7QUb5C1k7wTOMMRHWjpDR7evWTpCRXm/tBBlFZK96eeey5oSmBrDPuCQ8QXrpQgghXty9e/c4evQoP/646Jl15ctXYPPmzSQlJdG8ebNn1iclJeHl5YVKpaZPn3eJiYkmISGBK1eu0KpV+pXR1q9fz9ChQzPcz2g0mhovwcHBdOrUCSDD6XFP5liqVes10/3Onj1Lhw6duH37NkeOHOHixYvMmDHdtD4mJoakpORnciqKgouLM6NHf0hERDgJCQncvHmTkiVLPs5wily5clGsWLHnPkdvv92dmjVr8u67fQA4c+Y0HTt2Mq3v2rUbS5YsoVixQN57bwDDh4+gYsWKz92XEEII65DGkRBCCCGEEC8hNPQmWq2WwMBA07JLly6Z5iC6fv0ar732GosXL33mvt7e3kyePImFC39k4sTJlC1blkKFClG5cpCpcXLz5g1TgwYgLCyMR48eUb58efR6PefOnc3QLOrevbvp65o1a5ruFxkZya1bt6hQoQI3blzHzs6OU6dCnpvpr5YsWcKIER8wceIkqlSpQkBAQTp16mDKGBwcTNmyZVGpnv3w5fbt22zatBGAH3743rS8W7e3OH78KJ9+Ohtvb2+OHj3GTz8t5ZNPprJu3TqOHTuOk5PTPzzzQrz65KQx8SqRj9eFEELkeAaDXL/Zlki9bYs16+3o6IROpyMlJcW0bMGC+aZmjouLC2Fh4eTLl890Gzt2DBs2/Aakz+8zevRHdOvWjQoVKnD58iVCQ0OpVKkSAE5OTiQkJJj2/c0383FxcaFIkSJcvHiR5ORkypevgE6n4/z5cxmaSE+P2gkOPoWTkxMlSpTAxcWF1NRUtFqtKdP69b8ybtxY7O3/MhQXWLlyOb17v0u/fv2pVKkyKSkp/PHHHwQFVTYd6++ukObh4cHRo8dNt7lz5+Hk5MTRo8cZOfJDFiz4hl69eqLVaunRoyeHDh3hxo3rHDly+D9URQghRFaTxpEQQogcTxoJtkXqbVusWe8SJUrg7e3NxInjCQsLY/z4jzlw4IBpDqLmzV/n2rWrfPvtAh4+fMjo0R+yZ89uWrduA0CBAvnZvXs3ERERHD58iLfffhuAwMCiALz2Wm1mzpzBgwcPWLNmDZ9//hlly5ZFURSCg4MJCAggd+7cXLx4kZSUFMqVK09qaioXLpw3zX0EcOrUKcqVK4dKpaJcufIUKlSIMWM+IiwsjOXLlzNu3Fi6du363MeYP38B/vjjIPfv3+fMmTN06tQBnU5H0aLpo6wuX76Mi4sL8fHxz9w3V65cVKhQwXRLSEigTJkyVKhQAW9vbwIDA1m3bi2bN28iJiaGvXv3oigKhQsX+dvn3Cj/vEUOoVjpJsTLkMaREEIIIYQQL8HBwYHFi5ewfv16SpcuiU6no1Sp0qYROMWKFWPp0mV88cXnlCxZnHPnzrJr1x7Tpeg//XQ2V65cITCwMEOHDuWDD9KvpvZkBNNnn32OXq+nRIlirFmzmtat25j2ffp0cIZJsgsXLoyLiwvnz59Hr9dTtmw5U87g4GAqVgwCQK1Ws3btz1y6dJGiRYvwxRefs3r1Gho0aPjcxzhu3McoikLJksXp1q0r777bF61Wa8rYvHlz5s6dw5Qpk//1+QoODs4wOqlBg4bMmDGT4cM/IF8+P6ZOncKKFasICAh4wQoIIYSwBMVolL7939FP72ftCBlV/p+1EzzL0dnaCTK6ecnaCTLKbpNj37hm7QQZqEd8Ye0IGcjk2DmXRqNCp7PmZOzCkqTetsUS9Y6KisTFxeG5cwAJy1IUGXWUk4SHhxMXl4yHh+dz13t7u1g4keVs9PS1ynFbRGazC0CJV4JMji2EEEIIIYQQQliQSs4bE68Q+XhdCCGEEEIIIYQQQjyXNI7MpNvKXWhGLwBgVchVis5cjuvHP9Dguw2EPoqzeJ5Lt+/j1LwXX/68zbRs4pJf0DR6m+j4hH+4p3l9OG8peVv0wLNpN3pO/ZrUtDSLZ5j+217yDZiGx7sT6Tp3JQnJqQAkpaZRduTntPv82UvomjXPhn3kGzwDj35T6Dp/NQkpqWwJuUzZ0V/h3ncy7b5cRkScZWt2+HYY1RZswG3qT7yxcjeJqTpO3Y+k0vz1eExbRo9fficpTWfRTE+7dPkK9rnz8MWceVbLIIQQQgghxItSrPSfEC9DGkdmsOb0NVaEXAUgMTWNHmv2UNTLjQXtanPrURzjth+1aJ4tR0NoNGI6qY/f2McnJTNu4Vqm/LTeojn+atfx08xa/itdGtdmWr9urNhxgKVb91k0w+5z1xi7ejvdawcxs0tzVh8+w6eb9nPhbhiNp/3AhXvhls1z/jpj1+6ke62KzOzUlNVHzjLxl910nreKonk9+bLr62w9fYWp6/daLFNUYgrNf9pBfrdcfN6sKpsv3+HLw+fpvm4/DloNnzWtysozN5hz5ILFMj1ty7Yd1G/eitTUVKscX7waZD4M2yL1ti1SbyGEEMK8pHGUxe7FJjDg198p7ZMbAP3jv2aKeblTq6Av3s6O2GvUFssT+jCC1uM+p2FQGdOyz9ZuYdHW32lcucw/3NP89Ib0iSyrlSpKzXIlsNNqsNdadtotdycHPm7XgAlvNKB3vSq453IgNPwRLWctJncuR/K45rJ8njb1mNCuPr3rVsbdyYHw2ATOTXufH3q3o0KAL2qVCq0FX0Pbr90lNiWNKQ2C6FGxKCf7t6JLucJciIjh7QqBvFOxKJX8PNl69a7FMj0ReusWLdp3pFH9uhY/tni16PUyUbItkXrbFqm3bZFGocgpFCvdhHgZMjl2FjIajfRau5e6Rfwo7ePBuYcncLG3Y/br/2PQbweYc+gsPs6OrHmrscUyebo6c2HhDNQqFUt2HACgU70aDH+zOZ+u3sy2Y2csluWvGletwJv1/8dbEz4HoFb5knRpXNuiGYIK+RNUyB+A+TsOExWfRMMygQxpVovyAb4UGTLTsnkK+hFUMP0SvfN3HSEqIYmGpYvg7+HK0Wt3+N+kBRT0cmdUC8s9Tzej4wEYs+skW67coVo+b6Y0SL+kr6ejPQAejvZcjYq1WKYnPD08uBxyArVaxeJlKyx+fCGEEEIIIYTI6aRxlIXmHTrHqXsRHB/0BguOnAcgKU3HtL0naVosPwP+V4YBv/7OgPW/82v3phbJ5OzogLOjAzcf/HnKVbF8eS1y7H9z4uI1ft53mBFvtaF0ofz0njaPL1dvZGinVhbP8sOeYwxesoHGZYvSpWYFFMW6/fgf9h5n8NJNNC4bSJf/lQegoLc7m4Z3571Fv9Hj23X8NqybRbI8+WTP19mRlW/WpeevB5i0NxhIvySuNTk7O+Ps7MzN0FDrBhHZnlqtklEJNkTqbVssVe/o6EdmP4b4d4oio45ykujoR6jVjtaOIYT4F9I4ykLrzl4nIiGZgtOXmZa5fPwDADOb1aBZ8QI0KZafZaeuWCtitrL7xBn0egOD32yBr1duPlm8jt0nzli8cbR4/wn6/fgrjcoEsm5oV6s3jRb/fpJ+i36jUZkirBvchZjEZPZcuE61IvlpUrYojUoHsuLwaYvlyefqBEDPoGIE+XlS1d+L30MfAhCZmJL+/6QUfF2cLJZJiMyydpNTWJbU27ZYot5ubu7ExEBcXLL5Dyb+kVqtoNdL5yinUKsdcXNzt3YMq5DfVeJVIo2jLDSn9WvEpqRP0PvjsYv8ePwiv/drTeMfNvHNkXPYaVRsvniLCn5eVk6aPZQtEgDA1EVrKF+0IFfvPuCNejUsmuHcnYf0//FXfFydGdC4Bgcvh5LHNRflCvhaNEeGPIt+w8c1FwMaVufglVto1Sq6L1hHg1KF6VqzAhuCL1KzWAGLZWoc6I+TVsP030/TvnRBjt2NoEOZQhwIfcji4KvYqVWcuh/JxHoVLZZJCCGEsCS1Wo2Hh6e1YwhAo1Gh08mIQiGEsCSZHDsLlfLJTfUCPlQv4IO/W/qkyjUC8rKqSyMiE5N5Z/UeCnm48N0bdaycNHtoWr0in/TryvrfjzJq3lI6NqjJqK5tLZrhu91HSdXpeRATR+vZS2g6/UcmrNtp0QwZ8uw9/jhPPK0//4mmMxfx5bY/WDmgI1ceRtLr+1+oVNCP73tZ7nnycXbk184NuBQRQ5/fDlIrwIfpjSqzskNdknV6hm49SofShRhUraTFMgkhhBBCCPEqk8mxxatEMRrlLOG/o5/ez9oRMqr8P2sneJajs7UTZHTzkrUTZKTXWztBRjeuWTtBBuoRX1g7QgbhCdJLz6nkE2rbIvW2LVJv2yL1ti3e3i7WjmA22739rHLcxuH3rHJc8WqTU9WEEELkeDJRsm2RetsWqbdtkXqLnEIl43/EK0Q+XhdCCJHjydha2yL1ti1Sb9si9RZCCMuTxpEQQogcz9pXSxSWJfW2LVJv2yL1FkIIy5PGkRBCiBxPrZY3GrZE6m1bpN62ReotcgqZHFu8SqRxJIQQQgghhBBCCCGeSybHFkIIIYQQQgghLEjOuhSvEhlxJIQQQgghhBBCCCGeSxpHQgghcjyDQS7DY0uk3rZF6m1bpN5CCGF5cqraPzAmJlo7QgZKfKy1IzwrJdnaCTJKyl41y255jHFx1o4ghFXIGw3bIvW2LVJv2yL1FjmFnKkmXiUy4kgIIYQQQgghhBBCPJeMOBJCCJHjaTQqdDqDtWMIC5F62xapt22ReoucQpExR+IVIiOOhBBCCCGEEEIIIcRzyYgjIYQQQgghhBDCglQy4Ei8QmTEkRBCCCGEEEIIIYR4LmkcCSGEEEIIIYQQQojnklPVhBBC5HgykaptkXrbFqm3bZF6i5xCzlQTrxIZcSSEEEIIIYQQQgghnsvqjaMdO3ZQvHjxDLfBgwcDcP78ed58803Kly/PG2+8wdmzZzPcd+PGjTRs2JDy5cszYMAAoqKiTOuMRiOzZs2ievXqVK1alZkzZ2IwWOYTisN3wqn2/Sbcp6+g/eq9JKbpTOu+P3kF7eSl7Lv5wCJZnrh09yFObw7lyw17AJi3eT+atoNMt+aT5lk2z50HOLUZwJfrdwKw5fhZyvafgPubg2k3ZR4RMfEWyzJ980HyDf8Cj8Gf0vW7X9h0+gqad6c8c7NYnu1HKfjxt/iMnseIX/dhNBqZtz8YzeDPTLfm89ZZLA/A6P1n8J23Aa85v9Fz63FS9QbmnbqGdvY60+31dQcsmulply5fwT53Hr6YY9nXsXh1qNXyuZ4tkXrbFqm3bZF6i5xCsdJNiJdh9VPVrl69Sr169Zg8ebJpmb29PYmJifTp04eWLVsyffp0VqxYQd++fdmxYwdOTk6cPn2aMWPGMHHiREqUKMHUqVMZPXo0CxYsAGDhwoVs3LiROXPmoNPpGDFiBJ6envTq1cusjycqKYXXl++ifsG89K1UjIGbj/LVkQt8WKss16LiGLHjuFmP/zxbTpyj77wVpOr+bGAdvXKT8gX9mf52GxQFvFydLZfn+Fn6frXUlCcxOZXOM76lfvkSDH+jMf3nLGPqyk183rej2bPsvnCDsb/sYWSz/1HYy533ftqCt4sTW4d2ASA2KYXuP6ynZ60KZs8CsP/qHcZuPMCYJtVI0xuYufMYNQv5cTT0PuX9vZneunZ6vXI5WiQPwO7QMGYdu8zgoECKe7gwZHcwNf08OfoginLebsyoXRZFAU9He4tletqWbTvoPWAwqampVjm+eDUoigIYrR1DWIjU27ZIvW2L1FsIISzP6iOOrl27RrFixfD29jbdXF1d2bx5M/b29owcOZIiRYowZswYcuXKxdatWwH46aefaNasGW3atKFEiRLMnDmTffv2cfv2bQCWLFnC4MGDqVy5MtWrV2f48OEsW7bM7I9n+7V7xKakMbl+RXpUCOREnxb0q1wcvcFAj/UHCXDLZfYMTwsNi6L1JwtoWL54huXHroRyIyySllPmM/anDTg7WOZNf2hYJK0nzaFhxZKmZU4OdpybP5EfhrxNhcL5UasVtFq1RfK4OznwccvaTGhVh961g3B3ciA6MZmGpQrTsFRhtp27hp+7MzPfbGiRPDUL+3FxXA9GN65GsTy5AdBq1BwLfcCNyBhafvMLYzccwNlea5E8AHpj+h9nVX09qOnvhZ1ahb1GxfH7UdyMSaDlLwcZ8/s5nLWW70OH3rpFi/YdaVS/rsWPLYQQQgghhBC2IFs0jgoWLPjM8pCQECpVqvT4U4X0TxeCgoIIDg42ra9cubJpe19fX/z8/AgJCeHhw4fcv3+fKlWqmNZXqlSJu3fvEhYWZtbHExqdforV2N2ncJ62nAGbD5OQqmPmwXPcj09kSv2KZj3+X3m65OLCnHF83Km5aVmaTo97Lifeql2FtaPe5W5kNH3nrbBcngWT+bhLiwzL/b1yc+VuGJUGT8HH3ZVR7ZtaJE9QgC8ft6qNnUbN/D3HiUpIomGpwgBcC4ti4YEQPm5ZGwcLNUXUKhWB3rn5et8pei/fTosyhWlcIgB3JwfeqlyStb1bcTc6nr4rdlgkD0Cjgj68WSwfXTcdpcLiHVTMk5s3i+XD3cGOLiULsLZVDe7FJ9Fvx0mLZXrC08ODyyEnmDDmQ4sfWwghhBBCiJelWOk/IV6GVU9VMxqN3LhxgwMHDrBgwQL0ej1NmzZl8ODBhIeHExgYmGF7T09Prly5AkBYWBh58uR5Zv2DBw8IDw8HyLDey8sLgAcPHjxzvyx9TI//n9fZkRVv1KbXb3/Qe8Mf7A99yC8d65n+qabqDRiMRlSKef/xOjva4+zozc2wSNMyrUbNwRkfmL7fc6YSczfvQ6fXo1Gbd6SPs6MDzo4O3HwY8cy6gj6ebJo4mPfmLqPH54v4bfxAs2Z52g+/n2Lwiq00Ll2YLtXKADB393Fy53KgU9UyFsvxRKuyRfBzy0WvZdv5au8pDg7rbFq3J6g4c/cHo9Mb0KjN3/s98fARP1+5y4gqxSjl5cq7204wL/gaB7rUM23T4XY+5p66hs5gQKOyXD/a2dkZZ2dnboaGWuyYQgghhBBCCGFLrNo4unfvHklJSdjZ2fHFF19w584dpkyZQnJysmn50+zs7EzzmCQnJ//t+uTkZNP3T68DzD4Pir+LEwA9KwYS5OtJVX8v7sYmkKo38PryXabtmi/fxc5ujahTMK9Z8zzPw+hYFu06TMuqZSmV3xe9wYBapTJ7E+vvRMcnsuf0RaoVL0yTSqVpVLEkK/Yds9jxFx8Mod/STTQqVZh1771pGuW2IeQyr5ctapHmzBM3ImM4cvM+HYOKU9zHgylbD7P78i10BgMtyxShlK/n43opFqvXntAw9EYjg4IC8XV2ZNrhi+wKDSNNb6RFoC+lPF3RGYyoFctlMheNJr3WRiPo9emT6avVKv76sPR6A0YjqFQKKlXGlQaDEYPBmGF/T3tyGeF/2q+iKM9M/mk0GtHr/32/z8uk1xsxGo0oSvpxM+73z8ea2f0+eaz/tt/s8RymH+fF9quYfg78ud/s9xy+yH6fl+lFa/O81+GL1+afnkNLvL4VNBqV1Z9D+RlhqZ8RSoZsL/scZs3rO/s8hzn1Z8Rf6/1vj/VFayM/I7Lvz4ic6hX/s1nYGKs2jvz9/Tly5Ahubm4oikLJkiUxGAyMGDGCqlWrPtPkSU1NxcHBAUifQPt56x0dHTM0iezt7U1fAzg6mndS4cZF/HDSqplx4CxvlArg2N0IWhbPzzctagBw6kEUg7cc5atmVano62HWLH/H0U7L9HU72BF8kT5NarLq9xO0q1EBlQVHijxNbzDQffaPNChfkq71q7PhyGlqlipikWOfuxtO/5824+PqzID6VTh49TZ5XHPh7ezEjYhohjepYZEcT1x8GEXXxZs5ez8CX9dcXI2IpkvlkkzffpQdF0PpU7Mcq05eol35os/88jWXst5uAEw9fJHyedy4Gh1Ps8J5mX70IjtCH/JuuUKsvniHtkX9X/nG0ZM/bp72T3+0PP3H3Yvu70X2azQa0elebr//lMlo/Of7mmu/r9pzmP6HtTyH5nsOrfP6tsZzmB1rIz8jnmSSnxEvkil7/ozQ/+26V+05zI61yY4/I4QQ1mf1OY7c3d0zfOJQpEgRUlJS8Pb2JiIi4+lMERERptPMfHx8nrve29sbHx8fANMpa09/7e3tbZbH8YSPsyO/dqzHpcgY+m48RK0CeZjeIIjq+bypns+bUl7pb8JLebnham/3L3szD1cnR1YM78GDR7H0/HoZVYoG8EWv9lbJAuDp6szKD/ty5d5Den2xmEpFA/j+/bctcuzv9p8kVafnQUw8rb9eRdPPlzNh/T7uRscBUMDTzSI5nmhWqhBTWtRi4aGzTNx8iAGvVeDDxlVZ0eN1HsQm0HPZVqoE5OWL9vX+fWdZpEmhvHzyWhl+u3qPD/edoUPx/Ez4X2lWtKjGg4Rkem07ThXf3HxRv7zFMgmRWX/9ZFvkbFJv2yL1ti1Sb5FTqKx0E+JlKEaj0WrXs/z9998ZPnw4e/fuNY0E2rBhA1OmTGHEiBF89913bN26FUVRMBqNNG7cmH79+vHGG28wcuRItFotU6dOBeD+/fvUq1ePHTt2kD9/furVq8eQIUNo3bo1AL/++itffvkle/bseeF8uo+7Z/2D/g+UoKrWjvAsrXWaX3/r/m1rJ8goKdHaCTIwZrO5gDSTfrB2hAzCE+TXaU6l0ajk00wbIvW2LVJv2yL1ti3e3i7WjmA2h/Pmt8pxqz/IZu+XxCvBqu+SKlasiL29PWPHjuX69evs27ePmTNn0rt3b5o2bUpsbCxTp07l6tWrTJ06laSkJJo1awZA586dWb9+PWvWrOHixYuMHDmSunXrkj9/ftP6WbNmceTIEY4cOcLs2bPp3j17NYKEEEIIIYQQQgghsjOrznHk7OzMDz/8wCeffMIbb7xBrly56NSpE71790ZRFBYsWMD48eNZvXo1xYsX59tvv8XJKX3y6YoVKzJp0iS++uorYmJiqFmzJpMnTzbtu1evXkRGRjJw4EDUajXt27fnnXfesdIjFUIIIYQQQggh0slJl+JVYtVT1bI7OVXtBcipav9MTlX7R3KqmrAUObXBtki9bYvU27ZIvW1LTj5V7YiVTlWrJqeqiZdg1RFHQgghhCXIZyS2ReptW6TetkXqLXIKmehdvErk43UhhBA5Xvqln4WtkHrbFqm3bZF6CyGE5UnjSAghhBBCCCGEEEI8lzSOhBBC5Hgajfy6syVSb9si9bYtUm+RUyhWugnxMuQnrxBCCCGEEEIIIYR4Lpkc+5/Ex1s7QUaRYdZO8KyUFGsnyCgxwdoJsre0NGsnEEIIIYQQwubJ6B/xKpERR0IIIYQQQgghhBDiuWTEkRBCCCGEEEIIYUGKImOOxKtDRhwJIYTI8XQ6g7UjCAuSetsWqbdtkXoLIYTlyYgjIYQQQgghhBBCZJm0tDRGjRrFgwcPcHR05NNPP8XDw8PascRLkhFHQgghcjyVSoaD2xKpt22RetsWqbfIKVSKdW6WsnnzZnx8fFi+fDmvv/463333neUOLrKcjDgSQgiR46lUCgaD0doxhIVIvW2L1Nu2SL2FeDW0bt2a119/HYAHDx7g5uZm5UTiv5DGkRBCCCGEEEIIYUGKDYye02g09OnThzNnzrBw4UJrxxH/gZyqloWMRiMf/X4W3282EfjDNr4/cwOAzdcfUHbxDty+/o26q/ZzKSrOormmbz5Avg8+x2PQTLp++zMJKancj46jzdcr8Rg0k6qTvuPSgwjL5dl2mIJj5uMz8mtG/LwHo9HIprPXKDPpe1yHfk6dz5Zz6WGkxfI80W35djQj5gKw6cJNyny6HNePFlBn3s9cCntk1TxbLoZS9tPluI/9lnaLNhORkGSRDJcexZNrzka+PHUNgFNhMVRavhfPbzbTY/tJknR6AG7GJlJ37QFyz99Em9+OEJmUapF8ppyXr2CfOw9fzJln0eMKIYQQQggh/t63337LypUref/9960dRfwH0jjKQisv3eHT41cYXrkobQP96L8zmP13Iui86SiF3XKxqGklQmMT6b/zlMUy7b5wg7E/76H7/8ox882GrD52nk+3/kHHb9ZxLewR87s1JyYphfeXb7NInv1XbjP2t/28XaMMvWqW4/Ndx1h29Dydf/iNwt7uLH77dUIjY+hnoTxPrAm5wopTVwCIS06l89JtFPZ0ZXHnhoRGxdFv3V6r5UlMTaPzT9so6u3Ol61fY+vFUKbuPG72DFtvPqTxz3+Qavjz6iVvbzuBo0bN7NplWHX5LnNDrgMwcM9pHiakMK9+eQ49iGL84Ytmz/fElm07qN+8Famplm1WCSGEEEII8bIUxTo3S1m1ahU//fQTAE5OTqhU0np4lUn1stChe1E4qFV8ULkYM2qXQa0oLD4XykfVijOjdlnaFvWncl53QmMTLZbJ3cmBj1vVZkLruvSuHYS7kwNHrt/lj6u3GdigKh2qlGb78K782LOVRfLULOLPxfHvMrpJDYrlSZ9V32A08lHTGsxsW4+2FYpROSAvoZGxFskDcC8mgQE/76O0T3qeJJ2OjxpWZmaLmrQtW4TK+fMQGmW9PE52Ws6N6MIPHepTwd8btUqFVm3ef7qhsYm03nCEBgW8Myy78Cie7iXz806pAlTK487Wm2Gk6Q3svh1Ou0BfOhfPR+MCedgWGmbWfKZMt27Ron1HGtWva5HjiVeXXi/zYdgSqbdtkXrbFqm3ENaRmppKixYtOHLkiGlZSkoKH330EZUrV6ZWrVr8+OOPpnXNmjXjwIEDdO3alffff5/JkydbI7bIIjLHURYq4OJIst7AvtvhGIygNxpJ0ukZVbU4ACcePmLrjYd0LpnfYpmCAnwJCvAFYP6e40QlJFEzMD87zl3nt+BLjFqzEx/XXHzXoyV+7i5mz6NWqQjMk5tPdxxh9K/7aFG2CN2rlzGtP3HrAVvP36BLlZJmzwLppxf2Wr2LukXyUTqvB+d2RJHH2YkP61dKz3MnjK0XQ+kSVMxqeQD83Zw5eush//t6LQVzuzCqXiWz5vB0sON8twaoVQpLL9wG4G5CsmkdgIeDHVej4wlPSiXNYMTTMX15bgct9+KTzZrPlNPDg8shJ1CrVSxetsIixxSvJqNR3mjYEqm3bZF62xaptxCWl5KSwgcffMCVK1cyLJ85cyZnz55l8eLF3Lt3j1GjRuHn50fTpk1xdXXlm2++sVJikdVkxFEW6lOuEEF53Gm49gDvbD2Os1bDk9GAxx88otm6g3g72TP5f6Usnu2H/acYvHwLjUsXoV6JQkD6KVlrB7yJu5MDXRb8bNFfxK3KBbL47dfZeu4Gs3ceBeB46H2afr0ab2dHJresbZEc8/44w6m74XzWqha6x6dkJafp0vPcDqPpt7+l52la3ep5Cnq4sKl3S4xAj1U7zZrD2U5DEfdcGZY9eX38dYirkcfLzZro+ZydnSlSuJAVjixeNZYcmi2sT+ptW6TetkXqLXKKV+VUtatXr9KhQwdu3bqVYXliYiJr1qxhzJgxlC5dmkaNGtG7d2+WLVuWRc+QyE6kcZSFXO21bHmjJsHdGnDm7YYYjEYKuDoRHBZNs58P4mavZWf71/DJ5WDRXIsPhtBv6UYalSrCugFvkt/DFYC2QSVoWKow7SqV5EFMPJHx5p9w+UZENCuPn6dYHg/eqlqaQl5u7Ltyi+DbD2n69WrcHO3ZNaQzPq65/n1nWWDd6WtEJCRTcOpipu06AYDzRwsIvhtO0+9+w83Bjl392uDj4mTVPL+cuYZOb6RJ8QI0KpaffdfuWiTP03wfv24jk1NN//fN5YC3oz1qRSEyOQ2AqOQ0/Jwt+xoX4t+ozXx6p8hepN62ReptW6TeQljW0aNHqVatGqtWrcqw/OLFi+h0OipWrGhaVqlSJUJCQjA8NUeqyBnkVLUstPd2OI3WHmBUlWIYHp+m1ibQj44bjxKbmsaM2mW4EZPAnfgkaufzskimc3fD6L90Ez6uzgxoUIWDV2+TxyUXlQJ8WXjgFIW83Pnl5AUKernjZYHmyMWHUXRduJGz9yLwdXXmavgjOlcuRYfv1xObnMrMdvW4HhHN7Uex1ClawOx55rSrQ+zjRsiPR8/z49EL7OrXhg5LtqbnafE/rkfGcjs6njpF/K2SZ9977Wj63W80KJqPrkHF2XDuBjUL+pk9y18VdstFETcnlpy/jZ1KxamwGCbWKI6dWkVtf09+vnqP0p4u7LwVTvuils8nhBBCCCHEq0J5RYbPdenS5bnLw8PDyZ07N3Z2dqZlXl5epKSkEB0djYeHh6UiCguQxlEWqpvfm4EVijAv5Dp5HO1Z3Kwy9+KTuB6TAEDfHelXU3Oz1xLxXguLZPpu30lSdXoexMTT+quVALSqUIzV77Xn3UUbefuHXymR14tV/dpbJE+z0oWZ0qo2X+85QZpBz4DaQZTI68H1iGgA+izbCoCboz2Rs8x/ycZSPn/+QNt2KX34ZVRiMtcfT4bdZ82e9DwOdkROftcqeWoW8mVltyaM3HCQXqt3UaeIP9+8Uc/sWZ5nRbMqvLvzFMP2n+XNYn4MLF8YgAUNytNzxyne2x1CbX8vJlYvYZV8QgghhBBCCPNLSkrK0DQCTN/L1Y5zHsUoM8z9Ld2wdtaOkIFSusy/b2RpKSnWTpBRYoK1E2Rrxtu3rR0hA820JdaOkEF4ggx/z6k0GhU6nQybthVSb9si9bYtUm/b4u1t/ov3WMuZgtaZp7PszRsvfd/ixYuzZMkSqlWrxpYtW5gyZQoHDx40rb927RrNmzfnyJEjuLu7Z0FakV3IiCMhhBA5nnxEYluk3rZF6m1bpN4ip3hFzlT7Wz4+Pjx69AidTodGk95WCA8Px8HBAVdXVyunE1lNPl4XQgiR4+n18um0LZF62xapt22ReguRPZQsWRKNRkNwcLBp2YkTJyhbtiwqlbQZchqpqBBCCCGEEEIIYUGKoljlllUcHR1p06YNEyZM4PTp0+zcuZMff/yR7t27Z9kxRPYhp6oJIYTI8dRqlXxKbUOk3rZF6m1bpN5CZB+jR49mwoQJvP322zg7OzNo0CAaN25s7VjCDKRxJIQQIsd71ecREJkj9bYtUm/bIvUWOcWr+Fq+dOlShu8dHR2ZMWMGM2bMsFIiYSlyqpoQQgghhBBCCCGEeK7/1DhKTk4mPDyc1NTUrMojhBBCCCGEEEIIIbKJTJ2qlpaWxqZNm9i9ezdHjhwhNjbWtC5v3rxUrFiRZs2aUb9+fdRqdZaHFUIIIYQQQgghXnWqV/FcNWGzXqhxZDQaWbp0Kd9++y2RkZEYjcZntrl//z73799ny5YteHl50b9/fzp37pylM7dbmuFRnLUjZKCOjbF2hOwvKcnaCTLS662dIAN9TIK1I2Qgk6wJS9HpZCJVWyL1ti1Sb9si9RZCCMt7ofdtHTt25PTp02i1WmrVqkX16tUpXrw4Xl5eODk5ER8fT3h4OJcuXeLUqVMcOnSISZMmsXbtWn7++WdzPwYhhBBCCCGEEOKV8QqPrxA26IUaR3FxcYwdO5Y2bdrg7Oz8t9vVqVMHgJSUFLZs2cLixYuzJqUQQgjxH6hUCgbDs6NlRc4k9bYtUm/bIvUWQgjLe6HG0ZYtWzK1U3t7e9q0aUObNm1eJpMQQgiRpeSNhm2RetsWqbdtkXoLIYTlvdQUI3q9noiICHx8fEhNTWXp0qVERkbSqlUrSpQokdUZhRBCCCGEEEKIHONVngtY2B5VZu9w7949mjdvzpw5cwD48MMPmTVrFgsXLqRTp06cPn06y0MKIYQQQgghhBBCCMvLdONo9uzZhIaGcvPmTSIjI9m6dSuOjo6ULFmS5ORk5s2bZ46cQgghhBBCCCFEjqCorHMT4mVk+qVz9OhRNBoNM2bM4NChQxgMBrp27cry5cvRarWcO3fOHDmFEEKIlybzYdgWqbdtkXrbFqm3EEJYXqYbRzExMbi5ueHn58exY8dQFIVKlSrh4OCAs7MzcXFx5sgphBBCvDR5o2FbpN62ReptW6TeIqdQFMUqNyFeRqYnx/by8iIsLIybN2+yb98+1Go1lSpV4vjx4zx69IiAgABz5Hw15M2HdtIC9Gu+x7DjF9NiVe1maHoMI236BxgvnQa1BnWHd1FVrwdpaeiWzcF46pDZYk3feYxv/jhDUpqO7lVKMrNlLdYEX+GjTX8Ql5JK54rFmdmqFnYatdkyZOc8HVftZt25m6bvpzasRGRSCp8dPGta1qdycea1qmmRPIfvhPP+5iNcjIihYRFflrarzZ4bDxi14zi3YhKo6OvBty3/R3EvN7NnUfLmQzv5W/Rrvke//WdUDVqh7TbYtN5w5hhps0eDlw/adz9EKVAEw6UQdN99CgmxZs/3xKXLVyhXrSYzJk9gyMD3LHZcIYQQQgghhMjpMt04qlGjBuvWraNZs2YA1KlTB4Du3bujKApNmzbN2oSvCKVsFTQ9hqFo7TKu8PZF3alfhkXq1l1RvdYU/fJ5qKrURvPuKNIGvwm6tCzPtf/aXcZuPsSYRlVJ0+uZufsE/m7OfLTxIG9WKErtIv4MXLeXPC5OfNSoSpYfP7vnATh6J5xuFQLpUq4IigJFPd14e90+GhXxZ1jNMigK5HPNZZEsUUkpNP9pB/UL+dK3cnEGbDrMrINnmfXHOeoWzMvk+hUZuvUo/TYeYs875v23pipbBU3PDzK8plWFS2K4dRXdqm/BCMTHAKDt/j645Ua3+As0XQeiafcOuqVfmTXfE1u27aD3gMGkpqZa5Hji1aTRqNDpDNaOISxE6m1bpN62ReothBCWl+lT1YYMGUKZMmUwGo34+voyatQonJ2dcXV1JSgoiD59+pgjZ/bmmQfNkMkYzp3MuFxRoXl3FMbIhxkWqyrXxnD6CIYD29B9N4O0Ce+BXmeWaDUL+XJxdHdGN6xMsTy5AfBwciBVb+C9WuXpVb0M/yvoy69nrprl+Nk9z4O4RG7HJLDx0i1aL9vBDycu4+Vkz6n7kRy7G07Ln7bz6e9n8HSyt0ie7VfvEpuSxpQGQfSoGMjJfi3pV6U4H71WjpmNK9O2ZACV/bwIjY43bxDPPGiGTsFw7kSGxUrh4ihevmiHfoKmfS+MyUmgVqOUqojh+O8YDu/GcOY4qnKWafqF3rpFi/YdaVS/rkWOJ4QQQgghRFZQFOvchHgZmR5x5O3tzdq1a3n06BFubm6oVOm9p2+++YZy5cqZvrcp8bGkfdgDDAbUtRqbFqte74Ti7oFu2TxUQyb/ub2XD0pCLNrZy8HOHv2vSzDsWm+WaGqVikBvdz7dfYLRGw/SonQhSjxu2Oy8fIu8Lk5cDo9Gb7DMJzfZLc+9uETK+uSmR1AxnO209P3tACW93Snq4crrxQtQ1ic3vX79nQ+3H+eHtq+ZPc/N6AQAxuw6wZYrd6mWz5uf2r3Gh6+VBeDEvUi2Xr1Ll7KFzRskPpbUUe+A0YC6VpP0ZWo1JMRjOH8Kw+mjaN4ZirbHMNIWTEPRaCH+8alpCbHg7mnefI95enhwOeQEarWKxctWWOSYQgghhBBCCGFLXqhxFBkZ+dzljx49Mn2dP39+0/eenpZ505htpCRD+H3w9DEtUgICUbd6C91X48H4eBI/jdbU6lW8/dD9OAtV5dqou7yH4cIpuHfLbBFblSmMn2sueq3cyWuF/eldvTTjtxxm6vaj+Lk5k5Rm2YkGs0ueID8vTg1oa/p+/tEL7Ltxn+PvtTEtW3nmOvtu3LdIHiPpj9vX2YmV7evQc/1BRmw/zvL2dTh+L4JmS3fg7eTA5PoVzRvkyWva68/XNHo9aVP+nN9If2Qv6oZt0htKj9NbmrOzM87OztwMDbX4sYUQQgghhHhZMlG1eJW8UOOoVq1aL7xDRVE4f/78SwfKKVQVaqBo7dB+MM20TDt8OmnTP4CoCIx3b2I8fRRDfBzq15qg+AVgNEPj6EZkDEdCH9CxYjGK58nNlB1H2XftDqvfbs7g2hXwyuXI28u3E52UkuXHfhXynLwXwYaLt/iwdnnsNWp0BgOKojB1bzC9KhUjr4sTOoMBrdoyI+mezKXUM6goQb6eVD1+iXNh0QQ/iKLp0h24O9ixvXtjfJwdLZInA1d31K81xXDqj/TXqloNRgNER2HU6yGXa/p2zq4Q/fxmsxDWYpSL8NgUqbdtkXrbFqm3EEJY3gs1joyZ+AmdmW1zMv3+LRjOHAfSRx9pug9Gt+QrjKFXMZw8gKrO66j+1xClZEWMOh3GW9fMkuNi2CO6/rSNsw8i8XXJxdWIaLpXKYn32G+pXzQfbcoWYd/VO0x5/X9mOX52zxOTnMbkvcFEJaUQ6OnKmYeP+KZVTQZs/IOzYY9oWjQfO6/dY8j/SlskT+MifjhpNUz//QztSwVw7G4ErUrkp8PqPcSmpDGzUWWuP4rjdkwCdQrmtUgmk9RU1C06oypdCf3eTair1cVw/HfQ6zBeCkFVpTbGuzdRla6E4eg+y2YT4l/o9TKRqi2RetsWqbdtkXoLIYTlvVDjaMmSJaavw8LCGDduHAUKFKBbt27kzZuXBw8esGjRIuLi4liwYIHZwr5SHkVgfBSR/rVWC4DxXigkJ6L/eRE4OKHu3D/9+x9nQdg9s8RoVrIgU5rX4OvfQ0jTGxhQszzD6wWRz82Z0RsPcuzWQ96vU5H3a1cwy/Gze556hX2Z3rgKX/xxloQ0HUP+V5pelYrhoFEzfvdJNl66RfvSBRlbxzJ5fJwd+bVzfYZuOUqfDX9Qr5AvTYr4szg4vbHYZ8MfALjZa4n8sItFMpkkJ5I2bwqazv3Q9B6B4fwpdD/NBSDtx8/QvjsSzdtDMFw6je7nRZbNJoQQQgghxCtEzlQTrxLFmMkhQgMGDGDfvn0cOHAAd3d30/KIiAjq1KlD/fr1+frrr7M6p1Wk9mhk7QgZqMuVsnaE7C/ezFcbyyy93toJMtDdvGPtCBnYz1tn7QgZhCfY4OT+NkKtVsmn1DZE6m1bpN62ReptW7y9XawdwWxulClmleMWOnvZKscVr7ZMX1Xt4MGDaLVa3NzcMix3d3dHq9Vy4MCBLAsnhBBCZAX5VM+2SL1ti9Tbtki9RU6hkhezeIVk+uN1FxcXkpOTmTBhAlFRUUD6aKNJkyaRnJz8TENJCCGEEEIIIYQQQryaMj3iqF27dixYsIDVq1ezevVqVCoVBkP6cFFFUXjrrbeyPKQQQgghhBBCCJFTyIAj8SrJ9IijwYMH06lTJ1QqFUajEb1ej9FoRKvV0q9fP959911z5BRCCCGEEEIIIYQQFpbpEUdqtZoJEyYwaNAgTp8+TVxcHO7u7lSoUAFXV1dzZBRCCCH+E5lI1bZIvW2L1Nu2SL2FEMLyMt04esLT05N69eplZRYhhBDCLDJ3/VDxqpN62xapt22ReoucQpFz1cQrJNONo+TkZObPn8++fftISEgwzW/0hKIo7Ny5M8sCCiGEEP+VSqVgMMi7DVsh9bYtUm/bIvUWQgjLy3TjaNKkSfzyyy8Y/6bdL51TIYQQ2Y280bAtUm/bIvW2LVJvkVPI22bxKsl042j79u0AlC5dmtq1a+Po6JjlobILXVyStSNkoE7KXnmAbDde2Jiaau0IGSUkWDtBBvps9prW/7He2hEyKt/W2gmEEEIIIYSwaRs2bKBKlSrkzZuXefPmsXnzZoKCghgzZgz29vbWjmeTMt04UqlUODg4sHz5cimaEEIIIYQQQgiRSTLi6PnmzZvHN998w6JFi7h79y5fffUVb775JkeOHGHWrFmMGTPG2hFtkiqzd2jSpAk6nY6k7Dj6RQghhBBCCCGEEK+kdevWMWPGDIKCgti2bRsVKlRg8uTJTJ06la1bt1o7ns3K9Iijdu3acejQIbp370779u3JnTs3arU6wzbNmzfPsoBCCCHEfyXzYdgWqbdtkXrbFqm3EDlbWFgYFStWBOCPP/6gadOmAPj6+hIbG2vNaDYt042jLl26mL6eNm3aM+sVRZHGkRBCiGxF3mjYFqm3bZF62xapt8gpFJWcq/Y8efPm5caNG6SkpHD16lVq1qwJwPHjx8mbN6+V09muTDeO/u5qai+6XgghhBBCCCGEEOKvOnXqxJAhQ7Czs6N48eJUrFiRZcuWMXPmTAYPHmzteDYr042jixcvmiOHEEIIYTYajQqdzmDtGMJCpN62ReptW6TeIqeQybGfr1evXhQqVIjbt2/TqlUrAFxdXRk3bhzt27e3cjrblenJsZ92+/ZtgoODuXv3blblEUIIIYQQQgghhA2aM2cONWrU4O233yZ37twAtGzZkqZNmzJ16lQrp7NdmR5xBHD69GnGjRvH5cuXTctKlSrF1KlTKVGiRJaFe1Vo2nZF27w92DmgP3mI1G9moPjlx/69j1Dy+KI/9jup334KqamoipRA22c4Kr8CGK5dJHXeNIxh982ar+OKnaw7e8P0/dTGVRhVpwIRCcmU+WINXSoE8tnrNcyaIWOeXaw791SeRlXI6+LI1D2niExKoXXJAOa1qomD9qVenpl2+E447287xqWIWBoW9qVXxUBardzzzHZpY7uaPYvRaGTMgXMsPBdKLq2GD6sWo3fZQqb135+5Qf+dwexsX4s6+b3NlkPTthva15+8pv8gdf4MSEkGOzscZv6I4f5tUmeMBkDJ649d/w9RFSmB4e4tUr+ZgfHG5X85wn936fZ9KvYdy7TeHXi/XRMAJi75hclLfyXil3m4O+cyewYhhBBCCCHEf3Pt2jWioqIAmDt3LiVKlMDNzS3DNpcvX2b16tWMGTPGGhFtXqbfmV+5coW3336bpKSkDMvPnTtH165dWb16NYULF86ygNmdqkwQdm/1I+3npRjC7mH37nC092+jrlEPY2ICaYu+wq7PCDS3b6Bbvxy7YZMwRkeS+s0M7HoOQdtjsOkNuLkcvR1Gt4pF6VIhEAWFop6uHL71kHd/3k9EYrJZj/3cPHfC6FahKF0qFEFBQatW0ejHzfSsVIySeXLzwebDlMvrwZCaZc2eJSophddX7KZ+wbz0DSrGwC1HqeTrwdYuDQCISUnj7fUH6VGhiNmzAKy8dIdPj19h+muleZCQQv+dwZT0cKWmvyfXouMZse+s2TOoygRh1/Xxa/rhXez6jEB7/w66Azuxe+9DVPkLYbh/27S9Xb9RKB5epM79BG2XPtgP/IjkD94xa8YtR0Po+9mPpKbpAIhPSmbGyo1MX7HRrMcVQgghhBAiK6jkXDWT27dv069fP5THz8nAgQOfu90bb7xhyVjiKZluHH311VckJSVRvnx5hg4dSr58+bh9+zaff/45p0+f5ssvv+TLL780R9ZsyZgQT+qqH9D9shR0OnirH6pSFVDlL0Tqgk/R79mMoWFL1BWro1u/nOTRfQBQHJww6tLS72NGD+ISuR2TwMaLt1h1+hqtSxXkh3Z1KDJrJe8EFeNCeLRZj/+3eS7dYtWZa7QuGcD37WpzeVgHvJwcOHInDAA7tdoiebZfu0dsShqT61WguKcrNfJ74+vsiLuDHQB9Nx7Gz9mRmQ0rWSTPoXtROKhVfFC5GAajka9PXePXq/eo7utBj60nCHB15FxknFkzGBPiSV35/Z+v6a79Ubx9sR8zC+PtGxijozJsnzLzIxR7B4xGA9rkJIwG8847EPowgtbjPqdrg5os2XEAgM/WbmHR1t9pXLkM246dMevxhRBCCCGEEFmnbt267N69G4PBQMOGDVmzZg0eHh6m9Yqi4OTkhLu7u/VC2rhMN46OHj2KRqPhm2++MZ1zmC9fPooXL85rr73G4cOHszxkdma8cRnd49NyNE3aori4oT97EnWZIIxxMekbxcei5M2f/nVsNLi64zhvNca4GNKWfWPWfPdiEynr40GPysVxttPQ99ffKentzomB7Sjv68mik+Y/pShDnrhEyvrkpkel4jjbaem7/ndK5snNx/WDWHPmOp1X7aayvxe9Kxe3SJ7QmAQAxu4JZsvVu1Tz92Jpm1q4O9hxLSqORSHX+KFlDRw0lmlkFXBxJFlvYN/tcAxG0BuN3I1PYuaxy9xPSObzuuVo+5t5/4099zV9+ihpG1ZiDL2Kw/y1Ge+QGI8xMR7HZTtBUZE60bxXO/B0debCwhmoVSpT46hTvRoMf7M5n67eLI0j8VwykaptkXrbFqm3bZF6i5xCBhxl5OfnB8CuXbvw8/MzjT4S2UOmG0epqanY2dmZmkZPeHh4YGdnR2pqapaFe5WoG7RA22so+lNHMJw5AZ16g9H4/I1TU0ieOAS7rv2xHzHVrKf1BPl7cWrwn0P65h8+z74b9/m4gWVG0DyTx8+LU4OeynMkPQ9A1Xze/PxWI3qs28fwLUf4quX/zJ7nSYnyOjuyot1r9NpwiJE7T7Cs3WvMPX6J3A52dCpT0Ow5nuhTrhBrLt+l4doD+OVywFmr4VFyGlOOXOSXVtVNv2BSDQYMRqNZh7iqG7RE23sY+lOH0e/f/s8bq1SkTB+FtlVn7EdMJWlgZ0hONEsuZ0cHnB0duPkg3LSsWL68ZjmWEEIIIYQQwnJ8fX357bffOHnyJGlpaRj/8p562rRpVkpm2zJ9VbXChQuTlJTE999/n2H5t99+S1JSEoGBgVkW7lWhrtsMu74jMYQcI+XT0RgfRaavcHk8oZezG8ZHEaDRoq5SCyW3F4Yzx9Ed2YsqIPDP7czg5N0IJu46QYpOD4DOYESr/k8X0/tvee79NY8BrUrFmjPX8XCyp1XJAKr4e5uaSebm7+oEQM8KRWhVPD9V/Tw59/j0vY2X79C8qD8aleWeL1d7LVveqElwtwacebshBqORCnncSNUbeP2XP2j+8x8ANP/5D36/E2G2HOp6zbHrNxJDyFFSZv7zHFyqoBooAUUwnDmBbt82lNxeqPwLmC2bEC9DbcWfe8LypN62ReptW6TeIqdQFMUqt+zuk08+4cMPP+T06dPcvn2bO3fuZLgJ68j0iKPOnTszduxYZs+ezYoVK/D39+fu3bvcu3cPRVHo2LGjOXJmW0q+Qtj1HQExUaRtWYuqeDmMsY8w3L+Dpl4z0KWhKlyMtJXfg0GP9t3hGMMfoFu/HE3tJhjuhsKTU9rMICYllcm7TxKVmEygpxtnHkYxoMZrZjvev+ZJTmXynlNEJaUQ6OnKmYeP6FW5BG+t3sM7QUV5raAvf9x6SNcKlmlANi7si5NWzYyD53ijZAGO3YukZbF83I9L5EZ0PB/UKGWRHE/svR1Oo7UHGFUlfY6jJJ2e1wvnpXVg+tDNU2HRDN4dwlf1y1Mxj7tZMij5n3pNb16LqkQ5jDGPMIZee+722jd7oDi7kLZ0PpqmbTHGRqe/roXIRl6Bv5NEFpJ62xapt22ReguRs23YsIFPPvmEtm3bWjuKeEqmG0ft27fn8uXLLFmyhLt373L37l3Tuo4dO9K+ffssDZjdaRq3QtHaQW4vHD76FADd0f2kfDYO+/dGY9fjffR/7Ea3eS0YDKR++hF2vT/AbvA4DNcvkbrgU7Pmq1fYj+lNq/LFgTMkpOkYUrMsvSw0f9Df5mlSlS8OPslThgHVS+Fsp2XS7pOsPXuD1iUDmN6kqkXy+Dg78muHegzdfoy+mw5Tr2BepjcIMs19FOBm2Uu6183vzcAKRZgXcp08jvYsblaZWv5epvVPRmqV8nDB1V5rlgyaRq3/fE2PmQWkv6b/7up/qV9Nxq7/KOze/xjjvVukTB8FyUnP3VYIIYQQQggh/k5qaipVqlSxdgzxF4rxrycNvqCLFy+yY8cOIiIi8Pb2pk6dOpQta/7Lp1tSYvta1o6QgX2QZUe/vJCXe/mYjTE52doRMkpIsHaCDFJDH1o7Qgb2/ftaO0IGUeXlk42cSqNRyYSqNkTqbVuk3rZF6m1bvL1drB3BbCKql7bKcb0On7PKcV/U4MGDqVatGm+99Za1o4inZHrE0RN58uRh0KBBACQmJhIRYb75VoQQQgghhBBCCJGzVahQgU8//ZRDhw5RpEgRtNqMZ1kMHDjQSslsW6YbRzqdjvHjx7N7924OHToEwJkzZ3jnnXdo06YNkyZNeqa4QgghhDXp9fLptC2RetsWqbdtkXqLnOJVmKjaGn766Sc8PDw4f/4858+fz7BOURRpHFlJphtH33zzDevWrUNRFO7du4efnx+3bt3CaDTy66+/UqBAAfr372+OrEIIIcRLyWZn1Qozk3rbFqm3bZF6C5Gz7d6929oRxHNk+nqWv/32G4qiMHv2bPz80q/09OabbzJnzhyMRiPr16/P8pBCCCHEfyGf6tkWqbdtkXrbFqm3ELbh2LFjrFy5kvj4eK5evYpOp7N2JJuW6RFHDx48wNXVlebNm2dY3rBhQ9zc3Lh//36WhRNCCCGyglqtoNPJx9S2QuptW6TetkXqLXIK6YE+X3x8PL169SIkJARFUahZsyazZs3i1q1bLFy4EB8fH2tHtEmZHnHk5uZGbGzsM+cbnjx5kpiYGFxdXbMsnBBCCCGEEEIIIWzDZ599hqIo7NixAwcHBwBGjBiBvb09M2fOtHI625XpEUcNGjRg5cqVdO7cmZo1a5I7d24ePnzI4cOHURSFhg0bmiOnEEIIIYQQQgiRI8hpl8+3Z88eZs+eTf78+U3LihQpwscff8yAAQOsmMy2ZbpxNGzYME6dOsWlS5fYvXs3iqJgfDxLXYkSJRg2bFiWhxRCCCGEEEIIIUTOFhUVhbe39zPLXV1dSUxMtEIiAS/ROHJ1dWXNmjX8/PPPHDlyhJiYGNzd3alevTpt2rTBzs7OHDmtQh+fYu0IGRgTEqwd4VnZbZIyvd7aCTIwxGavmhmS0qwdQQirMMpleGyK1Nu2SL1ti9Rb5BRKpieNsQ1ly5Zly5Yt9OnTJ8PyZcuWUapUKSulEpluHAHY2dnRqVMnOnXqlKVh+vTpg4eHB9OnTwfg/PnzjB8/nsuXLxMYGMjEiRMpU6aMafuNGzfyxRdfEB4eTq1atZg8eTIeHh5A+i+V2bNns3btWgwGA+3bt2f48OGoVPIvVAghbI1eL280bInU27ZIvW2L1FuInG3YsGH07NmT06dPo9PpmD9/PteuXePcuXP88MMP1o5ns16qi5KUlMTixYvp168f7dq1A2DFihWEhYW9dJBNmzaxb98+0/eJiYn06dOHypUr8/PPP1OxYkX69u1rGp52+vRpxowZw8CBA1m1ahWxsbGMHj3adP+FCxeyceNG5syZw1dffcWGDRtYuHDhS+cTQgghhBBCCCGE+QQFBbFy5UqcnJwICAggODiYvHnzsmzZMqpVq2bteDYr0yOOIiIi6Nq1K6GhoRiNRtOkXp9//jnz5s3jp59+IiAgIFP7jI6OZubMmZQtW9a0bPPmzdjb2zNy5EgURWHMmDHs37+frVu30q5dO3766SeaNWtGmzZtAJg5cyb16tXj9u3b5M+fnyVLljB48GAqV64MwPDhw/nyyy/p1atXZh+yEEKIV5xGo0KnM1g7hrAQqbdtkXrbFqm3yClkcuznO3ToEDVq1JArqGUzmW4czZ49m5s3b1K1alXOnTtHYmIiycnJuLq6cvfuXWbPns1XX32VqX3OmDGD1q1bZxixFBISQqVKlUz/oBRFISgoiODgYNq1a0dISAjvvvuuaXtfX1/8/PwICQnBzs6O+/fvU6VKFdP6SpUqcffuXcLCwsiTJ88L5Tofl5Spx2Fu9mHR1o7wrGw2pxCG7JXHmM3mOEqLy14TytnfuGPtCBnE2J23dgRhJmq1Iqc32BCpt22RetsWqbdt8faWESa2pmfPnvj6+tKmTRvatm2b4epqwnoy3Tjat28f9vb2LFiwgKZNm5KYmIiDgwPr1q2jdu3aHD16NFP7O3ToEMePH2fDhg1MmDDBtDw8PJzAwMAM23p6enLlyhWA5zaAPD09efDgAeHh4QAZ1nt5eQHw4MGDF24c9T97I1OPxdyU6/etHeFZ2W6CwmyWR5+9PhEzpmavycxVn35n7QgZ6JzWWjuCMBNFyYY/roTZSL1ti9Tbtki9bUtw8ElrRzAflYw4ep5du3bx22+/sXHjRubPn09QUBBt27alWbNm5MqVy9rxbFam5ziKj4/HwcEBR0fHDMudnJxQFIWUlBe/EllKSgrjx4/n448/xsHBIcO6pKSkZ67QZmdnR2pqKgDJycl/uz45Odn0/dPrANP9hRDirxQl/fZ3y5+3PjPr/st9X+X9ZodM/5bHlp5Dc+03Oz2HT74212M1136z03P4Kr2+/7pNdn6s2fU5fJVe36/CYzXXfrP769CcNRe2w8/Pj379+rFx40bWrVtHuXLlmDt3LrVq1WLUqFHWjmezMj3iKDAwkAsXLrB8+XL0j09TunbtGt988w3JycmUK1fuhfc1Z84cypQpw2uvvfbMOnt7+2eaPKmpqaYG09+td3R0zNAksre3N30NPNPw+ifzyxR64W0twb5U5uaOsgg5Ve0fZbtT1cJjrR0hA/vuXawdIYOY4g2sHUGYiZzaYFuk3rZF6m1bpN5C2I5SpUphNBrRaDQsX76cXbt2WTuSzcp042jAgAEMHDiQyZMnm5a1aNECAEVRMjX59KZNm4iIiKBixYrAn82dbdu20aJFCyIiIjJsHxERYTrNzMfH57nrvb298fHxAdJPd8uXL5/pawBvb+8XzlfK5cWbTJbgmMfd2hGepctepz5lt0aWQfNSFy40m9Tk7FUvx0L5rB0hg6iSpawdQQghhBBC2AIZWvW3bt++zYYNG9iwYQOhoaFUq1aNjz/+mCZNmlg7ms3KdOOoQYMGzJ49m5kzZ/LgwQPTcn9/f4YMGZKpYi5duhTdU42HWbNmAelXQDt27Bjfffed6cptRqORkydP0q9fPwDKly/PiRMnaNeuHQD379/n/v37lC9fHh8fH/z8/Dhx4oSpcXTixAn8/PxeeH6jzLDr+A7a1h1R7B3QHT1A2p6tOE364pnt4pr+OVm3wwfj0dSoQ3z7+lme52mT9p9m8oGzGZbVKZCHYdVLMmrXKW7FJlDRx4MFr1ejuKerWbM8MXpvCIvO3CTNYKBVUX++aVKJcxGx9N5yjJvRCbQq6se8xpVw1Gb65flyefafYdHZm6QZjLQK9KNzifw0X3fgme3SPnjD/GF88qGdMB/9uh8x7PwFpUxlNB36gIc3xgvB6BZ/DvGxkMcPzdtDUAKKYnxwB/2SLzHeupplMbQd3kbb6vFr+thBUr6ciuKUC/tBo1GXDcJw7zbJM8dhvHsLXNxwGPYx6rIVMVy/QvKsCRjDzD8f16Xb96nYdyzTenfg/XbpP3cmLvmFyUt/JeKXebg7yznQQgghhBBCvEo6dOjAmTNnyJcvn2mCbD8/P2vHsnkv9c68efPmNG/enBs3bhAdHY23tzf+/v5k9pKC/v7+Gb5/MtlVQEAAnp6ezJ49m6lTp9KpUydWrlxJUlISzZo1A6Bz585069aNChUqULZsWaZOnUrdunVNs6537tyZWbNmkTdvXiD9anA9e/Z8mYf7j9TlK2PfYwApqxZhvH8X+0EfYoyJJnH0AAAUp1w4jJxE2rbf0u/g4oZ9z4FoG7XAGB+X5Xn+qmvZwtTMn94sO3YvknH7QninfBE6/3KAugE+TKpTnmE7TtB/81F2d2to9jy7Qx8y6+glBlcqSnFPV4bsPEVNfy++PH4ZV3stsxtU4L1tJyjt5cbwaiUskCeMWccuMzgokOIeLgzZHUxpTxe2tq8FQEyKjre3HKVHmYJmz6KUqYzm7aEo2sdzc9nZo+k3BuOFYAxb16DuNhh1iy7oV36Dptv7KG6e6BZ+hqbtO6h7fIBuYv8syaEuXxn7dwaQunoRhvt3sR/4Ica7t1BXqILi4krK19Ow694P+/7DSR47GPvu/VCXKEvKnBnYde2D/YCRJI8fmiVZ/s6WoyH0/exHUtPSG8/xScnMWLmR6Ss2mvW44tWlUikYDHJqg62QetsWqbdtkXqLnCKz751tRZEiRRgxYkSGK6QL63vpIR2JiYkUKpQ+B9DWrVvZt28fDRs2NJ0m9l85OzuzYMECxo8fz+rVqylevDjffvstTk5OAFSsWJFJkybx1VdfERMTQ82aNTOcPterVy8iIyMZOHAgarWa9u3b884772RJtqcZE+JIWbqA1FWLQKfDvucAlFzO6E+lX13O/v0xGCMjSPnuSwAc3n0fVcmy6M+FoAoonOV5/qpwbmcK53YmTW9g2I4TdCoVQOPCvnxUswyti+WjhJcby8/e4OSDKLNnAdA//kVf1c+TMt5u2KlVaNUqLkTGMrdxJd4pW4gfQq6z9fp9izSO9I8vy1HV14MyXul5fHI50CAg/XXcd/sJ/HI5MrPOi8/d9VI88qAZPAnDoV2oazZOX5aaQtrY3pCaguKRBwwG06mBunmTwM4ejEaMKUnp67KIMT6OlJ++JW31ovTXdI+BqEqURV26AslzpqPbvwP9xTOmLOpKNdCdOoJu7zZUAYXRtusKKrXZ5psKfRhB63Gf07VBTZbsSB8Z9tnaLSza+juNK5dh27EzZjmueLXJGw3bIvW2LVJv2yL1FiJnmzZtGgD37t3j2rVrVKlShYSEBDw9Pa2czLZlunEUExPDoEGDKFKkCOPHj2fKlCksW7YMgLlz5/LTTz9RuPDLNUSmT5+e4fty5crxyy+//O327dq1M52q9ldqtZrRo0czevTol8ryogxXL5F69RIA2hbtUVzd0T1uGim+/mgbtyT5s4mQlj5/U+q6nzDcDsVh6FiLNI6eWHb2BpejYvm1Qx3y5HJg1P9KA3DifhRbr9+nc+mCFsnRqFBe3iyen64bDgNQK58XgbmdAfB0TB9p4+Fgx9VH8ZbJU9CHN4vlo+um9JrV8veiS8kCAFyLjmfR2Zv80LQyDhq1eYMkxJI2phcYDH82jgCiI1EKFUc75iuM4Q/Qb1mVvjwpAZIS0M5dD4qCbvaHWRbFcO0Shmvpr2nN62+guLqhPx+MplJ1NNVrY99zEMboKJK/mIIxKgLF0xtjXAwAxrhYFK0Wxc0d46PILMv0NE9XZy4snIFapTI1jjrVq8HwN5vz6erN0jgSQgghhBDZn0pGHD1PWloaI0eOZMuWLahUKrZt28aMGTNISEjg66+/xtnZ2doRbVKmZ+797LPPOHr0KFeuXCE2NpZVq1ahUqnw8vIiKiqKOXPmmCNntqdt2hr790agO34I3e4tANi16ogxPg7dnu2m7Qyh161y5a+vj12iWRE/Crn/+Q/t+P1Imq3YjbeTPZPNPaLmsRMPovj58h1GVCvBwtercvheJPtuhQGgYPkfnicePuLnK3cZUaUYC5tV5vD9SL48cQWAuaeukdvejk4l8ps/SEoyhD9/XiBjxAPSPv8IFND0HPHnCkWF7uvxGC+dRtN/LNhn7WTumiatse+f/prWhxxPP6SjE8lTRmJMiMfhw6mPcyhgwQ/+nB0dKOKXcWRjsXx5cXKwt1wIIYQQQgghRJabN28eFy9eZPHixaYrpHfr1o3Q0FDTnMjC8jLdONq/fz8qlYqPPvqII0eOkJaWRpcuXdi4cSMajYZTp06ZI2e2pmnUAvvBH6E/eYSkSX++sddUr43+6AGrXyL+VkwCp8OiaV38zwZI8MNHNFuxGzd7LTvfaoiPs2WuILcnNAy90cigSkXpWroghd2cOXgn/ep4kUkp6f9PTsXX2cGyeYIC6VoqgMJuudhzK/0KfBuv3aN5EV80KitdGc0xF0pQTVCpMZ47geHcSZTi6Q0+pWwVlHyFMF4MxnBoF4q7J0rerLtCmabh69gPGo3+5JH0RlH4QwB0f+xFH3wM3YFdqDy8wNUtfdSRq1t6Llc3jGlpGGOisyyLEEIIIYQQwjZs2rSJcePGUa1aNdOyatWqMXXqVHbt2mXFZLYt06eqRUZGkjt3bkqVKsUvv/yCoihUrVoVNzc3XF1diYqyzFw52YUqoDAOg0ZjjI4i9bdVqEuXxxgdhTHmESpff1LXLLF2RP64k94IqeaXfl5oik5Px3W/E5uiY0b9IG5Ex3MnNoHaAVkzP9U/Keud3mCY+sd5yudx52p0PG+UyMfVR/EsOXsTO7WKUw8fMbFWGbNnyZDn8EXK53FLz1MsH/fjk7gRk8gHVTwskuO5VCo0vUZivHAK/aFdqCpUx3j1HADqll1RnJzRrfsBVb0WGONiMD64nTWHLVAY+8ev6bQNq1GXKocx+hH6KxfQNG6F4cE9NDXrY3hwD2Jj0J86mt4krdMYTc366IOPWr1ZKsRf6fUyH4YtkXrbFqm3bZF6ixxDJsd+rocPH1KgQIFnlvv6+hITE2OFRAJeYsSRu7s7sbGxxMXFsX//fhRFoXLlyly7do1Hjx7h5eVljpzZlrZ5WxQ7O1QeXjhN+gKnaXOx69YXxTP9SmaGsAdWTgj34pIACHBLv2rd5qv3uB4dj8FopO/mIzRdsZt2a/dbJEuTwr58Uqcsv125y4d7T9OhRH5GVivBitY1SNLpGbYrmDdL5GdgpaKWyVMoL5+8Vobfrt7jw31n6FA8PyOrFudufDIAAa5OFsnxXAlx6L6ZiuKTD02PDzDevIJu4WwAdD/MxBgThab3KLCzRzdnQvrpbllA06wtijb9Ne048XMcP0l/TSdPHYUxKgKH4RNAUUj+JH1epZQfv0Z/4XT6FQUfRZEyd2aW5BAiKxmN8kbDlki9bYvU27ZIvYXI2YoUKcKhQ4eeWb5p0yYCAwOtkEgAKMZM/vR9//332bZtG46OjiQnJ1O5cmW++eYb6tSpQ0JCAl26dGHcuHHmymtRcU2z1yUAHSsVs3aEZz2+sla2oc9eI10M0XHWjpBB6r1H1o6QgeOwgdaOkEFU+bbWjiDMRFFA3mvYDqm3bZF62xapt23x9naxdgSziWtS2SrHddl23CrHfVF79uxh6NChdOzYkRUrVtC7d29u3LjBtm3b+Pzzz2nSpIm1I9qkTI84GjZsGHnz5iUpKQknJyeGDx9OrlzpI1kKFizIe++9l+UhhRBCiP9CrbbSXGXCKqTetkXqbVuk3kLkbPXq1eOrr77i7NmzqNVqfvjhB27fvi1NIyvL9BxHAQEBbN++ncuXL1OgQAFcXV0BmDJlCrVq1ZLL4wkhhBBCCCGEEP9E5jj6W7Vr16Z27drWjiGekunGEYCdnR1lymScvLhp06ZZEkgIIYQQQgghhBBCZA8v1Dhq3rw53t7eLF68mObNm//jtoqisGnTpiwJJ4QQQgghhBBCCCGs54UaR9evXycxMdH09T9RZMidEEKIbEYmUrUtUm/bIvW2LVJvkVMoKnnfLF4dL9Q4GjhwoGnuooEDs9dVkIQQQoh/o9cbrB1BWJDU27ZIvW2L1FsIISzvhRtHz/taCCGEEEIIIYQQmSRn6pjcu3fvhbf18/MzYxLxd16ocRQZGZmpnXp6er5UGCGEEMIcNBoVOp18Sm0rpN62ReptW6TeQuQ89evX/9cpb4xGI4qicOHCBQulEk97ocZRrVq1XniHiqJw/vz5lw6UnaTFJlk7QgYOEVHWjvAMxcHO2hEy0D+Kt3aEDHTRidaOkEHswzhrR8jAMSrc2hGEEEIIIYQQVrRkyRJrRxD/4oUaR0aZhU4IIYQQQgghhMgaMjm2SdWqVa0dQfyLF2ocSQdQCCGEEEIIIYQQ5pSSksKqVau4fPkyer3etDw1NZWzZ8+ybds2K6azXS/UOJIOoBBCCCGEEEIIkTX+bU4fWzVlyhR+/fVXSpUqxZkzZ6hYsSKhoaFERkbyzjvvWDuezXqhxtHmzZsztdPmzZu/VBghhBDCHGQiVdsi9bYtUm/bIvUWImfbtWsX06ZNo0WLFjRq1IjJkyeTP39+hg4dSlpamrXj2awXahwNGzbshTuiiqJI40gIIYQQQgghhPg7MsfRc8XGxhIUFARAYGAg58+fp3DhwvTt25chQ4YwduxYKye0TaoX3dBoNL7QzWCQTwGEEEJkLyr548ymSL1ti9Tbtki9hcjZPDw8iIyMBKBgwYJcvnwZgNy5cxMREWHNaDbthUYcXbx40dw5hBBCCLNRqRQMBrlCqK2QetsWqbdtkXoLkbPVrl2biRMnMm3aNCpVqsQnn3xCo0aN2Lx5M3nz5rV2PJv1wiOOxN9z6NYbt1924r75dxwHDgfArkFT3NZuxX3z7zgNHQ2a9B6dumhxXL9fQe7dx3Bbth5NpWrmC+bjj2bOb6gatAFAKVMFzYQFaL76BfXwT8HHP+P2fgFo5qxH1eIts0UyGo18dPA8vt9uJXDhDr4/GwrA6st3KbpoJ3m/3cqQfWdI1Zt/5JqSNx92P2xB3aQdAKoGrbFfsst00w6flr5dyQpoP/kBu/nr0fQbDQ6OWZ5F2747jos24LRiB/YfTAR7B9RB1XGcsxynlTux/2g6uLil5/HNh8PUuTit3InD7B9RFS6W5XkAcs/4HL8TF0w353d6A6Byd8dn50FcPxidYXvHlm3wO3EBTbESZsnzV5fuheH01ii+3LQfgFUHT1F00Ce4dh9Ng4nzCQ2PskgOIYQQQgghMk1RrHPL5kaOHEmePHk4evQoDRo0oEiRIrz55pssXbqUwYMHWzuezXqhEUcTJkzAzc2NoUOHMmHChH/cVlEUxo8fnxXZXgmaCpVw6j+EpB/ng0aLY/feGMIf4tR/KKm7t6E7dRyn4WMxREWSvPhbnIZ+hOLmTsK08dg3b43zuKlEt2mY5bmU0pVRd3sfRatNX2DviLrPRxgvhWBYvxh1h36ou76PfvbI9PVqDZqeI1C0dlme5WkrL9/l0xNXmV6zFA8Sk+m/O4SSHs702H6K9kX9qO3vyaC9p/Fxsmd0FfM0RABU5aqi6flBhserKlICQ+hVdCu/BYwQFwP2DmgHjcd44xK6DcvQdBuEpkt/dD9+loVZKmHXvT+pa5dgfHAXu/4j0UaGo23aBv3p4+h//gm7AaOw69iD1O+/wH7AKBQPL1K+/gS7rn2xe38sye93z7I8T2jLlCNx468kbd6A0WhEfysUbZnyuI+fgjq3x58barTkat8R1/dHZHmGv7Pl1AX6LlhDqi79Ep2JKan0mLeSuqUDmdSxKR+v2sq4lVtZMqiLxTIJIYQQQggh/htXV1fmzZtn+v7bb7/lwoULeHl5kSdPHisms20v1DhauXIlvr6+DB06lJUrV/7tRNlGo9HmGke606eIfrMZhvCH2DVKnxTcGBuDYmdH8trl6M+fwa7x69jVaUDy4m9BrcYQFUla8Ak05Sqiylcg60N55EE9cALGw7tR/tcofZmdHYbNKzCc+gMe3sFYrT5KgUDTXVStu4NKnfVZ/uLQ/Sgc1Co+qBSIwWjk6+Ab9Nx+ilSDgffKF6Ja3tysuHSHX67eN1/jyDMPmmFTMBzcifq1JqbFSuESKO4eaD/4BOOtq6TNm4riVwDF2RXd/q0YjuzFULoSqsqvQRY2joiPI3X5d6StXQI6HXbd30Nxz03Se50xpiSj8vYBgwGjTgdA8rTRKPYO6cuSk8Cgz7osj6k8vdDk9UP1Wl0cGzcnee8uoid+hM+mXSSuX4e28J+vHcemzXHpN4jk/XtwbNjkH/aaNULDo2g940e61q7Ekn3HAdA/nlutmK83tUoUxtvVGXvtC/14E0IIIYQQwuIUOffnuerXr0+bNm1o27Yt+fPnR1EUSpUqZe1YNu+F3llVqVIFT09P09fiKQYDhru3cXirB04DPiD19z3ob14HQFu1BsaoCNQFCoI6vSmT+Pk0XOctIvf6XRh1OuJHvJf1mRJi0Y17F4x6VE8aR3ExGLauTv+6QCBK6coYj+4BQAksjap+a3QzhqEdOyfr8zylgIsjyXoD++5EYDAa0RuN5Hdx5HpsIrtuhZPXyZ7L0fHozXnuenwsqSPfBoPhz8aRWg2J8RjOn8Jw+iiaHkPR9vyAtPlTMRr0qEpWxHAxBCUgEMXZFbR2kJaaJXEM1y9juJ4+6ZumWTsUVzf0wUcxRoWjKloKx9k/YHh4j7R1S9LvkBCPMSEep9W7QVGRPG5QluR4mto7D2lXLpG4fh3GxETcxk4i1/WrhHVqg+7KJZxav2HaNvX4MR62aIhDvQYWaRx5uuTiwhejUKtUpsaRi6MDs7u3YtCPvzBn6wF83FxY88HbZs8iXh0yH4ZtkXrbFqm3bZF6C5GztWvXjo0bNzJ//nyCgoJo164dTZs2JVeuXNaOZtNeqHG0dOnS534t/pT6+x4MEeHkGjMZXfAJktevwanPYBzf6YchIgxF5QCA49t9MDyKInHmRBw6vU2uj6YQ3fF1SE7KujApyZByHzyfHcqnBBRF/f5UiI9B/+vi9FPYegzHsGMd3L+VvpFaDSoVmOEKeX3KFGTNlXs0/PkP/HI54KxV4+NkT6/SAYw/fJGpRy/j5+xAkjHrR9GYpCRD2H3w8vlzmV5P2qQ/GzD6I3tRN2wDcdHof16Mut072NVtjjHs3uMtsv6PFk2jltj1/QDdycPo924DwBB2n+TxQ7B7bxT2Qz4mZXL6HFqoVCRPGYm2bRfsP/yEpP4dISkxy7KkXTxPeKc2pu+dOnTBvnJV4r+b98y2+gf3nllmTs4O9jjntedm2J9zGCWlpjHtl100rVCCAU1rMuD7dQz4fh2/juxp0Wwi+5I3GrZF6m1bpN62ReotRM42cOBABg4cyOnTp/ntt9/4/PPPmTJlCo0bN6Zt27ZUr17d2hFtkgyQ+49Uvv7YNWqG4dZNUrdtxHDvLpqgKiR+Po3oLq2IbtsQw+1QDI/fXGur/Y+0IwdJO/IHKZt/ReWdB3WhIpYJm69wetMoKQHd7FEQF50+gsYrL+rmndHO/Q0AdfPOqJp3NksEV3stW9rUIPitupzpWg+DEQq4OvFFnTKEvFWPGz0bUdQ9FwVcsn4C6n8Olht1i04ofgHp3z9pnBmN6DetJO3DHqQO7YzxfDDGmEeQlpalh9fUb47dgA/RBx8l5ZMPIZcz6hp1UNRq9KeOoA8+grpMRQDUlWqgKhiI4fRxdHu2ovLwQuWftac8akuUwqXPAHg8R5aiVptOlcuOzty6z71HsXStXYlmFUvSpHwJdp+9Yu1YIht5BeaCFFlI6m1bpN62ReotcgyZHPsflStXjrFjx7J//36GDx/Ozp076dGjh7Vj2axMTwISFRXF1KlTOXLkCAkJCRj+MipFURSCg4OzKl+2pw4ohPPET0kqXBRDRDiqfAVI2bye3FsPknb8CKn7dqGpWIWkBV8CoL96Gbta9Ug7dhj7Vu0xJiRguB1q/qAaLZp+Y8HRCf2671G88kJub4y3rqGbPvTPzT78HMOBrRgObDNLjL23I2j0yx+MqlwUg9FIkk5P84I+5Pl2K/XzedG6iC/77kQy5X+WuTKXSWoK6pZdUJWpjH7PRtTV62E4vh+MRuxmLsEYE4V+xy+oqtbGcGhXlh5ayV8IuwGjMEZHodu4BlXJcqDTYT9sAvrgY+j2bkVd9TX0F04DoO3UC8XZhdTF89A2b4cxNhrDnax9DSnOzrj0HYji5o7+dijaosVJWLUsS4+RlYrm9cLRTss32//ATqNm86kLVCjo/+93FDZDrVah05n/ao0ie5B62xapt22RegthG+7fv8+GDRvYsGED165do2rVqrRr187asWxWphtH48aNY/fu3RiNzx8m+ncTZ+dUaYcPkDj/Cxw6dAWNhpR1K0hethBD2EOc3huKplRZklctIXlV+il+8ZNGk+vDiTiPnYIh7CHx40dgjI8ze06lbBUUb18ANN3TG0XGxHh0Q9/EeONihm2NjyIgOsIsOerm92Jg+ULMC7lBHic7FjcJ4jV/T+bWK8dHB89z7OEj3q9YmMEVLDQK64nkRNLmTEbzVn80747EcP4Uup/mApC26HO07wxB020QhuMH0K36LksPrW3aBkVrh+LhhcPHswHQHd5Hyowx2PUcjP3gMejPniJ17nQAUj6fiP3A0dgPG4/h7i2Sp4zM2lMdgdTjR4n54lOcu76D4uBI/E8LSfxlTZYeIyvldnZi1bDujFq6gXfmriCoUD4W9H3T2rGEEEIIIYR4LkVlW++bX9TKlSvZuHEjJ0+exN/f3zRRtp+fn7Wj2TTF+HcdoL9RsWJFkpOTadWqFRUrVsTe3v6Zbdq2bZtlAa0p6n9lrB0hA5ey+a0d4RmKg92/b2RB+kfx1o6QgS466+Ydygoxd6OtHSEDn1G9rR0hg6h6fawdQZiJRiOfUNsSqbdtkXrbFqm3bfH2drF2BLNJ6vCaVY7ruPp3qxz3RVWsWJGmTZvSrl07uTBXNpLpEUfOzs5otVpmzJhhjjxCCCGEEEIIIUTOZmNn6ryogwcP4uTkZO0Y4i8y3Tjq0qULX331Ffv376d27drmyCSEEEJkqcyNrRWvOqm3bZF62xaptxA5z+jRoxkzZgzOzs5Mnjz5H7edNm2ahVKJp2W6cdS7d282bNhA3759CQgIwMvLC5Xqz4uzKYrC4sWLszSkEEII8V/o9XJagy2RetsWqbdtkXoLkfPcuXPHdNGtO3fuWDmNeJ5MN45mzJjB9evXAbh58yY3b97MsN7WJscWQgghhBBCCCEyRSbHNlm6dKnp6/fff59y5cphZ5e95tK1dZluHP36668oikLRokUpU6YMWq3WHLmEEEKILKNWq+RTahsi9bYtUm/bIvUWImcbNGgQ33//PaVLl7Z2FPGUTDeONBoNjo6O/PLLL6jVanNkEkIIIbKUDIa1LVJv2yL1ti1Sb5FTyJk6z+fh4UFcXJy1Y4i/yHTj6M0332ThwoXcu3eP/Pmz3+XhhRBCCCGEEEII8eqpXbs2ffv2pU6dOgQEBGBvb59h/cCBA62UzLZlunGUN29e3NzcaNeuHTVq1MDd3f2ZybHHjx+fpSGFEEIIIYQQQgiRs23btg1PT0/Onj3L2bNnM6xTFEUaR1aS6cbR5MmTURQFo9HIjh07MqwzGo05qnEUE5tq7QgZOETEWjvCM9QujtaOkEHaowRrR8ggKSx7DbMMD0+ydoQMfFJSrB1BCCGEEEIIy5PJsZ9r4cKFBAQEWDuG+ItMN46qVKlijhxCCCGE2chEqrZF6m1bpN62ReotRM7WtWtX5s6dS7ly5awdRTwl042jpy+VJ4QQQrwKjEZrJxCWJPW2LVJv2yL1FjmGTI79XFqtFo0m020KYWYvVJH58+fTsWNHPDw8XnjHSUlJrF69mrfffvulwwkhhBBZQaVSMBjk3YatkHrbFqm3bZF6C5GztW3blt69e9O6dWsCAgJwcHDIsL5NmzbWCWbjXqhxNHfuXObPn0+DBg1o3Lgx1atXJ3fu3M9sFxUVxaFDhzh48CA7duwgMTFRGkdCCCGsTt5o2Bapt22RetsWqbfIKRQZcfRcc+fOBdLnOvorRVGkcWQlL9Q4Wrt2LRMmTGDLli1s3boVAG9vb7y8vHByciIlJYUHDx4QEREBpE+SXalSJcaOHWu+5EIIIYQQQgghhMgxLl68aO0I4jleqHFUokQJVq5cyaFDh1ixYgWHDh0iLCyMsLCwDNu5ublRu3ZtOnXqRKVKlcwSWAghhBBCCCGEELblwYMH5M2b19oxbFKmZp2qUaMGNWrUQK/Xc+XKFR4+fEhcXBwuLi74+/sTGBhorpxCCCGEEEIIIUTOoJJT1Z7n9u3bzJgxg8uXL6PX64H0M5pSU1OJiori/PnzVk5om1Qvcye1Wk2JEiWoU6cOLVq0oE6dOjbdNLIvVx6/VesIOHqKPF/ORXlqAi+XNzpQ6OxlHKpUzXAfbWBRAk6cwf29QWbJpGnbDcfv1+O4ZBt2Q8aDvQNKoaI4zFqUvmzgWLCzA0BVJgiHL37CcclW7N4fDw5OZsmk5M2H3XebUTdul2G5qk5z7BftRClRPn27/IXRfjwHu/nr0QydCm4vPin7i9K2747T4o3kWrkT++ETwf7Pmmkat8Z5w2HUZYIAcN5w+JmbqkzFLM8E4DJxBt5HzmVY5tC6Pd5HzqENqgKAumgJ3H9cide+4+Re+RvaytWyNIN94cKUvXIJr149AXAsXZpiWzZT5uxp8n82G8XeHgCnChUouvE3yl66QLHNm3CqmP6cKPb25P98NmXOnqbYls04li6dpfmmb9hHvkHT8Og7ia7zVpGQksqm4IuUGfUFrr0nUGfKt1y6H56lxxSvPpkPw7ZIvW2L1Nu2SL2FyNkmTZrEpUuXaNKkCQ8fPuT111+ndOnSREREMGHCBGvHs1kv1TgSf1K5upF3wY/o7t8ncvpUnGrXwbXbOwBo8ufHY+SHz95Jo8V7+ixUj9+AZ3mmMkHYde2Hbs8WUpfMQf2/BmjbvIX9++MxpqaQuvBL1LUaomnWHhwcsR8+FWNkGKnfzkZdsTp272R9M0tVtgraUbNQtHYZV3j7ounUL8MizYCPQaVG98MsVP4BaN8dlaVZ1OUqYf/2e+h2bSLlx6/R1GqI3RtdAVDy+mPfa3CG7ZPGDjLdDHduor9yAcOlc8/b9X9i36AJDk1bZFim8s9PrvdHZljmMvwjVG5uxE0dj+HhA1zGf5JlGVzq1qXIyuUZXpsFvvoCQ3IydydOxr1VS7x6vANAwLw5GPUGQgcOBpWKgLlfA+DVswfuLVpwd+JkDCkpFPjqiyzLt/v8Ncau2U7314KY2akZq4+cYfy6nXSes5LCeTxY3PdNQiOi6ffjr1l2TJEzyBsN2yL1ti1Sb9si9RY5haIoVrlldydPnmTKlCl88MEHBAYG0rBhQ77++mv69u3Lvn37rB3PZknj6D9yrFkLlYsLj778jPif13L3jdbErVwGKhXen8xEd+/eM/fJPeh9FLXabJmMCfGkrvyetFXfo9+5ARLjUZWqgCp/IfR7NqPfsxnDtYuog2qg8g9AcXFFt2sT+gM70B/7HXX1OlkbyDMPmqFTMJw7kXG5okLbZxTGyId/LnN2RZU3H4ajezEc/x3979tQSlXM0lFQxoR4UpZ9R+ry79BtXw8J8Sh5fEGlwmHoeAzhDzJsrw85hj7kGIq7B4qPPylfTIK01CzLA6Dy8sZ51Mforl15aqEK1/HTMDz4y2tIpcIQFUla8HH0d25BatZk0fr7U2jhD8T9fiDDMoeiRYlau5ZHa9aQdPoMrnXrotjbE7F4CfcmTiJ2xw7iDx5E6+MDGg2udeqQdPYcj9asIWr1ahyKFkXr758lGd2dHPi4bX0mtGtA73pVcHdy4MK9MD5qXY+ZnZvRtkppKhfyJzQiOkuOJ4QQQgghhLCc1NRUChQoAEChQoW4dOkSAG3atCEkJMSa0WyaNI7+I41/PgByD/mAgifP4jluIoqjE269+6D2zkPUF7MzbG8fVBnXrm8T/tHI5+0uSxhvXEa3ZiHodGiatEVxcUN/9mT6uriY9I3iY1Fye2GIDMeo16MqGwTuHqgKFUNxcTOdxpYl4mNJHfUOul+XZFisbtEJxd0T/dof/lyYEI8xKRGleDlwcUNVpCSKSoWS2yvL4hiuXSJt5Q/pz0/zN1Bc3dAHH0PbvjuKpxepi+c/eyeVCru33kW3ZwuGWzeyLMsTLuOmknbiKCm7t5uWOXXvjcrbm4R5X2TYNn72NDTFSuC5YTcObd4kbuaULMmgf/SIi3Xr8eDzP4+nzetjWgegj4lG45MHY0oK4Qu+JfHkSbT58uHetg3xR46AToc2rw/66MfbR0en78fHJ0syBhX05+O2DbDTaJi/8zBRCUl0qVGBD1vWoYSfNydu3GXr6cs0LFMkS44ncg6NRn7d2RKpt22RetsWqbfIMVSKdW7ZnL+/P5cvXwbSG0cXLlwAwGAwkJCQYM1oNk1+8v5Xj4f76cPDCPvgfeyKFcd7yjRy9xtI5KTxppEpilaL4uyM9ycziF30A2nXrqYvV6vBTKOP1A1aou09DP2pwxhOH3/+RtGRpK36AU3DVjh+tx6enKKUlaOAU5Ih/H6GRUpAIOpWXUlb/CXGtLTHgTWAEd2yOahKB2H/9Trw9uX/7N13dBRlF8fx7+xueiG9QELvgVBDR4o0Bekg8iooKCC9I7333qUriPTeO0iRXkKoCSUEAimQ3rO77x8J0QgqCcEE9n7O2QOZmZ357dx1ZW+eeSbrA6XQNGiKSdcBJF/6HV3AA4zbdSJh4VRITh3BY6RJq6+6Ug1Urm4k7dmc5TlMW7dHU6wE0bOnpJ4D0JQui3nn74maMg79y9FNRkagKJh/0wXdixeE9+5C0sVzWI2cAKZmb51DFxtLov+j9AtfDmfVv/78G7u7UXjDelRGxjwZNTrtOfq/2T6rrDh+gd5rdtOgdBHaV0uZG+vi/cc0mrYKRysLxrdu8E6PL4QQQgghhMh6LVq0YPDgwZw4cYLatWuzdetWli9fzoQJEyhWrFh2xzNYGbqr2p+9ePGCixcv8uzZMzp06EBwcDBOTk5Zme29oA1KuawpassmEm/dJOH6NTTOLijGxrgsXZm2ncvSVTz95kuM3Nyx6dodm67dAbDp2h29Vkv4ovlZmktd51OMuw1Gd+08CdOG/jFix8o69c9c6MNCAUje/gvaM0chIR5Nm69RzC2z/FKsv1KVq4ZiZIzxwClpy4wHTSVxygB0pw+TeOd6yuuoVBul1dfon2ftZMeajxtj0uMHtFfOET/pB4xbfYViZIzZuLlp25iNm0fc0O5ofS6jqVQTXdBTdPfvZmkOAJO69VHZ2mG/62jaMtvlawGwmbc0bZnNvGWEf/81xlWqE79vF0nnThOfKxfW46ejKVCI5Fs+WZ4tOTgYALWtbcqfNrYkB6UsM3J1pdCG9agsLLj3v/+R4HcPgKTgYDQ2tumelxQU9NddZ9rPJy/TbdUO6pcqzJY+/0NRFK76B9Jo2ipszM04+EMnnHNZZtnxhBBCCCGEEP+NLl26YGJigl6vx9PTk+7du7N48WJcXV2ZPn16dsczWJlqHM2ePZuVK1eSnJyMoih06NCB//3vf1SoUIGJEyeifofz9+Q0sadPoouNxea7bsQc3I9JaU9ijx4hdPRwAIxLeOAwcgyh48eQcPMGge3bpD0396+biNqyiagtG7M0k+JeAOOugyDiBUl7N6Mq7ok+Igzd08doan8KycmoChYlad0yAEwXbEAf/oLkPZvQVK1D8slDWZrndbQn9qK7fiElb74iGHXoTdLqeegf+mI0ZDrY2KPdsgp1rU/QeZ+HxPgsO7YqbwFMegxBH/6CpN2bUJfwJNn7IsmXf09ZX6g4pt8PIn7xdLT3bgOgLuGJ9k7WN2YAoqdPQLGwAMC0aSvMmrUmrMtXoE0GQFOsJFaDRxI1bTzJd26S7HcX45p1MD7/O6bNWqOLiUEb4P9OsiU+CiDh4UPsWrdGn5iEWSkPns2cBUC+BfMwdnPj6ZSpqK2tsaxRnejfzxJ18hTOvXth27oVdq1bE+/rS9KTJ1mS58bjIL5ftR1nawt61K/C6bv+OFpb0Hb+OiLjEpj2xSfcD35BwIsIahUvkCXHFEIIIYQQIsu9BxNVZwdFUfj666/Tfu7SpQtdunTJvkACyETjaM2aNSxZsgSNRoNKpUKn0xEbG0tAQACPHz/Gzc2Nnj17vousOZLu+XOCenbDfugIHMZOIO7cWV7MmoYudU6Yl7cuT7rvhz4mhgTv9BN6JQc9Q5uFozEANPWbpdy9zNYB0+EzUo5z/jcSZo7ApPswjL/pg/b0EZL3plx2lbhkGsZdBmH8bX+0506QtGZRluZ5rbDQtBFPpN5pTR/oD/GxJK/7EU2XIWg69Ud34zLJP83O0kNrGrVAMTJGsXPAbHRKEyT57AniJ6bcvU0xSqmZ/tEDiItNWWbviP7sb1ma4yXtg3tpf9dVqZGS59rltGWKsUnadvqYGKLG/IDl0LFYj5qINjiIqJED0UdHvZNsAP7f98B9+jTyjBlF+O7dhK76CbNSHlh4eQHg+sMfd727XsqTkCVLMcmfnzxjRpMY8JhHvftmWZZlxy6QmKzlWUQ0zWatAcDK1ISo+AQAuqzYBkAuc1Oe/zgyy44rhBBCCCGEEIZK0WdwMpJPP/2Uhw8fsnXrVrp27UpwcDC3bt3i8OHD9OrVCzc3Nw4devcjVv4LD0oVze4I6TgXc8zuCK9QW7393DpZKel5dHZHSCcu+N01dDIj8GnOmlCu1MSc9duDF416ZXcEIYQQQgiRytHRKrsjvDNJXRply3GNlu7PluOK91uGJ8cOCAggV65cFC9ePN3yevXqYW1tTVAWj54RQgghhBBCCCGEENkjw40jOzs7IiMjCQwMTLf8+PHjRERE4OCQdbdNF0IIIbKCWi03ETUkUm/DIvU2LFJvIQxXYuK7vYGT+HsZ/uRt3LgxWq2WNm3aEJY6j0+bNm3o3r07iqLQqFH2DLkTQggh/o7MP2lYpN6GReptWKTe4oOhKNnzyOE2bnz9jaOuXLlCs2bN/uM04qUMN4769u3LRx99xPPnz0lMTESv13P9+nV0Oh3VqlWjVy+ZI0QIIYQQQgghhBAZM27cOLZu3Zr2c0JCApMnT+Z///ufXN2UjTJ8VzVjY2OWLl3KmTNnOHv2LOHh4Tg6OuLl5UWVKlXeRUYhhBBCCCGEEOLDocr5o3+yw4wZMxg8eDAqlQo3NzeGDRtGeHg4Y8eOpU2bNtkdz2BluHH0UrVq1ahWrVpWZhFCCCGEEEIIIYSBatSoERqNhgEDBpCUlESDBg0YMWKEjDbKZhluHMXHx7N48WLOnTtHdHQ0Op0u3XpFUdizZ0+WBRRCCCHellar+/eNxAdD6m1YpN6GReotPhTKezDfUHapV68e8+bNo0+fPjRo0ECaRjlAhhtH48aNY9u2bej1+teul/8AhBBC5DR/878s8YGSehsWqbdhkXoL8eEpXrz4a/sIer2eAQMGMGDAgLRlt27d+i+jiVQZbhwdPHgQAC8vL8qWLYuJiUmWhxJCCCGykqIof/sLD/HhkXobFqm3YZF6C/HhmTRpkgxAyeEy3DhSq9VYWFiwZs2ad5EnRwkMicvuCOlYmIdld4RXGBlFZneEdGJjk7I7QjrhEYnZHSGdp7E5K0+ph/eyO4IwEGq1QnKyfNEwFFJvwyL1NixSb/HB+MAnx05ISGDw4MFpd2MfNmwYZcuWfe22LVu2TPdzVFQUYWFh5M2bF0gZvFKpUiVsbGzecWrxd1QZfULz5s2Ji4vj9u3b7yKPEEIIIYQQQggh3mObN2+mYMGC/PLLL0yZMoXJkye/0fNu3LhBvXr1WLduXdqyKVOm0KRJE3x9fd9VXPEvMjziaMCAAZw8eZLPP/+cihUr4uDggEr1R/9JURQmTZqUpSGFEEIIIYQQQogPxgd+aVazZs3SLj/TarUYGRm90fOmTJlC3bp16devX9qygwcPMnLkSCZPnszKlSvfSV7xzzLcOFq2bBn3799HURROnz6d7lpEvV4vjSMhhBBCCCGEEMKAWVpaAvDixQsGDx7M4MGD3+h5Pj4+TJo0CWNj47RlGo2GLl260Lp163eSVfy7DDeOfvnlFxRFwc7OjsKFC79x51AIIYTILjqdzIdhSKTehkXqbVik3kK8Px48eEDv3r3p168fVatWfaPnWFhYEBAQgLu7e7rlwcHB6ZpJ4r+V4cZRUlISJiYmHDhwIK2LKIQQQuRk8kXDsEi9DYvU27BIvcUH4wO/VO3p06d8//33TJs2DU9Pzzd+XsOGDRk7dixjxoxJe97169cZN24c9evXf1dxxb/I8OTYn376KVqtlsTEnHV3JiGEEEIIIYQQQmS9xMREmjRpwrlz59KWJSQkMGzYMCpWrEiNGjXSzT+0aNEiYmNjmT59Ol999RW9e/d+o+MMGDCAvHnz8s0331CxYkUqVqzIN998Q+HChd/4cjeR9TI84qh69eocOXKEtm3bUr9+fWxsbNJNjg3w3XffZVlAIYQQ4m1pNCqSk3XZHUP8R6TehkXqbVik3uKD8R6NOEpISGDAgAGv3NVs2rRp+Pj48PPPPxMYGMiQIUPInTs3jRo1Yvz48Zk6lrm5OcuWLePBgwfcvXsXjUZDoUKFyJ8/fxa8EpFZGW4c9enTB0VR0Ov1/PTTT6/dxpAaR2aFClL22EEeTpjM06Ur0pY7f/kFhWdO43qLNkSeOUv1oIBXnnu9eRvyDupPrurpr/d8NG0mATPnvHU263HTMG3UhOBKJVHZO2A1dAxG5b3QBjwicuQgtI8eonbLi9XwcWiKe6B99ICoSaNJvnPrrY/9V6ZfdcakRTswMSFx7w6Sfv8Nq/mvzogfVr00qjzumP8wFk3xkmgfPSR26li0d7M2k920OZjVb5T2c8S8mehCQ7H67ntUNjbEHTtC+MTRkJiIsVdlbIaMQO3kTPzJE4RPHIM+NiZL8zgNHoxtmzbo4uIIXbiQsA0bMC1ZktzTpmHs7k7UwYMEjhiBPiEBU09Pco8fj3HBgsR7e/NkyBCSHj9+6wwF+/Qkb5fOqM3MCDl0hBv9BmJXvRrFxo7CNE8eIr2vc6PfQGL87qU9p/T82Th92ogjhUoAUGnHZuyqV0u3X9+pM7g3fdZb5/uzzzccZcuNh2k/T6xXgedxCcw67ZO2rEvFYixqWj1LjyuEEEIIIYQh8fPzY8CAAej16S8TjY2NZdOmTSxbtgwPDw88PDzw9fVl7dq1NGrU6G/29uZ0Oh06nQ69Xo9OJ83i7JbhxlHu3LnfRY73kk3d2hSeNR2ViUm65ab58lFg7Kh0y3zafJH294KTxqOLiSXq8hUejBmPxiYXAC5ftsemVk1Ctm5/62wm9Rph2qhJ2s/Wk2ejsrYhavIYLLr1wWrgcMJ7f4fVsDGoHJ2ImjACi+/7YDVqImH/a/nWx/8zTZkKmHXrS9yqH0Gjweyrb0m+foWoPikNRsXSEotRk0nYvQ0A8yGjUTk4EjNpFGZdemE+bDxRX2ftDPpGpTyJ3bWd2D07AT365GQclvxE7PYtJN33w2bQMJLu3iZ26ybsp88l8YYPUcuXYPPDCHINGEL4+FH/eow3latpUxy7dePZ5MloHB3JPXky8X5+5J40CV1UFM/Gj8d1wgTifX15vnQp7vPmkRwSQuDQobiOHo3LyJEEdO36Vhnsalan6Mhh3J8zn1h/fzxmTCUhKAj3jh14cfo0vhOnUHzSeDxmTeN801YY2dpSdNQw8nzxOUkREWn7uT1qLEa5bABw6/A/HGp/xNMt294q2+ucfxzCV2UL096zEIoCRexz0XHLCeoXykP/6qVQFHCztsjy4wohhBBCCJElVBmeNSZbnD9/nsqVK9OvXz/Kli2btvz27dskJydTrly5tGUVKlTgxx9/RKfTvXJV0pt6ObrpyJEjac0qRVGoU6cOc+bMkQmys0mGG0dHjx59FzneOyZueSj5y08Eb9qKc7s2f6xQqSiyYDbxj59gUbxY2uKI304B4NiqOab58nK13ifoExKI8b4OgGn+/NjWr8eDUWOIf/DwrbKpHByxGjKK5Hu+aAoVQWXvgHHZCkROGUvCoX0kXb8GyUkpuQb3QTE1Bb0efWws6LRvdezXSb5+hYi2n6ILCcK43qcA6JOSSL54FkhpFOlCQ4hbMAOAmGH9wNQUdDr0cbGQxR1mlb0DGtfcqD6qjVnDT4k7dpjwMcMJ+qwBuvAwjEunTt6WlISmQEFUuWyI3bGFuIP7MKlSDbO6DbK0cWRWvjy6+HieL1sGioL9119j+/nnmBYpQuDw4YRv3ozt559jVasWz5cu5X6rVqDXo7KwQJ+YiD4p6a0zJEdE4jt1BvfnzEeflETRkcOwLFqU+7PmELRnPzF+fri2aUWuMinnptjYUdh4VSDs3AUsixdN20/ktZT3s3mB/Dg1qM+tEaOIvf/grfP92bOoWAIiYth95xEbrt+nWYl8LG9egytPn2OkUvHZLwepld+VX9rUytLjCiGEEEIIYWjat2//2uUhISHY2tqma+Q4ODiQkJBAeHg4dnZ2mTre7Nmz8fb2ZsGCBVSqVAmdTseFCxeYMGEC8+fPZ8CAAZnar3g7GW4ciRRJL8K4XLUWep02XePIrXcPjF2cuT98NCXXrEr/JJUK98EDCdm8lbg7d9Otcu/fm8SnTwn6Zd1bZ7MaNZHEi+fQ3vdLaRzlzgOAyUd1sew1EN2L50RNGI4uNAR9dBT66CgcT1wERUVYj05vffxX6HTongRg0v4bzHv0J/HUMZJ/PwmAKo8bxo1bEDtxBKROuK6PjoLoKGwOnwOViqje32ZpHLWjE0l37xCzfTP6uFhsRo4n+f49opYuxKx+I+ymzSHxxnVitm5CZWODXqvFxKsKCZcuYFS8BCobGzAxgYSELMmTFBiIytQU88qVUVQqFI0GIxcXALTh4Sl/RkRgnHpdr/b5c9T29hQ9cYLksDCCp09/6wyR3teJTG1iun/TEWM7OwK3bOXppq0AWJcpjePHdQhMHT30cOFiYvzuUWrOjHSNo5cKDehL/NNAHq/59a2z/VVgVCylnW35pnxRLI2N6LrzFCUcbShiZ03jYnkp7WxL5+0n+eHgRVa0qJnlxxdCCCGEEMLQxcXFvTL65+XPb3Mjrd27dzN+/Hjq1KmTtqxevXqo1WrGjh0rjaNs8kbjx8qUKUPDhg0B8PT0pEyZMn/7+PPwtQ+ZLjaWeH//dMssSpfCvX8f7g0ahj4h5T8WlZFx2sRndg3rY5Y/H09X/JTueRp7OxxaNOPZz2tA/3a3GDVr0x6jYiWJnj0F1OrUpSnHV8zNiRjcG310JNYT/zTnjEpF+MCeJF6+QK6pc1HMzd8qw99JOnWMmLFDMapSA5MvOgJg0ro9+qhIEg/vS7+xSkX0kN4kX76I5cTZkIWZkm7fJPjzZsSsW5NyadqdW5hUrARAoo83z/t1R5M3H7kG/IAuNISoH+dj3rINLgd/Q2VqlrKTt6zTn4X9+itx169TYN068syciTY6Om3dX68lTlseH8/Dr74i6fFj3BcvzrIsbl+2p+TUiYQcOfZH06isJxU3ryfx+Qt8J04BIPrOXfTa149OM7K3w7Vlcx6tWp2l5+ml8rkduNKjBb2retCpQlHKuthz4sFTLnZvztiPy9O6VAHqF8rDiQdPs/zY4v0lE6kaFqm3YZF6Gxapt/hgKEr2PLKIiYnJKw2ilz+bmppmer8xMTEULFjwleUFChTgxYsXmd6veDtv1DhKSEggIXV0RWJiYtrPf/cwVHYN66MyMcFjwy94bFwLgMfGtVhXrZy2Pv5RADE+N9I9z7ZuHVTGxjzfu/+tM5jUbYDK1g6H3cew6NQt5bgrUkZ9JBw/TNKF30k4chC1gyNKLhuMq32EpnAxki6cJX7fTtQOjqjzFXjrHH+mcs2DUb1P0D16SOLB3egCn6Ap5wWAUfU6JJ35Df7UhNBUrYm6UFGSL50j4cAuVA6OqPPmz7I8RsVLYtW1JxgZAaCoNeiTkzGr3whdRATxx4+S6HMdk4opGaN+Wk5wi0959kkdEi6cQ/s8NG10VFbQRUfj36EDfg0b4tegAYpKhTYyEgCNjQ0AahsbkoOCUIyNsapXD42TEzGnTxN54ACmxYujtrV96xx52rXFY9Y0Qo+d4ErHzgBYlfLAa/N6kiOjON+sFYkhof+6H8eP66IyNiZ4z75/3TYzLgeGMvboZRKSU94zyTodiqIw8fhVnkXFpi0zUr8f140LIYQQQgjxvnF2diYsLIzk5OS0ZSEhIZiammJtbZ3p/RYtWpT9+1/9Xrxv3z4KFMja76nizb3RpWqTJ0/GzMws7e/i9YLWriPs2HEALEuXptDUidwbMpwY75Q7PVl7VSTq8pVXnmddqSKJwcEkBLz9nbGipo1HsUiZFNisWWvMmrXmRad2WA0agVnTVmgDH2NStz7awMfoI8Kx+LY7irU10QtmYtaqHbrwMLQPs3ZOGlW+AliOnUZcwcLon4eicstLwp7tKPYOqPO4Ef9r+rurmX3TDcXKmrjFszFt8XlKJv+sy6RYWmHdrScqGxuSH/ljVLQYMVM3YTt5JrE7t5Jw+SLGZcsRt2cnAM47DqALDSF63S+Y1WtI7P7dWZYFwLxKFQr8+ishixaBSoViakrokiWYliyJTatW6JOSMPXwIHj2bPTJybiOH0/SkyeELl2KTfPmJNy7hzYs7K0yWBYrisfMqSSEhPBo+UpsK3mR+Pw55VYtQ2Nlxe3R4zHPlw/TPLkJO3P2H/dlW9mLhKBg4rLg/fw6EfFJjD9+lRdxCRS2t+Z6UBg/Nq1Oj91n8AkOo1ERNw7fC6RvNY93cnzxflKrFbTarB8BJ3ImqbdhkXobFqm3+GBk4eif7FCiRAk0Gg1Xr16lYsWKAFy6dInSpUtnemJsgO+//57u3btz69Ytypcvn7bfQ4cOMXPmzCzJLjLujRpHbm5uadcrtmjR4p0Gep8lPn1G4tNnAGl3Wou9ezft0iNjVxcS9h145XnGri4kPH6SJRm0D/64Vbquasr8Lsk+3kQM6Yv1iPFYj5mK1v8+ET/0BSByzBCsho0j19ipJPs/JHxAj5QJqbNQ8tlTxP04B5M2X4JGQ8KWdSSs+xl1kZS5cXTP0l9SFDN+GOZDxmAxajLaRw+JHtIL4uKyLE/ixXNEzJ6G5Zdfo5iZE7VmFTHrf0EfG4tVtx6Y1WtE/LEjRMxJmTsofMJobIaPweaHEcQdPUTk3BlZlgUg9uxZnq9ahd1XX5H8/DlP+vcn/vp1HvfsSe6pU3EZNYrIPXt48dNPoNMR0K0bruPG4TZrFnE+PgQOH/7WGdw7foXKxARTZ2cqrFsDQHJUFBorKwBKz035kE6KiOBIoRL/uC8TVxfiHr+bphFAnYKuTGngxZwzPsQkJdO3mgedKxTFVKNm9NHL7L7ziNYe+RlRq+w7yyDeP4qiAPJFw1BIvQ2L1NuwSL2FyBnMzMxo3rw5Y8aMYdKkSQQHB7Ny5cq3HmhSu3Zt5s6dy7Jlyzh+/Dh6vZ5ixYoxZ84cGjRokEXpRUYp+r+bROVPihcvjqurK8eOHfsvMuUYp53dsztCOkXyWWV3hFcYGan/faP/UGzs299hLCuFR2TdJW1ZISAyPrsjpFO/zyfZHSGdF93mZHcE8Y5oNCqZF8OASL0Ni9TbsEi9DYujY877/pNVkge0ypbjamZuyfRzixUrxurVq6lcOWUqlri4OMaMGcPBgwextLSkc+fOfP3111mUVOQkb3xXtTfoLwkhhBBCCCGEEOLfvIeXqt25cyfdz2ZmZkydOpWpU6e+1X63b9/+xts2b978rY4lMueNG0fvir+/P+PGjePy5cvkypWLL7/8km+/Tbn9ekBAACNHjuTq1avkzp2bYcOGUaNGjbTnnjlzhkmTJhEQEECZMmWYOHEi7u5/jBL66aefWLFiBdHR0XzyySeMHDkyba4mIYQQQgghhBBCZK8ffvjhjbZTFEUaR9nkjRtHERERDB069F+3UxSFSZMmvdE+dTodXbp0oXTp0mzbtg1/f3/69++Ps7MzTZo0oUePHhQtWpQtW7Zw+PBhevbsyd69e8mdOzeBgYH06NGDXr16UbNmTRYuXEj37t3ZuXMniqJw4MABFixYwPTp07G3t2fo0KFMnz6dUaNGvelLFkII8YGQiVQNi9TbsEi9DYvUW3ww3mIC6Q/N7du3szuC+Bdv3DiKj4//1yFker0+Q42j0NBQSpQowZgxY7C0tCR//vxUrVqVS5cu4eDgQEBAAOvXr8fc3JxChQrx+++/s2XLFnr16sWmTZsoVaoUnTp1AlLu9la9enXOnz9P5cqVWb16NR07dqROnToAjB07ls6dOzNo0CAZdSSEEAZGLrc2LFJvwyL1NixSbyEMQ0BAAHfv3sXExITChQvj4uKS3ZEM2hs3joyNjfHy8srSgzs5OTFnzhwg5X8Cly9f5sKFC4wePZpr165RsmRJzM3N07avUKECV69eBeDatWtpt/2DlOsrPTw80m4HeP36dXr27Jm2vmzZsiQlJXH79m3KlSuXpa9DCCFEzqYoIN81DIfU27BIvQ2L1Ft8MN7DOY7+CxEREQwbNowjR46kLVOpVDRv3pzRo0djknr3cvHfeuPGka2tLcuXL39nQerWrUtgYCB16tShYcOGTJo0CScnp3Tb2Nvb8+xZyu3uQ0JC/nZ9ZGQkCQkJ6dZrNBpsbGzSni+EEMJwqNVyFx5DIvU2LFJvwyL1FuLDNmHCBO7du8fKlSvx9PREp9Nx8eJFJkyYwNSpU2XqmWyS7ZNjvzRv3jxCQ0MZM2YMkydPJi4uDmNj43TbGBsbk5iYcnvzf1ofHx+f9vPfPV8IIf5Ko0m51lyvB6025R+larXqlV8IabU69HpQqRRUqvQrdTo9Op0+3f7+7OU/dv9pv4qioFanX6nX69Pmdfin/b4uk1arT72UOOW46ff7x2vN6H5fvtZ/229OOIdqtSoD+1VQlJx/Dt9kv6/L9Ka1ed37MGvO4bt/f7/8M7vPoXxG/DefEX/dd2bPoXxGvNl+s/sz4q/n4d9e65vWRj4jcu5nhDAsR48eZcmSJemuLqpbty4mJib0799fGkfZJMc0jkqXLg1AQkICAwcOpFWrVsTFxaXbJjExEVNTUwBMTExeaQIlJiZibW2dNnztdetlfiMhxN953W8w/+kfLX/+x92b7u9N9qvX60lOztx+/ymTXv/Pz31X+80p5/DPx/nn/eoBOYdv8z7853P437y//7qf7DiHObE2H+pnREY/v9/d+/v9PYcZ3W92fUZotbq/3ff7dg5zYm1y4mfEB0suVXstIyMjLC0tX1luZ2eHTmeA75Mc4o0aR6tXr35l9E5WCA0N5erVq9SrVy9tWeHChUlKSsLR0ZH79++/sv3Ly8+cnZ0JDQ19ZX2JEiWwsbHBxMSE0NBQChUqBEBycjLh4eE4Ojq+cb4orTazL+2dCAtLyO4IrzA2UWd3hHQiI3PWiLKohOTsjpBORA57T+sjIrI7ghBCCCGEECKH6NChA5MmTWLOnDnY2dkBEBsby+zZs2nfvn02pzNcb9Q4qlSp0js5+OPHj+nZsycnTpzA2dkZAB8fH+zs7KhQoQIrV64kPj4+bZTRpUuXqFChAgBlypTh0qVLafuKi4vj5s2b9OzZE5VKRenSpbl06RKVK1cG4OrVq2g0GooXL/5OXosQQoicSyZSNSxSb8Mi9TYsUm/xwZARR2nq1q2b7vLVJ0+eULduXfLly4darebBgwckJCQQIb90zjbZeqla6dKl8fDwYNiwYQwdOpQnT54wffp0unXrRqVKlXB1dWXo0KF0796dY8eO4e3tzeTJkwFo1aoVK1asYOnSpdSpU4eFCxfi5uaW1ihq3749o0aNomjRojg5OTFmzBjatm0rl6oJIYQBknkSDIvU27BIvQ2L1FuID0+LFi1emfdM5CzZ2jhSq9UsWrSI8ePH8/nnn2NmZsZXX31Fhw4dUBSFRYsWMXz4cFq2bEm+fPlYuHAhuXPnBsDNzY358+czadIkFi5cSLly5Vi4cGHaG65x48Y8efKEUaNGkZiYSIMGDRg0aFB2vlwhhBBCCCGEEAJUr04mbqh69eqV3RHEv1D0ehnw+Xf2O+TO7gjpFLDNeaOlZI6jf5bT5jh6kpiU3RHSadW5ZnZHSCdsyKrsjiDeEY1Gbt9sSKTehkXqbVik3obF0dEquyO8M8nD/5ctx9VMXJstxxXvN2lzCiGEEEIIIYQQQojXeqNL1caMGfPGO1QUhdGjR2c2jxBCCCGEEEII8WGTOX3Ee+SNGkfr169/o8mq9Hq9NI6EEEIIIYQQQgjxRqZNm0bXrl3JlSsXgYGBuLq6ymTZOcwbXarm5eVFxYoV//XxcjtDULBPT2rfuMLH92/juWQhanMzHOt/TI0zJ6jn70elXduwKFwIAPMC+am0YzP1Ht6l6uF9WHuWTttP8fGjqet7g5rnTmJf66MsyWbfqzfFfO+le7ivWYtV4yYUOHqMIteu475mLZrUicYxMsJx+AgKnT1PwRMnsfy4Xpbk+DMTzzLk3rCFfOev4DR3IYqpKWY1PiLPjr3kO3cZp7mLUNnYAmBcrDi5120m39nLOC9aitrBMetyFCxIad87OHTuBICZhwdF9+2llI837rNmopiYpCz39KTI7p2UunWDQuvXYezuBoDKwgLPB/co8+hh2kPj+Hb5zAoVpNqje+Tu0hkA1286UiPocdrDY90vANjWq5tueflTxwFQjIwoMH4MlW5cpeKlc9g1apCpHCX69eYzn8s097tJmXEpzV9TZydq/LqaFv6+1D92EKvU97RloYLU2b2NVo8f8Mn507g2rA+A2syMyksW0uLhXZrevk6JAX3f4sz8vaG/Xcd10S4cFuyk0/6LJGp1LLpyD6OZW9IejbeceifHFkIIIYQQ4q0pSvY8cqBffvmFqKgoAD7++GPCwsKyOZH4qzcacbRmzZp3neO9YlezOkVHDuP+nPnE+vvjMWMqCUFBuHfswIvTp/GdOIXik8bjMWsa55u2wmPWNExcnLneuz9Fhw+h1LxZnKldH5fmTcn/fVduDRuJfe2PKLN8McdLlUeXkPBW+SK3byPu0kUATD3L4DhgIBFbt+AybRpxZ88ROnsWDv3649h/AE8HDsChZy9sWrchaMI4rBp9isuMGdyrXAl9YtZMNK2yzoXLkpXEnfudyA3rcBg5Buuvvsbm2y7EnT1LxMplOIwej0237ryYMhGnmXPRxcYSMnIodgOH4Dh5Gs++++atc1jVro37tCmoUptDAHnnzUEbGcWTseNxmzyR+Lt3CflxCfkWLSA5OITHg38gz7gx5B49mofffod5GU8UtRr/3n1IDg0FQBsenulMtnXrUHjW9HSZrMqXI9rnBg/HTkCPnuTnL1KXlycxOJi7PfqgR48uNhYA9wF9cW7fjvvDR+HwWROKLpjLuZJlMlQ/x2pV8Bw1nBvTZqIYGVGyX29Cz52nWM/vMbax4WK/QZQe/gPlp07iRKvP8Zo3CzMXF8526U7h7zpRdfkSdhYvRfHePXFv9hkX+w7E1rM0niOG8vzcBYJPnc70Ofqro/7BzLhwl97lC1PMzoq+R69SPbc955+9wNMxF1M/Ko2igL2Zyb/vTBgMmUjVsEi9DYvU27BIvYX48OTJk4eePXtSokQJ9Ho9EyZMwMTk9f+Wnzx58n+cTsAbNo4ywtvbG09Pz6zebY6SHBGJ79QZ3J8zH31SEkVHDsOyaFHuz5pD0J79xPj54dqmFbnKpJyHKx2/RW1uhl6nIzkmFrRaABzq1iE+KAj/pSuIvuuHU4P65KpQjrAzZ98qX1JAAEkBAaDR4DRiJJG7dhJ18ADOEyaQ+PABcRcuon3+HF1qY8Gq0SdEHz9O5JYtxBw9isrKGn1S1t19y6x6DVRWVoTNnUXSg/skXL2CNiSY6B3b0MfHoXHNjV6rRZ+UhMrGFqP8BXgxazqxhw5gXLgINt/3RLGwQB8Tk+kMRnnyUGDVCsK2bsOuTeu0ZaZFihAwdBhhmzZh/0U7rGvXJuTHJfg1a4Fer0dtaYEuMRF9Usq5Mi9bFoA848eBVsvTSZOJzuS5MnHLQ8lffiJ40xac27VNW25ZrizGzk6U/HU1MT43uNOtJwBW5cqitrCg5C8/Ef8ogLs9+wDg8FkTwg4fIXj9Rl4cPITGOleG6xd69jx7ylcmNvAp+Vq1AEBjbo5jlcpc7D+IgK3beX7hIrrU/T7esZuo+/d5dvgo5m55cKn9ESb2Dry46s2VoSN4uH4jYdd9KPp9Fyzyumfq/PwdbeqNICu52lHKIRfGahUmGhUXn77gaUw8n207TRlHG35pXClLjyuEEEIIIYTIetOnT2fJkiU8efIERVEIDAzEyMgou2OJP8lw4yg6OpqZM2dy5coVYmJi0OlSuv56vZ7IyEhiY2O5efNmlgfNSSK9rxPpfR0A9286YmxnR+CWrTzdtBUA6zKlcfy4DoFbtgGQHBlJcmQk9fz9UFQKF1p+DoCpqwtJL1KG4SWFp/xp6uKSZTmtmzXDOH8BnnT5Dn1MDCETJ+I8dhy2HTqSHBJCYM8eAGjc8mAUHk7Bk6dQmZoROncO4b9k3SgzTZ6Uy7xs+w7AvGYt4q9dJWTIALTBQRiX8iTP+s0kPQ4gYvlSdFGR6GKiMa3oRdS2zZh4lkVRqdA4u5B0/16mM2jDwrhduw56re6PxpGLc9o6AG1EOMb58wOQ/Pw5Gnt7Spw6SXJYGE+nTEvZkVpN9PnzBC9ajF3rVrhNnkT0uXMk+j/KcKakF2FcqvoRep02rXGkaDQkR0QQfvIUYUePUXjGVArPmoZPy7boEhN4fuAQwRs3U2DMSIr9uJBLVWti6u5GclgYXlcuoDIz49G0GTxd+VOGsuh1OqIfPKR47x6UGTuKJ/sOEP3QH4A8nzaizNjRxIeEcKFXX+KfBeG7dHnKOcyVi8LffkOU3z1iHj0i5tEf56Fk/z5oExMJPv17hs/NP6mf35k2Rd34cs95AGrkcaBNUTd+vHqfOnmdaFTAhe8PXabbocscbps1l3+K959KpaDT6bM7hviPSL0Ni9TbsEi9xQcjh142lh1KlSrF/PnzAahbty6LFy/G1tY2m1OJP3ujOY7+bObMmaxbt47bt28TEBDAkydPePLkCYGBgURHR6NSZXiX7y23L9tTcupEQo4c+6NpVNaTipvXk/j8Bb4Tp/yxsUrF5S+/5sXp3yn70zLUlhYpHxb6d/c/PtuOXxN94jhJjx+jmJhg9313oo8f53HnTugTE3EeOw4ABQWjvHkJGjmC6COHcRo5CuPChbMuSOqHojYkmOABfTAuWgy7QT8AkBz4mGddOoGi4DhpKuh0PJ80HrOq1ch38hwat5Sm09ueJ11s7KvNnZcf1n+zb118PPfa/4/Ex4/Jv/RHAILnL+Be67ZEHT1G0LwFKEZGWHh5ZTpTvL9/umX65GS8Gzfj/tARhB06Quj2nVhX8gK1mlsdO3P3+56EHzvOszVrMSuQH5M8uUFRMM2fD79BQ3ix/wAFJ47DrGiRTGV6snc/Z7t2x7VeXZxrpzRdNJaWnP7qG5IiIqi6Ymnatsa2ttTZuQWLvO5c6Dvwj50oCpUWziVvy+bcmDqDmL+8xrd1KSiMrb5PGORVlFWfVOTs0+csunqPU+3rML9eORoXcqVtcTdOPwklWSfD2UUKlUr+cWZIpN6GReptWKTeQnzYjh49iq2tLffu3WPfvn0cPnyYBw8eZHcsg5fhLs+xY8dQFIVOnTpRsmRJSpcuzdixYylfvjyKojBt2rR3kTPHydOuLR6zphF67ARXOqZMamxVygOvzetJjozifLNWJIakzIHjUK8uVh4leXHyFIGbtmDq7IxF4UIkBAVhZJc6IXRqRzX+2bMsyadxdcW0REmiDx0CwKRYMYxcXIjcsZ2Y304Qc/I3zKtWAyAp6Bnx164Sc/w44evXoahUWdo40galvKaoLZuIPXaEhOvXMC5cBPN6DVDUGuLOnCLuzGlMvVIuLYretYPHn31CwCcfp1zOptWS/OxpluV5KTk4GAB16rlX29iSHBSMYmyMdf36aJyciD51moi9+zArUQK1rS22rVpi06wpAIpGDZCll/UZOTrg1qtHWuNH0WhAq0VlbESe77tiVbFCynL1y2Mnk/j0KVGXrxB2+CjP1qxFUakwL1o0Q8e1yJuXvK1aEOV3D/+NW4jxf4RTjeoAPN61h6ATvxGwczdmLs4Y29lhZG1F7R2bsSpSmNNffUPI6TNp+6o0fzYF2rfDZ+oMbs2amxWnJZ1j/sFo9Xp6lS/MlyXzUTCXBUf8g5l27g43n0cCkKzTo1YUVPKbHCGEEEIIkQMpKlW2PHK6xMREevbsSePGjenXrx89e/bk008/pXv37iRm0Ry8IuMyfKna8+fPsba2ZvDgwaxYsYINGzbw+eef07BhQ2rUqMHq1av59NNP30XWHMOyWFE8Zk4lISSER8tXYlvJi8Tnzym3ahkaKytujx6Peb58mObJTdiZsxQe1B8jm1zcGTuRvN90JPH5C2J8/Xh+/DfyfN6GfN91xr72RyS+eEHEpStZktGsQsrd7eKvpuwv8eFDdHFx2LRvjz4pEYvatYlPvaQw+sBBbNq1w7p5C8yrVkWflETCzVtZkgMg9vRJdLGx2HzXjZiD+zEp7Uns0SM4Tp5O3NkzRO/agXmdusRfvgSAy4rVaJycCJs3G6tWbYg7eQJ9XFyW5Xkp8VEACQ8fYte6NfrEJMxKefBs5iz0ycm4TZpA4uMnBP+4BNuWLYn3u4c2LAzL6tXJ1bABqFTYNG6MNjqaqOMnsiyTLi4etz49san9Ec9W/4JD86aE7tmHLi4e105f49S2NY9mzMa141dEnr9AYlAQoXv24dLhS5zatCJXjerokpKI8bmRoeNaFS1M1eU/kqtEceKCgrAsWID7a9dhZGVJwS/bE+P/CPfPGhPt/4jEFy+osnQRtqVLcXfxUnSJSTjX+ojnFy+St1VLCvzvC4JOnib093M41/qISD8/4p4EZtk5Ku2YC4CJZ29TxikXfuHRfFLQhSnnb3PIP4jvPAuw8fZjWhTJI40jIYQQQggh3iOzZs3C29ubhQsXUqlSJXQ6HRcuXGDChAnMnz+fAQMGZHdEg5ThlqOlpSWJiYkkJiZSpkwZAgICCA4OxsLCAmNjY3x9fd9FzhzFveNXqExMMHV2psK6NXht3UDl3dswL5AfRa2m9NyZeG3dQPk1qwDw7t6bhKBgPBcvQGVuxuUvv0YbE0vg5q08WPgjhQb1w6JIIa591/2t76j2ksY5Zf6epCdPANBFRhLYqydqW1tcp80gKSCAZ8NSLhcLnTOLyN27cRo+AvNKlXn2wxCSHmXd5UW6588J6tkNowIFcRg7gfhLF3kxaxrBA/pglK8AjhMmk3jDh9CRwwB4MX0y+qQkHMZOJPH2LUJGDM2yLH/l/30PVKam5BkzivDduwld9RPodDz8riuKsRF5584m+cVzHnbpAkDghIlEnz2L26SJmBYtwsOu36ONiMiyPNroaG5/9z3GTk4UmTub6CtXuT98JAC3v+2KLjGRogvnkRgSwp0evQF4NHUGodt2UGD8WHJVq4pvnwHEP3yYoeM+O3wU73ETKfBle0r9MAjfZSu5s2Axpzt2Ji4omMo/LgRF4UzHzhjb2ZE3dQLtot93ofb2TdTevgnLAgUo0iVl9J1zzeppy90/a5Jl5wegYQEXJtUsxU6/QH44cZ22xdwZU82DdU0q8ywmns4HLuLlasucumWy9LhCCCGEEEJkGUXJnkcOt3v3bsaOHcvHH3+MlZUVuXLlol69eowePZpdu3ZldzyDpej1GZs8pnPnzpw5c4bq1auzaNEivLy8KFiwIKamply5cgUHBwdOnTr1rvL+p/Y75M7uCOkUsDXL7givMDZRZ3eEdCIjc9bwxaiE5OyOkM6TxKy7rC4rtOpcM7sjpBM2ZFV2RxDviEymalik3oZF6m1YpN6GxdHRKrsjvDPasd9ky3HVo3P2v3fLlSvH9u3byZcvX7rlDx8+pGnTpnh7e2dTMsOW4RFH/fr1w9raGq1Wi7GxMU2aNOHWrVtcuZJySVTjxo2zPKQQQgjxNuRLhmGRehsWqbdhkXoL8WErWrQo+/fvf2X5vn37KFCgQDYkEpCJOY5KlSrFvn370mY2HzlyJLa2tvj6+lK+fHk6deqU5SGFEEKIt/GOb2Ipchipt2GRehsWqbf4YLwHl41lh++//57u3btz69YtypcvD8ClS5c4dOgQM2fOzOZ0hivDjaMrV65Qrlw57OzsADA1NWXgwIH/8iwhhBAi+6jVKpKTddkdQ/xHpN6GReptWKTeQnzYateuzdy5c1m2bBnHjx9Hr9dTrFgx5syZQ4MGDbI7nsHKcOPoiy++oGDBgrRs2ZJmzZrh6Oj4LnIJIYQQQgghhBAfJhlx9Lfq169P/fr1szuG+JMMz3GkKAr3799n5syZ1KlTh27dunHo0CGSk3PWJMBCCCGEEEIIIYQQ4u1keMTR8ePH2bVrF7t27eLOnTscP36cEydOYGNjQ9OmTWnRogXFixd/F1mFEEIIIYQQQgghxH8owyOOnJ2d+fbbb9mxYwe7du2ia9eu5M2bl7CwMFavXk3Lli3fRU4hhBAi02QiVcMi9TYsUm/DIvUWHwyVKnseQmTCW71zbGxssLW1xdHREZVKhV6vRy+f5kIIIXIYrVYmUjUkUm/DIvU2LFJvIT5sFy9eJCkpKbtjiL/I8KVq0dHRHDhwgF27dnHhwgV0Oh16vR4TExMaNGhA69at30VOIYQQQgghhBDiwyCTY79Wr169WL58OR4eHtkdRfxJhhtH1atXJzExMW1kkYeHB61bt6ZJkyZYWVllecDs5J+QmN0R0jGPzHlDC41z2AdedA77LVSsLmfleZaYsyax14VHZXcEYSDUapX8ltqASL0Ni9TbsEi9hfiw2dnZERUl3xFymgw3jhISEsiVKxdNmzalVatWMhG2EEKIHC+H9bjFOyb1NixSb8Mi9RYfDHkzv9ZHH31E165dqVWrFvny5cPExCTd+p49e2ZTMsOW4cbRrFmzqFevHsbGxu8ijxBCCCGEEEIIIQzQgQMHsLe3x8fHBx8fn3TrFEWRxlE2eaPGkbe3N8bGxhQvXhw3Nzdu3779j9t7enpmSTghhBBCCCGEEEIYhqNHj2Z3BPEab9Q4atu2La6urhw7doy2bdui/MOwOkVRuHnzZpYFFEIIIYQQQgghPihyqdo/unDhAvfu3aNJkyY8e/aM/Pnzo9Fk+IIpkUXe+My/nAz7r3//p+2EEEKInCA5WSZSNSRSb8Mi9TYsUm8hPmzR0dF07tyZa9euoSgK1atXZ8aMGTx69IhVq1bh7Oyc3REN0hs1jo4cOZLW3Tty5Mg7DSSEEEIIIYQQQnzQVDnvjtk5waxZs1AUhUOHDtG0aVMABg0axMCBA5k2bRozZ87M5oSG6Y0aR3ny5En7+9y5cylZsiRt2rTBwsLinQUTQgghsopKpaDTyYhYQyH1NixSb8Mi9Rbiw3bs2DFmzpyJu7t72rJChQoxatQoevTokY3JDFuG25yHDh1i7ty5GBkZvYs875V6q1fQNSo07VG2f2/y1KnF51fO0dHflyqTxqVt6/Fdp3Tbfrp1AwCO5cvR8sRhOj19SJM927HKl/etMpkVKkiNR/fI06UzAMZOTnisXkk135uUO7gXs0IFAVCMjCg4fgxVblyl0qVz2DdqAIDn1k18FPQ43SPvgH6ZzmNaqCCV/P1w+S4lj03d2nj+dgQvv1sUXbUcjZ0tAFWeBbzysKpaBZW5GYXmzaLireuUu3AG+xbN3+LsgHmhQtR9fB/3rt8C4Ny8KdUv/s5Ht69TdNI4lNT3tWUpD7wO7KaOvx9VTh3DtmYNAFRmpngsmkctv5vUvHGF/P16ZzpL4b69aHDjKp88uEP5JQtRm5th4uxEpV9+4pMHd/joyAEsChcCUurlMXEcDW9fp961i7h80jDdvtRmZtQ9d4pqO7ZkOs+na1bSJ+Z52qPigD6U7dGVzn43+P6ZP002/IJxLut0z8n7cW16R4VQ4ssvUnKYmNBg2SK6BT6g/e/HcSxTOtN5XsvZDaPFu1DVawGAUqoiRuOWYrRgG5oeo8EyNZ9TbjSDpqUsHzEfJW/hrM0h3jsqlcwjYEik3oZF6m1YpN5CfNhevHiBo6PjK8utra2JjY3NhkQCMtE4KlWqFMnJyYSEhLyLPO8Vp4oVuPPrenY3bcXuz1rit2kr9X5aToSvH5enzqBMr+4UbNEsbdtQ7+tp254bPR6Aej8tQ5uUyIme/bArWZxqUydmOo9t3Tp4btmIysQkbVmJ5T9imj8/voN+QGNtTeFJKcfNN6AvLu3b8WD8JGJv36HYgrkoxsbcHzMO7zbt8G7TjuAdO0kKDyd46/ZM5bGpW5uSmzek5VGZmVJk6WLi7z3g4fBR2NStTZ5+fQC42eaLtEecrx/R17yJvnwF125dsG/WlIcjRhF76zaF5s1C42CfqTz2H9eh/LY/8pi6u+GxYA7h5y7gN2ESbh2/Il/P7wEoNnk8Rra23Ow3kITAQDwWzAEgf++eODdtwt3hownatpPCw4ZgW71ahrM41KxOyZHDCFi/kRujxpGnRTMK9+pBxZXLsChYgGv9B2NkbUXpKSnvh2KD+pPvyy+4OW4CUbduU27xfFTGxmn78xg/GsvUJlNmuXhV4Oba9Wz7rBVbm7Tk6bkL1Jo2iccnTnKs/2DyVKtChT5/3P7SxCYX9X9cgPKnYbZle3SlSKvm/DZkOMnxCTRcseStMv2ZUqoiRgOnohilvm5jEzTdhqMPeoL210UopSqibtIeAM1XfVBy2ZO8ahaKqTnqbwZkWQ4hhBBCCCHemqJkzyOHK126NPv27Xtl+dq1aylZsmQ2JBKQgcmxX6pUqRJXr16lcePGVKhQAUdHR0xMTNLutKYoCqNHj87yoDmNmZMTVu5u5GvUkMKtWvBw9z5uLFuJqZ0tPkuW8/jIMcr07UXeBh9zf9sOHCuWx9zZmU+2rOe5tw9HOnUBYFvdRoAeI0tLtAmJaBMTM5XHxC0PpX75iaBNW3Bp1xZIGW2Uq3IlfAf9QMj2nURevIQ+KRkAh8+a8OLwEYLWb+T5wUNorHOhT0oi2vs6AKb582Nfvz73Ro0h/sGDDOcxdstDsTU/Ebp5K46ftwFAFxfP1Rp10MXFYZInN3qtDn1SEgCRJ08BYN+yOSb58nK9/ifoExIIXPgjoZu3khQailXVKpCsBa02w3lM3fJQdu3PPN20hdyp58e6bBlUJiYErFhF5OUruLRqiVPjT3g4ex6KSk1iSCjhv5/DprIXZvnzAxB1zZs7w0fzdMMmoq77kLfrt5jmdYPTGcuTFBHJ7SnT8Z0zH31SEiVHDcO2YgXsq1Ti2oAhBG7bQdiFS+iSU85P7mZNCDp4mIBfNxC0/xBGuazRpZ47p4/r4ta2DTEP/TN8Xl4yd055Pxf8pCFFW7fg/q69XJg+C4BQnxsEnv6dxKgotAkJac+pM2cG8eHhWOZ2TVuWr15dQq56c3PNr6g0Gj5eMBsrdzeiAh5nOhsAdk5oeo9D9/sR1NVTRseRmEDSiG8hMQHFzgl0OkhOeX8nLxoHxiag16NPiEtZJ4QQQgghhMjR+vfvT6dOnfD29iY5OZnFixdz7949bty4wYoVK7I7nsHKcONo4cKFKIpCUlISp0+fTmsYQcod1QylcWTh6sJznxvcXr2WpJgYas2fTdjtOwDEvwgDICEsDHMXF1QaDYnh4QQe/41Hh47w0bxZfDR/NrsbNyc+NBRTBwfaX79E/IsXnB8zIVN5kl6EcaHqR+h12rTGkUleNwDsGzWkwOgRJIWEcrfvABKDgjB1dyMpLIzKVy6gMjPDf9oMAlf+lLa/fP37kPD0Kc9++TVTeZJfhHG1Wi3QadMaRwBJz55hUa4spfftIv7RIwLnL/zjSSoV7oMHErp5K3F37gKgT0gg4VEAxdb+jO3HdXk4ehzJYeEZzpMUFsaZKjXRa7VpjaP4x08AsK/9EYnBwVgULggqNQB3ho2k4s6t1PS+iC45mavtOwAQsv9g2j7z9+2FLjGR8DNnM5wnwvs6EalNuvydOmJsZ8eLs+dxqlsbl08a4jF2JAnBIVzp3Z+EZ0GYubuT+CKM+tcvoTYz4/aU6cQsX4WRrS1l583i5rgJ5P6sSYZzvGTh6kKozw1u/PwLSdExfLxwDi9u3+Hi7HnUmDCGGhPG8OKOL5fnLwag2OetyV//Y3a2/oI2h/em7ccytyvhfvcAiA8LS9v3WzeOYiJJGt4ZdLo/GkcA4c9RChTDaPg89CHP0O5LuQSUuBiIi8Fo4Q5QFJJn/vB2xxdCCCGEECIrvQejf7JD+fLlWb9+PStWrCBfvnxcvXqVIkWKMGzYMMqUKZPd8QxWhi9V8/LyomLFinh5eaX9/eXj5c+GIPSaN5ur1sJn8VLurF5LqLcPFYcPSVmpTz9hny45me0ff8KpAUN4tP8g97Zsw6VqZRR1SpNCGx/P7s9aEuUfQIO1P2Uqjy42lnj/9CNOFFI+jNSWFtz85luSIyIovnRR6koFs/z58B00hOf7D1Bo4jjMixYBwMjeDscWzXj68+pXXktG8iT4v34ETEJAALfafYmiKBSaNzttuW2D+pjmz8ezPzWwXno8fRaBCxaRd8RQLMuXy3AebUwscX8ZkRN55SqPV/9CoaGDqXb2JLqERCDl9Rbo15vE0FAut21P2MlTeMybhcrcLOWJikLJ+bNxadGM+9NnEef/KMN5Xsr7ZXtKT51E8JFjhKaOutJYWnK+QyeSIiOpuPzH1EMqWOTPz7X+g3m27wClJ0/AslhRysyaRvS9+zz6ZR2KSpXyyMT8YyFXvVlb+SOuLlrKjdVrCfG+Tp6a1fH8thM31/zKrs+/wsLFmepjR2KZOze1Z07l5PDRxIY+B0Cl0aQcW1HQZ/I9848S4iHk6WtX6UOfkTR7GCig6TTojxWKiuT5o9Hf8Ubz/QgwMcv6XOK9IROpGhapt2GRehsWqbcQH77ixYszffp0du/ezd69e5k7d640jbJZhkccDRkyhBIlSqBObXoYKocynuT7tBFXZs5Bl5iISqNGm5iI2tgY09QJn03s7Ai5fAUzR0eKffUFD/fsJ/zOXRS1Gr1Wi6JWk7dRA8Lv3OXJ8d94sHMXlUaPwNTejvjnL946Y8LTlC/aoXv2Ef7bKULL7KXAiKFo7GxJePqU2Nt3eHH4KElh4bh88TnmRYsSe9cX27p1UBkbE7p3/1tn+DO1tTXWNaoRfekKEcdPEH78NxxaNk9bb9uwPgkBAcT63EhbZlG2DBobGyKOnyDx6TNy9+yOVeVKRF++kiWZ7g4bRcCS5SS+eEGpRfPQWKdMrmxfpzZPN23hxbETGNnYUHrpIiyLFiXy6jVKzp1J7nZtuT99Fg/nzM/0sd2/aEuZ2dMJOXaC8x06YWKfMnfT0917CT1xksCduyk5ajjGdnbEBT4l6tZtgg8dISksjLzt22FVtAi5m6aMMmry5I/LCatuXs+ZZq0ylMWxrCcFP23ExRlz0CYmotJocKtZHUWl4vrKn3l2/iLPLlzEvfZHBF/zxtTWhnoL56Q9v97COeiSk4l5FoSpnR1A2p8xT59l+hz9IzMLlBJl0d+7hf7GJXQ3LqOqXAcApbQXhL9Af/sqOmtbNKW9UFzc0Pv7vpssIseTLxqGReptWKTehkXqLT4YqgyP4TAYhw8fZtWqVfj6+mJsbEzRokXp3r27wQxSyYky3Djq1q0bWq2WPXv2YJf6xdAQGVtbU3HYYEztbIm4dx/7Uh6cHjyMisN/wKNLZ2yKFcXCxZlHB4+QHB9HuQH9cKtbh1srf6Zw6xY82LEbfXIyNWdPJzoggKtz5lOkXVvC7vpmSdMIIOFJIFFXr+HSvh3xjwJwaPwJ8Y8ekfwijNA9+3Dt8CVObVphU6M6uqQkolMbNrkqeZEYHEzC215e9BeKWkXhBfOIOHmK0M1bsG1Yn6hzF9LWW3lVJOpS+oaQfZNPcenciftDhmJVoTx6nY6o8xf+uutMUZmZUuu2Dy9OniJk7z5sq1XFb+JUAKJv3sKxUX1e/HaSPF/9j+ToaGLvPyD3l+3J/cXnvDh1hvCz57H7qCYxfvdICAzM0LGtihXFc+Y0EoJDuL9sBXaVvVLmVLp6jbxffkHso0e4ftaYGP9HJL54wdPde8n/9Ve4fd4Gh5op9Yr0ucHJho3T9ll62hQAvAcPzfC5MLG2psrwIZja2RF+7z4OpTw4MWgoNadMoHzvHtzbuRvXypW4v2cfD/cfZEPtlLu6Wbg402T9as5NmcHD/QexypObSj8MpMT/2lHyyy94fuvO21+m9ndUKjSdB6O/dQXt70dQla2C3i/lPaz+7EsUc0uSt6xAVacJ+qgI9M8C3k0OIYQQQgghRJZYu3YtkyZN4pNPPqFRo0ZotVouXbpEhw4dmDlzJp988kl2RzRIGW4cJaZO3mzITSOAwJOnODtiDKV7fo+RuTnX5i/CZ/FSwm7focbMqbhUrYL3gsXc37YDgMMdO1N1ygRq/zifJydOcnrwUPQ6HQfbd6DGrOnUXbaY0Kve/Nanf5bmvNm5C0Vnz6D4wrnE+vpxs3NXAPynzkBjZUWh8WPRRkVxt88A4h8+BMDY1SVt/p+slBwWjm+XbuQbPZJCc2YSeeZ37g/8Y+4ZY1cXwvYfSPecxzNnY+TiQv4JY9FGRnJ/4BCiL13Okjy6uHhuD/qBwqOGYV2uLI+WLOPRkmUA+PToTclZ0/CYN5v4p0+53qU7yZGRuH/7DQB2NaphVyPlbmp3RowmYMnyDB0739dfoTYxQe3iTJX1vwDwdO9+LnT8lrLzZlJ+0Xyi/fy4+M13ANyePA2NlRWlJo4lOSqaq736EfPgITEPHqbtMzkqCoDo1PmhMuLxb6c4OXw05Xt9j8bcgsvzFnJ10VISIiKpPGww+erX5cnJ05wcNoq40OfEpV6iZpXXHYCIBw+JC33OpbkLyVWoILWmTybS358Dqe+3dyImiuQfJ6Jp2wXNNwPQ3/EmefUcAJJXTEPToS+ab4egfxZA8oIxKZe7CYOl0ahITpZJ0g2F1NuwSL0Ni9RbiA/bypUrGTp0KF9++WXasq+//pqlS5cyb948aRxlE0WfwQlJNm3axOjRo/n8889p2rQpjo6OmJqappsk294+c7dLz2mWWDlkd4R0SpibZneEVxjnsEndorU56x8SsTnsbl4P4jN317535fsvctZw04jJm7M7gnhH5IuGYZF6Gxapt2GRehsWR0er7I7wzmhn98mW46r7zc2W474pT09Pdu3aRb58+dItf/DgAc2aNcPb2zubkhm2DI84mjlzJiqVivXr17N+/fpX1iuKws2bN7MknBBCCCGEEEIIIQxD5cqVOXDgAF26dEm3/Pjx45Qrl/GbJImskeHGUXh4+DuIIYQQQgghhBBCGIgcduVGdlqwYEHa311dXZkzZw4+Pj6UL18etVrNjRs32L17N507d87GlIYtw42j1atXv4scQgghxDuTsYuyxftO6m1YpN6GReotxIdn69at6X52cXHBx8cHHx+ftGVOTk7s3r2bfv36/dfxBJloHFWqVOlv1yUmJrJ/f9bewl0IIYR4W9ocNv+ZeLek3oZF6m1YpN7igyEjjtIcPXo0uyOIf5HhxtHr+Pn5sXHjRnbs2EFUVBRNmzbNit0KIYQQQgghhBDCwISGhqbd0f3PcufOnQ1pRKYbRwkJCezbt48NGzZw9epVAPR6fbq7qwkhhBA5gVqtkt9SGxCpt2GRehsWqbcQH7YTJ04wdOhQwsLC0i1/2Wu4detWNiUzbBluHN25c4eNGzeya9cuoqKigJQiOjg40KhRI5o0aZLlIYUQQoi3Ib/TMCxSb8Mi9TYsUm/xwVCpsjtBjjRx4kQ8PT1p3749pqam2R1HpHqjxlF8fDy7d+9m48aNXL9+HUhpFhkZGZGUlISiKBw4cAALC4t3GlYIIYQQQgghhBAfpuDgYH788UcKFiyY3VHEn7xR46hGjRrExMSgT72NQbFixWjVqhVNmzalSpUqAKg+wI7pvbjk7I6Qjr0mKbsjvMI0h9U9Xpezhi5rszvAX0Rq5VYkQgghhBBCZDsZPvdaVapU4caNG9I4ymHeqHEUHR2NoiiYmpoyfPhw2rRp865zCSGEEEIIIYQQwoCMGTOG1q1bc/LkSdzd3V+ZQ7lnz57ZlMywvVHjyN7enufPnxMfH8+oUaNYu3YtzZs3l7unCSGEeC/IRKqGReptWKTehkXqLcSHbdGiRYSGhnLy5EnMzMzSrVMURRpH2eSNGke//fYbx44dY/PmzZw8eZLbt28zdepUZsyYkbZNQkLCK4UVQgghcgK9XKVpUKTehkXqbVik3uKDIZeqvdbu3buZPHkyLVq0yO4o4k/eqHGkVqupV68e9erVIzg4mG3btrF161b8/f3TtqlTpw61atWiUaNGNGrU6J0FFkIIITJKUZS0efrEh0/qbVik3oZF6i3Eh83MzIzy5ctndwzxFxme2djJyYmuXbty4MAB1qxZQ9OmTTExMSEuLo79+/fTv3//d5FTCCGEyDS1Wn6rZ0ik3oZF6m1YpN7ig6GosueRw7Vv35758+cTFxeX3VHEn7zRiKO/4+XlhZeXF6NGjWL37t1s2rSJGzduZFU2IYQQQgghhBBCGIiLFy9y4cIF9u/fj729PRpN+pbFkSNHsimZYXurxtFLlpaWtGvXjnbt2nHnzp2s2KUQQgghhBBCCPFhUsnoudepUKECFSpUyO4Y4i+yfKxasWLFsnqXOdInk0Yz6qkfP/h5U6lzBwDKtGnBD77XGP3sHk1nT0VtZASAuZ0tX29fz7gXj+h2bC+2+fICoDEx4fNVPzL2uT99L54kd1nPTOcp1q83n/pc5jO/m3iOG522XGVqSoPff6PqLz+lLctVqiR1D++nmb8f1Tf8gqmzEwBGNjZU+XkFzfz9+PjEYewqvt1/sIX69qLejas0fHCHcksWojY3I1/nr2ny/Gnao9LGX9M9x6F2LRqHPMHti7Yp+U1MKLtoHg0f3KHm8UNYly6V6TyvO0cuDerR4OxJmj9+QO29O7AsXCjdcyounEvTh3fTfq61ayutw4LSPUoMHpCpPCX69eYzn8s097tJmdQ8ps5O1Ph1NS38fal/7CBWf8mTq0RxWj/1x2PIwLRlBb/6H40vn6PFw7t4/DAoU1k+GjGEkfEv0j2+OrCDil07p1v2xc5NAOSvXZNul88w6NkDmv+0BGNLy9fuzySXdaby/C1nN4wW70JVL2WyPKVURYzGLcVowTY0PUaDZcrxjJcfeOWhFC2dtVmEEEIIIYQQWapnz57/+BDZI0tGHBmasu1aU2dwP/YMGYmVizOtl8wj6NYdPv/pR65t2s6D307RfMFMooODOTp5Jg3HjSBfFS+2du9PgzHDaLFgBis/a0uN3t0o07YFW7v3p3KXr/li9VJmelbJcB6HalUoPWo4N6fNRGVkRPF+vQk9d54oXz8qzJuFdfFiRN27n7Z9lVXLSY6J4WKvvniOH43X4gWcbNmW0qNH4FSrJpf6DSR/+3bU2LiWvZ4VSI6OyXAm+5rVKTFyGH5z5hP70J/SM6cSc/8B5vnyEnHdh1tjxoNeT+LzF2nPMcqVi7ILZqOo/uhnFuj6La7Nm3J94BDydfyKcksWcqJarSw5R+E3blB+5nRCTp3GZ8Jkyk6ZQIU5MzjRpAXGtraUGj2C/O3bkRgRkbafayPGYGxjk5Ktw5c4161FwOatGc7jWK0KnqOGc2PaTBQjI0qm1qxYz+8xtrHhYr9BlB7+A+WnTuJEq88BUBkZUXnJQtSmpmn7ca71EV7zZuEzdQZqUxNKDRnIs6PHeH7+YobyeK9dT8CZswDkrlieuuNGcnHJSoo2bsiza9c5PGw06PXEhj7HyMKC1r/+ROClK5yaOpNGs6dRf9oE9nTvi5GFBdUH9aHG4Kyf60wpVRFNx34oRsYpC4xN0HQbjv7WVXT7N6H+qjfqJu3Rrv+RpJk/pD1P074H+oQ49PdvZ3km8f7Q6WQiVUMi9TYsUm/DIvUW4sO2ffv2f1zfvHnz/ySHSE8aR5mQr2olkuLiODFzPoqiUL1XN9qt+hGNiQlnFi0l4PwlyrVvS6nmn3F08kyKNayH7+FjXF2/GZdSJfiofy9UajXFGtbjyZVrXPx5LWojDa1+nItNXnfCHwVkKE/o2fPsK1+ZuMCnuLdKGYmhS0qixsZfibx9h/jgkLRtje3ssCpciOtjxvNk526sixej5JCBaKwssa/sxYsLF3m8dTvxz4KovWc7jjWq83T/wQyfo6SISO5MmY7fnPnok5IoPmoYZnndsSlfDhNnJyqt/4VInxtc/u77tOeUmjGFxPAITF1d05Y51q1DpPd1Hv+6AZXGCM/Z0zFzcyPu8eO3PkeKouLWzNkE7t5LlK8f+dq2xiZ11Jfn+NHYeVUk9Nx5rIv/MYou/Jo3ABYF8uPaqD7Xho0i+v6DDJ+f0LPn2VO+MrGBT8mXmkdjbo5jlcpc7D+IgK3beX7hIrqkpD/Oz/AhqP5yja9788+ICwrmxpTpqIyNebh+E9EPHmY4T/gDf8If+KPSaGg4YzI+GzZza+sOao8eiqWLC19s30DQtets7fAdDsWKYGZny9Wf13Jz8zYKfFyH4s2asKd7X6r27UHZDv/j3qGjFG5YL8M5/padE5re49D9fgR19QYpyxITSBrxLSQmoNg5gU4HyckA6G9dAUBVuQ44uqAd1wOSk/5u78IAyBcNwyL1NixSb8Mi9RYfjPdgours8MMPP7x2uYmJCS4uLtI4yiYZfrdqtdp/XP/o0aNMh3lfhAc8xsjMjIK1alCwdk3UGg3hASmNjCL16mCT1x3HooXJ5ZYbAOs8rsSkjqyJfRGGxtgYC0cHrHO7Evun5QDWuV0yHkinI+bBQwp3/RavhXMJ3HeAZwcPc+bLjpxu9yXa+D9mpE8MDycpKhqHalUwtrfH3qsCikqFmasrsY8fY12iBGZueXCsXhUAs9yuf3fUfxTpfR3f6bPQJyWRr1NHjO3sCD1xkqTwcJ5s2sLFDp0wdXXBc/YMAPK0bonTx3W4PmBIuv2YurqQmHpuksJS/jRxcc54oNecI//1G7kzex5Rvn7YlPHEpV5dgo/9BsDdBYs5VK0W0X8aqfVnJQb1Jy7wKQ9W/5LxLIBepyP6wUOKdv2WSgvn8mTfAaIf+gOQ59NGtHx0j9rbN2NVsAAADlUrU7Trd5zrln54prm7O/rkJOod3EuLh3cp3vN79KnNk8wo3b4tdkUKcWz0BFQaDfFhEVxft5FNbb/CKrcrTRbPISrwKTqtlvy1a2Lh7IRLmdKY29uhMTXFZ8MWFnhU5MmFS5nO8FoxkSQN74x251/Od/hzFOc8GI1ZDJHhaPdt+GOdokLdrAO634+gD/TP2jxCCCGEEEKILHf79u10jxs3brBnzx48PT3p1atXdsczWBluHHXr1o34+PhXloeHhzNhwgSaNGmSJcFysrNLVvH44hW6HdlNu59+JCEqiqigYM4t+4lG40Yw+NZFkhMSQZ/yGxFFUeA1vxxRFOXlJlkicO9+znftjku9uhTt+T0RPjdf3Uin4+qQYTjXrkVTv5tY5MuXslyv58b4yaiMjGh8/TJ527RKW/423L9sT6mpkwg+cownGzdzutFn+AweRvDBwwRu3YFdlUqY5nbFY+pEbo0eT+Lz5wCoNEagUqWeu6w7SX89RwC2Zcvw0baNJDx/js+EyQBE3r6D/m+apMb29uRt1YL7K39+62xP9u7nbNfuuNari3PtjwDQWFpy+qtvSIqIoOqKpWgsLai8eAG3Fywm4k7KfEuKRoOiVqMoCuZ58nB/7Tq8x06kwP++oGCH/2U6T6UeXfHbf4jwh4/QJSezqnZD9vcdjO++g9zYtA33alWICQnlxPgplO/UgX4PbmJkbgaAXq/nhd89kt/FrTMT4iHk6WtX6UOfkTR7GCig6fTHHE9KmcooTrnRHd2Z9XnEe0ejkd/qGRKpt2GRehsWqbf4YChK9jzeM2q1mkKFCjF06FDmzp2b3XEMVoY/eU+ePEmHDh148SJlpExiYiJLly6lfv36rF27lqSkD/9ykISoKJZ90oKZnlWYUaoyikpF2KMAdvQdwozSlZmY34MQXz/CUi85i3z6DHN7WwDM7e1ITkwkJiSUyGdB6ZYDRAY+y3Ae87x5cW/Vgmi/ezzauIUY/0c41qj+t9v7b9jEgUo12FeuEg/XbUCv1RL7JJDw6z4crvUxByrX4FKflDlqYgMydknYn7l90RbP2dMJOXaCix06YezoQKE+PbEsVhQARaNGr9XiWLsWxjY2eM6ZQZ1zpwDwnDMDt89bEx8UjJFdyjkysks5RwnPgjKc5e/OUa5SHtTctpGkyChONGlJQkjIv+7LpV5dVMbGPNm9N8M5XrLIm5e8rVoQ5XcP/9Q8Tqk1e7xrD0EnfiNg527MXJxxqVsHy3x58RjYjzbPUkb0eQzsR8mB/YgNfEpSZBT3f16D75JlaOPjyVWieKYyWbvnwaVMaW7v3JOS0cmRagP74JB6qZ4qtV56nY4zM+ayyLMyc4t48vDEKaKDgtEmJGT6fGSKmQVK+eqgUqO/cQndjcsoxf6YYF5Vtir60GfoA+79t7mEEEIIIYQQWUqlUhEcHJzdMQxWhuc4sre35/r163zxxRd06NCBFStW8PTpU/R6PQULFqR//6yfFDenKVS7Jl0P7+LolJkoKhUaMzNu7z3ImJAH+B39DZ/tuylUqwb7R4wHwPfwcTyafkrZz1vh2bIZfkeOo9Nq8T18jI+HD6LCV19QsWN7gm7ezvD8RgDWRQtTefmPWJcoTnxQEJYFC/Bw7bq/3b7Wzi2YurhwY8JkCnz1P54eOoI2NpaSPwyieP8+XOrdH7cWTYkPDiH41JlMnSPLYkUpPXMaCcEhPFy2ArvKXiSEhFK4X28c69TC/6c15G7RnGe79hJ04BCnGjYGwNTZmYqrV3J3xmyCDx7BLHceigzsi1u7Nrh/0ZaoO3czPL/R352jR5u2UHX1SoysrPAeORaL/Pkwy5Ob0DO//+O+HKpUIj4omNiAjNfqJauiham6/EdylShOXGqe+2vXYWRlScEv2xPj/wj3zxoT7f+IZ8eOc7j+p2nPrXdoL/dXr+X+mrXYlC5FwS+/wGPIQJKiolCbmvLi8tVMZXKvWhmAJ+dSJtZOiounxuD+FKxXh8vLf8ajTUtubd8Fej09blwk+lkwFxYtoUSLpvhs2Jzpc5FpKhWazoPR37qC9vcjqMpWQe9344/VhUuikwmxhRBCCCGEeG+8bnLs6OhoNm7ciKdn5u9CLt5OhhtHGzdupFu3bvj6+jJhwgT0ej3Ozs707NmTVq1aoVJ9+MNH7x0/yal5P1Kt+3dEB4eyvkMXHpw8w9bu/fl08hjcvcpzcu4iTs5dBMDeH0Zh6ehAy8Wzeertw7aeKbdSPzFzPvaFCtJ0zhTCHjxiXYcumcrz7PBRro+bSJGu36EYafBbtpK7Cxb/7fbXho/Ga/F8KsydRdDxE1zul3J5j+/ipdhX8qLcjKlE3rrNqdbt0L3mssQ3ke/rr1CbmKB2cabS+pR5aZ7t3c/lTl0pOXEsZRfMIfS3U/gMHUFSWFjaJWpm7m4AxD58SOLz59xbuBjzgvnxmDyBWP9HXOnaI1N5XneOonz9sCyQH4CK82cDkBgRwc78Rf9xX2aurm81EutlHu/UPCojDb7LVnJnwWIebdmG17zZVP5xIVG+vpzp2JnkqGieX0w/Z1BsYCBxgU+JC3zKlaEjKdazG2pTU+4sWMzD9Rszlckqd8qcXBGpzcvEqCi2/K8TDaZPpOmyBTw49hsH+qdMVrenR38+XZByR7XbO3ZzZPjYtzgbmRQTRfKPE9G07YLmmwHo73iTvHrOH+ttHODKPzcBhRBCCCGEyBYG8L05M143ObZGo6FcuXKMGTPmvw8kAFD0+oxP0hITE8OAAQM4fvw4iqIwe/ZsGjVq9C7yZavBGpvsjpBOJSuT7I7wCtMc9oEXr9Nld4R0/nkq+f/e3bicdSnpkC+9sjtCOhGTs2HklPhPaDQqkpNz1ueDeHek3oZF6m1YpN6GxdHRKrsjvDPa5SOz5bjqb8dny3HF++2NRhx99913ryzT6XSo1Wp0Oh0DBw5k8+bNKIqCoigsXbo0y4MKIYQQmSVfMgyL1NuwSL0Ni9RbfDDew4mqheF6o8bRyZMnU+8A9sfgpD//nJyczKlTp9KWCyGEEEIIIYQQQvybDh06vNF2iqLw888/v+M04nXeqHHUvHlzaQgJIYR4b6nVClpthq/MFu8pqbdhkXobFqm3+GAoOWvKj+yUJ0+ef1x/8eJFAgICsLa2/o8Sib96o8bRlClT3nUOIYQQ4p1J+eWHfNEwFFJvwyL1NixSbyE+PJMnT37t8ujoaKZMmUJAQADVq1dn4sSJ/3Ey8VKm2pz37t1j9uzZaT/fv3+fQYMG4evrm2XBhBBCCCGEEEIIYXjOnDlD06ZNOXDgAOPHj2fFihW4uLhkdyyDleHG0fXr12nTpg3Lly8nPvVW7Xfu3GHXrl20a9cOHx+fLA8phBBCCCGEEEJ8MBQlex45XGxsLKNGjaJTp04UKFCAnTt30qZNm+yOZfAy3DiaM2cOsbGxlChRgtjYWADy5s1L2bJliYmJYf78+VkeUgghhBBCCCGEEB+u33//nSZNmrBnzx7GjRvHihUrcHV1ze5Ygjec4+jPfHx8MDU1Zc2aNZiZmQHg4eHBypUrqVatGt7e3lkeUgghhHgbMpGqYZF6Gxapt2GReosPhkomx34pNjaWadOmsWHDBqpWrcrEiROlYZTDZLhxFB8fj0qlwsTEJP2ONBr0ej1xcXFZFk4IIYTICnq9fNEwJFJvwyL1NixSbyE+PJ999hmBgYG4u7tTvnx5tmzZ8rfb9uzZ8z9MJl7KcOOoePHieHt7M3jwYDp37oytrS1BQUEsW7aMhIQEypYt+w5iZo9IrS67I6STlAP/R6nkwEw5SU67itg4hwVSGWf4I0iITFEURb5sGBCpt2GRehsWqbcQHx69Xo+rqyvJycls3br1b7dTFEUaR9kkw9/aunbtSvfu3dmzZw979uxJt05RFLp27Zpl4YQQQoisoFYrJCfLFw1DIfU2LFJvwyL1Fh+M92Ci6v/K0aNHszuC+BcZvrCybt26TJ8+HScnJ/R6fdrDycmJ6dOnU6dOnXeRUwghhBBCCCGEEEL8xzJ1nchnn31GkyZNuH//PhEREdjY2FCgQAEU6ZoKIYQQQgghhBD/TJHJscX7I9Pv1qSkJEJCQnj69CmhoaEkJydnZS4hhBBCCCGEEEIIkc0yNeLoyJEjjB49mufPn6ctc3JyYsKECdSsWTPLwgkhhBBZQSZSNSxSb8Mi9TYsUm/xwVDJ1Tri/ZHhEUeXL1+mT58+hIaGpn1w6/V6goKC6N69O97e3lkeUgghhHgbWq180TAkUm/DIvU2LFJvIYT472W4cbRw4UKSk5OpU6cOhw4d4ubNmxw6dIg6deqQlJTE/Pnz30VOIYQQQgghhBBCCPEfy3Dj6OrVqxgZGTF79mzc3d1RFAV3d3dmzpyJRqPh8uXL7yJnjuJctDDz40Oo26c7AKU+bcjomxeYG/2UAb/tx7loYQDyeJbih3PHmB3xmB67N2Ht4gyAua0tXTavYXbEY4ZdPkmByl5p+274Q3+mBt5ldngAndauwNjc/I0ylezXm6Y+V2h57xZlx4/BqWZ1vggPfuUBYFO6FA2O7KdN4EM+PXsS549SLi80trGhxuqVtH50j0a/HcG+YoW3Ok/F+vbik+uXaOJ7g9LjRgOQq3QpPj5xmKYP71Jx4TxUpqYAONasTv0zJ/jswR28lixEY2mRcq7c3Ki5dSNN/f2otWc7loULZT5Pv9586nOZz/xu4pmax6VBPRqcPUnzxw+ovXfHK/uvuHAuTR/eTftZbWaG15KFNH14lya3r1N8QN9M5ynerzdNfC7TzO8mZVLzFP72G9qGBaU9am5aB4C5uzt19u6gxaN71Fi3BmNbWwBylSrJx4f308LfjxobfsHU2SnTeXJXqkiHU0foF/KIFhtWU7BhPYbEvXjlAeBY2oOvTh6ib5A/rbeuxyL1vf1SqS+/YEjcC5w8S2U6z2s55UE9dztKnWZpi1SN26NZtAfMUt4zqDWovuqLesYG1FN/RdX8m6zNIN5LGo1MQGlIpN6GReptWKTe4oOhqLLnIUQmZOqdo9FoMDIySrfM2NgYjSZTUya9Vzwa1aff0d0YmZgAYGJpyXcbfyLk3gNWfdUF+/x5+d/SeQB02bQalUbNmk49yO1RnG9WLwGgxZQxFP+4Fmu79CEqOJSeezdjYmlJsTof0WLyGH7/aS1bBo6g4uctaTC4779mcqxWhTKjR/Dg1/Xc+/kXSvTqjnGuXBxt1pqjzVpzskMnkuPiuLt0BQAVpk7C2M6O8737E/skkCqLU0aJlRkzAudaNTnfdwDxIaHU2vRrWgMnoxyqVqHUqOH4/7qBB6vXUrTn9+Ru/AmVli5CGx/PtWGjcG/VnMLfdUZtYU6Vn5YTFxjI1YE/4FKvLp4TxgJQfu4MLAoW4GLPPqjNzKi29ufM5alWhdKjhvNw7fqUPL26k/fz1lRZuYyYh/6c79YD87zuVJgzAwBjW1vKz5lJ/vbt0u2nWN9euDX7jGs/jCBg63ZKjRiKY43qmcrjOWo4D9au5/7qtRTr1Z08jT/BrkJ5wq77cKJFG443b8P1sRMAqDBrKqZOTlzqPwj7ShUpNXwIANVWLUelUXOhV19yFS9GpcULMnV+TG1taLtzM5GPH3Nk4DAKNWqAcxlP1n/agvWftmDbFx1Jiovj0o/LAGi+dhUqtYZ93XrhULI4TZYvBkBlZESF7l1ouGBWpnL8E6VkBdR9J6G8/OwxMUX12Vcon3yRfrvKdVFVrY/u4GZ0R7ahatAapVjZLM8jhBBCCCGEEIYgw42j4sWLEx8fz+TJk0lMTAQgMTGRSZMmER8fT8mSJTO0v6CgIHr37k2lSpWoWbMmkydPJiEhAYCAgAC+/vprypYty6effsqpU6fSPffMmTM0adKEMmXK0KFDBwICAtKt/+mnn6hZsyblypVj2LBhxMXFZfTlpmOX150euzdy69CxtGXGZqbsnTCdLQOHc3XbLvwvXMY+f14s7O1wLlqYixu2cnnLDs6sWkuxj2tjamVFwWqVuf/7BS5u2ML+STOwsLOlaO0axIZHsGv0JHaNnsSp5T8TGx6Bff68/5or9Ox5dpWrzI2Zc4i8dw8AXWIiQSd+I+jEb7h+XIe4Z0FcGTkGAEWtJj44hOAzvxN1/wHa1Do6VPIi9PxFHm3dzo1ZczCxtcUpE00RgNBz59lfoQq3Z80l+t59ADRWVlgXK4r/rxvw/3U9YVev4VyvLlZFimBsa8vDtesJ2LKNwH0HyN3kUwDsvbwIOnyUwF178Fu6AqsihbEuUTzjec6eZ1/5ytyeNZcov5RzpCgqbs2cjffIMQTu3kvY5auY53UHwHP8aByqVib03Pl0+wm76s21oSPwX7+Rh2tTRwOlPicjnp89z97ylbn1pzy6pCTsypfDIl9eam78Fc9Rw0iOiUHRaHD6qCaPd+7m0eatPDt6HJd6H2NsZ4dV4UIEbNvB4527ebB2Pc61aqKxssxwngL162KSy5rfRk3A++dfWFXpIy4vWY7/sRP4HztBwfofE/30Gcd+GIWZvR12RQpze8s27mzbyfXVv5KvzkcYW1lRsm0raowcyr29BzKc4R/ZOaLqPhr9ratpi5SPW6BUrY/+1l9GOab+JkXv54P+/s2UvycnZW0eIYQQQggh3oaiZM9DiEzIcOPom2++Qa/Xs3btWry8vPj444/x8vJi3bp1KIpCx44d33hfer2e3r17ExcXx9q1a5k9ezbHjh1jzpw56PV6evTogYODA1u2bKFZs2b07NmTwMBAAAIDA+nRowctW7Zk8+bN2NnZ0b1797QJuw8cOMCCBQsYN24cP//8M9euXWP69OkZfbnpxDx/waii5dk9ZnLasqiQUA5MmUXQHV/yli+Lxyf1uXXoGLFh4cRHRVHko+pYOthToIoXKpUKmzyuhD16TJ7SJbF1d6NIrRoA2LrlIeDKNfaMm4I2KYla33+Lpb1duibV355HnY7oBw8o1vU7qiycx+N9+wk8eBgAy/z5Kfhle3ymTEeX2pC7PGQYtqU9aH7zGoW/6cDFASmjV2IfP8GmZAnM3fLgVL0aAOa5c2fuZOl0xDx4SOEu31JxwRwC9x0g+n5KAykxLCz1z3DMXJyJf/oUvVaLY83qmDg5YlO6FCZ2dqhMTYl98gTbCuUwcXTAoUolAMzyZCLTyzxdv8Vr4VwC9x3Af/1G7syeR5SvHzZlPHGpV5fgY78BcHfBYg5Vq5XW9Hrp6b793F+1GoDi/fugS0wk9PTvGY6TUrOHFOn6LZUWzuXJvgM8O3qcxPAIHm3czOmvvsHM1ZWKc2dh4mCP2tiYxBcv0s6fmYszSeHhJEVF41CtCib29th7VUBRqTBzdc1wnlx5UxqUtcaPZED4UxrMn4mRRcpoM5sC+Snd8X+cnjAVbUIC8WHhJERF4V69GmYO9uSuVBFFpcIqtyuPTp7ix+Jl8MvqxlFMFNoxXdDtWZu2SH/xBNrR38HDO+k21Z89jN7vBpqBM9D0n4bu/DG4dyNr8wghhBBCCCGEgchw46hevXoMHToUjUZDQkICT548ISEhAZVKRb9+/ahXr94b7+v+/ftcvXqVyZMnU6RIESpWrEjv3r3ZvXs3Z8+eJSAggHHjxlGoUCG6du1K2bJl2bJlCwCbNm2iVKlSdOrUiSJFijB58mSePHnC+fMpI0RWr15Nx44dqVOnDp6enowdO5YtW7a81aijhJgYQu8/eO26vBXK0efQDqJDQtkxfBx6nY4NvQZRon4dZoQ8wKFgfiClWbZj+DjURkZMfnSTSv9rm7b8peqdO/D5ghnc2H+Y82s3vHG+x3v38XuX7uSu9zHFe6bMv1S0a2eSwsPx37w1bbuSA/sRHxrKsZafE3TiJJUXzkVtbo73hEmojIxo5nOF/G1akRosI6foFYH79nO+aw9c6tXFuXatV14rQHxQMDenTKdAhy9pfPMaajOztGN7Dx+FZcGCNLnjg0PVKm+dKXDvfs537Y5LvboU7fk9ALZly/DRto0kPH+Oz4SUpmDk7TvotdrX70RRqLhwLu4tm3Nz6gxi/P3fKs/Zrt1xrVeXot2+42jDxlweNJSnBw7xaOt2HKpUQpV6adZfz5tep+PKkGE4165FM7+bWOTLl7oiE+cn9bcP0U+D2PFlJ5xKeVB3yngAKnTvQnxYODc3bkk77uH+P5D/49r0DvAlV4F8afkiHz0mISIyM6finyXEQ+iz9MuCAyEp4dWX4lERpbAH2k1L0G5ehqpSHZSy1bI+kxBCCCGEEJklcxyJ90imJiXq2LEjn332GcePHyc0NBRHR0dq1KiBo6Njhvbj6OjI8uXLcXBwSLc8Ojqaa9euUbJkScz/NDl0hQoVuHr1KgDXrl2jYsWKaevMzMzw8PDg6tWrVKxYkevXr9OzZ8+09WXLliUpKYnbt29Trly5TLzqv+dWpjR9Dm0nLjyCOR83JSo4BICza9bj+9sZUBQqtG1BswkjCQt4QmJsLBPL1cAslzWWDvYMPHmAF/4pl9lV7die/y2dx62DR/mxRfs3Or5Fvrw4VKyA/5ZtRPndw2PwAJxqVOP2gkXk+aQRTw4cStcEca1bm4cbNvPs6DFMbG2otmIJuYoV5cWVq+z/qC5G1taY2NtRb98uYv5y+d+bMs+bF7uK5Xm8dTvRfvcoMag/dhXKA2BilzKxs7GdLXHPggC4M3cBj7fvRBsXR/GB/TCytkaXkEDQsRMcqlYLtZkptmXLUGnpImIDHmcqj71XBQK2bEvNMwDHGtUJOv4bNbdtJCkikt+atSYhJORf91Vx/mzyt2/HzakzuD1rboazAFjkzYtdap4ov3t4DBqAU62aKBoNgfsOEHnnLiqNBr1WS/yzIHTJyZjY2QFgYmeXdt78N2wi5MxZUMC9RTNKDf+B2CeBGc4Tlfoc75/WEHTVm8ALl3AoWQKAwo0bcW/fgXTvoRu/biDg1BkURaF4q+bUHDOcqMdPMnUusppSsjz6pCT0x3YCoG/2NUqxMuivnsnmZCI7JSfrsjuC+A9JvQ2L1NuwSL2FEOK/l+nZrO3s7GjZsuVbHdza2pqaNWum/azT6fjll1+oUqUKISEhODmlv0OUvb09z56ljDr4p/WRkZEkJCSkW6/RaLCxsUl7flbRGBvTdcsvmFlbs2XgCBwK5sfWPQ++v52m39Hd2OR2ZcfwcdT4tiM+ew+SGBtLkzHD+GTYANZ824sKbVsQGRTM3eMncS1ZnPZL5hIVFMyx+UsoVL0KUcEhPLn+z5fZWBcpnNL8KVGcuKAgrAoW4P4vv2Lq7IRl/nzcmpt+wuTwGzfJ80lDnh0/QaGOX5IUFU3U/fuUGjoYj/59ON+7P+7Nm6bMg3Qqc1+2rYoWpvLyH8lVojjxQcFYFizAw7XrsCxUkHxffI4uMQkbz9LcnDQNgIYXfyc+OJh7S5aTp2kTAjZvA6Digrm4NKzH1UFDKdz1OyJu3iLqrm+G81in5rEuUZz4oCAsCxbg0aYtVF29EiMrK7xHjsUifz7M8uQm9MzfX3pWoMOX5P/fFwSfPE3o7+dwqvURUX5+xGWwWWNVtDBV085PSh7/jZsp0a8PznVqc/+n1bi3bM7jXXvQJSURcvp33Jo2IeLWbZxrf0TA9pSmSK2dWzBzceH6hMkU/Op/PDt0BG1sbIbPz4PDR0mMiaHq4P7c3roD14rl8du9DwsXZ2wK5OfcrHnptm+3fweWri6cHDMRz2++4v7+QyRl4rjvgv7JA1RGRiiffgFaLYqREbqAe9kdSwghhBBCCCHeS2/UOPruu+/eeIeKorB06dJMhZk+fTo3b95k8+bN/PTTTxgbG6dbb2xsnDYhd1xc3N+uj4+PT/v5756fVUo1bohjoQIAdFixEIDY8HD62+Zlc/9hfL16CV8un8+tQ8dY27UPAEfnLKJQtUp8sWgmgT63mN+oJUnx8dTs2gkjExNyubrQc88mAK5u3/2vI4+eHj7KtbETKNqtCyojDXeXreD2gsXYlvIAeGXU0O9de1Bp3iyqLJpHbOBTznTuQlJEJHcWLcGxkhcVZ0wh/NZtjrf+HG3qucyooMNH8Rk3kcJdv0Mx0nBv2Up8F/5I0NHjVJw/mzKTx/N42078li4H4Er/QZSbOY2y0ybxZPdefFLvJnZzynSsihamwtxZvLh4iXOdu2Yqz7PDR7k+biJFUvP4LVtJlK8flgXyAymjiAASIyLYmb/o3+6nUJfOADjVrI5TzZSJw68OHYnfjxl7zz87fBTv1Dyq1Dy3Zs/jxeUrlJ04Dq+Fcwn+7RRXhgwH4GLv/lRaPI8Ks6YTcuZ3fCZOBeDa8NFUWjwfr7mzCDp+gov9BmUox0uxwSFsadWeejOn0GjRHB4dP8mx4aPJlTrxd+Sj9KO8jg4ZQZPli2m0aC4Pjx7nQM9+mTruu6A/tR+dUx5UtT8DFHTHdqL//fAbPfflLX71etBqU36jqVarXplHUKvVodeDSqWgUqVfqdPp0en06fb3Zy9/U/pP+1UUBbU6/Uq9Xo9W++/7fV0mrVaPXq9HUVKOm36/f7zWjO735Wv9t/3mhHOoKApare4N96ugKDn/HL7Jfl+X6U1r87r34ZvX5p/O4bt/fyuKgl6vz/ZzKJ8R/81nxMt6/zVT9ry/c845/FA/I4yM1K9cvp8V72/5jMi5nxEfrL+cDyFyMkX/10/e1yhevPgr/1P+2x0qCrdu3cpwkOnTp7Nq1Spmz55Nw4YNGTt2LOHh4cyePTttm19//ZV169axa9cuGjduzJdffskXX/xxK+6+ffvi4OBA9+7dqVq1Knv37qVQoUJp66tVq8aYMWNo0KDBG2Xqplhn+HW8S7VymWZ3hFcYq3LWdbJv8h79L+W0/909iM9Zdxcb8E3V7I6QTtjY9dkdQbwjGo1KLm8wIFJvwyL1NixSb8Pi6GiV3RHeGe3GmdlyXHXbAdlyXPF+e6MRR82bN3/ltwJZafz48axbt47p06fTsGFDAJydnfHz80u3XWhoaNrlZ87OzoSGhr6yvkSJEtjY2GBiYkJoaGha4yg5OZnw8PAMz8MkhBBCCCGEEEJkqXf4/VqIrPZGjaMpU6a8swALFixg/fr1zJo1i0aNGqUtL1OmDEuXLiU+Ph5T05SRNpcuXaJChQpp6y9dupS2fVxcHDdv3qRnz56oVCpKly7NpUuXqFy5MgBXr15Fo9FQvHjxd/ZahBBCCCGEEEIIIT4kb32dUVxcHD4+PgQFBWX4uffu3WPRokV89913VKhQgZCQkLRHpUqVcHV1ZejQofj6+rJ06VK8vb1p3bo1AK1ateLy5cssXboUX19fhg4dipubW1qjqH379qxYsYLDhw/j7e3NmDFjaNu2LWYvb/UuhBBCCCGEEEIIIf7RG99Vzd/fn61btxIXF0e9evWoVKkSp06dYsCAAURGRqIoCp988gmTJ09+ZVLqv3PkyBG0Wi2LFy9m8eLF6dbduXOHRYsWMXz4cFq2bEm+fPlYuHAhuXPnBsDNzY358+czadIkFi5cSLly5Vi4cGHaJXWNGzfmyZMnjBo1isTERBo0aMCgQZmbOFgIIcT77eWEoMIwSL0Ni9TbsEi9xQdDyVlzxQrxT95ocuxLly7RuXNnEhIS0pYNGjSIZcuWERYW9sfOFIVOnTp9MA0amRz738nk2P8sp03dKJNj/zOZHFsIIYQQIuf4oCfH3jwnW46rbt03W44r3m9v9K1/9uzZxMfHY21tTcWKFTE2Nmb69OmEh4dTt25dli5dSosWLdDr9ezfv/9dZxZCCCEyROafNCxSb8Mi9TYsUm/xwVAp2fMQIhPe6FK1O3fuoFar2b59O66urpw+fZrOnTuj0WiYPn06FhYWVK1alb179xISEvKuMwshhBAZolbL7ZsNidTbsEi9DYvUWwgh/ntv1DiKjY3F1tYWV1dXgLQJqG1sbLCwsADAyMgIa2trnj9//o6iCiGEEEIIIYQQHwCZ40i8R96ocaTValGr1X88SaNJ9+dLKpUqx80x8zYs1TnrP2bLP9UgpzDJYcMdNTls/LLk+WdKmTLZHUEIIYQQQgghxD94486IksO+cAohhBBCCCGEEEKId+uNRhwBREZGMmbMmH9cFhkZmVW5hBBCiCzzAQ2GFW9A6m1YpN6GReotPhgyMEO8R964cRQXF8eGDRvSLYuNjU23TK/Xy8gkIYQQOY5WKxOpGhKpt2GRehsWqbcQQvz33qhx5OXl9a5zCCGEEEIIIYQQhkEmxxbvkTdqHK1Zs+Zd5xBCCCHeGbVaJb+lNiBSb8Mi9TYsUm8hhPjvSZtTCCHEB0+uojYsUm/DIvU2LFJvIYT4773xHEdCCCGEEEIIIYTIAirpgor3h4w4ygTHooWZEhNEzd7fA5C7rCf9Lp5k/HN/2q1cjMbUFAD3iuXoc/YYE8Mf0+3wLuzy5wPANq873Q7tZFLEE4b5XqPs563S9t3n96PMSA5Pe5Rt2/KNMhXu24v6N67S6MEdyi1ZiNrcjPydv+az50/THpU3/gqAfc3q1D59nEb3b1Pux4WoLS3S7cvEyZGGd29QdsGctzpPBfr0pJbPFercu03pH1MyWZUuRZVjh6hz7zalFsxBlXqu7GrWoNrJY3zsf4/KB/diVcoDAGMHe8qt/Zm6D+5S8/J5crdv91aZzAsVonbAfdy6fAuAU/OmVL1whloPfCm3dROmbnnSbW9RvBi1Ht2jwKD+6Za7fN6WusFPsEzNmVlmhQpS49E98nTpDICxkxMeq1dSzfcm5Q7uxaxQwZQcHiUpu3831R/4UuG3o9jUrA6A59ZNfBT0ON0j74B+mcpStG8vPr15jc8e3sVr6SLU5ubkadGMhlfO09j3Bp6TJ6AYGQHQ8sWzVx4O1aqiNjenwsJ5NLl3i4ZXL+DWqsVbnZ+/M2X/GfIPXYDzgDkM2nwEvV7PlUfPqDBhBXZ9Z/HNT7uIS0x6J8cWQgghhBBCCEMijaMMKt6oHt0O7URjYpK27H+rl5IUH8fO/sMo264VNXp2AeDLX1ehTUpkU5feuHiUoOmsyQA0GjeC3GVKs7l7fx7+fo52KxdhZGaG2tgY1zKlODZjLksaNWdJw2b4HT/5r5nsa1anxMhhBKzfyM1R48jTohmFevXApkJ5Iq778Hurz/m9ZVtujZuI2sKciquWERf4lOuDhuJUrw4e48em21+ZebMxtrd7q/NkV6M6RUYM48n6jdwdPQ6X5k3J37MHpRcvQBcXx50Ro3Fp0Zy833YCoNT8OWjj4rjRdwAoCsWnTASg6JhR5KpQgRt9BxB+/gIes6ZjViB/5jLVrUO5rRtQpdZOZWZKyflziL13n9sDBmHqnoeCw4akba8YGVFy0XzUqc2tl8vcvu1E8RlTMnlm/mBbtw6eWzam5QEosfxHTPPnx3fQD2isrSk8aTwAhSeNx8jWhrsDBpEQGEixeXMAuD9mHN5t2uHdph3BO3aSFB5O8NbtGc7iWLM6pUYNx3/dBq6PGotbi2aUnT6Fiovm8fzsOW6Mm0jBbzpQtFd3AE62aJP2iLrrS9iVa7y4dJkiPbrh1rIZ134YQeTNW1RcNA8TB4e3Pld/9pvvI0ZsP0HHqp50rlGW2YfPs+PqXTqs3ImpkYZZbeux/sJNFhy7lKXHFUIIIYQQIssoqux5CJEJ8s7JANu87nTasYG7h4+nW+ZcsjgXf/6VCz+v5fGlKxRvVB+A+dXrsapFex5duERyQgLaxEQAFLWK+IhIHpw8w7Mbt0hOSAAgTzlPNMbGVO7UgW+2/kqpZk2ICQn911zJEZHcmTKdO1Om82jNWpIiIjDP645t+XKY58tL5fW/UGLkMJJjYrAsUgRjW1sC1q7jyZZtPNt3ANcmn6TtK983HcjlWZrE5y/e6lwlRUbiN3UG96bO4Mkvv5IUEYFt1cpYFitK4PqNBK7bQORVbxw+rpPyBLWK+CdPCPv9LPFPAtGlnpPnv53k9tARBO3YxbNtO1DUakxz585wHlO3PJRZ+zMvTvzRiFNUagBi790n/Ox5EkOeo0tITFtf8IdBKGp1uv04t2xOgSEDCT14OMMZ/szELQ+lfvmJsBO/pS0zdnIiV+VKBC5fScj2nXi3/pw7vVNHOqnVJIaEEvH7OeIfPESXmHJ+or2vE/7bKeIfPca+fn0eTJhM/IMHGc6TFBHJzSnTuTllOg9XryUxIoI8TZugNjHh3vKVPFzzK8/PXSB3k08BCDlxkpATJzF1dMQifz4u9uiNLiGBu/MWcqhyTQL37CM+OBh9cjJ6rfatztVfVS/kxu1xXRn6STWKOqc0OCPjE7j17Dkdq3rydTVP/t/efYdHUXVxHP9uegNCSAhIB6WHFqr03gVBEOmCFFFBQUGKNEWqWABFQDrSBUEQ6VV6773XhBBaerLvHyH7shJ6kiWZ3+d59sG9M3vn7JydNTm5945/toysOHw6QY8ryVtUlBZSNRLl21iUb2NRvkVEkp4KR8/h/s0ghufzZ+Xg/482SZ0pIwAhDwotIUG3SJ0xAwD3AgIxmUz0ObkfR1dXlveNHdnzd9/BOHm40/fMQeoMGcCSz/sSGRqKm1daruw/xJ/de7P621GU7dIB/5ZPn5p1+8BBTowcjTkykmzt2uDk5UXghk1EBAdzaf5CdrZuh0vGDBT+fhRhV69ijo7Gu3w5nNP7kMavIDStAEAAAHUPSURBVE5eXti5uOCeMwf5B/Zn/6c9iLp//6XO1d0DBzkzKjamLO/HxhS0+V8AIm/div03+BbOGWLP1dEevUhfuxYVD+4hXaUKHO8fe66uzlvAtUWLMTk5kf3jD4m8dYs7+w88dzyRt26xrUx5zo78ztIWff8+J/sPIkuH9pTdtxOXrJk5M3wUAGlKlSRzh/Yc+bibVT/BW/5lq3/ply4cRQbdYmeZCpwfNdrS5pw1MwDpatXkzdPHKLRgrmV01em+/fEoUIDS+3aSsXVLTvXqa9Vftu7dCL96lWszf3+heIIPHOTYiO8wR0aSs11bnL28OPHTWADSV6qIa+bMeLyeC9eHi3Z2duTr3ZML8xZw99hxAGLCwwm5cIFSUyaSo3VLDg8ZRsSDfCcUezs7Xk/vxZi1u/hg+jLqFXqd19PHFpDSubsC4OXuwtXb9xL0uCIiIiIiCcZkss1D5AWocPQcIu7f5+aZc1ZtpgcXn9kc/2siQ8P4tWYDbp27QJv5MwEo3+1D7B0dmfJ2c3bNmMNb332LZ5bMHPt7FaP9y7F75hzWDhvN/ZtB5KpY7pnjy9qyOX7Dv+XGmnVcmreALbXqc6hnH26sXM3lP/7Eq3RJIgJvcnz4KLK2bkH1w/uwd439RdtkZ6LoL2O4tvxvAjdsApMJk709JoeXWz89U8vm5B02hMC16wjatPnBuXr0ZOXq9Tl3Dh5i1zvNCDlzloJjf7Rss3NxoejMqXiWLMHR3v2Ivvf8BYHo+yGEnjtv1Wbn4kL2Tz8hcPUa9jVriTk8gjwjhmLv7k7+sT9y8edfCTlxEgCTvQMme3vCLl0m6s6d5z7+f8WEhBB23joeE7GfJXsPd468/wFRt2+Td8LPAGT9tCuRgYEcfLcFtzZtJveP32HnFps7x3Re+LzdgKvTpj/+g/iMsrdqTuER33J9zVqOjRzN2WkzKND3S2rs3EJMRIRV/xlr1cAjR3ZOT5z8SD9Hh43k+I9jKTigH2mLF3upmB7nrcJvMO39+qw4dIbVR2NHWen/hfI4dlqA0lCUb2NRvo1F+RYRSXoqHL2kO1evAeCWLu2Df724c/Ua9k5OFKhfh1QZfTm5ZgMHFi3htUIFcEvnRZ7qVbiwYxeHly5n66+/4ZIqFVlL+pOrYjmq9Pr/wsZ29vZERz7bAr+Z32tKoe9HErBuAztbt8PJx5vXu32MR57cAJgc7DFHR2OOieHUj2NZV7o8qwsX5+bmfwm/EYBTunSkLe5P5qbvUPfKOdyyZCZz03co/MOoFz43rzVrSv7vRnBz/Qb2tWlP+PXrADimTWv5N/zaNZy805G6kB83/lpG0IaNXP9zCakLFsAxnRcmBweKTJ9CugrlOdKjJ9cWLnrheP7LPV9enDNm5Pr8hQStXcfNdevxKl+OVIUL4ZotK9m7d6PSxTMAZO/ejezduz2lx5cTfvUqAIHL/iZ442YC/1qOs68vDl5pSVupIrfWb+DW+g1cnzsf5wwZcMsdm9u0VSpj5+RE4PIVL3X8rO+9S9HvR3Fj3Xq2topde2r/l/1YVaYCK/z8uXf6NCGXLln2z1i7JvcvXOT2wUOWtrRFi5C+SiVu7d3H6V8nYufoiHfpUi8V13+dDQxmzs7D5Pb1okWpguTwTsOOs1cAuHk/NPbfe6FkTOORoMeV5E2/aBiL8m0syrexKN8iIknv5YaTCEFnzxN46gwl2jQnOiKSzEULs2LAEGKiomg07jtuXbjI+pE/4d/iXW4cO0HIzSCuHDxMgXq1KNbiXfLVqUFMdDRXDx4me5lS1BkyAJOdHY5urrh6pmH/wsVPjcEjT24KfTeC8BsBnJ34G16lShAeEMjrn3XFp3JFzk+dQaa3G3J16XIwm6my81/Cb9zg7ITfyPhWXS4vXET49RtsqlnX0meJaZNjp8CN+v6Fzot7ntzkHzWciIAALkyajGfJEkQEBhJy9iyZmr2LOTKS1IX8ODVsJBGBNwm7do2MTd7h/slTZHi7IWGXrxB5M4jX+/TCu3JFrv6xmNALF/GqUJ67hw8T+ZJrMAGEnjlLdEgomdq2JiYyknTVqnL30CHuHjjIrtr1LfsV/3spV2b+zpWZs1/6mE8SfvkKd/ftJ0PzZoRduIh33dqEXbhAVNAt7h89ilfN6nhv3ETGls2JuneP0DOxo2zSlCxBxI0bhF+89JQjPF6qvHkoOjr2M3R6wmTSPfgMVVq5jICNm7my7G+8y77J4W+GWl6TrmQJgnZZL0D92lv1eL1je/b26IVXCX/MMTHc3L7jheOKz7FrN2n52xIOXQ4kYxp3TgXcou2bhTl5I4hpWw/iZG/P3ovXGVS/QoIeV0REREQkwdhpDIckH/q0JoDpzdri6OJKg++Hsm/eIjaP+RVzTAzT3mmJg6MTzaf/yv3Am0x9pyUAf37ai5NrN9J43HdkL12S+Z26EXDiFLum/86GH8ZR4dOPKNPhff7q9RUnH1qI+3GytW2FvbMzLhl8KTVnJmX+mEfe3j3Z3a4Tzr6+FBn7A8F79nKodz8ADnTvibOPDwWHD+Hqsr85OmgIMRERBO/aY3nEREQQcfMmIf+Z3vWsMrdphZ2zM86+vhT7fQbFF87l9V5fsL99J+xcXcgzZDDXFi/hwsTfANjXuh3RoaH4/TIOc0wM+9t3BJOJLO3aApCxUUOKL5xL8YVz8SxZ8oVi+q+o27c51L4jjl5e5B/zI2Hnz3Ps08+JvnePO7v3WB4QOxoobkRQYjrSviMRN26Qd9yPYDJxpH0nAI591I3QU2fI89P3OGXIwLFOXYh+MGXOKWMGwi5dfqnj5mjz/8/Qm3NnUn7RfPL37sm+Hr1IW6QwBb7qw6lfJnDqlwmW17hmzEjIf4pVx0Z8x+Wlyyg87BsyVKvK3s8+J2hnwt7drHbBXHzTsCJT/t3PoL828VElf7pXL8mcDm8TFhnFZ/NW09Q/H59UKZ6gxxURERERETEikzm+BWcEgM8dPG0dgpWKaVxtHcIjnF+x4cIOr9giN69aPIGRUbYOwUqDoe1sHYKVoEa9bR2CJBIHBzvdicdAlG9jUb6NRfk2Fh+fVLYOIdFEr/jNJse1r9XeJseV5E0jjkREJMWLidHfSIxE+TYW5dtYlG8RkaSnwpGIiKR4+kXDWJRvY1G+jUX5FhFJelocW0RERERERCQpmTSGQ5IPfVpFRCTFc3DQ/+6MRPk2FuXbWJRvEZGkpxFHIiIiIiIiIknpFbuJjsiTqGQvIiIiIiIiIglu9erV9O6tOxcndxpxJCIiIiIiIpKU7FL+GI7hw4ezbt06ihQpYutQ5CWl/E+riIgYnlk34TEU5dtYlG9jUb5Fko9ChQoxcOBAW4chCUCFIxERSfGio2NsHYIkIeXbWJRvY1G+RZKP2rVrY9JaTimCpqo9QUF3R1uHYCWvj7utQ3hEWk9nW4dgxTV9aluHYMXkZG/rEKxEBYfYOgQrQY0031lEREREDEgFFUlGNOJIRAzJ3l5ff0aifBuL8m0syrexKN8iIklP37wiYkj6I4+xKN/Gonwbi/JtLMq3pBgmO9s8XlBERAT16tVj+/btlrbw8HD69OlD8eLFKVeuHJMnT06IMyOvIE1VExEREREREZF4hYeH06NHD06ePGnVPmLECA4dOsS0adO4cuUKvXr14rXXXqNWrVqWfUqVKkWpUqWSOmRJYCociYiIiIiIiCSlZDJ87tSpU/To0QPzf25pGBISwvz585k4cSIFChSgQIECnDx5klmzZlkVjiRl0FQ1EREREREREXnEjh07KFWqFHPnzrVqP3bsGFFRURQtWtTS5u/vz/79+4mJ0d0PUxqNOBIRQ9LtfI1F+TYW5dtYlG9jUb5Fklbz5s3jbQ8ICCBt2rQ4OTlZ2ry9vQkPDyc4OBgvL6+kClGSgApHImJI/xltKymc8m0syrexKN/GonxLivESC1W/CkJDQ62KRoDleUREhC1CkkSUvD+tr4DyE3+h7e0AADJVq0rD7ZtpceksVWZNw/lBldXLryB11/5Dy6vnabh9Mxkrlrfq4/XmzWh7OwAvv4IJEpPXx11549gpq0emaTNxq1iJbMtWkGvPATLPnI1jjhwAOL3+htW+ufYfTpA44uMxaDje22L7d3yzAp5zlpBu3U7SjJ+OfdbssTs5OOL+6Zd4Ld9I2sWrcSpfOcHjcHynNa5Tl+I2exXOPQaBswv2xUrjOvZ33OasxrnPMEiVBgDTa1lw+fZn3OatxfXnOdgXL5vg8Ti83RLXiYtxnbYCp24DwNkFU443cBk5Jbbt477w4IvY5JMB56/H4TpjJc5fDgeP1Akej9N77+Mx9x9S/bkB1z5DwMUFh0o18JixFI+Fa3D+6AtwiK072+V8A/ex00n150Zch/yIycs7weNJDHZ2yWNeuSQM5dtYlG9jUb6NRfkWeTU4Ozs/UiCKe+7i4mKLkCQRqXD0ErK/3YBcTd8BwN7VlUpTJ3Hn1Gm29+xNpupVKdyzBwClRgzF2SstWz75jPuXr1Dul7EA2Dk6kq9TB8r8MCpB47qzeBGX3m/NpfdbE/j9d7FtCxeQ8fufiLx4gWu9PschU2bSDx4CgEuhwpgjI7ncoR2X3m/NlY7tEzSeOE5Va+JSsx4AJjc3Ug/5jphLF7k7qDd2GV/D48uBALi1/xDn+o24P2400WdO4jFwGDg6JlgcdoX8cWr9IVFrlxMxZQz25ari+N4HOPf8hpgrF4iYMBp7/zI4vfs+AM6f9MaUzofw7wZiDryB8xeDwcU14eIpWAynFp2JWvc3ETPGYf9mFRwbNMe5a3/MEeFETP0J+7LVcKgd+1lz6vg5Jk8vIn4diV2egjg265BgsQDYFymBS/tPiFy5lLBff8ChYg1cuvbGtedgog7tI3zSGJzqvYNT0zYAuPYfAfb2hI4ahH22XLj2Gpyg8SQW/eBpLMq3sSjfxqJ8G4vyLSmGnck2jwTi6+vLrVu3iIqKsrQFBATg4uJC6tQJ/4dtsS0Vjl6QawZfSo8ewa0jRwGIDg1lUYkybP6oKzcPHMQcHU1MZGzF1WRvR9iNAK7/u5U7Z84SHREOQI53GlG0Ty8urliZoLFFXbpI6NZ/Cd25g1T13uLuX0sI2byRoPE/EzB8GPdXrST84AEcX8sEgEuhQpjNZjL+MAbfb4djcnZO0HgA7Lx98OjZn6jTD27h6OxCyJRfuT9mFBHrVxN19BB2GWPjcapSg8h/NxC+bDF3B/UmuE0TeOgL6aXdu0vE7xOJ/H0iUSuXwP17mDzTEtrlPcJ/HELMmRMQE4P5wTGjtqwj4tfviN6+kagdmzC5umFK45lg4Zjv3yNi7m9EzvuN6NVLIeQedvmLYJclB9Hr/yZ63XJizhzDvmhpsLfHrqA/0VvXE715FdH7dmBfNGFvb2m+d5ewaeMJnzaeyOWLMN+/i2P5apicnIj8cy6Rfy8m+vA+HMtVwZTaE/vM2Yhcv5KoTWuI+GcJ9kVLgpt7gsYkIiIiIiKvjnz58uHg4MC+ffssbbt378bPzw87O5UZUhpl9AWV+3kM1zZt4fyfSy1tIVevkTpnThpsWU9oQAAHR/8EwPZeffDyK0jTowfI835rtvXoBcC1zVtYUKgYlxK4cBQn9VsNcMqencDvRxMdFMStCeOJPHsG5wIFcKtQkZB/twBgjjET+u8Wrnb7hMiLF8gwcjR2Hh4JGotHvyFE7t5BxLrY92q+FUTo9ElEnz+LfZ78OJUuT+TOfwGwz5gJO9+MpF2yhrTzluNUulyCTmiPOXOCyDmTISoKh9qNMKVOQ/S+HZiDArB7LQuuP83AHBxE5MLpAET9NZ/oPdvAPRWOdRoTc/kC5utXEywe89kTRM2fEhtPzbcxpUpD9KE9sdvu3o7d6d4dTGm9MaX2xOToiPnendjt9+4k+NSwmFPHiJgxAaKicHyrCXapPQmfOxUAe/9SmNJnxC5zdkw+6THfu4M55D72hYphSuOJQz4/THZ22HmnT9CYRERERETk1eHq6krDhg0ZOHAgBw4cYPXq1UyePJnWrVvbOjRJBCocvYC8HdqTrrAfO77si+nBOi/2D0bp3LtwkZWNmmLCRLnxsVPSCvX4jLCAQFY2asrVDZsoN+4nHNzcuH/xEhG37yRanJ6t2nB/4waiLl+ytDkXLEim36YRHRTEzR9ip7EFDB7Alc4dCNm8keApk7FPkwbnfPkTLA6Xd5rjkCcf978fBvYP1mN/sF6PQ94CpPlpEjHBt7g/PrbQhsmEfeYs3Bs2iIhNa3Hv3hv77LkSLJ44DtXr49SpB1F7thG9/h8AYm5cJWzAp4AJ50/7/3/nVKlxGTIWk29GwscNS/BYAOyr1sOx/WdE791OzMHdsY3/LZiZTPG3JwLH2g1x+bgXUTv/JWLmRCKW/YHL+x/hMXURREbExhATQ9jYETgUK02qhWsxPRg1ppUrRURERESewGRnm0cC6t27NwUKFKBNmzYMGjSITz75hBo1aiToMeTVoLuqvYDsDerj4u1N06MHLG2tblxibcu2BOzcxZU167i8bj0532kMQKaqlTk9dz5X1qzD2dOTipMnkCZvbm7u2ZdoMTpkzIhzvvzcmj7V0uaUNx+ZfptGzN07XGrbmuibNwFI07IVkRcvErJhPTjYA2COikywWJyrVMcurRdeS9da2rw37uVWq8ak/mki5nt3uf1xe8xBsfHE3LhG1JlTRP67EfPtYFzqvY19jlxEnzudYDE5VKmD00dfEr1vB+HffgnuHtgX8ifm+GGi924net92HCo8+NJzc8fl6zHYZcpG+LdfEnNob4LFEce+Um2cOvUkZv9Owkf2xuT5YBTRgwW68UiD+VYg5jvBmKOjMKWKnTdsSpUGc1BggsfjWKM+Lp/1I3r3NkIGxK7VFTZ2BBELZ2G+E4zrl99gco8dlRa5ehlRB/cAJhwrVceubRdiAq4leEwJLSZGxS0jUb6NRfk2FuXbWJRvEds5fvy41XNXV1eGDx/O8OHDbRSRJBUVjl7A1h49cUqVCoA32rQkd+uWLK9RlxqL53Nl/UZOz51P1tq1uLFtOwC3Dh8hS+1aXFm/kdxtWxF59x53T59J1BhdivkDEPZgzqnJ0YmMP43DzsODwBHDcMySBceMGQnduQOPmrVxzJKVwKFD8Gz7PpGXLxF28GCCxXJvxDeY3GPXvHFp0BiXt94h+MM2pB76PSZ3D+6PGYV9pszY+WYgau8uwtevxqVhU5xrv4Vj8VKYoyKJOnksweIxZcmB00e9MAcHEfXXfOzyFYKoKJy7DyR6306i1q/AvmR5oh8UBp07f4F9ztxELpmLOSoKu8IliDl+CMJCEyaezDlw6vQF3A4i8u8F2OUphPnOLWKuXsKhcm2IisQuZ24i50yCqChijuzDvnRlYi6cxb5QcaL+XZcgccSxy5YTl0/7Yr51k4jFc7AvWBjzrVu4j5lK1N6dRG1Zh30hf8Inx46ocxv5a+zi4VPG4VS7IVE7tkBYWILGlBj0g6exKN/Gonwbi/JtLMq3pBimhFuoWiSxqXD0Am4fP2H570zVqgBwY/sO1rf5gBJDBlFu3E9c27yFf7t1B2Bjx48o+9Noyv38EyFXrrKhXcdEnaIG4ODrC0DUlcsAuFWqhFPWrAD4DhkKQPSdO5wpWYwbfb4k/ZCh+A4bQeT5c1z95KMEXYz64ZFCMWXKAWCXxhP7zLHxpOr7dey2u3cIql6GkAljsHP3wP3TLzGH3OPeN/2IuXQhweJxrNUQk6MTJi9vXPrHTteL2raB8OF9cWrXFeeufYk+tJeIccMgVRrsK1SPfd1b7+L41rsAhHZrTczZkwkSj0ONtzA5OkFab1z6jIyNZ8dGwkd/hXOX3ji9343of9cStXwBABG/DMfp4744dfqCmCN7iZwzMUHiiONYrzEmJydM6XxwGxI7fTByyzrCfvwW5w+6Yp+3ABF/zCLij98BCBs/Gtdeg3Ht/hVRe7YT9v2QBI1HREREREREbMdkNmsxkseZmsbH1iFYKZsxja1DeERaz4S/A9vLcE3/at360eRkb+sQrEQFh9g6BCvhszfY7NgODnZERcXY7PiStJRvY1G+jUX5Nhbl21h8fFLZOoREE73lD5sc175sI5scV5I3LY4tIiIiIiIiIiLxUuFIRERERERERETipTWORERERERERJKQSYtjSzKiEUciIiIiIiIiIhIvjTgSEUPSwprGonwbi/JtLMq3sSjfkmKYNIZDkg99WkVEREREREREJF4qHImIIdnb6+vPSJRvY1G+jUX5NhblW0Qk6WmqmogYktYjNBbl21iUb2NRvo1F+ZYUQ1PVJBlR4egJ3nBxsXUIVnJUz2frEB7l5mbrCKyY3N1tHYI1h1frEnMKDrZ1CFbCbR2AiIiIiIiIPNGr9VutiIiIiIiISEpnp+FzknxofJyIiIiIiIiIiMRLI45ExJCio3U7XyNRvo1F+TYW5dtYlG9JMbTGkSQj+rSKiCGZzbaOQJKS8m0syrexKN/GonyLiCQ9FY5ExJBMui2LoSjfxqJ8G4vybSzKt4hI0tNUNRExJHt7E1FR+rOlUSjfxqJ8G4vybSzKt6QYKoJKMqIRRyIiIiIiIiIiEi+NOHpJrrlyUmTdSs59M5SrE36ztPu2fI/XvxvBwbebcOffbbgXyE+u74bjlicP4RcvcqZvf25v2kLBP+aRpmwZqz4vjPiOi9/98PLBpc+E/ZdjiFkyFfP6JZA5J/YtukE6X8wHthEz92eIjMCUuxB273SCdL5w9QLRs8fA5bMvf/x4DN58iK//PWLVVjGLDx2L5KLvxoPcjYikWb6sjKhcGCd7+0SJ4b/enbuOhUfOWZ4PqeaPi4M9o7Yc5G54JJVzZGTK2+XxdHVOmnhmr2bhof+f/yE1SuDr4co36/YQcD+MCtkzMrFRBTKkckuSeHpvOMDUg2eJjDHz1uuvMb5mcZzsY2vOk/af4cOVu1n9bkUqZk2fJPGIiIiIiCR7WhxbkhF9Wl+CZ5VKFFg4Fztn64KCS7Zs5BjU36otx7df45A2Lad69CT8ylXe+Ol7AM4O/JpDTd7jUJP3CPxzKVHBwQT8sfilYzPl98f+kyGYHB0tbfate0BkBDELJ2Lyr4CpQj0A7Fp+ChHhxPz+E5jAvknnlz7+47QsmJ0VTSuyomlFvi5fEIDaOTPy/vIdvJnJmyEVCjFh3xm+23E80WL4rx2XA2hVOBd/t67BitY1KZ0lPT1W7KByjoyMqVuGzReu892/h5Iunos3aFX0Df5+vzYr3q9D6ay+dFy0iUo5XmPC2xXYfP4avf/ZkSSxrD1/nVE7jtM8fza+reDHnKMXmHH4HACnb93ji3X7kyQOERERERERsQ0Vjl6Qc+ZM5J85leANm6w32NnxxtjvCbt02arZZG9HZEAAd7ZuI+zsOWIiIgC4f+AgtzduJvzCJdJWr8a5b4YSdvbcywWX1ge7Tl9hPr7Pqs2UMSsx29dg3r4GLpzClN/fErP5VgDmU4cw3wrEHBX5csd/gpyeHlTN7kuFLD7MPnKBZvmykt3TnYjoGLoUe532hXPyZqZ0LDpx+emdJYBrd0O4ePs+f524SINZq/lt93HSujgB4OfrRblsvqR2dsI5iUY/WeI5doEG0//ht13HSOvqxICqxRhSswTvFsrF616pOXfrbpLEEx0Tu4ZAyYxelM3sjZO9Hc729kTHmHl/+Q6ypUmaUU+JwazbshiK8m0syrexKN/GonyLiCQ9TVV7QZFBt9hTpiLmmGh8mzWxtGfu+hFOGXw503cA+WdMsbSf7TuAgosXUGLfTsxRURxp0daqvyzduxJx9SrXZ85++eDu3yX6684QE4NdqaqxbZ7pHmy7A4A55B4mn4wAxMwZh12HvjgUeRNzeCjR3/d8+RieYtaR85y4dZfFjcsREBoOwJpz18ng7sKJoLtEJ9EPBVfuhuDnm5b3i76Bh5MjnZZuIZ+PJz3KFqT3ql30XrWLPN5p+OzNAkkTz50Q/Hy9eL94HjycHOi0eBP5fDzpXzW2yLfs2AX2Xr3JoGr+SRJP9RwZaJInMy3/2g5AuczeNM+fleHbjnH1fijfVynK24u2JEksCS06Wj94GonybSzKt7Eo38aifEuKocWxJRnRiKMXFBMSQtj581Zt7n4FydK9G6e/6IM5PHZEkZ2jE5hMZP70EyIDAzn8bkuCN23hjR+/w87NFQCHdF54v92Aa9NmQEIUTCLCIPDafxoffDHF071dnRZw6QzRY7+CG1ewb/nZy8fwFGN2n6R2zozk8PSgZMZ0tC+UkwGbD5F/0t84O9gn2a1Wi73mzd4uDelapgDt/HNTJIMXG85d49edx2hT5HUWNqvC1bsh9F29O2niyeTN3q6N6fpmQdoVz0uRDOnYcPYqAMuPX6Dp7NUUzuBF93KFkiSe3ddu8ceJy3xRMg9T6pRk25Wb/LjrJN9sPcK46v44P1jrKCI6hhj9BVBERERERCTFUeEoAXnVrI6dszMF5s6kwLxZABSYN4vUZUrhWakiwes3ELx+Azfmzscpgy9uuXMDkLZKZeycnLi5fEXiBXcnKPZf91QAmNxTYb4dBB5pMGXJRcy+fzEf30fM3s2YMucEj9SJFsqFO/c5cCOYBm9ksrT9UK0o+9vV5GzneryR1oOsqZNmCtSeK4EMWreX8KhoAKJizGw8f417EVF8UDwPDfJlo1RmH9aeuZo08VwOZNCa3VbxONrbsfLkJZr8vpoC6dPyT7u6uDomzWDBdeevE20284n/G7QskI2cadxZd+E6EdEx1F2wiToLYqdq1lmwiU0XA5IkpoTi4KCvPyNRvo1F+TYW5dtYlG9JMUx2tnmIvABNVUtA12fN5ta69QB4+PmRa/gQTvfqy/0Dhwg5ehSvmtUJ3rgZ35bvEX3vHqFnYu+clbpkcSJu3CD84qXEC+7mdcwBV7ArVZWY6CjInAvzsplw7zbm2zexK1GZmOuXsPOvgPlWANy7k2ih/HvpJgClXoudPhcSGUWGMX9SJVt6GryRiQ0XA/imvF+iHf9ht8Mj+Xr9PoJCwnk9XWoOXr/F6Fol+fyfnXz/7yHO5cvG1os3eCtv1iSKJ4Kv1+4hKCSM19Ol4eD1IN4rUoIWc9fiYGeiV8XC7Lt6k1TOjpTKkvh3MfNL7wnAkK1HKZzek1PB9yib2YdNLaoAsPf6Lbqu3stP1YpS1DdtoscjIiIiIiIiSUuFowQUcfUaEVdjp4jF3Wkt5MQJou/d48RH3Xj9uxG88dNoIq5c5Xinj4i+E1ucccqYgfBLib8YdPTk4dg374pd4w6Y927CvGFpbPvEIdg3/RC7Np/D9UtETx6eqHFcuRcCQLYHo4rcHB0YV8OfPhsOsPNqEN2K56Zr8TcSNYY4lXNkZFj14vyw9TD3I6P4tEwBPimdH09XJwav28c/py5TMXsGRtQokTTx5HyNYbVK8sPmg7HxlPXDwc6OWw/WgXp39hoACmfwYvcnjRM9npo5MvBtBT/G7D7J7CPnaZo3K6OrFMHDKfarI25kVP50qUnt7PikrkREREREJI6d1jiS5MNk1q0JHmuLbxZbh2ClVNMitg7hUW6v1l21TO7utg7BmsOrVZs1BwfbOgQrt774zWbHdnCwIyoqxmbHl6SlfBuL8m0syrexKN/G4uOTytYhJJqY/Wtscly7wlVtclxJ3jTJUURERERERERE4vVqDYcQEUki+mulsSjfxqJ8G4vybSzKt6QYWqhakhF9WkVEREREREREJF4acSQihmRnZyImRku8GYXybSzKt7Eo38aifEuKYdLi2JJ8aMSRiBiSne5kYSjKt7Eo38aifBuL8i0ikvQ04khEREREREQkKWmNI0lG9GkVEREREREREZF4qXAkIiIiIiIiIiLx0lQ1ETGk6GgtrGkkyrexKN/Gonwbi/ItKYYWx5ZkRIWjJyhSJoutQ7BiKuhn6xAelS2XrSOwFhZq6wismF7LbusQrIXdt3UErwyzWT94GonybSzKt7Eo38aifIuIJD0VjkTEkEwm0M+exqF8G4vybSzKt7Eo35JiaHFsSUZemU9rREQE9erVY/v27Za2ixcv0rZtW4oUKUKdOnXYvHmz1Wv+/fdf6tWrR+HChWndujUXL1602j516lTKly9P0aJF6dOnD6Ghr9ZoFBGxHXv7V+brT5KA8m0syrexKN/GonyLiCS9V+KbNzw8nO7du3Py5ElLm9ls5qOPPsLb25uFCxfSoEEDPv74Y65cuQLAlStX+Oijj2jUqBELFizAy8uLLl26WIav/vPPP4wdO5bBgwczbdo09u/fz8iRI23y/kREREREREREkiObF45OnTpF06ZNuXDhglX7tm3buHjxIoMHDyZXrlx06tSJIkWKsHDhQgDmz59PwYIFadeuHW+88QZDhw7l8uXL7NixA4Dp06fTpk0bKleuTKFChRg0aBALFy7UqCMRERERERGxLTs72zxEXoDNPzk7duygVKlSzJ0716p9//795M+fHzc3N0ubv78/+/bts2wvXry4ZZurqysFChRg3759REdHc/DgQavtRYoUITIykmPHjiXuGxIRERERERERSSFsvjh28+bN420PCAggffr0Vm3p0qXj2rVrT91+584dwsPDrbY7ODjg6elpeb2IGJsW1jQW5dtYlG9jUb6NRfmWlMJkMtk6BJFnZvMRR48TGhqKk5OTVZuTkxMRERFP3R4WFmZ5/rjXi4ixRUfH2DoESULKt7Eo38aifBuL8i0ikvRsPuLocZydnQkODrZqi4iIwMXFxbL9v0WgiIgIUqdOjbOzs+X5f7e7uromeKyOjVvhULcJJmcXonf/S/i4YdgXLIZT248x+fgSc+Y44WOHYb5yAbvsr+PU5UvsMmcj+sh+IsYNxXzrZoLH9LBhK/5l7NpdhEREUccvF7+2rM2yg6fos2g9d8MieK9kfkY0roqTg32ixvGw45euUfTDgQxt15hub1dn2Y4D9Jo0jws3gij6ejYmfNqGPJkzJFk8AMcvX6fop8MY2votutWvzM/LN9J14nzL9hpF87G8f5cki2fQxN8ZPGm2VVulYn6s+eXbJIvhYWazmT4TZjNl2TrcXZ3p3fJtPqhf9aX6dHCIrV1HRcX+EGhnZ8LOzvqvL9HRZsxmMybTo3dSMZv//wOkvb0d//3DzZP6jYkxExNjtorjWfuNjo7BbH7+fh+O6Un9mkwm7O2tN5rNZqKjn97vy5zD5+037r2+SG5scQ6fvV/TI38FfBXPYWJ/vhPvHNrm863vCH1HPNyvviP0HfEs71XfEXH92vbznWKZXtkxHCKPeGULR76+vpw6dcqqLTAw0DL9zNfXl8DAwEe258uXD09PT5ydnQkMDCRXrlwAREVFERwcjI+PT4LGaefnj1OrD4lYMB3z9Ss4df4Cp1s3cajZkOiDe4ia9StOH3yKc5dehPX7COcvvsEcFkr4mG9xev9jnLt9RdjATxM0poetPXaOfos30LNmGXJ6e9Ll9xU42tsxd9dRmvjnpcIbWfl49j+kT+VOnzplEy2Oh/298yCdfpxGRFQUAHdDwnjv2/FUKpyXr9u8zWfj59D5x+msG9kzSeIB+Hv3YTr9PNsSE8COk+conD0Tw9o0xGQC79QeSRYPQKs6VShbOD8AO4+coN8vM+j8Tp0kjeFhc1ZvYeTvSxjWuQXXgoLpPGoi+bJnpqxfnhfuM+6HiTgP/7D0X2bzo/s/7Ek/XMTXr4ODnaUtIft92Iv2azabiYp6sX5f5hwmVr+vwjl8ON9P79cM6By+zOfwyecw8T/fDg52j/Rji3P4KuYmJX5HxJfvp/WbeJ/v5HkOX6RfW31HPKnv5HYOX8XcvIrfESJie69smbNw4cIcPnzYMu0MYPfu3RQuXNiyfffu3ZZtoaGhHDlyhMKFC2NnZ4efn5/V9n379uHg4EDevHkTNtD7d4mYPYnIOZOIWrUE7t/DlDk7kfOnEjF1LNHbNhBz8iim9BkhVRrsMmUlevMaoreuI2rNMuwKFQdXt6cf5wV5urnQv145BtYvzwfli+Dp5szCPceJiIqmSyV/2pcrwpu5MrN434lEi+Fh56/fpMHAn6hWNL+lLTQigj7v1WPEB014u6w/xXNn5/yNwCf0ksAx3Qiiwbe/Uq2wdQFk58nznL1xk/rf/EK/mUvxcHFOspgAcmbKQLWSRahYrCC/r1hPsxoVaFK1XJLG8LCth0/g4uTI5+/VZ8SHLbC3t2PRxh02i0dEREREREQS3ytbOCpZsiQZM2akd+/enDx5kgkTJnDgwAHeeecdABo3bsyePXuYMGECJ0+epHfv3mTOnJlSpUoBsYtu//bbb6xevZoDBw4wcOBAmjZtmuBT1WLOnCBy7mSIisKhdiNMqdMQtXElkQtnYL58HrtcebAvVobo/Tvg/l3MofexK1AEUntil7sAJjs7TOkSdhTUw4plzUD/euVxcrDnl/W7Cbofxhc1SwOw+ug5zt+8zYnrQVy6dSfRYnhYutTuHJ04hP4t37K0pfdMzZfv1iFvlozsPnmOFbsOWRWWEj2mVO4cHfsV/Zv9fzRPZFQ0nu5utKhQggW9OnD5ZjCdfp79hF4Sz8y/13PiwhW++bCVTY4fJ0t6b8IiIlm/9zDr9x0hOjqGywGJO81SRERERCRFMpls8xB5Aa/sVDV7e3t+/vln+vbtS6NGjciWLRvjxo3jtddeAyBz5syMGTOGb7/9lnHjxlG0aFHGjRtnmS9dt25dLl++TP/+/YmIiKBGjRp88cUXiRavQ7X6OHXoTtSebURv+AcAu1x5cRn4A+Y7t4iY+SvExBAx8XucPuyF+/TlxFw+H/viJLg7xG+b99F17kpq5M9BvzpluXzrLgOWbGTI8i28lsaD0MikuUWFh6sLHq4unLv+6IiiXSfOUbvvaHzSpOLrNm8nSTyxMTnj4erDuRv/L4I4OtizZXgPy/N1B/0Zt3wDUdHRONgn3VpQAGPmLqH2m8XJ8VrSrvn0X50aVGPB+m1U+/RrXvNOi4eri+4GISIiIiIiksK9UoWj48ePWz3Pli0bM2fOfOz+FStWpGLFio/d3rFjRzp27Jhg8T2OQ5U6OHXpRfS+HYQP+xIAuxxv4DLoB8z37xHWvyvcvgVA1PoVRB/eByYTDmWr4Ni8I+bA64ka37R/D9B51t9Uz5eDhZ0bYzKZ+OHd6nStUgJvD1faTF1KcEjY0ztKRPtOX6BW39F4uruxcmgPfNOmsWk814PvMHXNNuqX9CN/loxEx8Rgb2eHXRIXSi5cu8H+k2fp2uytp++cyFK7u/H3qD5cvXmLLOnTkbnRh2T19bZ1WCIiIiIiyY8Wx5Zk5JUqHCVHpiw5cPqwJ+bgIKKWLcAubyG4E4xzr2/B1Z3IqWMx+b6GyTs9MYf34TJ4DCYvbyJm/YpD9beI3rMVwhOvaHP4SgAf/r4C31TufFS5OFtOXyJ9KnfKDp9GlbzZaVgkNxtOXOCbBo8vwCW28IhImn7zC3dCQhnxQRPOXAvgYkAQFQu9+KLLL8vVyZFhC1exat8xOtYsy9xNu2lUpgh2dkn7Bb9l/1EAShe03bmIs27PYap/9jW9WjQgxmwmNDyCdyqVtnVYL0yLMBqL8m0syrexKN/GonyLiCQ9FY5ekmPNhpgcnTB5eePy1SgAzCH3Mbm5A+D8cZ/Ytvt3CWlRk4gpP+Hc7SucP+pN9P4dhP88IlHjm7hpLxFR0Vy7c58G42JvLf9W4Tf4uUUtev+xjp3nrtCtagm6VS2RqHE8yfKdBzhzLQCAjj9MAyCNuys3F4yxWUyp3VyZ/fn7fD75D9qNmUUVv9z80P6dJI/jyoM1hLJlSJ/kx/6vysUK8EnjWvy8aCXp06Zmet+PKJ43l63DEhERERERkURkMpvNSbO4TTJ0v+Gbtg7BikvtSrYO4VHZXrHCQViorSOwYnotu61DsGIOu2/rEKwE5avz9J0SiZ2d6Ym3wJWURfk2FuXbWJRvY1G+jcXHJ5WtQ0g05tN7bHJcU65iNjmuJG+aWCkihmRnp4W9jUT5Nhbl21iUb2NRvkVEkp6mqomIiIiIiIgkpSReO1XkZejTKiIiIiIiIiIi8dKIIxEREREREZGkZNK0S0k+NOJIRAxJC2sai/JtLMq3sSjfxqJ8i4gkPY04EhFD0g+exqJ8G4tR8x0dHc3t28G2DkMkwaRJ44m9vb1Vm1GvbxERW1LhSEQMyWQCs372NAzl21iMmu/bt4OJjg7F0zOtrUMReWnBwbe4fRu8vNJZtRv1+pYUyKTJP5J8qHAkIoZkb29HVFSMrcOQJKJ8G4uR8+3pmRYfHx9bh5GkVEhIue7eDXukzcjXt4iIrahw9AQu3bvZOgQrQfnq2DqEFM3BIeF/EPEOPpag/b2sm555bR2CiIiIiIhocWxJRjQ+TkRERERERERE4qXCkYiIiIiIiIiIxEtT1UQe0PoIxqJ8G4vybSzKd+Iym82YNMVCbETXt6Qc+h6V5EMjjkQeiI7WQotGonwbi/JtLMq3tfbt2+Hk5PDER7VqVZ7aT3BwMO+/35bNmzc99/HfeCPXY7efO3fukXjc3FzIkSMbXbp8SGBgoGXfDRvW4+TkwIYN6y1tCVFIcHJyYPDgQS/f0XP466+lODk9+jfcsLAw3NxcHjknadOmeWxfgwcPemJ+N27cAEBMTAyjR39H/vx5SZ3aA3//Yvz++++P9Ld79y6qVatC2rRpyJYtC/369SUiIiLh3vxL0PUtIpL0NOJIREREJAXr06cvHTt2tDz/9tsh7N27l/nzF1jaUqVK/dR+9u/fx6xZM2nbtm1ihEnv3n2oUyf2RiBhYWGcOHGCwYMHcfToEdat25Aox7SVDRvW07p1q3i3HT58iKioKKZOnU6uXDkt7fb29o/tr1279tSsWdOqLSIighYtmpMhQ0ZKlCgJwMCBA/juu1EMGDCQ4sWLs2LF37Rt2xo7OzuaNWsGwJkzZ6hVqyalS5fm999nc+zYMfr3/4pbt24xbtzPL/vWRSSORm5KMqLCkcgD9vZ2+iuWgSjfxqJ8G4vybS1XrlzkyvX/ET/e3j44OztTqlRpG0b1qFy5clnFVLFiJZycnOjQ4QMOHz5MgQIF4n2dyZR8pi/dvXuXESOGM2rUSNKkiX8E0f79+3FwcKBx48Y4Ozs/U7+ZM2cmc+bMVm1ffNGDe/fuMW/efFxdXQkJCWHMmJ/45JNP6NmzFwBVqlRlz549jBs3xlI4GjVqJKlSpWLhwkU4OTlRu3Yd3Nzc6NatK716fUnWrFlf4gy8PF3fIiJJT1PVRB5Q0d9YlG9jUb6NRfl+MatXr6Jy5Yp4e3uRIUN6WrVqycWLF4HYETLVq1cDoHr1apapbdHR0YwcOYIiRQqTOrUHnp6pqVChHOvXr0uQmDw90wI8cU2lXbt2Ua9eHTJkSE+6dGlp2LABhw8fttrn6tWrtGv3PpkyZcTLy5OqVSuzbdvWx/Y5aNBAXFycmD59OgABAQG0bt2KLFkykSqVO8WL+zNjxgyr1zg5OdC+fbsnvp8pUyYzefJv/PTTGLp0+Sjeffbv30+ePHmfuWgUn4MHDzJ27Fj69fuK7NmzA+Ds7MyGDZv49NPu/4nbibCwcMvzVatWUrt2HZycnCxtjRo1JiYmhlWrVr5wTAlF17ekGCaTbR4iL0CFo0RkNpvp/evvZHirA7ne/ZhJS9fYOiRJplr2+Aq73CVtHYaIiKRQM2fOpE6d2mTOnIUZM2YycuR3bN++jQoVynHjxg2KFi3GTz+NAeCnn8bw009jAejbtzdDhnxDhw4d+OuvZfzyy68EBd2iWbN3CQkJea4YYmJiiIqKIioqitDQUPbv38/Qod9SuXJl8ufPH+9r1q9fR4UK5TGbzUyc+Bvjx0/g0qVLVKxYnmPHjgFw7949KlWqwIYN6xk6dJhlBE6dOrU5efLkI32OHv0d3347hPHjf6V169YAtG3bmqNHjzJ27M8sXfoXRYoUoX37960KZJs2baZPn75PfI9169bj5MnTdOjQ8bH77N+/DwcHB+rUqYWnZ2p8fX3o0uVD7t69+9RzGKd3717kyJGDrl27Wdrs7e0pVKgQGTJkwGw2c/36dUaMGM6aNWvo3LkzAKGhoZw/f5433njDqj8fHx9Sp07NiRPHnzkGERFJOTRVLRHNWb2Fkb8vYVjnFlwLCqbzqInky56Zsn55bB2aJCPzlq/i96X/2DoMERFJoWJiYujT50tq1KjBjBkzLe1vvvkmhQv7MXr0dwwbNpx8+fIBkC9fPksh58qVq3z99Td89NHHlte5uLjw7rtNOHjwwHNNh+vYsQMdO3awavPy8mL16rWPfU3fvn144403WLLkL8saQNWrVydv3twMGjSQ2bPnMH36NM6dO8f27TspUqTIg/dWlhIlirNp00arIsmECb/Su/eX/PzzL7Rt+76lfePGjfTt248GDRoAUKFCRby901mNCnqW9/rwlMH4mM1mDh48iNlspl27dvTu3Yddu3bxzTdfc/ToEdasWYed3ZP/7nvgwAFWrlzJ+PG/4uAQ/4/6c+fOpXXrlgDUqVOH5s1bAHD79m0AUqd+dM2rVKlScefOsxevREQk5VDhKBFtPXwCFydHPn+vPjExMYxZ+DeLNu5Q4Uie2ZXrAXQZOJwCb+Tk8Mkztg5HRERSoOPHj3Pt2jW++eZbq/ZcuXJRunRpyx254jN9eux0rYCAAE6cOM6pU6f466+/AAgPD3/s6+LTr99X1K1bF4DIyEguXrzEmDE/UrFieVavXkPRosWs9r9//z67du3iq6++slo42tPTk7p167Fixd8AbNmyhRw5cliKRgBubm4cPnzEqr9ly5axb99eypUrR/v2H1htq1SpEoMHD2Lfvn3UrFmTWrVqM2zYiOd6f8/CbDbzxx+L8Pb2sazpVL58BXx9M9C2bWtWrvyHWrVqP7GPX375mfTp09OyZfyLbwOUKFGCNWvWcvDgQQYOHEC9enVYvXotMTFPXjvoaUUrEXkemjYmyYe+/RNRlvTehEVEsn7vYdbvO0J0dAyXA27aOix5jFdtoUWz2Uy73oOpXKo4jWs+/TbJ8nxetXxL4lK+jUX5fj63bgUBkCGD7yPbfH0zEBx8+7Gv3b17F2++WZpMmTJSt24dfv11vKW4YH7OFauzZ8+Ov39x/P2LU7p0GZo0acLy5Suwt7dn8ODBj+wfHByM2WzG1zdDPHH7EhwcDEBQ0E18fHyeevy9e/dQu3ZtNm3axF9/LbXaNnPm73Tr9im7d++iU6eO5MiRjXr16nD+/Pnneo9PY2dnR8WKlR5ZCDzubnMHDhx44uujo6P588/FNG78jtUaRf+VK1cuypevQJcuH/Hdd9+zadMmNm/eZBlpFN+0uDt37sQ7Eimp6foWEUl6Khwlok4NquGfJyfVPv2atkPG4eHq8sTFHcW2XrU7soybOZ89h4/zfd/PiIqOBiDsOf96K4/3quVbEpfybSzK9/NJm9YLgGvXrj+y7dq1q3h7p4v3dXfu3KFevbp4eHiwb98BgoKC+fffbbRt2zbBYvPw8CBPnjycOnXqkW2enp6YTCauXbsWT9zX8Pb2BiBNGk8CAwMf2Wfr1n85evSo5XmHDh1ZtOhPSpcuTdeun1gVT9KkScPQocM4efI0Bw8e5ptvhrBlyxa6dv34kX5fxpUrV/jtt0lcuHDBqj00NBTgqQWwHTu2ExgYyDvvvPPItoCAAGbMmMGNGzes2osWLfrg2Ffx8PAgU6ZMnD592mqfGzducPfuXct0RVvS9S0phhbHlmREhaNElNrdjb9H9WH/1JEcmv4dMWYzWX29bR2WPIad3av1Rbrwn7UE3goma4X6fPvLFADc/MrbOKqU41XLtyQu5dtYlO/nkydPHjJkyMC8eXOs2s+cOcO2bdt4882yAFbTwQCOHz/GzZs3+fjjruTPn98y0uiff2LX5XvatKdncfv2bU6cOMHrr7/+yDZ3d3f8/f1ZuHAB0Q/+wBL3muXLl1niLleuHGfOnLG601pYWBhNmzZh6tTJljZfX19MJhNjx/7MtWvX6Nu3DwDnz58nZ87sLFy4EIg9X59//gVVq1bj/HnrAs/LioqK4sMPOzNx4gSr9vnz52Fvb0/ZsuWe+Prt27fj4OBAiRKP3lAjNDSU9u3fZ8qUyVbtq1evAsDPzw+AatWqs3z5MquphosW/YG9vT2VKlV+ofeVkHR9i4gkPa1xlIjW7TlM9c++pleLBsSYzYSGR/BOpWdfJFKSlp2diZiYV+fPWOMG9uTOvfsATJr3J5MXLOHfeb/ZOKqU41XLtyQu5dtYlO/nY2dnxzffDOGDD9rTqlVLWrRoQWDgTb75ZjBeXl58+ulnQOzIHYC//16Op2dacufOQ+rUqRk27FscHOxxdHTkjz/+sBQm7t+//1xxnD59mu3bt1meX7t2ne++G8mdO3fo0aNHvK/55psh1K1bh7feqkfnzl2IiIhgxIjhhIeH07dvPwDatGnLuHFjadz4bfr3H4i3dzrGjh1DREQEnTt3eaTPQoUK0bVrN77/fjTvvfceZcq8SaZMmeje/VPu3r1Dzpw52b17NytW/E3Pnr0sr9u+fRve3j5PXQD7SbJmzUqbNm0ZPfo7XF1dKV26NFu2bGH48GF06fIRuXPnBmJHD505c5p8+fJbTR87dOgQOXLkxMXFJd6+27Z9nyFDvsHR0ZEiRYqwefNmRo4cwfvvt7MseN6jx+fMnTuH+vXr0q3bp5w8eZKvvurHBx90IGvWrC/83hKKrm8RkaSnEUeJqHKxAnzSuBY/L1rJHxu2M73vRxTP++I/TIix5H89J6WL+FG6iB+ZM6QHoHQRPxtHJSIiKVHr1m2YM2ceJ0+e5J13GtOz5+eULl2Gf//dRoYMsWsIFShQgHffbcbPP/9MmzatSZMmDQsX/oHZDO+914z332/LxYsXWLt2HalSpWLz5s3PFcPQod9Svnw5ypcvR8WKFejY8QPc3d1Ztmw55crFP+K2SpWq/PPPP4SGhtKyZXM+/LATmTJlYvPmfylYsCAQezewNWvWUbJkKT79tCvNm79HdHQ0q1atIUeOHPH227//ALJmzUqnTp2IiIhg/vyFVK9eg4EDB1CnTm0mTPiVfv2+ol+/ryyvKV++HN9+O+S53nN8xo4dR9++/Zg1axYNGrzF77/PYsCAgYwcOcqyz99/L6d8+XLs3bvH6rU3blwnbVrPJ/bdu3cfJk2axFtv1Wf27N8ZMGAgv/wy3rJP3rx5Wb78b0JCQmjW7F1+/PEHunbtxujR37/0exORh5hs9BB5ASbz865caCDRG+faOgQrQfnq2DqEFM3BwY6oqIRdcNE7+FiC9veyAj3z2jqEV0Zi5FteXcq3sRg130FBN0mVyuWZFoJOSUwmY6578/77bencuTOlSqXM0ewBAQHcvRuGl5f1GltGvb6Nyscnla1DSDTmK8dtclzTa7rDtzw/jTgSEREREUlGjhw5wo4dOyhYUCORRZIvDTmS5EOFI5EHNF/eWJRvY1G+jUX5lpQuffr0rFjxD+7u7rYOJcnp+hYRSXpaHFvkAf0gYizKt7Eo38aifBuLEaepeXsb9y69ur4lxTBp9I8kHxpxJCIiIiLykrRsqIiIpFQqHIk84OCgy8FIlG9jUb6NRfl+utatW+Hk5MD3349+qX4GDx6Ek1PCDmDfsGE9Tk4ObNiw/pn2fxX+aP/vv1to0KB+oh4jKiqKcuXeZPDgQY9sO3LkCA0bvkX69N5kyJCedu3e59q1a1b7TJ78G05ODo88unXr+sTjHjx4kPr16+Lr60PWrJlp1+59rl+//tj9x40byxtvPP4uwk/b/jS6vkVEkp6+eUVEREQM5Pbt2/z552IKFvRj0qRJLzVSpl279mzatDkBo0uefvvtN44ePZpo/YeFhdGqVUt27NjxyLYrV65Qo0Y1goKCmDp1GmPH/sy2bVupVasmkZGRlv32799P7tx52LRps9Xjs8+6P/a4169fp2bN6ly/foNJkyYzatRoNm3aSP369az6jjN37ly++OLzx/b3tO0ihmIy2eYh8gK0xpGIiIiIgcydOweA0aNHU6NGddatW0uVKlVfqK/MmTOTOXPmhAxP/mPz5k1069aNy5cvxbv9t98mcfv2bRYt+pN06WJvXe/j40316tVYt24tNWrUBGD//n0UL16cUqVKP/Oxly5dQmBgIJs2bSFXrthRQp6eaahXry5bt/5LhQoVAbhx4wYDBw5g0qSJeHl5PdLP07aLiMirTSOORERERAxk6tQpVK5chUqVKvP6668zceJEq+3VqlWhTZvWvPtuUzw9U1O7dk3OnTuHk5MDP/zwPQULFiBNmlRMmzbVaqrasGFDcXd35datW1b9/fTTj7i5uXDjxg0ANm3aSN26tUmf3ht3d1dy536dwYMHERMT81zvY/Lk3yhcuBDu7m7kypWDwYMHER0dDcDs2bNxcnLg0KFDVq/5888/cXJyYO/evQAEBQXRpcuHZM78GqlSuVOu3JusXbvG6jVOTg6MH/8LnTp1xNfXBy8vT957r5llulb79u2YMWM658+fx8nJgenTpwEwZ84c/P2LkTq1B6+9loE2bVpz5coVS79x5+7cuXNPfJ+NGr1NlixZ2L59Z7zbO3f+kPXrN1iKRrExOwEQFhYOxK6/dPDgQQoXLvzEY/1XWFgYAKlTp7a0xR3n5s0gS9vw4cNYtWolc+fOp27deo/087TtIsZkstFD5PmpcCQiIiJiEIcPH2bXrl20atUagJYtW7FkyZ+PrFkzf/48UqVKxR9/LKJHj/9PLfr668F88cUXTJkyjapVq1m95r33mhMVFcWiRX9Ytc+dO4caNWqQPn169u/fT82aNUiXzptZs35n0aLFlC1bjm+++Zr58+c/8/sYPnwYH37YmapVq7J48WI+/LALo0aN5MMPOwPQoEEDPDw8mDdv7iOx5M9fgKJFixIWFkaNGtVZunQJgwd/zbx588mUKTP16tVl3bq1Vq/76qt+REdHM3PmLIYNG86yZX/Ro0fsFK8+ffpSu3ZtMmTIwKZNm6lduw7//ruF999vw9tvv83SpX8xcuR3rFu3llatWlj6jJvmlzFjxie+1zVr1rF48Z9ky5Yt3u0+Pj74+xcHYgs927dvo2vXruTKlYvq1asDcPr0ae7evcuuXbsoUCA/bm4uFCiQnxkzZjzx2O+804SMGTPSrVtXrl69ytmzZ/nyy15kzJiRqlX/P0qtQ4eOHDlyjLfffjvefp62XUREXm2aqvYkEeG2jkCSUFTU8/2l81kEeuZN8D4lYSRGvuXVpXwbi/L9eNOmTSFdunTUrx+7kHOrVq0ZPHgQU6ZM5ssve1v2c3JyYty4n3F2dgawjIp5550mtGnTNt6+s2XLRvny5Zk7dw7t2rUHYgsWO3fuZObM34HYhZarVavG1KnTsLOL/ftltWrV+euvpWzcuIF33333qe/h9u3bfPvtEDp06Mjo0d8/6KMG6dKlo1OnjnTr9ikFChTg7bcbMX/+PAYP/hqAe/fusWzZX/Tr9xUAs2bN5MCB/WzevIWSJUsBUKtWbapVq0KfPn3YunWb5ZgFCxZk0qTfLM937tzJwoULAMiVKxfe3j44OztbpoFNmTIZNzc3vviip+Ucpkvnxa5duzCbzZhMpmee5ufn5/fUfeL4+xfj5MkTuLq6Mn/+AlxdXYHY9Y0Azp07y4gRI3B0dGTmzJm0b/8+ERHhtG//Qbz9ZciQgbFjf6Zly+YsWBBb2EubNi0rV662GoWUN++Tf9552vbnoetbUgytNyTJiEYciYiIiBhAZGQkv//+O2+91YCQkBCCg4NJlSoVZcuWZfLk36ymiuXNm89S8HjY06Y6tWjRko0bN1ru6DVv3lxSp05tKVS1bNmSJUv+IiIiggMHDvDHH38waNBAoqKiCA9/tj/Ybdu2ldDQUOrVq0dUVJTlETcFas2a1Q9iacHp06fZtSt2iteSJUsIDw/nvfeaA7B27VoyZMhAsWL+lj6io6OpW7ceu3fvsppy9991gTJlysT9+/cfG2OFChW4f/8+RYsWpm/fPmzevInq1WvQr99XmBLxl8WffvqJZcuWU7lyFRo2bMDKlf8AUL58eRYtWszKlaupW7ceNWrUZPr0GVStWpVBgwY+doH02bNn06RJY+rVq8+yZctZuHARBQoUoG7d2hw7dizR3oeIiLxaVDgSecDeXpeDkSjfxqJ8G4vyHb9ly5Zx48YNpkyZTPr03pbHpk2bOHfunKXIAODh4R5vHx4eHk88RqNGjXF0dLSMTpk7dy6NGjW2jHwJDQ2lU6eOeHt7UaKEP336fMn58+dxdHR85ru7xa2t89Zb9XFzc7E8Mmd+DcCyjlClSpXJlCmTZTHwefPmULFiRcson6Cgm1y7ds2qDzc3F778shcAV69etRzTzc3NKgY7O7snxlu6dBmWLFlKjhw5+PHHH6hSpTLZs2dl3Lixz/QeX1TVqtWoXr0GCxYsJEeOnIwaNRKA9OnTU7duPdzdrfNau3Ydrl279shUxThffz2YMmXKMGvW71SvXoP69euzbNnfuLq6MmBA/0R9L4+j61tEJOlpqprIAxotaizKt7Eo38aifMdv2rSp5MyZk19/nWDVbjabadLkHSZMmECtWrVf6hhp0qShXr36LFgwn0qVKnPkyGF+/PFHy/bu3T/jjz8W8vvvc6hataqlkJEp05PX+XmYp2eaB+9nBrlzv/HI9vTpfYHY4k6zZu8xd+4cvvyyD6tWreKXX8Y/FKsnr7/+xmPX+cmRI8czxxSfGjVqUqNGTUJCQli3bi1jx47hs88+pVSpUhQvXuKl+n7Y+vXrCA0NpXbtOpY2BwcHChYsyOHDh4HYO7OdOXOW1q1bW702NDQUe3v7x97p7MKF8zRo0MCqzdXVlWLF/Dly5EiCvYfnoetbUg59mCX5UMleREREJIW7du0a//yzgiZNmlKxYiWrR6VKlWnc+B3+/ns5ly9ffuljtWjRgm3btjFhwq9kzZrVcst2gC1btlCxYiXeeustS9Foz57dBAQEPPNd1UqVKo2TkxNXrlzG3784xYsXx9+/OPb2DvTr15dz584+FEtLLl26xDfffI2DgwNvv93Isq1ChQpcunQRH5/0+PsXtzxWrVrFqFGjcHB49r+v2tvbWz3v1esLypQpjdlsxs3Njbp16zFs2AgAzp+/8Mz9PotZs2bRrt373L1719J29+5dtm/fZlkfaf369XzwQTtOnDhh2ScmJoY//viDMmXKWO7C9l958uRl69Z/rUZXhYWFsW/fXnLmfLnCmoiIJB8qHImIiIikcDNnziAqKop3320W7/aWLVsSHR3Nb79Neulj1axZi3Tp0jFx4gSaNXvPak2fEiVKsGrVSiZM+JWNGzcwduwY6tevh8lkeuKaQQ9Lly4dPXp8zsCBAxgwoD9r165hxowZvPNOI06dOkWhQv9fh6lgwYIULlyE8eN/4a23GpAqVSrLtjZt2pI1azZq167F9OnTWb9+Hf369WXgwAG89tprODo6PvN79vRMw/Xr11mx4m+uXr1K5cpV2LNnN+3bt2P16lUsX76M7t0/xcvLi8qVKwNw6dIltm/f9sxrOz1O9+49CAsL4+23G7B8+TIWLVpErVo1uHv3Ll99FTudrEOHjmTIkIG3327IvHnzWLbsLxo2fIvDhw8xbNhwS19Hjhxh7969lucDBw5i69atvPdeM/75ZwVLliyhXr06XL58mT59+r5U3CKGZzLZ5iHyAlQ4EhEREUnhpk2bRv78BShYsGC828uWLUeOHDmYMmUy0dHRL3UsBwcHmjZ9l+joaJo3b2G1beTIUTRo0JABA/rTsGEDJk+eTO/efWjf/gO2b9/2zMceNGgwI0eOYvHixdSvX58+fb6kbNlyrFmzjjRp0ljt26JFiwexNLdqd3d3Z+3adZQtW5Y+fb6kfv16LF68mCFDvmXkyFHP9Z5bt25LtmzZady4ETNmTKdWrdpMmzaDw4cP07RpE1q1aom7uzurVq2xTAubPPk3ypcvZ7WW0ovIly8fa9eux8XFhfffb8sHH7TDxyc9GzZsIn/+/AD4+vqydu16/Pz86N79U5o3f4/79+/zzz8rLXeUA+ja9WOaNn3H8rx+/fosWbKUq1ev0KTJO3z4YSc8PDz4999tjywYLiIiKZfJ/KwrERpQ9Orptg7BSlDht20dQopmMoGuBuNQvo1F+TYWo+Y7KOgmqVK54OPjY+tQJJmKiIigZMkS7Nu339ahEBAQwN27YXh5pbNqN+r1bVQ+PqmevlMyZb5xzibHNaXPbpPjSvKmEUeJ5PjFq7jVac+Pf/z/DiWDpi/CoXobgu8921BsSVr6IcRYlG9jUb6NRfkWeTGjRo2kUqVKtg7jiXR9S4qhqWqSjOiuaong7x376TR6MhGRUQDcCw1j+Jy/GDb7LxtHJk9iMpme+VbAkvwp38aifBuL8i3yYurXf4t8+fLZOown0vUtIpL0NOIogZ2/HkiDr76nWrH/ryEwesHfTF2xiRrF419XQF4N9vaqwBuJ8m0syrexKN/Goj+gJxw/P7/nupucLej6lpTDZKOHyPNT4SiBpUvtwdEpw+nfuqGlrVnlMhyfNoKSeXPZLjARERERERERkef0av9JIRnycHXBw9WFc9cCLG25M2ewYUQiIiIiIiLyKjFpuKQkIxpxJCIiIiIiIiIi8dKII5EHYmK00KKRKN/Gonwbi5HzHRx8y9YhJDndnj1lCg6+hb296yPtRr6+RURsRYUjkQf0g4ixKN/Gonwbi1HznSaNJ7dvw927YbYOReSl2du7kiaN5yPtRr2+JQXSVDVJRkxm3c/ysaJXT7d1CFaCCr9t6xBERERERESShI9PKluHkHhuXrLNcdNlts1xJVnTGkciDzg46HIwEuXbWJRvY1G+jUX5NhblW1IOk40eIs9P37wiIiIiIiIiIhIvFY5ERERERERERCReWhxbREREREREJClpcWxJRjTiSERERERERERE4qURRyIPREXF2DoESULKt7Eo38aifBuL8m0syrekGBpxJMmIRhyJiIiIiIiIiEi8VDgSecDeXlV/I1G+jUX5Nhbl21iUb2NRviXlMNnoIfL8NFXtCe74N9ZwWAMxmUyA2dZhSBJRvo1F+TYW5dtYlG9jUb5FRJKeRhyJiIiIiIiIiEi8NOJIREREREREJClpcWxJRjTiSERERERERERE4qURR08QHa3500aifBuL8m0syrexKN/Gonwbi/ItKYYGHEkyohFHT2A2639MRqJ8G4vybSzKt7Eo38aifBuL8i0ikvRUOHoCTTs1FuXbWJRvY1G+jUX5Nhbl21iUbxGRpKfC0RPY2+v0GInybSzKt7Eo38aifBuL8m0syrekHCYbPUSen755RUREREREREQkXlocW0RERERERCQpad6lJCMacSQiIiIiIiIiIvHSiKMn0E0bjEX5Nhbl21iUb2NRvo1F+TYW5VtSDI04kmREI46eIDo6xtYhSBJSvo1F+TYW5dtYlG9jUb6NRfkWEUl6KhyJiIiIiIiIiEi8VDh6AgcHnR4jUb6NRfk2FuXbWJRvY1G+jUX5lpTDZKOHyPPTN6+IiIiIiIiIiMRLi2OLiIiIiIiIJCUtji3JiApHIiIiIiIiIpJgYmJi6Nu3L2fPnsXd3Z0RI0aQLl06W4clL0hT1URERERERESSkslkm0cSWbVqFS4uLsyZM4fGjRvz66+/JtmxJeGpcPQEUVG63aeRKN/Gonwbi/JtLMq3sSjfxqJ8iyQPe/bsoWzZsgCUL1+eHTt22DgieRkqHImIiIiIiIhIgrl37x4eHh4AuLu7c//+fRtHJC8jRReOwsPD6dOnD8WLF6dcuXJMnjz5uV5vZ6cFy4xE+TYW5dtYlG9jUb6NRfk2FuVbUg6TjR5Jw8PDw1Isun//PqlSpUqyY0vCS9GFoxEjRnDo0CGmTZvGgAEDGDt2LCtWrHjm1+t/TMaifBuL8m0syrexKN/Gonwbi/ItkjwUKVKELVu2ALBx40aKFi1q44jkZaTYwlFISAjz58+nb9++FChQgOrVq/PBBx8wa9YsW4cmIiIiIiIiRpbMFseOiIigXr16bN++3dL2pBk+NWrUIDQ0lGbNmjFnzhw6d+78UqdLbMvB1gEklmPHjhEVFWVV2fT392f8+PHExMRgZ5dia2YiIiIiIiIiCSI8PJwePXpw8uRJq/aHZ/hcuXKFXr168dprr1GrVi3s7e0ZOnSojSKWhJZiC0cBAQGkTZsWJycnS5u3tzfh4eEEBwfj5eVlw+hEREREREREXm2nTp2iR48emM1mq/a4GT4TJ06kQIECFChQgJMnTzJr1ixq1aplo2glsaTYwlFoaKhV0QiwPI+IiHimPtKmdU/wuERERERERMTg3NLYOoJnsmPHDkqVKsVnn31GkSJFLO2a4WMsKbZw5Ozs/EiBKO65i4uLLUISERERERERSTaaN28eb7tm+BhLii0D+vr6cuvWLaKioixtAQEBuLi4kDp1ahtGJiIiIiIiIpJ8JcQMH0k+UmzhKF++fDg4OLBv3z5L2+7du/Hz89OwOREREREREZEXpBk+xpJiKyiurq40bNiQgQMHcuDAAVavXs3kyZNp3bq1rUMTERERERERSbY0w8dYUmzhCKB3794UKFCANm3aMGjQID755BNq1Khh67BEREREREREki3N8DEWk/m/99UTEREREREREXlInjx5mD59OqVKlQKgf//+7Nmzh2+//ZYbN27Qq1cvhg4dqsEaKVCKvauaiIiIiIiIiCSO3r17M3DgQNq0aYOHh4dm+KRgGnEkIiIiIiIiIiLx0uRDERERERERERGJl6ELR+Hh4fTp04fixYtTrlw5Jk+e/Nh9jxw5QpMmTShcuDCNGzfm0KFDSRipJITnyfeHH35Injx5rB7r1q1LwmgloURERFCvXj22b9/+2H10faccz5JvXd/J3/Xr1+natSslS5akfPnyDB06lPDw8Hj31fWd/D1PvnV9J3/nz5+nffv2FC1alEqVKjFp0qTH7qvrO/l7nnzr+haxHUOvcTRixAgOHTrEtGnTuHLlCr169eK1116jVq1aVvuFhITQsWNH6tevz7Bhw5g9ezadOnVi1apVuLm52Sh6eV7Pmm+A06dPM3LkSMqUKWNpS5MmTVKGKwkgPDycHj16cPLkycfuo+s75XiWfIOu7+TObDbTtWtXUqdOzaxZs7h9+zZ9+vTBzs6OXr16We2r6zv5e558g67v5C4mJoaOHTvi5+fHokWLOH/+PN27d8fX15f69etb7avrO/l7nnyDrm8RWzLsiKOQkBDmz59P3759KVCgANWrV+eDDz5g1qxZj+y7fPlynJ2d6dmzJ7ly5aJv3764u7uzYsUKG0QuL+J58h0REcGlS5fw8/PDx8fH8nBycrJB5PKiTp06RdOmTblw4cIT99P1nTI8a751fSd/Z86cYd++fQwdOpQ33niD4sWL07VrV/76669H9tX1nfw9T751fSd/gYGB5MuXj4EDB5I9e3YqVqxImTJl2L179yP76vpO/p4n37q+RWzLsIWjY8eOERUVRdGiRS1t/v7+7N+/n5iYGKt99+/fj7+/PyaTCQCTyUSxYsXYt29fUoYsL+F58n3mzBlMJhNZsmRJ6jAlAe3YsYNSpUoxd+7cJ+6n6ztleNZ86/pO/nx8fJg0aRLe3t5W7ffu3XtkX13fyd/z5FvXd/KXPn16fvjhBzw8PDCbzezevZudO3dSsmTJR/bV9Z38PU++dX2L2JZhp6oFBASQNm1aqyq1t7c34eHhBAcH4+XlZbXv66+/bvX6dOnSPXU6hLw6niffZ86cwcPDg549e7Jjxw4yZMjAJ598QsWKFW0Ruryg5s2bP9N+ur5ThmfNt67v5C916tSUL1/e8jwmJoaZM2dSunTpR/bV9Z38PU++dX2nLFWqVOHKlStUrlyZmjVrPrJd13fK8rR86/oWsS3DjjgKDQ19ZGhj3POIiIhn2ve/+8mr63nyfebMGcLCwihXrhyTJk2iYsWKfPjhhxw8eDDJ4pWko+vbWHR9pzwjR47kyJEjfPbZZ49s0/Wd8jwp37q+U5affvqJ8ePHc/ToUYYOHfrIdl3fKcvT8q3rW8S2DDviyNnZ+ZH/scQ9d3FxeaZ9/7ufvLqeJ99dunShVatWlsX28ubNy+HDh5k3bx5+fn5JE7AkGV3fxqLrO2UZOXIk06ZN4/vvvyd37tyPbNf1nbI8Ld+6vlOWuJyFh4fz+eef07NnT6tCka7vlOVp+db1LWJbhh1x5Ovry61bt4iKirK0BQQE4OLiQurUqR/ZNzAw0KotMDCQ9OnTJ0ms8vKeJ992dnaP3KEhZ86cXL9+PUlilaSl69tYdH2nHF9//TVTpkxh5MiR8U5rAF3fKcmz5FvXd/IXGBjI6tWrrdpef/11IiMjH1nXStd38vc8+db1LWJbhi0c5cuXDwcHB6sF9Hbv3o2fnx92dtanpXDhwuzduxez2QzE3hp2z549FC5cOClDlpfwPPn+8ssv6d27t1XbsWPHyJkzZ1KEKklM17ex6PpOGcaOHcucOXMYPXo0devWfex+ur5ThmfNt67v5O/SpUt8/PHHVsWAQ4cO4eXlZbUeJej6TgmeJ9+6vkVsy7CFI1dXVxo2bMjAgQM5cOAAq1evZvLkybRu3RqIHY0SFhYGQK1atbhz5w5Dhgzh1KlTDBkyhNDQUGrXrm3LtyDP4XnyXaVKFZYuXcrixYs5f/48Y8eOZffu3bRs2dKWb0ESkK5vY9H1nbKcPn2an3/+mQ4dOuDv709AQIDlAbq+U5rnybeu7+TPz8+PAgUK0KdPH06dOsWGDRsYOXIknTt3BnR9pzTPk29d3yI2ZjawkJAQc8+ePc1FihQxlytXzjxlyhTLtty5c5sXLlxoeb5//35zw4YNzX5+fuZ33nnHfPjwYRtELC/jefI9b948c40aNcwFCxY0v/322+YdO3bYIGJJKLlz5zZv27bN6rmu75TrafnW9Z28/frrr+bcuXPH+zCbdX2nNM+bb13fyd+1a9fMH330kblYsWLmsmXLmn/55RdzTEyM2WzW9Z0SPU++dX2L2I7JbH4wvlNEREREREREROQhhp2qJiIiIiIiIiIiT6bCkYiIiIiIiIiIxEuFIxERERERERERiZcKRyIiIiIiIiIiEi8VjkREREREREREJF4qHImIiIiIiIiISLxUOBIREXkBMTExtg5BRERERCTRqXAkIvICWrVqRZ48eawe+fPnp3jx4rRo0YJdu3ZZ7f/ll1+SJ08e2rdvnyjxJHb/8fnv+8+TJw8FCxbkzTffpFu3bly9etVq/ypVqpAnTx4mTJjwXMe5dOmSpf99+/a9cLyffPKJpZ+dO3e+cD9ms5kFCxbQo0ePF+7jaZ41n8HBwQwdOpQaNWrg5+dHkSJFaNCgARMnTiQyMtKy3/bt2y3vPSAgINHiflhQUBAjR46kVq1aFCpUiGLFitG8eXOWLFmSJMc3qufJ9bFjxyhQoADjxo0D/v+5i3v89xquVq2aZVuVKlUs7c/zfXj16lXy58/P0KFDE/Bdi4iISGJS4UhE5CW4ubnh6+tL+vTpSZs2Lffv32fXrl20a9eOs2fP2jq8JOHp6Wk5B+7u7ty8eZMVK1bQrl07q+KFLQUFBbFu3TrL87lz575wXyNHjqRv374EBgYmRGgvLDw8nJYtWzJ16lTOnz+Pi4sLEFsMGDVqlFVhy8nJCV9fX3x9fbG3t0/02E6dOkXDhg2ZNGkSZ8+excHBgbCwMHbv3s0XX3zBwIEDEz0GebqBAwdiMplo1qxZvNu3bt1q+e/Lly9z8eLFJ/b3LN+HGTNmpGrVqsyYMYNDhw4l3JsRERGRRKPCkYjIS6hfvz4bN25k06ZNbNmyhdWrV+Pp6Ul4eDh//PGHrcN7LnEjgrZv3/5cr+vfv7/lHGzfvp3x48cDcObMGbZt25YYoT63xYsXExkZibOzMwArV64kODj4hfq6d+9eAkb24lasWMHJkydxdXVlwYIF7Ny5k927d/PJJ58A8M8//3D8+HEAihYtysaNG9m4cSNeXl6JGldUVBSffPIJ169fJ0uWLMybN489e/awY8cOGjVqBMDs2bOtihKS9LZu3crevXupUqUK6dKls9rm6OgIwL///mu1/8Pb4vOs34dNmjQhOjraMtJJREREXm0qHImIJKBMmTLxxhtvABAaGvrU/VevXk2LFi0oVqwYxYoVo127duzevfuR/dauXcu7775LoUKFKFWqFO3bt+fAgQOP7ffy5cuULVvWMt0pKUf+VKhQAZPJBEBYWNgT942Ojmby5MnUq1ePQoUK8eabb9KzZ0+uXLkS7/5XrlyhQ4cOFCpUiCpVqjB58uRnimnBggUAfPTRR5ZfZP/888/H7vvWW2/h5+fHm2++SdeuXS2jJb788kvLaKUdO3ZYCm2Pmx7Uvn178uTJw5dffmlpO3/+PF27dqVs2bIULFiQsmXL8vnnn3Pjxo1nei9xrl+/DoCdnZ3lF397e3s6dOhAu3btaNeunSUP/43v4el/8T3iXL16lc8++4zixYtTuHBhmjVrxubNm58Y1+rVqzlz5gwA33//PYULFwbAw8ODr7/+mpIlS9KsWTNcXV0trwkLC+OHH36gRo0aFCxYkAoVKjB48GCr4t4ff/xBnjx5aNq0KRs3bqR+/fr4+fnx7rvvcvr0aXbv3k3jxo3x8/Ojbt26bNiwwfLaMWPGkCdPHrp06cLixYstU/tatmzJsWPHHjlGo0aNGDt2LEWLFqVSpUpcv36dmJgYJkyYQNWqVSlYsCBVq1blp59+srq27t27x7Bhw6hWrZrl89y5c2erYwDMmjWL+vXrU7RoUYoXL07Tpk1ZtWqV1T63b9/mq6++okyZMvj5+dGwYUP++usvq32ioqL4/vvvKVeuHIULF6ZLly7P/DmaPXs2ALVq1Xpkm5+fH4BV4TeucFSoUKFn6h8e/31YunRpPDw8WLdu3VNHMYmIiIjtOdg6ABGRlCIyMpIdO3ZYCjrVqlV74v7Tpk3j22+/BcDFxYXo6Gi2bNnC9u3b+fHHHy2vX7p0KZ9//rllv9DQUDZv3syePXuYP38+r7/+ulW/9+7do3PnzgQGBlKwYEHGjBnzxFECCSkkJIRZs2ZhNptJlSoVpUqVeuL+3bp1s/zC7O7uTlBQEH/++SebN29m7ty5ZMmSxWr/Pn36EBUVhZ2dHZcvX2b48OFERkbSqVOnxx5j7969nD59GgcHBxo3bkxAQAAzZsxg/vz5tGnTxmrfX3/9ldGjRwOx027u3LnDP//8w549e/jzzz9JkyYNbm5uhISE4OjoiJeXF05OTkRERDzT+YmIiOD999/n8uXLODk54eHhQWBgIEuXLiU4OJhJkyY9Uz+A5dzev3+fGjVqUK5cOd58803Kli1Lr169nvhaBwcHfH19Lc9jYmIsBS93d3cAbt26xXvvvcfVq1dxdHTE1dWVvXv30qFDB8aPH0/FihXj7TtulErGjBktBYiHjztjxoxHzknr1q3Zv38/EFtgun79OrNmzWLLli3MnTsXT09Py/7nzp3jww8/xMXFhYiICPbt20eHDh24efMm9vb2REVFcerUKT799FPWrl1L2rRpLa/dt28fa9aswc3NjcjISHbu3EmrVq1YsmQJGTNmtOx34sQJDh8+TOrUqUmVKhW+vr4MHDiQ2bNnYzKZSJMmDVeuXGHcuHGcO3fO8pnp27cvK1aswGQykTZtWu7cucO6devYu3cvK1asIG3atMyaNYvBgwcDsdM8IyIi2L9/P127dmXy5MmUKVOGiIgI2rZty5EjR3BwcMDDw4OjR4/So0cP7t27Z5la9s0331gKQK6urqxfv95qlNDjREVFWfYrXbr0I9uzZcvG5cuXuX79OidPnuSNN96wjEQsWbJkvMXt/3rS96GTkxP+/v5s2LCBdevW0bp166f2JyIiIrajEUciIi9h7ty5VgtDt2vXjvDwcL744ot4fyGLc/PmTUaOHAlA8+bN2bVrFzt27KBy5cpERUXRv39/wsPDiYmJsexXt25ddu3axdatWylYsCBhYWGPLDRsNpvp0aMHJ06cIGvWrEyYMAE3N7fHxvHwKJPLly8D0Lp1a0vbs0y36969u2X/okWLMmrUKNzc3Bg3bhypU6d+7OtWr15tKRqNGjWKPXv2sGrVKrJmzcrNmzcZMmTII6/JmzcvW7duZdeuXVSuXBngkYWg/ytutFH58uXx9vbmnXfeAeDkyZNWvwDfuXOHn3/+GYB27dqxZ88eNmzYwGuvvcatW7dYuXIlvXv3pn79+sD/p38VLVr0qecozsWLF8mZMycFCxZk06ZNbNu2jf79+wOxBa7nUbhwYT799FNMJhORkZGsW7eOIUOGUKdOHRo1asSOHTse+9oMGTJYpq5t3LjRMurEZDIxYsQIAKZOncrVq1cpWbIk27dvZ+fOnfTv35+YmBi+++67x/Ydt6ByhgwZnul9zJ49m/379+Pk5MTUqVPZvXs3ixcvxtPTk3PnzjF27Fir/W/fvk23bt3YvXu3ZR2ny5cvU61aNXbs2GEZhRYSEsLBgwetXnvz5k26devGnj17WLJkCe7u7ty5c4cpU6ZY7RcZGUn37t3ZuXMnU6dO5dy5c8yZMwdHR0f++OMPtm/fzurVq0mbNi3Lli3jyJEjAGzcuBGI/Uxu3bqVTZs2UaFCBSpUqGAZIRa3T8eOHdm+fTs7duygefPmVK1alTt37gDw559/cuTIEXLmzGmZAhq3qPwPP/xAZGQkgYGBzJs3D4CmTZuye/duNm/eTNasWZ96zk+ePMndu3fx8fF57NTFEiVKALEjjU6dOkVAQAAZMmR4Yv/P830YN7LtSZ9TEREReTVoxJGIyEtwc3MjVapUQOxf8YODg4mOjmbixInkyZOH8uXLx/u69evXExkZiZOTE7169cLR0RFHR0f69u3LunXruHnzJnv27CF9+vSWXzjbt29v2e/XX3/Fzc3tkaLQtm3biI6OBmILQP9du+S/Hh51EhgYSHR0NGnTpsXJyQnAajrR43h6euLs7IzZbCYiIoLg4GBCQkL45ptv+OWXX8icOXO8r4srGpUoUcJSjMmSJQudOnWib9++bN68mfDwcKvXtGnTxnK+O3XqxLp167h79y5nz54ld+7cjxzj/v37LF++HIC3334biC0+FShQgMOHDzN//nz8/f2B2MJN3NS6Tp06YTKZSJcuHXPmzLE6Jy8jV65cTJo0icjISI4ePcpff/3FP//8Y4n1eX344YfUqFGDhQsXsmnTJk6ePInZbObw4cO0a9eOefPmkT9//if2MW/ePMsooC5dulhGhsRNUzp8+DC1a9cGYkcmARw/fpygoKB4iw5x+zyruM9BnTp1KFOmDAD58uWjefPm/Pzzz6xatYp+/fpZvaZ58+YAVkW7Fi1a4ODgQLFixSxt/12Pys3NzZLb3LlzU7duXebNmxfvCJqGDRsCkC5dOlatWoXZbCYmJobOnTs/0v/WrVvJnz8/+fLlsywAXrFiRUqUKMHAgQPJlCmT5TX58uVj/fr1TJ06lZMnT1K6dGmaNGlilae4aWFXr161xBHn1q1bHDt2jICAAMu1/umnn2Jvb4+XlxetWrV65Hz9V9x0Nm9v78fuU6pUKf766y+2bt2KnV3s3xnjikmP8zzfh3HfTf+9c5uIiIi8elQ4EhF5CfXr17dMO4HYXyS/+OIL1q5dS48ePVi3bp1l6s/Dbt68CYCPj4/lblgQuyaIyWTCbDYTGBhoVax4eMrN437hi/tFEuC3336jadOmlgWh4xM3+gFiF8e+fPkyP/7441OnmD2sf//+1K1b1/L8/PnzdOzYkRMnTtC/f//HrkMUd1ey/xaW4p5HRkY+soD1w+87ffr0lv++e/duvMf4+++/CQkJAaBr167xbu/bty+pUqXi9u3bQOyaQWnSpLHs83Bx7Xk9nA/AMlpnzpw53Lt3D19fX0tRwWw2P3f/t2/fxsfHh549e9KzZ0+CgoL4559/GDFiBCEhIcydO5dBgwY99vW7du2yfH4rV65sWVgbsJz7+/fvx1vUun79eryFo7i8PG6dqm3btpE3b17L9LOnfQ7irpU4cVO3wHqh5rjPxsOf9/+e07Rp01rdVS4ut/F9fnx8fCz/HXcuoqOjLYXch127dg2IXdNp2LBhrFmzhsWLF7N48WIAypYty6hRo/Dy8qJLly5ERUWxYMEC1q1bZ7nbX44cORgxYgSFChWyHC80NDTetdKuX79uycnDa1zBs430ihvZ9KTRiHFFoh07dljOY8mSJZ/Y7/N8H8b9+6osNi8iIiKPp6lqIiIJyMPDw7L+yO3btzl9+nS8+8X9khsQEGC1gPSlS5csv6T5+PhYre3y8C+shw4dYvny5Y/0b29vz/fff4+vry9Xr15l6tSpCfG2nku2bNkso1b27Nnz2P3ifjG/dOmSVXvcYrmOjo5WxTLAMp0O/l9wAKzO08Pipqk9TlhYmGWR7Lg+Hl7vB2IXll61apUlzrgFpx8WNyIDsFrv6L8Fiblz5zJp0iTc3NxYvnw5GzdupEuXLk+M8XFatWpFyZIlrQpDXl5evPfee5QtWxZ4tOjysCtXrtC1a1ciIyPJkSMHo0aNsnpvcflp164dx48f5/jx4xw8eJBDhw5x/Phx8uXLF2+/cVOSrl+/zuHDh6223b59m06dOlG2bFnLIuNP+xw8XMAB63P9LO0PCwwMtMpP3Mib/35+HB0drfqLiyFt2rSWc3H8+HH27NnD8ePH6du3LxBbiPr666/Zvn07U6ZM4eOPPyZdunRs2bKFn376CYhd36dr166sX7+e+fPn07t3b/Lly8fZs2cti6jHHa9mzZqWYx05coQDBw5w/PhxqlWrZvV5fXhB7Lgi1pPETSH974i+h+XIkQMfHx/u3btnWWj8aYWj/3rS92FcwejhIq2IiIi8mlQ4EhFJQBEREaxYsQKILTA8PCrmYeXKlcPe3p6IiAjLAs8hISEMHToUiP3FsVixYuTIkcMyKmLixIlERERYpoF99tlnljV54pQpU4Y6depYRo5MmDCBoKCgxHq78QoKCrLceetJo3XiFlfeuXMnS5cuBWKLBXFruVSqVOmR6WG//fYbAQEBREREMHHiRCB2ykuOHDke6f/06dOWdYMmTpzInj17rB41atQAsKwTU6RIEcvor/HjxxMTE0NQUBD9+vXj448/Zv78+UDsiBf4/y++UVFRVms5xRXLjhw5wvHjx61iOnHiBBBbmPD19SU0NNTSLzzfNK9y5coBsHz5cv78809LwXH79u2WqU6PK+6Ehoby0UcfcfPmTTw9PZkwYYJlFE+cuBEnS5cu5cKFCwB89913FC1alDZt2jx2hFTt2rUti5p3797dUjwKCgqie/fuhIWFERMTw5tvvgn8/3OwfPlyS9xHjx61LPocl6eEEB4eztixYzGbzZw9e9ZyrRYvXtxqv/8WB/39/bGzs+PWrVvMmjULiC3elihRggoVKnDw4EEuX75MuXLl8Pf3Z9WqVZY7qsXdhSwoKAiz2cy7775LkSJFGDZsGPnz56dt27aWqYBxhb64c79hwwbL4tIzZ86kaNGi1K9fn9DQUIoUKWK5PsaMGWNZ9+hZisWvvfYaQLyjpx4WVyiKiYkhffr0ZM+e/al9P+xJ34dxxdls2bI9V58iIiKS9DRVTUTkJSxdupT169cDsb9c3blzx/JX/Nq1az922kj69Onp1q0bo0eP5vfff+ePP/4gOjqayMhIHB0dGTJkiOWXwi+++ILPP/+cNWvWULx4cUwmE2FhYbi5udGhQ4d4+2/UqBGTJ0/mzJkzjBs3jq+++uqp72Xt2rUvcAZg8ODBDB8+HIidynPr1i3LFK22bds+9nU1a9akfPnybNq0ic8//5wBAwYQEhKC2WzGx8eHPn36PPKae/fuUaFCBZydnS1TeD766KN4R5vEjTby9vamXLlyj+xTv359Vq5cyfHjx9m/f7/lduajR49m1qxZLFq0iMjISCIjI/Hx8bGsqxNXFDly5Aj+/v4MHz6cypUrkz59em7cuEGvXr0YP34858+fx9vb22oNl2LFivH7779z+fJlypYti9lsthr1cfv27UdGWT1O27ZtWbFiBUeOHKFnz54MGDAAOzs7yxSmrFmz0qJFi3hfO3PmTMuCzhEREbRs2dJq+48//kjr1q2ZP38+AQEB1KhRg1SpUlmmONWrVy/ekVcQO6Jm7NixtG/fnnPnztGoUSM8PDwICQmxFMa++uory3ls2bIlS5cu5dixY7Rt2xYPDw9LUe7111/n448/fqbz8SxcXFyYOHEiM2bMIDQ0FLPZjKen5yN31/uv7Nmz07hxY+bPn8/gwYP5/vvvuX//PjExMWTNmpWCBQtiMpkoUaIEy5cv54svvuCbb74hPDycsLAwTCYTjRo1wmQy0bBhQ/bt28fs2bP5888/cXBwsJzXuIXbGzRowJQpUzh16hRNmjQhTZo0lqmUVatWxdXVFVdXV9q3b88vv/zCvHnzWLJkCZGRkU9d1wxiz6unpycBAQEEBgY+dupryZIlWbZsmeW/n+Z5vg/jiqrPs7i8iIiI2IZGHImIvISQkBCuX7/O9evXCQwMJCYmhkyZMtGuXTuGDRv2xNd26tSJMWPGUKJECezs7HB0dKRcuXLMmDHD6lbn9evX5+eff6Zw4cJA7C+/5cuXZ9q0aeTNmzfevu3t7enevTsQOz3q3LlzCfOG4xEcHGw5B0FBQTg6OpI7d24GDRrEe++999jX2dnZMX78eL744gty585NZGQkadOm5e2332bBggWWUREPmzRpEpUqVcJsNpMpUyb69+8fb3EkMjLSMgWtevXq8RaWKlasaBllEzdtqlOnTgwZMsQST5o0aahVqxYzZsywjJ566623KFOmDG5ubri6uuLg4IC9vT2//PILhQsXttwSfsCAAZaRJHHq169Pt27dyJAhAyaTiezZszNs2DDLL/txI26ehbOzM1OnTqVdu3Zkz56dqKgooqOjyZ49O61bt37kNvYPe3h65MOf4bhHREQEadOmZfbs2dSpU4c0adIQHh5O3rx5GTVqFE2aNHlibHnz5mXx4sW0bt2azJkzEx4ejre3NxUqVGDq1KmWIhzEfp5nz55N586dyZYtG+Hh4fj6+tKqVSt+//13y2LLCSFjxoyMGTMGHx8fHB0dKVmyJDNnznymdawGDBhAt27dyJYtG2FhYfj4+NCqVSvGjx9vKaKNGDGCHj168PrrrxMREYGrqyslSpRgwoQJVKpUCYD33nuPH3/8kaJFi+Lg4EBUVBR58uShX79+lmvW0dGR6dOn06RJE3x8fAgNDSVHjhz06dOHTz/91BJTt27d6NGjB76+vphMJipVqsSvv/761PdiMpksC1U/6TP38GLYT1sYG579+zAqKoqDBw/i4OBA9erVn9qviIiI2JbJ/CKrcYqIiIgkE2PGjGHs2LHkyJHDMnXK6Hbt2kWLFi1o1KiRZYpsUtmxYwetWrWievXqjB07NkmPLSIiIs9PI45EREREDKZ48eL4+/uzcuXKeO+al5gWLVqEvb19gk5DFBERkcSjwpGIiIiIAfXr14+QkBCrBdoTW0BAAH/99RfNmjV77FRbERERebVoqpqIiIiIiIiIiMRLI45ERERERERERCReKhyJiIiIiIiIiEi8VDgSEREREREREZF4qXAkIiIiIiIiIiLxUuFIRERERERERETipcKRiIiIiIiIiIjES4UjERERERERERGJlwpHIiIiIiIiIiISLxWOREREREREREQkXv8DtWeQhgNXbwwAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Creating plot for MEV: False Worst case with EIP7623 with solo_stakers and observed by home users\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Creating plot for MEV: None Worst case with EIP7623 with solo_stakers and observed by home users\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Creating plot for MEV: True Worst case with EIP7623 with kiln and observed by home users\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Creating plot for MEV: False Worst case with EIP7623 with kiln and observed by home users\n", - "Skipping kiln observed by home users (MEV: False) due to low block count: 35\n", - "Creating plot for MEV: None Worst case with EIP7623 with kiln and observed by home users\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "from matplotlib import gridspec, colors\n", "\n", @@ -1005,7 +644,7 @@ " 'observer_colors': ['#884EA0', '#D35400', '#1ABC9C']\n", "}\n", "\n", - "observed_by_groups = ['home users', 'all nodes', 'ethpandaops']\n", + "observed_by_groups = ['home users']\n", "figures = []\n", "trend_data = []\n", "\n", @@ -1013,7 +652,12 @@ "ethpandaops_logo = plt.imread('./content/ethpandaops.png')\n", "xatu_logo = plt.imread('./content/xatu.png')\n", "\n", - "feature_set = {'show_block_size': False, 'show_blob_count': False, 'show_trend_lines': False}\n", + "feature_set = {'show_block_size': False, 'show_blob_count': True, 'show_trend_lines': False}\n", + "\n", + "# only the top 5 entities\n", + "top_entities = combined_data['entity'].value_counts().head(5).index.tolist()\n", + "\n", + "entities =['solo_stakers']\n", "\n", "for block_size in block_sizes:\n", " for entity in entities:\n", @@ -1176,330 +820,748 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 36, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Creating plot for MEV: True Historical p99 block size with solo_stakers and observed by home users\n", - "Creating plot for MEV: False Historical p99 block size with solo_stakers and observed by home users\n", - "Creating plot for MEV: None Historical p99 block size with solo_stakers and observed by home users\n", - "Creating plot for MEV: True Historical p99 block size with kiln and observed by home users\n", - "Creating plot for MEV: False Historical p99 block size with kiln and observed by home users\n", - "Skipping kiln observed by home users (MEV: False) due to low block count: 35\n", - "Creating plot for MEV: None Historical p99 block size with kiln and observed by home users\n", - "Creating plot for MEV: True Worst case with EIP7623 with solo_stakers and observed by home users\n", - "Creating plot for MEV: False Worst case with EIP7623 with solo_stakers and observed by home users\n", - "Creating plot for MEV: None Worst case with EIP7623 with solo_stakers and observed by home users\n", - "Creating plot for MEV: True Worst case with EIP7623 with kiln and observed by home users\n", - "Creating plot for MEV: False Worst case with EIP7623 with kiln and observed by home users\n", - "Skipping kiln observed by home users (MEV: False) due to low block count: 35\n", - "Creating plot for MEV: None Worst case with EIP7623 with kiln and observed by home users\n", - "Creating plot for MEV: True Historical p99 block size with solo_stakers and observed by home users\n", - "Creating plot for MEV: False Historical p99 block size with solo_stakers and observed by home users\n", - "Creating plot for MEV: None Historical p99 block size with solo_stakers and observed by home users\n", - "Creating plot for MEV: True Historical p99 block size with kiln and observed by home users\n", - "Creating plot for MEV: False Historical p99 block size with kiln and observed by home users\n", - "Skipping kiln observed by home users (MEV: False) due to low block count: 35\n", - "Creating plot for MEV: None Historical p99 block size with kiln and observed by home users\n", - "Creating plot for MEV: True Worst case with EIP7623 with solo_stakers and observed by home users\n", - "Creating plot for MEV: False Worst case with EIP7623 with solo_stakers and observed by home users\n", - "Creating plot for MEV: None Worst case with EIP7623 with solo_stakers and observed by home users\n", - "Creating plot for MEV: True Worst case with EIP7623 with kiln and observed by home users\n", - "Creating plot for MEV: False Worst case with EIP7623 with kiln and observed by home users\n", - "Skipping kiln observed by home users (MEV: False) due to low block count: 35\n", - "Creating plot for MEV: None Worst case with EIP7623 with kiln and observed by home users\n", - "Creating plot for MEV: True Historical p99 block size with solo_stakers and observed by home users\n", - "Creating plot for MEV: False Historical p99 block size with solo_stakers and observed by home users\n", - "Creating plot for MEV: None Historical p99 block size with solo_stakers and observed by home users\n", - "Creating plot for MEV: True Historical p99 block size with kiln and observed by home users\n", - "Creating plot for MEV: False Historical p99 block size with kiln and observed by home users\n", - "Skipping kiln observed by home users (MEV: False) due to low block count: 35\n", - "Creating plot for MEV: None Historical p99 block size with kiln and observed by home users\n", - "Creating plot for MEV: True Worst case with EIP7623 with solo_stakers and observed by home users\n", - "Creating plot for MEV: False Worst case with EIP7623 with solo_stakers and observed by home users\n", - "Creating plot for MEV: None Worst case with EIP7623 with solo_stakers and observed by home users\n", - "Creating plot for MEV: True Worst case with EIP7623 with kiln and observed by home users\n", - "Creating plot for MEV: False Worst case with EIP7623 with kiln and observed by home users\n", - "Skipping kiln observed by home users (MEV: False) due to low block count: 35\n", - "Creating plot for MEV: None Worst case with EIP7623 with kiln and observed by home users\n", - "Creating plot for MEV: True Historical p99 block size with solo_stakers and observed by home users\n", - "Creating plot for MEV: False Historical p99 block size with solo_stakers and observed by home users\n", - "Creating plot for MEV: None Historical p99 block size with solo_stakers and observed by home users\n", - "Creating plot for MEV: True Historical p99 block size with kiln and observed by home users\n", - "Creating plot for MEV: False Historical p99 block size with kiln and observed by home users\n", - "Skipping kiln observed by home users (MEV: False) due to low block count: 35\n", - "Creating plot for MEV: None Historical p99 block size with kiln and observed by home users\n", - "Creating plot for MEV: True Worst case with EIP7623 with solo_stakers and observed by home users\n", - "Creating plot for MEV: False Worst case with EIP7623 with solo_stakers and observed by home users\n", - "Creating plot for MEV: None Worst case with EIP7623 with solo_stakers and observed by home users\n", - "Creating plot for MEV: True Worst case with EIP7623 with kiln and observed by home users\n", - "Creating plot for MEV: False Worst case with EIP7623 with kiln and observed by home users\n", - "Skipping kiln observed by home users (MEV: False) due to low block count: 35\n", - "Creating plot for MEV: None Worst case with EIP7623 with kiln and observed by home users\n" - ] - } - ], + "outputs": [], "source": [ - "from matplotlib import gridspec\n", + "# # Create combined CDF of arrivals for all configs\n", + "# import plotly.graph_objects as go\n", + "# from plotly.subplots import make_subplots\n", + "# import numpy as np\n", + "\n", + "# # Create single CDF plot with all configs\n", + "# fig = go.Figure()\n", + "\n", + "# colors = ['#2E86C1', '#E74C3C', '#28B463', '#F39C12', '#8E44AD', '#17A2B8', '#FD7E14', '#20C997']\n", + "# color_idx = 0\n", + "\n", + "# # Dedupe configs by removing feature_set from uniqueness check\n", + "# unique_configs = []\n", + "# seen_configs = set()\n", + "\n", + "# for config in configs:\n", + "# # Create a key without feature_set for deduplication\n", + "# dedup_key = (\n", + "# config['block_size']['label'],\n", + "# config['entity'],\n", + "# config['is_mev'],\n", + "# config['observed_by_group']\n", + "# )\n", + " \n", + "# if dedup_key not in seen_configs:\n", + "# seen_configs.add(dedup_key)\n", + "# unique_configs.append(config)\n", + "\n", + "# for config in unique_configs:\n", + "# feature_set = config['feature_set']\n", + "# block_size = config['block_size']\n", + "# entity = config['entity']\n", + "# is_mev = config['is_mev']\n", + "# observed_by_group = config['observed_by_group']\n", + " \n", + "# print(f\"Adding CDF for MEV: {is_mev} {block_size['label']} with {entity} and observed by {observed_by_group}\")\n", + " \n", + "# # Filter data based on conditions\n", + "# if is_mev is None:\n", + "# slots_df = combined_data\n", + "# elif is_mev:\n", + "# slots_df = mev_slots_with_sizes\n", + "# else:\n", + "# slots_df = non_mev_slots_with_sizes\n", + " \n", + "# # Merge and filter data\n", + "# plot_data = (arrival_data\n", + "# .merge(slots_df[['slot', 'block_total_bytes_compressed', 'total_blob_size', 'entity']], on='slot'))\n", + " \n", + "# if observed_by_group != 'all nodes':\n", + "# plot_data = plot_data.query(f\"observed_by_group == '{observed_by_group}'\")\n", + " \n", + "# plot_data = plot_data.query(f\"entity == '{entity}'\")\n", + " \n", + "# valid_mask = ~np.isnan(plot_data['arrival_time'])\n", + "# plot_data = plot_data[valid_mask]\n", + " \n", + "# n_blocks = len(plot_data['slot'].unique())\n", + "# n_arrivals = len(plot_data)\n", "\n", - "# Define color map for title parameters\n", - "title_param_colors = {\n", - " 'mev_status': ['#2E86C1', '#E74C3C', '#27AE60'], \n", - " 'entity_colors': ['#8E44AD', '#E67E22', '#16A085', '#2980B9', '#C0392B', '#7D3C98', '#F39C12', '#1ABC9C', '#2E86C1', '#E74C3C', '#27AE60', '#8E44AD', '#D35400', '#16A085', '#2980B9'],\n", - " 'observer_colors': ['#884EA0', '#D35400', '#1ABC9C']\n", + "# if n_blocks < 100:\n", + "# print(f\"Skipping {entity} observed by {observed_by_group} (MEV: {is_mev}) due to low block count: {n_blocks}\")\n", + "# continue\n", + "\n", + "# if len(plot_data) == 0:\n", + "# print(f\"No data for {entity} observed by {observed_by_group}\")\n", + "# continue\n", + "\n", + "# # Get arrival times for CDF\n", + "# arrival_times = plot_data['arrival_time'].values\n", + " \n", + "# # Calculate CDF values using normalized percentiles for faster computation\n", + "# percentiles = np.linspace(0, 100, min(1000, len(arrival_times)))\n", + "# x_values = np.percentile(arrival_times, percentiles)\n", + "# y_values = percentiles / 100\n", + " \n", + "# # Create trace name\n", + "# mev_text = \"MEV relay\" if is_mev else \"Locally built\" if is_mev is not None else \"All blocks\"\n", + "# trace_name = f\"{mev_text} - {entity} - {observed_by_group}\"\n", + " \n", + "# # Add CDF line\n", + "# fig.add_trace(go.Scatter(\n", + "# x=x_values,\n", + "# y=y_values,\n", + "# mode='lines',\n", + "# name=trace_name,\n", + "# line=dict(color=colors[color_idx % len(colors)], width=2)\n", + "# ))\n", + " \n", + "# color_idx += 1\n", + "\n", + "# # Add vertical line at 4000ms (attestation deadline)\n", + "# fig.add_vline(\n", + "# x=4000,\n", + "# line_dash=\"dash\",\n", + "# line_color=\"red\",\n", + "# annotation_text=\"Attestation deadline (4s)\",\n", + "# annotation_position=\"top right\"\n", + "# )\n", + "\n", + "# # Update layout\n", + "# fig.update_layout(\n", + "# title=\"CDF of Block Arrival Times - All Configurations\",\n", + "# xaxis_title=\"Block Arrival Time (milliseconds)\",\n", + "# yaxis_title=\"Cumulative Probability\",\n", + "# width=1000,\n", + "# height=700,\n", + "# showlegend=True,\n", + "# template=\"plotly_white\",\n", + "# legend=dict(\n", + "# orientation=\"v\",\n", + "# yanchor=\"top\",\n", + "# y=1,\n", + "# xanchor=\"left\",\n", + "# x=1.02\n", + "# )\n", + "# )\n", + "\n", + "# fig.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# P66 Head Time Analysis\n", + "\n", + "Analyze when 66% of nodes have seen each block (p66 head time) - this represents when a block can be accepted by the network." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Calculate p66 head time for each slot across different node groups\n", + "# Function to calculate p66 for a group of arrival times\n", + "def calculate_p66(arrival_times):\n", + " if len(arrival_times) == 0:\n", + " return np.nan\n", + " return np.percentile(arrival_times, 66)\n", + "\n", + "# Calculate p66 for each slot and node group\n", + "p66_results = []\n", + "\n", + "for slot in arrival_data['slot'].unique():\n", + " slot_data = arrival_data[arrival_data['slot'] == slot]\n", + " \n", + " # Skip slots with too few observations\n", + " if len(slot_data) < 10:\n", + " continue\n", + " \n", + " # Get slot metadata from combined_data\n", + " slot_metadata_df = combined_data[combined_data['slot'] == slot]\n", + " \n", + " # Skip if slot not found in combined_data\n", + " if len(slot_metadata_df) == 0:\n", + " continue\n", + " \n", + " slot_metadata = slot_metadata_df.iloc[0]\n", + " \n", + " # Calculate p66 for all nodes\n", + " all_nodes_p66 = calculate_p66(slot_data['arrival_time'].dropna())\n", + " \n", + " # Calculate p66 for ethpandaops nodes only\n", + " ethpandaops_data = slot_data[slot_data['observed_by_group'] == 'ethpandaops']\n", + " ethpandaops_p66 = calculate_p66(ethpandaops_data['arrival_time'].dropna())\n", + " \n", + " # Calculate p66 for home users only\n", + " home_users_data = slot_data[slot_data['observed_by_group'] == 'home users']\n", + " home_users_p66 = calculate_p66(home_users_data['arrival_time'].dropna())\n", + " \n", + " # Store results\n", + " p66_results.append({\n", + " 'slot': slot,\n", + " 'proposer_index': slot_metadata['proposer_index'],\n", + " 'entity': slot_metadata['entity'],\n", + " 'via_mev': slot_metadata['via_mev'],\n", + " 'block_size_mb': slot_metadata['block_total_bytes_compressed'] / 1_000_000,\n", + " 'total_size_mb': slot_metadata['total_size_mb'],\n", + " 'num_blobs': slot_metadata['num_blobs'],\n", + " 'p66_all': all_nodes_p66,\n", + " 'p66_ethpandaops': ethpandaops_p66,\n", + " 'p66_homeusers': home_users_p66\n", + " })\n", + "\n", + "# Create DataFrame\n", + "p66_df = pd.DataFrame(p66_results)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Create interactive CDF plot of p66 head times with Plotly\n", + "import plotly.graph_objects as go\n", + "from plotly.subplots import make_subplots\n", + "import numpy as np\n", + "from PIL import Image\n", + "import base64\n", + "from io import BytesIO\n", + "\n", + "# Create figure\n", + "fig = go.Figure()\n", + "\n", + "# Color scheme\n", + "colors = {\n", + " 'all': '#2E86C1',\n", + " 'ethpandaops': '#E74C3C', \n", + " 'homeusers': '#28B463'\n", "}\n", "\n", - "observed_by_groups = ['home users', 'all nodes', 'ethpandaops']\n", - "figures = []\n", - "trend_data = []\n", + "# Nice names for display\n", + "nice_names = {\n", + " 'all': 'All nodes',\n", + " 'ethpandaops': 'ethPandaOps',\n", + " 'homeusers': 'Home users'\n", + "}\n", "\n", - "# Load logos\n", + "# Line styles for MEV vs non-MEV\n", + "dash_styles = {\n", + " True: 'solid', # MEV blocks\n", + " False: 'dash' # Non-MEV blocks\n", + "}\n", + "\n", + "# Plot CDFs for different combinations\n", + "for node_group, color in colors.items():\n", + " for is_mev in [True, False]:\n", + " # Get the appropriate p66 column\n", + " p66_col = f'p66_{node_group}'\n", + " \n", + " # Filter data\n", + " data = p66_df[p66_df['via_mev'] == is_mev][p66_col].dropna()\n", + " \n", + " if len(data) > 0:\n", + " # Sort values for CDF\n", + " sorted_data = np.sort(data)\n", + " y_values = np.arange(1, len(sorted_data) + 1) / len(sorted_data)\n", + " \n", + " # Calculate statistics\n", + " p98 = np.percentile(data, 98)\n", + " p95 = np.percentile(data, 95)\n", + " median = np.percentile(data, 50)\n", + " \n", + " # Create label with p99\n", + " mev_label = 'MEV' if is_mev else 'Local'\n", + " label = f'{mev_label} blocks seen by {nice_names[node_group]} (p98: {p98:.0f}ms)'\n", + " \n", + " # Add trace\n", + " fig.add_trace(go.Scatter(\n", + " x=sorted_data,\n", + " y=y_values,\n", + " mode='lines',\n", + " name=label,\n", + " line=dict(\n", + " color=color,\n", + " width=2.5,\n", + " dash=dash_styles[is_mev]\n", + " ),\n", + " hovertemplate=f'{nice_names[node_group]} - {mev_label}
' +\n", + " 'P66 Time: %{x:.0f}ms
' +\n", + " 'Percentile: %{y:.1%}
' +\n", + " f'Stats:
' +\n", + " f'Median: {median:.0f}ms
' +\n", + " f'P95: {p95:.0f}ms
' +\n", + " f'P98: {p98:.0f}ms' +\n", + " ''\n", + " ))\n", + "\n", + "# Add vertical line at 4000ms (attestation deadline)\n", + "fig.add_vline(\n", + " x=4000,\n", + " line_dash=\"dot\",\n", + " line_color=\"red\",\n", + " line_width=2,\n", + " annotation_text=\"Attestation deadline (4s)\",\n", + " annotation_position=\"top\",\n", + " annotation_font_size=12,\n", + " annotation_yshift=-150 # Move text to middle of plot\n", + ")\n", + "\n", + "# Calculate overall statistics for annotation\n", + "stats_text = \"Overall Statistics:
\"\n", + "for node_group in ['all', 'ethpandaops', 'homeusers']:\n", + " p66_col = f'p66_{node_group}'\n", + " median = p66_df[p66_col].median()\n", + " p95 = p66_df[p66_col].quantile(0.95)\n", + " pct_under_4s = (p66_df[p66_col] < 4000).sum() / len(p66_df[p66_col].dropna()) * 100\n", + " stats_text += f\"{nice_names[node_group]}: median={median:.0f}ms, p95={p95:.0f}ms, <4s={pct_under_4s:.1f}%
\"\n", + "\n", + "# Load logos and convert to base64\n", + "def image_to_base64(image_path):\n", + " img = Image.open(image_path)\n", + " buffered = BytesIO()\n", + " img.save(buffered, format=\"PNG\")\n", + " img_str = base64.b64encode(buffered.getvalue()).decode()\n", + " return f\"data:image/png;base64,{img_str}\"\n", + "\n", + "ethpandaops_b64 = image_to_base64('./content/ethpandaops.png')\n", + "xatu_b64 = image_to_base64('./content/xatu.png')\n", + "\n", + "# Update layout with logos\n", + "fig.update_layout(\n", + " title={\n", + " 'text': 'CDF of P66 Head Times by Node Group and Block Type',\n", + " 'x': 0.5,\n", + " 'xanchor': 'center',\n", + " 'font': {'size': 18, 'family': 'Arial Black'}\n", + " },\n", + " xaxis=dict(\n", + " title=\"P66 Head Time (milliseconds)\",\n", + " titlefont=dict(size=14, family='Arial Black'),\n", + " range=[0, 6000],\n", + " gridcolor='rgba(128,128,128,0.2)',\n", + " showgrid=True,\n", + " showline=True,\n", + " linewidth=1,\n", + " linecolor='black',\n", + " mirror=False,\n", + " ticks='outside',\n", + " tickmode='linear',\n", + " tick0=0,\n", + " dtick=1000\n", + " ),\n", + " yaxis=dict(\n", + " title=\"Cumulative Probability\",\n", + " titlefont=dict(size=14, family='Arial Black'),\n", + " range=[0, 1],\n", + " gridcolor='rgba(128,128,128,0.2)',\n", + " showgrid=True,\n", + " tickformat='.0%',\n", + " showline=True,\n", + " linewidth=1,\n", + " linecolor='black',\n", + " mirror=False,\n", + " ticks='outside',\n", + " tickmode='linear',\n", + " tick0=0,\n", + " dtick=0.2\n", + " ),\n", + " plot_bgcolor='white',\n", + " paper_bgcolor='white',\n", + " width=1200,\n", + " height=700,\n", + " hovermode='x unified',\n", + " legend=dict(\n", + " x=0.98,\n", + " y=0.02,\n", + " xanchor='right',\n", + " yanchor='bottom',\n", + " bgcolor='rgba(255,255,255,0.9)',\n", + " bordercolor='rgba(0,0,0,0.2)',\n", + " borderwidth=1,\n", + " font=dict(size=11)\n", + " ),\n", + " margin=dict(t=120) # Add more top margin for logos\n", + ")\n", + "\n", + "# Add statistics annotation\n", + "fig.add_annotation(\n", + " text=stats_text,\n", + " xref=\"paper\",\n", + " yref=\"paper\",\n", + " x=0.02,\n", + " y=0.98,\n", + " xanchor=\"left\",\n", + " yanchor=\"top\",\n", + " showarrow=False,\n", + " bordercolor=\"rgba(0,0,0,0.2)\",\n", + " borderwidth=1,\n", + " bgcolor=\"rgba(255,255,255,0.9)\",\n", + " font=dict(size=10),\n", + " align=\"left\"\n", + ")\n", + "\n", + "# Add ethpandaops logo (bigger)\n", + "fig.add_layout_image(\n", + " dict(\n", + " source=ethpandaops_b64,\n", + " xref=\"paper\",\n", + " yref=\"paper\",\n", + " x=0.08,\n", + " y=1.15,\n", + " sizex=0.12, # Increased from 0.08\n", + " sizey=0.12, # Increased from 0.08\n", + " xanchor=\"center\",\n", + " yanchor=\"middle\"\n", + " )\n", + ")\n", + "\n", + "# Add Xatu logo\n", + "fig.add_layout_image(\n", + " dict(\n", + " source=xatu_b64,\n", + " xref=\"paper\",\n", + " yref=\"paper\",\n", + " x=0.92,\n", + " y=1.15,\n", + " sizex=0.08,\n", + " sizey=0.08,\n", + " xanchor=\"center\",\n", + " yanchor=\"middle\"\n", + " )\n", + ")\n", + "\n", + "# Add text under logos\n", + "fig.add_annotation(\n", + " text=\"ethpandaops.io\",\n", + " xref=\"paper\",\n", + " yref=\"paper\",\n", + " x=0.08,\n", + " y=1.06,\n", + " xanchor=\"center\",\n", + " yanchor=\"top\",\n", + " showarrow=False,\n", + " font=dict(size=11, color='#2C3E50')\n", + ")\n", + "\n", + "fig.add_annotation(\n", + " text=\"Data from Xatu\",\n", + " xref=\"paper\",\n", + " yref=\"paper\",\n", + " x=0.92,\n", + " y=1.08,\n", + " xanchor=\"center\",\n", + " yanchor=\"top\",\n", + " showarrow=False,\n", + " font=dict(size=11, color='#2C3E50')\n", + ")\n", + "\n", + "# Show the plot\n", + "fig.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Analyze p66 times by entity with branding\n", + "# Get top entities by block count\n", + "top_entities = p66_df['entity'].value_counts().head(10).index.tolist()\n", + "\n", + "# Create figure with subplots\n", + "plt.style.use('seaborn-v0_8')\n", + "fig = plt.figure(figsize=(18, 10))\n", + "\n", + "# Create grid with space for title and logos\n", + "gs = gridspec.GridSpec(2, 1, height_ratios=[1, 10], hspace=0.05, figure=fig)\n", + "\n", + "# Create title/logo axes\n", + "title_ax = fig.add_subplot(gs[0])\n", + "title_ax.axis('off')\n", + "\n", + "# Create subplot axes for the charts\n", + "chart_ax = fig.add_subplot(gs[1])\n", + "chart_ax.axis('off')\n", + "\n", + "# Now create subplots within the chart area\n", + "subfigs = fig.subfigures(1, 1, wspace=0.1, height_ratios=[1])\n", + "subfig = subfigs\n", + "axes = subfig.subplots(1, 3)\n", + "\n", + "node_groups = ['all', 'ethpandaops', 'homeusers']\n", + "titles = ['All Nodes', 'EthPandaOps Nodes', 'Home Users']\n", + "\n", + "for idx, (node_group, title) in enumerate(zip(node_groups, titles)):\n", + " ax = axes[idx]\n", + " p66_col = f'p66_{node_group}'\n", + " \n", + " # Calculate median p66 for each entity\n", + " entity_stats = []\n", + " for entity in top_entities:\n", + " entity_data = p66_df[p66_df['entity'] == entity][p66_col].dropna()\n", + " if len(entity_data) > 0:\n", + " entity_stats.append({\n", + " 'entity': entity,\n", + " 'median_p66': entity_data.median(),\n", + " 'p25': entity_data.quantile(0.25),\n", + " 'p75': entity_data.quantile(0.75),\n", + " 'count': len(entity_data)\n", + " })\n", + " \n", + " entity_stats_df = pd.DataFrame(entity_stats).sort_values('median_p66')\n", + " \n", + " # Create bar plot with error bars\n", + " positions = range(len(entity_stats_df))\n", + " ax.bar(positions, entity_stats_df['median_p66'], \n", + " yerr=[entity_stats_df['median_p66'] - entity_stats_df['p25'],\n", + " entity_stats_df['p75'] - entity_stats_df['median_p66']],\n", + " capsize=5, alpha=0.7, color='skyblue', edgecolor='navy')\n", + " \n", + " # Add attestation deadline line\n", + " ax.axhline(y=4000, color='red', linestyle='--', alpha=0.7, \n", + " label='Attestation deadline')\n", + " \n", + " # Styling\n", + " ax.set_xlabel('Entity', fontsize=12, fontweight='bold')\n", + " ax.set_ylabel('P66 Head Time (ms)', fontsize=12, fontweight='bold')\n", + " ax.set_title(title, fontsize=14)\n", + " ax.set_xticks(positions)\n", + " ax.set_xticklabels(entity_stats_df['entity'], rotation=45, ha='right')\n", + " ax.grid(True, alpha=0.3, axis='y')\n", + " \n", + " # Add block counts as text\n", + " for i, (_, row) in enumerate(entity_stats_df.iterrows()):\n", + " ax.text(i, row['median_p66'] + 50, f\"n={row['count']}\", \n", + " ha='center', va='bottom', fontsize=8)\n", + "\n", + "# Add title to title axes\n", + "title_ax.text(0.5, 0.5, 'P66 Head Times by Entity', \n", + " ha='center', va='center', fontsize=16, fontweight='bold')\n", + "\n", + "# Load and add logos\n", "ethpandaops_logo = plt.imread('./content/ethpandaops.png')\n", "xatu_logo = plt.imread('./content/xatu.png')\n", "\n", - "# Feature flags for gradual fade in\n", - "feature_sets = [\n", - " {'show_block_size': False, 'show_blob_count': False, 'show_trend_lines': True},\n", - " {'show_block_size': False, 'show_blob_count': False, 'show_trend_lines': False},\n", - " {'show_block_size': True, 'show_blob_count': True, 'show_trend_lines': False}, \n", - " {'show_block_size': True, 'show_blob_count': True, 'show_trend_lines': True}\n", - "]\n", + "# Add logos to title area\n", + "logo_size = 0.06\n", + "# Ethpandaops logo on left\n", + "logo_ax1 = fig.add_axes([0.05, 0.91, logo_size, logo_size])\n", + "logo_ax1.imshow(ethpandaops_logo)\n", + "logo_ax1.axis('off')\n", "\n", - "for feature_set in feature_sets:\n", - " for block_size in block_sizes:\n", - " for entity in entities:\n", - " for is_mev in [True, False, None]:\n", - " for observed_by_group in observed_by_groups:\n", - " if observed_by_group == 'nan':\n", - " continue\n", - " \n", - " print(f\"Creating plot for MEV: {is_mev} {block_size['label']} with {entity} and observed by {observed_by_group}\")\n", - " \n", - " # Filter data based on conditions\n", - " if is_mev is None:\n", - " slots_df = combined_data\n", - " elif is_mev:\n", - " slots_df = mev_slots_with_sizes\n", - " else:\n", - " slots_df = non_mev_slots_with_sizes\n", - " \n", - " # Merge and filter data\n", - " plot_data = (arrival_data\n", - " .merge(slots_df[['slot', 'block_total_bytes_compressed', 'total_blob_size', 'entity']], on='slot'))\n", - " \n", - " if observed_by_group != 'all nodes':\n", - " plot_data = plot_data.query(f\"observed_by_group == '{observed_by_group}'\")\n", - " \n", - " plot_data = plot_data.query(f\"entity == '{entity}'\")\n", - " \n", - " valid_mask = ~np.isnan(plot_data['arrival_time'])\n", - " n_blocks = len(plot_data['slot'].unique())\n", - " n_arrivals = np.sum(valid_mask)\n", + "text_ax1 = fig.add_axes([0.05, 0.89, logo_size, 0.02])\n", + "text_ax1.text(0.5, 0.5, 'ethpandaops.io', ha='center', va='center', fontsize=10, fontweight='bold')\n", + "text_ax1.axis('off')\n", "\n", - " if n_blocks < 100:\n", - " print(f\"Skipping {entity} observed by {observed_by_group} (MEV: {is_mev}) due to low block count: {n_blocks}\")\n", - " continue\n", + "# Xatu logo on right\n", + "logo_ax2 = fig.add_axes([0.89, 0.91, logo_size, logo_size])\n", + "logo_ax2.imshow(xatu_logo)\n", + "logo_ax2.axis('off')\n", "\n", - " if len(plot_data) == 0:\n", - " print(f\"No data for {entity} observed by {observed_by_group}\")\n", - " continue\n", + "text_ax2 = fig.add_axes([0.89, 0.89, logo_size, 0.02])\n", + "text_ax2.text(0.5, 0.5, 'Data from Xatu', ha='center', va='center', fontsize=10, fontweight='bold')\n", + "text_ax2.axis('off')\n", "\n", - " # Calculate total size in MB\n", - " plot_data['total_size_mb'] = (plot_data['block_total_bytes_compressed'] + plot_data['total_blob_size']) / 1_000_000\n", + "plt.subplots_adjust(top=0.88)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Analyze relationship between block size and p66 times with branding\n", + "plt.style.use('seaborn-v0_8')\n", + "fig = plt.figure(figsize=(15, 8))\n", "\n", - " # Create figure and gridspec\n", - " plt.style.use('seaborn-v0_8')\n", - " fig = plt.figure(figsize=(14, 10))\n", - " \n", - " # Store metadata in figure for filename generation\n", - " fig.metadata = {\n", - " 'block_size': block_size['label'],\n", - " 'entity': entity,\n", - " 'is_mev': is_mev,\n", - " 'observed_by': observed_by_group,\n", - " 'features': '_'.join(k for k,v in feature_set.items() if v)\n", - " }\n", - " \n", - " gs = gridspec.GridSpec(2, 1, height_ratios=[1, 10])\n", - " \n", - " # Create title axes\n", - " title_ax = fig.add_subplot(gs[0])\n", - " title_ax.axis('off')\n", - " \n", - " # Create main plot axes\n", - " ax = fig.add_subplot(gs[1])\n", - " \n", - " # Plot all points\n", - " ax.scatter(plot_data['total_size_mb'], plot_data['arrival_time'], \n", - " alpha=0.05, s=20, color='#404040', label='Individual blocks')\n", - "\n", - " # Add trend lines if enabled\n", - " if feature_set['show_trend_lines'] and np.sum(valid_mask) > 1:\n", - " # Convert to numpy arrays and filter out NaN values\n", - " x_data = plot_data['total_size_mb'][valid_mask].values\n", - " y_data = plot_data['arrival_time'][valid_mask].values\n", - "\n", - " # Calculate p99, p95 and p50 values per bin\n", - " bins = np.linspace(min(x_data), max(x_data), 20)\n", - " p99_vals = []\n", - " p95_vals = []\n", - " p50_vals = []\n", - " bin_centers = []\n", - " \n", - " for i in range(len(bins)-1):\n", - " mask = (x_data >= bins[i]) & (x_data < bins[i+1])\n", - " if np.sum(mask) > 0:\n", - " p99_vals.append(np.percentile(y_data[mask], 99))\n", - " p95_vals.append(np.percentile(y_data[mask], 95))\n", - " p50_vals.append(np.percentile(y_data[mask], 50))\n", - " bin_centers.append((bins[i] + bins[i+1])/2)\n", - "\n", - " # Fit trend lines to percentile data\n", - " if len(bin_centers) > 1:\n", - " p99_z = np.polyfit(bin_centers, p99_vals, 1)\n", - " p95_z = np.polyfit(bin_centers, p95_vals, 1)\n", - " p50_z = np.polyfit(bin_centers, p50_vals, 1)\n", - "\n", - " metrics = [\n", - " ('p99', p99_z, '#cc4c02'),\n", - " ('p95', p95_z, '#de2d26'), \n", - " ('p50', p50_z, '#2171b5')\n", - " ]\n", - " x_range = np.linspace(0, 3.5, 100)\n", - "\n", - " for label, z, color in metrics:\n", - " if z[0] > 0:\n", - " max_size = (4000 - z[1]) / z[0]\n", - " p_fit = np.poly1d(z)\n", - " \n", - " ax.plot(x_range, p_fit(x_range), '--', color=color, alpha=0.8, linewidth=2, label=f'{label} trend')\n", - " \n", - " if feature_set['show_blob_count']:\n", - " if label == 'p95':\n", - " offset = 3500\n", - " else:\n", - " offset = 4250\n", - " ax.annotate(\n", - " f'{label} block arrival trend\\n crosses 4s at {max_size:.2f} MB',\n", - " xy=(max_size, 4000),\n", - " xytext=(max_size-0.5, offset),\n", - " arrowprops=dict(facecolor=color, shrink=0.05, width=2, headwidth=8),\n", - " color=color,\n", - " fontsize=10,\n", - " bbox=dict(facecolor='white', edgecolor=color, alpha=0.9, boxstyle='round,pad=0.5')\n", - " )\n", - "\n", - " base_size = block_size['value']\n", - " max_blobs = int((max_size - base_size) / 0.128)\n", - " trend_data.append({\n", - " 'entity': entity,\n", - " 'is_mev': is_mev,\n", - " 'observed_by': observed_by_group,\n", - " 'metric': label,\n", - " 'max_size_mb': max_size,\n", - " 'max_blobs': max_blobs,\n", - " 'slope': z[0],\n", - " 'intercept': z[1]\n", - " })\n", - "\n", - " # Rest of plot formatting\n", - " ax.axhline(y=4000, color='black', linestyle='-', alpha=0.8, linewidth=2, label='Attestation deadline (4s)')\n", - " \n", - " if feature_set['show_block_size']:\n", - " base_size = block_size['value']\n", - " ax.axvspan(0, base_size, color='#90EE90', alpha=0.3, zorder=0)\n", - " ax.axvline(x=base_size, color='#228B22', linestyle='--', alpha=0.7, linewidth=2, \n", - " label=f\"{block_size['label']}\")\n", - "\n", - " if feature_set['show_blob_count']:\n", - " blob_increment = 0.128\n", - " for i in range(1, int((3.5 - base_size) / blob_increment) + 1):\n", - " x_pos = base_size + (i * blob_increment)\n", - " ax.axvspan(base_size + ((i-1) * blob_increment), x_pos, color='#ADD8E6', alpha=0.2, zorder=0)\n", - " ax.axvline(x=x_pos, color='#4169E1', linestyle=':', alpha=0.4, linewidth=1.5)\n", - " ax.text(x_pos - blob_increment/2, 1100,\n", - " str(i),\n", - " color='#4169E1',\n", - " alpha=1,\n", - " fontsize=10,\n", - " bbox=dict(facecolor='white', alpha=0.9),\n", - " ha='center')\n", - " ax.plot([], [], color='#4169E1', alpha=0.4, label='Maximum number of blobs')\n", - "\n", - " ax.legend(loc='upper right', frameon=True, framealpha=1.0, fontsize=10,\n", - " bbox_to_anchor=(0.99, 0.99), borderaxespad=0, facecolor='white')\n", - "\n", - " mev_text = \"MEV relay blocks\" if is_mev else \"Locally built blocks\" if is_mev is not None else \"All blocks\"\n", - " \n", - " # Add title text to title axes\n", - " title = 'Predicted Maximum Blob Count' if feature_set['show_blob_count'] else 'Block Arrival Trend'\n", - " title_ax.text(0.5, 0.6, title, ha='center', va='bottom',\n", - " fontsize=16, color='black', fontweight='bold')\n", - " title_ax.text(0.5, 0.3, mev_text, ha='center', va='bottom',\n", - " fontsize=16, color=title_param_colors['mev_status'][0 if is_mev else 1 if is_mev is not None else 2], \n", - " fontweight='bold')\n", - " title_ax.text(0.5, 0.0, 'Blocks created by ', ha='right', va='bottom',\n", - " fontsize=16, color='black')\n", - " title_ax.text(0.5, 0.0, entity, ha='left', va='bottom',\n", - " fontsize=16, color=title_param_colors['entity_colors'][hash(entity) % len(title_param_colors['entity_colors'])], \n", - " fontweight='bold')\n", - " title_ax.text(0.5, -0.3, 'Blocks seen by ', ha='right', va='bottom',\n", - " fontsize=16, color='black')\n", - " title_ax.text(0.5, -0.3, observed_by_group, ha='left', va='bottom',\n", - " fontsize=16, color=title_param_colors['observer_colors'][hash(observed_by_group) % len(title_param_colors['observer_colors'])], \n", - " fontweight='bold')\n", - "\n", - " # Add logo in top right corner\n", - " logo_ax1 = fig.add_axes([0.8, 0.75, 0.1, 0.1]) \n", - " logo_ax1.imshow(xatu_logo)\n", - " logo_ax1.axis('off')\n", - " \n", - " # Add \"Data from Xatu\" text below logo\n", - " text_ax = fig.add_axes([0.8, 0.73, 0.1, 0.02])\n", - " text_ax.text(0.5, 0.5, 'Data from Xatu', ha='center', va='center', fontsize=10, fontweight='bold')\n", - " text_ax.axis('off')\n", - "\n", - " # Add ethpandaops logo in top left corner\n", - " logo_ax2 = fig.add_axes([0.13, 0.75, 0.1, 0.1])\n", - " logo_ax2.imshow(ethpandaops_logo)\n", - " logo_ax2.axis('off')\n", - "\n", - " # Add \"Data from ethpandaops\" text below logo\n", - " text_ax = fig.add_axes([0.13, 0.73, 0.1, 0.02])\n", - " text_ax.text(0.5, 0.5, 'ethpandaops.io', ha='center', va='center', fontsize=10, fontweight='bold')\n", - " text_ax.axis('off')\n", - "\n", - " # Add block and arrival counts\n", - " ax.text(0.65, 0.12, f'Total Blocks: {n_blocks:,}\\nArrival events: {n_arrivals:,}', \n", - " ha='left', va='top', transform=ax.transAxes,\n", - " fontsize=12, color='black', \n", - " bbox=dict(facecolor='white', alpha=0.8, edgecolor='gray'))\n", - " ax.set_xlabel('Block + Blob Actual Size Compressed (MB)', fontsize=12, fontweight='bold')\n", - " ax.set_ylabel('Block Arrival Time (milliseconds)', fontsize=12, fontweight='bold')\n", - " ax.grid(True, alpha=0.2, linestyle='--')\n", - " ax.set_ylim(0000, 6500)\n", - " ax.set_xlim(0, 3.5)\n", - "\n", - " plt.subplots_adjust(top=0.85)\n", - "\n", - " if len(trend_data) > 0:\n", - " p99_data = [d for d in trend_data if d['metric'] == 'p99']\n", - " if p99_data:\n", - " figures.append((p99_data[-1]['max_size_mb'], fig))\n", - " # plt.show()\n", - " plt.close()\n", - "\n", - "figures.sort(key=lambda x: x[0], reverse=True)\n", - "trend_df = pd.DataFrame(trend_data)\n", - "# print(trend_df)\n" + "# Create grid with space for title and logos\n", + "gs = gridspec.GridSpec(2, 1, height_ratios=[1, 10], hspace=0.05, figure=fig)\n", + "\n", + "# Create title/logo axes\n", + "title_ax = fig.add_subplot(gs[0])\n", + "title_ax.axis('off')\n", + "\n", + "# Create subplot area\n", + "subplot_gs = gridspec.GridSpecFromSubplotSpec(1, 3, subplot_spec=gs[1], wspace=0.3)\n", + "\n", + "for idx, (node_group, title) in enumerate(zip(['all', 'ethpandaops', 'homeusers'], \n", + " ['All Nodes', 'EthPandaOps Nodes', 'Home Users'])):\n", + " ax = fig.add_subplot(subplot_gs[idx])\n", + " p66_col = f'p66_{node_group}'\n", + " \n", + " # Create scatter plot\n", + " valid_data = p66_df[[p66_col, 'total_size_mb']].dropna()\n", + " \n", + " # Separate MEV and non-MEV blocks\n", + " mev_data = valid_data[p66_df['via_mev'] == True]\n", + " non_mev_data = valid_data[p66_df['via_mev'] == False]\n", + " \n", + " # Plot scatter points\n", + " ax.scatter(non_mev_data['total_size_mb'], non_mev_data[p66_col], \n", + " alpha=0.3, s=10, color='blue', label='Local blocks')\n", + " ax.scatter(mev_data['total_size_mb'], mev_data[p66_col], \n", + " alpha=0.3, s=10, color='red', label='MEV blocks')\n", + " \n", + " # Add trend lines\n", + " if len(valid_data) > 0:\n", + " z = np.polyfit(valid_data['total_size_mb'], valid_data[p66_col], 1)\n", + " p = np.poly1d(z)\n", + " x_trend = np.linspace(valid_data['total_size_mb'].min(), \n", + " valid_data['total_size_mb'].max(), 100)\n", + " ax.plot(x_trend, p(x_trend), \"k--\", alpha=0.8, linewidth=2, \n", + " label=f'Trend: {z[0]:.1f}ms/MB')\n", + " \n", + " # Add attestation deadline\n", + " ax.axhline(y=4000, color='red', linestyle=':', alpha=0.7)\n", + " \n", + " # Styling\n", + " ax.set_xlabel('Total Block + Blob Size (MB)', fontsize=12, fontweight='bold')\n", + " ax.set_ylabel('P66 Head Time (ms)', fontsize=12, fontweight='bold')\n", + " ax.set_title(title, fontsize=14)\n", + " ax.grid(True, alpha=0.3)\n", + " ax.legend(loc='upper left', fontsize=10)\n", + " ax.set_xlim(0, 3.5)\n", + " ax.set_ylim(0, 6000)\n", + "\n", + "# Add title to title axes\n", + "title_ax.text(0.5, 0.5, 'Relationship between Block Size and P66 Head Time', \n", + " ha='center', va='center', fontsize=16, fontweight='bold')\n", + "\n", + "# Load and add logos\n", + "ethpandaops_logo = plt.imread('./content/ethpandaops.png')\n", + "xatu_logo = plt.imread('./content/xatu.png')\n", + "\n", + "# Add logos to title area\n", + "logo_size = 0.06\n", + "# Ethpandaops logo on left\n", + "logo_ax1 = fig.add_axes([0.05, 0.90, logo_size, logo_size])\n", + "logo_ax1.imshow(ethpandaops_logo)\n", + "logo_ax1.axis('off')\n", + "\n", + "text_ax1 = fig.add_axes([0.05, 0.88, logo_size, 0.02])\n", + "text_ax1.text(0.5, 0.5, 'ethpandaops.io', ha='center', va='center', fontsize=10, fontweight='bold')\n", + "text_ax1.axis('off')\n", + "\n", + "# Xatu logo on right\n", + "logo_ax2 = fig.add_axes([0.89, 0.90, logo_size, logo_size])\n", + "logo_ax2.imshow(xatu_logo)\n", + "logo_ax2.axis('off')\n", + "\n", + "text_ax2 = fig.add_axes([0.89, 0.88, logo_size, 0.02])\n", + "text_ax2.text(0.5, 0.5, 'Data from Xatu', ha='center', va='center', fontsize=10, fontweight='bold')\n", + "text_ax2.axis('off')\n", + "\n", + "plt.subplots_adjust(top=0.87)\n", + "plt.show()" ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Save p66 data for future analysis\n", + "p66_df.to_csv('./blob-predictions/p66_head_times.csv', index=False)\n", + "\n", + "# Summary statistics\n", + "stats_text = \"Overall P66 Head Time Statistics:\\n\" + \"=\"*50\n", + "for node_group in ['all', 'ethpandaops', 'homeusers']:\n", + " p66_col = f'p66_{node_group}'\n", + " stats_text += f\"\\n\\n{node_group.upper()} NODES:\"\n", + " stats_text += f\"\\n Median: {p66_df[p66_col].median():.0f} ms\"\n", + " stats_text += f\"\\n Mean: {p66_df[p66_col].mean():.0f} ms\"\n", + " stats_text += f\"\\n P25: {p66_df[p66_col].quantile(0.25):.0f} ms\"\n", + " stats_text += f\"\\n P75: {p66_df[p66_col].quantile(0.75):.0f} ms\"\n", + " stats_text += f\"\\n P95: {p66_df[p66_col].quantile(0.95):.0f} ms\"\n", + " stats_text += f\"\\n P99: {p66_df[p66_col].quantile(0.99):.0f} ms\"\n", + " \n", + " # Percentage meeting attestation deadline\n", + " pct_under_4s = (p66_df[p66_col] < 4000).sum() / len(p66_df[p66_col].dropna()) * 100\n", + " stats_text += f\"\\n % under 4s deadline: {pct_under_4s:.1f}%\"\n", + "\n", + "# Data contributors summary\n", + "contributors_text = \"\\n\\nData Contributors Summary:\\n\" + \"=\"*50\n", + "\n", + "# Count unique contributors\n", + "unique_nodes = arrival_data['meta_client_name'].nunique()\n", + "unique_countries = arrival_data['country'].nunique()\n", + "\n", + "# Get country distribution\n", + "country_counts = arrival_data.groupby('country')['meta_client_name'].nunique().sort_values(ascending=False)\n", + "top_countries = country_counts.head(10)\n", + "\n", + "# Count by node group\n", + "ethpandaops_nodes = arrival_data[arrival_data['observed_by_group'] == 'ethpandaops']['meta_client_name'].nunique()\n", + "home_user_nodes = arrival_data[arrival_data['observed_by_group'] == 'home users']['meta_client_name'].nunique()\n", + "\n", + "# Get regional distribution (continents based on countries)\n", + "region_mapping = {\n", + " 'United States': 'North America',\n", + " 'Canada': 'North America',\n", + " 'Mexico': 'North America',\n", + " 'Germany': 'Europe',\n", + " 'France': 'Europe',\n", + " 'United Kingdom': 'Europe',\n", + " 'Italy': 'Europe',\n", + " 'Spain': 'Europe',\n", + " 'Belgium': 'Europe',\n", + " 'Austria': 'Europe',\n", + " 'Poland': 'Europe',\n", + " 'Czechia': 'Europe',\n", + " 'Croatia': 'Europe',\n", + " 'Slovenia': 'Europe',\n", + " 'Hungary': 'Europe',\n", + " 'Portugal': 'Europe',\n", + " 'Bulgaria': 'Europe',\n", + " 'Australia': 'Oceania',\n", + " 'New Zealand': 'Oceania',\n", + " 'Brazil': 'South America',\n", + " 'Singapore': 'Asia',\n", + " 'India': 'Asia',\n", + " 'Thailand': 'Asia',\n", + " 'Kuwait': 'Asia',\n", + " 'South Africa': 'Africa',\n", + " 'Nigeria': 'Africa'\n", + "}\n", + "\n", + "arrival_data['region'] = arrival_data['country'].map(region_mapping)\n", + "unique_regions = arrival_data['region'].nunique()\n", + "\n", + "contributors_text += f\"\\n\\nTotal unique nodes: {unique_nodes:,}\"\n", + "contributors_text += f\"\\n - EthPandaOps nodes: {ethpandaops_nodes:,}\"\n", + "contributors_text += f\"\\n - Home user nodes: {home_user_nodes:,}\"\n", + "contributors_text += f\"\\n\\nTotal countries: {unique_countries}\"\n", + "contributors_text += f\"\\nTotal regions: {unique_regions}\"\n", + "\n", + "contributors_text += f\"\\n\\nTop 10 countries by node count:\"\n", + "for country, count in top_countries.items():\n", + " contributors_text += f\"\\n - {country}: {count:,} nodes\"\n", + "\n", + "# Region summary\n", + "region_counts = arrival_data.groupby('region')['meta_client_name'].nunique().sort_values(ascending=False)\n", + "contributors_text += f\"\\n\\nNodes by region:\"\n", + "for region, count in region_counts.items():\n", + " if pd.notna(region):\n", + " contributors_text += f\"\\n - {region}: {count:,} nodes\"\n", + "\n", + "# Total observations\n", + "total_observations = len(arrival_data)\n", + "contributors_text += f\"\\n\\nTotal block arrival observations: {total_observations:,}\"\n", + "contributors_text += f\"\\nUnique slots observed: {arrival_data['slot'].nunique():,}\"\n", + "\n", + "print(stats_text)\n", + "print(contributors_text)" + ] + }, + { + "cell_type": "code", + "execution_count": 128, "metadata": {}, "outputs": [], "source": [ @@ -1516,12 +1578,15 @@ "for i, (size_mb, fig) in enumerate(figures):\n", " metadata = fig.metadata\n", " # Create subdirectory if it doesn't exist\n", - " subdir = os.path.join(output_dir, metadata[\"features\"])\n", - " os.makedirs(subdir, exist_ok=True)\n", " \n", - " # Clean filename by replacing spaces with underscores\n", - " clean_filename = f'block_arrival_trend_{metadata[\"entity\"]}_{metadata[\"block_size\"]}_{metadata[\"is_mev\"]}_{metadata[\"observed_by\"]}'.replace(' ', '_')\n", - " filename = os.path.join(subdir, f'{clean_filename}.png')\n", + " # Create clean filename components\n", + " entity = metadata[\"entity\"].lower().replace(' ', '_')\n", + " block_size = str(metadata[\"block_size\"]).replace('.', 'p')\n", + " mev_flag = 'mev' if metadata[\"is_mev\"] else 'local' if metadata[\"is_mev\"] is not None else 'all'\n", + " observed_by = metadata[\"observed_by\"].lower().replace(' ', '_')\n", + " \n", + " clean_filename = f'block_arrival_{entity}_{block_size}mb_{mev_flag}_{observed_by}'\n", + " filename = os.path.join(output_dir, f'{clean_filename}.png')\n", " \n", " fig.savefig(filename, bbox_inches='tight', dpi=300)\n" ] @@ -1529,7 +1594,7 @@ ], "metadata": { "kernelspec": { - "display_name": ".venv", + "display_name": "ldm", "language": "python", "name": "python3" }, @@ -1543,7 +1608,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.4" + "version": "3.10.5" } }, "nbformat": 4, diff --git a/config/environments.yaml b/config/environments.yaml new file mode 100644 index 00000000..e88e95b1 --- /dev/null +++ b/config/environments.yaml @@ -0,0 +1,47 @@ +environments: + staging: + clickhouse: + default: + host: clickhouse.staging.example.com + port: 8123 + user: exporter_staging + password_env: CLICKHOUSE_STAGING_PASSWORD # From env var + experimental: + host: clickhouse.experimental-staging.example.com + port: 8123 + user: exporter_staging + password_env: EXPERIMENTAL_CLICKHOUSE_STAGING_PASSWORD + storage: + endpoint: https://xxx.r2.cloudflarestorage.com + bucket: xatu-staging + access_key_env: STAGING_AWS_ACCESS_KEY_ID + secret_key_env: STAGING_AWS_SECRET_ACCESS_KEY + public_url: https://staging-data.ethpandaops.io + + production: + clickhouse: + default: + host: chendpoint-xatu-clickhouse + port: 8123 + user: exporter + password_env: CLICKHOUSE_PASSWORD + experimental: + host: clickhouse.xatu-experimental.ethpandaops.io + port: 8123 + user: default + password_env: EXPERIMENTAL_CLICKHOUSE_PASSWORD + storage: + endpoint: https://xxx.r2.cloudflarestorage.com + bucket: xatu-public + access_key_env: AWS_ACCESS_KEY_ID + secret_key_env: AWS_SECRET_ACCESS_KEY + public_url: https://data.ethpandaops.io + +# Define which ClickHouse clusters export to which storage +export_mappings: + - source: staging.default + destination: staging + - source: production.experimental + destination: staging + - source: production.default + destination: production \ No newline at end of file diff --git a/config/tables.yaml b/config/tables.yaml new file mode 100644 index 00000000..a450ee75 --- /dev/null +++ b/config/tables.yaml @@ -0,0 +1,849 @@ +table_groups: + daily: + - name: beacon_api_eth_v1_events_block + database: default + networks: + - name: mainnet + start_date: "2020-12-01" + - name: holesky + start_date: "2023-12-24" + - name: sepolia + start_date: "2023-12-24" + partition: + column: slot_start_date_time + type: daily + lag_days: 0 + redacted_columns: + meta_client_ip: "CAST('0.0.0.0' AS IPv6)" + meta_client_geo_longitude: "CAST(0 AS Float64)" + meta_client_geo_latitude: "CAST(0 AS Float64)" + meta_client_geo_city: "CAST('' AS String)" + meta_client_geo_country: "CAST('' AS String)" + meta_client_geo_country_code: "CAST('' AS String)" + meta_client_geo_continent_code: "CAST('' AS String)" + + - name: beacon_api_eth_v1_events_chain_reorg + database: default + networks: + - name: mainnet + start_date: "2020-12-01" + - name: holesky + start_date: "2023-12-24" + - name: sepolia + start_date: "2023-12-24" + partition: + column: slot_start_date_time + type: daily + lag_days: 0 + redacted_columns: + meta_client_ip: "CAST('0.0.0.0' AS IPv6)" + meta_client_geo_longitude: "CAST(0 AS Float64)" + meta_client_geo_latitude: "CAST(0 AS Float64)" + meta_client_geo_city: "CAST('' AS String)" + meta_client_geo_country: "CAST('' AS String)" + meta_client_geo_country_code: "CAST('' AS String)" + meta_client_geo_continent_code: "CAST('' AS String)" + + - name: beacon_api_eth_v1_events_finalized_checkpoint + database: default + networks: + - name: mainnet + start_date: "2020-12-01" + - name: holesky + start_date: "2023-12-24" + - name: sepolia + start_date: "2023-12-24" + partition: + column: slot_start_date_time + type: daily + lag_days: 0 + redacted_columns: + meta_client_ip: "CAST('0.0.0.0' AS IPv6)" + meta_client_geo_longitude: "CAST(0 AS Float64)" + meta_client_geo_latitude: "CAST(0 AS Float64)" + meta_client_geo_city: "CAST('' AS String)" + meta_client_geo_country: "CAST('' AS String)" + meta_client_geo_country_code: "CAST('' AS String)" + meta_client_geo_continent_code: "CAST('' AS String)" + + - name: beacon_api_eth_v1_events_head + database: default + networks: + - name: mainnet + start_date: "2020-12-01" + - name: holesky + start_date: "2023-12-24" + - name: sepolia + start_date: "2023-12-24" + partition: + column: slot_start_date_time + type: daily + lag_days: 0 + redacted_columns: + meta_client_ip: "CAST('0.0.0.0' AS IPv6)" + meta_client_geo_longitude: "CAST(0 AS Float64)" + meta_client_geo_latitude: "CAST(0 AS Float64)" + meta_client_geo_city: "CAST('' AS String)" + meta_client_geo_country: "CAST('' AS String)" + meta_client_geo_country_code: "CAST('' AS String)" + meta_client_geo_continent_code: "CAST('' AS String)" + + - name: beacon_api_eth_v1_events_voluntary_exit + database: default + networks: + - name: mainnet + start_date: "2020-12-01" + - name: holesky + start_date: "2023-12-24" + - name: sepolia + start_date: "2023-12-24" + partition: + column: slot_start_date_time + type: daily + lag_days: 0 + redacted_columns: + meta_client_ip: "CAST('0.0.0.0' AS IPv6)" + meta_client_geo_longitude: "CAST(0 AS Float64)" + meta_client_geo_latitude: "CAST(0 AS Float64)" + meta_client_geo_city: "CAST('' AS String)" + meta_client_geo_country: "CAST('' AS String)" + meta_client_geo_country_code: "CAST('' AS String)" + meta_client_geo_continent_code: "CAST('' AS String)" + + - name: beacon_api_eth_v1_proposer_duty + database: default + networks: + - name: mainnet + start_date: "2020-12-01" + - name: holesky + start_date: "2023-12-24" + - name: sepolia + start_date: "2023-12-24" + partition: + column: slot_start_date_time + type: daily + lag_days: 0 + redacted_columns: + meta_client_ip: "CAST('0.0.0.0' AS IPv6)" + meta_client_geo_longitude: "CAST(0 AS Float64)" + meta_client_geo_latitude: "CAST(0 AS Float64)" + meta_client_geo_city: "CAST('' AS String)" + meta_client_geo_country: "CAST('' AS String)" + meta_client_geo_country_code: "CAST('' AS String)" + meta_client_geo_continent_code: "CAST('' AS String)" + + - name: beacon_api_eth_v1_validator_attestation_data + database: default + networks: + - name: mainnet + start_date: "2020-12-01" + - name: holesky + start_date: "2023-12-24" + - name: sepolia + start_date: "2023-12-24" + partition: + column: slot_start_date_time + type: daily + lag_days: 0 + redacted_columns: + meta_client_ip: "CAST('0.0.0.0' AS IPv6)" + meta_client_geo_longitude: "CAST(0 AS Float64)" + meta_client_geo_latitude: "CAST(0 AS Float64)" + meta_client_geo_city: "CAST('' AS String)" + meta_client_geo_country: "CAST('' AS String)" + meta_client_geo_country_code: "CAST('' AS String)" + meta_client_geo_continent_code: "CAST('' AS String)" + + - name: beacon_api_eth_v2_beacon_block + database: default + networks: + - name: mainnet + start_date: "2020-12-01" + - name: holesky + start_date: "2023-12-24" + - name: sepolia + start_date: "2023-12-24" + partition: + column: slot_start_date_time + type: daily + lag_days: 0 + redacted_columns: + meta_client_ip: "CAST('0.0.0.0' AS IPv6)" + meta_client_geo_longitude: "CAST(0 AS Float64)" + meta_client_geo_latitude: "CAST(0 AS Float64)" + meta_client_geo_city: "CAST('' AS String)" + meta_client_geo_country: "CAST('' AS String)" + meta_client_geo_country_code: "CAST('' AS String)" + meta_client_geo_continent_code: "CAST('' AS String)" + + - name: beacon_api_eth_v3_validator_block + database: default + networks: + - name: mainnet + start_date: "2020-12-01" + - name: holesky + start_date: "2023-12-24" + - name: sepolia + start_date: "2023-12-24" + partition: + column: slot_start_date_time + type: daily + lag_days: 0 + redacted_columns: + meta_client_ip: "CAST('0.0.0.0' AS IPv6)" + meta_client_geo_longitude: "CAST(0 AS Float64)" + meta_client_geo_latitude: "CAST(0 AS Float64)" + meta_client_geo_city: "CAST('' AS String)" + meta_client_geo_country: "CAST('' AS String)" + meta_client_geo_country_code: "CAST('' AS String)" + meta_client_geo_continent_code: "CAST('' AS String)" + + - name: canonical_beacon_block + database: default + networks: + - name: mainnet + start_date: "2020-12-01" + - name: holesky + start_date: "2023-12-24" + - name: sepolia + start_date: "2023-12-24" + partition: + column: slot_start_date_time + type: daily + lag_days: 0 + + - name: canonical_beacon_blob_sidecar + database: default + networks: + - name: mainnet + start_date: "2024-03-13" + - name: holesky + start_date: "2024-02-07" + - name: sepolia + start_date: "2024-01-30" + partition: + column: slot_start_date_time + type: daily + lag_days: 0 + + - name: canonical_beacon_proposer_duty + database: default + networks: + - name: mainnet + start_date: "2020-12-01" + - name: holesky + start_date: "2023-12-24" + - name: sepolia + start_date: "2023-12-24" + partition: + column: slot_start_date_time + type: daily + lag_days: 0 + + - name: canonical_beacon_elaborated_attestation + database: default + networks: + - name: mainnet + start_date: "2020-12-01" + - name: holesky + start_date: "2023-12-24" + - name: sepolia + start_date: "2023-12-24" + partition: + column: slot_start_date_time + type: daily + lag_days: 0 + + - name: libp2p_gossipsub_beacon_block + database: default + networks: + - name: mainnet + start_date: "2020-12-01" + - name: holesky + start_date: "2023-12-24" + - name: sepolia + start_date: "2023-12-24" + partition: + column: slot_start_date_time + type: daily + lag_days: 0 + redacted_columns: + meta_client_peer_id: "CAST('REDACTED' AS String)" + meta_client_geo_longitude: "CAST(0 AS Float64)" + meta_client_geo_latitude: "CAST(0 AS Float64)" + meta_client_geo_city: "CAST('' AS String)" + meta_client_geo_country: "CAST('' AS String)" + meta_client_geo_country_code: "CAST('' AS String)" + meta_client_geo_continent_code: "CAST('' AS String)" + + - name: mev_relay_bid_trace + database: default + networks: + - name: mainnet + start_date: "2023-04-24" + - name: holesky + start_date: "2024-02-20" + - name: sepolia + start_date: "2024-02-20" + partition: + column: slot_start_date_time + type: daily + lag_days: 0 + + - name: mev_relay_proposer_payload_delivered + database: default + networks: + - name: mainnet + start_date: "2023-04-24" + - name: holesky + start_date: "2024-02-20" + - name: sepolia + start_date: "2024-02-20" + partition: + column: slot_start_date_time + type: daily + lag_days: 0 + + - name: mev_relay_validator_registration + database: default + networks: + - name: mainnet + start_date: "2023-04-24" + - name: holesky + start_date: "2024-02-20" + - name: sepolia + start_date: "2024-02-20" + partition: + column: request_start_date_time + type: daily + lag_days: 0 + + hourly: + - name: beacon_api_eth_v1_events_attestation + database: default + networks: + - name: mainnet + start_date: "2020-12-01" + - name: holesky + start_date: "2023-12-24" + - name: sepolia + start_date: "2023-12-24" + partition: + column: slot_start_date_time + type: hourly + lag_hours: 0 + redacted_columns: + meta_client_ip: "CAST('0.0.0.0' AS IPv6)" + meta_client_geo_longitude: "CAST(0 AS Float64)" + meta_client_geo_latitude: "CAST(0 AS Float64)" + meta_client_geo_city: "CAST('' AS String)" + meta_client_geo_country: "CAST('' AS String)" + meta_client_geo_country_code: "CAST('' AS String)" + meta_client_geo_continent_code: "CAST('' AS String)" + + - name: beacon_api_eth_v1_events_blob_sidecar + database: default + networks: + - name: mainnet + start_date: "2024-03-13" + - name: holesky + start_date: "2024-02-07" + - name: sepolia + start_date: "2024-01-30" + partition: + column: slot_start_date_time + type: hourly + lag_hours: 0 + redacted_columns: + meta_client_ip: "CAST('0.0.0.0' AS IPv6)" + meta_client_geo_longitude: "CAST(0 AS Float64)" + meta_client_geo_latitude: "CAST(0 AS Float64)" + meta_client_geo_city: "CAST('' AS String)" + meta_client_geo_country: "CAST('' AS String)" + meta_client_geo_country_code: "CAST('' AS String)" + meta_client_geo_continent_code: "CAST('' AS String)" + + - name: beacon_api_eth_v1_events_contribution_and_proof + database: default + networks: + - name: mainnet + start_date: "2020-12-01" + - name: holesky + start_date: "2023-12-24" + - name: sepolia + start_date: "2023-12-24" + partition: + column: contribution_slot_start_date_time + type: hourly + lag_hours: 0 + redacted_columns: + meta_client_ip: "CAST('0.0.0.0' AS IPv6)" + meta_client_geo_longitude: "CAST(0 AS Float64)" + meta_client_geo_latitude: "CAST(0 AS Float64)" + meta_client_geo_city: "CAST('' AS String)" + meta_client_geo_country: "CAST('' AS String)" + meta_client_geo_country_code: "CAST('' AS String)" + meta_client_geo_continent_code: "CAST('' AS String)" + + - name: beacon_api_eth_v1_beacon_committee + database: default + networks: + - name: mainnet + start_date: "2020-12-01" + - name: holesky + start_date: "2023-12-24" + - name: sepolia + start_date: "2023-12-24" + partition: + column: slot_start_date_time + type: hourly + lag_hours: 0 + redacted_columns: + meta_client_ip: "CAST('0.0.0.0' AS IPv6)" + meta_client_geo_longitude: "CAST(0 AS Float64)" + meta_client_geo_latitude: "CAST(0 AS Float64)" + meta_client_geo_city: "CAST('' AS String)" + meta_client_geo_country: "CAST('' AS String)" + meta_client_geo_country_code: "CAST('' AS String)" + meta_client_geo_continent_code: "CAST('' AS String)" + + - name: canonical_beacon_committee + database: default + networks: + - name: mainnet + start_date: "2020-12-01" + - name: holesky + start_date: "2023-12-24" + - name: sepolia + start_date: "2023-12-24" + partition: + column: slot_start_date_time + type: hourly + lag_hours: 0 + + - name: libp2p_gossipsub_beacon_attestation + database: default + networks: + - name: mainnet + start_date: "2020-12-01" + - name: holesky + start_date: "2023-12-24" + - name: sepolia + start_date: "2023-12-24" + partition: + column: slot_start_date_time + type: hourly + lag_hours: 0 + redacted_columns: + meta_client_peer_id: "CAST('REDACTED' AS String)" + meta_client_geo_longitude: "CAST(0 AS Float64)" + meta_client_geo_latitude: "CAST(0 AS Float64)" + meta_client_geo_city: "CAST('' AS String)" + meta_client_geo_country: "CAST('' AS String)" + meta_client_geo_country_code: "CAST('' AS String)" + meta_client_geo_continent_code: "CAST('' AS String)" + + - name: libp2p_gossipsub_blob_sidecar + database: default + networks: + - name: mainnet + start_date: "2024-03-13" + - name: holesky + start_date: "2024-02-07" + - name: sepolia + start_date: "2024-01-30" + partition: + column: slot_start_date_time + type: hourly + lag_hours: 0 + redacted_columns: + meta_client_peer_id: "CAST('REDACTED' AS String)" + meta_client_geo_longitude: "CAST(0 AS Float64)" + meta_client_geo_latitude: "CAST(0 AS Float64)" + meta_client_geo_city: "CAST('' AS String)" + meta_client_geo_country: "CAST('' AS String)" + meta_client_geo_country_code: "CAST('' AS String)" + meta_client_geo_continent_code: "CAST('' AS String)" + + - name: mempool_transaction + database: default + networks: + - name: mainnet + start_date: "2023-08-02" + - name: holesky + start_date: "2023-12-24" + - name: sepolia + start_date: "2023-12-24" + partition: + column: event_date_time + type: hourly + lag_hours: 0 + redacted_columns: + meta_client_ip: "CAST('0.0.0.0' AS IPv6)" + meta_client_geo_longitude: "CAST(0 AS Float64)" + meta_client_geo_latitude: "CAST(0 AS Float64)" + meta_client_geo_city: "CAST('' AS String)" + meta_client_geo_country: "CAST('' AS String)" + meta_client_geo_country_code: "CAST('' AS String)" + meta_client_geo_continent_code: "CAST('' AS String)" + + chunked: + - name: canonical_execution_block + database: default + networks: + - name: mainnet + start_index: 21010000 + - name: holesky + start_index: 2100000 + - name: sepolia + start_index: 6000000 + partition: + column: block_number + type: integer + chunk_size: 1000 + lag_interval: 0 + + - name: canonical_execution_transaction + database: default + networks: + - name: mainnet + start_index: 21010000 + - name: holesky + start_index: 2100000 + - name: sepolia + start_index: 6000000 + partition: + column: block_number + type: integer + chunk_size: 1000 + lag_interval: 0 + + - name: canonical_execution_address_appearances + database: default + networks: + - name: mainnet + start_index: 21010000 + - name: holesky + start_index: 2100000 + - name: sepolia + start_index: 6000000 + partition: + column: block_number + type: integer + chunk_size: 1000 + lag_interval: 0 + + - name: canonical_execution_balance_diffs + database: default + networks: + - name: mainnet + start_index: 21010000 + - name: holesky + start_index: 2100000 + - name: sepolia + start_index: 6000000 + partition: + column: block_number + type: integer + chunk_size: 1000 + lag_interval: 0 + + - name: canonical_execution_balance_reads + database: default + networks: + - name: mainnet + start_index: 21010000 + - name: holesky + start_index: 2100000 + - name: sepolia + start_index: 6000000 + partition: + column: block_number + type: integer + chunk_size: 1000 + lag_interval: 0 + + - name: canonical_execution_contracts + database: default + networks: + - name: mainnet + start_index: 21010000 + - name: holesky + start_index: 2100000 + - name: sepolia + start_index: 6000000 + partition: + column: block_number + type: integer + chunk_size: 1000 + lag_interval: 0 + + - name: canonical_execution_erc20_transfers + database: default + networks: + - name: mainnet + start_index: 21010000 + - name: holesky + start_index: 2100000 + - name: sepolia + start_index: 6000000 + partition: + column: block_number + type: integer + chunk_size: 1000 + lag_interval: 0 + + - name: canonical_execution_erc721_transfers + database: default + networks: + - name: mainnet + start_index: 21010000 + - name: holesky + start_index: 2100000 + - name: sepolia + start_index: 6000000 + partition: + column: block_number + type: integer + chunk_size: 1000 + lag_interval: 0 + + - name: canonical_execution_four_byte_counts + database: default + networks: + - name: mainnet + start_index: 21010000 + - name: holesky + start_index: 2100000 + - name: sepolia + start_index: 6000000 + partition: + column: block_number + type: integer + chunk_size: 1000 + lag_interval: 0 + + - name: canonical_execution_logs + database: default + networks: + - name: mainnet + start_index: 21010000 + - name: holesky + start_index: 2100000 + - name: sepolia + start_index: 6000000 + partition: + column: block_number + type: integer + chunk_size: 1000 + lag_interval: 0 + + - name: canonical_execution_native_transfers + database: default + networks: + - name: mainnet + start_index: 21010000 + - name: holesky + start_index: 2100000 + - name: sepolia + start_index: 6000000 + partition: + column: block_number + type: integer + chunk_size: 1000 + lag_interval: 0 + + - name: canonical_execution_nonce_diffs + database: default + networks: + - name: mainnet + start_index: 21010000 + - name: holesky + start_index: 2100000 + - name: sepolia + start_index: 6000000 + partition: + column: block_number + type: integer + chunk_size: 1000 + lag_interval: 0 + + - name: canonical_execution_nonce_reads + database: default + networks: + - name: mainnet + start_index: 21010000 + - name: holesky + start_index: 2100000 + - name: sepolia + start_index: 6000000 + partition: + column: block_number + type: integer + chunk_size: 1000 + lag_interval: 0 + + - name: canonical_execution_storage_diffs + database: default + networks: + - name: mainnet + start_index: 21010000 + - name: holesky + start_index: 2100000 + - name: sepolia + start_index: 6000000 + partition: + column: block_number + type: integer + chunk_size: 1000 + lag_interval: 0 + + - name: canonical_execution_storage_reads + database: default + networks: + - name: mainnet + start_index: 21010000 + - name: holesky + start_index: 2100000 + - name: sepolia + start_index: 6000000 + partition: + column: block_number + type: integer + chunk_size: 1000 + lag_interval: 0 + + - name: canonical_execution_traces + database: default + networks: + - name: mainnet + start_index: 21010000 + - name: holesky + start_index: 2100000 + - name: sepolia + start_index: 6000000 + partition: + column: block_number + type: integer + chunk_size: 1000 + lag_interval: 0 + + - name: canonical_beacon_block_attester_slashing + database: default + networks: + - name: mainnet + start_index: 0 + - name: holesky + start_index: 0 + - name: sepolia + start_index: 0 + partition: + column: inclusion_slot + type: integer + chunk_size: 32768 # ~9 days of slots + lag_interval: 0 + + - name: canonical_beacon_block_bls_to_execution_change + database: default + networks: + - name: mainnet + start_index: 0 + - name: holesky + start_index: 0 + - name: sepolia + start_index: 0 + partition: + column: inclusion_slot + type: integer + chunk_size: 32768 + lag_interval: 0 + + - name: canonical_beacon_block_deposit + database: default + networks: + - name: mainnet + start_index: 0 + - name: holesky + start_index: 0 + - name: sepolia + start_index: 0 + partition: + column: inclusion_slot + type: integer + chunk_size: 32768 + lag_interval: 0 + + - name: canonical_beacon_block_proposer_slashing + database: default + networks: + - name: mainnet + start_index: 0 + - name: holesky + start_index: 0 + - name: sepolia + start_index: 0 + partition: + column: inclusion_slot + type: integer + chunk_size: 32768 + lag_interval: 0 + + - name: canonical_beacon_block_voluntary_exit + database: default + networks: + - name: mainnet + start_index: 0 + - name: holesky + start_index: 0 + - name: sepolia + start_index: 0 + partition: + column: inclusion_slot + type: integer + chunk_size: 32768 + lag_interval: 0 + + - name: canonical_beacon_block_withdrawal + database: default + networks: + - name: mainnet + start_index: 6600000 + - name: holesky + start_index: 0 + - name: sepolia + start_index: 0 + partition: + column: inclusion_slot + type: integer + chunk_size: 32768 + lag_interval: 0 + + - name: canonical_beacon_block_execution_transaction + database: default + networks: + - name: mainnet + start_index: 4700000 + - name: holesky + start_index: 0 + - name: sepolia + start_index: 0 + partition: + column: inclusion_slot + type: integer + chunk_size: 32768 + lag_interval: 0 + + - name: canonical_beacon_validators + database: default + networks: + - name: mainnet + start_index: 0 + - name: holesky + start_index: 0 + - name: sepolia + start_index: 0 + partition: + column: validator_index + type: integer + chunk_size: 10000 + lag_interval: 0 \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 00000000..81447d16 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,33 @@ +[build-system] +requires = ["setuptools>=65", "wheel"] +build-backend = "setuptools.build_meta" + +[project] +name = "xatu-exporter" +version = "0.1.0" +description = "Xatu data export pipeline for ClickHouse to Parquet with Iceberg metadata" +readme = "README.md" +requires-python = ">=3.9" +dependencies = [ + "click>=8.1.0", + "clickhouse-connect>=0.7.0", + "boto3>=1.26.0", + "pyiceberg>=0.6.0", + "pyyaml>=6.0", + "pyarrow>=14.0.0", + "structlog>=23.1.0", + "pandas>=2.0.0", +] + +[project.optional-dependencies] +dev = [ + "pytest>=7.0.0", + "pytest-mock>=3.10.0", + "black>=23.0.0", + "ruff>=0.1.0", + "mypy>=1.0.0", +] + +[project.scripts] +xatu-export = "scripts.export_table:export_table" +xatu-export-all = "scripts.export_all:export_all" \ No newline at end of file diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..8af86419 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,8 @@ +click>=8.1.0 +clickhouse-connect>=0.7.0 +boto3>=1.26.0 +pyiceberg>=0.6.0 +pyyaml>=6.0 +pyarrow>=14.0.0 +structlog>=23.1.0 +pandas>=2.0.0 \ No newline at end of file diff --git a/scripts/__init__.py b/scripts/__init__.py new file mode 100644 index 00000000..c3644984 --- /dev/null +++ b/scripts/__init__.py @@ -0,0 +1 @@ +# CLI scripts for Xatu data export pipeline \ No newline at end of file diff --git a/scripts/backfill_iceberg.py b/scripts/backfill_iceberg.py new file mode 100755 index 00000000..b9fd1685 --- /dev/null +++ b/scripts/backfill_iceberg.py @@ -0,0 +1,243 @@ +#!/usr/bin/env python3 +import click +import logging +import sys +from datetime import datetime, timedelta +from concurrent.futures import ThreadPoolExecutor, as_completed +from pathlib import Path +import json + +# Add parent directory to path +sys.path.insert(0, str(Path(__file__).parent.parent)) + +from src.storage import R2Storage +from src.iceberg_manager import IcebergManager + + +def setup_logging(verbose: bool): + """Configure logging based on verbosity""" + level = logging.DEBUG if verbose else logging.INFO + logging.basicConfig( + level=level, + format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', + datefmt='%Y-%m-%d %H:%M:%S' + ) + + +@click.command() +@click.option('--environment', '-e', required=True, + type=click.Choice(['staging', 'production']), + help='Environment to backfill') +@click.option('--table', '-t', help='Specific table to backfill') +@click.option('--network', '-n', help='Specific network to backfill') +@click.option('--start-date', type=click.DateTime(['%Y-%m-%d']), + help='Start date for backfill') +@click.option('--end-date', type=click.DateTime(['%Y-%m-%d']), + help='End date for backfill') +@click.option('--parallel', '-p', default=10, + help='Number of parallel workers') +@click.option('--dry-run', is_flag=True, + help='Show what would be done without doing it') +@click.option('--verbose', '-v', is_flag=True, + help='Enable verbose logging') +def backfill_iceberg(environment, table, network, start_date, end_date, parallel, dry_run, verbose): + """Generate Iceberg metadata for existing Parquet files + + This command scans existing Parquet files in R2 storage and generates + Iceberg metadata for them, allowing historical data to be queried via Iceberg. + + Examples: + # Backfill all tables and networks + backfill_iceberg.py -e production + + # Backfill specific table + backfill_iceberg.py -e production -t beacon_api_eth_v1_events_block + + # Backfill specific date range + backfill_iceberg.py -e production --start-date 2024-01-01 --end-date 2024-01-31 + + # Dry run to see what would be backfilled + backfill_iceberg.py -e staging --dry-run + """ + setup_logging(verbose) + logger = logging.getLogger(__name__) + + try: + if dry_run: + click.echo("🔍 Running in DRY RUN mode - no metadata will be created") + + click.echo(f"📊 Backfilling Iceberg metadata for {environment}") + + # Load configuration + config_path = Path(__file__).parent.parent / 'config' + with open(config_path / 'environments.yaml') as f: + import yaml + env_config = yaml.safe_load(f) + + with open(config_path / 'tables.yaml') as f: + table_config = yaml.safe_load(f) + + # Get storage configuration + storage_config = env_config['environments'][environment]['storage'] + storage = R2Storage(storage_config) + iceberg = IcebergManager(storage_config, dry_run=dry_run) + + # Determine which tables to backfill + tables_to_backfill = [] + for group_name, group_tables in table_config['table_groups'].items(): + for table_info in group_tables: + if table and table_info['name'] != table: + continue + + for network_info in table_info['networks']: + if network and network_info['name'] != network: + continue + + tables_to_backfill.append({ + 'table': table_info['name'], + 'network': network_info['name'], + 'database': table_info.get('database', 'default'), + 'partition_type': table_info['partition']['type'], + 'start_date': network_info.get('start_date'), + 'start_index': network_info.get('start_index') + }) + + click.echo(f"Found {len(tables_to_backfill)} table/network combinations to backfill") + + # Process each table/network combination + total_files = 0 + with ThreadPoolExecutor(max_workers=parallel) as executor: + futures = [] + + for table_info in tables_to_backfill: + future = executor.submit( + backfill_table_network, + storage, iceberg, table_info, start_date, end_date, dry_run + ) + futures.append(future) + + # Wait for completion + with click.progressbar( + as_completed(futures), + length=len(futures), + label='Backfilling tables' + ) as bar: + for future in bar: + try: + count = future.result() + total_files += count + except Exception as e: + logger.error(f"Backfill failed: {e}") + + click.echo(f"\n✅ Backfilled metadata for {total_files} files") + + except Exception as e: + click.echo(f"❌ Error: {e}", err=True) + if verbose: + import traceback + traceback.print_exc() + sys.exit(1) + + +def backfill_table_network(storage, iceberg, table_info, start_date, end_date, dry_run): + """Backfill a single table/network combination""" + logger = logging.getLogger(__name__) + + table_name = table_info['table'] + network = table_info['network'] + database = table_info['database'] + + logger.info(f"Backfilling {table_name}/{network}") + + # List existing Parquet files + prefix = f"xatu/{network}/databases/{database}/{table_name}/" + existing_files = storage.list_files(prefix) + + # Filter to only Parquet files + parquet_files = [f for f in existing_files if f.endswith('.parquet')] + + # Filter by date range if specified + if start_date or end_date: + filtered_files = [] + for file_path in parquet_files: + # Extract date from path (depends on partition structure) + if 'partition_date=' in file_path: + date_part = file_path.split('partition_date=')[1].split('/')[0] + try: + file_date = datetime.strptime(date_part, '%Y-%m-%d') + if start_date and file_date < start_date: + continue + if end_date and file_date > end_date: + continue + filtered_files.append(file_path) + except: + pass + else: + filtered_files.append(file_path) + parquet_files = filtered_files + + logger.info(f"Found {len(parquet_files)} Parquet files to backfill") + + # Get existing files from Iceberg metadata + existing_in_iceberg = iceberg.get_existing_files(table_name, network) + + # Determine which files need to be added + files_to_add = [] + for file_path in parquet_files: + if file_path not in existing_in_iceberg: + files_to_add.append(file_path) + + logger.info(f"Need to add {len(files_to_add)} files to Iceberg metadata") + + # Process each file + for file_path in files_to_add: + try: + # Extract partition value from path + partition_value = extract_partition_value(file_path, table_info['partition_type']) + + # Get file metadata + file_metadata = storage.get_file_metadata(file_path) + if not file_metadata: + logger.warning(f"Could not get metadata for {file_path}") + continue + + # Register with Iceberg + iceberg.register_file( + table_name, network, file_path, partition_value, + { + 'file_size': file_metadata['size'], + 'row_count': 0, # Would need to read Parquet metadata for actual count + 'export_time': file_metadata['last_modified'].isoformat() + } + ) + + except Exception as e: + logger.error(f"Failed to backfill {file_path}: {e}") + + # Update catalog + if not dry_run and files_to_add: + iceberg.update_catalog(table_name, network) + + return len(files_to_add) + + +def extract_partition_value(file_path, partition_type): + """Extract partition value from file path""" + if partition_type == 'daily': + if 'partition_date=' in file_path: + return file_path.split('partition_date=')[1].split('/')[0] + elif partition_type == 'hourly': + if 'partition_date=' in file_path and 'partition_hour=' in file_path: + date_part = file_path.split('partition_date=')[1].split('/')[0] + hour_part = file_path.split('partition_hour=')[1].split('/')[0] + return f"{date_part}/{hour_part}" + elif partition_type == 'integer': + if 'partition_chunk=' in file_path: + return file_path.split('partition_chunk=')[1].split('/')[0] + + # Fallback + return Path(file_path).parent.name + + +if __name__ == '__main__': + backfill_iceberg() \ No newline at end of file diff --git a/scripts/export_all.py b/scripts/export_all.py new file mode 100755 index 00000000..d5e85cd1 --- /dev/null +++ b/scripts/export_all.py @@ -0,0 +1,147 @@ +#!/usr/bin/env python3 +import click +import logging +import sys +from datetime import datetime, timedelta +from concurrent.futures import ThreadPoolExecutor, as_completed +from pathlib import Path + +# Add parent directory to path +sys.path.insert(0, str(Path(__file__).parent.parent)) + +from src.exporter import XatuExporter + + +def setup_logging(verbose: bool): + """Configure logging based on verbosity""" + level = logging.DEBUG if verbose else logging.INFO + logging.basicConfig( + level=level, + format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', + datefmt='%Y-%m-%d %H:%M:%S' + ) + + +@click.command() +@click.option('--environment', '-e', required=True, + type=click.Choice(['staging', 'production']), + help='Environment to export from/to') +@click.option('--table-group', '-g', + type=click.Choice(['daily', 'hourly', 'chunked', 'all']), + default='all', + help='Table group to export') +@click.option('--date', '-d', type=click.DateTime(['%Y-%m-%d']), + help='Date to export (defaults to yesterday for daily, last hour for hourly)') +@click.option('--parallel', '-p', default=4, + help='Number of parallel exports') +@click.option('--dry-run', is_flag=True, + help='Show what would be done without doing it') +@click.option('--verbose', '-v', is_flag=True, + help='Enable verbose logging') +@click.option('--continue-on-error', is_flag=True, + help='Continue exporting even if some tables fail') +def export_all(environment, table_group, date, parallel, dry_run, verbose, continue_on_error): + """Export all tables for a given date/group + + Examples: + # Export all daily tables for yesterday + export_all.py -e production -g daily + + # Export all hourly tables for specific date + export_all.py -e production -g hourly -d 2024-05-30 + + # Export all table groups with high parallelism + export_all.py -e production -g all -p 10 + + # Dry run to see what would be exported + export_all.py -e staging -g daily --dry-run + """ + setup_logging(verbose) + + try: + if dry_run: + click.echo("🔍 Running in DRY RUN mode - no files will be uploaded") + + click.echo(f"📊 Exporting {table_group} tables from {environment}") + + exporter = XatuExporter(environment, dry_run=dry_run) + + # Determine which groups to export + if table_group == 'all': + groups = ['daily', 'hourly', 'chunked'] + else: + groups = [table_group] + + total_exports = 0 + successful_exports = 0 + failed_exports = 0 + + with ThreadPoolExecutor(max_workers=parallel) as executor: + # Submit export jobs + futures = [] + + for group in groups: + if group == 'daily': + export_date = date or (datetime.now() - timedelta(days=1)) + futures.extend(exporter.submit_daily_exports(executor, export_date)) + click.echo(f"📅 Submitted daily exports for {export_date.strftime('%Y-%m-%d')}") + + elif group == 'hourly': + export_date = date or (datetime.now() - timedelta(hours=1)) + futures.extend(exporter.submit_hourly_exports(executor, export_date)) + click.echo(f"🕐 Submitted hourly exports for {export_date.strftime('%Y-%m-%d %H:00')}") + + elif group == 'chunked': + futures.extend(exporter.submit_chunked_exports(executor)) + click.echo("📦 Submitted chunked exports") + + total_exports = len(futures) + click.echo(f"🚀 Running {total_exports} export jobs with {parallel} workers") + + # Wait for completion and report results + with click.progressbar( + as_completed(futures), + length=total_exports, + label='Exporting tables' + ) as bar: + for future in bar: + try: + result = future.result() + if result: + successful_exports += 1 + else: + failed_exports += 1 + except Exception as e: + failed_exports += 1 + if verbose: + click.echo(f"\n❌ Export failed: {e}", err=True) + if not continue_on_error: + raise + + # Report final results + click.echo(f"\n📈 Export Summary:") + click.echo(f" Total: {total_exports}") + click.echo(f" ✅ Success: {successful_exports}") + click.echo(f" ❌ Failed: {failed_exports}") + + if failed_exports > 0: + if continue_on_error: + click.echo(f"\n⚠️ {failed_exports} exports failed but continued due to --continue-on-error") + sys.exit(2) # Exit with warning code + else: + click.echo(f"\n❌ {failed_exports} exports failed", err=True) + sys.exit(1) + else: + click.echo("\n✅ All exports completed successfully!") + sys.exit(0) + + except Exception as e: + click.echo(f"❌ Error: {e}", err=True) + if verbose: + import traceback + traceback.print_exc() + sys.exit(1) + + +if __name__ == '__main__': + export_all() \ No newline at end of file diff --git a/scripts/export_table.py b/scripts/export_table.py new file mode 100755 index 00000000..3683e781 --- /dev/null +++ b/scripts/export_table.py @@ -0,0 +1,81 @@ +#!/usr/bin/env python3 +import click +import logging +import sys +from datetime import datetime +from pathlib import Path + +# Add parent directory to path +sys.path.insert(0, str(Path(__file__).parent.parent)) + +from src.exporter import XatuExporter + + +def setup_logging(verbose: bool): + """Configure logging based on verbosity""" + level = logging.DEBUG if verbose else logging.INFO + logging.basicConfig( + level=level, + format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', + datefmt='%Y-%m-%d %H:%M:%S' + ) + + +@click.command() +@click.option('--environment', '-e', required=True, + type=click.Choice(['staging', 'production']), + help='Environment to export from/to') +@click.option('--table', '-t', required=True, help='Table name to export') +@click.option('--network', '-n', required=True, help='Network to export') +@click.option('--date', '-d', type=click.DateTime(['%Y-%m-%d']), + help='Date to export (for daily/hourly tables)') +@click.option('--force', '-f', is_flag=True, + help='Force export even if file exists') +@click.option('--dry-run', is_flag=True, + help='Show what would be done without doing it') +@click.option('--verbose', '-v', is_flag=True, + help='Enable verbose logging') +def export_table(environment, table, network, date, force, dry_run, verbose): + """Export a single table/network combination + + Examples: + # Export yesterday's data for a daily table + export_table.py -e production -t beacon_api_eth_v1_events_block -n mainnet + + # Export specific date + export_table.py -e staging -t beacon_api_eth_v1_events_block -n mainnet -d 2024-05-30 + + # Dry run to see what would be exported + export_table.py -e production -t canonical_execution_block -n mainnet --dry-run + + # Force re-export even if files exist + export_table.py -e production -t beacon_api_eth_v1_events_block -n mainnet -f + """ + setup_logging(verbose) + + try: + if dry_run: + click.echo("🔍 Running in DRY RUN mode - no files will be uploaded") + + click.echo(f"📊 Exporting {table} for {network} from {environment}") + + exporter = XatuExporter(environment, dry_run=dry_run) + success = exporter.export_table(table, network, date, force) + + if success: + click.echo(f"✅ Successfully exported {table}/{network}") + sys.exit(0) + else: + click.echo(f"❌ Failed to export {table}/{network}", err=True) + sys.exit(1) + + except Exception as e: + click.echo(f"❌ Error: {e}", err=True) + if verbose: + import traceback + traceback.print_exc() + sys.exit(1) + + +if __name__ == '__main__': + export_table() \ No newline at end of file diff --git a/src/__init__.py b/src/__init__.py new file mode 100644 index 00000000..6b7bcca4 --- /dev/null +++ b/src/__init__.py @@ -0,0 +1,3 @@ +"""Xatu data export pipeline for ClickHouse to Parquet with Iceberg metadata.""" + +__version__ = "0.1.0" \ No newline at end of file diff --git a/src/clickhouse.py b/src/clickhouse.py new file mode 100644 index 00000000..4358f3a8 --- /dev/null +++ b/src/clickhouse.py @@ -0,0 +1,160 @@ +import os +import clickhouse_connect +from typing import Dict, Any, Optional, List +from datetime import datetime +import logging + + +class ClickHouseClient: + def __init__(self, config: Dict[str, Any]): + self.config = config + self.client = self._connect() + self.logger = logging.getLogger(__name__) + + def _connect(self): + password = os.environ.get(self.config['password_env']) + if not password: + raise ValueError(f"Password not found in {self.config['password_env']}") + + return clickhouse_connect.get_client( + host=self.config['host'], + port=self.config['port'], + username=self.config['user'], + password=password, + settings={ + 'max_block_size': 65536, + 'max_threads': 8, + 'max_memory_usage': 10 * 1024 * 1024 * 1024, # 10GB + } + ) + + def export_to_parquet(self, query: str, output_path: str, + compression: str = 'zstd') -> Dict[str, Any]: + """Export query results to Parquet file""" + # Use ClickHouse's native Parquet export + query_with_format = f"{query} FORMAT Parquet SETTINGS output_format_parquet_compression_method='{compression}'" + + # Count rows first + count_query = f"SELECT count() as cnt FROM ({query})" + row_count = self.client.query(count_query).first_row[0] + + self.logger.info(f"Exporting {row_count} rows to {output_path}") + + # Export to file + start_time = datetime.now() + with open(output_path, 'wb') as f: + # Stream results to avoid memory issues + result = self.client.raw_query(query_with_format) + f.write(result) + + export_duration = (datetime.now() - start_time).total_seconds() + + # Return metadata about the export + return { + 'row_count': row_count, + 'file_size': os.path.getsize(output_path), + 'export_time': datetime.now().isoformat(), + 'export_duration_seconds': export_duration, + 'compression': compression + } + + def get_table_columns(self, database: str, table: str) -> List[str]: + """Get list of columns for a table""" + query = f""" + SELECT name + FROM system.columns + WHERE database = '{database}' + AND table = '{table}' + ORDER BY position + """ + result = self.client.query(query) + return [row[0] for row in result.result_rows] + + def get_table_engine(self, database: str, table: str) -> str: + """Get the engine type for a table""" + query = f""" + SELECT engine + FROM system.tables + WHERE database = '{database}' + AND name = '{table}' + """ + result = self.client.query(query) + if result.result_rows: + return result.result_rows[0][0] + return '' + + def get_max_value(self, database: str, table: str, column: str, + where_clause: Optional[str] = None) -> Optional[int]: + """Get maximum value for a column""" + where = f"WHERE {where_clause}" if where_clause else "" + query = f""" + SELECT max({column}) as max_val + FROM {database}.{table} + {where} + """ + try: + result = self.client.query(query) + if result.result_rows and result.result_rows[0][0] is not None: + return result.result_rows[0][0] + except Exception as e: + self.logger.error(f"Failed to get max value: {e}") + return None + + def test_connection(self) -> bool: + """Test if connection is working""" + try: + result = self.client.query("SELECT 1") + return result.result_rows[0][0] == 1 + except Exception as e: + self.logger.error(f"Connection test failed: {e}") + return False + + def get_table_size(self, database: str, table: str) -> Dict[str, Any]: + """Get size information for a table""" + query = f""" + SELECT + sum(rows) as total_rows, + sum(bytes_on_disk) as bytes_on_disk, + sum(data_compressed_bytes) as compressed_bytes, + sum(data_uncompressed_bytes) as uncompressed_bytes, + count() as parts_count + FROM system.parts + WHERE database = '{database}' + AND table = '{table}' + AND active + """ + result = self.client.query(query) + if result.result_rows: + row = result.result_rows[0] + return { + 'total_rows': row[0] or 0, + 'bytes_on_disk': row[1] or 0, + 'compressed_bytes': row[2] or 0, + 'uncompressed_bytes': row[3] or 0, + 'parts_count': row[4] or 0 + } + return { + 'total_rows': 0, + 'bytes_on_disk': 0, + 'compressed_bytes': 0, + 'uncompressed_bytes': 0, + 'parts_count': 0 + } + + def check_partition_exists(self, database: str, table: str, + partition: str) -> bool: + """Check if a partition exists in the table""" + query = f""" + SELECT count() > 0 + FROM system.parts + WHERE database = '{database}' + AND table = '{table}' + AND partition = '{partition}' + AND active + """ + try: + result = self.client.query(query) + return result.result_rows[0][0] == 1 + except Exception as e: + self.logger.error(f"Failed to check partition: {e}") + return False \ No newline at end of file diff --git a/src/exporter.py b/src/exporter.py new file mode 100644 index 00000000..87c0eecb --- /dev/null +++ b/src/exporter.py @@ -0,0 +1,452 @@ +import yaml +from datetime import datetime, timedelta +from pathlib import Path +import logging +from typing import Optional, Dict, Any, List, Tuple +import tempfile +import os +from concurrent.futures import Future + +from .clickhouse import ClickHouseClient +from .storage import R2Storage +from .iceberg_manager import IcebergManager + + +class XatuExporter: + def __init__(self, environment: str, dry_run: bool = False): + self.environment = environment + self.dry_run = dry_run + self.config = self._load_config() + self.setup_clients() + self.logger = logging.getLogger(__name__) + + def _load_config(self) -> Dict[str, Any]: + """Load environment and table configurations""" + config_path = Path(__file__).parent.parent / 'config' + + # Allow override path for local development + if 'XATU_CONFIG_PATH' in os.environ: + config_path = Path(os.environ['XATU_CONFIG_PATH']) + + with open(config_path / 'environments.yaml') as f: + env_config = yaml.safe_load(f) + with open(config_path / 'tables.yaml') as f: + table_config = yaml.safe_load(f) + + return { + 'env': env_config['environments'][self.environment], + 'tables': table_config['table_groups'], + 'mappings': env_config['export_mappings'] + } + + def setup_clients(self): + """Initialize ClickHouse and storage clients""" + self.clickhouse_clients = {} + self.storage_clients = {} + self.iceberg_managers = {} + + # Set up based on export mappings + for mapping in self.config['mappings']: + source_env, source_cluster = mapping['source'].split('.') + if source_env == self.environment: + # Initialize ClickHouse client + ch_config = self.config['env']['clickhouse'][source_cluster] + self.clickhouse_clients[source_cluster] = ClickHouseClient(ch_config) + + # Initialize storage client + dest_env = mapping['destination'] + # Get storage config for destination environment + if dest_env == self.environment: + storage_config = self.config['env']['storage'] + else: + # Load destination environment config + with open(Path(__file__).parent.parent / 'config' / 'environments.yaml') as f: + all_envs = yaml.safe_load(f) + storage_config = all_envs['environments'][dest_env]['storage'] + + self.storage_clients[dest_env] = R2Storage(storage_config) + + # Initialize Iceberg manager + self.iceberg_managers[dest_env] = IcebergManager( + storage_config, dry_run=self.dry_run + ) + + def export_table(self, table_name: str, network: str, + date: Optional[datetime] = None, + force: bool = False) -> bool: + """Export a single table/network/date combination""" + table_config = self._get_table_config(table_name) + if not table_config: + self.logger.error(f"Table {table_name} not found in config") + return False + + # Check if network is configured for this table + network_config = self._get_network_config(table_config, network) + if not network_config: + self.logger.error(f"Network {network} not configured for table {table_name}") + return False + + # Determine which files need to be exported based on Iceberg metadata + files_to_export = self._get_missing_files( + table_name, network, date, table_config, force + ) + + if not files_to_export: + self.logger.info(f"No files to export for {table_name}/{network}") + return True + + # Export each missing file + success = True + for file_info in files_to_export: + try: + self._export_single_file( + table_config, network, file_info + ) + except Exception as e: + self.logger.error(f"Failed to export {file_info}: {e}") + success = False + + # Update Iceberg catalog after all exports + if success and not self.dry_run: + self._update_iceberg_catalog(table_name, network) + + return success + + def _get_table_config(self, table_name: str) -> Optional[Dict[str, Any]]: + """Get configuration for a specific table""" + for group in self.config['tables'].values(): + for table in group: + if table['name'] == table_name: + return table + return None + + def _get_network_config(self, table_config: Dict, network: str) -> Optional[Dict[str, Any]]: + """Get network-specific configuration for a table""" + for net_config in table_config['networks']: + if net_config['name'] == network: + return net_config + return None + + def _get_missing_files(self, table_name: str, network: str, + date: Optional[datetime], table_config: Dict, + force: bool) -> List[Dict[str, Any]]: + """Determine which files need to be exported based on Iceberg metadata""" + iceberg_manager = self._get_iceberg_manager_for_table(table_name) + + # Get list of existing files from Iceberg metadata + existing_files = iceberg_manager.get_existing_files( + table_name, network + ) if not force else set() + + # Generate list of files that should exist + if table_config['partition']['type'] == 'daily': + expected_files = self._generate_daily_files( + table_name, network, date, table_config + ) + elif table_config['partition']['type'] == 'hourly': + expected_files = self._generate_hourly_files( + table_name, network, date, table_config + ) + else: # chunked + expected_files = self._generate_chunked_files( + table_name, network, table_config + ) + + # Return files that don't exist in Iceberg + return [f for f in expected_files if f['path'] not in existing_files] + + def _generate_daily_files(self, table_name: str, network: str, + date: Optional[datetime], table_config: Dict) -> List[Dict[str, Any]]: + """Generate list of daily partition files""" + if date is None: + date = datetime.now() - timedelta(days=1) + + # Get network start date + network_config = self._get_network_config(table_config, network) + start_date = datetime.strptime(network_config['start_date'], '%Y-%m-%d') + + # Apply lag + lag_days = table_config.get('lag_days', 0) + max_date = datetime.now() - timedelta(days=lag_days) + + if date > max_date: + self.logger.warning(f"Date {date} is within lag period, skipping") + return [] + + if date < start_date: + self.logger.warning(f"Date {date} is before network start date {start_date}") + return [] + + # Generate file path + date_str = date.strftime('%Y-%m-%d') + path = f"xatu/{network}/databases/{table_config['database']}/{table_name}/partition_date={date_str}/{table_name}.parquet" + + return [{ + 'path': path, + 'partition_value': date_str, + 'date': date, + 'where_clause': f"{table_config['partition']['column']} >= '{date_str} 00:00:00' AND {table_config['partition']['column']} < '{date_str} 00:00:00' + INTERVAL 1 DAY" + }] + + def _generate_hourly_files(self, table_name: str, network: str, + date: Optional[datetime], table_config: Dict) -> List[Dict[str, Any]]: + """Generate list of hourly partition files""" + if date is None: + date = datetime.now() - timedelta(hours=1) + + # Get network start date + network_config = self._get_network_config(table_config, network) + start_date = datetime.strptime(network_config['start_date'], '%Y-%m-%d') + + # Apply lag + lag_hours = table_config.get('lag_hours', 0) + max_date = datetime.now() - timedelta(hours=lag_hours) + + files = [] + # Generate all hours for the date + current_hour = date.replace(hour=0, minute=0, second=0, microsecond=0) + for hour in range(24): + check_time = current_hour + timedelta(hours=hour) + if check_time > max_date or check_time < start_date: + continue + + date_str = check_time.strftime('%Y-%m-%d') + hour_str = check_time.strftime('%H') + path = f"xatu/{network}/databases/{table_config['database']}/{table_name}/partition_date={date_str}/partition_hour={hour_str}/{table_name}.parquet" + + files.append({ + 'path': path, + 'partition_value': f"{date_str}/{hour_str}", + 'date': check_time, + 'where_clause': f"{table_config['partition']['column']} >= '{check_time.strftime('%Y-%m-%d %H:00:00')}' AND {table_config['partition']['column']} < '{check_time.strftime('%Y-%m-%d %H:00:00')}' + INTERVAL 1 HOUR" + }) + + return files + + def _generate_chunked_files(self, table_name: str, network: str, + table_config: Dict) -> List[Dict[str, Any]]: + """Generate list of chunked partition files based on integer ranges""" + network_config = self._get_network_config(table_config, network) + start_index = network_config.get('start_index', 0) + chunk_size = table_config['partition']['chunk_size'] + + # Query ClickHouse for max value + ch_client = self._get_clickhouse_client_for_table(table_name) + max_value = ch_client.get_max_value( + table_config['database'], + table_name, + table_config['partition']['column'], + f"meta_network_name = '{network}'" + ) + + if max_value is None: + return [] + + # Apply lag + lag_interval = table_config.get('lag_interval', 0) + max_value = max_value - lag_interval + + files = [] + current_chunk = (start_index // chunk_size) * chunk_size + + while current_chunk <= max_value: + chunk_end = current_chunk + chunk_size - 1 + path = f"xatu/{network}/databases/{table_config['database']}/{table_name}/partition_chunk={current_chunk}/{table_name}.parquet" + + files.append({ + 'path': path, + 'partition_value': str(current_chunk), + 'chunk_start': current_chunk, + 'chunk_end': chunk_end, + 'where_clause': f"{table_config['partition']['column']} >= {current_chunk} AND {table_config['partition']['column']} <= {chunk_end}" + }) + + current_chunk += chunk_size + + return files + + def _export_single_file(self, table_config: Dict, network: str, + file_info: Dict[str, Any]) -> None: + """Export a single file with column redaction""" + ch_client = self._get_clickhouse_client_for_table(table_config['name']) + storage = self._get_storage_for_table(table_config['name']) + iceberg = self._get_iceberg_manager_for_table(table_config['name']) + + # Build query with redacted columns + query = self._build_export_query( + table_config, network, file_info, + table_config.get('redacted_columns', {}) + ) + + # Export to temporary file + with tempfile.NamedTemporaryFile(suffix='.parquet', delete=False) as tmp: + try: + metadata = ch_client.export_to_parquet(query, tmp.name) + + # Upload to storage + remote_path = file_info['path'] + storage.upload_file(tmp.name, remote_path, dry_run=self.dry_run) + + # Register with Iceberg + iceberg.register_file( + table_config['name'], network, remote_path, + file_info['partition_value'], metadata + ) + + self.logger.info(f"Successfully exported {remote_path}") + finally: + # Clean up + Path(tmp.name).unlink(missing_ok=True) + + def _build_export_query(self, table_config: Dict, network: str, + file_info: Dict, redacted_columns: Dict) -> str: + """Build ClickHouse query with column redaction""" + # Get all columns from table + ch_client = self._get_clickhouse_client_for_table(table_config['name']) + all_columns = ch_client.get_table_columns( + table_config['database'], table_config['name'] + ) + + # Build SELECT with redacted columns + select_parts = [] + for col in all_columns: + if col in redacted_columns: + select_parts.append(f"{redacted_columns[col]} AS {col}") + else: + select_parts.append(col) + + select_clause = ", ".join(select_parts) + + # Build WHERE clause + where_parts = [file_info['where_clause']] + where_parts.append(f"meta_network_name = '{network}'") + where_clause = " AND ".join(where_parts) + + # Determine if FINAL is needed + final_clause = self._get_final_clause( + table_config['database'], table_config['name'] + ) + + return f""" + SELECT {select_clause} + FROM {table_config['database']}.{table_config['name']} {final_clause} + WHERE {where_clause} + ORDER BY {table_config['partition']['column']} + """ + + def _get_final_clause(self, database: str, table: str) -> str: + """Determine if FINAL clause is needed based on table engine""" + ch_client = list(self.clickhouse_clients.values())[0] + engine = ch_client.get_table_engine(database, table) + + # Use FINAL for MergeTree engines that deduplicate + if 'ReplacingMergeTree' in engine or 'CollapsingMergeTree' in engine: + return 'FINAL' + return '' + + def _get_clickhouse_client_for_table(self, table_name: str) -> ClickHouseClient: + """Get the appropriate ClickHouse client for a table""" + # For now, use the first available client + # In future, this could be more sophisticated based on table mapping + return list(self.clickhouse_clients.values())[0] + + def _get_storage_for_table(self, table_name: str) -> R2Storage: + """Get the appropriate storage client for a table""" + # Determine destination based on mapping + for mapping in self.config['mappings']: + source_env, source_cluster = mapping['source'].split('.') + if source_env == self.environment: + return self.storage_clients[mapping['destination']] + return list(self.storage_clients.values())[0] + + def _get_iceberg_manager_for_table(self, table_name: str) -> IcebergManager: + """Get the appropriate Iceberg manager for a table""" + # Determine destination based on mapping + for mapping in self.config['mappings']: + source_env, source_cluster = mapping['source'].split('.') + if source_env == self.environment: + return self.iceberg_managers[mapping['destination']] + return list(self.iceberg_managers.values())[0] + + def _update_iceberg_catalog(self, table_name: str, network: str): + """Update Iceberg catalog after exports""" + iceberg = self._get_iceberg_manager_for_table(table_name) + iceberg.update_catalog(table_name, network) + + def export_all_daily(self, date: Optional[datetime] = None): + """Export all daily tables for a given date""" + if date is None: + date = datetime.now() - timedelta(days=1) + + results = [] + for table in self.config['tables'].get('daily', []): + for network in table['networks']: + success = self.export_table(table['name'], network['name'], date) + results.append((table['name'], network['name'], success)) + + return results + + def export_all_hourly(self, date: Optional[datetime] = None): + """Export all hourly tables for a given date""" + if date is None: + date = datetime.now() - timedelta(hours=1) + + results = [] + for table in self.config['tables'].get('hourly', []): + for network in table['networks']: + success = self.export_table(table['name'], network['name'], date) + results.append((table['name'], network['name'], success)) + + return results + + def export_all_chunked(self): + """Export all chunked tables""" + results = [] + for table in self.config['tables'].get('chunked', []): + for network in table['networks']: + success = self.export_table(table['name'], network['name']) + results.append((table['name'], network['name'], success)) + + return results + + def submit_daily_exports(self, executor, date: Optional[datetime] = None) -> List[Future]: + """Submit daily export jobs to executor""" + if date is None: + date = datetime.now() - timedelta(days=1) + + futures = [] + for table in self.config['tables'].get('daily', []): + for network in table['networks']: + future = executor.submit( + self.export_table, table['name'], network['name'], date + ) + futures.append(future) + + return futures + + def submit_hourly_exports(self, executor, date: Optional[datetime] = None) -> List[Future]: + """Submit hourly export jobs to executor""" + if date is None: + date = datetime.now() - timedelta(hours=1) + + futures = [] + for table in self.config['tables'].get('hourly', []): + for network in table['networks']: + future = executor.submit( + self.export_table, table['name'], network['name'], date + ) + futures.append(future) + + return futures + + def submit_chunked_exports(self, executor) -> List[Future]: + """Submit chunked export jobs to executor""" + futures = [] + for table in self.config['tables'].get('chunked', []): + for network in table['networks']: + future = executor.submit( + self.export_table, table['name'], network['name'] + ) + futures.append(future) + + return futures \ No newline at end of file diff --git a/src/iceberg_manager.py b/src/iceberg_manager.py new file mode 100644 index 00000000..ddb82a8b --- /dev/null +++ b/src/iceberg_manager.py @@ -0,0 +1,480 @@ +import json +import uuid +from typing import Dict, Any, Optional, Set, List +from datetime import datetime +import logging +import tempfile +from pathlib import Path +import pyarrow.parquet as pq + +from .storage import R2Storage + + +class IcebergManager: + def __init__(self, storage_config: Dict[str, Any], dry_run: bool = False): + self.storage_config = storage_config + self.dry_run = dry_run + self.catalog_url = f"{storage_config['public_url']}/xatu/catalog.json" + self.storage = R2Storage(storage_config) + self.logger = logging.getLogger(__name__) + self._metadata_cache = {} # Cache loaded metadata + self._manifest_cache = {} # Cache loaded manifests + + def get_existing_files(self, table_name: str, network: str) -> Set[str]: + """Get set of existing file paths from Iceberg metadata""" + try: + metadata = self._load_table_metadata(table_name, network) + if not metadata: + return set() + + # Extract file paths from current snapshot + current_snapshot_id = metadata.get('current-snapshot-id') + if not current_snapshot_id: + return set() + + # Find current snapshot + current_snapshot = None + for snapshot in metadata.get('snapshots', []): + if snapshot['snapshot-id'] == current_snapshot_id: + current_snapshot = snapshot + break + + if not current_snapshot: + return set() + + # Load manifest list + manifest_list = self._load_manifest_list( + current_snapshot['manifest-list'] + ) + + # Extract all data file paths + file_paths = set() + for manifest_entry in manifest_list: + manifest_content = self._load_manifest(manifest_entry['manifest_path']) + for entry in manifest_content.get('entries', []): + if entry['status'] in ['ADDED', 'EXISTING']: + file_path = entry['data_file']['file_path'] + # Convert absolute path to relative if needed + if file_path.startswith(self.storage_config['public_url']): + file_path = file_path[len(self.storage_config['public_url']) + 1:] + file_paths.add(file_path) + + return file_paths + + except Exception as e: + self.logger.warning(f"Could not load existing files for {table_name}/{network}: {e}") + return set() + + def register_file(self, table_name: str, network: str, file_path: str, + partition_value: Any, file_metadata: Dict[str, Any]) -> None: + """Register a new Parquet file with Iceberg metadata""" + if self.dry_run: + self.logger.info(f"[DRY RUN] Would register {file_path} in Iceberg metadata") + return + + metadata_path = self._get_metadata_path(table_name, network) + + # Load or create table metadata + metadata = self._load_table_metadata(table_name, network) + if not metadata: + metadata = self._create_initial_metadata( + table_name, network, file_path, partition_value + ) + + # Add file to metadata + new_metadata = self._add_file_to_metadata( + metadata, file_path, partition_value, file_metadata + ) + + # Save new metadata version + self._save_metadata(metadata_path, new_metadata) + + # Update version hint + self._update_version_hint(metadata_path, new_metadata['format-version']) + + def update_catalog(self, table_name: str, network: str): + """Update the main Iceberg catalog""" + if self.dry_run: + self.logger.info(f"[DRY RUN] Would update catalog for {table_name}/{network}") + return + + # Load existing catalog + catalog = self._load_catalog() + + # Add or update table entry + table_id = f"{network}.{table_name}" + metadata_path = self._get_metadata_path(table_name, network) + + catalog['tables'][table_id] = { + 'metadata-location': f"{self.storage_config['public_url']}/{metadata_path}/current.metadata.json", + 'updated-at': datetime.now().isoformat() + } + + # Save catalog + catalog_key = "xatu/catalog.json" + self.storage.put_file_content( + catalog_key, + json.dumps(catalog, indent=2), + dry_run=self.dry_run + ) + + def _load_table_metadata(self, table_name: str, network: str) -> Optional[Dict]: + """Load current table metadata from storage""" + cache_key = f"{network}/{table_name}" + if cache_key in self._metadata_cache: + return self._metadata_cache[cache_key] + + try: + metadata_path = self._get_metadata_path(table_name, network) + version_hint_key = f"{metadata_path}/version-hint.text" + + # Get current version + version_hint = self.storage.get_file_content(version_hint_key) + if not version_hint: + return None + + current_version = int(version_hint.strip()) + + # Load metadata file + metadata_key = f"{metadata_path}/v{current_version}.metadata.json" + metadata_content = self.storage.get_file_content(metadata_key) + + if metadata_content: + metadata = json.loads(metadata_content) + self._metadata_cache[cache_key] = metadata + return metadata + + except Exception as e: + self.logger.debug(f"No existing metadata for {table_name}/{network}: {e}") + + return None + + def _load_catalog(self) -> Dict[str, Any]: + """Load the main Iceberg catalog""" + catalog_key = "xatu/catalog.json" + catalog_content = self.storage.get_file_content(catalog_key) + + if catalog_content: + return json.loads(catalog_content) + + # Create initial catalog + return { + 'format-version': 1, + 'location': f"{self.storage_config['public_url']}/xatu", + 'tables': {}, + 'updated-at': datetime.now().isoformat() + } + + def _create_initial_metadata(self, table_name: str, network: str, + first_file: str, partition_value: Any) -> Dict: + """Create initial Iceberg metadata for a new table""" + table_uuid = str(uuid.uuid4()) + location = f"{self.storage_config['public_url']}/xatu/{network}/databases/default/{table_name}" + + # Get schema from the actual Parquet file + schema = self._get_parquet_schema(first_file) + + return { + "format-version": 2, + "table-uuid": table_uuid, + "location": location, + "last-sequence-number": 0, + "last-updated-ms": int(datetime.now().timestamp() * 1000), + "last-column-id": len(schema.get('fields', [])), + "current-schema-id": 0, + "schemas": [schema], + "default-spec-id": 0, + "partition-specs": [self._get_partition_spec(table_name)], + "last-partition-id": 1000, + "default-sort-order-id": 0, + "sort-orders": [{"order-id": 0, "fields": []}], + "properties": { + "created-by": "xatu-exporter", + "created-at": datetime.now().isoformat() + }, + "snapshots": [], + "snapshot-log": [], + "metadata-log": [], + "refs": { + "main": { + "snapshot-id": -1, + "type": "branch" + } + } + } + + def _get_parquet_schema(self, file_path: str) -> Dict[str, Any]: + """Extract Iceberg schema from a Parquet file""" + # For remote files, we'd need to download temporarily + # For now, return a basic schema structure + return { + "type": "struct", + "schema-id": 0, + "fields": [] # Would be populated from actual Parquet schema + } + + def _get_partition_spec(self, table_name: str) -> Dict[str, Any]: + """Get partition spec for a table based on configuration""" + # This would be derived from table configuration + # For now, return a basic partition spec + return { + "spec-id": 0, + "fields": [{ + "source-id": 1, + "field-id": 1000, + "name": "partition_date", + "transform": "identity" + }] + } + + def _add_file_to_metadata(self, metadata: Dict, file_path: str, + partition_value: Any, file_metadata: Dict) -> Dict: + """Add a new file to existing metadata, creating a new snapshot""" + # Clone metadata for new version + new_metadata = json.loads(json.dumps(metadata)) + + # Increment version + current_version = new_metadata.get('format-version', 1) + new_metadata['format-version'] = current_version + + # Update timestamp and sequence + new_metadata['last-updated-ms'] = int(datetime.now().timestamp() * 1000) + new_metadata['last-sequence-number'] += 1 + + # Create new snapshot + snapshot_id = new_metadata['last-sequence-number'] + snapshot = { + "sequence-number": snapshot_id, + "snapshot-id": snapshot_id, + "timestamp-ms": new_metadata['last-updated-ms'], + "summary": { + "operation": "append", + "spark.app.id": "xatu-exporter", + "added-data-files": "1", + "added-records": str(file_metadata.get('row_count', 0)), + "added-files-size": str(file_metadata.get('file_size', 0)), + "total-data-files": str(self._count_total_files(metadata) + 1), + "total-records": str(self._count_total_records(metadata) + file_metadata.get('row_count', 0)), + "total-files-size": str(self._count_total_size(metadata) + file_metadata.get('file_size', 0)) + }, + "manifest-list": self._create_manifest_list_path(metadata, snapshot_id) + } + + # Add snapshot + new_metadata['snapshots'].append(snapshot) + new_metadata['current-snapshot-id'] = snapshot_id + + # Update refs + if 'refs' not in new_metadata: + new_metadata['refs'] = {} + new_metadata['refs']['main'] = { + "snapshot-id": snapshot_id, + "type": "branch" + } + + # Update snapshot log + new_metadata['snapshot-log'].append({ + "timestamp-ms": snapshot['timestamp-ms'], + "snapshot-id": snapshot_id + }) + + # Create manifest for the new file + self._create_manifest_for_file( + metadata, snapshot, file_path, partition_value, file_metadata + ) + + return new_metadata + + def _create_manifest_list_path(self, metadata: Dict, snapshot_id: int) -> str: + """Generate manifest list path for a snapshot""" + base_path = metadata['location'] + if base_path.startswith(self.storage_config['public_url']): + base_path = base_path[len(self.storage_config['public_url']) + 1:] + return f"{base_path}/metadata/snap-{snapshot_id}-manifest-list.json" + + def _create_manifest_for_file(self, metadata: Dict, snapshot: Dict, + file_path: str, partition_value: Any, + file_metadata: Dict) -> None: + """Create manifest entry for a new file""" + manifest_path = f"{metadata['location']}/metadata/manifest-{uuid.uuid4()}.json" + + # Create manifest entry + manifest = { + "entries": [{ + "status": "ADDED", + "snapshot_id": snapshot['snapshot-id'], + "sequence_number": snapshot['sequence-number'], + "data_file": { + "content": "DATA", + "file_path": f"{self.storage_config['public_url']}/{file_path}", + "file_format": "PARQUET", + "partition": {"partition_date": partition_value}, + "record_count": file_metadata.get('row_count', 0), + "file_size_in_bytes": file_metadata.get('file_size', 0), + "column_sizes": {}, + "value_counts": {}, + "null_value_counts": {}, + "nan_value_counts": {}, + "lower_bounds": {}, + "upper_bounds": {} + } + }] + } + + # Save manifest + if manifest_path.startswith(self.storage_config['public_url']): + manifest_key = manifest_path[len(self.storage_config['public_url']) + 1:] + else: + manifest_key = manifest_path + + self.storage.put_file_content( + manifest_key, + json.dumps(manifest, indent=2), + dry_run=self.dry_run + ) + + # Create manifest list + manifest_list = [{ + "manifest_path": manifest_path, + "manifest_length": len(json.dumps(manifest)), + "partition_spec_id": 0, + "content": "data", + "sequence_number": snapshot['sequence-number'], + "min_sequence_number": snapshot['sequence-number'], + "added_snapshot_id": snapshot['snapshot-id'], + "added_files_count": 1, + "existing_files_count": 0, + "deleted_files_count": 0, + "added_rows_count": file_metadata.get('row_count', 0), + "existing_rows_count": 0, + "deleted_rows_count": 0, + "partitions": [{"partition_date": partition_value}] + }] + + # Save manifest list + manifest_list_key = snapshot['manifest-list'] + if manifest_list_key.startswith(self.storage_config['public_url']): + manifest_list_key = manifest_list_key[len(self.storage_config['public_url']) + 1:] + + self.storage.put_file_content( + manifest_list_key, + json.dumps(manifest_list, indent=2), + dry_run=self.dry_run + ) + + def _save_metadata(self, metadata_path: str, metadata: Dict) -> None: + """Save metadata to storage""" + version = len(metadata.get('metadata-log', [])) + 1 + metadata_key = f"{metadata_path}/v{version}.metadata.json" + + # Add to metadata log + if 'metadata-log' not in metadata: + metadata['metadata-log'] = [] + + metadata['metadata-log'].append({ + "timestamp-ms": metadata['last-updated-ms'], + "metadata-file": metadata_key + }) + + # Save metadata file + self.storage.put_file_content( + metadata_key, + json.dumps(metadata, indent=2), + dry_run=self.dry_run + ) + + # Update current symlink + current_key = f"{metadata_path}/current.metadata.json" + self.storage.put_file_content( + current_key, + json.dumps(metadata, indent=2), + dry_run=self.dry_run + ) + + def _update_version_hint(self, metadata_path: str, version: int) -> None: + """Update version hint file""" + version_hint_key = f"{metadata_path}/version-hint.text" + self.storage.put_file_content( + version_hint_key, + str(version), + dry_run=self.dry_run + ) + + def _get_metadata_path(self, table_name: str, network: str) -> str: + """Get the metadata path for a table""" + return f"xatu/{network}/databases/default/{table_name}/metadata" + + def _load_manifest_list(self, manifest_list_path: str) -> List[Dict]: + """Load manifest list from storage""" + if manifest_list_path in self._manifest_cache: + return self._manifest_cache[manifest_list_path] + + # Convert URL to storage key if needed + if manifest_list_path.startswith(self.storage_config['public_url']): + key = manifest_list_path[len(self.storage_config['public_url']) + 1:] + else: + key = manifest_list_path + + content = self.storage.get_file_content(key) + if content: + manifest_list = json.loads(content) + self._manifest_cache[manifest_list_path] = manifest_list + return manifest_list + + return [] + + def _load_manifest(self, manifest_path: str) -> Dict: + """Load manifest from storage""" + if manifest_path in self._manifest_cache: + return self._manifest_cache[manifest_path] + + # Convert URL to storage key if needed + if manifest_path.startswith(self.storage_config['public_url']): + key = manifest_path[len(self.storage_config['public_url']) + 1:] + else: + key = manifest_path + + content = self.storage.get_file_content(key) + if content: + manifest = json.loads(content) + self._manifest_cache[manifest_path] = manifest + return manifest + + return {"entries": []} + + def _count_total_files(self, metadata: Dict) -> int: + """Count total files in all snapshots""" + # Simple implementation - would need to deduplicate in production + current_snapshot_id = metadata.get('current-snapshot-id') + if not current_snapshot_id: + return 0 + + for snapshot in metadata.get('snapshots', []): + if snapshot['snapshot-id'] == current_snapshot_id: + return int(snapshot.get('summary', {}).get('total-data-files', 0)) + + return 0 + + def _count_total_records(self, metadata: Dict) -> int: + """Count total records in all snapshots""" + current_snapshot_id = metadata.get('current-snapshot-id') + if not current_snapshot_id: + return 0 + + for snapshot in metadata.get('snapshots', []): + if snapshot['snapshot-id'] == current_snapshot_id: + return int(snapshot.get('summary', {}).get('total-records', 0)) + + return 0 + + def _count_total_size(self, metadata: Dict) -> int: + """Count total size in all snapshots""" + current_snapshot_id = metadata.get('current-snapshot-id') + if not current_snapshot_id: + return 0 + + for snapshot in metadata.get('snapshots', []): + if snapshot['snapshot-id'] == current_snapshot_id: + return int(snapshot.get('summary', {}).get('total-files-size', 0)) + + return 0 \ No newline at end of file diff --git a/src/storage.py b/src/storage.py new file mode 100644 index 00000000..cc5740f3 --- /dev/null +++ b/src/storage.py @@ -0,0 +1,202 @@ +import os +import boto3 +from typing import Dict, Any, Optional, List +from pathlib import Path +import logging +from botocore.exceptions import ClientError + + +class R2Storage: + def __init__(self, config: Dict[str, Any]): + self.config = config + self.client = self._create_client() + self.bucket = config['bucket'] + self.public_url = config['public_url'] + self.logger = logging.getLogger(__name__) + + def _create_client(self): + access_key = os.environ.get(self.config['access_key_env']) + secret_key = os.environ.get(self.config['secret_key_env']) + + if not access_key or not secret_key: + raise ValueError(f"AWS credentials not found in environment variables") + + return boto3.client( + 's3', + endpoint_url=self.config['endpoint'], + aws_access_key_id=access_key, + aws_secret_access_key=secret_key, + region_name='auto' + ) + + def upload_file(self, local_path: str, remote_key: str, + dry_run: bool = False) -> str: + """Upload file to R2 and return public URL""" + if dry_run: + self.logger.info(f"[DRY RUN] Would upload {local_path} to {remote_key}") + return f"{self.public_url}/{remote_key}" + + try: + # Get file size for progress logging + file_size = os.path.getsize(local_path) + self.logger.info(f"Uploading {file_size:,} bytes to {remote_key}") + + # Upload with metadata + self.client.upload_file( + local_path, + self.bucket, + remote_key, + ExtraArgs={ + 'ContentType': 'application/octet-stream', + 'Metadata': { + 'uploaded-by': 'xatu-exporter', + 'upload-time': str(os.path.getmtime(local_path)) + } + } + ) + + self.logger.info(f"Successfully uploaded to {remote_key}") + return f"{self.public_url}/{remote_key}" + + except ClientError as e: + self.logger.error(f"Failed to upload {local_path}: {e}") + raise + + def file_exists(self, remote_key: str) -> bool: + """Check if file exists in R2""" + try: + self.client.head_object(Bucket=self.bucket, Key=remote_key) + return True + except ClientError as e: + if e.response['Error']['Code'] == '404': + return False + # For other errors, log and return False + self.logger.error(f"Error checking file existence: {e}") + return False + + def get_file_content(self, remote_key: str) -> Optional[str]: + """Get file content as string""" + try: + response = self.client.get_object(Bucket=self.bucket, Key=remote_key) + return response['Body'].read().decode('utf-8') + except ClientError as e: + if e.response['Error']['Code'] == 'NoSuchKey': + return None + self.logger.error(f"Error reading file {remote_key}: {e}") + return None + + def get_file_content_bytes(self, remote_key: str) -> Optional[bytes]: + """Get file content as bytes""" + try: + response = self.client.get_object(Bucket=self.bucket, Key=remote_key) + return response['Body'].read() + except ClientError as e: + if e.response['Error']['Code'] == 'NoSuchKey': + return None + self.logger.error(f"Error reading file {remote_key}: {e}") + return None + + def put_file_content(self, remote_key: str, content: str, + dry_run: bool = False) -> bool: + """Put string content to a file""" + if dry_run: + self.logger.info(f"[DRY RUN] Would write content to {remote_key}") + return True + + try: + self.client.put_object( + Bucket=self.bucket, + Key=remote_key, + Body=content.encode('utf-8'), + ContentType='application/json' if remote_key.endswith('.json') else 'text/plain', + Metadata={ + 'uploaded-by': 'xatu-exporter', + } + ) + return True + except ClientError as e: + self.logger.error(f"Failed to put content to {remote_key}: {e}") + return False + + def list_files(self, prefix: str, max_results: Optional[int] = None) -> List[str]: + """List all files under a prefix""" + files = [] + paginator = self.client.get_paginator('list_objects_v2') + + page_iterator = paginator.paginate( + Bucket=self.bucket, + Prefix=prefix, + PaginationConfig={ + 'MaxItems': max_results + } if max_results else {} + ) + + try: + for page in page_iterator: + if 'Contents' in page: + files.extend([obj['Key'] for obj in page['Contents']]) + except ClientError as e: + self.logger.error(f"Error listing files with prefix {prefix}: {e}") + + return files + + def delete_file(self, remote_key: str, dry_run: bool = False) -> bool: + """Delete a file from R2""" + if dry_run: + self.logger.info(f"[DRY RUN] Would delete {remote_key}") + return True + + try: + self.client.delete_object(Bucket=self.bucket, Key=remote_key) + self.logger.info(f"Deleted {remote_key}") + return True + except ClientError as e: + self.logger.error(f"Failed to delete {remote_key}: {e}") + return False + + def get_file_metadata(self, remote_key: str) -> Optional[Dict[str, Any]]: + """Get metadata for a file""" + try: + response = self.client.head_object(Bucket=self.bucket, Key=remote_key) + return { + 'size': response['ContentLength'], + 'last_modified': response['LastModified'], + 'etag': response['ETag'], + 'content_type': response.get('ContentType'), + 'metadata': response.get('Metadata', {}) + } + except ClientError as e: + if e.response['Error']['Code'] == '404': + return None + self.logger.error(f"Error getting metadata for {remote_key}: {e}") + return None + + def copy_file(self, source_key: str, dest_key: str, + dry_run: bool = False) -> bool: + """Copy a file within the bucket""" + if dry_run: + self.logger.info(f"[DRY RUN] Would copy {source_key} to {dest_key}") + return True + + try: + copy_source = {'Bucket': self.bucket, 'Key': source_key} + self.client.copy_object( + CopySource=copy_source, + Bucket=self.bucket, + Key=dest_key + ) + self.logger.info(f"Copied {source_key} to {dest_key}") + return True + except ClientError as e: + self.logger.error(f"Failed to copy {source_key} to {dest_key}: {e}") + return False + + def download_file(self, remote_key: str, local_path: str) -> bool: + """Download a file from R2""" + try: + self.client.download_file(self.bucket, remote_key, local_path) + self.logger.info(f"Downloaded {remote_key} to {local_path}") + return True + except ClientError as e: + self.logger.error(f"Failed to download {remote_key}: {e}") + return False \ No newline at end of file diff --git a/uv.lock b/uv.lock new file mode 100644 index 00000000..537eac59 --- /dev/null +++ b/uv.lock @@ -0,0 +1,1552 @@ +version = 1 +revision = 2 +requires-python = ">=3.9" +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", + "python_full_version < '3.10'", +] + +[[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 = "black" +version = "25.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "click", version = "8.1.8", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, + { name = "click", version = "8.2.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "mypy-extensions" }, + { name = "packaging" }, + { name = "pathspec" }, + { name = "platformdirs" }, + { name = "tomli", marker = "python_full_version < '3.11'" }, + { name = "typing-extensions", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/94/49/26a7b0f3f35da4b5a65f081943b7bcd22d7002f5f0fb8098ec1ff21cb6ef/black-25.1.0.tar.gz", hash = "sha256:33496d5cd1222ad73391352b4ae8da15253c5de89b93a80b3e2c8d9a19ec2666", size = 649449, upload-time = "2025-01-29T04:15:40.373Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4d/3b/4ba3f93ac8d90410423fdd31d7541ada9bcee1df32fb90d26de41ed40e1d/black-25.1.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:759e7ec1e050a15f89b770cefbf91ebee8917aac5c20483bc2d80a6c3a04df32", size = 1629419, upload-time = "2025-01-29T05:37:06.642Z" }, + { url = "https://files.pythonhosted.org/packages/b4/02/0bde0485146a8a5e694daed47561785e8b77a0466ccc1f3e485d5ef2925e/black-25.1.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:0e519ecf93120f34243e6b0054db49c00a35f84f195d5bce7e9f5cfc578fc2da", size = 1461080, upload-time = "2025-01-29T05:37:09.321Z" }, + { url = "https://files.pythonhosted.org/packages/52/0e/abdf75183c830eaca7589144ff96d49bce73d7ec6ad12ef62185cc0f79a2/black-25.1.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:055e59b198df7ac0b7efca5ad7ff2516bca343276c466be72eb04a3bcc1f82d7", size = 1766886, upload-time = "2025-01-29T04:18:24.432Z" }, + { url = "https://files.pythonhosted.org/packages/dc/a6/97d8bb65b1d8a41f8a6736222ba0a334db7b7b77b8023ab4568288f23973/black-25.1.0-cp310-cp310-win_amd64.whl", hash = "sha256:db8ea9917d6f8fc62abd90d944920d95e73c83a5ee3383493e35d271aca872e9", size = 1419404, upload-time = "2025-01-29T04:19:04.296Z" }, + { url = "https://files.pythonhosted.org/packages/7e/4f/87f596aca05c3ce5b94b8663dbfe242a12843caaa82dd3f85f1ffdc3f177/black-25.1.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a39337598244de4bae26475f77dda852ea00a93bd4c728e09eacd827ec929df0", size = 1614372, upload-time = "2025-01-29T05:37:11.71Z" }, + { url = "https://files.pythonhosted.org/packages/e7/d0/2c34c36190b741c59c901e56ab7f6e54dad8df05a6272a9747ecef7c6036/black-25.1.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:96c1c7cd856bba8e20094e36e0f948718dc688dba4a9d78c3adde52b9e6c2299", size = 1442865, upload-time = "2025-01-29T05:37:14.309Z" }, + { url = "https://files.pythonhosted.org/packages/21/d4/7518c72262468430ead45cf22bd86c883a6448b9eb43672765d69a8f1248/black-25.1.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bce2e264d59c91e52d8000d507eb20a9aca4a778731a08cfff7e5ac4a4bb7096", size = 1749699, upload-time = "2025-01-29T04:18:17.688Z" }, + { url = "https://files.pythonhosted.org/packages/58/db/4f5beb989b547f79096e035c4981ceb36ac2b552d0ac5f2620e941501c99/black-25.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:172b1dbff09f86ce6f4eb8edf9dede08b1fce58ba194c87d7a4f1a5aa2f5b3c2", size = 1428028, upload-time = "2025-01-29T04:18:51.711Z" }, + { url = "https://files.pythonhosted.org/packages/83/71/3fe4741df7adf015ad8dfa082dd36c94ca86bb21f25608eb247b4afb15b2/black-25.1.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4b60580e829091e6f9238c848ea6750efed72140b91b048770b64e74fe04908b", size = 1650988, upload-time = "2025-01-29T05:37:16.707Z" }, + { url = "https://files.pythonhosted.org/packages/13/f3/89aac8a83d73937ccd39bbe8fc6ac8860c11cfa0af5b1c96d081facac844/black-25.1.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1e2978f6df243b155ef5fa7e558a43037c3079093ed5d10fd84c43900f2d8ecc", size = 1453985, upload-time = "2025-01-29T05:37:18.273Z" }, + { url = "https://files.pythonhosted.org/packages/6f/22/b99efca33f1f3a1d2552c714b1e1b5ae92efac6c43e790ad539a163d1754/black-25.1.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3b48735872ec535027d979e8dcb20bf4f70b5ac75a8ea99f127c106a7d7aba9f", size = 1783816, upload-time = "2025-01-29T04:18:33.823Z" }, + { url = "https://files.pythonhosted.org/packages/18/7e/a27c3ad3822b6f2e0e00d63d58ff6299a99a5b3aee69fa77cd4b0076b261/black-25.1.0-cp312-cp312-win_amd64.whl", hash = "sha256:ea0213189960bda9cf99be5b8c8ce66bb054af5e9e861249cd23471bd7b0b3ba", size = 1440860, upload-time = "2025-01-29T04:19:12.944Z" }, + { url = "https://files.pythonhosted.org/packages/98/87/0edf98916640efa5d0696e1abb0a8357b52e69e82322628f25bf14d263d1/black-25.1.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8f0b18a02996a836cc9c9c78e5babec10930862827b1b724ddfe98ccf2f2fe4f", size = 1650673, upload-time = "2025-01-29T05:37:20.574Z" }, + { url = "https://files.pythonhosted.org/packages/52/e5/f7bf17207cf87fa6e9b676576749c6b6ed0d70f179a3d812c997870291c3/black-25.1.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:afebb7098bfbc70037a053b91ae8437c3857482d3a690fefc03e9ff7aa9a5fd3", size = 1453190, upload-time = "2025-01-29T05:37:22.106Z" }, + { url = "https://files.pythonhosted.org/packages/e3/ee/adda3d46d4a9120772fae6de454c8495603c37c4c3b9c60f25b1ab6401fe/black-25.1.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:030b9759066a4ee5e5aca28c3c77f9c64789cdd4de8ac1df642c40b708be6171", size = 1782926, upload-time = "2025-01-29T04:18:58.564Z" }, + { url = "https://files.pythonhosted.org/packages/cc/64/94eb5f45dcb997d2082f097a3944cfc7fe87e071907f677e80788a2d7b7a/black-25.1.0-cp313-cp313-win_amd64.whl", hash = "sha256:a22f402b410566e2d1c950708c77ebf5ebd5d0d88a6a2e87c86d9fb48afa0d18", size = 1442613, upload-time = "2025-01-29T04:19:27.63Z" }, + { url = "https://files.pythonhosted.org/packages/d3/b6/ae7507470a4830dbbfe875c701e84a4a5fb9183d1497834871a715716a92/black-25.1.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:a1ee0a0c330f7b5130ce0caed9936a904793576ef4d2b98c40835d6a65afa6a0", size = 1628593, upload-time = "2025-01-29T05:37:23.672Z" }, + { url = "https://files.pythonhosted.org/packages/24/c1/ae36fa59a59f9363017ed397750a0cd79a470490860bc7713967d89cdd31/black-25.1.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:f3df5f1bf91d36002b0a75389ca8663510cf0531cca8aa5c1ef695b46d98655f", size = 1460000, upload-time = "2025-01-29T05:37:25.829Z" }, + { url = "https://files.pythonhosted.org/packages/ac/b6/98f832e7a6c49aa3a464760c67c7856363aa644f2f3c74cf7d624168607e/black-25.1.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d9e6827d563a2c820772b32ce8a42828dc6790f095f441beef18f96aa6f8294e", size = 1765963, upload-time = "2025-01-29T04:18:38.116Z" }, + { url = "https://files.pythonhosted.org/packages/ce/e9/2cb0a017eb7024f70e0d2e9bdb8c5a5b078c5740c7f8816065d06f04c557/black-25.1.0-cp39-cp39-win_amd64.whl", hash = "sha256:bacabb307dca5ebaf9c118d2d2f6903da0d62c9faa82bd21a33eecc319559355", size = 1419419, upload-time = "2025-01-29T04:18:30.191Z" }, + { url = "https://files.pythonhosted.org/packages/09/71/54e999902aed72baf26bca0d50781b01838251a462612966e9fc4891eadd/black-25.1.0-py3-none-any.whl", hash = "sha256:95e8176dae143ba9097f351d174fdaf0ccd29efb414b362ae3fd72bf0f710717", size = 207646, upload-time = "2025-01-29T04:15:38.082Z" }, +] + +[[package]] +name = "boto3" +version = "1.38.26" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "botocore" }, + { name = "jmespath" }, + { name = "s3transfer" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/3a/3e/acc8aae38061a044080d77d29bad964460e40f70bf1af32c4b2003e8b4de/boto3-1.38.26.tar.gz", hash = "sha256:d129dac62e8973322d29ce72fc71cb81eb9ed0cef7c5ebef5f5bf2a0af5af245", size = 111807, upload-time = "2025-05-29T19:31:32.345Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/72/bd/ed02504eeecffbf0cac5c52fda17bbbc81466e972309288d15332c3295b5/boto3-1.38.26-py3-none-any.whl", hash = "sha256:b2e6064bcbe3f130c6cbb6acdd30f412bc63f30a5771b48baa4f4e361110248b", size = 139940, upload-time = "2025-05-29T19:31:29.112Z" }, +] + +[[package]] +name = "botocore" +version = "1.38.26" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jmespath" }, + { name = "python-dateutil" }, + { name = "urllib3", version = "1.26.20", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, + { name = "urllib3", version = "2.4.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/95/b5/19d1aceee31ad08b590530002a3f97eb71913ca09674c54a29dd8c6a72df/botocore-1.38.26.tar.gz", hash = "sha256:780bf3deba610e915bf1aee32c7ce9cc4ff299a9aab79772dba7936b7dd5b24b", size = 13917886, upload-time = "2025-05-29T19:31:20.22Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1c/91/f52079dd0a484f98fa30c4614eeae16c05a79c157a55e7c2439ae749104d/botocore-1.38.26-py3-none-any.whl", hash = "sha256:d73559858d8fda5d41d3833cc784ba472eb794cff95f94e9f21ba5f03c0dc8db", size = 13579600, upload-time = "2025-05-29T19:31:17.383Z" }, +] + +[[package]] +name = "cachetools" +version = "5.5.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6c/81/3747dad6b14fa2cf53fcf10548cf5aea6913e96fab41a3c198676f8948a5/cachetools-5.5.2.tar.gz", hash = "sha256:1a661caa9175d26759571b2e19580f9d6393969e5dfca11fdb1f947a23e640d4", size = 28380, upload-time = "2025-02-20T21:01:19.524Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/72/76/20fa66124dbe6be5cafeb312ece67de6b61dd91a0247d1ea13db4ebb33c2/cachetools-5.5.2-py3-none-any.whl", hash = "sha256:d26a22bcc62eb95c3beabd9f1ee5e820d3d2704fe2967cbe350e20c8ffcd3f0a", size = 10080, upload-time = "2025-02-20T21:01:16.647Z" }, +] + +[[package]] +name = "certifi" +version = "2025.4.26" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e8/9e/c05b3920a3b7d20d3d3310465f50348e5b3694f4f88c6daf736eef3024c4/certifi-2025.4.26.tar.gz", hash = "sha256:0a816057ea3cdefcef70270d2c515e4506bbc954f417fa5ade2021213bb8f0c6", size = 160705, upload-time = "2025-04-26T02:12:29.51Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4a/7e/3db2bd1b1f9e95f7cddca6d6e75e2f2bd9f51b1246e546d88addca0106bd/certifi-2025.4.26-py3-none-any.whl", hash = "sha256:30350364dfe371162649852c63336a15c70c6510c2ad5015b21c2345311805f3", size = 159618, upload-time = "2025-04-26T02:12:27.662Z" }, +] + +[[package]] +name = "cffi" +version = "1.17.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pycparser" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/fc/97/c783634659c2920c3fc70419e3af40972dbaf758daa229a7d6ea6135c90d/cffi-1.17.1.tar.gz", hash = "sha256:1c39c6016c32bc48dd54561950ebd6836e1670f2ae46128f67cf49e789c52824", size = 516621, upload-time = "2024-09-04T20:45:21.852Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/90/07/f44ca684db4e4f08a3fdc6eeb9a0d15dc6883efc7b8c90357fdbf74e186c/cffi-1.17.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:df8b1c11f177bc2313ec4b2d46baec87a5f3e71fc8b45dab2ee7cae86d9aba14", size = 182191, upload-time = "2024-09-04T20:43:30.027Z" }, + { url = "https://files.pythonhosted.org/packages/08/fd/cc2fedbd887223f9f5d170c96e57cbf655df9831a6546c1727ae13fa977a/cffi-1.17.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8f2cdc858323644ab277e9bb925ad72ae0e67f69e804f4898c070998d50b1a67", size = 178592, upload-time = "2024-09-04T20:43:32.108Z" }, + { url = "https://files.pythonhosted.org/packages/de/cc/4635c320081c78d6ffc2cab0a76025b691a91204f4aa317d568ff9280a2d/cffi-1.17.1-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:edae79245293e15384b51f88b00613ba9f7198016a5948b5dddf4917d4d26382", size = 426024, upload-time = "2024-09-04T20:43:34.186Z" }, + { url = "https://files.pythonhosted.org/packages/b6/7b/3b2b250f3aab91abe5f8a51ada1b717935fdaec53f790ad4100fe2ec64d1/cffi-1.17.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:45398b671ac6d70e67da8e4224a065cec6a93541bb7aebe1b198a61b58c7b702", size = 448188, upload-time = "2024-09-04T20:43:36.286Z" }, + { url = "https://files.pythonhosted.org/packages/d3/48/1b9283ebbf0ec065148d8de05d647a986c5f22586b18120020452fff8f5d/cffi-1.17.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ad9413ccdeda48c5afdae7e4fa2192157e991ff761e7ab8fdd8926f40b160cc3", size = 455571, upload-time = "2024-09-04T20:43:38.586Z" }, + { url = "https://files.pythonhosted.org/packages/40/87/3b8452525437b40f39ca7ff70276679772ee7e8b394934ff60e63b7b090c/cffi-1.17.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5da5719280082ac6bd9aa7becb3938dc9f9cbd57fac7d2871717b1feb0902ab6", size = 436687, upload-time = "2024-09-04T20:43:40.084Z" }, + { url = "https://files.pythonhosted.org/packages/8d/fb/4da72871d177d63649ac449aec2e8a29efe0274035880c7af59101ca2232/cffi-1.17.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2bb1a08b8008b281856e5971307cc386a8e9c5b625ac297e853d36da6efe9c17", size = 446211, upload-time = "2024-09-04T20:43:41.526Z" }, + { url = "https://files.pythonhosted.org/packages/ab/a0/62f00bcb411332106c02b663b26f3545a9ef136f80d5df746c05878f8c4b/cffi-1.17.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:045d61c734659cc045141be4bae381a41d89b741f795af1dd018bfb532fd0df8", size = 461325, upload-time = "2024-09-04T20:43:43.117Z" }, + { url = "https://files.pythonhosted.org/packages/36/83/76127035ed2e7e27b0787604d99da630ac3123bfb02d8e80c633f218a11d/cffi-1.17.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:6883e737d7d9e4899a8a695e00ec36bd4e5e4f18fabe0aca0efe0a4b44cdb13e", size = 438784, upload-time = "2024-09-04T20:43:45.256Z" }, + { url = "https://files.pythonhosted.org/packages/21/81/a6cd025db2f08ac88b901b745c163d884641909641f9b826e8cb87645942/cffi-1.17.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:6b8b4a92e1c65048ff98cfe1f735ef8f1ceb72e3d5f0c25fdb12087a23da22be", size = 461564, upload-time = "2024-09-04T20:43:46.779Z" }, + { url = "https://files.pythonhosted.org/packages/f8/fe/4d41c2f200c4a457933dbd98d3cf4e911870877bd94d9656cc0fcb390681/cffi-1.17.1-cp310-cp310-win32.whl", hash = "sha256:c9c3d058ebabb74db66e431095118094d06abf53284d9c81f27300d0e0d8bc7c", size = 171804, upload-time = "2024-09-04T20:43:48.186Z" }, + { url = "https://files.pythonhosted.org/packages/d1/b6/0b0f5ab93b0df4acc49cae758c81fe4e5ef26c3ae2e10cc69249dfd8b3ab/cffi-1.17.1-cp310-cp310-win_amd64.whl", hash = "sha256:0f048dcf80db46f0098ccac01132761580d28e28bc0f78ae0d58048063317e15", size = 181299, upload-time = "2024-09-04T20:43:49.812Z" }, + { url = "https://files.pythonhosted.org/packages/6b/f4/927e3a8899e52a27fa57a48607ff7dc91a9ebe97399b357b85a0c7892e00/cffi-1.17.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a45e3c6913c5b87b3ff120dcdc03f6131fa0065027d0ed7ee6190736a74cd401", size = 182264, upload-time = "2024-09-04T20:43:51.124Z" }, + { url = "https://files.pythonhosted.org/packages/6c/f5/6c3a8efe5f503175aaddcbea6ad0d2c96dad6f5abb205750d1b3df44ef29/cffi-1.17.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:30c5e0cb5ae493c04c8b42916e52ca38079f1b235c2f8ae5f4527b963c401caf", size = 178651, upload-time = "2024-09-04T20:43:52.872Z" }, + { url = "https://files.pythonhosted.org/packages/94/dd/a3f0118e688d1b1a57553da23b16bdade96d2f9bcda4d32e7d2838047ff7/cffi-1.17.1-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f75c7ab1f9e4aca5414ed4d8e5c0e303a34f4421f8a0d47a4d019ceff0ab6af4", size = 445259, upload-time = "2024-09-04T20:43:56.123Z" }, + { url = "https://files.pythonhosted.org/packages/2e/ea/70ce63780f096e16ce8588efe039d3c4f91deb1dc01e9c73a287939c79a6/cffi-1.17.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a1ed2dd2972641495a3ec98445e09766f077aee98a1c896dcb4ad0d303628e41", size = 469200, upload-time = "2024-09-04T20:43:57.891Z" }, + { url = "https://files.pythonhosted.org/packages/1c/a0/a4fa9f4f781bda074c3ddd57a572b060fa0df7655d2a4247bbe277200146/cffi-1.17.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:46bf43160c1a35f7ec506d254e5c890f3c03648a4dbac12d624e4490a7046cd1", size = 477235, upload-time = "2024-09-04T20:44:00.18Z" }, + { url = "https://files.pythonhosted.org/packages/62/12/ce8710b5b8affbcdd5c6e367217c242524ad17a02fe5beec3ee339f69f85/cffi-1.17.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a24ed04c8ffd54b0729c07cee15a81d964e6fee0e3d4d342a27b020d22959dc6", size = 459721, upload-time = "2024-09-04T20:44:01.585Z" }, + { url = "https://files.pythonhosted.org/packages/ff/6b/d45873c5e0242196f042d555526f92aa9e0c32355a1be1ff8c27f077fd37/cffi-1.17.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:610faea79c43e44c71e1ec53a554553fa22321b65fae24889706c0a84d4ad86d", size = 467242, upload-time = "2024-09-04T20:44:03.467Z" }, + { url = "https://files.pythonhosted.org/packages/1a/52/d9a0e523a572fbccf2955f5abe883cfa8bcc570d7faeee06336fbd50c9fc/cffi-1.17.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:a9b15d491f3ad5d692e11f6b71f7857e7835eb677955c00cc0aefcd0669adaf6", size = 477999, upload-time = "2024-09-04T20:44:05.023Z" }, + { url = "https://files.pythonhosted.org/packages/44/74/f2a2460684a1a2d00ca799ad880d54652841a780c4c97b87754f660c7603/cffi-1.17.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:de2ea4b5833625383e464549fec1bc395c1bdeeb5f25c4a3a82b5a8c756ec22f", size = 454242, upload-time = "2024-09-04T20:44:06.444Z" }, + { url = "https://files.pythonhosted.org/packages/f8/4a/34599cac7dfcd888ff54e801afe06a19c17787dfd94495ab0c8d35fe99fb/cffi-1.17.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:fc48c783f9c87e60831201f2cce7f3b2e4846bf4d8728eabe54d60700b318a0b", size = 478604, upload-time = "2024-09-04T20:44:08.206Z" }, + { url = "https://files.pythonhosted.org/packages/34/33/e1b8a1ba29025adbdcda5fb3a36f94c03d771c1b7b12f726ff7fef2ebe36/cffi-1.17.1-cp311-cp311-win32.whl", hash = "sha256:85a950a4ac9c359340d5963966e3e0a94a676bd6245a4b55bc43949eee26a655", size = 171727, upload-time = "2024-09-04T20:44:09.481Z" }, + { url = "https://files.pythonhosted.org/packages/3d/97/50228be003bb2802627d28ec0627837ac0bf35c90cf769812056f235b2d1/cffi-1.17.1-cp311-cp311-win_amd64.whl", hash = "sha256:caaf0640ef5f5517f49bc275eca1406b0ffa6aa184892812030f04c2abf589a0", size = 181400, upload-time = "2024-09-04T20:44:10.873Z" }, + { url = "https://files.pythonhosted.org/packages/5a/84/e94227139ee5fb4d600a7a4927f322e1d4aea6fdc50bd3fca8493caba23f/cffi-1.17.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:805b4371bf7197c329fcb3ead37e710d1bca9da5d583f5073b799d5c5bd1eee4", size = 183178, upload-time = "2024-09-04T20:44:12.232Z" }, + { url = "https://files.pythonhosted.org/packages/da/ee/fb72c2b48656111c4ef27f0f91da355e130a923473bf5ee75c5643d00cca/cffi-1.17.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:733e99bc2df47476e3848417c5a4540522f234dfd4ef3ab7fafdf555b082ec0c", size = 178840, upload-time = "2024-09-04T20:44:13.739Z" }, + { url = "https://files.pythonhosted.org/packages/cc/b6/db007700f67d151abadf508cbfd6a1884f57eab90b1bb985c4c8c02b0f28/cffi-1.17.1-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1257bdabf294dceb59f5e70c64a3e2f462c30c7ad68092d01bbbfb1c16b1ba36", size = 454803, upload-time = "2024-09-04T20:44:15.231Z" }, + { url = "https://files.pythonhosted.org/packages/1a/df/f8d151540d8c200eb1c6fba8cd0dfd40904f1b0682ea705c36e6c2e97ab3/cffi-1.17.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:da95af8214998d77a98cc14e3a3bd00aa191526343078b530ceb0bd710fb48a5", size = 478850, upload-time = "2024-09-04T20:44:17.188Z" }, + { url = "https://files.pythonhosted.org/packages/28/c0/b31116332a547fd2677ae5b78a2ef662dfc8023d67f41b2a83f7c2aa78b1/cffi-1.17.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d63afe322132c194cf832bfec0dc69a99fb9bb6bbd550f161a49e9e855cc78ff", size = 485729, upload-time = "2024-09-04T20:44:18.688Z" }, + { url = "https://files.pythonhosted.org/packages/91/2b/9a1ddfa5c7f13cab007a2c9cc295b70fbbda7cb10a286aa6810338e60ea1/cffi-1.17.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f79fc4fc25f1c8698ff97788206bb3c2598949bfe0fef03d299eb1b5356ada99", size = 471256, upload-time = "2024-09-04T20:44:20.248Z" }, + { url = "https://files.pythonhosted.org/packages/b2/d5/da47df7004cb17e4955df6a43d14b3b4ae77737dff8bf7f8f333196717bf/cffi-1.17.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b62ce867176a75d03a665bad002af8e6d54644fad99a3c70905c543130e39d93", size = 479424, upload-time = "2024-09-04T20:44:21.673Z" }, + { url = "https://files.pythonhosted.org/packages/0b/ac/2a28bcf513e93a219c8a4e8e125534f4f6db03e3179ba1c45e949b76212c/cffi-1.17.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:386c8bf53c502fff58903061338ce4f4950cbdcb23e2902d86c0f722b786bbe3", size = 484568, upload-time = "2024-09-04T20:44:23.245Z" }, + { url = "https://files.pythonhosted.org/packages/d4/38/ca8a4f639065f14ae0f1d9751e70447a261f1a30fa7547a828ae08142465/cffi-1.17.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:4ceb10419a9adf4460ea14cfd6bc43d08701f0835e979bf821052f1805850fe8", size = 488736, upload-time = "2024-09-04T20:44:24.757Z" }, + { url = "https://files.pythonhosted.org/packages/86/c5/28b2d6f799ec0bdecf44dced2ec5ed43e0eb63097b0f58c293583b406582/cffi-1.17.1-cp312-cp312-win32.whl", hash = "sha256:a08d7e755f8ed21095a310a693525137cfe756ce62d066e53f502a83dc550f65", size = 172448, upload-time = "2024-09-04T20:44:26.208Z" }, + { url = "https://files.pythonhosted.org/packages/50/b9/db34c4755a7bd1cb2d1603ac3863f22bcecbd1ba29e5ee841a4bc510b294/cffi-1.17.1-cp312-cp312-win_amd64.whl", hash = "sha256:51392eae71afec0d0c8fb1a53b204dbb3bcabcb3c9b807eedf3e1e6ccf2de903", size = 181976, upload-time = "2024-09-04T20:44:27.578Z" }, + { url = "https://files.pythonhosted.org/packages/8d/f8/dd6c246b148639254dad4d6803eb6a54e8c85c6e11ec9df2cffa87571dbe/cffi-1.17.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f3a2b4222ce6b60e2e8b337bb9596923045681d71e5a082783484d845390938e", size = 182989, upload-time = "2024-09-04T20:44:28.956Z" }, + { url = "https://files.pythonhosted.org/packages/8b/f1/672d303ddf17c24fc83afd712316fda78dc6fce1cd53011b839483e1ecc8/cffi-1.17.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0984a4925a435b1da406122d4d7968dd861c1385afe3b45ba82b750f229811e2", size = 178802, upload-time = "2024-09-04T20:44:30.289Z" }, + { url = "https://files.pythonhosted.org/packages/0e/2d/eab2e858a91fdff70533cab61dcff4a1f55ec60425832ddfdc9cd36bc8af/cffi-1.17.1-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d01b12eeeb4427d3110de311e1774046ad344f5b1a7403101878976ecd7a10f3", size = 454792, upload-time = "2024-09-04T20:44:32.01Z" }, + { url = "https://files.pythonhosted.org/packages/75/b2/fbaec7c4455c604e29388d55599b99ebcc250a60050610fadde58932b7ee/cffi-1.17.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:706510fe141c86a69c8ddc029c7910003a17353970cff3b904ff0686a5927683", size = 478893, upload-time = "2024-09-04T20:44:33.606Z" }, + { url = "https://files.pythonhosted.org/packages/4f/b7/6e4a2162178bf1935c336d4da8a9352cccab4d3a5d7914065490f08c0690/cffi-1.17.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:de55b766c7aa2e2a3092c51e0483d700341182f08e67c63630d5b6f200bb28e5", size = 485810, upload-time = "2024-09-04T20:44:35.191Z" }, + { url = "https://files.pythonhosted.org/packages/c7/8a/1d0e4a9c26e54746dc08c2c6c037889124d4f59dffd853a659fa545f1b40/cffi-1.17.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c59d6e989d07460165cc5ad3c61f9fd8f1b4796eacbd81cee78957842b834af4", size = 471200, upload-time = "2024-09-04T20:44:36.743Z" }, + { url = "https://files.pythonhosted.org/packages/26/9f/1aab65a6c0db35f43c4d1b4f580e8df53914310afc10ae0397d29d697af4/cffi-1.17.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dd398dbc6773384a17fe0d3e7eeb8d1a21c2200473ee6806bb5e6a8e62bb73dd", size = 479447, upload-time = "2024-09-04T20:44:38.492Z" }, + { url = "https://files.pythonhosted.org/packages/5f/e4/fb8b3dd8dc0e98edf1135ff067ae070bb32ef9d509d6cb0f538cd6f7483f/cffi-1.17.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:3edc8d958eb099c634dace3c7e16560ae474aa3803a5df240542b305d14e14ed", size = 484358, upload-time = "2024-09-04T20:44:40.046Z" }, + { url = "https://files.pythonhosted.org/packages/f1/47/d7145bf2dc04684935d57d67dff9d6d795b2ba2796806bb109864be3a151/cffi-1.17.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:72e72408cad3d5419375fc87d289076ee319835bdfa2caad331e377589aebba9", size = 488469, upload-time = "2024-09-04T20:44:41.616Z" }, + { url = "https://files.pythonhosted.org/packages/bf/ee/f94057fa6426481d663b88637a9a10e859e492c73d0384514a17d78ee205/cffi-1.17.1-cp313-cp313-win32.whl", hash = "sha256:e03eab0a8677fa80d646b5ddece1cbeaf556c313dcfac435ba11f107ba117b5d", size = 172475, upload-time = "2024-09-04T20:44:43.733Z" }, + { url = "https://files.pythonhosted.org/packages/7c/fc/6a8cb64e5f0324877d503c854da15d76c1e50eb722e320b15345c4d0c6de/cffi-1.17.1-cp313-cp313-win_amd64.whl", hash = "sha256:f6a16c31041f09ead72d69f583767292f750d24913dadacf5756b966aacb3f1a", size = 182009, upload-time = "2024-09-04T20:44:45.309Z" }, + { url = "https://files.pythonhosted.org/packages/b9/ea/8bb50596b8ffbc49ddd7a1ad305035daa770202a6b782fc164647c2673ad/cffi-1.17.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:b2ab587605f4ba0bf81dc0cb08a41bd1c0a5906bd59243d56bad7668a6fc6c16", size = 182220, upload-time = "2024-09-04T20:45:01.577Z" }, + { url = "https://files.pythonhosted.org/packages/ae/11/e77c8cd24f58285a82c23af484cf5b124a376b32644e445960d1a4654c3a/cffi-1.17.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:28b16024becceed8c6dfbc75629e27788d8a3f9030691a1dbf9821a128b22c36", size = 178605, upload-time = "2024-09-04T20:45:03.837Z" }, + { url = "https://files.pythonhosted.org/packages/ed/65/25a8dc32c53bf5b7b6c2686b42ae2ad58743f7ff644844af7cdb29b49361/cffi-1.17.1-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1d599671f396c4723d016dbddb72fe8e0397082b0a77a4fab8028923bec050e8", size = 424910, upload-time = "2024-09-04T20:45:05.315Z" }, + { url = "https://files.pythonhosted.org/packages/42/7a/9d086fab7c66bd7c4d0f27c57a1b6b068ced810afc498cc8c49e0088661c/cffi-1.17.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ca74b8dbe6e8e8263c0ffd60277de77dcee6c837a3d0881d8c1ead7268c9e576", size = 447200, upload-time = "2024-09-04T20:45:06.903Z" }, + { url = "https://files.pythonhosted.org/packages/da/63/1785ced118ce92a993b0ec9e0d0ac8dc3e5dbfbcaa81135be56c69cabbb6/cffi-1.17.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f7f5baafcc48261359e14bcd6d9bff6d4b28d9103847c9e136694cb0501aef87", size = 454565, upload-time = "2024-09-04T20:45:08.975Z" }, + { url = "https://files.pythonhosted.org/packages/74/06/90b8a44abf3556599cdec107f7290277ae8901a58f75e6fe8f970cd72418/cffi-1.17.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:98e3969bcff97cae1b2def8ba499ea3d6f31ddfdb7635374834cf89a1a08ecf0", size = 435635, upload-time = "2024-09-04T20:45:10.64Z" }, + { url = "https://files.pythonhosted.org/packages/bd/62/a1f468e5708a70b1d86ead5bab5520861d9c7eacce4a885ded9faa7729c3/cffi-1.17.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cdf5ce3acdfd1661132f2a9c19cac174758dc2352bfe37d98aa7512c6b7178b3", size = 445218, upload-time = "2024-09-04T20:45:12.366Z" }, + { url = "https://files.pythonhosted.org/packages/5b/95/b34462f3ccb09c2594aa782d90a90b045de4ff1f70148ee79c69d37a0a5a/cffi-1.17.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:9755e4345d1ec879e3849e62222a18c7174d65a6a92d5b346b1863912168b595", size = 460486, upload-time = "2024-09-04T20:45:13.935Z" }, + { url = "https://files.pythonhosted.org/packages/fc/fc/a1e4bebd8d680febd29cf6c8a40067182b64f00c7d105f8f26b5bc54317b/cffi-1.17.1-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:f1e22e8c4419538cb197e4dd60acc919d7696e5ef98ee4da4e01d3f8cfa4cc5a", size = 437911, upload-time = "2024-09-04T20:45:15.696Z" }, + { url = "https://files.pythonhosted.org/packages/e6/c3/21cab7a6154b6a5ea330ae80de386e7665254835b9e98ecc1340b3a7de9a/cffi-1.17.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:c03e868a0b3bc35839ba98e74211ed2b05d2119be4e8a0f224fba9384f1fe02e", size = 460632, upload-time = "2024-09-04T20:45:17.284Z" }, + { url = "https://files.pythonhosted.org/packages/cb/b5/fd9f8b5a84010ca169ee49f4e4ad6f8c05f4e3545b72ee041dbbcb159882/cffi-1.17.1-cp39-cp39-win32.whl", hash = "sha256:e31ae45bc2e29f6b2abd0de1cc3b9d5205aa847cafaecb8af1476a609a2f6eb7", size = 171820, upload-time = "2024-09-04T20:45:18.762Z" }, + { url = "https://files.pythonhosted.org/packages/8c/52/b08750ce0bce45c143e1b5d7357ee8c55341b52bdef4b0f081af1eb248c2/cffi-1.17.1-cp39-cp39-win_amd64.whl", hash = "sha256:d016c76bdd850f3c626af19b0542c9677ba156e4ee4fccfdd7848803533ef662", size = 181290, upload-time = "2024-09-04T20:45:20.226Z" }, +] + +[[package]] +name = "charset-normalizer" +version = "3.4.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e4/33/89c2ced2b67d1c2a61c19c6751aa8902d46ce3dacb23600a283619f5a12d/charset_normalizer-3.4.2.tar.gz", hash = "sha256:5baececa9ecba31eff645232d59845c07aa030f0c81ee70184a90d35099a0e63", size = 126367, upload-time = "2025-05-02T08:34:42.01Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/95/28/9901804da60055b406e1a1c5ba7aac1276fb77f1dde635aabfc7fd84b8ab/charset_normalizer-3.4.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:7c48ed483eb946e6c04ccbe02c6b4d1d48e51944b6db70f697e089c193404941", size = 201818, upload-time = "2025-05-02T08:31:46.725Z" }, + { url = "https://files.pythonhosted.org/packages/d9/9b/892a8c8af9110935e5adcbb06d9c6fe741b6bb02608c6513983048ba1a18/charset_normalizer-3.4.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b2d318c11350e10662026ad0eb71bb51c7812fc8590825304ae0bdd4ac283acd", size = 144649, upload-time = "2025-05-02T08:31:48.889Z" }, + { url = "https://files.pythonhosted.org/packages/7b/a5/4179abd063ff6414223575e008593861d62abfc22455b5d1a44995b7c101/charset_normalizer-3.4.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9cbfacf36cb0ec2897ce0ebc5d08ca44213af24265bd56eca54bee7923c48fd6", size = 155045, upload-time = "2025-05-02T08:31:50.757Z" }, + { url = "https://files.pythonhosted.org/packages/3b/95/bc08c7dfeddd26b4be8c8287b9bb055716f31077c8b0ea1cd09553794665/charset_normalizer-3.4.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:18dd2e350387c87dabe711b86f83c9c78af772c748904d372ade190b5c7c9d4d", size = 147356, upload-time = "2025-05-02T08:31:52.634Z" }, + { url = "https://files.pythonhosted.org/packages/a8/2d/7a5b635aa65284bf3eab7653e8b4151ab420ecbae918d3e359d1947b4d61/charset_normalizer-3.4.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8075c35cd58273fee266c58c0c9b670947c19df5fb98e7b66710e04ad4e9ff86", size = 149471, upload-time = "2025-05-02T08:31:56.207Z" }, + { url = "https://files.pythonhosted.org/packages/ae/38/51fc6ac74251fd331a8cfdb7ec57beba8c23fd5493f1050f71c87ef77ed0/charset_normalizer-3.4.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5bf4545e3b962767e5c06fe1738f951f77d27967cb2caa64c28be7c4563e162c", size = 151317, upload-time = "2025-05-02T08:31:57.613Z" }, + { url = "https://files.pythonhosted.org/packages/b7/17/edee1e32215ee6e9e46c3e482645b46575a44a2d72c7dfd49e49f60ce6bf/charset_normalizer-3.4.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:7a6ab32f7210554a96cd9e33abe3ddd86732beeafc7a28e9955cdf22ffadbab0", size = 146368, upload-time = "2025-05-02T08:31:59.468Z" }, + { url = "https://files.pythonhosted.org/packages/26/2c/ea3e66f2b5f21fd00b2825c94cafb8c326ea6240cd80a91eb09e4a285830/charset_normalizer-3.4.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:b33de11b92e9f75a2b545d6e9b6f37e398d86c3e9e9653c4864eb7e89c5773ef", size = 154491, upload-time = "2025-05-02T08:32:01.219Z" }, + { url = "https://files.pythonhosted.org/packages/52/47/7be7fa972422ad062e909fd62460d45c3ef4c141805b7078dbab15904ff7/charset_normalizer-3.4.2-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:8755483f3c00d6c9a77f490c17e6ab0c8729e39e6390328e42521ef175380ae6", size = 157695, upload-time = "2025-05-02T08:32:03.045Z" }, + { url = "https://files.pythonhosted.org/packages/2f/42/9f02c194da282b2b340f28e5fb60762de1151387a36842a92b533685c61e/charset_normalizer-3.4.2-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:68a328e5f55ec37c57f19ebb1fdc56a248db2e3e9ad769919a58672958e8f366", size = 154849, upload-time = "2025-05-02T08:32:04.651Z" }, + { url = "https://files.pythonhosted.org/packages/67/44/89cacd6628f31fb0b63201a618049be4be2a7435a31b55b5eb1c3674547a/charset_normalizer-3.4.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:21b2899062867b0e1fde9b724f8aecb1af14f2778d69aacd1a5a1853a597a5db", size = 150091, upload-time = "2025-05-02T08:32:06.719Z" }, + { url = "https://files.pythonhosted.org/packages/1f/79/4b8da9f712bc079c0f16b6d67b099b0b8d808c2292c937f267d816ec5ecc/charset_normalizer-3.4.2-cp310-cp310-win32.whl", hash = "sha256:e8082b26888e2f8b36a042a58307d5b917ef2b1cacab921ad3323ef91901c71a", size = 98445, upload-time = "2025-05-02T08:32:08.66Z" }, + { url = "https://files.pythonhosted.org/packages/7d/d7/96970afb4fb66497a40761cdf7bd4f6fca0fc7bafde3a84f836c1f57a926/charset_normalizer-3.4.2-cp310-cp310-win_amd64.whl", hash = "sha256:f69a27e45c43520f5487f27627059b64aaf160415589230992cec34c5e18a509", size = 105782, upload-time = "2025-05-02T08:32:10.46Z" }, + { url = "https://files.pythonhosted.org/packages/05/85/4c40d00dcc6284a1c1ad5de5e0996b06f39d8232f1031cd23c2f5c07ee86/charset_normalizer-3.4.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:be1e352acbe3c78727a16a455126d9ff83ea2dfdcbc83148d2982305a04714c2", size = 198794, upload-time = "2025-05-02T08:32:11.945Z" }, + { url = "https://files.pythonhosted.org/packages/41/d9/7a6c0b9db952598e97e93cbdfcb91bacd89b9b88c7c983250a77c008703c/charset_normalizer-3.4.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aa88ca0b1932e93f2d961bf3addbb2db902198dca337d88c89e1559e066e7645", size = 142846, upload-time = "2025-05-02T08:32:13.946Z" }, + { url = "https://files.pythonhosted.org/packages/66/82/a37989cda2ace7e37f36c1a8ed16c58cf48965a79c2142713244bf945c89/charset_normalizer-3.4.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d524ba3f1581b35c03cb42beebab4a13e6cdad7b36246bd22541fa585a56cccd", size = 153350, upload-time = "2025-05-02T08:32:15.873Z" }, + { url = "https://files.pythonhosted.org/packages/df/68/a576b31b694d07b53807269d05ec3f6f1093e9545e8607121995ba7a8313/charset_normalizer-3.4.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:28a1005facc94196e1fb3e82a3d442a9d9110b8434fc1ded7a24a2983c9888d8", size = 145657, upload-time = "2025-05-02T08:32:17.283Z" }, + { url = "https://files.pythonhosted.org/packages/92/9b/ad67f03d74554bed3aefd56fe836e1623a50780f7c998d00ca128924a499/charset_normalizer-3.4.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fdb20a30fe1175ecabed17cbf7812f7b804b8a315a25f24678bcdf120a90077f", size = 147260, upload-time = "2025-05-02T08:32:18.807Z" }, + { url = "https://files.pythonhosted.org/packages/a6/e6/8aebae25e328160b20e31a7e9929b1578bbdc7f42e66f46595a432f8539e/charset_normalizer-3.4.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0f5d9ed7f254402c9e7d35d2f5972c9bbea9040e99cd2861bd77dc68263277c7", size = 149164, upload-time = "2025-05-02T08:32:20.333Z" }, + { url = "https://files.pythonhosted.org/packages/8b/f2/b3c2f07dbcc248805f10e67a0262c93308cfa149a4cd3d1fe01f593e5fd2/charset_normalizer-3.4.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:efd387a49825780ff861998cd959767800d54f8308936b21025326de4b5a42b9", size = 144571, upload-time = "2025-05-02T08:32:21.86Z" }, + { url = "https://files.pythonhosted.org/packages/60/5b/c3f3a94bc345bc211622ea59b4bed9ae63c00920e2e8f11824aa5708e8b7/charset_normalizer-3.4.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:f0aa37f3c979cf2546b73e8222bbfa3dc07a641585340179d768068e3455e544", size = 151952, upload-time = "2025-05-02T08:32:23.434Z" }, + { url = "https://files.pythonhosted.org/packages/e2/4d/ff460c8b474122334c2fa394a3f99a04cf11c646da895f81402ae54f5c42/charset_normalizer-3.4.2-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:e70e990b2137b29dc5564715de1e12701815dacc1d056308e2b17e9095372a82", size = 155959, upload-time = "2025-05-02T08:32:24.993Z" }, + { url = "https://files.pythonhosted.org/packages/a2/2b/b964c6a2fda88611a1fe3d4c400d39c66a42d6c169c924818c848f922415/charset_normalizer-3.4.2-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:0c8c57f84ccfc871a48a47321cfa49ae1df56cd1d965a09abe84066f6853b9c0", size = 153030, upload-time = "2025-05-02T08:32:26.435Z" }, + { url = "https://files.pythonhosted.org/packages/59/2e/d3b9811db26a5ebf444bc0fa4f4be5aa6d76fc6e1c0fd537b16c14e849b6/charset_normalizer-3.4.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:6b66f92b17849b85cad91259efc341dce9c1af48e2173bf38a85c6329f1033e5", size = 148015, upload-time = "2025-05-02T08:32:28.376Z" }, + { url = "https://files.pythonhosted.org/packages/90/07/c5fd7c11eafd561bb51220d600a788f1c8d77c5eef37ee49454cc5c35575/charset_normalizer-3.4.2-cp311-cp311-win32.whl", hash = "sha256:daac4765328a919a805fa5e2720f3e94767abd632ae410a9062dff5412bae65a", size = 98106, upload-time = "2025-05-02T08:32:30.281Z" }, + { url = "https://files.pythonhosted.org/packages/a8/05/5e33dbef7e2f773d672b6d79f10ec633d4a71cd96db6673625838a4fd532/charset_normalizer-3.4.2-cp311-cp311-win_amd64.whl", hash = "sha256:e53efc7c7cee4c1e70661e2e112ca46a575f90ed9ae3fef200f2a25e954f4b28", size = 105402, upload-time = "2025-05-02T08:32:32.191Z" }, + { url = "https://files.pythonhosted.org/packages/d7/a4/37f4d6035c89cac7930395a35cc0f1b872e652eaafb76a6075943754f095/charset_normalizer-3.4.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0c29de6a1a95f24b9a1aa7aefd27d2487263f00dfd55a77719b530788f75cff7", size = 199936, upload-time = "2025-05-02T08:32:33.712Z" }, + { url = "https://files.pythonhosted.org/packages/ee/8a/1a5e33b73e0d9287274f899d967907cd0bf9c343e651755d9307e0dbf2b3/charset_normalizer-3.4.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cddf7bd982eaa998934a91f69d182aec997c6c468898efe6679af88283b498d3", size = 143790, upload-time = "2025-05-02T08:32:35.768Z" }, + { url = "https://files.pythonhosted.org/packages/66/52/59521f1d8e6ab1482164fa21409c5ef44da3e9f653c13ba71becdd98dec3/charset_normalizer-3.4.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fcbe676a55d7445b22c10967bceaaf0ee69407fbe0ece4d032b6eb8d4565982a", size = 153924, upload-time = "2025-05-02T08:32:37.284Z" }, + { url = "https://files.pythonhosted.org/packages/86/2d/fb55fdf41964ec782febbf33cb64be480a6b8f16ded2dbe8db27a405c09f/charset_normalizer-3.4.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d41c4d287cfc69060fa91cae9683eacffad989f1a10811995fa309df656ec214", size = 146626, upload-time = "2025-05-02T08:32:38.803Z" }, + { url = "https://files.pythonhosted.org/packages/8c/73/6ede2ec59bce19b3edf4209d70004253ec5f4e319f9a2e3f2f15601ed5f7/charset_normalizer-3.4.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4e594135de17ab3866138f496755f302b72157d115086d100c3f19370839dd3a", size = 148567, upload-time = "2025-05-02T08:32:40.251Z" }, + { url = "https://files.pythonhosted.org/packages/09/14/957d03c6dc343c04904530b6bef4e5efae5ec7d7990a7cbb868e4595ee30/charset_normalizer-3.4.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:cf713fe9a71ef6fd5adf7a79670135081cd4431c2943864757f0fa3a65b1fafd", size = 150957, upload-time = "2025-05-02T08:32:41.705Z" }, + { url = "https://files.pythonhosted.org/packages/0d/c8/8174d0e5c10ccebdcb1b53cc959591c4c722a3ad92461a273e86b9f5a302/charset_normalizer-3.4.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a370b3e078e418187da8c3674eddb9d983ec09445c99a3a263c2011993522981", size = 145408, upload-time = "2025-05-02T08:32:43.709Z" }, + { url = "https://files.pythonhosted.org/packages/58/aa/8904b84bc8084ac19dc52feb4f5952c6df03ffb460a887b42615ee1382e8/charset_normalizer-3.4.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:a955b438e62efdf7e0b7b52a64dc5c3396e2634baa62471768a64bc2adb73d5c", size = 153399, upload-time = "2025-05-02T08:32:46.197Z" }, + { url = "https://files.pythonhosted.org/packages/c2/26/89ee1f0e264d201cb65cf054aca6038c03b1a0c6b4ae998070392a3ce605/charset_normalizer-3.4.2-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:7222ffd5e4de8e57e03ce2cef95a4c43c98fcb72ad86909abdfc2c17d227fc1b", size = 156815, upload-time = "2025-05-02T08:32:48.105Z" }, + { url = "https://files.pythonhosted.org/packages/fd/07/68e95b4b345bad3dbbd3a8681737b4338ff2c9df29856a6d6d23ac4c73cb/charset_normalizer-3.4.2-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:bee093bf902e1d8fc0ac143c88902c3dfc8941f7ea1d6a8dd2bcb786d33db03d", size = 154537, upload-time = "2025-05-02T08:32:49.719Z" }, + { url = "https://files.pythonhosted.org/packages/77/1a/5eefc0ce04affb98af07bc05f3bac9094513c0e23b0562d64af46a06aae4/charset_normalizer-3.4.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:dedb8adb91d11846ee08bec4c8236c8549ac721c245678282dcb06b221aab59f", size = 149565, upload-time = "2025-05-02T08:32:51.404Z" }, + { url = "https://files.pythonhosted.org/packages/37/a0/2410e5e6032a174c95e0806b1a6585eb21e12f445ebe239fac441995226a/charset_normalizer-3.4.2-cp312-cp312-win32.whl", hash = "sha256:db4c7bf0e07fc3b7d89ac2a5880a6a8062056801b83ff56d8464b70f65482b6c", size = 98357, upload-time = "2025-05-02T08:32:53.079Z" }, + { url = "https://files.pythonhosted.org/packages/6c/4f/c02d5c493967af3eda9c771ad4d2bbc8df6f99ddbeb37ceea6e8716a32bc/charset_normalizer-3.4.2-cp312-cp312-win_amd64.whl", hash = "sha256:5a9979887252a82fefd3d3ed2a8e3b937a7a809f65dcb1e068b090e165bbe99e", size = 105776, upload-time = "2025-05-02T08:32:54.573Z" }, + { url = "https://files.pythonhosted.org/packages/ea/12/a93df3366ed32db1d907d7593a94f1fe6293903e3e92967bebd6950ed12c/charset_normalizer-3.4.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:926ca93accd5d36ccdabd803392ddc3e03e6d4cd1cf17deff3b989ab8e9dbcf0", size = 199622, upload-time = "2025-05-02T08:32:56.363Z" }, + { url = "https://files.pythonhosted.org/packages/04/93/bf204e6f344c39d9937d3c13c8cd5bbfc266472e51fc8c07cb7f64fcd2de/charset_normalizer-3.4.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:eba9904b0f38a143592d9fc0e19e2df0fa2e41c3c3745554761c5f6447eedabf", size = 143435, upload-time = "2025-05-02T08:32:58.551Z" }, + { url = "https://files.pythonhosted.org/packages/22/2a/ea8a2095b0bafa6c5b5a55ffdc2f924455233ee7b91c69b7edfcc9e02284/charset_normalizer-3.4.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3fddb7e2c84ac87ac3a947cb4e66d143ca5863ef48e4a5ecb83bd48619e4634e", size = 153653, upload-time = "2025-05-02T08:33:00.342Z" }, + { url = "https://files.pythonhosted.org/packages/b6/57/1b090ff183d13cef485dfbe272e2fe57622a76694061353c59da52c9a659/charset_normalizer-3.4.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:98f862da73774290f251b9df8d11161b6cf25b599a66baf087c1ffe340e9bfd1", size = 146231, upload-time = "2025-05-02T08:33:02.081Z" }, + { url = "https://files.pythonhosted.org/packages/e2/28/ffc026b26f441fc67bd21ab7f03b313ab3fe46714a14b516f931abe1a2d8/charset_normalizer-3.4.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6c9379d65defcab82d07b2a9dfbfc2e95bc8fe0ebb1b176a3190230a3ef0e07c", size = 148243, upload-time = "2025-05-02T08:33:04.063Z" }, + { url = "https://files.pythonhosted.org/packages/c0/0f/9abe9bd191629c33e69e47c6ef45ef99773320e9ad8e9cb08b8ab4a8d4cb/charset_normalizer-3.4.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e635b87f01ebc977342e2697d05b56632f5f879a4f15955dfe8cef2448b51691", size = 150442, upload-time = "2025-05-02T08:33:06.418Z" }, + { url = "https://files.pythonhosted.org/packages/67/7c/a123bbcedca91d5916c056407f89a7f5e8fdfce12ba825d7d6b9954a1a3c/charset_normalizer-3.4.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:1c95a1e2902a8b722868587c0e1184ad5c55631de5afc0eb96bc4b0d738092c0", size = 145147, upload-time = "2025-05-02T08:33:08.183Z" }, + { url = "https://files.pythonhosted.org/packages/ec/fe/1ac556fa4899d967b83e9893788e86b6af4d83e4726511eaaad035e36595/charset_normalizer-3.4.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ef8de666d6179b009dce7bcb2ad4c4a779f113f12caf8dc77f0162c29d20490b", size = 153057, upload-time = "2025-05-02T08:33:09.986Z" }, + { url = "https://files.pythonhosted.org/packages/2b/ff/acfc0b0a70b19e3e54febdd5301a98b72fa07635e56f24f60502e954c461/charset_normalizer-3.4.2-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:32fc0341d72e0f73f80acb0a2c94216bd704f4f0bce10aedea38f30502b271ff", size = 156454, upload-time = "2025-05-02T08:33:11.814Z" }, + { url = "https://files.pythonhosted.org/packages/92/08/95b458ce9c740d0645feb0e96cea1f5ec946ea9c580a94adfe0b617f3573/charset_normalizer-3.4.2-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:289200a18fa698949d2b39c671c2cc7a24d44096784e76614899a7ccf2574b7b", size = 154174, upload-time = "2025-05-02T08:33:13.707Z" }, + { url = "https://files.pythonhosted.org/packages/78/be/8392efc43487ac051eee6c36d5fbd63032d78f7728cb37aebcc98191f1ff/charset_normalizer-3.4.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4a476b06fbcf359ad25d34a057b7219281286ae2477cc5ff5e3f70a246971148", size = 149166, upload-time = "2025-05-02T08:33:15.458Z" }, + { url = "https://files.pythonhosted.org/packages/44/96/392abd49b094d30b91d9fbda6a69519e95802250b777841cf3bda8fe136c/charset_normalizer-3.4.2-cp313-cp313-win32.whl", hash = "sha256:aaeeb6a479c7667fbe1099af9617c83aaca22182d6cf8c53966491a0f1b7ffb7", size = 98064, upload-time = "2025-05-02T08:33:17.06Z" }, + { url = "https://files.pythonhosted.org/packages/e9/b0/0200da600134e001d91851ddc797809e2fe0ea72de90e09bec5a2fbdaccb/charset_normalizer-3.4.2-cp313-cp313-win_amd64.whl", hash = "sha256:aa6af9e7d59f9c12b33ae4e9450619cf2488e2bbe9b44030905877f0b2324980", size = 105641, upload-time = "2025-05-02T08:33:18.753Z" }, + { url = "https://files.pythonhosted.org/packages/28/f8/dfb01ff6cc9af38552c69c9027501ff5a5117c4cc18dcd27cb5259fa1888/charset_normalizer-3.4.2-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:005fa3432484527f9732ebd315da8da8001593e2cf46a3d817669f062c3d9ed4", size = 201671, upload-time = "2025-05-02T08:34:12.696Z" }, + { url = "https://files.pythonhosted.org/packages/32/fb/74e26ee556a9dbfe3bd264289b67be1e6d616329403036f6507bb9f3f29c/charset_normalizer-3.4.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e92fca20c46e9f5e1bb485887d074918b13543b1c2a1185e69bb8d17ab6236a7", size = 144744, upload-time = "2025-05-02T08:34:14.665Z" }, + { url = "https://files.pythonhosted.org/packages/ad/06/8499ee5aa7addc6f6d72e068691826ff093329fe59891e83b092ae4c851c/charset_normalizer-3.4.2-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:50bf98d5e563b83cc29471fa114366e6806bc06bc7a25fd59641e41445327836", size = 154993, upload-time = "2025-05-02T08:34:17.134Z" }, + { url = "https://files.pythonhosted.org/packages/f1/a2/5e4c187680728219254ef107a6949c60ee0e9a916a5dadb148c7ae82459c/charset_normalizer-3.4.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:721c76e84fe669be19c5791da68232ca2e05ba5185575086e384352e2c309597", size = 147382, upload-time = "2025-05-02T08:34:19.081Z" }, + { url = "https://files.pythonhosted.org/packages/4c/fe/56aca740dda674f0cc1ba1418c4d84534be51f639b5f98f538b332dc9a95/charset_normalizer-3.4.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:82d8fd25b7f4675d0c47cf95b594d4e7b158aca33b76aa63d07186e13c0e0ab7", size = 149536, upload-time = "2025-05-02T08:34:21.073Z" }, + { url = "https://files.pythonhosted.org/packages/53/13/db2e7779f892386b589173dd689c1b1e304621c5792046edd8a978cbf9e0/charset_normalizer-3.4.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b3daeac64d5b371dea99714f08ffc2c208522ec6b06fbc7866a450dd446f5c0f", size = 151349, upload-time = "2025-05-02T08:34:23.193Z" }, + { url = "https://files.pythonhosted.org/packages/69/35/e52ab9a276186f729bce7a0638585d2982f50402046e4b0faa5d2c3ef2da/charset_normalizer-3.4.2-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:dccab8d5fa1ef9bfba0590ecf4d46df048d18ffe3eec01eeb73a42e0d9e7a8ba", size = 146365, upload-time = "2025-05-02T08:34:25.187Z" }, + { url = "https://files.pythonhosted.org/packages/a6/d8/af7333f732fc2e7635867d56cb7c349c28c7094910c72267586947561b4b/charset_normalizer-3.4.2-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:aaf27faa992bfee0264dc1f03f4c75e9fcdda66a519db6b957a3f826e285cf12", size = 154499, upload-time = "2025-05-02T08:34:27.359Z" }, + { url = "https://files.pythonhosted.org/packages/7a/3d/a5b2e48acef264d71e036ff30bcc49e51bde80219bb628ba3e00cf59baac/charset_normalizer-3.4.2-cp39-cp39-musllinux_1_2_ppc64le.whl", hash = "sha256:eb30abc20df9ab0814b5a2524f23d75dcf83cde762c161917a2b4b7b55b1e518", size = 157735, upload-time = "2025-05-02T08:34:29.798Z" }, + { url = "https://files.pythonhosted.org/packages/85/d8/23e2c112532a29f3eef374375a8684a4f3b8e784f62b01da931186f43494/charset_normalizer-3.4.2-cp39-cp39-musllinux_1_2_s390x.whl", hash = "sha256:c72fbbe68c6f32f251bdc08b8611c7b3060612236e960ef848e0a517ddbe76c5", size = 154786, upload-time = "2025-05-02T08:34:31.858Z" }, + { url = "https://files.pythonhosted.org/packages/c7/57/93e0169f08ecc20fe82d12254a200dfaceddc1c12a4077bf454ecc597e33/charset_normalizer-3.4.2-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:982bb1e8b4ffda883b3d0a521e23abcd6fd17418f6d2c4118d257a10199c0ce3", size = 150203, upload-time = "2025-05-02T08:34:33.88Z" }, + { url = "https://files.pythonhosted.org/packages/2c/9d/9bf2b005138e7e060d7ebdec7503d0ef3240141587651f4b445bdf7286c2/charset_normalizer-3.4.2-cp39-cp39-win32.whl", hash = "sha256:43e0933a0eff183ee85833f341ec567c0980dae57c464d8a508e1b2ceb336471", size = 98436, upload-time = "2025-05-02T08:34:35.907Z" }, + { url = "https://files.pythonhosted.org/packages/6d/24/5849d46cf4311bbf21b424c443b09b459f5b436b1558c04e45dbb7cc478b/charset_normalizer-3.4.2-cp39-cp39-win_amd64.whl", hash = "sha256:d11b54acf878eef558599658b0ffca78138c8c3655cf4f3a4a673c437e67732e", size = 105772, upload-time = "2025-05-02T08:34:37.935Z" }, + { url = "https://files.pythonhosted.org/packages/20/94/c5790835a017658cbfabd07f3bfb549140c3ac458cfc196323996b10095a/charset_normalizer-3.4.2-py3-none-any.whl", hash = "sha256:7f56930ab0abd1c45cd15be65cc741c28b1c9a34876ce8c17a2fa107810c0af0", size = 52626, upload-time = "2025-05-02T08:34:40.053Z" }, +] + +[[package]] +name = "click" +version = "8.1.8" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.10'", +] +dependencies = [ + { name = "colorama", marker = "python_full_version < '3.10' and sys_platform == 'win32'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b9/2e/0090cbf739cee7d23781ad4b89a9894a41538e4fcf4c31dcdd705b78eb8b/click-8.1.8.tar.gz", hash = "sha256:ed53c9d8990d83c2a27deae68e4ee337473f6330c040a31d4225c9574d16096a", size = 226593, upload-time = "2024-12-21T18:38:44.339Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/d4/7ebdbd03970677812aac39c869717059dbb71a4cfc033ca6e5221787892c/click-8.1.8-py3-none-any.whl", hash = "sha256:63c132bbbed01578a06712a2d1f497bb62d9c1c0d329b7903a866228027263b2", size = 98188, upload-time = "2024-12-21T18:38:41.666Z" }, +] + +[[package]] +name = "click" +version = "8.2.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", +] +dependencies = [ + { name = "colorama", marker = "python_full_version >= '3.10' and 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 = "clickhouse-connect" +version = "0.8.17" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "lz4" }, + { name = "pytz" }, + { name = "urllib3", version = "1.26.20", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, + { name = "urllib3", version = "2.4.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "zstandard" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c2/c2/e46db00486e02007551ff9ba8880ebee9f6d564b26b9323bc9f83f961849/clickhouse_connect-0.8.17.tar.gz", hash = "sha256:16405a37f8229a83956fbc372598d03b876537ee3acf2a5ad2f660336879b3fa", size = 91247, upload-time = "2025-04-12T22:56:10.889Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ba/9d/ebee7d08e6cd162eaa2e8682fb4dfa323b6a9ae679b23e40e9ad1b2315b6/clickhouse_connect-0.8.17-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:9d962ebdfb0be18685b2b60c0b117d13eb91e05744dcf0778e3ff2f6f5a87e52", size = 258229, upload-time = "2025-04-12T22:54:25.064Z" }, + { url = "https://files.pythonhosted.org/packages/f5/b2/ed42834c606ae6ade9a2cb44f3e1cb6b197242fe77b83b62010093dd4cec/clickhouse_connect-0.8.17-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:41476c523bd5c6c5f656059b48f0f3408c73080c2771e7f811fef58b29c16e42", size = 251577, upload-time = "2025-04-12T22:54:26.925Z" }, + { url = "https://files.pythonhosted.org/packages/7f/a0/cec0de8d0549956a962e6ee29d5e66c7fa19d2a132a8df792b2f4d345432/clickhouse_connect-0.8.17-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:989e0aad99be01f51019382770cf27d49e7502e146fc6a326640054e8002ddcd", size = 964204, upload-time = "2025-04-12T22:54:28.36Z" }, + { url = "https://files.pythonhosted.org/packages/41/95/049bef419bfae18a4d40eac2196d38ce93311446de1eba29ee3997590f44/clickhouse_connect-0.8.17-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c4c3d821e2d28a750245ce40ca5063c6c2683b7c92414951eb5385ed5a41f134", size = 979485, upload-time = "2025-04-12T22:54:29.869Z" }, + { url = "https://files.pythonhosted.org/packages/7c/9e/a021fa47a8ee200f82cdc2dec32f0603d76223cce509d99ab5512d9bcb19/clickhouse_connect-0.8.17-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2e0746ada3132cba1d0928baa048bdc309a11eb49cb19338928377198d97211c", size = 955589, upload-time = "2025-04-12T22:54:31.466Z" }, + { url = "https://files.pythonhosted.org/packages/d0/41/ac8c5b26197177c4b151eb88795eb59ecbb9b171c7b884cc750ce65f7a0a/clickhouse_connect-0.8.17-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:0b6e02350ddc3700bf4f541e79bcb781c4137d1e2a5f7bcda60fcc9703678dea", size = 970720, upload-time = "2025-04-12T22:54:32.856Z" }, + { url = "https://files.pythonhosted.org/packages/62/ad/f7c6387c97089c87014d39add30212d5f034905f80c8f81d3b7bc767f0ad/clickhouse_connect-0.8.17-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:55293a1554de20e7eadc2d921939db48445617221e57bf1565dea1ed738dc21f", size = 993388, upload-time = "2025-04-12T22:54:34.236Z" }, + { url = "https://files.pythonhosted.org/packages/53/0d/2053f66ce648a2b8d92a767ab3c648d860e9f26fa6719e9e83ad8023fe8d/clickhouse_connect-0.8.17-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:c25fdf175af6be5d2de775ad7f823e9f877ecb3de8a29ca64fba66aaa291855f", size = 1004387, upload-time = "2025-04-12T22:54:36.117Z" }, + { url = "https://files.pythonhosted.org/packages/09/d8/09c3875b87d241525440ab4874204fd77ebbde4a914b4fb3ebbdaa1b4fe1/clickhouse_connect-0.8.17-cp310-cp310-win32.whl", hash = "sha256:dcfe77e985ade54609c0f8bff90120ff5ac12cd3f1df80b975613756ac1bf2fe", size = 229922, upload-time = "2025-04-12T22:54:37.194Z" }, + { url = "https://files.pythonhosted.org/packages/62/43/89d087aafdebacec99d69537633bab83d589433a93cf1ef4aa6f465d5f4b/clickhouse_connect-0.8.17-cp310-cp310-win_amd64.whl", hash = "sha256:1869bf1ec1397ec3d995354d28e6655b4ca854d43ec706471ed74821de22bcdc", size = 246985, upload-time = "2025-04-12T22:54:38.21Z" }, + { url = "https://files.pythonhosted.org/packages/cb/31/2077ded60a46f7a4ac16ab23b73be1e817975e45dcfef4d8c1803f4e84cc/clickhouse_connect-0.8.17-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:d292a4c73ec863115875b91533003427ef4cdd4931e899064488ce2c75d22d4e", size = 258605, upload-time = "2025-04-12T22:54:39.477Z" }, + { url = "https://files.pythonhosted.org/packages/6d/b6/744f7f9664d9611b5835cc9b8c5d27ae2c6e826bd974712dccd8be4c31ec/clickhouse_connect-0.8.17-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:45f3d55bf17ff69f63ca0150cdd77436d35f5cf85e672056798befe06651b78c", size = 251649, upload-time = "2025-04-12T22:54:40.914Z" }, + { url = "https://files.pythonhosted.org/packages/63/53/b03dfd20fd8fa090c4d6d70f96b2e2e44574408de2561d6b68fbb6dd371e/clickhouse_connect-0.8.17-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5ecc8539cdbcde71394d242665329ad3d32477a9a8d21449876f4a841def0a2d", size = 1061626, upload-time = "2025-04-12T22:54:42.396Z" }, + { url = "https://files.pythonhosted.org/packages/33/3f/c1f80477ab5b90d8e50480410d1f384ca1fdbf800c6e5b72a029699cffb6/clickhouse_connect-0.8.17-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ab35c6eec3758c65d61fe6f96bd13e242f7a7cd27dcb6fbe527db0285011f400", size = 1072472, upload-time = "2025-04-12T22:54:43.977Z" }, + { url = "https://files.pythonhosted.org/packages/22/08/076fa97e065ac5b5bc8d50c5ea24f9ac852c5b6d2f60ee2f54b57eb230b2/clickhouse_connect-0.8.17-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:db2227650d3cf34f3b1bafc207ec113697e58b7b08f0947014e5d66f2687d702", size = 1034338, upload-time = "2025-04-12T22:54:45.181Z" }, + { url = "https://files.pythonhosted.org/packages/f2/01/5218d78c97683fd4789030287fcc7f239003e93bad71634c5c58b3535afc/clickhouse_connect-0.8.17-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6c25c76a07ab2d4188b9923d76a61bf6f6e7a1a9e702ec1124cff4478e4bc3b7", size = 1066617, upload-time = "2025-04-12T22:54:46.776Z" }, + { url = "https://files.pythonhosted.org/packages/0d/bb/3916a0a675245598d52ea4f72eb2ba2e1f79cc45aee632a48fd757c18a19/clickhouse_connect-0.8.17-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:f257922b32949f18013bb52e71f50f2eb4667458d73d5782861b46e22081221f", size = 1072619, upload-time = "2025-04-12T22:54:47.981Z" }, + { url = "https://files.pythonhosted.org/packages/78/8c/5feb108128ca33b687bb03bcc8ff52be35d26cbba291af9504f6aed55fd6/clickhouse_connect-0.8.17-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:8b59c22ed333f20d547aaf9b1dbd5fd475b2861da8acbb59633503b41b51fdf2", size = 1103629, upload-time = "2025-04-12T22:54:49.613Z" }, + { url = "https://files.pythonhosted.org/packages/58/c1/ce42d2381c29cd2b6a08ae7810639de95bc53051240ca87ab1c59f3da9ab/clickhouse_connect-0.8.17-cp311-cp311-win32.whl", hash = "sha256:6613e1b863535a94b438b946e0dc4619fe83d8a021d99f947d88eee95568838e", size = 229555, upload-time = "2025-04-12T22:54:51.297Z" }, + { url = "https://files.pythonhosted.org/packages/4a/dd/050a2c10856ef08dce5c188c26c750881b6a2a7dd5be829eaab334cb0fb0/clickhouse_connect-0.8.17-cp311-cp311-win_amd64.whl", hash = "sha256:d6879fa613128229a397ea5f31612bc1731dad72759a7b566ee684c600e61c90", size = 247119, upload-time = "2025-04-12T22:54:52.369Z" }, + { url = "https://files.pythonhosted.org/packages/3d/18/da233967602118f985088ae29ed7fa8b24a6893178ccce35ff6b09261606/clickhouse_connect-0.8.17-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:ca0a9d39af57c269f2c26a3142ca31812bde82a5a176d89c2ee1b9500d1e471d", size = 262090, upload-time = "2025-04-12T22:54:53.689Z" }, + { url = "https://files.pythonhosted.org/packages/61/cf/9a2efb2cc72bb2312bc3ca5464239b31388c537aef60278cbfbf8a0134ff/clickhouse_connect-0.8.17-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:cac30623ed9ca51c3619751b23567901e8a85025e8c4fde11dc64292f68a3dee", size = 253789, upload-time = "2025-04-12T22:54:54.798Z" }, + { url = "https://files.pythonhosted.org/packages/f7/75/7b083fcbc9e5b4e92a56c08a5eb943412d1a6e5c01b137bd62e06d56525d/clickhouse_connect-0.8.17-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6e0f7f3dde0c9ffae210a402574bb3ea30a9fef1b6d1fbc81d95e67a8ac7799d", size = 1058039, upload-time = "2025-04-12T22:54:56.062Z" }, + { url = "https://files.pythonhosted.org/packages/1a/58/339bd60c3d0a16eb793badd6a67bfdcbc13c10b0232ea7e6feae2390ba10/clickhouse_connect-0.8.17-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3a85d11ff8d115a707ee91c86b96ef1d8e92e2c34ab3f3ce41241ec0ebae78d5", size = 1076405, upload-time = "2025-04-12T22:54:57.33Z" }, + { url = "https://files.pythonhosted.org/packages/dd/e8/26dac5044f197f985c52263861f6771c39449e642fcad83374dbce1c70b0/clickhouse_connect-0.8.17-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:32cfe3a81b8b3d58af62948c0cdfd3fe0aaab6e35299ddfe6a556c9c3c00c37d", size = 1031665, upload-time = "2025-04-12T22:54:58.675Z" }, + { url = "https://files.pythonhosted.org/packages/81/39/dd7977f111e77f16a4d7e7249104ef9a4a7c86c0569a3b792352c560a15e/clickhouse_connect-0.8.17-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ba1e360fa7a28f6dcfa584c82e0a03db26a71e91e14c115a2d70603eea43cbac", size = 1057311, upload-time = "2025-04-12T22:55:00.028Z" }, + { url = "https://files.pythonhosted.org/packages/3d/68/a46278e295658cc508ffc33b008491a8e14d85ebd60873167aaf0f8c9cc1/clickhouse_connect-0.8.17-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:4ea849c2dcb1712fd209d8b58fe3fcf016b65b30ff6aadae444194f470bbd800", size = 1073995, upload-time = "2025-04-12T22:55:01.798Z" }, + { url = "https://files.pythonhosted.org/packages/12/9e/095de494d63ebf0f90369b4f3ef9c50de0488a0e2771e84aa767ee99f743/clickhouse_connect-0.8.17-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:d0a34eb004e0dcbc1583d4fc31918e665794cdcc242150f1e699c75a7aa46b7d", size = 1099316, upload-time = "2025-04-12T22:55:03.566Z" }, + { url = "https://files.pythonhosted.org/packages/87/35/3c1335dab9184985b5e73b6f31dda60ba56ab7d05b6c43bf89339eda031b/clickhouse_connect-0.8.17-cp312-cp312-win32.whl", hash = "sha256:b77f5c8aca4d7ed87649afbda1eea62cd16406c74029e85f28512b24c2165106", size = 229349, upload-time = "2025-04-12T22:55:04.837Z" }, + { url = "https://files.pythonhosted.org/packages/10/3c/e507a6bd392c6618c90deb634a7447a9e11af41dc66e9f141c117d8de232/clickhouse_connect-0.8.17-cp312-cp312-win_amd64.whl", hash = "sha256:01903b8989afc3cf60f959695d56e38c20033a3dbb88aae42af857eb16e028b0", size = 247420, upload-time = "2025-04-12T22:55:06.022Z" }, + { url = "https://files.pythonhosted.org/packages/83/17/918d5c2396426502ad4ed84b314f3699b8d0834f9741823ba59362aa8205/clickhouse_connect-0.8.17-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f0772cc3de3df5a460c2a5a4ef5b3737da7bfbc93b91e88000cf712f5a7ab5f9", size = 259327, upload-time = "2025-04-12T22:55:07.186Z" }, + { url = "https://files.pythonhosted.org/packages/43/ce/fb6374bab859d145c403d49cb270998c2fa92f8eac1291fb2dad963e27d6/clickhouse_connect-0.8.17-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:dffcb1767c684eac1ae9f2fb5c40cc98e23bd3b57f9fb090cd31f4fd2add898b", size = 250996, upload-time = "2025-04-12T22:55:08.352Z" }, + { url = "https://files.pythonhosted.org/packages/67/e4/b749f0b402781140702775e2b9d7674679f104b8701034252d51f1fc5194/clickhouse_connect-0.8.17-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4b1bd03750e69b2f278fff6e041a5d8b059656735e4d8c60ee82d647645481f1", size = 1041001, upload-time = "2025-04-12T22:55:09.54Z" }, + { url = "https://files.pythonhosted.org/packages/9f/ec/84745d52d9e15449234debee0b90789113bd057347f87cee582ce59100d0/clickhouse_connect-0.8.17-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:030395cbd6e64e467f004fe481346849e482d38a87004103df7a806835851171", size = 1059424, upload-time = "2025-04-12T22:55:10.966Z" }, + { url = "https://files.pythonhosted.org/packages/71/d2/8e55c77aad1882ac210a8ec0924bd4bc771a03f390991d4768f42992ea16/clickhouse_connect-0.8.17-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0e44328e12997d361e02d1f8208e1f151133d372f8ef85a524fc622385e69096", size = 1015033, upload-time = "2025-04-12T22:55:12.478Z" }, + { url = "https://files.pythonhosted.org/packages/6c/ae/b37a84923675437e88d8974bf15e75368a781767fd556861205dbd9d2a43/clickhouse_connect-0.8.17-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:44a00808be2c72754e0c0c76005a9ecdb9ef08cb5490f82c45224455ccb47b1c", size = 1042049, upload-time = "2025-04-12T22:55:13.811Z" }, + { url = "https://files.pythonhosted.org/packages/0c/46/214b8bd87b6a56c2d7bf31edc48c5ea2ffa0b1485ced97f198befd1d232e/clickhouse_connect-0.8.17-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:4ab8ea92a2b48dd09f26a491989628244a29231d56731aa53e29b10a8fcabe7e", size = 1057463, upload-time = "2025-04-12T22:55:15.157Z" }, + { url = "https://files.pythonhosted.org/packages/fc/e1/551af37d606b4ae39ddc254bc1348787dc02d1af53748f9a4d522653e61c/clickhouse_connect-0.8.17-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a6b2111c0b5cecef6f63f57af4e882fe7289918d5f61fd16068b721878e8610f", size = 1084897, upload-time = "2025-04-12T22:55:16.518Z" }, + { url = "https://files.pythonhosted.org/packages/88/e7/b5059eb293e4d1968385854471fe50c7f1196085bc99e9a439a8798fa367/clickhouse_connect-0.8.17-cp313-cp313-win32.whl", hash = "sha256:8430adebbbb401a80357a81c55c8cf42ff1c6f272c12130c22046c0f4225c399", size = 228640, upload-time = "2025-04-12T22:55:17.829Z" }, + { url = "https://files.pythonhosted.org/packages/b7/8f/a9be019232982608cf9619a746d46215951d62a4aecbdc3241219c523251/clickhouse_connect-0.8.17-cp313-cp313-win_amd64.whl", hash = "sha256:097209544de81c8c4a5e659c50089066bd92ebfb4a0c96cc7853f7c98bbf7487", size = 246393, upload-time = "2025-04-12T22:55:19.384Z" }, + { url = "https://files.pythonhosted.org/packages/c6/b5/a227f024e55d34e9a55d40c54c5c476183baac1fb04d0455447eb44a71ed/clickhouse_connect-0.8.17-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:03ba0e155aa0d821083fd0ce18acf2a3f911ea1737836e6d2e2b8e9729b6b038", size = 259548, upload-time = "2025-04-12T22:55:29.788Z" }, + { url = "https://files.pythonhosted.org/packages/9b/d3/933d8cc30709697d38bf7928e6869604172baa641c5c2ffe425bdde78eea/clickhouse_connect-0.8.17-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:40654052209dcd6206cd25f6d23ed7e769c655dd14543679172642ff987db306", size = 252758, upload-time = "2025-04-12T22:55:31.471Z" }, + { url = "https://files.pythonhosted.org/packages/cd/20/44c5e9f6ba7ea47911af2dd021cb911c1f8f9fcdbaf3486290f5e8bb777f/clickhouse_connect-0.8.17-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ff7c7b70d7798f0d118790e558d02f72da02ecf6e9319b517865b2fbbbe13cdb", size = 969911, upload-time = "2025-04-12T22:55:33.313Z" }, + { url = "https://files.pythonhosted.org/packages/44/12/7a1b19b9cb8c59e7b4ed161b429bea8ca2053fe231cfa7946353616708e3/clickhouse_connect-0.8.17-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e419d47989f6bf8b5c4a102cbbbc3d22d8cb4a419322f77a06a63f6c61e7ac01", size = 984131, upload-time = "2025-04-12T22:55:34.697Z" }, + { url = "https://files.pythonhosted.org/packages/8a/0c/6b3419aa9dca69f155951d6292a1a4b08c5fbbd5d21622f433506a442676/clickhouse_connect-0.8.17-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e02be85ed1eba1f02effd9ea3d0227c34881b8288667fa69810eeff855b63cab", size = 960995, upload-time = "2025-04-12T22:55:36.148Z" }, + { url = "https://files.pythonhosted.org/packages/a7/f1/2bbade6efd5ec47796073341a43ff37c8278df3ee89f4d0ba11ec7ee49aa/clickhouse_connect-0.8.17-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:412218fb550de88fba848465b249c42dc72f7cbde3d28d81dd4cd3486bf169ab", size = 975321, upload-time = "2025-04-12T22:55:38.254Z" }, + { url = "https://files.pythonhosted.org/packages/2b/9f/a997891d576741027b5f6bca7c4908f9ace8c2fe1ee8d51dce0ffdeca7fe/clickhouse_connect-0.8.17-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:6d31607dda56c7fd19dfbca3e8c856ca59a5bfb2184762d9d381ea903faaa04b", size = 994276, upload-time = "2025-04-12T22:55:40.118Z" }, + { url = "https://files.pythonhosted.org/packages/27/c7/8ad9b11ecc8fbc7f021a20c95ad316daef40eb251702df0335b827a4c6c1/clickhouse_connect-0.8.17-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:a13b17b2e4be568a133fa137c1257c599b19d9380301a39da2675b30647cacd0", size = 1009465, upload-time = "2025-04-12T22:55:42.048Z" }, + { url = "https://files.pythonhosted.org/packages/5c/b9/88e71985dc8ebb20c8e18875de6eb648c81d59e685f5e45e3ff97ce19b7b/clickhouse_connect-0.8.17-cp39-cp39-win32.whl", hash = "sha256:8205b80ae0bcb04787ab8a6a417f34768ff036202056d9aa12f5a79ab1e9d222", size = 231212, upload-time = "2025-04-12T22:55:43.703Z" }, + { url = "https://files.pythonhosted.org/packages/2e/b1/bd7c94d8cff62dc6ccaecae707b6570b4464165c5295236d37b0f3eaa264/clickhouse_connect-0.8.17-cp39-cp39-win_amd64.whl", hash = "sha256:a7b1d30d3bb3488a8209fa60e8004a6e29e9e2ba53c516a3911db76e740870b2", size = 248041, upload-time = "2025-04-12T22:55:45.398Z" }, + { url = "https://files.pythonhosted.org/packages/25/fd/7b6e9d251ee97fa82f405bfcd45e9e8406bf5f735f88e32022f096e06425/clickhouse_connect-0.8.17-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:c3d5253e289d01a8416d3340828b8a3b093027c0efcc95632e010e5ce825c5f2", size = 230259, upload-time = "2025-04-12T22:55:46.701Z" }, + { url = "https://files.pythonhosted.org/packages/e6/0d/bc9ff448ddb89b035322c5ce311c60273f9d41e5731e0a41533554e6411f/clickhouse_connect-0.8.17-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:4554d0fe2e44bcf753ebc85d21b73a6af870ad08407e92fc1d83bbc108633af4", size = 226380, upload-time = "2025-04-12T22:55:48.073Z" }, + { url = "https://files.pythonhosted.org/packages/77/7a/8d6fa1bfee2366d8f69361a573bc8fd950467cc945502a97d9c79ab12bf7/clickhouse_connect-0.8.17-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b6026c359c0e8a60bf95476be5fed24aca1b71d4b29b873b23b31ef5cbb4fa27", size = 255277, upload-time = "2025-04-12T22:55:49.475Z" }, + { url = "https://files.pythonhosted.org/packages/f8/b2/00f5451a520ed9b7ac52059ddbca89532592f4c145e7cf13916b71f58df2/clickhouse_connect-0.8.17-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4ddb1edcfb5ef3cf533163f2db6323f124d593517fca7e34ca75a32efef4a551", size = 262415, upload-time = "2025-04-12T22:55:51.642Z" }, + { url = "https://files.pythonhosted.org/packages/a9/f5/d726f9d72eb5adcc85945d2470d1136173ff667e35b72372ff5cf9d48af7/clickhouse_connect-0.8.17-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a009f24989703d00349823c7dd7c7c442311d7f00bebedad53bc7946ea4d9e52", size = 268476, upload-time = "2025-04-12T22:55:53.058Z" }, + { url = "https://files.pythonhosted.org/packages/da/5b/091b6a02a4ec7aad9209f581a7f9141c660e9133f573a9057e2ccdb5c7ce/clickhouse_connect-0.8.17-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:8456604f2ce3f0623c9d7101710d15b59b069b4095813ad3d850b9376c8e8bd8", size = 234410, upload-time = "2025-04-12T22:55:54.441Z" }, + { url = "https://files.pythonhosted.org/packages/d0/62/a00a0fc1c0a50a57247f83fa676440df41912fe894f81796422cca891d41/clickhouse_connect-0.8.17-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:ab9b3a6f1f0888df36983d5bff4901ac025236f5deef0b1964396d4c0a522408", size = 229967, upload-time = "2025-04-12T22:56:01.634Z" }, + { url = "https://files.pythonhosted.org/packages/23/92/32a14206b7f55788d693b47714bfa3c8dfcf01276b553102ba6284ca97d5/clickhouse_connect-0.8.17-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:5a63103616c247d4c7d4ad99dccd53d238ccf26e93a1437ac2ff8c73b27fdfa5", size = 226080, upload-time = "2025-04-12T22:56:02.991Z" }, + { url = "https://files.pythonhosted.org/packages/14/98/504002eb8ba2adae1767d4da40ceabf95bd814b6be5aea0fb098f463e1cd/clickhouse_connect-0.8.17-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0385e738b155e8cd47f83cdcafb0e985c12c9b6b94e7abd0299d45ef76ea7740", size = 254895, upload-time = "2025-04-12T22:56:04.755Z" }, + { url = "https://files.pythonhosted.org/packages/ca/01/98cef34c31ffc597f406aea7a7d3bfb4eaaebb4927d11827a4089cb8ac03/clickhouse_connect-0.8.17-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e6f45f7fe44ed4df0d1a19a5c4ea875c6a393e5cf89f0d47a7761cc90c93c6d9", size = 262120, upload-time = "2025-04-12T22:56:06.185Z" }, + { url = "https://files.pythonhosted.org/packages/bc/22/82506daba2c6c89373c3a31a145be2f1d299755c6b8f47151d7a401023aa/clickhouse_connect-0.8.17-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3b031c51fc922d62c6ea05883413527ec2372b01722875dd3b1e13a140550e58", size = 268270, upload-time = "2025-04-12T22:56:08.119Z" }, + { url = "https://files.pythonhosted.org/packages/08/f1/a32554961629b9c950c479ab36caab9d3af9c638e96a8a0a44128b31cda0/clickhouse_connect-0.8.17-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:b72e6a37fe588abc1d2f1e87abb71a1d6d5369be2131c33ebc4f87a7b84a8cac", size = 234202, upload-time = "2025-04-12T22:56:09.535Z" }, +] + +[[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 = "exceptiongroup" +version = "1.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0b/9f/a65090624ecf468cdca03533906e7c69ed7588582240cfe7cc9e770b50eb/exceptiongroup-1.3.0.tar.gz", hash = "sha256:b241f5885f560bc56a59ee63ca4c6a8bfa46ae4ad651af316d4e81817bb9fd88", size = 29749, upload-time = "2025-05-10T17:42:51.123Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/36/f4/c6e662dade71f56cd2f3735141b265c3c79293c109549c1e6933b0651ffc/exceptiongroup-1.3.0-py3-none-any.whl", hash = "sha256:4d111e6e0c13d0644cad6ddaa7ed0261a0b36971f6d23e7ec9b4b9097da78a10", size = 16674, upload-time = "2025-05-10T17:42:49.33Z" }, +] + +[[package]] +name = "fsspec" +version = "2025.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/00/f7/27f15d41f0ed38e8fcc488584b57e902b331da7f7c6dcda53721b15838fc/fsspec-2025.5.1.tar.gz", hash = "sha256:2e55e47a540b91843b755e83ded97c6e897fa0942b11490113f09e9c443c2475", size = 303033, upload-time = "2025-05-24T12:03:23.792Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bb/61/78c7b3851add1481b048b5fdc29067397a1784e2910592bc81bb3f608635/fsspec-2025.5.1-py3-none-any.whl", hash = "sha256:24d3a2e663d5fc735ab256263c4075f374a174c3410c0b25e5bd1970bceaa462", size = 199052, upload-time = "2025-05-24T12:03:21.66Z" }, +] + +[[package]] +name = "idna" +version = "3.10" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f1/70/7703c29685631f5a7590aa73f1f1d3fa9a380e654b86af429e0934a32f7d/idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9", size = 190490, upload-time = "2024-09-15T18:07:39.745Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/76/c6/c88e154df9c4e1a2a66ccf0005a88dfb2650c1dffb6f5ce603dfbd452ce3/idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3", size = 70442, upload-time = "2024-09-15T18:07:37.964Z" }, +] + +[[package]] +name = "iniconfig" +version = "2.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f2/97/ebf4da567aa6827c909642694d71c9fcf53e5b504f2d96afea02718862f3/iniconfig-2.1.0.tar.gz", hash = "sha256:3abbd2e30b36733fee78f9c7f7308f2d0050e88f0087fd25c2645f63c773e1c7", size = 4793, upload-time = "2025-03-19T20:09:59.721Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2c/e1/e6716421ea10d38022b952c159d5161ca1193197fb744506875fbb87ea7b/iniconfig-2.1.0-py3-none-any.whl", hash = "sha256:9deba5723312380e77435581c6bf4935c94cbfab9b1ed33ef8d238ea168eb760", size = 6050, upload-time = "2025-03-19T20:10:01.071Z" }, +] + +[[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 = "lz4" +version = "4.4.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c6/5a/945f5086326d569f14c84ac6f7fcc3229f0b9b1e8cc536b951fd53dfb9e1/lz4-4.4.4.tar.gz", hash = "sha256:070fd0627ec4393011251a094e08ed9fdcc78cb4e7ab28f507638eee4e39abda", size = 171884, upload-time = "2025-04-01T22:55:58.62Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b0/80/4054e99cda2e003097f59aeb3ad470128f3298db5065174a84564d2d6983/lz4-4.4.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:f170abb8416c4efca48e76cac2c86c3185efdf841aecbe5c190121c42828ced0", size = 220896, upload-time = "2025-04-01T22:55:13.577Z" }, + { url = "https://files.pythonhosted.org/packages/dd/4e/f92424d5734e772b05ddbeec739e2566e2a2336995b36a180e1dd9411e9a/lz4-4.4.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:d33a5105cd96ebd32c3e78d7ece6123a9d2fb7c18b84dec61f27837d9e0c496c", size = 189679, upload-time = "2025-04-01T22:55:15.471Z" }, + { url = "https://files.pythonhosted.org/packages/a2/70/71ffd496067cba6ba352e10b89c0e9cee3e4bc4717ba866b6aa350f4c7ac/lz4-4.4.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:30ebbc5b76b4f0018988825a7e9ce153be4f0d4eba34e6c1f2fcded120573e88", size = 1237940, upload-time = "2025-04-01T22:55:16.498Z" }, + { url = "https://files.pythonhosted.org/packages/6e/59/cf34d1e232b11e1ae7122300be00529f369a7cd80f74ac351d58c4c4eedf/lz4-4.4.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dc64d6dfa7a89397529b22638939e70d85eaedc1bd68e30a29c78bfb65d4f715", size = 1264105, upload-time = "2025-04-01T22:55:17.606Z" }, + { url = "https://files.pythonhosted.org/packages/f9/f6/3a00a98ff5b872d572cc6e9c88e0f6275bea0f3ed1dc1b8f8b736c85784c/lz4-4.4.4-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a355223a284f42a723c120ce68827de66d5cb872a38732b3d5abbf544fa2fe26", size = 1184179, upload-time = "2025-04-01T22:55:19.206Z" }, + { url = "https://files.pythonhosted.org/packages/bc/de/6aeb602786174bad290609c0c988afb1077b74a80eaea23ebc3b5de6e2fa/lz4-4.4.4-cp310-cp310-win32.whl", hash = "sha256:b28228197775b7b5096898851d59ef43ccaf151136f81d9c436bc9ba560bc2ba", size = 88265, upload-time = "2025-04-01T22:55:20.215Z" }, + { url = "https://files.pythonhosted.org/packages/e4/b5/1f52c8b17d02ae637f85911c0135ca08be1c9bbdfb3e7de1c4ae7af0bac6/lz4-4.4.4-cp310-cp310-win_amd64.whl", hash = "sha256:45e7c954546de4f85d895aa735989d77f87dd649f503ce1c8a71a151b092ed36", size = 99916, upload-time = "2025-04-01T22:55:21.332Z" }, + { url = "https://files.pythonhosted.org/packages/01/e7/123587e7dae6cdba48393e4fdad2b9412f43f51346afe9ca6f697029de11/lz4-4.4.4-cp310-cp310-win_arm64.whl", hash = "sha256:e3fc90f766401684740978cd781d73b9685bd81b5dbf7257542ef9de4612e4d2", size = 89746, upload-time = "2025-04-01T22:55:22.205Z" }, + { url = "https://files.pythonhosted.org/packages/28/e8/63843dc5ecb1529eb38e1761ceed04a0ad52a9ad8929ab8b7930ea2e4976/lz4-4.4.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ddfc7194cd206496c445e9e5b0c47f970ce982c725c87bd22de028884125b68f", size = 220898, upload-time = "2025-04-01T22:55:23.085Z" }, + { url = "https://files.pythonhosted.org/packages/e4/94/c53de5f07c7dc11cf459aab2a1d754f5df5f693bfacbbe1e4914bfd02f1e/lz4-4.4.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:714f9298c86f8e7278f1c6af23e509044782fa8220eb0260f8f8f1632f820550", size = 189685, upload-time = "2025-04-01T22:55:24.413Z" }, + { url = "https://files.pythonhosted.org/packages/fe/59/c22d516dd0352f2a3415d1f665ccef2f3e74ecec3ca6a8f061a38f97d50d/lz4-4.4.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a8474c91de47733856c6686df3c4aca33753741da7e757979369c2c0d32918ba", size = 1239225, upload-time = "2025-04-01T22:55:25.737Z" }, + { url = "https://files.pythonhosted.org/packages/81/af/665685072e71f3f0e626221b7922867ec249cd8376aca761078c8f11f5da/lz4-4.4.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:80dd27d7d680ea02c261c226acf1d41de2fd77af4fb2da62b278a9376e380de0", size = 1265881, upload-time = "2025-04-01T22:55:26.817Z" }, + { url = "https://files.pythonhosted.org/packages/90/04/b4557ae381d3aa451388a29755cc410066f5e2f78c847f66f154f4520a68/lz4-4.4.4-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9b7d6dddfd01b49aedb940fdcaf32f41dc58c926ba35f4e31866aeec2f32f4f4", size = 1185593, upload-time = "2025-04-01T22:55:27.896Z" }, + { url = "https://files.pythonhosted.org/packages/7b/e4/03636979f4e8bf92c557f998ca98ee4e6ef92e92eaf0ed6d3c7f2524e790/lz4-4.4.4-cp311-cp311-win32.whl", hash = "sha256:4134b9fd70ac41954c080b772816bb1afe0c8354ee993015a83430031d686a4c", size = 88259, upload-time = "2025-04-01T22:55:29.03Z" }, + { url = "https://files.pythonhosted.org/packages/07/f0/9efe53b4945441a5d2790d455134843ad86739855b7e6199977bf6dc8898/lz4-4.4.4-cp311-cp311-win_amd64.whl", hash = "sha256:f5024d3ca2383470f7c4ef4d0ed8eabad0b22b23eeefde1c192cf1a38d5e9f78", size = 99916, upload-time = "2025-04-01T22:55:29.933Z" }, + { url = "https://files.pythonhosted.org/packages/87/c8/1675527549ee174b9e1db089f7ddfbb962a97314657269b1e0344a5eaf56/lz4-4.4.4-cp311-cp311-win_arm64.whl", hash = "sha256:6ea715bb3357ea1665f77874cf8f55385ff112553db06f3742d3cdcec08633f7", size = 89741, upload-time = "2025-04-01T22:55:31.184Z" }, + { url = "https://files.pythonhosted.org/packages/f7/2d/5523b4fabe11cd98f040f715728d1932eb7e696bfe94391872a823332b94/lz4-4.4.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:23ae267494fdd80f0d2a131beff890cf857f1b812ee72dbb96c3204aab725553", size = 220669, upload-time = "2025-04-01T22:55:32.032Z" }, + { url = "https://files.pythonhosted.org/packages/91/06/1a5bbcacbfb48d8ee5b6eb3fca6aa84143a81d92946bdb5cd6b005f1863e/lz4-4.4.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fff9f3a1ed63d45cb6514bfb8293005dc4141341ce3500abdfeb76124c0b9b2e", size = 189661, upload-time = "2025-04-01T22:55:33.413Z" }, + { url = "https://files.pythonhosted.org/packages/fa/08/39eb7ac907f73e11a69a11576a75a9e36406b3241c0ba41453a7eb842abb/lz4-4.4.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1ea7f07329f85a8eda4d8cf937b87f27f0ac392c6400f18bea2c667c8b7f8ecc", size = 1238775, upload-time = "2025-04-01T22:55:34.835Z" }, + { url = "https://files.pythonhosted.org/packages/e9/26/05840fbd4233e8d23e88411a066ab19f1e9de332edddb8df2b6a95c7fddc/lz4-4.4.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8ccab8f7f7b82f9fa9fc3b0ba584d353bd5aa818d5821d77d5b9447faad2aaad", size = 1265143, upload-time = "2025-04-01T22:55:35.933Z" }, + { url = "https://files.pythonhosted.org/packages/b7/5d/5f2db18c298a419932f3ab2023deb689863cf8fd7ed875b1c43492479af2/lz4-4.4.4-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e43e9d48b2daf80e486213128b0763deed35bbb7a59b66d1681e205e1702d735", size = 1185032, upload-time = "2025-04-01T22:55:37.454Z" }, + { url = "https://files.pythonhosted.org/packages/c4/e6/736ab5f128694b0f6aac58343bcf37163437ac95997276cd0be3ea4c3342/lz4-4.4.4-cp312-cp312-win32.whl", hash = "sha256:33e01e18e4561b0381b2c33d58e77ceee850a5067f0ece945064cbaac2176962", size = 88284, upload-time = "2025-04-01T22:55:38.536Z" }, + { url = "https://files.pythonhosted.org/packages/40/b8/243430cb62319175070e06e3a94c4c7bd186a812e474e22148ae1290d47d/lz4-4.4.4-cp312-cp312-win_amd64.whl", hash = "sha256:d21d1a2892a2dcc193163dd13eaadabb2c1b803807a5117d8f8588b22eaf9f12", size = 99918, upload-time = "2025-04-01T22:55:39.628Z" }, + { url = "https://files.pythonhosted.org/packages/6c/e1/0686c91738f3e6c2e1a243e0fdd4371667c4d2e5009b0a3605806c2aa020/lz4-4.4.4-cp312-cp312-win_arm64.whl", hash = "sha256:2f4f2965c98ab254feddf6b5072854a6935adab7bc81412ec4fe238f07b85f62", size = 89736, upload-time = "2025-04-01T22:55:40.5Z" }, + { url = "https://files.pythonhosted.org/packages/3b/3c/d1d1b926d3688263893461e7c47ed7382a969a0976fc121fc678ec325fc6/lz4-4.4.4-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:ed6eb9f8deaf25ee4f6fad9625d0955183fdc90c52b6f79a76b7f209af1b6e54", size = 220678, upload-time = "2025-04-01T22:55:41.78Z" }, + { url = "https://files.pythonhosted.org/packages/26/89/8783d98deb058800dabe07e6cdc90f5a2a8502a9bad8c5343c641120ace2/lz4-4.4.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:18ae4fe3bafb344dbd09f976d45cbf49c05c34416f2462828f9572c1fa6d5af7", size = 189670, upload-time = "2025-04-01T22:55:42.775Z" }, + { url = "https://files.pythonhosted.org/packages/22/ab/a491ace69a83a8914a49f7391e92ca0698f11b28d5ce7b2ececa2be28e9a/lz4-4.4.4-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:57fd20c5fc1a49d1bbd170836fccf9a338847e73664f8e313dce6ac91b8c1e02", size = 1238746, upload-time = "2025-04-01T22:55:43.797Z" }, + { url = "https://files.pythonhosted.org/packages/97/12/a1f2f4fdc6b7159c0d12249456f9fe454665b6126e98dbee9f2bd3cf735c/lz4-4.4.4-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e9cb387c33f014dae4db8cb4ba789c8d2a0a6d045ddff6be13f6c8d9def1d2a6", size = 1265119, upload-time = "2025-04-01T22:55:44.943Z" }, + { url = "https://files.pythonhosted.org/packages/50/6e/e22e50f5207649db6ea83cd31b79049118305be67e96bec60becf317afc6/lz4-4.4.4-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d0be9f68240231e1e44118a4ebfecd8a5d4184f0bdf5c591c98dd6ade9720afd", size = 1184954, upload-time = "2025-04-01T22:55:46.161Z" }, + { url = "https://files.pythonhosted.org/packages/4c/c4/2a458039645fcc6324ece731d4d1361c5daf960b553d1fcb4261ba07d51c/lz4-4.4.4-cp313-cp313-win32.whl", hash = "sha256:e9ec5d45ea43684f87c316542af061ef5febc6a6b322928f059ce1fb289c298a", size = 88289, upload-time = "2025-04-01T22:55:47.601Z" }, + { url = "https://files.pythonhosted.org/packages/00/96/b8e24ea7537ab418074c226279acfcaa470e1ea8271003e24909b6db942b/lz4-4.4.4-cp313-cp313-win_amd64.whl", hash = "sha256:a760a175b46325b2bb33b1f2bbfb8aa21b48e1b9653e29c10b6834f9bb44ead4", size = 99925, upload-time = "2025-04-01T22:55:48.463Z" }, + { url = "https://files.pythonhosted.org/packages/a5/a5/f9838fe6aa132cfd22733ed2729d0592259fff074cefb80f19aa0607367b/lz4-4.4.4-cp313-cp313-win_arm64.whl", hash = "sha256:f4c21648d81e0dda38b4720dccc9006ae33b0e9e7ffe88af6bf7d4ec124e2fba", size = 89743, upload-time = "2025-04-01T22:55:49.716Z" }, + { url = "https://files.pythonhosted.org/packages/60/92/84d57db743cef59b2277cf40577de12ab48cbcd327772273a81a39d70580/lz4-4.4.4-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:bd1add57b6fe1f96bed2d529de085e9378a3ac04b86f116d10506f85b68e97fc", size = 220887, upload-time = "2025-04-01T22:55:50.607Z" }, + { url = "https://files.pythonhosted.org/packages/87/b7/afa1ba2f827c1ec9d0b571e4fc71a2357a7fc735430cfb9b4c03f94f5d8a/lz4-4.4.4-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:900912e8a7cf74b4a2bea18a3594ae0bf1138f99919c20017167b6e05f760aa4", size = 189664, upload-time = "2025-04-01T22:55:51.579Z" }, + { url = "https://files.pythonhosted.org/packages/6f/6b/bfa74d3412cc9a5c787b44e1941b3186a813f8354ea633aed785ad8af106/lz4-4.4.4-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:017f8d269a739405a59d68a4d63d23a8df23e3bb2c70aa069b7563af08dfdffb", size = 1237318, upload-time = "2025-04-01T22:55:52.55Z" }, + { url = "https://files.pythonhosted.org/packages/b8/c7/3e826333be0034ac702a6fa25ed289002c83a154c69d8b9da7f3583157c5/lz4-4.4.4-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dac522788296a9a02a39f620970dea86c38e141e21e51238f1b5e9fa629f8e69", size = 1263452, upload-time = "2025-04-01T22:55:53.757Z" }, + { url = "https://files.pythonhosted.org/packages/45/e5/06b90dbe76f21475aab0052e0f1a8598d651a5a269f2e9a86f05241142ed/lz4-4.4.4-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6b56aa9eef830bf6443acd8c4e18b208a8993dc32e0d6ef4263ecfa6afb3f599", size = 1183617, upload-time = "2025-04-01T22:55:54.858Z" }, + { url = "https://files.pythonhosted.org/packages/0b/9e/1781ecb72300aed4d74484dff9a16a585e82c5de47c52930bb6e5a415c40/lz4-4.4.4-cp39-cp39-win32.whl", hash = "sha256:585b42eb37ab16a278c3a917ec23b2beef175aa669f4120142b97aebf90ef775", size = 88266, upload-time = "2025-04-01T22:55:55.988Z" }, + { url = "https://files.pythonhosted.org/packages/f8/2d/2426270bc39cd39a49773559137415b5a1bb43d3be75a44807806f5cb503/lz4-4.4.4-cp39-cp39-win_amd64.whl", hash = "sha256:4ab1537bd3b3bfbafd3c8847e06827129794488304f21945fc2f5b669649d94f", size = 99915, upload-time = "2025-04-01T22:55:56.849Z" }, + { url = "https://files.pythonhosted.org/packages/66/ea/cadcd430073925e1acd7c509333101cc1b922593af6779355bf6cc064c73/lz4-4.4.4-cp39-cp39-win_arm64.whl", hash = "sha256:38730927ad51beb42ab8dbc5555270bfbe86167ba734265f88bbd799fced1004", size = 89747, upload-time = "2025-04-01T22:55:57.749Z" }, +] + +[[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]] +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 = "mmh3" +version = "5.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/47/1b/1fc6888c74cbd8abad1292dde2ddfcf8fc059e114c97dd6bf16d12f36293/mmh3-5.1.0.tar.gz", hash = "sha256:136e1e670500f177f49ec106a4ebf0adf20d18d96990cc36ea492c651d2b406c", size = 33728, upload-time = "2025-01-25T08:39:43.386Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a1/01/9d06468928661765c0fc248a29580c760a4a53a9c6c52cf72528bae3582e/mmh3-5.1.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:eaf4ac5c6ee18ca9232238364d7f2a213278ae5ca97897cafaa123fcc7bb8bec", size = 56095, upload-time = "2025-01-25T08:37:53.621Z" }, + { url = "https://files.pythonhosted.org/packages/e4/d7/7b39307fc9db867b2a9a20c58b0de33b778dd6c55e116af8ea031f1433ba/mmh3-5.1.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:48f9aa8ccb9ad1d577a16104834ac44ff640d8de8c0caed09a2300df7ce8460a", size = 40512, upload-time = "2025-01-25T08:37:54.972Z" }, + { url = "https://files.pythonhosted.org/packages/4f/85/728ca68280d8ccc60c113ad119df70ff1748fbd44c89911fed0501faf0b8/mmh3-5.1.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:d4ba8cac21e1f2d4e436ce03a82a7f87cda80378691f760e9ea55045ec480a3d", size = 40110, upload-time = "2025-01-25T08:37:57.86Z" }, + { url = "https://files.pythonhosted.org/packages/e4/96/beaf0e301472ffa00358bbbf771fe2d9c4d709a2fe30b1d929e569f8cbdf/mmh3-5.1.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d69281c281cb01994f054d862a6bb02a2e7acfe64917795c58934b0872b9ece4", size = 100151, upload-time = "2025-01-25T08:37:59.609Z" }, + { url = "https://files.pythonhosted.org/packages/c3/ee/9381f825c4e09ffafeffa213c3865c4bf7d39771640de33ab16f6faeb854/mmh3-5.1.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4d05ed3962312fbda2a1589b97359d2467f677166952f6bd410d8c916a55febf", size = 106312, upload-time = "2025-01-25T08:38:02.102Z" }, + { url = "https://files.pythonhosted.org/packages/67/dc/350a54bea5cf397d357534198ab8119cfd0d8e8bad623b520f9c290af985/mmh3-5.1.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:78ae6a03f4cff4aa92ddd690611168856f8c33a141bd3e5a1e0a85521dc21ea0", size = 104232, upload-time = "2025-01-25T08:38:03.852Z" }, + { url = "https://files.pythonhosted.org/packages/b2/5d/2c6eb4a4ec2f7293b98a9c07cb8c64668330b46ff2b6511244339e69a7af/mmh3-5.1.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:95f983535b39795d9fb7336438faae117424c6798f763d67c6624f6caf2c4c01", size = 91663, upload-time = "2025-01-25T08:38:06.24Z" }, + { url = "https://files.pythonhosted.org/packages/f1/ac/17030d24196f73ecbab8b5033591e5e0e2beca103181a843a135c78f4fee/mmh3-5.1.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d46fdd80d4c7ecadd9faa6181e92ccc6fe91c50991c9af0e371fdf8b8a7a6150", size = 99166, upload-time = "2025-01-25T08:38:07.988Z" }, + { url = "https://files.pythonhosted.org/packages/b9/ed/54ddc56603561a10b33da9b12e95a48a271d126f4a4951841bbd13145ebf/mmh3-5.1.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:0f16e976af7365ea3b5c425124b2a7f0147eed97fdbb36d99857f173c8d8e096", size = 101555, upload-time = "2025-01-25T08:38:09.821Z" }, + { url = "https://files.pythonhosted.org/packages/1c/c3/33fb3a940c9b70908a5cc9fcc26534aff8698180f9f63ab6b7cc74da8bcd/mmh3-5.1.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:6fa97f7d1e1f74ad1565127229d510f3fd65d931fdedd707c1e15100bc9e5ebb", size = 94813, upload-time = "2025-01-25T08:38:11.682Z" }, + { url = "https://files.pythonhosted.org/packages/61/88/c9ff76a23abe34db8eee1a6fa4e449462a16c7eb547546fc5594b0860a72/mmh3-5.1.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:4052fa4a8561bd62648e9eb993c8f3af3bdedadf3d9687aa4770d10e3709a80c", size = 109611, upload-time = "2025-01-25T08:38:12.602Z" }, + { url = "https://files.pythonhosted.org/packages/0b/8e/27d04f40e95554ebe782cac7bddda2d158cf3862387298c9c7b254fa7beb/mmh3-5.1.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:3f0e8ae9f961037f812afe3cce7da57abf734285961fffbeff9a4c011b737732", size = 100515, upload-time = "2025-01-25T08:38:16.407Z" }, + { url = "https://files.pythonhosted.org/packages/7b/00/504ca8f462f01048f3c87cd93f2e1f60b93dac2f930cd4ed73532a9337f5/mmh3-5.1.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:99297f207db967814f1f02135bb7fe7628b9eacb046134a34e1015b26b06edce", size = 100177, upload-time = "2025-01-25T08:38:18.186Z" }, + { url = "https://files.pythonhosted.org/packages/6f/1d/2efc3525fe6fdf8865972fcbb884bd1f4b0f923c19b80891cecf7e239fa5/mmh3-5.1.0-cp310-cp310-win32.whl", hash = "sha256:2e6c8dc3631a5e22007fbdb55e993b2dbce7985c14b25b572dd78403c2e79182", size = 40815, upload-time = "2025-01-25T08:38:19.176Z" }, + { url = "https://files.pythonhosted.org/packages/38/b5/c8fbe707cb0fea77a6d2d58d497bc9b67aff80deb84d20feb34d8fdd8671/mmh3-5.1.0-cp310-cp310-win_amd64.whl", hash = "sha256:e4e8c7ad5a4dddcfde35fd28ef96744c1ee0f9d9570108aa5f7e77cf9cfdf0bf", size = 41479, upload-time = "2025-01-25T08:38:21.098Z" }, + { url = "https://files.pythonhosted.org/packages/a1/f1/663e16134f913fccfbcea5b300fb7dc1860d8f63dc71867b013eebc10aec/mmh3-5.1.0-cp310-cp310-win_arm64.whl", hash = "sha256:45da549269883208912868a07d0364e1418d8292c4259ca11699ba1b2475bd26", size = 38883, upload-time = "2025-01-25T08:38:22.013Z" }, + { url = "https://files.pythonhosted.org/packages/56/09/fda7af7fe65928262098382e3bf55950cfbf67d30bf9e47731bf862161e9/mmh3-5.1.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:0b529dcda3f951ff363a51d5866bc6d63cf57f1e73e8961f864ae5010647079d", size = 56098, upload-time = "2025-01-25T08:38:22.917Z" }, + { url = "https://files.pythonhosted.org/packages/0c/ab/84c7bc3f366d6f3bd8b5d9325a10c367685bc17c26dac4c068e2001a4671/mmh3-5.1.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:4db1079b3ace965e562cdfc95847312f9273eb2ad3ebea983435c8423e06acd7", size = 40513, upload-time = "2025-01-25T08:38:25.079Z" }, + { url = "https://files.pythonhosted.org/packages/4f/21/25ea58ca4a652bdc83d1528bec31745cce35802381fb4fe3c097905462d2/mmh3-5.1.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:22d31e3a0ff89b8eb3b826d6fc8e19532998b2aa6b9143698043a1268da413e1", size = 40112, upload-time = "2025-01-25T08:38:25.947Z" }, + { url = "https://files.pythonhosted.org/packages/bd/78/4f12f16ae074ddda6f06745254fdb50f8cf3c85b0bbf7eaca58bed84bf58/mmh3-5.1.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2139bfbd354cd6cb0afed51c4b504f29bcd687a3b1460b7e89498329cc28a894", size = 102632, upload-time = "2025-01-25T08:38:26.939Z" }, + { url = "https://files.pythonhosted.org/packages/48/11/8f09dc999cf2a09b6138d8d7fc734efb7b7bfdd9adb9383380941caadff0/mmh3-5.1.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8c8105c6a435bc2cd6ea2ef59558ab1a2976fd4a4437026f562856d08996673a", size = 108884, upload-time = "2025-01-25T08:38:29.159Z" }, + { url = "https://files.pythonhosted.org/packages/bd/91/e59a66538a3364176f6c3f7620eee0ab195bfe26f89a95cbcc7a1fb04b28/mmh3-5.1.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:57730067174a7f36fcd6ce012fe359bd5510fdaa5fe067bc94ed03e65dafb769", size = 106835, upload-time = "2025-01-25T08:38:33.04Z" }, + { url = "https://files.pythonhosted.org/packages/25/14/b85836e21ab90e5cddb85fe79c494ebd8f81d96a87a664c488cc9277668b/mmh3-5.1.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:bde80eb196d7fdc765a318604ded74a4378f02c5b46c17aa48a27d742edaded2", size = 93688, upload-time = "2025-01-25T08:38:34.987Z" }, + { url = "https://files.pythonhosted.org/packages/ac/aa/8bc964067df9262740c95e4cde2d19f149f2224f426654e14199a9e47df6/mmh3-5.1.0-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e9c8eddcb441abddeb419c16c56fd74b3e2df9e57f7aa2903221996718435c7a", size = 101569, upload-time = "2025-01-25T08:38:35.983Z" }, + { url = "https://files.pythonhosted.org/packages/70/b6/1fb163cbf919046a64717466c00edabebece3f95c013853fec76dbf2df92/mmh3-5.1.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:99e07e4acafbccc7a28c076a847fb060ffc1406036bc2005acb1b2af620e53c3", size = 98483, upload-time = "2025-01-25T08:38:38.198Z" }, + { url = "https://files.pythonhosted.org/packages/70/49/ba64c050dd646060f835f1db6b2cd60a6485f3b0ea04976e7a29ace7312e/mmh3-5.1.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:9e25ba5b530e9a7d65f41a08d48f4b3fedc1e89c26486361166a5544aa4cad33", size = 96496, upload-time = "2025-01-25T08:38:39.257Z" }, + { url = "https://files.pythonhosted.org/packages/9e/07/f2751d6a0b535bb865e1066e9c6b80852571ef8d61bce7eb44c18720fbfc/mmh3-5.1.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:bb9bf7475b4d99156ce2f0cf277c061a17560c8c10199c910a680869a278ddc7", size = 105109, upload-time = "2025-01-25T08:38:40.395Z" }, + { url = "https://files.pythonhosted.org/packages/b7/02/30360a5a66f7abba44596d747cc1e6fb53136b168eaa335f63454ab7bb79/mmh3-5.1.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:2a1b0878dd281ea3003368ab53ff6f568e175f1b39f281df1da319e58a19c23a", size = 98231, upload-time = "2025-01-25T08:38:42.141Z" }, + { url = "https://files.pythonhosted.org/packages/8c/60/8526b0c750ff4d7ae1266e68b795f14b97758a1d9fcc19f6ecabf9c55656/mmh3-5.1.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:25f565093ac8b8aefe0f61f8f95c9a9d11dd69e6a9e9832ff0d293511bc36258", size = 97548, upload-time = "2025-01-25T08:38:43.402Z" }, + { url = "https://files.pythonhosted.org/packages/6d/4c/26e1222aca65769280d5427a1ce5875ef4213449718c8f03958d0bf91070/mmh3-5.1.0-cp311-cp311-win32.whl", hash = "sha256:1e3554d8792387eac73c99c6eaea0b3f884e7130eb67986e11c403e4f9b6d372", size = 40810, upload-time = "2025-01-25T08:38:45.143Z" }, + { url = "https://files.pythonhosted.org/packages/98/d5/424ba95062d1212ea615dc8debc8d57983f2242d5e6b82e458b89a117a1e/mmh3-5.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:8ad777a48197882492af50bf3098085424993ce850bdda406a358b6ab74be759", size = 41476, upload-time = "2025-01-25T08:38:46.029Z" }, + { url = "https://files.pythonhosted.org/packages/bd/08/0315ccaf087ba55bb19a6dd3b1e8acd491e74ce7f5f9c4aaa06a90d66441/mmh3-5.1.0-cp311-cp311-win_arm64.whl", hash = "sha256:f29dc4efd99bdd29fe85ed6c81915b17b2ef2cf853abf7213a48ac6fb3eaabe1", size = 38880, upload-time = "2025-01-25T08:38:47.035Z" }, + { url = "https://files.pythonhosted.org/packages/f4/47/e5f452bdf16028bfd2edb4e2e35d0441e4a4740f30e68ccd4cfd2fb2c57e/mmh3-5.1.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:45712987367cb9235026e3cbf4334670522a97751abfd00b5bc8bfa022c3311d", size = 56152, upload-time = "2025-01-25T08:38:47.902Z" }, + { url = "https://files.pythonhosted.org/packages/60/38/2132d537dc7a7fdd8d2e98df90186c7fcdbd3f14f95502a24ba443c92245/mmh3-5.1.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b1020735eb35086ab24affbea59bb9082f7f6a0ad517cb89f0fc14f16cea4dae", size = 40564, upload-time = "2025-01-25T08:38:48.839Z" }, + { url = "https://files.pythonhosted.org/packages/c0/2a/c52cf000581bfb8d94794f58865658e7accf2fa2e90789269d4ae9560b16/mmh3-5.1.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:babf2a78ce5513d120c358722a2e3aa7762d6071cd10cede026f8b32452be322", size = 40104, upload-time = "2025-01-25T08:38:49.773Z" }, + { url = "https://files.pythonhosted.org/packages/83/33/30d163ce538c54fc98258db5621447e3ab208d133cece5d2577cf913e708/mmh3-5.1.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d4f47f58cd5cbef968c84a7c1ddc192fef0a36b48b0b8a3cb67354531aa33b00", size = 102634, upload-time = "2025-01-25T08:38:51.5Z" }, + { url = "https://files.pythonhosted.org/packages/94/5c/5a18acb6ecc6852be2d215c3d811aa61d7e425ab6596be940877355d7f3e/mmh3-5.1.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:2044a601c113c981f2c1e14fa33adc9b826c9017034fe193e9eb49a6882dbb06", size = 108888, upload-time = "2025-01-25T08:38:52.542Z" }, + { url = "https://files.pythonhosted.org/packages/1f/f6/11c556324c64a92aa12f28e221a727b6e082e426dc502e81f77056f6fc98/mmh3-5.1.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c94d999c9f2eb2da44d7c2826d3fbffdbbbbcde8488d353fee7c848ecc42b968", size = 106968, upload-time = "2025-01-25T08:38:54.286Z" }, + { url = "https://files.pythonhosted.org/packages/5d/61/ca0c196a685aba7808a5c00246f17b988a9c4f55c594ee0a02c273e404f3/mmh3-5.1.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a015dcb24fa0c7a78f88e9419ac74f5001c1ed6a92e70fd1803f74afb26a4c83", size = 93771, upload-time = "2025-01-25T08:38:55.576Z" }, + { url = "https://files.pythonhosted.org/packages/b4/55/0927c33528710085ee77b808d85bbbafdb91a1db7c8eaa89cac16d6c513e/mmh3-5.1.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:457da019c491a2d20e2022c7d4ce723675e4c081d9efc3b4d8b9f28a5ea789bd", size = 101726, upload-time = "2025-01-25T08:38:56.654Z" }, + { url = "https://files.pythonhosted.org/packages/49/39/a92c60329fa470f41c18614a93c6cd88821412a12ee78c71c3f77e1cfc2d/mmh3-5.1.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:71408579a570193a4ac9c77344d68ddefa440b00468a0b566dcc2ba282a9c559", size = 98523, upload-time = "2025-01-25T08:38:57.662Z" }, + { url = "https://files.pythonhosted.org/packages/81/90/26adb15345af8d9cf433ae1b6adcf12e0a4cad1e692de4fa9f8e8536c5ae/mmh3-5.1.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:8b3a04bc214a6e16c81f02f855e285c6df274a2084787eeafaa45f2fbdef1b63", size = 96628, upload-time = "2025-01-25T08:38:59.505Z" }, + { url = "https://files.pythonhosted.org/packages/8a/4d/340d1e340df972a13fd4ec84c787367f425371720a1044220869c82364e9/mmh3-5.1.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:832dae26a35514f6d3c1e267fa48e8de3c7b978afdafa0529c808ad72e13ada3", size = 105190, upload-time = "2025-01-25T08:39:00.483Z" }, + { url = "https://files.pythonhosted.org/packages/d3/7c/65047d1cccd3782d809936db446430fc7758bda9def5b0979887e08302a2/mmh3-5.1.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:bf658a61fc92ef8a48945ebb1076ef4ad74269e353fffcb642dfa0890b13673b", size = 98439, upload-time = "2025-01-25T08:39:01.484Z" }, + { url = "https://files.pythonhosted.org/packages/72/d2/3c259d43097c30f062050f7e861075099404e8886b5d4dd3cebf180d6e02/mmh3-5.1.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3313577453582b03383731b66447cdcdd28a68f78df28f10d275d7d19010c1df", size = 97780, upload-time = "2025-01-25T08:39:02.444Z" }, + { url = "https://files.pythonhosted.org/packages/29/29/831ea8d4abe96cdb3e28b79eab49cac7f04f9c6b6e36bfc686197ddba09d/mmh3-5.1.0-cp312-cp312-win32.whl", hash = "sha256:1d6508504c531ab86c4424b5a5ff07c1132d063863339cf92f6657ff7a580f76", size = 40835, upload-time = "2025-01-25T08:39:03.369Z" }, + { url = "https://files.pythonhosted.org/packages/12/dd/7cbc30153b73f08eeac43804c1dbc770538a01979b4094edbe1a4b8eb551/mmh3-5.1.0-cp312-cp312-win_amd64.whl", hash = "sha256:aa75981fcdf3f21759d94f2c81b6a6e04a49dfbcdad88b152ba49b8e20544776", size = 41509, upload-time = "2025-01-25T08:39:04.284Z" }, + { url = "https://files.pythonhosted.org/packages/80/9d/627375bab4c90dd066093fc2c9a26b86f87e26d980dbf71667b44cbee3eb/mmh3-5.1.0-cp312-cp312-win_arm64.whl", hash = "sha256:a4c1a76808dfea47f7407a0b07aaff9087447ef6280716fd0783409b3088bb3c", size = 38888, upload-time = "2025-01-25T08:39:05.174Z" }, + { url = "https://files.pythonhosted.org/packages/05/06/a098a42870db16c0a54a82c56a5bdc873de3165218cd5b3ca59dbc0d31a7/mmh3-5.1.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:7a523899ca29cfb8a5239618474a435f3d892b22004b91779fcb83504c0d5b8c", size = 56165, upload-time = "2025-01-25T08:39:06.887Z" }, + { url = "https://files.pythonhosted.org/packages/5a/65/eaada79a67fde1f43e1156d9630e2fb70655e1d3f4e8f33d7ffa31eeacfd/mmh3-5.1.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:17cef2c3a6ca2391ca7171a35ed574b5dab8398163129a3e3a4c05ab85a4ff40", size = 40569, upload-time = "2025-01-25T08:39:07.945Z" }, + { url = "https://files.pythonhosted.org/packages/36/7e/2b6c43ed48be583acd68e34d16f19209a9f210e4669421b0321e326d8554/mmh3-5.1.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:52e12895b30110f3d89dae59a888683cc886ed0472dd2eca77497edef6161997", size = 40104, upload-time = "2025-01-25T08:39:09.598Z" }, + { url = "https://files.pythonhosted.org/packages/11/2b/1f9e962fdde8e41b0f43d22c8ba719588de8952f9376df7d73a434827590/mmh3-5.1.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e0d6719045cda75c3f40397fc24ab67b18e0cb8f69d3429ab4c39763c4c608dd", size = 102497, upload-time = "2025-01-25T08:39:10.512Z" }, + { url = "https://files.pythonhosted.org/packages/46/94/d6c5c3465387ba077cccdc028ab3eec0d86eed1eebe60dcf4d15294056be/mmh3-5.1.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d19fa07d303a91f8858982c37e6939834cb11893cb3ff20e6ee6fa2a7563826a", size = 108834, upload-time = "2025-01-25T08:39:11.568Z" }, + { url = "https://files.pythonhosted.org/packages/34/1e/92c212bb81796b69dddfd50a8a8f4b26ab0d38fdaf1d3e8628a67850543b/mmh3-5.1.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:31b47a620d622fbde8ca1ca0435c5d25de0ac57ab507209245e918128e38e676", size = 106936, upload-time = "2025-01-25T08:39:12.638Z" }, + { url = "https://files.pythonhosted.org/packages/f4/41/f2f494bbff3aad5ffd2085506255049de76cde51ddac84058e32768acc79/mmh3-5.1.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:00f810647c22c179b6821079f7aa306d51953ac893587ee09cf1afb35adf87cb", size = 93709, upload-time = "2025-01-25T08:39:14.071Z" }, + { url = "https://files.pythonhosted.org/packages/9e/a9/a2cc4a756d73d9edf4fb85c76e16fd56b0300f8120fd760c76b28f457730/mmh3-5.1.0-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f6128b610b577eed1e89ac7177ab0c33d06ade2aba93f5c89306032306b5f1c6", size = 101623, upload-time = "2025-01-25T08:39:15.507Z" }, + { url = "https://files.pythonhosted.org/packages/5e/6f/b9d735533b6a56b2d56333ff89be6a55ac08ba7ff33465feb131992e33eb/mmh3-5.1.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:1e550a45d2ff87a1c11b42015107f1778c93f4c6f8e731bf1b8fa770321b8cc4", size = 98521, upload-time = "2025-01-25T08:39:16.77Z" }, + { url = "https://files.pythonhosted.org/packages/99/47/dff2b54fac0d421c1e6ecbd2d9c85b2d0e6f6ee0d10b115d9364116a511e/mmh3-5.1.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:785ae09276342f79fd8092633e2d52c0f7c44d56e8cfda8274ccc9b76612dba2", size = 96696, upload-time = "2025-01-25T08:39:17.805Z" }, + { url = "https://files.pythonhosted.org/packages/be/43/9e205310f47c43ddf1575bb3a1769c36688f30f1ac105e0f0c878a29d2cd/mmh3-5.1.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:0f4be3703a867ef976434afd3661a33884abe73ceb4ee436cac49d3b4c2aaa7b", size = 105234, upload-time = "2025-01-25T08:39:18.908Z" }, + { url = "https://files.pythonhosted.org/packages/6b/44/90b11fd2b67dcb513f5bfe9b476eb6ca2d5a221c79b49884dc859100905e/mmh3-5.1.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:e513983830c4ff1f205ab97152a0050cf7164f1b4783d702256d39c637b9d107", size = 98449, upload-time = "2025-01-25T08:39:20.719Z" }, + { url = "https://files.pythonhosted.org/packages/f0/d0/25c4b0c7b8e49836541059b28e034a4cccd0936202800d43a1cc48495ecb/mmh3-5.1.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:b9135c300535c828c0bae311b659f33a31c941572eae278568d1a953c4a57b59", size = 97796, upload-time = "2025-01-25T08:39:22.453Z" }, + { url = "https://files.pythonhosted.org/packages/23/fa/cbbb7fcd0e287a715f1cd28a10de94c0535bd94164e38b852abc18da28c6/mmh3-5.1.0-cp313-cp313-win32.whl", hash = "sha256:c65dbd12885a5598b70140d24de5839551af5a99b29f9804bb2484b29ef07692", size = 40828, upload-time = "2025-01-25T08:39:23.372Z" }, + { url = "https://files.pythonhosted.org/packages/09/33/9fb90ef822f7b734955a63851907cf72f8a3f9d8eb3c5706bfa6772a2a77/mmh3-5.1.0-cp313-cp313-win_amd64.whl", hash = "sha256:10db7765201fc65003fa998faa067417ef6283eb5f9bba8f323c48fd9c33e91f", size = 41504, upload-time = "2025-01-25T08:39:24.286Z" }, + { url = "https://files.pythonhosted.org/packages/16/71/4ad9a42f2772793a03cb698f0fc42499f04e6e8d2560ba2f7da0fb059a8e/mmh3-5.1.0-cp313-cp313-win_arm64.whl", hash = "sha256:b22fe2e54be81f6c07dcb36b96fa250fb72effe08aa52fbb83eade6e1e2d5fd7", size = 38890, upload-time = "2025-01-25T08:39:25.28Z" }, + { url = "https://files.pythonhosted.org/packages/44/e8/65dae27ee37a8b00bb580cebe62e79e0901f7e06210fd5cf900da1751a50/mmh3-5.1.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:166b67749a1d8c93b06f5e90576f1ba838a65c8e79f28ffd9dfafba7c7d0a084", size = 56106, upload-time = "2025-01-25T08:39:26.287Z" }, + { url = "https://files.pythonhosted.org/packages/73/03/f6c27e317c52f8f12faa2f9fd237f27f50fc7bcd9b862d3d7101932319a5/mmh3-5.1.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:adba83c7ba5cc8ea201ee1e235f8413a68e7f7b8a657d582cc6c6c9d73f2830e", size = 40515, upload-time = "2025-01-25T08:39:27.212Z" }, + { url = "https://files.pythonhosted.org/packages/4c/4d/83927efc3ff223c564d6b2686880ef5087b6215bbfc1b73fcb7a1e0d12ed/mmh3-5.1.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:a61f434736106804eb0b1612d503c4e6eb22ba31b16e6a2f987473de4226fa55", size = 40108, upload-time = "2025-01-25T08:39:28.093Z" }, + { url = "https://files.pythonhosted.org/packages/47/c6/f0e33468cc00729cb4019176288ed1506632dce12ee7a842f1c78d1f2c93/mmh3-5.1.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ba9ce59816b30866093f048b3312c2204ff59806d3a02adee71ff7bd22b87554", size = 99892, upload-time = "2025-01-25T08:39:28.957Z" }, + { url = "https://files.pythonhosted.org/packages/22/16/73e25fc16b17acc0de604a28c716407728777c4d52dae72a0e505e32d281/mmh3-5.1.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:cd51597bef1e503363b05cb579db09269e6e6c39d419486626b255048daf545b", size = 106054, upload-time = "2025-01-25T08:39:29.994Z" }, + { url = "https://files.pythonhosted.org/packages/4f/f3/f9c5e4051e8ab54fd92717906f998f7161bfd3440bcea1b6f84e956e168a/mmh3-5.1.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d51a1ed642d3fb37b8f4cab966811c52eb246c3e1740985f701ef5ad4cdd2145", size = 104004, upload-time = "2025-01-25T08:39:31.788Z" }, + { url = "https://files.pythonhosted.org/packages/e1/18/6452be7e21f792f69e83854bc71fa4443816a6f8e909374a547f2eccdd44/mmh3-5.1.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:709bfe81c53bf8a3609efcbd65c72305ade60944f66138f697eefc1a86b6e356", size = 91420, upload-time = "2025-01-25T08:39:32.804Z" }, + { url = "https://files.pythonhosted.org/packages/66/59/7e16f10ee38f56bb0890d4da2c5bf1bfd77b15ea8e91244eeebdcfc84077/mmh3-5.1.0-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e01a9b0092b6f82e861137c8e9bb9899375125b24012eb5219e61708be320032", size = 98910, upload-time = "2025-01-25T08:39:33.818Z" }, + { url = "https://files.pythonhosted.org/packages/cb/78/f247daea100fb9f4a7aad3fb01aa6e258de12fc594f37415c8dc22d8bd71/mmh3-5.1.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:27e46a2c13c9a805e03c9ec7de0ca8e096794688ab2125bdce4229daf60c4a56", size = 101325, upload-time = "2025-01-25T08:39:34.898Z" }, + { url = "https://files.pythonhosted.org/packages/6e/d6/07ac481d91dc4659c9c556a326e4349d08331b5713a1ac11bf7b063c6bdc/mmh3-5.1.0-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:5766299c1d26f6bfd0a638e070bd17dbd98d4ccb067d64db3745bf178e700ef0", size = 94625, upload-time = "2025-01-25T08:39:35.952Z" }, + { url = "https://files.pythonhosted.org/packages/ff/3a/118c058b05f2396e3c4077183ad8f5d0e0a508c28eaae57b08d6c49a0754/mmh3-5.1.0-cp39-cp39-musllinux_1_2_ppc64le.whl", hash = "sha256:7785205e3e4443fdcbb73766798c7647f94c2f538b90f666688f3e757546069e", size = 109398, upload-time = "2025-01-25T08:39:36.893Z" }, + { url = "https://files.pythonhosted.org/packages/8d/d5/accc9372f70e15db8e8e203940b25ac409e061460cd6f96aab6066bb66a6/mmh3-5.1.0-cp39-cp39-musllinux_1_2_s390x.whl", hash = "sha256:8e574fbd39afb433b3ab95683b1b4bf18313dc46456fc9daaddc2693c19ca565", size = 100319, upload-time = "2025-01-25T08:39:37.954Z" }, + { url = "https://files.pythonhosted.org/packages/bb/98/e157770077a19322483a1ab661fce14b6489bca8da49bd6fece98918c845/mmh3-5.1.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:1b6727a5a20e32cbf605743749f3862abe5f5e097cbf2afc7be5aafd32a549ae", size = 99946, upload-time = "2025-01-25T08:39:38.922Z" }, + { url = "https://files.pythonhosted.org/packages/6d/65/9b5b506e8a88386316d9cff0c4b155262200d1ec95cad6d4287ec240a7fd/mmh3-5.1.0-cp39-cp39-win32.whl", hash = "sha256:d6eaa711d4b9220fe5252032a44bf68e5dcfb7b21745a96efc9e769b0dd57ec2", size = 40823, upload-time = "2025-01-25T08:39:40.13Z" }, + { url = "https://files.pythonhosted.org/packages/bd/67/c4468b21d9d219e0d64708c07936666968c88d92e3542cfb6c47ce06768b/mmh3-5.1.0-cp39-cp39-win_amd64.whl", hash = "sha256:49d444913f6c02980e5241a53fe9af2338f2043d6ce5b6f5ea7d302c52c604ac", size = 41481, upload-time = "2025-01-25T08:39:41.009Z" }, + { url = "https://files.pythonhosted.org/packages/20/bb/cb97418e487632eb1f6fb0f2fa86adbeec102cbf6bfa4ebfc10a8889da2c/mmh3-5.1.0-cp39-cp39-win_arm64.whl", hash = "sha256:0daaeaedd78773b70378f2413c7d6b10239a75d955d30d54f460fb25d599942d", size = 38870, upload-time = "2025-01-25T08:39:41.986Z" }, +] + +[[package]] +name = "mypy" +version = "1.16.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "mypy-extensions" }, + { name = "pathspec" }, + { name = "tomli", marker = "python_full_version < '3.11'" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/d4/38/13c2f1abae94d5ea0354e146b95a1be9b2137a0d506728e0da037c4276f6/mypy-1.16.0.tar.gz", hash = "sha256:84b94283f817e2aa6350a14b4a8fb2a35a53c286f97c9d30f53b63620e7af8ab", size = 3323139, upload-time = "2025-05-29T13:46:12.532Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/64/5e/a0485f0608a3d67029d3d73cec209278b025e3493a3acfda3ef3a88540fd/mypy-1.16.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:7909541fef256527e5ee9c0a7e2aeed78b6cda72ba44298d1334fe7881b05c5c", size = 10967416, upload-time = "2025-05-29T13:34:17.783Z" }, + { url = "https://files.pythonhosted.org/packages/4b/53/5837c221f74c0d53a4bfc3003296f8179c3a2a7f336d7de7bbafbe96b688/mypy-1.16.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e71d6f0090c2256c713ed3d52711d01859c82608b5d68d4fa01a3fe30df95571", size = 10087654, upload-time = "2025-05-29T13:32:37.878Z" }, + { url = "https://files.pythonhosted.org/packages/29/59/5fd2400352c3093bed4c09017fe671d26bc5bb7e6ef2d4bf85f2a2488104/mypy-1.16.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:936ccfdd749af4766be824268bfe22d1db9eb2f34a3ea1d00ffbe5b5265f5491", size = 11875192, upload-time = "2025-05-29T13:34:54.281Z" }, + { url = "https://files.pythonhosted.org/packages/ad/3e/4bfec74663a64c2012f3e278dbc29ffe82b121bc551758590d1b6449ec0c/mypy-1.16.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4086883a73166631307fdd330c4a9080ce24913d4f4c5ec596c601b3a4bdd777", size = 12612939, upload-time = "2025-05-29T13:33:14.766Z" }, + { url = "https://files.pythonhosted.org/packages/88/1f/fecbe3dcba4bf2ca34c26ca016383a9676711907f8db4da8354925cbb08f/mypy-1.16.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:feec38097f71797da0231997e0de3a58108c51845399669ebc532c815f93866b", size = 12874719, upload-time = "2025-05-29T13:21:52.09Z" }, + { url = "https://files.pythonhosted.org/packages/f3/51/c2d280601cd816c43dfa512a759270d5a5ef638d7ac9bea9134c8305a12f/mypy-1.16.0-cp310-cp310-win_amd64.whl", hash = "sha256:09a8da6a0ee9a9770b8ff61b39c0bb07971cda90e7297f4213741b48a0cc8d93", size = 9487053, upload-time = "2025-05-29T13:33:29.797Z" }, + { url = "https://files.pythonhosted.org/packages/24/c4/ff2f79db7075c274fe85b5fff8797d29c6b61b8854c39e3b7feb556aa377/mypy-1.16.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:9f826aaa7ff8443bac6a494cf743f591488ea940dd360e7dd330e30dd772a5ab", size = 10884498, upload-time = "2025-05-29T13:18:54.066Z" }, + { url = "https://files.pythonhosted.org/packages/02/07/12198e83006235f10f6a7808917376b5d6240a2fd5dce740fe5d2ebf3247/mypy-1.16.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:82d056e6faa508501af333a6af192c700b33e15865bda49611e3d7d8358ebea2", size = 10011755, upload-time = "2025-05-29T13:34:00.851Z" }, + { url = "https://files.pythonhosted.org/packages/f1/9b/5fd5801a72b5d6fb6ec0105ea1d0e01ab2d4971893076e558d4b6d6b5f80/mypy-1.16.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:089bedc02307c2548eb51f426e085546db1fa7dd87fbb7c9fa561575cf6eb1ff", size = 11800138, upload-time = "2025-05-29T13:32:55.082Z" }, + { url = "https://files.pythonhosted.org/packages/2e/81/a117441ea5dfc3746431e51d78a4aca569c677aa225bca2cc05a7c239b61/mypy-1.16.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6a2322896003ba66bbd1318c10d3afdfe24e78ef12ea10e2acd985e9d684a666", size = 12533156, upload-time = "2025-05-29T13:19:12.963Z" }, + { url = "https://files.pythonhosted.org/packages/3f/38/88ec57c6c86014d3f06251e00f397b5a7daa6888884d0abf187e4f5f587f/mypy-1.16.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:021a68568082c5b36e977d54e8f1de978baf401a33884ffcea09bd8e88a98f4c", size = 12742426, upload-time = "2025-05-29T13:20:22.72Z" }, + { url = "https://files.pythonhosted.org/packages/bd/53/7e9d528433d56e6f6f77ccf24af6ce570986c2d98a5839e4c2009ef47283/mypy-1.16.0-cp311-cp311-win_amd64.whl", hash = "sha256:54066fed302d83bf5128632d05b4ec68412e1f03ef2c300434057d66866cea4b", size = 9478319, upload-time = "2025-05-29T13:21:17.582Z" }, + { url = "https://files.pythonhosted.org/packages/70/cf/158e5055e60ca2be23aec54a3010f89dcffd788732634b344fc9cb1e85a0/mypy-1.16.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c5436d11e89a3ad16ce8afe752f0f373ae9620841c50883dc96f8b8805620b13", size = 11062927, upload-time = "2025-05-29T13:35:52.328Z" }, + { url = "https://files.pythonhosted.org/packages/94/34/cfff7a56be1609f5d10ef386342ce3494158e4d506516890142007e6472c/mypy-1.16.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f2622af30bf01d8fc36466231bdd203d120d7a599a6d88fb22bdcb9dbff84090", size = 10083082, upload-time = "2025-05-29T13:35:33.378Z" }, + { url = "https://files.pythonhosted.org/packages/b3/7f/7242062ec6288c33d8ad89574df87c3903d394870e5e6ba1699317a65075/mypy-1.16.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d045d33c284e10a038f5e29faca055b90eee87da3fc63b8889085744ebabb5a1", size = 11828306, upload-time = "2025-05-29T13:21:02.164Z" }, + { url = "https://files.pythonhosted.org/packages/6f/5f/b392f7b4f659f5b619ce5994c5c43caab3d80df2296ae54fa888b3d17f5a/mypy-1.16.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b4968f14f44c62e2ec4a038c8797a87315be8df7740dc3ee8d3bfe1c6bf5dba8", size = 12702764, upload-time = "2025-05-29T13:20:42.826Z" }, + { url = "https://files.pythonhosted.org/packages/9b/c0/7646ef3a00fa39ac9bc0938626d9ff29d19d733011be929cfea59d82d136/mypy-1.16.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:eb14a4a871bb8efb1e4a50360d4e3c8d6c601e7a31028a2c79f9bb659b63d730", size = 12896233, upload-time = "2025-05-29T13:18:37.446Z" }, + { url = "https://files.pythonhosted.org/packages/6d/38/52f4b808b3fef7f0ef840ee8ff6ce5b5d77381e65425758d515cdd4f5bb5/mypy-1.16.0-cp312-cp312-win_amd64.whl", hash = "sha256:bd4e1ebe126152a7bbaa4daedd781c90c8f9643c79b9748caa270ad542f12bec", size = 9565547, upload-time = "2025-05-29T13:20:02.836Z" }, + { url = "https://files.pythonhosted.org/packages/97/9c/ca03bdbefbaa03b264b9318a98950a9c683e06472226b55472f96ebbc53d/mypy-1.16.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:a9e056237c89f1587a3be1a3a70a06a698d25e2479b9a2f57325ddaaffc3567b", size = 11059753, upload-time = "2025-05-29T13:18:18.167Z" }, + { url = "https://files.pythonhosted.org/packages/36/92/79a969b8302cfe316027c88f7dc6fee70129490a370b3f6eb11d777749d0/mypy-1.16.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0b07e107affb9ee6ce1f342c07f51552d126c32cd62955f59a7db94a51ad12c0", size = 10073338, upload-time = "2025-05-29T13:19:48.079Z" }, + { url = "https://files.pythonhosted.org/packages/14/9b/a943f09319167da0552d5cd722104096a9c99270719b1afeea60d11610aa/mypy-1.16.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c6fb60cbd85dc65d4d63d37cb5c86f4e3a301ec605f606ae3a9173e5cf34997b", size = 11827764, upload-time = "2025-05-29T13:46:04.47Z" }, + { url = "https://files.pythonhosted.org/packages/ec/64/ff75e71c65a0cb6ee737287c7913ea155845a556c64144c65b811afdb9c7/mypy-1.16.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a7e32297a437cc915599e0578fa6bc68ae6a8dc059c9e009c628e1c47f91495d", size = 12701356, upload-time = "2025-05-29T13:35:13.553Z" }, + { url = "https://files.pythonhosted.org/packages/0a/ad/0e93c18987a1182c350f7a5fab70550852f9fabe30ecb63bfbe51b602074/mypy-1.16.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:afe420c9380ccec31e744e8baff0d406c846683681025db3531b32db56962d52", size = 12900745, upload-time = "2025-05-29T13:17:24.409Z" }, + { url = "https://files.pythonhosted.org/packages/28/5d/036c278d7a013e97e33f08c047fe5583ab4f1fc47c9a49f985f1cdd2a2d7/mypy-1.16.0-cp313-cp313-win_amd64.whl", hash = "sha256:55f9076c6ce55dd3f8cd0c6fff26a008ca8e5131b89d5ba6d86bd3f47e736eeb", size = 9572200, upload-time = "2025-05-29T13:33:44.92Z" }, + { url = "https://files.pythonhosted.org/packages/bd/eb/c0759617fe2159aee7a653f13cceafbf7f0b6323b4197403f2e587ca947d/mypy-1.16.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:f56236114c425620875c7cf71700e3d60004858da856c6fc78998ffe767b73d3", size = 10956081, upload-time = "2025-05-29T13:19:32.264Z" }, + { url = "https://files.pythonhosted.org/packages/70/35/df3c74a2967bdf86edea58b265feeec181d693432faed1c3b688b7c231e3/mypy-1.16.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:15486beea80be24ff067d7d0ede673b001d0d684d0095803b3e6e17a886a2a92", size = 10084422, upload-time = "2025-05-29T13:18:01.437Z" }, + { url = "https://files.pythonhosted.org/packages/b3/07/145ffe29f4b577219943b7b1dc0a71df7ead3c5bed4898686bd87c5b5cc2/mypy-1.16.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f2ed0e0847a80655afa2c121835b848ed101cc7b8d8d6ecc5205aedc732b1436", size = 11879670, upload-time = "2025-05-29T13:17:45.971Z" }, + { url = "https://files.pythonhosted.org/packages/c6/94/0421562d6b046e22986758c9ae31865d10ea0ba607ae99b32c9d18b16f66/mypy-1.16.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:eb5fbc8063cb4fde7787e4c0406aa63094a34a2daf4673f359a1fb64050e9cb2", size = 12610528, upload-time = "2025-05-29T13:34:36.983Z" }, + { url = "https://files.pythonhosted.org/packages/1a/f1/39a22985b78c766a594ae1e0bbb6f8bdf5f31ea8d0c52291a3c211fd3cd5/mypy-1.16.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:a5fcfdb7318c6a8dd127b14b1052743b83e97a970f0edb6c913211507a255e20", size = 12871923, upload-time = "2025-05-29T13:32:21.823Z" }, + { url = "https://files.pythonhosted.org/packages/f3/8e/84db4fb0d01f43d2c82fa9072ca72a42c49e52d58f44307bbd747c977bc2/mypy-1.16.0-cp39-cp39-win_amd64.whl", hash = "sha256:2e7e0ad35275e02797323a5aa1be0b14a4d03ffdb2e5f2b0489fa07b89c67b21", size = 9482931, upload-time = "2025-05-29T13:21:32.326Z" }, + { url = "https://files.pythonhosted.org/packages/99/a3/6ed10530dec8e0fdc890d81361260c9ef1f5e5c217ad8c9b21ecb2b8366b/mypy-1.16.0-py3-none-any.whl", hash = "sha256:29e1499864a3888bca5c1542f2d7232c6e586295183320caa95758fc84034031", size = 2265773, upload-time = "2025-05-29T13:35:18.762Z" }, +] + +[[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 = "numpy" +version = "2.0.2" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.10'", +] +sdist = { url = "https://files.pythonhosted.org/packages/a9/75/10dd1f8116a8b796cb2c737b674e02d02e80454bda953fa7e65d8c12b016/numpy-2.0.2.tar.gz", hash = "sha256:883c987dee1880e2a864ab0dc9892292582510604156762362d9326444636e78", size = 18902015, upload-time = "2024-08-26T20:19:40.945Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/21/91/3495b3237510f79f5d81f2508f9f13fea78ebfdf07538fc7444badda173d/numpy-2.0.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:51129a29dbe56f9ca83438b706e2e69a39892b5eda6cedcb6b0c9fdc9b0d3ece", size = 21165245, upload-time = "2024-08-26T20:04:14.625Z" }, + { url = "https://files.pythonhosted.org/packages/05/33/26178c7d437a87082d11019292dce6d3fe6f0e9026b7b2309cbf3e489b1d/numpy-2.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f15975dfec0cf2239224d80e32c3170b1d168335eaedee69da84fbe9f1f9cd04", size = 13738540, upload-time = "2024-08-26T20:04:36.784Z" }, + { url = "https://files.pythonhosted.org/packages/ec/31/cc46e13bf07644efc7a4bf68df2df5fb2a1a88d0cd0da9ddc84dc0033e51/numpy-2.0.2-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:8c5713284ce4e282544c68d1c3b2c7161d38c256d2eefc93c1d683cf47683e66", size = 5300623, upload-time = "2024-08-26T20:04:46.491Z" }, + { url = "https://files.pythonhosted.org/packages/6e/16/7bfcebf27bb4f9d7ec67332ffebee4d1bf085c84246552d52dbb548600e7/numpy-2.0.2-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:becfae3ddd30736fe1889a37f1f580e245ba79a5855bff5f2a29cb3ccc22dd7b", size = 6901774, upload-time = "2024-08-26T20:04:58.173Z" }, + { url = "https://files.pythonhosted.org/packages/f9/a3/561c531c0e8bf082c5bef509d00d56f82e0ea7e1e3e3a7fc8fa78742a6e5/numpy-2.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2da5960c3cf0df7eafefd806d4e612c5e19358de82cb3c343631188991566ccd", size = 13907081, upload-time = "2024-08-26T20:05:19.098Z" }, + { url = "https://files.pythonhosted.org/packages/fa/66/f7177ab331876200ac7563a580140643d1179c8b4b6a6b0fc9838de2a9b8/numpy-2.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:496f71341824ed9f3d2fd36cf3ac57ae2e0165c143b55c3a035ee219413f3318", size = 19523451, upload-time = "2024-08-26T20:05:47.479Z" }, + { url = "https://files.pythonhosted.org/packages/25/7f/0b209498009ad6453e4efc2c65bcdf0ae08a182b2b7877d7ab38a92dc542/numpy-2.0.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:a61ec659f68ae254e4d237816e33171497e978140353c0c2038d46e63282d0c8", size = 19927572, upload-time = "2024-08-26T20:06:17.137Z" }, + { url = "https://files.pythonhosted.org/packages/3e/df/2619393b1e1b565cd2d4c4403bdd979621e2c4dea1f8532754b2598ed63b/numpy-2.0.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:d731a1c6116ba289c1e9ee714b08a8ff882944d4ad631fd411106a30f083c326", size = 14400722, upload-time = "2024-08-26T20:06:39.16Z" }, + { url = "https://files.pythonhosted.org/packages/22/ad/77e921b9f256d5da36424ffb711ae79ca3f451ff8489eeca544d0701d74a/numpy-2.0.2-cp310-cp310-win32.whl", hash = "sha256:984d96121c9f9616cd33fbd0618b7f08e0cfc9600a7ee1d6fd9b239186d19d97", size = 6472170, upload-time = "2024-08-26T20:06:50.361Z" }, + { url = "https://files.pythonhosted.org/packages/10/05/3442317535028bc29cf0c0dd4c191a4481e8376e9f0db6bcf29703cadae6/numpy-2.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:c7b0be4ef08607dd04da4092faee0b86607f111d5ae68036f16cc787e250a131", size = 15905558, upload-time = "2024-08-26T20:07:13.881Z" }, + { url = "https://files.pythonhosted.org/packages/8b/cf/034500fb83041aa0286e0fb16e7c76e5c8b67c0711bb6e9e9737a717d5fe/numpy-2.0.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:49ca4decb342d66018b01932139c0961a8f9ddc7589611158cb3c27cbcf76448", size = 21169137, upload-time = "2024-08-26T20:07:45.345Z" }, + { url = "https://files.pythonhosted.org/packages/4a/d9/32de45561811a4b87fbdee23b5797394e3d1504b4a7cf40c10199848893e/numpy-2.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:11a76c372d1d37437857280aa142086476136a8c0f373b2e648ab2c8f18fb195", size = 13703552, upload-time = "2024-08-26T20:08:06.666Z" }, + { url = "https://files.pythonhosted.org/packages/c1/ca/2f384720020c7b244d22508cb7ab23d95f179fcfff33c31a6eeba8d6c512/numpy-2.0.2-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:807ec44583fd708a21d4a11d94aedf2f4f3c3719035c76a2bbe1fe8e217bdc57", size = 5298957, upload-time = "2024-08-26T20:08:15.83Z" }, + { url = "https://files.pythonhosted.org/packages/0e/78/a3e4f9fb6aa4e6fdca0c5428e8ba039408514388cf62d89651aade838269/numpy-2.0.2-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:8cafab480740e22f8d833acefed5cc87ce276f4ece12fdaa2e8903db2f82897a", size = 6905573, upload-time = "2024-08-26T20:08:27.185Z" }, + { url = "https://files.pythonhosted.org/packages/a0/72/cfc3a1beb2caf4efc9d0b38a15fe34025230da27e1c08cc2eb9bfb1c7231/numpy-2.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a15f476a45e6e5a3a79d8a14e62161d27ad897381fecfa4a09ed5322f2085669", size = 13914330, upload-time = "2024-08-26T20:08:48.058Z" }, + { url = "https://files.pythonhosted.org/packages/ba/a8/c17acf65a931ce551fee11b72e8de63bf7e8a6f0e21add4c937c83563538/numpy-2.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:13e689d772146140a252c3a28501da66dfecd77490b498b168b501835041f951", size = 19534895, upload-time = "2024-08-26T20:09:16.536Z" }, + { url = "https://files.pythonhosted.org/packages/ba/86/8767f3d54f6ae0165749f84648da9dcc8cd78ab65d415494962c86fac80f/numpy-2.0.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:9ea91dfb7c3d1c56a0e55657c0afb38cf1eeae4544c208dc465c3c9f3a7c09f9", size = 19937253, upload-time = "2024-08-26T20:09:46.263Z" }, + { url = "https://files.pythonhosted.org/packages/df/87/f76450e6e1c14e5bb1eae6836478b1028e096fd02e85c1c37674606ab752/numpy-2.0.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c1c9307701fec8f3f7a1e6711f9089c06e6284b3afbbcd259f7791282d660a15", size = 14414074, upload-time = "2024-08-26T20:10:08.483Z" }, + { url = "https://files.pythonhosted.org/packages/5c/ca/0f0f328e1e59f73754f06e1adfb909de43726d4f24c6a3f8805f34f2b0fa/numpy-2.0.2-cp311-cp311-win32.whl", hash = "sha256:a392a68bd329eafac5817e5aefeb39038c48b671afd242710b451e76090e81f4", size = 6470640, upload-time = "2024-08-26T20:10:19.732Z" }, + { url = "https://files.pythonhosted.org/packages/eb/57/3a3f14d3a759dcf9bf6e9eda905794726b758819df4663f217d658a58695/numpy-2.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:286cd40ce2b7d652a6f22efdfc6d1edf879440e53e76a75955bc0c826c7e64dc", size = 15910230, upload-time = "2024-08-26T20:10:43.413Z" }, + { url = "https://files.pythonhosted.org/packages/45/40/2e117be60ec50d98fa08c2f8c48e09b3edea93cfcabd5a9ff6925d54b1c2/numpy-2.0.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:df55d490dea7934f330006d0f81e8551ba6010a5bf035a249ef61a94f21c500b", size = 20895803, upload-time = "2024-08-26T20:11:13.916Z" }, + { url = "https://files.pythonhosted.org/packages/46/92/1b8b8dee833f53cef3e0a3f69b2374467789e0bb7399689582314df02651/numpy-2.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8df823f570d9adf0978347d1f926b2a867d5608f434a7cff7f7908c6570dcf5e", size = 13471835, upload-time = "2024-08-26T20:11:34.779Z" }, + { url = "https://files.pythonhosted.org/packages/7f/19/e2793bde475f1edaea6945be141aef6c8b4c669b90c90a300a8954d08f0a/numpy-2.0.2-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:9a92ae5c14811e390f3767053ff54eaee3bf84576d99a2456391401323f4ec2c", size = 5038499, upload-time = "2024-08-26T20:11:43.902Z" }, + { url = "https://files.pythonhosted.org/packages/e3/ff/ddf6dac2ff0dd50a7327bcdba45cb0264d0e96bb44d33324853f781a8f3c/numpy-2.0.2-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:a842d573724391493a97a62ebbb8e731f8a5dcc5d285dfc99141ca15a3302d0c", size = 6633497, upload-time = "2024-08-26T20:11:55.09Z" }, + { url = "https://files.pythonhosted.org/packages/72/21/67f36eac8e2d2cd652a2e69595a54128297cdcb1ff3931cfc87838874bd4/numpy-2.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c05e238064fc0610c840d1cf6a13bf63d7e391717d247f1bf0318172e759e692", size = 13621158, upload-time = "2024-08-26T20:12:14.95Z" }, + { url = "https://files.pythonhosted.org/packages/39/68/e9f1126d757653496dbc096cb429014347a36b228f5a991dae2c6b6cfd40/numpy-2.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0123ffdaa88fa4ab64835dcbde75dcdf89c453c922f18dced6e27c90d1d0ec5a", size = 19236173, upload-time = "2024-08-26T20:12:44.049Z" }, + { url = "https://files.pythonhosted.org/packages/d1/e9/1f5333281e4ebf483ba1c888b1d61ba7e78d7e910fdd8e6499667041cc35/numpy-2.0.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:96a55f64139912d61de9137f11bf39a55ec8faec288c75a54f93dfd39f7eb40c", size = 19634174, upload-time = "2024-08-26T20:13:13.634Z" }, + { url = "https://files.pythonhosted.org/packages/71/af/a469674070c8d8408384e3012e064299f7a2de540738a8e414dcfd639996/numpy-2.0.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ec9852fb39354b5a45a80bdab5ac02dd02b15f44b3804e9f00c556bf24b4bded", size = 14099701, upload-time = "2024-08-26T20:13:34.851Z" }, + { url = "https://files.pythonhosted.org/packages/d0/3d/08ea9f239d0e0e939b6ca52ad403c84a2bce1bde301a8eb4888c1c1543f1/numpy-2.0.2-cp312-cp312-win32.whl", hash = "sha256:671bec6496f83202ed2d3c8fdc486a8fc86942f2e69ff0e986140339a63bcbe5", size = 6174313, upload-time = "2024-08-26T20:13:45.653Z" }, + { url = "https://files.pythonhosted.org/packages/b2/b5/4ac39baebf1fdb2e72585c8352c56d063b6126be9fc95bd2bb5ef5770c20/numpy-2.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:cfd41e13fdc257aa5778496b8caa5e856dc4896d4ccf01841daee1d96465467a", size = 15606179, upload-time = "2024-08-26T20:14:08.786Z" }, + { url = "https://files.pythonhosted.org/packages/43/c1/41c8f6df3162b0c6ffd4437d729115704bd43363de0090c7f913cfbc2d89/numpy-2.0.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:9059e10581ce4093f735ed23f3b9d283b9d517ff46009ddd485f1747eb22653c", size = 21169942, upload-time = "2024-08-26T20:14:40.108Z" }, + { url = "https://files.pythonhosted.org/packages/39/bc/fd298f308dcd232b56a4031fd6ddf11c43f9917fbc937e53762f7b5a3bb1/numpy-2.0.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:423e89b23490805d2a5a96fe40ec507407b8ee786d66f7328be214f9679df6dd", size = 13711512, upload-time = "2024-08-26T20:15:00.985Z" }, + { url = "https://files.pythonhosted.org/packages/96/ff/06d1aa3eeb1c614eda245c1ba4fb88c483bee6520d361641331872ac4b82/numpy-2.0.2-cp39-cp39-macosx_14_0_arm64.whl", hash = "sha256:2b2955fa6f11907cf7a70dab0d0755159bca87755e831e47932367fc8f2f2d0b", size = 5306976, upload-time = "2024-08-26T20:15:10.876Z" }, + { url = "https://files.pythonhosted.org/packages/2d/98/121996dcfb10a6087a05e54453e28e58694a7db62c5a5a29cee14c6e047b/numpy-2.0.2-cp39-cp39-macosx_14_0_x86_64.whl", hash = "sha256:97032a27bd9d8988b9a97a8c4d2c9f2c15a81f61e2f21404d7e8ef00cb5be729", size = 6906494, upload-time = "2024-08-26T20:15:22.055Z" }, + { url = "https://files.pythonhosted.org/packages/15/31/9dffc70da6b9bbf7968f6551967fc21156207366272c2a40b4ed6008dc9b/numpy-2.0.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1e795a8be3ddbac43274f18588329c72939870a16cae810c2b73461c40718ab1", size = 13912596, upload-time = "2024-08-26T20:15:42.452Z" }, + { url = "https://files.pythonhosted.org/packages/b9/14/78635daab4b07c0930c919d451b8bf8c164774e6a3413aed04a6d95758ce/numpy-2.0.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f26b258c385842546006213344c50655ff1555a9338e2e5e02a0756dc3e803dd", size = 19526099, upload-time = "2024-08-26T20:16:11.048Z" }, + { url = "https://files.pythonhosted.org/packages/26/4c/0eeca4614003077f68bfe7aac8b7496f04221865b3a5e7cb230c9d055afd/numpy-2.0.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:5fec9451a7789926bcf7c2b8d187292c9f93ea30284802a0ab3f5be8ab36865d", size = 19932823, upload-time = "2024-08-26T20:16:40.171Z" }, + { url = "https://files.pythonhosted.org/packages/f1/46/ea25b98b13dccaebddf1a803f8c748680d972e00507cd9bc6dcdb5aa2ac1/numpy-2.0.2-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:9189427407d88ff25ecf8f12469d4d39d35bee1db5d39fc5c168c6f088a6956d", size = 14404424, upload-time = "2024-08-26T20:17:02.604Z" }, + { url = "https://files.pythonhosted.org/packages/c8/a6/177dd88d95ecf07e722d21008b1b40e681a929eb9e329684d449c36586b2/numpy-2.0.2-cp39-cp39-win32.whl", hash = "sha256:905d16e0c60200656500c95b6b8dca5d109e23cb24abc701d41c02d74c6b3afa", size = 6476809, upload-time = "2024-08-26T20:17:13.553Z" }, + { url = "https://files.pythonhosted.org/packages/ea/2b/7fc9f4e7ae5b507c1a3a21f0f15ed03e794c1242ea8a242ac158beb56034/numpy-2.0.2-cp39-cp39-win_amd64.whl", hash = "sha256:a3f4ab0caa7f053f6797fcd4e1e25caee367db3112ef2b6ef82d749530768c73", size = 15911314, upload-time = "2024-08-26T20:17:36.72Z" }, + { url = "https://files.pythonhosted.org/packages/8f/3b/df5a870ac6a3be3a86856ce195ef42eec7ae50d2a202be1f5a4b3b340e14/numpy-2.0.2-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:7f0a0c6f12e07fa94133c8a67404322845220c06a9e80e85999afe727f7438b8", size = 21025288, upload-time = "2024-08-26T20:18:07.732Z" }, + { url = "https://files.pythonhosted.org/packages/2c/97/51af92f18d6f6f2d9ad8b482a99fb74e142d71372da5d834b3a2747a446e/numpy-2.0.2-pp39-pypy39_pp73-macosx_14_0_x86_64.whl", hash = "sha256:312950fdd060354350ed123c0e25a71327d3711584beaef30cdaa93320c392d4", size = 6762793, upload-time = "2024-08-26T20:18:19.125Z" }, + { url = "https://files.pythonhosted.org/packages/12/46/de1fbd0c1b5ccaa7f9a005b66761533e2f6a3e560096682683a223631fe9/numpy-2.0.2-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:26df23238872200f63518dd2aa984cfca675d82469535dc7162dc2ee52d9dd5c", size = 19334885, upload-time = "2024-08-26T20:18:47.237Z" }, + { url = "https://files.pythonhosted.org/packages/cc/dc/d330a6faefd92b446ec0f0dfea4c3207bb1fef3c4771d19cf4543efd2c78/numpy-2.0.2-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:a46288ec55ebbd58947d31d72be2c63cbf839f0a63b49cb755022310792a3385", size = 15828784, upload-time = "2024-08-26T20:19:11.19Z" }, +] + +[[package]] +name = "numpy" +version = "2.2.6" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", +] +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 = "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.2.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy", version = "2.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "python-dateutil" }, + { name = "pytz" }, + { name = "tzdata" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9c/d6/9f8431bacc2e19dca897724cd097b1bb224a6ad5433784a44b587c7c13af/pandas-2.2.3.tar.gz", hash = "sha256:4f18ba62b61d7e192368b84517265a99b4d7ee8912f8708660fb4a366cc82667", size = 4399213, upload-time = "2024-09-20T13:10:04.827Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/aa/70/c853aec59839bceed032d52010ff5f1b8d87dc3114b762e4ba2727661a3b/pandas-2.2.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:1948ddde24197a0f7add2bdc4ca83bf2b1ef84a1bc8ccffd95eda17fd836ecb5", size = 12580827, upload-time = "2024-09-20T13:08:42.347Z" }, + { url = "https://files.pythonhosted.org/packages/99/f2/c4527768739ffa4469b2b4fff05aa3768a478aed89a2f271a79a40eee984/pandas-2.2.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:381175499d3802cde0eabbaf6324cce0c4f5d52ca6f8c377c29ad442f50f6348", size = 11303897, upload-time = "2024-09-20T13:08:45.807Z" }, + { url = "https://files.pythonhosted.org/packages/ed/12/86c1747ea27989d7a4064f806ce2bae2c6d575b950be087837bdfcabacc9/pandas-2.2.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d9c45366def9a3dd85a6454c0e7908f2b3b8e9c138f5dc38fed7ce720d8453ed", size = 66480908, upload-time = "2024-09-20T18:37:13.513Z" }, + { url = "https://files.pythonhosted.org/packages/44/50/7db2cd5e6373ae796f0ddad3675268c8d59fb6076e66f0c339d61cea886b/pandas-2.2.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:86976a1c5b25ae3f8ccae3a5306e443569ee3c3faf444dfd0f41cda24667ad57", size = 13064210, upload-time = "2024-09-20T13:08:48.325Z" }, + { url = "https://files.pythonhosted.org/packages/61/61/a89015a6d5536cb0d6c3ba02cebed51a95538cf83472975275e28ebf7d0c/pandas-2.2.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:b8661b0238a69d7aafe156b7fa86c44b881387509653fdf857bebc5e4008ad42", size = 16754292, upload-time = "2024-09-20T19:01:54.443Z" }, + { url = "https://files.pythonhosted.org/packages/ce/0d/4cc7b69ce37fac07645a94e1d4b0880b15999494372c1523508511b09e40/pandas-2.2.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:37e0aced3e8f539eccf2e099f65cdb9c8aa85109b0be6e93e2baff94264bdc6f", size = 14416379, upload-time = "2024-09-20T13:08:50.882Z" }, + { url = "https://files.pythonhosted.org/packages/31/9e/6ebb433de864a6cd45716af52a4d7a8c3c9aaf3a98368e61db9e69e69a9c/pandas-2.2.3-cp310-cp310-win_amd64.whl", hash = "sha256:56534ce0746a58afaf7942ba4863e0ef81c9c50d3f0ae93e9497d6a41a057645", size = 11598471, upload-time = "2024-09-20T13:08:53.332Z" }, + { url = "https://files.pythonhosted.org/packages/a8/44/d9502bf0ed197ba9bf1103c9867d5904ddcaf869e52329787fc54ed70cc8/pandas-2.2.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:66108071e1b935240e74525006034333f98bcdb87ea116de573a6a0dccb6c039", size = 12602222, upload-time = "2024-09-20T13:08:56.254Z" }, + { url = "https://files.pythonhosted.org/packages/52/11/9eac327a38834f162b8250aab32a6781339c69afe7574368fffe46387edf/pandas-2.2.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7c2875855b0ff77b2a64a0365e24455d9990730d6431b9e0ee18ad8acee13dbd", size = 11321274, upload-time = "2024-09-20T13:08:58.645Z" }, + { url = "https://files.pythonhosted.org/packages/45/fb/c4beeb084718598ba19aa9f5abbc8aed8b42f90930da861fcb1acdb54c3a/pandas-2.2.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:cd8d0c3be0515c12fed0bdbae072551c8b54b7192c7b1fda0ba56059a0179698", size = 15579836, upload-time = "2024-09-20T19:01:57.571Z" }, + { url = "https://files.pythonhosted.org/packages/cd/5f/4dba1d39bb9c38d574a9a22548c540177f78ea47b32f99c0ff2ec499fac5/pandas-2.2.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c124333816c3a9b03fbeef3a9f230ba9a737e9e5bb4060aa2107a86cc0a497fc", size = 13058505, upload-time = "2024-09-20T13:09:01.501Z" }, + { url = "https://files.pythonhosted.org/packages/b9/57/708135b90391995361636634df1f1130d03ba456e95bcf576fada459115a/pandas-2.2.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:63cc132e40a2e084cf01adf0775b15ac515ba905d7dcca47e9a251819c575ef3", size = 16744420, upload-time = "2024-09-20T19:02:00.678Z" }, + { url = "https://files.pythonhosted.org/packages/86/4a/03ed6b7ee323cf30404265c284cee9c65c56a212e0a08d9ee06984ba2240/pandas-2.2.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:29401dbfa9ad77319367d36940cd8a0b3a11aba16063e39632d98b0e931ddf32", size = 14440457, upload-time = "2024-09-20T13:09:04.105Z" }, + { url = "https://files.pythonhosted.org/packages/ed/8c/87ddf1fcb55d11f9f847e3c69bb1c6f8e46e2f40ab1a2d2abadb2401b007/pandas-2.2.3-cp311-cp311-win_amd64.whl", hash = "sha256:3fc6873a41186404dad67245896a6e440baacc92f5b716ccd1bc9ed2995ab2c5", size = 11617166, upload-time = "2024-09-20T13:09:06.917Z" }, + { url = "https://files.pythonhosted.org/packages/17/a3/fb2734118db0af37ea7433f57f722c0a56687e14b14690edff0cdb4b7e58/pandas-2.2.3-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:b1d432e8d08679a40e2a6d8b2f9770a5c21793a6f9f47fdd52c5ce1948a5a8a9", size = 12529893, upload-time = "2024-09-20T13:09:09.655Z" }, + { url = "https://files.pythonhosted.org/packages/e1/0c/ad295fd74bfac85358fd579e271cded3ac969de81f62dd0142c426b9da91/pandas-2.2.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a5a1595fe639f5988ba6a8e5bc9649af3baf26df3998a0abe56c02609392e0a4", size = 11363475, upload-time = "2024-09-20T13:09:14.718Z" }, + { url = "https://files.pythonhosted.org/packages/c6/2a/4bba3f03f7d07207481fed47f5b35f556c7441acddc368ec43d6643c5777/pandas-2.2.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5de54125a92bb4d1c051c0659e6fcb75256bf799a732a87184e5ea503965bce3", size = 15188645, upload-time = "2024-09-20T19:02:03.88Z" }, + { url = "https://files.pythonhosted.org/packages/38/f8/d8fddee9ed0d0c0f4a2132c1dfcf0e3e53265055da8df952a53e7eaf178c/pandas-2.2.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fffb8ae78d8af97f849404f21411c95062db1496aeb3e56f146f0355c9989319", size = 12739445, upload-time = "2024-09-20T13:09:17.621Z" }, + { url = "https://files.pythonhosted.org/packages/20/e8/45a05d9c39d2cea61ab175dbe6a2de1d05b679e8de2011da4ee190d7e748/pandas-2.2.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6dfcb5ee8d4d50c06a51c2fffa6cff6272098ad6540aed1a76d15fb9318194d8", size = 16359235, upload-time = "2024-09-20T19:02:07.094Z" }, + { url = "https://files.pythonhosted.org/packages/1d/99/617d07a6a5e429ff90c90da64d428516605a1ec7d7bea494235e1c3882de/pandas-2.2.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:062309c1b9ea12a50e8ce661145c6aab431b1e99530d3cd60640e255778bd43a", size = 14056756, upload-time = "2024-09-20T13:09:20.474Z" }, + { url = "https://files.pythonhosted.org/packages/29/d4/1244ab8edf173a10fd601f7e13b9566c1b525c4f365d6bee918e68381889/pandas-2.2.3-cp312-cp312-win_amd64.whl", hash = "sha256:59ef3764d0fe818125a5097d2ae867ca3fa64df032331b7e0917cf5d7bf66b13", size = 11504248, upload-time = "2024-09-20T13:09:23.137Z" }, + { url = "https://files.pythonhosted.org/packages/64/22/3b8f4e0ed70644e85cfdcd57454686b9057c6c38d2f74fe4b8bc2527214a/pandas-2.2.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f00d1345d84d8c86a63e476bb4955e46458b304b9575dcf71102b5c705320015", size = 12477643, upload-time = "2024-09-20T13:09:25.522Z" }, + { url = "https://files.pythonhosted.org/packages/e4/93/b3f5d1838500e22c8d793625da672f3eec046b1a99257666c94446969282/pandas-2.2.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3508d914817e153ad359d7e069d752cdd736a247c322d932eb89e6bc84217f28", size = 11281573, upload-time = "2024-09-20T13:09:28.012Z" }, + { url = "https://files.pythonhosted.org/packages/f5/94/6c79b07f0e5aab1dcfa35a75f4817f5c4f677931d4234afcd75f0e6a66ca/pandas-2.2.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:22a9d949bfc9a502d320aa04e5d02feab689d61da4e7764b62c30b991c42c5f0", size = 15196085, upload-time = "2024-09-20T19:02:10.451Z" }, + { url = "https://files.pythonhosted.org/packages/e8/31/aa8da88ca0eadbabd0a639788a6da13bb2ff6edbbb9f29aa786450a30a91/pandas-2.2.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f3a255b2c19987fbbe62a9dfd6cff7ff2aa9ccab3fc75218fd4b7530f01efa24", size = 12711809, upload-time = "2024-09-20T13:09:30.814Z" }, + { url = "https://files.pythonhosted.org/packages/ee/7c/c6dbdb0cb2a4344cacfb8de1c5808ca885b2e4dcfde8008266608f9372af/pandas-2.2.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:800250ecdadb6d9c78eae4990da62743b857b470883fa27f652db8bdde7f6659", size = 16356316, upload-time = "2024-09-20T19:02:13.825Z" }, + { url = "https://files.pythonhosted.org/packages/57/b7/8b757e7d92023b832869fa8881a992696a0bfe2e26f72c9ae9f255988d42/pandas-2.2.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6374c452ff3ec675a8f46fd9ab25c4ad0ba590b71cf0656f8b6daa5202bca3fb", size = 14022055, upload-time = "2024-09-20T13:09:33.462Z" }, + { url = "https://files.pythonhosted.org/packages/3b/bc/4b18e2b8c002572c5a441a64826252ce5da2aa738855747247a971988043/pandas-2.2.3-cp313-cp313-win_amd64.whl", hash = "sha256:61c5ad4043f791b61dd4752191d9f07f0ae412515d59ba8f005832a532f8736d", size = 11481175, upload-time = "2024-09-20T13:09:35.871Z" }, + { url = "https://files.pythonhosted.org/packages/76/a3/a5d88146815e972d40d19247b2c162e88213ef51c7c25993942c39dbf41d/pandas-2.2.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:3b71f27954685ee685317063bf13c7709a7ba74fc996b84fc6821c59b0f06468", size = 12615650, upload-time = "2024-09-20T13:09:38.685Z" }, + { url = "https://files.pythonhosted.org/packages/9c/8c/f0fd18f6140ddafc0c24122c8a964e48294acc579d47def376fef12bcb4a/pandas-2.2.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:38cf8125c40dae9d5acc10fa66af8ea6fdf760b2714ee482ca691fc66e6fcb18", size = 11290177, upload-time = "2024-09-20T13:09:41.141Z" }, + { url = "https://files.pythonhosted.org/packages/ed/f9/e995754eab9c0f14c6777401f7eece0943840b7a9fc932221c19d1abee9f/pandas-2.2.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ba96630bc17c875161df3818780af30e43be9b166ce51c9a18c1feae342906c2", size = 14651526, upload-time = "2024-09-20T19:02:16.905Z" }, + { url = "https://files.pythonhosted.org/packages/25/b0/98d6ae2e1abac4f35230aa756005e8654649d305df9a28b16b9ae4353bff/pandas-2.2.3-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1db71525a1538b30142094edb9adc10be3f3e176748cd7acc2240c2f2e5aa3a4", size = 11871013, upload-time = "2024-09-20T13:09:44.39Z" }, + { url = "https://files.pythonhosted.org/packages/cc/57/0f72a10f9db6a4628744c8e8f0df4e6e21de01212c7c981d31e50ffc8328/pandas-2.2.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:15c0e1e02e93116177d29ff83e8b1619c93ddc9c49083f237d4312337a61165d", size = 15711620, upload-time = "2024-09-20T19:02:20.639Z" }, + { url = "https://files.pythonhosted.org/packages/ab/5f/b38085618b950b79d2d9164a711c52b10aefc0ae6833b96f626b7021b2ed/pandas-2.2.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:ad5b65698ab28ed8d7f18790a0dc58005c7629f227be9ecc1072aa74c0c1d43a", size = 13098436, upload-time = "2024-09-20T13:09:48.112Z" }, + { url = "https://files.pythonhosted.org/packages/ca/8c/8848a4c9b8fdf5a534fe2077af948bf53cd713d77ffbcd7bd15710348fd7/pandas-2.2.3-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:bc6b93f9b966093cb0fd62ff1a7e4c09e6d546ad7c1de191767baffc57628f39", size = 12595535, upload-time = "2024-09-20T13:09:51.339Z" }, + { url = "https://files.pythonhosted.org/packages/9c/b9/5cead4f63b6d31bdefeb21a679bc5a7f4aaf262ca7e07e2bc1c341b68470/pandas-2.2.3-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:5dbca4c1acd72e8eeef4753eeca07de9b1db4f398669d5994086f788a5d7cc30", size = 11319822, upload-time = "2024-09-20T13:09:54.31Z" }, + { url = "https://files.pythonhosted.org/packages/31/af/89e35619fb573366fa68dc26dad6ad2c08c17b8004aad6d98f1a31ce4bb3/pandas-2.2.3-cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:8cd6d7cc958a3910f934ea8dbdf17b2364827bb4dafc38ce6eef6bb3d65ff09c", size = 15625439, upload-time = "2024-09-20T19:02:23.689Z" }, + { url = "https://files.pythonhosted.org/packages/3d/dd/bed19c2974296661493d7acc4407b1d2db4e2a482197df100f8f965b6225/pandas-2.2.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:99df71520d25fade9db7c1076ac94eb994f4d2673ef2aa2e86ee039b6746d20c", size = 13068928, upload-time = "2024-09-20T13:09:56.746Z" }, + { url = "https://files.pythonhosted.org/packages/31/a3/18508e10a31ea108d746c848b5a05c0711e0278fa0d6f1c52a8ec52b80a5/pandas-2.2.3-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:31d0ced62d4ea3e231a9f228366919a5ea0b07440d9d4dac345376fd8e1477ea", size = 16783266, upload-time = "2024-09-20T19:02:26.247Z" }, + { url = "https://files.pythonhosted.org/packages/c4/a5/3429bd13d82bebc78f4d78c3945efedef63a7cd0c15c17b2eeb838d1121f/pandas-2.2.3-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:7eee9e7cea6adf3e3d24e304ac6b8300646e2a5d1cd3a3c2abed9101b0846761", size = 14450871, upload-time = "2024-09-20T13:09:59.779Z" }, + { url = "https://files.pythonhosted.org/packages/2f/49/5c30646e96c684570925b772eac4eb0a8cb0ca590fa978f56c5d3ae73ea1/pandas-2.2.3-cp39-cp39-win_amd64.whl", hash = "sha256:4850ba03528b6dd51d6c5d273c46f183f39a9baf3f0143e566b89450965b105e", size = 11618011, upload-time = "2024-09-20T13:10:02.351Z" }, +] + +[[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 = "platformdirs" +version = "4.3.8" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/fe/8b/3c73abc9c759ecd3f1f7ceff6685840859e8070c4d947c93fae71f6a0bf2/platformdirs-4.3.8.tar.gz", hash = "sha256:3d512d96e16bcb959a814c9f348431070822a6496326a4be0911c40b5a74c2bc", size = 21362, upload-time = "2025-05-07T22:47:42.121Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fe/39/979e8e21520d4e47a0bbe349e2713c0aac6f3d853d0e5b34d76206c439aa/platformdirs-4.3.8-py3-none-any.whl", hash = "sha256:ff7059bb7eb1179e2685604f4aaf157cfd9535242bd23742eadc3c13542139b4", size = 18567, upload-time = "2025-05-07T22:47:40.376Z" }, +] + +[[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 = "pyarrow" +version = "20.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a2/ee/a7810cb9f3d6e9238e61d312076a9859bf3668fd21c69744de9532383912/pyarrow-20.0.0.tar.gz", hash = "sha256:febc4a913592573c8d5805091a6c2b5064c8bd6e002131f01061797d91c783c1", size = 1125187, upload-time = "2025-04-27T12:34:23.264Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5b/23/77094eb8ee0dbe88441689cb6afc40ac312a1e15d3a7acc0586999518222/pyarrow-20.0.0-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:c7dd06fd7d7b410ca5dc839cc9d485d2bc4ae5240851bcd45d85105cc90a47d7", size = 30832591, upload-time = "2025-04-27T12:27:27.89Z" }, + { url = "https://files.pythonhosted.org/packages/c3/d5/48cc573aff00d62913701d9fac478518f693b30c25f2c157550b0b2565cb/pyarrow-20.0.0-cp310-cp310-macosx_12_0_x86_64.whl", hash = "sha256:d5382de8dc34c943249b01c19110783d0d64b207167c728461add1ecc2db88e4", size = 32273686, upload-time = "2025-04-27T12:27:36.816Z" }, + { url = "https://files.pythonhosted.org/packages/37/df/4099b69a432b5cb412dd18adc2629975544d656df3d7fda6d73c5dba935d/pyarrow-20.0.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6415a0d0174487456ddc9beaead703d0ded5966129fa4fd3114d76b5d1c5ceae", size = 41337051, upload-time = "2025-04-27T12:27:44.4Z" }, + { url = "https://files.pythonhosted.org/packages/4c/27/99922a9ac1c9226f346e3a1e15e63dee6f623ed757ff2893f9d6994a69d3/pyarrow-20.0.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:15aa1b3b2587e74328a730457068dc6c89e6dcbf438d4369f572af9d320a25ee", size = 42404659, upload-time = "2025-04-27T12:27:51.715Z" }, + { url = "https://files.pythonhosted.org/packages/21/d1/71d91b2791b829c9e98f1e0d85be66ed93aff399f80abb99678511847eaa/pyarrow-20.0.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:5605919fbe67a7948c1f03b9f3727d82846c053cd2ce9303ace791855923fd20", size = 40695446, upload-time = "2025-04-27T12:27:59.643Z" }, + { url = "https://files.pythonhosted.org/packages/f1/ca/ae10fba419a6e94329707487835ec721f5a95f3ac9168500bcf7aa3813c7/pyarrow-20.0.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:a5704f29a74b81673d266e5ec1fe376f060627c2e42c5c7651288ed4b0db29e9", size = 42278528, upload-time = "2025-04-27T12:28:07.297Z" }, + { url = "https://files.pythonhosted.org/packages/7a/a6/aba40a2bf01b5d00cf9cd16d427a5da1fad0fb69b514ce8c8292ab80e968/pyarrow-20.0.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:00138f79ee1b5aca81e2bdedb91e3739b987245e11fa3c826f9e57c5d102fb75", size = 42918162, upload-time = "2025-04-27T12:28:15.716Z" }, + { url = "https://files.pythonhosted.org/packages/93/6b/98b39650cd64f32bf2ec6d627a9bd24fcb3e4e6ea1873c5e1ea8a83b1a18/pyarrow-20.0.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:f2d67ac28f57a362f1a2c1e6fa98bfe2f03230f7e15927aecd067433b1e70ce8", size = 44550319, upload-time = "2025-04-27T12:28:27.026Z" }, + { url = "https://files.pythonhosted.org/packages/ab/32/340238be1eb5037e7b5de7e640ee22334417239bc347eadefaf8c373936d/pyarrow-20.0.0-cp310-cp310-win_amd64.whl", hash = "sha256:4a8b029a07956b8d7bd742ffca25374dd3f634b35e46cc7a7c3fa4c75b297191", size = 25770759, upload-time = "2025-04-27T12:28:33.702Z" }, + { url = "https://files.pythonhosted.org/packages/47/a2/b7930824181ceadd0c63c1042d01fa4ef63eee233934826a7a2a9af6e463/pyarrow-20.0.0-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:24ca380585444cb2a31324c546a9a56abbe87e26069189e14bdba19c86c049f0", size = 30856035, upload-time = "2025-04-27T12:28:40.78Z" }, + { url = "https://files.pythonhosted.org/packages/9b/18/c765770227d7f5bdfa8a69f64b49194352325c66a5c3bb5e332dfd5867d9/pyarrow-20.0.0-cp311-cp311-macosx_12_0_x86_64.whl", hash = "sha256:95b330059ddfdc591a3225f2d272123be26c8fa76e8c9ee1a77aad507361cfdb", size = 32309552, upload-time = "2025-04-27T12:28:47.051Z" }, + { url = "https://files.pythonhosted.org/packages/44/fb/dfb2dfdd3e488bb14f822d7335653092dde150cffc2da97de6e7500681f9/pyarrow-20.0.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5f0fb1041267e9968c6d0d2ce3ff92e3928b243e2b6d11eeb84d9ac547308232", size = 41334704, upload-time = "2025-04-27T12:28:55.064Z" }, + { url = "https://files.pythonhosted.org/packages/58/0d/08a95878d38808051a953e887332d4a76bc06c6ee04351918ee1155407eb/pyarrow-20.0.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b8ff87cc837601532cc8242d2f7e09b4e02404de1b797aee747dd4ba4bd6313f", size = 42399836, upload-time = "2025-04-27T12:29:02.13Z" }, + { url = "https://files.pythonhosted.org/packages/f3/cd/efa271234dfe38f0271561086eedcad7bc0f2ddd1efba423916ff0883684/pyarrow-20.0.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:7a3a5dcf54286e6141d5114522cf31dd67a9e7c9133d150799f30ee302a7a1ab", size = 40711789, upload-time = "2025-04-27T12:29:09.951Z" }, + { url = "https://files.pythonhosted.org/packages/46/1f/7f02009bc7fc8955c391defee5348f510e589a020e4b40ca05edcb847854/pyarrow-20.0.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:a6ad3e7758ecf559900261a4df985662df54fb7fdb55e8e3b3aa99b23d526b62", size = 42301124, upload-time = "2025-04-27T12:29:17.187Z" }, + { url = "https://files.pythonhosted.org/packages/4f/92/692c562be4504c262089e86757a9048739fe1acb4024f92d39615e7bab3f/pyarrow-20.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6bb830757103a6cb300a04610e08d9636f0cd223d32f388418ea893a3e655f1c", size = 42916060, upload-time = "2025-04-27T12:29:24.253Z" }, + { url = "https://files.pythonhosted.org/packages/a4/ec/9f5c7e7c828d8e0a3c7ef50ee62eca38a7de2fa6eb1b8fa43685c9414fef/pyarrow-20.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:96e37f0766ecb4514a899d9a3554fadda770fb57ddf42b63d80f14bc20aa7db3", size = 44547640, upload-time = "2025-04-27T12:29:32.782Z" }, + { url = "https://files.pythonhosted.org/packages/54/96/46613131b4727f10fd2ffa6d0d6f02efcc09a0e7374eff3b5771548aa95b/pyarrow-20.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:3346babb516f4b6fd790da99b98bed9708e3f02e734c84971faccb20736848dc", size = 25781491, upload-time = "2025-04-27T12:29:38.464Z" }, + { url = "https://files.pythonhosted.org/packages/a1/d6/0c10e0d54f6c13eb464ee9b67a68b8c71bcf2f67760ef5b6fbcddd2ab05f/pyarrow-20.0.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:75a51a5b0eef32727a247707d4755322cb970be7e935172b6a3a9f9ae98404ba", size = 30815067, upload-time = "2025-04-27T12:29:44.384Z" }, + { url = "https://files.pythonhosted.org/packages/7e/e2/04e9874abe4094a06fd8b0cbb0f1312d8dd7d707f144c2ec1e5e8f452ffa/pyarrow-20.0.0-cp312-cp312-macosx_12_0_x86_64.whl", hash = "sha256:211d5e84cecc640c7a3ab900f930aaff5cd2702177e0d562d426fb7c4f737781", size = 32297128, upload-time = "2025-04-27T12:29:52.038Z" }, + { url = "https://files.pythonhosted.org/packages/31/fd/c565e5dcc906a3b471a83273039cb75cb79aad4a2d4a12f76cc5ae90a4b8/pyarrow-20.0.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4ba3cf4182828be7a896cbd232aa8dd6a31bd1f9e32776cc3796c012855e1199", size = 41334890, upload-time = "2025-04-27T12:29:59.452Z" }, + { url = "https://files.pythonhosted.org/packages/af/a9/3bdd799e2c9b20c1ea6dc6fa8e83f29480a97711cf806e823f808c2316ac/pyarrow-20.0.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2c3a01f313ffe27ac4126f4c2e5ea0f36a5fc6ab51f8726cf41fee4b256680bd", size = 42421775, upload-time = "2025-04-27T12:30:06.875Z" }, + { url = "https://files.pythonhosted.org/packages/10/f7/da98ccd86354c332f593218101ae56568d5dcedb460e342000bd89c49cc1/pyarrow-20.0.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:a2791f69ad72addd33510fec7bb14ee06c2a448e06b649e264c094c5b5f7ce28", size = 40687231, upload-time = "2025-04-27T12:30:13.954Z" }, + { url = "https://files.pythonhosted.org/packages/bb/1b/2168d6050e52ff1e6cefc61d600723870bf569cbf41d13db939c8cf97a16/pyarrow-20.0.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:4250e28a22302ce8692d3a0e8ec9d9dde54ec00d237cff4dfa9c1fbf79e472a8", size = 42295639, upload-time = "2025-04-27T12:30:21.949Z" }, + { url = "https://files.pythonhosted.org/packages/b2/66/2d976c0c7158fd25591c8ca55aee026e6d5745a021915a1835578707feb3/pyarrow-20.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:89e030dc58fc760e4010148e6ff164d2f44441490280ef1e97a542375e41058e", size = 42908549, upload-time = "2025-04-27T12:30:29.551Z" }, + { url = "https://files.pythonhosted.org/packages/31/a9/dfb999c2fc6911201dcbf348247f9cc382a8990f9ab45c12eabfd7243a38/pyarrow-20.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:6102b4864d77102dbbb72965618e204e550135a940c2534711d5ffa787df2a5a", size = 44557216, upload-time = "2025-04-27T12:30:36.977Z" }, + { url = "https://files.pythonhosted.org/packages/a0/8e/9adee63dfa3911be2382fb4d92e4b2e7d82610f9d9f668493bebaa2af50f/pyarrow-20.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:96d6a0a37d9c98be08f5ed6a10831d88d52cac7b13f5287f1e0f625a0de8062b", size = 25660496, upload-time = "2025-04-27T12:30:42.809Z" }, + { url = "https://files.pythonhosted.org/packages/9b/aa/daa413b81446d20d4dad2944110dcf4cf4f4179ef7f685dd5a6d7570dc8e/pyarrow-20.0.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:a15532e77b94c61efadde86d10957950392999503b3616b2ffcef7621a002893", size = 30798501, upload-time = "2025-04-27T12:30:48.351Z" }, + { url = "https://files.pythonhosted.org/packages/ff/75/2303d1caa410925de902d32ac215dc80a7ce7dd8dfe95358c165f2adf107/pyarrow-20.0.0-cp313-cp313-macosx_12_0_x86_64.whl", hash = "sha256:dd43f58037443af715f34f1322c782ec463a3c8a94a85fdb2d987ceb5658e061", size = 32277895, upload-time = "2025-04-27T12:30:55.238Z" }, + { url = "https://files.pythonhosted.org/packages/92/41/fe18c7c0b38b20811b73d1bdd54b1fccba0dab0e51d2048878042d84afa8/pyarrow-20.0.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aa0d288143a8585806e3cc7c39566407aab646fb9ece164609dac1cfff45f6ae", size = 41327322, upload-time = "2025-04-27T12:31:05.587Z" }, + { url = "https://files.pythonhosted.org/packages/da/ab/7dbf3d11db67c72dbf36ae63dcbc9f30b866c153b3a22ef728523943eee6/pyarrow-20.0.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b6953f0114f8d6f3d905d98e987d0924dabce59c3cda380bdfaa25a6201563b4", size = 42411441, upload-time = "2025-04-27T12:31:15.675Z" }, + { url = "https://files.pythonhosted.org/packages/90/c3/0c7da7b6dac863af75b64e2f827e4742161128c350bfe7955b426484e226/pyarrow-20.0.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:991f85b48a8a5e839b2128590ce07611fae48a904cae6cab1f089c5955b57eb5", size = 40677027, upload-time = "2025-04-27T12:31:24.631Z" }, + { url = "https://files.pythonhosted.org/packages/be/27/43a47fa0ff9053ab5203bb3faeec435d43c0d8bfa40179bfd076cdbd4e1c/pyarrow-20.0.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:97c8dc984ed09cb07d618d57d8d4b67a5100a30c3818c2fb0b04599f0da2de7b", size = 42281473, upload-time = "2025-04-27T12:31:31.311Z" }, + { url = "https://files.pythonhosted.org/packages/bc/0b/d56c63b078876da81bbb9ba695a596eabee9b085555ed12bf6eb3b7cab0e/pyarrow-20.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:9b71daf534f4745818f96c214dbc1e6124d7daf059167330b610fc69b6f3d3e3", size = 42893897, upload-time = "2025-04-27T12:31:39.406Z" }, + { url = "https://files.pythonhosted.org/packages/92/ac/7d4bd020ba9145f354012838692d48300c1b8fe5634bfda886abcada67ed/pyarrow-20.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e8b88758f9303fa5a83d6c90e176714b2fd3852e776fc2d7e42a22dd6c2fb368", size = 44543847, upload-time = "2025-04-27T12:31:45.997Z" }, + { url = "https://files.pythonhosted.org/packages/9d/07/290f4abf9ca702c5df7b47739c1b2c83588641ddfa2cc75e34a301d42e55/pyarrow-20.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:30b3051b7975801c1e1d387e17c588d8ab05ced9b1e14eec57915f79869b5031", size = 25653219, upload-time = "2025-04-27T12:31:54.11Z" }, + { url = "https://files.pythonhosted.org/packages/95/df/720bb17704b10bd69dde086e1400b8eefb8f58df3f8ac9cff6c425bf57f1/pyarrow-20.0.0-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:ca151afa4f9b7bc45bcc791eb9a89e90a9eb2772767d0b1e5389609c7d03db63", size = 30853957, upload-time = "2025-04-27T12:31:59.215Z" }, + { url = "https://files.pythonhosted.org/packages/d9/72/0d5f875efc31baef742ba55a00a25213a19ea64d7176e0fe001c5d8b6e9a/pyarrow-20.0.0-cp313-cp313t-macosx_12_0_x86_64.whl", hash = "sha256:4680f01ecd86e0dd63e39eb5cd59ef9ff24a9d166db328679e36c108dc993d4c", size = 32247972, upload-time = "2025-04-27T12:32:05.369Z" }, + { url = "https://files.pythonhosted.org/packages/d5/bc/e48b4fa544d2eea72f7844180eb77f83f2030b84c8dad860f199f94307ed/pyarrow-20.0.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7f4c8534e2ff059765647aa69b75d6543f9fef59e2cd4c6d18015192565d2b70", size = 41256434, upload-time = "2025-04-27T12:32:11.814Z" }, + { url = "https://files.pythonhosted.org/packages/c3/01/974043a29874aa2cf4f87fb07fd108828fc7362300265a2a64a94965e35b/pyarrow-20.0.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3e1f8a47f4b4ae4c69c4d702cfbdfe4d41e18e5c7ef6f1bb1c50918c1e81c57b", size = 42353648, upload-time = "2025-04-27T12:32:20.766Z" }, + { url = "https://files.pythonhosted.org/packages/68/95/cc0d3634cde9ca69b0e51cbe830d8915ea32dda2157560dda27ff3b3337b/pyarrow-20.0.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:a1f60dc14658efaa927f8214734f6a01a806d7690be4b3232ba526836d216122", size = 40619853, upload-time = "2025-04-27T12:32:28.1Z" }, + { url = "https://files.pythonhosted.org/packages/29/c2/3ad40e07e96a3e74e7ed7cc8285aadfa84eb848a798c98ec0ad009eb6bcc/pyarrow-20.0.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:204a846dca751428991346976b914d6d2a82ae5b8316a6ed99789ebf976551e6", size = 42241743, upload-time = "2025-04-27T12:32:35.792Z" }, + { url = "https://files.pythonhosted.org/packages/eb/cb/65fa110b483339add6a9bc7b6373614166b14e20375d4daa73483755f830/pyarrow-20.0.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:f3b117b922af5e4c6b9a9115825726cac7d8b1421c37c2b5e24fbacc8930612c", size = 42839441, upload-time = "2025-04-27T12:32:46.64Z" }, + { url = "https://files.pythonhosted.org/packages/98/7b/f30b1954589243207d7a0fbc9997401044bf9a033eec78f6cb50da3f304a/pyarrow-20.0.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:e724a3fd23ae5b9c010e7be857f4405ed5e679db5c93e66204db1a69f733936a", size = 44503279, upload-time = "2025-04-27T12:32:56.503Z" }, + { url = "https://files.pythonhosted.org/packages/37/40/ad395740cd641869a13bcf60851296c89624662575621968dcfafabaa7f6/pyarrow-20.0.0-cp313-cp313t-win_amd64.whl", hash = "sha256:82f1ee5133bd8f49d31be1299dc07f585136679666b502540db854968576faf9", size = 25944982, upload-time = "2025-04-27T12:33:04.72Z" }, + { url = "https://files.pythonhosted.org/packages/10/53/421820fa125138c868729b930d4bc487af2c4b01b1c6104818aab7e98f13/pyarrow-20.0.0-cp39-cp39-macosx_12_0_arm64.whl", hash = "sha256:1bcbe471ef3349be7714261dea28fe280db574f9d0f77eeccc195a2d161fd861", size = 30844702, upload-time = "2025-04-27T12:33:12.122Z" }, + { url = "https://files.pythonhosted.org/packages/2e/70/fd75e03312b715e90d928fb91ed8d45c9b0520346e5231b1c69293afd4c7/pyarrow-20.0.0-cp39-cp39-macosx_12_0_x86_64.whl", hash = "sha256:a18a14baef7d7ae49247e75641fd8bcbb39f44ed49a9fc4ec2f65d5031aa3b96", size = 32287180, upload-time = "2025-04-27T12:33:20.597Z" }, + { url = "https://files.pythonhosted.org/packages/c4/e3/21e5758e46219fdedf5e6c800574dd9d17e962e80014cfe08d6d475be863/pyarrow-20.0.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cb497649e505dc36542d0e68eca1a3c94ecbe9799cb67b578b55f2441a247fbc", size = 41351968, upload-time = "2025-04-27T12:33:28.215Z" }, + { url = "https://files.pythonhosted.org/packages/ac/f5/ed6a4c4b11f9215092a35097a985485bb7d879cb79d93d203494e8604f4e/pyarrow-20.0.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:11529a2283cb1f6271d7c23e4a8f9f8b7fd173f7360776b668e509d712a02eec", size = 42415208, upload-time = "2025-04-27T12:33:37.04Z" }, + { url = "https://files.pythonhosted.org/packages/44/e5/466a63668ba25788ee8d38d55f853a60469ae7ad1cda343db9f3f45e0b0a/pyarrow-20.0.0-cp39-cp39-manylinux_2_28_aarch64.whl", hash = "sha256:6fc1499ed3b4b57ee4e090e1cea6eb3584793fe3d1b4297bbf53f09b434991a5", size = 40708556, upload-time = "2025-04-27T12:33:46.483Z" }, + { url = "https://files.pythonhosted.org/packages/e8/d7/4c4d4e4cf6e53e16a519366dfe9223ee4a7a38e6e28c1c0d372b38ba3fe7/pyarrow-20.0.0-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:db53390eaf8a4dab4dbd6d93c85c5cf002db24902dbff0ca7d988beb5c9dd15b", size = 42291754, upload-time = "2025-04-27T12:33:55.4Z" }, + { url = "https://files.pythonhosted.org/packages/07/d5/79effb32585b7c18897d3047a2163034f3f9c944d12f7b2fd8df6a2edc70/pyarrow-20.0.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:851c6a8260ad387caf82d2bbf54759130534723e37083111d4ed481cb253cc0d", size = 42936483, upload-time = "2025-04-27T12:34:03.694Z" }, + { url = "https://files.pythonhosted.org/packages/09/5c/f707603552c058b2e9129732de99a67befb1f13f008cc58856304a62c38b/pyarrow-20.0.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:e22f80b97a271f0a7d9cd07394a7d348f80d3ac63ed7cc38b6d1b696ab3b2619", size = 44558895, upload-time = "2025-04-27T12:34:13.26Z" }, + { url = "https://files.pythonhosted.org/packages/26/cc/1eb6a01c1bbc787f596c270c46bcd2273e35154a84afcb1d0cb4cc72457e/pyarrow-20.0.0-cp39-cp39-win_amd64.whl", hash = "sha256:9965a050048ab02409fb7cbbefeedba04d3d67f2cc899eff505cc084345959ca", size = 25785667, upload-time = "2025-04-27T12:34:19.739Z" }, +] + +[[package]] +name = "pycparser" +version = "2.22" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1d/b2/31537cf4b1ca988837256c910a668b553fceb8f069bedc4b1c826024b52c/pycparser-2.22.tar.gz", hash = "sha256:491c8be9c040f5390f5bf44a5b07752bd07f56edf992381b05c701439eec10f6", size = 172736, upload-time = "2024-03-30T13:22:22.564Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/13/a3/a812df4e2dd5696d1f351d58b8fe16a405b234ad2886a0dab9183fb78109/pycparser-2.22-py3-none-any.whl", hash = "sha256:c3702b6d3dd8c7abc1afa565d7e63d53a1d0bd86cdc24edd75470f4de499cfcc", size = 117552, upload-time = "2024-03-30T13:22:20.476Z" }, +] + +[[package]] +name = "pydantic" +version = "2.11.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/f0/86/8ce9040065e8f924d642c58e4a344e33163a07f6b57f836d0d734e0ad3fb/pydantic-2.11.5.tar.gz", hash = "sha256:7f853db3d0ce78ce8bbb148c401c2cdd6431b3473c0cdff2755c7690952a7b7a", size = 787102, upload-time = "2025-05-22T21:18:08.761Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b5/69/831ed22b38ff9b4b64b66569f0e5b7b97cf3638346eb95a2147fdb49ad5f/pydantic-2.11.5-py3-none-any.whl", hash = "sha256:f9c26ba06f9747749ca1e5c94d6a85cb84254577553c8785576fd38fa64dc0f7", size = 444229, upload-time = "2025-05-22T21:18:06.329Z" }, +] + +[[package]] +name = "pydantic-core" +version = "2.33.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ad/88/5f2260bdfae97aabf98f1778d43f69574390ad787afb646292a638c923d4/pydantic_core-2.33.2.tar.gz", hash = "sha256:7cb8bc3605c29176e1b105350d2e6474142d7c1bd1d9327c4a9bdb46bf827acc", size = 435195, upload-time = "2025-04-23T18:33:52.104Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e5/92/b31726561b5dae176c2d2c2dc43a9c5bfba5d32f96f8b4c0a600dd492447/pydantic_core-2.33.2-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:2b3d326aaef0c0399d9afffeb6367d5e26ddc24d351dbc9c636840ac355dc5d8", size = 2028817, upload-time = "2025-04-23T18:30:43.919Z" }, + { url = "https://files.pythonhosted.org/packages/a3/44/3f0b95fafdaca04a483c4e685fe437c6891001bf3ce8b2fded82b9ea3aa1/pydantic_core-2.33.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:0e5b2671f05ba48b94cb90ce55d8bdcaaedb8ba00cc5359f6810fc918713983d", size = 1861357, upload-time = "2025-04-23T18:30:46.372Z" }, + { url = "https://files.pythonhosted.org/packages/30/97/e8f13b55766234caae05372826e8e4b3b96e7b248be3157f53237682e43c/pydantic_core-2.33.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0069c9acc3f3981b9ff4cdfaf088e98d83440a4c7ea1bc07460af3d4dc22e72d", size = 1898011, upload-time = "2025-04-23T18:30:47.591Z" }, + { url = "https://files.pythonhosted.org/packages/9b/a3/99c48cf7bafc991cc3ee66fd544c0aae8dc907b752f1dad2d79b1b5a471f/pydantic_core-2.33.2-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d53b22f2032c42eaaf025f7c40c2e3b94568ae077a606f006d206a463bc69572", size = 1982730, upload-time = "2025-04-23T18:30:49.328Z" }, + { url = "https://files.pythonhosted.org/packages/de/8e/a5b882ec4307010a840fb8b58bd9bf65d1840c92eae7534c7441709bf54b/pydantic_core-2.33.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0405262705a123b7ce9f0b92f123334d67b70fd1f20a9372b907ce1080c7ba02", size = 2136178, upload-time = "2025-04-23T18:30:50.907Z" }, + { url = "https://files.pythonhosted.org/packages/e4/bb/71e35fc3ed05af6834e890edb75968e2802fe98778971ab5cba20a162315/pydantic_core-2.33.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4b25d91e288e2c4e0662b8038a28c6a07eaac3e196cfc4ff69de4ea3db992a1b", size = 2736462, upload-time = "2025-04-23T18:30:52.083Z" }, + { url = "https://files.pythonhosted.org/packages/31/0d/c8f7593e6bc7066289bbc366f2235701dcbebcd1ff0ef8e64f6f239fb47d/pydantic_core-2.33.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6bdfe4b3789761f3bcb4b1ddf33355a71079858958e3a552f16d5af19768fef2", size = 2005652, upload-time = "2025-04-23T18:30:53.389Z" }, + { url = "https://files.pythonhosted.org/packages/d2/7a/996d8bd75f3eda405e3dd219ff5ff0a283cd8e34add39d8ef9157e722867/pydantic_core-2.33.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:efec8db3266b76ef9607c2c4c419bdb06bf335ae433b80816089ea7585816f6a", size = 2113306, upload-time = "2025-04-23T18:30:54.661Z" }, + { url = "https://files.pythonhosted.org/packages/ff/84/daf2a6fb2db40ffda6578a7e8c5a6e9c8affb251a05c233ae37098118788/pydantic_core-2.33.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:031c57d67ca86902726e0fae2214ce6770bbe2f710dc33063187a68744a5ecac", size = 2073720, upload-time = "2025-04-23T18:30:56.11Z" }, + { url = "https://files.pythonhosted.org/packages/77/fb/2258da019f4825128445ae79456a5499c032b55849dbd5bed78c95ccf163/pydantic_core-2.33.2-cp310-cp310-musllinux_1_1_armv7l.whl", hash = "sha256:f8de619080e944347f5f20de29a975c2d815d9ddd8be9b9b7268e2e3ef68605a", size = 2244915, upload-time = "2025-04-23T18:30:57.501Z" }, + { url = "https://files.pythonhosted.org/packages/d8/7a/925ff73756031289468326e355b6fa8316960d0d65f8b5d6b3a3e7866de7/pydantic_core-2.33.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:73662edf539e72a9440129f231ed3757faab89630d291b784ca99237fb94db2b", size = 2241884, upload-time = "2025-04-23T18:30:58.867Z" }, + { url = "https://files.pythonhosted.org/packages/0b/b0/249ee6d2646f1cdadcb813805fe76265745c4010cf20a8eba7b0e639d9b2/pydantic_core-2.33.2-cp310-cp310-win32.whl", hash = "sha256:0a39979dcbb70998b0e505fb1556a1d550a0781463ce84ebf915ba293ccb7e22", size = 1910496, upload-time = "2025-04-23T18:31:00.078Z" }, + { url = "https://files.pythonhosted.org/packages/66/ff/172ba8f12a42d4b552917aa65d1f2328990d3ccfc01d5b7c943ec084299f/pydantic_core-2.33.2-cp310-cp310-win_amd64.whl", hash = "sha256:b0379a2b24882fef529ec3b4987cb5d003b9cda32256024e6fe1586ac45fc640", size = 1955019, upload-time = "2025-04-23T18:31:01.335Z" }, + { url = "https://files.pythonhosted.org/packages/3f/8d/71db63483d518cbbf290261a1fc2839d17ff89fce7089e08cad07ccfce67/pydantic_core-2.33.2-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:4c5b0a576fb381edd6d27f0a85915c6daf2f8138dc5c267a57c08a62900758c7", size = 2028584, upload-time = "2025-04-23T18:31:03.106Z" }, + { url = "https://files.pythonhosted.org/packages/24/2f/3cfa7244ae292dd850989f328722d2aef313f74ffc471184dc509e1e4e5a/pydantic_core-2.33.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e799c050df38a639db758c617ec771fd8fb7a5f8eaaa4b27b101f266b216a246", size = 1855071, upload-time = "2025-04-23T18:31:04.621Z" }, + { url = "https://files.pythonhosted.org/packages/b3/d3/4ae42d33f5e3f50dd467761304be2fa0a9417fbf09735bc2cce003480f2a/pydantic_core-2.33.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dc46a01bf8d62f227d5ecee74178ffc448ff4e5197c756331f71efcc66dc980f", size = 1897823, upload-time = "2025-04-23T18:31:06.377Z" }, + { url = "https://files.pythonhosted.org/packages/f4/f3/aa5976e8352b7695ff808599794b1fba2a9ae2ee954a3426855935799488/pydantic_core-2.33.2-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a144d4f717285c6d9234a66778059f33a89096dfb9b39117663fd8413d582dcc", size = 1983792, upload-time = "2025-04-23T18:31:07.93Z" }, + { url = "https://files.pythonhosted.org/packages/d5/7a/cda9b5a23c552037717f2b2a5257e9b2bfe45e687386df9591eff7b46d28/pydantic_core-2.33.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:73cf6373c21bc80b2e0dc88444f41ae60b2f070ed02095754eb5a01df12256de", size = 2136338, upload-time = "2025-04-23T18:31:09.283Z" }, + { url = "https://files.pythonhosted.org/packages/2b/9f/b8f9ec8dd1417eb9da784e91e1667d58a2a4a7b7b34cf4af765ef663a7e5/pydantic_core-2.33.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3dc625f4aa79713512d1976fe9f0bc99f706a9dee21dfd1810b4bbbf228d0e8a", size = 2730998, upload-time = "2025-04-23T18:31:11.7Z" }, + { url = "https://files.pythonhosted.org/packages/47/bc/cd720e078576bdb8255d5032c5d63ee5c0bf4b7173dd955185a1d658c456/pydantic_core-2.33.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:881b21b5549499972441da4758d662aeea93f1923f953e9cbaff14b8b9565aef", size = 2003200, upload-time = "2025-04-23T18:31:13.536Z" }, + { url = "https://files.pythonhosted.org/packages/ca/22/3602b895ee2cd29d11a2b349372446ae9727c32e78a94b3d588a40fdf187/pydantic_core-2.33.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:bdc25f3681f7b78572699569514036afe3c243bc3059d3942624e936ec93450e", size = 2113890, upload-time = "2025-04-23T18:31:15.011Z" }, + { url = "https://files.pythonhosted.org/packages/ff/e6/e3c5908c03cf00d629eb38393a98fccc38ee0ce8ecce32f69fc7d7b558a7/pydantic_core-2.33.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:fe5b32187cbc0c862ee201ad66c30cf218e5ed468ec8dc1cf49dec66e160cc4d", size = 2073359, upload-time = "2025-04-23T18:31:16.393Z" }, + { url = "https://files.pythonhosted.org/packages/12/e7/6a36a07c59ebefc8777d1ffdaf5ae71b06b21952582e4b07eba88a421c79/pydantic_core-2.33.2-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:bc7aee6f634a6f4a95676fcb5d6559a2c2a390330098dba5e5a5f28a2e4ada30", size = 2245883, upload-time = "2025-04-23T18:31:17.892Z" }, + { url = "https://files.pythonhosted.org/packages/16/3f/59b3187aaa6cc0c1e6616e8045b284de2b6a87b027cce2ffcea073adf1d2/pydantic_core-2.33.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:235f45e5dbcccf6bd99f9f472858849f73d11120d76ea8707115415f8e5ebebf", size = 2241074, upload-time = "2025-04-23T18:31:19.205Z" }, + { url = "https://files.pythonhosted.org/packages/e0/ed/55532bb88f674d5d8f67ab121a2a13c385df382de2a1677f30ad385f7438/pydantic_core-2.33.2-cp311-cp311-win32.whl", hash = "sha256:6368900c2d3ef09b69cb0b913f9f8263b03786e5b2a387706c5afb66800efd51", size = 1910538, upload-time = "2025-04-23T18:31:20.541Z" }, + { url = "https://files.pythonhosted.org/packages/fe/1b/25b7cccd4519c0b23c2dd636ad39d381abf113085ce4f7bec2b0dc755eb1/pydantic_core-2.33.2-cp311-cp311-win_amd64.whl", hash = "sha256:1e063337ef9e9820c77acc768546325ebe04ee38b08703244c1309cccc4f1bab", size = 1952909, upload-time = "2025-04-23T18:31:22.371Z" }, + { url = "https://files.pythonhosted.org/packages/49/a9/d809358e49126438055884c4366a1f6227f0f84f635a9014e2deb9b9de54/pydantic_core-2.33.2-cp311-cp311-win_arm64.whl", hash = "sha256:6b99022f1d19bc32a4c2a0d544fc9a76e3be90f0b3f4af413f87d38749300e65", size = 1897786, upload-time = "2025-04-23T18:31:24.161Z" }, + { url = "https://files.pythonhosted.org/packages/18/8a/2b41c97f554ec8c71f2a8a5f85cb56a8b0956addfe8b0efb5b3d77e8bdc3/pydantic_core-2.33.2-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:a7ec89dc587667f22b6a0b6579c249fca9026ce7c333fc142ba42411fa243cdc", size = 2009000, upload-time = "2025-04-23T18:31:25.863Z" }, + { url = "https://files.pythonhosted.org/packages/a1/02/6224312aacb3c8ecbaa959897af57181fb6cf3a3d7917fd44d0f2917e6f2/pydantic_core-2.33.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3c6db6e52c6d70aa0d00d45cdb9b40f0433b96380071ea80b09277dba021ddf7", size = 1847996, upload-time = "2025-04-23T18:31:27.341Z" }, + { url = "https://files.pythonhosted.org/packages/d6/46/6dcdf084a523dbe0a0be59d054734b86a981726f221f4562aed313dbcb49/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4e61206137cbc65e6d5256e1166f88331d3b6238e082d9f74613b9b765fb9025", size = 1880957, upload-time = "2025-04-23T18:31:28.956Z" }, + { url = "https://files.pythonhosted.org/packages/ec/6b/1ec2c03837ac00886ba8160ce041ce4e325b41d06a034adbef11339ae422/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:eb8c529b2819c37140eb51b914153063d27ed88e3bdc31b71198a198e921e011", size = 1964199, upload-time = "2025-04-23T18:31:31.025Z" }, + { url = "https://files.pythonhosted.org/packages/2d/1d/6bf34d6adb9debd9136bd197ca72642203ce9aaaa85cfcbfcf20f9696e83/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c52b02ad8b4e2cf14ca7b3d918f3eb0ee91e63b3167c32591e57c4317e134f8f", size = 2120296, upload-time = "2025-04-23T18:31:32.514Z" }, + { url = "https://files.pythonhosted.org/packages/e0/94/2bd0aaf5a591e974b32a9f7123f16637776c304471a0ab33cf263cf5591a/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:96081f1605125ba0855dfda83f6f3df5ec90c61195421ba72223de35ccfb2f88", size = 2676109, upload-time = "2025-04-23T18:31:33.958Z" }, + { url = "https://files.pythonhosted.org/packages/f9/41/4b043778cf9c4285d59742281a769eac371b9e47e35f98ad321349cc5d61/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8f57a69461af2a5fa6e6bbd7a5f60d3b7e6cebb687f55106933188e79ad155c1", size = 2002028, upload-time = "2025-04-23T18:31:39.095Z" }, + { url = "https://files.pythonhosted.org/packages/cb/d5/7bb781bf2748ce3d03af04d5c969fa1308880e1dca35a9bd94e1a96a922e/pydantic_core-2.33.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:572c7e6c8bb4774d2ac88929e3d1f12bc45714ae5ee6d9a788a9fb35e60bb04b", size = 2100044, upload-time = "2025-04-23T18:31:41.034Z" }, + { url = "https://files.pythonhosted.org/packages/fe/36/def5e53e1eb0ad896785702a5bbfd25eed546cdcf4087ad285021a90ed53/pydantic_core-2.33.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:db4b41f9bd95fbe5acd76d89920336ba96f03e149097365afe1cb092fceb89a1", size = 2058881, upload-time = "2025-04-23T18:31:42.757Z" }, + { url = "https://files.pythonhosted.org/packages/01/6c/57f8d70b2ee57fc3dc8b9610315949837fa8c11d86927b9bb044f8705419/pydantic_core-2.33.2-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:fa854f5cf7e33842a892e5c73f45327760bc7bc516339fda888c75ae60edaeb6", size = 2227034, upload-time = "2025-04-23T18:31:44.304Z" }, + { url = "https://files.pythonhosted.org/packages/27/b9/9c17f0396a82b3d5cbea4c24d742083422639e7bb1d5bf600e12cb176a13/pydantic_core-2.33.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:5f483cfb75ff703095c59e365360cb73e00185e01aaea067cd19acffd2ab20ea", size = 2234187, upload-time = "2025-04-23T18:31:45.891Z" }, + { url = "https://files.pythonhosted.org/packages/b0/6a/adf5734ffd52bf86d865093ad70b2ce543415e0e356f6cacabbc0d9ad910/pydantic_core-2.33.2-cp312-cp312-win32.whl", hash = "sha256:9cb1da0f5a471435a7bc7e439b8a728e8b61e59784b2af70d7c169f8dd8ae290", size = 1892628, upload-time = "2025-04-23T18:31:47.819Z" }, + { url = "https://files.pythonhosted.org/packages/43/e4/5479fecb3606c1368d496a825d8411e126133c41224c1e7238be58b87d7e/pydantic_core-2.33.2-cp312-cp312-win_amd64.whl", hash = "sha256:f941635f2a3d96b2973e867144fde513665c87f13fe0e193c158ac51bfaaa7b2", size = 1955866, upload-time = "2025-04-23T18:31:49.635Z" }, + { url = "https://files.pythonhosted.org/packages/0d/24/8b11e8b3e2be9dd82df4b11408a67c61bb4dc4f8e11b5b0fc888b38118b5/pydantic_core-2.33.2-cp312-cp312-win_arm64.whl", hash = "sha256:cca3868ddfaccfbc4bfb1d608e2ccaaebe0ae628e1416aeb9c4d88c001bb45ab", size = 1888894, upload-time = "2025-04-23T18:31:51.609Z" }, + { url = "https://files.pythonhosted.org/packages/46/8c/99040727b41f56616573a28771b1bfa08a3d3fe74d3d513f01251f79f172/pydantic_core-2.33.2-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:1082dd3e2d7109ad8b7da48e1d4710c8d06c253cbc4a27c1cff4fbcaa97a9e3f", size = 2015688, upload-time = "2025-04-23T18:31:53.175Z" }, + { url = "https://files.pythonhosted.org/packages/3a/cc/5999d1eb705a6cefc31f0b4a90e9f7fc400539b1a1030529700cc1b51838/pydantic_core-2.33.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f517ca031dfc037a9c07e748cefd8d96235088b83b4f4ba8939105d20fa1dcd6", size = 1844808, upload-time = "2025-04-23T18:31:54.79Z" }, + { url = "https://files.pythonhosted.org/packages/6f/5e/a0a7b8885c98889a18b6e376f344da1ef323d270b44edf8174d6bce4d622/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0a9f2c9dd19656823cb8250b0724ee9c60a82f3cdf68a080979d13092a3b0fef", size = 1885580, upload-time = "2025-04-23T18:31:57.393Z" }, + { url = "https://files.pythonhosted.org/packages/3b/2a/953581f343c7d11a304581156618c3f592435523dd9d79865903272c256a/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2b0a451c263b01acebe51895bfb0e1cc842a5c666efe06cdf13846c7418caa9a", size = 1973859, upload-time = "2025-04-23T18:31:59.065Z" }, + { url = "https://files.pythonhosted.org/packages/e6/55/f1a813904771c03a3f97f676c62cca0c0a4138654107c1b61f19c644868b/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1ea40a64d23faa25e62a70ad163571c0b342b8bf66d5fa612ac0dec4f069d916", size = 2120810, upload-time = "2025-04-23T18:32:00.78Z" }, + { url = "https://files.pythonhosted.org/packages/aa/c3/053389835a996e18853ba107a63caae0b9deb4a276c6b472931ea9ae6e48/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0fb2d542b4d66f9470e8065c5469ec676978d625a8b7a363f07d9a501a9cb36a", size = 2676498, upload-time = "2025-04-23T18:32:02.418Z" }, + { url = "https://files.pythonhosted.org/packages/eb/3c/f4abd740877a35abade05e437245b192f9d0ffb48bbbbd708df33d3cda37/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9fdac5d6ffa1b5a83bca06ffe7583f5576555e6c8b3a91fbd25ea7780f825f7d", size = 2000611, upload-time = "2025-04-23T18:32:04.152Z" }, + { url = "https://files.pythonhosted.org/packages/59/a7/63ef2fed1837d1121a894d0ce88439fe3e3b3e48c7543b2a4479eb99c2bd/pydantic_core-2.33.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:04a1a413977ab517154eebb2d326da71638271477d6ad87a769102f7c2488c56", size = 2107924, upload-time = "2025-04-23T18:32:06.129Z" }, + { url = "https://files.pythonhosted.org/packages/04/8f/2551964ef045669801675f1cfc3b0d74147f4901c3ffa42be2ddb1f0efc4/pydantic_core-2.33.2-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:c8e7af2f4e0194c22b5b37205bfb293d166a7344a5b0d0eaccebc376546d77d5", size = 2063196, upload-time = "2025-04-23T18:32:08.178Z" }, + { url = "https://files.pythonhosted.org/packages/26/bd/d9602777e77fc6dbb0c7db9ad356e9a985825547dce5ad1d30ee04903918/pydantic_core-2.33.2-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:5c92edd15cd58b3c2d34873597a1e20f13094f59cf88068adb18947df5455b4e", size = 2236389, upload-time = "2025-04-23T18:32:10.242Z" }, + { url = "https://files.pythonhosted.org/packages/42/db/0e950daa7e2230423ab342ae918a794964b053bec24ba8af013fc7c94846/pydantic_core-2.33.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:65132b7b4a1c0beded5e057324b7e16e10910c106d43675d9bd87d4f38dde162", size = 2239223, upload-time = "2025-04-23T18:32:12.382Z" }, + { url = "https://files.pythonhosted.org/packages/58/4d/4f937099c545a8a17eb52cb67fe0447fd9a373b348ccfa9a87f141eeb00f/pydantic_core-2.33.2-cp313-cp313-win32.whl", hash = "sha256:52fb90784e0a242bb96ec53f42196a17278855b0f31ac7c3cc6f5c1ec4811849", size = 1900473, upload-time = "2025-04-23T18:32:14.034Z" }, + { url = "https://files.pythonhosted.org/packages/a0/75/4a0a9bac998d78d889def5e4ef2b065acba8cae8c93696906c3a91f310ca/pydantic_core-2.33.2-cp313-cp313-win_amd64.whl", hash = "sha256:c083a3bdd5a93dfe480f1125926afcdbf2917ae714bdb80b36d34318b2bec5d9", size = 1955269, upload-time = "2025-04-23T18:32:15.783Z" }, + { url = "https://files.pythonhosted.org/packages/f9/86/1beda0576969592f1497b4ce8e7bc8cbdf614c352426271b1b10d5f0aa64/pydantic_core-2.33.2-cp313-cp313-win_arm64.whl", hash = "sha256:e80b087132752f6b3d714f041ccf74403799d3b23a72722ea2e6ba2e892555b9", size = 1893921, upload-time = "2025-04-23T18:32:18.473Z" }, + { url = "https://files.pythonhosted.org/packages/a4/7d/e09391c2eebeab681df2b74bfe6c43422fffede8dc74187b2b0bf6fd7571/pydantic_core-2.33.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:61c18fba8e5e9db3ab908620af374db0ac1baa69f0f32df4f61ae23f15e586ac", size = 1806162, upload-time = "2025-04-23T18:32:20.188Z" }, + { url = "https://files.pythonhosted.org/packages/f1/3d/847b6b1fed9f8ed3bb95a9ad04fbd0b212e832d4f0f50ff4d9ee5a9f15cf/pydantic_core-2.33.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:95237e53bb015f67b63c91af7518a62a8660376a6a0db19b89acc77a4d6199f5", size = 1981560, upload-time = "2025-04-23T18:32:22.354Z" }, + { url = "https://files.pythonhosted.org/packages/6f/9a/e73262f6c6656262b5fdd723ad90f518f579b7bc8622e43a942eec53c938/pydantic_core-2.33.2-cp313-cp313t-win_amd64.whl", hash = "sha256:c2fc0a768ef76c15ab9238afa6da7f69895bb5d1ee83aeea2e3509af4472d0b9", size = 1935777, upload-time = "2025-04-23T18:32:25.088Z" }, + { url = "https://files.pythonhosted.org/packages/53/ea/bbe9095cdd771987d13c82d104a9c8559ae9aec1e29f139e286fd2e9256e/pydantic_core-2.33.2-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:a2b911a5b90e0374d03813674bf0a5fbbb7741570dcd4b4e85a2e48d17def29d", size = 2028677, upload-time = "2025-04-23T18:32:27.227Z" }, + { url = "https://files.pythonhosted.org/packages/49/1d/4ac5ed228078737d457a609013e8f7edc64adc37b91d619ea965758369e5/pydantic_core-2.33.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:6fa6dfc3e4d1f734a34710f391ae822e0a8eb8559a85c6979e14e65ee6ba2954", size = 1864735, upload-time = "2025-04-23T18:32:29.019Z" }, + { url = "https://files.pythonhosted.org/packages/23/9a/2e70d6388d7cda488ae38f57bc2f7b03ee442fbcf0d75d848304ac7e405b/pydantic_core-2.33.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c54c939ee22dc8e2d545da79fc5381f1c020d6d3141d3bd747eab59164dc89fb", size = 1898467, upload-time = "2025-04-23T18:32:31.119Z" }, + { url = "https://files.pythonhosted.org/packages/ff/2e/1568934feb43370c1ffb78a77f0baaa5a8b6897513e7a91051af707ffdc4/pydantic_core-2.33.2-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:53a57d2ed685940a504248187d5685e49eb5eef0f696853647bf37c418c538f7", size = 1983041, upload-time = "2025-04-23T18:32:33.655Z" }, + { url = "https://files.pythonhosted.org/packages/01/1a/1a1118f38ab64eac2f6269eb8c120ab915be30e387bb561e3af904b12499/pydantic_core-2.33.2-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:09fb9dd6571aacd023fe6aaca316bd01cf60ab27240d7eb39ebd66a3a15293b4", size = 2136503, upload-time = "2025-04-23T18:32:35.519Z" }, + { url = "https://files.pythonhosted.org/packages/5c/da/44754d1d7ae0f22d6d3ce6c6b1486fc07ac2c524ed8f6eca636e2e1ee49b/pydantic_core-2.33.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0e6116757f7959a712db11f3e9c0a99ade00a5bbedae83cb801985aa154f071b", size = 2736079, upload-time = "2025-04-23T18:32:37.659Z" }, + { url = "https://files.pythonhosted.org/packages/4d/98/f43cd89172220ec5aa86654967b22d862146bc4d736b1350b4c41e7c9c03/pydantic_core-2.33.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8d55ab81c57b8ff8548c3e4947f119551253f4e3787a7bbc0b6b3ca47498a9d3", size = 2006508, upload-time = "2025-04-23T18:32:39.637Z" }, + { url = "https://files.pythonhosted.org/packages/2b/cc/f77e8e242171d2158309f830f7d5d07e0531b756106f36bc18712dc439df/pydantic_core-2.33.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c20c462aa4434b33a2661701b861604913f912254e441ab8d78d30485736115a", size = 2113693, upload-time = "2025-04-23T18:32:41.818Z" }, + { url = "https://files.pythonhosted.org/packages/54/7a/7be6a7bd43e0a47c147ba7fbf124fe8aaf1200bc587da925509641113b2d/pydantic_core-2.33.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:44857c3227d3fb5e753d5fe4a3420d6376fa594b07b621e220cd93703fe21782", size = 2074224, upload-time = "2025-04-23T18:32:44.033Z" }, + { url = "https://files.pythonhosted.org/packages/2a/07/31cf8fadffbb03be1cb520850e00a8490c0927ec456e8293cafda0726184/pydantic_core-2.33.2-cp39-cp39-musllinux_1_1_armv7l.whl", hash = "sha256:eb9b459ca4df0e5c87deb59d37377461a538852765293f9e6ee834f0435a93b9", size = 2245403, upload-time = "2025-04-23T18:32:45.836Z" }, + { url = "https://files.pythonhosted.org/packages/b6/8d/bbaf4c6721b668d44f01861f297eb01c9b35f612f6b8e14173cb204e6240/pydantic_core-2.33.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:9fcd347d2cc5c23b06de6d3b7b8275be558a0c90549495c699e379a80bf8379e", size = 2242331, upload-time = "2025-04-23T18:32:47.618Z" }, + { url = "https://files.pythonhosted.org/packages/bb/93/3cc157026bca8f5006250e74515119fcaa6d6858aceee8f67ab6dc548c16/pydantic_core-2.33.2-cp39-cp39-win32.whl", hash = "sha256:83aa99b1285bc8f038941ddf598501a86f1536789740991d7d8756e34f1e74d9", size = 1910571, upload-time = "2025-04-23T18:32:49.401Z" }, + { url = "https://files.pythonhosted.org/packages/5b/90/7edc3b2a0d9f0dda8806c04e511a67b0b7a41d2187e2003673a996fb4310/pydantic_core-2.33.2-cp39-cp39-win_amd64.whl", hash = "sha256:f481959862f57f29601ccced557cc2e817bce7533ab8e01a797a48b49c9692b3", size = 1956504, upload-time = "2025-04-23T18:32:51.287Z" }, + { url = "https://files.pythonhosted.org/packages/30/68/373d55e58b7e83ce371691f6eaa7175e3a24b956c44628eb25d7da007917/pydantic_core-2.33.2-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:5c4aa4e82353f65e548c476b37e64189783aa5384903bfea4f41580f255fddfa", size = 2023982, upload-time = "2025-04-23T18:32:53.14Z" }, + { url = "https://files.pythonhosted.org/packages/a4/16/145f54ac08c96a63d8ed6442f9dec17b2773d19920b627b18d4f10a061ea/pydantic_core-2.33.2-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:d946c8bf0d5c24bf4fe333af284c59a19358aa3ec18cb3dc4370080da1e8ad29", size = 1858412, upload-time = "2025-04-23T18:32:55.52Z" }, + { url = "https://files.pythonhosted.org/packages/41/b1/c6dc6c3e2de4516c0bb2c46f6a373b91b5660312342a0cf5826e38ad82fa/pydantic_core-2.33.2-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:87b31b6846e361ef83fedb187bb5b4372d0da3f7e28d85415efa92d6125d6e6d", size = 1892749, upload-time = "2025-04-23T18:32:57.546Z" }, + { url = "https://files.pythonhosted.org/packages/12/73/8cd57e20afba760b21b742106f9dbdfa6697f1570b189c7457a1af4cd8a0/pydantic_core-2.33.2-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:aa9d91b338f2df0508606f7009fde642391425189bba6d8c653afd80fd6bb64e", size = 2067527, upload-time = "2025-04-23T18:32:59.771Z" }, + { url = "https://files.pythonhosted.org/packages/e3/d5/0bb5d988cc019b3cba4a78f2d4b3854427fc47ee8ec8e9eaabf787da239c/pydantic_core-2.33.2-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2058a32994f1fde4ca0480ab9d1e75a0e8c87c22b53a3ae66554f9af78f2fe8c", size = 2108225, upload-time = "2025-04-23T18:33:04.51Z" }, + { url = "https://files.pythonhosted.org/packages/f1/c5/00c02d1571913d496aabf146106ad8239dc132485ee22efe08085084ff7c/pydantic_core-2.33.2-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:0e03262ab796d986f978f79c943fc5f620381be7287148b8010b4097f79a39ec", size = 2069490, upload-time = "2025-04-23T18:33:06.391Z" }, + { url = "https://files.pythonhosted.org/packages/22/a8/dccc38768274d3ed3a59b5d06f59ccb845778687652daa71df0cab4040d7/pydantic_core-2.33.2-pp310-pypy310_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:1a8695a8d00c73e50bff9dfda4d540b7dee29ff9b8053e38380426a85ef10052", size = 2237525, upload-time = "2025-04-23T18:33:08.44Z" }, + { url = "https://files.pythonhosted.org/packages/d4/e7/4f98c0b125dda7cf7ccd14ba936218397b44f50a56dd8c16a3091df116c3/pydantic_core-2.33.2-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:fa754d1850735a0b0e03bcffd9d4b4343eb417e47196e4485d9cca326073a42c", size = 2238446, upload-time = "2025-04-23T18:33:10.313Z" }, + { url = "https://files.pythonhosted.org/packages/ce/91/2ec36480fdb0b783cd9ef6795753c1dea13882f2e68e73bce76ae8c21e6a/pydantic_core-2.33.2-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:a11c8d26a50bfab49002947d3d237abe4d9e4b5bdc8846a63537b6488e197808", size = 2066678, upload-time = "2025-04-23T18:33:12.224Z" }, + { url = "https://files.pythonhosted.org/packages/7b/27/d4ae6487d73948d6f20dddcd94be4ea43e74349b56eba82e9bdee2d7494c/pydantic_core-2.33.2-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:dd14041875d09cc0f9308e37a6f8b65f5585cf2598a53aa0123df8b129d481f8", size = 2025200, upload-time = "2025-04-23T18:33:14.199Z" }, + { url = "https://files.pythonhosted.org/packages/f1/b8/b3cb95375f05d33801024079b9392a5ab45267a63400bf1866e7ce0f0de4/pydantic_core-2.33.2-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:d87c561733f66531dced0da6e864f44ebf89a8fba55f31407b00c2f7f9449593", size = 1859123, upload-time = "2025-04-23T18:33:16.555Z" }, + { url = "https://files.pythonhosted.org/packages/05/bc/0d0b5adeda59a261cd30a1235a445bf55c7e46ae44aea28f7bd6ed46e091/pydantic_core-2.33.2-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2f82865531efd18d6e07a04a17331af02cb7a651583c418df8266f17a63c6612", size = 1892852, upload-time = "2025-04-23T18:33:18.513Z" }, + { url = "https://files.pythonhosted.org/packages/3e/11/d37bdebbda2e449cb3f519f6ce950927b56d62f0b84fd9cb9e372a26a3d5/pydantic_core-2.33.2-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2bfb5112df54209d820d7bf9317c7a6c9025ea52e49f46b6a2060104bba37de7", size = 2067484, upload-time = "2025-04-23T18:33:20.475Z" }, + { url = "https://files.pythonhosted.org/packages/8c/55/1f95f0a05ce72ecb02a8a8a1c3be0579bbc29b1d5ab68f1378b7bebc5057/pydantic_core-2.33.2-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:64632ff9d614e5eecfb495796ad51b0ed98c453e447a76bcbeeb69615079fc7e", size = 2108896, upload-time = "2025-04-23T18:33:22.501Z" }, + { url = "https://files.pythonhosted.org/packages/53/89/2b2de6c81fa131f423246a9109d7b2a375e83968ad0800d6e57d0574629b/pydantic_core-2.33.2-pp311-pypy311_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:f889f7a40498cc077332c7ab6b4608d296d852182211787d4f3ee377aaae66e8", size = 2069475, upload-time = "2025-04-23T18:33:24.528Z" }, + { url = "https://files.pythonhosted.org/packages/b8/e9/1f7efbe20d0b2b10f6718944b5d8ece9152390904f29a78e68d4e7961159/pydantic_core-2.33.2-pp311-pypy311_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:de4b83bb311557e439b9e186f733f6c645b9417c84e2eb8203f3f820a4b988bf", size = 2239013, upload-time = "2025-04-23T18:33:26.621Z" }, + { url = "https://files.pythonhosted.org/packages/3c/b2/5309c905a93811524a49b4e031e9851a6b00ff0fb668794472ea7746b448/pydantic_core-2.33.2-pp311-pypy311_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:82f68293f055f51b51ea42fafc74b6aad03e70e191799430b90c13d643059ebb", size = 2238715, upload-time = "2025-04-23T18:33:28.656Z" }, + { url = "https://files.pythonhosted.org/packages/32/56/8a7ca5d2cd2cda1d245d34b1c9a942920a718082ae8e54e5f3e5a58b7add/pydantic_core-2.33.2-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:329467cecfb529c925cf2bbd4d60d2c509bc2fb52a20c1045bf09bb70971a9c1", size = 2066757, upload-time = "2025-04-23T18:33:30.645Z" }, + { url = "https://files.pythonhosted.org/packages/08/98/dbf3fdfabaf81cda5622154fda78ea9965ac467e3239078e0dcd6df159e7/pydantic_core-2.33.2-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:87acbfcf8e90ca885206e98359d7dca4bcbb35abdc0ff66672a293e1d7a19101", size = 2024034, upload-time = "2025-04-23T18:33:32.843Z" }, + { url = "https://files.pythonhosted.org/packages/8d/99/7810aa9256e7f2ccd492590f86b79d370df1e9292f1f80b000b6a75bd2fb/pydantic_core-2.33.2-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:7f92c15cd1e97d4b12acd1cc9004fa092578acfa57b67ad5e43a197175d01a64", size = 1858578, upload-time = "2025-04-23T18:33:34.912Z" }, + { url = "https://files.pythonhosted.org/packages/d8/60/bc06fa9027c7006cc6dd21e48dbf39076dc39d9abbaf718a1604973a9670/pydantic_core-2.33.2-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d3f26877a748dc4251cfcfda9dfb5f13fcb034f5308388066bcfe9031b63ae7d", size = 1892858, upload-time = "2025-04-23T18:33:36.933Z" }, + { url = "https://files.pythonhosted.org/packages/f2/40/9d03997d9518816c68b4dfccb88969756b9146031b61cd37f781c74c9b6a/pydantic_core-2.33.2-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dac89aea9af8cd672fa7b510e7b8c33b0bba9a43186680550ccf23020f32d535", size = 2068498, upload-time = "2025-04-23T18:33:38.997Z" }, + { url = "https://files.pythonhosted.org/packages/d8/62/d490198d05d2d86672dc269f52579cad7261ced64c2df213d5c16e0aecb1/pydantic_core-2.33.2-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:970919794d126ba8645f3837ab6046fb4e72bbc057b3709144066204c19a455d", size = 2108428, upload-time = "2025-04-23T18:33:41.18Z" }, + { url = "https://files.pythonhosted.org/packages/9a/ec/4cd215534fd10b8549015f12ea650a1a973da20ce46430b68fc3185573e8/pydantic_core-2.33.2-pp39-pypy39_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:3eb3fe62804e8f859c49ed20a8451342de53ed764150cb14ca71357c765dc2a6", size = 2069854, upload-time = "2025-04-23T18:33:43.446Z" }, + { url = "https://files.pythonhosted.org/packages/1a/1a/abbd63d47e1d9b0d632fee6bb15785d0889c8a6e0a6c3b5a8e28ac1ec5d2/pydantic_core-2.33.2-pp39-pypy39_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:3abcd9392a36025e3bd55f9bd38d908bd17962cc49bc6da8e7e96285336e2bca", size = 2237859, upload-time = "2025-04-23T18:33:45.56Z" }, + { url = "https://files.pythonhosted.org/packages/80/1c/fa883643429908b1c90598fd2642af8839efd1d835b65af1f75fba4d94fe/pydantic_core-2.33.2-pp39-pypy39_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:3a1c81334778f9e3af2f8aeb7a960736e5cab1dfebfb26aabca09afd2906c039", size = 2239059, upload-time = "2025-04-23T18:33:47.735Z" }, + { url = "https://files.pythonhosted.org/packages/d4/29/3cade8a924a61f60ccfa10842f75eb12787e1440e2b8660ceffeb26685e7/pydantic_core-2.33.2-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:2807668ba86cb38c6817ad9bc66215ab8584d1d304030ce4f0887336f28a5e27", size = 2066661, upload-time = "2025-04-23T18:33:49.995Z" }, +] + +[[package]] +name = "pygments" +version = "2.19.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7c/2d/c3338d48ea6cc0feb8446d8e6937e1408088a72a39937982cc6111d17f84/pygments-2.19.1.tar.gz", hash = "sha256:61c16d2a8576dc0649d9f39e089b5f02bcd27fba10d8fb4dcc28173f7a45151f", size = 4968581, upload-time = "2025-01-06T17:26:30.443Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8a/0b/9fcc47d19c48b59121088dd6da2488a49d5f72dacf8262e2790a1d2c7d15/pygments-2.19.1-py3-none-any.whl", hash = "sha256:9ea1544ad55cecf4b8242fab6dd35a93bbce657034b0611ee383099054ab6d8c", size = 1225293, upload-time = "2025-01-06T17:26:25.553Z" }, +] + +[[package]] +name = "pyiceberg" +version = "0.9.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cachetools" }, + { name = "click", version = "8.1.8", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, + { name = "click", version = "8.2.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "fsspec" }, + { name = "mmh3" }, + { name = "pydantic" }, + { name = "pyparsing" }, + { name = "requests" }, + { name = "rich" }, + { name = "sortedcontainers" }, + { name = "strictyaml" }, + { name = "tenacity" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/bd/6a/6c1ac381ff0b8e03a9abc2f05722f6002d7452a2c05118697b3f3910e171/pyiceberg-0.9.1.tar.gz", hash = "sha256:3634134ce33859a441768b39df179b2c6f3de2bbbf506622884f553b013ee799", size = 617629, upload-time = "2025-04-30T14:59:34.306Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ea/5d/bb10c86b85895d4ba471b8a0e187031d4aaa82592a639242b83dd9354861/pyiceberg-0.9.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0a183d9217eb82159c01b23c683057f96c8b2375f592b921721d1c157895e2df", size = 527097, upload-time = "2025-04-30T14:58:52.39Z" }, + { url = "https://files.pythonhosted.org/packages/ec/b9/1d6f0d334bc51cd64a58b7320d521e54af3810a6bd748fe2e89db1ad8d5f/pyiceberg-0.9.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:57030bb15c397b0379242907c5611f5b4338fb799e972353fd0edafde6cfd2ef", size = 523267, upload-time = "2025-04-30T14:58:53.978Z" }, + { url = "https://files.pythonhosted.org/packages/02/f5/bd43a9c1d2cd3aeb987cbf2b7f25e2b10306fa81522ea00df250fb23cc84/pyiceberg-0.9.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3ba4cd9a8f6a04cfbc68e0c83f2db3ffd14244da8601a142cc05965d4b343645", size = 838616, upload-time = "2025-04-30T14:58:55.252Z" }, + { url = "https://files.pythonhosted.org/packages/d0/01/c68f9e03413dc983ddadc2c471038af2ff792449fc451731f58a958a7696/pyiceberg-0.9.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:d5a48c6a2016d0dcde8c9079cc5e6b6d2e2ac663eddfe4697e7ea03a0edc40b7", size = 838290, upload-time = "2025-04-30T14:58:56.412Z" }, + { url = "https://files.pythonhosted.org/packages/ab/80/b7cba54a33b8b7be3655ff656d6bb8594fec0316eec5cafa231ec7f6ff74/pyiceberg-0.9.1-cp310-cp310-win_amd64.whl", hash = "sha256:8bebfa5a804a95a9f3d98d88cbeb37430b09add04592238bba2a2b2e0466d60d", size = 523612, upload-time = "2025-04-30T14:58:59.507Z" }, + { url = "https://files.pythonhosted.org/packages/f6/75/c8b4ebba7d345b5e736ebf4976121b97dd7091dcad401a17ca57152704c5/pyiceberg-0.9.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:0e75c502dd56ac3d77036ce8a3b2566348da5ff4367c7c671981616ef6dcc883", size = 566274, upload-time = "2025-04-30T14:59:00.626Z" }, + { url = "https://files.pythonhosted.org/packages/e0/a0/9494c7930e5e4dc951d95abba584d8ffdb7403368398796ede21ff25c26f/pyiceberg-0.9.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:0a8189c9b3ba81dd12493d6bb874a656a4d4909904552b97a629d1d43b3a0e90", size = 560157, upload-time = "2025-04-30T14:59:02.082Z" }, + { url = "https://files.pythonhosted.org/packages/4a/d4/351776b1ae83de187d7cf37b100f4f124c7a71e35337182d3aef308156d1/pyiceberg-0.9.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7c03065d5c5b704444ab8fb18cdd232ec43994db95b9e53444008ebc2cf9dc2c", size = 1052290, upload-time = "2025-04-30T14:59:03.232Z" }, + { url = "https://files.pythonhosted.org/packages/40/17/d8fea681afb52f20bf6a640f9044dcf621a47165f67cc5320bf3c6e82e4e/pyiceberg-0.9.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:93f2586a5da737de6e4643bf096a01772f068d1eedb7ffde6b36c60b6b9e6bd3", size = 1047503, upload-time = "2025-04-30T14:59:04.38Z" }, + { url = "https://files.pythonhosted.org/packages/d0/e0/d173fc2aa8dc252d7aac71703ba2c0491e4988b3a160cf5abb531cfb9086/pyiceberg-0.9.1-cp311-cp311-win_amd64.whl", hash = "sha256:94e45c10051110ba7a43b85a1f0a680b4a31d1d6cee593c8e62e14d22d18c47d", size = 559491, upload-time = "2025-04-30T14:59:05.615Z" }, + { url = "https://files.pythonhosted.org/packages/52/26/77983c2884b4a5f13f8a35e5c5e762ae699f6c511efd16730ab883000c1b/pyiceberg-0.9.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b8a958e3bbe919026533cee1f0fb6b7040928fce8d42c2ecea228de7c17578fa", size = 605755, upload-time = "2025-04-30T14:59:07.087Z" }, + { url = "https://files.pythonhosted.org/packages/6d/67/e6ea7fcc43aebc85aea5a67a69d01c9015283478061c3121b6b8aa158ce4/pyiceberg-0.9.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b7e956b35c6822600c45fd8f3ea8cfea328cc406fefa534afeb6fdb325d05406", size = 597325, upload-time = "2025-04-30T14:59:08.644Z" }, + { url = "https://files.pythonhosted.org/packages/7f/cf/178a9f63fac1bfdd13bc85169e7ab903955d082e2cd80507b1921a6f64dc/pyiceberg-0.9.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1e4e585164d7d86f5c9a609a1bc2abeae2f0ea0680a11a2064d3a945866b5311", size = 1277399, upload-time = "2025-04-30T14:59:10.193Z" }, + { url = "https://files.pythonhosted.org/packages/d1/6b/78d1739eb1d5b18529ee438aed75dac3e0b246f5e4d800931f9d1e37cda2/pyiceberg-0.9.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:5fee08dac30e8524526f7d18468f9670f8606905b850b261314c597c6633f3b4", size = 1269083, upload-time = "2025-04-30T14:59:11.964Z" }, + { url = "https://files.pythonhosted.org/packages/67/69/c0087d19c8d8e8530acee3ba485d54aedeebf2963784a16692ca4b439566/pyiceberg-0.9.1-cp312-cp312-win_amd64.whl", hash = "sha256:124793c54a0c2fb5ac4ab19c38da116c068e277c85cbaa7e4064e635a70b595e", size = 595512, upload-time = "2025-04-30T14:59:14.464Z" }, + { url = "https://files.pythonhosted.org/packages/08/12/8d46a700af1a2a9cb41d612115303d462a71646edd0f196ec961b09e9dba/pyiceberg-0.9.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:a6e29eb5ce63e8a14738f3efeb54022093456e02b681f0b8c815f7ef9e20ddcb", size = 488285, upload-time = "2025-04-30T14:59:15.823Z" }, + { url = "https://files.pythonhosted.org/packages/35/47/35b0e1466b79d8a98881c1e5bd02b75a6611d27f8202dcbcc3bbcccd71fc/pyiceberg-0.9.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:1ebd4f74da8a3f7b78ad746c1d91d8cd9aa9cf97f4d36da164e3550f6a06b00e", size = 486373, upload-time = "2025-04-30T14:59:17.297Z" }, + { url = "https://files.pythonhosted.org/packages/97/cf/a55aedec089b521445b6bb18f703e3e8f666f22c7b81db0b8668b6727ed6/pyiceberg-0.9.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b357638a58d9b0a5d7018fbe88fa84469c980c80d86441b7b9cd99871512447d", size = 645018, upload-time = "2025-04-30T14:59:18.41Z" }, + { url = "https://files.pythonhosted.org/packages/fc/b1/32f25ea1905c0e7581d68d30e5a0b69182f9cab0acd3e8a9d1648429a39e/pyiceberg-0.9.1-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:f8a93c1e4ab35195018ce8fbbb6d973e099194ffe06d859bdf069d7b846da7aa", size = 644838, upload-time = "2025-04-30T14:59:19.515Z" }, + { url = "https://files.pythonhosted.org/packages/40/0f/d3ade290baddef6cfa31430e131bb36f3e34a8ec2d3bc5caf107e58dbbda/pyiceberg-0.9.1-cp39-cp39-win_amd64.whl", hash = "sha256:5c1b3598d521476ffce13949ae762a3dec49287198b26de445caa0daf2e395fa", size = 487809, upload-time = "2025-04-30T14:59:20.61Z" }, + { url = "https://files.pythonhosted.org/packages/aa/62/0153ed3a39d6f4b3235d430123703d4684eec7ba780404bbc118ace7406a/pyiceberg-0.9.1-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:77aec1c77d675603e0c5358e74adcae8d13b323753d702011be3f309d26af355", size = 668261, upload-time = "2025-04-30T14:59:21.751Z" }, + { url = "https://files.pythonhosted.org/packages/24/bd/c4cec142686dd8124032c69b6b02ba3703abc114ce787d0f02088b1f43d8/pyiceberg-0.9.1-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:cf567438bf6267bbb67fdfdfc72ac500d523725fca9a6a38f93e8acd4146190e", size = 657439, upload-time = "2025-04-30T14:59:23.304Z" }, + { url = "https://files.pythonhosted.org/packages/ae/74/bbfc70bb1857f9d55d06fee1330a0236876b8ae4aa6fc5d815e2c4fef4f7/pyiceberg-0.9.1-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5992db7c00d789a33ff117700d453126803e769507a5edeb79bb6510ff72fc00", size = 1352983, upload-time = "2025-04-30T14:59:25.023Z" }, + { url = "https://files.pythonhosted.org/packages/90/20/e33e1716d1368b2471b80d9f1e338110f1e781b34ebffc5e320523102ffc/pyiceberg-0.9.1-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:c9e460fca26162a3822c0e8d50b49c80928a0e35cb41698748d7a26f8c016215", size = 657563, upload-time = "2025-04-30T14:59:27.004Z" }, + { url = "https://files.pythonhosted.org/packages/c9/37/9d531ce880a5ccd458a408b0b8d65305201822166d6cabdb6daa5a1f1f6f/pyiceberg-0.9.1-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:037aa7a8bfaf7f1482e6a3532217b5f4281bc81db6698c3ea87771d0453a8232", size = 637004, upload-time = "2025-04-30T14:59:28.948Z" }, + { url = "https://files.pythonhosted.org/packages/eb/fd/d370f11fcb8da9c4146356dd635ef6a6615372f1e202e37cb4a9e47fafd5/pyiceberg-0.9.1-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:5150464428a0568c4f46405884bc777dde37935580fb72b0030dfa28805d82e7", size = 627370, upload-time = "2025-04-30T14:59:30.559Z" }, + { url = "https://files.pythonhosted.org/packages/af/66/843ce33ab3dbcce71fa8dec4368f930c4349d0c403990087a2ae996d387e/pyiceberg-0.9.1-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:af2a6c273cfaf2b21b319fcf79489f87604220a0497942303b2a715a9d0f29e9", size = 1315204, upload-time = "2025-04-30T14:59:31.959Z" }, + { url = "https://files.pythonhosted.org/packages/1c/56/f0c7014cd16bd9990bdfa9b901fe6ecc344d6b9775676dc35c48b3a6aca1/pyiceberg-0.9.1-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:023c3fcee36a441b7e20418b6e9cdc6f904141bfda09f8580dfe022d7faa7a53", size = 626539, upload-time = "2025-04-30T14:59:33.17Z" }, +] + +[[package]] +name = "pyparsing" +version = "3.2.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/bb/22/f1129e69d94ffff626bdb5c835506b3a5b4f3d070f17ea295e12c2c6f60f/pyparsing-3.2.3.tar.gz", hash = "sha256:b9c13f1ab8b3b542f72e28f634bad4de758ab3ce4546e4301970ad6fa77c38be", size = 1088608, upload-time = "2025-03-25T05:01:28.114Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/05/e7/df2285f3d08fee213f2d041540fa4fc9ca6c2d44cf36d3a035bf2a8d2bcc/pyparsing-3.2.3-py3-none-any.whl", hash = "sha256:a749938e02d6fd0b59b356ca504a24982314bb090c383e3cf201c95ef7e2bfcf", size = 111120, upload-time = "2025-03-25T05:01:24.908Z" }, +] + +[[package]] +name = "pytest" +version = "8.3.5" +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 = "tomli", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ae/3c/c9d525a414d506893f0cd8a8d0de7706446213181570cdbd766691164e40/pytest-8.3.5.tar.gz", hash = "sha256:f4efe70cc14e511565ac476b57c279e12a855b11f48f212af1080ef2263d3845", size = 1450891, upload-time = "2025-03-02T12:54:54.503Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/30/3d/64ad57c803f1fa1e963a7946b6e0fea4a70df53c1a7fed304586539c2bac/pytest-8.3.5-py3-none-any.whl", hash = "sha256:c69214aa47deac29fad6c2a4f590b9c4a9fdb16a403176fe154b79c0b4d4d820", size = 343634, upload-time = "2025-03-02T12:54:52.069Z" }, +] + +[[package]] +name = "pytest-mock" +version = "3.14.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pytest" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/71/28/67172c96ba684058a4d24ffe144d64783d2a270d0af0d9e792737bddc75c/pytest_mock-3.14.1.tar.gz", hash = "sha256:159e9edac4c451ce77a5cdb9fc5d1100708d2dd4ba3c3df572f14097351af80e", size = 33241, upload-time = "2025-05-26T13:58:45.167Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b2/05/77b60e520511c53d1c1ca75f1930c7dd8e971d0c4379b7f4b3f9644685ba/pytest_mock-3.14.1-py3-none-any.whl", hash = "sha256:178aefcd11307d874b4cd3100344e7e2d888d9791a6a1d9bfe90fbc1b74fd1d0", size = 9923, upload-time = "2025-05-26T13:58:43.487Z" }, +] + +[[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 = "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 = "pyyaml" +version = "6.0.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/54/ed/79a089b6be93607fa5cdaedf301d7dfb23af5f25c398d5ead2525b063e17/pyyaml-6.0.2.tar.gz", hash = "sha256:d584d9ec91ad65861cc08d42e834324ef890a082e591037abe114850ff7bbc3e", size = 130631, upload-time = "2024-08-06T20:33:50.674Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9b/95/a3fac87cb7158e231b5a6012e438c647e1a87f09f8e0d123acec8ab8bf71/PyYAML-6.0.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0a9a2848a5b7feac301353437eb7d5957887edbf81d56e903999a75a3d743086", size = 184199, upload-time = "2024-08-06T20:31:40.178Z" }, + { url = "https://files.pythonhosted.org/packages/c7/7a/68bd47624dab8fd4afbfd3c48e3b79efe09098ae941de5b58abcbadff5cb/PyYAML-6.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:29717114e51c84ddfba879543fb232a6ed60086602313ca38cce623c1d62cfbf", size = 171758, upload-time = "2024-08-06T20:31:42.173Z" }, + { url = "https://files.pythonhosted.org/packages/49/ee/14c54df452143b9ee9f0f29074d7ca5516a36edb0b4cc40c3f280131656f/PyYAML-6.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8824b5a04a04a047e72eea5cec3bc266db09e35de6bdfe34c9436ac5ee27d237", size = 718463, upload-time = "2024-08-06T20:31:44.263Z" }, + { url = "https://files.pythonhosted.org/packages/4d/61/de363a97476e766574650d742205be468921a7b532aa2499fcd886b62530/PyYAML-6.0.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7c36280e6fb8385e520936c3cb3b8042851904eba0e58d277dca80a5cfed590b", size = 719280, upload-time = "2024-08-06T20:31:50.199Z" }, + { url = "https://files.pythonhosted.org/packages/6b/4e/1523cb902fd98355e2e9ea5e5eb237cbc5f3ad5f3075fa65087aa0ecb669/PyYAML-6.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ec031d5d2feb36d1d1a24380e4db6d43695f3748343d99434e6f5f9156aaa2ed", size = 751239, upload-time = "2024-08-06T20:31:52.292Z" }, + { url = "https://files.pythonhosted.org/packages/b7/33/5504b3a9a4464893c32f118a9cc045190a91637b119a9c881da1cf6b7a72/PyYAML-6.0.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:936d68689298c36b53b29f23c6dbb74de12b4ac12ca6cfe0e047bedceea56180", size = 695802, upload-time = "2024-08-06T20:31:53.836Z" }, + { url = "https://files.pythonhosted.org/packages/5c/20/8347dcabd41ef3a3cdc4f7b7a2aff3d06598c8779faa189cdbf878b626a4/PyYAML-6.0.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:23502f431948090f597378482b4812b0caae32c22213aecf3b55325e049a6c68", size = 720527, upload-time = "2024-08-06T20:31:55.565Z" }, + { url = "https://files.pythonhosted.org/packages/be/aa/5afe99233fb360d0ff37377145a949ae258aaab831bde4792b32650a4378/PyYAML-6.0.2-cp310-cp310-win32.whl", hash = "sha256:2e99c6826ffa974fe6e27cdb5ed0021786b03fc98e5ee3c5bfe1fd5015f42b99", size = 144052, upload-time = "2024-08-06T20:31:56.914Z" }, + { url = "https://files.pythonhosted.org/packages/b5/84/0fa4b06f6d6c958d207620fc60005e241ecedceee58931bb20138e1e5776/PyYAML-6.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:a4d3091415f010369ae4ed1fc6b79def9416358877534caf6a0fdd2146c87a3e", size = 161774, upload-time = "2024-08-06T20:31:58.304Z" }, + { url = "https://files.pythonhosted.org/packages/f8/aa/7af4e81f7acba21a4c6be026da38fd2b872ca46226673c89a758ebdc4fd2/PyYAML-6.0.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:cc1c1159b3d456576af7a3e4d1ba7e6924cb39de8f67111c735f6fc832082774", size = 184612, upload-time = "2024-08-06T20:32:03.408Z" }, + { url = "https://files.pythonhosted.org/packages/8b/62/b9faa998fd185f65c1371643678e4d58254add437edb764a08c5a98fb986/PyYAML-6.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1e2120ef853f59c7419231f3bf4e7021f1b936f6ebd222406c3b60212205d2ee", size = 172040, upload-time = "2024-08-06T20:32:04.926Z" }, + { url = "https://files.pythonhosted.org/packages/ad/0c/c804f5f922a9a6563bab712d8dcc70251e8af811fce4524d57c2c0fd49a4/PyYAML-6.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5d225db5a45f21e78dd9358e58a98702a0302f2659a3c6cd320564b75b86f47c", size = 736829, upload-time = "2024-08-06T20:32:06.459Z" }, + { url = "https://files.pythonhosted.org/packages/51/16/6af8d6a6b210c8e54f1406a6b9481febf9c64a3109c541567e35a49aa2e7/PyYAML-6.0.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5ac9328ec4831237bec75defaf839f7d4564be1e6b25ac710bd1a96321cc8317", size = 764167, upload-time = "2024-08-06T20:32:08.338Z" }, + { url = "https://files.pythonhosted.org/packages/75/e4/2c27590dfc9992f73aabbeb9241ae20220bd9452df27483b6e56d3975cc5/PyYAML-6.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3ad2a3decf9aaba3d29c8f537ac4b243e36bef957511b4766cb0057d32b0be85", size = 762952, upload-time = "2024-08-06T20:32:14.124Z" }, + { url = "https://files.pythonhosted.org/packages/9b/97/ecc1abf4a823f5ac61941a9c00fe501b02ac3ab0e373c3857f7d4b83e2b6/PyYAML-6.0.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:ff3824dc5261f50c9b0dfb3be22b4567a6f938ccce4587b38952d85fd9e9afe4", size = 735301, upload-time = "2024-08-06T20:32:16.17Z" }, + { url = "https://files.pythonhosted.org/packages/45/73/0f49dacd6e82c9430e46f4a027baa4ca205e8b0a9dce1397f44edc23559d/PyYAML-6.0.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:797b4f722ffa07cc8d62053e4cff1486fa6dc094105d13fea7b1de7d8bf71c9e", size = 756638, upload-time = "2024-08-06T20:32:18.555Z" }, + { url = "https://files.pythonhosted.org/packages/22/5f/956f0f9fc65223a58fbc14459bf34b4cc48dec52e00535c79b8db361aabd/PyYAML-6.0.2-cp311-cp311-win32.whl", hash = "sha256:11d8f3dd2b9c1207dcaf2ee0bbbfd5991f571186ec9cc78427ba5bd32afae4b5", size = 143850, upload-time = "2024-08-06T20:32:19.889Z" }, + { url = "https://files.pythonhosted.org/packages/ed/23/8da0bbe2ab9dcdd11f4f4557ccaf95c10b9811b13ecced089d43ce59c3c8/PyYAML-6.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:e10ce637b18caea04431ce14fabcf5c64a1c61ec9c56b071a4b7ca131ca52d44", size = 161980, upload-time = "2024-08-06T20:32:21.273Z" }, + { url = "https://files.pythonhosted.org/packages/86/0c/c581167fc46d6d6d7ddcfb8c843a4de25bdd27e4466938109ca68492292c/PyYAML-6.0.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:c70c95198c015b85feafc136515252a261a84561b7b1d51e3384e0655ddf25ab", size = 183873, upload-time = "2024-08-06T20:32:25.131Z" }, + { url = "https://files.pythonhosted.org/packages/a8/0c/38374f5bb272c051e2a69281d71cba6fdb983413e6758b84482905e29a5d/PyYAML-6.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ce826d6ef20b1bc864f0a68340c8b3287705cae2f8b4b1d932177dcc76721725", size = 173302, upload-time = "2024-08-06T20:32:26.511Z" }, + { url = "https://files.pythonhosted.org/packages/c3/93/9916574aa8c00aa06bbac729972eb1071d002b8e158bd0e83a3b9a20a1f7/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1f71ea527786de97d1a0cc0eacd1defc0985dcf6b3f17bb77dcfc8c34bec4dc5", size = 739154, upload-time = "2024-08-06T20:32:28.363Z" }, + { url = "https://files.pythonhosted.org/packages/95/0f/b8938f1cbd09739c6da569d172531567dbcc9789e0029aa070856f123984/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9b22676e8097e9e22e36d6b7bda33190d0d400f345f23d4065d48f4ca7ae0425", size = 766223, upload-time = "2024-08-06T20:32:30.058Z" }, + { url = "https://files.pythonhosted.org/packages/b9/2b/614b4752f2e127db5cc206abc23a8c19678e92b23c3db30fc86ab731d3bd/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:80bab7bfc629882493af4aa31a4cfa43a4c57c83813253626916b8c7ada83476", size = 767542, upload-time = "2024-08-06T20:32:31.881Z" }, + { url = "https://files.pythonhosted.org/packages/d4/00/dd137d5bcc7efea1836d6264f049359861cf548469d18da90cd8216cf05f/PyYAML-6.0.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:0833f8694549e586547b576dcfaba4a6b55b9e96098b36cdc7ebefe667dfed48", size = 731164, upload-time = "2024-08-06T20:32:37.083Z" }, + { url = "https://files.pythonhosted.org/packages/c9/1f/4f998c900485e5c0ef43838363ba4a9723ac0ad73a9dc42068b12aaba4e4/PyYAML-6.0.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8b9c7197f7cb2738065c481a0461e50ad02f18c78cd75775628afb4d7137fb3b", size = 756611, upload-time = "2024-08-06T20:32:38.898Z" }, + { url = "https://files.pythonhosted.org/packages/df/d1/f5a275fdb252768b7a11ec63585bc38d0e87c9e05668a139fea92b80634c/PyYAML-6.0.2-cp312-cp312-win32.whl", hash = "sha256:ef6107725bd54b262d6dedcc2af448a266975032bc85ef0172c5f059da6325b4", size = 140591, upload-time = "2024-08-06T20:32:40.241Z" }, + { url = "https://files.pythonhosted.org/packages/0c/e8/4f648c598b17c3d06e8753d7d13d57542b30d56e6c2dedf9c331ae56312e/PyYAML-6.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:7e7401d0de89a9a855c839bc697c079a4af81cf878373abd7dc625847d25cbd8", size = 156338, upload-time = "2024-08-06T20:32:41.93Z" }, + { url = "https://files.pythonhosted.org/packages/ef/e3/3af305b830494fa85d95f6d95ef7fa73f2ee1cc8ef5b495c7c3269fb835f/PyYAML-6.0.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:efdca5630322a10774e8e98e1af481aad470dd62c3170801852d752aa7a783ba", size = 181309, upload-time = "2024-08-06T20:32:43.4Z" }, + { url = "https://files.pythonhosted.org/packages/45/9f/3b1c20a0b7a3200524eb0076cc027a970d320bd3a6592873c85c92a08731/PyYAML-6.0.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:50187695423ffe49e2deacb8cd10510bc361faac997de9efef88badc3bb9e2d1", size = 171679, upload-time = "2024-08-06T20:32:44.801Z" }, + { url = "https://files.pythonhosted.org/packages/7c/9a/337322f27005c33bcb656c655fa78325b730324c78620e8328ae28b64d0c/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0ffe8360bab4910ef1b9e87fb812d8bc0a308b0d0eef8c8f44e0254ab3b07133", size = 733428, upload-time = "2024-08-06T20:32:46.432Z" }, + { url = "https://files.pythonhosted.org/packages/a3/69/864fbe19e6c18ea3cc196cbe5d392175b4cf3d5d0ac1403ec3f2d237ebb5/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:17e311b6c678207928d649faa7cb0d7b4c26a0ba73d41e99c4fff6b6c3276484", size = 763361, upload-time = "2024-08-06T20:32:51.188Z" }, + { url = "https://files.pythonhosted.org/packages/04/24/b7721e4845c2f162d26f50521b825fb061bc0a5afcf9a386840f23ea19fa/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:70b189594dbe54f75ab3a1acec5f1e3faa7e8cf2f1e08d9b561cb41b845f69d5", size = 759523, upload-time = "2024-08-06T20:32:53.019Z" }, + { url = "https://files.pythonhosted.org/packages/2b/b2/e3234f59ba06559c6ff63c4e10baea10e5e7df868092bf9ab40e5b9c56b6/PyYAML-6.0.2-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:41e4e3953a79407c794916fa277a82531dd93aad34e29c2a514c2c0c5fe971cc", size = 726660, upload-time = "2024-08-06T20:32:54.708Z" }, + { url = "https://files.pythonhosted.org/packages/fe/0f/25911a9f080464c59fab9027482f822b86bf0608957a5fcc6eaac85aa515/PyYAML-6.0.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:68ccc6023a3400877818152ad9a1033e3db8625d899c72eacb5a668902e4d652", size = 751597, upload-time = "2024-08-06T20:32:56.985Z" }, + { url = "https://files.pythonhosted.org/packages/14/0d/e2c3b43bbce3cf6bd97c840b46088a3031085179e596d4929729d8d68270/PyYAML-6.0.2-cp313-cp313-win32.whl", hash = "sha256:bc2fa7c6b47d6bc618dd7fb02ef6fdedb1090ec036abab80d4681424b84c1183", size = 140527, upload-time = "2024-08-06T20:33:03.001Z" }, + { url = "https://files.pythonhosted.org/packages/fa/de/02b54f42487e3d3c6efb3f89428677074ca7bf43aae402517bc7cca949f3/PyYAML-6.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:8388ee1976c416731879ac16da0aff3f63b286ffdd57cdeb95f3f2e085687563", size = 156446, upload-time = "2024-08-06T20:33:04.33Z" }, + { url = "https://files.pythonhosted.org/packages/65/d8/b7a1db13636d7fb7d4ff431593c510c8b8fca920ade06ca8ef20015493c5/PyYAML-6.0.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:688ba32a1cffef67fd2e9398a2efebaea461578b0923624778664cc1c914db5d", size = 184777, upload-time = "2024-08-06T20:33:25.896Z" }, + { url = "https://files.pythonhosted.org/packages/0a/02/6ec546cd45143fdf9840b2c6be8d875116a64076218b61d68e12548e5839/PyYAML-6.0.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:a8786accb172bd8afb8be14490a16625cbc387036876ab6ba70912730faf8e1f", size = 172318, upload-time = "2024-08-06T20:33:27.212Z" }, + { url = "https://files.pythonhosted.org/packages/0e/9a/8cc68be846c972bda34f6c2a93abb644fb2476f4dcc924d52175786932c9/PyYAML-6.0.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d8e03406cac8513435335dbab54c0d385e4a49e4945d2909a581c83647ca0290", size = 720891, upload-time = "2024-08-06T20:33:28.974Z" }, + { url = "https://files.pythonhosted.org/packages/e9/6c/6e1b7f40181bc4805e2e07f4abc10a88ce4648e7e95ff1abe4ae4014a9b2/PyYAML-6.0.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f753120cb8181e736c57ef7636e83f31b9c0d1722c516f7e86cf15b7aa57ff12", size = 722614, upload-time = "2024-08-06T20:33:34.157Z" }, + { url = "https://files.pythonhosted.org/packages/3d/32/e7bd8535d22ea2874cef6a81021ba019474ace0d13a4819c2a4bce79bd6a/PyYAML-6.0.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3b1fdb9dc17f5a7677423d508ab4f243a726dea51fa5e70992e59a7411c89d19", size = 737360, upload-time = "2024-08-06T20:33:35.84Z" }, + { url = "https://files.pythonhosted.org/packages/d7/12/7322c1e30b9be969670b672573d45479edef72c9a0deac3bb2868f5d7469/PyYAML-6.0.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:0b69e4ce7a131fe56b7e4d770c67429700908fc0752af059838b1cfb41960e4e", size = 699006, upload-time = "2024-08-06T20:33:37.501Z" }, + { url = "https://files.pythonhosted.org/packages/82/72/04fcad41ca56491995076630c3ec1e834be241664c0c09a64c9a2589b507/PyYAML-6.0.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:a9f8c2e67970f13b16084e04f134610fd1d374bf477b17ec1599185cf611d725", size = 723577, upload-time = "2024-08-06T20:33:39.389Z" }, + { url = "https://files.pythonhosted.org/packages/ed/5e/46168b1f2757f1fcd442bc3029cd8767d88a98c9c05770d8b420948743bb/PyYAML-6.0.2-cp39-cp39-win32.whl", hash = "sha256:6395c297d42274772abc367baaa79683958044e5d3835486c16da75d2a694631", size = 144593, upload-time = "2024-08-06T20:33:46.63Z" }, + { url = "https://files.pythonhosted.org/packages/19/87/5124b1c1f2412bb95c59ec481eaf936cd32f0fe2a7b16b97b81c4c017a6a/PyYAML-6.0.2-cp39-cp39-win_amd64.whl", hash = "sha256:39693e1f8320ae4f43943590b49779ffb98acb81f788220ea932a6b6c51004d8", size = 162312, upload-time = "2024-08-06T20:33:49.073Z" }, +] + +[[package]] +name = "requests" +version = "2.32.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "charset-normalizer" }, + { name = "idna" }, + { name = "urllib3", version = "1.26.20", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, + { name = "urllib3", version = "2.4.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/63/70/2bf7780ad2d390a8d301ad0b550f1581eadbd9a20f896afe06353c2a2913/requests-2.32.3.tar.gz", hash = "sha256:55365417734eb18255590a9ff9eb97e9e1da868d4ccd6402399eaf68af20a760", size = 131218, upload-time = "2024-05-29T15:37:49.536Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f9/9b/335f9764261e915ed497fcdeb11df5dfd6f7bf257d4a6a2a686d80da4d54/requests-2.32.3-py3-none-any.whl", hash = "sha256:70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6", size = 64928, upload-time = "2024-05-29T15:37:47.027Z" }, +] + +[[package]] +name = "rich" +version = "13.9.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markdown-it-py" }, + { name = "pygments" }, + { name = "typing-extensions", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ab/3a/0316b28d0761c6734d6bc14e770d85506c986c85ffb239e688eeaab2c2bc/rich-13.9.4.tar.gz", hash = "sha256:439594978a49a09530cff7ebc4b5c7103ef57baf48d5ea3184f21d9a2befa098", size = 223149, upload-time = "2024-11-01T16:43:57.873Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/19/71/39c7c0d87f8d4e6c020a393182060eaefeeae6c01dab6a84ec346f2567df/rich-13.9.4-py3-none-any.whl", hash = "sha256:6049d5e6ec054bf2779ab3358186963bac2ea89175919d699e378b99738c2a90", size = 242424, upload-time = "2024-11-01T16:43:55.817Z" }, +] + +[[package]] +name = "ruff" +version = "0.11.12" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/15/0a/92416b159ec00cdf11e5882a9d80d29bf84bba3dbebc51c4898bfbca1da6/ruff-0.11.12.tar.gz", hash = "sha256:43cf7f69c7d7c7d7513b9d59c5d8cafd704e05944f978614aa9faff6ac202603", size = 4202289, upload-time = "2025-05-29T13:31:40.037Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/60/cc/53eb79f012d15e136d40a8e8fc519ba8f55a057f60b29c2df34efd47c6e3/ruff-0.11.12-py3-none-linux_armv6l.whl", hash = "sha256:c7680aa2f0d4c4f43353d1e72123955c7a2159b8646cd43402de6d4a3a25d7cc", size = 10285597, upload-time = "2025-05-29T13:30:57.539Z" }, + { url = "https://files.pythonhosted.org/packages/e7/d7/73386e9fb0232b015a23f62fea7503f96e29c29e6c45461d4a73bac74df9/ruff-0.11.12-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:2cad64843da9f134565c20bcc430642de897b8ea02e2e79e6e02a76b8dcad7c3", size = 11053154, upload-time = "2025-05-29T13:31:00.865Z" }, + { url = "https://files.pythonhosted.org/packages/4e/eb/3eae144c5114e92deb65a0cb2c72326c8469e14991e9bc3ec0349da1331c/ruff-0.11.12-py3-none-macosx_11_0_arm64.whl", hash = "sha256:9b6886b524a1c659cee1758140138455d3c029783d1b9e643f3624a5ee0cb0aa", size = 10403048, upload-time = "2025-05-29T13:31:03.413Z" }, + { url = "https://files.pythonhosted.org/packages/29/64/20c54b20e58b1058db6689e94731f2a22e9f7abab74e1a758dfba058b6ca/ruff-0.11.12-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3cc3a3690aad6e86c1958d3ec3c38c4594b6ecec75c1f531e84160bd827b2012", size = 10597062, upload-time = "2025-05-29T13:31:05.539Z" }, + { url = "https://files.pythonhosted.org/packages/29/3a/79fa6a9a39422a400564ca7233a689a151f1039110f0bbbabcb38106883a/ruff-0.11.12-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f97fdbc2549f456c65b3b0048560d44ddd540db1f27c778a938371424b49fe4a", size = 10155152, upload-time = "2025-05-29T13:31:07.986Z" }, + { url = "https://files.pythonhosted.org/packages/e5/a4/22c2c97b2340aa968af3a39bc38045e78d36abd4ed3fa2bde91c31e712e3/ruff-0.11.12-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:74adf84960236961090e2d1348c1a67d940fd12e811a33fb3d107df61eef8fc7", size = 11723067, upload-time = "2025-05-29T13:31:10.57Z" }, + { url = "https://files.pythonhosted.org/packages/bc/cf/3e452fbd9597bcd8058856ecd42b22751749d07935793a1856d988154151/ruff-0.11.12-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:b56697e5b8bcf1d61293ccfe63873aba08fdbcbbba839fc046ec5926bdb25a3a", size = 12460807, upload-time = "2025-05-29T13:31:12.88Z" }, + { url = "https://files.pythonhosted.org/packages/2f/ec/8f170381a15e1eb7d93cb4feef8d17334d5a1eb33fee273aee5d1f8241a3/ruff-0.11.12-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4d47afa45e7b0eaf5e5969c6b39cbd108be83910b5c74626247e366fd7a36a13", size = 12063261, upload-time = "2025-05-29T13:31:15.236Z" }, + { url = "https://files.pythonhosted.org/packages/0d/bf/57208f8c0a8153a14652a85f4116c0002148e83770d7a41f2e90b52d2b4e/ruff-0.11.12-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:692bf9603fe1bf949de8b09a2da896f05c01ed7a187f4a386cdba6760e7f61be", size = 11329601, upload-time = "2025-05-29T13:31:18.68Z" }, + { url = "https://files.pythonhosted.org/packages/c3/56/edf942f7fdac5888094d9ffa303f12096f1a93eb46570bcf5f14c0c70880/ruff-0.11.12-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:08033320e979df3b20dba567c62f69c45e01df708b0f9c83912d7abd3e0801cd", size = 11522186, upload-time = "2025-05-29T13:31:21.216Z" }, + { url = "https://files.pythonhosted.org/packages/ed/63/79ffef65246911ed7e2290aeece48739d9603b3a35f9529fec0fc6c26400/ruff-0.11.12-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:929b7706584f5bfd61d67d5070f399057d07c70585fa8c4491d78ada452d3bef", size = 10449032, upload-time = "2025-05-29T13:31:23.417Z" }, + { url = "https://files.pythonhosted.org/packages/88/19/8c9d4d8a1c2a3f5a1ea45a64b42593d50e28b8e038f1aafd65d6b43647f3/ruff-0.11.12-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:7de4a73205dc5756b8e09ee3ed67c38312dce1aa28972b93150f5751199981b5", size = 10129370, upload-time = "2025-05-29T13:31:25.777Z" }, + { url = "https://files.pythonhosted.org/packages/bc/0f/2d15533eaa18f460530a857e1778900cd867ded67f16c85723569d54e410/ruff-0.11.12-py3-none-musllinux_1_2_i686.whl", hash = "sha256:2635c2a90ac1b8ca9e93b70af59dfd1dd2026a40e2d6eebaa3efb0465dd9cf02", size = 11123529, upload-time = "2025-05-29T13:31:28.396Z" }, + { url = "https://files.pythonhosted.org/packages/4f/e2/4c2ac669534bdded835356813f48ea33cfb3a947dc47f270038364587088/ruff-0.11.12-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:d05d6a78a89166f03f03a198ecc9d18779076ad0eec476819467acb401028c0c", size = 11577642, upload-time = "2025-05-29T13:31:30.647Z" }, + { url = "https://files.pythonhosted.org/packages/a7/9b/c9ddf7f924d5617a1c94a93ba595f4b24cb5bc50e98b94433ab3f7ad27e5/ruff-0.11.12-py3-none-win32.whl", hash = "sha256:f5a07f49767c4be4772d161bfc049c1f242db0cfe1bd976e0f0886732a4765d6", size = 10475511, upload-time = "2025-05-29T13:31:32.917Z" }, + { url = "https://files.pythonhosted.org/packages/fd/d6/74fb6d3470c1aada019ffff33c0f9210af746cca0a4de19a1f10ce54968a/ruff-0.11.12-py3-none-win_amd64.whl", hash = "sha256:5a4d9f8030d8c3a45df201d7fb3ed38d0219bccd7955268e863ee4a115fa0832", size = 11523573, upload-time = "2025-05-29T13:31:35.782Z" }, + { url = "https://files.pythonhosted.org/packages/44/42/d58086ec20f52d2b0140752ae54b355ea2be2ed46f914231136dd1effcc7/ruff-0.11.12-py3-none-win_arm64.whl", hash = "sha256:65194e37853158d368e333ba282217941029a28ea90913c67e558c611d04daa5", size = 10697770, upload-time = "2025-05-29T13:31:38.009Z" }, +] + +[[package]] +name = "s3transfer" +version = "0.13.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "botocore" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ed/5d/9dcc100abc6711e8247af5aa561fc07c4a046f72f659c3adea9a449e191a/s3transfer-0.13.0.tar.gz", hash = "sha256:f5e6db74eb7776a37208001113ea7aa97695368242b364d73e91c981ac522177", size = 150232, upload-time = "2025-05-22T19:24:50.245Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/18/17/22bf8155aa0ea2305eefa3a6402e040df7ebe512d1310165eda1e233c3f8/s3transfer-0.13.0-py3-none-any.whl", hash = "sha256:0148ef34d6dd964d0d8cf4311b2b21c474693e57c2e069ec708ce043d2b527be", size = 85152, upload-time = "2025-05-22T19:24:48.703Z" }, +] + +[[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 = "sortedcontainers" +version = "2.4.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e8/c4/ba2f8066cceb6f23394729afe52f3bf7adec04bf9ed2c820b39e19299111/sortedcontainers-2.4.0.tar.gz", hash = "sha256:25caa5a06cc30b6b83d11423433f65d1f9d76c4c6a0c90e3379eaa43b9bfdb88", size = 30594, upload-time = "2021-05-16T22:03:42.897Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/32/46/9cb0e58b2deb7f82b84065f37f3bffeb12413f947f9388e4cac22c4621ce/sortedcontainers-2.4.0-py2.py3-none-any.whl", hash = "sha256:a163dcaede0f1c021485e957a39245190e74249897e2ae4b2aa38595db237ee0", size = 29575, upload-time = "2021-05-16T22:03:41.177Z" }, +] + +[[package]] +name = "strictyaml" +version = "1.7.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "python-dateutil" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b3/08/efd28d49162ce89c2ad61a88bd80e11fb77bc9f6c145402589112d38f8af/strictyaml-1.7.3.tar.gz", hash = "sha256:22f854a5fcab42b5ddba8030a0e4be51ca89af0267961c8d6cfa86395586c407", size = 115206, upload-time = "2023-03-10T12:50:27.062Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/96/7c/a81ef5ef10978dd073a854e0fa93b5d8021d0594b639cc8f6453c3c78a1d/strictyaml-1.7.3-py3-none-any.whl", hash = "sha256:fb5c8a4edb43bebb765959e420f9b3978d7f1af88c80606c03fb420888f5d1c7", size = 123917, upload-time = "2023-03-10T12:50:17.242Z" }, +] + +[[package]] +name = "structlog" +version = "25.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ff/6a/b0b6d440e429d2267076c4819300d9929563b1da959cf1f68afbcd69fe45/structlog-25.3.0.tar.gz", hash = "sha256:8dab497e6f6ca962abad0c283c46744185e0c9ba900db52a423cb6db99f7abeb", size = 1367514, upload-time = "2025-04-25T16:00:39.167Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f5/52/7a2c7a317b254af857464da3d60a0d3730c44f912f8c510c76a738a207fd/structlog-25.3.0-py3-none-any.whl", hash = "sha256:a341f5524004c158498c3127eecded091eb67d3a611e7a3093deca30db06e172", size = 68240, upload-time = "2025-04-25T16:00:37.295Z" }, +] + +[[package]] +name = "tenacity" +version = "9.1.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0a/d4/2b0cd0fe285e14b36db076e78c93766ff1d529d70408bd1d2a5a84f1d929/tenacity-9.1.2.tar.gz", hash = "sha256:1169d376c297e7de388d18b4481760d478b0e99a777cad3a9c86e556f4b697cb", size = 48036, upload-time = "2025-04-02T08:25:09.966Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e5/30/643397144bfbfec6f6ef821f36f33e57d35946c44a2352d3c9f0ae847619/tenacity-9.1.2-py3-none-any.whl", hash = "sha256:f77bf36710d8b73a50b2dd155c97b870017ad21afe6ab300326b0371b3b05138", size = 28248, upload-time = "2025-04-02T08:25:07.678Z" }, +] + +[[package]] +name = "tomli" +version = "2.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/18/87/302344fed471e44a87289cf4967697d07e532f2421fdaf868a303cbae4ff/tomli-2.2.1.tar.gz", hash = "sha256:cd45e1dc79c835ce60f7404ec8119f2eb06d38b1deba146f07ced3bbc44505ff", size = 17175, upload-time = "2024-11-27T22:38:36.873Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/43/ca/75707e6efa2b37c77dadb324ae7d9571cb424e61ea73fad7c56c2d14527f/tomli-2.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678e4fa69e4575eb77d103de3df8a895e1591b48e740211bd1067378c69e8249", size = 131077, upload-time = "2024-11-27T22:37:54.956Z" }, + { url = "https://files.pythonhosted.org/packages/c7/16/51ae563a8615d472fdbffc43a3f3d46588c264ac4f024f63f01283becfbb/tomli-2.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:023aa114dd824ade0100497eb2318602af309e5a55595f76b626d6d9f3b7b0a6", size = 123429, upload-time = "2024-11-27T22:37:56.698Z" }, + { url = "https://files.pythonhosted.org/packages/f1/dd/4f6cd1e7b160041db83c694abc78e100473c15d54620083dbd5aae7b990e/tomli-2.2.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ece47d672db52ac607a3d9599a9d48dcb2f2f735c6c2d1f34130085bb12b112a", size = 226067, upload-time = "2024-11-27T22:37:57.63Z" }, + { url = "https://files.pythonhosted.org/packages/a9/6b/c54ede5dc70d648cc6361eaf429304b02f2871a345bbdd51e993d6cdf550/tomli-2.2.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6972ca9c9cc9f0acaa56a8ca1ff51e7af152a9f87fb64623e31d5c83700080ee", size = 236030, upload-time = "2024-11-27T22:37:59.344Z" }, + { url = "https://files.pythonhosted.org/packages/1f/47/999514fa49cfaf7a92c805a86c3c43f4215621855d151b61c602abb38091/tomli-2.2.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c954d2250168d28797dd4e3ac5cf812a406cd5a92674ee4c8f123c889786aa8e", size = 240898, upload-time = "2024-11-27T22:38:00.429Z" }, + { url = "https://files.pythonhosted.org/packages/73/41/0a01279a7ae09ee1573b423318e7934674ce06eb33f50936655071d81a24/tomli-2.2.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8dd28b3e155b80f4d54beb40a441d366adcfe740969820caf156c019fb5c7ec4", size = 229894, upload-time = "2024-11-27T22:38:02.094Z" }, + { url = "https://files.pythonhosted.org/packages/55/18/5d8bc5b0a0362311ce4d18830a5d28943667599a60d20118074ea1b01bb7/tomli-2.2.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:e59e304978767a54663af13c07b3d1af22ddee3bb2fb0618ca1593e4f593a106", size = 245319, upload-time = "2024-11-27T22:38:03.206Z" }, + { url = "https://files.pythonhosted.org/packages/92/a3/7ade0576d17f3cdf5ff44d61390d4b3febb8a9fc2b480c75c47ea048c646/tomli-2.2.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:33580bccab0338d00994d7f16f4c4ec25b776af3ffaac1ed74e0b3fc95e885a8", size = 238273, upload-time = "2024-11-27T22:38:04.217Z" }, + { url = "https://files.pythonhosted.org/packages/72/6f/fa64ef058ac1446a1e51110c375339b3ec6be245af9d14c87c4a6412dd32/tomli-2.2.1-cp311-cp311-win32.whl", hash = "sha256:465af0e0875402f1d226519c9904f37254b3045fc5084697cefb9bdde1ff99ff", size = 98310, upload-time = "2024-11-27T22:38:05.908Z" }, + { url = "https://files.pythonhosted.org/packages/6a/1c/4a2dcde4a51b81be3530565e92eda625d94dafb46dbeb15069df4caffc34/tomli-2.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:2d0f2fdd22b02c6d81637a3c95f8cd77f995846af7414c5c4b8d0545afa1bc4b", size = 108309, upload-time = "2024-11-27T22:38:06.812Z" }, + { url = "https://files.pythonhosted.org/packages/52/e1/f8af4c2fcde17500422858155aeb0d7e93477a0d59a98e56cbfe75070fd0/tomli-2.2.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4a8f6e44de52d5e6c657c9fe83b562f5f4256d8ebbfe4ff922c495620a7f6cea", size = 132762, upload-time = "2024-11-27T22:38:07.731Z" }, + { url = "https://files.pythonhosted.org/packages/03/b8/152c68bb84fc00396b83e7bbddd5ec0bd3dd409db4195e2a9b3e398ad2e3/tomli-2.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8d57ca8095a641b8237d5b079147646153d22552f1c637fd3ba7f4b0b29167a8", size = 123453, upload-time = "2024-11-27T22:38:09.384Z" }, + { url = "https://files.pythonhosted.org/packages/c8/d6/fc9267af9166f79ac528ff7e8c55c8181ded34eb4b0e93daa767b8841573/tomli-2.2.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4e340144ad7ae1533cb897d406382b4b6fede8890a03738ff1683af800d54192", size = 233486, upload-time = "2024-11-27T22:38:10.329Z" }, + { url = "https://files.pythonhosted.org/packages/5c/51/51c3f2884d7bab89af25f678447ea7d297b53b5a3b5730a7cb2ef6069f07/tomli-2.2.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:db2b95f9de79181805df90bedc5a5ab4c165e6ec3fe99f970d0e302f384ad222", size = 242349, upload-time = "2024-11-27T22:38:11.443Z" }, + { url = "https://files.pythonhosted.org/packages/ab/df/bfa89627d13a5cc22402e441e8a931ef2108403db390ff3345c05253935e/tomli-2.2.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:40741994320b232529c802f8bc86da4e1aa9f413db394617b9a256ae0f9a7f77", size = 252159, upload-time = "2024-11-27T22:38:13.099Z" }, + { url = "https://files.pythonhosted.org/packages/9e/6e/fa2b916dced65763a5168c6ccb91066f7639bdc88b48adda990db10c8c0b/tomli-2.2.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:400e720fe168c0f8521520190686ef8ef033fb19fc493da09779e592861b78c6", size = 237243, upload-time = "2024-11-27T22:38:14.766Z" }, + { url = "https://files.pythonhosted.org/packages/b4/04/885d3b1f650e1153cbb93a6a9782c58a972b94ea4483ae4ac5cedd5e4a09/tomli-2.2.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:02abe224de6ae62c19f090f68da4e27b10af2b93213d36cf44e6e1c5abd19fdd", size = 259645, upload-time = "2024-11-27T22:38:15.843Z" }, + { url = "https://files.pythonhosted.org/packages/9c/de/6b432d66e986e501586da298e28ebeefd3edc2c780f3ad73d22566034239/tomli-2.2.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b82ebccc8c8a36f2094e969560a1b836758481f3dc360ce9a3277c65f374285e", size = 244584, upload-time = "2024-11-27T22:38:17.645Z" }, + { url = "https://files.pythonhosted.org/packages/1c/9a/47c0449b98e6e7d1be6cbac02f93dd79003234ddc4aaab6ba07a9a7482e2/tomli-2.2.1-cp312-cp312-win32.whl", hash = "sha256:889f80ef92701b9dbb224e49ec87c645ce5df3fa2cc548664eb8a25e03127a98", size = 98875, upload-time = "2024-11-27T22:38:19.159Z" }, + { url = "https://files.pythonhosted.org/packages/ef/60/9b9638f081c6f1261e2688bd487625cd1e660d0a85bd469e91d8db969734/tomli-2.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:7fc04e92e1d624a4a63c76474610238576942d6b8950a2d7f908a340494e67e4", size = 109418, upload-time = "2024-11-27T22:38:20.064Z" }, + { url = "https://files.pythonhosted.org/packages/04/90/2ee5f2e0362cb8a0b6499dc44f4d7d48f8fff06d28ba46e6f1eaa61a1388/tomli-2.2.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f4039b9cbc3048b2416cc57ab3bda989a6fcf9b36cf8937f01a6e731b64f80d7", size = 132708, upload-time = "2024-11-27T22:38:21.659Z" }, + { url = "https://files.pythonhosted.org/packages/c0/ec/46b4108816de6b385141f082ba99e315501ccd0a2ea23db4a100dd3990ea/tomli-2.2.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:286f0ca2ffeeb5b9bd4fcc8d6c330534323ec51b2f52da063b11c502da16f30c", size = 123582, upload-time = "2024-11-27T22:38:22.693Z" }, + { url = "https://files.pythonhosted.org/packages/a0/bd/b470466d0137b37b68d24556c38a0cc819e8febe392d5b199dcd7f578365/tomli-2.2.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a92ef1a44547e894e2a17d24e7557a5e85a9e1d0048b0b5e7541f76c5032cb13", size = 232543, upload-time = "2024-11-27T22:38:24.367Z" }, + { url = "https://files.pythonhosted.org/packages/d9/e5/82e80ff3b751373f7cead2815bcbe2d51c895b3c990686741a8e56ec42ab/tomli-2.2.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9316dc65bed1684c9a98ee68759ceaed29d229e985297003e494aa825ebb0281", size = 241691, upload-time = "2024-11-27T22:38:26.081Z" }, + { url = "https://files.pythonhosted.org/packages/05/7e/2a110bc2713557d6a1bfb06af23dd01e7dde52b6ee7dadc589868f9abfac/tomli-2.2.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e85e99945e688e32d5a35c1ff38ed0b3f41f43fad8df0bdf79f72b2ba7bc5272", size = 251170, upload-time = "2024-11-27T22:38:27.921Z" }, + { url = "https://files.pythonhosted.org/packages/64/7b/22d713946efe00e0adbcdfd6d1aa119ae03fd0b60ebed51ebb3fa9f5a2e5/tomli-2.2.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ac065718db92ca818f8d6141b5f66369833d4a80a9d74435a268c52bdfa73140", size = 236530, upload-time = "2024-11-27T22:38:29.591Z" }, + { url = "https://files.pythonhosted.org/packages/38/31/3a76f67da4b0cf37b742ca76beaf819dca0ebef26d78fc794a576e08accf/tomli-2.2.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:d920f33822747519673ee656a4b6ac33e382eca9d331c87770faa3eef562aeb2", size = 258666, upload-time = "2024-11-27T22:38:30.639Z" }, + { url = "https://files.pythonhosted.org/packages/07/10/5af1293da642aded87e8a988753945d0cf7e00a9452d3911dd3bb354c9e2/tomli-2.2.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a198f10c4d1b1375d7687bc25294306e551bf1abfa4eace6650070a5c1ae2744", size = 243954, upload-time = "2024-11-27T22:38:31.702Z" }, + { url = "https://files.pythonhosted.org/packages/5b/b9/1ed31d167be802da0fc95020d04cd27b7d7065cc6fbefdd2f9186f60d7bd/tomli-2.2.1-cp313-cp313-win32.whl", hash = "sha256:d3f5614314d758649ab2ab3a62d4f2004c825922f9e370b29416484086b264ec", size = 98724, upload-time = "2024-11-27T22:38:32.837Z" }, + { url = "https://files.pythonhosted.org/packages/c7/32/b0963458706accd9afcfeb867c0f9175a741bf7b19cd424230714d722198/tomli-2.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:a38aa0308e754b0e3c67e344754dff64999ff9b513e691d0e786265c93583c69", size = 109383, upload-time = "2024-11-27T22:38:34.455Z" }, + { url = "https://files.pythonhosted.org/packages/6e/c2/61d3e0f47e2b74ef40a68b9e6ad5984f6241a942f7cd3bbfbdbd03861ea9/tomli-2.2.1-py3-none-any.whl", hash = "sha256:cb55c73c5f4408779d0cf3eef9f762b9c9f147a77de7b258bef0a5628adc85cc", size = 14257, upload-time = "2024-11-27T22:38:35.385Z" }, +] + +[[package]] +name = "typing-extensions" +version = "4.13.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f6/37/23083fcd6e35492953e8d2aaaa68b860eb422b34627b13f2ce3eb6106061/typing_extensions-4.13.2.tar.gz", hash = "sha256:e6c81219bd689f51865d9e372991c540bda33a0379d5573cddb9a3a23f7caaef", size = 106967, upload-time = "2025-04-10T14:19:05.416Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8b/54/b1ae86c0973cc6f0210b53d508ca3641fb6d0c56823f288d108bc7ab3cc8/typing_extensions-4.13.2-py3-none-any.whl", hash = "sha256:a439e7c04b49fec3e5d3e2beaa21755cadbbdc391694e28ccdd36ca4a1408f8c", size = 45806, upload-time = "2025-04-10T14:19:03.967Z" }, +] + +[[package]] +name = "typing-inspection" +version = "0.4.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f8/b1/0c11f5058406b3af7609f121aaa6b609744687f1d158b3c3a5bf4cc94238/typing_inspection-0.4.1.tar.gz", hash = "sha256:6ae134cc0203c33377d43188d4064e9b357dba58cff3185f22924610e70a9d28", size = 75726, upload-time = "2025-05-21T18:55:23.885Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/17/69/cd203477f944c353c31bade965f880aa1061fd6bf05ded0726ca845b6ff7/typing_inspection-0.4.1-py3-none-any.whl", hash = "sha256:389055682238f53b04f7badcb49b989835495a96700ced5dab2d8feae4b26f51", size = 14552, upload-time = "2025-05-21T18:55:22.152Z" }, +] + +[[package]] +name = "tzdata" +version = "2025.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/95/32/1a225d6164441be760d75c2c42e2780dc0873fe382da3e98a2e1e48361e5/tzdata-2025.2.tar.gz", hash = "sha256:b60a638fcc0daffadf82fe0f57e53d06bdec2f36c4df66280ae79bce6bd6f2b9", size = 196380, upload-time = "2025-03-23T13:54:43.652Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5c/23/c7abc0ca0a1526a0774eca151daeb8de62ec457e77262b66b359c3c7679e/tzdata-2025.2-py2.py3-none-any.whl", hash = "sha256:1a403fada01ff9221ca8044d701868fa132215d84beb92242d9acd2147f667a8", size = 347839, upload-time = "2025-03-23T13:54:41.845Z" }, +] + +[[package]] +name = "urllib3" +version = "1.26.20" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.10'", +] +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 = "urllib3" +version = "2.4.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version == '3.10.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/8a/78/16493d9c386d8e60e442a35feac5e00f0913c0f4b7c217c11e8ec2ff53e0/urllib3-2.4.0.tar.gz", hash = "sha256:414bc6535b787febd7567804cc015fee39daab8ad86268f1310a9250697de466", size = 390672, upload-time = "2025-04-10T15:23:39.232Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6b/11/cc635220681e93a0183390e26485430ca2c7b5f9d33b15c74c2861cb8091/urllib3-2.4.0-py3-none-any.whl", hash = "sha256:4e16665048960a0900c702d4a66415956a584919c03361cac9f1df5c5dd7e813", size = 128680, upload-time = "2025-04-10T15:23:37.377Z" }, +] + +[[package]] +name = "xatu-exporter" +version = "0.1.0" +source = { editable = "." } +dependencies = [ + { name = "boto3" }, + { name = "click", version = "8.1.8", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, + { name = "click", version = "8.2.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, + { name = "clickhouse-connect" }, + { name = "pandas" }, + { name = "pyarrow" }, + { name = "pyiceberg" }, + { name = "pyyaml" }, + { name = "structlog" }, +] + +[package.optional-dependencies] +dev = [ + { name = "black" }, + { name = "mypy" }, + { name = "pytest" }, + { name = "pytest-mock" }, + { name = "ruff" }, +] + +[package.metadata] +requires-dist = [ + { name = "black", marker = "extra == 'dev'", specifier = ">=23.0.0" }, + { name = "boto3", specifier = ">=1.26.0" }, + { name = "click", specifier = ">=8.1.0" }, + { name = "clickhouse-connect", specifier = ">=0.7.0" }, + { name = "mypy", marker = "extra == 'dev'", specifier = ">=1.0.0" }, + { name = "pandas", specifier = ">=2.0.0" }, + { name = "pyarrow", specifier = ">=14.0.0" }, + { name = "pyiceberg", specifier = ">=0.6.0" }, + { name = "pytest", marker = "extra == 'dev'", specifier = ">=7.0.0" }, + { name = "pytest-mock", marker = "extra == 'dev'", specifier = ">=3.10.0" }, + { name = "pyyaml", specifier = ">=6.0" }, + { name = "ruff", marker = "extra == 'dev'", specifier = ">=0.1.0" }, + { name = "structlog", specifier = ">=23.1.0" }, +] +provides-extras = ["dev"] + +[[package]] +name = "zstandard" +version = "0.23.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi", marker = "platform_python_implementation == 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ed/f6/2ac0287b442160a89d726b17a9184a4c615bb5237db763791a7fd16d9df1/zstandard-0.23.0.tar.gz", hash = "sha256:b2d8c62d08e7255f68f7a740bae85b3c9b8e5466baa9cbf7f57f1cde0ac6bc09", size = 681701, upload-time = "2024-07-15T00:18:06.141Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2a/55/bd0487e86679db1823fc9ee0d8c9c78ae2413d34c0b461193b5f4c31d22f/zstandard-0.23.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:bf0a05b6059c0528477fba9054d09179beb63744355cab9f38059548fedd46a9", size = 788701, upload-time = "2024-07-15T00:13:27.351Z" }, + { url = "https://files.pythonhosted.org/packages/e1/8a/ccb516b684f3ad987dfee27570d635822e3038645b1a950c5e8022df1145/zstandard-0.23.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:fc9ca1c9718cb3b06634c7c8dec57d24e9438b2aa9a0f02b8bb36bf478538880", size = 633678, upload-time = "2024-07-15T00:13:30.24Z" }, + { url = "https://files.pythonhosted.org/packages/12/89/75e633d0611c028e0d9af6df199423bf43f54bea5007e6718ab7132e234c/zstandard-0.23.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:77da4c6bfa20dd5ea25cbf12c76f181a8e8cd7ea231c673828d0386b1740b8dc", size = 4941098, upload-time = "2024-07-15T00:13:32.526Z" }, + { url = "https://files.pythonhosted.org/packages/4a/7a/bd7f6a21802de358b63f1ee636ab823711c25ce043a3e9f043b4fcb5ba32/zstandard-0.23.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b2170c7e0367dde86a2647ed5b6f57394ea7f53545746104c6b09fc1f4223573", size = 5308798, upload-time = "2024-07-15T00:13:34.925Z" }, + { url = "https://files.pythonhosted.org/packages/79/3b/775f851a4a65013e88ca559c8ae42ac1352db6fcd96b028d0df4d7d1d7b4/zstandard-0.23.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c16842b846a8d2a145223f520b7e18b57c8f476924bda92aeee3a88d11cfc391", size = 5341840, upload-time = "2024-07-15T00:13:37.376Z" }, + { url = "https://files.pythonhosted.org/packages/09/4f/0cc49570141dd72d4d95dd6fcf09328d1b702c47a6ec12fbed3b8aed18a5/zstandard-0.23.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:157e89ceb4054029a289fb504c98c6a9fe8010f1680de0201b3eb5dc20aa6d9e", size = 5440337, upload-time = "2024-07-15T00:13:39.772Z" }, + { url = "https://files.pythonhosted.org/packages/e7/7c/aaa7cd27148bae2dc095191529c0570d16058c54c4597a7d118de4b21676/zstandard-0.23.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:203d236f4c94cd8379d1ea61db2fce20730b4c38d7f1c34506a31b34edc87bdd", size = 4861182, upload-time = "2024-07-15T00:13:42.495Z" }, + { url = "https://files.pythonhosted.org/packages/ac/eb/4b58b5c071d177f7dc027129d20bd2a44161faca6592a67f8fcb0b88b3ae/zstandard-0.23.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:dc5d1a49d3f8262be192589a4b72f0d03b72dcf46c51ad5852a4fdc67be7b9e4", size = 4932936, upload-time = "2024-07-15T00:13:44.234Z" }, + { url = "https://files.pythonhosted.org/packages/44/f9/21a5fb9bb7c9a274b05ad700a82ad22ce82f7ef0f485980a1e98ed6e8c5f/zstandard-0.23.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:752bf8a74412b9892f4e5b58f2f890a039f57037f52c89a740757ebd807f33ea", size = 5464705, upload-time = "2024-07-15T00:13:46.822Z" }, + { url = "https://files.pythonhosted.org/packages/49/74/b7b3e61db3f88632776b78b1db597af3f44c91ce17d533e14a25ce6a2816/zstandard-0.23.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:80080816b4f52a9d886e67f1f96912891074903238fe54f2de8b786f86baded2", size = 4857882, upload-time = "2024-07-15T00:13:49.297Z" }, + { url = "https://files.pythonhosted.org/packages/4a/7f/d8eb1cb123d8e4c541d4465167080bec88481ab54cd0b31eb4013ba04b95/zstandard-0.23.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:84433dddea68571a6d6bd4fbf8ff398236031149116a7fff6f777ff95cad3df9", size = 4697672, upload-time = "2024-07-15T00:13:51.447Z" }, + { url = "https://files.pythonhosted.org/packages/5e/05/f7dccdf3d121309b60342da454d3e706453a31073e2c4dac8e1581861e44/zstandard-0.23.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:ab19a2d91963ed9e42b4e8d77cd847ae8381576585bad79dbd0a8837a9f6620a", size = 5206043, upload-time = "2024-07-15T00:13:53.587Z" }, + { url = "https://files.pythonhosted.org/packages/86/9d/3677a02e172dccd8dd3a941307621c0cbd7691d77cb435ac3c75ab6a3105/zstandard-0.23.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:59556bf80a7094d0cfb9f5e50bb2db27fefb75d5138bb16fb052b61b0e0eeeb0", size = 5667390, upload-time = "2024-07-15T00:13:56.137Z" }, + { url = "https://files.pythonhosted.org/packages/41/7e/0012a02458e74a7ba122cd9cafe491facc602c9a17f590367da369929498/zstandard-0.23.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:27d3ef2252d2e62476389ca8f9b0cf2bbafb082a3b6bfe9d90cbcbb5529ecf7c", size = 5198901, upload-time = "2024-07-15T00:13:58.584Z" }, + { url = "https://files.pythonhosted.org/packages/65/3a/8f715b97bd7bcfc7342d8adcd99a026cb2fb550e44866a3b6c348e1b0f02/zstandard-0.23.0-cp310-cp310-win32.whl", hash = "sha256:5d41d5e025f1e0bccae4928981e71b2334c60f580bdc8345f824e7c0a4c2a813", size = 430596, upload-time = "2024-07-15T00:14:00.693Z" }, + { url = "https://files.pythonhosted.org/packages/19/b7/b2b9eca5e5a01111e4fe8a8ffb56bdcdf56b12448a24effe6cfe4a252034/zstandard-0.23.0-cp310-cp310-win_amd64.whl", hash = "sha256:519fbf169dfac1222a76ba8861ef4ac7f0530c35dd79ba5727014613f91613d4", size = 495498, upload-time = "2024-07-15T00:14:02.741Z" }, + { url = "https://files.pythonhosted.org/packages/9e/40/f67e7d2c25a0e2dc1744dd781110b0b60306657f8696cafb7ad7579469bd/zstandard-0.23.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:34895a41273ad33347b2fc70e1bff4240556de3c46c6ea430a7ed91f9042aa4e", size = 788699, upload-time = "2024-07-15T00:14:04.909Z" }, + { url = "https://files.pythonhosted.org/packages/e8/46/66d5b55f4d737dd6ab75851b224abf0afe5774976fe511a54d2eb9063a41/zstandard-0.23.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:77ea385f7dd5b5676d7fd943292ffa18fbf5c72ba98f7d09fc1fb9e819b34c23", size = 633681, upload-time = "2024-07-15T00:14:13.99Z" }, + { url = "https://files.pythonhosted.org/packages/63/b6/677e65c095d8e12b66b8f862b069bcf1f1d781b9c9c6f12eb55000d57583/zstandard-0.23.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:983b6efd649723474f29ed42e1467f90a35a74793437d0bc64a5bf482bedfa0a", size = 4944328, upload-time = "2024-07-15T00:14:16.588Z" }, + { url = "https://files.pythonhosted.org/packages/59/cc/e76acb4c42afa05a9d20827116d1f9287e9c32b7ad58cc3af0721ce2b481/zstandard-0.23.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:80a539906390591dd39ebb8d773771dc4db82ace6372c4d41e2d293f8e32b8db", size = 5311955, upload-time = "2024-07-15T00:14:19.389Z" }, + { url = "https://files.pythonhosted.org/packages/78/e4/644b8075f18fc7f632130c32e8f36f6dc1b93065bf2dd87f03223b187f26/zstandard-0.23.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:445e4cb5048b04e90ce96a79b4b63140e3f4ab5f662321975679b5f6360b90e2", size = 5344944, upload-time = "2024-07-15T00:14:22.173Z" }, + { url = "https://files.pythonhosted.org/packages/76/3f/dbafccf19cfeca25bbabf6f2dd81796b7218f768ec400f043edc767015a6/zstandard-0.23.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd30d9c67d13d891f2360b2a120186729c111238ac63b43dbd37a5a40670b8ca", size = 5442927, upload-time = "2024-07-15T00:14:24.825Z" }, + { url = "https://files.pythonhosted.org/packages/0c/c3/d24a01a19b6733b9f218e94d1a87c477d523237e07f94899e1c10f6fd06c/zstandard-0.23.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d20fd853fbb5807c8e84c136c278827b6167ded66c72ec6f9a14b863d809211c", size = 4864910, upload-time = "2024-07-15T00:14:26.982Z" }, + { url = "https://files.pythonhosted.org/packages/1c/a9/cf8f78ead4597264f7618d0875be01f9bc23c9d1d11afb6d225b867cb423/zstandard-0.23.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:ed1708dbf4d2e3a1c5c69110ba2b4eb6678262028afd6c6fbcc5a8dac9cda68e", size = 4935544, upload-time = "2024-07-15T00:14:29.582Z" }, + { url = "https://files.pythonhosted.org/packages/2c/96/8af1e3731b67965fb995a940c04a2c20997a7b3b14826b9d1301cf160879/zstandard-0.23.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:be9b5b8659dff1f913039c2feee1aca499cfbc19e98fa12bc85e037c17ec6ca5", size = 5467094, upload-time = "2024-07-15T00:14:40.126Z" }, + { url = "https://files.pythonhosted.org/packages/ff/57/43ea9df642c636cb79f88a13ab07d92d88d3bfe3e550b55a25a07a26d878/zstandard-0.23.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:65308f4b4890aa12d9b6ad9f2844b7ee42c7f7a4fd3390425b242ffc57498f48", size = 4860440, upload-time = "2024-07-15T00:14:42.786Z" }, + { url = "https://files.pythonhosted.org/packages/46/37/edb78f33c7f44f806525f27baa300341918fd4c4af9472fbc2c3094be2e8/zstandard-0.23.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:98da17ce9cbf3bfe4617e836d561e433f871129e3a7ac16d6ef4c680f13a839c", size = 4700091, upload-time = "2024-07-15T00:14:45.184Z" }, + { url = "https://files.pythonhosted.org/packages/c1/f1/454ac3962671a754f3cb49242472df5c2cced4eb959ae203a377b45b1a3c/zstandard-0.23.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:8ed7d27cb56b3e058d3cf684d7200703bcae623e1dcc06ed1e18ecda39fee003", size = 5208682, upload-time = "2024-07-15T00:14:47.407Z" }, + { url = "https://files.pythonhosted.org/packages/85/b2/1734b0fff1634390b1b887202d557d2dd542de84a4c155c258cf75da4773/zstandard-0.23.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:b69bb4f51daf461b15e7b3db033160937d3ff88303a7bc808c67bbc1eaf98c78", size = 5669707, upload-time = "2024-07-15T00:15:03.529Z" }, + { url = "https://files.pythonhosted.org/packages/52/5a/87d6971f0997c4b9b09c495bf92189fb63de86a83cadc4977dc19735f652/zstandard-0.23.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:034b88913ecc1b097f528e42b539453fa82c3557e414b3de9d5632c80439a473", size = 5201792, upload-time = "2024-07-15T00:15:28.372Z" }, + { url = "https://files.pythonhosted.org/packages/79/02/6f6a42cc84459d399bd1a4e1adfc78d4dfe45e56d05b072008d10040e13b/zstandard-0.23.0-cp311-cp311-win32.whl", hash = "sha256:f2d4380bf5f62daabd7b751ea2339c1a21d1c9463f1feb7fc2bdcea2c29c3160", size = 430586, upload-time = "2024-07-15T00:15:32.26Z" }, + { url = "https://files.pythonhosted.org/packages/be/a2/4272175d47c623ff78196f3c10e9dc7045c1b9caf3735bf041e65271eca4/zstandard-0.23.0-cp311-cp311-win_amd64.whl", hash = "sha256:62136da96a973bd2557f06ddd4e8e807f9e13cbb0bfb9cc06cfe6d98ea90dfe0", size = 495420, upload-time = "2024-07-15T00:15:34.004Z" }, + { url = "https://files.pythonhosted.org/packages/7b/83/f23338c963bd9de687d47bf32efe9fd30164e722ba27fb59df33e6b1719b/zstandard-0.23.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:b4567955a6bc1b20e9c31612e615af6b53733491aeaa19a6b3b37f3b65477094", size = 788713, upload-time = "2024-07-15T00:15:35.815Z" }, + { url = "https://files.pythonhosted.org/packages/5b/b3/1a028f6750fd9227ee0b937a278a434ab7f7fdc3066c3173f64366fe2466/zstandard-0.23.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1e172f57cd78c20f13a3415cc8dfe24bf388614324d25539146594c16d78fcc8", size = 633459, upload-time = "2024-07-15T00:15:37.995Z" }, + { url = "https://files.pythonhosted.org/packages/26/af/36d89aae0c1f95a0a98e50711bc5d92c144939efc1f81a2fcd3e78d7f4c1/zstandard-0.23.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b0e166f698c5a3e914947388c162be2583e0c638a4703fc6a543e23a88dea3c1", size = 4945707, upload-time = "2024-07-15T00:15:39.872Z" }, + { url = "https://files.pythonhosted.org/packages/cd/2e/2051f5c772f4dfc0aae3741d5fc72c3dcfe3aaeb461cc231668a4db1ce14/zstandard-0.23.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:12a289832e520c6bd4dcaad68e944b86da3bad0d339ef7989fb7e88f92e96072", size = 5306545, upload-time = "2024-07-15T00:15:41.75Z" }, + { url = "https://files.pythonhosted.org/packages/0a/9e/a11c97b087f89cab030fa71206963090d2fecd8eb83e67bb8f3ffb84c024/zstandard-0.23.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d50d31bfedd53a928fed6707b15a8dbeef011bb6366297cc435accc888b27c20", size = 5337533, upload-time = "2024-07-15T00:15:44.114Z" }, + { url = "https://files.pythonhosted.org/packages/fc/79/edeb217c57fe1bf16d890aa91a1c2c96b28c07b46afed54a5dcf310c3f6f/zstandard-0.23.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:72c68dda124a1a138340fb62fa21b9bf4848437d9ca60bd35db36f2d3345f373", size = 5436510, upload-time = "2024-07-15T00:15:46.509Z" }, + { url = "https://files.pythonhosted.org/packages/81/4f/c21383d97cb7a422ddf1ae824b53ce4b51063d0eeb2afa757eb40804a8ef/zstandard-0.23.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:53dd9d5e3d29f95acd5de6802e909ada8d8d8cfa37a3ac64836f3bc4bc5512db", size = 4859973, upload-time = "2024-07-15T00:15:49.939Z" }, + { url = "https://files.pythonhosted.org/packages/ab/15/08d22e87753304405ccac8be2493a495f529edd81d39a0870621462276ef/zstandard-0.23.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:6a41c120c3dbc0d81a8e8adc73312d668cd34acd7725f036992b1b72d22c1772", size = 4936968, upload-time = "2024-07-15T00:15:52.025Z" }, + { url = "https://files.pythonhosted.org/packages/eb/fa/f3670a597949fe7dcf38119a39f7da49a8a84a6f0b1a2e46b2f71a0ab83f/zstandard-0.23.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:40b33d93c6eddf02d2c19f5773196068d875c41ca25730e8288e9b672897c105", size = 5467179, upload-time = "2024-07-15T00:15:54.971Z" }, + { url = "https://files.pythonhosted.org/packages/4e/a9/dad2ab22020211e380adc477a1dbf9f109b1f8d94c614944843e20dc2a99/zstandard-0.23.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:9206649ec587e6b02bd124fb7799b86cddec350f6f6c14bc82a2b70183e708ba", size = 4848577, upload-time = "2024-07-15T00:15:57.634Z" }, + { url = "https://files.pythonhosted.org/packages/08/03/dd28b4484b0770f1e23478413e01bee476ae8227bbc81561f9c329e12564/zstandard-0.23.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:76e79bc28a65f467e0409098fa2c4376931fd3207fbeb6b956c7c476d53746dd", size = 4693899, upload-time = "2024-07-15T00:16:00.811Z" }, + { url = "https://files.pythonhosted.org/packages/2b/64/3da7497eb635d025841e958bcd66a86117ae320c3b14b0ae86e9e8627518/zstandard-0.23.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:66b689c107857eceabf2cf3d3fc699c3c0fe8ccd18df2219d978c0283e4c508a", size = 5199964, upload-time = "2024-07-15T00:16:03.669Z" }, + { url = "https://files.pythonhosted.org/packages/43/a4/d82decbab158a0e8a6ebb7fc98bc4d903266bce85b6e9aaedea1d288338c/zstandard-0.23.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:9c236e635582742fee16603042553d276cca506e824fa2e6489db04039521e90", size = 5655398, upload-time = "2024-07-15T00:16:06.694Z" }, + { url = "https://files.pythonhosted.org/packages/f2/61/ac78a1263bc83a5cf29e7458b77a568eda5a8f81980691bbc6eb6a0d45cc/zstandard-0.23.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a8fffdbd9d1408006baaf02f1068d7dd1f016c6bcb7538682622c556e7b68e35", size = 5191313, upload-time = "2024-07-15T00:16:09.758Z" }, + { url = "https://files.pythonhosted.org/packages/e7/54/967c478314e16af5baf849b6ee9d6ea724ae5b100eb506011f045d3d4e16/zstandard-0.23.0-cp312-cp312-win32.whl", hash = "sha256:dc1d33abb8a0d754ea4763bad944fd965d3d95b5baef6b121c0c9013eaf1907d", size = 430877, upload-time = "2024-07-15T00:16:11.758Z" }, + { url = "https://files.pythonhosted.org/packages/75/37/872d74bd7739639c4553bf94c84af7d54d8211b626b352bc57f0fd8d1e3f/zstandard-0.23.0-cp312-cp312-win_amd64.whl", hash = "sha256:64585e1dba664dc67c7cdabd56c1e5685233fbb1fc1966cfba2a340ec0dfff7b", size = 495595, upload-time = "2024-07-15T00:16:13.731Z" }, + { url = "https://files.pythonhosted.org/packages/80/f1/8386f3f7c10261fe85fbc2c012fdb3d4db793b921c9abcc995d8da1b7a80/zstandard-0.23.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:576856e8594e6649aee06ddbfc738fec6a834f7c85bf7cadd1c53d4a58186ef9", size = 788975, upload-time = "2024-07-15T00:16:16.005Z" }, + { url = "https://files.pythonhosted.org/packages/16/e8/cbf01077550b3e5dc86089035ff8f6fbbb312bc0983757c2d1117ebba242/zstandard-0.23.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:38302b78a850ff82656beaddeb0bb989a0322a8bbb1bf1ab10c17506681d772a", size = 633448, upload-time = "2024-07-15T00:16:17.897Z" }, + { url = "https://files.pythonhosted.org/packages/06/27/4a1b4c267c29a464a161aeb2589aff212b4db653a1d96bffe3598f3f0d22/zstandard-0.23.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d2240ddc86b74966c34554c49d00eaafa8200a18d3a5b6ffbf7da63b11d74ee2", size = 4945269, upload-time = "2024-07-15T00:16:20.136Z" }, + { url = "https://files.pythonhosted.org/packages/7c/64/d99261cc57afd9ae65b707e38045ed8269fbdae73544fd2e4a4d50d0ed83/zstandard-0.23.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:2ef230a8fd217a2015bc91b74f6b3b7d6522ba48be29ad4ea0ca3a3775bf7dd5", size = 5306228, upload-time = "2024-07-15T00:16:23.398Z" }, + { url = "https://files.pythonhosted.org/packages/7a/cf/27b74c6f22541f0263016a0fd6369b1b7818941de639215c84e4e94b2a1c/zstandard-0.23.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:774d45b1fac1461f48698a9d4b5fa19a69d47ece02fa469825b442263f04021f", size = 5336891, upload-time = "2024-07-15T00:16:26.391Z" }, + { url = "https://files.pythonhosted.org/packages/fa/18/89ac62eac46b69948bf35fcd90d37103f38722968e2981f752d69081ec4d/zstandard-0.23.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6f77fa49079891a4aab203d0b1744acc85577ed16d767b52fc089d83faf8d8ed", size = 5436310, upload-time = "2024-07-15T00:16:29.018Z" }, + { url = "https://files.pythonhosted.org/packages/a8/a8/5ca5328ee568a873f5118d5b5f70d1f36c6387716efe2e369010289a5738/zstandard-0.23.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ac184f87ff521f4840e6ea0b10c0ec90c6b1dcd0bad2f1e4a9a1b4fa177982ea", size = 4859912, upload-time = "2024-07-15T00:16:31.871Z" }, + { url = "https://files.pythonhosted.org/packages/ea/ca/3781059c95fd0868658b1cf0440edd832b942f84ae60685d0cfdb808bca1/zstandard-0.23.0-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:c363b53e257246a954ebc7c488304b5592b9c53fbe74d03bc1c64dda153fb847", size = 4936946, upload-time = "2024-07-15T00:16:34.593Z" }, + { url = "https://files.pythonhosted.org/packages/ce/11/41a58986f809532742c2b832c53b74ba0e0a5dae7e8ab4642bf5876f35de/zstandard-0.23.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:e7792606d606c8df5277c32ccb58f29b9b8603bf83b48639b7aedf6df4fe8171", size = 5466994, upload-time = "2024-07-15T00:16:36.887Z" }, + { url = "https://files.pythonhosted.org/packages/83/e3/97d84fe95edd38d7053af05159465d298c8b20cebe9ccb3d26783faa9094/zstandard-0.23.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a0817825b900fcd43ac5d05b8b3079937073d2b1ff9cf89427590718b70dd840", size = 4848681, upload-time = "2024-07-15T00:16:39.709Z" }, + { url = "https://files.pythonhosted.org/packages/6e/99/cb1e63e931de15c88af26085e3f2d9af9ce53ccafac73b6e48418fd5a6e6/zstandard-0.23.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:9da6bc32faac9a293ddfdcb9108d4b20416219461e4ec64dfea8383cac186690", size = 4694239, upload-time = "2024-07-15T00:16:41.83Z" }, + { url = "https://files.pythonhosted.org/packages/ab/50/b1e703016eebbc6501fc92f34db7b1c68e54e567ef39e6e59cf5fb6f2ec0/zstandard-0.23.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:fd7699e8fd9969f455ef2926221e0233f81a2542921471382e77a9e2f2b57f4b", size = 5200149, upload-time = "2024-07-15T00:16:44.287Z" }, + { url = "https://files.pythonhosted.org/packages/aa/e0/932388630aaba70197c78bdb10cce2c91fae01a7e553b76ce85471aec690/zstandard-0.23.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:d477ed829077cd945b01fc3115edd132c47e6540ddcd96ca169facff28173057", size = 5655392, upload-time = "2024-07-15T00:16:46.423Z" }, + { url = "https://files.pythonhosted.org/packages/02/90/2633473864f67a15526324b007a9f96c96f56d5f32ef2a56cc12f9548723/zstandard-0.23.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:fa6ce8b52c5987b3e34d5674b0ab529a4602b632ebab0a93b07bfb4dfc8f8a33", size = 5191299, upload-time = "2024-07-15T00:16:49.053Z" }, + { url = "https://files.pythonhosted.org/packages/b0/4c/315ca5c32da7e2dc3455f3b2caee5c8c2246074a61aac6ec3378a97b7136/zstandard-0.23.0-cp313-cp313-win32.whl", hash = "sha256:a9b07268d0c3ca5c170a385a0ab9fb7fdd9f5fd866be004c4ea39e44edce47dd", size = 430862, upload-time = "2024-07-15T00:16:51.003Z" }, + { url = "https://files.pythonhosted.org/packages/a2/bf/c6aaba098e2d04781e8f4f7c0ba3c7aa73d00e4c436bcc0cf059a66691d1/zstandard-0.23.0-cp313-cp313-win_amd64.whl", hash = "sha256:f3513916e8c645d0610815c257cbfd3242adfd5c4cfa78be514e5a3ebb42a41b", size = 495578, upload-time = "2024-07-15T00:16:53.135Z" }, + { url = "https://files.pythonhosted.org/packages/fb/96/4fcafeb7e013a2386d22f974b5b97a0b9a65004ed58c87ae001599bfbd48/zstandard-0.23.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:3aa014d55c3af933c1315eb4bb06dd0459661cc0b15cd61077afa6489bec63bb", size = 788697, upload-time = "2024-07-15T00:17:31.236Z" }, + { url = "https://files.pythonhosted.org/packages/83/ff/a52ce725be69b86a2967ecba0497a8184540cc284c0991125515449e54e2/zstandard-0.23.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:0a7f0804bb3799414af278e9ad51be25edf67f78f916e08afdb983e74161b916", size = 633679, upload-time = "2024-07-15T00:17:32.911Z" }, + { url = "https://files.pythonhosted.org/packages/34/0f/3dc62db122f6a9c481c335fff6fc9f4e88d8f6e2d47321ee3937328addb4/zstandard-0.23.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fb2b1ecfef1e67897d336de3a0e3f52478182d6a47eda86cbd42504c5cbd009a", size = 4940416, upload-time = "2024-07-15T00:17:34.849Z" }, + { url = "https://files.pythonhosted.org/packages/1d/e5/9fe0dd8c85fdc2f635e6660d07872a5dc4b366db566630161e39f9f804e1/zstandard-0.23.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:837bb6764be6919963ef41235fd56a6486b132ea64afe5fafb4cb279ac44f259", size = 5307693, upload-time = "2024-07-15T00:17:37.355Z" }, + { url = "https://files.pythonhosted.org/packages/73/bf/fe62c0cd865c171ee8ed5bc83174b5382a2cb729c8d6162edfb99a83158b/zstandard-0.23.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1516c8c37d3a053b01c1c15b182f3b5f5eef19ced9b930b684a73bad121addf4", size = 5341236, upload-time = "2024-07-15T00:17:40.213Z" }, + { url = "https://files.pythonhosted.org/packages/39/86/4fe79b30c794286110802a6cd44a73b6a314ac8196b9338c0fbd78c2407d/zstandard-0.23.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:48ef6a43b1846f6025dde6ed9fee0c24e1149c1c25f7fb0a0585572b2f3adc58", size = 5439101, upload-time = "2024-07-15T00:17:42.284Z" }, + { url = "https://files.pythonhosted.org/packages/72/ed/cacec235c581ebf8c608c7fb3d4b6b70d1b490d0e5128ea6996f809ecaef/zstandard-0.23.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:11e3bf3c924853a2d5835b24f03eeba7fc9b07d8ca499e247e06ff5676461a15", size = 4860320, upload-time = "2024-07-15T00:17:44.21Z" }, + { url = "https://files.pythonhosted.org/packages/f6/1e/2c589a2930f93946b132fc852c574a19d5edc23fad2b9e566f431050c7ec/zstandard-0.23.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:2fb4535137de7e244c230e24f9d1ec194f61721c86ebea04e1581d9d06ea1269", size = 4931933, upload-time = "2024-07-15T00:17:46.455Z" }, + { url = "https://files.pythonhosted.org/packages/8e/f5/30eadde3686d902b5d4692bb5f286977cbc4adc082145eb3f49d834b2eae/zstandard-0.23.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:8c24f21fa2af4bb9f2c492a86fe0c34e6d2c63812a839590edaf177b7398f700", size = 5463878, upload-time = "2024-07-15T00:17:48.866Z" }, + { url = "https://files.pythonhosted.org/packages/e0/c8/8aed1f0ab9854ef48e5ad4431367fcb23ce73f0304f7b72335a8edc66556/zstandard-0.23.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:a8c86881813a78a6f4508ef9daf9d4995b8ac2d147dcb1a450448941398091c9", size = 4857192, upload-time = "2024-07-15T00:17:51.558Z" }, + { url = "https://files.pythonhosted.org/packages/a8/c6/55e666cfbcd032b9e271865e8578fec56e5594d4faeac379d371526514f5/zstandard-0.23.0-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:fe3b385d996ee0822fd46528d9f0443b880d4d05528fd26a9119a54ec3f91c69", size = 4696513, upload-time = "2024-07-15T00:17:53.924Z" }, + { url = "https://files.pythonhosted.org/packages/dc/bd/720b65bea63ec9de0ac7414c33b9baf271c8de8996e5ff324dc93fc90ff1/zstandard-0.23.0-cp39-cp39-musllinux_1_2_ppc64le.whl", hash = "sha256:82d17e94d735c99621bf8ebf9995f870a6b3e6d14543b99e201ae046dfe7de70", size = 5204823, upload-time = "2024-07-15T00:17:55.948Z" }, + { url = "https://files.pythonhosted.org/packages/d8/40/d678db1556e3941d330cd4e95623a63ef235b18547da98fa184cbc028ecf/zstandard-0.23.0-cp39-cp39-musllinux_1_2_s390x.whl", hash = "sha256:c7c517d74bea1a6afd39aa612fa025e6b8011982a0897768a2f7c8ab4ebb78a2", size = 5666490, upload-time = "2024-07-15T00:17:58.327Z" }, + { url = "https://files.pythonhosted.org/packages/ed/cc/c89329723d7515898a1fc7ef5d251264078548c505719d13e9511800a103/zstandard-0.23.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:1fd7e0f1cfb70eb2f95a19b472ee7ad6d9a0a992ec0ae53286870c104ca939e5", size = 5196622, upload-time = "2024-07-15T00:18:00.404Z" }, + { url = "https://files.pythonhosted.org/packages/78/4c/634289d41e094327a94500dfc919e58841b10ea3a9efdfafbac614797ec2/zstandard-0.23.0-cp39-cp39-win32.whl", hash = "sha256:43da0f0092281bf501f9c5f6f3b4c975a8a0ea82de49ba3f7100e64d422a1274", size = 430620, upload-time = "2024-07-15T00:18:02.613Z" }, + { url = "https://files.pythonhosted.org/packages/a2/e2/0b0c5a0f4f7699fecd92c1ba6278ef9b01f2b0b0dd46f62bfc6729c05659/zstandard-0.23.0-cp39-cp39-win_amd64.whl", hash = "sha256:f8346bfa098532bc1fb6c7ef06783e969d87a99dd1d2a5a18a892c1d7a643c58", size = 495528, upload-time = "2024-07-15T00:18:04.452Z" }, +]