diff --git a/README.md b/README.md index ac5786b0b..b53e24823 100644 --- a/README.md +++ b/README.md @@ -29,6 +29,7 @@ This repository covers the most popular community approaches, use-cases and the * 5M long context using [Llama 4 Scout](./getting-started/build_with_llama_4.ipynb) * Analyze research papers with [Llama 4 Maverick](./end-to-end-use-cases/research_paper_analyzer/README.md) * Create a character mind map from a book using [Llama 4 Maverick](./end-to-end-use-cases/book-character-mindmap/README.md) +* Convert Powerpoint Decks to Text-to-Speech Ready Transcripts with [Llama 4 Maverick](./end-to-end-use-cases/powerpoint-to-voiceover-transcript/README.md) ## Repository Structure: diff --git a/end-to-end-use-cases/README.md b/end-to-end-use-cases/README.md index 3a7561813..6f0a4d2c1 100644 --- a/end-to-end-use-cases/README.md +++ b/end-to-end-use-cases/README.md @@ -56,6 +56,9 @@ Use Llama4 Maverick to process entire books at once and visualize character rela Discover new insights into your favorite books! +## [Powerpoint to Text-to-Speech Ready Transcripts:](./powerpoint-to-voiceover-transcript/README.md) +### Knowledge Grounded & Narrative Continuity Enabled TTS Transcript Generation from a Powerpoint Deck +This tutorial demonstrates the complete workflow for converting PowerPoint presentations into Llama 4 generated TTS transcripts with retrieval augmentation and narrative continuity features, powered by Llama 4 Maverick's vision capabilities through the Llama API. @@ -96,10 +99,9 @@ This step-by-step tutorial shows how to use the [WhatsApp Business API](https:// ## [Messenger Chatbot](./customerservice_chatbots/messenger_chatbot/messenger_llama3.md): - ### Building a Llama 3 Enabled Messenger Chatbot This step-by-step tutorial shows how to use the [Messenger Platform](https://developers.facebook.com/docs/messenger-platform/overview) to build a Llama 3 enabled Messenger chatbot. -### RAG Chatbot Example (running [locally](./customerservice_chatbots/RAG_chatbot/RAG_Chatbot_Example.ipynb) +## [RAG Chatbot Example (running locally)](./customerservice_chatbots/RAG_chatbot/RAG_Chatbot_Example.ipynb) A complete example of how to build a Llama 3 chatbot hosted on your browser that can answer questions based on your own data using retrieval augmented generation (RAG). diff --git a/end-to-end-use-cases/powerpoint-to-voiceover-transcript/.env.example b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/.env.example new file mode 100644 index 000000000..b21181c85 --- /dev/null +++ b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/.env.example @@ -0,0 +1,20 @@ +# Copy this file to .env and fill in your actual values +# Usage: cp .env.example .env +# ============================================================================= + +# ============================================================================= +# REQUIRED API CONFIGURATION +# ============================================================================= + +# GROQ API Key (REQUIRED) +# This is essential for AI transcript generation +# Required API Keys +GROQ_API_KEY=your_groq_api_key_here + +# ============================================================================= +# SETUP INSTRUCTIONS +# ============================================================================= + +# 1. COPY THIS FILE: +# cp .env.example .env +# 2. Fill in your API key diff --git a/end-to-end-use-cases/powerpoint-to-voiceover-transcript/.gitignore b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/.gitignore new file mode 100644 index 000000000..59dd3b911 --- /dev/null +++ b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/.gitignore @@ -0,0 +1,191 @@ +# Environment variables and secrets +.env +.env.local +.env.development +.env.test +.env.production +*.env + +# PowerPoint files +# *.pptx +# *.ppt +# *.potx +# *.pot + +# Output directories and generated files +slide_images/ +cache/ +logs/ +temp/ +*.log + +# Progress and state files +progress.json +*.progress + +# Python +__pycache__/ +*.py[cod] +*$py.class +*.so +.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 +pptx_to_vo_workflow.ipynb + +# IPython +profile_default/ +ipython_config.py + +# pyenv +.python-version + +# pipenv +Pipfile.lock + +# poetry +poetry.lock + +# pdm +.pdm.toml + +# PEP 582 +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# pytype static type analyzer +.pytype/ + +# Cython debug symbols +cython_debug/ + +# IDE and Editor files +.vscode/ +.idea/ +*.swp +*.swo +*~ + +# OS generated files +.DS_Store +.DS_Store? +._* +.Spotlight-V100 +.Trashes +ehthumbs.db +Thumbs.db + +# # Image files (generated from slides) +# *.png +# *.jpg +# *.jpeg +# *.gif +# *.bmp +# *.tiff +# *.svg + +# # PDF files (intermediate conversion files) +# *.pdf + +# # CSV and JSON output files +# *.csv +# *.json + +# Backup files +*.bak +*.backup +*.old + +# Temporary files +*.tmp +*.temp + +# LibreOffice lock files +.~lock.* + +# API keys and configuration with sensitive data +api_keys.txt +secrets.yaml +credentials.json + +# Large model files or cached data +*.model +*.bin +*.safetensors +.DS_Store +**/.DS_Store + +*narrative_ diff --git a/end-to-end-use-cases/powerpoint-to-voiceover-transcript/README.md b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/README.md new file mode 100644 index 000000000..40d0e8c5d --- /dev/null +++ b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/README.md @@ -0,0 +1,330 @@ +# PowerPoint to Voiceover Transcript Generator + +> **RAG-powered AI system that converts PowerPoint presentations into professional voiceover transcripts using Llama 4 Maverick** + +Transform PowerPoint slides into natural-sounding voiceover scripts optimized for human narration and text-to-speech systems. + +## Features + +- **Multi-Modal AI**: Analyzes slide visuals and speaker notes with Llama 4 Maverick +- **RAG Enhancement**: FAISS-powered knowledge retrieval from markdown files +- **Narrative Flow**: Maintains context and smooth transitions between slides +- **Speech Ready**: Converts numbers, technical terms, and abbreviations to spoken form + +## Use Cases +- **Corporate Presentations:** Internal training, product demos, quarterly reviews +- **Educational Content:** Course materials, conference talks, webinars +- **Marketing Materials:** Product launches, sales presentations, customer demos +- **Technical Documentation:** API walkthroughs, system architecture presentations +## Quick Start + +### Prerequisites +- Python 3.12+ +- LibreOffice (for PPTX conversion) +- Groq API key + +### Installation + +#### Option 1: Using uv (Recommended) + +```bash +# Install uv if not already installed +curl -LsSf https://astral.sh/uv/install.sh | sh + +# Clone and setup project +git clone +cd powerpoint-to-voiceover-transcript +uv sync + +# Activate environment +source .venv/bin/activate # macOS/Linux +# or .venv\Scripts\activate # Windows +``` + +#### Option 2: Using pip + +```bash +git clone +cd powerpoint-to-voiceover-transcript +pip install -e . +``` + +### Environment Setup + +```bash +# Copy environment template +cp .env.example .env + +# Edit .env and add your API key +echo "GROQ_API_KEY=your_api_key_here" >> .env + +# Configure your presentation in config.yaml +# Update the pptx_file path to your presentation +``` + + +## Usage + +### ๐Ÿš€ Jupyter Notebooks (Recommended!) +```bash +# Basic workflow with narrative continuity +jupyter notebook narrative_continuity_workflow.ipynb + +# Advanced workflow with knowledge enhancement +jupyter notebook knowledge_enhanced_workflow.ipynb +``` + +### ๐Ÿ Python API +```python +from src.core.pptx_processor import pptx_to_images_and_notes +from src.processors.unified_transcript_generator import UnifiedTranscriptProcessor + +# Extract slides and notes +result = pptx_to_images_and_notes("input/presentation.pptx", "output/") + +# Generate transcripts with full enhancement +processor = UnifiedTranscriptProcessor( + use_narrative=True, + context_window_size=5, + enable_knowledge=True +) + +transcripts = processor.process_slides_dataframe( + result['notes_df'], + "output/", + save_context=True +) + +# Save results +transcripts.to_csv("output/transcripts.csv", index=False) +``` + +## Knowledge Base Setup + +1. **Add markdown files** to `knowledge_base/` directory: + ```bash + echo "# Product Overview\nOur product..." > knowledge_base/product.md + echo "# Technical Terms\nAPI means..." > knowledge_base/glossary.md + ``` + +2. **The system will automatically**: + - Index your markdown files with FAISS + - Search for relevant content during processing + - Enhance transcripts with domain knowledge + +## Configuration + +### Main Configuration File (`config.yaml`) + +```yaml +# API Configuration +api: + groq_model: "meta-llama/llama-4-maverick-17b-128e-instruct" + max_retries: 3 + retry_delay: 1 + +# Processing Configuration +processing: + default_dpi: 200 + default_format: "png" + batch_size: 5 + +# Current Project Settings +current_project: + pptx_file: "input/All About Llamas" + extension: ".pptx" + output_dir: "output/" + +# Knowledge Base Configuration +knowledge: + # Core settings + enabled: true + knowledge_base_dir: "knowledge_base" + + # FAISS Vector Store + vector_store: + index_type: "flat" # "flat", "ivf", "hnsw" + use_gpu: false # Enable GPU acceleration + cache_enabled: true # Persistent caching + + # Embedding Configuration + embedding: + model_name: "all-MiniLM-L6-v2" # Lightweight, fast model + device: "cpu" # Use "cuda" if GPU available + + # Search Configuration + search: + top_k: 5 # Number of chunks to retrieve + similarity_threshold: 0.3 # Minimum similarity score + max_chunk_size: 1000 # Maximum characters per chunk + + # Context Integration + context: + strategy: "combined" # "knowledge_only", "narrative_priority", "combined" + knowledge_weight: 0.3 # Knowledge influence (0.0-1.0) + integration_method: "system_prompt" + + # Performance Settings + performance: + enable_caching: true # Cache embeddings and search results + max_memory_mb: 512 # Maximum memory for embeddings + lazy_loading: true # Load embeddings on demand + +# File Paths +paths: + cache_dir: "cache" + logs_dir: "logs" + temp_dir: "temp" + +# Logging +logging: + level: "INFO" + file_enabled: true + console_enabled: true +``` + +### Environment Variables (`.env`) + +```bash +# Required +GROQ_API_KEY=your_groq_api_key_here +``` + +### Integration Strategies + +| Strategy | Configuration | Best For | +|----------|---------------|----------| +| **Knowledge Only** | `strategy: "knowledge_only"` | Technical docs, specifications | +| **Narrative Priority** | `strategy: "narrative_priority"` | Storytelling, educational content | +| **Combined** | `strategy: "combined"` | Most presentations (recommended) | + +### Performance Tuning + +**For Speed:** +```yaml +processing: + default_dpi: 150 +knowledge: + search: + top_k: 3 + performance: + max_memory_mb: 256 +``` + +**For Quality:** +```yaml +knowledge: + search: + top_k: 7 + similarity_threshold: 0.2 + context: + knowledge_weight: 0.4 +``` + +## System Architecture + +### Core Processing Pipeline + +The system follows a modular 3-stage pipeline: + +``` +โ”Œโ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ” โ”Œโ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ” โ”Œโ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ” +โ”‚ PowerPoint โ”‚โ”€โ”€โ”€โ–ถโ”‚ Content โ”‚โ”€โ”€โ”€โ–ถโ”‚ Knowledge โ”‚ +โ”‚ File โ”‚ โ”‚ Extraction โ”‚ โ”‚ Retrieval โ”‚ +โ””โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”˜ โ””โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”˜ โ””โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”˜ + โ”‚ +โ”Œโ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ” โ”Œโ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ” โ”Œโ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ” +โ”‚ Output โ”‚โ—€โ”€โ”€โ”€โ”‚ Transcript โ”‚โ—€โ”€โ”€โ”€โ”‚ LLM Processing โ”‚ +โ”‚ Files โ”‚ โ”‚ Generation โ”‚ โ”‚ Vision & Text โ”‚ +โ””โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”˜ โ””โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”˜ โ””โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”˜ +``` +#### Stage 1: Content Extraction (`pptx_processor.py`) +- Extracts speaker notes and slide text using `python-pptx` +- Converts PPTX โ†’ PDF โ†’ Images via LibreOffice and PyMuPDF +- Generates structured DataFrame with slide metadata +- Supports configurable DPI (default: 200) and formats (PNG/JPEG) + +#### Stage 2: Knowledge Retrieval (`markdown_knowledge.py`) +- Loads and chunks markdown files from knowledge base +- Generates embeddings using sentence-transformers +- Performs semantic search for relevant knowledge chunks +- Integrates knowledge with slide content and speaker notes + +#### Stage 3: AI Processing (`groq_client.py` + `unified_transcript_generator.py`) +- Integrates with Groq's vision models via `groq` client +- Base64 encodes images for vision model processing +- Applies narrative continuity with sliding context window +- Handles API retries and comprehensive error management + + +### Project Structure +``` +โ”œโ”€โ”€ README.md # This guide +โ”œโ”€โ”€ config.yaml # Configuration +โ”œโ”€โ”€ pyproject.toml # Dependencies +โ”œโ”€โ”€ knowledge_enhanced_workflow.ipynb # Advanced notebook +โ”œโ”€โ”€ narrative_continuity_workflow.ipynb # Basic notebook +โ”œโ”€โ”€ input/ # PowerPoint files +โ”‚ โ””โ”€โ”€ All About Llamas.pptx # Example presentation +โ”œโ”€โ”€ output/ # Generated transcripts and images +โ”œโ”€โ”€ knowledge_base/ # Domain knowledge (.md files) +โ”‚ โ”œโ”€โ”€ llama diet.md +โ”‚ โ””โ”€โ”€ llamas.md +โ””โ”€โ”€ src/ + โ”œโ”€โ”€ config/settings.py # Configuration management + โ”œโ”€โ”€ core/ # Core processing + โ”‚ โ”œโ”€โ”€ pptx_processor.py # PPTX extraction + โ”‚ โ”œโ”€โ”€ groq_client.py # Groq API client + โ”‚ โ””โ”€โ”€ image_processing.py # Image encoding + โ”œโ”€โ”€ knowledge/ # Knowledge management + โ”‚ โ”œโ”€โ”€ faiss_knowledge.py # FAISS vector search + โ”‚ โ””โ”€โ”€ context_manager.py # Context integration + โ”œโ”€โ”€ processors/ # Main processing + โ”‚ โ””โ”€โ”€ unified_transcript_generator.py + โ””โ”€โ”€ utils/ # Utilities + โ”œโ”€โ”€ visualization.py # Slide display + โ””โ”€โ”€ transcript_display.py # Transcript formatting +``` + +## Processing Your Own Presentations + +1. **Add your PowerPoint**: + ```bash + cp your_presentation.pptx input/ + ``` + +2. **Update config.yaml**: + ```yaml + current_project: + pptx_file: "input/your_presentation" + ``` + +3. **Add domain knowledge** (optional): + ```bash + echo "# Your Domain Info\n..." > knowledge_base/domain.md + ``` + +4. **Run processing**: + ```bash + jupyter notebook knowledge_enhanced_workflow.ipynb + ``` + +## Troubleshooting + +| Issue | Solution | +|-------|----------| +| LibreOffice not found | `brew install --cask libreoffice` (macOS) | +| API key error | Set `GROQ_API_KEY` environment variable | +| Memory issues | Reduce `context_window_size` and `top_k` in config | +| Slow processing | Lower `default_dpi` or disable knowledge: `enabled: false` | +| Knowledge base not loading | Check `.md` files exist: `ls knowledge_base/*.md` | + +## Output Files + +After processing, check the `output/` directory for: +- **Slide images**: `slide-001.png`, `slide-002.png`, etc. +- **Transcripts**: `*_transcripts.csv` and `*_transcripts.json` +- **Context data**: `narrative_context/` (if narrative mode enabled) +- **Knowledge stats**: `knowledge_base_stats.json` (if knowledge enabled) + +--- diff --git a/end-to-end-use-cases/powerpoint-to-voiceover-transcript/config.yaml b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/config.yaml new file mode 100644 index 000000000..74f26be28 --- /dev/null +++ b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/config.yaml @@ -0,0 +1,195 @@ +# PPTX to Transcript Configuration + +# API Configuration +api: + groq_model: "meta-llama/llama-4-maverick-17b-128e-instruct" + max_retries: 3 + retry_delay: 1 + rate_limit_delay: 1 + +# Processing Configuration +processing: + default_dpi: 200 + supported_formats: ["png", "jpeg", "jpg"] + default_format: "png" + batch_size: 5 + +# File Paths +paths: + default_output_dir: "output/" + cache_dir: "cache" + logs_dir: "logs" + temp_dir: "temp" + +# Current Project Settings +current_project: + pptx_file: "input/All About Llamas" # Powerpoint file name (without the ppt/pptx extension) + extension: ".pptx" + output_dir: "output/" + +# LibreOffice Paths (auto-detected, but can be overridden) +libreoffice: + possible_paths: + - "/Applications/LibreOffice.app/Contents/MacOS/soffice" + - "/usr/bin/soffice" + - "/usr/local/bin/soffice" + # # Linux paths + # - "/snap/bin/libreoffice" + # - "/opt/libreoffice/program/soffice" + # # Windows paths + # - "C:\\Program Files\\LibreOffice\\program\\soffice.exe" + # - "C:\\Program Files (x86)\\LibreOffice\\program\\soffice.exe" + # - "C:\\Users\\%USERNAME%\\AppData\\Local\\Programs\\LibreOffice\\program\\soffice.exe" + # - "C:\\PortableApps\\LibreOfficePortable\\App\\libreoffice\\program\\soffice.exe" + +# Logging Configuration +logging: + level: "INFO" + format: "%(asctime)s - %(levelname)s - %(message)s" + file_enabled: true + console_enabled: true + +# Progress Tracking +progress: + save_interval: 5 # Save progress every N slides + progress_file: "progress.json" + +# Image Quality Settings +image_quality: + jpeg_quality: 90 + jpeg_optimize: true + png_compression: 6 + +# Knowledge Base Configuration +knowledge: + # Enable/disable knowledge base integration + enabled: true # Set to true to enable knowledge base features + + # Knowledge base directory path (relative to project root) + knowledge_base_dir: "knowledge_base" + + # Vector store configuration (FAISS) + vector_store: + type: "faiss" # Vector database type + index_type: "flat" # "flat", "ivf", "hnsw" + use_gpu: false # Enable GPU acceleration (requires faiss-gpu) + cache_enabled: true # Enable persistent caching + rebuild_on_changes: true # Auto-rebuild when files change + + # Embedding model configuration + embedding: + model_name: "all-MiniLM-L6-v2" # Lightweight, fast model + device: "cpu" # Use "cuda" if GPU available + batch_size: 32 + max_seq_length: 512 + + # Search configuration + search: + top_k: 5 # Number of knowledge chunks to retrieve + similarity_threshold: 0.3 # Minimum similarity threshold (0.0 to 1.0) + enable_keyword_fallback: true # Enable fallback keyword search if similarity search fails + max_chunk_size: 1000 # Maximum characters per knowledge chunk + chunk_overlap: 200 # Overlap between chunks (characters) + + # Context integration settings + context: + # Strategy for combining knowledge with narrative context + strategy: "combined" # Options: "knowledge_only", "narrative_priority", "combined" + max_context_length: 8000 # Maximum total context length (characters) + knowledge_weight: 0.3 # Knowledge context weight (0.0 to 1.0, higher = more knowledge influence) + integration_method: "system_prompt" # Integration method: "system_prompt" or "user_message" + + # Performance and reliability settings + performance: + # Enable caching of embeddings and search results + enable_caching: true + # Cache directory (relative to project root) + cache_dir: "cache/knowledge" + # Cache expiration time in hours (0 = never expire) + cache_expiry_hours: 24 + # Maximum memory usage for embeddings (MB) + max_memory_mb: 512 + # Enable lazy loading of embeddings + lazy_loading: true + + # Fallback options for reliability + fallback: + # Continue processing if knowledge base fails to load + graceful_degradation: true + # Use simple keyword matching if embedding model fails + use_keyword_fallback: true + # Log errors but don't fail the entire process + log_errors_only: true + +# Example System Prompt - Replace with your own, although this one is pretty good. +system_prompt: | + You are a speech-aware GenAI expert who specializes in generating natural-sounding transcripts for human narration and text-to-speech systems. + You are also a GenAI expert specializing in LLaMA vision and language models at Meta. + + Your task involves analyzing a PowerPoint slide image and its associated speaker notes to generate a complete, professional transcript suitable for voiceover narration. The voiceover will be recorded for an internal team, so clarity, tone, and spoken correctness are critical. + Your goal is to ensure that all technical terms, numbers, and abbreviations are rendered the way a human would say them out loud โ€” clearly, naturally, and without confusion. + + Please follow these detailed steps: + + 1. Extract all visual content from the slide image: + - Detect and extract all visible text elements including titles, headings, body text, callouts, labels, and captions. + - Preserve the top-to-bottom, left-to-right visual order to reflect how a human would naturally read the slide. + - Identify any diagrams, tables, or charts and include a brief verbal explanation only if necessary to communicate the slide's key message. + - Do not extract hyperlinks. + + 2. Combine the extracted text with the provided speaker notes to form a unified understanding of the slide's purpose and content. + + 3. Generate a professional voiceover transcript that: + - Sounds natural, confident, and informative, as if explaining the slide to an internal executive audience. + - Seamlessly blends slide content and speaker notes into a single narrative. + - Avoids non-verbal artifacts like slide numbers, bullet points, hyperlinks, or placeholder text such as "click here" or "see above." + - Does not include transitional fluff such as "Welcome toโ€ฆ" or "This slide showsโ€ฆ" โ€” only speak the core informational content. + - Is suitable for a 1.5โ€“3 minute spoken video. + + 4. Ensure the transcript: + - Does not contain the title of the slide. + - Flows logically, even if slide layout is fragmented. + - Expands acronyms or technical terms on first use (e.g., "LLM" becomes "Large Language Model, or LLM"). + - Maintains a neutral, respectful, and professional tone appropriate for stakeholders. + + 5. Normalize all numbers, technical terms, and model names into naturally spoken form: + + You must **rewrite all numbers, decimal points, and alphanumeric tokens** so they sound correct when read aloud or used with a text-to-speech system. Use the following phonetic transformation rules: + + - **Decimal numbers**: Convert all numbers with a decimal (e.g., `3.2`) into the form: **"three dot two"**. + - Examples: + - `3.5` โ†’ "three dot five" + - `3.1` โ†’ "three dot one" + - `3.3` โ†’ "three dot three" + - `2.0` โ†’ "two dot oh" + - `4.0` โ†’ "four dot oh" + + - **Model size suffixes**: + - `70B` โ†’ "seventy B" + - `10M` โ†’ "ten M" + - `2K` โ†’ "two K" + - `10B+` โ†’ "ten B plus" + + - **Model names**: Break apart letters and digits where needed for natural clarity. + - `LLaMA-3.2` โ†’ "LLaMA three dot two" + - `LLaMA 4 Scout` โ†’ "LLaMA four Scout" + + - **Large numbers**: Convert `17B` into "seventeen billion", `128` into "one hundred twenty-eight", etc. + - `16 experts` โ†’ "sixteen experts" + - `128 experts` โ†’ "one hundred twenty-eight experts" + + - **Context windows or token counts**: Always use full expansion. + - `10M` โ†’ "ten million" + - `1T` โ†’ "one trillion" + + - **Industry Abbreviations**: Break apart letters + - "LLM" โ†’ "L L M" + - "GPU" โ†’ "G P U" + - "AI" โ†’ "A I" + + These spoken-form transformations **must be applied consistently across the entire transcript**. + + Final Output: + - Do not leave any numeric or technical token in a written format that would confuse a voiceover or text-to-speech engine. + - Provide only the final transcript for voiceoverโ€”no markdown, no labels, no extra commentary. + - Check for numeric mispronunciations before final output diff --git a/end-to-end-use-cases/powerpoint-to-voiceover-transcript/input/All About Llamas.pptx b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/input/All About Llamas.pptx new file mode 100644 index 000000000..866d0d6f8 Binary files /dev/null and b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/input/All About Llamas.pptx differ diff --git a/end-to-end-use-cases/powerpoint-to-voiceover-transcript/knowledge_base/.faiss_cache/chunks.pkl b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/knowledge_base/.faiss_cache/chunks.pkl new file mode 100644 index 000000000..494ee50ed Binary files /dev/null and b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/knowledge_base/.faiss_cache/chunks.pkl differ diff --git a/end-to-end-use-cases/powerpoint-to-voiceover-transcript/knowledge_base/.faiss_cache/faiss.index b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/knowledge_base/.faiss_cache/faiss.index new file mode 100644 index 000000000..170370440 Binary files /dev/null and b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/knowledge_base/.faiss_cache/faiss.index differ diff --git a/end-to-end-use-cases/powerpoint-to-voiceover-transcript/knowledge_base/.faiss_cache/metadata.json b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/knowledge_base/.faiss_cache/metadata.json new file mode 100644 index 000000000..8f7faece4 --- /dev/null +++ b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/knowledge_base/.faiss_cache/metadata.json @@ -0,0 +1,13 @@ +{ + "knowledge_base_hash": "8364d097acf9253df6376c62a82b791c", + "index_type": "flat", + "embedding_model": "all-MiniLM-L6-v2", + "total_chunks": 19, + "created_at": "2025-08-26T16:31:16.693386", + "stats": { + "total_searches": 0, + "cache_hits": 0, + "index_builds": 1, + "last_updated": "2025-08-26T16:31:16.688962" + } +} \ No newline at end of file diff --git a/end-to-end-use-cases/powerpoint-to-voiceover-transcript/knowledge_base/llama diet.md b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/knowledge_base/llama diet.md new file mode 100644 index 000000000..6a3830d2a --- /dev/null +++ b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/knowledge_base/llama diet.md @@ -0,0 +1,145 @@ +๐Ÿฆ™ Llama Diet and Digestion +Llamas (Lama glama), as members of the camelid family, are highly adapted herbivores with efficient digestive systems that enable them to survive in nutrient-sparse environments such as the high Andes. Their diet is composed primarily of fibrous plant material, and their specialized digestive system is evolved to extract maximum nutrients from minimal input. + +๐ŸŒฑ Natural Diet +In their native Andean habitat, llamas are browsers and grazers that consume a diverse range of plant matter. Their diet varies depending on altitude, season, and availability. + +Primary Components: +Grasses: The bulk of their diet, especially puna grasses in the Andes. + +Shrubs and herbs: Including low-lying woody plants and succulents. + +Forbs: Broad-leaved herbaceous plants. + +Lichens and mosses: Occasionally consumed in high-altitude regions. + +In Captivity or Managed Settings: +Grass hay: The main source of fiber (e.g., timothy, orchard grass, brome). + +Legume hay (e.g., alfalfa): High in protein but given in moderation due to excess calcium and energy. + +Grain concentrates: Provided sparingly, typically during pregnancy, lactation, or recovery from illness. + +Fresh pasture: When available, llamas graze like sheep or goats. + +Supplements: Mineral blocks or loose minerals to support trace element intake (especially selenium, copper, and zinc in deficient regions). + +Llamas are efficient foragers, able to sustain themselves on marginal land where other livestock might fail. They prefer to browse selectively and will often avoid contaminated or spoiled feed. + +๐Ÿง  Feeding Behavior +Llamas exhibit intelligent and selective feeding behavior: + +Diurnal feeding: Most active during early morning and late afternoon. + +Slow, deliberate grazers: They nibble plants rather than tearing or uprooting them. + +Low water requirement: Llamas can go long periods without drinking, deriving moisture from forage. + +They also have a strong memory for feeding areas and can adapt quickly to rotational grazing practices, which makes them relatively low-maintenance compared to cattle or horses. + +๐Ÿงช Digestive System +Llamas are pseudoruminants, meaning they have a three-compartment stomach (as opposed to the four compartments found in true ruminants like cows). These compartments are: + +C1 (Compartment 1): + +Analogous to the rumen. + +The largest compartment. + +Hosts a diverse microbial population (bacteria, protozoa, fungi) that ferments fibrous plant material. + +Responsible for volatile fatty acid (VFA) production, a major energy source. + +C2 (Compartment 2): + +Functions in further fermentation and nutrient absorption. + +Works closely with C1 to maximize microbial breakdown of cellulose. + +C3 (Compartment 3): + +Equivalent to the abomasum in true ruminants (the โ€œtrue stomachโ€). + +Secretes digestive enzymes (HCl, pepsin) for acidic digestion of microbial proteins and residual carbohydrates. + +The distal end of C3 is highly acidic and prone to ulcers if under stress or dietary imbalance. + +Key Features: +Regurgitation and remastication: Like ruminants, llamas chew cud to further break down fibrous material. + +Microbial symbiosis: Microbes digest cellulose and hemicellulose into VFAs like acetate, propionate, and butyrate. + +Long retention time: Slow digestion allows for high fiber digestibility (>50% in some cases). + +Efficient nitrogen recycling: Llamas are able to conserve nitrogen via urea recycling into the digestive tract. + +๐Ÿ’ฉ Waste Output and Nutrient Cycling +Llamas produce small, dry fecal pellets that are: + +Low in moisture + +Rich in partially digested fiber + +Valuable as fertilizer ("llama beans") due to slow nitrogen release and low odor + +They often defecate in communal dung piles, a behavior that: + +Minimizes parasite transmission + +Helps with territory marking + +Makes pasture cleanup easier + +โš ๏ธ Dietary Issues and Management +While llamas are hardy, their diet must be managed to avoid health issues: + +Common Problems: +Issue Cause Prevention +Obesity Overfeeding grain, lush pasture Monitor body condition, restrict energy-dense feeds +Protein Deficiency Low-quality forage Supplement with legume hay or protein concentrates +Mineral Deficiency Selenium, copper, or zinc lack Provide species-specific mineral supplements +Ulcers in C3 Stress, abrupt dietary change Ensure consistent feeding, reduce stress, avoid NSAIDs +Bloat (rare) Excess legumes or lush pasture Limit high-risk feeds, encourage slow transition + +Special Diets: +Pregnant/lactating females: Require higher protein and energy levels. + +Working llamas: May need additional energy (carbohydrates) for endurance. + +Older llamas: Benefit from easy-to-chew forage and soaked hay cubes. + +๐Ÿงฎ Nutritional Requirements +Approximate daily requirements (adult llama, maintenance level): + +Nutrient Requirement +Dry matter intake 1.8โ€“2.5% of body weight +Crude protein 8โ€“10% (12โ€“16% for growth or lactation) +Calcium:Phosphorus ratio 1.5โ€“2:1 +Salt 0.25โ€“0.5 oz/day +Water 2โ€“5 gallons/day (varies by temperature and diet) + +These values should be adjusted for workload, age, reproductive status, and environment. + +๐Ÿงฌ Evolutionary Adaptations +Llamas evolved in high-altitude, arid environments, leading to: + +Low metabolic requirements + +High fiber digestion efficiency + +Ability to thrive on poor forage + +Adaptation to wide dietary variability + +These traits make llamas an eco-efficient livestock option in areas where conventional livestock may not be viable. + +๐Ÿ“š References +Fowler, M.E. (1998). Medicine and Surgery of South American Camelids. + +Van Saun, R.J. (2006). Nutritional Requirements and Feeding of Llamas and Alpacas. + +NRC (2007). Nutrient Requirements of Small Ruminants. + +Camelid Nutrition Council: www.camelidnutrition.org + +Oregon State University Extension Service diff --git a/end-to-end-use-cases/powerpoint-to-voiceover-transcript/knowledge_base/llamas.md b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/knowledge_base/llamas.md new file mode 100644 index 000000000..b3ee7fd26 --- /dev/null +++ b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/knowledge_base/llamas.md @@ -0,0 +1,208 @@ +# Llamas (*Lama glama*) + +Llamas are domesticated South American camelids, widely used as meat and pack animals by Andean cultures since the Pre-Columbian era. They are members of the biological family Camelidae, which includes camels, alpacas, guanacos, and vicuรฑas. Llamas are closely related to alpacas but are larger and typically used for different purposes. + +--- + +## Etymology + +The name "llama" (pronounced \[หˆja.ma] in Spanish) is derived from the native Quechua word "lama" or "llama". The word was adopted by Spanish settlers and integrated into English and other languages. + +--- + +## Taxonomy + +* **Kingdom**: Animalia +* **Phylum**: Chordata +* **Class**: Mammalia +* **Order**: Artiodactyla +* **Family**: Camelidae +* **Genus**: *Lama* +* **Species**: *Lama glama* + +Llamas are part of the genus *Lama*, which also includes alpacas (*Lama pacos*), guanacos (*Lama guanicoe*), and the extinct species *Lama owenii*. They are believed to be domesticated from wild guanacos around 4,000 to 5,000 years ago in the Andean highlands. + +--- + +## Physical Description + +| Feature | Description | +| -------- | ------------------------------------------------------------------------------------------------ | +| Height | 1.7 to 1.8 meters (5.5 to 6 ft) at the head | +| Weight | 130 to 200 kg (290 to 440 lb) | +| Coat | Long, soft wool in various natural colors: white, black, brown, gray, and patterned combinations | +| Lifespan | 15 to 25 years | +| Ears | Long and banana-shaped, curving inward | +| Feet | Two-toed with soft pads for gripping rocky terrain | + +--- + +## Distribution and Habitat + +Llamas are native to the **Andes Mountains** in South America. Today, they are primarily found in: + +* **Peru** +* **Bolivia** +* **Ecuador** +* **Chile** +* **Argentina** + +Due to their adaptability, llamas have also been introduced to North America, Europe, Australia, and New Zealand. They are well-suited to high-altitude environments but can thrive in various climates with appropriate care. + +--- + +## Domestication and Historical Use + +Llamas were domesticated in the Andes around 4,000โ€“5,000 years ago. They played a central role in the development of early Andean civilizations, including the Inca Empire. Uses included: + +* **Transport**: Llamas were the primary pack animals, capable of carrying 25โ€“30% of their body weight. +* **Fiber**: Their wool was woven into textiles, a crucial cultural and economic component of Andean society. +* **Meat and leather**: Used for sustenance and clothing. +* **Manure**: Used as fertilizer and fuel in high-altitude regions. + +Llama caravans were a vital part of the Incan road and trade networks. + +--- + +## Behavior and Social Structure + +Llamas are social herd animals and form strong social bonds. They are generally gentle, curious, and intelligent. Key behavioral traits: + +* **Herd hierarchy**: Llamas live in hierarchical groups with an alpha male. +* **Spitting**: Used primarily as a social signal among llamas, especially to establish dominance. Rarely directed at humans. +* **Communication**: Includes humming, clucking, and alarm calls. +* **Training**: Easily trainable; can learn simple commands and are used in therapy, trekking, and shows. + +--- + +## Diet and Digestion + +Llamas are herbivorous grazers. Their natural diet includes: + +* Grasses +* Shrubs +* Lichens and mosses (in mountainous areas) +* Hay and supplemental grains (in captivity) + +They have a **three-compartment stomach** that allows efficient digestion of roughage and fibrous plants. They chew cud like cattle. + +--- + +## Reproduction and Lifespan + +* **Mating system**: Induced ovulators; breeding is polygynous in the wild. +* **Gestation**: Approximately 11.5 months +* **Offspring**: One baby, called a **cria** +* **Weaning**: Around 4โ€“6 months + +Llamas reach maturity at around 2โ€“3 years of age. Under proper care, llamas can live up to 25 years. + +--- + +## Llama Fiber and Its Uses + +Llama fiber is highly valued for its warmth, softness, and durability. It differs from alpaca fiber, which is finer and softer. + +### Characteristics of Llama Fiber + +* Hollow, insulating fibers +* Lanolin-free (hypoallergenic) +* Coarse guard hairs are typically removed in processing + +### Common Products + +* Blankets +* Ropes +* Rugs +* Outerwear (ponchos, coats) + +--- + +## Economic and Cultural Importance + +Llamas continue to serve a key economic role in rural Andean communities. They are used in: + +* **Agricultural labor** +* **Eco-tourism and trekking** +* **Cultural ceremonies and festivals** +* **Wool and meat production** + +In modern contexts, llamas are used in North America and Europe for: + +* **Companionship and therapy** +* **Guard animals for sheep** +* **4H and agricultural education programs** + +--- + +## Health and Care + +Llamas are hardy animals but require basic veterinary care, including: + +* **Vaccinations** (e.g., CDT: Clostridium perfringens types C and D and tetanus) +* **Regular deworming** +* **Shearing and toenail trimming** +* **Adequate shelter and nutrition** + +They are generally disease-resistant but may be prone to parasites and heat stress in non-native environments. + +--- + +## Llamas vs. Alpacas + +| Feature | Llama (*Lama glama*) | Alpaca (*Lama pacos*) | +| ----------- | -------------------- | --------------------- | +| Size | Larger (290โ€“440 lb) | Smaller (120โ€“145 lb) | +| Ears | Long, banana-shaped | Short, spear-shaped | +| Fiber | Coarser | Softer, finer | +| Use | Pack animal | Fiber production | +| Temperament | More independent | More docile | + +--- + +## Conservation Status + +Llamas are **not endangered**. They are widely bred and maintained both in South America and globally. However, genetic diversity is a concern in some isolated populations. + +Efforts exist to preserve native Andean breeds and to prevent crossbreeding that could lead to loss of local adaptations. + +--- + +## Llamas in Popular Culture + +Llamas have become widely recognized in popular media. Examples include: + +* **Books**: *Llama Llama* children's series by Anna Dewdney +* **Films**: *The Emperor's New Groove* (features a human transformed into a llama) +* **Memes and merchandise**: Known for their expressive faces and quirky charm +* **Emojis**: ๐Ÿฆ™ + +They are often used as symbols of uniqueness, calmness, and endurance. + +--- + +## See Also + +* **Alpaca** (*Lama pacos*) +* **Guanaco** (*Lama guanicoe*) +* **Vicuรฑa** (*Vicugna vicugna*) +* **Inca Empire** +* **South American camelids** + +--- + +## References + +1. Fowler, M. E. (2010). *Medicine and Surgery of Camelids*. Wiley-Blackwell. +2. Wheeler, J. C. (1995). Evolution and present situation of the South American Camelidae. *Biological Journal of the Linnean Society*, 54(3), 271-295. +3. National Geographic. "Llamas: Profile and Facts." +4. Smithsonian National Zoo. "Llama Profile." +5. International Llama Association. [https://www.internationalllama.org/](https://www.internationalllama.org/) + +--- + +## External Links + +* [International Llama Registry](https://www.lamaregistry.com/) +* [North American Camelid Studies Program](https://www.camelidstudies.org/) +* [American Llama Show Association](https://www.americanllamashows.com/) diff --git a/end-to-end-use-cases/powerpoint-to-voiceover-transcript/knowledge_enhanced_workflow.ipynb b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/knowledge_enhanced_workflow.ipynb new file mode 100644 index 000000000..947a4852c --- /dev/null +++ b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/knowledge_enhanced_workflow.ipynb @@ -0,0 +1,1522 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "0e4aad87-ddd4-4b5e-a83f-63a75bd89f38", + "metadata": {}, + "source": [ + "# PowerPoint to Knowledge-Grounded & Narrative-Aware Voiceover Transcript Generator\n", + "\n", + "This cookbook demonstrates the complete workflow for converting PowerPoint presentations into AI-generated voiceover transcripts with retrieval augmentation and narrative continuity features, powered by Llama 4 Maverick's vision capabilities through the Llama API.\n", + "\n", + "## Overview\n", + "\n", + "This workflow performs the following operations:\n", + "\n", + "1. **Content Extraction**: Pulls speaker notes and visual elements from PowerPoint slides\n", + "2. **Knowledge Base Integration**: Leverages external knowledge sources to enhance transcript quality (For the purposes of this cookbook, the knowledge_base folder)\n", + "3. **Image Conversion**: Transforms slides into high-quality images for analysis by Llama 4 Maverick.\n", + "4. **Context-Aware Generation**: Creates natural-sounding voiceover content with narrative continuity and knowledge-based insights\n", + " - **Speech Optimization**: Converts numbers, technical terms, and abbreviations to spoken form\n", + "6. **Results Export**: Saves transcripts, context information, and knowledge usage statistics in multiple formats\n", + "\n", + "## Key Features\n", + "\n", + "- **Knowledge Base Integration**: Automatically retrieves relevant information from markdown knowledge files\n", + "- **Unified Processor**: Single class handles both standard and narrative-aware processing with knowledge enhancement\n", + "- **Configurable Context**: Adjustable context window for narrative continuity and knowledge retrieval\n", + "- **Mode Selection**: Toggle between standard and narrative processing with optional knowledge integration\n", + "- **Performance Optimization**: Caching and lazy loading for efficient knowledge retrieval\n", + "\n", + "## Prerequisites\n", + "\n", + "Before running this notebook, ensure you have:\n", + "- Created a `.env` file with your `LLAMA_API_KEY`\n", + "- Updated `config.yaml` with your presentation file path\n", + "- Set up your knowledge base directory with relevant markdown files (This cookbook only supports markdown format at the moment)\n", + "- Enabled knowledge base features in `config.yaml` (set `knowledge.enabled: true`)\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "b3367845-76ad-4493-a312-f80f00fad029", + "metadata": {}, + "source": [ + "\n", + "## Setup and Configuration\n", + "\n", + "Import required libraries and load environment configuration." + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "id": "37249034-75bf-41bd-b640-eb6345435f47", + "metadata": {}, + "outputs": [], + "source": [ + "# Import required libraries\n", + "import pandas as pd\n", + "import os\n", + "from pathlib import Path\n", + "from dotenv import load_dotenv\n", + "import matplotlib.pyplot as plt\n", + "from IPython.display import display" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "id": "0aedb2c5-5762-43ae-826b-fdb45ff642f5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SUCCESS: Environment loaded successfully!\n", + "SUCCESS: GROQ API key found\n" + ] + } + ], + "source": [ + "# Load environment variables from .env file\n", + "load_dotenv()\n", + "\n", + "# Verify setup\n", + "if os.getenv('GROQ_API_KEY'):\n", + " print(\"SUCCESS: Environment loaded successfully!\")\n", + " print(\"SUCCESS: GROQ API key found\")\n", + "else:\n", + " print(\"WARNING: GROQ_API_KEY not found in .env file\")\n", + " print(\"Please check your .env file and add your API key\")" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "id": "0563bb13-9dbd-4a29-9b3b-f565befd2001", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SUCCESS: All modules imported successfully!\n", + "- PPTX processor ready\n", + "- Unified transcript generator ready\n", + "- Configuration manager ready\n", + "- Visualization generator ready\n", + "- FAISS knowledge base components ready\n" + ] + } + ], + "source": [ + "# Import custom modules\n", + "try:\n", + " from src.core.pptx_processor import extract_pptx_notes, pptx_to_images_and_notes\n", + " from src.processors.unified_transcript_generator import (\n", + " UnifiedTranscriptProcessor,\n", + " process_slides,\n", + " process_slides_with_narrative\n", + " )\n", + " from src.config.settings import load_config, get_config, is_knowledge_enabled\n", + " from src.utils.visualization import display_slide_grid, display_slide_preview\n", + "\n", + " print(\"SUCCESS: All modules imported successfully!\")\n", + " print(\"- PPTX processor ready\")\n", + " print(\"- Unified transcript generator ready\")\n", + " print(\"- Configuration manager ready\")\n", + " print(\"- Visualization generator ready\")\n", + "\n", + " # Try to import knowledge base modules\n", + " knowledge_available = False\n", + " try:\n", + " from src.knowledge.faiss_knowledge import FAISSKnowledgeManager\n", + " from src.knowledge.context_manager import ContextManager\n", + " knowledge_available = True\n", + " print(\"- FAISS knowledge base components ready\")\n", + " except ImportError as e:\n", + " print(f\"- WARNING: Knowledge base components not available: {e}\")\n", + "\n", + "except ImportError as e:\n", + " print(f\"ERROR: Import error: {e}\")\n", + " print(\"Make sure you're running from the project root directory\")" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "id": "cafe366c-3ec6-47c7-8e70-ed69e89ae137", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "SUCCESS: Configuration loaded successfully!\n", + "\n", + "Current Settings:\n", + "- Llama Model: meta-llama/llama-4-maverick-17b-128e-instruct\n", + "- Image DPI: 200\n", + "- Image Format: png\n", + "- Context Window: 5 previous slides (default)\n", + "- Knowledge Base: ENABLED\n", + " - Knowledge Directory: knowledge_base\n", + " - Context Strategy: combined\n", + " - Knowledge Weight: 0.3\n", + " - Embedding Model: all-MiniLM-L6-v2\n" + ] + } + ], + "source": [ + "# Load configuration\n", + "config = load_config()\n", + "print(\"\\nSUCCESS: Configuration loaded successfully!\")\n", + "print(\"\\nCurrent Settings:\")\n", + "print(f\"- Llama Model: {config['api']['groq_model']}\")\n", + "print(f\"- Image DPI: {config['processing']['default_dpi']}\")\n", + "print(f\"- Image Format: {config['processing']['default_format']}\")\n", + "print(f\"- Context Window: 5 previous slides (default)\")\n", + "\n", + "# Display knowledge base configuration\n", + "knowledge_enabled = is_knowledge_enabled()\n", + "print(f\"- Knowledge Base: {'ENABLED' if knowledge_enabled else 'DISABLED'}\")\n", + "\n", + "if knowledge_enabled:\n", + " knowledge_config = config.get('knowledge', {})\n", + " print(f\" - Knowledge Directory: {knowledge_config.get('knowledge_base_dir', 'knowledge_base')}\")\n", + " print(f\" - Context Strategy: {knowledge_config.get('context', {}).get('strategy', 'combined')}\")\n", + " print(f\" - Knowledge Weight: {knowledge_config.get('context', {}).get('knowledge_weight', 0.3)}\")\n", + " print(f\" - Embedding Model: {knowledge_config.get('embedding', {}).get('model_name', 'all-MiniLM-L6-v2')}\")" + ] + }, + { + "cell_type": "markdown", + "id": "dd800f7d-3ae5-4291-89d4-32d5cfca6cc7", + "metadata": {}, + "source": [ + "#### Don't forget to update the config file with your pptx file name!\n" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "id": "58642e4d-cb6f-4e6f-8543-c1290a0e258d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File Configuration:\n", + "- Input File: input/All About Llamas.pptx\n", + "- Output Directory: output/\n", + "- SUCCESS: Input file found (10.8 MB)\n", + "- SUCCESS: Output directory ready\n" + ] + } + ], + "source": [ + "# Configure file paths from config.yaml\n", + "pptx_file = config['current_project']['pptx_file'] + config['current_project']['extension']\n", + "output_dir = config['current_project']['output_dir']\n", + "\n", + "print(\"File Configuration:\")\n", + "print(f\"- Input File: {pptx_file}\")\n", + "print(f\"- Output Directory: {output_dir}\")\n", + "\n", + "# Verify input file exists\n", + "if Path(pptx_file).exists():\n", + " file_size = Path(pptx_file).stat().st_size / 1024 / 1024\n", + " print(f\"- SUCCESS: Input file found ({file_size:.1f} MB)\")\n", + "else:\n", + " print(f\"- ERROR: Input file not found: {pptx_file}\")\n", + " print(\" Please update the 'pptx_file' path in config.yaml\")\n", + "\n", + "# Create output directory if needed\n", + "Path(output_dir).mkdir(parents=True, exist_ok=True)\n", + "print(f\"- SUCCESS: Output directory ready\")" + ] + }, + { + "cell_type": "markdown", + "id": "09cf9962-a9f0-4362-a72b-7c11f50772bb", + "metadata": {}, + "source": [ + "## Knowledge Base Setup and Validation\n", + "\n", + "Set up and validate the knowledge base if enabled in configuration.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "id": "e7666fa8-a4a4-4e7d-bf5d-e34ca992f9b0", + "metadata": {}, + "outputs": [], + "source": [ + "def setup_knowledge_base(config):\n", + " \"\"\"Setup and validate knowledge base if enabled.\"\"\"\n", + " knowledge_enabled = is_knowledge_enabled()\n", + "\n", + " if not knowledge_enabled:\n", + " print(\"Knowledge base is disabled in configuration\")\n", + " return None, None\n", + "\n", + " if not knowledge_available:\n", + " print(\"WARNING: Knowledge base is enabled but components are not available\")\n", + " return None, None\n", + "\n", + " print(\"Setting up knowledge base...\")\n", + "\n", + " knowledge_config = config.get('knowledge', {})\n", + " knowledge_base_dir = Path(knowledge_config.get('knowledge_base_dir', 'knowledge_base'))\n", + "\n", + " # Check if knowledge base directory exists and has content\n", + " if not knowledge_base_dir.exists():\n", + " print(f\"Creating knowledge base directory: {knowledge_base_dir}\")\n", + " knowledge_base_dir.mkdir(parents=True, exist_ok=True)\n", + "\n", + " # Create sample knowledge base files for demonstration\n", + " create_sample_knowledge_base(knowledge_base_dir)\n", + "\n", + " # List existing knowledge files\n", + " md_files = list(knowledge_base_dir.rglob(\"*.md\"))\n", + "\n", + " print(f\"Knowledge Base Status:\")\n", + " print(f\"- Directory: {knowledge_base_dir}\")\n", + " print(f\"- Markdown files found: {len(md_files)}\")\n", + "\n", + " if md_files:\n", + " print(\"- Available knowledge files:\")\n", + " for md_file in md_files:\n", + " file_size = md_file.stat().st_size\n", + " print(f\" - {md_file.name} ({file_size} bytes)\")\n", + " else:\n", + " print(\"- No knowledge files found\")\n", + " print(\"- Creating sample knowledge base for demonstration...\")\n", + " create_sample_knowledge_base(knowledge_base_dir)\n", + " md_files = list(knowledge_base_dir.rglob(\"*.md\"))\n", + " print(f\"- Created {len(md_files)} sample knowledge files\")\n", + "\n", + " # Initialize knowledge manager\n", + " try:\n", + " # Get FAISS configuration from config\n", + " vector_config = knowledge_config.get('vector_store', {})\n", + " embedding_config = knowledge_config.get('embedding', {})\n", + "\n", + " # Initialize FAISS knowledge manager with configuration\n", + " knowledge_manager = FAISSKnowledgeManager(\n", + " knowledge_base_dir=str(knowledge_base_dir),\n", + " index_type=vector_config.get('index_type', 'flat'),\n", + " embedding_model=embedding_config.get('model_name', 'all-MiniLM-L6-v2'),\n", + " use_gpu=vector_config.get('use_gpu', False)\n", + " )\n", + " knowledge_manager.initialize()\n", + "\n", + " context_manager = ContextManager()\n", + "\n", + " # Display knowledge base statistics\n", + " stats = knowledge_manager.get_stats()\n", + " print(f\"- Knowledge chunks loaded: {stats['total_chunks']}\")\n", + " print(f\"- Index type: {stats['index_type']}\")\n", + " print(f\"- Embedding model: {stats['embedding_model']}\")\n", + " print(f\"- Model loaded: {stats['model_loaded']}\")\n", + " print(f\"- Index loaded: {stats['index_loaded']}\")\n", + "\n", + " return knowledge_manager, context_manager\n", + "\n", + " except Exception as e:\n", + " print(f\"ERROR: Failed to initialize knowledge base: {e}\")\n", + " import traceback\n", + " traceback.print_exc()\n", + " return None, None\n" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "id": "91f8fd6d-c142-4eb8-a72d-6640a7423af8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setting up knowledge base...\n", + "Knowledge Base Status:\n", + "- Directory: knowledge_base\n", + "- Markdown files found: 2\n", + "- Available knowledge files:\n", + " - llama diet.md (5762 bytes)\n", + " - llamas.md (7567 bytes)\n", + "- Knowledge chunks loaded: 19\n", + "- Index type: flat\n", + "- Embedding model: all-MiniLM-L6-v2\n", + "- Model loaded: True\n", + "- Index loaded: True\n" + ] + } + ], + "source": [ + "# Setup knowledge base\n", + "knowledge_manager, context_manager = setup_knowledge_base(config)" + ] + }, + { + "cell_type": "markdown", + "id": "85c830ee-c91f-452b-987e-1652efeb326a", + "metadata": {}, + "source": [ + "## Processing Mode Configuration\n", + "\n", + "Choose your processing mode and configure the processor with knowledge integration.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "id": "290d9c7e-19db-44e0-b9c3-8973674b1010", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing Mode Configuration:\n", + "- Mode: NARRATIVE CONTINUITY\n", + "- Context Window: 5 previous slides\n", + "- Knowledge Integration: ENABLED\n", + " - Knowledge chunks available: 19\n", + " - Search strategy: combined\n" + ] + } + ], + "source": [ + "# Configure processing mode with knowledge integration\n", + "\n", + "USE_NARRATIVE = True # Set to False for standard processing, True for narrative continuity\n", + "CONTEXT_WINDOW_SIZE = 5 # Number of previous slides to use as context (only used when USE_NARRATIVE=True)\n", + "ENABLE_KNOWLEDGE = True # Set to False to disable knowledge base integration\n", + "\n", + "print(\"Processing Mode Configuration:\")\n", + "if USE_NARRATIVE:\n", + " print(f\"- Mode: NARRATIVE CONTINUITY\")\n", + " print(f\"- Context Window: {CONTEXT_WINDOW_SIZE} previous slides\")\n", + "else:\n", + " print(f\"- Mode: STANDARD PROCESSING\")\n", + " print(f\"- Features: Independent slide processing, faster execution\")\n", + "\n", + "print(f\"- Knowledge Integration: {'ENABLED' if ENABLE_KNOWLEDGE else 'DISABLED'}\")\n", + "\n", + "if ENABLE_KNOWLEDGE and knowledge_manager:\n", + " print(f\" - Knowledge chunks available: {knowledge_manager.get_stats()['total_chunks']}\")\n", + " print(f\" - Search strategy: {config.get('knowledge', {}).get('context', {}).get('strategy', 'combined')}\")\n", + "\n", + "# Initialize the unified processor with knowledge integration\n", + "processor = UnifiedTranscriptProcessor(\n", + " use_narrative=USE_NARRATIVE,\n", + " context_window_size=CONTEXT_WINDOW_SIZE,\n", + " enable_knowledge=ENABLE_KNOWLEDGE\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "2cd7bd6d-364a-4350-9f38-b988323fcdae", + "metadata": {}, + "source": [ + "## Processing Pipeline\n", + "\n", + "Execute the main processing pipeline in three key steps.\n" + ] + }, + { + "cell_type": "markdown", + "id": "1ce1e223-faf0-4ab3-996d-a451bed30fc9", + "metadata": {}, + "source": [ + "### Step 1: Extract Content and Convert to Images\n", + "\n", + "Extract speaker notes and slide text, then convert the presentation to high-quality images for AI analysis.\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "id": "db3ad12e-03d8-45cb-9999-b167d2ab93c5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PROCESSING: Converting PPTX to images and extracting notes...\n", + "Processing: All About Llamas.pptx\n", + "Extracting speaker notes...\n", + "Found notes on 10 of 10 slides\n", + "Notes df saved to: /Users/yucedincer/Desktop/Projects/llama-cookbook/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/All About Llamas_notes.csv\n", + "Converting to PDF...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n", + "To disable this warning, you can either:\n", + "\t- Avoid using `tokenizers` before the fork if possible\n", + "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Converting to PNG images at 200 DPI...\n", + "\n", + "Successfully processed 10 slides\n", + "Images saved to: /Users/yucedincer/Desktop/Projects/llama-cookbook/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output\n", + "\n", + "SUCCESS: Processing completed successfully!\n", + "- Processed 10 slides\n", + "- Images saved to: /Users/yucedincer/Desktop/Projects/llama-cookbook/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output\n", + "- Found notes on 10 slides\n", + "- DataFrame shape: (10, 8)\n", + "\n", + "Sample Data (First 5 slides):\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
slide_numberslide_titlehas_notesnotes_word_countslide_text_word_count
01Llamas: Fascinating Animals of the AndesTrue3414
12Introduction to LlamasTrue2825
23Physical CharacteristicsTrue2833
34Diet & HabitatTrue2423
45Behavior & Social StructureTrue3130
\n", + "
" + ], + "text/plain": [ + " slide_number slide_title has_notes \\\n", + "0 1 Llamas: Fascinating Animals of the Andes True \n", + "1 2 Introduction to Llamas True \n", + "2 3 Physical Characteristics True \n", + "3 4 Diet & Habitat True \n", + "4 5 Behavior & Social Structure True \n", + "\n", + " notes_word_count slide_text_word_count \n", + "0 34 14 \n", + "1 28 25 \n", + "2 28 33 \n", + "3 24 23 \n", + "4 31 30 " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Displaying first 6 of 10 slide images:\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print(\"PROCESSING: Converting PPTX to images and extracting notes...\")\n", + "\n", + "result = pptx_to_images_and_notes(\n", + " pptx_path=pptx_file,\n", + " output_dir=output_dir,\n", + " extract_notes=True\n", + ")\n", + "\n", + "notes_df = result['notes_df']\n", + "image_files = result['image_files']\n", + "\n", + "print(f\"\\nSUCCESS: Processing completed successfully!\")\n", + "print(f\"- Processed {len(image_files)} slides\")\n", + "print(f\"- Images saved to: {result['output_dir']}\")\n", + "print(f\"- Found notes on {notes_df['has_notes'].sum()} slides\")\n", + "print(f\"- DataFrame shape: {notes_df.shape}\")\n", + "\n", + "# Show sample data\n", + "print(\"\\nSample Data (First 5 slides):\")\n", + "display(notes_df[['slide_number', 'slide_title', 'has_notes', 'notes_word_count', 'slide_text_word_count']].head())\n", + "\n", + "# Preview only the first 6 slide images\n", + "display_slide_preview(image_files, num_slides=6, max_cols=3)" + ] + }, + { + "cell_type": "markdown", + "id": "bf5e8a23-c046-45f5-a7cd-14baa70854c2", + "metadata": {}, + "source": [ + "### Step 2: Generate Knowledge-Enhanced Narrative-Aware AI Transcripts\n", + "\n", + "Use the Llama vision model to analyze each slide image and generate natural-sounding voiceover transcripts with both narrative continuity and knowledge base enhancement.\n", + "\n", + "This enhanced process:\n", + "- Analyzes slide visual content using AI vision\n", + "- Retrieves relevant information from the knowledge base\n", + "- Uses transcripts from previous slides as context\n", + "- Combines slide content, speaker notes, and knowledge insights\n", + "- Generates speech-optimized transcripts with smooth transitions and enhanced accuracy\n", + "- Maintains consistent terminology throughout the presentation\n", + "- Converts numbers and technical terms to spoken form\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "id": "2c56a543-4ad7-4276-99d2-0be5c198782c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PROCESSING: Starting AI transcript generation with knowledge-enhanced unified processor...\n", + "- Processing 10 slides\n", + "- Using model: meta-llama/llama-4-maverick-17b-128e-instruct\n", + "- Mode: Narrative Continuity\n", + "- Knowledge Integration: ENABLED\n", + "- Context window: 5 previous slides\n", + "- Using previous transcripts as context for narrative continuity\n", + "- Knowledge base: 19 chunks available\n", + "- Search strategy: combined\n", + "- This may take several minutes...\n", + "Processing 10 slides with narrative continuity...\n", + "Using context window of 5 previous slides\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Processing slides: 100%|โ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆ| 10/10 [00:40<00:00, 4.01s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Context information saved to: output/narrative_context\n", + "\n", + "SUCCESS: Transcript generation completed!\n", + "- Generated 10 transcripts\n", + "- Average length: 652 characters\n", + "- Total words: 951\n", + "- Context information saved to: output/narrative_context/\n", + "- Average context slides used: 3.5\n", + "- Knowledge base integration: Active during processing\n", + "- Enhanced transcripts with domain-specific information\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "print(\"PROCESSING: Starting AI transcript generation with knowledge-enhanced unified processor...\")\n", + "print(f\"- Processing {len(notes_df)} slides\")\n", + "print(f\"- Using model: {config['api']['groq_model']}\")\n", + "print(f\"- Mode: {'Narrative Continuity' if USE_NARRATIVE else 'Standard Processing'}\")\n", + "print(f\"- Knowledge Integration: {'ENABLED' if ENABLE_KNOWLEDGE else 'DISABLED'}\")\n", + "\n", + "if USE_NARRATIVE:\n", + " print(f\"- Context window: {CONTEXT_WINDOW_SIZE} previous slides\")\n", + " print(f\"- Using previous transcripts as context for narrative continuity\")\n", + "\n", + "if ENABLE_KNOWLEDGE and knowledge_manager:\n", + " print(f\"- Knowledge base: {knowledge_manager.get_stats()['total_chunks']} chunks available\")\n", + " print(f\"- Search strategy: {config.get('knowledge', {}).get('context', {}).get('strategy', 'combined')}\")\n", + "\n", + "print(\"- This may take several minutes...\")\n", + "\n", + "# Generate transcripts using the knowledge-enhanced unified processor\n", + "processed_df = processor.process_slides_dataframe(\n", + " df=notes_df,\n", + " output_dir=output_dir,\n", + " save_context=True # Only saves context if USE_NARRATIVE=True\n", + ")\n", + "\n", + "print(f\"\\nSUCCESS: Transcript generation completed!\")\n", + "print(f\"- Generated {len(processed_df)} transcripts\")\n", + "print(f\"- Average length: {processed_df['ai_transcript'].str.len().mean():.0f} characters\")\n", + "print(f\"- Total words: {processed_df['ai_transcript'].str.split().str.len().sum():,}\")\n", + "\n", + "if USE_NARRATIVE:\n", + " print(f\"- Context information saved to: {output_dir}narrative_context/\")\n", + " print(f\"- Average context slides used: {processed_df['context_slides_used'].mean():.1f}\")\n", + "\n", + "if ENABLE_KNOWLEDGE and knowledge_manager:\n", + " print(f\"- Knowledge base integration: Active during processing\")\n", + " print(f\"- Enhanced transcripts with domain-specific information\")" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "id": "2cd0590b-66af-4653-a3e1-5d4eb9a845af", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "KNOWLEDGE BASE SUMMARY\n", + "==================================================\n", + "Total Chunks: 19\n", + "Index Type: FLAT\n", + "Embedding Model: all-MiniLM-L6-v2\n", + "Content Size: 0.0 MB\n", + "Avg Chunk Size: 673 characters\n", + "\n", + "Knowledge Sources (2):\n", + " โ€ข llama diet.md\n", + " โ€ข llamas.md\n", + "\n", + "Knowledge Sections (18):\n", + " โ€ข Behavior and Social Structure\n", + " โ€ข Conservation Status\n", + " โ€ข Diet and Digestion\n", + " โ€ข Distribution and Habitat\n", + " โ€ข Etymology\n", + " โ€ข External Links\n", + " โ€ข Llamas vs. Alpacas\n", + " โ€ข Physical Description\n", + " โ€ข Reproduction and Lifespan\n", + " โ€ข Taxonomy\n", + " ... and 8 more\n", + "==================================================\n", + "Displaying first 5 slide transcripts with knowledge enhancement\n", + "\n", + "====================================================================================================\n", + "\n", + "SLIDE 1 - Llamas: Fascinating Animals of the Andes\n", + "================================================================================\n", + "\n", + "TRANSCRIPT:\n", + "\"Llamas are unique animals deeply intertwined with human history and culture in the Andes Mountains of South America. Native to this region, they are primarily found in Peru, Bolivia, Ecuador, Chile, and Argentina. Llamas were domesticated in the Andes around four thousand to five thousand years ago and played a central role in the development of early Andean civilizations, including the Inca Empire. They were used for transportation and other purposes. Today, llamas are not endangered and are widely bred and maintained both in South America and globally. Let's discover why they're so remarkable.\"\n", + "\n", + "KNOWLEDGE ENHANCEMENT:\n", + " Search Query: \"Llamas: Fascinating Animals of the Andes Welcome everyone! Today, we're going to explore the fascina...\"\n", + " Chunks Found: 5\n", + "\n", + "KNOWLEDGE CHUNKS USED:\n", + "\n", + " Chunk 1:\n", + " Source: llamas.md\n", + " Section: Distribution and Habitat\n", + " Similarity Score: 0.779\n", + " Content: \"Llamas are native to the **Andes Mountains** in South America. Today, they are primarily found in:\n", + "\n", + "* **Peru**\n", + "* **Bolivia**\n", + "* **Ecuador**\n", + "* **Chile**\n", + "* **Argentina**\n", + "\n", + "Due to their adaptability, llama...\"\n", + "\n", + " Chunk 2:\n", + " Source: llamas.md\n", + " Section: Domestication and Historical Use\n", + " Similarity Score: 0.739\n", + " Content: \"Llamas were domesticated in the Andes around 4,000โ€“5,000 years ago. They played a central role in the development of early Andean civilizations, including the Inca Empire. Uses included:\n", + "\n", + "* **Transpor...\"\n", + "\n", + " Chunk 3:\n", + " Source: llamas.md\n", + " Section: References\n", + " Similarity Score: 0.736\n", + " Content: \"1. Fowler, M. E. (2010). *Medicine and Surgery of Camelids*. Wiley-Blackwell.\n", + "2. Wheeler, J. C. (1995). Evolution and present situation of the South American Camelidae. *Biological Journal of the Linn...\"\n", + "\n", + " Chunk 4:\n", + " Source: llamas.md\n", + " Section: Llamas (*Lama glama*)\n", + " Similarity Score: 0.723\n", + " Content: \"Llamas are domesticated South American camelids, widely used as meat and pack animals by Andean cultures since the Pre-Columbian era. They are members of the biological family Camelidae, which include...\"\n", + "\n", + " Chunk 5:\n", + " Source: llamas.md\n", + " Section: Taxonomy\n", + " Similarity Score: 0.709\n", + " Content: \"* **Kingdom**: Animalia\n", + "* **Phylum**: Chordata\n", + "* **Class**: Mammalia\n", + "* **Order**: Artiodactyla\n", + "* **Family**: Camelidae\n", + "* **Genus**: *Lama*\n", + "* **Species**: *Lama glama*\n", + "\n", + "Llamas are part of the genus *La...\"\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\n", + "SLIDE 2 - Introduction to Llamas\n", + "================================================================================\n", + "\n", + "TRANSCRIPT:\n", + "\"A llama is defined as a domesticated South American camelid, with the scientific name Lama glama. Originating from the Andes Mountains in South America, llamas share their habitat with related species such as alpacas, guanacos, and vicuรฑas, which are their wild relatives. Domesticated thousands of years ago, llamas descend from wild camelids native to this region. Their history and relationship with other camelid species highlight their significance in South American culture and ecology.\"\n", + "\n", + "KNOWLEDGE ENHANCEMENT:\n", + " Search Query: \"Introduction to Llamas Llamas were domesticated thousands of years ago. They descend from wild camel...\"\n", + " Chunks Found: 5\n", + "\n", + "KNOWLEDGE CHUNKS USED:\n", + "\n", + " Chunk 1:\n", + " Source: llamas.md\n", + " Section: Llamas (*Lama glama*)\n", + " Similarity Score: 0.902\n", + " Content: \"Llamas are domesticated South American camelids, widely used as meat and pack animals by Andean cultures since the Pre-Columbian era. They are members of the biological family Camelidae, which include...\"\n", + "\n", + " Chunk 2:\n", + " Source: llamas.md\n", + " Section: References\n", + " Similarity Score: 0.819\n", + " Content: \"1. Fowler, M. E. (2010). *Medicine and Surgery of Camelids*. Wiley-Blackwell.\n", + "2. Wheeler, J. C. (1995). Evolution and present situation of the South American Camelidae. *Biological Journal of the Linn...\"\n", + "\n", + " Chunk 3:\n", + " Source: llamas.md\n", + " Section: Distribution and Habitat\n", + " Similarity Score: 0.800\n", + " Content: \"Llamas are native to the **Andes Mountains** in South America. Today, they are primarily found in:\n", + "\n", + "* **Peru**\n", + "* **Bolivia**\n", + "* **Ecuador**\n", + "* **Chile**\n", + "* **Argentina**\n", + "\n", + "Due to their adaptability, llama...\"\n", + "\n", + " Chunk 4:\n", + " Source: llamas.md\n", + " Section: Conservation Status\n", + " Similarity Score: 0.773\n", + " Content: \"Llamas are **not endangered**. They are widely bred and maintained both in South America and globally. However, genetic diversity is a concern in some isolated populations.\n", + "\n", + "Efforts exist to preserve ...\"\n", + "\n", + " Chunk 5:\n", + " Source: llamas.md\n", + " Section: Taxonomy\n", + " Similarity Score: 0.762\n", + " Content: \"* **Kingdom**: Animalia\n", + "* **Phylum**: Chordata\n", + "* **Class**: Mammalia\n", + "* **Order**: Artiodactyla\n", + "* **Family**: Camelidae\n", + "* **Genus**: *Lama*\n", + "* **Species**: *Lama glama*\n", + "\n", + "Llamas are part of the genus *La...\"\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\n", + "SLIDE 3 - Physical Characteristics\n", + "================================================================================\n", + "\n", + "TRANSCRIPT:\n", + "\"Llamas have several distinct physical characteristics that enable them to thrive in their native environments. They typically stand between five point five to six feet tall at the head and weigh between two hundred eighty to four hundred fifty pounds, or one hundred twenty-seven to two hundred four kilograms. Their coat is made of soft, woolly fiber that comes in various colors. One of their most significant adaptations is their large lungs and efficient oxygen use, which allows them to survive at high altitudes. These physical traits are crucial for their survival in harsh mountain environments, where thick coats protect them from the cold. We'll explore how these adaptations contribute to their overall hardiness in the next section.\"\n", + "\n", + "KNOWLEDGE ENHANCEMENT:\n", + " Search Query: \"Physical Characteristics Llamas are well adapted to life in harsh mountain environments, with thick ...\"\n", + " Chunks Found: 5\n", + "\n", + "KNOWLEDGE CHUNKS USED:\n", + "\n", + " Chunk 1:\n", + " Source: llamas.md\n", + " Section: Health and Care\n", + " Similarity Score: 0.731\n", + " Content: \"Llamas are hardy animals but require basic veterinary care, including:\n", + "\n", + "* **Vaccinations** (e.g., CDT: Clostridium perfringens types C and D and tetanus)\n", + "* **Regular deworming**\n", + "* **Shearing and toena...\"\n", + "\n", + " Chunk 2:\n", + " Source: llamas.md\n", + " Section: Distribution and Habitat\n", + " Similarity Score: 0.694\n", + " Content: \"Llamas are native to the **Andes Mountains** in South America. Today, they are primarily found in:\n", + "\n", + "* **Peru**\n", + "* **Bolivia**\n", + "* **Ecuador**\n", + "* **Chile**\n", + "* **Argentina**\n", + "\n", + "Due to their adaptability, llama...\"\n", + "\n", + " Chunk 3:\n", + " Source: llamas.md\n", + " Section: Conservation Status\n", + " Similarity Score: 0.665\n", + " Content: \"Llamas are **not endangered**. They are widely bred and maintained both in South America and globally. However, genetic diversity is a concern in some isolated populations.\n", + "\n", + "Efforts exist to preserve ...\"\n", + "\n", + " Chunk 4:\n", + " Source: llamas.md\n", + " Section: Behavior and Social Structure\n", + " Similarity Score: 0.660\n", + " Content: \"Llamas are social herd animals and form strong social bonds. They are generally gentle, curious, and intelligent. Key behavioral traits:\n", + "\n", + "* **Herd hierarchy**: Llamas live in hierarchical groups with ...\"\n", + "\n", + " Chunk 5:\n", + " Source: llamas.md\n", + " Section: Diet and Digestion\n", + " Similarity Score: 0.631\n", + " Content: \"Llamas are herbivorous grazers. Their natural diet includes:\n", + "\n", + "* Grasses\n", + "* Shrubs\n", + "* Lichens and mosses (in mountainous areas)\n", + "* Hay and supplemental grains (in captivity)\n", + "\n", + "They have a **three-compartme...\"\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\n", + "SLIDE 4 - Diet & Habitat\n", + "================================================================================\n", + "\n", + "TRANSCRIPT:\n", + "\"Llamas are herbivorous animals with a diet consisting of grasses, hay, grains, and leaves. They inhabit semi-arid regions and high-altitude grasslands, known as the Altiplano. These animals require regular access to clean water to thrive. Their simple yet nutritious diet makes them well-suited for regions where food resources may be limited, showcasing their adaptability to various environments.\"\n", + "\n", + "KNOWLEDGE ENHANCEMENT:\n", + " Search Query: \"Diet & Habitat Llamas have a simple but nutritious diet. Their feeding habits make them ideal animal...\"\n", + " Chunks Found: 5\n", + "\n", + "KNOWLEDGE CHUNKS USED:\n", + "\n", + " Chunk 1:\n", + " Source: llamas.md\n", + " Section: Diet and Digestion\n", + " Similarity Score: 0.857\n", + " Content: \"Llamas are herbivorous grazers. Their natural diet includes:\n", + "\n", + "* Grasses\n", + "* Shrubs\n", + "* Lichens and mosses (in mountainous areas)\n", + "* Hay and supplemental grains (in captivity)\n", + "\n", + "They have a **three-compartme...\"\n", + "\n", + " Chunk 2:\n", + " Source: llamas.md\n", + " Section: Health and Care\n", + " Similarity Score: 0.746\n", + " Content: \"Llamas are hardy animals but require basic veterinary care, including:\n", + "\n", + "* **Vaccinations** (e.g., CDT: Clostridium perfringens types C and D and tetanus)\n", + "* **Regular deworming**\n", + "* **Shearing and toena...\"\n", + "\n", + " Chunk 3:\n", + " Source: llama diet.md\n", + " Similarity Score: 0.734\n", + " Content: \"๐Ÿฆ™ Llama Diet and Digestion\n", + "Llamas (Lama glama), as members of the camelid family, are highly adapted herbivores with efficient digestive systems that enable them to survive in nutrient-sparse environm...\"\n", + "\n", + " Chunk 4:\n", + " Source: llamas.md\n", + " Section: Conservation Status\n", + " Similarity Score: 0.696\n", + " Content: \"Llamas are **not endangered**. They are widely bred and maintained both in South America and globally. However, genetic diversity is a concern in some isolated populations.\n", + "\n", + "Efforts exist to preserve ...\"\n", + "\n", + " Chunk 5:\n", + " Source: llamas.md\n", + " Section: Behavior and Social Structure\n", + " Similarity Score: 0.681\n", + " Content: \"Llamas are social herd animals and form strong social bonds. They are generally gentle, curious, and intelligent. Key behavioral traits:\n", + "\n", + "* **Herd hierarchy**: Llamas live in hierarchical groups with ...\"\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\n", + "SLIDE 5 - Behavior & Social Structure\n", + "================================================================================\n", + "\n", + "TRANSCRIPT:\n", + "\"Llamas are highly social herd animals with a sophisticated social structure. They communicate effectively through various methods, including humming, ear positioning, and body language. When it comes to defense, llamas typically spit when they feel threatened or stressed, though this behavior is often misunderstood and occurs less frequently than popularly believed. Interestingly, llamas also exhibit unique hygiene habits by creating communal dung piles. These behaviors highlight their complex social interactions and adaptability to their environments. We'll explore how these traits contribute to their overall nature and usefulness as pack animals in the next section.\"\n", + "\n", + "KNOWLEDGE ENHANCEMENT:\n", + " Search Query: \"Behavior & Social Structure Llamas have a sophisticated social structure. They communicate effective...\"\n", + " Chunks Found: 5\n", + "\n", + "KNOWLEDGE CHUNKS USED:\n", + "\n", + " Chunk 1:\n", + " Source: llamas.md\n", + " Section: Behavior and Social Structure\n", + " Similarity Score: 0.860\n", + " Content: \"Llamas are social herd animals and form strong social bonds. They are generally gentle, curious, and intelligent. Key behavioral traits:\n", + "\n", + "* **Herd hierarchy**: Llamas live in hierarchical groups with ...\"\n", + "\n", + " Chunk 2:\n", + " Source: llamas.md\n", + " Section: Llamas in Popular Culture\n", + " Similarity Score: 0.648\n", + " Content: \"Llamas have become widely recognized in popular media. Examples include:\n", + "\n", + "* **Books**: *Llama Llama* children's series by Anna Dewdney\n", + "* **Films**: *The Emperor's New Groove* (features a human transfo...\"\n", + "\n", + " Chunk 3:\n", + " Source: llamas.md\n", + " Section: Diet and Digestion\n", + " Similarity Score: 0.613\n", + " Content: \"Llamas are herbivorous grazers. Their natural diet includes:\n", + "\n", + "* Grasses\n", + "* Shrubs\n", + "* Lichens and mosses (in mountainous areas)\n", + "* Hay and supplemental grains (in captivity)\n", + "\n", + "They have a **three-compartme...\"\n", + "\n", + " Chunk 4:\n", + " Source: llamas.md\n", + " Section: Llamas (*Lama glama*)\n", + " Similarity Score: 0.593\n", + " Content: \"Llamas are domesticated South American camelids, widely used as meat and pack animals by Andean cultures since the Pre-Columbian era. They are members of the biological family Camelidae, which include...\"\n", + "\n", + " Chunk 5:\n", + " Source: llamas.md\n", + " Section: Health and Care\n", + " Similarity Score: 0.573\n", + " Content: \"Llamas are hardy animals but require basic veterinary care, including:\n", + "\n", + "* **Vaccinations** (e.g., CDT: Clostridium perfringens types C and D and tetanus)\n", + "* **Regular deworming**\n", + "* **Shearing and toena...\"\n", + "\n", + "--------------------------------------------------------------------------------\n" + ] + } + ], + "source": [ + "# Show first 5 transcripts with detailed knowledge information\n", + "\n", + "from src.utils.transcript_display import show_transcripts_with_knowledge\n", + "show_transcripts_with_knowledge(processed_df, knowledge_manager, num_slides=5)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e2d617a6-33c3-4747-86d3-5a4161aa857c", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b4dd6593-6539-4d4f-baa7-678fed43165d", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "207e169d-7668-4d75-b2d7-265504175ec7", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "25258057-dad3-4ced-adfd-8e399eb2bae6", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "b6aec6d2-f001-46a7-bf5d-2e29318d5f82", + "metadata": {}, + "source": [ + "### Step 3: Save Results\n", + "\n", + "Save results in multiple formats with knowledge integration metadata.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "id": "ff2f8de2-121b-4e98-a426-80c37cb19da1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PROCESSING: Saving knowledge-enhanced results in multiple formats...\n", + "- SUCCESS: Complete results saved to output/knowledge_enhanced_narrative_transcripts.csv\n", + "- SUCCESS: Clean transcripts saved to output/knowledge_enhanced_narrative_transcripts_clean.csv\n", + "- SUCCESS: JSON format saved to output/knowledge_enhanced_narrative_transcripts.json\n", + "- SUCCESS: Knowledge base statistics saved to output/knowledge_base_stats.json\n" + ] + } + ], + "source": [ + "print(\"PROCESSING: Saving knowledge-enhanced results in multiple formats...\")\n", + "\n", + "# Create output directory\n", + "os.makedirs(output_dir, exist_ok=True)\n", + "\n", + "# Determine file prefix based on processing mode and knowledge integration\n", + "mode_prefix = \"narrative\" if USE_NARRATIVE else \"standard\"\n", + "knowledge_prefix = \"knowledge_enhanced\" if ENABLE_KNOWLEDGE else \"standard\"\n", + "file_prefix = f\"{knowledge_prefix}_{mode_prefix}\"\n", + "\n", + "# Save complete results with all metadata\n", + "output_file = f\"{output_dir}{file_prefix}_transcripts.csv\"\n", + "processed_df.to_csv(output_file, index=False)\n", + "print(f\"- SUCCESS: Complete results saved to {output_file}\")\n", + "\n", + "# Save transcript-only version for voiceover work\n", + "if USE_NARRATIVE:\n", + " transcript_only = processed_df[['slide_number', 'slide_title', 'ai_transcript', 'context_slides_used']]\n", + "else:\n", + " transcript_only = processed_df[['slide_number', 'slide_title', 'ai_transcript']]\n", + "\n", + "transcript_file = f\"{output_dir}{file_prefix}_transcripts_clean.csv\"\n", + "transcript_only.to_csv(transcript_file, index=False)\n", + "print(f\"- SUCCESS: Clean transcripts saved to {transcript_file}\")\n", + "\n", + "# Save as JSON for API integration\n", + "json_file = f\"{output_dir}{file_prefix}_transcripts.json\"\n", + "processed_df.to_json(json_file, orient='records', indent=2)\n", + "print(f\"- SUCCESS: JSON format saved to {json_file}\")\n", + "\n", + "# Save knowledge base statistics if available\n", + "if ENABLE_KNOWLEDGE and knowledge_manager:\n", + " knowledge_stats_file = f\"{output_dir}knowledge_base_stats.json\"\n", + " stats = knowledge_manager.get_stats()\n", + "\n", + " import json\n", + " with open(knowledge_stats_file, 'w') as f:\n", + " json.dump(stats, f, indent=2)\n", + " print(f\"- SUCCESS: Knowledge base statistics saved to {knowledge_stats_file}\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "d49d7cb9-e598-4511-875b-1629a4373a67", + "metadata": {}, + "source": [ + " " + ] + }, + { + "cell_type": "markdown", + "id": "4b2e1671-9495-45bb-9ac1-a02a83037eb5", + "metadata": {}, + "source": [ + "---\n", + "\n", + "# Completion Summary\n", + "\n", + "## Successfully Generated:\n", + "- **Knowledge-Enhanced Processing**: Integrated external knowledge base with transcript generation\n", + "- **Unified Processing**: Single processor handles standard, narrative, and knowledge-enhanced modes\n", + "- **Flexible Configuration**: Easy switching between processing modes and knowledge integration\n", + "- **Speech-Optimized Transcripts**: Natural-sounding voiceover content enhanced with domain knowledge\n", + "- **Multiple Formats**: CSV, JSON exports for different use cases\n", + "- **Context Analysis**: Detailed information about narrative flow and knowledge usage\n", + "- **Performance Optimization**: Efficient knowledge retrieval with caching and lazy loading\n", + "\n", + "## Output Files:\n", + "- `[knowledge_mode]_[narrative_mode]_transcripts.csv` - Complete dataset with metadata\n", + "- `[knowledge_mode]_[narrative_mode]_transcripts_clean.csv` - Clean transcripts for voiceover work\n", + "- `[knowledge_mode]_[narrative_mode]_transcripts.json` - JSON format for API integration\n", + "- `knowledge_base_stats.json` - Knowledge base usage statistics\n", + "- `narrative_context/` - Context analysis files (narrative mode only)\n", + "- Individual slide images in PNG/JPEG format\n", + "\n", + "## Processing Modes:\n", + "\n", + "### Standard Mode (`USE_NARRATIVE = False`, `ENABLE_KNOWLEDGE = False`)\n", + "- **Best for**: Simple presentations, quick processing, independent slides\n", + "- **Features**: Fast execution, no context dependencies\n", + "- **Use cases**: Training materials, product demos, standalone slides\n", + "\n", + "### Knowledge-Enhanced Standard Mode (`USE_NARRATIVE = False`, `ENABLE_KNOWLEDGE = True`)\n", + "- **Best for**: Technical presentations requiring domain expertise\n", + "- **Features**: Domain knowledge integration, improved accuracy\n", + "- **Use cases**: Technical documentation, educational materials, expert presentations\n", + "\n", + "### Narrative Mode (`USE_NARRATIVE = True`, `ENABLE_KNOWLEDGE = False`)\n", + "- **Best for**: Story-driven presentations, complex topics, educational content\n", + "- **Features**: Context awareness, smooth transitions, terminology consistency\n", + "- **Use cases**: Conference talks, educational courses, marketing presentations\n", + "\n", + "### Knowledge-Enhanced Narrative Mode (`USE_NARRATIVE = True`, `ENABLE_KNOWLEDGE = True`)\n", + "- **Best for**: Complex educational content requiring both continuity and expertise\n", + "- **Features**: Full context awareness, domain knowledge, smooth transitions, enhanced accuracy\n", + "- **Use cases**: Advanced training, academic presentations, expert-level educational content\n", + "\n", + "## Knowledge Base Features:\n", + "\n", + "### Automatic Knowledge Retrieval\n", + "- **Semantic Search**: Uses embedding models to find relevant knowledge chunks\n", + "- **Context Integration**: Seamlessly blends knowledge with slide content and speaker notes\n", + "- **Fallback Mechanisms**: Graceful degradation if knowledge components fail\n", + "\n", + "### Performance Optimization\n", + "- **Caching**: Stores embeddings and search results for faster processing\n", + "- **Lazy Loading**: Loads knowledge components only when needed\n", + "- **Memory Management**: Efficient memory usage with configurable limits\n", + "\n", + "### Configuration Options\n", + "- **Search Strategy**: Choose between knowledge-only, narrative-priority, or combined approaches\n", + "- **Knowledge Weight**: Adjust the influence of knowledge base content\n", + "- **Similarity Threshold**: Control the relevance threshold for knowledge retrieval\n", + "\n", + "## Next Steps:\n", + "1. **Review** generated transcripts for accuracy, flow, and knowledge integration quality\n", + "2. **Customize** knowledge base with domain-specific content for your presentations\n", + "3. **Tune** knowledge integration parameters for optimal results\n", + "4. **Edit** any content that needs refinement\n", + "5. **Create** voiceover recordings or use TTS systems\n", + "6. **Integrate** JSON data into your video production workflow\n", + "7. **Experiment** with different processing modes and knowledge settings\n", + "\n", + "## Tips for Better Results:\n", + "\n", + "### Knowledge Base Optimization\n", + "- **Rich Content**: Include comprehensive, well-structured markdown files in your knowledge base\n", + "- **Relevant Topics**: Ensure knowledge base content aligns with your presentation topics\n", + "- **Clear Structure**: Use proper markdown headers and sections for better chunk extraction\n", + "- **Regular Updates**: Keep knowledge base content current and accurate\n", + "\n", + "### Processing Mode Selection\n", + "- **Simple Presentations**: Use standard mode for quick, independent slide processing\n", + "- **Technical Content**: Enable knowledge integration for domain-specific accuracy\n", + "- **Story-Driven Content**: Use narrative mode for presentations with logical flow\n", + "- **Complex Educational Material**: Combine both narrative and knowledge features\n", + "\n", + "### Configuration Tuning\n", + "- **Context Window**: Adjust context window size (3-7 slides) based on presentation complexity\n", + "- **Knowledge Weight**: Fine-tune knowledge influence (0.1-0.5) based on content needs\n", + "- **Search Parameters**: Adjust similarity threshold and top-k values for optimal knowledge retrieval\n", + "- **Consistent Style**: Maintain consistent formatting across your presentation\n", + "\n", + "### Performance Considerations\n", + "- **Memory Usage**: Monitor knowledge base memory consumption for large knowledge bases\n", + "- **Processing Time**: Knowledge integration adds processing time but improves quality\n", + "- **Caching**: Enable caching for repeated processing of the same presentations\n", + "- **Batch Processing**: Process multiple presentations efficiently with shared knowledge base\n", + "\n", + "---\n", + "\n", + "## Advanced Features\n", + "\n", + "### Custom Knowledge Base Creation\n", + "Create domain-specific knowledge bases by:\n", + "1. **Organizing Content**: Structure markdown files by topic, domain, or presentation type\n", + "2. **Using Headers**: Employ clear markdown headers for better chunk extraction\n", + "3. **Including Examples**: Add concrete examples and case studies\n", + "4. **Maintaining Quality**: Ensure accuracy and relevance of knowledge content\n", + "\n", + "### Integration with Existing Workflows\n", + "- **API Integration**: Use JSON output for seamless integration with video production tools\n", + "- **Batch Processing**: Process multiple presentations with shared knowledge bases\n", + "- **Custom Prompts**: Modify system prompts for specific use cases or audiences\n", + "- **Quality Assurance**: Implement review workflows for generated transcripts\n", + "\n", + "### Troubleshooting Common Issues\n", + "- **Knowledge Base Not Loading**: Check file paths and permissions\n", + "- **Poor Knowledge Retrieval**: Adjust similarity thresholds and search parameters\n", + "- **Memory Issues**: Reduce knowledge base size or enable lazy loading\n", + "- **Processing Errors**: Enable graceful degradation for robust processing\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "365e0d35-3a76-4dbf-b83f-5f43b7613e3b", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fb21e0eb-6534-4a74-a8be-11585c5816ea", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2f267a58-d43e-4a4c-96e9-7875754f1b80", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b3a09ab5-3bff-49e0-8ad3-75dc8153a9f0", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a964a651-8a63-4d20-bc9c-49a043a8cf64", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ff14ceca-df4a-4ea5-8da1-468be8367e07", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5778eee0-ee4f-421b-81a3-a74f13b43d36", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "787e632c-9866-4283-82b0-c26d101a1020", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "52aaaa68-1553-4bd6-b2bd-25604f4515c2", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "82861c16-c84e-401f-94a4-343512b29bf6", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c464ba5b-8c55-45d3-be5c-2f2258ea327f", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0af5695f-f436-4652-82bd-233b014d3a15", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f29420c4-40c9-48e5-9331-e5b487fb084e", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ed3bae75-4ed0-4742-81af-2b0f155de947", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a24c87dd-97b7-434a-b669-471f5dc3af29", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "54a23f65-207d-476c-9aac-ea61f5af6804", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e7493249-d0e4-4ef9-bdf4-fffea7f9de70", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2596be10-0ff9-4440-9385-dd135fc3a633", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "01fd46be-46b9-4fcf-b4ed-2cc31f5fed07", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a203ca3d-92ba-40f6-be14-fa1943531a3d", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "pptxTTS", + "language": "python", + "name": "pptxtts" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/end-to-end-use-cases/powerpoint-to-voiceover-transcript/narrative_continuity_workflow.ipynb b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/narrative_continuity_workflow.ipynb new file mode 100644 index 000000000..837bb61ee --- /dev/null +++ b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/narrative_continuity_workflow.ipynb @@ -0,0 +1,879 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "6c33ba3a", + "metadata": {}, + "source": [ + "# PowerPoint to Narrative-Aware Voiceover Transcript Generator\n", + "\n", + "This notebook demonstrates the complete workflow for converting PowerPoint presentations into AI-generated voiceover transcripts using the unified transcript processor with Llama 4 Maverick through the Llama API.\n", + "\n", + "## Overview\n", + "\n", + "This unified workflow performs the following operations:\n", + "\n", + "1. **Content Extraction**: Pulls speaker notes and visual elements from PowerPoint slides\n", + "2. **Image Conversion**: Transforms slides into high-quality images for AI analysis\n", + "3. **Flexible Processing**: Choose between standard or narrative-aware processing modes\n", + "4. **Transcript Generation**: Creates natural-sounding voiceover content with optional narrative continuity\n", + "5. **Speech Optimization**: Converts numbers, technical terms, and abbreviations to spoken form\n", + "6. **Results Export**: Saves transcripts and context information in multiple formats\n", + "\n", + "## Key Features\n", + "\n", + "- **Unified Processor**: Single class handles both standard and narrative-aware processing\n", + "- **Configurable Context**: Adjustable context window for narrative continuity\n", + "- **Mode Selection**: Toggle between standard and narrative processing with a simple flag\n", + "- **Backward Compatibility**: Maintains compatibility with existing workflows\n", + "\n", + "## Prerequisites\n", + "\n", + "Before running this notebook, ensure you have:\n", + "- Created a `.env` file with your `LLAMA_API_KEY`\n", + "- Updated `config.yaml` with your presentation file path\n", + "---" + ] + }, + { + "cell_type": "markdown", + "id": "d8965447", + "metadata": {}, + "source": [ + "## Setup and Configuration\n", + "\n", + "Import required libraries and load environment configuration." + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "id": "21a962b2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SUCCESS: Environment loaded successfully!\n", + "SUCCESS: GROQ API key found\n" + ] + } + ], + "source": [ + "# Import required libraries\n", + "import pandas as pd\n", + "import os\n", + "from pathlib import Path\n", + "from dotenv import load_dotenv\n", + "import matplotlib.pyplot as plt\n", + "from IPython.display import display\n", + "\n", + "# Load environment variables from .env file\n", + "load_dotenv()\n", + "\n", + "# Verify setup\n", + "if os.getenv('GROQ_API_KEY'):\n", + " print(\"SUCCESS: Environment loaded successfully!\")\n", + " print(\"SUCCESS: GROQ API key found\")\n", + "else:\n", + " print(\"WARNING: GROQ_API_KEY not found in .env file\")\n", + " print(\"Please check your .env file and add your API key\")" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "id": "71c1c8bd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SUCCESS: All modules imported successfully!\n", + "- PPTX processor ready\n", + "- Unified transcript generator ready\n", + "- Configuration manager ready\n", + "- Visualization generator ready\n" + ] + } + ], + "source": [ + "# Import custom modules\n", + "try:\n", + " from src.core.pptx_processor import extract_pptx_notes, pptx_to_images_and_notes\n", + " from src.processors.unified_transcript_generator import (\n", + " UnifiedTranscriptProcessor,\n", + " process_slides,\n", + " process_slides_with_narrative\n", + " )\n", + " from src.config.settings import load_config, get_config\n", + " from src.utils.visualization import display_slide_grid, display_slide_preview\n", + "\n", + "\n", + " print(\"SUCCESS: All modules imported successfully!\")\n", + " print(\"- PPTX processor ready\")\n", + " print(\"- Unified transcript generator ready\")\n", + " print(\"- Configuration manager ready\")\n", + " print(\"- Visualization generator ready\")\n", + "\n", + "except ImportError as e:\n", + " print(f\"ERROR: Import error: {e}\")\n", + " print(\"Make sure you're running from the project root directory\")" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "id": "53781172", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SUCCESS: Configuration loaded successfully!\n", + "\n", + "Current Settings:\n", + "- Llama Model: meta-llama/llama-4-maverick-17b-128e-instruct\n", + "- Image DPI: 200\n", + "- Image Format: png\n", + "- Context Window: 5 previous slides (default)\n" + ] + } + ], + "source": [ + "# Load and display configuration\n", + "config = load_config()\n", + "print(\"SUCCESS: Configuration loaded successfully!\")\n", + "print(\"\\nCurrent Settings:\")\n", + "print(f\"- Llama Model: {config['api']['groq_model']}\")\n", + "print(f\"- Image DPI: {config['processing']['default_dpi']}\")\n", + "print(f\"- Image Format: {config['processing']['default_format']}\")\n", + "print(f\"- Context Window: 5 previous slides (default)\")" + ] + }, + { + "cell_type": "markdown", + "id": "e11ef993-f0bc-4eba-82cb-e8d4b083196e", + "metadata": {}, + "source": [ + "#### Don't forget to update the config file with your pptx file name!" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "id": "9386e035", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File Configuration:\n", + "- Input File: input/All About Llamas.pptx\n", + "- Output Directory: output/\n", + "- SUCCESS: Input file found (10.8 MB)\n", + "- SUCCESS: Output directory ready\n" + ] + } + ], + "source": [ + "# Configure file paths from config.yaml\n", + "pptx_file = config['current_project']['pptx_file'] + config['current_project']['extension']\n", + "output_dir = config['current_project']['output_dir']\n", + "\n", + "print(\"File Configuration:\")\n", + "print(f\"- Input File: {pptx_file}\")\n", + "print(f\"- Output Directory: {output_dir}\")\n", + "\n", + "# Verify input file exists\n", + "if Path(pptx_file).exists():\n", + " file_size = Path(pptx_file).stat().st_size / 1024 / 1024\n", + " print(f\"- SUCCESS: Input file found ({file_size:.1f} MB)\")\n", + "else:\n", + " print(f\"- ERROR: Input file not found: {pptx_file}\")\n", + " print(\" Please update the 'pptx_file' path in config.yaml\")\n", + "\n", + "# Create output directory if needed\n", + "Path(output_dir).mkdir(parents=True, exist_ok=True)\n", + "print(f\"- SUCCESS: Output directory ready\")" + ] + }, + { + "cell_type": "markdown", + "id": "35a9e13a-4f85-488e-880b-62c7512d1248", + "metadata": {}, + "source": [ + "## Processing Mode Configuration\n", + "\n", + "Choose your processing mode and configure the unified processor." + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "id": "6fbfcb28-2f09-4497-8098-35cf3d62ebf3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing Mode Configuration:\n", + "- Mode: NARRATIVE CONTINUITY\n", + "- Context Window: 5 previous slides\n" + ] + } + ], + "source": [ + "# Configure processing mode\n", + "\n", + "USE_NARRATIVE = True # Set to False for standard processing, True for narrative continuity\n", + "CONTEXT_WINDOW_SIZE = 5 # Number of previous slides to use as context (only used when USE_NARRATIVE=True)\n", + "\n", + "print(\"Processing Mode Configuration:\")\n", + "if USE_NARRATIVE:\n", + " print(f\"- Mode: NARRATIVE CONTINUITY\")\n", + " print(f\"- Context Window: {CONTEXT_WINDOW_SIZE} previous slides\")\n", + "else:\n", + " print(f\"- Mode: STANDARD PROCESSING\")\n", + " print(f\"- Features: Independent slide processing, faster execution\")\n", + "\n", + "# Initialize the unified processor\n", + "processor = UnifiedTranscriptProcessor(\n", + " use_narrative=USE_NARRATIVE,\n", + " context_window_size=CONTEXT_WINDOW_SIZE\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "ea4851e6", + "metadata": {}, + "source": [ + "\n", + "## Processing Pipeline\n", + "\n", + "Execute the main processing pipeline in three key steps." + ] + }, + { + "cell_type": "markdown", + "id": "0f098fdf", + "metadata": {}, + "source": [ + "### Step 1: Extract Content and Convert to Images\n", + "\n", + "Extract speaker notes and slide text, then convert the presentation to high-quality images for AI analysis." + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "644ee94c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PROCESSING: Converting PPTX to images and extracting notes...\n", + "Processing: All About Llamas.pptx\n", + "Extracting speaker notes...\n", + "Found notes on 10 of 10 slides\n", + "Notes df saved to: /Users/yucedincer/Desktop/Projects/llama-cookbook/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/All About Llamas_notes.csv\n", + "Converting to PDF...\n", + "Converting to PNG images at 200 DPI...\n", + "\n", + "Successfully processed 10 slides\n", + "Images saved to: /Users/yucedincer/Desktop/Projects/llama-cookbook/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output\n", + "\n", + "SUCCESS: Processing completed successfully!\n", + "- Processed 10 slides\n", + "- Images saved to: /Users/yucedincer/Desktop/Projects/llama-cookbook/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output\n", + "- Found notes on 10 slides\n", + "- DataFrame shape: (10, 8)\n", + "\n", + "Sample Data (First 5 slides):\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
slide_numberslide_titlehas_notesnotes_word_countslide_text_word_count
01Llamas: Fascinating Animals of the AndesTrue3414
12Introduction to LlamasTrue2825
23Physical CharacteristicsTrue2833
34Diet & HabitatTrue2423
45Behavior & Social StructureTrue3130
\n", + "
" + ], + "text/plain": [ + " slide_number slide_title has_notes \\\n", + "0 1 Llamas: Fascinating Animals of the Andes True \n", + "1 2 Introduction to Llamas True \n", + "2 3 Physical Characteristics True \n", + "3 4 Diet & Habitat True \n", + "4 5 Behavior & Social Structure True \n", + "\n", + " notes_word_count slide_text_word_count \n", + "0 34 14 \n", + "1 28 25 \n", + "2 28 33 \n", + "3 24 23 \n", + "4 31 30 " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Displaying first 6 of 10 slide images:\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABKUAAAINCAYAAADvIszyAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs/Qe4HMd5JQyf6ckzNyfgIkcCzJkUg0RaOVnZVrQl+3P8nXctW/ZatuWk9a6jnO21JGtl5SyvIimJIsWcwACQyMAFcHOcnLr/51R3dVf39MydexEEkHXwXMxMd3WlnumqOnXe941YlmVBQ0NDQ0NDQ0NDQ0NDQ0NDQ0PjHMI4l4VpaGhoaGhoaGhoaGhoaGhoaGgQmpTS0NDQ0NDQ0NDQ0NDQ0NDQ0Djn0KSUhoaGhoaGhoaGhoaGhoaGhsY5hyalNDQ0NDQ0NDQ0NDQ0NDQ0NDTOOTQppaGhoaGhoaGhoaGhoaGhoaFxzqFJKQ0NDQ0NDQ0NDQ0NDQ0NDQ2Ncw5NSmloaGhoaGhoaGhoaGhoaGhonHNoUkpDQ0NDQ0NDQ0NDQ0NDQ0ND45xDk1IaGhoaGhoaGhoaGhoaGhoaGuccmpTSeF4gEongS1/6knh/9OhR8fnxxx9vmf573/ueSLOwsHAOa6mhoaGh8cOGHi80NDQ0NNpBjxMaGmcWmpTSuOAxPT2NX/zFX8SmTZuQTCaxdu1avOIVr8APfvCD0PQbN27E+Pg4LrvssrNaL5bxjne8AxdddBEMw8Cv//qvn9XyNDQ0NDQuzPHiC1/4Al72spdheHgYPT09uOmmm/DNb37zrJapoaGhoXHhjBP33HMPbrnlFgwODiKdTmP37t3467/+67NapobGuULsnJWkoXGW8OY3vxnVahX/8R//gW3btmFychJ33nknZmdnQ9NHo1ExwJxtVCoVscD4vd/7PT1oaGhoaJwHOF/Hi+9///uClPqzP/sz9PX14SMf+Qh+9Ed/FA888ACuvvrqs16+hoaGhsb5PU5ks1n88i//Mq644grxniTVz//8z4v3P/dzP3fWy9fQOKuwNDQuYMzPz1v8Gn/ve99rm45pvvjFL4r3R44cEZ8fe+wx9/z/+3//z9q5c6eVSqWs22+/3frIRz4i0jB/ibvvvtu69dZbRZoNGzZYv/Irv2Ll8/mO6nnbbbdZv/Zrv7bqdmpoaGhoPD/GC4lLLrnE+sAHPrDidmpoaGhoPD/GiTe+8Y3Wu971rhW3U0PjfIM239O4oNHV1SX+aNdNZdJqMDY2hje96U1iV5r24D/zMz+D973vfb40hw4dwitf+Uqxe/LEE0/g05/+tNih4I6FhoaGhsb5jwtpvDBNE7lcDgMDA6uqp4aGhobGc3uceOyxx3DvvffitttuW1U9NTTOJ2hSSuOCRiwWw0c/+lEhsaXJA22tf/d3f1c84DvFP/3TP2H79u34y7/8S+zatQvvfOc78Z73vMeX5oMf/KA4Tr9QO3fuxM0334wPfehD+NjHPoZyuXwWWqahoaGh8XwdL/7iL/4C+XweP/7jP77idmpoaGhoPHfHiQ0bNghfV9dddx1+6Zd+SZBeGhoXOjQppXHBg7sMp06dwle+8hWx68AIF9dcc40YVDrBvn37cOONN/qO0cmsij179oj85A4K/+j0kLvZR44cOaPt0dDQ0NB4/o4Xn/jEJ/CBD3wAn/nMZzAyMrLCFmpoaGhoPJfHibvvvhsPP/ww/vmf/xl/8zd/g09+8pOraKWGxvkF7ehc4zmBVColnMTy7/3vf7/YNfiDP/iDpp2J1YI71nQm+Ku/+qtN5xidQ0NDQ0PjwsD5PF586lOfEvX57Gc/i5e+9KVnpD4aGhoaGs+dcWLr1q3i9fLLLxdO2P/wD/8Qb3/7289IvTQ0fljQpJTGcxKXXHKJsAfvBBdffLHYDVFx//33+z5zh2Tv3r3YsWPHGa2nhoaGhsYPF+fLeMHd7p/+6Z8WxNRrXvOaFV2roaGhofHcHyeCoLJqtb6vNDTOJ2jzPY0LGgzP+uIXvxgf//jHhb03Ja/cYf5f/+t/4fWvf31HefzCL/wCDhw4gPe+97149tlnhelEUKL727/928KZIB0Q0mkh03/5y19e1iEh0/KPOyLT09PiPQchDQ0NDY1zi/N5vGA+P/mTPyl8kNDsY2JiQvwtLi6edrs1NDQ0NC78ceIf/uEf8NWvflWk5d+///u/C/+D73rXu0673RoaP3T8sMP/aWicDsrlsvW+973Puuaaa6ze3l4rk8lYu3btsn7v937PKhaLHYdu/epXv2rt2LHDSiaT1gtf+ELrwx/+cFPo1gcffNB62cteZnV1dVnZbNa64oorrD/90z9tWz/mEfzbvHnzWekLDQ0NDY0Lc7y47bbbQseLd7/73WetPzQ0NDQ0Lpxx4kMf+pB16aWXijr19PRYV199tfWP//iPVqPROGv9oaFxrhDhfz9sYkxDQ0NDQ0NDQ0NDQ0NDQ0ND4/kFbb6noaGhoaGhoaGhoaGhoaGhoXHOoUkpDQ0NDQ0NDQ0NDQ0NDQ0NDY1zDk1KaWhoaGhoaGhoaGhoaGhoaGicc2hSSkNDQ0NDQ0NDQ0NDQ0NDQ0PjnEOTUhoaGhoaGhoaGhoaGhoaGhoa5xyalNLQ0NDQ0NDQ0NDQ0NDQ0NDQOOeIdZqwVqud3ZpoaGhoaJwXiMfjq75WjxUaGhoazw/osUJDQ0ND40yMFVoppaGhoaGhoaGhoaGhoaGhoaFxzqFJKQ0NDQ0NDQ0NDQ0NDQ0NDQ2Ncw5NSmloaGhoaGhoaGhoaGhoaGhonHNoUkpDQ0NDQ0NDQ0NDQ0NDQ0ND45xDk1IaGhoaGmcdS0tLKBaLTcdN00Sj0Vj2esuyRB7lcnnZdPV6XeQ5MzMjPncCeV2r9Dw+PT3t1pWf5+bmxDUaGhoaGquHfL4eOXIER48excLCgjjGZzjHiE7A8SWXyy1bTjBPPtOPHTuGffv2iTxWWu7pjiuzs7NNY6C8rlQqLdsmDQ0NjedV9D31QfnQ4XnMFX74UTMizmtnS44gLETcHOSRznKKuP/L9JHQq4P5qyV5tW91zMktEglN3i5nf73CS2pfL3+Klv3kq1erGoWXEVGuDfYiy/O1oFV38SWipFGqEvgYer7puL/RiEcN3LxzEMm45m41NE4Xn//857Fhwwa89KUvdceSSCSCb3/72xgeHsbVV1/tSy/P84/v+ffpT39apLv22mub8pfpObn/x3/8R/zkT/4kvvWtb+Ftb3ub73xY/jIS1D//8z/jF37hF0SUkOB5LlD+5E/+BL//+7+PwcFBcexv//ZvRfq1a9e2zL/d+7B6aGhoaDwf8T//5/+EYRjo7u7GoUOH8N73vhcf/ehH8YEPfACZTKbldfIZSkJrcXERN910U8vnLMeHD37wg/jjP/5jkSeJn7//+78XxFBvb68gp/7wD/9Q1IWv2WzWlwcR9qwOG6/4fnx8XIxxHI/U4+p1d9xxB1796lejq6vLPT82Noa7775bjHfz8/O4+eab9dihoaHxnMaKSSnTAv71u8fwyNGFM1YJ94HqPPDbUUMi5bIP4BAWg4OB74DZ9CC3BxyHNGlbX6UY5UBwJ2S1A4XNQ5GccY94xVjOObsjvHJYNgdDSRnxY6sCmIdysnU6mYlMQTLJLiH8HhlOcqf/5YubjcckudSX2pkyoWCalNaLfo34CCv7k309sw3SeV77LLtY0T3OfZJFyOLsTnUz4XErEkFvJoZP/fINSMYTrXpIQ0OjQ1SrVbEA+OxnPysm6lNTU/iJn/gJfPGLX8SaNWvELvmDDz6IK664QiwcnnjiCWzevBlvf/vbBbn0+OOPi4XK5Zdfjk9+8pN44xvfiMOHD4tFSH9/Pz73uc8JMum2224T73fv3i3K5U7zxz72MVHejTfeiMsuu0wQZJzob9myRdQhGo2KvHnd9ddfj3w+j3vvvRdDQ0N4z3ve4y5MmJf6nKdqi2TWJz7xCXF9T0+PSP+f//mfQtWVTCbFwoft/dVf/VU8/fTT+P73vy/64ed+7ufEIurOO+8Ui7Cf/dmfFYsSDQ0Njecj+Gz9xV/8RWzdulWQUQ8//LB4bv/d3/0dKpWKeLbeddddeMc73oEnn3xSPI85LnDsIGmzbt06kQ+fs1/4wheQSqXwUz/1U/jOd76DZ599VjzH+ZxV1bYHDhwQ48hf/dVfiXGA+RcKBaGUkuWyTiSrOA7xec96PPbYY2KMetGLXiSe/adOncL69evx7ne/G9/85jdF3Tdt2oREIiHGlRe+8IWCfJqYmMAtt9yCiy66SIwTsVhMbGqwHH6enJzEC17wApHuS1/6ktjIYZq9e/eKcYtjCsesr371qyLNDTfcgFe+8pWamNLQ0LjgsToJiFy8L/MMlAz+cn/KBTbJ0C6tk16+DfsLVfsYMg+ZziN0XMpFnDea6tZcX+dPqY9Mp6ZfXd8oebn9oRTj1l0hpHw3ozm/5j4McE0t6mfnKfN32Brx2qbu8rzsH/GR19kkm3Pay8urtcp9qS+CIBIkk6y7WweSYF6feQWohKByn4wILMPpU1me7AhRhndflZZraGicQdxzzz247rrrxGSek3eSULfeeqswneAknn8khH7jN35DLEi+8pWviJ3mX/mVXxEkERcu999/vyC5Tp48KRYb//Iv/4K3vvWtuP3228V5ElIXX3yxSMcyuNggKcS8mJ4TfObHckhqERs3bhTXcYFAooznuaj5+te/3tYEkAsjLhpYPhcpXOCQeOLOOBdO11xzDUZGRvDII4+IxdNb3vIWkS/TcNFBko3lLmeWqKGhofFcBp+BVC1RGcXnI8kZKlS5AcHnM5+hfHYfP34cX/7ylwVBRPLnVa96lbheHQ/e+c53CvKHz2M+v6mY5TluBKg4ceKEIMH4DOe8kZsaJLdY7utf/3ps27ZN1IUbC6wHn+Ucjzi2sH48T+Xsj/3Yj4kNBpbxjW98A7/2a78mlFfcWKHa6amnnhJ5vO51r8PHP/5xQWSxbhwnHn30UUF6PfDAA6ItrAc3T6gIJln1zDPPiDaRjCO5tWfPHtx3332CjKKyrFMTdQ0NDY3nlFJKwkeeLCNrPZOw85eKpvZ1s+skSQtbXRRaT6G2aVY5BaWyndQt2B9uXiFmGy1yaWpjK6lweB18kqpQaiWoTGvXHrcsqTRSuKOwOsm2iv/bmvZJMtAKtVi0lW02kWVRgaXY2llUWvkUUnalTEc9pZKDSnE+k0A734i4xlCISVUDpneeNDTOPNLptJio01yCpA2VRNz9JXFEIokLDS4KqDrihP/gwYPo6+sTf7t27fKZR0jfUVzMcJeafySZqJjiDjXB3WTmy+sHBgaEfw4qpPieyiTpy4OLEl7HvJiW6qudO3cKoqkdSEqR3OION98zP5ojUv3FVy6m2AYuLriDz515klPcAeeChKQXj7PNJN00NDQ0no/gM/sNb3iDGB/4fCZ5T2KHz0qSQVQw0fybyiNuSnBzg+MIPxMklDgm8Byfp3wGkwj61Kc+JcYB+osK+gBkGiqYSEJxbKFSiiQTxx9ukJAAk76uSCwxj9HRUTFmcTOBz/vvfe97QinFZzx9YbHuHENIILF8touvrCuJJ45HLGvHjh1ijOB71oMkGNvCulAhzOtIOrHOzJvjG8umCpdtpBqM4yXbzb7S0NDQuJBxxpzlBJVF6rHllEOt0rdVVXVUJ0elI8mdZYiGMIVU2LlgXcLq1ipdu3JlnVUyqpNrfA1WyLiVldu6nzvtezcvn/lc5/CVIxVeLqmotsd/nTQoDAjXvPRNqjKp1JJmkEpKRynnqrxW3gwNDY0QcHLN3xbJJ/W5Q5KKZnuc3PPz9u3bBYnzta99TSwQuHNMookqJy4emIbmblQZcUeaE3eSR5/5zGeEuQVJJE7guYBgmTRv+K//+i9h7kCTPS5WeFzWSYL5csHBNDTfY3n84/USJJ1oqvfhD39Y7JTzei40eJwLFC6auEhgG9U284/H2S4qp7igIPlFQorEGxc/XGhoaGhoPF/BjQESUCSl+IwPPkPl85wkEFVQDDTBsYMKWT57OfclWUTlE83E6fOPylw+Wy+99FLxfOdzWH3uy40OKrRoPkdTb25IyDQ8R5KIaiU+uyXpJetFdRbHIJbJ/EmecQzhmEO/VHzOUxXF5zyv4fhD00CSSOo4wWNUP7EtzId9sX//fpEX03Jc5BjHNnFc/MEPfiDSyo0QDQ0NjQsdEatD3Scf5ETDtPDzH3kcjwqfUssTHyuuUMCJn3rMUxpxl7x1VAxX5dR8wpeP+tqUdJk6rkguq6RXTQXDESBKFKfcwp9SWF0VX1K+tlvL1LvZynH5psharuBatVzf+3Z+xtX7I8t1fVTZVxnkVIX/p6CXK/9CU/iIaunIXuiwfM7VpcCsLx3DJ/9/12GgS/uU0nh+gYqh1UKOFUFwp5oLBhJM3O3l5J67ylx80HSPx7gYoHqJaWmmwYk8VU3cqaaaiLvJVB6xDPoS4c6xVDzRBIIEF80BGb2J+XOxwOupTuLigeeozOJihtcyHRdB0rE503ExwN15mkhwAUHfH9JEgnVinflcoZkfj7NOrD8XBzzGNnAhwbrTJIN5sM3Ml8dZJhcwrBt9nNA3Ca+hGZ9cpGhoaGg8n8YKPl/5bOQ4IFU/JIOoUOIznM9Qki8893u/93v4gz/4A6FGInFDEzyau3F8YZ5yPOArySiOHdxo4LOY10h/gnzeslzpm4pk0FVXXSWUUjStYxoSWsyT5BLHB2nqx+v47GceNCvkWMCxiGWwLKqASSRxfGHevI4bGFRe8VnPurEechziK9tKB+esMxVUHBtIcrHNVG6xHI4ZvJ71Y16XXHKJ6DOt7NfQ0LjQx4pVkVK/8JE9eOTovFCV+BEWJq3ZxM9/zvXRHXqt3+RNvZ7ElP0aJLKalD4hV6v18azMIm2vCdauE3IrTLoT6dQ00fV35Dkub+VM3XUR75rm+dM3kX0yzxYDWctoUa6v8uboha2u7wQ+c8eAU6nwb5X0m+64PPe6STHQ87JRzSf9dTPt8hyWzVN4RdCfieMTv3itJqU0nnc4G6SUhoaGhsZzC+dyrCBJ9U//9E+C/H/Tm96kiRgNDQ2N59BYcRo+paRiKUhsSD9OzSRNMzklCRNfqtBrgvmLSG8ymlvb9OFqnCBZ04q4UhizJnIkzFyxY7iEi03uuB6WfE66HeLIWt7XldoK15VUC9LJZ8bWqnqtzA7dS9u3deWmlkp5DmcmtXCqxydZBWki6PMB5UvlwQuSqJgqquorCq4EOaonOBoaGhoaGhoa5xs4d2MkvNW489DQ0NDQOL+xalJKotn/kHwX9NejHg+SWP7zTk6+PMP1XIo2po0aq119myofvF46wW5diY7hJ3cccztJj6jiKIX9csVTbdoQbHs7JVaTA/aAymvFponLIEzFFlRhNV8UEIu5CjA/WRd4o6jKJPkUnqmtjFK9qjfXVSlcQ0NDQ0NDQ0PjhwhNRmloaGg8d7E6UkolTIRaKkgChJEaAdO00BW/3zzPI0hsZ9fNyqvmfIIEiyQfrE7MyhQ/VE21XAV5027w9PpMdibNyHxXuyog6TPKk1eFt8FH9EQ6JLBCSJlQs70Wn1fS9rD87ZY6+amvRjhx5JatXOQ3YVS/F/b3LcJofYqySpr7BXKUV7dsk4aGhoaGhoaGhoaGhoaGxg+ZlPIiojmfl1nHC0og4L17OTFOqA+hoAfwUI9PfuLE5yi7RV5+59/SEC5IUnhkhqRAwkmnzsgNV30VINdUgkY66baPd97hKzXPk5+DpJNK9kTaEFwiTZhJYUCJFabUEq/CWXlzdemAXLWoa2cS2hZOJ0aUPFWS0stbuaQDE0UNDQ0NDQ0NDQ0NDQ0NDY0fovmejWaiwaeCcW3SPC2MxyU0ExedgP6k/ARFuILJR1stQ46oEftUUsr20eTP0/sYpghSLP2kgyQesJkm18TM7puAaieE0wr2SVjdfcelzV8L4q9lxMGwvhfV9RrUVBennFb3bTl/W54KTDGVVPOWJKhC1AUR9r2xjzkNUL8HLe69c8pttKo209DQ0NDQ0NDQ0NDQ0NDQOK9IKc+kLsw/kEt8dEAytSMuljvXRK4sQ2x555pNAsW5Jj9EkihRyBN5qrV1mXfeFS3J621ZUKsauqokJaqcejzYF62OK5KuZfqhNcnlKyOs/6VHdaUfW5JPTnvaOl5vV8fWTWmRZ+s07Ug+NY3mpDQ0NDQ0NDQ0NDQ0NDQ0zjufUp7Sqd1i3/u8Mt9DK6pKqMqpOeJakDzzyK4gKROQKikOtwWxItO79TZF/Lwgg+ESdoHIed4Hv/pKPe4SU8GqyGKCPFzgeBPpIpVaduO9kHNh9QpBk+mjmm8neUiCp4V4q5WvruD9Wk5J54vat4KvVbNvMvu+aVpKQ0NDQ0NDQ0NDQ0NDQ+M8dHQuuQGPz/GooE58/6zMVC9c1dMyzTLn7feOjyiqlkRED6UZbjnecVfpoxBQgngSadT6taqBynuoeQT6QJqNBftHubap25yub6nYkpX1cggJMtjZvWC/2GSUPxqhavoWWgfHdLFVKe3ITVluk68w11xRLUQtrpngCuTqNIEEndIW2ceak9LQ0NDQ0NDQ0NDQ0NDQOM9IKcFK+EkocVjxLbSs+mYZEqKT61pWryPCy/FUZJjLlKNE73MkSSq1EmI41qQiEz21THU8pZPihVuekA7PVVM+lY9RFFKuqshhqXwqMJm/0q6VKtX8RJlfXeT9Gc3KJlWtFdJ4RsgTGieHDQp1iN5Kieeo5Pi/7OegSWOYiamf4AuQps2HNDQ0NDQ0NDQ0NDQ0NDQ0fvjR95T30ql2gKzxpV+xE/NwR9zheTU7NRfnFH9PPv/fQV/iMj/FN1LQJLCNT/OQ+gU+t2mjD2GWfKybFFW58h8l4xDTQI8Ia44f2Kp8v6IonDsKmripKqWw+IY+/1ut2hxaSGtSM8ycT17XykC0XcTA5aDVUhoaGhoaGhoaGhoaGhoa56X5nm0CZi/ypRNvKk+aCYrlfQ65VERH6T31jRrRL8RHuZveIVoCKhpffrbjpSayxvYtRJO1zok12wLPiRhntCeGmH9ovopCyqVc2kSO87VVIYlkPdRKhJm02e9t1Vgk4vmbsuumRCJ06uqVo5Ytr2tHh0mCS5rOSQfzfpNCSYJ5UfT8/SZfl+uPTsnO0PSakdLQ0NDQ0NDQ0NDQ0NDQOM+UUiHmVLbSyILgJQTR4k9LtCV1HIIpSARIeiWodrLZHD9R0+y3SnE4HgmPACd9R3lEW5C08AgeI0SR45JpgQh0PjLISxjedEHyhJiPOXRfp2SdV5TiIymgqOo0Dy+tv1bqtX4KiiST12ZD8HzBcmRbTDutJLuC9zaUaGqpheokwGNHEf5Wck5DQ0NDQ0NDQ0NDQ0NDQ+OHoZRqoTrxuxtSiRSpojL85FRA6WRDJWFkRD1JdjhOwN2Mm8sKq4+nhAoxr1vWvMspu5XKSuFVwoglV2TUJB5qVmb5S/UcGy2n8AnPI6CQcq63BWGmez88ojBoGwiXPFI/NxdlBAwFFR9cgTp6qiuZzv4+uCUoTuIlRelVxzbJtP1lOSkEscU+tr8XwXvQicN9r6dCPMVrTkpDQ0NDQ0NDQ0NDQ0ND4/zzKRX0MeSecP1LKTSH6szJUSQFFUatiJWmz22IgrB8PL9D8lzQL5GsWFjp0rG5NItrKtAjW3ySJCW6XuvqhiqgWvXF6al2VP9PfmbOyzdITMnz/vr6iR7V6FKSRSr5p6qc/GZ4rt8v8V1wVG9Bc0Co5x3H7SqVFfEMFanKijSp9wJtVbL3OZ53zC0dnkvpF5WQ09DQ0NDQ0NDQ0NDQ0NDQOC+UUoJk8FwPKVBJAamQkgfCyR/DCM2oOVuHgQgz1+MxNZ9WJn1udq4JYnO9w1rSxIeZit8mH7EjKyB9JQUjvrWuS7v6toYkfKSPL+eoq7Jq53g83BgxWN1gHzWpyxyzPVM1GXSVVSHEnyOSs7uHNbOJTNPJ13AFcYqjeYeQYp1FpD7ZPkEw+RVYKpXkauyEfy7PTpDvlWzcaqtqK1edp6GhoaGhoaGhcV6gXq+jVqu1PN9JgKWO3GGsYkP4XF1zNvM52+Usd38WpvdhfvIHiKBhz/vlBrXwfWsJFyGeEUy41Q6XhJFoBFEjiVi8B4nkOhjRLMxGHhHUYXHVYlZQq5qoVqPg16laM1FvNGBaFrp7R9DXvw1T+59EzLAQMSOwaibMah31Wg2NRgONhgnTSc9abL35dnSPjJ5W32hoPF+xSkfnng8morWJ1OmQLSH5+1Qs4Wklwvw/STRH71NIMcXHVJO6pkV54WaMwbb7VUieA++wtoRHwGtXhndMLdNTb63Mj1RzfaXqKNRJulMGySS47tKDxJ8/L7U2PrVZmMJMkFieMqqpPU2kp0NguU7iyXjJegc6SzTV+T5Yti8seUJV1mloaGhoaGhoaJwfpFShUFix39B2nztJ2yq4Tru0QT+8neYRlq5TS4qw8oP5dhocqFVe7Yil5aw/ZH6tzh8++CDu+dofwzLrYhYeMyIwohaihonRkTL6uqqIRFkQt8PlesoWS4glagSIxoBoPIF4oheZ9FZ09d+CWHwtapUTMFAAIg3U60tYWiyhVDJE+njcQiweQRQmSvUrMbL2NzBzbB+WDj2GqBmBmaugli+jnC+iXK6gWqkJcpTkVAMW+jdt1aSUhsa5Nt8LI5za+fA5HVZdMOTSwstVAnkPyKaHpep6KqBUkgSJRzbZxINNBAXM11xhjaP4UrUzLn8i/SxJAsOmZPz94Dn4do3PnIdmU2Gug3ZV+dTCvNAhr0IHOnGV2RGxog4Kdh4euaNeHfTZJEgoReEURih5jtr9eYVVyeOLWg9wRtM9tYRXK/utVEUFinAUWWq/uW1w0ovzzn1udrevoaGhoaGhoaFxvqMT4mZ5f7Kry7sdgdPumrD5eKtrVqIAa7eBvpLrW+UZJK7Eeq2FYKFdOUH09TSwe2dBKJpo2SACOFm2bUU8asKIRYQSymahuNZRCCnDVkkZUf4ZiEWj4lWsQSIRGBEDkUhUfOb77u4GurvqKJUjKFcMlEsR1KpRJHoMxFJduOxlb8VjizOoTB5Do1GHadZhCp+7JMRMe81hGIgazUGrNDQ0zoFSKvi78z+4JLGxMkKqJevuOLL2dD/Bh6L4X8nII6aazLGaovyFPWhVtZRHJMnkfqs3txRffn7TuOayAq1RylVEPOLpaoW2xd/25j5hYj5yVYrJSyN3KML60mX9Qkgmt2I+v+Ctbq89fLiUka/f2u04NedjN8jXewrjFFR2tSS+gn2n9IdQYgUUcsvTeRoaGhoaGucn1AWihsbpwjSlDv78wEpUQ8ulWck17cih5QijTjfyWyGYf6fEVyfqqE7a0k6V1WlatT6tkC8kceRoFyKowTBM8TcyUEdfd9Ullgzh64NklPxzSCe+GnTpAkSjFoyoHe074pj+RUgeyX8iL1slUC4bwoQvlogim40i2ZMRAaEy/Wuw/bY34Mkv/CMajSXU61VBTpGUsttkk19GLA4jSvmWhobGuVNKuU7Dw855BIG70Hc9GvlJqna7Cb6HtTjky8FPFwjmxXTIEocwcxgQwa4LOIOpw9J4KiPv1UugvqrkkXKo6UCQYFKqJ3cPHLWXQwkFSDC/yZ5PIaWSasGSW0TmEw/ZgEmc13i/8ktthRtN0HEcbvt7cvw0SQmSzY65FfZoJ5lvi45qQWR6B+Q9CphTiiYoWqemqI3SaXrAdZWPYGvNoPnMBt0vhG2zrqGhoaGhcaGiI5+dGhodzC3PN1JqJcqkVsdXS9quJCjRmSCGg4ql1eTZ6TVBxVOQdAr2d/B70knfLFeX7mwEW7eUELUa4NeuYVlIxhq2CsohnqhMEusBoYyK+MgpVylFckq0hXWiosq2brFtIvzEfU8PUKlEUKk2UCwaqMdcZyQY3n4F1l59O47f8SU0qJSyaKznrIGMKCKxGJJdXYjFEx31sYaGxhlTSnk+hvwPKCWBG4XPiZAWYkbmVzCFPaBsO+HmB5x0nq3mI5Uu8iEayMk1iVOlsV4ZKq/S+U6F7aTba7ZNaDT59ZaElE95tLqBq9WD3m6KQ265/RrxoswpCrEgfyP7X0hkHX5HmLVJwkm4ZJIPcF/BwZq0qLTar5ai0Aq68HIcw7vUljzpGU66eihf2VJKFh6d0bdb1EE/651lDQ0NDY3nClot3FupFVayeF3pNWcDK1WbtLu+3bXL+ehZbfk/bIR9Dzo19fphop2ZW5iiaLn73LxGaD1P74R0UctrGx28TdtaHVe/i602p1eKIBnVru6d1LVV/p2gUolhfDwBQzgkt4MZDfQByUQdEYPklCFIJzHtp1JJqKO8P5JURsRClBvMgpiylVL2Ooavzp8wi7BXFks5oFI1EIsZSCUMJJM1WFZDLJWjRgy7Xvh6lOcXcPK+byNSX0KkQd9TMcRiUcQyXRi54jr0rNvQUfs0NDTOEClFokISOX6/R3xjNtEuQrXjUjgtzKKCMiHBMzhqH8Vpua3kUUzLPHs+mZEvW08J1TyQhD4gl3teigeby/R47xWWxyZNvNrIwHDtnsWtZcCqg6xARd3MJenjVUASSC7B41SKL4ajYFOVR7ZPJa/+smX2YODozVz1mUs12p+d46YsVzrdclk4ux2uXk5pT1if2DJbxYRQRslzCUDVB1hwoG72TaV+I1yfVNKEMziO+yYVYf2uoaGhoaFxYWK5RTfPd0LShKkjVmKm0wn5s1J0UtdONh1bpe2E0FPPdUoWtLoP6rmwfDrtw5WQIc8FdKLUaUUwng6h2I50WUm+6j1vde9W810Mq8dKvp+dknrLHWsHmTaVbmBkpAqrbgrrCcuKIJnwm93Z6yp7M10opFxyylZSCSGVIKhshZS91iEZJdcS9trEboqBwQEDphlDrQ7UKhZq9YZnUQMgnu7Gla97D7KDa3HsvjtQnJkGOatU3yDWX38rLv6R1yDZM9BxWzU0NM6EUkqlnXyElP+s35RLsaCSl/jOBR6ULvnjKHtc0scjRiT5s5xdt/3SfoBSrmzJTNmEh3QqJWkZhWILXCYj7Cl8VUsE6yJN4mS401DuzesUedYjv1Q1UsDHl5daSR/oAV+asIE7mNIxsfObJcoTtkxMPdxywuW2r5lcbKW0Cx4LHlVJU0moyT4KDv5SSdXk9F5DQ0NDQ+MChbo47ITwOF0CY7nrOjl/Ooqn00mzmrSnc/1q+/9M5N8OnXw/zke0Uyypx4LmaUF0qprqlDxaCcHYqXlgu7q3qnen5o6dHlOPd9IP7SDTVWsJzMymELEqSMYtJOMmKlYUtVoG0WgE8TiQSJjIZBqIROqug3OxiS43yKXjc66oxCuJKZuU4rqkUDAxMQnUavTASyKL6qsIYnSObphIJBSfuE69EuluXPySN2HzdbchNzUOy7TQPbwG2YERGNHYeWniqqHxPIi+R0hFi6IUkqSAVDuFkBniEeXYh7V6TDV5JmpiZZS0IWyX73qfdF1OygL5uCogh8SxbHWQ+nhxi5YPX2kM54YGtI82ORB32HyRyPWzpZbrkDb88zfMNfuTTL3sOr93KpUU8hNSisZMWlCLsHm2ekshu5R8vHLaDaBuh6tF2m1WM+WuhCfmUq5fhmAKWuIp5o/qNR555HmdalJIufeWmdj25eKTEuGQg5g9CZDREbWDWA0NDQ2NCx8rJRVWQwh1Un4rM8KwtMHrws4H0W4Bvly6MwE1Clm7clr170r7qV26M2FSGHYvzid0onzq9FgYQdWKaAkzoVPPLXe8VZnq63J1bkV2dUKiBY+1+511oo5q1TerITXldYmEhf6+BhrVCBpWBPWIhXoDwmROrHXKJKYiyGTpS8qbx7vKKScgl/1qOMSU3I22FxTpdBQb1yfQaBRhGHXb9xSiME0L9ZqBetxdSHntcUiubN8wsv0jXrvtynfcTg0NjTPpU0p9EPlIoSBJFHp5k88lqSoKpApF64HbF6ZOpvaXTSfaAV4oyI65b1V1j+cB3PusimmC3RFkUKT3KdfPlp+0k5+bIBl/QXZ5DrtlvbwHvz86XUhrfO8EdyT7XCHRwroufCBSk9gEXtPg5bFlrtN1z4QvbJLpqd8CXRrWnEA5we+PX6GmpvNlpXSA1yeKaaOGhoaGhsZzBJ2QE2eatFlucb6SsoPXd5L+XGGlahAVKyV92pEP8viZJBcvhE26Toim1fhICqY/HXO5Vvm3OtdJ/ZarUzt1VRh5pJJiK+mnViRUJ20KXmOaUZh1qpds9yKxuIWuVB3plKOKivJcQ/zZ5JOijPIRUu6i0Cco4DERmQ8WajBhwsLJ8TpKJZJdUSTjMSR7Ew6hFdglDz7PRANUmxYNDY1zGH3Pe2CF285Lx3GGG+nOTttJ5p4kJrh7oJbvf89CFE2TYLsliWPXx/P95BEQgYID1ZAPLzsPfmT0UfpNsuE8qERIULuRPi7HIa2kMIrKLFW/o/pwsnOTb+zrVHJGkkjy4Wep7pY81qyFOZzn2DzSSu3Uml/0a5BCTCVlHXzHw0glplHVXAo8gazSfyGQvJKP1GS+HIjc7lQJJQ44iicqd5CVg7GjH3MDCdoROkJqr6GhoaGhcUFipUTPavJfyfWnS3B0SkStpk2nc20wj9O5ZqV5tFPitMvzbJsAngs0zUvbEHWdHOv0fCfldKqeC8sjbN2zHGEWdv2Z8nUVdt1qCKew/mnOxxJze66dGg0D9XIEiZiFFGruesggYSSi6TmR99woe3YEPvezE5UPaDhb497aUETui0bFGmJ0rQFD0FN235mJ5siloao0+d/5+xPR0Hhu+5TyuIzmgcB2zi0ZBOlTqIOHu3iYSPokSCQ0k1p20hASwWFt3Kxc+Y/fmbdMulyd1AaLtjm+pVzFk5JePKiUPnKFVcpBmcZvzmY/HEWdQrrJJrXsMmW73EHOX4Cv3wI9E2xh0zU+AsuppKpkIoEUZoa3kkmpVC25uwqtHuYBEksG15OO491kPhtEL4KgJNQ80tBvrOgX+/lpOJug0sSUhoaGhsZzG8spNTpRYbRTf7S7bjUKoXb15blWi+DTIc469QN0OvmtBqtR1nRSz/OZhDrdPjgTpGHwXDuFVCd92UpN2KrenaiRgveyVT3aEV3BTeflTATDyl1pvQlGz4vF6khGG4jFnA1jw0K1nkTUsJCKMgqfvXbyNpPlulDZYHcCOck/4ZRFuk0B/UkZmJ6OolaPoFppwGSwPZgwoiaygybWK+uN0/0OaWhonBXzPechIMzbPMffzek82koSCi4DoTxEnMT+/Jty9Byfq2HuWj8UJTnlEDgOfUQ/Qm4uohoRl5H3iZcc9sN19O1WTa2nfAkMJtJYz36GNjdTsiZe9XyWbqEtUv1NuX6mZJRCLy9f42U3qSSOap8XUpDK80mVl0/dFPJw9k4FfWI5+Si22KJ4ReXUVL+QankKLDthsL1hZarHZD+5fa/0jZvYIRq9PP0DnYaGhoaGxnMJnSyWV+oP5mypscLKaLf4XUndgvl1gtUsSs8G0dNOKSPPr1SlE0x7PhJUnSrLOlVQtSNLluu35ZRaYZ/bqZc6JW5a1XvlbfHPpsPufSdmiZ1gub6R5TSsKJaWkohGa0IRJZRLjQjoRzweA7ZuziMKmvLZi6CIz5+UVEnJMhwyij5uRXrpVxeIxYD+vjiiUTpA58y/bqe16kCy5lzv9Y2GhsZ5a77nOfUOnrfhkAi+iGgcIFvtLNgPHjcfv1eggN2W/0HhewhLnkw97x7ziBCptLLJqZCGBskSQTj5CQ0p7gxyHOLhFjBDFoOQJMGUtHY+KtnmHxDs/vGXq0aRC9o726m9Y75HqUO+SYJIbZtToFsHjwIMTGhUYko6Gu9kJ9VVeqmKMqe2Hcibm1RaTX3RZkLq9J9bppJUEoL2i1LC+TcP09DQ0NDQWDXOFcGwErOeMHLpTBFmy9Wj08V1pwRCK7RSWp0poi7cBKp9PZ7Lao/lCMogudKKuFnWwiPwuVOFYCsisdP7046IXKkqT5n2d1xWMP8zRejK9U4qYWJ0TRUGqkIZFY3C9gFlkFiC40vKW1uo60OfSkoRTliuuxX7KmH9EaGfqopIP79gIFeIo16no3Mg3W9hza7AQlBDQ+P8IqUMSRAoTHQowdEC3gOj+cHffK39Wfhz8j42pbDro5pt+RF1EqoqIPu97aRbhSQ4bLtjP9sjSCX1kGKB5ssjGD0uUOMW+x7NR9zyFafrgXN+osYmiNxnrkpkBRVS0r+W2nEBwka9ThUcyYJd311t6uRWReYfNOXsUAqsVLm5jssMGr48nDa6EznZHEmw+auloaGhoaHxnMPpkhKdqlXO1PlgmnYL+NUQBqeLTtVF55IMei4TT6dLDC2ncupkszR43WqJpFblh9WzlQldGDnUqammt8nf+W8qDGHO0sPLa87LOx5BtRrF5FQa9XocZsP2D7tmpIaBgZKjePKUUd5GuX/N5CqonDf2KdXpCv1HmTAtU0Tey3ZFkekiUcVTDTTiVE+F999q1IcaGhpnQykl2GVJAjlKo7aEyukN5kJh40atC5IFkuRwPyEivYA3Jw42xPMY7iNKbGJHSEbVtKH17nwnTBIgAe5jeajtUfIVpwJ1kPsGgQNNdXLPNRFEbSvSnH+rgdY76d0KhfdaCfx96OW7oh2/kD5ffsDVg42GxvmE58sufys839uvcfo4G+TMufxensm6r7Suy/n5UdN0Wt5q78dqrjud+3Q+Pm9aERudpm2XphOSqVXeYaTLapSDnVx/ugolf11XT6R2+r1vZQ4YfJ9Kmti4roKoUREkEQkoOxKfRzbZ/qEkGaWWH/QZ67RNmMjQNE/6l6IFhYlaFShXDZimZauk6hZqFRPRbAOjbr+c2WiWGhoaZ8ynlGeSx+dKmEkV4fzklXMeGRL8cQu1ksIAOY8tN0epspGqJklQyTLln/QZ5ZlkSRNCh9uRVQh6E3c+uocdws1HtzU1VJbVLJeKtCA5pNkg+fl2Ewu36krGto8n2xbarqdjkiaZKR9pJa9rYZfoM6lsk1Qhguhs3UvUzPKEP6sDfagSaYHy/PeoA+KradCXMuTgPVcK813T6pvbrj0aGhpnC4VCAf/5n/+JSqWCXbt24cUvfjFidPrgTGIPHDiAb33rW1i7dq04NzAw4F77yCOPoLu7G8lkEn19fbjrrrvw6le/2r1+ObBM5v2KV7wCiUTCPV6r1bBnzx5ce+21q5qQsk3lchnHjh3DlVdeiSjtEFqkGRwc9B1nm1n2RRddhEwmg+npaXzzm98U9XvVq16Fnp6e0DJLpRLy+TyOHj0qylTbw3N33HEHXvnKVyIej3fUBpbLOm7ZsgVnE2zvQw89hP7+fnFv2R/j4+Oib7Zu3XpWy34+YaUL2eUci3eKYD6nk9eZICpaoVMVxGryPVNtDl53phfMQcXL+ehXKghZz9UQSu0USq3ShUElXVZCRKllt7tueZXRysisVsqwTrAcAXg63/VSNYYjYylErKhtCcP2MVJexMLaNWX095Ucv7/t5vH2Asm2eqnDop8oYcKnpI8A1bqJSiWCRDyCdDqKWMyAEY3Aiseb1iNaIaWhcZ6SUh7hIOkbcTKQNujOSPF15JMZBRU/zNHxMeWosni9TYarhIijovLbD0oax1cBRnPwynIevsoDJ1RY5Ry01VchbZMmbIpT9ObuUpguSSS12Wmzy20mrdyHI/tCcFCBHm9imZQyg3Vy/rfNDF2mLnBtcLAM5tsJKeXPT3a56t+rlZ8w2f7mgSDMONDOJ1hHl4RUlGX+65bZ3dHjjobGOQOJlE984hP4b//tv+Hf/u3fBKG0YcMG7Nu3Dy94wQvwoQ99CIZhiOPz8/PiOF8vv/xyzM7OYmZmBn/913+N3/qt38LJkycF0fT9738fjUYDt9xyC5588knkcjlBelx88cXYu3evIJuIp556Cl/96lcxOjrqHjt8+DCeeeYZPP7444IUefjhh8UryaCDBw+KZ4RpmhgeHsb69evxwAMPYN26ddi4cSPuv/9+rFmzRhBDJFYuvfRSUTbzYBkk1vie1/L88ePH8cY3vlGQUKwbiTXmd/fdd+OXf/mXBSn1+c9/XuTDPmC67du344knnhDH2EaWx7xYN7aHRNLU1BS2bduG3bt3izY9+uijop1sB+vJPiDpw/xJmF122WV48MEHxWeSYWw728m8me+hQ4dw/fXXi3ZNTk7ixhtvxNjYmHjPMpgnwX47ceIEbrjhBtGPExMTIi2P8T3bz9ebb75Z3CuSdtdddx2+853vCDKR9+6+++7D008/LfpWk1LnBp2ogVqhVbp2i9Hl/d388NQJrRagFwJBI3Gmncs/FwmpVliOgFDn5506J1+JGir43V8NYbSS304r8rnTOrTr+077R6bNpixs31pEBDV3hWZEaLYXQTRa96xoKFawlOBE6jrSncKr0fe8paF9PoLuDJBN11AoVVEqx2CZNBmMI5o1MCqiYJ19ElhDQ2PV5ntSAyUX/d7i3memFaRG5APC+c8mJ8IecP6HoavUCSEt7GJDKDGhkmn2w+RVJkhgNKu8JAEk6yF5KR8/5b4GCBqPV1LfKBHtwmE7Qw8p23HO5/mwkg//oHNQuxx/dVo/OFudCVMrtUKwP4LknKdeCieu2j/Y5fcsSIA1l9E6H/UetyK01M+t66qhoXF20dXVhZe97GWC5Pje976Hxx57TBAlfE+igmqde++9F5s3b8af//mf4/Wvf71QD/F4Op0WxFaxWBRqoGw2KwiWVColVFZf/vKXBfFDUoakF8mUa665Rjw7vvvd7+Itb3mLUEvxGMv65Cc/iZe85CUiv49+9KO47bbb8JnPfEaQJAQJHSqOPvWpTwlVD9U9LJckGQmXTZs2ifZQwUVyiUTRJZdcIggbEjEkkj7ykY/g5S9/uSCB/uEf/kGU/Y//+I+ifWw3iSWCz/kXvehFonyqwd70pjfhwx/+MH70R39U5MGy2bavfe1rgoRiuSTpSKCxHe9///sF6UQF2Zvf/GZ84xvfEGozfmb7d+zYIYiu/fv3C6KPJB/rSGLo1ltvFWQSCSnWlX3K85L04j1629veJlRu73vf+8S5L33pS6K/SGrxWhJfPEYS7bWvfS0+9rGPCfKP9WV+JLrYx2wnyUb2P1VqBIk/jbOHsIXm6RIynfqyWQ6dLvxWs4A/G2TL+aIqWokZ2w+rr84E1O9Su+9qp+Zvy303g07lO1Pxt65jME2w/E7JnJX8psKuPR0yuh2W68dW6SuVBI4ey8Iya+IY/40MVjE8UHCWkMpKM6gXUNaNNvkk16w03bOj8Imy5BrK+VStWiK6XzJhIpWIAGmqms/P772GxnMRQR/fHYE/ePqUoqTS9vfEz4ZzrFlLI/7kQ9wlWvzH/X/eQ8WvngrUQ+ajpFXzpDIqmDfrLOq9zMPWbplKsKmDkNcP7YiQYNvFnxuNsMXAopBNYX3jqdRUPsxft5aDSmAXwUsTLC8s39b95SrQfLUK5h9oh1JuO/i/D/7rg2U0XxdsT3O7Alcpr/af5qU0NM4t6vW6IKRI3AwNDQmCg8omkk4kakj4UCnEiSpVVC996UuFSRo/9/b2CkUPySASGSSdrrjiCqHA4XuSVCSRaM5GYuemm24SzwKWQaUSy5VKnmq1KtJQtUSCh8QUlUAkeUiYMF/Whyol5sdrqeCioocKI6qhSLawrqwXsbCwIPKgaaIkf9hekmkkrviZxBFJJaqqmI5lSDz77LNCNUXTvS9+8YviGPPjNSRw+EdSjvWl0or9RvM95s/+YLtYTxJJJJjYbrZPKqlYTyqtaNZHxRPbz/ZR1STVVPzM8qh+Yp7se6q9eF/kc5V9xfJJqhEsiwScTMvjvJ87d+7E3Nyc6E8Sh5Ls471cXFwUdWC92Ie8H+frwvi5jE77/EyqBk7nPosF7Fn0mdUKYfOKlapDVnrNatJ1Ctme8/03J+93K1JHPaaiVbrg96fdhmjYd63dfeiEGFPbE5zLn4m6tPuedkJAd0qqtbo+DGHpUilgy+YCdm4r4qIdBezaXkB/X4Uuzt2I6fT6K0glYaIXrJeMTu438bMVVc4GtdxEN2wfwtm0gWTcQqPeQC5XQ6Eg10zn929AQ+P5HX3PfajZpnuELYbxkyXSP5PgqJ0fv4++8EQpAT9QncsjmyzOHIWP4NUdZZHIQ1Si9QM76GLKp8ByVVVO3iHROtw2+9oiO0B9IPrrKfxDBa90dwDUgUIJedpkfuiZJIb1nXc8fFch2Betjq9msA2el13hJ7Ka69wM9VzIQOumai7XVlGtbBdIkpoaGhrnDiRBSDR98IMfFOTOu9/9bkH0UJH0ute9TpA6JJ1ItIyMjODqq68WZA4JIl5HEovH6JeIRBTVO1QfkRD5pV/6JXzuc58TxArPUeVD5RSPUxH0zne+U5iakaShKRlNzUjWfPzjHxdlkiCiMomKJB4ngUNihXWmyoh/NBUkASRJKprXMc2dd94pXpkHVUski0jOsD1sJwksEk40W6OJHMsjYca0rKf0CcU8qPAiSUOFFOv5r//6r4IQYh6f/exnBWHE91QosU/Yf6wbryHh9p73vAdXXXWVaMOpU6cE8UNijEQWj1HJ9fWvf12kZx9IH10kh44cOYL/83/+j3hPEokgYcU+Ybksh2D57AcquKiG4ns+33mc7WaebAv7UJJmNAdkWpbL9rMeVJex/bfffrvoQyroOvURpnHmsBIlzWrJkZWaXgVxvhAoy5EhZ8MPz2pUMp0o2c5ntN8U9qdbyed2x1c6B15N/YLH2tVvJfe70zl6u2PLkVSrJVDDrqPjcSqljEhVrDlNs4G+niqGBkvuvF7Uyd0+dkimEBLJXns6Sil5XlwiiTxDfM4V6VsKSMSplmogmqi5C9N2TTsfnjsaGs8FRKwOf01SRt8wLfzelw7gqZN55YffvLsQSvQEC5ePEnmd31d3+DWSYHIeKH4fd367OAo0XcfogYx9Jm+ugXFzGlHDNpOIlewE+EgjkYFk7Oxzbf0uqOSTetzJR21fJztFraS6nUwsW+W77LWtmKNA+asZPDuuQ4fg9T2pKP7u7bvRl+nMGbCGxnMFnTrAbjdWrAbqOKL+hkkqhTkIb5WHer3Mk2THcgg+A/meaiB5rfo+DDwvF0vqe/W51io/mUZtq5qHWh8iLI+w/JZr53LtCDvHMtqlWU3asHt8tkxKni9gX7FPOx3PV1vGahbHz+WFXKt5yNkgzlban53UIWxex1f+Rs+XsYLKSSovVXTyvGtF/gX78XTIq3bHw9KoY8RKfBV1MtcPOxb2HViuvcuRmCtRSLVqn3rdzIk7cPDBn4Fllt3FQzRaQzxWQzRiIcphLmYiGjURMTi+AEbU3vAWUfqcVyMaRyzSCyM6gkT6SkTjG2CZC0CkAlgNWI0KTJPfowjqdRO1WgO1moU6v5rpq7Djmt9HxEh2XO/n8nNNQ+N00MlYseItR/4k+9IG0gmgatoEkT3pt3042a8eP2QLjjwmRfJJqmmUb8LpvPq4JvU6K8jGBCoojYT5APPrlnwPcH+ZSuV85drceqe7I77BTNhAh6dz2yRJrxYDhq++IfWz04ZfsxyWG5jD0vvz9/o17Fr/YOm37/bThRIrmwi0a9Nqrm9ujV78aGica7QiLlaijjmdZ0gwvVzUSyxHjLVKq+a5XBq1rcHygvXptMwwtDvfrp3yXCck4UrSht1j/Qw+c1itWdiZwkoWrecCnSzMVZyuKmWlc5mzRV49X7Ecsd2K2AnbuO1kntyJ/yj1vfrajmg83e/WsvNgkZffJHK5NnSU9wp+W0xbrkYxdiqFWtVWOMViloiOF4smEDU4DgLxhIk1a3IwYIrgTywhspxLFmW5VyzSpL0izkZj9kYPyzbQEFH+EsJa4uwoFTU0NM4EKRUBfvH2TTg+X8a3nprAQ0fzKNft6HOmYKRskzTP9E1lTrwXQfgEiZcQckr9rD7sO3soKkyIfBCFXNvO4V5ktTsUqklfSDtdQiokz1ZlLefgqJPFWKv+trtIKtZkZ8lyhZzL83clH9Ty3rZ5DosyfNyhDB2oyLukB/wW0rqVE1OOwXlIfpIw9BGBAWWErKaGhoaGhsZzGStRRKwmj9UuXpczcztdkmildewkzUp88KwkXzVtmA+ksPed5ncho5Wi63T7dLn37Y61uraddcJyJNdyZbW7tl09vPeChrKVuJQIic2PRIdttTeZO+n3sDStiOFU0sS60RKsuu3oPBIxEIvylc7Kqf4EIrGa2N42ONeX99/1LuW0za9k8IJGRSJIZ6PYvDkGWGVEDPpAp8LZQKMeQ61aRyMWcTfQL/TfiobGhYBVOWfoSsVxydoYdgxtw8PHF/ClR8ZxdK4GBuk0lch3rp8j13GSQ2o4+ag/ctXkoHN1j6K76nAXLqycTnYzlqtTp1Db0G4C07o9Xtu9Qcd3uCNGRSW67LeeKabn20r2r0NHudc4kZDkde5mAvvWJrAc74OBQp1zgfdyQOSg0GSOKdsabIDKeTZJnLxrbeNMr4N87WgqxyPR3PpoaGhoaGhcwGjrGuA0d/eXu36l+Z+p/M72IjJscb/SOiw3bw0jJVRS7mybDV1Iyo+wuXOrNK0+d3JuuQ3t5VRWYe/D0nRSx2Ca5UwUW9WP891yMYfxE0dQLuSwfst29PaPtiGa7Al4o8FVn4WosKXz+qRVmSv5PdRqUUxMRxFFA/EoEDMi6Okx0Z2t2PvKNNkz+Ma01V1y3u6zrfHWiG4ZckUhhAM2ySV+SzQZnKN6ykIsSgIsiWSM7bJNzzU0NM5TUoo/T6qi4tEIrtvUj91revB/7zmM+44VUDPFT9gRvigkhKePEp9ssUr4A7PdIC8hjePC4qOtSnLa5HQqsrLzp7FTthyar/eTcTYp5SeuOiH3vM/Kg9u9TCETPf7KSeI81gNKKxFp1R181CvkddJhvEtLKpcHCpElhX1HgnUKJHG/cZJbU80wQwdZ+T1VCTm9M6KhoaGh8dzEhUQ4nO32rZRU6pQMOtOE3UqvOx3F2nPh+7Gc0qmdQqoT5c9qN6XDrg1b93Tqm0yt63JElK/NjhlDIbeIb3zlc3js4Udw3fXXYMPWnW3bITVHudwCEok4MpneFSvJ2qXj53jcwPBgAzE0nLm8gUTCtsixaK4n3ILwsxOFT60fLXbUHW4Rnc82A+S10tKDedj7+PbaYHCggaF+Oy3XM3WukPU6QEPj/CalGiadHfJHbwgGuzsFvP3GTYB5FD8YKwf8KfkeFR6Z5LDU4T94JdqdQ/40PZwDpmPNElynJD6cFCWRdGsuBFPSeiyskeIhGDBn89XQ/0aN7ma7UQqSWPIx7hUQJNTCB0HVFE3qfhRSJySqHB+6jvW0p6TypfcUSmHtjjh+oOyHtVKe70WaacrrIs1Wf+LhryiyVI4yaB3oZqz0iso4uWosfy+Gwd40USurDFjivgeu97VLur0PtE9DQ0NDQ+NChTvutfDF6Zxy50VybiHnYIGh2H21J1qOLxoPztAbnAIq+Sq5uYoNtTLKhpJaz+AmlOuzNGyLMqQblMZGzjD5c6Y3slarhApL2+mxpjTNXX5eo5XZWrv0YZ9XQiC1U0ytxpyw03p38v1oq8aLWKjV63jo3u/hM5/8NJLJNF78shcjne1tWa7Mo1YtY2lxFn19Qy3L6wStlGKmZSCfTyIaaSBGVZSglGzfUvb6UaobAvWTayTZVDcelumonphLw15NuY+eCEzLxOSkiVzeRCIWFWqpZG8DawLtXk4pp6GhcY5Jqfn5JSSSCcTjCcRicSws5fDQg3uQnVvE1SNb8dhk1eGihTjSmbA0TwOW/TELX0OecsVHfCvmZ8FjLgnlTHpskyzH5Ey9JECyNBXvq2OQHJOVcWSrir9ylc9S82oqRZIuzqTOziMYUdD+z00iSRbZL0E4hIyb3uAnhkFtkT7Qd/7+cXrGmZXYSieP4YsEH8rBexzs0rBJa1i6sO9GgAALP6l+t1qr8ULLU/ZV2tVLQ0NDQ0PjQkC+UseCE6FM5aTkaixsiPbPNQKMkm/C1UwWudeIaYwM5BKsVUCpoVTLzcpfjLJl5NMzh9bFU1K3mIcEynMb7pQQss711c1fb7+5kHSP2XSBko+vX9rNExWizd3OVerm3Q2HynPnaQEybzniyamHmKOHJXU2JqORCLoStiPo8wXNm9F+QmmlSqdO29Yp6bWcUi3MFHM5gnOlpFtYXdx8YGF87Ci+f8e3cfTIcey+ZDf6h9YiFvP7kwrUAJVKCc88/Rii0QiGhkbd/FdKxIUpvOQr885m64iYjDgL1GsNNBr2+sg225O1UTa2ZbAt5fdsp2jYiSIUVDSc7znXRfyzU1BttWYkgpEh6beqjnrcEw8sZ2qroaHxQyCl+GP85re+j0JuCUY0hm07tiKVSorQrGuHehBfOolj9RjmYwOwREwEx6ePUMlIX0T2D93PMzT/4O0JklS5BCc3yl6dO5IHBxh5mbcTF3BvFVJme8eCvoeuupvoJrXbKMkbtS3qlMr3UJNEkzJQNJerPnnbTBTVFAE1mnu1b/KiHAvm4U405R1wpE7KhcuNO+oA6tsFbfFM98g2q81UMBjZsNUAZyn9ag9Ydo94JKmcvkkNmioCPn+mXhoaGhoaGivDPc9O4i+/9pTrFoGDmh2lymNP3LmCdAvjMCuGsskn3QTYCgVvjPXe23+8xnUp4ETdlcfcdM7mlpev86eM8Nyc8/JSzstXwza9EYtJX92cOYvhqJ2dY2IN66ubnFO5JXrHAqZA3lzK+6zuw7llyiPO5qL87Eb9Eh+d+aBXmAIlmEwLMZtYcEuluxP12lPSO1GwZXo53/ZN2YLzTqXPfSV5bZP3cqAriTdftwmx6PkzMwoGPwrO3VspmFbiFP10SLjVkEWdpl+NCWfY8WeefgoPPvgI8oWSuNn9/UMwjGigj/jObkuhsIgffOfbKBSXMDq6EYlkRhxv2kdu49S8E/LQsgw0qhE06vT5BBjRCGp1Awu5NLKZOtKpKqr1GIrlOKKGhd7uChgQPl9KIR4z0dNTdn4j/AFQaUWVlIVTEzU8sa+KdLKGW66PieO5nIWFRaq/SH7Z6RjdL9lnYkQlklusFVdyPzQ0NM6wUmpxqYjp6Xns2LoelUoF2WwaWzavw9NPH8Te/YfQn+pFZl0WU7UEqmZUSC4VSzsXHi8QIAIcQkEV93jDZpCYceiEpodayC6Cs9UkJyOSWFIJr+bdQQdu5R3zLpeo8ZfW1MYAYy8cwDc9hOXw37yT0RY+Pkptj7NT4Gw5OtMVr6Sgsim4m9dyh8bfWNfQzT0hzfV8W7J+BVuQDQuU20ziBdK4W5FhJGJgh9V5L+fatiN1/zaopMqk3Fd8mxxC8XzaEdTQ0NDQ0FgJKCwoNUjc2PMem5gKkDiSvHF365QxWCWOnHRiPCXZJOdNDsnFBaBNQnmElQjU6xJhXn42oeQFwzGcfN1yYIm6MzCNOO4QXBz/RRlURDj1d50VOBF9RXrTqauTPxergrxSZmz2NVIx5u3UMcpXKIkUQuDwOju181lVlyvkkiQB3euapha8wMnJTadsvPrgKdHsiGlwdB72jMx22swETlAf8Z+z0afOtRWyyr7//jm3yJXH6SfWNHHq5CmY12wAFKfW5wNW6hi8nR+pVunDSRP/JuhqSIl2JndhBM6ZID786iwTY2PHcGJ8Rszed+zcge7evqZvnU12mpifmcIdX/8qjh06jC07tmF0wyZEyd544su2/aW+b3efXBM+mgk2gHojAlQjiBoGYnFG5gOikTqOTWTwv/6ljkQ8ig/89wjqDeCP/9rA6IiB9/+3BAxUhaEeixLR4WHh+HgU33nAwtoBEzdfy2cPnadH0dVFIq5u+6MyTVimhUbCciL7BbfC/X0p32tiSkPjnCulgHy1jv1jUyiXSrj4YuCqKy9BNBZDoVBCd1dGmIz1Dybw1KyFB09VUDYYcjMKizMEqTF21TvKg1chftwJgk/q3erBIK+RqdTP3rAuSQup2PEGYNteWW462df4lVzhyh2lDiHvvLYq7qnamND5CS++o4TUndIoDVHqJMuQ5I8iA/NMDJ0WuXyOn4iRfaGauzX3afNA7j2E1XOBPgjrO7d9zens4Ihy0AyQTOI/pe7yPrEenHSrfJNSDx/9J8wZle+ALFkpSyr01Dw0NDTOPrj4eeCBB7Bnzx5cc801uP76693nTa1Ww1133YUXvehFSCSazQv4LMrn86jX63jmmWewfft2PPbYY2g0GkilUrj99tvd6Ksy/aOPPirObd26VZR72223+dKsBMzvwIEDGBkZQV9fH04X8/PzWFhYwJYtWzRBrrEqkAyKRaMwOO6pBJJPveR/75reKcoiV+2jKJdIdMElkyQBI8tR09kbQ15eDhElxmK/AsvNRyHOaDbmZOkju+z3Dtmm5qNsKknizD3vvjruEphCaZ/dCercyWu3c8o/I3BM21TSKZiXetxOHzjmyzO4Q6io+8Vp3wd3HiM14eK01UwA2B+d9M7cTm2LJBXtyZGi8opQqVLDQw/ci6Xpcfzia67D+YR2lg0rVUC1IkrCiKtg2pUQY2oe7c53qsRZrqz2REkEZsMU/GW2pxubN29BKpMRzsNVmGYDEyeO4Uuf+RSmpqZw7Y0vQCaTxobN233pOlWedULeMJuYYcFI8NtaF1xoV9ZEJlVzLS+SCQsLOaBYauDzX0uivzeGydkSKvUovvKtblFv0zRgReKIxwz09NcwPlcS/qqymagwERSNjdBxuonp2QaWlug3mb87A+lBAyNhFsgaGhrnBynFB0VvVxc2bViH4sIsnnxiH7q7u9DTncaTTzyLjZs2Cqb5gQcfx2KxjD4rhaX+i1BNZGE6u1v2AGo/lKREvMlYPnSHyC+rDqldS1JKzc0/qfDIGI/rkYSVVDd58lXuLLStgyxIdeDgRIBrabPmN0YLOewokuQMRR4LI03cCYc9QXHN53yZNvuBEm/ltU35hg/6zceW33VSp0HLwSOJWkwIA/2mTniXy9fXuqDvKbXP9GikoXHOMDs7i/e///1417vehX//93/Hzp07ceTIERSLRVx55ZV49tlncd111+H+++/H8PCwIJNIQC0uLmLbtm3imv7+fgwODgoS6w/+4A/wm7/5mzh+/Dhe8IIXCBIqk8mIvEg+feELX8APfvAD/Ou//iv+5V/+RRBhDz/8MHp7e7Fjxw5RNvNes2aNqNsNN9yAgwcPuu+PHTuG0dFRdHd3i/p/+ctfxrvf/W7x/OB1TzzxBDZu3ChIqrGxMUGYxWIxZLNZQV49/vjjWLt2rShLtn///v0YGhrC0aNHkUwmBdHGv6uvvlq0Y25uTrR9cnJS1JfpZmZmxHu2TUNDgsQPF2MuaaKQP+pn6VLBN/ZLwsUle+x5g1Qc+c3qPBJLmgeqpBZJKZsYU4guHxHlqKeUfCQR5TPPkySYVPE41VXJMnHIqYPPBNFHjHl+nbztLafZkpRqmndIU3//BMI355BTNJ+PUbWe8noqMNRSA3MadZPMVUPZUcVcEsoXAVoec94JdYdHVtnXqhSWf9tVVa3JCMW8j+VyCd/7znfx7L692LxuGOcrTpeQ6jTdSsz9WpEvK4uMvfIJqFpuJ2WtXbdOmOsNj4xg07ZtqBYWMZ9fQPfgWjTqdRTzOXphwg/u+i4OHz6Cy666GulMBldde4MQIzR9g1dA7rUj9mi+ly/FYNZjiETiwsyODs9JSsm1WW8XsHYoggPHIvjyt+uIGDXhJaZUtfBvn2yITWj+kKIxIJu1cNFFBvr6Re7YsiEGw+BvyxD+o1h+X5+F/j5D9AczaogVslY/aWicx+Z7EWzaOIK9B4+gUq2hu68bCws5nBg7ActsYDG3hGrDwsT0rNAf7djSj6uvG8YTU3U8cLyEasQuUt2J8aKn+ERSITqX9vWShIv3uTlFq4d8q4eoP3pd6wHJ3a3xLnY/BW2yW8EmQhQFka8sn5jW1yifrbOYVPgf+H7Vk5pvQB6s9KK9YbqyPmwSmQcGHDnhCbbNT5g1H/XyCZJrHlyBlaL8aqYj/UWHBVeUYrNoxPAmvRoaGucEJHdIGH3605/GjTfeKEibD3/4w4Kc4nPgO9/5jiCb9u7di+npabz3ve/F+973PrzmNa/Bf/7nfwqiicooEjt85kiV1He/+13E43E89dRTgrghkUQyiKYHJIg++tGPivQ8TzXW97//ffzqr/4q/u3f/k0olarVqlAuveMd7xBpSTQdPnxYkFfMj/VmvUgeSZXU3XffLcr/+te/jiuuuEIQa1SAvfrVrxbkGMk1pv/qV7+KP/qjPxLXkFS75ZZb8Ld/+7e49NJLBZH24IMPCiJKpr3pppvwrW99S5TJ+pP4ohk9z7/yla/8Id9BjfMJHM+iUZrA0cmSM346amFB2PhIKknqSJM2P+nDPDxCSSGGfP6qFDM8hZySSi2VkBJpFZWSn3zylFGe+V4LVZU7RwiQZK6iyukLd1rmqK34vxunxiGoFAfvvnmB+5+ibmra0FPnIn7Sy8vfm5uQlHJdVbjlqFSRN5cVcxUhX6lDrLAV36j23FMx6RPOnr0NVXtKZLkmfu4kx+f5XinPMXuslEv49je/gSOHDsMyTScq8/mDMGKjXdrlCKWVEECdriNWq3DtVE0Udk2npJf8jmy/6GIMDgxgaGgYXdksPv9//gGbtm7Di9/yLvHsiCdi6Ovux0tf8wZs330ZGvWK+KoMDI0oQQX8CrAz4asrapB0aiAaqSEet2BEGRXP/uKLr28ESKbKePePdeFjn69jbLyOao1R9Azhz5yEE5875Jfoc8ow6jCMBtKpGi7dYOKmaxOIoOSjZhcWLBF9z1YORpDotjC4035Wdabu0iZ8GhrnXCnFnd7bbr0Wd915D4ZH+pHOpLBv/yFsWjuA2190Ayam5nD5pReJQWwhV8STjz+OufkcukpRLAzuhhlP+XaI1IeTKQdxd1enOY0K9wEgJwHK8U4GjuUcITbn0cEg40w6pGlbp+OSv15hMt/WiiXf8YCTqE5kvy6F5k5K7SmMfb3fWZNaepic2WrRjzJ/ZarlHA+SUS12D32TP3Uax/fSiX6rdlod7YKpe5cc0DQ0NM4dSL6sX78e73nPe/Abv/EbgnShGd6b3/xmcZ4kD03kOAZRJUXlEcml173udfjgBz+ISy65RJBI99xzDzZs2CD+du/eLa4jiURCZ/PmzUKBJPHTP/3T+Kd/+ieRJ1VQ5XJZPBtI9JAMu/baa1EoFIQqisopkj8ktaRJoFQnkbQiwcU6Mz2JM9aFRNnExATe+ta3CtOHiy++GIcOHRIEFdvAupEwo/KJebG9PJ7L5YQKivnxetaHRBbJKJJPNDc8efKkKHt8fFyQeMyL5a12MaTx3AKJl0QUiEcaaJQKSBl1lBK9iERjMOg7KcQxuffdUZ2COwopx5eUn3SS5xXFkktMqc7OHdIqcCxoeqeec80DFfM7uREnCSdJGEnH52pedt1bXy/bJl9dEs7tQS8AjQpPLSXNB70zdn1VpbVStms26Pm6dOccSj68en4xB6NexLq+LEpmBJNzi4g0qujq6UYi2+uQS6SZhLNM+zrFdE8SUl7kPi9skNc8xSGGO5WmGXQOd3z72zh6+BBg0isPr/QiWJ9v6IQMWNk8v/NjYedWq3AKvq5EVRV0+t4O6ppioH8QN15/NRbyJZw4fBBVK4K+9VtRyc0jHo0hlUghYtUxODQoFMgzUxNinLLN3D1Warly2/V1WN0bZgSLxQQiZsP+hptAd1cNA/22qonfXf6Gr7y4gD/77ThOTsRw4GgS//LxPAb7Y/jpt6fRQ4fo6TjiySTS2S4MDKTR35NFV6aCqFEVfqMsJzIfiey+vih6e2kybBPbjbhUKrZfe2loaPwQHZ339GTx8J69KNVqGBufwdxiAfOLeawZ7MXDDz+OeCKOuaUKTozP4tCxEzAsC3O5IgyrjvSmGqJbroUZoXO85oeYePg4vITn5yfoJV19+Ksfg+SF4sjcNcPziBvB3agRZ3zkSmD3KIBmG3J/vdxilXzdg0q0lE4GydN9ELYksXz9ZE+c5BRHNQ+UaRQjQgWyvk4+NNF2e91PyMkWe34UmhVkbjQZWYVIG+LO9046LlWO+9kzt4AmUtKdLDoTWafpevjR0Di3oOkdiak///M/F2TQO9/5TvzFX/wF/uqv/kool0g6UWn0f//v/xVEDkknHuMkedeuXUJddOeddwolE1VMPJdOpwURRGLrQx/6kEj7gQ98QJRHgooE0O/8zu/ga1/7Grq6ugShRDKqp6dHmNXRdI9EFSfhl112mTCVO3XqFF772tfis5/9LF784hcLIonmeiSPWAaVUSSTlpaWRB34nKEfLNaRpBbP00yQ1/A886bCij61/uEf/kGUy/QkoJgn+4Xt4HUkx0h2STM/ElMkyPj+jjvuwMtf/vIf9m3UOE+QRQWJyf2ol6tAbgaDvVHkutah2LcBRqor1IeThHzvkVD+aHp+Mskjfmzn5rYSySZITUUZZRfoEVx+Mkq+93xBeQSSSiJ5751rnLmCR5o59ZdzGIWccvN1TRf95Jb9Ys8pXPO/FvNB33nFDYTwt+XM9Tyllje/8PrXI6lk/jxcKFYwNjEJmHV0GzVxvlAoo1yrYWZ2Ftu2bUeqp9e5xCObPDM/z+k5Wryq803X5A/Awvw8vvH1r+Hk2JhQSAk2QDpPPw8R/M62MpkL+26HpV+N2iks75UQGWEb5WHtWK5uQSfuyyqWnFM9Pd2YnprBqbETSEYNLB16Co8eeBT1Ql64LEl392HNjkvQu2ErTp2aRKNSwaadO9G/caswdVNJ4GA9wuraqh1qnamOWjtcg4GKIEr5m29YDVSqcTv6JlWgMfu3mkk2sGNzDUN9ERRKPejORnDjlTWkkjUkEswriohhIZESURJQrdbRaNRRr1dRq9rBjYSyuk51tcWfnfBFlewFhnZ4G+rLQaukNDRODxGrw18RTRMITpq/fefd2HfoOP7r2/fhit1bMDs7j2Q0joHeDOLxGLZt24inDp3EN+57EgPZNC7ZOISTszlEYwYMq4HeS29FaWCb68uACHt4mj4iREqPw+zE1MOKGZ0zztpEhbIv5bAXLjck0hr+B7o8HDIQN/eYsx/ls/FX0wcvUDSvbdKLB7TrFcAj1rx2ePb/7r6Hz9wwRKmk+Cxw8xDREf27NP4+8D77NE2tHtLOZGulxm+dDMShkwjZowHfUC1uh/vdCDZIyuHlRLg7FcMH37gDvelVcbcaGhcsSPisFnKsWA2k9J95sA78PVP9w2NUMnH84UKXCimeI/Ejj/GVx3iOx+Ux9VW9TpYnnxkyDcvm+VY75Uwn1U3yGvlc4nFClinfy2vV8tS0PEby6VOf+pSo49vf/nasW7dOHGd92PZgHvJVnleP6R1dDeKBx/fhg//6OdpiYW1PHP1daZQrNcxWDZijO2ANrEc0Zv/OpDJJ0iy2GVrQZC6gOPIppDxCyCWdVLM9h+SxTfxoOhdUSnnzFJfgcsoR0QN53DE9VBVZ0tzMd71CSslfgupLSyW4Ij6H5Z6iSd2Ac19DNsmU6VZTOk+F5s0rXIWVbyLm7Y9Waib2PHNALJz7sgkMpqJIRYGjs2UslWtYnJ/HjtFe7Ni5HdFUl39zzrLnza55n+OPyiad/KSVe5Xj8oA4fnwM3/r6NzA/N2OrSExTPMdITGzbsAaf+bsPIJVMnBdjBa+lenQlvozUz62i2610Q7iVAmu5a9sRTJ04QQ9Dp0SYlw5YnJ/Dxz/ybygWSug1apg6MYa6yYh3DdTLRWwZ6ceanjQSqTSOZy/FYWsUa6YewOYeA1e86EXYctWNSKbS7ji3XB06qRvTTJ98FA98/V2o1/Piu8ivKEkjU5jT2JEqjagFMZRT1WRadpS+SFSY/vF4PAEkEjEkkzEkE1l0dW9DPD0My6wgAn73KjBQRixhIe7kxWsNw4kYH78Kwzt/H5FIwnFrsnzdNTGloRGOTsaKVUXfu/fBJ1DK5zA82IOxk9OIxSJIxWOYnZtDpdbAqYlJdPf0oiudwmKximK5gmTCwMTcItb3ZlA68CDyA7Po2XEdEImJH7HYcVK4GvlWVdW4bIJLxsha0YG6vNS5Qm5UObnJaCpiqiG3xJSJgB1txs1aIbf8tJR7fUiIULm7FnwmBQdBVy3l61jneIB48XbvFEWSore25132BIf/c1xwJyDu7qAtRfVHbpETUI88klMyd7fQJa58cyfvTbtBx+bSAml8N6Xlta5QSpnMue8YJtoh4ZQAOT7bdgkOWx5RGaDI3O+ZEtY3SBfqdZ2GxjmFXGyq5nWSkCEkmaQObvKYfFUj8wXPBQdFdZIZdn0YmC6Yr8xLrWtYFD+1PDUtQTPEn/mZnxF5UhUl0wbrE1yYqOc1GaWhYmYhj2OnpnHtxl4RZWthMY9ipYqqGcHI4jGcmptC19aLEcv2OSSONxsQ/wf8NgVVTdJkziahHELU9VlFh8H2xXYEvYDayiWjPMfarkpKKrQMSbIKr1gBkseby8lzsuqessrOV50LyWOyld5xhXxT2i8R5uA8+Nn7bfrTODMrH6EnTlkRNGBifn4J/T1Urhk4MjaOucU8Bnu7YZkRQRCUzTrK1QqWlvKoWxYmFgvoHT+FvsERRJMpZNIpO/pegO5ylVBiUW/vwkrNk0tWOZuXDCJxxzfvRJ7qGPsiR3HlLLTP88X2coRUJyqjdqSPSvifjrrqTCmxOsl7WVhAtrsXGzduwpH9+/DMvr24d+8x5AqMYFdDobCEXaMjuHzDCFIj23FvOo6tM59BtXoKTxcreHLvftz8qhN4yZt+DMlkOtSwRF3/tLpHYUROLN7AyEgRllkQz4iYERGOzqPRum3iIrIyETVM4TeKz52Gs9bjcycW5XooirqVgGklRMCHbI+JdNqAxYh8QoggdqOEaSq/54tLwFLJgNmwUK+biHc1MBQWjqAD0lFDQ2PlWJUEhD/hpVwRV1+0Cfc8+izGZ3IY6Erjki3rUKzUUCqVYFZL2DbSh4nFEhZLVWxeMyBs4jlgFhYXMXXyPnSnEjA2XeNNglynjfKjj47wTZaa7MLUzyQuVJWT74Huv0w9bg+8XlmSFooEVUiW5fq+CubGSYapVoXSZ7fKkimSmXskjfpMdic7kaANv0dMuSZnquJJRAZU5OGqakxSZi7zovox8AZi3+An1lSOjWNETmWaZnjhD+hQJ+HeZEmW55nPNZNBrR75dhuV3RiVnQot0U86tRvofd+JFuVraGhonGnwGSSj+GlonAlUa3VkYxZSMQMzuTL6skn0d3dh/8QcGrOLsCJLqD27iNjWSxEb2ug6QSdcwifgtFz9s8kgxwzPF11PXueZ40kiSB6Xfluk2XyTmaDri8kjo8KUTbKuGQbMAtCbNJCIGyhV6qjTlXFdIYekiZ1iruduyTkHVJJKThiDc8Ug3PmpYgIp+0adW3h1txfVpXIFx46dwKFjY1g/MiSinJ2YzaG7qwcxx+fXYgXoS0YxkI2jUkkimeiGaVmYyVexlD+OcsPC5o0bMLJmyJ5TqYSTdBNBxalpYmmpgFq9jnSKJlAGEsmk6JMjR8fwrW98C6VC0b7YtEQZItq0SaWqCZNz2fPQhO9MEQTt8vAry84cIRFGjKnn2hFlq/Vz5GsLLFQKS4g3yjDqZZQKeSzmc8gVquJOJxNpdPX0Yb4KnKpuRm36AcTK+5GLAKlkFpZh4NC+vYh/8+u46faXoKu71/mOR1ZFpqntpdPyw8eSqFdtn2bxGDAyWMfIMH/VJiyuSUymM3DiRBoHj0Zw1RUNrF9TEL++Q8e6cNe9URGZL1cwEI9XcdFFBVx2SRnXXGZg4zppgeP5/yVxFe2KOGqpCKy4E10wsJ7RhJSGxnlESpXrFo6emsfcUgkTcwvozaTQaJgwYlHMzywI+9+Ltm3AJf39mC028OyhY6jWqnjxLdfh5IkJdKWLKDRy6Fo6hkZlM6qpQWXXphmqHwAJldhohSCp5YqRfKZrTn5B2W7AUlBV1KgPqCaH7D63k57PKttUUFJJARLFlefYYYIVXkn1kuWRUqJujhoquJMX1icu2eY/r0rMZf9y4hg3gItGMkIa++xkGTVTDo5OY5qUTAGySa1Rm2e3O9n02C1XqtYkslLvTYBEEjuDYeV4srewbHx196dp0Y8aGhoaGhoXCKIGMNqfxVBfFw5OLSGdSqArCVy2dT0OjM/h6Mwi1nYnMYo9qBcXkdp8KQwR5t2b60gSSRIuKnkkI9h5xJE8T5JKxOtz9wxtEkpJ53vvd5AufTW5sUakqttVbtnRAKVNWrVSwvqhJLaMdKNaqSIWBZ48nkdPMoatQ70Yz9dQqLn0k9OW5s0o36als4OnqqY8P6c2XC2kJNyUfNzrlU02+5h9oEF10rFx5JdyGO5NI5/LAQYdS9MsmPRUDFyO1xsm9p6YRzRioi+dQFcmjVy5LgispSKDMgCHjp5AFA109w8glYwLhQhnPiSipueWhJnb3PwiZucWBMFEFWciHsOOrZswPn4K3/jGt1EkIeWY6tFsz96kVT475sjnG5YzEztTSiQ1v9USU8E6+QIEtfEne6bmokFFUqNex/EnH8Qzj96P/jUb0JVMYMfaATxxaAyRqIHLt2/Fdbu2YaqSxj0TZVzZOIBiqYBytY71G/oxW1jCxDNP48T0FMrlEl7zlrchEomekQ3deNTEutEyoigJ891Y1EQq7ij2nGdEPWLhuw924cOfrKJcjeCP3mtg86iBux/qwd9/pIHFAp9P9CdlCN9SVtLCQqWGh5+q4CfekMGurTYZZVtV0KdUA8Vygz8D4dIlmrGwJkBKL6eS09DQOMekVNyIogpg78kZLBVLKFUb2L62H9VqTfxA55bymJ1fQiqdxPTEoogiMlvKC2foY1O0hx9CbzaJxdk5GHgQictehobyIPM8KClQo9Ep/0u4/oQccst+H/C/1MZ8zJuU2OZ37nNG8dmklkjn7eqV0sxP1luG3qV2SZJQkugKUlNqHZRaOuyUZ0YoWy3zcN1bqhMr12zPyUkxC1Sbbs+NFL8Mju+B7qSFV106hOs396BWbeC+4wXc8cwcqqbhxV5RJlkqMRZp0aAm4qdFxEPWRwzS9LEiW9vmee8KuVQVmJLezqv1gN8qcy+NHmw0NDQ0NC5MWNUyDh09jmoxj22jozg2k8NIfzdGBrqEWqZcqSIRNVAplTG0cBLF/CIKsS70r9+MZE8fjETKH1XPVUdJWsh2HKz6hZKkFa1XPSLK24Cyj/mVVB4h5Re+q6omOUdg+Y6+QfiRKRRLyOeWsLdkYNNACj3phFDsF0pVPHt8GtvX2qZw0XgaJdMma+y8PTWY68YgEMW5ST2uvorkyuQnMLX0FO0MU2+hWCojQ2USFRiRCA4cn8STzx5BJp3GlsEMskYDU/kKDHpvZn0MXkeVR0W0JxFPoFgHLhrIYGqpirGJWVRqNXSlkhjuTWF2dgYzCyQe07AiBrqyGdTqpvD/WqvbapN0MoFY1EAsGkWtWsY3v/ltHD16RMzdpT8cSUhFJCHl/p1/KqkwE7B2ZnntjoVdK9OulsRq8gHbwbVBn4Gt6r0SMiRMgcW/Un4RR/fvQ6pnwLG0MLGuN4P5oV5h4jucSYlIjPvzacRLpxCz5hCLJ9CX6UY9EsXTh44Kh/x9XV3YuONi51fkuMtYJWkn61pvxIQCqlqxHe3Tz9PaYRPrRwvu779cTuKLX69hKW/BiJool6MolhP43H9ZmM/RfBjIphrIdtHMvSEcojP/xTzw7e8vYfvGmDD/M5W1FFWW0ahtLmilVtwEDQ2Nc01KLZVKGJtZRKVu2/YuFCtCcjzYk0VPJoGY0YWp2QXEY1Gs6e9D3bRw8ngRSfrQEI5iLWEz35UwMJCbRPnYU0htuULsCtnGYvYjQu4quYSPZEFcBB7uLofRvBthH5XkhTJYKBH+BI0T4EHC1FGuyZlPBitz91/nklBO3T2LvGZqyhc5LpBK9enUalDyduSUqZPnS94jtJSdz5htmSfk/RevyWDHoIHdIymMnZzB4EAXfuSifuHw8DsHcmgo9VMVZJJCsrvEb4co74tbeUkehk0IlEao72XfSAWZUJP5LvIcorpqddZMvXetBsi2kuKWpzQ0NDQ0NM5rmI0a8vOTOF7OYzGXR7x7CEenFmE2Ghjs68F1u7Zgan4RPdmUUNMMRutYnDyGxw88g9H167Ht2psQz3S7QWlsgsox5Qv4iHJ9QsnzjJClmv8FTfpUP1Tq3CRATnkme36TO8OKYGJqGku5AroySRFC/tRcEf1pA0cnF5GOMRSwiSNTOVQajNRVxfBQL/L1mD2PEC4JFLM9Jdqe9FHq+a0KbIKK/2TEPVkpde7ibdqRkHrmyEk8c+g4sumkUDrRD9zY1Byi0bgglmbyFYxmDESicTqqQzIRF9eLCGGNBkaGhhCNWChXa1gs1jHcncTMYhqReEr4CDPrDawd6cbx2RLK9Ypwkj41s4ho1EB/bw/q9Ya3UVqt4OjRQzi4fz/yubzdIKGKaoj+kkp/muvZ0fccoop+qS4AtCJzVkoMyXMrNTtbST3boVVdw4iuFZfBy0wTubkZJHoGUD5yEqlYFQYj7UWB9X3dIkJ6vlzHkXELvfFDuH1tN/LTBvq6u9HXP4D5YhVXXnopbrr5ZkxOzyCVzaBcKiCT6Vq2PsuZJBLJhIld20uINPK0JhXfyUSMRDTQgIFYpIGlpSjmF/jbjuAVL0ph26Ya5hejODnJgCZxvPTWKH7sRy309dJHVQxmxMBDTwHfuc/Eick6ypUoutIWyhULtbotPaC6tFEzUa55a43lHM9raGj8EEmpxVINxWpViTZgYmJhEZuL/SKEbU8mhXQmg3KlgunFU8h0dSGWTKEnk0RflmZhEaS5XWZCSIZnnvgB1hhRRAfWoVbMo1oswCrn0bdxJyJdZPBJMXjSYU8F5UmaVJVO8DHhI5aUHThfWlX948AnrQ0QTs50xueQ3HWH5Zz3FE8OIRTmBFBN4Ysi6E/T0rTRVRfZbZPdopJREmqYZSNi4qLhDF5y6ZDwH9CTiMCsVTA+vYjFQhkL+QomFwq4ZOsoXnbxEKoNC/cdzaHO2ZriM12EUg3ra1+/+xrTEqJeYQkDDumDPsI868c2js2betYhsZzk6vdA3UnV0NDQ0NC4EEGCqNowEatVYVXo07MGJNeiWEnjxMGT6O3pQk93F3pScTRSSdQrFWxd04+SGUFudhpzTz2IkctuQLyrz1URcdGmOimXRJNKPlH3Tp8sguRxlVDSUbQ0w7NdHYjIeoq9vuMb3TXNi1LuoETlk+P77OIixqemMdzXjXjUQL5UxoPPnsStu9YItRTnL0M9aeTrwPRiEZlMBMbcPLZvWIPpoomG5YVCIXx7ZU5bXNW8YKmW9ysTNmc4fmoaTx08JlRPZrmOcr0ECyVB8qSTDLxgIGLEUKb7UbOKYt0URFQjmUCFhJNl2SZ5QnkPTOaqyKQTGO7LYLFURz0RRa5aw+HJJRRqBjLpOFKpJGq1qsgnYZno686iXqti7Ohh7HliDxaWFr35kuPE3HWK7szppY9VGW20YdbPS1/n7dRGwY3p5dApuRSq9A/J63TQjrCR51vV1xfBO3Cdq0Sq15DL51Cs1hFLJtHV042uri4USjOCAKW567HaCBZjA7h9UwQXr40ie9E2QQAtmlHkj59A98AQRke7cdnFmzA3fRhTY49j6+5bz0g/1GpRnDiVgVVnBEhG3bNNXht1A91dFrZszqNUMVA3GyKQ1o++LIb1QwUslGJIp4DFfB0vekECW9bNw6CvqFgVyVQJV+xO4K77CqCmguat/NHm8iaqdZuQihp8ZbAVwEj4SbTzWS2oofG8JaUYNYhSYsqMSyU6RrRD/04tLCFD2Sd3ZYoldHVlEDfrWDM8IAbz3NwcUvGoYJ/5kCnWKujr7kOsXMCz934biKfRqFZQrdeRScZgzB5B7yW3Av12aOzWuxuqz6kAEeIOtD5dlXKtZ+pnK2vCdyE8UkRxThWQequ8h6vcclVKKkXllS0nBT75sSfiaqHaUtoqEnNSx8IcLwvOtqOUpNu+rOx0PBKLmLh2QxfecO16dCcj6O2yfYJxN4KTO5pZ8h6OjvQLNVykUMLrruZEto4nJspiMmdPXOy6C8fuQf9W0gzS193hg70bgtm3A+RruNMb9iQ2eI84UbMntVKC284dp79X3fopSjSRKlzMpaGhoaGhcUGgRkIqGhVKFzrVNqw6Jk6UhBY9menGnhPzqJvzuHXnWiSiQHcmhf50GgencphcLKJ/fhbG0w9h7RU3INnd65BIdjQ81QWAOO6QUNKEjws76fvFdUyuOEd31VDOhIbRAeuVApKJBAq5AuJWRSgwNq5fh3okgTjjuxsRxBMJEZHu0LGTIu98oYhDx0+hUK4gEYshblawaagHqWgU08KlRBzJVAb1hoWDJ2fRnYxi45oBnMrXQV1QrVoXxE8imRC+mHxmeFKupXxU3/lUUYqim2Adx8an8cjTh2DQPQXJuljC8bVlCp9QJAGKhRJyxQpyBVul1DBICBkwovbfQDYtrAwKpQosKyJ8/ZxcrCHJ+VAE6OlKo1w2UKrWkElHxUI7lWS0sahwak5fP3uf3I/DB5/F3MKCULzbcGUgot7sAx4zLduxOUwSUQ1BSJnO34WATk31gtd0mq7TPIPXhBFE7dIvh1Z5hamRmokpE4WlBWH+2jMwhJFyBX29Xcj2DiBTrGDfVA17a+tRa1joKj2IB60rkTSBF13ah0atjCce34O5QgVdC0uINOoYXdODhEEyNK+4hl2+j9qlSSRMbN9SRaRRdGWH/A1TzWBH17SQTlsgr5svRPCxzzbwhldmsW6thR+5NYv/+4UFYdrX1zuA4b46ao0kCtUkHtpbZsw+dKUbSMb5nbYwPBwRTtMrFUuoDBl9j7/BRiOcjDodhZyGhsaZ9imVSuGiiy4T8t6xscMoFfOCzOjr7RYDGMOJMsILB9itm9Zjz8GTmJyYwuaRPiQZpjNi4ordm7D30AlBpAz19WEyP4NCbkn8wNPJpHD2mGqUUXjiDqQ27EJi02VoxLOc+bTfsQi+cZVULR4cQfO8ls8XhzgRDyJvt06m9/w7OcndNJ6SSlXmqNyZVPdI7kWQY8JEMFhNhVlzotf0pqK4dlMXEoaJcqWBw3NVzJca6EpFMV+soVLnrqWdN0mnTKyBl108iO39CeEY86GnT+KWK7cjTRIQwLYNw3h4sYi5fBWILGF0uAcz83nhLPC1V6/FzD3HcSpPCa2n3xJ3RAnK51Va3iupcpMKpiAp6HCHTgf4VGzOMea0qS8mJnrjSzUxoZN26/Tv5bp2cFnAVoO/X2VlJ/U5EXNl9w63p6GhcQ6xEvOE5wtWG2lJ4/mNTMJAxKKxC5URdZRtd7549uBB1Iw40l19MONZ7D81gw39WWEaM1OoCfOxdDyBhWIDS+UJRKMPY/2VNyImiCl/lDxJQkmH5+J9tYShRB2RRBbFmgkrmoApztvjq2+MN7moLOHpZ/cjbVjYtWEY9WJB1H1jTxK5ieMwjQTmS3Wh2qkgilo0hVy+iKXFRbFJKgLGmSaqVg3HZ3O4cutazCwWMTrQhVM5ElO0TqsLcmc6V0GhcBKL5QYSyRRmlopIJhnVzsDG0TWISkfvAc8D6qs7l3FYqEhgylOq1PDY/jHsPzYuyh7s60WRUanFxl8MucISMukU6rW6IPOS0YRQNtG6gJnFUinEYnFkMylEHXcEdFJP1Vu+WELcBOZrdTRqFWweiiPZnRHElmE2kEnHxHyIJN/4iTE8/vijyC0tKTNRTxVlN0VxQyF9STUcdZT4qwnH6xbN+y4gX1IrMZFTVWJheXWijFoOwTJa1aXTuqvpOvFxJc4J/2YmioUcZqcnUCkVkMxk0Ds0jO6eXmy99AosIYUTU1sQXZzA5b1T6Nu8AU/MVjEzm0etMoh6eQmXbBnFE4dO4MSpY1g7EMWWK+nbjfVtuL+J5dqwHElXqcaw/0gSkXrW/l2ZjPhXwfp1OZcUHxmsYff2BO7f08D9eyp49GmuH7keWBLKxAf21LHvIJClTaJhYXCkjoEhm4C6YlccqSRd0NhrOj4ZiyULpRKVUhZiMa6xaL7aeiGgx2MNjR8yKcXf4IY1ozgxcwyxSBQb1m9FNNKAZdaQNoowrAYm53LozmQEG79t6wY8vv+kuK5YLgmp5XyhhnS6jC1rh1Co1HDg5ByKlE7yQeNEbCnShK8viZG+HmQxj2fu/zKS63chvX4XjHSPTSKpixfFiF/6IGh+3IU4OQ/xT9QOjiDJLwtySQ3Fz5SogDercZ2dq5e5fRqc6jTrqhw6zG0XiaaL16TxIxf1oruew/Gjx7F3/1FcvH4j4muHMNBloFCP41gOqInJUwyjfSmMpA10x00Uy1VhqndsfB67NuexZqDbjpATjYqSc0VGsImiMj6PLev6MTO/iHVDvXjD1aP4+APjWKw6TRV8k11T6Y+hGf5G+5MpkXAUGsj3sDctjBh53L5xCMODvTgyXcLh6Rxy9ShOLNVQajjhpqUjCP8+ptLXLZRaqr8w5Uo93mhonFtwkrpnzx58+ctfRm9vL975zndiaMgOdX748GEcPXoUL37xi93009PTuPfee/G6172u5QSReX7jG9/AJZdcgs2bN4ee/8EPfoAbb7wR8Xi8ZR7f+973kM1mcf311+Oxxx5DqVTCLbfcsmybSAaMjY1hy5Ytbh0nJyeRz+exffv2ZftjamoKX/3qV8W1bOfw8HBoWtZndnZWlHXVVVchnU6758rlMr74xS/ijW98I1Kpzry3zszMiPx27drVUXqN8w/RSARD2biYc8VTUVTqDfRm07DMCGYXSkJ9k4xFMVfuwUB6I2KJJMYXiohEI9g41I1ytYFjs3lETk6jVLkXO665QSxgPVJK+pSyx9gYSRGrjC1DMZRLDdSsIox6DRErikqyWxBhQj3lqM1r9RqOHjuFo8dPolAso7+nC4cmF3DdtmHkF5ewbV0/zEavqMdDh2cQj8UxNrUAK161Caq6iXK1hEwqhe6uLBKxKKKJNKaKNQzRvG2pJDZCa6aJ7nQCPWmSbRHUasB8oQqUqKAAEklgYnoB8/MLuHjnVmQyGYU4k5tl6nwx0lKlzyRHTkzi4LFxoVRjnfgMqNXqSMTjsCKmWFTHonGhYhIbezRLsqgEaYi+NBtUOFWQotNyy0StXhXR8sqlolB28blAJVo0EcdMrogda3oQjSSRrzRQrDZQq1XwxGP349jRo+5mofBZKiMxy4A4blRmU5CXVNRREeURUlSNOP6kzmPLpU78PrU73o7cakX4rERZ1alKKqw+ZwIyPzFlNxuolovi90NfY/ycSmdwcmYB9x4poV4qYTi6hDde343to5uw51QVRiODmfzTiKfSGBzoRvXYEVy0rk/8ntYMFnDpRZOYmSblvbIIjWF9LdudiNWxfrSEGAriu24YJFPritkwCd4q3v3jCSzmDBw42kCtHkG1bltpMMIkFYrFahQ1i9H34hiMJBGJmLh4Wx0ve1ECRqTqbIjbAoKebgvZTFRYjpAwtr0bh6ukNDQ0zgtSKoJrdqzBgSOnUDEj6MsMYHp6HGNjx7B22wjqpoGTCwVs32ChUq2jVi7guku34cGHFmDWaJaXRL5cEVH41g31oVBuYLZUEw8QDshWrYb+TBLpWBo7t2xArljC/sNjYkCcfPJ+RPY/hY1XvACJ0e1ANOGSHKrXJS+Silvr1gxDwGQvjLjwBgfPJ5XvGtc8zqONXAmrktx94LrEiaKTcs3+ZB0CD0KF7IqYEVy9MYnrRyLYc9+DiNdyqFYqWJxfQiH3DI7NN7BhkIReBmtHR2AZCfT09eDyrYPIFeuCcJpfLODE1BK6sknk6UNqcQlbN66FWanjsh3rkEzGUK7VReQX+gKLGinsPXwSF21eh1fs7sdX9i2iwh1QRyYlLRqbJ22Bliq3xXMmqg7uchC3j6/LALOT0+jOipka5uYXsLYrjtx0ERcNZXHRYAp7p2uYLELYhNOUUNTGMR/0bmIIJ9lUX786za/J09DQONuYm5vD+973Pvz6r/869u/fjz/+4z/GT/zET+D48eOCECLxcuTIEUFEDQwMCKJnfn5eEFkTExPI5XJ4zWteg4cffhjXXnutuGZpaQnf+c53BKH1cz/3c3jwwQcFKXT55ZcLgoaf77//flx88cV44IEH0NPTI0id73//+2JxeuuttwqynnmSBLv66qvxhS98AWvXrsXo6Cgef/xxXHnllWIRt2HDBlEOzXKeffZZVKtVbNu2Df/0T/+E3/qt38Kjjz4q6nTRRRcJx9Ikw0g6MU+2bd++fYIcW79+vdsnX/va10Q7SUY99dRT2LFjBx566CFBspFE4/HxcY7BY7jnnnuE6oPvScDdcMMNIg/2D88xn0svvVRcXygU0NfXJ+r9ghe8AHfffbfIj3VhP3BMXrduHZ555hns3btX1Iv5njhxQvQJ269xfoMmLt0pbvjFMV8x0d+dRDxqYSARRyFtYrZQE2HQl6x5HD9SRaFuYM36DRgaWINUIopqoypILG4a1stF7H3gHlxxzdVYt2mjiCxci3ATy95IbFTLsIpLmCsUcc3GbYj3ZbDvxByS8RhyC7NAPI9YdhDlBk3wUiJq3olTkzh0/KQgXNYM94vvX7FhYHKpgqs2DaNWriAZj4o6dqVTWChUURcuCCxkkgmY3V0ichwX1plkHOtHBpFIxjGxVMe6gSzWjyRQmshhsWKKfKj2ySTiXM1i78lFYbLW19ONYrGEhVwe5UpN/G3bsh5rhwYRi9E7ljcvsOgc3XFXEQSPc7Nv//FxHDg+Lgg3Rr3LpruBSBQxhqZnQse8rur4fIpFY1jM5wQZxHw5F+Jzw4gYQt2VzqRFZLRSuYxqrS6mKvEE1WGWcHDOTbmT82WkEjGkE3FMzU7jofsfwNT0pG0qqVbQmX4qWhY3uh77kP1smrYijcSY1WgIssqeG52frFQrEmk5lc65qlcnxFSnSqdWaTpX0lqo1WooF+hTqS580dZLFTy851l8/LsHsVQo4aXbgd5kBMMbt2PXJRuwcWcF1e/vww8erSPdlUUq0cDQYC+MdDde/JZXYf3aBTx674ewsNDA+itqy+7ut9s8Ut9XasDhowk0allBmjIa3vBQDetGWIatYOIlW0dz+MB/z2DPMwk8uc/C2ISJpbyJWs0uJ5awkElFMTQYwxWXW7j2qjgu2sTnQLHJZcr8ItetVEgZYjM8LiLz2SbHat00MaWhcR6Z740MduO1t16M+546jqeePYjDRw5gtL8H2WQCuUpVOGxcKpbF4DZ+chzzxboYMONR21kjQxGfENH7TJxYygOxJMw6HTpyADSFw8qqwQdLHoODAyJCycnJKcznSyguzmLsoW+jd/0RDF52M6KZXrHrRKiycAHVnqzpGeJpY7zPklhyPvkePgrlJY7787IHfz78IijXLFTrUkDlt1X3iCnnuMy7acBqjhhoOOk2D8fRX5rE/mdyMKsllCsl1Cp19HUnMLdQQdyyMDtfwvBAL0YG+rFm3VrhL6FQKMKKxDEzM4dozECtUsFll2/G5nVDKFU4QTIRj9LvQQS7t4xgPlfEoROzYFAKqqQ4WWOknnS1ils3ZfD9o0URWdFth+MkwuPwFHM9R4Iu+8A77ymkPLUUkIwCsWoJ8yfGUVrKox4fwLqRfoxPzwuHh9G4gZm5RSyVqtiWTWNzKoXFhoGjuQiWOGa50nqnqJAxRPJ/3l1X774z8dRjj4bGOcOpU6fQ3d2Nl73sZYI0+pmf+Rn8x3/8hyCKLrvsMjzxxBP4yle+gpe85CX4y7/8S/ziL/6iIFNIVPG5QlJn06ZNKBbtnWA+m0iwkMB5+umnBQH02c9+VhBdfCXx8upXv1rkwXypKCK5dfLkSZGeBA7JI5JTVB6RUCJBw1eW9/GPfxxve9vb8J//+Z/o7+/Hm9/8ZnzrW98ShBDLYhpG2iJxxDxJblEF9spXvlIopUiGUQ32+c9/XnwmWUXSh2SQfE7+yI/8CD7xiU+Ierz+9a/Hxz72MbzlLW/Bpz/9aYyMjOClL32pUHFt3boVa9asEeqmjRs3CjLriiuuECTVd7/7Xbz2ta/FN7/5TVFPknpUoDFPkn8ktdhutp8KKZJnvAePPPIIjh07JtrFdjNvpmFf/ezP/qyenJ/vEENrA+lUDGY0jmK5hv6BbuHcuDdhoFg1UKrTvC6KdMxCzWrg6LEjiNAJd+8wejMJ9GVTmCpUYcTiiJgN3PODB7Hr5ElcedF67Ni0EQuNuPBjlMvngUYFU8UKnjk2jWsvGsXoQBYnpnMY6u0WBNCR6SkcXygjEksKJUKt0UBvTze6s2lBztCH5ezMPI6jhtsvW4clKoYqVaGgH+5OIBqP4fhSEfVaA2nhN8lAKpnFQG+3vXkWjSBmGMgXy9h3bAa3XjyKS7cO4bEj87aPK4u+lxqIGSaiRhTVWg0LS0vCdI4E0kBfj/CVM/3kIVy6pYCt64aRTCftxXutgbmlvHBPMdzfg97uLqGal3OgYsXEvXv2Y2xi3nGYbKA7kxBKKc5lk7G4/Uwi0WNEUC5VBBFE8oeLbEbKs6P1ce5h121ubh6JKJ2Xp9GVzQrzPRJWdRJxjhokFTdQrgO1egnHjzyJZ/btE31GUkuY4gXMoeV81D5u+QgpoYyiQ3OhjuLCv+GQWXYUvgsB7QiaVr6AWhENQWIpWEZYvsH0/v4OuwfN+bSq/0rbG8ybGxCV0hImjh9BMp2xXWMYBjKJKHYMxbH7sgyuuXgj/t9Dp/DR7x6GlRnAi69ej7e9PI59xyZwx+OHcP3mLsxX0xjdfQ1u/pFXoJp/BONrDMSjJDQ7IwI7qWsybmHrJkYELDq/DzsinyoMEAQx3Zh0FXDb9cBtN3KVERPuRYSLEfrZjQLxOCNaRpHO1pBMNhhezzfvp2da/g76e+iahO8jsBpRNBKOitCu1Kr6XUND4yyTUhUT+N4jBzA2OYPp6SlkE3Gs6+8WDHx/T1aMXwfGp7GpvwdTUzNYv2kT5mZmUSiUEGPkvUQcOzaMCAePW0aHUTy1BLNuoFivCl9BhUoF2e406g1g74Fjtj07gO5UAqVqFdVKFdWpQxi/bxboXYu12y5BYmiD46g84K/AgVQoqXb1zhnnGsfEzu+2yZVt0yeVfT4o47bJFcrkd40k8cqL+3Do5CLuO1HBRL5uy6Tt/xyLP8dBuBOfT9ZURuuTdXJ9JDn+kiRxk4rUcfu2AYwkM9jz9BFctmsb8vOzmB4bw8zcAvLlquNUM4b9RycRj0fQsBoYHB7G3PwSrHoJMwefQKRRwe6dVyARjWBqZh4D/T04fGISG9cOYX42h7WDPUgnU5iey6OvO425hTxiMe7cNXDnnfdg+5Z12N27EfsWo2Jy5PWz8uxW/Ts5UXlUQk+Sid49s/sjallIl2aRn57E1NQ0Bgf6sJRbEo70t6wfxEKuhE1raVJYwN4jB7Fp7QBOTU2gtyeLK0fX4v5xCzUR2cd2yB4Wdc+5Fe5uMocdTuDk/XLcsq78x6GhobFqkLxZWFgQ5BMVOlTjkFR5xSteIXZ2xeKvWBSKJGmeJif4VAXxHIkWqp54HReBVCPRBI0kDNVPJHKoNiJ5xDyZF1VXLJevVDaRVKJqg4QW85Wmd1RfkRQiEXTw4EFxjAQQX5kXy6Zai5937twp6sP3JLGonBKbC1QFM/QPIEgk1oWk0ote9CKhsiJhRDJJmtlR1UQSjcqmz33uc64ii/WTZS4uLor+IHnGz2wv2820JJlIkPF6qspIerGNJPpIflE1RrKJ17M+PM46sZ9YH5ZDoo/kFEk/Xssy+EfCje3ROD/B6GzH5+rYOpxAf6yBfCyKycU8ekiyJgEzZ887CtU6GqCTcxJVJvLz4yKQTSO9BrGogfV9aSyUaoLwycQNPH3oJJ49dgo3XTKJGy/bgXVrBzBpxvDksarYzHny6ARyhSIu377W3rIzgJlcFcfnK6ia9KHkuVno6soKxVAqFUOuWBR+lKpWBHc9PY7d6/sQiwH5YhFDvSmcWlwQiiMjERcBcRhlbri3B9lMUpAodDkQNwyUqzXkooaIJNydTSFLq0HhGJxRvKgWqSNi1pGg3Z5ZRzKRQiRaw1KpgkqtLnykHpuYxVKuiN6ejFB70Sk0Jy+cM02MT6BcyKIBEn1V0Y5nxqZwaqEoNvf4xw3Y7q6k7Tuq3kClUhK/QYIElDB3jNJUiPWiOV9E1E04M6dJpMH5i4mZ+XmMiGhgCaH2KpctUT+5yce5y9zkOPbueVhEU3M3Z90oeiGkipiHNoRqi/Nr8WwlQSb+HELKtOdDJBPtAH0rM806n9HK/9RK1E3Ba1vlq5YZ5oT8bPheDHdubqHRqKKYz4mxhVYFQp0XjeLyyy7B5k3rcfzAU7AaZbz9pTtww8WL+M7De/D03icwnDFx82Xr8djhRdRQwStefjve9IbXiuADNSOGdLKOTNp2QO5bA3TQxrB6CrVgI4aT40k06jaBFIsAA311rBmiCR+j5jHquL3+khE9hQP0aMPzdRcl6UZ/d1FB9BqW2LG211TSx5fzeyAxNbtgIZ/n5nxM/H7jPfydCX8tyyrAWvW7hobGWSSlOEB998FnMTG3hPmFBVSqFWSihtjtKVYYDSGJmGGhUmmgZgKnZpawZYuJgb4s0nFDTAa4W5dMRZFJJXHdlZega98Ynj1yCoXFRdtWng7s+rqEOYOwJUYUi4W8kEBzl6urN4VSuQ6zMoO5E2PA7Bg23/pqGL2jNpkgWSOFPJIEg2tmJk3m5OAgB25X6eNF1pPkkc8k0CVW+CC2cM2GLG5YG8Hk3scxc2wS123cjsjoICzDwFOTJeSqlojoQAm9jPInTfWkXb9LXinSaq9IS/hr6LUWkDZ7MDI4KAjAfU/tQ61awc4dW4D4CZyYKyPDXba6KUILz84XsLUhKBfUlqbx2Y/9K556Zj8uv2w3rkpsRD46ga6EgWg8jpn5HIb6ezDYk4HVqCEWSyCT4aIjhlK5KnYfR4YG0N/bjacfewLDa05iYM0VmDe6XXt1z/wwIEKT55zRwjXoc6Mq2k4Fh5LA/NQM5mYmUa/VkGJcViuC+aUy7n78CN72sqvE94NRgvhdGxzrFfL7R/YdR6lm4fKdUdy0MY6Hx2uocoKnViDwydmYFEcSaKAvUsKO9b04vtDAyTwnYKc/uLBf+D3mAtn21wWxUORilSY+Z3uXheVTgcGJJsHyWO5KF5LMhxNqTmboWLaT9BK8ju1v5a+nXR4kurn4bddXPM8+5aJ6JbuLK2lPsD+5W03Fib1wWH1beV+YH8mETuqxmrZeSCAp8tu//dv4t3/7N0HkvP/97xfEEI9z4XTNNdeIvy996UviN0QSiaZng4ODgmCh6RnJJ/qQ+rEf+zHXHI0KI5JF//Vf/yUIKx6nCor5Uu3Ee/mqV71KqIt4H0iOkQyi+oh5E1Qx8RoqnqQCiffv3//930UdWC7rxbxIVPG7xe8J7xUJKSrAqEaiHykSPgTPsS6sE78H/P6wffT/RGUTr6Ep4ac+9Slxv+kTiiaOH/nIR4SSjHmxzsyHZZLMI4FGsoh5si0kpN71rneJfmAbqCpjGl7DuvIYSaivf/3rgpgjCce20bSPCjPWVZbH/mabSdpR5UWSjnXUOD9Ra0Qwk+cirYztw3F0JRgVLyY2/nozKSRiEbHJSHJkvljFut4UepIRsRBs5Cdg9GaxWMugYZlCNcWxsiebQn1uSSjC79t7HJOLZWzbOCo2p/q6MyJyLwO17T85jygjwJkRVJJRHJ0pYL5kCrNAMR5xE0g8P+2IzpxjcKMqm46jtyuL43NlnFyYxI6hNLb0p4RSXPwTTo4jQnkvfEhFLLFgrVlUUtgkEaPOFWoJzOarIoIYzf3y1brwJ0X/SCJqXSaOk4slMReJJeilM4ZqtcwBGvG4gWqtgTL9TdW4sHUWt5EI1vVnkB7JYt/xBdQitllRrljG1PwS6tUGotEYytU6uhg1L5lEsVRGIZ8X8wAudEWd6Q8qagg/UmwP59Vc/iY4RzadyMU033PmSfML89gwMoANA1lBSLEN7G86pj+0fy/27XlEEErsT3EFiSW5taYaD0hSxFGR2mZ6NhFF31GCFDPVpbrqt/XCwnIOwFuppoLoVCXV6jo7UnVnpNVK0MpMsV0+wg9bPo/JU8cxtH6jUOyl4kkRQKpRK2D9hvXILc5iYt+zmBk/iS3RPGolC8NrtuGG21+CVzYMXHzZpRge3SCUhuI3HAH6euso5Ug+izAHHZu4qYqxoFUJrWy3bq4BZtEV65F8YrAjpqESUfStwfWNQ3KrQgIGVnD8T0mSiu8Z6EENsCT/KDwYHgAGeyMumWsmHAdskc6+F8/FOZmGxrlExOqQ1uXikKC08ff/6hO456EncGL8lLB5X9efxUAmIeTUawZ78PiRcaGsSdHfRV8XdmwcRLVmCkk4H4J0IkepdFc6ga3bNmLf8Vk8tv84pueXxJMnChPXbV+HbCohQuJWqg3M5YuoNCxMzeexc90gDp6cFBH6uGvFgX39+o0YuOFVsNK9gvQJaqVUb0Eq2RTSJfaArPqA8sHvsDwTNYWz8b7aAhoLkyjn81jMFXF8tiRIEjqqvPTS7UL6Xo1EsWc+iiMLNUG02DuF9i4ZJ4L5Sh2VBsuUuyg2e88SEzDRW1tAvJrH6190CYxKCU8//Qymp6bth20sjde+5nYcOXoCzz5zELlSFSOjI+jt6sL84iLqxQXc/V+fxzNP7UUjHcebf/ytqK65TuwCbF7TL6JT7N6xSfhB2DmaxeLUCfRsuBTff+wwUvEYrtu9HsdPTgoC6AcPPonF2WnhJ2L7pZfg6cY65BocoIJ9pZJ6anRDe8Rg26RygG1IVwvA4oRwOFqvVkVkkN7uLOq1KopVCy+4agdefdNFYhdyqVhFX3cW33v0AHasH8HX7t0ndhJfe9NO9HWlMTZfwbHZIkpmHEvlGjIxWw3F791gVwKlQgnpaAM9Pd2YmFnC9OQUauUyNo/24oYrdmDPVA1Hlyz89iu3oSe1KkGhABUMP//zP4/f//3fFws84sCBA/jd3/1dsZhVF3RByXcn8vDlIpVxIvxTP/VTwhcOF790Hk3/NlyMLpe3eoy//9/4jd/A//f//X9i0dyuLvxMVQVNht7xjnfgd37nd8Rimn5olrtOBY//9V//tVgsf/SjH/X52VGv+cxnPiMW2vTZ004Srx4nucO2vPe97xWL/k4i+PAcF/i8jovyP//zPxfECdUkbCsX/r/0S78kzLGoeumkb2km9au/+qv4zd/8TbzhDW9Y9j5/8pOfFGqVP/qjP2rbvtOdHK2UQAwbK1YLOYlv1QYqlagCIlHJfuA9ON3yTnfHutMFTqfn+fshyUQiW43aFFZOp/U/nV3cdmXoifj5i0988Wv4tf/xQTGGb+pPYrQ/ilK9gTpiyJUh1NAn5suCvOpOxdGdjGCgOy0i1HH+lk3GkRnZjDkzJdRS+WJV+KFMOYTKQrGOGgz0ZNO4+YqtSKfSODGTE99bkjiVOmDEosiVGphezKEWiQnVEVXNJJLERpYRFRHv5hcWxfSAzs6phipWq4jSZLBRQXc8gg39GRyeWsSpJUYGjiCbTgnn5XGDZE4cXdmUIHomZhaFu2WeS8ei6I3WYEYY+MXASG9aEFOlcgWTS2UcX6ggEo2JBS7VTNkUHaFHYdbrYq7LOUU6nRJkEcsRLhqMhjCpKzeo7o8Ildcjew+hUG3YLhDicbFxkEiwrQnk8zn7cywq2pyIc0HNTbGYmPvULKpCbMIgGYsIgo5zXYIbcFSnUa1GJVUmlQai9nyEec3PTuOu79yBRs02cZS/caF0UgkZ/ic2Dm2FlNWgmZLtxNw22bNJKXsxTpM9WynlESoWtm9ej6/+xz8gnUqeF2MFryXpr6LVM7EdIRU834nJXiemaKsZl1fyLF3OMXuYAqlcyuPo3j0YO3wAa5ygH7ZysCqI6FqlhNziPOZnprC0MCvUhH29vbjmBS/E1suuRzzbByPC75+zW04/akuP4oFv/QpOHC/jpW/8fazb9vomCrNVHVu1iZibfBL3fe1taNQWUa/ZwQnEuoy/HQbTMyxhird1yxISMTvCJnkyW2Vov+er/TmOiNGDRHI7ooktsEyaBNZFtL3x8YoTuEpuRNuyAP7mUj3XY/v1fwgjklj2/qjjtIaGRjM6GStWtdpOGhZKhSWhkqLp3nBPF1IxOwLa7EIea/t70KhbmMmVUJ3PoTebEERLMmaguystpJEcbLlrtOfZMdz/zDERQrcnkxLmZ/RhQJMxRhAZ6h9CPl8QEtOphQISMUNELOH1C/kCdm9Yg4n5JSQbeVQOPgirfyPS63aIEMQ+KP6F3HC+zntvsu4RUl4kP+Uq7ma5n+38tvVFcWm/ib1PTWL8yBFkkjFhv7xhTQ8mZsuYmpvH3Xc9IEifiBHHjl07sGnjKB6dKAuHn8moga09wM3benByoYxTS3QezsmOKT7nK5x8mBi0cjALc6ibJo6emMYlm4eQSUaRikeR7e1DzYrhjrsexqtfcQu2bNmIffuPiBDEXZzgxQzc89Bd2DCxiL21OnpG+pEa2ISFqgHTrGF2aQnjM3wgRzE82I17D+7BpnWDqMzM4ZlDJ7FxdFBM0HZuXicW8z09WZyYyWNgx1Xo7e3GznIFT+czYrDgLp8bRE886C3xfelL0pdDHam4LYZdaEQEAceJFHdchLpueh75+bzYxcsv2T4gOOGjfH3Txk3YRcentQaSybjYOcwk02JXkoMqzfrK5ar4HpHMHEpZmCxNY+twP+47ehiVCNCVSSO3mMdcIiYi1FBtdeowzyUx54SFfvzZMawd7sMtOzcBR/OnvTvIyR4XmPTDok6mqJjgOfpsoQNlminRRIl+W6gAYaQxKhjopJkmN1RNUClCgoaKihe+8IXCjIZkCAkZ+tu56aabhB8cpqMqQn6vSUjR9w4jhXESTCLsvvvuE6oKLnxpikRH0nfddZdY4NPfDckrEib82717t3ByzD8qJWhexLyp/qCJEssl0UbTKBIF9EXz4Q9/WBAH1113nfij2oLKE7adZk80B2IbWDf6uWE9SKAxspo0y6Jqg8oWqkfYbpJBVKmQlGEfcUJKf0BUfbDe7GfmzeuoPKJyhf3BfuX7O+64Q7STig/2D82WpE8dWXempUJE9h0JJ5pW8Rj7iSZfPEZfR6wn28O2sk8YlY2kFcs8dOiQ+Mz7wr6hzyKqWkjMSUUU86cvIYJKGLaFoFNu1oXX0XcS+4Z9x+8Gy6ZShvdY+lIiAca86bCbDq1p2sW68vt8IcLe8Wz9y6Mp21vf+lbRj1z8ni4pciavP91FhzzP73TwWKtyVlL/1bZVE08XJhja3Ig00JWKo1A1UamlxDGaag13J8VzZMtAElP5hiBeSk7kqnLdQl/GQLlWQ2JxHEZ8ANVaApl0QgSyuXRNj5gvpPpiWCrXkS8U8OCe/di2YQTd3T2IxaOYK1RRaRhYWioLR+mMdmdE6mikk4iWKiJwifCJlIgj2miIaHNdmZQgdkrlGiyqOAxGxVvEQjSGqaIJg2Z+UQNVC+iiryc20lFIkJCq0P+UMLHj6jSKUi2CuGliYr6AWCqJod6MiIjHC9f2JjCxRP9WMbEZRyKHcw76t6LzdC7UScBwDkLSiuY+UauBru648CO1a20/JhbLuPOR/ZgvlBwltL3AZz58rZTKguhhnbjxyONURXHBa88hTXQlYkL1VKnbqrF4xEIyEUPVUWvYkcc4XzXQqFPtRaLaQC63gAfu/YEgEzj5CipyZN/YZnyeQ3P6i7LN9BqO/xx5zvYfxciIwqeO4lZBtOGC00q1xkoJplbohKToNN8w876VohUhJdcrIqjB3BSqlYKrlCP43eV3nBYvnHtwzTHQ341sNo216zZi7aYdiCZS7ma96gOX36Ndm5cwmMnJWixbz1Y+vdQ+iEZNDA/wOVHho0LM80XUPUE4MfqkhWjMFBYWslhPEaW6YfEifHvWD7zGRDZlYccWqiQbzm/A/p2JX6YZQV38Tv19q/Zv8LujCSkNjXMdfQ/A7i3DOL5lLYdI8fCiNJoMGE2+UqkErEgMpyw6pLZEBLd8qYqBrjTSPGeaqHHgo71/sYoHD55CoVIXuz696RQKlSqGutLCCSYJh8Nj4yhVTWzbsEY8KOjAMR6LYaCnC1XKpc0GBruzyNcsjD/9JAa7DmKkOI/0RTfAMuKueEeImgXf5DwMI34FFQky+7PHTakmfHbjPfKK/9Z3Abt6GeWhgUt2bUZhfhalxQV0ZbrQPdSHvgEDg/Pd2LvvKOIwUSzl8dD9j2Lt2kG8jP5PjAzMSgWl2UkcOzCFFKqwpsvYvGktunqSeOHWNRhbqqOQK+LgvjGUcksoFIvYl4xi57b1eMkrX4L9e5/FkbFxXL7rIkzMzOOJJ/Zi167twp/D+NQ8pucWsWHNAA4//RQSs7OYrVWwcWAQie5hrE9kMDu3hEqpgoYVwYGj4xg/+gxiuaO45LJ3Ya5YFRHtYpEIJqbnsXvLKKamc0Iij1hKkGxTixUR5W9Tbg6DXUkUYl04UTRQEfMbC4laAcbMOLq7E6gs5TFfKIr6bNx6EfbMmDAZkYZS9noVuaUlGJaJQm4JlUpZ9OOpUycxODgk7vfmtQPCKen6rmFwI7HaaCATjwuT0E3DXZhbLCJfKAln7QkjgnyZ5ot2RJ1iqSJ2UOlcPxaLo7c7I5R5UwslZDI0p8sjl1tCMpVBuWoKvxkv3TUowkmfLZBwIqFBk6C/+Iu/EMQKCRBG8yLR87//9/8WqhuSKZy8c+JAkoivNE/6lV/5FXzwgx8UjpbptJl+ZEgUkWgh6SLBiQfVRCQxSBCReKHzaJogMboZSaq//du/FQQKiR5OSkga/ff//t/xpje9SaiVqPQiccLFMl9JvpB0+Zd/+RdRNpVMNHmiA2T6pyFxRiKOJlP0g0OSi20joUTHzX/3d38n8vmTP/kT4cOGBAzNkFg/kj387pDoYZ9Q6cX6U3XF6GOMzkZSiI6eSUyQ4GO+bPef/dmfCcUSzY1I6LAu9E3EfqSDafYRVUl0HE2wjlRYsb/4nnWhGRdBwuwXfuEXBBlH8ofEEE3EpEmmas7Hskmesa+Zjv3Hfvnnf/5noYQiSfRXf/VXYhHI9wR9/TAi2v/4H/9D3Ae2gQTUH/7hH4q6s3yarv3ar/2aUKnxPpPA5D2488478Td/8zfiXvLcn/7pnwrV14//+I8Lko9mZ1KZ91yDWMg6/pY0NDRaoydlYF1fFPW6hf6umBjnl3IWurNUNteF6RlHuI39cVQaUSyWTBQrdfSm6Ly8ge5UFNVKCenaKZSNGgbXrEcvN4WKZazvy6BSt9AlTN0iyJcqePyZ48hk07jt2l3UgGNisWL7T7JsH0vcuGLkOT43s5mMeF4WSrYJHeeLJIPoekCcTyVRK5cE8U+Fc4WpRDQ4U/iSIgFFcogOznu60phfyGN+cUlslPE5W41ww8vAQqmBXKmMJDX4pom5Ihe6JiKNKrqiQF6UlRZKJqq3K9WaUFJx04oKJ5oCUolF9wUDmZiY/1TKDRycLGKMTtmn511CSC7yXbcRDmHGPk5EIcwnG5YhXAuIMZ1mU0IhZauoGoiKjc9YPIK4FRMKKvYbiSmaWDIqmFmvYW5mGo89+ijyuUXPXUUAcsFs+4Sy1VO2Y3W+mjC5CJf+o3wWSpLQsu+b8FolbaEuEKhE/nJEQSdK09WQDWrZqzERXC0xFVZXof+xLFQrReQW5oV/Jfl9teMR2b8/selu0sIjg2g0jb7+fvQMrEE80yVIXnfvXtZZkJX8vdZBf/0+z7jLqHmXI+3qjQjGTsVQL8cRjVrC1Livt4ahgYII3mBEKYSw/cSJPByXLKJaXs7u/w696tTXi/xtkdQSdTExOW0iXzAECSxMbbtqGFLa3O57oAkpDY3Tx6o8lB4+dgKzszO4YsMQLt8yKmTFUUcvyUU/JcgDvVmxG9Som5hZLAgbew76BJloPoRoZkXzrFQiIZ4ii8WyIAGGe+j40rapXz8yLB4wC4uM4JLFmoFu4cSSJFN3NoO5fBWpdApPHZ8R4YLLpTLyR55E9cge4WvAnhBIv012RDX3mIya59gTi8+M5sA/h8gK/uODSgRlqxbRkzuO737vfnzljodEtMHXvO6VuPL6q5HIpDA01IeR4T70ZJO47NJtSGSzuOKy7di1fR22bliD/NhhDFdnUJwex/TMHPoZ3nzbNlx9yVbhRJP90mNU8apLR7C11xCTtbmlHNJdvejq7sMDew6IiCvX33Q9rr/hGpwaHxdpLruM0aJquPKyXejuymB2oYjJU6cwNTGO+/Iz6BscwO7Lr8JijTbkNdxy9U5s2zCM4Z4ETjz7EO779ucwPLoeTxyexoNPHUW+UMb4zALSqRRKlYrwj3DgxCzSmRSmZ2Zx+MQUnjx8CvNzc+hOANWJQ9idWsSubAmD5QnM7X8Sjz36CB547EnseepZTE7PIVeoYDRWxkikgJRZQ8ZsYOnkGKrFPCzTDnnc3dWDhbkZ8R3o7ulz7cOHBnrEd4EmAPOLOWTSMVGvtQPdwuyAk8mJ2SX09XWJyevDe49hfqkkfD5wp2f9uhEM9vehVC5h/6GjmJmdwsGDB7CYyyEaTyCWSCKTSuD4+JwgXUXEnrME+n2haoeqGpIcNPXjwEZFEwkIkkUkZEgukFyhMookDB0VMy3VRySQJDlDMCoXCZjgDg5Jl5e//OWiPKqI6G+GRBDLpeqIJmwkv3iMC/7HHntMkB+//Mu/LIgzKqLUCRZJE9aNIJlz5ZVXishpJKH4R3KJ6h2a+qmDNdVRP/3TPy1UPCSTSKKRYJLHJLgYoIqICxISUSSWWCeCxA0jf5HMI7EjwXJIxjAvKqMYMYzKK6ahXyCa/1FJRfJIkkrsN7adCiieU+vAMrm4IQnGfpDKL5o+UtXERQXvIf3q8N6wrexrEnlvf/vbRT8wj7GxMUHisSyq02RdSdLxvlLhxHLoR4jHmY5qoNe97nUuqUbfR1S7kYQiSNixb6j2IilGgpP9TfKOn4O+rjQ0NJ5/IN8wmI1hpI+K6xrqZklMbmJGDFHERdh14TQYdfRn7UhuHDoySUZ0ayAWpe8iE4mYCaM4g6XJI8hEa0JJdWqpTH0B+jIxDHZRlm+HXuez+9ipGVy+eQgvvHQDLt+6Bv3daeGFmI+kkYEeYXrf190t/oYH+oX/Js4xODZx05GKjmK5JOY8nEfmC0WUiyXk8gUUymXbyX6MfkkTwtxPROEiWZ1OC59WxQqj6uVtYiBiu3ngPGE+b/+VKnXhm4YL8EaVedm+mBbzRRF1uGaaItLd7ALVHxGh1l/Il/Hs+CIOT+fRgIGjk7N4ZN9hZ4Frq8/EHNNRfIhXZ9uThFQmaglSKpOw/UpxLkqVR386imwCSCfopN3eCqWYi76jqIRPxKOIOYTZ/MwEfnDXd/Hd79wpFNRBosgtVzHjs8kHx4k530tVlKOAkn++TVlXVcI5NL8T9pz9QlPVyjSrPa+qzzq5Tk0bZj4XdlwtR7anU2WVml+QBFP/hLtamMjNzmD61BiqlbLjTEn6IuH7hph/87uWTCTQ0zOAvsE1yHT3igjonmpOlinLNXDsZB+ePtAj/JO1M7/vxLWC+CxMVy0MD9awbrQu/jasq2Kgn4EUlL73EVBKvu5/8gDJJ5vQtsuy/VB5ZdsR9tYMRbB9q4ltWyxs3lTH8GC4P6l290NDQ+McklL8/R47NY1ipSrMw6hoyaYTqNdrSCViYjeJk5KR3i4MZJOigEQ8hrlcAYVSRaha+BAUtvRCFh1FPEYbfFNMCOhPSoSkjVio1S0RFvfqXduwedM64SickVVopz861I/tG0YRiSXw8OEJVGt1pAyGJY3CqtUEMVWfPekM0NJZnXyQ2g8haUNs+26yOyPMMZ5wcilloyS1amXkj+1FvbAk/BEdOD6FA0fGcez4GC67+kps2rlL7HjRbK4rm4ERMbF71zZMTMyKXTzKYi/evR31Rh0jA13o6e1FPGWHHF+/bgija0cwv1hAT3dWKHzor4H+uoZG1mB4aAgb1/ZhsVDBU/vHcOzocWTTSYyuXYNHnjyI79y3B1u3bMLG9cN482tfjB1b1+HYkcMoVcqoxwxcefnFGN5xHWbzDczkazh4bBzx+iK+/1+fxNMP3YmbX3Atkr3rcfDYJPYfOYVsMoJiqWo/uK0INm4YRalaEyTk7Nyc2JkcOzGB2blZHDo6hnK1gZmpWTz56OPY//Q+TEyMi12Zk+NTwjcDd0efevYw/uOLd+CZRx9F4dh+TO19FCcPPI1atYy52RkhnuUEipPYtaMbhKPSQqmKfYdPYXSoT5CFG9b0o1Gri+8ZCc/hgR4xuR4d6UONfgYsC5fv2oTLd2/Brm0bMDw8JCasJDYnZ2YwMTUvyE0RRapWQb1WEVJ9klB0wM+J68Rc/jR+WupvxhImXXQMTHM96QeBZAP949AUiQSTHJhJSkhfW7ZvDkP8pv7+7/9eKHkkMUFyheQQlT40x6PCiuXQhCu4C0Xnxa95zWsEAUO1DR0yk7wiwSKiZvb3C99PJHWoomJ9aCr35JNPCr89zFMFlZFy8kTChWoqmv1J8op1JilDU7NW15H8ojkgTRCp/FFNHGmmxrJpCkiyhWQQFVfc2WP/MP8wZ+2y7/gn3xMkfGimR7KPRJIE207Cim2nuon3Q+52U/lFwo73jPdudHQ01CRObSvLk20kaPbHe8a+ue222wThKMv9whe+IO4f1Ve8NyQFSULJusv28V6QWOO95R/BuvD4j/7oj4rvA9tAko6OwblYoZJOQ0Pj+Y1YLILZAp1xA6lEHRYqyCTrWCoWUK5TDRQFTCpwoshTHZSiSYsITYVSzZ6LxaN0LmwhnbSwtDCP4sRBdJtLKNVNPDtTxPH5AroSFka6E+LZ150wMDk1i+NjY7hlVz/eeutWvPP2XXjRpeuxdd0g+rtSwkUDCRj6usokk2JeMTIyiJ7eLvT39SKTTSFXsDeTOE80I1FkM2nhA5JzjPmlvFBw7Vg3gGwyChrg0PSPDtLj8aQgsvgcP3JqAkcmZsRkjuZzdQsolKvC71WhUsNgdwoVjjtUcnE30lme1s0IJufzYmOPT3L2Rb5UxrbRAVRMA48ensBTh8YEASZdQBDSGboNOnIHsjFgNMO20uDRQiJioT9lIEFyMEqTSXtOygiBnG8xYjIJKVog9KWjSBrA5NgR3P/9O3HP3d/D+MSEs+hX1suCSFIX21RCkYSiiV7NdmYuySnLUUkJIspxZq6oX9RFvkdGyW3Z8w8qmdMuzXI+f9opedrlG3y/0us6JTOCRFM7U79gfzAlzTwLuUXxLDAbVeFLjPNekqmNehUR4WuMjptMoUJKZbJiE5zWAwx65GzrK/VxbEkiBtJpCz09dkQ8NdJ2O5KuXV+xJFpDzM1HMTNrYFb8RZHLiTCaPqJI/Rg45bpg8exgbKWU6j/K/sbb9ZicbuDAARMHD9Zx5Egd49M0+WhlEum/LxoaGqePVfmU4sBbKJWFs0ejbCBJH1ExQ0Q9KVYawndAdyqBNf1dwlaeDz36FKjUSCoBdbOCnmhaSMo52AuvdbTqNRvIxBKIcYKRSiJXLGFkaA2uu+4qfPar30G9XBQKGaqPEqkUHnj2GGZyRTe052y+iKGepGD5+dCdevwurL3xlYh0DSox9BwoimfX/l5uGggomk1byWw/8Mw6Fo/uRWHqFPbmomJXLZlKo1xr4Kknn8HSwgKuu/E6PPLYk4jULVx15cXCUfvRY2PYuWsrZmfmsLS4gEw6KZxpziyVMD69gN7uNNKRmoiot2PLeozPzAt77lKhjA0jfVi3ZhAT0xGkkzFMTM1h7OQMdm0ZFVFYvvzVb6GQL6OYL+Leh/cJnwOvf+Ut6OlO4XUvuxVLJ/aiABP9A/245aYXoByLoScB9KYaOPHkXfjifd/DwsI83vTaV2DTtouBZDca5ixmFvIwYgl0Zw3huJ6+weiUNBZN4PjJcTFZXL92ELPT0zh1ahyzU1NYt2YE+XIDU9zFY/QKAL19fbZvoxlOVE8ilU6ip3cAmUgVxsKsmGTxni0szGFxccFR3UUwMDCIWDwhQjHnCmWsG+nHwmIeg/1dQuLflUkilYyJMih/JyEp5P+NBk5MzmHX1nVCxbf/6DTGZ3Oir/bsPYTxqWnEk0mks1kx2Cb4ng5EI3RmChTLFQz3d2Nm3g7ffDoguUBChSZV/KP6iY7PSRIx4hVfGf2LSiMSHvQjRZM1EpQ0GyOBQp9O9BMkTcJIaDA9iQiqjUgYURFEczqWQaKN5wmSWjxO8keCKin+0YSN51gWCRiSPqwvTdao+qFCieaBLJ9/VASRvKJyi/Vh3VhHKpCoHKJKhwQLy6Iii0QQ1UVUaTF/to3nWAavo5qJpmc042N+bL+cSNFcjkQNTd+40GE9SZaxrtJfFtvA60jY8ftFNRFNEmWbSQixPiRr6HeJZnUka26++WZRhvR1xX5k21kO740kg1hfms7RBI/EEs3qWD7vmRopj31N00DZVraL95BtpLkg86Q5IcuheR1BAovpaErI+0pSi+q38fFxcR0VA+wzkoi8F4weR+KPBB3zYWQ5+sdi3eQ9IHhPqSRjeg0Njec3SGyM9BiYWDCxaZBOvIFcxYQR42tdEBMikm0igiMzNfRm6KONpjKG8GeZr0YRQx2ZZBypOE3l6GeqgaXpE+geqiIfGcZ4gSZhJVw0nMZ8GZgrNrCmJ4EnD57E5Mw8rti9DVfs3IBXXbUe8/mamB8mEnFBvFCJdGqhioWagWrDEn4nufs30NuLxaU8FpeKSGRToo4bGBoL9ClKxXYJs/NL2DWcwPrhHhTLddx3aF74zSKJlurOYClaweRCTswPexIJbBnpxnB/Svg2nZ7Po1itI4oqtoz0wkhysRvBYG+XEx3ZVsRzvkki59TskpivHplcwsmJSRQKJeF2wJtE2gozG/ZCl3MPlk1CT8wtqNaq03dXTPjQ7EsZKDVsQoVmesKfVSKCtBVB2aTPHAPF/BIeefRxnDw1IXxbSWGLRxA5fk+d6Mf2EUcNxQh9wmTPUUGZDUU95c11XbWKq3yxw5H5Td86V4ycS7QjAzrx97Ocn6BO8g2rRxjp1Ilz79WeD7Yv7Bqz3hDKvPETx7FuyzayVEIZRf+/8TjXTBXh45XmodFYUkTOpAsVBgIQUfUitimovy9YmIHxmRgOHYviGlDRt3qo9aY7p4H+BizW24ggGY8gkbD9Pjk2h76FnOeWJYzwo084+pmzFWNiZSIUotKKhkoqC2tGgJEh/s5sFVkt6imqWkErpDQ0fpjR9xomfvl9fy4iv3Wl6VeIyiWqnagMiuHE9KKIYNKfScOIGTg1PS+ihzAdpchdIpS5heEBEgsW7njqBOrcicotisFy12g/tq/tx8b1a5Ht6hLqqdlcGcdPjIsdpnQqLkz2SnXg0PS8GKjJfNnqjAjW9mZw2aYR1Cs15EolxHoHsPa6lyLSt9Zl+R3fjwHayTvuPWPkYML/bQls7vgBzOx/UijEmLjMqCpUbg104YpNgxjuieLSyy/BRbt34Rvf+h7WrR3B1q0bxQJ0gT6wGnXhC2FxYRFziyU8eWwGC8UKXnTtLizNL6AvbWBkeBBLpZpQAK0b7hcRaP7fvfuwsFQUvgTGTo5jYGgYr/mRa3H1jhGhDLrn7vtwcHwB+47OYPPoAG6+9hK8/PYXCL8Rf/lnf4gvfumruOTSXfjJt7wGucUFXHf7q8Wk7Nl9TwsHyosz07jihtthdG/A1o1r8M+f+jbqsQzWDA8Kc8xX3Xwxdm1Zg8nZJXz2Ww8LP2FrRgZhWA3kFpfE92JmfgEDPT04eGISi7klxOMxDA0NC+fmmUQMTzxz0PYP0aihp7sPA/39gggolarIdmVRKuYxNTluOwXtG8DWrduFxJ4+Hnq7MnjnK65C3DBFBMAM/Y+VKoIUPD6xgJGeJPYdHkNfbzdOnprG0bFxvPbF12NqdgmPHxjHzGIRxUIBOZo2xRjJJiomn+l0FkY0JqLacM8znUhguDeNt7/qehw8MYuX37TbcUq6OoTtosgJBF85YeR720lq87VqWoJmXjKtPMdjqipInlPLV3fOpC8BqWhS8+Z76Tya53m/ZN5h9VGPkRxiWnksrK7BOjAKIc3NSNbRuTuVStKnVND5ZbD8VvVodY71U+XxwX5V267eA55TlVlh/Rlsq5pO5i/zCLanVfuW61/1mHq/pLrudCZLP8zoexoaGmcGd33nG/jQh/4cC+UoyhUL6/uTYs6SL1ONHhX+jTi+0wSPSuHJRfp8igvS5MRiQ2z0dCUNYXLWm+aiMIK5HFCuAelUDPHuAcwYI+hLxbE2G8FwdwLzJRP1hoWBroQgwMpmDBdv34gNI70isAvH7mw2KeZaE7MFPHmMEYQNEcSFQV4YiY+uGaaWqjgyPovBdBSXb1+L7p4ujE0VsH/sFOZyRaGCv3pjH95wy2709WTw5LEFPHh0UThrjscMmJaB4xPTKFWq6EvHsGskg7e8+Cos5KsYmyngmeOTKBbL2LqmF5vXDyNfqdmmc7QGmC4KgouL4aViCVPzOaQTcczMzWGpYJdNSGfgwqWD62fHVuXzWi7ROWyMZA30U4FmRIVriq40g/1ERNTDqrPsrZoRZBi4JmHAiESxmCvgzu/fj5m5+SYyQDgkp0mS9KHjOp12CChFTWOP9Y7/KJ/KRomu50yIxWcaJzrFqem2b9qAL33kQ+dV9L2w64PzgLDzYe/bHVsuTRg51SrvsHG+lalbqzaE5RlWD/VctVzEfV/7NB763rew6aJd2LjzEkE2cX3BTdlquSDm4BE00Ns3gN6BIfQOjCBN871EVkSwI78ai9v3X37vikuPYeHAT2Hs6DzWXfnX2LTzze7aKcyMb7n+lfVdnHkaj3/7x2A15oW/qnpdRt5roLu7hr6eslA3RmjJIiLt0WedtGiRkfjsIAGMGBgxuhGLb0Q0vhGWWVCCVtWxuFTD5LT9W+EmuPSzluq7EVfc+r9hOIGzWs3P1Lpr1ZSGxrmMvheBQ0DFhVKGoWXphFpIQEnQcNKRsB1ZJoTxr4FTCzlsGBpAdyZpR/swLSwVKjapBRO1uim4azpx5CSIhczMLeGZIyfFrlqxWsPaXvqZqiOZSqE8X8RsoepGDhGEkSgLIuLLE8cmcM22USFBzRdymH3420htvhQ9O66GKRaWjl8pue3kTCLs5jmOzB0HlWIHig82GKgtTGPm6AGUK4wGYUeO4QOsWq9hYj6Hkf4supJJHD18TPh1+pHbb8WeJ/YKE0WmHRjoFQ89Em3ZbBfqmEKxMonurm7hGyE+0IueVAyTUzPC/9HEbB4bR4fFZI0+DZaWCsgXSzDicaxdMyQceHPiwknCK1/1Utzx3XsxPVcQ/XLnvU8I1Ronkk8+8RT6+3uwYe0QHn/iKZwcO4656Rls2bgOuzasw9WvexkqsQyeOjSPqXwB9z9xAEYig/6eHrFTSOXNfY8/i60bRjDYm8XrX3wNnjg0hXK5hlPjpzC7sGQ76owagmAE5fOJFOLJuHBeXjQs1LNZZHv6RV9wB5DOTnk/GbWHfpEmJydQr1cQTySQSqWxbt0GEYWHzhcZiYaDBNu+eU0fisUSMqm42M0lIcewyIf2z2P9hlEU8jls37QGjzy1H1/45r1ix+fpw2PCuSfT1sR3KAmr0UA8kURPT58gpnizGdmG36fZXAnHJufR050WZNvpkFKtZOXyWBgZFUyjXh/8UfOcao7WSfmSfAliubzD6qMek6SNPBaWX7BedKZO0zg+O6hKkg6sg/VWPy9Xj1bnVHVTME2rhyXTtGtHqzTL5d9J+5brX/VYJ98FDQ2N5xnEfA0Y6rIwBwtVs47BrgzqJv0m0YcmFUrAfCmCQpURkBOYzVUw3JvEluEUxufqYswuVi0Uqg2sG4iCj2ia0zEATbQwg/6Mgd70JsxXTDSsGvrSEVQjEbGxNtJDkqqOp/cfxvj0oAh205vNIB43xByQkfs49tJHFZX2RiwmFBHzc1RMx3DJmgx2jPZi94Z+dHcl0G+U0W0MYHophZMLRfH3/2fvT+AsOc/qYPzUfve1956eXTPaF++WjbFjsxgMNph8rHEgEAIkhCwQICHJj4Q/kBA+whbCTsIaPjBgwMY2Nra8SLK1S6MZzT7Te/fdt7q1/3/nqVvdd1ozo5Esg+TcV79WT99bt+qtt+rW+7znOc859z91EYVsBoVCDkNniL7tCbBGOQmCU/aQC9oQ89Ui1tbrMHQFdyzlMZPTsN0eYLaSQ6Nrw9J1bHVsMeoZuK6AUpamoTuM472V9QbcUfJCSpR2BMFj7aiEpcFwQR0xp/hvQ1WkDI8i6e0h445YezWX0pHmNCxKBRrUUMHAi+UmMrqPBz77ELYbsYj6jku0HGJUdrdTLhY7k+0uiPfqCo3EzMf1c0Zh7+59sss40SR5+4W5uP5cAalrgURXSzyOv7cXLLoas2rvZ6623fhrz3Uue9vQ7qHfaYtpQKdRR7e5jXSuIKzFIGAySxUpFepH0e2cf49JN42OPQ6Wxa9RToPhpGWOJPJHhlJXa+Oxy7XOOXlfVXVYfNYQKAoiaN5I9F8LYBixG+Tu9268ljURdk8IBaPY6ooh4v0dr/HY10JeQS4Xv8bvUgLS+rIcHZkXXGWsP5fE36RN2qS9GKAU0WOKL2rE0/kFpjhenIlh5me6mJEpzUoZov9E297VZhe1bh+HZkugcdtgGKBFMcmAD4EAOhQYaeon2Wj0HSxWQzQ7HazV2qj1huKMQtDp1sMHsLaxjbRlIOjZVz7URrYQBDLaAw8X1htYmioKYu4P+xicfQRG5CF77NUSdEiT2mc6CFJrIIIYrYm1MAUpdXF7oLvgxdU6hv0+VLuHSnUK6/0uIj8SJxuybIjER4oKNZVHKmtifaOGlfWaPNhf+6q7oBt0CNvCVLWMZqsFP9SQz8X6UVBOy4L8qZPncfzIPgSqKgyxS6ubUPUs6o2WTBrUU9hsdGGkMzg2Py8o/9C2EQR5rKys49Ch/fjiL3o9zq3U0OrZcDwPn33saSyVVDTFbQNCh69tbgrt/JMPn8Cli8vI6b6wvJaOHMe+6SUJJJ+8PMT01IzoP5Gqb+oRVjeaePSpM3jL6+4QUJLi9A88dRF+pIrguBJ4mJ6qwPEC5LM5yTgyk1fIpEQram2rJuKjFDFlaVOpWIZppRBGvpTtkXnGe2hx3wFMTc3AHg4FJCJQSTvr4/urOH3mHGqbOSyvb+IVt90kQWvIcRj00Or18NR9D6GQz+D1d96E2246gPufuoxIDZEvzwolmVkgw/cwS44uqNujCkMnhCbaXdT+6vU7KBfycj+R3fWsDOWkvWiN312W3E1KzSYtaS+kxOJaZRd7g9zrLRxupE/Pd/sXcqwb3f9zZdn/LkpkrrX9jWbGr7VAeb7HvN5C5/n24+Xe+k6Ejg1kzAi5NARU6Qy7yFg6eq6KjKagOQgEuOrYZBm4IhHQGriYK6lYmjIwGAJ2pIiLndL0sVC1oHqx1IrtAVNhC1FHRb58kAZd2OgOsb+io+dEqDN+szQoKQXNVh12OieaikyKUMy758QlaSxpK2UttG0H3QEZCxEMnc7NA9TbXZy6vI2DMwVZUDMRmlYjHJvKSXJyebuHYt/HrBfgYNHAo50+6KnT8bgvirEDThiJVEKKsYuhiWNy1/bR6Q2wWu9jEESwUqaMBeMUEUFXVLQ7fWzV62LwEpe0xYDTzkJXPAZjZkaSyOQ6Nmaqxux9vt5zgekcReE1DDzAoIaXEwpDrWCoIwAsFhQfBgqeOXMGl9a3r3ARi2/PBJAKd55pCet5FzDAs1lT8T+uWtq0+x0ZGfmQGbWz1YiNFZ8xXg7teoDOtcCR8c8+F7Nn73P3RphMN9rvG3mexlcjKcEc9X8MZbwWuCUsatNC4A7h9dro1jeFlcj1ScpKCzgjOqbCvB7ZPI2zw+PC0NE9eGVS8/J6BvX6EFVqwe7imzc8LlcD6fif50UI/fje9z3AsnyUijY0LS6946dU0XzavYcTT/UdQC25Xjs6UqPfo/We/CnbhdiqaWi3R30IFaSKCqaOP/f1+0IEcCdt0l4mmlKRsKEIDDFw4TOLKHkQKMJkIQOG1Gqn4WP/TBXVnIUpuqJ5AWqtPhanMsinNUShhfbQw9BxhXWlawZCRYETRGJJTDq2F7WQNnUMXRfPrGyJ3g8BGjrddckfF0h+z4NNVaR/BCvaAxulXEYAMIIog0snkE5bWLrlThFL910PltvBzUsVhKouIASZGr1BHyk1FECt07PxxCdOQdFMVMtF6EoR8/sPYb5g4tETpyWLSLr43NwCrFwZ2x5p6z5Sloat7Toee+xJvOIVd0oQ0Wp1UCwUsVlroUuGU9pCMZfG4aVZhN4QtXoDz2xtIW0oOHrTMTT6vjCHWJJWypqS/aP2EvvV7HYlaHKGLoqFPC5dXMHdd92K7/gHX4PPPPwUhkMXKcXG8snPiNML3WIoxE6XPF43utudubyGbqeFYwtVHDqzLKV3jZ6NfLaMtLMIrXoQC3OHUCgvYKtWh+cN0Wi34fuBCI3fPZzHyfOrqM7uQ0r1sDBLkE0R0fEPPnASpmnB0IDtek2ysbw8LJubnZ4WrSheP9/zRJg0nclKqd/U9Jw4gzBwJbMlm83gdXcckGv0sQceR3WqjIW5KQHWnnr6DNY2t7HVsgUc6w1d3HPHLVjaN4epmWmc33KkNJJNVTOwsnm5xtTv4vXgZMxJTyb4MJSyQgZluWxKSg0Ier08wrBJm7QvjEZtrR/90R8VoJ6AMV0PqfuVNGpmJXpsSaMrIwX6qSG2t1HLi2L51NmicP/P/dzPifPit3/7t+/orl2tBGI8yPzLv/xL2T+11K7W9i4kKPxP50g6RFJcn88x6pNd67PPZ1HDheaHP/xhEbwnK44mCdQeey4g7kaOc63j8nMU5X/HO94hjD/qpxWLRRHu31uyysZrR+02lqxS4P9q5gDj+/7EJz4h+m7UUUsatfI4jnQapV4dG/XyqA3H7a52LjQKeN3rXifM26QfHCeOP3XY5ubmnjVOV5S3uK4YRvAYVzNReFk2RcF2L0IlG7u5saTMdsjcDGCMSl+YZCL5JpNS0PeoWxkKE3m756GYjlDM6AiHGvy+h/pAhRO52FeyZC1HYGnoh9AHLVTLDbzhNa9HKmWKPMHTZy+iY/voDgMU0oa4y9X6fbQ8X1jzsT6lAsqKSizgs08K0iMnvGHARCfL3QLUew422xvIWKYwoGIyAw1DIqiGDksHmt2+JL1uqhhoDjyEioqpnCWJzqyhYaXWR1oF5ipZrNRdbLX6sCwDthOibgOd2kCSmjTNYXzB7xp1MCkInZQBJcBTDE4RkIpL9xLHu/h1Lubjv5mo5bkMvAgDF8ilgIyhYuAzuasKWJWzKG9AxhoX2SHOn7+AR584IcBc7JoWj08s0jky5+GzYCRevluCt3vZk5K8GEwYvTZafSf3fHLfs78xIJJUC4w/K3apMtTcebm15wswP1c53dX2e71j7H3OXG/bqz2jx8syCSY5vYaslTQrJRUnjFutfCnWfBormUuAoZ19jqQa6HBJXanAGaC7tYZMJoXQHcCcW4KZSkM3DHlGGKYBXSpeQrnndhhJY8Dnzn2kAIWMDzsTjvTYrj/fXC95dMU2UVxFw/OkOLuVisuHk7K7XfmV8Xs/0Xjb+d/Y3+OgLL8LMbgcn1c8RtPVANNVjqUhoBgZn59vQIqf59zDuTWRZBhnvHMe5evjbHveDwQZud3eef5ajftNZCQSyQf+zdc5j++tnrjadWLVDD+bbMvPsx+U3LjRpOD43J/IZlzNuOhqc3QiwXGtChO+/1wVKOP7v5r0yaS9DIXOySgi+KQPXWEYUfuIjml0iKOzCS8yJ0uCQftmKnHpHYBUShcmjaaGkqnbaPfEDYVCdvbQjX0ROBErEQLPRUrX45tWZYlc/DhhCRYfll7Qkb7sVN8lD0wKRCpAlg9XhU5qBlQli/7QE1bW4PyTSOdo9VkWF8Gu7eLUdg4HDyxAz2ax//B+6F6A5bUt+KUSMuk0MqYGxTAxV6KIuo5LmxHuvWMB51fW0OjYOHDgEAqlkjixXGj1kZlLI6N6sm2t1sQTT5zE0WOH8fjjT+OVr7gDU5UCOt0+XM/FgbkSyoUMHnrsAkqFLLIZU4TEgx0dnFAYQ5k07ZsdZNNZKX8jmNPq9mGlqdmkw7QMtNtdFAtZ3Pvq23Dp0jLOPXIf/uZv7hPxzgsr69BCH71uH/WOjf7AkQBsyExkq4czKzWYpo7+0EHWMjE7VYYfKJidmcPtr3srFm9+BUzDwsb6NvYtzokos++7cPwI6UwOpawOI2UhbaiiR8Fsix94WF9ZRb/fhaFbsmicn5lGJptBrdaQa+t6Q5SKVezbdwD5fAGe58JxXVjpjEy4ZLItzRSxNF/Fl3/xq3Hu0ipymQJ6gwGmpsro2Q40KyMg1/FUFvPTVdGj6A7amCql0WKal4y2Uf07BR093xdtMpY58uHlOa6wpMhsYx16yjDQkHLMkgSikzZpk/a30+jASOH+n/zJn8Qv//Iviysj2XR0QPzar/1acY6kuD1LPglYEPT4F//iXwgAxO342Xe/+92iU/ahD30IH/3oR0X0np/hvigw/7a3vQ1nzpyRZ9jZs2flmHSiJKjBfX7jN36jiMgT/HnjG98oASMDL4JTzzzzjIjV0znzkUceEQCDeoEEUb7oi75InjEf//jH5fM8Bl9nAPnEE08IGMbt6bBIp0wCVRSu53EoVM/+U4yfANrhw4dx3333iZslHRuToOncuXNiQPA93/M94lDJHwJfPMfPfOYzOHDggJwzgRsK4FN8n+dHNiLHbG1tDW95y1vQ6XQEzOPn2B8aC7Bv7C/3x3+zD0lZKYNRag8SAKMYP4X/uS2PxX4nBgjsG9/jOPK4/CGYtL29jS/90i8VkIhg09vf/nYBG/k6z4kxA40L2EeK+3OceQ7cH/fLMWV/X//618sY89ryWrKP7BeBSl4TjhevE8eaxgw/+7M/i2/91m+V43C+YX/4eV4PXlP2ie6ffP2rv/qrZXwIXvIafCE0xlIpXUFrAJRyEYyIpcZxHKZrcaxVzKpo9+NyMi4MGr0AU3kG9zq2uj6mWdpiKcKYJojS6xDkCqXMznE1YQ45foD1jXWcPPEYvurtX4LZSh5bzQ7Mrh2Xt0W+jH+JjCl7gHbfxVQhh6Jhoe34cNxQ4hiKkFOkm/iHSWBItJOosURWOpnwgbC/2Bh7sITf8VwMvXixxcQlgSl+drs3FPF0MuG50Kb+TK3vYODRkY7KSQxmQzQGLlYbQziUZIAS6xSRBSZMdC6Cdl31pHyIiViRf4h1o0icikGpuJQpLhUasY74vlwISGKOWlvsB+Mk21egqyG6LqSMr2DpePwUAamnEVB4arTWpoOesDzGgCcBA0Yi5gmbO2aHxKyScdApKeGL74er3CMjsfSYTXXNO0nYMy/lNg78jJ/7lQvOqzOhboRReTVm1HN97vmUel0dkOKayEd7/QIufOqvsH7qMZHQ0DN5uUcy2Txm77wX5ZvugZ4t7Gidxddx7Lx4b+oaNlcuwndseLqC0HPR3ViBF4SSODBmF0UvijUwlpWKS1ATKlHoC1DD+zC5l5L+8Xe5ZMMlSSFBUcdAqxs596uOs4DeFF5XoWg0DiCwHmtGXcEgHIG0CXMsMbVSIn4uGY5Rse3IUT1WbrmSUcf/1xsqegN+lk8HFXomwvTRG7teL7TxGUMH7R/4gR+QuZBxBWOaBCziHM5nEV2W+Rqfc4wtmKCj2zK3+cAHPiCJMxrr7JWGSPqaOFDffvvt4trM137lV35FXLyZzGGsQ7fpT37ykzIvJgBWsi/OzYwxSNxgUo/H/a3f+i0xE2IcxpYAS0nfGdvQWIjVMYx5uAY8ePDgjgbr7/7u78prnPvZ9wSU4zE5v588eVLiKm7POCIxAGJMwGMlz7mkn4wT2Tj3J+/zGTkOoiUyHvz3b//2b+ObvumbdmRDJu1lCkpRL4mi45WsCdsN4DqeZJxYv1/OZ6UW2XM90QxSIw/7p3OotXtIaxG6A1K3iazroilFZN0NiMSThhnCdsme8pHWFcwWLPiei47tyAROzYHpUhZh094hE48/GJLAgeAKH45iKdruiebVSq2FlGlAGwzx4Gcexb6lRUGZmemjG1zghyjms2IPXC0X4HoB1mtdATgWZ0rYaDuo5gxMlTPY3NpCPqVifqoAPZVHtVIV6mc5R8dAF5lCCaHbFCtfO/IlCN9/YF5K0h559DG88p47Ua2UpFwxn02j2WxRiUAAk6V9s7h4cUVYUAw2LNNAo9URGjlf01VFgj+y0hqZtGQSTp08iSOHl9BpdzE7cztc14GluHjo8aex0erh6GIVeUuH53jIpnRonRD9fg9hxLEysH9hFsVcDk+ePS/j0NUdrDY6EoQMPB/FE/cBfg/qra8XEI0TE62SmQUVDai0BcuibpaGqVJW9Jj4QCdQWSxVpTSPzypaNheKBXn6p9MZ6cPMzJwk/3I5CinyetKaWRNnQmYSZ8tptNsdhOE0KsUccGAfNusN9Ht9vPqeW3H7zUckCOXYPPDEBZiMSlUFBXHmYyZWgzN00G014Ee6uBuKewfDx9FMJqWDIUsYNOQyORzbPyP3+OlLa1icZ8npC/qaTNqkTdoLaLVabYctRedEBmgESX76p39agmcuGhmwEISItfoqwqqiUyQDGG5HwIlAEwGHpL31rW/Fk08+KewpBmUJgEJw5ed//ufxsY99TNhTdDQkaEGWFvvCYIq/GQQSFCHbiqATQRWCLwwGk1KZhG1DQOgv/uIvxDmRgA6P9Y/+0T8Sl0cGYAysyD5igEaAhvsnIMJ9/umf/ql8nqwxgmvjCysel8BLq9USYIbOjQw02W+CWGSFcTzIVGIAx8+TJcRgjQEn9/O+971PXieQxwCYQBEDM44LAzUCPQStksbPkBXFz3FfHGMGwRxL9r3ZbMo5sy8MXAkAEqRKzptjwqCaASrBJvaVx+e5su8Mai9duiRgF49BAGk8U0zW2dd93ddJwJ40niuv7y/8wi+I8yidOefn56XfzCgzmCUzioy6zc1N2R+PzzHg2PN93jNkffH8eZ0ITBGM4n31hQJKkUGUTUWIHDomR8hlFGECZclA9yIooSLuetSS6bsRSlneZ2RIaGgPXBTylpTtFTMRlqoWTm86ov/UGCiYyjE5SR3JCJGmoG17OHfpMn7j99+Ld335W/Blb3qFaDkypuj1B1hZ3xZZAsCmqhGicIjQpzOejrYbommT+aQhzT6bmpSzcTuH+4ioj2mIDtZWn8LlJiIllNiRRjoCXlE7KVJQ7zsSD5TSTEjG7HuGiQSqCAr1HV/Y424IbNcG2OoNRR8rrm4biYKPFjPjYJQwDEQ0OeZY8L0Y7Ip/drRKx8w0EgYVYxs67ZVHjA1ubmoEnFQsVtIYDoa4/5ETePTURXieHzOgSAeLR0oWybsgQMyUkLI92V0CPFwJxjwbkNplzSTlePJewv6KK6J29KcSZsnLiUXwQvr6uTBIP5d2PTbW7jF8bJ55DI//2W+iefksNrZaoj+7MFXAgGuNbBqd9YuYvfgUlr7oa2CUZoWBKCDUONhGVoxty30vMBPvH0pa9DryHV155oRsk6eweTpeoMefjYSRF+lxqcMui473RbzoZ3v6XBYryxq++OgLK92++nss2YukXJfHVQlCB3vYNCPWopTxjb5/Uobqaxg8kEL+jS4UK4w5UfIevzNjLIYRAyx24FNQraioVlghEYMdnha7co7391ossBfCRk72yaQQGcOcBzmfMnZgcoXJFs6PnLd+/dd/XeZTXjsm3hivcG3J+Y8JPMYmnO8IMBHg4Wc433I+JhDD+ZrxRsIyZxxFcIsADl9nY5KLLtqcGx988EEBa5jUYdzFpB7BIDKRpSS515M+/8N/+A/xS7/0SxKvMa4iqMX4hPM8527GAmRCM+nHBB7nYs7xTMgxIZYkvdg4FzPRxb95LP6bsRC3//3f/31JqHE/jNv+wT/4BxIrMWZhQolxGPv0/ve/X7bh+/w353UmInn+jPV4rmR6M8bjeH7DN3zD875mk/b5ay8g9aEgZapQQgpa6pjOkx0DaFHM6OGThNkuCmaW8ylx8qBDGplKnYEjE+5g6An4VKTVL/WHVLrAjAQZAw+2PRDGTClj4vhiFTctTokWQGfoyIOQbKz4ATmCzEc/psEyQAVZKxbqa/VtsfB96Pw6zm13oFCI26dOwRDPnLmIZrMjVHNn6MEwdTTqDbieB59MHctCz/YQeB7eeM9RWFokIpoq++m5OHduGV4ATE1VRTgzCAPRAChmLZSKWVyuDbCy1cB0tYBSKY/7738EW9sNPPDwCTz40KN46sRJbNcaqBQy2L8wg5uP7BcApd7po1ytoFLMo1KwkE2nBExb2dwWAIpAG0sNKZRpDx1sbDeEckvghFTzixcuoVHbxCc/cR8uriwLSXW73Rdb4nZ/KMFQ2tJgGpqwyKj5ZPd7OH/pEhAFI0eXWNOBY3Xm4mW872/ux8c/8gGcO/koNMNAfzCQCaOcT+PQQlUAutlKVgTZHz+7gcdPr8v1SZw6KtU5HDx4BPPz+8DUBcGwVMrCzMy0lO7ppiFB22DQkwclJwSywVjeuLpOIfgsOt2BMJtyWQtTpQIOH9wnOg8sGZyfnRJB9myaJY4WVlZr6HR7WNlsSx+483yxilK5JJMyy/ZcjiX1xzpt1Gub0A0NxXwOC1PUkwqFjprNWDdSGj9pkzZpL2Ija+infuqnJMghWCOZ2HJZGDRsBG8INjHAYUDDAIqN2xGQYTB0tWCYgQr3zWCF2cdEi0WYvcLKVATYIIOJx+Z7PH6yHRsBDWYaGQjyuASqkqwgG1k7ZA4RECEYQvCMLXF15LYM2hjsJQtfHp8AFINMAircjgEWg0cCKQzwCOqwMZAjG4yNQAqZXtwnj0MgjqBQ4pjJfbMfHDv2hUEYA8rEsYp94meSf7M/DIKTAJQAT0KHZ2DMPhBESkoRkwwkg1/+m8E0x4uLd27PDChBNII8PC73RUCLmVkGvMk14/nyXP78z/9c3mc2NgmS2RK6/rhRAYNSjjP7ynO88847ZTuCTTzXxMEzOQYBMwKIPHfeI+wbx5LHIeC5vLwsAXFyjTjmXwg6IQRpLCNE3orNXMhq5/xK8xjTiHVbuOiyzEiSQHREptsewaypfArtng/TVKX0jKzkhYolot1dO0DfVUU3igCQaEVm4rI5usX95h/9Fc6dv4RKIS9JvvmZKo4enMfNR5ZwdIGyDqawg5TIk0VvXtewL69jKqtJrEI2ExlOBKNoNMKF9sBjOR9QTpuix8SYSwxWVMZfEKYT4yOW/zFZuta2YbsO5nI65oumAEc9Jht7Dk5u9XBmuyfb8JzjxwXLGePEGHUwpTxvxLLiD0uINLrqjaoFGGuSNcX+iRaPFrv66slvvrbzOQrJK6gNyP6IxGXv2HwZr75pDpcvreF3/vw+fPbpC3J9GJcQKCAQJYyNKDZ8SZ4XvD93nklj5XvjpV67OlNjAfLOGjyhRfHSx8k5uu0Jy2YMFEnKFJP2LK3ov+N2rXKh59aSurJE70bKya713nPp+t1oCduzPxeDo06vgyfe/wc488jD2K41JeG62erC8YHSzAwO3XEHDt95B6amsnAufBr9kx9B/8wnMdw8B7dbQ+DZwoiSEjxWWHANw+NHcfUF2UeipRv6cKiVG3gCIlMrOOki11I7XKJRxYHcSjv3igpdsXb1wF+km4TfrUw6kh/qy5HB5fA71KDWbg7b9Tzq9SyicHdeiLs0YkKdBfyPmwg/lkLw8RT8s0bsZxXtsg4dR8XyCnB5RcPlVRWrqyFWV31c5s9yhK3tZ0u2fz7mBX6nOXfRgZrrLibGGN8wScNkDMEjAjA0A+LfBG0YyxCcYizDRBdjEpbYky3NRgCG+/zVX/1ViQvIZnrzm98sMQsTRbwHmewhKEXXa54X4x/GT9yeSR+CN5zz+R73x30zAcU5nHP6HXfcIXEBQTX2m/1lHMP5l3HOzTffvAOCMZnG7Rn7MGGWxADj48rnFudmni/nePaFIBbHgp/lb5bz89zJnEriH/ZpPPnIZCZjJ8ZKjB3ItOZ+2Gdu++lPf1rYXkzATdpLq70gCgiZMt2BI8AINZ+yFkES2tqrMHVmgGIxSr7G8JcZN9b1I7JRymYFGOnZPsp5E7culPHgWTt2bYsoBGnCohDlKKOVTRtYqOREN4jve56DNDUQ6O5HBzfPlS8DKel8iJYzacyVstLLjbaNnuPLQzVvWcLoYpkbdaKqpQIazSZavQEOHdiHXNbE3EwVTzz+FKanpzC3eFDEMAlazZgqpvImcpk0zpw5L4H8B89fglGcwv6KiVani2a7LS561byFdqsH6JZY/G7VmsJGYt8YVOdzOZw7v4ZbvuJmOYe0MKIglNyD81VcXN3C5fUt3H7sIHx3KCVwBOkUhYua+ItLraPpShXE/0PFlLK/+bkZrK9vCdg1aG/jgfsfgGvbUKNArhW56gz0cpGCnGkgZPaQNdPuUKyimUEcp0EmVHCWINIK2CZQR0CqP4BRzGF1bU3K+L7jna8VFtyJ85t4+vwmmu2eiJHGbnaBgIvpTAYZgo/MrEAVcC+MPDguA94UMqkMXHeAXq+LTDonDxGe9+r6Ou66aQEpQxEAr93ro5DPiddrJmVJENVqd0auhhEyloFaM9a8YokeJ25e+5RoaVDAkXXTkkKS7XvdriD1zP7z2laKWdx+eBbLm1yQAG993c0CCE7apE3a305jsEKdJAIGpKYTrPnBH/xBYfowS0YGC4EEfm9JCSd4w8CHwMj3f//3C6uJQQmzhcw0MnOXaC595Vd+pTBqGMj8u3/374S1xFItBlrvec97JGhippJ0cx6DQQ8ZQuwLg6CEYcPMHYMwAjBkUzE7R5YPgy8GVcwsEjBhQEeghs8X7otAD0v/CA6x/9w3wRi+zvNiwMh98jeBJII5DCQZqHK/BIzYV7KTmIFk4EeGE88hocmzn8wIMmvKcyDIxWCMrKSE+s+x4TiTJcRz4Xkxo8iMIfdF0I+lAmRiMdBl/zkX8DVeDwJByf4ToI+BIgM/gkPM0vLacL+cU5ipZDDI7Xh+nAdZkshGgIvH5liwxDA5R4JI7CPBLY4Nz4/XJ9Gn4vEZtLLPHE8Gr7xO7CtZVLwv+MP+8low2Oa4sR/cN/vBa8PzZxBNYItBL68TSxoJLvIYL/fGqZgLOZJ9KbLdtgM4AXWMVEkEyoKTySOdACOBHk1Y4papCtObAEnPZtlMLPAdui4WKym0B6HoJIXDUJKKMcOKpWQE9Zi48/DnH3kA2ZSFW48dhmpqmC4XJYaYqZbQaHexsc0suSa6kQE0ccDr9FxMZQ1sdVz48JE3dTiRwnyZlOKR3USTnWJKwcCP+874gG0Yqtga+KimdZRSmmiU0iGaYuiMKyk1QdCM589/i06NTgdlnh+TmTqa3R5ariMxrpQNir08058xQ0qYUSMdprQaYE5tIVOZw7k2ASpuH3M2YskAAjvcTwxmTWV1vP7WfZguZpFNp/HMxTX87/d9Ek+dX5UEIx0CmdgVQGAkyEzJiaQsKQabEgDqald7V/Q8AdnYFKGTJKyrREYnBiPHmTSxkPuzWUA72kF4ebRr6TddDXy6Gqj0fACm59KJulb/nuvzUrrmezh5/0fwxIOfRqfDygbgtuOH8Na7bsPigX0w0+lY08d1EUUe/N4W0LiEYY8O3Ar80IALJuh15BYPC6jrdmpiLGUSNB3dDJGmolipwHUcuHZf3K8JYtGhmreN3I8jQ6v47t9Vc0o6a+ohqqXBDSmcj7PBrscuIvwbhiaikOuVmBUpGsZ6bEZF0ErYWjtsqd0yPvkuqCHUvAolFcVlfCJZmAi1x7RA0wwxO0PGF8+NLCp+b2N3SnGG1278rv9cwCoCNd/2bd8m8w7nL7KbOHffc889Ms8zmUKw5v/8n/8jcxfHjfNfwlriNmRFca4lw4hzaDIHsnHuJzjF+Y7zKgEmxgIsiScoxX0l2k6cFzlnkkXEWIBxBV/nfglAsV9JmR5/Eyji/Mr5l/1g/xgLMfnDeIp/s+9c1zH2ogQDmUuMofY2xhCcn7kfNjKkknI+xlk8P77HPvDck+MmuqPsT6I5yXNK3ieIR5CMTHKCbPws4yQyzZiAYlKPYz5pf/dNiW7wm5RkV3mD/Mh//Cl88qEnhGWTNXXJGHHxzgwX6+ZZIpZjUBCxvt9Eq+9guztEo9NHtZCVTA0n8FzGQiadwumtLs4sbyJwHSyV0yKOzhuPOlMskaMY32MXtpHRgcVqQcrGHjizCiOVFU0kOZHRg32mmMbt++dwYauJC5vNWLg6lUI+pWEma8pkTEaV43rIF3LCmLFSaRHnft09N0up2OxMGYeOHsOl9TZuP0L9pA4ePr0h1sGb6xv4+JOX0PeA+bl52R8zXwzkDswWcfP+Kh47eUECLdfuYiYLvOquo3jm9GW0ujZe99q70Wz3kTEV3HbrzRi6dCK00Wi2Uchnsby8igsbLbzy9sPIpSw88uRJYU2tNBycr/VxcK4aM6yKeZxf2cCR+RJKJrOKnMQcNGrbeOTB+9BpNeA6NhqtrjCFDFXDdm0bCGIQj49kZvL4QCd4SCF6ERWki6JoOSjQNV3YVK+753YcPXwImco8jt71RagWUqhWK6hOT4lV9P2PX8D9J5ZFsJSi78ywU/uBQZ2uk4GURVFAKQoZd+LSwcCHlUohl8tLRrLdbgqLLp3OiYYCdZ5mKhm88013i3bVxeU1HFpawMF9s1jZiN0Es7mMaGTNVIvyUH/fhx8QdhpnpVQmiwvbjrDIxGlPU+VcWNpJ0KrVaqLdbqFcnpIFFNluFJMv5SzccngfavUuDi9N4RW3HRJgbtIm7f+mNi6q+XxbMle8WO1agplX+/tGFgFJI7DDgCVhYD3X519o1ptZRTK7CIq9kMbnaWz6kL0hV8Fr9etqwqHXawwICfJcSzT0Ro57I9eOoBCBsiQQvd5xblRMde/fN8KGYPaYgSvBzy8UofMPfPCv8NP/73+RZKE4w5Fx7sT6LGQNa3QP5sSsRkhZ1JTSsNWKMFemHmMo+MpGyxFZhpwgU/Fyzg9UBGSte3Hp2nRBFwY9QTAohiQTo0jHfLWEb/3aLxUtyRgWiZlCdAEUoV6DGpqayDg4jisseP4+eWEbF7baoue5MF0SdjPvw8ubLWFD7ZsuCquo3h2I2zKTmGQj8fC8W0tZQ95nDMPyP4qIzxctiRu6TigOd+IireuSRKMQOw16nri4IZpWoqcjpXqjEr3xsryIlQE+ek99EMOVk7jn3d+NplqGFXRwaKaCsy2W5cXMS8pQFFM65oopLJYzmK1mZXze+5HP4NNPnkenP4RL7TXHkURaNAZICaNj1MbZT7tOfOP3dUyDuuL+T16WP3Z1gMbBgJ1yJAIOz9KiCq74+/CBffjTX/vvwnJ/KcwVoknqsuTzxsCe59J8ut5r13oGPdcxr6epdL3j8P+u3cMf/NSP4GMfeB9mSnl85dvfiKM3H5fEKis2qLEGaqx1OnDsochjNLY20W6w9FqRGD1fKcG1HQx6HdQ6fTx9fl0qVsqVIqanKzHrTjNQmNsH1UghVyojlSsgX5xCsVxFNl8Qx2+VZlRmRiodxJwoVYjLBCPA7j6G9un3YGO1jsotP40Dx77hWeJl1zr/681D3cYpnLrvaxD6NBsgQ5Cs5gD5nANNH5XWqrHGlDhdclz4twBKKvwTKWTvCBAZEZSBBa1oQjNmoBlLiIL+6BnPbxuFxAMgdFFvUlOKTMcYWFZSr8ZNr/kJaBrLyZXPCzjF7zWTaUyuEXghKMSkFJlEfI0gC0EVJtn4myVtZFIxLiCQQuCIcyeZwJyvCcTw83v7xPeZ6GLiSEgdozI6vs7yOoI47AtL+glqJRqSZGFxrHg8AkpMRiVgF4El9oEAFhNATCoxscXXmXDja7zHyEgi+MPXE5F29pF94A+PTeY5Wc5kLPM82AcCSATm+IzhGDEGImCWMLXIGiNJhGAbxyApB4yJKob0hcATz4+AGMePABn3wf0ROCMIRrCLCbBJ+/y2G5krXsBqm5O0JqLeBJs0RYUmdb50bNElA1XvOBi4Jvr2UMrZKIA+lUujPxiKM14ywUdBCG84xG37Kuh2ulip2fDCmCFVKuhizUvQZr3Txma7j9vny0L1zlkapgoZdP3YRYDaVUTJSfeezWex2erhYq0jGQKi/O1BH5V0XkoAOfFbhgrNSIve1FQph16njY2tGiLfxavuvlVigbXVDUCxYJrxZ4KATgcGVus9dD1gbnpKrJM71PwIaLecwptfcQiFtIVGq4eVrRby6SyeOnsG5ayFN957Dzo9B1bawIc+/hDKpQwOHjwAy0qjkEkL84dsq5tvOgQ9tYm19Rpee/ctmKlW0R/0cPzwApr2qgiIbm7VBQjMmIYwh47uK+IjH30AphahtbUMx+4BoScsMpb1MQuXI10+lYI98KBSq4HONhqDMlL1KbwZR63UZKLmBLOWmhpAh4aHnziBSNFxc7aIte0GFuduErH0P73/Qaw3YjFRssp0uuaIJkEEx7bR63YwNT2DTLoiWQ0ypJqNLfR7PeQLxR1lTU6odBHkQ6Y/6CMMPQmC3/aaW8WeeG19E/vmpuU3wb5VljLyoVbIinLVuQvLOHbkAI7snxe2G3d738PPwB44EmRTvwoqwVOCkiE6BKSaDRFzLBYKAqAtThcwXUzj0modG9tNbDf7eOLMCm45uviigFJJ3TgnHWbkr7eQ5UObKD5/mAGgAOHV3C1upDFo4+RyrZKmG+07MyvM4JC5wfuGi+wkoOR3kBMdJx8u8q/VD042BADG+8HPkAXDCYz74bFIueVkzNf5OTJHrtV3jhXr2pnp4AOP++GkPL59Mumzj+MlQNdqyfYcsxtx8Xg+jRMkJ9RkUuekSqYH+0tglSwNTpTj/Wd2inTm57pvvlDbcy0uXpCIahQJ9f35fP6Fjj2DygSQeiH7IOPqev14If2/kc+Mux4+1/5udJur/c3v9ws9zgu9N672OoNjMsO+kL5jTLpttV1x1iNQE3gBCpYGx4/Z6AF8pJmk8whIhZKcKWRU9Bm851LYaLiYK2XE/a6aLoB4BEv3chkdyw2yoE15RtrUfpGEnyqi44qrIWdFaHR6+PO//gTe9eVvxkylJPO1lIsZmoBCO0wVBqwpEwY8KLm8SDvc1KmI3mQpn5J5nyWCtx+cgRf4ohPKZzmdmS+t1QRQKmRTwqLi941Ju1anj/MrdTR6Q2z1PRmLYlqHmtaRCrmAZalgGMdIboCLm3Q2Ex7UaKEbA24EzeLStpiNwfjG37qEMw99CsfvuANGroJZt4/1kw9i/tjXYn6+JE6AjI2nihnsn6WZTVaSoWTr//zvfwAPnDiPoe1IctRzyZJyR4BUQvXYLRlOylquLMfbfY7tLu7HgJMr1sXJ9s8GpNgSPbxEo3VHK3sP8PVSNt+7UaD92ZpN1xcqv9Y+knG8kT4839I++Qy/u84QrWZT5EDe8eWvF1dpOTblOwZ9uMM+FM8V0NQbdPHM+fPo9mxh/U9VS2JkMGi3BDzW0ym4tZZsS1kK1izwuluZOPnP7bLVaWFH0WSK1MQ4lg8Rep58V0by4XGtDKU+hD8Y316dvilrvtLIjW+cdXe9cb7WmMk9H6lodQ0ErrljYpVKu8jnyQwbXYfRGmJ8iGMRcwXhtgLvgo7wrAJsAuardaivSco3Y7kYMjVjPDfWZ8tmKd3Bqp/4KgQat9kVb/98NAI+jFvZ+OxK5l2yvMfHg4wmlrb/63/9rwUIShInietwElNerXE8yDjeq5XIWJPM5qTxWc4Y9GrzP4Ejzo/jLSl/S/rPRpZUUrJHcClpBKH2gmV7GxnL4y65BJuSRnBqb0w0/tre4yXHTNp4H9n2nsukvTTaC15tl2jpO8KZidz3HDrxxeV8Ak4FIUzTwmBIy8dYIHKpWhAARMQxSS8NFNiuD20wQFoCFAprh+KwQKAgS72nIMKFrY58Xsr6vACGqUkdNDUFKAhJkIyTOMUvcykDZzebEhCwkb0ldfdk7tBZTTPheqGANM1OgHa3Jywigh9nL64KYPYlb36tAFpbG9toLxRFbFyLAtS2a+i7PK8Mivk8HMfGbLWCVqcHMshZPjcsFXB+rYaFmbJY+9baNh46cUE0i2675SB8J8BXvu1eKZd7+uRZKYE7f3lDGD0EPwjmUBPrwoUGHnz4cdxx6zERFb+01RZLZQJSxXxGAro7jx9ANZ+SQPPo4QN44pGHsHb5PBB4MunItaFGVOgLG2m6WkLP1GHbfck8JI4x1JiizXLG0mEJkBmi2U1hrdmD7XhwOWkNbTipfbiw0cXB/UNc2h7g0mYfA5dUf9qnxpmr4aCPZjNGq0t8CJWKQvi1nT62trYx6NuoVqfEnS8MXNj9PjrtBsrVKdS3t+S6FwslzBZTou9k20MYmoHzl9dw5MAiLl9ew5tfdxearQ6eOnUBtUYH+/fN4PD+uZiO+uQZdAdD+F4g4Bcn0na7Ie8d3L8kYB7Bi5nZOWTSGTl/6lHNlvMiRE/wcTB08ImHn5ZSkRerfJyTCp0eCEr8t//23wSAIODCH04ECejE7Viqwppu1oczs0HhZjpzJLoqBIOkxNH3pWyJkwUbX+f+2G8R8Q8C+ZvbJOAG/2ZGIrGTHbdkTbILcgeEoWQ52E9uR/FDThb8m/vlREgwiI06MATc+MNJgdkMAYup30YAMp+X8+LxEwtZNp5z4oBBwCUBjNhfZlX4+r/8l/9Sjse+CKNtpLmTNPaTAoicwPlvurb9l//yX6TP/AyPwXP7gz/4A8mIsP/cD/vDvrERDE3Gja8zm8I+jP87oTcn14znNB7Y8tjMJPG4DCy4TWLlmxyP/SFAyMxWEkBQD4CvM+CgyCSv9X/+z//5imvLsaCeAMeIr3H8ePwvFDbH30X72wQevpBAji/k8Xmp9OPFbCxNs/0Q/lATHanZkikxTsoI4Ycahn6IIXywSl1TLTjiisSSP8AMPeQzmgBVfsZEnck9pJFNxa7Ac2UKn9uoFC2JHbyAMV0oyTrRUHICFvTh0fNrGP7lh/HOt74JC9OVRPEljj9i9EcWnBdPn8KnPvBefPU/+qew0nksTJUA35F6Hc53BIjKxczIPjwGlUIEqBTYJ0PK9wkwFRgfpdKYKuYwP1WETefICxuodV04XnxsXmn2lawtz/ewVm/BpRW7Hu9b7gURKudCjb9j/VL2Vwl9NOrL6NpDHLz1buhOG5cf+hvc89rXY2lxXnRAw7AgGphklWjwEXiOuCf/9WeexoNPX8RgMJS5hQ7MLNPiojgWVyZDalegfByYGgeSrliE79U5GgOgYhAj2W6sFG+vYHOyyJcd7zK0rjjGS/jrcSPs0efDYHk+ANfn7ZkShsjqPv7+l9+LcjmL4aAH3UpRxAyu40rM4fQH6FM+pNFGvd4SZuBUpShxCOMErgJsx5dk/3atLd85VgsYXNOoaiyx4TgIVBuWE8c2VpbVLCE8xxYX7FiCTFChGKgKCFpldmTK+P5GLYXtrSwWxfXu+kV844yya7NtWfIaoJAbAqEtRAGuaUyLunLshIi/7TpSjm7P2GMvQuSriNYB/WYNTitE6u06/CdD0U7bCerlF+/10RMpUtDvA90+xf/JHNRh5jXMjLiL43prVzuHz+f8wX2znDwpKf9CnKsmbdJeICgVyWRM4fKYHu1KQMDyPYJKjufLwy7FWn1SQ8lOYllWxkTaVNEf2CymksWl75O+bYgLBNkxRN5ZSkZ9KEHaIwWtvisCmwcqOQkY+GVkhq/WHcAFnSTiWnhLV7BUKaDvMPBgHRkDjnhy5UOMTCYygJhF6PcGyAYmpgsZbLU6cBUNtfYAxUwKK6tbePLkORw6chSrm3U8eVIVraG02B/7UmZYqs7K/rngbXe64gSXLaRl/59+6rxQze+9bQnzWQWnc6aU0T30+Dn4jovDhxeRL8+g37dx5vxlTE9VZDG7slGTwCtexBdwfnldREJLxULsrNe1UclZ2Kx3cGRpFp3+QM6bwQ71GdaWL+LS6Sfg9MgYkZkDxkjYnXoJ1I46tDiDsJxHr9cXYCo2RSZVVZcyO1rPUuidWgtHD+3HkdvmcWF1A51eHzff8ya89jX34K/uexIff/gsPCMrTDhmbZjhY2AlGUSf/yazjDTbvDzMHda8h57UrKczaZlxuHCvb2+Ky56VyqLdbMfiwgyK3T6swMDpk6dx8y3H0Gp1UC4XMDtVFlba40+dwcEDC5ifruDpMytYXtmUbM7rXnMX8rk0nj6/hka3Pzo2nf80lPIFDFke0OugkMsKS4oAFftOplbW0mD3faQtCw88egq1RgszokXz4qBS1Jzh5EUGEJlABBj+w3/4D8LqIcX0h3/4h3d0X+ic9UM/9ENCMSWz6Ed+5EeEpUSaLZ0u6LTBmmwCRQRUCFBQk+VnfuZnBHjhcQhiUROGQAuptQSUqKdDgIS0WAIdZG9QmJCf4fukvtIKln2g0wfvS/584zd+407tORcE3CeBKNaKs/HfBNFIKyboxm3o7PU//sf/kOvMv7/lW75FtuH9zWNSU+ZarhekLZPCTPCGDCg6fTEAI8X2e7/3e3eErZPG702S1eF3ktv+xm/8htB6CeJ8x3d8h/SLNfWkK1MHiKwt6gNxHFhnTlYW+8y6fI4zqb4cp1/7tV+T4xHM+pqv+Rr82I/9mGSb6AjHc2PjePGaMAikYDL7yPHj53jdv/u7v1uYV9wnr/VerRpSpHks9vuzn/2s9JFuJvw8g8t3vetdsh3ZUrTQ5XGpxcPXJ8HJpE3apF2rEecnJkHwhfPgWtNDOWeIk7DFshbGbEEIX6V49hARDAGl6Fwrrrhpsq08YRjVexG6nEN9vm6Kmx1ZVVttB1N5BXMlaovSJZlanJ7IJjS4saLh9EoDv/cXf42vfNOrMDdVFpCHbsOJAQDBm/f/yXvhDAeIVAJcnli6t1bPYHrxEO11EAS+ODNzDUgtLM4r3b4tJX2MPfIZS5jknLLJqCfeZZnUYlIxX82j53TQHNgSY4ow+ejZSaY9naNZvsjPJo55LN8jSyLhVhCc4t+sYux7PdHKeuNt+xBEIZbe8Dp0swv41FOX4mqAkRYVXQSnilzkR7i03sD/95GHJF4kUEaXZMoYRFcAUs8WLh//97VKxZ7FAEr+z7ImuhOOjByutp+kjb//+RBz/ny3a5XDPV9G54t57ldjZl2vP+Pbq6GHO24+CNXrod8folQuYtBuoLFFcwACJ8CwSzZVD81GnLifYuLf0iXO4ve917flO8N4mOV7RjoVPw/4+ZF+rD4CsAbdDlTdktdyxbJ8x6RPAsiysiWQMt/IHSLUh5K4T6Cgowf6yBnNK0pOr3W+1wOkdsFSPrN01OoWIp9lt7GpQD7vIZ3yYoB1BECNg1IjmhSghtCmIww/EMJ8fYThho9UVUcY+WLKxf9EpzeBpMSFMkImo0A3VOracJQAi6ysWBduvLfXKg3/fH5vJrHepP3f0F4QU4oPtIxlYrM9EA2BnOOjmI2d4cg4Yp2+BAQj8fFQ0dAZuChSxNw0RH/J9l2p+6X7CmnZR+en0BwE6NiOsJsoUpkyyFZqCdunmDalTl9XST33EaixFgLL8/iEKqTTwqQ6ubKFnsssYPJwiJBL6dDVmFFFkCafSaHW6iCfNpBPmegMfMkmshis7fjCttmodbG0bx/anZ5MBPWuiycu1eC4EYq5jAA+1HYiYENAbv9MQcCy3jBCwQjxyMOPot3pwx242LdvFqfPr+LhExeQy6fRaPVxfr2FiytbUPAo3v3Ot+PpZ87j1NlLuHh5DetbTQycAN1eH0+cOC2TkaFEODhfjm1SfR/FXFpEvr2ui9rmGs6cOgWn1xYXQTKQCPgxC8DAi5MVGUfMtCwtTGFpNgtLN+D5rgBUZAcxEGOZomZmUDl4F+aPvQYbAx36ZhP5bEocdf7ybx4W/QbVyqDVa0vJXTpL96W+jDSZSVy8V6dnJONCcJGMNmYih4NYcJaNbCi+z8U8MzW6bqJe28JcpYg7b1nCwnQRvuuIQ+K+pX34onvvwaNPnBRQ8NzFZWGmPfDZJ7G4MIvzK+vIWQY+8+hJbNdbsmB/+txlcXzkcdno+kfGCUEo3q+9Hl0XU6MyUlZp0lHQRqPdwZPPLOPsygaMVAaGiOp+7hMBJyoCNuwbaadkvVA0kIEAARKCRYnFfMJuSvRjGFCy72QmUQSQbBoCKSzt4+cp/kvBYtJlCZb8m3/zbwQMIsOKVF+KJ1Kzhc5WBDlYXsd/k4XF95P9UZCQpXmc+AiKEFz50R/9UTkmgRLSZAneXK/8jVTbf/JP/omISJMBRNCKFFna2/I4/JusILpd0fXjWmPF7QgA0UGD585zpQgygTmCOwTBxhvBKh6PY0cQiufCbXkMbk9GF/fzPd/zPTIWieU7x5jvE7Tj3wSm+MNjEUBLtG4I1JG9xGvEMeQY7y3rI8jI60a2GM+V5/mv/tW/kmPzGBxr7oP9ZN38+PnyOKzjZ79//Md/XJxBWANP0JAgGK8F25/8yZ8I3ZrUbYpD83pdS4dn0iZt0iZNSl7MmDftBky6GGgNAthuhJmiiaxF65HYdU8hgKVSCsFEmpotiiaSAJoaSnkZQadL2x5KBQL/PuwgwExeEzZWd+CJZpOhclGqojvwkTJjsMcPA3RtH2fXW/g/H/wk7rr5MKqFIlSVDKjYvY4xypnLq7jj9puwub0NK5XBUw99BnNlHdmZA4iCjsz/nb6Dru2J0+5UKSuvMdmUz2awb66MYj4NfZQoG7qelPWt13qotYfC3No/lRcQjhIRZOmTBc7kHCUdVI0sMkVY9jG7KHYhZot1UGO2xk1lHZ/yu6I1+ju/9bt442tfgdfeey9aoYKnNwawjbRsy8+zPLBtN8TA5uGnz6Pe6seC0p4rCTlq2XBhzdg2vmAx6zb+5wsDiGJHxfg3F/PXKim74vV4df4c2708FsXj43ajpb/j216rtO9ZjLTnYPvsPcbV/r7a9rxuvmdj7alPInDpSO0jl0vBGTqioRsDNqqU1jnDIewBASJV4vRsNo3t7Rb6A1eqMZQRMNUbDuEpGtQwgka3cJE8iRmKBo2jQlX2lfZcqEpepFWkZHREENoBSuWEYwyH3w3eX9yg1WXJr4nq2L10o9fhWec/+hyfDVNTHhTfha7H2lHc8cAmmO3DMgl47342xqPiPrIyBMcA442BrHLTFDs36GBbiBlfsc7/TlWe6ylotrXYpCFUdgBiPSt72ykJvFE9x0mbtEl7Ye0FaUox0GAQkc9kUOvGDnesVSbAQ4SZ5WJBpKHnxywqCtARbafugBIRtNJEjJLAOwEuxYiZVbcdnMPDZ5ZRSFlwhh4CA2jbLjIGH8AMPihWrUl5GzWHOkNfKKZT2bS4651Y3pLyP2YFJeM0mpSncinpB6nd9XYXpXxOsgV0O+FrdJ0hT4slZSxXCzMpnDxzDpfXNnDTwSVMFzNIZfPohwampsoiKr6+sYFGpwtD09B3hzh/OUS2UBRdq5liCgXNh2M76IYDrK5v4dJWE3OFDB4/cRl337Yfr7vrmAjFnzh5Do89/gRuvfVmPPTY0/JadaqMja0m5uem8IbX3IP9i/N48tQFrG110O5xkjJQKeYQekOsb25g9cJ5NGsb8NwB0umCjL2hUd+L1yWQSYeA08pmXVw6KMiezlooZHTkTAvdPn2UK1DLR1E+8CpERhqL+6YQ1Vo4cWZZgjuCV2RFzU1XJaBrNPsC8gU90n+HAlaQjUW3PccZxhlQpKG0HPQ6LdF+mJ2di53xPBelYkleYwldvVFDytRw84EqPLuHXpf2rGRRebjvk5/FG+99JUzdwKc/8zgurGzKvhuNtoBTxXScRclls/iiN7xSnH1cPYXOp09CVXTR7EpnMzLxiENfNgc1Y4lIOsHQSlZHLm3ggcefwZOnLksZqm6YyOfL0I3UixKHkaZPYIcCumQIEnQhYyZxkSAbJglE+TfBO5Z5sbabbB9uy9ptgjRkAHE/ZBCRYUOAgq5YBFgIeHFs+D5L2rifpN48sYcnK4ouVNw3ywgpYkjQgyBKUm8+HkSMZ1nl23+d4CIpKWMfCBAlAApZXUltNz/Pfu4tPUuEXPc29oWAEvdDbS32n6BskmFPjksGGX8TxCEoxPFIHEzo+kWwiePMvwnm0XmNY0BxQ7KoCHT93M/9nACH4+OQuFEmf/MYyfklfeDYcX9f+7VfK04kPA8eKymjZNliErzwe7JXU4GfI9ON14P6Uvx8Mj57s9dk1pFVRUDqRvSxJm3SJu3/4sakIMuQXR/pVKzNkuKiFAq2Oz6GaQ3lHEtudLhcsJIZFHnIGWmRKugNyYpSxaWK8isHZi00uhE8RZUyvnrXQzVroNUPUUxZ8EMPbTdAXtdlYVzOp7Dd88TljuV9zb6H+x49g6W5aczNTIuMg6VryJkqCpUpDNsNrD71WUzv24+8FaIVZvHwM6siru1HFFJnfAe0Bg4a3WF8iqqG1VoPjZ4jcYToP43K8/qOJ8dgI/jFpCfjFyZJOdcnNAuJaZMCIJImhC0VjaqERiV/UYicFmDz8c/A7tTFre/xsyv47MllTL/3r7A0W0amNIUDd7wexaWj0CwLre4AD584i/OX1kTTiixyzj9MBHJ/AkKNWBoECG4EiNpbendtcGWnZu+q+9j5bFIClVBO9my325eX5gL8ajHJtV67kbK+59pmXE/q2uVn12elXa2PO9c+DHH5sU/i7Kc/iFQ6JUz+TCGHgeMAITV5QxFBHw4cDPoDYQVS7zaby0oFRn/giFMddVSb7Q76NqtHfPkOsYqFh+EzQfSiCMIyniFAKyZFbRSmpsWkiuuoOCajqyaBnEi+IxGLZr0B9BSZ4tSQilCrZ7C6HmD/HS9ct3RvCyIVtboO3zVhGtR2G4G2UYhCnrF9LL+wO4wJIBV/j92HgdTbNAzuV1B4hxeXCe/YLcTgeYLFikZvKj5nnh+/m7Jbiw6EwTWv2YS9NGmT9uK2F7SqKXBRnzJR9gM0etQi0KSUj6KWpDYTsTeEvxyX2pkUzDY0KeMic4cAEx+IrG1WDRWOSzcFEwfmqlipNUVkM1vISOBBCQAypgg8MMgQ0fEImCoU0BvWkbNMERff6vQFpOJDQthYriflewx4+FBWSinJTGXTGQxsR6yCCdaEricPa1WxhXU1W8pKli1rmWg0Wzjtuzj4ptfgyG234fFtFYHrYn1jHY1WE5qqo+86IOt7dduD2rKRMXXkUYCao5uMI2PTG/poDz3MFIDlzQYU+OKKly9V5SH4N/c9hEajieOH57G5ncbl5TUszkzhwOIcNja3hSnFBy37JWM9dHCx3UbouVLuVt9cwfqlM0hbpMFbUoqn0LZT4g3qbunQPZbmDbGy2USv15XM4FS5gKWb7oC5cAxNZUYYY7X1NirZHjatCKfOLqPRaqGUz0rJ2/xsFbpp4NSjZzBwfHmcc5yTki5OYNRyEGowr4OVRuAP0Ol2hR119vw5ZDM5KaVsNevwXVeC2+nqFPqNdZw6dVZc//Yvzsk1Et2Jbh8f++RD6BKcTKfkHtiqt8VqmmPy9974SgSRj9uOH0GlkJXA+11vfRUi1cQTZ9bFDZKfYbaW9QgMPvfPV3Hr4Xlxe/zzjzwoQvDNvotAMzCzMCe0XpmMGXy8CKgUGTZkKCVlWNw3QZIEqGEJXmJ1zvv327/926V8i1bxBKX4OWo1kWFEgXGCKQQ6fuEXfkGYTARpCFglOkcs7SJ9m+VxvDYEpsi6ISOLguXcLtGHYnlgcu0SPSkytvj+z/7szwr49Z3f+Z3Sl73OCUn5Ghv3kdjT8rzYR7J/2D/2haAPX+dnxtk9IkgZhsIQYnBEZhW3I+DC3wTj2Bcynwjm0Z72V37lV6SkcBzo+q//9b/K59lHlgaeP39eGEgsSeR4cltulwCBBLp4XTi+BM8I4LFvZEYlxyZQxPI9AoQE0giIcSy5qCAb7bu+67tkDHlcnj+dQsg6Y4A1fjxeA+6X48n+sH9J45hxH+wTywx/4id+Qthmv/M7vyP7Y5/odsLjE9z7vd/7PQHdCEi+2CLskzZpk/aF1Th/kTXAWKtLtnouPSrli8tX+k4IL1RQykNKzcjsYYw2cFwxhimmTGFBZfIGDFNBMaciZ6no2UC7x7I+Q4TU6ZiswaHdDDyX7PdA5k8es5o1JTZj0tJ2Q1TzBp65vIWtVhcHlhbhBaZ8rjI9hYce+BTOnl/BLccOis6kUtVhDzRhcCuSaFPE7p7zuKW7cAPqkCaLSUpDxKLHPG8moTyCWLKQTQra+PkQHoWao5GQucrkwi74IqIQUr43qgQaLXJNBci2lvF77/8QZnKaaOsMBj1sd4YiyLxca0PRVpB65BTufd0rcfCu1+G+kxvYbnYlwcZ5mgyVIPTj8qAdzahdQOpGmRfjoNJVS6TijeKF+PVK9hINqp3zf2kCT8+nPZew+F6R8ufD4tm7r2u1G2EH7QUVk7K11uZFPP6BP4DK2LndRr5UgO/6UlXg2kPYvZ4k7Z2BDYPJr5QlOrusDljfbCFlGQLcdPtd9JwAfduR5HvRNAR8MdP8vimxnhnlO3QFeioNXbOQY9xCI6QRc49lguKiLjpuWqyzppkIhN0X7HxXaE4nTMJYeu15t6uBeLoaYmGO3xUXDN/JYooZUhR3T0TXkx3s2R/JE76K8AkN+mUg+qSFcEaBdivv9cTZcsQoZAWOHqCQD9EfqLDtkamB4FaJAt5ztwlratIm7XNvSnSD36REnJgLyP/+0/8dp0+dlprji1ttbLYcCWKq+QyfYqjkTZSyaQS01FQpeh5h4AUips3JOGWQaTVakJIWTX0AjaV9OjpeiMdOXcKhmRKe2WiKkPb+MkX1fJTzudghzjJwqelis9WBEkZxkOH54vrAhxHL6QjcsFH8UlciTOUtHJrOxRamji9ZK84AmbQl4oFPXNwSkXRDCTFXirMSzMDx9x03H0Nueh8eObeJcqWKVrOGYX8AzyUdFAJupVIZzJRzSCmBgDJFM0KlVJQnNbmtKh4AAQAASURBVF33LtdaKBl0vWM9tI+j++fQ7jvY7vSFsXVooYpC1sKltbpkAh0/QL5UEf0FwzJFU2r//gVcXtvGU0+fkcmLGl3GoIbNy6fR2LwkNsWFUkGE0QlGMQgS21zfj7MnnivZBgamzPLt37+Er/q2H8DfPFnDyQtrqOSzsHvtmCIceNhu95DNlXD4wCJUBLj1pgP447/+LFr92MJYZquk/l3XsbBAZoolpYMExqjPxOM1GzWcPX1S7pejR29Cq1FHqVBAs9nC4uIC7G4X6rApDDoCioqUFoaS3alkqf2kYkhGnaKKdbQw3JQIs9NlvOcb34H5mQp6A1v0ySyLWmUBdNPCymYDDz5xTq43dR3ozkPgcXGmJM6F2VwKf/KhB/GZpy6h42nwIgq2x+KrPIepQgo/86/ehRLv68+h8RokoI/oZ4yuCxvBDH63CFwkzBd+JfkaAROCEvxJJm2WqhHEYCPoScAnYR5xn+Ni3WTp8HP8N19naRs/T2CF2/N19mmcpZUcn68RYOGxE1F29m8cCEmeCbE+3O45JsfjZ8giIgCUvJ6wi8bPlf0i8ygZD77Gvifi49w3xyIB71i6RseuREA8EVDnOSUgUdJ/gkL8SfqUjDs/R72sRIQ96S/7lYwNX+N40S0vGbO4LNWQksSv+IqvkH8nfeBPonclzjZjx2Of2B/2j8fg+bFxf8m1T65vIlLKazt+3Ktdw89Xpu7vyuZ70iZt0l689md/+Zf44f/0/0PWVOFGCjzqbSoqMmmau6iif8lpnNIH+ZSOXIrzU7ygph5T2uC2lpS8WSZZsHzmEJTS4LosT9PQc4C2E+K2/XkMPQWuD4Saio2WJ0nJ/dPZUalMLE7ORKGiaVhpOdg3lcf+fftgGSaM7afxwT/7E5xcaSDNZ2Ck4FW33YS3feVXoJddhA9V5vgImvSZ7HzKKPCU+m4k7JAY2CHLIp7DRApiBPbwMzuKS8ou4ER9Kybw2ORviQFiwCrZhiV9+aCHUx/5Y5w8fUr0tJhM3Wi2xUFPDEgouSNlVDkxhvniN74Bj9sVMedhPOF7vmhIxQSmZGGcLGavBKSuF5QLqBL/a8QSGQdZWLI1Yj+NxM53dxqPzc4KOwFFxlhSV7r8XbnQPnJgAe/91Z+VJO5LYa4YN025HqNpryj11V7f267FRLveduOv7W1X2+Zq+/fdIe7/P7+I5Sc+gR7dyk0TBw4sSDK6trkpyVg6lrfbXSkqixRNRMsl3mkPIDCREsBxA0nEtnquJPIzKQPVYh55os8UOGfVQC4rbCTVTMEslGBlC9AME9l8HoVyFVNz+5DOl5DJxwx83WTskhbd2kizYGQK0DQdTv9pNE59OzbO1TF9949h6eZv3AGMrga8PVdLPtNpXsCn/vRrEQXbUlVDNY5c1sPCXBeGHrP3FYJTahRLcUj5cazlxmeUctGEOuBCUxXATKlqMA5NwTAWEEY9qArvW14HljIGo9JAIwal+N2hPIx5Dw7e81NQVVZN3BjIOGmTNmlXbzcyV7wgphSnbQIxdNK7dSGHw9MZbDaH2Oy42O5TWFpFygzFSrfds+MFFwOEQIOhxiASHyJ0vYuh6lC0C6LAx8HZKWxuNUSIjppAC6WciJjrqiVCe6HCDJkJU6ceUcKAicUoE8tem7RsIWqxbJCilC5Sjoat1kCCMwqG9x1FBC8JnnD/i5UstjsDqbdWFDJqNKHFlrMZnLu8CqzVMHPwdpSmF1CqTOPS+dMImqSPRyL4R+aVaw+Qz8cU2SAKsN3sIJfLwCdVW1HF3aWSsTD0VRG65DOOtHoKZW7QrlUpwPMZwIRIp1JS9tdoUfg8J/pST52+JAEQdaPmZkpo1poIXWpPtWH3O9CY91DIAKO9Nd0RmVGkWxsXvrFQJ/+mwGg2l8Mdd9yGfXMVvGtmCZ0/7WPoBDLG3f5AQB7dsLC0byF2EQs8fPrRZ0CClGT86NomdwMDVQXz8wvIZ/NyLiIIOrpXPBGut4Q1tbhvP+ZmFzFTraLXaaLbAQa9NvxBF8WUJoxaAlG0tS3k8tDIcnN8TBfTWJybEnZWoZBDu9eHPxxiZqqI7XoD1QonR2pCxHk/ASV4L81XsTRTHrng+OjbNhwnQDYbO0eGQYS33XsXbr7pEJ6+uIX7Hl8RvbOUZSEIGbQHVy0pe75tb5kV/x5/LQEodr5f4pBiChtm7+vjLCMCHAlAxZYARtxu/PXk3wRxEq2q8df3Mm4k86VpV9irJkyuaz1gxs8n2S8/M/658T6NH2u8T+Mt2Z7HYVlcMvFT4yk5Hj8/ztgaH4vx/o/vK2nJPq92jsn2Cag1/jr7QEBqbx+u1o/x45GRtbeNX/vx68v+38g1nLRJm7RJu1bjlEj5g0AmPM7F8WLYduiUHDutidYm3VaHvpTrTeV0ZEwCOzGIpDDZZWnCqOJ0yFhi4JANpWG+aKAzAOxWgO4wRCljwKaxCTWCdQXtgS9sqWxKhambOyU4ZM+X04YwoNutJg7NlbGxfE5kFfaXU+g4IXK6jtW1NQxqy9Dys3B9HQN7CIsl74YuIJfjBcKcZyxIXSw3iMEnKVFiedIe9pFECOoYMCAazrF2TgKcRVzUil7pyHWPTDMtQH9zGXavgYVybGpDp/pWV4OpRpJQ494LuTR6QxepXBqvOr6AjfMRLm60xQiG8aQUPzFmHYFQMSA0alesaa9edre7qI/dC8dfi0GWZEdJTLxrZy86OslhxkhRMUss1h8beZftOWoCXr08SpWuxWh6PqDBi8VYu96+nrVtFGHtzBM4+9An0Go1kS/kZP3AmHxjY0v0esNQx4CxuaqK/AXXP65PECoGgFmp2u7FGlNDx5MqkcSIiusG3rfUSk0xQSsMJwupfBGZ8hSsXEGEnDLZPAwzFcugMBEsUigxiyvWmIoT+jvnQHd1nWszR2JtuadHp3ajSbOrjZGuhZiftYGAou2JXhT7YQjRQbSe6J5tObFb3s7O4nWg34ygbsavByI5A1hHeE4EXvmd55oU6PW55jMSjz0wJJNTiAIEEuKNEOznaBONqUmbtM+9vTBREoqGaxTGDmQi43Q8XbDQGrjoexGMoY+0TeZUGsWshcu1njysZkp6bE3asTGVJ/sjRC5DTSBmvrjPmEk0Xy3g0kZNMgFZXRFWCwMMot3MlLUHDjbp1iaaUSNRStK0OenH3O3RQ0TBkAwKBgspXbJml2p9AaUKaQrzUcCTbnOKMKkubNYxNV1C1yZgpCKfoWClAsUPMHRsdNfOwiJbJFfF1MwCIm+IQb8nVFctoDhhhFKujPVaC+l8Br2+gzrZXswyWmlhLKlqhEImjU5viHzaRDmbwtCjM50rQoPUYzLNlAR0X//Vb8ZWo4fPPnkWa/We9IETVCaVwjo1bdwOlk/cj+bGRXHYYwTaH/ShGSqKhTwMnVlFjqs2yiwwuOK/DSzOzeA1r3kVHMdFuVjCW19zHB+872G0Oy0R+yI76fiRgwLQnHzmGbR6NhyZpJghjUv3+GC3LBOLC/tQKFK7KBYJZFkAG4E6qXdPpXD4pptRLlfRrK3Da28AgYeSriIdDJApWUL5516Z9aRDIsv3yJpSKeAVAW//kjdicd+c1M6TFVerNTA3O431rW202nF5IEFQgkqtTheZUUlao9MXNl4qZaCUy4oWVzZtYcgs52YdpVIeNx+cwYH5Crr9IU6fX0bf7sCmS09AMf7JJPNSavx+fy6Z2S+UPkzapE3apD1Xm854uKli41zDiFlRIaOhEL7ESRp6Ax/FPGOjEKFPEWQV7SE1+3Rx1GMspVOsPAgF8GGyRlED5DMaNloBHN/BfCWDuUhF3/ZQSFMjKhQXvkrGEMYGp9ABDWBKwJAsZi1OUJYzJjquIqVJYXMVOXWIWw9NY2j3sVXv4JZDVTx0poGVrQamFkJhRHDN1xt6SNHsJUPtTBX1foSmHcIJ9ogxy+9k8Sz/j0NDAWfIsEiwmQQAGmk1jXy9EkBKmBe+g9WzJ1DOSsYP9hAo51K4+4AusRvjupRpQrWyeGrFxonzW3hiuYuteiAyBRSGTxb0uy57o45epSV93wE7ElbUqKsx22okZM5s3h5wKznP3dfGgDkBl5LSpbh0MNkmdiIb64QcbzSmL3FM6rkAgb3A0fPRB9r7uWuJx1+vP9fS/or/JrDq4fQDf4Nuq4G0yFNQz3PEJKdBUzGHVoMAZyBulYx1WX1AoJbgLG/o/nAYg7N0ySQ4Ss1ccaEcJdDILAwC+Fx/VKrIV2fEuMjK5pHK5cECkjBSEbFET0pKR8w56b9ws6QaJlLJUBv1n+Y0LQsXtguoCqz8bIbUtc77WteJjWLul1ZTsHu52NHdjEuRFZWA0kjnTY1w6EAELTXcwY5CccxUoU0pMFJkgkVSsafNEoDm95ArjUQrSwOLalgdsePkN/reK+HoXD7PawCy/cjGZ0UB5TLIguc1ZyIySVqSCJBsszM+JBB0u1IpkdyTiR7pOFCdsP0pKcG/ydhP9GeTaggmZMc/w+PzdbL12T9WKfB1/s397NWEfSHnnFQTjLfk2EnyN6n+4Hlye54/KxySqgz2KxkfngvHjudF926+l4wfz5/JXJ4jKxr42b1kAVZHXCsBP2kvZVAqIvsF6Nm+gDkyvYdkRUFo2ls9Vx6ULeoQWAb2VdNIGXlc2mzD1ELkU0S5dckmVQtZyWpxP2QMkS7eqLexOFfFar0lgBAfzKSNB0H8peO2K21bgpv4PRMBadFktVCcbvTF4mMr0XCk+DgfpCIy3Rvi4nYPxxfyyKc1EV8nEEaNguNzxbhExrblNynr5ZQln6cDzfr6MuxuCzNHboeWqcSaQ4oiX/pqIY9iPoNao4PewBFnF4JgvmaiXCpgcaYsLnWtxhYOFuMSN8PQMF3WEfqWOGSwfG9mporzy1viQvPG190Fy0zhFXcdxy/+/kfEba++tSV0XAaQfntTgh1QcHxU383SNX6pOS5KalfwkrXkHC+CTblsGq991a3Il8owp2eRyRXxlpkqbjm6D7/2u3+Kp06v4hW33Yq777gFF1fraPcHcEiTVpid5MM8zqCWSkWUSxX5vZtRicuweCwRskckTn+5TBa9bhPd7VUo3lCyN5wo6eJo6gpmq0WhhRdKJZy5uIHNRlfKPQnC9ewhPvmpB/D1/89XI2WZyGZSKBXzsIe2ZAt7touVtU3RMmPmI82STClLCKWefm27IX/XGz0UC1kcXZrD7cf3xw+vVg+VkoJGo4VUNMDl8+clSOO4TpfyL4qm1KRN2qRN2qRN2t92y+oe7i7XcVPRxIV2Dpe7Fnw1JXpKwQjUaHaGYvbRdrlQYPmZIXFRvc+ynwjljIZyVhMRdIeTesSYJcRUMYW2HQogxPg+sKmXpIsQs2VqGHoRZssZScZRkiBtKKN/azAFEQqRNVn+HEC16zCiISppHwvTIUp3zcEpHEfxziW4uUUMXJYYxkCSgFwuy/vJygZsnwxr9i0+53EwJiFtCJAzBirI39TWGm0w8hmLy/dY0iT1gULGkAVuaPdgt7YwVdLgiaMxdVQdVEoa7nnVzahZN+EvH97GSifAwAxhHnbw4KqPnu3siEUnC/xd1GzXJe/Kxhdj5OkKYGMXOxstwEfgSEKBGmNB7S1XizdIWN+7pXkJW2vnOMmAJcDWyKGMMX4gDK+XZrtRhsq1gKMbKecb/8yNlPddb5/Pfi1Cfe0iHn/gPrknyYTyfAel4jQGXTKFFHS6A3T7NnSNjMF4zSKu2QGZj5QvUTB0KV3B6ghP9KIIHjCRK7IYlI7g4k3VoFKTLZOFkc4jV5lCKl/CcEg5EgVWJiOJ8VQ6K9deTF2Yg6NIOiNijcnuGPiIgVbAcwnixDpyCeb5fNrVxkhXA+xf6gN+X4BUVoBwHaaq3th9r0DTr/wGJYy+oKHCPxkhddyAtx4iZQP6UvI9iG9wrjnnZnhfx27ljkNTKJ4bvxQKAj1mN34+G412/u2//bfy8/Vf//X45V/+ZdEU/e7v/m7REyV4Qi3Yv/zLvxS9Ua7v+BoBrB/5kR/Bz/zMzwiARDMlmhbROIfjk0hm/OIv/qKAUKwcIDjDH36eJkfUfeW98k//6T/dkc6gGzWNkv79v//3+Mmf/EkxDHrrW9+KD33oQ7Jmos4rqxXY+FkCQmT48znHtXDyb26byGokZbaJTAYNfQgcUbeV9xc/w3uA79GdnDq6v/3bvy16snT+/sM//EN5nyZOJ06cEM1YnvMP/MAPSJ9/8zd/U86Xx7/55ptFB5bH5hjS1fp//s//uaM7y3F8xSteIefFcUhAKoJdn/zkJ+XYEwH7lxEoxa8nmTLUhjKYQaKYuS8zN1JGhFsWSthsDWEacfkbgYGsEWGxmsZWq4eUlsdCJS32vAxG+IDlZC26NNSFYias3cHdxw+JuJ486CKIsDrjhKnZOZxpXZaASixRneFOHbyuG8gX8nJzyedGAQqzBWTRMOvATMFax0W1GGAqq0JXQgQS6ESYL8V6NC011jOgSCZpojwXZsLmy3Qb7GHtzOOYXToKJQxhD+MSPjrBUTibYIt8ESMI2EMQbX66iMvrG1ivNTDo9+Uht1jJyERSLaagWdRzUIX6/ZYv/WIMvUCAHk44BEeOHpjDV37x3fjIZ04JZbfbaGCmlAayeRSn5jHsteHZHclm8mFKi1hN7cZxitRdx+gcswWpjIl7bj+KwweWAD0NVTd3EPb5mRK++z3vwpPPXASMLB4/vYK1elfKFbc2t8SVjmV9nNQoaD4zPYtyIRNr8JDixIfOSKOIzDfS+zl2vHAsIVxbvQzLHcKUAm9qHQ2F0URQKYhsRIqNmUgRcKnZ6QmgxMk4ZRjYqrVx6pnzuO3WI6LZVSjETm98qHT6XZkkmx2CZz5yTgqe64q2VjZj4daj+9GhCL+qYkCBSAqse16svQXgz//6QXzywcelJIGlkyJ8qGqxRsWL/pWbtEmbtEmbtEn7/DdO/dRnTCk2juUdlDwTPTsDo1zCU51YF8owyZ4YiRmbXPAGyGZU0YfqDAPUuyEMzUU5R5dk6uFxoauLFEMxreLLXnkIa60BPv3UMvqDABlLgxMqODBXwEbbE12q9aaNru2hnFHR91kYH4NihRSdmH3A7sjcTXZ5w8jgze/8V3jf4y1sN23kVB1pLh7cUAAo16O4QyTlhNwHQ4+keCcGbXZTSbu/CWjFC2nGrjti1wr3NWJQCRYUu2/JwLEUScr5IrjtJlJqAEslEyOAofpIWSoKxTJuetN78NEPnMBjW9vClqd0QMQkqjuMRc3ZAQGA4sVwYojH44xjKdeANq6RGEtYTVdGKFLSN0KmEn2tZPsdJlgCRl3FQS4GGuLSP77NCofxfb3U46GrsZ+uBVh9rqVWN7JwvdHFLddKj3/8g2jWtlEuZiTpXiqS6WHA0WJH45VVJqTjONvUVWQMS0AHGvUQmOoMhijkcsKaku+8oUn1CZFcXkbqtGkmjQuGUl7LGF1lKV++JEZTVpoEgxGfUKMESQRL0Ub3mXAHBUgWNo41LsUQYabqwJvvC5vquc77RthSbJ6v4MKlrLAUhaBAkD0TYmGhKQBSXDmYgKnJfR0v+tRQgfd0hPwrDTifCpH7ChX2Z4DU6+Pv8xhcvcM65PeTpXyyxBHmlArF2imEfdY5XO0av5ASPoJFXLN+8IMfFEmJv/7rv8bKyooY8fzUT/2UAEp0l15fX8ef/dmf4c///M/lutPIiODLD/3QD+HQoUPy/tmzZ4VNxPff+c53yn3zTd/0TcI04n5FK5CuoK0WPvOZz+BbvuVbBATiZ+nqzH7QIIjbEDTiT+J4TcCIoBhdqglK0XiI/aNbNUEegkVcV/EcuC2PT1dqOkY/+uij8hoNingO3O+dd94p5j9kMxEIIgB38uRJ6T/BJf7mccl+ogkQTZ4IqH3zN38zfv7nfx7vfve7d8aQbtRkQtGAiOdFcyYCawSkPvzhD18hwcF9P/bYYztmUxxDgnk//MM/LOPOMeCYT9rfTXveHDwhHVF/wPbF4pcPKcvgl5STmYZKzsTSVFp0lIbU8RlwO1oNq5gq5KT+eWD7MDVFHOAovm0QUQ0D4dhQqJqTtakBi7NVoUQLdZOsq30LeGq5hu3uIAZZCKYkwIHCAIVif+1YNDlKsk0KerQ79QNM5SwUMyn0vQBbbRu2F0oftxt0DVRgaREsLcS+ShoLJUMCJlqsEgQZDuPa7APTBREzH9ZXYHptCVL4WGNA1e5Ts8jBnTcfxle89V5hig26HSyvruPpC2vYapB2GGF1u4OV7V6M8isRClkTNx3Zh0q5gGw2jf0H9o10Y+IHJcGdd7zlHnzH170Zdxw7iBSRaFH101BfPYdepxFn+0LqUQVC6yXzKqZeukL1Df1AwKnFuWncduwgzHQGgWKg2WxjfWNL3P/4Zc1m0piZKuHy6rqcCwGcbKEI1dDR68dlmJwg9i3MYqqYEedByYwasego3fgEFRcXH0ZwsehobzCA4nuYnyojn6E+WIRcJiOC6Zx4fd+FPfTwxOlVPHLyggCU3E9MUddw9NhhMLzbrDVEp2x5dRPnL6xIqV6v28fCbAXlYkHKE1miVy0VhAJdyGawtd1APp/Ba+++BfumS8ilTLTbtJON8JFPPYr3/vUD2Gz1pO+8B0gR5sTG83zph2GTNmmTNmmTNmnPbnTZmymEqKYZd/j4yCPbqNW2cTzjomIMkDMjaJJAom5d7HJspWN9FRMdeE4Pq3Ub5zZsPL08xHrHR9+l63LMArLgoPvMo7i7auCem2ZxdF9FEk0HCgq+/I45LE5lkTMVIR1ttGx4ojlDsIduwCFsz4cZeVACliCFIqb82jfei9TMQWw0eqh1BljdaqDZ6aLWc7DacbFl+6jbITpOgIEXSvJQEmFk84hbGB33Rj+SIIuTZDvbjH4ztgpGDKDkvTB5TbaPfxjj9hubiMIhXMYksbKNMLxvveUm5CozuHh5HT4lCMhiH8kW0GkvdtiL9xuzSmJL+riEb1Sil6yRE80eAY/iY1zxk+hFSXyyy/Zg2wHZRoJasZtfzNDaYYbsWUwnydzxtqtzxXLJ+Hi7uprRF4wL39+F9s/1+tNt1vDYJz4sSdGN7TZsiucbGtLpuISrVmuLAQETp9SwTVkpDIYO2v0hBsNAYuJ8No2h66HV6QsDMc3yFVbb8VRJKeSPQgaNjmw+G5fnidZvAEVnae+IMUjhf02XiheaPSV1cXLnUhvNi52xYwA4/n4MXVG0ldLga8FNe/W9nus6GFqEmw7auPVoH8ePdHH4YBfTU33I10oGdMxlMvn+jHanaiFSS4D7lA/zJgXt9wfQUtxkVL63K5A11pcQmbSPUpGAYCi/c5lYZe3zeesTAKI7N0EUOjqTkUSgiiASyRpra2s4c+YMVldXBZD6nu/5nh3WE52y/9k/+2cC+tBJm0wi/nzZl32Z7JtJe64D/+RP/kQYVDQMIpOIaz2CRASt+EOAhmATQR3epwRp+P73fd/34VWvehXe97737ZgAJc8DPuuOHj0qQBOBH+6boNUzzzwjIBfX4WSB8XW6at90003ixk0Ai31JSuvGjY54XJ4T9VfvuOMO6QvNg8jo4r5e+9rXyjiwz2RR/e7v/i7e+973yhj++q//Ov7+3//70kcxT1NVeY/rSI4hQTQ2rmvpRH7XXXfJeX/rt36rAG/sA9fdZKBNtMFeTkwpspp1TcrAerQNJpU78FHMsgZZlzIv6k1xPqOwHMEgMoLyGUMCExGi1lV0bbpD+KgUMohCX+x2Q3GFCBB6gGMPcPORfTinKRj0+qIfNDU9jYMdG77j4PxmDQwPYgW8Xcr2rqZAMgnHD0mWE940q2CpnEbL9lDrDjFftAQIoc5Vz/Zg5k0Rvw7hIW1qyJcNtC3IQztbMGE7HjIpEwdncliu2yR7okKNK09Dz2OGMI3DB5fEAeNDn3gYzW5f2GRnV7dFYFDcYAjQ6RqafUeE9Jam5jA/NyPAy+veeC+yxZJoMpEhpQroFoj+A8v9ji6W8YP/+Kvw0BO34G8+9iDOP3EK9qAr5yiyWvwZUbEjunfZzNSF4oxHYG+2WMar7jyGtBU7aVDsdLm2KhMQqcClYgG27SCfz+Kr3nSn6EzUOy7+5jMnYcFHvdHAbLWAg/vmcOzQPhxcnJJyOAZALL+k2x2zoZ3+EE+dXZMyQwI8Q8dHp1kTt5qhZ2K2XBSgjI02rwT7Di3NYm2rBbXVRy3wJYhL0xEon8ZddxzH0r55Oa/HT16UhxmBrWq5JJmdpX1zcb4jipC2qgJyig6Gt+vIxkDZcxyZuOmGs75Rx4lzy/jDD31WSkkraV3uVeJQKV2V11xvpHg4aZM2aZM2aZP2Mmuc182Uis4gkmTcHQfyOL5/DnpmiC8t2VjuZHGylkErNOCTVW5qCPy+uPB2+1soFtMYKGW0g7wwlbYa1EeKMFcx0e376PZV5LwI1pOP4/955ztQXTqAjh2gduYk+p6PQWsDfqhjqZrG2botSSNKG+QsQ7RtuDjydBdR5IojcsZKYeHAEWE0kwHCuIZxRL3VlUVRwUjDiXRhYnGxzYKiHZ2Gq7QRcWIn+5qwNASmCWKgJ/57xA6KzQklmBINK77g+mivL8MSKz4Vw6EvC2aOVWV6DoOhK6VVgeeOFrcxyMXfwpwQLc5RqZewr3ZL5JJe7r62qx2VuPfEINWuAHnivHeFV/0uPrXj5jfuvjdecrbD5riiMnC3rDB2KkyAu2eDWS/Fdj22yo2yla4lUv75KuUZ7+PGhdPYXFmOZUZMOsC5oolDLalepy8JU1ZJUE+VUhxDm5UFKlq9WFw8k05JtUCt00e5kJW4m+sCasORLUVAK07wElTwsXJ5DQdvKcSlVdSxtTJIZ3LynSJoxYR/DPLw/EdGOFGEwO4i7NcRpXO7lZ5RhOU1CxsbBczfMX7vvvBxFD2hkOywLEJvwGGB4zK+D7F/P53Rd500ExW4uG4w/qpFagjjixyongqkI+Tu1aQEMVB86BFFRaQwcfSZ3fu834vQ7lGOJt6nmokwu8dJ8Eav6fNpr3nNa4ShxHI2lpq98pWvFIDkU5/6FBYWFgSAIUDFkrtf/dVfFUbRG97whh09KL5H8OYjH/kI7r//fgFivuRLvkQAoR/7sR+T8juCObzeLFfj7+PHjwsAxtJAMpVE3qZWk5+LFy8KWESwKQGIWNb3gQ98QFhZSWMZHtlGt956qwBnH/3oR+W+JTOJzCYyjwhccc3G5zdZVdwPj08jJ7Kh2AhkEZjjvsjqYkvApSeffFJApK/+6q8WYIrnTgCO+/uar/kaAcf+43/8j1JWyPe5H7LOyMb6uq/7OtkfWWeJVhT79s//+T8XxhZZXHTz5nmQeZbob507d076PWkvC6Hz2LmFNf18GFLjZ+CS0eKhlNWlXIvfc2oK0fGB5WvbbWbIIswU07AjBbYTCDum0xmiv92T0j5SvE0+aHRqETEyUFCvNXD04BIuXFyWcrbNrW1k1BCHqhnk0rN4enlLdJv40BTrX2HxxGBENEZDTgQhqTtQzlpyHNsPUWvbwuzqDGibGqHR81DKpSSx1O75MPUQhbQuZXHMtFmaIdk3AnKzRQMXtgbImBGfeWi5HmqeizPnLkFP59Do9ASUY4lYgyLodLDjg5kpyZDKSwHadoSt9hBvPrAogFK/3xFGUiqTZcQEX4KcELbdw/b2FtzhEFYqgzuOzsFpHURv4xQ2Z+awvnxe2GVxEBFPyBxCum/w2WsYITIpC7cc2Yf5qSJMPsQsXgvI9ctksuLowdESsfkwhOs68nAh++nr3non3vyKI0ilTKQtIu82TFOTYGuukh2h0poIhl9eq+HiWh2vPL4P6ZSJx0+v4sMPnESjUUfougLqkbHF8STNmJ8laFWrt3FoaQbFHO+HogSN5XIBr33NPaIhRUfFfDaLy2vbokNFMIqlk6yVp9D55bUtnL+8gVyaTn1leX1udgrTU0UprWT5Zy6XlmDryRPn0OwO8McffhAd24XGTI8TokAG1yiQJD2awfdLOxSbtEmbtEmbtEm7eqOZjKYFUp73imMWsoYp7lKc21xniLvnAhzMO1jpK6ipFTy5NkS3UYfTbcKxbWihh2reh6KaCNWs6GAyrNiud1EwlmFmprE8qGI+G+LMk4/A0h0Uq/OY+6I34w/+v/cj8IcwDFUScUuVDEoZGrsMsNEcSHKMEE3kdRDo1AUFSqUC8pU5bA49cb9lEo/JSmHs+AEsDFCwTASGKWWArmiNJmcbA1RXE5jeW7I22lq4Hbui3yPwKoxLfEKJpQAt8hE6PRLTJYnGigCys1jikZ+aRbfvojugdhTlKhJxaMpTjIAAcQwbOZaNaTbtuuUlHRoV6sUdkxgn0Y7a6fAY/iaL8RFlRNR+VCV2TNsTtTyLDUWZh/G/Rwv7WO+cv3f7fiW7BS+L9nwAkOuxl57P9p9TiyJsrl6WC07NtqEdCEsqn0uj3Whhe6smjCbP9ZFl7DuK7wfDoXxn6JJJhlW904WlsxyW73kiB+KSWUUzKY1kAA3d7gDbzS6mZ2fRbXeQbjRQnJ4Xo6FBf4BcqSwVGJpOtuSY7phoxobw7Q4Up4PI7gC5KbkfY/1YFbUGYjf0F2PcRAc3xIH9Q6iBLeszKYARcXKBosc00kaqTwnLb2RgEKoUmI0Zf0qaXy9VWJr8bsZfwDAGnYUVqcD1DGSzAbK5EaDLEmMjuAqI/Dmc1zXGhm7OZCSRAfUbv/Eb8mwh4ETwheswgicEg1iaVq/XBTgiaPITP/ET8t5/+k//ScrmuM3i4uLOvgnA/OAP/qBcQ5bBkYlFPSb+5n4JBr35zW8WMChhJbGMjz/cHxP6ZBYdO3YMr3vd6wRkItMqOW/qMhGQ4vsJ+MPSOR6PxyHYlgiOs2/sDz9PFhaBNpYRslyOABkbwS+yuvh5gkvcP9ej1I5K+ke2VCLMTuCODCdqRxGI4/75/unTpwXgSxzMuZ+kJO/tb3+7jC37zdI99nt2dlb2w/PluXO9PmkvE1CKNwJdT1i73nYC5IYBMmlmzVwoLIGjU14UYZvaALaPQ9NZASfWm33k0jpymRScrivZJjrMkR56Zq2NxWpeHryzlRzSlhmj96Iz5SKbzaDVHaBea8qNw5K5uw8vYLFaweX1LVysddF24lKvuAb+yglfGaGutb6L6XxKsocEOUi/ZrbLJYOJeYYA2GrZqORTIjS42XLg+EAlb0AJQqha7DTIY2RNBUdmM2h0HJkIZtIaVjs2NuohDs7GABsneZbSeYEnmTiOmTIqUeQkQD2t8+tNfPqhp7E0U4RmbqM83Ua5UsHGxqYw0NKZjHyBqRPVHwzhOevYWFuFrgQwFR+t+racoYByoyAqyYKRnSXuiCqwODOHuUoOOkLpL9lRZIURqCETrFwpot3poVoujpwN6NJHoUSKxzkoZVNiM0smkTLKMNCtrn7qnDj0Uf9pqlJEIZ/D3cf3YavWwl994gk8caGBbs/GcNBDNZcRhlTb92MheBFIdDAY2ri42cTlrSYq+azoVuxbmsMb3vBqAaboxFfIZ6HrGu591W04d3lDSiXZVwqeN9ttbNW7IpTu+p7cPwQDyTJjad+BhWkZF07QOstIq2X89l/cJ1TockqX1zjWzEYRVJXMkxW7FU3apE3apE3apL0cm+/TbUhBOR9JSYuq2kiZlCLQYKm6LLyYHFx75hzecm8K6LXw0XM15BTg9cfm0fJcdLwelopdRFYKXdeQedTtbKLl1nDkgA2jUIAdaPjwfQ9ha2sbr3jjl2E60KFa1A7VUTRoNuOgaIUwVAvFlC6CzCtNB0tlC+GgjaEVM7AqlRL0VA6RzeQlgak4ZqJcQbIYp0RBynQkORiqLDFSRV+KAJUnDItEMyoBmWLARTy5RCtmd33JJJUhjl2jEiXJqMZMISWkAY+DenMFrUYdxRlTYjEyvBgfUh7ATGXiZOBOeVwocewuqJGIiY9b2u2CHrvbJb0aOWfxHEavS9d2mE071ntjV5kL9V2gS7baAbLinomAOxlhibh6ohGV9IPlgvJ+8rFxJ8NdhtZLXf73cwWjPpftrufId9VStZH+F++Z9tZ67Kjnx8AmY1sy+9fWtsX1sj90ZD3EuJySJSwvZXUC2X6U2HCogeoFWCjmpJQvlbbE+ZLSH2RWMclK1pXoSAlb0cPszCwC10en0cL04hKslCX3rqrEpU/sH7c1zNghPXBdBE4fOkEcp7/jCkkXzwNLA8DrJGS/HUDrRoTj97ZknOjQeeFiCo6dFaYXnw9cf+hmhOmqj/nZzuj7FY+9qG0IAMyaRYJSI4KisA/jkth4zAlKhSNQikloJsgj1BuKGCWNpN/kR8+FmH42zvuig5MEbhInOZaSJY26S0kjsJKUvJH5xPKzxEGOQAobQazxRvDmtttuu+I1Cocn7fbbb39WX3jtWULHRvZR0giY8SdpBLIozJ4wp8io4k/S2L/xRiCIbZxptVe7icwpgmQJQMSf5FjXaiQ2JKBW0ghujbfkfMb3RTAvKV18z3veI8d6xzveIcDXpP3dtRe06qaO0ELFkkxXXJcc6xH0hoGg9pahYb5axGq9i/4wEBc7Cum5gYpOL9ZmqndsZFj3bGlIG3kpp9N0HUbPRSkXSS019YYG9gCLi3M4deaSgAWScaILROCLJW/DUnFsroD1dg9Dh8FCXG632XFGgpKxG4QIV/shmgNXGDrljCXsGYpyTheyGDghiiUTy7WBBBylrIFizhT7YSLrlbwlDC7ujw95ATB0DdWCKZlDZpeOpzLY6LoIfQfTuSzW2zb6jiPufWmD5Y0Bhr4vzCth+zCA8kI8duIi0sZR5HI+AjTQ7nRx9sxFKVmcNqh/1BH6Kj9Xb/ZQDEKsrS7jmaefFJe9QY/BJrOOMaNLJgRh+VCwMEIxm8axA7PiftPvtjE1XZXz4Pn0hwPJsuSzeSmHE6ablA3yId2S/XMyIEBDcIpB2XatKSVwBIb4kN+/MCO5io2NbbS6Nk5d2sZT57exWu8JpZgWz5VcFlnLENdGZjt4bNKEWWbHa8OJbas1EBZelhMqNnF4q45I0dDt9VAp5hH4Gi6tbmF5bQuVYkECx1wuJWDVHccDOPYQ5XJO9sc5lTpSZIsRFONDrtFs44OfeEzYVgRF5/MZmaCoB+bLhEWXCF8m8ihUUMoYo4lu0iZt0iZt0ibt5dVGazK4LqBZIXwnZhwwFsmkNHEgPrxkolgqwLO7eNP+AfSehRPnB+jVOvh7rz6Az24D251tQGmjkppHy1Wwtr0Gy/DFAXe22EdKzWBhbgY9T8dDjz2FeytfJqX2XDSZCFHRfOSyEeBvo6gxfjRR1RW0ul3o7gCBHvv6FvM5aIaJsOMiY+pYabK0KIJJfQdq4tDflwY0HrCgdLDgLWPedOFki1jHFFQlQKWgQTEzUPpNZMKe6Nw0PRNbdg4bYVESoYGwrgh6AbMpoBGksRmk0A8J1EFY6ZeWV7C5toaC30PRGcA0THQ6A2Fv5dNmXN6jWUgpBnIMijEcrWjjBW/S9vi97eBJV3dvi9nuyackkTliMMXbxaLT4zu/wjkvOcpOmd4IVBKzm8SDLwbR4uPs9on8/cT0ZnefY2BKAlJ9gTKl9l6P51POd1VtrhsAXngPEWRtbG9IEnnkuYSpSh7bmzWJX5nwFdMdPxTjHq4DCESRBDDo0dTIQJeyGylT1j6888heouZbMWfJNad2bUj2h6LBTKVlfUVXv5l9h0C9lNVLF7B44JCAHql0RphShhF/lrdOQC2pIZ3w3BGu48Xgq8Ybx0NE6Qv+W5hHexh+z9H2OiAmTVMDzM31oUaxaRMlsjSdlSqeAEnxvRrrGZMJRjOqnf1wXKllghB6zEqImVICdjFhT0mTCKmULy6b2QyQy1AHjuui2K2dX2Ff39Vj+7t2ZOPxyegZF/j+u2wEccYBphfrHCl4/rfVCFaROTVpL3NQihkpflErOU2sel0/Eoc7qf/3YseShVIa/f4gLtPyqbeUgqZArIY3mm2UC7SNZG2+Bg8+ihkTbdtDn9QkxOV9FPOjIHWlHAuek+pHlo8IUEYssevBUCIRWs9UyPih+OSoWtgLUKdtKrWU8mkRTufD/GK9Lw5xJIB2bAcz5RTK+RTq6z3YLkQU3W/byFg6cmk60mjSp67tImvpcj48jqHrkjGjw0Vcv20IaHZkOo1ary9ufxT47Hu0R7bg2QPRaGI5I0cvnzFFe4kACLN85y5v4tD+GWEPqbaOqekpFEtFyUoKANQeSBatN3BijYVGH7OLh3Dh/Pkdkb74oR4LamrMcqgKcikDi9MlpHilw0Doq7H1hgPf05FKFaWGnYylUrmAXDYr4uik8jbbPdTrbWxuN0X0e3a2KkHjzMwUVte3kaHgeuDj8vI6Du/fh3Y/xF/8zQms1LoISIGXSMdHs1mHSmBylIHkxMlrYOmk00bIlnJCNxYgKWNhYX4ab3zd3VhcmEW9yWyIIpmdU+cu4vSFFeQyaRyg0HqF7oYqet2uaJPlFqaRycQTKQVJqY9F8HCr1kC3a+OPPvgprG13UMmamMuZMo4dhyy2ka4Erw9pZQJmJjnaSZu0SZu0SZu0l1/jQq5EMIjyvoEGPcvqHFXEyjdbdDUOUSoMUS270Cop0Yy652gWpprBRtPHuc0eNhsDDGlEM6ARygqcdoCAGpnUDHUUlEwfacOHqjNZ18IH/+pJ3HbrYXzd8QBp04LSa0Jpb8IbOoDnoJxVYORL8KbSeOBcH0/16aCclrI5xojUwXGctsQhZOXXbZYbesjRHWy0qDSbq3jm/r/AKbuPVxwq4JU3F5E10qJ7VSgZkmAiW93rDzHsu8h5PgqqhumhjpSmIXLseBENFQuzWRSWFrDuTeGJfhW1RhcPnq3hcsulsjNyeh+BO8BwSGMXLmbJhgqEtcLFuZFWkLdGsddIID3uKRlSVwI/BJliBtLVHfASnRz2P4nnnr1gj0XNd7Whng0WjTzFdpz+RCOKNLNESl0oUYlO1e4x9upI7QqfvzR1pa4GFDwXeLD3/asBSp9LuxZj6mqvx/cBNchiVhPXEKw2yactbG91xVHPYSLbC2DqhgCK3BdBJ8dxR9eM76mwTF3iXcqmiFA6KyIIKInQfrwmEHF/Oni3O1g6VEVjaxOVmTmkcwX0u13kaDrle0hls5LoJhMroDyL7yLoN6DTlID99u14LTEq99ysZ3DuQgEH7t51s7vaWD+fcQtCFZeWM3CH1Mii3l2EfC7AvkUvvk/JjvQNfOiTKbTaCu59NXDbsQE+/IkMzl4AvuwtIQ4t9eSZQgBPiZhsBk6dU/A/fttGtajgh743h3zWj0ErAM2WjmZbQeDHWnBmVkH1eOJ0uXstb/S6T9qkTdrfAihFdhPBE7qrpc3YrYxQSC6lCbOo3RtivprFgekcmj0vBp78ALpuwpQMnS7MlUxaE3CIX2VTCbGvygehinbfQW9ArzVHPrO+sSmlWXzcEezh04Gsqt7AlkmetrsEvqKAQVAMOB2fz2Oz46E9dDFTMFFMGbjcIHPJQyllwtRUFNIpoYUSHJkvp6Wkz9IUAaBqXRv5TE7qmglQDd3Y2peOgQRomGlj+R0zjmSG8QHe6sf2rLPFNFr9HrRIxXS+Ajsy0On1ZHIniMJzIPVWADa6F7LkUVFw7uKG6C9QIytLRAzA+kYNuVwWW1stYfjwqXr3nYeRz1o4deIJdLpdpPjAFcxpFEzEqRLJNC7OlKEiFGFEUy/BUAGD2YzARuAArV6AUrmEYj4vzLTl1S20Wl00Wx20egMZX6FQShlg/OAmY2putooGab/laRmDi6t11Hse5ip5uQYr2x20Bi6G/a64PxQsHSlTl85xP1IGGAH5dAqWyWztHO684zj2Lc6IzhVplTwWx3NmqoLtRhsXljcwN13FgYUZzFSKsAwd3V4f3d4A9XYXtUYHM9UiTNPCvvmqODYSNCPO9Ifv/zg2qIORMhAFDvxIEYcSTub9oScWvOwUJxxtdL/SmfGlT1iftEmbtEmbtEm7+kLJoYC4GQNQRCgMPUKODHUmxIJABIQdlcmqPmYqKqaKLvbPGlirWTi94oPpRps5MQJCng/bDpDPaSP9Iw0ZmooM43leVyPcc6yIrcsX8fT9jwujPR8O0e3Y6JHJHvmo5AwcmLGRzWi4//E6zOlFWFISRyJGLNzs2gMBpbiwztL5d0iwxBHdR5WJsAc/huWLG6JFWi2nsfJwGx2/KXIL3A9Z4Qp1TAsWFooGLCXAVneIy5sDSVZ6oYqMHuHm2ZyUrrnKMrLZOr6IwEC2j7e/Mo+zTQtbjSE+9dg51NyYcZ1L6ZLotEwucgkQRIh8X+LGmLaxo08em+RdoXMVVxWM/pVcoERffOfVUTQ3Uly/mpZTIkwVC0zFQupxOdiuxnS8iB6p7Yz2MaYPtQNGXb2cMC7NGjueHGeX/fVyac8Sd7/ONuN/733/hRz3+TC3EkZSqABT5Tw0JZTyVUnuQoXK0FmJxMmcBkgiOk6ZDU2PNcH8WFOMyVQmW7lDlkt5vicMLCbE+X1gvFsupKCaaTTqDUwvZNDrtJHVDBQrVWEhcm1F0Ie6sewXy/6CYR9hvwnd4BogQOh0Ebo2NNMS9lUuHWF6iuZFcWXKtfSXrjYW4+M//m9WpOxfcqAEA3lmWSbPcaQBNXaQjz0Q4emzPjykMD+bxacfVvGJz/o4ejiDlEVGjwLL4hqNmrEZPHlaw6V1HYNhrCWVlKhy/MtlH+USq0UI4gbw1Nj86LlYbzvulxNwatIm7W/ffY8MH87Bhh4L7KVMRVzfyJgiUOD7trxeymWgqy70vivIPVF8YcYYVCWK0Ld9Qe8LGVO0nLyBg/myhXRRg+N7GNihuC1wMkwZVjyNRqRyx3alZBCJQ11Em0dfMmMEpjRDlyBMgSsPVQJM1Aja6NICmUwr6gLoGPoh+k4g4FAxrYOPd0u3YPYUFLOpmAGma1AUurhBwKogNMUVjgEALX/JRuKgmGqE6YKFrXYo2k95U8MwiNBubsCLdKTpehDEE4Z8BoqIhtNRgyCI6/iwLF2o5cyCUNTw1OmLEsTwXAvFHI4YGvp9B4OejdWVlZE+lclIEUOPoJ8WZxu1WJSwUkgjb+kCqvHc3IENvZQFPBuK7yCtp+EbzDIMsLHZxsrqtlwnirxVywVhRbG/+VzMcivksjLZ9QnaNdqYnSpju9ZAuZTH4aUp7A9VnLy4LVbOza4tYqAMLAW40+lsGD/gZbwzKRFRZxnjwuIMpmcqOH7soJTe1VttWFYKa1sbOH54SYTKWbaXSVuYKmUFZLqwuin3w9o6X0/BZJmArqHeaOPi6hZeefsRHNo/j/WtOv7XH/81VrZaEoRzgjUJLIreRgBDU1DJGvDEOXLMCnoU4L08COuTNmmTNmmTNmlXNtFS9FWRXAh8FWlLgcEyFy1eoPZdBbU20AshcZPiKihkQ5iag1JOxU1LOl7TKeLTzwxxcs3GZteHMwwwP0ttqQiBr0MJNdRaHYkbpktpfMnXfB3+6Hc/gPWLNYSuI+VHTAY6gmmoCKIBsmeaMQil67h1PnZrZnKQsYui6YA/lEW5EUbIGCG0lC5ufj1bQcnroLOxjo7j46b5Ci62PbjwZe7OmJow4ns2Yz9Fyv+C/SUs5hXUOw7OdgOsd1yJA6eyJp6pu1jruTjScrB/zoUTMlYLUC150JodPPpkC+e3hxIDtXsD6EpKSveyqRSymQxUzcDQHkjSUoSWx13A5AIkwNBI1yoBe66o2BspmifXbI+joCx297ChEha3yDTIdsn28WdjbZ8rwZhnM4J2QaYryvZGfYz1eHbfe6kqnV+PlXMFyHYNh77rld7dCLj0XCDEtQGxRGR/BCYRIPZ8SZiTicfEvR/4Akwx4RwoIXQmw4VNSNkLFZoZM/opwM9FCqVJuH4QMW8yqAxdEuD20BWDo3QmJf2xAx2mquPShQvYf/AIUnlXACkrTUAqds0m1UBTdTi9DqJhB0rgioYb3dUx7MIftmHkSlBUHXNzFGLvj6zvds/7amNxrTHa++8g0rC2kUbocR0plgjgcmdxsS3rImK2LOfbv6Di5LkI7/ugj49+UkF/4CHwIvz3X7NhGoowGkUmRI9gGB5cnkeoIZuihuxIX0pS90CjqaPV1mNh90CHljZQPR4/nyZt0ibtJeq+RwDp8mYb81M5KQ/jw0vlRBxBwBE+ayk2yX8X8mkwxuj0IglCCErYjo9ChuVuMUWSD0BqNjl0NmG8RAqrDgzcQFD+YjaS8rtYuTIW4DNTVkx5ZV31MESt68DSImRTZFvFD+2h62E6Zwm9dK1lw/Yj5DM6NEWTB3Cr78oEwGBlrpRGEHEiCGH7BMviYMIbOfrFPjEKWr0homwKaYJepMYKDZoucvG5TBVMKVGkvpWhEvAwsdHqI3BClDMZ9Dw+NF3kihmh2TIw5P5NU41FPJ1YnJxMHeo7MWuxst4WsC9kHTfd+AYhhkNXNJmYiZR8VzTqi1DEqQGlyaTFAE3YTpYpDC1mTgLfhRrRGtVHt9vG2ct15PMF+Uw1kxLWVyGXgkonD1UVFxCWtfmBKyCY5EpEEZATxBw2tmrCOHvfx57AM2sdBEmGTyi4sdAoAUlVTcUuIiPquDjccSLo2Lj19rl4cuV405FvOBSAqlIuCgOKANKr7zyG+emKaF2VCtmYtmwZSKcMZERwNMCJ0xdweN+sAF5PnTyP3/7Tj2Kt1pW+OK6HvKUBEUFLFRy5gFkouWVjBhy/EMxKMfuTphD/33Ed+aRN2qRN2qRN2gtpLKkzUoBPx2FqMdnUVuHaUUUupaCY0lDKKLC9EEMXaHU0DP0ClvbPIF8oy3otY1PTcQtv7Pbx5CUPj13oweGiNcs4KwvXjdAbssxLxa133oVIz6G3vS4lb+vNgSy0GRFwoTfwPdRsD1MZHUVLE10rXWbhSBj0uUIJmpmWhTCFHei6xbIleEPkDQO6qcDqtiWGOTKVlX13WW5k6MJiokxBPwiRprBzyEV+gM9eqOMhAK0hNT1DWfx3qHXqh+imDWhdYHsQoe0aUKIhLmy1sdUZij6oQ/diygyEPgJXF6aYmtZFFzWVTUM30xhsk6EVu3TR7VC0bSi+zIhGXPTGGFSjtlMSt8NWGlmG7YBQI1e8cfZFopFKgEqJZRqSxmMkmlNStyCOhVcKbF+zTG38fRGJHv09KjF8qbdrgU17/713++cCSG6UMXUjMeK12FjJS6oemw6kqeFK0x2HpaPx9Rjy3wLaKrKGYkzuOJ5US3ANwNuLoCh1p/heOEp8M2kuES0ZVHw9DJHP5aT6oN/uIlMooZDPo9/rYmpxURy3M1oJIfWjAlaejMBU30Xk2uBKj/pRMcZKjanOjuh+4IaIHMbWV+CpNzw+V2ssillacmFE/VikPKTDOMF1kgJCeW7oWoR3flmEk2cVXN4Msd2KDy7Am0MZD8qYaDIGXKOl0hosU4VlhLj3Naze4BjRSZ7noaJS8lCt8LsU/82RF1B5l4L4gq7/pE3apH0e3fcIpvSGPtbrA6GCVnKxGDbBD7JgcukUWj1HnPTIbCKThTpCfJDywTlwiE4rqOZ1AVAoaMeSwFSkCoDEYCEIqQdFthHLq1yk7B4O7V/A2sa2PJjIxCL6r1jMKvhSqtYdDDH0KKAdU7jnShkBIvigX6/3hXZNZk6zP4RJi1SVgUucFSIjiJPC0I/1orKWBkunk0ucISIJiZp3ththqz1APm2gkkuNLEoj0bAStzpoAo6lcha6tifC3gulDGq9IdqDPippE3rQh2nkhQFFlhlzHYZuSOliq2NL3TgnolyOzgQKHN9Fu0P9KZb2kdaqihh6p1EXnYCYyRrTuCUUUUnVp+ghA82Yvtu3bfgBNaBYU05thyE0uHAHsWvedqMnzCaDWk+WjnTaQr3dwf6FWQHCKAAOhbpeAwHM6G63XW+h1uxIjoFAG0E0S4ud+5h1ZRlnz6WuGEUQY4HGXMqCQ70nL5B+5zIGDh1Ykv3Rslb0trJpERSlUPnK6qYw4151x1EU8xnRKWPZJkvztmpNYd51O21hyl1eWRfAc9AbwB7O4A8/9ABqBATprsgMkzDUyBmjLhoE0LSdQLTCSH0m807YeBQ5pK5ZJjMp3pu0SZu0SZu0l2UbuAU4+j3IF5m1qgmbwXV7AmLEMpMRjBCoZi0EaRWVfXcjzBxHZKYRpTXkLAVlzcXSzSwFGuLm2iW8vXYJa+srOLni4Fyd7ryB6HFW8mkcvPlWrK1uwvBd9PoD0Z4SjXJxdgvh+SEsTUXJitkLBJMY0BH0KZUKKE5NS2mRY/cEVGI5E5OOZJVTHiAHFRUrxP4KnQBddN2YIUVdAsoAMDbhNE/giQnTRs9Bx6HZTlLOFi/co0gV5lV36MbrTUXFYxcbWK53RAfUFXkK6tio4vacMRSkDEpXMAGmjQC0IrR0Hv3uMjoD7keBoSh452sP4hMnN1GjDqgw+1XMVAq4tN5CNFbKd0VLVvGJQ9iY190OIDW22bOd3EYg1s7uouuXFyWMrTG3ZpYj7jryxTqlCTi26+z30gapxkv1rgVIXYs1dTWtqRcDcLgeSys2r9Mwv3RQYtpWzxYZEH5PCKJwHcBYvm8PRS4kqbIQppROoyBdBM25BmEilmsAe1TeRvYU11fUYN1FiuLjVipFNNp9KJqJqbk5edtxBgKIpXJ50XXjMQj++s4ATruBXEqFqcQsosAdAjb1Xrlmi+Cv6tDOWlBvu7HaghsrdVNRr6XhDHKyvhTmmBu7aGZzIQ4f7EDRQhzd38eP/2AWn3mcZXnApz4bod4K8dbXpzE3Tb0ukiTIrFJgpUJUy8CxIybuuZ2vEWSL0KgrqDf5XCDvIZK1DNeDWlpF6QiJEJ/bPTBpkzZpn0dNKYqUkxZKLR62tElwhQGBIpmpbMZEvzmQ91OprAQXpDo7bluCIDpCcOHfc5hVUuAPPOQymoAudJXgc3ezPUQ6ZQrDp9G1oWgq5mdTmJuZQr3RxHa9ga5N8CG28iWV24uAgRdh0ByIePlg6Eg9NpNRBJv4MOtxOwZiKoMMDc3eAPPlnAQr3JCZNJd6VykNqkzSZE8ROFPkoZ+mmODAQ7sfZwymi2l4gS/sn9CnkDkzezr8KBAHPwZdZFdNZUzRfqp1bGFntZo1lJb2ic6SRjCL48AMX5rgjSfChhQ17/VsZEjLEvq2gnIxh8FgAHswwMAdynH5Wep2CcWaj1ImFfxAQCYCWAQL2VdmVTyX7oAeAndkDW1aqDdtAW4W56fR73PcLaHOk1lFLS9OjoOBg/OX1rBVa8N2fWQsC5USsy6uZGxmpko4NJNFc3MLC7NFFAtpLG9GODkI0GcWaFRimTV1lLNpYbzlC1m89pV34vCBBRTyGWFT9fp99Po26s0ultfryKZTMoFysqyW8tKPTCaFer2F+x96UsocOYFsbLeETcZxoN7ZBz9zUjStWEdP0GwqZ0lgzLLQOPNBN0aMAKk4GCQQ2Rt4MWNK0wWIezlkCidt0iZt0iZt0va2SmUOhw7fi5nZKtIpHXa/gxMnPonIfQzD0BX3X1NXYAUuVpolfOTTG+gPlqFEPgopHYdn8ziyWMLCbBnTi3PIz9yG4sJd2H/nAAfPPIZPP7KCkxe7wowv5rMoFIt48rMPo99zZP4UrSUBQGKTF0YxeZN6jorEdNkUGeBkh/uYmalgev/hWGDZZ+wWiISC46jwQqCYMWAzwabnhNXd6wcYeExoGsKYYKxDTVMa0aRNFW4QYUBBdrpzSQjEssSRIx3I9CbzXpGk3ZnttpQ9DX1PNEIZK1DTRmQqNJY8KvLZjKXGv9MWsqUqIiOPza3t2B2NGpmWgrtxGZm7j+Dxy20EnoO75yzYqonLm60dXCBeuo8zmPYCIIlL34i9xLYDVo39Of4JjrMAblcCUuON58h4kbEik6HsB1kiiUj7LqsqdhC8cl9MJr982/UAphcDfLqak9/e389iX5Gjr2jYd9MtsDJZOJ2+xN6iE7ZzTQJZMzCO53eDbD1dicv3xIWPGrtqfO01orgEk8QIL0RKjRO/fC9lWQKKcv3jE+wd2Nh/cEac9ZxhH1PlslReJOAm2Yv2gGV6PQw7NWT1goDVvHfETKi5SkepeG3CXzx2NCosvQ4bbRyQup7WF8l+szNDwOuK26ZwA4XEEMLQQ9HdEvW1SEOx4OJL3iQFDlLBc2lFx7e8Gziyn6ZL/KwGVWO1CKtITGFeEXwijYD/n676mKlSvkOgqFH5IrXmJnjUpE3aSx6UIsAwV85heauNZm+IQtaSzFs2pYnIdXcYYnG6GDuYaWQc6eKGJpwgxRdASlwjoMHxiPhraPY9FDN8EKnoDmxMFdM4v9nGwfmKlPo5boBLKxvYtzArrJp2dyDgBoGXRt9BbRADZNN+TGWF6omY9cAPRQSb5KyM0F9jhW0en656g6Ev4t8MaJxQxWbfxlzBEje4jMG+MfsQu61wQqecFGm03aGPvqPCsukQo8vEwSAojFT4oSfMLeoXcVKYLRjYalMk05QfAnf9XhPLKwGOHzkozoJ02OjbozHihTEMyTIWchl5aPPBOhi6yDqOONGkM1l5yPKxLBnPMRHKbNpCKmWKrsJgqMNJ6+jbBvoDG4UsAS6yb11YKZc1beh3fLi+jsFgiEKOdrEW2p0eCsWCgE7s0MZWCxv1mDnV6XSFedTt9jFdLSCfy6Jeb+LU+VVst7to9HqYLuUEZJrPp6EGgYB/vgBBITJRhMXZCl5x121YXJxBNptCq9XB8uoGWp0+HM+F58YZz0eePIMjBxckKOSkzPLDrXoDJ89cFFFzjtapc5eRTZtSUuhFEZ44v4am44G5jqymYqGYkbI96oe1h3HWj0BqEpxpij4CHMn0UuGQBj1icU2YuZM2aZM2aZP2cmyMlQ7sI9vZl0VsoVTF9NwdMLUSLp/7iCy86EbXGKj46FMRGp2WLHJdL8JWw8fFzRYeOrOJxUoGx5ZWcNstB7Bv/zTS2TSKB16NjftqiKKOxEiFjAbNzGLl/Hm0+7YwFLjk2yFpUFZAVURvk33J5yzk07pokzKpWS7lkCHQE/rY7g2F2aCFAXSDsgksj6MIu4HuhXWsNvtwQ0otxAz1DEv7aBmvkAUdINSYcByOGEbBDoNcVxT4ImrMxXnMcufil/HMIGBcGu+D+laJqQ01LPnb1KhZpQi4VyrlUZw/hHazifPrbZGCII4z9FRsdgJ8yzffhu89cBS+6+GZxx7Hf/jtT8asGI44jWb2OtztYevIQn00bjsKVTslROPi5VfXTtpd6I/AreR1Jl/JGtlTnpcwpGLNq5Gw+Z7Sv5daeu5GNKKuVYp3PRbU8wWoXqgQetJPxqFzB49h/uAxrG5sSVUJf3iFCK5yDcKEN5lCdNyLGJ+ahujRErui5EhSuskkLdddZBbx+5FnInY4RCqdgmHq6PdYMREyQy3AEdcdxXQKCoGpXhvF6owASwRuCFYNe00Egx6V4MRpUjdLAhjL8XrbYnBAwEudDhD0A/C/a43L9fS4rgZOhaGK1bUUhv0MHIeSJoqYNRw93IGmxSV2UaTj1/8wjafPhHjbm3R85d/r4e7bQpw8HeDRpyIc2j8CsghCiWsh1z/x2BJ8YhlgrBgVg7m1OjWlqCMsvYKRDVE++uz+vtDrfq1GPb5z587J/o8ePSoMuKs1vs9tuU6mzMn468vLy+h0Ojhy5IiYU+1ocwUBzp49i/n5eeRyOfns822u66Lf78u+qtXqswDYS5cuyVpqZmZG+lcqlV7QOOw911qtJtU7PB8x3BqdT6vVQqVSkb/r9br8e+95NRoN5PN5+fzzaTxPtmw2+zn1n+PBPuwdr0n7PIBSnKBJlc5nDWy3fWFE0W7YHvqYpXtLXsPQDeExQ8VMDLNIZBJxKiQLRddhs35K3CCoLaQJ4FHIFCVDRQYVWd1L0yVc2OrizgNVyX45voL19U0szs/C8anrpCNH7QAFWG0NZNIcuF5MXQ0jAcucnodhLHMlQtez+RTMkTNd0/YQKsYoqxBhoxPXblPcvN51oOZNCZhYjua64SjbRwq3LrpRjd5QyvsMLS00b07kzBjy+ASQMixHCwP43hD7ChY6Q4oWBsinNTR6Pur1Bk54Hm6+6QigmvAcB8NAixliBu1OHdB3eeh4AFF+XUO370JDPDmJ9bBYvvKhG8cqlsUvIGm/1HCiRXPM9iGbiBkW3/XlsyzhsxDACD15JLse0O3byGVZltfB6mYN5ZKNciEn59jp2JirlFDMWjj7zBkYpinspNCflgCOQOCJixsyQfV7LjbbPSnlJJhEl0N7OIy1IaIQxUIehpkSsfter492p4NHHjuFze2GjH86nRJA6uihfcjefhjdAUsGQzz2xEl0+wMRYM+lLTTrbfQESMtKsLvabeGZlW10nfihTZBpKqMhT/0oP84IF9MGBo4vbC8y5ahDQZaYTFIeHSQtRLYj15FjmwiKTtqkTdqkTdqkvZwadWVcZyCgQ7/XEw3G/QtTMFML6DZX0G2clrjpxEoKjTbdi+kMTBZRJHFG5NPYJpAyorVGH6ubLRzfXxZm+rkNW7QftdAThvhMOS9yCRcurghYxLiEsR9lEwjsOHTwpfwA5QVEHiFmI/HvYj6FcqmEVCaPyO1jQDdlyiZI4shFIWWh3vGEtZ7ZWhFGE5OOjAsJXrH0SaGOE/utacKSJjgVs7Qi6AJCMNKJ53XGNASkePJknfgjVW+KgzN2oGB6HNMBNA1mwjWXNpCyCKalYlBqZgkXLyzj0lYPXhS7klEHtZ+poPXUx9G/8FlUD96CpVtvQ8p8cMTq2AV6xhOJV2WNXMGQSvgrV3n/Kp+/Ui8qEWCPSwNjHdSkomsXvEqAKOGkyL93972jN/USa9crA9sLSO0FQK5WVpdsdy09qmsdI2nPh1k/foxceQqvettX4vKZp9HtdUROhFqpec8auUBTAkOH61JHiYBqAHvIGJ8laCyhg8hP8KJSooP7tkwTpmVKYjmVzUDVDdkuk0phdbOJIzcdxaA/QLfTxeL+fSKMTkqSrhuSFHdtF4auwR600a5vCyORXylVoZkVqy16COwuFCuCWggRFjy5064jv/S8xolMpik6+hWGotXGZwjlobg2jIs/+GwALi5HeORkIBUns9N5YUnd/4iNoWdiaioPYyQpoqo6FI2VH2RKUSZExS1H+TyKXUk5ZjPTIaarsV4umV+OwrH//ABR42PxS7/0S3jkkUfkefrlX/7l+JZv+RYBZOigSCCJYBMrZMrlMn78x38c3/iN34jFxUUBTvi8O3PmDP7oj/4Ix44dwyc+8Qn843/8jwWs4WcvXLiA3/u93xPA6Ou//usFnGIjeMQfNu6D/+ZvAikElSzLkn/ztWaziY997GOyz+/6ru+S49q2LUBRu93Gz/zMz+BLv/RLZfsnnngCX/VVXyVgDMEsvs9/O1zfDodyDhxHvs7X+Hfs9mjK3wSdut0upqamcOrUKWxsbOC2226TfnueJ/36X//rf+Gbv/mbBYz6rd/6LXzv936vfIb7IBDF/Z8/f14AOj7P2Y8EHEr6zWMl55ZOp+U1Oshub28LkMXx4pgnfef7Mt+NxoivJ4AXtyOYxT7zN7djP9i37/u+75NxKxaL0hceg9eV518oFOTYE9DqcwGlIsQofhQinzLQ7BJsYP2xhrbtIGg4WJpOI2uFMvET8ClNVTEc0lK3L1RpYiy5TBadfoy4S4aLF7rrIGNpKOfTohVEUCnTJ8AxxHwxLcysYj6PWr2O6ZlZDHpZuI6N+WJGgKZGf4iipUv/GPAwkKBYdndIwUxmp1iKR60q9isUTQGyuAZuCEv10en1UE1bsCIX8BQoAWmvZOcE0Pg0JMOLYnlRiKylwHOBlKGKdpQaqdAiD6bo8VH0E3BtBxnFjZ3nyKjiQ58UcTfCjAkMDQvNfgenTjyO+WoVppVBtTIHXTfRrm/G7DLVlxs8kyvIpJRKpVHfrKPZqKPXG8TuK6N4QxvpffGPrGWg6wwB1ZKAhFReqZJmZpDXkc6B1HoKfZSzWfTp8BEFWN6oyRdb1VRUijnRA2s0OyjlLAHjnnqKD4lt6IYudOBGo4VmszOiygfoOEMRSeR1oHYDGWj8vh2aqwjQM1Upw8pmkElnBJDipLixXcPaJjOuYhkjoNnCTBWPPnEKmXQuznDqLK0bSgngWr8mgJtpGkJ1Vj0fG80eLmw1Y8tcBaJZMZM1UUgZIpLPbCpvAQEVCWSOglSOCYNPBosixOp4cp5krU1K9yZt0iZt0ibt5dpq23WcP3cJqkGdyCwqpQxMIy0LyyO3fSlOPbQsWpzn1xkXMD7ip+ISGTKDYsHkOKk4cEJ85nQfnz2zKUmuEt19zUDK79JGhLn5KlrNHla3msIkl1gxjERjk8VikvyjQDcX40qs6Sm6UqaCuVmW7h2EbqXhttfg2KwHihfYdAAjM6KSjeANPQztvsQ6Q4l94mCeJXYEU8h+YkJUDF6YlIsVjGMtzhEIQ34BGdXUuIqYOI29cyQByb+5HfdHuQXqQTGeYHkUZRSo71OtFLB06ysQRCpqm5vY6PoiGSCsqyhANQc8/vRpFAs5hIWD2Ng+L+x4ET+/huj4eEss6tmuBEcSAfVdptOuOHq87XiBH2M9Ad7GXIRjbCmWeRgv1dtx8RNG1DjLauz1Mbe+l1q7ERDpWsydq4mQX60E8rkWjtdj/ezVudrbaGh0/NVvwrFP/TWe+PTHRHQ8n2Ey1xVdWh6aIBPlPLg+YJJVnPpYaipC3RFcAsGgIZGPtJmSigmD+r8DG+URE44xs87EaxiIlMf0zLQs9Nk/rnF4HxD8CTyKnfsCEGhkqmRzGA768IZdienJjGScH3ouFANYXkvj9Pki5m6NKz2uNz7PdV12t1exuZXCoJsRvTPm27m82b+fxgkj4DQMcfiAik8/quDRp0OceIb3KJ0ENTzwiIvPPj4yfRL3PQIfAVTdke/RTQeA//c/pqESVBN2mYpLKyoGg9H3KlJg5kJMHf/8rgMIknzgAx/Ar/3arwmIRFCDYManPvUpAVN+5Ed+BL/8y7+MtbU1vO1tb8P73/9+LC0tCbjxDd/wDQLWEKghcEVg6Yu/+IvxF3/xFwKuENg6ePCggCEErriPBJQisPJXf/VXAqhwfysrK/I698XPveENb8CDDz4ogMyrX/1q2Tfvld/5nd/Bu971Lrz3ve/Fd3zHd8i27PPm5qZ89v7775d93nrrrQK0EXQi8EKQaHZ2Fu95z3ukr3/wB38g53DHHXdga2sLr33ta3dAKLbp6WnZJ4EnvvaRj3xEgBz268knn5Rz5HixX+xnAup967d+K+bm5vD000/LcT784Q8LiMY+E9zi+N1999346Ec/KsATQSmOzZvf/GbZ9p577pH9njhxQvq+b98+Afa+7du+Df/7f/9v6RuJNXz97W9/uxyDoCJBJ4JgDz/8sPz78OHDMl4EBHmv8hx5Lbhfjjf7SlCKAOQElPpcQCkxwBMRHqE35wR8iN3x6GhGgKbWMVHKKshZnKg92N0moGVRLhUke0VqOEEoZsu6tisI/0wpgzr1lgxDhM5Z9re61sShuTJanQF8z8V8KY3LtQ7y6Sq67RaOHNyHs2fOy4OzmNJRTBfA1F4sYB7X+FtGhIWsISVhOV1BTg9RZWld5OO2iolKjk5sDERU3DmVQc5UMJPThAlEhhXtUfm7OySlVhVrY1cJkDMDVPLUbLIR0T50qECPhjCiQKiizHT0WnX0oxH7ytRFuJ1OdlVmITwfimHCM1LoOApQ70DNlhCZJqJUHordgkJqeiojmQpfCRHqBlr9Ji6cPYnz507D9ai/pQjAwt/ZTEqCJmFRjZ6jLGlrk03U01EpZOB5afkyMIPKIIP6CWUzg6Gu45ZbjuLChTWsb7cwXSkik+IF5MTjYWWthq3thpTXMXvpUpvLDZALU1LuFwUB9k8XcXq1JnXYpkZnwEAow6Tql4t5lMsl0fnyXAemoQpw98RTp0WEneWGkqFMWaJFcfbCsmRsmJXcrDWFibVRa0lQm0+nRPPJ9zxkUobcN5frHQl6WaZHMfkq9bwIRFHYPaQwJO9RBZL3EAYfqbyxqgIBVk60Ma89ttU1RtT9SZu0SZu0SZu0l2PrdFvo95tYXFgQO3VqSQ7JtIhUbGy0UKzeglbrcXS6gczHZBH4ngMDZIDHC1R3BPZEQexox3mZ5iMpnUhMIDIFuYyKuQNHcPrCZTT7jhjCCENJiWReplYnA2/GKYxNXE611GYyNVTLBUzNzMSle1xs2tsIvR4ymgEq5gRStk+QK8RS1URdp9YTJQ3IxKITMEGVUMqVGFcJe0phCWIQA0WyVzqQxSCXrDeZMBVznhFQRWCKzl4j8EVjWSNL/KMI+ZyBfMaQv7NpAwdvugXTR+5Gu9nC6to2Lmy2JBEpeuuGivlcgNlCFul8EQ996hOoZW+KHZjjGkbZ/zhL6gogg8DSqFQuFjYfL+kbs+1jBDM6pgBR4hAdiznLtrHp8W6Z4M6RolgTaARgxf0Y144aY0Uln38JM6VuDNx4NkC0t/zoanpQL+bx9m7/7DIwDbnSFO59x9dj8+wTsG0HxWxaYlCCwtTwZYkpf7i2YYzMyg0/4D0NuGQljtyr5boGPvKZ2FRI0w1JrPMwmVxOvsuVUlmS0yw/Xdy/X5z4WGrabzdRmpqFO+jI943NSGeQD8sY1NfgdJoIUyYiarWxFE6ji3onNoyifO/ncIs8CxxEhLlZH1FlKOdKUEo3Qvl+8Lxj4mOEL/9iH6vrJh5/2oft0N1710wgUceKx5z3OxP0cdkb7/1xNqCqhji4xO8HSxVjyRZXpcHTjYGx19PHupFGAIMAyeXLl/HBD34QP/ZjP4bf/M3fxEMPPSQsHQIhBEBuvvlmvOUtbxFgI2HqcO30nd/5nVhfXxfghNt///d/vwBHJBncddddAuwQFEn6SLCHoA9BJ/4mWMVtfviHfxi/+Iu/iPvuuw/vfve75b1HH31UACee4+23344//uM/ls/z+ASAbrnlFnmfa3GCYgR4fv3Xf13AnNe//vX/f/b+A9iS9LwOBE/6zOvN8+VNV/tGO3gQAEHvnQg5ShSlZUijkCjGBDXShmLFCM2MQhur2VXsaKUQtaJmRyYEURQlQqIBCUPCErYbaF/V5Z9/7/qb3myc78/76lWhqru6AYLd5P06Xr9X12T++ee9md9/vvOdAwJkXPMTRON4ZiwtglkE3mbgEUEeHgPXqJwHzgmBodnrCXZxPASVuK1/8k/+iRw7gTCRuckyYSVxTHztDFAjg4nv49j5XgJTHA/BJ4JxBIzItCJLjfP8hS98QVhnPA4CgiI3lOfyGoJon//85w/aBwn08Vxwrj7+8Y/LPgiw/fIv/7KMh62Nf/fv/l3ZDsfw4z/+47KtD3/4wzL2g+vxHJh6/UwpfqSZJPACSVBjPA7gdOuyoL++18NSt46RT8p3jlbNhpFHksisLC7IB3A8DUU3gLRoOvcR8WeCs9RypZWPFahcM/HiBkUnQ9QsXTSnWlUP9x9twg8CREWG/WQdy1UDY58uLApQ4JeESZKStstxrK7hvasOlmseXETKTYXCmKYmbXSsjhFUy+WCogAY5Winene1jFpPMaZ2ivEkQu6YWN8biqtLRZwaVAVQWuDiWPqwSa1lhXA0mkoSM5z6ok+10KxCj0PUbA92xUCaRyiKCZaq1NYqsLO3hf2tC7C8OqpmgTAIkRgWRsMpKq0OrmztY7c/xM7OFpIZICVC54pJROp8rUMh9AiRRrc5o3RENBW9l3bIcnMyBKwSnawiRSLOhufkpsQvNhlS7UZVNKbOX7iMnf0xhsOR6Gnx/dQzZGseL/mj8VRRQDUdXc/ESrOC9d5Ikka6HlJjbHmxI1XJ/nAkX7xWs479wRBfe/68fCFVNZRihQ76w/GBC56mZdja2Rd3ESaYrATRill67umyo5tY3+/jyt5IxOabroWWS3c9JqyZ6EQReOIcCRAlzoWa3GuFOCc38tLwhm5Es8yU9P7SGfmNnYbNYx7zmMc85nH7yLUIL178NDZ3KoDmoOI1Yeiucp2teHDNIUybeioZ8pSsggSm6Kyo+yEduOQeTR1OJjl0zTPYfkctS74nFRBrsbOMXLfxlU/9noAvk1S1wFRNYMK8I1eMeN5PyVInm4OSKM2mg4Wlrjh+ichy4kPPAxz3r8AbkoGkoe+08FzegmYa2J2mMCyaxigmEINsKAJSNIhh7kW29EzPig7HHCP/5kJTgTIKZJHFAJOnkmXONQEZ4ooZpUku1244MAs6+bHgBxw9toKTT7wPSWFiyFaVS9vCtCcywH0wB6mbMcIpxd8T5FGCvWwqedMMjLoVkLoJGDmk3aRyoFJrqnxMWO9s93INfNs9bXzuhR34iY5TSwZOLXl4cTPC+ojAxQ0tr8OtfApnmmlHHXbaO8TgmrXuzYS2RWL6MIPqjRN3AwS8Govq1ZzgXuk9s3hF5ttdtQEqHdlj9z2K1VNnsXvpBVljke0n804Wf0jJjlzWGeIwyVxeWH5kHuqSR5NBlVGkO2MxvEAURKjXq1LU58eOC+4ki2A5JmwSCtgSyPWXWwUqOka9HqaDPfV9LFuq4kCHJiZCJpJgKmuGPByjsGsw3SrirA9/SlMmauIq46nDshevdI5eaU6oz7u9rSMObGiliDq/AYsLY+hGgnqDa4ACS90A/9e/kWF738Z+z8BTz1n4d//FxxMPe/iR7zEUmEXWhM4uEkOE0bmtepXSMQrEU5/zDDu7NgZDR7ECuYaoali494Z202sZ/90GWUQf/OAH8Xf+zt8REIVMIgI7//gf/2NhEn3P93wP/uN//I9YW1uT9SZZOGT5kGHF9xFMIljyoQ99CKdOnRKGEVv7CEgRcPmO7/gOAZsIGj3zzDPy+SHjiqAMt8l9vvTSSwLWPP3009IGyNcQTCKTigAR2UPr6+sCdhHg+qVf+iX8g3/wDw7AFD7O7fPzRcYSx/2e97xHHmMbG9sBCfxw/Hw9x8Pt8nH++/HHH8dHPvIRAYkISlFXiwDdbLsEcwhQkVnEoP4Wj4+v4+sJBL344ovyGrbVMfhe4gE8t4d1pQjMEfAiqPWZz3xG2FJ8Lcc20+Iiy4msLTKzuG3O26/92q/JmAmwcb+cW26bABi3RwYZ554MLR4f30ctLx4/QTwCcNwuv1PU/+I4CNqR9cX3kXk1j9fJlOLFjk5uijIaCvU0iHOESSbg0My5g453e6MYrSqtTEOEk30cWelia3sPYejLBUVpPfFiqdhTvOimIhaeo2ob2BlMkFQdceGLhxGOVIElM0Y62ZZqnRaNcX+7itSzEOSWNB0TJKqYGZarQNtOYSLEylKTHWtyg9W1CIZ8gQhu5JhO2TtNoW8f0GlRzP5tAjoqM3A96k7lyFK2kAXoVkzYWiati4OJj4B+yJJsKOCH4oE52VMFsLE3xJm1LiqehStbI2kLe7heRX8Si/A2mVe9sY+L2yP0AuowAEGSiCD6cBqquxUdN3IgiGIl0il0dUW15fNKT6qQCgjdI8jGYqWQOhAztcxpEAkVmOPjMUTsoUyVaGIwGcOcjLHT2xWx8mNHVoQ+fOnSOqZ+qLQbyuMTOi+FF4sbF3MCXDkdAE0Dxzp1UIqhUa2iWfOE4ktHPb6fToS8yV4dTaSCQwCSUaswYQb6g4nsj4kwGXNsX9wb0j2DGmOmsMB4QujIwwroZq+HnbGi8hO4pH5XmCiXRKnIlomZAu+YWKmEk49zPkXwHpxbRYvnv5lY0nWwyPibt9Y3XiI2j3nMYx7zmMerhWECfubDHweSj7SKLTSqFgqzQH+so12rIc/q0DCSYo/JhXCZY7BGo0xp+G+yjXmPVw5gzJEmkwjIIthmgWmY4df+w3/Dyy9fRcPVsDPhPRqwUw0T5iVk1lM4WKfzHl2LTawuuqjXHVRrFSk6BeMhnFpPCoGR18K5b38cJ06sYry1C/fKFM9f3ZEFdKXZERa0reWYSnW8kNyGGqPMZ8gcUe5y1MqkXIPiSs3AGLKnFX9CJXhGKQzNkGVvCchYpjKbWV500fI0nDraxrlHHkNt4SiG/SGefeZFfOXyQPKuklaExYYNI4ux1xth3x+i9diP4Hf+0zNl/nQDkJqxomZUJxbPbtaQUsFc+jAgNfsrTnJUEePP3JMgSEycre/igfsbKN7fwYc+p+G/PjUsWV+HWsZmgFfJBpsBVDe5AJbsKDW+Eoy6SZ/qjR13AkC+WaLms3g157hbx3M77arbbc+uVHHk3GO49uKzIlpOl+tmpSJrq9l3UVg8BE35WZI1WAm+SoFaF71eynj4AYv/mbD8giDD1PfRpFufbsjaiYVsghe94Qh5GqPabCKrVZGlMdI4lDxYiYGX3wuLABYdrRMg8mFXF2C6NWSBgXtPTeEao5KT+PXH9mpzf7vXEC9eXMjg6LGwNjW9XIOk+cFeJL+n1pQe4ehihKPLwJmTLh57yEanmeHkMZ+rJWgGiQi5rFW51lTAM9cjXMuotl3+t7hYYHFBfdSFkQbztmZH30xWC7dFIIqaTPybLW68ThDYIEhDIIasHYIZ/OFzBF8IABHwYJCpRO0iMo4IUnEtzffPNItIHOAcE8ii5tNsv2T3zMTT+ToCU3wfmUUEaLhfAjoEwghecd8EY/g6soMY1Ef66Z/+aZlL/hC04vh4HO94xzukvY9jItDFfTAeeeQRAYNmWk48LgJTbLP7uZ/7uQOAiMFj4Q/BIO6LIBWBOoI8BIR4THycrXkc6wyU+smf/El5n2LB3RBB52O/+Iu/KO9hiyGZVWRIcQyHxeM/8IEPCCbA4yAzjcAf55vzToCN4xeSRauFv/7X/7oAcTzO9773vTImvo/v53FwTn/4h39YxsH3z8A0thRyzIf3+yc9XjMoxS9rEJEZw+REF2DBdSkex7+p4ePIhcMxciXQbVmYBgrx9+wY0WSATqOKXhYJxVQqcVKRIV2SYIsJgwmBVuB018GV/UgQ+8UK4KY+sr0tBOkIvdFExMqTJEKzaGOhUUVbp7C4sjzVSREfFgjrLho1F3u9sYhhkk0kguF7YwEcmk0Pe31fGDi1iov+KBKHN/7NcRHgEDeaOIFPUChT9FnV+qahXXPR8GwZ43gayXESnGGvd5DkmEZVoa53PRdve6CJZy9u4YsXdnB5Z4idSSRtgREtWlm9k/okWVrAvk/RwNnFWjkLMmZUbUm6ZhWe8nGdx+VH6NQr6I8n0vJGbSmylRxbk2NnUqcqcOo9BJSo32BMApy/tC4i54ZmYHm5I3McUiSRop90IoQGn1VOYo4JkzaKlKoedo4nSglW2rj32LLM0WjiI4zpSqgYdZHceJXbCG+aciwa5GKnqkJSzzyoEDLZ5GeJAqZ0QySgRpc9CpVf3euL/hM1yCzNEPCrVnOEQcXzxURUckVJrgvRiJBtCpBHu2gl8Mc2RibbnI2aZihtCrYdkl2WznWl5jGPecxjHm/O4L2wainXYeZUka9hyHzMLtBukHUUIc5MLDRyXN/KEIeR5AvSyl7QnJc6mlxsKOYzpRG4OOaiI4xSafOrug72pgRkUrFq7zYM7E809EMFRvE+nBQsSunoENxZsnH2RAULixU4NeaLCSJ/gsj3kcchijSBXevgysVLmAy2cebes/ipB+/D3jjCl567hhe/MMKQmk9mAVMIWWSIZKhUDWUTXxbppIp/uO1MI5uK7YSqQKXyJi5IZ3N1gxnNVn8ytzpdDzWnwD2nujjz4MPonnxEFrHRpIfnruxjGEOBXuLbU2C1ZiAOfYx9oLN2DzbTJiY+nflu1hOS3O3QfiXR4WjKsZc+fTct8GcaUmJVnxT4jeen+ODDS0i2nsGXNmK8vD3Fe95ZwV/5wQfx/NZ5PHN9dEgTqtzCISFzeeRwfiM5aPk8/zvUi6Vand54udDtwKG7BQzu5nV3w5KaPXYnRtSt2lV3As0Uo8PB4qn7xAgpSfs4d2IJrbqL/thHkuiIc+baKTSdouUsRKu1gzhKO6Z8X9kpYrhcd4VS8Od3wqaURRzJYlm3bTQadSkAi75rEqHI1DqL2rUujYNMGgewZTdS2q0EoGXNxzVXCJOF+0pX2EeyXhmYmPoEAA6ZRH6DwU//cOgiDStqjsDrUYGIplN6gZMnJqhXqGFbYDK18eJFR9pX3/nEFE8+EmN7r4YP/XoFz7xYYOqz07DAQhd49EET73uni7XlWOZ8OrXw+aeUtixxENcxhV2lGxasioWFg71//fm9FXB8vcG1D1lLh/99mDlz+LnbBcfAdrJZSxnj8PtnTCGCQGRhzcY8A34Ox/Hjxw/+JugzC4IpPF6COQTRZkAPfxM8m8XhbRJkmrnYEfSZBUEYAqKHY7YNgjm3i8PHw22yrY8xA+ZmWlmHX3O74LHP3sNj4c/tguDXzEWQr5+9h3HixImbXkvQjj8MjuvWsc0AvDvN8zy+Qfe93VGArf0JVjsEfBwBI4jgs02s7qibPZFnVsVI9STaPpmyXcwWDaAsC1Cr1TGejIU2LiLipXWttMyVIpiLdeoWGBgPegjXryAOB0jjAHv9MVbaVWxPfDRrFp6/todOdYxGrcJUSnqxyXLhuPaGE7mgEFhZaFVw5OiSJGfxOMDW7hgdPxB2FJ3palUPYZKIeOZzFzekUkAAhZU0Ahutmocs06ElmYBOPL7QzLC5P5EEjXRaigtWqy5qno2kN0anbqM/ybC+O8I6Cnzx0i42hkHp7kZKO9vgSGlUon2ie0BquWQfs4TphsYAWUGq4qUukjOBS6X5oF40DiJJeijqLW6GfgTPoRWo2jarBHwfKysEqsIww/7VDaxv7QtzbGNjG+tbu5iGERxDw2AUSCsgQT0mLppxo1rH/FXVGErGFM+3HkIrdOmFp5aXEktl25zSsBLtCqF9KoCIryMDa9aWR1FTnv/eJBCQrVHhxUxpQmz0xtgdc/4y0TPjsZCZJs6HCan7OdpVCrkqYdCZtkLFpAB+LoAkk1LRpJK8m8CXJsAhHfkKCsLaBkajAfYH/QN3innMYx7zmMc83kzhmRqOtW3kRoo8VWwntrhR+0izdDjC6Naw0NGwsZUJ25jqRLy/sgWe+oo2hRByVdghS5qLXt7r2c7vWA50yxWR4GPLGU4s1PFff3cfJxcsWPsRpjEXzQqAqVsFzq1YOHHMg1e3RILBKHOQrb1LMC0HneVlRGGEixcuoD9VoNhn/uBrWOzW8La3PoLvfct9uL/7bvzyFz8B14+lPZALbs/MsdDQsTPUkUwJhjHPKWDJYl+5JjNjSqkXpWmImceU+RS1mbjIZfFLdLDKol/DM0Fy9sljbaydPIXO8fvgNJaFRVVtNvB/+Ws/jXecX8eHf+dz+IOnX0J/PMXZjoHYDxDEGtYW1vCFLSVZwPeQgTYruCnN8hJQuanZ6YYw+U2aUgeEJvU82ykpc6H7PVApc32c4rPX9kSP9GHnLCJaUs9a8ZS4lNpu2ZJ3uGXvYLdlC5N63c0sK2l3fAOCUozbgUF3Axa8Ejj0WsXSD//9WrWmDo+X7aNLx08jgIOXLm2iXvdwarEpJk2UPOH3jI7abC9VLWeUpFAav2zvI2BTdU0BoigGrtpTaVrA76omv0nKq9Y8AZOYE3e6XSnuc9VRbXdkceC4FRR5jCJlqxsR11kLrCrqQ6/AWTxROuCRnWgii+lqp7Ri5fN7l4DenULXcqysJEASqDVRCajqoGM4O2u42tOxuefh//lLBp5/OcW7nnDw5KM6rlz28I/+KXB9W8m6kInIa5d53cDTzxf4yKem+B9/to6H7wkxnAKf/OwQP/Z9VXTbauziPZpqSKnjcbDW+saO540Q36h2Ed97KyAzj3n8kYNSnZqHLw4mYs15bKGqbHAD9vXHWO7UEUcxDAIGTGaSWC5ivICOprEkOU2245kpPTmVgxwvenIPVW4oAlaULJpsvIONl5/H5s6esKpmukEXNgdYbnq4tBnKxepoN0MmjJkC13eHqLmOtBhSP4oX1U6zjXazhvMvX8fKYgt5mmN5sYkXL+8Io6hVcXF9ZyS0UIJXrCS4JvDy9QEqFBB3NOwOfdh0qKDzS0jWkWq3a9U9TO0Evp9I2x5vBLReJq224ZjYGQzx0vYQV/s+IqGOU9+ItHGCNQpJEge9mUVv+TO7gMg/y0rajEp7MEEEXvg8aYG0mwwi1eoYhWjXHAHjRLQ9iuEuNeBPA0kopeJZFOJUM5iG2I/74obIFjuKk6/v9hAkGbqNioiWEzgim4kJJAXVORphjuUWHJPaE5rM92gaUCJU9BiEjkynDiL1pe6VuHZwBkxd6Ml08ON2+Rwp+KMgFhTdodWoHwpgJK4iWYGtUYBxTEeQHDYZV9BEj4xJdtU2JVGjVhidGFVFVO1XHBSpWyV6UiV1v2xD5XzTqZEaWeIORNB1bwcXLl+StoI3Zho2j3nMYx7zmMcrh0bQxmHLPYtBBVyL5vIG4shAlltwpY8lx7GOiaeLKaYRMI0mqFfJOs4RU6C8dLejazFZ4NSvMan7SckFuadzEZegu6BhoWEDvwcMJhruP+ahP4qxMyaLGujUTXg1BxPY+MxXhjD1EZbaE3SbPbD2c7TpwYhOYnuzj8k0Qs4iU5QgiTQMBwOsX9/B6me+AtfS0KybuL5XoGJqaLlkaWlYaAP3ZA52X5hAZ+VMCp6zPEDlACxU0pCHhSkGRy4FrILOvGRYa/DMVBwDaYKztuhgcXkBrdWTcFvL0OwqRtuX8NKXP4/lE2fw1vtO4a2P/BlcurKNX/+N38fx/CKGewHCTINbX8DmV/eFcVIxdTTcGQtJk+Is2xg5t3Qq7E2BMFHyCwJHfR2j5gZ7SiSGaF/vZTBGGyJgf+/RGt76wCKWu1V86tNfwrLbwUs0qTkEQs0c924AU4cYPiXF5YZL382AlPz9jahY/yHH62E93Y0g+WG9qbvRo3q117/6WDU02gs4cfo0nn35Kj79/BaW6q44knOtwE4HadNjzl22ntE1m7tnHkx8quZZB7/5Oau4thTRq40GXNeCV63I93lpZVXa2bx6C3oUCpPFtB0RRucPxWMLyqGkUen87SCakGnlwuscg7twQnJrDRmOdHzog0R1O5Qi+neag7uZGykWFwauXbcQTymgrSNO6ECY4szJGIbF4jdfb+B3PmHhmRczWZPwmpWmJn71N4Grm8z9SSbIIQohhgJy48TA+raO/+NDY/zDv+PKNeKDP1rD/WemCCNT9GRNg3pdOjJqIL3C2ZrHPObxBgClaHt7bLGJ3cEU7aqNdt2UxCTLdTRsBVBoeQyaHESphixIhVrK5rQo1rCfh6h7ljhKdDtN9EcTJFGkLkii/VNAz3ME0ymuXruGzd19TMligYbeNBRnFLalbfsxWq6y6d2bJAizEc4d7YhwJ9k9TWnTZz+qjt7Ix+7+GJbFHtAaLlzbEy0jtmkRDaI7GxlOo0kkFyHqG4ndsA70hmOwHhXFKfqDqfRot6ouHMuU9jEmE8SMCAyN/QSObWIajfHly3vYHkyxPU1EjFNkiw67rMiMlODTISHJ0hPuhhCliFKW1O4yvRBtJFYAWemUbKJAw7PkhkX9qJNLTaHvEsxhGyUrmiIU16E9pyM96Kxgki3EG9uEWk7UoUp4rizpO6+5ulRheJEmAFWFCZuMI6USfgCYcaAEikjvJENrOJkIKKjoxay8MvHVpAWSFR4RWi/P93jqC7BEthwtl1umib3hFMOJj4anxOcqjonr+2P4SSI3ZibX1NQKklTa8FzDkJaDMI7RqDiS+DGVFqyTmmCmEmclEEjeE282BUVd6caXquMXkCpLcPH6Fez39oVtZntfT22dxzzmMY95zOPNEOLIRkaOkVKaUgxdyBpw7Bx5bKBWT1CpFWhlJpoNEy88OxbZgZVWjGOLFWEkUM5A2OJFJMwrGs9bvM1qhrTU837brKdodynrkOG+Uw4+97UUzW4Xjz7cxqULL2N9P8HOuEC+k+HehS7e99YGGnUbv/2pdWH1vPvRUzhz71HsbG3i4x/7PJIkQBpn0On2JwtfIPBjbG7EWGxbWFuuYmN3hBd2Ylmgp5qOvp/j5MlFXNkJsN5XeQfzUpPuesxR5NjJlFLtcwJLlYANmVQ1W0fDyQXgOtI1ceKoh9W1DmqtNtxKE5bL9hINuxsb+PhHP4vFzrM4fXoNJ87dg1NnHsRf+qF34Iv/6Sn0Yi6QTVg15rZX8MCyjT/9qInTSzbcqiHFU10zBfyyHEOcxPb8Ai9vxnj6coCvXfex0U/gp0qEXWFBXOyXSjqiI1rgiJ1id28At2Lj5MkKmnWgUo2x39/D0PVUy520DSrNqxlwMtO1OshFS7BpxryZvVbAgwMHvzem+96trXu3Y029EgByO4Dk9TJiXm2fryx0fuM5u1LDw29/t9jcbw6m+OKlPXzgkSPotmuqVW8SQjNYcM8RUzKEjtERtVgpP0EZlQK1ioOFdgXVqodWswa3UoVTb8Cp1kRfCYYCoNxai/Z6qFbrMJ2KXCtM24Nh22KAVKSBsJ+sShNIdHhsBfSqqJ54CGatXcqAaAgSA2FmH3xW1BLn9syx24GDX/ca9tfomjCliljp4Yk2EF1BKU5eFucJMD1zPkOh57j/jIk/+yNkfha4tkFAVsOTD9j4+Z810GoqUfQwBj7zZeD/96sJLq9rGIx1VDxeY9SaYTi1MBmb0A3VqaK7CRbufdVTP495zOOPDpQqsDMKRItnseXh2t4Uda+JDnvp2d8sVpqkbKfw2KNrmUhSZd/LiwUvmHx+GiYw41QurE2CQezTD4MDe0ReZOkIcOHCeWmLE20CtmgJaAVM0wy2XIQNNCrsp2Z7mYmrO7QyLdCoWDI+Pk5mD/dPHaPLm30Bqt715H3Y2NyD65rSxkew4+rWECNSwmsODMvA1c0e7ju1hHajJppUZBR1mhXs9abY6E3l2AiudVqE4XVc2uphsV3F05d3cWlnhK1xqG4i5bwJtVUji4eJkXKvY7Bqp1SNFNDEBPC2F/QbBhTyOoJfArrYdKTLpa2y6TkClLE82KBjjGfJDx+z7RIoonOdqQtLikwk9olneYKKbWN/EghraUS9CIM6YGQf6dAMJqCk/fO1itHGmwaTOQJfjvCC2TdsKmtY0ZhKhQ1GYIsMK54rVjDTNBE2lySDhi4tfdSHoigpgb4uS4i6DktXCdXVnQH2ppGAVzxeETClPW6hEk9udxRQC4PAJ5311OeQn5eKZcDjnJLGLMmcouQSOGUF1bZ0+TyOx31cuX4NuxTWT1MstDwc7dblGOcxj3nMYx7zeLMF9VM9SxMGN++LukVPYgOmSXZyhklcII8JZmjotOl0FCDJU2EaEwyKSkYRC3KiESqFxRhj6lJpzD0ocryGR95C0eChgCf3nHaxswecfehxPPrIEtY6Yzx/McJvfmEHm4MEZ/QKjp+YwPdHUhizLRdn7lnFNOnj0rWreOnyujA9HNsSHRhqPIp+qcZ2xAJ6GqPRtPHWtxzDhU9cwoVejsRIcAYGzpz28M4H23jqxT62+0nZTsT8kwU8oHCYc+SCw4QpYLLFj4CUBRxvFTi9YmBt1cXSUgNuvQm32hSHMavagGF5iPwBNi+eh5nHGO3v4oXRDtZfPo/jJ57HeNhHFg6FQa8b9Ho20chG+N7GFVz6xDYumja6LRtexYUfqkakZsNCo+GhtVDHo20b736fgzhrYGOQ4elrCT75YoiXdlIEqWLFMB88tljDYDTFotbHziiGFhSIMcBD5xax0ziHp8YmRvthmafh69rxvo4hdJO7Xsm8P6xFdeDI98a3I369zJzXuv27acU7/O/Dr7vTc7O/LdvFA0++E6udBvbHIb788h6Odqu492gX7XZD3Av4GSO2SM1XFpvZjsu1Uc1zUPdsrC7UsbyyICCUR0Cq2oTh1QCTnQnUS6J8hQbdctTnm2LTrtLWodC5bpqYjieIB7vS9md6DRieB8OxoTtVWM1VmJbSCKL20tWdOi5uW1idMYtepZXxbs4BP+8bmzbGAzUuFpZrXoYTx/i9VutAMjBHYqpQ4B1POHjw3r4AWu2mLXIg992n4+gqncNz6c5AkeDb32nhv/x2jjA0ZA200k1QUH6o0NBuxGjWWCRXjgeZTvmZN/iHfh7z+JPOlJIWp76PE6sNZGQFxco+2GPWwO92BvilVgGRe9MmSKAhiAsMprGwplhoY6IxCUJYCcW0TdiGh8E4FNvF/v4+rm9sCEOHaRGb3FRlq9yHtIYZWKp7OLlYUwkU2ToEaNJMLIi3h76IslPfSfUVa5JYXd8d4NrmvuqFThNJDqh98OzlHUnGXri2h2bFluPc2BtLGxzZQ9NIJTMU2vYsE36SodWkGwAZRMD+OMBzmz3ssY1PHGcOyeMRTCl1BNT4Sxp2Oaeqde/GxZxjVYmBYk6JJXNZ4VOFM/Zyl/RvPxLmGNsiLQ2iteR5bOEjs4jio7aIlVLYsF0n+4fMMFNE1v2QNFgFOtESen/io+K6mMQp4jQV5hSZZkzsVhqeHAN1GSZRiqptqR51zq1uyPzzJsm+eL7XYg+3oaxseeOho6BqQ1RuD+VtS45lRisP40TmOPBD0aLi+RiHMQK6hpS0LNY0ODFsK+TNyE9Ugsw54O9QWg2ZbBoCxhE4FAvdLBNnHtmKzH0hAunXNzdwef26tH6STdVpeLKvrf5EwK15zGMe85jHPN5sIax1W91bySiWAl9KHUlD7t1c6DF3icJUmFKL7QrqlQztGtvhdSkeHlupYzBKMY4NjOMMq8suzm/20GpUULM9NJeP49jJIaa9geR8a8crWL2UYnFtDbW2huaSiYVpAycXp7i8F4tbsdeuYDAewKs4WF6oYfn4AnqbfyC6TrSvj7MEzWpd8qhJFIE2K/UqpQJy1D0Tj77326FXj+LjT/1DDJMQI4qq6xXUCCTxuHQDm5sDXNwKIH47umJLMQ8chCqPYPLLIumCB5xZMXD6mI2FrgvLc4WtEhVtHD36IOrtZRFYTuII+9dfxLUXn0G7QkmFDP50imHsYwdcyFJri/lqgVa3hd1xhiPpdWydvw4/09FtZdjdD5DsBpK7spXw0jUgLgrUKzaWunU0GnQNs1Gr2/jA8Qq+9z4P14YafuuZGB9/IcE0BX7siUVYxhIuf+JFxKkmxWBrnKKxchIffnaKgZhBK0DqVpbUAftJWhZnUNTh55Vg+816VDPG/hszF7obBtLdClK/EqvngD32GoCs1yIOP2NukfFUb1FupI66s4/tcYJPPk+3cQ/HV+roUrcszuE4EcLAxyiLpJuhU3ex2KlhoV3DkbUFVDtdWF5TPsumXQMsF+NpIKAWt0WmFOhK51Slz7fQLCSRD384hNdoY/3KFfSvX8SRo8ew+sBbxVU7H12HUe1AdyjqXHZvaBrOnQpQsXoHLLzbzeWd5vpOc6RrGY6sBcg6E9GkJU5kWzR4IgtK5fECKFdVpf53PhGh5tZxfC3DQ/fX8bmvDPDxT0a473QNJ47kMGwNceTic1+mTq4GzyHriu0UdDVUa7ThyML+fqnrmwN2rUD33rs7h29EI4B5zONPACiliVNdlOZY353i6GIVEz+Ba7EXme4nvL7l8CgCHmVC7yajh5AS3VeSTMfl3akwk04t11Gt2HJTjeJQHE9adRuDIhWB7CCKFBhVkDI+E/su0Gwt4ty9D6OOCVrRjugYhQmZUCbiSQI/jrHc8uBaNmquIUDUcreONnUSADx8chkXNvrY749xfXusLm62g9XFpjCt9voTScZcy0CnUcH+JMKKbQnwwja1oR9jaqSouSb2R74wiV5c7+PaYIpRmJUAkmrJI2CjqkyzizCBD3Uxnuk6CThS3uyYhJGOK53aZQJB0IgXZAFjRBRdnQmKkZIl5LlkSmXQNVuqJXTA2xtN0aq5qBBc06glYaBeVb3llsVKqYVUxko3RQWiieteq6bc60xdKiAUN+fzTGD5mBIwpI6EshgV9pvNqosSLCUhKaGOmE5FMd4EErgmWzUNOUaCh9wPWwR40Wc7ZZLkqFU8jHxfWFdyDEzakhw9P8QwiG5qZ+Q+ao4rTCxx06Ogq0UWFtsRlRU0daUaLinymgBUSvC8kDmnpazYvaYJXrh8Bevbu8I8qzs2giRG7oeiB2aE6rzNYx7zmMc85vFmC95P40gXhvB4pOPyNnB+3UdIzcdSBsB0eG9Vdt71GlvmY3iujSAMsdAy8NhDTXz+KxNYXgWuZyLDEJbrodlsCQNh3B8ijqaAxhZBJTr+wIMO+tuXkd+zhHFMLRcLjz18GvjqedxzpIulI2vY2djCStvD/fefxCjYQYgIe+MaxkGC6STESgNY6DbhB3Qey+E6LlpVE2srDRw7dxbbvRDLLQPDyBZG/Pd997fDSPdRWDG6K0u45+EHUfz27+H6Xgy90DBMyhzEUABV3QEajoEHTzpYO7mK8aiP3kYB29Vw/PQCTp65B4OsiZxWekMf/miIC099AUU8RtUxkNDpzASqLo85QhD5GE+nkvOdeegR/O6lPVQLX4q2Rzo2BtNIWvLI2Oi4KtfzRQuowPXeFJf22aakCcP/9Fod2TN9HFmt4MTxGv6HbzPxA4+38KtfCHCyGWNw6SK29n2RfGaeyEQxctp46doVcUc8cMubsZ5mzmHyv5meloqbtKPYqTCrouY3xM1n4NYbNe4WADn871diO91N+92dAK/X0rp3J+dAt1LD2uoirlzfgE891YGP56/3sNKtoVZ1UW+4aMCS7wZdzNlr0W1XpGWvUvMQwsb61T4sN8biko5mp4KCzpZs3XWrcGsNKVQHdLUu+tjb28eRYyeQRAE2r11GoznE+uUrMHUT3dOPoNI9gjwOpG3QrLagW1xXqOsGPxeXN6q4dCUtW93uDgi83XEffizPDVzfcJH7ykWNrbeul2NlOVFAkrApc7z7CQsvvBxjYzvFP/0/lSC7rvdEP+raZoFf/N8iWLbq2DCMWGlRwcbpsxk6DUU0KHITeaaj3SrQanC1qdqSEz19Uwqaz2Mef2JAKX43HZssJVr9FtjuT3FipYkwJjuJLWNs3+LVyoBj6wIIUZyPwAW/6KxydRounr82QAG66HnSvtVwLXE/0yJfhBuzOIIfqQqAkodUF4V6rYF3v/+HBGwYvvhJXBsoNgsdJ0I/RIfi3pYjwMo0ypSWlZ7js89eR7dewZHlBq5uvIAruyNhxFAEkKBWkAa4uD1Cb+xLG1hCe1TTlpY8wkajQAE3a4sNtOoO9kYh3MLENMnwa587jyu7E8TKRbm8sCqHlZkDHFk/ClRRiSCfIxDCf4gek0bHF/HhOwCvFAAzA4IUnUqBWIoxRU0uVj7zpECn7gk9fRQm6E8CdOqOCMgPJhHajaa08LHFruKRos9zQTBKAWBkEJGOz/tLy3ME2FnwTBFJJLhUVC14LEmQU0ZtCYJJvCFYajv88eMUkzASrQOeTz7IfzNhahg6JqFydeFz1KQahjGqPNGpLp+bIJkKw436TzwnEx5HEGJrTOF0NS88dtc0pSWBgFRcVmU4t5xTaR1lhUNa/ygmyo93IWMj24vnhGCUVmTY7e3jpSvXsTccw7Gpt5ViO5oqBxLHwXAyReeQhek85jGPecxjHm+mYAGH+ijMZ6oN4OGGgVPHbPihKSwb3vv3+zm29zL4sQabhiOaMmxhe/x955oihF6pWsKEtt0qJkMfrquhamvo1nLo5gBZOJFcR5xzLQ2LazmufmkHk6CJjZ2QKlR463e9D0j3EPW3oFsPwjItLDQcNI+cwO9+7KNYWwEuXRvDtQosrXpoVyr4tu9+J3avfxYf/b0h9gdTMV4JCgtxniDPt3DmhIdpauHsqRU8/PZ34cInPwzbduWx4w89gHtefh5huoPeJMPOMEeQAUsVOnERcNGQsai3eBKfG3QRXumjTk2pJQen6msYxx4+/DtfxA8/3kQwmWA0GCIJJ9LSbxmUeGBbkw6mCWHoY+QHGEcJFlbXcPyx78D2l/47bDTwnuP72BvEmMS6FEXrlo445yKZepcFwkwVvyhJQFBqqzfFdt8XttfLWw5ObYU4vuJiaWGMP3u/gy996Qv4zNPbcizMiw2TTn81PHt9ikmQ3NymVwJTwq+XXPRmIOamdr6va9crgajD7XtvwLiTgPntNKNmj90OEHmlbb2W/R8Gmu5Gr+p24dWaWDt2DK3nX8QoLtBtKr2mMNex0uzAbS2icfwRxIWJ4oWvYjT2Za1AofzeKISVh1jfncC0CBZbsKst7O/soUJnamuMKL6C1tJR6QaYDHuI4xiGbmEyHGB7/SpWV0NsXD6PJ9/7PeiefECAL6tS58Bg2ASuqVanACmuS/wpC9Vca+mv+VhvF2rNlGOV7ntpIGsbVtDp+D0cO9K+12ywmyLF939HiM1dFx/9VIRJALAHQ8ykyqEkKVsblTC8aWlw3QKnj6X42T9fgWOH8t0IQ6A30JHlLJJzP+yqyGBXDCzeV3an3MGt8fDfb9TvyDzm8ce6fY8slBorPazE5cDuMMRKp4ppkMAPUqx0XKH96oYG2zYQRYnoAdkW2UY5lhsOJgtVDCcxgjAVjZ+pn4hzi7RjTSJsbW3JRUGuRSVPhsDD/eceQMVxsPX8JzHZ2xHBboIt4yBGq2pRfgApMkS5hqm4AiZYbbt46OSCMJoeOLUkrYS2Z8N2bAyHI7EUZkvaSqeC1Y6HIM6wN/KxM/AFKCPAFu6O5Sbd9xMsNj057ks7Q1zbHws7SlwDDypRN26G6r+y7YwgEx33StaUqkwpwEXa+8THgoCT0pQiXq90pkqh81IOnUwjAlh0xmnQs7go0B8FIty93CSvHLi8M8LZ1RZqVTppGHIu6J7BOajV6ZioCRhEa+SksAS8oxg79bd2hhMBzChMnmkUlbfVuaB+FK2NNSZi7GtPRficc7E/HCunP4NtkgWGYYr+NETd5TnJMQ1j1CuetMhNIyVaT+0KtlkKTZb6VZYh7CoeD4EmnlOZx7JSx0qHiBWmSiNqdkNgFZg6XGSLCROKovtsG6RToGMISErASphuaSLaUS9vbIp+GN2EaH3N8y+i7JqGgThCHpzNecxjHvOYxzzedEGjmUmiI4kyaBRGzti9Y2GxSRFwakAWOHeURRwTX7ts4mNfUHIGbHlr1my8+0EXpp1jZ1fD5c0c40kAPzFh0nK+SHBkTUe9lSOO2AroSG5TIJO8bqfvwzBqWFykLoyL5mILqydtPPP0CGlsQtNc1KpVrKxpuOfkFLv7DtY3pnjrw0tIphFO33svcu0a3EaEkydsbG05OH7fW/DyC+extzOF4dl48OEG1ns+2otd5JqtdEl1oH3kBMLp82LYwrzOc8iQSGHYFtYWGnj20j62hykSut25TVxfH6CdJShMT9oAWZT775+7iE++tIuH65tigkLJA73IJZ/RHBsGW/YsOn7FGPgRxmGCWs3FW977/Wgvr+J/+pl34tkXjqL47K8g3r8kIB/fYJsaqk6BSaDAKOZEXOI7lB6gpERGOecChPJG+6m07F3YGEsHANndAz+WZbtoTOk56paBk2eO498/3y91pA4vjG+4Wat/zgqeN2c3B4LnNwFaN7b1RtWTeq0Mqbtx3LvTa1/Le+7EgLqb1/Nvw7JQaTSEuXjKrUgh975Ta+KURxfIpXvegs7ZJxVI099DnK1LVwrlUSZBikbhwvVcYUrSdXI4jbA5iJBv93DixAkcu+8xnHjoSfzW//z3EY4HaLaaeOarX0USx+jUq0CeAsEYrXYLlkP3OxaDlYs6vwczfVz1mdDQaARI07Fot6hD/Xqw5m70uG48zwKyhq0tG1ngSZstXfIiLvAKDZ6XodWI5LNccUL8D38+x/d9u43nL2i4vgH0hwX8gF0SapumRSMrYHnJwEP3m3jnYxaWOjRbErVfVLwU1Qq7P/jd43Hye5ghZtdLKffxSh//19rWebv37+/vw6UOcLV6MGe9Xg+1Wg2O49zxfZRCocnU4fnlY+J4Pxqh2+2+rrENh0MZC7f9eoJAJ/XOuI1vRvB4JpMJBoOBdFpxuzw2grEMPsd5sizrtu/le/gZfiOx3g6PizEajVCv15W00S3HQ/breDxGo9G447WH54zvZ/C1/OxwW7M5msWrbevNpymlUzzcw9b+BO1mFf1hAM820KraYuU7DVM0PLMU9KbTi4koyURvyKJQnlbg6EINaToSTaNmlUlQhhHbAG0NgR8gjmIBCJKy9Y0aTBWP2gP3Y+fqS+jtbKBIU9gET3KlG8Q+/d1xKBRygid1x4JhF+hPQlhBhCOLTYynobQefumlbVzt+Xj/I0fx0D0LuLLZI3cIJ1ZaAkJd3BwgTXiBLZlLZB1NI7k5MClZ709lX2w9JDg360nGTQ55SseKoAdBId7zFVBVFqQOXboPalilmDltXmcfFm5HAK1SY4mAEVvpCKJMIwJRLpYbrjgT7gymWGlXcWShLq51pkbUP0HFrYkuVqNWQbPZxji1sTtiZY2tbHTH02FpmgBLvCATqGNSUiXrKafQPEVBlS8gQZ+6a2IS0j3GwvZ+XwFJ4mKjY2ccyViOdxuomhRD5xzYAmJxDCQtUefKtZUAeir6UGRXKUYYzzf1uchCU3OvMigmXGEp9ql6yglUUoxdOTuKNhafy3lMrI6QPVWCXBTPj2Ocv3IF17Z24IcR6hVXAK3h1BcNrAPJz4NWyzfWl3Ue85jHPOYxj7sN0QRKUzhWIa1eBKEKPRORb4IVaWKiQmBFT1GvkFVQiPanaWrodCy4rViKXedO67iyBURBKALkaZjA83KcvUdHxY2QZybGU1X8YpEqzVnkijEdjXBkzcP5QBm7BHmMFzemGO4NpcgUBhGiyUtYXUsQZcCxE8dw5v4Kzj99HWcevRe9nQ/Ddkysrlro7eVodBcRxF/Bc8+cx0NvfxyVxgKWu7uy+J70laYNAaJHHq8i8T+N5kKCIu9isQjRagToLHTRXljCOMjQn/aEQRFnGhYaFrzMQrVSQ61SlVzi0y/1sTUu8PIgx5I2RLvVAvJE2EgVz4FBxy4u+nMWylLopoGl4ydx6tH3YntjE8/+/u/jHd/1fuxXfwiXnv//CCjF/JHtevxhfkLZCR43kw4Roi/NbpjbkGVOyQYWSMn+EGdkuggbilXPlbJraTi64GGvaOLa3v4Bm4P5C/MxRReZOTiXQubci7CgVK6kyFH8PQOhSkDq1ta+Nxgq9Wqg0Gt5/6uBJnfToncTgHeb5+7U1ndb8XndQGflGBY7TcQwYRomOu02ussr0NwGvIWjqHSWcfThtyOYjuB8+eN4+YUXMIljDCYhCnOK02fPYhJEUoxdXDuJd/zwX8CU35Esw7FzD+LalUvYuXYJpsXPfUXaaSuehcbaEswsRcMBuqtHZEGr1kH8faMYfGOwBVYWJ8Jomjk4zl5xJ1H3Vzr2WRhajiPLdN+LDpwk+amseGRIcT3Eor5sGaYR4dyJGA+c4fJNPEcVk0vcvpUjvDJ3yGFSvFyjyzo7IUph9vLTPRiZGAy5FlGyH4ZrYune2bN3jm90YU8d5b/0l/4SnnzySfziL/6iABUEKP6X/+V/wc/8zM/g7NmziKJIQAT+5vMEi65cuYL/9t/+G37+539eQAw+RrDhX/yLf4Gf/umfxm/91m/hr/7VvyrbIrhB0Iv7IljkeZ6cWz5XqVRg27Y8x8d5PP/u3/07/PiP/zhWVlYOAC6CJ3w+CGiIZcp2+Fpul2Pi+2egyvnz53Hx4kV893d/t2ybIBWD4+e/CbjMxsW/p9OpbJ9jOfxd5Pu4PwIs//Jf/kvZNgG8d77znfiu7/oueR/Hwn2trq4KWDUDrbgv/vC9//bf/lv86I/+KFqt1gEow3HLtZJkBmoO59RqIwir1p7c9mx8s3k/vF0eK8fM9xEIPPw3x83nOUeH54XH5PtsSU9k///m3/wbOfc8hl/+5V/Gn//zf17GyPkjgMx9z74nfJ6v5bb4ej7Gbc/O27/+1/8a999/P9bW1tDv97GxsYH3v//9At7x9aLlrGny3L//9/8ef/Nv/k2ZB845n+f54HZ4fv6owKrXDkqVQohsGyv94tCoWpiyesO2r6YHn856OlBx2ZqmdJXocpYgQ5rwwmAIMLHcrmF9ZyjgBgWppQ0soJ5UhkqtgmJXMYOUQSgECCuiEXYuP404otaQ0i5qVhy4ji5OJEqUG+jWPKFHC0PHVVpQ1EaintKZk6v4va9t4JRli6bR0SOLGE2naHq2tJBd3e7Bc1xU6x52+hNkcYrlTkW0tLYHvoif740jSSqUELkaIRMIAZBygnEHEucCiAidlG17hx4vaVA3Ls6zNjW2mJUMILKlZgZwfA0TOY6RFPKarbS92G9OAOiRE0sYTnxc2R2LKDvb85aaFtp1S1VfDB2ddh1OpYaNHc6FAz/2xeGjUmvJDWyrNxb6m07nOocsImoekGWko0iYrJYC4QWkFbA/niKMyTgy4ZD6n2TCkrJoWWsQCEqRm4aAWPvTSBwMCSLxy81qKsFDWyd6PZsrHeMwxe4kPNDZmoloUdyec6LaOdU4FJOKVRT1nExr6QDCWxOTN2Gd5TleunQJFze3BRxreJaI2a/vDURcXd1sS3TxMJ19HvOYxzzmMY83YWQpnWULZMzB9EKEgqsedY2Ya3CxRl5TDqZztZqGxY6J9T263tEynuwfyjVk8hwXs+NpChqABUEI09LFjddyMsnvKlUulNRtM0lNhMkYzz37NbztiQTbO5exv3sMjY6GaRZjZ3sDjWooyfFwO4bpKTffZttDrbKL5bUGLDeDbVqIElVkZFvb1YsvSpL+xa+8iNaJB/Dy+QI0G+atm4VKsrsr3SVk6QsYTTLUuy6aC48gjUY4W6UrcYYXz/ewuNBEdX0k7oNxnOH0ogfdpCh0A2uLNVzYyXC1pwqYX1tP8FA1xHZ/G/ccayBLElmskPFE+njINh/HEs2txZVjMO0Krl38Ar78pRcwHU/x/u96G9xWHcl+X/I5glPDmPlggWmiQCrJEUXzUoZYylaoIp3GBTh0MdexDWXGkmZkqWtYqBu45y334t8+PZX3zMAo5lMs9DFnpS4qdarqFUfa/Xb2R9jeH0meSZmD3ijAJFQg1EG73q2A1KwV8A0er1fM/E7gyGFW1O0YPa/Uqvdax3x4ewIknbofy8tL2O2NUKk1kRom3FpTOjl0m/puFRQLqzj3ju/E+jOfRhil6E0jab1N6Gzuemi0F0oANEN3+Qi6S0flu+TYNr74qU9IW55TrcJx2NGQolFvo9tpYXj9AlaWFlHvLMtYVKFWRnvTnM3MitKCpkNcyH69GP6dQKdXbnVTTMCtHROx7wopgCBwpUJQgN+JUsh/JpOiF/LDQWqEcPk9EUyKgIMCHdhVI2sEzSr7TtR+2BUh3zVoaDYSNJpKh4XtiMkt7tvfjPN9u3l4+umnBXD64he/KIDLr/zKr+ArX/kKvvrVrwow9Pf+3t/D5uamABa/9mu/JiALr0Hnzp2Tf/P3f//v/12up9/7vd8r7yfAdfnyZfzmb/4m/sN/+A8y3p/7uZ/DP/yH/1DAm4WFBSwvL+Opp54S8OOv/bW/hl/6pV/C3/7bf1sACoIus2P92te+hk9+8pMyhh/+4R8WIOXd7343rl27Jsyl7/zO75SxE9B48MEHBQjhGo9jJFDyUz/1UzKGGcjD97zvfe/DF77wBdkGx8y/Cbb85b/8lw/YVQSj/tk/+2cCmnDML7zwggAuBH9efvlldDodfPazn5XX8nEyhT7zmc/I+N/73vfKPo8dO4YjR47I6zgnzWYTv/M7v4MLFy7IeL7t274Nzz//vPy9tLSEt7zlLfjyl78sryMwdPXqVfzpP/2n8YlPfELAmne9610yv8ePH5d9/qk/9acE/PmDP/gDPPLII3jmmWdkezwWztFHP/pRGf99992HD3zgA9jb2xNAiCAix/PpT38aP/IjP4LFxUWZC26bc89zQuDq4x//uPx+4IEH5HNCcI3j5Ji4DQJVfP2jjz4q4BTPJxl2/OEx8rNC4Ok973kPPv/5z0sXGueP+/qN3/gN+U0AjWDWbNwEvmbsrW913MzpuosQQCAvRHuASYQfJKITNKu48AZHtg37mqeR0kRizzsrb2yjIsBBgKBiaahXDLQbnghaR1EmABYngvakYjeq0B75IRjTrnoYX30Gw9EIe1O6nGioe66MZzBVjJuxn2Dsx9K+RrBG1wyM/FRa1yq2jmbdw/5gAsvQpIf/hSu7ePb8JkzTwanjy9LSxy/ifScXcHljH3vDQKpNQaqAOAqI705j0WiQ+SiYBPBCReCmvECWWlIzxhzb3tiCrYQBCTYp4IzimwKtlILm6t/lYQv4Qlq32r48U7b4EdQjbZcJU9Ux0XAsrPfHeHl7BNch5f4oTi568Cy6y2noDXxs7fGY2epIYXkNjufCTzUMIuWKyPZKNkvujgKMg0iE0VkFpCA5b2oE9cIkE1YVj9wwbfhxJu6GBBGVdheEQUZGGY9pGqcwebMj2p3xM6OLLldIe+mYLZ0EziiGnymBfF6EkgyX9oby++CSL0QpxTpT5sXlh5cW0ba60RDMmj3OuSM7S6HS6sa0P+jj6taOAKedKpHwHNd2esLUOtiNOG6oz6w6b3Om1DzmMY95zONNGgVd5ixoqQ49MhAHOsZDYDo2EAVAHmno7xjY37TgTwscXdHFDj4uqFWkdBrpfFXxCkyDMTZ3++j3h+L6tbQITH22TRiIQxdxTA1RYDzNMZxEWOoamAYWtncK5FqOCy9cRr1q4J6jNVRbFnQrwUNP3I/EMDCamKjXc7RaGqpVH/V6hDicwLZS1OsFTp7UsbRUQ7ub4tTZHJ2WBju/jmNrE2ztDyUHmU6mYq5z4twJGOkGmiw8NV0Ekx4su4Lle5/EZDgSoxaCUo2aDdfUYWQRvvPJNo7SeMc1cfT4Mjb2t3G8DXhGjEwzpNXu6Zcn2B+T5Q0p/rElKkhSKcL6cY5cM2F7VSRpiMtPfwZpMMbzz1/EzuYe1u6/TxhV0zRDP0gxZC4li2gyN1TnHMGmmSkOU48ZUMK/a44m+WvNMUQ6o+kZONbR8QPf/SjM409gdxRKbtipWXj/W47g537irfh//M3vwS/93e/HP/35b8f//Jffjp//sfvw9/7SO/H/+oUfwv/xv/4U/r9//yfw//659+N//4UfxL3HWsqUpyz0zUCoG2DNG1dT6m6Bp1uBpdm/bwUZbvfa24J0t2znbsZxt2NmYXX13KM4/sBj8DxHOhX42aIBD/Nxy6vBNG1Uqw3Ylo0iYXuqcteUsm2aCOuh2Wqh0W4i9KeS19oOzY9qcq43L74E07DgeRU4loWFbgtHVpfg2TqGW9fRXV6V/agWULVWOXyss4Ixx3rhch1f/OqCkr049DF5pRbG283v4dfz+7C0mGFlOcTSYoRuJ0atqpy21Rtu3s5N81e2p6ohKsCqVIY6cPEuXzlbYMjv3T0TL73k4cLLFVy8ZGN7i87tN4/x1vM963qRlcnrWDJwmx/60IcEFCHo85GPfEQAkF/4hV8QIIPsFgJWPH8vvviiADp/62/9LQESCCy9/e1vF5CCbJj19XUBYAisnDx5Ejs7O/jP//k/42/8jb8hjxHgIFjEf7/00ksClmxvbx+0DpJxdScwguPc3d2Vn7e+9a3yOrKgvv3bv13AG26PQbDo8Htm7XYEzHgsBFMIGhEk+smf/Ek88cQTAvbwOYJQBGBmnwPOB4ES/pt/EzghsEMAhvNFkIWgHVlhBGYIbBH0IR7BcRB0+zN/5s/IPBC445wwCDr9xb/4FwVU4hx87nOfw9GjR/G2t71N5p/HSOYVx/rYY48JQCiSQuV2OdcECDnfDI6d3zeOgSwoni+CQpcuXZJzdnheuA2eS46foBKPieeRsbCwIOPiPBBgIyjJuf6BH/gBAZx4DAT4ZvudMea4XwKQ/FyePn0a9957r2z7nnvukWPmtvh54Rxy25wvfmZ+93d/V8bD88/t8Bxx/g+MMt4s7XukIPOLTtcRCuuNprGAPAnd0HQD2/0AS+0Kpn6KKAJqFUsuJGzjY4/v/jBEq+6K3s9yxxOAYupHMG22ZekwS/olq0Na2deu5Tkm/V2sj+mgQl0roFV1BaRgRYg3fItgj6HQe7bu8RZL4WxeLkbTCPcfX8B+38d2b4hm1caXLu7hXQ8eUTbJSY4XLm2LZkLVc0RvqFFxcWqtIo4kV3fHeGmjj0GYyI1BtYmpChZDQCX90A2uvDrJY6IXqaph/JsgimoTK9vVDoFO6gI5a/G7cYWbOctpM00nUt9Tuu/pWGh4qMPBaBLgQhSJI+AjZ5ZwdLGOgO1xSekiV+SoVT3pm97uKUe7wjClf30aRtjojUScfKXhCehFphLBIbYBEoCiXgQ/uATK2OVKhtX+JISJXOZ3a0CqeYiClFBhsdERT5cWwCjPRYSdSS4FU6WiV7YiJgIQQmj3VwcThAmfn01HWT0q3QzV3NLymY43bDkke4wglGJHzW4Y1KiazR7b9q6sX0fF0UXEnKBofzRBzJJkucVZ4sX95hRFPKAAz2Me85jHPObx5gsW7qSARiFtGqWwVSTOUSHTINcltzGdAsgMULbkyEKGz9A8RasiTjQpHpL8EMUaFrou/NDCyeM2rl0Hui0TXiWEltlI4wiamSLJAHaRbexR89KA7zv4g6d70EIL2l6KjR3g+NEVJFoLX/hChofucWDT2TgLoOkOOs0qxmMLlpOKjo2MP4gx9HXUm214ro9OJ8FjGkGaKSqrqQizw7BRr7oIa3VUGgb83UQKmdTZuXL1MrqtZWiNJnLDg+Uwh4qx0KxgPB3B1TN0uh5qnotJGGJpCfih7nV84BEDV7Y09AcOxlddRJSlqNjYXB9iebGO7WGMQcxcJcOVnQlOreU4fnaAT3/of8fu5WdRtQuMogDXr2zh7JNPwvitz2FvkGOsFVh2ChE8X21b2O3HCDMNsUYNMLWwJauNrX08XxW6BLrMSzQ4ZoGKXeDM8TruOXscmVXBu996Hz7yhcvoVDT86LtOoWOz0Jaj3s4R+/sYD6m9o4vz2vqVDSytLcNxXXTbHaz3YyQbl/DXfvQJ/N1//jFMMlVgPWjjmy2334Dte4w7tdwdfu7VXvtqbXm32+7dLthez8JOSVZoqNRbeOgDP47+9obkq+JwHSUwvRocr9SKoatmb0u6QtiixiItC8xpmmB7axtn7n8Q1VoT/bGPMAhQb7qyD7Ie2R5Hp27LZnuSi6MnjmNpdRm71y8hGA/ROXoaplt71ePlc8sLOfwxdWdL2uKrzMVhIOm2OlyyRtLR61kIJ67SsjJzuG6CSoUaOfKisl9CacHe1IFyeAwHDK8bur+zzoyCwuYUaJeieI5uO0W3o1wwKeOSlm2Lr3Q8M20ttV4p3a5eAxhJ8IKAAtlQZNz8l//yXwSoIEOILB0CBl/60pcENJm1fv3zf/7PBaQ4c+YMfvVXf1Va+Ag8kBVDJhJBGAIiZC4R9PlX/+pfCWjysz/7s8K2IQg0a+Uj8EXghGAOWVcErLjOIzDx67/+6wKUcHsEWshg4hi4XQIfZAERrHnHO94hjCS+tt1uy3Hx80lWK8EQsrU4boI5XFtx/wRMPvzhDwvw8v3f//3SJkjQhMwdjodgG7dHxhBZRNwn54Pv5/hm2yCwQgCGY+O/CRCRQUVwjuCSgLG2fQDckMl16tQpYZax/ZH75RxxnwS8OG8/+IM/KOeVx09A6sd+7McEXJttl/PB52d6T9w338dxcJ4YBLzIUCKjiscx03riPgkMzeaJr+E4CRK5rnswb9w255QMLB4TtzNrreTxMAgo8rwRfOP5mp1XAoR8P+eJABZ/OE8E4DgPZEhxvwT3uE2+l+eJoNdzzz0nx8Lgv98UoBSBliTJhEJs6IawXdyaLW5sTHgu706EKnlkwcN4mghrquYqkfOKy6b4CkaTSNn82gbWulU8NwkEmNgeT3FiwRWtItexEE3ZTQ8BvfQ8E70qwlUpe36zQoAuahzNXkMmDy84bNE62q2KcDlvyEEYi2bV9f0JNvYn2OwH0q52fWeM00t1TMMEL1zdk/e2a64AbZ1mBatLDTz1wjVc3B5iEqWi6cSWNgIhUt1ilSsnw0u17anqweHZKqtdM0aUPD/D1UUVqUTu1Wvl//I6VbUSC2PZidIbmFWwlOi3Bp+i4eyZLjLce3wJcRQhTiI8d2kXNcfE/WfXxAGx5tpY6TZljnc2R1hqtrDen2DspyL2HaYF+tNA9hUkFCOP0Kg40mpHMfWh78vxcq55EyAbaodaB6QFt5S4es+nW2IBB3TJ00vE28EwTAS8iuguk+fwmIQKcGSgSiYVW+t2huLIJ2dypqVVwlBkUclxl+wxsqA8Ot/Q7Ud0rkqqe1nJ4XY5bsU4gzjthcFUHDx2BmP4YSx6XHKLOnwzK1tF6VpYEuHmMY95zGMe83hTBgtJk0hEKqWdXc8VqziLCoQFMMygnPTcHIEPYUh7lUwE0oPAQOCzIMT8pkCnbSGYWHjgrIZr69SN0mGIDpGOrX0d9QZQq6pWv7Oug5qTYHuPRTAHvekEJ441sH7FhuHpePnqDp6/PMXx5QSXexo1ldFtAq36NdTsFJatIw59RCGwu51ha4e5po1eb4Q6Gd6jEZxGJO1sx4/Z6A3YFmJANy04zDFra8jiEZxqiuP3Uui3jdFwA27VwHCLgFQdKysNrO9NEVOlvbAFwCroGu2NMB3FqLeAJzrM30x8KqihKAysrTUx7A1w8t5zCJ+/hDyvY6/fR16YyDQXv/Kxr+KsOxRAyqmbsALO1SYeevwB1BsOdrZC7A1THAkNfN8Ty+guLUH76lexMyLTSggu8Ew68Sn2FNlqBKIaXgHLKFBxdbztbQ/i5PE1fPazX8X2cIju8Wfxf/+578Vk+xqe+szn8NI+tWUMuLUKnIqL3b0hvEoFXs1D1fXwwtdeklat1kIH9z/4AL78+Wdw7FQAmhVPDpQLZtpSisU/+3mjxiuBSa/G0LlbkOluwKs7aU29NpFvlZbquomFE/fh3rd/AJ/57f+KhMX7MMJid1Fa8xhJEuMTv/Vh1G0L9aoj6xyuKaiZmu71MBoOcWRhFdrERzidoNHsqG4Xtn/aFtyKK90TzXYLR4+fFFfzp86/KEX99on7BGSagZG3Hv+NAryOia9jv680ee52Xl5tPsiUarZiuGYEn6561F4PDFy51lTYj7TtaTh5YgKvEhzM2017Kv8xK1irPzhGXX6HiYmNDVMAv4LLYQqdK8FaAQe8RoHuvYoUMFsm3OjIKCHbLEUaTpEMdxH2tlA9cg5WUzFf7iYIYhCAIjhC5guZMQQsCCQQ7ODfjz/+uAAVBBnYJvfBD35QGDAzkGQGHBH4oB4RNaX4PgI7fA3b6Qg+EPggKMPH/tE/+kfyeoIkBIv4GFlFM6YUW7gIxHAeuH0CRmyz43ZmgAjBIoIcBLbYBkeAjePiXM9YOtw3t/M93/M98jj3SabOrH2OYyIoxHERSOF8kMk0mxuCZAReCE4RzJlpPrE1jtsiiEWwZaaLxW1xTATxHn74YQHqOF+H2T8/8RM/IcdNTSoeL8fObc/Gw7Y6sr84hzwvBG/YmsfXECji3xzbn/tzf062x/mhdhf3wfcQgCNIyOMnGEhgcTYvPJeca55bjo1tdfzN+Jmf+RmZ37/yV/6KjIvzxnFyWwTSCJbxmMmWYlBr7C/8hb8gQBSPn8fHv8l44na4Dc4Fx0tgawaE8dyR4cZtEajjeHg8/JvsN46Hc/xHEa8ZlOIXkfoBbMcjmu9SZFrTpI2r4mXSkucQndudoOYaaFcJaBQHLV5xlMIhu6fpiGAkLwZMhNa6DfTGobBk9sYpGu1F1Ovb8CMCCDlccXWDWHVSA4EVtEkUI4hiEc/m1YbubUsNFxF7rnW2dpkIggS1qgPPYbtZgReuj7E1GGPsh3LRsy0NgzGd9hSQJo5ytoPd/hj3HGnjxUvbeP76AKMgkTY0aihkFKxkqyFzPWHXEKCi0HbpkSc3lFL7iGLv/JLTjrfsy76hoX1DhHsGaDEBPNCPEotXhbwLO4jjo5iaAGEZKhQcNXRc2h7g1EJd9s12u3uOLIrA+eWtgQhynj22LLR0Uta9ahV6AHz14i4styrnhQ54SvOqwGqrCrLKqTFB4XMRbctz1DwTw6mqPvI4r/cmiJIE7YoFxzBweZ+OfQW6FYqyQZwPiyKFpvtIcia5PJ7SKa+cJ56jSZRgfRggoKPeDTyqZIsVqJp0z9NF5JPn3TOoq6BDZ4+59IiXTLUDUXgFTvK9M5H53rAvLD5+tnjeKZh4WKvq8A12BvpJm6Wct2/SN20e85jHPOYxj29hXNqK8J8+NYCsM0qTELt0c+e9jswmQRvI4DYg+Vyu16CZOq71CvzqJyJ4DhnaGia+K4yMC9czed3+roZ6VYNnJpLwhtMcWcJkxULN5f0ZOH9xC3/xgw7FrfDJz23hoZMehn0Tp49q0B7xhNHRbnoIxhn6Qx+GsHSAmqch2PwUoKUlOFMgiicYjRLRsExTDRtXN9FqZzhx3MRwpPKN61t7OL5zAbm/jlrNQsRCYlrAMV2YVR1JMMby8kl0O21hSUHbwdWdCbY3A/TIJkkt9PZ3kecVWE5VtLgMrQqnsoUcATY3ezh+6ijOPP4WXL54FWaUY3ltVTR83GoDF7ZCWH6Kk+0cppVhsaFjr7eD3sZ10XEg66mWa1itW1g9eRb/+fkMC8YKVuvbyIIMRVhIrhSkmsx10y1wtJVjdUlHp+Xg1H33YWKs4pNffgmFP4bv2/jYb38S5y5cxvbeEJcubUmxWDNMBCyeWpZotlLmol61sbzUwskTa7h6fQfPX3weq8sLeNt73oWnvvy0yCoollR+g/HBONTC94a04LtNvBrj6W7b6l5JnPz1gFmvdQwEppZO3iufhdHUh1ONpI2P8hnc98bVi/jkJz6BH33fg+i26hiOlOgzZUyyMERvZwcn7n8E9WZHgMhZuxodI5mHt1tNVGtVLK6uot5qYfulZ6HHExx/8AE0jj9QrlFuJv7c1C5XMoSOrkzggkL7M63hu4tXEkLn9z7wTaQJOxcoE1OABBHbptET25aUxq1hKuLCgV6v1P0NYL9c3nK9ZJnQ+GKuyc0ZIYCswwSnTyZiLqU+3rJyUIq0hY5ICw86NBQ4R5BWVHWRBFMEexuIdi4jG+3DSCmeXgDLJ/BagkAK9ZIYPHcEmRgEdWbBliyZkzzH3//7f1/AiJkj3+x1M8CBQQbV4Tj8b4IsDLJrGGRl3focg0AVf2YxY/ocHjcZPgQ8yKjhemnWhsbg+GZjJOhxODhW7pdMLbYVcr+HgVuCRAw+xvfO3n87F0KCNYeDDKVZEKBjUB/qcBD84hweDm6b4yFgRYCGQBtBKAJSBKoOf1Zncz3bPp+bnTcGQR2+53bzyHN8eN+H57Vdbnf2m0ATtaQIDHKeZk6Is/1yzmefjcMxAw7vFIf3eZgN9UfBjPrmCJ3nyoFtGqWCzrcbDvb7gQAOlg7ce7SO9X0fu31fiedVHWEiTYchOuQhi80m2/948YxFCLtTdzAOYtnu2M9QMSx0uwvo9QbCrrHpPCfuC7wRqIFwHM2Ki0kUCUuLjJ/tQSDbIFhScywcWagK+HV94ONqP8D5jYG8niwi6kyx/e3i5j56kxg1z8P2YCruMmQcbewNpR2NtsGKJqp6R6nNFOdMlkq2lJbLBZ7jIUh1gKoLOKWYPHyO7WxkBd2w2ZvVINjzPJPeU3cAanbZlimsHgJTs23OdJWUAKaOpaolNNy9cYBTyy0Rnf/K+S08ef8xPHLuKKbTAOOJjyNLa9CdOq7tpajXKqiOcnz2Qh9+QqaWgTRP0a54qNhqn+LCR8F2CqtnGVqeLVazBKUIOFGwnMmPa5KemaBqmag3bDmmbWFQKRFNjpMC6GQ2cY5uVBxY+dOxN4lEW0p0s2Y3hrKgQbYVxTzZZkcgzjNpyUwXwEIAxFnMbo5k7bHdwLPUnE8mI2zu7WB7b0dAtpEfyPkqZ7/EBW+xq51VejQCrwrsnMc85jGPeczjzRbTMMfF7VC1tR+CFFjwEmMW3nlFDLiQHMqx2NIToMK2vCKR6lTV0bDapWsycHKthtiYolEt0F04hp39K2AHA9eitF3n/ToXJ7pCWu6Pr2Xo71M/Kscg2MHkvIM8q+IhuiNXgWef38H73tPG2oOGsICYw+V6jDw1RIohS5QEQJonWN/s4Tc/mWDgx9Iy16xEcOwcCx0bSeCjP9zGtY1d9LdcLHczZJEGr1JIEZEi0FKkjDIYtoOQeplFgK9tTnC0DYwHW5j41NOcokgspEWM/QFdvjy0a1wAGxhNE2RRgEff835sbj8FzcqRUEO12obpVdFqAj95ro7+ZobdrT7GsQ6nrqHtFHjuc5+T/KlTMfDwyToWGxbM1hIurD8Lp9PCI4sOtq9s4fiajiiMcXk7ER2p02suzp5Zwpl7jyHOTAwCA//6Yy+iF4X4Cw848PxIquhffjoszYeUWHqQ5ZjGOcyMBjA5xgE7A0Jxou5021hZXcbXnr+Eiy9fwePveDs+9/JEBLQFkGLRrridm9wbF5D6RgGiV3rdnQTOX892X0+Me9sAAY88h+8HwubjSaZD9yc/8mH0h0OkRhVrR45ga2sP45A6rVxnxOjtbCMNA9TbHRjlglYdAxmSHqrVihgWtTttAWwvPfsUPNvG2ff+CAyvoVY9r3RspXmTtHfSZbzsAjmcN7+WOb95bgtYTiwu62QpUrMuSRPUahFMo2zZk4vaLW2BfGxqILnswOhk0J0CRaADQx1VtrEuKdjp0CEcOFBu7zoY9G3YNh0PAd0z0D2njKf4k6UJov42JtfPI9q5Ai0YqQK4zusWdZYJZv3htVlwPUlG0RshCOLQAe/1BoGbGfh0OJQp1x+NyDbBsRkwd6fxfSvDNE1hzv1JitfVvkfmUm8ci0YQT5+hFfBcC+NpBMtwBGxaatiiHbU38EW/qdtwMfQTbOxNsdqtCDtK9IAaFsJQ2eEutKrojyNJAEgbdaotVD0Xmu/LBYLC2zMQhwwZXgD9OJEvKllDBHa6DU/2s9CoyLioZ7U78DEIEjy3wRa8RB6nrtE0SaU6VjEKEau0DEsc+K7tjYRZw3YzHqvNrIusm4ygjBJ1l1EUZOUo0GaGphNpnxFs5FJWXl8Jhjils4rgUaTTK1a9XBEJQqlWZF00IJpVT7kFmgYcjXpdmaD5bEojsGXphhz7YtPDfUc7uLozxs5wim977Aw6tV18/rkrcO0zeODkIlaX2lg7uoJaewE7UYznrgdKvBzARj8QFlnNc+DaFoY+LaAhgBKF1OUDUjLiGlWK/mmYxAnCNEGFYyYlkq45riXAk7jnUXxc19DyLDiWssCcAYlKIwqSACunPmpblWAVy7UUKdcISGkCSvG91IdyzAO594N7pBKDV3Ah3f4sakxRX4rMPd5gr17Etd19OYc8nzc5yDARN+gqUrxCsvHmqQzOYx7zmMc85nFrKNILmdhqKUZwqV1xxbQllceVGUuSkXnOpCSCOWThzsDUzkWj5sqOgbPLXXzH+57EF579JKy8ivd957fji5/+d5gEmRTokJogFyOICngwZEF59IiPYTCBVwBvuV9Hb5jg1z86xkMPmqjVC1zb2cXvfyrG+9/DImGGVAtFHoF6Lv7QgZHpqLE1J8vx1ocM3H+WxikuBsMMw1EKP1C6GZf2p3jp5R2Rc7hwScP1TQ1njqXoakB3sUC/t4tCt5BrEZJgKLIDR467cBwd9NRptHwsL1RxqumiVg/hBw6ePh/g6vYIJxZ9eIkNz7NQdy3UF9swJtfQXmhgrz9CkSbINbKQMrz1UR+XXA2DfQOLyytwKiaMNMalFy6Lw13D0fHQPSsCDFWR4n/9oWP43OefxW89vSM5ySNNC0faHobTAjmlFJwm8vYpXNtN8bu//xTWjh7D13ZjTOMCv3Wlhu86rsEcRIipqWoZUnxjPuWHLBxnUsx1TNXJQKa4H0V49vmLaHXakvs+9cxFHDl+Ei9sjMr07IbAuZKeKD9Dd3Cn+6OO16IH9UotZK8FZHqtGlR3u93Z84e1ingOd65dxP7eLjKzgiAbIKVQLzVgggBf+NQnsLa8hM29ER44dQKLy5vYfumqFIWZt+/v7WPn6kWcffv7UCkdzbhdt1pHd3kFw+EAjWYdll7gy5/4KPY21vH+H/4JLN7/9oN8+5XGrhhHBi5erWJ/K0DnHv01te29ku4XZTQmE0BLDOnCqdiZuPtR7kQ+ptqMtVS+txzRwf8zA/lGAefhBAW7JwyyAFXxX60bZu8o2WAwRBtrqUvmVCrzF2mp7C+e9DHduozJtZeQ7K9Dj8nqLIkHomXMjiGaPXGh+sb7nsxjHn98QSlNCYxTe4n/kQEURjksApsGARMIM4mCkH6UCOtmNA1RTU00KzZs3cP+KBJ72oZLWqaGisuCnAHbpNBmXao5BGxS3cOxYyews34FWhEjJLDA/zRqJeTSf09whIyocZRgdxIIm+betaZoPi20ayLoJ2MSPSheaAh8KJFwXjuu7U+wWrelUtif+jB0inpT24hjIutJl5Y+cWQrXd2ov6QcAQlUzZI6GZQAZQbb7ijmUCaCqpXsxoVYGFUiGm4I84cVD84H38KWOMbRbg17gwCmyf5wtjWyWkhwhdR2R0AWAje7Qx8Pnjwmwu/U8/ris1fwQ+99EPWqh0vXd3F8rS1tc81OB4XpoNt1sTnq46mLfXzt2gj7fg7DilC1A7n4LtUseIYCg3hDpFONzHWWidYWQTW6IC6zWsE50DWZn07NlkoJWx8JJtVsMr30g2NleyMZZorRpCyLybQjC+3GfYnzS0aUgapNYFJDVp6nw/RcVSGZtRwqHQzdUAKd7G/f2N7AhcuXEMShnMck4efmFiDrkIAhb3QHQOPshpmnpdbEN+NrNo95zGMe85jHH1GU/SkzZ9n9caBUGMvcRXIZWUwpTcaGZ2EchsgKE1GmCoK1UzVJny5cDtFp6rj83FcwGFq4vB3IfZfaRyRo8EU0sWm0KHWgwcpoeGPBMnNhLJ1caWJ/N5b84ImH2QoYYzSxUK3lSKIceaLB9Qo4TiI6VcgSGA5t3A0sgvINKZND6IYjjAkKgH/k93WsHK1iybNRW/CkvYfZQH9EkxvqZpKNnoqbVzC9hOlUQ8XU8JYzTbzr8QdguT20W3U89J63oJh+DHUDeO8ThuRUaWpg44qO9rCOCkG6dAI/fA5e3cN2bwwrUq/LixSTcArDM1Fv1gDdwrVL13D2nuPo+wlGYYFTJ9qSj7qdI/jEx76AYydXcGmrh27LQatm4MiyjaqZou5qGGc6XK+OSr2Br/zBF+E5Dp7aMyXX5eL605fZEdDE+48N0OsTdKJoMzVBeYYzaY1kXm1pLMTS5U91GUymU1xd3xYtnL39Pta39rDfnyoJCToQHyrGiYpnKWfwRtaUuh1b6vW26N3aUnZn3adXZlC90ljutI2vCzqK720ji2NEqYmQGr7+WNrvLKcG161gteVKgdlqreH0uftwbWeA4caerBd294d44WvP4Myjb4dpK5FzBoHclRNnsX75ZVkrPPXpT+HS88/hgfvO4eHv+dPQTefrGE+3nbuy8H7E0VC3v97d8I7vm7GrXml+qU9rR0iyVEwXopwC1zpqNTpt32AjzTigB9pXaivQUg04D+S+IazN4ogOs1HKqMwE/GetiOWh7vUt7O8pJ3HquelGgGz0UUw3riAf7kHjtUgaKQwUhiJPFDpZYrRYL73B56DUPObxrWVKaUUmIuKjSYiRHwkTKggTAUuY3FCnIIzpDKchinMMJrw58jKii86U23UxDTOMghyuYyhww1AMoxOLdaQJWUoFao06Ij3BUhZib/PqQU/vge1oSUkP4lSYVgSD1poUQcvhl+W/JCfwNMVGbyI98+LqQCcHei0UwChK0amSf65EvEUlin+XAlBp2TpH4MW1TNFg4k4dXRe2kdzAS9aTzI204d0I5oBi8QuV9B1cOuk6lzJJ1FB3ben53xyMhQW10KjiSLcBP0gEwGlWapgGCXrTQIC5qmNiquuIkhinF2vYGfg4e6SLqmfj2Ze38LWXNvH+t92DB06OMBpNsLy0iLQwxFo2GU3Rrjnk2kvSxnOZJAVzPJzsVFC1ycqijlQprF4msgqko24WNRZyqRiybY+gk8d+7TyFoRnojadybKZuHgA8PCa2C4iWk7CaLGwMQ+xMI3Uu5VSmokVWkZY97qNs16TmFt8rNzBlpSmVjuKGBoa4GbI9UgM2d7fxwoXziAXc4+M8X6pV8uDzW1KOlcUtn/r6JIS/KQY5j3nMYx7zmMebNXjPZV5CLcYMvF9bsrBijsP8wzI1MUJJEaNTs7Bcr8BjHpBTCFlHp65c8O5ZM7Cz/RS+/z02ojTFYPQ1rCzmWFkwSWxCEbMIpbOeA90EkjyVwo/tkDnNVV4Ox7FwfJkM8wDVqoZ2pYBuke2eoz/IgcxRLHojRqGn6PWYezE3pFwCNWWUVALbBG27QBRaIrR+6riGSaaj3TFw5Mw98PQriEPqhubotJmXMa+jDICBZs3HOEgRJTrWlqs4d98Sqs4WdlBFkcfIkSKl2UlKwxwemwbbUzpNpq0jikLkmgmvTkfiAuPhCLvjQPR5uDg1HR3HTq5Cs5fQrCdI0hCtpovLmxGOLDVRZBqeuryPxJ5iMrqEx+5bQKzbWA9cnJ9kOGLtouJqmE5ynFhrwWTeFMc4cuwoPvkMASlV7GT2+dlLGR5Y6eDU8gBbeyHGkY5ppAmImBOUSk0xkKm6BWy6UFkGpqMe8jiWfze8Ci6t72MwoeMYaVZkxzNfo1mNhmYJNjCWm8YfapvaNwpCvR5A6nbbvDXuliH2WvZ5J0Dr64W/2RJrYcJcueJKAXsy7COajFCpd/Ge970P57/0e1haXhZxc2rKvucD34Vf/U+/isG+jzgLsbWxjd2rl3DP22/aMmrtDlzPxfrlS/jql54Wgf23vPc74Ta7ZQuaMhaaOVrfPtR6hoC07atOj1ebhTvN560ufFyBRKGtnEHNHLbD1mLm8zc0PlQafzvnRaBg2+13pTBOZtBGBrL9UkxPOjJuBrBExkMz0O1kaDVpyESndA3D/U3sfukj0JMCGlthDRbALRSWw4sYyCqQ2ra4mSrGKNc585jHPL5lmlIF4oysF120oobTQKpqG/0pTtg2WlJ1o/ZSBseiPSlvypZcrMia4i7JCqp7pBqzugRppdPSQtqvdKPAyZU61neniHNAr3eRTgc3xPUO2SmILkLB6pzSJGpXbGmx2xsXaHoW1vcn6I8CXNqbYBDEJQijLrJk2DBY2SPziRa8finOzQpemuZwbAJPmvzN5I3j5XWTyR3HmpcimvL6TFWT1MVUhdJPIptMUeYF2z8AvNSF06IuVLuO3jgQmjzb9Y4vNDCZ+mhXKRjqoF23sd73BSCbhIm0SgIxgqAQIXMmT9f3xviBdz0g4MylzR4ub+zj3W85JfpLrZot4u9+LxYdraE/lSrpUqOCI50mdsc+Op4lgJRyuSsBP2F8cR4sOZ8U/SRziZU+jrXi2OIGUhWbuwIJMiXELucRogU1E1cVOKpQ4vOjKMMetcRkllQFj5pUkmiWoN5M+J3tkqLDdbjnnE6MwpIi0AVpQeAQ+v0dvHjxPKKYYvDsP2ciS1BR6WbcfPNXPeQzsGt27mY3VNVOOI95zGMe85jHmzNcS8eppQq6NRe1io66U6DjGHDqfE5VzXhPtkyusXLQ1Mu0Ndgs2xk2xkmOIqXmFFlOfYx8HXtDDdWKJsATxYCRG9CyDI5L558cmm1g4LO1xoBrGEjCHJnORSXlg1MBaciIDkMCTAY4jPFUR67l8Kwcocga6Rj7ZCsomQaCZPx7MtJRaygJCX9M6QguUhMRZh8PNbTaHvzQRZQ10NvzkaUGLNOG7RSoODRpSUAtdjK4mGvSjY4EEjoNifue8LDIHndg6AEqNeY8Osy1ApsbFVSrBSYTE1/6MtejKRa6bQxCDQlzkUzll9u7pGdPMeldx+l7bGxshDh2ooHnXx7DsQ04eoEHz0ToPlZBs0INriomvoE4cHBt3cfnv5yi7pjAiF0AOnx/guEkQfVYHVq2g7arS87sGCb8JMW//YMI3/9gHWtegYpGjc5MpCJQpAgCulyzFZNdCRamfowkjBFnPOYCx1YXkE82UTFiRLmGR1ctPLZsY8UDKlYK8tN4XPzcdE+4ohn7ZtaUuh0z5/A2Xsv+7rT91/va2znRkYlz8sn3wfzob2OzN0W9aWLz2jrCCV3RDNz36JP48u/9Jrz9faRkNoYZvv/P/hS+/MWvoD96QT7TYz/C9ZdeRBqMYbtVtYaippRXle6FF1+4IA7dRzpdHHvwyRK4ufPYb3ISLEl1+7mN83EDb3uNdLrbMatm88A1U72mIQ1zJGRKsbWY8iX7ljiELna5jrnRYlpu5UbbaSVDMdEQ/J8WdE+H/Qhb7PgdJyPwQFRWxj+e2tjeNUs5FSUxwohGGbKdPdiFBUO3oNkOCrp7slOIG6GWMElSRiFAtpTv/xA1peYxjz/u8bqYUqqFqkBbWrZSRAR2ElbcTOlbJ2hDMIrMIGolEZUJKZ7tmQIYEGSgYx5Fs6ldxNfTVY+MJ2pFkT5+ZLkmwBTtFbJaXVrdALJfhHQuFw8q6AchHQ8U8DEDnOh4V3EN0YTaGkfYn7C6NMP0Dw6hvKCxGpbD80g/1xBl/LdqGRPBR9JiTRNJKbat2gZzZLRDNgyYBE9uXAqV4F0JTElrG933ShCk3K0wgPgcj58FxDjNMA4iEQRv1ariUHi028Jeb4yqR2SerY2WgH9Fp4aCboQ2EwUDe4MJnji3ihcubmF/4uOBs2uiDRWJ8OcETzxyBo1mFZNYx3PXenAqVcSZJk6E1Mrq+5HYyDpVU8AbBfKXwB1ZSRpBHSUsznNHjllvOBYAKYgTWHRi5MRQSyqIBLBydLoYKjdCqcayQstzYpM9pWNzOFG6YOJ+YcC11LkjyDjTt+B2CEwRZCMgeLNVLOeNwFQ550WG3Z2ruHJ9A0FCdpkCoWYtedz/zA70MENqdkaUUPqNStUh3tTr+3rMYx7zmMc85vFHHKdXXPzAo225T/OG6WoFKsyk6Fxl5JILTNMEU1/pNvaGGZyqIeLCLBwmqYY0KdBuEmAqpO2NtcW9Xo4oo0W9JiAIRZgtRxPWPEXJDSuHnhvQzQTDSSaLNouC5XJ/VS13lG6AkcKfUjohk5yExSbmE7wPN6um6DiJ2LqroerqqHg6PCcTJjZ1m3VhXzEPsnBtvY+lpoVP/u4n0ZtMcXF7KrINZJu0GhYMIy9lFQrUPAOdpoWObWO7H+L6tQBmkGEwSHH+5QL1Woxuk07TzHFK12kXWDneRrXt4XvfX8F4nOE3fjNHvW5i6Fu4ct0W8Gi5qyGLx9jcsTEYUeTdxPHTNdQ+w3EPsN/TcMyqYGtHw9VQQ8ULcfxoAscr0IkzeHU6JA/hpwX6owmOL6eo1GrIxz08vqJjbwr4icpS4lSX/PZXvpjgTMfC40shdgcRKo4lzI0wS4Uhv+WbuD4EjlUzTIcprvQzHGnbSHUXzz37DP6nb1vExa0IX3m5h99aT9Ci1IZ0Pagc+aGVGs6ZKd5GhjreOHErqHFYnP1WfaZvBDB6tfhmvv6mY4KOldMPwq51sX3hWXQXFrHYbaFI6TCuod5elBXReDLF0bU1ZJ6H5vIJnLj3fly7el00falHu7O5gWDUR6VduqsxN89STAY9jIcDKTx3Om1UyZK6ZRyvCNaVsrmalcCtBSJHUtymqPtK7Kg7nwNNxM3TmMVnTdz2XC+BLWYMdNxTbK6bx6vWXrImZAeEr7o0jI4OWCy4zwCnA7E0eW2jFqNej5V5Vc6CdoEsBnqwsDkaoihcWLYHo9CRGy4Ko5C2PZooiHkpF04kIJQ/85jHPL6FmlLMJRTlm7TsKjYGQSkaHsC1KohZoZFefPWlpcsDE5cwSdGqO9LHm4WJXLjIuKLTm2mqqkCS5EjyTGlCNR0Mpon0P9uWDU2LFGhRAlNBRJHsGyKM0yhBmGVYoci5bmCj5+PizrhkZB2i9pb/E9ydrXl0mdN1OJbaMjk8eUKRc+JSpYVy+XZpFSup7xmZTezTL+mfxGZuoOxqTNy+XCopiMckgu8TirSuQBhdx/7IFyCO7KsoIgXXxMSP5cYRJtxXLGyepufAsWyMglBa7habrgjBE6R5y71H8LUX11F99DTuOb0qDCHOKYElAlGGQyZSiKfPb2Cc2iKMOU0KXN0bo+0xkVROLaKNJXh/2SwpiSTddQoBz/w4Eqc+XTMFdKw4ptwc2VZI4IktdbwJ8lyydY46EHzvTPeJ4pqtiikTophnZKcxQTZUix/nttShEnRKtMtU+yPHphS6VDce/12kIa6vX8L69g7iVAGEnN+sYDKqTvRB5aXU05hpSh18Hsq/Z+ysgwRmfm+ZxzzmMY95vFkjz9GoaDAryrWWacWz6zHCWMPeJMDIT9GfpkgyXYp4vP2zFa/t2rBY/adUAQtHuQGf+p2uh0v7YzQ9F6Mghk8m1cygy9Ck9c9PYikwSsYz8xYpc6PZazW9zI3KVjyapDC/MW0WmYAqBcg1ExVDQ71mwLAMNJqUgwCCpECjogpYtk3NywwwYoR+hL1dC8sr+6hPdNxzchkxJnj+Qow4N3Dh+lhyUDHJMTNU94F3nTXxzIURfv+zQ3z3Q2sIQg/XNmKsLSqW2TRnPkBtSh3Npg8UVYTjfdgsVKYTxLmFo4sJru8UePJxoOKRjWQgTSLce18K17EQTG2EKaTwF1CDNZgAfgOnjuWYBkAQAKOJIbb308DAqWMmgp6B/ksJtDxGqx3CMiZ43xMu3l1Q08rC2LcwDnKMJjaevkzHajrsxZgkNKsJ0Kq7aNVM2JmOl8cuzu8xz2LaZeA9xwqMEx9LCw2EuYEvXppib5Thaj/C1oSGMMDGmPmnylu56N6eRkha4ZtqwX0r4HE77ai71nb6o4jZmsNysLa6jLXrG4iiBLphwyS1kW1zbgWW7WB1ZQmDfg9ra0dgeTUcO3MfrI99DFmhujiiIMB0fwPdk/fL+3i0494uRr19cV9ybQcVryItqrcCUrN5vLXb4MYY+X1MsLLoK2fwV2lJvOPhfh1TDKhUqAfM7zydRGmiYODIagjDYCPyQVNH+f7yfbOWZa2Adb8G49EcehIj2aI7ePmhlhdyJaf0VdQaLsdwVEGvx7UNSQg50omGaKKOC4UJy8qRpdSrYgsgO2jKtaQUttkZQn2pOVNqHvP4loFS/OKL2ygTB9dBfzLG2bXmAcsmiGJ4toWd/lSsRtm2N6NGKzFqBW5Q14AXMzq8hVEGzyVoAlQcJhlKGNu2NNQ8HaFRwBRQqhzDjOlymP1EYXQmYJYtCc7lnRE2R6HQvA/8GQSI4ntVQiQAk6bE2rlNJkcENlgh0mFIfzZb86ifQFaUYt6oiy5BLB6LUbrvcbyOoVoSuW257h1m4LC9j4525fOMKMvgyXbVdgj2EeAZTQNcLnIcWWiiVrFxbWeIlW5dxLfZAunaHtZ3x6i6Fh48u4zrWwM8fM+qVA6vrO/hiYdOo+ZZOLq2hErNk0SESRXp+lGc4PzGEJndwpXeEBUKkytJrZIlpNreNEP1hhOUm0aRYnClBaI4FjYYgScCSUxiCVoFpZi4mhcyWBXYRMFN6hhw5kfTWM07GWRKEVWAIj7GbalKA+8Z1N9ilY5tedTr0mBaZEfxrKibI28YeTjApcsXsTsYlcmSYkfNbqCcS1XBKE8/2z3L52fuMvJ5IiPu4LNxyP1jjkrNYx7zmMc83qTBNvqKB/hIxCV3GmeINYhm5ziwsDlMMAxy1BxTWEWircIiEgWVUWB7HMj9e7HqoucnOFK3MPAzLNYsRGksTJoDFyvqK4UJHEPJHggANQOsmGORZcNCmUE3Xx31ioluzcaxDt2ZDbTrBmpsQXMUu1orcnhujlqN6z8TOoXSiXWRgaWTuUTpBh2WaM3kyE/swigcHFnVYVoRHCOWtr37Tzp4/jxwbctAmGTwWGU0eMwOikxHEgEjP8feKMDu1hRbO5Qo0DCcZsLKSmIDfeaSqQ8NPQTTlxVDQs8RTGwMJsztbEx95rihjK9eNdFt2jCdAMinCAMNy0cdyYFOPGDj8qUJVmwNO7sFNndjyXPadRM7eznOHbMRGh6WWzHWui5yI8SZo01YlUxa7ypOhIWOgTgmI13DA6cLjCYaBhMbW1cTDG0Xp08ew+j5K0ip4+qYqNjsZsiwPdEx0So40Y5x7vgCHnv0fnz0d/8AL+wEwppzdJV3MafT2eJYntf9IMWLe2SM4A0ddxIav9u403teD4D1jehTyWvVVmTts3TsFBYuvIRcd6RYa7rkOwK1ZgethRV5TIycyq4Ct1JX+rcsC5fCtuPt63QsEME3Frl7W9cx6A+lgF/zPDiOIznyncZ7u79VFq1hc6+Ci9e6WH747gCpu5lDYYCNC2ndoxFVwwUcJ5V8ncwpTezvvm7LpQ4WUOxWkF3IkMYZKt+VQ6/NgKtS90ouUISbymJ1DjTqMaqVQlwsqY3XSwoEkwi5TuJEJo+bXJekbAKk8zjXK2otQ1BKk7G9wb8k85jHH7f2PSLvFDJni9zOKEaj5uJ41xPXPTqvCahBO9uQDisEIDJJVlh5CkJN6MQEcVK5hiqWEkW9fY3U7FyoxwQu+AX3LAOu48K0+RivAJlyrLsNZNDwHHi2ju1hiCkreLkCmAh8zYIgioAcYuWphARFDynLxfEtMnKMwlxAEl52yP5hzFr0eAGXy95sk2X1TzGiZglaIQyqZHZxKnXZCbaRYUUdKfVe0lMT2VfM1kVLR82zMaUOQJqhU69g7JtCZ58EERYbnmhAOEksVUw6C7L9jRXQjZ0hjiw30fBsbO/s4sRj90vVzq3WxAq5P/Klajf2Q6SxjzBMYQgl1pDK4Qy7IUuJYzTEpZB6WypRNS0L05DaXrz5KWCNc8eLP/WllGiqctsrp6VkijEfZYU2LoXeNSQxtZ5mU6NummJeWLZlsgWU2+P72dpJx40Dti0K0HjaH2zj+vp15SJUngOelJtvhjM9q0PllEPMOgHEOGZqX81uZoeYVTN3vnnMYx7zmMc83mxBRjuBI4MLsVjHgqdh+ayJcKxhaV/H5IVYciGapPgx9T8LMTFhWsS8iWY1xHC4HRYeGczNmANK3iBs6LLgx/fEKR46uYCvXushTGXZJm2BLC+JgUpGJjy3nWHkJ9jcj/DcVdW6z9s82ebMB1xHMbQqFrDcttGtmzi+YuPYsoWqQ5c+wJ+oXLRRtVF3MxSLGta3IvynjwQCxnkEtwpKAGjYHejoT5jLsEBmIYpD+HqO6ztTNHO26enY2BtD+9oVDEZ1bA2GsI0EKx0Ha4s6Tq7Z4nx8fTNDb5Di2l4gRbpTC018+qkRLMvBL/1HtimGWGwZOLlKxlOKqk2ZBIhT9JmzdTz31Qgn7/XwmU9keLRdxWI3wGMPl9IJKSUnYiRRgI11jp9tgRkMP8Sp+xT7vEJh+MJGmlDXNEceaQgSFggzrHSB3lYEr2qiWnfk/Om6iR9653HYX1rHc9fpsJfiel/DsYqJldUFNKsWjp46geLlS5hGOUIuwjMDk1gVcyVPNpRhDP9+M8XdAB+3c+y7HZDySi5xd4pXcuO7+7Eq6YxH3v0duPDCc9jd2Zd8m6ATC6y6aWBxbQ1f++IfYGWxK50NDObaI5+O5bmwGTPdxKS3LXIrFOqOwwD7W9ex0xti4CewnAR7NKSiFvAdxnXnFkhKmegiQq5gzFc+3rsF6/j5q1RyUIk4jjWEEZ20TdQqfOZgAXaDITUjQJX/1luZdLzw1f6XDehLJswjgmorhpQAUmXLDNEl6Oj1DQyHJmxbfb/CSJeOHM104IikCHE95dadlmsjpUerhM7ZxlzIemIe85jHt1RTSlrzSz2e3ijGAh1aMjKKqDOVifsZXdTYgT4JUkyjGI7lYBrSiQ9YaFek2sUvOQEZ6kMRxOnvR2hVU3TrZFmRzUTtKBu2bQuYJCwkVXgrgYhSMNzURavpWm96QBHnb1XJOxi2XICokSR6VgJuqWuSgCDUxrPIkCoEFJqJoVMDi/tW7X4FokQJn3MbbBUTVg5fWIqX85WKDUUMvqS+6hyLAj8EDOOlkm1qGhBTg4GtaYYlYJ8wtGAIe6w3HEnCmLLqoRsIw0BALGpycW62doc4sdIQUO3ilS285/FzAhYy+ajVqgImJYWO3iQW2ilfRydBAjirTESLTIRFawWrj8qtkLoLHDNvbEwiKbYesIo6q4wQLLJIceUNzhANrMPMI3ldeX5Iu2cyKtsi4EUGVQn8KMaTYqxReJTPB3S8ERas0iZz6OxX3oAMprbpGOPBDi6u7yFIYlWgkCrs4SrWgYrhDeH2EiQ7TEWeCdEzZvpTs9ccBrHmMY95zGMe83izBdv0Nvtsn9fQdgzsT3O4tUQyk7UlF9/rtrHbj7Dj0xU3x/6ITBwLq40K1vtTuJZXAk583ijdbg2RSiDbfcI2vbIoxz+oJbk3iuE5NsIkEBe4zFAOvDOzEy4AWaia5V3MpRIWuA4KSTk0n39SOFjHC+uJCLEf6zg4vVqBZSSi/TkJc0z8TIp8BLmo/UmQikxupgxhQokIHeOQwuEG3CpF1XV0ah7qZHolzJ/GWFnS8UPv62AwyLCztQ1LK/DOJ47g/nv7oKSVYxOAIwu+wAPn2L6jIwwbwk7a3mPrnoNLGyF29pVr8VYvxvn1DGuXbZxYsFD1gBpZYe0Mx07o6PdzNJYSXLoQobHM+VOgnDCfyNR3CtGvMkzuK8HykmoTogaQSB3YCfxpimlsYUQt1kDHQtOCrqVYWtUwCoDlpT7CLMJ4EsHVNvHBdy/gd7+Y4cKmL3kj2fN5GmEyHKGXOgjtOs41AynIXtxLEOhKE5WlWUvPRAqCjnx/HOKV2vi+2ft5Jc2kO43nxhMKYOE35ci9j+Gn/sd/gP/t//YL2OsPxEVz1tnQ7i5hMg2wgz7ue+uatOANh33sTyOsjyLUwgTtThPT6VQK9eKInaUY9/vYHUwxDFJMijFGL76M77zwIh568l23Hf+dQSZgdSWEUYzLlrhvTu7Ma8aImyQ7ychh24BtJkrSQ1zuNIUlHbiy36IZnKcwTyeyyrVarJ5z/VWyoni9OXxM5ZBbzRRVktByft81+Hom61ObrcyyHqKsSwok7Bgpi97lnBKMIpFiZsw0j3nM41sGSqkvYxAXaFVJSQ7hmbYkBZMgxjhIMAoSLLVceTW/yPzSiosdExOrQBCEaFQrwqxJyhY2qwQLNnuBVHgotEkWi2WbcMiWEmH0DDFBkxkGIhcoCj6S1URMXQFHctEqW+1EGH3WqjVjS5FCTiCIWE+ZLBEUY1WPYMgMhGHSJJWAsvVrxrqaaVup5Grm+FACUQcAlrqhMAnIDvB5VrpmQts3bEkJNHVbdazv9AXo4r7I0uJYCO6RsLW+O4BjWfCnyr1muVVFrz/GvSe7Agy1Kg7Wt/bw9recFoq647qSfBDQJwX4het78KNMQCf+l+UxaraGUZwjyUxhKhGEEq0nTdG4efzNWhU7g3FZIWU7nrIjNknxjxJpm5Qju4Wyy5ZHYV7Rnlh6rdW54nZ5LinIzgs5309QKs6pTcV50lCxTLEklmRYNAp9THvbGE2m2NwfCRWdrLAwTkVHbBY3GFIzdxCChsZB6175Ivk1S4wPi6LfnET88UjC5jGPecxjHn/ygsyjmkvnugKpFcETiYICcZih2Yxw4qSNc6dM7PmJaBVJepPrYn++NywwnhK80LA7iqFZpgAVnkNX5VSY6WwHIjuDd8yqtACSnRFLoYn3eTowHxR5aFoyyw9mGjVlqz+TJRbFOjUH/Wl80Mo/Mz0pYg1bvQzr+1yQs63PhOfoqNsGUoPugSbWOjYWmyoPYWFuf5xgFKZIEgMnl+oidNz0bCnYJQlwaSNCc7kBdgEdX7bx5EM+oiwUFhY1MMnWolgyh0sGkehgwRb794VOhsUFDcfXCjwcAsNpHXuDAmGUYjI2sLkX4dkrMb56fghLN1GtsEWKWVIO4+kca0sWOrUc3j4LYho6TcBzlfnMdj9B5HOf1Jti+2AB29PEDZqL/jCkyzQX1hl6/QzDkYYwoHNzjsGY4vIWLq2PcPa0gy88G6DeHKFu+/jg+6q4cFXH5l6KqxshBv0Rrl69jFrVxvMx+ecVtM0MNS+Dn3J7JjLdkJbLupGhWVH5/Bs97tRm93pEzV8JULpbJtYrsbJedTyztYRuIjcsbO8PMJlOsXf9ChrdI8Keay+uCmCyszdAXJjI0hSXr65jEJNp5GGpqxy2xxHF0ZVMvW6YMEwTOVsBbRMP33sSD73rO3D2gUduGtvtgLWvE5DndYZFZPk6l87ihzoOXst8HQ6u41w3FVF3Lp6yVMMkcNDrO0gTdlUol+8zZyaoVGLV9SI7KudxpCG7pMNqGIjCHNYxE/oJ1Wo3uySFsYUr12zV0ifXMWXsRGYoW4K5fqDjONc9AkgldPqkYZO6XqmBsejOMYpt6I11xjzmMY9vDSg1DVNhsPDLW/dMJBGpjgbCOEEGA1f3JyV7qAQqUKDqUBOK/1ZMndQ24YcRKq6Dqqljfxig6llYaDhYj1Nc2R7hyEINdU85qbluBRXPQxQTjebFVbGl2ALHfuMZq4mh9nuQBx1yg1Cv48WEoAiBrLrrIGe7IYGjXGkeWDqrgrzo8UeBNBT8FPBIeu4VeVQ/SLKUIwkBFGFU8eJMam1JxCGYIx1oBO0PWDo3IA8CUqzCXdnaF+F35VqoYTgO0aw66I18dJtV9MYxhkiQJTGaFUNcZ9qaI5Rb3njIJtve7Ukm51Wq0jvOvugkYkUxwU4/xDRWrCwmn0xYizxGx7MQZTHSzBRHvZzMJaHZFwLGcV5CKoyWLZMVW4mtE1Ti69V5VXMxixnoptxulGB6nNE9kZVHldwScCSQRzAsoXaV9MDrqJhsGdBA51Ur95H6fez39rE/HCMpLNE7YAymYQk83ZyE3JSUGKJCpcQHSxBq1rrHxwhWHXZsUY6D5Q35m1Txmcc85jGPeczjWx1SFGIrm2Gi5hI0YZHPgGcX0IxU2lPETUpY7jpck4tLLsosdBpk3WSoOBqQ1LA+iIHIRvRyjq1RRNEh2DYBIV0Y3o2KjYiscjKcS80CsqvYFkhNSIYyMJnJHpTshrLjh8U4aVkLKKjNYh71SJmDMFdQ+QVZT5SE8AwdFUuXdr7jizaaFQ1HVnLUPZrnWFJMG4f87cCzCriOrvRBowS2S1c6ttPZGPYmMDVTdKOCsSnCyrUWF9kF1TCRUVmLhj0pZQ54vOSoGMhABrcJP6BweYyN9Qz9ERMqHWEyhUF3QLYHMd8z6UxMIyDmlabknVd2I3SqCd5xfwPH1lh8M4RJn6U5ui0Nad2AU7EQjgtsbriI9RBxBOzt5zCsSOag2cyx2NVw/CidrwshqewNgYUldiGMRdeKWTjHVVvMUKkP8MA5QDM1vLxOJ8UxRkMXXTvHiZaNnVEEW7dgmtT+zNCsVdDPTWxPE1SbDlZqSkP0jR53An9u58j3ats5/L4/nPHNft9ZkJ3B9c7G1UvY2dtDo1rD3u4GTpfaSZ2lVVkDUKLD930Bqh54/B1wP/SfRQ/u6GILW70BrEpd1gQM07TQXT0q2+00Kjiy3MF3ft/3weW64VC8Uivj4XnM9hxkL1nQzqhFz2st596OjUWiwnDIdZaGigC2BSwvh2Fyvcbf7JDJYdlcN8wKzDfEz7WFGPa3hdJ+avMaskGdOkVkIDjM93hOjHvPkrJgoMi51tFEw4qFfP5M8gJRlsJKVfdPkrBFN5WxzVy7CUYJi5FrDLb2lZIv85jHPL5FoBRvTONphOWuB9PPUfN48ytQr7rYEOAjlQSFbVtEnKchUWwlZk12CxOMmG5tuQIkCLxUK6RTs289F4bV+m4gNPCicMSFxavW0O60MRhPDgS4iUgT1BAXtpKFxFA6UaWOnXrgQC9I9KRITTbp7kJyMlCrWnJRV2LZZEtR9BzSY0+WEoE0ud4USv9KUakpaklgQ12cVFuhSqAOQI8ZM6p0LDzQYZrNozw7c69RVFw+x8SF4BWTF84zbyw0dohjOhhGoifVqLVlu2uLLUmK7GUHruNgodOA61VQrTegmbYIa5LRRhHLnVEgYBQTxDyhIyFBKSJ3OapmgjiJxJWPoNasxY4uM9SDUu2SKlEUjSlDiZ3P3O3UTWVWXcHNLnfMaUmBNZXDnpwvMudKofq00DBhzx40ASgNLUMNEfJJT2jIJKBt90fiwlh3TIx7oTr3r1CROACWyn3MEuBbb6j8rT5Ht7n5vp4vxzzmMY95zGMeb4BQWQnty3P0gkTYy12X+iyaMigZFMisRO7BdLIzLOqw6HANB5HmC/DD3ITOxGdXdHiugc5iA89fjzEYUvfSxR6FgPNIWEWLNa80KyFzypL8ZuboS4aSYhiUIyML2iLYQ12kVDSY98eRGOX4YSotNtIio7IRKRSuNj1ZJB5t1+BYOc4sWzh6RIOba2hYyiymRsBNdKyUvTvzOi4aud+aozSl2A5EaYP6oqhcSmsa+Q+TgQ5MdFTcBIFPhpkCn0wrRVjQxcyFYSgtH40OYFqOeifD/Q2OM0UYFNgf2Li8Djzu1HE2MtjpA+Qu9oexHK9t5qi4GhwTWG5qOL5qwnHJHqf4lAHbUQLKP/XBOioIkRtcjDMnSzAY59jtFdjcKfDiV3PsDRIxw+nUDXQ7Bi5cy3DuZIRGs0C1oaFS0cVh0XA0TCLVqXBpPcE9JyvQixhuxcCDR8dYsAtc2jYwHBcIChtNjxqr1Pq0JF/ysxybY5UHvhnidsDOYfbP7R5/rQyrb/b4Xo1NVak1hBE18ANh7LA1lZ+6Sr0FzTAwDSMMhyN5zxPvfh8eectbcP6F57G+NxRt3rXT9x4ImfNzvXryDBa7bTGi4rrFIyIrO73zOG/HmFL0A1OAnxlbaeZ8/Y3Mi4ibtxLEPrXpqCelCsndesxyt+yDTKk79TXkQx3ZloWcBlu2hmICaG11TTwYnTDRyi4JPUF/aGMysuG6XCcp4IstyZGZwiEwRXG4WIeRGwete/xSpCnJAqn8kFE1j3nM41sESvGLXLFV3z+F3gy9gOcZQtOmCDjRZOW6ovSUmJ2IkHfKtrEMsZWhVXMFmOIFLYzU6+kcR7YQtQoaVQ+dlomt/RDLLRcx3WmdqoBABInItOKFRdzzDtrmyDhSF0lWB4URVbKYxF+hvHKRHcT+eF6ErbLtjqypiq0LTZMJDPfhGbnoLflRAc+mVgHhM5Xi8cYs8NFMMHsmsHfAtlH74bXuALkvkysl6n2j5U8BbMLFFke50jtZaLa90QTLzQp0y8b+YAS9SOEYBaquKclgreJK1dMu59e2Mix0u+gsLENz6kg1E7vDsaD6O/0JpmEmLZSihUUWFChaTptlsohSaFkAS6MWhHK/QTnekEJ/nOuiFD4VVpwSKxWW1IHR4CHRd2mJUwAQmWYV21RAHbWjSrdC3lSTnAmpapFkMdXIJqjmfWTJBONJKO8fTgJUbEsAs5Efynl6rZTrw4DU7N+3CzXGWX/6myQDm8c85jGPeczjliBTKRgW8JoabCpVxiaCqBBGEyEKKdjlEczChB6yVSyXBexoGsGp6rDdHNNpDsOTJh3ouYHF5QROXcfGRo6tLWB3pHRWepMIrYolepMEmZpVE30/gWea8EwDkyITzUi2AxLkYoGK+RZb6kIKa+vM/yKstWpwNAODOEKdjHADaFdNHGu7qFepz6RhpWOj1khQMTTU6JaVOJJHNGshdoMcTkVHrcLuQrbVGIhzHcNAg2sWyEhoor5mksDQHDHbCVICdXQlUx7vcd1BELAgWCALla5pd4Vi45G0EdHFeG/PQc1rwIunciyJH8BPHNh6iofPAqYTwtQs5LkpLYSFUco25Kon0avFoodFwMwQZy9qmRYwrFgWurZlI4i42M9QpKY4GnomsFjLcWwZePJBFikt7O5qGI8MXNvOMAkyfOKLffz+l3O06jqixMD1Dc5hCs/j/g2MQ+DJRz1cuDBGuwXkiQ+vluLI8QIT30A0rmI0cjGZFBinFl7ezuHHBMrY5vTGi8OFxtcDIB3WGb3b1zNey77uvI+7F08/fuoUHnzgPnz1mRdhidabWkO0Fpdx9OhRXLi0gf39fVmftBeW8P0/9IP4NxtXMPIjnDtzHKcfeOxAeoU/jc4Sjh1dxXQ0xMrSooBeLEjf7qhe6VgLmk9VMxQLkTjS3e64Xk9wBTkamcgCSn1ocCo5XLcsIIt+r/o+qYL+gQeoAqsqGazlFEWohpJO+b3O4DRmgi6lZpd6i3JLJ0Ginom4ep4TTDYRRYocYCVkSqVi5CB0AnbXcIts3eNPmiKNI6RxjJSavfOYxzy+NaAUL5kU4h4HsVj6EuBIC4JTBDgoSKl6bdneZ7D9ilUeQ0Oc6KL94yQi0ScXANXaVUBPVP86K2lk8VCg0rF0nFqtiWicRrBJ0+F4VbRaDUzC/QMgaCa8zT+k/U5T4NSBEDovUKW+FN9jluMxDaXzNAtWsPg4WUO6UYgOQ1YYYpdMwIcte7xwqY5swClb1ma4hQh2kjGl8jz1+7DzXtnqRwcTdd9RNxSOU+jpJQbC7efSXkdghGymAjvDoVQs6xWKWWpoNio4utQWyhpBmkajCj+I0e100FpcglFpICosBOMcpuvhhZd3cXV3JHpYCgQjMFe2tVFzqUwOhcKv5fBMR8TPjfIYEwEBFVNKGG8mwcdMxOmVO6GqGKiKqLpRzPSaZG4NunOwRTFTQBXbJzVddAcFD6NSg57DjvrQ/C2M80SSYu6PldJWvSaaVgHptAEfv0XU8BCYdPjGP0tUbn397G/VE36bROCARfVavx3zmMc85jGPebwxQlyFPQMWW0y0Al5FUyALhXvZ/uJmqGmGiIZniYadqEA6jLHY0JAndBAGJhFbgzIMY8BMU5zfnmB3kmAS5Fir1LA3jIR1JR57FOxO1X245VqYxoqJ3A8zYcZzycu8sOlaaFgm+lGClsdmvwIGGeBVA0stCwt1DZnp4OiSja5JPSaCWUB7iQU8IKFBS0xuUgqjosNNKNKto2CemRTwhwmcSgWmmSMyqHElyt3i7GvR4bllwLJimHok7CQ/1JAPNQz7roBj+SiU326NbX8FxiMNg4kJwxbRS2Rxjnp1gjyNEQUGzBpz1CqCaYr+2JP3rh1J0KgnQG5CS8mOyqHbGqhiEEcJgsBAUJBxwQKrDddLYdoZotiDbk2QawlgpUjYqmTEiHyyyhy4toE8KGDYOTzdwfGVFOlyjlMnyaxnx4ElbmVxrEAuFkHT3MDQT+S9D58zBYis1w3kyZ5odImIc87CpobqUobWAnWqNIxGGc4cMTAa6whtsubwhos7MaDuBlA6zJi/9fHX6rZ3p33d7dhujZuc+8DWURf3P3g/vvbcSzCdSpnf8vPs4fS9D+D3PvUF7Owohz26xZ2+5z5061W4ho63PfkYap2lAw1Vhl2p48w9Z/Hcl78Er96GU2mUe/p64YpXBuJ0bExMXNj38E4pqr82cO9O22Xuv7AAhONMJGImvibfedvhOq5cZ5UO4DNgStZgPAKu805GwqSarcm4PtE1AqvkRCrixGx9NhuLH1gIfBOWRRZWDsdVazF2hbDbI7LIFpxJlSh5EpIzCErRNTOehgJ2z2Me8/gWtu8xqWC/7WASi0iiLnoE7OXX0W14uLA9QZQkSC1WoQi6mBjHU2HD0JKXrXcUFCcV3DENuJYpLWo+k5RRIAlHkqbSjlaltmJOXQINtc4ytje3DpzuZkCOAFwEpTKAWpAlNqJ4SOV1T+p8FMzWybYisEJQRDF7qIcVxzpO3/sQ9tdfhp4qnQHCVkyWCIbEiYZoJlBVaPBLzSgyxUg7565IAZc2vZLGqjrdSg2qnCwjkWEQUW8BSmToCqaX9yEXEXendLajDtfQp25SjG61gqqjoV2volKpyE+U0v2uQGHX4FarcBpLmOQeikmBjqH0Ewi2bfSmuLw9xNhPRRyQc0S9KM4P9Z3IViObjcBZmKQwMmozVBEVvLzPIEQF5HmOI4mu0IBL4S4CUjz3DCaxPBiK1vM8K+BOsaW4TxJ9RU5QGGw8bwVcPYPubyIcbAkASMCTLLhWo6p0FujKl9Bth4DUzZ/FW0GoGdB0u4TjcB8/P4tkaolA4aFtHbyuFJicxzzmMY95zOPNGLwdNio6LDuH5mro9VPRDUrJWvIBPctwdZoimRS4vBfi0n4kxT0W79bqHq6NI2r9wtFMTOMMi66LjUmAQjdQdW1s+7GIgmdkElAQmEwrCqBrKTxbR7dmiSnJ8a6HNE9FV9LRdTy45kkLW71Wh8kcLzHhtWx4eiqOvW2ONYxgujmqkhMZmGZkfvPvArBz5JEOPdMxNgCfDHDe+oc6ajUN08LAOIvg0gSHUgOxiaRIRVOnyEMRTjcCA0zzaPLimCmqtVQWs1Q+n+xbKBILWkHpCQOtpQQRgTVxJqZ5CllYGly7QMHXBwUce4Luoot6bSpzEKU6Bnu2uO+51RxRSHDKRuiT+u+iYMugrgtIlqZkexnCzGC+UwSOFAgLMtlTE77DvDsVjSvKTuieBV3PJff2Q2AauOS9o2KGaNVMQFMFQz1PMPU1jKf8MVG1U1TazMMMHD1SiD4pdaxYVNYspuesWCp2mWFkCsTMNSwsFuiuWKoD4E0Ur7cV7xtt2fvDcPOjOPmZex+AVvy6OICrYivzXx0nzz0Iz3Wwv7sjLnst20aj2ZJcfanbxrkHH4VBNKfsaFC5soFaswG3Wodmu6Ur+A2Q5lb22SvNSbXKLo2D5dhdxau5HnL9MB1ZSEM6u1MKpoDjlHIoUti+AUopiRR+rtXupVOm7Ds50JiS/3HVMVs4HnLtLts9ah7XOTRCIJECmEwhzuepTm3hVGReZgeozKjozpcISyqJIgTj6RyUmsc8vqXtexoEUKKIIjWWgjBW7WC8sZkGmp6l7HclQ2BrFtvFDAEVeFGR1rOGK5pJFYdAiHLO4zXBZZ9zp46hHyCgflLMi0MmelO2Q32kMdKUFSwKQ6pWMnJ4RMO6ZB2xYicKV6WgnZKzUwfK11c9Ha2ajUzjvtmXzZtujlPnHkP7xENwW0fRf/lzsMK+MK5443cSthaWwFeaI6W2QKK0rHiBI+2a4p68YSumVsnakXZCJdgnLX0U9S6ZRTPXQGo6Ebzi2KhPJa41pRYXx8Ue5oW6jWbdxULTlRsMQbJxlKDe6qDi2cjcKhKnjtisYThNkfs+TLuK3jDANIgxDGLEiYKWKLjZrFF0now1NW+eZ2PqR3KhZyLJHuosDqATQLQ8ARwJslUsCxXPwmDsC4go855nAiwSiGMbYFlAEHCK1HmyqqQfXBz/mBNS90GJzEsVF2Okwy2MBnQdLDANQtG2WFtsyo0oSNge4GMSUl9MHcPNN7Jbqy1qXstHvt4q9tBrxab6lrY+3mQYSiNsHvOYxzzmMY83Z2Spjr1hDI0tboMCWmjg+d4Uhmljox8gSBJp6/eDVETNlbmwYh14BR34Urg2GUJEYWhWUkh+YFgU19ak+Hh60cMkyWDbFtYaJpabHqqNXIpolsXCVwHLIePaRZpr8JCjRUaVDVBGaRpkMDMHZitGf6BJu+Gop8MxyVrIkBKYCnWkWgGTOUlawI4tmBZQVGIkAXNA5gUG4AJGrMEhO4gsoZoyexlPQ9RYgAsyWJ4JneOhVntioFK61rGvL05MuI0MXitGTvZYXggwRr3Tgi7RdCqOmT+RvSQNjejtFhhPgHpHQ675sDMDWRoKs34a6NCp18lXmjTpiWE4ZFWQlWWjXjXg2Ia4fLH1jlpVjplIyx/F1XWLchKZtDAqBr0Ds4hQxAnC3EOcxMizVHLlvR0bJ1dsFEaMgrqdzLksxYKibiodCTUYYltPo5kwYoE0RZaZQK4kLTQtRRqykFpKVfBxk+LOLJnORFrfuPF6waRXbk+7Oxe5uwWi7lZw/abnS2fv7uIRAUa3NtYFFJmVTtdOnEazUUM0HuPqyxfQfOJtsD1PdNMajRpqiyvQiMAeCO2qTgae14cefRiVKgXOy3XTzKn8FmDqVvbYQQdCAVS8GO1WKiDRa5nDV5p3ypl0uylSP0EQagLY+r6FIOB6iOZO09K4SsmpKOW6Urql/K0AKgXczVRvb8rsZVo1+KGNvX1X2FHUsjLlusW1Jx3X+X1JBXzSjRgmi/LS6UPyRIKUAuhxhDiKEUSKSTWPeczjW8iUootJxaFwJe9lugAOBGhc/hg6qq4h6DIZSUlmCCMpJviSs03OxHgao+baCHRWvSxM/RA1Cp2HStCy4XmwjQy+3HCJVDMZ4e00Qb1ex2gcIsmT0ipVwG+58LCfORZqtwJ3ZiYIlka7XVLATbiujky3MAkSBYQ5JtqNNpaOnMY4zFA4XdROvhX+xlehT7YFZLFiakvxAlSA7E/i8RSpJPOHN22GXMh0RU3nb247n7nfCKWLLWySeyjhzvLGwNcwaSBVnppKfFiBWwX0IkK1oqPTdNFs1dFs1lCYLjzPhdvoYnFlDfGQApwmghBoRNRoMrE9mMK1HWzsDrHZG2My9WU0jYqJNM+FQdWo2fCDRPQfioxi9Q4CiosWysaZ2lMWxQGLBIluS2W04tgCEir9KNV+SVF2JlVM2niDEyCNyZA4CFIU3hBgjGeWQJawkwTcS2EGewiGG6IRxc9PnuZYXWipHnVWPmwbF7f3MeH7b0OnPqh+HBJUP8yEulXYfKZ7RQDt1ra+GaB1s2D7GzwDm8c85jGPeczjDrE/SvHRr06RkyFQGKjbJiZxgmYdaHkehpMU04CASC7FIjKoeKPkwooAErU/WSRzawYqloa6rSPIXRxZdHFixYOhZzjdcWiTK5qitFEnk2caFbDoAuxwOzriMBIGFPUvkQK9hPbqOlpsvdMs7IxiuBlBLAORUCAKTDNNNLCu7iVYa2hoVADdyqCFdORiW54Ft06HPLbtZcjsAntBhkXHQAoFMO1NqT+Zo+k4yMICFegYj6hNyRY8HZpJJ+MMZgXiJFjzEpAM4VUM5LYyU4mmBsJURxjmko8xZ+QeTCNBrmdotJX8wwsvsi3PgVMpkMQFVhaZKVJygW17LNBxsZuhP9DRaeioN4EsSTAcUSvHkKaiNLUQsbCqpUgyHcGEoJaOaR7DJe2rSDEMMgGzCjomJzmCmG7SFlrtAqNYQ9Mx4E+Vlmo8ZM7L9DOBnlswbbYoMUdTzxOQ0rJcDIY4TmG+M4/VqRlKp0CyQ5jXGsiyN3Y+9Gr52t2ARq+F4fRataUOy0vcTk5iFrdtGyzBJObOlMF44dnnRFybLnp8fa3Rgu06SEYhPv2x38H9b3lMuXB7Hh545BHU28uHRJRKV3CaGE1DvOXxx2FXmqVG1YwrdfvxfF0ervrisLlbw4vP5fjAubI7RXt1B787zd3suTzTMehbKCIFAvP7YTsZPC9DrUqpEbXuJBHAOMSYkhY+aYmdrRFm2r4z6Eoa/UoelcBX4rp5hGBxCkQxO2cKhL6B0ZBrWGrxEpRKoZvsNlFjpBYcNaTIjIrL31k5H/OYxzy+VaCUsHso/k0NKV0sellp+/+z9x5gluRnee9buU7uPDntbM6SVhKSEEggg64Iuja2cMRgoq9tLrbBgHm4GBtj44B5jI1xBhswGDBZiCAJRZSl1WpzmBw6n1y56j7vV+d0n+ntnumZXbV2Vt9vn97uPqFOnTo9/3/V+3+/96sVdEiZInAcnK7j3HJPxBbfc9BjdxZ2uas4qPuOuKs8N4eVm+KAYXeQiufANilgcRAoy8ZYviZBlaYpmUm56cCr1FFgqRwcWYpXduFFTKsyhRKKPJLxVE66FQojliEZSWEvwT6LAgtXvsoVQA4f7Hh8ZMrGk2spR2qE/iys/Q/Caz8Nc+2MtMiVVcEoRz/MRoHquTjGKMAwhK/MSipdT3RxURTjSV1AMUss39KHRlxUpOzkV3YfpLhTVoyVJ4MuWzM7wELLx1TDx8xUA47DLjcZFqp13HLsFhw8OIf2MMfcrInza0M5Hp0gkW0tt4ci/F1abks2U8WzREi0iwxTNQe9ITvtpaj4NqKYnTcoFOWoVm2EYelOY4A6Jz/PpN3fQG5XUfE5ORgYSDe+ApZNca4c8ZnVILkEUkaZw5McKZ7kQrKjWKIpnTmKDGnQRX/pPIpkUHY1zFMszDQkRJCle1zVtPqJiFm0/o8bzG5MbpP600YFJ91zpfNrHHywdTIcVeVt9CQqnzaOR9ycizdCEFWUUhRFUW5SalUb++ZqsNlGygSOz/sYxhHWuinOrQwR546EkhumjYrrykVfmf9IZcTBwnQTsAvcdqSJhYaNqQYkKJvncpZL15SBxMolfNyCg37M8yqKPS7aYQqT53txgZl6FT1mPQUFGhUbFoWboY21HhfLDHi+iXY7w75ZB1Wxl1uYnjJkMfCQzRAZYJW5LkMXLputsNQsAfyehYhNU1IbFbqXnAIDuoNiQ6INDMuBkZq42Emlm85Mo4BfsWThKzSB4dDESlzAi3NUGSVBd5dLVxfzp9gtELBdU1wTJssUUxdJniJzGEngyrnlYMjzKODoEQuPPhXj3HmmNNFFVkHNs9Hu+mhMhWg0GWJeXguv9SngcSGT56I2hhFdTKncljN03nJQMIOTi6IOG840JK6BlUGe52EQsnNhITlh7C7G80iTXftSC4PYk3M3vg++Vlaw43GO3GbulXQEQlEww7WQC26bj+PFuV2KkL0hy6QMcWa5lfL8sOyYzSD4l+Y50dWcRy92Kd3zzyt3t/0bPZ/ceF8wcPq5Z6Tk8nOf+TQunn4OR2+7Q7bL4P1uZ4CGV8FnPvJhdFZXZJH48OH9OHbbbXBr9c1z39H2LIddx3N89jOfw5vf9vbRQu7u96fcWnlOvX+2gHMgkWufG+X5xzFDvR7DcGlAMJCmFJUKTDV4PcZxqoxKkQV8uqXGeb7jsHP5eRTsLk0dmN/G0lbW0jBbqmy8xIVyLprTERhHJrKITQYKVLwUs7McaHKJkwl43cNyW6fsKsqFdbqnpONeyu6hZdfMMltXUZQ9CzpnCVi7l0qeVMUxxUG01mOnEgt118J0zce5lR6GSY5W3ZFaeA4S01VXLKf9MJUOe8wi4EDYtVj3nqBeK08ELMtDELHOPh6Vmo3CwE2eLKWYm53BpaUVWcGTAYCDkjilRrXB9EyJcFF25wvjcpBqeaaUu9FiSXFIhrjcwh133YXLvVjq8H2HJxPAoPCwb//dUocdrJwCCi49MRNhlEPllEIUX5CDXo2uIhGiNkP3eDI2jEv5g/+n0EQnmSkrH1zdYlkbLbRljgAHVTrCKPTM1B3Mz02X1tKMrXpTHD16DI2ZOXRTG2ankPdyfqmL9R671AFhxFXPGJdXeyI68XOhM4plcQ3DEds9B1uWL3YGpfuodEXR8UTnWwHfZ55VIicrFAopFPkGSysDVJwa1vuRrEDw/fP4UXRa74QSWC7OL+ZR2FxNtOR7d5CJhZhCnosUQfsi1lYX0W73RLQ6sNBEvdaQk57BMJbViDAzEIehuK7IRmD8hihVrsZsuKN4orSROT+aZEbPnQw133BNyYPHDqrxH/aE8MXNSdC82nAVRVGUm5MHX/vl+Jn/+Vvlxeho3qSrmY4ACifSk2o014lvgJEFcsnFLrvl4iAv/DyX2ZucW8s8UVq+Oe1KhqN00i3nYm6r7DLMi0h2NrbkXIJCFfMsywxHXgCWJXd0SXOdbjw/82dxn49MG9TSeE7H2ZznCFx048W27C+dziNHtFxWyhsoIxXk3I/nYqManvG5giFNb0adlEcGFD6f+VCuBHlL0VqZfzqKhJBOwXJyyfvHrW7YhIbCF88hy8YufPzbEl7Alhe7FHP4AmXGaSkiGRYzDzYbrIy7MJfnJtbotcvzqHFnZ7ngHudfjvaryOlCH7tWSjf+WA/gY6XBz8a1Md9zeSe3W+5W+bmWEQzj6jC+Hj+n8riNuynLFnhhb7Jk8qXbge+FdOPbq3O93ezTpLh25fvK8dSTT8r5d7/XxeXzp3HijrvkM6o3Wqg2Woh6XZy6eBErly9h/sA+HDl6CJ31dQS9Llpzh67IVbUdOhw9fPITn8Gtd9+PfSfvHy34Pn//rtq12mDEWwIPQXnt8yJpMvQjLC26sDMfzXqOaoU5w8xuK91QUpUizrNRWWphw2BTAZbxcoGcIlGRwa9nMOx0lCeVbji5+BxJQp9YrGbAeeLQZWlg0HPRaZf2tChPUUSluYId5qWjnzikEjFOUJAal+1p+Z6i7HH5nmObUiK31g0xQydP00EnGODCah/H5luwHQtT9SrWB6GcQAyjBD5FCcuC63kIs0DGBVqITWTwbQNhmsOMMzSZHyWTsIHFtRwOc4rY3Y/B1KaJ5sy8uIZW19qIaJkcleqxyy4FGFnzkROPcuwJeRIjJXwGpmquCFkyIFs2aq153PfgQ2jbVbqiZYAps63KMrRu6qA1dysMWtqLs8izHmwrQ8RyQh4D5JJLwIGYzxnnR/EEjO+Ng+BMnVlT5YkE3xNPCHlaw8BznhSY0tWPAyxdVFT9y4Bw0+aqI9X4XEJGGWy+sLAPfrWGtaDAEDHy9RCX2yEytjdOYxF1+sNIjjddZMyp4muyVJErm3y93pDldyYaFQe9IIPHEzHQjVSebIkLzrfRHiQwmOfFDjphGWTfba8gSDkBsDY9FxcTnXIUpspTwVI8pNPLtWl552cC1Bx2WGxjaek8lhcXYds2ZltVsazzWezk1x8EYkXmKmDK7LAsm5iUN/3Apag0umXUyXBjkpcTrVEA+4QFeXzCu9FXZPTkybmjDDocOa4muvYpiqIoys1IrTmL5vTCaCFmvIZDV/Eon3G8rjPK4NwaG3SFMWan6bBcF9yYpbf4SDZrecYLSJMPvuKFtmS9bN3Ghp15+6vejS08byeu3Ifxy+/I+PnPfzNXnotMHp/rPVW42vM27pt80Jb3vfVzudb2Jm+/xj5vLAJueYxEUowyN1/qbM1tutZjriq6jLiWA2vy/p26+11t21uzUmXRe+J33j89PY0gCtEZDNDrdcqu2bzmqNZw3yteid//P7+OxbU2fvNC7CjzAAEAAElEQVSXfwFv/4vvkJzf97/3fbjzoS8VN894v3hOzPNwuiIHwwAf+cCHcP+XfpUIVZPNg7a+1+0ENYo77dDB00sVvIqC67hi4Rpc65izidSBhRhIhpLdxngTXklVXRtF6qEIpmFkczCMBZj2LAyLJYjsnskGBcxvY7dvZqZ1UdjLgLUG0+7BsPqAFaIweZ0kqcSjP3rmz3nSxr3qA80GayV9JHmOnK5JI5aKEulWntM0kUn5reQM0y3Fqg4+hU4DRVH2TpSifsHVIwZ596MYjZovjqjeEBhEMaq+g+lGRcSRgF9xilbVlSwjlnaNT4zGA690gEsScfpwgLBqnoQyMpuKqz3sgsD5mWJUUYG4aBiwTTErH5WHidNo5ILZ7Be3GXQnLq4qc5RCGZDnZvfhtW94E4ZwcOFyR1YFKdRwEKN1ulX1sd4fwrY81KaPwmddcXYGrgR0pxvbZukeQ9CZL0XVnqIGhRi2WA7iXMQqrmzw9ogrjBa7qrCF6KiTC9/gaEyUDigwRx3nGJKZSGYXEmCuwo57NayFBYZpgeXVvriKWDrJWmauCvDYM9ySx5WOMsdyygypNEVvGGF+qoK8sLDYDrGv5YsAyM+oUvXQ74ewXTrZmA0FNKoOltvs/AcRpkK+Fy+DLeLO6N0zGN1nlxcGv3MgltpFKWukVTaOIjTMAEVvBYvLy1hpDzHTrKLKUkKblnAGidJNzprtAqvdAdrDUBxeZKdA863nuZsLgpurjnKiMRafRid1pU33+ZuTXyfPmzfs0ipKKYqiKDc3cjY0MceN7QzjuXPsFNiq91ypfVwlQ2fiqRuah1zsb8lX2fI6G4LA+PbJ19uY/ydvf/4F87b7O+Gs3nYfthEtrszKudLVsilgXPnYTX2neEEB2jsd080frmI/ufLwXPsx13rs5N1X/AG89M6HriZs7LbM7nrK6q7mdNqtuLXTvna7HayurFzRvW1j8VXccQUGvb68BjtR/8m73439x++Uc3266C4vLWG508NDr3wFPvS+P0EY9hC2V7B0eRVrq6tIz5we5fCys6KFoN+WErQgjPDs08/i6aeeQLU2JdckvEbarnOh7/uYm6MQdOXIkBsp8kq4IZ9ufd7k+77q8d4cPGRxvrNuw8x86XLJ3DffnYfl3gfDOIksTZAnQ5h2FaY1DdNpwHRqMGxPrqPKLK5EymCRBaCDIC8iCfNnMwDDoDAVAAY7w7MVaRvI2kjigVTTZClw6XImnT2LhFUnXFznZ8PstxxxlCCh5ZSuSJsRKWwE5UlliKIoeyhKUSxhhlMSlblIQZKhWrHg2rbkF5UGaIohDFRk28wcEgvg2FhZH6JV98vBkLlKzC9IMikpY+6RdJSgup2Y4jiis2nAYO6KJy6aIk8R9ttw2CyFnfuS0tpd1g2XJuWyW0U5h1IoovOq6ZsYxmVInZEb8CwLXWYeeCaOLDRx9nJb7OEsF2QtMzOzuqYlYeBetQpn6iCqSYAkviAunjgtBbVx2RsFmbLDXoEgZu4Ca/CBJM0wO9PC3Nw8WnMLqDUaOPXEw1i6dGlU/lcG9fG98OSJriGW9Y286DBNF4z4azUbcDwPa2s9dAaJOJl47Ph4dsCRPCqppWY9tI0oLbvrsUMExRiKSueXBjg835SVBgpO89MVeC7rylkK6IlwRZGJR5Hvq1ax0RlkcJi14DL8j/ZZG46EoTtYH5aZC2Knl9BMOtBMVFnKGLXhBqtot9ew3qUzrsDB+Tqqvo3V9T4QMjDfwiAMUKUg1Y/QHcYbJXtXW87bCDjfWBbdZHJ1aXx3aYMfCZbjE4Ir8qPGLqzxHZvi1vUvgSqKoijKS5trOUm2e/z1bv+FPOaFZjruZtu7ff1rPf5G9vWlmlm5k7DyUt3fG/nbfr7YuLv3uvVvYjth8XrKBsfP43n6ufNnMOj3J8rJxj3yeK2RIwwDPPq5h3Hy9jsRPvkULi4u49knPwuvPoXhMJBMWafWwIWlFbSmp3H63Hmce+YUDu9fwLDXRTWJR6JuJlUT3B4bEERhjKHRxeknHsPtD74aBstOtvmb5/tioHez2ZRrsfEe8vap+gC3Ho8l0mPSmXfdx2R8el7kyPvLOLSvhyIdwipcTE29AZWprwLyFpD3Yfkh4KVy8VRWiwyAKGKHJFhODbbfgmHXuT4uglSRDFHkEYqCridWVTDQtny9vEiRs3lWEaGed2AYSzDcy8BUD5VKG+uDAcKIpXp8TnmNII0bKr4cC9fz4bouPN+DzcA7RVH2TpSSf5dZLmIF/5GGYTJyKpW3u66FVsPFVN/Daj9EOqqvZyePsDClO4rn2GJ9ZBBkP6fyn2DG8cX5U225GISRlLOxVK47SKXzWyq7W2YecHsUhySkexQkLmF1o34KpRjBrgwGGr6Jqbov4eZiWc0NvPbBu3HBdNHvRphpeDh+cBrnF9fR7oWoVtg+18P8dE3Cwhs5BbMa/NZ+JNFQaooZzp0xYD2liLRZ319mLkggwKgazIDfaKE+uw9zR2+XksNKpSqPy8VVNTqO7HaT5RIw6krn1qJ0LhUW/Hodtx0/iEGYiHATxrSl5vJd5gDJBihEpCrYQYUdEq2y04SUDvK1GECeF+j2h5iqV7CYpBhEuYhSAPOlTNTonApiEaj4eDlmUYDVboK5piHCFN+XY2WyijBdsTFMCqwOEsmOqNgGHAQYrl4U4bDTH8jnyU+kVXPls+b2pfNLnsuKgml7kj/G47ihF4065W3+fOXkyPc1LheUx0w4nMYd9srMBHPjvnHmw6SQtVGyN2YjKL18HCdGRVEURbmZ2eki/XqdPNfbcWy7be1mH671+N28lxspv7+aIHO117xece96j8cXgq1d117K7NTR7mp/w9s95oW8z2t1lNvOeTQ+V+33e2i315FnaZnxJd3deJ7PCo0MURSh1+vKAn2Qplju9rC43pOF9NnZWUzPFHjTW96CfYcOo9Nex6GDB/Dco58uK0nCBGefeQbzt9w70QSIZWYpzp46hZW1DgaVGJ/91Cdxxytee9V/R/w5DMMJUarsId7pe2j3XExtLCpfydXcZROPKrcWDdA/8wiGl59Ap81GBXNo1t+MyvRXweB1JqNP3DnkdoEiSSQ3yjDLcj3QPRVFiNJlhMYKvPo8TIpTVKYKGiYY1j/Ki5PQubFLk4HmdFhVYBZ1ZPECiuQONLIU3/n/BDj1zDk88blncPbMBQSDWCJqbDbncl04tguH3x0HruPKdZiiKHsoSjGPgHW0cs0urpVSGIql3rwsGasaCY7uq8rj1waJDI5pYYotcr5wJcx7mDJM04LH+3JT2viu9BJxTXHg4GskcQ7bNFGv+CJc+YYJ36+UOUzMdUpKESdj+2IKCdJxoXRrsUsLg8unGm7ZMQ8WgjDB6+8+hjuOz2HtEsvkTKx2BmjVK9g328LKWk9WDih6VHxPnGD9KEXTd+BWplGZ2oc4GCBHv3QH5Sy7G3V+kGDMURC6ZaDaaCCLGQyeozW7UAYCmmw12pGMJgaQS/8/sZkaiGMOrqVlxzAt+TINB6+8/x4cPzCFT54aiugXxGVwaJrTsVW2cJbXplAonXMyee/8TByW2LmliNMZDFFzbVSzTNxqQ+m0VyCKC9SrZdlgjUHwYYoKSxmzAnMtHyvdEOdXAhzf30DF4X7nEnDPPCkG2/u2iw5dTuEa1ttLWG/3pOsf4YrMvpmmdDrke2N4+tiVRffWSncgYuW4q8vVavCv6J43Ye0vxaXSGreRncEJf2TTF4Fw24yJsrxgHG6+zV/6jfzzUBRFUZSXNDuVj12tFOp6cnW2u/1aJWu7FWtuxIV1o86f7Rwju9nmTu9lN8Ledo+52m273d5O+7obXurC1Jid3E+T55bXKu270eO1nXtqJ5fQ5P4sLS0hDEKJDxlXeWy8Fy4yey6m7Gnc9cqH8OQTT+I1r3s95man4dYb8hhmfTEz6vDhw7jzzjsxMzOFD/3xu9Blp+20jTNnz+OVoxy5sR3Jtj0Mgqis8LAsDNtrKLjazO4CV3EHUpRqtVrjdyjn5MOwgqVlHyeY/XEdbPybGp23Z3EP3c99AGgvws0H2Defo+K/GrW5t8Nk9z0jheG4Uk6XcyGbTQV4/cDr0YJVOexaWZEu30USYbDShen04NVqZfD/uDseBapRZUR5VORqrrwO2VisZhmjg9k5H1NTLdxzz+1S6njp0jJOPXMWly6vinuKghergMTwYLMzg143KMqeilIshaI7SCLDCyBMMzimAVs68VHZL10/jRpw4mBduo6stBPJjaKIsj5MUKvmoLDdjQr0ggQ+O70lOVZ6QxxbqIkYJMJUnqBV80VgkdvgwZIOIHyNMr+Itb78jwHs41ItftU8A82aC993mSiEJItxfGEKr7//VnFgOXkK3wJSmw6iAPWqj4P7prG01EEYxrJSMT9Vw+XVLqqeDdNwYdfmUZsejEIgWYvMzguTbUAzKS3kwNRsNeBXD8D3XFi2I6WEYRzAzDMwdoktd5MCkkclk8+opemoryhM08bswn58ySvvRyVZwlJ3BRXXwnI7ELGq5tvAsJDjT5FLbMAsf2QHGsngKsOS4rAss+PjKOYNwwzTTeZrpQjjVLKujCiTHC+KXhWKRv0IzYYjA/1c0+PRxoWVIY7vr0M++SJH1bMwDBMY2QDorWBtrYvLa33JEHPMAvNTVVQ9B0PagwM6xFyZOFkCmBUGFts9+cwlflwEpWsz7opTTuicNLgrDMPfkJnKYzjKf2Adfsl4phmV5o077BQTaldx852AKYqiKMoLYbfz3bUCpG/USXU9+7DTc16Iw+jF2s5223qxzyWuJnK8GG6xm5FrHfOr/X4tkXHyb3qnY7+Tk/Ba/154PsoMqeWly8goCG0IR+U2ymwnXg6Ycl5/8uSt8Nyq3H7gwALqjQbiOMJwOMT62qosTHMx3XEsOLYtFSTMm2LXxHzj2qDcH7dawz0PvQYXz57HIIqwungZaRzA9mtX7MPW90zXFrclTYUExnsUmJ1hV0s2hbr2v6FtBVYu9Z95DPnlZ+EUFpIixVr7Dpy49xtgMsQ8H8CwasgZ65Rlcm6f5wwnhwSR89olTw3qUUBuIxMFykUeB7CMLmzPhSnXjjQtjHONpeBQok9KYYxXtWbZwY8bytJRtUkmWcCNehWNu2/HydtOoNPp4vLlFVy+tIKV5XWpGGLW8hfLvzlFecmIUnTiSHvcUaxd1bWkfCxhZ7mRayiM6aYqUK9l2DddhW2GuLASwqu5qHomeoNIMqTSPMVM05PcI2YrzdV9cejQ/ZRkFLoYykeXTYGGWwZu00HE12eLYgmfGzli+HwOlNwHOokYXD7TqmHAcreCAlUFX/fmV6Nx8Cg+9ExHRCHmYLGzQ5Al6PQGMtge2DeDS8trEtJeMy0pcaPQwhpi2A24jX2osGseVuHlQDjsSwtliiOFw0kkh5fTqVXg0Ik7gGgg5W2Sl5QncJj7ZLOcsQx959CeSyvVUkzjRMLStmarhbvuuh3Hjx/EM49cxEA6EQJzzQpWexFs2xAhKQ0YGM5JonSIsfsgM6Uqri1109w+hS9piJoXWBvEkh3F51KUYibY+iDDif1TUh443bDQqLkYDumYsmQVYqbmYLUXoztIMNsQtUvqr4fdZVy4vCylhb1hgkBKJE3sn6khiRL08xR9rgDRpZbmcBwb/TjBSmeAOBlbfUeC1ORCzjZz2uREL6WZFClF0GOnPmvziWOBqezVvCWMdHMyHK/RlALWpng1dm0piqIoysuVnS6YrzcX52p8vi7SdrPdFyp07YbrdSi9GI95scsXd3rsS6WUcCeu5oa61u1XK+PbDduV4+0kZO10P0/o19dX0et3xe20dRc28lNHcSRZGiMIBqj4vkSgpHEC9gzvdjrodTswDUvOi1kxcXC6hfbiCnpBiP0LsyJO8fphMsT88ImTWJibxtLKGs5fuoD3/s5v4LVv+b9Qa03LNZmcJ2/pxkcRjcJUpVIp9xEGZmfZhS5EJorQ7saPK4U7XhqFiC6fhh3GyHOKSyH2HXg1vNpBIIlhmhUUuSm5wlIVUdhiNuBVBK9/sthEnjAQHjBYXlf1YbBCIx+giBZF9CrjOcZr0axIGWfN8nd2A2fkB4U1vp8BTM8fiVgGrGGELInh+jW5Jp1xXTSmmrj1jlsQRTFWlldx+dIyXO/G+ocpinKDohT/gco/7yLfcCVRVKEoMrasUDChGtIfZIhiSNc1dlVr9xlmXWAYR5hxOKiVjpY0S0SAOravLnXVvusjCctyMnblC8IMdoVZSWX+kiAh4WVdMB1EFKOsctSV8rlms44op7hVwHcdPHTXcdxz71341KkOIopZLDYsgJkaywULKQ/sDoaSF3XkwBwuLq4hjGPUKg7WOwE825NueK5bh9ecl32n2MJViDRJRNDyDBMVup+YHVWrwvWq8JtNpIYl23dzBoeb4pTiPpYlZOzgNxbUDMw0Kjg8P4VDJ47h5Imj8O1CxCPm63HAZRA6O+cxr6lZd1AvCqz1QnH+SOcMyZAyECaZlB1WfQODKIVnW/I+KUKtdgMcnqtKZwoe68VuiMIw4dk2Lq9FODTrA76NJM7gijGtEDFqyJK79gCuGeP0hcu4tNJFxXOxPohFxKPYtn+qjiTLsTYMsW+6gUrhoN0PEacWaMsaxGUXxnJimJiFN9Sj0UnCxARersps2q5ZFsiDsdFhz9hSpy8OqfHJxkTp+MZjyteb9GeVLrXRa4joqiiKoig3PzsFM++2tG7MtS7ed5OzdL0Cyo1kN12P++uFbPN6BbwbyWq6XsfVi3nsbxauR3gal/BdjzC13ed8tTD8a32X10eOpaVFcThxYX/7EkPx/4uolEQhhv0ueHnFzURxJILM+vq6uKWYaWTbFnoUutbXxAPEq5RLFy7gnjiGaXGh2hLjAM+poyCEW2viwpPP4ZaTt+AP/+gP0A5D/F//9zeiVm9srPNuPS58rbEoxfvPnrNx6ZKPBw6Pz7t3J0iNf5YjkSXIB31kbEgVJ4jjEM6BO+VcXqJyTbtc+C9YEVOKSrzO4bUnG2txH9neyaq4cFo1FNKEKoMRMRimrMiQtzFqMFVWaIz/XUluiuy5GAziAQzTg2FVyusPCzCdCDkvZi1HSvXMLJEmT+yk7lYqqDVqOHr8iJROKoqyl06plCVrmWQQUa2HRZeSIQIGb2cIXiytMksxgWIFS+0aVRuew45xBdKCZWMpltoJZhpVeI4pHeXqdP4UlggnnmtIaHhi5iiyAgE7KzDQ23ZFgKIgISHhozApDigUvJgj5boOXK+CyysdeJ6FAwtz+Ko3vwEXe8CZ5R58xy6dQywLRI7pWhncx6wjlppdSpZx5NBBnL20jCRleaEl7iOPg5BVgeUZcBvlSoLtVsT2mkikli8Df5aEcPyaDGZx4cn7c61Q9o/14XIcWAvNKWMUdk6m6z6OLzRx59F5zB05gIWZJhB2sNyjs4z7QFcUs5lMEako2LGMLohtcZG5DH6n4Cblj0AinfJMdIe5dN2jpbezNpTXmgoTzLU8DKMC0zUHne4A9QpL9gqsdmMszHiyb/y8ebwsM0MQDrG8toooCnF2sYM0Z/fFEGGcyPYPztYRJfzbyLEw3UC96knpIx1ri6sDrPRp/R0XzI+MTaNloLHYuKWS7nknZFzBKcWjje7OmyV7dKONA8vl/klhasMbtTnRjsWs8QnJ2G49El0VRVEU5WbnRsWH3YooN+qqebG3+WKKLLsVwyYFi90KSC91Meil7pK6HmFqOzFqO2FqN4603YhSW2/fKZ+JpXft9XbZlGf0+jznLn/eLAXjOTMFljAIREjKKlVxDNG1FEfcxrq4l8bnrg9//KOwXB9guVoc49TZ81g8+xya+w5KJQq3xU1fXlnDY6fOw/KqiDJgdt8hvOeP34swBf7SX/vrsG13W0EuCILN0kSez+c2Oh1m8MrejioXdlO+OK5aYKli2TgLYYg8iJEygqXSFIGqXIM2kGfSIWpUzTAhMpVFEbDYCW+mIYKUxHrwbD+PYZhlk6xxxEe57szHlJUR3F++tsHrhyRCEgRw61Mo+HpS6mfDcnzE/R4M25EvcZzZDiybsShAwayrjLnAGnSuKHubKWWW2UUsSeNgQ2GEDpmqbyOOyxppBmzznzMdMRQRmM+UpiZqvgPTYPmfhWGUoOI6SNJUSrk4ODAkveY58NiZDRS4bHEB0XnVqrIrXyKOnjLXqhwQ6TySgZYDjXTCM1CtVhEmOUzbkkHvnjtPYv/BA3j/ex4RVZz7xRUFcTtRmHIKTNc9ycLqBrG4q06fu4CDB/ZhcWUdScIQvRyplAgaMG0XRmWqdGd5VRn4erGJwqTww30o6xgZpO66BsKIr2fD9tk21Jf7mcsl5XYGBSoO3pa4mSjuMAuLgt/MVA3dxaewtB6gyCkOWRgEiXTuozAVhrnkeDEcfrVbCj4sn+NKCvOahnEmZYyzzYpkd8ltaQ4rpCjI8kkO/OXKSRTnEgRfdU0sd2PUap7sI0Wutc46VlfXsNYL5PPGqBSQIhlHeH6uraovAecUpLgPFBTp8OLntLzaR3sQSgW35EdtlNWNhaJRav6Gv4mT1eZEuOmQkhCpjb/FMkOqrG0vJ5grgqE2fiwn64nbNzLANja0+cpjserKdHRFURRFuem53pDvF+txLwV2I7J9Pt7Pi5V5dSPbvN5Q+ZuJa5Xq7SREXU2cutp2x1wtW2q3ofxraytI02Qin6lkLBqVP5fxHGkSIxgMRMhikC0NACwnG/S76He7Ik5Zhok4ivHsqTMIDBf16Vksr6+jse8gBnRSDQdl5m/K6pMAa70h8kpDMnQvr7XRjGMcPXkSvX4fg8EAzZY7UcCwWYYYx7Fsg9c0XEyuVEJMt0LkRXltcLXjuBOm48NqzCI+expZEADVOgrbRZEmMCy77JY3arAlyRzyPZd4EQpKzIiya1XkUhFSVmLwGpJ5uHQHSKnfaEWaVgSW6uU53U6OlAtK0HoSIu11YLAqxvSQhYG8X+YYF2aEXDr9lZm/vIalAcGwKYhJqYu0pt/6WSqK8nkWpdhlj4I25WnTNiVkm+OOdH+jICJd8cpBlblJLKnjbWGUyT9Y1+U/5rK73HBYKu4UUyhkUZSiJdKOIgkGp6BB11SnE8N1HOnEx9plcdiIOLbZ2tMySxGDXxR+OgN2s2DwXw0P3H0rHj+3hqV2IFlLDK+jaMKgdMu0EMccTAo0K47YZEVwSRKcu3gZh/bvQ44eev2B7J/veoizsh4ZlgWH7iizQLVwMIxyxAzHowBlGGgPYjjJUNxgacLdtOFVqvBcS8Q42k/HNdVJmovIw4HTLWOzYEZ9dJaXsdyLpbY5T3MRgAYRB9tCRLsoZhvZHDMNT0LQy9I0HmeKdZCyQQpTU3UH7UGK2TrFPYpSGQLmVI3ywaquIYMsu/I1q7Y4mw7P+1hZWcFau431zhBRlstnyiwufmasQGTnQjrjVrtDeS/Nqic17RQP+RnUfBfr/VAEsfJzMuDzPQRRKQCNnU3COOup1IjGhXyb4lQpSJXNMTaS4UcnFaOnjbZZrhlNuKAmTw5GZX+TDqnRk8a2q2takBVFURTlZuCFCBOfj7K5az3281myd72PvR5eLJfUjbz/F6vE8GZkp7K9a31tOpOur5xvp9efdAZNvsbkl5SaZRnW11ZgWay4KEUXPpeCFEWS8WPL7TAziQJUX8QgkwHmaRnuvba6gk67jV6vjzTJsLi0hEHCheQuBmGMfpyjHwQwXE86lzMPiddf478JLoZzHyqVKuq1Khb2LWBqegaNRmvj/HirkMt9Zxe+er0u5YG1aoGjh5hA/nzhbldOSDkft1A5civ6n/0EclbFeB6yaCiOMMPxgYxOJC5Km+JIynmNKaV+afkzo2R8d9SAq8w6KbKorJ6Q0hpek/B981deS6XioOI1GN8PVS7eFg968GcOIUniMiKELite34p46JTXHWOHl5gvKG/xZlYN5aU4pSjK3olS44EkH4tJ/Ac/uqYf9VKTDmsUWegqogghXeHA7nMpvJGJsuJSGHIQJ8wtYvlZKgPmei9Af2iJS8d3LXi+jWE7QGcQoekbSKKgfH0RzsvXozDGcjbXMiSYnMJO2Qkwx8H982hNTeN3/ugRXG5TIPLR8B3JT6Krx7IgDqR4lPfUqnpY77PDHZ1eKS4tXsbM1Aw8x0W700YimVcugiAC+00UDEO3LdiGiZZnyX5SjKlXfHiejwtrLHMrMN/ykecmHK8m+8jVCduiiEUBjEJfqdbzcGZJKt0AO4tnsdYJxCFmOSNH0MiZNAwjOeyl46q8fbZVwdLaEGbFlLUAVlcaOfOsUjR8G65tYH/Lx6oVixEoCHnMKV4Z8B2gaplIYg7mMYbREI891UdvEMDzHKwPEgwogPFzziP5FNmdME7KyahW9dDpD0WU2zdbQxQl8JgNNlrF4ETILo38G6GbbiwwbQpS5R/RZjD5lvr90ng76pwxmhg2Jv7SaSXaU3kwUBhlRw0Jj9/Y/riD3+TrTZbxldHzo0feyD8PRVEURblpud6MpN1evH+hHFqfL0Hmxd7u56ME8nof/3IWr64lSO0kTo1/3kkovJogNilGUfwY/zwODC8znsryPZ6LS4D3xvNG37MESTAU0YQL6o1GHc1GQ5pOFaxMMG1U/Apmplo4cfgwarU6PvvZRyTT1nEczM3NYGZun+RAySK0iF90HckVDDzXw+zMDPbtW0Brakp+n3zP24madFLVauzUB6ys2zh3to5XnxhlM+2iA98V99NkUAD1g7diZd9hJJ1VFOEQSW8dZsGYE9qReP3E1XpHztMpRKUiSJWiVE43k2RTFRvvq0gDmLIzFJPsUQZteX5P8Y9RMFIeSCcWI2l6a7C8CpIkhGV74k4rr6QKZEEfBp1b3FkRC8t4GlZ+8JiWTdPtl/W/H0V5SYpSLp1MpokwTUX4MTzApvAkgoAhpXYMf2N5HwUXupnoeOK/ZVH5R0IVq+eqFFeknIuB2w5SDswcoOkc4gBOgxAK6TjXDRLUbQNJyBA6Dt6lo4kDFAUIBodTSKLaH4zCtBu1Kl7z4D34+JMXsM7uCXkhZWwUwlo1T0rlZOA3Uvg23Ut0/7DM0ENnGEqeEu2ul1dWMTs1hbmZaay324jiGH7Fw2AYozDoGLPL1qIFw9k9GZS7gxBV38VMvYLF9kAcYzM1C6ZXkcwrCYNPIRlb0oiOGVyMTmdnQeZSRQHCYB0XuoWsfFRMTkjM5KIoRvHNEvcRBfqMutBIsW/VXXFosZzSplDHVHWGE4aJHDd2LWTulpTWGTnqOQd8ICsMBMMuVtfXMQgCdHshPN9DbxjjcidAGGfyGVPx43GmG4rlfHxyteKL84mfLW9fXOuJGETbrDjWCn7muZhp+RnQpXbF6tJEPOJGTOJEeHnJppuqdDlx8iu9vDJpTq7SjCfSLWV64/r1KxxUG1vdnFA5e71c7O2KoiiKspUbuYC63ufs9PhJZ8lun3+t5+x237ZztdzI6+203Wvt01Zx40aD0l/IY673sTfDxfZ24tDWn8e/b71/t8LU1ba1nSC1nVOKXwzy5n0UpRhVUf68ufA8+ZVlVunmZ3WCZaFaraA5NSUle7Zly+906DSaTcwvzGN6YZ+U63W6fXFAHT5yWK6L+FwRUEYLub1OF9FwsLHN6ZlpuK6/qxJXhp1LkLhhwnYq6PcHz69OuJ7xgMvBfhXzX/IWnD77LOLuGsL2CtyqL24oK68gS+iS4v5TVONxGTnPUjqZMtjMupK8WLrOeHEVSO88uZExMkVWluulZUlfxsVxakx0nQV9pHEEpz4jAlU4XCtFqyyVBXUea6c5U76/0aJ3mWXFnOMyCmaizkNRlL0SpUrXUw7fMdFnTlFqwGD3O6rvzF2isGNZouJXGBBOdw0ziNJcXFUs7cvFXUXrKFCveAhDhvSJBacUhjh4UvXm4EGXjVmg4tvo99cRBmVQNx1OZsqBppAgdIpgFHtMx0E8jEVQuf+OE1g4cAj/6z2fk7Izz7UleD1JLXFFsXyPms24owNznHIjk1JBwnwpCmvcv6WVFdTrXHmwSmtnEqFec+UY9IcRfJYFGhYGYSSC0XSjgk4/KPeJpXzDGK5lo1Wpo1pvyEpDzkTBUZ0ahToO8DyODD4P+300vAzLAbDSjXFgtnQ6cVCnoFTxXdgMO0xpMWUL1bI8jsHnObhfMSqeLVZXlhJadK+x9DJj9z5fXFLMzsqYx5XFWLq8hk6vL+8lTFJxb2GYwGG54iAuj7N0DKEAyBWL0eAMQ1xbY0lpwNUfdgthd0baYxnubhuYbdSljK/Lsr2R+iQi0YQwdSVbusSMYwpHNd1Fxr+r0qZbhqVvBpuXJX8bP442tZGsvvG4cblnadraLKXcKFxXFEVRlC8CbkQkGT9+N5k7L3S/vti4kfe9W9Hq5XRMr/VeJt0+k993u92dnFBbv1+tPHDslBqXvzGXaaMD9ChOosxM3boPObI0Rq/dkSoNyThiFUm1Wrr6C1ZLlOHaFIlsx0a1UsNUq4XFxSXJn+K1DqtJxue7Y6dUr9PGcNCH4zqoN2pwHG/nTKTJYwBWojBonQvlrL5IgH3RVc+Zt5Y1Pt91xmsBoHH4Vix8xdvxzO/8IoarSzDMOSAMYJsJstACEp6vj0QpNn5i5AnDz+0QVr0KBuqWpZAxrGSAzHVkh01mzkq4OQ9JIhlWacrrTlu6p2fhEHatBViuZAQXaQaz4kvJHx1TNFR4fr2sCKIYJ9ewZfTHuFJl62enKMoeBZ3ziy6lqZqHYczQvARVzx0pxhSm0o3uBizlY4i2dIQbdciToThLJHvJMHKxmMYpB08bQZIiiSMRiDjg8R97MureF62tIwjjcpCXVypDs3NmTRXMxquhz/thYN9sA2/8klfig4+cRTfgYM7XTqUbHYWY9X4kQtl0zZdOf2ESo8qQddsUAWuq6ss+dIYxhix1izO0e8OyVDAtJLOJA2vNtyV8fBjGEtzOfe4NYnEjzbaqWO0MRByiSLRuAU7Vg9+aR6W7DpPd6DYylcpQdtaLc5DEsAcaoIZxId36Lq8NcXi+Lj9z/9klsFZhSN/mKkvZNc6QsHg6o9iRr+aylrp8DF1YdCvxFetVW8ob2/0ulleW0e0Py1prvtckR8oya75OEkoJXhkSWD43GdW6exOhgnSVSakmc+zphDNM7J9ryOfFsHs6tqTDXmlF2pIltTnpbbuyWD5gIxdKJp3xczY2t7Xgb+LZ4/DyiUdsOKMkk2zLycXoREHnGEVRFEW5tuvpao/Z7rEv5j7slp3Es8+XSLPdBfhO3dhuJA9sa7e33XIzOJ92y42IbJOfyQvtmLiTe2qrU2osSLFs79Rzz8B1bPi+P2rQZJWdpSf3cbStwaCHII5RqTdg+1Wpami3u3Kd4PoV1FsGbL8C1/Owvt5FJc7E+URhShpTZRnW1tYkmJyNlUgUsoGUhampFmq1KsLhAMtLl8rMqVE54WQna4nCkGs/C9VaXUoIGW9isdu5mcC3E9ZBXNUrdPW/udHVgGli4YE3wKhUcPGPfx7W6jK1N1gIYSQ+Col64rVl2aQqy8rveRHAXGUDKk8qHUwzglFEyCX7t1zANl13VFlRZndJoyue/2epZAk7fh1pshmcnnCB3a+iCPoS02Kwo6GsWWewXLe8njHK6xq+tdFlkaIoe5optaEflAMMRRL+wx5GEXzPlTK68URJt5Rn2iIE9QKKPqxVZn5S6eqRHaCTxuVjy45rInRIbXUpMvAfu0V3UjBEe3lRnstSMjqqRLBijp1IVCwXBMIkw/Ej+/Hm1z6IfubhifNtWVmgkEPXEwPRGabO7n8UVyieTZulDXMYFfAdV4Qnlu1VHAtFhR0Cs1HIO7tglCMP1fnSeZSj4jno9WOESESEo9DG0POGWWCq7gPMmerT1WSjF5nwvWnUmjOw1vrICg6I5eF0nLJ7nwTvJQk63QSdviWljdz3i2sBjs1X4TomgigT1xcdWgwnz83N0HcO8HzdpQ4zngzJ2uL7t2xDxDRungGCeRrgwtIywihBP6QoyMZ0BWwOwMhlQO8OS+FsLNGIuDiayBmWLn0sKLZZJhamm1jt9iVnaqZZQ6c3RKtWQW8YyvunUDYOFR8LUuWmn1/Gx9vEFSWf7UR5H51RpUd3c/Vm429l8+RiHFUuryO/UJwbua1GXfvGQZJjse0KkWxHkUtRFEVRXr5cTfS4mgi1Xf7Mds/b7rl7ydVe+0YcYy+mqHW1zKLr+Syu5zEvB2fVFed/O+zzTiLk1Y7dTg6rnUoAt/7+/BK+8npi8dIFBMOhnFPzfJT6Ca9NuDg8jqgYO5fYIGp2tiWnquzA98wTj8l1DeNOqjUPfsWRqojTzz0Fwypzquanm3Lu21tfQXtlsex6Lc2GuKBuSnpqveahyGM899RjoyqCMsB7LF6VDq9Ucm754uxEd8vtd+C2O+4QUcsoLCz1XXz6whS+9EEplrviXPxq5avbfk6i85hoHbkFD6frmB86IiblSQQbDDz3UGQMH7eAnOfwFKVKYapot+EaTTmPt6wBbDsTwYluMXFJ8XOgW42L80mZJSUlfGkM03JRsJVewaqPslufxH+w1LK7CrsxIyV/YPC6XJ+W3f8Y3SKFFZIqoivZirL3Tilj1LVBFOdSA3HtzbA+uo9syxmJSmWHPDpo6CLiv146aqRMrqC7ZiSixGlZ2sdSMxkwy/I/ySUaCSHRoI1BfyCla3RF0X1V+mXKeHXW/dKN5Hku7rvzNtx/5634vY8/J+6nMIrLjp3iAspQZRdAurpMQ0rKhnEiAedN35KysyRix0CKbZDcKdR9LHf64qKiE4swl4rh3iJ4RTGckfAmDUeZiQWgM4zQrLpoVGz0ArcUkSwXQ7eCamMWtn2JHiPpaNhwKe9wH02YTkVcZ3ScscKPbrRG1UFnkODSWoDDc/VSjEpoA05FFGOmEz8XimQs/+MAydys/pCuLU+ErjQqrbxFEqPf76Pd6YhYRScUuw0ORiIXjyUdYiwNLLWfzUDwjRDD0UQicVgUvIwCQRzJ9li3zc+HCz90wHFFiGHrk+P1WICa/F0mqPFvMlnxEy5XI0o9aWyL4qR+9ZOK8ndO9qOTibEIRivvSPSU32UZaLJ7X/knuSWlSlEURVFuSnYjTLxU3TMvZL9eqCDzQnkhTqzPR4j8Fxs7iXjX61bbuo0rn7dZgraTGDV5G8WOg4cO47Of/SwunD+Hubk5nD59BinFnzSV8/4gKDNtc15nURiisDJRZbDh/B+5mPiYDVFMIpTovqK4VD6G5//cBuHtpfBVnvByoX+cBsXHMz6l4vmo1Wuo+D5cj53PbdnPL33Tm1CtT6Feb4nLK46ZlZviwUMssRtVMFxDnN7pOI6vCSTuJRkiNh9HL2+hPjwmJXdh2Gf7JlhmBQZbZhWsFLFGopSBpNOVTHOr4kr5HheiWUlicNXfLMVAXrey8zsvQMvjlolYx856WRCU1y/jJWnHQxoOkIQB/ANNuZXHyqZINqrWKM1SZSmfVvApyhdAlKKYxH+Qo+xyEZ042DGHif+4KfykeVYOiCbFCpa7sUOEWbqPPFdsp6x9TuJMBjwZtGkFlbykBL7vSmkZA9KlW1qRIxj0ROBgaRm3J64n7kQZRSWqNx1N99xxGHffchQr7QGevbCGvDAlS4piVlk+Bsl94n5Q2OYwPYwypGkgNdKtmi+P80e2VQ5gdBrtm6pLxlTEnCsRLnIMg0gyphhozmPguaZ0yuP+R0ksKxeUNuhsmq55WGwP5T30QhO+04BleYiSgRxTZjhFORAWNk5dXoPn9nDg4CG0k7C0mWalyMTufovtEPunKvDp+AppmzWkQx5zojip8PiYloG6y3poG8MgQY2CW56j3+tJWHsQcHWgFP943GjtpW1VBL+Irq7x+5e6xzKIkBPWaA6ZdBWxXJAlihTl+LmXx6jAgdkGar4rpY18jdJxtelsmqxTHzvvDLaxGL1CeRPXc0oRdPz47WrTJ9kUtyZdU+MZg4KdJU6xstxxNA0yp0qMU6N90nM8RVEU5WXEi11edy3R53oDj6+1zRvNvdrN62597d26vra6yXZy01zt9Xd63NbtbrdPuwmLvxmcTnvBjR677VxYm7eVjv6rlfddIVDlZU5tr9eX57bbHayurYkgJSV+Rdl5j48rM4tYnlY2CZJu0lLmt6FMla6qiYwj3k5hybJHjic6sLjgP9pnboOL7hK3Ig4t44rKFIosruPC8zyJVOG1HX+vVqsIhmFZrRIlIprJOTMzha3NeI3dHNfJx5QB4aMrChoX+mtoP/EphFEfy2sr2G9WMFc7gEpzRq5X0jRBHgcw8ghm7iAHs4B5/p4iHhqoVurSCCtj3jEvWHg9mhswKV7xiNvlZyEVF4wm4VeSIB50YfujrobSZQ/Ihl3pumc5/sZnIQvWY3FrVDnCHF1uTlGUPRelGGI9al/K0jnDQKPFrnoJwqAK5mPzfqr+FKLAwYoDAbvjceArcvgeBawctl8KSSJkW4BnGbALWiop8IxErryQcHS6bwZRipCilLSBE3mhHAhpf5UMqwyNagVVFzi7PpByviCiAGVLGCA75bF0jbAEkDlH4tBEgSjN0Q5y9OMUrmWh7tuoeR7HW3k9dq2bb1bAsX+tH5UDUlp2gGCYO/eXbiHClQ4Kb6wRp7jGA1XxPXFMxUlZfjiEjTgv95+vRQGH5XuPXmzjk6cWcc/xfeg404hzW44n30vFomnLRWeYwkCA+ZYHV8LbU1QrnDhMcTeVnSnYGcNAs2qjN0iQ5ynW1lawstYR55VYWDOGjo+D0z0ZnPl8HnM6jMoJdORW23KSVLqyyoPJY1xup1zZ4URr2gbWu0P0h6Ec+3QcHj5Zq34Fo1ayE5PteDGoDEMfC1Hjzn1XPnt8krA50W2uXl3xKjJHcfLnSQQDEUeSlWRjTZzw6UmcoiiK8jJgN13ltruovh4x40aEj2s9Z6dyrN2IPVcrg7tRXoxj9EJFohsVAl/odm8WrlY6tpVxhcfVvq4mSI1Dw3nOy4Xq7UTEyZ/H4tT09Az+6jd9s1wniCNq5NzZePbGeXaZf8rnPXf6FJZXVqWB0Hg7E+9aHus4rpwrM6e3DEUvO+5RBKNZQPZHnEEmbF7/8DoGwJ13nMTs9PSGY4rXdVy05hfP33ndw59d14XvV2Dbjuw3z7PXuxU8uVzFQ6N8WeM6/z2XPwPJcB3D048jvXgORn8FjgF4jQ7Ww8/CHiRopIfh1mdRm2ZWFi/MYsTsuCfxKiy38+BUXNiOKS6qMjsKMCjuSUYKu+4ZIvDJAjlFQoacRzGyQQ9Jb02qPijUOfUWsiRGPBigMrPAC93STOE6yNIEFtue86CMShzLaJCb99+Moty0opRkRrGumUKRKO7MWVpBreIiNn2YLK3KDBFRWIXM0CcKHCztpTJdDtqbkoRnFwjTMnA6SthVj2Hb7NbHkr5S5ec4UVgMBHSRhoGINLY1Cs42mJlU1mBzYD97niVxNp4+vyilhg6VbI5AVo6qayFKSpcVB7FSQOFTOYixVjtHbptIE4pfGdYHMZoVDzP1Sjm4oUCVYYFNE6u9ELFMCoa0I6XLiSV8rPZLcwNVn2WD7E7BeuMyX4tuKQaWU0AzLAeNRgNVrwPfdaXML8ktDHMD3UGEXpTDiW3YjoM0iuQYcJ+qno1qbqM9YIB4gemGj6KwxA3F1+REw8mCAYA8PCyddK0M5y9cwkq7LyV/AUU0yQLLMNWsl21dLRPNRg2Lqx0ZsLmmUDqJKNzJOsAVgtHkxMySQ5YJyoqBdMdjSWAG3ylLASn4sVSTqxc7+lsZxi4bLmuzN1aDNkSorSeh8v8rbps8EdkQm8b3ldPWaJtjd9SVgeuTJyiKoiiKotw8vNzm7hfqDJtku8D1F3P7X0i2E4t2K7JtCktXbmsnYWrrbdcSGa/MkyojMer1Jmr1xtYl09EJ8POCLeRa553v+SAeffzpzbIxjDr6YdRcyLZx8sQJcTQBgVxLEX4/dfosBhRwRllI8h5G57z8OnTkGF59aABr/Rk8a92OpxdDzE03sLjaxi0LPl6R/DHMtIt09kHEt/xZEXzGES0tJ8Ktre7o3Hp7bWZngbiM1ojbi+h85oOwB11xNdE9wOiSbmAjGkZYjZ7CET/ATDSEF/Th1abh1WdQX5gXgQzSZMtAGgUowiGKNJH3ymtCjGJixqWN5bVfKVSlUYw07CNtryIOBjC8Kiy3IiHnFtKye3hjBmmclKHxFKQsG2mRsZBQTAllyDmrU7gPL6/xR1Fe8qIUB5CKZ4o7iAHl/MdtcYWA7UitAK1GH0FgodufKRXpvIDnWmJwpScpyymScKRkpz125WPmFMWAMnyPYhQzkpK07I/GEj2W4MVeHZXmFNqDYGOAiUeCQq1SDg775ufxli97nQgzy52hZEBxsBCbKUxxADFLioMYw8HTtCwvZMA3BysO6nTM5KOQQQabr/YChEmKmmeLS4kOsSbzn4oCPTuVTCoKQBSaKNR5o/s4RtYrtkwaLOWWXg9WgfnpKlbbQ+nm4LE2OSutsHPNCmC7GKYmqkYO13Ph+T7SQQTHYgZXVpbWJRkchxXVNtYGiRyLVs0VC+twlAlVOoZKW2qvP8S5C4voBDHaAfOrylpoOtQ4yA7oZLIdtHuByE6+7yEIo1LI2zKZl4LhOINp5FajODiaz0d6I1zbls+Qj2n3QzkuMulPTkRbBaSRIrVx4iQ61WQR3sYf4HgTz9u/Kxk5vDZ+K1eSNmruR/vAE4DSPly6pRRFURTli40Xs8zratu6atDxC8xherH373q3SV7o+77a9m/EzbSbksHtRIObVajazil1rfez1TG1W7Y69Cdv3+5rnC9FJxOve7bu9+jZE+V5o78peR7PzyvyO3NarayNKOJicClKmWaKxQtPlY9nZ7o8Q6/bl255tuOKiFWr+uh0ujBtD5XmflT8SilOWQ6SQReD1csYVA7gzNnLQH4AZ8+eR6Oow8s+CCtaRpr3kZ38s9JnT94TF6BhoJ8WaBasznj+sbkWDDHvPP0pGGtLUm5YwEYyHCIYpvDdAq1GChttJEkXi91l1NaOoTGcRzLow6224FSaMP1KWb0jGVyMOykXunOTXcHL/ZQkmFGZYsFFcoaYB4HkRsUUskQ05H2JlC3G/Ta85lTpghptl9d5LLM0aRbgd1acjMr3xgKhoih7KEqx5I2iiE33ohUgZLOCLEIaFOiFq1hf66A1dZSaE8yCAeeQLCmpZRb3jQUjjcFGB2JDzVn7y/K80sdCUYVB1hSL2MVtZLxBtepham4e6ysriFPGiI9FBVOC0znATzVq0nEiZIZRkkqdMW836ZASpbsUpphVVWHZW5JKyHcinec4QZTZShSx6DCSYLsCWO8HSDIH7UEI36GVlTlHFNMscSqFYVK2epUaa1typqROW7pmOEiT0jbL16pYOeanaxgEIVozs/C901juxTi/0sMdtxxChQJ+7KLRmsYwzjFd97HWC0cW3hwxVX/mZEkQe471QSJiXp3dNwpbAsb5/uiCYp365aV1LLeHyE2z7DZIwcwuV4bYDZH73QtCUf95u5TgiZWYImEpzpWLC6YsOIwHdc6E484gvIHHq+776AYhEg7WpoE4TSVDa1wbP+myeh5bnE8bkecbjfbGE9xIRBoFrm9qVOWKiwhZo7wzfk502/EEgHXw3C+Kl5TlygB1/g1txisqiqIoyhcj1ysCbSfCXKvb1m62t9vfb2SbN/rY6xGQXkwH0qRrZyx+XM/ntNtsn53KJF/q7rOd9n27z2DrQuh2TqhJ8Wjr4ya3cTXxajuxb1KQElfNqGxuq1C55d2Vz6VwI9EarLyw5TzX8TzccewkCpQNhMbB5tIUSOI2gF5viMuXV2E5DjyGfxcFjhw5iFOnzsH3G1gfWJjfN1/mQ+UF1lv3om0eRxpEqNX7kpHUmJ5BwJB0/xCM2lFZ/Ka5YNy92jAyRBmwGFSwLx9FcGwRpq76+aFAMmgjW7kEN0qQFzFyRpAMBzDtjD2wEPdMxGFZ5bJv/hyScBX9wSHUoiNoDOfg+g3Ybl06A7IbHo8Dqy0Y1yIuOO6vHPPRZy1lexlyiVmJpQMfjy8cVwwJPIJJFEi5nl+fEncUr2fK/KiR4DkyXTH/i/dRoLLE3aAoyt46paSMje6jFXEYJWGMNCoV7aW1AaabDmquDd9j5lOEcMCBtEK5RwYNRwZziREHdSBpa+qUQpDYL9MCHmuCzQIV30YYhShy5kEBNkUmg6HpLIcrxRGWsHHVgAP1sN+HkUXoDDMkUjedS57UMErLQZTZURyMRNSxpSMgy8rG2UjlykVpa2WpnNg1GbhuWwiTQsr6pJsc7aLi6snLUjd5Xg7XYfe+AkWSirg1nrzKQSuTxwXs1GdTKLFguU1Uqz68MJegwvV2H81mA/Waj1qjhdP9CL7rSBZVPyxFNar5zKmS1RarzMRiwDjLBCujDn5hGGBxaRnPnV8RkYgfdSzB3pCyvXrFE6cbywsLEY+4j2WnPw7OItGMRCdujzXlLMebnGDGqzxijy2nKQz53rhiY9lynDmJ8g9ma6fUbXMQJiWpcec9TgA7dOkoi+3Lk7SpuodDCzPyOVHknGpUMT/VwOxUXd5rLKtJBQp2FeyH+PSTp/H02aWRWLpp4LriREYrxBVFUZSXAZMX6C+WE2m75+90206vuVNA+I3kY73QbW/3mOsRlW70NW50+9sJX7t5zNbP4nnnVzfwmXwhuZaoNr79Wo+/lki1VSAcP2en71u/Nu9nh+oycmTrvl15prx5LpplqZyz07VTCj90RpWhGhI/IovovG1cFcBzYaBSqciCP6stJBHDNKVDOUPMvdzFzPQMhsMAcRxLVIjjOtI0aWqqivmZaXEOVZwYiNswwovA1G0i6owDvnmdVi8yHPdyWaQ3buDvJmPJ3WCINI7pYEAWBgiHPaSJBUY3+V6ORoPRH7xOymA4PRSVZ9EeXsZwcATV8BA8twnHqcJ2fbnO5CI7ryvNnG3XpRGfCFU8eDmrV/g6bEaVJsjSWMwK1doUYDlyjBikbldrZXfCJEJBsauwkMcRHL8izy2v+3iNWF4PybXTS/+fi6K8vEQpAzEGw0sIgjZMqyrlUZfXIulox3+PC80a0iRHkKzgwAzQXweaLaAb15BlFINKtxItlRXblM53rmeP3FIjgcfIxVVF8aXimBjEZcZQtVaVQO8e85Skq2fZXpVCEAfwJIlx+eJFuM25UtGWxY4cVd9GmpWOIr4DuqjodbJsBqCXQYIUn+js4fxAcYMlZxKEbjI/K5GSNApHgzBFZFGCKeB7rgy+KScLmk5HNcXcLkUVBqTzNeki4sTAXCkO3EGUSEfABI6IUHQyMRR+dqqKRs1Fdf80Et9Hsl523uNrcNCjeEZBTlqdZrm4u7KC2V4m1vsxsooFy8hw/tIlnL/cwSBmyV9ZPy1jpQERlwYhO2iUk9qG4i9BgJuT6djOLHbV8UTMMV2CxzdimWRSrPrsIshSwrIbYxRFpeAzft2x4jQu6Z6A29uw1F5hjRo/p3zd0aM3OukVYGC+j9fefyu+/JV3YK5VlWO0trYmQh8nuDhhiamLWm1OnFJLyyto+RXcfewhPHdpHR/8zDM4dWFVjsm4LLHcBZWkFEVRlJubrY6O3YgW291+PeVcWy/ar+buuRHR41pi2LVe84W81vVu+3pLwW6EF0MMe6H3v9TY7u9569/k1jK/qwlJW0UqMilUbefqm7xp8vk8t5ZF3dE5bvn88eO2P9ZsHMVqj3KRtryGWW7H5esam7ET4zAKKjFhaKA3hGTFhkEKz3extByhVniIwwJhEODxx5+U7Z04tIBur49+EMEoMnT6ETyHv4diOogb+2DF6zzrloVflsOV+2nB8EyAMVaj6oPdfj7ltUEhpXBZkqKIIhRhJKV7LKmrV1MkMBEGBfpDxqMABw8U8OwUhpnDcDpI/VDO5bPlQzg4NY2KX0PFq8LzarAyR67FeJFKl9TGhYsITXRHpSi4cM5Kj0oNhlcRUarIE1lQr9YbiMKhCFx8r0kewHI8uc6kwsdjbY6yrHi9J+63m+zfiaK8lLgxr2GRYWWpXXZdWFtHs+5h/0wTg9hAkSVYmJlDPwywurqGqtlAlBToDwzYji+uIstwkRlsbVqgbkdIE2ZC2cgzOpESOCbgmKmo8XTesKNczfPFqeTWmhIOPgwpJIzqwKUjYI5WrYJv+Jq3oGpEiAxIiR8DxJmd5DrAdN0VMYsrDdJxT7LPczZVkM4KHNbpxKJIMha7WN5HN5XNWkSZDXIRkyh2UGiKOKDlFKcccQbRDcUug+wWyCcwv0pC3rNRR7vRRMYf6Lhil4h6s4V6ZR2zrSqOLbRQn5qVssOzg3LQphOJbrIgLvOikoTOLUoyBcKYYpk1KkksnVYXFy+j26dbLBEXlGxj3FNjJCqxxStff+wUojjF47/TytvYyjwOBOc2mjVfgsxX2kNEHKRHKzblPjPivnRciZtpvPqzaYXaFIA2cpxkiWf8oiM9alOQKn1ZLBs1cHTfDB648wQuL17C6+4+iia7OCYJDNfB9PQUkjgq29aGkRwjdkqcnprC8aNHEIYhgmCIO4/O4pYDU1haD/DYqYv4zJPnsd4biI158iRBURRFUW42OI+NXeCK8nJjJ+Fza4ne5M87lYRuV5Y3+X28SDsuwdvJTTbpRCzN/JN5U+VzR8+6IqJic1vbv1epjJA8XMZ2sLt5jvOL/VEQxYRIOn69kegzP3cAt952m1RO2K6Hlp3i1UuP4lQco+M0N/JVWblxaP9s2aDIdXDy2AHpKM7zar7n2HxIRBmYPnLTLxeHR/Ee/biCtcTGFBsZ7fIzm8SptlC4VaThKjIRwWLJyuplFmy/QKWWg6YlClGORcNC2dWdlRQXV238p3ctYTBYwmtO7sMbTh7C4dkpVOIAnsvQck/MBOJ1KHNHyoNMYW30WXquN1rmLq/xWNZner6YEeThTo4ijkp3mHT9YzyJBcO2kbOZlc0O6VS2Jj9fRVH2RJSi+ydJCgnQo8NpPQmBholDC/skjDvJbfiOg7nWrLifHNdDDg+tiitldGkyRGE4iPICnXgdruMhGJiYaU1hbTWEbcRAwaAqB60a7aSuBMtJOHlcoNmaxcrKmghLFJgoyHAYOHxwP2am6rh4dhWt6WlxJMV0FhVlaZ1jAbWqg+4ghuPYiKIyX4jlbNJKlZOOBRF9OOJKdpZlIkpSKfWjAMXyPFo/KQDxuRzGODlwZygOUdjh8aGGVXabK0S4oeTF4DyW7tFNFcd0TJmgt4wDGnOnOEDWKp5MBNMzLZw9HcgAztd3C3b1s5CkpRg1Tlyigl9qXDmG/R5On7uE1Q5rwS0pX+SEIflZDoPdY3F7xVkpqJXvKUYxKgUcs3UF6YpBdpT7NA6wZ24Wjy2dW8yN4koOa6xLUWlkqRo98Qo9qnyhUhmU7KpNWzPzskjpnto8ueCkcvuReRzb30TNLnDfrQuI+6tod3uo1aoIGVRYQKzIDJuvuB5W2135fM6cv4SFuVnsn5/FIBjCsQ006jVxuvHYHJyt4UsfvA0XVzp45twynjh9EeloPxRFURRFUZSXLlfLOJsUkq72uK3nvFvL8ShOlZlQZebq2C01yaTwxOKJTWdWmVubJBEuXDgnpXVllqslTYQodIy74Y3Pw8dfDCj/f/7GN4pYw3NaLrYzx6jstM0vRomMBJex019ikEz4noc7j+2T12JpXtN+CK90HbzSZpmbIbmr9XqtjFKRsjxeFzly9u3YjlRlDJgXlfNaLAeijlRQtFotuLaBWq3AkcOMK7lSlNopn2zzdkMWuC2vBmffIfTOPIeCGU8pK08y1OsJwrRAEBlIY0aXmNi/j+HiDFQvm2O95+MFLq2ywsXAh565hMcurODBowt49S37sb/VhO9WxRBhW45Uq4xLIq1RgyNmUPGST47ZKOaDwhSvy+J4KMcmTUIR/txKRTr0MZ6ExxI0JYyiWbgdo7BUlFKUvRalGCq+f3YWcRzJoOV6Fo4fXEAYZvB9F2nOQZt5QjFc18Rcy0eGKnxESE1DMqFy9mtgKVw/hufSjlmBgwgV30QWd2AaEUy7gjzMYSY1EUAoJNWcAnGtCtej3TMX91QhqrWJlbVVnL94GQ8/eQZf+qqKCA9RKiXKElYuVW9FhqmaJ9ZMAxaCOEWasfveyNFE95TN8rpYBiPLKMUgCkYMOC9L2XIRY+I8hydp7hSoCqRG6bqieCJB6ZYhJXns3MftOEaGqscyQpbicRDMxe3lGVz9sFHzHTSqPpZ6Q8zvmxW7LgdO2zWRpMxXKu2hHBw5EboUt6R7YIF+t4enz5xHbxiKGEXpSgQpw5BJhtldFNSYr9Tp0yFVCmpl27xyVUWEpCtWeUah4pMTy6jbIe/pD1nGSfGwXKs5NO3jwvpAMsG2pD9dWQg3njNFfyrLB0vKroCTYtTkk2YqJpx4GaefPid78OSzzyCOEjx36lnZxzCKcNftd6LVrOOxp55Gv9fFcDgUl5Rs1wAOH9jPLrBYXlvH177ly3DbLcfgeA6CTiRC6v6mi8OvOI7X3nUYqwN24CjDKBVFURRFUZSXFlvFj2vli5HtXFPXEq62RltMClTjnykQUSzi91JcSkUn4u+lKAWsr7fRbq9L1QeznRgxwWsACh08x6dANSlIjbfPL16P0MlUNhkaRXBM7LN8jWxBpZtpvO+bZ9XlbeP3x2uAAsNBH4N+73mZWWT8vuia4nUfSwf5+9RUC/fcNY/V3hyWunfhjkPeFemwV8v22viMRrkijZN3Y+2TH0JBgS1PpWkUS/YyC/CdAo16Cscu4EgnPYpnOcLYxumLZeTKa+718TVfYYCxVB/+5Ap+5o8Xceu+abz61n04PjuFuleFY7uygF5Wh5TXcw6rTBweWwNZGG5cO+VRJIIirxRZieNVKgiCAJaIWzlMi69LtxS3UzaQMs1Rl3FFUfZOlFpZWULVdyTbiLlLvulJtwIG3lV9S8qhDKPsVhClIaasBEXBcqoC07UG1tbXECaBiFJJxtpd1i4DVhaIc6UXhoiRoFmLsd6J0bQc2HYFscH8pwQ2HUyS+VSICNbtlVlGdCIxnPzZc0t46O4TUgY4FFeQxYpDKemjICYijVXAlk4MHHAYap6g6pWh53QWcaSkcMNwPJaByYRTAGmciMBE9YkrCSLaSOg67Z3cNjsTlp3x0jyXbhEsP+QWh2Ei97EUkFlQcUI1vrTelsHgqbwGB2PJd6Jllq9HMWyjCwf3u3wu9ZKKY2B5tY2nTl/AIExEgNuw73KtQeypsrvyHlgvbtnMtmJ5XenuokhGmXDkWRoFKZZFf+M8K9medNAbW3ZL8Y7H0rch+x6EobjIxiLT2ClLsY8rFFMNH4cXZjA73cTjz17A4lpX9nWybLDMnJo8USj3gYLiTN2UFQuWSfLvhLdxhak/GMpEwAnzk595WMr3Ftc6IgC61Qb6g365kpTnePy5syOrVo4/eO8HpDvh/ffcJSKn/INwHHS6PRzct4CD+z0RYBVFURRFUZSbk63ldtcSpCarBbarHJgUpygi8Rx0LN6w2zOFKZ6TEt4+FpoIQ8V//ud/HoPBAI7jwvcpTJVfvu+jWq1uiFUSSO554qoai1f84muXQpZ1xdeVTqvNztWT+zf+mhTR+MVoC+7z+IvZsLyN+8s83DiKRJjhc3y/gu/4jm/HPXfNIsM06q0TQMHMqyu7Gu3sIruS6sIR+Lfeh/YnPyhOqTxP0GpmCPMMcWxhvWMhSXi94MkVwtHDEXLGoPA6zQROnnBwx4lQnnfymIV3zXv4P3+4jE+eXsZdB1v48jv24/h8C7blw6SwZDriAkuyFE5Wfj5lZV/pOJNuhnRTGYZ8LkEQw6CrzCk/b94v33MTBkPkRYRkzIs6pRTlRrmhK+5a1UWn30at6qFpAYfm5sQ1xDDxMlycEkcuNs8Ku/PlXczNA2HPgYU+eoMAzYaH9W4PcRbBLAp0B10sOR0pqTMyG8udNezb76LGLhG1BGlcQZxn8o/fdyj82DBogxInT7liwI5zHDjFUluw656JIHVkkGBpGV+HDqeiYOkcy/WGiE0XhcF6YOYyUZHnKJ6hWXHRD8puddJVgc+1LPBuSkSUcTggUcTiNpk7JbXILB8LUtQq5kj0gghB7EhXofAxsvt6Liez0iZbMNLdMEuH2cgFxRpnQqstBS9+sZQwiOi2gpQiZlmC5XYPT525iF7AyWDkeCLyXlk6aOGBWw/hntsOoFmvYTAMysB2Nna1aDU1MIhSPHdhBWcuruD8SkfcVxIkLonmW0Si8aQ8eh88rrW6J21Ve8xk50FkJ5CRNYki5e1HF3DPLQcw06zi7Nlz+JJXncCbXnECv/3eT+PSahcXVgej13h+6OTozcA1+ceaIR1NsBTEWFdedoFMkdCpxjuNDI1GE2964xswN91CteLJez59/iIuXma3vRzDIEKvP5Dcq49+5lE8+dwZ3HnrLbjz1hNSPjk7c1hWgjzfG3U0URRFURRFUV5qXG8o/3Yi03aZUzv9vPX3sTtmLPyMRajSzbQpCo07ctdqdbzlLW/Bxz72CZw7dw6XLl2W89it7qjtnFLj37fuy3ZfOx2fyZ+3y4/dGvY+dl9x/5lH+9BDD+Ed7/gLeOUrX4E0W8cgnkduNJEVzGDa+Zht99mM81t5bXfwDW9B99I5BE99DsMoQXvdhuHzeqVAvVZ2ePd9VqHwMoPVOC5mmyaWV4F3/skQp867eMdbLRxYGOBtb6aAVMWv/8EQn7vYwdPLXdwy18At+1q48+AUZmtVeK4Px/YlxkRyquQahBU1m+9ZBMacUSmphJpLbAkFQF6DZKUoCLt0SbHbO689FUXZQ1EqCCIsr/ZQrzGPx5ecpjy30ag6WOv0pN43KXLsP1hHpzOUQO219Q7aHTqIDDQbFQzDAaZaFi5eTpCYlnTgu7i2Bs+zEQYJbLdAHDiYqjEjqAPfqcPKh7AMH7VaA61mE1FaBpHT2SS12LaDwwcWcPuJQ+j1h3DNqpS2cfCg+FN1Qxh5IWJZbmbIrEgEmgyZOKlEJc8jKQfMiqrUSocRQ//KQZEuINZc03FjFKXTiK4llulRjMooL9GxZdFCygGUuU0cfMtgdLqfys5+dPyk4sLJM2MUrF0aePgYBnPTgSaDI9O4RvOPuJJo/8oLWbm4vLyKc4trSKjyj7K1OJhybOW3RsXBW19/L15xx2F5Hh1LRVER9xUHVraFpZBn23Xcd8s+ycx68swi3vOJp3FusSPBfQyb538+c8FGdezjOaegw8kAWMEXJBDhiK6wIKFbykTFNfHgLbPI4x6qzj4cnGuh322j0x1gfqaBv/DWV+NX3vmnuLg6kBUPKTcUF1uZ4yWrPDBQcwwcaFqIokDu477naY7ULEqx0DSQxKl0NJxp1bG6uiKTfcX3pIyUWWMnTxzFA3eeFDGNYtw4oPHxZ57D773nQ3j3hz4uf6MP3HsH7HYP+/fNj+rzb/BflqIoiqIoivJ551odEXfqMrlVmNouMH277KlJxiLRZBj6pHuJYg7FjbGziSeWt912m9QmHDt2DJ1ORxxIY1cSv+hUGjuYxuWAY8GIv0+KR5P7tZ3YtFWsmhS5xo6r8T7SjTX+Gru26vW6lBq2plqYn5vHiRMncPvtd4ghIM3qOHD8bUzPwvRcc7J6b8fP4HnHf3Si7U/N47a3/1U8/lu/iM7jH8PMTI4wzzEIDHT7FhKnkJypcfVhxU/xVW+s4szFDJ1hjo8+EuAtr6/g6CE2RErw9W8pcGChjl/6rQBL6zkeu9zHY5d6eP+Tl/CmV7TwVQ/VEXamkYc1GAVNFWUndn5xl+TzS1idU36GrKTgsed3I2XFDjO5LBgZrz8t6QjPhXpFUfZQlOIgxmyiOExxeKEhLUFbzaqETbO06ujhKQRxjrhYRbOYxb133IHWVAVRmOLC4mWcPnUK/aAPmx31okREo/OX1zEII6S1TISdatWCldsw04qUlwXpAFGUY2YqQ2FXZIAM4gzZIIAxjGA7HFTpKsow3Wqi3RnCb7oiLI2FiyIdAlkbWeqgoAJuZTTWoOpWkRkm5qeraPeZ+eQgZVlfDtR9FyZYLuahFzJwL5Z8Jt+y0I0oTnEQYvkdBygbSZxg/2xdrLacExo1D9PNBlbaPax3+5LBFISxDGR0OlGEScXZBRFVKr6PKO5IeR3dUBTdPd+CnfP+DEyUGgZcEVjCUmew0dGPiIhTmpswVXPx5a88idfdewJxEkur12qlgqlWE52sKw6gXj+A5/si2FEk4/7fd/IQbj1yAH/yiafx3k89hXTU/Y515NxXmtKYZcXjTCGvLNErS+x431y9ggvLPVQ8C6+97zgevOMw6tUKjhxYgOsYSJMAS6vMDMvk9rd92SvxzMV3ozssJxoKbwtTVVxc7csxqVg5js+6yKK+CFcS6sg7DOZsJaXNVlxyCRoMibdNCZFcXAnFwUYB67lzF/GhTzwsx/aWY4fxJa9+AAfmZ2XF586Tx/AH7/solgcRPvbwY3jimVO4767b8eyZCzh69LCueiiKoiiKorxEuZorauvjdnINbZcntd3zdvP6k2IUS+/G4tFkCd1dd92Nr/iKssRvqwA1/n3yvnGm02Tp3fPcTNsIU2Phabw/Y/GJv4+FMn4fC1Lj28Zf4+dNlgaOHVslNTSbsxvvvcycvdKpde3ParMeozp/APf/le/C6U/djfe/50nk2QCeBzTrOaoVVrlwMbrspscu5F/2Wl7/VfHO92a4tJRK5Ao7oDPehO6mN3/JALfeUsWvv9PAJx4J0A8g4ekDc4Djr+wgGayit9xEe8lBv2shDqpA5sOCA5OZUeYoiN6x4WauXDfYGRtv2WJw4PHi9R+FKdvmZ6LXDIqyp6IUy/Mqnodmo45mrSJOn3avJ4HS09NzWJibF3vjY8+EmJ9ZwHCQ4u5bD2Fqqo5X3HsPVtt9/P6734U468OrdUuxYVQKlsU5pqerEo5e96vw7Dp60RCuy0ExQ6VWhWHYmJ5qot0fiiBVGAWiJIHvN3FpeQ1+1cdKZx2HF3JERoIkKpDHsQSGdygIsStfGMFmQVg6wDNPncVap4/Z6RZOHjuCB++9W7rInb1wGcOgh3vvuFVC2xvNJuLcQqfdwaXLlzFMXRmCPbt0RxlI0agaeNWdh3D8yAIaDGQXlxUHybI8sDdM8InPPYdHnjojZX5gid9olUDCEPNCxKJLl5bg2b4ITUGciDhGF9SlxTU8d3EF6wN2iSg7a8ikJGWMzNUyccu+Kdx1bBZH901L9lK95iHNSgGwP+AA72JxaQ2W42BppY3pVgN5kcK3y5UChq1/9ZfcKY995Onz6IeJCDyH52s4tRRIqRwVO8mgMgpM1evidKMDLC8M3HKAoYLA6+67BUkc4vHHn8Bzzz2Lg/vnsG9hAQdZF8+OI5aBJO3hbW+4G7/13kcQ0f1E91WW4c4jUziz1EODOfJ5hDgfTehFgSGPR5YhiulNK8TNxkmyKgIiEEmulSHONU4PDKbPUyAbDPHoU8+J+Pk1b/kyPPLYUzh2aD/+0te/BQ8/8Sw+/vDjWO8O8JFPPoypVgPtYSTOMEVRFEVRFOWlxU4OqK1cz/3blf/tJGhdK1D9aplKW3++Vv7SbgLcr3XfTu/reo/ftUSnrVEcW0sKr3jOlt+cSh1HH/wSzD/uIeyW3Q2z3ER73cFiUpHrkakZE0mUIYwNzLUMvOOtPnoDC2aR4plTHlxeO9jl67KZ1Ve90cWrH2hiZa1cR1+YL9DpddHrOpJLZe8fYOZgAiNdR9RzMOxY6LcrCPtNOLYHy7XhJQ48mwJeKd65/J4yK7gU8LiIrd33FGWPRalGrYIDCzMYDEO02wPJepqfnUIQpmjUHQnSfvTJZ/HY0+dQr7UlGJzCyJe//hVi9zxy8ADe/ravxS//xi/DNi2srodo1SvwJLyPtlcDNc9HteJipbsG33PgeKPAcWYhuTk8j+HXm0NZmERwKgWePnUer37gHpw7fQ62GaPbOQPPa6EzCOHEzJUyxc2URilSx0K7M+AWcfL4CZw8dhj75qcRDEPJHGIJ3qH9+1DxHXi5japt4OSBeVi3HsHFxf349BNnsNYZwMgjhMMQly8tYWllFRfOncHBhRl8/Ve9Efvmp0S8se1yEKvaOd7y2jtw7y378e6PPobT55fEwkvBpeYzmykRl1VA0WwUmscyOOYgDYMAg34gpX0UhTjYctWgWfHQCwIcPziH19xzAr32MlaWFnH/HbfIQJnQCpyxhwTguLSbmpibm5VAwCgK5bg2Gw0pHaSjjCVyFPD+3JffI46rP/zYU9LtYhiXXTqQZyjyDHXPEncVyzm5anFguoKGHWPY7yEaMHvMQ2vfFI4d2Yennz2DZrMuYl+epQiGwcjaBdx6cBZvefVJvPdTz0pGl+cYsIocB2dqQDwQR5l014sTeOw6wmmLFmauHGUZhlEszr3xGk0Z7Fh20JBcrJF9jGIqj9v62jpW1rtiwe0HIRqNOl73invx0P134cz5yzhz/hJOX7go37lCpSiKoiiKory02El4mQwk3+lxN8pWV9VOQsRucp2utn/bvcZObq6dtrmbfK3dHJvdiFDXeu5uPgupPmGVA4DVVRfp0EW9msP1ctSbKWyPQfI8lzcQuyYaLBxk4yoHIkRZFrO7CtgUpRitMuo8KE2tmA1lsqLGQBxZGIZMkuL1DJ1oKVw3Q5LTKBVLpUZ/EOOTn76IiuNJJVCjURUzRq1WQ6XiwnNtVPyqNNyiQOVyAVy77ynKHgedVxzpYif5QcMYfpV1Zgna3YEE0S0tX8AzZy5itlUFkMAwfXz0E59Bxcnxute9RoSU/fPz+PLXfwV+5/d/F3Fioj8IUanYEjQd57EII0tLAWAb2D9Xh2XYEhSeJEP0ggxZkYrAwq51FLqCMEG16mLpYle2Uav6sAwPvWGMIk8Yh40LiwO0ajYatToas9PIcxPHDh/E/Xc1pYa73x/g/KUlcWw5lgWX2U9xhJWVVWR5BnOqhosXQph2Fa1mA2984DjW2h08+dxZvO8jj6PTD0TUOXthUUoJP/fkKXR6c9g/N4NqwxARhGPy2uoaZuoe3vFnXoXPPnMB7//An8oASKdPnmY4fnAfDsy1cHl9ANex0OkNJIfp8moXRhZjumrCNmwJAqQ4c2DGxaHCQKuSYeniGTx16iwqno/F5RUc3D8DkyVtIUPiTbCaPQ5jhFEsIepzM1NYXeugaDUkAJ7iGUUrCnW1eg2vfeA2fObpC1jpJojZmZD5TVmBqmthtlHBbNOXYPh9cYw8XkMQshQwwb79C+h2uwiDPo4eOYBbTxxCt89MKAvnLi9jbnYavV4ftXoVeRji/tuO4PxSBxcXV9EdppLFFUc55qou+r2hiEMUlXj8ap4nvQIpoiVJJqsTdF1xMuBcx1JEWmwJS/w4GTGsnu+L3fy6vR7e9e73lcH2roO52RZe/9CDqFUrOHF4P04ePYBf/b02OnTh6aKHoiiKoijKS5LtG+TsnGF0La7HCXW1bVwti+p6xbLduJ62u/16nnc9rz1mp/e4G7HqKqoUkMXYPz/EsM/FcwPDoYHIBBb8BGZRdkR3K5JKLtcr7Y6H5VUTUQzMzADHj2SoVYKygx7L+UwGlDMD10QY2ZJNNbfAjuGyVi1L2nnmIstYAZMiCNhN3sGHoxTRIEW3PcQi41YKE1FWSKXJ0UOzuPXkfsxOT6FerUolh4pSirKHohTHmQfvnMesdwj9QSTh2Y5rYTikG4dB13T3eNg/4yJKYlxa7MK1U7RqHizaKp/4HLI0RL3RxMmD87jjxHGcuXgBnS5D0BlIbiM3ypKzPDWxf98M7r/nPrSmZpClCS4vLeLchedwafEcPJaB8fUoUKQQ9xMHKJZg3Xvn7ahXDSSPGOglKVp1G+b0FIqcHfNcPH1hFWtrHcQZA8k9cSZRwGCelUvxRjKiTCzMzpTh17aFequFCxcuYGn9DA7un8f09Ayq1RqeOnUBfSkLLAPXOQizbI3ljJeWO3jsqTO4+85bcWj/PCquLSV1dDsZRYIHTh7A8f1vw/s/8mmsnTuDxbUe2nFXyhMrroGw34ZvAYMixsHpigTKM2T9xD4fq91IFHrPyrG8vI6wWxYCGkUu3QWDcCiB78xuqlQr4ohiJpPjeFIDzXrpMItwYN8++WCDpMzmosvIcT1xKB2cn8FbX38/fuu9n5L4v/uOTeOxs+vwzASH56rI4iE6XWZgZeJ6GleG1ysuDh2Yw3NnL+Gjn/wcbjtxWBxVjYaNqWYdw+EQ3d4A01MNBEWB933gY1JmeWz/NJbWemUHRRgIsnRjoOe7Y019GYxYOueCOJZjzhvKfC2GzbNUUuxSEmTPjntlE71RoDwMLC2viLjGv9eLlxdx+vRZHD54EK995X2yf71BiIQtN1SVUhRFURRFeclyNTHqekSYG3FW7SRiXU3cup7t3oi4di1RbLevfaOPu7EytrK5ELfYX13G4qUMacLF/ByOl6HCNXDppg4UzASW6wAPv/nHHt71vgidHoNuDckSPnzAxv/91ibe/LoQFT+ShWvLBj72MQv/8Rdy3H3SxA/+vxYcK5Xb+Tb6QxuLKxUMh0AS52h32YgqBmJee6ToJhlYMMLGUVUvwflzKVbX1rB/YQbHjx3Awuys5AErirJXohQMND0fC7UqZiqelEuxhMucpRVyKEIRy/XoiskNA/ccOwzHsVBkdFZFMKJltphDe3EVUXcRr7p9Hrcf8RBnkXRsc92yXjcO2enOx1p7ACNpo+FMYXr/vLiOpqo5EA9x+lIEy7QlaDxmmRU77FVsPPr0abz63jvh2yZed++d4NDV6YaIKwkeffoiOv0QnW6/DAssgEEQyfuypC0pw7QTFLmJLDNx5sKiKOLHD++XgPFnTp3H7MI8Tp+9iEuLy3BdH6fPXRqVk+UysrHj28raGj7wkU/ggXvugu9X8IlPP4rnWnUcP3IAx7itYSBC2L6FObQaNXzD134l2msdPPLZR3HpmVP4+OeexsmDM/CtBDMNFy2vKmJZq+lLWPr++aa4hJIkxoWlVSxdTsSqGkfMWoqRpzE+/omPo+b7uOeu28SV1Gg2RqsCOTy3FKYYMs/OdXSm0ZpK0Yrvo1q1kaRAEiV49X23obN+AUWRYjDMMXvfYVy8dAGLF8+VfxPSz5VNAWmppY3WwfzsjIhQnJcefuxZ7Jufg2kWsh8SumiaGPT7OHfhMj78qcfwzNlF7J+fxdx0DQszVZkQ9k176PR6UqLHDo4s3qRbis9lwKBkcKVskVF24Yti2m/Lzib8c6CoKCWJTGCnt0qisHJYThmAblKkyhmcaKI7CKQT3/LqCr7klQ9IyaNlsyRQURRFURRFuRkcU7sVRHZVTnYN0eVaJXrXu90bfex2WU7Xy25zonZ7fLdzh11933gtId2jEKxexPzMUDqXB1EhbqnBwEC9xmu1zYyq933Mw6+9M0TEawFugQvyMfDk6QT/6r8keO5cFd/2lxx4Xl/uy1ILa50Uy+0yh9eS3Ck+00StmuLI4QG4Hs3O6JWKh36Yot1LpcN507cw61lyvSTvg5UjQYLTZxZx7vwKDh6Yw5f+9Wi3h1tRlBcqStGtEgQJOp1ABCHDNBFkZSA0RYFGrex+RhGBI4DH1pm5iTCMEZnlP9YgCmFYNi4vdjE9XZdudtOVlnSJM3MTcTeQV7KcBNNVwEEb3aVHsXqp7KJnJDHuObGAbm9RBCmW71EP4jh5aK6Bh5++gJPHj+LY/AE8cPsh2HYmoeiPPnMJR/c3cHmFgkQZlE2BpDdgC9YEiVG2caXAQWXekm0WuHBxEa958C50Om34no0oCKSTW5bGePSpZ5GzG0aawaBDJ8ukax4zli5dXsTS0jJOHj+CmakpDENPyhrp4un3+tKNrzuIcPggc6s82I6FN77pS3HbPXfjox/7JIIkxOvvOQTTCCUIvupTRslQr8xhrbOGolqIIHhpmRZUDpqmDNYsP+QYS4Hpc48+irvuOCndCstVBb7nsgVrmZfE4zce4OkQK7srSn01XVMMALQtvO7B2/D4Iw/j+LEZHNq/gF/+3TMYZOXxE1dTVtZSc7u2ARw+fEDKKwvmR4UhHnvqOdx/z23o9vsiFlUqPg4cXMAfvf9TeOr0RXE+veLOA5hrVWUlgseGQfGfeTJARA1yJEJR+GJnvyjNJJyQf2dmTkHQGX1ugG2yTW0mTqckLUv5pLyPXRgZmCjh5XS1UaQSz9WoFayBpdU23vPhT6Dd6WBmdu56/3koiqIoiqIoe8R23fM+n4HTW7e9m9d6oa6p7bZzNa4V1r7T9q6WQ7U1z2qy899O+7Dd866578wJXuvg/DkbuenAcwt4Xga/wusc2ZIISVlh40OfTOX64OA+C1/9BheVSoHHngE+8nCEQVjgN/9giF7Px//7bQ1MtwZSIVHud3ntwsVyClJkMPRw4WJFwtNZ7hcOLFQcA9V62ZiJ1S9srCXXDbweMVIUWYEky6Wj3+LyaaysdnDrrt6loigvSqbUMEyRZxQuMrR7fem61mzUYCYpoiiCZZXZUMxDKsvUCgm9zjMKIRl8t4IcOTKnwNnza2jWfTRrdLrQtQJ4jimh4FEQS6e9/pD2yhxZwlaqhYhXhuWABV5JlkirTiNNMegnuO9oAw/nl/CnH/8U7jv5dhhhgbVwBcMoxInDDbTqBV5x95wE2A2CDJ0gwXNn13HyxF0Sev3ZRz6NA/taeOKZy0hSihiAESd44qlncc9t+3FgoSEiVt0v4Lo1/OmnV0WUYjh7nCQynFJwyZJUBCC+/2dOnUWen4bn+qhWfTz8OR8Ls9OYn53GJx/+HFbX1+XnudlZREkmwtfXve0rkSYx+uur+NBHP4DZKR+FEcFxfXQGPZxfXMd6t1xRePyZJQRRgiRlm1QOspxU6CiysbS8jEcfewL333ePiEbVSkXcQxTfRIiLY/lMXZYKBqG0hI3CUALFywklh2m52L/vIJ547FGcOXcRjz55CuudvjyvfExZXse/BwkkD0I8+dRzmHrofgnAf+Du0qnFcklmf81M1cWN9uiTz+GpMxdFcGtUXNxzSxP7Zh0MY26vzN+66/id+M0/DNA7H0pgIUVQviIngSCMJVuKk1TZCxAIoxSeY8l+jIVRlvm5tiNuOh4Ximy8jSsffJY43GRiLSem5ZV12SeKVlvagiiKoiiKoigvEa5W3nY14eTFyFva+lq7ffzVXFU7CUfXI37t1C1vp9feKQ/qhXb3Gx//nR5/xWMnT7mzCAvzIXKDZgZWN7ASxMblngPXL3BwgS4qA2ttnucDX/uWKr7+K7pyLv/WN1l4/Nka/usvR3j2XI53/2mEpTUff+dbpwGD5/Zl/izP8Xnan6Y2+oMKHBe45SQ7yRtg3/SVxQrmGiZ6nbIag5m/vFygKMXvcVbIAnk+WgxnPAu/K4qyh6JUEOdY6wbi+On2OWCYGIQMjTYlLDuOI1R8G0GUiXNmYZoiBF01ELHJZoh1nKFZ9VGv1EVcYgkVy/foWqHjaDBMRGCo0B1ERZsR3RJuzmBzigoZji20UHMuYH00jK2sh5iqV/Hqu47igw+fxoWlNRycqmG97cM0a5jyPbjNqpTr1ZoN9O0IC00DNdNDHK/joVsWcGLmfikRu//EYQzoAUWGVrWKer0moXdUzY/MtjbK9JiDJelHBTOxDHGG2cxnkrpi8SZJDhIfPwxCdPp9LMxNSye9M+cvYr3Tw8c+/VkJ3G7Wqzh29KgcI4pNr37gTtx9x61405vfisceexKX1y4iTWN4bgMHD+7H7bc3ReT56Gd/XcSsYcQOewzn80RQs5JMSv4e/uwjOHxwP+bn50QMYnnkoDdEq9VCZISIIgbLW6hWqyIslV346PpKxfWW5SEc08Dx47dhtjtAZzDAavdpLLK36sg9R1GKrinCnwfDAOfPX8LcTAtTjZoM1L3uABeX1tDtVmRy+vCnnxAnE7dwYG4KQZCi04V0PTRtS46lmYW49dgCnjm3IhNBuTpC8SkuuxAWBqqeK0GFfH3OfalMGLlMFDweFJ2yvMz6ohDFzC2+T+nwkfPvbTwZlm4s3sC/R23tqiiKoiiK8tJlq7vnhWQp7fb1ruf2633sbrd/NYfS9Wz/el7vWufFOwmEk+LUVZ9PIwAFI6+KxZUmCrOA70McUPVqAW+6gOulsNwKHNNFs2Gg2s3wic9a0kDrwTvYUTvBa16Z4paTDfyn/2Hgo5+N8fRZA//43wC33sLueTEqVVbjuLBsB7nhIM3r6K5biCNTRCnfBYYDE16F13DszmfItVGR0FxRiGPKdU00HRu+Y0sFCJtKMYJGUZQbwyh2eeUtwspIcPj93/0tLF+6OBJmNi/wKaxQBKHbpl71EEYJfNdGs+aiwn/hozBqOqtEDLBsKaWiO4plVSw6k8IyZhMZpmQd8TWk7tcaiwQUDEpXEq2UZy53cOrS2qhszsSr7z4iAsvnnr2EhbkZzDRruLS8LkLWsUNz8M0EEcOS+EoUJ7g/o22X2UhliB5VcQ7HYuxkyVdelsVVK66IJmUgeIFHnj6P3jDcGLw3xIzxcwrGdZfvrXQwFaUAJ+XIdPGUpWO8z6UQ4/moVpgbFaDVrOPYof2YnaEIxjLDUErh2utt6XjHTnjtfojnzl8uB0uWzo2EIXkrBkUyS9xe060Wjh47AsdmZpcj3QZt25bjWuYujbrXsRxzGKBer8q+F0gRxX3kqYWV1b444W49cRS9YYDnTp3Ferc3qgMvJbhy8slFUJqdmYLne7BMBuEP4Hkezl9eQb3io9MfynEjPCa3HT+MQwtTcGwLQTBAEjN0nT/HsF0Xjzx1XsrxuJ/cZ9aZSxA56KyzJU+rzEgcBSWO3s/4WPBYs6SPLqnyb7a8j48fh7PzZz5OxC1wIqzgr33TN0v7V0X5YkKE8RtkPFcoiqIoL2++UHOFLhq+cD4fgt2LRRLwemMZMMpAc4kYGVVECHKBZmC1w4Xs8tqQpXhz0wYcZ9OZFcYWVtfL66zytjKqg3+287O87pv8O+J1BDdsImeXvTDHoFs+t/wqI0JGa9dyPVLu1+bTZ/bth1dh53lFUa53rrhuUUpRFEV5eaOilKIoinItdK5QFEVRXoy5QotfFUVRFEVRFEVRFEVRlD1HRSlFURRFURRFURRFURRlz1FRSlEURVEURVEURVEURdlzVJRSFEVRFEVRFEVRFEVR9hwVpRRFURRFURRFURRFUZQ9R0UpRVEURVEURVEURVEUZc9RUUpRFEVRFEVRFEVRFEXZc1SUUhRFURRFURRFURRFUfYcFaUURVEURVEURVEURVGUPUdFKUVRFEVRFEVRFEVRFGXPUVFKURRFURRFURRFURRF2XNUlFIURVEURVEURVEURVH2HBWlFEVRFEVRFEVRFEVRlD1HRSlFURRFURRFURRFURRlz1FRSlEURVEURVEURVEURdlzVJRSFEVRFEVRFEVRFEVR9hwVpRRFURRFURRFURRFUZQ9R0UpRVEURVEURVEURVEUZc9RUUpRFEVRFEVRFEVRFEXZc4yiKIq9f1lFURRFURRFURRFURTlixl1SimKoiiKoiiKoiiKoih7jopSiqIoiqIoiqIoiqIoyp6jopSiKIqiKIqiKIqiKIqy56gopSiKoiiKoiiKoiiKouw5KkopiqIoiqIoiqIoiqIoe46KUoqiKIqiKIqiKIqiKMqeo6KUoiiKoiiKoiiKoiiKsueoKKUoiqIoiqIoiqIoiqLsOSpKKYqiKIqiKIqiKIqiKHuOilKKoiiKoiiKoiiKoijKnqOilKIoiqIoiqIoiqIoirLnqCilKIqiKIqiKIqiKIqi7DkqSimKoiiKoiiKoiiKoih7jopSiqIoiqIoiqIoiqIoyp6jopSiKIqiKIqiKIqiKIqy56gopSiKoiiKoiiKoiiKouw5KkopiqIoiqIoiqIoiqIoe46KUoqiKIqiKIqiKIqiKMqeo6KUoiiKoiiKoiiKoiiKsueoKKUoiqIoiqIoiqIoiqLsOSpKKYqiKIqiKIqiKIqiKHuOilKKoiiKoiiKoiiKoijKnqOilKIoiqIoiqIoiqIoirLnqCilKIqiKIqiKIqiKIqi7DkqSimKoiiKoiiKoiiKoih7jopSiqIoiqIoiqIoiqIoyp6jopSiKIqiKIqiKIqiKIqy56gopSiKoiiKoiiKoiiKouw5KkopiqIoiqIoiqIoiqIoe46KUoqiKIqiKIqiKIqiKMqeo6KUoiiKoiiKoiiKoiiKsueoKKUoiqIoiqIoiqIoiqLsOSpKKYqiKIqiKIqiKIqiKHuOilKKoiiKoiiKoiiKoijKnqOilKIoiqIoiqIoiqIoirLnqCilKIqiKIqiKIqiKIqi7DkqSimKoiiKoiiKoiiKoih7jopSiqIoiqIoiqIoiqIoyp6jopSiKIqiKIqiKIqiKIqy56gopSiKoiiKoiiKoiiKouw5KkopXxQYhoHf/M3flJ9Pnz4tv3/mM5/Z8fF/8id/Io9pt9t7uJeKoijKFxqdLxRFUZSrofOEory4qCil3PQsLy/jb/7Nv4mjR4/C8zzs378fX/3VX40PfehD2z7+yJEjuHTpEu69994920fui23bePDBB/fsNRVFUZSbY74YX7Bs/bp8+fLn9XUVRVGUm2OeIFEU4Yd+6Idw7Ngx2bfjx4/jv/23//Z5f11F+Xxjf95fQVE+z3zDN3wD4jjGz//8z+OWW27B4uIi3v3ud2N1dXXbx1uWJRPMXsFVkW/6pm/CV37lV8q+KYqiKF8YXurzxZNPPolms7nx+8LCwp69tqIoivLSnife8Y53yP781//6X3HrrbeKGJbn+Z68tqJ8PlGnlHJTQ8HnAx/4AH7iJ34Cb37zm2Xl4DWveQ1+8Ad/EF//9V+/7XO2s9m+853vxO23345KpSLb4WO28sEPfhBvfOMb5TFcFfnu7/5uDAaDa+7jd33Xd+Ev/+W/jNe97nUv8N0qiqIoL+f5giIUL27GX6app2mKoih7xUt5nnjXu96F973vfbLtt7zlLeKS4rXFG97whhfp3SvKFw4921Fuaur1unyxrpuW1hvh3Llz+HN/7s/h677u62RC+bZv+zb8wA/8wBWPefbZZ/HWt75VVk8++9nP4ld+5VdkMvnbf/tvX3Xb//2//3c899xz+JEf+ZEb2jdFURTli2O+ICzxPnDgAP7Mn/kzO5aKKIqiKF9888Rv//Zv46GHHsK/+Bf/AocOHRLR63u/93sRBMEN7aeivKQoFOUm59d+7deK6enpwvf94vWvf33xgz/4g8XDDz98xWP4p/4bv/Eb8vOpU6fk909/+tPyOx9/9913X/H47//+75fHrK+vy+/f+q3fWnzHd3zHFY/5wAc+UJimWQRBsO1+PfXUU8XCwkLx5JNPyu8/8iM/UjzwwAMv4jtXFEVRXg7zxRNPPFH87M/+bPGJT3yi+NCHPlR8y7d8S2HbdvHJT37yRX3/iqIoys05T3z1V3914Xle8TVf8zXFRz/60eL3fu/3imPHjhXf/M3f/KK+f0X5QqBOKeWmh6sMFy9elBUErjowMPaVr3wlfu7nfm5Xz3/88cfx2te+9orbtpbaPfzww7K98QoKvxh6yDruU6dOPW+bWZZJyd6P/uiPykqGoiiK8oXnpThfkDvuuAPf+Z3fiVe96lV4/etfL8G1/P5v/s2/eQHvVlEURXm5zBO8j2WCv/iLvyglhW9729vwkz/5k5J9pW4p5WZHg86VlwW+70u5A79++Id/WKyyLJn75m/+5hdl+/1+Xy4YWO+9FXbn2Eqv18MnPvEJfPrTn96w4nIy4eIKu/D94R/+Ib7iK77iRdk3RVEU5eadL3aCFx0s51AURVH2lpfiPMHSbpbttVqtjdvuuusuubY4f/48brvtthdl3xTlC4GKUsrLkrvvvlvqwXcDB3SuhkzykY985IrfuULy2GOPSaeL3cDuSY888sgVt/3Mz/wM3vOe9+DXfu3XcOLEiV1tR1EURXl5zxc7wSwSXoQoiqIoX1heCvMEA81/9Vd/VQQtOqvIU089JQ0xDh8+vOvtKMpLES3fU25q2J6VjqNf+IVfkKBAWl45YDME8O1vf/uutsHueE8//TS+7/u+T9px/9Iv/dLzLLrf//3fjw9/+MPieuKFAh//W7/1WzsGEnKCuPfee6/4Ylclrrzw51qt9qK8f0VRFOXmni/IT/3UT8ljnnnmGXzuc5/D93zP98gixt/6W3/rBb9vRVEU5eafJxgLMjs7i2/5lm8RQev973+/vMbf+Bt/Qzr4KcrNjDqllJsarhSwbpu5G+xkkSSJtFX99m//dvzDf/gPd7UN2mR//dd/HX/37/5d/PRP/7SUTPz4j/+4DPJj7r//fmnD+kM/9EPSvpVW2ZMnT+Ibv/EbP4/vTlEURflimC/iOMbf//t/HxcuXEC1WpVt/PEf/7G0ElcURVH2hpfyPMF9+6M/+iP8nb/zd6QLHwWqd7zjHfixH/uxF+W9K8oXEoNp51/QPVAURVEURVEURVEURVG+6NDyPUVRFEVRFEVRFEVRFGXPUVFKURRFURRFURRFURRF2XNUlFIURVEURVEURVEURVH2HBWlFEVRFEVRFEVRFEVRlD1HRSlFURRFURRFURRFURRlz1FRSlEURVEURVEURVEURdlz7N0+MEmSz++eKIqiKC8JHMe54efqXKEoivLFgc4ViqIoyosxV6hTSlEURVEURVEURVEURdlzVJRSFEVRFEVRFEVRFEVR9hwVpRRFURRFURRFURRFUZQ9R0UpRVEURVEURVEURVEU5eYQpYqiwPLyMk6dOoUzZ86g3+/Lbb1eD0EQPO/xeZ7L1+Tz19bW8NRTTz0v6JDbGAwGG8/j6/Dxk/A56+vrG7dnWYbV1VX5PU3TbfeXt2/djqIoivL5g2Pu0tLSxlzB+WHrOMzfOX5zHN/tNnf7eD623W7jySefRBzHz7vv8uXLePTRR6+YT673dSfnn8nX5HYvXbok8xhv2+37G29D5yxFUb5Y2M1csdvtcDzmdcLkuLwb+Bxel/D6ZPJ5HLtXVlaed83Bsf25556T+3aCjzl//jwee+yxjWulq8HHDIfDXe+zoigKvtidUv/8n/9z/MzP/Az+23/7b/ie7/keGcg/+9nPyoTCQXd8Is6v3/7t35b7x4MxRacf+ZEfwS/+4i/i13/9168YpH/v934P7373uzcG53/0j/6RTACT27xw4QL+w3/4Dxvb5/b++I//GKdPn8av/uqvbtw+fjyFrv/0n/7Ti3G8FEVRlOvgx37sx/CzP/uz+C//5b/gH/yDfyAn3JPjM/lX/+pfiZAzOW9snUcmv/7gD/4AYRhu+5jJ7UZRJHPI//7f/xv/83/+zyuEo49+9KP4x//4H+MP//AP8X3f931ycbH1dcaPHS+q8LHji6Xx6/Di5Kd+6qc2Hk+h6/u///vlsXzvnJsef/xx/O7v/u6272W7faeAxvl1PPft9Lit71dRFOXlOldsHe92+v1f/+t/jcXFRRmDr/a4reP8L//yL+NXfuVX8MM//MMyv4yhSPVP/+k/3Xgs5wBu++mnn5Y5hIsP243F/J3XSP/u3/07mbO+93u/V4S3q43pv//7v48PfehDOrYrivJFh32jT+RA+Tf/5t/EiRMn5OT+537u5/A1X/M1ct/HP/5xvOtd70Kr1cJf/It/Ef/n//wf3Hvvvfh7f+/vwbbLl+x2uzh48ODzWgTyZJwn4hSS+MVJiV8UsDjJ8PXe8IY34NOf/jR+/Md/HMePH5fX5f685z3vwTvf+U489NBDcgHAi5xXvvKVaDab+LVf+zW85S1vwe233/5Cj5miKIpyHXzbt30b9u3bhx/8wR+UsZ+rxjz55hzx1//6X5exmhcjvBD4zu/8TvnOBQaO/V//9V+PZ555Bm9729vk9j/90z/dWNX+H//jf8hCyD333IOv/MqvlAsAPufv//2/j1qtJvPCeK5xXfeKfaJQ9MADD+Av/aW/JCvzvADg6/CixDAM/JW/8ldQr9fx3//7f5dtfsM3fMPGHEWR69y5c9i/f7/MP5MXMLxA4Wv/1b/6V8XtRLGLFySf+tSnsLCwgPe+972y3enpafzlv/yX8f73vx9HjhyR+e53fud3UK1W8ZrXvEbmrPvuu09W4f/8n//zch/ntt/8zd+U1+B+88KIz3vrW98q93G/FUVRXg5zBR2s/+t//S9ZcP7Gb/xGvO997xOBiGM9z+1/4Rd+QcbC173udXjjG98o1yG8n2LRWOz55Cc/iQ9/+MMiBvExr3/96/Gf//N/lnGcY+13fdd3bcwN40oP/j45lnJu2FoFwtt4ncHFc27nP/7H/7jxGm9605vk+VxA/8hHPoJ//+//vWyT10oXL16UhQqO35zLeH3yuc99Tty8vE7iQgrnjc985jOyfc4l3/It3yLzhaIoysuZF5wpxYGXQhEHY04EPKnnAPzVX/3VMgjT+cSBlgO1ZVkySXBQpvDE1YD7779fVpon4Qk/nVT/7J/9M5lgeMHCiwpeFPBChpNAo9HA3/pbf0subujQohDGE3iemPNihRcpX/u1Xysn9tw/3sfviqIoyt5BQYfOWgpFHMs5Z4znCM/zxC3Lk3AKK7zQoNBCwYeLCK961atkUYMXEDyB58n8+OSev7Ms4u/+3b+LT3ziE3j44YdlHuBFTaVS2SjP48UD3bcUejhPEe7D29/+dpl7vvu7v1sWPfgcOnA5z1AA48+/9Eu/JPPXN33TN4lwxdelSMQLiXe84x0iKHGOmoSP5/zzAz/wA/gn/+SfyAUL57nXvva1IpDR2ftn/+yflW1xH5944gl5H7xQ+uZv/maZw3zfx1133YVjx47Je+LjuBDDizSKWhS8/uRP/kSOBY/jWNBTFEV5ucwVHAc53lGQorjEMY6LABwrKdhw3OQ4znF6fG3w7d/+7bL4TXGHYywXLTh/fMd3fIfMJb/1W78lotdf+2t/DR/84Ac3Ij/4GL4mFxC+7Mu+TOagydiRSbhtjsucU77kS75EBCTOJV/3dV+Hn//5n5ftEM43XLgYi1ycAzg/cL7i3MSFBs4nvIZhxQmvXbhtfv3bf/tvZQ7kwg0dXOqYUhTl5c4LFqXGJ/4zMzMy6HLSYA4UV4U5sB46dEjcULz4GK880JpL19Rf+At/QSYGriRPwtv+5b/8l3JCPzs7i06nIy4oXgBw4uBrnjx5ElNTUyJW8USd8HU4+PMigU6tj33sYzLIUwzjfWOXlqIoirI3UJT5oR/6IRGieEJOgWhyjuAYTucQBRheLPC2s2fPStk3Fzo4hnNlnCIMn8OLgPEJPxcaKBBxnuFFAbdx4MABmGY5tXHlnBcpFKroyOIixmT5Hi9UKD49+OCDcmHDiyK6lujApYBEdy7nGt5GVxXhhQ/nIr4Pzndbs6K46s2Ve273W7/1W2UFnXPQeA684447ZNV7vJLPiyJ+cTu8gKEQN3YR82syx4TMz8/L++S8S5cAjwmPq160KIrycporuPDA83yOwRzvOW9QDOJ9XNzmmE8nEgV83sdxkdcMR48e3dgmx1w+f25uTq4BxhUXdK3ya3LcppjEBQq6Yzl+XwuO6fziOExxidccXJAYX+twX3h9Mi7D5r5z8YSL9Fx85/vl3MDxnuITHVZjQY3vlwsRXMTg/KMoivJy54ZFKZ5E04XEE24q+izT44UAB1a6knjSzRN8DtgceHkBMF6R4ATB1QhOALSmTuZNcRscpPk1/pkr1Lxo4cDMbXI7nKy4ysBVZpbk8bFcVaEFlq/FixROCLTc8j6ewHM7iqIoyt7B8fo3fuM3RCBiyRwFoPEcwRNuzhFjEYkn8/ziBQIvPMYn6BSauCDBMZ1zDB9P9xHLMliyze3edtttMl9MwrmG7ipeMHAOmZxrOJf86I/+qIhfvFjg9u68804Rp3hhwt9Z6sEyQv7OFXa+Li9A+J3bHs9H4/0nXBj5iZ/4Cbno+KM/+iPZJufARx55RN4vH0uxie+HpXh8D3Rpcc7inPqTP/mTePbZZ6Usj04AXpzwcVxN57Hhe+R3XtjwvVCk4sLN1vJERVGUm3muoHg0HtMZ28HxjsI9hR7+zvs4blKQ4kLABz7wARnPOX9wjORYO/5O+J3jJt25dDRxPhjDcZRjO4UlXpdwmxyDybgUj2IVv3gtMd42v7hQwu+cpyiUcU4jhw8flv3lmM75gEIXF/C5D7x+efOb3yyLFLxuYVUJsxU5L3CuesUrXiFzHRc+tsacKIqivBwxil0ur052yeNTWKbHk2VeNIxXuDmI88SYgzUVfpbY8cSeAzsfz9IMTiIcdGnFJVzh4ATDlWkO6twmn89VDU5QtN5y1YOP57Y5SI8nD6548EKEv3PC4ATA1+XjOchzhYUn+9w2xSs+jpOGoiiKsjMv5CR461xBtxPnBo79HJs5BtNtRIfPeI6gM4qLDlxEoHDDeYUiDG/j82655RZZWOB+UZjivMD7OO5zbrn77rtlzuDqOeej8Uo194Wvw7mEK9i8YOC2eD9Xrzkv8AKDcwQvDsaP52vyooDfuR/cJzqYOO9w/3kb3xtfk/vDBZbxHMbbWfrBiyrOQRThCEs8OEfxPYznLB4b3sb5k6/FeY7P4b7yPi60cD8pTnE1nRdg3AderPF16PziseW+8nmaKaUoystlrqCgw7F+PLZyvOb4R9cqx12O/Ry/uYDBMZRVFxxX6YDiPMDH0knL53J8ZDYVS/Io+lN4YvOLn/7pnxYRia/P+7lNjr+cizg28z5es9DhNN5fLkhwTuA4zusb7if3neM+5zPePp4Lxs/lHMHFGD6WP/9//9//JxEl3A/uM69ZOI9x7uMXjyvnIi5ocA7RSg9FUV7uc8UNiVKKoijKy5cX60JDURRFeflys80VFIBY4UFxik6lr/iKr9hTMZ8LJOzWSiGNeYC6kKAoyhcDjopSiqIoysv9QkNRFEXZe262uWKc5cevcQneXr8+BbEvxGsriqK8lOcK9YMqiqIoiqIoivKyZpwD9YV8/a3Zh4qiKMqL0H1PURRFURRFURRFURRFUa4XFaUURVEURVEURVEURVGUPUdFKUVRFEVRFEVRFEVRFGXPUVFKURRFURRFURRFURRF2XNUlFIURVEURVEURVEURVH2HBWlFEVRFEVRFEVRFEVRlD1HRSlFURRFURRFURRFURRlz1FRSlEURVEURVEURVEURdlzVJRSFEVRFEVRFEVRFEVR9hwVpRRFURRFURRFURRFUZQ9R0UpRVEURVEURVEURVEUZc9RUUpRFEVRFEVRFEVRFEXZc1SUUhRFURRFURRFURRFUfYcFaUURVEURVEURVEURVGUPUdFKUVRFEVRFEVRFEVRFGXPUVFKURRFURRFURRFURRF2XPsvX9JRVFeaqR5gY9fjjFM8+ffaRjXtzFjl3de52blCdfzHD62GD2tKBX4GnIcMiLMmOuwzQBAjjzLURQFkjiT76YJZGmGIs8xCFJ0gwSmaWG6WYHv2jAtA0GYIogz9INIXsqyLDRrFdQqLoK4vK/TDzEIY7i2Bcs0EaUZ8jyHa5uwLas8rIYBwzCRZDmyLAMKA1mRw+Dtcrex8RjuG29zXBf1ag2ZO4UVq4HQsFHIGx29X/5v9OsVFM+/seYYePXBCizzuj8MRVEURVEURVGUF4yKUoqiIEwLfNu7V/FsO32+dmQY1EpGN2/eUVDIGP861jvkJqPUgowJbUQeN97IxsbKnyf1EKpHm79cqUEZz99WscXsKfu6sVmKOAXMAnABzOU5Xp8P8Fe8x/CK2ofgGsuIwyGiMEFEkUkEJBOWkeHSpRWYloUnnl3D+x5dRK3exNd96R2YbVVQq1ew0gmwPkjx1JkVLK4PcHapg/1zLdx7ywH4fg1LnQCnFrt47OxlDIMYjmPDsS2kaYogipFkGXzHhu86qFSqIjQNhiGCMJGdp0BlWqYIY47rwXY8eV9pksDzfRw8eAjThx/A4/vejI83b0FkOiioJ+YUpIqN76LL8bvoVKP75IGlcHXnrIcPf8txVFWUUhRFURRFURTlC4CKUoqiCDkM5JOCkXwvhaFSlNoqIE2KS9e4f/K2bR+7Q0Xx87Y3tj5d+YBSitq8y0IBC7kMcC4MNPIcd+YJXmet4FbvcVS9HpJhhDQMMehHMC0XzWYFw24XURTDtQx87pnLOHV5iNlWDX/urffj1iNNuF4Vpu1i/kCBKClQq1XwoYfPAO0I59dCdIKLmGnW4DgW6hUHr737BM6t9PD4qYsIuz24ti2uqzQ30O7HcKwUtShFq1lDtVIRLSmOYji2KT+nWYY8DGDbFlzHQ55lGA76OHfuDLqDAAvDDCeOfBWebB1DZtmbx5aHkYdk87BsGqUmRL2Nz1tRFEVRFEW5Toobfkpxo8+/4vx3u5u33louRG59pS2n0jdQwjCxxdHp+fO3fqPvb/uX2RE9n73pUVFKUZRSzDEN+RrPKyJEjZxHVwz224lRE9vZ9nEbLqmxhap4/gTyvN83b5MyNk6oo9ccv7Q4oaQ8z4AlklYhg5oFAzZM2EUBxygwZxS43Yxwv3cW85Ul2FaGXjBEbxjBcjxUKw6iIBQpy3JctKYdTE/nePziJVi2heMHKkiiEKdPLyOM6WJyUW/W4ZoFXnH7YbzuwVthOT4ef24Jn3jyLBq1Cg63msgMA82Ki6P753Dm0jLWugNM1Vx4lgXPtuQ4FMgxGA7E0VT1KTylSNMMpmnCcVzEcYRo2IfTtOD7jsiHaRqjs76COPsYDiUmogOvx9nWEcR+HTDsDceYHKR85JLiMaRJyhgJf3KTTuKKoiiKoig3BM+limh0bjVaPKUjnV+yEGvJfYasFuYokAFZhHSwgs7aEoJwKNEOXLDkV5YViJMESZLKuVsZ4zDaLM8ZC8h5aaPeQKM5Bdf1YdkOTMeDYXswLB8wHYl9GD+x4L5kEZLBMgbtFbndrzXgVpqwvBpgeTBkP684ub8KfH+j7RbZ6Ivv1xydg/I7v7ZUPGykTOxOqJLtS9VDDuSM2kiBfFTRwTP+0WsUVnVrbYVyE6KilKIoG6VwVwhR25Xa7XTb+PdJthOytnVM7SRqbTq1+FVWCxawaARi9hOneKMcxKwNh1QpTtEpJY8dOaXqAI5bPRx0L8J1Y4SDPpLCQmN6FsgTJFEE0yzguQWCQVlGZyDDXbfsx7Ejc/A9C6vrKbxaC6abinOp3RlguZMgh4WK72JtvYt6zcOXvepOXF5py8kEy/ZmWjUYtoMMzI66iIrvYBDEG4chl8m5QBRHMA0DvuehlwxQsITPduCOhKlg0JMyQtsykKYF8jTGsL0ML/0gDg+7GBz5SlzedzsKvyqTtQhT3DYPkkSFjX6eWL0al2UqiqIoiqIo1wfP4PLhKizRgEwUWYosGcpCpu3YsCtNGLZfilMUWdIhov4alhfPYml5GXGSiTOeJ2Qiv0gCQ4FcbtxcxyVy++jczbNttOo1yRj1PAeeV0G12kR1ah/M6gxgMriiFMKMLEIetdFbPocL589Kzmmr1URzehbV5hzs6jRgV0TMGp1xX1HBMF7AlHPKkegmAlEaoIh6yKIe8iyCaVdgV2cBh0KXU64kX3H+v0Pm6Zb3OX4NgwJUnqLIIhRphDwZIk+CUsSzHJg8rqYLo+ah/ACUmxkVpRRF2YSrDpPj+ngy2cgcmiid2648b8vzxgV3z3+8scUJNbb+ljlI4zUlvqx8F6FpLDrRHWXCNMpEKbOgOCWS2uhxDAY3JEuKz2Ea03EzxV3uEqarq8jiAaIoQ2t2HnkSIuyHQJ5JlhSQYGW5hyC1cHqxi5VejvvuPIgcLub3NTAcxBgGOZ4+s4I/feQc1nuBhIRTjDp+9ABmpqfRCzLUKlVcWGljyrJwz8lDCOMUBQUn18KzZ84joyvKcyVTisHqnOjzIkcQRfBcoFatYDAM5OTGsR0UhYM4TuAlvN8VQSofuZ6SoAu7/Qymp+/C8uxxpKhsik2l6jUSpmQ5j2Fgozu3CbVXFEVRFEVRdkmB3voSTIo0AOI4RL/fw2DQR6XqY3pqGn6lBsuykecZoqCH9voyVtfbsgDK/kJiZJLzQOo4XFDckuG68bWp6AR5jqTdR6c/lOY5bKpTr1ZxqChQN2yYbrV0aBUpiiRA3FvByuoSltsdeBazS0NkaYA8GaCWBrArLRgiTNHp5KAwrdHPFKC2usAoSA2R9ZfRWTmLtdXLCMNIFk73H7oFldYhwK3DsJyN7NfyPY2yTcfvSt7iyO00PnGV7NNUnF0FRah4gCwZIB52EQd9DAddhFEIz6uiUmvAcWqo+bPyWsrNjYpSiqKUjFWc7RxRG2LUNh3wxrlTE7+P2SghGz2vNEiVP5dT3FiEKvUwa7QLFJlEXJLpzBAnlD36XRxRY0FKXq68jfeWv5f7Q9cRtzeXp7jH6uJk5Sw8qysnAbWZ/TLRDvtrSKMISRghTxNYFmB7PmzkeONDxzAICxw/0oBfdREOuUqTwvNsnDy+gNn5WSy3h/jYo2cl1PyTpx7F4bkW5qZbsL0KWs062v0h/ugjj8D1fFQqPjzPw9zcLC4traEfhsiyBDXe7tJqXR5FilQUuoyqjyAMxRbtOjYSZEjiSFbEKp6HYRiVE3duIA9WMLX2KKpzt6NXaaJwNh1R4uAelUte0aVPTgB0ZUlRFEVRFOVG4OnV6lpbRBOWmyVsaBNT8EkxCEKEYSCLkJZlShObKAoRRCGiJBNBKssL+RJBisur1Hy2pGSMlxAp3IzPFbmYmRZ8fgbDyDA0DIRxAt+/LB2hvUpTGvYUeYokHGJ1dQkra20UeYbMyBCEEYqijzReRRQso9aYhes1YToVWJbHk+FSpHIoVLkb4pKU0mUBinAdgw6dV89icaWNKMlR9bsivu03bbjVBKAwZtGxxTXRUakfy/DkFnaaLsv9KH5RBJN3lqcwuP2oj3i4irC/iuGgh/X1VfR6PSyvtrHW6cO2bczNTGNmagZ3LdyDilv7wvwBKC8aKkopilJCNYRuoQ2d4ko3U3nT9vVexRWPGWsdFIc2nVAm8lHJXTm1ldlPm04ocTnR4TThjipffixMlc8rxadSgNoUtzZ3b/w7v3tFgZNGjIfc85h1ziCLh/DqM7ArNWT9NbazQxoOkSUJut0IsC3MzdbRG8SoWBkG8RAPf/pptKZq6PRzLMy1+BBECeDbHhYaDt70qtvwwCDFpXaAR56+gMfOLUt53+xUE5VqDd2owPKlS5ieqiNNmBvlY2F2Gu1uT04OGGZehDk834VtmuWxMQvYngXD8JEkmbxn5lOxe18cBbLq5qam5A7Im6ajqvMs5tZPY9Dch9xuoDDL4b0UouiWKrO3ynyp51dOKoqiKIqiKNdDgeEwwaA3FMc7S+wylp7xrjRFb5AiDAeSE8qOymlG4SqTGIZSkOJzyuQkKY8bhaeO3VEbUQzjVxt1VuYJnBjgy12QZwRFissra7LdVqMpnZ3ZIIfOrcsrLBUM4doFbIvn45m47geDAcKwg153CZ5fg+tW4TgV6frseC241RlYXmOUVWWVZXvxAPFgFWvLl7DW7ogYFmcFQrq2LlyEbbuYmg7g+g2YtlcuiqYJcinHo/OqzFM1TAuW7cJ0GHNB8cqQUr0s6iLsL6O9dhErK5exutrB6noPgzCWheUwyZFkOc4ttVHxL+H4qyJUmNOh3NSoKKUoSomoQaMvbHFHbXzboWRvnP1kXJn/xJK6zZyn8vaNn0eZUFJ2tyFEjRxQG1lSfEz5YqVotblyNDIEb9S6b7y+6C/MnjLQLICTRoij1WW49hCZycnPESGKuVJhFMkJBE8SHM9Gt5/CRh9ZlGO5z1UoC7npoBOY8BoN5E4Fi+0A5xY7eOrMEman6rj75BHsn2miWa9ittXAmcUOnr20jpVOF1W6uQtqXRaCIIFtO+j0B6XbyzIkpJHvj9lTXEFjVpbrll30ojhBlparYdxHh/vNsj2KWFkMx7VLQYvW7CxGMVzG/vPvR9tvYn3hLhjVBgpavzY+N4nMLD8vcU6NvhRFURRFUZQbIskzxBkXEHmedeV5FfOPYslbKE+9mBWVZmNBiud3ZbkeXVAbTZOf18luC5MVCZMG+BzoBRGS5RW0u104ti2iVxAESJIYDhc8rQyOmcMyc5gszUMuC5w8H0avJ2fXFNDoePLp+m/No96ch1tpwKQwhQJJ1ENn7SKWV5cQxDFSnkfzfeUpLq2syc4cGPRRr9fF0cRzWGajFjnPQkdHKadTCvArFVRrZYWBaVjI0wDhcB3raxdx/vw5XFpex2CYIE7Y5KcU9XgM+ZVlOdI8EhFQuflRUUpRlBIqPgwK3KZMryy5GweglyHi41K8cRneOANKNjNRPjcWk+gBGpfmjR1TFI7o3tlwO8njNn+f1Mg2yvz4nImSvc1ywJE4xUnPMOAaBQ7mCe72VjHlLkpXE7s+L8Hm4XAJSRggjlOZjBn6mCJDrerg7KUephoO1rox7r3vOKYazGiy0O0HMMwCzqyL6dYBHDu8D2Fa4PJyB8FiD5WKh8KwUfM9zE43YbkeLlxaknDLWrWK/mAoWVi1Wg1BEIq9OogTGI4JVt1TuOJ75f4YKcvuSnGKtzFrgJMv86VM00CeJ7L6RDGLK255SvUrhtt9DgdXHkW3eRipV6HytakUShrnxJlOuQS3139liqIoiqIoLyOYSZptONPL89lSoKJ4IjLMRoD5uGSvPCUTMWpSWBr/VDzfJTVmfNtGAPlIxSqFqQKDiG6iRM6Ly/PzHI6ZwaEgZRUiTpXSUI48y2UBlEKZlBMWXOzkVtl8Z4h2p4tGcxmNehMey/GYZxX0sLa+gv5wuBnSzvNU5lylGc4urWC930OrWoXvOaXbnw4vg+e55WJs6QpL4bk26rV1afLDxdokDrDeXsXSyhKWV7sYBOxInUtXwlLMK4W+0pWWy2LuTuHpys2FilKKomzWconFacJ5NL5XdI3SjlyKQ3Q3TXa6G4WQj0rsyjK8svvd+PdxGZ6EkG84pUq31Hi7G2LXZBneSK26skSv9EldYeoaBUMaFrdfYKrIcLfVx0n3LDxjDYbjw3R85Ky9QwGv4iHPQgzaMS5e7GJqtoWFuRrOLQYI4ePe+w5gqvn/s/ce4LJkV3X/6gqd+8aX00RN0MwojKRRRgQjIYFARJGDyFkEg23+xglsbMCAybbJ2AZkIcBCEkggIYTiKEyQJqeX37uxc3eFrv/321Xn3p7HSBoFJqn2fD3dXV116pxT99XZtfbaa4fqb3V1bnuqW+5a03iSqN5qGyU6qFJ6N9TmIFJ/NNXo3La8gLz4qjy/Zsyp2cGDOnPuvMJqqFpSswWUiizNZl1JmuRsqDRVjPNQCQ30ou/k2cOAAojKxR8rpk/APgBRYIezNLKFGJ0CIlT2PR1ruXuXFsbP0NbiHmU2KSYqtZvraJ5RPmll9b3SSiuttNJKK620T97QKDXWkatORyU5By9ZqloOQBmgkubsdzzq2c7vu2x2BzQ9HNsBrNz5HLhlYFderTogUOzP7EXaHvIQ+Od2BJqkBpIVLwAq+oNzSH9hRSUTC6Bub29bNUH8bmQlojjJUwnnkyoKHXN+2+ynGkwi1cJQ9bBqrC0LviJTYaX22DfWeDLWoN+V58GASkzEvD8YaTCcajJNTKtqF8jLga/Efba+Oo2q0h7vVoJSpZVWmlnFqxgLx4CgImd9NxVvN/0uB5S8f6T/5FL1dphRxe+5dnoBQBXncsfNg0/8f5cJlR+fby0gqSLlzBhRO+mCOwlpRVv5d2pwHMxSXRIOtFjdVFAN5NWauWMQjRWP+to6u6Zud6wwrKm9uGiaTtWqp0N7Gqo1GmpVUx2//6zOrMdqdBZ0+OB+1Zs1LS0t6fb7N3Tz3adVrde12Z9qazhWoxZYel6tlmkST7U9HKvW6Ghxccly9tsLbWNLMY7RaKhGo6o0STXo9zSdEZmaqV4L5Ae+AmOsIYqZWP68zR9sriQ2oXMfFtWM/PxYCTJgfmDRMaWx6qPTOrh+q7rLxzSr1ecE6Hfrt+yAUyVTqrTSSiuttNJKK+2TNkS87WVfXAqe4y8B/BRAVAGkAEbtsKR2qOy7oWAHaM1X4Hso2y1ekzvqOwwqA7fyzITQl7Gjqj5sqUy+N8/cghllMk+5wHoBKuWfd/sVz3I2VQV2v/nf6Fnl8hJkO9goinPnkhMQx2aaZkkOwqWZauFM1bCqwM+D2nkfUlVmqeJ0qjiZmkQFlaZH6EZNyWSYKYIltTN/xWeYUoU4fFlI+oljJShVWmmlmVFxrprNiip3DxYb303Ny1lI+XenGTXPetoVId/RgNrRSy8Woh0gyulGFaBVsTDPM6ocAwpz33OB811wakcQvRgH34FiVmeJ9gU91f1hnsYWNnIas1cxYXMWPhhJYVjRwQOtPHrjeWrVUoXBRLfddl73n5/qs150vQ7ub2o6GCqKMw2Gka69ZFWXHduvO4+v66Z7zqoWV3Xi/JatjksLC5Z7n1aqWt/YtJLAtRqVSypa6HTU7w9Uq9U1Q5zcr6haq1k1lgzW1CxREnqqV/MKe61mzfLno4jqKvliH8cTNesdS+VD6DGOp7YmM5ZZHFnVkr1bH9Gp/vXqdpYNbDRfYUc/atfRKDGp0korrbTSSiuttE/BLN6X5ezzHfJS7mDlqWY50wcgxZHVnY5Uvq87pkCFdr49mAO0k643L3zulM7dpsLfI3OhiuSElwNSwYWA1Kwy16eCtWXtOI2reXH1OSlSgsF8uCD10Al8uL5wJlLuQLioDmg+P19934r65C49Adk07wPzRHpekarHK05yQXMTg3d9Be8qtLnovxt+aY9/K0Gp0korzYy6F3VLwcuBp3n9pzwnPU/Xc8CQ04naYUsVuk45g8riKDtsqDyysvu+oxt1Qapgvm+ebmbn3AG1KnPvFxxTfLNFskgnbGczHQgj7WlQNja2qh6eFygdb2vc3dR0PDbxxWYzr0KiuK/BONPYl3rbY81mnm6+a0vXXH2pNO3pnW+7UxvdiU6uDzSJUhNmXFxcVHNhWS946qXqT1LddiJnT508v61OO9aevQdsHja3NtVZ6BgQRb58p91Wr9c1HSvS+Gaz1Gjf0+nUKNHMX6zExlUNZ2rUQ0VxaosyY4/jJAemmm2FcaIJC3Sa2Hio5jdLpqqNz2jfxh3q7b1UszDYFSpwCGHhERWZgaWVVlpppZVWWmmlfRJmKXgFM+rC7bmUeM6OcopTuZ4SIE9R6GcnO6BQpdrBpio7x7r2dtr+GP0BkAo9qeqrYEjNbJuTUs+JTAXIM/OKdMJ5TSv3OQewMPPZYeYTIC2QIMf22u3wXP8KDVNSAJMkzQPazBGyFL5vMhRUAMQhBbjTrGK+qWvGsaEspXAO2MsBtbzKIeeYeWX63hPFSlCqtNJKM1yiVqmo7km+WyR3gCnHZHKpfI4J5RbT3TQ+Rxd2AFXOeHJV9Ipz7WhIFQCVte9IzrvgFbbDgioYVg6ccn3Oic8FLFWU3qtm0mqW6nBtoqZ68gF4KnCnMiWjbU2HQ4vAkC43GIwUxdJyx1ev21N3JE0iT2lFqrY6uuuB8/rLd95hDKdpEuvc1kRxmqo36WuhNVRYXVenEerIof26aN+K2q227jxxXuc3trW2dl7LKytaWOio1++bnlQ1DBUGiDl6Gg76lorXbNTM7Qh9z4TXyaefJTlyZMCfD2uqqsFospPkSNofx5Dml6f1FcKUnpRRxS+ZaE/vHj0w6mnaaDz0BXcXrLTSSiuttNJKK620T8oMfAIwKYKjJlBegDeWqlcwmmauYNCsyDrwlGs8AdA4TSbtMpAAXtJC32k+S63Aq/6R4dIRmIUhVUXQ3CfwCkOKIHEuvO4qOlvbJmyeA187zK2cWp+fb464BTvJxlVsdOCZpSPa99wf3/HXjRZFWl/ulwJO0Ya8PF9wxvNGhWBrDkrlwN4O9Wsn6uzmFlBqh2lm73kan5crrf+TX+PS/umtBKVKK600s6on1VgvLHpRgE1zqXU7LCgDo/IKdw8SK58TMM81pHZxj3ltqh1G1NxnqnFcuMbugFA7DKrdqn9uXwdMuVS0PHVPWmZBpkJdOpaCmWkuzaZdZfHIMvkQa4w8X1nm6/jJDZ2vh7rysj3qzHwtLC9pPJ3p+kZd996/qSuveZKuuHiPplGmjX6i4+e6uuXuc7rz5IYeOLeh1Xaou85uaXFhQQudBTXrTS2vLGswHGsyGVu1PWM3Taeqct5orEa9qmgaahpN5VcovZtrDtRrnhq1htIEvajUGFD5XHoGYNEOkaK8JG6qiglGFpGrDMozVfioRpKqNTmrTv+spot7VQlxU3bnzakOPNYWcqvekqbGGqvX6wa4fTTRT/Zjfxhi88eyP5UN+YzDwu9JkjPJ5tu6sHrNwzXnPHEO2qWP7vt8P/hO265P7PeJ2oXHzrftfnfj/2h2YX8e7rk+lbZKK6200kor7TPFTIgbhAdfleCg4Ui7lY/dZ3N1Z4BEeWEgQCMrEPSglDhenoFF6DXZtlnuZzyUHzfn1Vgg09L1glxHKoAhRcqek28odKQsTW4ufW9eUwplLMdWcoV2nIB7zvwqmipS/BJjNBUaWXNcq1zLfFcdix1mtF4IqOeBVGYGnyoHpnJwqxhXhacJBOR3UxatXmDBSnNA2E61w9Ie9/aJe8mllVbaE9Ay1YiusKBVKg96Vd3Lyxe70KvYq+p5qvr5K+SzbeM3t5975YBX6Nr2XNtEiCoKABEKvSpbqIkc+fOf80hSYBGlPG3QjkXQvKgsYudRZt/r3kxV08eKFGicU6XTSDNS93rrGvZ6Gmz3NBnHWl5d0HXXHtPRYwd04MiKLj7W1mJrqlY40nIr1XVXruiKQ6HG21tSNFSQTnRoqabPuv5Svejpl+uLXvBUXX7ssCpeoOEkUnc00Vq3pzRFkJzSt5niaKKFTq5ZFUdRAY7kwvJJnCohgmQAy8yq8U2nUa7f5Xu5qGOaKJvFytLY9LBoh5x7AKog9MzJoWIJc4VXkaWJlf+txV3t27pLfjR8MCrowL8CSHws2WQy0b/8l/9S3/md36l/9a/+laIo2gFCHD3efX7nO9+pN7/5zTvbsN/6rd/Su9/9bvv83ve+V9/93d9tIvM/+ZM/qfX19WI+8/n+3//7f2swGOyATPPv868dWn4BYt12223627/9W/v82te+Vh/+8Id10003Pagf//f//l9tbW3Ztn/4h3/Q7bff/o/a+Wjjmu/DLbfcorW1tZ1+9/t9/cmf/Ikd3+127Twfqw237fd///cNQHuo87r97rjjDp06depBv8/PCduYyz/6oz+ydtw+pZVWWmmllfaZbAbwGJCUv2aFgLkBPIArcy983VowUz2cqeajYZoo8BP5Ffw4Xqm9B/aeg0o526mQxuBVaKC6atW8goIdVTNAarZzvHGeipQ3V8EumUmJAVOO6eTAqEJPagfmefAa78AgjiM4SuZA3l6mZI6B5QCk+WJGOwWLzKcgaJj7YjD/8xS9nEmVg1u7WRIWuC3GnQNlhR/lUiAfY8HV0j55K5lSpZVWmi0W3PQBpVzqXQVK8VyW105KXsFsyhlV/JcvXzu6UhSOM/0pR+GdW5B2tKXmgJF5kccddlReUhfbrc7nKuwVlT52DtxNA+QVZBXLW69lE/kaqgKKRSRmtssECcKqoslEXhabMLiX+oonY3nZVPfcs66NXqpkdlZhtaZJ7Omqqy9Sfxjr3hNbqoRVbQ9jrXQW1KiFGo0iHTmwT1vdnioZjJyqsoqf58pTdWQG2ynQQqet0Xho1UXQt2rUETgfK45iczZgUUGASeJEEQyptKBKRzgr+SzD7PJgqSDWnsSmBBaGviYTcutxQHzN2J4lqmqi1fWb1dj/NA3rrVxcoKiq4gQnH2vhJUCiG2+8Ud/4jd9oY+f7b/zGb+jkyZP62q/9WnNEAEUuv/xyPfnJTzYQ63d+53f0vve9T5/1WZ+ls2fP6tixY9ZWr9fTG9/4Rj3vec/T/fffr/Pnz+vnf/7nDcz50i/9Uv3UT/2UAYT33nuvvvVbv1W//du/reuuu86OoS0AofF4rB/4gR+wbV/yJV+iAwcOaDQaGRB1+PBhA6g4H/340z/9U50+fVq1Wk2bm5sGkC0sLGj//v3a2NjQuXPndNFFFxnIdMMNN+gtb3mLHc84ms2mjWHv3r167nOfq7/4i78wptill15qf6+AT8zFS1/6UjseA2SijRMnTujzPu/zdObMGRvL1VdfbWO/7777dNlll+n48eP6yEc+oq//+q83p/TP/uzP7JhLLrnEQD/mrFqt6ilPeYqNjfml7ZWVFZurr/mar7H+cP6XvexlNo7Xv/711v4znvEMm9/HGrhZWmmllVZaaY+UGaiT5d4q/ueOZ+s0UItUNn6zIKoJkaMnSiArm9Nncvly+M/4kcFudT5PStB/Au5x/jG+uOm35oFbiucYIOXnYFbefl4pzzGRAKNyQGr3ZULnO8Llu+Ll2G4grajS54CpbBdIstdchcHdgwufn+4XGRZZpQDJDFPicxEEM7Y/vjftzge9ck1b96zhzETXi1dpTwwrmVKllVaarZ3GigIcmWczOTbUPDPKsaLQXXJiiiaoWNllTfme6R3BeIINBehCWVqrBOK7xTP/7rbZeyUvWWusqjkmFG2w2BqzyhhTvHvFK/+c06Hpk9TyZqp7kXxNc+F0qtaN+ooGQ6XTyMCjdttX6CcKvVS97aHWz/V0fm2q7shTd+orbC8r9ju6//xQb37HbXrfrScUzTIrUxvHM508v6Wb7j6l9f7YFtq9q8vyQ1LspsZsCrxArUbT5gC2VK3mqd1sGPCUZYmhQ7nGVJ6CB7sKYAlQj+2WIlVAblGCE8F7aqCVy6nXLM3HTgBpBkPKkvetsh8Je83hGS11T0pJNHetcQp2SiLqsWSdTkc//MM/bGDN//pf/0t/8zd/Y4DUt3/7t+u//bf/pl//9V/Xt3zLtxgQApgC4BKGodrttgElJpZZGNcEIOl1r3udMYBwdgBaaI9jAWyuv/56vec97zEwBmYVQAvAEIAQ32Emwcb64i/+YjvWGQAQzCIAIthDMKHuuecefdM3fZOBX/Tpla98pYFDtL1nzx5r721ve5uBVBh9AMzCYF4BjNEeoNAXfMEXGADFeba3t01Un75wnnkDnPvyL/9yveMd7zBQjPmjv3fffbde8YpXGLBGuwBomEszpD0YXA888IDtB6uLzwBOGKAc42Uu6AP7M06uCwb4Fsd5aejSSiuttNJK+0w2Y0UV6W+7danx4fIXnwFWzLf1dllMAEoVIoWAMLPYfDcn7E01On5zFa8to8DPjB2fV8PGP57tpusF+MaAUbmoeS7r4ATDaVOKUylOiqp2ycwYTsaWMsFzB67NC5zvFhdyIJGJj1vaXqYYxhTvKW05QfJcoNyEzqm8N3NgQwFu7WhwzSxTALYVvi2aqtM4tcI+9BHieR5E3c1XNHCLwPNcILz0Qp449pgHpfIS6LE57y6VgyiuS5OY3+/CVAK3L+b0RR6qffZxx85/frzYhWP4dNhHm69H4tylPTpmqXIAPERaDGjKAai8gkeRlmcLagFC2W8FkOXS+CxKM5/C59rKU+/y7flvQYVXDjSF7h2QqUjjy8Gmud8rxW9Fup9blN1nojCMgd+NVWQpb2NpNlE67SsaDxVPJ4rGE3W3ulo/v6WtjW0NByPdd2pD291IaRboqiuP6rnPvExXX76qxXZNN1x/pS659CJFlZo+dOcZPXB2S/3RRHcdP697Tp7T2lZXcRKrOxwpShKjJAMQkTKIgCMABeNJorHC0DPAqVavWuRsxr8z0/LJjCnF3Lt7HvPYrAeqBZ5qIeMpUq5czr5RmRmzJy/P3ZMf5PpUAFMejk82Vnt4TpVZHi1Txd+hqe1oHjyGjBQ7GEawfbBGo2FADQDKwYMHtW/fPv393/+9ATDoTsFk+j//5/9odXX1Ie9XHANDyLGFYGE5cAlHC3CFex3gF6ALBoBz6NAhA6ZgRl111VV6//vfb0whZ8985jONbQXLCYNpxPp08803G7uIa07fnd4TnwGjYDIdPXrUti0tLempT32qnZvjAZIAntx+pCc6VhbMK8bo1jNngHGci/PQV0Cqa665xs7Hb4zhrrvuMmALY76YvyNHjuzobbGPVW4s7uEcR39gb7GdeYPpxby58wOycY0AwADyGHtppZVWWmmlfSbabjp8pjQpRM+NcURQ1DNtqED4s4XOU2U2V3kOECbVNJoZKGMpccayL4SeAK4KkMnJV+R+eZ6uZ9X1ilfOkEKHqRAjd2LppkUKGJUpAphK8/Q9l8Jnle1catyOlzmn3zRX9c4AKY51aXs7ulROesBV9ZtLr9vRqGK7A8kApXJwDFBqAjBl0hQ8V+avHZ2pQvBqR0d2/pHzseXGlvYpWCV7mGgCD0mfLttRzP8YIrbz+/7H//gf9aEPfcicbyLmAFSIB7/whS/caYcINA8s7iGBdnmY+au/+it7KPm7v/s7S6V42tOetnMMxuff/d3f1dd93ddZ2gXR7CuuuMIeGOb74Np8UDlOqJgPIQo73/78cfPb+c52tuWVCnbb/ljb5z+7uWM+eDAj5WV+XA/Vt3nE+6P1h208CC0vL9tDnRunu+nOXze+o1fyVV/1VfYgM9/nhzM/D/fvoLR/WhslmV71N12dHaYPEi/Pxc7nStb+o9+43vnvLsVvV8AcGvN89bxiQdnRNXL58XNp6xf8GeyImF9I6nEVTub+zyLMot+YpbpsNtIL9D4dqbxDflVKxz31zp/V9vqWutsj021a3xipXve0utzW3954Vvv2tHTDU4/o4OE9mo6m+vsbj6teDXXJxQcVp5kqYVv9capT60PddXxd3VGsreFEY0TMcR4A1KpVA0tYdDvttvXes/RBFv1YgY/yVU62xknY2txWv9e1VLxqlZQ+mFY4J7E96MOCog/MKxGp0TSfk3q1qlajrnarpiiONRgNbYE3AMz31Wi01F5c0XCc6HT7Wt1yw3dquudQ7tHkHG2b86uXQr3ry/arCWI4Z7TzydqnslZwzwDYufXWWw30IKWMez+g0md/9mfb/YJ7PSwnQBLmiPs8gBEsIe7xgDcANLB+AHNIgQPgITUPcAvWD8AQTCXWEUApwDCOBxDifkRKHvsCMH3u536uMYQApwBsYBUBYAHswI7iOMAj+kl/AIFgSXEO+g3oA8ADI4t/B7CgMBhbaFGxZtFv0vfoK+emv6xBMJUAhpgT7sescfSX8XMu2uAeDTuLtmFGMU7AI/oHGPXBD37QQCRYYRjnYc2gffrF+Vw/ue6MhXOxD9eSdZE22J/5caLxrBGAaux/8cUX236llVbaZ5Y9WmtFaaU9VozA4rvf+hfqbq7lHiu+rwUIA5OPsAJBFYCoVKGXKKzA1o8s0JhmOSsoigFncoAIZ5dgY+D7JskgL5AqgTJehVdsAFUBPnkeqYD5Z37FzasY4FUIg5smJGwmwCR8yfw7jKwdd/AhkICd500D17JdIGkmRfaes692NKSK9D3XVs4XKwLKxuh3lfmcUHkOTjldVQAqxxJz2p8G8pn2FNtyltYuUJVnBgRhqO/90Z/RvgNHHuErX9qne614xEEpTofALJHuH//xH9eznvWsjwlIsP/3f//3W/oETvF//s//WV/91V9tTjzpBjj1pGiQ2sFDDA8QPHSQ3kEU/Fd/9VdNiwRQit9x4nmoANDiwYeHFiLBPBig94FjzgMH/brzzjvtnKRG8KD3kpe8xPr+7Gc/2zRKePj8/M//fEup4EEDfQ/+seDgoxlCO/SDqDUPJLyIVKMZQn9IkeBhA+efqPsb3vAGu2gveMELLJ2DcdA+c8VDAOkcaHvwGQCKhyGMhwJ0TxgfDx48NPAQxfG8XvSiF1l0HN0RHsKY0//3//6fzR/GQwmpKFdeeeXOwwnzwUMGUXyuD/3gwYR0lJe//OX2UOSuz8/93M/Z+OkzDznojpAyw/g5N+9E8HmA45ywAXjApD0emphXHvhKe/RsnGT69rf2dM5AqZxtlINGxQK3U03PgVJFhb1iAcwXw13BxTyzvgCLdkCp/Fz22YFM3H6K707acAef2gGrcsB0Z1ux1Lpj3Fk4D7yU5izRVWlPz9W7tK9yo4KqFPXWNNjY1NhYUmNLvzt9rqdmq6ZLjy3pI/duK6jW9PSrVq3t85uR3vWhk9q7uqj7z/bt73zv8oJiebrz5LYmSUWtVlPDaSSS5rZHkSYxFfNmajYattgCTNUb1UIrIAeZraeeb+cnhW6COPr2tulMTSek+AUG7jo26HSaaJbO1GpUVQMwiIh0IYSZpwZ22jVF0USD0cjKugQBAFZFzRag1LKGo1gbSUe3PfvV2rjsqawKeeTN6hMXoNSXPnZAqcer8ffBPZ375/Of/3wDl+bXNe6B3N+/8Au/0O6RpZVWWmlPBCvXitI+0w2m07v/9s+1vUlRktyD5ZnRD4KcvW4C5aTZIbeQKNBUynJ/0RhScaYpoJSxowpxbx9Qi+wD3zRIKaZT8cJCNB2GfK4ZletG4SOT6pflLwvaFsz6ufS8PMWuEDgvNKUM5JlnM2EXPpLP60gZ40qKspzhZGmG+Lt5nZ2d8RvRwaUcFpkOlm5nhAT2yYElA6MsjXAXlOKzK66yw7wq5sbeCzDLgVJhWNX3/tjPaH8JSj3u14pHPH2P6O6v/dqvGSjiqvg8HAMgIfILAAOwAaAEw4moOCKwACqf8zmfo+c85zm69tprd44DdCJyDUCFNgYPDoBEf/3Xf20PEABcRLRf9apXWeSXfQGiAFiIfH/gAx8w0ASQhgg90XmAHiLxAEkI4JJ2weIK6MI5eKDkpgLoxLn4h/PWt77VtFDYjr4JDy6Mh4g0orOkazjBWYAa0iX4DNMLIIhIOKkntM/2C1NVSDn5hm/4BgN6OAf9fNe73mUgFMASc0ZfMEAw5o8xMz/MA2NhXBwHW4w+wUDgjwgQinmg39xoHypVEvFc+sQcMIdOA4V+cyzjB8SjMhb9Z/5pD3uo9kp75C3XiCLVzulJFZ9J46vkWlEuHS+c13+ytL4ijW+nsp5XbCt0paxySPagSnq2WBUaUUR6nEj6/EJr6XiWP18svMbacgLsAGK76XyWX59JjWymVjaVnw7yVLjxQMONDfU2tjTYHqheC7S4UNUVlx/Q8mJbi4t1XX3psp565aql9pEut7zS0Re/9Bl65tMu1g1PuVRPuuSo9uzdp/4o3UlrgqFkWXPoN1UqatRqqoWBouk4p1j7Fc0SImKFCGUB4jEGokacyxbUwFc1CNRpNw2AShFCx6mYpapXPdXroeXYT2OYVnn1kVmWV+3bFaCcyctwUnIh9xzPyyucVMbrWty+Tx4pVjuK8PndPysVIj8txj0XAJ578IWAFMbfzFd8xVfs3INLK6200kr79BlrIcxWWKYEey9Mdb5wX54lLsx8YBv+MX7sJ+KT8vDMMQ9H8uJjGc8AH6vf7lz40vOGr37hNowxEIR3Y2U/BwTyHR+c5x6Ywp+oD87+BNkJuHCOz3QLg8xevp+n2uUvV/nO6trZflmRJpc4fSe0QtOKvae8qOJnn7nWAEhSYsdQ3c9VtIMdlfvL+M4mE+GhWdq2c+Ti5bTF5/y7pdgZIwpQK7CCOfOWV99zek85wLTz2qkcnAuhA0HtMpWKVL85htSO9pTpTuWMKqc3laSJ+a556mCevpdX8csr+cWAU7yymVXzy19SXGhYJcq3wQNjPuzlyvWV9ri3RxyUApD4wR/8QXPQSat7OMYfOODPL/zCL5iWBwAVbB4AFEAXWEm8syjAbgJkcQZYhZAr7CYeDJzuBswc2uAFeMJxPEjwsMlDBaANzCn2B2QB1AFAgp3EOyAX2wHFuCmTNkE7pFvQtgOCHEDFcQBGgD3uO8wpQB5SQlgoqGTEIgGbi/66lEX0TUgpJHWDfQB66O/8wsn4mVsWLHQ+AKk4D8wp5o60RcAzpyPCcbQPKOX0T2B6kQrigKf5dvnOvDB20loY+/wCzDwB7jF2FlYWKa4PbbEdNhpaJ27+n/SkJ1nKB9/f/va3W3sX6oSV9sia03cyIXEf4GlO1wlgyQTH8+3ktNcK0Co/rtCjKsAoEzc3YfKiHdd2kQ9v74W+lO0DkEVUyCIqxbl2wKZd0MlYWS76gpaSsbZyWnBQCK83lSrMYlvRbbks6L7k+U8nMw0GE3tlMVpTI22t9w1gm0WRut2JQoAgP1WTbKQ0UTwd674T5/T2992m9a2eshjQaKZJlGowTtSfQMOO5WeJ6tXAACbTevJJeSWig6g5ZW9Jx8srB1Zr6Ex5iqdTA5IQPg+DitqtumbcM2YzVbkIGfKYUj0MbOElrY9SwEbBRvA8BehDr6BIx0VSE4F0i0rlzoKXxup0T8iLx0XVwh0RrjIX/9NoLnX5oZi/H+u30korrbTSPjUjhfv7vu/7LOCN5AeFLwBqyGoAPOEz+nf4vGQS/Ot//a8NgHI+Nz7rD/3QD9n+b3rTm8wf5Tf8bZfizXeCxATX2d/5yQSVac9lUJA6TgCZ41zgl2MIOLOdZwa3L9t4TuCdbTxH4EMDIPGcwXeeD3ieoC2C0/j0HMs2ACdYuK49p7WI8bzxYz/2YzZuwKcf+ZEf2dEXxF/4H//jf5hvTrsY53Hj5J2xsx995jP9JGDOeJi7X/7lXza9RfrDHDJe9qPfnypA93izViNVp5Wq1YQtn78a9VSNWv6qVTOFVSkIkXTwVQEUqri6eXm40iAsA58AknKAKilegC8GBBV5Art16fKshIPHrtahq16kanMhB29M84ljcyHy/HhPtVpdT7rqqbrm2meaxEQuMOpAp12waaf9HbWHooKfAIRcX3aSGXKRUrNC9anAiWx/ACZ0swo2lIFP9popsldecdp+pwKfAU05k8q0rgpALS3aykEx9iv0rajeV6JSTwjLVVgfQcMp/8qv/EoDpR6uk46OFDdB2DeAUtzwAVL+2T/7ZwYekSLHDRLQBZDIaVsAisDywUjHA4wBpOLmTYocIAlAFXpStElKHDdVwJ/v+q7vMh0OwBoYR2hpwJbi5g3IwkJAVAbtEBYkbsSUzuYcpPN98zd/s4FOgC6ATmijcJPnfLC5YGMB8rDAfNmXfZm1SQodKXYwvdD9oG0+w1xingCk2J++AOoAPtEG44XpBIDEO3NBf77jO77DHlABfzg/Cxdpd2zjOwsf/Xjxi19s80aUn0WM4xg77QIyMR/swyLMMVwDmE60Rb8A/Rgn/WQcpBHCiKJtwDH6xfzzG9edBQ8WmXMGuI70t7RH13KGE0ybvLLFTsqeYybNA0LG+tlNy8txjnxRyLGOXEzK0vzY6FL25tL6HqwRVSxutj66PTG30DjKb7HT3Kf8HJn8DCCr0D/zQlvc6Yv1w/dVb1Y1y3xFWaAkCzTGSRyMtT0YaP9qQ3v3N0wwfO1cX2fWJrr9+J06s9bX2iBVXKnK80PVAdvCirYGQw2nM1XrNWub6M8kmirLUtVrdStzy/hqtRwoNoHGCgKYie0PQNVsNjSZDg20glWVxpGq1VCNek2j8djAtkYttEV3GqW2KE+jxKjcVOxL08QYUwik82+a77gAxiDzPbuOMLnQFqhPtxWmkWaFwPnu1JYgSWmllVZaaY9vA2jiYRpZEDIi8Gl/+qd/2sAd5D7ITCAwzDu+K7Ic+KxkWgDa4L8jc+GkJf7yL/9Sr33taw1M4hnk53/+5+2ZAb8foAf2/7d927fZOQmscjzBaHxrjsWHJmCO5AfPKAA+PBsQYAa0wXenb/jzAD34y7wTcMYfpk/4zTybEFTm+QEGGIFmQCIAJcblxsfzAy/8H9p2EhzIhWA8P9GOA9IArjiW8zAnPFPg/yN5gs9O/+kH/jnnpf9Pf/rTDfSjfY7hmYtnBObRyZYwL/j9SK4QUP9MsEoBSmVxYmLlSeqL2CS4k2FPO0Gp3P/NZvhvvtJqRX6cKozRlKqYwHeewmfhRAtAZgQtDRwqdJ2KtDggP9hTs9RTvdVQc/GQ7vzIh9WsAUptF2ASAJOn2SxnN0EweNK1z9VMHZOr2H9wqF7/lh2mUy6VYTWcd4GqQiTD0gAFyJWnA5r+egGROfnx/DATxXqQj+kYXjtyGw5cM8F0GFROLN1VC3zwa5eplSNduXbVHKOrxKOeMPaIg1LYJxIxZj9upLyccUN0Bsjk7JJLLnnQsbCgnPYRoMl81SCMRQtjEbnQYPM4Y5Fy5nScAIiczacLuv7xj4e0P6cfAoOKmz/luwGJ3Pid6O18HzE0nJwB4Fz4mSgE+iQYD6QsKBf2mz6guUVbLFosEk5gnLGzoKC3xbzRH+Zyfj7njUUK7SmEbWnXtcVx7twAas4AsebNCccjwssLg3Xl5s5di9IeHeOv0bGi8gofuwLm9j1fInd+y4XNWcDy93mAysTPd/Sl5kCpQvTcisBdeHK3sLHI/OMfdz7nez0YlLJzAkjlInn5AhVHSuOJonhLk/66kigykIYDplGooLlkEZokDDUdD9Ve6BSLJl5ETQ+sdXW6W9EsbOuaJy0qrDV0ZqOv7dFUa/2J/LCqSjzVaDzJc//DUNVaTRHV/eKpavW6K3JnmgAAU/m/eRZ3i/Moq6QKAs/YTlbiFwZUEjPLqlVJ2UtM4DEvIEC/+exbKh96AEakYtxUPgx9TbK4SIGE2Za/O1eBtgGo6r40RWTd0clLTKq00korrbTHueHvA7QAGgFKAbgQ9EQqg4AqQAmgE0FkfFX8fvxOAtwwgPDV8WXxcf/8z//cJDy+6Zu+yYLYZAew3/d+7/fqh3/4hw2QIYiNwXoicM1zBeANfjJ+Om3znecB/OVf/MVfND+a54I/+IM/sGeB//Sf/pNpsMLwAgxCi5V+AAQB7qAjSzVax6gCtHKBd4AvQCDAIl6AXRxPYJzjMQAvfH+MPjNHGD48+zEWwKr//t//uwXL8VMYP745xxIcB6DjOQXGFt8BodDuJfDMswNBa56RIAHAIiPbgnlnXuYLMz3RrVqNVa9Nje80m+X6nkGYp8nlvlgevS3cXaUzz1hM9YSq7zMlScU0mnjBcMp4Ff4tMgsVk7QowK1CoiHXK03V6qxqcOY+9bsb6hw5bNpTUQRD36XR5UDQ4WNP1jhuaX2rq/0rTfW6W0oz/MHch79kOZOXznRiFJjOlZ3BCZLbe94nvi9XZzqymOpUz9P5YZH6VxTMenBabP493S2/l7dZgFJOPH23ut88GOWKZhWg2Y7gutteVNp+5JO+SnsigVKfCcY/TBYgZ9zInZj3p+MGzUPmxxPM5TwsMA/VH6InLoLyifbnwrZKe2IYWk9VmDWFuLmBUAUTaafiHkuA03sqKu/lgucFIFUIpO+AUkXbBR6zY/N/cjtRFltzPnbI48GQ1O45ctBsZil8NZhB2Uhhtq1Rf0PDrS1b4PzAV1qpaqS2Wq19SuWrWV3VaiVStT3W9uaG9u9vaRx7ajeq+qynrejwwRWFtabuOr6t89tDrfVGWusOVasGajUbgps0mkxVmUaq1asGEFmkiDTZMMgFJy39MGd6JUmai0EWwpB+JVNMumFIxAtOU6XQfMhBp2kUWXu1WojElIFRzD1Lep5mm5gDElZJ7/MtZbJa9RRWfYsmxTHH5+mABpB5FcvJhxYO+PcZ4CuWVlpppZX2BDf8a9hBP/ETP2GpfIA9AFMw8pHiIIOAwC/b8F/Zjv4U7H+AGUAaXrB+AFgAYtCt5aH5e77neyxVDmCK3/gMaEVGBewnQCeCxKQMIosBwwgQDJ1bUtyojk3/YDgR2CbQBIMKQAcA7dWvfrVlH5CZgV8P6MR+Tt4DqQ725Tf6zjkIjNMfAr7sy36ASQBP85VQaZNxYRzLswPHsz8sMQL17jmB/djOMbTB/sypS2dEVgRGFPu55w/mkWOc1i3AIH0iqwTmGADWEx+UyhT6E1WDsVXUg53kB6EJcPs+xWfyAP5O1fIdQKaoJlf4dqYfZbpSebpdju0UwJ5pR+X6UbkV7KWZLCh55ra7NFjb0nqtoWMXXaoHHrjHgCmHD7XaHR04coXufmDd2FjIRXS724VWVUU+TKruCf3V20/oumc/TVFtycAyA34AjpweVgEgLXtdvect79WRSy7SZYev0t1beTGfeY3gndS/Ha0p99rVqHLgU57y92D/P/9epALCCiuE2eeBqo9WObC0x6c94tX3SiuttMeeTZJMP/muvtbHOfsJwAmAKQeeCvDHBMcpa1uUuC2YUw6Qmq+QZ4vnHA71IChp54fdbfOL7862+f0fnED/oKYMOEPDiWp3SaKDyUiXjO/QpbO/VhDdp976hga9sWqNqs5uV6WVS/Xh+07qxtuOq9ms62lXHNOVR/aoEfe0vz3W3feva2XPig4fWVV3s6eTZyc6vTnRxmCiM5sjbQ5GpiNV8XwlmW8RoGwnZQ5x9rzDAEVsQ2wc54G0O9yJOIpyAciEyiIwuqaWwhf4ecQW3ai8IkpebpdKfUEAHTzQeJJqPM0rkpDat7LYNoH0aTS2NIMwqKrVbqve6lh64dr5DSVxotmlX6Cbnv8dCg4c1EQVjQtFy6s6gd71RfvK6nullVZaaaV9wvZYWSuMjZGmxiZyYI3TdHKgE785YIfPgDmwewBhOAZAZR7AgZ0EMMR+MH84FukO9oe9xHfWXYAejmc8AF0cR+ELjoWFBKsKMIt9AY3Yj30Akdjm2nXZB/SBfQCGOA/b6Cd9YhugG5/d2DD6DqsK2Q+kMpxxvFWC8337DHjEOTkH3zkv7CvOnVdCy3Vwc+Z2YuPi3Hx3+reOXcaLec/Z3DmoQD/YztgAApmrJzooReBv+95f1WR4UnGSM3h8P1AQ1uT7tQKUyq8tVZfzgwomkIEyeTU501Iq0vcMhDG/t6hKU0ErNH9ZeNgAnTz9bWHhsO679YRufsubddFzX6SnPP+z5aentXn+AXl+zrRfPXCllg9cp3vvuU/98VRH91Z1y01v12iaX0eu/VWNc3rzX75bah/W0593vTZSrjN9KSrlWZodrK6ZDnvn9cY/+2ud2U71Hd/wYg2bR3S2n/uuOVhUAFpWATA/Pt+WV82bB5bcMfjKeVW9ouKe217MCZX58mp8u9X32Je/x3/+Ez+rg4d2/+5Le3yuFSVTqrTSSpvTlJpjPgGwFPpQjgUF48fbERnP0+YcaHVBpp1bSndoxnnaXiHQaLjNrkbUhQwpl4H+j6ygP2dz7RkgVaEaYEWNSkX1NFIt3VI6WVPU31ISx6o3qpZel/gN9aaR/uHmu7Q2nCrb2tQD509rz9KiXnDtlXpa2FZjoaIwkI7ff16b21Od3RgrnmU6sndBe5abOrU+1CiR7j/fVb/bN+fOxMUBpkiTs1K+BvlbwjtzllYQeESk3FeFFElEySuATrFqVV8zq6QXq2m6VzgJqULPz+nccabRJFE1gO0EEJgpCD1Vg1wzysZOdcO6b0wtWFVhNdRsPMnTBtG3ypL8OATm0aaqIBpZCp2XVlpppZX2+DcH5pB25gwgZf77/GckNTCX0nbhZwwg6ULpDvfuwKt5VhIPXehA8cAMgMP6i74s7dA/V30VEAfmkzsGuzD7wLXvjpnvm5PDmB8PD+jo9ZKmN2/z/XNtuHfOMX9eB15d2AcApvl93Pt8284Ym7OPl83xhDFzVofyKn2FNj0EKH15lUh+ZWoBSUApIrsujW/eQ3bgDLIKppdUpLK59DQ7zir54ffOitLJRVU90yzdVL1VkzcZaRbH+tCNH9TnvOSztWf/JfKCmoE9QWO/KkFdl1x2ieLJQOPuPeq08I0pwpOLjo/8ZX3B512hv/jbk/rw+z+spz3rGm14vsgEBCAzvdkkZ23VvFxM4+z2SO98/x168RdfqrN9cgccw2uX4WRMKCeGnuXZBBeynBwrajfUnEdOnWbUQ/NndsXZS3tiWAlKlVZaaWZWwc5y1QsQCmaUEzgvUvhyrSn37nLcd9cSWxyyikVXPJ9o24NJUfmiOpcr/6CKHQXYtLvnQ1hRPa743Qmd+7NMQZyoPR1ocXxSjdFtmsXbmo6nGnYHSlJPnWVflbChU+fWlWQIk08UJamGE2kwXddGf6DN667Si667XF4w0bh7Wt3+WOvbPXXHsc51R2o3G+ZUnNvqajCe2mqZJnHuKFTQBEBLoJprOBXiAfwehKEBeEQoDfQzPShgIU8eYuW1UNPp2FIoFzoNbVufExNKZ5TJMNFwkprAObRrAKZa6KsacL5K4fRI1VpdfpUIZ6oI4fVZavNjuYBUKbQqi/mNP/cbHnuolItuuxSGT3eUFSfGRZqdxt6F5ioHuej4vKP+sWw+Kk3E+ONFiYkk81DycNu/0FyU3j08PFLG/DBWrpGJlSbJQz6gzLMhHk6U7OONh/M6tsG8uQj/R+tDaaWVVtojYfNADPf1R0ovlbWGNMXSHh3LMqobj3J/y7IHeLGOse4F1EW2VxFKzZlPxXeH2RBgzQB7AKWs1cKxhh1lLKl0DsgqtJpS2EXrOnzpdbpt3x5lvS1tDCPdfftxXXf90xSPuorTUHElUVhNFdTaCutNhUGki5INdbduNy1T04yaZWqtXqYXTgK97q/v1WQa6/Nf/HRVm4FVybZCR0HdmFInb7tH60N0T2fa6A7UrkvNOiLvBcup0HyC3ZQDS4U4eZFyuCtgnn/mOQOmmEleFM8gBHDRid0NYM9rVbk0wTJ/74lkJShVWmmlFWLYgB151bicGVVU2rOoj6vElytGAYqY9pQDl3YEDT1NAXpGsWqaaWUB+nIBXO2cyb0DUM2DUEUe+g7cNMeWyhGs3XYKko9JNmUS0E2rMlMLllS0KW90UlHcs0Wt2W5oOEw1GUVKKzNtbves9CysoikiobCRIircJXr7rbepEtb1oquOaRCFes9tJ60870K7qXNbfT2w3tc0nWkcs4DmugHoNnmzzMTOSd9z7CgDpUzwCpBuomqtYeKVVN4zMMQDlEqNXWXU7gwWVarAC7W80NZmt6c4ykGOZt3LK/SZFgDi6RU1qrxyxpQqABuBUi/UYBxpMJqoC7CVRFYNMK61lfmcA0YZ85VXY9md/8eGASz83M/9nG655RYDhKiehICsA0Cw3AnLNbV4B8BgGy+XVkC0lnd+490qMhbgCZ9//dd/Xd/93d9t4AZtuP3dsb/9279tYrh/9md/ZqkXpEi4/TiPc4jc+TgPTigVUUmdQESX6kjf+q3fuqNVQn8BVBxoxf60j7YfVYouBKaMzp+m/2icfHZgGlojROQRl3WgDL+7Prl0EIz+zp8fsMilXrA/xjFunhzzgM/zc+Ro84jeUhEKbRN0WqgKRfvs55xlzo9QMO0wLx+vj+i0MBZ0TC48t0vNoYos14Tj3Fyg8YKoMNouF4JlbrwO8Mq12LJ/NC/u78ultjzU9SqttNJKK620Bxt+H0HKaZFqxzZ8VtbYSNnM18wCviaIUZQN8pUZMJX7ujtVqY1Q5IrQmMirVAHUwscowKkiKAsW4/szYzrVWiNd+6LP08n3f1DtA8u6+647lCVjjYfb8hf2y6s21Gg01Wi2VK+3tNBa0OrB61UNehoP7rAeONmIq557nS67bV0nz27qgdtO6PkvulrNViy/syivtmKA063ve58qtZairG/raquV6cg+KlDnvqWrpGfpiKYHpSIND80sfD38WQdSsQ3fmDVdliKY621VTGcLCQvSItnf2jPtLRXHV+QH888YpT2erQSlSiutNDMDoBxDygmdO/0oV1mvqLjnBNDzaFAObEySVFvjmfr9ibS9obS/ruqTr9FSm0p0O1SpOX2pC1aRnaodBUuqqPRhPxXUql1Qyi3t/DZTdZaphqZTo6bqLFSIbzBONBmMVfE9LXRqthB6k0jjKE9rswfnPHRjx4+6iabxTH/3wZu1UG/o0k5bz7r2EvUHI93+wDmNJjN1J4kmcap6o65a6JlT4Qc5XR1gCe0n34Tgcw0uaMqwojxy5NOpperFgG3pSGGIGPlMgVVnCZVlubZU6AfGXF5Z7Gi72y8gOvYjrbBigFSzFqrZCFWv+cae8sOaMi/U+uZA59e7mkxizdKZ6qEnv9rUdM8VuTNSqSiCYk8fSOUrQMbHiiGaSqluhGERVIUp9Wu/9mt6//vfb5WRqGoEYATDCCFZhGOpXMQ+/I2RJkEJbaoK/cmf/Il+4Ad+wH574QtfaAAQFYSooMQ+lL/+pV/6JQMuaINz0t4XfdEX6Td+4zeM6YRgLfshngvYQQlwKjgBwgCQ/NRP/ZT+8A//UD/yIz9iwAnHAGRg6HAgKPue97zHKiBRTptjceAAqwCTAHU4nm2MzVWQ4m/zr/7qrwz0Yg7oN0K6f/EXf2F/uwj2AtohPEv/f/M3f9Mi5YjzItTrgBUEep0B9CE8y7kYI6W9aZfPjJ054jPzzwuQBpCHc2JopCDKy/FUV6V6KxWY2I8+UZKdylcI5wJ4MT/MGdWv0C1B7wR2GsK3AEiME1DpB3/wB3f6SH8or066yCte8QqrgoVxPrZz3TkOAWJSVRgDpdg5H/OBeDCVtpyeDP3hN45HSJg+MUfsS6Va/sYAtDgvVbP4G6JyFNed83NOxvuqV71qJ22ntNJKK6200uYtimLFUVxUx8vTSc1HJhhYaEqZtpQFeP2dbbsB2OLd6ataUkFebsgBUg9mW83JZPip0vGNuupZX6A0jXViO1Y/inXzHXeq1ahpIWjLjxP1hn0LjrZbC+r2mjqwt6P28lXydFpZspFX1kPf1FvXK1/1xTr1gXeruznV2974bi3WM4X1QONprN4o1m0nNkwSI/M87d2/omY70SFvOle8KE/5ywv7FMyoNP9sQu5pwZhy74VmVL49Z20ZQGWgFFIWBHf5nW2AVJ5mpBWi1+oTQHtUL39pnyYrL2NppZWWL26W5VUseXMV9xwIZQLohYj5zm/F8piXd5W669uq3/FW3RDcplo81Ptue6nCp79QrTAo9KlyICtnKhQnnjPL5svXY4dE5d1z+5qAuhOKzORTypbFC9Hw8UCd0f1aGL1HXnRGSUYFPF/TSWKAUKtdU5hN5Vd8DafpTjQmS9FaylSZZtqYAEx19bcfvEVXvPQF2u9nuuu9H9LJjaG2RlNVfIAghELjvKJdkZ+IfgCpctC1c5AJoUtSimLrLSl2sxnaAqEaNU9JnKriJfLRHSiE0WtZVaMxgAai6b4xttvtunqDcQFyoVklNaq+Wo1AjXpolfb8aqBKUNMormhza6TNzaFVUqlRhY/rVO9ouHBIzVpNYV4E0LL1IXXVPkqS5KNlDkwB6AC0ATwAnPmf//N/GrMJHRDSIXgH/ACAoMQ34AaACpWQAA/uuOMOA00AMXiHeQNTB9Dqpptu0n333Wclty+++GJ97dd+rR3Pb4BigBSwswBPAJ3e+MY3GoBByWxKefP3+3Vf93UGBNE/gB+XmsZvLvXPsbkcSEIJb8YEoHX69Gkr4c04AVVg/7CNMZFaiKE5AvsIQVx3DP3CGA8AE5WjOAdpG5QHB0zivJQyZ87mjXGwL0AYQBtpJoBwsK0AgQC9MAAaSooDqgFW0e4111xjIJ9jGzmhXipKoWEC2MZxP/qjP6r//J//8864OIY+ApzBgGJO3/KWt9h3AD4Aw3ljHgGbGCvnfsELXmBlx3/nd37H2GQwpGiTcTBnTqsF457CeWmDawxoSR9+//d/3+bqK77iKwxEA6jiRXukiQLmAXQBfAIK/tiP/Zix9bhezBHzBVDl5r600korrbTSnOFFbfdiTUf4eMgp5NIVvOdSGHxH8xMd0Jyti+/oWMIPquUDC3unYFABYJmGa6VgSj2odPUuq3oWK4zv1rWf+6U6//rX6Hx/It+bqbF/vzH603ii6XSiyXhgbP1GvW0C7ZdfdLHqC9cq7r9d2WyszKMudaRWe6h4b6DT955Rf2ui29YH6hOUTWZ64HxPlVpowdnlTlPPf8YxBf6mljpIWexqle5UyNvRhcolPvL+5tthUeUFq3Oh97wa4S4oZbpZxpLKwSp7T9DScsLnedZGtUQznhBWXsbSSivNjJxxY844oXPHjJIDoZyG1DxbKj+WZRVGVTMe6OKtt6nbf0CV+rI273iNhvuv0GXHDlpKWx5DyfJccTtyt+Sra2lHf9sYzMUJdqR/5thSLHJp3pegUlE7HqvRv0eVyT1KpgPNolRZOjPx8NE4lud7qmpkkaMx+XeGknESz+jP7DuOMqWVis5sbun9D6zpqv3L2hxltvhetLysjd5YU5gw9D9F8D1nGln0y2NxRVC8mjse3kyVgAjP2B6UoSkHHqBLaABTOpvI86o5o4r5zXx5caDheKxabUGT6ZQQmKXlUdqX6FC96qlZD9WoV1Wlul/gywsCA9nWt4amAQBDyvc5V64/VWksKGouqBbgAOVXAKYU1xjm1GPJAI4AZn7yJ39SH/7wh43xBPAAwALgACAF2wbwAICHbfy9uqpEbJuvMETJawAUnD/AKo5zuk+XXnqpgR0AM0972tOMFcM2l9L2wQ9+0PaDofWnf/qnBpRQOhtGkOsDoNcf//Ef61u+5VvsGl922WUGlgBkYDhatH3jjTcauAJjimOdgC4AHMfxzm+wmQB7AKNcKW/64tLH2OYqIrltjI2+8J00Q0A1gB/aoa+ARrQNsMbYmQeYQPSdfsAoAnxxJatpH7YV80BqHm0AUAEqAcKxnWvD+diX+aNf7EPlKUs3bTatj7wu7CPnB/yjj4BCd955pwFwAGP0hbkCmOPct956q7HaAMUAH9/1rndZv2E78Tfy3/7bf9vpN2ODmQbwddddd+3MKy/Ax7e97W3G0OJYQCvGwm8AmIBfgGfME4wqUg4p547RX8bDtbnuuuse1X8fpZVWWmmlPbYM//XkWqxed2pM9jD0TMbTAo7mRwNEJeaPVcOK6YHymQBm7kPmzPodvVUadYFhL0+lNyu0Mpy497zyFB/94JyW99e1Z7Gj+8/2tHJwnxb3HlajtWis/cm4r3g6QZDDPkfTkU5VAx098GRF/Xdrlm0pyCqqaUUbH3qPXv+mk9roxdoeT9SfJpplniaxVA09RapoMk317Gsu0VOevKSZv62qn2urOt3XPMDsosx5b3er7RXi5UUVwZ0xFSmE+Xv+mwOoHlyFDx86Z1blUgOPrQBraZ+cVbKHlrR/zJT5nteFwHBanX4H5kpDzv8+r1ExrwPhhnrhNsbGcTjNH083wqpZFU72R+uv0wFx+z9cPYqP1/ZHO5/T1eDYC9uY789H64M7xkX53bEPtf+F8/up2oX9/0Tnxv198DdBO24cH+saOCbDw5lnjsU+WSHix4tN00y//MGxtie5plQOShXaUQAYTlOqgJFMlBEwiGpyRSW9ZJbp/NkNHfvQryo9/vc63Qt0x7lEybO/Sde97JXa2wrzVMCdlPsLyvXNF+TLv80rpM8HYPJ3oijJTP54quXxUHuHp7Wv+3dqdt+ieLRp/a5VAYBY8D11lhpaW5/o3WuL+uO3fUi9ydT0r+hTbZyo1010Ns3UaFd1cG9V1152TF/6/Ofq3ltv0v0nT6s/TTVNZorSTCjw2F8Rc0DKnu+rXq2aMLkxlEIiYpRLppxzKlUAq/J32FbJLNZ40rXF1fMoGdwwOnI0zbS5OVCt1tRknJKZb7pQAE2Mf6FV01KnlY+L+6AfKkoDnd8c6szZTU2nsZI4US2UWjVf7Wao9KLP0x3P+QG1jlxklQHjrKLYUhcrungx1OtevE8NdKkeA2W+nQg5AAAAFICQA1f4DPAEI8eBOQAhLr0NQAZggn/fAD+wi2DAACjAVHLrCL9zHOwiwAuOgXn0kY98xNYA2uPfPcdyDkAdQAr6hVYU4BRMLcASwBRAGcAop3FEm6SJ0SbtAawA/sDc4RwAZwBE/PuijwAhjJF3mF70l3aZRz7TF8cgc1pWbIft466T28a4YIDRF/pw7bXX6sorr7QqTbQBmMTcAP7xmTlzqW7sQ59e//rX74BCgHSAQaTfwRSCYUVf+cy5MOaJMXFOWFdcJ87FmOnDvMYUc0u/XRogc0m1Kq4F8wNIBSuJsQDi0R4gFHPJfAOmkboI+wz2E2mX9Jk+ADKxnc+MifPyNwRAyHGAX4yZaliMB6Mt2uW6Mf+AVfQT1tS/+Bf/wgAr5ov+MRbYVaWVVtqjv1aUVtpjxShm8zu//R1aO3+XySkA2lhA0HCZvOIeukfVUGo2fDVrvhq1iskrUKwGnxgWPIFTJ5+RS2nkbeBrzgM0edW9Qn7Cnk/y13LnSTp2zY/r5P0P6Obbb9fy6l6FtaZVz6P4jSf0p/CReCZqmP/Z8ANdcXGoIHm90viUmrWLNLp/qDf8+Qf0njvWzY/On5iQswoVVGvqDofqjiP1x4m+7POfpa/6ykOaeOeKvuc6WLm/XrmgOFHuv1j1PSfmbuypmb14AMi1y91+OfC2y7bKtWXTWWqAVA5S0URVT7rhl1Vvl0L/j/e14lEBpZzDj+P58YABuvezP/uzFv3Ewfzv//2/W0oFxh86kVFSB3BOaQuqPlFmtn/VV31VzlAohvia17xGL33pS835dMcTVUbTg/2IgqM9caEIqjN3PpxnHhp21f/z3/iMA40ALPogOOakIJByMN/eheCP+0xknocFV61jHkS5cN/59ojU028izTjRzCvtOMCHlBPSTVzU2h3n2iI9BqebhyseGtxDEmkbF14LHlie+cxnmjPv+ujGfuFczB/nhIYv/J0HAqLyaJfMj/PCfbnGzDkPWPPn5eECceGXv/zlpjPitEh+7/d+zx4geeiaj3pzDA8cvPN38lBzO/+ZBxquOeksT2ShW0CpX7tpoq1JuqsnZQwgllQnfJ4vMfEsUwQ4jIg4aXkFXYoox2AUqXXHW3Ts/t/RqY2R3nTzhibtK7X36/+dnnLZEdvfCsHNg547QumuNxem7e1k7lmfnOi5itS9AFBqe017e7drtf92BcMPKZv0LHUOECYMfAW1qhZXmtreGOiD3f36g799v85uD/PrTMZ+L9Z6P9V6lqnRDLV/T1WH9nT01S9+sbonjuvW2+7QBMqwlQnxrJpeIsTR8/si3wGKACFM5ynEyYhUoSKLN5MfsKzHSrNEU8ur9zWabJn2U5JQOriuTKEmE0+bm0Sy8lLAkygxzaw4TtWqVXT0wKLa7YY5OF5QVZT6OnWmq42tgba7E9uX3Pp6WNFSu6J6e1Hdq79N9z7tFVrZs8eo4PQ7pUJiJl3cCfWaF+9T/TECSpX2qRl/z9zfuK8+73nPM7Bo/r7/cAwWE3/H/1RVo7ifs9ZxHkTeuUfPB5oezvEwpgD2AAcfznEAYawh7A8I9lB+B+0CggFcsXbArnoi3/NLK+3TYeVaUdpnuuFr/tdfeJVOnb7T9I0ApnJAKa+Sp50AJozhQK26p3bDU7vuGfsdAIuCQKSgwaSCbWV+coXnppn53KatZPpKmQVHp4X4N/4wx9dqFV155Cm64qnfp8Hmtm6943alyUTnNzbUj1taO7euweYp7d+3qMNHj6neWlGaSMutBR3bE6neulnT7s3ytg7p7/7mXt1076a6/a6OrnRMVoPxhJay11SCCtXalu46flZf+8XP03Ne4KuXAmDlFfPsWcEFsgugquKceAPX8mIpeYW+XUaUY07lMFiR71cAVTvPlLj/BUMqT+dj36quef5vqtG5+FH9OyjtU18rHvH0Pf4Y0ZxAFwJwCR2Lj+f4IUYK0EPkFacRej9AEgAE4qyInaIb8spXvtLALqKdtM3+pBMQff2yL/sy/Yf/8B/sD5uI59d//ddbNJXIL5HQl73sZRZpJZJNBJbfAKkAPIikk1KC40xEHMcWIyoL6ERU+Uu+5Ev0ute9ziLLRPNJ4aBPACKOzYOoLmKqGJFbQB+O5ZwAdUS1ie4CMjFP9AmhV44nvYCINZF1ABLSGZwBrCEii3NPqggLPSkIjAfHmgcAQCb6BviDkcpABB8QinEB7qChwThgJeCYMzf04U1vepNFxgGv+I12EL9lTF/6pV9qIB0PGKTKAMp99md/ts0b4BXXjoi6E+BlvLRJlSXmFaFegB/mi2sL2MX1YKw8OAA2Ma/8BthEygd/LwB9gGf8LfDwxFgB1Yiycy5SMfhMe+zH2Jgn2qa/zC8pQcwL88lDDvNGlJ+/G8SJuc7omwD08fDEA94T1fIicWgr7WpIPVhPKl9osDhNNYhS1agAR5WqgsFEChoC3PHqFWp0D+uy8JQOPrCl41v3a+sd/093L369rti/qKbvWbqdYVkXkKV2qL6OFTWXHpgLhxcy6GynLB6glAmcN1TvD1XL1uUHmaZ0Ks2rfEBHngL+xESHPDVDX616VWEwUm80U7XiaxZnGrEyFotonEj94UTHz5zVXnRqgkDjOLJFtVaHnZSX5uVv1ETTZ7CafHl+ZoBREMIio5xtrgUVhBXNssCciDhONBiODXQaT6XRiH5RVU2aRp6iWaDBILJ/9+NJonbTV7vmW5StQsqUUsvDDyqexlGqzW0AqbE5LaGJrOPcZKpXK/JXr9Dm0Weo0e6oAUuooLl5RUomlfhKe+IYf4+ALp+KcX/8pzQXEOD1yR4P4PaJGGsjmmMfr12ALl6llVba48tYL/ED8R3x10k3dkFN/EGeFwDbH8o4jiAyfj9+PT4jfvEna/iXtDOveffxDP8TJu8nkikxb4zzk+k7Y3dVTpmj0j45i9KZJvFM/swzFlOeEZCTEIzgw99BPNMwStQbVVSveWpWc1AKZlUthDkl+85nmFNZJddeMr/RXoXwdypF6CwV4lPsu9isaXn1mVJS0ebaKSXJVP3ehvl8b/6L1+r4qbMKslSf9+LP0fLKSEGto+lgoPPdddX9U8q2b1aQxOreOtK5fqag0dFSWJUXxOoOBjq7PbC+Ly8t6eDqgg7vW9XSYkcXH1nSue2T2phGO2mIBKrxf5mDagG4IQ/iRLAcKcI0pgpdKauqZyl7juBQgFI8FRhVi7l0ep0q5iMP2FKt8AqyHB7Vv4DSPh32iINS3HgBNwBi0PBw4qoPJ7IKoOBKfwM2AEYR0YTmD3gAUwbggFLeOJYuJYMXgASAEs4sN2z2o12AIG7ItAWYBFjEYgawxeIASAHgQuUhwBGX/kGKBO3j7JKCAMDDds4Nmwv7/u//fgOiMPpMigmViNDCAGRy50Q35ed//ucNBKIdnHUWR+YJkA0ABhCIxQPtDsdKcosdQNaXf/mX64/+6I9MwBdgiHZhB9EGCw3Ct5RBh0VFm7QDmMM1ABhizMwlAB5zyziZM64XoAx9A4BiUQcIcgASwrqAgYBML3nJS2zeAIfoP+3SHi+OAaCC7cTiz2fSYlx6HHNNP//hH/7BBIABlmBlAVbBOiNtAhCLa8F1dMeRkgGo5AAvXvytYLQDY4xrhXPA3xr9ZCwO/CKCDuAJs4BKXYgX0/arX/1q05vh74E5Awx8IoNSmFGGPVd1bzddjoXCCaHzDig1JE3M97RUJyXPUZ+kesXTaOWgBttP1970vJ51+aLO3Lipwfv/Qtuttu76nC/Wk/Yvq2X6RoVOFUKHO36bU08vmFJzGXw7lpcIMaHuQDM1k6n2jE5rJbpFmpzSNBqa1hIWTVP1R3Euil6dGhhD061m1RZNE1lUnpI3ZZw+DDEpjmbqDWKdWlvT/qOH1GwiJD5RlTL1OAnmDeQpdaTv7ernzKz6nukFeLCwyLFPVPH8vAwu1UVm0hDRdC9RkgBE4VTMNJ3OFKdExkKbY65Fq55XF0SPCyZWZkBUrLBWNV0A/i0RpctDSfncBF6mTrOiRrOuwb7rNdt7VHtadRtv0W0BoTEXoU3wQ01yaaWVVlpppT0+DP8YHw5QBv+UYgX4efiw+Nr4py7FG9CKQKzT7cMHhF1P4QUC5vi6rgAC+/LOC5+R8+A742e7zy4TAH+Sd3wBArhOG9ClguML4+fyrMD52eaeRchoIJODQDH7u3Z5PmFflxLNefFznQbfPLufIDlZEwQWOC/nc887PH+4fZkD1/4HPvAB838J0PKswTHMk8tEoI/sTxs8FxDUp488Y/CZ+X440idPdMOX3BHtNv8qZw0hD1Goluf7kWmQEFPNchBrTGXlnC2F7EKd9D+Y8Di48mw/q06He0oaINX88pCotQ/YxTlWFw+qs3KFxoNtbQ36SmapsaGWDuzVc14wUv3979M119+g65/xDGtjlsYGFPXOntKZU3vUWNkrPzujgRfb3/zxzS3NkkTRZKLRZKo7znXVjwM1+z2tDyIdXtzS3tW9+XimMKcyJUVqHhWniQsj7N4AeIP9FewWSrJ60oBSeJ+FmLmJmgNMWar/zHzlPP7sAtVFVWvlqYvTaKbxdGbZBBzzvLjUlHoi2CMOSgGg/MzP/IyBA7CVHo5xIwR0QvPi3//7f2+lvbnhclPkDxuQAVACwIObOedgIYINRLUdJyrLDRgwhBspQAYLDL/D1AF0AgCBHUMqG21wYwaQ4IbL+ZyuEIsBDCTALm7ktM/C4VhHvPjOwshC4IybOi8WSsAu2gb4QT8F0AMABTCHPrrFi4XIaXLQLxYIxuVS9Jy2Cv1z1DgWCVhaAFwc7+aK/gOk0TcAKhZpt5jyDqPJpVRyfrazsBJlQl+ENp0osBuDS+PjJsZ8oKcC0EcfGIcDorgepN6xuMFKYh8WcCcmDDsNBhXOAd/deJgD2GZcY46nH8wrfYER4BZ8riNVtBgv15F5cZWmMLYTQSOSxLzBomJcsL4Y9/wccV537ZywMI4AYwe8e6IaLCkYTHmVPUCjPDozTpKcSVUDgPIMMAEYqVRZInNGkOV9AzL5UrPT1Lm9L9Dy8FZddijRlQd7uuXEQN1/eI38aKzbX/QlOnpon1YavhoFoOXS+earkGC7+o4uHz1PEzTWVpoqnEZaGZ3W8vhDCqb3qOLFdnwaJwprDc3SieXSt9oNdbfGanXaljpn2krpTFEMaORrkGSKYF2FudDkeJLmTiaMpqBmFUeG40iZl8gLa1bNxOnZuXRaKunhXBAVCgOAJCrvTRVnidJZaBEu2FpZktOPWVitZG6Wb4/jikXCRtOpUbSJvMGOalTRIqiqgePnEyGKVfcaRonGaQi9mao+c5NHzJZaFS13pMryldo89CzVjCWVA3/4Ocwy6Xs4O1y70korrbTSSns8G3p8+JkEePHVWL+/+qu/2oAhQBx8zv/6X/+rBZG/9Vu/1fxBfE58efbFlyXw7CqLkrGA30hxAzIPyHKgXRf4xg/HP8UvJ4iKjwooxPH42XzHv6UPtAuAhI+JD4x/yjtBT7Tr8Dl5DiBQS/o1zwEE1nlOwa+mL/iiAE48O3FenjcAxXiOwQfhM2Ojr/iuBOA5P74rTH/ANmRQCPzyLEVgnH3oFz4u/aagh/N1AbZ4VsLXJmsEX4c5Ym54biGITZAYX59nuc90UArmu1U1LvRG7bmq0KVw0hdOdgTLGUIzGZYCAwgGe6EtZeLnlbn9K1Loe1Z5uRYCYpHil6e8zyw46mt1+ZBqzX3a7N5vlaeNbVTxFE26uvrJl+joRQe0uLJPnk9Af2bgTrWxJH851NrWmjqbT1ZWpapeVe+9a1NbvZ5WW74araYOX3yxkvaW3vuhj2g6merQ/qM6upfKtNvqDqRms62N3laevEBKXTbLpS4k1QKpVfWs6nRo4u95KiA6qW5ecnbUrmYWvjEMKAuIF6l7BLDzlEbSJQGjMo2nqSaTRAlyFBZxLe3xbo84KMU/Im6QvB6uvepVr7IbJDd0GCwARzByYAKxIAB6AKJQAQmwAVYNZZ0BSgCMAJfYRsobN39urE7Dgps0IAk31+/4ju8wUIaUP4AXwAvMpeyR2uYqQLEgsA0QgwWCm7yrYuQYRaTAsSCxYAAscTx9gbUEeAMQRjUgzs1Cx3fa4jjaYkFyrCMWTxYLABqYSQjFMm7GwYLIwkB6gqMnsy9AF30FvKHf9MsJtbKI0DZzyxzxYlHi/MwP7bAIsyASPQEQYp7oE3MD4MXCx0KPAVCxmNIGizzt0T8WXeaKz660OQwqGE58f/rTn26LKamMfEeEljmi34yLvgBU4Vhw/egPv7EgYqQIApwxt/zOzcsBdVx/HA/GjQPBuQHinOivExVmPxZcxkyKIO0DcsI+c+w8Fxl7IhuAEywbk2Ys/ItRFOv8cJJXcvOJeEhj0s+gmhd0XMudz+MZ9t0PfY33HdPm6EXaM/4jfe7Tj2p7eL/uObep3gfeqLB/Tiee/yUaXHaVDi/W1ELzyfLPc0nIXStEEi01MF/Enah6Nk1Um4y1ONrS4vSUqtOTCjRWQuparWqLXLVeM++g2ekYYCS/qsbigmZnE83ki8K3SRorSdF5KsrwiupjmaIY8fyapkm+4JFH7/tbtt8sTVX1gwLQzcUZXe58Xu6X91QVNKTS2EC8SUz1vIqiac6Ogk0VxSy8eeSIqBCOBSDgcEg6YA4Y0ZegnmsUVKuAYVK7hhYBUaapQi+xa5JUiUoh7C4tL0hhtaGtvc/ReO8lWm5UVcUJAKxz9GoWcQMidyN4pZVWWmmllfZ4NFc5FH8NP9lp1f34j/+4/vk//+c7zCj2I1gKMDWvcYLsBMAQxwI6Wfr8eGzPFPjg+JFvfOMbTcoCnVF8S/xX/GiMjILnPOc55jMC5AA64UMja8EzBJkM/E5gFH+f9hwIhB9KgBTD16YvSHLgb+NT48PjU/Pcw7MDfi9AG2PCr8WfxcfGX+aZA/1cwCueNRgr4+IYfHeCwQR3aWfenGYPbQKo4RfzTEH/kT8hcwDfmd8Bvz7/8z/fnl9c9sg84PKZaHk1PMeS2qkbfUHxnl1dYSfebXpKJvydt4Hlc1nIZpAK56M1lacA4ruGpL8JHzMPNvoVCnXsM0hsGk0FRx/zQ3zhimr1quqtRc2E3+prPOrn/n5jVXe+9/268R/eooWFji46kOie28+pO0pUr7fMWcwrR6e6/NCytjf2maN70YFlEV1dXV40dlOQhUriisZpDoYR8EX3ioAw4wJEgy1V9WF6MZbA/GhjfO1kZTAvefU90vIIGANK5U8Xxq0yH5dgbM6kgmmWajIl+yBPBSzt8W+POCj1iRr/KLmROgPQwNwNHCN9z5kTZ+Vmjs0f+1AGWAQYNG+AIQ9lTmTbGWALdNsLDYAGc6AWxo3bHc87L/7xAkixqLGQMA7GSwTjwrZY1DAHvNBHFj+ngzG/r2NHsVCwn5uT+f4DJjlAydn8eUmZwwCYnLEIObsQVMQBYPHk+tCuW+yJ7DyUuev4UNfQmRuXEynHLrxW7MPiTGTKLYpEdZyxUGMs/OzLNXNGVOpCc3MECIgRKWLcD1dQ9/FsRGe8Sp6SBs2WlLat8VT3r2/KDwI1Ql9LWVXd8VRrg748tW3xYTGBPpxPT65a7jVq6u57llZ6H5B/9lZ9ztOPqP+u4zq9uaHK3R/U8vZZ9Z72WZo+9UXas3efVlpVtcmjn8vem08qY6E3pzOmgkhFQTZTO55qaXCX2tHNqs9OWwqcV69r3O2rtdCQz2LqVbSwd9UW45V6TTNYU72RvEqoxU5dkyhVv5fk0aqCWg1Lyn1m8WNZXGi31WzURZCJMc9SqugF5kSYdlQRJ4MpZWyrLNI0HiuJI0UplfbyyE6vlyomXa9GtZHcYbHIERGgGfPvqdPIGWrDMZGkTBNoypNIsxmOAukG0LYnmsWRan5sguZZmkefGjVE16Vp7aA29j5FtYUFtcIwZ1UVKXvwPWeWNokGVZm4V1pppZVW2uPbAIvwdb/7u7/b/LZ/+2//rQE5+KL4ygSuCWDiy+FDA7Lgv7sMBIJM3/AN36Dv/d7vteMBbwjS4ne41DXH4Me3d2lsTmMWuQiAJ4KsV111le0LEwktW1j8nJvgcV6+Ps+omE9741kEEAxwiwAtPi02f16CyvjK9IexMQ4AMIA4zglohdQHfUdvFxCN/hDUpb+uLRe4xXjn3LwTEOeZiT4QyHZzx3F8B9xywX1S/ugLkiEAXGz7TNbjczpJlaJCnIvs4t8B3Jg+q7db6IoN5gMCRhWMIAOlnJCrfcz9NY5BMqISAdRIQVLRuGgLB67me6rWOtIsUTydWhQ3CGvKCCaHDfOlk2isKIrVWdynhcW9OXGBarZHLtK+I5fqxN23KR1Xdcvdp9SoV/XkK/ao3a4rmUXaWF+z63vxvgVVOFfVUyWrijIFEfqyFfRSZxbEtkq7BdsJYImxAzT1ra+51pZXyYv5OFnZ/Jkj/y3XYJ4pIYvBQCtTNrfPOYssL0WYi5znou8kNjpAr7THtz0q1fdK27ULq/t9utt9pICUf6pxfCLn/ljn/WTn45Gex0fLAKD+9+1T9aMclMK2R5E+fHpd95+4V1mtpaddcqmW6lXdfm5Np9bXtHd1j555ZL8uWm6pUShm59ymnIrLgtQ680HVb/o1RZOBNvqx/t8/PKCNQUNLi8tqtRfUOnBMC8/8Z6o9CR21tlZqgRpG8Z1vL/9k5W9ZwIdTddJIyxv3aU///VrovVX1MLaFMosnBhhRiSSoN1QJq/LrNdVWD5po5PD8ht5/20B/cdNpne2u6cz5rs6em6jbjUw4EsFEzlOr+lpsV/X0a47q+dc8WafvI/Vz04AdCp7ktUHylEKAnnoN562uTruhVqeiNF7XaLSmaRRpMqHaqLS+JZ1dlyaRdNFFFfnVXKuL9TaKPE0noWYZ74nObyaaTjO16hV7rS5WdeTAslYPtJWmG5qOh0pA0hKAK6nbSzUYAw7iMARKrvwanb7+m7Xv0GEt1Ks7LKl8CotqJ1mmQ+1Qv/CivSZaP29lRaXSSiuttNI+nj1W1gp8NQKyLrsAwMgBS7wDxiDnALgCCAMwAODiNJMwtiPnwHZAF/YFOKJt2Ew8yDsRcY4BPAIoYhuMKlLnOBcBXkAi2iFoSl/oG5IRDhSj3fkq5IBHzAe/wUZy2q4c55hI8+dFSsJYKcUxLjWQ/nM+NwbGBBjGfnymPcYMq4w54Rgr1lK0RT8AvRgTbc5raWGMj9851gnI0y720YTkn+iGrue//U/fqAdO3JEze0zKApZTXgwnl3hw0lK71fis5Ix7dCqkk3Do0IqyXYqqd4BT7rOT1sgLD+WN7lta0Dd96fdoZeky3Xv3h7U9jjVNUivI4yE1keYMwmqtYUwpz6vKD2q66aYP6iM336xBd1Oj7qaiONXp02e1urKoQ/tX1K4FumjfkmazXBN5MOhrdWlBi4sd1eptDXp9XXQYyRvpNR+8Xb0osn7z95oDUzkgB5PJhlhEYvOCRi4SzDcX2M0zNXLBc47JtxtWZwyzAuszllnOjiJNMAzr+k//4U915PBnLij6eLDHZPW90h5s/1RgxyMNojyaoM3DOfcn278nOhg1bzu57Cyyaa4l1R/0lJ2/X/HKUW1NoAVn6o0nikZDDVod0z3iiMCU0Ath9CyP6sAaGu65Rp0rX6b++/5I+5bb+mfPOqA3vPOsBqNQYeArOXmPJuuntXLPB1V55ks0PnK59nWq6oS+aVyZTlWRuseCRtpew0vVWj+pxdkpVYe3yYu6Go8GGnpNddpVVXyinhVVcAqyqfzqombR0BZKgLJxEhjzaXO8reXFqomhs7htbE2NoUS0po5eFjpRVplyrG6vr2kcybM8fqI6eTocC6Jn5X9zfS0YT6GHbtRYWRxpOkjV7Um9QaaNbkWjcS5EzvEsv+TYZ35FUVRRtUoETVpfz+eUCizmDNc9NetBofrumeglIuzb3Znl6+9d8hRUK9pezxlui15Vk/YxVRcWtFDL59EJb9KyvdiWVRSWmlKllVZaaaU9zo31GhBlnt3v9GQBqT5WZVGOm2f9f7R9AWfmjwHscQaIRJodAASAlNOgdfuwP6yseZsvnjPf9nwVPAf4fLTzzv/uhNOdzWugugdCB6q57/Njn58rZy674MJ37MLxfKYasAqs+hQUxoFSMN9hM3kUv8lFyV02Rx50zStK72pHFdqpxX45VcoVosn/zzl2GUFFG4iJ11pqNBaVxlPNMgrr4OvNFEcDxcNEadS3LIHF1SOqBL6yykT9rW3tbcaqaqRJ96SuvmRZa71I02lbSRLp1NlzetoVF6vTaWs4HiqFjs84ZzNVGy3FSaoa2QPeTKPxRINJZOl01tdCIyrXmMpT+owNhg9vgJPTkZrtfidVzwr25GmQTtx8txJf3k7uOeMbFyl7SHVQ/bokSj0hrASlSiuttN3qe+iHU1o5irXWGyseD+RP+pqO+9rsDzSKqupT2WM61iSONYhiRQmi53k1OxaPQTTTYJoYyNVpNrSx7wVauvh2nb79Pbr2qku02Yv01+/f1Ga3ooVOW+ks1eTmd2vx1N1avP7zFD/lRdq3d0WLVbSmiAwmqsxmVuUOofTFtbt0OL1DtbX3KozPKhr3bGHsbpxXd6upgwcW5HXayqJpznwajTSbDpXMKlo7P1Fz6bCOxjWdG/UUhJmmsdQfkj4fW/W8ViNQq4lOQqZGrabRcGQV9xASB4iqVkNzDiqm+5SDV0ZLpoJK6OnongXV9tZ1+lxNp2cbSqeR0mimYCHToUXy6T35jUz9hLYQaCTy5SsIA00mM40jFvm8lC6yWHmUKdeumlm5YT+PJxFRnVR0fjvT+nZF57YyrXZyuvPMD9Wshqr57Js7ArnuFYs56XscX1FBcHvMGNFbIs5E9XigwEF2wLDT+EDvgvTtjxd1YX8i4zjRHyuCy7k4J+cmao1uxnxZbtI+OJ7fPpYRveZBZN5p/2iGo4YuB+NxhTWcEZGmHVcenHEQpZyfi4djRPUZ2/zDzkeznDKfi91yDqLgD+cY2qefn0i/XGGJh8uwcH1zOpCfrDE25nv+ga600kor7dNh3J8QRS/tM9NmMIKSnM0DKJTjK5n5iVkh7p2/kFIoACnYQQUTKmdEFSWnXWqe02otQB6ruWd6VPk58eHMjwtqCqpLyibjQhgcsCdRGseKJwNNhz2Nt89qcuY27WnXdPCSq7R25lad73Z1xWWhnnL11bp77bwu399WczbSncd76lSragYzjccjtZp1zZaX1PMrai8umOYqfZklaFkhg7Fl1aN5dii4TZZCiPKVEyo3cGlH0DwHpXIwCvmJfHsOMpHWmLOpXOYFB+QB7wKsKtpxmq5WT7pEpZ4QVoJSpZVW2oMMNtHWJNbZblfx1ll5wy1VMl9bnVWUExVtn1Pc29ao0dLmeG+e001lDKpiZFJvHOl8f6Rq4Kse+qotH9Dwsi/VUnfd0uU++/lP19nNd+rm+wbqD6ROq2Oi22tnTqv35j/WgQc+rPD5r1ByydXqNKtWZSTbXlN146wWgon2Z6fVXvsbNbSt3mBLva1eXoo383XfA2taWmpqIRpptDVQWAs13orU6NSlsK4771rTsec8Q8tpVWlyl6rVpoIwViWABeWLRLdOh/z4TM1GqMV2U9UK1e0qykLf6NBp6isIcso/jgQC8AaYBZ5azZYuOXKxDu9ta3PrmE6fPqXN7lAnz65pu9dV6PsaTifqztCJmqlabyibzEz8sSKEzhMD96ohgBfbc8cEIfTxaKTFdFmzNNQUljSCj5l04jygFH5MLiZpeEoay88yAwYnCLcDHlQ8QbgCnSpgLgP9Hku4FADQ133d15mALOATlZTQ7yAFggj2//yf/9OKHfzH//gfDdgBqAEYAXAgLYHvrnw3nykFjq4H0XNAEIAa3h3IA6ACCIQgLFoa6HP863/9r+387MM5f+M3fsN06p7//Ofbd1IreHE8fwMuteEd73iHAWlEy0lxcOAH53Qgl9MBRCCWVA+i6+95z3v0FV/xFdZnwBrGzT5vf/vbTUsQMIyxUQyC89Fn2gEE40HIpX9wHpfCAciFvgipLOjwub7O95vzEVVnPmgfYV10CTk3Y+A39nfAGPPMmFwpdOaCMuYUmXBpIGzjdwf+cCz9dJVpmRcqUaE1iKYfbfK70y1xYsQupcZVl0L/Bb0X9gcgdOk2tMt1on8uXcfpoPA347bTH4SJmRP+vkorrbTSSivt02WzNH8VMcq8wpxVxgNsQgvKBbpgyrtPOVhTAaGaN0vlc8CUE7CoqFmva6HesMI9/cnYKjWTJteoNRTWWgY+5dXv8mAb7YZhTZVWW83goMLptg7sP6Bg4YBuPPlmrW13rRI17gnFeM5XPF16cUfPe/YlWm3v0e03vkvnz57RsNFWMgvk+VXTN8U/BoQLKplWVxq66YGRIqQkPOnIUk0HFhqqeZ7O9Ea6b2uoSVIxFpRjUO0CULsgUw48FYDbXHZfPvzd6tuW1Vfod1n2hM2fA+1Ke7xbCUqVVlppZlY5JMvUi2Kd6Q00YYHbPqNZ77wqcaq4e1Azv6q0v61k0JU3GRqIkswQH88sFWwcpdrsD3VybV3VWl1LADuLLU32XqHaNa/Q8N1/oGEsfdFLbtDGa/5eJ9YHxrRqNVoKg9AeQu/50Ls1OHOPDj/rxUqu/3zVF5fV9utqeVOtnnmLOuP3qhqMtN3tyw+pNiIdPzc04UQq6lmK4dq2hv1I4zjQ0p6WTh9f10Yv1blBU09eWdbo+JoqFTSc0GugIkggPyBlztdkPNNkmml5qaW9i0tano01aFTVHw2t1K5Hnn6hE5BlLPyAVL6lI3YOXq/qoacrDO7TvmyklcXLFVeaet+HbtEtd92p9uI+pf2BhqOxgnSkep2qlxP5AGOZrykMtCh3RqrVXDeA6xIlqYm140BklcCYXVvdzECr0dTTNJ5puempFkqV1gHNlo+pEQbEsqwayzBKFIaBakFdYQGQENWy6nuPIcPBIHXhZ3/2Zw0MAlQCpIFdQ/UgKgqhyfGLv/iLBrggLovY6p//+Z8boPHt3/7tVpYbQIVKmoiwAlL84R/+oVVavfHGGw34gkEF8ELFVaelAUjC/rBy/t2/+3dWORSgCkADAVsAsZ/+6Z/W7//+7xuzimIQH/jAB/QjP/IjVmocYVrAnX//7//9jq4JBR1+93d/d6fi6g/90A8ZiAQAA4CCOC8vxgqQwjhdEQzAKgAb5gMQhqpQ9J0XY6ECFHPDGJgHxu3OB1BEhVSEawHAqKL05je/2QAa5ouy4IB99Pf7vu/7DNjhfIBKADd///d/ry/8wi/U7/3e71mhCcA6gC7GzH70j/FRcRXWGpVZ6T/ghISpYAAAwpNJREFU3V/+5V8aCMg1cBotzCEsAvpDvylEQhtcN64F40RAl/N+z/d8j6XO/Oqv/qrNFf2lGiqpKPxOZSzG5oqCMC76wrWici5jpHrV61//eptn+s8+/HstWVKllVZaaaV9+m2XwYTYuWmZF0LnfCaVz7GnAIw8+w9WUC7TAJjEvgBJjj2FZnqe7ufp0NKSXnjdM3TlVc9XWOtoY+Ok7jt+m9576/vVQj+1UlGaxJIXSNl0h5HEe+BXVWtX1V5cVHvvIb37jpu0ORiYDxhHhIRznzOqpLpza6LlPYFe8tlfqPTcPTp14/3a6o6lsKVqA8H/xPrje4FWF9taWqhaHcBq4OmFFy3rpc+/SgvL++R5gSZRohtvuU1/8s7b1U2oF+hmKtdyZ+w5WFWkLhbvfDAwz6Xy7bDCnKB8kQYI+lZkApSg1BPDLoBnSyuttM9U40Y/Ms2lmYbTSPGgq6y/bqlrlQOXaXH/ETUWFpSQt97fUJbEBmrAiIItxFoCKLU96Kt39n6tbZzX5miqNJup06orOnSD9j7t83VubVN7Dx3VF/2zp2pfJ9Is7qvf39JoPDT2zjRKdN+99+ojb/gdrf3JTyu+80ZLN/OSgaqjO+Unm+pvrGttbaB7792ibJ1Fac73Zrp/LbIo0WY31r1nJnpgI1J/ONHbbzytt7z/vLL6grJ0pv5wrPE0ll+vq9Wpa2m5rr2rLQOXesPYtKJajZpIqtrc3FKfFEATlfQsl570vRyUyhfRwPcV1BpKDj5H3f0vUq/5bM1mbQVeqNEk1qnNbZ3vDbUxmGgQB1LQUVhdUL2xqiBcVFhty6sEBoaZtleQ06BhTTWqvprVHJDyg9Dq542n0mZPlr5n2/28bHDFC5Qcerb8Q0/SarsukveoxjIe9jWZjEw8kop7vKqkGz5GNaUcFRsABgYSKXUwXShlDSDz1re+1bYBlgBoUF0IIOKBBx4w4IGqpoAdHA9AAtj027/923rKU56it73tbQZwUA0J5xADuIIlRPUgfv+bv/kba//222+3fb7qq77KwBHAKJg8MJIotQ0g83M/93P2G2AW5wV0AVSjv5wX4AQm1A//8A/bsYyNPrqS5ABm2Fd+5VcaC4i0PsAhwCoqmfIOsAMw9cVf/MXGrgKcoaQ4IBTn5W8QUI3KS45lRZ8AcKjCBBgHKMa56Tf9//qv//odlhHnQweFaqVUpGI+EbEFSALkoew4+wGMAfTQF/rJfAFsMW73OwAR1aY4/u/+7u9s/rgOgFmM0VV5ZX9Yb9/4jd9ox3DtXv7ylxtYxhiYf9pgjgDq6COVUAHz6DeRUtplLE7IGHARhhQgFn8X7MN5SZF85StfuTP/JdW/tNJKK620T6fNSw3kpXBy5lS+LQeJTBcKIXD8SKrTUWkuSpVEvGdWdc5+o/AOFfeyii5e3aevf9nX6Ybnfo0Wly9V4C9p//6n6gXP/1q94nO/XIdW9hegFIz/mipeLjHhUuToCWLgtfqSAVrnNs7Zb7nvmL/yQCuyAUHOSkrGqmShGvWWtUl/xqOx4mlkshX1MFSzFsjXSHGc6LpDS/qiz3qqFhVr7f0f0d1v/7BO33RcTzlyRF/+nCss6JvPUTEnBSMqnyNAOJ4hckiCYKwDJ3bSGAGq7JUz0fLMvZ2qQzuMstIe31aCUqWVVtpO5KI7iXVuMFGSwDkypEoVHsL3HNZyu6OFdsfKzCbjvgE0My8XPiRSgcbjOEo0GfY1O3+Poq1z2hqM1Z8kJq/dbDc1Pvp52nf59Tp3blvXP/v5euENl2v/0kzVYKrptK/hqKc4jTWKU504t6FbP/QenX3dzyp69x9rqlCzsKOzayNjbO3b39HGMNZb3r9melELCy0dPrSi7nasm+4aaGtIelygO+/d1N1rFT3Qy7R3/14Nx1ONKIHnBbZ422II3XkmjaZ5KVu0oZYXOooQUB9PNJpGiuKoYDBVc9HJGel1LKS5VkCI/lRjrzabe7S29HT1Gs/U1vmB7r3jbp04fdro1r3hmpJ0Ks+vq1pbUK22YCV7q2HDwAVK4ZJSZyLvWcVSKWcpQpl59IgqKDgOsLsArHifTPMqJdC4/fqqoqPP1tLePVqsBaqgLTAZKOtv2FhMm6eSWToiwFSuA/bYMeZya2tLP/qjP2psHoAEGDSkhPEOqABIAmsKZhQMIdg0rhqQiyoCbAAKAfLwG2wZWHjPfe5zDZjiWJhN83pIpNMBcgE0kb4HuwdACAYQbXMewBAAD/rAeWAkwRYCLAIcoSQ556YM+J49ewz8AnABLPmVX/kVGwcGoAOzCbCHlD8AFFhh9JHjAGIo4c1xAGP8zdG+q4gEWMT+gD7OGBf9h4VEP2mH8XMMFaIAZjgXLCTG4oSB3bxzbgfycH6XGgjwBFgFKMRcAh7x3c01f1NunABjLp2QOYO9xDnpCyyqN7zhDcbcyqsRVWyuHFuKNhinK5kNuMS5AfasfPXamo2Ha0KbAHuuyhR9ZuwAWVw3xsg52Yc+0Oe/+qu/MoDs3e9+t+1TWmmllVZaaZ+6FXpQOwBLznS6UBshm9dUwmcGkIoLcKoAqPLPRZqaCBz6et51z9DBi55txXN6Z+7V2sn7tXH2jLbOr+vY0Wfo2quuN//QNKRi/G04WJVcJzKiMSesHqjiV1UJkZygkI8UVgGsfPN5eaGDv7ywqHSwbhWgSdmjKnRKZLh4VqjVQgWhp3Y9UDTpqzeI9DlPuVTtINNt/3Cf3vi243rHB07p7999v9751jt07f49OtJuWJ8ecvYMqCpAvJ0Z3Zm0ufmbS/2zDUU16U/rtSzt0bQyfa+00krbMaIng8lUo/62saGS6dDAl6Aoezsdj5R0zyvurSvrb2qrP9bGKNJqA6FzaTiZaDYdqDLc0KxS00avp/P9tto1X62ap2pnVd7lL1PlI6/R5lZPL3nZSxRFE334jlM6vzVVbzRVnPk5ayjOdG5roI5/UuHf/q6my4uK2iMdaEnv/tA5VXxfVxxp6b4zE73p5p6+4IZFfcnnX64HTk7UWMz0pIuXdeDost7xd7dqGI3UaLa0f9+qJtNEmYI8kpR6Cmu+Kj4MKCJLYG0VLS7UtX/PkrZ7Aw364xyMCovbJWlvAcAQqXuZaUmFiLL7M0XTbQ2zTNu1trw9z1b1xIeUDe/RvvaCzm3BdqEEdFt+2FCQZQqrpHKN5AepptPYwLsgAHySalWp0wiK74mlB3qVRF6WqlGtaGWxoijx1R3G5oJAn/ZXL5F36Ek6uNhS6Fc0i2N5k578/pqirKLp8iqFmxVSWRBw6jEWlgDUIVUOUIK0NUCHX/qlX7LS1gAYgBMAF7ClYOe46kLsjzltJYAt9nflrQEyYBYBUqBTBQMHAAXj9//1v/6XOXCAG6QHwtghBQ9wAyYQ22EPAbTATgLMoh/0kXQ1jgH4YTtpg65vFr1MUwN5SOGjHbbRBkwmgBf66XSrALkAg2iH3+kbABPnZRvvsLbuvPNOGycgjKuWBFAEQ4tjaB8Ax9IEinRNNLEAnTgfbCV+h61lVSZ9Xz/4gz9o74BKbj45nva++Zu/2c7HnAGIcYwDn9iHVEjGwu8AhhwDA4pzwC4DIGIbn0kL5DrTBowqUhC/4Au+wObT9ZV+fM3XfI0BUU5TDOOctMlY6SNzDHBFH/jMvDPH/E4/uaZcQ5hW/C1wvdj3wopTpZVWWmmllfbJmSskk2t25sLl81X1LmRS5UFHt83AGgOxck3QXBQ8T/BbbNR10ZHLcpSqIrX3X6KOV7Mq0xUClGmi+uKq/Y5PmsQT068imEmwGK1SE0gv0gXZj8rYgFKk3eWWK7PTfX679JKrNdo4p/440UwUXAkswyBDlDxvxYoALS401R+NtVyr6NLDbZ1+3y26+a5t3X9+rJn5CDVt9vq64tKmLt+3oPu2cp1H86GtQranKYWSXOpjBbRO8nJ9dBOJdwJTxo66kAzlihTaMB5bAdbSPjkrQanSSivNjNQuY+JYjnaqeNjVtLumCBHpU3drEk00Xj+t6cm7jF6bjvoaDLo63euoEUhNv6Juv6dksCklQ2WTbfW62zq/vKTVVk2tal3NeqDRwmG1r/hcDe96s1oLS3rxy16uJHqNAm9NgRdra5hYX6qhNBzHun+tq9Ggp/bpM7qz5unSFarGBTrbi3XT8U31JxU944rD2rPU0anjXZ09H+vSY8saRQh8S6Osqe3xTCsdz6oBJvWmVPFtcQQIGg4TbW8j/ExaXqZms6qDBxbVaTbVO3fOUhlhIRFtCqA4swLOZvKI7FTyRbxWI48/0fTcndrsPk9Zp6NaY1Wrh67WJcObtLx3UaMo0fH1s6o0U4VBVTH59H5DnhfanE8mUxPANF6ZaceTuge1eraTMohYueelajdYnT2lw5zyjMB5u+ErqDbk16pqAWARQUoSeZOB/PG2KrWOxlGkSTJT3fdU9RjPY2spB4wAhJg3gCSnBTRfRY90u4cywA9AkAv3d58BuuYr5OEUXlj+mzZc+67qnqtI58AsZwBDrp8fq28AJc4AX0jDw/g7JL2Pdly5bsz9Pl/i2/UflhcsKtIZAcNcm64E+oVlxN34Xalx9/t8+W+AtY9mbowfq6y6O96VVHfviLV/tBLigHUw0y40rgnHuzYuBJHcmC/8PN/+fDl0QDBepZVWWmmllfbpNEAVgpNWmMZUHnbBqPmKsU64/MEgimNWFS8vDxL5FM/xpKP79mppz+WqIPNQ32usoEqW7Aike9Wmsf6zyZamiJ+PBsqqzSKFEAY9+xI8ylMHSYGrhr6dx6MsoDP6nFW0WAt1dP8BbXzgTvOt8aFtTEXwj6AOTYdBoAMHVnTxkzo6fNkVqi3UtHz1dXr+3qGCd96pW+5e1ySeqRlWFFY9xVlqx5seVK57QZHBnSqExiLLi+/l7/jchR6XY6LNg3tkJ7Cd9uZ/K+3xbY95UIo/VCLVONHoWODEOj0I58DP60N8tJLR8+0QPTWhNkpefQxjv/nzPFSb9Il/aC5y/nBKVuf/MGFEfOrTvyOaVwgvPxLm5vtjjdVptXy8Of50nrO0T96Y3WmcqsLfJeLd/F0Ba9Q6mk3XFd31bg1Pr2ja21I62FSwckjZdKTB2RM6QT56tKDFsKIYdtXWcWXJVLPpVJPuhrb6q+ottbU3rakeeGqS5rZwlfZdnSg9f4ua7WW94HM/V+M3vlFeZUudpq/z27GGk4pFn6azmY73YgVCzLuqB/pSy5/pyKJvC9j+xVBhZabLjjX1wOkoz5nfnunU+aHOb8XaGPlaG81Uj6XuIFZnqaFGs6lGg7SsRP3BWBQQZHXEEdizUtfFF19kef1JFOfpROT2WyQMRwFAK5VX8YzCDIMJ2nNMSuDZWzQ8f0JRdkQU/GstNtXZU1czDvTSZz9VH7q7o7vOda2NalhFPEoVz1M0HZngJCmESZKZRhdMJq8yU7vpazxOFBjFuqpaEqgaespGmfqj1Nht1aCiRj1Q6KXyM8rAJCZCn8UjBUpUV6p43NVo2Ne409ZC1Vfd8xReWPWltEfcHgoU+3gGQPac5zznn6xPpZVWWmmPJyMlG+08fE98cdibF4Lz+N0UW4A5eeFvpEvDyDx27Jh9R+8OPUKKKgDekyr+UP4nwQF0BGGSkvbtmK48q3wsgzXqAiUuiPLJGsxfgiIugPJwDa1Cnose7vl5JiL13On+PZS5FHXYzczlx3omI+Wa+WOeP1rfuZ7MlbsuMGtZL522Ie0wfgISj+bzgR9WFNQqRdpdDi4ZmOPApjlWUv49NweouGc4D2mF0DPg6PDKsp7x5Gcq7BxR5lct8FlJplIaqRKEko+URJ72phSGVN4mzHq0XMluMH2qSqw0CJTM+JusKCKjoRAH33l+hvXveVpd6KjpTXXv5rZiNLAQFC8YS7iLVlUwRXKjov1HL1L7sqfxl2Fj7ezLtJBVdODqu7T4F2/Xhz5MlkBqBYmGoxxIy/IJytutmFJrDkLhihYgVQZjKp2bO44rlOPtcEvxL5IUbe5KPaknij0qTyQOSHk4YqMsNK9+9astlYJSzm9605usChJVmLhB0g60fEpGu++u7V1UN7M0gK/+6q82nREEb9GVYDvHOOHT+c8c9yd/8id2PtqZ/831G12Kn/iJn7BqRz/zMz9ji9hDtWOlK+eORT/jlltueVD/3DFufhxwNb/PhZ9de2iLcFOe7+f8vq4fH60d93l+nws/z58PIWAnIjt/HefbYyGnItOFc/fx5ubCl+sH6TiI9z5UG6Vo7aduABsntofqTSMlcSIvGsuv1lVbPaqgvay4v6nRqbuUDrcVUJLWp7IbSNZI2aSvZDLWZLCt6eYJTdbuMmfB6ouguUSKz2ymGKAyy1QLPbWaTY0Xr1X7yNO1vbWh1tI+Peu5z9e+vUtablW0t4MYdyyS67nei42annRoVZcdWNGhpbbxpG89O9UHT431zvt7OtcbK63UdNkVh3TFkw/qquufpKuvvUStPYd10cVHtLKyqLPdiW65+5Tue+C0RY6CgFSqUKurHS0s1pWkiRY6gZaWF7S4sKJRry+/kv99OmcHBpdRtc15yEGsKql7XkVJFCnduEN64J3qr5/TtLeuuj9Vo4ETMtNllx7TC57xdB3ec8AqDVZrDXkVNI2kyXCoKJppMmHxlUXIWk1o01KaJKqGFdXrNVXrDXN6YVr5fu5g1ANS9yB/zeRN1xUM1hRNxpqOB8qGG6pNt1WLe6rFA/nRJAfS08RAL16llVZaaaWV9ng2Unf/xb/4FwYQ4YsDjqDHhyYdwAcFHij2QHVUwBAAGVKjSWlmjadyJ88GGN8psIEfS3VVfHaKONAGPivncoFXjqMKK88hf/Znf2bp5+jmcQz94BmGz5ybc9EX0q/Zj3bYhv9+xx132L60w2e2OT8X/xcwzfX3nnvuseqw+EaM5U//9E/tGQnDN2fMfKct2uQ4ADcAHbZzPOdmG2Ac2zgnc8a88Jn23fkBotyckepO/3n+oX0KhtAO56VdtBLx/f/4j//Y2uZ4986L83Jd6BMVVgESX/Oa11h7bHeFLHhWYxugGRVvOSe+C8e731/72tfa8wjFQlybj9bzQLPmqV73Va35xgzCPUOzyb0oimfAVbVi7/lnT0Etl5DguGotZ93zef/ygl7xopfpyc/8KlWChiqzSIpH0ixSBiAVwJCi3DJnT5WMt60oEdumE8C6mf2tEejk5IBA6Yy/2UyL7UUTLkdUPRdWR8oiB6muPHaJ0v6W1tYHGoynxsxKs4q1jQaWj5SF75nf2WjMlG7eqvTke5We+KCS4x/U6Pb3KNrs6dqnXKNn3fAMHTmM/qSvcZLOVdIrquYVW3aumFUcLLS4AJo8NK1m8oLMhmrvFAHyIGLMzOe1BxGbg9KXfSLYI86U4o+RGww3k3/5L/+lRXs/FrpNJIEbJdWWuHECRnGDh7IPWIW96EUvsgpIpFUgZop993d/t5UNJ10B4IibNzd1SncTFWBftEq40aFrwU3zjW98o+luIBj767/+63YjRocEwIkFAjFbJ9CKcK6LyKA/wgJGW9ygOQ5RXh4eWdS4cRO1AclnYSMdgxvvL/zCL1j/iKiw6LAP80Ff6BupGUQIOA/nYA646ZIGQtv0h0WQBYE5YWHiM5odiMdSTenLv/zLrV+Aa8wjFZfYj/mgyhLiviyyaHowd4zvZS97mQFdfHbltBGTRVeEbRzPQsFYWPDQd2HOGNMf/MEfWNukr9AugB19opQ4iwiLImkp9J/Fhbn8ru/6Lrt50kd+ox2M6NT73vc+6zf6IPzO/h/84ActTYW0EPpPv4i0lPap/bs8ubGh7WGseDJSPNxWJR7b/Z588oTPQUPV5QMmlJh5vrw0Ur0aqlMNc+aNAo18ctwzZUFLaq1KtYam0VRbo4lWGjW1qSQXeqpVfaWVhob+k7R6bKj7b3mnVg5cpKffkOl9//AODUaRwkpiaWlU+bhoT8cWwe54omQaEZfSjPQ1eWo267rz/ETvvOmsnnNtRSdO9HTfuYma7bqajYZSv6qnXHFU77/3jN7+oXt1eGOqpOIrTjI1q23VvFCryy0N9qEdlenw0SOW1jcZjRSkVDbLo0MuasMC6AU5mETVvXo9tMgRf8OVJFJy9lbF7Yu1EPhqNDcVk0oX+Kov7tfB1qqetp3o/cdHGmSAUoFm8VQjqprE5NVXDJACZCLCZb8b3RoRyqo8A6LQEqgrDCK1GpmSIFMY5MdmUV/VzXuU9g/Ki4eqbd6hrH9KyaSnWhJpttXRsF5Vv+qbnhTHFtn7j/afYGmllVZaaaV90j4M/ig+JqwagBUAEnzwn/qpn7LnBTT7WKcpooHPjT+Ln4zP7IKqri0KWuCn4r/Sxi//8i/b+g/wBRDyqle9ylKpSRPGN8WoAEsFVILgFMDg+YBnAwotUHCB5wPOh0+PX85zAkDLW97yFnv2oF2+03+28bxCH/HzeRbiGQX/mt9pi+cFwCM+v/jFL7Y+ABrhrwOC0SYp0IyVsfBcwDZ8d1Ky0VrkGYM+8vyBv81zFjp9VHhFo5DnF8aOT4+uIuAUc0Ngn3HCION5wRUaAZzCd2eM+P9oAzIn3/md32m/vf71r7c2GQO+PePjnL/1W79lz0MAavzGMxeahzCo6C/XgMIeHMv+N9100w7TjDEQ6OcZBm3ER9rwBfcs+Oot+JrEUmzsokpR+S6Xfsj3M6EpY03lKX55GhrbKWYTBARLfTXCUE+99BIdvfKz5QcdY74rnRpTytj1QV1ZPFZGtb3GojRLFQ17mhBwJIhqWlNkPMzMb8yrNuc0I8CqhWbLtJtI53MVpP1Mqlc9PQk9qfP3amN7rP54akDUrncISJRX2ublV1Jloy1Nzm9o+/zEMhGmCX55qNivq7W0R3sOLCjyzulUN9dmna9Q+CBoqvif/Rvks03ehUAT+5q2hbGpLMWvrKb7hLJHnCkFmPE//sf/sJs46PjHM25YUGK5YcF0YqEhUgCoxGIAQMFNixs9NypumIA63NxBzgE8nB4FwAY3fG5s3PBA8gE3QNkBoQB7AMsAzSg9jWCrA7O4mbLgsQ2wyBkUVUAa2uSmjugtoBMLCswexG25OQNUASgBxHAjp69EHSjZDdjEGDjGpQTSL9rhZswi+rrXvc7emQP6DsBDu0QmHHsI+i43eW7efGcBxtiPmz1tUeqcxeUbvuEb7KbO3ALKsSixcPEicsG4WFBZAAC8mEOXcshCBpBGn2kHYAgjQgUtGuCLY4kqsXDxGTCRY+gjJbqZB/rH3wPnYHFh4WZ/FkauM4sc/WaMzAXAF4sb27nu7AMg6Wi9pX3yxkLVWzunrfMnNTh9p6JTH1ayca+i7VOakpKXJPJrdQW1hsJqQ2GjbUyfTrujpWZDS42amtWqLYBBI9fWyaZ9RcOutrrbOtft6Vx/qD4rNkKL5M0HnhIW1z3X6vKnPNcYWkcvvVLXPO2ZqtWqymaxGsFMl6yE8rOpCSaytJLahs4Vf48Tqm9UfHUWWjq9MdVvvf4W3XfivJpBrIVWVYcP79G+vSu68rIjWmq3dPv9J/Xum27Xhz58p7a2e6jrWAW+lZW29u1pq9lsaHF5RZNpoeHkeQoIc5mR+e70Anz7txCEoeq10CqeGLMxjRRt3KP2uffqWHaPakFf9YWOllaXFFA5bvWg9u1ZVNXLVKvVlc0STQY99XqxphElegG6YD5RAVCKSKm0cxFFC9WAXeUFqlVrltrXrKHLA0qWp8qiNRD07lOjf1zh1s3y1t+pSvcWeePjCnr3qrp5p7zN4+pTGXF7U8NBt4wvlVZaaaWV9rg30rq+7du+zXxLgps8AONj4nsDwnzP93yPrdtUYcUPxd+kKIR7UMZXNnZJmpovja8L6JJXxk3sGQG//du//dt3tP54Lvi+7/s+3XDDDfYsQWCVF+fkhf8MeEUQmHMDuhAEBuBxmQQ8z7CNPvMiMOw08egL7fAMwrMNvjj74ksDbFFtdT64zzl4fkHjD6YR7TMW2gEYA7ziWPxt2uV3Arwc49hXnN9p8HE+nq945uDZCz1D2uA5hmcVAD2r8hbHNu/MFz45/gjzB0h27bXXWv/oh3uW4roQqOc30gEB1miP89EW7TqNRNrhuzunC6RTHIQ2OB99dul8jwZIcXSfrysPV3XFoaou3V/TxftqOranqiOrNR1YqWnvUk2rC6FW2qGWWoEWmr5JVaAF2m56JtPA95V2YFkBz3j6S+U39kvIacCS4vL6NclvmG8db51QMtpSNpsqnWxq0N3SCGbZdKLpeGxBTXLhAHFcMROAHorpzCjvx29z8Uje9nea2rvU0uap0xpFqaIk1Zjsiaxowyo/z4w9xWe/3pG3dIkmWVsnzvZ19/Et3XN8XWc2Bjq/2dXWZlcbE09bk7qBWUbqKIgdzgDRdrJsqD6YZsW7e+XZMu7fYP5KjelFWqFl2/B6xK94aU8IphQAxQ//8A8bYk91no9n/PEC9vyX//Jf7OYLYAGAwYICOMPC4KIZ/HFyQ4NFBdLPjddV+cH47Yd+6IeMYQSgwg2PiAI3ZKc3BegEEMJiBZDEwgCIw80UhJ+2+YfFgkK7VEj6/u//fksphMLrzu1KegNoAfBwUwckA0h53vOeZ/1x5c1dBSGiC66vTqyX3+gf+xJ54cVCw36ASix4LLZERbhhcwz/aBmX06wi4sF2xsz5AIsYLzdwFhoWItqj7/xOe9zsAbFY9FwEhfYdAMSxjAt6shPLdcwm+sfCzRjc2FhoAe5YmKE2c4N0Jc5dehRzyfHMHf2FFk2fXK4580nfHCuKvnIOFnmckXlR49I+QWN1GmyqllVV8StKRmc1XX9Ak0mi4TAyhk69s6r64l6jAhOFaS/t0XJnQa1GVdFkoNloQ8lw3Ra9sBpqOuoqOveAJuORRXQWG6GOLSEyXlHo54taXAkVzRpaPfxUXapUG+dO6JqnPE0nH3hA62t91bKZrtwbWrSmG1a02R+pN0q1NoiMUgytqFGrqlat6p7zfT2wPtCtZydGMd6zeEYH9x7X1Zce0UKnpUsPr2p7kujW+08pqAZKs0UtrbS0d29Lw+FE292RlpYWVcl8TaaZ4vFE9QaV9UJLP8wjOPlCCGAEq8py/6uhJtPYpjGJI2Vbx3X0wD7tqYWmD+A3OvLTWOm0r9F4alX4RtOp/EZV8bCvXrer0SRXkyRdD9ZT4JNaV9kBnD2/oaXFVV131ZW6v+5p30KgxUam42e7WuuiBRBYXzI0B/r3qNZrK4nOaxqfkqKhZhPKBa+pMt1QOD0nP3mKtHpQmjWl7JJHK5O7tNJKK6200j5lw3/HT4fdg/8LCwkABHAGn93pEAEY4UcCBOF3OvAFPxMGEIwefHT2wafk/YUvfKH9Rvu0Q5YDfr8rbkGgHUYS4AnvBHY5N4AJD9T47/SBZwsCtwA1+N58dgUqeMfv5Zw8T/A7xvH4vhSEYFy0zzhoi/MRSCfIS0VVjN/xq/HHAXtgD9Fvnp/Yhm+OT8F48bXxoQGBOIaxsi/n5/kH4zeeM+ibC3C7fXmOQDqF3/DHaY/fYS1xLoA6yAdkrjDXBKA5hnO6fZlDfHiAQn5nrmjPVarlxbMerCsALJ47ON4xswiG046bX56RuEbzBTD+qY3HtsN7fbX9wITB4wSBcbSd8IaLd2NOZUpmpMLJXhB92OYVjCn0SWuBr6dcfo1WDt9Q6FABuEBnIgcwVJaOFW2f02DjrPxGW61qQ+PehrqDiaKkkEuxPqFrVrOiRdFkJJ/q0Y2GgmpdcRJZiNUvWE+cn+rNR/fvUTBLtH5+SwlBWT9QnEYmW+E0r3ItNk9xFCva2JKXJKo32nZN7j3V1zSZaTwbqNZsWXXrjTTW4YNLesUzn6b/8+73aTCNUaDaQcOcgLoBU2hX2ITlAubMjYFWfKZadj5hObvKBLGKSoZByfR/olgle5iQMjemT5c5JHueyvexDFSdGw0RDYAS/mFwwwM4cmlcgD+AGtA4uemxLyAQTCBu4NxoQeIBW2DZcLMG9Qd0YQHiHzJAFwsZQApADjd39oM9BFsHcMblkQPOcAw3U0AX+gjYw42e88LqYXEBqIKdBBAHiESbHEsf6RMLDW3QPn3lZgzgA1DEjZUbLtEM+g0jiesAAEdUACCKBdaBM+xL+w6YclWNaItFgsWXOYJNxvkB1ugT14IICn3lM9uZI24UjIPtLIZsZy6hR7N4cA6AKuaF39mffekjQJ7LJeeaAPYRmaHvXDv2Z9Fg4cM5YIECuGJ/zuEWSlhf9JvFnWvFmAC1OJbtLFwcU4JSn5qNJpFe9SuvVT/x5McDde9+lzZP3qpBf6Qoraq6fEjtA5eovnJEmRcoCKrqLK1qz/KSOuFM1XhTs+E5RdO++hvr6o9iTZJQaX1F2cI+LR+9TE+9+mo99cgeHV5sWLU+7jyjKVG8kRrpUMfaqbzBA+qvH9cdH75Ff/O6/6enHApV10wn1qa68/RQHz4zlh+GCjxEEoks1ZVmns52hwYSbQ2nunjPgtZ7I1vcYVx1Wg0tLzS1Z2lBiRfqA3ce1yiekFmoyy4/qHo90J13HtfZc0MdPLSqK696itCSnJ66VautQJ4faEzaIIUPKpmBUPw7B/NdXmpqz2pHg8FU3e6WJuOe6URd+ZQb9NLnXaljhzuaTTa0eXZNp9dj3XlyQ5uDVNOspvrKxbr99lv14Zs+pBNnB0piWf58PZCW2lYkV3Xy6D1p/8E9esYznqvnPusZqoep/HhDb/uH9+jv3neHtgax6jVS+xBPr2nlyDEduuqooqSn7c3z6m6PNRimmsS+/LBlulTNzopaC3t09MBBvfq7/lUuuj5nH0+k9ZFaK0orrbTSSnvs2mNlrcD/xA93hj+In8pDNCAK67eTA8Hn/v/+v/9PP/ZjP7bDlHKMIswFdBkbvrJrC8N3ZT+2cRx+rtM+AmChH3zmnd/d/PDuwB/8YL67wk283LnIvHA6uABftEH7tMc+rk3XFv3CZ6Y/PBuxne+M56HO5baxL8c4QIDtnB+tK/alXRhhGOPlN541XLuuYBRt4a/TBud12R585jkKQAk9YDdXPM/QviuCRFuMj77wG76VY/bQvmuPlzu/k1Fxc+PGZxIKBvB8/EJWn06D1X/mI9+nSf+eAnzKWfWk7bnUtIzCQfYOYEVwE7Fv9JpyupL1u+KrUVvUk57yw6p2ri7mDARrqEpQs1J0cfeMts4c1+bGhlqdjpb2HtTm5obWNnMm3ThNNU0STe3vtmH+axZPVdNMezsdXfHkJ+tv3/86vfe2m+zcgGGkDlKN+Yuf8xxdfeRS/fUf/JHuODOwzIZJlGkcwaxCQ6qhlaVFqzh97MCqnnb1ZRpub6jVamoyiXT8zLa6o7GmUapqrZZrnyLv0WnrkouX9YETt+qvb75DkwQ94RyEguU0z3gCkMpgS5kQe651ZYwpdK+c4PoObpB/J+vgN375jbr42BWP2DUv7Z9mrXhUQKnPJGN6AdQAlT6VxRswDHALIA0Np/ny4qWV9ukApb7jV/9UY6+ubLyt9dvepvX7Pqh+b6RYVTVWj6q17xI1Vo/YoupXG1pYXNb+PStaCCIF0zVlyVjTOFF/c02b6+c1q+6Vt3xU9b2HdPDiy/Tko0d01b6O9rar8j1ouRVtDKZa6/bViPu6rDPTvvZMlcFxnbnzFn3wb/9Sz7k40PlzPdWrgc6tT3TLianO9lO99951hbWalps1W1DPD4jmFOpIWapOvarNwUjdSaKFZs2iQI1aHj2ElnzP2XPqLEiHj7SFRNWZ012tb0y0vNLRU69/lmp+W1t3v097OwCkHY1GE3PMZllqzhNpfrWqpz2rLTXrVc0yX1vbG+r3Nm3BPPrkZ+vFN1ytJ1++otnwtE7d94Dec/Npveu2M2otLOpzXvg8XfrkZ+k1f/g7+uu/u1En1sbIAqgaSs2q1G54xlJr1zMttCo6fNFF+uIveaUuv+xyJeMN9TdO6N3vvVEf+Mi9OrvZU7vVMgenGta1cvRiHbzqmKbRpjbXTmt7e6xuHyeF0ikIs9fUbLa02GnroiMX64d+6Bdt22PxQaO00korrbTHrj0e1wqAFCcD8khVrX64zwuAQbCBCLw64OuRPD/AEIAYc/NwK4p/tLYYBz7XEz1gDCi1dc8PKB3fm4NPhX7ULhdot/JenjZXgC4GzMxJdGcVNTvXas9l/9x0UyteTUr6uZZUUFc63FTvzANaW99UbzhSs9VUvdG0gP4wSjUcjTSKpoqTWElRSAoDYu3UQh1aWtSl11ylW+58g2655yYrPmQAIIBYNtNLn/8FWqmE+pvX/KXed8dZDadoWCGXkSrJKL7T1N7VZdXCUPv3LOvooQM6ef/9qgWBVvesqD+OtLHVs6JBsKwoxlOt1c1Xpzr0k69Y0Gvf8w7ddGpLCel6M6pH59pQpg9VVASEFbULSuX6qmRLsI/JchlzzIF9uW7Wb/zSm3RRCUo97teKRzx97zPR5jWoPlkD9Sfnu7TS/mks02w6oIaHZuOhkhgNgsQW2xkRxK3TlpaXTgfyw5pqnT2qLS2qTeWQNFIQBgoaK6oMe6KV2aSnNGuq6gdqNTtaqDcUFosI0Q4WQWi+/XGs7cFEvXFfrclQ8cDTgVbHNKSuu/KwFoItDcKKqlVPB5c8ZVNPhxY8HVw9qoOrDW0MMt17bqxJ3NViq6reJNHpzb6lFCLGTp7+cDJV2G5oEsfahro+m6kB3TeT+v2JfL+marVulURIg7OKjl6+OJK2h4ZUUA3lxZGoVJvnxlcUVonkZRr2h2q1Oxbhm4wGyiqexv6yzo8CXZmxMFfVqFaN1bVveVHdSaxGq6MjF12mz3765br9lo/o7NZUcVEql+qEuDOs0fClWq2aVvbuV6uzZDpe0bCi/ijVkSPHdH6jr/E0pnpuHh0MA4W1przqHtMNSGc5PTvwpcRLbM5nM0Q1UyW1NI9MPYaMuSftAQYsDw5EUYnOPZQRMcWBnk97/njmKhkR0eZ4oq98dsfPR8Pn98VMs+tjlLd2DzoEDD7ew4TTUHAR30faXH+JcM/rqQC8MvZPxtx8Mq75dksrrbTSHkvG/clpQj2WjHvmo9k3zs9659a8T7UtMjk+U8yq25HmVjC1goKtlQNOu6CUiZ0XlZwNlHKQlPkEFbUXrzVAyjaR6DaLVAmqypKJ+eHd7rb647HirKJhlGkWZuojH+GHynD0rGBOpmhKcaJA9VpDjWrNCgWFVQrkxNrTmeiai0Klad4XY+qppj37jim678OaTMYmBUHPqP4sdFQBhIph5GzAWKNppGE801avp5kfqN5sWlGf8XCsRiOwSoOMD62rQT/VXdlYn3vN5TrZv1m9SSRkr2ZpntZYkJ6KdL2cFQVDyt4TqTrLwTyvkj9D5FpUsPwoAmRIVWlPAHvshAieoOYopp8OB/3T2VZppV1o08GW+udParhxWpN+z2izlkcOGDUZabx+Wv2Tt6l/6g55yVSLnZYWar4W6lUFmqoyGyjwIlXSbc3ibY23TyoarGs6Qsh7Wxv9ntYHIw2miciCnUwT9UYjS3s7vb6uD91zQjfdfq9OnN7QyvI+HVwJtXZ+W52VlhZamc6sj9UdJdqzEOiZxwLtXwjU9FI998plfe61h3Rs76IuPbBX111ySNO0oq3hRAHC6GFoYo1Ec+I4snS41aW26tW6fB/B9kXV6i0tLLS1uNhSUCHWBV0ZJyOPeNXqTatoAhjFizsnpXuHg6HW1zYVTSZq1huq12qWHjdKA53rJYqi1PS3SCtY7jR19WVHTOR9MJrKS0baW0v0gqsO69LVumpIBgBSwESjfSQA6lJncUH1zh4tLK2q0V60yFOrXtPFRw/ruqsu12KrboLs5giFVdU6q1J1VTNvRalyBlRIGd0KFQJTjSexBsNIw1GkKMqz+x8rBqhDygLgyG/+5m+aHoYTL3VirQBRfCaaS7VPHCS2zQvU8t2EM4v9DWgkOpmmlkqNBgfFHahyyjYijaQnUFACDQwAG7b/3u/9njFdf+VXfmXnPFxL1x+XekFaOW3RJlVfSSlwKR3sz2eXhuD6Q99pg99cm/PRctc+fXFgD9vcb7wAgty5nHgs88C+vLuUFI6ZPz+/UTzEpW5wHGnZ//f//l/77LbNt+/SVJx4LsY43PholxRytD9cvzmPi767dksrrbTSSivtiWKsaoNRqt4wVncUW/VoABtXkMcFoWYwg+x7vi3XRsrBKUAtoQPVukxKRqYJZQwpXmmidLCuyWioiErP+DZZRYk8k8AIGx2tnz+bt2nVoQO1FpfVaLQUT8cabK9rtL0lPyAtMtLKYqyL9nu6+ICvY/t9Hdlb0UWHl1Vr7VPUP6MoTqwwUL3q59pXM9I784rTDihCBJ3MCC+saoLm62Cs4WisMEDfNLBKgJZCWZG2uz1t9/q6/9SmmkFLVx9p68jemvYvV7WyGGq5U9VSJ9BSJ9TyAtsaWl1saGmhpk6rqsWFmlaW6tqz3NDexaYW2zU16771r0rlb4LG5XPxE8JKplRppZVmC+Pw/HH1RpHiwboGG6eVpWkOdMCyMaHBWLPxTFmSyp9NKfqqmhIFlbHGo1OKptuajvqKe2c1SyaaIrx43weUJFOl454q0aWq+5461UA1KrFEkQbDgbY3z6p//n6td08orsZaifbrsuuOqNpqKllu6vY7z+uW+yY6uLepG565rA9+6JzefFNfR/fFuvqSRXtAbh+oa3UQ6PzIV2vS1OYo0SSKNYkTi1jNjJUVqdUIVfV9oxN3WkuqttpK5SlJfauih74UFVCyOLKFtYpWUxDKD2ryQ6JVmhOl9HR+radRf6hOq6lWp61Oa0FTGDbDszp+hrFR0SQzzad6raIz95zWcEzbNSX98xqsr2mh6uv6i1eM9P3AFg/uvoFSrXqqhYWGOiuHlAQ1zTJP1caCGgine77RpNGCWl7oqD/tyvN8BVRAbC0qzXxNEZQEPEDrwYMtlVf3I18/SWON0IlIIj2WzAE8ADbvete7jCWF7sf3fu/36rd/+7dNqw4tQdhU6F0ApLzhDW8wHQ4EbV/+8pdbJVX+br/yK7/S9CwQqEVQ9kd+5Ed2dO4AnqiAitOEhgZFGNDjo33KW7/5zW+2yq20TxluzkE6A7/B4qIsOGKwlJ+GWYTeH5WHEGJFJw/dPgRgEchFL5BAwhd90RftiM6i1UdFUs5HeXL6wfHoI6Kjx/k5hrRvNPQAdD7rsz7Lqo8yBnQPAdLQ8wM0A8xzBTtI+6AqKX3iM7oeGJVb2QYwhX6h018BUGLOHHMLUImqqlwDzoMWI6DWK1/5Shs//ad9yp/Td6rMou1HJVmuHe0yNo6jTfQKEf4l+v4t3/ItO3otpZVWWmmllfZEsO3BTJMBwFJqPmKjnqndmKkRerbm5WQCSAV5YMbkyy2Nb5an8GWZatVVedVDxo6C6V+J+nm63yxSNNhWjBYT3yu+4DEZo4jKhwjXd9q67+7b1F7eo4VlxPsrBmKZD49WVb2mdmdRqowUBBO1GmQL+HZuUv0IqHpBQ1mSKUG7eDRWn+Bc5ilVRdVK1dLqchZTzrCPyOnzQk3j1PbH0LEKglDTZKwxzOv2gvma08lUk0mg06d6eurFbe3tzTQcJxpOUkVxXtEvD/LB9KpQpFvTKLHgNc8nXoUAueFz2h5O1R3OFKfsl6kafnQWe2mPLyu9w9JKK80EFLun79GZMydlKt8ZOeH5T1SQCxACJUedUq2ZNNk8qWTrpOL6UNHofo3WblUcD2wBmY6nxsCZTlPFwwc0Hm0b7TjIEh1Y3aNkz5JFkEaTqcaDngk3Br0HVBmcVRx62t5ARPOgGkGgc+cjtRZWdMN1iY4erOvsiU3dd3aq1eW2rr9qVbNZrNF4pmQ60ZnzY50ezjRKfT3zqqN64GxL692hLYj9wVA+zKeU2JSnWrWmVntRfr2uSL6xwaAntyjL26ro3IktA3KIOFV4+Z6JKU5SmB8wj3zVPGnQG2kwHKu93dXKypLanY4q5PNHPZ3b6On0Wkv7lw5oYe8Bnd48aWKQoe9raaGjuH/eUv+SeKZjiKWPI53urlvUrQoghpD6nv0KF/doQFQqogqib7pQo2msU2c3VAsy7VtdMkHK3mSqoIaY6Vjj3v0a9x5QGueOgl1Hz1MtzKndxNgqlci0veYUDR4TBkDjdCgoZgCIAgBEQQnAmn/zb/6NVViCfQMABLuH/QFEKKZA+hyACWANwBbADQUdAEtcWh2CqVQhAmBx1T4BTqjsSZo0ABTnon0KYbhiCqTzOTHZV7/61TuVQZ1QLeaKUbhqQvQTbQ6qKQHecF7AMionAYzRNkAXQBbAEiDaK17xCgPJYDN98zd/swFxjAGQinNRlvstb3mLHYvGIFVLAbVgdgFQ0Qd+AwiiXDjgJAUnOD9941zO6Avnf8lLXmKgF8fhdMJEY54ovc1cvu1tb7MKT1wfzuEALao6cY0ojsE7BvhGQQ80RegLICIpKS5qXDqQpZVWWmmlPSEso+Ie4A4f8xQzP8408RG7z1Q34facBZ9V8L+83WpzlrqWA1Qw901Hahbnkkm8e76yBKZ0mqfTyVfmhXl1ZtLmYXpvb6jRamn1wGGduO9uba6f1eLSqpJ4qulgoLqXaWX/PmM7xZPjmiXjvLKfX5E3m8nPYP6vyPMXLVAb+pVCqylA2UrTJJOX5WMwQKriKYZCVcllJvCJomimUSVSBQkMG1fFAqOtFiCdZwATPvbG1kiXXtdSozPSdDrTNPaKSoQAXhXz0RGKJ5siin3FcVD4DfiuiO5nOreZqV6FrZXPHZpSgV/6FE8EK0Gp0korzWwWTZVMxsUiCc0YgCDXJCKVrcLCyYKhVHHvjLoP3KjGdEH1oKs02lI0GWs8zDQcpBoNE8VRauVvs9GWon5TwSxWtUIbsSbTTMPRUKPuWU23T1uaXxBPNPOb6vip6mgeJdKBo3s0Ho4sf3w8mujk+kxrE09b/YmemvgmUu5Vqzq4UtfZvpR2EYWsKJlGuvroPt1f3dRGj1J/M42nU2N8sZBF00QNKoSEmelPhV5DgUZq1T35s0SDXk9elqriVwyQ4kHcqrsEobygombN12pVyuJUm92pGmFfe7e2daCzoLQayu+PFSVTfeT4GV16eI8W2staXdnWNZcf1vD2M1peWlY8OFmINs50ZO+Szm6PTNCd/vHQXq/X1GgtGCg2HE80Go8MPEySVMPxVPefPm06WhGpafC9PKnaqCqOzms82FQ87JGwX1DH8xx8qNWwvCwqF+ZpfY81c4wngBPAHCqN/viP/7je9KY3WWnqX/7lX9ZHPvIRYx7xO0ANbCRAEMAlwA/AF178BiADUwrWFeOG2QQAc8cddxjQAhOK6p6ushHsH8Am2gfoYn/aB9SB2UTVU9L/YGd927d9m7ULcwj2FawgACLaZzt9gtFEP53wKzobrkIT+wCiAQoBemEAY7CbALOYCwpcUNn1uuuu20nJc9WGiMDSNi/3NwoQxbjoM0Ae8+CqsAKCAbhxbgeicW6Aqbe+9a071YtgVAHA0b47F6wrwDHAPZhWLn3PMaXoH9eMY6hi6wA7xgqIRgVY5pz+Md+llVZaaaWV9ri3itSqeaoaQJMLh9eraB0B5MCsN/ymkH+A74OweM4Igv6DbwYoE9ZWzVfNMvj7eQA1SyJ7eSFiFGz15PlVA6v6/S5OuhoLC9reWFNnaY+uuHZBa+dO6/zZkxasRcu1ubCodnPB5B+m0zUl6dhkJEzHqnAB/foRqVI1KhJML3zFahXB8Yr8AN+iZj0ajCdWJdBfyNn4xrD2fZOpgP2VC5TLNKewJE6tCjZsrko2s9RG32toqZNp1gTkyoEttKFMcsEq8dEOXeE3X9nMs31gSY0nmTqtuobjQHGSFTIjoaroxJb2uLcSlCqttNLyiAsMn2lkOeksjB6lWE3UO8ep0iRfcNAvmsUjTYfn5ceJmvVACprqTSYaDSMNBommExYgRLt9eX4qP0sVsGQRuUErJ/HU3T6n/tnblPROKBlvq0MFj2pFhxZ91St9pWGqhZW2ult9RamnZrWqUTxTEPqaDGOd7yY6cmBBQ4TSR6nCWqildlUntiY6fnZdz3zyJarBcApDLXVa1j8G2lCmOE7U3do254BH9kbds1S4MACQGiqajNSssxACwklhvSZ/PLHFGSHyA51QT1qtae3Qqja6Y/WGE20i0L13j+ory6oMcwDp3rVN3X9uU9ddfkRLKx0F958zltVCu6H45LZFw4henTjX071ne0ZJJuJDtZPAr6lCOV/5Gk9HBgbMklhRNDGQaqO3rXtObiqbQX9O1WwtKKjVFcUjTSY9o3wjxI6A+iSaKZpAkU5skee8SZyYxtRjyQBI0GQC5HDlqF/72tca6AOYAnADoLJ//34DOm644QYDbu68805jVcEuAjABEHnmM59poA9AydGjR3dKRP+X//Jf7Hj2B0TCYP686lWvMgAKMIq5BtCBZUSfAJc4P+cEALrkkksMpKGfgDhXXXWVAVSATqTZsQ8ADwAZ/cNogzZha8FAYhzsB4DDZ1hStAXLC0CJvgBY8ZnxLy8v72g00cbXfu3X7oBS9Ic2SY/jOFhZn/M5n7Mj4u7YSYBpHOtKeOMgM2eMHTYTfWU/wCsYYuzLizQ+5gj2FGNk/jDm9NJLLzU2GvswnziW9IV5J32ReQbIYwxsL6200korrbQniuFPLbQ9JaGvkCCmV7yb0Dn/4UXmrHT+C7zA2EZ2ZJG6RxpftXFQipFwIJgI7Yr0vEnBmApNvymdxcoM5fIsKAQYRIEbivXce8fNJu+wuLpHrU5Ls2ii2TTSSrujenvJWPkASCZBYUwr+FKwuUIFjUuVoQ0b1g1QOru2aRX9ojRTrd5QFHfVbNS1Z3VVaZaaphTaU4zKJ+g2RfNzZpX3YEaxPUldhb3Mni+CCqwnAt4AU8wD6Yy7Yus8XyQ8ZxQaXLkEZcWeJSywOqMCYEXtlq8k8XLgiuyHLFDVKimV9ni3EpQqrbTSciNXPIZ1w3/SrEJ0Jy2qWuQPtlbqlsUDnaior5a/qsVqS0ormkw3LUec1D3AkDCokGlmC1I67WrSPaNRd0PbzUCVbKKN+29U78T7NN7eUKda1bHlPbpstaVDB5ZVSXoK/Vgb6+dtEV1oBZrFsS2kaSXQVRcva3UR8fFMa9sTWzhPnB9omqQWGdroDXX3yfOKkplq1UBe2NbKdGIL3WA0Mcpz25OlD86SSEGlrbDWkFdJNBwgrE16W1G+tKgIgl6TP/FVq0pXHmxrTzXTYj1Uza9oaxSr1x+qS/W15UVb6DmwHyX6wN2ntG+xo30Li1rs1HVg34rq9aq2xz1tdceKJrG1n5fnzSNXebQp1yCIZpnGUzSyppqlkTHSzq1vaDgeaFgIXrebbdXbC8rCqoaTvhKiR3b9WMhhVqXqDfJqe543s5x/KrsMR48tUAqQBfAGAyABrAH0IJ0NAOXFL36xpbfBnrriiit2ynnD0nHmqsc5AMQBT84AqDDAHLePA1kw2FbOAKIwgCMMAOfCdjCAHEAZXs5c1UDAJmcwti40QK95w5FlbM4AvC5sE3MMqPntru+uvxfaQ53fjX9+DgDA5o1zAfTB4oIt5phS119/vV0zt//8WOb78NH6U1pppZVWWmmPd2vW8U1zQAqgpUiuy4vKAS4ZkIM+UkWhHxoTyfdhrhfsdYCicNEqXGeVUD6MqWQkpbEqflWajXJx86JYyGg8VFhvqN/bUs1vGfizuu+Q1s+d0mC4qVo11CyK1Qx8JV5FcWdJk/FY7YVOkUqIh5r79WG4LD9cUjY6oSRKtLjQ0Z6VWLVpnjJIxWkK7PB5NBqrWq0ZQwnfEwqYDwM/qymNpwaUwZninQC2K7bixN7TWWJjMDCNwl3ezPpi7PEkMaAL/5U5M3ZZUVYPsMoYZlZV2ytANZ5Fcj0qtG9Le/xbCUqVVlppZgY6FZovOwAUN/75AATlWKnUN401HkeqZNBm26SmK47JFsvLxpIZxDsLC9GZKOlr/YFbdKrmK+0dkJ9ua+vUzRp3T6lKylK7oyMtX8f21rXaniobHNdg7ZRGvZGStKql1Y5G/UzTRLrscEcb/dgYV5ceWdFk3NTm9lTXPemgTq93de+Zng6sdIwqvNQKDZiK0Z9cXtJgMtRVR/eqHpL3XlFkAJCvaDxVP/PU7DSMTp0LK+Ypbyz2tnDXqvIDT0tNX5fsa2iwPjDH4cByR+d66+oOp8YmWdy/qoVaTRtpvrjedmpD+zon9blPv0z7DuzRZZVEgSIlk6FCr6Jmva7TWxsWSWtUPY2izIAoqqxw3gT6stcQhfJY9KlkuNVDADOnWEdeRfVGS7WFZY1NwJwqiKTzMejdasSIUU6mgFAs9qma01C9AVE5PWYN4AggyhmgD9pJpT061wJNqXlzLLDSSiuttEfT0MpDdw8tP/wWNAIJcFA4guAFDNRPl5YdWnqkVXNO7ouwSknLvtBIu4atiubhhcaD+n333WcP7wQeLiwAwdr/4Q9/2IIA+BUf+MAHrB3Gx3hgtqKZyJpIgQ3SztEwhLVa3pcfefMqMyX4u0nO8InTRFOq78FIruTspHH8/7P3Z7GypvlZL/j75iG+GFesac9DzkNlTa4qGxvbmHPaQDdHHOgrBFw1aiEkxAVXiCtuEUhItAAhQEIg0Trd0A0+QmAa2xgMVa6qrKycc++de1rzivmbx9b/jb3L1Qh1n6rjPkmW3ye1tKaIL774VuR+33j+z9CwSUU5BFFgqeKdwLWfNdvJh0edb+hMHxkbtpW03oLlbZXNopoXhZRY/bI8xXKkAEf24xn33n9btfLdfuFFiixRURxb+72HaTnk0pIbx4qUUqmiosZS6qMGx79FV1fED/4jy7NLskxCyVPitGKV5ISBFP0IGeUQRQMMydVsJfSpVI8hpJTaJ9fb7FnZm8r/a01Tqe8TaextWlUO5DomjSHxHNvICbPd5mtVVUuay/5Vgtu3ym5bzRw7irIlKSRNyyT0XHq+geeJTVJIM9nP/reXjarx40GTUhoaGoq3UKGG4ltXKh2Z7Gz/kd9OVNQuSTFS8rs8rdhsCrJ8m/0kZJY0YHiuWM8MskJkvPK7jrKSZaNm5ZyyPnoft3iEa+fU6RyZvRwEfa5HNq9INe1oQTv7hHid88nHFyS5xY3rrqrIlcyrr74xVlLhy1VNr+cxX27wrJa9iYXtWXzhjRc5O1tzdplSNR2TSURWyWLoMFttwyLTLCMtGxUWWbSyKjrMNglNVZEnwvxsVUa2vW0elNZBlS0lOQGey8tXeowCm03TsDd0ma4kZNFkEVeMNxs2l+eMrl0jlgW67sjLht++f8KdKzvc3NvnTs+EKqHMchbrkjRHqatulQ3Hqwu1cVF2RLtgmuUEOwGeH1K3FlVZYVs21w8PeXT0SH3vOSF+tEdt+6ySC8oyIfSfkYIymWpaXAtCz1S2yqyU4EnZ3HSk+X9b7XsaGhoaGho/KsRa/Df+xt/g61//ulKbioVZyKO/8lf+Cn/5L/9lRU49z8MTa7FYlL/yla+o7DwheETRIapaySuUsgchd6R9VYgeUYmKRVq+FxWrvBGXz3/rb/0t/vSf/tPq9mK1Fnu0HEfy+8Te/bxcQ+zl8hhCHkmuniiAhTCTsgo5RzmeWLvlfqJ2lQw/aYT9O3/n76hmVGkzlduIUlUgb+Ll90JI/cqv/Ip6DLmNDHCeK2jlXORY8rhCnMnjyjmKwlfy/eQ8RcEq9nC5j5yHHFdUx7oh9UeHlM+kcUFRSaGOfF8z31RkZavKbUTtLza0s2XLIm7pBQ3TYcegVxEGJr3AJqpSjLYmi88J9u78wPAnaiFR0kvZjXyWISuWTZLEigySpKlrt1/iwf33mV2cMd3dZ5VmSMySxDSUTkNe16TJhqaVMFSLriu3ivy2xu69TLM55ei9j3j8eM2qNJQdcGDY6rUvinxlwWtkP9+orCnZR0fW9jnJflmFnsvxRLEkw9xn7yHkfJfLlbIESvRF2OvozEr9XrKiZOgtFjyJmMhKee8g+2bJOzWVW0Meb7lpuFgKwSdEnsGw1xFJ5IattF5YtiiwPutXgMbvBvS/PBoaGlv70f6BylratoI883Q/q61ViqGmfeYHb1Vbna/Cmy2qpv0BYVNVnmrgS7OSsnjmKRdxjtFhyaSkzTEryafKlbTqzmTAW4cTXrs+ZDpoqBdHHB/NSXObXj/i2hWX0cjBciqaLOb48Rq3F9IPXPqhtOgFync/2hmoVrrFfKamQb5j0fcNBnKbxiLOWwYDn9kyxbAcDg+mWG7A+TJjlTeEA480npHLIi8tI6KWEu++UkwZNFWJ63hEgc2rN0cir6LIctabTLXvSXbWMqnYpKXKqooOdgkcg1RJkFvO1jVvPzjl2t6U6f4BXbKkSEtMLHZGAVVdsTfwlVKq3VREvkVb1STLNb0rIll21bVUkmfLwjbNrQ2xFZvaGKxQWfziNMboSlrPVH+XsjZVI4wKQXcMZT3MikZtAIQ0jBOxKuoJk4aGhobG5xvPVd4CKZx4Xg4hLap/9+/+XZVvJ9l2//gf/+Mf2LqFzBFCRkiqP/kn/6S6n5BIQmr9i3/xL1QunqiihICShlEho4Q0EhJJSB/5/h/+w3+oiKF/+S//pVI1Sa7gP/pH/0gRT/KYongSNZQUWEhZhxxbMg+fn6uonEQ5Jefy5/7cn/uBNVqIMYGUZci+SwgoIaLkfn/oD/0hRYYpNXVdqw8puBD7ujy3t99+W9nNRWElkK/l/CQzURRaH374oSLk5Gd/7I/9MdU2K5mJQlr9sIVd4/835K8oxMliXlFXFm1rs0waZjFskg7DbNgdWgx7BlVtkucmSS5lJx2r2CT0W0aDmuHkMeP+S+TpCW0jLdhy3y3xI6/jvCoolfpoK4EvSmkP9og3c7J4xc50T+3Fpd1a1ExpEmOFfSrJauo65S5oqm2hiyG9eqIwMh0cd5fi4kMuLwqOzmMu1pki2XpRuFXYS1aUDJebbduf5F/1g3D7vkAUT46tgtdVjlS7zarcwiBNMkWeiZXPMnz2Dnxcp6RqTWyxO1omtTgwxLLnGTiS+SFEkynvN1qK0lJh63lpk+ZCQtlk8vahlPxVIcTEfiiEmM6U+kmAJqU0NDTUlMP3Q6Kov5W4PwtfVGr3Z1a+7YZvq5QSBY7nyIzCUYts3ViYZrSV94aNiIMJg2061XbjZXAwHjAIejgy26gN7u7t8caVPfb7HsF4Spvd5+TRBfNVg+fbDCObaORSFjHvvn3B/aOUB+clq3zFl++OeO1GwXc+fEjQ93nh1pTLRcVsWfK9RwuyqqQQK6FlqcynznTpTJsruzvs74wUubPepCTVdrFWwmg7wCwSMEUuvCWapOWjqTPqylaB6Vd3Aq5NPOLzNRg+m7zleJmriVjedEo5lqc5XV5gezat+N1FMdZ2PDy7JEkzhnsh6eyJUpNdrnO6uCarG77zcMbDWUYlbSemBDrKNEvUZoVSRBVFQllk5HmFZUp4+0ip0ISQyvOaxpBNR4ltNdQVaiMiofObpFEBYbKIK0++/HWqVtXxbhKtlNLQ0NDQ+PxDrHDr9Vopf+RrKcaQXEDJvBPiSb4W5ccv/dIvKbLmP/7H/6j2J2K/E/WUkEdiuZMiCDmOKIz++B//44o0kp/98i//8n/1caUQQ4gpsQiKhVAIJ1EjicpKIOSUWJ/l8YQgE4JBVFTPIY//T/7JP1Gk0PPyDMk7lDf3z89PfvfX//pfVwopIZPExvfP/tk/48/8mT+jzvPP/tk/q8grIaOElBLF2N/8m39TkUyimhIboRBaoiiTcxASS85BjivnK6ScPH8hw+R6PS8G0fhfBhGdZwU4pkPo+mogKIHdjuw/WyGebKVg972Occ8kryRPadvkLJe6KjuSzQnTaUi82ahGajcYqf222BUkx7Uoimd2vZSiLHAcFz/skSYrknhD1I8Iwkjt8oQwslwP2/XVAFaNksWu12RYluS+Sgi7bAlttV/PTj8iSUu1jzVtRx1XHkv20DKYjUIfz/NVnlQQhIqcauta/X8hryWVofXMHqtypZpG5VpdzOcqh2rQ8+mHFvuHkv9Uq6xYz3bVa70yKnUNQkUsCakn9ovmB26LKNwSekW1bTaU4bgErausW3V5xMnwWb8CNH43oEkpDQ0NBZHyKjv4syGHcEnGD2iMbXWtxBSpGlmjVbJbWYjjrCHJOzapTV2ZKlxbFl7b3uppO0OmGxCGPRw3hLYmMH0ie8gilsDGluuv3SW//ylnSyFTXA52I/YPQ+KLM77120f8P97OeLTs2BtaVLXBu09jdsYOk5HFr783470nMUE0UBa6s3WmvPyB7yhpclpIHo5BP7QVwVNIA2DTklYdl6tcyYjlBGVRde0GLEd58Jsmp65lEmXTNeK/r7hzMFDTnaKEUnzvtq3sdJPI5WxTUNSdUj01RQVOn7o1aDpZYEWeDLlsUutCtRBKwOX1wz2l8DrfFERRTN4sVQZWWjTsjR2qsqDMEmxCfLNV5xIEEYEf0vf7LGxpM6yhznD8PrYVqnrc51W5eSnB8+Z2ytVK6KSEqUuYtmwaWrUR0kIpDQ0NDY3PM4TMESLlL/2lv6SIGCGgRB306quvKoLmN3/zNxUhI8UZQhxJ7pIUP4j6ScgdIauk8VVsbkLgCDEj6iZRQMkxRAH1r//1v+bP//k/v1WaGMYPWl3FBvf3/t7fU3bAf/fv/h1//+//faU2EgufPI4omP7BP/gH3Lx5U52rvJEX0kl+L0SDkFaSTyXk1g/nXsnvxUontsHf+I3fUN//0T/6RxVZ9bf/9t9ms9mocxfV1D//5/9cnYuQaM9LJ4TQkucujyHPX34v10R+Lo8v5yFElZAKp6enStUlv5Pz/QN/4A/8rmVw/V5A6Bl0A8lB6nCdFtc3GdWeyiyV6+i50gQtw08hZSzKWjKXxIImhUBiz+sIfEsRSLIpW519yv7tLwkrRJOvVHtdkm6bqLdElSjoZW9XEfYiXN9VFrn+wKNUpT7bYXJZZviujyFFPWJT6DY0XQntdugpA06jXrI+OeJysdk6H0yx0ZXq/4mmqpVLQNRR22hxyAtROuUMRyNFXMljNXWpyFbTddUgVn4he8vT83NFIkn5z3QS0utLRmurlFO/U6DUbsPXlUVBSC3UHlb25bYj2albpX9db89AtYE/u65NJd9LwPxn/QrQ+N2AJqU0NDTUwrBcp8xWiVronlv3FBmlWty2FbKq0e3ZfVzbIis6vKxWzW7L1VaJ49qSci5rS60CGZXiSt3DxjIsQgk7BJ5cxizDhpdu3yYY7jIv5R4OOyNfkV8nj8753rvH/IcPE07illUF5yclk9Ah8uG3PlwyDAz2xwGn64L7s3PCqEcjGwDPYtL3lRXvfBVjtiJBblhmFeePzyhEwdQZ5HWL5Riq6lbW+b7b4HkBw+GAdL2hKFPVbCah4WJZHEY9tXnY5A2PVxWncc0yrXg4ExucEFWt8tA3tTz3gKK2qdta+f4XscVqU9A1ok4SYs8mLiq+df+If/veU042BeusUpsUvxDZd6nCM8vVJdHkJrcOJoTRkMEwY3dnwit37zBfp1wsYwzXJLBc+tFUbTSkIVHW9NDvVBjktjZ3+yFBnEUhIZw1u9Op3nhqaGhoaHyuIeTKP/2n//QH3z8njkT5I3uav/bX/pra14j1TpREQsSIwkiUUdLmKoSQEECSOfU79iOxvpv81b/6V9VnCR3/4fVS8qTke7HdiWVPCB8hnv7En/gTP2hqld8LaSWPLceXN+5CDv3wcYQkk5bW582zz+8nx5HPYrmTHCo59+fqKVFGPbf/yfH+4l/8i+r753lQovySYHQh1uR+b731lrqd3F+e6w+fg3z+C3/hL/zg/qKe0vuC/+WQKzXoWQTSvGeKw6AkDISskSGtjWVKQ52lSB35veydRegjv7csIZdkeNkRBB6GZeO7Nk8+/Zjh9Cr+5BZ0NV1d0ooEXiLQm1ophopaclILNsuF2pu7vgdGq1RVdVXg+Z4qw2nKhLrL8Xd2Maw5bScNeLXamzqI8yFWpJfY+YRAEgLq+aBaGgKruiYIA0V+CQEke+eBclWYlIW8LsVit42EUIlmnbzWTU7Oz7dlALZJ4HtEPXl+cvznzguJA2moaunra59l1pqUVasGqpJhpfJubSHQ5Dy3TdhChHWtgW1tv1aiPv1y/YmAJqU0NDQUfpAjpSYfWzJJyWqMH97kmSKYekY0GYr8kDtspeAlnWHSuIrKUmolqXdVQYQmlP1QLTayIqWt+OIhaRumea0mK63pSs0Ip4uC7350gayvx/OWeWnQqiTFms6EuG7Z1AZWWilV1cvXhxwcGjy8jLl/EhMXNa4Nj2YrfC/YLvSmpWx6iyxXeUppLosgWK4DjUMB+HbLxDHVlGhnZ5c8OXu2QMtGoFbNe0Xnc//xGf+X/+d3OEtNXr62T95ZxGVHKFycKfMgaVdRJbVbyTQ2DbIBUE55aCva1iIrTVJsvvvojE/nqSLTVOtt3ZGWLYukVhuWfpGyF9pc2dtVm5e2FLVVSd/31CPIBkSUXZJPZZuBCrYUyXOlWmA6tXCry/eMYJRcqcCTDUTNqB9p2bOGhoaGxucaqq3r/0tA9w//TgiZ5/Y0UT7J757/Xgic/xLPb/vDlrbnpNdzNdLzgPE/9af+1A8seP+1xxMi7L+EEEeixvphMkzww98/P/7zx/4v7XX/5XMXgkvyqeT5yO1/+HH/a+fww/fXhNSPDs9zcDuP+vlAVxRQplxTIalMbFMan4WEkaxSCe2W14WvrrsQLrJrtp2hchJIPqvsUR9/9B1e+Nq+si80TamyQesi/0FTNpQk6zVP7r2njrN39SZVmbJenFKmG6hCgv5YteP5lkdvWGJaKyw86qZQ6v/GqGmaDcO9HYz2XDkAJFBdji/DWMd1VPvderUgTjOCoEdfEa7SmCeDU5O6bNQeXoaxiKJKmgaLkqPTE3UtXMdWtj+J95DRs5Bd23cJ2yKkJNuSU9vGvo51KkHxkqMlhFVH4KEavmUfK+RXJX1EYmow5aNTtkCt+P/JgCalNDQ0tpAUQ2nyELudmkZIyLdY98xnxJQsJK2a0MhC45hCNgnhIbfb5khJ8LlMP+T3TVsr+5zc1zJsfNsi9B2srmKRmCr8uyw3XD2oKdKU2vDAdomTioukwylNNrXFumqpxB/vSMShKscjVy47hztXRxzseCpk/Msv7nNld8TxPOPByZKkKNXkx5ZKXJlQtiazVU5aGXhBRCOSXy9UEyDxvLtmolr6LMciiIYse0O6di0XRtXYmo7Hcexy3exzkTZEk0MqO6Q2HbVaip1RrItKBSXVwM22iVAIIglhtB1HTYxoM+XTz6uKb378iA8vYqLIVYTeMpaAeMmYQuVd9WT17Rp6nqPsiMXmkovjJ7z30T0eHZ0wX86VbNoJQrkyKt+rKESyLUTh7+R5yQZIgtLl3Gz19zPU9ahVVYqGhoaGhsbvPYg9738N5I202OD+1xxP1Nj/rT0vjR8N0hLX1Z0ipWQzKHvJrcVOfisqKZeuqUgyUdUXSiUv+Z99+durgaSJFxm0+Ypss1U+XZ4/5VZ6gW3LbUxFItkymGxkCLwiT2NOn9xjcf6Q/et3oSuphcjJl5TJAteIaH0X1xkynrh40YyOxZbM6bbt0qLCaps1wxsvMem9y6NZqTKd6jrD6MTy56k9qISqS/qUvFYlv8oPJdDcojNapbKi2ZYkiaNCMlIfPH6sHAJi0xN3gZQfyfsH2RsLbSfDUtkvq7D01lTvO2xb9suiIpPGQhmAm1SVQVWZYIvJTwLP5aG2ZFZVge+C72zjRjQ+/9CklIaGhsIPyCXhoGRxUZM6WWR++F97kfNup3eOJaSU1NE2WPJhNhjSEFdJMJWQH62qahUIGeM5LXWZU3UtF8uUspUlzsK0Qk6OznDqLXEjlru7N3dZJSX7uwNa2+ftTy8pOwksN+iElTJMhv2Ag2mfpi25Oo14cB6zWOXKE98LPIaR+OChbFrmm5zLTa0UTY4XEboh436PTZpyfnnJxeWKN25LBlSjanQdz2Mw3GGzSpV8WWW/WzYfnJUc3jng933xTXrjQ7WIzlcrlmnOMs4U+aM0yEop1qpFU3ID5OeygPuBrJ6ZjGOp2pJ3H5+T1tD3t9dUbIeyqSiElCpkwmTihD3WeaWaVMq24t6nT/jk8RGPjp5yuVxg25by24uEWjZFsjlKs4q8lEB0g8CVsPaW1TpWMmnZJMjkTjYMg36iF3MNDQ0NDQ0NjR8DKmeprOlKiWYQW1kPA9l3lTSypxZbnFEqi95mY5NWltrfZWXNMMpVqY1n24wkL8owOT99wnydE4UO5foMZ+/lZwPi7WC4EjteGXPx9EPy5SXD4TYfrEgW6hZ+4FGuK4y2JHBthuM+g32LdXEfszzDfWbdtE1R0zck6+8znPwC129O+ODJQ86ShbLdOXaL7bq4nkd5OePy/IJ8vGK0c4Bp2UqB9dxKUWYFEp0uboHHT55ysVwqdZMve/qiIs0zpSYzDAkobzBN2Sdvc6XCwFDDUnECyF5bQtAdxxSei6IUwkpiQSToHJJMCC35eaNa+FxLvt8qFjU+/9CklIaGhsK2JnZbsarEUd1Wnv5cQS7/5MuURggQmXDIYrAlskSuW29JqWeOP7W4SGbhsxY/06xp2xLX8SnKmqrOyYuWyPWosw2//psPud4r2LFNrh1I4whc2TOYL9e8cVOaYAzeebxmnYsKy8DyHMaRh+dIIKLFp2cb3n20wHUcdoeBCh5/Mks5nidKVXW8yJQdzrRdDvyINMs4vbggyxouF3MV+l0UMebLu9z1+3RtR28wJE9Pnz0Xi7yxeDqPmfoOr9y9rSZhEi753nDES7canhyfYhobNYUSJVRSNEqxJFMzUU2lJawzgyJJ6MwIP7Dphx6elavWPhUIb9o4rq2mSfKcr1y7irdzm3nSqfBKsRCajsNLd24yW15yeiHXusFxXXwvZCCyfsPFMRvcvCTwXBVWKQGYZdmSyLRq67hU5yXKNg0NDQ0NDQ0NjR8PwkfJUNB3trlMeSW5TxJfITPUhqItVL5TFHm0SYDtlPhVoxRDluynJQRdhsC2B03JcjajrSLmRx8RTm7g+b7KlMqLQpFPi+P7lMklrmlgOja2qPPrktV6sW3MFnU+FiPfZ/cg5CL5mPn6CZ4rhJBJ6EJfBPYGrONHmPaH3P7al7hz74iLRcdSyKpsielK8Y+v8qAWs5YkXuEGHn7gq/cGhiGD1IqqLLFdmzhZc355sW3wNkySvFLXYKQUUa0i5tIip7Ll+brUrbT7tXTy3C0bR9keUXt7o7Oht81lFeVUllv0Q4OmlfcPFlEgw2+f02WsSamfEGhSSkNDQy0akjXke1sy6Xkrhgo3V5V7qvAV1zTV4iDfbeW1kjwo/nhRR8nNflDZpz7k/tulQogr+bwNJhRFkqq4bQuePH3MyKpYnie8cWAwDk1WScWLt0acnqcczQq18PUcl8A1KJ7lXd2+tsvB1OOdj49Y5i3jYQ/fsTmYhJwtUk5mKeebUlnhVmmjqnFF/7VYxRyfzkjSDEybaBRhNhU396TRzlJSZFncXa+HaVu0XYlhW6wKg01ecu9iw+uv7zHwTPK64/aVPXq+zU+/dMgHH34Hx8kxbI88kc3JcwskLDYF/+rbJwysPnsHAbv7V/k//LTBmy9k/Ob79zleJNiOyUyCyKsWPwiIRgcUjavk065MvAYRb73+Em1ZcHr8lE+fnKqF3xOroajOaHFMG8+VWl3JjvKIgpDMKHFtl9KS1pOtx18sljJF09DQ0NDQ0NDQ+PEgOUlJ2uIMZK9bIvFKoV+rQa4MNS2x73UtUa8iCmXf1SevExxRBdkD2q7A7C7UnjPqRyTr+5yfnlGsTvgjV1/B743IkoQ4y1nNFxR5hesM2AtritogXpzQWA6OJWHiDp0RELg9RoMRZ+snnC8eMo0GnF9suIxzBj2DQSgZqrIfr4lX3+XLX/nTfOX3fZkPPv1VjvAwDY8iz/B9OUdTDUzl/YDR5jR1ivUsJ6uS7FijY9BzefLwAUUuOafS9iy2xprAdVQG2ngUkmYxZyspGegY+AZNbajHD3xRVUm7trSAb99zOJYMdCX+QtRVYvpzMCSmotqmjciOV6x/Qvb9l3lsGp9P6HckGhoamBa88mrHZHdLKklOtywM0hQiGVKimGolg6kzMVppfzGUNWwUdWp6E4YNe7vidZcWkec1r9uq2K6RQHRxrG3zlpquVXlTGBUDCWF0+jw5+YQXrozZ1DV2nqmwxaaqOJolfPPjtbLQ9cOAfuSxN+opgqvne+zvj/AeXXL85JKiafE9izgveHS+4WKdg2Gr7CZZ0iQgshZvvCxgMpEJHQzHZnJgs+P2eXU/ILBNulpUXx2WH9Eb7OKaKaYXspEBVN0wdGDoW3iOwWqzYTfyePRozbceHuGbBZFjU+CRls8a70QBZciUqOP9p0se3w442K/YvXGbg4czyqLiF1+7xo2DKUlR8Y9/7W0+PtlOu2SzIcSWJ5Z6y0TU0g4lRxdnXMxWSuEVBBFO0FO3M7pndkpTWoZaJb+WaZ1kF0imu1QSSzbVoCfNhNDvba2JGhoaGhoaGhoaPxpkCxVJ03EjhIoU1KQq3kIsZ1UjtrZARVVYlqNUPqIMsi0L32iexS84KrxbhrhiUwh7fSbDAbOzC/K+hWGJSkrKgCSgXDJEpwStTbdZ8PJBzdn5nFpcAd4Ib+cQJ4gw6gaJ7O+sgIvZTIWUR7bPk7OSs1WF4xhMetsoh0Xa8HS4YXfnfQ7vvsag901syTEd9CnzNReXc2zL4fZhXwWaJ23LcnnJeOzRtRZFWeBZNld3e8yeVlRZoQiyuNwGuPcDH9/z1ZBUsrXaxsbsZJ8tJUAS4i5qq47GNHBMj6apVLC7vImoKjEFNgy8ET17wMXqTA3BxUkg71GksGc6lOyrz/pVoPG7AU1KaWhoKMvezdspg531loBSmdgy4dm2hqiIcUPCGi1MIaZEGGzK1zl1ZTCtG5rOVauz3FeCvWnNbYufPEBr0hNGpWmx44rrluQ+Rbz14i/w8TtHHM02bNYzojeus6wSFXR48yCgagx8z+MLdw/IsoJFUvHKzR3u3txTpE0cr9XiLgTLp+eSj1QrsmieiFzaJGtK1mlBUTU40lAnIZFtoxYyQZdWWK1PYLvbBHV72+ghYxixyoWDHTwzpLZ65G1Lz4NXdn3cOmGd1JR5TWC1/MxrN/nW91c8PZ+xuzcg6XwVeCmknmxAGmXNa6najpNVoQIphzuHXL2xw8efHtNWJd//+B4fnaxYxRkD38VoO+aLOQc7+0ohJi2Adb7h8vSUb793j09PL1QVbhCYREMbrwdVKTZEsUcK+bcNgHSdmqASObdN3YQMQp+eSMHpiBTBp1kpDQ0NDQ0NDY0fB7bVErolcS6ZoCWeW3G5Fquc0Ew1SdXSNAajntoGYxip9NdhmhnDngwcRd2e0yl3gaPscYcHE6Y7fexgQLw+ozEcTDfEc7bZo34Qk29WKkpiZzhhYQ8xggFuNJZmG8y6wPJ9wqZmmdScrlKu7Qg5ZPP4PMe3DQLPYp2YLNYN954eM7w6Jms9huMIN/ApxS5YxFgO/NE/8iWasuB/+o0jNXxerRMs06HtagLHZTT0ufPilMcnK443kqnaMup79Ho+nufiuJZqxp4ObHzPxHc9fEcyV2X4LTZHC8ewqbtMxVIYSFvfVhWVlgUGS5U35dkFlTRw27LHFsufNBhq+95PAjQppaGhodQyO7sL3N6FClKUf9/lZ0JKWbIQYmMaoqoRYkq+FmmvTdc6tIp8+p2QQvGyi0VPJiQ/IDyk6aOLKcuc3aLhSm0w6Dns9jOKtGV6Y49/9T+/x394v2UadJzNlspjLzWyv/zVPQ53Qo5mJV8Yj7m641NnKY7ncDHPlCJKmuqWmUxXaizbIMllsbJU6LcQXK5rUZctpQRMPYMsYRK8WMQm4URuK6GQhqperqsCq6oIwiG90COYhvi7DW1dYw4rkqZlcbkmCHw+ODnmcOxxc8fldGbi9Yd4+wEvTLYthep6SAC8qKa6lvMmZZE37PU23H3hNsvTE379O/f5zx8fcbyqVUOhb8O1PY833jog2DWUmmqeXNAzB1zMN3z88IR1luPYEA1cpvsWvYEQbtJ0IplUYujfypuFcKwbmO4GKnBTgidtaYZpDcKB/Oyze91paGhoaGhoaHx+IbEUBWmRsc4aTueihNrmREkUgxAmohZ6OsvUz4WA8uySvG7ZH0VUZYXt5PT8J0S7S0zHxXZcxqOIyShSToG6bqhVh46UEbnqNtLc59kRNBbOsMcmMZVq3nJDOrNUZUNSDBmNW5W1KiU3g0hIqJaDnYB+UDDqm4yHEhheszfqqIqYrOpwPV/toQ3LJeoNGPsdt16aqvcE/bc3NJ1Hkmc0lSjxbcJeoAbYr71xjffePeUiTeiHNqO+Ty/w6fUCokEP13XwW6EeJF/KUARbJ+8pcImzjEKIJympltB3ymeuDdgktXJbpHmJZTXEWaOILLlBU2/LhDQ+/9CklIaGhsqCct1MKYAUsbS1dG9Dy9VnIae2FjLTsLAND8v0MfC2YebK5vdMUfUsUOqHSSkhY0TmW9U2vcZgR7KP3BzL/HXufkEkzhXLLORX/u/n3B0OmSUlv/HOU754d5cv7UaEoUM42qHubIo8ZZXmxHHK8eWK7z1c8uBivZ2odKZSL4kPveeb+NIwkhu4noPtWLRxQdM0apNgS2i4SKjlM1JnK171HMMMqaSFr67ww5Drtx12DoWqE9JHkgFKrMLlitHj4f2nfO+jj/mtqqQsC8LQIpz0ufmSS2dJha2QUqIcs5R9Tzz2ImE6L9eMSp9gcMCVvQGvXJ/yzXtnnG4aXEskzJ0KK7etgt29hjSvWVYzXgj32Nubsjfd4dHFmWoymRxEjKbg9yQEfktGSRi8Crvs5LnKom3Qa8VGKEHosrMp1d8tiiQL4LN+8WloaGhoaGhofP4ge8/lpuX41CDOt/u8J5eyq6w4XZb0HBiEDcuiYjKwWG1ahqHNZVxRXvFJYpd5MeNwdMZw9x7R5AoG76k8pyI36NpKuQAMClynou4CVRpk1w5+NGEUDYlLmydlguMJISUD5JpB4NHvr/HDmp2RR1nJmZr0I5vpRMgeC9vs6IUS9WAQOjGuGOws2bdKQZGJ7fgEEjZexqwvYiY3IxzHoevk8Ws1AJWBtNxW9vi7ezu88MI+y+yMQiI/bGtrVfRdbFesjQ1hECq1mDRRi8pK3i8UTaVselVl4tkeVVXSWSlNK89fslEnFMqhkChb5OXCVM9n2BOSaluopPH5hyalNDQ0FGSxsO3ud0gpRSo9CzmXIHP1WXTHNZ20ZXSiRpK625rWyKnln5POV4ueqWS3z1VSQs5s1VetMFyWLISWssdZZqFmJHYLP/v7Q4KeyckHY4bnHo8eP2WdDlV17Ghnh7zzObvYcLC7w9NHpzy9zLh/UahmvVKIJrWkiSJJrG7bx93fcQkji6KyiNNG8sJVxaxkXUmN7M7YZTp2qasS05FTM+jE4ldvQ8plsdu/2jHZyZTiqFPexIp+6tIutvlY0+GQb90/IisLXhz06I1d9g5KVVvLc6WUUo91VE2nJM2xOScufVx/D9PzlJXx9Rv7HC+ecLnO2elb9Hohw4nBoF/heDWVFSvy0Da2IeZqYjX0uH6nz2DUYjuS09Wp/K4tMbUlpeRxnz+++ht0QsBtc8PcQCqMNTQ0NDQ0NDQ0fmR0kJewWts8PGt54boQLyVJZnN6DrcPTD49rhSZst+HNK25MnZZri3+wzsXHEx6FG3Dcb9gf/ouL976w8oOKFlNbeXQ1WLzs3Ctgs6oKUQl73hYtY/hVFx78TWeHs0wzhs8PyIpCqyuUYHqQe9YDZMhVFZBUVrZZl9ltGblirLO2HFFiSWbwg1uFNEPbE7nJa7v4/k9MqPF6RoCO6TMtvv3QiI7ZN8s9UFybrbNerbCbHf50k8fcHae83gWY1iGGgAHvofnyx54jeuOVK5sWYniSrbqFp47oG3X1HVN022fp6ilysLDsWxm8Sm2latA9FaUYYal9vuymZUG7u0wXOPzDk1KaWhoKGyNec+8fM+mP1tiauv1FuWTKbfqHLrGozVEJWVuF49OfPJCfMjiIJlTYl2TEMXnR1dBTc+UOnJkIUa2yYTqZ5KN5Bv87M8EHF2dMPvwZfI0p5JAQ8fCdmxcI+TK1T4ffXSf2WXMo3nCO4/nrLJayX3lqEIqSZuIyKI9z+LmlRDblnre7STrYuWwWsli2KlQ9F5o05Qlji/NfDWGkGZIG0iLSMNst8ELCixb/OzqImG2FkbjcnwyJ+r1eOXGAY8v55yuKmWLc0NwvWxL8KkF91nOVmdgt0IetXRNwVqmWpuYwbBPHN/na6++yMs3rvGr3/mE948u1aLvhw2BX2DaIlUWH31GWkg+QEletdyYDtg9COj5LYa1VUIZinwSAlEee9t+2P1/nMezAPquU8Hnei3X0NDQ0NDQ0PjRIXusvDAZRzZFadBzK/r7Mgx0yFKLsrbZ6dvsjEo2ScYoMsnLllHP4dFpxevXRpzMa843MRdnJ7z+Wo/hsM/5ibQ/G7SlqIMq+mFBsaopkoQgGBOEEcMdB2/nKsbZhtFoovawZbyiZ3UMhx5td7SN2BBFkhoqG2RVruIpMMqtVa6V4aX8uqa1UpUNlR+t8cIAx/Fp2hanljD2hvNjGV57VHFMmYvbQfbv4p5oybM13/6tjK/80pDRyOVsKXtmUW0ZKu5jtTBwdyyS8kztTW27hNZTmVieu7UDirXRsUoscxs3IZbAtlmrTCvHSFSubYXH3k5DVkjwuyixfKXW0vj8Q5NSGhoaikSyugCrDRTxhIRzi6JGqKXOwzICTFMku8+pKwtTZU1t1VNG125pJ2NLSm2PKdY/83csgKb8TPzwEv7Yqg+1oP3gPtuP6e6Gk/ddfvqLL0KZ4fkenWQy2TbvfvSEthQCy+ViU7AuRMrcYHcS6G0pJZKc4Xhgcvv6kF7gUuQb2rKQ3lvsZ4GK0iCyWpcqLHJ0KL78rTXRsGRTIcGODX3DxPUrbFceo1I7j+dZTUQGN97YpzwWsivh+k5IWsaYYgX0DDpDpMgmrSFZAzLP2S76KhJAqZ2kGtehWSXcmAy5e2NClneqjeXF/YBZ6vDi60N2DuT2kkMgVzxX9sKsaEmKllVmEpfu9jmb0mSyJfi2hKBInuXB1A+3yqkfIqa2iqkO3/mBnk1DQ0NDQ0NDQ+NHgOyhbBPixOJgYjGIGlVqs4wtvvCyw9MTh2UqzXMlZWXy5Vc7LhYuRmdwKMr6ifQK2Uodvz+dYrg9ev0RQRio4PN0/phgdEjPLbmoapqiBrdhOBlhBS1mb8Jw1GevgKOLBfl6psLFfW/JKrmkqS1VehN6Np3hqOByyYHy3ICmlrIicRhAXbdsksccXJ3QvXvJZhMzmfi4tsnAt4mijtk8wWga8ixRIegqH8v1GfsG8Srn6YMTXnjtC9y6Pebh4zlpIwNQkzgrePBwzctjh6a28WwTo9uST2YndrxHSv21OzjgcvNAKc+UQ8NIqNsY23CZpT5HlxU9r2EQVjLaxvMamlaIM23f+0mAJqU0NDS2JEazT1uLvFea4hpMUUApNsPDNEO1KPzwImwZ5nY6oax8zwRWhorWfpYntbUCbn8uNr+t3U++FkOf5CHJ4SWvSj62JyL5TwXudM78Ycwf/KmfYTwOIFnQ1B37e3u0eczFZaOCzWVRklFPJ+QPnWoVESmxkFaOG5KX8rgBnmsQ1pkimxKjwTM7okgaSzwiT55jpex6bSch4ajF0fFNRrslnVlTqXx0IXe24eWF2XC4EzE/T5S/fncY8vBCJkYmlqvSrdSES66rWPwUwScKpmdTNRuPIvdZzDNu7I6V3fA3v/eAe2czTjeFeizLtbBUKaDImdWlpakbyrqj6iyS2uNoZnFxWbKzaz4j/bY5XmrqpR5J/hoyqXrelyt/EyHK5GqpxKvP5PWmoaGhoaGhofF5h+zzVrHJ0aziqm3g+ya2VXN0YTHpG0xGHWHPJHA9xn2HvWHJ9anHPDa5sQ+DYU3eGty8YnLr7jdospSqKbFcUwWcby4eEe2/gG2FNPWauiwp8xTT9knSFW1bM9jdx704wWxO6XslURhQt0uePKkIvJr9oWwKXao2V5lXvmuTK1KpwDIiXMdkkRWk6SU7e7uy2SRJEga9SNn1hqGJG7kcuhKgXpClGXVVqUiL2quJ7I775yuSrOCjdy65JrESvZB0XVGUJes44fFJzMtvRjj2mrqJsU2TvFlSl7bKlRX1mGs9gtYiSVua1sH1pFUbLpZgdj5F2rBYbrCdhrLckoBlJc9JTWE1PufQpJSGhsYWbQBtiCEqph8onbYSJ2nGMFoHU+UkbVVOKtxQ5DmK4HhmHZN2PpHqyu/UZyFnhDqSBUOIKFnAhbT6gT/wWf6RSqzaZjABh7dyXnttxJVgh8n4NeYf/mf1+OnqAqOrVQtJ2T4/y20+lLR4iPfcshxcx6aqxMon2mQLywyVXW93XDLqtdR1pcK/LbvDtyocJTOSCluHhoJoPOLwBrzw0vacGvVYv0OeCXklJJMQYKY0o7So0HSZGkn7n7oi6nmbNM/JKCHPVCi8SJUk98pivU7J6h3GkyHXDg7IOoe3n36CRD+u1pXKyhIFl2itPNtXHvu8EA+9QSn5VI1BVtZKLWZ2QgjKuUmC1/azqNhMIQNFtbU176tzqRqZLnWYKlxSQ0NDQ0NDQ0Pjx8Em7Rj3WxzTVzmiaWkwCT3qsqPXM/G8ltCHQdQy7ttqCDqxn+0hDZs710wi38d1fUVClazwo4p6A1U1V3tZKeHx3BjXlu1qRtOtyOpzmvoUp7eP616wvzuj7HsYpkfTlkxCaQGETSa5Vx2dEVPVAXnhMgjBNlKi6JDl5lNct6GqUwxbcldb6raiKgt812XY8zADcRRIk3VOUZRqj2nZNj3XpihSVnGC73pcnq+YXpFyn20AuZQALVcrzlybeDMic1ZqX5sn0gYtRJRY8Eri3Od81eHbDnUtqi4Zlts09RTHyDlbpixWLceXLcukYndScTmTZr9k62LQ+NxDk1IaGhoKioyyJFdJlFLPfeBCMonMdpstJd8LeSOZUCo4u33WsqfIIbH3iZ1vawmTwHAJM+wMaXoTEst5lje1Veo8M7Op20tzXyf8F414ABkPDAahxWgwxnRCcPpUKSzXsuhZnFzGrCVLSpFEBo40fNgStC6L6TYXKssK5ZcXwqo1hJwRY6KN6dS09fZ+ttHh2PKYJY3kY8m5i6y553J4vcW2hVSTxfU5qbYl3szWpG5FtVQzjHzyGkUSyQbDsh01kZLft0hripBCjpI6tUrb1dKaOaZbqPvMVznRcEAvuFT1up7tkBU163VLUXVKeSV/A/HWV2VLKQyYIRuVCtct6A1F4i2qNvVX3Mqwn11j1Uii8r62we3PpVqSmSV/glq8kJqW0tDQ0NDQ0ND4kSE7zn5gEfYcpf7xfV81TUs0RVKUipC6spuB4RAEPWhriroi9Gpcx6PuLDZpjGmmVPlTlqsK7FOiSUpp+1i9QhUMWXbOZFSwXosSqiMabjOWVMWP2OjCFV6Tc3zaw/c6Dq9K1EVKXFjcP7LJ8pphz+X1W6lS3IO4HzLi+Lu0Ta2yV33HJk5L0rKl6jqauiIKXW5cl9a9bRSHZMA2jewx5X2Dze6kz8VixiqJ1Q5fGq6LrFQDUyGv8jqjrBo1LF4sAtKgZRR1rJOW3K6eBbELeSUNgwaBY2C6uYi1aDufxbpQw9UwLDEWHTf3eiw/ckhWNWZkEW8MJCJL4/MPTUppaGioRXXbtCeh4c7WAtaK9U0UQLJcCDkjwd2mUkCpoYQKywbLtJUSaUuICAHzLOC7bai6nNaosI0ephE8y6OSMG6xsylz4LNMI1nKhCgR1RJ0UklrVBTtnKA8pDJDFpsFpfK+t3x6uaGopB3PUjW0QhR1ynpn4MjPFGHWKfJFVEJC2tRNidE1pLmQNQ6hJ154ycwq1LEMU1RSEAQh0ysdO9PmWYtgRdNKda2QXEJ8eduwd8TiaDBbrnjv8blSLSnCSt3Gha6gUdfQwHqex/Ws/a4yCvr9Gj/0OZsnvH6lTy8Qy2DAwbhHer5mvaqoiw56P8ieV38DVZIi162tme50DEbSalhQdTWOIvdsSQVTxr1Gte81ypsvaipHVG+GkG+GakLc/s01NDQ0NDQ0NDR+ZBgdL900oLDYZC2+KwHhIXVb0DQyKDWVamgUGZh2wXxtUbcmtlOpSIs0y9RAOKssymJGni1pukuCfkIUNfjDgCK7ABI8tyTqtexOZ9s9d3OTrrkgTiArKy5WEYuNz1TtefvUrQxfYRwZRF7A7lAGxCajSGIlYqpWSnRkjBlTlA6Be400kRB0kzyvlUVvZxxw+wtD3r94j8AePRu4yibTVh+90OX0UoiuVoWVB70drEGtSn2EoCorUfMXjOuKxxcbijDlbGkx8CFuch6f+dy96rBYGgwjh7UQe15CU5q4Tk3edIwHHVbt8PJNE7vziFNL3SYrwAsaVd6j8fmHJqU0NDQUtsVzFpbVV0RM14o8V8ilbjsdkYlMt/WQK0ufCiiXOY2Pbfgq+wj5UDlS0vZhKIucZDqZdoTZBlsbnyHKKCFptvlG20Tu9gdWPEuUWKKs6lri4iFD90XSrCRJczEOkhYV90+lyla88s9tcdJSIuTUllzbBnqLckm+EIuaqKoMimpLXomyyrJEGdayiYWIswl9F9v1CPo+d1+2VPi5EGxNl9N1K9FeYROpiZXYGWlE6tyyShpl4aOWaZaozISMqlTOlbqtqKfkAkrbYCNHFMVUi+c3RJHPxewS88YBdA09z2N/1OcylmNJRpW9vSqqNaVV5y2Qhr1RZLO3Z6ua3a09UmnQFPHWiYKsEzrOfEYyyjlXuKpFcXvLWv1ddcy5hoaGhoaGhsaPizhvMCqx58l3BVkpQ1dRSRkErquU7dJ657SGUivlpUFWyM40Y53InnTbQDObv49th4rQMe3yWRNdxuLiW1jWiijYMJ0auE5GmfdVcx1Wj/nZR1hWrLKk7tzIMKgwupBeMKauc3y35s4VGIQddVNRNzKI3dDWvvo+yVwMPKxmRFk+ZTiWlj5bRUcI3VPI8ayWtnQUSWTaFqawXVanslv9wKdsxRsgyvyazMnpT1zaWUYl0a+yhzVb5knCJpWMqpInpw3jfkedeTw5qZhtWkZZzY39lMcnFuu4YdiDXmgSVhJPIdfJV3v22zdkyzzk6DTDsQ2VG6vx+YcmpTQ0NBSEoGmNDUkppEdB4DgYptjQclUza6naupymq7AMF1M6WkXtJNYxY0vICAHStvGW4ZIJzDMVlW26ihAR6kTUQ1vyaZs7JURK80zNYxgSVC6qqQKza4irIzbtGcvFguVqo4iadV5xuorVtKauDdxn1j0hwsSuJx9yLCHPxLpn26LsMkmzhqoy8RxZ2EQRJXbAlDTv6EcGju8T9vvsX7WYToXIEutdoTYWlmliGX0cw1dKJyF+mrpVwYyW49BzLPJSPP/iFyyVF96Qa/RDIe/bVPftVE2OWRkbTHvE5TLGsAxGQ4/QFy99q+x7ReGodkClSjMbGqPEEjLNFMIPxiOX/YMA33FVHe+2CVGC1Tu1CVHh6Mj1FyJKLopc+0qprUS6rWgq9bfQ0NDQ0NDQ0ND4cbDaNKyWcPNga2sTwmnS3zYdF3WGY3WUmU8jrdN2TdVWKj5huchJM1M13EkERpp9wsHoFm3jsCklLzWhH85ZJ6cYRkHPjxnjqeiHuujRC3JlC0yzC/xgye50SVn0WCwGpGkJZoltdVzdHdMPN9t9vHnATFr5KhffbllnEoEBju1hljWlO2dy1aCoHbyBwzqOoR6p7NX1U5NVVdOKlU8yqLqaJxcb7k5DTNfFnQyU7c+SoaxjEg0D3B0Hw3ExQ5d1vT3u4dAgbgz2Bwb/6dOGZtkSBi6rpGO2MXlyZhAnDUu/ZTyymK1M9kYmfbfC9Uys1iVLfPamBo5r4DjPy3w0Ps/QpJSGhoZC1azJ6wuWyTlNZXJj95asKbSkdN0G2gFGJ9OURn3UzxrlhECCFM8ZYVk+ZTWjNVc0SF5RTymFWpmziPXPkoDwbQh3I8fphDSRqlxbTVfEWmYaHp147ls5bsWymClSarZYEfkuTy+WpEWJQa0Cvy3TVYSUkDWqge5Z65+IlwyrVs0kcSokj4Xt2IrACgMJL99Oi2RBM20Ty3EJhx6vvCkB7gVVu6ZuN4CHbQ6VukvOuupK9Q+nCnCsW+V/z6tSLfYyPbIcT1noWnlOYmfspCVQrpXMnKR5MKPuSvIuVmTcfBmTFY3y7at72ZYilPKioWqE8NvmdOVtSish6aZIwTt6fZvhpIdti1JNtFfbXKmtbkr+EwujKMbEriiPK2chX4t0HKquUhsjDQ0NDQ0NDQ2NHw+i2J+tS3ZGFqFfsTu0VNi4FO400mptN4SuQ9EkSl2fyhCTmnUC56tSkTiyz+u5FSN3TSKEktHiBjXn80ess5zxIMaX5uV8pELBPTOjzxF1eQXX29DJXp1cDYqjqMM2TJraJAoCtQcXd4FnhMRZTJnbVCoT1idwKxYbB9uK8djw9KLB8WwODmw62Ue7JYaXY5Z9Ts9jrLGLV1Rs5hscT1r7cgx3wODaAU0jTYADVlXF1atDjpcmlu8QTB0GeCR1yc7AUgqrYWRwciGP0XFlFHAZG5C1PHwi7d5id+xw3I6TS2nqlqgNg2AKZ3OJBOnwpPnblCwvydbSA9afBGhSSkNDQ9nD0nwJdahsaVkmlbMelZ3RGUuw15RNimdeVQupqJQ8o4/nDknyR8qbXndzLEsqZ89UnlLd1BhNRGeJX11IJEtNNywjpMOj6hJlaXONCbbKm3Kp6lJRJ0KFyWOIFS6Ol6o1JC+3BMrHJ3OltrLNrQXNsEQhZanaWtPqsEzJkTJwLfHyl5zPc4rSoBd6eJ6H7XQ4HqS5gRc4KsfK7zmEI4+7r9uMJ79zXeRxZHF0DV/lRVVdpsIh5WvVLNJ2XC43xHmFI+GMQno58lxMPMvHtUeYhgSix6TVklplbGWKmJNmPTnGxTLlbLYh8Dxmm4RVmitiKcsasqJVIZhC4pVNTm3VirCq6hpvbGKpSVWurJIqhF3UZqqpT8yWgSL40nKl8qREL2XJ88CmMiraulRElc4519DQ0NDQ0ND48RD58Mo1F1tU7Y0MPQsibwfHDJnFD6mbjLqRaAWxzRXMVhauWN+KkiQRRb/s9wyO84x1fMomKxj1K168nvPk/AlPLg3uXCnYn1hs4h6b1GEcSQNfSbb+EMPYDjllCDoISmovVW3NKqyhLVSRkGNHapCbpeIkgMCxleoosCPqsqBoxDZYsjMJOLhV8v57lbr97jWXuE45nYMbOvR3fVarhJOkZRi1VG3BsigwBz692sQYeDxddbx+2KN/UVOJWt+qaK2WzrIZ9j21ZxW1V9d47O9IALvFpjRwleOiYZ127AxdHLum76ZkhaWC1suuZRVLNmzF3khyaE3y2pQk28/6JaDxuwBNSmloaCgIKWS3PTxiLD8gtEYk9VNqM8aVbKOuB/jU7QoZn4yCQxxLFqtH1I0sMAuyRto3wLNNHMtXta51vVILkvzctQaq1ta03K0Frkuo2pWyuQkxpSxzhkyIhFCSxo2aIq9YJTlxkrNKSx6dL1SbnCxBtiuZS4ay/JmSVfWsbc8ROx9SF1uy2nT4gdI2KRWVZYvlcKto8q0az7OJdnp85edCrt0SK+EGca8bRk+pr5o2fxZq7tK29rPFTxZBk7puyBuDQRSR5LFSOTmWQ2DbXIluM/KvUTQxp/H7JNVKaZiUkqmTCZbY8wyqVppRLvnKjQGeY20zAjBI0ob1umZYgyM2RBWWblI2KAWW55i0VkXW5Ipwkowvuca+ZWMbLqEVKRVa3aS0da4IKtsK1N9aZOOWKdfrmaVQQ0NDQ0NDQ0PjR0bgy6RRyCVpuZNIcpuinuG7M0VGyX5PbG1CPLm2rQLAl2mBY+eczg2qZ/u8OCs5Pi/ouZZqlBuEBieXcHYpka0mcWpyZWRyOPLI6hVJ0WEnBr7rUlRbq55hiMpeWq9VrRCWLY12YiOAQoa7RkUv9FU8hxT/tE6N6WzbqfO2Y7wrkRYO7Z0AKwjw7JZMslVFdd8TlZTNzVd2KKwBlpPjtw7uyMecbZheGWJKzmlicpKmXDkIebIpVNys34dFXiiC7eUrBucLi2GvZbMxOF22agAsArHJsKZvQFnb6nx3Bx2+b6i4jHVskWQWu6OKLC8xDZFySeyF3sj+JECTUhoaGooEcowJtbHAd0oMV2xuOaZMPbo+ruFhmRNli2ulCratKIoFRjtgElwjbY621rayUFY6lxDfcmmw2RQ5hrTiiae8C+lqj7aR4/sqmLHjhLbLsMzbSvGk2u6Milq891Kpu8qV3czzfO6fzlgmkvPU0JrgOLaqpBXbn+0YakEWskZCzMX+NlvWWK6F6zi4noPjtHieBdJQZ0vDxwjLs3jpzR637nrk9YKiOse3BrjWLl0n4Y0NWZNhq7wmsR+aitTpGtEkuao+92S+oeeLsqqlrGLKyiQrLjHbgrhZs8jPlVTaNAeqjUVseWHtUxSGav17cLTkGy/uMI58hr1QXcMkr1jPJSDSxrfAMSQs01N5UFIjLJZKUbiJisrBxu46iYHExVdTsKKrVE6Y2CLrtlbHlMBJ1ZAotzWFdPM+61eehoaGhoaGhsbnFnHesYpz+oHsQ03aOiStTFbpudqXOmbAJjY4W5REYUNbuSzWkusp7c819x9JrlRLFIhiCuibtAuD5cYmz6VpumG+FmV+yyfOBf0w4dYVWx1rtipwraGKo3CdllKRVbJXDdkZhNiWVFoXbFIhdjpG/etMR3c4W3xEmp2QF64SzLuOQd1W7O25BF6tgssfnRbYpqEcBjUWjVlgtYmK0JCG7WAgw1ST07aiN3QouppZ0ajbn60NfHnP0FWqeCctGtWCLcTax0dCzJk4bklWWiwTObqMjm1MS1RkFatNThSUZLVLkkMhe+1aokZMJiOH1shZrDp2xhL/oSX/PwnQpJSGhoYSy7gyaTFbAk8a5CR3KMaxTSLvpiy5uM5ATUo8r09RXdA0x7jhCNvaocrP8OybBNb+trHPkKBy8bjXWJ2rfOyR51DVHnlaUJUxo4GF6cQUzQrDGKpFse1kNQbX7is1kqillsuM2SLHNCXkvKRSGUlCjBnYlUFZG8oGJ4SWWOhsRUp1pOtMqZk811HPzXUk5HxLZEkDnm17NK3J7q7Lq2949K0AS4Wrx5hmoNRSIuHqukg140nzoC1B5oaHUXYqNF2mWq4T4DouRVOo6ZQQW2llcRyXGF22Jdgkl8roKzVa14qyqYXGUkGUnheQVhuwHYb9AeNezUtXd3n7wTHrixa7dbAMqby1yFIJV2/Ym0y4qBZKJi6NJKHpqg/XErVZR9FlJOWKJNsoGbmDp4Lrsyojawp8Z4Bn99T5aGhoaGhoaGho/BgQkVQBWdYpBdSNvauY9Dm+fKqKg1xPAsoz0sLm6KIhcAuV45SmDhcrn/k6I887LLdlMOwInQGHO1Mu10s+Prpg1Ct5+YbFRezy8KTC9wuuTm08r8RxRHmfY3Udu4OQtiqZxRvSslYE0NbYJs3NQnaJ+srFtc+ZrXOqaq2a65rappQ4CjPFssShYBKXlbLdDYc2g9DCs2ymIyj9ipOZxcKMGO1KYHtN25WktY3vOlSULLKGsjEpZAraydctbdNSJjJgrkg7izSTvXhHknUUVUOey4X0sa2aVVcq66EMYGWff7mWTCmY9BM2eUlReNx/3BJ68tgWs7Vkx2ql1E8CNCmloaGxbcOzY/JmjZS69sMRoT2gqOe4tqiYdqi7lqJMGQTXsMwNln1Ex2OWcYBp5eR1iskOthFhGDmudZWcmNBMVEMeYouTJhC3IK8kB8lTZIln3MB175CVM5ompaoKvBaVGVWVcHZWkOSFmj6dLtYq50kWuFrCxHOx4pVKBeRYNo4jKijJlrKomzW+7ytZ85aY6vB8UWzZ1K1DUdtYjskLr4qtraEsG1xjzMi2sc1CnPhYbkRSplRikTNbTGOpVEe2MVZh8HUjYZbSvLetzZVGvo5EPbeqFaucjWNup0USACnEmm92mEaIUUSKlJoMIkWitYZJ1A+U93+5ScnrltOTjDyb4HmimIpYzHPSJOXq7pT18Sl1YeCZvrLtSbR5rnKqGmVRlOlUXq6p6pyRu4cpqu1SbJQtRbsNindFbqahoaGhoaGhofHjoUERS45dcblYcX3nGmnxlCRv2GQdmVdS1rlSx1/OG9686SL/yRQ3iSvVtBzXDY/OEn7pi6/x5q0b/MYH9/j+8pg6r7h9rSPwHKaDiN0dmZe2fPK4YhW3XBkPVezDfFWTSXteI1moJUnRkmUBxa7JuC8REPLRcLFacbneKOeD7JtDqd5rxQpXYJodcWEIl0SWb/fNkne1kAK+umKemIxGAXFbYXYmXSf7b0lRLYnzBtuwMaySqnSVW0HeWxSllBLlag/f1N12aFyn2KWtLHt5IYp+2UuXVFVJWQrJ5Kih+CqxqMoO06q5slvTLA3SzCYvTJaq2ahSBUaVhK1qfO6hSSkNDQ2lPNrkK0wrIs7kH/cEv7+h7C5VWPikd406fYJpOKziM8LQpyMkzmeU9YSe55EV93DMiqa9oqS6frTPNHqFpfEJrTTxdTaOnYK5xnGm+OaYYe8ai+SSuDinaB8TWDfp2jlZfa7USsnFT7G4LFhvYkXWFFWl2uTqpsP3fHwvVA14802hLHqO7xPaPqaUe9guvdDA9x08V7KmcqVokma8spbQcoNrV2yuXrcom5VqogvMHQJHCKiYUpKa2oimyWjalKLKaZqZut3EDJQNsemyrS3PcllnNaUsnrWYF018q4fh9LFI6JqEXOx0RqXyBHxuk1S71M2SvdGAZVzQGg6+YzDqBYRhSNstOT9Pma0qDL/h0N9nmYAlFseuYzVveXi/YH/XprEsluWaulyp5+a7NpPeSKmoNslaZRGs66UYLLGdCBkqdWJJlDAvDQ0NDQ0NDQ2NHxmyY15tGi7nomRqGQ3P+E/fn1O1HVd3OxzH5OzSIqsqyrIlzVqeXCSsV6Zq3xN7n5A1rWS3GgOazuF0mfDxk/NtC3NZ8/bHBtcODKYT2WunPD7O2GxKAicg71nMVvDoJKFsa6LQJHAt1knD+aJgGRvcvVox6Ek/s02cBtSNTRg2jPo1aVWqWAdxSRSFFPtA6PtE9iFF7ZCWS9o2xTE6lU1VOiVXRy3ubs0yEZudqWI9np6mtD2H64OOsjRYS+6GlPTkJU1r0EjIOzVlLhEcBp4rCqiWojJU8Pnzva1FjW1LxIREVojKSogsg55nSA8T284jaZdu1CC6VU4GTUr9JECTUhoaGspyd7woGPop/dDGc6TVLabtHLpmwMni+3TmmrYcEccd/c7FsiqKOsN3fPrGLm0XqjaN0PaUfa9o5lwZfpWmS4mLOUUti4uB67xC3cUMgl21sORVyjo/wrQ2GNVj3KBPWW5oy9vc+3ZI18nkp1N1thfLjZqiSGufbRsqJ0o86HmWMI9LXC/AD8SnLvlRgWrC810TuhTTlPpYm7TyqaSbrlfx2ls1jjxX44yu8cEYkJQdtVmAWeJ3Y2hyHEPIrz55ZeLbPn51hyx2KVqLxTpjlbUqUyBNZewzwm5yMDNsd4em6tSibNuirEpoDIOICVlicjq74M7hLoZZUXZCOHkEQZ/d4YjIn3FymnDyaczepE8Y7NI2OZfS0Lde8/R0jv2w4ms/FWyD4ZsltC1NFZE1Id4gonUa3N42LHLdifWxomtrZQekKbEa2RpoYkpDQ0NDQ0ND48fBOin55GFCXFr0A5PDqU28KTjqSoY9WMQmadYxX0nuqMWlVXM5r6EdMh01tHWC0e7y+t07nG9y3vn0hKOLpQrXkOyl5XrbGl1jMF+azGYmPRm4eiZnq5j7n65Jk5YgFIueTWxZqqm5rEtWXseR2/H4rFZ78MCVVjuoG9kPbhVJcuRMKZ1MfNejNUdM+zvM41zlm/pOjWt72GbOKExpWpuLZYcZWEw8n0+PKoaOpZrx2mnLzrBkthLiqKXnQJyZyiEhzYOiFrNMh7ZulIuirsSGJ+3VllJada1BXZX4jkVXN3iWxdVJiGmsyXLZs8qeXt63iPVv2xCoOamfDGhSSkNDQ8l4B4EEkyc0bYjResTZEt/uE3i3WGffJRaPenZJ6IWsspxGgg0jm01zjJOlBM516sok6g1pzYrjxSPyo/8bvu1Rd6JMKpRvPGw3WMaK07VUyaYYpsko3FVB6mk5wzX3SKqEo/d8Pv34IYP+gLZtmMcpG/GkVw2WyICbkixbq8B027JJ80L56POqJRDyK4hUm4llFCoA0rItknzrnff8kq/8TMru1ZqsrijbHN+U46Q00vrR9eg6ybqa49mVkgabpodj1UyCAcHmkKerinUqKqqO0BPlmEFZNGrSVOKhkqQsW0mcDbdiMDwkr55QVRuMvGI+m3P/8X1evTNldySZWA2O38OwC8qqZm805JPjM+5/uOJLb46RbpT5cs33P/yAN+/e5eremF7/RE2UJKcqLWMVMD/o9UjykovNnCgwCYOQdT4nayo826WpGupqg9f1MQdiq/ysX30aGhoaGhoaGp8/CCHy+LRkuSpIq444qfElGLw2OLus1Z5wuTYoaoNVYrCJJc7BoawbfFda8kJ2d6TQZsTBeMiTyzUnl5fKyqYSXw1LZafOVw2FGiw6eEHJzsQizQ2yQixyDUXZqpiNLqswTcl46tgfdfimxdFJw/lqGyPRD1OGfQPHK/GsmnHPw7JqwrBV+0lRRB0MDDbJJbNNgmc35FWB46REXqUC0VeJzTCycAfSDlhxfRpg1iXxmdxeCDPYG5iUZUXbyN5fiCgJXxfLIERBgG20VBJ5ITPSRgbh0rLX4vomm8ygrST4XZ4jnK/XRFGLa3qqnEiuXVWY6hrZovzX+9ifCGhSSkNDQ2llqq7mYtERxymmBJpbnsxksOz7mG6pggldS7KnGqa9EYt0TttINlNDbJ+TV7DXe0kFoiftPZJqyWZ+wiiakOZCPmX07VtUzQmbJsVuB+wOv0yaXxD4feLsmL3hDbp6QMJ1Hry7YbHJaQ2DTRZzPF8qv7zKj3KkdjcjLzICX1RI28a5tKhIywanarGjA0JfSkfOoDBp6JFVHrbd8sZXMu68KBOhHdLskqx28IMepmtitAuc2lTNKbPiHp4phNmQxijxnJI2T8hnJptkQ1qX9Aa2yqTaZDlFbdFZGa0tCi4f23ZJykc0lGwqXzXe+a7P8nLJ0WVG5y8wexv8KANLbpupxsKo1+fGgc3xbMV3vrfmi19a8dJwwTq9YJ5cMI5e5eWbu7TTJVVl0fM9VUPcWaJEy1mkMxbrlheu7WDTULcW57OVkj5v1tDmGdfGHmFPwuj1aq6hoaGhoaGh8eOgrRxcw2Y8dLlM1xxdJpidQyEDUcNmtW4VUTQKPRKx+s0g6MHBZMPLt0PO5hHnS4O3H51yOd9QFhWeaWHYhoqc6MyGupahZ4Xr+ni+Q14WHJ3L7t2mMySTqcbztiHjYoWr6o7ji4blpt1mTdWdKgWarVKijQwsO3p2w9IT657BeCBxFyY9x+a4TJXbQfaHTSdEVikdz2QSo1FKiLlkUXlUzQY/AE8aBh2LcGRzdVdsgi2nl9ug88ZqcFyDQRRgdC7DvqtIqJOLnDzfkmySLVXkNV3dcfsa9KKG5arDaCyyosEwpMFPzAC1hKPStI66Hk0FprBSGj8R0KSUhoaGkkoZ7ZA6d+l7JYE15Pyy5GxdcH0KA+eAvckJeQmh56ppRp03NOWaSX+IZ7psygtm+ZK4mrJu5mSlS+SIf35Nz7vCPPmUoV2SNdLAYbDTG1M3RzRtrYIX6+qJmOowW1mYQso0ZW+6w/FsyYOjOUXT8erNq/TCUCminpydUVQFWZ7gOC2hP6CuW7VQLZKGKIioi5iRG9JVAUXlYpkG0/2S67c9us4lcK+pyZFY24u6prMC1e4XuUPcbkRan1FJM0ld0uFh2ruEzqvMly2Pz8/5dHbMwSBk2LeYZxbDHYfWTAncAzoCVpt7lO0Ko+txcvpddge3MduAeydzZnXO5GpNF55heRVYPlWX0A88JVs+W+QqY2qWwne/M+NLtx8zS59y865F1sy4djAhjqY8OVqRTyOK2qWrIx4dL3Fdgxt70ghzwdFJpVRifcPhnYcLFklHUxpU7SX++ER78TU0NDQ0NDQ0fgzIFmqZtCzSlvOVDCdVrCr9sFNt0FHgE9g2y4208G2zlBbrioFl0x+IOigWqTxZUZLkLXEiVj4ZAEubtIXjOzSSzFrVSunemI1qh54r5VNLEHS0ojbqTHWfwHZoWyGOapK8Y5NJ5pIMn13VVtc0lmqrS5KOtS2tdgZtzyYrOxVavhMZ+G6GH+SKfKpbcSZIFpWJabvKLlfkHa4FnmsRBjZdUDEaVRzuQ+BBkgsJZdNra3Vevh0wHXqq7a9uGz540JIWlsqKkjKgIDSU6iuvtqqvu9c7xj2L84WhsmFdyyLOXFzXpGpMaiGjpKPbMNU10jEUPxnQpJSGhob65zzyOjUNuTKeYLQOvXCNeWnQ8yte2H2Jo/RcLYxCrJTtY5XnJFlGtj2i70Rk2X0u05TOOFae77aEIGrZi+6oLKb5JiRvQy5Sg0Hg0FqXHC2W7PWukcRnTMPrVOUMw1iyWCbcvP4Kvj/l6W99j1VW8/vffIG3Xn1RtdK98+lTFsmSJi7I0kb56g1TFlQUySWxU26Z8sEH3+HutQE9P1A2waif8OWfsVTg+cB3mScPsOyAnf6EqjphnhyxFxzSYVKXLb5hkrc5dZ1j2C6LJGSv39GaJYvgnGiQMx3usH/N5su/9BXm6/s4XqLyAVbFGT1/l7w0GIWScWUgW4uiOqcJL/niN25zepKSWI8Y9iI17ZGSwrzI+ejpMd+5/5CuszDtlvv3cz46Psadxry5N6WuzolGPWzHY9MmrHIJjAwww479HZ87ewau63K2qLjcSKXwRP2dD3Yirk8d6ralshPCoamumYaGhoaGhoaGxo8G27b5P/+5v0GWpSqfVbZUsq8yze2H2N1syXiSGAiJHa069bVtiTKpw3Wk2dqkrIRMkqynlk6k/wodhiqk+Z2Nmvq+61Tpj7Bf0uosiiYhnixL3ULdum07lbv0g/spGufZEPrZ4eSeco5yLuo7CRq3pKVPjiXKKrmFodr+5HHU/UQA1Uk4ebeNyFD3leezfSw5PYm1eP1ntudlGHIHC0s9fEfdiKtBCDU5codlmqr1T5RccrpynF4gxxJroqGehxxDnpuQaaL2EtW/3Fhub5om+/vX/zf7e2v8/w+alNLQ0JBlhL53QNkPMU0J9Z7TCwcMhy3Xxg2Ge4xRtNw4CIiiiGWSsdsb0HY99kev8NGj/0CWdnj9gEjCGBub1rUZeUPG4Us8uPh3Knw8CgesMweLjCQRlU7A0fKCUZhRtEswlzjmANHyDkeRCmVsuhbfc/nia3fZm454+5OHHF+cUtYpVSUrk4nnOVR1AUag8qZwXVaLI+LNmroJFXkWDVJ++X9fsn9wldPzC+wuJ0mXDII7mG5Az1nxaHWughXzymAYhnjWAseaEHo3aM1HfPxgxu07F6wkn2knpHNO6A9avnxwncnNPd559/sM+kMsd0TUQt/p0TQGcbJimcwp84ZxMGAybtjpxwzCiLQ21KQpqY/ouob7R085nS8p25b9/ZadiceTJyWZmTC60dAUA8aTktC/oC5LjPmUOGt5845P3nVk+ZpZlmPXOZfLhMpouLp/l4+f3Kcf5ESGR2oX5EahNhRaJ6WhoaGhoaGh8aNDIiVu3Xr1sz6N/+Yw+KxPQONzB01KaWhoqIlE5EfEmcXx4oJ+1NB3pxyGAVmZYlhPGEbX6XsuF/H36dqI3d4t0rzj9PIYS4IXVYi2gd8raWyb0MjZCe7SlDVtOmTcW3K0fI+d3pDl2mIyfoUD3+BotaGp54S9Etf2oRrjeCGLekOR1BRtriYxMiV5fHbG9x884HR+QZZV5FlDrydWvFpVx3qujWFbRIOIT+8/wpaKEZE0Oxlf/zmLcCik1w6GeOOFePIOWCUf0jOneE5IVhb0vQ7fsqiNGIyG0L9CmjtsqjU1cP9kznG3pHM6Du74DAKbawe3OY/f44tf79Hvj5VSq0gb6uIxnnuHuAmw2HC0PObbH59z/SAk9CR8vePQ3WVeXLA2nmKHe7Rmzt4oYFU4fPXnICkanjytyfMFpxsJZLcYWzVVnbJaGqre9wu3I/KyZbE5p2rWNEbA3qSH1cVqArZezairBes453Th0EUtB7s9AmOsZc8aGhoaGhoaGhoaGp8ZNCmloaGhpMLr5DHn64zObpivDJbLBTdHHlndUuRDJqMpefUJlA2BvcPj86d0VUzk79JzRlT2muMkZdcZksUGVWPhW5f0gopxZLOsWpZpysS1OBy8okLM6TaYjcE6Calq2O3vEseuIprGuyMeXC5I0wTTMJhvYr790X0+fnrEfFGQZ9IUIvZBiywt2JmMCQOT1jBxA6mgXWI4kDUpX/5Gj4Oba1w3Yp0/pOxc4jJi1Jtidhnnqye0dZ/p+C3q4hGW03Bl9L9jnT3heH7KNBxgWgH9sctvfXLG6y/v0F6s6O/C/v4Ox8vv8unigslIfPxjqEvmy1PSdMD5/Pu8cuc6V/ZeU+0so0nCzuSqqtQdTQ65OH1Kf3CXixnshB47+yG7jcuT2GR90XLzCyYnN0wVinlZwM6+yellTLt2eDDP+Nk3DCp6nK0aFo9j2jDDMhxCI6WsKpJNzcfzYxWI3hEyGewzr884vVgT9dY6U0pDQ0NDQ0NDQ0ND4zPDM4OphobG72UI6WO1O1SlzRV3gpdNWa5yjpcVZjflfJXx4aN3yJKGqbtH3V0QuSk9CwZBRGAGDCOTSc/nclmTVQlZOeFsOWedwQfHCx5e5CoYsahz5psThv05JQkXcUJrFzjGmIcna1pMnG7Gzt6EvCgpq4x1lvPug0fcPzlhviiVVVAEPpYtlbC1IrG8QJpKWgzXIU4voDHoBRFOWFB1cD7b4Fi7LJqUx5cxqySjIKFqpDJ3l1F0kziJyaqMuo04mn+T49kDTNPjMj1m5O6q+lyCnMPpPv2dmM6qebh8qgLe07TPex8X+HZOb/gEb7zB7m+4+dKao/h9/s03P8FsX+bq6HXaumKRHPHR8SeUjsuDk48435ywt2+xt+fTD8EZSkuehMVf4+AFS5FYgTnhSt+lTjoeXlTcutIxj8+YlZJlkPHoqKJvHZLMWu4fLblcOCwu4IP7ax49tGgSjzA08QKH2QYeHWe6SldDQ0NDQ0NDQ0ND4zODJqU0NDRouoaLy0u6os/ZaoPvVAw8g75bMjR28Y0+VhbS5C5ZkpNnJenapSn6pJsK392j17/JbuTQNinzeYlnOYyHr9OaLoPBEN/rkSQO5+sOy+txtobadOj1DAZuxG54nWl0yCwtaT2H4XCHYRAyHQYkWcp3PnpIXlUq6FDqZpWlzzYUIeV6Nq5vY3s2jm9xcvIYt19iByUvfSGkMCsWyx6//b2YBw9C6sZhtpqS5AmRP6QfZaT1ezy5OKI0hpws1zxdnlKYK1zbwLF84kJIMp/Q7ZHka0zLIa8C7j2OuX8kDSQud65FeL7NoydzpUzywgzbqXn59ogbhybDYcfbH51zdt4RebcpypoPnzzhwXFNZ1ZcJGeMRz62XzE5NPnGL9hUpPzUl/a4d2JRNyUn5wvmuc2Vw5xpr8N0DZLskrPLx9y+02PohIS+zet3vkJTOfSCAbMFJHXO7o1dzInNp0cpH39Ys1q2OlNKQ0NDQ0NDQ0NDQ+Mzg7bvaWhoqAaPrCkxTZu2MVlVGUUOqePRdiY3D1/mk4cfQdfjaJXTHw7o9W9AXUsmuSJ50tTmaBlTVh55WXK2mHPt8CUu8nfIrDWzVYtr71B3cxZZjhnkZImNaZacLgqOq7fZG4yp6oYPntR8eWAy6Pd4/fYdjs7XnC0TPMNWdjOpgA17DkEoFbFSmStVIQ2tY9KZBSeP5phDcL2MnfGY1rjkw4fyPAuatmU6Cvj+/cfkrU/gOHR1QbRjc/3A5dPzQlXtHk59mqpmsPuYpn6Bp2cbqjanrSxG/g5lmvD2xxln6zO+9PqYUXBJ1+1zfDFn3LtLkpfsXS351nvHZL2Wq4cO790/ZhUv+MoLL/D4qMT0bY5n8lg2F+uYd7P7fPdezsOyINzts7E63nq55Ve/5fDtRzk/73ucNgVWLyOKDDaNSdk1NNkl02lEz+l4aeeAXuhhWQVRr+FoXfD6F0Nef2nEo+OC2cmRUrx5nkHQ14lSGhoaGhoaGhoaGhqfHTQppaGhoRD5PumiZtF59KwefiRVsyaZ8ZD7pwaBc40wFFIppjNPKIqEplkTGhFNl5BXDqPBkOWlTT9a4JgurVlztswouoZe38PtTDrLxrTnrOcD1XK3WBX0GHLzoM+8OGfqX6MsC4zOEgeeCj//H/7gL/Kb3/4uHz46U7W0Ud9ViiTHMTEdaI2asqkJjJbzk3PqvMU0TLhmMN1vmB62mB5s5hFXDwNemE75t+8c8eikYdKr2ZuEePZU1cxezi5YzCO+eLfHg0dzdiY55/OMTTnDcnIWKyGuHvHtjzZUZcebd3bodSGzxYayzinrBa/s32I02uW3P/pt+gO4mJmssnM+PqpwgdUm4eksZzzOOF1X+EGBS5/L5QWV7XMyz+gNBrz3pGDiu3zng4yB37KMC2ZJw+//qYCPHtUcTh2ujAMW6zGnpwav3oDL9JLzNKFOCla5yTo2+eIbFV1RMgjG+PsTbuy2XCRrDg4sKSbU0NDQ0NDQ0NDQ0ND4TKBJKQ0NDWXhmuUFXVASmQbzpOTa2CdvMoyuIfACxk3HIokx6ozZJsFNHMygR14HzDdz8NaMRxGjqGTohao17uMnR1BHJHmhlFhfvWOyyVwWS7ixO6Khx7p3DmnLZmVBeMhpbhDHNY23xqCl6xpG0Yj9vRd5cFLheAWe32EKmWJ2YDY0tLSdTZ4nrNYrwrEHVcPtaz7/02+e86UXXXbDkERylFqIvIpFVrCOGz6IK+5ec9hbxVStBKSLNbDi08cxZ5cGq8Lm+/eP+MZb0ijY53yZ8Ku/fcn1PRfPg/uPlrR1zHjaUpsXDEKbzuuzTj+mKx0eXzSKmKvKksGg4+FRw/nlKS9ch5N7HY9PKpKlSdN5PDkv2PNLBn14sFpQAL+66AgMi8ORwcWy44t3A97/GB6cdpiZweII8rpivoF9d0J/3CMrS+JqzmJTUmUmdRywd+2AwLX51r2CFw4dPnnq0PM+61eehoaGhoaGhoaGhsbvZWhSSkNDQ6mKIvcq7z55wnRcM92xeXISMx11hAOD9czGaGwqd41TVVi9Kf7A5drV29w7OuH8YsPAKngyL3nrhktjO+x7E4rigO9+8i1c2+bOVZe0y7DcgJ3Q5mSxZhhE3Nq7y/Hq+2RJxxeu/fe8c+8/sN9zMN0NfmAoRdTp+QUf3rvH19+8Q1qVnF4+ZZ0n0LVgbEPPDbtkflZya9rx/v2aG68EvHqrx29/2vDRg4boroHtw7c+mNO1Jvef5EwGNjeuBzydpWSNSVXn3D/uGIQ+lCaO4/HxJ9I+aPH02KfXT4gTk8Nex4cPKi4vKt56PWJ/0Gd/f8FZXPP+g4ayfMhqlXC5MKkKkw/PEqoKrKcGm0VD4NfM10KclTxKSo6emvTCJbVpsmodksog3zQ8XHc8LhP6oUPTGnSmyb9/N+OFqUuXGtRVxXSnZRrYzDc27z695HS25CJrmUxDsrxkfxDy5HHD46NT/KBivmp43NhcmQzI4meMpIaGhoaGhoaGhoaGxmcATUppaGgoZsL1LBw34mRRs9vBdOSQ5ybeoMYOLWazc8aWx2lS4VbQBTXvPPmYxihxfZ9NVfPC9AaLzRo8G6vnM08+4gu3TD46KTm5rHCzjpHlEecFw57NIPC4uFxiWYFSTWGWTEcJLiEbY0ZvWGNc1JxvzjGCDVdvG+xGX+Dy1OXffPtd0qJj4JtcvxEpdVfoVAz3LYwH8ObrfQ6uNNTvdhylBWmcMAk9yrrl175zSloVxFWD7dgs53B+lnH9qsl6DT/9ss/545qQGqNNqLOAt9+PeenVnKoO2KwaHn5o0bgdq1nN3nDN996vSUo4mNh8fD8ljm32JwGmUZGsU0ahS1d17ASeIpeOTnOSpMToQ3FZk8oVmPpcWCbpsqHLbYygobM6rLYmTSwWlxWj0OKbZwWGZ3KRehxctvx3d18lamd8cPqIizAn8F2+9Z9nfPUlWDYlD57UNFXFg+MCpwcvX6mx2wLTHtC04HzWLz8NDQ0NDQ0NDQ0Njd+T0KSUhoYGbddxtJwrssQ0pPGtoMxtTFw2aUK2Fhudw7AG35EwdLgo4KP751y5EvHiwQFV3SMyPAzDJ0nB9goGPmTtkMZZcn0Ucu98QxslBLbD9fHPEVgFTvsxm8xifzDm/vl3sY0azEs+OX6bL07f4lZzhSeLnLquqZw5o92ANHYY9iyyqubVayOc0OC3v7Pk4NDECWD3qk+e1xw9dbg5DbEuLb5y+zXm80vWZsm9i4LO7MjaisVqhVdbvHTLJV035Eu4/0HDT924zsMn9/jlL1r8sw8yPv24o+1axr1MBYT33I4UR/0j+uBxxv1PGoq6U815km81Gjh87/2Cod+RLwxmy4Zpz5dsePKmYhAYGKXDpiroChNMizzvcKwGo6wxXAvLgp4EuFfw5hcbfu3fdRwvTSgrru6bnC5Nlsua/+OrEfeePuD9pwVTH4YjqNqW9z81Oc9jSG0mvsG1nYDFpuKDT0pc1+T6dYtOK6U0NDQ0NDQ0NDQ0ND4j6IhbDQ0NZeGS7KEir3npdkTfcwiDkstFwYffh9OTltBzCHYrNnXJeycJ54sYq/Qwqxq/Cfn6tVcZRzG73h7Xe68SL1IuNzmh7bNruuxGLaHRw7E6bNvCtkqSImG2GdA2BruDQx7NH2K5Gw6CSOU+3bt4F2d4Sm+45Mr1httXLWbLdyi6M958pWbvRsudWxB3a772FYtf+IM2CS0ZDTeuNzw4XvH0Scn/+NVvsB/NMMz7GEVOvWlJFw3V0qBemmxWLY3VklYtxarmpieZTY/4tyc5WVuyG1Y0VUe1CuhHHV+6NuX2LYN+YJIVDR981DErWmzDYXHZsRs4LM9q4kVJt4qYMKBJTM7mNatVQ14YnF3W1DTYtoHTd7FHliK9hCSyFTkIQc+g3ze4XDo8PW+4cruj3mQ0dcNpaZCuUtzGomtqjhcxedlwuW64/xRau+WjxxWL047lvOXBScfxWUO2ccg3FnFsYDRaI6WhoaGhoaGhoaGh8dlBK6U0NDQUwhYGeJjmkvEop858el6DvWcjHq9Bf0GRmmS1SWhb9N2WKBwRmgV3Ji/hlSFjZ8GT5PtcLK+TmxmlUWB3j/GJgBTT6CgLUQzZ1M2aON1QtzMqPyKvzpn2p5TdEeu8wjEP+PUP7/H6S5fcec3jrbfeVO137xx/SOrkHL5ek/QtDg4rrh7scL4y8A5SvvnBhl/4mZCGkts7I974wpf54Pi3ee/xJZ8+aJknFf2eDxJJtYAirHAqk2uHUGQNb+ze5iUn51c+eUoad7y3btnZ7Qg8i5evBfTMAN8LCCZr3pp6/Kt/teDa3pBu0NBlHnuuxYNHJUVh8MUb12iqmnV+QWa2UNS8eSPkpRtT/vMnay4kndxqMZpKEXOtBaYN8SbDGwSEvYadgcGjj0s++QC+9PWGpxPITZdik2GZLpFlE6c5q7TCtwyqpKW2G7JVh2s0ZIlkhjUgD6+UXZ36r8oqjEbPJTQ0NDQ0NDQ0NDQ0PjtoUkpDQwPTMIiChpV5SdTrWC5MirTiYGSwSFvG/YBs3TFwTXZsk929Pp3bgJljBhs+PfkmWVaT+o9463bBR4uUqnHpe5AuTAZuy6JoGQ0kRN2kazKG0YCifExW19Tdig+fnFJ1FrcOemxOB4w8kxdvVfj+iEEUUjZPeDxvcMKaVw56hGO4c7elTWvcZgdntOYor/k//Ym3mIxt/tP37zPq7/Er/+ab/MYn51ihS79ns7vb4dkWL+4PeHwREzfg7RiEvsnYGhEOnrC43zDoe3ztBY91ccmdmwZ/4Ksuq3XJz73+Ck9OT4mGNsvVhrs3LHYnBpNrfcrTjnIecm+e8tbVq7ROwUdnRwwjg03S4Lmwf9Pm5gtDfuPtNWZhMQwcmlHJzvWWpx+bXN/xabyS87Sjs1sME67f9jl5lLGeGdx6A97/ZoVttLyy67I/ClSTYFmUvPCqzem8I8k9iiTFjSA9k25Cg3DicHXXJ3JtvvfJEvERtlXzWb/0NDQ0NDQ0NDQ0NDR+D0OPyTU0NOiMjthccftmwXpdYdoVhrfBDmPuviAB3htGI2lzs7h7I+PO1OTNwxfYvdowHBasyg3z4iGHY4f5+SvcuV6z08tJ0xzf7nPnyi4WPn4wYZ2nmOWE08UnpHWO3zdw3Qsco+aw72NaJXHTchp/yNfuhLhWy5PTJb1By+vXR7z00oBBz+KFnVtMIw8rLHjv+D73l3P8QY/anvH/+u338Q2fk/Vj8jYmMC2KTc3QrnjjbsNss+HagYnbGISho2yBrx7cYd/bpbNz3ngDXrk94PquQ5vb7E4tXr1bce26g+HOmQ4CzApevjng574RMu7b3N59iX0jZF22/A+//ypffM0hMGZ87YsGe4fglXBtD7705j5Fm2MaMV+6HVE1DbPzhvUcXn/D4s61lv3djl/8Weh7nZoc3LrV8taXe1RFj/FOy7WDlv/u5wK+8pbFF2+EHC/XNE1DGDZU65pmnTHwDAahiT22EKHa/r7P3p7Hu/fmtHWDY5m42r2noaGhoaGhoaGhofEZQpNSGhoaKlSqP26JnIhRZLFaW7z3SYPtuyxnFr3+DjYu/W7AYp2zWpt0xqdMg2sURYgfNHzxjds0lRTotRhdn7Ip2XevUHcWlp+QxxVNaYER4IZXKZonXN19g7bzqepWKZheu/smee3hRxWXZcPp3KVITOI6ZzarIO9z61rIlcmENLugSgY0tYXr1rzxxiHj3oR/+2/nVIsR+dpgf8/g8JrD178UYOedOre9w5bXXjW5cXuPwZVKZVd97Qseq8sZR0dP2cWnclpeeb3l2jV47e4udA6LyuSFWwGHe2Kfm1PJsQZ7BP6IW68WXL8RMn1hyB/+IyFhf8H98yccb2Kscc2uscOtyYAbNyyu3zgkX6d8+VbLl14AK6zZiRz2N32VD7V/YDAceFy5XnLzmsU3vhxw/XrHfJmxfJowbg1+9qdNFpct73zUcfP6mGCcYYUtoWORL1u6rORLb1hQNuzfMukFFrev9vnO25cYrYllGoyGFtOJqfLENDQ0NDQ0NDQ0NDQ0Pgto+56GhgYGMA5cPA5Ylsc0bcvdK32cPCBOJuzfsDg/PSOrWnpWzf6VOT0rJGxjUs/iysEN2tolbx9QlgXzVcym8Lm1e53IecTl5oJd7yWMQcr7pzEx36bnRNw48LmcnbNYG9y6M2edlJAPKNM1kyiksyNuDDyefnLKnn+H/dFVPjn/NuvVmheuwDv3KoJ+S4zPt799ydDqU6c1V285bJIVB5MJ1d01y++veOMlm1deCymzmp95qSXqzfn6z3fc2vUZRBFFEnLz1pDIHLF+/CHRlZbBbsmyyBhFN9m7vct59T3Oc4/RbsorI0lnipkedmzKkuPZgvBKQR6b7ExdvvDmhs0i5OPLmk+KjD/yi1PMwwIsl/GoYHzH59OnNb//6wFR7vDhOzUTJlRpyeHVPpMJvFDDvQeGClv/fV+z2B1Y3L/XsKYjSxuu34JwYLO8n/HKFyRDyiR0bDqzpbVzbu54LBx49acHdHMbD2n7K8ExuPaCRVXVn/VLT0NDQ0NDQ0NDQ0Pj9zA0KaWhoYFhGFRdxiJ9TFzWGPkhP/1Tf4Sjk28x6AlZdcTt/ducW+fsT31cUTsZHtmFRbh4k8YYcNH8JlXe8eTknPE1ixd2h7jBOfuTDQ9mVznP3mdc+0TWVrmzG/rQ/BqT8TnvH8FoDdfcc9xixL2TI6b7DUeLksE05M2rLo19xDKNMNqavf0Mz7/KeHrJJoP1oqTOCmwn4g//zFf5+OJdvvjKHVw35OQy4ctfc2lzk9WljRnYjCc1e/0eL01HrJMG26nw2jGR3+PJ7H3OuwVfcW5g+RLMfkpeBKwu3yf1K5wiIhqPcYOOs+OcTZ5yfJlz+9qK6eQuZ0/vkbcGj049NlnBCzt9Dn+m4OUXjzgtPRoMGidheCXiF994kXtnnzJbpLjjnFfemIDVY++Gw4fnczbrjnDQcWW/ZRpC7/RF8mDOfzy64NrLLVcmNuNhj5OLiqsv2Uxdh298w2C5zpkENgc3YI1Nr2/x/Qcr/vB//wq/9usf4e3C9TsNmyc6U0pDQ0NDQ0NDQ0ND47ODJqU0NDRUG5uEcD887jhdddyd7rN/+GXizTvE2SWPn16SXrTsH/YJC5tcCJ7eMZ/OGh5+9ymh7dKbjrGGBrev+KxzlzKY4Ts5XT1itc5xfIsoeJXl4+8QhQkDf8DFMuP+UUu9djh52HDHfsBl0jGNJoyCBScnOU9nBq/f/iKFndNkHVfCDVkeMAl/Hsv/n1nN1xSNwagf8OKVKxT5Ja/fPWQnMJRd8PUb1zg33uPf/0bMcNBxc9/BjTw29QVhaXE4uc1pfEJprUkWn/Lx8VxZ3DabPuv1I167Oubd43v0ugyj7rh4uOKnnJe5fvUG729+jaIsOT9v+cLdHMcuOdxpSa2Ke8cdXlBycL2AaxvOE49BdAfDWlP7La7rMui1/MIXv8rRxSNGo/dxpiXT/h6BndJ3Wm69FJKWJstsw83+LcbudWp7zVeHU+pgyc3dXXJSBqMNPaOjNnJu3O1zsKw5HFncuzDY2x3jhOd84RsV8WLOW78QYPkFTdrx1esH2Jbo5DQ0NDQ0NDQ0NDQ0NP63hyalNDQ0FLKkYXbicGPvJV69fpf14ohPjj8iLi7wA4PeZI/x+IBN/oC7V34fb5/8S86rBdXU5JtvG7xSj3n4fsxPfeUNQsmQ6mKaqGJdG0y9PYaTAM/Z57XdHcxoRVJNeefTY56cGzz6uGL0pktqZPhRQbPZZ3W0y8+/ckCv1yfwbOrshMCr6bViwRsT+tdJCptN0jIJI17aCSiLe9x58TpXpi/Q1hZNafDRu+/wtIq58zLcvmHj4/DokcFLt/bxXIc4jzm/vMAxZ0SRoYgkvzM5mX+A1yspMwlJ77DMCKOLyf2cD84fcp4d07MCrl21uLLTMGJN33qEsX/E5VnOpq554dDg8XFF6xv4rkXoDpktZtC4THshg8Eus+U9ru+9QWdIuPsj3KZkOjrkU/eE6zt3SOJzdr2AK8FNKruhnVRcmU7oR1e4s3PA7HjNxJ8y7iWM9zqVSxUeRrx336Vzc67tBWBGxNmc3b0FbZhhGLuM8pDI9Wh1qJSGhoaGhoaGhoaGxmcETUppaGjQdfDguObpcsVg5z2eLtfctgN2nB2MZsEmbdnzpsRnJ/j9jlF0Bb+bsDtsSFYZVw59Oj/HOcg5LU655h5QXg5YTtY8vRAD2YC+X7I0P6ToHNKVwd0rX6IXpBTzTxn1G+5cH7BIYx6vGpok4erOmOmuTZp/RJPnjLIBA+cOSfYUp/N4cPQb1PlCEUgvHt7ild07NHzA/vSA1kzIjAl5meAGFT1sDKdix97B7jp+8fWrbPIay/SYX6RY9ZAXDnfpeJnl4XeZuhdkWcMn5yaVv8JuXC6Xkl/l4hols6qgWRbciW5ydW8FXsxiM8MLVxRFjWHB3sSgrDscp+Fg6lK3u9RdwdPTY3pezf0nn3KyWBH1S6bTOwwbiyJwIc/ZzJ/SdDlnyyMOg7vs+ya0Ma2Zcnsy5sn6jEUiarUC3AF/6GdfJCtTnsYfk1sxw+ErvPSiyXz2gLPlmrbJeXH/OuezNQYe5+ucolqzafoYWiiloaGhoaGhoaGhofEZQZNSGhoaqoEtCgxefMHC6TXcP3rIhx/+X7nWc3A9k9AMqJqapGhwqpSmKUlzn4s448X9If7BHicXBvPTj0hWG46aCV2UMM4LHq1g2lvBmYE/XGJaA7yiTxFXfO3l/xFv8y+4N3+P0rlUJ7LfH/Pa64d4ZkFdnLNeXrKfTzmMesyzUx4+banDmCg4Y983SAKTxojJuhk7A4un5x+SGjM+etjDzi12903CXFRKBVUe0xgBK9OlN9hhkRWsNgtuHUwZe/vYvVsEg9uY1iMWq0d0zYbAc/n6K1/FtiLO0/dYxO+yaTLMeIoVPsIISmZFgRU6KsS8akrVbte28PgUru82+M5tHOMGQTjm517ts2u4LFYp92a/TdqUHF9+i8YouFh1DIM5g55DvaqI1yWm0ycKBpyfvq+Ip6wouTl+AbuX43s3eLKeUZtr/HCHkyfS/OdwOsuo8w03Dl7m48en/L43fp4sj3n65DfIZh1pt+TqlYhXbu9+1q88DQ0NDQ0NDQ0NDY3fw9CklIaGBm0Hy03HcGBjWT7zJKYjYb6ekJg2/X4Pz7nk7XvHvH47pDUCoqjP0UcVR+WcF6635OUuRWXx+HTDl14t2d3dIa9KvnCnz+F4n/efzvng/obAyvnGy1e49/jfs3P4NZLgArffEg5aLi8dbu8cYhsFv/atC27enHJxXPFbH6/4Qz9/ncnhmHvf+g6Jd8mXxx7XdjwenHVMhgeEfZdZAkfrBak14+FihruxKLp9Irdm7//d3r38xnEfBhz/znPfL3JJPSiJspRIFiLbdYoCRY+9tv9qgJ4K9NIenAQG4oPlpIogx1UkUSQlPpbcJXdnd2ZnCjKnnAwU7uiQ7+e6u9jZB/DDfPF7pE0o7jIa7dId3WBeXPDm6IAg6tBt3WC1qnh38hveLz6QB0e8OsvpxU2G+YCy+jce3GkzSj8haI052H9BucyI2wVfvyz5/m3A7WHCo/trfvgAbw6g267Y6vZ5euuf6EQpnd4OYdjgcr5g72CPdrpJQpNWkXBwuEd/1GF7dIsgnHG57lFmF3QaHcok5+TiD5zPXpEm2/z+7REf/vuIf/3Hn/Pi7WtubicU1Zr/mbwgLzK60TZpccHDx7+kE48o6fL25e/Z3Njg3saQKO/wZjoliVNm89zFe5IkSZI+GqOUpOslXO1WwPlJzKDVJ5stODpfQ3DMaCvk4gMcrBaEZUjKBl9//Z9UvR9YTkuyZcL81gW/fX7KRVGydTOg1dtjXQLFmMG4f71Mbty/zck852hyxOTijLOsYP/FN3z+tMPu3TFFOeXRToudQcrvvj1nNmswv1hwp9mhHMTsLw7Z7O7y6Zef8c2Lr2iGPSbZ1cbldzieHZD2Ela0CBpXJ+odMRpXbGytmU+OWJcFaQiz6jWd3n3KfElYRQT5ks9//pTZxYJFnlNFBS/3jsmDJVmQ88m9hNu9FRUTZosJ88t9yjBi0IS3k5yiqmgmDXYHCS9fXdLtBFSErJcBm70bfDIYwDqkP3hCEDb4zbP/4qx4xv6fMwatIWljQS+IKOMRq2WDRhgyXTc5nyd0WzFJM2CS/Yn87B15BXFY8Pmjx2RZl2IdcHDynAe3brIoRxwePecf7j4kGWwSt7bIqu/55uUxBx9OaGUpTzb6TJewmh+SdBLevT+DVed6lpwkSZIkfQxGKUnX2mlEVEF+esriOCDKUpbVnNOiJGkkvHuT8XA3pijg27ffMX40JwpDmmHO6TF04oBW1eX+TsFwe0oYN1kvEr4/PGKjHdNodhl3BhTrE569O2FvL2CVTbn/oMXuzce8PVwSRgveHL2h21/zWfs2G4M2w3jI5jDnNHzJ4eR7bt/5O24d3CWfZOxVU0ajJs20y/7VEsAyJY5ikrBiZ1TRrCq2k4B2GRM1lqzJeHf6ip3hXaJywcOdm1SMqMIpRbDi3ckfubuT02l1aTVarMtjltU5ZVAybKZ0g5J5Xl5HvDKt6Hbh4WhMZ2fM/fE+SfeENGnzcCPnycbPaCef0RrfYZqt+PevfsV3z59z935FVEVUyYLd+58wav2MTjjkw9mf+OrFc8Y3Cs4uDxgP1yyyq+V1C/6wt+LLT1t0qz57b46Zz99z796QndGcfHHKMk94svUpVdXm4GSfjfE557Mlp5OUXqPD5vaIyfKMo/k+q7BNFKZs32qSNiP3lJIkSZL00RilJP1lo/NXFa3VioKCPIGtOOL9ZUC+CBimCX//2Q4ZhyybU3aetCjCgi+f9GhG0+vXjPsRDza+4PDiiOPzHxgMcrLqgPm8YL7OeDp+TLcK6RTQS+HtOxhvhpSLJYvpG85nlxD2ebzVIxsfE8Yx5XrFxdlrZtOK9UbB3uQ13VmHKIG9SU6y2eF0dsi98Yj3Z02msznjXsn9fsCigskFDOMlaVyRUVFWOZPLV7TSNnFZMbtcc3m5T8IhWb7JjY07FMy5MRrSbSc82zsijhbsbkFeLrlYBFxkAcfnFUcnAU/vjqjWJe9OJnSTLml8Rrub0Go16W/uMup/wZsP+/z6u1/x4eQFs+maYtrlzs4Wt3a2aYRjVos1G62CwaDPl7+4SZbvM2ikLJdXU5hKtjcSvni0yWZ7xOVxRDeNCcqAsqoI5m2OyNm5ecEw7/Hq5DVBFfPqxQV/3Lvk4HjNv/zyMQ/HD/jti295P4N7t7ucTyGOGzTDlMAqJUmSJOkjCarq6nb0x+V5/v9/NZI+ivU653fP/oNiNYWgvD49Li5huQpI04B+p0sQwrJc0GgkBCxZXc2gCiMaSUR5laWKkmDd5eQsJ2oWRHEF0fp6w+9GHDBsN1jlkOXL68cmV4fWxSGj7tUJdTBfQYMmo1ZEVl1SVC0qIsrlmnURE7VXLNcrwqpFvsoJiK9ncOVFQbvRYL6aUZQF3UZFI4Z5ARcriEroplCGsLpakUhAEnVoJW2Wq4p1NaeVrFjmVyfkNajK6noZXhDmzFYz0gg6KSzyq+8Divwv17rMYWvYoR0nXC7WFPmSOC0Ik4p2c5NB+z55UXFwtMc8m1CSk+cB/W6LIIxYrJYss5KbvRZxFLJiSVldrXmEVtxini0JSRj2GqzDkHy5Zn71gYLw+nmDfptssaAI1gTrnKSMWBQ5VRhfnwCYlRVFUdFPm0TNBoQli1VGNl8Rx1f7hLWIaPLpo38mDKO/+j8kVz/I/5FjhST9bXCskCT9FGOFUUqS9Fe80ZAk/RjHCknSTzFWhD/6DEmSJEmSJOknZpSSJEmSJElS7YxSkiRJkiRJqp1RSpIkSZIkSbUzSkmSJEmSJKl2RilJkiRJkiTVziglSZIkSZKk2hmlJEmSJEmSVDujlCRJkiRJkmpnlJIkSZIkSVLtjFKSJEmSJEmqnVFKkiRJkiRJtTNKSZIkSZIkqXZGKUmSJEmSJNXOKCVJkiRJkqTaGaUkSZIkSZJUO6OUJEmSJEmSameUkiRJkiRJUu2MUpIkSZIkSaqdUUqSJEmSJEm1M0pJkiRJkiSpdkYpSZIkSZIk1c4oJUmSJEmSpNoZpSRJkiRJklQ7o5QkSZIkSZJqZ5SSJEmSJElS7YxSkiRJkiRJqp1RSpIkSZIkSbUzSkmSJEmSJKl2RilJkiRJkiTVziglSZIkSZKk2hmlJEmSJEmSVDujlCRJkiRJkmpnlJIkSZIkSVLtjFKSJEmSJEmqnVFKkiRJkiRJtTNKSZIkSZIkqXZGKUmSJEmSJNXOKCVJkiRJkqTaGaUkSZIkSZJUO6OUJEmSJEmSameUkiRJkiRJUu2MUpIkSZIkSaqdUUqSJEmSJEm1M0pJkiRJkiSpdkYpSZIkSZIk1c4oJUmSJEmSpNoZpSRJkiRJklQ7o5QkSZIkSZJqZ5SSJEmSJElS7YxSkiRJkiRJqp1RSpIkSZIkSbUzSkmSJEmSJKl2RilJkiRJkiTVziglSZIkSZKk2gVVVVX1v60kSZIkSZL+ljlTSpIkSZIkSbUzSkmSJEmSJKl2RilJkiRJkiTVziglSZIkSZKk2hmlJEmSJEmSVDujlCRJkiRJkmpnlJIkSZIkSVLtjFKSJEmSJEmqnVFKkiRJkiRJ1O1/AUj0btIiIRCBAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print(\"PROCESSING: Converting PPTX to images and extracting notes...\")\n", + "\n", + "result = pptx_to_images_and_notes(\n", + " pptx_path=pptx_file,\n", + " output_dir=output_dir,\n", + " extract_notes=True\n", + ")\n", + "\n", + "notes_df = result['notes_df']\n", + "image_files = result['image_files']\n", + "\n", + "print(f\"\\nSUCCESS: Processing completed successfully!\")\n", + "print(f\"- Processed {len(image_files)} slides\")\n", + "print(f\"- Images saved to: {result['output_dir']}\")\n", + "print(f\"- Found notes on {notes_df['has_notes'].sum()} slides\")\n", + "print(f\"- DataFrame shape: {notes_df.shape}\")\n", + "\n", + "# Show sample data\n", + "\n", + "print(\"\\nSample Data (First 5 slides):\")\n", + "display(notes_df[['slide_number', 'slide_title', 'has_notes', 'notes_word_count', 'slide_text_word_count']].head())\n", + "\n", + "# Preview only the first 6 slide images\n", + "display_slide_preview(image_files, num_slides=6, max_cols=3)" + ] + }, + { + "cell_type": "markdown", + "id": "1f95749d", + "metadata": {}, + "source": [ + "### Step 2: Generate Narrative-Aware AI Transcripts\n", + "\n", + "Use the Llama vision model to analyze each slide image and generate natural-sounding voiceover transcripts with narrative continuity.\n", + "\n", + "This process:\n", + "- Analyzes slide visual content using AI vision\n", + "- Uses transcripts from previous slides as context\n", + "- Combines slide content with speaker notes\n", + "- Generates speech-optimized transcripts with smooth transitions\n", + "- Maintains consistent terminology throughout the presentation\n", + "- Converts numbers and technical terms to spoken form" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "fe564b99", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PROCESSING: Starting AI transcript generation with unified processor...\n", + "- Processing 10 slides\n", + "- Using model: Llama-4-Maverick-17B-128E-Instruct-FP8\n", + "- Mode: Narrative Continuity\n", + "- Context window: 5 previous slides\n", + "- Using previous transcripts as context for narrative continuity\n", + "- This may take several minutes...\n", + "Processing 10 slides with narrative continuity...\n", + "Using context window of 5 previous slides\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Processing slides: 100%|โ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆโ–ˆ| 10/10 [00:30<00:00, 3.01s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Context information saved to: output/narrative_context\n", + "\n", + "SUCCESS: Transcript generation completed!\n", + "- Generated 10 transcripts\n", + "- Average length: 541 characters\n", + "- Total words: 767\n", + "- Context information saved to: output/narrative_context/\n", + "- Average context slides used: 3.5\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "print(\"PROCESSING: Starting AI transcript generation with unified processor...\")\n", + "print(f\"- Processing {len(notes_df)} slides\")\n", + "print(f\"- Using model: {config['api']['llama_model']}\")\n", + "print(f\"- Mode: {'Narrative Continuity' if USE_NARRATIVE else 'Standard Processing'}\")\n", + "if USE_NARRATIVE:\n", + " print(f\"- Context window: {CONTEXT_WINDOW_SIZE} previous slides\")\n", + " print(f\"- Using previous transcripts as context for narrative continuity\")\n", + "print(\"- This may take several minutes...\")\n", + "\n", + "# Generate transcripts using the unified processor\n", + "processed_df = processor.process_slides_dataframe(\n", + " df=notes_df,\n", + " output_dir=output_dir,\n", + " save_context=True # Only saves context if USE_NARRATIVE=True\n", + ")\n", + "\n", + "print(f\"\\nSUCCESS: Transcript generation completed!\")\n", + "print(f\"- Generated {len(processed_df)} transcripts\")\n", + "print(f\"- Average length: {processed_df['ai_transcript'].str.len().mean():.0f} characters\")\n", + "print(f\"- Total words: {processed_df['ai_transcript'].str.split().str.len().sum():,}\")\n", + "\n", + "if USE_NARRATIVE:\n", + " print(f\"- Context information saved to: {output_dir}narrative_context/\")\n", + " print(f\"- Average context slides used: {processed_df['context_slides_used'].mean():.1f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "id": "8461761d-f80d-4bfb-8062-75038af25604", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Displaying first 10 slide transcripts\n", + "\n", + "Slide 1\n", + "Llamas are unique animals deeply intertwined with human history and culture in the Andes Mountains of South America. They're fascinating creatures that have adapted to the harsh, high-altitude environments of the Andes. Today, we're going to explore their life, behavior, and the significant role they play in their native habitats. Let's discover why they're so remarkable.\n", + "\n", + "Slide 2\n", + "A domesticated South American camelid, scientifically known as Lama glama, originates from the Andes Mountains in South America. Related species include alpacas, guanacos, and vicuรฑas, which are their wild relatives. Llamas were domesticated thousands of years ago, descending from wild camelids native to South America, and share their habitat with these related species.\n", + "\n", + "Slide 3\n", + "Llamas typically stand between five point five to six feet tall at the head and weigh between two hundred eighty and four hundred fifty pounds, or one hundred twenty-seven to two hundred and four kilograms. They have a soft, woolly coat that comes in various colors. Their adaptations include large lungs and efficient oxygen use, enabling them to thrive at high altitudes. These physical characteristics are crucial for their survival in harsh mountain environments, where thick coats protect them from the cold and specialized respiratory adaptations allow them to survive at high elevations.\n", + "\n", + "Slide 4\n", + "Llamas are herbivores, feeding on grasses, hay, grains, and leaves. They inhabit semi-arid regions and high-altitude grasslands, known as the Altiplano. These animals require regular access to clean water. Their simple yet nutritious diet makes them particularly well-suited to regions where food resources may be limited, showcasing their remarkable adaptability to various environments.\n", + "\n", + "Slide 5\n", + "Llamas are highly social herd animals with a sophisticated social structure. They communicate effectively through various methods, including humming, ear positioning, and body language. While it's commonly believed that llamas spit frequently, they actually reserve this behavior for when they feel threatened or stressed, using it as a defensive mechanism. Additionally, llamas exhibit interesting hygiene habits by creating communal dung piles. This social behavior highlights their complex nature and ability to interact with each other in meaningful ways. Understanding these aspects of llama behavior provides valuable insights into their overall social dynamics and how they thrive in their environments.\n", + "\n", + "Slide 6\n", + "Llamas have a gestation period of approximately eleven dot five months. Newborn llamas are referred to as crias. These crias are remarkable for their ability to stand and nurse shortly after birth, a crucial adaptation for survival in challenging environments. Typically, a llama gives birth to one cria per year. The average lifespan of a llama ranges from fifteen to twenty-five years.\n", + "\n", + "Slide 7\n", + "Llamas have been domesticated for between four thousand to five thousand years. Historically, they were used for transport, wool production, food, and played a role in various rituals. In Andean cultures, llamas held symbolic importance, being central to trade, transportation, clothing production, and possessing spiritual significance to indigenous communities. This deep-rooted cultural significance underscores their integral role in the Andean way of life for thousands of years.\n", + "\n", + "Slide 8\n", + "Llamas have diversified roles today, showcasing their versatility and value across various industries. Their high-quality wool makes them essential for fiber production, particularly in the textile industry. Additionally, llamas are popular as pack animals in hiking and trekking tourism, leveraging their strength and endurance. Their gentle temperament also makes them suitable as therapy animals, providing comfort and companionship. Furthermore, llamas serve as effective guard animals, protecting sheep and goats from predators due to their protective instincts. This multifaceted utility underscores their continued economic and social value in modern times.\n", + "\n", + "Slide 9\n", + "Conservation efforts primarily focus on wild relatives of llamas, such as guanacos and vicuรฑas. These species face significant threats, including habitat loss and the impacts of climate change on their ecosystems. It's also essential to emphasize ethical care for domesticated llamas, which includes proper shearing techniques, providing humane living conditions, and ensuring adequate veterinary care. Although domesticated llamas are not currently endangered, maintaining ethical farming practices is crucial for their welfare. Conservation efforts are mainly directed towards protecting wild camelids, which are threatened by human activities and environmental changes.\n", + "\n", + "Slide 10\n", + "Llamas are truly remarkable animals, showcasing a unique combination of intelligence, strength, and cultural significance. They are highly trainable and inquisitive, making them stand out for their intelligence and curiosity. In terms of strength, llamas can carry approximately twenty-five to thirty percent of their body weight, demonstrating their impressive physical capabilities. Moreover, sustainable llama farming plays a vital role in supporting local economies and ecosystems, highlighting their positive community impact. By embracing responsible llama farming practices, we not only contribute to the well-being of these animals but also foster economic and environmental sustainability. Thank you, and I'd be happy to address any questions you may have.\n", + "\n" + ] + } + ], + "source": [ + "print('Displaying first 10 slide transcripts\\n')\n", + "for idx, row in processed_df.head(10).iterrows():\n", + " print('Slide', row['slide_number'])\n", + " print(row['ai_transcript'])\n", + " print()" + ] + }, + { + "cell_type": "markdown", + "id": "b743c690-6547-4790-96b6-7f5cd0d43255", + "metadata": {}, + "source": [ + " " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cb7f1884-67f6-4a8c-8e80-2c846f111b9f", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "b4a27ad6-4685-48dd-80d3-6d3374e26b50", + "metadata": {}, + "source": [ + " " + ] + }, + { + "cell_type": "markdown", + "id": "5cff4b70", + "metadata": {}, + "source": [ + "### Step 3: Save Results\n", + "\n", + "Save results in multiple formats for different use cases." + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "8463ac3a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PROCESSING: Saving results in multiple formats...\n", + "- SUCCESS: Complete results saved to output/narrative_transcripts.csv\n", + "- SUCCESS: Clean transcripts saved to output/narrative_transcripts_clean.csv\n", + "- SUCCESS: JSON format saved to output/narrative_transcripts.json\n", + "\n", + "Export Summary:\n", + "- Processing mode: Narrative Continuity\n", + "- Total slides processed: 10\n", + "- Slides with speaker notes: 10\n", + "- Total transcript words: 767\n", + "- Average transcript length: 541 characters\n", + "- Estimated reading time: 5.1 minutes\n", + "- Average context slides per slide: 3.5\n" + ] + } + ], + "source": [ + "print(\"PROCESSING: Saving results in multiple formats...\")\n", + "\n", + "# Create output directory\n", + "os.makedirs(output_dir, exist_ok=True)\n", + "\n", + "# Determine file prefix based on processing mode\n", + "file_prefix = \"narrative\" if USE_NARRATIVE else \"standard\"\n", + "\n", + "# Save complete results with all metadata\n", + "output_file = f\"{output_dir}{file_prefix}_transcripts.csv\"\n", + "processed_df.to_csv(output_file, index=False)\n", + "print(f\"- SUCCESS: Complete results saved to {output_file}\")\n", + "\n", + "# Save transcript-only version for voiceover work\n", + "if USE_NARRATIVE:\n", + " transcript_only = processed_df[['slide_number', 'slide_title', 'ai_transcript', 'context_slides_used']]\n", + "else:\n", + " transcript_only = processed_df[['slide_number', 'slide_title', 'ai_transcript']]\n", + "\n", + "transcript_file = f\"{output_dir}{file_prefix}_transcripts_clean.csv\"\n", + "transcript_only.to_csv(transcript_file, index=False)\n", + "print(f\"- SUCCESS: Clean transcripts saved to {transcript_file}\")\n", + "\n", + "# Save as JSON for API integration\n", + "json_file = f\"{output_dir}{file_prefix}_transcripts.json\"\n", + "processed_df.to_json(json_file, orient='records', indent=2)\n", + "print(f\"- SUCCESS: JSON format saved to {json_file}\")\n", + "\n", + "# Summary statistics\n", + "total_words = processed_df['ai_transcript'].str.split().str.len().sum()\n", + "reading_time = total_words / 150 # Assuming 150 words per minute\n", + "\n", + "print(f\"\\nExport Summary:\")\n", + "print(f\"- Processing mode: {'Narrative Continuity' if USE_NARRATIVE else 'Standard Processing'}\")\n", + "print(f\"- Total slides processed: {len(processed_df)}\")\n", + "print(f\"- Slides with speaker notes: {processed_df['has_notes'].sum()}\")\n", + "print(f\"- Total transcript words: {total_words:,}\")\n", + "print(f\"- Average transcript length: {processed_df['ai_transcript'].str.len().mean():.0f} characters\")\n", + "print(f\"- Estimated reading time: {reading_time:.1f} minutes\")\n", + "\n", + "if USE_NARRATIVE and 'context_slides_used' in processed_df.columns:\n", + " print(f\"- Average context slides per slide: {processed_df['context_slides_used'].mean():.1f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "8728d2ac", + "metadata": {}, + "source": [ + "---\n", + "# Completion Summary\n", + "\n", + "## Successfully Generated:\n", + "- **Unified Processing**: Single processor handles both standard and narrative modes\n", + "- **Flexible Configuration**: Easy switching between processing modes\n", + "- **Speech-Optimized Transcripts**: Natural-sounding voiceover content\n", + "- **Multiple Formats**: CSV, JSON exports for different use cases\n", + "- **Context Analysis**: Detailed information about narrative flow (when enabled)\n", + "\n", + "## Output Files:\n", + "- `[mode]_transcripts.csv` - Complete dataset with metadata\n", + "- `[mode]_transcripts_clean.csv` - Clean transcripts for voiceover work\n", + "- `[mode]_transcripts.json` - JSON format for API integration\n", + "- `narrative_context/` - Context analysis files (narrative mode only)\n", + "- Individual slide images in PNG/JPEG format\n", + "\n", + "## Processing Modes:\n", + "\n", + "### Standard Mode (`USE_NARRATIVE = False`)\n", + "- **Best for**: Simple presentations, quick processing, independent slides\n", + "- **Features**: Fast execution, no context dependencies\n", + "- **Use cases**: Training materials, product demos, standalone slides\n", + "\n", + "### Narrative Mode (`USE_NARRATIVE = True`)\n", + "- **Best for**: Story-driven presentations, complex topics, educational content\n", + "- **Features**: Context awareness, smooth transitions, terminology consistency\n", + "- **Use cases**: Conference talks, educational courses, marketing presentations\n", + "\n", + "## Next Steps:\n", + "1. **Review** generated transcripts for accuracy and flow\n", + "2. **Edit** any content that needs refinement\n", + "3. **Create** voiceover recordings or use TTS systems\n", + "4. **Integrate** JSON data into your video production workflow\n", + "5. **Experiment** with different processing modes for optimal results\n", + "\n", + "## Tips for Better Results:\n", + "- **Rich Speaker Notes**: Detailed notes improve transcript quality in both modes\n", + "- **Clear Visuals**: High-contrast slides with readable text work best\n", + "- **Mode Selection**: Use narrative mode for complex presentations, standard for simple ones\n", + "- **Context Window**: Adjust context window size (3-7 slides) based on presentation complexity\n", + "- **Consistent Style**: Maintain consistent formatting across your presentation\n", + "\n", + "---" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7122cdf6-667e-4ae4-8ce7-67cfc32577c8", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c927fa86-401b-4096-9777-667e5f6e698b", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c5cce573-9172-4a96-bb8c-a55fc7ed21e2", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "be34df29-0e9a-4877-98a5-2ccac6a5036b", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "52fb7f37-7aa0-413d-bc3c-3e625d9b1a43", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "08543fff-1978-4767-8f34-8516925f9e4f", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "29e03124-5ec7-422d-88ca-764a5cab0652", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ff5ce530-b46e-4b1e-b85a-92b02789e3ab", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "34793a3d-9bc3-4337-be53-c7a44d809164", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0b8972b3-1006-4aa9-956e-e4bd37c9f18c", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7b97fc43-b584-4b86-9011-f74a89c7a750", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9dd37180-ebb5-4a08-934a-4e60a9b18832", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7b8fda49-e582-4d4a-98db-774c961ab0f5", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f7da06eb-74ec-4946-a21f-a0dcee8d849b", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "promptTesting", + "language": "python", + "name": "prompttesting" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/All About Llamas.pdf b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/All About Llamas.pdf new file mode 100644 index 000000000..ad7abaac3 Binary files /dev/null and b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/All About Llamas.pdf differ diff --git a/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/All About Llamas_notes.csv b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/All About Llamas_notes.csv new file mode 100644 index 000000000..659ecd8b8 --- /dev/null +++ b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/All About Llamas_notes.csv @@ -0,0 +1,44 @@ +slide_number,slide_title,slide_text,speaker_notes,has_notes,notes_word_count,slide_text_word_count,image_filename +1,Llamas: Fascinating Animals of the Andes,"Llamas: Fascinating Animals of the Andes +An Overview of Their Life, Behavior, and Role","Welcome everyone! Today, we're going to explore the fascinating world of llamas, unique animals deeply intertwined with human history and culture in the Andes Mountains of South America. Let's discover why they're so remarkable.",True,34,14,slide-001.png +2,Introduction to Llamas,"Introduction to Llamas +Definition: A domesticated South American camelid. +Scientific Name: Lama glama. +Origin: Andes Mountains, South America. +Related Species: Alpacas, Guanacos, Vicuรฑas (wild relatives).","Llamas were domesticated thousands of years ago. They descend from wild camelids native to South America and share their habitat with related species like alpacas, guanacos, and vicuรฑas.",True,28,25,slide-002.png +3,Physical Characteristics,"Physical Characteristics +Height: ~5.5 to 6 feet tall at the head. +Weight: 280-450 pounds (127-204 kg). +Coat: Soft, woolly fiber available in various colors. +Adaptations: Large lungs, efficient oxygen use at high altitudes.","Llamas are well adapted to life in harsh mountain environments, with thick coats protecting them from the cold and specialized respiratory adaptations that allow survival at high elevations.",True,28,33,slide-003.png +4,Diet & Habitat,"Diet & Habitat +Diet: Herbivorous; grasses, hay, grains, leaves. +Habitat: Semi-arid regions, high-altitude grasslands (Altiplano). +Water Needs: Require regular access to clean water.","Llamas have a simple but nutritious diet. Their feeding habits make them ideal animals for regions where food can be sparse, demonstrating their adaptability.",True,24,23,slide-004.png +5,Behavior & Social Structure,"Behavior & Social Structure +Social Nature: Highly social herd animals. +Communication: Use humming, ear positioning, body language. +Defensive Behavior: Spitting when threatened or stressed. +Hygiene Habits: Create communal dung piles.","Llamas have a sophisticated social structure. They communicate effectively through subtle signals and body language. Contrary to popular belief, llamas only spit as a last resort when feeling threatened or irritated.",True,31,30,slide-005.png +6,Breeding & Life Cycle,"Breeding & Life Cycle +Gestation: Approximately 11.5 months. +Cria: Name given to newborn llamas. +Early Life: Standing and nursing shortly after birth. +Lifespan: Typically 15-25 years.","Llamas have a relatively long gestation period, producing typically one offspring (cria) per year. Newborn llamas are quick to stand and nurse, vital for survival in challenging environments.",True,28,26,slide-006.png +7,Historical & Cultural Significance,"Historical & Cultural Significance +Domestication: Occurred 4,000-5,000 years ago. +Uses Historically: Transport, wool, food, rituals. +Cultural Role: Symbolic importance in Andean cultures.","Llamas have been integral to the Andean way of life for thousands of years. They were central to trade, transportation, clothing production, and had spiritual significance to indigenous communities.",True,29,22,slide-007.png +8,Modern Uses of Llamas,"Modern Uses of Llamas +Fiber Production: High-quality wool for textiles. +Pack Animals: Popular in hiking and trekking tourism. +Therapy Animals: Gentle temperament makes them suitable. +Guard Animals: Effective protectors of sheep and goats from predators.","Today, llamas have diversified roles. Their gentle nature makes them beloved as therapy animals, while their strength and wool continue to make them economically valuable in various industries.",True,28,35,slide-008.png +9,Conservation & Welfare,"Conservation & Welfare +Conservation: Focus on wild relatives like guanacos, vicuรฑas. +Threats: Habitat loss, climate change impact ecosystems. +Ethical Care: Importance of proper shearing, humane living conditions, veterinary care.","Although domesticated llamas are not endangered, ethical farming practices are crucial. Conservation efforts focus mainly on wild camelids threatened by human activities and environmental changes.",True,25,29,slide-009.png +10,Conclusion & Fun Facts,"Conclusion & Fun Facts +Intelligent & Curious: Highly trainable and inquisitive. +Strength: Can carry approximately 25-30% of their body weight. +Community Impact: Sustainable farming supports local economies and ecosystems.","To wrap up, llamas are extraordinary animals, intelligent, strong, and culturally significant. By supporting responsible llama farming, we contribute positively to local economies and ecosystems. Thank you, and Iโ€™d be happy to answer any questions!",True,35,29,slide-010.png diff --git a/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/knowledge_base_stats.json b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/knowledge_base_stats.json new file mode 100644 index 000000000..03edab3fe --- /dev/null +++ b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/knowledge_base_stats.json @@ -0,0 +1,19 @@ +{ + "total_chunks": 19, + "index_type": "flat", + "embedding_model": "all-MiniLM-L6-v2", + "model_loaded": true, + "index_loaded": true, + "use_gpu": false, + "cache_dir": "knowledge_base/.faiss_cache", + "knowledge_base_dir": "knowledge_base", + "index_size": 19, + "dimension": 384, + "is_trained": true, + "total_searches": 5, + "cache_hits": 0, + "index_builds": 1, + "last_updated": "2025-08-26T16:31:16.688962", + "content_size_mb": 0.012198448181152344, + "avg_chunk_size": 673.2105263157895 +} \ No newline at end of file diff --git a/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/knowledge_enhanced_narrative_transcripts.csv b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/knowledge_enhanced_narrative_transcripts.csv new file mode 100644 index 000000000..7e93dc5f4 --- /dev/null +++ b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/knowledge_enhanced_narrative_transcripts.csv @@ -0,0 +1,44 @@ +slide_number,slide_title,slide_text,speaker_notes,has_notes,notes_word_count,slide_text_word_count,image_filename,context_slides_used,ai_transcript,knowledge_chunks_used,knowledge_sources,knowledge_sections,knowledge_search_query,avg_knowledge_score +1,Llamas: Fascinating Animals of the Andes,"Llamas: Fascinating Animals of the Andes +An Overview of Their Life, Behavior, and Role","Welcome everyone! Today, we're going to explore the fascinating world of llamas, unique animals deeply intertwined with human history and culture in the Andes Mountains of South America. Let's discover why they're so remarkable.",True,34,14,slide-001.png,0.0,"Llamas are fascinating animals native to the Andes Mountains in South America. Today, we're going to explore their life, behavior, and role in human history and culture. Llamas have been an integral part of Andean civilizations for thousands of years, playing a central role in the development of early cultures, including the Inca Empire. They were domesticated around four thousand to five thousand years ago and were used for transportation, meat, and other purposes. Llamas are members of the camelid family and are known for their adaptability to high-altitude environments. They are still widely bred and maintained in South America and globally, and are not considered endangered. Let's discover why llamas are so remarkable.",5.0,llamas.md,"Distribution and Habitat, References, Domestication and Historical Use, Llamas (*Lama glama*), Conservation Status","Llamas: Fascinating Animals of the Andes Welcome everyone! Today, we're going to explore the fascinating world of llamas, unique animals deeply intertwined with human history and culture in the Andes ...",0.7308 +2,Introduction to Llamas,"Introduction to Llamas +Definition: A domesticated South American camelid. +Scientific Name: Lama glama. +Origin: Andes Mountains, South America. +Related Species: Alpacas, Guanacos, Vicuรฑas (wild relatives).","Llamas were domesticated thousands of years ago. They descend from wild camelids native to South America and share their habitat with related species like alpacas, guanacos, and vicuรฑas.",True,28,25,slide-002.png,1.0,"Llamas are domesticated South American camelids, known scientifically as Lama glama. Originating from the Andes Mountains in South America, they share their habitat with related species such as alpacas, guanacos, and vicuรฑas, which are their wild relatives. Domesticated thousands of years ago, llamas descend from wild camelids native to South America. Their adaptability to high-altitude environments has made them invaluable to Andean cultures for centuries. Let's continue exploring their significance and characteristics.",5.0,llamas.md,"Llamas (*Lama glama*), Distribution and Habitat, References, Conservation Status, Taxonomy","Introduction to Llamas Llamas were domesticated thousands of years ago. They descend from wild camelids native to South America and share their habitat with related species like alpacas, guanacos, and...",0.7962 +3,Physical Characteristics,"Physical Characteristics +Height: ~5.5 to 6 feet tall at the head. +Weight: 280-450 pounds (127-204 kg). +Coat: Soft, woolly fiber available in various colors. +Adaptations: Large lungs, efficient oxygen use at high altitudes.","Llamas are well adapted to life in harsh mountain environments, with thick coats protecting them from the cold and specialized respiratory adaptations that allow survival at high elevations.",True,28,33,slide-003.png,2.0,"Llamas are well adapted to life in harsh mountain environments, with thick coats protecting them from the cold and specialized respiratory adaptations that allow survival at high elevations. Let's examine their physical characteristics. Llamas typically stand between five point five to six feet tall at the head and weigh between two hundred eighty and four hundred fifty pounds, or one hundred twenty-seven to two hundred four kilograms. Their coat is made of soft, woolly fiber available in various colors. Key adaptations include large lungs and efficient oxygen use at high altitudes, making them well-suited to their native Andean habitats.",5.0,llamas.md,"Health and Care, Distribution and Habitat, Conservation Status, Behavior and Social Structure, Diet and Digestion","Physical Characteristics Llamas are well adapted to life in harsh mountain environments, with thick coats protecting them from the cold and specialized respiratory adaptations that allow survival at h...",0.6936 +4,Diet & Habitat,"Diet & Habitat +Diet: Herbivorous; grasses, hay, grains, leaves. +Habitat: Semi-arid regions, high-altitude grasslands (Altiplano). +Water Needs: Require regular access to clean water.","Llamas have a simple but nutritious diet. Their feeding habits make them ideal animals for regions where food can be sparse, demonstrating their adaptability.",True,24,23,slide-004.png,3.0,"Llamas have a simple but nutritious diet consisting of grasses, hay, grains, and leaves, making them herbivorous animals. Their feeding habits make them ideal for regions where food can be sparse, demonstrating their adaptability. They inhabit semi-arid regions and high-altitude grasslands, known as the Altiplano. Llamas require regular access to clean water to thrive in their native habitats.",5.0,"llamas.md, llama diet.md","Diet and Digestion, Health and Care, Conservation Status, Behavior and Social Structure","Diet & Habitat Llamas have a simple but nutritious diet. Their feeding habits make them ideal animals for regions where food can be sparse, demonstrating their adaptability.",0.7428 +5,Behavior & Social Structure,"Behavior & Social Structure +Social Nature: Highly social herd animals. +Communication: Use humming, ear positioning, body language. +Defensive Behavior: Spitting when threatened or stressed. +Hygiene Habits: Create communal dung piles.","Llamas have a sophisticated social structure. They communicate effectively through subtle signals and body language. Contrary to popular belief, llamas only spit as a last resort when feeling threatened or irritated.",True,31,30,slide-005.png,4.0,"Llamas have a sophisticated social structure. They are highly social herd animals that communicate effectively through subtle signals and body language, including humming, ear positioning, and various body language cues. Contrary to popular belief, llamas only spit as a last resort when feeling threatened or irritated. This defensive behavior is a key aspect of their social interaction. Additionally, llamas exhibit interesting hygiene habits by creating communal dung piles, demonstrating their natural inclination towards organization within their social groups.",5.0,llamas.md,"Behavior and Social Structure, Llamas in Popular Culture, Diet and Digestion, Llamas (*Lama glama*), Health and Care","Behavior & Social Structure Llamas have a sophisticated social structure. They communicate effectively through subtle signals and body language. Contrary to popular belief, llamas only spit as a last ...",0.615 +6,Breeding & Life Cycle,"Breeding & Life Cycle +Gestation: Approximately 11.5 months. +Cria: Name given to newborn llamas. +Early Life: Standing and nursing shortly after birth. +Lifespan: Typically 15-25 years.","Llamas have a relatively long gestation period, producing typically one offspring (cria) per year. Newborn llamas are quick to stand and nurse, vital for survival in challenging environments.",True,28,26,slide-006.png,5.0,"Llamas have a relatively long gestation period of approximately eleven point five months, typically producing one offspring, known as a cria, per year. Newborn llamas are quick to stand and nurse shortly after birth, which is vital for their survival in challenging environments. The cria, as newborn llamas are called, must be able to stand and nurse soon after birth to ensure their survival. Llamas generally live between fifteen to twenty-five years.",5.0,llamas.md,"Reproduction and Lifespan, Health and Care, Conservation Status, Behavior and Social Structure, Distribution and Habitat","Breeding & Life Cycle Llamas have a relatively long gestation period, producing typically one offspring (cria) per year. Newborn llamas are quick to stand and nurse, vital for survival in challenging ...",0.616 +7,Historical & Cultural Significance,"Historical & Cultural Significance +Domestication: Occurred 4,000-5,000 years ago. +Uses Historically: Transport, wool, food, rituals. +Cultural Role: Symbolic importance in Andean cultures.","Llamas have been integral to the Andean way of life for thousands of years. They were central to trade, transportation, clothing production, and had spiritual significance to indigenous communities.",True,29,22,slide-007.png,5.0,"Llamas have been integral to the Andean way of life for thousands of years, serving multiple purposes that were central to the survival and cultural practices of indigenous communities. Their domestication occurred between four thousand and five thousand years ago, marking the beginning of their significant role in Andean cultures. Historically, llamas were used for transport, providing wool, serving as a source of food, and participating in various rituals. Beyond their practical uses, llamas held symbolic importance in Andean cultures, reflecting their deep integration into the social and spiritual fabric of these communities.",5.0,llamas.md,"Domestication and Historical Use, Economic and Cultural Importance, Distribution and Habitat, Llamas in Popular Culture, Llamas (*Lama glama*)","Historical & Cultural Significance Llamas have been integral to the Andean way of life for thousands of years. They were central to trade, transportation, clothing production, and had spiritual signif...",0.6966 +8,Modern Uses of Llamas,"Modern Uses of Llamas +Fiber Production: High-quality wool for textiles. +Pack Animals: Popular in hiking and trekking tourism. +Therapy Animals: Gentle temperament makes them suitable. +Guard Animals: Effective protectors of sheep and goats from predators.","Today, llamas have diversified roles. Their gentle nature makes them beloved as therapy animals, while their strength and wool continue to make them economically valuable in various industries.",True,28,35,slide-008.png,5.0,"Llamas have diversified roles today, building on their historical significance and versatility. Their gentle nature makes them beloved as therapy animals, while their strength and wool continue to make them economically valuable in various industries. Modern uses of llamas include fiber production, providing high-quality wool for textiles. They are also used as pack animals, particularly popular in hiking and trekking tourism. Their gentle temperament makes them suitable as therapy animals. Additionally, llamas serve as effective guard animals, protecting sheep and goats from predators. These diverse roles demonstrate the ongoing importance of llamas in contemporary society.",5.0,llamas.md,"Economic and Cultural Importance, Health and Care, Llamas (*Lama glama*), Domestication and Historical Use, Behavior and Social Structure","Modern Uses of Llamas Today, llamas have diversified roles. Their gentle nature makes them beloved as therapy animals, while their strength and wool continue to make them economically valuable in vari...",0.7373999999999999 +9,Conservation & Welfare,"Conservation & Welfare +Conservation: Focus on wild relatives like guanacos, vicuรฑas. +Threats: Habitat loss, climate change impact ecosystems. +Ethical Care: Importance of proper shearing, humane living conditions, veterinary care.","Although domesticated llamas are not endangered, ethical farming practices are crucial. Conservation efforts focus mainly on wild camelids threatened by human activities and environmental changes.",True,25,29,slide-009.png,5.0,"While domesticated llamas are not endangered, ethical farming practices remain crucial. Conservation efforts primarily focus on their wild relatives, such as guanacos and vicuรฑas, which face significant threats from habitat loss and climate change impacting their ecosystems. Ensuring proper care for llamas involves practices like proper shearing, providing humane living conditions, and adequate veterinary care. These measures are essential for maintaining the welfare of these animals and supporting conservation initiatives for their wild counterparts.",5.0,llamas.md,"Conservation Status, Economic and Cultural Importance, Llamas (*Lama glama*), Health and Care, References","Conservation & Welfare Although domesticated llamas are not endangered, ethical farming practices are crucial. Conservation efforts focus mainly on wild camelids threatened by human activities and env...",0.7 +10,Conclusion & Fun Facts,"Conclusion & Fun Facts +Intelligent & Curious: Highly trainable and inquisitive. +Strength: Can carry approximately 25-30% of their body weight. +Community Impact: Sustainable farming supports local economies and ecosystems.","To wrap up, llamas are extraordinary animals, intelligent, strong, and culturally significant. By supporting responsible llama farming, we contribute positively to local economies and ecosystems. Thank you, and Iโ€™d be happy to answer any questions!",True,35,29,slide-010.png,5.0,"Llamas are intelligent and curious animals, known for being highly trainable and inquisitive. They possess significant strength, capable of carrying approximately twenty-five to thirty percent of their body weight. The impact of llama farming on local communities is substantial, as sustainable farming practices support both local economies and ecosystems. By supporting responsible llama farming, we contribute positively to these areas. Thank you, and I'd be happy to answer any questions.",5.0,llamas.md,"Economic and Cultural Importance, Conservation Status, Diet and Digestion, Behavior and Social Structure, Health and Care","Conclusion & Fun Facts To wrap up, llamas are extraordinary animals, intelligent, strong, and culturally significant. By supporting responsible llama farming, we contribute positively to local economi...",0.7714000000000001 diff --git a/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/knowledge_enhanced_narrative_transcripts.json b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/knowledge_enhanced_narrative_transcripts.json new file mode 100644 index 000000000..cdd0f3278 --- /dev/null +++ b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/knowledge_enhanced_narrative_transcripts.json @@ -0,0 +1,172 @@ +[ + { + "slide_number":1, + "slide_title":"Llamas: Fascinating Animals of the Andes", + "slide_text":"Llamas: Fascinating Animals of the Andes\nAn Overview of Their Life, Behavior, and Role", + "speaker_notes":"Welcome everyone! Today, we're going to explore the fascinating world of llamas, unique animals deeply intertwined with human history and culture in the Andes Mountains of South America. Let's discover why they're so remarkable.", + "has_notes":true, + "notes_word_count":34, + "slide_text_word_count":14, + "image_filename":"slide-001.png", + "context_slides_used":0.0, + "ai_transcript":"Llamas are fascinating animals native to the Andes Mountains in South America. Today, we're going to explore their life, behavior, and role in human history and culture. Llamas have been an integral part of Andean civilizations for thousands of years, playing a central role in the development of early cultures, including the Inca Empire. They were domesticated around four thousand to five thousand years ago and were used for transportation, meat, and other purposes. Llamas are members of the camelid family and are known for their adaptability to high-altitude environments. They are still widely bred and maintained in South America and globally, and are not considered endangered. Let's discover why llamas are so remarkable.", + "knowledge_chunks_used":5.0, + "knowledge_sources":"llamas.md", + "knowledge_sections":"Distribution and Habitat, References, Domestication and Historical Use, Llamas (*Lama glama*), Conservation Status", + "knowledge_search_query":"Llamas: Fascinating Animals of the Andes Welcome everyone! Today, we're going to explore the fascinating world of llamas, unique animals deeply intertwined with human history and culture in the Andes ...", + "avg_knowledge_score":0.7308 + }, + { + "slide_number":2, + "slide_title":"Introduction to Llamas", + "slide_text":"Introduction to Llamas\nDefinition: A domesticated South American camelid.\u000b\nScientific Name: Lama glama.\u000b\nOrigin: Andes Mountains, South America.\u000b\nRelated Species: Alpacas, Guanacos, Vicu\u00f1as (wild relatives).", + "speaker_notes":"Llamas were domesticated thousands of years ago. They descend from wild camelids native to South America and share their habitat with related species like alpacas, guanacos, and vicu\u00f1as.", + "has_notes":true, + "notes_word_count":28, + "slide_text_word_count":25, + "image_filename":"slide-002.png", + "context_slides_used":1.0, + "ai_transcript":"Llamas are domesticated South American camelids, known scientifically as Lama glama. Originating from the Andes Mountains in South America, they share their habitat with related species such as alpacas, guanacos, and vicu\u00f1as, which are their wild relatives. Domesticated thousands of years ago, llamas descend from wild camelids native to South America. Their adaptability to high-altitude environments has made them invaluable to Andean cultures for centuries. Let's continue exploring their significance and characteristics.", + "knowledge_chunks_used":5.0, + "knowledge_sources":"llamas.md", + "knowledge_sections":"Llamas (*Lama glama*), Distribution and Habitat, References, Conservation Status, Taxonomy", + "knowledge_search_query":"Introduction to Llamas Llamas were domesticated thousands of years ago. They descend from wild camelids native to South America and share their habitat with related species like alpacas, guanacos, and...", + "avg_knowledge_score":0.7962 + }, + { + "slide_number":3, + "slide_title":"Physical Characteristics", + "slide_text":"Physical Characteristics\nHeight: ~5.5 to 6 feet tall at the head.\u000b\nWeight: 280-450 pounds (127-204 kg).\u000b\nCoat: Soft, woolly fiber available in various colors.\u000b\nAdaptations: Large lungs, efficient oxygen use at high altitudes.", + "speaker_notes":"Llamas are well adapted to life in harsh mountain environments, with thick coats protecting them from the cold and specialized respiratory adaptations that allow survival at high elevations.", + "has_notes":true, + "notes_word_count":28, + "slide_text_word_count":33, + "image_filename":"slide-003.png", + "context_slides_used":2.0, + "ai_transcript":"Llamas are well adapted to life in harsh mountain environments, with thick coats protecting them from the cold and specialized respiratory adaptations that allow survival at high elevations. Let's examine their physical characteristics. Llamas typically stand between five point five to six feet tall at the head and weigh between two hundred eighty and four hundred fifty pounds, or one hundred twenty-seven to two hundred four kilograms. Their coat is made of soft, woolly fiber available in various colors. Key adaptations include large lungs and efficient oxygen use at high altitudes, making them well-suited to their native Andean habitats.", + "knowledge_chunks_used":5.0, + "knowledge_sources":"llamas.md", + "knowledge_sections":"Health and Care, Distribution and Habitat, Conservation Status, Behavior and Social Structure, Diet and Digestion", + "knowledge_search_query":"Physical Characteristics Llamas are well adapted to life in harsh mountain environments, with thick coats protecting them from the cold and specialized respiratory adaptations that allow survival at h...", + "avg_knowledge_score":0.6936 + }, + { + "slide_number":4, + "slide_title":"Diet & Habitat", + "slide_text":"Diet & Habitat\nDiet: Herbivorous; grasses, hay, grains, leaves.\u000b\nHabitat: Semi-arid regions, high-altitude grasslands (Altiplano).\u000b\nWater Needs: Require regular access to clean water.", + "speaker_notes":"Llamas have a simple but nutritious diet. Their feeding habits make them ideal animals for regions where food can be sparse, demonstrating their adaptability.", + "has_notes":true, + "notes_word_count":24, + "slide_text_word_count":23, + "image_filename":"slide-004.png", + "context_slides_used":3.0, + "ai_transcript":"Llamas have a simple but nutritious diet consisting of grasses, hay, grains, and leaves, making them herbivorous animals. Their feeding habits make them ideal for regions where food can be sparse, demonstrating their adaptability. They inhabit semi-arid regions and high-altitude grasslands, known as the Altiplano. Llamas require regular access to clean water to thrive in their native habitats.", + "knowledge_chunks_used":5.0, + "knowledge_sources":"llamas.md, llama diet.md", + "knowledge_sections":"Diet and Digestion, Health and Care, Conservation Status, Behavior and Social Structure", + "knowledge_search_query":"Diet & Habitat Llamas have a simple but nutritious diet. Their feeding habits make them ideal animals for regions where food can be sparse, demonstrating their adaptability.", + "avg_knowledge_score":0.7428 + }, + { + "slide_number":5, + "slide_title":"Behavior & Social Structure", + "slide_text":"Behavior & Social Structure\nSocial Nature: Highly social herd animals.\u000b\nCommunication: Use humming, ear positioning, body language.\u000b\nDefensive Behavior: Spitting when threatened or stressed.\u000b\nHygiene Habits: Create communal dung piles.", + "speaker_notes":"Llamas have a sophisticated social structure. They communicate effectively through subtle signals and body language. Contrary to popular belief, llamas only spit as a last resort when feeling threatened or irritated.", + "has_notes":true, + "notes_word_count":31, + "slide_text_word_count":30, + "image_filename":"slide-005.png", + "context_slides_used":4.0, + "ai_transcript":"Llamas have a sophisticated social structure. They are highly social herd animals that communicate effectively through subtle signals and body language, including humming, ear positioning, and various body language cues. Contrary to popular belief, llamas only spit as a last resort when feeling threatened or irritated. This defensive behavior is a key aspect of their social interaction. Additionally, llamas exhibit interesting hygiene habits by creating communal dung piles, demonstrating their natural inclination towards organization within their social groups.", + "knowledge_chunks_used":5.0, + "knowledge_sources":"llamas.md", + "knowledge_sections":"Behavior and Social Structure, Llamas in Popular Culture, Diet and Digestion, Llamas (*Lama glama*), Health and Care", + "knowledge_search_query":"Behavior & Social Structure Llamas have a sophisticated social structure. They communicate effectively through subtle signals and body language. Contrary to popular belief, llamas only spit as a last ...", + "avg_knowledge_score":0.615 + }, + { + "slide_number":6, + "slide_title":"Breeding & Life Cycle", + "slide_text":"Breeding & Life Cycle\nGestation: Approximately 11.5 months.\u000b\nCria: Name given to newborn llamas.\u000b\nEarly Life: Standing and nursing shortly after birth.\u000b\nLifespan: Typically 15-25 years.", + "speaker_notes":"Llamas have a relatively long gestation period, producing typically one offspring (cria) per year. Newborn llamas are quick to stand and nurse, vital for survival in challenging environments.", + "has_notes":true, + "notes_word_count":28, + "slide_text_word_count":26, + "image_filename":"slide-006.png", + "context_slides_used":5.0, + "ai_transcript":"Llamas have a relatively long gestation period of approximately eleven point five months, typically producing one offspring, known as a cria, per year. Newborn llamas are quick to stand and nurse shortly after birth, which is vital for their survival in challenging environments. The cria, as newborn llamas are called, must be able to stand and nurse soon after birth to ensure their survival. Llamas generally live between fifteen to twenty-five years.", + "knowledge_chunks_used":5.0, + "knowledge_sources":"llamas.md", + "knowledge_sections":"Reproduction and Lifespan, Health and Care, Conservation Status, Behavior and Social Structure, Distribution and Habitat", + "knowledge_search_query":"Breeding & Life Cycle Llamas have a relatively long gestation period, producing typically one offspring (cria) per year. Newborn llamas are quick to stand and nurse, vital for survival in challenging ...", + "avg_knowledge_score":0.616 + }, + { + "slide_number":7, + "slide_title":"Historical & Cultural Significance", + "slide_text":"Historical & Cultural Significance\nDomestication: Occurred 4,000-5,000 years ago.\u000b\nUses Historically: Transport, wool, food, rituals.\u000b\nCultural Role: Symbolic importance in Andean cultures.", + "speaker_notes":"Llamas have been integral to the Andean way of life for thousands of years. They were central to trade, transportation, clothing production, and had spiritual significance to indigenous communities.", + "has_notes":true, + "notes_word_count":29, + "slide_text_word_count":22, + "image_filename":"slide-007.png", + "context_slides_used":5.0, + "ai_transcript":"Llamas have been integral to the Andean way of life for thousands of years, serving multiple purposes that were central to the survival and cultural practices of indigenous communities. Their domestication occurred between four thousand and five thousand years ago, marking the beginning of their significant role in Andean cultures. Historically, llamas were used for transport, providing wool, serving as a source of food, and participating in various rituals. Beyond their practical uses, llamas held symbolic importance in Andean cultures, reflecting their deep integration into the social and spiritual fabric of these communities.", + "knowledge_chunks_used":5.0, + "knowledge_sources":"llamas.md", + "knowledge_sections":"Domestication and Historical Use, Economic and Cultural Importance, Distribution and Habitat, Llamas in Popular Culture, Llamas (*Lama glama*)", + "knowledge_search_query":"Historical & Cultural Significance Llamas have been integral to the Andean way of life for thousands of years. They were central to trade, transportation, clothing production, and had spiritual signif...", + "avg_knowledge_score":0.6966 + }, + { + "slide_number":8, + "slide_title":"Modern Uses of Llamas", + "slide_text":"Modern Uses of Llamas\nFiber Production: High-quality wool for textiles.\u000b\nPack Animals: Popular in hiking and trekking tourism.\u000b\nTherapy Animals: Gentle temperament makes them suitable.\u000b\nGuard Animals: Effective protectors of sheep and goats from predators.", + "speaker_notes":"Today, llamas have diversified roles. Their gentle nature makes them beloved as therapy animals, while their strength and wool continue to make them economically valuable in various industries.", + "has_notes":true, + "notes_word_count":28, + "slide_text_word_count":35, + "image_filename":"slide-008.png", + "context_slides_used":5.0, + "ai_transcript":"Llamas have diversified roles today, building on their historical significance and versatility. Their gentle nature makes them beloved as therapy animals, while their strength and wool continue to make them economically valuable in various industries. Modern uses of llamas include fiber production, providing high-quality wool for textiles. They are also used as pack animals, particularly popular in hiking and trekking tourism. Their gentle temperament makes them suitable as therapy animals. Additionally, llamas serve as effective guard animals, protecting sheep and goats from predators. These diverse roles demonstrate the ongoing importance of llamas in contemporary society.", + "knowledge_chunks_used":5.0, + "knowledge_sources":"llamas.md", + "knowledge_sections":"Economic and Cultural Importance, Health and Care, Llamas (*Lama glama*), Domestication and Historical Use, Behavior and Social Structure", + "knowledge_search_query":"Modern Uses of Llamas Today, llamas have diversified roles. Their gentle nature makes them beloved as therapy animals, while their strength and wool continue to make them economically valuable in vari...", + "avg_knowledge_score":0.7374 + }, + { + "slide_number":9, + "slide_title":"Conservation & Welfare", + "slide_text":"Conservation & Welfare\nConservation: Focus on wild relatives like guanacos, vicu\u00f1as.\u000b\nThreats: Habitat loss, climate change impact ecosystems.\u000b\nEthical Care: Importance of proper shearing, humane living conditions, veterinary care.", + "speaker_notes":"Although domesticated llamas are not endangered, ethical farming practices are crucial. Conservation efforts focus mainly on wild camelids threatened by human activities and environmental changes.", + "has_notes":true, + "notes_word_count":25, + "slide_text_word_count":29, + "image_filename":"slide-009.png", + "context_slides_used":5.0, + "ai_transcript":"While domesticated llamas are not endangered, ethical farming practices remain crucial. Conservation efforts primarily focus on their wild relatives, such as guanacos and vicu\u00f1as, which face significant threats from habitat loss and climate change impacting their ecosystems. Ensuring proper care for llamas involves practices like proper shearing, providing humane living conditions, and adequate veterinary care. These measures are essential for maintaining the welfare of these animals and supporting conservation initiatives for their wild counterparts.", + "knowledge_chunks_used":5.0, + "knowledge_sources":"llamas.md", + "knowledge_sections":"Conservation Status, Economic and Cultural Importance, Llamas (*Lama glama*), Health and Care, References", + "knowledge_search_query":"Conservation & Welfare Although domesticated llamas are not endangered, ethical farming practices are crucial. Conservation efforts focus mainly on wild camelids threatened by human activities and env...", + "avg_knowledge_score":0.7 + }, + { + "slide_number":10, + "slide_title":"Conclusion & Fun Facts", + "slide_text":"Conclusion & Fun Facts\nIntelligent & Curious: Highly trainable and inquisitive.\u000b\nStrength: Can carry approximately 25-30% of their body weight.\u000b\nCommunity Impact: Sustainable farming supports local economies and ecosystems.", + "speaker_notes":"To wrap up, llamas are extraordinary animals, intelligent, strong, and culturally significant. By supporting responsible llama farming, we contribute positively to local economies and ecosystems. Thank you, and I\u2019d be happy to answer any questions!", + "has_notes":true, + "notes_word_count":35, + "slide_text_word_count":29, + "image_filename":"slide-010.png", + "context_slides_used":5.0, + "ai_transcript":"Llamas are intelligent and curious animals, known for being highly trainable and inquisitive. They possess significant strength, capable of carrying approximately twenty-five to thirty percent of their body weight. The impact of llama farming on local communities is substantial, as sustainable farming practices support both local economies and ecosystems. By supporting responsible llama farming, we contribute positively to these areas. Thank you, and I'd be happy to answer any questions.", + "knowledge_chunks_used":5.0, + "knowledge_sources":"llamas.md", + "knowledge_sections":"Economic and Cultural Importance, Conservation Status, Diet and Digestion, Behavior and Social Structure, Health and Care", + "knowledge_search_query":"Conclusion & Fun Facts To wrap up, llamas are extraordinary animals, intelligent, strong, and culturally significant. By supporting responsible llama farming, we contribute positively to local economi...", + "avg_knowledge_score":0.7714 + } +] \ No newline at end of file diff --git a/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/knowledge_enhanced_narrative_transcripts_clean.csv b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/knowledge_enhanced_narrative_transcripts_clean.csv new file mode 100644 index 000000000..4709c8ddb --- /dev/null +++ b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/knowledge_enhanced_narrative_transcripts_clean.csv @@ -0,0 +1,11 @@ +slide_number,slide_title,ai_transcript,context_slides_used +1,Llamas: Fascinating Animals of the Andes,"Llamas are fascinating animals native to the Andes Mountains in South America. Today, we're going to explore their life, behavior, and role in human history and culture. Llamas have been an integral part of Andean civilizations for thousands of years, playing a central role in the development of early cultures, including the Inca Empire. They were domesticated around four thousand to five thousand years ago and were used for transportation, meat, and other purposes. Llamas are members of the camelid family and are known for their adaptability to high-altitude environments. They are still widely bred and maintained in South America and globally, and are not considered endangered. Let's discover why llamas are so remarkable.",0.0 +2,Introduction to Llamas,"Llamas are domesticated South American camelids, known scientifically as Lama glama. Originating from the Andes Mountains in South America, they share their habitat with related species such as alpacas, guanacos, and vicuรฑas, which are their wild relatives. Domesticated thousands of years ago, llamas descend from wild camelids native to South America. Their adaptability to high-altitude environments has made them invaluable to Andean cultures for centuries. Let's continue exploring their significance and characteristics.",1.0 +3,Physical Characteristics,"Llamas are well adapted to life in harsh mountain environments, with thick coats protecting them from the cold and specialized respiratory adaptations that allow survival at high elevations. Let's examine their physical characteristics. Llamas typically stand between five point five to six feet tall at the head and weigh between two hundred eighty and four hundred fifty pounds, or one hundred twenty-seven to two hundred four kilograms. Their coat is made of soft, woolly fiber available in various colors. Key adaptations include large lungs and efficient oxygen use at high altitudes, making them well-suited to their native Andean habitats.",2.0 +4,Diet & Habitat,"Llamas have a simple but nutritious diet consisting of grasses, hay, grains, and leaves, making them herbivorous animals. Their feeding habits make them ideal for regions where food can be sparse, demonstrating their adaptability. They inhabit semi-arid regions and high-altitude grasslands, known as the Altiplano. Llamas require regular access to clean water to thrive in their native habitats.",3.0 +5,Behavior & Social Structure,"Llamas have a sophisticated social structure. They are highly social herd animals that communicate effectively through subtle signals and body language, including humming, ear positioning, and various body language cues. Contrary to popular belief, llamas only spit as a last resort when feeling threatened or irritated. This defensive behavior is a key aspect of their social interaction. Additionally, llamas exhibit interesting hygiene habits by creating communal dung piles, demonstrating their natural inclination towards organization within their social groups.",4.0 +6,Breeding & Life Cycle,"Llamas have a relatively long gestation period of approximately eleven point five months, typically producing one offspring, known as a cria, per year. Newborn llamas are quick to stand and nurse shortly after birth, which is vital for their survival in challenging environments. The cria, as newborn llamas are called, must be able to stand and nurse soon after birth to ensure their survival. Llamas generally live between fifteen to twenty-five years.",5.0 +7,Historical & Cultural Significance,"Llamas have been integral to the Andean way of life for thousands of years, serving multiple purposes that were central to the survival and cultural practices of indigenous communities. Their domestication occurred between four thousand and five thousand years ago, marking the beginning of their significant role in Andean cultures. Historically, llamas were used for transport, providing wool, serving as a source of food, and participating in various rituals. Beyond their practical uses, llamas held symbolic importance in Andean cultures, reflecting their deep integration into the social and spiritual fabric of these communities.",5.0 +8,Modern Uses of Llamas,"Llamas have diversified roles today, building on their historical significance and versatility. Their gentle nature makes them beloved as therapy animals, while their strength and wool continue to make them economically valuable in various industries. Modern uses of llamas include fiber production, providing high-quality wool for textiles. They are also used as pack animals, particularly popular in hiking and trekking tourism. Their gentle temperament makes them suitable as therapy animals. Additionally, llamas serve as effective guard animals, protecting sheep and goats from predators. These diverse roles demonstrate the ongoing importance of llamas in contemporary society.",5.0 +9,Conservation & Welfare,"While domesticated llamas are not endangered, ethical farming practices remain crucial. Conservation efforts primarily focus on their wild relatives, such as guanacos and vicuรฑas, which face significant threats from habitat loss and climate change impacting their ecosystems. Ensuring proper care for llamas involves practices like proper shearing, providing humane living conditions, and adequate veterinary care. These measures are essential for maintaining the welfare of these animals and supporting conservation initiatives for their wild counterparts.",5.0 +10,Conclusion & Fun Facts,"Llamas are intelligent and curious animals, known for being highly trainable and inquisitive. They possess significant strength, capable of carrying approximately twenty-five to thirty percent of their body weight. The impact of llama farming on local communities is substantial, as sustainable farming practices support both local economies and ecosystems. By supporting responsible llama farming, we contribute positively to these areas. Thank you, and I'd be happy to answer any questions.",5.0 diff --git a/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/narrative_context/narrative_summary.json b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/narrative_context/narrative_summary.json new file mode 100644 index 000000000..30b21ae9c --- /dev/null +++ b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/narrative_context/narrative_summary.json @@ -0,0 +1,46 @@ +{ + "total_slides": 10, + "context_window_size": 5, + "slide_progression": [ + { + "slide_number": 1, + "title": "Llamas: Fascinating Animals of the Andes" + }, + { + "slide_number": 2, + "title": "Introduction to Llamas" + }, + { + "slide_number": 3, + "title": "Physical Characteristics" + }, + { + "slide_number": 4, + "title": "Diet & Habitat" + }, + { + "slide_number": 5, + "title": "Behavior & Social Structure" + }, + { + "slide_number": 6, + "title": "Breeding & Life Cycle" + }, + { + "slide_number": 7, + "title": "Historical & Cultural Significance" + }, + { + "slide_number": 8, + "title": "Modern Uses of Llamas" + }, + { + "slide_number": 9, + "title": "Conservation & Welfare" + }, + { + "slide_number": 10, + "title": "Conclusion & Fun Facts" + } + ] +} \ No newline at end of file diff --git a/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/narrative_context/slide_contexts.json b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/narrative_context/slide_contexts.json new file mode 100644 index 000000000..e6f95b60b --- /dev/null +++ b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/narrative_context/slide_contexts.json @@ -0,0 +1,52 @@ +[ + { + "slide_number": 1, + "title": "Llamas: Fascinating Animals of the Andes", + "transcript": "Llamas are fascinating animals native to the Andes Mountains in South America. Today, we're going to explore their life, behavior, and role in human history and culture. Llamas have been an integral part of Andean civilizations for thousands of years, playing a central role in the development of early cultures, including the Inca Empire. They were domesticated around four thousand to five thousand years ago and were used for transportation, meat, and other purposes. Llamas are members of the camelid family and are known for their adaptability to high-altitude environments. They are still widely bred and maintained in South America and globally, and are not considered endangered. Let's discover why llamas are so remarkable." + }, + { + "slide_number": 2, + "title": "Introduction to Llamas", + "transcript": "Llamas are domesticated South American camelids, known scientifically as Lama glama. Originating from the Andes Mountains in South America, they share their habitat with related species such as alpacas, guanacos, and vicu\u00f1as, which are their wild relatives. Domesticated thousands of years ago, llamas descend from wild camelids native to South America. Their adaptability to high-altitude environments has made them invaluable to Andean cultures for centuries. Let's continue exploring their significance and characteristics." + }, + { + "slide_number": 3, + "title": "Physical Characteristics", + "transcript": "Llamas are well adapted to life in harsh mountain environments, with thick coats protecting them from the cold and specialized respiratory adaptations that allow survival at high elevations. Let's examine their physical characteristics. Llamas typically stand between five point five to six feet tall at the head and weigh between two hundred eighty and four hundred fifty pounds, or one hundred twenty-seven to two hundred four kilograms. Their coat is made of soft, woolly fiber available in various colors. Key adaptations include large lungs and efficient oxygen use at high altitudes, making them well-suited to their native Andean habitats." + }, + { + "slide_number": 4, + "title": "Diet & Habitat", + "transcript": "Llamas have a simple but nutritious diet consisting of grasses, hay, grains, and leaves, making them herbivorous animals. Their feeding habits make them ideal for regions where food can be sparse, demonstrating their adaptability. They inhabit semi-arid regions and high-altitude grasslands, known as the Altiplano. Llamas require regular access to clean water to thrive in their native habitats." + }, + { + "slide_number": 5, + "title": "Behavior & Social Structure", + "transcript": "Llamas have a sophisticated social structure. They are highly social herd animals that communicate effectively through subtle signals and body language, including humming, ear positioning, and various body language cues. Contrary to popular belief, llamas only spit as a last resort when feeling threatened or irritated. This defensive behavior is a key aspect of their social interaction. Additionally, llamas exhibit interesting hygiene habits by creating communal dung piles, demonstrating their natural inclination towards organization within their social groups." + }, + { + "slide_number": 6, + "title": "Breeding & Life Cycle", + "transcript": "Llamas have a relatively long gestation period of approximately eleven point five months, typically producing one offspring, known as a cria, per year. Newborn llamas are quick to stand and nurse shortly after birth, which is vital for their survival in challenging environments. The cria, as newborn llamas are called, must be able to stand and nurse soon after birth to ensure their survival. Llamas generally live between fifteen to twenty-five years." + }, + { + "slide_number": 7, + "title": "Historical & Cultural Significance", + "transcript": "Llamas have been integral to the Andean way of life for thousands of years, serving multiple purposes that were central to the survival and cultural practices of indigenous communities. Their domestication occurred between four thousand and five thousand years ago, marking the beginning of their significant role in Andean cultures. Historically, llamas were used for transport, providing wool, serving as a source of food, and participating in various rituals. Beyond their practical uses, llamas held symbolic importance in Andean cultures, reflecting their deep integration into the social and spiritual fabric of these communities." + }, + { + "slide_number": 8, + "title": "Modern Uses of Llamas", + "transcript": "Llamas have diversified roles today, building on their historical significance and versatility. Their gentle nature makes them beloved as therapy animals, while their strength and wool continue to make them economically valuable in various industries. Modern uses of llamas include fiber production, providing high-quality wool for textiles. They are also used as pack animals, particularly popular in hiking and trekking tourism. Their gentle temperament makes them suitable as therapy animals. Additionally, llamas serve as effective guard animals, protecting sheep and goats from predators. These diverse roles demonstrate the ongoing importance of llamas in contemporary society." + }, + { + "slide_number": 9, + "title": "Conservation & Welfare", + "transcript": "While domesticated llamas are not endangered, ethical farming practices remain crucial. Conservation efforts primarily focus on their wild relatives, such as guanacos and vicu\u00f1as, which face significant threats from habitat loss and climate change impacting their ecosystems. Ensuring proper care for llamas involves practices like proper shearing, providing humane living conditions, and adequate veterinary care. These measures are essential for maintaining the welfare of these animals and supporting conservation initiatives for their wild counterparts." + }, + { + "slide_number": 10, + "title": "Conclusion & Fun Facts", + "transcript": "Llamas are intelligent and curious animals, known for being highly trainable and inquisitive. They possess significant strength, capable of carrying approximately twenty-five to thirty percent of their body weight. The impact of llama farming on local communities is substantial, as sustainable farming practices support both local economies and ecosystems. By supporting responsible llama farming, we contribute positively to these areas. Thank you, and I'd be happy to answer any questions." + } +] \ No newline at end of file diff --git a/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/narrative_transcripts.csv b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/narrative_transcripts.csv new file mode 100644 index 000000000..0789f4aa0 --- /dev/null +++ b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/narrative_transcripts.csv @@ -0,0 +1,44 @@ +slide_number,slide_title,slide_text,speaker_notes,has_notes,notes_word_count,slide_text_word_count,image_filename,context_slides_used,ai_transcript +1,Llamas: Fascinating Animals of the Andes,"Llamas: Fascinating Animals of the Andes +An Overview of Their Life, Behavior, and Role","Welcome everyone! Today, we're going to explore the fascinating world of llamas, unique animals deeply intertwined with human history and culture in the Andes Mountains of South America. Let's discover why they're so remarkable.",True,34,14,slide-001.png,0.0,"Llamas are unique animals deeply intertwined with human history and culture in the Andes Mountains of South America. They're fascinating creatures that have adapted to the harsh, high-altitude environments of the Andes. Today, we're going to explore their life, behavior, and the significant role they play in their native habitats. Let's discover why they're so remarkable." +2,Introduction to Llamas,"Introduction to Llamas +Definition: A domesticated South American camelid. +Scientific Name: Lama glama. +Origin: Andes Mountains, South America. +Related Species: Alpacas, Guanacos, Vicuรฑas (wild relatives).","Llamas were domesticated thousands of years ago. They descend from wild camelids native to South America and share their habitat with related species like alpacas, guanacos, and vicuรฑas.",True,28,25,slide-002.png,1.0,"A domesticated South American camelid, scientifically known as Lama glama, originates from the Andes Mountains in South America. Related species include alpacas, guanacos, and vicuรฑas, which are their wild relatives. Llamas were domesticated thousands of years ago, descending from wild camelids native to South America, and share their habitat with these related species." +3,Physical Characteristics,"Physical Characteristics +Height: ~5.5 to 6 feet tall at the head. +Weight: 280-450 pounds (127-204 kg). +Coat: Soft, woolly fiber available in various colors. +Adaptations: Large lungs, efficient oxygen use at high altitudes.","Llamas are well adapted to life in harsh mountain environments, with thick coats protecting them from the cold and specialized respiratory adaptations that allow survival at high elevations.",True,28,33,slide-003.png,2.0,"Llamas typically stand between five point five to six feet tall at the head and weigh between two hundred eighty and four hundred fifty pounds, or one hundred twenty-seven to two hundred and four kilograms. They have a soft, woolly coat that comes in various colors. Their adaptations include large lungs and efficient oxygen use, enabling them to thrive at high altitudes. These physical characteristics are crucial for their survival in harsh mountain environments, where thick coats protect them from the cold and specialized respiratory adaptations allow them to survive at high elevations." +4,Diet & Habitat,"Diet & Habitat +Diet: Herbivorous; grasses, hay, grains, leaves. +Habitat: Semi-arid regions, high-altitude grasslands (Altiplano). +Water Needs: Require regular access to clean water.","Llamas have a simple but nutritious diet. Their feeding habits make them ideal animals for regions where food can be sparse, demonstrating their adaptability.",True,24,23,slide-004.png,3.0,"Llamas are herbivores, feeding on grasses, hay, grains, and leaves. They inhabit semi-arid regions and high-altitude grasslands, known as the Altiplano. These animals require regular access to clean water. Their simple yet nutritious diet makes them particularly well-suited to regions where food resources may be limited, showcasing their remarkable adaptability to various environments." +5,Behavior & Social Structure,"Behavior & Social Structure +Social Nature: Highly social herd animals. +Communication: Use humming, ear positioning, body language. +Defensive Behavior: Spitting when threatened or stressed. +Hygiene Habits: Create communal dung piles.","Llamas have a sophisticated social structure. They communicate effectively through subtle signals and body language. Contrary to popular belief, llamas only spit as a last resort when feeling threatened or irritated.",True,31,30,slide-005.png,4.0,"Llamas are highly social herd animals with a sophisticated social structure. They communicate effectively through various methods, including humming, ear positioning, and body language. While it's commonly believed that llamas spit frequently, they actually reserve this behavior for when they feel threatened or stressed, using it as a defensive mechanism. Additionally, llamas exhibit interesting hygiene habits by creating communal dung piles. This social behavior highlights their complex nature and ability to interact with each other in meaningful ways. Understanding these aspects of llama behavior provides valuable insights into their overall social dynamics and how they thrive in their environments." +6,Breeding & Life Cycle,"Breeding & Life Cycle +Gestation: Approximately 11.5 months. +Cria: Name given to newborn llamas. +Early Life: Standing and nursing shortly after birth. +Lifespan: Typically 15-25 years.","Llamas have a relatively long gestation period, producing typically one offspring (cria) per year. Newborn llamas are quick to stand and nurse, vital for survival in challenging environments.",True,28,26,slide-006.png,5.0,"Llamas have a gestation period of approximately eleven dot five months. Newborn llamas are referred to as crias. These crias are remarkable for their ability to stand and nurse shortly after birth, a crucial adaptation for survival in challenging environments. Typically, a llama gives birth to one cria per year. The average lifespan of a llama ranges from fifteen to twenty-five years." +7,Historical & Cultural Significance,"Historical & Cultural Significance +Domestication: Occurred 4,000-5,000 years ago. +Uses Historically: Transport, wool, food, rituals. +Cultural Role: Symbolic importance in Andean cultures.","Llamas have been integral to the Andean way of life for thousands of years. They were central to trade, transportation, clothing production, and had spiritual significance to indigenous communities.",True,29,22,slide-007.png,5.0,"Llamas have been domesticated for between four thousand to five thousand years. Historically, they were used for transport, wool production, food, and played a role in various rituals. In Andean cultures, llamas held symbolic importance, being central to trade, transportation, clothing production, and possessing spiritual significance to indigenous communities. This deep-rooted cultural significance underscores their integral role in the Andean way of life for thousands of years." +8,Modern Uses of Llamas,"Modern Uses of Llamas +Fiber Production: High-quality wool for textiles. +Pack Animals: Popular in hiking and trekking tourism. +Therapy Animals: Gentle temperament makes them suitable. +Guard Animals: Effective protectors of sheep and goats from predators.","Today, llamas have diversified roles. Their gentle nature makes them beloved as therapy animals, while their strength and wool continue to make them economically valuable in various industries.",True,28,35,slide-008.png,5.0,"Llamas have diversified roles today, showcasing their versatility and value across various industries. Their high-quality wool makes them essential for fiber production, particularly in the textile industry. Additionally, llamas are popular as pack animals in hiking and trekking tourism, leveraging their strength and endurance. Their gentle temperament also makes them suitable as therapy animals, providing comfort and companionship. Furthermore, llamas serve as effective guard animals, protecting sheep and goats from predators due to their protective instincts. This multifaceted utility underscores their continued economic and social value in modern times." +9,Conservation & Welfare,"Conservation & Welfare +Conservation: Focus on wild relatives like guanacos, vicuรฑas. +Threats: Habitat loss, climate change impact ecosystems. +Ethical Care: Importance of proper shearing, humane living conditions, veterinary care.","Although domesticated llamas are not endangered, ethical farming practices are crucial. Conservation efforts focus mainly on wild camelids threatened by human activities and environmental changes.",True,25,29,slide-009.png,5.0,"Conservation efforts primarily focus on wild relatives of llamas, such as guanacos and vicuรฑas. These species face significant threats, including habitat loss and the impacts of climate change on their ecosystems. It's also essential to emphasize ethical care for domesticated llamas, which includes proper shearing techniques, providing humane living conditions, and ensuring adequate veterinary care. Although domesticated llamas are not currently endangered, maintaining ethical farming practices is crucial for their welfare. Conservation efforts are mainly directed towards protecting wild camelids, which are threatened by human activities and environmental changes." +10,Conclusion & Fun Facts,"Conclusion & Fun Facts +Intelligent & Curious: Highly trainable and inquisitive. +Strength: Can carry approximately 25-30% of their body weight. +Community Impact: Sustainable farming supports local economies and ecosystems.","To wrap up, llamas are extraordinary animals, intelligent, strong, and culturally significant. By supporting responsible llama farming, we contribute positively to local economies and ecosystems. Thank you, and Iโ€™d be happy to answer any questions!",True,35,29,slide-010.png,5.0,"Llamas are truly remarkable animals, showcasing a unique combination of intelligence, strength, and cultural significance. They are highly trainable and inquisitive, making them stand out for their intelligence and curiosity. In terms of strength, llamas can carry approximately twenty-five to thirty percent of their body weight, demonstrating their impressive physical capabilities. Moreover, sustainable llama farming plays a vital role in supporting local economies and ecosystems, highlighting their positive community impact. By embracing responsible llama farming practices, we not only contribute to the well-being of these animals but also foster economic and environmental sustainability. Thank you, and I'd be happy to address any questions you may have." diff --git a/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/narrative_transcripts.json b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/narrative_transcripts.json new file mode 100644 index 000000000..324c5a2e8 --- /dev/null +++ b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/narrative_transcripts.json @@ -0,0 +1,122 @@ +[ + { + "slide_number":1, + "slide_title":"Llamas: Fascinating Animals of the Andes", + "slide_text":"Llamas: Fascinating Animals of the Andes\nAn Overview of Their Life, Behavior, and Role", + "speaker_notes":"Welcome everyone! Today, we're going to explore the fascinating world of llamas, unique animals deeply intertwined with human history and culture in the Andes Mountains of South America. Let's discover why they're so remarkable.", + "has_notes":true, + "notes_word_count":34, + "slide_text_word_count":14, + "image_filename":"slide-001.png", + "context_slides_used":0.0, + "ai_transcript":"Llamas are unique animals deeply intertwined with human history and culture in the Andes Mountains of South America. They're fascinating creatures that have adapted to the harsh, high-altitude environments of the Andes. Today, we're going to explore their life, behavior, and the significant role they play in their native habitats. Let's discover why they're so remarkable." + }, + { + "slide_number":2, + "slide_title":"Introduction to Llamas", + "slide_text":"Introduction to Llamas\nDefinition: A domesticated South American camelid.\u000b\nScientific Name: Lama glama.\u000b\nOrigin: Andes Mountains, South America.\u000b\nRelated Species: Alpacas, Guanacos, Vicu\u00f1as (wild relatives).", + "speaker_notes":"Llamas were domesticated thousands of years ago. They descend from wild camelids native to South America and share their habitat with related species like alpacas, guanacos, and vicu\u00f1as.", + "has_notes":true, + "notes_word_count":28, + "slide_text_word_count":25, + "image_filename":"slide-002.png", + "context_slides_used":1.0, + "ai_transcript":"A domesticated South American camelid, scientifically known as Lama glama, originates from the Andes Mountains in South America. Related species include alpacas, guanacos, and vicu\u00f1as, which are their wild relatives. Llamas were domesticated thousands of years ago, descending from wild camelids native to South America, and share their habitat with these related species." + }, + { + "slide_number":3, + "slide_title":"Physical Characteristics", + "slide_text":"Physical Characteristics\nHeight: ~5.5 to 6 feet tall at the head.\u000b\nWeight: 280-450 pounds (127-204 kg).\u000b\nCoat: Soft, woolly fiber available in various colors.\u000b\nAdaptations: Large lungs, efficient oxygen use at high altitudes.", + "speaker_notes":"Llamas are well adapted to life in harsh mountain environments, with thick coats protecting them from the cold and specialized respiratory adaptations that allow survival at high elevations.", + "has_notes":true, + "notes_word_count":28, + "slide_text_word_count":33, + "image_filename":"slide-003.png", + "context_slides_used":2.0, + "ai_transcript":"Llamas typically stand between five point five to six feet tall at the head and weigh between two hundred eighty and four hundred fifty pounds, or one hundred twenty-seven to two hundred and four kilograms. They have a soft, woolly coat that comes in various colors. Their adaptations include large lungs and efficient oxygen use, enabling them to thrive at high altitudes. These physical characteristics are crucial for their survival in harsh mountain environments, where thick coats protect them from the cold and specialized respiratory adaptations allow them to survive at high elevations." + }, + { + "slide_number":4, + "slide_title":"Diet & Habitat", + "slide_text":"Diet & Habitat\nDiet: Herbivorous; grasses, hay, grains, leaves.\u000b\nHabitat: Semi-arid regions, high-altitude grasslands (Altiplano).\u000b\nWater Needs: Require regular access to clean water.", + "speaker_notes":"Llamas have a simple but nutritious diet. Their feeding habits make them ideal animals for regions where food can be sparse, demonstrating their adaptability.", + "has_notes":true, + "notes_word_count":24, + "slide_text_word_count":23, + "image_filename":"slide-004.png", + "context_slides_used":3.0, + "ai_transcript":"Llamas are herbivores, feeding on grasses, hay, grains, and leaves. They inhabit semi-arid regions and high-altitude grasslands, known as the Altiplano. These animals require regular access to clean water. Their simple yet nutritious diet makes them particularly well-suited to regions where food resources may be limited, showcasing their remarkable adaptability to various environments." + }, + { + "slide_number":5, + "slide_title":"Behavior & Social Structure", + "slide_text":"Behavior & Social Structure\nSocial Nature: Highly social herd animals.\u000b\nCommunication: Use humming, ear positioning, body language.\u000b\nDefensive Behavior: Spitting when threatened or stressed.\u000b\nHygiene Habits: Create communal dung piles.", + "speaker_notes":"Llamas have a sophisticated social structure. They communicate effectively through subtle signals and body language. Contrary to popular belief, llamas only spit as a last resort when feeling threatened or irritated.", + "has_notes":true, + "notes_word_count":31, + "slide_text_word_count":30, + "image_filename":"slide-005.png", + "context_slides_used":4.0, + "ai_transcript":"Llamas are highly social herd animals with a sophisticated social structure. They communicate effectively through various methods, including humming, ear positioning, and body language. While it's commonly believed that llamas spit frequently, they actually reserve this behavior for when they feel threatened or stressed, using it as a defensive mechanism. Additionally, llamas exhibit interesting hygiene habits by creating communal dung piles. This social behavior highlights their complex nature and ability to interact with each other in meaningful ways. Understanding these aspects of llama behavior provides valuable insights into their overall social dynamics and how they thrive in their environments." + }, + { + "slide_number":6, + "slide_title":"Breeding & Life Cycle", + "slide_text":"Breeding & Life Cycle\nGestation: Approximately 11.5 months.\u000b\nCria: Name given to newborn llamas.\u000b\nEarly Life: Standing and nursing shortly after birth.\u000b\nLifespan: Typically 15-25 years.", + "speaker_notes":"Llamas have a relatively long gestation period, producing typically one offspring (cria) per year. Newborn llamas are quick to stand and nurse, vital for survival in challenging environments.", + "has_notes":true, + "notes_word_count":28, + "slide_text_word_count":26, + "image_filename":"slide-006.png", + "context_slides_used":5.0, + "ai_transcript":"Llamas have a gestation period of approximately eleven dot five months. Newborn llamas are referred to as crias. These crias are remarkable for their ability to stand and nurse shortly after birth, a crucial adaptation for survival in challenging environments. Typically, a llama gives birth to one cria per year. The average lifespan of a llama ranges from fifteen to twenty-five years." + }, + { + "slide_number":7, + "slide_title":"Historical & Cultural Significance", + "slide_text":"Historical & Cultural Significance\nDomestication: Occurred 4,000-5,000 years ago.\u000b\nUses Historically: Transport, wool, food, rituals.\u000b\nCultural Role: Symbolic importance in Andean cultures.", + "speaker_notes":"Llamas have been integral to the Andean way of life for thousands of years. They were central to trade, transportation, clothing production, and had spiritual significance to indigenous communities.", + "has_notes":true, + "notes_word_count":29, + "slide_text_word_count":22, + "image_filename":"slide-007.png", + "context_slides_used":5.0, + "ai_transcript":"Llamas have been domesticated for between four thousand to five thousand years. Historically, they were used for transport, wool production, food, and played a role in various rituals. In Andean cultures, llamas held symbolic importance, being central to trade, transportation, clothing production, and possessing spiritual significance to indigenous communities. This deep-rooted cultural significance underscores their integral role in the Andean way of life for thousands of years." + }, + { + "slide_number":8, + "slide_title":"Modern Uses of Llamas", + "slide_text":"Modern Uses of Llamas\nFiber Production: High-quality wool for textiles.\u000b\nPack Animals: Popular in hiking and trekking tourism.\u000b\nTherapy Animals: Gentle temperament makes them suitable.\u000b\nGuard Animals: Effective protectors of sheep and goats from predators.", + "speaker_notes":"Today, llamas have diversified roles. Their gentle nature makes them beloved as therapy animals, while their strength and wool continue to make them economically valuable in various industries.", + "has_notes":true, + "notes_word_count":28, + "slide_text_word_count":35, + "image_filename":"slide-008.png", + "context_slides_used":5.0, + "ai_transcript":"Llamas have diversified roles today, showcasing their versatility and value across various industries. Their high-quality wool makes them essential for fiber production, particularly in the textile industry. Additionally, llamas are popular as pack animals in hiking and trekking tourism, leveraging their strength and endurance. Their gentle temperament also makes them suitable as therapy animals, providing comfort and companionship. Furthermore, llamas serve as effective guard animals, protecting sheep and goats from predators due to their protective instincts. This multifaceted utility underscores their continued economic and social value in modern times." + }, + { + "slide_number":9, + "slide_title":"Conservation & Welfare", + "slide_text":"Conservation & Welfare\nConservation: Focus on wild relatives like guanacos, vicu\u00f1as.\u000b\nThreats: Habitat loss, climate change impact ecosystems.\u000b\nEthical Care: Importance of proper shearing, humane living conditions, veterinary care.", + "speaker_notes":"Although domesticated llamas are not endangered, ethical farming practices are crucial. Conservation efforts focus mainly on wild camelids threatened by human activities and environmental changes.", + "has_notes":true, + "notes_word_count":25, + "slide_text_word_count":29, + "image_filename":"slide-009.png", + "context_slides_used":5.0, + "ai_transcript":"Conservation efforts primarily focus on wild relatives of llamas, such as guanacos and vicu\u00f1as. These species face significant threats, including habitat loss and the impacts of climate change on their ecosystems. It's also essential to emphasize ethical care for domesticated llamas, which includes proper shearing techniques, providing humane living conditions, and ensuring adequate veterinary care. Although domesticated llamas are not currently endangered, maintaining ethical farming practices is crucial for their welfare. Conservation efforts are mainly directed towards protecting wild camelids, which are threatened by human activities and environmental changes." + }, + { + "slide_number":10, + "slide_title":"Conclusion & Fun Facts", + "slide_text":"Conclusion & Fun Facts\nIntelligent & Curious: Highly trainable and inquisitive.\u000b\nStrength: Can carry approximately 25-30% of their body weight.\u000b\nCommunity Impact: Sustainable farming supports local economies and ecosystems.", + "speaker_notes":"To wrap up, llamas are extraordinary animals, intelligent, strong, and culturally significant. By supporting responsible llama farming, we contribute positively to local economies and ecosystems. Thank you, and I\u2019d be happy to answer any questions!", + "has_notes":true, + "notes_word_count":35, + "slide_text_word_count":29, + "image_filename":"slide-010.png", + "context_slides_used":5.0, + "ai_transcript":"Llamas are truly remarkable animals, showcasing a unique combination of intelligence, strength, and cultural significance. They are highly trainable and inquisitive, making them stand out for their intelligence and curiosity. In terms of strength, llamas can carry approximately twenty-five to thirty percent of their body weight, demonstrating their impressive physical capabilities. Moreover, sustainable llama farming plays a vital role in supporting local economies and ecosystems, highlighting their positive community impact. By embracing responsible llama farming practices, we not only contribute to the well-being of these animals but also foster economic and environmental sustainability. Thank you, and I'd be happy to address any questions you may have." + } +] \ No newline at end of file diff --git a/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/narrative_transcripts_clean.csv b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/narrative_transcripts_clean.csv new file mode 100644 index 000000000..ae2b88d80 --- /dev/null +++ b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/narrative_transcripts_clean.csv @@ -0,0 +1,11 @@ +slide_number,slide_title,ai_transcript,context_slides_used +1,Llamas: Fascinating Animals of the Andes,"Llamas are unique animals deeply intertwined with human history and culture in the Andes Mountains of South America. They're fascinating creatures that have adapted to the harsh, high-altitude environments of the Andes. Today, we're going to explore their life, behavior, and the significant role they play in their native habitats. Let's discover why they're so remarkable.",0.0 +2,Introduction to Llamas,"A domesticated South American camelid, scientifically known as Lama glama, originates from the Andes Mountains in South America. Related species include alpacas, guanacos, and vicuรฑas, which are their wild relatives. Llamas were domesticated thousands of years ago, descending from wild camelids native to South America, and share their habitat with these related species.",1.0 +3,Physical Characteristics,"Llamas typically stand between five point five to six feet tall at the head and weigh between two hundred eighty and four hundred fifty pounds, or one hundred twenty-seven to two hundred and four kilograms. They have a soft, woolly coat that comes in various colors. Their adaptations include large lungs and efficient oxygen use, enabling them to thrive at high altitudes. These physical characteristics are crucial for their survival in harsh mountain environments, where thick coats protect them from the cold and specialized respiratory adaptations allow them to survive at high elevations.",2.0 +4,Diet & Habitat,"Llamas are herbivores, feeding on grasses, hay, grains, and leaves. They inhabit semi-arid regions and high-altitude grasslands, known as the Altiplano. These animals require regular access to clean water. Their simple yet nutritious diet makes them particularly well-suited to regions where food resources may be limited, showcasing their remarkable adaptability to various environments.",3.0 +5,Behavior & Social Structure,"Llamas are highly social herd animals with a sophisticated social structure. They communicate effectively through various methods, including humming, ear positioning, and body language. While it's commonly believed that llamas spit frequently, they actually reserve this behavior for when they feel threatened or stressed, using it as a defensive mechanism. Additionally, llamas exhibit interesting hygiene habits by creating communal dung piles. This social behavior highlights their complex nature and ability to interact with each other in meaningful ways. Understanding these aspects of llama behavior provides valuable insights into their overall social dynamics and how they thrive in their environments.",4.0 +6,Breeding & Life Cycle,"Llamas have a gestation period of approximately eleven dot five months. Newborn llamas are referred to as crias. These crias are remarkable for their ability to stand and nurse shortly after birth, a crucial adaptation for survival in challenging environments. Typically, a llama gives birth to one cria per year. The average lifespan of a llama ranges from fifteen to twenty-five years.",5.0 +7,Historical & Cultural Significance,"Llamas have been domesticated for between four thousand to five thousand years. Historically, they were used for transport, wool production, food, and played a role in various rituals. In Andean cultures, llamas held symbolic importance, being central to trade, transportation, clothing production, and possessing spiritual significance to indigenous communities. This deep-rooted cultural significance underscores their integral role in the Andean way of life for thousands of years.",5.0 +8,Modern Uses of Llamas,"Llamas have diversified roles today, showcasing their versatility and value across various industries. Their high-quality wool makes them essential for fiber production, particularly in the textile industry. Additionally, llamas are popular as pack animals in hiking and trekking tourism, leveraging their strength and endurance. Their gentle temperament also makes them suitable as therapy animals, providing comfort and companionship. Furthermore, llamas serve as effective guard animals, protecting sheep and goats from predators due to their protective instincts. This multifaceted utility underscores their continued economic and social value in modern times.",5.0 +9,Conservation & Welfare,"Conservation efforts primarily focus on wild relatives of llamas, such as guanacos and vicuรฑas. These species face significant threats, including habitat loss and the impacts of climate change on their ecosystems. It's also essential to emphasize ethical care for domesticated llamas, which includes proper shearing techniques, providing humane living conditions, and ensuring adequate veterinary care. Although domesticated llamas are not currently endangered, maintaining ethical farming practices is crucial for their welfare. Conservation efforts are mainly directed towards protecting wild camelids, which are threatened by human activities and environmental changes.",5.0 +10,Conclusion & Fun Facts,"Llamas are truly remarkable animals, showcasing a unique combination of intelligence, strength, and cultural significance. They are highly trainable and inquisitive, making them stand out for their intelligence and curiosity. In terms of strength, llamas can carry approximately twenty-five to thirty percent of their body weight, demonstrating their impressive physical capabilities. Moreover, sustainable llama farming plays a vital role in supporting local economies and ecosystems, highlighting their positive community impact. By embracing responsible llama farming practices, we not only contribute to the well-being of these animals but also foster economic and environmental sustainability. Thank you, and I'd be happy to address any questions you may have.",5.0 diff --git a/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/slide-001.png b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/slide-001.png new file mode 100644 index 000000000..5ae833383 Binary files /dev/null and b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/slide-001.png differ diff --git a/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/slide-002.png b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/slide-002.png new file mode 100644 index 000000000..fbbc2f96a Binary files /dev/null and b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/slide-002.png differ diff --git a/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/slide-003.png b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/slide-003.png new file mode 100644 index 000000000..57ca0ce47 Binary files /dev/null and b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/slide-003.png differ diff --git a/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/slide-004.png b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/slide-004.png new file mode 100644 index 000000000..9914e9c03 Binary files /dev/null and b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/slide-004.png differ diff --git a/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/slide-005.png b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/slide-005.png new file mode 100644 index 000000000..00b924257 Binary files /dev/null and b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/slide-005.png differ diff --git a/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/slide-006.png b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/slide-006.png new file mode 100644 index 000000000..ea21a7188 Binary files /dev/null and b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/slide-006.png differ diff --git a/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/slide-007.png b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/slide-007.png new file mode 100644 index 000000000..b3fd60103 Binary files /dev/null and b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/slide-007.png differ diff --git a/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/slide-008.png b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/slide-008.png new file mode 100644 index 000000000..f22085dcc Binary files /dev/null and b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/slide-008.png differ diff --git a/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/slide-009.png b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/slide-009.png new file mode 100644 index 000000000..29e2225ba Binary files /dev/null and b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/slide-009.png differ diff --git a/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/slide-010.png b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/slide-010.png new file mode 100644 index 000000000..a994cd287 Binary files /dev/null and b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/output/slide-010.png differ diff --git a/end-to-end-use-cases/powerpoint-to-voiceover-transcript/pyproject.toml b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/pyproject.toml new file mode 100644 index 000000000..4f05c3862 --- /dev/null +++ b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/pyproject.toml @@ -0,0 +1,32 @@ +[project] +name = "pptx-to-transcript" +version = "0.1.0" +description = "Convert PowerPoint presentations to transcripts with AI-powered analysis" +requires-python = ">=3.12" +dependencies = [ + "pandas>=2.3.1", + "pillow>=11.3.0", + "python-pptx>=1.0.2", + "pymupdf>=1.24.0", + "numpy>=2.3.2", + "python-dotenv>=1.0.0", + "tqdm>=4.66.0", + "pyyaml>=6.0.0", + "matplotlib>=3.10.5", + # Knowledge base integration dependencies + "sentence-transformers>=2.2.0,<3.0.0", + "jupyter>=1.1.1", + "ipykernel>=6.30.1", + "seaborn>=0.13.2", + "faiss-cpu>=1.11.0.post1", + "openpyxl>=3.1.5", + "groq>=0.31.0", +] + +[project.optional-dependencies] +dev = [ + "pytest>=7.0.0", + "memory-profiler>=0.60.0", + "pytest-benchmark>=4.0.0", + "pytest-mock>=3.10.0", +] diff --git a/end-to-end-use-cases/powerpoint-to-voiceover-transcript/src/__init__.py b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/src/__init__.py new file mode 100644 index 000000000..8f7a6f9eb --- /dev/null +++ b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/src/__init__.py @@ -0,0 +1,28 @@ +""" +PPTX to Transcript - A tool for converting PowerPoint presentations to AI-generated transcripts. + +This package provides functionality to: +- Extract speaker notes and slide content from PPTX files +- Convert slides to images +- Generate AI-powered transcripts using Llama models +""" + +__version__ = "0.1.0" +__author__ = "Yuce Dincer" + +from .core.pptx_processor import extract_pptx_notes, pptx_to_images_and_notes +from .processors.unified_transcript_generator import ( + UnifiedTranscriptProcessor, + process_slides, + process_slides_with_narrative +) +from .config.settings import load_config + +__all__ = [ + "extract_pptx_notes", + "pptx_to_images_and_notes", + "UnifiedTranscriptProcessor", + "process_slides", + "process_slides_with_narrative", + "load_config" +] diff --git a/end-to-end-use-cases/powerpoint-to-voiceover-transcript/src/config/__init__.py b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/src/config/__init__.py new file mode 100644 index 000000000..6bfed0c30 --- /dev/null +++ b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/src/config/__init__.py @@ -0,0 +1,5 @@ +"""Configuration management for PPTX to Transcript.""" + +from .settings import load_config, get_config + +__all__ = ["load_config", "get_config"] diff --git a/end-to-end-use-cases/powerpoint-to-voiceover-transcript/src/config/settings.py b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/src/config/settings.py new file mode 100644 index 000000000..f90b654b5 --- /dev/null +++ b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/src/config/settings.py @@ -0,0 +1,239 @@ +"""Configuration management using YAML files.""" + +import os +import yaml +from pathlib import Path +from typing import Dict, Any, Optional + +# Global config cache +_config_cache: Optional[Dict[str, Any]] = None + + +def load_config(config_path: Optional[str] = None) -> Dict[str, Any]: + """ + Load configuration from YAML file. + + Args: + config_path: Path to config file. If None, looks for config.yaml in project root. + + Returns: + Dictionary containing configuration settings + + Raises: + FileNotFoundError: If config file doesn't exist + yaml.YAMLError: If config file is invalid YAML + """ + global _config_cache + + if config_path is None: + # Look for config.yaml in project root (parent of src directory) + current_dir = Path(__file__).parent.parent.parent + config_file_path = current_dir / "config.yaml" + else: + config_file_path = Path(config_path) + + if not config_file_path.exists(): + raise FileNotFoundError(f"Configuration file not found: {config_file_path}") + + try: + with open(str(config_file_path), 'r', encoding='utf-8') as f: + config = yaml.safe_load(f) + + # Cache the config + _config_cache = config + + # Load environment variables for API keys + _load_env_variables(config) + + return config + + except yaml.YAMLError as e: + raise yaml.YAMLError(f"Invalid YAML in config file {config_file_path}: {e}") + + +def get_config() -> Dict[str, Any]: + """ + Get cached configuration. Loads from default location if not already loaded. + + Returns: + Dictionary containing configuration settings + """ + global _config_cache + + if _config_cache is None: + _config_cache = load_config() + + return _config_cache + + +def _load_env_variables(config: Dict[str, Any]) -> None: + """ + Load environment variables and add them to config. + + Args: + config: Configuration dictionary to update + """ + # Load API key from environment + llama_api_key = os.getenv('LLAMA_API_KEY') + if llama_api_key: + if 'api' not in config: + config['api'] = {} + config['api']['llama_api_key'] = llama_api_key + + +def get_system_prompt() -> str: + """ + Get the system prompt from configuration. + + Returns: + System prompt string + """ + config = get_config() + return config.get('system_prompt', '') + + +def get_api_config() -> Dict[str, Any]: + """ + Get API configuration settings. + + Returns: + Dictionary containing API settings + """ + config = get_config() + return config.get('api', {}) + + +def get_processing_config() -> Dict[str, Any]: + """ + Get processing configuration settings. + + Returns: + Dictionary containing processing settings + """ + config = get_config() + return config.get('processing', {}) + + +def get_paths_config() -> Dict[str, Any]: + """ + Get file paths configuration. + + Returns: + Dictionary containing path settings + """ + config = get_config() + return config.get('paths', {}) + + +def get_libreoffice_paths() -> list: + """ + Get possible LibreOffice installation paths. + + Returns: + List of possible LibreOffice paths + """ + config = get_config() + return config.get('libreoffice', {}).get('possible_paths', []) + + +def get_image_quality_config() -> Dict[str, Any]: + """ + Get image quality configuration settings. + + Returns: + Dictionary containing image quality settings + """ + config = get_config() + return config.get('image_quality', {}) + + +def get_knowledge_config() -> Dict[str, Any]: + """ + Get knowledge base configuration settings. + + Returns: + Dictionary containing knowledge base settings + """ + config = get_config() + return config.get('knowledge', {}) + + +def is_knowledge_enabled() -> bool: + """ + Check if knowledge base integration is enabled. + + Returns: + True if knowledge base is enabled, False otherwise + """ + knowledge_config = get_knowledge_config() + return knowledge_config.get('enabled', False) + + +def validate_knowledge_config() -> None: + """ + Validate knowledge base configuration parameters. + + Raises: + ValueError: If configuration is invalid + """ + from ..knowledge.exceptions import KnowledgeConfigurationError + + if not is_knowledge_enabled(): + return + + knowledge_config = get_knowledge_config() + + # Validate required fields + required_fields = ['knowledge_base_dir', 'embedding', 'search', 'context'] + for field in required_fields: + if field not in knowledge_config: + raise KnowledgeConfigurationError( + f"Missing required knowledge configuration field: {field}", + config_key=field + ) + + # Validate embedding config + embedding_config = knowledge_config.get('embedding', {}) + if 'model_name' not in embedding_config: + raise KnowledgeConfigurationError( + "Missing embedding model_name in knowledge configuration", + config_key='embedding.model_name' + ) + + # Validate search config + search_config = knowledge_config.get('search', {}) + top_k = search_config.get('top_k', 5) + if not isinstance(top_k, int) or top_k <= 0: + raise KnowledgeConfigurationError( + f"Invalid top_k value: {top_k}. Must be a positive integer.", + config_key='search.top_k', + config_value=top_k + ) + + similarity_threshold = search_config.get('similarity_threshold', 0.3) + if not isinstance(similarity_threshold, (int, float)) or not 0.0 <= similarity_threshold <= 1.0: + raise KnowledgeConfigurationError( + f"Invalid similarity_threshold: {similarity_threshold}. Must be between 0.0 and 1.0.", + config_key='search.similarity_threshold', + config_value=similarity_threshold + ) + + # Validate context config + context_config = knowledge_config.get('context', {}) + strategy = context_config.get('strategy', 'combined') + valid_strategies = ['knowledge_only', 'narrative_priority', 'combined'] + if strategy not in valid_strategies: + raise KnowledgeConfigurationError( + f"Invalid context strategy: {strategy}. Must be one of {valid_strategies}.", + config_key='context.strategy', + config_value=strategy + ) + + integration_method = context_config.get('integration_method', 'system_prompt') + valid_methods = ['system_prompt', 'user_message'] + if integration_method not in valid_methods: + raise KnowledgeConfigurationError( + f"Invalid integration method: {integration_method}. Must be one of {valid_methods}.", + config_key='context.integration_method', + config_value=integration_method + ) diff --git a/end-to-end-use-cases/powerpoint-to-voiceover-transcript/src/core/__init__.py b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/src/core/__init__.py new file mode 100644 index 000000000..5bb3146dd --- /dev/null +++ b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/src/core/__init__.py @@ -0,0 +1,14 @@ +"""Core functionality for PPTX to Transcript processing.""" + +from .image_processing import encode_image +from .pptx_processor import extract_pptx_notes, pptx_to_images_and_notes +from .groq_client import GroqClient +from .file_utils import check_libreoffice + +__all__ = [ + "encode_image", + "extract_pptx_notes", + "pptx_to_images_and_notes", + "GroqClient", + "check_libreoffice" +] diff --git a/end-to-end-use-cases/powerpoint-to-voiceover-transcript/src/core/file_utils.py b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/src/core/file_utils.py new file mode 100644 index 000000000..c387ebb25 --- /dev/null +++ b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/src/core/file_utils.py @@ -0,0 +1,53 @@ +"""File system utilities for PPTX to Transcript.""" + +import shutil +from pathlib import Path +from ..config.settings import get_libreoffice_paths + + +def check_libreoffice() -> str: + """ + Find LibreOffice soffice binary. + + Returns: + Path to the soffice binary as a string + + Raises: + FileNotFoundError: If LibreOffice is not found + """ + # Get possible paths from config + possible_paths = get_libreoffice_paths() + + # Add shutil.which result to the list + which_result = shutil.which("soffice") + if which_result: + possible_paths.insert(1, which_result) # Insert after the first path + + for path in possible_paths: + if path and Path(path).exists(): + return str(path) + + raise FileNotFoundError( + "LibreOffice not found! Please install LibreOffice or update the paths in config.yaml" + ) + + +def ensure_directory_exists(directory_path: Path) -> None: + """ + Ensure a directory exists, creating it if necessary. + + Args: + directory_path: Path to the directory + """ + directory_path.mkdir(parents=True, exist_ok=True) + + +def get_project_root() -> Path: + """ + Get the project root directory. + + Returns: + Path to the project root directory + """ + # Go up from src/core to project root + return Path(__file__).parent.parent.parent diff --git a/end-to-end-use-cases/powerpoint-to-voiceover-transcript/src/core/groq_client.py b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/src/core/groq_client.py new file mode 100644 index 000000000..66555e655 --- /dev/null +++ b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/src/core/groq_client.py @@ -0,0 +1,282 @@ +"""Groq API client wrapper for PPTX to Transcript.""" + +from typing import Optional, Any, Union +import os +from .image_processing import encode_image +from ..config.settings import get_api_config, get_system_prompt, is_knowledge_enabled, get_knowledge_config + +try: + from groq import Groq + GROQ_AVAILABLE = True +except ImportError: + GROQ_AVAILABLE = False + + +class GroqClient: + """Wrapper for Groq API client with configuration management.""" + + def __init__(self, api_key: Optional[str] = None, model: Optional[str] = None): + """ + Initialize Groq client. + + Args: + api_key: API key for Groq. If None, will be loaded from environment. + model: Model to use. If None, uses default vision model. + """ + if not GROQ_AVAILABLE: + raise ImportError("groq package is required. Install with: pip install groq") + + if api_key is None: + api_key = os.getenv('GROQ_API_KEY') + + if not api_key: + raise ValueError("Groq API key not found. Set GROQ_API_KEY environment variable or provide api_key parameter.") + + self.client = Groq(api_key=api_key) + + # Groq vision models (update as new models become available) + self.model = model or "meta-llama/llama-4-maverick-17b-128e-instruct" + + # Groq API configuration + self.max_tokens = 4096 + self.temperature = 0.1 + + def generate_transcript( + self, + image_path: str, + speaker_notes: str = "", + system_prompt: Optional[str] = None, + context_bundle: Optional[Any] = None, + stream: bool = False + ) -> Union[str, Any]: + """ + Generate transcript from slide image and speaker notes with optional context. + + Args: + image_path: Path to the slide image + speaker_notes: Speaker notes for the slide + system_prompt: Custom system prompt. If None, uses default from config. + context_bundle: ContextBundle for knowledge integration + stream: Whether to stream the response + + Returns: + Generated transcript text if not streaming, otherwise the response object + """ + if system_prompt is None: + system_prompt = get_system_prompt() + + # Enhance with context if available + if context_bundle is not None and is_knowledge_enabled(): + system_prompt, user_message_prefix = self._integrate_context( + system_prompt, context_bundle + ) + else: + user_message_prefix = "" + + encoded_image = encode_image(image_path) + + # Build user message with optional context prefix + user_text = f"{user_message_prefix}Speaker Notes: {speaker_notes}".strip() + + try: + response = self.client.chat.completions.create( + model=self.model, + messages=[ + {"role": "system", "content": system_prompt}, + { + "role": "user", + "content": [ + { + "type": "text", + "text": user_text, + }, + { + "type": "image_url", + "image_url": { + "url": f"data:image/png;base64,{encoded_image}", + }, + }, + ], + }, + ], + max_tokens=self.max_tokens, + temperature=self.temperature, + stream=stream, + ) + + if stream: + return response + else: + return response.choices[0].message.content + + except Exception as e: + raise Exception(f"Groq API error: {str(e)}") + + def _integrate_context(self, system_prompt: str, context_bundle: Any) -> tuple[str, str]: + """ + Integrate context bundle into system prompt or user message. + + Args: + system_prompt: Original system prompt + context_bundle: ContextBundle with context information + + Returns: + Tuple of (enhanced_system_prompt, user_message_prefix) + """ + try: + # Import here to avoid circular imports + from ..knowledge.context_manager import ContextManager + + context_manager = ContextManager() + knowledge_config = get_knowledge_config() + integration_method = knowledge_config.get('context', {}).get('integration_method', 'system_prompt') + + # Get formatted context + context_data = context_manager.get_context_for_integration( + context_bundle, integration_method + ) + + if not context_data: + return system_prompt, "" + + if integration_method == "system_prompt": + return self._enhance_system_prompt(system_prompt, context_data), "" + elif integration_method == "user_message": + return system_prompt, self._enhance_user_message(context_data) + else: + return system_prompt, "" + + except Exception as e: + # Graceful degradation - log error but continue without context + import logging + logger = logging.getLogger(__name__) + logger.warning(f"Failed to integrate context: {e}") + return system_prompt, "" + + def _enhance_system_prompt(self, system_prompt: str, context_data: dict) -> str: + """ + Enhance system prompt with context information. + + Args: + system_prompt: Original system prompt + context_data: Context data from ContextManager + + Returns: + Enhanced system prompt + """ + context_addition = context_data.get('context_addition', '') + integration_point = context_data.get('integration_point', 'before_instructions') + + if not context_addition: + return system_prompt + + if integration_point == 'before_instructions': + # Add context before the main instructions + enhanced_prompt = f"{context_addition}\n\n{system_prompt}" + else: + # Default: append at the end + enhanced_prompt = f"{system_prompt}\n\n{context_addition}" + + return enhanced_prompt + + def _enhance_user_message(self, context_data: dict) -> str: + """ + Create user message prefix with context information. + + Args: + context_data: Context data from ContextManager + + Returns: + User message prefix + """ + context_addition = context_data.get('context_addition', '') + + if context_addition: + return f"{context_addition}\n\n" + + return "" + + def run( + self, + image_path: str, + system_prompt: str, + user_prompt: str, + stream: bool = False + ) -> Union[str, Any]: + """ + Legacy method for backward compatibility with notebook code. + + Args: + image_path: Path to the image file + system_prompt: System prompt for the chat completion + user_prompt: User prompt (speaker notes) + stream: Whether to stream the response + + Returns: + Response from the chat completion + """ + encoded_image = encode_image(image_path) + + try: + response = self.client.chat.completions.create( + model=self.model, + messages=[ + {"role": "system", "content": system_prompt}, + { + "role": "user", + "content": [ + { + "type": "text", + "text": f"Speaker Notes: {user_prompt}", + }, + { + "type": "image_url", + "image_url": { + "url": f"data:image/png;base64,{encoded_image}", + }, + }, + ], + }, + ], + max_tokens=self.max_tokens, + temperature=self.temperature, + stream=stream, + ) + + if stream: + for chunk in response: + if chunk.choices[0].delta.content: + print(chunk.choices[0].delta.content, end="", flush=True) + else: + return response + + except Exception as e: + raise Exception(f"Groq API error: {str(e)}") + + def list_models(self) -> list: + """ + List available models from Groq. + + Returns: + List of available models + """ + try: + models = self.client.models.list() + return [model.id for model in models.data] + except Exception as e: + print(f"Error listing models: {e}") + return [] + + def get_model_info(self) -> dict: + """ + Get information about the current model. + + Returns: + Dictionary with model information + """ + return { + 'model': self.model, + 'max_tokens': self.max_tokens, + 'temperature': self.temperature, + 'provider': 'Groq' + } diff --git a/end-to-end-use-cases/powerpoint-to-voiceover-transcript/src/core/image_processing.py b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/src/core/image_processing.py new file mode 100644 index 000000000..74d0a5cef --- /dev/null +++ b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/src/core/image_processing.py @@ -0,0 +1,31 @@ +"""Image processing utilities for PPTX to Transcript.""" + +import base64 +from typing import Union +from pathlib import Path + + +def encode_image(image_path: Union[str, Path]) -> str: + """ + Encode an image file as a base64 string. + + Args: + image_path: Path to the image file + + Returns: + Base64-encoded image data as a string + + Raises: + FileNotFoundError: If the image file doesn't exist + IOError: If there's an error reading the image file + """ + image_path = Path(image_path) + + if not image_path.exists(): + raise FileNotFoundError(f"Image file not found: {image_path}") + + try: + with open(image_path, "rb") as image_file: + return base64.b64encode(image_file.read()).decode("utf-8") + except IOError as e: + raise IOError(f"Error reading image file {image_path}: {e}") diff --git a/end-to-end-use-cases/powerpoint-to-voiceover-transcript/src/core/pptx_processor.py b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/src/core/pptx_processor.py new file mode 100644 index 000000000..33e8532bc --- /dev/null +++ b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/src/core/pptx_processor.py @@ -0,0 +1,208 @@ +"""PPTX processing functionality for extracting notes and converting to images.""" + +import pandas as pd +import subprocess +import io +import fitz # PyMuPDF +from PIL import Image +from pptx import Presentation +from typing import Dict, Any, Union +from pathlib import Path + +from .file_utils import check_libreoffice, ensure_directory_exists +from ..config.settings import get_processing_config, get_image_quality_config + + +def extract_pptx_notes(pptx_path: Union[str, Path]) -> pd.DataFrame: + """ + Extract speaker notes from PPTX file. + + Args: + pptx_path: Path to PPTX file + + Returns: + DataFrame with columns: + - slide_number: Slide number (1-indexed) + - slide_title: Title of the slide (first line of text, max 100 chars) + - slide_text: Text content of the slide + - speaker_notes: Speaker notes for the slide + - has_notes: Whether the slide has speaker notes + - notes_word_count: Number of words in the speaker notes + - slide_text_word_count: Number of words in the slide text + - image_filename: Suggested filename for the slide image (e.g. "slide-001.png") + """ + pptx_path = Path(pptx_path) + processing_config = get_processing_config() + default_format = processing_config.get('default_format', 'png') + + prs = Presentation(pptx_path) + slides_data = [] + + for slide_num, slide in enumerate(prs.slides, 1): + # Extract slide text (from shapes on the slide) + slide_text = [] + slide_title = "" + + for shape in slide.shapes: + if hasattr(shape, "text") and shape.text.strip(): + text = shape.text.strip() + slide_text.append(text) + + # Try to identify title (usually the first text or largest text) + if not slide_title and text: + slide_title = text.split('\n')[0][:100] # First line, max 100 chars + + # Extract speaker notes + notes_text = "" + if slide.has_notes_slide: + notes_slide = slide.notes_slide + if notes_slide.notes_text_frame: + notes_text = notes_slide.notes_text_frame.text.strip() + + slides_data.append({ + 'slide_number': slide_num, + 'slide_title': slide_title, + 'slide_text': '\n'.join(slide_text), + 'speaker_notes': notes_text, + 'has_notes': bool(notes_text), + 'notes_word_count': len(notes_text.split()) if notes_text else 0, + 'slide_text_word_count': len('\n'.join(slide_text).split()) if slide_text else 0, + 'image_filename': f"slide-{slide_num:03d}.{default_format}" + }) + + return pd.DataFrame(slides_data) + + +def pptx_to_images_and_notes( + pptx_path: Union[str, Path], + output_dir: Union[str, Path], + dpi: Union[int, None] = None, + fmt: Union[str, None] = None, + extract_notes: bool = True +) -> Dict[str, Any]: + """ + Convert PPTX to images and extract notes. + + Args: + pptx_path: Path to PPTX file + output_dir: Directory to save images and notes + dpi: Image resolution (uses config default if None) + fmt: Image format - "png" or "jpeg" (uses config default if None) + extract_notes: Whether to extract speaker notes + + Returns: + Dict with image_files, notes_df, and output_dir + + Raises: + FileNotFoundError: If PPTX file or LibreOffice not found + RuntimeError: If conversion fails + """ + pptx_path = Path(pptx_path).resolve() + output_dir = Path(output_dir).resolve() + + # Load configuration + processing_config = get_processing_config() + image_quality_config = get_image_quality_config() + + if dpi is None: + dpi = processing_config.get('default_dpi', 200) + if fmt is None: + fmt = processing_config.get('default_format', 'png') + + # Validate format + supported_formats = processing_config.get('supported_formats', ['png', 'jpeg', 'jpg']) + if fmt not in supported_formats: + raise ValueError(f"Unsupported format '{fmt}'. Supported formats: {supported_formats}") + + ensure_directory_exists(output_dir) + + print(f"Processing: {pptx_path.name}") + + # Step 1: Extract notes if requested + notes_df = pd.DataFrame() + if extract_notes: + print("Extracting speaker notes...") + try: + notes_df = extract_pptx_notes(pptx_path) + # Update image filenames based on actual format + notes_df['image_filename'] = notes_df['slide_number'].apply( + lambda x: f"slide-{x:03d}.{fmt}" + ) + + notes_with_content = notes_df[notes_df['has_notes']] + print(f"Found notes on {len(notes_with_content)} of {len(notes_df)} slides") + + # Save df to CSV + csv_file = output_dir / f"{pptx_path.stem}_notes.csv" + notes_df.to_csv(csv_file, index=False, encoding='utf-8') + print(f"Notes df saved to: {csv_file}") + + except Exception as e: + print(f"Warning: Could not extract notes: {e}") + notes_df = pd.DataFrame() + + # Step 2: Convert to images + soffice = check_libreoffice() + + # Clean previous outputs + for f in output_dir.glob("slide*"): + if f.is_file(): + f.unlink() + + # Convert PPTX โ†’ PDF + pdf_path = output_dir / f"{pptx_path.stem}.pdf" + + print("Converting to PDF...") + try: + subprocess.run([ + soffice, + "--headless", + "--convert-to", "pdf", + "--outdir", str(output_dir), + str(pptx_path) + ], check=True, capture_output=True, text=True) + except subprocess.CalledProcessError as e: + raise RuntimeError(f"Failed to convert PPTX to PDF: {e}") + + if not pdf_path.exists(): + raise FileNotFoundError(f"PDF was not created: {pdf_path}") + + # Convert PDF โ†’ Images + print(f"Converting to {fmt.upper()} images at {dpi} DPI...") + doc = fitz.open(str(pdf_path)) + + for page_num in range(len(doc)): + page = doc.load_page(page_num) + zoom = dpi / 72 + mat = fitz.Matrix(zoom, zoom) + pix = page.get_pixmap(matrix=mat) + + image_path = output_dir / f"slide-{page_num+1:03d}.{fmt}" + + if fmt.lower() == "png": + pix.save(str(image_path)) + elif fmt.lower() in ["jpg", "jpeg"]: + img_data = pix.tobytes("png") + pil_img = Image.open(io.BytesIO(img_data)) + pil_img = pil_img.convert("RGB") + + # Get quality settings from config + quality = image_quality_config.get('jpeg_quality', 90) + optimize = image_quality_config.get('jpeg_optimize', True) + + pil_img.save(str(image_path), "JPEG", quality=quality, optimize=optimize) + + pix = None + + doc.close() + + # Summary + image_files = sorted(list(output_dir.glob(f"slide*.{fmt}"))) + print(f"\nSuccessfully processed {len(image_files)} slides") + print(f"Images saved to: {output_dir}") + + return { + 'image_files': image_files, + 'notes_df': notes_df, + 'output_dir': output_dir + } diff --git a/end-to-end-use-cases/powerpoint-to-voiceover-transcript/src/knowledge/__init__.py b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/src/knowledge/__init__.py new file mode 100644 index 000000000..26a185b79 --- /dev/null +++ b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/src/knowledge/__init__.py @@ -0,0 +1,29 @@ +""" +Knowledge base package for PowerPoint to Voiceover Transcript Generator. + +This package provides knowledge base integration capabilities using FAISS +for efficient vector search and retrieval of domain-specific information. +""" + +# Import main classes for easy access +try: + from .faiss_knowledge import FAISSKnowledgeManager, KnowledgeChunk + from .context_manager import ContextManager, ContextBundle + + # Backward compatibility + MarkdownKnowledgeManager = FAISSKnowledgeManager + + __all__ = [ + 'FAISSKnowledgeManager', + 'MarkdownKnowledgeManager', # Backward compatibility alias + 'KnowledgeChunk', + 'ContextManager', + 'ContextBundle' + ] + +except ImportError as e: + # Graceful degradation if dependencies are missing + import warnings + warnings.warn(f"Knowledge base components not fully available: {e}") + + __all__ = [] diff --git a/end-to-end-use-cases/powerpoint-to-voiceover-transcript/src/knowledge/context_manager.py b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/src/knowledge/context_manager.py new file mode 100644 index 000000000..935c316a0 --- /dev/null +++ b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/src/knowledge/context_manager.py @@ -0,0 +1,87 @@ +from typing import List, Dict, Any, Optional +from dataclasses import dataclass + +@dataclass +class ContextBundle: + knowledge_context: str = "" + narrative_context: str = "" + combined_context: str = "" + +class ContextManager: + def __init__(self): + pass + + def create_context_bundle(self, knowledge_chunks=None, narrative_context="", previous_slides=None) -> ContextBundle: + """Create a context bundle from knowledge chunks and narrative context""" + knowledge_context = "" + + # Ensure narrative_context is not None + narrative_context = narrative_context or "" + + if knowledge_chunks: + knowledge_context = "\n\n".join([ + f"From {chunk.file_path}: {chunk.content[:200]}..." + for chunk in knowledge_chunks + ]) + + combined_context = f"{narrative_context}\n\n{knowledge_context}".strip() + + return ContextBundle( + knowledge_context=knowledge_context, + narrative_context=narrative_context, + combined_context=combined_context + ) + def get_context_stats(self, context_bundle: ContextBundle) -> Dict[str, Any]: + """Get statistics about the context bundle""" + return { + 'knowledge_length': len(context_bundle.knowledge_context), + 'narrative_length': len(context_bundle.narrative_context), + 'combined_length': len(context_bundle.combined_context), + 'total_words': len(context_bundle.combined_context.split()) + } + def get_context_for_integration(self, context_bundle: ContextBundle, integration_method: str = "system_prompt") -> Dict[str, Any]: + """ + Get context data formatted for integration into prompts. + + Args: + context_bundle: The context bundle to format + integration_method: How to integrate context ("system_prompt" or "user_message") + + Returns: + Dictionary with context_addition and integration_point + """ + if not context_bundle: + return {} + + # Safely get context strings, handling None values + combined_context = getattr(context_bundle, 'combined_context', '') or '' + knowledge_context = getattr(context_bundle, 'knowledge_context', '') or '' + narrative_context = getattr(context_bundle, 'narrative_context', '') or '' + + if not combined_context.strip(): + return {} + + # Format the context for integration + context_parts = [] + + if knowledge_context.strip(): + context_parts.append("## RELEVANT KNOWLEDGE\n\n" + knowledge_context) + + if narrative_context.strip(): + context_parts.append("## PREVIOUS SLIDES CONTEXT\n\n" + narrative_context) + + if not context_parts: + return {} + + context_addition = "\n\n".join(context_parts) + + # Add instructions for using the context + if integration_method == "system_prompt": + context_addition += "\n\n## CONTEXT USAGE INSTRUCTIONS\n\n" + context_addition += "Use the above knowledge and context information to enhance your transcript generation. " + context_addition += "Incorporate relevant facts and maintain consistency with previous slides when appropriate." + + return { + 'context_addition': context_addition, + 'integration_point': 'before_instructions' if integration_method == "system_prompt" else 'prefix' + } diff --git a/end-to-end-use-cases/powerpoint-to-voiceover-transcript/src/knowledge/faiss_knowledge.py b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/src/knowledge/faiss_knowledge.py new file mode 100644 index 000000000..197b3b1b9 --- /dev/null +++ b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/src/knowledge/faiss_knowledge.py @@ -0,0 +1,506 @@ +""" +FAISS-based Knowledge Manager for enhanced vector search and storage. +Replaces the numpy-based approach with production-ready vector database. +""" + +import faiss +import pickle +import hashlib +import logging +from pathlib import Path +from typing import List, Dict, Any, Optional, Tuple +from dataclasses import dataclass, field +import json +from datetime import datetime + +try: + from sentence_transformers import SentenceTransformer + import numpy as np + SENTENCE_TRANSFORMERS_AVAILABLE = True +except ImportError: + SENTENCE_TRANSFORMERS_AVAILABLE = False + +logger = logging.getLogger(__name__) + +@dataclass +class KnowledgeChunk: + """Enhanced knowledge chunk with FAISS indexing support""" + content: str + file_path: str + section: Optional[str] = None + metadata: Optional[Dict[str, Any]] = None + chunk_id: int = 0 + embedding_hash: Optional[str] = None + created_at: Optional[str] = None + + def __post_init__(self): + if self.created_at is None: + self.created_at = datetime.now().isoformat() + if self.metadata is None: + self.metadata = {} + +class FAISSKnowledgeManager: + """ + Production-ready knowledge manager using FAISS for vector search. + + Features: + - Multiple index types (Flat, IVF, HNSW) + - Persistent caching with automatic invalidation + - Incremental document updates + - Memory-efficient storage + - GPU acceleration support + """ + + def __init__( + self, + knowledge_base_dir: str, + index_type: str = "flat", + embedding_model: str = "all-MiniLM-L6-v2", + use_gpu: bool = False + ): + self.knowledge_base_dir = Path(knowledge_base_dir) + self.chunks = [] + self.index = None + self.model = None + self.index_type = index_type.lower() + self.embedding_model = embedding_model + self.use_gpu = use_gpu + + # Cache and metadata + self.cache_dir = self.knowledge_base_dir / ".faiss_cache" + self.cache_dir.mkdir(exist_ok=True) + self.metadata_file = self.cache_dir / "metadata.json" + + # Performance tracking + self.stats = { + 'total_searches': 0, + 'cache_hits': 0, + 'index_builds': 0, + 'last_updated': None + } + + def initialize(self) -> None: + """Initialize the FAISS knowledge manager""" + if not SENTENCE_TRANSFORMERS_AVAILABLE: + raise ImportError("sentence_transformers and numpy are required for knowledge base functionality") + + logger.info(f"Initializing FAISS Knowledge Manager with {self.index_type} index") + + # Load embedding model + self.model = SentenceTransformer(self.embedding_model) + logger.info(f"Loaded embedding model: {self.embedding_model}") + + # Try to load cached index + if self._should_rebuild_index(): + logger.info("Building new FAISS index...") + self._build_index() + self._save_index() + else: + logger.info("Loading cached FAISS index...") + if not self._load_cached_index(): + logger.warning("Failed to load cached index, rebuilding...") + self._build_index() + self._save_index() + + def _should_rebuild_index(self) -> bool: + """Check if index needs to be rebuilt based on file changes""" + if not self.metadata_file.exists(): + return True + + try: + with open(self.metadata_file, 'r') as f: + metadata = json.load(f) + + # Check if knowledge base files have changed + current_hash = self._get_knowledge_base_hash() + stored_hash = metadata.get('knowledge_base_hash') + + return current_hash != stored_hash + + except Exception as e: + logger.warning(f"Error reading metadata: {e}") + return True + + def _get_knowledge_base_hash(self) -> str: + """Generate hash of all knowledge base files for change detection""" + md_files = sorted(self.knowledge_base_dir.rglob("*.md")) + hash_content = "" + + for md_file in md_files: + try: + with open(md_file, 'r', encoding='utf-8') as f: + content = f.read() + hash_content += f"{md_file.name}:{len(content)}:{hash(content)}" + except Exception as e: + logger.warning(f"Error reading {md_file}: {e}") + + return hashlib.md5(hash_content.encode()).hexdigest() + + def _build_index(self) -> None: + """Build FAISS index from knowledge base""" + self._load_knowledge_base() + + if not self.chunks: + logger.warning("No knowledge chunks found") + return + + logger.info(f"Processing {len(self.chunks)} knowledge chunks...") + + # Generate embeddings with progress tracking + texts = [chunk.content for chunk in self.chunks] + embeddings = self.model.encode( + texts, + show_progress_bar=True, + batch_size=32, + convert_to_numpy=True + ) + + # Create FAISS index based on type + dimension = embeddings.shape[1] + + if self.index_type == "flat": + # Exact search - best for small to medium datasets + self.index = faiss.IndexFlatIP(dimension) + + elif self.index_type == "ivf": + # Inverted File index - good balance of speed and accuracy + nlist = min(100, max(10, len(self.chunks) // 10)) + quantizer = faiss.IndexFlatIP(dimension) + self.index = faiss.IndexIVFFlat(quantizer, dimension, nlist) + + # Train the index + logger.info(f"Training IVF index with {nlist} clusters...") + self.index.train(embeddings.astype('float32')) + + elif self.index_type == "hnsw": + # Hierarchical Navigable Small World - very fast approximate search + self.index = faiss.IndexHNSWFlat(dimension, 32) + self.index.hnsw.efConstruction = 200 + self.index.hnsw.efSearch = 50 + + else: + raise ValueError(f"Unsupported index type: {self.index_type}") + + # Normalize embeddings for cosine similarity BEFORE adding to index + embeddings_normalized = embeddings.astype('float32').copy() + faiss.normalize_L2(embeddings_normalized) + + # Add embeddings to index + self.index.add(embeddings_normalized) + + # Move to GPU if requested and available (after adding data) + if self.use_gpu and faiss.get_num_gpus() > 0: + logger.info("Moving index to GPU...") + gpu_res = faiss.StandardGpuResources() + self.index = faiss.index_cpu_to_gpu(gpu_res, 0, self.index) + + # Update statistics + self.stats['index_builds'] += 1 + self.stats['last_updated'] = datetime.now().isoformat() + + logger.info(f"Built {self.index_type.upper()} index with {len(self.chunks)} chunks") + + def _load_knowledge_base(self) -> None: + """Load and chunk markdown files from knowledge base""" + md_files = list(self.knowledge_base_dir.rglob("*.md")) + self.chunks = [] + chunk_id = 0 + + logger.info(f"Loading {len(md_files)} markdown files...") + + for md_file in md_files: + try: + with open(md_file, 'r', encoding='utf-8') as f: + content = f.read() + + # Enhanced chunking by sections with better parsing + chunks = self._chunk_content(content, str(md_file)) + + for chunk_content, section_title in chunks: + if chunk_content.strip(): + chunk = KnowledgeChunk( + content=chunk_content.strip(), + file_path=str(md_file), + section=section_title, + chunk_id=chunk_id, + metadata={ + 'file_size': len(content), + 'chunk_size': len(chunk_content), + 'source_file': md_file.name + } + ) + self.chunks.append(chunk) + chunk_id += 1 + + except Exception as e: + logger.error(f"Error processing {md_file}: {e}") + + logger.info(f"Created {len(self.chunks)} knowledge chunks from {len(md_files)} files") + + def _chunk_content(self, content: str, file_path: str) -> List[Tuple[str, Optional[str]]]: + """Enhanced content chunking with better section detection""" + chunks = [] + + # Split by main headers (# and ##) + sections = content.split('\n## ') + + for i, section in enumerate(sections): + if not section.strip(): + continue + + if i == 0: + # First section might not have ## prefix + if section.startswith('# '): + # Extract title and content + lines = section.split('\n', 1) + title = lines[0].replace('# ', '').strip() + content_part = lines[1] if len(lines) > 1 else "" + chunks.append((content_part, title)) + else: + chunks.append((section, None)) + else: + # Subsequent sections + lines = section.split('\n', 1) + section_title = lines[0].strip() + section_content = lines[1] if len(lines) > 1 else "" + + # Further split large sections by ### if needed + if len(section_content) > 2000: # Large section threshold + subsections = section_content.split('\n### ') + for j, subsection in enumerate(subsections): + if subsection.strip(): + if j == 0: + chunks.append((subsection, section_title)) + else: + sub_lines = subsection.split('\n', 1) + sub_title = f"{section_title} - {sub_lines[0].strip()}" + sub_content = sub_lines[1] if len(sub_lines) > 1 else "" + chunks.append((sub_content, sub_title)) + else: + chunks.append((section_content, section_title)) + + return chunks + + def search( + self, + query: str, + top_k: int = 5, + similarity_threshold: float = 0.3 + ) -> List[KnowledgeChunk]: + """Search for relevant knowledge chunks using FAISS""" + if not self.chunks or self.index is None: + logger.warning("No index available for search") + return [] + + self.stats['total_searches'] += 1 + + try: + # Encode query + query_embedding = self.model.encode([query], convert_to_numpy=True) + faiss.normalize_L2(query_embedding.astype('float32')) + + # Search FAISS index + scores, indices = self.index.search(query_embedding.astype('float32'), top_k) + + # Filter by similarity threshold and return chunks + results = [] + for score, idx in zip(scores[0], indices[0]): + if score >= similarity_threshold and 0 <= idx < len(self.chunks): + chunk = self.chunks[idx] + # Add search score to metadata + chunk.metadata['search_score'] = float(score) + results.append(chunk) + + logger.debug(f"Search query: '{query}' returned {len(results)} results") + return results + + except Exception as e: + logger.error(f"Search error: {e}") + return [] + + def add_document(self, file_path: str, content: str) -> bool: + """Add new document to existing index""" + try: + # Process new content into chunks + new_chunks = [] + chunks = self._chunk_content(content, file_path) + + start_id = len(self.chunks) + for i, (chunk_content, section_title) in enumerate(chunks): + if chunk_content.strip(): + chunk = KnowledgeChunk( + content=chunk_content.strip(), + file_path=file_path, + section=section_title, + chunk_id=start_id + i, + metadata={ + 'file_size': len(content), + 'chunk_size': len(chunk_content), + 'source_file': Path(file_path).name + } + ) + new_chunks.append(chunk) + + if not new_chunks: + logger.warning(f"No chunks created from {file_path}") + return False + + # Generate embeddings for new chunks + texts = [chunk.content for chunk in new_chunks] + embeddings = self.model.encode(texts, convert_to_numpy=True) + + # Normalize embeddings before adding to index + embeddings_normalized = embeddings.astype('float32').copy() + faiss.normalize_L2(embeddings_normalized) + + # Add to index + self.index.add(embeddings_normalized) + + # Add to chunks list + self.chunks.extend(new_chunks) + + # Save updated index + self._save_index() + + logger.info(f"Added {len(new_chunks)} chunks from {file_path}") + return True + + except Exception as e: + logger.error(f"Error adding document {file_path}: {e}") + return False + + def _save_index(self) -> None: + """Save FAISS index and chunks to cache""" + if self.index is None: + return + + try: + index_path = self.cache_dir / "faiss.index" + chunks_path = self.cache_dir / "chunks.pkl" + + # Save FAISS index (move to CPU first if on GPU) + index_to_save = self.index + if self.use_gpu and faiss.get_num_gpus() > 0: + index_to_save = faiss.index_gpu_to_cpu(self.index) + + faiss.write_index(index_to_save, str(index_path)) + + # Save chunks + with open(chunks_path, 'wb') as f: + pickle.dump(self.chunks, f) + + # Save metadata + metadata = { + 'knowledge_base_hash': self._get_knowledge_base_hash(), + 'index_type': self.index_type, + 'embedding_model': self.embedding_model, + 'total_chunks': len(self.chunks), + 'created_at': datetime.now().isoformat(), + 'stats': self.stats + } + + with open(self.metadata_file, 'w') as f: + json.dump(metadata, f, indent=2) + + logger.info(f"Saved FAISS index with {len(self.chunks)} chunks") + + except Exception as e: + logger.error(f"Error saving index: {e}") + + def _load_cached_index(self) -> bool: + """Load cached FAISS index and chunks""" + index_path = self.cache_dir / "faiss.index" + chunks_path = self.cache_dir / "chunks.pkl" + + if not (index_path.exists() and chunks_path.exists()): + return False + + try: + # Load FAISS index + self.index = faiss.read_index(str(index_path)) + + # Move to GPU if requested + if self.use_gpu and faiss.get_num_gpus() > 0: + logger.info("Moving cached index to GPU...") + self.index = faiss.index_cpu_to_gpu(faiss.StandardGpuResources(), 0, self.index) + + # Load chunks + with open(chunks_path, 'rb') as f: + self.chunks = pickle.load(f) + + # Load metadata and stats + if self.metadata_file.exists(): + with open(self.metadata_file, 'r') as f: + metadata = json.load(f) + self.stats.update(metadata.get('stats', {})) + + logger.info(f"Loaded cached index with {len(self.chunks)} chunks") + return True + + except Exception as e: + logger.error(f"Failed to load cached index: {e}") + return False + + def rebuild_index(self) -> None: + """Force rebuild of the index""" + logger.info("Force rebuilding FAISS index...") + self._build_index() + self._save_index() + + def clear_cache(self) -> None: + """Clear all cached data""" + try: + import shutil + if self.cache_dir.exists(): + shutil.rmtree(self.cache_dir) + self.cache_dir.mkdir(exist_ok=True) + logger.info("Cleared FAISS cache") + except Exception as e: + logger.error(f"Error clearing cache: {e}") + + def get_stats(self) -> Dict[str, Any]: + """Get comprehensive knowledge base statistics""" + stats = { + 'total_chunks': len(self.chunks), + 'index_type': self.index_type, + 'embedding_model': self.embedding_model, + 'model_loaded': self.model is not None, + 'index_loaded': self.index is not None, + 'use_gpu': self.use_gpu, + 'cache_dir': str(self.cache_dir), + 'knowledge_base_dir': str(self.knowledge_base_dir), + } + + # Add FAISS-specific stats + if self.index: + stats.update({ + 'index_size': self.index.ntotal, + 'dimension': self.index.d, + 'is_trained': getattr(self.index, 'is_trained', True) + }) + + # Add performance stats + stats.update(self.stats) + + # Memory usage estimation + if self.chunks: + total_content_size = sum(len(chunk.content) for chunk in self.chunks) + stats['content_size_mb'] = total_content_size / (1024 * 1024) + stats['avg_chunk_size'] = total_content_size / len(self.chunks) + + return stats + + def get_chunk_by_id(self, chunk_id: int) -> Optional[KnowledgeChunk]: + """Get specific chunk by ID""" + for chunk in self.chunks: + if chunk.chunk_id == chunk_id: + return chunk + return None + + def search_by_file(self, file_path: str) -> List[KnowledgeChunk]: + """Get all chunks from a specific file""" + return [chunk for chunk in self.chunks if chunk.file_path == file_path] + + +# Backward compatibility alias +MarkdownKnowledgeManager = FAISSKnowledgeManager diff --git a/end-to-end-use-cases/powerpoint-to-voiceover-transcript/src/processors/__init__.py b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/src/processors/__init__.py new file mode 100644 index 000000000..f2ec1786a --- /dev/null +++ b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/src/processors/__init__.py @@ -0,0 +1,13 @@ +"""Processing modules for PPTX to Transcript.""" + +from .unified_transcript_generator import ( + UnifiedTranscriptProcessor, + process_slides, + process_slides_with_narrative +) + +__all__ = [ + "UnifiedTranscriptProcessor", + "process_slides", + "process_slides_with_narrative" +] diff --git a/end-to-end-use-cases/powerpoint-to-voiceover-transcript/src/processors/unified_transcript_generator.py b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/src/processors/unified_transcript_generator.py new file mode 100644 index 000000000..13517191a --- /dev/null +++ b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/src/processors/unified_transcript_generator.py @@ -0,0 +1,514 @@ +"""Unified transcript generation processor with optional narrative continuity.""" + +import json +import logging +from pathlib import Path +from typing import Any, Dict, List, Optional, Union + +import pandas as pd +from tqdm import tqdm + +from ..config.settings import get_processing_config, get_system_prompt, is_knowledge_enabled +from ..core.groq_client import GroqClient + + +logger = logging.getLogger(__name__) + + +class SlideContext: + """Simple container for slide context information.""" + + def __init__(self, slide_number: int, title: str, transcript: str): + self.slide_number = slide_number + self.title = title + self.transcript = transcript + + def to_dict(self) -> Dict[str, Any]: + return { + "slide_number": int(self.slide_number), # Convert to native Python int + "title": str(self.title), # Ensure it's a string + "transcript": str(self.transcript), # Ensure it's a string + } + + +class UnifiedTranscriptProcessor: + """Unified processor for generating transcripts with optional narrative continuity.""" + + def __init__( + self, + api_key: Optional[str] = None, + use_narrative: bool = True, + context_window_size: int = 5, + knowledge_base_dir: Optional[str] = None, + enable_knowledge: Optional[bool] = None, + ): + """ + Initialize unified transcript processor. + + Args: + api_key: Llama API key. If None, will be loaded from config/environment. + use_narrative: Whether to use narrative continuity (default: True) + context_window_size: Number of previous slides to include in context when use_narrative=True (default: 5) + knowledge_base_dir: Path to knowledge base directory (optional) + enable_knowledge: Override knowledge base enable setting (optional) + """ + self.client = GroqClient(api_key=api_key) + self.processing_config = get_processing_config() + self.use_narrative = use_narrative + self.context_window_size = context_window_size + self.slide_contexts: List[SlideContext] = [] + + # Knowledge base integration + self.knowledge_manager = None + self.context_manager = None + self.enable_knowledge = enable_knowledge if enable_knowledge is not None else is_knowledge_enabled() + + if self.enable_knowledge: + self._initialize_knowledge_components(knowledge_base_dir) + def _initialize_knowledge_components(self, knowledge_base_dir: Optional[str] = None) -> None: + """Initialize knowledge base components with error handling.""" + try: + from ..knowledge.faiss_knowledge import FAISSKnowledgeManager + from ..knowledge.context_manager import ContextManager + from ..config.settings import load_config + + # Get configuration + config = load_config() + knowledge_config = config.get('knowledge', {}) + + # Get knowledge base directory from config if not provided + if knowledge_base_dir is None: + knowledge_base_dir = knowledge_config.get('knowledge_base_dir', 'knowledge_base') + + # Ensure we have a valid path + if not knowledge_base_dir: + raise ValueError("Knowledge base directory not specified") + + # Get FAISS configuration + vector_config = knowledge_config.get('vector_store', {}) + embedding_config = knowledge_config.get('embedding', {}) + + # Initialize FAISS knowledge manager with configuration + self.knowledge_manager = FAISSKnowledgeManager( + knowledge_base_dir=knowledge_base_dir, + index_type=vector_config.get('index_type', 'flat'), + embedding_model=embedding_config.get('model_name', 'all-MiniLM-L6-v2'), + use_gpu=vector_config.get('use_gpu', False) + ) + self.knowledge_manager.initialize() + + # Initialize context manager + self.context_manager = ContextManager() + + logger.info("FAISS knowledge base components initialized successfully") + + except Exception as e: + logger.warning(f"Failed to initialize knowledge base: {e}") + # Graceful degradation - disable knowledge features + self.enable_knowledge = False + self.knowledge_manager = None + self.context_manager = None + + def _retrieve_knowledge_chunks(self, slide_content: str, speaker_notes: str) -> tuple[List[Any], Dict[str, Any]]: + """ + Retrieve relevant knowledge chunks for the current slide. + + Args: + slide_content: Content extracted from slide image (if available) + speaker_notes: Speaker notes for the slide + + Returns: + Tuple of (knowledge chunks, knowledge metadata) + """ + if not self.enable_knowledge or not self.knowledge_manager: + return [], {} + + try: + # Combine slide content and speaker notes for search query + search_query = f"{slide_content} {speaker_notes}".strip() + + if not search_query: + return [], {} + + # Search for relevant chunks + chunks = self.knowledge_manager.search(search_query) + + # Create metadata about knowledge usage + knowledge_metadata = { + 'search_query': search_query[:200] + '...' if len(search_query) > 200 else search_query, + 'chunks_found': len(chunks), + 'knowledge_sources': [], + 'knowledge_sections': [], + 'search_scores': [] + } + + # Extract metadata from chunks + for chunk in chunks: + if hasattr(chunk, 'file_path'): + source_file = Path(chunk.file_path).name + if source_file not in knowledge_metadata['knowledge_sources']: + knowledge_metadata['knowledge_sources'].append(source_file) + + if hasattr(chunk, 'section') and chunk.section: + if chunk.section not in knowledge_metadata['knowledge_sections']: + knowledge_metadata['knowledge_sections'].append(chunk.section) + + if hasattr(chunk, 'metadata') and chunk.metadata and 'search_score' in chunk.metadata: + knowledge_metadata['search_scores'].append(round(chunk.metadata['search_score'], 3)) + + logger.debug(f"Retrieved {len(chunks)} knowledge chunks for query: {search_query[:100]}...") + + return chunks, knowledge_metadata + + except Exception as e: + logger.warning(f"Failed to retrieve knowledge chunks: {e}") + return [], {} + + def _build_context_bundle( + self, + knowledge_chunks: List[Any], + slide_number: Optional[int] = None + ) -> Optional[Any]: + """ + Build context bundle combining knowledge and narrative contexts. + + Args: + knowledge_chunks: Retrieved knowledge chunks + slide_number: Current slide number for narrative context + + Returns: + ContextBundle or None if no context available + """ + if not self.enable_knowledge or not self.context_manager: + return None + + try: + # Get narrative context if using narrative mode + narrative_context = None + previous_slides = None + + if self.use_narrative and slide_number is not None and self.slide_contexts: + # Build narrative context from previous slides + recent_contexts = self.slide_contexts[-self.context_window_size:] + narrative_parts = [] + + for context in recent_contexts: + narrative_parts.append( + f"Slide {context.slide_number} - {context.title}: {context.transcript[:200]}..." + ) + + narrative_context = "\n".join(narrative_parts) + previous_slides = [ctx.to_dict() for ctx in recent_contexts] + + # Create context bundle + context_bundle = self.context_manager.create_context_bundle( + knowledge_chunks=knowledge_chunks, + narrative_context=narrative_context, + previous_slides=previous_slides + ) + + return context_bundle + + except Exception as e: + logger.warning(f"Failed to build context bundle: {e}") + return None + + def _build_context_prompt( + self, current_slide_number: int, slide_contexts: List[SlideContext] + ) -> str: + """ + Build enhanced system prompt with previous slide transcripts as context. + Only used when use_narrative=True. + + Args: + current_slide_number: Number of the current slide being processed + slide_contexts: List of previous slide contexts + + Returns: + Enhanced system prompt with context + """ + base_prompt = get_system_prompt() + + if not slide_contexts or not self.use_narrative: + return base_prompt + + # Build context section + context_section = "\n\n## PREVIOUS SLIDE CONTEXT\n\n" + context_section += f"You are currently processing slide {current_slide_number} of this presentation. " + context_section += "Here are the transcripts from the previous slides to maintain narrative continuity:\n\n" + + # Add previous slides context (use last N slides based on context window) + recent_contexts = slide_contexts[-self.context_window_size :] + + for context in recent_contexts: + context_section += ( + f'**Slide {context.slide_number} - "{context.title}":**\n' + ) + context_section += f"{context.transcript}\n\n" + + # Add continuity instructions + continuity_instructions = """ +## NARRATIVE CONTINUITY REQUIREMENTS + +When generating the transcript for this slide, ensure: + +1. **Smooth Transitions**: Reference previous concepts when appropriate (e.g., "Building on what we discussed about...", "As we saw in the previous section...") + +2. **Consistent Terminology**: Use the same terms and definitions established in previous slides + +3. **Logical Flow**: Ensure this slide's content logically follows from previous slides + +4. **Avoid Repetition**: Don't repeat information already covered unless it's for emphasis or summary + +5. **Forward References**: If this slide sets up future content, use appropriate language (e.g., "We'll explore this further...", "This leads us to...") + +6. **Contextual Awareness**: Understand where this slide fits in the overall presentation narrative + +""" + + return base_prompt + context_section + continuity_instructions + + def process_single_slide( + self, + image_path: Union[str, Path], + speaker_notes: str = "", + system_prompt: Optional[str] = None, + slide_number: Optional[int] = None, + slide_title: str = "", + ) -> tuple[str, Dict[str, Any]]: + """ + Process a single slide to generate transcript with optional knowledge integration. + + Args: + image_path: Path to the slide image + speaker_notes: Speaker notes for the slide + system_prompt: Custom system prompt. If None, uses default from config. + slide_number: Number of the current slide (used for narrative continuity) + slide_title: Title of the current slide (used for narrative continuity) + + Returns: + Tuple of (generated transcript text, knowledge metadata) + """ + # Retrieve knowledge chunks if knowledge base is enabled + knowledge_chunks = [] + knowledge_metadata = {} + if self.enable_knowledge: + # Use slide title and speaker notes as search context + slide_content = slide_title # Could be enhanced with OCR in the future + knowledge_chunks, knowledge_metadata = self._retrieve_knowledge_chunks(slide_content, speaker_notes) + + # Build context bundle + context_bundle = None + if knowledge_chunks or (self.use_narrative and slide_number is not None): + context_bundle = self._build_context_bundle(knowledge_chunks, slide_number) + + if self.use_narrative and slide_number is not None: + # Use narrative-aware processing with optional knowledge integration + enhanced_prompt = self._build_context_prompt( + slide_number, self.slide_contexts + ) + + # Generate transcript with context bundle + transcript = self.client.generate_transcript( + image_path=str(image_path), + speaker_notes=speaker_notes, + system_prompt=enhanced_prompt, + context_bundle=context_bundle, + stream=False, + ) + + # Create and store slide context for future slides + slide_context = SlideContext( + slide_number=slide_number, + title=slide_title, + transcript=transcript, + ) + self.slide_contexts.append(slide_context) + + return transcript, knowledge_metadata + else: + # Use standard processing with optional knowledge integration + transcript = self.client.generate_transcript( + image_path=str(image_path), + speaker_notes=speaker_notes, + system_prompt=system_prompt, + context_bundle=context_bundle, + stream=False, + ) + return transcript, knowledge_metadata + + def process_slides_dataframe( + self, + df: pd.DataFrame, + output_dir: Union[str, Path], + system_prompt: Optional[str] = None, + save_context: bool = True, + ) -> pd.DataFrame: + """ + Process slides from a DataFrame containing slide information. + + Args: + df: DataFrame with slide information (from extract_pptx_notes) + output_dir: Directory containing slide images + system_prompt: Custom system prompt. If None, uses default from config. + save_context: Whether to save context information to file (only used when use_narrative=True) + + Returns: + DataFrame with added 'ai_transcript' column and context columns if using narrative mode + """ + output_dir = Path(output_dir) + df_copy = df.copy() + + if self.use_narrative: + print(f"Processing {len(df_copy)} slides with narrative continuity...") + print(f"Using context window of {self.context_window_size} previous slides") + else: + print(f"Processing {len(df_copy)} slides in standard mode...") + + for i in tqdm(range(len(df_copy)), desc="Processing slides"): + # Get data for current slide + slide_row = df_copy.iloc[i] + slide_number = slide_row["slide_number"] + slide_title = slide_row.get("slide_title", "") + slide_filename = slide_row["image_filename"] + speaker_notes = ( + slide_row["speaker_notes"] + if pd.notna(slide_row["speaker_notes"]) + else "" + ) + + image_path = output_dir / slide_filename + + # Initialize knowledge metadata for this slide + knowledge_metadata = {} + + # Generate transcript + if self.use_narrative: + transcript, knowledge_metadata = self.process_single_slide( + image_path=image_path, + speaker_notes=speaker_notes, + system_prompt=system_prompt, + slide_number=slide_number, + slide_title=slide_title, + ) + # Add context information to dataframe + df_copy.loc[i, "context_slides_used"] = min( + len(self.slide_contexts) - 1, self.context_window_size + ) + else: + transcript, knowledge_metadata = self.process_single_slide( + image_path=image_path, + speaker_notes=speaker_notes, + system_prompt=system_prompt, + ) + + # Add transcript to dataframe + df_copy.loc[i, "ai_transcript"] = transcript + + # Add knowledge metadata if available + if knowledge_metadata: + df_copy.loc[i, "knowledge_chunks_used"] = knowledge_metadata.get('chunks_found', 0) + df_copy.loc[i, "knowledge_sources"] = ', '.join(knowledge_metadata.get('knowledge_sources', [])) + df_copy.loc[i, "knowledge_sections"] = ', '.join(knowledge_metadata.get('knowledge_sections', [])) + df_copy.loc[i, "knowledge_search_query"] = knowledge_metadata.get('search_query', '') + if knowledge_metadata.get('search_scores'): + df_copy.loc[i, "avg_knowledge_score"] = sum(knowledge_metadata['search_scores']) / len(knowledge_metadata['search_scores']) + else: + df_copy.loc[i, "avg_knowledge_score"] = 0.0 + else: + # Initialize knowledge metadata columns with default values + df_copy.loc[i, "knowledge_chunks_used"] = 0 + df_copy.loc[i, "knowledge_sources"] = "" + df_copy.loc[i, "knowledge_sections"] = "" + df_copy.loc[i, "knowledge_search_query"] = "" + df_copy.loc[i, "avg_knowledge_score"] = 0.0 + + # Save context information if requested and using narrative mode + if save_context and self.use_narrative: + self._save_context_information(output_dir) + + return df_copy + + def _save_context_information(self, output_dir: Path): + """Save context information to files. Only used when use_narrative=True.""" + if not self.use_narrative: + return + + context_dir = output_dir / "narrative_context" + context_dir.mkdir(exist_ok=True) + + # Save slide contexts + contexts_data = [context.to_dict() for context in self.slide_contexts] + with open(context_dir / "slide_contexts.json", "w") as f: + json.dump(contexts_data, f, indent=2) + + # Save simple summary + summary = { + "total_slides": len(self.slide_contexts), + "context_window_size": self.context_window_size, + "slide_progression": [ + { + "slide_number": int( + ctx.slide_number + ), # Convert to native Python int + "title": str(ctx.title), # Ensure it's a string + } + for ctx in self.slide_contexts + ], + } + + with open(context_dir / "narrative_summary.json", "w") as f: + json.dump(summary, f, indent=2) + + print(f"Context information saved to: {context_dir}") + + +# Convenience functions for backward compatibility +def process_slides( + df: pd.DataFrame, + output_dir: Union[str, Path] = "slide_images", + api_key: Optional[str] = None, + system_prompt: Optional[str] = None, + use_narrative: bool = False, +) -> pd.DataFrame: + """ + Process slides from a DataFrame to generate transcripts. + + Args: + df: DataFrame with slide information (from extract_pptx_notes) + output_dir: Directory containing slide images + api_key: Llama API key. If None, will be loaded from config/environment. + system_prompt: Custom system prompt. If None, uses default from config. + use_narrative: Whether to use narrative continuity (default: False for backward compatibility) + + Returns: + DataFrame with added 'ai_transcript' column + """ + processor = UnifiedTranscriptProcessor(api_key=api_key, use_narrative=use_narrative) + return processor.process_slides_dataframe(df, output_dir, system_prompt) + + +def process_slides_with_narrative( + df: pd.DataFrame, + output_dir: Union[str, Path] = "slide_images", + api_key: Optional[str] = None, + context_window_size: int = 5, + save_context: bool = True, +) -> pd.DataFrame: + """ + Process slides from a DataFrame to generate transcripts with narrative continuity. + + Args: + df: DataFrame with slide information (from extract_pptx_notes) + output_dir: Directory containing slide images + api_key: Llama API key. If None, will be loaded from config/environment. + context_window_size: Number of previous slides to include in context (default: 5) + save_context: Whether to save context information to files + + Returns: + DataFrame with added transcript and context columns + """ + processor = UnifiedTranscriptProcessor( + api_key=api_key, use_narrative=True, context_window_size=context_window_size + ) + return processor.process_slides_dataframe(df, output_dir, save_context=save_context) diff --git a/end-to-end-use-cases/powerpoint-to-voiceover-transcript/src/utils/__init__.py b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/src/utils/__init__.py new file mode 100644 index 000000000..93b56ea2d --- /dev/null +++ b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/src/utils/__init__.py @@ -0,0 +1,5 @@ +"""Utility functions for PPTX to Transcript.""" + +from .visualization import display_slide_grid + +__all__ = ["display_slide_grid"] diff --git a/end-to-end-use-cases/powerpoint-to-voiceover-transcript/src/utils/transcript_display.py b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/src/utils/transcript_display.py new file mode 100644 index 000000000..3230b0a2a --- /dev/null +++ b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/src/utils/transcript_display.py @@ -0,0 +1,194 @@ +""" +Utility functions for displaying transcripts with knowledge enhancement details. +""" + +import pandas as pd +from typing import Optional, List, Dict, Any +from pathlib import Path + + +def display_enhanced_transcripts( + processed_df: pd.DataFrame, + knowledge_manager=None, + num_slides: int = 5, + show_knowledge_details: bool = True, + show_search_scores: bool = True +) -> None: + """ + Display transcripts with knowledge enhancement details. + + Args: + processed_df: DataFrame with processed transcripts + knowledge_manager: FAISS knowledge manager instance + num_slides: Number of slides to display + show_knowledge_details: Whether to show knowledge chunk details + show_search_scores: Whether to show similarity scores + """ + + print(f'Displaying first {num_slides} slide transcripts with knowledge enhancement\n') + print('=' * 100) + + for idx, row in processed_df.head(num_slides).iterrows(): + print(f'\nSLIDE {row["slide_number"]} - {row["slide_title"]}') + print('=' * 80) + + # Display transcript + print('\nTRANSCRIPT:') + print(f'"{row["ai_transcript"]}"') + + # Display knowledge enhancement details if available + if show_knowledge_details and knowledge_manager: + _display_knowledge_details(row, knowledge_manager, show_search_scores) + + # Display basic knowledge stats from DataFrame if available + elif 'knowledge_chunks_used' in row and pd.notna(row['knowledge_chunks_used']): + _display_basic_knowledge_stats(row) + + print('\n' + '-' * 80) + + +def _display_knowledge_details( + row: pd.Series, + knowledge_manager, + show_search_scores: bool = True +) -> None: + """Display detailed knowledge chunk information.""" + + # Try to reconstruct the search that was performed + search_query = "" + if 'knowledge_search_query' in row and pd.notna(row['knowledge_search_query']): + search_query = row['knowledge_search_query'] + else: + # Fallback: use slide title and notes + search_query = f"{row.get('slide_title', '')} {row.get('speaker_notes', '')}".strip() + + if not search_query: + print('\nKNOWLEDGE ENHANCEMENT: No search query available') + return + + try: + # Perform the same search to get chunk details + chunks = knowledge_manager.search(search_query, top_k=5) + + if not chunks: + print('\nKNOWLEDGE ENHANCEMENT: No relevant knowledge found') + return + + print(f'\nKNOWLEDGE ENHANCEMENT:') + print(f' Search Query: "{search_query[:100]}{"..." if len(search_query) > 100 else ""}"') + print(f' Chunks Found: {len(chunks)}') + + print('\nKNOWLEDGE CHUNKS USED:') + + for i, chunk in enumerate(chunks, 1): + print(f'\n Chunk {i}:') + print(f' Source: {Path(chunk.file_path).name}') + + if hasattr(chunk, 'section') and chunk.section: + print(f' Section: {chunk.section}') + + if show_search_scores and hasattr(chunk, 'metadata') and chunk.metadata: + score = chunk.metadata.get('search_score', 'N/A') + if score != 'N/A': + print(f' Similarity Score: {score:.3f}') + + # Show content preview + content_preview = chunk.content[:200] + '...' if len(chunk.content) > 200 else chunk.content + print(f' Content: "{content_preview}"') + + except Exception as e: + print(f'\nKNOWLEDGE ENHANCEMENT: Error retrieving details - {e}') + + +def _display_basic_knowledge_stats(row: pd.Series) -> None: + """Display basic knowledge statistics from DataFrame.""" + + print(f'\nKNOWLEDGE ENHANCEMENT:') + + if 'knowledge_chunks_used' in row and pd.notna(row['knowledge_chunks_used']): + print(f' Chunks Used: {int(row["knowledge_chunks_used"])}') + + if 'knowledge_sources' in row and pd.notna(row['knowledge_sources']) and row['knowledge_sources']: + sources = row['knowledge_sources'].split(', ') if isinstance(row['knowledge_sources'], str) else [] + print(f' Sources: {", ".join(sources)}') + + if 'knowledge_sections' in row and pd.notna(row['knowledge_sections']) and row['knowledge_sections']: + sections = row['knowledge_sections'].split(', ') if isinstance(row['knowledge_sections'], str) else [] + print(f' Sections: {", ".join(sections)}') + + if 'avg_knowledge_score' in row and pd.notna(row['avg_knowledge_score']): + print(f' Avg Similarity Score: {row["avg_knowledge_score"]:.3f}') + + +def display_knowledge_base_summary(knowledge_manager) -> None: + """Display summary of knowledge base contents.""" + + if not knowledge_manager: + print("No knowledge manager available") + return + + try: + stats = knowledge_manager.get_stats() + + print('\nKNOWLEDGE BASE SUMMARY') + print('=' * 50) + print(f'Total Chunks: {stats.get("total_chunks", 0)}') + print(f'Index Type: {stats.get("index_type", "unknown").upper()}') + print(f'Embedding Model: {stats.get("embedding_model", "unknown")}') + print(f'Content Size: {stats.get("content_size_mb", 0):.1f} MB') + print(f'Avg Chunk Size: {stats.get("avg_chunk_size", 0):.0f} characters') + + # Show knowledge sources + if hasattr(knowledge_manager, 'chunks') and knowledge_manager.chunks: + sources = set() + sections = set() + + for chunk in knowledge_manager.chunks: + if hasattr(chunk, 'file_path'): + sources.add(Path(chunk.file_path).name) + if hasattr(chunk, 'section') and chunk.section: + sections.add(chunk.section) + + print(f'\nKnowledge Sources ({len(sources)}):') + for source in sorted(sources): + print(f' โ€ข {source}') + + if sections: + print(f'\nKnowledge Sections ({len(sections)}):') + for section in sorted(list(sections)[:10]): # Show first 10 + print(f' โ€ข {section}') + if len(sections) > 10: + print(f' ... and {len(sections) - 10} more') + + print('=' * 50) + + except Exception as e: + print(f"Error displaying knowledge base summary: {e}") + + +# Convenience function for notebook use +def show_transcripts_with_knowledge( + processed_df: pd.DataFrame, + knowledge_manager=None, + num_slides: int = 5 +) -> None: + """ + Convenience function for displaying transcripts with knowledge details in notebooks. + + Usage in notebook: + from src.utils.transcript_display import show_transcripts_with_knowledge + show_transcripts_with_knowledge(processed_df, knowledge_manager, num_slides=3) + """ + + # Display knowledge base summary first + if knowledge_manager: + display_knowledge_base_summary(knowledge_manager) + + # Display enhanced transcripts + display_enhanced_transcripts( + processed_df, + knowledge_manager, + num_slides=num_slides, + show_knowledge_details=True, + show_search_scores=True + ) diff --git a/end-to-end-use-cases/powerpoint-to-voiceover-transcript/src/utils/visualization.py b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/src/utils/visualization.py new file mode 100644 index 000000000..9bf850569 --- /dev/null +++ b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/src/utils/visualization.py @@ -0,0 +1,105 @@ +"""Visualization utilities for displaying slide images and analysis results.""" + +import matplotlib.pyplot as plt +from PIL import Image +import math +from typing import List, Union, Tuple +from pathlib import Path + + +def display_slide_grid( + image_files: List[Union[str, Path]], + max_cols: int = 3, + figsize_per_image: Tuple[int, int] = (4, 3) +) -> None: + """ + Display slide images in a grid layout for Jupyter notebooks. + + Args: + image_files: List of image file paths + max_cols: Maximum number of columns in the grid (default: 3) + figsize_per_image: Size of each image subplot as (width, height) (default: (4, 3)) + + Example: + # Display first 6 slides in a 3-column grid + display_slide_grid(image_files[:6], max_cols=3, figsize_per_image=(4, 3)) + + # Display all slides in a 2-column grid with larger images + display_slide_grid(image_files, max_cols=2, figsize_per_image=(6, 4)) + """ + if not image_files: + print("No images to display") + return + + num_images = len(image_files) + cols = min(max_cols, num_images) + rows = math.ceil(num_images / cols) + + # Calculate figure size + fig_width = cols * figsize_per_image[0] + fig_height = rows * figsize_per_image[1] + + fig, axes = plt.subplots(rows, cols, figsize=(fig_width, fig_height)) + + # Handle single row/column cases + if rows == 1 and cols == 1: + axes = [axes] + elif rows == 1 or cols == 1: + axes = axes.flatten() + else: + axes = axes.flatten() + + for i, img_path in enumerate(image_files): + try: + # Load and display image + img = Image.open(img_path) + axes[i].imshow(img) + axes[i].set_title(f"Slide {i+1}", fontsize=10, pad=5) + axes[i].axis('off') + except Exception as e: + # Handle error case + img_name = Path(img_path).name if hasattr(img_path, 'name') else str(img_path) + axes[i].text(0.5, 0.5, f"Error loading\n{img_name}", + ha='center', va='center', transform=axes[i].transAxes) + axes[i].set_title(f"Slide {i+1} (Error)", fontsize=10, pad=5) + axes[i].axis('off') + + # Hide any unused subplots + for i in range(num_images, len(axes)): + axes[i].axis('off') + + plt.tight_layout() + plt.show() + + +def display_slide_preview( + image_files: List[Union[str, Path]], + num_slides: int = 6, + max_cols: int = 3, + figsize_per_image: Tuple[int, int] = (4, 3) +) -> None: + """ + Display a preview of the first N slide images. + + Args: + image_files: List of image file paths + num_slides: Number of slides to display (default: 6) + max_cols: Maximum number of columns in the grid (default: 3) + figsize_per_image: Size of each image subplot as (width, height) (default: (4, 3)) + + Example: + # Show first 6 slides + display_slide_preview(image_files, num_slides=6) + + # Show first 8 slides in 4 columns + display_slide_preview(image_files, num_slides=8, max_cols=4) + """ + total_slides = len(image_files) + slides_to_show = min(num_slides, total_slides) + + print(f"\nDisplaying first {slides_to_show} of {total_slides} slide images:") + display_slide_grid( + image_files[:slides_to_show], + max_cols=max_cols, + figsize_per_image=figsize_per_image + ) diff --git a/end-to-end-use-cases/powerpoint-to-voiceover-transcript/uv.lock b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/uv.lock new file mode 100644 index 000000000..7a88cdfcf --- /dev/null +++ b/end-to-end-use-cases/powerpoint-to-voiceover-transcript/uv.lock @@ -0,0 +1,2814 @@ +version = 1 +revision = 3 +requires-python = ">=3.12" +resolution-markers = [ + "python_full_version >= '3.14'", + "python_full_version < '3.14'", +] + +[[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 = "anyio" +version = "4.9.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "idna" }, + { name = "sniffio" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/95/7d/4c1bd541d4dffa1b52bd83fb8527089e097a106fc90b467a7313b105f840/anyio-4.9.0.tar.gz", hash = "sha256:673c0c244e15788651a4ff38710fea9675823028a6f08a5eda409e0c9840a028", size = 190949, upload-time = "2025-03-17T00:02:54.77Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a1/ee/48ca1a7c89ffec8b6a0c5d02b89c305671d5ffd8d3c94acf8b8c408575bb/anyio-4.9.0-py3-none-any.whl", hash = "sha256:9f76d541cad6e36af7beb62e978876f3b41e3e04f2c1fbf0884604c0a9c4d93c", size = 100916, upload-time = "2025-03-17T00:02:52.713Z" }, +] + +[[package]] +name = "appnope" +version = "0.1.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/35/5d/752690df9ef5b76e169e68d6a129fa6d08a7100ca7f754c89495db3c6019/appnope-0.1.4.tar.gz", hash = "sha256:1de3860566df9caf38f01f86f65e0e13e379af54f9e4bee1e66b48f2efffd1ee", size = 4170, upload-time = "2024-02-06T09:43:11.258Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/81/29/5ecc3a15d5a33e31b26c11426c45c501e439cb865d0bff96315d86443b78/appnope-0.1.4-py2.py3-none-any.whl", hash = "sha256:502575ee11cd7a28c0205f379b525beefebab9d161b7c964670864014ed7213c", size = 4321, upload-time = "2024-02-06T09:43:09.663Z" }, +] + +[[package]] +name = "argon2-cffi" +version = "25.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "argon2-cffi-bindings", version = "21.2.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.14'" }, + { name = "argon2-cffi-bindings", version = "25.1.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.14'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0e/89/ce5af8a7d472a67cc819d5d998aa8c82c5d860608c4db9f46f1162d7dab9/argon2_cffi-25.1.0.tar.gz", hash = "sha256:694ae5cc8a42f4c4e2bf2ca0e64e51e23a040c6a517a85074683d3959e1346c1", size = 45706, upload-time = "2025-06-03T06:55:32.073Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4f/d3/a8b22fa575b297cd6e3e3b0155c7e25db170edf1c74783d6a31a2490b8d9/argon2_cffi-25.1.0-py3-none-any.whl", hash = "sha256:fdc8b074db390fccb6eb4a3604ae7231f219aa669a2652e0f20e16ba513d5741", size = 14657, upload-time = "2025-06-03T06:55:30.804Z" }, +] + +[[package]] +name = "argon2-cffi-bindings" +version = "21.2.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.14'", +] +dependencies = [ + { name = "cffi", marker = "python_full_version >= '3.14'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b9/e9/184b8ccce6683b0aa2fbb7ba5683ea4b9c5763f1356347f1312c32e3c66e/argon2-cffi-bindings-21.2.0.tar.gz", hash = "sha256:bb89ceffa6c791807d1305ceb77dbfacc5aa499891d2c55661c6459651fc39e3", size = 1779911, upload-time = "2021-12-01T08:52:55.68Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d4/13/838ce2620025e9666aa8f686431f67a29052241692a3dd1ae9d3692a89d3/argon2_cffi_bindings-21.2.0-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:ccb949252cb2ab3a08c02024acb77cfb179492d5701c7cbdbfd776124d4d2367", size = 29658, upload-time = "2021-12-01T09:09:17.016Z" }, + { url = "https://files.pythonhosted.org/packages/b3/02/f7f7bb6b6af6031edb11037639c697b912e1dea2db94d436e681aea2f495/argon2_cffi_bindings-21.2.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9524464572e12979364b7d600abf96181d3541da11e23ddf565a32e70bd4dc0d", size = 80583, upload-time = "2021-12-01T09:09:19.546Z" }, + { url = "https://files.pythonhosted.org/packages/ec/f7/378254e6dd7ae6f31fe40c8649eea7d4832a42243acaf0f1fff9083b2bed/argon2_cffi_bindings-21.2.0-cp36-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b746dba803a79238e925d9046a63aa26bf86ab2a2fe74ce6b009a1c3f5c8f2ae", size = 86168, upload-time = "2021-12-01T09:09:21.445Z" }, + { url = "https://files.pythonhosted.org/packages/74/f6/4a34a37a98311ed73bb80efe422fed95f2ac25a4cacc5ae1d7ae6a144505/argon2_cffi_bindings-21.2.0-cp36-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:58ed19212051f49a523abb1dbe954337dc82d947fb6e5a0da60f7c8471a8476c", size = 82709, upload-time = "2021-12-01T09:09:18.182Z" }, + { url = "https://files.pythonhosted.org/packages/74/2b/73d767bfdaab25484f7e7901379d5f8793cccbb86c6e0cbc4c1b96f63896/argon2_cffi_bindings-21.2.0-cp36-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:bd46088725ef7f58b5a1ef7ca06647ebaf0eb4baff7d1d0d177c6cc8744abd86", size = 83613, upload-time = "2021-12-01T09:09:22.741Z" }, + { url = "https://files.pythonhosted.org/packages/4f/fd/37f86deef67ff57c76f137a67181949c2d408077e2e3dd70c6c42912c9bf/argon2_cffi_bindings-21.2.0-cp36-abi3-musllinux_1_1_i686.whl", hash = "sha256:8cd69c07dd875537a824deec19f978e0f2078fdda07fd5c42ac29668dda5f40f", size = 84583, upload-time = "2021-12-01T09:09:24.177Z" }, + { url = "https://files.pythonhosted.org/packages/6f/52/5a60085a3dae8fded8327a4f564223029f5f54b0cb0455a31131b5363a01/argon2_cffi_bindings-21.2.0-cp36-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:f1152ac548bd5b8bcecfb0b0371f082037e47128653df2e8ba6e914d384f3c3e", size = 88475, upload-time = "2021-12-01T09:09:26.673Z" }, + { url = "https://files.pythonhosted.org/packages/8b/95/143cd64feb24a15fa4b189a3e1e7efbaeeb00f39a51e99b26fc62fbacabd/argon2_cffi_bindings-21.2.0-cp36-abi3-win32.whl", hash = "sha256:603ca0aba86b1349b147cab91ae970c63118a0f30444d4bc80355937c950c082", size = 27698, upload-time = "2021-12-01T09:09:27.87Z" }, + { url = "https://files.pythonhosted.org/packages/37/2c/e34e47c7dee97ba6f01a6203e0383e15b60fb85d78ac9a15cd066f6fe28b/argon2_cffi_bindings-21.2.0-cp36-abi3-win_amd64.whl", hash = "sha256:b2ef1c30440dbbcba7a5dc3e319408b59676e2e039e2ae11a8775ecf482b192f", size = 30817, upload-time = "2021-12-01T09:09:30.267Z" }, + { url = "https://files.pythonhosted.org/packages/5a/e4/bf8034d25edaa495da3c8a3405627d2e35758e44ff6eaa7948092646fdcc/argon2_cffi_bindings-21.2.0-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:e415e3f62c8d124ee16018e491a009937f8cf7ebf5eb430ffc5de21b900dad93", size = 53104, upload-time = "2021-12-01T09:09:31.335Z" }, +] + +[[package]] +name = "argon2-cffi-bindings" +version = "25.1.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.14'", +] +dependencies = [ + { name = "cffi", marker = "python_full_version < '3.14'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/5c/2d/db8af0df73c1cf454f71b2bbe5e356b8c1f8041c979f505b3d3186e520a9/argon2_cffi_bindings-25.1.0.tar.gz", hash = "sha256:b957f3e6ea4d55d820e40ff76f450952807013d361a65d7f28acc0acbf29229d", size = 1783441, upload-time = "2025-07-30T10:02:05.147Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/60/97/3c0a35f46e52108d4707c44b95cfe2afcafc50800b5450c197454569b776/argon2_cffi_bindings-25.1.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:3d3f05610594151994ca9ccb3c771115bdb4daef161976a266f0dd8aa9996b8f", size = 54393, upload-time = "2025-07-30T10:01:40.97Z" }, + { url = "https://files.pythonhosted.org/packages/9d/f4/98bbd6ee89febd4f212696f13c03ca302b8552e7dbf9c8efa11ea4a388c3/argon2_cffi_bindings-25.1.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:8b8efee945193e667a396cbc7b4fb7d357297d6234d30a489905d96caabde56b", size = 29328, upload-time = "2025-07-30T10:01:41.916Z" }, + { url = "https://files.pythonhosted.org/packages/43/24/90a01c0ef12ac91a6be05969f29944643bc1e5e461155ae6559befa8f00b/argon2_cffi_bindings-25.1.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:3c6702abc36bf3ccba3f802b799505def420a1b7039862014a65db3205967f5a", size = 31269, upload-time = "2025-07-30T10:01:42.716Z" }, + { url = "https://files.pythonhosted.org/packages/d4/d3/942aa10782b2697eee7af5e12eeff5ebb325ccfb86dd8abda54174e377e4/argon2_cffi_bindings-25.1.0-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a1c70058c6ab1e352304ac7e3b52554daadacd8d453c1752e547c76e9c99ac44", size = 86558, upload-time = "2025-07-30T10:01:43.943Z" }, + { url = "https://files.pythonhosted.org/packages/0d/82/b484f702fec5536e71836fc2dbc8c5267b3f6e78d2d539b4eaa6f0db8bf8/argon2_cffi_bindings-25.1.0-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e2fd3bfbff3c5d74fef31a722f729bf93500910db650c925c2d6ef879a7e51cb", size = 92364, upload-time = "2025-07-30T10:01:44.887Z" }, + { url = "https://files.pythonhosted.org/packages/c9/c1/a606ff83b3f1735f3759ad0f2cd9e038a0ad11a3de3b6c673aa41c24bb7b/argon2_cffi_bindings-25.1.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c4f9665de60b1b0e99bcd6be4f17d90339698ce954cfd8d9cf4f91c995165a92", size = 85637, upload-time = "2025-07-30T10:01:46.225Z" }, + { url = "https://files.pythonhosted.org/packages/44/b4/678503f12aceb0262f84fa201f6027ed77d71c5019ae03b399b97caa2f19/argon2_cffi_bindings-25.1.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ba92837e4a9aa6a508c8d2d7883ed5a8f6c308c89a4790e1e447a220deb79a85", size = 91934, upload-time = "2025-07-30T10:01:47.203Z" }, + { url = "https://files.pythonhosted.org/packages/f0/c7/f36bd08ef9bd9f0a9cff9428406651f5937ce27b6c5b07b92d41f91ae541/argon2_cffi_bindings-25.1.0-cp314-cp314t-win32.whl", hash = "sha256:84a461d4d84ae1295871329b346a97f68eade8c53b6ed9a7ca2d7467f3c8ff6f", size = 28158, upload-time = "2025-07-30T10:01:48.341Z" }, + { url = "https://files.pythonhosted.org/packages/b3/80/0106a7448abb24a2c467bf7d527fe5413b7fdfa4ad6d6a96a43a62ef3988/argon2_cffi_bindings-25.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:b55aec3565b65f56455eebc9b9f34130440404f27fe21c3b375bf1ea4d8fbae6", size = 32597, upload-time = "2025-07-30T10:01:49.112Z" }, + { url = "https://files.pythonhosted.org/packages/05/b8/d663c9caea07e9180b2cb662772865230715cbd573ba3b5e81793d580316/argon2_cffi_bindings-25.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:87c33a52407e4c41f3b70a9c2d3f6056d88b10dad7695be708c5021673f55623", size = 28231, upload-time = "2025-07-30T10:01:49.92Z" }, + { url = "https://files.pythonhosted.org/packages/1d/57/96b8b9f93166147826da5f90376e784a10582dd39a393c99bb62cfcf52f0/argon2_cffi_bindings-25.1.0-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:aecba1723ae35330a008418a91ea6cfcedf6d31e5fbaa056a166462ff066d500", size = 54121, upload-time = "2025-07-30T10:01:50.815Z" }, + { url = "https://files.pythonhosted.org/packages/0a/08/a9bebdb2e0e602dde230bdde8021b29f71f7841bd54801bcfd514acb5dcf/argon2_cffi_bindings-25.1.0-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:2630b6240b495dfab90aebe159ff784d08ea999aa4b0d17efa734055a07d2f44", size = 29177, upload-time = "2025-07-30T10:01:51.681Z" }, + { url = "https://files.pythonhosted.org/packages/b6/02/d297943bcacf05e4f2a94ab6f462831dc20158614e5d067c35d4e63b9acb/argon2_cffi_bindings-25.1.0-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:7aef0c91e2c0fbca6fc68e7555aa60ef7008a739cbe045541e438373bc54d2b0", size = 31090, upload-time = "2025-07-30T10:01:53.184Z" }, + { url = "https://files.pythonhosted.org/packages/c1/93/44365f3d75053e53893ec6d733e4a5e3147502663554b4d864587c7828a7/argon2_cffi_bindings-25.1.0-cp39-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1e021e87faa76ae0d413b619fe2b65ab9a037f24c60a1e6cc43457ae20de6dc6", size = 81246, upload-time = "2025-07-30T10:01:54.145Z" }, + { url = "https://files.pythonhosted.org/packages/09/52/94108adfdd6e2ddf58be64f959a0b9c7d4ef2fa71086c38356d22dc501ea/argon2_cffi_bindings-25.1.0-cp39-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d3e924cfc503018a714f94a49a149fdc0b644eaead5d1f089330399134fa028a", size = 87126, upload-time = "2025-07-30T10:01:55.074Z" }, + { url = "https://files.pythonhosted.org/packages/72/70/7a2993a12b0ffa2a9271259b79cc616e2389ed1a4d93842fac5a1f923ffd/argon2_cffi_bindings-25.1.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:c87b72589133f0346a1cb8d5ecca4b933e3c9b64656c9d175270a000e73b288d", size = 80343, upload-time = "2025-07-30T10:01:56.007Z" }, + { url = "https://files.pythonhosted.org/packages/78/9a/4e5157d893ffc712b74dbd868c7f62365618266982b64accab26bab01edc/argon2_cffi_bindings-25.1.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:1db89609c06afa1a214a69a462ea741cf735b29a57530478c06eb81dd403de99", size = 86777, upload-time = "2025-07-30T10:01:56.943Z" }, + { url = "https://files.pythonhosted.org/packages/74/cd/15777dfde1c29d96de7f18edf4cc94c385646852e7c7b0320aa91ccca583/argon2_cffi_bindings-25.1.0-cp39-abi3-win32.whl", hash = "sha256:473bcb5f82924b1becbb637b63303ec8d10e84c8d241119419897a26116515d2", size = 27180, upload-time = "2025-07-30T10:01:57.759Z" }, + { url = "https://files.pythonhosted.org/packages/e2/c6/a759ece8f1829d1f162261226fbfd2c6832b3ff7657384045286d2afa384/argon2_cffi_bindings-25.1.0-cp39-abi3-win_amd64.whl", hash = "sha256:a98cd7d17e9f7ce244c0803cad3c23a7d379c301ba618a5fa76a67d116618b98", size = 31715, upload-time = "2025-07-30T10:01:58.56Z" }, + { url = "https://files.pythonhosted.org/packages/42/b9/f8d6fa329ab25128b7e98fd83a3cb34d9db5b059a9847eddb840a0af45dd/argon2_cffi_bindings-25.1.0-cp39-abi3-win_arm64.whl", hash = "sha256:b0fdbcf513833809c882823f98dc2f931cf659d9a1429616ac3adebb49f5db94", size = 27149, upload-time = "2025-07-30T10:01:59.329Z" }, +] + +[[package]] +name = "arrow" +version = "1.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "python-dateutil" }, + { name = "types-python-dateutil" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/2e/00/0f6e8fcdb23ea632c866620cc872729ff43ed91d284c866b515c6342b173/arrow-1.3.0.tar.gz", hash = "sha256:d4540617648cb5f895730f1ad8c82a65f2dad0166f57b75f3ca54759c4d67a85", size = 131960, upload-time = "2023-09-30T22:11:18.25Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f8/ed/e97229a566617f2ae958a6b13e7cc0f585470eac730a73e9e82c32a3cdd2/arrow-1.3.0-py3-none-any.whl", hash = "sha256:c728b120ebc00eb84e01882a6f5e7927a53960aa990ce7dd2b10f39005a67f80", size = 66419, upload-time = "2023-09-30T22:11:16.072Z" }, +] + +[[package]] +name = "asttokens" +version = "3.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4a/e7/82da0a03e7ba5141f05cce0d302e6eed121ae055e0456ca228bf693984bc/asttokens-3.0.0.tar.gz", hash = "sha256:0dcd8baa8d62b0c1d118b399b2ddba3c4aff271d0d7a9e0d4c1681c79035bbc7", size = 61978, upload-time = "2024-11-30T04:30:14.439Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/25/8a/c46dcc25341b5bce5472c718902eb3d38600a903b14fa6aeecef3f21a46f/asttokens-3.0.0-py3-none-any.whl", hash = "sha256:e3078351a059199dd5138cb1c706e6430c05eff2ff136af5eb4790f9d28932e2", size = 26918, upload-time = "2024-11-30T04:30:10.946Z" }, +] + +[[package]] +name = "async-lru" +version = "2.0.5" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b2/4d/71ec4d3939dc755264f680f6c2b4906423a304c3d18e96853f0a595dfe97/async_lru-2.0.5.tar.gz", hash = "sha256:481d52ccdd27275f42c43a928b4a50c3bfb2d67af4e78b170e3e0bb39c66e5bb", size = 10380, upload-time = "2025-03-16T17:25:36.919Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/03/49/d10027df9fce941cb8184e78a02857af36360d33e1721df81c5ed2179a1a/async_lru-2.0.5-py3-none-any.whl", hash = "sha256:ab95404d8d2605310d345932697371a5f40def0487c03d6d0ad9138de52c9943", size = 6069, upload-time = "2025-03-16T17:25:35.422Z" }, +] + +[[package]] +name = "attrs" +version = "25.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5a/b0/1367933a8532ee6ff8d63537de4f1177af4bff9f3e829baf7331f595bb24/attrs-25.3.0.tar.gz", hash = "sha256:75d7cefc7fb576747b2c81b4442d4d4a1ce0900973527c011d1030fd3bf4af1b", size = 812032, upload-time = "2025-03-13T11:10:22.779Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/77/06/bb80f5f86020c4551da315d78b3ab75e8228f89f0162f2c3a819e407941a/attrs-25.3.0-py3-none-any.whl", hash = "sha256:427318ce031701fea540783410126f03899a97ffc6f61596ad581ac2e40e3bc3", size = 63815, upload-time = "2025-03-13T11:10:21.14Z" }, +] + +[[package]] +name = "babel" +version = "2.17.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7d/6b/d52e42361e1aa00709585ecc30b3f9684b3ab62530771402248b1b1d6240/babel-2.17.0.tar.gz", hash = "sha256:0c54cffb19f690cdcc52a3b50bcbf71e07a808d1c80d549f2459b9d2cf0afb9d", size = 9951852, upload-time = "2025-02-01T15:17:41.026Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/b8/3fe70c75fe32afc4bb507f75563d39bc5642255d1d94f1f23604725780bf/babel-2.17.0-py3-none-any.whl", hash = "sha256:4d0b53093fdfb4b21c92b5213dba5a1b23885afa8383709427046b21c366e5f2", size = 10182537, upload-time = "2025-02-01T15:17:37.39Z" }, +] + +[[package]] +name = "beautifulsoup4" +version = "4.13.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "soupsieve" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/d8/e4/0c4c39e18fd76d6a628d4dd8da40543d136ce2d1752bd6eeeab0791f4d6b/beautifulsoup4-4.13.4.tar.gz", hash = "sha256:dbb3c4e1ceae6aefebdaf2423247260cd062430a410e38c66f2baa50a8437195", size = 621067, upload-time = "2025-04-15T17:05:13.836Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/50/cd/30110dc0ffcf3b131156077b90e9f60ed75711223f306da4db08eff8403b/beautifulsoup4-4.13.4-py3-none-any.whl", hash = "sha256:9bbbb14bfde9d79f38b8cd5f8c7c85f4b8f2523190ebed90e950a8dea4cb1c4b", size = 187285, upload-time = "2025-04-15T17:05:12.221Z" }, +] + +[[package]] +name = "bleach" +version = "6.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "webencodings" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/76/9a/0e33f5054c54d349ea62c277191c020c2d6ef1d65ab2cb1993f91ec846d1/bleach-6.2.0.tar.gz", hash = "sha256:123e894118b8a599fd80d3ec1a6d4cc7ce4e5882b1317a7e1ba69b56e95f991f", size = 203083, upload-time = "2024-10-29T18:30:40.477Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fc/55/96142937f66150805c25c4d0f31ee4132fd33497753400734f9dfdcbdc66/bleach-6.2.0-py3-none-any.whl", hash = "sha256:117d9c6097a7c3d22fd578fcd8d35ff1e125df6736f554da4e432fdd63f31e5e", size = 163406, upload-time = "2024-10-29T18:30:38.186Z" }, +] + +[package.optional-dependencies] +css = [ + { name = "tinycss2" }, +] + +[[package]] +name = "certifi" +version = "2025.7.14" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b3/76/52c535bcebe74590f296d6c77c86dabf761c41980e1347a2422e4aa2ae41/certifi-2025.7.14.tar.gz", hash = "sha256:8ea99dbdfaaf2ba2f9bac77b9249ef62ec5218e7c2b2e903378ed5fccf765995", size = 163981, upload-time = "2025-07-14T03:29:28.449Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4f/52/34c6cf5bb9285074dc3531c437b3919e825d976fde097a7a73f79e726d03/certifi-2025.7.14-py3-none-any.whl", hash = "sha256:6b31f564a415d79ee77df69d757bb49a5bb53bd9f756cbbe24394ffd6fc1f4b2", size = 162722, upload-time = "2025-07-14T03:29:26.863Z" }, +] + +[[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/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" }, +] + +[[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/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/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 = "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 = "comm" +version = "0.2.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4c/13/7d740c5849255756bc17888787313b61fd38a0a8304fc4f073dfc46122aa/comm-0.2.3.tar.gz", hash = "sha256:2dc8048c10962d55d7ad693be1e7045d891b7ce8d999c97963a5e3e99c055971", size = 6319, upload-time = "2025-07-25T14:02:04.452Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/60/97/891a0971e1e4a8c5d2b20bbe0e524dc04548d2307fee33cdeba148fd4fc7/comm-0.2.3-py3-none-any.whl", hash = "sha256:c615d91d75f7f04f095b30d1c1711babd43bdc6419c1be9886a85f2f4e489417", size = 7294, upload-time = "2025-07-25T14:02:02.896Z" }, +] + +[[package]] +name = "contourpy" +version = "1.3.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/58/01/1253e6698a07380cd31a736d248a3f2a50a7c88779a1813da27503cadc2a/contourpy-1.3.3.tar.gz", hash = "sha256:083e12155b210502d0bca491432bb04d56dc3432f95a979b429f2848c3dbe880", size = 13466174, upload-time = "2025-07-26T12:03:12.549Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/be/45/adfee365d9ea3d853550b2e735f9d66366701c65db7855cd07621732ccfc/contourpy-1.3.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b08a32ea2f8e42cf1d4be3169a98dd4be32bafe4f22b6c4cb4ba810fa9e5d2cb", size = 293419, upload-time = "2025-07-26T12:01:21.16Z" }, + { url = "https://files.pythonhosted.org/packages/53/3e/405b59cfa13021a56bba395a6b3aca8cec012b45bf177b0eaf7a202cde2c/contourpy-1.3.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:556dba8fb6f5d8742f2923fe9457dbdd51e1049c4a43fd3986a0b14a1d815fc6", size = 273979, upload-time = "2025-07-26T12:01:22.448Z" }, + { url = "https://files.pythonhosted.org/packages/d4/1c/a12359b9b2ca3a845e8f7f9ac08bdf776114eb931392fcad91743e2ea17b/contourpy-1.3.3-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92d9abc807cf7d0e047b95ca5d957cf4792fcd04e920ca70d48add15c1a90ea7", size = 332653, upload-time = "2025-07-26T12:01:24.155Z" }, + { url = "https://files.pythonhosted.org/packages/63/12/897aeebfb475b7748ea67b61e045accdfcf0d971f8a588b67108ed7f5512/contourpy-1.3.3-cp312-cp312-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b2e8faa0ed68cb29af51edd8e24798bb661eac3bd9f65420c1887b6ca89987c8", size = 379536, upload-time = "2025-07-26T12:01:25.91Z" }, + { url = "https://files.pythonhosted.org/packages/43/8a/a8c584b82deb248930ce069e71576fc09bd7174bbd35183b7943fb1064fd/contourpy-1.3.3-cp312-cp312-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:626d60935cf668e70a5ce6ff184fd713e9683fb458898e4249b63be9e28286ea", size = 384397, upload-time = "2025-07-26T12:01:27.152Z" }, + { url = "https://files.pythonhosted.org/packages/cc/8f/ec6289987824b29529d0dfda0d74a07cec60e54b9c92f3c9da4c0ac732de/contourpy-1.3.3-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4d00e655fcef08aba35ec9610536bfe90267d7ab5ba944f7032549c55a146da1", size = 362601, upload-time = "2025-07-26T12:01:28.808Z" }, + { url = "https://files.pythonhosted.org/packages/05/0a/a3fe3be3ee2dceb3e615ebb4df97ae6f3828aa915d3e10549ce016302bd1/contourpy-1.3.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:451e71b5a7d597379ef572de31eeb909a87246974d960049a9848c3bc6c41bf7", size = 1331288, upload-time = "2025-07-26T12:01:31.198Z" }, + { url = "https://files.pythonhosted.org/packages/33/1d/acad9bd4e97f13f3e2b18a3977fe1b4a37ecf3d38d815333980c6c72e963/contourpy-1.3.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:459c1f020cd59fcfe6650180678a9993932d80d44ccde1fa1868977438f0b411", size = 1403386, upload-time = "2025-07-26T12:01:33.947Z" }, + { url = "https://files.pythonhosted.org/packages/cf/8f/5847f44a7fddf859704217a99a23a4f6417b10e5ab1256a179264561540e/contourpy-1.3.3-cp312-cp312-win32.whl", hash = "sha256:023b44101dfe49d7d53932be418477dba359649246075c996866106da069af69", size = 185018, upload-time = "2025-07-26T12:01:35.64Z" }, + { url = "https://files.pythonhosted.org/packages/19/e8/6026ed58a64563186a9ee3f29f41261fd1828f527dd93d33b60feca63352/contourpy-1.3.3-cp312-cp312-win_amd64.whl", hash = "sha256:8153b8bfc11e1e4d75bcb0bff1db232f9e10b274e0929de9d608027e0d34ff8b", size = 226567, upload-time = "2025-07-26T12:01:36.804Z" }, + { url = "https://files.pythonhosted.org/packages/d1/e2/f05240d2c39a1ed228d8328a78b6f44cd695f7ef47beb3e684cf93604f86/contourpy-1.3.3-cp312-cp312-win_arm64.whl", hash = "sha256:07ce5ed73ecdc4a03ffe3e1b3e3c1166db35ae7584be76f65dbbe28a7791b0cc", size = 193655, upload-time = "2025-07-26T12:01:37.999Z" }, + { url = "https://files.pythonhosted.org/packages/68/35/0167aad910bbdb9599272bd96d01a9ec6852f36b9455cf2ca67bd4cc2d23/contourpy-1.3.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:177fb367556747a686509d6fef71d221a4b198a3905fe824430e5ea0fda54eb5", size = 293257, upload-time = "2025-07-26T12:01:39.367Z" }, + { url = "https://files.pythonhosted.org/packages/96/e4/7adcd9c8362745b2210728f209bfbcf7d91ba868a2c5f40d8b58f54c509b/contourpy-1.3.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d002b6f00d73d69333dac9d0b8d5e84d9724ff9ef044fd63c5986e62b7c9e1b1", size = 274034, upload-time = "2025-07-26T12:01:40.645Z" }, + { url = "https://files.pythonhosted.org/packages/73/23/90e31ceeed1de63058a02cb04b12f2de4b40e3bef5e082a7c18d9c8ae281/contourpy-1.3.3-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:348ac1f5d4f1d66d3322420f01d42e43122f43616e0f194fc1c9f5d830c5b286", size = 334672, upload-time = "2025-07-26T12:01:41.942Z" }, + { url = "https://files.pythonhosted.org/packages/ed/93/b43d8acbe67392e659e1d984700e79eb67e2acb2bd7f62012b583a7f1b55/contourpy-1.3.3-cp313-cp313-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:655456777ff65c2c548b7c454af9c6f33f16c8884f11083244b5819cc214f1b5", size = 381234, upload-time = "2025-07-26T12:01:43.499Z" }, + { url = "https://files.pythonhosted.org/packages/46/3b/bec82a3ea06f66711520f75a40c8fc0b113b2a75edb36aa633eb11c4f50f/contourpy-1.3.3-cp313-cp313-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:644a6853d15b2512d67881586bd03f462c7ab755db95f16f14d7e238f2852c67", size = 385169, upload-time = "2025-07-26T12:01:45.219Z" }, + { url = "https://files.pythonhosted.org/packages/4b/32/e0f13a1c5b0f8572d0ec6ae2f6c677b7991fafd95da523159c19eff0696a/contourpy-1.3.3-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4debd64f124ca62069f313a9cb86656ff087786016d76927ae2cf37846b006c9", size = 362859, upload-time = "2025-07-26T12:01:46.519Z" }, + { url = "https://files.pythonhosted.org/packages/33/71/e2a7945b7de4e58af42d708a219f3b2f4cff7386e6b6ab0a0fa0033c49a9/contourpy-1.3.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a15459b0f4615b00bbd1e91f1b9e19b7e63aea7483d03d804186f278c0af2659", size = 1332062, upload-time = "2025-07-26T12:01:48.964Z" }, + { url = "https://files.pythonhosted.org/packages/12/fc/4e87ac754220ccc0e807284f88e943d6d43b43843614f0a8afa469801db0/contourpy-1.3.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ca0fdcd73925568ca027e0b17ab07aad764be4706d0a925b89227e447d9737b7", size = 1403932, upload-time = "2025-07-26T12:01:51.979Z" }, + { url = "https://files.pythonhosted.org/packages/a6/2e/adc197a37443f934594112222ac1aa7dc9a98faf9c3842884df9a9d8751d/contourpy-1.3.3-cp313-cp313-win32.whl", hash = "sha256:b20c7c9a3bf701366556e1b1984ed2d0cedf999903c51311417cf5f591d8c78d", size = 185024, upload-time = "2025-07-26T12:01:53.245Z" }, + { url = "https://files.pythonhosted.org/packages/18/0b/0098c214843213759692cc638fce7de5c289200a830e5035d1791d7a2338/contourpy-1.3.3-cp313-cp313-win_amd64.whl", hash = "sha256:1cadd8b8969f060ba45ed7c1b714fe69185812ab43bd6b86a9123fe8f99c3263", size = 226578, upload-time = "2025-07-26T12:01:54.422Z" }, + { url = "https://files.pythonhosted.org/packages/8a/9a/2f6024a0c5995243cd63afdeb3651c984f0d2bc727fd98066d40e141ad73/contourpy-1.3.3-cp313-cp313-win_arm64.whl", hash = "sha256:fd914713266421b7536de2bfa8181aa8c699432b6763a0ea64195ebe28bff6a9", size = 193524, upload-time = "2025-07-26T12:01:55.73Z" }, + { url = "https://files.pythonhosted.org/packages/c0/b3/f8a1a86bd3298513f500e5b1f5fd92b69896449f6cab6a146a5d52715479/contourpy-1.3.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:88df9880d507169449d434c293467418b9f6cbe82edd19284aa0409e7fdb933d", size = 306730, upload-time = "2025-07-26T12:01:57.051Z" }, + { url = "https://files.pythonhosted.org/packages/3f/11/4780db94ae62fc0c2053909b65dc3246bd7cecfc4f8a20d957ad43aa4ad8/contourpy-1.3.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:d06bb1f751ba5d417047db62bca3c8fde202b8c11fb50742ab3ab962c81e8216", size = 287897, upload-time = "2025-07-26T12:01:58.663Z" }, + { url = "https://files.pythonhosted.org/packages/ae/15/e59f5f3ffdd6f3d4daa3e47114c53daabcb18574a26c21f03dc9e4e42ff0/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e4e6b05a45525357e382909a4c1600444e2a45b4795163d3b22669285591c1ae", size = 326751, upload-time = "2025-07-26T12:02:00.343Z" }, + { url = "https://files.pythonhosted.org/packages/0f/81/03b45cfad088e4770b1dcf72ea78d3802d04200009fb364d18a493857210/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ab3074b48c4e2cf1a960e6bbeb7f04566bf36b1861d5c9d4d8ac04b82e38ba20", size = 375486, upload-time = "2025-07-26T12:02:02.128Z" }, + { url = "https://files.pythonhosted.org/packages/0c/ba/49923366492ffbdd4486e970d421b289a670ae8cf539c1ea9a09822b371a/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6c3d53c796f8647d6deb1abe867daeb66dcc8a97e8455efa729516b997b8ed99", size = 388106, upload-time = "2025-07-26T12:02:03.615Z" }, + { url = "https://files.pythonhosted.org/packages/9f/52/5b00ea89525f8f143651f9f03a0df371d3cbd2fccd21ca9b768c7a6500c2/contourpy-1.3.3-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:50ed930df7289ff2a8d7afeb9603f8289e5704755c7e5c3bbd929c90c817164b", size = 352548, upload-time = "2025-07-26T12:02:05.165Z" }, + { url = "https://files.pythonhosted.org/packages/32/1d/a209ec1a3a3452d490f6b14dd92e72280c99ae3d1e73da74f8277d4ee08f/contourpy-1.3.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:4feffb6537d64b84877da813a5c30f1422ea5739566abf0bd18065ac040e120a", size = 1322297, upload-time = "2025-07-26T12:02:07.379Z" }, + { url = "https://files.pythonhosted.org/packages/bc/9e/46f0e8ebdd884ca0e8877e46a3f4e633f6c9c8c4f3f6e72be3fe075994aa/contourpy-1.3.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:2b7e9480ffe2b0cd2e787e4df64270e3a0440d9db8dc823312e2c940c167df7e", size = 1391023, upload-time = "2025-07-26T12:02:10.171Z" }, + { url = "https://files.pythonhosted.org/packages/b9/70/f308384a3ae9cd2209e0849f33c913f658d3326900d0ff5d378d6a1422d2/contourpy-1.3.3-cp313-cp313t-win32.whl", hash = "sha256:283edd842a01e3dcd435b1c5116798d661378d83d36d337b8dde1d16a5fc9ba3", size = 196157, upload-time = "2025-07-26T12:02:11.488Z" }, + { url = "https://files.pythonhosted.org/packages/b2/dd/880f890a6663b84d9e34a6f88cded89d78f0091e0045a284427cb6b18521/contourpy-1.3.3-cp313-cp313t-win_amd64.whl", hash = "sha256:87acf5963fc2b34825e5b6b048f40e3635dd547f590b04d2ab317c2619ef7ae8", size = 240570, upload-time = "2025-07-26T12:02:12.754Z" }, + { url = "https://files.pythonhosted.org/packages/80/99/2adc7d8ffead633234817ef8e9a87115c8a11927a94478f6bb3d3f4d4f7d/contourpy-1.3.3-cp313-cp313t-win_arm64.whl", hash = "sha256:3c30273eb2a55024ff31ba7d052dde990d7d8e5450f4bbb6e913558b3d6c2301", size = 199713, upload-time = "2025-07-26T12:02:14.4Z" }, + { url = "https://files.pythonhosted.org/packages/72/8b/4546f3ab60f78c514ffb7d01a0bd743f90de36f0019d1be84d0a708a580a/contourpy-1.3.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fde6c716d51c04b1c25d0b90364d0be954624a0ee9d60e23e850e8d48353d07a", size = 292189, upload-time = "2025-07-26T12:02:16.095Z" }, + { url = "https://files.pythonhosted.org/packages/fd/e1/3542a9cb596cadd76fcef413f19c79216e002623158befe6daa03dbfa88c/contourpy-1.3.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:cbedb772ed74ff5be440fa8eee9bd49f64f6e3fc09436d9c7d8f1c287b121d77", size = 273251, upload-time = "2025-07-26T12:02:17.524Z" }, + { url = "https://files.pythonhosted.org/packages/b1/71/f93e1e9471d189f79d0ce2497007731c1e6bf9ef6d1d61b911430c3db4e5/contourpy-1.3.3-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:22e9b1bd7a9b1d652cd77388465dc358dafcd2e217d35552424aa4f996f524f5", size = 335810, upload-time = "2025-07-26T12:02:18.9Z" }, + { url = "https://files.pythonhosted.org/packages/91/f9/e35f4c1c93f9275d4e38681a80506b5510e9327350c51f8d4a5a724d178c/contourpy-1.3.3-cp314-cp314-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a22738912262aa3e254e4f3cb079a95a67132fc5a063890e224393596902f5a4", size = 382871, upload-time = "2025-07-26T12:02:20.418Z" }, + { url = "https://files.pythonhosted.org/packages/b5/71/47b512f936f66a0a900d81c396a7e60d73419868fba959c61efed7a8ab46/contourpy-1.3.3-cp314-cp314-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:afe5a512f31ee6bd7d0dda52ec9864c984ca3d66664444f2d72e0dc4eb832e36", size = 386264, upload-time = "2025-07-26T12:02:21.916Z" }, + { url = "https://files.pythonhosted.org/packages/04/5f/9ff93450ba96b09c7c2b3f81c94de31c89f92292f1380261bd7195bea4ea/contourpy-1.3.3-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f64836de09927cba6f79dcd00fdd7d5329f3fccc633468507079c829ca4db4e3", size = 363819, upload-time = "2025-07-26T12:02:23.759Z" }, + { url = "https://files.pythonhosted.org/packages/3e/a6/0b185d4cc480ee494945cde102cb0149ae830b5fa17bf855b95f2e70ad13/contourpy-1.3.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:1fd43c3be4c8e5fd6e4f2baeae35ae18176cf2e5cced681cca908addf1cdd53b", size = 1333650, upload-time = "2025-07-26T12:02:26.181Z" }, + { url = "https://files.pythonhosted.org/packages/43/d7/afdc95580ca56f30fbcd3060250f66cedbde69b4547028863abd8aa3b47e/contourpy-1.3.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:6afc576f7b33cf00996e5c1102dc2a8f7cc89e39c0b55df93a0b78c1bd992b36", size = 1404833, upload-time = "2025-07-26T12:02:28.782Z" }, + { url = "https://files.pythonhosted.org/packages/e2/e2/366af18a6d386f41132a48f033cbd2102e9b0cf6345d35ff0826cd984566/contourpy-1.3.3-cp314-cp314-win32.whl", hash = "sha256:66c8a43a4f7b8df8b71ee1840e4211a3c8d93b214b213f590e18a1beca458f7d", size = 189692, upload-time = "2025-07-26T12:02:30.128Z" }, + { url = "https://files.pythonhosted.org/packages/7d/c2/57f54b03d0f22d4044b8afb9ca0e184f8b1afd57b4f735c2fa70883dc601/contourpy-1.3.3-cp314-cp314-win_amd64.whl", hash = "sha256:cf9022ef053f2694e31d630feaacb21ea24224be1c3ad0520b13d844274614fd", size = 232424, upload-time = "2025-07-26T12:02:31.395Z" }, + { url = "https://files.pythonhosted.org/packages/18/79/a9416650df9b525737ab521aa181ccc42d56016d2123ddcb7b58e926a42c/contourpy-1.3.3-cp314-cp314-win_arm64.whl", hash = "sha256:95b181891b4c71de4bb404c6621e7e2390745f887f2a026b2d99e92c17892339", size = 198300, upload-time = "2025-07-26T12:02:32.956Z" }, + { url = "https://files.pythonhosted.org/packages/1f/42/38c159a7d0f2b7b9c04c64ab317042bb6952b713ba875c1681529a2932fe/contourpy-1.3.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:33c82d0138c0a062380332c861387650c82e4cf1747aaa6938b9b6516762e772", size = 306769, upload-time = "2025-07-26T12:02:34.2Z" }, + { url = "https://files.pythonhosted.org/packages/c3/6c/26a8205f24bca10974e77460de68d3d7c63e282e23782f1239f226fcae6f/contourpy-1.3.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ea37e7b45949df430fe649e5de8351c423430046a2af20b1c1961cae3afcda77", size = 287892, upload-time = "2025-07-26T12:02:35.807Z" }, + { url = "https://files.pythonhosted.org/packages/66/06/8a475c8ab718ebfd7925661747dbb3c3ee9c82ac834ccb3570be49d129f4/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d304906ecc71672e9c89e87c4675dc5c2645e1f4269a5063b99b0bb29f232d13", size = 326748, upload-time = "2025-07-26T12:02:37.193Z" }, + { url = "https://files.pythonhosted.org/packages/b4/a3/c5ca9f010a44c223f098fccd8b158bb1cb287378a31ac141f04730dc49be/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ca658cd1a680a5c9ea96dc61cdbae1e85c8f25849843aa799dfd3cb370ad4fbe", size = 375554, upload-time = "2025-07-26T12:02:38.894Z" }, + { url = "https://files.pythonhosted.org/packages/80/5b/68bd33ae63fac658a4145088c1e894405e07584a316738710b636c6d0333/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ab2fd90904c503739a75b7c8c5c01160130ba67944a7b77bbf36ef8054576e7f", size = 388118, upload-time = "2025-07-26T12:02:40.642Z" }, + { url = "https://files.pythonhosted.org/packages/40/52/4c285a6435940ae25d7410a6c36bda5145839bc3f0beb20c707cda18b9d2/contourpy-1.3.3-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b7301b89040075c30e5768810bc96a8e8d78085b47d8be6e4c3f5a0b4ed478a0", size = 352555, upload-time = "2025-07-26T12:02:42.25Z" }, + { url = "https://files.pythonhosted.org/packages/24/ee/3e81e1dd174f5c7fefe50e85d0892de05ca4e26ef1c9a59c2a57e43b865a/contourpy-1.3.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:2a2a8b627d5cc6b7c41a4beff6c5ad5eb848c88255fda4a8745f7e901b32d8e4", size = 1322295, upload-time = "2025-07-26T12:02:44.668Z" }, + { url = "https://files.pythonhosted.org/packages/3c/b2/6d913d4d04e14379de429057cd169e5e00f6c2af3bb13e1710bcbdb5da12/contourpy-1.3.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:fd6ec6be509c787f1caf6b247f0b1ca598bef13f4ddeaa126b7658215529ba0f", size = 1391027, upload-time = "2025-07-26T12:02:47.09Z" }, + { url = "https://files.pythonhosted.org/packages/93/8a/68a4ec5c55a2971213d29a9374913f7e9f18581945a7a31d1a39b5d2dfe5/contourpy-1.3.3-cp314-cp314t-win32.whl", hash = "sha256:e74a9a0f5e3fff48fb5a7f2fd2b9b70a3fe014a67522f79b7cca4c0c7e43c9ae", size = 202428, upload-time = "2025-07-26T12:02:48.691Z" }, + { url = "https://files.pythonhosted.org/packages/fa/96/fd9f641ffedc4fa3ace923af73b9d07e869496c9cc7a459103e6e978992f/contourpy-1.3.3-cp314-cp314t-win_amd64.whl", hash = "sha256:13b68d6a62db8eafaebb8039218921399baf6e47bf85006fd8529f2a08ef33fc", size = 250331, upload-time = "2025-07-26T12:02:50.137Z" }, + { url = "https://files.pythonhosted.org/packages/ae/8c/469afb6465b853afff216f9528ffda78a915ff880ed58813ba4faf4ba0b6/contourpy-1.3.3-cp314-cp314t-win_arm64.whl", hash = "sha256:b7448cb5a725bb1e35ce88771b86fba35ef418952474492cf7c764059933ff8b", size = 203831, upload-time = "2025-07-26T12:02:51.449Z" }, +] + +[[package]] +name = "cycler" +version = "0.12.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a9/95/a3dbbb5028f35eafb79008e7522a75244477d2838f38cbb722248dabc2a8/cycler-0.12.1.tar.gz", hash = "sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c", size = 7615, upload-time = "2023-10-07T05:32:18.335Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/05/c19819d5e3d95294a6f5947fb9b9629efb316b96de511b418c53d245aae6/cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30", size = 8321, upload-time = "2023-10-07T05:32:16.783Z" }, +] + +[[package]] +name = "debugpy" +version = "1.8.16" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ca/d4/722d0bcc7986172ac2ef3c979ad56a1030e3afd44ced136d45f8142b1f4a/debugpy-1.8.16.tar.gz", hash = "sha256:31e69a1feb1cf6b51efbed3f6c9b0ef03bc46ff050679c4be7ea6d2e23540870", size = 1643809, upload-time = "2025-08-06T18:00:02.647Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/61/fb/0387c0e108d842c902801bc65ccc53e5b91d8c169702a9bbf4f7efcedf0c/debugpy-1.8.16-cp312-cp312-macosx_14_0_universal2.whl", hash = "sha256:b202e2843e32e80b3b584bcebfe0e65e0392920dc70df11b2bfe1afcb7a085e4", size = 2511822, upload-time = "2025-08-06T18:00:18.526Z" }, + { url = "https://files.pythonhosted.org/packages/37/44/19e02745cae22bf96440141f94e15a69a1afaa3a64ddfc38004668fcdebf/debugpy-1.8.16-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:64473c4a306ba11a99fe0bb14622ba4fbd943eb004847d9b69b107bde45aa9ea", size = 4230135, upload-time = "2025-08-06T18:00:19.997Z" }, + { url = "https://files.pythonhosted.org/packages/f3/0b/19b1ba5ee4412f303475a2c7ad5858efb99c90eae5ec627aa6275c439957/debugpy-1.8.16-cp312-cp312-win32.whl", hash = "sha256:833a61ed446426e38b0dd8be3e9d45ae285d424f5bf6cd5b2b559c8f12305508", size = 5281271, upload-time = "2025-08-06T18:00:21.281Z" }, + { url = "https://files.pythonhosted.org/packages/b1/e0/bc62e2dc141de53bd03e2c7cb9d7011de2e65e8bdcdaa26703e4d28656ba/debugpy-1.8.16-cp312-cp312-win_amd64.whl", hash = "sha256:75f204684581e9ef3dc2f67687c3c8c183fde2d6675ab131d94084baf8084121", size = 5323149, upload-time = "2025-08-06T18:00:23.033Z" }, + { url = "https://files.pythonhosted.org/packages/62/66/607ab45cc79e60624df386e233ab64a6d8d39ea02e7f80e19c1d451345bb/debugpy-1.8.16-cp313-cp313-macosx_14_0_universal2.whl", hash = "sha256:85df3adb1de5258dca910ae0bb185e48c98801ec15018a263a92bb06be1c8787", size = 2496157, upload-time = "2025-08-06T18:00:24.361Z" }, + { url = "https://files.pythonhosted.org/packages/4d/a0/c95baae08a75bceabb79868d663a0736655e427ab9c81fb848da29edaeac/debugpy-1.8.16-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bee89e948bc236a5c43c4214ac62d28b29388453f5fd328d739035e205365f0b", size = 4222491, upload-time = "2025-08-06T18:00:25.806Z" }, + { url = "https://files.pythonhosted.org/packages/5b/2f/1c8db6ddd8a257c3cd2c46413b267f1d5fa3df910401c899513ce30392d6/debugpy-1.8.16-cp313-cp313-win32.whl", hash = "sha256:cf358066650439847ec5ff3dae1da98b5461ea5da0173d93d5e10f477c94609a", size = 5281126, upload-time = "2025-08-06T18:00:27.207Z" }, + { url = "https://files.pythonhosted.org/packages/d3/ba/c3e154ab307366d6c5a9c1b68de04914e2ce7fa2f50d578311d8cc5074b2/debugpy-1.8.16-cp313-cp313-win_amd64.whl", hash = "sha256:b5aea1083f6f50023e8509399d7dc6535a351cc9f2e8827d1e093175e4d9fa4c", size = 5323094, upload-time = "2025-08-06T18:00:29.03Z" }, + { url = "https://files.pythonhosted.org/packages/52/57/ecc9ae29fa5b2d90107cd1d9bf8ed19aacb74b2264d986ae9d44fe9bdf87/debugpy-1.8.16-py2.py3-none-any.whl", hash = "sha256:19c9521962475b87da6f673514f7fd610328757ec993bf7ec0d8c96f9a325f9e", size = 5287700, upload-time = "2025-08-06T18:00:42.333Z" }, +] + +[[package]] +name = "decorator" +version = "5.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/43/fa/6d96a0978d19e17b68d634497769987b16c8f4cd0a7a05048bec693caa6b/decorator-5.2.1.tar.gz", hash = "sha256:65f266143752f734b0a7cc83c46f4618af75b8c5911b00ccb61d0ac9b6da0360", size = 56711, upload-time = "2025-02-24T04:41:34.073Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4e/8c/f3147f5c4b73e7550fe5f9352eaa956ae838d5c51eb58e7a25b9f3e2643b/decorator-5.2.1-py3-none-any.whl", hash = "sha256:d316bb415a2d9e2d2b3abcc4084c6502fc09240e292cd76a76afc106a1c8e04a", size = 9190, upload-time = "2025-02-24T04:41:32.565Z" }, +] + +[[package]] +name = "defusedxml" +version = "0.7.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0f/d5/c66da9b79e5bdb124974bfe172b4daf3c984ebd9c2a06e2b8a4dc7331c72/defusedxml-0.7.1.tar.gz", hash = "sha256:1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69", size = 75520, upload-time = "2021-03-08T10:59:26.269Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/07/6c/aa3f2f849e01cb6a001cd8554a88d4c77c5c1a31c95bdf1cf9301e6d9ef4/defusedxml-0.7.1-py2.py3-none-any.whl", hash = "sha256:a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61", size = 25604, upload-time = "2021-03-08T10:59:24.45Z" }, +] + +[[package]] +name = "distro" +version = "1.9.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/fc/f8/98eea607f65de6527f8a2e8885fc8015d3e6f5775df186e443e0964a11c3/distro-1.9.0.tar.gz", hash = "sha256:2fa77c6fd8940f116ee1d6b94a2f90b13b5ea8d019b98bc8bafdcabcdd9bdbed", size = 60722, upload-time = "2023-12-24T09:54:32.31Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/12/b3/231ffd4ab1fc9d679809f356cebee130ac7daa00d6d6f3206dd4fd137e9e/distro-1.9.0-py3-none-any.whl", hash = "sha256:7bffd925d65168f85027d8da9af6bddab658135b840670a223589bc0c8ef02b2", size = 20277, upload-time = "2023-12-24T09:54:30.421Z" }, +] + +[[package]] +name = "et-xmlfile" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d3/38/af70d7ab1ae9d4da450eeec1fa3918940a5fafb9055e934af8d6eb0c2313/et_xmlfile-2.0.0.tar.gz", hash = "sha256:dab3f4764309081ce75662649be815c4c9081e88f0837825f90fd28317d4da54", size = 17234, upload-time = "2024-10-25T17:25:40.039Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c1/8b/5fe2cc11fee489817272089c4203e679c63b570a5aaeb18d852ae3cbba6a/et_xmlfile-2.0.0-py3-none-any.whl", hash = "sha256:7a91720bc756843502c3b7504c77b8fe44217c85c537d85037f0f536151b2caa", size = 18059, upload-time = "2024-10-25T17:25:39.051Z" }, +] + +[[package]] +name = "executing" +version = "2.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/91/50/a9d80c47ff289c611ff12e63f7c5d13942c65d68125160cefd768c73e6e4/executing-2.2.0.tar.gz", hash = "sha256:5d108c028108fe2551d1a7b2e8b713341e2cb4fc0aa7dcf966fa4327a5226755", size = 978693, upload-time = "2025-01-22T15:41:29.403Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7b/8f/c4d9bafc34ad7ad5d8dc16dd1347ee0e507a52c3adb6bfa8887e1c6a26ba/executing-2.2.0-py2.py3-none-any.whl", hash = "sha256:11387150cad388d62750327a53d3339fad4888b39a6fe233c3afbb54ecffd3aa", size = 26702, upload-time = "2025-01-22T15:41:25.929Z" }, +] + +[[package]] +name = "faiss-cpu" +version = "1.11.0.post1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, + { name = "packaging" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/5c/f4/7c2136f4660ca504266cc08b38df2aa1db14fea93393b82e099ff34d7290/faiss_cpu-1.11.0.post1.tar.gz", hash = "sha256:06b1ea9ddec9e4d9a41c8ef7478d493b08d770e9a89475056e963081eed757d1", size = 70543, upload-time = "2025-07-15T09:15:02.127Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/30/1e/9980758efa55b4e7a5d6df1ae17c9ddbe5a636bfbf7d22d47c67f7a530f4/faiss_cpu-1.11.0.post1-cp312-cp312-macosx_13_0_x86_64.whl", hash = "sha256:68f6ce2d9c510a5765af2f5711bd76c2c37bd598af747f3300224bdccf45378c", size = 7913676, upload-time = "2025-07-15T09:14:06.077Z" }, + { url = "https://files.pythonhosted.org/packages/05/d1/bd785887085faa02916c52320527b8bb54288835b0a3138df89a0e323cc8/faiss_cpu-1.11.0.post1-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:b940c530a8236cc0b9fd9d6e87b3d70b9c6c216bc2baf2649356c908902e52c9", size = 3313952, upload-time = "2025-07-15T09:14:07.584Z" }, + { url = "https://files.pythonhosted.org/packages/89/13/d62ee83c5a0db24e9c4fc0a446949f9c8feca18659f4c17caca6c3d02867/faiss_cpu-1.11.0.post1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fafae1dcbcba3856a0bb82ffb0c3cae5922bdd6566fdd3b7feb2425cf4fca247", size = 3785328, upload-time = "2025-07-15T09:14:09.397Z" }, + { url = "https://files.pythonhosted.org/packages/db/a9/acfdd5bd63eff99188d0587fa6de4c30092ce952a1c7229e2fd5c84499d4/faiss_cpu-1.11.0.post1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5d1262702c19aba2d23144b73f4b5730ca988c1f4e43ecec87edf25171cafe3d", size = 31287778, upload-time = "2025-07-15T09:14:11.252Z" }, + { url = "https://files.pythonhosted.org/packages/88/96/195aecb139db223824a6b2faf647fbe622732659c100cdeca172679cc621/faiss_cpu-1.11.0.post1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:925feb69c06bfcc7f28869c99ab172f123e4b9d97a7e1353316fcc2748696f5b", size = 9714469, upload-time = "2025-07-15T09:14:18.497Z" }, + { url = "https://files.pythonhosted.org/packages/ca/0c/483d5233c41f753da6710e7026c0f7963649f6ecd1877d63c88cb204c8dc/faiss_cpu-1.11.0.post1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:00a837581b675f099c80c8c46908648dcf944a8992dd21e3887c61c6b110fe5f", size = 24012806, upload-time = "2025-07-15T09:14:20.679Z" }, + { url = "https://files.pythonhosted.org/packages/1c/17/4384518de0c58f49e4483c6dfdd1bc54540c9d0d71ccfcc87f6b52adfcb9/faiss_cpu-1.11.0.post1-cp312-cp312-win_amd64.whl", hash = "sha256:8bbaef5b56d1b0c01357ee6449d464ea4e52732fdb53a40bb5b9d77923af905f", size = 14882869, upload-time = "2025-07-15T09:14:23.195Z" }, + { url = "https://files.pythonhosted.org/packages/56/64/ec3823d4703fa704c5e8821a5990fd0485e024d80d813231df0c65b3e18f/faiss_cpu-1.11.0.post1-cp312-cp312-win_arm64.whl", hash = "sha256:57f85dbefe590f8399a95c07e839ee64373cfcc6db5dd35232a41137e3deefeb", size = 7852194, upload-time = "2025-07-15T09:14:25.501Z" }, + { url = "https://files.pythonhosted.org/packages/ef/c2/28c147fec80609b6ce8578df27d7fafe02d97726df2d261c446176e6ceda/faiss_cpu-1.11.0.post1-cp313-cp313-macosx_13_0_x86_64.whl", hash = "sha256:caedaddfbfe365e3f1a57d5151cf94ea7b73c0e4789caf68eae05e0e10ca9fbf", size = 7913678, upload-time = "2025-07-15T09:14:27.072Z" }, + { url = "https://files.pythonhosted.org/packages/ff/71/7b06a5294e1d597f721016c6286a0c6e9912ed235d5e5d3600d4fd100ba8/faiss_cpu-1.11.0.post1-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:202d11f1d973224ca0bde13e7ee8b862b6de74287e626f9f8820b360e6253d12", size = 3313956, upload-time = "2025-07-15T09:14:29.061Z" }, + { url = "https://files.pythonhosted.org/packages/ad/15/ae1db1c42c8bef2cfc27b9d5a032b7723aafcc9420c656c19a7eaafd717b/faiss_cpu-1.11.0.post1-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f6086e25ef680301350d6db72db7315e3531582cf896a7ee3f26295b1da73c44", size = 3785332, upload-time = "2025-07-15T09:14:30.784Z" }, + { url = "https://files.pythonhosted.org/packages/41/0d/4538dfccb6e28fdfafd536b6f9c565ca6f5495272ae0c3f872259b29afc8/faiss_cpu-1.11.0.post1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b93131842996efbbf76f07dba1775d3a5f355f74b9ba34334f1149aef046b37f", size = 31287781, upload-time = "2025-07-15T09:14:32.791Z" }, + { url = "https://files.pythonhosted.org/packages/13/e5/82e3cf427f11380aae54706168974724409fdf9a8caa0894d2c1f454c627/faiss_cpu-1.11.0.post1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f26e3e93f537b2e1633212a1b0a7dab74d77825366ed575ca434dac2fa14cea6", size = 9714472, upload-time = "2025-07-15T09:14:35.537Z" }, + { url = "https://files.pythonhosted.org/packages/b4/f9/f518bd45a247fe241dc6196f3b96aef7270b3f1e1a98ebee35d8d66cc389/faiss_cpu-1.11.0.post1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:7f4b0e03cd758d03012d88aa4a70e673d10b66f31f7c122adc0c8c323cad2e33", size = 24012805, upload-time = "2025-07-15T09:14:38.362Z" }, + { url = "https://files.pythonhosted.org/packages/43/0a/7394ba0220d0e13be48d7c4c4d8ddd6a2a98f7960a38359157c88e045fe3/faiss_cpu-1.11.0.post1-cp313-cp313-win_amd64.whl", hash = "sha256:bc53fe59b546dbab63144dc19dcee534ad7a213db617b37aa4d0e33c26f9bbaf", size = 14882903, upload-time = "2025-07-15T09:14:41.148Z" }, + { url = "https://files.pythonhosted.org/packages/18/50/acc117b601da14f1a79f7deda3fad49509265d6b14c2221687cabc378dad/faiss_cpu-1.11.0.post1-cp313-cp313-win_arm64.whl", hash = "sha256:9cebb720cd57afdbe9dd7ed8a689c65dc5cf1bad475c5aa6fa0d0daea890beb6", size = 7852193, upload-time = "2025-07-15T09:14:43.113Z" }, +] + +[[package]] +name = "fastjsonschema" +version = "2.21.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/8b/50/4b769ce1ac4071a1ef6d86b1a3fb56cdc3a37615e8c5519e1af96cdac366/fastjsonschema-2.21.1.tar.gz", hash = "sha256:794d4f0a58f848961ba16af7b9c85a3e88cd360df008c59aac6fc5ae9323b5d4", size = 373939, upload-time = "2024-12-02T10:55:15.133Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/90/2b/0817a2b257fe88725c25589d89aec060581aabf668707a8d03b2e9e0cb2a/fastjsonschema-2.21.1-py3-none-any.whl", hash = "sha256:c9e5b7e908310918cf494a434eeb31384dd84a98b57a30bcb1f535015b554667", size = 23924, upload-time = "2024-12-02T10:55:07.599Z" }, +] + +[[package]] +name = "filelock" +version = "3.18.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0a/10/c23352565a6544bdc5353e0b15fc1c563352101f30e24bf500207a54df9a/filelock-3.18.0.tar.gz", hash = "sha256:adbc88eabb99d2fec8c9c1b229b171f18afa655400173ddc653d5d01501fb9f2", size = 18075, upload-time = "2025-03-14T07:11:40.47Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4d/36/2a115987e2d8c300a974597416d9de88f2444426de9571f4b59b2cca3acc/filelock-3.18.0-py3-none-any.whl", hash = "sha256:c401f4f8377c4464e6db25fff06205fd89bdd83b65eb0488ed1b160f780e21de", size = 16215, upload-time = "2025-03-14T07:11:39.145Z" }, +] + +[[package]] +name = "fonttools" +version = "4.59.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/8a/27/ec3c723bfdf86f34c5c82bf6305df3e0f0d8ea798d2d3a7cb0c0a866d286/fonttools-4.59.0.tar.gz", hash = "sha256:be392ec3529e2f57faa28709d60723a763904f71a2b63aabe14fee6648fe3b14", size = 3532521, upload-time = "2025-07-16T12:04:54.613Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e2/77/b1c8af22f4265e951cd2e5535dbef8859efcef4fb8dee742d368c967cddb/fonttools-4.59.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:f9b3a78f69dcbd803cf2fb3f972779875b244c1115481dfbdd567b2c22b31f6b", size = 2767562, upload-time = "2025-07-16T12:04:06.895Z" }, + { url = "https://files.pythonhosted.org/packages/ff/5a/aeb975699588176bb357e8b398dfd27e5d3a2230d92b81ab8cbb6187358d/fonttools-4.59.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:57bb7e26928573ee7c6504f54c05860d867fd35e675769f3ce01b52af38d48e2", size = 2335168, upload-time = "2025-07-16T12:04:08.695Z" }, + { url = "https://files.pythonhosted.org/packages/54/97/c6101a7e60ae138c4ef75b22434373a0da50a707dad523dd19a4889315bf/fonttools-4.59.0-cp312-cp312-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:4536f2695fe5c1ffb528d84a35a7d3967e5558d2af58b4775e7ab1449d65767b", size = 4909850, upload-time = "2025-07-16T12:04:10.761Z" }, + { url = "https://files.pythonhosted.org/packages/bd/6c/fa4d18d641054f7bff878cbea14aa9433f292b9057cb1700d8e91a4d5f4f/fonttools-4.59.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:885bde7d26e5b40e15c47bd5def48b38cbd50830a65f98122a8fb90962af7cd1", size = 4955131, upload-time = "2025-07-16T12:04:12.846Z" }, + { url = "https://files.pythonhosted.org/packages/20/5c/331947fc1377deb928a69bde49f9003364f5115e5cbe351eea99e39412a2/fonttools-4.59.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6801aeddb6acb2c42eafa45bc1cb98ba236871ae6f33f31e984670b749a8e58e", size = 4899667, upload-time = "2025-07-16T12:04:14.558Z" }, + { url = "https://files.pythonhosted.org/packages/8a/46/b66469dfa26b8ff0baa7654b2cc7851206c6d57fe3abdabbaab22079a119/fonttools-4.59.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:31003b6a10f70742a63126b80863ab48175fb8272a18ca0846c0482968f0588e", size = 5051349, upload-time = "2025-07-16T12:04:16.388Z" }, + { url = "https://files.pythonhosted.org/packages/2e/05/ebfb6b1f3a4328ab69787d106a7d92ccde77ce66e98659df0f9e3f28d93d/fonttools-4.59.0-cp312-cp312-win32.whl", hash = "sha256:fbce6dae41b692a5973d0f2158f782b9ad05babc2c2019a970a1094a23909b1b", size = 2201315, upload-time = "2025-07-16T12:04:18.557Z" }, + { url = "https://files.pythonhosted.org/packages/09/45/d2bdc9ea20bbadec1016fd0db45696d573d7a26d95ab5174ffcb6d74340b/fonttools-4.59.0-cp312-cp312-win_amd64.whl", hash = "sha256:332bfe685d1ac58ca8d62b8d6c71c2e52a6c64bc218dc8f7825c9ea51385aa01", size = 2249408, upload-time = "2025-07-16T12:04:20.489Z" }, + { url = "https://files.pythonhosted.org/packages/f3/bb/390990e7c457d377b00890d9f96a3ca13ae2517efafb6609c1756e213ba4/fonttools-4.59.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:78813b49d749e1bb4db1c57f2d4d7e6db22c253cb0a86ad819f5dc197710d4b2", size = 2758704, upload-time = "2025-07-16T12:04:22.217Z" }, + { url = "https://files.pythonhosted.org/packages/df/6f/d730d9fcc9b410a11597092bd2eb9ca53e5438c6cb90e4b3047ce1b723e9/fonttools-4.59.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:401b1941ce37e78b8fd119b419b617277c65ae9417742a63282257434fd68ea2", size = 2330764, upload-time = "2025-07-16T12:04:23.985Z" }, + { url = "https://files.pythonhosted.org/packages/75/b4/b96bb66f6f8cc4669de44a158099b249c8159231d254ab6b092909388be5/fonttools-4.59.0-cp313-cp313-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:efd7e6660674e234e29937bc1481dceb7e0336bfae75b856b4fb272b5093c5d4", size = 4890699, upload-time = "2025-07-16T12:04:25.664Z" }, + { url = "https://files.pythonhosted.org/packages/b5/57/7969af50b26408be12baa317c6147588db5b38af2759e6df94554dbc5fdb/fonttools-4.59.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:51ab1ff33c19e336c02dee1e9fd1abd974a4ca3d8f7eef2a104d0816a241ce97", size = 4952934, upload-time = "2025-07-16T12:04:27.733Z" }, + { url = "https://files.pythonhosted.org/packages/d6/e2/dd968053b6cf1f46c904f5bd409b22341477c017d8201619a265e50762d3/fonttools-4.59.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a9bf8adc9e1f3012edc8f09b08336272aec0c55bc677422273e21280db748f7c", size = 4892319, upload-time = "2025-07-16T12:04:30.074Z" }, + { url = "https://files.pythonhosted.org/packages/6b/95/a59810d8eda09129f83467a4e58f84205dc6994ebaeb9815406363e07250/fonttools-4.59.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:37e01c6ec0c98599778c2e688350d624fa4770fbd6144551bd5e032f1199171c", size = 5034753, upload-time = "2025-07-16T12:04:32.292Z" }, + { url = "https://files.pythonhosted.org/packages/a5/84/51a69ee89ff8d1fea0c6997e946657e25a3f08513de8435fe124929f3eef/fonttools-4.59.0-cp313-cp313-win32.whl", hash = "sha256:70d6b3ceaa9cc5a6ac52884f3b3d9544e8e231e95b23f138bdb78e6d4dc0eae3", size = 2199688, upload-time = "2025-07-16T12:04:34.444Z" }, + { url = "https://files.pythonhosted.org/packages/a0/ee/f626cd372932d828508137a79b85167fdcf3adab2e3bed433f295c596c6a/fonttools-4.59.0-cp313-cp313-win_amd64.whl", hash = "sha256:26731739daa23b872643f0e4072d5939960237d540c35c14e6a06d47d71ca8fe", size = 2248560, upload-time = "2025-07-16T12:04:36.034Z" }, + { url = "https://files.pythonhosted.org/packages/d0/9c/df0ef2c51845a13043e5088f7bb988ca6cd5bb82d5d4203d6a158aa58cf2/fonttools-4.59.0-py3-none-any.whl", hash = "sha256:241313683afd3baacb32a6bd124d0bce7404bc5280e12e291bae1b9bba28711d", size = 1128050, upload-time = "2025-07-16T12:04:52.687Z" }, +] + +[[package]] +name = "fqdn" +version = "1.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/30/3e/a80a8c077fd798951169626cde3e239adeba7dab75deb3555716415bd9b0/fqdn-1.5.1.tar.gz", hash = "sha256:105ed3677e767fb5ca086a0c1f4bb66ebc3c100be518f0e0d755d9eae164d89f", size = 6015, upload-time = "2021-03-11T07:16:29.08Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cf/58/8acf1b3e91c58313ce5cb67df61001fc9dcd21be4fadb76c1a2d540e09ed/fqdn-1.5.1-py3-none-any.whl", hash = "sha256:3a179af3761e4df6eb2e026ff9e1a3033d3587bf980a0b1b2e1e5d08d7358014", size = 9121, upload-time = "2021-03-11T07:16:28.351Z" }, +] + +[[package]] +name = "fsspec" +version = "2025.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/8b/02/0835e6ab9cfc03916fe3f78c0956cfcdb6ff2669ffa6651065d5ebf7fc98/fsspec-2025.7.0.tar.gz", hash = "sha256:786120687ffa54b8283d942929540d8bc5ccfa820deb555a2b5d0ed2b737bf58", size = 304432, upload-time = "2025-07-15T16:05:21.19Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2f/e0/014d5d9d7a4564cf1c40b5039bc882db69fd881111e03ab3657ac0b218e2/fsspec-2025.7.0-py3-none-any.whl", hash = "sha256:8b012e39f63c7d5f10474de957f3ab793b47b45ae7d39f2fb735f8bbe25c0e21", size = 199597, upload-time = "2025-07-15T16:05:19.529Z" }, +] + +[[package]] +name = "groq" +version = "0.31.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "distro" }, + { name = "httpx" }, + { name = "pydantic" }, + { name = "sniffio" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/66/a2/77fd1460e7d55859219223719aa44ae8902a3a1ad333cd5faf330eb0b894/groq-0.31.0.tar.gz", hash = "sha256:182252e9bf0d696df607c137cbafa851d2c84aaf94bcfe9165c0bc231043490c", size = 136237, upload-time = "2025-08-05T23:14:01.183Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ab/f8/14672d69a91495f43462c5490067eeafc30346e81bda1a62848e897f9bc3/groq-0.31.0-py3-none-any.whl", hash = "sha256:5e3c7ec9728b7cccf913da982a9b5ebb46dc18a070b35e12a3d6a1e12d6b0f7f", size = 131365, upload-time = "2025-08-05T23:13:59.768Z" }, +] + +[[package]] +name = "h11" +version = "0.16.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" }, +] + +[[package]] +name = "hf-xet" +version = "1.1.7" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b2/0a/a0f56735940fde6dd627602fec9ab3bad23f66a272397560abd65aba416e/hf_xet-1.1.7.tar.gz", hash = "sha256:20cec8db4561338824a3b5f8c19774055b04a8df7fff0cb1ff2cb1a0c1607b80", size = 477719, upload-time = "2025-08-06T00:30:55.741Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b1/7c/8d7803995caf14e7d19a392a486a040f923e2cfeff824e9b800b92072f76/hf_xet-1.1.7-cp37-abi3-macosx_10_12_x86_64.whl", hash = "sha256:60dae4b44d520819e54e216a2505685248ec0adbdb2dd4848b17aa85a0375cde", size = 2761743, upload-time = "2025-08-06T00:30:50.634Z" }, + { url = "https://files.pythonhosted.org/packages/51/a3/fa5897099454aa287022a34a30e68dbff0e617760f774f8bd1db17f06bd4/hf_xet-1.1.7-cp37-abi3-macosx_11_0_arm64.whl", hash = "sha256:b109f4c11e01c057fc82004c9e51e6cdfe2cb230637644ade40c599739067b2e", size = 2624331, upload-time = "2025-08-06T00:30:49.212Z" }, + { url = "https://files.pythonhosted.org/packages/86/50/2446a132267e60b8a48b2e5835d6e24fd988000d0f5b9b15ebd6d64ef769/hf_xet-1.1.7-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6efaaf1a5a9fc3a501d3e71e88a6bfebc69ee3a716d0e713a931c8b8d920038f", size = 3183844, upload-time = "2025-08-06T00:30:47.582Z" }, + { url = "https://files.pythonhosted.org/packages/20/8f/ccc670616bb9beee867c6bb7139f7eab2b1370fe426503c25f5cbb27b148/hf_xet-1.1.7-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:751571540f9c1fbad9afcf222a5fb96daf2384bf821317b8bfb0c59d86078513", size = 3074209, upload-time = "2025-08-06T00:30:45.509Z" }, + { url = "https://files.pythonhosted.org/packages/21/0a/4c30e1eb77205565b854f5e4a82cf1f056214e4dc87f2918ebf83d47ae14/hf_xet-1.1.7-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:18b61bbae92d56ae731b92087c44efcac216071182c603fc535f8e29ec4b09b8", size = 3239602, upload-time = "2025-08-06T00:30:52.41Z" }, + { url = "https://files.pythonhosted.org/packages/f5/1e/fc7e9baf14152662ef0b35fa52a6e889f770a7ed14ac239de3c829ecb47e/hf_xet-1.1.7-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:713f2bff61b252f8523739969f247aa354ad8e6d869b8281e174e2ea1bb8d604", size = 3348184, upload-time = "2025-08-06T00:30:54.105Z" }, + { url = "https://files.pythonhosted.org/packages/a3/73/e354eae84ceff117ec3560141224724794828927fcc013c5b449bf0b8745/hf_xet-1.1.7-cp37-abi3-win_amd64.whl", hash = "sha256:2e356da7d284479ae0f1dea3cf5a2f74fdf925d6dca84ac4341930d892c7cb34", size = 2820008, upload-time = "2025-08-06T00:30:57.056Z" }, +] + +[[package]] +name = "httpcore" +version = "1.0.9" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "h11" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" }, +] + +[[package]] +name = "httpx" +version = "0.28.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "certifi" }, + { name = "httpcore" }, + { name = "idna" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" }, +] + +[[package]] +name = "huggingface-hub" +version = "0.34.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "filelock" }, + { name = "fsspec" }, + { name = "hf-xet", marker = "platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'arm64' or platform_machine == 'x86_64'" }, + { name = "packaging" }, + { name = "pyyaml" }, + { name = "requests" }, + { name = "tqdm" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/91/b4/e6b465eca5386b52cf23cb6df8644ad318a6b0e12b4b96a7e0be09cbfbcc/huggingface_hub-0.34.3.tar.gz", hash = "sha256:d58130fd5aa7408480681475491c0abd7e835442082fbc3ef4d45b6c39f83853", size = 456800, upload-time = "2025-07-29T08:38:53.885Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/59/a8/4677014e771ed1591a87b63a2392ce6923baf807193deef302dcfde17542/huggingface_hub-0.34.3-py3-none-any.whl", hash = "sha256:5444550099e2d86e68b2898b09e85878fbd788fc2957b506c6a79ce060e39492", size = 558847, upload-time = "2025-07-29T08:38:51.904Z" }, +] + +[[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 = "ipykernel" +version = "6.30.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "appnope", marker = "sys_platform == 'darwin'" }, + { name = "comm" }, + { name = "debugpy" }, + { name = "ipython" }, + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "matplotlib-inline" }, + { name = "nest-asyncio" }, + { name = "packaging" }, + { name = "psutil" }, + { name = "pyzmq" }, + { name = "tornado" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/bb/76/11082e338e0daadc89c8ff866185de11daf67d181901038f9e139d109761/ipykernel-6.30.1.tar.gz", hash = "sha256:6abb270161896402e76b91394fcdce5d1be5d45f456671e5080572f8505be39b", size = 166260, upload-time = "2025-08-04T15:47:35.018Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fc/c7/b445faca8deb954fe536abebff4ece5b097b923de482b26e78448c89d1dd/ipykernel-6.30.1-py3-none-any.whl", hash = "sha256:aa6b9fb93dca949069d8b85b6c79b2518e32ac583ae9c7d37c51d119e18b3fb4", size = 117484, upload-time = "2025-08-04T15:47:32.622Z" }, +] + +[[package]] +name = "ipython" +version = "9.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "decorator" }, + { name = "ipython-pygments-lexers" }, + { name = "jedi" }, + { name = "matplotlib-inline" }, + { name = "pexpect", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, + { name = "prompt-toolkit" }, + { name = "pygments" }, + { name = "stack-data" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/54/80/406f9e3bde1c1fd9bf5a0be9d090f8ae623e401b7670d8f6fdf2ab679891/ipython-9.4.0.tar.gz", hash = "sha256:c033c6d4e7914c3d9768aabe76bbe87ba1dc66a92a05db6bfa1125d81f2ee270", size = 4385338, upload-time = "2025-07-01T11:11:30.606Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/63/f8/0031ee2b906a15a33d6bfc12dd09c3dfa966b3cb5b284ecfb7549e6ac3c4/ipython-9.4.0-py3-none-any.whl", hash = "sha256:25850f025a446d9b359e8d296ba175a36aedd32e83ca9b5060430fe16801f066", size = 611021, upload-time = "2025-07-01T11:11:27.85Z" }, +] + +[[package]] +name = "ipython-pygments-lexers" +version = "1.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ef/4c/5dd1d8af08107f88c7f741ead7a40854b8ac24ddf9ae850afbcf698aa552/ipython_pygments_lexers-1.1.1.tar.gz", hash = "sha256:09c0138009e56b6854f9535736f4171d855c8c08a563a0dcd8022f78355c7e81", size = 8393, upload-time = "2025-01-17T11:24:34.505Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d9/33/1f075bf72b0b747cb3288d011319aaf64083cf2efef8354174e3ed4540e2/ipython_pygments_lexers-1.1.1-py3-none-any.whl", hash = "sha256:a9462224a505ade19a605f71f8fa63c2048833ce50abc86768a0d81d876dc81c", size = 8074, upload-time = "2025-01-17T11:24:33.271Z" }, +] + +[[package]] +name = "ipywidgets" +version = "8.1.7" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "comm" }, + { name = "ipython" }, + { name = "jupyterlab-widgets" }, + { name = "traitlets" }, + { name = "widgetsnbextension" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/3e/48/d3dbac45c2814cb73812f98dd6b38bbcc957a4e7bb31d6ea9c03bf94ed87/ipywidgets-8.1.7.tar.gz", hash = "sha256:15f1ac050b9ccbefd45dccfbb2ef6bed0029d8278682d569d71b8dd96bee0376", size = 116721, upload-time = "2025-05-05T12:42:03.489Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/58/6a/9166369a2f092bd286d24e6307de555d63616e8ddb373ebad2b5635ca4cd/ipywidgets-8.1.7-py3-none-any.whl", hash = "sha256:764f2602d25471c213919b8a1997df04bef869251db4ca8efba1b76b1bd9f7bb", size = 139806, upload-time = "2025-05-05T12:41:56.833Z" }, +] + +[[package]] +name = "isoduration" +version = "20.11.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "arrow" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7c/1a/3c8edc664e06e6bd06cce40c6b22da5f1429aa4224d0c590f3be21c91ead/isoduration-20.11.0.tar.gz", hash = "sha256:ac2f9015137935279eac671f94f89eb00584f940f5dc49462a0c4ee692ba1bd9", size = 11649, upload-time = "2020-11-01T11:00:00.312Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7b/55/e5326141505c5d5e34c5e0935d2908a74e4561eca44108fbfb9c13d2911a/isoduration-20.11.0-py3-none-any.whl", hash = "sha256:b2904c2a4228c3d44f409c8ae8e2370eb21a26f7ac2ec5446df141dde3452042", size = 11321, upload-time = "2020-11-01T10:59:58.02Z" }, +] + +[[package]] +name = "jedi" +version = "0.19.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "parso" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/72/3a/79a912fbd4d8dd6fbb02bf69afd3bb72cf0c729bb3063c6f4498603db17a/jedi-0.19.2.tar.gz", hash = "sha256:4770dc3de41bde3966b02eb84fbcf557fb33cce26ad23da12c742fb50ecb11f0", size = 1231287, upload-time = "2024-11-11T01:41:42.873Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c0/5a/9cac0c82afec3d09ccd97c8b6502d48f165f9124db81b4bcb90b4af974ee/jedi-0.19.2-py2.py3-none-any.whl", hash = "sha256:a8ef22bde8490f57fe5c7681a3c83cb58874daf72b4784de3cce5b6ef6edb5b9", size = 1572278, upload-time = "2024-11-11T01:41:40.175Z" }, +] + +[[package]] +name = "jinja2" +version = "3.1.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markupsafe" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115, upload-time = "2025-03-05T20:05:02.478Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899, upload-time = "2025-03-05T20:05:00.369Z" }, +] + +[[package]] +name = "joblib" +version = "1.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/dc/fe/0f5a938c54105553436dbff7a61dc4fed4b1b2c98852f8833beaf4d5968f/joblib-1.5.1.tar.gz", hash = "sha256:f4f86e351f39fe3d0d32a9f2c3d8af1ee4cec285aafcb27003dda5205576b444", size = 330475, upload-time = "2025-05-23T12:04:37.097Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7d/4f/1195bbac8e0c2acc5f740661631d8d750dc38d4a32b23ee5df3cde6f4e0d/joblib-1.5.1-py3-none-any.whl", hash = "sha256:4719a31f054c7d766948dcd83e9613686b27114f190f717cec7eaa2084f8a74a", size = 307746, upload-time = "2025-05-23T12:04:35.124Z" }, +] + +[[package]] +name = "json5" +version = "0.12.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/12/be/c6c745ec4c4539b25a278b70e29793f10382947df0d9efba2fa09120895d/json5-0.12.0.tar.gz", hash = "sha256:0b4b6ff56801a1c7dc817b0241bca4ce474a0e6a163bfef3fc594d3fd263ff3a", size = 51907, upload-time = "2025-04-03T16:33:13.201Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/41/9f/3500910d5a98549e3098807493851eeef2b89cdd3032227558a104dfe926/json5-0.12.0-py3-none-any.whl", hash = "sha256:6d37aa6c08b0609f16e1ec5ff94697e2cbbfbad5ac112afa05794da9ab7810db", size = 36079, upload-time = "2025-04-03T16:33:11.927Z" }, +] + +[[package]] +name = "jsonpointer" +version = "3.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6a/0a/eebeb1fa92507ea94016a2a790b93c2ae41a7e18778f85471dc54475ed25/jsonpointer-3.0.0.tar.gz", hash = "sha256:2b2d729f2091522d61c3b31f82e11870f60b68f43fbc705cb76bf4b832af59ef", size = 9114, upload-time = "2024-06-10T19:24:42.462Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/71/92/5e77f98553e9e75130c78900d000368476aed74276eb8ae8796f65f00918/jsonpointer-3.0.0-py2.py3-none-any.whl", hash = "sha256:13e088adc14fca8b6aa8177c044e12701e6ad4b28ff10e65f2267a90109c9942", size = 7595, upload-time = "2024-06-10T19:24:40.698Z" }, +] + +[[package]] +name = "jsonschema" +version = "4.25.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "attrs" }, + { name = "jsonschema-specifications" }, + { name = "referencing" }, + { name = "rpds-py" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/d5/00/a297a868e9d0784450faa7365c2172a7d6110c763e30ba861867c32ae6a9/jsonschema-4.25.0.tar.gz", hash = "sha256:e63acf5c11762c0e6672ffb61482bdf57f0876684d8d249c0fe2d730d48bc55f", size = 356830, upload-time = "2025-07-18T15:39:45.11Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fe/54/c86cd8e011fe98803d7e382fd67c0df5ceab8d2b7ad8c5a81524f791551c/jsonschema-4.25.0-py3-none-any.whl", hash = "sha256:24c2e8da302de79c8b9382fee3e76b355e44d2a4364bb207159ce10b517bd716", size = 89184, upload-time = "2025-07-18T15:39:42.956Z" }, +] + +[package.optional-dependencies] +format-nongpl = [ + { name = "fqdn" }, + { name = "idna" }, + { name = "isoduration" }, + { name = "jsonpointer" }, + { name = "rfc3339-validator" }, + { name = "rfc3986-validator" }, + { name = "rfc3987-syntax" }, + { name = "uri-template" }, + { name = "webcolors" }, +] + +[[package]] +name = "jsonschema-specifications" +version = "2025.4.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "referencing" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/bf/ce/46fbd9c8119cfc3581ee5643ea49464d168028cfb5caff5fc0596d0cf914/jsonschema_specifications-2025.4.1.tar.gz", hash = "sha256:630159c9f4dbea161a6a2205c3011cc4f18ff381b189fff48bb39b9bf26ae608", size = 15513, upload-time = "2025-04-23T12:34:07.418Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/01/0e/b27cdbaccf30b890c40ed1da9fd4a3593a5cf94dae54fb34f8a4b74fcd3f/jsonschema_specifications-2025.4.1-py3-none-any.whl", hash = "sha256:4653bffbd6584f7de83a67e0d620ef16900b390ddc7939d56684d6c81e33f1af", size = 18437, upload-time = "2025-04-23T12:34:05.422Z" }, +] + +[[package]] +name = "jupyter" +version = "1.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ipykernel" }, + { name = "ipywidgets" }, + { name = "jupyter-console" }, + { name = "jupyterlab" }, + { name = "nbconvert" }, + { name = "notebook" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/58/f3/af28ea964ab8bc1e472dba2e82627d36d470c51f5cd38c37502eeffaa25e/jupyter-1.1.1.tar.gz", hash = "sha256:d55467bceabdea49d7e3624af7e33d59c37fff53ed3a350e1ac957bed731de7a", size = 5714959, upload-time = "2024-08-30T07:15:48.299Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/38/64/285f20a31679bf547b75602702f7800e74dbabae36ef324f716c02804753/jupyter-1.1.1-py2.py3-none-any.whl", hash = "sha256:7a59533c22af65439b24bbe60373a4e95af8f16ac65a6c00820ad378e3f7cc83", size = 2657, upload-time = "2024-08-30T07:15:47.045Z" }, +] + +[[package]] +name = "jupyter-client" +version = "8.6.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-core" }, + { name = "python-dateutil" }, + { name = "pyzmq" }, + { name = "tornado" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/71/22/bf9f12fdaeae18019a468b68952a60fe6dbab5d67cd2a103cac7659b41ca/jupyter_client-8.6.3.tar.gz", hash = "sha256:35b3a0947c4a6e9d589eb97d7d4cd5e90f910ee73101611f01283732bd6d9419", size = 342019, upload-time = "2024-09-17T10:44:17.613Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/11/85/b0394e0b6fcccd2c1eeefc230978a6f8cb0c5df1e4cd3e7625735a0d7d1e/jupyter_client-8.6.3-py3-none-any.whl", hash = "sha256:e8a19cc986cc45905ac3362915f410f3af85424b4c0905e94fa5f2cb08e8f23f", size = 106105, upload-time = "2024-09-17T10:44:15.218Z" }, +] + +[[package]] +name = "jupyter-console" +version = "6.6.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ipykernel" }, + { name = "ipython" }, + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "prompt-toolkit" }, + { name = "pygments" }, + { name = "pyzmq" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/bd/2d/e2fd31e2fc41c14e2bcb6c976ab732597e907523f6b2420305f9fc7fdbdb/jupyter_console-6.6.3.tar.gz", hash = "sha256:566a4bf31c87adbfadf22cdf846e3069b59a71ed5da71d6ba4d8aaad14a53539", size = 34363, upload-time = "2023-03-06T14:13:31.02Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ca/77/71d78d58f15c22db16328a476426f7ac4a60d3a5a7ba3b9627ee2f7903d4/jupyter_console-6.6.3-py3-none-any.whl", hash = "sha256:309d33409fcc92ffdad25f0bcdf9a4a9daa61b6f341177570fdac03de5352485", size = 24510, upload-time = "2023-03-06T14:13:28.229Z" }, +] + +[[package]] +name = "jupyter-core" +version = "5.8.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "platformdirs" }, + { name = "pywin32", marker = "platform_python_implementation != 'PyPy' and sys_platform == 'win32'" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/99/1b/72906d554acfeb588332eaaa6f61577705e9ec752ddb486f302dafa292d9/jupyter_core-5.8.1.tar.gz", hash = "sha256:0a5f9706f70e64786b75acba995988915ebd4601c8a52e534a40b51c95f59941", size = 88923, upload-time = "2025-05-27T07:38:16.655Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2f/57/6bffd4b20b88da3800c5d691e0337761576ee688eb01299eae865689d2df/jupyter_core-5.8.1-py3-none-any.whl", hash = "sha256:c28d268fc90fb53f1338ded2eb410704c5449a358406e8a948b75706e24863d0", size = 28880, upload-time = "2025-05-27T07:38:15.137Z" }, +] + +[[package]] +name = "jupyter-events" +version = "0.12.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jsonschema", extra = ["format-nongpl"] }, + { name = "packaging" }, + { name = "python-json-logger" }, + { name = "pyyaml" }, + { name = "referencing" }, + { name = "rfc3339-validator" }, + { name = "rfc3986-validator" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9d/c3/306d090461e4cf3cd91eceaff84bede12a8e52cd821c2d20c9a4fd728385/jupyter_events-0.12.0.tar.gz", hash = "sha256:fc3fce98865f6784c9cd0a56a20644fc6098f21c8c33834a8d9fe383c17e554b", size = 62196, upload-time = "2025-02-03T17:23:41.485Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e2/48/577993f1f99c552f18a0428731a755e06171f9902fa118c379eb7c04ea22/jupyter_events-0.12.0-py3-none-any.whl", hash = "sha256:6464b2fa5ad10451c3d35fabc75eab39556ae1e2853ad0c0cc31b656731a97fb", size = 19430, upload-time = "2025-02-03T17:23:38.643Z" }, +] + +[[package]] +name = "jupyter-lsp" +version = "2.2.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-server" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/28/3d/40bdb41b665d3302390ed1356cebd5917c10769d1f190ee4ca595900840e/jupyter_lsp-2.2.6.tar.gz", hash = "sha256:0566bd9bb04fd9e6774a937ed01522b555ba78be37bebef787c8ab22de4c0361", size = 48948, upload-time = "2025-07-18T21:35:19.885Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/47/7c/12f68daf85b469b4896d5e4a629baa33c806d61de75ac5b39d8ef27ec4a2/jupyter_lsp-2.2.6-py3-none-any.whl", hash = "sha256:283783752bf0b459ee7fa88effa72104d87dd343b82d5c06cf113ef755b15b6d", size = 69371, upload-time = "2025-07-18T21:35:16.585Z" }, +] + +[[package]] +name = "jupyter-server" +version = "2.16.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "argon2-cffi" }, + { name = "jinja2" }, + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "jupyter-events" }, + { name = "jupyter-server-terminals" }, + { name = "nbconvert" }, + { name = "nbformat" }, + { name = "overrides" }, + { name = "packaging" }, + { name = "prometheus-client" }, + { name = "pywinpty", marker = "os_name == 'nt'" }, + { name = "pyzmq" }, + { name = "send2trash" }, + { name = "terminado" }, + { name = "tornado" }, + { name = "traitlets" }, + { name = "websocket-client" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/41/c8/ba2bbcd758c47f1124c4ca14061e8ce60d9c6fd537faee9534a95f83521a/jupyter_server-2.16.0.tar.gz", hash = "sha256:65d4b44fdf2dcbbdfe0aa1ace4a842d4aaf746a2b7b168134d5aaed35621b7f6", size = 728177, upload-time = "2025-05-12T16:44:46.245Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/46/1f/5ebbced977171d09a7b0c08a285ff9a20aafb9c51bde07e52349ff1ddd71/jupyter_server-2.16.0-py3-none-any.whl", hash = "sha256:3d8db5be3bc64403b1c65b400a1d7f4647a5ce743f3b20dbdefe8ddb7b55af9e", size = 386904, upload-time = "2025-05-12T16:44:43.335Z" }, +] + +[[package]] +name = "jupyter-server-terminals" +version = "0.5.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pywinpty", marker = "os_name == 'nt'" }, + { name = "terminado" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/fc/d5/562469734f476159e99a55426d697cbf8e7eb5efe89fb0e0b4f83a3d3459/jupyter_server_terminals-0.5.3.tar.gz", hash = "sha256:5ae0295167220e9ace0edcfdb212afd2b01ee8d179fe6f23c899590e9b8a5269", size = 31430, upload-time = "2024-03-12T14:37:03.049Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/07/2d/2b32cdbe8d2a602f697a649798554e4f072115438e92249624e532e8aca6/jupyter_server_terminals-0.5.3-py3-none-any.whl", hash = "sha256:41ee0d7dc0ebf2809c668e0fc726dfaf258fcd3e769568996ca731b6194ae9aa", size = 13656, upload-time = "2024-03-12T14:37:00.708Z" }, +] + +[[package]] +name = "jupyterlab" +version = "4.4.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "async-lru" }, + { name = "httpx" }, + { name = "ipykernel" }, + { name = "jinja2" }, + { name = "jupyter-core" }, + { name = "jupyter-lsp" }, + { name = "jupyter-server" }, + { name = "jupyterlab-server" }, + { name = "notebook-shim" }, + { name = "packaging" }, + { name = "setuptools" }, + { name = "tornado" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/20/89/695805a6564bafe08ef2505f3c473ae7140b8ba431d381436f11bdc2c266/jupyterlab-4.4.5.tar.gz", hash = "sha256:0bd6c18e6a3c3d91388af6540afa3d0bb0b2e76287a7b88ddf20ab41b336e595", size = 23037079, upload-time = "2025-07-20T09:21:30.151Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/47/74/e144ce85b34414e44b14c1f6bf2e3bfe17964c8e5670ebdc7629f2e53672/jupyterlab-4.4.5-py3-none-any.whl", hash = "sha256:e76244cceb2d1fb4a99341f3edc866f2a13a9e14c50368d730d75d8017be0863", size = 12267763, upload-time = "2025-07-20T09:21:26.37Z" }, +] + +[[package]] +name = "jupyterlab-pygments" +version = "0.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/90/51/9187be60d989df97f5f0aba133fa54e7300f17616e065d1ada7d7646b6d6/jupyterlab_pygments-0.3.0.tar.gz", hash = "sha256:721aca4d9029252b11cfa9d185e5b5af4d54772bb8072f9b7036f4170054d35d", size = 512900, upload-time = "2023-11-23T09:26:37.44Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b1/dd/ead9d8ea85bf202d90cc513b533f9c363121c7792674f78e0d8a854b63b4/jupyterlab_pygments-0.3.0-py3-none-any.whl", hash = "sha256:841a89020971da1d8693f1a99997aefc5dc424bb1b251fd6322462a1b8842780", size = 15884, upload-time = "2023-11-23T09:26:34.325Z" }, +] + +[[package]] +name = "jupyterlab-server" +version = "2.27.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "babel" }, + { name = "jinja2" }, + { name = "json5" }, + { name = "jsonschema" }, + { name = "jupyter-server" }, + { name = "packaging" }, + { name = "requests" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0a/c9/a883ce65eb27905ce77ace410d83587c82ea64dc85a48d1f7ed52bcfa68d/jupyterlab_server-2.27.3.tar.gz", hash = "sha256:eb36caca59e74471988f0ae25c77945610b887f777255aa21f8065def9e51ed4", size = 76173, upload-time = "2024-07-16T17:02:04.149Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/54/09/2032e7d15c544a0e3cd831c51d77a8ca57f7555b2e1b2922142eddb02a84/jupyterlab_server-2.27.3-py3-none-any.whl", hash = "sha256:e697488f66c3db49df675158a77b3b017520d772c6e1548c7d9bcc5df7944ee4", size = 59700, upload-time = "2024-07-16T17:02:01.115Z" }, +] + +[[package]] +name = "jupyterlab-widgets" +version = "3.0.15" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b9/7d/160595ca88ee87ac6ba95d82177d29ec60aaa63821d3077babb22ce031a5/jupyterlab_widgets-3.0.15.tar.gz", hash = "sha256:2920888a0c2922351a9202817957a68c07d99673504d6cd37345299e971bb08b", size = 213149, upload-time = "2025-05-05T12:32:31.004Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/43/6a/ca128561b22b60bd5a0c4ea26649e68c8556b82bc70a0c396eebc977fe86/jupyterlab_widgets-3.0.15-py3-none-any.whl", hash = "sha256:d59023d7d7ef71400d51e6fee9a88867f6e65e10a4201605d2d7f3e8f012a31c", size = 216571, upload-time = "2025-05-05T12:32:29.534Z" }, +] + +[[package]] +name = "kiwisolver" +version = "1.4.8" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/82/59/7c91426a8ac292e1cdd53a63b6d9439abd573c875c3f92c146767dd33faf/kiwisolver-1.4.8.tar.gz", hash = "sha256:23d5f023bdc8c7e54eb65f03ca5d5bb25b601eac4d7f1a042888a1f45237987e", size = 97538, upload-time = "2024-12-24T18:30:51.519Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fc/aa/cea685c4ab647f349c3bc92d2daf7ae34c8e8cf405a6dcd3a497f58a2ac3/kiwisolver-1.4.8-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:d6af5e8815fd02997cb6ad9bbed0ee1e60014438ee1a5c2444c96f87b8843502", size = 124152, upload-time = "2024-12-24T18:29:16.85Z" }, + { url = "https://files.pythonhosted.org/packages/c5/0b/8db6d2e2452d60d5ebc4ce4b204feeb16176a851fd42462f66ade6808084/kiwisolver-1.4.8-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:bade438f86e21d91e0cf5dd7c0ed00cda0f77c8c1616bd83f9fc157fa6760d31", size = 66555, upload-time = "2024-12-24T18:29:19.146Z" }, + { url = "https://files.pythonhosted.org/packages/60/26/d6a0db6785dd35d3ba5bf2b2df0aedc5af089962c6eb2cbf67a15b81369e/kiwisolver-1.4.8-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b83dc6769ddbc57613280118fb4ce3cd08899cc3369f7d0e0fab518a7cf37fdb", size = 65067, upload-time = "2024-12-24T18:29:20.096Z" }, + { url = "https://files.pythonhosted.org/packages/c9/ed/1d97f7e3561e09757a196231edccc1bcf59d55ddccefa2afc9c615abd8e0/kiwisolver-1.4.8-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:111793b232842991be367ed828076b03d96202c19221b5ebab421ce8bcad016f", size = 1378443, upload-time = "2024-12-24T18:29:22.843Z" }, + { url = "https://files.pythonhosted.org/packages/29/61/39d30b99954e6b46f760e6289c12fede2ab96a254c443639052d1b573fbc/kiwisolver-1.4.8-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:257af1622860e51b1a9d0ce387bf5c2c4f36a90594cb9514f55b074bcc787cfc", size = 1472728, upload-time = "2024-12-24T18:29:24.463Z" }, + { url = "https://files.pythonhosted.org/packages/0c/3e/804163b932f7603ef256e4a715e5843a9600802bb23a68b4e08c8c0ff61d/kiwisolver-1.4.8-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:69b5637c3f316cab1ec1c9a12b8c5f4750a4c4b71af9157645bf32830e39c03a", size = 1478388, upload-time = "2024-12-24T18:29:25.776Z" }, + { url = "https://files.pythonhosted.org/packages/8a/9e/60eaa75169a154700be74f875a4d9961b11ba048bef315fbe89cb6999056/kiwisolver-1.4.8-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:782bb86f245ec18009890e7cb8d13a5ef54dcf2ebe18ed65f795e635a96a1c6a", size = 1413849, upload-time = "2024-12-24T18:29:27.202Z" }, + { url = "https://files.pythonhosted.org/packages/bc/b3/9458adb9472e61a998c8c4d95cfdfec91c73c53a375b30b1428310f923e4/kiwisolver-1.4.8-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cc978a80a0db3a66d25767b03688f1147a69e6237175c0f4ffffaaedf744055a", size = 1475533, upload-time = "2024-12-24T18:29:28.638Z" }, + { url = "https://files.pythonhosted.org/packages/e4/7a/0a42d9571e35798de80aef4bb43a9b672aa7f8e58643d7bd1950398ffb0a/kiwisolver-1.4.8-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:36dbbfd34838500a31f52c9786990d00150860e46cd5041386f217101350f0d3", size = 2268898, upload-time = "2024-12-24T18:29:30.368Z" }, + { url = "https://files.pythonhosted.org/packages/d9/07/1255dc8d80271400126ed8db35a1795b1a2c098ac3a72645075d06fe5c5d/kiwisolver-1.4.8-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:eaa973f1e05131de5ff3569bbba7f5fd07ea0595d3870ed4a526d486fe57fa1b", size = 2425605, upload-time = "2024-12-24T18:29:33.151Z" }, + { url = "https://files.pythonhosted.org/packages/84/df/5a3b4cf13780ef6f6942df67b138b03b7e79e9f1f08f57c49957d5867f6e/kiwisolver-1.4.8-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:a66f60f8d0c87ab7f59b6fb80e642ebb29fec354a4dfad687ca4092ae69d04f4", size = 2375801, upload-time = "2024-12-24T18:29:34.584Z" }, + { url = "https://files.pythonhosted.org/packages/8f/10/2348d068e8b0f635c8c86892788dac7a6b5c0cb12356620ab575775aad89/kiwisolver-1.4.8-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:858416b7fb777a53f0c59ca08190ce24e9abbd3cffa18886a5781b8e3e26f65d", size = 2520077, upload-time = "2024-12-24T18:29:36.138Z" }, + { url = "https://files.pythonhosted.org/packages/32/d8/014b89fee5d4dce157d814303b0fce4d31385a2af4c41fed194b173b81ac/kiwisolver-1.4.8-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:085940635c62697391baafaaeabdf3dd7a6c3643577dde337f4d66eba021b2b8", size = 2338410, upload-time = "2024-12-24T18:29:39.991Z" }, + { url = "https://files.pythonhosted.org/packages/bd/72/dfff0cc97f2a0776e1c9eb5bef1ddfd45f46246c6533b0191887a427bca5/kiwisolver-1.4.8-cp312-cp312-win_amd64.whl", hash = "sha256:01c3d31902c7db5fb6182832713d3b4122ad9317c2c5877d0539227d96bb2e50", size = 71853, upload-time = "2024-12-24T18:29:42.006Z" }, + { url = "https://files.pythonhosted.org/packages/dc/85/220d13d914485c0948a00f0b9eb419efaf6da81b7d72e88ce2391f7aed8d/kiwisolver-1.4.8-cp312-cp312-win_arm64.whl", hash = "sha256:a3c44cb68861de93f0c4a8175fbaa691f0aa22550c331fefef02b618a9dcb476", size = 65424, upload-time = "2024-12-24T18:29:44.38Z" }, + { url = "https://files.pythonhosted.org/packages/79/b3/e62464a652f4f8cd9006e13d07abad844a47df1e6537f73ddfbf1bc997ec/kiwisolver-1.4.8-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:1c8ceb754339793c24aee1c9fb2485b5b1f5bb1c2c214ff13368431e51fc9a09", size = 124156, upload-time = "2024-12-24T18:29:45.368Z" }, + { url = "https://files.pythonhosted.org/packages/8d/2d/f13d06998b546a2ad4f48607a146e045bbe48030774de29f90bdc573df15/kiwisolver-1.4.8-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:54a62808ac74b5e55a04a408cda6156f986cefbcf0ada13572696b507cc92fa1", size = 66555, upload-time = "2024-12-24T18:29:46.37Z" }, + { url = "https://files.pythonhosted.org/packages/59/e3/b8bd14b0a54998a9fd1e8da591c60998dc003618cb19a3f94cb233ec1511/kiwisolver-1.4.8-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:68269e60ee4929893aad82666821aaacbd455284124817af45c11e50a4b42e3c", size = 65071, upload-time = "2024-12-24T18:29:47.333Z" }, + { url = "https://files.pythonhosted.org/packages/f0/1c/6c86f6d85ffe4d0ce04228d976f00674f1df5dc893bf2dd4f1928748f187/kiwisolver-1.4.8-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:34d142fba9c464bc3bbfeff15c96eab0e7310343d6aefb62a79d51421fcc5f1b", size = 1378053, upload-time = "2024-12-24T18:29:49.636Z" }, + { url = "https://files.pythonhosted.org/packages/4e/b9/1c6e9f6dcb103ac5cf87cb695845f5fa71379021500153566d8a8a9fc291/kiwisolver-1.4.8-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3ddc373e0eef45b59197de815b1b28ef89ae3955e7722cc9710fb91cd77b7f47", size = 1472278, upload-time = "2024-12-24T18:29:51.164Z" }, + { url = "https://files.pythonhosted.org/packages/ee/81/aca1eb176de671f8bda479b11acdc42c132b61a2ac861c883907dde6debb/kiwisolver-1.4.8-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:77e6f57a20b9bd4e1e2cedda4d0b986ebd0216236f0106e55c28aea3d3d69b16", size = 1478139, upload-time = "2024-12-24T18:29:52.594Z" }, + { url = "https://files.pythonhosted.org/packages/49/f4/e081522473671c97b2687d380e9e4c26f748a86363ce5af48b4a28e48d06/kiwisolver-1.4.8-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:08e77738ed7538f036cd1170cbed942ef749137b1311fa2bbe2a7fda2f6bf3cc", size = 1413517, upload-time = "2024-12-24T18:29:53.941Z" }, + { url = "https://files.pythonhosted.org/packages/8f/e9/6a7d025d8da8c4931522922cd706105aa32b3291d1add8c5427cdcd66e63/kiwisolver-1.4.8-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a5ce1e481a74b44dd5e92ff03ea0cb371ae7a0268318e202be06c8f04f4f1246", size = 1474952, upload-time = "2024-12-24T18:29:56.523Z" }, + { url = "https://files.pythonhosted.org/packages/82/13/13fa685ae167bee5d94b415991c4fc7bb0a1b6ebea6e753a87044b209678/kiwisolver-1.4.8-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:fc2ace710ba7c1dfd1a3b42530b62b9ceed115f19a1656adefce7b1782a37794", size = 2269132, upload-time = "2024-12-24T18:29:57.989Z" }, + { url = "https://files.pythonhosted.org/packages/ef/92/bb7c9395489b99a6cb41d502d3686bac692586db2045adc19e45ee64ed23/kiwisolver-1.4.8-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:3452046c37c7692bd52b0e752b87954ef86ee2224e624ef7ce6cb21e8c41cc1b", size = 2425997, upload-time = "2024-12-24T18:29:59.393Z" }, + { url = "https://files.pythonhosted.org/packages/ed/12/87f0e9271e2b63d35d0d8524954145837dd1a6c15b62a2d8c1ebe0f182b4/kiwisolver-1.4.8-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:7e9a60b50fe8b2ec6f448fe8d81b07e40141bfced7f896309df271a0b92f80f3", size = 2376060, upload-time = "2024-12-24T18:30:01.338Z" }, + { url = "https://files.pythonhosted.org/packages/02/6e/c8af39288edbce8bf0fa35dee427b082758a4b71e9c91ef18fa667782138/kiwisolver-1.4.8-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:918139571133f366e8362fa4a297aeba86c7816b7ecf0bc79168080e2bd79957", size = 2520471, upload-time = "2024-12-24T18:30:04.574Z" }, + { url = "https://files.pythonhosted.org/packages/13/78/df381bc7b26e535c91469f77f16adcd073beb3e2dd25042efd064af82323/kiwisolver-1.4.8-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e063ef9f89885a1d68dd8b2e18f5ead48653176d10a0e324e3b0030e3a69adeb", size = 2338793, upload-time = "2024-12-24T18:30:06.25Z" }, + { url = "https://files.pythonhosted.org/packages/d0/dc/c1abe38c37c071d0fc71c9a474fd0b9ede05d42f5a458d584619cfd2371a/kiwisolver-1.4.8-cp313-cp313-win_amd64.whl", hash = "sha256:a17b7c4f5b2c51bb68ed379defd608a03954a1845dfed7cc0117f1cc8a9b7fd2", size = 71855, upload-time = "2024-12-24T18:30:07.535Z" }, + { url = "https://files.pythonhosted.org/packages/a0/b6/21529d595b126ac298fdd90b705d87d4c5693de60023e0efcb4f387ed99e/kiwisolver-1.4.8-cp313-cp313-win_arm64.whl", hash = "sha256:3cd3bc628b25f74aedc6d374d5babf0166a92ff1317f46267f12d2ed54bc1d30", size = 65430, upload-time = "2024-12-24T18:30:08.504Z" }, + { url = "https://files.pythonhosted.org/packages/34/bd/b89380b7298e3af9b39f49334e3e2a4af0e04819789f04b43d560516c0c8/kiwisolver-1.4.8-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:370fd2df41660ed4e26b8c9d6bbcad668fbe2560462cba151a721d49e5b6628c", size = 126294, upload-time = "2024-12-24T18:30:09.508Z" }, + { url = "https://files.pythonhosted.org/packages/83/41/5857dc72e5e4148eaac5aa76e0703e594e4465f8ab7ec0fc60e3a9bb8fea/kiwisolver-1.4.8-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:84a2f830d42707de1d191b9490ac186bf7997a9495d4e9072210a1296345f7dc", size = 67736, upload-time = "2024-12-24T18:30:11.039Z" }, + { url = "https://files.pythonhosted.org/packages/e1/d1/be059b8db56ac270489fb0b3297fd1e53d195ba76e9bbb30e5401fa6b759/kiwisolver-1.4.8-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:7a3ad337add5148cf51ce0b55642dc551c0b9d6248458a757f98796ca7348712", size = 66194, upload-time = "2024-12-24T18:30:14.886Z" }, + { url = "https://files.pythonhosted.org/packages/e1/83/4b73975f149819eb7dcf9299ed467eba068ecb16439a98990dcb12e63fdd/kiwisolver-1.4.8-cp313-cp313t-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7506488470f41169b86d8c9aeff587293f530a23a23a49d6bc64dab66bedc71e", size = 1465942, upload-time = "2024-12-24T18:30:18.927Z" }, + { url = "https://files.pythonhosted.org/packages/c7/2c/30a5cdde5102958e602c07466bce058b9d7cb48734aa7a4327261ac8e002/kiwisolver-1.4.8-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2f0121b07b356a22fb0414cec4666bbe36fd6d0d759db3d37228f496ed67c880", size = 1595341, upload-time = "2024-12-24T18:30:22.102Z" }, + { url = "https://files.pythonhosted.org/packages/ff/9b/1e71db1c000385aa069704f5990574b8244cce854ecd83119c19e83c9586/kiwisolver-1.4.8-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d6d6bd87df62c27d4185de7c511c6248040afae67028a8a22012b010bc7ad062", size = 1598455, upload-time = "2024-12-24T18:30:24.947Z" }, + { url = "https://files.pythonhosted.org/packages/85/92/c8fec52ddf06231b31cbb779af77e99b8253cd96bd135250b9498144c78b/kiwisolver-1.4.8-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:291331973c64bb9cce50bbe871fb2e675c4331dab4f31abe89f175ad7679a4d7", size = 1522138, upload-time = "2024-12-24T18:30:26.286Z" }, + { url = "https://files.pythonhosted.org/packages/0b/51/9eb7e2cd07a15d8bdd976f6190c0164f92ce1904e5c0c79198c4972926b7/kiwisolver-1.4.8-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:893f5525bb92d3d735878ec00f781b2de998333659507d29ea4466208df37bed", size = 1582857, upload-time = "2024-12-24T18:30:28.86Z" }, + { url = "https://files.pythonhosted.org/packages/0f/95/c5a00387a5405e68ba32cc64af65ce881a39b98d73cc394b24143bebc5b8/kiwisolver-1.4.8-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:b47a465040146981dc9db8647981b8cb96366fbc8d452b031e4f8fdffec3f26d", size = 2293129, upload-time = "2024-12-24T18:30:30.34Z" }, + { url = "https://files.pythonhosted.org/packages/44/83/eeb7af7d706b8347548313fa3a3a15931f404533cc54fe01f39e830dd231/kiwisolver-1.4.8-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:99cea8b9dd34ff80c521aef46a1dddb0dcc0283cf18bde6d756f1e6f31772165", size = 2421538, upload-time = "2024-12-24T18:30:33.334Z" }, + { url = "https://files.pythonhosted.org/packages/05/f9/27e94c1b3eb29e6933b6986ffc5fa1177d2cd1f0c8efc5f02c91c9ac61de/kiwisolver-1.4.8-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:151dffc4865e5fe6dafce5480fab84f950d14566c480c08a53c663a0020504b6", size = 2390661, upload-time = "2024-12-24T18:30:34.939Z" }, + { url = "https://files.pythonhosted.org/packages/d9/d4/3c9735faa36ac591a4afcc2980d2691000506050b7a7e80bcfe44048daa7/kiwisolver-1.4.8-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:577facaa411c10421314598b50413aa1ebcf5126f704f1e5d72d7e4e9f020d90", size = 2546710, upload-time = "2024-12-24T18:30:37.281Z" }, + { url = "https://files.pythonhosted.org/packages/4c/fa/be89a49c640930180657482a74970cdcf6f7072c8d2471e1babe17a222dc/kiwisolver-1.4.8-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:be4816dc51c8a471749d664161b434912eee82f2ea66bd7628bd14583a833e85", size = 2349213, upload-time = "2024-12-24T18:30:40.019Z" }, +] + +[[package]] +name = "lark" +version = "1.2.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/af/60/bc7622aefb2aee1c0b4ba23c1446d3e30225c8770b38d7aedbfb65ca9d5a/lark-1.2.2.tar.gz", hash = "sha256:ca807d0162cd16cef15a8feecb862d7319e7a09bdb13aef927968e45040fed80", size = 252132, upload-time = "2024-08-13T19:49:00.652Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2d/00/d90b10b962b4277f5e64a78b6609968859ff86889f5b898c1a778c06ec00/lark-1.2.2-py3-none-any.whl", hash = "sha256:c2276486b02f0f1b90be155f2c8ba4a8e194d42775786db622faccd652d8e80c", size = 111036, upload-time = "2024-08-13T19:48:58.603Z" }, +] + +[[package]] +name = "llama-api-client" +version = "0.1.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "distro" }, + { name = "httpx" }, + { name = "pydantic" }, + { name = "sniffio" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/d0/78/875de3a16efd0442718ac47cc27319cd80cc5f38e12298e454e08611acc4/llama_api_client-0.1.2.tar.gz", hash = "sha256:709011f2d506009b1b3b3bceea1c84f2a3a7600df1420fb256e680fcd7251387", size = 113695, upload-time = "2025-06-27T19:56:14.057Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/99/08/5d7e6e7e6af5353391376288c200acacebb8e6b156d3636eae598a451673/llama_api_client-0.1.2-py3-none-any.whl", hash = "sha256:8ad6e10726f74b2302bfd766c61c41355a9ecf60f57cde2961882d22af998941", size = 84091, upload-time = "2025-06-27T19:56:12.8Z" }, +] + +[[package]] +name = "lxml" +version = "6.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c5/ed/60eb6fa2923602fba988d9ca7c5cdbd7cf25faa795162ed538b527a35411/lxml-6.0.0.tar.gz", hash = "sha256:032e65120339d44cdc3efc326c9f660f5f7205f3a535c1fdbf898b29ea01fb72", size = 4096938, upload-time = "2025-06-26T16:28:19.373Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/89/c3/d01d735c298d7e0ddcedf6f028bf556577e5ab4f4da45175ecd909c79378/lxml-6.0.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:78718d8454a6e928470d511bf8ac93f469283a45c354995f7d19e77292f26108", size = 8429515, upload-time = "2025-06-26T16:26:06.776Z" }, + { url = "https://files.pythonhosted.org/packages/06/37/0e3eae3043d366b73da55a86274a590bae76dc45aa004b7042e6f97803b1/lxml-6.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:84ef591495ffd3f9dcabffd6391db7bb70d7230b5c35ef5148354a134f56f2be", size = 4601387, upload-time = "2025-06-26T16:26:09.511Z" }, + { url = "https://files.pythonhosted.org/packages/a3/28/e1a9a881e6d6e29dda13d633885d13acb0058f65e95da67841c8dd02b4a8/lxml-6.0.0-cp312-cp312-manylinux2010_i686.manylinux2014_i686.manylinux_2_12_i686.manylinux_2_17_i686.whl", hash = "sha256:2930aa001a3776c3e2601cb8e0a15d21b8270528d89cc308be4843ade546b9ab", size = 5228928, upload-time = "2025-06-26T16:26:12.337Z" }, + { url = "https://files.pythonhosted.org/packages/9a/55/2cb24ea48aa30c99f805921c1c7860c1f45c0e811e44ee4e6a155668de06/lxml-6.0.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:219e0431ea8006e15005767f0351e3f7f9143e793e58519dc97fe9e07fae5563", size = 4952289, upload-time = "2025-06-28T18:47:25.602Z" }, + { url = "https://files.pythonhosted.org/packages/31/c0/b25d9528df296b9a3306ba21ff982fc5b698c45ab78b94d18c2d6ae71fd9/lxml-6.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:bd5913b4972681ffc9718bc2d4c53cde39ef81415e1671ff93e9aa30b46595e7", size = 5111310, upload-time = "2025-06-28T18:47:28.136Z" }, + { url = "https://files.pythonhosted.org/packages/e9/af/681a8b3e4f668bea6e6514cbcb297beb6de2b641e70f09d3d78655f4f44c/lxml-6.0.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:390240baeb9f415a82eefc2e13285016f9c8b5ad71ec80574ae8fa9605093cd7", size = 5025457, upload-time = "2025-06-26T16:26:15.068Z" }, + { url = "https://files.pythonhosted.org/packages/99/b6/3a7971aa05b7be7dfebc7ab57262ec527775c2c3c5b2f43675cac0458cad/lxml-6.0.0-cp312-cp312-manylinux_2_27_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:d6e200909a119626744dd81bae409fc44134389e03fbf1d68ed2a55a2fb10991", size = 5657016, upload-time = "2025-07-03T19:19:06.008Z" }, + { url = "https://files.pythonhosted.org/packages/69/f8/693b1a10a891197143c0673fcce5b75fc69132afa81a36e4568c12c8faba/lxml-6.0.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ca50bd612438258a91b5b3788c6621c1f05c8c478e7951899f492be42defc0da", size = 5257565, upload-time = "2025-06-26T16:26:17.906Z" }, + { url = "https://files.pythonhosted.org/packages/a8/96/e08ff98f2c6426c98c8964513c5dab8d6eb81dadcd0af6f0c538ada78d33/lxml-6.0.0-cp312-cp312-manylinux_2_31_armv7l.whl", hash = "sha256:c24b8efd9c0f62bad0439283c2c795ef916c5a6b75f03c17799775c7ae3c0c9e", size = 4713390, upload-time = "2025-06-26T16:26:20.292Z" }, + { url = "https://files.pythonhosted.org/packages/a8/83/6184aba6cc94d7413959f6f8f54807dc318fdcd4985c347fe3ea6937f772/lxml-6.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:afd27d8629ae94c5d863e32ab0e1d5590371d296b87dae0a751fb22bf3685741", size = 5066103, upload-time = "2025-06-26T16:26:22.765Z" }, + { url = "https://files.pythonhosted.org/packages/ee/01/8bf1f4035852d0ff2e36a4d9aacdbcc57e93a6cd35a54e05fa984cdf73ab/lxml-6.0.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:54c4855eabd9fc29707d30141be99e5cd1102e7d2258d2892314cf4c110726c3", size = 4791428, upload-time = "2025-06-26T16:26:26.461Z" }, + { url = "https://files.pythonhosted.org/packages/29/31/c0267d03b16954a85ed6b065116b621d37f559553d9339c7dcc4943a76f1/lxml-6.0.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:c907516d49f77f6cd8ead1322198bdfd902003c3c330c77a1c5f3cc32a0e4d16", size = 5678523, upload-time = "2025-07-03T19:19:09.837Z" }, + { url = "https://files.pythonhosted.org/packages/5c/f7/5495829a864bc5f8b0798d2b52a807c89966523140f3d6fa3a58ab6720ea/lxml-6.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:36531f81c8214e293097cd2b7873f178997dae33d3667caaae8bdfb9666b76c0", size = 5281290, upload-time = "2025-06-26T16:26:29.406Z" }, + { url = "https://files.pythonhosted.org/packages/79/56/6b8edb79d9ed294ccc4e881f4db1023af56ba451909b9ce79f2a2cd7c532/lxml-6.0.0-cp312-cp312-win32.whl", hash = "sha256:690b20e3388a7ec98e899fd54c924e50ba6693874aa65ef9cb53de7f7de9d64a", size = 3613495, upload-time = "2025-06-26T16:26:31.588Z" }, + { url = "https://files.pythonhosted.org/packages/0b/1e/cc32034b40ad6af80b6fd9b66301fc0f180f300002e5c3eb5a6110a93317/lxml-6.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:310b719b695b3dd442cdfbbe64936b2f2e231bb91d998e99e6f0daf991a3eba3", size = 4014711, upload-time = "2025-06-26T16:26:33.723Z" }, + { url = "https://files.pythonhosted.org/packages/55/10/dc8e5290ae4c94bdc1a4c55865be7e1f31dfd857a88b21cbba68b5fea61b/lxml-6.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:8cb26f51c82d77483cdcd2b4a53cda55bbee29b3c2f3ddeb47182a2a9064e4eb", size = 3674431, upload-time = "2025-06-26T16:26:35.959Z" }, + { url = "https://files.pythonhosted.org/packages/79/21/6e7c060822a3c954ff085e5e1b94b4a25757c06529eac91e550f3f5cd8b8/lxml-6.0.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:6da7cd4f405fd7db56e51e96bff0865b9853ae70df0e6720624049da76bde2da", size = 8414372, upload-time = "2025-06-26T16:26:39.079Z" }, + { url = "https://files.pythonhosted.org/packages/a4/f6/051b1607a459db670fc3a244fa4f06f101a8adf86cda263d1a56b3a4f9d5/lxml-6.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:b34339898bb556a2351a1830f88f751679f343eabf9cf05841c95b165152c9e7", size = 4593940, upload-time = "2025-06-26T16:26:41.891Z" }, + { url = "https://files.pythonhosted.org/packages/8e/74/dd595d92a40bda3c687d70d4487b2c7eff93fd63b568acd64fedd2ba00fe/lxml-6.0.0-cp313-cp313-manylinux2010_i686.manylinux2014_i686.manylinux_2_12_i686.manylinux_2_17_i686.whl", hash = "sha256:51a5e4c61a4541bd1cd3ba74766d0c9b6c12d6a1a4964ef60026832aac8e79b3", size = 5214329, upload-time = "2025-06-26T16:26:44.669Z" }, + { url = "https://files.pythonhosted.org/packages/52/46/3572761efc1bd45fcafb44a63b3b0feeb5b3f0066886821e94b0254f9253/lxml-6.0.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d18a25b19ca7307045581b18b3ec9ead2b1db5ccd8719c291f0cd0a5cec6cb81", size = 4947559, upload-time = "2025-06-28T18:47:31.091Z" }, + { url = "https://files.pythonhosted.org/packages/94/8a/5e40de920e67c4f2eef9151097deb9b52d86c95762d8ee238134aff2125d/lxml-6.0.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d4f0c66df4386b75d2ab1e20a489f30dc7fd9a06a896d64980541506086be1f1", size = 5102143, upload-time = "2025-06-28T18:47:33.612Z" }, + { url = "https://files.pythonhosted.org/packages/7c/4b/20555bdd75d57945bdabfbc45fdb1a36a1a0ff9eae4653e951b2b79c9209/lxml-6.0.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9f4b481b6cc3a897adb4279216695150bbe7a44c03daba3c894f49d2037e0a24", size = 5021931, upload-time = "2025-06-26T16:26:47.503Z" }, + { url = "https://files.pythonhosted.org/packages/b6/6e/cf03b412f3763d4ca23b25e70c96a74cfece64cec3addf1c4ec639586b13/lxml-6.0.0-cp313-cp313-manylinux_2_27_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8a78d6c9168f5bcb20971bf3329c2b83078611fbe1f807baadc64afc70523b3a", size = 5645469, upload-time = "2025-07-03T19:19:13.32Z" }, + { url = "https://files.pythonhosted.org/packages/d4/dd/39c8507c16db6031f8c1ddf70ed95dbb0a6d466a40002a3522c128aba472/lxml-6.0.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2ae06fbab4f1bb7db4f7c8ca9897dc8db4447d1a2b9bee78474ad403437bcc29", size = 5247467, upload-time = "2025-06-26T16:26:49.998Z" }, + { url = "https://files.pythonhosted.org/packages/4d/56/732d49def0631ad633844cfb2664563c830173a98d5efd9b172e89a4800d/lxml-6.0.0-cp313-cp313-manylinux_2_31_armv7l.whl", hash = "sha256:1fa377b827ca2023244a06554c6e7dc6828a10aaf74ca41965c5d8a4925aebb4", size = 4720601, upload-time = "2025-06-26T16:26:52.564Z" }, + { url = "https://files.pythonhosted.org/packages/8f/7f/6b956fab95fa73462bca25d1ea7fc8274ddf68fb8e60b78d56c03b65278e/lxml-6.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:1676b56d48048a62ef77a250428d1f31f610763636e0784ba67a9740823988ca", size = 5060227, upload-time = "2025-06-26T16:26:55.054Z" }, + { url = "https://files.pythonhosted.org/packages/97/06/e851ac2924447e8b15a294855caf3d543424364a143c001014d22c8ca94c/lxml-6.0.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:0e32698462aacc5c1cf6bdfebc9c781821b7e74c79f13e5ffc8bfe27c42b1abf", size = 4790637, upload-time = "2025-06-26T16:26:57.384Z" }, + { url = "https://files.pythonhosted.org/packages/06/d4/fd216f3cd6625022c25b336c7570d11f4a43adbaf0a56106d3d496f727a7/lxml-6.0.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:4d6036c3a296707357efb375cfc24bb64cd955b9ec731abf11ebb1e40063949f", size = 5662049, upload-time = "2025-07-03T19:19:16.409Z" }, + { url = "https://files.pythonhosted.org/packages/52/03/0e764ce00b95e008d76b99d432f1807f3574fb2945b496a17807a1645dbd/lxml-6.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:7488a43033c958637b1a08cddc9188eb06d3ad36582cebc7d4815980b47e27ef", size = 5272430, upload-time = "2025-06-26T16:27:00.031Z" }, + { url = "https://files.pythonhosted.org/packages/5f/01/d48cc141bc47bc1644d20fe97bbd5e8afb30415ec94f146f2f76d0d9d098/lxml-6.0.0-cp313-cp313-win32.whl", hash = "sha256:5fcd7d3b1d8ecb91445bd71b9c88bdbeae528fefee4f379895becfc72298d181", size = 3612896, upload-time = "2025-06-26T16:27:04.251Z" }, + { url = "https://files.pythonhosted.org/packages/f4/87/6456b9541d186ee7d4cb53bf1b9a0d7f3b1068532676940fdd594ac90865/lxml-6.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:2f34687222b78fff795feeb799a7d44eca2477c3d9d3a46ce17d51a4f383e32e", size = 4013132, upload-time = "2025-06-26T16:27:06.415Z" }, + { url = "https://files.pythonhosted.org/packages/b7/42/85b3aa8f06ca0d24962f8100f001828e1f1f1a38c954c16e71154ed7d53a/lxml-6.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:21db1ec5525780fd07251636eb5f7acb84003e9382c72c18c542a87c416ade03", size = 3672642, upload-time = "2025-06-26T16:27:09.888Z" }, +] + +[[package]] +name = "markupsafe" +version = "3.0.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b2/97/5d42485e71dfc078108a86d6de8fa46db44a1a9295e89c5d6d4a06e23a62/markupsafe-3.0.2.tar.gz", hash = "sha256:ee55d3edf80167e48ea11a923c7386f4669df67d7994554387f84e7d8b0a2bf0", size = 20537, upload-time = "2024-10-18T15:21:54.129Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/22/09/d1f21434c97fc42f09d290cbb6350d44eb12f09cc62c9476effdb33a18aa/MarkupSafe-3.0.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:9778bd8ab0a994ebf6f84c2b949e65736d5575320a17ae8984a77fab08db94cf", size = 14274, upload-time = "2024-10-18T15:21:13.777Z" }, + { url = "https://files.pythonhosted.org/packages/6b/b0/18f76bba336fa5aecf79d45dcd6c806c280ec44538b3c13671d49099fdd0/MarkupSafe-3.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:846ade7b71e3536c4e56b386c2a47adf5741d2d8b94ec9dc3e92e5e1ee1e2225", size = 12348, upload-time = "2024-10-18T15:21:14.822Z" }, + { url = "https://files.pythonhosted.org/packages/e0/25/dd5c0f6ac1311e9b40f4af06c78efde0f3b5cbf02502f8ef9501294c425b/MarkupSafe-3.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1c99d261bd2d5f6b59325c92c73df481e05e57f19837bdca8413b9eac4bd8028", size = 24149, upload-time = "2024-10-18T15:21:15.642Z" }, + { url = "https://files.pythonhosted.org/packages/f3/f0/89e7aadfb3749d0f52234a0c8c7867877876e0a20b60e2188e9850794c17/MarkupSafe-3.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e17c96c14e19278594aa4841ec148115f9c7615a47382ecb6b82bd8fea3ab0c8", size = 23118, upload-time = "2024-10-18T15:21:17.133Z" }, + { url = "https://files.pythonhosted.org/packages/d5/da/f2eeb64c723f5e3777bc081da884b414671982008c47dcc1873d81f625b6/MarkupSafe-3.0.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:88416bd1e65dcea10bc7569faacb2c20ce071dd1f87539ca2ab364bf6231393c", size = 22993, upload-time = "2024-10-18T15:21:18.064Z" }, + { url = "https://files.pythonhosted.org/packages/da/0e/1f32af846df486dce7c227fe0f2398dc7e2e51d4a370508281f3c1c5cddc/MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2181e67807fc2fa785d0592dc2d6206c019b9502410671cc905d132a92866557", size = 24178, upload-time = "2024-10-18T15:21:18.859Z" }, + { url = "https://files.pythonhosted.org/packages/c4/f6/bb3ca0532de8086cbff5f06d137064c8410d10779c4c127e0e47d17c0b71/MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:52305740fe773d09cffb16f8ed0427942901f00adedac82ec8b67752f58a1b22", size = 23319, upload-time = "2024-10-18T15:21:19.671Z" }, + { url = "https://files.pythonhosted.org/packages/a2/82/8be4c96ffee03c5b4a034e60a31294daf481e12c7c43ab8e34a1453ee48b/MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ad10d3ded218f1039f11a75f8091880239651b52e9bb592ca27de44eed242a48", size = 23352, upload-time = "2024-10-18T15:21:20.971Z" }, + { url = "https://files.pythonhosted.org/packages/51/ae/97827349d3fcffee7e184bdf7f41cd6b88d9919c80f0263ba7acd1bbcb18/MarkupSafe-3.0.2-cp312-cp312-win32.whl", hash = "sha256:0f4ca02bea9a23221c0182836703cbf8930c5e9454bacce27e767509fa286a30", size = 15097, upload-time = "2024-10-18T15:21:22.646Z" }, + { url = "https://files.pythonhosted.org/packages/c1/80/a61f99dc3a936413c3ee4e1eecac96c0da5ed07ad56fd975f1a9da5bc630/MarkupSafe-3.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:8e06879fc22a25ca47312fbe7c8264eb0b662f6db27cb2d3bbbc74b1df4b9b87", size = 15601, upload-time = "2024-10-18T15:21:23.499Z" }, + { url = "https://files.pythonhosted.org/packages/83/0e/67eb10a7ecc77a0c2bbe2b0235765b98d164d81600746914bebada795e97/MarkupSafe-3.0.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ba9527cdd4c926ed0760bc301f6728ef34d841f405abf9d4f959c478421e4efd", size = 14274, upload-time = "2024-10-18T15:21:24.577Z" }, + { url = "https://files.pythonhosted.org/packages/2b/6d/9409f3684d3335375d04e5f05744dfe7e9f120062c9857df4ab490a1031a/MarkupSafe-3.0.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f8b3d067f2e40fe93e1ccdd6b2e1d16c43140e76f02fb1319a05cf2b79d99430", size = 12352, upload-time = "2024-10-18T15:21:25.382Z" }, + { url = "https://files.pythonhosted.org/packages/d2/f5/6eadfcd3885ea85fe2a7c128315cc1bb7241e1987443d78c8fe712d03091/MarkupSafe-3.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:569511d3b58c8791ab4c2e1285575265991e6d8f8700c7be0e88f86cb0672094", size = 24122, upload-time = "2024-10-18T15:21:26.199Z" }, + { url = "https://files.pythonhosted.org/packages/0c/91/96cf928db8236f1bfab6ce15ad070dfdd02ed88261c2afafd4b43575e9e9/MarkupSafe-3.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:15ab75ef81add55874e7ab7055e9c397312385bd9ced94920f2802310c930396", size = 23085, upload-time = "2024-10-18T15:21:27.029Z" }, + { url = "https://files.pythonhosted.org/packages/c2/cf/c9d56af24d56ea04daae7ac0940232d31d5a8354f2b457c6d856b2057d69/MarkupSafe-3.0.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f3818cb119498c0678015754eba762e0d61e5b52d34c8b13d770f0719f7b1d79", size = 22978, upload-time = "2024-10-18T15:21:27.846Z" }, + { url = "https://files.pythonhosted.org/packages/2a/9f/8619835cd6a711d6272d62abb78c033bda638fdc54c4e7f4272cf1c0962b/MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:cdb82a876c47801bb54a690c5ae105a46b392ac6099881cdfb9f6e95e4014c6a", size = 24208, upload-time = "2024-10-18T15:21:28.744Z" }, + { url = "https://files.pythonhosted.org/packages/f9/bf/176950a1792b2cd2102b8ffeb5133e1ed984547b75db47c25a67d3359f77/MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:cabc348d87e913db6ab4aa100f01b08f481097838bdddf7c7a84b7575b7309ca", size = 23357, upload-time = "2024-10-18T15:21:29.545Z" }, + { url = "https://files.pythonhosted.org/packages/ce/4f/9a02c1d335caabe5c4efb90e1b6e8ee944aa245c1aaaab8e8a618987d816/MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:444dcda765c8a838eaae23112db52f1efaf750daddb2d9ca300bcae1039adc5c", size = 23344, upload-time = "2024-10-18T15:21:30.366Z" }, + { url = "https://files.pythonhosted.org/packages/ee/55/c271b57db36f748f0e04a759ace9f8f759ccf22b4960c270c78a394f58be/MarkupSafe-3.0.2-cp313-cp313-win32.whl", hash = "sha256:bcf3e58998965654fdaff38e58584d8937aa3096ab5354d493c77d1fdd66d7a1", size = 15101, upload-time = "2024-10-18T15:21:31.207Z" }, + { url = "https://files.pythonhosted.org/packages/29/88/07df22d2dd4df40aba9f3e402e6dc1b8ee86297dddbad4872bd5e7b0094f/MarkupSafe-3.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:e6a2a455bd412959b57a172ce6328d2dd1f01cb2135efda2e4576e8a23fa3b0f", size = 15603, upload-time = "2024-10-18T15:21:32.032Z" }, + { url = "https://files.pythonhosted.org/packages/62/6a/8b89d24db2d32d433dffcd6a8779159da109842434f1dd2f6e71f32f738c/MarkupSafe-3.0.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:b5a6b3ada725cea8a5e634536b1b01c30bcdcd7f9c6fff4151548d5bf6b3a36c", size = 14510, upload-time = "2024-10-18T15:21:33.625Z" }, + { url = "https://files.pythonhosted.org/packages/7a/06/a10f955f70a2e5a9bf78d11a161029d278eeacbd35ef806c3fd17b13060d/MarkupSafe-3.0.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:a904af0a6162c73e3edcb969eeeb53a63ceeb5d8cf642fade7d39e7963a22ddb", size = 12486, upload-time = "2024-10-18T15:21:34.611Z" }, + { url = "https://files.pythonhosted.org/packages/34/cf/65d4a571869a1a9078198ca28f39fba5fbb910f952f9dbc5220afff9f5e6/MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4aa4e5faecf353ed117801a068ebab7b7e09ffb6e1d5e412dc852e0da018126c", size = 25480, upload-time = "2024-10-18T15:21:35.398Z" }, + { url = "https://files.pythonhosted.org/packages/0c/e3/90e9651924c430b885468b56b3d597cabf6d72be4b24a0acd1fa0e12af67/MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c0ef13eaeee5b615fb07c9a7dadb38eac06a0608b41570d8ade51c56539e509d", size = 23914, upload-time = "2024-10-18T15:21:36.231Z" }, + { url = "https://files.pythonhosted.org/packages/66/8c/6c7cf61f95d63bb866db39085150df1f2a5bd3335298f14a66b48e92659c/MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d16a81a06776313e817c951135cf7340a3e91e8c1ff2fac444cfd75fffa04afe", size = 23796, upload-time = "2024-10-18T15:21:37.073Z" }, + { url = "https://files.pythonhosted.org/packages/bb/35/cbe9238ec3f47ac9a7c8b3df7a808e7cb50fe149dc7039f5f454b3fba218/MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:6381026f158fdb7c72a168278597a5e3a5222e83ea18f543112b2662a9b699c5", size = 25473, upload-time = "2024-10-18T15:21:37.932Z" }, + { url = "https://files.pythonhosted.org/packages/e6/32/7621a4382488aa283cc05e8984a9c219abad3bca087be9ec77e89939ded9/MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:3d79d162e7be8f996986c064d1c7c817f6df3a77fe3d6859f6f9e7be4b8c213a", size = 24114, upload-time = "2024-10-18T15:21:39.799Z" }, + { url = "https://files.pythonhosted.org/packages/0d/80/0985960e4b89922cb5a0bac0ed39c5b96cbc1a536a99f30e8c220a996ed9/MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:131a3c7689c85f5ad20f9f6fb1b866f402c445b220c19fe4308c0b147ccd2ad9", size = 24098, upload-time = "2024-10-18T15:21:40.813Z" }, + { url = "https://files.pythonhosted.org/packages/82/78/fedb03c7d5380df2427038ec8d973587e90561b2d90cd472ce9254cf348b/MarkupSafe-3.0.2-cp313-cp313t-win32.whl", hash = "sha256:ba8062ed2cf21c07a9e295d5b8a2a5ce678b913b45fdf68c32d95d6c1291e0b6", size = 15208, upload-time = "2024-10-18T15:21:41.814Z" }, + { url = "https://files.pythonhosted.org/packages/4f/65/6079a46068dfceaeabb5dcad6d674f5f5c61a6fa5673746f42a9f4c233b3/MarkupSafe-3.0.2-cp313-cp313t-win_amd64.whl", hash = "sha256:e444a31f8db13eb18ada366ab3cf45fd4b31e4db1236a4448f68778c1d1a5a2f", size = 15739, upload-time = "2024-10-18T15:21:42.784Z" }, +] + +[[package]] +name = "matplotlib" +version = "3.10.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "contourpy" }, + { name = "cycler" }, + { name = "fonttools" }, + { name = "kiwisolver" }, + { name = "numpy" }, + { name = "packaging" }, + { name = "pillow" }, + { name = "pyparsing" }, + { name = "python-dateutil" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/43/91/f2939bb60b7ebf12478b030e0d7f340247390f402b3b189616aad790c366/matplotlib-3.10.5.tar.gz", hash = "sha256:352ed6ccfb7998a00881692f38b4ca083c691d3e275b4145423704c34c909076", size = 34804044, upload-time = "2025-07-31T18:09:33.805Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/66/1e/c6f6bcd882d589410b475ca1fc22e34e34c82adff519caf18f3e6dd9d682/matplotlib-3.10.5-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:00b6feadc28a08bd3c65b2894f56cf3c94fc8f7adcbc6ab4516ae1e8ed8f62e2", size = 8253056, upload-time = "2025-07-31T18:08:05.385Z" }, + { url = "https://files.pythonhosted.org/packages/53/e6/d6f7d1b59413f233793dda14419776f5f443bcccb2dfc84b09f09fe05dbe/matplotlib-3.10.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ee98a5c5344dc7f48dc261b6ba5d9900c008fc12beb3fa6ebda81273602cc389", size = 8110131, upload-time = "2025-07-31T18:08:07.293Z" }, + { url = "https://files.pythonhosted.org/packages/66/2b/bed8a45e74957549197a2ac2e1259671cd80b55ed9e1fe2b5c94d88a9202/matplotlib-3.10.5-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a17e57e33de901d221a07af32c08870ed4528db0b6059dce7d7e65c1122d4bea", size = 8669603, upload-time = "2025-07-31T18:08:09.064Z" }, + { url = "https://files.pythonhosted.org/packages/7e/a7/315e9435b10d057f5e52dfc603cd353167ae28bb1a4e033d41540c0067a4/matplotlib-3.10.5-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:97b9d6443419085950ee4a5b1ee08c363e5c43d7176e55513479e53669e88468", size = 9508127, upload-time = "2025-07-31T18:08:10.845Z" }, + { url = "https://files.pythonhosted.org/packages/7f/d9/edcbb1f02ca99165365d2768d517898c22c6040187e2ae2ce7294437c413/matplotlib-3.10.5-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ceefe5d40807d29a66ae916c6a3915d60ef9f028ce1927b84e727be91d884369", size = 9566926, upload-time = "2025-07-31T18:08:13.186Z" }, + { url = "https://files.pythonhosted.org/packages/3b/d9/6dd924ad5616c97b7308e6320cf392c466237a82a2040381163b7500510a/matplotlib-3.10.5-cp312-cp312-win_amd64.whl", hash = "sha256:c04cba0f93d40e45b3c187c6c52c17f24535b27d545f757a2fffebc06c12b98b", size = 8107599, upload-time = "2025-07-31T18:08:15.116Z" }, + { url = "https://files.pythonhosted.org/packages/0e/f3/522dc319a50f7b0279fbe74f86f7a3506ce414bc23172098e8d2bdf21894/matplotlib-3.10.5-cp312-cp312-win_arm64.whl", hash = "sha256:a41bcb6e2c8e79dc99c5511ae6f7787d2fb52efd3d805fff06d5d4f667db16b2", size = 7978173, upload-time = "2025-07-31T18:08:21.518Z" }, + { url = "https://files.pythonhosted.org/packages/8d/05/4f3c1f396075f108515e45cb8d334aff011a922350e502a7472e24c52d77/matplotlib-3.10.5-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:354204db3f7d5caaa10e5de74549ef6a05a4550fdd1c8f831ab9bca81efd39ed", size = 8253586, upload-time = "2025-07-31T18:08:23.107Z" }, + { url = "https://files.pythonhosted.org/packages/2f/2c/e084415775aac7016c3719fe7006cdb462582c6c99ac142f27303c56e243/matplotlib-3.10.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:b072aac0c3ad563a2b3318124756cb6112157017f7431626600ecbe890df57a1", size = 8110715, upload-time = "2025-07-31T18:08:24.675Z" }, + { url = "https://files.pythonhosted.org/packages/52/1b/233e3094b749df16e3e6cd5a44849fd33852e692ad009cf7de00cf58ddf6/matplotlib-3.10.5-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d52fd5b684d541b5a51fb276b2b97b010c75bee9aa392f96b4a07aeb491e33c7", size = 8669397, upload-time = "2025-07-31T18:08:26.778Z" }, + { url = "https://files.pythonhosted.org/packages/e8/ec/03f9e003a798f907d9f772eed9b7c6a9775d5bd00648b643ebfb88e25414/matplotlib-3.10.5-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee7a09ae2f4676276f5a65bd9f2bd91b4f9fbaedf49f40267ce3f9b448de501f", size = 9508646, upload-time = "2025-07-31T18:08:28.848Z" }, + { url = "https://files.pythonhosted.org/packages/91/e7/c051a7a386680c28487bca27d23b02d84f63e3d2a9b4d2fc478e6a42e37e/matplotlib-3.10.5-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ba6c3c9c067b83481d647af88b4e441d532acdb5ef22178a14935b0b881188f4", size = 9567424, upload-time = "2025-07-31T18:08:30.726Z" }, + { url = "https://files.pythonhosted.org/packages/36/c2/24302e93ff431b8f4173ee1dd88976c8d80483cadbc5d3d777cef47b3a1c/matplotlib-3.10.5-cp313-cp313-win_amd64.whl", hash = "sha256:07442d2692c9bd1cceaa4afb4bbe5b57b98a7599de4dabfcca92d3eea70f9ebe", size = 8107809, upload-time = "2025-07-31T18:08:33.928Z" }, + { url = "https://files.pythonhosted.org/packages/0b/33/423ec6a668d375dad825197557ed8fbdb74d62b432c1ed8235465945475f/matplotlib-3.10.5-cp313-cp313-win_arm64.whl", hash = "sha256:48fe6d47380b68a37ccfcc94f009530e84d41f71f5dae7eda7c4a5a84aa0a674", size = 7978078, upload-time = "2025-07-31T18:08:36.764Z" }, + { url = "https://files.pythonhosted.org/packages/51/17/521fc16ec766455c7bb52cc046550cf7652f6765ca8650ff120aa2d197b6/matplotlib-3.10.5-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:3b80eb8621331449fc519541a7461987f10afa4f9cfd91afcd2276ebe19bd56c", size = 8295590, upload-time = "2025-07-31T18:08:38.521Z" }, + { url = "https://files.pythonhosted.org/packages/f8/12/23c28b2c21114c63999bae129fce7fd34515641c517ae48ce7b7dcd33458/matplotlib-3.10.5-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:47a388908e469d6ca2a6015858fa924e0e8a2345a37125948d8e93a91c47933e", size = 8158518, upload-time = "2025-07-31T18:08:40.195Z" }, + { url = "https://files.pythonhosted.org/packages/81/f8/aae4eb25e8e7190759f3cb91cbeaa344128159ac92bb6b409e24f8711f78/matplotlib-3.10.5-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8b6b49167d208358983ce26e43aa4196073b4702858670f2eb111f9a10652b4b", size = 8691815, upload-time = "2025-07-31T18:08:42.238Z" }, + { url = "https://files.pythonhosted.org/packages/d0/ba/450c39ebdd486bd33a359fc17365ade46c6a96bf637bbb0df7824de2886c/matplotlib-3.10.5-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8a8da0453a7fd8e3da114234ba70c5ba9ef0e98f190309ddfde0f089accd46ea", size = 9522814, upload-time = "2025-07-31T18:08:44.914Z" }, + { url = "https://files.pythonhosted.org/packages/89/11/9c66f6a990e27bb9aa023f7988d2d5809cb98aa39c09cbf20fba75a542ef/matplotlib-3.10.5-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:52c6573dfcb7726a9907b482cd5b92e6b5499b284ffacb04ffbfe06b3e568124", size = 9573917, upload-time = "2025-07-31T18:08:47.038Z" }, + { url = "https://files.pythonhosted.org/packages/b3/69/8b49394de92569419e5e05e82e83df9b749a0ff550d07631ea96ed2eb35a/matplotlib-3.10.5-cp313-cp313t-win_amd64.whl", hash = "sha256:a23193db2e9d64ece69cac0c8231849db7dd77ce59c7b89948cf9d0ce655a3ce", size = 8181034, upload-time = "2025-07-31T18:08:48.943Z" }, + { url = "https://files.pythonhosted.org/packages/47/23/82dc435bb98a2fc5c20dffcac8f0b083935ac28286413ed8835df40d0baa/matplotlib-3.10.5-cp313-cp313t-win_arm64.whl", hash = "sha256:56da3b102cf6da2776fef3e71cd96fcf22103a13594a18ac9a9b31314e0be154", size = 8023337, upload-time = "2025-07-31T18:08:50.791Z" }, + { url = "https://files.pythonhosted.org/packages/ac/e0/26b6cfde31f5383503ee45dcb7e691d45dadf0b3f54639332b59316a97f8/matplotlib-3.10.5-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:96ef8f5a3696f20f55597ffa91c28e2e73088df25c555f8d4754931515512715", size = 8253591, upload-time = "2025-07-31T18:08:53.254Z" }, + { url = "https://files.pythonhosted.org/packages/c1/89/98488c7ef7ea20ea659af7499628c240a608b337af4be2066d644cfd0a0f/matplotlib-3.10.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:77fab633e94b9da60512d4fa0213daeb76d5a7b05156840c4fd0399b4b818837", size = 8112566, upload-time = "2025-07-31T18:08:55.116Z" }, + { url = "https://files.pythonhosted.org/packages/52/67/42294dfedc82aea55e1a767daf3263aacfb5a125f44ba189e685bab41b6f/matplotlib-3.10.5-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:27f52634315e96b1debbfdc5c416592edcd9c4221bc2f520fd39c33db5d9f202", size = 9513281, upload-time = "2025-07-31T18:08:56.885Z" }, + { url = "https://files.pythonhosted.org/packages/e7/68/f258239e0cf34c2cbc816781c7ab6fca768452e6bf1119aedd2bd4a882a3/matplotlib-3.10.5-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:525f6e28c485c769d1f07935b660c864de41c37fd716bfa64158ea646f7084bb", size = 9780873, upload-time = "2025-07-31T18:08:59.241Z" }, + { url = "https://files.pythonhosted.org/packages/89/64/f4881554006bd12e4558bd66778bdd15d47b00a1f6c6e8b50f6208eda4b3/matplotlib-3.10.5-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:1f5f3ec4c191253c5f2b7c07096a142c6a1c024d9f738247bfc8e3f9643fc975", size = 9568954, upload-time = "2025-07-31T18:09:01.244Z" }, + { url = "https://files.pythonhosted.org/packages/06/f8/42779d39c3f757e1f012f2dda3319a89fb602bd2ef98ce8faf0281f4febd/matplotlib-3.10.5-cp314-cp314-win_amd64.whl", hash = "sha256:707f9c292c4cd4716f19ab8a1f93f26598222cd931e0cd98fbbb1c5994bf7667", size = 8237465, upload-time = "2025-07-31T18:09:03.206Z" }, + { url = "https://files.pythonhosted.org/packages/cf/f8/153fd06b5160f0cd27c8b9dd797fcc9fb56ac6a0ebf3c1f765b6b68d3c8a/matplotlib-3.10.5-cp314-cp314-win_arm64.whl", hash = "sha256:21a95b9bf408178d372814de7baacd61c712a62cae560b5e6f35d791776f6516", size = 8108898, upload-time = "2025-07-31T18:09:05.231Z" }, + { url = "https://files.pythonhosted.org/packages/9a/ee/c4b082a382a225fe0d2a73f1f57cf6f6f132308805b493a54c8641006238/matplotlib-3.10.5-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:a6b310f95e1102a8c7c817ef17b60ee5d1851b8c71b63d9286b66b177963039e", size = 8295636, upload-time = "2025-07-31T18:09:07.306Z" }, + { url = "https://files.pythonhosted.org/packages/30/73/2195fa2099718b21a20da82dfc753bf2af58d596b51aefe93e359dd5915a/matplotlib-3.10.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:94986a242747a0605cb3ff1cb98691c736f28a59f8ffe5175acaeb7397c49a5a", size = 8158575, upload-time = "2025-07-31T18:09:09.083Z" }, + { url = "https://files.pythonhosted.org/packages/f6/e9/a08cdb34618a91fa08f75e6738541da5cacde7c307cea18ff10f0d03fcff/matplotlib-3.10.5-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1ff10ea43288f0c8bab608a305dc6c918cc729d429c31dcbbecde3b9f4d5b569", size = 9522815, upload-time = "2025-07-31T18:09:11.191Z" }, + { url = "https://files.pythonhosted.org/packages/4e/bb/34d8b7e0d1bb6d06ef45db01dfa560d5a67b1c40c0b998ce9ccde934bb09/matplotlib-3.10.5-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f6adb644c9d040ffb0d3434e440490a66cf73dbfa118a6f79cd7568431f7a012", size = 9783514, upload-time = "2025-07-31T18:09:13.307Z" }, + { url = "https://files.pythonhosted.org/packages/12/09/d330d1e55dcca2e11b4d304cc5227f52e2512e46828d6249b88e0694176e/matplotlib-3.10.5-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:4fa40a8f98428f789a9dcacd625f59b7bc4e3ef6c8c7c80187a7a709475cf592", size = 9573932, upload-time = "2025-07-31T18:09:15.335Z" }, + { url = "https://files.pythonhosted.org/packages/eb/3b/f70258ac729aa004aca673800a53a2b0a26d49ca1df2eaa03289a1c40f81/matplotlib-3.10.5-cp314-cp314t-win_amd64.whl", hash = "sha256:95672a5d628b44207aab91ec20bf59c26da99de12b88f7e0b1fb0a84a86ff959", size = 8322003, upload-time = "2025-07-31T18:09:17.416Z" }, + { url = "https://files.pythonhosted.org/packages/5b/60/3601f8ce6d76a7c81c7f25a0e15fde0d6b66226dd187aa6d2838e6374161/matplotlib-3.10.5-cp314-cp314t-win_arm64.whl", hash = "sha256:2efaf97d72629e74252e0b5e3c46813e9eeaa94e011ecf8084a971a31a97f40b", size = 8153849, upload-time = "2025-07-31T18:09:19.673Z" }, +] + +[[package]] +name = "matplotlib-inline" +version = "0.1.7" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/99/5b/a36a337438a14116b16480db471ad061c36c3694df7c2084a0da7ba538b7/matplotlib_inline-0.1.7.tar.gz", hash = "sha256:8423b23ec666be3d16e16b60bdd8ac4e86e840ebd1dd11a30b9f117f2fa0ab90", size = 8159, upload-time = "2024-04-15T13:44:44.803Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8f/8e/9ad090d3553c280a8060fbf6e24dc1c0c29704ee7d1c372f0c174aa59285/matplotlib_inline-0.1.7-py3-none-any.whl", hash = "sha256:df192d39a4ff8f21b1895d72e6a13f5fcc5099f00fa84384e0ea28c2cc0653ca", size = 9899, upload-time = "2024-04-15T13:44:43.265Z" }, +] + +[[package]] +name = "memory-profiler" +version = "0.61.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "psutil" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b2/88/e1907e1ca3488f2d9507ca8b0ae1add7b1cd5d3ca2bc8e5b329382ea2c7b/memory_profiler-0.61.0.tar.gz", hash = "sha256:4e5b73d7864a1d1292fb76a03e82a3e78ef934d06828a698d9dada76da2067b0", size = 35935, upload-time = "2022-11-15T17:57:28.994Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/49/26/aaca612a0634ceede20682e692a6c55e35a94c21ba36b807cc40fe910ae1/memory_profiler-0.61.0-py3-none-any.whl", hash = "sha256:400348e61031e3942ad4d4109d18753b2fb08c2f6fb8290671c5513a34182d84", size = 31803, upload-time = "2022-11-15T17:57:27.031Z" }, +] + +[[package]] +name = "mistune" +version = "3.1.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c4/79/bda47f7dd7c3c55770478d6d02c9960c430b0cf1773b72366ff89126ea31/mistune-3.1.3.tar.gz", hash = "sha256:a7035c21782b2becb6be62f8f25d3df81ccb4d6fa477a6525b15af06539f02a0", size = 94347, upload-time = "2025-03-19T14:27:24.955Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/01/4d/23c4e4f09da849e127e9f123241946c23c1e30f45a88366879e064211815/mistune-3.1.3-py3-none-any.whl", hash = "sha256:1a32314113cff28aa6432e99e522677c8587fd83e3d51c29b82a52409c842bd9", size = 53410, upload-time = "2025-03-19T14:27:23.451Z" }, +] + +[[package]] +name = "mpmath" +version = "1.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e0/47/dd32fa426cc72114383ac549964eecb20ecfd886d1e5ccf5340b55b02f57/mpmath-1.3.0.tar.gz", hash = "sha256:7a28eb2a9774d00c7bc92411c19a89209d5da7c4c9a9e227be8330a23a25b91f", size = 508106, upload-time = "2023-03-07T16:47:11.061Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/43/e3/7d92a15f894aa0c9c4b49b8ee9ac9850d6e63b03c9c32c0367a13ae62209/mpmath-1.3.0-py3-none-any.whl", hash = "sha256:a0b2b9fe80bbcd81a6647ff13108738cfb482d481d826cc0e02f5b35e5c88d2c", size = 536198, upload-time = "2023-03-07T16:47:09.197Z" }, +] + +[[package]] +name = "nbclient" +version = "0.10.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "nbformat" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/87/66/7ffd18d58eae90d5721f9f39212327695b749e23ad44b3881744eaf4d9e8/nbclient-0.10.2.tar.gz", hash = "sha256:90b7fc6b810630db87a6d0c2250b1f0ab4cf4d3c27a299b0cde78a4ed3fd9193", size = 62424, upload-time = "2024-12-19T10:32:27.164Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/34/6d/e7fa07f03a4a7b221d94b4d586edb754a9b0dc3c9e2c93353e9fa4e0d117/nbclient-0.10.2-py3-none-any.whl", hash = "sha256:4ffee11e788b4a27fabeb7955547e4318a5298f34342a4bfd01f2e1faaeadc3d", size = 25434, upload-time = "2024-12-19T10:32:24.139Z" }, +] + +[[package]] +name = "nbconvert" +version = "7.16.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "beautifulsoup4" }, + { name = "bleach", extra = ["css"] }, + { name = "defusedxml" }, + { name = "jinja2" }, + { name = "jupyter-core" }, + { name = "jupyterlab-pygments" }, + { name = "markupsafe" }, + { name = "mistune" }, + { name = "nbclient" }, + { name = "nbformat" }, + { name = "packaging" }, + { name = "pandocfilters" }, + { name = "pygments" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a3/59/f28e15fc47ffb73af68a8d9b47367a8630d76e97ae85ad18271b9db96fdf/nbconvert-7.16.6.tar.gz", hash = "sha256:576a7e37c6480da7b8465eefa66c17844243816ce1ccc372633c6b71c3c0f582", size = 857715, upload-time = "2025-01-28T09:29:14.724Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cc/9a/cd673b2f773a12c992f41309ef81b99da1690426bd2f96957a7ade0d3ed7/nbconvert-7.16.6-py3-none-any.whl", hash = "sha256:1375a7b67e0c2883678c48e506dc320febb57685e5ee67faa51b18a90f3a712b", size = 258525, upload-time = "2025-01-28T09:29:12.551Z" }, +] + +[[package]] +name = "nbformat" +version = "5.10.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "fastjsonschema" }, + { name = "jsonschema" }, + { name = "jupyter-core" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6d/fd/91545e604bc3dad7dca9ed03284086039b294c6b3d75c0d2fa45f9e9caf3/nbformat-5.10.4.tar.gz", hash = "sha256:322168b14f937a5d11362988ecac2a4952d3d8e3a2cbeb2319584631226d5b3a", size = 142749, upload-time = "2024-04-04T11:20:37.371Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a9/82/0340caa499416c78e5d8f5f05947ae4bc3cba53c9f038ab6e9ed964e22f1/nbformat-5.10.4-py3-none-any.whl", hash = "sha256:3b48d6c8fbca4b299bf3982ea7db1af21580e4fec269ad087b9e81588891200b", size = 78454, upload-time = "2024-04-04T11:20:34.895Z" }, +] + +[[package]] +name = "nest-asyncio" +version = "1.6.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/83/f8/51569ac65d696c8ecbee95938f89d4abf00f47d58d48f6fbabfe8f0baefe/nest_asyncio-1.6.0.tar.gz", hash = "sha256:6f172d5449aca15afd6c646851f4e31e02c598d553a667e38cafa997cfec55fe", size = 7418, upload-time = "2024-01-21T14:25:19.227Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a0/c4/c2971a3ba4c6103a3d10c4b0f24f461ddc027f0f09763220cf35ca1401b3/nest_asyncio-1.6.0-py3-none-any.whl", hash = "sha256:87af6efd6b5e897c81050477ef65c62e2b2f35d51703cae01aff2905b1852e1c", size = 5195, upload-time = "2024-01-21T14:25:17.223Z" }, +] + +[[package]] +name = "networkx" +version = "3.5" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6c/4f/ccdb8ad3a38e583f214547fd2f7ff1fc160c43a75af88e6aec213404b96a/networkx-3.5.tar.gz", hash = "sha256:d4c6f9cf81f52d69230866796b82afbccdec3db7ae4fbd1b65ea750feed50037", size = 2471065, upload-time = "2025-05-29T11:35:07.804Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/eb/8d/776adee7bbf76365fdd7f2552710282c79a4ead5d2a46408c9043a2b70ba/networkx-3.5-py3-none-any.whl", hash = "sha256:0030d386a9a06dee3565298b4a734b68589749a544acbb6c412dc9e2489ec6ec", size = 2034406, upload-time = "2025-05-29T11:35:04.961Z" }, +] + +[[package]] +name = "notebook" +version = "7.4.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-server" }, + { name = "jupyterlab" }, + { name = "jupyterlab-server" }, + { name = "notebook-shim" }, + { name = "tornado" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9f/21/9669982f9569e7478763837e0d35b9fd9f43de0eb5ab5d6ca620b8019cfc/notebook-7.4.5.tar.gz", hash = "sha256:7c2c4ea245913c3ad8ab3e5d36b34a842c06e524556f5c2e1f5d7d08c986615e", size = 13888993, upload-time = "2025-08-05T07:40:56.529Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fe/c7/207fd1138bd82435d13b6d8640a240be4d855b8ddb41f6bf31aca5be64df/notebook-7.4.5-py3-none-any.whl", hash = "sha256:351635461aca9dad08cf8946a4216f963e2760cc1bf7b1aaaecb23afc33ec046", size = 14295193, upload-time = "2025-08-05T07:40:52.586Z" }, +] + +[[package]] +name = "notebook-shim" +version = "0.2.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-server" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/54/d2/92fa3243712b9a3e8bafaf60aac366da1cada3639ca767ff4b5b3654ec28/notebook_shim-0.2.4.tar.gz", hash = "sha256:b4b2cfa1b65d98307ca24361f5b30fe785b53c3fd07b7a47e89acb5e6ac638cb", size = 13167, upload-time = "2024-02-14T23:35:18.353Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f9/33/bd5b9137445ea4b680023eb0469b2bb969d61303dedb2aac6560ff3d14a1/notebook_shim-0.2.4-py3-none-any.whl", hash = "sha256:411a5be4e9dc882a074ccbcae671eda64cceb068767e9a3419096986560e1cef", size = 13307, upload-time = "2024-02-14T23:35:16.286Z" }, +] + +[[package]] +name = "numpy" +version = "2.3.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/37/7d/3fec4199c5ffb892bed55cff901e4f39a58c81df9c44c280499e92cad264/numpy-2.3.2.tar.gz", hash = "sha256:e0486a11ec30cdecb53f184d496d1c6a20786c81e55e41640270130056f8ee48", size = 20489306, upload-time = "2025-07-24T21:32:07.553Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/00/6d/745dd1c1c5c284d17725e5c802ca4d45cfc6803519d777f087b71c9f4069/numpy-2.3.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:bc3186bea41fae9d8e90c2b4fb5f0a1f5a690682da79b92574d63f56b529080b", size = 20956420, upload-time = "2025-07-24T20:28:18.002Z" }, + { url = "https://files.pythonhosted.org/packages/bc/96/e7b533ea5740641dd62b07a790af5d9d8fec36000b8e2d0472bd7574105f/numpy-2.3.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2f4f0215edb189048a3c03bd5b19345bdfa7b45a7a6f72ae5945d2a28272727f", size = 14184660, upload-time = "2025-07-24T20:28:39.522Z" }, + { url = "https://files.pythonhosted.org/packages/2b/53/102c6122db45a62aa20d1b18c9986f67e6b97e0d6fbc1ae13e3e4c84430c/numpy-2.3.2-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:8b1224a734cd509f70816455c3cffe13a4f599b1bf7130f913ba0e2c0b2006c0", size = 5113382, upload-time = "2025-07-24T20:28:48.544Z" }, + { url = "https://files.pythonhosted.org/packages/2b/21/376257efcbf63e624250717e82b4fae93d60178f09eb03ed766dbb48ec9c/numpy-2.3.2-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:3dcf02866b977a38ba3ec10215220609ab9667378a9e2150615673f3ffd6c73b", size = 6647258, upload-time = "2025-07-24T20:28:59.104Z" }, + { url = "https://files.pythonhosted.org/packages/91/ba/f4ebf257f08affa464fe6036e13f2bf9d4642a40228781dc1235da81be9f/numpy-2.3.2-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:572d5512df5470f50ada8d1972c5f1082d9a0b7aa5944db8084077570cf98370", size = 14281409, upload-time = "2025-07-24T20:40:30.298Z" }, + { url = "https://files.pythonhosted.org/packages/59/ef/f96536f1df42c668cbacb727a8c6da7afc9c05ece6d558927fb1722693e1/numpy-2.3.2-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8145dd6d10df13c559d1e4314df29695613575183fa2e2d11fac4c208c8a1f73", size = 16641317, upload-time = "2025-07-24T20:40:56.625Z" }, + { url = "https://files.pythonhosted.org/packages/f6/a7/af813a7b4f9a42f498dde8a4c6fcbff8100eed00182cc91dbaf095645f38/numpy-2.3.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:103ea7063fa624af04a791c39f97070bf93b96d7af7eb23530cd087dc8dbe9dc", size = 16056262, upload-time = "2025-07-24T20:41:20.797Z" }, + { url = "https://files.pythonhosted.org/packages/8b/5d/41c4ef8404caaa7f05ed1cfb06afe16a25895260eacbd29b4d84dff2920b/numpy-2.3.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fc927d7f289d14f5e037be917539620603294454130b6de200091e23d27dc9be", size = 18579342, upload-time = "2025-07-24T20:41:50.753Z" }, + { url = "https://files.pythonhosted.org/packages/a1/4f/9950e44c5a11636f4a3af6e825ec23003475cc9a466edb7a759ed3ea63bd/numpy-2.3.2-cp312-cp312-win32.whl", hash = "sha256:d95f59afe7f808c103be692175008bab926b59309ade3e6d25009e9a171f7036", size = 6320610, upload-time = "2025-07-24T20:42:01.551Z" }, + { url = "https://files.pythonhosted.org/packages/7c/2f/244643a5ce54a94f0a9a2ab578189c061e4a87c002e037b0829dd77293b6/numpy-2.3.2-cp312-cp312-win_amd64.whl", hash = "sha256:9e196ade2400c0c737d93465327d1ae7c06c7cb8a1756121ebf54b06ca183c7f", size = 12786292, upload-time = "2025-07-24T20:42:20.738Z" }, + { url = "https://files.pythonhosted.org/packages/54/cd/7b5f49d5d78db7badab22d8323c1b6ae458fbf86c4fdfa194ab3cd4eb39b/numpy-2.3.2-cp312-cp312-win_arm64.whl", hash = "sha256:ee807923782faaf60d0d7331f5e86da7d5e3079e28b291973c545476c2b00d07", size = 10194071, upload-time = "2025-07-24T20:42:36.657Z" }, + { url = "https://files.pythonhosted.org/packages/1c/c0/c6bb172c916b00700ed3bf71cb56175fd1f7dbecebf8353545d0b5519f6c/numpy-2.3.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:c8d9727f5316a256425892b043736d63e89ed15bbfe6556c5ff4d9d4448ff3b3", size = 20949074, upload-time = "2025-07-24T20:43:07.813Z" }, + { url = "https://files.pythonhosted.org/packages/20/4e/c116466d22acaf4573e58421c956c6076dc526e24a6be0903219775d862e/numpy-2.3.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:efc81393f25f14d11c9d161e46e6ee348637c0a1e8a54bf9dedc472a3fae993b", size = 14177311, upload-time = "2025-07-24T20:43:29.335Z" }, + { url = "https://files.pythonhosted.org/packages/78/45/d4698c182895af189c463fc91d70805d455a227261d950e4e0f1310c2550/numpy-2.3.2-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:dd937f088a2df683cbb79dda9a772b62a3e5a8a7e76690612c2737f38c6ef1b6", size = 5106022, upload-time = "2025-07-24T20:43:37.999Z" }, + { url = "https://files.pythonhosted.org/packages/9f/76/3e6880fef4420179309dba72a8c11f6166c431cf6dee54c577af8906f914/numpy-2.3.2-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:11e58218c0c46c80509186e460d79fbdc9ca1eb8d8aee39d8f2dc768eb781089", size = 6640135, upload-time = "2025-07-24T20:43:49.28Z" }, + { url = "https://files.pythonhosted.org/packages/34/fa/87ff7f25b3c4ce9085a62554460b7db686fef1e0207e8977795c7b7d7ba1/numpy-2.3.2-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5ad4ebcb683a1f99f4f392cc522ee20a18b2bb12a2c1c42c3d48d5a1adc9d3d2", size = 14278147, upload-time = "2025-07-24T20:44:10.328Z" }, + { url = "https://files.pythonhosted.org/packages/1d/0f/571b2c7a3833ae419fe69ff7b479a78d313581785203cc70a8db90121b9a/numpy-2.3.2-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:938065908d1d869c7d75d8ec45f735a034771c6ea07088867f713d1cd3bbbe4f", size = 16635989, upload-time = "2025-07-24T20:44:34.88Z" }, + { url = "https://files.pythonhosted.org/packages/24/5a/84ae8dca9c9a4c592fe11340b36a86ffa9fd3e40513198daf8a97839345c/numpy-2.3.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:66459dccc65d8ec98cc7df61307b64bf9e08101f9598755d42d8ae65d9a7a6ee", size = 16053052, upload-time = "2025-07-24T20:44:58.872Z" }, + { url = "https://files.pythonhosted.org/packages/57/7c/e5725d99a9133b9813fcf148d3f858df98511686e853169dbaf63aec6097/numpy-2.3.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a7af9ed2aa9ec5950daf05bb11abc4076a108bd3c7db9aa7251d5f107079b6a6", size = 18577955, upload-time = "2025-07-24T20:45:26.714Z" }, + { url = "https://files.pythonhosted.org/packages/ae/11/7c546fcf42145f29b71e4d6f429e96d8d68e5a7ba1830b2e68d7418f0bbd/numpy-2.3.2-cp313-cp313-win32.whl", hash = "sha256:906a30249315f9c8e17b085cc5f87d3f369b35fedd0051d4a84686967bdbbd0b", size = 6311843, upload-time = "2025-07-24T20:49:24.444Z" }, + { url = "https://files.pythonhosted.org/packages/aa/6f/a428fd1cb7ed39b4280d057720fed5121b0d7754fd2a9768640160f5517b/numpy-2.3.2-cp313-cp313-win_amd64.whl", hash = "sha256:c63d95dc9d67b676e9108fe0d2182987ccb0f11933c1e8959f42fa0da8d4fa56", size = 12782876, upload-time = "2025-07-24T20:49:43.227Z" }, + { url = "https://files.pythonhosted.org/packages/65/85/4ea455c9040a12595fb6c43f2c217257c7b52dd0ba332c6a6c1d28b289fe/numpy-2.3.2-cp313-cp313-win_arm64.whl", hash = "sha256:b05a89f2fb84d21235f93de47129dd4f11c16f64c87c33f5e284e6a3a54e43f2", size = 10192786, upload-time = "2025-07-24T20:49:59.443Z" }, + { url = "https://files.pythonhosted.org/packages/80/23/8278f40282d10c3f258ec3ff1b103d4994bcad78b0cba9208317f6bb73da/numpy-2.3.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:4e6ecfeddfa83b02318f4d84acf15fbdbf9ded18e46989a15a8b6995dfbf85ab", size = 21047395, upload-time = "2025-07-24T20:45:58.821Z" }, + { url = "https://files.pythonhosted.org/packages/1f/2d/624f2ce4a5df52628b4ccd16a4f9437b37c35f4f8a50d00e962aae6efd7a/numpy-2.3.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:508b0eada3eded10a3b55725b40806a4b855961040180028f52580c4729916a2", size = 14300374, upload-time = "2025-07-24T20:46:20.207Z" }, + { url = "https://files.pythonhosted.org/packages/f6/62/ff1e512cdbb829b80a6bd08318a58698867bca0ca2499d101b4af063ee97/numpy-2.3.2-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:754d6755d9a7588bdc6ac47dc4ee97867271b17cee39cb87aef079574366db0a", size = 5228864, upload-time = "2025-07-24T20:46:30.58Z" }, + { url = "https://files.pythonhosted.org/packages/7d/8e/74bc18078fff03192d4032cfa99d5a5ca937807136d6f5790ce07ca53515/numpy-2.3.2-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:a9f66e7d2b2d7712410d3bc5684149040ef5f19856f20277cd17ea83e5006286", size = 6737533, upload-time = "2025-07-24T20:46:46.111Z" }, + { url = "https://files.pythonhosted.org/packages/19/ea/0731efe2c9073ccca5698ef6a8c3667c4cf4eea53fcdcd0b50140aba03bc/numpy-2.3.2-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:de6ea4e5a65d5a90c7d286ddff2b87f3f4ad61faa3db8dabe936b34c2275b6f8", size = 14352007, upload-time = "2025-07-24T20:47:07.1Z" }, + { url = "https://files.pythonhosted.org/packages/cf/90/36be0865f16dfed20f4bc7f75235b963d5939707d4b591f086777412ff7b/numpy-2.3.2-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a3ef07ec8cbc8fc9e369c8dcd52019510c12da4de81367d8b20bc692aa07573a", size = 16701914, upload-time = "2025-07-24T20:47:32.459Z" }, + { url = "https://files.pythonhosted.org/packages/94/30/06cd055e24cb6c38e5989a9e747042b4e723535758e6153f11afea88c01b/numpy-2.3.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:27c9f90e7481275c7800dc9c24b7cc40ace3fdb970ae4d21eaff983a32f70c91", size = 16132708, upload-time = "2025-07-24T20:47:58.129Z" }, + { url = "https://files.pythonhosted.org/packages/9a/14/ecede608ea73e58267fd7cb78f42341b3b37ba576e778a1a06baffbe585c/numpy-2.3.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:07b62978075b67eee4065b166d000d457c82a1efe726cce608b9db9dd66a73a5", size = 18651678, upload-time = "2025-07-24T20:48:25.402Z" }, + { url = "https://files.pythonhosted.org/packages/40/f3/2fe6066b8d07c3685509bc24d56386534c008b462a488b7f503ba82b8923/numpy-2.3.2-cp313-cp313t-win32.whl", hash = "sha256:c771cfac34a4f2c0de8e8c97312d07d64fd8f8ed45bc9f5726a7e947270152b5", size = 6441832, upload-time = "2025-07-24T20:48:37.181Z" }, + { url = "https://files.pythonhosted.org/packages/0b/ba/0937d66d05204d8f28630c9c60bc3eda68824abde4cf756c4d6aad03b0c6/numpy-2.3.2-cp313-cp313t-win_amd64.whl", hash = "sha256:72dbebb2dcc8305c431b2836bcc66af967df91be793d63a24e3d9b741374c450", size = 12927049, upload-time = "2025-07-24T20:48:56.24Z" }, + { url = "https://files.pythonhosted.org/packages/e9/ed/13542dd59c104d5e654dfa2ac282c199ba64846a74c2c4bcdbc3a0f75df1/numpy-2.3.2-cp313-cp313t-win_arm64.whl", hash = "sha256:72c6df2267e926a6d5286b0a6d556ebe49eae261062059317837fda12ddf0c1a", size = 10262935, upload-time = "2025-07-24T20:49:13.136Z" }, + { url = "https://files.pythonhosted.org/packages/c9/7c/7659048aaf498f7611b783e000c7268fcc4dcf0ce21cd10aad7b2e8f9591/numpy-2.3.2-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:448a66d052d0cf14ce9865d159bfc403282c9bc7bb2a31b03cc18b651eca8b1a", size = 20950906, upload-time = "2025-07-24T20:50:30.346Z" }, + { url = "https://files.pythonhosted.org/packages/80/db/984bea9d4ddf7112a04cfdfb22b1050af5757864cfffe8e09e44b7f11a10/numpy-2.3.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:546aaf78e81b4081b2eba1d105c3b34064783027a06b3ab20b6eba21fb64132b", size = 14185607, upload-time = "2025-07-24T20:50:51.923Z" }, + { url = "https://files.pythonhosted.org/packages/e4/76/b3d6f414f4eca568f469ac112a3b510938d892bc5a6c190cb883af080b77/numpy-2.3.2-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:87c930d52f45df092f7578889711a0768094debf73cfcde105e2d66954358125", size = 5114110, upload-time = "2025-07-24T20:51:01.041Z" }, + { url = "https://files.pythonhosted.org/packages/9e/d2/6f5e6826abd6bca52392ed88fe44a4b52aacb60567ac3bc86c67834c3a56/numpy-2.3.2-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:8dc082ea901a62edb8f59713c6a7e28a85daddcb67454c839de57656478f5b19", size = 6642050, upload-time = "2025-07-24T20:51:11.64Z" }, + { url = "https://files.pythonhosted.org/packages/c4/43/f12b2ade99199e39c73ad182f103f9d9791f48d885c600c8e05927865baf/numpy-2.3.2-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:af58de8745f7fa9ca1c0c7c943616c6fe28e75d0c81f5c295810e3c83b5be92f", size = 14296292, upload-time = "2025-07-24T20:51:33.488Z" }, + { url = "https://files.pythonhosted.org/packages/5d/f9/77c07d94bf110a916b17210fac38680ed8734c236bfed9982fd8524a7b47/numpy-2.3.2-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fed5527c4cf10f16c6d0b6bee1f89958bccb0ad2522c8cadc2efd318bcd545f5", size = 16638913, upload-time = "2025-07-24T20:51:58.517Z" }, + { url = "https://files.pythonhosted.org/packages/9b/d1/9d9f2c8ea399cc05cfff8a7437453bd4e7d894373a93cdc46361bbb49a7d/numpy-2.3.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:095737ed986e00393ec18ec0b21b47c22889ae4b0cd2d5e88342e08b01141f58", size = 16071180, upload-time = "2025-07-24T20:52:22.827Z" }, + { url = "https://files.pythonhosted.org/packages/4c/41/82e2c68aff2a0c9bf315e47d61951099fed65d8cb2c8d9dc388cb87e947e/numpy-2.3.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:b5e40e80299607f597e1a8a247ff8d71d79c5b52baa11cc1cce30aa92d2da6e0", size = 18576809, upload-time = "2025-07-24T20:52:51.015Z" }, + { url = "https://files.pythonhosted.org/packages/14/14/4b4fd3efb0837ed252d0f583c5c35a75121038a8c4e065f2c259be06d2d8/numpy-2.3.2-cp314-cp314-win32.whl", hash = "sha256:7d6e390423cc1f76e1b8108c9b6889d20a7a1f59d9a60cac4a050fa734d6c1e2", size = 6366410, upload-time = "2025-07-24T20:56:44.949Z" }, + { url = "https://files.pythonhosted.org/packages/11/9e/b4c24a6b8467b61aced5c8dc7dcfce23621baa2e17f661edb2444a418040/numpy-2.3.2-cp314-cp314-win_amd64.whl", hash = "sha256:b9d0878b21e3918d76d2209c924ebb272340da1fb51abc00f986c258cd5e957b", size = 12918821, upload-time = "2025-07-24T20:57:06.479Z" }, + { url = "https://files.pythonhosted.org/packages/0e/0f/0dc44007c70b1007c1cef86b06986a3812dd7106d8f946c09cfa75782556/numpy-2.3.2-cp314-cp314-win_arm64.whl", hash = "sha256:2738534837c6a1d0c39340a190177d7d66fdf432894f469728da901f8f6dc910", size = 10477303, upload-time = "2025-07-24T20:57:22.879Z" }, + { url = "https://files.pythonhosted.org/packages/8b/3e/075752b79140b78ddfc9c0a1634d234cfdbc6f9bbbfa6b7504e445ad7d19/numpy-2.3.2-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:4d002ecf7c9b53240be3bb69d80f86ddbd34078bae04d87be81c1f58466f264e", size = 21047524, upload-time = "2025-07-24T20:53:22.086Z" }, + { url = "https://files.pythonhosted.org/packages/fe/6d/60e8247564a72426570d0e0ea1151b95ce5bd2f1597bb878a18d32aec855/numpy-2.3.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:293b2192c6bcce487dbc6326de5853787f870aeb6c43f8f9c6496db5b1781e45", size = 14300519, upload-time = "2025-07-24T20:53:44.053Z" }, + { url = "https://files.pythonhosted.org/packages/4d/73/d8326c442cd428d47a067070c3ac6cc3b651a6e53613a1668342a12d4479/numpy-2.3.2-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:0a4f2021a6da53a0d580d6ef5db29947025ae8b35b3250141805ea9a32bbe86b", size = 5228972, upload-time = "2025-07-24T20:53:53.81Z" }, + { url = "https://files.pythonhosted.org/packages/34/2e/e71b2d6dad075271e7079db776196829019b90ce3ece5c69639e4f6fdc44/numpy-2.3.2-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:9c144440db4bf3bb6372d2c3e49834cc0ff7bb4c24975ab33e01199e645416f2", size = 6737439, upload-time = "2025-07-24T20:54:04.742Z" }, + { url = "https://files.pythonhosted.org/packages/15/b0/d004bcd56c2c5e0500ffc65385eb6d569ffd3363cb5e593ae742749b2daa/numpy-2.3.2-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f92d6c2a8535dc4fe4419562294ff957f83a16ebdec66df0805e473ffaad8bd0", size = 14352479, upload-time = "2025-07-24T20:54:25.819Z" }, + { url = "https://files.pythonhosted.org/packages/11/e3/285142fcff8721e0c99b51686426165059874c150ea9ab898e12a492e291/numpy-2.3.2-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cefc2219baa48e468e3db7e706305fcd0c095534a192a08f31e98d83a7d45fb0", size = 16702805, upload-time = "2025-07-24T20:54:50.814Z" }, + { url = "https://files.pythonhosted.org/packages/33/c3/33b56b0e47e604af2c7cd065edca892d180f5899599b76830652875249a3/numpy-2.3.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:76c3e9501ceb50b2ff3824c3589d5d1ab4ac857b0ee3f8f49629d0de55ecf7c2", size = 16133830, upload-time = "2025-07-24T20:55:17.306Z" }, + { url = "https://files.pythonhosted.org/packages/6e/ae/7b1476a1f4d6a48bc669b8deb09939c56dd2a439db1ab03017844374fb67/numpy-2.3.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:122bf5ed9a0221b3419672493878ba4967121514b1d7d4656a7580cd11dddcbf", size = 18652665, upload-time = "2025-07-24T20:55:46.665Z" }, + { url = "https://files.pythonhosted.org/packages/14/ba/5b5c9978c4bb161034148ade2de9db44ec316fab89ce8c400db0e0c81f86/numpy-2.3.2-cp314-cp314t-win32.whl", hash = "sha256:6f1ae3dcb840edccc45af496f312528c15b1f79ac318169d094e85e4bb35fdf1", size = 6514777, upload-time = "2025-07-24T20:55:57.66Z" }, + { url = "https://files.pythonhosted.org/packages/eb/46/3dbaf0ae7c17cdc46b9f662c56da2054887b8d9e737c1476f335c83d33db/numpy-2.3.2-cp314-cp314t-win_amd64.whl", hash = "sha256:087ffc25890d89a43536f75c5fe8770922008758e8eeeef61733957041ed2f9b", size = 13111856, upload-time = "2025-07-24T20:56:17.318Z" }, + { url = "https://files.pythonhosted.org/packages/c1/9e/1652778bce745a67b5fe05adde60ed362d38eb17d919a540e813d30f6874/numpy-2.3.2-cp314-cp314t-win_arm64.whl", hash = "sha256:092aeb3449833ea9c0bf0089d70c29ae480685dd2377ec9cdbbb620257f84631", size = 10544226, upload-time = "2025-07-24T20:56:34.509Z" }, +] + +[[package]] +name = "nvidia-cublas-cu12" +version = "12.8.4.1" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/dc/61/e24b560ab2e2eaeb3c839129175fb330dfcfc29e5203196e5541a4c44682/nvidia_cublas_cu12-12.8.4.1-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:8ac4e771d5a348c551b2a426eda6193c19aa630236b418086020df5ba9667142", size = 594346921, upload-time = "2025-03-07T01:44:31.254Z" }, +] + +[[package]] +name = "nvidia-cuda-cupti-cu12" +version = "12.8.90" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f8/02/2adcaa145158bf1a8295d83591d22e4103dbfd821bcaf6f3f53151ca4ffa/nvidia_cuda_cupti_cu12-12.8.90-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ea0cb07ebda26bb9b29ba82cda34849e73c166c18162d3913575b0c9db9a6182", size = 10248621, upload-time = "2025-03-07T01:40:21.213Z" }, +] + +[[package]] +name = "nvidia-cuda-nvrtc-cu12" +version = "12.8.93" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/05/6b/32f747947df2da6994e999492ab306a903659555dddc0fbdeb9d71f75e52/nvidia_cuda_nvrtc_cu12-12.8.93-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", hash = "sha256:a7756528852ef889772a84c6cd89d41dfa74667e24cca16bb31f8f061e3e9994", size = 88040029, upload-time = "2025-03-07T01:42:13.562Z" }, +] + +[[package]] +name = "nvidia-cuda-runtime-cu12" +version = "12.8.90" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0d/9b/a997b638fcd068ad6e4d53b8551a7d30fe8b404d6f1804abf1df69838932/nvidia_cuda_runtime_cu12-12.8.90-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:adade8dcbd0edf427b7204d480d6066d33902cab2a4707dcfc48a2d0fd44ab90", size = 954765, upload-time = "2025-03-07T01:40:01.615Z" }, +] + +[[package]] +name = "nvidia-cudnn-cu12" +version = "9.10.2.21" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "nvidia-cublas-cu12" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/ba/51/e123d997aa098c61d029f76663dedbfb9bc8dcf8c60cbd6adbe42f76d049/nvidia_cudnn_cu12-9.10.2.21-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:949452be657fa16687d0930933f032835951ef0892b37d2d53824d1a84dc97a8", size = 706758467, upload-time = "2025-06-06T21:54:08.597Z" }, +] + +[[package]] +name = "nvidia-cufft-cu12" +version = "11.3.3.83" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "nvidia-nvjitlink-cu12" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/1f/13/ee4e00f30e676b66ae65b4f08cb5bcbb8392c03f54f2d5413ea99a5d1c80/nvidia_cufft_cu12-11.3.3.83-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4d2dd21ec0b88cf61b62e6b43564355e5222e4a3fb394cac0db101f2dd0d4f74", size = 193118695, upload-time = "2025-03-07T01:45:27.821Z" }, +] + +[[package]] +name = "nvidia-cufile-cu12" +version = "1.13.1.3" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bb/fe/1bcba1dfbfb8d01be8d93f07bfc502c93fa23afa6fd5ab3fc7c1df71038a/nvidia_cufile_cu12-1.13.1.3-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1d069003be650e131b21c932ec3d8969c1715379251f8d23a1860554b1cb24fc", size = 1197834, upload-time = "2025-03-07T01:45:50.723Z" }, +] + +[[package]] +name = "nvidia-curand-cu12" +version = "10.3.9.90" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fb/aa/6584b56dc84ebe9cf93226a5cde4d99080c8e90ab40f0c27bda7a0f29aa1/nvidia_curand_cu12-10.3.9.90-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:b32331d4f4df5d6eefa0554c565b626c7216f87a06a4f56fab27c3b68a830ec9", size = 63619976, upload-time = "2025-03-07T01:46:23.323Z" }, +] + +[[package]] +name = "nvidia-cusolver-cu12" +version = "11.7.3.90" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "nvidia-cublas-cu12" }, + { name = "nvidia-cusparse-cu12" }, + { name = "nvidia-nvjitlink-cu12" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/85/48/9a13d2975803e8cf2777d5ed57b87a0b6ca2cc795f9a4f59796a910bfb80/nvidia_cusolver_cu12-11.7.3.90-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:4376c11ad263152bd50ea295c05370360776f8c3427b30991df774f9fb26c450", size = 267506905, upload-time = "2025-03-07T01:47:16.273Z" }, +] + +[[package]] +name = "nvidia-cusparse-cu12" +version = "12.5.8.93" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "nvidia-nvjitlink-cu12" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/c2/f5/e1854cb2f2bcd4280c44736c93550cc300ff4b8c95ebe370d0aa7d2b473d/nvidia_cusparse_cu12-12.5.8.93-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1ec05d76bbbd8b61b06a80e1eaf8cf4959c3d4ce8e711b65ebd0443bb0ebb13b", size = 288216466, upload-time = "2025-03-07T01:48:13.779Z" }, +] + +[[package]] +name = "nvidia-cusparselt-cu12" +version = "0.7.1" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/56/79/12978b96bd44274fe38b5dde5cfb660b1d114f70a65ef962bcbbed99b549/nvidia_cusparselt_cu12-0.7.1-py3-none-manylinux2014_x86_64.whl", hash = "sha256:f1bb701d6b930d5a7cea44c19ceb973311500847f81b634d802b7b539dc55623", size = 287193691, upload-time = "2025-02-26T00:15:44.104Z" }, +] + +[[package]] +name = "nvidia-nccl-cu12" +version = "2.27.3" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5c/5b/4e4fff7bad39adf89f735f2bc87248c81db71205b62bcc0d5ca5b606b3c3/nvidia_nccl_cu12-2.27.3-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:adf27ccf4238253e0b826bce3ff5fa532d65fc42322c8bfdfaf28024c0fbe039", size = 322364134, upload-time = "2025-06-03T21:58:04.013Z" }, +] + +[[package]] +name = "nvidia-nvjitlink-cu12" +version = "12.8.93" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f6/74/86a07f1d0f42998ca31312f998bd3b9a7eff7f52378f4f270c8679c77fb9/nvidia_nvjitlink_cu12-12.8.93-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", hash = "sha256:81ff63371a7ebd6e6451970684f916be2eab07321b73c9d244dc2b4da7f73b88", size = 39254836, upload-time = "2025-03-07T01:49:55.661Z" }, +] + +[[package]] +name = "nvidia-nvtx-cu12" +version = "12.8.90" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a2/eb/86626c1bbc2edb86323022371c39aa48df6fd8b0a1647bc274577f72e90b/nvidia_nvtx_cu12-12.8.90-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5b17e2001cc0d751a5bc2c6ec6d26ad95913324a4adb86788c944f8ce9ba441f", size = 89954, upload-time = "2025-03-07T01:42:44.131Z" }, +] + +[[package]] +name = "openpyxl" +version = "3.1.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "et-xmlfile" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/3d/f9/88d94a75de065ea32619465d2f77b29a0469500e99012523b91cc4141cd1/openpyxl-3.1.5.tar.gz", hash = "sha256:cf0e3cf56142039133628b5acffe8ef0c12bc902d2aadd3e0fe5878dc08d1050", size = 186464, upload-time = "2024-06-28T14:03:44.161Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c0/da/977ded879c29cbd04de313843e76868e6e13408a94ed6b987245dc7c8506/openpyxl-3.1.5-py2.py3-none-any.whl", hash = "sha256:5282c12b107bffeef825f4617dc029afaf41d0ea60823bbb665ef3079dc79de2", size = 250910, upload-time = "2024-06-28T14:03:41.161Z" }, +] + +[[package]] +name = "overrides" +version = "7.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/36/86/b585f53236dec60aba864e050778b25045f857e17f6e5ea0ae95fe80edd2/overrides-7.7.0.tar.gz", hash = "sha256:55158fa3d93b98cc75299b1e67078ad9003ca27945c76162c1c0766d6f91820a", size = 22812, upload-time = "2024-01-27T21:01:33.423Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2c/ab/fc8290c6a4c722e5514d80f62b2dc4c4df1a68a41d1364e625c35990fcf3/overrides-7.7.0-py3-none-any.whl", hash = "sha256:c7ed9d062f78b8e4c1a7b70bd8796b35ead4d9f510227ef9c5dc7626c60d7e49", size = 17832, upload-time = "2024-01-27T21:01:31.393Z" }, +] + +[[package]] +name = "packaging" +version = "25.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a1/d4/1fc4078c65507b51b96ca8f8c3ba19e6a61c8253c72794544580a7b6c24d/packaging-25.0.tar.gz", hash = "sha256:d443872c98d677bf60f6a1f2f8c1cb748e8fe762d2bf9d3148b5599295b0fc4f", size = 165727, upload-time = "2025-04-19T11:48:59.673Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/20/12/38679034af332785aac8774540895e234f4d07f7545804097de4b666afd8/packaging-25.0-py3-none-any.whl", hash = "sha256:29572ef2b1f17581046b3a2227d5c611fb25ec70ca1ba8554b24b0e69331a484", size = 66469, upload-time = "2025-04-19T11:48:57.875Z" }, +] + +[[package]] +name = "pandas" +version = "2.3.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, + { name = "python-dateutil" }, + { name = "pytz" }, + { name = "tzdata" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/d1/6f/75aa71f8a14267117adeeed5d21b204770189c0a0025acbdc03c337b28fc/pandas-2.3.1.tar.gz", hash = "sha256:0a95b9ac964fe83ce317827f80304d37388ea77616b1425f0ae41c9d2d0d7bb2", size = 4487493, upload-time = "2025-07-07T19:20:04.079Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/46/de/b8445e0f5d217a99fe0eeb2f4988070908979bec3587c0633e5428ab596c/pandas-2.3.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:689968e841136f9e542020698ee1c4fbe9caa2ed2213ae2388dc7b81721510d3", size = 11588172, upload-time = "2025-07-07T19:18:52.054Z" }, + { url = "https://files.pythonhosted.org/packages/1e/e0/801cdb3564e65a5ac041ab99ea6f1d802a6c325bb6e58c79c06a3f1cd010/pandas-2.3.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:025e92411c16cbe5bb2a4abc99732a6b132f439b8aab23a59fa593eb00704232", size = 10717365, upload-time = "2025-07-07T19:18:54.785Z" }, + { url = "https://files.pythonhosted.org/packages/51/a5/c76a8311833c24ae61a376dbf360eb1b1c9247a5d9c1e8b356563b31b80c/pandas-2.3.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9b7ff55f31c4fcb3e316e8f7fa194566b286d6ac430afec0d461163312c5841e", size = 11280411, upload-time = "2025-07-07T19:18:57.045Z" }, + { url = "https://files.pythonhosted.org/packages/da/01/e383018feba0a1ead6cf5fe8728e5d767fee02f06a3d800e82c489e5daaf/pandas-2.3.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7dcb79bf373a47d2a40cf7232928eb7540155abbc460925c2c96d2d30b006eb4", size = 11988013, upload-time = "2025-07-07T19:18:59.771Z" }, + { url = "https://files.pythonhosted.org/packages/5b/14/cec7760d7c9507f11c97d64f29022e12a6cc4fc03ac694535e89f88ad2ec/pandas-2.3.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:56a342b231e8862c96bdb6ab97170e203ce511f4d0429589c8ede1ee8ece48b8", size = 12767210, upload-time = "2025-07-07T19:19:02.944Z" }, + { url = "https://files.pythonhosted.org/packages/50/b9/6e2d2c6728ed29fb3d4d4d302504fb66f1a543e37eb2e43f352a86365cdf/pandas-2.3.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ca7ed14832bce68baef331f4d7f294411bed8efd032f8109d690df45e00c4679", size = 13440571, upload-time = "2025-07-07T19:19:06.82Z" }, + { url = "https://files.pythonhosted.org/packages/80/a5/3a92893e7399a691bad7664d977cb5e7c81cf666c81f89ea76ba2bff483d/pandas-2.3.1-cp312-cp312-win_amd64.whl", hash = "sha256:ac942bfd0aca577bef61f2bc8da8147c4ef6879965ef883d8e8d5d2dc3e744b8", size = 10987601, upload-time = "2025-07-07T19:19:09.589Z" }, + { url = "https://files.pythonhosted.org/packages/32/ed/ff0a67a2c5505e1854e6715586ac6693dd860fbf52ef9f81edee200266e7/pandas-2.3.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:9026bd4a80108fac2239294a15ef9003c4ee191a0f64b90f170b40cfb7cf2d22", size = 11531393, upload-time = "2025-07-07T19:19:12.245Z" }, + { url = "https://files.pythonhosted.org/packages/c7/db/d8f24a7cc9fb0972adab0cc80b6817e8bef888cfd0024eeb5a21c0bb5c4a/pandas-2.3.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:6de8547d4fdb12421e2d047a2c446c623ff4c11f47fddb6b9169eb98ffba485a", size = 10668750, upload-time = "2025-07-07T19:19:14.612Z" }, + { url = "https://files.pythonhosted.org/packages/0f/b0/80f6ec783313f1e2356b28b4fd8d2148c378370045da918c73145e6aab50/pandas-2.3.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:782647ddc63c83133b2506912cc6b108140a38a37292102aaa19c81c83db2928", size = 11342004, upload-time = "2025-07-07T19:19:16.857Z" }, + { url = "https://files.pythonhosted.org/packages/e9/e2/20a317688435470872885e7fc8f95109ae9683dec7c50be29b56911515a5/pandas-2.3.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2ba6aff74075311fc88504b1db890187a3cd0f887a5b10f5525f8e2ef55bfdb9", size = 12050869, upload-time = "2025-07-07T19:19:19.265Z" }, + { url = "https://files.pythonhosted.org/packages/55/79/20d746b0a96c67203a5bee5fb4e00ac49c3e8009a39e1f78de264ecc5729/pandas-2.3.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:e5635178b387bd2ba4ac040f82bc2ef6e6b500483975c4ebacd34bec945fda12", size = 12750218, upload-time = "2025-07-07T19:19:21.547Z" }, + { url = "https://files.pythonhosted.org/packages/7c/0f/145c8b41e48dbf03dd18fdd7f24f8ba95b8254a97a3379048378f33e7838/pandas-2.3.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6f3bf5ec947526106399a9e1d26d40ee2b259c66422efdf4de63c848492d91bb", size = 13416763, upload-time = "2025-07-07T19:19:23.939Z" }, + { url = "https://files.pythonhosted.org/packages/b2/c0/54415af59db5cdd86a3d3bf79863e8cc3fa9ed265f0745254061ac09d5f2/pandas-2.3.1-cp313-cp313-win_amd64.whl", hash = "sha256:1c78cf43c8fde236342a1cb2c34bcff89564a7bfed7e474ed2fffa6aed03a956", size = 10987482, upload-time = "2025-07-07T19:19:42.699Z" }, + { url = "https://files.pythonhosted.org/packages/48/64/2fd2e400073a1230e13b8cd604c9bc95d9e3b962e5d44088ead2e8f0cfec/pandas-2.3.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:8dfc17328e8da77be3cf9f47509e5637ba8f137148ed0e9b5241e1baf526e20a", size = 12029159, upload-time = "2025-07-07T19:19:26.362Z" }, + { url = "https://files.pythonhosted.org/packages/d8/0a/d84fd79b0293b7ef88c760d7dca69828d867c89b6d9bc52d6a27e4d87316/pandas-2.3.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:ec6c851509364c59a5344458ab935e6451b31b818be467eb24b0fe89bd05b6b9", size = 11393287, upload-time = "2025-07-07T19:19:29.157Z" }, + { url = "https://files.pythonhosted.org/packages/50/ae/ff885d2b6e88f3c7520bb74ba319268b42f05d7e583b5dded9837da2723f/pandas-2.3.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:911580460fc4884d9b05254b38a6bfadddfcc6aaef856fb5859e7ca202e45275", size = 11309381, upload-time = "2025-07-07T19:19:31.436Z" }, + { url = "https://files.pythonhosted.org/packages/85/86/1fa345fc17caf5d7780d2699985c03dbe186c68fee00b526813939062bb0/pandas-2.3.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2f4d6feeba91744872a600e6edbbd5b033005b431d5ae8379abee5bcfa479fab", size = 11883998, upload-time = "2025-07-07T19:19:34.267Z" }, + { url = "https://files.pythonhosted.org/packages/81/aa/e58541a49b5e6310d89474333e994ee57fea97c8aaa8fc7f00b873059bbf/pandas-2.3.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:fe37e757f462d31a9cd7580236a82f353f5713a80e059a29753cf938c6775d96", size = 12704705, upload-time = "2025-07-07T19:19:36.856Z" }, + { url = "https://files.pythonhosted.org/packages/d5/f9/07086f5b0f2a19872554abeea7658200824f5835c58a106fa8f2ae96a46c/pandas-2.3.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:5db9637dbc24b631ff3707269ae4559bce4b7fd75c1c4d7e13f40edc42df4444", size = 13189044, upload-time = "2025-07-07T19:19:39.999Z" }, +] + +[[package]] +name = "pandocfilters" +version = "1.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/70/6f/3dd4940bbe001c06a65f88e36bad298bc7a0de5036115639926b0c5c0458/pandocfilters-1.5.1.tar.gz", hash = "sha256:002b4a555ee4ebc03f8b66307e287fa492e4a77b4ea14d3f934328297bb4939e", size = 8454, upload-time = "2024-01-18T20:08:13.726Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ef/af/4fbc8cab944db5d21b7e2a5b8e9211a03a79852b1157e2c102fcc61ac440/pandocfilters-1.5.1-py2.py3-none-any.whl", hash = "sha256:93be382804a9cdb0a7267585f157e5d1731bbe5545a85b268d6f5fe6232de2bc", size = 8663, upload-time = "2024-01-18T20:08:11.28Z" }, +] + +[[package]] +name = "parso" +version = "0.8.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/66/94/68e2e17afaa9169cf6412ab0f28623903be73d1b32e208d9e8e541bb086d/parso-0.8.4.tar.gz", hash = "sha256:eb3a7b58240fb99099a345571deecc0f9540ea5f4dd2fe14c2a99d6b281ab92d", size = 400609, upload-time = "2024-04-05T09:43:55.897Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c6/ac/dac4a63f978e4dcb3c6d3a78c4d8e0192a113d288502a1216950c41b1027/parso-0.8.4-py2.py3-none-any.whl", hash = "sha256:a418670a20291dacd2dddc80c377c5c3791378ee1e8d12bffc35420643d43f18", size = 103650, upload-time = "2024-04-05T09:43:53.299Z" }, +] + +[[package]] +name = "pexpect" +version = "4.9.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ptyprocess" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/42/92/cc564bf6381ff43ce1f4d06852fc19a2f11d180f23dc32d9588bee2f149d/pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f", size = 166450, upload-time = "2023-11-25T09:07:26.339Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/c3/059298687310d527a58bb01f3b1965787ee3b40dce76752eda8b44e9a2c5/pexpect-4.9.0-py2.py3-none-any.whl", hash = "sha256:7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523", size = 63772, upload-time = "2023-11-25T06:56:14.81Z" }, +] + +[[package]] +name = "pillow" +version = "11.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f3/0d/d0d6dea55cd152ce3d6767bb38a8fc10e33796ba4ba210cbab9354b6d238/pillow-11.3.0.tar.gz", hash = "sha256:3828ee7586cd0b2091b6209e5ad53e20d0649bbe87164a459d0676e035e8f523", size = 47113069, upload-time = "2025-07-01T09:16:30.666Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/40/fe/1bc9b3ee13f68487a99ac9529968035cca2f0a51ec36892060edcc51d06a/pillow-11.3.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:fdae223722da47b024b867c1ea0be64e0df702c5e0a60e27daad39bf960dd1e4", size = 5278800, upload-time = "2025-07-01T09:14:17.648Z" }, + { url = "https://files.pythonhosted.org/packages/2c/32/7e2ac19b5713657384cec55f89065fb306b06af008cfd87e572035b27119/pillow-11.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:921bd305b10e82b4d1f5e802b6850677f965d8394203d182f078873851dada69", size = 4686296, upload-time = "2025-07-01T09:14:19.828Z" }, + { url = "https://files.pythonhosted.org/packages/8e/1e/b9e12bbe6e4c2220effebc09ea0923a07a6da1e1f1bfbc8d7d29a01ce32b/pillow-11.3.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:eb76541cba2f958032d79d143b98a3a6b3ea87f0959bbe256c0b5e416599fd5d", size = 5871726, upload-time = "2025-07-03T13:10:04.448Z" }, + { url = "https://files.pythonhosted.org/packages/8d/33/e9200d2bd7ba00dc3ddb78df1198a6e80d7669cce6c2bdbeb2530a74ec58/pillow-11.3.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:67172f2944ebba3d4a7b54f2e95c786a3a50c21b88456329314caaa28cda70f6", size = 7644652, upload-time = "2025-07-03T13:10:10.391Z" }, + { url = "https://files.pythonhosted.org/packages/41/f1/6f2427a26fc683e00d985bc391bdd76d8dd4e92fac33d841127eb8fb2313/pillow-11.3.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:97f07ed9f56a3b9b5f49d3661dc9607484e85c67e27f3e8be2c7d28ca032fec7", size = 5977787, upload-time = "2025-07-01T09:14:21.63Z" }, + { url = "https://files.pythonhosted.org/packages/e4/c9/06dd4a38974e24f932ff5f98ea3c546ce3f8c995d3f0985f8e5ba48bba19/pillow-11.3.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:676b2815362456b5b3216b4fd5bd89d362100dc6f4945154ff172e206a22c024", size = 6645236, upload-time = "2025-07-01T09:14:23.321Z" }, + { url = "https://files.pythonhosted.org/packages/40/e7/848f69fb79843b3d91241bad658e9c14f39a32f71a301bcd1d139416d1be/pillow-11.3.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3e184b2f26ff146363dd07bde8b711833d7b0202e27d13540bfe2e35a323a809", size = 6086950, upload-time = "2025-07-01T09:14:25.237Z" }, + { url = "https://files.pythonhosted.org/packages/0b/1a/7cff92e695a2a29ac1958c2a0fe4c0b2393b60aac13b04a4fe2735cad52d/pillow-11.3.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:6be31e3fc9a621e071bc17bb7de63b85cbe0bfae91bb0363c893cbe67247780d", size = 6723358, upload-time = "2025-07-01T09:14:27.053Z" }, + { url = "https://files.pythonhosted.org/packages/26/7d/73699ad77895f69edff76b0f332acc3d497f22f5d75e5360f78cbcaff248/pillow-11.3.0-cp312-cp312-win32.whl", hash = "sha256:7b161756381f0918e05e7cb8a371fff367e807770f8fe92ecb20d905d0e1c149", size = 6275079, upload-time = "2025-07-01T09:14:30.104Z" }, + { url = "https://files.pythonhosted.org/packages/8c/ce/e7dfc873bdd9828f3b6e5c2bbb74e47a98ec23cc5c74fc4e54462f0d9204/pillow-11.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:a6444696fce635783440b7f7a9fc24b3ad10a9ea3f0ab66c5905be1c19ccf17d", size = 6986324, upload-time = "2025-07-01T09:14:31.899Z" }, + { url = "https://files.pythonhosted.org/packages/16/8f/b13447d1bf0b1f7467ce7d86f6e6edf66c0ad7cf44cf5c87a37f9bed9936/pillow-11.3.0-cp312-cp312-win_arm64.whl", hash = "sha256:2aceea54f957dd4448264f9bf40875da0415c83eb85f55069d89c0ed436e3542", size = 2423067, upload-time = "2025-07-01T09:14:33.709Z" }, + { url = "https://files.pythonhosted.org/packages/1e/93/0952f2ed8db3a5a4c7a11f91965d6184ebc8cd7cbb7941a260d5f018cd2d/pillow-11.3.0-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:1c627742b539bba4309df89171356fcb3cc5a9178355b2727d1b74a6cf155fbd", size = 2128328, upload-time = "2025-07-01T09:14:35.276Z" }, + { url = "https://files.pythonhosted.org/packages/4b/e8/100c3d114b1a0bf4042f27e0f87d2f25e857e838034e98ca98fe7b8c0a9c/pillow-11.3.0-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:30b7c02f3899d10f13d7a48163c8969e4e653f8b43416d23d13d1bbfdc93b9f8", size = 2170652, upload-time = "2025-07-01T09:14:37.203Z" }, + { url = "https://files.pythonhosted.org/packages/aa/86/3f758a28a6e381758545f7cdb4942e1cb79abd271bea932998fc0db93cb6/pillow-11.3.0-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:7859a4cc7c9295f5838015d8cc0a9c215b77e43d07a25e460f35cf516df8626f", size = 2227443, upload-time = "2025-07-01T09:14:39.344Z" }, + { url = "https://files.pythonhosted.org/packages/01/f4/91d5b3ffa718df2f53b0dc109877993e511f4fd055d7e9508682e8aba092/pillow-11.3.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:ec1ee50470b0d050984394423d96325b744d55c701a439d2bd66089bff963d3c", size = 5278474, upload-time = "2025-07-01T09:14:41.843Z" }, + { url = "https://files.pythonhosted.org/packages/f9/0e/37d7d3eca6c879fbd9dba21268427dffda1ab00d4eb05b32923d4fbe3b12/pillow-11.3.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7db51d222548ccfd274e4572fdbf3e810a5e66b00608862f947b163e613b67dd", size = 4686038, upload-time = "2025-07-01T09:14:44.008Z" }, + { url = "https://files.pythonhosted.org/packages/ff/b0/3426e5c7f6565e752d81221af9d3676fdbb4f352317ceafd42899aaf5d8a/pillow-11.3.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:2d6fcc902a24ac74495df63faad1884282239265c6839a0a6416d33faedfae7e", size = 5864407, upload-time = "2025-07-03T13:10:15.628Z" }, + { url = "https://files.pythonhosted.org/packages/fc/c1/c6c423134229f2a221ee53f838d4be9d82bab86f7e2f8e75e47b6bf6cd77/pillow-11.3.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f0f5d8f4a08090c6d6d578351a2b91acf519a54986c055af27e7a93feae6d3f1", size = 7639094, upload-time = "2025-07-03T13:10:21.857Z" }, + { url = "https://files.pythonhosted.org/packages/ba/c9/09e6746630fe6372c67c648ff9deae52a2bc20897d51fa293571977ceb5d/pillow-11.3.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c37d8ba9411d6003bba9e518db0db0c58a680ab9fe5179f040b0463644bc9805", size = 5973503, upload-time = "2025-07-01T09:14:45.698Z" }, + { url = "https://files.pythonhosted.org/packages/d5/1c/a2a29649c0b1983d3ef57ee87a66487fdeb45132df66ab30dd37f7dbe162/pillow-11.3.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:13f87d581e71d9189ab21fe0efb5a23e9f28552d5be6979e84001d3b8505abe8", size = 6642574, upload-time = "2025-07-01T09:14:47.415Z" }, + { url = "https://files.pythonhosted.org/packages/36/de/d5cc31cc4b055b6c6fd990e3e7f0f8aaf36229a2698501bcb0cdf67c7146/pillow-11.3.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:023f6d2d11784a465f09fd09a34b150ea4672e85fb3d05931d89f373ab14abb2", size = 6084060, upload-time = "2025-07-01T09:14:49.636Z" }, + { url = "https://files.pythonhosted.org/packages/d5/ea/502d938cbaeec836ac28a9b730193716f0114c41325db428e6b280513f09/pillow-11.3.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:45dfc51ac5975b938e9809451c51734124e73b04d0f0ac621649821a63852e7b", size = 6721407, upload-time = "2025-07-01T09:14:51.962Z" }, + { url = "https://files.pythonhosted.org/packages/45/9c/9c5e2a73f125f6cbc59cc7087c8f2d649a7ae453f83bd0362ff7c9e2aee2/pillow-11.3.0-cp313-cp313-win32.whl", hash = "sha256:a4d336baed65d50d37b88ca5b60c0fa9d81e3a87d4a7930d3880d1624d5b31f3", size = 6273841, upload-time = "2025-07-01T09:14:54.142Z" }, + { url = "https://files.pythonhosted.org/packages/23/85/397c73524e0cd212067e0c969aa245b01d50183439550d24d9f55781b776/pillow-11.3.0-cp313-cp313-win_amd64.whl", hash = "sha256:0bce5c4fd0921f99d2e858dc4d4d64193407e1b99478bc5cacecba2311abde51", size = 6978450, upload-time = "2025-07-01T09:14:56.436Z" }, + { url = "https://files.pythonhosted.org/packages/17/d2/622f4547f69cd173955194b78e4d19ca4935a1b0f03a302d655c9f6aae65/pillow-11.3.0-cp313-cp313-win_arm64.whl", hash = "sha256:1904e1264881f682f02b7f8167935cce37bc97db457f8e7849dc3a6a52b99580", size = 2423055, upload-time = "2025-07-01T09:14:58.072Z" }, + { url = "https://files.pythonhosted.org/packages/dd/80/a8a2ac21dda2e82480852978416cfacd439a4b490a501a288ecf4fe2532d/pillow-11.3.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:4c834a3921375c48ee6b9624061076bc0a32a60b5532b322cc0ea64e639dd50e", size = 5281110, upload-time = "2025-07-01T09:14:59.79Z" }, + { url = "https://files.pythonhosted.org/packages/44/d6/b79754ca790f315918732e18f82a8146d33bcd7f4494380457ea89eb883d/pillow-11.3.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:5e05688ccef30ea69b9317a9ead994b93975104a677a36a8ed8106be9260aa6d", size = 4689547, upload-time = "2025-07-01T09:15:01.648Z" }, + { url = "https://files.pythonhosted.org/packages/49/20/716b8717d331150cb00f7fdd78169c01e8e0c219732a78b0e59b6bdb2fd6/pillow-11.3.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:1019b04af07fc0163e2810167918cb5add8d74674b6267616021ab558dc98ced", size = 5901554, upload-time = "2025-07-03T13:10:27.018Z" }, + { url = "https://files.pythonhosted.org/packages/74/cf/a9f3a2514a65bb071075063a96f0a5cf949c2f2fce683c15ccc83b1c1cab/pillow-11.3.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f944255db153ebb2b19c51fe85dd99ef0ce494123f21b9db4877ffdfc5590c7c", size = 7669132, upload-time = "2025-07-03T13:10:33.01Z" }, + { url = "https://files.pythonhosted.org/packages/98/3c/da78805cbdbee9cb43efe8261dd7cc0b4b93f2ac79b676c03159e9db2187/pillow-11.3.0-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1f85acb69adf2aaee8b7da124efebbdb959a104db34d3a2cb0f3793dbae422a8", size = 6005001, upload-time = "2025-07-01T09:15:03.365Z" }, + { url = "https://files.pythonhosted.org/packages/6c/fa/ce044b91faecf30e635321351bba32bab5a7e034c60187fe9698191aef4f/pillow-11.3.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:05f6ecbeff5005399bb48d198f098a9b4b6bdf27b8487c7f38ca16eeb070cd59", size = 6668814, upload-time = "2025-07-01T09:15:05.655Z" }, + { url = "https://files.pythonhosted.org/packages/7b/51/90f9291406d09bf93686434f9183aba27b831c10c87746ff49f127ee80cb/pillow-11.3.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:a7bc6e6fd0395bc052f16b1a8670859964dbd7003bd0af2ff08342eb6e442cfe", size = 6113124, upload-time = "2025-07-01T09:15:07.358Z" }, + { url = "https://files.pythonhosted.org/packages/cd/5a/6fec59b1dfb619234f7636d4157d11fb4e196caeee220232a8d2ec48488d/pillow-11.3.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:83e1b0161c9d148125083a35c1c5a89db5b7054834fd4387499e06552035236c", size = 6747186, upload-time = "2025-07-01T09:15:09.317Z" }, + { url = "https://files.pythonhosted.org/packages/49/6b/00187a044f98255225f172de653941e61da37104a9ea60e4f6887717e2b5/pillow-11.3.0-cp313-cp313t-win32.whl", hash = "sha256:2a3117c06b8fb646639dce83694f2f9eac405472713fcb1ae887469c0d4f6788", size = 6277546, upload-time = "2025-07-01T09:15:11.311Z" }, + { url = "https://files.pythonhosted.org/packages/e8/5c/6caaba7e261c0d75bab23be79f1d06b5ad2a2ae49f028ccec801b0e853d6/pillow-11.3.0-cp313-cp313t-win_amd64.whl", hash = "sha256:857844335c95bea93fb39e0fa2726b4d9d758850b34075a7e3ff4f4fa3aa3b31", size = 6985102, upload-time = "2025-07-01T09:15:13.164Z" }, + { url = "https://files.pythonhosted.org/packages/f3/7e/b623008460c09a0cb38263c93b828c666493caee2eb34ff67f778b87e58c/pillow-11.3.0-cp313-cp313t-win_arm64.whl", hash = "sha256:8797edc41f3e8536ae4b10897ee2f637235c94f27404cac7297f7b607dd0716e", size = 2424803, upload-time = "2025-07-01T09:15:15.695Z" }, + { url = "https://files.pythonhosted.org/packages/73/f4/04905af42837292ed86cb1b1dabe03dce1edc008ef14c473c5c7e1443c5d/pillow-11.3.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:d9da3df5f9ea2a89b81bb6087177fb1f4d1c7146d583a3fe5c672c0d94e55e12", size = 5278520, upload-time = "2025-07-01T09:15:17.429Z" }, + { url = "https://files.pythonhosted.org/packages/41/b0/33d79e377a336247df6348a54e6d2a2b85d644ca202555e3faa0cf811ecc/pillow-11.3.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:0b275ff9b04df7b640c59ec5a3cb113eefd3795a8df80bac69646ef699c6981a", size = 4686116, upload-time = "2025-07-01T09:15:19.423Z" }, + { url = "https://files.pythonhosted.org/packages/49/2d/ed8bc0ab219ae8768f529597d9509d184fe8a6c4741a6864fea334d25f3f/pillow-11.3.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:0743841cabd3dba6a83f38a92672cccbd69af56e3e91777b0ee7f4dba4385632", size = 5864597, upload-time = "2025-07-03T13:10:38.404Z" }, + { url = "https://files.pythonhosted.org/packages/b5/3d/b932bb4225c80b58dfadaca9d42d08d0b7064d2d1791b6a237f87f661834/pillow-11.3.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2465a69cf967b8b49ee1b96d76718cd98c4e925414ead59fdf75cf0fd07df673", size = 7638246, upload-time = "2025-07-03T13:10:44.987Z" }, + { url = "https://files.pythonhosted.org/packages/09/b5/0487044b7c096f1b48f0d7ad416472c02e0e4bf6919541b111efd3cae690/pillow-11.3.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:41742638139424703b4d01665b807c6468e23e699e8e90cffefe291c5832b027", size = 5973336, upload-time = "2025-07-01T09:15:21.237Z" }, + { url = "https://files.pythonhosted.org/packages/a8/2d/524f9318f6cbfcc79fbc004801ea6b607ec3f843977652fdee4857a7568b/pillow-11.3.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:93efb0b4de7e340d99057415c749175e24c8864302369e05914682ba642e5d77", size = 6642699, upload-time = "2025-07-01T09:15:23.186Z" }, + { url = "https://files.pythonhosted.org/packages/6f/d2/a9a4f280c6aefedce1e8f615baaa5474e0701d86dd6f1dede66726462bbd/pillow-11.3.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7966e38dcd0fa11ca390aed7c6f20454443581d758242023cf36fcb319b1a874", size = 6083789, upload-time = "2025-07-01T09:15:25.1Z" }, + { url = "https://files.pythonhosted.org/packages/fe/54/86b0cd9dbb683a9d5e960b66c7379e821a19be4ac5810e2e5a715c09a0c0/pillow-11.3.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:98a9afa7b9007c67ed84c57c9e0ad86a6000da96eaa638e4f8abe5b65ff83f0a", size = 6720386, upload-time = "2025-07-01T09:15:27.378Z" }, + { url = "https://files.pythonhosted.org/packages/e7/95/88efcaf384c3588e24259c4203b909cbe3e3c2d887af9e938c2022c9dd48/pillow-11.3.0-cp314-cp314-win32.whl", hash = "sha256:02a723e6bf909e7cea0dac1b0e0310be9d7650cd66222a5f1c571455c0a45214", size = 6370911, upload-time = "2025-07-01T09:15:29.294Z" }, + { url = "https://files.pythonhosted.org/packages/2e/cc/934e5820850ec5eb107e7b1a72dd278140731c669f396110ebc326f2a503/pillow-11.3.0-cp314-cp314-win_amd64.whl", hash = "sha256:a418486160228f64dd9e9efcd132679b7a02a5f22c982c78b6fc7dab3fefb635", size = 7117383, upload-time = "2025-07-01T09:15:31.128Z" }, + { url = "https://files.pythonhosted.org/packages/d6/e9/9c0a616a71da2a5d163aa37405e8aced9a906d574b4a214bede134e731bc/pillow-11.3.0-cp314-cp314-win_arm64.whl", hash = "sha256:155658efb5e044669c08896c0c44231c5e9abcaadbc5cd3648df2f7c0b96b9a6", size = 2511385, upload-time = "2025-07-01T09:15:33.328Z" }, + { url = "https://files.pythonhosted.org/packages/1a/33/c88376898aff369658b225262cd4f2659b13e8178e7534df9e6e1fa289f6/pillow-11.3.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:59a03cdf019efbfeeed910bf79c7c93255c3d54bc45898ac2a4140071b02b4ae", size = 5281129, upload-time = "2025-07-01T09:15:35.194Z" }, + { url = "https://files.pythonhosted.org/packages/1f/70/d376247fb36f1844b42910911c83a02d5544ebd2a8bad9efcc0f707ea774/pillow-11.3.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:f8a5827f84d973d8636e9dc5764af4f0cf2318d26744b3d902931701b0d46653", size = 4689580, upload-time = "2025-07-01T09:15:37.114Z" }, + { url = "https://files.pythonhosted.org/packages/eb/1c/537e930496149fbac69efd2fc4329035bbe2e5475b4165439e3be9cb183b/pillow-11.3.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ee92f2fd10f4adc4b43d07ec5e779932b4eb3dbfbc34790ada5a6669bc095aa6", size = 5902860, upload-time = "2025-07-03T13:10:50.248Z" }, + { url = "https://files.pythonhosted.org/packages/bd/57/80f53264954dcefeebcf9dae6e3eb1daea1b488f0be8b8fef12f79a3eb10/pillow-11.3.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c96d333dcf42d01f47b37e0979b6bd73ec91eae18614864622d9b87bbd5bbf36", size = 7670694, upload-time = "2025-07-03T13:10:56.432Z" }, + { url = "https://files.pythonhosted.org/packages/70/ff/4727d3b71a8578b4587d9c276e90efad2d6fe0335fd76742a6da08132e8c/pillow-11.3.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4c96f993ab8c98460cd0c001447bff6194403e8b1d7e149ade5f00594918128b", size = 6005888, upload-time = "2025-07-01T09:15:39.436Z" }, + { url = "https://files.pythonhosted.org/packages/05/ae/716592277934f85d3be51d7256f3636672d7b1abfafdc42cf3f8cbd4b4c8/pillow-11.3.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:41342b64afeba938edb034d122b2dda5db2139b9a4af999729ba8818e0056477", size = 6670330, upload-time = "2025-07-01T09:15:41.269Z" }, + { url = "https://files.pythonhosted.org/packages/e7/bb/7fe6cddcc8827b01b1a9766f5fdeb7418680744f9082035bdbabecf1d57f/pillow-11.3.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:068d9c39a2d1b358eb9f245ce7ab1b5c3246c7c8c7d9ba58cfa5b43146c06e50", size = 6114089, upload-time = "2025-07-01T09:15:43.13Z" }, + { url = "https://files.pythonhosted.org/packages/8b/f5/06bfaa444c8e80f1a8e4bff98da9c83b37b5be3b1deaa43d27a0db37ef84/pillow-11.3.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:a1bc6ba083b145187f648b667e05a2534ecc4b9f2784c2cbe3089e44868f2b9b", size = 6748206, upload-time = "2025-07-01T09:15:44.937Z" }, + { url = "https://files.pythonhosted.org/packages/f0/77/bc6f92a3e8e6e46c0ca78abfffec0037845800ea38c73483760362804c41/pillow-11.3.0-cp314-cp314t-win32.whl", hash = "sha256:118ca10c0d60b06d006be10a501fd6bbdfef559251ed31b794668ed569c87e12", size = 6377370, upload-time = "2025-07-01T09:15:46.673Z" }, + { url = "https://files.pythonhosted.org/packages/4a/82/3a721f7d69dca802befb8af08b7c79ebcab461007ce1c18bd91a5d5896f9/pillow-11.3.0-cp314-cp314t-win_amd64.whl", hash = "sha256:8924748b688aa210d79883357d102cd64690e56b923a186f35a82cbc10f997db", size = 7121500, upload-time = "2025-07-01T09:15:48.512Z" }, + { url = "https://files.pythonhosted.org/packages/89/c7/5572fa4a3f45740eaab6ae86fcdf7195b55beac1371ac8c619d880cfe948/pillow-11.3.0-cp314-cp314t-win_arm64.whl", hash = "sha256:79ea0d14d3ebad43ec77ad5272e6ff9bba5b679ef73375ea760261207fa8e0aa", size = 2512835, upload-time = "2025-07-01T09:15:50.399Z" }, +] + +[[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 = "pptx-to-transcript" +version = "0.1.0" +source = { virtual = "." } +dependencies = [ + { name = "faiss-cpu" }, + { name = "groq" }, + { name = "ipykernel" }, + { name = "jupyter" }, + { name = "llama-api-client" }, + { name = "matplotlib" }, + { name = "numpy" }, + { name = "openpyxl" }, + { name = "pandas" }, + { name = "pillow" }, + { name = "pymupdf" }, + { name = "python-dotenv" }, + { name = "python-pptx" }, + { name = "pyyaml" }, + { name = "seaborn" }, + { name = "sentence-transformers" }, + { name = "tqdm" }, +] + +[package.optional-dependencies] +dev = [ + { name = "memory-profiler" }, + { name = "pytest" }, + { name = "pytest-benchmark" }, + { name = "pytest-mock" }, +] + +[package.metadata] +requires-dist = [ + { name = "faiss-cpu", specifier = ">=1.11.0.post1" }, + { name = "groq", specifier = ">=0.31.0" }, + { name = "ipykernel", specifier = ">=6.30.1" }, + { name = "jupyter", specifier = ">=1.1.1" }, + { name = "llama-api-client", specifier = ">=0.1.0" }, + { name = "matplotlib", specifier = ">=3.10.5" }, + { name = "memory-profiler", marker = "extra == 'dev'", specifier = ">=0.60.0" }, + { name = "numpy", specifier = ">=2.3.2" }, + { name = "openpyxl", specifier = ">=3.1.5" }, + { name = "pandas", specifier = ">=2.3.1" }, + { name = "pillow", specifier = ">=11.3.0" }, + { name = "pymupdf", specifier = ">=1.24.0" }, + { name = "pytest", marker = "extra == 'dev'", specifier = ">=7.0.0" }, + { name = "pytest-benchmark", marker = "extra == 'dev'", specifier = ">=4.0.0" }, + { name = "pytest-mock", marker = "extra == 'dev'", specifier = ">=3.10.0" }, + { name = "python-dotenv", specifier = ">=1.0.0" }, + { name = "python-pptx", specifier = ">=1.0.2" }, + { name = "pyyaml", specifier = ">=6.0.0" }, + { name = "seaborn", specifier = ">=0.13.2" }, + { name = "sentence-transformers", specifier = ">=2.2.0,<3.0.0" }, + { name = "tqdm", specifier = ">=4.66.0" }, +] +provides-extras = ["dev"] + +[[package]] +name = "prometheus-client" +version = "0.22.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5e/cf/40dde0a2be27cc1eb41e333d1a674a74ce8b8b0457269cc640fd42b07cf7/prometheus_client-0.22.1.tar.gz", hash = "sha256:190f1331e783cf21eb60bca559354e0a4d4378facecf78f5428c39b675d20d28", size = 69746, upload-time = "2025-06-02T14:29:01.152Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/32/ae/ec06af4fe3ee72d16973474f122541746196aaa16cea6f66d18b963c6177/prometheus_client-0.22.1-py3-none-any.whl", hash = "sha256:cca895342e308174341b2cbf99a56bef291fbc0ef7b9e5412a0f26d653ba7094", size = 58694, upload-time = "2025-06-02T14:29:00.068Z" }, +] + +[[package]] +name = "prompt-toolkit" +version = "3.0.51" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "wcwidth" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/bb/6e/9d084c929dfe9e3bfe0c6a47e31f78a25c54627d64a66e884a8bf5474f1c/prompt_toolkit-3.0.51.tar.gz", hash = "sha256:931a162e3b27fc90c86f1b48bb1fb2c528c2761475e57c9c06de13311c7b54ed", size = 428940, upload-time = "2025-04-15T09:18:47.731Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ce/4f/5249960887b1fbe561d9ff265496d170b55a735b76724f10ef19f9e40716/prompt_toolkit-3.0.51-py3-none-any.whl", hash = "sha256:52742911fde84e2d423e2f9a4cf1de7d7ac4e51958f648d9540e0fb8db077b07", size = 387810, upload-time = "2025-04-15T09:18:44.753Z" }, +] + +[[package]] +name = "psutil" +version = "7.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/2a/80/336820c1ad9286a4ded7e845b2eccfcb27851ab8ac6abece774a6ff4d3de/psutil-7.0.0.tar.gz", hash = "sha256:7be9c3eba38beccb6495ea33afd982a44074b78f28c434a1f51cc07fd315c456", size = 497003, upload-time = "2025-02-13T21:54:07.946Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ed/e6/2d26234410f8b8abdbf891c9da62bee396583f713fb9f3325a4760875d22/psutil-7.0.0-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:101d71dc322e3cffd7cea0650b09b3d08b8e7c4109dd6809fe452dfd00e58b25", size = 238051, upload-time = "2025-02-13T21:54:12.36Z" }, + { url = "https://files.pythonhosted.org/packages/04/8b/30f930733afe425e3cbfc0e1468a30a18942350c1a8816acfade80c005c4/psutil-7.0.0-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:39db632f6bb862eeccf56660871433e111b6ea58f2caea825571951d4b6aa3da", size = 239535, upload-time = "2025-02-13T21:54:16.07Z" }, + { url = "https://files.pythonhosted.org/packages/2a/ed/d362e84620dd22876b55389248e522338ed1bf134a5edd3b8231d7207f6d/psutil-7.0.0-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1fcee592b4c6f146991ca55919ea3d1f8926497a713ed7faaf8225e174581e91", size = 275004, upload-time = "2025-02-13T21:54:18.662Z" }, + { url = "https://files.pythonhosted.org/packages/bf/b9/b0eb3f3cbcb734d930fdf839431606844a825b23eaf9a6ab371edac8162c/psutil-7.0.0-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4b1388a4f6875d7e2aff5c4ca1cc16c545ed41dd8bb596cefea80111db353a34", size = 277986, upload-time = "2025-02-13T21:54:21.811Z" }, + { url = "https://files.pythonhosted.org/packages/eb/a2/709e0fe2f093556c17fbafda93ac032257242cabcc7ff3369e2cb76a97aa/psutil-7.0.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a5f098451abc2828f7dc6b58d44b532b22f2088f4999a937557b603ce72b1993", size = 279544, upload-time = "2025-02-13T21:54:24.68Z" }, + { url = "https://files.pythonhosted.org/packages/50/e6/eecf58810b9d12e6427369784efe814a1eec0f492084ce8eb8f4d89d6d61/psutil-7.0.0-cp37-abi3-win32.whl", hash = "sha256:ba3fcef7523064a6c9da440fc4d6bd07da93ac726b5733c29027d7dc95b39d99", size = 241053, upload-time = "2025-02-13T21:54:34.31Z" }, + { url = "https://files.pythonhosted.org/packages/50/1b/6921afe68c74868b4c9fa424dad3be35b095e16687989ebbb50ce4fceb7c/psutil-7.0.0-cp37-abi3-win_amd64.whl", hash = "sha256:4cf3d4eb1aa9b348dec30105c55cd9b7d4629285735a102beb4441e38db90553", size = 244885, upload-time = "2025-02-13T21:54:37.486Z" }, +] + +[[package]] +name = "ptyprocess" +version = "0.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/20/e5/16ff212c1e452235a90aeb09066144d0c5a6a8c0834397e03f5224495c4e/ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220", size = 70762, upload-time = "2020-12-28T15:15:30.155Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/22/a6/858897256d0deac81a172289110f31629fc4cee19b6f01283303e18c8db3/ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35", size = 13993, upload-time = "2020-12-28T15:15:28.35Z" }, +] + +[[package]] +name = "pure-eval" +version = "0.2.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cd/05/0a34433a064256a578f1783a10da6df098ceaa4a57bbeaa96a6c0352786b/pure_eval-0.2.3.tar.gz", hash = "sha256:5f4e983f40564c576c7c8635ae88db5956bb2229d7e9237d03b3c0b0190eaf42", size = 19752, upload-time = "2024-07-21T12:58:21.801Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8e/37/efad0257dc6e593a18957422533ff0f87ede7c9c6ea010a2177d738fb82f/pure_eval-0.2.3-py3-none-any.whl", hash = "sha256:1db8e35b67b3d218d818ae653e27f06c3aa420901fa7b081ca98cbedc874e0d0", size = 11842, upload-time = "2024-07-21T12:58:20.04Z" }, +] + +[[package]] +name = "py-cpuinfo" +version = "9.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/37/a8/d832f7293ebb21690860d2e01d8115e5ff6f2ae8bbdc953f0eb0fa4bd2c7/py-cpuinfo-9.0.0.tar.gz", hash = "sha256:3cdbbf3fac90dc6f118bfd64384f309edeadd902d7c8fb17f02ffa1fc3f49690", size = 104716, upload-time = "2022-10-25T20:38:06.303Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e0/a9/023730ba63db1e494a271cb018dcd361bd2c917ba7004c3e49d5daf795a2/py_cpuinfo-9.0.0-py3-none-any.whl", hash = "sha256:859625bc251f64e21f077d099d4162689c762b5d6a4c3c97553d56241c9674d5", size = 22335, upload-time = "2022-10-25T20:38:27.636Z" }, +] + +[[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.7" +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/00/dd/4325abf92c39ba8623b5af936ddb36ffcfe0beae70405d456ab1fb2f5b8c/pydantic-2.11.7.tar.gz", hash = "sha256:d989c3c6cb79469287b1569f7447a17848c998458d49ebe294e975b9baf0f0db", size = 788350, upload-time = "2025-06-14T08:33:17.137Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6a/c0/ec2b1c8712ca690e5d61979dee872603e92b8a32f94cc1b72d53beab008a/pydantic-2.11.7-py3-none-any.whl", hash = "sha256:dde5df002701f6de26248661f6835bbe296a47bf73990135c7d07ce741b9623b", size = 444782, upload-time = "2025-06-14T08:33:14.905Z" }, +] + +[[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/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" }, +] + +[[package]] +name = "pygments" +version = "2.19.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631, upload-time = "2025-06-21T13:39:12.283Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload-time = "2025-06-21T13:39:07.939Z" }, +] + +[[package]] +name = "pymupdf" +version = "1.26.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6d/d4/70a265e4bcd43e97480ae62da69396ef4507c8f9cfd179005ee731c92a04/pymupdf-1.26.3.tar.gz", hash = "sha256:b7d2c3ffa9870e1e4416d18862f5ccd356af5fe337b4511093bbbce2ca73b7e5", size = 75990308, upload-time = "2025-07-02T21:34:22.243Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/70/d3/c7af70545cd3097a869fd635bb6222108d3a0fb28c0b8254754a126c4cbb/pymupdf-1.26.3-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:ded891963944e5f13b03b88f6d9e982e816a4ec8689fe360876eef000c161f2b", size = 23057205, upload-time = "2025-07-02T21:26:16.326Z" }, + { url = "https://files.pythonhosted.org/packages/04/3d/ec5b69bfeaa5deefa7141fc0b20d77bb20404507cf17196b4eb59f1f2977/pymupdf-1.26.3-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:436a33c738bb10eadf00395d18a6992b801ffb26521ee1f361ae786dd283327a", size = 22406630, upload-time = "2025-07-02T21:27:10.112Z" }, + { url = "https://files.pythonhosted.org/packages/fc/20/661d3894bb05ad75ed6ca103ee2c3fa44d88a458b5c8d4a946b9c0f2569b/pymupdf-1.26.3-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:a2d7a3cd442f12f05103cb3bb1415111517f0a97162547a3720f3bbbc5e0b51c", size = 23450287, upload-time = "2025-07-03T07:22:19.317Z" }, + { url = "https://files.pythonhosted.org/packages/9c/7f/21828f018e65b16a033731d21f7b46d93fa81c6e8257f769ca4a1c2a1cb0/pymupdf-1.26.3-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:454f38c8cf07eb333eb4646dca10517b6e90f57ce2daa2265a78064109d85555", size = 24057319, upload-time = "2025-07-02T21:28:26.697Z" }, + { url = "https://files.pythonhosted.org/packages/71/5d/e8f88cd5a45b8f5fa6590ce8cef3ce0fad30eac6aac8aea12406f95bee7d/pymupdf-1.26.3-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:759b75d2f710ff4edf8d097d2e98f60e9ecef47632cead6f949b3412facdb9f0", size = 24261350, upload-time = "2025-07-02T21:29:21.733Z" }, + { url = "https://files.pythonhosted.org/packages/82/22/ecc560e4f281b5dffafbf3a81f023d268b1746d028044f495115b74a2e70/pymupdf-1.26.3-cp39-abi3-win32.whl", hash = "sha256:a839ed44742faa1cd4956bb18068fe5aae435d67ce915e901318646c4e7bbea6", size = 17116371, upload-time = "2025-07-02T21:30:23.253Z" }, + { url = "https://files.pythonhosted.org/packages/4a/26/8c72973b8833a72785cedc3981eb59b8ac7075942718bbb7b69b352cdde4/pymupdf-1.26.3-cp39-abi3-win_amd64.whl", hash = "sha256:b4cd5124d05737944636cf45fc37ce5824f10e707b0342efe109c7b6bd37a9cc", size = 18735124, upload-time = "2025-07-02T21:31:10.992Z" }, +] + +[[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.4.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "iniconfig" }, + { name = "packaging" }, + { name = "pluggy" }, + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/08/ba/45911d754e8eba3d5a841a5ce61a65a685ff1798421ac054f85aa8747dfb/pytest-8.4.1.tar.gz", hash = "sha256:7c67fd69174877359ed9371ec3af8a3d2b04741818c51e5e99cc1742251fa93c", size = 1517714, upload-time = "2025-06-18T05:48:06.109Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/29/16/c8a903f4c4dffe7a12843191437d7cd8e32751d5de349d45d3fe69544e87/pytest-8.4.1-py3-none-any.whl", hash = "sha256:539c70ba6fcead8e78eebbf1115e8b589e7565830d7d006a8723f19ac8a0afb7", size = 365474, upload-time = "2025-06-18T05:48:03.955Z" }, +] + +[[package]] +name = "pytest-benchmark" +version = "5.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "py-cpuinfo" }, + { name = "pytest" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/39/d0/a8bd08d641b393db3be3819b03e2d9bb8760ca8479080a26a5f6e540e99c/pytest-benchmark-5.1.0.tar.gz", hash = "sha256:9ea661cdc292e8231f7cd4c10b0319e56a2118e2c09d9f50e1b3d150d2aca105", size = 337810, upload-time = "2024-10-30T11:51:48.521Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/d6/b41653199ea09d5969d4e385df9bbfd9a100f28ca7e824ce7c0a016e3053/pytest_benchmark-5.1.0-py3-none-any.whl", hash = "sha256:922de2dfa3033c227c96da942d1878191afa135a29485fb942e85dff1c592c89", size = 44259, upload-time = "2024-10-30T11:51:45.94Z" }, +] + +[[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 = "python-dotenv" +version = "1.1.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f6/b0/4bc07ccd3572a2f9df7e6782f52b0c6c90dcbb803ac4a167702d7d0dfe1e/python_dotenv-1.1.1.tar.gz", hash = "sha256:a8a6399716257f45be6a007360200409fce5cda2661e3dec71d23dc15f6189ab", size = 41978, upload-time = "2025-06-24T04:21:07.341Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5f/ed/539768cf28c661b5b068d66d96a2f155c4971a5d55684a514c1a0e0dec2f/python_dotenv-1.1.1-py3-none-any.whl", hash = "sha256:31f23644fe2602f88ff55e1f5c79ba497e01224ee7737937930c448e4d0e24dc", size = 20556, upload-time = "2025-06-24T04:21:06.073Z" }, +] + +[[package]] +name = "python-json-logger" +version = "3.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/9e/de/d3144a0bceede957f961e975f3752760fbe390d57fbe194baf709d8f1f7b/python_json_logger-3.3.0.tar.gz", hash = "sha256:12b7e74b17775e7d565129296105bbe3910842d9d0eb083fc83a6a617aa8df84", size = 16642, upload-time = "2025-03-07T07:08:27.301Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/08/20/0f2523b9e50a8052bc6a8b732dfc8568abbdc42010aef03a2d750bdab3b2/python_json_logger-3.3.0-py3-none-any.whl", hash = "sha256:dd980fae8cffb24c13caf6e158d3d61c0d6d22342f932cb6e9deedab3d35eec7", size = 15163, upload-time = "2025-03-07T07:08:25.627Z" }, +] + +[[package]] +name = "python-pptx" +version = "1.0.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "lxml" }, + { name = "pillow" }, + { name = "typing-extensions" }, + { name = "xlsxwriter" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/52/a9/0c0db8d37b2b8a645666f7fd8accea4c6224e013c42b1d5c17c93590cd06/python_pptx-1.0.2.tar.gz", hash = "sha256:479a8af0eaf0f0d76b6f00b0887732874ad2e3188230315290cd1f9dd9cc7095", size = 10109297, upload-time = "2024-08-07T17:33:37.772Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d9/4f/00be2196329ebbff56ce564aa94efb0fbc828d00de250b1980de1a34ab49/python_pptx-1.0.2-py3-none-any.whl", hash = "sha256:160838e0b8565a8b1f67947675886e9fea18aa5e795db7ae531606d68e785cba", size = 472788, upload-time = "2024-08-07T17:33:28.192Z" }, +] + +[[package]] +name = "pytz" +version = "2025.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f8/bf/abbd3cdfb8fbc7fb3d4d38d320f2441b1e7cbe29be4f23797b4a2b5d8aac/pytz-2025.2.tar.gz", hash = "sha256:360b9e3dbb49a209c21ad61809c7fb453643e048b38924c765813546746e81c3", size = 320884, upload-time = "2025-03-25T02:25:00.538Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/81/c4/34e93fe5f5429d7570ec1fa436f1986fb1f00c3e0f43a589fe2bbcd22c3f/pytz-2025.2-py2.py3-none-any.whl", hash = "sha256:5ddf76296dd8c44c26eb8f4b6f35488f3ccbf6fbbd7adee0b7262d43f0ec2f00", size = 509225, upload-time = "2025-03-25T02:24:58.468Z" }, +] + +[[package]] +name = "pywin32" +version = "311" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/ab/01ea1943d4eba0f850c3c61e78e8dd59757ff815ff3ccd0a84de5f541f42/pywin32-311-cp312-cp312-win32.whl", hash = "sha256:750ec6e621af2b948540032557b10a2d43b0cee2ae9758c54154d711cc852d31", size = 8706543, upload-time = "2025-07-14T20:13:20.765Z" }, + { url = "https://files.pythonhosted.org/packages/d1/a8/a0e8d07d4d051ec7502cd58b291ec98dcc0c3fff027caad0470b72cfcc2f/pywin32-311-cp312-cp312-win_amd64.whl", hash = "sha256:b8c095edad5c211ff31c05223658e71bf7116daa0ecf3ad85f3201ea3190d067", size = 9495040, upload-time = "2025-07-14T20:13:22.543Z" }, + { url = "https://files.pythonhosted.org/packages/ba/3a/2ae996277b4b50f17d61f0603efd8253cb2d79cc7ae159468007b586396d/pywin32-311-cp312-cp312-win_arm64.whl", hash = "sha256:e286f46a9a39c4a18b319c28f59b61de793654af2f395c102b4f819e584b5852", size = 8710102, upload-time = "2025-07-14T20:13:24.682Z" }, + { url = "https://files.pythonhosted.org/packages/a5/be/3fd5de0979fcb3994bfee0d65ed8ca9506a8a1260651b86174f6a86f52b3/pywin32-311-cp313-cp313-win32.whl", hash = "sha256:f95ba5a847cba10dd8c4d8fefa9f2a6cf283b8b88ed6178fa8a6c1ab16054d0d", size = 8705700, upload-time = "2025-07-14T20:13:26.471Z" }, + { url = "https://files.pythonhosted.org/packages/e3/28/e0a1909523c6890208295a29e05c2adb2126364e289826c0a8bc7297bd5c/pywin32-311-cp313-cp313-win_amd64.whl", hash = "sha256:718a38f7e5b058e76aee1c56ddd06908116d35147e133427e59a3983f703a20d", size = 9494700, upload-time = "2025-07-14T20:13:28.243Z" }, + { url = "https://files.pythonhosted.org/packages/04/bf/90339ac0f55726dce7d794e6d79a18a91265bdf3aa70b6b9ca52f35e022a/pywin32-311-cp313-cp313-win_arm64.whl", hash = "sha256:7b4075d959648406202d92a2310cb990fea19b535c7f4a78d3f5e10b926eeb8a", size = 8709318, upload-time = "2025-07-14T20:13:30.348Z" }, + { url = "https://files.pythonhosted.org/packages/c9/31/097f2e132c4f16d99a22bfb777e0fd88bd8e1c634304e102f313af69ace5/pywin32-311-cp314-cp314-win32.whl", hash = "sha256:b7a2c10b93f8986666d0c803ee19b5990885872a7de910fc460f9b0c2fbf92ee", size = 8840714, upload-time = "2025-07-14T20:13:32.449Z" }, + { url = "https://files.pythonhosted.org/packages/90/4b/07c77d8ba0e01349358082713400435347df8426208171ce297da32c313d/pywin32-311-cp314-cp314-win_amd64.whl", hash = "sha256:3aca44c046bd2ed8c90de9cb8427f581c479e594e99b5c0bb19b29c10fd6cb87", size = 9656800, upload-time = "2025-07-14T20:13:34.312Z" }, + { url = "https://files.pythonhosted.org/packages/c0/d2/21af5c535501a7233e734b8af901574572da66fcc254cb35d0609c9080dd/pywin32-311-cp314-cp314-win_arm64.whl", hash = "sha256:a508e2d9025764a8270f93111a970e1d0fbfc33f4153b388bb649b7eec4f9b42", size = 8932540, upload-time = "2025-07-14T20:13:36.379Z" }, +] + +[[package]] +name = "pywinpty" +version = "2.0.15" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/2d/7c/917f9c4681bb8d34bfbe0b79d36bbcd902651aeab48790df3d30ba0202fb/pywinpty-2.0.15.tar.gz", hash = "sha256:312cf39153a8736c617d45ce8b6ad6cd2107de121df91c455b10ce6bba7a39b2", size = 29017, upload-time = "2025-02-03T21:53:23.265Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/88/e5/9714def18c3a411809771a3fbcec70bffa764b9675afb00048a620fca604/pywinpty-2.0.15-cp312-cp312-win_amd64.whl", hash = "sha256:83a8f20b430bbc5d8957249f875341a60219a4e971580f2ba694fbfb54a45ebc", size = 1405243, upload-time = "2025-02-03T21:56:52.476Z" }, + { url = "https://files.pythonhosted.org/packages/fb/16/2ab7b3b7f55f3c6929e5f629e1a68362981e4e5fed592a2ed1cb4b4914a5/pywinpty-2.0.15-cp313-cp313-win_amd64.whl", hash = "sha256:ab5920877dd632c124b4ed17bc6dd6ef3b9f86cd492b963ffdb1a67b85b0f408", size = 1405020, upload-time = "2025-02-03T21:56:04.753Z" }, + { url = "https://files.pythonhosted.org/packages/7c/16/edef3515dd2030db2795dbfbe392232c7a0f3dc41b98e92b38b42ba497c7/pywinpty-2.0.15-cp313-cp313t-win_amd64.whl", hash = "sha256:a4560ad8c01e537708d2790dbe7da7d986791de805d89dd0d3697ca59e9e4901", size = 1404151, upload-time = "2025-02-03T21:55:53.628Z" }, +] + +[[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/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" }, +] + +[[package]] +name = "pyzmq" +version = "27.0.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi", marker = "implementation_name == 'pypy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/30/5f/557d2032a2f471edbcc227da724c24a1c05887b5cda1e3ae53af98b9e0a5/pyzmq-27.0.1.tar.gz", hash = "sha256:45c549204bc20e7484ffd2555f6cf02e572440ecf2f3bdd60d4404b20fddf64b", size = 281158, upload-time = "2025-08-03T05:05:40.352Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0e/9b/c0957041067c7724b310f22c398be46399297c12ed834c3bc42200a2756f/pyzmq-27.0.1-cp312-abi3-macosx_10_15_universal2.whl", hash = "sha256:af7ebce2a1e7caf30c0bb64a845f63a69e76a2fadbc1cac47178f7bb6e657bdd", size = 1305432, upload-time = "2025-08-03T05:03:32.177Z" }, + { url = "https://files.pythonhosted.org/packages/8e/55/bd3a312790858f16b7def3897a0c3eb1804e974711bf7b9dcb5f47e7f82c/pyzmq-27.0.1-cp312-abi3-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:8f617f60a8b609a13099b313e7e525e67f84ef4524b6acad396d9ff153f6e4cd", size = 895095, upload-time = "2025-08-03T05:03:33.918Z" }, + { url = "https://files.pythonhosted.org/packages/20/50/fc384631d8282809fb1029a4460d2fe90fa0370a0e866a8318ed75c8d3bb/pyzmq-27.0.1-cp312-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1d59dad4173dc2a111f03e59315c7bd6e73da1a9d20a84a25cf08325b0582b1a", size = 651826, upload-time = "2025-08-03T05:03:35.818Z" }, + { url = "https://files.pythonhosted.org/packages/7e/0a/2356305c423a975000867de56888b79e44ec2192c690ff93c3109fd78081/pyzmq-27.0.1-cp312-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f5b6133c8d313bde8bd0d123c169d22525300ff164c2189f849de495e1344577", size = 839751, upload-time = "2025-08-03T05:03:37.265Z" }, + { url = "https://files.pythonhosted.org/packages/d7/1b/81e95ad256ca7e7ccd47f5294c1c6da6e2b64fbace65b84fe8a41470342e/pyzmq-27.0.1-cp312-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:58cca552567423f04d06a075f4b473e78ab5bdb906febe56bf4797633f54aa4e", size = 1641359, upload-time = "2025-08-03T05:03:38.799Z" }, + { url = "https://files.pythonhosted.org/packages/50/63/9f50ec965285f4e92c265c8f18344e46b12803666d8b73b65d254d441435/pyzmq-27.0.1-cp312-abi3-musllinux_1_2_i686.whl", hash = "sha256:4b9d8e26fb600d0d69cc9933e20af08552e97cc868a183d38a5c0d661e40dfbb", size = 2020281, upload-time = "2025-08-03T05:03:40.338Z" }, + { url = "https://files.pythonhosted.org/packages/02/4a/19e3398d0dc66ad2b463e4afa1fc541d697d7bc090305f9dfb948d3dfa29/pyzmq-27.0.1-cp312-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:2329f0c87f0466dce45bba32b63f47018dda5ca40a0085cc5c8558fea7d9fc55", size = 1877112, upload-time = "2025-08-03T05:03:42.012Z" }, + { url = "https://files.pythonhosted.org/packages/bf/42/c562e9151aa90ed1d70aac381ea22a929d6b3a2ce4e1d6e2e135d34fd9c6/pyzmq-27.0.1-cp312-abi3-win32.whl", hash = "sha256:57bb92abdb48467b89c2d21da1ab01a07d0745e536d62afd2e30d5acbd0092eb", size = 558177, upload-time = "2025-08-03T05:03:43.979Z" }, + { url = "https://files.pythonhosted.org/packages/40/96/5c50a7d2d2b05b19994bf7336b97db254299353dd9b49b565bb71b485f03/pyzmq-27.0.1-cp312-abi3-win_amd64.whl", hash = "sha256:ff3f8757570e45da7a5bedaa140489846510014f7a9d5ee9301c61f3f1b8a686", size = 618923, upload-time = "2025-08-03T05:03:45.438Z" }, + { url = "https://files.pythonhosted.org/packages/13/33/1ec89c8f21c89d21a2eaff7def3676e21d8248d2675705e72554fb5a6f3f/pyzmq-27.0.1-cp312-abi3-win_arm64.whl", hash = "sha256:df2c55c958d3766bdb3e9d858b911288acec09a9aab15883f384fc7180df5bed", size = 552358, upload-time = "2025-08-03T05:03:46.887Z" }, + { url = "https://files.pythonhosted.org/packages/6c/a0/f26e276211ec8090a4d11e4ec70eb8a8b15781e591c1d44ce62f372963a0/pyzmq-27.0.1-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:497bd8af534ae55dc4ef67eebd1c149ff2a0b0f1e146db73c8b5a53d83c1a5f5", size = 1122287, upload-time = "2025-08-03T05:03:48.838Z" }, + { url = "https://files.pythonhosted.org/packages/9c/d8/af4b507e4f7eeea478cc8ee873995a6fd55582bfb99140593ed460e1db3c/pyzmq-27.0.1-cp313-cp313-android_24_x86_64.whl", hash = "sha256:a066ea6ad6218b4c233906adf0ae67830f451ed238419c0db609310dd781fbe7", size = 1155756, upload-time = "2025-08-03T05:03:50.907Z" }, + { url = "https://files.pythonhosted.org/packages/ac/55/37fae0013e11f88681da42698e550b08a316d608242551f65095cc99232a/pyzmq-27.0.1-cp313-cp313t-macosx_10_15_universal2.whl", hash = "sha256:72d235d6365ca73d8ce92f7425065d70f5c1e19baa458eb3f0d570e425b73a96", size = 1340826, upload-time = "2025-08-03T05:03:52.568Z" }, + { url = "https://files.pythonhosted.org/packages/f2/e4/3a87854c64b26fcf63a9d1b6f4382bd727d4797c772ceb334a97b7489be9/pyzmq-27.0.1-cp313-cp313t-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:313a7b374e3dc64848644ca348a51004b41726f768b02e17e689f1322366a4d9", size = 897283, upload-time = "2025-08-03T05:03:54.167Z" }, + { url = "https://files.pythonhosted.org/packages/17/3e/4296c6b0ad2d07be11ae1395dccf9cae48a0a655cf9be1c3733ad2b591d1/pyzmq-27.0.1-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:119ce8590409702394f959c159d048002cbed2f3c0645ec9d6a88087fc70f0f1", size = 660565, upload-time = "2025-08-03T05:03:56.152Z" }, + { url = "https://files.pythonhosted.org/packages/72/41/a33ba3aa48b45b23c4cd4ac49aafde46f3e0f81939f2bfb3b6171a437122/pyzmq-27.0.1-cp313-cp313t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:45c3e00ce16896ace2cd770ab9057a7cf97d4613ea5f2a13f815141d8b6894b9", size = 847680, upload-time = "2025-08-03T05:03:57.696Z" }, + { url = "https://files.pythonhosted.org/packages/3f/8c/bf2350bb25b3b58d2e5b5d2290ffab0e923f0cc6d02288d3fbf4baa6e4d1/pyzmq-27.0.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:678e50ec112bdc6df5a83ac259a55a4ba97a8b314c325ab26b3b5b071151bc61", size = 1650151, upload-time = "2025-08-03T05:03:59.387Z" }, + { url = "https://files.pythonhosted.org/packages/f7/1a/a5a07c54890891344a8ddc3d5ab320dd3c4e39febb6e4472546e456d5157/pyzmq-27.0.1-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:d0b96c30be9f9387b18b18b6133c75a7b1b0065da64e150fe1feb5ebf31ece1c", size = 2023766, upload-time = "2025-08-03T05:04:01.883Z" }, + { url = "https://files.pythonhosted.org/packages/62/5e/514dcff08f02c6c8a45a6e23621901139cf853be7ac5ccd0b9407c3aa3de/pyzmq-27.0.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:88dc92d9eb5ea4968123e74db146d770b0c8d48f0e2bfb1dbc6c50a8edb12d64", size = 1885195, upload-time = "2025-08-03T05:04:03.923Z" }, + { url = "https://files.pythonhosted.org/packages/c8/91/87f74f98a487fbef0b115f6025e4a295129fd56b2b633a03ba7d5816ecc2/pyzmq-27.0.1-cp313-cp313t-win32.whl", hash = "sha256:6dcbcb34f5c9b0cefdfc71ff745459241b7d3cda5b27c7ad69d45afc0821d1e1", size = 574213, upload-time = "2025-08-03T05:04:05.905Z" }, + { url = "https://files.pythonhosted.org/packages/e6/d7/07f7d0d7f4c81e08be7b60e52ff2591c557377c017f96204d33d5fca1b07/pyzmq-27.0.1-cp313-cp313t-win_amd64.whl", hash = "sha256:b9fd0fda730461f510cfd9a40fafa5355d65f5e3dbdd8d6dfa342b5b3f5d1949", size = 640202, upload-time = "2025-08-03T05:04:07.439Z" }, + { url = "https://files.pythonhosted.org/packages/ab/83/21d66bcef6fb803647a223cbde95111b099e2176277c0cbc8b099c485510/pyzmq-27.0.1-cp313-cp313t-win_arm64.whl", hash = "sha256:56a3b1853f3954ec1f0e91085f1350cc57d18f11205e4ab6e83e4b7c414120e0", size = 561514, upload-time = "2025-08-03T05:04:09.071Z" }, + { url = "https://files.pythonhosted.org/packages/5a/0b/d5ea75cf46b52cdce85a85200c963cb498932953df443892238be49b1a01/pyzmq-27.0.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:f98f6b7787bd2beb1f0dde03f23a0621a0c978edf673b7d8f5e7bc039cbe1b60", size = 1340836, upload-time = "2025-08-03T05:04:10.774Z" }, + { url = "https://files.pythonhosted.org/packages/be/4c/0dbce882550e17db6846b29e9dc242aea7590e7594e1ca5043e8e58fff2d/pyzmq-27.0.1-cp314-cp314t-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:351bf5d8ca0788ca85327fda45843b6927593ff4c807faee368cc5aaf9f809c2", size = 897236, upload-time = "2025-08-03T05:04:13.221Z" }, + { url = "https://files.pythonhosted.org/packages/1b/22/461e131cf16b8814f3c356fa1ea0912697dbc4c64cddf01f7756ec704c1e/pyzmq-27.0.1-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5268a5a9177afff53dc6d70dffe63114ba2a6e7b20d9411cc3adeba09eeda403", size = 660374, upload-time = "2025-08-03T05:04:15.032Z" }, + { url = "https://files.pythonhosted.org/packages/3f/0c/bbd65a814395bf4fc3e57c6c13af27601c07e4009bdfb75ebcf500537bbd/pyzmq-27.0.1-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a4aca06ba295aa78bec9b33ec028d1ca08744c36294338c41432b7171060c808", size = 847497, upload-time = "2025-08-03T05:04:16.967Z" }, + { url = "https://files.pythonhosted.org/packages/1e/df/3d1f4a03b561d824cbd491394f67591957e2f1acf6dc85d96f970312a76a/pyzmq-27.0.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:1c363c6dc66352331d5ad64bb838765c6692766334a6a02fdb05e76bd408ae18", size = 1650028, upload-time = "2025-08-03T05:04:19.398Z" }, + { url = "https://files.pythonhosted.org/packages/41/c9/a3987540f59a412bdaae3f362f78e00e6769557a598c63b7e32956aade5a/pyzmq-27.0.1-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:87aebf4acd7249bdff8d3df03aed4f09e67078e6762cfe0aecf8d0748ff94cde", size = 2023808, upload-time = "2025-08-03T05:04:21.145Z" }, + { url = "https://files.pythonhosted.org/packages/b0/a5/c388f4cd80498a8eaef7535f2a8eaca0a35b82b87a0b47fa1856fc135004/pyzmq-27.0.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:e4f22d67756518d71901edf73b38dc0eb4765cce22c8fe122cc81748d425262b", size = 1884970, upload-time = "2025-08-03T05:04:22.908Z" }, + { url = "https://files.pythonhosted.org/packages/9a/ac/b2a89a1ed90526a1b9a260cdc5cd42f055fd44ee8d2a59902b5ac35ddeb1/pyzmq-27.0.1-cp314-cp314t-win32.whl", hash = "sha256:8c62297bc7aea2147b472ca5ca2b4389377ad82898c87cabab2a94aedd75e337", size = 586905, upload-time = "2025-08-03T05:04:24.492Z" }, + { url = "https://files.pythonhosted.org/packages/68/62/7aa5ea04e836f7a788b2a67405f83011cef59ca76d7bac91d1fc9a0476da/pyzmq-27.0.1-cp314-cp314t-win_amd64.whl", hash = "sha256:bee5248d5ec9223545f8cc4f368c2d571477ae828c99409125c3911511d98245", size = 660503, upload-time = "2025-08-03T05:04:26.382Z" }, + { url = "https://files.pythonhosted.org/packages/89/32/3836ed85947b06f1d67c07ce16c00b0cf8c053ab0b249d234f9f81ff95ff/pyzmq-27.0.1-cp314-cp314t-win_arm64.whl", hash = "sha256:0fc24bf45e4a454e55ef99d7f5c8b8712539200ce98533af25a5bfa954b6b390", size = 575098, upload-time = "2025-08-03T05:04:27.974Z" }, +] + +[[package]] +name = "referencing" +version = "0.36.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "attrs" }, + { name = "rpds-py" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/2f/db/98b5c277be99dd18bfd91dd04e1b759cad18d1a338188c936e92f921c7e2/referencing-0.36.2.tar.gz", hash = "sha256:df2e89862cd09deabbdba16944cc3f10feb6b3e6f18e902f7cc25609a34775aa", size = 74744, upload-time = "2025-01-25T08:48:16.138Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c1/b1/3baf80dc6d2b7bc27a95a67752d0208e410351e3feb4eb78de5f77454d8d/referencing-0.36.2-py3-none-any.whl", hash = "sha256:e8699adbbf8b5c7de96d8ffa0eb5c158b3beafce084968e2ea8bb08c6794dcd0", size = 26775, upload-time = "2025-01-25T08:48:14.241Z" }, +] + +[[package]] +name = "regex" +version = "2025.7.34" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0b/de/e13fa6dc61d78b30ba47481f99933a3b49a57779d625c392d8036770a60d/regex-2025.7.34.tar.gz", hash = "sha256:9ead9765217afd04a86822dfcd4ed2747dfe426e887da413b15ff0ac2457e21a", size = 400714, upload-time = "2025-07-31T00:21:16.262Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ff/f0/31d62596c75a33f979317658e8d261574785c6cd8672c06741ce2e2e2070/regex-2025.7.34-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:7f7211a746aced993bef487de69307a38c5ddd79257d7be83f7b202cb59ddb50", size = 485492, upload-time = "2025-07-31T00:19:35.57Z" }, + { url = "https://files.pythonhosted.org/packages/d8/16/b818d223f1c9758c3434be89aa1a01aae798e0e0df36c1f143d1963dd1ee/regex-2025.7.34-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:fb31080f2bd0681484b275461b202b5ad182f52c9ec606052020fe13eb13a72f", size = 290000, upload-time = "2025-07-31T00:19:37.175Z" }, + { url = "https://files.pythonhosted.org/packages/cd/70/69506d53397b4bd6954061bae75677ad34deb7f6ca3ba199660d6f728ff5/regex-2025.7.34-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0200a5150c4cf61e407038f4b4d5cdad13e86345dac29ff9dab3d75d905cf130", size = 286072, upload-time = "2025-07-31T00:19:38.612Z" }, + { url = "https://files.pythonhosted.org/packages/b0/73/536a216d5f66084fb577bb0543b5cb7de3272eb70a157f0c3a542f1c2551/regex-2025.7.34-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:739a74970e736df0773788377969c9fea3876c2fc13d0563f98e5503e5185f46", size = 797341, upload-time = "2025-07-31T00:19:40.119Z" }, + { url = "https://files.pythonhosted.org/packages/26/af/733f8168449e56e8f404bb807ea7189f59507cbea1b67a7bbcd92f8bf844/regex-2025.7.34-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4fef81b2f7ea6a2029161ed6dea9ae13834c28eb5a95b8771828194a026621e4", size = 862556, upload-time = "2025-07-31T00:19:41.556Z" }, + { url = "https://files.pythonhosted.org/packages/19/dd/59c464d58c06c4f7d87de4ab1f590e430821345a40c5d345d449a636d15f/regex-2025.7.34-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ea74cf81fe61a7e9d77989050d0089a927ab758c29dac4e8e1b6c06fccf3ebf0", size = 910762, upload-time = "2025-07-31T00:19:43Z" }, + { url = "https://files.pythonhosted.org/packages/37/a8/b05ccf33ceca0815a1e253693b2c86544932ebcc0049c16b0fbdf18b688b/regex-2025.7.34-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e4636a7f3b65a5f340ed9ddf53585c42e3ff37101d383ed321bfe5660481744b", size = 801892, upload-time = "2025-07-31T00:19:44.645Z" }, + { url = "https://files.pythonhosted.org/packages/5f/9a/b993cb2e634cc22810afd1652dba0cae156c40d4864285ff486c73cd1996/regex-2025.7.34-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6cef962d7834437fe8d3da6f9bfc6f93f20f218266dcefec0560ed7765f5fe01", size = 786551, upload-time = "2025-07-31T00:19:46.127Z" }, + { url = "https://files.pythonhosted.org/packages/2d/79/7849d67910a0de4e26834b5bb816e028e35473f3d7ae563552ea04f58ca2/regex-2025.7.34-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:cbe1698e5b80298dbce8df4d8d1182279fbdaf1044e864cbc9d53c20e4a2be77", size = 856457, upload-time = "2025-07-31T00:19:47.562Z" }, + { url = "https://files.pythonhosted.org/packages/91/c6/de516bc082524b27e45cb4f54e28bd800c01efb26d15646a65b87b13a91e/regex-2025.7.34-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:32b9f9bcf0f605eb094b08e8da72e44badabb63dde6b83bd530580b488d1c6da", size = 848902, upload-time = "2025-07-31T00:19:49.312Z" }, + { url = "https://files.pythonhosted.org/packages/7d/22/519ff8ba15f732db099b126f039586bd372da6cd4efb810d5d66a5daeda1/regex-2025.7.34-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:524c868ba527eab4e8744a9287809579f54ae8c62fbf07d62aacd89f6026b282", size = 788038, upload-time = "2025-07-31T00:19:50.794Z" }, + { url = "https://files.pythonhosted.org/packages/3f/7d/aabb467d8f57d8149895d133c88eb809a1a6a0fe262c1d508eb9dfabb6f9/regex-2025.7.34-cp312-cp312-win32.whl", hash = "sha256:d600e58ee6d036081c89696d2bdd55d507498a7180df2e19945c6642fac59588", size = 264417, upload-time = "2025-07-31T00:19:52.292Z" }, + { url = "https://files.pythonhosted.org/packages/3b/39/bd922b55a4fc5ad5c13753274e5b536f5b06ec8eb9747675668491c7ab7a/regex-2025.7.34-cp312-cp312-win_amd64.whl", hash = "sha256:9a9ab52a466a9b4b91564437b36417b76033e8778e5af8f36be835d8cb370d62", size = 275387, upload-time = "2025-07-31T00:19:53.593Z" }, + { url = "https://files.pythonhosted.org/packages/f7/3c/c61d2fdcecb754a40475a3d1ef9a000911d3e3fc75c096acf44b0dfb786a/regex-2025.7.34-cp312-cp312-win_arm64.whl", hash = "sha256:c83aec91af9c6fbf7c743274fd952272403ad9a9db05fe9bfc9df8d12b45f176", size = 268482, upload-time = "2025-07-31T00:19:55.183Z" }, + { url = "https://files.pythonhosted.org/packages/15/16/b709b2119975035169a25aa8e4940ca177b1a2e25e14f8d996d09130368e/regex-2025.7.34-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:c3c9740a77aeef3f5e3aaab92403946a8d34437db930a0280e7e81ddcada61f5", size = 485334, upload-time = "2025-07-31T00:19:56.58Z" }, + { url = "https://files.pythonhosted.org/packages/94/a6/c09136046be0595f0331bc58a0e5f89c2d324cf734e0b0ec53cf4b12a636/regex-2025.7.34-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:69ed3bc611540f2ea70a4080f853741ec698be556b1df404599f8724690edbcd", size = 289942, upload-time = "2025-07-31T00:19:57.943Z" }, + { url = "https://files.pythonhosted.org/packages/36/91/08fc0fd0f40bdfb0e0df4134ee37cfb16e66a1044ac56d36911fd01c69d2/regex-2025.7.34-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d03c6f9dcd562c56527c42b8530aad93193e0b3254a588be1f2ed378cdfdea1b", size = 285991, upload-time = "2025-07-31T00:19:59.837Z" }, + { url = "https://files.pythonhosted.org/packages/be/2f/99dc8f6f756606f0c214d14c7b6c17270b6bbe26d5c1f05cde9dbb1c551f/regex-2025.7.34-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6164b1d99dee1dfad33f301f174d8139d4368a9fb50bf0a3603b2eaf579963ad", size = 797415, upload-time = "2025-07-31T00:20:01.668Z" }, + { url = "https://files.pythonhosted.org/packages/62/cf/2fcdca1110495458ba4e95c52ce73b361cf1cafd8a53b5c31542cde9a15b/regex-2025.7.34-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:1e4f4f62599b8142362f164ce776f19d79bdd21273e86920a7b604a4275b4f59", size = 862487, upload-time = "2025-07-31T00:20:03.142Z" }, + { url = "https://files.pythonhosted.org/packages/90/38/899105dd27fed394e3fae45607c1983e138273ec167e47882fc401f112b9/regex-2025.7.34-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:72a26dcc6a59c057b292f39d41465d8233a10fd69121fa24f8f43ec6294e5415", size = 910717, upload-time = "2025-07-31T00:20:04.727Z" }, + { url = "https://files.pythonhosted.org/packages/ee/f6/4716198dbd0bcc9c45625ac4c81a435d1c4d8ad662e8576dac06bab35b17/regex-2025.7.34-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d5273fddf7a3e602695c92716c420c377599ed3c853ea669c1fe26218867002f", size = 801943, upload-time = "2025-07-31T00:20:07.1Z" }, + { url = "https://files.pythonhosted.org/packages/40/5d/cff8896d27e4e3dd11dd72ac78797c7987eb50fe4debc2c0f2f1682eb06d/regex-2025.7.34-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c1844be23cd40135b3a5a4dd298e1e0c0cb36757364dd6cdc6025770363e06c1", size = 786664, upload-time = "2025-07-31T00:20:08.818Z" }, + { url = "https://files.pythonhosted.org/packages/10/29/758bf83cf7b4c34f07ac3423ea03cee3eb3176941641e4ccc05620f6c0b8/regex-2025.7.34-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:dde35e2afbbe2272f8abee3b9fe6772d9b5a07d82607b5788e8508974059925c", size = 856457, upload-time = "2025-07-31T00:20:10.328Z" }, + { url = "https://files.pythonhosted.org/packages/d7/30/c19d212b619963c5b460bfed0ea69a092c6a43cba52a973d46c27b3e2975/regex-2025.7.34-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:f3f6e8e7af516a7549412ce57613e859c3be27d55341a894aacaa11703a4c31a", size = 849008, upload-time = "2025-07-31T00:20:11.823Z" }, + { url = "https://files.pythonhosted.org/packages/9e/b8/3c35da3b12c87e3cc00010ef6c3a4ae787cff0bc381aa3d251def219969a/regex-2025.7.34-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:469142fb94a869beb25b5f18ea87646d21def10fbacb0bcb749224f3509476f0", size = 788101, upload-time = "2025-07-31T00:20:13.729Z" }, + { url = "https://files.pythonhosted.org/packages/47/80/2f46677c0b3c2b723b2c358d19f9346e714113865da0f5f736ca1a883bde/regex-2025.7.34-cp313-cp313-win32.whl", hash = "sha256:da7507d083ee33ccea1310447410c27ca11fb9ef18c95899ca57ff60a7e4d8f1", size = 264401, upload-time = "2025-07-31T00:20:15.233Z" }, + { url = "https://files.pythonhosted.org/packages/be/fa/917d64dd074682606a003cba33585c28138c77d848ef72fc77cbb1183849/regex-2025.7.34-cp313-cp313-win_amd64.whl", hash = "sha256:9d644de5520441e5f7e2db63aec2748948cc39ed4d7a87fd5db578ea4043d997", size = 275368, upload-time = "2025-07-31T00:20:16.711Z" }, + { url = "https://files.pythonhosted.org/packages/65/cd/f94383666704170a2154a5df7b16be28f0c27a266bffcd843e58bc84120f/regex-2025.7.34-cp313-cp313-win_arm64.whl", hash = "sha256:7bf1c5503a9f2cbd2f52d7e260acb3131b07b6273c470abb78568174fe6bde3f", size = 268482, upload-time = "2025-07-31T00:20:18.189Z" }, + { url = "https://files.pythonhosted.org/packages/ac/23/6376f3a23cf2f3c00514b1cdd8c990afb4dfbac3cb4a68b633c6b7e2e307/regex-2025.7.34-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:8283afe7042d8270cecf27cca558873168e771183d4d593e3c5fe5f12402212a", size = 485385, upload-time = "2025-07-31T00:20:19.692Z" }, + { url = "https://files.pythonhosted.org/packages/73/5b/6d4d3a0b4d312adbfd6d5694c8dddcf1396708976dd87e4d00af439d962b/regex-2025.7.34-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:6c053f9647e3421dd2f5dff8172eb7b4eec129df9d1d2f7133a4386319b47435", size = 289788, upload-time = "2025-07-31T00:20:21.941Z" }, + { url = "https://files.pythonhosted.org/packages/92/71/5862ac9913746e5054d01cb9fb8125b3d0802c0706ef547cae1e7f4428fa/regex-2025.7.34-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:a16dd56bbcb7d10e62861c3cd000290ddff28ea142ffb5eb3470f183628011ac", size = 286136, upload-time = "2025-07-31T00:20:26.146Z" }, + { url = "https://files.pythonhosted.org/packages/27/df/5b505dc447eb71278eba10d5ec940769ca89c1af70f0468bfbcb98035dc2/regex-2025.7.34-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:69c593ff5a24c0d5c1112b0df9b09eae42b33c014bdca7022d6523b210b69f72", size = 797753, upload-time = "2025-07-31T00:20:27.919Z" }, + { url = "https://files.pythonhosted.org/packages/86/38/3e3dc953d13998fa047e9a2414b556201dbd7147034fbac129392363253b/regex-2025.7.34-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:98d0ce170fcde1a03b5df19c5650db22ab58af375aaa6ff07978a85c9f250f0e", size = 863263, upload-time = "2025-07-31T00:20:29.803Z" }, + { url = "https://files.pythonhosted.org/packages/68/e5/3ff66b29dde12f5b874dda2d9dec7245c2051f2528d8c2a797901497f140/regex-2025.7.34-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d72765a4bff8c43711d5b0f5b452991a9947853dfa471972169b3cc0ba1d0751", size = 910103, upload-time = "2025-07-31T00:20:31.313Z" }, + { url = "https://files.pythonhosted.org/packages/9e/fe/14176f2182125977fba3711adea73f472a11f3f9288c1317c59cd16ad5e6/regex-2025.7.34-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4494f8fd95a77eb434039ad8460e64d57baa0434f1395b7da44015bef650d0e4", size = 801709, upload-time = "2025-07-31T00:20:33.323Z" }, + { url = "https://files.pythonhosted.org/packages/5a/0d/80d4e66ed24f1ba876a9e8e31b709f9fd22d5c266bf5f3ab3c1afe683d7d/regex-2025.7.34-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:4f42b522259c66e918a0121a12429b2abcf696c6f967fa37bdc7b72e61469f98", size = 786726, upload-time = "2025-07-31T00:20:35.252Z" }, + { url = "https://files.pythonhosted.org/packages/12/75/c3ebb30e04a56c046f5c85179dc173818551037daae2c0c940c7b19152cb/regex-2025.7.34-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:aaef1f056d96a0a5d53ad47d019d5b4c66fe4be2da87016e0d43b7242599ffc7", size = 857306, upload-time = "2025-07-31T00:20:37.12Z" }, + { url = "https://files.pythonhosted.org/packages/b1/b2/a4dc5d8b14f90924f27f0ac4c4c4f5e195b723be98adecc884f6716614b6/regex-2025.7.34-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:656433e5b7dccc9bc0da6312da8eb897b81f5e560321ec413500e5367fcd5d47", size = 848494, upload-time = "2025-07-31T00:20:38.818Z" }, + { url = "https://files.pythonhosted.org/packages/0d/21/9ac6e07a4c5e8646a90b56b61f7e9dac11ae0747c857f91d3d2bc7c241d9/regex-2025.7.34-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:e91eb2c62c39705e17b4d42d4b86c4e86c884c0d15d9c5a47d0835f8387add8e", size = 787850, upload-time = "2025-07-31T00:20:40.478Z" }, + { url = "https://files.pythonhosted.org/packages/be/6c/d51204e28e7bc54f9a03bb799b04730d7e54ff2718862b8d4e09e7110a6a/regex-2025.7.34-cp314-cp314-win32.whl", hash = "sha256:f978ddfb6216028c8f1d6b0f7ef779949498b64117fc35a939022f67f810bdcb", size = 269730, upload-time = "2025-07-31T00:20:42.253Z" }, + { url = "https://files.pythonhosted.org/packages/74/52/a7e92d02fa1fdef59d113098cb9f02c5d03289a0e9f9e5d4d6acccd10677/regex-2025.7.34-cp314-cp314-win_amd64.whl", hash = "sha256:4b7dc33b9b48fb37ead12ffc7bdb846ac72f99a80373c4da48f64b373a7abeae", size = 278640, upload-time = "2025-07-31T00:20:44.42Z" }, + { url = "https://files.pythonhosted.org/packages/d1/78/a815529b559b1771080faa90c3ab401730661f99d495ab0071649f139ebd/regex-2025.7.34-cp314-cp314-win_arm64.whl", hash = "sha256:4b8c4d39f451e64809912c82392933d80fe2e4a87eeef8859fcc5380d0173c64", size = 271757, upload-time = "2025-07-31T00:20:46.355Z" }, +] + +[[package]] +name = "requests" +version = "2.32.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "charset-normalizer" }, + { name = "idna" }, + { name = "urllib3" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e1/0a/929373653770d8a0d7ea76c37de6e41f11eb07559b103b1c02cafb3f7cf8/requests-2.32.4.tar.gz", hash = "sha256:27d0316682c8a29834d3264820024b62a36942083d52caf2f14c0591336d3422", size = 135258, upload-time = "2025-06-09T16:43:07.34Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7c/e4/56027c4a6b4ae70ca9de302488c5ca95ad4a39e190093d6c1a8ace08341b/requests-2.32.4-py3-none-any.whl", hash = "sha256:27babd3cda2a6d50b30443204ee89830707d396671944c998b5975b031ac2b2c", size = 64847, upload-time = "2025-06-09T16:43:05.728Z" }, +] + +[[package]] +name = "rfc3339-validator" +version = "0.1.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "six" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/28/ea/a9387748e2d111c3c2b275ba970b735e04e15cdb1eb30693b6b5708c4dbd/rfc3339_validator-0.1.4.tar.gz", hash = "sha256:138a2abdf93304ad60530167e51d2dfb9549521a836871b88d7f4695d0022f6b", size = 5513, upload-time = "2021-05-12T16:37:54.178Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7b/44/4e421b96b67b2daff264473f7465db72fbdf36a07e05494f50300cc7b0c6/rfc3339_validator-0.1.4-py2.py3-none-any.whl", hash = "sha256:24f6ec1eda14ef823da9e36ec7113124b39c04d50a4d3d3a3c2859577e7791fa", size = 3490, upload-time = "2021-05-12T16:37:52.536Z" }, +] + +[[package]] +name = "rfc3986-validator" +version = "0.1.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/da/88/f270de456dd7d11dcc808abfa291ecdd3f45ff44e3b549ffa01b126464d0/rfc3986_validator-0.1.1.tar.gz", hash = "sha256:3d44bde7921b3b9ec3ae4e3adca370438eccebc676456449b145d533b240d055", size = 6760, upload-time = "2019-10-28T16:00:19.144Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/51/17023c0f8f1869d8806b979a2bffa3f861f26a3f1a66b094288323fba52f/rfc3986_validator-0.1.1-py2.py3-none-any.whl", hash = "sha256:2f235c432ef459970b4306369336b9d5dbdda31b510ca1e327636e01f528bfa9", size = 4242, upload-time = "2019-10-28T16:00:13.976Z" }, +] + +[[package]] +name = "rfc3987-syntax" +version = "1.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "lark" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/2c/06/37c1a5557acf449e8e406a830a05bf885ac47d33270aec454ef78675008d/rfc3987_syntax-1.1.0.tar.gz", hash = "sha256:717a62cbf33cffdd16dfa3a497d81ce48a660ea691b1ddd7be710c22f00b4a0d", size = 14239, upload-time = "2025-07-18T01:05:05.015Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/71/44ce230e1b7fadd372515a97e32a83011f906ddded8d03e3c6aafbdedbb7/rfc3987_syntax-1.1.0-py3-none-any.whl", hash = "sha256:6c3d97604e4c5ce9f714898e05401a0445a641cfa276432b0a648c80856f6a3f", size = 8046, upload-time = "2025-07-18T01:05:03.843Z" }, +] + +[[package]] +name = "rpds-py" +version = "0.27.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1e/d9/991a0dee12d9fc53ed027e26a26a64b151d77252ac477e22666b9688bc16/rpds_py-0.27.0.tar.gz", hash = "sha256:8b23cf252f180cda89220b378d917180f29d313cd6a07b2431c0d3b776aae86f", size = 27420, upload-time = "2025-08-07T08:26:39.624Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cd/17/e67309ca1ac993fa1888a0d9b2f5ccc1f67196ace32e76c9f8e1dbbbd50c/rpds_py-0.27.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:19c990fdf5acecbf0623e906ae2e09ce1c58947197f9bced6bbd7482662231c4", size = 362611, upload-time = "2025-08-07T08:23:44.773Z" }, + { url = "https://files.pythonhosted.org/packages/93/2e/28c2fb84aa7aa5d75933d1862d0f7de6198ea22dfd9a0cca06e8a4e7509e/rpds_py-0.27.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6c27a7054b5224710fcfb1a626ec3ff4f28bcb89b899148c72873b18210e446b", size = 347680, upload-time = "2025-08-07T08:23:46.014Z" }, + { url = "https://files.pythonhosted.org/packages/44/3e/9834b4c8f4f5fe936b479e623832468aa4bd6beb8d014fecaee9eac6cdb1/rpds_py-0.27.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:09965b314091829b378b60607022048953e25f0b396c2b70e7c4c81bcecf932e", size = 384600, upload-time = "2025-08-07T08:23:48Z" }, + { url = "https://files.pythonhosted.org/packages/19/78/744123c7b38865a965cd9e6f691fde7ef989a00a256fa8bf15b75240d12f/rpds_py-0.27.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:14f028eb47f59e9169bfdf9f7ceafd29dd64902141840633683d0bad5b04ff34", size = 400697, upload-time = "2025-08-07T08:23:49.407Z" }, + { url = "https://files.pythonhosted.org/packages/32/97/3c3d32fe7daee0a1f1a678b6d4dfb8c4dcf88197fa2441f9da7cb54a8466/rpds_py-0.27.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6168af0be75bba990a39f9431cdfae5f0ad501f4af32ae62e8856307200517b8", size = 517781, upload-time = "2025-08-07T08:23:50.557Z" }, + { url = "https://files.pythonhosted.org/packages/b2/be/28f0e3e733680aa13ecec1212fc0f585928a206292f14f89c0b8a684cad1/rpds_py-0.27.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ab47fe727c13c09d0e6f508e3a49e545008e23bf762a245b020391b621f5b726", size = 406449, upload-time = "2025-08-07T08:23:51.732Z" }, + { url = "https://files.pythonhosted.org/packages/95/ae/5d15c83e337c082d0367053baeb40bfba683f42459f6ebff63a2fd7e5518/rpds_py-0.27.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5fa01b3d5e3b7d97efab65bd3d88f164e289ec323a8c033c5c38e53ee25c007e", size = 386150, upload-time = "2025-08-07T08:23:52.822Z" }, + { url = "https://files.pythonhosted.org/packages/bf/65/944e95f95d5931112829e040912b25a77b2e7ed913ea5fe5746aa5c1ce75/rpds_py-0.27.0-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:6c135708e987f46053e0a1246a206f53717f9fadfba27174a9769ad4befba5c3", size = 406100, upload-time = "2025-08-07T08:23:54.339Z" }, + { url = "https://files.pythonhosted.org/packages/21/a4/1664b83fae02894533cd11dc0b9f91d673797c2185b7be0f7496107ed6c5/rpds_py-0.27.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:fc327f4497b7087d06204235199daf208fd01c82d80465dc5efa4ec9df1c5b4e", size = 421345, upload-time = "2025-08-07T08:23:55.832Z" }, + { url = "https://files.pythonhosted.org/packages/7c/26/b7303941c2b0823bfb34c71378249f8beedce57301f400acb04bb345d025/rpds_py-0.27.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:7e57906e38583a2cba67046a09c2637e23297618dc1f3caddbc493f2be97c93f", size = 561891, upload-time = "2025-08-07T08:23:56.951Z" }, + { url = "https://files.pythonhosted.org/packages/9b/c8/48623d64d4a5a028fa99576c768a6159db49ab907230edddc0b8468b998b/rpds_py-0.27.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:0f4f69d7a4300fbf91efb1fb4916421bd57804c01ab938ab50ac9c4aa2212f03", size = 591756, upload-time = "2025-08-07T08:23:58.146Z" }, + { url = "https://files.pythonhosted.org/packages/b3/51/18f62617e8e61cc66334c9fb44b1ad7baae3438662098efbc55fb3fda453/rpds_py-0.27.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b4c4fbbcff474e1e5f38be1bf04511c03d492d42eec0babda5d03af3b5589374", size = 557088, upload-time = "2025-08-07T08:23:59.6Z" }, + { url = "https://files.pythonhosted.org/packages/bd/4c/e84c3a276e2496a93d245516be6b49e20499aa8ca1c94d59fada0d79addc/rpds_py-0.27.0-cp312-cp312-win32.whl", hash = "sha256:27bac29bbbf39601b2aab474daf99dbc8e7176ca3389237a23944b17f8913d97", size = 221926, upload-time = "2025-08-07T08:24:00.695Z" }, + { url = "https://files.pythonhosted.org/packages/83/89/9d0fbcef64340db0605eb0a0044f258076f3ae0a3b108983b2c614d96212/rpds_py-0.27.0-cp312-cp312-win_amd64.whl", hash = "sha256:8a06aa1197ec0281eb1d7daf6073e199eb832fe591ffa329b88bae28f25f5fe5", size = 233235, upload-time = "2025-08-07T08:24:01.846Z" }, + { url = "https://files.pythonhosted.org/packages/c9/b0/e177aa9f39cbab060f96de4a09df77d494f0279604dc2f509263e21b05f9/rpds_py-0.27.0-cp312-cp312-win_arm64.whl", hash = "sha256:e14aab02258cb776a108107bd15f5b5e4a1bbaa61ef33b36693dfab6f89d54f9", size = 223315, upload-time = "2025-08-07T08:24:03.337Z" }, + { url = "https://files.pythonhosted.org/packages/81/d2/dfdfd42565a923b9e5a29f93501664f5b984a802967d48d49200ad71be36/rpds_py-0.27.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:443d239d02d9ae55b74015234f2cd8eb09e59fbba30bf60baeb3123ad4c6d5ff", size = 362133, upload-time = "2025-08-07T08:24:04.508Z" }, + { url = "https://files.pythonhosted.org/packages/ac/4a/0a2e2460c4b66021d349ce9f6331df1d6c75d7eea90df9785d333a49df04/rpds_py-0.27.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:b8a7acf04fda1f30f1007f3cc96d29d8cf0a53e626e4e1655fdf4eabc082d367", size = 347128, upload-time = "2025-08-07T08:24:05.695Z" }, + { url = "https://files.pythonhosted.org/packages/35/8d/7d1e4390dfe09d4213b3175a3f5a817514355cb3524593380733204f20b9/rpds_py-0.27.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9d0f92b78cfc3b74a42239fdd8c1266f4715b573204c234d2f9fc3fc7a24f185", size = 384027, upload-time = "2025-08-07T08:24:06.841Z" }, + { url = "https://files.pythonhosted.org/packages/c1/65/78499d1a62172891c8cd45de737b2a4b84a414b6ad8315ab3ac4945a5b61/rpds_py-0.27.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ce4ed8e0c7dbc5b19352b9c2c6131dd23b95fa8698b5cdd076307a33626b72dc", size = 399973, upload-time = "2025-08-07T08:24:08.143Z" }, + { url = "https://files.pythonhosted.org/packages/10/a1/1c67c1d8cc889107b19570bb01f75cf49852068e95e6aee80d22915406fc/rpds_py-0.27.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fde355b02934cc6b07200cc3b27ab0c15870a757d1a72fd401aa92e2ea3c6bfe", size = 515295, upload-time = "2025-08-07T08:24:09.711Z" }, + { url = "https://files.pythonhosted.org/packages/df/27/700ec88e748436b6c7c4a2262d66e80f8c21ab585d5e98c45e02f13f21c0/rpds_py-0.27.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:13bbc4846ae4c993f07c93feb21a24d8ec637573d567a924b1001e81c8ae80f9", size = 406737, upload-time = "2025-08-07T08:24:11.182Z" }, + { url = "https://files.pythonhosted.org/packages/33/cc/6b0ee8f0ba3f2df2daac1beda17fde5cf10897a7d466f252bd184ef20162/rpds_py-0.27.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:be0744661afbc4099fef7f4e604e7f1ea1be1dd7284f357924af12a705cc7d5c", size = 385898, upload-time = "2025-08-07T08:24:12.798Z" }, + { url = "https://files.pythonhosted.org/packages/e8/7e/c927b37d7d33c0a0ebf249cc268dc2fcec52864c1b6309ecb960497f2285/rpds_py-0.27.0-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:069e0384a54f427bd65d7fda83b68a90606a3835901aaff42185fcd94f5a9295", size = 405785, upload-time = "2025-08-07T08:24:14.906Z" }, + { url = "https://files.pythonhosted.org/packages/5b/d2/8ed50746d909dcf402af3fa58b83d5a590ed43e07251d6b08fad1a535ba6/rpds_py-0.27.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:4bc262ace5a1a7dc3e2eac2fa97b8257ae795389f688b5adf22c5db1e2431c43", size = 419760, upload-time = "2025-08-07T08:24:16.129Z" }, + { url = "https://files.pythonhosted.org/packages/d3/60/2b2071aee781cb3bd49f94d5d35686990b925e9b9f3e3d149235a6f5d5c1/rpds_py-0.27.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:2fe6e18e5c8581f0361b35ae575043c7029d0a92cb3429e6e596c2cdde251432", size = 561201, upload-time = "2025-08-07T08:24:17.645Z" }, + { url = "https://files.pythonhosted.org/packages/98/1f/27b67304272521aaea02be293fecedce13fa351a4e41cdb9290576fc6d81/rpds_py-0.27.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:d93ebdb82363d2e7bec64eecdc3632b59e84bd270d74fe5be1659f7787052f9b", size = 591021, upload-time = "2025-08-07T08:24:18.999Z" }, + { url = "https://files.pythonhosted.org/packages/db/9b/a2fadf823164dd085b1f894be6443b0762a54a7af6f36e98e8fcda69ee50/rpds_py-0.27.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:0954e3a92e1d62e83a54ea7b3fdc9efa5d61acef8488a8a3d31fdafbfb00460d", size = 556368, upload-time = "2025-08-07T08:24:20.54Z" }, + { url = "https://files.pythonhosted.org/packages/24/f3/6d135d46a129cda2e3e6d4c5e91e2cc26ea0428c6cf152763f3f10b6dd05/rpds_py-0.27.0-cp313-cp313-win32.whl", hash = "sha256:2cff9bdd6c7b906cc562a505c04a57d92e82d37200027e8d362518df427f96cd", size = 221236, upload-time = "2025-08-07T08:24:22.144Z" }, + { url = "https://files.pythonhosted.org/packages/c5/44/65d7494f5448ecc755b545d78b188440f81da98b50ea0447ab5ebfdf9bd6/rpds_py-0.27.0-cp313-cp313-win_amd64.whl", hash = "sha256:dc79d192fb76fc0c84f2c58672c17bbbc383fd26c3cdc29daae16ce3d927e8b2", size = 232634, upload-time = "2025-08-07T08:24:23.642Z" }, + { url = "https://files.pythonhosted.org/packages/70/d9/23852410fadab2abb611733933401de42a1964ce6600a3badae35fbd573e/rpds_py-0.27.0-cp313-cp313-win_arm64.whl", hash = "sha256:5b3a5c8089eed498a3af23ce87a80805ff98f6ef8f7bdb70bd1b7dae5105f6ac", size = 222783, upload-time = "2025-08-07T08:24:25.098Z" }, + { url = "https://files.pythonhosted.org/packages/15/75/03447917f78512b34463f4ef11066516067099a0c466545655503bed0c77/rpds_py-0.27.0-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:90fb790138c1a89a2e58c9282fe1089638401f2f3b8dddd758499041bc6e0774", size = 359154, upload-time = "2025-08-07T08:24:26.249Z" }, + { url = "https://files.pythonhosted.org/packages/6b/fc/4dac4fa756451f2122ddaf136e2c6aeb758dc6fdbe9ccc4bc95c98451d50/rpds_py-0.27.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:010c4843a3b92b54373e3d2291a7447d6c3fc29f591772cc2ea0e9f5c1da434b", size = 343909, upload-time = "2025-08-07T08:24:27.405Z" }, + { url = "https://files.pythonhosted.org/packages/7b/81/723c1ed8e6f57ed9d8c0c07578747a2d3d554aaefc1ab89f4e42cfeefa07/rpds_py-0.27.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c9ce7a9e967afc0a2af7caa0d15a3e9c1054815f73d6a8cb9225b61921b419bd", size = 379340, upload-time = "2025-08-07T08:24:28.714Z" }, + { url = "https://files.pythonhosted.org/packages/98/16/7e3740413de71818ce1997df82ba5f94bae9fff90c0a578c0e24658e6201/rpds_py-0.27.0-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:aa0bf113d15e8abdfee92aa4db86761b709a09954083afcb5bf0f952d6065fdb", size = 391655, upload-time = "2025-08-07T08:24:30.223Z" }, + { url = "https://files.pythonhosted.org/packages/e0/63/2a9f510e124d80660f60ecce07953f3f2d5f0b96192c1365443859b9c87f/rpds_py-0.27.0-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:eb91d252b35004a84670dfeafadb042528b19842a0080d8b53e5ec1128e8f433", size = 513017, upload-time = "2025-08-07T08:24:31.446Z" }, + { url = "https://files.pythonhosted.org/packages/2c/4e/cf6ff311d09776c53ea1b4f2e6700b9d43bb4e99551006817ade4bbd6f78/rpds_py-0.27.0-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:db8a6313dbac934193fc17fe7610f70cd8181c542a91382531bef5ed785e5615", size = 402058, upload-time = "2025-08-07T08:24:32.613Z" }, + { url = "https://files.pythonhosted.org/packages/88/11/5e36096d474cb10f2a2d68b22af60a3bc4164fd8db15078769a568d9d3ac/rpds_py-0.27.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ce96ab0bdfcef1b8c371ada2100767ace6804ea35aacce0aef3aeb4f3f499ca8", size = 383474, upload-time = "2025-08-07T08:24:33.767Z" }, + { url = "https://files.pythonhosted.org/packages/db/a2/3dff02805b06058760b5eaa6d8cb8db3eb3e46c9e452453ad5fc5b5ad9fe/rpds_py-0.27.0-cp313-cp313t-manylinux_2_31_riscv64.whl", hash = "sha256:7451ede3560086abe1aa27dcdcf55cd15c96b56f543fb12e5826eee6f721f858", size = 400067, upload-time = "2025-08-07T08:24:35.021Z" }, + { url = "https://files.pythonhosted.org/packages/67/87/eed7369b0b265518e21ea836456a4ed4a6744c8c12422ce05bce760bb3cf/rpds_py-0.27.0-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:32196b5a99821476537b3f7732432d64d93a58d680a52c5e12a190ee0135d8b5", size = 412085, upload-time = "2025-08-07T08:24:36.267Z" }, + { url = "https://files.pythonhosted.org/packages/8b/48/f50b2ab2fbb422fbb389fe296e70b7a6b5ea31b263ada5c61377e710a924/rpds_py-0.27.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:a029be818059870664157194e46ce0e995082ac49926f1423c1f058534d2aaa9", size = 555928, upload-time = "2025-08-07T08:24:37.573Z" }, + { url = "https://files.pythonhosted.org/packages/98/41/b18eb51045d06887666c3560cd4bbb6819127b43d758f5adb82b5f56f7d1/rpds_py-0.27.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:3841f66c1ffdc6cebce8aed64e36db71466f1dc23c0d9a5592e2a782a3042c79", size = 585527, upload-time = "2025-08-07T08:24:39.391Z" }, + { url = "https://files.pythonhosted.org/packages/be/03/a3dd6470fc76499959b00ae56295b76b4bdf7c6ffc60d62006b1217567e1/rpds_py-0.27.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:42894616da0fc0dcb2ec08a77896c3f56e9cb2f4b66acd76fc8992c3557ceb1c", size = 554211, upload-time = "2025-08-07T08:24:40.6Z" }, + { url = "https://files.pythonhosted.org/packages/bf/d1/ee5fd1be395a07423ac4ca0bcc05280bf95db2b155d03adefeb47d5ebf7e/rpds_py-0.27.0-cp313-cp313t-win32.whl", hash = "sha256:b1fef1f13c842a39a03409e30ca0bf87b39a1e2a305a9924deadb75a43105d23", size = 216624, upload-time = "2025-08-07T08:24:42.204Z" }, + { url = "https://files.pythonhosted.org/packages/1c/94/4814c4c858833bf46706f87349c37ca45e154da7dbbec9ff09f1abeb08cc/rpds_py-0.27.0-cp313-cp313t-win_amd64.whl", hash = "sha256:183f5e221ba3e283cd36fdfbe311d95cd87699a083330b4f792543987167eff1", size = 230007, upload-time = "2025-08-07T08:24:43.329Z" }, + { url = "https://files.pythonhosted.org/packages/0e/a5/8fffe1c7dc7c055aa02df310f9fb71cfc693a4d5ccc5de2d3456ea5fb022/rpds_py-0.27.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:f3cd110e02c5bf17d8fb562f6c9df5c20e73029d587cf8602a2da6c5ef1e32cb", size = 362595, upload-time = "2025-08-07T08:24:44.478Z" }, + { url = "https://files.pythonhosted.org/packages/bc/c7/4e4253fd2d4bb0edbc0b0b10d9f280612ca4f0f990e3c04c599000fe7d71/rpds_py-0.27.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:8d0e09cf4863c74106b5265c2c310f36146e2b445ff7b3018a56799f28f39f6f", size = 347252, upload-time = "2025-08-07T08:24:45.678Z" }, + { url = "https://files.pythonhosted.org/packages/f3/c8/3d1a954d30f0174dd6baf18b57c215da03cf7846a9d6e0143304e784cddc/rpds_py-0.27.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:64f689ab822f9b5eb6dfc69893b4b9366db1d2420f7db1f6a2adf2a9ca15ad64", size = 384886, upload-time = "2025-08-07T08:24:46.86Z" }, + { url = "https://files.pythonhosted.org/packages/e0/52/3c5835f2df389832b28f9276dd5395b5a965cea34226e7c88c8fbec2093c/rpds_py-0.27.0-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e36c80c49853b3ffda7aa1831bf175c13356b210c73128c861f3aa93c3cc4015", size = 399716, upload-time = "2025-08-07T08:24:48.174Z" }, + { url = "https://files.pythonhosted.org/packages/40/73/176e46992461a1749686a2a441e24df51ff86b99c2d34bf39f2a5273b987/rpds_py-0.27.0-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6de6a7f622860af0146cb9ee148682ff4d0cea0b8fd3ad51ce4d40efb2f061d0", size = 517030, upload-time = "2025-08-07T08:24:49.52Z" }, + { url = "https://files.pythonhosted.org/packages/79/2a/7266c75840e8c6e70effeb0d38922a45720904f2cd695e68a0150e5407e2/rpds_py-0.27.0-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4045e2fc4b37ec4b48e8907a5819bdd3380708c139d7cc358f03a3653abedb89", size = 408448, upload-time = "2025-08-07T08:24:50.727Z" }, + { url = "https://files.pythonhosted.org/packages/e6/5f/a7efc572b8e235093dc6cf39f4dbc8a7f08e65fdbcec7ff4daeb3585eef1/rpds_py-0.27.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9da162b718b12c4219eeeeb68a5b7552fbc7aadedf2efee440f88b9c0e54b45d", size = 387320, upload-time = "2025-08-07T08:24:52.004Z" }, + { url = "https://files.pythonhosted.org/packages/a2/eb/9ff6bc92efe57cf5a2cb74dee20453ba444b6fdc85275d8c99e0d27239d1/rpds_py-0.27.0-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:0665be515767dc727ffa5f74bd2ef60b0ff85dad6bb8f50d91eaa6b5fb226f51", size = 407414, upload-time = "2025-08-07T08:24:53.664Z" }, + { url = "https://files.pythonhosted.org/packages/fb/bd/3b9b19b00d5c6e1bd0f418c229ab0f8d3b110ddf7ec5d9d689ef783d0268/rpds_py-0.27.0-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:203f581accef67300a942e49a37d74c12ceeef4514874c7cede21b012613ca2c", size = 420766, upload-time = "2025-08-07T08:24:55.917Z" }, + { url = "https://files.pythonhosted.org/packages/17/6b/521a7b1079ce16258c70805166e3ac6ec4ee2139d023fe07954dc9b2d568/rpds_py-0.27.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7873b65686a6471c0037139aa000d23fe94628e0daaa27b6e40607c90e3f5ec4", size = 562409, upload-time = "2025-08-07T08:24:57.17Z" }, + { url = "https://files.pythonhosted.org/packages/8b/bf/65db5bfb14ccc55e39de8419a659d05a2a9cd232f0a699a516bb0991da7b/rpds_py-0.27.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:249ab91ceaa6b41abc5f19513cb95b45c6f956f6b89f1fe3d99c81255a849f9e", size = 590793, upload-time = "2025-08-07T08:24:58.388Z" }, + { url = "https://files.pythonhosted.org/packages/db/b8/82d368b378325191ba7aae8f40f009b78057b598d4394d1f2cdabaf67b3f/rpds_py-0.27.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:d2f184336bc1d6abfaaa1262ed42739c3789b1e3a65a29916a615307d22ffd2e", size = 558178, upload-time = "2025-08-07T08:24:59.756Z" }, + { url = "https://files.pythonhosted.org/packages/f6/ff/f270bddbfbc3812500f8131b1ebbd97afd014cd554b604a3f73f03133a36/rpds_py-0.27.0-cp314-cp314-win32.whl", hash = "sha256:d3c622c39f04d5751408f5b801ecb527e6e0a471b367f420a877f7a660d583f6", size = 222355, upload-time = "2025-08-07T08:25:01.027Z" }, + { url = "https://files.pythonhosted.org/packages/bf/20/fdab055b1460c02ed356a0e0b0a78c1dd32dc64e82a544f7b31c9ac643dc/rpds_py-0.27.0-cp314-cp314-win_amd64.whl", hash = "sha256:cf824aceaeffff029ccfba0da637d432ca71ab21f13e7f6f5179cd88ebc77a8a", size = 234007, upload-time = "2025-08-07T08:25:02.268Z" }, + { url = "https://files.pythonhosted.org/packages/4d/a8/694c060005421797a3be4943dab8347c76c2b429a9bef68fb2c87c9e70c7/rpds_py-0.27.0-cp314-cp314-win_arm64.whl", hash = "sha256:86aca1616922b40d8ac1b3073a1ead4255a2f13405e5700c01f7c8d29a03972d", size = 223527, upload-time = "2025-08-07T08:25:03.45Z" }, + { url = "https://files.pythonhosted.org/packages/1e/f9/77f4c90f79d2c5ca8ce6ec6a76cb4734ee247de6b3a4f337e289e1f00372/rpds_py-0.27.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:341d8acb6724c0c17bdf714319c393bb27f6d23d39bc74f94221b3e59fc31828", size = 359469, upload-time = "2025-08-07T08:25:04.648Z" }, + { url = "https://files.pythonhosted.org/packages/c0/22/b97878d2f1284286fef4172069e84b0b42b546ea7d053e5fb7adb9ac6494/rpds_py-0.27.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:6b96b0b784fe5fd03beffff2b1533dc0d85e92bab8d1b2c24ef3a5dc8fac5669", size = 343960, upload-time = "2025-08-07T08:25:05.863Z" }, + { url = "https://files.pythonhosted.org/packages/b1/b0/dfd55b5bb480eda0578ae94ef256d3061d20b19a0f5e18c482f03e65464f/rpds_py-0.27.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0c431bfb91478d7cbe368d0a699978050d3b112d7f1d440a41e90faa325557fd", size = 380201, upload-time = "2025-08-07T08:25:07.513Z" }, + { url = "https://files.pythonhosted.org/packages/28/22/e1fa64e50d58ad2b2053077e3ec81a979147c43428de9e6de68ddf6aff4e/rpds_py-0.27.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:20e222a44ae9f507d0f2678ee3dd0c45ec1e930f6875d99b8459631c24058aec", size = 392111, upload-time = "2025-08-07T08:25:09.149Z" }, + { url = "https://files.pythonhosted.org/packages/49/f9/43ab7a43e97aedf6cea6af70fdcbe18abbbc41d4ae6cdec1bfc23bbad403/rpds_py-0.27.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:184f0d7b342967f6cda94a07d0e1fae177d11d0b8f17d73e06e36ac02889f303", size = 515863, upload-time = "2025-08-07T08:25:10.431Z" }, + { url = "https://files.pythonhosted.org/packages/38/9b/9bd59dcc636cd04d86a2d20ad967770bf348f5eb5922a8f29b547c074243/rpds_py-0.27.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a00c91104c173c9043bc46f7b30ee5e6d2f6b1149f11f545580f5d6fdff42c0b", size = 402398, upload-time = "2025-08-07T08:25:11.819Z" }, + { url = "https://files.pythonhosted.org/packages/71/bf/f099328c6c85667aba6b66fa5c35a8882db06dcd462ea214be72813a0dd2/rpds_py-0.27.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f7a37dd208f0d658e0487522078b1ed68cd6bce20ef4b5a915d2809b9094b410", size = 384665, upload-time = "2025-08-07T08:25:13.194Z" }, + { url = "https://files.pythonhosted.org/packages/a9/c5/9c1f03121ece6634818490bd3c8be2c82a70928a19de03467fb25a3ae2a8/rpds_py-0.27.0-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:92f3b3ec3e6008a1fe00b7c0946a170f161ac00645cde35e3c9a68c2475e8156", size = 400405, upload-time = "2025-08-07T08:25:14.417Z" }, + { url = "https://files.pythonhosted.org/packages/b5/b8/e25d54af3e63ac94f0c16d8fe143779fe71ff209445a0c00d0f6984b6b2c/rpds_py-0.27.0-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a1b3db5fae5cbce2131b7420a3f83553d4d89514c03d67804ced36161fe8b6b2", size = 413179, upload-time = "2025-08-07T08:25:15.664Z" }, + { url = "https://files.pythonhosted.org/packages/f9/d1/406b3316433fe49c3021546293a04bc33f1478e3ec7950215a7fce1a1208/rpds_py-0.27.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5355527adaa713ab693cbce7c1e0ec71682f599f61b128cf19d07e5c13c9b1f1", size = 556895, upload-time = "2025-08-07T08:25:17.061Z" }, + { url = "https://files.pythonhosted.org/packages/5f/bc/3697c0c21fcb9a54d46ae3b735eb2365eea0c2be076b8f770f98e07998de/rpds_py-0.27.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:fcc01c57ce6e70b728af02b2401c5bc853a9e14eb07deda30624374f0aebfe42", size = 585464, upload-time = "2025-08-07T08:25:18.406Z" }, + { url = "https://files.pythonhosted.org/packages/63/09/ee1bb5536f99f42c839b177d552f6114aa3142d82f49cef49261ed28dbe0/rpds_py-0.27.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:3001013dae10f806380ba739d40dee11db1ecb91684febb8406a87c2ded23dae", size = 555090, upload-time = "2025-08-07T08:25:20.461Z" }, + { url = "https://files.pythonhosted.org/packages/7d/2c/363eada9e89f7059199d3724135a86c47082cbf72790d6ba2f336d146ddb/rpds_py-0.27.0-cp314-cp314t-win32.whl", hash = "sha256:0f401c369186a5743694dd9fc08cba66cf70908757552e1f714bfc5219c655b5", size = 218001, upload-time = "2025-08-07T08:25:21.761Z" }, + { url = "https://files.pythonhosted.org/packages/e2/3f/d6c216ed5199c9ef79e2a33955601f454ed1e7420a93b89670133bca5ace/rpds_py-0.27.0-cp314-cp314t-win_amd64.whl", hash = "sha256:8a1dca5507fa1337f75dcd5070218b20bc68cf8844271c923c1b79dfcbc20391", size = 230993, upload-time = "2025-08-07T08:25:23.34Z" }, +] + +[[package]] +name = "safetensors" +version = "0.6.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6c/d2/94fe37355a1d4ff86b0f43b9a018515d5d29bf7ad6d01318a80f5db2fd6a/safetensors-0.6.1.tar.gz", hash = "sha256:a766ba6e19b198eff09be05f24cd89eda1670ed404ae828e2aa3fc09816ba8d8", size = 197968, upload-time = "2025-08-06T09:39:38.376Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6b/c0/40263a2103511917f9a92b4e114ecaff68586df07f12d1d877312f1261f3/safetensors-0.6.1-cp38-abi3-macosx_10_12_x86_64.whl", hash = "sha256:81ed1b69d6f8acd7e759a71197ce3a69da4b7e9faa9dbb005eb06a83b1a4e52d", size = 455232, upload-time = "2025-08-06T09:39:32.037Z" }, + { url = "https://files.pythonhosted.org/packages/86/bf/432cb4bb1c336d338dd9b29f78622b1441ee06e5868bf1de2ca2bec74c08/safetensors-0.6.1-cp38-abi3-macosx_11_0_arm64.whl", hash = "sha256:01b51af8cb7a3870203f2735e3c7c24d1a65fb2846e75613c8cf9d284271eccc", size = 432150, upload-time = "2025-08-06T09:39:31.008Z" }, + { url = "https://files.pythonhosted.org/packages/05/d7/820c99032a53d57279ae199df7d114a8c9e2bbce4fa69bc0de53743495f0/safetensors-0.6.1-cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:64a733886d79e726899b9d9643813e48a2eec49f3ef0fdb8cd4b8152046101c3", size = 471634, upload-time = "2025-08-06T09:39:22.17Z" }, + { url = "https://files.pythonhosted.org/packages/ea/8b/bcd960087eded7690f118ceeda294912f92a3b508a1d9a504f9c2e02041b/safetensors-0.6.1-cp38-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f233dc3b12fb641b36724844754b6bb41349615a0e258087560968d6da92add5", size = 487855, upload-time = "2025-08-06T09:39:24.142Z" }, + { url = "https://files.pythonhosted.org/packages/41/64/b44eac4ad87c4e1c0cf5ba5e204c032b1b1eac8ce2b8f65f87791e647bd6/safetensors-0.6.1-cp38-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6f16289e2af54affd591dd78ed12b5465e4dc5823f818beaeddd49a010cf3ba7", size = 607240, upload-time = "2025-08-06T09:39:25.463Z" }, + { url = "https://files.pythonhosted.org/packages/52/75/0347fa0c080af8bd3341af26a30b85939f6362d4f5240add1a0c9d793354/safetensors-0.6.1-cp38-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1b62eab84e2c69918b598272504c5d2ebfe64da6c16fdf8682054eec9572534d", size = 519864, upload-time = "2025-08-06T09:39:26.872Z" }, + { url = "https://files.pythonhosted.org/packages/ea/f3/83843d1fe9164f44a267373c55cba706530b209b58415f807b40edddcd3e/safetensors-0.6.1-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d498363746555dccffc02a47dfe1dee70f7784f3f37f1d66b408366c5d3a989e", size = 485926, upload-time = "2025-08-06T09:39:29.109Z" }, + { url = "https://files.pythonhosted.org/packages/b8/26/f6b0cb5210bab0e343214fdba7c2df80a69b019e62e760ddc61b18bec383/safetensors-0.6.1-cp38-abi3-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:eed2079dca3ca948d7b0d7120396e776bbc6680637cf199d393e157fde25c937", size = 518999, upload-time = "2025-08-06T09:39:28.054Z" }, + { url = "https://files.pythonhosted.org/packages/90/b7/8910b165c97d3bd6d445c6ca8b704ec23d0fa33849ce9a51dc783827a302/safetensors-0.6.1-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:294040ff20ebe079a2b4976cfa9a5be0202f56ca4f7f190b4e52009e8c026ceb", size = 650669, upload-time = "2025-08-06T09:39:32.997Z" }, + { url = "https://files.pythonhosted.org/packages/00/bc/2eeb025381d0834ae038aae2d383dfa830c2e0068e2e4e512ea99b135a4b/safetensors-0.6.1-cp38-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:75693208b492a026b926edeebbae888cc644433bee4993573ead2dc44810b519", size = 750019, upload-time = "2025-08-06T09:39:34.397Z" }, + { url = "https://files.pythonhosted.org/packages/f9/38/5dda9a8e056eb1f17ed3a7846698fd94623a1648013cdf522538845755da/safetensors-0.6.1-cp38-abi3-musllinux_1_2_i686.whl", hash = "sha256:a8687b71ac67a0b3f8ce87df9e8024edf087e94c34ef46eaaad694dce8d2f83f", size = 689888, upload-time = "2025-08-06T09:39:35.584Z" }, + { url = "https://files.pythonhosted.org/packages/dd/60/15ee3961996d951002378d041bd82863a5c70738a71375b42d6dd5d2a6d3/safetensors-0.6.1-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:5dd969a01c738104f707fa0e306b757f5beb3ebdcd682fe0724170a0bf1c21fb", size = 655539, upload-time = "2025-08-06T09:39:37.093Z" }, + { url = "https://files.pythonhosted.org/packages/91/d6/01172a9c77c566800286d379bfc341d75370eae2118dfd339edfd0394c4a/safetensors-0.6.1-cp38-abi3-win32.whl", hash = "sha256:7c3d8d34d01673d1a917445c9437ee73a9d48bc6af10352b84bbd46c5da93ca5", size = 308594, upload-time = "2025-08-06T09:39:40.916Z" }, + { url = "https://files.pythonhosted.org/packages/6c/5d/195dc1917d7ae93dd990d9b2f8b9c88e451bcc78e0b63ee107beebc1e4be/safetensors-0.6.1-cp38-abi3-win_amd64.whl", hash = "sha256:4720957052d57c5ac48912c3f6e07e9a334d9632758c9b0c054afba477fcbe2d", size = 320282, upload-time = "2025-08-06T09:39:39.54Z" }, +] + +[[package]] +name = "scikit-learn" +version = "1.7.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "joblib" }, + { name = "numpy" }, + { name = "scipy" }, + { name = "threadpoolctl" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/41/84/5f4af978fff619706b8961accac84780a6d298d82a8873446f72edb4ead0/scikit_learn-1.7.1.tar.gz", hash = "sha256:24b3f1e976a4665aa74ee0fcaac2b8fccc6ae77c8e07ab25da3ba6d3292b9802", size = 7190445, upload-time = "2025-07-18T08:01:54.5Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cb/16/57f176585b35ed865f51b04117947fe20f130f78940c6477b6d66279c9c2/scikit_learn-1.7.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:3cee419b49b5bbae8796ecd690f97aa412ef1674410c23fc3257c6b8b85b8087", size = 9260431, upload-time = "2025-07-18T08:01:22.77Z" }, + { url = "https://files.pythonhosted.org/packages/67/4e/899317092f5efcab0e9bc929e3391341cec8fb0e816c4789686770024580/scikit_learn-1.7.1-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:2fd8b8d35817b0d9ebf0b576f7d5ffbbabdb55536b0655a8aaae629d7ffd2e1f", size = 8637191, upload-time = "2025-07-18T08:01:24.731Z" }, + { url = "https://files.pythonhosted.org/packages/f3/1b/998312db6d361ded1dd56b457ada371a8d8d77ca2195a7d18fd8a1736f21/scikit_learn-1.7.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:588410fa19a96a69763202f1d6b7b91d5d7a5d73be36e189bc6396bfb355bd87", size = 9486346, upload-time = "2025-07-18T08:01:26.713Z" }, + { url = "https://files.pythonhosted.org/packages/ad/09/a2aa0b4e644e5c4ede7006748f24e72863ba2ae71897fecfd832afea01b4/scikit_learn-1.7.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e3142f0abe1ad1d1c31a2ae987621e41f6b578144a911ff4ac94781a583adad7", size = 9290988, upload-time = "2025-07-18T08:01:28.938Z" }, + { url = "https://files.pythonhosted.org/packages/15/fa/c61a787e35f05f17fc10523f567677ec4eeee5f95aa4798dbbbcd9625617/scikit_learn-1.7.1-cp312-cp312-win_amd64.whl", hash = "sha256:3ddd9092c1bd469acab337d87930067c87eac6bd544f8d5027430983f1e1ae88", size = 8735568, upload-time = "2025-07-18T08:01:30.936Z" }, + { url = "https://files.pythonhosted.org/packages/52/f8/e0533303f318a0f37b88300d21f79b6ac067188d4824f1047a37214ab718/scikit_learn-1.7.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:b7839687fa46d02e01035ad775982f2470be2668e13ddd151f0f55a5bf123bae", size = 9213143, upload-time = "2025-07-18T08:01:32.942Z" }, + { url = "https://files.pythonhosted.org/packages/71/f3/f1df377d1bdfc3e3e2adc9c119c238b182293e6740df4cbeac6de2cc3e23/scikit_learn-1.7.1-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:a10f276639195a96c86aa572ee0698ad64ee939a7b042060b98bd1930c261d10", size = 8591977, upload-time = "2025-07-18T08:01:34.967Z" }, + { url = "https://files.pythonhosted.org/packages/99/72/c86a4cd867816350fe8dee13f30222340b9cd6b96173955819a5561810c5/scikit_learn-1.7.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:13679981fdaebc10cc4c13c43344416a86fcbc61449cb3e6517e1df9d12c8309", size = 9436142, upload-time = "2025-07-18T08:01:37.397Z" }, + { url = "https://files.pythonhosted.org/packages/e8/66/277967b29bd297538dc7a6ecfb1a7dce751beabd0d7f7a2233be7a4f7832/scikit_learn-1.7.1-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4f1262883c6a63f067a980a8cdd2d2e7f2513dddcef6a9eaada6416a7a7cbe43", size = 9282996, upload-time = "2025-07-18T08:01:39.721Z" }, + { url = "https://files.pythonhosted.org/packages/e2/47/9291cfa1db1dae9880420d1e07dbc7e8dd4a7cdbc42eaba22512e6bde958/scikit_learn-1.7.1-cp313-cp313-win_amd64.whl", hash = "sha256:ca6d31fb10e04d50bfd2b50d66744729dbb512d4efd0223b864e2fdbfc4cee11", size = 8707418, upload-time = "2025-07-18T08:01:42.124Z" }, + { url = "https://files.pythonhosted.org/packages/61/95/45726819beccdaa34d3362ea9b2ff9f2b5d3b8bf721bd632675870308ceb/scikit_learn-1.7.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:781674d096303cfe3d351ae6963ff7c958db61cde3421cd490e3a5a58f2a94ae", size = 9561466, upload-time = "2025-07-18T08:01:44.195Z" }, + { url = "https://files.pythonhosted.org/packages/ee/1c/6f4b3344805de783d20a51eb24d4c9ad4b11a7f75c1801e6ec6d777361fd/scikit_learn-1.7.1-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:10679f7f125fe7ecd5fad37dd1aa2daae7e3ad8df7f3eefa08901b8254b3e12c", size = 9040467, upload-time = "2025-07-18T08:01:46.671Z" }, + { url = "https://files.pythonhosted.org/packages/6f/80/abe18fe471af9f1d181904203d62697998b27d9b62124cd281d740ded2f9/scikit_learn-1.7.1-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1f812729e38c8cb37f760dce71a9b83ccfb04f59b3dca7c6079dcdc60544fa9e", size = 9532052, upload-time = "2025-07-18T08:01:48.676Z" }, + { url = "https://files.pythonhosted.org/packages/14/82/b21aa1e0c4cee7e74864d3a5a721ab8fcae5ca55033cb6263dca297ed35b/scikit_learn-1.7.1-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:88e1a20131cf741b84b89567e1717f27a2ced228e0f29103426102bc2e3b8ef7", size = 9361575, upload-time = "2025-07-18T08:01:50.639Z" }, + { url = "https://files.pythonhosted.org/packages/f2/20/f4777fcd5627dc6695fa6b92179d0edb7a3ac1b91bcd9a1c7f64fa7ade23/scikit_learn-1.7.1-cp313-cp313t-win_amd64.whl", hash = "sha256:b1bd1d919210b6a10b7554b717c9000b5485aa95a1d0f177ae0d7ee8ec750da5", size = 9277310, upload-time = "2025-07-18T08:01:52.547Z" }, +] + +[[package]] +name = "scipy" +version = "1.16.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f5/4a/b927028464795439faec8eaf0b03b011005c487bb2d07409f28bf30879c4/scipy-1.16.1.tar.gz", hash = "sha256:44c76f9e8b6e8e488a586190ab38016e4ed2f8a038af7cd3defa903c0a2238b3", size = 30580861, upload-time = "2025-07-27T16:33:30.834Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f8/d9/ec4864f5896232133f51382b54a08de91a9d1af7a76dfa372894026dfee2/scipy-1.16.1-cp312-cp312-macosx_10_14_x86_64.whl", hash = "sha256:81b433bbeaf35728dad619afc002db9b189e45eebe2cd676effe1fb93fef2b9c", size = 36575194, upload-time = "2025-07-27T16:27:41.321Z" }, + { url = "https://files.pythonhosted.org/packages/5c/6d/40e81ecfb688e9d25d34a847dca361982a6addf8e31f0957b1a54fbfa994/scipy-1.16.1-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:886cc81fdb4c6903a3bb0464047c25a6d1016fef77bb97949817d0c0d79f9e04", size = 28594590, upload-time = "2025-07-27T16:27:49.204Z" }, + { url = "https://files.pythonhosted.org/packages/0e/37/9f65178edfcc629377ce9a64fc09baebea18c80a9e57ae09a52edf84880b/scipy-1.16.1-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:15240c3aac087a522b4eaedb09f0ad061753c5eebf1ea430859e5bf8640d5919", size = 20866458, upload-time = "2025-07-27T16:27:54.98Z" }, + { url = "https://files.pythonhosted.org/packages/2c/7b/749a66766871ea4cb1d1ea10f27004db63023074c22abed51f22f09770e0/scipy-1.16.1-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:65f81a25805f3659b48126b5053d9e823d3215e4a63730b5e1671852a1705921", size = 23539318, upload-time = "2025-07-27T16:28:01.604Z" }, + { url = "https://files.pythonhosted.org/packages/c4/db/8d4afec60eb833a666434d4541a3151eedbf2494ea6d4d468cbe877f00cd/scipy-1.16.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:6c62eea7f607f122069b9bad3f99489ddca1a5173bef8a0c75555d7488b6f725", size = 33292899, upload-time = "2025-07-27T16:28:09.147Z" }, + { url = "https://files.pythonhosted.org/packages/51/1e/79023ca3bbb13a015d7d2757ecca3b81293c663694c35d6541b4dca53e98/scipy-1.16.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f965bbf3235b01c776115ab18f092a95aa74c271a52577bcb0563e85738fd618", size = 35162637, upload-time = "2025-07-27T16:28:17.535Z" }, + { url = "https://files.pythonhosted.org/packages/b6/49/0648665f9c29fdaca4c679182eb972935b3b4f5ace41d323c32352f29816/scipy-1.16.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f006e323874ffd0b0b816d8c6a8e7f9a73d55ab3b8c3f72b752b226d0e3ac83d", size = 35490507, upload-time = "2025-07-27T16:28:25.705Z" }, + { url = "https://files.pythonhosted.org/packages/62/8f/66cbb9d6bbb18d8c658f774904f42a92078707a7c71e5347e8bf2f52bb89/scipy-1.16.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e8fd15fc5085ab4cca74cb91fe0a4263b1f32e4420761ddae531ad60934c2119", size = 37923998, upload-time = "2025-07-27T16:28:34.339Z" }, + { url = "https://files.pythonhosted.org/packages/14/c3/61f273ae550fbf1667675701112e380881905e28448c080b23b5a181df7c/scipy-1.16.1-cp312-cp312-win_amd64.whl", hash = "sha256:f7b8013c6c066609577d910d1a2a077021727af07b6fab0ee22c2f901f22352a", size = 38508060, upload-time = "2025-07-27T16:28:43.242Z" }, + { url = "https://files.pythonhosted.org/packages/93/0b/b5c99382b839854a71ca9482c684e3472badc62620287cbbdab499b75ce6/scipy-1.16.1-cp313-cp313-macosx_10_14_x86_64.whl", hash = "sha256:5451606823a5e73dfa621a89948096c6528e2896e40b39248295d3a0138d594f", size = 36533717, upload-time = "2025-07-27T16:28:51.706Z" }, + { url = "https://files.pythonhosted.org/packages/eb/e5/69ab2771062c91e23e07c12e7d5033a6b9b80b0903ee709c3c36b3eb520c/scipy-1.16.1-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:89728678c5ca5abd610aee148c199ac1afb16e19844401ca97d43dc548a354eb", size = 28570009, upload-time = "2025-07-27T16:28:57.017Z" }, + { url = "https://files.pythonhosted.org/packages/f4/69/bd75dbfdd3cf524f4d753484d723594aed62cfaac510123e91a6686d520b/scipy-1.16.1-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:e756d688cb03fd07de0fffad475649b03cb89bee696c98ce508b17c11a03f95c", size = 20841942, upload-time = "2025-07-27T16:29:01.152Z" }, + { url = "https://files.pythonhosted.org/packages/ea/74/add181c87663f178ba7d6144b370243a87af8476664d5435e57d599e6874/scipy-1.16.1-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:5aa2687b9935da3ed89c5dbed5234576589dd28d0bf7cd237501ccfbdf1ad608", size = 23498507, upload-time = "2025-07-27T16:29:05.202Z" }, + { url = "https://files.pythonhosted.org/packages/1d/74/ece2e582a0d9550cee33e2e416cc96737dce423a994d12bbe59716f47ff1/scipy-1.16.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:0851f6a1e537fe9399f35986897e395a1aa61c574b178c0d456be5b1a0f5ca1f", size = 33286040, upload-time = "2025-07-27T16:29:10.201Z" }, + { url = "https://files.pythonhosted.org/packages/e4/82/08e4076df538fb56caa1d489588d880ec7c52d8273a606bb54d660528f7c/scipy-1.16.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fedc2cbd1baed37474b1924c331b97bdff611d762c196fac1a9b71e67b813b1b", size = 35176096, upload-time = "2025-07-27T16:29:17.091Z" }, + { url = "https://files.pythonhosted.org/packages/fa/79/cd710aab8c921375711a8321c6be696e705a120e3011a643efbbcdeeabcc/scipy-1.16.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:2ef500e72f9623a6735769e4b93e9dcb158d40752cdbb077f305487e3e2d1f45", size = 35490328, upload-time = "2025-07-27T16:29:22.928Z" }, + { url = "https://files.pythonhosted.org/packages/71/73/e9cc3d35ee4526d784520d4494a3e1ca969b071fb5ae5910c036a375ceec/scipy-1.16.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:978d8311674b05a8f7ff2ea6c6bce5d8b45a0cb09d4c5793e0318f448613ea65", size = 37939921, upload-time = "2025-07-27T16:29:29.108Z" }, + { url = "https://files.pythonhosted.org/packages/21/12/c0efd2941f01940119b5305c375ae5c0fcb7ec193f806bd8f158b73a1782/scipy-1.16.1-cp313-cp313-win_amd64.whl", hash = "sha256:81929ed0fa7a5713fcdd8b2e6f73697d3b4c4816d090dd34ff937c20fa90e8ab", size = 38479462, upload-time = "2025-07-27T16:30:24.078Z" }, + { url = "https://files.pythonhosted.org/packages/7a/19/c3d08b675260046a991040e1ea5d65f91f40c7df1045fffff412dcfc6765/scipy-1.16.1-cp313-cp313t-macosx_10_14_x86_64.whl", hash = "sha256:bcc12db731858abda693cecdb3bdc9e6d4bd200213f49d224fe22df82687bdd6", size = 36938832, upload-time = "2025-07-27T16:29:35.057Z" }, + { url = "https://files.pythonhosted.org/packages/81/f2/ce53db652c033a414a5b34598dba6b95f3d38153a2417c5a3883da429029/scipy-1.16.1-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:744d977daa4becb9fc59135e75c069f8d301a87d64f88f1e602a9ecf51e77b27", size = 29093084, upload-time = "2025-07-27T16:29:40.201Z" }, + { url = "https://files.pythonhosted.org/packages/a9/ae/7a10ff04a7dc15f9057d05b33737ade244e4bd195caa3f7cc04d77b9e214/scipy-1.16.1-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:dc54f76ac18073bcecffb98d93f03ed6b81a92ef91b5d3b135dcc81d55a724c7", size = 21365098, upload-time = "2025-07-27T16:29:44.295Z" }, + { url = "https://files.pythonhosted.org/packages/36/ac/029ff710959932ad3c2a98721b20b405f05f752f07344622fd61a47c5197/scipy-1.16.1-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:367d567ee9fc1e9e2047d31f39d9d6a7a04e0710c86e701e053f237d14a9b4f6", size = 23896858, upload-time = "2025-07-27T16:29:48.784Z" }, + { url = "https://files.pythonhosted.org/packages/71/13/d1ef77b6bd7898720e1f0b6b3743cb945f6c3cafa7718eaac8841035ab60/scipy-1.16.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:4cf5785e44e19dcd32a0e4807555e1e9a9b8d475c6afff3d21c3c543a6aa84f4", size = 33438311, upload-time = "2025-07-27T16:29:54.164Z" }, + { url = "https://files.pythonhosted.org/packages/2d/e0/e64a6821ffbb00b4c5b05169f1c1fddb4800e9307efe3db3788995a82a2c/scipy-1.16.1-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3d0b80fb26d3e13a794c71d4b837e2a589d839fd574a6bbb4ee1288c213ad4a3", size = 35279542, upload-time = "2025-07-27T16:30:00.249Z" }, + { url = "https://files.pythonhosted.org/packages/57/59/0dc3c8b43e118f1e4ee2b798dcc96ac21bb20014e5f1f7a8e85cc0653bdb/scipy-1.16.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:8503517c44c18d1030d666cb70aaac1cc8913608816e06742498833b128488b7", size = 35667665, upload-time = "2025-07-27T16:30:05.916Z" }, + { url = "https://files.pythonhosted.org/packages/45/5f/844ee26e34e2f3f9f8febb9343748e72daeaec64fe0c70e9bf1ff84ec955/scipy-1.16.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:30cc4bb81c41831ecfd6dc450baf48ffd80ef5aed0f5cf3ea775740e80f16ecc", size = 38045210, upload-time = "2025-07-27T16:30:11.655Z" }, + { url = "https://files.pythonhosted.org/packages/8d/d7/210f2b45290f444f1de64bc7353aa598ece9f0e90c384b4a156f9b1a5063/scipy-1.16.1-cp313-cp313t-win_amd64.whl", hash = "sha256:c24fa02f7ed23ae514460a22c57eca8f530dbfa50b1cfdbf4f37c05b5309cc39", size = 38593661, upload-time = "2025-07-27T16:30:17.825Z" }, + { url = "https://files.pythonhosted.org/packages/81/ea/84d481a5237ed223bd3d32d6e82d7a6a96e34756492666c260cef16011d1/scipy-1.16.1-cp314-cp314-macosx_10_14_x86_64.whl", hash = "sha256:796a5a9ad36fa3a782375db8f4241ab02a091308eb079746bc0f874c9b998318", size = 36525921, upload-time = "2025-07-27T16:30:30.081Z" }, + { url = "https://files.pythonhosted.org/packages/4e/9f/d9edbdeff9f3a664807ae3aea383e10afaa247e8e6255e6d2aa4515e8863/scipy-1.16.1-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:3ea0733a2ff73fd6fdc5fecca54ee9b459f4d74f00b99aced7d9a3adb43fb1cc", size = 28564152, upload-time = "2025-07-27T16:30:35.336Z" }, + { url = "https://files.pythonhosted.org/packages/3b/95/8125bcb1fe04bc267d103e76516243e8d5e11229e6b306bda1024a5423d1/scipy-1.16.1-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:85764fb15a2ad994e708258bb4ed8290d1305c62a4e1ef07c414356a24fcfbf8", size = 20836028, upload-time = "2025-07-27T16:30:39.421Z" }, + { url = "https://files.pythonhosted.org/packages/77/9c/bf92e215701fc70bbcd3d14d86337cf56a9b912a804b9c776a269524a9e9/scipy-1.16.1-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:ca66d980469cb623b1759bdd6e9fd97d4e33a9fad5b33771ced24d0cb24df67e", size = 23489666, upload-time = "2025-07-27T16:30:43.663Z" }, + { url = "https://files.pythonhosted.org/packages/5e/00/5e941d397d9adac41b02839011594620d54d99488d1be5be755c00cde9ee/scipy-1.16.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:e7cc1ffcc230f568549fc56670bcf3df1884c30bd652c5da8138199c8c76dae0", size = 33358318, upload-time = "2025-07-27T16:30:48.982Z" }, + { url = "https://files.pythonhosted.org/packages/0e/87/8db3aa10dde6e3e8e7eb0133f24baa011377d543f5b19c71469cf2648026/scipy-1.16.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3ddfb1e8d0b540cb4ee9c53fc3dea3186f97711248fb94b4142a1b27178d8b4b", size = 35185724, upload-time = "2025-07-27T16:30:54.26Z" }, + { url = "https://files.pythonhosted.org/packages/89/b4/6ab9ae443216807622bcff02690262d8184078ea467efee2f8c93288a3b1/scipy-1.16.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:4dc0e7be79e95d8ba3435d193e0d8ce372f47f774cffd882f88ea4e1e1ddc731", size = 35554335, upload-time = "2025-07-27T16:30:59.765Z" }, + { url = "https://files.pythonhosted.org/packages/9c/9a/d0e9dc03c5269a1afb60661118296a32ed5d2c24298af61b676c11e05e56/scipy-1.16.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:f23634f9e5adb51b2a77766dac217063e764337fbc816aa8ad9aaebcd4397fd3", size = 37960310, upload-time = "2025-07-27T16:31:06.151Z" }, + { url = "https://files.pythonhosted.org/packages/5e/00/c8f3130a50521a7977874817ca89e0599b1b4ee8e938bad8ae798a0e1f0d/scipy-1.16.1-cp314-cp314-win_amd64.whl", hash = "sha256:57d75524cb1c5a374958a2eae3d84e1929bb971204cc9d52213fb8589183fc19", size = 39319239, upload-time = "2025-07-27T16:31:59.942Z" }, + { url = "https://files.pythonhosted.org/packages/f2/f2/1ca3eda54c3a7e4c92f6acef7db7b3a057deb135540d23aa6343ef8ad333/scipy-1.16.1-cp314-cp314t-macosx_10_14_x86_64.whl", hash = "sha256:d8da7c3dd67bcd93f15618938f43ed0995982eb38973023d46d4646c4283ad65", size = 36939460, upload-time = "2025-07-27T16:31:11.865Z" }, + { url = "https://files.pythonhosted.org/packages/80/30/98c2840b293a132400c0940bb9e140171dcb8189588619048f42b2ce7b4f/scipy-1.16.1-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:cc1d2f2fd48ba1e0620554fe5bc44d3e8f5d4185c8c109c7fbdf5af2792cfad2", size = 29093322, upload-time = "2025-07-27T16:31:17.045Z" }, + { url = "https://files.pythonhosted.org/packages/c1/e6/1e6e006e850622cf2a039b62d1a6ddc4497d4851e58b68008526f04a9a00/scipy-1.16.1-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:21a611ced9275cb861bacadbada0b8c0623bc00b05b09eb97f23b370fc2ae56d", size = 21365329, upload-time = "2025-07-27T16:31:21.188Z" }, + { url = "https://files.pythonhosted.org/packages/8e/02/72a5aa5b820589dda9a25e329ca752842bfbbaf635e36bc7065a9b42216e/scipy-1.16.1-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:8dfbb25dffc4c3dd9371d8ab456ca81beeaf6f9e1c2119f179392f0dc1ab7695", size = 23897544, upload-time = "2025-07-27T16:31:25.408Z" }, + { url = "https://files.pythonhosted.org/packages/2b/dc/7122d806a6f9eb8a33532982234bed91f90272e990f414f2830cfe656e0b/scipy-1.16.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f0ebb7204f063fad87fc0a0e4ff4a2ff40b2a226e4ba1b7e34bf4b79bf97cd86", size = 33442112, upload-time = "2025-07-27T16:31:30.62Z" }, + { url = "https://files.pythonhosted.org/packages/24/39/e383af23564daa1021a5b3afbe0d8d6a68ec639b943661841f44ac92de85/scipy-1.16.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f1b9e5962656f2734c2b285a8745358ecb4e4efbadd00208c80a389227ec61ff", size = 35286594, upload-time = "2025-07-27T16:31:36.112Z" }, + { url = "https://files.pythonhosted.org/packages/95/47/1a0b0aff40c3056d955f38b0df5d178350c3d74734ec54f9c68d23910be5/scipy-1.16.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5e1a106f8c023d57a2a903e771228bf5c5b27b5d692088f457acacd3b54511e4", size = 35665080, upload-time = "2025-07-27T16:31:42.025Z" }, + { url = "https://files.pythonhosted.org/packages/64/df/ce88803e9ed6e27fe9b9abefa157cf2c80e4fa527cf17ee14be41f790ad4/scipy-1.16.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:709559a1db68a9abc3b2c8672c4badf1614f3b440b3ab326d86a5c0491eafae3", size = 38050306, upload-time = "2025-07-27T16:31:48.109Z" }, + { url = "https://files.pythonhosted.org/packages/6e/6c/a76329897a7cae4937d403e623aa6aaea616a0bb5b36588f0b9d1c9a3739/scipy-1.16.1-cp314-cp314t-win_amd64.whl", hash = "sha256:c0c804d60492a0aad7f5b2bb1862f4548b990049e27e828391ff2bf6f7199998", size = 39427705, upload-time = "2025-07-27T16:31:53.96Z" }, +] + +[[package]] +name = "seaborn" +version = "0.13.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "matplotlib" }, + { name = "numpy" }, + { name = "pandas" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/86/59/a451d7420a77ab0b98f7affa3a1d78a313d2f7281a57afb1a34bae8ab412/seaborn-0.13.2.tar.gz", hash = "sha256:93e60a40988f4d65e9f4885df477e2fdaff6b73a9ded434c1ab356dd57eefff7", size = 1457696, upload-time = "2024-01-25T13:21:52.551Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/83/11/00d3c3dfc25ad54e731d91449895a79e4bf2384dc3ac01809010ba88f6d5/seaborn-0.13.2-py3-none-any.whl", hash = "sha256:636f8336facf092165e27924f223d3c62ca560b1f2bb5dff7ab7fad265361987", size = 294914, upload-time = "2024-01-25T13:21:49.598Z" }, +] + +[[package]] +name = "send2trash" +version = "1.8.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/fd/3a/aec9b02217bb79b87bbc1a21bc6abc51e3d5dcf65c30487ac96c0908c722/Send2Trash-1.8.3.tar.gz", hash = "sha256:b18e7a3966d99871aefeb00cfbcfdced55ce4871194810fc71f4aa484b953abf", size = 17394, upload-time = "2024-04-07T00:01:09.267Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/40/b0/4562db6223154aa4e22f939003cb92514c79f3d4dccca3444253fd17f902/Send2Trash-1.8.3-py3-none-any.whl", hash = "sha256:0c31227e0bd08961c7665474a3d1ef7193929fedda4233843689baa056be46c9", size = 18072, upload-time = "2024-04-07T00:01:07.438Z" }, +] + +[[package]] +name = "sentence-transformers" +version = "2.7.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "huggingface-hub" }, + { name = "numpy" }, + { name = "pillow" }, + { name = "scikit-learn" }, + { name = "scipy" }, + { name = "torch" }, + { name = "tqdm" }, + { name = "transformers" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/65/8d/8d6147fdef0ed7aeff3dab487bd17619b512afab845eb295faa08b20a5d0/sentence_transformers-2.7.0.tar.gz", hash = "sha256:2f7df99d1c021dded471ed2d079e9d1e4fc8e30ecb06f957be060511b36f24ea", size = 128393, upload-time = "2024-04-17T13:15:44.223Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/76/2c/bd95032aeb087b0706596af0a4518c4bfe0439a1bb149048ece18b617766/sentence_transformers-2.7.0-py3-none-any.whl", hash = "sha256:6a7276b05a95931581bbfa4ba49d780b2cf6904fa4a171ec7fd66c343f761c98", size = 171480, upload-time = "2024-04-17T13:15:42.048Z" }, +] + +[[package]] +name = "setuptools" +version = "80.9.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/18/5d/3bf57dcd21979b887f014ea83c24ae194cfcd12b9e0fda66b957c69d1fca/setuptools-80.9.0.tar.gz", hash = "sha256:f36b47402ecde768dbfafc46e8e4207b4360c654f1f3bb84475f0a28628fb19c", size = 1319958, upload-time = "2025-05-27T00:56:51.443Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a3/dc/17031897dae0efacfea57dfd3a82fdd2a2aeb58e0ff71b77b87e44edc772/setuptools-80.9.0-py3-none-any.whl", hash = "sha256:062d34222ad13e0cc312a4c02d73f059e86a4acbfbdea8f8f76b28c99f306922", size = 1201486, upload-time = "2025-05-27T00:56:49.664Z" }, +] + +[[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 = "sniffio" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc", size = 20372, upload-time = "2024-02-25T23:20:04.057Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235, upload-time = "2024-02-25T23:20:01.196Z" }, +] + +[[package]] +name = "soupsieve" +version = "2.7" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/3f/f4/4a80cd6ef364b2e8b65b15816a843c0980f7a5a2b4dc701fc574952aa19f/soupsieve-2.7.tar.gz", hash = "sha256:ad282f9b6926286d2ead4750552c8a6142bc4c783fd66b0293547c8fe6ae126a", size = 103418, upload-time = "2025-04-20T18:50:08.518Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/9c/0e6afc12c269578be5c0c1c9f4b49a8d32770a080260c333ac04cc1c832d/soupsieve-2.7-py3-none-any.whl", hash = "sha256:6e60cc5c1ffaf1cebcc12e8188320b72071e922c2e897f737cadce79ad5d30c4", size = 36677, upload-time = "2025-04-20T18:50:07.196Z" }, +] + +[[package]] +name = "stack-data" +version = "0.6.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "asttokens" }, + { name = "executing" }, + { name = "pure-eval" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/28/e3/55dcc2cfbc3ca9c29519eb6884dd1415ecb53b0e934862d3559ddcb7e20b/stack_data-0.6.3.tar.gz", hash = "sha256:836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9", size = 44707, upload-time = "2023-09-30T13:58:05.479Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f1/7b/ce1eafaf1a76852e2ec9b22edecf1daa58175c090266e9f6c64afcd81d91/stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695", size = 24521, upload-time = "2023-09-30T13:58:03.53Z" }, +] + +[[package]] +name = "sympy" +version = "1.14.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "mpmath" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/83/d3/803453b36afefb7c2bb238361cd4ae6125a569b4db67cd9e79846ba2d68c/sympy-1.14.0.tar.gz", hash = "sha256:d3d3fe8df1e5a0b42f0e7bdf50541697dbe7d23746e894990c030e2b05e72517", size = 7793921, upload-time = "2025-04-27T18:05:01.611Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a2/09/77d55d46fd61b4a135c444fc97158ef34a095e5681d0a6c10b75bf356191/sympy-1.14.0-py3-none-any.whl", hash = "sha256:e091cc3e99d2141a0ba2847328f5479b05d94a6635cb96148ccb3f34671bd8f5", size = 6299353, upload-time = "2025-04-27T18:04:59.103Z" }, +] + +[[package]] +name = "terminado" +version = "0.18.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ptyprocess", marker = "os_name != 'nt'" }, + { name = "pywinpty", marker = "os_name == 'nt'" }, + { name = "tornado" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/8a/11/965c6fd8e5cc254f1fe142d547387da17a8ebfd75a3455f637c663fb38a0/terminado-0.18.1.tar.gz", hash = "sha256:de09f2c4b85de4765f7714688fff57d3e75bad1f909b589fde880460c753fd2e", size = 32701, upload-time = "2024-03-12T14:34:39.026Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6a/9e/2064975477fdc887e47ad42157e214526dcad8f317a948dee17e1659a62f/terminado-0.18.1-py3-none-any.whl", hash = "sha256:a4468e1b37bb318f8a86514f65814e1afc977cf29b3992a4500d9dd305dcceb0", size = 14154, upload-time = "2024-03-12T14:34:36.569Z" }, +] + +[[package]] +name = "threadpoolctl" +version = "3.6.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b7/4d/08c89e34946fce2aec4fbb45c9016efd5f4d7f24af8e5d93296e935631d8/threadpoolctl-3.6.0.tar.gz", hash = "sha256:8ab8b4aa3491d812b623328249fab5302a68d2d71745c8a4c719a2fcaba9f44e", size = 21274, upload-time = "2025-03-13T13:49:23.031Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/32/d5/f9a850d79b0851d1d4ef6456097579a9005b31fea68726a4ae5f2d82ddd9/threadpoolctl-3.6.0-py3-none-any.whl", hash = "sha256:43a0b8fd5a2928500110039e43a5eed8480b918967083ea48dc3ab9f13c4a7fb", size = 18638, upload-time = "2025-03-13T13:49:21.846Z" }, +] + +[[package]] +name = "tinycss2" +version = "1.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "webencodings" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7a/fd/7a5ee21fd08ff70d3d33a5781c255cbe779659bd03278feb98b19ee550f4/tinycss2-1.4.0.tar.gz", hash = "sha256:10c0972f6fc0fbee87c3edb76549357415e94548c1ae10ebccdea16fb404a9b7", size = 87085, upload-time = "2024-10-24T14:58:29.895Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e6/34/ebdc18bae6aa14fbee1a08b63c015c72b64868ff7dae68808ab500c492e2/tinycss2-1.4.0-py3-none-any.whl", hash = "sha256:3a49cf47b7675da0b15d0c6e1df8df4ebd96e9394bb905a5775adb0d884c5289", size = 26610, upload-time = "2024-10-24T14:58:28.029Z" }, +] + +[[package]] +name = "tokenizers" +version = "0.21.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "huggingface-hub" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c2/2f/402986d0823f8d7ca139d969af2917fefaa9b947d1fb32f6168c509f2492/tokenizers-0.21.4.tar.gz", hash = "sha256:fa23f85fbc9a02ec5c6978da172cdcbac23498c3ca9f3645c5c68740ac007880", size = 351253, upload-time = "2025-07-28T15:48:54.325Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/98/c6/fdb6f72bf6454f52eb4a2510be7fb0f614e541a2554d6210e370d85efff4/tokenizers-0.21.4-cp39-abi3-macosx_10_12_x86_64.whl", hash = "sha256:2ccc10a7c3bcefe0f242867dc914fc1226ee44321eb618cfe3019b5df3400133", size = 2863987, upload-time = "2025-07-28T15:48:44.877Z" }, + { url = "https://files.pythonhosted.org/packages/8d/a6/28975479e35ddc751dc1ddc97b9b69bf7fcf074db31548aab37f8116674c/tokenizers-0.21.4-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:5e2f601a8e0cd5be5cc7506b20a79112370b9b3e9cb5f13f68ab11acd6ca7d60", size = 2732457, upload-time = "2025-07-28T15:48:43.265Z" }, + { url = "https://files.pythonhosted.org/packages/aa/8f/24f39d7b5c726b7b0be95dca04f344df278a3fe3a4deb15a975d194cbb32/tokenizers-0.21.4-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:39b376f5a1aee67b4d29032ee85511bbd1b99007ec735f7f35c8a2eb104eade5", size = 3012624, upload-time = "2025-07-28T13:22:43.895Z" }, + { url = "https://files.pythonhosted.org/packages/58/47/26358925717687a58cb74d7a508de96649544fad5778f0cd9827398dc499/tokenizers-0.21.4-cp39-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2107ad649e2cda4488d41dfd031469e9da3fcbfd6183e74e4958fa729ffbf9c6", size = 2939681, upload-time = "2025-07-28T13:22:47.499Z" }, + { url = "https://files.pythonhosted.org/packages/99/6f/cc300fea5db2ab5ddc2c8aea5757a27b89c84469899710c3aeddc1d39801/tokenizers-0.21.4-cp39-abi3-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3c73012da95afafdf235ba80047699df4384fdc481527448a078ffd00e45a7d9", size = 3247445, upload-time = "2025-07-28T15:48:39.711Z" }, + { url = "https://files.pythonhosted.org/packages/be/bf/98cb4b9c3c4afd8be89cfa6423704337dc20b73eb4180397a6e0d456c334/tokenizers-0.21.4-cp39-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f23186c40395fc390d27f519679a58023f368a0aad234af145e0f39ad1212732", size = 3428014, upload-time = "2025-07-28T13:22:49.569Z" }, + { url = "https://files.pythonhosted.org/packages/75/c7/96c1cc780e6ca7f01a57c13235dd05b7bc1c0f3588512ebe9d1331b5f5ae/tokenizers-0.21.4-cp39-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cc88bb34e23a54cc42713d6d98af5f1bf79c07653d24fe984d2d695ba2c922a2", size = 3193197, upload-time = "2025-07-28T13:22:51.471Z" }, + { url = "https://files.pythonhosted.org/packages/f2/90/273b6c7ec78af547694eddeea9e05de771278bd20476525ab930cecaf7d8/tokenizers-0.21.4-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:51b7eabb104f46c1c50b486520555715457ae833d5aee9ff6ae853d1130506ff", size = 3115426, upload-time = "2025-07-28T15:48:41.439Z" }, + { url = "https://files.pythonhosted.org/packages/91/43/c640d5a07e95f1cf9d2c92501f20a25f179ac53a4f71e1489a3dcfcc67ee/tokenizers-0.21.4-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:714b05b2e1af1288bd1bc56ce496c4cebb64a20d158ee802887757791191e6e2", size = 9089127, upload-time = "2025-07-28T15:48:46.472Z" }, + { url = "https://files.pythonhosted.org/packages/44/a1/dd23edd6271d4dca788e5200a807b49ec3e6987815cd9d0a07ad9c96c7c2/tokenizers-0.21.4-cp39-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:1340ff877ceedfa937544b7d79f5b7becf33a4cfb58f89b3b49927004ef66f78", size = 9055243, upload-time = "2025-07-28T15:48:48.539Z" }, + { url = "https://files.pythonhosted.org/packages/21/2b/b410d6e9021c4b7ddb57248304dc817c4d4970b73b6ee343674914701197/tokenizers-0.21.4-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:3c1f4317576e465ac9ef0d165b247825a2a4078bcd01cba6b54b867bdf9fdd8b", size = 9298237, upload-time = "2025-07-28T15:48:50.443Z" }, + { url = "https://files.pythonhosted.org/packages/b7/0a/42348c995c67e2e6e5c89ffb9cfd68507cbaeb84ff39c49ee6e0a6dd0fd2/tokenizers-0.21.4-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:c212aa4e45ec0bb5274b16b6f31dd3f1c41944025c2358faaa5782c754e84c24", size = 9461980, upload-time = "2025-07-28T15:48:52.325Z" }, + { url = "https://files.pythonhosted.org/packages/3d/d3/dacccd834404cd71b5c334882f3ba40331ad2120e69ded32cf5fda9a7436/tokenizers-0.21.4-cp39-abi3-win32.whl", hash = "sha256:6c42a930bc5f4c47f4ea775c91de47d27910881902b0f20e4990ebe045a415d0", size = 2329871, upload-time = "2025-07-28T15:48:56.841Z" }, + { url = "https://files.pythonhosted.org/packages/41/f2/fd673d979185f5dcbac4be7d09461cbb99751554ffb6718d0013af8604cb/tokenizers-0.21.4-cp39-abi3-win_amd64.whl", hash = "sha256:475d807a5c3eb72c59ad9b5fcdb254f6e17f53dfcbb9903233b0dfa9c943b597", size = 2507568, upload-time = "2025-07-28T15:48:55.456Z" }, +] + +[[package]] +name = "torch" +version = "2.8.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "filelock" }, + { name = "fsspec" }, + { name = "jinja2" }, + { name = "networkx" }, + { name = "nvidia-cublas-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "nvidia-cuda-cupti-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "nvidia-cuda-nvrtc-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "nvidia-cuda-runtime-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "nvidia-cudnn-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "nvidia-cufft-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "nvidia-cufile-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "nvidia-curand-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "nvidia-cusolver-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "nvidia-cusparse-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "nvidia-cusparselt-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "nvidia-nccl-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "nvidia-nvjitlink-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "nvidia-nvtx-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "setuptools" }, + { name = "sympy" }, + { name = "triton", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "typing-extensions" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/49/0c/2fd4df0d83a495bb5e54dca4474c4ec5f9c62db185421563deeb5dabf609/torch-2.8.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:e2fab4153768d433f8ed9279c8133a114a034a61e77a3a104dcdf54388838705", size = 101906089, upload-time = "2025-08-06T14:53:52.631Z" }, + { url = "https://files.pythonhosted.org/packages/99/a8/6acf48d48838fb8fe480597d98a0668c2beb02ee4755cc136de92a0a956f/torch-2.8.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:b2aca0939fb7e4d842561febbd4ffda67a8e958ff725c1c27e244e85e982173c", size = 887913624, upload-time = "2025-08-06T14:56:44.33Z" }, + { url = "https://files.pythonhosted.org/packages/af/8a/5c87f08e3abd825c7dfecef5a0f1d9aa5df5dd0e3fd1fa2f490a8e512402/torch-2.8.0-cp312-cp312-win_amd64.whl", hash = "sha256:2f4ac52f0130275d7517b03a33d2493bab3693c83dcfadf4f81688ea82147d2e", size = 241326087, upload-time = "2025-08-06T14:53:46.503Z" }, + { url = "https://files.pythonhosted.org/packages/be/66/5c9a321b325aaecb92d4d1855421e3a055abd77903b7dab6575ca07796db/torch-2.8.0-cp312-none-macosx_11_0_arm64.whl", hash = "sha256:619c2869db3ada2c0105487ba21b5008defcc472d23f8b80ed91ac4a380283b0", size = 73630478, upload-time = "2025-08-06T14:53:57.144Z" }, + { url = "https://files.pythonhosted.org/packages/10/4e/469ced5a0603245d6a19a556e9053300033f9c5baccf43a3d25ba73e189e/torch-2.8.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:2b2f96814e0345f5a5aed9bf9734efa913678ed19caf6dc2cddb7930672d6128", size = 101936856, upload-time = "2025-08-06T14:54:01.526Z" }, + { url = "https://files.pythonhosted.org/packages/16/82/3948e54c01b2109238357c6f86242e6ecbf0c63a1af46906772902f82057/torch-2.8.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:65616ca8ec6f43245e1f5f296603e33923f4c30f93d65e103d9e50c25b35150b", size = 887922844, upload-time = "2025-08-06T14:55:50.78Z" }, + { url = "https://files.pythonhosted.org/packages/e3/54/941ea0a860f2717d86a811adf0c2cd01b3983bdd460d0803053c4e0b8649/torch-2.8.0-cp313-cp313-win_amd64.whl", hash = "sha256:659df54119ae03e83a800addc125856effda88b016dfc54d9f65215c3975be16", size = 241330968, upload-time = "2025-08-06T14:54:45.293Z" }, + { url = "https://files.pythonhosted.org/packages/de/69/8b7b13bba430f5e21d77708b616f767683629fc4f8037564a177d20f90ed/torch-2.8.0-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:1a62a1ec4b0498930e2543535cf70b1bef8c777713de7ceb84cd79115f553767", size = 73915128, upload-time = "2025-08-06T14:54:34.769Z" }, + { url = "https://files.pythonhosted.org/packages/15/0e/8a800e093b7f7430dbaefa80075aee9158ec22e4c4fc3c1a66e4fb96cb4f/torch-2.8.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:83c13411a26fac3d101fe8035a6b0476ae606deb8688e904e796a3534c197def", size = 102020139, upload-time = "2025-08-06T14:54:39.047Z" }, + { url = "https://files.pythonhosted.org/packages/4a/15/5e488ca0bc6162c86a33b58642bc577c84ded17c7b72d97e49b5833e2d73/torch-2.8.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:8f0a9d617a66509ded240add3754e462430a6c1fc5589f86c17b433dd808f97a", size = 887990692, upload-time = "2025-08-06T14:56:18.286Z" }, + { url = "https://files.pythonhosted.org/packages/b4/a8/6a04e4b54472fc5dba7ca2341ab219e529f3c07b6941059fbf18dccac31f/torch-2.8.0-cp313-cp313t-win_amd64.whl", hash = "sha256:a7242b86f42be98ac674b88a4988643b9bc6145437ec8f048fea23f72feb5eca", size = 241603453, upload-time = "2025-08-06T14:55:22.945Z" }, + { url = "https://files.pythonhosted.org/packages/04/6e/650bb7f28f771af0cb791b02348db8b7f5f64f40f6829ee82aa6ce99aabe/torch-2.8.0-cp313-none-macosx_11_0_arm64.whl", hash = "sha256:7b677e17f5a3e69fdef7eb3b9da72622f8d322692930297e4ccb52fefc6c8211", size = 73632395, upload-time = "2025-08-06T14:55:28.645Z" }, +] + +[[package]] +name = "tornado" +version = "6.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/51/89/c72771c81d25d53fe33e3dca61c233b665b2780f21820ba6fd2c6793c12b/tornado-6.5.1.tar.gz", hash = "sha256:84ceece391e8eb9b2b95578db65e920d2a61070260594819589609ba9bc6308c", size = 509934, upload-time = "2025-05-22T18:15:38.788Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/77/89/f4532dee6843c9e0ebc4e28d4be04c67f54f60813e4bf73d595fe7567452/tornado-6.5.1-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:d50065ba7fd11d3bd41bcad0825227cc9a95154bad83239357094c36708001f7", size = 441948, upload-time = "2025-05-22T18:15:20.862Z" }, + { url = "https://files.pythonhosted.org/packages/15/9a/557406b62cffa395d18772e0cdcf03bed2fff03b374677348eef9f6a3792/tornado-6.5.1-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:9e9ca370f717997cb85606d074b0e5b247282cf5e2e1611568b8821afe0342d6", size = 440112, upload-time = "2025-05-22T18:15:22.591Z" }, + { url = "https://files.pythonhosted.org/packages/55/82/7721b7319013a3cf881f4dffa4f60ceff07b31b394e459984e7a36dc99ec/tornado-6.5.1-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b77e9dfa7ed69754a54c89d82ef746398be82f749df69c4d3abe75c4d1ff4888", size = 443672, upload-time = "2025-05-22T18:15:24.027Z" }, + { url = "https://files.pythonhosted.org/packages/7d/42/d11c4376e7d101171b94e03cef0cbce43e823ed6567ceda571f54cf6e3ce/tornado-6.5.1-cp39-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:253b76040ee3bab8bcf7ba9feb136436a3787208717a1fb9f2c16b744fba7331", size = 443019, upload-time = "2025-05-22T18:15:25.735Z" }, + { url = "https://files.pythonhosted.org/packages/7d/f7/0c48ba992d875521ac761e6e04b0a1750f8150ae42ea26df1852d6a98942/tornado-6.5.1-cp39-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:308473f4cc5a76227157cdf904de33ac268af770b2c5f05ca6c1161d82fdd95e", size = 443252, upload-time = "2025-05-22T18:15:27.499Z" }, + { url = "https://files.pythonhosted.org/packages/89/46/d8d7413d11987e316df4ad42e16023cd62666a3c0dfa1518ffa30b8df06c/tornado-6.5.1-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:caec6314ce8a81cf69bd89909f4b633b9f523834dc1a352021775d45e51d9401", size = 443930, upload-time = "2025-05-22T18:15:29.299Z" }, + { url = "https://files.pythonhosted.org/packages/78/b2/f8049221c96a06df89bed68260e8ca94beca5ea532ffc63b1175ad31f9cc/tornado-6.5.1-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:13ce6e3396c24e2808774741331638ee6c2f50b114b97a55c5b442df65fd9692", size = 443351, upload-time = "2025-05-22T18:15:31.038Z" }, + { url = "https://files.pythonhosted.org/packages/76/ff/6a0079e65b326cc222a54720a748e04a4db246870c4da54ece4577bfa702/tornado-6.5.1-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:5cae6145f4cdf5ab24744526cc0f55a17d76f02c98f4cff9daa08ae9a217448a", size = 443328, upload-time = "2025-05-22T18:15:32.426Z" }, + { url = "https://files.pythonhosted.org/packages/49/18/e3f902a1d21f14035b5bc6246a8c0f51e0eef562ace3a2cea403c1fb7021/tornado-6.5.1-cp39-abi3-win32.whl", hash = "sha256:e0a36e1bc684dca10b1aa75a31df8bdfed656831489bc1e6a6ebed05dc1ec365", size = 444396, upload-time = "2025-05-22T18:15:34.205Z" }, + { url = "https://files.pythonhosted.org/packages/7b/09/6526e32bf1049ee7de3bebba81572673b19a2a8541f795d887e92af1a8bc/tornado-6.5.1-cp39-abi3-win_amd64.whl", hash = "sha256:908e7d64567cecd4c2b458075589a775063453aeb1d2a1853eedb806922f568b", size = 444840, upload-time = "2025-05-22T18:15:36.1Z" }, + { url = "https://files.pythonhosted.org/packages/55/a7/535c44c7bea4578e48281d83c615219f3ab19e6abc67625ef637c73987be/tornado-6.5.1-cp39-abi3-win_arm64.whl", hash = "sha256:02420a0eb7bf617257b9935e2b754d1b63897525d8a289c9d65690d580b4dcf7", size = 443596, upload-time = "2025-05-22T18:15:37.433Z" }, +] + +[[package]] +name = "tqdm" +version = "4.67.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a8/4b/29b4ef32e036bb34e4ab51796dd745cdba7ed47ad142a9f4a1eb8e0c744d/tqdm-4.67.1.tar.gz", hash = "sha256:f8aef9c52c08c13a65f30ea34f4e5aac3fd1a34959879d7e59e63027286627f2", size = 169737, upload-time = "2024-11-24T20:12:22.481Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d0/30/dc54f88dd4a2b5dc8a0279bdd7270e735851848b762aeb1c1184ed1f6b14/tqdm-4.67.1-py3-none-any.whl", hash = "sha256:26445eca388f82e72884e0d580d5464cd801a3ea01e63e5601bdff9ba6a48de2", size = 78540, upload-time = "2024-11-24T20:12:19.698Z" }, +] + +[[package]] +name = "traitlets" +version = "5.14.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/eb/79/72064e6a701c2183016abbbfedaba506d81e30e232a68c9f0d6f6fcd1574/traitlets-5.14.3.tar.gz", hash = "sha256:9ed0579d3502c94b4b3732ac120375cda96f923114522847de4b3bb98b96b6b7", size = 161621, upload-time = "2024-04-19T11:11:49.746Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/00/c0/8f5d070730d7836adc9c9b6408dec68c6ced86b304a9b26a14df072a6e8c/traitlets-5.14.3-py3-none-any.whl", hash = "sha256:b74e89e397b1ed28cc831db7aea759ba6640cb3de13090ca145426688ff1ac4f", size = 85359, upload-time = "2024-04-19T11:11:46.763Z" }, +] + +[[package]] +name = "transformers" +version = "4.55.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "filelock" }, + { name = "huggingface-hub" }, + { name = "numpy" }, + { name = "packaging" }, + { name = "pyyaml" }, + { name = "regex" }, + { name = "requests" }, + { name = "safetensors" }, + { name = "tokenizers" }, + { name = "tqdm" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/27/5d/f7dc746eef83336a6b34197311fe0c1da0d1192f637c726c6a5cf0d83502/transformers-4.55.0.tar.gz", hash = "sha256:15aa138a05d07a15b30d191ea2c45e23061ebf9fcc928a1318e03fe2234f3ae1", size = 9569089, upload-time = "2025-08-05T16:13:48.997Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1c/93/bcb22fb52ed65084c0199270832aa4cdd4b41296d896f3e7ade188bccb68/transformers-4.55.0-py3-none-any.whl", hash = "sha256:29d9b8800e32a4a831bb16efb5f762f6a9742fef9fce5d693ed018d19b106490", size = 11267905, upload-time = "2025-08-05T16:13:34.814Z" }, +] + +[[package]] +name = "triton" +version = "3.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "setuptools" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/d0/66/b1eb52839f563623d185f0927eb3530ee4d5ffe9d377cdaf5346b306689e/triton-3.4.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:31c1d84a5c0ec2c0f8e8a072d7fd150cab84a9c239eaddc6706c081bfae4eb04", size = 155560068, upload-time = "2025-07-30T19:58:37.081Z" }, + { url = "https://files.pythonhosted.org/packages/30/7b/0a685684ed5322d2af0bddefed7906674f67974aa88b0fae6e82e3b766f6/triton-3.4.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00be2964616f4c619193cb0d1b29a99bd4b001d7dc333816073f92cf2a8ccdeb", size = 155569223, upload-time = "2025-07-30T19:58:44.017Z" }, + { url = "https://files.pythonhosted.org/packages/20/63/8cb444ad5cdb25d999b7d647abac25af0ee37d292afc009940c05b82dda0/triton-3.4.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7936b18a3499ed62059414d7df563e6c163c5e16c3773678a3ee3d417865035d", size = 155659780, upload-time = "2025-07-30T19:58:51.171Z" }, +] + +[[package]] +name = "types-python-dateutil" +version = "2.9.0.20250708" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c9/95/6bdde7607da2e1e99ec1c1672a759d42f26644bbacf939916e086db34870/types_python_dateutil-2.9.0.20250708.tar.gz", hash = "sha256:ccdbd75dab2d6c9696c350579f34cffe2c281e4c5f27a585b2a2438dd1d5c8ab", size = 15834, upload-time = "2025-07-08T03:14:03.382Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/72/52/43e70a8e57fefb172c22a21000b03ebcc15e47e97f5cb8495b9c2832efb4/types_python_dateutil-2.9.0.20250708-py3-none-any.whl", hash = "sha256:4d6d0cc1cc4d24a2dc3816024e502564094497b713f7befda4d5bc7a8e3fd21f", size = 17724, upload-time = "2025-07-08T03:14:02.593Z" }, +] + +[[package]] +name = "typing-extensions" +version = "4.14.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/98/5a/da40306b885cc8c09109dc2e1abd358d5684b1425678151cdaed4731c822/typing_extensions-4.14.1.tar.gz", hash = "sha256:38b39f4aeeab64884ce9f74c94263ef78f3c22467c8724005483154c26648d36", size = 107673, upload-time = "2025-07-04T13:28:34.16Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b5/00/d631e67a838026495268c2f6884f3711a15a9a2a96cd244fdaea53b823fb/typing_extensions-4.14.1-py3-none-any.whl", hash = "sha256:d1e1e3b58374dc93031d6eda2420a48ea44a36c2b4766a4fdeb3710755731d76", size = 43906, upload-time = "2025-07-04T13:28:32.743Z" }, +] + +[[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 = "uri-template" +version = "1.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/31/c7/0336f2bd0bcbada6ccef7aaa25e443c118a704f828a0620c6fa0207c1b64/uri-template-1.3.0.tar.gz", hash = "sha256:0e00f8eb65e18c7de20d595a14336e9f337ead580c70934141624b6d1ffdacc7", size = 21678, upload-time = "2023-06-21T01:49:05.374Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/00/3fca040d7cf8a32776d3d81a00c8ee7457e00f80c649f1e4a863c8321ae9/uri_template-1.3.0-py3-none-any.whl", hash = "sha256:a44a133ea12d44a0c0f06d7d42a52d71282e77e2f937d8abd5655b8d56fc1363", size = 11140, upload-time = "2023-06-21T01:49:03.467Z" }, +] + +[[package]] +name = "urllib3" +version = "2.5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/15/22/9ee70a2574a4f4599c47dd506532914ce044817c7752a79b6a51286319bc/urllib3-2.5.0.tar.gz", hash = "sha256:3fc47733c7e419d4bc3f6b3dc2b4f890bb743906a30d56ba4a5bfa4bbff92760", size = 393185, upload-time = "2025-06-18T14:07:41.644Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a7/c2/fe1e52489ae3122415c51f387e221dd0773709bad6c6cdaa599e8a2c5185/urllib3-2.5.0-py3-none-any.whl", hash = "sha256:e6b01673c0fa6a13e374b50871808eb3bf7046c4b125b216f6bf1cc604cff0dc", size = 129795, upload-time = "2025-06-18T14:07:40.39Z" }, +] + +[[package]] +name = "wcwidth" +version = "0.2.13" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6c/63/53559446a878410fc5a5974feb13d31d78d752eb18aeba59c7fef1af7598/wcwidth-0.2.13.tar.gz", hash = "sha256:72ea0c06399eb286d978fdedb6923a9eb47e1c486ce63e9b4e64fc18303972b5", size = 101301, upload-time = "2024-01-06T02:10:57.829Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fd/84/fd2ba7aafacbad3c4201d395674fc6348826569da3c0937e75505ead3528/wcwidth-0.2.13-py2.py3-none-any.whl", hash = "sha256:3da69048e4540d84af32131829ff948f1e022c1c6bdb8d6102117aac784f6859", size = 34166, upload-time = "2024-01-06T02:10:55.763Z" }, +] + +[[package]] +name = "webcolors" +version = "24.11.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7b/29/061ec845fb58521848f3739e466efd8250b4b7b98c1b6c5bf4d40b419b7e/webcolors-24.11.1.tar.gz", hash = "sha256:ecb3d768f32202af770477b8b65f318fa4f566c22948673a977b00d589dd80f6", size = 45064, upload-time = "2024-11-11T07:43:24.224Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/60/e8/c0e05e4684d13459f93d312077a9a2efbe04d59c393bc2b8802248c908d4/webcolors-24.11.1-py3-none-any.whl", hash = "sha256:515291393b4cdf0eb19c155749a096f779f7d909f7cceea072791cb9095b92e9", size = 14934, upload-time = "2024-11-11T07:43:22.529Z" }, +] + +[[package]] +name = "webencodings" +version = "0.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0b/02/ae6ceac1baeda530866a85075641cec12989bd8d31af6d5ab4a3e8c92f47/webencodings-0.5.1.tar.gz", hash = "sha256:b36a1c245f2d304965eb4e0a82848379241dc04b865afcc4aab16748587e1923", size = 9721, upload-time = "2017-04-05T20:21:34.189Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f4/24/2a3e3df732393fed8b3ebf2ec078f05546de641fe1b667ee316ec1dcf3b7/webencodings-0.5.1-py2.py3-none-any.whl", hash = "sha256:a0af1213f3c2226497a97e2b3aa01a7e4bee4f403f95be16fc9acd2947514a78", size = 11774, upload-time = "2017-04-05T20:21:32.581Z" }, +] + +[[package]] +name = "websocket-client" +version = "1.8.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e6/30/fba0d96b4b5fbf5948ed3f4681f7da2f9f64512e1d303f94b4cc174c24a5/websocket_client-1.8.0.tar.gz", hash = "sha256:3239df9f44da632f96012472805d40a23281a991027ce11d2f45a6f24ac4c3da", size = 54648, upload-time = "2024-04-23T22:16:16.976Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5a/84/44687a29792a70e111c5c477230a72c4b957d88d16141199bf9acb7537a3/websocket_client-1.8.0-py3-none-any.whl", hash = "sha256:17b44cc997f5c498e809b22cdf2d9c7a9e71c02c8cc2b6c56e7c2d1239bfa526", size = 58826, upload-time = "2024-04-23T22:16:14.422Z" }, +] + +[[package]] +name = "widgetsnbextension" +version = "4.0.14" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/41/53/2e0253c5efd69c9656b1843892052a31c36d37ad42812b5da45c62191f7e/widgetsnbextension-4.0.14.tar.gz", hash = "sha256:a3629b04e3edb893212df862038c7232f62973373869db5084aed739b437b5af", size = 1097428, upload-time = "2025-04-10T13:01:25.628Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ca/51/5447876806d1088a0f8f71e16542bf350918128d0a69437df26047c8e46f/widgetsnbextension-4.0.14-py3-none-any.whl", hash = "sha256:4875a9eaf72fbf5079dc372a51a9f268fc38d46f767cbf85c43a36da5cb9b575", size = 2196503, upload-time = "2025-04-10T13:01:23.086Z" }, +] + +[[package]] +name = "xlsxwriter" +version = "3.2.5" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a7/47/7704bac42ac6fe1710ae099b70e6a1e68ed173ef14792b647808c357da43/xlsxwriter-3.2.5.tar.gz", hash = "sha256:7e88469d607cdc920151c0ab3ce9cf1a83992d4b7bc730c5ffdd1a12115a7dbe", size = 213306, upload-time = "2025-06-17T08:59:14.619Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fa/34/a22e6664211f0c8879521328000bdcae9bf6dbafa94a923e531f6d5b3f73/xlsxwriter-3.2.5-py3-none-any.whl", hash = "sha256:4f4824234e1eaf9d95df9a8fe974585ff91d0f5e3d3f12ace5b71e443c1c6abd", size = 172347, upload-time = "2025-06-17T08:59:13.453Z" }, +]