From 75b36e0503816cd61311a6b0fd0623927da3d016 Mon Sep 17 00:00:00 2001 From: jjmachan Date: Wed, 15 Oct 2025 08:42:35 -0700 Subject: [PATCH 1/7] added a new plan directory to save plans --- .gitignore | 1 + CLAUDE.md | 1 + 2 files changed, 2 insertions(+) diff --git a/.gitignore b/.gitignore index bf49b53bf..f817be47d 100644 --- a/.gitignore +++ b/.gitignore @@ -202,3 +202,4 @@ text2sql_logs # MLflow artifacts mlartifacts mlflow.db +plan diff --git a/CLAUDE.md b/CLAUDE.md index 41f0f2c50..8d913a88f 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -218,3 +218,4 @@ analytics_logger.addHandler(console_handler) - **Minimal setup**: `[project.optional-dependencies].dev-minimal` for fast development (79 packages) - **Full setup**: `[dependency-groups].dev` for comprehensive development (383 packages) - Use `make install-minimal` for most development tasks, `make install` for full ML stack work +- if the user asks you to save a plan, save it into the plan/ directory with an appropriate file name. From bc3b19f527315cfdbd040caeb71172fb326fa1c5 Mon Sep 17 00:00:00 2001 From: jjmachan Date: Wed, 15 Oct 2025 12:20:59 -0700 Subject: [PATCH 2/7] refactor the tests --- .../metrics_migration/base_migration_test.py | 197 +++++++ tests/e2e/metrics_migration/conftest.py | 69 +++ .../test_context_recall_migration.py | 158 ++++++ tests/e2e/metrics_migration/test_utils.py | 146 +++++ tests/notebooks/metric_score_diff.ipynb | 537 ++++++++++++++++-- tests/utils/__init__.py | 21 + tests/utils/llm_setup.py | 229 ++++++++ 7 files changed, 1301 insertions(+), 56 deletions(-) create mode 100644 tests/e2e/metrics_migration/base_migration_test.py create mode 100644 tests/e2e/metrics_migration/conftest.py create mode 100644 tests/e2e/metrics_migration/test_context_recall_migration.py create mode 100644 tests/e2e/metrics_migration/test_utils.py create mode 100644 tests/utils/__init__.py create mode 100644 tests/utils/llm_setup.py diff --git a/tests/e2e/metrics_migration/base_migration_test.py b/tests/e2e/metrics_migration/base_migration_test.py new file mode 100644 index 000000000..d8f1fcb4d --- /dev/null +++ b/tests/e2e/metrics_migration/base_migration_test.py @@ -0,0 +1,197 @@ +"""Base test class for metrics migration E2E tests.""" + +from typing import Any, Callable, Dict, List, Optional + +import pytest + +from .test_utils import ( + assert_score_types, + compare_scores_with_tolerance, + create_legacy_sample, + print_score_comparison, + print_test_header, + print_test_success, +) + + +class BaseMigrationTest: + """Base class for metrics migration E2E tests. + + Provides common functionality for testing compatibility between legacy and v2 implementations. + Subclasses should implement metric-specific test data and configurations. + """ + + @pytest.mark.asyncio + async def run_e2e_compatibility_test( + self, + sample_data: List[Dict[str, Any]], + legacy_metric_factory: Callable, + v2_metric_factory: Callable, + v2_score_method_name: str = "ascore", + legacy_components: Optional[Dict[str, Any]] = None, + v2_components: Optional[Dict[str, Any]] = None, + tolerance: float = 0.3, + metric_name: str = "Metric", + additional_info_keys: Optional[List[str]] = None, + ) -> None: + """Run E2E compatibility test between legacy and v2 implementations. + + Args: + sample_data: List of test cases, each as a dictionary + legacy_metric_factory: Function to create legacy metric instance + v2_metric_factory: Function to create v2 metric instance + v2_score_method_name: Name of the scoring method on v2 metric + legacy_components: Components for legacy metric (llm, embeddings, etc.) + v2_components: Components for v2 metric (llm, embeddings, etc.) + tolerance: Maximum allowed score difference + metric_name: Name of the metric for display + additional_info_keys: Keys from data dict to display in test output + """ + # Check if required components are available + if legacy_components: + if any(component is None for component in legacy_components.values()): + pytest.skip("Required components not available for E2E testing") + + if v2_components: + if any(component is None for component in v2_components.values()): + pytest.skip("Required components not available for E2E testing") + + # Create metric instances + legacy_metric = ( + legacy_metric_factory(**legacy_components) + if legacy_components + else legacy_metric_factory() + ) + v2_metric = ( + v2_metric_factory(**v2_components) if v2_components else v2_metric_factory() + ) + + # Run tests for each sample + for i, data in enumerate(sample_data): + description = data.get("description", "No description") + + # Prepare additional info for display + additional_info = {} + if additional_info_keys: + for key in additional_info_keys: + if key in data: + additional_info[key.replace("_", " ").title()] = str(data[key]) + + print_test_header(metric_name, i + 1, description, additional_info) + + # Score with legacy implementation + legacy_sample = create_legacy_sample(data) + legacy_score = await legacy_metric._single_turn_ascore(legacy_sample, None) + + # Score with v2 implementation + # Extract parameters for v2 scoring (exclude metadata keys) + v2_params = {k: v for k, v in data.items() if k != "description"} + v2_score_method = getattr(v2_metric, v2_score_method_name) + v2_result = await v2_score_method(**v2_params) + + # Compare scores + print_score_comparison(legacy_score, v2_result.value) + + # Assert scores are within tolerance + compare_scores_with_tolerance( + legacy_score, + v2_result.value, + tolerance, + description, + i + 1, + ) + + # Assert types and ranges + assert_score_types(legacy_score, v2_result) + + print_test_success() + + @pytest.mark.asyncio + async def run_metric_specific_test( + self, + test_cases: List[Dict[str, Any]], + legacy_metric_factory: Callable, + v2_metric_factory: Callable, + legacy_components: Optional[Dict[str, Any]] = None, + v2_components: Optional[Dict[str, Any]] = None, + test_name: str = "Metric Specific Test", + assertion_fn: Optional[Callable] = None, + ) -> None: + """Run a metric-specific test with custom assertions. + + Args: + test_cases: List of test cases + legacy_metric_factory: Function to create legacy metric instance + v2_metric_factory: Function to create v2 metric instance + legacy_components: Components for legacy metric + v2_components: Components for v2 metric + test_name: Name of the test for display + assertion_fn: Optional custom assertion function that takes (case, legacy_score, v2_result) + """ + # Check if required components are available + if legacy_components: + if any(component is None for component in legacy_components.values()): + pytest.skip("Required components not available for testing") + + if v2_components: + if any(component is None for component in v2_components.values()): + pytest.skip("Required components not available for testing") + + # Create metric instances + legacy_metric = ( + legacy_metric_factory(**legacy_components) + if legacy_components + else legacy_metric_factory() + ) + v2_metric = ( + v2_metric_factory(**v2_components) if v2_components else v2_metric_factory() + ) + + # Run tests for each case + for case in test_cases: + description = case.get("description", "No description") + print(f"\n๐ŸŽฏ Testing {test_name}: {description}") + + # Score with legacy implementation + legacy_sample = create_legacy_sample(case) + legacy_score = await legacy_metric._single_turn_ascore(legacy_sample, None) + + # Score with v2 implementation + v2_params = { + k: v + for k, v in case.items() + if k not in ["description", "expected_high", "expected_low"] + } + v2_result = await v2_metric.ascore(**v2_params) + + # Print scores + print_score_comparison(legacy_score, v2_result.value) + + # Run custom assertions if provided + if assertion_fn: + assertion_fn(case, legacy_score, v2_result) + else: + # Default: just verify types + assert_score_types(legacy_score, v2_result) + + def create_requirements_documentation( + self, + metric_name: str, + requirements: Dict[str, str], + test_file_name: str, + ) -> None: + """Print documentation about E2E test requirements. + + Args: + metric_name: Name of the metric + requirements: Dictionary of requirements + test_file_name: Name of the test file + """ + print(f"\n๐Ÿ“‹ {metric_name} E2E Test Requirements:") + for key, value in requirements.items(): + print(f" {key.capitalize()}: {value}") + + print("\n๐Ÿš€ To enable full E2E testing:") + print(" 1. Configure required providers (e.g., export OPENAI_API_KEY=...)") + print(" 2. Remove @pytest.mark.skip decorators") + print(f" 3. Run: pytest tests/e2e/metrics_migration/{test_file_name} -v -s") diff --git a/tests/e2e/metrics_migration/conftest.py b/tests/e2e/metrics_migration/conftest.py new file mode 100644 index 000000000..22dd7ead1 --- /dev/null +++ b/tests/e2e/metrics_migration/conftest.py @@ -0,0 +1,69 @@ +"""Common fixtures for metrics migration E2E tests. + +This module provides pytest fixtures that wrap the shared utility functions +from tests.utils.llm_setup for use in E2E migration tests. +""" + +import pytest + +from tests.utils import ( + create_legacy_embeddings, + create_legacy_llm, + create_modern_embeddings, + create_modern_llm, +) + + +@pytest.fixture +def legacy_llm(): + """Create a test LLM for legacy metric evaluation. + + Uses legacy llm_factory for legacy implementation. + Skips if LLM factory is not available or API key is missing. + """ + try: + return create_legacy_llm("gpt-3.5-turbo") + except Exception as e: + pytest.skip(str(e)) + + +@pytest.fixture +def modern_llm(): + """Create a modern instructor LLM for v2 implementation. + + Uses instructor_llm_factory with OpenAI client. + Skips if instructor LLM factory is not available or API key is missing. + """ + try: + return create_modern_llm("openai", model="gpt-3.5-turbo") + except Exception as e: + pytest.skip(str(e)) + + +@pytest.fixture +def legacy_embeddings(): + """Create legacy embeddings for legacy implementation. + + Uses legacy embedding_factory interface. + Skips if embedding factory is not available or API key is missing. + """ + try: + return create_legacy_embeddings("text-embedding-ada-002") + except Exception as e: + pytest.skip(str(e)) + + +@pytest.fixture +def modern_embeddings(): + """Create modern embeddings for v2 implementation. + + Uses modern interface with explicit provider and client. + Skips if OpenAI or embedding factory is not available or API key is missing. + """ + try: + return create_modern_embeddings( + provider="openai", + model="text-embedding-ada-002", + ) + except Exception as e: + pytest.skip(str(e)) diff --git a/tests/e2e/metrics_migration/test_context_recall_migration.py b/tests/e2e/metrics_migration/test_context_recall_migration.py new file mode 100644 index 000000000..7d1141dcb --- /dev/null +++ b/tests/e2e/metrics_migration/test_context_recall_migration.py @@ -0,0 +1,158 @@ +"""E2E tests for Context Recall metric migration from v1 (class-based) to v2 (class-based with automatic validation).""" + +import pytest + +from ragas.metrics import LLMContextRecall as LegacyContextRecall +from ragas.metrics.collections import ContextRecall + +from .base_migration_test import BaseMigrationTest + + +class TestContextRecallE2EMigration(BaseMigrationTest): + """E2E test compatibility between legacy ContextRecall class and new V2 ContextRecall class with automatic validation.""" + + @pytest.fixture + def sample_data(self): + """Real-world test cases for context recall evaluation.""" + return [ + { + "user_input": "What is the capital of France?", + "retrieved_contexts": [ + "Paris is the capital and largest city of France.", + "France is a country in Western Europe.", + ], + "reference": "Paris is the capital of France. It is located in northern France.", + "description": "Full attribution - all statements should be found in context", + }, + { + "user_input": "Tell me about Albert Einstein", + "retrieved_contexts": [ + "Albert Einstein was born in 1879. He developed the theory of relativity." + ], + "reference": "Einstein was born in 1879. He won the Nobel Prize in 1921. He developed relativity theory.", + "description": "Partial attribution - Nobel Prize not mentioned in context", + }, + { + "user_input": "What are the main causes of climate change?", + "retrieved_contexts": [ + "Climate change is primarily caused by greenhouse gas emissions from burning fossil fuels.", + "Deforestation also contributes to climate change by reducing CO2 absorption.", + ], + "reference": "The main causes include fossil fuel emissions and deforestation.", + "description": "Multiple contexts - all statements attributed", + }, + { + "user_input": "How does photosynthesis work?", + "retrieved_contexts": [ + "Photosynthesis is a process where plants use sunlight to produce glucose." + ], + "reference": "Plants convert sunlight into glucose through photosynthesis. This process also produces oxygen and occurs in chloroplasts.", + "description": "Partial attribution - oxygen and chloroplasts not in context", + }, + { + "user_input": "What is quantum computing?", + "retrieved_contexts": [ + "Quantum computers use quantum bits or qubits instead of classical bits." + ], + "reference": "Quantum computing uses qubits.", + "description": "Simple case - direct attribution", + }, + ] + + @pytest.mark.asyncio + async def test_legacy_context_recall_vs_v2_context_recall_e2e_compatibility( + self, + sample_data, + legacy_llm, + modern_llm, + ): + """E2E test that legacy and v2 implementations produce similar scores with real LLM.""" + await self.run_e2e_compatibility_test( + sample_data=sample_data, + legacy_metric_factory=LegacyContextRecall, + v2_metric_factory=ContextRecall, + legacy_components={"llm": legacy_llm}, + v2_components={"llm": modern_llm}, + tolerance=0.3, + metric_name="Context Recall", + additional_info_keys=["user_input", "reference"], + ) + + @pytest.mark.asyncio + async def test_context_recall_attribution_detection(self, legacy_llm, modern_llm): + """Test that both implementations correctly detect statement attributions.""" + + if legacy_llm is None or modern_llm is None: + pytest.skip("LLM required for E2E testing") + + # Test cases specifically for attribution detection + test_cases = [ + { + "user_input": "What is the capital of France?", + "retrieved_contexts": ["Paris is the capital of France."], + "reference": "Paris is the capital of France.", + "expected_high": True, + "description": "Perfect attribution - should get high score", + }, + { + "user_input": "What is the capital of France?", + "retrieved_contexts": ["France is a European country."], + "reference": "Paris is the capital of France.", + "expected_high": False, + "description": "No attribution - should get low score", + }, + { + "user_input": "Tell me about Einstein", + "retrieved_contexts": ["Einstein was born in 1879."], + "reference": "Einstein was born in 1879. He won the Nobel Prize.", + "expected_high": False, + "description": "Partial attribution - should get medium score (50%)", + }, + ] + + # Define custom assertion function + def assertion_fn(case, legacy_score, v2_result): + print(f" Reference: {case['reference']}") + + if case.get("expected_high"): + # High attribution should get high scores (> 0.8) + assert legacy_score > 0.8, ( + f"Legacy should detect high attribution: {legacy_score}" + ) + assert v2_result.value > 0.8, ( + f"V2 class should detect high attribution: {v2_result.value}" + ) + print(" โœ… All detected high attribution") + else: + # Low/partial attribution should get lower scores + # Note: We don't enforce strict thresholds here as it depends on the specific case + print( + f" โœ… Scores reflect attribution level (Legacy: {legacy_score:.2f}, V2: {v2_result.value:.2f})" + ) + + await self.run_metric_specific_test( + test_cases=test_cases, + legacy_metric_factory=LegacyContextRecall, + v2_metric_factory=ContextRecall, + legacy_components={"llm": legacy_llm}, + v2_components={"llm": modern_llm}, + test_name="attribution detection", + assertion_fn=assertion_fn, + ) + + def test_context_recall_migration_requirements_documented(self): + """Document the requirements for running full E2E context recall tests.""" + + requirements = { + "llm": "OpenAI GPT, Anthropic Claude, or other LangChain-compatible LLM", + "environment": "API keys configured for LLM providers", + "purpose": "Verify that v2 class-based implementation with automatic validation produces similar results to legacy class-based implementation", + } + + self.create_requirements_documentation( + metric_name="Context Recall", + requirements=requirements, + test_file_name="test_context_recall_migration.py", + ) + + assert True diff --git a/tests/e2e/metrics_migration/test_utils.py b/tests/e2e/metrics_migration/test_utils.py new file mode 100644 index 000000000..edd26bc3d --- /dev/null +++ b/tests/e2e/metrics_migration/test_utils.py @@ -0,0 +1,146 @@ +"""Utility functions for metrics migration E2E tests.""" + +from typing import Any, Dict, Optional + +from ragas.dataset_schema import SingleTurnSample +from ragas.metrics import MetricResult + + +def create_legacy_sample( + data: Dict[str, Any], + user_input_key: str = "user_input", + response_key: str = "response", + reference_key: Optional[str] = "reference", + retrieved_contexts_key: Optional[str] = "retrieved_contexts", +) -> SingleTurnSample: + """Create a SingleTurnSample from a data dictionary for legacy metrics. + + Args: + data: Dictionary containing sample data + user_input_key: Key for user input in data dict + response_key: Key for response in data dict + reference_key: Key for reference in data dict (optional) + retrieved_contexts_key: Key for retrieved contexts in data dict (optional) + + Returns: + SingleTurnSample instance + """ + kwargs = { + "user_input": data.get(user_input_key, "dummy"), + } + + if response_key and response_key in data: + kwargs["response"] = data[response_key] + + if reference_key and reference_key in data: + kwargs["reference"] = data[reference_key] + + if retrieved_contexts_key and retrieved_contexts_key in data: + kwargs["retrieved_contexts"] = data[retrieved_contexts_key] + + return SingleTurnSample(**kwargs) + + +def compare_scores_with_tolerance( + legacy_score: float, + v2_score: float, + tolerance: float, + case_description: str, + case_num: int, +) -> None: + """Compare scores and assert they are within tolerance. + + Args: + legacy_score: Score from legacy implementation + v2_score: Score from v2 implementation + tolerance: Maximum allowed difference + case_description: Description of the test case + case_num: Test case number + + Raises: + AssertionError: If scores differ by more than tolerance + """ + score_diff = abs(legacy_score - v2_score) + assert score_diff < tolerance, ( + f"Case {case_num} ({case_description}): " + f"Large difference: {legacy_score} vs {v2_score} (diff: {score_diff})" + ) + + +def assert_score_types(legacy_score: Any, v2_result: MetricResult) -> None: + """Assert that scores have correct types and values are in valid range. + + Args: + legacy_score: Score from legacy implementation + v2_result: MetricResult from v2 implementation + + Raises: + AssertionError: If types or ranges are invalid + """ + assert isinstance(legacy_score, float), ( + f"Legacy score should be float, got {type(legacy_score)}" + ) + assert isinstance(v2_result, MetricResult), ( + f"V2 result should be MetricResult, got {type(v2_result)}" + ) + assert 0.0 <= legacy_score <= 1.0, f"Legacy score out of range: {legacy_score}" + assert 0.0 <= v2_result.value <= 1.0, f"V2 score out of range: {v2_result.value}" + + +def print_test_header( + metric_name: str, + case_num: int, + description: str, + additional_info: Optional[Dict[str, str]] = None, +) -> None: + """Print a standardized test case header. + + Args: + metric_name: Name of the metric being tested + case_num: Test case number + description: Description of the test case + additional_info: Optional dictionary of additional info to print + """ + print(f"\n๐Ÿงช Testing {metric_name} - Case {case_num}: {description}") + if additional_info: + for key, value in additional_info.items(): + # Truncate long values + display_value = value[:100] + "..." if len(value) > 100 else value + print(f" {key}: {display_value}") + + +def print_score_comparison( + legacy_score: float, + v2_score: float, + precision: int = 6, +) -> None: + """Print a standardized score comparison. + + Args: + legacy_score: Score from legacy implementation + v2_score: Score from v2 implementation + precision: Number of decimal places to display + """ + score_diff = abs(legacy_score - v2_score) + print(f" Legacy: {legacy_score:.{precision}f}") + print(f" V2 Class: {v2_score:.{precision}f}") + print(f" Diff: {score_diff:.{precision}f}") + + +def print_test_success(message: str = "Scores within tolerance!") -> None: + """Print a standardized success message. + + Args: + message: Success message to display + """ + print(f" โœ… {message}") + + +def print_metric_specific_info(metric_name: str, description: str) -> None: + """Print metric-specific test information. + + Args: + metric_name: Name of the metric + description: Description of what's being tested + """ + print(f"\n๐ŸŽฏ Testing {metric_name}: {description}") diff --git a/tests/notebooks/metric_score_diff.ipynb b/tests/notebooks/metric_score_diff.ipynb index cca6ced1c..18db8402a 100644 --- a/tests/notebooks/metric_score_diff.ipynb +++ b/tests/notebooks/metric_score_diff.ipynb @@ -14,10 +14,11 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ + "import asyncio\n", "import time\n", "from dataclasses import dataclass\n", "from typing import Any, Dict, List, Tuple\n", @@ -40,21 +41,34 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "โœ“ OpenAI API key found\n" + ] + } + ], "source": [ "import os\n", + "import sys\n", + "from pathlib import Path\n", "\n", - "# Check for OpenAI API key\n", - "if not os.getenv(\"OPENAI_API_KEY\"):\n", - " raise ValueError(\n", - " \"OPENAI_API_KEY environment variable not set. \"\n", - " \"Please set it before running this notebook:\\n\"\n", - " \" export OPENAI_API_KEY='your-api-key-here'\"\n", - " )\n", + "# Add tests directory to path so we can import from tests.utils\n", + "tests_dir = Path.cwd().parent.parent\n", + "sys.path.insert(0, str(tests_dir))\n", "\n", - "print(\"โœ“ OpenAI API key found\")" + "from tests.utils import check_api_key\n", + "\n", + "# Check for OpenAI API key\n", + "try:\n", + " check_api_key(\"openai\")\n", + " print(\"โœ“ OpenAI API key found\")\n", + "except ValueError as e:\n", + " raise ValueError(str(e))" ] }, { @@ -66,7 +80,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ @@ -123,28 +137,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "metadata": {}, "outputs": [], "source": [ "async def run_metric_on_dataset(\n", - " metric: Any, dataset: List[Dict[str, Any]], metric_type: str = \"old\"\n", + " metric: Any,\n", + " dataset: List[Dict[str, Any]],\n", + " metric_type: str = \"old\",\n", + " max_concurrent: int = 10,\n", ") -> Tuple[List[float], float]:\n", " \"\"\"\n", - " Run a metric on a dataset and return scores with execution time.\n", + " Run a metric on a dataset with concurrent processing for better performance.\n", "\n", " Args:\n", " metric: The metric instance (either old or new style)\n", " dataset: List of dictionaries containing the data samples\n", " metric_type: \"old\" for legacy metrics, \"new\" for collections metrics\n", + " max_concurrent: Maximum number of concurrent requests (default: 10)\n", "\n", " Returns:\n", " Tuple of (scores list, execution time in seconds)\n", " \"\"\"\n", - " scores = []\n", - " start_time = time.time()\n", "\n", - " for sample_dict in dataset:\n", + " async def score_single_sample(sample_dict: Dict[str, Any]) -> float:\n", + " \"\"\"Score a single sample.\"\"\"\n", " try:\n", " if metric_type == \"old\":\n", " # Old metrics use SingleTurnSample\n", @@ -155,18 +172,31 @@ " result = await metric.ascore(**sample_dict)\n", " score = result.value\n", "\n", - " scores.append(float(score))\n", + " return float(score)\n", " except Exception as e:\n", " print(f\"Error processing sample: {e}\")\n", - " scores.append(np.nan)\n", + " return np.nan\n", + "\n", + " start_time = time.time()\n", + "\n", + " # Use semaphore to limit concurrent requests (prevents API rate limiting)\n", + " semaphore = asyncio.Semaphore(max_concurrent)\n", + "\n", + " async def score_with_limit(sample_dict: Dict[str, Any]) -> float:\n", + " \"\"\"Score with concurrency control.\"\"\"\n", + " async with semaphore:\n", + " return await score_single_sample(sample_dict)\n", + "\n", + " # Process all samples concurrently\n", + " scores = await asyncio.gather(*[score_with_limit(s) for s in dataset])\n", "\n", " execution_time = time.time() - start_time\n", - " return scores, execution_time" + " return list(scores), execution_time" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 23, "metadata": {}, "outputs": [], "source": [ @@ -176,9 +206,11 @@ " dataset: List[Dict[str, Any]],\n", " old_metric_type: str = \"old\",\n", " new_metric_type: str = \"new\",\n", + " max_concurrent: int = 10,\n", + " parallel_metrics: bool = True,\n", ") -> MetricDiffResult:\n", " \"\"\"\n", - " Compare two metrics on the same dataset.\n", + " Compare two metrics on the same dataset with optional parallel execution.\n", "\n", " Args:\n", " old_metric: The baseline/old metric instance\n", @@ -186,19 +218,32 @@ " dataset: List of dictionaries containing the data samples\n", " old_metric_type: Type identifier for old metric (\"old\" or \"new\")\n", " new_metric_type: Type identifier for new metric (\"old\" or \"new\")\n", + " max_concurrent: Maximum number of concurrent requests per metric (default: 10)\n", + " parallel_metrics: If True, run both metrics in parallel. If False, run sequentially\n", + " for more accurate individual timing (default: True)\n", "\n", " Returns:\n", " MetricDiffResult containing comparison statistics\n", " \"\"\"\n", - " print(f\"Running old metric on {len(dataset)} samples...\")\n", - " old_scores, old_time = await run_metric_on_dataset(\n", - " old_metric, dataset, old_metric_type\n", - " )\n", + " if parallel_metrics:\n", + " print(f\"Running both metrics in parallel on {len(dataset)} samples (max {max_concurrent} concurrent)...\")\n", + " \n", + " # Run both metrics concurrently using asyncio.gather\n", + " (old_scores, old_time), (new_scores, new_time) = await asyncio.gather(\n", + " run_metric_on_dataset(old_metric, dataset, old_metric_type, max_concurrent),\n", + " run_metric_on_dataset(new_metric, dataset, new_metric_type, max_concurrent),\n", + " )\n", + " else:\n", + " # Sequential execution for more accurate individual timing\n", + " print(f\"Running old metric on {len(dataset)} samples (max {max_concurrent} concurrent)...\")\n", + " old_scores, old_time = await run_metric_on_dataset(\n", + " old_metric, dataset, old_metric_type, max_concurrent\n", + " )\n", "\n", - " print(f\"Running new metric on {len(dataset)} samples...\")\n", - " new_scores, new_time = await run_metric_on_dataset(\n", - " new_metric, dataset, new_metric_type\n", - " )\n", + " print(f\"Running new metric on {len(dataset)} samples (max {max_concurrent} concurrent)...\")\n", + " new_scores, new_time = await run_metric_on_dataset(\n", + " new_metric, dataset, new_metric_type, max_concurrent\n", + " )\n", "\n", " # Calculate differences\n", " diffs = [new - old for old, new in zip(old_scores, new_scores)]\n", @@ -218,6 +263,70 @@ " )" ] }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "async def run_metric_on_dataset_with_batching(\n", + " metric: Any,\n", + " dataset: List[Dict[str, Any]],\n", + " metric_type: str = \"new\",\n", + " batch_size: int = 5,\n", + ") -> Tuple[List[float], float]:\n", + " \"\"\"\n", + " Run metric using batch processing if available (for better performance).\n", + " \n", + " This function attempts to use the metric's abatch_score method if available,\n", + " which can be more efficient than individual scoring. Falls back to concurrent\n", + " processing if batching is not supported.\n", + "\n", + " Args:\n", + " metric: The metric instance\n", + " dataset: List of dictionaries containing the data samples\n", + " metric_type: \"old\" or \"new\" - old metrics don't support batching\n", + " batch_size: Number of samples per batch (default: 5)\n", + "\n", + " Returns:\n", + " Tuple of (scores list, execution time in seconds)\n", + " \"\"\"\n", + " # Check if metric supports batching\n", + " has_batch = hasattr(metric, \"abatch_score\")\n", + "\n", + " if not has_batch or metric_type == \"old\":\n", + " # Fall back to concurrent processing\n", + " print(f\" Batching not available, using concurrent processing...\")\n", + " return await run_metric_on_dataset(metric, dataset, metric_type)\n", + "\n", + " start_time = time.time()\n", + " all_scores = []\n", + "\n", + " # Process in batches\n", + " num_batches = (len(dataset) + batch_size - 1) // batch_size\n", + " print(f\" Processing {len(dataset)} samples in {num_batches} batches of {batch_size}...\")\n", + "\n", + " for i in range(0, len(dataset), batch_size):\n", + " batch = dataset[i : i + batch_size]\n", + " try:\n", + " results = await metric.abatch_score(batch)\n", + " scores = [r.value for r in results]\n", + " all_scores.extend(scores)\n", + " except Exception as e:\n", + " print(f\" Warning: Batch {i//batch_size + 1} failed ({e}), falling back to individual processing...\")\n", + " # Fall back to individual processing for this batch\n", + " for sample in batch:\n", + " try:\n", + " result = await metric.ascore(**sample)\n", + " all_scores.append(result.value)\n", + " except Exception as e2:\n", + " print(f\" Error processing sample: {e2}\")\n", + " all_scores.append(np.nan)\n", + "\n", + " execution_time = time.time() - start_time\n", + " return all_scores, execution_time" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -229,14 +338,32 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "metadata": {}, "outputs": [], - "source": "# Setup LLMs and Embeddings\nfrom langchain_openai import ChatOpenAI, OpenAIEmbeddings\nfrom openai import AsyncOpenAI\n\nfrom ragas.embeddings.base import LangchainEmbeddingsWrapper, embedding_factory\nfrom ragas.llms.base import LangchainLLMWrapper, instructor_llm_factory\n\n# For old metric (legacy) - wrap langchain components\nlangchain_llm = ChatOpenAI(model=\"gpt-4o-mini\")\nlegacy_llm = LangchainLLMWrapper(langchain_llm)\n\nlangchain_embeddings = OpenAIEmbeddings(model=\"text-embedding-ada-002\")\nlegacy_embeddings = LangchainEmbeddingsWrapper(langchain_embeddings)\n\n# For new metric (modern)\nclient = AsyncOpenAI()\nmodern_llm = instructor_llm_factory(\"openai\", client=client, model=\"gpt-4o-mini\")\nmodern_embeddings = embedding_factory(\n \"openai\", model=\"text-embedding-ada-002\", client=client, interface=\"modern\"\n)" + "source": [ + "# Import setup utilities from shared test utilities\n", + "from tests.utils import (\n", + " create_legacy_embeddings,\n", + " create_legacy_llm,\n", + " create_modern_embeddings,\n", + " create_modern_llm,\n", + ")\n", + "\n", + "# For old metric (legacy) - uses legacy factories\n", + "legacy_llm = create_legacy_llm(model=\"gpt-4o-mini\")\n", + "legacy_embeddings = create_legacy_embeddings(model=\"text-embedding-ada-002\")\n", + "\n", + "# For new metric (modern) - uses modern factories with OpenAI client\n", + "modern_llm = create_modern_llm(provider=\"openai\", model=\"gpt-4o-mini\")\n", + "modern_embeddings = create_modern_embeddings(\n", + " provider=\"openai\", model=\"text-embedding-ada-002\"\n", + ")" + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 26, "metadata": {}, "outputs": [], "source": [ @@ -258,16 +385,104 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 27, "metadata": {}, - "outputs": [], - "source": "# Load amnesty dataset\nimport sys\nfrom pathlib import Path\n\nfrom tests.e2e.test_dataset_utils import load_amnesty_dataset_safe\n\n# Add tests directory to path\ntests_dir = Path.cwd().parent if Path.cwd().name == \"notebooks\" else Path.cwd()\nif tests_dir.name == \"tests\":\n sys.path.insert(0, str(tests_dir.parent))\nelse:\n sys.path.insert(0, str(tests_dir))\n\n# Load the dataset (will use HuggingFace or fallback to local samples)\namnesty_dataset = load_amnesty_dataset_safe(\"english_v3\")\n\n# Convert to list of dicts for our utility functions\n# We'll use a subset for faster testing\ntest_dataset = []\nfor i, sample in enumerate(amnesty_dataset):\n if i >= 5: # Limit to 5 samples for faster testing\n break\n test_dataset.append(\n {\"user_input\": sample[\"user_input\"], \"response\": sample[\"response\"]}\n )\n\nprint(f\"Test dataset contains {len(test_dataset)} samples from amnesty_qa\")\nprint(\"\\nFirst sample:\")\nprint(f\"Question: {test_dataset[0]['user_input']}\")\nprint(f\"Response: {test_dataset[0]['response'][:100]}...\")" + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/Users/jjmachan/workspace/eglabs/ragas-workdir/ragas\n" + ] + } + ], + "source": [ + "import sys\n", + "from pathlib import Path\n", + "\n", + "path = Path.cwd().parent.parent\n", + "print(path)\n", + "sys.path.insert(0, str(path))\n", + "\n", + "from tests.e2e.test_dataset_utils import load_amnesty_dataset_safe" + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 28, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Test dataset contains 15 samples from amnesty_qa\n", + "\n", + "First sample:\n", + "Question: What are the global implications of the USA Supreme Court ruling on abortion?\n", + "Response: The global implications of the USA Supreme Court ruling on abortion can be significant, as it sets a...\n" + ] + } + ], + "source": [ + "# Add tests directory to path\n", + "tests_dir = Path.cwd().parent if Path.cwd().name == \"notebooks\" else Path.cwd()\n", + "if tests_dir.name == \"tests\":\n", + " sys.path.insert(0, str(tests_dir.parent))\n", + "else:\n", + " sys.path.insert(0, str(tests_dir))\n", + "\n", + "# Load the dataset (will use HuggingFace or fallback to local samples)\n", + "amnesty_dataset = load_amnesty_dataset_safe(\"english_v3\")\n", + "\n", + "# Convert to list of dicts for our utility functions\n", + "# We'll use a subset for faster testing\n", + "test_dataset = []\n", + "for i, sample in enumerate(amnesty_dataset):\n", + " if i >= 15: # Limit to 5 samples for faster testing\n", + " break\n", + " test_dataset.append(\n", + " {\"user_input\": sample[\"user_input\"], \"response\": sample[\"response\"]}\n", + " )\n", + "\n", + "print(f\"Test dataset contains {len(test_dataset)} samples from amnesty_qa\")\n", + "print(\"\\nFirst sample:\")\n", + "print(f\"Question: {test_dataset[0]['user_input']}\")\n", + "print(f\"Response: {test_dataset[0]['response'][:100]}...\")" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running both metrics in parallel on 15 samples (max 10 concurrent)...\n", + "============================================================\n", + "METRIC COMPARISON SUMMARY\n", + "============================================================\n", + "\n", + "Score Statistics:\n", + " Old Metric Mean: 0.9023\n", + " New Metric Mean: 0.9670\n", + "\n", + "Difference Statistics (new - old):\n", + " Mean Diff: 0.0647\n", + " Max Diff: 0.9992\n", + " Min Diff: -0.0232\n", + " Std Dev: 0.2499\n", + "\n", + "Execution Time:\n", + " Old Metric: 22.33s\n", + " New Metric: 32.67s\n", + " Speedup: 0.68x\n", + "============================================================\n" + ] + } + ], "source": [ "# Run comparison\n", "result = await compare_metrics(\n", @@ -284,9 +499,203 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 30, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \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", + "
user_inputold_scorenew_scorediffabs_diff
0What are the global implications of the USA Su...0.9999991.0000000.0000010.000001
1Which companies are the main contributors to G...0.9652470.9652600.0000130.000013
2Which private companies in the Americas are th...0.9844030.982324-0.0020790.002079
3What action did Amnesty International urge its...0.9887780.983347-0.0054310.005431
4What are the recommendations made by Amnesty I...0.9890840.9890850.0000010.000001
5Who are the target audience of the two books c...0.0000000.9992090.9992090.999209
6Which right guarantees access to comprehensive...0.9658840.9676050.0017200.001720
7Who has the right to be fully informed about h...0.9374200.9413280.0039080.003908
8When can individuals be found guilty under Art...0.8998820.9018580.0019760.001976
9When does the prosecution consider statements ...0.9078750.9084570.0005820.000582
10What factors have contributed to the decline o...1.0000000.998699-0.0013010.001301
11What conditions designate wetlands as Ramsar s...0.9789480.974074-0.0048740.004874
12Where was COP15 held in 2022?0.9999980.976795-0.0232020.023202
13What is the purpose of the agreement known as ...0.9839270.9946370.0107100.010710
14Who failed to explicitly recognize Indigenous ...0.9328970.921576-0.0113210.011321
\n", + "
" + ], + "text/plain": [ + " user_input old_score new_score \\\n", + "0 What are the global implications of the USA Su... 0.999999 1.000000 \n", + "1 Which companies are the main contributors to G... 0.965247 0.965260 \n", + "2 Which private companies in the Americas are th... 0.984403 0.982324 \n", + "3 What action did Amnesty International urge its... 0.988778 0.983347 \n", + "4 What are the recommendations made by Amnesty I... 0.989084 0.989085 \n", + "5 Who are the target audience of the two books c... 0.000000 0.999209 \n", + "6 Which right guarantees access to comprehensive... 0.965884 0.967605 \n", + "7 Who has the right to be fully informed about h... 0.937420 0.941328 \n", + "8 When can individuals be found guilty under Art... 0.899882 0.901858 \n", + "9 When does the prosecution consider statements ... 0.907875 0.908457 \n", + "10 What factors have contributed to the decline o... 1.000000 0.998699 \n", + "11 What conditions designate wetlands as Ramsar s... 0.978948 0.974074 \n", + "12 Where was COP15 held in 2022? 0.999998 0.976795 \n", + "13 What is the purpose of the agreement known as ... 0.983927 0.994637 \n", + "14 Who failed to explicitly recognize Indigenous ... 0.932897 0.921576 \n", + "\n", + " diff abs_diff \n", + "0 0.000001 0.000001 \n", + "1 0.000013 0.000013 \n", + "2 -0.002079 0.002079 \n", + "3 -0.005431 0.005431 \n", + "4 0.000001 0.000001 \n", + "5 0.999209 0.999209 \n", + "6 0.001720 0.001720 \n", + "7 0.003908 0.003908 \n", + "8 0.001976 0.001976 \n", + "9 0.000582 0.000582 \n", + "10 -0.001301 0.001301 \n", + "11 -0.004874 0.004874 \n", + "12 -0.023202 0.023202 \n", + "13 0.010710 0.010710 \n", + "14 -0.011321 0.011321 " + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# View detailed results\n", "df = result.to_dataframe()\n", @@ -297,9 +706,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 32, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Visualize the differences\n", "import matplotlib.pyplot as plt\n", @@ -339,19 +759,15 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ - "# Create two instances with different LLMs\n", - "client = AsyncOpenAI()\n", + "# Create two instances with different LLMs using shared utilities\n", + "llm_gpt4_mini = create_modern_llm(provider=\"openai\", model=\"gpt-4o-mini\")\n", + "llm_gpt4 = create_modern_llm(provider=\"openai\", model=\"gpt-4o\")\n", "\n", - "llm_gpt4_mini = instructor_llm_factory(\"openai\", client=client, model=\"gpt-4o-mini\")\n", - "llm_gpt4 = instructor_llm_factory(\"openai\", client=client, model=\"gpt-4o\")\n", - "\n", - "embeddings = embedding_factory(\n", - " \"openai\", model=\"text-embedding-ada-002\", client=client, interface=\"modern\"\n", - ")\n", + "embeddings = create_modern_embeddings(provider=\"openai\", model=\"text-embedding-ada-002\")\n", "\n", "metric_gpt4_mini = NewAnswerRelevancy(\n", " llm=llm_gpt4_mini, embeddings=embeddings, strictness=3\n", @@ -364,7 +780,16 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running old metric on 15 samples...\n", + "Running new metric on 15 samples...\n" + ] + } + ], "source": [ "# Compare LLMs\n", "result_llm = await compare_metrics(\n", @@ -476,7 +901,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": ".venv", "language": "python", "name": "python3" }, @@ -490,9 +915,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.0" + "version": "3.12.8" } }, "nbformat": 4, "nbformat_minor": 4 -} \ No newline at end of file +} diff --git a/tests/utils/__init__.py b/tests/utils/__init__.py new file mode 100644 index 000000000..6b94e34c0 --- /dev/null +++ b/tests/utils/__init__.py @@ -0,0 +1,21 @@ +"""Shared test utilities for Ragas tests. + +This module provides reusable utilities for both pytest tests and Jupyter notebooks, +including LLM setup, embeddings configuration, and common test helpers. +""" + +from .llm_setup import ( + check_api_key, + create_legacy_embeddings, + create_legacy_llm, + create_modern_embeddings, + create_modern_llm, +) + +__all__ = [ + "check_api_key", + "create_legacy_llm", + "create_modern_llm", + "create_legacy_embeddings", + "create_modern_embeddings", +] diff --git a/tests/utils/llm_setup.py b/tests/utils/llm_setup.py new file mode 100644 index 000000000..79caf75d4 --- /dev/null +++ b/tests/utils/llm_setup.py @@ -0,0 +1,229 @@ +"""Factory functions for creating LLMs and embeddings for testing. + +This module provides reusable functions for creating both legacy and modern +LLM and embedding instances. These can be used in both pytest tests (via fixtures) +and Jupyter notebooks (directly). +""" + +import os +from typing import Optional + + +def check_api_key(provider: str = "openai") -> bool: + """Check if required API key is set. + + Args: + provider: The provider to check for (default: "openai") + + Returns: + True if API key is set + + Raises: + ValueError: If API key is not set + """ + env_vars = { + "openai": "OPENAI_API_KEY", + "anthropic": "ANTHROPIC_API_KEY", + } + + env_var = env_vars.get(provider.lower()) + if not env_var: + raise ValueError(f"Unknown provider: {provider}") + + if not os.getenv(env_var): + raise ValueError( + f"{env_var} environment variable not set. " + f"Please set it before running:\n" + f" export {env_var}='your-api-key-here'" + ) + + return True + + +def create_legacy_llm(model: str = "gpt-3.5-turbo", **kwargs): + """Create a legacy LLM instance for old-style metrics. + + Args: + model: The model name to use + **kwargs: Additional arguments to pass to llm_factory + + Returns: + Legacy LLM instance + + Raises: + ImportError: If llm_factory is not available + Exception: If LLM creation fails (e.g., missing API key) + """ + try: + from ragas.llms.base import llm_factory + + return llm_factory(model, **kwargs) + except ImportError as e: + raise ImportError(f"LLM factory not available: {e}") + except Exception as e: + raise Exception(f"Could not create LLM (API key may be missing): {e}") + + +def create_modern_llm( + provider: str = "openai", + model: str = "gpt-3.5-turbo", + client: Optional[any] = None, + **kwargs, +): + """Create a modern instructor LLM instance for v2 metrics. + + Args: + provider: The LLM provider (e.g., "openai", "anthropic") + model: The model name to use + client: Optional async client instance. If None, will create one. + **kwargs: Additional arguments to pass to instructor_llm_factory + + Returns: + Modern instructor LLM instance + + Raises: + ImportError: If required libraries are not available + Exception: If LLM creation fails + """ + try: + from ragas.llms.base import instructor_llm_factory + + # Create client if not provided + if client is None: + if provider == "openai": + import openai + + client = openai.AsyncOpenAI() + else: + raise ValueError(f"Auto-client creation not supported for {provider}") + + return instructor_llm_factory(provider, model=model, client=client, **kwargs) + except ImportError as e: + raise ImportError(f"Instructor LLM factory not available: {e}") + except Exception as e: + raise Exception(f"Could not create modern LLM (API key may be missing): {e}") + + +def create_legacy_embeddings(model: str = "text-embedding-ada-002", **kwargs): + """Create legacy embeddings for old-style metrics. + + Args: + model: The embedding model name to use + **kwargs: Additional arguments to pass to embedding_factory + + Returns: + Legacy embeddings instance + + Raises: + ImportError: If embedding_factory is not available + Exception: If embeddings creation fails + """ + try: + from ragas.embeddings.base import embedding_factory + + return embedding_factory(model, **kwargs) + except ImportError as e: + raise ImportError(f"Embedding factory not available: {e}") + except Exception as e: + raise Exception( + f"Could not create legacy embeddings (API key may be missing): {e}" + ) + + +def create_modern_embeddings( + provider: str = "openai", + model: str = "text-embedding-ada-002", + client: Optional[any] = None, + interface: str = "modern", + **kwargs, +): + """Create modern embeddings for v2 metrics. + + Args: + provider: The embeddings provider (e.g., "openai") + model: The embedding model name to use + client: Optional async client instance. If None, will create one. + interface: Interface type (default: "modern") + **kwargs: Additional arguments to pass to embedding_factory + + Returns: + Modern embeddings instance + + Raises: + ImportError: If required libraries are not available + Exception: If embeddings creation fails + """ + try: + from ragas.embeddings.base import embedding_factory + + # Create client if not provided + if client is None: + if provider == "openai": + import openai + + client = openai.AsyncOpenAI() + else: + raise ValueError(f"Auto-client creation not supported for {provider}") + + return embedding_factory( + provider=provider, + model=model, + client=client, + interface=interface, + **kwargs, + ) + except ImportError as e: + raise ImportError(f"OpenAI or embedding factory not available: {e}") + except Exception as e: + raise Exception( + f"Could not create modern embeddings (API key may be missing): {e}" + ) + + +# Legacy-style factory functions for backward compatibility with langchain wrappers +def create_legacy_llm_with_langchain(model: str = "gpt-4o-mini", **kwargs): + """Create a legacy LLM using Langchain wrapper. + + This is for compatibility with older code that uses Langchain wrappers. + + Args: + model: The model name to use + **kwargs: Additional arguments + + Returns: + LangchainLLMWrapper instance + """ + try: + from langchain_openai import ChatOpenAI + + from ragas.llms.base import LangchainLLMWrapper + + langchain_llm = ChatOpenAI(model=model, **kwargs) + return LangchainLLMWrapper(langchain_llm) + except ImportError as e: + raise ImportError(f"Langchain or LangchainLLMWrapper not available: {e}") + + +def create_legacy_embeddings_with_langchain( + model: str = "text-embedding-ada-002", **kwargs +): + """Create legacy embeddings using Langchain wrapper. + + This is for compatibility with older code that uses Langchain wrappers. + + Args: + model: The embedding model name to use + **kwargs: Additional arguments + + Returns: + LangchainEmbeddingsWrapper instance + """ + try: + from langchain_openai import OpenAIEmbeddings + + from ragas.embeddings.base import LangchainEmbeddingsWrapper + + langchain_embeddings = OpenAIEmbeddings(model=model, **kwargs) + return LangchainEmbeddingsWrapper(langchain_embeddings) + except ImportError as e: + raise ImportError(f"Langchain or LangchainEmbeddingsWrapper not available: {e}") From 5e69e305b94ec9dad8fe592b202cd9e2efdcca1b Mon Sep 17 00:00:00 2001 From: jjmachan Date: Wed, 15 Oct 2025 13:51:20 -0700 Subject: [PATCH 3/7] utils to test with fiqa --- tests/e2e/test_dataset_utils.py | 58 +++++ tests/utils/__init__.py | 14 ++ tests/utils/metric_comparison.py | 351 +++++++++++++++++++++++++++++++ 3 files changed, 423 insertions(+) create mode 100644 tests/utils/metric_comparison.py diff --git a/tests/e2e/test_dataset_utils.py b/tests/e2e/test_dataset_utils.py index 4f1861466..0f4cb7a0a 100644 --- a/tests/e2e/test_dataset_utils.py +++ b/tests/e2e/test_dataset_utils.py @@ -30,6 +30,39 @@ }, ] +# Sample data structure matching the fiqa dataset +SAMPLE_FIQA_DATA = [ + { + "user_input": "How to deposit a cheque issued to an associate in my business account?", + "reference": "Have the check reissued to the proper payee. Just have the associate sign the back and then deposit it. It's called a third party cheque and is perfectly legal. I wouldn't be surprised if it has a longer hold period and, as always, you don't get the money if the cheque doesn't clear.", + "response": "The best way to deposit a cheque issued to an associate in your business account is to have the associate sign the back of the cheque and deposit it as a third party cheque.", + "retrieved_contexts": [ + "Just have the associate sign the back and then deposit it. It's called a third party cheque and is perfectly legal.", + "I wouldn't be surprised if it has a longer hold period and, as always, you don't get the money if the cheque doesn't clear.", + ], + }, + { + "user_input": "What is the difference between a mutual fund and an ETF?", + "reference": "Mutual funds are actively managed investment vehicles that pool money from multiple investors. ETFs are passively managed and trade on exchanges like stocks. ETFs typically have lower fees and can be bought and sold throughout the trading day.", + "response": "A mutual fund pools money from investors and is actively managed, while an ETF trades like a stock and typically tracks an index with lower fees.", + "retrieved_contexts": [ + "Mutual funds pool money from multiple investors and are actively managed by professional fund managers.", + "ETFs trade on exchanges like stocks and can be bought and sold throughout the trading day.", + "ETFs typically have lower expense ratios compared to mutual funds.", + ], + }, + { + "user_input": "Should I pay off my mortgage early or invest the money?", + "reference": "It depends on your mortgage interest rate and expected investment returns. If your mortgage rate is low and you expect higher returns from investments, investing may be better. Consider your risk tolerance and financial goals.", + "response": "The decision depends on comparing your mortgage interest rate to expected investment returns, along with your risk tolerance and financial security needs.", + "retrieved_contexts": [ + "Compare your mortgage interest rate to expected investment returns to make an informed decision.", + "Consider your risk tolerance and overall financial situation before making this decision.", + "Having no mortgage provides peace of mind and guaranteed savings equal to the interest rate.", + ], + }, +] + def load_amnesty_dataset_safe(config: str = "english_v3"): """ @@ -54,3 +87,28 @@ def load_amnesty_dataset_safe(config: str = "english_v3"): local_dataset = Dataset.from_list(SAMPLE_AMNESTY_DATA) logger.info(f"Created local dataset with {len(local_dataset)} samples") return local_dataset + + +def load_fiqa_dataset_safe(config: str = "ragas_eval_v3"): + """ + Safely load the fiqa dataset, falling back to local data if remote fails. + + Args: + config: Dataset configuration name (default: "ragas_eval_v3" - recommended) + + Returns: + Dataset: The loaded dataset + """ + try: + logger.info(f"Attempting to load fiqa dataset with config '{config}'") + dataset = load_dataset("explodinggradients/fiqa", config)["baseline"] + logger.info(f"Successfully loaded dataset with {len(dataset)} samples") + return dataset + except Exception as e: + logger.warning(f"Failed to load remote dataset: {e}") + logger.info("Using local sample data as fallback") + + # Create a local dataset from sample data + local_dataset = Dataset.from_list(SAMPLE_FIQA_DATA) + logger.info(f"Created local dataset with {len(local_dataset)} samples") + return local_dataset diff --git a/tests/utils/__init__.py b/tests/utils/__init__.py index 6b94e34c0..7d7733305 100644 --- a/tests/utils/__init__.py +++ b/tests/utils/__init__.py @@ -11,11 +11,25 @@ create_modern_embeddings, create_modern_llm, ) +from .metric_comparison import ( + MetricDiffResult, + compare_metrics, + export_comparison_results, + run_metric_on_dataset, + run_metric_on_dataset_with_batching, +) __all__ = [ + # LLM and embeddings setup "check_api_key", "create_legacy_llm", "create_modern_llm", "create_legacy_embeddings", "create_modern_embeddings", + # Metric comparison utilities + "MetricDiffResult", + "compare_metrics", + "export_comparison_results", + "run_metric_on_dataset", + "run_metric_on_dataset_with_batching", ] diff --git a/tests/utils/metric_comparison.py b/tests/utils/metric_comparison.py new file mode 100644 index 000000000..2adc6171b --- /dev/null +++ b/tests/utils/metric_comparison.py @@ -0,0 +1,351 @@ +"""Utilities for comparing metrics across different implementations. + +This module provides tools for comparing legacy and modern metric implementations, +including concurrent execution, statistical analysis, and result export capabilities. +""" + +import asyncio +import time +from dataclasses import dataclass +from typing import Any, Dict, List, Tuple + +import numpy as np +import pandas as pd + +from ragas.dataset_schema import SingleTurnSample + + +@dataclass +class MetricDiffResult: + """Container for metric comparison results. + + Attributes: + old_scores: List of scores from the baseline/old metric + new_scores: List of scores from the new metric + diffs: List of differences (new - old) + mean_diff: Mean of differences + max_diff: Maximum difference + min_diff: Minimum difference + std_diff: Standard deviation of differences + old_mean: Mean of old metric scores + new_mean: Mean of new metric scores + old_time: Execution time for old metric (seconds) + new_time: Execution time for new metric (seconds) + """ + + old_scores: List[float] + new_scores: List[float] + diffs: List[float] + mean_diff: float + max_diff: float + min_diff: float + std_diff: float + old_mean: float + new_mean: float + old_time: float + new_time: float + + def to_dataframe(self) -> pd.DataFrame: + """Convert results to a pandas DataFrame. + + Returns: + DataFrame with columns: old_score, new_score, diff, abs_diff + """ + return pd.DataFrame( + { + "old_score": self.old_scores, + "new_score": self.new_scores, + "diff": self.diffs, + "abs_diff": [abs(d) for d in self.diffs], + } + ) + + def print_summary(self): + """Print a formatted summary of the comparison results.""" + print("=" * 60) + print("METRIC COMPARISON SUMMARY") + print("=" * 60) + print("\nScore Statistics:") + print(f" Old Metric Mean: {self.old_mean:.4f}") + print(f" New Metric Mean: {self.new_mean:.4f}") + print("\nDifference Statistics (new - old):") + print(f" Mean Diff: {self.mean_diff:.4f}") + print(f" Max Diff: {self.max_diff:.4f}") + print(f" Min Diff: {self.min_diff:.4f}") + print(f" Std Dev: {self.std_diff:.4f}") + print("\nExecution Time:") + print(f" Old Metric: {self.old_time:.2f}s") + print(f" New Metric: {self.new_time:.2f}s") + print( + f" Speedup: {self.old_time / self.new_time:.2f}x" + if self.new_time > 0 + else " N/A" + ) + print("=" * 60) + + +async def run_metric_on_dataset( + metric: Any, + dataset: List[Dict[str, Any]], + metric_type: str = "old", + max_concurrent: int = 10, +) -> Tuple[List[float], float]: + """ + Run a metric on a dataset with concurrent processing for better performance. + + This function processes all samples concurrently with a semaphore to limit + the number of simultaneous API calls, preventing rate limiting issues. + + Args: + metric: The metric instance (either old or new style) + dataset: List of dictionaries containing the data samples + metric_type: "old" for legacy metrics, "new" for collections metrics + max_concurrent: Maximum number of concurrent requests (default: 10) + + Returns: + Tuple of (scores list, execution time in seconds) + + Example: + >>> scores, time = await run_metric_on_dataset( + ... metric=my_metric, + ... dataset=[{"user_input": "q1", "response": "a1"}], + ... metric_type="new", + ... max_concurrent=5, + ... ) + """ + + async def score_single_sample(sample_dict: Dict[str, Any]) -> float: + """Score a single sample using the appropriate metric interface.""" + try: + if metric_type == "old": + # Old metrics use SingleTurnSample + sample = SingleTurnSample(**sample_dict) + score = await metric._single_turn_ascore(sample, callbacks=None) + else: + # New metrics use direct kwargs + result = await metric.ascore(**sample_dict) + score = result.value + + return float(score) + except Exception as e: + print(f"Error processing sample: {e}") + return np.nan + + start_time = time.time() + + # Use semaphore to limit concurrent requests (prevents API rate limiting) + semaphore = asyncio.Semaphore(max_concurrent) + + async def score_with_limit(sample_dict: Dict[str, Any]) -> float: + """Score with concurrency control.""" + async with semaphore: + return await score_single_sample(sample_dict) + + # Process all samples concurrently + scores = await asyncio.gather(*[score_with_limit(s) for s in dataset]) + + execution_time = time.time() - start_time + return list(scores), execution_time + + +async def compare_metrics( + old_metric: Any, + new_metric: Any, + dataset: List[Dict[str, Any]], + old_metric_type: str = "old", + new_metric_type: str = "new", + max_concurrent: int = 10, + parallel_metrics: bool = True, +) -> MetricDiffResult: + """ + Compare two metrics on the same dataset with optional parallel execution. + + This function runs both metrics on the dataset and computes detailed + comparison statistics. Metrics can be run in parallel (faster) or + sequentially (more accurate individual timing). + + Args: + old_metric: The baseline/old metric instance + new_metric: The new/updated metric instance + dataset: List of dictionaries containing the data samples + old_metric_type: Type identifier for old metric ("old" or "new") + new_metric_type: Type identifier for new metric ("old" or "new") + max_concurrent: Maximum number of concurrent requests per metric (default: 10) + parallel_metrics: If True, run both metrics in parallel. If False, run sequentially + for more accurate individual timing (default: True) + + Returns: + MetricDiffResult containing detailed comparison statistics + + Example: + >>> result = await compare_metrics( + ... old_metric=legacy_metric, + ... new_metric=modern_metric, + ... dataset=test_data, + ... max_concurrent=5, + ... parallel_metrics=True, + ... ) + >>> result.print_summary() + """ + if parallel_metrics: + print( + f"Running both metrics in parallel on {len(dataset)} samples (max {max_concurrent} concurrent)..." + ) + + # Run both metrics concurrently using asyncio.gather + (old_scores, old_time), (new_scores, new_time) = await asyncio.gather( + run_metric_on_dataset(old_metric, dataset, old_metric_type, max_concurrent), + run_metric_on_dataset(new_metric, dataset, new_metric_type, max_concurrent), + ) + else: + # Sequential execution for more accurate individual timing + print( + f"Running old metric on {len(dataset)} samples (max {max_concurrent} concurrent)..." + ) + old_scores, old_time = await run_metric_on_dataset( + old_metric, dataset, old_metric_type, max_concurrent + ) + + print( + f"Running new metric on {len(dataset)} samples (max {max_concurrent} concurrent)..." + ) + new_scores, new_time = await run_metric_on_dataset( + new_metric, dataset, new_metric_type, max_concurrent + ) + + # Calculate differences + diffs = [new - old for old, new in zip(old_scores, new_scores)] + + return MetricDiffResult( + old_scores=old_scores, + new_scores=new_scores, + diffs=diffs, + mean_diff=float(np.mean(diffs)), + max_diff=float(np.max(diffs)), + min_diff=float(np.min(diffs)), + std_diff=float(np.std(diffs)), + old_mean=float(np.mean(old_scores)), + new_mean=float(np.mean(new_scores)), + old_time=old_time, + new_time=new_time, + ) + + +async def run_metric_on_dataset_with_batching( + metric: Any, + dataset: List[Dict[str, Any]], + metric_type: str = "new", + batch_size: int = 5, +) -> Tuple[List[float], float]: + """ + Run metric using batch processing if available (for better performance). + + This function attempts to use the metric's abatch_score method if available, + which can be more efficient than individual scoring. Falls back to concurrent + processing if batching is not supported. + + Args: + metric: The metric instance + dataset: List of dictionaries containing the data samples + metric_type: "old" or "new" - old metrics don't support batching + batch_size: Number of samples per batch (default: 5) + + Returns: + Tuple of (scores list, execution time in seconds) + + Example: + >>> scores, time = await run_metric_on_dataset_with_batching( + ... metric=my_metric, + ... dataset=test_data, + ... metric_type="new", + ... batch_size=10, + ... ) + """ + # Check if metric supports batching + has_batch = hasattr(metric, "abatch_score") + + if not has_batch or metric_type == "old": + # Fall back to concurrent processing + print(" Batching not available, using concurrent processing...") + return await run_metric_on_dataset(metric, dataset, metric_type) + + start_time = time.time() + all_scores = [] + + # Process in batches + num_batches = (len(dataset) + batch_size - 1) // batch_size + print( + f" Processing {len(dataset)} samples in {num_batches} batches of {batch_size}..." + ) + + for i in range(0, len(dataset), batch_size): + batch = dataset[i : i + batch_size] + try: + results = await metric.abatch_score(batch) + scores = [r.value for r in results] + all_scores.extend(scores) + except Exception as e: + print( + f" Warning: Batch {i // batch_size + 1} failed ({e}), falling back to individual processing..." + ) + # Fall back to individual processing for this batch + for sample in batch: + try: + result = await metric.ascore(**sample) + all_scores.append(result.value) + except Exception as e2: + print(f" Error processing sample: {e2}") + all_scores.append(np.nan) + + execution_time = time.time() - start_time + return all_scores, execution_time + + +def export_comparison_results( + result: MetricDiffResult, + dataset: List[Dict[str, Any]], + filename: str = "metric_comparison_results.csv", +): + """ + Export comparison results to CSV file. + + The CSV includes all scores, differences, and the original dataset fields, + plus a summary row with aggregate statistics. + + Args: + result: MetricDiffResult object containing comparison data + dataset: Original dataset (to include context in export) + filename: Output CSV filename (default: "metric_comparison_results.csv") + + Example: + >>> export_comparison_results( + ... result=comparison_result, + ... dataset=test_data, + ... filename="context_recall_results.csv", + ... ) + """ + df = result.to_dataframe() + + # Add dataset information + for key in dataset[0].keys(): + df[key] = [sample.get(key, "") for sample in dataset] + + # Add summary statistics as a separate row + summary = pd.DataFrame( + [ + { + **{ + key: "SUMMARY" if i == 0 else "" + for i, key in enumerate(dataset[0].keys()) + }, + "old_score": result.old_mean, + "new_score": result.new_mean, + "diff": result.mean_diff, + "abs_diff": np.mean([abs(d) for d in result.diffs]), + } + ] + ) + + df = pd.concat([df, summary], ignore_index=True) + df.to_csv(filename, index=False) + print(f"Results exported to {filename}") From c093afd9808ebef5010b5f30eb705539c9793a37 Mon Sep 17 00:00:00 2001 From: jjmachan Date: Wed, 15 Oct 2025 18:58:05 -0700 Subject: [PATCH 4/7] added the plan and edited metrics migration --- .../metrics_migration/metric_score_diff.ipynb | 1233 +++++++++++++++++ .../plan-for-metrics-migration.md | 797 +++++++++++ tests/notebooks/metric_score_diff.ipynb | 923 ------------ 3 files changed, 2030 insertions(+), 923 deletions(-) create mode 100644 tests/e2e/metrics_migration/metric_score_diff.ipynb create mode 100644 tests/e2e/metrics_migration/plan-for-metrics-migration.md delete mode 100644 tests/notebooks/metric_score_diff.ipynb diff --git a/tests/e2e/metrics_migration/metric_score_diff.ipynb b/tests/e2e/metrics_migration/metric_score_diff.ipynb new file mode 100644 index 000000000..98b3c2a47 --- /dev/null +++ b/tests/e2e/metrics_migration/metric_score_diff.ipynb @@ -0,0 +1,1233 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Metrics Migration Testing Notebook (General Purpose)\n", + "\n", + "This notebook provides a **generalized, reusable approach** for comparing legacy and modern metric implementations.\n", + "\n", + "## Quick Start\n", + "1. **Edit the Configuration Cell** (cell 2) with your metric details\n", + "2. Run all cells - no other modifications needed!\n", + "3. Works for ANY metric type: LLM-based, embeddings-based, or deterministic\n", + "\n", + "## Purpose\n", + "- **PRIMARY**: Validate migration on real-world datasets (amnesty_qa, fiqa)\n", + "- **SECONDARY**: Test specific edge cases and behaviors\n", + "- **FLEXIBLE**: Works with any metric configuration\n", + "\n", + "## Structure\n", + "1. Configuration (specify your metrics and requirements)\n", + "2. Setup and component creation\n", + "3. Dataset-based comparison (Amnesty QA)\n", + "4. FIQA dataset testing (domain generalization)\n", + "5. Optional: Different LLMs, edge cases\n", + "\n", + "Based on: `tests/e2e/plan-for-metrics-migration.md`" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/jjmachan/workspace/eglabs/ragas-workdir/ragas/.venv/lib/python3.12/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + } + ], + "source": [ + "import asyncio\n", + "import time\n", + "from dataclasses import dataclass\n", + "from typing import Any, Dict, List, Tuple\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "# Ragas imports\n", + "from ragas.dataset_schema import SingleTurnSample" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "โœ“ Configuration loaded - Edit above for your metric\n" + ] + } + ], + "source": [ + "## โš ๏ธ CONFIGURATION CELL - EDIT THIS FOR YOUR METRIC โš ๏ธ\n", + "\n", + "# Metric Configuration - Update these values for any metric\n", + "METRIC_CONFIG = {\n", + " # ===== METRIC IMPORTS =====\n", + " \"legacy_import\": {\n", + " \"module\": \"ragas.metrics._answer_relevance\", # e.g., \"ragas.metrics._context_recall\"\n", + " \"class_name\": \"AnswerRelevancy\", # e.g., \"ContextRecall\"\n", + " },\n", + " \"modern_import\": {\n", + " \"module\": \"ragas.metrics.collections\",\n", + " \"class_name\": \"AnswerRelevancy\",\n", + " },\n", + " \n", + " # ===== COMPONENT REQUIREMENTS =====\n", + " # Set to False if your metric doesn't need this component\n", + " \"needs_llm\": True,\n", + " \"needs_embeddings\": True,\n", + " \n", + " # ===== DATASET FIELD MAPPING =====\n", + " # Which fields does your metric require from the dataset?\n", + " # Choose ONE based on your metric type:\n", + " \n", + " # OPTION 1: Answer-based metrics (AnswerRelevancy, AnswerSimilarity, etc.)\n", + " \"dataset_fields\": [\"user_input\", \"response\"],\n", + " \n", + " # OPTION 2: Context-based metrics (ContextRecall, ContextPrecision, etc.)\n", + " # \"dataset_fields\": [\"user_input\", \"retrieved_contexts\", \"reference\"],\n", + " \n", + " # OPTION 3: Deterministic metrics (NonLLMContextRecall, etc.)\n", + " # \"dataset_fields\": [\"retrieved_contexts\", \"reference_contexts\"],\n", + " # \"needs_llm\": False,\n", + " # \"needs_embeddings\": False,\n", + "}\n", + "\n", + "# ===== QUICK REFERENCE =====\n", + "# AnswerRelevancy: dataset_fields = [\"user_input\", \"response\"], needs_llm = True, needs_embeddings = True\n", + "# ContextRecall: dataset_fields = [\"user_input\", \"retrieved_contexts\", \"reference\"], needs_llm = True, needs_embeddings = False\n", + "# NonLLMContextRecall: dataset_fields = [\"retrieved_contexts\", \"reference_contexts\"], needs_llm = False, needs_embeddings = False\n", + "# ContextPrecision: dataset_fields = [\"user_input\", \"retrieved_contexts\", \"reference\"], needs_llm = True, needs_embeddings = False\n", + "\n", + "print(\"โœ“ Configuration loaded - Edit above for your metric\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Setup\n", + "\n", + "Make sure you have your OpenAI API key set as an environment variable before running this notebook." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "โœ“ Setup complete\n", + "โœ“ Metric classes loaded:\n", + " Legacy: AnswerRelevancy from ragas.metrics._answer_relevance\n", + " Modern: AnswerRelevancy from ragas.metrics.collections\n" + ] + } + ], + "source": [ + "import os\n", + "import sys\n", + "from pathlib import Path\n", + "import importlib\n", + "\n", + "# Add project root to path\n", + "project_root = Path.cwd().parent.parent\n", + "sys.path.insert(0, str(project_root))\n", + "\n", + "from tests.utils import check_api_key\n", + "\n", + "# Check for OpenAI API key\n", + "check_api_key(\"openai\")\n", + "print(\"โœ“ Setup complete\")\n", + "\n", + "# ===== DYNAMIC METRIC LOADING =====\n", + "def load_metric_class(import_config):\n", + " \"\"\"Dynamically load a metric class from module and class name.\"\"\"\n", + " try:\n", + " module = importlib.import_module(import_config[\"module\"])\n", + " return getattr(module, import_config[\"class_name\"])\n", + " except (ImportError, AttributeError) as e:\n", + " raise ValueError(f\"Failed to load {import_config['class_name']} from {import_config['module']}: {e}\")\n", + "\n", + "# Load metric classes from config\n", + "LegacyMetric = load_metric_class(METRIC_CONFIG[\"legacy_import\"])\n", + "ModernMetric = load_metric_class(METRIC_CONFIG[\"modern_import\"])\n", + "\n", + "print(f\"โœ“ Metric classes loaded:\")\n", + "print(f\" Legacy: {METRIC_CONFIG['legacy_import']['class_name']} from {METRIC_CONFIG['legacy_import']['module']}\")\n", + "print(f\" Modern: {METRIC_CONFIG['modern_import']['class_name']} from {METRIC_CONFIG['modern_import']['module']}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Import Comparison Utilities\n", + "\n", + "The `compare_metrics` function is imported from `tests.utils` and provides:\n", + "- Concurrent processing for better performance\n", + "- Parallel or sequential metric execution\n", + "- Built-in result aggregation and statistics" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "โœ“ Comparison utilities loaded\n" + ] + } + ], + "source": [ + "from tests.utils import compare_metrics\n", + "\n", + "print(\"โœ“ Comparison utilities loaded\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Create LLM and Embeddings Components\n", + "\n", + "Use shared test utilities to create legacy and modern components based on configuration." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "โœ“ LLM components created\n", + "โœ“ Embeddings components created\n", + "โœ“ All required components created\n" + ] + } + ], + "source": [ + "from tests.utils import (\n", + " create_legacy_embeddings,\n", + " create_legacy_llm,\n", + " create_modern_embeddings,\n", + " create_modern_llm,\n", + ")\n", + "\n", + "# ===== CREATE COMPONENTS BASED ON CONFIGURATION =====\n", + "components_config = {\n", + " \"legacy_llm\": None,\n", + " \"legacy_embeddings\": None,\n", + " \"modern_llm\": None,\n", + " \"modern_embeddings\": None,\n", + "}\n", + "\n", + "if METRIC_CONFIG[\"needs_llm\"]:\n", + " components_config[\"legacy_llm\"] = create_legacy_llm(model=\"gpt-4o-mini\")\n", + " components_config[\"modern_llm\"] = create_modern_llm(provider=\"openai\", model=\"gpt-4o-mini\")\n", + " print(\"โœ“ LLM components created\")\n", + "\n", + "if METRIC_CONFIG[\"needs_embeddings\"]:\n", + " components_config[\"legacy_embeddings\"] = create_legacy_embeddings(model=\"text-embedding-ada-002\")\n", + " components_config[\"modern_embeddings\"] = create_modern_embeddings(\n", + " provider=\"openai\", model=\"text-embedding-ada-002\"\n", + " )\n", + " print(\"โœ“ Embeddings components created\")\n", + "\n", + "print(\"โœ“ All required components created\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Initialize Metrics\n", + "\n", + "Uses the dynamically loaded metric classes and configured components." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "โœ“ Metrics initialized:\n", + " Legacy: answer_relevancy\n", + " Modern: answer_relevancy\n", + " Dataset fields required: ['user_input', 'response']\n" + ] + } + ], + "source": [ + "# ===== INITIALIZE METRICS DYNAMICALLY =====\n", + "def init_metric(metric_class, components_config, is_legacy=True):\n", + " \"\"\"Initialize a metric with available components.\"\"\"\n", + " prefix = \"legacy_\" if is_legacy else \"modern_\"\n", + " \n", + " # Build kwargs from available components\n", + " kwargs = {}\n", + " if components_config[f\"{prefix}llm\"]:\n", + " kwargs[\"llm\"] = components_config[f\"{prefix}llm\"]\n", + " if components_config[f\"{prefix}embeddings\"]:\n", + " kwargs[\"embeddings\"] = components_config[f\"{prefix}embeddings\"]\n", + " \n", + " return metric_class(**kwargs)\n", + "\n", + "# Initialize metrics\n", + "legacy_metric = init_metric(LegacyMetric, components_config, is_legacy=True)\n", + "modern_metric = init_metric(ModernMetric, components_config, is_legacy=False)\n", + "\n", + "# Display initialized metrics\n", + "legacy_name = getattr(legacy_metric, 'name', legacy_metric.__class__.__name__)\n", + "modern_name = getattr(modern_metric, 'name', modern_metric.__class__.__name__)\n", + "\n", + "print(f\"โœ“ Metrics initialized:\")\n", + "print(f\" Legacy: {legacy_name}\")\n", + "print(f\" Modern: {modern_name}\")\n", + "print(f\" Dataset fields required: {METRIC_CONFIG['dataset_fields']}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'legacy_llm' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mNameError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[8]\u001b[39m\u001b[32m, line 7\u001b[39m\n\u001b[32m 3\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mragas\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mmetrics\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mcollections\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m AnswerRelevancy\n\u001b[32m 5\u001b[39m \u001b[38;5;66;03m# Initialize metrics\u001b[39;00m\n\u001b[32m 6\u001b[39m legacy_metric = LegacyAnswerRelevancy(\n\u001b[32m----> \u001b[39m\u001b[32m7\u001b[39m llm=\u001b[43mlegacy_llm\u001b[49m, embeddings=legacy_embeddings, strictness=\u001b[32m3\u001b[39m\n\u001b[32m 8\u001b[39m )\n\u001b[32m 9\u001b[39m new_metric = AnswerRelevancy(\n\u001b[32m 10\u001b[39m llm=modern_llm, embeddings=modern_embeddings, strictness=\u001b[32m3\u001b[39m\n\u001b[32m 11\u001b[39m )\n\u001b[32m 13\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mLegacy metric: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mlegacy_metric.name\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m)\n", + "\u001b[31mNameError\u001b[39m: name 'legacy_llm' is not defined" + ] + } + ], + "source": [ + "# Import metrics\n", + "from ragas.metrics._answer_relevance import AnswerRelevancy as LegacyAnswerRelevancy\n", + "from ragas.metrics.collections import AnswerRelevancy\n", + "\n", + "# Initialize metrics\n", + "legacy_metric = LegacyAnswerRelevancy(\n", + " llm=legacy_llm, embeddings=legacy_embeddings, strictness=3\n", + ")\n", + "new_metric = AnswerRelevancy(\n", + " llm=modern_llm, embeddings=modern_embeddings, strictness=3\n", + ")\n", + "\n", + "print(f\"Legacy metric: {legacy_metric.name}\")\n", + "print(f\"New metric: {new_metric.name}\")\n", + "print(\"โœ“ Metrics initialized\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "\n", + "## PRIMARY: Dataset-Based Testing\n", + "\n", + "### Load Amnesty QA Dataset" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from tests.e2e.test_dataset_utils import load_amnesty_dataset_safe\n", + "\n", + "print(\"Loading amnesty_qa dataset...\")\n", + "amnesty_dataset = load_amnesty_dataset_safe(\"english_v3\")\n", + "print(f\"โœ“ Loaded {len(amnesty_dataset)} samples from amnesty_qa\")\n", + "\n", + "# Convert to format expected by metric using configured fields\n", + "amnesty_test_data = []\n", + "for i, sample in enumerate(amnesty_dataset):\n", + " if i >= 20: # Start with 20 samples, adjust as needed\n", + " break\n", + " \n", + " # Extract only configured fields\n", + " test_sample = {}\n", + " for field in METRIC_CONFIG[\"dataset_fields\"]:\n", + " if field == \"reference_contexts\" and field not in sample:\n", + " # Handle transform case: split retrieved_contexts\n", + " retrieved_contexts = sample.get(\"retrieved_contexts\", [])\n", + " if retrieved_contexts and len(retrieved_contexts) > 1:\n", + " mid = len(retrieved_contexts) // 2\n", + " test_sample[field] = retrieved_contexts[mid:]\n", + " elif field in sample:\n", + " test_sample[field] = sample[field]\n", + " elif field == \"response\":\n", + " # Default for response if not in sample\n", + " test_sample[field] = sample.get(\"response\", \"\")\n", + " elif field == \"reference\":\n", + " # Rename reference_contexts to reference if needed\n", + " test_sample[field] = sample.get(\"reference_contexts\", sample.get(\"reference\", \"\"))\n", + " \n", + " if test_sample: # Only add if we have data\n", + " amnesty_test_data.append(test_sample)\n", + "\n", + "print(f\"โœ“ Prepared {len(amnesty_test_data)} samples for testing\")\n", + "if amnesty_test_data:\n", + " print(f\"\\nFirst sample fields:\")\n", + " first_sample = amnesty_test_data[0]\n", + " for key, value in first_sample.items():\n", + " if isinstance(value, list):\n", + " print(f\" {key}: {len(value)} item(s)\")\n", + " elif isinstance(value, str):\n", + " print(f\" {key}: {value[:80]}...\")\n", + " else:\n", + " print(f\" {key}: {value}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Compare on Amnesty QA (Optimized & Parallel)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "======================================================================\n", + "AMNESTY QA DATASET COMPARISON\n", + "======================================================================\n", + "Dataset: 20 samples\n", + "Mode: Concurrent processing + Parallel metrics\n", + "======================================================================\n", + "Running both metrics in parallel on 20 samples (max 10 concurrent)...\n", + "============================================================\n", + "METRIC COMPARISON SUMMARY\n", + "============================================================\n", + "\n", + "Score Statistics:\n", + " Old Metric Mean: 0.9211\n", + " New Metric Mean: 0.9736\n", + "\n", + "Difference Statistics (new - old):\n", + " Mean Diff: 0.0525\n", + " Max Diff: 0.9992\n", + " Min Diff: -0.0221\n", + " Std Dev: 0.2174\n", + "\n", + "Execution Time:\n", + " Old Metric: 34.06s\n", + " New Metric: 48.82s\n", + " Speedup: 0.70x\n", + "============================================================\n" + ] + } + ], + "source": [ + "\n", + "print(\"\\n\" + \"=\"*70)\n", + "print(\"AMNESTY QA DATASET COMPARISON\")\n", + "print(\"=\"*70)\n", + "print(f\"Dataset: {len(amnesty_test_data)} samples\")\n", + "print(\"Mode: Concurrent processing + Parallel metrics\")\n", + "print(\"=\"*70)\n", + "\n", + "amnesty_result = await compare_metrics(\n", + " old_metric=legacy_metric,\n", + " new_metric=new_metric,\n", + " dataset=amnesty_test_data,\n", + " old_metric_type=\"old\",\n", + " new_metric_type=\"new\",\n", + " max_concurrent=10,\n", + " parallel_metrics=True,\n", + ")\n", + "\n", + "amnesty_result.print_summary()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Analyze Amnesty QA Results in Detail\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "======================================================================\n", + "DETAILED STATISTICAL ANALYSIS\n", + "======================================================================\n", + "\n", + "Dataset: amnesty_qa (20 samples)\n", + "\n", + "Score Statistics:\n", + " Legacy Mean: 0.9211\n", + " New Mean: 0.9736\n", + " Score Shift: +0.0525\n", + "\n", + "Difference Statistics:\n", + " Mean |Diff|: 0.0558\n", + " Std Dev: 0.2174\n", + " Max Diff: 0.9992\n", + " Min Diff: -0.0221\n", + " Median Diff: 0.0026\n", + "\n", + "Tolerance Analysis:\n", + " < 0.10: 19/20 ( 95.0%)\n", + " < 0.15: 19/20 ( 95.0%)\n", + " < 0.20: 19/20 ( 95.0%)\n", + " < 0.25: 19/20 ( 95.0%)\n", + " < 0.30: 19/20 ( 95.0%)\n", + "\n", + "======================================================================\n", + "TOP 10 LARGEST DIFFERENCES\n", + "======================================================================\n", + "\n", + "#6: Who are the target audience of the two books created by Amne...\n", + " Legacy: 0.0000 | New: 0.9992 | Diff: 0.9992\n", + "\n", + "#9: When can individuals be found guilty under Article 207.3 of ...\n", + " Legacy: 0.8999 | New: 0.9259 | Diff: 0.0260\n", + "\n", + "#13: Where was COP15 held in 2022?...\n", + " Legacy: 1.0000 | New: 0.9779 | Diff: 0.0221\n", + "\n", + "#8: Who has the right to be fully informed about human rights vi...\n", + " Legacy: 0.9374 | New: 0.9588 | Diff: 0.0214\n", + "\n", + "#3: Which private companies in the Americas are the largest GHG ...\n", + " Legacy: 0.9778 | New: 0.9939 | Diff: 0.0161\n", + "\n", + "#15: Who failed to explicitly recognize Indigenous Peoples' lands...\n", + " Legacy: 0.9051 | New: 0.9175 | Diff: 0.0124\n", + "\n", + "#10: When does the prosecution consider statements contrary to th...\n", + " Legacy: 0.9078 | New: 0.9119 | Diff: 0.0041\n", + "\n", + "#7: Which right guarantees access to comprehensive information a...\n", + " Legacy: 0.9679 | New: 0.9641 | Diff: 0.0039\n", + "\n", + "#5: What are the recommendations made by Amnesty International t...\n", + " Legacy: 0.9891 | New: 0.9927 | Diff: 0.0036\n", + "\n", + "#2: Which companies are the main contributors to GHG emissions a...\n", + " Legacy: 0.9652 | New: 0.9621 | Diff: 0.0031\n" + ] + } + ], + "source": [ + "\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "# Get detailed DataFrame\n", + "df_amnesty = amnesty_result.to_dataframe()\n", + "df_amnesty[\"sample_idx\"] = range(len(df_amnesty))\n", + "\n", + "# Create description from first available string field in your test data\n", + "def get_description(sample):\n", + " \"\"\"Extract a short description from sample data.\"\"\"\n", + " for key in [\"user_input\", \"response\", \"reference\", \"question\"]:\n", + " if key in sample and isinstance(sample[key], str):\n", + " return sample[key][:60] + \"...\"\n", + " return f\"Sample with {len(sample)} fields\"\n", + "\n", + "df_amnesty[\"description\"] = [get_description(s) for s in amnesty_test_data]\n", + "\n", + "# Statistical Analysis\n", + "print(\"\\n\" + \"=\"*70)\n", + "print(\"DETAILED STATISTICAL ANALYSIS\")\n", + "print(\"=\"*70)\n", + "print(f\"\\nDataset: amnesty_qa ({len(df_amnesty)} samples)\")\n", + "print(f\"\\nScore Statistics:\")\n", + "print(f\" Legacy Mean: {amnesty_result.old_mean:.4f}\")\n", + "print(f\" New Mean: {amnesty_result.new_mean:.4f}\")\n", + "print(f\" Score Shift: {amnesty_result.mean_diff:+.4f}\")\n", + "\n", + "print(f\"\\nDifference Statistics:\")\n", + "print(f\" Mean |Diff|: {df_amnesty['abs_diff'].mean():.4f}\")\n", + "print(f\" Std Dev: {amnesty_result.std_diff:.4f}\")\n", + "print(f\" Max Diff: {amnesty_result.max_diff:.4f}\")\n", + "print(f\" Min Diff: {amnesty_result.min_diff:.4f}\")\n", + "print(f\" Median Diff: {df_amnesty['abs_diff'].median():.4f}\")\n", + "\n", + "# Tolerance Analysis (adjust for your metric type)\n", + "# For LLM-based metrics: use [0.1, 0.15, 0.2, 0.25, 0.3]\n", + "# For deterministic metrics: use [1e-10, 1e-8, 1e-6, 1e-4, 0.01]\n", + "tolerance_levels = [0.1, 0.15, 0.2, 0.25, 0.3]\n", + "print(f\"\\nTolerance Analysis:\")\n", + "for tol in tolerance_levels:\n", + " within = (df_amnesty[\"abs_diff\"] < tol).sum()\n", + " pct = within / len(df_amnesty) * 100\n", + " print(f\" < {tol:.2f}: {within:3d}/{len(df_amnesty)} ({pct:5.1f}%)\")\n", + "\n", + "# Identify problematic cases\n", + "print(\"\\n\" + \"=\"*70)\n", + "print(\"TOP 10 LARGEST DIFFERENCES\")\n", + "print(\"=\"*70)\n", + "top_diffs = df_amnesty.nlargest(10, \"abs_diff\")\n", + "for idx, row in top_diffs.iterrows():\n", + " print(f\"\\n#{row['sample_idx']+1}: {row['description']}\")\n", + " print(f\" Legacy: {row['old_score']:.4f} | New: {row['new_score']:.4f} | Diff: {row['abs_diff']:.4f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/2y/02fp70k56p75ldrkgtx7z10r0000gn/T/ipykernel_82228/1485780648.py:59: MatplotlibDeprecationWarning: The 'labels' parameter of boxplot() has been renamed 'tick_labels' since Matplotlib 3.9; support for the old name will be dropped in 3.11.\n", + " ax5.boxplot([df_amnesty[\"old_score\"], df_amnesty[\"new_score\"]], labels=['Legacy', 'New'])\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "### Visualize Amnesty QA Results\n", + "\n", + "# Comprehensive Visualization\n", + "fig = plt.figure(figsize=(16, 12))\n", + "gs = fig.add_gridspec(3, 3, hspace=0.3, wspace=0.3)\n", + "\n", + "# 1. Scatter: Legacy vs New scores\n", + "ax1 = fig.add_subplot(gs[0, 0])\n", + "ax1.scatter(df_amnesty[\"old_score\"], df_amnesty[\"new_score\"], alpha=0.5, s=30)\n", + "ax1.plot([0, 1], [0, 1], 'r--', label=\"Perfect match\", linewidth=2)\n", + "ax1.set_xlabel(\"Legacy Score\", fontsize=10)\n", + "ax1.set_ylabel(\"New Score\", fontsize=10)\n", + "ax1.set_title(\"Score Correlation\", fontsize=12, fontweight='bold')\n", + "ax1.legend()\n", + "ax1.grid(True, alpha=0.3)\n", + "ax1.set_xlim(-0.05, 1.05)\n", + "ax1.set_ylim(-0.05, 1.05)\n", + "\n", + "# 2. Histogram: Difference distribution\n", + "ax2 = fig.add_subplot(gs[0, 1])\n", + "ax2.hist(df_amnesty[\"diff\"], bins=40, alpha=0.7, edgecolor='black')\n", + "ax2.axvline(x=0, color='r', linestyle='--', linewidth=2, label='Zero diff')\n", + "ax2.axvline(x=df_amnesty[\"diff\"].mean(), color='g', linestyle='--', linewidth=2, \n", + " label=f'Mean: {df_amnesty[\"diff\"].mean():.3f}')\n", + "ax2.set_xlabel(\"Difference (New - Legacy)\", fontsize=10)\n", + "ax2.set_ylabel(\"Frequency\", fontsize=10)\n", + "ax2.set_title(\"Difference Distribution\", fontsize=12, fontweight='bold')\n", + "ax2.legend()\n", + "ax2.grid(True, alpha=0.3)\n", + "\n", + "# 3. Histogram: Absolute difference (log scale for deterministic metrics)\n", + "ax3 = fig.add_subplot(gs[0, 2])\n", + "non_zero_diffs = df_amnesty[df_amnesty[\"abs_diff\"] > 0][\"abs_diff\"]\n", + "if len(non_zero_diffs) > 0:\n", + " ax3.hist(np.log10(non_zero_diffs), bins=40, alpha=0.7, color='orange', edgecolor='black')\n", + " ax3.axvline(x=-10, color='r', linestyle='--', linewidth=2, label='1e-10 tolerance')\n", + " ax3.set_xlabel(\"Log10(Absolute Difference)\", fontsize=10)\n", + "else:\n", + " ax3.text(0.5, 0.5, 'All differences are zero!', ha='center', va='center', fontsize=12)\n", + "ax3.set_ylabel(\"Frequency\", fontsize=10)\n", + "ax3.set_title(\"Absolute Difference Distribution (Log)\", fontsize=12, fontweight='bold')\n", + "ax3.legend()\n", + "ax3.grid(True, alpha=0.3)\n", + "\n", + "# 4. Line plot: Score trends\n", + "ax4 = fig.add_subplot(gs[1, :])\n", + "x = df_amnesty[\"sample_idx\"]\n", + "ax4.plot(x, df_amnesty[\"old_score\"], 'o-', label=\"Legacy\", alpha=0.6, markersize=4)\n", + "ax4.plot(x, df_amnesty[\"new_score\"], 's-', label=\"New\", alpha=0.6, markersize=4)\n", + "ax4.set_xlabel(\"Sample Index\", fontsize=10)\n", + "ax4.set_ylabel(\"Score\", fontsize=10)\n", + "ax4.set_title(\"Score Trends Across Dataset\", fontsize=12, fontweight='bold')\n", + "ax4.legend()\n", + "ax4.grid(True, alpha=0.3)\n", + "ax4.set_ylim(-0.05, 1.05)\n", + "\n", + "# 5. Box plots: Score distributions\n", + "ax5 = fig.add_subplot(gs[2, 0])\n", + "ax5.boxplot([df_amnesty[\"old_score\"], df_amnesty[\"new_score\"]], labels=['Legacy', 'New'])\n", + "ax5.set_ylabel(\"Score\", fontsize=10)\n", + "ax5.set_title(\"Score Distribution Comparison\", fontsize=12, fontweight='bold')\n", + "ax5.grid(True, alpha=0.3, axis='y')\n", + "\n", + "# 6. Cumulative distribution of absolute differences\n", + "ax6 = fig.add_subplot(gs[2, 1])\n", + "sorted_diffs = np.sort(df_amnesty[\"abs_diff\"])\n", + "cumulative = np.arange(1, len(sorted_diffs) + 1) / len(sorted_diffs) * 100\n", + "ax6.plot(sorted_diffs, cumulative, linewidth=2)\n", + "ax6.axvline(x=0.2, color='r', linestyle='--', linewidth=2, label='0.2 tolerance')\n", + "ax6.axhline(y=90, color='g', linestyle='--', linewidth=1, alpha=0.5, label='90%')\n", + "ax6.set_xlabel(\"Absolute Difference\", fontsize=10)\n", + "ax6.set_ylabel(\"Cumulative Percentage\", fontsize=10)\n", + "ax6.set_title(\"Cumulative Distribution\", fontsize=12, fontweight='bold')\n", + "ax6.set_xscale('log')\n", + "ax6.legend()\n", + "ax6.grid(True, alpha=0.3)\n", + "\n", + "# 7. Scatter: Difference vs Legacy score\n", + "ax7 = fig.add_subplot(gs[2, 2])\n", + "ax7.scatter(df_amnesty[\"old_score\"], df_amnesty[\"abs_diff\"], alpha=0.5, s=30)\n", + "ax7.axhline(y=0.2, color='r', linestyle='--', linewidth=2, label='0.2 tolerance')\n", + "ax7.set_xlabel(\"Legacy Score\", fontsize=10)\n", + "ax7.set_ylabel(\"Absolute Difference\", fontsize=10)\n", + "ax7.set_title(\"Difference vs Score\", fontsize=12, fontweight='bold')\n", + "ax7.set_yscale('log')\n", + "ax7.legend()\n", + "ax7.grid(True, alpha=0.3)\n", + "\n", + "plt.suptitle(f\"Amnesty QA Migration Analysis ({len(df_amnesty)} samples)\", \n", + " fontsize=14, fontweight='bold', y=0.995)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "๐ŸŽฏ AMNESTY QA VALIDATION COMPLETE\n", + "======================================================================\n", + " Mean |Diff|: 0.0558\n", + " Within 0.2: 19/20 (95.0%)\n", + " Within 0.3: 19/20 (95.0%)\n", + "\n", + "๐Ÿ“Š Validation Criteria (LLM-based metrics):\n", + " โœ… Mean |diff| < 0.15: 0.0558\n", + " โœ… >90% within 0.2: 95.0%\n", + " โš ๏ธ >95% within 0.3: 95.0%\n", + " โš ๏ธ No systematic bias (|mean diff| < 0.05): 0.0525\n", + "\n", + "๐Ÿ’ก For deterministic metrics, use stricter criteria:\n", + " - Mean |diff| < 1e-10\n", + " - 100% within 1e-10\n" + ] + } + ], + "source": [ + "### Validate Amnesty QA Results\n", + "\n", + "print(\"๐ŸŽฏ AMNESTY QA VALIDATION COMPLETE\")\n", + "print(\"=\"*70)\n", + "print(f\" Mean |Diff|: {df_amnesty['abs_diff'].mean():.4f}\")\n", + "print(f\" Within 0.2: {(df_amnesty['abs_diff'] < 0.2).sum()}/{len(df_amnesty)} \"\n", + " f\"({(df_amnesty['abs_diff'] < 0.2).sum()/len(df_amnesty)*100:.1f}%)\")\n", + "print(f\" Within 0.3: {(df_amnesty['abs_diff'] < 0.3).sum()}/{len(df_amnesty)} \"\n", + " f\"({(df_amnesty['abs_diff'] < 0.3).sum()/len(df_amnesty)*100:.1f}%)\")\n", + "\n", + "# Validation criteria for LLM-based metrics\n", + "# For deterministic metrics, use stricter tolerances (1e-10, 1e-6)\n", + "mean_abs_diff = df_amnesty['abs_diff'].mean()\n", + "pct_within_02 = (df_amnesty['abs_diff'] < 0.2).sum() / len(df_amnesty) * 100\n", + "pct_within_03 = (df_amnesty['abs_diff'] < 0.3).sum() / len(df_amnesty) * 100\n", + "\n", + "print(\"\\n๐Ÿ“Š Validation Criteria (LLM-based metrics):\")\n", + "print(f\" {'โœ…' if mean_abs_diff < 0.15 else 'โŒ'} Mean |diff| < 0.15: {mean_abs_diff:.4f}\")\n", + "print(f\" {'โœ…' if pct_within_02 > 90 else 'โš ๏ธ'} >90% within 0.2: {pct_within_02:.1f}%\")\n", + "print(f\" {'โœ…' if pct_within_03 > 95 else 'โš ๏ธ'} >95% within 0.3: {pct_within_03:.1f}%\")\n", + "print(f\" {'โœ…' if abs(amnesty_result.mean_diff) < 0.05 else 'โš ๏ธ'} \"\n", + " f\"No systematic bias (|mean diff| < 0.05): {abs(amnesty_result.mean_diff):.4f}\")\n", + "\n", + "print(\"\\n๐Ÿ’ก For deterministic metrics, use stricter criteria:\")\n", + "print(\" - Mean |diff| < 1e-10\")\n", + "print(\" - 100% within 1e-10\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "\n", + "## FIQA Dataset Testing (Domain Generalization)\n", + "\n", + "Test on financial Q&A dataset to validate metric works across different domains." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "### Load FIQA Dataset\n", + "\n", + "from tests.e2e.test_dataset_utils import load_fiqa_dataset_safe\n", + "\n", + "print(\"\\n\" + \"=\"*70)\n", + "print(\"FIQA DATASET COMPARISON\")\n", + "print(\"=\"*70)\n", + "print(\"Testing on financial Q&A dataset for domain generalization...\")\n", + "\n", + "fiqa_dataset = load_fiqa_dataset_safe(\"ragas_eval_v3\")\n", + "print(f\"โœ“ Loaded {len(fiqa_dataset)} samples from fiqa\")\n", + "\n", + "# Convert to format expected by metric using configured fields\n", + "fiqa_test_data = []\n", + "for i, sample in enumerate(fiqa_dataset):\n", + " if i >= 30: # Use up to 30 samples from ragas_eval_v3\n", + " break\n", + " \n", + " # Extract only configured fields (same logic as Amnesty QA)\n", + " test_sample = {}\n", + " for field in METRIC_CONFIG[\"dataset_fields\"]:\n", + " if field == \"reference_contexts\" and field not in sample:\n", + " # Handle transform case: split retrieved_contexts\n", + " retrieved_contexts = sample.get(\"retrieved_contexts\", [])\n", + " if retrieved_contexts and len(retrieved_contexts) > 1:\n", + " mid = len(retrieved_contexts) // 2\n", + " test_sample[field] = retrieved_contexts[mid:]\n", + " elif retrieved_contexts:\n", + " test_sample[field] = retrieved_contexts\n", + " elif field in sample:\n", + " test_sample[field] = sample[field]\n", + " elif field == \"response\":\n", + " test_sample[field] = sample.get(\"response\", \"\")\n", + " elif field == \"reference\":\n", + " test_sample[field] = sample.get(\"reference_contexts\", sample.get(\"reference\", \"\"))\n", + " \n", + " if test_sample: # Only add if we have data\n", + " fiqa_test_data.append(test_sample)\n", + "\n", + "print(f\"โœ“ Prepared {len(fiqa_test_data)} samples for testing\")\n", + "if fiqa_test_data:\n", + " print(f\"\\nFirst sample fields:\")\n", + " first_sample = fiqa_test_data[0]\n", + " for key, value in first_sample.items():\n", + " if isinstance(value, list):\n", + " print(f\" {key}: {len(value)} item(s)\")\n", + " elif isinstance(value, str):\n", + " print(f\" {key}: {value[:80]}...\")\n", + " else:\n", + " print(f\" {key}: {value}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "======================================================================\n", + "Dataset: 30 samples\n", + "Mode: Concurrent processing + Parallel metrics\n", + "======================================================================\n", + "Running both metrics in parallel on 30 samples (max 10 concurrent)...\n", + "============================================================\n", + "METRIC COMPARISON SUMMARY\n", + "============================================================\n", + "\n", + "Score Statistics:\n", + " Old Metric Mean: 0.7542\n", + " New Metric Mean: 0.7887\n", + "\n", + "Difference Statistics (new - old):\n", + " Mean Diff: 0.0346\n", + " Max Diff: 0.9577\n", + " Min Diff: -0.0120\n", + " Std Dev: 0.1716\n", + "\n", + "Execution Time:\n", + " Old Metric: 33.05s\n", + " New Metric: 58.09s\n", + " Speedup: 0.57x\n", + "============================================================\n" + ] + } + ], + "source": [ + "### Compare on FIQA (Optimized & Parallel)\n", + "\n", + "print(\"\\n\" + \"=\"*70)\n", + "print(f\"Dataset: {len(fiqa_test_data)} samples\")\n", + "print(\"Mode: Concurrent processing + Parallel metrics\")\n", + "print(\"=\"*70)\n", + "\n", + "fiqa_result = await compare_metrics(\n", + " old_metric=legacy_metric,\n", + " new_metric=new_metric,\n", + " dataset=fiqa_test_data,\n", + " old_metric_type=\"old\",\n", + " new_metric_type=\"new\",\n", + " max_concurrent=10,\n", + " parallel_metrics=True,\n", + ")\n", + "\n", + "fiqa_result.print_summary()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "======================================================================\n", + "DETAILED STATISTICAL ANALYSIS\n", + "======================================================================\n", + "\n", + "Dataset: fiqa (30 samples)\n", + "\n", + "Score Statistics:\n", + " Legacy Mean: 0.7542\n", + " New Mean: 0.7887\n", + " Score Shift: +0.0346\n", + "\n", + "Difference Statistics:\n", + " Mean |Diff|: 0.0364\n", + " Std Dev: 0.1716\n", + " Max Diff: 0.9577\n", + " Min Diff: -0.0120\n", + " Median Diff: 0.0029\n", + "\n", + "Tolerance Analysis:\n", + " < 0.10: 29/30 ( 96.7%)\n", + " < 0.15: 29/30 ( 96.7%)\n", + " < 0.20: 29/30 ( 96.7%)\n", + " < 0.25: 29/30 ( 96.7%)\n", + " < 0.30: 29/30 ( 96.7%)\n", + "\n", + "======================================================================\n", + "TOP 10 LARGEST DIFFERENCES\n", + "======================================================================\n", + "\n", + "#11: Using credit card points to pay for tax deductible business ...\n", + " Legacy: 0.0000 | New: 0.9577 | Diff: 0.9577\n", + "\n", + "#8: Intentions of Deductible Amount for Small Business...\n", + " Legacy: 0.9299 | New: 0.9501 | Diff: 0.0202\n", + "\n", + "#4: Applying for and receiving business credit...\n", + " Legacy: 0.9126 | New: 0.9284 | Diff: 0.0158\n", + "\n", + "#2: Can I send a money order from USPS as a business?...\n", + " Legacy: 0.9660 | New: 0.9810 | Diff: 0.0151\n", + "\n", + "#3: 1 EIN doing business under multiple business names...\n", + " Legacy: 0.9348 | New: 0.9487 | Diff: 0.0139\n", + "\n", + "#22: Where to request ACH Direct DEBIT of funds from MY OWN perso...\n", + " Legacy: 0.9821 | New: 0.9701 | Diff: 0.0120\n", + "\n", + "#23: Challenged an apparently bogus credit card charge, what happ...\n", + " Legacy: 0.8674 | New: 0.8777 | Diff: 0.0103\n", + "\n", + "#21: What percentage of my company should I have if I only put mo...\n", + " Legacy: 0.8675 | New: 0.8757 | Diff: 0.0081\n", + "\n", + "#18: Have plenty of cash flow but bad credit...\n", + " Legacy: 0.9158 | New: 0.9222 | Diff: 0.0064\n", + "\n", + "#25: Following an investment guru a good idea?...\n", + " Legacy: 0.9572 | New: 0.9629 | Diff: 0.0057\n" + ] + } + ], + "source": [ + "### Analyze FIQA Results in Detail\n", + "\n", + "# Get detailed DataFrame\n", + "df_fiqa = fiqa_result.to_dataframe()\n", + "df_fiqa[\"sample_idx\"] = range(len(df_fiqa))\n", + "df_fiqa[\"description\"] = [get_description(s) for s in fiqa_test_data]\n", + "\n", + "# Statistical Analysis\n", + "print(\"\\n\" + \"=\"*70)\n", + "print(\"DETAILED STATISTICAL ANALYSIS\")\n", + "print(\"=\"*70)\n", + "print(f\"\\nDataset: fiqa ({len(df_fiqa)} samples)\")\n", + "print(f\"\\nScore Statistics:\")\n", + "print(f\" Legacy Mean: {fiqa_result.old_mean:.4f}\")\n", + "print(f\" New Mean: {fiqa_result.new_mean:.4f}\")\n", + "print(f\" Score Shift: {fiqa_result.mean_diff:+.4f}\")\n", + "\n", + "print(f\"\\nDifference Statistics:\")\n", + "print(f\" Mean |Diff|: {df_fiqa['abs_diff'].mean():.4f}\")\n", + "print(f\" Std Dev: {fiqa_result.std_diff:.4f}\")\n", + "print(f\" Max Diff: {fiqa_result.max_diff:.4f}\")\n", + "print(f\" Min Diff: {fiqa_result.min_diff:.4f}\")\n", + "print(f\" Median Diff: {df_fiqa['abs_diff'].median():.4f}\")\n", + "\n", + "# Tolerance Analysis (adjust for your metric type)\n", + "# For LLM-based metrics: use [0.1, 0.15, 0.2, 0.25, 0.3]\n", + "# For deterministic metrics: use [1e-10, 1e-8, 1e-6, 1e-4, 0.01]\n", + "tolerance_levels = [0.1, 0.15, 0.2, 0.25, 0.3]\n", + "print(f\"\\nTolerance Analysis:\")\n", + "for tol in tolerance_levels:\n", + " within = (df_fiqa[\"abs_diff\"] < tol).sum()\n", + " pct = within / len(df_fiqa) * 100\n", + " print(f\" < {tol:.2f}: {within:3d}/{len(df_fiqa)} ({pct:5.1f}%)\")\n", + "\n", + "# Identify problematic cases\n", + "print(\"\\n\" + \"=\"*70)\n", + "print(\"TOP 10 LARGEST DIFFERENCES\")\n", + "print(\"=\"*70)\n", + "top_diffs = df_fiqa.nlargest(10, \"abs_diff\")\n", + "for idx, row in top_diffs.iterrows():\n", + " print(f\"\\n#{row['sample_idx']+1}: {row['description']}\")\n", + " print(f\" Legacy: {row['old_score']:.4f} | New: {row['new_score']:.4f} | Diff: {row['abs_diff']:.4f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/2y/02fp70k56p75ldrkgtx7z10r0000gn/T/ipykernel_82228/2878535787.py:59: MatplotlibDeprecationWarning: The 'labels' parameter of boxplot() has been renamed 'tick_labels' since Matplotlib 3.9; support for the old name will be dropped in 3.11.\n", + " ax5.boxplot([df_fiqa[\"old_score\"], df_fiqa[\"new_score\"]], labels=['Legacy', 'New'])\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABSYAAARpCAYAAADTK9lGAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjUsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvWftoOwAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3XdUFNffBvBnWXpXOgKigL13NJaoscQYjb1LYu81Go1dE01i7yURY6Kx5GeNRiVGDBoramJsUQGxgBQF6W3v+wfvTnZhl84C8nzO2QMzc2fm3tndmZ3v3CITQggQERERERERERER6ZBeSWeAiIiIiIiIiIiIyh8GJomIiIiIiIiIiEjnGJgkIiIiIiIiIiIinWNgkoiIiIiIiIiIiHSOgUkiIiIiIiIiIiLSOQYmiYiIiIiIiIiISOcYmCQiIiIiIiIiIiKdY2CSiIiIiIiIiIiIdI6BSSIiIiIiIiIiItI5BiaJiIioSIWEhEAmk0kvf3//ks5SoS1atEgqj7u7e0lnp0zz8fGRjmW7du10uu927dpJ+/bx8SnWfZ06dUra14QJE4p1X5SzkvzMJSUlwc7OTjp3pKSk6HT/REREpR0Dk0RERFr4+/urBdi0vbIGOHJaphQbG4uVK1eiffv2cHBwgKGhIaytrVGnTh2MGzcON27cyFMe69Spo7Y/JycnpKen57usu3btylauyZMna0y7bdu2bGkXLVqU732WFm9j0PH69evZ3qOZM2eWdLbKDSEE5syZAwCQy+WYMWOG2vKDBw9i0KBBqF27NmxtbWFgYABzc3PUrFkTI0aMwM2bN7Vu+/r16xgwYACcnZ1hZGQEBwcHfPjhh/jtt9+KtUxUMCYmJlJg+smTJ9iyZUsJ54iIiKh00S/pDBAREZU3Z86cweDBgxEVFaU2PzY2FrGxsbhz5w62bt2K8ePHY+3atTAwMNC4nWvXruHOnTtq88LDw3Hq1Cl88MEHhc7nrl278MUXX8DCwkJt/vr163Ncr2LFivjmm2+kaQ8Pj0LnpaR16tQJ5ubmAAArK6sSzk3ufH19s83bs2cPVqxYAX398vvzb9y4cdJ3o06dOsW2n8OHD+PWrVsAgA8++ABVq1ZVW/7999/jxIkTavPS09Nx//593L9/H7t378b+/fvRq1cvtTTffvstxowZA4VCIc2LiIjA8ePHcfz4cSxYsACLFy8unkJRgU2YMAFffPEF0tPT8eWXX2LcuHEwMjIq6WwRERGVCuX3lykREVE+9e/fH02aNMk2Pz8BjosXL6J79+5ITU0FkFmbqk+fPqhbty6ioqJw4MABvHjxAgCwefNmpKamYseOHRq3tWvXLq3ziyIwGRcXB19fX7Wak7/99hvu3r2b43qWlpY6rZ2XkZGBlJQUmJqaFts+WrZsiZYtWxbb9otSSkoK9u3bl21+UQaty6r+/fvrZD9bt26V/h8wYEC25aampmjXrh3q1q0Le3t7pKen4+LFi1Ktx/T0dMydO1ctMHnz5k2MGzdOCkq2aNECH3zwAS5evIhff/0VALBkyRI0a9YM3bp1K87iUT7Z2dmhffv2OHPmDCIjI3Ho0CEMHDiwpLNFRERUOggiIiLS6Ny5cwKA9PL19c3TeqrrDB8+XJqfkZEhatWqJS2Ty+Xi3LlzauvGxMSI+vXrq23jwoUL2faRnJwsKlSoIKWpVq2a9L+hoaGIiorKV1l9fX3V9qmnpycACC8vL6FQKKR0H3zwgZR31fQLFy6U0gQHB6sty1rGqKgoMXbsWOHg4CCMjY1F48aNxYEDB7Id7+DgYGmd4cOHS/Pbtm0rnjx5IoYMGSLs7e2FTCYThw8fFkII8d1334m+ffuKGjVqCBsbG6Gvry8sLCxE/fr1xaxZs0RkZKS0zaz70/RSvucLFy6U5lWuXDnb8Xv16pVYvHixaNy4sbC0tBQGBgbC2dlZfPTRR+LMmTO5Hu/k5GSxbNky4eXlJQwNDUWlSpXEjBkzRHJycr7eRyGEOHDggLRdmUwmvLy8pOnevXtrXCfr8X3x4oUYNWqUcHR0FIaGhqJGjRpi+/bt2dY7d+6c+OSTT0TDhg2ltCYmJsLDw0P4+PiIv//+O9d9CSHEo0ePpM8cAHH69Ols6zVp0kRaPnbsWGn+0aNHRefOnYW9vb30fletWlX06NFDfPnllyIjI0NK27ZtW43fTSGE+OOPP0TPnj2Fs7OzMDAwEGZmZqJy5cqiS5cuYuHChSImJiYvh1+EhoZKZTE0NBTx8fF5Wk8IITp27Cjlz9jYWG1Z3759pWVVqlQRKSkp0rJWrVpJy5o1a5bn/fn6+oq2bdtK3xVra2tRrVo10a9fP7Fp0ya1tIcOHRJDhgwRdevWFfb29tIxqlmzppgwYYLa91Up6/G+cuWK6NChgzAzMxP29vZi/PjxIi4uTgghxP79+0WjRo2EsbGxcHZ2FtOnT8/2+c/6PXz9+rWYPHmyqFSpkjA0NBQ1a9YUGzZsUDtnCaH5M6cqPDxczJkzR9SvX1+Ym5sLIyMj4eHhIcaPHy+ePHmSLX18fLxYvHixaNiwoTA3Nxf6+vrCzs5O1K9fX4wcOVL8+uuv2dbZvn27lIeOHTvm9tYQERGVGwxMEhERaVHUgUl/f3+1ZUOGDNG4/unTp7VuQ2n//v1qaS5duiQMDAyk6fXr1+errFkDZT179pT+P3HihBBCPXj00UcfFSgw+fr1a1GjRg2NQcDu3bvnKTDp5eUlHB0d1dIqA5ONGzfOMdBYqVIl8fz5cyFE0QUm7969K1xcXHLczpQpU3I83u+8847G9YYOHZqv91EIIbp27Sqt37JlS7Fu3TppWlvQWvX4Vq1aVTg5OWnMz3fffae23owZM3Ist6GhofDz89O6L9UgUbdu3aT5ffv2VVsnKChIbbtXr17VeBw1vZKSkqTtaAtM/vbbb9mC7Vlf9+7dy9Px37lzp7ROkyZN8rRObGysOHXqlLC3t5fWbdy4sbQ8PT1dmJmZScsmTZqktv6qVavU8hoeHp7rPlU/05peDg4Oaul79+6dY3pLS8tsgWjV4127dm1hZGSUbb127dqJlStX5unzr5pnOzs7UadOHY3rZT0+OQUm//zzT2Fra6u1XFZWVuKPP/5QW6ddu3Y5Hov+/ftnO963b9+WlhsZGRXooQMREdHbiE25iYiI8ujUqVPZ+oUEMpuHurq65rp+QECA2nTfvn01puvUqROsra0RExMDALhw4UK2NKrNuBs1aoQWLVqgY8eOUpPOXbt2YdKkSbnmSZtx48bhxIkTSEtLw/r16/H+++9j48aNUjPSyZMn4/Dhw/ne7rx583D//n1p+p133sG7776LgIAAHD9+PE/bePjwIQCgV69eqF+/Pp48eSL1+2hvb4/u3bvDw8MDFStWhFwux/Pnz7F//35ER0fj+fPnWLZsGTZv3gwPDw988803OHPmDPz8/AAAFSpUwNy5c6V9NW3aNMe8pKen46OPPsKzZ88AZDbNHzp0KFxcXHDkyBH8888/AIB169ahUaNGGDZsmMbtXLhwAR999BFq1aqFPXv2ICQkBMB//UI6Ozvn6diEhYXhzJkz0vSAAQPQt29fTJs2DQqFAqmpqdi7d2+On42goCAYGxtj3LhxMDExwZYtW5CUlAQA+Prrr/HJJ59Iac3MzNC2bVvUrVsXFStWhImJCaKjo3HixAncu3cPqampmDx5cq7N/wFg0qRJUr+LR48eRVRUFGxtbQFkDhajVLt2bel9UR1IpGnTpvjggw+Qnp6Op0+f4sqVK7h3715eDhu2b9+OjIwMAECNGjXQt29f6OvrIzQ0FLdu3crzYFSA+vdcU9cPqlxcXPD8+fNs862trbFu3Tpp+vHjx0hISJCms/ZZmXX677//xnvvvZfjvlWPXceOHdGuXTskJCTg6dOnuHDhgvSeq+apU6dOqFmzJipUqABDQ0O8fPkShw8fRmhoKN68eYPZs2fj5MmTGvd3584dVK5cGYMHD8bVq1elZuv+/v7w9/eHp6cn+vfvj9OnT+P69esAcv78R0ZG4s2bNxg7diysra3x448/St/DDRs2oHfv3mjbtm2Ox+DNmzfo2bOndF6vXLky+vfvDxMTE/z888+4c+cOYmNj0bt3bzx8+BBWVla4d+8e/P39AQB6enoYNmwYqlWrhqioKAQHB0vLsqpZsybMzMyQkJCAlJQUXL16Fa1bt84xf0REROUBA5NERER5tH//fuzfvz/b/CZNmuQpMKnsO1KpcuXKWtNWrlxZCkyGhYWpLcsafFL2VTZw4EApMHnjxg3cvn0bdevWzTVfmjg7O6Nv377Yu3cvzpw5g8DAQOzcuRMAUK9ePbRr1y7f20xPT8f3338vTbds2RL+/v6Qy+VQKBTo2LEjzp07l6dtrV27FlOmTMk2/+TJk0hMTMSlS5cQFBSE+Ph4VKlSBe+88w6OHj0KADh9+jQAwNXVFTNnzkR8fLwUmMxv/5i//PILHjx4IE1v2LAB48aNAwDMnTsXNWvWxJMnTwAAq1ev1hqYnDp1KtasWQMgM2DdoEEDAIBCoUBgYGCeA5M//PCDFGCTy+Xo168fHBwc0K5dO/z+++8A8ha03rdvH3r06AEAcHNzw9SpUwEADx48QFxcnDQg0uLFi6FQKHD9+nXcu3cPMTExcHBwQNeuXaWg4L179/D06dNcvyOdOnVCtWrV8O+//yI1NRW7d+/G9OnTAQAHDhyQ0qkGRpOTk6X/169fjxYtWqhtMyQkBIaGhjnuN+t2Fi5cmK1fyPDwcFhaWua6HSAziKiUl/NCVlWrVsWBAwfQuHFjad6rV6/U0mTNS9YBqqKjo3Pdj2qZf/jhBzg6OqotDwoKUpv+9ttvkZaWhsuXL+Phw4d48+YNXFxc0KFDB2mwpd9//x1paWkaB+wyMDCAv78/3N3dkZiYCCsrK6SnpwMADA0Ncf78eTg7O2Po0KGoUaMGgNw//zt37sSgQYMAAGPGjEG1atWQlpYGANixY0eugcldu3YhIiICQOZDiRs3bqBixYoAgE8//RRVqlRBZGQkIiMj8f3332Py5Mlqx6169erYuXMnZDKZNC8jI0MKkKqSy+VwcnLCo0ePAGR+ThiYJCIiYmCSiIioxJiYmOQpnTLQpKQafJLJZNKAHj179oSxsbF04+zr64vVq1cXOH9TpkzB3r17IYRAjx498ObNGwAocE3M+/fvIz4+XpoePHgw5HI5gMyaR8OHD89TYLJChQqYMGGCxmWrV6/GwoUL1faTlaagQUFdunRJbVo18GhiYoJ+/fpJI5T//fffSExM1DhIz/jx46X/q1evrrbs9evXec6Pak3adu3awcHBAUBmzUllYDK3oLWzs7MUlNSWH2UgzM/PDyNHjkRoaGiO+Xr27FmuQTqZTIaJEydKgy19++23mD59OoKDgxEYGAggM7g1ZMgQaZ3WrVvj77//BgC899578Pb2hpeXF2rVqoU2bdrkOTDfunVrHDt2DADg4+ODbdu2oVq1aqhevTpatWqFZs2aqQWfchIZGSn9rwxyaTN//nzExsYiKioKZ8+exY0bNxAUFISWLVvi22+/xdChQzWuJ4TIcTovWrduLdVQrVOnDpo3bw4vLy/Url0b7777Ljw9PdXS79mzB1OnTtVYa1wpJSUFUVFRcHJyyrasVatWcHd3B5A5+I+dnZ300KVVq1ZS8NHDw0NtPW2ffwMDA7XBjNzd3fHOO+9I5xDlZyYnFy9eVNuPjY2N1rR//vknJk+ejJo1a8LGxgbR0dG4d+8ePD090bBhQ1SrVg316tVDx44dtT50srGxkQKTqp8TIiKi8kyvpDNARERUVvj6+kJk9s+s9spr7cGsNZJyCuYoa9kBmc09VakGn1q2bCkFfCwsLNRG492zZ49UI6kgmjVrhubNmwOA1NzUxsYGgwcPLtD2lDVAlbIej6zT2nh4eEBfP/uz1SNHjmDGjBk5BiUBSCOiFwXVmmzm5uYwMzNTW64MDAKZwaOsx0BJGbABACMjI7VlyubzucnadFm11l/v3r3VarEpa7jllpec8vPixQv07Nkz16AkkBmwygsfHx8p6Hnv3j1cvHhRrbZkt27dYG9vL01/+eWX6Nq1KwBINV83b96MiRMnSjV7VZtAazN16lQMHToUcrkcKSkp8Pf3x/bt2zFjxgy0aNEC9erVy1ZzuSiMGTMGs2bNwtdff43AwECpNmhqairGjBmD8PBwAMgWMIuLi8txWtkEPidbtmyRaphGR0fj5MmTWLduHUaPHg0vLy/0799feq9v3LiBYcOG5RiUVNL2Xmet9ahak1V1WdbvtrbPv42NjfRgQ0n1+6btu6Yqa03UnCgDicbGxjhw4ADc3NwAZNYs/d///ofly5dj4MCBqFSpktYHQgUJIBMREb3tGJgkIiLSkazN9pS1lbLy8/NTu6lWXS9r8OnixYuQyWTS63//+5+0LCIiQmt/b3mVtbn0qFGj8lzTMytra2u1aWUTSiVlECY3WYN/SqrN7M3NzXHmzBkkJSVBCIFNmzblL7N5pFojLj4+PlsQ7OXLl9L/Mpks2zFQUg0a5rVmXlaqAWsg871Sfi5sbGykJq5AzkHrrM1wteXn+PHjSExMlKZXrVqFmJgYCCFw586dApXBwsICPj4+0vS3336r1r/kxx9/rJbe0tISJ0+exNOnT3Hw4EF88cUXGDx4sFQr9fz58/j6669z3a++vj52796NsLAwHDlyBF999RU++eQTVKhQAQDwzz//4LPPPstTGVSDgvmp7QpAraZqUlISrly5AiCzebfq5z5rM2vV5uMA8lRT1NXVFZcuXcLDhw+xZ88eLFq0CL1795YCgwcOHJC6Xjh48KAUIJTJZPjpp58QHx8PIYTW81hWmpp3K2l60JCb6OjobLXJVb9v2r5rqlS/v05OTvjmm2+0vkaPHi2lbd++PYKDg3Ht2jXs2LEDs2fPls7Tqamp+PTTT6WakapUA6F2dnZ5LisREdHbjIFJIiIiHWnTpo1as9itW7dKgQcl5QASqsaOHSv9nzX4lJv8ps+qT58+Um0mfX19tSbH+VWjRg2Ym5tL0/v375dqEAkh1PqfLAjVfvWqVq2K9957D8bGxlAoFPj555+1rqcaMFENtOVFy5Yt1aZ3794t/Z+UlKRW269+/foam3EXheTkZOzbty/P6YsiaJ21H8OPP/5YGoRItdz5NXHiRCkY+tNPP0lNch0cHPD++++rpf3nn3+QlpYGFxcX9OnTB3PnzsWPP/6IkSNHSmnyMnDNgwcPkJiYCDs7O/To0QOzZs3Cd999h/nz5+drO4D6QDRPnz7NtvzRo0daBwPKGuRTHge5XK5WG/qXX36Rav4KIdQ+382bN1erOajNX3/9BYVCAU9PTwwaNAgLFy7Ezz//rHaMlWVWfa+trKzQr18/KVBamPe6MNLS0tQeRoSEhKgNFKbaR6c2qt/fyMhIdOrUCTNnzlR7zZgxAw0aNECzZs0AZH7X7t27Bz09PTRp0gQjR47EihUrcP78eenzr1Ao8Ndff6ntKyMjQ62f4awDFhEREZVX7GOSiIhIR+RyObZv346OHTsiLS0NycnJaN26Nfr164datWohKioKBw4cUBul9/PPP5eaU2cNPlWpUkW6WVZ1+/ZtKfDxyy+/qI1unF8GBgY4fvw4QkNDYWVlVaDBPJT09fXh4+ODjRs3Asgcjbd9+/Zo06YN/vjjD62j2eZV9erVpUFs/v77bwwcOBA1a9bEr7/+isuXL2tdr1KlStL/kZGR+Pjjj1GrVi3IZDJMmDAhxxqi3bp1Q/Xq1aUBcCZNmoRr166hUqVKOHLkiFqT/GnTphWqfDk5cuSIWi3b9u3ba6yRdezYMWm0ZV9fX3z44YcF3mfWvie7deuGrl274u+//84xEJybatWqoVOnTjh9+rRas+ChQ4dmq1k3c+ZMXL16FR06dICrqyvs7Ozw4sULtabqeak5t2bNGvzwww/o0KEDqlSpAgcHB7x69Uot0JyX7QCZ/SUqg+yagpn//PMPPvroIzRq1AitWrWCk5MT3rx5g/Pnz6v1WWphYYE2bdpI05999hkOHTqE9PR0BAcHo127dujWrRsuXLig9oBDNZiak/79+yM2NhbvvvsuKlWqhIoVK+Lx48dqAWtlmVXf65iYGHTr1g0tW7bEhQsX1Abi0rVPPvkEAQEB0qjcqrWCVYPT2vj4+GDZsmWIiopCeno6WrVqhb59+8LT0xMpKSl48OAB/P398fLlS5w7dw5VqlRBTEwMatWqhdq1a6NZs2ZwdnaGiYkJLly4gNjYWGnbWT8v9+7dkx58GBoaajx3ExERlUuCiIiINDp37pwAIL18fX3ztJ7qOsOHD8+2/OTJk8LGxkYtXdaXXC4Xs2bNEgqFQlrvp59+Ukvz448/atz/2bNn1dKtXbs21zz7+vqqrXP79u18lXPhwoXS/ODgYLVl586dk5a9fv1a1KhRQ2OZu3btqjb95MkTab3hw4dL89u2basxPw8fPhQWFhbZtquvry8GDx6sNk9VWFiYMDU11ZinyMhIIYQQCxculOZVrlxZbf27d+8KFxeXHN/PyZMn53i8czq2efncde7cWUpvaWkpEhISNKYbOnSolM7AwEAqX07HN+v3IDg4WAghRGpqqqhbt67G8qpuL+tnIC/v5S+//JJtm3fu3Mmx3JpexsbG4urVq1L6tm3bavxujhkzJsft6OnpicOHD+f6PgghRFBQkJDJZNL+s74Xhw8fznFfAISpqak4evRotm1v375d6OnpaV1v/vz5ecqjEEJUr149xzxUrFhRhISECCGEiI6OFs7Oznl6r5Wfj5yOtxBCVK5cWesybZ9/1e+hg4ODaNy4scY8jR8/Xm17OX3mLl68KGxtbXN9T5Sf4bCwsFzTNmvWTKSlpWV775TLO3TokOf3iYiI6G3HptxEREQ61rVrVzx+/BgrV65Ehw4dYG9vn63/NV9fX3z11Vdq/fupNsu2srJCr169NG7/3XffVRvApLDNuYuStbU1AgICMGbMGNjb28PIyAj169fH7t271Ua0VqbND09PT/zxxx/o1KkTTE1NYW5ujrZt2+Ls2bPo2LGj1vUcHR1x/PhxtGrVSmv/lTmpWbMm/vrrLyxatAiNGjWCubk59PX14eTkhI8++ginT5/GunXr8r3dvHr+/LlUUxTIHPRGW5Nx1T4a09LSsGfPngLv18DAAL///jt8fHxgY2MDIyMj1KlTB9u3b8eiRYsKvF0AeP/999VGhW7evDlq1aqVLd2nn36KKVOmoEWLFqhUqRIMDQ1hZGSEqlWrYvjw4bh69SqaNm2a6/5GjBiB2bNno02bNnB1dYWxsTEMDQ3h6uqKvn374vz58+jZs2ee8l6lShVpQKzk5ORszbObNm2KBQsWoH379nBzc4OpqSn09fVhY2MDb29vfP7553jw4IHG2qyjRo3C5cuX0a9fPzg6OsLAwAC2trbo1q0bzpw5gyVLluQpjwCwfPlyjB07Fo0bN5a2ZWpqiho1amD8+PEIDAyURpeuWLEiLly4gF69esHS0hImJiZo2rQpDh06pNYnqC4ZGxvj3LlzmDZtGlxcXGBoaIjq1atj3bp1Uq3svGjZsiXu3LmD+fPno3HjxrC0tIRcLoe1tTUaN26MiRMnws/PT6q9WqFCBWzcuBEDBw5ErVq1ULFiRcjlclhaWqJJkyZYunQpzp49m612r2otYuUgR0RERATIhODwcERERKXBypUr8emnnwLIDJZduHABHh4eJZyropeUlKSxeXSfPn2kwXu8vLzw77//6jprVIp06dIFp0+fBpDZH+uYMWNKOEd5d/DgQfTr1w8A0KtXL7VBqajgFi1ahMWLFwMAKleujJCQkJLNUB5FRkbC2dkZ6enpsLW1xdOnT2FsbFzS2SIiIioV2MckERFRKTFz5kzExMTgiy++QHh4ODp27IiLFy9Kg8+8LapXr47OnTtL/bNFRETg559/VuvbbvLkySWYQyop9+/fx/Pnz3H58mWp70Jra2sMHjy4hHOWP71790a9evXw999/49ixYwgJCVGrxUzly6ZNm5Ceng4AmDt3LoOSREREKlhjkoiIqJTZtm0bwsLCAAC1atWSal69LaytrdUGichq1KhR2LZtm1ozdioffHx8so3OvmnTpkKNBl9Sfv31V2mE6wkTJuSreTFpVhZrTCYlJcHNzQ1RUVFwc3PDv//+CyMjo5LOFhERUanBGpNERESlTFlqsloQc+bMwalTp3D//n28evUKenp6cHJyQosWLTBixAh06NChpLNIJczIyAienp6YNm0aRowYUdLZKZCuXbuCz//JxMQEkZGRJZ0NIiKiUos1JomIiIiIiIiIiEjnOCo3ERERERERERER6RwDk0RERERERERERKRzDEwSERERERERERGRzjEwSURERERERERERDrHwCQRERERERERERHpHAOTREREREREREREpHMMTBIREREREREREZHOMTBJREREREREREREOsfAJBEREREREREREekcA5NERERERERERESkcwxMEhERERERERERkc4xMElEREREREREREQ6x8AkERERERERERER6RwDk0RERERERERERKRzDEwSERERERERERGRzjEwSURERERERERERDrHwCQRERERERERERHpHAOTREREREREREREpHMMTBIREREREREREZHOMTBJREREREREREREOsfAJBEREREREREREekcA5NERERERERERESkcwxMEhERERERERERkc4xMElEREREREREREQ6x8AkERERERERERER6RwDk0RERERERERERKRzDEwSERERERERERGRzjEwSURERERERERERDrHwCQRERERERERERHpHAOTREREREREREREpHMMTBIREREREREREZHOMTBJREREREREREREOsfAJBEREREREREREekcA5NERERERERERESkcwxMEhERERERERERkc4xMElEREREREREREQ6x8AkERERERERERER6RwDk0RERERERERERKRzDEwSERERERERERGRzjEwSURERERERERERDrHwCQRERERERERERHpHAOTREREREREREREpHMMTBIREREREREREZHOMTBJREREREREREREOsfAJBEREREREREREekcA5NERERERERERESkcwxMEhERERERERERkc4xMElEREREREREREQ6x8AkERERERERERER6RwDk0RERERERERERKRzDEwSERERERERERGRzjEwSURERERERERERDrHwCQRERERERERERHpHAOTREREREREREREpHMMTBIREREREREREZHOMTBJREREREREREREOsfAJBEREREREREREekcA5NERERERERERESkcwxMEhERERERERERkc4xMElEREREREREREQ6x8AkERERERERERER6RwDk0RERERERERERKRzDEwSERERERERERGRzjEwSURERERERERERDrHwCQRERERERERERHpHAOTREREREREREREpHMMTBIREREREREREZHOMTBJREREREREREREOsfAJBEREREREREREekcA5NERERERERERESkcwxMEhERERERERERkc4xMElEREREREREREQ6x8AkERERERERERER6RwDk0RERERERERERKRzDEwSERERERERERGRzjEwSURERERERERERDrHwCQRERERERERERHpHAOTREREREREREREpHMMTBIREREREREREZHOMTBJREREREREREREOsfAJBEREREREREREekcA5NERERERERERESkcwxMEhERERERERERkc4xMElEREREREREREQ6x8AkERERERERERER6RwDk0RERERERERERKRzDEwSERERERERERGRzjEwSURERERERERERDrHwCQRERERERERERHpHAOTREREREREREREpHMMTBIREREREREREZHOMTBJREREREREREREOsfAJBEREREREREREekcA5NERERERERERESkcwxMEhERERERERERkc4xMElEREREREREREQ6x8AkEWnk7+8PmUwGmUwGHx+fYtnHokWLpH3s2rWrWPZBRFRU3N3dpXNWVmvXrkWNGjVgZGQEmUyGBg0aSMvOnDmD5s2bw8LCQlo/JiZGdxkvB3RxzcqJtutZTp+Z4lbSx4SorGjXrp30XQkJCSmRPLztv4lzOh+Fh4djyJAhcHZ2hp6eHmQyGdauXQsASE1Nxfz58+Hh4QEDAwPIZDL07NlT5/l/2/n4+Ejvj7+/v873r+laWdLXsJI+JlkJIVC3bl3IZDKMGjWqpLOTzZ49eyCTyWBsbIxnz57le30GJkknnj17hlGjRsHd3R2GhoawsrKCp6cnunfvjiVLlpR09orcs2fPMGvWLNSvXx+WlpYwMzNDzZo1MXz4cJw9e7aks6czMTExWLRoERYtWvRW/sgiorJJ9QZQJpPBwMAA1tbWqFmzJgYMGIBTp07la3v79u3DtGnT8ODBA6SmpqotCwkJQY8ePXD16lXEx8cXZTHeWqo3KHp6ejAyMoKDgwOaN2+OWbNmFUvg4NatW9L1qjTcgOTV2rVrpXwTkbqxY8eqnetXrFhR0lkqdrt27ZLOCcX1AKyoz9E+Pj7Ys2cPwsLCIIRQW7Z69WosW7YMQUFBSE9PL8JSvJ1Ug3kymQxyuRzm5uaoUqUKunbtih07diA5ObnI96uLz11RCwkJkfJ85MiRks5Orvbv349//vkHADB16lRp/q5du6T3u127diWTOQD9+vWDs7MzUlJS8MUXX+R/A4KomIWFhQknJycBQONLLpeXdBaL1M8//yzMzMy0ltfKyqqks5gn586dk/I8fPjwAm0jODhY2kbbtm2zLX/y5IkICAgQAQEB4uXLl4XLMBFRHi1cuFDrOVr56t69u3jz5o3aeteuXZPOWaoGDx4srbdgwQIREBAgbt68KYQQYseOHdKynj17Cn9/fxEQECDS09N1Vdwyp3Llyjm+NwYGBmLbtm1q68TExEjvzb///pvvffr6+krbX7hwYb7X13Y9Uy1Lcchp+4U9JkRlWWpqqrCxsVE7d9SvX19j2rZt20ppgoODdZpPJdXrkq+vb4G3o4uyFOU5OiUlRejp6QkAwsbGRvzyyy8iICBAPH/+XAghRKtWraTtbt68WQQEBIi7d+8WS7neBqr3b9pe1atXF/fv31db799//5Xen5iYmHzvt7CfO02/r4riXjQnuW2/sMekqDVu3FgAEC1atFCbr/r7RdP9ti7NmTNHABCGhoYiOjo6X+vq5z+USZQ/GzZsQFhYGACgQ4cOmDBhAszNzRESEoKrV6+W+BOKhIQEmJmZFcm2Ll26hIEDByItLQ0A0KxZM0yYMAGurq548eIFfvnlF/j5+RXJvlTlVoaiLGNRcnNzg5ubW0lng4jKsa5du2Lu3Ll49eoVfvvtN2zbtg2pqak4fvw4hg4dqnaNatKkicZtvHjxQvrfx8cHVapU0bjsww8/RNu2bYu8DImJiTA1NS3y7ZYG69evR926dfHkyRP4+vri/PnzSEtLw5gxY2BnZ4ePPvoIAGBlZYV33nlH5/lTXl9L4/WspI4JUWng5+eH6OhotXl//fUX7t+/jxo1apRQrt4+hT1Hh4eHQ6FQAABq166Nbt26qS1XvYYqa8AWpdJ6j1QUHB0dcfDgQSQkJCAwMBDr16/Hy5cv8eDBA3Tp0gU3b96EtbU1AMDLywteXl46z6Py+Gv7fVWSSuqYaHL79m0EBgYCAHr37l3CudGuV69eWL58OVJTU7F3715MnDgx7ysXU7CUSNKlSxcpiv/3339nW56QkJBtXnR0tPjss89EzZo1hYmJibCwsBANGzYUGzZsUEv38OFD4ePjI1xcXISBgYGoWLGi6Nq1q/jtt9/U0mV9IvK///1P1K9fXxgaGqrVjPjjjz9E9+7dha2trTAwMBDu7u5i2rRp4tWrV3kqq7e3t7Qfb29vkZqami1N1qd8YWFhYtKkSaJq1arC0NBQWFlZibZt24oDBw6opcta+/D8+fOiRYsWwtjYWHrKo/oE88mTJ6JXr17C0tJSuLu7S9uJiIgQ06ZNE56ensLQ0FBYW1uL999/X1y6dCnHY6Z0/vx50adPH+Hp6SmsrKyEgYGBcHJyEn379hV//fWXlG748OFan9Qpn+bk9HQ4MDBQ9OnTRzg4OAgDAwPh4OAgevfuLa5fv66WLmstlx9++EHUrl1bGBoaCi8vL7F///4c3zMiKn9Uzz1Zn5IfP35c7Xylej3JWjstp5oJOZ0DK1euLG0zKChIjBw5Uri5uQlDQ0NhZ2cn+vXrl+1akfVct2XLFlGtWjWhr6+vdv48cuSI6NChg7C2thaGhoaiWrVqYtGiRSIxMVFte6q1G/766y8xceJEYWdnJ4yNjUWXLl1ESEhItuN26dIl0adPH+Hk5CSdl7t27SrVDs1vHrRRPc7nzp2T5isUCtGnTx9pmbu7u0hLS8v2Xqi+p1FRUWLMmDHCzc1NGBgYCHNzc+Hl5SUGDBgg/P39s+0v60v5G0H1eAUGBoqPP/5Yqo0lhPbrmeq2IyMjxbBhw4S1tbWwtLQUgwYNUqtdmVMrg6yfPdXPg6ZXTsdEiIL/9rh69apo166dMDExEQ4ODuLzzz8XGRkZeXpfiXRp6NCh0md3wIABOdaIVv1+37lzR0yePFnY2dkJU1NT0a1bN/Ho0SO19Ldu3RIffvihsLOzE/r6+qJixYqifv36YsyYMeLJkydqac+ePSvef/99YWNjIwwMDISLi4sYPnx4tlrM2s4hmq4bWfMcHByca0051VpspeUcndN1MqdznOp7WJBrnqZzuBBCxMXFiYULF4ratWsLY2NjYWFhIdq2bStOnjyptq2CnBfT09PFpk2bRIsWLYSlpaUwNjYWnp6eYvTo0Wrp8poHbVSPc9bPzNOnT4WVlZW0fN68edIy1fdC9T09d+6c6NChg6hQoYLQ19cXtra2omnTpmLy5MkiJiYmT5+7/N7DairL8OHDxdmzZ0XTpk2FkZGRcHd3F2vWrFErn7bvkKbPnurnQdPvt5yOiRAF+17v3LlTrFmzRnh4eAhDQ0NRr149cfbs2Ty9r4sXL1b7zaYqvzUm83qPLYQQISEhokePHsLMzEzY2dmJyZMnizt37uS4vwoVKggAon379nkqmxIDk1Ts+vbtK314P/zwQxEQECBSUlK0pg8NDRVubm4aTxSqH/4rV64ICwsLjelkMpnYvHmzlFb1hFSlShUhk8myXdx27NghNSXI+qpevXquwcnQ0FC1dZQ3PDkJCgoSjo6OWk+Ms2fPltKqntSdnZ2FsbFxthOo6km9atWq2S5MT548ES4uLhr3ZWBgII4eParxmKne0Cxfvlxrfk1NTaWb6cIEJo8ePSoMDAzylE/Vk7FqmZUvPT29bM0ViKh8yykwKYQQHTt2lJaPGDFCml/UgcnAwEBhbW2tMY25ubm4cuWKtO+cznXK8+f8+fO17rN169Zq117VH+Wazp2tWrVSOyY7d+4Ucrlc47ZVz9/5yYM22m56hci81qpeq5XNvrRds9q3b681P59//nm2/WV9aQpMZj1eQuQtMFmvXr1s269Xr55ITk4WQuguMFnQ3x5OTk7CxMQkW/odO3bk+p4S6VJSUpJ0j2BnZyfCw8OFvr6+ADJ/02el+v3W9D2tVKmSiIqKEkJkPuyws7PT+v3x8/OTtrtp0ya1ew7Vl4WFhbh69aqUVleBydJ0ji5sYLKornlCZDY1r1u3rtbtbdq0SdpWfs+LqamponPnzjmer/ObB21yCkwKIcSyZcuk5R4eHtJ8TUG4+/fvayyb8vXw4cN8Bybzcg+rqSw1a9bUeG+4fPlyKb2uApMF/V5r+q1lYWGRpwpQnTp1EgCEsbGxFOxXyk9gMj/32K9fv9b4+6h+/fo57k/5u8vMzCxf3RZx8Bsqdh07dpT+P3bsGFq3bg0LCwu88847WLVqFRISEtTSjx8/HqGhoQAym/pu374dp06dwtdffw1XV1cAgBACH3/8MeLi4gAAffr0wYkTJzB//nzo6elBCIGpU6fi6dOn2fITHByMJk2a4ODBgzhy5Ahat26N58+fY+LEiVAoFLCwsMCGDRtw+vRpfPzxxwCABw8eYO7cuTmW86+//pL+l8vlaNmyZa7HZvz48QgPDweQOSLgsWPHsHr1ahgbGwMAvvrqK1y5ciXbei9evICLiwt+/PFHnDx5UuPodC9fvsTq1atx5swZKe/jx4+XRskaNmwYTp06hS1btsDc3BxpaWn45JNPsr0fWTVr1gwbNmzAsWPHcO7cOfj5+eGrr74CkNmccM2aNQCAzz//HAcPHpTWa9CgAQICAhAQEIANGzZo3X5CQgJGjBghNYcfN24cTp48ifHjxwMA0tLSMGLECI35DAoKwogRI/DLL7+gQ4cOAACFQoFvv/02xzIREany9vaW/r9165bWdA0bNkRAQIDaCNwHDx5EQEAAPv/8cwQEBEjXEQCYO3cuAgIC8PPPP0MIgeHDh0udxM+YMQNnzpzBV199Bblcjvj4eHz88cfZBgIAMs91nTt3xpEjR3DgwAHUrl0b165dw9KlSwEATk5O+O6773Dq1CmpWVxAQIB0fs4qMjISW7duxY8//ig167p48SLu3LkDAHj+/DnGjRuHjIwMAEDPnj1x+PBh/Pzzzxg1ahQMDQ0BoFB5yCtXV1dUqlRJms7p/YmLi8O5c+cAZL5Xx44dw6+//oqtW7eid+/eUvO9n3/+We0a//HHH0vXq08++STbdkNDQ7Fw4UKcPn06X+WJj4/H/v37sWvXLtja2gIA/v77b2zfvj3P21B6//33ERAQAEdHR2meMs8BAQE5rlvQ3x5hYWFo1KgRjh49ismTJ0vzt23blu/8ExWnX375RbpH6NmzJxwcHKRBIR48eICbN29qXffFixfw9fXFwYMHUbVqVQCZ58Avv/wSQGa3TZGRkQCAgQMHws/PD0eOHMHKlSvRtm1byOVyAMDTp08xbdo0CCGgp6eHefPm4cSJE+jbty+AzPOTj4+PxnN8QeR0PQoICICTk1OpO0fndK/w7rvvaj3HffLJJ4Uqi6Zz+Oeff47bt28DyDy/njhxArt375b2P23aNI33lXk5L65fvx6nT58GAJiammLp0qU4deoUduzYgaZNm6odj4LkIT9Uf988fvw4x0H5/Pz8kJSUBACYMmUKzp49i59//hnLli1DkyZNIJPJ8vS5U5WXe1hN7t27h759++LEiROYNm2aNH/RokWIiorK0zZUbdiwAevXr5emu3btKuX5888/17peYb7XQUFBmD17No4dO4b69etL6ffu3Ztrfu/duwcAqFy5MvT1C9YbY37vsb/++ms8efIEQGZMZt++ffD19c11xG1PT09pf8r18yTPIUyiAkpPT1cbGCDry8PDQ3pSEB0dLT1lk8vlWjs3vnHjhrS+o6OjWpPp3r17S8uUVbxVn5SYm5tn64x1zZo10vKPP/5Y6uj2jz/+EKampgLIHLQmp+ZKP/74o7QNBweHXI9LdHS09LTFyMhIehIrhBAzZsyQtjVlyhQhhPrTOW21AFWfamzfvl3r/hwdHaUyBgQEiI8++kha7+eff852zFRrWiQkJIhFixaJunXrSsdG9dWwYUMpbW6D32h6snXo0CFpXuPGjdXSKzv9BSAOHz4shFB/SqTaqfnly5el+T179szt7SCiciS3GpObN2+Wlnt6ekrztQ00klOn79qe4N+8eVOa36BBA7Vzsmq3IMqmNarnusqVK2d7Yj5lyhRp+dy5c6VtqTZNr1OnjsY8qzaHGjt2rDT/yJEjQgj1a2TLli21Htf85kGbnGrjCCFEs2bNpOXLli0TQmi+ZiUmJkq/Kd577z1x9+7dbMdNKbfBb1SP19y5c7Mtz0uNSdWaVKqDIimbO+WnxmRu87Udk8L89jA0NBTh4eFCCCEyMjKk3wDW1tYajylRSVG9Fzh9+rQQQoitW7dK82bNmqWWXvX7rVrTzc/PT5pftWpVIYQQp06dUttOaGioUCgU2fKwevVqKV3v3r2l+ampqWo1lpVdYRS2xmRu84UofedoIXK/V9B2jivMNS/rOTwjI0NqfmpoaCh+++03aXvjx4+X1lu5cmW2POflvKhawyzroEAFzYM2udWYvHv3rrQcgHj27JkQQnPtQNXvzNq1a0VYWJjW/eb0ucvvPaymsri5uanVvlMdFGn37t1CiPzVmMxpvpKmY1KY73WPHj2k9Pv27ZPmT506VetxVVLWXM068I0Qea8xmd977Jo1a0rzjh8/LqVV/Vxo2t/s2bOl5aotf3LDGpNU7ORyOX788UdcvnwZM2bMQMOGDaGn999H7/Hjx/jmm28AAI8ePZI6QK5atSpq1qypcZv//vuv9H+jRo1gYGAgTTdr1kxjOqVWrVqhYsWKWrfn6+uL1q1bo3Xr1mjTpg0SExMBALGxsWodMGdlZWUl/R8VFSU9jdDm4cOH0tMUDw8P2NjY5LkMXl5eqF69eo7b7969u9r0o0ePpP2Fh4dLZWzdujUOHz4spVM+kdFm4MCBWLRoEW7fvi0dG1XK2j8FpVre5s2bqy3L7bioDiqhejwLmyciKl+eP38u/a96bi9KquewW7duqZ2TL126JC3TdE7u0qVLtifmqtv78ssvpW2pXgvu37+vMS+5nTtVt511YIKiykN+5PX9MTExwcCBAwFk1vyoVasWTE1N0bBhQyxYsACxsbEF2n/W62teqV7TVK9nQUFBBdpeQRTmt0eNGjXg4OAAANDT00OFChUA8BpLpUtcXBxOnDgBAKhYsSLat28PIHNQBmVtxv3792utqajtexoSEgIhBFq3bi0NiPH111/Dzc0NVlZWaNeuHXbs2CHdx2j7PWtgYICGDRtK05q+a8WltJ2jC6MwZcl6Do+KisLr168BAKmpqejYsaO0vc2bN0vpNF2P83JeVM3rBx98oDFPhclDfqi+N0DO70+PHj2ka8TUqVPh5OSEihUromvXrmo1XfMjL/ewmjRp0kT6/gIldw0tzPe6KO5TtZ238iK/99iqx1U1vWqt26LMIwOTpDPNmzfHypUrcePGDbx48QK9evWSlt24caPI9pPbaG3Ki0dB5NTMWVklGwAyMjJw+fLlAu+nKMpQ0HLmVMbQ0FAcO3YMAGBubo7NmzfD398f/v7+UhrlD7LikNtxUf4YAKB2016YkzgRlT8XL16U/ldtnlQSNJ2TC3p+T09PR0pKSrb5ujx3astDXgUHB6s9JMzt/fH19cW2bdvw4YcfwsPDAxkZGbh16xaWLl2K/v37FygPhfkdoaTpeqY6T9lsXqkgTdWKIk+qVD8nAArcnIyoOB05cgTJyckAgFevXsHAwAAymQz29vbS9+rJkydqD4C00fSdMDU1xcWLF7FkyRK0b98ejo6OiIuLw/nz5zF69Gh8/fXXBdpubnR1TtD1Obo4aStLUd4j6fq8mFuXW7lR/X3j4eEBc3NzrWkdHR0RGBiI2bNn45133oGNjQ1ev36NU6dOoV+/fti3b1++918U108gf9dQXVw/teVJVWF+aym7f1EGr4tabnnPzzlLNY/KfOcFA5NU7P74449s/Vc4ODhg+PDh0rTy5OHp6SnVpgwKCtL6pKtatWrS/zdv3kR6ero0rdovkmo6JU1fLNV0CxcuhMgcGErtlZCQkOMTHldXV7UnCHPmzNFYa1L5pMvT01PKy+PHjxEdHV2oMuSWRnV/Hh4eSE9Pz1bG1NRULFmyROs2VZ+yde7cGePGjUPbtm1hZGSkMb1qzdi8BixVy3v16lW1ZarTmo4LEVFhHTlyRO1hS0GDV7lRPYe1bdtW63VnzJgx2dbN7Trm6+urdXvaztd5zevJkyfzlK6o8wBk/nifMWOG9CO+cuXKaNGiRY7r6OvrY/To0Th69CgePXqE169fS31AnzlzRrrJy8/1qiBBBUD9GqZ6nVf2Y6dac0XZByQAXLhwQevNaH6vs4X57UFUFvz00095SqctqKLte+ru7g6ZTAYhBOzs7DB//nycPXsWYWFhCAoKkgI8hw4dAqD992xaWppaH5e5fdeU54Xo6GjpviIkJETrPVJO54TSeI4uqMKUJes53NbWVgoamZubIy4uLtu2MjIy4OvrW+i8KmvzZlXceQAyK5isXr1ams7t940QApUrV8aKFSsQEBCAqKgoXLt2TVqu/KwDeb8WFfT6GRgYqLbd/FxDT506pXGbRXmfmt/vdX4pW5E+efJELe6RH/m9x/bw8JDmqb7vuT3UefToEQDAzMwMlStXznP++KiTit327dulTmHbtm0LZ2dnvHz5UupEGoDU8a+yeviJEyeQkZGBrl27Yt68eXB1dcWdO3dw48YN/PDDD2jQoAFq1qyJe/fuISwsDIMHD4aPjw+uXLkiNUs2NDRE796985THPn364LPPPkNKSgpWrFgBmUwGb29vJCYmIjg4GOfOnUNSUhL8/Pxy3M6qVavQtm1bpKWl4eLFi2jdujUmTJgAFxcXhIWF4fjx4/Dz80NUVBRsbGzQuXNnnDp1CikpKejXrx+mTZuGx48fq1XZVzZDKyzlsT158iQeP36MDz/8ECNGjICFhQWePHmCmzdv4tChQ7h06RLc3d01bkP15PL777/jp59+glwu1zowkOqTodu3b+PIkSOwtbWFm5sb3NzcNK7TqVMn2NjYIDo6GtevX8fEiRPRrVs3nDx5EtevXweQefF+7733CngkiIj+ExERgQsXLuDVq1fw8/NTG4ike/fuxXauqV+/PurUqYN//vkH58+fx7Bhw9C3b18YGBggJCQEV69exeHDh/P8dHzQoEFYt24dgMwO8l+9eoV69eohJiYGjx8/xpkzZ1C5cmXs3Lkz33nt27evdI28ePEievfujWHDhkGhUMDPzw+tWrXC4MGDiyUPt2/fhkwmQ0hICL777ju1gV1WrVqVa+0UDw8P9O7dG/Xr14ezszMiIiIQHBwMIPOmKyUlBWZmZmrXq1OnTqFNmzYwNjZG3bp1i6wp4pgxY7B8+XIkJyerda7fo0cPAIC1tbV0/Xv06BHGjh2L6tWrY+XKlVq3WaFCBak8GzZsQOPGjWFlZYW6detqTK/r3x5EuhQdHS39VrewsFC71wAym8jOmDEDQOYAHWvXrlULTgCZFQv09fVhZmaGOXPmSPOV39M///wTkydPRu/eveHl5QVbW1v8/fffUvdGyhp6ffr0wezZs5GWloZDhw5h4cKFaNGiBb7//nuEhYUBAGrVqqXW4koTT09PBAYGIikpCYMGDUKbNm2wefPmbDUolVTPZTt27MD7778PExMTNGnSpFSeowuqKMuip6eHgQMHYvPmzYiPj0enTp0wefJk2Nra4tmzZ/jnn39w6NAh7Ny5UxpEKT+GDBkiDZI6bdo0REREoGnTpnj+/Dm2b9+OS5cuFUseUlJScOHCBSQmJuLatWtYv3493rx5AyDznm7mzJk5rv/TTz9h69at6NmzJ6pUqQIrKyv8/vvvattXyulzVxSePHmC4cOHY9CgQTh79qxU89PIyAhdunQB8N+gKwCwevVqmJub49GjR1o/A6p5vnDhAn799VdYWFigWrVqsLe317hOUX2v86tVq1Y4c+YMUlJScOfOHa3bDwoKwmeffZZt/ujRo/N9j92zZ0/cvXsXADBx4kSsWLECiYmJOQ4OBPw34FXz5s3Vmt/nKs+9URIVUE4D3wCZA7Godqb75MkT4eLiojGtagerV65cERYWFhrTyWQysXnzZiltbp3bCpHZEb2yk/zc9p2Tn3/+WZiZmWndjpWVlZT28ePHah3lZn3Nnj1bSptb59BC5NwJfm7HVvlSdlis7Zh169Yt2zqqHRBn7WhZtTNd5Us5sIC2ToqPHDkiDAwMNObPwMBAHD16VEqrbcCCvBwvIiqfVM892l7dunUTb968UVuvKAe/EUKIwMBAYW1tnWM+lHIbnEUIIebPn5/jtlTP5dryrC2/OV0jVdPlJw/aqB5nbdeBrVu3qq2j7Zoll8u1bqdz585SusjISGFkZJQtjbLD+5ze45yOm2pZvLy8sm2/Tp06IikpSUo/Z86cbGmcnJzUPieqVAesyXrN03ZMiuq3R26/OYh0TXVQBtWBKVQ1aNBASvPbb78JIdS/35q+p05OTiIiIkIIIURAQECO56fly5dL+9q0aZM02FTWl4WFhbh69aqUVts5ZNu2bdnWNTc3V/s9r3pO2rBhQ7b0qr/NS9s5uqCD3+S3LLmdw1+/fi3q1q2b4/aU14P8nhdTU1NFx44dtW63IHnQRvU4a3t5eXllG4BG00AvP/zwQ47b+emnn6T1c/rcFfQeVrUsVatW1fgbRDm4kvI4u7m5ZUujOoiL6mciLS1N47VQ+f3TdEyEKJrvdV5iE6pu374tpc86AJLq78PcPjf5ucd+/fq1xu96vXr1tL6f165dk5Zt3Lgx13KpYlNuKnYLFy7E119/jU6dOsHDwwNmZmYwNDSEh4cHxo0bh+vXr8PR0VFK7+bmhps3b2LWrFmoUaMGjI2NYW5ujgYNGqBPnz5SumbNmiEwMBDDhw9HpUqVoK+vjwoVKqBLly44c+YMxo0bl698jhw5En/88Qd69eoFBwcH6Ovrw8HBAc2aNcP8+fPVahLkpHfv3rh//z4+/fRT1K1bF+bm5jAxMYGnpycGDRqEn3/+WUpbtWpV3LhxAxMnTkSVKlVgYGAAS0tLtGnTBvv378eKFSvyVYbcKI/tp59+Kh1bCwsL1KhRA8OGDcOxY8fg6uqa4zZ++OEHDB8+HLa2trC2tsbQoUNx/Phxrel/+ukndOnSJVsfLDnp0aMHLl26hD59+sDe3h76+vqws7NDr1698Oeff+LDDz/M87aIiHKjp6cnPSXv27cvjh8/juPHj8PCwqJY99uoUSPcunULY8eORdWqVWFoaAhra2vUqVMHY8eOxdmzZ/O1vSVLluCXX35Bly5dYGNjAwMDA1SqVAnvvPMOVqxYgcWLFxc4ryNHjkRAQIDaNdLe3h5du3ZV60OsOPJgYGAAOzs7NGnSBNOnT8e9e/c0NnHX5Msvv0Tnzp3h4uICIyMjGBkZoXr16vj000/VOu+3tbXFkSNH0LBhQ5iYmOQ7j3nh7++Pfv36wdLSEhYWFhgwYAB+++03GBsbS2kWLFiA0aNHw9raGmZmZujRowcuXryotdbmwoULMXr0aDg7O+e5iZyuf3sQ6YpqM25tvxVVBz7R1Jz74MGDGD16NGxsbGBiYoKuXbvijz/+gJ2dHYDMZo6zZ89GixYtpHOhubk5mjZtik2bNmH27NnStsaPHw8/Pz907doVFStWhL6+PpydnTFs2DAEBgZKLcZyMnLkSMyZMwf29vYwMTFB+/btERAQoNbMUtWYMWMwe/ZsuLm5ZasNCpS+c3RhFGVZrK2tcenSJSxduhT169eHiYkJTE1N4eXlhT59+uCnn34qcLN0AwMD/Prrr1i/fj2aNWsGc3NzGBsbw9PTE6NGjSrWPMhkMpiamqJy5cro1KkTtmzZgr/++itPA9B4e3tjypQpaNSoEWxtbSGXy2FlZYXWrVtj//79GDBggJQ2t89dYbVu3RrHjh1Dw4YNYWRkhMqVK2PVqlVqtfcMDAxw5MgReHt7w9DQEC4uLli8eDHWr1+vcZv6+vo4duwY3nnnnXz93iuK73V+1alTR6p9qtqEPr/yc49tbW2N8+fP48MPP4SpqSlsbGwwfvx4bNmyRUpjamqqtn1l3oyMjPLd8kImBEeFICIiIiIiIiIiKm1Ug8F37txBrVq1in2fQohsDz23bt0qVQCbPHmy1KVCWloa3N3d8eLFC4wbNy7PlbqUWGOSiIiIiIiIiIioFOrXrx/q1KkDAFizZo1O9tmtWzfs3LkTd+7cQVBQEHbv3o158+ZJy1UHUDpw4ABevHgBIyMjreNP5IQ1JomIiIiIiIiIiAgA4O7ujidPnmhc9umnn+Lrr78usn2xxiQREREREREREREByOzjtkmTJqhQoYLUH2XXrl1x9OjRIg1KAqwxSURERERERERERCWANSaJiIiIiIiIiIhI5/RLOgO6plAo8OLFC1hYWGQbYYiIiApHCIG4uDg4OztDT4/PvkoTXv+IiIoPr3+lF69/RETFo6iufeUuMPnixQu4urqWdDaIiN5qT58+hYuLS0lng1Tw+kdEVPx4/St9eP0jIipehb32lbvApIWFBYDMA2dpaZnv9RUKBSIjI2FnZ1funoaW17KX13ID5bfs5bXcQOHL/ubNG7i6ukrnWio9Cnv9y0rUqAFZWBiEkxNk9+/nmLbGxhoIiwuDk4UT7k/MOW1ZUZ7PE0rl/RiU9/IDPAaq5Y+Pj+f1r5QqzPUvP9e6t015/n6z7OWv7OW13EDhyl5U937lLjCprL5vaWlZ4MBkcnIyLC0ty+UHtjyWvbyWGyi/ZS+v5QaKruxsKlX6FPb6l5XQ04NM+TeX7ekZ6wFpmX+LYt+lQXk+TyiV92NQ3ssP8BhoKj+vf6VPYa5/+bnWvW3K8/ebZS9/ZS+v5QaKpuyFvfaVryNOREREREREREREpQIDk0RERERERERERKRzDEwSERERERERERGRzpW7PiaJiIiIiHKSkZGBtLS0HNMoFAqkpaUhOTm53PVHpVSejoGBgQHkcnlJZ4OIyrm8XJ8Kozyd11WV13IDuZfd0NCw2I8JA5NERESUb+LwYbx6+RIVHByQW3fXRwccRWpGKgzlhjrJG1FBCSEQHh6OmJiYPKVVKBSIi4srtwOelLdjYG1tDUdHx3JRVsqUn2sdUXHKz/WpsPspT+d1pfJabiD3suvp6aFKlSowNCy+3/ElGpj8448/8M033yAwMBBhYWE4fPgwevbsmeM6/v7+mD59Ou7cuQNXV1fMmzcPPj4+OskvERER/b/GjZEWEQHY2+ee1LmxDjJEVHjKmz57e3uYmprmeHMihEB6ejr09fXL3U2MUnk5BkIIJCYmIiIiAgDg5ORUwjkincnHtY6oOOXn+lQY5eW8nlV5LTeQc9kVCgVevHiBsLAwuLm5FduxKdHAZEJCAurXr49PPvkEvXr1yjV9cHAwunXrhrFjx2LPnj04e/YsRo4cCScnJ3Tu3FkHOSYierukpitwI/Q1roe8QlR8KmzNDFDXBrCuaAtjw/LVjKEkLV++HIcOHcL9+/dhYmKCli1b4quvvkL16tWlNO3atcP58+fV1hszZgy2bt2q6+wSvZUyMjKkmz4bG5tc05fnmxil8nQMTExMAAARERGwt7dns+4isGLFCsyZMwdTpkzB2rVrtaY7ePAg5s+fj5CQEHh5eeGrr77C+++/r7uMEpWw/F6fCqM8nddVlddyA7mX3c7ODi9evEB6ejoMDAyKJQ8lGpjs2rUrunbtmuf0W7duRZUqVbBq1SoAQM2aNXHhwgWsWbOGgUkionyKT07HKr8HuPgoCqnpCljpA5XS4xDhUhFPEg0woFllGOozOKkL58+fx4QJE9C0aVOkp6dj7ty56NSpE+7evQszMzMp3ahRo7BkyRJp2tTUtCSyS/RWUvbZxe8VaaP8bKSlpTEwWUjXrl3Dtm3bUK9evRzT/fnnnxg4cCCWL1+ODz74AHv37kXPnj1x48YN1KlTR0e5JSpZvD5RSVI24c7IyHg7A5P5denSJXTs2FFtXufOnTF16lSt66SkpCAlJUWafvPmDYDMKqkKhSLfeVAoFFIb/PKmvJa9vJYbKL9lLw/ljk9Ox2eH/saFh5HQk8ngkhCNpQeXwyw1CdsXb8Llx1HwcrBA8yoV87Xdt/mYFadTp06pTe/atQv29vYIDAxEmzZtpPmmpqZwdHTM0zaL+voHAFFRUdJ2TH//HcmvXyO8QgUktm8PALC0tIStrW229X759xckpSfBRN8EH1T7oED7Lm3Kw3kiN2/bMVCWB4D0Nzf5Tf82Km/HQPmZV75Upylv4uPjMXjwYOzYsQPLli3LMe26devQpUsXfPrppwCApUuXws/PDxs3btTaYqAor3/i+HEYvXwJ4eAARffu+Vq3rHvbzvH5UdrKXpDrU2GU9fN6eno6MjIypGm5XA59/dxDX2W93IWRW9m1XeuK6jtSpgKT4eHhcHBwUJvn4OCAN2/eICkpSWpioWr58uVYvHhxtvmRkZFITk7Odx4UCgViY2MhhCiXozWVx7KX13ID5bfsb0u50zIUCIqMx8OIeLxJSoeliT4qVzTFs9dJ+P3+S7xOTENlU6DFv4GYvG81LBLjAAC99m7EQZ+ZuPM4FFXM0vO1z7i4uOIoSrkTGxsLAKhYUT0wvGfPHvz4449wdHRE9+7dMX/+fK1Pz4v6+hcbG4tV6zYgPinzZm/jgZ/gnJiAV6ZmmNlvIADA3MQIM6ZMgpWVldq6Y38Zi7CEMDiZOeHGkBv53ndp9LacJwrjbTsGaWlpUCgUSE9PR3p67uc+IYR041Pemn0plbdjkJ6eDoVCgejoaBgYGKh9BxISEko6e2XGhAkT0K1bN3Ts2DHXwOSlS5cwffp0tXmdO3fGkSNHtK5TlNc/u7FjUSE8HBmOjoho3jxf65Z1b9s5Pj9KW9nze30qjLJ+Xs/IyEBERDiE4r/ApExPDnt7xxxrupf1chdGbmXPeu1TVVT3fmUqMFkQc+bMUbuYvXnzBq6urrCzs4OlpWW+t6dQKCCTyWBnZ1cqTlK6VF7LXl7LDZTfsr8N5U5NV+DA9ae4EvwGcpkMJkZGuPs8GWsCgpCUlvlkSz8jA5+e/x6jrh2R1nthbY8zjTviYawM5taGsM9nZ+/GxsZFWYxySaFQYOrUqWjVqpVaM7VBgwahcuXKcHZ2xt9//43Zs2fjwYMHOHTokMbtFPX1Lz4+Hrfu/gu7Fr1gVtEBQv8QgAQIfSOk13wfCa9e4tHlQ5DL5dk+N8rvkZ6eXr4/U6XV23CeKKy37RgkJycjLi4O+vr6eapZoVRczZrKkvJyDPT19aGnpwcbGxsYGxurfQfi4+NLOntlwr59+3Djxg1cu3YtT+m1VUwJDw/Xuk5RXv9k/x/I0NNwbXvbvW3n+PwobWUv6PWpMMrqeT0jIwMpSYlwsJbBUF8PqekKvIzJrAWYl2NXVstdFLSVPeu1T1VR3fuVqcCko6MjXr58qTbv5cuXsLS01FhbEgCMjIxgZGSUbb6enl6BTzIymaxQ65dl5bXs5bXcQPkte1kv961nr3E5+BWcrUxhZqSPpNQM/PJXGBLSBAAZXGJfYsPRr9Ew7IG0ztkaLbH0o+lwdjRDXKoCthZG+S5/WT1epcmECRPwzz//4MKFC2rzR48eLf1ft25dODk5oUOHDnj8+DE8PDyybaeor38ymQxCCJhWdICFvYt0syaTy2Fh7wKBzCeuyu+ONm/TZ6SsnyeKwtt0DPT09CCTyaRXbpSfd6D81a5Qys8x2LVrF6ZOnYqYmBgAwKJFi3DkyBHcunVLSrNo0SJs2bIFEREROHz4MHr27KlxXklRfjZUP/Nv03eguD19+hRTpkyBn59fsT7ILMrrn2qjxvL4Hpfnz3dpKnt+r0+F8bZc2wz19VQG8sy9JmRhy63pmlZW5FZ2Tdc+paL6fpT8tywfvL29cfbsWbV5fn5+8Pb2LqEcERGVTtdDXkEuk8HMKPP50+WgaCSk/tek4YvTm6SgZKqePhZ1GI1xH81FoqkF0tIVMJDL0MQ9f/1LUuFNnDgRv/zyC86dOwcXF5cc0zb//yZljx490kXWiKiU8vf3V7thzfp69913SzqLGs2cOVPtd/29e/ewePFibNu2DWFhYejatavGeVR2BQYGIiIiAo0aNZJqfp0/fx7r16+Hvr6+Wp9wStoqpuS1v2UiKll//PEHunfvDmdnZ8hkshy7YciPsLAwDBo0CNWqVYOenp7WcUf+d/QUOnf9ANbW1qhbty5OnjyZ43YXLVqEBg0aFEkeKe9KNDAZHx+PW7duSVHl4OBg3Lp1C6GhoQAyq+EPGzZMSj927FgEBQVh1qxZuH//PjZv3owDBw5g2rRpJZF9IqJSKTVdgX+ev0FwdAL8H0TgavArPIpU7//j807j8cbIDE+sHdF7yDfY1eRDZAggKTUDAgItPWzRyK1CCZWg/BFCYOLEiTh8+DB+//13VKlSJdd1lNdOJyenYs4dEZVmLVu2RFhYWLbXtm3bIJPJMH78+AJvOzU1tQhzqs7c3Bw2NjbS9OPHjwEAPXr0gKOjI4yMjDTOo7KrQ4cOuH37tnT/d+vWLTRp0gSDBw/GrVu3NPb/xoopRGVbQkIC6tevj02bNhXpdlNSUmBnZ4d58+ahfv36GtP8eeUGho+egb59euHy5cvo2bMnevbsiX/++adI81JUlKOvl0clGpi8fv06GjZsiIYNGwIApk+fjoYNG2LBggUAMqPgyiAlAFSpUgUnTpyAn58f6tevj1WrVuHbb79F586dSyT/RESlTWq6AvuuheJxZBzCYpIQFpOMu2GxSEpRr4XwzNoRPn0W4QOfdbjt5AUAUAhAJgNqOVlhWsdqMNQvU5Xqy7QJEybgxx9/xN69e2FhYYHw8HCEh4cjKSkJQOYN+9KlSxEYGIiQkBAcO3YMw4YNQ5s2bVCvXr0Szj0RlSRDQ0M4OjqqvV6/fo2ZM2di7ty56Nu3r5T2n3/+QdeuXWFubg4HBwcMHToUUVFR0vJ27dph4sSJmDp1KmxtbaXf2OfPn0ezZs1gZGQEJycnfPbZZ7kOwLBr1y64ubnB1NQUH330EaKjo9WWq9ZKWbRoEbr//4jHyiaLmuZR2WZhYYE6deqovczMzGBjYyP1qTxs2DDMmTNHWmfKlCk4deoUVq1ahfv372PRokW4fv06Jk6cWFLFIKJ86Nq1K5YtW4aPPvpIa5qUlBTMnDkTlSpVgpmZGZo3bw5/f/8ct+vu7o5169Zh2LBh2QZdVFq35Xt0av8ORo74BDVq1MDSpUvRqFEjbNy4UWP63bt3Y8mSJfjrr7+kVge7du0CAISGhqJHjx4wNzeHpaUl+vXrl602d1bffvstatasCWNjY9SoUQObN2+WloWEhEAmk2H//v1o27YtjI2NsWfPHkRHR2PgwIGoVKkSTE1NUbduXfz0009q223Xrh0mT56MWbNmoWLFinB0dMSiRYvU0sTExGDMmDFwcHCAsbEx6tSpg19++UVafuHCBbRu3RomJiZwc3PDtGnTSnQQtxLtY7Jdu3Y5DsWu/BBkXefmzZvFmCvNUtMVuBH6GteDo5EaHwND8zdoUsUGjdwq8OadiEqNG6Gv8eejaBjq6yE5TQEDOdD13gX0/+MgBg9YhkTD//rjveFSU21dE0M5ejd2wbAGFWBuXKa6IC7ztmzZAiDzGqfK19cXPj4+MDQ0xG+//Ya1a9ciISEBrq6u6N27N+bNm1cCuSUqh1avznxlke1M2agRcOyY+rwPPwRu5GE0+unTM1+FFBMTgx49eqBdu3ZYunSp2vz27dtj5MiRWLNmDZKSkjB79mz069cPv//+u5Tu+++/x7hx43Dx4kUAwPPnz/H+++/Dx8cHu3fvxv379zFq1CgYGxtj4cKFGvNw5coVjBgxAsuXL0fPnj1x6tQprWmBzGbd7u7u+PjjjxEWFgYgs0Zl1nn09gsNDVXrs6xly5bYu3cv5s2bh7lz58LLywtHjhxRGxyOqFzTcn3KJh/Xp2zXtiK6PmkzceJE3L17F/v27YOzszMOHz6MLl264Pbt2/Dy8irwdi9dvYVJY33U5nXu3Flrc/K+ffvi7t27OH36NH777TcAgJWVFRQKhRSUPH/+PNLT0zFhwgT0799fawB1z549WLBgATZu3IiGDRvi5s2bGDVqFMzMzDB8+HAp3WeffYZVq1ahYcOGMDY2RnJyMho3bozZs2fD0tISJ06cwNChQ+Hh4YFmzZpJ633//feYPn06rly5gkuXLsHHxwetWrXCe++9B4VCga5duyIuLg4//vgjPDw8cPfuXalW+uPHj9GlSxcsW7YMO3fuREREBCZOnIhJkybB19e3wMe7MHjnmQfKGkiXg6KhLwOcjRUIeRmHu+Fx+PdlHAY0dWNwkoh0QnpIEvIKUfGpsDU3RBP3itJDkitB0Xj6KgFhsckwTE/Fpye3Y1DgCQDAUr8tmNFN848KAz0ZWnrYYHaXGoh5FaUxDRWfnB7SAYCrqyvOnz+vo9wQUTZv3gDPn6vN0lh/z9U1+7zIyGzrat1HISkUCgwaNAj6+vrYs2ePWi1D5c3Rl19+Kc3buXMnXF1d8e+//6JatWoAAC8vL3z99ddSms8//xyurq7YuHEjZDIZatSogRcvXmD27NmYP3++xnysW7cOXbp0waxZswAA1apVw59//olTp05pTG9ubg5ra2sAUOs7UNM8ertkvanXdJPft29ftZq/RKRCw/VJozxenzRe24rg+qRNaGgofH19ERoaCmdnZwCZD6tOnToFX19ftWtWfoW/jIK9nY3aPAcHB4SHh2tMb2JiAnNzc+jr66tdd/z8/HD79m0EBwfD9f+P4+7du1G7dm1cu3YNTZs2zbathQsXYtWqVejVqxeAzNa/d+/exbZt29QCk1OnTpXSKM2cOVP6f9KkSTh9+jQOHDigFpisV6+e9MDPy8sLGzduxNmzZ/Hee+/ht99+w9WrV3Hv3j3p2l61alVp3eXLl2Pw4MFSv5yenp5Ys2YNOnTogC1bthTr4GTaMDCZBzdCX+NyUDScrUxgZiiHaUY8jMzNEZ+agctB0ajmYIEWVW1y3xARUSGoPiSRQYbE1HRcehyFg4HP4GlnhqEtKuPCwygERyWgUtQzrDu8ArVeBknr62dkQD8jHely9VO/maEc3lUrooGrNR+yEBFpYmkJVKqkNkv1cYJ0I2dnl31dO7ts62rdRyHNnTsXly5dwtWrV2FhYaG27K+//sK5c+dgbm6ebb3Hjx9LNy+NGzdWW3bv3j14e3urBTlbtWqF+Ph4PHv2TLqRzLpO1mZ73t7eWgOTRERUQBquTxrl8fqk8dpWBNcnbW7fvo2MjAzpGqSUkpIi9UOset0aMmQItm7dWmz50eTevXtwdXWVgpIAUKtWLVhbW+PevXvZApMJCQl4/PgxRowYgVGjRknz09PTszU7b9Kkidp0RkYGvvzySxw4cADPnz9HamoqUlJSYGpqqpYua1dOTk5OiIiIAJDZD72Li0u2Y6r0119/4e+//8aePXukeUIIKBQKBAcHo2bNmhrXK04MTOaB2ui2KrVazI30IdeT4XrIKwYmiajYKR+SOFgYIzg6Ac9eJ0IPMhjp6+Huizis+PU+nsUkodPf57Ds1EaYp2b2T5isb4gvOo/FyabvQ5aaDgMhg1xPBkN9PbjbmKFuJSu8TkrlKNyULylGpkg2NkWKkWmuac0NzWFhaAFzw+wBEaIyQVMzNiGQnp4OfX39zA56tcnadK6Y7Nu3DytXrsSJEyc0Nn2Lj49H9+7d8dVXX2VbpjqIlpmZWbHmk6hMMTeHwtwcMg0BfaJSoTDNrDVdn/J6bSsi8fHxkMvlCAwMzDYAljIgqRzwEQAs8xEkdXSwRUSkev/GL1++LPZa+PHx8QCAHTt2oHnz5mrLspYx6zX3m2++wbp167B27VrUrVsXZmZmmDp1arbB6AwMDNSmZTIZFAoFgMyan7nlb8yYMZg8eTKAzKCk8j2vXLlyHktZtBiYzIOo+FSYGmk+VKaG+oiKL74RC4mIlJQPSd4kp+HZ60RYGBn8V8NRAG9ev8GC45vQ79ZpaZ0gW1dM7zUH/9i4wUQBuFQwhYFcD9UdLWBqqI/E1HS8TkpFi6o2HIWb8mX+8gOwN0hBRFruo+Ten3hfBzkiKr9u3bqFESNGYMWKFVoHhWzUqBH+97//wd3dPfOGM49q1qyJ//3vfxBCSLUmL168CAsLC7i4uEg3QlnXuXLlitq8y5cv56NERKWDuHsXERERsLe319zElYgKpWHDhsjIyEBERARat26tMY2np2eBtu3drAH8/7iEnn2GSPP8/Pzg7e2tdR1DQ0NkZKgPGlqzZk08ffoUT58+lWpN3r17FzExMahVq1a2bTg4OMDZ2RlBQUEYPHhwvvJ88eJF9OjRA0OGZOZZoVDg33//1bgfberVq4dnz56pddOiqlGjRrh79650XFUDkyU10Bzb7OWBrbkhElM0jzyYmJoOW3NDHeeIiMoj5UOSFzFJ0INMrdl11ahQ7No6SS0oeaRuB/T7ZC0e2LsDkEEIAS87Cwxo6obqDhYwMZCjuoMFhnm7s69cIqIyKioqCj179kS7du0wZMgQhIeHq70iIyMBABMmTMCrV68wcOBAXLt2DY8fP8bp06fx8ccfZ7sJUzV+/Hg8ffoUkyZNwv3793H06FEsXLgQ06dPVxukRNXkyZNx6tQprFy5Eg8fPsTGjRvZjJuIqByKj4/HrVu3pFqPwcHBuHXrFkJDQwFk9kE8ePBgDBs2DIcOHUJwcDCuXr2K5cuX48SJEzluW7nd+Ph4REZG4tatW7h37560fMq44Tjz+wV8t3MXHjx4gEWLFuH69euYOHGi1m26u7tLeYyKikJKSgo6duyIunXrYvDgwbhx4wauXr2KYcOGoW3bttmaYistXrwYy5cvx/r16/Hvv//i9u3b8PX1xepcBiry8vKCn58f/vzzT9y7dw9jxozJdfTvrNq2bYs2bdqgd+/e8PPzQ3BwMH799VfpOjx79mz8+eefmDhxIm7duoWHDx/i2LFjOR6X4sYak3nQxL0i7oa9QXxKOswN/6t6G5+SjgyFYPNHIioWWQe6eRQRhwyFQEJKBuRyGd4kpSEuOQ1pCgHvwABUi3wCAEgyMMLK7pOwp1Z7CAHIZYBcD5DryfBONVsGIYmI3iInTpzAkydP8OTJE7Um2UqVK1dGSEgInJ2dcfHiRcyePRudOnVCSkoKKleujC5dumgNMAJApUqVcPLkSXz66aeoX78+KlasiBEjRmDevHla12nRogV27NiBhQsXYsGCBejYsSPmzZunNko4ERG9/a5fv453331Xmp7+/83Ohw8fjl27dgEAfH19sWzZMsyYMQPPnz+Hra0tWrRogQ8++CDHbTds2FD6PzAwEHv37oWbmxt+O/MrAKBl80bYtW0l5i9dizVr18HLywtHjhxBnTp1tG6zd+/eOHz4MN59913ExMTA19cXPj4+OHr0KCZNmoQ2bdpAT08PXbp0wYYNG7RuZ+TIkTA1NcU333yDTz/9FGZmZqhbt6404Iw28+bNQ1BQEDp37gxTU1OMHj0aPXv2RGxsbI7rZfW///0PM2fOxMCBA5GQkABPT0+sWLECQGaNyvPnz+Pzzz9H69atIYRA1apV0b9//3ztoyjJRG5Dgb5l3rx5AysrK8TGxua5fwK1Ubn1AGejNLxIMUC6AmhR1abc3OQrFAqpKUNOP2DfNuW13ED5LXtpKLfqeUcuk8HUSB+h0QkIjkqAvh6Qki6QoRCALLNj6pTUdGzetxCOMRFYMGg+MmrWQnxyOuKS05CcrkByWgaaulfEtqFNcjxfFbbsBTnHkm4U9r15/PgxBnwyFu7dxsPS3gUyCKkpt4AMbyKeIeTEZuzbuRUeHh7FUILSpTScJ0ra23YMkpOTERwcjCpVquRpRMrS0PSppJW3Y5D1M6L6HYiPj+f1r5QqzPXvbTvP5QfLXnrKnt/rU2GU9fN6cnIynj4JgqutHMaGekhOVeBpVAZcK1fN8diV9XIXRm5lz+nzV1T3fqwxmQeG+noY0NQN1RwscD04GqnxMahmb4EmVTL7ZCsPQUki0i3VgW7eJKchNDoRCSkZMJDLMpt0x8dCYV0BepBBAcDGwgRfDfocTxIVMLQwh21SGgzkejA10oe+PAMOlkYY8U4Vnq+oyPTZvx42STGINrHGwf5Tckz76ZlP8Tr5NSoYV8A3nb7RUQ6JiIgKRzZrFizDwiBzcgJWrizp7BARvZUYmMwjQ309tKhqg2buFUrV0xMiejtdD3kFmQCCoxLwLCZz9G0DfT0Y6euh983T+MxvOyYNXIS/PRrA0tgABnIZki2tYWGcDrlMBj2ZDKnpGZDr6cHB0gSdazuiWRWbki4WvUWaXTmDiq8j8aqCXa6ByZ/++QnP456jkkUlBiaJiKjs2LcPps+fQ1SqxMAkEVExYWCSiKgUiopPRWJaBp7F/Df6tnFyAkYe+Aatr54BAKw6uhKfzduFl0amMDWUw9naBBBAQlo66jhbISo+FbbmhmjiXpG1u4mIiIiIiKjUYWCSiKgUsjU3xKXHUdLo25WfPcTUHfPh/DJUShNYvzXq1HBFTUMjaV5QVDzqOFthYnuvksg2EREREREVg3I2PAiVErr43DEwSURUCjVxr4iDgc9gpCdDxz8OY/iBdTBMTwUAJBiZYlmPafirZWe8pxKUjE9JR4ZCoIl7xZLKNhERERERFSEDAwMAQGJiIkxMTEo4N1TepKZm3oPK5fJi2wcDk0REpVAjtwqoaybQc+tidLx9Xpr/wKUadkz4EvdM7ZGeoUBQVDxMDfWRmJoZlGxRNXNQLiIiIiIiKvvkcjmsra0REREBADA1NS22kaPL+ujUKSkpyFAokJIqAyCQkioyp1NSclyvrJe7MHIqu0KhQGRkJExNTaGvX3zhQwYmiYhKIcM7t/HNVyNgEhoizTv1bh/8PuJTmFuYwTU2Gc2qVERiajqi4lPhWsGEfUkSEREREb2FHB0dAUAKThYXIQQUCgX09PTKZIAuLS0Nr19FITVBDwZyGdIyBF7HK5CappBqnmpS1stdGLmVXU9PD25ubsV6XBiYJCIqYanpCtwIfY3rIa+kAWveSU9E/ajMHx6JphbYM2YBHrXqhKTUdMTHJaOlpw0GNHVjEJKIiIiI6C0nk8ng5OQEe3t7pKWlFdt+FAoFoqOjYWNjAz29snefERoail1bV2JObwu4OZgi9GUidv0vDnOWrIWbm5vW9cp6uQsjt7IbGhoW+zFhYJKIqASlpiuw71ooLgdFQy6TwdRIHw/C43BXGGLQ9CXwPrUfD1ZtQ0q6OUxYM5KIiIiIqNySy+XF2tefQpFZs9DY2LhMBujkcjmiIsMhT02GscIM8tQEREXGQC6Xw9jYWOt6Zb3chVEayl6+jjgRUSlzI/Q1LgdFo2FUCLysDOBoaYyqduZwsjLB3hrtcG3PcTRs0xAT23th0Ye1MbG9F1pUtWFQkoiIJD4+PpDJZBg7dmy2ZRMmTIBMJoOPj4/uM5YHQggsWLAATk5OMDExQceOHfHw4cNc19u0aRPc3d1hbGyM5s2b4+rVq2rLx4wZAw8PD5iYmMDOzg49evTA/fv31dLIZLJsr3379hVp+YiIiChnvLMlIipmqekKXA6KxsbfH2LRsTvY+PtDXA6KRmq6AteDo9Hx1z34ZMYAtNn+lbSOuZE+5HoyXH/2pgRzTqTd7XqtcLtZO9yu1yrXtN28uqFPrT7o5tVNBzkjKp9cXV2xb98+JCUlSfOSk5Oxd+/eHJuvlbSvv/4a69evx9atW3HlyhWYmZmhc+fOSE5O1rrO/v37MX36dCxcuBA3btxA/fr10blzZ7W+1xo3bgxfX1/cu3cPp0+fhhACnTp1QkZGhtq2fH19ERYWJr169uxZXEWlsuj995H8wQfA+++XdE6IiN5abMpNRFSMUtMV+PHyE5y+E46YxFQohICeTIaAh1H40MUIHRdNR43rmaNuNzi2B4+9OyC0cWagx9RQH1HxqSWZfSKtfvCZA3uDFESkGeWadlv3bTrIEVH51qhRIzx+/BiHDh3C4MGDAQCHDh2Cm5sbqlSpopZWoVDgq6++wvbt2xEeHo5q1aph/vz56NOnDwAgIyMDo0ePxu+//47w8HC4ublh/PjxmDJlirQNHx8fxMTEwNvbG2vXrkVqaioGDBiAtWvX5jjAgCohBNauXYt58+ahR48eAIDdu3fDwcEBR44cwYABAzSut3r1aowaNQoff/wxAGDr1q04ceIEdu7cic8++wwAMHr0aCm9u7s7li1bhvr16yMkJAQeHh7SMmtra2lQCaKsxNatiImIgL29PcrXcBhERLrDGpNERMXoanA0/nfjKV6+SYJCAGkZAlHxKTC4egkdBneRgpIAcK3/KDyr30yaTkxNh625YUlkm4iIyqBPPvkEvr6+0vTOnTul4J2q5cuXY/fu3di6dSvu3LmDadOmYciQITh/PvOapFAo4OLigoMHD+Lu3btYsGAB5s6diwMHDqht59y5cwgKCsLvv/+O77//Hrt27cKuXbuk5YsWLYK7u7vW/AYHByM8PBwdO3aU5llZWaF58+a4dOmSxnVSU1MRGBioto6enh46duyodZ2EhAT4+vqiSpUqcHV1VVs2YcIE2NraolmzZti5cyeEEFrzS0REREWPNSaJiIrR8b/C8CohFQ4WxnidlIa4hBQMv3gQE37fBX2FAgAQa2aF4zO/QmSrd6X14lPSkaEQaOJesaSyTkRE/2/1pdVYfWl1rukaOTXCsYHH1OZ9+NOHuBF2I9d1p3tPx3Tv6QXOIwAMGTIEc+bMwZMnTwAAFy9exL59++Dv7y+lSUlJwZdffonffvsN3t7eAICqVaviwoUL2LZtG9q2bQsDAwMsXrxYWqdKlSq4dOkSDhw4gH79+knzK1SogHXr1sHIyAg1a9ZEt27dcPbsWYwaNQoAYGtrq1Y7Mavw8HAAgIODg9p8BwcHaVlWUVFRyMjI0LhO1j4kN2/ejFmzZiEhIQHVq1eHn58fDA3/e+C3ZMkStG/fHqampjhz5gzGjx+P+Ph4TJ48WWueqeC2bNmCLVu2ICQkBABQu3ZtLFiwAF27dtWYfteuXdkC60ZGRjk28yciorKHgUkiomL08GUcDPT0kJKugDwqEpsOr4T3w2vS8kD3ulj38UKkODjDPioepob6SEzNDEq2qGqDRm4VSjD3REQEAG9S3uB53PNc07lauWabF5kYmad136QUvk9hOzs7dOvWDbt27YIQAt26dYOtra1amkePHiExMRHvvfee2vzU1FQ0bNhQmt60aRN27tyJ0NBQJCUlITU1FQ0aNFBbp3bt2mqjwzo5OeH27dvS9MSJEzFx4sRCl6ugBg8ejPfeew9hYWFYuXIl+vXrh4sXL0ojs86fP19K27BhQyQkJOCbb75hYLKYuLi4YMWKFfDy8oIQAt9//z169OiBmzdvonbt2hrXsbS0xIMHD6RpmYwNqomI3jYMTBIRFYPUdAVuhL5GWGwS4pLTYfH8CX7a9Skc4qIBAAqZDDtaD8DujsPRoKodnIz04VrRBFHxqXCtYIIm7hXRyK0CR9+mUmve4uGoEBuN11Y2WLpwd45pm2xvgvD4cDiaO+L66Os6yiFR0bE0skQli0q5prMztdM4Ly/rWhpZFihvWX3yySdSMHDTpk3ZlsfHxwMATpw4gUqV1PNlZJTZZ+y+ffswc+ZMrFq1Ct7e3rCwsMA333yDK1euqKXP2pekTCaD4v9bA+SFsm/Hly9fwsnJSZr/8uXLbEFQJVtbW8jlcrx8+VJt/suXL7P1FWllZQUrKyt4eXmhRYsWqFChAg4fPoyBAwdq3Hbz5s2xdOlSpKSkSMeCik737t3Vpr/44gts2bIFly9f1hqYlMlkJdoHqKxZM9i9eAGZszNwndcvIqLiwMAkEVERS01XYN+1UFwOioa+XA8ZQiDIzAah1o5wiItGtHkFLOr7Gc651oObpSnMjfVhYiDHxPZeJZ11ojyzjI2G1etIZOSeFOHx4XmqMUZUWmlqZi2EQHp6OvT19XOsxZW1aXdx69KlC1JTUyGTydC5c+dsy2vVqgUjIyOEhoaibdu2Grdx8eJFtGzZEuPHj5fmPX78uMjzWqVKFTg6OuLs2bNSIPLNmze4cuUKxo0bp3EdQ0NDNG7cGGfPnpVG0FYoFDh79myOtTOFEBBCICUlRWuaW7duoUKFCgxK6kBGRgYOHjyIhIQEqUsBTeLj41G5cmUoFAo0atQIX375pdYgplJKSora+/zmTWZtZIVCka/AOQDIwsMhDwuD0NPL97plnUKhgBCi3JUbYNnLctmFEJDJZBCQQSEy/8pkslzLVNbLXRiFKXtRHS8GJomIitiN0Ne4HBQNZysTGMn1EPAoCvECmP7hLMw5uwNfdxuP1xY2MJbLUN3BHImp6XCtYFLS2SYioreAXC7HvXv3pP+zsrCwwMyZMzFt2jQoFAq88847iI2NxcWLF2FpaYnhw4fDy8sLu3fvxunTp1GlShX88MMPuHbtWrbRvXOzceNGHD58GGfPntW4XCaTYerUqVi2bBm8vLxQpUoVzJ8/H87OzlLQEQA6dOiAjz76SAo8Tp8+HcOHD0eTJk3QrFkzrF27FgkJCVJ/hEFBQdi/fz86deoEOzs7PHv2DCtWrICJiQnef/99AMDx48fx8uVLtGjRAsbGxvDz88OXX36JmTNn5quMlD+3b9+Gt7c3kpOTYW5ujsOHD6NWrVoa01avXh07d+5EvXr1EBsbi5UrV6Jly5a4c+cOXFxctO5j+fLlan2kKkVGRua7f0q7jAzIASgyMhAZEZGvdcs6hUKB2NhYCCGgp1e+WvCw7GW37HFxcXB190Kc3AwR6caIkyfD1T0BcXFxiMjhO1zWy10YhSl7XFxckeSBgUkioiJ2PeQVat69BhtnOxh71kEtJ0vcDXuDl1a2mPLRHOjLZahoJIeHnTmsTA0REZfMQW6IiKjIWFrm3Cx86dKlsLOzw/LlyxEUFARra2s0atQIc+fOBQCMGTMGN2/eRP/+/SGTyTBw4ECMHz8ev/76a77yERUVlWtNS+XgNKNHj0ZMTAzeeecdnDp1SuoHEsisrRkVFSVN9+/fH5GRkViwYAHCw8PRoEEDnDp1ShoQx9jYGAEBAVi7di1ev34NBwcHtGnTBn/++Sfs7e0BZDZD37RpE6ZNmwYhBDw9PbF69Wpp4B4qHtWrV8etW7cQGxuLn3/+GcOHD8f58+c1Bie9vb3ValO2bNkSNWvWxLZt27B06VKt+5gzZw6mT/+vhvObN2/g6uoKOzu7XL8bWcn+P7ivJ5dLn53yQqFQQCaTwc7OrlwGalj2sln2+Ph4PA15CIsMa9jrmyE+IwFPQ2JgYWGR43e4rJe7MApTdtVrdWEwMElEVJQyMlBn+2q0ObANcQ6V8OOWI6jnYg0bMyPcevYaEXEpMJDroZqDBUwN5YiIS+YgN0REVCi7du3KcfmRI0fUpmUyGaZMmYIpU6ZoTG9kZARfX1/4+vqqzV++fLnaPpXN2ZXWrl2rln7RokVYtGhRjnmTyWRYsmQJlixZojWNchRnVTkNrOPs7IyTJ0/muN8uXbqgS5cuOaahomdoaAhPT08AQOPGjXHt2jWsW7cO27Zty3VdAwMDNGzYEI8ePcoxnZGRkcbm+Hp6evm+6RZZ1i9vZDJZgY7b24BlL5tlVzbblkFAT5b5V9m8O7fylOVyF1ZBy15Ux6r8HXEiouLy4gXQsSPa7d8KPSFgFf4M9Y/thVxPBjcbU3Sr64z6Ltao42yJyjZmqOlkiWHe7hjQ1I2D3BAREVG5o1Aocuz3U1VGRgZu376tNlASERGVfawxSURUFE6fBoYOBSIjAQAZenKcHzIJf/X/r0lYUloGrE0NMMzbHS2q2pRUTomIiIh0bs6cOejatSvc3NwQFxeHvXv3wt/fH6dPnwYADBs2DJUqVZJq5i5ZsgQtWrSAp6cnYmJi8M033+DJkycYOXJkSRaDiIiKGAOTRESFkZ4OLFgAqDRvE5UqwW/eGhyzqAr5q0SYGuojMTUdGQrBZttERERULkVERGDYsGEICwuDlZUV6tWrh9OnT+O9994DAISGhqo1C3z9+jVGjRqF8PBwVKhQAY0bN8aff/6pdbAcIiIqmxiYJCIqqGfPgIEDgQsX/pvXrRtku3ahvXVFWIe+xvWQV4iKT4VrBRM0ca+IRm4V2GybiIiIyp3vvvsux+X+/v5q02vWrMGaNWuKMUdERFQaMDBJRFQQiYlA8+aZ/UoCgL5+Zq3J6dMBPT0YAmhR1YZNtomIyhghRO6JqFziZ4OIiKjoMTBJRFQQpqbAZ58BkycDlSsD+/YBLVqUdK6IdObnvpNgmxGPKLl5rmm/fu9rJKYlwtTAVAc5IyoYAwMDAEBiYiJMTExKODdUGiUmJgL477NCbz+xYgXevHwJCwcHyEo6M0REbykGJomICmriRCAlBRgxAqjAfiOpfLnq3Rn2BimISDPKNe2guoN0kCOiwpHL5bC2tkZERAQAwNTUFDKZ9lCEEALp6enQ19fPMd3brLwcAyEEEhMTERERAWtra8jl8pLOEunKoEFIioiAhb19SeeEiOitxcAkEVFeHD0K3L0LzJnz3zyZDJg5s+TyRERERcrR0REApOBkToQQUCgU0NPTe6uDcjkpb8fA2tpa+owQERFR0WBgkogoJ6mpwKxZwLp1mdONGgGdO5dsnoiIqFjIZDI4OTnB3t4eaWlpOaZVKBSIjo6GjY2N2kjC5Ul5OgYGBgasKUlERFQMSjwwuWnTJnzzzTcIDw9H/fr1sWHDBjRr1kxr+rVr12LLli0IDQ2Fra0t+vTpg+XLl8PY2FiHuSaiciEoKHPU7evX/5t3+DADk0QAHMKewE4vCTKFCcKd3HNM+yDqAdIV6dDX00d12+q6ySBRIcjl8lyDUAqFAgYGBjA2Nn7rg3La8BjQW+/BA+hHRACvXwM1a5Z0boiI3kolGpjcv38/pk+fjq1bt6J58+ZYu3YtOnfujAcPHsBeQz8ee/fuxWeffYadO3eiZcuW+Pfff+Hj4wOZTIbVq1eXQAmI6G1l9MsvkM2YAbx5kznD0BBYswYYN65kM0ZUSsz4ZgIqvo7Eqwp2+HT1iRzTdtjdAc/jnqOSRSU8m/5MRzkkIiIqHNl778H2+XOISpWAZ7x+EREVhxINTK5evRqjRo3Cxx9/DADYunUrTpw4gZ07d+Kzzz7Llv7PP/9Eq1atMGhQZif67u7uGDhwIK5cuaJ1HykpKUhJSZGm3/x/kEGhUEChUOQ7zwqFQupPp7wpr2Uvr+UGymnZk5OBGTNQYetWaZbw9ITYtw9o2BAQIvP1lirse16uPitERERERERUKCUWmExNTUVgYCDmqAwkoaenh44dO+LSpUsa12nZsiV+/PFHXL16Fc2aNUNQUBBOnjyJoUOHat3P8uXLsXjx4mzzIyMjkZycnO98KxQKxMbGQghR7pqslNeyl9dyA+Wv7PKgIFiPGQODf/6R5iV99BHefP01hLk5kIfBEMq6wr7ncXFxxZCrt9/y5ctx6NAh3L9/HyYmJmjZsiW++uorVK/+X7Pn5ORkzJgxA/v27UNKSgo6d+6MzZs3w8HBoQRzTkREREREVHAlFpiMiopCRkZGthsqBwcH3L9/X+M6gwYNQlRUFN555x0IIZCeno6xY8di7ty5WvczZ84cTJ8+XZp+8+YNXF1dYWdnB0tLy3znW6FQQCaTwc7OrlwEalSV17KX13ID5a/ssoEDIfv/oKQwNoZizRoYjRoFu3Iw0qhSYd9z9vdbMOfPn8eECRPQtGlTpKenY+7cuejUqRPu3r0LMzMzAMC0adNw4sQJHDx4EFZWVpg4cSJ69eqFixcvlnDuiYiIiIiICqbEB7/JD39/f3z55ZfYvHkzmjdvjkePHmHKlClYunQp5s+fr3EdIyMjGBkZZZuvp6dX4ECLTCYr1PplWXkte3ktN1DOyr5jB9CoEYSzM6I3b0bFdu3KR7mzKMx7Xh6PV1E4deqU2vSuXbtgb2+PwMBAtGnTBrGxsfjuu++wd+9etG/fHgDg6+uLmjVr4vLly2jRokW2bRZ1VyZCCMhkMsgAyCCgDNerTstksly7AnhbmvuXy64usijvx6C8lx/gMVAtf3k9BkRERIVVYoFJW1tbyOVyvHz5Um3+y5cv4ejoqHGd+fPnY+jQoRg5ciQAoG7dukhISMDo0aPx+eef84aYiPJHoQBUzxuensDp0xC1ayM9MbHk8kXlXmxsLACgYsWKAIDAwECkpaWhY8eOUpoaNWrAzc0Nly5d0hiYLOquTOLi4uBZpTLszQBTgxQovzl6AOwNUmBuBuhXqYy4uDhEZOn2QHnDrlAosi0rq8pbVxealPdjUN7LD/AYqJY/ISGhpLNDRERUJpVYYNLQ0BCNGzfG2bNn0bNnTwCZF/ezZ89i4sSJGtdJTEzM9qNHLpcDyKzJQUSUZz/8AGzcCPz+O/D/TWUBAN7emQFLBiaphCgUCkydOhWtWrVCnTp1AADh4eEwNDSEtbW1WloHBweEh4dr3E5Rd2USHx+PR8FPkF4TsDQzgrJukAJARJoR3iQAIcFPYGFhAXt7e7V1ldduPT29bMvKqvLW1YUm5f0YlPfyAzwGquWPj48v6ewQERGVSSXalHv69OkYPnw4mjRpgmbNmmHt2rVISEiQRukeNmwYKlWqhOXLlwMAunfvjtWrV6Nhw4ZSU+758+eje/fuUoCSiChHCQnAxInArl2Z05MmATt3lmiWiFRNmDAB//zzDy5cuFCo7RR1VybKZtoCgIAMyseBqtPK5t45bf9tCl6Uq64utCjvx6C8lx/gMSjv5SciIiqsEg1M9u/fH5GRkViwYAHCw8PRoEEDnDp1ShoQJzQ0VO0iP2/ePMhkMsybNw/Pnz+HnZ0dunfvji+++KKkikBEZcmdO0C/fsDdu//Nk8mA9HRAv0x1uUtvqYkTJ+KXX37BH3/8ARcXF2m+o6MjUlNTERMTo1ZrMqfuT4iIiIiIiEq7Er8Tnzhxotam2/7+/mrT+vr6WLhwIRYuXKiDnBHRW0MIwNc3s6ZkUlLmPDMzYOtWYMiQks0bETJrGk6aNAmHDx+Gv78/qlSpora8cePGMDAwwNmzZ9G7d28AwIMHDxAaGgpvb++SyDIREREREVGhlXhgkoioWMXHA2PHAnv2/DevXj3gwAGgevWSyxeRigkTJmDv3r04evQoLCwspH4jraysYGJiAisrK4wYMQLTp09HxYoVYWlpiUmTJsHb21vjwDe68MWCXbDTS0KkwiTXtNdGXUOGyIBcxm5XiIio7BBXriDy5UvYOjhAVtKZISJ6SzEwSURvr7/+ymy6/e+//80bMwZYswYwyT2YQqQrW7ZsAQC0a9dObb6vry98fHwAAGvWrIGenh569+6NlJQUdO7cGZs3b9ZxTv8Ta20LI4MUxKZl78cyKycLJx3kiIiIqIg5OUEhlwNvycBtRESlEQOTRPT2Onnyv6CkhQWwYwfQv3/J5olIAyFErmmMjY2xadMmbNq0SQc5IiIiIiIiKn4MTBLR22v2bODcOSA6Gti/H/D0LOkcEREREREREdH/08s9CRFRGREVpT6tpwfs2wf8+SeDkkRFrI3/YbQ6uR9t/A/nmnZ74HasvrQa2wO36yBnRERUGm3ZsgX16tWDpaUlLC0t4e3tjV9//TXHdQ4ePIgaNWrA2NgYdevWxcmTJ3WU2/+3fTtMt24FtvP6RURUXBiYJKKyTwhg40agcmXgwgX1ZRUrAka594FHRPnzwbHv0G3vJnxw7Ltc0y45vwQzzszAkvNLdJAzIiIqjVxcXLBixQoEBgbi+vXraN++PXr06IE7d+5oTP/nn39i4MCBGDFiBG7evImePXuiZ8+e+Oeff3SWZ9myZbBcvBiyZct0tk8iovKGTbmJqGyLiQFGjAAOHcqcHjAAuHULsLUtyVwRERERkYru3burTX/xxRfYsmULLl++jNq1a2dLv27dOnTp0gWffvopAGDp0qXw8/PDxo0bsXXrVq37SUlJQUpKijT95s0bAIBCoYBCochXnlVH4s7vumWdQqGAEKLclRtg2cty2YUQkMlkEJBBITL/pqZlICQkRK1Pd0tLS9iq3C9qK3dUVJR0DtG2bllXmPe8qD4nDEwSUdl19WrmYDYhIf/N69cPsLQssSwRERERUc4yMjJw8OBBJCQkwNvbW2OaS5cuYfr06WrzOnfujCNHjuS47eXLl2Px4sXZ5kdGRiI5OTlf+bTLyIAcgCIjA5EREflat6xTKBSIjY2FEAJ6euWroSXLXnbLHhcXB1d3L8TJzRCRbowXKfEwMk3H/t2bYWBgIKUzMLbAuEkzYWVlBUBzuWNjY7Flw0qkJcep7SPrumVdYd7zuLi43BPlAQOTRFT2CAGsXZs5uE1aWua8ChWAXbuADz8syZwRERERkRa3b9+Gt7c3kpOTYW5ujsOHD6NWrVoa04aHh8PBwUFtnoODA8LDw3Pcx5w5c9QCmm/evIGrqyvs7Oxgmc+H1zK5HACgJ5fD3t4+X+uWdQqFAjKZDHZ2dmUyQFUYLHvZLXt8fDyehjyERYY17PXNcCcmCkH3/8bYdtVRzdUaAPA0MglrfkmBXOV7ranc8fHxCLp/A9M+MIKrnYnWdcu6wrznxsbGRZIHBiaJqGx59Qrw8QGOH/9vnrc38NNPmX1MEhEREVGpVL16ddy6dQuxsbH4+eefMXz4cJw/f15rcLIgjIyMYKShf3E9Pb1833QLlf/LYpCmsGQyWYGO29uAZS+bZZfJZJnNuSGgJ8v8q1Ao4GpnCM9KpplpICBEslRO1XVVy63clpudMTxyWbesK+h7XlTH4O05kkT09rt2DWjQQD0oOWsWcP48g5JEREREpZyhoSE8PT3RuHFjLF++HPXr18e6des0pnV0dMTLly/V5r18+RKOjo66yCoREekIA5NEVHaYmABRUZn/29gAJ04AX30FqPQXQkRERERlg0KhUBuoRpW3tzfOnj2rNs/Pz09rn5RERFQ2sSk3EZUddeoAGzYA338P7N0LuLiUdI6IiIiIKA/mzJmDrl27ws3NDXFxcdi7dy/8/f1x+vRpAMCwYcNQqVIlLF++HAAwZcoUtG3bFqtWrUK3bt2wb98+XL9+Hdu3by/JYhARURFjYJKISq+rV4H69QHVfoI++SSzj8n/74yciIiIiEq/iIgIDBs2DGFhYbCyskK9evVw+vRpvPfeewCA0NBQtf7KWrZsib1792LevHmYO3cuvLy8cOTIEdSpU6ekikBERMWAgUkiKn0UCmD5cmDBAmDiREC17yGZjEFJolLgpYMb0kzN8MrCJte01WyqwcrYCg5mDrmmJSKit9N3332X43J/f/9s8/r27Yu+ffsWU47yoFo1pJmZQb9SpZLLAxHRW46BSSIqXV6+BIYOBfz8MqfXrwd69gTefbdEs0VE6lbN3gx7gxREpGUf+TSr34f/roMcERERFS3x22+IjoiAvb09ZCWdGSKitxQDk0RUevz+OzB4MBAenjktkwELFwJt2pRsvoiIiIiIiIioyDEwSUQlLyMDWLoUWLIEECJznqNj5gA3rClJRERERERE9FZiYJKISlZYWGYtyXPn/pv33nvADz8ADuyPjoiIiIiIiOhtxcAkEZWc+/eBtm2BiIjMaT29zJqTn32W+T8RlVojty1AxYRXeGVWETvGLM0x7eBDgxGVGAVbU1vs6bVHRzkkIiIqHNmQIajw4gVkzs6ZLXmIiKjIMTBJRCXHwwPw9MwMTFaqBPz0E9C6dUnniojyoNqDG6j4OhKvKtjlmvZ8yHk8j3uOShYc1ZSIiMqQP/6A0fPnEByVm4io2LBKEhGVHAMDYN8+YNAg4NYtBiWJiIiIiIiIyhEGJolId06eBG7eVJ/n6grs2QPY2pZMnoiIiIiIiIioRDAwSUTFLy0NmDUL6NYN6NcPePOmpHNERERERERERCWMgUkiKl6hoZkD3HzzTeb0o0fAd9+VbJ6IiIiIiIiIqMQxMElExefYMaBBA+DSpcxpAwNgzRpg6tSSzBURERERERERlQIclZuIil5qKjB7NrB27X/zqlQB9u8HmjYtsWwRERERERERUenBwCQRFa3gYKB/f+Datf/m9e4NfPstYG1dYtkiIiIiIiIiotKlQE25AwICMGTIEHh7e+P58+cAgB9++AEXLlwo0swRURkTHw80b/5fUNLQENi4ETh4kEFJIiIiIiIiIlKT7xqT//vf/zB06FAMHjwYN2/eREpKCgAgNjYWX375JU6ePFnkmSSiMsLcHJg7F5g2DfDwAA4cABo1KulcEVExCGjTEzYpsYg2sso17ahGoxCbEgurPKQlIiIqLcTIkUgMC4OJkxNkJZ0ZIqK3VL4Dk8uWLcPWrVsxbNgw7Nu3T5rfqlUrLFu2rEgzR0Rl0JQpgBDAiBGApWVJ54ao2AUFBaFq1aolnQ2dO95zJOwNUhCRZpRr2oXtFuogR0REVFzK67UOCxYgLiICJvb2JZ0TIqK3Vr6bcj948ABt2rTJNt/KygoxMTFFkSciKiv27wdWrFCfJ5Nl1phkUJLKCU9PT7z77rv48ccfkZycXNLZISIiKnK81hERUXHJd2DS0dERjx49yjb/woUL5fMpGlF5lJQEjBkDDBiQ2XT7t99KOkdEJebGjRuoV68epk+fDkdHR4wZMwZXr14t6WwREREVGV7riIiouOQ7MDlq1ChMmTIFV65cgUwmw4sXL7Bnzx7MnDkT48aNK448ElFp8uAB0KIFsH175rQQAPuWpXKsQYMGWLduHV68eIGdO3ciLCwM77zzDurUqYPVq1cjMjKypLNIRERUKLzWERFRccl3YPKzzz7DoEGD0KFDB8THx6NNmzYYOXIkxowZg0mTJhVHHomotPjxR6BxY+DvvzOnTUyAnTuBVatKNl9EpYC+vj569eqFgwcP4quvvsKjR48wc+ZMuLq6YtiwYQgLCyvpLBapr6d/gC+HtMHX0z/INa3LahfIFsvgstpFBzkjIqLiUphr3fLly9G0aVNYWFjg/9i77/CmqjcO4N+kI23ponRSyt6zDMEyBBQpoAjqDxFQNg6GaAEFZKMUkI3IpgUECyigAhawUjYyy6bIKIXaxeqkKzm/P2IvDU1H2qRpm+/nefLQe3LOve9703KSk3PvcXV1Re/evREeHp7v8QIDAyGTyTQeVlZW+k4rT7KqVeHu4QFZ1aoldkwiIlOj08CkUqnE0aNHMWrUKDx+/BhXrlzBqVOnEB8fj9mzZxcpgBUrVqB69eqwsrJCmzZtCrwk4OnTpxg1ahQ8PDygUChQt25drgROZGipqcDQocCHHwIpKeqyhg2BM2eAIUPU95UkMnFnz57FyJEj4eHhgUWLFmH8+PG4ffs2Dh48iH///Re9evUydohERETFUpy+7vDhwxg1ahROnTqFgwcPIjMzE127dkVK9nvLPNjb2yM6Olp63Lt3T99pERGREem0KreZmRm6du2K69evw9HREQ0bNizWwbdt2wY/Pz+sWrUKbdq0wZIlS+Dr64vw8HC4aln5LCMjA6+//jpcXV3x888/w9PTE/fu3YOjo2Ox4iCivJmHh0M2ciRw7drzwqFDgeXLARsb4wVGVEosWrQIAQEBCA8PR48ePbBp0yb06NEDcrn6u78aNWogMDAQ1atXN26gRERERaSPvi44OFhjOzAwEK6urjh37pzWxVWzyWQyuLu76yUPIiIqfXQamASAxo0b486dO6hRo0axD75o0SKMGDECQ4YMAQCsWrUKe/fuxYYNGzBx4sRc9Tds2IDHjx/jxIkTsLCwAAB+0CMyJCFgP2ECZNmDkhUqACtXqmdOEhEAYOXKlRg6dCgGDx4MDw8PrXVcXV2xfv36Eo6MiIhIPwzR1yUkJAAAnJyc8q2XnJyMatWqQaVSoUWLFpgzZw4aNWqUZ/309HSkp6dL24mJiQAAlUoFlUpV6PgAIOc1Qbq2LetUKhWEECaXN8Dcy3LuQgjIZDIIyKAS6n/lcrm0DQAC6ttC5MxTW94v7iuvtmVdcV5zfZ0DnQcmv/nmG4wfPx6zZ89Gy5YtUaFCBY3n7e3tC7WfjIwMnDt3DpMmTZLK5HI5unTpgpMnT2pt89tvv8HHxwejRo3Cr7/+ChcXF/Tv3x9fffUVzMzMtLbRZ8eU3a48/RLqwlRzN9W8AUAlBJ4uXgyXbt2AmjUhfvoJqF8fKOfnwqRf82Lmborn7J9//imwjqWlJQYNGlQC0RAREemfvvs6lUqFzz//HO3atUPjxo3zrFevXj1s2LABTZs2RUJCAhYsWIC2bdvi6tWrqFJF+32L/f39MXPmzFzl8fHxSEtLK1R82VyUSpgBUCmViI+L06ltWadSqZCQkAAhhDQz1lQw97Kbe1JSEryq10GSWQXEZVlBaeOAug3lSLWsgbgs9VhVklkavKqnICkpCXH//V1ry/vFfeXVtqwrzmuelJSklxh0Hpjs0aMHAOCtt96CLMd95bJHk5VKZaH28/DhQyiVSri5uWmUu7m54caNG1rb3LlzB3/99RcGDBiAffv24datWxg5ciQyMzMxffp0rW302TEBZf8PtThMNXeTy1ulAv7LU6VSIcHJCbKffoKyUSP1Yjfl5D/g/Jjca55DcXPXV+dUlgQEBMDW1hZ9+vTRKN+xYwdSU1M5IElERGWevvu6UaNG4cqVKzh27Fi+9Xx8fODj4yNtt23bFg0aNMDq1avzXONg0qRJ8PPzk7YTExPh5eUFFxeXQk+iySb7b/KL3MxM663GyjOVSgWZTAYXFxeTfD/M3Mtm7snJybgf8Q/slI5wNa8As9SHuHntEmwyVHA1d1bXUabgfsRTaSEuQHveL+4rr7ZlXXFec30tRqbzwOShQ4f0cuCiUKlUcHV1xZo1a2BmZoaWLVsiKioK3333XZ4Dk/rsmLJjKMt/qMVhqrmbTN5CAGvXQhYQAPHXX4C1tZR7xW7dynfuLzCZ11yL4uZekitllhb+/v5YvXp1rnJXV1d89NFHhfqwduTIEXz33Xc4d+4coqOjsWvXLvTu3Vt6fvDgwdi4caNGG19f31z36yIiIjIEffR12UaPHo09e/bgyJEjec56zIuFhQWaN2+OW7du5VlHoVBAoVDkKpfL5Tq/txEvtDc1MpmsSOetPGDuZTP37MusZRCQy9T/qlQqaRsAZBDSxLqcOb6Y94v7yq9tWVfU11xf50DngcmOHTvq5cDOzs4wMzNDbGysRnlsbGyeNzf28PCAhYWFxmXbDRo0QExMDDIyMmBpaZmrjT47pmxl+Q+1uEw193Kfd2Ii8PHHQFAQAED2xRfAmjXqn8t77nkw1byB4uVuiucrMjJS632Xq1WrhsjIyELtIyUlBc2aNcPQoUPxzjvvaK3TrVs3BAQESNva+jYiIiJD0EdfJ4TAmDFjsGvXLoSGhhZpzQKlUonLly9LV/EREVHZp/PAJAA8ffoU69evx/Xr1wEAjRo1wtChQ+Hg4FDofVhaWqJly5YICQmRZoWoVCqEhIRg9OjRWtu0a9cOW7duhUqlkj783rx5Ex4eHloHJYmoEM6fB/r2BXJ+82xpWe7vI0mkL66urrh06VKuxdguXryISpUqFWof3bt3R/fu3fOto1AouCopEREZhT76ulGjRmHr1q349ddfYWdnh5iYGACAg4MDrK2tAQADBw6Ep6cn/P39AQCzZs3Cyy+/jNq1a+Pp06f47rvvcO/ePQwfPlx/yRERkVHpPDB59uxZ+Pr6wtraGq1btwagXl3722+/xYEDB9CiRYtC78vPzw+DBg1Cq1at0Lp1ayxZsgQpKSnSKt0vdkyffvopvv/+e4wdOxZjxozBP//8gzlz5uCzzz7TNQ0iEgJYsQIYNw7IyFCXOTgA69cD776r3ubgJFGB+vXrh88++wx2dnZ45ZVXAACHDx/G2LFj8f777+vtOKGhoXB1dUXFihXx6quv4ptvvsn3w6C+F3/LvmxFBvVlLNl3mc65XZhVCsvLAkmmvEhWNlM/B6aeP8BzkDP/8n4O9NHXrVy5EgDQqVMnjfKAgAAMHjwYgHpmZs6rL548eYIRI0YgJiYGFStWRMuWLXHixAk0bNiw+EkREVGpoPPA5BdffIG33noLa9euhbm5unlWVhaGDx+Ozz//HEeOHCn0vvr27Yv4+HhMmzYNMTEx8Pb2RnBwsLQgzosdk5eXF/bv348vvvgCTZs2haenJ8aOHYuvvvpK1zSITNvTp8Dw4cAvvzwve+kl9aXcNWsaLSyismj27NmIiIjAa6+9JvWLKpUKAwcOxJw5c/RyjG7duuGdd95BjRo1cPv2bUyePBndu3fHyZMnNW5vkpO+F39LSkpC7RrV4FoBsLFIxy+ffg171TMkyq3hapEO2wqAeY1qWlcpXNZpGdKV6VCYKbiCYTli6ufA1PMHeA5y5p+SkmLscAxKH32dEKLAOqGhoRrbixcvxuLFi3WOV1/Epk14EhsLRzc3yAquTkRERVCkGZM5ByUBwNzcHF9++SVatWqlcwCjR4/O89LtFzsmQL0y26lTp3Q+DhH958wZ9aXbd+8+L/v8c2DePPUl3ESkE0tLS2zbtg2zZ8/GxYsXYW1tjSZNmqBatWp6O0bO2ShNmjRB06ZNUatWLYSGhuK1117T2kbfi78lJyfj1t17yGoA2FdQIL7Oy3CxSEd8pgIiU4bEFCDi7j2tqxT2du2t8/FKO1NeJCubqZ8DU88f4DnImX9ycrKxwzGokujrSqVOnZARFweUk9V3iYhKI50HJu3t7REZGYn69etrlN+/fx92dnZ6C4yIDOSPP54PSlasCAQGAm+9ZdSQiMqDunXrom7duiVyrJo1a8LZ2Rm3bt3Kc2BS34u/ZV+mLQCNC7mF9EC5XKUwP6a8SFY2Uz8Hpp4/wHNgavmXZF9HRESmQeeByb59+2LYsGFYsGAB2rZtCwA4fvw4JkyYgH79+uk9QCLSs6+/Bg4fBp49A376CSjv33QTGZhSqURgYCBCQkIQFxeX6z5jf/31l96P+eDBAzx69AgeHh563zcREdGLjNHXERGRadB5YHLBggWQyWQYOHAgsrKyAAAWFhb49NNPMXfuXL0HSETF9OLlJ2ZmwI4dgJ0dYGFhvLiIyomxY8ciMDAQb7zxBho3bgyZTPe7UCUnJ+PWrVvS9t27dxEWFgYnJyc4OTlh5syZePfdd+Hu7o7bt2/jyy+/RO3ateHr66vPVHRS78Y5OItUVJTZ4Eb9/G/lEhoRivSsdCjMFehUvVPJBEhERHqjj76uTAoNhWVsLODmBrz6qrGjISIql3QemLS0tMTSpUvh7++P27dvAwBq1aoFGxsbvQdHRMWgUgELFwLTpwMhIYCPz/PnnJyMFxdRORMUFITt27ejR48eRd7H2bNn0blzZ2k7+96QgwYNwsqVK3Hp0iVs3LgRT58+ReXKldG1a1fMnj1b66XaJWXYmulwehKPxxVdMGHR3nzrfrDzA0QlRcHTzhMP/B6UUIRERKQv+ujryiLZwIFwioqC8PQEHrD/IiIyBJ0HJhMSEqBUKuHk5IQmTZpI5Y8fP4a5uXmRbqhPRHr28CEwaBCwb596u29f4OJF9T0liUivLC0tUbt27WLto1OnTvmuVrp///5i7Z+IiKg49NHXERERaaPzXZrff/99BAUF5Srfvn27xqqhRGQkR48C3t7PByVlMuDDD9WXbhOR3o0bNw5Lly7Nd2CRiIioLGNfR0REhqLzjMm///4bixYtylXeqVMnfP3113oJioiKQKUC5s4Fpk0DlEp1mYsL8OOPQNeuxo2NqBw7duwYDh06hD/++AONGjWCxQv3bt25c6eRIiMiItIP9nVERGQoOg9MpqenS4ve5JSZmYlnz57pJSgi0lFsrHpW5MGDz8s6dQK2bgW4ai+RQTk6OuLtt982dhhEREQGw76OiIgMReeBydatW2PNmjVYvny5RvmqVavQsmVLvQVGRIV0/Djwv/8BMTHqbZlMPWty6lT1CtxEZFABAQHGDoGIiMig2NcREZGh6Dww+c0336BLly64ePEiXnvtNQBASEgIzpw5gwMHDug9QCIqgK0t8OSJ+md3d2DLFuDVV40bE5GJycrKQmhoKG7fvo3+/fvDzs4O//77L+zt7WFra2vs8IiIiIqNfR0RERmCzgOT7dq1w8mTJ/Hdd99h+/btsLa2RtOmTbF+/XrUqVPHEDESUX6aNQOWLgV++QXYvBlwczN2REQm5d69e+jWrRsiIyORnp6O119/HXZ2dpg3bx7S09OxatUqY4dIRERULOzriIjIUHQemAQAb29vbNmyRd+xEFFhHD8OvPQSYGn5vOyjj4ARIwC53HhxEZmosWPHolWrVrh48SIqVaoklb/99tsYMWKEESMjIiLSD/Z1RERkKIUemMzKyoJSqYRCoZDKYmNjsWrVKqSkpOCtt95C+/btDRIkEQHIygJmzADmzAG++AJYuPD5czKZ+kFEJe7o0aM4ceIELHN+WQCgevXqiIqKMlJURERE+sO+joiIDKXQA5MjRoyApaUlVq9eDQBISkrCSy+9hLS0NHh4eGDx4sX49ddf0aNHD4MFS2SyHjwA+vcHjh5Vby9aBLzzDtCunXHjIiKoVCoolcpc5Q8ePICdnZ0RIioZXy7aA1eLdMRlKgqs+8DvQQlEREREhmKqfZ2IjERsXBxcXV3BKQBERIZR6Os+jx8/jnfffVfa3rRpE5RKJf755x9cvHgRfn5++O677wwSJJFJ++MPwNv7+aCkmRkwbx7g42PUsIhIrWvXrliyZIm0LZPJkJycjOnTp/PLOiIiKhfY1xERkaEUemAyKipKY3GbkJAQvPvuu3BwcAAADBo0CFevXtV/hESmKjMT+OoroEcP4NEjdZmXF3DkCPDll7yfJFEpsXDhQhw/fhwNGzZEWloa+vfvL13aNm/ePGOHR0REVGzs64iIyFAKfSm3lZUVnj17Jm2fOnVKY4aklZUVkpOT9RsdkamKjATefx84efJ5Wc+eQGAg4ORktLCIKLcqVarg4sWLCAoKwqVLl5CcnIxhw4ZhwIABsLa2NnZ4RERExca+joiIDKXQA5Pe3t7YvHkz/P39cfToUcTGxuLVV1+Vnr99+zYqV65skCCJTMrly0DHjsCTJ+ptCwv1pduff84FbohKKXNzc3zwwQfGDqNE9dy9DpXSE/BI4YDfeue/IuvM0JlISE+Ag8IB0ztNL6EIiYhIn0yxr8OsWbCLjgY8PNSLUBIRkd4VemBy2rRp6N69O7Zv347o6GgMHjwYHh4e0vO7du1COy7EQVR89esDdesCf/8NVK8ObNsGtG5t7KiIKA+bNm3K9/mBAweWUCQlq8OR3XB6Eo/HFV0KHJhce34topKi4GnnyYFJIqIyyFT7Otm6dagQFQXh6cmBSSIiAyn0wGTHjh1x7tw5HDhwAO7u7ujTp4/G897e3mjNwROi4rOwUA9GTp8OLFkCODoaOyIiysfYsWM1tjMzM5GamgpLS0vY2NiU2w9rRERkOvTR1/n7+2Pnzp24ceMGrK2t0bZtW8ybNw/16tXLt92OHTswdepUREREoE6dOpg3bx4X3CEiKkd0Wj2jQYMGGDt2LPr27Qv5CwtvfPTRR/D29tZnbESmYedOICxMs6xaNfX9JDkoSVTqPXnyROORnJyM8PBwtG/fHj/99JOxwyMiIio2ffR1hw8fxqhRo3Dq1CkcPHgQmZmZ6Nq1K1JSUvJsc+LECfTr1w/Dhg3DhQsX0Lt3b/Tu3RtXrlzRV2pERGRkXNaXyFjS0oAxY4B33wXeew9ISjJ2RESkJ3Xq1MHcuXNzzTAhIiIqL3Tt64KDgzF48GA0atQIzZo1Q2BgICIjI3Hu3Lk82yxduhTdunXDhAkT0KBBA8yePRstWrTA999/r680iIjIyAp9KTcR6dGtW+rByAsX1Nv//ANs2gSMGmXcuIhIb8zNzfHvv/8aOwwiIiKDKU5fl5CQAABwcnLKs87Jkyfh5+enUebr64vdu3fn2SY9PR3p6enSdmJiIgBApVJBpVLpFGPOZSd1bVvWqVQqCCFMLm+Auesz94cPH0p/g9ns7e3h7OxskHZCCMhkMgjIoBLqf+VyubQNAAIydZ0ceapUKjx9+hRJSUmQ/bfg7L1796BUqgpsW9YV5zXX1zngwCRRSdu2DRgx4vkMSYUCWLoU+Ogj48ZFREXy22+/aWwLIRAdHY3vv/+ei8IREVG5oO++TqVS4fPPP0e7du3QuHHjPOvFxMTAzc1No8zNzQ0xMTF5tvH398fMmTNzlcfHxyMtLU2nOF2USpgBUCmViI+L06ltWadSqZCQkAAhRK7buJV3zF0/uSckJGDl8gXITNO8MtDCyg6fjhkPBwcHvbYDgKSkJHhVr4MkswqIy7KC0sYBdRvKkWpZA3FZ9uo6Zmnwqp6CpKQkxP33d/306VPsCNqMmAd3AAgAQFp6JqxtHfAYVWCbZZtn27KuOK95kp6u+uTAJFFJefYM+OILYPXq52V16wLbtwPNmhkvLiIqlt69e2tsy2QyuLi44NVXX8XChQuNExQREZEe6buvGzVqFK5cuYJjx47pKcLnJk2apDHLMjExEV5eXnBxcYG9vb1O+5KZmQEA5GZmcHV11WucpZ1KpZJeZ1McnGPuxc89OTkZd26cxxdvKuDlYg0AuB//DIv3pMMsn7+porbLbns/4h/YKR3hal4BZqkPcfPaJdhkqOBqrp5tmaxMwf2Ip7Czs5P2lZSUhNioO3i3cSSqulgBAP6+/hT+R8NhlZaZb9uyrjivuZWVlV5i0Hlgctq0aejcuTN8fHz0FgRRuRcerr50+9Kl52UDBgArVwJ2dsaLi4iKrbxcxkFERJQXffZ1o0ePxp49e3DkyBFUqVIl37ru7u6IjY3VKIuNjYW7u3uebRQKBRQKRa5yuVyu84du8UJ7UyOTyYp03soD5l783LMvea7qYoVanjbqMggIkSYdQ5/tcraVQUAuU/+rUqmk7ef7Ehr7ynnM2v8dMzI2tVBty4Oivub6Ogc67+XkyZPo2bMnHB0d0aFDB0yZMgV//vknnj17ppeAiMqdhATAx+f5oKS1NbB+PbB5MwcliYiIiMgkCCEwevRo7Nq1C3/99Rdq1KhRYBsfHx+EhIRolB08eBA+Pj6GCpOIiEqYzjMmDx48iKysLPz99984cuQIDh8+jGXLliE9PR0vvfSSQabjE5VpDg7A5MnAhAlAgwbAjh1Ao0bGjoqI9OTFm/LnZ9GiRQaMpGTdrNcCTimP8bhC3osWZOtYvSMepj6Es03+NywnIqLSSR993ahRo7B161b8+uuvsLOzk+4T6eDgAGtr9eWaAwcOhKenJ/z9/QEAY8eORceOHbFw4UK88cYbCAoKwtmzZ7FmzZpiZlRIr7yC9H//hWXlyiVzPCIiE1Ske0yam5ujXbt2cHFxgZOTE+zs7LB7927cuHFD3/ERlQ9+foCFBTB8OFChgrGjISI9unDhAi5cuIDMzEzUq1cPAHDz5k2YmZmhRYsWUr3sFf7Ki3Ufz4KrRTriMnNfLveiLe9sKYGIiIjIUPTR161cuRIA0KlTJ43ygIAADB48GAAQGRmpcWlg27ZtsXXrVkyZMgWTJ09GnTp1sHv37nwXzNEn8eOPeBIXB1dXV5SvXpyIqPTQeWByzZo1CA0NxeHDh5Geno4OHTqgU6dOmDJlCpo2bWqIGInKDiGAwEAgNhaYOPF5uVwOjB1rtLCIyHB69uwJOzs7bNy4ERUrVgQAPHnyBEOGDEGHDh0wbtw4I0dIRERUPPro64QQBdYJDQ3NVdanTx/06dNH55iJiKhs0Hlg8pNPPoGLiwvGjRuHkSNHwtbW1hBxEZU9ycnAyJHqe0fKZEDr1sCrrxo7KiIysIULF+LAgQPSBzUAqFixIr755ht07dqVA5NERFTmsa8jIiJD0Xnxm507d2LAgAEICgqCi4sL2rZti8mTJ+PAgQNITU01RIxEpd+lS8BLL6kHJQH1zMk//zRuTERUIhITExEfH5+rPD4+HklJSUaIiIiISL/Y1xERkaHoPGOyd+/e6N27NwAgISEBR48exY4dO/Dmm29CLpcjLS1N3zESlV5CAGvXqi/Tzv7dt7UF1qwB+vUzbmxEVCLefvttDBkyBAsXLkTr1q0BAH///TcmTJiAd955x8jRGc64eSPhlPQIj+0qYcFXK/Ot++rGVxGbEgu3Cm74a9BfJRQhERHpi6n2dbIuXVApKgoyT0/gL/ZfRESGUKTFbx49eoTDhw8jNDQUoaGhuHr1KipWrIgOHTroOz6i0isxEfj4YyAo6HmZtzewfTtQp47RwiKikrVq1SqMHz8e/fv3R2ZmJgD1InHDhg3Dd999Z+ToDMctNhJOT+JhUTGlwLo3H91EVFIUEtISSiAyIiLSN1Pt63DzJiyioiBSCu7riIioaHQemGzSpAmuX7+OihUr4pVXXsGIESPQsWNHLnxDpuXCBeC994Bbt56XjRwJLFwIWFkZLy4iKnE2Njb44Ycf8N133+H27dsAgFq1aqFChQpGjoyIiEg/2NcREZGhFGnxm44dO6Jx48aGiIeo9BNCPVMye1DS3h5Yvx743/+MGxcRGVV0dDSio6PxyiuvwNraGkIIyGQyY4dFRESkN+zriIhI33Re/GbUqFFo3LgxMjIyEB4ejqysrGIHsWLFClSvXh1WVlZo06YNTp8+Xah2QUFBkMlk0j0viUqETAZs2gRUqAC0aqWePclBSSKT9ejRI7z22muoW7cuevTogejoaADAsGHDuEopERGVC+zriIjIUHQemHz27BmGDRsGGxsbNGrUCJGRkQCAMWPGYO7cuToHsG3bNvj5+WH69Ok4f/48mjVrBl9fX8TFxeXbLiIiAuPHj+d9LalkKJWa2/Xrq2+AfewYULOmcWIiolLhiy++gIWFBSIjI2FjYyOV9+3bF8HBwUaMjIiISD/Y1xERkaHoPDA5ceJEXLx4EaGhobDKcS+9Ll26YNu2bToHsGjRIowYMQJDhgxBw4YNsWrVKtjY2GDDhg15tlEqlRgwYABmzpyJmhwUIkMSAli6FE5vvgk8e6b5XOvWgEJhnLiIqNQ4cOAA5s2bhypVqmiU16lTB/fu3TNSVERERPrDvo6IiAxF53tM7t69G9u2bcPLL7+scT+RRo0aSTdCLqyMjAycO3cOkyZNksrkcjm6dOmCkydP5tlu1qxZcHV1xbBhw3D06NF8j5Geno709HRpOzExEQCgUqmgUql0ije7nRCiSG3LOpPL/fFjyIYNg/y332AJQOXnB9XKlcaOqkSZ3Gv+H1PNGyh+7qZ4zlJSUjRmj2R7/PgxFPzygoiIygH2dUREZCg6D0zGx8fD1dU1V3lKSorONz5++PAhlEol3NzcNMrd3Nxw48YNrW2OHTuG9evXIywsrFDH8Pf3x8yZM3OVx8fHIy0tTad4AfWH7oSEBAghIJfrPOG0TDOl3C3OnYPjxx9DHhUllaXK5UiOjVXfY9JEmNJrnpOp5g0UP/ekpCQDRFW6dejQAZs2bcLs2bMBADKZDCqVCvPnz0fnzp2NHB0REVHxsa8jIiJD0XlgslWrVti7dy/GjBkDANJg5Lp16+Dj46Pf6F6QlJSEDz/8EGvXroWzs3Oh2kyaNAl+fn7SdmJiIry8vODi4gJ7e3udY1CpVJDJZHBxcTHJAYtyn7tKBSxaBNnXX0P238JOwskJT5YsgX2/frApr3nnwSRecy1MNW+g+LnnvMWHqZg/fz5ee+01nD17FhkZGfjyyy9x9epVPH78GMePHzd2eERERMXGvo6IiAxF54HJOXPmoHv37rh27RqysrKwdOlSXLt2DSdOnMDhw4d12pezszPMzMwQGxurUR4bGwt3d/dc9W/fvo2IiAj07NlTKsu+bNDc3Bzh4eGoVauWRhuFQqH18gK5XF7kAQeZTFas9mVZuc794UNg8GBg797nZe3aQWzZggyFovzmXYBy/Zrnw1TzBoqXuymer8aNG+PmzZv4/vvvYWdnh+TkZLzzzjsYNWoUPDw8jB2ewex5axgqZSbhkYVdgXWndZyG5Ixk2FralkBkRESkb6ba14kpU5AUEwNbd3eYzjVTREQlS+eByfbt2yMsLAxz585FkyZNcODAAbRo0QInT55EkyZNdNqXpaUlWrZsiZCQEPTu3RuAeqAxJCQEo0ePzlW/fv36uHz5skbZlClTkJSUhKVLl8LLy0vXdIjUjh0D+vUDHjx4XjZpEjBrFiCXAwWsEk9EpikzMxPdunXDqlWr8PXXXxd5P0eOHMF3332Hc+fOITo6Grt27ZL6RQAQQmD69OlYu3Ytnj59inbt2mHlypWoU6eOHrIoYsyd3oarRTriMgu+t9hHLT8qgYiIiMgQ9NXXlUkffYTUuDjYarmVGRER6YfOA5MAUKtWLaxdu1YvAfj5+WHQoEFo1aoVWrdujSVLliAlJQVDhgwBAAwcOBCenp7w9/eHlZUVGjdurNHe0dERAHKVE+nk4MHng5IuLsDmzYCvr3rbBBfzIKLCsbCwwKVLl4q9n5SUFDRr1gxDhw7FO++8k+v5+fPnY9myZdi4cSNq1KiBqVOnwtfXF9euXTPJy+eJiKjk6KuvIyIi0qZIA5P61LdvX8THx2PatGmIiYmBt7c3goODpQVxIiMjTfLSQCph06YBhw+rF7bZsgWoXNnYERFRGfHBBx9g/fr1mDt3bpH30b17d3Tv3l3rc0IILFmyBFOmTEGvXr0AAJs2bYKbmxt2796N999/v8jHJSIiKgx99HVERETaFHpgUi6XF7jqtkwmQ9Z/C4boYvTo0Vov3QaA0NDQfNsGBgbqfDwiREcDOe+HY2YG7NoF2NurfyYiKqSsrCxs2LABf/75J1q2bIkKFSpoPL9o0aJi7f/u3buIiYlBly5dpDIHBwe0adMGJ0+ezHNgMj09Henp6dJ2YmIiAPUtU1RFmAkuhIBMJoMMgAwCjk/jYS9/hgyVNZ46uqjLZTIIIXLtPzopGkqhhJnMDB525eNeZCqVSmuupsTUz4Gp5w/wHOTMv7yfA0P3daVWdDTksbGAUgl4eho7GiKicqnQA5O7du3K87mTJ09i2bJl5b5DpnJAqQS++Qbw91fPkGzT5vlzFSsaLy4iKnPu3LmD6tWr48qVK2jRogUA4ObNmxp1CvpCrzBiYmIAQLqSIJubm5v0nDb+/v6YOXNmrvL4+HikpaXpHEdSUhJq16gG1wqAjUU6vpo1BA5P4pFQ0QXzlv8C2wqAeY1qSEpKQtwL9+V96ceXEJ0SDY8KHjj/wXmdj10aqVQqJCQkQAhhsld2mPo5MPX8AZ6DnPmnpKQYOxyDKKm+rrSStWkD16goCE9PzXvRExGR3hR6YDL78rGcwsPDMXHiRPz+++8YMGAAZs2apdfgiPQqJgYYMAD46y/1dt++wMWLgIODceMiojKpTp06iI6OxqFDhwCob02ybNmyXAOIxjJp0iT4+flJ24mJifDy8oKLiwvs7e113l9ycjJu3b2HrAaAfQUFsr+KVAGIy1QgMQWIuHsPdnZ2cH1hkYDsAQu5XJ7rubJKpVJBJpPBxcXFJAdkAJ4DU88f4DnImX9ycrKxwzGI0t7XERFR2Veke0z++++/mD59OjZu3AhfX1+EhYVx8Rkq3f78Uz0omT2LRy4Hhg8HbG2NGxcRlVlCCI3tP/74wyAzZtzd3QEAsbGx8MhxC4rY2Fh4e3vn2U6hUEChyL1itlwuL9IAQvZl2gKAgAzZ2efczr7cO7/9l6fBi+xcy1NOujL1c2Dq+QM8B+U9f333dUeOHMF3332Hc+fOITo6Grt27ULv3r3zrB8aGorOnTvnKo+Ojpb6RyIiKtt06kETEhLw1VdfoXbt2rh69SpCQkLw+++/c1CSSq+sLGDqVKBr1+eDkpUrq2dNTpnC+0kSkd68+OFNX2rUqAF3d3eEhIRIZYmJifj777/h4+NjkGMSERFpU9y+LiUlBc2aNcOKFSt0ahceHo7o6GjpUV5m3xMRkQ4zJufPn4958+bB3d0dP/30k9ZLu4lKlagooH9/4MiR52XdugGbNgEuLsaLi4jKBZlMluu+WkW9z1ZycjJu3bolbd+9exdhYWFwcnJC1apV8fnnn+Obb75BnTp1UKNGDUydOhWVK1fOd5YJERFRcemzrwOA7t27o3v37jq3c3V1haOjY5GPS0REpVehByYnTpwIa2tr1K5dGxs3bsTGjRu11tu5c6fegiMqskOHgPfeAx4+VG+bmQHffgtMmKC+jJuIqJiEEBg8eLB0uXRaWho++eSTXCuVFqZfPHv2rMalatn3hhw0aBACAwPx5ZdfIiUlBR999BGePn2K9u3bIzg4GFZWVnrMiIiISJM++7ri8Pb2Rnp6Oho3bowZM2agXbt2edZNT09Henq6tJ2YmAgARVo9PecQrKkt9Jpz1XlTw9z1k3v2LX4EZFAJ9V+TgEy6PVBexyhqO21tBdS32yhoX3kdszBty7rivOb6OgeFHpgcOHBguV5xjcoZR0fgvzchqFIFCAoC8nkDQ0Skq0GDBmlsf/DBB0XeV6dOnfK9PE4mk2HWrFlcZI6IiEqUPvu6ovDw8MCqVavQqlUrpKenY926dejUqRP+/vtvaZXwF/n7+2PmzJm5yuPj45GWlqbT8V2USpgBUCmViM++LZSJyLnqfHm9h2pemLt+ck9KSoJX9TpIMquAuCz1l+lJZmnwqp6CpKQkxOXxN1XUdtraKm0cULehHKmWNRCXZZ/nvpKTk+Hs6oFkswqIy1J/EVPYtmVdcV7zpKQkvcRQ6IHJwMBAvRyQqEQ0bw4sXgz88QcQGAhUqmTsiIionAkICDB2CERERAZl7L6uXr16qFevnrTdtm1b3L59G4sXL8bmzZu1tpk0aZJ05QGgnjHp5eUFFxcX2Nvb63R82X/3o5ebmZncfS1zrjpvioNzzL34uScnJ+N+xD+wUzrC1Vw9yzpZmYL7EU9hZ2eX599UUdtpa2uW+hA3r12CTYYKrubOee4rKSkJD+OiYauMh6u5DQAUum1ZV5zXXF9XbxVpVW6iUufQIaB9e8DC4nnZp5+qH5zpS0RERERULrRu3RrHjh3L83mFQiFdep5TUVZPz3ktg6kNUAHlf9X5/DD34ueefcmzDAJymfqvSQYhXTad1/6L2k5bWxnUlygXtK+8jlmYtuVBUV9zfZ2D8nMmyTRlZAB+fsCrr6pX2c5JJuOgJBERERFRORIWFgYPDw9jh0FERHrCGZNUdt29C7z/PnD6tHp7/nzgf/8DXnrJuHEREZmAhRNWwEX+DPEq6wLrhgwMQZYqC+Zyvu0gIjJlycnJuHXrlrR99+5dhIWFwcnJCVWrVsWkSZMQFRWFTZs2AQCWLFmCGjVqoFGjRkhLS8O6devw119/4cCBAyUSrzh4EI/i4uDk6gpOdyAiMgx+QqCyaedOYOhQICFBvW1pCSxYALRqZdy4iIhMRKxHNQiLdMRl5r5c7kX1nOsVWIeIiMq/s2fPonPnztJ29r0gBw0ahMDAQERHRyMyMlJ6PiMjA+PGjUNUVBRsbGzQtGlT/Pnnnxr7MKh69ZBVsSJQTu4lR0RUGnFgksqW9HRg/Hjg+++fl9WsCWzfDrRsaby4iIiIiIgoX506dYIQIs/nX1xw9csvv8SXX35p4KiIiMiYODBJZcetW0DfvsD588/L3nsPWLMGcHAwXlxERERERERERKQzDkxS2XD+PNCpE5CUpN5WKIAlS4CPP+YCN0RERtD65H44K5Px0MwWf/t0y7fu1stbkZqZChsLG/Rv0r+EIiQiIiqmrVthHRsLuLkBH3xg7GiIiMolDkxS2dC4MVC/PnDmDFCnjvrSbW9vY0dFRGSy/rdjOZyexONxRZcCBya/PPglopKi4GnnyYFJIiIqM2QTJ8IhKgrC05MDk0REBiI3dgBEhWJpCWzbBowYAZw7x0FJIiIiIiIiIqIyjgOTVDpt2QJcvqxZVqOG+n6SdnbGiYmIiIiIiIiIiPSGA5NUuqSmAsOGqS+VeO89IDnZ2BEREREREREREZEBcGCSSo9r14DWrYENG9TbN26oL98mIiIiIiIiIqJyhwOTVDoEBgKtWgFXr6q3bWyAjRvVsyeJiIiIiIiIiKjc4arcZFzJycCoUcCmTc/LGjdWr7rdoIHx4iIiIiIiIiIiIoPijEkynsuXgZde0hyUHDECOH2ag5JEREREREREROUcZ0yScTx+DLRrByQlqbdtbYHVq4H+/Y0bFxERERERERERlQjOmCTjcHICvv5a/bO3N3DuHAcliYjKkESHSkio6IJEh0oF1nW3dYennSfcbd1LIDIiIiI9cXeH0sMDcGf/RURkKJwxScYzYYJ6puSwYYCVlbGjISIiHXwzfSNcLdIRl6kosO7Zj86WQERERET6JU6fRnxcHFxdXSEzdjBEROUUZ0yS4QkB/PADMH++Zrlcrl74hoOSREREREREREQmhzMmybASEoDhw4Gff1YPRLZpA3TsaOyoiIiIiIiIiIjIyDhjkgznzBmgeXP1oCQAqFTA0aPGjYmIiIiIiIiIiEoFzpgk/RMCWLZMfQ/JzEx1maMjEBgI9OplzMiIiEhPPgz0h9Ozp3hs7YhNgyfnW/fj3z/G47THcLJywuqeq0soQiIiouKRffIJHKOjIfPwANasMXY4RETlEgcmSb8ePwaGDgV+/fV5WZs2wLZtQLVqxouLiIj0qsml43B6Eo/HFV0KrLv3n72ISoqCp51nCURGRESkJ/v2wSoqCsKT/RcRkaHwUm7Sn1On1Jdu5xyUHD9effk2ByWJiIiIiIiIiCgHzpgk/VCpgE8/BSIj1dtOTsCmTcAbbxg3LiIiIiIiIiIiKpU4Y5L0Qy4HtmwBrK2Bdu2AsDAOShIRERERkeTIkSPo2bMnKleuDJlMht27dxfYJjQ0FC1atIBCoUDt2rURGBho8DiJiKjkcGCSii4rS3O7YUPgyBEgNBTw8jJKSEREREREVDqlpKSgWbNmWLFiRaHq3717F2+88QY6d+6MsLAwfP755xg+fDj2799v4EiJiKik8FJu0p1KBcybB+zapR6ItLJ6/lyrVsaLi4iIiIiISq3u3buje/fuha6/atUq1KhRAwsXLgQANGjQAMeOHcPixYvh6+trqDCJiKgElYqByRUrVuC7775DTEwMmjVrhuXLl6N169Za665duxabNm3ClStXAAAtW7bEnDlz8qxP+iV/+BCygQOBgwfVBePHA99/b9ygiIiIiIio3Dl58iS6dOmiUebr64vPP/88zzbp6elIT0+XthMTEwEAKpUKKpVKp+PLcvysa9uyTqVSQQhhEnk/fPhQ+j0BACEElEolnJ2djRiV2oux2dvbFyquF9sVtq0+X3chBGQyGQRkUAn1X5OADBmZSkREREAIoTWuwrYrTFsBGeRyeYH7ioiIUOf+Qr3CtC3sa1Ja6PP3XV//Pxh9YHLbtm3w8/PDqlWr0KZNGyxZsgS+vr4IDw+Hq6trrvqhoaHo168f2rZtCysrK8ybNw9du3bF1atX4enpaYQMTEhoKCr17w9ZbKx6WyYDKlUChFD/TEREREREpCcxMTFwc3PTKHNzc0NiYiKePXsGa2vrXG38/f0xc+bMXOXx8fFIS0vT6fguSiXMAKiUSsTHxenUtqxTqVRISEiAEAJyefm9A1xCQgJWLl+AzLSkHKUyuFepiT7vfwhHR0djhaY1NgsrO3w6ZjwcHBx0alfYtvp83ZOSkuBVvQ6SzCogLkt9leW/6clQ2GRh26YfYGFhoTWuwrYrTFuljQPqNpQj1bIG4rLs89xXenoWKtjZ4QlsEJdVAQAK3bYw57W00Pfve1JSUsGVCsHoA5OLFi3CiBEjMGTIEADq6fp79+7Fhg0bMHHixFz1t2zZorG9bt06/PLLLwgJCcHAgQNz1dfnN2bZ7UzlmyOJUgnMmQPZrFmQ/5e3cHOD2LwZeO019cBkjm8tyhuTfM3/Y6q5m2reQPFzN8VzRkRERKXHpEmT4OfnJ20nJibCy8sLLi4usLe312lfMjMzAIDczEzrpJnyTKVSQSaTwcXFpVwPTCYnJ+POjfP44k0FvFzUA92R8WnYeRUwM/Lr/mJs9+OfYfGe9ALj0pZTYdvq83VPTk7G/Yh/YKd0hKu5erDv6tOHuHPjEj7pVA91vRy1xlWYdnnl9GJbs9SHuHntEmwyVHA1d85zX39fT8DOC9ZQtFTB1bwSABSqbWHPa2mh7993q5y39SsGow5MZmRk4Ny5c5g0aZJUJpfL0aVLF5w8ebJQ+0hNTUVmZiacnJy0Pq/Pb8wA0/nmKJs8Lg4Oo0ZBceyYVJbevj0SVqyAytUVMIFvDk3tNc/JVHM31byB4ueur2/NqPQ73aYrKj17ikfWjgXW7de4H56kPUFFq4qGD4yIiMoNd3d3xGZfrfWf2NhY2Nvba50tCQAKhQIKhSJXuVwu1/m9jXj/faRGR8Paw8Pk3hMCgEwmK9J5K0tkMhmEEKjqYoVanjZSefYlwcbM/cXYZBAQIq3AuLTlVNi22e318bpnxyGDgFwmpDhUKhW8XCxRO4+cCtMur5xebJvdrqB93Yt9lucxdY2/NNP377u+cjbqwOTDhw+hVCq1Ts+/ceNGofbx1VdfoXLlyrnuPZJNn9+YAabzzREA4M8/IfvwQ8j+G3wUcjmSx4+H9axZcM4xfbq8M6nX/AWmmrup5g0UP3d9fWtGpd/PfT+Dq0U64jJzf/h70XddvyuBiIiIqLzx8fHBvn37NMoOHjwIHx+fEjm+mD8fiXFxsHJ1BW9cRURkGEa/lLs45s6di6CgIISGhub5YVif35hlM4VvjgAAhw8/nxFZuTLEjz8ipUEDVLCwKP+5v8BkXnMtTDV3U80bKF7upni+iIiIqHCSk5Nx69Ytafvu3bsICwuDk5MTqlatikmTJiEqKgqbNm0CAHzyySf4/vvv8eWXX2Lo0KH466+/sH37duzdu9dYKRARkZ4ZdWDS2dkZZmZmWqfnu7u759t2wYIFmDt3Lv788080bdrUkGGarpkzgSNHgAoVgM2b1QvdmMCl20REREREpH9nz55F586dpe3sK9sGDRqEwMBAREdHIzIyUnq+Ro0a2Lt3L7744gssXboUVapUwbp16+Dr61visRMRkWEYdWDS0tISLVu2REhICHr37g1AfRlhSEgIRo8enWe7+fPn49tvv8X+/fvRqlWrEorWBDx4AFSp8nzb3Bz4/XfA3h6QywEuakFEREREREXUqVMniHwWzQwMDNTa5sKFCwaMioiIjMno19z5+flh7dq12LhxI65fv45PP/0UKSkp0irdAwcO1FgcZ968eZg6dSo2bNiA6tWrIyYmBjExMUhOTjZWCmVfZiYwcSJQuzZw5ozmc46O6kFJIiKiHGZPeg/ThnfD7EnvFVi3/vf1Ye9vj/rf1y+ByIiIiPRD1rAhXOvUgaxhQ2OHQkRUbhl9xKlv375YsGABpk2bBm9vb4SFhSE4OFhaECcyMhLR0dFS/ZUrVyIjIwP/+9//4OHhIT0WLFhgrBTKtvv3gU6dgHnzgPR0oG9fgKvqEhGVOjNmzIBMJtN41K9vvIE+RXoqrNJSoUhPLbBuckYykjKSkJzBLxGJiKgMSU6GPDkZ4CQYIiKDKRWL34wePTrPS7dDQ0M1tiMiIgwfkKn4/Xdg8GDg8WP1trk5MHo0YGtr1LCIiEi7Ro0a4c8//5S2zc1LRTdORERERERUJPxEY4oyMoBJk4BFi56XVasGbNsGtGljvLiIiChf5ubmBS4OR0REREREVFZwYNLU3L0LvP8+cPr087LevYENG4CKFY0WFhERFeyff/5B5cqVYWVlBR8fH/j7+6Nq1apa66anpyM9PV3aTkxMBKBeZE5VhMXMhBDqS8gByCAg+68857ZMJoMQIt/9F+XYpZFKpSow1/LO1M+BqecP8BzkzN9UzwEREVFxcWDSlAQHqwclExLU2xYWwIIFwJgxgEyWf1siIjKqNm3aIDAwEPXq1UN0dDRmzpyJDh064MqVK7Czs8tV39/fHzNnzsxVHh8fj7S0NJ2Pn5SUhNo1qsG1AmBjkS7dpFoOwNUiHbYVAPMa1ZCUlIS4uDiNttkf2FUqVa7nyiqVSoWEhAQIISA30UXiTP0cmHr+AM9BzvxTUlKMHQ4REVGZxIFJU+LiAqT+t0hBzZrqS7dbtTJuTEREVCjdu3eXfm7atCnatGmDatWqYfv27Rg2bFiu+pMmTYKfn5+0nZiYCC8vL7i4uMDe3l7n4ycnJ+PW3XvIagDYV1Age26QCkBcpgKJKUDE3Xuws7ODq6urRtvsAQu5XJ7rubJKpVJBJpPBxcXFJAdkAJ4DU88f4DnImX8yF0chIiIqEg5MmpKWLdUzJI8dA9auBRwcjB0REREVkaOjI+rWrYtbt25pfV6hUEChUOQql8vlRRpAyL5MWwAQkEH8V55zO/ty7/z2X54GL7JzLU856crUz4Gp5w/wHJh6/kRERMXFHrQ8O3AAyMrSLBszRj1TkoOSRERlWnJyMm7fvg0PDw9jh0JERERERFQkHJgsj9LSgJEjAV9fYNo0zedkMt5PkoioDBo/fjwOHz6MiIgInDhxAm+//TbMzMzQr18/Y4dGRERERERUJLyUu7y5eRN47z3g4kX1tr+/etvb26hhERFR8Tx48AD9+vXDo0eP4OLigvbt2+PUqVNwcXExSjw/DpwIZ1UyHsptC6y76s1VeJb5DNYW1iUQGRERkX6IH37A09hYOLi5gVM7iIgMgwOT5cmWLcDHHwPZqwJaWQHffw80a2bcuIiIqNiCgoKMHYKGS97t4WqRjrjM3PexfNGbdd8sgYiIiIj07M03kR4XB5SThduIiEojDkyWB6mpwGefAevXPy+rXx/YsQNo3Nh4cREREREREREREeWBA5Nl3fXr6ku1r1x5XjZoELBiBVChgvHiIiIiIiIiIiIiygcHJsuyU6eA115Tz5gEABsb4Icf1AOTREREBlQt4jqckQpr2CCiekMAQGZGBu7du5er7pVHV2BhbQG3Sm5oWbllSYdKRERUNOfOwSI2FnBzA156ydjREBGVSxyYLMuaN1dfsn3+PNCoEbB9O9CwobGjIiIiEzBq2QQ4PYnH44oumLBoL9KTExBx9w4+nzwDCoXmfScvtj2KTKt0eFTwwL/j/zVSxERERLqRvf02KkVFQXh6Ag8eGDscIqJyiQOTZZlCAWzbBixZAsyfr54xSUREZASZ6c+gkpnD+eV3UKlyNY3nLqeeBZAOlVAZJzgiIiIiIiqVODBZVggBbNgAvPyyenZkttq11StvExERlQI2FV1g71pFo0x+T26kaIiIiIiIqDTjJ4WyICkJ+OADYPhw9UI3KSnGjoiIiIiIiIiIiKhYODBZ2oWFAS1bAlu3qrevXQN27TJqSERERERERERERMXFgcnSSghg5Ur1pdv//KMus7dX31Pygw+MGxsREREREVERrFixAtWrV4eVlRXatGmD06dP51k3MDAQMplM42FlZVWC0RIRkaHxHpOlUUICMGIEsGPH87KWLdWDkrVqGS8uKhdUKhUyMjIKXTczMxNpaWmQy03newxTzRsoOHcLCwuYmZkZITIiIiIq67Zt2wY/Pz+sWrUKbdq0wZIlS+Dr64vw8HC4urpqbWNvb4/w8HBpWyaTlVS4RERUAjgwWdqcPQv07QvcufO87LPP1KtuKxTGi4vKhYyMDNy9excqVeFWxhVCQKVSISkpyaTeBJpq3kDhcnd0dIS7u7vJnRsiIiIqnkWLFmHEiBEYMmQIAGDVqlXYu3cvNmzYgIkTJ2ptI5PJ4O7uXuhjpKenIz09XdpOTEwEoP7ytbDvgaVj5/hZ17ZlnUqlkt4XlmdCCMhkMgjIoBLqV1xAPTvX2Pm/GFth4ypOTvp83fOKQy6X55tTYdrllZO2c6atXZ77KkS9guIvzfT9+66vnDkwWZrExQGvvAI8e6bednQEAgKA3r2NGRWVE0IIREdHw8zMDF5eXoWaCSiEQFZWFszNzU1qEMpU8wbyz10IgdTUVMTFxQEAPDw8jBEiERERlUEZGRk4d+4cJk2aJJXJ5XJ06dIFJ0+ezLNdcnIyqlWrBpVKhRYtWmDOnDlo1KhRnvX9/f0xc+bMXOXx8fFIS0vTKWYXpRJmAFRKJeL/e/9jKlQqFRISEiCEKNdXECUlJcGreh0kmVVAXJb6NgHJZulwdrVHcnKy9L63NMSWZJYGr+opSEpKyjcubTkVtq0+X3dtcShtHFC3oRypljUQl2WvNa7CtMsrpxfbamuXV5lnVTmeWaoKrFdQ/KWZvn/fk5KS9BIXByZLE1dX4OuvgSlTgDZtgKAgoHp1Y0dF5URWVhZSU1NRuXJl2NjYFKqNqQ7QmWreQMG5W1tbAwDi4uLg6urKy7qJiIioUB4+fAilUgk3NzeNcjc3N9y4cUNrm3r16mHDhg1o2rQpEhISsGDBArRt2xZXr15FlSpVtLaZNGkS/Pz8pO3ExER4eXnBxcUF9vb2OsUs++99jtzMLM9LzcsrlUoFmUwGFxeXcj0wmZycjPsR/8BO6QhX8woAgCRlKh7GucDW1taor/uLsSUrU3A/4ins7OzyjUtbToVtq8/XXVscZqkPcfPaJdhkqOBq7qw1rsK0yyunF9tqa6e97BGiIuWwbqWCq3mlfOoVHH9ppu/fd33d85cDk6XNpEmAszMwZAhgaWnsaKgcUSqVAABL/l5RMWUPbGdmZnJg0oRN/XYbXM3TEZdV8G1GulotR+T+tQj4YYnhAyMionLDx8cHPj4+0nbbtm3RoEEDrF69GrNnz9baRqFQQKHlFlhyuVzngRbV1auIi4uDi6truR6cy4tMJivSeStLsi9hlUFALhPqMgjpkldj5v5ibIWNq7g56et1zysOlUqVb06FaZdXTtrOmbZ2ee6rEPUKir800/fvu75y5sCksQgBLF4MKJXAhAnPy+Vy4OOPjRcXlXumNgOQ9I+/QwQA6dYVkG5hjvTMggcmLWTWMFOaw9bCtgQiIyKi0sjZ2RlmZmaIjY3VKI+NjS30PSQtLCzQvHlz3Lp1yxAh5mZnB/HsGWBnVzLHIyIyQaV/SLc8evQIeOstYNw49QzJY8eMHREREREREZHBWFpaomXLlggJCZHKVCoVQkJCNGZF5kepVOLy5cu8zzURUTnCgcmSdvw44O0N7Nmj3lYqgVOnjBoSkamaMWMG3NzcIJPJsHv3bmOHYxSBgYFwdHQ0dhhERERkAvz8/LB27Vps3LgR169fx6effoqUlBRple6BAwdqLI4za9YsHDhwAHfu3MH58+fxwQcf4N69exg+fLixUiAiIj3jwGRJUamAuXOBjh2BBw/UZc7OwB9/AOPHGzc2olJs8ODBkMlkkMlksLS0RO3atTFr1ixkZWUVa7/Xr1/HzJkzsXr1akRHR6N79+7FjnXGjBnw9vYu9n7K6vHJtLy+fyte+2UDXt+/tcC6NzN/Q1SN21h/bX0JREZERKVV3759sWDBAkybNg3e3t4ICwtDcHCwtCBOZGQkoqOjpfpPnjzBiBEj0KBBA/To0QOJiYk4ceIEGjZsWDIBL14M2wUL1LfgIiIig+A9JktCfDwwcCAQHPy87JVXgK1bAU9P48VFVEZ069YNAQEBSE9Px759+zBq1ChYWFhofKNeWEqlEjKZDLdv3wYA9OrVi/dMJCqC1/dvhdOTeDyu6IIDvgPyrftP1m94VuMxNtzYgDk955RQhEREVBqNHj0ao0eP1vpcaGioxvbixYux2IiDgrLFi2EbFQXh6am+DRcREekdZ0wa2uHD6ku3swclZTJg6lQgJISDkkSFpFAo4O7ujmrVquHTTz9Fly5d8NtvvwEA0tPTMX78eHh6eqJChQpo06aNxpva7EuVf/vtNzRs2BAKhQJDhw5Fz549AahXEss5MLlu3To0bNgQdnZ2aNCgAX744QeNWB48eIB+/frByckJFSpUQKtWrfD3338jMDAQM2fOxMWLF6UZnoGBgVrzGTx4MHr37o05c+bAzc0Njo6O0izQCRMmwMnJCVWqVEFAQIBGu6+++gp169aFjY0NatasialTpyIzM1PKM6/jP336FB9//DHc3NxgZWWFxo0bY0/27ST+s3//fjRo0AB2dnZ48803NWYrEBERERERERkCZ0waklIJjBkD/PuvetvNDfjxR6BLF+PGRZTTokXqRx6k/yRatAD+GwyUvPUWcP58wcfw81M/9MTa2hqPHj0CoP7W/dq1awgKCkLlypWxa9cudOvWDZcvX0adOnUAAKmpqZg3bx7WrVuHSpUqwcPDA506dcKQIUM0BuC2bNmCadOmYfny5WjSpAkuX76Mjz76CBUqVMCgQYOQnJyMjh07wtPTE7/99hvc3d1x/vx5qFQq9O3bF1euXEFwcDD+/PNPAICDg0OeOfz111+oUqUKjhw5guPHj2PYsGE4ceIEXnnlFfz999/Ytm0bPv74Y7z++uuoUqUKAMDOzg6BgYGoXLkyLl++jBEjRsDOzg5ffvllnsdXqVTo3r07kpKS8OOPP6JWrVq4du0azMzMpFhSU1OxYMECbN68GTKZDB988AEmTJiALVu26O01IyIiIiIiInoRByYNycxMfbl269ZA27bqQUl3d2NHRaQpMRGIitL6lMYFzl5euSvEx+fZNtcx9EAIgZCQEOzfvx9jxoxBZGQkAgICEBkZicqVKwMAxo8fj+DgYAQEBGDOHPUlo5mZmfjhhx/QrFkzaV/ZC7645/ibnD59OhYuXIh33nkHWVlZqFOnDq5fv47Vq1dj0KBB2Lp1K+Lj43HmzBk4OTkBAGrXri21t7W1hbm5ucY+8+Lk5IRly5ZBLpejXr16mD9/PlJTUzF58mQAwKRJkzB37lwcO3YM77//PgBgypQpUvvq1atj/PjxCAoKwpdffglra2utxz9w4ABOnz6N69evo27dugCAmjVrasSSmZmJVatWoVatWhBCYOTIkfj2228LzIGIiIiIiIioODgwqW+ZmYCFxfPtxo3VK3E3baoeqCQqbezt87ytgMjxs8zFJXcFF5fC3ZLA3r5osf1nz549sLW1RWZmJlQqFfr3748ZM2YgNDQUSqVSGnDLlp6ejkqVKknblpaWaNq0ab7HSElJwe3btzFs2DCMGDFCKs/KypJmPoaFhaF58+bSoGRxNGrUCHL587tpuLm5oXHjxtK2mZkZKlWqhLi4OKls27ZtWLZsGW7fvo3k5GRkZWXBvoBzGxYWhipVquQ6RznZ2NigVq1a0ra7u7vGcYmIiIiIiIgMgQOT+qJUArNmqe8leeQIoFA8f655c+PFRVSQ/C6zFgJZWVkwNzdX3x/1RS9e2m0gnTt3xsqVK2FpaYnKlSur4wGQnJwMMzMznDt3TuPSZEA9ezGbtbV1gQvcJCcnAwDWrl2L1q1bS3nLZDJp39bW1nrLySLnFxgAZDKZ1jKVSgUAOHnyJAYMGICZM2fC19cXDg4OCAoKwsKFC/M9TmFi1nZcIUQetYmIiIiIiIj0gwOT+vDvv0D//uqFbgDgq6+AJUuMGhJReVKhQgWNS6azNW/eHEqlEnFxcejQoUOxjuHm5obKlSvjzp076N+/v8bAZLamTZti3bp1ePz4sdZZk5aWllAqlcWKIy8nTpxAtWrV8PXXX0tl9+7dK/D4TZs2xYMHD3Dz5s18Z00SERERERERlTSuyl1c+/erV93OHpQ0MwM8PADONiIyuLp162LAgAEYOHAgdu7cibt37+L06dPw9/fH3r17dd7fzJkz4e/vj2XLluHmzZu4fPkyAgICsOi/xYH69esHd3d39O7dG8ePH8edO3fwyy+/4OTJkwDU9328e/cuwsLC8PDhQ6Snp+st1zp16iAyMhJBQUG4ffs2li1bhl27dmnU0Xb8jh074pVXXsG7776LgwcP4u7du/jjjz8QHByst9iIiIiIiIiIiqJUDEyuWLEC1atXh5WVFdq0aYPTp0/nW3/Hjh2oX78+rKys0KRJE+zbt8/gMUY9TsX/Vp5Ao6l/YMTGM2j69R7s9P0Q6NZNvQAIAFSpoh6g/Oor7Ze9EpHeBQQEYODAgRg3bhzq1auH3r1748yZM6hatarO+xo+fDjWrVuHwMBAtGjRAp06dUJgYCBq1KgBQD0j8cCBA3B1dUWPHj3QpEkTzJ07V7rU+91330W3bt3QuXNnuLi44KefftJbnm+99Ra++OILjB49Gt7e3jhx4gSmTp2qUSev4//yyy946aWX0K9fPzRs2BBffvmlwWZ2EhERERERERWW0S/l3rZtG/z8/LBq1Sq0adMGS5Ysga+vL8LDw+Hq6pqr/okTJ9CvXz/4+/vjzTffxNatW9G7d2+cP39eY+EIfYp6nIpuS48gKV0JOQScnsZj+uYFaBV1/XmlN98EAgOBHAtuEFHxBQYG5vu8hYUFZs6ciZkzZ2p9fvDgwRg8eHCu8t69e2u9j2L//v3Rr18/rZdyA0C1atXw888/az2WQqHI87mctOUUGhqaqywiIkJje/78+Zg/f75G2eeff17g8Z2cnLBhwwatsWg7P7169ZLubUmUl8hq9ZFcyRWPbQteDMpRXhPyJ0o08mxUApERERHpSfPmyHB3h4WHh7EjISIqt4w+MLlo0SKMGDECQ4YMAQCsWrUKe/fuxYYNGzBx4sRc9ZcuXYpu3bphwoQJAIDZs2fj4MGD+P7777Fq1SqDxDh2W9h/g5LA63fP4rs9i2CfmgQAyJSbYWvvTzHo52WcJUlERCbj+7EL4GqRjrhMRYF12ykmI+LcD1gzyjD9NBERkSGIX3/F47g4uLq6gp/0iIgMw6gDkxkZGTh37hwmTZoklcnlcnTp0kW6Z9uLTp48Cb8XVhD29fXF7t27tdZPT0/XuM9bYmIiAEClUhV6RtDVB08gh4ClmQyt7l+RBiWjHFwxpucEXK/aAB8KUe7vK6lSqSCEMLmZVOUl7+w8sh+FlV3X1FZpNtW8gYJzz/4d0vb/aFn/OyEiIiIiIqKSY9SByYcPH0KpVMLNzU2j3M3NDTdu3NDaJiYmRmv9mJgYrfX9/f21XuIZHx+PtLS0QsVZ214FFQBzObD/rQF4NfYq4q0dsazPWKRbVUBtqBAXF1eofZVlKpUKCQkJEEJALi8VtyctEeUl78zMTKhUKmRlZSErK6tQbYQQ0r0IX7ykuTwz1byBwuWelZUFlUqFR48ewcLCQuO5pKQkg8dIRERERERE5YPRL+U2tEmTJmnMsExMTISXlxdcXFxgb29fqH3cSpQjXameMSmHBaYOmo6wtApQZciR8UxAYSbTej/M8kalUkEmk8HFxaVMD9DpqrzknZaWhqSkJJibm8PcXLc//RcHn0yFqeYN5J+7ubk55HI5KlWqBCsrK43nXtwmIiIqLeLj46Wrp7Sxt7eHi4tLCUZERERERh2YdHZ2hpmZGWJjYzXKY2Nj4e7urrWNu7u7TvUVCgUUitz3v5LL5YUeZGpUpSLO3nuCDCVgaSZDirUtVOkyZCgBFWRoVKVimR6w0oVMJtPp3JUX5SFvuVwuzYAr7CxAIYTObcoDU80bKHzuef1NlOW/EdLN6KXj4ZT8GI9tnbB87MJ86x5Pn4PElv/go0MfIaRWSAlFSET0XHx8PD4YMhyPk1LzrONkZ4MfA9ZxcJIksl694BQdDZmHB/D778YOh4ioXDLqwKSlpSVatmyJkJAQ9O7dG4B6dlpISAhGjx6ttY2Pjw9CQkI0VqI9ePAgfHx8DBbn0r7e0qrcGUqBLJWQBiXtFGZY2tfbYMcm0hczMzMA6nu7WltbGzkaKstSU9Uf6kx5RikBVe/dgNOTeNhWLPgD/FPVHTxzSMDVJ1dLIDIiotwSExPxOCkVLj7vooKTW67nUx7HIv7kL0hMTOTAJD134QIso6IgPD2NHQkRUbll9Eu5/fz8MGjQILRq1QqtW7fGkiVLkJKSIq3SPXDgQHh6esLf3x8AMHbsWHTs2BELFy7EG2+8gaCgIJw9exZr1qwxWIyeTjYIHvsKxm4LkxbCUZipZ0ou7esNTycbgx2bSF/Mzc1hY2OD+Ph4WFhYFGpmmxACWVlZMDc3N6mZg6aaN5B/7kIIpKamIi4uDo6OjtJgNxERUVlRwckN9q5VtD4XX8KxEBERUSkYmOzbty/i4+Mxbdo0xMTEwNvbG8HBwdICN5GRkRoDKG3btsXWrVsxZcoUTJ48GXXq1MHu3bvRuHFjg8bp6WSDnz9tC5VKvdCNq6srL1mkMkUmk8HDwwN3797FvXv3CtUme+XlnJeBmwJTzRsoXO6Ojo553j6DiIiIiIiIqLCMPjAJAKNHj87z0u3Q0NBcZX369EGfPn0MHBVR+WNpaYk6deogIyOjUPWzV16uVKmSSQ3Em2reQMG5W1hYcKYkERERERER6UWpGJgkopIjl8sLvXKySqWChYUFrKysTGqAzlTzBkw7dyIiIiIiIipZ/NRJRERURqxYsQLVq1eHlZUV2rRpg9OnTxs7JCIiIp3o2pft2LED9evXh5WVFZo0aYJ9+/aVUKRERFQSODBJRERUBmzbtg1+fn6YPn06zp8/j2bNmsHX1xdxcXHGDo2IiKhQdO3LTpw4gX79+mHYsGG4cOECevfujd69e+PKlSslHDkRERkKByaJiIjKgEWLFmHEiBEYMmQIGjZsiFWrVsHGxgYbNmwwdmhERESFomtftnTpUnTr1g0TJkxAgwYNMHv2bLRo0QLff/99CUdORESGYnL3mBRCAAASExOL1F6lUiEpKckk779mqrmbat6A6eZuqnkDxc89+//W7P9rST8yMjJw7tw5TJo0SSqTy+Xo0qULTp48qbVNeno60tPTpe2EhAQAwNOnT6FSqXSOITExESqlEgnREchKS0ViVhbMASRmZeFx5E0kxT+ADEBS7H1YvLCguypNCQDIVGXiwoULOh+7tEpKSkJ0dLSxwzAqUz8Hpp4/UHbOwf3795GZni79H/ailCdxUCmVSExMxNOnTwu1T5VKhcTERFhaWiI5ORkA+7/8FKUvO3nyJPz8/DTKfH19sXv37jyPo8/+T6ZSQQZAqFQQhfy9KC9y/n6X5/fDiYmJyFKqcP1+MhJT1e9XHjxKQ+oze1y9ehVJSUlGi+3+/ftIy8iUYot69AzP0jJx9erVfMczXmwHoNBtAf39v64tjtvRzyAgQ/j9Z8hSJWqNqzDt8srpxbba2mkruxP9DFlZVgi/nwZlPvUKE39ppu3cPniUhszMikhKSip0/5dNb5/9hIm5f/++AMAHH3zwwYcBH/fv3zf2f/flSlRUlAAgTpw4oVE+YcIE0bp1a61tpk+fbvTfAz744IMPU3uw/8tbUfoyCwsLsXXrVo2yFStWCFdX1zyPw/6PDz744KNkH8Xt+0xuxmTlypVx//592NnZQSaTFdzgBYmJifDy8sL9+/dhb29vgAhLL1PN3VTzBkw3d1PNGyh+7kIIJCUloXLlygaIjnQxadIkjVkmKpUKjx8/RqVKlYrU/73IlP9OAOYP8ByYev4Az0HO/O3s7Nj/lRL67P9M+XecuTN3U8rdVPMGipe7vj77mdzApFwuR5UqVYq9H3t7e5P7hc1mqrmbat6A6eZuqnkDxcvdwcFBz9GQs7MzzMzMEBsbq1EeGxsLd3d3rW0UCgUUCoVGmaOjo95jM+W/E4D5AzwHpp4/wHOQnT/7v/wVpS9zd3fXqT5gmP7PlH/HmTtzNyWmmjdQ9Nz10feV35tFEBERlROWlpZo2bIlQkJCpDKVSoWQkBD4+PgYMTIiIqLCKUpf5uPjo1EfAA4ePMi+j4ioHDG5GZNERERlkZ+fHwYNGoRWrVqhdevWWLJkCVJSUjBkyBBjh0ZERFQoBfVlAwcOhKenJ/z9/QEAY8eORceOHbFw4UK88cYbCAoKwtmzZ7FmzRpjpkFERHrEgUkdKRQKTJ8+PdflAabAVHM31bwB083dVPMGTDv30q5v376Ij4/HtGnTEBMTA29vbwQHB8PNzc0o8Zj674qp5w/wHJh6/gDPgannXxQF9WWRkZEaK0C3bdsWW7duxZQpUzB58mTUqVMHu3fvRuPGjUskXlN+jZk7czclppo3UDpylwlR3HW9iYiIiIiIiIiIiHTDe0wSERERERERERFRiePAJBEREREREREREZU4DkwSERERERERERFRiePAJBEREREREREREZU4DkxqsWLFClSvXh1WVlZo06YNTp8+nW/9HTt2oH79+rCyskKTJk2wb9++EopUv3TJe+3atejQoQMqVqyIihUrokuXLgWep9JM19c8W1BQEGQyGXr37m3YAA1I19yfPn2KUaNGwcPDAwqFAnXr1i2Tv/O65r1kyRLUq1cP1tbW8PLywhdffIG0tLQSilZ/jhw5gp49e6Jy5cqQyWTYvXt3gW1CQ0PRokULKBQK1K5dG4GBgQaPk0oHU+0Ps5lyv5jNlPtHwHT7yJxMtb8E2Geaum+//RZt27aFjY0NHB0dtdaJjIzEG2+8ARsbG7i6umLChAnIysoq2UBLwM2bN9GrVy84OzvD3t4e7du3x6FDh4wdVonZu3cv2rRpA2tra1SsWLHM9226Sk9Ph7e3N2QyGcLCwowdjsFFRERg2LBhqFGjBqytrVGrVi1Mnz4dGRkZxg7NIIr6Xk+vBGkICgoSlpaWYsOGDeLq1atixIgRwtHRUcTGxmqtf/z4cWFmZibmz58vrl27JqZMmSIsLCzE5cuXSzjy4tE17/79+4sVK1aICxcuiOvXr4vBgwcLBwcH8eDBgxKOvPh0zT3b3bt3haenp+jQoYPo1atXyQSrZ7rmnp6eLlq1aiV69Oghjh07Ju7evStCQ0NFWFhYCUdePLrmvWXLFqFQKMSWLVvE3bt3xf79+4WHh4f44osvSjjy4tu3b5/4+uuvxc6dOwUAsWvXrnzr37lzR9jY2Ag/Pz9x7do1sXz5cmFmZiaCg4NLJmAyGlPtD7OZcr+YzZT7RyFMt4/MyZT7SyHYZ5q6adOmiUWLFgk/Pz/h4OCQ6/msrCzRuHFj0aVLF3HhwgWxb98+4ezsLCZNmlTywRpYnTp1RI8ePcTFixfFzZs3xciRI4WNjY2Ijo42dmgG9/PPP4uKFSuKlStXivDwcHH16lWxbds2Y4dVoj777DPRvXt3AUBcuHDB2OEY3B9//CEGDx4s9u/fL27fvi1+/fVX4erqKsaNG2fs0PSuqO/19I0Dky9o3bq1GDVqlLStVCpF5cqVhb+/v9b67733nnjjjTc0ytq0aSM+/vhjg8apb7rm/aKsrCxhZ2cnNm7caKgQDaYouWdlZYm2bduKdevWiUGDBpXZD1665r5y5UpRs2ZNkZGRUVIhGoSueY8aNUq8+uqrGmV+fn6iXbt2Bo3T0ArzIevLL78UjRo10ijr27ev8PX1NWBkVBqYan+YzZT7xWym3D8KYbp9ZE7sL59jn2m6AgICtA5M7tu3T8jlchETEyOVrVy5Utjb24v09PQSjNCw4uPjBQBx5MgRqSwxMVEAEAcPHjRiZIaXmZkpPD09xbp164wditHs27dP1K9fX1y9etVkBia1mT9/vqhRo4axw9C74r7f1Rdeyp1DRkYGzp07hy5dukhlcrkcXbp0wcmTJ7W2OXnypEZ9APD19c2zfmlUlLxflJqaiszMTDg5ORkqTIMoau6zZs2Cq6srhg0bVhJhGkRRcv/tt9/g4+ODUaNGwc3NDY0bN8acOXOgVCpLKuxiK0rebdu2xblz56Rp7Xfu3MG+ffvQo0ePEonZmMrD/3GkO1PtD7OZcr+YzZT7R8B0+8ic2F/qrjz9P0gFO3nyJJo0aQI3NzepzNfXF4mJibh69aoRI9OvSpUqoV69eti0aRNSUlKQlZWF1atXw9XVFS1btjR2eAZ1/vx5REVFQS6Xo3nz5vDw8ED37t1x5coVY4dWImJjYzFixAhs3rwZNjY2xg7HqBISEsrse7q86OP9rr6Yl+jRSrmHDx9CqVRqdC4A4Obmhhs3bmhtExMTo7V+TEyMweLUt6Lk/aKvvvoKlStXzvVmrLQrSu7Hjh3D+vXry/z9NYqS+507d/DXX39hwIAB2LdvH27duoWRI0ciMzMT06dPL4mwi60oeffv3x8PHz5E+/btIYRAVlYWPvnkE0yePLkkQjaqvP6PS0xMxLNnz2BtbW2kyMiQTLU/zGbK/WI2U+4fAdPtI3Nif6k79pmmJa/XO/u58kImk+HPP/9E7969YWdnB7lcDldXVwQHB6NixYrGDs+g7ty5AwCYMWMGFi1ahOrVq2PhwoXo1KkTbt68We4GqnISQmDw4MH45JNP0KpVK0RERBg7JKO5desWli9fjgULFhg7FL3Sx/tdfeGMSSq2uXPnIigoCLt27YKVlZWxwzGopKQkfPjhh1i7di2cnZ2NHU6JU6lUcHV1xZo1a9CyZUv07dsXX3/9NVatWmXs0AwqNDQUc+bMwQ8//IDz589j586d2Lt3L2bPnm3s0IioFDKlfjGbqfePgOn2kTmxv6TSbuLEiZDJZPk+SvoDubEU9lwIITBq1Ci4urri6NGjOH36NHr37o2ePXsiOjra2GkUSWFzV6lUAICvv/4a7777Llq2bImAgADIZDLs2LHDyFkUTWFzX758OZKSkjBp0iRjh6w3Rfn7j4qKQrdu3dCnTx+MGDHCSJGXf5wxmYOzszPMzMwQGxurUR4bGwt3d3etbdzd3XWqXxoVJe9sCxYswNy5c/Hnn3+iadOmhgzTIHTN/fbt24iIiEDPnj2lsuwOy9zcHOHh4ahVq5Zhg9aTorzuHh4esLCwgJmZmVTWoEEDxMTEICMjA5aWlgaNWR+KkvfUqVPx4YcfYvjw4QCAJk2aICUlBR999BG+/vpryOXl9zuevP6Ps7e358yPcsxU+8NsptwvZjPl/hEw3T4yJ/aXumOfWfqNGzcOgwcPzrdOzZo1C7Uvd3f3XKvXZr/+ZaHvK+y5+Ouvv7Bnzx48efIE9vb2AIAffvgBBw8exMaNGzFx4sQSiFa/Cpt79sBrw4YNpXKFQoGaNWsiMjLSkCEajC6v+8mTJ6FQKDSea9WqFQYMGICNGzcaMErD0PXv/99//0Xnzp3Rtm1brFmzxsDRlbzivN/Vt/L97kBHlpaWaNmyJUJCQqQylUqFkJAQ+Pj4aG3j4+OjUR8ADh48mGf90qgoeQPA/PnzMXv2bAQHB6NVq1YlEare6Zp7/fr1cfnyZYSFhUmPt956C507d0ZYWBi8vLxKMvxiKcrr3q5dO9y6dUv6sAkAN2/ehIeHR5n5wFWUvFNTU3N9mMr+4CmEMFywpUB5+D+OdGeq/WE2U+4Xs5ly/wiYbh+ZE/tL3ZWn/wfLKxcXF9SvXz/fR2H/Xn18fHD58mXExcVJZQcPHoS9vb3GQFZpVdhzkZqaCgC5/rblcrnG/3dlSWFzb9myJRQKBcLDw6W2mZmZiIiIQLVq1YyYQdEVNvdly5bh4sWLUp++b98+AMC2bdvw7bffGjmLotHl7z8qKgqdOnWSZsmWxy/Wivp+1yBKdKmdMiAoKEgoFAoRGBgorl27Jj766CPh6Ogorbb24YcfiokTJ0r1jx8/LszNzcWCBQvE9evXxfTp04WFhYW4fPmysVIoEl3znjt3rrC0tBQ///yziI6Olh5JSUnGSqHIdM39RWV51VFdc4+MjBR2dnZi9OjRIjw8XOzZs0e4urqKb775xlgpFImueU+fPl3Y2dmJn376Sdy5c0ccOHBA1KpVS7z33nvGSqHIkpKSxIULF8SFCxcEALFo0SJx4cIFce/ePSGEEBMnThQffvihVP/OnTvCxsZGTJgwQVy/fl2sWLFCmJmZieDgYGOlQCXEVPvDbKbcL2Yz5f5RCNPtI3My5f5SCPaZpu7evXviwoULYubMmcLW1lb6Xcj+fz0rK0s0btxYdO3aVYSFhYng4GDh4uIiJk2aZOTI9Ss+Pl5UqlRJvPPOOyIsLEyEh4eL8ePHCwsLCxEWFmbs8Axu7NixwtPTU+zfv1/cuHFDDBs2TLi6uorHjx8bO7QSdffuXZNZlfvBgweidu3a4rXXXhMPHjzQeF9X3hTUz5cUDkxqsXz5clG1alVhaWkpWrduLU6dOiU917FjRzFo0CCN+tu3bxd169YVlpaWolGjRmLv3r0lHLF+6JJ3tWrVBIBcj+nTp5d84Hqg62ueU1n/4KVr7idOnBBt2rQRCoVC1KxZU3z77bciKyurhKMuPl3yzszMFDNmzBC1atUSVlZWwsvLS4wcOVI8efKk5AMvpkOHDmn9283Od9CgQaJjx4652nh7ewtLS0tRs2ZNERAQUOJxk3GYan+YzZT7xWym3D8KYbp9ZE6m2l8KwT7T1A0aNEjr63/o0CGpTkREhOjevbuwtrYWzs7OYty4cSIzM9N4QRvImTNnRNeuXYWTk5Ows7MTL7/8sti3b5+xwyoRGRkZYty4ccLV1VXY2dmJLl26iCtXrhg7rBJnSgOTAQEBWv/2y+u8vvz6+ZIiE8IErqsgIiIiIiIiIiKiUqX8XShPREREREREREREpR4HJomIiIiIiIiIiKjEcWCSiIiIiIiIiIiIShwHJomIiIiIiIiIiKjEcWCSiIiIiIiIiIiIShwHJomIiIiIiIiIiKjEcWCSiIiIiIiIiIiIShwHJomIiIiIiIiIiKjEcWCSiIiIyIBkMhl2794tbd+4cQMvv/wyrKys4O3tnWdZefThhx9izpw5xg7DpE2cOBFjxowxdhhERHo3depUfPTRRzq1CQ0NhUwmw9OnTw0TFIBOnTrh888/N9j+9cUU36+8//77WLhwobHDMHkcmCSTMnjwYPTu3dvYYejdxYsX8dZbb8HV1RVWVlaoXr06+vbti7i4OGOHRkRULg0ePBgymQwymQwWFhZwc3PD66+/jg0bNkClUmnUjY6ORvfu3aXt6dOno0KFCggPD0dISEieZeXNxYsXsW/fPnz22WdSWadOnSCTyRAUFKRRd8mSJahevXoJR1iw6tWrY8mSJcYOo1jGjx+PjRs34s6dO8YOhYhKuZL47LRz50507doVlSpVgkwmQ1hYWK46aWlpGDVqFCpVqgRbW1u8++67iI2N1agTExODpUuX4uuvv87V/uTJkzAzM8Mbb7xhqDT0KiIiIs9zoSu+X8nflClT8O233yIhIcHYoZg0DkwSlXHx8fF47bXX4OTkhP379+P69esICAhA5cqVkZKSYrDjZmZmGmzfRERlQbdu3RAdHY2IiAj88ccf6Ny5M8aOHYs333wTWVlZUj13d3coFApp+/bt22jfvj2qVauGSpUq5Vmmq4yMjOIlZGDLly9Hnz59YGtrq1FuZWWFKVOmsF8pIc7OzvD19cXKlSuNHQoREVJSUtC+fXvMmzcvzzpffPEFfv/9d+zYsQOHDx/Gv//+i3feeUejzrp169C2bVtUq1YtV/v169djzJgxOHLkCP7991+951Da8f1K3ho3boxatWrhxx9/NHYoJo0Dk0Q5XLlyBd27d4etrS3c3Nzw4Ycf4uHDh9LzSUlJGDBgACpUqAAPDw8sXrw419T8zZs3o1WrVrCzs4O7uzv69++fa+bi1atX8eabb8Le3h52dnbo0KEDbt++jSNHjsDCwgIxMTEa9T///HN06NBBa8zHjx9HQkIC1q1bh+bNm6NGjRro3LkzFi9ejBo1ahR4TABQqVSYNWsWqlSpAoVCAW9vbwQHB0tts7+127ZtGzp27AgrKyts2bIFgPpNQIMGDWBlZYX69evjhx9+KNrJJyIqYxQKBdzd3eHp6YkWLVpg8uTJ+PXXX/HHH38gMDBQqpfz0iiZTIZz585h1qxZkMlkmDFjhtYyALh//z7ee+89ODo6wsnJCb169UJERIS03+yZLN9++y0qV66MevXq6dRuwYIF8PDwQKVKlTBq1CiNgcH09HR89dVX8PLygkKhQO3atbF+/Xrp+YL6yxcplUr8/PPP6NmzZ67n+vXrh6dPn2Lt2rX5nu9ff/0VLVq0gJWVFWrWrImZM2dKH6jGjx+PN998U6q7ZMkSyGQyjb6sdu3aWLduXb7HKK78YgTUl8C1b98eVlZWaNiwIf78889cl8599dVXqFu3LmxsbFCzZk1MnTo116Dt77//jpdeeglWVlZwdnbG22+/DQCYNWsWGjdunCsub29vTJ06Vdru2bNnrlmqRES6Onz4MFq3bg2FQgEPDw9MnDhR4/+8wnx2+vDDDzFt2jR06dJF6zESEhKwfv16LFq0CK+++ipatmyJgIAAnDhxAqdOnZLqBQUFae1jkpOTsW3bNnz66ad44403NPrnnI4fP46mTZvCysoKL7/8Mq5cuSI9d+/ePfTs2RMVK1ZEhQoV0KhRI+zbt6/Q5+FFL/6/DwCOjo5SbNmf4Zo3bw6ZTIZOnTpJ9Yry2YvvV/J/v8I+0fg4MEn0n6dPn+LVV19F8+bNcfbsWQQHByM2NhbvvfeeVMfPzw/Hjx/Hb7/9hoMHD+Lo0aM4f/68xn4yMzMxe/ZsXLx4Ebt370ZERAQGDx4sPR8VFYVXXnkFCoUCf/31F86dO4ehQ4ciKysLr7zyCmrWrInNmzdr7G/Lli0YOnSo1rjd3d2RlZWFXbt2QQihtU5+xwSApUuXYuHChViwYAEuXboEX19fvPXWW/jnn3809jNx4kSMHTsW169fh6+vL7Zs2YJp06bh22+/xfXr1zFnzhxMnToVGzdu1OncExGVF6+++iqaNWuGnTt3an0+OjoajRo1wrhx4xAdHY3x48drLcvMzISvry/s7Oxw9OhRHD9+HLa2tujWrZvGTIOQkBCEh4fj4MGD2LNnT6HbHTp0CLdv38ahQ4ewceNGBAYGanw4GThwIH766ScsW7YM169fx+rVq6WZjoXpL1906dIlJCQkoFWrVrmes7e3x9dff41Zs2blOdP/6NGjGDhwIMaOHYtr165h9erVCAwMxLfffgsA6NixI44dOwalUglA/SHR2dkZoaGhANT94O3btzU+3OlbQTEqlUr07t0bNjY2+Pvvv7FmzRqtlxza2dkhMDAQ165dw9KlS7F27VosXrxYen7v3r14++230aNHD1y4cAEhISFo3bo1AGDo0KG4fv06zpw5I9W/cOECLl26hCFDhkhlrVu3xoMHDzQ+ABIR6SIqKgo9evTASy+9hIsXL2LlypVYv349vvnmG6lOYT47FeTcuXPIzMzUGLisX78+qlatipMnTwIAHj9+jGvXrmntY7Zv34769eujXr16+OCDD7Bhwwatn5kmTJiAhQsX4syZM3BxcUHPnj2lAbBRo0YhPT0dR44cweXLlzFv3jypTyzMedDV6dOnAQB//vknoqOjpfcU+vzsxfcrz7Vu3RqnT59Genq6zueR9EQQmZBBgwaJXr16aX1u9uzZomvXrhpl9+/fFwBEeHi4SExMFBYWFmLHjh3S80+fPhU2NjZi7NixeR7zzJkzAoBISkoSQggxadIkUaNGDZGRkaG1/rx580SDBg2k7V9++UXY2tqK5OTkPI8xefJkYW5uLpycnES3bt3E/PnzRUxMjPR8QcesXLmy+PbbbzXKXnrpJTFy5EghhBB3794VAMSSJUs06tSqVUts3bpVo2z27NnCx8cnz1iJiMqD/PqTvn37avw/DkDs2rVL2m7WrJmYPn26RpsXyzZv3izq1asnVCqVVJaeni6sra3F/v37pRjc3NxEenq6zu2qVasmsrKypDp9+vQRffv2FUIIER4eLgCIgwcPas2voP5Sm127dgkzMzONuIQQomPHjmLs2LEiLS1NVKtWTcyaNUsIIcTixYtFtWrVpHqvvfaamDNnjkbbzZs3Cw8PDyGEEE+ePBFyuVycOXNGqFQq4eTkJPz9/UWbNm2EEEL8+OOPwtPTU2tsuqhWrZpYvHix1ucKivGPP/4Q5ubmIjo6Wnr+4MGDuX4/XvTdd9+Jli1bSts+Pj5iwIABedbv3r27+PTTT6XtMWPGiE6dOmnUSUhIEABEaGhonvshIsqvr5s8eXKu/mbFihXC1tZWKJVKnT87ZX/euHDhgkb5li1bhKWlZa76L730kvjyyy+FEEJcuHBBABCRkZG56rVt21b6DJOZmSmcnZ3FoUOHpOcPHTokAIigoCCp7NGjR8La2lps27ZNCCFEkyZNxIwZM4p0HoR43tdl0/b/voODgwgICMj3XBTlsxffrxT8fuXixYsCgIiIiNC6HzI8zpgk+s/Fixdx6NAh2NraSo/69esDUN9L486dO8jMzJRmJQCAg4ODNBU927lz59CzZ09UrVoVdnZ26NixIwAgMjISABAWFoYOHTrAwsJCaxyDBw/GrVu3pEsTAgMD8d5776FChQp5xv7tt98iJiYGq1atQqNGjbBq1SrUr18fly9fLvCYiYmJ+Pfff9GuXTuN8nbt2uH69esaZTm/hUxJScHt27cxbNgwjXP2zTffSJeIExGZIiEEZDJZsfZx8eJF3Lp1C3Z2dtL/r05OTkhLS9P4P7ZJkyawtLTUuV2jRo1gZmYmbXt4eEi3HQkLC4OZmZnUf2mLLb/+Uptnz55BoVDkeV4UCgVmzZqFBQsWaL0k/OLFi5g1a5bGMUeMGIHo6GikpqbC0dERzZo1Q2hoKC5fvgxLS0t89NFHuHDhApKTk3H48OE888k+H9n7zXnjf10UFGN4eDi8vLzg7u4utcn5niLbtm3b0K5dO7i7u8PW1hZTpkyR3kMA6tfntddeyzOOESNG4KeffkJaWhoyMjKwdevWXFddWFtbAwBSU1OLlCsR0fXr1+Hj46Px/3q7du2QnJyMBw8eFPqzkz48e/YMgPqexTmFh4fj9OnT6NevHwDA3Nwcffv21bjUN5uPj4/0s5OTE+rVqyd9Fvrss8/wzTffoF27dpg+fTouXbok1S3oPOiLIT578f2KGvtE4zM3dgBEpUVycjJ69uyp9cbLHh4euHXrVoH7SElJga+vr3SZs4uLCyIjI+Hr6ytNSc/+jy8vrq6u6NmzJwICAlCjRg388ccf0qVo+alUqRL69OmDPn36YM6cOWjevDkWLFiAjRs3FnjMwso5OJqcnAwAWLt2Ldq0aaNRL2fnQURkaq5fv65xj9+iSE5ORsuWLaX7+ebk4uIi/fzil1aFbffiF1UymUxanbOgPqOg/lIbZ2dnpKamIiMjQ+ODSU4ffPABFixYgG+++SbXitzJycmYOXNmrsUOgOcfRDt16oTQ0FAoFAp07NgRTk5OaNCgAY4dO4bDhw9j3Lhxeea0b98+6ZK9ovaZhYmxICdPnsSAAQMwc+ZM+Pr6wsHBAUFBQVi4cKFUp6D4evbsCYVCgV27dsHS0hKZmZn43//+p1Hn8ePHADR/J4iISiN3d3dkZGTg6dOncHR0lMpjY2OlL3qcnZ0BAE+ePNH4f239+vXIyspC5cqVpTIhBBQKBb7//ns4ODgUKobhw4fD19cXe/fuxYEDB+Dv74+FCxdizJgxRcpJJpPlupy8oAXgDPHZi+9X1NgnGh8HJon+06JFC/zyyy+oXr06zM1z/2nUrFkTFhYWOHPmDKpWrQpAfTPmmzdv4pVXXgGgvqn9o0ePMHfuXHh5eQEAzp49q7Gfpk2bYuPGjcjMzMxz1uTw4cPRr18/VKlSBbVq1co1m7EglpaWqFWrlnSvrvyOaW9vj8qVK+P48eMa3zYdP35c60yObG5ubqhcuTLu3LmDAQMG6BQfEVF59ddff+Hy5cv44osvirWfFi1aYNu2bXB1dYW9vb3B2+XUpEkTqFQqHD58WOtiBAX1l9p4e3sDAK5duyb9/CK5XA5/f3+88847+PTTT3MdMzw8HLVr187zGB07dsSGDRtgbm6Obt26AVAPVv7000+4efNmvveX1LaKq64KirFevXq4f/8+YmNj4ebmBgAa94IEgBMnTqBatWoa9568d++eRp2mTZsiJCRE456ROZmbm2PQoEEICAiApaUl3n///Vwf3q5cuQILCws0atRI5zyJiACgQYMG+OWXXzRm3R0/fhx2dnaoUqUKKlasWOBnp8Jo2bIlLCwsEBISgnfffReAeiZkZGSkNMuxVq1asLe3x7Vr11C3bl0AQFZWFjZt2oSFCxeia9euGvvs3bs3fvrpJ3zyySdS2alTp6Q4nzx5gps3b6JBgwbS815eXvjkk0/wySefYNKkSVi7di3GjBlT4HnQxsXFBdHR0dL2P//8ozFbL/sLvOz7JgP6/+zF9yvPXblyBVWqVJEGuKnk8VJuMjkJCQkICwvTeNy/fx+jRo3C48eP0a9fP5w5cwa3b9/G/v37MWTIECiVStjZ2WHQoEGYMGECDh06hKtXr2LYsGGQy+VSJ1S1alVYWlpi+fLluHPnDn777TfMnj1b4/ijR49GYmIi3n//fZw9exb//PMPNm/ejPDwcKmOr68v7O3t8c033+T5wSPbnj178MEHH2DPnj24efMmwsPDsWDBAuzbtw+9evUq1DEnTJiAefPmYdu2bQgPD8fEiRMRFhaGsWPH5nvsmTNnwt/fH8uWLcPNmzdx+fJlBAQEYNGiRTq/LkREZU16ejpiYmIQFRWF8+fPY86cOejVqxfefPNNDBw4sFj7HjBgAJydndGrVy8cPXoUd+/eRWhoKD777LN8Lw0rarucqlevjkGDBmHo0KHYvXu3tI/t27cDQIH9pTYuLi5o0aIFjh07lu+x33jjDbRp0warV6/WKJ82bRo2bdqEmTNn4urVq7h+/TqCgoIwZcoUqc4rr7yCpKQk7NmzRxqE7NSpE7Zs2QIPDw/pw2pxRUVF5Xof8eTJkwJjfP3111GrVi0MGjQIly5dwvHjx6Xnst9H1KlTB5GRkQgKCsLt27exbNky7Nq1S+P406dPx08//YTp06fj+vXr0kIMOQ0fPhx//fUXgoODtS6ed/ToUXTo0EFvV1QQUfmV12enkSNH4v79+xgzZgxu3LiBX3/9FdOnT4efnx/kcnmhPjsB6tlqYWFhuHbtGgD1oGNYWBhiYmIAqC//HjZsGPz8/HDo0CGcO3cOQ4YMgY+PD15++WUA6i+2unTpotHH7NmzB0+ePMGwYcPQuHFjjce7776b63LuWbNmISQkBFeuXMHgwYPh7OyM3r17AwA+//xz7N+/H3fv3sX58+dx6NAhadCyoPOgzauvvorvv/8eFy5cwNmzZ/HJJ59oTB5xdXWFtbW1tFhLQkICgKJ/9uL7lfzfrxw9ejTX4DWVMGPe4JKopA0aNEgAyPUYNmyYEEKImzdvirfffls4OjoKa2trUb9+ffH5559LN+VNTEwU/fv3FzY2NsLd3V0sWrRItG7dWkycOFE6xtatW0X16tWFQqEQPj4+4rfffst18+KLFy+Krl27ChsbG2FnZyc6dOggbt++rRHr1KlThZmZmfj333/zzen27dtixIgRom7dusLa2lo4OjqKl156Sbp5cmGOqVQqxYwZM4Snp6ewsLAQzZo1E3/88YfUNq8bMAuhviG1t7e3sLS0FBUrVhSvvI+6FdgAAQAASURBVPKK2LlzZ4GvBRFRWZazPzE3NxcuLi6iS5cuYsOGDdLN7rOhCDeTF0KI6OhoMXDgQOHs7CwUCoWoWbOmGDFihEhISJBi0HZD+6K0Gzt2rOjYsaO0/ezZM/HFF18IDw8PYWlpKWrXri02bNggPV9Qf6nNDz/8IF5++WWNshcXBBBCiBMnTggAGovfCCFEcHCwaNu2rbC2thb29vaidevWYs2aNRp1mjVrJtzd3aXtR48eCZlMJt5///0849JFtWrVtL6P2Lx5c6FivH79umjXrp2wtLQU9evXF7///rsAIIKDg6U6EyZMEJUqVRK2traib9++YvHixcLBwUEjjl9++UXqe52dncU777yTK9YOHTqIRo0aac2jXr164qefftLDGSGi8qygz06hoaHipZdeEpaWlsLd3V189dVXIjMzU2pfmM9OAQEBWo+Rs0989uyZGDlypKhYsaKwsbERb7/9tsZCYkIIsW/fPuHp6Sn1wW+++abo0aOH1rz+/vtvAUBcvHhRWvzm999/F40aNRKWlpaidevW4uLFi1L90aNHi1q1agmFQiFcXFzEhx9+KB4+fCg9X9B5eLGvi4qKEl27dhUVKlQQderUEfv27dNY/EYIIdauXSu8vLyEXC7X6J91/ezF9yv5v1959uyZcHBwECdPnszzHJLhyYR44eYGRFRoKSkp8PT0xMKFCzFs2DC97nvYsGGIj4/Hb7/9ptf9EhERGcOzZ89Qr149bNu2TWORAVN2/PhxtG/fHrdu3UKtWrX0tl8hBOrUqYORI0fCz89P47k//vgD48aNw6VLlwp9KT4RkT4Y8rOTEAJt2rTBF198IS12Q1SQlStXYteuXThw4ICxQzFpfDdCpIMLFy7gxo0baN26NRISEjBr1iwAkC6Z1oeEhARcvnwZW7du5aAkERGVG9bW1ti0aZPWVbdNxa5du2Bra4s6derg1q1bGDt2LNq1a6fXQcn4+HgEBQUhJiZG6+1gUlJSEBAQwEFJIjK4kvjslE0mk2HNmjW4fPmy3vdN5ZeFhQWWL19u7DBMHt+REOlowYIFCA8Ph6WlJVq2bImjR4/q9Ua5vXr1wunTp/HJJ5/g9ddf19t+iYiIjC2/BWhMQVJSEr766itERkbC2dkZXbp00VhxWx9cXV3h7OyMNWvWoGLFirmef3GFbiIiQzL0Z6ecvL2981xgjUib4cOHGzsEAsBLuYmIiIiIiIiIiKjEcVVuIiIiIiIiIiIiKnEcmCQiIiIiIiIiIqISx4FJIiIiIiIiIiIiKnEcmCQiIiIiIiIiIqISx4FJIiIiIiIiIiIiKnEcmCQiIiIiIiIiIqISx4FJIiIiIiIiIiIiKnEcmCQiIiIiIiIiIqISx4FJIiIiIiIiIiIiKnEcmCQiIiIiIiIiIqISx4FJIiIiIiqUTp06QSaTQSaTISIiwtjhEBEREVEZx4FJIiIiKhUePHiAESNGoHr16rC0tISDgwNq166Nnj17YtasWcYOr9giIiKkQb3CPEzR3LlzNc7BJ598YuyQSlxgYKDGOTA3N4e9vT3q1KmD3r17Y9u2bVAqlcU6RkREBGbMmIEZM2Zg9+7d+glcz5YsWSLFSEREROWXTAghjB0EERERmbaYmBi0aNEC0dHRWp83MzNDVlZWCUelXxEREahRo0ah65fGt2idOnXC4cOHAQB3795F9erV9br/Zs2a4dKlS9K2s7MzoqOjYW5urtfjlGaBgYEYMmRIvnVefvll7Nq1C+7u7kU6RmhoKDp37gwAGDRoEAIDA4u0H0OqXr067t27B6B0/i0QERGRfpjOuzwiIiIqtZYvXy4NSr722msYNWoUbG1tERERgdOnTxt9VldKSgoqVKhQrH14eHjg6NGj0nZMTAz69Okjbed8Lj+pqamwsbEpViyl0fXr1zUGJQHg4cOH+PPPP9GtWze9Hksfr2dJ8Pb2xvLly5GYmIhjx45hxYoVSExMxKlTp/DWW2/h+PHjsLCwMHaYREREREXGS7mJiIjI6M6fPy/9vHjxYrz99tt4/fXXMWLECKxdu1aaOZXT48ePMWnSJDRs2BA2Njawt7dHixYt8P3332vUu3XrFoYMGQIvLy9YWlqiUqVK6NGjB0JCQjTqhYaGSpfPDh48GDt37oS3tzcUCgW+++47qd7Ro0fx1ltvwcXFBZaWlqhRowb8/Pzw5MmTfHNUKBRo37699GjVqpXG8zmfu3XrlhTLjBkzsGrVKtSrVw8WFhbYvn271ObXX39Fly5dULFiRSgUCtSrVw8zZ87Es2fPNPad896Qly5dwpgxY+Dq6gpra2t079491/lVKpWYMWMGPD09YWNjg86dO+PixYt55vbLL7+gffv2cHBwgKWlJdzd3dG+fXt89dVXhZ7t9tNPP0k/v//++9LPQUFBWusX5vXPmff58+cxdOhQODs7w9bWVqqTmJiIr7/+Gg0aNIC1tTXs7OzQpk0brF69OlfsoaGh6NKlC5ycnGBhYQEXFxe0bt0aY8eORUJCgl7PBwA4ODigffv26NGjB+bMmYPDhw9Ls0fPnDmDTZs2SXV3796Nt956CzVq1ICdnR0sLS1RrVo1DBkyRON+oJ06dZJmSwLAxo0bNX7vAeDIkSPo06cP6tSpA0dHR1haWqJy5cp47733cg0eP3v2DBMmTECdOnWgUChQoUIF1KhRA++88w527dqlUTc+Ph5+fn5S3YoVK+KNN97AqVOnpDrZl7Ln/J009VscEBERlWuCiIiIyMj69OkjAAgA4q233hJHjx4V6enpedaPjIwUVatWldrkfHTs2FGq9/fffws7Ozut9WQymfjhhx+kuocOHZKeq1GjhpDJZNL29OnThRBCrF27Vsjlcq37q1evnnj8+HGhc757965G+5wCAgKk8po1a2rUCwgIEEIIMXXqVK1xABAdOnTQOH8dO3bMc38ARLt27TSOP2rUqFx17O3tRfXq1aXtu3fvCiGECA0NzfOcABCZmZmFOh+1a9cWAIS5ubmIiYkRzs7O0nHT0tI06hb29c8vbyGEePz4sahfv36esb///vvSvm7cuCGsra3zrPvPP//o5XzkfO1z5pJt+PDh0vOvvfaaVP7xxx/neUw3NzcRGxub65y8+Bg0aJAQQgh/f/8869jY2Ihr165Jxx06dGiedQcMGCDVu3fvnqhSpYrWehYWFuLXX3/Nlb+2BxEREZUvnDFJRERERtelSxfp599++w0dOnSAnZ0d2rdvj4ULFyIlJUWj/siRIxEZGQkAqFq1KtasWYPg4GDMnz8fXl5eANT3pRsyZAiSkpIAAP/73/+wd+9eTJ06FXK5HEIIfP7557h//36ueO7evYtWrVphx44d2L17Nzp06ICoqCiMHj0aKpUKdnZ2WL58Ofbv3y/dDzA8PByTJ0/W+7m5c+cOfH19sXv3bmzfvh2NGjXCmTNnMHv2bADqS8TXr1+P4OBgvPHGGwDUszoXL16sdX/x8fFYtWoVfvzxRzg6OgIAjh8/jqtXrwIAbty4gR9++AEAIJfLMWPGDOzZswc+Pj5aV+L+/fffoVKpAABz5sxBSEgIgoKCMGXKFDRs2LBQs9zOnj2LW7duAQA6d+4MNzc39O7dG4B6RuO+ffs06hfm9X9RZGQkpk+fjv3790vnZvLkybhx4wYAoEmTJti5cyfWrVuHihUrAlDP1ty2bRsA4ODBg9JM1LFjxyIkJAQ///wzvvnmG7Rq1UrKUx/nIz8+Pj7Sz2FhYdLPXbt2xerVq/H7778jNDQUwcHBGDduHAAgNjYW69atA6C+bcKyZcukdt27d8fRo0dx9OhRfP311wCA1q1bY/ny5fjtt99w6NAhHDx4EPPmzQOgvpVAzt+tX3/9FQBQrVo1/Pzzzzhw4ADWr1+PgQMHSucRUL9mDx48AAAMHDgQwcHBWLlyJWxtbZGZmYmhQ4ciJSUFPXr0wNGjRzXun5kdX2Fvd0BERERliLFHRomIiIiysrLEgAED8pwlVatWLWk24qNHj6QZaWZmZhqzt3I6f/681N7d3V1kZGRIz7377rvSc4sXLxZCaM6YtLW1FY8ePdLY3+LFi6XnhwwZIo4ePSqOHj0qjhw5ImxsbAQA4eDgIJRKZaFyLuyMyWrVquWaZTd27Fjp+cmTJ0ux/P7771J548aNpfo5Z8ll5yuEEJ988olUvnv3biGEEPPmzZPK+vTpI9V9+vSplCdyzJicOHGiVLZjxw7x8OHDQuWf07hx46R9rF69WgghRHBwsFT23nvvSXUL+/q/mPfkyZM1nlMqlaJixYrS85cvX5aeW758uVTeq1cvIYQQq1atksqWLFkioqOjtR6zuOejoBmT+/btk543NzeXyh89eiT8/PxEvXr1tM7sfPvtt6W6OX/Xs2dJ5pSSkiJmzJghmjRpovGaZz+aN28u1XV3dxcARLNmzcSFCxdyzW7Nji17BrK7u7v0+3r06FHx9ttvS/v9+eefpTbVqlXjLEkiIiITwBmTREREZHRmZmb48ccfcerUKYwbNw7NmzeHXP78bcrt27el+zzeunVLmpFWs2ZNNGjQQOs+b968Kf3cokULjUVCWrdurbVetnbt2sHJySnP/QUEBKBDhw7o0KEDXnnlFaSmpgIAEhIS8O+//xY678Lo1q1brlWpc8YyZ84cKZaePXtK5dkzAV/UsWNH6edKlSpJPz99+hSAeoZmtpdeekn62cHBAfXq1cu1vwEDBkChUAAA+vTpA2dnZ7i5ueGdd97Bn3/+WWB+QghpVqKZmRnefvttAOpFkLJfgz179kizZgv7+r8o57kB1DNHs+8LamNjg8aNG0vPafv96NWrl3S+Pv/8c3h4eMDJyQndu3fHjh079HY+ChIVFSX97ODgAEB9T9AuXbpg0aJFCA8Pz3WPUeD561sY/fr1w4wZM3D58mXpdzuvfQ0bNgwAcPHiRTRv3hwVKlRAw4YN4efnJy1odevWLenemjExMdLva4cOHTTuQ3n9+vVCx0hERETlAwcmiYiIqNRo06YNFixYgPPnz+Pff//FO++8Iz2Xc4Gc4iroclo3N7ci7/vFy86Lq6ixZGVlIT09PVd5zstrcw54ikIsyqLtvDVu3Bjnzp3DZ599hjZt2sDBwQFxcXHYtWsXfH19ceLEiXz3eezYMekSX6VSCVdXV8hkMlhYWODx48cA1JcPZ18yXFT5nccX89KWp7u7O86dO4evvvoK7du3R6VKlfDkyRMEBwfjvffekxbpKe75KMjx48eln729vaWyCxcuAFBf2r9x40YcOXJEY0Gh7MHcgkRGRuK3334DANja2uKHH35AaGgoQkNDte5r9uzZ+Omnn9CnTx/Uq1cPMpkM169fx+LFi9G1a1dkZWUVOjd9/+0QERFR6ceBSSIiIjK6I0eOIDk5WaPMzc0NgwYNkraVSiUAoHbt2tJsyjt37uQ5M7Bu3brSzxcuXNAYIPn777+11sumbWAqZ73p06dDCJHrkZKSonVWYXEUFEtAQECesWTP3NNFzZo1pZ/Pnj0r/ZyQkIDw8PBc9YUQaNSoEZYuXYpTp07h6dOn+PnnnwGoB7B2796d7/FyDp7lJ3vgr7Cv/4tePI8uLi7SPTZTUlKke2wC2n8/hBCoVq0a5s6di6NHj+Lhw4c4c+aMVG/nzp1SveKcj/ycO3cOmzdvlrb79u0LQHMWZf/+/TFw4EB06NAhz/3knI384oBlzn35+vri008/RceOHfP9XXr//fexfft23LhxA0lJSfjf//4HALhy5Qpu3ryJ2rVrS+e/Vq1ayMrKyvX7mpGRgVmzZhUqRiIiIio/zAuuQkRERGRYa9aswd69e9GnTx907NgRlStXRmxsLObMmSPVyb6sOPvy2b1790KpVKJ79+6YMmUKvLy8cPXqVZw/fx6bN2+Gt7c3GjRogOvXryM6OhoDBgzA4MGD8ffff0uXj1paWuLdd98tVIz/+9//MHHiRKSnp2Pu3LmQyWTw8fFBamoq7t69i0OHDuHZs2c4ePCg/k/QC/r374+lS5cC+D97/x0m2VkeeP/fc+pUztVVXR2mZ3qyRlkaBRTIQkJgieCAwwIXjrDgF6PdtaV9jbXAb4HX68X2GttcFmAwNkbY2FpAAoEFQhIooRxG0oSe6Rwr5zrh98ep6pnR9OTurnR/rquu7q6ucFd1nzrn3M/z3Dd87GMfI5VKceGFF5LJZNi/fz8/+MEP2LRpE1/+8pdP+7Fvuukm/uiP/giAb33rW3zqU59i9+7dfP7zn19xRtuf/umfcv/99/P2t7+djRs34vf7uffee5d/v9KszSZd15eTdoqi8Gd/9me4XK6jbnPbbbdRKBS49957SafTp/z3PxlVVfnVX/1VvvCFLwD2Euzbb7+ddDrN7bffvny7X/u1XwPsBOoXvvAF3vnOd7J582bC4TA/+tGPjnmdZ/N+vFo2m+Whhx4in8/z4IMP8vnPf345Qb979+7lxP2mTZuW7/Otb32La6+9lnQ6za233rri4x45a/ahhx7ie9/7HsFgkB07dhz1WD/60Y/453/+ZxwOx3EbO11zzTVccsklXHHFFQwPD5PP53nxxRePer3Nv9k999zD/v37ufnmm/mt3/otgsEghw4d4qmnnuLf/u3fePjhhxkdHV2OcWxsDLAb9uzevZtwOMwFF1xwyu+fEEIIITrA+pa0FEIIIYQ41oka39BomHFks5FDhw5ZGzZsWPG2RzYMefTRR61gMLji7RRFsf7mb/5m+bYnawhiWZZ1xx13LDdeOdlzn8ypNr+5/fbbV7z/xz/+8RO+Z0e+hiObwDSb1liWZd1+++3L1//93//98vVHNsVpXrxerzU8PHzM43zqU586bgyqqloPPfTQcd+DIxvc7N69e8XbvPOd71y+zRe/+EXLsk7973+81920tLRknXPOOceN/1d/9Vct0zQty7Ksr33tayd8v//5n//5rN8Pyzr6b3+8y5VXXmlNT08v30fXdevCCy885nbXXHPNiu9LvV5fblpz5KX5P/D2t7/9hI+1adOm5cfaunXrceM899xzLV3XT/o3W+lvdGRDpDPZvoQQQgjRGWQptxBCCCFa7vbbb+dP//RPuf7669m6dSt+vx+Xy8XWrVv50Ic+xM9//nMGBgaWb79x40aeeuop/vAP/5BzzjkHj8dDIBDg4osvXl5GCnYTkyeeeIL3v//9DA8Po2ka0WiUt771rfzgBz/gQx/60GnF+du//ds88MADvPvd7yaZTKJpGslkkiuuuIKPf/zj/M3f/M2qvScn88lPfpLvfve7vPWtb6Wvrw+n08nw8DDXXnstn/3sZ/nEJz5xxo/9V3/1V3z84x9ncHAQj8fDNddcw3333ce2bduOue3b3vY2fu/3fo/zzz+faDSKw+EgFotx/fXXc++993LNNdcc93mOXMZ98803r3ibI5vWNJdzn+rf/2RisRiPPPIIt912Gzt37sTtduP3+7n88sv527/9W77+9a8vL0G+6qqr+OhHP8qll15KPB7H4XAQDod57Wtfy5133smv/uqvnvX7sRJVVfH7/WzZsoWbbrqJf/qnf+Khhx5icHBw+TYOh4O7776bd7zjHYTDYRKJBB/96Ef54he/uOJjaprGt7/9ba699lqCweAxv//a177G+9//fuLxOJFIhPe+97185zvfWfGxbrvtNt7xjnewadMmfD4fTqeT0dFRPvjBD/KjH/0Ih8MBHP6b/bf/9t+W/2bBYJBzzjmH973vfXz7299mZGRk+XFvv/12fvd3f5ehoaGT1oQVQgghROdSLOsUKp0LIYQQQgghhBBCCCHEKpIZk0IIIYQQQgghhBBCiHUniUkhhBBCCCGEEEIIIcS6k8SkEEIIIYQQQgghhBBi3UliUgghhBBCCCGEEEIIse4kMSmEEEIIIYQQQgghhFh3kpgUQgghhBBCCCGEEEKsO63VAaw30zSZnp4mGAyiKEqrwxFCCCGEEEIIIYQQoqNYlkU+n2doaAhVPfN5jz2XmJyenmZkZKTVYQghhBBCCCGEEEII0dEmJibYsGHDGd+/5xKTwWAQsN+4UCjU4mjWhmmaLCwskEgkziprLUQnk+1ACNkOhGiSbUEI2Q6EANkOhGhajW0hl8sxMjKynGc7Uz2XmGwu3w6FQl2dmKxUKoRCIfmwFT1LtgMhZDsQokm2BSFkOxACZDsQomk1t4WzLZMoW6IQQgghhBBCCCGEEGLdSWJSCCGEEEIIIYQQQgix7iQxKYQQQgghhBBCCCGEWHeSmBRCCCGEEEIIIYQQQqw7SUwKIYQQQgghhBBCCCHWXUsTkw888AA33XQTQ0NDKIrCXXfdddL73H///Vx66aW43W62bdvGV77ylTWPUwghhBBCCCGEEEK0iVIKMhPHXkqpVkcmTpPWyicvFotcdNFF/OZv/ibvfve7T3r7sbEx3v72t/PBD36Qf/qnf+K+++7jt3/7txkcHOSGG25Yh4iFEEIIIYQQQgghRMuUUvC9W6G0eOzvfHG48bPgi61/XOKMtDQxeeONN3LjjTee8u2/8IUvsHnzZv73//7fAOzatYuHHnqIP//zPz9uYrJarVKtVpd/zuVyAJimiWmaZxF9+zJNE8uyuvb1CXEqZDsQQrYDISinoVbANC2U3BKmswKqAq4AeKOtjk6IdSX7BCFkO+ga1TxKcYGc4WCqoFCsGfhdDoYDFqHiAlY1D55Iq6Nsa6uxLazWdtTSxOTpevjhh7nuuuuOuu6GG27gD/7gD457n8985jN84hOfOOb6hYUFKpXKaofYFkzTJJvNYlkWqiplREVvku1ACNkOuolSyaDUS8dcbzl9WHLgvSKlkiH00/9JObvAUqlOpWaQczno8znxhhPkrvl/5b0TPUX2CULIdtAt1PwSWqHMnpwLxagSVEpUyioTeYMRv4XxysMYoUkszQOaB8vhtr9X1ycF1gnHbauxLeTz+VWJpaMSk7OzsySTyaOuSyaT5HI5yuUyXq/3mPvcdttt3HLLLcs/53I5RkZGSCQShEKhNY95XR0xK8DhKNHn9qK2y6yARmzHaIfYRFcyTRNFUUgkEnLQIXqWbAddopxG+en/huIKy5X8cay3flb2pSvJVimUMuzPKhQNF6rqgLqDXL7GDmeGRNgL4f5WRynEupF9guhp7XyuLE6fu8qhqoVpWWwyp7AsCyxQ9Dp13WD+sW9hOv2oqoJDUZa/Kg4nOL3g9KI4vSguLw6XD9XlxeHy4nD70dy+5YvT40dp3B6nF1QnKMqJY2sctxVSsywWalTqBh6ng3jARSA20DbHbauxT/B4PKsSS0clJs+E2+3G7XYfc72qqt21Qy6l4Pu3kU/PspivUqrWKbmdxINugtGB1tZYaMQm9R/EelMUpb229VIKasVjr3f5ZRs4EXnfzkrbbQfi9NVLUFoia2hMFRWKNR2/S2PYbxEuLdkj8v6+VkfZNizLYiZbYeyFAwzMTRPWa/QrJmXTzaJ7E0XTxWKxQlBRQbYL0WPacZ/w/FSWe1+YZTxVYmPMxw3nDXD+cLjVYYlucsT5qGJZRGo1HC4XiqLI+WinUlQ74UfdXo6MSlqN4DTKmFaZWTWJaTnR6lWcZhXNqjXuWAVWmDB1vKeBo5KbqqJiOb1YmhfL6UXRPODyoR6R5HQbRSITLzFdUihaLlRVY8FwkarV2aHMEWyj47az3Ses1r6koxKTAwMDzM3NHXXd3NwcoVBoxdmSPaVWJJ+eZd9ihYqp4FCcFCoKhWqRzfohAqkDoJ9o6fpJsv5nIzcNuSnQ3PYog+a2RxnqZTtZWSvKjkB0v0aB5nx6lsVClUrNwONyEA+0weBBO5P3TfQ6y4JqjmI+zWy2jmrqhFQH2UqAl0sudsUUgq2OsQ1YlsVsrsILY1Ok9j5KcOk5Bsp7CehpqmgoqhOPWWG4updFYpRUZ6tDFkIAe/Yf4qs/fo7FfBW/28neRZPZ8b385hsvYNfWTa0OT3SLWhFKi2R1B1MFyJdNgl6N4QCE5Xy0Y3lcDvR8DoepU1d9WP4EhUoRr8di29t+n7J3iJpuUjMMqjWdeq2MUS2iV8uYtRJmrYxVK2LVy1i1CuglqFdQ9DKKXsFpVnBaVZxmDadRAcMEDKjVgdxx43IZJYK5aUKWg6DixFIU5sIXUyzlWSxU5LhtBR2VmLzqqqu45557jrruhz/8IVdddVWLImovi4UqZr3CkLmEhYWiKChmneq8weLd/xvFHUBzKDgdauOi4FRVNM0eAVgztQKkD4DDDQ4nKGpjGrQGpgHZCQgkQXOtXQxCtFpj8OCVpTol04XTobJQhlS1xg5mCcoB0cqOeN+KpgenQ6VeNuV9E92rmofMBGTGqacPUV0Yo56ehtQEPt2BpWoopkJAyUJZp7bohPFHwOlrm9H39bKcjDw4y8LexwkuPUeieoggFqqiEPa5Uco+0lYMw9dPsDyBSy+QNGexam6eGZvhwos32DNmhBDrr5TCuOcP+aX0rH3eUgCXpmLmLKzvJ+EDfyP7eHFm9CpUclDNQSUDS/spp2dYLJg4TIgpFlPmMNkynB8zJFHUiVx+IvFBrMI8GnUUTNRKmoCq0tc/QjSZAN+Z/2Uty6JmmNR0k6puUqsb1Ktl6rUSeqWEXi2iV0sY1RJGrYzVSHSilzGKM1TyLzUGRh1YAIqdh6nUjFV7C7pJSxOThUKBffv2Lf88NjbG008/TSwWY+PGjdx2221MTU3xD//wDwB88IMf5POf/zx/+Id/yG/+5m/yox/9iG9+85vcfffdrXoJbaVSM1BUFd3S7BkWKKhY1EyLuYqDar05zdYCjt4gNPWIhKWm4Gp879IaX5sJTU1FU5XTm19pWaBoVEyVfEXHMHScjgp+p4WHOvz8S/DsNyE4AKFhCG+A8AiEh+0EphCdxrKoljLkl+bIp2apZOZg8RUis/vo0y3iqopSB8Phpl5XKKUUgtNPgVmHwAC4fK1+Ba1VK0FhDqswR/bQM5TnDxKpWcRUyDiGUf0JisWcjDiKzlcrYmUmKC+MUZwfo754kHoxTaVuUK4bVHW706HTqJAwHKQJUlAiONEJmXm8Vg2jUmT/T7+F79n/IJDYSGDTJSgDF9j70i5MuDWTkc8fWmB+7xMElp4hWR0jaJmNZKST4MAW+na8Bld4gPx3bkNfqlOs1Ckp/YQcThLWLG7KTD/4N/x76rd4yzWvIeiRGZRCrLeDM/OUM3NULBd1tVGnzACXVcFZWJBZbCfSzmVu1jI2vQaVbCPhmD3i+9zy91Y5g16rNGbK2Yklo5rHnZ3HZWg4VQ3LgqQzy4IRZLFQlePJTuSLEX3353jpG5+lMvsST3uvIrD9Gl63PU50ZOCs/9cURcGtOXBrjiP+P3zAKQwCZyYY+8rjzJQ9uP2H+5rUDROv13FWcXWrliYmf/7zn/PGN75x+edmk5r3v//9fOUrX2FmZobx8fHl32/evJm7776bj33sY/zlX/4lGzZs4Itf/CI33HDDusfejjwuBwuGn3pgA3XdTlLWynmGXGXUN/whJUc/xapO4chLRUc3rZM/uNm41MGhgt+tEXRrBNya/b3H/hp41fd+l4aamyQ/f5DnUw7ylhufU0fTS0SrOTZ5ynhcAcCC/Ix9mfr54ef1xe0EZXikkbDcAG7ZdYjWq+sGmaV5CqlZSplZqtl59PwCVnEBpbSEpVePur3LKKHqFVQ0LFQsQDWqeMw6Skln7/1fJxAKE/I68QXCKMEBeyZxoL/xNWkXSe6WRINp2kXIC3ONyzwU5qhlZ8ll02TLdXLlOtQKDNUKONGwcOKrpal5EjLieDLNkwLLRM0vgbtqz1ZvhxOWHmXWymRmxyjM7qe8eBAzNY5ZXKRSN161H1bIazEyrgHSgQEq/mH6fE5cz36KXN2B0+PHsGBeD6PWsiTUPBNWgkAqC6mXcO57mZDnW/jDcUKbL8W/8RLo2wpq5x4ILycjx5eY2fcUgcVnGajsZ5tVt5ORXifBxIidjNx4Gfjj9h1LKYLRAXYwy2KhQqlSx+f3E/RshnIGt1Vh+IU7uGd2Dxe+8VfYNRRp6esUoldUdYPvPz/LnpcmeIuiUMPJoKuKicJkPURdN/HrJR7at8hVl27AoXbJsc9qaecyN43YTru3gF5bIdmYPWLWo/29VS9jmBbVRsLxyOTjkd+bloWhOKk4AlQcfjAjbDefJ6ME0BSIWmlUvYxTC8vxZCfzxXBRRw2EeeubbmDX+Ze2OqJl8YCbVLVGsZizV3wZJn61Rl/g2P4nosWJyTe84Q1296Tj+MpXvrLifZ566qk1jKpzLf/zl/KoWBgohBx1hiJedm6KQmTgmPtYlkVVN5eTlM2EZTOBma8c/X1VNzFMyJV1cmX9pDEpCgyYC7xuvkBdd+B1mqiWiuJ0k64FcCl+Nr/2v4InBNlJyE7ZS7uzk1BO2Tu10iLMPHP4QT3hoxOVoeHuStiIs7NKCRndMMkUK+RTcxRSs1Syc9Ry8xiFRZTiIlo1hWqtfCBjf6op1F1hLF8faiCBy+Wg9MIM03oQ1RvDsgyol9EqaeJqnkMMoGVreFNZXI48Ie8cYa+TsNeJ09H433a4IZCwZ1UembT0J8DRppU59Goj6Th/dBKyOA+mjmlBoaovJyKLVR0LKDuCFLRBcDsIlcZJGx4SVgqnWQbLkhHHEznipECxLMK1GorLZX9GSoH3NVfVDRbSObJzhyjPj1FPHULJjuMoLWKucMxT1KJkPAPowWG06Ca8iVHi0RDbAm4SQTd+twalFOmlEazJCfRaBk1V0S0Tze0glDwP/+UfZW+qRnnyWeLFvSRLYziK0zA9jeex7xEIBHEPX0B86248Q+eBc3U6KK4ly7KYy1V5bjLN1N6n8S8+x1DlFXaa1UYyUiPUt5HY9kYyMjR47IP4YnDjZwnWivgtk8XFJeLxPlRFBVVj6/PfZ/zZnzC69CBj3xnjwMX/iet2n4Nbk88WIdbK+FKJf3ligsVCjbAFw94qA+VFzKqFQ1EIMM+SI4JHU/nhvkWeye/nVy4bIRGUk/ll7Vzm5shajkWFUrVOyGkx6KkTrB6AfffZ/QaOTDxWsqCXAdBN69hk45E/GyY1S2skHINU1ABlR4CqI0DF5aesBqk4/FQcATweLxG/m5BHY4BF9Ad/Tq2mojosHNUFPHoBVSnL8WQHs/QqVikFQCy5scXRHMHlP2pgtFIz8HiPGDxw+VsdYdtp0zNZcdpe9c9fqtTxeZwn/edXFAWP09FoX3/yHX7dMI+edfmqZGa+cvj7Ys3AsiBjuJkzAoStLA69Do18pmFa7CuEeejJRfoSGoPhIYYGthLf5rZHRmvFoxOV2UkoLhweSZt7/nBgTv/hRGVzKbg/fvJkZTsvgxCn78gR5EZ3+uJxutMbpkW2XCeVK1BMz1FKz1LLzqPn57GKizgqS/j0HM00I9gfmEd+aKqqA9Pbh+LvQwsmcIWTeCMDBGIDhPuSeNxHbFOZCfKz95BaqlOsluyDSEvF7Q0SiUQIv+Y3eaEQZHw+hbuaIqgvEawsESikGHZkGdDyRDx1AnoFNTt59OtWVDvhdOTsymDj66mWQzibbcGy7G3y1cnHwpxd1+dVKnWTbLlOpmIyrQdJqwkKWh95f4x8OEawb4itgzHO6Q8yqi1R/rcnyS7VoDyHZtWpFdP4HaaMOB5P46QApwc0D6ZaBY/bboAmBd5PrJTi5YlZfvLKAtOZMkMRL6/fkWDnq5YEWZZFvqqzkK+ykCmQX5igtjiGlZnAU5wkWF+i+dnRLKJiAlVnCD04ghrdiDu+iUByCxujEeIBN07HCboaNpYrzU/M8sjeRabSJYajPl63Pc7AyAADvhivAXTjHCbSZfbPplk6+Bzq3HMky/uppDOQfpDp5x/E63Gj9e8kOHopyR27cfoia/NenoHDycgME/tfwLfwDEPll9lllpaTkeHoINHtV+IauQwiG0++n/fF7ItpYlbdEO5f7sQdvvoD7NpwHpM/+SqkJ6k//hd8c+oXeMMb3sJIrMdLagixynTD5EcvzXP/KwtYFmxSpvkVz4+IKWkqPidZw4Ou64RVkyHnEqCSNOd5JT3AX/1oL289f4CrtvRJTdiGxUIVXTeIk8NhNE6uajUKszWm7/4rTHcIRVFwKBaqAg7VLvGlKtg/KwqqcvhnFRo/K43rrMZ19kVpHg9bFmAd/vrq66p5anMvUayo+C2ViGJhlCxKWQO328R84R6qDu9ywrF6RNKxYqoUFP9ywtFOMAapuPzLCciKI4CuuPC7NXsA32cP4g95nUQaA/oRn4ugRzt6v1oKkd6/AX1yAl2v46IOpk5AqRKOb5JEUYfKL05jmCZ1h5e+WBsd2x4xMHrMWk/JM6xIEpPd4kSzAlbxn9/pUIn4XER8J29UY5oWpbpBoaLzJfWPeHl8hr6Am6puUqrWWSjUCAQibMlokDk83V9TFZIhN4NhL4ORGIORYQY3efA4HVCv2B2+c1OHk5X5GagXYfFl+7L8QJ4jalY2LoGB5ROSM15qINrXq0aQFVzMlxUWK2U2FPay/8f3kK+ZmIUF1NIiPj2DxygA9gHZq+cQORQFh8sDjVmPzlA/nnASf2yAYGwAb6gP5VSXR55k5Cy2fQOX+2LoxiYOLpXYO5dn73yBF7MVABTLwK9niZXSbPcVGXXnGdRy+GtLdsKp2JiFeGTCHsAdaiQqB45OXHrCh0/oT3VbMHR7cODIxGPze6N67H0bdM3PEhEm9SD7SwGmjRB5Z4yyJ4SlqPhdDrYnA5yfDLKtP0DoyFpvpRrB6ADbmaU4bTf0GtFy9MWiMuJ4Mk4vmBZqaQEC2+2/d73S6qjaVylF+t9uoTY5weWmac9KnDCpvqAwER/i0BV/wkzVRXlpEiN1CF95hmhthlB9kRDmUQ/ldCg4vGGs8EacfZvx948SHtxKJBI985NqX4ydO2Ps3Hn8m2gOlc1xP5vjfjh/A5X69RyYzzNzcA+l8Wfwp1/EqqRh/Fly488y8+BXITqKe8NFJLZfxsDQxnU/6bcsi/l8lecmMoyNvYJ34Rk2lPZwnpFfTkZGwgki267AtfFyiG1Z1RUS2sYrGH33FoIP3MH42EvsmPxXHr5rL/uufA+v37UBVZaQCnHW5nIVvvn4BNPZCn49zY3qY1ykjaMZRVBUPMEknsiIndjKz0FuEswqv+74Dx6vTXO/eiXfecZiz0yeX7p0A2Ffb9eELcwdwJmbYNDUsdTD74Vi1VF1ndL8fmqO1R1cURV7QosKKKqCioKiHHF9I6HpNEqEy1UMQ8OhOTEsMC2FgqlSq8DzmX7S7sHGjMcAFY+dgCw7guiKvbrD63QQaSQcY41kYzMBeXg10QkG81ZyxADfQ3vmGHz284S1OoNv+n2i5++Wc74OlZk7BIDhH0A73f+JtdYcGBWnRBKT3eQEswJaQVUVAo1ak++46nz+vOBiolwn6HVSUOoko07+02s2EvI4mc5WmMmUmclWqOomU5kKU5kKHDr8eDG/005WhgMMhi9maMdrCHudKKZuJyebicrsBORm7GRNar99WQ7KaS/3Co+Aw2Xf1hs+OrlRL8usog5lYTGbLVOpWQQp4DFLuJQ6TrOCVjPwv/LvOI84UFMVBbfTgcPtQ/HHcQT7cYf78UaSBGKD+CL9KEcm8M7GKY6caQ6Vbf0BtvUHuBHIVersmy+wb67A3nkX49UY4zrLM49jPo1zk7AjUGKTq4CrvHA4Ydis0VPNwdLeo59T8xxOVCoqpMfskgqeMJiGncCqZKHwAjx2h92Yp7jIkTNIj3LErE0r0M8iUfaVfbyU87I/a5eAAMAJqgs29fnYngyyvT/AcMR7/GTIEe/bvru/APMv4bvg7QQve4uMOJ6K7DhqaQkKYfCGTn77XlYrklmcoWQ5MTQvtbqOw6ziq2WpTz+H/uCfs8EsL5dwUAC35sDrc+D0RnBEN+JJjBIc2Io3PgreSCtfDQAep4NzhyOcO3wVXHMV2VKNQ+NjZA48gTn9LN7SFKTGKKfGGH/2Lva6+2DgQsKbL2Vkyy5iazgreS5X4bnJLAfG9uNeeIYNpZe4UE8dTkaGYkS3XIZz42UQ37G2NTL9cfqu/28EXvgu449/FwrPkP/JJP848Su8/drdMjtbiDNkmhYP7Vvkhy/OgV7h0vKjvMn1En1uFVBhw7V2zelKFsoZ+05OD0RHoV7B7fJwjWOSbYUxflLayQvmVfzFfSVuvmiIi0ciPTd7srqwn4M//VcqBx9nyKpSQiOn9aFrASzLwqiViTurcMEvYbjj6CYYJhgW6Ka9TNq0oG5ah683LHTLwrDs2zZ/p5sWFgr2XMnl+ZJYSvPcUlkuXWQ12qJaikqovsDV8xNkFT91vOiKhqk4cFpFIhR4qf96lPAIYa+TwVclG8NeFyGvtnblNBoDfNu3n8O9s/fiq00R9mpyLNnBiotTADjCK5RzER1FEpNiXZw/HOZjb9nBD16c49BSkQs2hLn+3CTnD4ePup1lWaSKNWaylcalzHSmYi+5LdqXF6Zzy7f3Oh0MRTwMhr0MhHcxtOkSEgE3moKdmGkmKrOT9ixLvQKZcftSK0DmIOQ9dkLG5beTNZZpJyfLaQgOtm/tPrEsV6nz4ksvU3j+HnYVDjJiKViqEwsLFXsU11RUokPbUOPbcEeS+GNJ/JEkij+xfrPuzmDkLORxcunGKJdujGJZFtPZCq/M5dk3V+BQqkiqpPNQCR7CharE2BjbwI5kkG07Awz7sWfLNROV+Vl7dmNp8dhtITcJRTc4jpiFYNTtmZBLr4ArYF+neQ7Pugz0Lyc3844wexcrdgJ1LE+h2qy/aWckY34nO5JBtvcH2ZLw2zOgT/d9S+yitjSOUapCZOS03seeVSvZX+slSUyegkrNwHAEcVdTDFopVEwU6ngtnc3ODJo3iNvjxx3fhDexGS22yV5O3CF1jsM+FxeesxPO2Yll/RqLC/PM7X2C0sRTKIt7cVeX4NCPqRz6Mc8/4Ccf2Yl75GL6N5/P1mTUrnd5FprJyL0HD+FeeJaR0h4uqs8vJyOjfREioxfbycj+c4/+PFprDg33he9k28A5zD/wJSZm5/Dv/Tu+s/Qmzr/67ewejfVcEkSIs5Eq1vjXJyY4uFBgtPgM1xiPsT2q4HKokDgHzn2nPVng3Hccv5SMXkF58dsMKHu4ub6Xc1Iv8XPn5fzr45fw4kyMd148fNafS53ASh9k8pF/Y3HsGWq6idNSMN0hUlYfefw4UambJn4XxPtCbL7s2rM+TrIsC8O00BsXw7Com+bh6wyz8dVCN83GVwtHbhL3tJdSFVxOBYdqoiomRk2n3+vhY2/e0R7HcMEBWJqisDB58tuKtlVJ24lJb3S4xZGIs9X9n+SibZw/HD4mEflqiqLQF3DTF3AfddtSTWc6U2E2W2E6W2Y2W2EuV6FcN9i/UGT/wuEDGocKyaCHwYiXwfBmBpO7GNzhxetU7RlfzUTl7PMw/ihg2Sft9cYJfDMZ87O/BFfQTlp6Y/aJpy9mf+9r/OyNgXbyZe1i9dUNk5fGJph58SGU6ScJ1ebpM0q4MCnhouLqo+IIYGo+CpUqI94aozd8pD0Ohs6QoigMR7wMR7y8cWc/lbrB2GKRvfMF9s7lWSzUOLhU4uBSiR+8OIfP5WBbf4AdyW1sG72EsLdxkm/odnKyMGcvmZrfA1NPcrgaHnZhcs0LlgE7fwEGLrCTkO4gKAq6YXIo1Vhy/mKe6ezCUbG6NZWtCT/b+oPsSAZWZcaRPz5CDahnps/6sXpCJW9/rpmGPdDiPfHnrwCPy0G9pDNkLqIo4NI0SoYLj9vBpte/F4YvP7X6xR1AURQS/UkS/W8D3oZRLTG//2kyB55An30BpVTEnXoSUk9SeNbFDzyj1OPnEx69iC1DCTb1+XFph0ujHK8257zu49nJLC8fmsK18CwbSnu4tDZ9OBkZDRLZeKGdjEye3/LGPEr/OSRv+hOCj32NQ3seZ9fSD5n64QH2nfsebrp8e08kQYQ4G5Zl8fNDae5+doZwYR9vyf+E84IlEhE3SjBpJyT7dx3+HD3ZoO1rPgjzL+Hd820u1KaIZx9h79yTPF9+PX+5eB7vunQDuwa7dOAtM07qyf/LzN4nKVR1LFRSsUvYeumb6d/zeXzpuTVrrKEoCppD4bQnL5Ys0kONWo5GFs1S0U0Tr6oSSYy0TQkeZygJS1BJSWKyk5m5GQD8iQ0tjkScLTm6Eh3B59KWl7c26YbJfL66PKuymbSs1E2msxWms0fXUov6nAyGPQyGhxmMbGU4ej7hycfJmh7mc2X0apGAwyDurOLDAkUDrMPNdtJjKwfnChyRtIwekbhs/Ow6wxov0pjnGJZlMT67yMEXHqZy8DEipXHCjYUkfo+bUGIr3ukUkwU3edONqluYeh2/qnflUjyP08GuwdDyAXmqWFuuTblvvkCpZvDsZJZnJ7MAJENutjcShaPxfpzBARjEPkEY+4n9/6q57P99VbVnUpbSsOEyrPAGFgs19k4tsW++wIGFIlX96Lp6wxHP8vLsjTHfqtd6iQ5sIg0o+Rks00RpYamKtuby28vqM4dAr6Kapt2EqFa2O7i3yUlBO4oH3MyXa1iWhaloPK+eQ0Cr0R8zIHkBBBKtDnHNONw+Bs+9msFzrwZDpzb/Mov7nqQ88TSl3BKO8isw8QrWxF287B7hQd92nMMXMhr3s+2JT1Gbm16uzVkfNyk+C0/7ojwVvYFEdYLLquOoCnYyMhwgMnIuzpHdMHhR+/1PuoP4rv0QO4fOY+aRO1FT+yk983/4x7mbeeO117IjeUxBDiEEkK/U+bcnp5iaGOPS7P1sZ5zNiQAeXwx2vhU2XXNmZRn6z4H4DpTJxxl++W4i3hSxhbuZLjzO3bk3smfnBbztgsHTW43RzrKTlJ77LtMvP85SsYaFykzwQpK7b+It5+2w6yuO/n/t2VjjBM3aoq9qJNdK3uggjIGZm211KOIMWfUKVmkJaLOO3OKMSGJSdCzNoTIU8TIU8bJ7k32dZVlkSnWms2VmMvZS8JlshXSpvnx5cSYPQLg2yztm8yxVi1Rw49J8zNUtFupudvT1EXzT/wueCJRTdpKwnLYvpZR9XTltL4etFexLduI4gXpeNcvyVTMvXYFjZ99IY56jpPIl9j73KNl9DxPMvoLHMvBgz8rzDuwkuesaIlsvB70K35tmW/r0utN3i5jfxZVb+rhySx+GaTGZLvHKXIFX5vJMZcrM5arM5ao8tG8Rp0Nhc9zP9v4gO71V4kAun2OqqFCs6fhdGoNeE83S+dkLszyTL5Iu1Y96vqDHHjDY3h9gezJIYI1nEkUTQ6CoKEaVXGaJcKx7k0RnpVGXk333wSvfo1ap4vG44eqP2jOGe+iz43QF3RojnjxWzaCieNgQsBjyawS1zp8heVocGq7B8xgaPA+s/wTZCcrjT5EZe4ry0iTuygSJ9CFI/wdV1Uch/Tx5I4jujmCZJl4jT8RMEcmNoygK3kCYaMJHZGiHnYwcutiuZ9vOFAV16+sZjm8j9LMvMnZwjIun/plH79nPS5e8gxsvGD795gtCdLHnp7J89+d7GV18gOtKzzAS9TAQjqBseR1sv+HMB+qbVBU2XglDF+M/cD/n7f0PwgtpYgtfZ6qwgy9Nv5m3veYiu/lXp8pOUd/zPWZfeYzZbAXTggn/eXjPu5HrLj6X4JHNAdu5scYpNGtrtUBsiAqgl9JYtSJKl58jdKPc4hSGaVFz+IhF23RbEKdMEpOiqyiKQtTvIup3cd7Q4ZOecs1YTlLONBrt5NI+ZnQ/HiNDyFFD0e22HtWaxc/no+z56Sy+iEHU76LPv5GYfxuxhIuo32kXZbasRi3KRpKytHRE4rKRxKwV7ORlftq+rER1Hp2s9EbtRiPZcTtp6QkdTlz2UGOeSk1n756nWXzppzgXnsdpVggDDlXB2zdCbMdVDOy6GsXfd/hOLv+6dKfvBA5VYVOfn019ft5ybpJSTWfffIG9cwVemc+TK+uNpGWBH+k53ragLifCVQXyBZMcgC/Oo1M1ylodTVWOalozGPasa801zenC9CVQi3OkZg9KYvJEfDEwdXAFsAwNXB67W0sPbQOnrTHT1G1M4nAYRAJO/OFGlylfvOsHNo5LUSCyEW9kI94L3wHFRazZ5ygeeorCzCuU8lkCRhY3RWr1HA50VCwcio5DgXN37MC5/c0wdAkc+XndKcLDBN9yG+c+9y0mn/kR5B4l/cg4X5r+RW6++kKGIt5WR7j6ZMWGOA3lmsF3nxon+9KPuTb/MBGtzpahIL6Ri+xl26s901xzw44bcGy8ik0vf4/oKw/gWtjH4IF9PDp/MXsvuYk3XrilswYOcjOYL3+Pxb2PMZUuUzMsJn27qIxex5suP5/BcBd+zrRYXzjIPkcQr5GnuDRJYLCNs6hiRZl5e1KQ6U+2X0ducdokMSl6gtflYEsiwJbEkUvBt/Jfv/ZRSvksHqdGpa5T002ylTp1h48Lql6YK6z4eAG3g5jfTczvJOpz0RcYJhrcTN+Am5BXO5ys0auvSlamjp5xWck1uh3P25emWsFehulw293DNbedpFQddrLBqK3l29UypmlxcOwVpl/4KdbkE7j0HD7sfIonGCOw9UqGz78Wd3Tk+DXe2qw7fbvwuTQu3BDhwg0RLMtiIV/llbkCe+fzjC0q/C/1NylYGYJuJ4qiYFkW+Wqdfl8f79q5mR3JAJvj/rXrlHiKHOEhrOIchYUJ4PKWxtL28nbdHUtrlDHIz9rLZsXKGjNNX/yn/0nAcZChK38J/65r7d9JQuYwfxxl6xsJbH0jgWoe9t/P4ndeRK3U8Ko6iqJgOjxkDDeW10Xf1f+5o2v7AqC50C75NUaTuwg/8jUOzswR3P93fDv9FnZd/mZeuy2OqnbJrFpZsSFOw765HD958Mdsnr+PTXqawYiXoZFdOM5/FyR2rO2Te0Jw0XsIbX4d5z1/FxMvPYFSeBL9py/wnX2v4zVveidDfW1eezI/C698n+yBxxlfKlKqmUx5dzI/+AZed+kF7BoMStOtNaI5FAx/EnJ5MnMTkpjsQIVFuz6oFh5qcSRiNUhiUvQszaEyMjTMw/s9bEsE8DeTMXN5rh6N8iuXbSRVrJEq1kiXasvfl2oGhapBoVpiPLXC46oKUZ+TWGPmZp/fTdQ/TCy6meiw6+j6N4Zu1347MllZSkHqAEz8HDslZ9mzLvXK4cY8938G+rbZ3WDDI/bX0HDHdhCfn5th/LkHKY89iqs8T3OhitPtw7vpUjac/zqCw+d0RcOJdqAoCv0hD/0hD9duj1M3TD74tTJFNUhJVXBpKmGPE003CAXc3HxR++zw3dEhKtNPUU5NtTqU9mZZ9gkPUI+fC9k9kJOmQSdTcYYxayVqDh+hLZd1fkJtrbmDMHQx7r5N7E8pGIaB4nCSN90EnVU2hYxWR7i6hi4m+taN+B//Kof2Ps8lS3cz8cBB/n7qZt59xTai/i5ohlcrQmmRrO5gLlfBqJZweIIkg07CPbJiQ5xcVTe4/7Gn0J/7d86vjuNxOti8aZjQJe+EDVes74BwaBDn1R9iy/ZXCDx6J5OH9jI880P23vkY0xe/k0uvfBNqu82mKszDK9+nfOhxJpbsUjnT3h2MDb+OKy86j5s3x2QG2DpwhIcgt4/i4nHKcYm2Vmt05HZLR+6u0JlZDCFWyQ3nDfDidI598wWCHif5Sp2Iz8XNFw0f1WjnSOWacVSi8tXJS920WCjUWCisPKsx4HYQ9buI+VzE/C76Ai6iviH64psJejR71kVmAqafIoOfyZxBvVIk7KgyoBXxWQZg2bOh8jMw8aj9wIoDQkN2krJ5CQy07WzBQj7L2HM/I7fvYbSM3VjIBagODdfQ+SR3XUty2yUo0vV8zTkdKucOhciW62zrDyzPmNw3X2C0r72Wr/rjI1QAMzvT6lDaWyllD2KoGnp8l52YzEuB95NZWErjMQq4NBVvTJKSpyro1jgn4WC6qFCo6Yy4zO6tzemL4XrtR9k2cC+LT34bx9KL5PZM85XFm3nDlbu5eCTSuTOcLAuy45TTM+TzRbymiUNRMKpzZPJutEgAf5eu2BCnbmJ6lud/9HViqacBi/6wnw2XvQ3njuvB6WldYIkd9L/9jwkceISxh+6E7BLGz7/KY3t/zI43/SdiI7taF1tTYQH23os+/jhT6RLz+QpTnu28nLyGXefs4vfO6ce/xvW6xWHe6BBMHE5wic7SPBcISkfuriCffKKnnT8c5mNv2cEPXpzj0FKRCzaEuf7cJOcPH78ov9flwOvyrlhXyjQtsuU6S6+aZXnsbMsyE6nyMfdvzrbcoC5xZarITLFEyXLhdKjka27SqsKOvijBa/8LWCZkxg9f6kW7AU92Ag791H5AhwvCGw4nKsMbwR9v2cxDvVbl4J7HWXrppzD/IlgmGvYMPjW+ldiOq9l43lVonpWTwmLtrJSkD3udvOXcZKtDO0okuZElQClIZ+4TatS0tQJJjEBjxmtx3p6l3aEzq9dDevYgAKov1toT7E7SqM0ZLi0SXt51dnltTlVF2XkjifgOAo/+PQcmprhq5ms89eNDvHzOdbzjkg14XR3SHdg0YGkfzDwLs89i5Kao5hdAd2CqLkqWCx9VNL2Akc3BA38Gm18HI1dAbIusZOgheq3Ksw/cReWlHxAza7g0laFd15C88pfbZxatouDbehXnbrqU/Y/ezdLTd6Nkxzlw12fIbr2U0df+GkqwBcc1xSXYey/WxOPM58pMpktMurawJ3ENAyPb+MAFg/SHZJ+z3gL9GykARlYGbjuNVa9gle2li9KRuzvI2YnoeecPh0+YiDwdqnq4+c5KKnXjmGTlSrMtC7pFvOjBU8sQcFRQTLsxT820eGoxxsSeGr5wnIi3n/DQVUS2aETIE6rOoOUnG8nKCXvGVOqAfWly+g4v/440vnoia3ZyYZkGsweeZ+bFh6hPPm0vSW8KDRHY+hpGL3gt/kh8TZ5fnJozSdK3QiwxxH5VA1MnvThDrF+Wb6yoOTsyOIjlCtrbvV6GwhyE5T07nvziJBqgReQ9OmXNLvC92Cylbyve6/47u575BjMvPYKavp/5pw/yhfl3cNOV5xx35UXLGXVYeAlmnsGYfZ5iPke+opOr6JTKFaK6l1n6yChxTEXFadWIW/NQXyS9kCFUfZDw+MOo/gSMXAkbLuvuv3OvsyyW9j7C2APfwCilcADexBZ2vOl9eJJbWx3dihTNzbZr3k383Nfz1H/8M96Zx5nf9wTV6efZeMl1+M5/u12KYq2VUrD3BzDxKJlSlfGlEgcdm9gTvwZX3yjvvnCQHcl1iEOsKNa/gQKgV3JYlRyKp81rkopluQW7I3fd4SMWk/1PN5DEpBDryON0MBQ58WzLVKlGuljjr5c+TL2Uw6Wp1A0T3YByXUdXfVyQckAqvcIzuAh6dhD2nkck5iCp5EiY88Tqs4Qq03grszhrJZTFl2Hx5cN3cwchsunoZeAnmuVyso6dlkVu7hDjz/2E8sGfY5Yzyzcx3BE8o5czcsHrSAyNnvJ7J9beaibp14rqcGD6+1Hz06TnJiQxeTzNepLBQVAUrOAgSvqAXf5BEpPHVU3ZiUl3TJYFnZZm07Fe5PKhXvYBhvvPIfTEN3HPTRA6dAffzb+NHRdcwfXntkm30HoZ5l/EmHqawsRzFIolchWdQlWnrHiZ8e5gOrCdetDNdcX/D93QiLoMNNWkqkPe8IPDzc89NxItzrJp6WXi3hKxxRnCL92Nmthpz6IcuBCkBEvXMJfGOPjgP7E08QqmZaG7wiSv+CW2XfL6jpgtG4n28YZf+jCPP7eH+cf+BUr72PPwPWzc/wiJS34BtrweHM6TP9DpKqVg33/A+COUqzXGUyVesTawJ3oN1cAI1+1KcuXmWPc0zepQfeEgL2thvHqWwsIkwZFzWx2SOEXNjtxGYACHbEddQRKTQrSJo2ZbJuD8rZt4eP8SGxo1/wzT5OXZPJdsiPDOS4bIlOr2pVwnW6qRKdepGxb5ik6+ojOZhudRgYHG5WJUSydqLLFBWWDAmidhzBPWl3A7qrgyKVzaM7gcqv0B7+s7ornOJntJuNOz3LEzn55lsVClUjPwuBzEA258wQiHkteROfQ8enYGq/HaDIcHdfgSBnZdw8ZtF7RfEXLRUbTwEGZ+msLCOPCaVofTnhoduQkOHP6aPiANcE7AsizMrP3+hPplWZA4DYoCm64mGNvCeT//ChMH9+Fe/Ff2Pz7G387dwC9fvpmBcAuWaVbz6NPPkjnwBJXpPeTLVQpVHdOyKDtCTHvPZTq4g1poE5sTQa6O+9kSqKH9YBOTkxPoegZNVdFME82tEk9uYPTcy3hyQeHZ4psZKr/CpszzDCxMEF18ktjE84QCAdThS+0kZXRzRySvxApKKQrP3MXEcw+Sq+gYipPSpjdwxXW/SMjfWeUZFEXhigvPZX70j/jhgw8RH/8++uwc2Qf+mU0HfoLzvHfA8O7V+V8tp2HffTD+MPV6nalMmRdqA7wY/AWy3mGu2hLnTef0d06phy6nOVTM4CCks6TnxyUx2UGaDYukI3f3kMSkEG1qpZp/8YCb91w+suKsNsuyKNUMMuU6mVKNbDNpWW4mMGvkK7CkJFkiyTMAGjicdcL1eaLlGSL1WaK1WSJmGreWxaUdxKU5cGsqLs2BFhrA5QtizezhUF4jTQCXCpVCFiU3ha5WyE4XqTt8mIqGHj+X2M6r2Hre5Xjc7nV/D0V3csc2UJ78OVUpVr4yQ7eXbIPdECtfh2DjwC0vTYOOp1Cp463MoQDRgU2tDkd0ouAA2uv+C5sT3ybywn04F59kce8EX03fzLWXnMfVW/vWvDFOvZBiYe9jFA8+ib6wbzkRCVDQ+pgObCcb2UXf0Fa2JgJcl/CTCLiPjuvdn2N+YpZH9i4ylS4xHPXxuu1xBkcGGPTFuN6yOLRU4tmpQZ6ZupgnC0tsLD3PxsXnCc3PEpv7D2IvP0CobxBl42vspd7e6Jq+brFK9CrW3h8y/8z3mVjMYZgwHbyQTVf/Mlft2NS5jZ2A/pCHX73xzfx4z/k8+dT97Mo+QH7fOJuzXyYy8GM4910Q33ZmD17Jwt4fwvjDmEad+VyVZyv9POt/K0uhEc4dDPKBCwaJB+RYuN1o4SFIv0RpcbLVoYjT0DwH8EhH7q4hiUkh2tTp1vxTFAW/W8Pv1hheYak4gG6Y5Cq6nbgsN2db1smUomTKW5gs1anqJk6zQqQ2R7Q+Q6Q2S7Q4g9fIw3wel1FiQ26akOUg5HBhWYBloVh1dMuiHNiIa9f1bL/gGmJhqdUiVl8wsYEyYEhn7pUVF+zmWJrHrh+bXzg8c1ISk8e1sDCLZtVwOZ04QwOtDkd0KocTzv9FovGd+J/4R8Zm5gnMfpVnH34ze6Zfwy9ftpGwb/WWjtYNk+nJQ6T3P0598hnITiwnIgEyrgHSoXNwb7iYoQ2j3LBSIvLVfDF27oyxc+fKv1YUhdG4n9G4n1+4YJCDS0Wem9rMzyZfiyd/kI3FFxieexnPwl6i44eIBe4iuOE81I1X2ku912LprDg7lgUTj1F74dscnJohXaqz5N5AevTt3HjtFcSOUzu90zhUhevOG2Dn4M1867ELCM/9jNLcIwwVX2Zj+v/gGLwAdt10eJ95MpUc7L8PDv4Uy7CPq58t9fFz92tYjG1kMOzhty4YbN96swJv3zDmQenM3WnMnF1LXTpydw9JTArRxla75p/mUIn5XSc8wKzUjcYMy53Ly8Xny3WK+RRWZoJw6jmiuT1YgNo4+akoHkpqFLfTwVW//DGUiCyDFGsnmtzEPKAW5zB0HYcmu7Kj5I+uLwlAaND+Wk7bteacKw9e9LLM7DiA3bFVlWV24iwNnI/rTbey46l/ZH7seZype5mojPHX6bdx0+6tXLDhzPbtdcNkYqnI9MR+SgefQJt/Hn998YhbKBT8m1AGLyQ8eimXjGw4eSLyLKiqwpZEgC2JADddOMSBxU08N3UR908sEs2+yMbS88RnJnDNP0r05SeJhsOEtlyBMnIFREdlqfd6adYGt0zU/BK4q6Codm3wUgpe+HdSMwcYWyySU0Psib+J83dfy1u3J7qyDuJIzMeH37KLe1+I8oOXL2RX7qdkp59ja+1pgvMvwsarYedb7UZRK9VUx4Lpp2DsQTDrFGsGL5RjPKRezkJoEwGPxrvPG2D3xmhXvn/dJBjfSBYw87N2gl4+k9qeVa9gleyO3JGBkRZHI1aLnM0JIY7icToYCDtWqIc1AlyEmb6Qsb//MRMVNy6XfbKjaG5qpTxRTwUF2aGLtRWO9YPDBUaN9PwU8SFZdnuUXLO+5ODh65w+8ITt5Wb5GYhtaU1sbay0OIETcEWkXpFYJd4IylUfJtl/H6Hnvo1vfj/RyS/z/dIvsGf7edx80RAe54mT4HXDZCJVYmwhz+L4y1izz5IsvoLPyNJMbWqaBvEdeEcupn/75fT1rf2S8ZWoqsK2/gDb+gPcfNEwBxa28uzk63jw0CESuWfZWHyBudw8rpl7iPn+g3BimPCOa1E2XAbeyLrH2zMatcEpLaJYFuFaDcXlAtNOuumxHRzKGcwWLV4OvZ7S8NX88hWbSYZaUBd1HTkdKr9w4RDnDIT41yfC7M/t5vzM/VxanmLYfBD10EOwdMAeqFIatdFNHcope4Bvw+XUFCd7qzF+aF7KnHczmkPl9dvivGFn4qTbtmgPfckNZFCpV4pYlQyKlJ1oe9mFSQzLou7wE4/0aOO9LiSJSSHEaVEVhf6Qh0y9TrGu4nSo1Go1/GqNPqmdI9aBoqpYgSRKdoL0/LgkJl+tuVw7NHj09cEhOzGZk8TkSmqZSZyANy6j72IVKQpsuw5v33Z2PfFVQtOT+Ba/zp7qNfzdzIVcPODmpdk805kyQxEv12zrwx8Is7/gYmwuS3nmJfpLexks72XUtGduuRwq/qAf5+B5RLbsJjJ6EYqrvRqSOFSF7ckg25NB9IuH2L9wIc9NZnhh7DkGss9Syb/MbG4/rkNjxPzfJDRyPpGd16IMXCBLvVdbrQilRbuBoebBpAT1NOSmqet1XqomeMF3JS8NXsvVuzbxpnP626OT/DrZ1h/go2/eznee9fPIeIx91XGuWnqISzyzeFP77LIokU2gV6EwD0YVyzSYqPn5Lq9nQhsFReGC4TBvPX+ga5a994q+kJ/nnRF89RTZuXEio5KYbHeZOXuFixkYkBnJXUQSk0KI0+PyE4wOsINZFgsVuyu31+7KHYwO2MuChFhjjvAwZnaCohQrP9ZyR+5XzfwLDcLCHqkzuQLTtJZnmkpHbrEmoptQX/+HjDz3L0T2P4J/7n6C03/HwpNeLlE1dqsK+phJ4UkLw+OhEH0Nu2rTaGYVl0Ml6NXwB2L4N15CcPQSlMQu0DojAaI5VHYOBNk5EES/ZJi989fywqF5sgceZzD3LLXsJLPZx3G/9AThUJjQtiuJ7bwGJbJJllWuokxdY35+CV/+IB4HaJjULCc/if4S1f6L+M3dI2zs87U6zJbwuhz8ymUjnDsY4q6nHHzHNcKB/E/5ReMxFAyKM2PUDROnQ8Xh9FKw3HzdfCtZ9wAbol7edsEgm+Ny/NuJVFXBCg5CKkV2fpLI6EWtDkmcRHHJrgeqhQdPckvRSSQxKYQ4Pb4Y3PhZgrUiwVf/zuW3fy/EGvPENlAah1paEpNHqVegtGR//+ri/dKZ+7hShRK+2hKqohDplxm4Yo04PXDpewkmzuGcx75MLp1BsfLMWkOYpknIKhC0sniqFiGrD280TDCcwDtyMcrgRdC3DRydfeiuOVR2DYbYNRiifvkWXpl7G6/sP0Bl7BEG889RTaWZf+z7eJ78If74MNGd1xLbeTWKp7FwvVkr8dXk+OOE8lWdl1I5hqoHsCyTBd1Fin4iHpUdWzbz+iu24dZk6fH5w2E29fn496emmDy0jQNmklqlRpQchupmvNpHraKxwVMh6NW4/tINXDIS6ehu5QKc0WFIvUBpaaLVoYhTsNyROyYdubtJZx/dCCFawxeTEwDRUqH+DZQAUzpzH61gdynEHQR3AEzz8O+aicrcjBR4f5XF2UkUTFweH6pfPtvEGhu5HM3hQn/pATTLYFBZRAFUh4JqaaDC6KVvhq1vgsgoqN25rNbpUDlvKMx5Q5dQv/oiXp7JceiVp6kffIRk8WUqs+MszX4dz8++iWvoPJJbLyb68j9TSC+wWKjaKzZcR6zYuPGzcmxyHIuFKoqh4FAsKqbKfsdWNKNMwlHj+nMHQJKSy4IeJ+99zSaeC+ap7reYM8JMaYOAgqWCphdRFIXffu0W3H2y7Lcb+Po2oO+HWnq61aGIU2A1VrgE4tKRu5tIYlIIIUTHiSQ3MQso5UXqtSpOl9Q3BY5ofLNCA5fgAKBAvQjVnN0MRwCQm2925B6ShK1YH74YRd8w5VKBPrVAXfVQcIRI1zWSXov49hsg0jv1Tp0OlfM3RDh/wxuo6q/llckFpl/8Gcrk41CZpHLoGSoHHkYpPc+iGWBJ7cNyBqmXTVLVGjuYJVgrSmLyOCo1gxBlLKOOYXkJO+r4nCaGabU6tLakKAoXbojwglMlaNapUAEL3JqKVzNRAHcP1eHsdqHEBlKAJZ25255VL2OW0gBEB6T0TjeRxKQQQoiOEwrHsDQvil4mNT9BcsO2VofUHo7X+AbshhL+BBTn7QSmJCaXlVOTeACXLAsS6yge9PB83c+UOYLT4aBmmAQdVfoCRqtDaym35uCC0QEuGH03lfo72Dd2gMUXH0SZ+Am6ruO28gyaFWqml3RgK8UKLBYqx5aXETaXH8vXhyf9Ei6rTkX10O8sUqoZWOGk1AY/HpcfxRfHr88TdRioioKqKpRqOlZQ3rduEu/fwJKiUq+VMYopHIG+VockjiO7MIXZ6MjdF5EZy91EEpNCCCE6jqKq9gzA9BiZ2XFJTDYdr/FNU2jQTkzmZ6D/nPWLq83pGbteUUA6cot1FHRrnJtwMF20KNQqJD0aQ36NoCazdZo8Tgfn79gOO7ZTWXgjh+74DUy9hpcKLquMu5rCcASo1Ho7mXtCvhjKjX/Kk//6/8NfnuYh7RoW3bsIRZz85hsvkFmmx9N4377+4+fIV3T8bo1iVScY0eR96zKRgIeyqw9fdYHM3EH6JDHZtpY7cgelI3e3kcSkEEKIjqSFhzDSY8vd+QSQa9RHenXjm6bgEMw8Iw1wjlA3TByN2pzhpDS+EevE5QdfnHBpkfDy5GXd/uKLy2ysFXicGi5fkImyh7BSIFKbRTNK1C0fXq/USDyRXVs2UosqTJsBpn07OX/nudxw3gC7hmXm/Ins2rqJ93si/ODFOQ4tFdkx6uf6c5PyvnUZRVEgOAjVBXILU/Rt3d3qkMRxFBftBkWO0HEG4EXHksSkEEKIjuTtG6FwEOoZSUwCUM1DrQAoJ0hMNhvgSIH3poV0Fq+eRVMVAgmZMSnWiS9mN2uRDtOnJR5wk6rWqNZBMeu4zBx+b4i+gNQZPqHiIppVJ+L38r7XXcjrL9yK2qVNlVbb+cNhzpdEZNdzRYZh8VnKi9KZu501GxR5pfRO15HEpBBCiI4U6t9AATBzMvsPONz4xtcH2nFO0psjzPlZu2O3nJiSmj0EgOaLosgsNbGefDFJQJ4Ol59gdIAdzLKYq+HO6XgVg2TUYXfllu33uMzMJKWaQc7Zz0jI0+pwhGg7/vgGqvuglpWB23bWPOYPJqQjd7eRxKQQQoiOFBvYxDSgllNUKyXcHl+rQ2qtfONgeqXGN02+OKhOMOtQWoJAYn1ia2OF+XEUQI3IsiAh2lpjlmmwViQIPPlPf4xSKzD4mt8ntO1CSfKeQG5+DNOyKHoGiXrl9E+IVwv3jzAPkJ+Tgds2ZdbKmOUMIB25u5FscUIIITqSPxjBctl9WJdmZenN8ozJ4zW+AftAO5i0v8/LrACASmoSAHdUlgUJ0fZ8MYiMQGSEWmwnNYePpUJJkpInkZ9vzAyPbrDr6QkhjtKXHMJUNGq1KvXCQqvDESvIzE/YHbm1ALFwpNXhiFUmiUkhhBCdq1EzMdc46eppyx25j1NfsinYmFGZn13beDqE0ai3GeyX0XchOom7z95mSwsHWxtIB6gt2Z1sfQlp8CXESoIeFxV3AgtIz8oxZTvKztuTEMyAdOTuRpKYFEII0bGcUXt2YHGxxxvgWNbhROPJOhU2E5PSAIdyVcddmgMgOiAn7EJ0kmByFAA9LTPmT6iSo1bMAgqRpAzACLESRVFQQvbAbn5hssXRiJUUl+y/ixaW0jvdSBKTQgghOpY3Zhe/7vnO3KUUGFVQNfCfpG7kkQ1wetz84jxOs4JL0/BIjUkhOkrf0FYA1MIser3W4mjal5WdpFTTKWgxBvuku7QQx+NqlHQpL0lish01O3J7YnK81o0kMSmEEKJjhfvtWW5Wvsc7czfrRQaSoDpOfNvmjMniPBj62sbV5prLtZRAAhzOFkcjhDgdkb4kluYFU2dxdrzV4bStwvxBdNMi7+6nPygduYU4Hn+fPditS2futnS4I/dIiyMRa0ESk0IIITpW34B9cKJWc5SL+RZH00LN2Y/BE3TkbvKEwekDy4TC3NrG1eaKi/YSUC0ijW+E6DSKqkLY3nYzM2MtjqZ95eYOAqCGN+CQumxCHFc4aR9TWvm5nh+4bTdmrYzV6MgdS0pishu1PDH513/914yOjuLxeLjyyit57LHHTnj7v/iLv2Dnzp14vV5GRkb42Mc+RqVSWadohRBCtBOPL4DpjgCwNNPDxcqb9SJDp5CYVJQjGuD09kzTetperuVrzJIQQnQWV8yumViQBjjHVWk0vvFK4xshTiiRGMRQXNR0nWpOyt20k/TcOKZlUdOCxCKRVocj1kBLE5N33nknt9xyC7fffjtPPvkkF110ETfccAPz8/Mr3v7rX/86t956K7fffjt79uzhS1/6EnfeeSf//b//93WOXAghRLtQGsm43EIPN0BY7sh9ConJI2/Xww1wLMvClI7cQnQ0fyPZpi/JUu4V1SvoOfu8KtRoFiSEWJnf46Tq7QcgLeUh2kq2eYwfSKIoMvO7G2mtfPLPfe5z/M7v/A4f+MAHAPjCF77A3XffzZe//GVuvfXWY27/s5/9jGuuuYZf//VfB2B0dJRf+7Vf49FHHz3uc1SrVarV6vLPuVwOANM0MU1zNV9O2zBN0z7h6tLXJ8SpkO2gdzgjQ+gLeygtTvTm39vUUfKzYFlYgQE44j047nYQGECxLKzc9FG37yXZUhVvZREFCCdGevN/p4fIPqE7RQc3kwHIT6PX66iOk9TY7TXZSYo1nYoaYFO8T7YDITjx/kAJDUBpktz8BP07ZTtpF83SO2p4UD6/VtFq7BNW6+/RssRkrVbjiSee4Lbbblu+TlVVrrvuOh5++OEV73P11Vfzj//4jzz22GNcccUVHDhwgHvuuYf3vve9x32ez3zmM3ziE5845vqFhYWuXQJumibZbBbLslDVlq/WF6IlZDvoHYYzhKHrlOfHjjvjvpupxTkCpRKWw0U+V4P84ffgeNuBo+bEX65gzu2n0IPvGcD45ASWXkVxuUmVLaj05vvQK2Sf0J1MxUXdVFD1Evtffp5w/BRnjfcI4+CzVKp1FtwxNldyzM/nZDsQPe9E+wPdFcbQdTLT+3rymLJd5WbGUHQdwxmSv8sqWo1jo3x+dWr8tywxubi4iGEYJJPJo65PJpO89NJLK97n13/911lcXOTaa6/Fsix0XeeDH/zgCZdy33bbbdxyyy3LP+dyOUZGRkgkEoRCodV5MW3GNE0URSGRSMhBh+hZsh30DnPreUy8+O+4ayn6+/tbHc76m5pE8XqwopvxvmqfetztIBpAecUDVPFFg+D0rm/MbWDywAs4NA1XbIT+V71vovvIPqF7HYqOoGbHoZKhv/+iVofTVmZfSuPQNLS+UTYMDch2IAQn3h/0b9xJefw+nNV0bx5TtqnJWhpD04hv3iV/l1W0GvsEj8ezKrG0dCn36br//vv59Kc/zd/8zd9w5ZVXsm/fPj760Y/yqU99io9//OMr3sftduN2u4+5XlXVrt4hK4rS9a9RiJOR7aA3xIc2MaEoqPUSpUKWQCja6pDWV2EWFAUlNAQr/K+vuB24A+CNQCWLUpyD2Jb1i7dNVFJTOAFndIN8RvQI2Sd0J2ffJozsOMXFQ/K3fZVm4xtP38bl90a2AyGOvx1EB0YpA1ZpEdUywOFsTYBimVktYVWyAMQHN8ln1yo7233Cav09WvZXjcfjOBwO5ubmjrp+bm6OgYGBFe/z8Y9/nPe+97389m//NhdccAHvete7+PSnP81nPvMZqTUghBA9yuX2YHljQI925m42vjmVjtxHCg7ZX3O92Zm7np4CwB8faXEkQoizEUiMAlCTBjhHM3T0rN3gSxrfCHFqEvEEddVDXTeopHu3QWA7Sc9PYFoWdS1INBxudThijbQsMelyudi9ezf33Xff8nWmaXLfffdx1VVXrXifUql0TEbW0ShybVnW2gUrhBCirSmNLtP5hR48MV3uyD10evdrJjLzvZeYNEwLpWC/7nByU4ujEUKcjchQY8Z3dhJLJiocVpijXKmjq276k6e5fxCiR3lcGnWfvVQ4JZ2520J23v47WMEB6cjdxVo6D/aWW27hjjvu4Ktf/Sp79uzhQx/6EMVicblL9/ve976jmuPcdNNN/O3f/i3f+MY3GBsb44c//CEf//jHuemmm5YTlEIIIXqPKzoM2Mtze0q9AqUl+/vgyqsNjquZyOzBxORSJoe3nsGhKoT7ZcakEJ0sPrARFBVFL5NNSVOEpmrqEBXdIOPsZyjae3WEhThTjsbAbaHRCVq0VmlpEgBHWAZYullLa0y+5z3vYWFhgT/5kz9hdnaWiy++mO9///vLDXHGx8ePmiH5x3/8xyiKwh//8R8zNTVFIpHgpptu4n/+z//ZqpcghBCiDfjjI9QAPdNjy26aSUV30K4beTqaMyZzM2BZ0EOj0Etz44CF5gmheLqzEZ4QvUJzujADA6j5aRan9hOJn+YgTZfKzIwBoAeG8Lk6qq2AEC3ljg7DdA8OdrepWmNJvTc23OJIxFpq+V7qIx/5CB/5yEdW/N39999/1M+apnH77bdz++23r0NkQgghOkUkuZE0QH4GyzRReqUwdn7W/nq6y7gBAklAgXoRqjnw9E7dnnxjWZAqo+9CdAUtuhEzP01+bgy4ptXhtIXSov0554ptbHEkQnSWQP9GCi+Ake29FSXtyMzZx7qh/g0tjkSspR45cxNCCNHNYv3D9lI+o0ous9TqcNZPvjFD9HQb34DdadKfsL/vsQY4zVkQ7pgc5ArRDXyNBjhVaYBjsyzqKXsZarBf6ugKcTqiSTuZbxYXseqVFkfT24xqEauSASDWL4Ms3UwSk0IIITqe5nRh+uwkW3quhzpzn82MSejZBjhGptmRWw5yhegGkcHDDXAEUFqiWilhKg5iSfmcE+J0JPr6qDl86KZFcUmWc7dSZm4C04K6M0QkLKV3upkkJoUQQnQFtZFkay7T7Qm5s5gxCT3ZAKeqG2glO6EbHZCZREJ0g/jQJlAUlFqeXDbV6nBarp6eoFwzyDkTDMdOs/6wED3O6VAx/HbPi8xcDx1TtqHljtwB6cjd7SQxKYQQoiu4G0WxK+keGd2u5qFWABQInGGzh2Yn71zvNA1aWFzCZZRwOhz4+6SQuhDdwO3xYfr6AVia2t/iaFovOzuGBVS8A4S8LW8pIETHaXaALi7KLOxWas5Y1SJSE7zbSWJSCCFEVwjE7XqBRqZHZv8160L646C5zuwxQs0Zk7NgmqsTV5vLzNpL/VV/H2juFkcjhFgtWnQEgNzsWIsjab3i/EHAfk9klpEQp88T7bHB7jZVz0hH7l4hiUkhhBBdIZK0l+UqBbszd9drNr4JnuFsSQBfHFQnmHUo9UbToHyjU61DRt+F6CqeRs3YymIP1Rk+jlqj8U1AGt8IcUYCCfvzRDpzt5bZGIQPJaRZYbeTxKQQQoiuEEsMgaqBqZNe7IEDyeaMyTNtfAOgqhC06ygtJzq7XDVlL8vySEduIbpKeGAzAGamx5deVnLUihlAITow2uJghOhMsQF7BrZZTmPVii2OpjfZHbmzwOFO6aJ7SWJSCCFEV1AdDky/XWMsPTfR4mjWQbNhzdnMmAQINjtzz57d43QIK2snYIP9cpArRDdJDG8FQK2kKBfzLY6mdczMJKWaQUGLMtgXaXU4QnSkvkiEqiOAYVoUFmQ5dysc1ZE7FGx1OGKNSWJSCCFE19AaxcoLi12emLSsw4nE0FkuSW4mJnugAU6hUsddWUBBOnIL0W28/iCmNwbA/GTvNsDJzR3EtCyKniTxwBnWHxaix2kOFbNxfJSel87crZCRjtw9RRKTQgghuoa7Uay8uVy3a5VSYFTtpev+xNk91pENcLrc/Nw0DquO0+nCHTrLmaZCiLajRhoNcOZ6twFOrtH4Ro1I4xshzoYWthOT0pm7NUqN9106cvcGSUwKIYToGoFEoyZQtxcrb9aDDCRBdZzdYzVnTBbnwdDP7rHaXG7OboqhhAbs+ppCiK7i6bNLNJQXercBTnXJXjHgS8iscCHOhqfPrkVdlc7cLVFrdOT2SUfuniBH5UIIIbpGrFEcWyktYOhdnGRrzm5sJhXPhicMTh9YJhTmzv7x2lipccLujMhBrhDdKNRogGP0agMcvYqetz/HI9L4RoizEozbg91WrssHu9tU830P9o+0OBKxHiQxKYQQomuE+5LgcNmduee7eIS7WQ8ytAqJSUU5ogFOdx981xqzHrx90pFbiG4UbzbAKc1TrZRaHM36s7JTlKo6FUeAgcRZlvkQosc1B7v1cg6r2rsNtVpBL+cxKzkA+qQjd0+QxKQQQoiuoagqZiAJHC6a3ZWWO3KvQmISDteZ7OIGOJZlQWP0PSwduYXoSsFwDMsVBMticbr36kwW5g+hmxY5V5L+oLvV4QjR0frCQSpaGNOyyMx1eVPFNpOZn8QCas4woWCg1eGIdSCJSSGEEF3lcGfuLl3KZ+iHl1yvVmIy2GgE08UzJtP5Ep5aClVRpCO3EF1MaTTAycwcbG0gLZCdPQCAEh5Gc8hpnhBnQ1UVrMZxVnZeEpPrKducXBAclCZePUL2WEIIIbqKJ2aflHZtsfLigl0PUvOAN7o6j9lMcHbxjMnF2QkUTDS3D9UbaXU4Qog14m40wCktHGxtIC1QadTR9fbJ4IsQq8HZ6MxdWuziVThtqLjU6MgdXqUBeNH2JDEphBCiq4QSdv1AK9ulSbZmR+7goF0fcjU0E5OVDNTLq/OYbSY/b3fpVUNDq/e+CSHaTqB/FAA93WOJBNNAb+z3gtL4RohV4W00wKlmundFSTuqNd5vX580K+wVkpgUQgjRVSKNZbpKeYl6rdriaNZAbpXrSwK4fOCJ2N936XLuUmP03RmTxjdCdLPlBjiFWfR6rcXRrKP8LOVqFV1xkUwOtToaIbpCqNkROjcNltXaYHpJ41g3lJCO3L1CEpNCCCG6Sigcw9K8YJmk5ruwzmQzcbgaHbmPtLycuzsTk0bWXtofiMtBrhDdLBzrX94HLM4canU466a0OE5NN8m6+hmIeFsdjhBdoa9/BFDQq0WMcrbV4fSEIztyxwakWWGvkMSkEEKIrqKo6nIzl8xsF56UNutABld5Rkwz0dmFMyZ1w0RtvK5oUmqvCdHNFFWFsD0zOj3TO525M7P2azWDw7g1R4ujEaI7RII+Kq4opgWZuR4rD9Ei6bmJRkfuCKGAv9XhiHUiiUkhhBBdp9mZu5TqsjqT9QqUU/b3qz5jspHo7MLE5GI6hdsooKkKgX6ZMSlEt3M1GuAUe6gBTmnBHohrvnYhxNlTFGV5RYl05l4fy+9zcEA6cvcQSUwKIYToOt4+e7ZMLd1lS7mbSUN3CFyrPIocOmIpd5fVUUrN2LMcVF8MxSlLHIXodoH+zQDUUz2SSLAsjIy9vwsmR1sbixBdxhmxB27LSz3yedJiyzXBI9KRu5dIYlIIIUTXaRYrN7utXmJ+1v66mo1vmgJJQIF6Eaq51X/8Fios2CcTjoh0dxSiF8SGtgCg5iYxDaPF0ayDUopKuYipOEhITTYhVpWvMdgtnbnXRz1jr3aSjty9RRKTQgghuk40aZ+YqeUU1UqpxdGsonxjafpqL+MGcDjBn7C/77KEbqUxc9YVlY7cQvSCvv5hcLjA1EnNddnM+RVUU+NU6gY5Lc5gNNDqcIToKuFkowRMvvtWlLQjKy8duXuRJCaFEEJ0nUAoiuWyT86WZrto6c3yjMlVbnzT1KUNcIysndANSn1JIXqCoqpYjc/Jpen9LY5m7WVmDgBQ9w/hd2stjkaI7tKX3ICFil4tUy+mWh1OV6uXc5iVPHB4koHoDZKYFEII0Z0ay51z813URTG3hjMmoSsb4FRqOq6indCNDUhHbiF6hdZoAlOYP9TiSNZesdH4xhmTWeFCrLag10PFHccC0rPd/3nSSs2O3HWXdOTuNZKYFEII0ZWaxcqbRbQ7XjUPtQKgQGBgbZ5juQFO93QzX5ifQbNqODUHXimkLkTPCCRGAainuj+R0Gzy02z6I4RYPYqioIbs467cQhetwmlDzY7clnTk7jmSmBRCCNGVljtzZ7okydas++iPg+Zam+doNtXJz4Jprs1zrLP0nJ2UUAJJcMgSRyF6RbTRAIfcFFaXfJ6tqJqnVkwDClFpfCPEmnBF7UYs5W4Z7G5TzckELhlI7jmSmBRCCNGVwo16gla3zP5rNr4JrtFsSQBfHFQnmHUoLa3d86yj4qI9+q5JR24hekp8YBOoGopeIbM01+pw1oyenqBcMyhqEYbi0VaHI0RXag5217PdU+qmHdUzUwB4pSxFz5HEpBBCiK7U16gnqFZzlIv5FkezCpozJteq8Q2AqkIwaX+f746Ebj3dOMjtk4NcIXqJQ9OwAvasm25ugJOeHcMCSt5Bwl5nq8MRoitFms3zcjNds6KkLeXtQaRQv8z+7jWSmBRCCNGVPL4ApjsCQGquCxrgNBvSrOWMSTiiAc7s2j7POrAsC6uR0A31S+MbIXqNFrOTCfm5g60NZA01m/to0Q1Sk02INRJPDmMqDur1GtX8fKvD6Ur1Una5I3dfUgaTe40kJoUQQnQtpVGsPNvpiUnLOpwoDK3hjEk4nPjsgiXwuVIFd2URBYhKR24heo43bm/31aXubYBTW7L3b/6EfMYJsVb8Hhc1TwKA9Kw0wFkLqeWO3FECfunI3WskMSmEEKJrNYuVl1IdXqy8lAKjCqoG/sTaPlcz8Znv/DpKi3OTKJhobi/OQF+rwxFCrLPoYKMBTmaiOxvg6FX0nD17KzwgHbmFWEtKyC4NkV/o8MHuNpWbb7yvIenI3YskMSmEEKJr+Rp1BfVO78zdrPcYSILqWNvnanbmLi6AUV/b51pjzYNcJTQIcpArRM9JDI+iKApKvUgum2p1OKvOzE5TrulUHAEGEms8aCVEj3Mvd+aeanEk3amUso91neE1Xhkk2pIkJoUQQnSt8JHFyjtZcxl3M2m4ljxhcPrAMqHQ2Z1sS42O3M6I1CoSohc5XR4Mv93Qa2mq+xrgZOcOYFgWRXc/8YC71eEI0dX88cZgd7bDB7vb1HJH7r7hFkciWqHlicm//uu/ZnR0FI/Hw5VXXsljjz12wttnMhk+/OEPMzg4iNvtZseOHdxzzz3rFK0QQohO0pfcCI3ZMoVcutXhnLlmvcfQOiQmFeVwArTDG+DojYPc5smEEKL3OKKNBjjzYy2OZPXlZu3amUp4BFWVWeFCrKVIo1O0VZgH02hxNN3HyjU6cidGWhyJaIWWJibvvPNObrnlFm6//XaefPJJLrroIm644Qbm51fudFWr1XjLW97CwYMH+dd//Vdefvll7rjjDoaHJasuhBDiWC6PF9MTAyA128HND5Y7cq9DYhIO15ns4AY4pmmhNN63cFKaQgjRq7x99vZfWey+unCVRlMfrzS+EWLNxfsHMRQXul6nnOnsgdt2Uytmsap5QKFvQBKTvailicnPfe5z/M7v/A4f+MAHOPfcc/nCF76Az+fjy1/+8oq3//KXv0wqleKuu+7immuuYXR0lNe//vVcdNFF6xy5EEKITqE2ZhnmFjq0i6KhH15SvV6JyWZn7g5ugLOUzeGuZ1EVZXmWgxCi90QGRwEwMx3eBO3VTAOjUT85PDDa2liE6AEel0bd1+zM3X0DHa2Unm925I4Q8PlaHY5oAa1VT1yr1XjiiSe47bbblq9TVZXrrruOhx9+eMX7fPvb3+aqq67iwx/+MP/3//5fEokEv/7rv84f/dEf4XCs3AygWq1SrVaXf87lcgCYponZjd35sF+bZVld+/qEOBWyHYgmZ2SI+tzzlBcnOvP/oTCHYhqgebDcYTiN13DG20FgAMWyIDvVsZ1sl6btZZuqNwwuX2f+7cWqkX1C7+ob3Mw0oFbSFHJpfIFwq0NaFVZ2mnK1iq64GIoPntL/tmwHQpzddqAGB6A4RW5+nIFzrlyD6HpTprmqKTiAZVlYltXagHrEauwTVmt/0rLE5OLiIoZhkEwmj7o+mUzy0ksvrXifAwcO8KMf/Yjf+I3f4J577mHfvn385//8n6nX69x+++0r3uczn/kMn/jEJ465fmFhgUqlcvYvpA2Zpkk2m8WyLFS15WVEhWgJ2Q5Ek+EKY+g6lfmDxy0V0s60+RfwlSsYoQTFhYXTuu8Zbwd1B6FyBcqz5KbHQfOcZtStNzO2B7euY7pjHfl3F6tL9gm9raoF0Spp9r34JAOj57U6nFVRHX+Waq3OoqufTbU88/OFk95HtgMhzm47qLsiOHSd9PQ+ObZYRUtTe0HXqbsi8r6uo9XYJ+Tz+VWJpWWJyTNhmib9/f383d/9HQ6Hg927dzM1NcX/+l//67iJydtuu41bbrll+edcLsfIyAiJRIJQKLReoa8r0zRRFIVEIiEHHaJnyXYgltXO5dBzGmotRSIeR+m0/4dUFcXrwRrajr+//7TuejbbgRIdgEoGj8eA2Ok9bzvYV8vg0DSCg1vpP833TXQf2Sf0tkOJLTDzDGol0zWfB1N77c84Z98oQwPJk98B2Q6EgLPbDpY27aQwfh9aLd01nyXtYKKawdQ0+jZsk/d1Ha3GPsHjWZ3JCy1LTMbjcRwOB3Nzc0ddPzc3x8DAwIr3GRwcxOl0HrVse9euXczOzlKr1XC5XMfcx+1243a7j7leVdWu3iEritL1r1GIk5HtQADEBzdySFFRjCqFXJpwLNHqkE5PYdbuLB4agjP4Xz7j7SA0BNUsSmEW4ltP+3lbzcjO4ASC/RvlM0AAsk/oZZ74Jiozz1BZGu+av395sdH4Jr7ptF6TbAdCnPl2EB0cpQBYxUUUy0BxONcmwF7TqKUeTp7e55k4e2e7T1itv1fL/uoul4vdu3dz3333LV9nmib33XcfV1111Yr3ueaaa9i3b99R69hfeeUVBgcHV0xKCiGEEJrThdksVj7XgZ25m52xg0Pr+7yNpkGd2ACnrhs4inbHzKg0hRCi54UHNgNgpju0CdqrWRZ6ZgqAYL905BZivcT7+tFVN4ZhUFyabnU4XaFazGBWC0hH7t7W0nT0Lbfcwh133MFXv/pV9uzZw4c+9CGKxSIf+MAHAHjf+953VHOcD33oQ6RSKT760Y/yyiuvcPfdd/PpT3+aD3/4w616CUIIITpAszN3vtM6c9crUE7Z34fWqSN3UzMR2oGJyfnFeZxmGc3hwB9b54SuEKLtxIftWd9KeZFKudjiaFZBOU21XMBSVPoGJTEpxHpxOR0Yfrt0Qnquw44p21R6zu5wXndHpSN3D2tpjcn3vOc9LCws8Cd/8ifMzs5y8cUX8/3vf3+5Ic74+NHLLUZGRrj33nv52Mc+xoUXXsjw8DAf/ehH+aM/+qNWvQQhhBAdwB0bpjrzNJXUVKtDOT3NpKA7BC7/+j53MxGamwHLAkVZ3+c/C5lZ+yAXfwJFkxUVQvS6QCiK6Q6hVnMsTo2xYdv5rQ7prJQXDlLTTXLOfi6OBlodjhA9RQ0PQX6c4uJ4q0PpCtl5O8GrBFcu5yd6w1klJmu1GmNjY2zduhVNO7OH+shHPsJHPvKRFX93//33H3PdVVddxSOPPHJGzyWEEKI3BeIbqAJGpsOW3eTt5cgE13m2JEAgCShQL0I1B57w+sdwhponC1pkuMWRCCHahRoZgbkXyMx2fmIyPTsGgBEcwuN0nOTWQojV5IkOYUxCJd1hg91tqrJkv4/OiKxw6WVntJS7VCrxW7/1W/h8Ps477zzGx+0TgN///d/ns5/97KoGKIQQQpytSNJe6qYUZrGOqFPc9vKNROp6L+MGcDjB32gUlOus5dzV1CQA3pgkJoUQNnefvR9oNo3pZMUF+zU4Y7KMW4j1FojbdRCNbGcdG7WrWmPSgK9vQ4sjEa10RonJ2267jWeeeYb777//qPbg1113HXfeeeeqBSeEEEKshlhiCFQNzDqZpblWh3PqlmdMtmgUuUMb4JhZ+yA32L+xxZEIIdpFMGk3wNG7oAFOPWW/Bml8I8T6iw2OAmAVl7D0amuD6XSWtXysG0xIYrKXnVFi8q677uLzn/881157LcoRNafOO+889u/fv2rBCSGEEKtBdTgw/f0ApGY7aLZMroUzJqEjG+CUqjVclQUAogNy0i6EsDUb4KiFWeq1Dk4mVAvoxTRwOEEihFg/sWiMusOLYZrkF2Q599moljKYtSKgEB+QweRedkaJyYWFBfr7+4+5vlgsHpWoFEIIIdqFFraTbIXFDpktU81DrQAoEGhRQfDlBjidU5tzYWYS1TLQnG484WSrwxFCtIlQpA/L6QPLZHHmYKvDOWO19DiVukFRizIYj7Y6HCF6juZQMfz2cVmzo7Q4M6mZwx25/T5vi6MRrXRGicnLLruMu+++e/nnZjLyi1/8IlddddXqRCaEEEKsInfUTkxWO6Uzd7Ouoz8Oreos3Wy6k5+FDqnNmZm3Z8QqocGO6iQuhFhbiqpC2F4qmJ4Za3E0Zy49M4YFVP2DBNxn1cdUCHGGmo1aip0y2N2mcot2TXClVSuDRNs4o73Zpz/9aW688UZefPFFdF3nL//yL3nxxRf52c9+xk9+8pPVjlEIIYQ4a4HERsqA0SmNXJqNb4Itmi0J4IuD6gSzDqUlCCRaF8spKi9OogBO6cgthHgVd99GaouvUJo/2OpQzlh+7iAAzshIawMRood5Yhuoj0NVOnOfFenILZrOaMbktddeyzPPPIOu61xwwQX84Ac/oL+/n4cffpjdu3evdoxCCCHEWYsm7do1anEe0zBaHM0paCZQW9X4BkBVIdhYDp3vjOXcy90d41JEXQhxtEC/3QCnnu7c5Ze1RuMbX0LqsQnRKoHGMYbZKYPdbaqWsROTvpgMJve6054xWa/X+b3f+z0+/vGPc8cdd6xFTEIIIcSqi/QlweECo0ZqYar9i2w3G860csYk2InR7KSdKB28qLWxnIRlWViNepjhpDS+EUIcLTa0hRSg5mcwDQPV4Wh1SKdHr2Lk5gCIDG5pcTBC9K7owEbSgFlKY9XLKE6pj3jajujIHeqXGeC97rRnTDqdTr71rW+tRSxCCCHEmlFUFTNgz/7LtHux8iMO1gi1eHlLMzHaAZ25M7kCnloaVYFIf5snnoUQ6y6WGMJyuMHUWZrrvNpwemaKSl2nqvoZXKERqRBiffRFotS0AKZltf8xZZuqFDOYtRJ2R25JTPa6M1rK/c53vpO77rprlUMRQggh1lazM3dxoc1PSEspMKqgauBv8clnMzHaAYnJ1Nw4YKF6gmi+cKvDEUK0GbsBjr1kcGl6f4ujOX2Z2TFMC0reASI+Z6vDEaJnqaqCFbAHbjPzbX5M2abSs42O3J4YPq/MOO11Z9T8Zvv27Xzyk5/kpz/9Kbt378bv9x/1+//n//l/ViU4IYQQYjV5YiOUxh+l0u7Fypv1HANJu85jKzU7cxcXwKiDo31PhrPz9kGu0upZpkKItuWMjaCnDlDswAY4uUbjG0d0BEVRWhuMED1OCw9BZh/FRmdpcXpyjUkCSqtLFom2cEaJyS996UtEIhGeeOIJnnjiiaN+pyiKJCaFEEK0pWBimBIdUKy8uYy7mRRsJU8YnD6ol6AwB+H2bSpTWZrAAbhi7RujEKK1/IlRsvt+Qj3VecsvK0v2ibynT0pVCNFq3vgItUNQa/fB7jZVbnTkdklHbsEZJibHxsZWOw4hhBBizUUHRpkD1NIieq2K5nK3OqSVNRq4EGqDxKSi2AnS1H47YdrGiUk9M40DCMSlVpEQYmWxoa1kAbJTWKZpL+/uBKaJmbVP5CMDo62NRQhBKDHMIh0w2N2m6o3PM19f+x5XivVz1ntiy7KwLGs1YhFCCCHWVCgcw9K8YJkszbfx0pvljtxtMorcXBrdTJi2IcO0UAv2+xaVjtxCiOPoS46AqqEYVVIL7fuZ9mpWYZZKtYquuEgOyIm8EK0WaxxrWJUsRqXQ4mg6jGVBfg6AcFIGk8VZJCb/4R/+gQsuuACv14vX6+XCCy/ka1/72mrGJoQQQqwqRVXtuo1Atl2LlRu6vWQaDnfEbrXmkvI2boCzlFrCaZRwqCqhhJy0CyFW5tA0zMZnWmr6QIujOXWZ2YMYpkXB3U886Gl1OEL0vEgoSM0ZwbSQztynqVI43JG7r18Sk+IME5Of+9zn+NCHPsTb3vY2vvnNb/LNb36Tt771rXzwgx/kz//8z1c7RiGEEGLVaBG7I2vbFisvzoNlguYBb7TV0diaCdI2njGZmjkIgOLrQ3HKSbsQ4vicUftEOD9/qMWRnLrsrF1KSwlvQFWl8Y0QraYoCgTbfLC7TaVm7c/eurcPr1eO2cQZ1pj8q7/6K/72b/+W973vfcvX3XzzzZx33nn8j//xP/jYxz62agEKIYQQq8nTN0zxINTSbZqYXF7GPWjXd2wHzRmTlQzUy+D0tjSclRQa3R0dUkRdCHESvsQo+YM/o7bUOYnJyqIdqzS+EaJ9aJFhSL1McalNjynbVF46cotXOaMZkzMzM1x99dXHXH/11VczM9O+y7yEEEKIcMKeKdO2xcqbcYXaKMHm8oEnYn/fpsu5qyn7pMAtHbmFECcRGdwCgJWdxDLNFkdzCiwLvTGYFhrY3OJghBBNzcYttYx05j4d5ZS9Akc6coumM0pMbtu2jW9+85vHXH/nnXeyffv2sw5KCCGEWCvRAbtYuVpOUa2UWhzNCpZnTLbZKPJyA5z2TEwaOfukIJiQ2URCiBNLDI2CoqLWi+QyS60O56SsUopauYClqPQNyGecEO0i3KyPmJ22G7qIU1LPSEducbQzWsr9iU98gve85z088MADXHPNNQD89Kc/5b777lsxYSmEEEK0i0AoiuX0o9SLpOYmGNy0s9UhHa1Zx7FdOnI3BQdg/sW2nDFZqeloxQUAYgPSkVsIcWJOlxvTn0QtzLA4tZ9wLNHqkE6oMH+IumlRcCUYiAZaHY4QoiE2MMIcCka1SL2cxemLtDqk9mdZWI0mj+F+SUwK2xnNmPzFX/xFHn30UeLxOHfddRd33XUX8Xicxx57jHe9612rHaMQQgixukJ2zcRsu3VRrFegnLK/b8TYNpqJ0jZMTC7NT+OwamiaE1+0zd43IURbciw3wDnY2kBOQabR+MYMbsDpOKPTNyHEGgj6fFRdUSwgPdtmx5RtqpxPY9VKWKj0JWUGuLCd0YxJgN27d/OP//iPqxmLEEIIsS60yBDG0j5K7VasvJn0c4fA5W9tLK/WTJTmZuzlSu3SmAdINxPMgQFQ5aRdCHFyvvhGihOPUV1s/wY4xQU7RlffSIsjEUIcSVEU1NAALKbIzk/Qv+XCVofU9lKNYzbdG8Prcbc4GtEuzujo/Z577uHee+895vp7772X733ve2cdlBBCCLGWfI2Tu1pmusWRvEp+1v4abMNZf4EkoEC9CJVsq6M5SnHRPsjVpIi6EOIUhRsNcMxMmw1QrUBP259xwX4pVSFEu3FGhwHab7C7TR3uyN2Gx7qiZc4oMXnrrbdiGMYx11uWxa233nrWQQkhhBBrqVms3MrNtjiSV8k3EqXttowbwOEEf6MOW7693rda2i6i7o1LrSIhxKlJDNuJSbWaoZBLtziaE6gV0Yt2fLFB6cgtRLvxxuxjDz3bZoPdbaqcshO4bhlMFkc4o8Tk3r17Offcc4+5/pxzzmHfvn1nHZQQQgixlmKNmjZqNUO5mG9xNEdYnjHZpgdrzYRpvs0OvhsNg0Iym0gIcYo8Xj+mLw7A0tSBFkdzfOXFQ1R1k6IWYTAebXU4QohXWe7MnZPO3KdCz9hli3zx4RZHItrJGSUmw+EwBw4cuwPft28ffn+b1cQSQgghXsXrD2K6I8DhWjdtIdfGMybhiAY47TNjMl8s4aykUIDYwGirwxFCdBBHxE4oZOcOtjaQE0hN241v9MAgHqejxdEIIV4tPjCChYpeq1AtpFodTnuzrOVjyHBCGt+Iw84oMfmOd7yDP/iDP2D//v3L1+3bt4//8l/+CzfffPOqBSeEEEKsFSU0AECuXRKT1TzUCoBiN3FpR8sNcNpnxuTS7AQKJg63D5c/0upwhBAdxBO3Z1lX2rgBTnHhIADOqJzEC9GO/F4PdU8fACnpzH1C5Xwas162O3IPSPkdcdgZJSb/9E//FL/fzznnnMPmzZvZvHkz55xzDn19ffzZn/3ZascohBBCrDpXo7ZNMdUmxcpzjY7c/jhortbGcjxHzpg0zdbG0pCdb5wEhIbaqlO4EKL9hQfsmo1GZqLFkRxfbcmOzd8/2tpAhBDH1xi4zS9IYvJEUrP2IJDhjeFxS0ducZh2JncKh8P87Gc/44c//CHPPPMMXq+Xiy66iNe+9rWrHZ8QQgixJnx9G8juBb1dOnM36za2c5dCXx+oTjDrUFqCQKLVEVFanEAFXFEZeRdCnJ748BZmAbW0SKVcxONts5JUeg0jPwdAdEAa3wjRrtzRIaz5ZyktTbU6lLaWawwmS0du8WqnNWPy4Ycf5rvf/S4AiqJw/fXX09/fz5/92Z/xi7/4i/zu7/4u1Wp1TQIVQgghVlO40QBneaZiqzXjaOeDNVWFYGOZeZs0wNEz9kmAPz7S4kiEEJ3GH4ws1xteaMMGONX0JNW6TlX1MdDf+oEgIcTKmscgzWMSsbJy2n5/XFFpfCOOdlqJyU9+8pO88MILyz8/99xz/M7v/A5vectbuPXWW/nOd77DZz7zmVUPUgghhFhtseQICqDUixRy6VaHA/lGYrJdG980NROnbZDQtSwLpfG+LSeahRDiNKgRe7Z1dqb9EpOZmTEsoOIbJOht0xIfQojDjVwKs9KZ+wSWO3L3SWJSHO20EpNPP/00b37zm5d//sY3vsEVV1zBHXfcwS233ML/+T//h29+85urHqQQQgix2tweH4Y3BhyuedMyR3QpbOsZk3A4cZpvfWIylcng1POoikK0XxKTQojT5240wCm1YQOcXKNbuBaVGeFCtLP4wDCm4sCo1yhnF1odTnuyLJRCoyO3HLOJVzmtxGQ6nSaZTC7//JOf/IQbb7xx+efLL7+ciYn2LR4thBBCHEkN2c1ccgst3neVUmBUQdXA39/aWE4m2EaJyUZCWfFGUd2+FkcjhOhEoWSjAU66/c5hqim7HpsvLifxQrQzj8uJ7rXLLbR8sLtNlXJLmPWK3ZE7KTMmxdFOKzGZTCYZGxsDoFar8eSTT/Ka17xm+ff5fB6n07m6EQohhBBrpFnjptLqYuXNeo2BpF3HsZ01E5PFBTDqLQ0l3yiiroaHWhqHEKJz9Q1vAUAtzlOvtVGtfNPEzNr7hrA0vhGi7anSmfuEUrP2+2J4+6QjtzjGaZ39vO1tb+PWW2/lwQcf5LbbbsPn8x3VifvZZ59l69atqx6kEEIIsRb8cbu2WMuLlXdC45smTxicPrBMKMy1NJRKahIAd0w6cgshzkwo3Ifl9INlsjB9sNXhLDPyc1SrVQzFRXJQlnIL0e6ag93lVHs0B2w3+cbqJKXda6mLljitxOSnPvUpNE3j9a9/PXfccQd33HEHLtfhQsxf/vKXuf7661c9SCGEEGIthPsbJ3uFWSzTbF0gndL4BkBRjljOPdvSUIyMffAfTMhJuxDizCiqChH7MyTTRg1w0jMHMC2LoqefqF8a3wjR7gKNwW6j1YPdbarZkdsdkVUu4linlZiMx+M88MADpNNp0uk073rXu476/b/8y79w++23n3YQf/3Xf83o6Cgej4crr7ySxx577JTu941vfANFUXjnO9952s8phBBC9CVHQFFR9Aq5bKp1gTQTk8EOOVhr1OYk17pZAbpu4Cja71tkYLRlcQghOp8rZtdwLC0cbG0gR8jO2eWzHOENKIrS4miEECcTSdqfI1ZhDss0WhxN+9Ebg8m+uNSXFMc6o0JW4XAYh8NxzPWxWOyoGZSn4s477+SWW27h9ttv58knn+Siiy7ihhtuYH5+/oT3O3jwIP/1v/7Xo5aSCyGEEKdDc7owfXEA0rMHWxOEoR9eEh0caE0Mp6sNGuAsLMziMGs4VAfBvg6YaSqEaFvB5CgAeqp9GuBUFu16bO7EphZHIoQ4FX2JIUxFwzR0iunWrihpO5YFeftYN5SQZl7iWFqrA/jc5z7H7/zO7/CBD3wAgC984QvcfffdfPnLX+bWW29d8T6GYfAbv/EbfOITn+DBBx8kk8kc9/Gr1SrV6uFC1rlcDgDTNDFbuWxvDZmmiWVZXfv6hDgVsh2IU6UGB6A4T25uHHPnpesfQH4WxTRA82C5w7CK/7Nrth0EkiiWBdmpli2BzzQTyYF+LMXR2qX4ou3JPkGcSHRglBRAfpp6rYZDa/EpkmVhpO0ausHExlX7v5XtQIi12w40h4LuS+IqTpGaOYQvKoOmTcXsIpZewUIh1j8on0FtYjW2hdX6W7Z0r1ur1XjiiSe47bbblq9TVZXrrruOhx9++Lj3++QnP0l/fz+/9Vu/xYMPPnjC5/jMZz7DJz7xiWOuX1hYoFKpnHnwbcw0TbLZLJZlobZ7d1ch1ohsB+JU6e4oiq6Tnt5/0tn6a0GbfxFfuYIRSlBcWFjVx16z7aDuIFSuQHmW3PQ4aJ7Ve+xTNHfoZVy6juGKteTvJjqL7BPEiVimg7rlQNWr7NvzNNFki2f0lNOUChkMU0FxBVbtM062AyHWdjuouaI4soeYPbgHV3zLqj52J1s4+DyGrlP1xMlmsq0ORzSsxraQz+dXJZaWJiYXFxcxDINkMnnU9clkkpdeemnF+zz00EN86Utf4umnnz6l57jtttu45ZZbln/O5XKMjIyQSCQIhUJnHHs7M00TRVFIJBJy0CF6lmwH4lTlN+4kdegnKLU0/f396x9Aqori9WANbce/ys+/ltuBEh2ASgaPx4DY+r9v+6ppHJpGeMO21vzdREeRfYI4mYOxUdT0fqhk6O+/rKWxZMYmUVQHFU8/V27ZhKquTo1J2Q6EWNvtYHJwC0b6ebRaTo5NjrC0N49D03D3bZT3pY2sxrbg8azO5ISWL+U+Hfl8nve+973ccccdxOPxU7qP2+3G7XYfc72qql29Q1YUpetfoxAnI9uBOBXRwU2kALUwi0KjQ+t6KsyCoqCEhmANnnvNtoPwMFSzKIVZiG9d3cc+BVbOrm8Z7N8k27g4JbJPECfi6htBT++ntDje8v+R7Nwh+5vwMJp2bF3/syHbgRBrtx0EExvJAGZuWraxI1TTduMbd3RI3pc2c7bbwmr9PVuamIzH4zgcDubm5o66fm5ujoGBYxsA7N+/n4MHD3LTTTctX9dc065pGi+//DJbt67/yZEQQojOFUsMs1/VwKyTWZojmljnmkDNztad0pG7KTgA8y+2pAFOuVLDWbGXvcekI7cQYhX4+0fJ7oN6arzVoSx3B3f3SZMIITpJdHATGcAqLGAZdRSHs9UhtQU9Yx8r+uIjLY5EtKuWpqtdLhe7d+/mvvvuW77ONE3uu+8+rrrqqmNuf8455/Dcc8/x9NNPL19uvvlm3vjGN/L0008zMiL/6EIIIU6P6nBg+u1lJem5dT4hrVegnLK/D3VYkfRmIrWZWF1Hi7MTKJaJw+nBGz61FRRCCHEifUP25AYl17qmXk3LjW/6pSO3EJ0kFktgqC5M0yC/uP4Dt23JsqBgT0QL90u+Rqys5Uu5b7nlFt7//vdz2WWXccUVV/AXf/EXFIvF5S7d73vf+xgeHuYzn/kMHo+H888//6j7RyIRgGOuF0IIIU6VIzSIlZ8mvzAOXLl+T9ycbegOgcu/fs+7GpqJ1PysfdCprE4NtFORmW8scwwOruvzCiG6V19yhAOqBkaNpfkp4gOtOYG2qgX04pId05A0zxCik2iaA8M/gCM/TnruEKFWN9JqA4Xljtwqff3DrQ5HtKmWJybf8573sLCwwJ/8yZ8wOzvLxRdfzPe///3lhjjj462v8yKEEKK7uWPDVKaeoJaaWt8nzs/aX4MdNlsSIJAERYV6ESpZ8EbW7alLixMAOKNygCuEWB2qw4EZHELNjpOaPtCyxGRhYZy6YVHWwiT7oi2JQQhx5rTIEOTHKTSOVXpdetYeTDZ8cdwuV4ujEe2q5YlJgI985CN85CMfWfF3999//wnv+5WvfGX1AxJCCNFTgokRKoCeW+dlN/nGMuhOW8YN4HCCP2Evz8nPrmtisp6Zwgn44hvW7TmFEN3PFRtBz45TXDgIvL4lMaRnDgBgBIdxOmRyhhCdxhMdojYBlfUe7G5T+QW7NIXaice6Yt3I3k4IIUTPiybtOl5qcR7TMNbviZdnTHZY45umYKNRXX796kxalgWNBHI4KfXXhBCrx5sYBaC61LoGOMUFe3aRMyZLQIXoRIFGgxdzvQe721QlbSdoXZEOPdYV60ISk0IIIXpepC8JqhNMndTCOo5w5zp4xiQcTqg2E6zrIJcv4KxlUICYJCaFEKsoOrjZ/iY72bIGOLWUvfwz0EiSCiE6S3Rg1P6muIil11oaSzvQM/axrnTkFiciiUkhhBA9T1FVzMbsv8x6deau5qFWABQIDKzPc662ZkJ1HTtzp2YPAqB4I2je4Lo9rxCi+yWGNoOiotRL5NIL6x+AUcfM2d1ro0Oj6//8QoizFovG0B1eTMsiMz/Z6nBayjLN5Y7ckaQkJsXxSWJSCCGEALSwPfuvsLhOB5HNJT7+OGgdWgz8yBmT6zS7KDtvzyZSw7IkSAixujSnC7MxULQ4tX/dn7+yNElN16mqPgYSyXV/fiHE2VMdKlZgnQe721Qhu4ClV7EUlb6ENCwUxyeJSSGEEALwxOwDpmpqnRKTzbqMndiRu8nX11gCX4fS0ro8ZXnJTky6pSO3EGINaFF7Vk9+/tC6P/dSo/FNPTCI190WPUqFEGdgebB7qbc7c6dn7ddveBO4XM4WRyPamSQmhRBCCOzO3ADWehUrbz5PJycmVXXdG+AYUqtICLGGvAm7dm11af0Tk4W5gwBoEfl8E6KTefrswdNaj3fmzi82Vrl0ai11sW4kMSmEEEJwuDO3UlpEr69DsfJ8IzHZ6QdrzcTqOiR0TcNEKdjPE01Kx1ohxOqLDm4BwMys/0ynZjdwf0IaewnRyQIJ+xjFzK1fc8B2VG0kZt1RKb8jTkwSk0IIIQQQivRhaR6wTJbm1viE1LIOd7Lu5BmTcDixml/7xORSagHNKONQVSL9MqNICLH64kObQVFQqzny2dT6PbFpYmbtk/hwszu4EKIj9TUHT8tLGLVKa4NpoXrWPjb09W1ocSSi3UliUgghhMDuzN3sjt1ssLJmSikwqqBq4O9f2+daa8H1S0ymZ+2llZYvjtKpDYOEEG3N7fFheeMALE0fWLfnrWVnqdWqGIqT/gE5iReik0UiEXQtgGlBukcb4FimCflmR25Z5SJOTBKTQgghRIMWsZeaFNe6M3ezHmMgaddp7GTNxGRxAYz6mj5VYcFOGDvC0vhGCLF21EYDnOzs2Lo9Z3pmDAuoeJOEvDLwIkQnUxQFq1GDO9ujiclCdgGMRkfuflnKLU6sw8+GhBBCiNXjaSw1qaXXuFh5NzS+afKEwekDy4TC3Jo+VaXRMd0jS4KEEGvIG7drPFYW168BTnbOToKqkREURVm35xX/f/buO76pcv8D+Cc7TZPuDYWyh+wpIuMKCuhV3CxlKCgKKtYFKku9gnpFBFEcF3CAKHpBvSCCaAH5IcoSZY+yu2eaNh05z++PNMemTXfapO3n/Xr1BTnzOSc563ue5/kS1Q11gP0lqiWtjl92eylHKxfJEAqNhhm5qWIMTBIRERXzkzNz13GG6caS+AYAFIoSzbnrtpN3R/9rjk7liYjqgl9E/SfAsRYnvvHh+Y2oUTAEFWfmzmyambnNKfaArKIxvISnOsfAJBERUbGgiOLM3NYM5Ftz625FjsCkqZE0bfEr3o46DOjmFxZCnZsMAAiK4IM7EdWd0Gb25DPKvHTkWcx1v0IhIGXYH+L9w5j4hqgx8CtO0iey6r4Pbm9kLc7IrQ1i9ztUOQYmiYiIihn9AiE0voAQSK+rzNy2or+bPBf3P9Tg1UMCnLSkK1AIG5RqLYxBfPtORHXHYPSHpA8EAKTWQwIcW24mCq05EFAiJKplna+PiOpeYHHCF2HNQqE1x8OlqX9FxQFZI7vfoSpgYJKIiKik4ubVWXUVmLQk2/tjVOsBn8C6WUd9czRJr8Mak5mOzuNNEfbm40REdUgZYK/tlJlwvs7XlZFwDpIQyNOFINjPt87XR0R1z89kQpHGHwJNLzO3kCQocpiRm6qOgUkiIqISHJm5c9PrqLNyc4nEN40lwGYsrvlpzQQK6qYJvCXVHih2dCZPRFSX9CH2wKQ19XydryuzOPu3wr8ZE98QNRIKhQLws98fZTaxwKQ5IxnCVgChUCGIGbmpChiYJCIiKsEQVMeZuR0Zuf0a0Y2a1gDoA+z/z6mbBDiO78PAJkFEVA/8wu19PRZl1H0CnNxUe9BCF8yaRUSNiab4ZWpuWtNKgJOZVCIjt1rt4dJQQ8DAJBERUQn+jj6Bsusow3TJGpONiZwAp276mXRkSvcL44M7EdW94GZtAADK3GQU5FvrdF224uCnKZyJb4gaE5/ixC+FTSwztznVvr1Kv0Z2r0t1hoFJIiKiEoKKA5PK/ExYc+sgG6ujH8bGFpiswwQ4FosFGms6ACAokokhiKju+fkHQ2hNgBBIuRJfZ+sRBRbYLGkAgOComDpbDxHVP3/Hy9Q6emnrreSM3IHsfoeqhoFJIiKiEnx8TZB0fgCAtEQ39wlUaAXy7AE2NLa3yKa6S4CTmngRgIBSZ4TOt5EkDCIi76ZQAP72riMyE+ouM3dm4nnYJAGr2h9hQUF1th4iqn/BEdEAFJDyc5BvyfR0cerN3xm5GZikqmFgkoiIqBRFcbPkrGQ39y3mqE2o8wO0jSzzqiPQak4EhHDrorOT7X0VKRpTv5xE5PUcfT7mpl6os3U4Et8I/+ZQKZn4hqgx8fX1RZEuAACQ7u6X3V5KSBLAjNxUTQxMEhERlaItzsydl+buwGRxv5WNMcBmDAcUSqDQAliz3LrovDR7hnQNmwQRUT0yhccAAIoy6i6gkFP84kUbFF1n6yAiDyq+58tOqftEWt7AnJ4MMCM3VRMDk0RERKU4Mj8XZrq5TyCzo3/JCPcu1xuoNIBvqP3/ZvcmDioszsjtG8IHdyKqP8FRxQlwzAkoKiyok3UUpduDnr6h7D+XqDHSBtqDc7mpTSMBTnrxyxabbxjUzMhNVcTAJBERUSly5md395foCNiZGukbZEfA1ey+/SaEgKK4Cbx/OB/ciaj+BASHQ6h9ACEV93XrZrZCiOImj0GRrd2/fCLyOEOQ42V30whM5qTYW7mo/BrhS3iqMwxMEhERlWLvrBxQFFqQk53hvgU7Ap2NLfGNgyPg6sYak5mZGVAVWaBQKOSM6URE9UGhVAL+9i4kMq+6PwGOOfUSCotsKFD5IDws3O3LJyLPk/tZzHF/H9zeyJGRW8fud6gaGJgkIiIqRac3QPKxZ0fNSHJTLZl8M1CQA0ABGBvpW2Q/92fmTk84b/+PIRgqrd5tyyUiqgpNoD2okFMHCXAyioOdNmMUtBqV25dPRJ4XHN4cAkqIglzkmd34sttL2bLtrVx8Q5p7uCTUkDAwSURE5IKyOMiWleymwGTxjRp8QwC11j3L9DYla0xKklsWaU6x73+VfyNt/k5EXs0YZu9CoijN/U25zcV9sWkC2X8uUWOl1+thK37ZnZ7o/hcc3kRIEhTMyE01wMAkERGRC9pA+5tea5qb+gSSE9800mbcAGAIBpQaQCoEctPcskhrcUZuLZsEEZEHOBLgKLKvQLLZ3LrsguJgp09ojFuXS0TeReHIzO2ul91eypyeBGErtGfkDmnE97vkdgxMEhERueBoglKU5aZmyY4ak405MKlUuj0Bji3LHhg2hbJGERHVv6Dw5vILl/QUNyavkCSIbPvyAiNbuW+5ROR1dAH2wGReRuNOgJNe3P2RxIzcVE0MTBIREbngH1YcCDMnQrijWbK5kSe+cSiuFSAHYmuhqMgGhSUZABAYwYzcRFT/lCoVJD97je10NybAsWYlorAgHzaFBuGR7IuNqDEzFL9cLWrkgcmclEsA/u4OiaiqGJgkIiJyISisOaBQQlGUh+ys9NotTAjAbO9zp1HXmARK1JisfWAyLSUBKqkACqUafiFsyk1EnqEJsgcVcpLPu22ZaVfsQc4CQwQMukba7zARASjxsjsnqVFn5rZm2F/CMyM3VRcDk0RERC5otDpIhhAAQGbi+dotLDcdsOUDSjXgG1b7wnkzOQFO7QOTmUnFncSbIqBQMmMtEXmGsbgPyAI3JsDJLj6/qQJZW5KosQsJaw6hUEIU5SMnM8XTxakzju6PjCHsfoeqh4FJIiKicjiaomTXtl8xRzNuY7i9H8bGzFFj0pIC2AprtaicVHuTIDUzchORBwVEtbb/J+uye7r2AGBNswcmDSHMXEvU2Gm1GtgM9hfTjTUzt5BsUBZ3vxMQzhcuVD2N/OmIiIio5hxNUazpl2q3oKaQ+MZB7w9ofAEh2Zss1UJBuj0jtz6Yb96JyHNCIlrIXXtkpSfXfoFCQMqyn9/8I5j4hqgpcLzsdvTD2NhkpSbaM3Ir1QgK5Qtlqh4GJomIiMphdHRWXtvM3I5mzU2hM3CF4u9ak7VMgCMV73dm5CYiT1JrtJCM9vNa6pWztV5eYW4mbHlmCCgRyozcRE2C42V3XnrjTICTmWx/2SIZwqBSsfsdqh6vCEyuWLECMTEx0Ov16N+/P3777bdyp/3www8xaNAgBAYGIjAwEMOHD69weiIiopoKKA6IKXOSatd8zxGYNDWRN8h+te9n0mq1QpWXBgAIjopxQ6GIiGpOHWhvcm1Oiq/1stKunIUAkK8PgZ/Rp9bLIyLv5xtib95sq+3Lbi9lLu5+R8Xud6gGPB6Y/OKLLxAbG4v58+fj4MGD6N69O0aMGIHkZNfNJOLi4jBu3Dj8/PPP2Lt3L6Kjo3HTTTfhypXG+eaBiIg8JzCsmT1hja0AmWk1bJZsK/q7SXNTqDEJ/N1kvRaBybTES1BAgkJrgMEU5KaCERHVjKE4AU6+GxLgZBUnvlH6N4dCoaj18ojI+wVGFPcnm5MEIdk8W5g6YC3ufkcX2ETudcmtPB6YXLJkCaZNm4YpU6agc+fOWLlyJQwGA1atWuVy+rVr1+LRRx9Fjx490LFjR3z00UeQJAk7duyo55ITEVFjp1KrIRVn0c5IquHDqCXZ3t+i2gfQB7ivcN7MEYDNrnmtgMxk+/5WmCLtzcOJiDwoIPLvBDi1lZdyHgCgZ+IboiYjKCQSQqGGsBXCXNOX3V7Mlp0IgBm5qWbUnlx5QUEBDhw4gDlz5sjDlEolhg8fjr1791ZpGbm5uSgsLERQkOvaFPn5+cjPz5c/Z2dnAwAkSYLkpqx63kaSJAghGu32EVUFjwNyF6VfOGC+CnPKRUhS3+ovIOsqFEJAGMMBIex/9cRjx4FvGBRCAHkZEPk5gMZQ7UVYUuw1ilT+UTyOqdZ4TaDaCoqIxmUooCgwIzMjBX7+wTVeVlGGvcmjMaxlvf4meRwQee44UCqVKPINgybnKtISz8MYHFGv669LQrJBUdw6yC+0Gc8xDYQ7jgV3fdceDUympqbCZrMhPDzcaXh4eDhOnDhRpWU899xziIqKwvDhw12OX7RoERYuXFhmeEpKCqxWa/UL3QBIkoSsrCwIIaBUerxSLJFH8DggdynSBEJRVITMq2fL7WakIrrLJ6DLs6IgwBfWGsxfG548DoySFsr8bFjOH4PNv/q1gnKS4qEvKoJSF1Cj/U5UEq8J5A5WTQA0eSmIP3YYkW261mgZoiAXhdnJEEJAaEz1en7jcUDk2eOgUBsIZdFFJJ4/CZ/Q1vW67rpkTk+CrcAKSaFGoaTifVsD4Y5jwWw2u6UsHg1M1tbixYuxfv16xMXFQa/Xu5xmzpw5iI2NlT9nZ2cjOjoaoaGh8PPzq6+i1itJkqBQKBAaGsqbDmqyeByQu+TEdEDa+Z+gyE9HWFhY9RdwwQKFjx765h3hV5P5a8Gjx0FEWyiSj0GvzQequd1CCOjy06BSq9GszTU12+9EJfCaQO5wIaw1cCUDCmsNrwcAUi8chVKlQr7GHx3ata3XPiZ5HBB59ji4GtUGhelHoSrIaFT3Npbkc1Cp1RDGSERGso/JhsIdx0J5cbjq8mhgMiQkBCqVCklJzn0sJCUlISKi4qrN//73v7F48WL8+OOP6NatW7nT6XQ66HS6MsOVSmWjviArFIpGv41EleFxQO4QHNkKaQCUuSmAEFCqVNVbgDkRUCig8IsCPPBb9Nhx4BcFpBy3N+2p5rqzzVlQF5qhABAaFcNjmNyC1wSqLUNoS+ReOYD8tIs1/h05Et/AvzlU1b2euAGPAyLPHQem0BZIByBlJzaqYzA3zZ6IWO3frFFtV1NQ22PBXd+3R381Wq0WvXv3dkpc40hkM2DAgHLne/311/Hyyy9j69at6NOnT30UlYiImqiA4HBAqQGkIqSnVDOZS6EVyEu3/7+pZOR2MNU8AU5Gwnn7f3wCodH7uq9MRES14B/RCgAgZV6q8TJyk88DAHRBTBBB1NQEhhd3bWNJhrAVebYwbmTNKM7IHRTl4ZJQQ+XxptyxsbGYNGkS+vTpg379+mHp0qWwWCyYMmUKAGDixIlo1qwZFi1aBAB47bXXMG/ePKxbtw4xMTFITCzO/mQ0wmg0uq1cNpsNhYWFbltefZIkCYWFhbBarQ32jYVGo/HIW2QiotIUSiWEMQKK7EvITLqAkIhqPEyaE+z/6vwAbRMLsDkCseZEe8KfajRXzE62P/Qr/HmDS0TeI7RZGyQAUFozkGcxw8fXVO1lFGbaH+BN4S3dXDoi8nZBweE4rdRCKRUgI+UqgiKq3we3N5KKM3L7BvOFC9WMxwOTY8aMQUpKCubNm4fExET06NEDW7dulRPiXLzo3FTivffeQ0FBAe6++26n5cyfPx8LFiyodXmEEEhMTERmZmatl+UpjsxKZrO5XvutcbeAgABEREQ06G0gosZBFRAFKfsSclIvV29Gs/1GDX5NMMBmDAcUSqDQAlizAJ+AKs+am1b85j2wWR0Vjoio+nx8TZB8gqDMS0fy5bNo2aFHteYXtkKg+AE+MLJNHZSQiLyZUmV/2Y3si8hMutAoApP2jNzJEAACwxmYpJrxeGASAGbOnImZM2e6HBcXF+f0+fz583VaFkdQMiwsDAaDoUEGxYQQKCoqglqtbrDlz83NlbN5sQNdIvI0fWAUci8C+elXqjejubgZs6nifpMbJZUG8A0FcpLsAdpqBCZtmVegAuAb0vBv2ImocVEGRAN56chOPAdUMzCZlXQRNsmGIpUPQkMaT+ILIqo6lX8kkH0ROWnVfNntpTJTEyCkIgilGkEhfG6nmvGKwKS3sNlsclAyODjY08WpsYYemAQAHx8fAEBycjLCwsLYrJuIPMoU1gK5AKTshOrN6KgxaWqCNSYBez+TOUn2AG1YxyrNItkkKHLs+zmATR2JyMvog1vAmvAH8lIvVnve9IR4AIBkioJazXtboqZIH9wc1kv7kJ9WzZfdXiojyX4ulHzDoVQ1zG7kyPP4yynB0aekwWDwcEkI+Pt7aKh9fRJR4xFYHCBT5qagqLCg6jM6Er80tcQ3DqYS/UxWUUZ6MpS2fCiUSgSGsSk3EXkXv+IEOLYaJMDJKU58ow5kbXCipsoYYm/uXO2X3V7K0c2Rqqne65JbMDDpQkOtZdjY8HsgIm/hFxAModIBQkJ6chXfcFuzgYIcAArA2ASbcgN/B2SrkZk7PfECAED4hkGp1tRFqYiIaiykmb1vSGVuCvKtudWatyDdHsz0DWNtcKKmKrg4M7ciNwW26rzs9lKObo70Qc09XBJqyBiYJCIiqoRCqZRr/2UmVbH5nqOWoG8IoNbWUcm8nKMJuzkRkKQqzZKTYt+/KmbkJiIvZPIPgtCaACGQejW+6jNKEpBtf4APimxVR6UjIm/nHxgMSe0DIQQykht+P5M2R0buELZyoZpjYJKIiKgK1AH2QJkltYrN9+TEN024aYshGFBqAKkQyE2r0iz56fabdH0QMzsSkXdSBNjPTxkJ56o8T05GAmyF+ZAUaoRG8vxG1FQplMWZuVGNl91eSrLZoLDYE9YGhrOLCqo5BiaJiIiqQB9kfxNckFHFptyOvoOacmBSqfw7I7m5as25pSz7dKYwPrgTkXfSFr84yUupelAhrbh2ZZFvJHQadlNB1JSpi1uFWBp4Zu6M1KuAVASh1CAwuIl2W0RuwcBkIzF58mTcfvvtni4GEVGjZQq1vwmucmfl5iae+MbBr7hJdhX2W2FhIZS5xW/eI2LqsFBERDVnCrc3xS7KqHpgMjvJHphUB7IfNqKmzqe6L7u9VFaSvRWRYEZuqiW1pwvQWP11JQs/HE3ExfRctAgyYMQ1EejSzN/TxSIiohoKjmyJRABKazoK8q3Q6vTlTywEYE6y/78p15gEqlVjMi3pMhRCAtR6mAJC67hgREQ1E9KsDdIAKHMSUVRYALWm8n6E84trRvmEMvENUVPnF94Cufi7lUhDlVPcvZHKv4nf61KtMaxdCSEE8ots1fo7dDEDb247iT1nU5GZW4A9Z1Px5raTOHQxo1rLEUK4ZRv++usvjBo1CkajEeHh4bj//vuRmpoqjzebzZgwYQJ8fX0RGRmJt956C0OHDsWsWbPkaT799FP06dMHJpMJERERGD9+PJKTk53Wc/ToUfzzn/+En58fTCYTBg0ahLNnz2LXrl3QaDRITEx0mn7WrFkYNGiQW7aRiKiuGf0CITS+gBBIK84cXa7cdMCWDyjVgG9Y/RTQW5VMgFOJzCT7flWYIuwJh4iIvJB/UBiE2gcQElITKrkeAPaXVVn2B/iACCa+IWrqAoq7q1HkpaMwP8/Dpam5/Ax7YFUXxMQ3VDusMVmJApuEBd8eq9Y8Ry5nIinbCj+9Blm5RRBC4GJaLl7c9Be6NQ+o8nIW3NYZOrWqmiV2lpmZiRtuuAFTp07FW2+9hby8PDz33HO499578dNPPwEAYmNjsWfPHnz77bcIDw/HvHnzcPDgQfTo0UNeTmFhIV5++WV06NABycnJiI2NxeTJk7FlyxYAwJUrVzB48GAMHToUP/30E/z8/LBnzx4UFRVh8ODBaN26NT799FM888wz8vLWrl2L119/vVbbR0RUr0wRQPpZZCVfQmTLDuVP56gdaIyw97PYlDlqTFpSAFshoCq/bzVLiv3BXR3AG1wi8l4KpRLwbw6knUZGwjlEtGhX4fTWnAzYrGYACoRGxdRLGYnIe/n5B0LS+EJZaEFG0kWEtajgntKL2bISoABgDGEXFVQ7DEzWgZz8ImhUSigUCgCAQqGARqVETn5RvZflnXfeQc+ePfHqq6/Kw1atWoXo6GicOnUKkZGR+Pjjj7Fu3ToMGzYMALB69WpERUU5LeeBBx6Q/9+6dWssW7YMffv2RU5ODoxGI1asWAF/f3+sX78emuIOvdu3by/P8+CDD2L16tVyYPK7776D1WrFvffeW2fbTkTkburAZrCln0VuZZ2Vy4lv2BE49P6AxhcotAA5SfaH+XIUZF6GEoBPMG9wici7aYNboDDtNCzJ5yudNrU48U2hTyh8DYY6LhkReTuFQmHv6if9DDKTLjXIwKRks0GRmwLg7xqgRDXFwGQltColFtzWuVrzvP3jafwan4a2Ib5QKBQQQuBMigUD2gTj8WEVv1Etve7a+uOPP/Dzzz/DaDSWGXf27Fnk5eWhsLAQ/fr1k4f7+/ujQwfnk+OBAwewYMEC/PHHH8jIyIAkSQCAixcvonPnzjh8+DAGDRokByVLmzx5Ml588UX8+uuvuPbaa7FmzRrce++98PX1rfU2EhHVF0NQc5jPAoWVdVZuLg5MNvXENwCgUMg1TZGdUGFgUhQHdP3CWtRX6YiIasQY1goZp4DCjMqz6mYnngMAKAP40oWI7NT+UZDSzzTYzNwZqVeYkZvchoHJSigUimo3p765ayROJppxLjUXJr0GZmshAg1ajOoSWeum2dWVk5ODW2+9Fa+99lqZcZGRkThz5kyly7BYLBgxYgRGjBiBtWvXIjQ0FBcvXsSIESNQUFAAAPDx8alwGWFhYbj11luxevVqtGrVCt9//z3i4uJqtE1ERJ7iFxoNMwApu5L+Eh2BSVNUxdM1FX5R9sCkufzM3Hm5FqisGQCA4MiYeioYEVHNBEW1RgYAZfZlSDYblKry7/HzUu3Zu/XBTHxDRHY+wc1hiQcKMxtmZu7MJPt5jRm5yR0YmKwDXZr548kb22PbsSRcSLOga3N/3NQ53CNZuXv16oWvv/4aMTExUKvLft2tW7eGRqPB77//jhYt7DVUsrKycOrUKQwePBgAcOLECaSlpWHx4sWIjrZX096/f7/Tcrp164aPP/4YhYWF5daanDp1KsaNG4fmzZujTZs2GDhwoDs3lYiozgVHtsQVAMr8TFhzc6A3lK2NDluRvckywBqTDo7M5BUEJuUEEjo/6H396qFQREQ1FxzWDGdVWsBWgPSkywiJKj/oKGXa+8/1i4ipp9IRkbfzC4uGBYCo7GW3l7Kk2Gt6qvz5Ep5qj6HtOtKlmT9ib2yPt8f2ROyN7eslKJmVlYXDhw87/T300ENIT0/HuHHj8Pvvv+Ps2bP44YcfMGXKFNhsNphMJkyaNAnPPPMMfv75Zxw9ehQPPvgglMq/+8hs0aIFtFotli9fjnPnzuHbb7/Fyy+/7LTumTNnIjs7G2PHjsX+/ftx+vRpfPrppzh58qQ8zYgRI+Dn54dXXnkFU6ZMqfP9QUTkbj6+Jkg6e9AsPfGi64ksyYCQALUPoA+ov8J5M0eANvtquZNkOTJy+/EGl4i8n0KphCiuFZ929Wy50xVZLRCWNABASBQzchORXXBEcbc11kzk5+V4tjA1YJUzcvO+jWqPgclGJC4uDj179kSvXr3Qr18/9OrVCy+//DL27NkDm82Gm266CV27dsWsWbMQEBAAZXGm2CVLlmDAgAH45z//ieHDh2PgwIHo1KkT9Ho9ACA0NBRr1qzBhg0b0LlzZyxevBj//ve/ndYdHByMn376CTk5ORgyZAh69+6NDz/80Kn2pFKpxOTJk2Gz2TBx4sT62zFERG6kKK79l5lcTmDSXCLxTfELnibPUWPSmgkU5LqcJK+4jyVNIDNyE1HDoA62BxZyki+UO03q1XgIAEVaf/j7B9RPwYjI6/ka/eSX3WkJ5dxTejGpuF9wEzNykxuwKXcjsWbNGqxZswYAIIRAUVER1Gq1XOvxv//9b7nzmkwmrF27Vv5ssViwcOFCPPTQQ/KwcePGYdy4cU7zCSGcPnfr1g0//PBDheW8cuUKbr75ZkRGsnkjETVMmoBmKEo9KQfSynBk5GbNv79pimuPWjOBnEQgqHWZSQozr0AFwDeEmR2JqGEwhsYg6+wuFKaXH5jMTLRn5Fb4N5fvy4mIANhf3OZnw5xyEWhdvYS7niQVFUFhsWfkDoxg37lUewxMEg4dOoQTJ06gX79+yMrKwksvvQQAGD16tNvWkZWVhT///BPr1q3Dt99+67blEhHVN9+Q5sg6AxRmltMsWa4xyRcwTvyi7IHJ7IQygUkhSVCY7fvTP5wZuYmoYQiMao0sAMi+Yj+PKcs2RsstTnyjC+JLFyJypg2IQlHqSVjSGlYCnIyUq4CwQai0CAgK83RxqBFgU24CAPz73/9G9+7dMXz4cFgsFuzevRshISFuW/7o0aNx0003Yfr06bjxxhvdtlwiovrmF1YcODOX01m5ox9FBiadVZAAJzszHcqiPCgUCgQzMElEDURIREtAqYaiyIrMtCSX0xSl2xPfGMPZvyQROfMJtr+wKMxoYIHJ4u6MhDHc5QsZoupijUlCz549ceDAgTpdR1xcXJ0un4iovgRHROMSAEWBGZbsDPj6Bf49stAK5KXb/8+M3M4cTdtdJMBJTzwPAJAMIVBrdfVYKCKimlOp1RDGSCiyLyHt6lkEhjqf96WiQihyEiAABDHxDRGV4h/WAmYAIqdhZea2pNq7M1Ky2yJyE4a3iYiIqkGnN0DyCQIApCeV6qzcURtQ5wdofeu5ZF7OFGH/15wIlOqj2Jxi349Kf97gElHDogq0J34wJ50vMy496SIkSYKk0iM4OLyeS0ZE3i44wl5jUpFvRl5OlodLU3X5xRm5fZiRm9yEgUkiIqJqUhbXhsxOvuQ8wszEN+UyhgMKJVBoAazON9/W4kRC+kBmdiSihsUQGgMAyE8rmwAnI+EcAEDyaw6lio9dRORM72OATW9veZOWUH4SLW9jK070aAzlfRu5B6+QRERE1aQJaAYAZTNzy4lvIuq5RA2ASgP4htr/X6qfyaIs+5t3Yyj7lySihiUwsjiZV+YlCElyGmdJtgcaNEx8Q0TlkF92p1yqZErvYCsqgtKSDAAIDON9G7kHA5NERETV5BtsD0w6AmqybEdgkjUmXXKRAMdms0FpsSeNCIxo6YlSERHVWEhUDKBQQFFoQXZWutO4gnR7NxWmMJ7biMg1bYD9njEvvWEkwMlIuQIIiRm5ya0YmCQiIqqmAEcAzZzoXENGbsrNxDcuOQKT2X8HJtOTr0AhFUGh0iAghDVNiahh0er0kHzt/UemXTkrDxeSBFH88irAUauSiKgUn5DizNyZZZMDeqPMJGbkJvfjL4mIiKiagsKa22vIFOX9XUPGmg0U5ABQAEYG2FzyK1tjMjPJ3tRRMkZAoVR5olRERLWiCrQHFrKT4uVhWakJgC0fQqFGaASbchORawFhxecHc0KZ5IDeyJGRW8X+1MmNGJgkIiKqJo1WB+ETAgDITCzurNycaP/XNwRQaz1UMi/naOJuTgSKa5rmFPeppGZGbiJqoHyC7bXo89MuysPSEuy1JyVTJNRqtUfKRUTeLzi8RXF3ELnIyc7wdHEqlV9cs1Mf1MzDJaHGhIHJupCbDmReKvuXm175vDU0efJkKBQKLF682Gn4pk2boFAo6my9RERNlaI4kJadUpwAx1zcBMfEZtzlMgQDSg0gFQK5aQCA/Az7/vMJZo0iImqYAiJjAABS5t/JK3KS7UFKdSDPbURUPq1OB6n4ZXdDyMwtZdlbvZiYkZvciK/v3C03Hfh+NpCbWnacIQQYtRgwBNXJqvV6PV577TU89NBDMJlMdbIOIiKy0wU2Q37CH7CmFwcmHf0msmlL+ZRKe8byrEv2QK4xFFLWVajAjNxE1HCFNmuDqwCU1kzk5mTBYPRHfpo9wGAIZeIbIqqYwi8CyE1BTspFoGNPTxenXLaiQihyUwAwIze5F2tMVkYIoCi/6n95GYAlGVBpAL3/338qjX14XkbVl1XNPiaGDx+OiIgILFq0qNxpfvnlFwwaNAg+Pj6Ijo7G448/DovFAgB455130KVLF3laR23LlStXOq3jxRdfrOZOJCJqfHxD7G+Ki7KKsyjKNSbZv2SFHIHb7ATkW3OhyrO3JgiO4sM7ETVMeoMRkk8wACDlcnET7uJrQ0BEK4+Vi4gaBl2gvVl0XoZ3Z+bOSHZk5NbBPyjU08WhRoQ1JitjKwC+f7bq0xfkAKknAZXOHoyUl1MI2PKBuFcBrbFqyxr1OqDWVXnVKpUKr776KsaPH49HH30UMTExTuPPnj2LkSNH4pVXXsGqVauQkpKCmTNnYubMmVi9ejWGDBmCxx9/HCkpKQgNDcXOnTsREhKCuLg4TJ8+HYWFhdi7dy9mz55d5TIRETVWgWEtkA5AmZMEIdmgMCfZR5hYY7JCjqbu5qtIS7wEQEBojTD61U1rAiKi+qAMiAby0pCVGI+cqBgo8s2AQoGQqBhPF42IvJxvcDQKABRlJlQ6rScxIzfVFf6aGpk77rgDPXr0wEsvvVRm3KJFizBhwgTMmjUL7dq1w3XXXYdly5bhk08+gdVqRZcuXRAUFISdO3cCAOLi4vDUU0/Jn3/77TcUFhbiuuuuq9dtIiLyRoFhzQCFCrAVIPvyCfvLJ6Ua8OUb5ArJgclEZBdn5Ga/nETU0OlD7M0arWkXkVZca9LmEwq93seTxSKiBiAgvLhZtDkBojg5oDfKSbPX6FQxYSG5GWtMVkaltddcrKqsy8DmpwCfQEDr+/fwAou9GffQ5wH/KnYUq6pZVtfFixdj2LBheOaZZ5yG//HHHzhy5AjWrl0rDxNCQJIkxMfHo1OnThg8eDDi4uIwfPhwHDt2DI8++ihef/11nDhxAjt37kTfvn1hMBhqVC4iosZEpVZD8g2DMicBOfG/wx8AjBH2fhSpfH7FQUhLCvIs8QAATSAzOxJRw+Yf0QrWPwEp4xKyk+0vXVRMfENEVRAUFoV4hRIKWz7MGanwCw7zdJFcyi9uau7DjNzkZgxMVkahqFZzaqi0gEJprzlTVOLh1JZvH67SVm95NTB48GDcdNNNeP755zF58mR5eE5ODh5++GE8/vjjZeZp0cL+lmbo0KH44IMPsHv3bvTs2RN+fn5ysHLnzp0YMmRInZadiKghUflHQuQkQFw9DBjB/iWrQucHaHyBQgtUKX8CsDdhIiJqyEKatUESAEVuCnITTgIA9Dy3EVEVqDVaSIYwKC2JSE+64LWBSSk7EUowIze5HwOT7qb1tWffzk0FCq3O4wwhzrUo69Arr7yCvn37okOHDvKwXr164dixY2jbtm258w0ZMgSzZs3Chg0bMHToUAD2YOWPP/6IPXv24KmnnqrrohMRNRi6oOawXjmI/LwcwOj7d21AKp9CYd9PaWdQlJcNAPBjZkciauCMfoGQdH5Q5mdDkXoSAvZalEREVaHyj4SwJMKccglAX08Xp4yiwgIoHRm5w5mwkNyLgUl3MwQBoxbbm26XpvW1j68HXbt2xYQJE7Bs2TJ52HPPPYdrr70WM2fOxNSpU+Hr64tjx45h+/bteOeddwAA3bp1Q2BgINatW4f//e9/AOyByaeffhoKhQIDBw6sl/ITETUExpBoWAHkFRTZBzDxTdWYIlGYfBqFNgEFgOBIBiaJqOFTBkQDSUchhAAAhDRr7eESEVFDoQ2MQv7VQ8hL987M3BkpV+WM3H4BwZ4uDjUyXtER1ooVKxATEwO9Xo/+/fvjt99+q3D6DRs2oGPHjtDr9ejatSu2bNlSTyWtIkMQEBBd9q+egpIOCxcuhFSi89xu3bph586dOHXqFAYNGoSePXti3rx5iIr6+0FaoVBg0KBBUCgUuP766+X5/Pz80KdPH/j61k+NTyIir5ebjmCDClpbLmzWHIj8HAASkJvu6ZJ5t9x0QKFCniULWlsu1BotdNY07jciathy02H0NUFry7Wf29RqGG1mntuIqHK56Qgw6OznjrRTQOYl+583nD9y04HMS8iJ3w+tLRcaH18osq94R9mo0VAIxys9D/niiy8wceJErFy5Ev3798fSpUuxYcMGnDx5EmFhZftW+L//+z8MHjwYixYtwj//+U+sW7cOr732Gg4ePIguXbpUur7s7Gz4+/sjKysLfn5+TuOsVivi4+PRqlUr6PV6t21jfRNCoKioCGq1GgqFwtPFqbHG8n2QZ0iShOTkZISFhUHJZCTkbrnpwPezYU5PQF7CcQhJgk6rgSq0A0xBEfaa8/X8Mqq0v65kYetfCTh9NQPtogIxskskujTz92iZHPvNkhKPgtR4FBRJKFL7wi+iFUyB3rHfqHHiNYHqVPG5Lf3KSdgyLkMSwivPbTwOiLzwOCg+f2QmnUdhyllIAHL92iLEpPP8+cNxv5uRiMyUK9DmZ6BAY0JAeEvPl41qzR3HQkXxterweFPuJUuWYNq0aZgyZQoAYOXKldi8eTNWrVqF2bNnl5n+7bffxsiRI+WM0y+//LLcFHnlypX1WnYiImqiCiwwZyTiVHoRTJIBeliRXeiDjNQCtCq6gtzEFBSZtB4r3ukkMz7+v/MwW4ugUUi4cjIFBy5kYNJ1MWgXbvJYudTmFBiSr+BCpgLhRSoIKJEhGZGYVoj2SISpwMIbXCJqeIqvCRctWgQJFQAgQzLx3EZElSs+f5wzqxAs1FBAIDUnHzl5VjTLMyPv5O+w+YZ7pGgqSxJ8rp7GFbMEbYENAmqkSSYk89xGbubRwGRBQQEOHDiAOXPmyMOUSiWGDx+OvXv3upxn7969iI2NdRo2YsQIbNq0yeX0+fn5yM/Plz9nZ9s72pckyamZs2OYEEL+a8gc5W/I2+H4Hlx9V0SVcRzP/O1QnRASUs35sEh66DV+0NlsMMOItHwVVGm52L7vIrK0+ZUvp44cuZyFJLMVfjo1bJIElVKJxGwrlv90Bt08WGvSvyAJN6blIqXIgAClHhoUwaYPhMWmQWqOFb5CAnjMUh3gNYHqVPE1IRs+8FPqoYINRfpAWGxqrzq38Tgg8sLjoPj8kSPpYVQZoRNWhEkpUNgKYUu3ITnuAxSoDB4pmtaWi+bZF+EvVBAKDYRCA0kfBEuRwqvObVQz7jgW3HUceTQwmZqaCpvNhvBw5zcA4eHhOHHihMt5EhMTXU6fmJjocvpFixZh4cKFZYanpKTAanXOml1YWAhJklBUVISioqLqbIpXEULAZrMBQINuyl1UVARJkpCWlgaNRuPp4lADI0kSsrKyIITwjmYa1KgozWnIzS+EEjqYNSFQSIVIVwRBBRskSYKPsgiFSs9dR6wFBdCrFdAoBZRCgkqpgF6tgDW/AAYPlstHaT+vq5RAkjIM/siBVWWC0paHXGshUlPTIOXrPFY+arx4TaC6VPKakKGJgM6Wg3yVCUpbrled23gcEHnfcVDy/JGtCYVfQTKgEFAKJVQoQL7GH/kqo0fKJpQaFECNAmghKdQoVOqQrzJAWeRd5zaqGXccC2az2S1l8XhT7ro2Z84cpxqW2dnZiI6ORmhoqMs+Js1mM9RqNdTqhr9rGnowT61WQ6lUIjg4mH1MUrVJkgSFQoHQ0FCvuOmgRkaXD4tOgzSrAgqdEWZ9e5iEQH6uGSE+ejx2U2fAP9pjxfPZfgq/nktDmxBfWPPzodfpcCbFgoFtQzBreDuPlQtZl3Dhqh55VjXUhkBYFBFQCYGiAisMeg1CQoIB/7L9SxPVFq8JVKdKXBOKDGEoUoQXn9sUXnVu43FA5IXHQYnzh80nBBmGUKD4njLax4p+E+Z77p4y6xIurHkIV6166AwmQKGwn9vgXec2qhl3HAvuitN4NPoWEhIClUqFpKQkp+FJSUmIiIhwOU9ERES1ptfpdNDpykbxlUplmZ2vVCrlGoYNuaahEKJRbAdgL7+r74qoKvj7oTqjUCLEpEN6QQEsuWZoVEoU2iT4KgsQYtRBqVACHvzdjewSieMJZpxJsUCnlJCfXYQAgxY3XRPh2ePBy/cbNW68JlCdaUDnNh4HRF52HHjz+cOby0ZuUdtjwV3HkEd/RVqtFr1798aOHTvkYZIkYceOHRgwYIDLeQYMGOA0PQBs37693Omrw1HDMDc3t9bLotpzfA8NveYnETVCWl+YAiPQPliDaB8rAmB/q90+WGPPUqj19WjxujTzx5M3tsd1bUNg0qlxXdsQPHlje89n5fby/UZEVCM8txFRTXnz+cOby0aNisfbK8fGxmLSpEno06cP+vXrh6VLl8JischZuidOnIhmzZph0aJFAIAnnngCQ4YMwZtvvolbbrkF69evx/79+/HBBx/UuiwqlQoBAQFITk4GABgMhgZZ41AIgaKiIqjV6gZb/tzcXCQnJyMgIAAqlcrTRSIicmYIAkYthqnAgjI5rrW+XpGhsEszf3SONCE5ORlhYWHeUSugAew3IqJq47mNiGrKm88f3lw2alQ8HpgcM2YMUlJSMG/ePCQmJqJHjx7YunWrnODm4sWLTg9T1113HdatW4cXX3wRzz//PNq1a4dNmzahS5cubimPo0m4IzjZEDkyK5Vsmt4QBQQElNtEn4jI4wxBvCGrCe43ImqMeG4jopry5vOHN5eNGg2FEEJ4uhD1KTs7G/7+/sjKyiqT/KYkm82GwsLCeiyZ+zgyWQcHB3tHDZka0Gg0rClJtSJJknfVFCPyAB4HRHY8Foh4HBABPA6IHNxxLFQ1vlYZj9eY9FYqlarBBsYkSYJGo4Fer+fJloiIiIiIiIiIvBKjVkRERERERERERFTvGJgkIiIiIiIiIiKietfkmnI7utTMzs72cEnqjiRJMJvNbMpNTRqPAyIeB0QOPBaIeBwQATwOiBzccSw44mq1TV3T5AKTZrMZABAdHe3hkhARERERERERETVcZrMZ/v7+NZ6/yWXlliQJV69ehclkgkKh8HRx6kR2djaio6Nx6dKlWmVGImrIeBwQ8TggcuCxQMTjgAjgcUDk4I5jQQgBs9mMqKioWtVAbnI1JpVKJZo3b+7pYtQLPz8/nmypyeNxQMTjgMiBxwIRjwMigMcBkUNtj4Xa1JR0YKcKREREREREREREVO8YmCQiIiIiIiIiIqJ6x8BkI6TT6TB//nzodDpPF4XIY3gcEPE4IHLgsUDE44AI4HFA5OBNx0KTS35DREREREREREREnscak0RERERERERERFTvGJgkIiIiIiIiIiKiesfAJBEREREREREREdU7BiaJiIiIiIiIiIio3jEwSURERERERERERPWOgclGZsWKFYiJiYFer0f//v3x22+/ebpIRPVqwYIFUCgUTn8dO3b0dLGI6tSuXbtw6623IioqCgqFAps2bXIaL4TAvHnzEBkZCR8fHwwfPhynT5/2TGGJ6khlx8HkyZPLXB9GjhzpmcIS1ZFFixahb9++MJlMCAsLw+23346TJ086TWO1WjFjxgwEBwfDaDTirrvuQlJSkodKTFQ3qnIsDB06tMx1Yfr06R4qMZH7vffee+jWrRv8/Pzg5+eHAQMG4Pvvv5fHe8v1gIHJRuSLL75AbGws5s+fj4MHD6J79+4YMWIEkpOTPV00onp1zTXXICEhQf775ZdfPF0kojplsVjQvXt3rFixwuX4119/HcuWLcPKlSuxb98++Pr6YsSIEbBarfVcUqK6U9lxAAAjR450uj58/vnn9VhCorq3c+dOzJgxA7/++iu2b9+OwsJC3HTTTbBYLPI0Tz75JL777jts2LABO3fuxNWrV3HnnXd6sNRE7leVYwEApk2b5nRdeP311z1UYiL3a968ORYvXowDBw5g//79uOGGGzB69GgcPXoUgPdcDxRCCFHva6U60b9/f/Tt2xfvvPMOAECSJERHR+Oxxx7D7NmzPVw6ovqxYMECbNq0CYcPH/Z0UYg8QqFQYOPGjbj99tsB2GtLRkVF4amnnsLTTz8NAMjKykJ4eDjWrFmDsWPHerC0RHWj9HEA2GtMZmZmlqlJSdSYpaSkICwsDDt37sTgwYORlZWF0NBQrFu3DnfffTcA4MSJE+jUqRP27t2La6+91sMlJqobpY8FwF5jskePHli6dKlnC0dUj4KCgvDGG2/g7rvv9prrAWtMNhIFBQU4cOAAhg8fLg9TKpUYPnw49u7d68GSEdW/06dPIyoqCq1bt8aECRNw8eJFTxeJyGPi4+ORmJjodH3w9/dH//79eX2gJicuLg5hYWHo0KEDHnnkEaSlpXm6SER1KisrC4D9QRQADhw4gMLCQqdrQseOHdGiRQteE6hRK30sOKxduxYhISHo0qUL5syZg9zcXE8Uj6jO2Ww2rF+/HhaLBQMGDPCq64G6XtdGdSY1NRU2mw3h4eFOw8PDw3HixAkPlYqo/vXv3x9r1qxBhw4dkJCQgIULF2LQoEH466+/YDKZPF08onqXmJgIAC6vD45xRE3ByJEjceedd6JVq1Y4e/Ysnn/+eYwaNQp79+6FSqXydPGI3E6SJMyaNQsDBw5Ely5dANivCVqtFgEBAU7T8ppAjZmrYwEAxo8fj5YtWyIqKgpHjhzBc889h5MnT+K///2vB0tL5F5//vknBgwYAKvVCqPRiI0bN6Jz5844fPiw11wPGJgkokZl1KhR8v+7deuG/v37o2XLlvjyyy/x4IMPerBkRETkSSW7LejatSu6deuGNm3aIC4uDsOGDfNgyYjqxowZM/DXX3+xr21q8so7Fh566CH5/127dkVkZCSGDRuGs2fPok2bNvVdTKI60aFDBxw+fBhZWVn46quvMGnSJOzcudPTxXLCptyNREhICFQqVZkMSklJSYiIiPBQqYg8LyAgAO3bt8eZM2c8XRQij3BcA3h9IHLWunVrhISE8PpAjdLMmTPxv//9Dz///DOaN28uD4+IiEBBQQEyMzOdpuc1gRqr8o4FV/r37w8AvC5Qo6LVatG2bVv07t0bixYtQvfu3fH222971fWAgclGQqvVonfv3tixY4c8TJIk7NixAwMGDPBgyYg8KycnB2fPnkVkZKSni0LkEa1atUJERITT9SE7Oxv79u3j9YGatMuXLyMtLY3XB2pUhBCYOXMmNm7ciJ9++gmtWrVyGt+7d29oNBqna8LJkydx8eJFXhOoUansWHDFkTyT1wVqzCRJQn5+vlddD9iUuxGJjY3FpEmT0KdPH/Tr1w9Lly6FxWLBlClTPF00onrz9NNP49Zbb0XLli1x9epVzJ8/HyqVCuPGjfN00YjqTE5OjtPb/fj4eBw+fBhBQUFo0aIFZs2ahVdeeQXt2rVDq1atMHfuXERFRTllLCZq6Co6DoKCgrBw4ULcddddiIiIwNmzZ/Hss8+ibdu2GDFihAdLTeReM2bMwLp16/DNN9/AZDLJ/YT5+/vDx8cH/v7+ePDBBxEbG4ugoCD4+fnhsccew4ABA5iRmxqVyo6Fs2fPYt26dbj55psRHByMI0eO4Mknn8TgwYPRrVs3D5eeyD3mzJmDUaNGoUWLFjCbzVi3bh3i4uLwww8/eNf1QFCjsnz5ctGiRQuh1WpFv379xK+//urpIhHVqzFjxojIyEih1WpFs2bNxJgxY8SZM2c8XSyiOvXzzz8LAGX+Jk2aJIQQQpIkMXfuXBEeHi50Op0YNmyYOHnypGcLTeRmFR0Hubm54qabbhKhoaFCo9GIli1bimnTponExERPF5vIrVwdAwDE6tWr5Wny8vLEo48+KgIDA4XBYBB33HGHSEhI8FyhiepAZcfCxYsXxeDBg0VQUJDQ6XSibdu24plnnhFZWVmeLTiRGz3wwAOiZcuWQqvVitDQUDFs2DCxbds2eby3XA8UQghRn4FQIiIiIiIiIiIiIvYxSURERERERERERPWOgUkiIiIiIiIiIiKqdwxMEhERERERERERUb1jYJKIiIiIiIiIiIjqHQOTREREREREREREVO8YmCQiIiIiIiIiIqJ6x8AkERERERERERER1TsGJomIiIiIiIiIiKjeMTBJRERERB6jUCiwadMmTxcDCxYsQI8ePTxdDCIiIqImhYFJIiIiokYsJSUFjzzyCFq0aAGdToeIiAiMGDECe/bs8XTR3OL8+fNQKBQ4fPiwp4tCRERERNWk9nQBiIiIiKju3HXXXSgoKMDHH3+M1q1bIykpCTt27EBaWpqni0ZERERETRxrTBIRERE1UpmZmdi9ezdee+01/OMf/0DLli3Rr18/zJkzB7fddps83ZIlS9C1a1f4+voiOjoajz76KHJycuTxa9asQUBAAP73v/+hQ4cOMBgMuPvuu5Gbm4uPP/4YMTExCAwMxOOPPw6bzSbPFxMTg5dffhnjxo2Dr68vmjVrhhUrVlRY5kuXLuHee+9FQEAAgoKCMHr0aJw/f77K2xwXFweFQoEdO3agT58+MBgMuO6663Dy5Emn6RYvXozw8HCYTCY8+OCDsFqtZZb10UcfoVOnTtDr9ejYsSPeffddedwDDzyAbt26IT8/HwBQUFCAnj17YuLEiVUuKxEREVFTx8AkERERUSNlNBphNBqxadMmOYDmilKpxLJly3D06FF8/PHH+Omnn/Dss886TZObm4tly5Zh/fr12Lp1K+Li4nDHHXdgy5Yt2LJlCz799FO8//77+Oqrr5zme+ONN9C9e3ccOnQIs2fPxhNPPIHt27e7LEdhYSFGjBgBk8mE3bt3Y8+ePTAajRg5ciQKCgqqte0vvPAC3nzzTezfvx9qtRoPPPCAPO7LL7/EggUL8Oqrr2L//v2IjIx0CjoCwNq1azFv3jz861//wvHjx/Hqq69i7ty5+PjjjwEAy5Ytg8ViwezZs+X1ZWZm4p133qlWOYmIiIiaMoUQQni6EERERERUN77++mtMmzYNeXl56NWrF4YMGYKxY8eiW7du5c7z1VdfYfr06UhNTQVgrzE5ZcoUnDlzBm3atAEATJ8+HZ9++imSkpJgNBoBACNHjkRMTAxWrlwJwF5jslOnTvj+++/lZY8dOxbZ2dnYsmULAHvym40bN+L222/HZ599hldeeQXHjx+HQqEAYK+JGBAQgE2bNuGmm24qU9bz58+jVatWOHToEHr06IG4uDj84x//wI8//ohhw4YBALZs2YJbbrkFeXl50Ov1uO6669CzZ0+n2pvXXnstrFar3Fdl27Zt5dqeDq+88gq2bNmC//u//wMA7N27F0OGDMHs2bOxaNEi/Pzzz7j++uur8e0QERERNW2sMUlERETUiN111124evUqvv32W4wcORJxcXHo1asX1qxZI0/jCOI1a9YMJpMJ999/P9LS0pCbmytPYzAY5KAkAISHhyMmJkYOSjqGJScnO61/wIABZT4fP37cZVn/+OMPnDlzBiaTSa7tGRQUBKvVirNnz1Zru0sGXiMjIwFALtvx48fRv3//cstpsVhw9uxZPPjgg3I5jEYjXnnlFadyDBgwAE8//TRefvllPPXUUwxKEhEREVUTk98QERERNXJ6vR433ngjbrzxRsydOxdTp07F/PnzMXnyZJw/fx7//Oc/8cgjj+Bf//oXgoKC8Msvv+DBBx9EQUEBDAYDAECj0TgtU6FQuBwmSVKNy5mTk4PevXtj7dq1ZcaFhoZWa1kly+aofVnVsjn61/zwww/LBDBVKpX8f0mSsGfPHqhUKpw5c6Za5SMiIiIi1pgkIiIianI6d+4Mi8UCADhw4AAkScKbb76Ja6+9Fu3bt8fVq1fdtq5ff/21zOdOnTq5nLZXr144ffo0wsLC0LZtW6c/f39/t5WpU6dO2LdvX7nlDA8PR1RUFM6dO1emHK1atZKne+ONN3DixAns3LkTW7duxerVq91WRiIiIqKmgIFJIiIiokYqLS0NN9xwAz777DMcOXIE8fHx2LBhA15//XWMHj0agL0vxcLCQixfvhznzp3Dp59+KvcR6Q579uzB66+/jlOnTmHFihXYsGEDnnjiCZfTTpgwASEhIRg9ejR2796N+Ph4xMXF4fHHH8fly5fdVqYnnngCq1atwurVq3Hq1CnMnz8fR48edZpm4cKFWLRoEZYtW4ZTp07hzz//xOrVq7FkyRIAwKFDhzBv3jx89NFHGDhwIJYsWYInnngC586dc1s5iYiIiBo7BiaJiIiIGimj0Yj+/fvjrbfewuDBg9GlSxfMnTsX06ZNk7NHd+/eHUuWLMFrr72GLl26YO3atVi0aJHbyvDUU09h//796NmzJ1555RUsWbIEI0aMcDmtwWDArl270KJFC9x5553o1KkTHnzwQVitVvj5+bmtTGPGjMHcuXPx7LPPonfv3rhw4QIeeeQRp2mmTp2Kjz76CKtXr0bXrl0xZMgQrFmzBq1atYLVasV9992HyZMn49ZbbwUAPPTQQ/jHP/6B+++/HzabzW1lJSIiImrMmJWbiIiIiOpETEwMZs2ahVmzZnm6KERERETkhVhjkoiIiIiIiIiIiOodA5NERERERERERERU79iUm4iIiIiIiIiIiOoda0wSERERERERERFRvWNgkoiIiIiIiIiIiOodA5NERERERERERERU7xiYJCIiIiIiIiIionrHwCQRERERERERERHVOwYmiYiIiIiIiIiIqN4xMElERERERERERET1joFJIiIiIiIiIiIiqncMTBIREREREREREVG9Y2CSiIiIiIiIiIiI6h0Dk+Q1zp8/D4VCAYVCgaFDh9b7+tesWSOvf8GCBfLwoUOHysPPnz9fr2Xy9D6hquN3RUT1acGCBfI5Z82aNXWyDk9e/2qrvGt6fZk8ebK8/ri4OHm4Y1hMTEy9l8nT+4SImqaYmBj53FPa0qVL0bFjR+h0OigUCvTo0UMet23bNvTv3x8mk0mePzMzs/4KTkT1Ru3pAjQ1ly9fxsKFC7F9+3ZcvXoVPj4+CA0NRadOndC3b1/MmzfP00V0i6FDh2Lnzp3yZ41GA39/f0RHR2PAgAF45JFH0KVLF7eu8/z58/LDWY8ePXD77be7dfl1Zc2aNfID36xZsxAQEODR8lSmsLAQn376KdavX4/Dhw8jKysL4eHhaN++Pe655x6MHz8eJpPJ08UkIirDYrHggw8+wMaNG3H06FFYLBZERkbimmuuwdixY3HvvfdCq9V6upj15vDhw9i0aRMA+3XbW1+qlHyYVSgU0Ol0CAwMRJs2bTB8+HA88sgjCAsLc+s64+Li5IDi7bff7vSw7M0cAceAgADMmjXLo2UhosZlwYIFWLhwofxZrVbD19cXkZGR6N69OyZPnoyRI0dWeXnr16/Hk08+6XLc+fPnMXr0aFit1lqXm9wvIyMDr7zyCr799ltcvHgRWq0WwcHBaN++Pfr06YMXXngBvr6+ni4mNSSC6k1CQoKIjIwUAFz+qVQqTxfRbYYMGVLudgIQCoVCzJs3z2keq9Uqdu/eLXbv3i2OHDlS7XX+/PPP8vInTZpU7fmTkpLk9V+4cMHltsTHx1d7uZWpaPm13SfudvnyZdG7d+8Kv9uNGzd6upge4W3fFRE5O3r0qGjdunWF569Dhw55uphVNn/+fLncq1evrtEyVq9eLS9j/vz5ZcYfOXJEPq9ZrdbaFbgWKvrOAAiTySS+/fZbp3nKu6ZXVW3376lTp+T1Z2ZmltmWli1bVnuZVVHR8mu7T4ioaSt5Xizv79ZbbxXZ2dlO8/3+++/yuaekCRMmyPPNmzdP7N69W74Of/jhh/K422+/XcTFxYndu3eLoqKi+tpcKkdubq7o3Llzhb+DS5cuebqY1MCwxmQ9Wr58ORISEgAAw4YNw4wZM2A0GnH+/Hn89ttvcq0FT7FYLHXyZuP555/HiBEjcOXKFXz55ZfYtGkThBB46aWXEBgYKL/R1+l0uP76692+/soUFBRAqVQiLCzM7TUuastT+8SVgoIC3HbbbTh48CAAe22Mp556Ctdeey3y8/Oxd+9e/Oc///FwKT0jNzcXBoPBa74rInKWnp6OUaNG4eLFiwCAqKgoPPPMM+jatSvMZjN27tyJ1atXe7iU3qdr166eLkIZGzZsQFBQEM6cOYP33nsPhw8fhtlsxt13343du3ejX79+AOCxa7rjXqpdu3Zo165dva+/It54n0NEDdOoUaPw/PPPIz09HT/++CPef/99FBQU4LvvvsP999/v9Fzbp08fl8u4evWq/P/JkyejVatWLsfddtttGDJkiNu3wXH/TtXz2Wef4dixYwCAXr164dlnn0VISAguXryIQ4cO4auvvvJo+eoqpkF1zNOR0aZk5MiR8lsEVzWqLBZLmWFpaWli9uzZolOnTsLHx0eYTCbRs2dPsXz5cqfpTp8+LSZPniyaN28uNBqNCAoKEqNGjRI//vij03SlaxV+/fXXonv37kKr1TrVlti1a5e49dZbRUhIiNBoNCImJkY8+eSTIj09vUrbWrIWYOmaBk899ZRTLYeMjAwhhBDx8fHy8CFDhsjT5+bmiqefflq0bdtWaLVaYTAYRExMjLjjjjvEf//73zLrK/3nqD05adIkediWLVtEbGysiIiIEAqFQsTHx5dbc6Tkso8ePSoef/xxERoaKgwGg7jlllvEmTNnnLbPMW3p2gqla0aW/C5c/cXHx5e7T4QQIisrSzz//POiY8eOQq/XC6PRKPr16ydWrlwpJEkqt0ynTp0St956q/D19RWBgYHi4YcfFnl5eZV+p++//75T7V5XNYuys7Od3pBJkiTef/990b9/f2E0GoVOpxMdOnQQc+bMcapBUnr/7N+/X0yYMEEYjUYRHh4u5s+fLyRJEn/88YcYOnSo0Ov1Ijo6Wrz99ttOyyj9HX766aeic+fOQqfTiU6dOom1a9c6Tf/nn3+K8ePHi06dOonAwEChVqtFaGiouPnmm8XOnTsrXPZ7770n2rdvL9RqtVi9enWtfr8OCQkJ4rHHHhOtW7cWWq1W+Pv7iyFDhogvv/zSabrS6/rtt9/E0KFDhY+PjwgPDxcvvPCCsNlslX6nRE3FnDlz5GPG399fXL58ucw0SUlJIi0tTQhRfm258mrml76+PPbYYyIoKEgEBgaKGTNmCKvVKi5cuCCfe10dp+Vdg8o7t5RXxo8++kjcdNNNIjo6WhgMBqHT6UTbtm3FzJkzRUpKijxdy5Yty73+ONZf+rqVlJQkVCqVACC6devmtP+sVqswmUwCgIiMjJRrtUiSJFatWiWuu+46YTKZhF6vF926dRNLly6t8nmq9LXRIT8/XwwYMEAed/3111dpf44bN05ERkYKtVot/P39RadOncTkyZPFH3/8UWZ9pf8c+7rk/rtw4YK48847hZ+fn4iJiSnzm/j555/LbEvLli1FfHy8uO2224TRaBTBwcHi0UcfFTk5OfK0FbUEKX2vUVFNJsc0FdWQrel95NatW0WfPn2ETqdzeV0mosaj5Hmm9Dnpu+++czrvlDx3lDxfCiEqfAYqee4s71wmhBDnzp0TU6dOFS1atBBarVaEhoaKe++9Vxw7dsypXJXdvzts2rRJDBs2TAQEBAitVivat28vFixYIHJzc52WV/K6+Mcff4iZM2eK0NBQodfrxciRI8X58+fL7Le9e/eKu+++W0RGRgqNRiPCw8PFqFGjyjxLVbUMpRUUFIjg4GABQAQFBYnCwkKn8e3btxcAhE6nk5/lv/rqKzFw4EDh5+cnl2ngwIHi2WefLfMcWdr06dPlfVC6tYKjPKXLkJubK/71r3+Jnj17Cl9fX2EwGETnzp3F3Llznaar6bPQzp07xbXXXiv0er3Tb/OPP/4QY8eOFREREUKj0YioqCjx4IMPskanF2Jgsh7dc8898gF02223id27d4v8/Pxyp7948aJo0aKFyxNzyYeTffv2yQ8Dpf8UCoV499135WlLXghatWolFApFmZvUDz/8UCiVSpfL69ChQ5WCkxUFJs1mswgMDJTHf/rpp0KI8h++HnjggXIvUBMmTCizPlcXOCGcHxJKN+eramCyW7duZZbfrFkzkZqaKk/v6uJZejm1DUymp6eLjh07ljvv2LFjndbtGO7n5ydfuEr+vfDCC5V+pzfccIM8/eTJkyudXpIkMXbs2HLL2LFjR6ffUsn906ZNmzLTP/bYYyIgIKDM8O3bt8vLKPkddujQweV6161bJ0//+eefl1s+pVIpfvrpJ5fLLv37qSgwWZXfrxD2G6yIiIhyp33uuefkaUuuKzIyUvj4+JSZ/sMPP6z0OyJqKkoeswsWLKh0+toEJl2dv+6//37RqlWrCo9TdwUmR4wYUe55pFOnTvKLqJoEJoVwfsl66tQpeb3ffPONPPzJJ5+Uh0+cOLHc9YwZM6bS70KI8gOTQgjxyy+/OI13PGy42p+FhYXyA5qrP8f3Ud74kvu65P4r+ftyXPsrC0wGBQWJ5s2bl1n+yJEj5WnrKzBZ0/vIli1burxfLHldJqLGo6LApBBCDB8+XB7/4IMPysPdHZg8cOCAy2cCAMJoNIp9+/bJ667s/l0IIebOnVvuOgcNGuT0vF7yuuiqe5iBAwc67ZNVq1bJL/TKu55UtwyulAwWbtu2TR7+xx9/yMPvuOMOIYQQcXFx5T7rAygTVCztmWeecdrebdu2uaxg5ZCVlSV69OhR4XcqRM2fhaKiooRery/z29yyZYvQ6XQulxURESHOnTtX4XZS/WJW7no0fPhw+f/ffvstBg0aBJPJhOuvvx5vvvkmLBaL0/SPPvqo3OysRYsW+OCDD7B161a8/vrriI6OBgAIITBlyhSYzWYAwN13343Nmzdj7ty5UCqVEEJg1qxZuHTpUpnyxMfHo0+fPtiwYQM2bdqEQYMG4cqVK5g5cyYkSYLJZMLy5cvxww8/YMqUKQCAkydP4vnnn6/VfjAajU6Jbw4fPlzh9N988w0AoGXLlvjqq6+wbds2/Oc//8HEiRMRGBgIwN5MftmyZfI8o0aNwu7du7F792688MILZZZ57tw5PP7449i6dSvef//9KidruXr1KlavXo0NGzagdevWAIArV67g1VdfrdL8JfXs2RO7d+926lB/w4YNcrkjIyPLnff555/HiRMnANib2v33v//FRx99JO+P9evX44svvigzX3Z2NkJDQ/H111/j5Zdfloe///77lZb3jz/+kP8/aNCgSqf/8ssvsX79egBAYGCgnHCiW7duAIATJ06U+1sym834/PPPnfbr8uXLERERgY0bN+KRRx6ptOwnT57EE088gc2bN+O+++6Th8fGxqKwsBAA0KFDB7z55pvYtGkTfvrpJ+zYsQPvvfcedDodJEnCokWLXC773LlzGDFiBDZt2oQvv/wS11xzTbn7oSq/X8B+vCcmJgKwJ6H49ttvsWTJEuj1egDAa6+9hn379pVZfkJCAnr16oVvvvkGjz/+eKX7haipycnJwblz5+TPVTl/1UZiYiI++OADfPTRR1Aq7bdZn376KfLy8rB+/XqnbMh1cZyOGTMGq1atwubNmxEXF4fNmzdj4sSJAIDjx4/jv//9LwDgq6++cjoHT5kyRb7+PPDAA+Uuv+T5tGRzrZL/d0zz1Vdf4ZNPPgFgP99+/vnn+O6773DttdcCAL744guX16rq6NevH1Qqlfy5onuKEydO4NSpUwDs92Rbt27F//73PyxfvhyjRo2CTqcDAOzevVu+7wHs11zHvrn55pvLLDcpKQlLlizBtm3bqnyPlJ6ejvDwcGzatAnLly+XmxNu3boV3333XZWWUdIDDzyA3bt3y58jIiLkMlfUrK4295EXLlzArbfeiu+++w5jx46Vh/P6Q9Q0DRgwQP5/Refiip6BXnjhhXLPwV999RWEEJg0aZKcnfupp57Ctm3b8Nprr0GlUiEnJwdTpkyBEKLMel3dv//+++/yM1FkZCT+85//YOvWrbjlllsA2K8Hb731lsvtSElJwcqVK/HZZ5/JyUv37NmDo0ePArA/Iz7yyCOw2WwA7InUNm7ciK+++grTpk2Tk+3VpgwO1bk2f/fdd5AkCQDw6quvYseOHVi/fj1efPFFdO7c2WX29JJKxjT27NmDm266CX5+fujTpw8WLlyI1NRUp+lfeOEF+fcQFBSEt956C1u3bsXy5cvRsWNHebqaPgtdvXoVzZs3x2effYYtW7bg9ttvR25uLiZNmoT8/Hyo1Wr861//wrZt2/Dss88CsN+rPfrooxVuJ9UzT0ZFm5qioiKnTn5L/7Vp00auQZaWlia/yVCpVGWqpTscPHjQKfJfUFAgj7vrrrvkcW+99ZYQwvkNldFolJutObz11lvy+ClTpsgdFe/atUsYDAYB2JvBVdb8qqIak0IIce+998rjp06dKoQov1aI481J9+7dxaFDh8rtgL+y5Dcl38CNHz++zPiq1JgsWbtl+/btTm/MHBzDKqsxWdnw8vaJzWZzqnH6559/ytMvX75cHj569OgyZQKckzuUrHVZuml1aWq1Wp72+++/r3BaIYS47bbb5OlLdj3w559/ysMDAwPl5gIl98MHH3wgT280GuXhO3bsEEIIkZKSIg/r0aOHPG3J77DkG8uioiKn2se7du2Shy9dulT07dtXmEwmpxrEjvK5WnbLli3LvE2sze83LS1NXrdOp3OqgVuy64MnnniizLq0Wq1ITEwUQth/G47jNCAgoNLviKgpuHz5stNxffz48UrnqU2Nyeeff14efs0118jD//Of/wgh7LXJHbXTSh6n7qoxefHiRTFt2jTRqlUrlzUFStZmrCz5javrU05OjvD19RUARK9evYQQ9ibVjtornTp1kucfPXq0PP+yZcvke4qSSQ3++c9/Vvp9lCy/qyR0YWFh8vjPPvus3G07ceKEPOz+++8XZ8+eLfd+prLkNyVrAJW8ZjlUVmMSgDh9+rQ8/IUXXpCHP/DAA0KI6tWYrGx4efukNveRYWFh8jUtMTHR5XWZiBqPympMvvvuu/L4tm3bysNL15h0qOgZqLxz8KFDh5zONY7ryu7du5269ti/f78QovL79yeeeMLp+u1YVsmm6V26dHFZZsd5UQjnGoubNm0SQjg/V1933XXl7tfqlsEVSZLklhlhYWFydyqdOnWS7zcc5+vZs2fLy92wYYPTc0dVPffcc2Wemxx/oaGhcldnNptNBAUFyeN++OEHl8urzbOQUqkUJ06ccFrexo0b5fGjRo1y+p3ExMQIwN4ioGQXN+RZrDFZj1QqFT777DP8+uuveOqpp9CzZ0+5NgUAnD17Fm+88QYA4MyZM/KbjNatW6NTp04ul+l48w/YO5/VaDTyZ0cH8KWncxg4cCCCgoLKXd7q1asxaNAgDBo0CIMHD0Zubi4AICsry6lD4pq4cuWK/H9/f/8Kp33wwQcB2Gvs9ezZE76+vujcuTNiY2PlZELVdeutt9Zovv79+8v/L7l/z58/7/LNXF1ISUlBRkYGAMBgMDjVPq3sO/fz83N6OxkcHCz/3/HmsTwlv6eqfP8l119yv3Xp0kWuGZKRkYGUlJQy85bcjpK1Ch2dZ4eEhFRa7pLrVKlU6N27t/zZUXsqNjYWs2bNwu+//w6z2VzmOyxv2SNHjoRaXbXcYVX5/Z4+fVped5s2bZy+l8q+044dOyI8PBwAoFQq5f1V2fdJ1FSUvsbU9vpVmZLHbMlrrOP8pVAo5OHuPk7NZjOuu+46fPjhh4iPj0d+fn6ZaWq7Tl9fX9x+++0AgIMHDyI+Ph4//vijvNwJEybI05Y8Zz3++OPyPcW0adPk4cePH69VeQoKCpxqZ1R0T9GuXTu5xuynn36KNm3awGg0YsCAAXjjjTdc7q+qqMk9RVBQENq2bSt/Lvm7KVnDt67V5j7y2muvlWuZVud+gogap+o839VUyXPR4cOH5evKoEGDsHfvXnmcq2uLq/v3kst79dVX5WWVPK87WqmVVjIhj6tzYMllO2o/VrZN1S2Dg0KhwPjx4wEAycnJ2LVrF44dOybvh7vvvls+X0+YMEH+/z333IOQkBCEh4fjzjvvxI8//ljhehwWL16MI0eOYO7cuejfv7/Tfk1JScHcuXMBAKmpqUhPTwdgT+pasrZlSbV5FmrXrh06dOjgNKzkdN9//73T7+T8+fMAACFEpfuV6g8Dkx7Qv39//Pvf/8bBgwdx9epV3HnnnfI4R8Zjd6isGrYjmFETpZudV0d2djb++usv+XPJQJkrL7/8Mj7//HPcc8896NChAxQKBY4fP4633noLN910E4qKiqpdhtpsu0Nl+9dRbd+hdLV2dyhdhsrKVDLIB8DpIlJZYLV79+7y//fs2VPVItZIyZuZksF7Pz+/MtNWNSBcet8UFBTggw8+AGDfD4sXL8bPP/+M3bt3y4HP8pZdnd9PbX+/tflOicjefYij6w2gauevksddyXN5Vc7j1Tl/uWudDhs3bsTly5cB2F9afPHFF2WagDleetZG6SZjjqZiJR+Mqqo29xMAsHfvXqdtquieQqlUYsuWLXjzzTcxcuRItGjRAnl5efj111/x7LPP4oknnqhRGerqnsIdvwl3l6mkktef6txPEFHjVPL6WtnzXV1zdW2p6bm6qKjI5Yur+jwHlleGksq7NgPOLw27dOmCAwcO4PHHH0f//v3h7++P5ORkbNy4ESNGjMD//d//ValMXbp0wUsvvYRff/0VqampmDFjhjzOVUxDoVBUel1xxVtjGuReDEzWo127diEnJ8dpWHh4OCZNmiR/dtx4tm3bVn6gOXfuXLnR/Pbt28v/P3TokFOQo2QfDCWnc3B1kJecbv78+RD2BElOfxaLpcxbieqYN28esrKyANgfGCt6g+QwduxYfPnllzhx4gTMZjPuvvtuAMBff/0lvxEp+QBY2YNXTU6KAPDbb7/J/y+5f2NiYuRlOh5K09LS5L4Mz58/X+53WJ1yA0BoaKjcj4nFYpH7MSldJlffeW2MGTNG/v8nn3yCI0eOlJnGbDbLD8Ul119yv/31119y7dvAwECEhoa6tZyu1mmz2bB//375c+vWrZGWlgar1QrAHnR97rnnMHToULRu3Vp+s1ee6v5+Kvv9tm3bVl7m2bNnkZaWJs9bl98pUVNR8vy1ZMkSl7Umk5OT5WO/ZHDR0d8RYO//r664Y50la6vMmDED9957L66//nr5XFdada8/DsOHD0dYWBgAe5/Gjr50r7vuOrRq1UqeruQ56+eff3Z5T3H27Nkqr7e0/Px8PPfcc/Ln6667Ds2bNy93eiEEjEYjYmNj8f333+PChQtITk6Wy+zofxOo+3uK9PR0nDlzRv5c8lzvCKTX5DfhKEtVv8/a3EcSETls2rQJcXFx8ueS1113KnkuGjJkSLnPqg8//HCZeSt79l29enW5y3PUMKxpWbds2VKl6WpTho4dO6JXr14A7NezDRs2AACio6OdancKIXDNNdfg7bffxq+//orMzEw5iClJEjZt2lThen777bcyL8j8/f3x0EMPyZ8dMY2QkBA5gGu1WsutkVmbZ6HKvtdJkyaVu09HjBhR4bZS/WHVmnr0wQcfYPPmzbjnnnswZMgQREVFISkpySnBR9++fQHYm/iMGjUKmzdvhs1mw6hRo/Diiy8iOjoaR48excGDB/Hpp5+iR48e6NSpE44fP46EhARMmDABkydPxr59+7Bx40YAgFarxV133VWlMt59992YPXs28vPzsXjxYigUCgwYMAC5ubmIj4/Hzz//jLy8PGzfvr3K23369Gns2rULV69exeeff45vv/1WHrdw4cIyNb5KGzhwIHr27Il+/fqhWbNmMJvNOHbsmDze8fao5HJ++eUXfP/99zCZTGjfvr38AFVbc+bMgVqthq+vL+bMmSMPHz16tPz/tm3b4sCBA8jLy8P48eMxePBgvPvuu2VqUDqULPeHH36Im2++GT4+PnKzv9KUSiXGjh2LlStXArC/AZs/fz4yMjIwf/58ebpx48bValtLmzx5MlauXCk/uAwdOhRPP/00+vXrh/z8fOzduxf/+c9/8N5776F58+YYP368/F3PmzcPOp0OISEhWLhwobzMMWPG1DhIXJlffvkFsbGxuPHGG7F+/Xo5kVR4eDiuvfZaqFQq6PV6WK1W/Pnnn/jggw8QHh6Ol19+2S01ihyq8vsNDg7GiBEjsHXrVuTn5+Pee+/Fk08+ibNnz+Ldd9+Vp3X3d0rUVDz99NNYu3YtLl68iMzMTPTv3x9PP/00unbtCrPZjLi4OKxevRpxcXFlmtguWbIERqMRZ86cwapVq+qsjCXX+dlnn6FNmzbIycnB66+/XuVltGzZUv7/qlWr0Lp1a5w5cwavvPKKy+lLXn+2bt2KwYMHQ6/Xo2vXrhU2w1Or1Rg7diyWLVvmVCuiZG0NwH59cgQt77//frzwwgto164dUlJScPr0aWzevBmjRo1yunZVZv/+/YiPj8epU6fw7rvvyi/JNBoN3nzzzQrnvXLlCoYPH457770XnTt3Rnh4OOLj4+UuRUrWRim5b77++mu0atUKGo0Gffv2rdEDqivjx4/Hiy++iMuXL2Pp0qXycMc9RatWraBUKiFJEn766Sc8//zzMJlMWLx4cbnLDAwMRHp6Oq5evYq1a9eiZcuWCA8PR7t27VxO7+77SCJqGpKTk/HLL78gPT0d27dvl1shAfbuLW688cY6WW/37t3RpUsX/PXXX9i5cycmTpyIe+65BxqNBufPn8dvv/2GjRs3yt1eVWb8+PF4++23AQBPPvkk0tPT0a1bN2RmZuLs2bPYtm0bWrZsWaPr/z333CM/V+/Zswd33XUXJk6cCEmSsH37dgwcOBATJkxwaxnuu+8+HDx4EImJifILrfHjxzs9b73++uuIi4vDLbfcghYtWsDX1xc//PCDPL6ympnffvst3nrrLdxxxx0YNmwYWrZsiaysLKfrmCOmoVQqMX78eKxYsUIuy9y5c9GxY0ecO3cO3377LbZs2eL2Z6Ebb7wRoaGhSElJwSeffIKgoCDceOONsNlsOH/+PPbs2YM//vjD6ZmMPKyuOq+ksipKfIPiTscTEhLk6S9cuCCaN2/uctqSHeDv27dP7ki/9J9CoRDvvvuuPG1lCWKEEOLDDz+UE+9Utu7ylOwYuLxyzZ0712me8jr4b9OmTbnL6dy5s9y5b2FhoZxopOSfo8Pk8jqid6hK8pt27dqVWX5kZKRITk6Wp3///ffLTGM0Gp2+y5IdPJdMWOP4c3RaX94+SUtLc0pcU/pv7NixclIZIaqfkKc8ly9fFr169arwu924caMQwt4J85gxY8qdrmPHjnKyp4rKUl6H2a62qeR32LVrV5fr/fTTT+XpZ8yYUWZ8u3btnBIpuFq2qyQRtf39nj171uXv1/H33HPPVbquivYXUVN39OhR0bp16wrPX47kYAUFBU4Jsxx/jk7kS19Dy7u+VPe8VrLjflfrrCz5TXZ2toiMjCyzjIEDB7osd0pKissEOY5tqOgasW/fPqd5NBqNyw70J06cWOE+d3U+La2i+R3X2G+++cZpHlfn7EuXLlW4nIcfflie/8iRIy479nfsh8rOtZUlv/H39xehoaFlln/jjTc6Xb/HjRtX4W+i9HW9ZMKa0t95edcxd91HllcmImocSl53yvu75ZZbRHZ2ttN87kx+I4QQBw4ckBOulffnUNn9uxBCzJ07t8JllTzXlVfm8spb0XN1yemqU4aKXL16VahUKqd5jxw54jTNyy+/XO56lEql+OWXXypcR8lkbeVdk0smZ83MzBTdunVzOW3J64W7noUcNm/e7PIeh9cq78Sm3PVo/vz5eP3113HTTTehTZs28PX1hVarRZs2bfDII49g//79iIiIkKdv0aIFDh06hGeffRYdO3aEXq+H0WhEjx495KaggL1D2AMHDmDSpElo1qwZ1Go1AgMDMXLkSGzbtg2PPPJItco5depU7Nq1C3feeSfCw8OhVqsRHh6Ofv36Ye7cuU5vLapKrVYjKCgI3bt3x8MPP4xDhw7hpZdeqtK8c+bMwejRo9GyZUsYDAZoNBrExMRg+vTp+Omnn6BSqeR1fPvtt7j++uthMpmqXcaq2LBhAx566CEEBwfDx8cHo0aNwq5du5yaI0+dOhVz5sxBWFgYfHx8cMMNN2D37t1o06aNy2U+/PDDeO6559CiRQunpmMVCQoKwq+//oo5c+agQ4cO0Ol08PX1Rd++ffHee+9h3bp1dVITsVmzZvj111/x0UcfYfjw4QgJCYFGo0FUVBSGDBmCFStWYNiwYQDs1erXrVuHlStXol+/fvD19YVOp0P79u0xe/Zs/Prrr5XWlq2NO++8E1988QWuueYaaLVadOjQAZ9++qlTjZ5///vfmDVrFiIjI2E0GnHbbbdhx44d8PHxcVs5qvr7bd26NQ4ePIiZM2fKNXP8/PwwePBgfPHFFxXWkCGiynXu3BlHjhzBkiVLcP311yMoKAharRbR0dEYMWIEPv74Y3Tu3BmAvfbdpk2bMGDAAGi1WjRv3hwLFy7EsmXL6rSMa9euxYgRI6DX6xEaGoonnnhCbopVFSaTCdu3b8cNN9wAo9GIZs2a4aWXXir3ehsSEoJNmzahZ8+e1T7v9evXz6mp1KhRo5w6q3f4+OOP8cknn2DIkCHw9/eHVqtFixYtMGzYMCxbtgyPPvpotdarUCig1WoRERGBAQMGYO7cuTh9+jRuu+22SucNCgrC/PnzMWTIEERGRkKj0cDHxwfdunXDK6+8guXLl8vTdu3aFZ988gk6derkthqSJQUEBGD37t0YOXIkfH19ERQUhOnTp+O///2v0/V7+fLluOeee+Dr6wt/f39MnDgRu3btKne577zzDu69995qdZPi7vtIImoalEql3DrtnnvuwXfffYfvvvuuzp7DHHr16oXDhw9j+vTpaN26NbRaLQICAtClSxdMnz4dO3bsqNbyXnrpJfzvf//DyJEjERwcDI1Gg2bNmuH666/H4sWLnVp7VdfUqVOxe/dup+fqsLAwjBo1yqkfTneVITIyEjfccIP8uVu3bujatavTNDfffDMefvhhdOnSBYGBgVCpVAgKCsJNN92EH374AQMHDqxwHdOnT8fy5ctx6623on379jCZTNBoNGjRogXuv/9+/P77707JWf39/bF37168/PLL6N69O3x8fGAwGNCpUydMnDhRns7dz0I333wz9u/fj/vvvx/NmzeHRqNBSEgIevTogdjY2GrdX1HdUwjBHqqJqHFYs2YNpkyZAsD+ImDBggWeLRARERERERERlYs1JomIiIiIiIiIiKjeMTBJRERERERERERE9Y6BSSIiIiIiIiIiIqp37GOSiIiIiIiIiIiI6h1rTBIREREREREREVG9U3u6APVNkiRcvXoVJpMJCoXC08UhImpUhBAwm82IioqCUsl3X96E1z8iorrD65/34vWPiKhuuOva1+QCk1evXkV0dLSni0FE1KhdunQJzZs393QxqARe/4iI6h6vf96H1z8iorpV22tfkwtMmkwmAPYd5+fn5+HSEBE1LtnZ2YiOjpbPteQ96vr6J0kSUlJSEBoa2uBrC3FbvBO3xTvVals6dgQSEoDISODEibopYDXUZlt4/fNetbn+NaZjtSaa8vZz27nt3PbKueva1+QCk47q+35+fgxMEhHVETaV8j51ff2TJAlWqxV+fn4N/kaO2+KduC3eqVbb4pheqQS84L7cHd8Lr3/epzbXv8Z0rNZEU95+bju3ndtedbW99jWtPU1ERERERERERERegYFJIiIiIiIiIiIiqncMTBIREREREREREVG9a3J9TBIREREREVHD8b///Q9PPfUUJEnCc889h6lTp3q6SEQNms1mQ2FhoctxkiShsLAQVqu1SfazyG133natVlvn+4KBSSIiIiIiqn/ffAMUFABaradLQl6sqKgIsbGx+Pnnn+Hv74/evXvjjjvuQHBwsKeLRtTgCCGQmJiIzMzMCqeRJAlms7nJJfTitpfddqVSiVatWkFbh9dqjwYmd+3ahTfeeAMHDhxAQkICNm7ciNtvv73CeeLi4hAbG4ujR48iOjoaL774IiZPnlwv5SUiIqqJyq53QgjMnz8fH374ITIzMzFw4EC89957aNeunTxNeno6HnvsMXz33XdQKpW466678Pbbb8NoNHpgi4iI3KB3b0+XgBqA3377Dddccw2aNWsGABg1ahS2bduGcePG1dk6C4okHLyYgf3xaSjIyYTWmI0+rYLRq0UgtOqmVYuKGhdHUDIsLAwGg8Fl8E0IgaKiIqjV6iYZnOO2/73tkiTh6tWrSEhIQIsWLepsn3g0MGmxWNC9e3c88MADuPPOOyudPj4+HrfccgumT5+OtWvXYseOHZg6dSoiIyMxYsSIeigxERFR9VV2vXv99dexbNkyfPzxx2jVqhXmzp2LESNG4NixY9Dr9QCACRMmICEhAdu3b0dhYSGmTJmChx56COvWravvzSEiIqqyqlRGWbFiBd544w0kJiaie/fuWL58Ofr16wcAuHr1qhyUBIBmzZrhypUrdVbegiIJ63+/iF/PpUGtAKL0Es4nmXEs0YxTSWaM7duCwUlqkGw2mxyUrKjGMYNz3PaS2x4aGoqrV6+iqKgIGo2mTtbt0cDkqFGjMGrUqCpPv3LlSrRq1QpvvvkmAKBTp0745Zdf8NZbb5UbmMzPz0d+fr78OTs7G4A98itJUi1KT0REpfG86lpF1zshBJYuXYoXX3wRo0ePBgB88sknCA8Px6ZNmzB27FgcP34cW7duxe+//44+ffoAAJYvX46bb74Z//73vxEVFVVv20JE1FgIIZCTX4QUcz5SzPlIzrbimiBPl6rxqezl3BdffIHY2FisXLkS/fv3x9KlSzFixAicPHkSYWFh1V5fbZ//DlxIx75zqYjy84GvVgWDLQc6X1/kFNiw71wq2oUZ0b9V0/ihSJIkN+9sahrjtufn50MIAR8fHwghKpzWMb6y6Rojbrvztms0GgghUFhYCJVK5TS9u46PBtXH5N69ezF8+HCnYSNGjMCsWbPKnWfRokVYuHBhmeEpKSmwWq3uLiIReZHc3FycOXPG5Tir1YpLly4hOjparpFWUtu2bWEwGOq6iI2O2Wz2dBEanPj4eCQmJjpd3/z9/dG/f3/s3bsXY8eOxd69exEQECAHJQFg+PDhUCqV2LdvH+64444yy63vF3ON6Qae2+KduC3eqVbb8r//AXl5gI8P8M9/uq1MBUUSUnPykZKTj1RzPlJyCuyBx+IAZGqO/d+UnHxYC53L/en4jmgRVf1taQzfZV2prDLKkiVLMG3aNEyZMgWAvTLK5s2bsWrVKsyePRtRUVFONSSvXLki16Z0pbbPf0fPXkWYOh+hagUgCeiEFZAAg1oBSZOA0eePAAC+7ElEQVSPo2cvopVvUaXLaQwkSUJWVhaEEE0yEUhj2/bCwkJIkgSbzYaiovJ/w0II2Gw2AGiStQa57c7bbrPZIEkS0tLSytSYdNezX4MKTCYmJiI8PNxpWHh4OLKzs5GXlwcfH58y88yZMwexsbHy5+zsbERHRyM0NBR+fn51XubGJjc3FydOnCgz3Gq14vz584iJiXEZ5AGAjh07MtBD9ergwYM17ubh999/R0xMjHsL1ASUd/xT+RITEwHA5fXNMS4xMbFMrRG1Wo2goCB5mtLq+8VcY7qB57Z4J26Ld6rNtoROnw5VQgJskZFIOXiw4vUIgWyrDWmWQqTlFtr/lf9fhPTcvz9nW2013p4LyZloE+JT7W3hi7maKSgowIEDBzBnzhx5mFKpxPDhw7F3714AQL9+/fDXX3/hypUr8Pf3x/fff4+5c+eWu8zaPv9dzktFnlqFXJUeEAIQQK7SCCgUyFWpcTlPVaOanA2RJElQKBQIDQ1t8Oeq6mqM2261WmE2m6FWq6FWVx4Kqqtmuw0Bt/1varUaSqUSwcHBZZ713PXs16ACkzWh0+mg0+nKDFcqlY3mBFOfTp06hb59+9Zo3gMHDqBXr15uLhFR+Tp37owDBw64HHf8+HHcd999+Oyzz9CpU6cy4zt27MhzRA1wn3mP+n4x15hu4Lkt3onb4p1qsy2K4ukFFLiQqy6uzVgg12Z0/JtaPLxIcl+zugAfDcJMOoSYdAg16RBq1CHEqEHHCA3CwsKqvS18MVczqampsNlsLl/OOSpDqNVqvPnmm/jHP/4BSZLw7LPPVtg/nuP5b8WKFVixYoVcA6iqz38hJh1OJpoBv+IaQwqF/JdbYEN0oKHBH7fVoVAomuyzc2PbdqVSCYVCIf+VRwghj2+KtQa57c7b7vi9uDoW3HVsNKjAZEREBJKSkpyGJSUlwc/Pz2VtSXK/jh07ugz0VBbkccxLVJ8MBkOlwfBOnToxYE4eFRERAcB+PYuMjJSHJyUloUePHvI0ycnJTvMVFRUhPT1dnr80T7yYa0w38NwW78Rt8U6lt6XQJiFNDjBa5T4cnQKO5nysz7YiAkCKOR9jPthX63LoNUqEmfRyoDHUVOKvxOdgoxY6tarM/JIkITk5uUbfS2P4Hr3Zbbfdhttuu61a88yYMQMzZsxAdnY2/P39qzxfn5ggHEvIRk5+EYzav38nOflFsEkCfWKaRv+SRFR1CxYswKZNm3D48GFPF6VBalCByQEDBmDLli1Ow7Zv344BAwZ4qERNT2WBHgZ5iIiqp1WrVoiIiMCOHTvkQGR2djb27duHRx55BID9+peZmYkDBw6gd+/eAICffvoJkiShf//+nio6ETUhQghk5RWWCTAmZ1txKTUL5sLzcm3H9NwCVCVnQFWmUSqAEKPrAGPJz2F+evhqVU2uhktDFxISApVK5bLySXkv3qqqdI3JqurVIhCnksz2rNxKIEpXiKv5OSiSgGtbB6NXi8BalYuIambFihV44403kJiYiO7du2P58uUV9jf74Ycf4pNPPsFff/0FAOjduzdeffXVCudhgNEzPBqYzMnJcUpMER8fj8OHDyMoKAgtWrTAnDlzcOXKFXzyyScAgOnTp+Odd97Bs88+iwceeAA//fQTvvzyS2zevNlTm9BonT59ulp95Rw/ftzp36oymUxo165dteYhcoW/WfJmlV3vZs2ahVdeeQXt2rVDq1atMHfuXERFReH2228HYH/pM3LkSEybNg0rV65EYWEhZs6cibFjxzIjNxHVirXQ5pQYpmSNxpJNqVPM+SiwuS/Bi59eDbXKHkTUa1V4YGArOdgYViLwGGjQQqVksLGx0mq16N27N3bs2CFf8yRJwo4dOzBz5sxaLbumNSa1aiXG9m2B9uEm7I9PQ0FOJtqHmdCnlT0oqVWzdixRffviiy8QGxuLlStXon///li6dClGjBiBkydPltvna1xcHMaNG4frrrsOer0er732Gm666SYcPXoUzZo1q+ctqFxhYWGT7dvSo4HJ/fv34x//+If82dEX1qRJk7BmzRokJCTg4sWL8vhWrVph8+bNePLJJ/H222+jefPm+Oijj2qc3IJcO336NNq3b1+jee+7775qz3Pq1CkGeqhW+Jslb1fZ9e7ZZ5+FxWLBQw89hMzMTFx//fXYunWrU59la9euxcyZMzFs2DAolUrcddddWLZsWb1vCxF5P5skkGYpG2B0+lz8Z853X3ZhrVrpskZjmJ9zTccQow56jQr4SAdkAYE+Gsy7tbPbykHepbKXc7GxsZg0aRL69OmDfv36YenSpbBYLHKW7pqqaY1JwP5bvrZ1MPrFBCI5OblG/Y4SkfssWbIE06ZNk88LK1euxObNm7Fq1SrMnj3b5Txr1651+vzRRx/h66+/xo4dOzBx4sQy069ZswYvvfQSgL+751i9ejUmT56Mixcv4rHHHsOOHTugVCoxcuRILF++vEz/uKXX9+abbyI+Ph4xMTF4/PHH8eijjwIAzp8/j1atWmH9+vV49913sW/fPqxcuRK33norZs6ciV27diEjIwNt2rTB888/j3HjxsnLHTp0KLp16wa9Xo+PPvoIWq0W06dPx4IFC+RpMjMz8dxzz2HTpk3IyspC27ZtsXjxYvzzn/8EAPzyyy+YM2cO9u/fj5CQENxxxx149dVXXXYDVR88GpgcOnQoRAVtONasWeNynkOHDtVhqchR66yi/iJLy8vLk7NyV7W/T0e/lMxiSLXF3yx5u8qudwqFAi+99JJ8M+RKUFAQ1q1bVxfFI6IGJK/AhiOXM8vUcEwuEWxMt+TDXXliFAog2Ffr1Jxa7sfRpEOIrwbKAgs6toyEv0HLptRURmUv58aMGYOUlBTMmzcPiYmJ6NGjB7Zu3VrhA39V1LTGJFGTtGSJ/a9YuYGiXr2Ab791HnbbbcDBg5WvIzbW/ldNBQUFOHDgAObMmSMPUyqVGD58OPbu3Vvl5eTm5qKwsBBBQa77iR0zZgz+/PNPbN26FT/++CMUCgX8/f0hSRJGjx4No9GInTt3oqioCDNmzMCYMWMQFxfncllr167FvHnz8M4776Bnz544dOgQpk2bBl9fX0yaNEmebvbs2XjzzTfRs2dP6PV6WK1W9O7dG8899xz8/PywefNm3H///WjTpo1TE/SPP/4YsbGx2LdvH/bu3YvJkydj4MCBuPHGGyFJEkaNGgWz2YzPPvsMbdq0wbFjx6BS2fvMPXv2LEaOHIlXXnkFq1atQkpKCmbOnInHHnsMH3zwQZX3pzs1qD4mqX5Vt7/IgQMH1mFpiCrH3ywRETVmlvwijF6xB2eSc2q9LKNOXW5yGLmmo0mHIF8t1Krya4rZE8bY4OejYVCSXKrs5RwAzJw5s9ZNt4moFrKzgStXAAAVnsmjo8sOS0mR5610HTWQmpoKm81W5mVFeHg4Tpw4UeXlPPfcc4iKisLw4cNdjvfx8YHRaIRarUZERIR8Tdu+fTv+/PNPxMfHI7p4+z/55BNcc801+P3339G3b98yy5o/fz7efPNN3HnnnQDsrX+PHTuG999/3ykwOWvWLHkah6efflr+/2OPPYYffvgBX375pVNgslu3bpg/fz4AoF27dnjnnXewY8cO3Hjjjfjxxx/x22+/4fjx43KrwtatW8vzLlq0CBMmTMCsWbPk+ZctW4YhQ4Zg2bJlMBqNVduhbsTAJBERERFRA7Do++MVBiU1KkWF2ajtn/UIMWlh0PIxgBq32jTlJmpy/PyA4n4XS75GKBOkDA0tO29oqDxvpevwkMWLF2P9+vWIi4tz6iqpKo4fP47o6Gg5KAkAnTt3RkBAAI4fP14mMGmxWHD27Fk8+OCDmDZtmjy8qKioTO3tPn36OH222Wx49dVX8eWXX+LKlSsoKChAfn4+DAaD03TdunVz+hwZGYnk5GQAwOHDh9G8efNyuzr7448/cOTIEaem7kIISJKE+Ph4dO3atbJd4na8IyEiIiIi8nK7TqXgs1/tfa/7aFSYNbwdwv30TgHIAEMDq7VoNAImk/1fIjdjU26iaijZzFoIFBUVQa1W2/vzqEzppt1uFhISApVKhaSkJKfhSUlJiIiIqHT+f//731i8eDF+/PHHMgG9upCTY3+B+OGHH6J///5O4xzNqR18fX2dPr/xxht4++23sXTpUnTt2hW+vr6YNWsWCgoKnKYrnSRHoVBAkuwJ6irrpiwnJwcPP/wwHn/8cafhQgiPJdVkYJKIGoUIowI+maeAq3XXMblP5ilEGBvQAx8RETUKWXmFeParI/Ln52/phPuvbenBErlJNZrgERFR06TVatG7d2/s2LEDt99+OwB7NyI7duyotAuI119/Hf/617/www8/lKmdWN66Stey7tSpEy5duoRLly7JtSaPHTuGzMxMdO5cNnFbeHg4oqKicO7cOUyYMKGKW2m3Z88ejB49Wk7QKkkSTp065XI95enWrRsuX76MU6dOuaw12atXLxw7dgxt27Z1Gi6KA9KewMAkETUKD/fWotOuh4FddbeOTsXrISIiqk8LvzuKxGwrAGBQuxDc17+Fh0tE5P3YlJuo8YiNjcWkSZPQp08f9OvXD0uXLoXFYpGzdAPAxIkT0axZMyxatAgA8Nprr2HevHlYt24dYmJikJiYCAAwGo3l9qMYExOD8+fP4/Dhw4iOjobJZMLw4cPRtWtXTJgwAUuXLkVRUREeffRRDBkypNxg58KFC/H444/D398fI0eORH5+Pvbv34+MjAw5AZgr7dq1w1dffYX/+7//Q2BgIJYsWYKkpKRqBSaHDBmCwYMH46677sKSJUvQtm1bnDhxAgqFAiNHjsRzzz2Ha6+9FjNnzsTUqVPh6+uLY8eOYdu2bVi6dGmV1+NODEwSUaPw/oECjJm3Bp06dqyzdRw/cQLvvzket9XZGoiIiJz9cDQR/z1oTypg0qnx2l3dGlZzbSIPYVNuosZjzJgxSElJwbx585CYmIgePXpg69atTglxLl68CKXy79Zz7733HgoKCnD33Xc7LWv+/PlYsGCBy/Xcdddd+Prrr3HDDTcgMzMTq1evxuTJk/HNN9/gsccew+DBg6FUKjFy5EgsX7683PJOnToVBoMBb7zxBp555hn4+vqia9eucsKZ8rz44os4d+4cRowYAYPBgIceegi33347srKyKt9JJXz99dd4+umnMW7cOFgsFrRt2xaLFy8GYK9RuXPnTrzwwgsYNGgQhBBo06YN7r333mqtw50YmCSX2CyWGprEHIG8gPZAVI86W0deooTEnIqzShIREblLWk4+Xtj4p/x5/m3XICqg4r6jiIiIGqOZM2dW2HQ7Li7O6fP58+ervQ6dTocvvvgCarXa6SVgixYt8M0335Q734IFC8oEO8ePH4/x48e7nD4mJgZClH2uDAoKwqZNmyosY+ntBFBmnqCgIKxatarcZfTt2xfbtm1zGsam3OR12CyWiIiIyHOEEHhx019IzbF3eD+8Uzju6lWFrKcNyTPPABkZQGAg8MYbni4NEREReQADk+QSm8USERERec6O48n4/i97f1iBBg1evbNL42vC/fnnwJUrQLNmDEyS27GPSSKihoGBSXKJzWKJiIiIPOfnk8ny/+ffeg3CTHoPloao4WEfk0REDUPddSBIREREREQ1cikjT/7/oHYhHiwJERERUd1hYJKIiIiIyMtczsgFAPhoVAjyZZ/cRETkHq6SrhCVpz5+LwxMEhERERF5ESEErhTXmGwe6NP4+pYkqgcrVqxA586d0bdvX08XhcgraDQaAEBubq6HS0INSUGBPQmfSqWqs3Wwj0kiIiIiIi+SkpOP/CIJgD0wSUTVxz4miZypVCoEBAQgOdneh7HBYHD54ksIgaKiIqjV6ib3Yozb7rztkiQhJSUFBoMBanXdhQ8ZmCQiIiIi8iKXS/Qv2TzQ4MGSEBFRYxIREQEAcnDSFSEEJEmCUqlsksE5brvztiuVSrRo0aJO9wcDk0REREREXuRS+t/N7FhjkoiI3EWhUCAyMhJhYWEoLCx0OY0kSUhLS0NwcDCUyqbV+x+3vey2a7XaOt8XDEwSERE1IYnmRFgUFvmzXq1HoE8giqQipFhSykwfaYoEAKTmpqLQ5nwDG6APgI/GB5YCCzLzMpFqSYXNbINSqYRWpUWwIRiSkJCUk1RmuWG+YVApVUjPS0d+Ub7TOJPOBKPWiLzCPGRaM53GqZVqhPqGAgASzAlllhtiCIFGpUGmNRN5hXlO43y1vvDT+SG/KB/peelO45QKJcKN4QCApJwkJFuS5W0BgCCfIOjUOmTnZ8NSYHGa10fjgwB9AApthUjNTS13H6ZYUlAkFbnchzkFOTDnm53G6dQ6BPkEwSbZkGwpW7Mh3BgOpUKJtNw0FNgKnMb56fzgq/VFXmEekixJTtuiUWkQYggpdx+G+oZCrVQjIy8D1iKr0zij1giTzuRyH6qUKoT5hsn7UBKS0/hgQzC0Kq3LfWjQGOCv93e5DxUKBSKM9hoeqXmpTtsCAIE+gdCr9S73oeP3Xd4+jDBGQKFQuNyH/np/GDQG5BbmIsua5TTO8fsWQiAxJ7HMch2/b1f70KQzwaA2wFpkRYI5wWlbHL/vyxl5sCEDAgIGH7P8PTl+31nWLOQWOvcR5vh9F9gKkJab5jSu5O872ZIMm2RzGu/4fZvzzcgpyHG5D8s7R4T72pebmpsKm3BebslzRHZ+dtl9CEBSAEk+NqDUb9ET5wgftT0InF+Uj8x85+WWPkeU/n2ri/hYRUQNh0qlKrfPQEmSoNFooNfrm2Rwjtte/9vOKygREVETsvrwauh8dfLnbuHdcGenO5Gdn433D7xfZvoFQxcAADad2ITL2Zedxt3Z6U50C++GoylHsfnUZlgsFvj6+kKhUKBNYBvc3/1+FNoKXS73meuega/WFz+c+QEn0046jRvRZgQGRA/AuYxz2HBsg9O4SGMkHu7zMADgo4MflQmEPNr3UYT5hmHXhV04mHDQadz1La7H8NbDkZCTgDWH1ziN89P5IXZALABg3V/rkJCeIG8LAEzuMRkxATH47cpv+OXiL07z9orshds63IYMa0aZbVUpVJg7ZC4A4L/H/4uEHOdAyT2d78E1Ydfgz6Q/8cPZH5zGdQjugHFdx8FaZHW5D+dcPwc6tQ5bTm/B2YyzTuNubncz+jXrh9Ppp/HZ8c+ctqW5X3NM7TUVAFwu9/H+jyPIJwg/n/8ZR5KOOI0bGjMUQ2OG4lL2JXx25DOncUE+QXi8/+MAgI//+LhM4OzBng8i2j8aey/txd7Le53G9Y3qi1va34LU3NQyZdKpdJgzaA4A4Luz38F63urUnGhcl3HoENIBhxIOYUf8Dqd5O4d2xr3X3AtLocXltr44+EWoFWp8d+o7nM887zTutg63oVdkL5xIPYFvT37rNC4mIAaTe0yGTdhcLjd2QCz8dH7Yfm47jqUccxo3rNUwDIweiMs5l7H99HanbQk1hGJGvxk4lWRGjno7BAqxN/EozubqAQAP934YkaZI/HLxF/x+9Xen5Q5oPgAj2o5AUk4S/nPoP07jDBoDnh34LABg/V/rywSV7+t2H9oGtcWBhAOIOx/nNK6yc8S8wfMAAJtObsJV81WncSXPEVtOb3Ea1yawDe6/5RYUZqTg/RYXgFLL9sQ54rrm16GbsRsSchLwyZFPnMaVPEes/XNtmUDrXa3vKrNviIiIqHIK0cRyxTs6P87KyoKfn5+ni+OVDh48iN69e+PAgQPo1atXg18PNX78zXoPnmO9l+O7OXn5JEx+Jnm4W2tMpqYiJCSkwdeYTMhOQHJKsrwtQMOtMWnJt+DM5TNO29JQa0xKkoRjF44hMCiwUdSYvHj1IjQmjcsak9e/9hMuZFyFTqPAT08NhUZln8Zba0wmJydDaVRWv8akl50jfNQ+sGZZ4R/kX/0ak4VqhAWH8frnheR7k8hI+FVWC6hXL+Dbv19ESJKEglGjoDt6FJX2rhYba/9zMJuBTp2qVshvvgF69/778//+B0yfXvl8RiNw4oTzsGeeAT7/vPJ5b7kFeL/Uy4Y+fYDEv89pAvi7z7mS073+OjB+/N+fT54Ehg2rfJ0A8PvvQGTk358/+AB46aXK52vfHvjpJ+dhEyYAO3dWPu+0acD8+c7DmjevcBbHtis++wzKG274e0RcHHDffZWvEwAuO7/QxcKFwIcfVj7fkCHA2rXOw264ATh1qvJ5580DHnro788JCUBVM9Pv2AF06ABJkpCcnIywH3+EcvbsyueLiAD273ce9vDDwObNlc87bhzwxhvOwzp2BHJyXE9f0sqVwD//+ffnAweA0aMrnw8Ajh8HTH/fD2PJEmDJkvJ/8w6lzhEAgNtuAw4edDW1My8/R5TZ9iqcI7IlCf4JCbW+9rHGJBERURMSYYqAn6nsjYNaqZYDaK44Almu+Gp94aP2gSpPhTBTmFOgRalQVrjcIJ+gcsf5aHzgoym/f72KlhugD0CAPsDlOJ1aV+G84cZwKHIVZbYFsAf8/HSub7w0Kk2Fy3UES1wxao0wao0ux6mUqgqXG2wILnecj8YH4b7hLrcFqHgfBvoEljuuKvuwPLXZhyE+IeVuS13tQ4PGAIPGdQIahUJRo30oSRL0ar3LbUk2W3E5Iw8qBKJXsyC0CGhWZn5/vT/89a6zDGtV2grL5Ageu2LSmWDSmVyOK+8cIUn2AF2IIaTcpl++Wl/4an1djvOmc4QkSbDCav99a6v3+87OznYxJXnSihUrsGLFCthsxQHzhLKB6jKio8sMUqalQXHlSuXzlv4NCAFUZT4AKHB+MYK8vKrNa3JxvGZkVG3e9PSywxITneZVAHDZ2DfX+cUIioqqvq025xcYyMmp2ryuMqunplZt3qysssMqmc+x7VK+84sR5OdXfVtdlaMq86aWfcmJpKSqzVs6oGezVb28Rc4vT5GbW/NtTU+v2rwZGWWHXb1qD9pVJs/55RIKCqpe3tL187KzgStXyv/NO7g4RyAlpWrr9fJzRJltr8I5wl0YmCSiBi+3+OboYFXeVBXLy8vD+fPnERMTAx+fqiUWOH78eI3KR0REVFUHL2TK/+/ZMsBj5SBq6GbMmIEZM2bINSYRGQlUVmMytOwLJCk4GKJZs8prTJauLaRQAM3KvlhwSat1/uzjU7V5jS5exgQGVm3eIBdB/+KMzQ7l1h4zlHpZo1ZXfVtL92toNFZt3nAXL7xCQqo2r6ugZiXzyTUmdTrnETpd1bfVVTmqMm+Ii5fB4eGuA6yllf5NqFRVL6+6VHjIYKjavKV+NwDsv6+qzBvo4gVeVFTVakyWfobTaqu+raUzTPv5Ac2aVV5j0sU5AqGhVVuvl58jymx7Fc4RkKSqvfSpBJtyUxlsFksNzUcffYRp06bV2/pOnTqFdu3a1dv6GhKeY71XXX83crOfMNe12RoSbot3airbsmjLcby/6xwA4IP7e+Oma1w88HmRpvK9VIbXP+9Vm++mMf2+a6Ipbz+3ndvOba+cu659rDFJZbD2GTU0t99+OwCgY8eOMJR+g1uO48eP47777sNnn32GTlXt2wOAyWRiUJKIiOrMgQt/N2vr1bL85vSNgqOvKlf9kxEREVGTwMAklXGiuHPU+qqBZnLV7wFRNYSEhGDq1Kk1mrdTp06ssUtERF6hoEjCkSv2pnotggwIMeoqmaOBq6O+qoiIiKjhYGCSyqio9pmjZmRp8fHxmDt3Ll5++WW0atXK5XJd1aZk7TOqS7m5uXKgvTRHjd3yau5Wp/YlERGROxxLyEZBkT2ZTO/GXluSiIiICAxMkgsV1T47ePAg7rvvvnLnnTt3brnj2Jck1bcTJ06gd+/eFU5T3u+Zv1ciIqpvW/78uwN5BiaJ/nbHHXcgLi4Ow4YNw1dffeXp4hARkRsxMEnV0rFjRxw4cKDM8Kr0MdmxY8e6Lh6Rk/J+r0Dlv1n+XomIqD7lF9nw1YHLAACtSombu0Z6uERE3uOJJ57AAw88gI8//tjTRSEiIjdjYJKqxWAwlFuLbODAgfVcGqKKVfR7BfibJSIi7/HD0SSkWwoAACO6RCDIV+vhEhF5j6FDhyIuLs7TxSAiojrQtPKfExERERF5oXX7Lsj/H9+vhQdLQlQ9u3btwq233oqoqCgoFAps2rSpzDQrVqxATEwM9Ho9+vfvj99++63+C0pERF6JNSaJiIiIiDzobEoOfj2XDgBoHeqLa1sHebhERFVnsVjQvXt3PPDAA7jzzjvLjP/iiy8QGxuLlStXon///li6dClGjBiBkydPIiwsDADQo0cPFBUVlZl327ZtiIqKqlZ58vPzkZ+fL3/Ozs4GAEiSBEmSqrUsSZIghKj2fI1FU95+bju3vampyba7az8xMElERERE5EGf77so/398vxZQKBQeLA1R9YwaNQqjRo0qd/ySJUswbdo0TJkyBQCwcuVKbN68GatWrcLs2bMBAIcPH3ZbeRYtWoSFCxeWGZ6SkgKr1VqtZUmShKysLAghoFQ2vcaGTXn7ue3cdm575cxms1vWzcAkERFROc6cOYOzZ89i8ODB8PHxgRCCAQMicitroQ1fH/w76c2dvZp7uERE7lNQUIADBw5gzpw58jClUonhw4dj7969dbLOOXPmIDY2Vv6cnZ2N6OhohIaGws/Pr1rLkiQJCoUCoaGhTS5IATTt7ee2c9u57ZXT6/VuWTcDk0RERKWkpaVhzJgx+Omnn6BQKHD69Gm0bt0aDz74IAIDA/Hmm296uohE1Ej8cDQRGbmFAIBRXZtY0pvXXwdycwGDwdMloTqSmpoKm82G8PBwp+Hh4eE4ceJElZczfPhw/PHHH7BYLGjevDk2bNiAAQMGuJxWp9NBp9NhxYoVWLFiBWw2GwB7QLQmgQaFQlHjeRuDprz93HZue1NT3W131z5iYJKIiKiUJ598Emq1GhcvXkSnTp3k4WPGjEFsbCwDk0TkNp/sbcJJb8aP93QJqIH48ccfqz3PjBkzMGPGDGRnZ8Pf378OSkVERO7AwCQREVEp27Ztww8//IDmzZ2bVLZr1w4XLlwoZy4iour580oWDlzIAAB0CDehXysmvaHGJSQkBCqVCklJSU7Dk5KSEBERUafrLl1jkoiIvJPH66auWLECMTEx0Ov16N+/P3777bcKp1+6dCk6dOgAHx8fREdH48knn6x2J8ZEREQVsVgsMLhoWpieng6dTueBEhFRY1SytuSk62LYhy01OlqtFr1798aOHTvkYZIkYceOHeU2xXaXGTNm4NixY/j999/rdD1E9P/s3XlYVGX7B/DvLAz7KouCILjvoiK4m0ailmW2mPnLray3MDVskUpNS3HLqCR5M5csTeutbNHUIndxw8AMxQ1CERBkHZAZZs75/YGMDosKDnNYvp/r8oLznO2+B2Rm7nkWovsjaWFy69atCAsLw/z583Hy5En06NEDISEhuHbtWpXHb968GXPmzMH8+fNx5swZrF27Flu3bsXbb79t5siJiKgxGzRoEDZu3GjYlslkEAQBy5Ytw9ChQyWMjIgai5ziUvyScBUA4GhtgTE9PSWOSAJJScA//5R9pQZLrVYjPj7esLJ2cnIy4uPjkZpattp8WFgY1qxZgy+//BJnzpzByy+/jKKiIsMq3XUlKioKnTt3Rp8+fer0PkREdH8kHcq9cuVKTJs2zfCkFB0dje3bt2PdunWYM2dOpeMPHz6MAQMG4Nmb89H4+vpi/PjxOHr0qFnjJiKixm3ZsmV48MEHceLECWi1Wrz55pv4559/kJOTg0OHDkkdHhE1Aj+dzoZWLwIAxvXxho2qCc6w9OCDQFoa4OUFXLkidTRUSydOnDD60K58RexJkyZhw4YNGDduHLKysjBv3jxkZGTA398fO3furLQgjqlxjkkiooZBsldAWq0WcXFxCA8PN7TJ5XIEBwcjNja2ynP69++Pr7/+GseOHUNgYCAuXbqEHTt24Lnnnqv2PhqNBhqNxrBdUFAAoGwIgSAIJsqGiIgANJq/q127dsW5c+ewatUq2NvbQ61WY+zYsQgNDUWLFi1Mfj+9Xo/33nsPX3/9NTIyMuDp6YnJkyfj3XffNQztFEUR8+fPx5o1a5CXl4cBAwZg9erVaNeuncnjIaK6VaoX8MOpLACATAY817eVxBER1d4DDzwAURTveMz06dMxffp0M0VEREQNiWSFyezsbOj1+kqflHl4eODs2bNVnvPss88iOzsbAwcOhCiK0Ol0+M9//nPHodwRERFYsGBBpfasrCzOTUlEZGKFhYVSh2Ayjo6OeOedd8xyr6VLl2L16tX48ssv0aVLF5w4cQJTpkyBo6MjZsyYAaCsF+cnn3yCL7/8En5+fpg7dy5CQkKQmJgIKysrs8RJRKbxe2ImstSlAIDgTh7wdqk8py0R3R8ufkNE1DA0qDEje/fuxeLFi/HZZ58hKCgIFy5cwMyZM/H+++9j7ty5VZ4THh5uGE4AlPWY9Pb2hpubGxwcHMwVOhFRk9BYCmSnTp2qsl0mk8HKygo+Pj4mXQTn8OHDeOyxx/Dwww8DKJuq5JtvvjEsCCeKIiIjI/Huu+/iscceAwBs3LgRHh4e2LZtG5555plK1zT3iAFBECCKYqPoNctc6qfGkosoilh/KMWwPbGvT4PO6X5+LrKb/0QAYj14DO4nl4b8M2ysOJSbiKhhkKww6erqCoVCgczMTKP2zMxMNG/evMpz5s6di+eeew4vvPACAKBbt24oKirCiy++iHfeeQdyeeW1fCwtLat88yiXy6s8noiIaq+x/F319/c3GkINwGi1XAsLC4wbNw7//e9/TVKM7d+/Pz7//HOcO3cO7du3R0JCAg4ePIiVK1cCKFtIICMjA8HBwYZzHB0dERQUhNjY2CoLk+YeMSAIAvLz8yGKYoP/PWAu9VNjyWXX2RzEpeYBAPxcrNDWXl/two8Nwf38XNwEAYqb18iqB4/B/eTSmEYMEBERmZNkhUmVSoXevXsjJiYGY8aMAVD2YiAmJqba+UeKi4srvUhQKBQAcNd5TYiIiO7Vjz/+iLfeegtvvPEGAgMDAQDHjh3Dhx9+iPnz50On02HOnDl49913sWLFivu+35w5c1BQUICOHTtCoVBAr9dj0aJFmDBhAgAgIyMDAKqc/qR8X0XmHjEgCAJkMhnc3NwadNEIYC71VWPIJadIi4/33+qR/ebITnW+AEhdu5+fi+zm8XK5HO7u7nURXo3cTy6NZcRAY8Kh3EREDYOkQ7nDwsIwadIkBAQEIDAwEJGRkSgqKjKs0j1x4kR4eXkhIiICADB69GisXLkSPXv2NAzlnjt3LkaPHm0oUBIREd2vRYsW4eOPP0ZISIihrVu3bmjZsiXmzp2LY8eOwdbWFrNnzzZJYfLbb7/Fpk2bsHnzZnTp0gXx8fGYNWsWPD09MWnSpFpdU4oRAzKZrNGMSGAu9VNDz+WD7WeQU1w2t+SD7ZwR0qV5g83ldvf7c5HhVpFSarXNpSH+HC9cuICLFy9i8ODBsLa2hiiKRqMDGjoO5SYiahgkLUyOGzcOWVlZmDdvHjIyMuDv74+dO3caPjlOTU01epIvX5303XffRVpaGtzc3DB69GgsWrRIqhSIiKgR+vvvv9GqVeVVclu1aoW///4bQNlw7/T0dJPc74033sCcOXMMQ7K7deuGf//9FxEREZg0aZJhipPMzEyjVcEzMzPh7+9vkhiIqG7tSbqGbfFXAQCO1hYIe8Bb4oioqbp+/TrGjRuHP//8EzKZDOfPn0fr1q3x/PPPw9nZGR9++KHUIRIRURMi+Ud706dPx7///guNRoOjR48iKCjIsG/v3r3YsGGDYVupVGL+/Pm4cOECbty4gdTUVERFRcHJycn8gRMRUaPVsWNHLFmyBFqt1tBWWlqKJUuWoGPHjgCAtLQ0kw3BrG6qkvLFFPz8/NC8eXPExMQY9hcUFODo0aPo16+fSWIgorqj1ujwzg9/G7bfHtURzWwtJIyImrLXXnsNSqUSqampsLG5tSL8uHHjsHPnTgkjIyKipqhBrcpNRERkDlFRUXj00UfRsmVLdO/eHUBZL0q9Xo9ff/0VAHDp0iW88sorJrlfee9/Hx8fdOnSBX/99RdWrlyJqVOnAigbWjhr1ix88MEHaNeuHfz8/DB37lx4enoa5mkmovpr+c6zuJpftujUwLaueLKXF7KysiSOipqq3bt3Y9euXWjZsqVRe7t27fDvv/9KFJXpcY5JIqKGgYVJIiKiCvr374/k5GRs2rQJ586dAwA89dRTePbZZ2Fvbw8AeO6550x2v08//RRz587FK6+8gmvXrsHT0xMvvfQS5s2bZzjmzTffRFFREV588UXk5eVh4MCB2LlzJxdcIKrn4v7NwcYjZcUeawsFFj/erVHN43dfjh8H9HqAc8WbVVFRkVFPyXI5OTlVzk3cUHGOSSKihoGFSSIioirY29vjP//5j9nuFRkZicjIyGqPkclkWLhwIRYuXGiWmIjo/ml0erz1/d8QxbLt2cPbw6eZjWGahibvtjlzyXwGDRqEjRs34v333wdQ9vwiCAKWLVuGoUOHShwdERE1NSxMEhERVSMxMRGpqalGc00CwKOPPipRRETUkET+cR4XrqkBAD1aOmLKAD+JIyICli1bhgcffBAnTpyAVqvFm2++iX/++Qc5OTk4dOiQ1OEREVETw8IkERFRBZcuXcLjjz+Ov//+GzKZDOLN7k7lwy85XxUR3c1fqbn4776LAAALhQxLn+wOhZxDuEl6Xbt2xblz57Bq1SrY29tDrVZj7NixCA0NRYtG1IuVc0wSETUMLEwSERFVMHPmTPj5+SEmJgZ+fn44duwYrl+/jtmzZ2PFihVSh0dE9VxJqR6vf5cA4eYQ7lnB7dGxuYO0QdVHn38OqNWAnR3w4otSR9OkODo64p133pE6jDrFOSaJiBoGFiaJiIgqiI2NxZ9//glXV1fI5XLI5XIMHDgQERERmDFjBv766y+pQySieuzD3Um4mFUEoGwI90uDW0scUT21cCGQlgZ4ebEwaUbr16+HnZ0dnnrqKaP27777DsXFxZg0aZJEkRERUVMklzoAIiKi+kav1xtW33Z1dcXVq1cBAK1atUJSUpKUoRFRPXciJQdfHEwGAKiUcqx4qgeUCr7kpvojIiICrq6uldrd3d2xePFiCSIiIqK70eoEHLl0Hav+PI/3fv4Hq/48jyOXrkOra/gL6rHHJBERUQVdu3ZFQkIC/Pz8EBQUhGXLlkGlUuHzzz9H69bs+UREVbuhLRvCbViF+6H2aOdhL21QRBWkpqbCz6/yQkytWrVCamqqBBEREdGdaHUCthxPxZFL16GQyWBjqURSRiES0wtwLrMQz/TxgUrZcD8EZWGSiIiognfffRdFRWXDMBcuXIhHHnkEgwYNQrNmzbBlyxaJoyOi+mrZrrNIuV4MAOjp44QXBvGDDKp/3N3dcerUKfj6+hq1JyQkoFmzZtIERURE1TqZmosjl67D09Eatpa3ynhqjQ5HLl1Hew979G3dcP9+szBJRERUQUhIiOH7tm3b4uzZs8jJyYGzs7NhZW4iotsdS87B+kMpAADLm0O4uQo31Ufjx4/HjBkzYG9vj8GDBwMA9u3bh5kzZ+KZZ56RODoiIqroREoOFDKZUVESAOwslVDIZTiRksPCJBERUWMydepUfPzxx4Z5JgHAxcUFRUVFePXVV7Fu3ToJoyOi+uiLA5cM3785oiPauNlJGA1R9d5//32kpKTgwQcfhFJZ9nZQEARMnDixUc0xGRUVhaioKOj1eqlDISK6Z1qdgJOpuTiRkoNstRaudiqcvpoPe0uLKo+3USmRrdaaOUrTYmGSiIiogi+//BJLliwxKkwCwI0bN7Bx40YWJonISEmpHgfOZwMAmtmqMLm/r7QBEd2BSqXC1q1b8f777yMhIQHW1tbo1q0bWrVqJXVoJhUaGorQ0FAUFBTA0dFR6nCIiO6qurkkL2UVQaWUw8PBqtJojGKtDt7O1pWuU7G4GeDrgl4+zvVyLkoWJomIiG4qKCiAKIoQRRGFhYWwsrIy7NPr9dixYwfc3d0ljJCI6qMjl67jRmlZr6yhHd05hJsahPbt26N9+/ZSh0FERDdVN5ekXhRx8t9cXMgqhK1Kiat5N1Cs1UMpl0GpkGNcgLfh2Ia4UA4Lk0RERDc5OTlBJpNBJpNV+WZNJpNhwYIFEkRGRPVZzJlrhu+DO/HDC6rf9Ho9NmzYgJiYGFy7dg2CIBjt//PPPyWKjIioaatuLsnWrnb4N7sYJ1NyoVDIYSGXQZQBOp0IZ1sLnLtWiEC/ZlAp5Q1yoRwWJomIiG7as2cPRFHEsGHD8P3338PFxcWwT6VSoVWrVvD09JQwQiKqb0RRxJ9nywqTKoUcA9u5SRxRA9K+PeDoCHh4SB1JkzJz5kxs2LABDz/8MLp27cpF3YiI6olstRY2lpXLdAq5DK72KmQXaeDpaAWdIMJGpYSnkxXsrSxwIiUXnVs4om/rZtUWN60tFMgt1mLVn+ex83RGvRrezcIkERHRTUOGDAEAJCcnw9vbG3J5/RrmQET1z9mMQqTl3QAABLV2gV0VbyioGuyZJ4ktW7bg22+/xahRo6QOhYiIbuNqp0JSRmGV+zILNHCytqjyA9DrRRrDytxVFTf1gojTafm4nHMDSrkMXs42lYZ3S1mb5CsnIiKiClq1aoW8vDwcO3asymFuEydOlCgyIqpvYs5kGr4P7sSef1T/qVQqtG3bVuow7tnly5fx3HPP4dq1a1AqlZg7dy6eeuopqcMiIjK5AF8XJKYXQK3RGX3QqdbocKNUj9autlWed/vK3FUVN9Pzb+BKXjFUChk8HKzQ3MHKcN3y4d2Bvs51lNXdsTBJRERUwS+//IIJEyZArVbDwcHBaJibTCZjYZKIDGLO3ppfclhHzi9J9d/s2bPx8ccfY9WqVQ1iGLdSqURkZCT8/f2RkZGB3r17Y9SoUbC1rfoNOhFRfVCblbF7+TjjXGZh2cI1chlsVEoUa3XQCyLautnCSqmo8rzbV+auqrh5Na8EggDI5TJ4Ot1awdvOUgmFXIYTKTksTBIREdUns2fPxtSpU7F48WLY2NhIHQ4R1VP5xaWIv5wHAOjgYQ9vF/69oPrv4MGD2LNnD3777Td06dIFFhYWRvt/+OEHiSKrWosWLdCiRQsAQPPmzeHq6oqcnBwWJomo3qrtytgqpRzP9PFBew97Q0HT29kaAb4u0OkFbD6WWmVvSr0gIsC3bG78qoqb6QU3oNMLaNvMHi0crY3ueXtvS6mwMElERFRBWloaZsyYwaIkEd3RsZQciGLZ9wPbuUobTEM0YQKQnQ24ugKbNkkdTZPh5OSExx9/3GTX279/P5YvX464uDikp6fjxx9/xJgxY4yOiYqKwvLly5GRkYEePXrg008/RWBgYI3vFRcXB71eD29vbxNFT0RkevezMrZKKUff1s0q7dfqBFzKLqqyN2Xf1s3Qy8fZcH7F4mZLJ2voBRFdPR2hkBv3lL+9t6VUWJgkIiKqICQkBCdOnEDr1q2lDoWI6rGjl64bvg/0c5EwkgZq3z4gLQ3w8pI6kiZl/fr1Jr1eUVERevTogalTp2Ls2LGV9m/duhVhYWGIjo5GUFAQIiMjERISgqSkJLi7l01/4O/vD51OV+nc3bt3w9PTEwCQk5ODiRMnYs2aNXeMR6PRQKPRGLYLCgoAAIIgVJoz+m4EQYAoijU+r7Foyvkzd+Z+P04kX4dSBtiqFDB8ggnATqWAUl62v6ZDp5Vy4OneLdHO3Q5x5b0pnezQ29cFPb2doJTDELdSDgT6OhvucTQ5B18fScENbeXeloIgoHcr51rlbqrfERYmiYiIKnj44YfxxhtvIDExEd26das0zO3RRx+VKDIiqk+OJucYvg/0ZWGSGg6dToe9e/fi4sWLePbZZ2Fvb4+rV6/CwcEBdnZ2NbrWyJEjMXLkyGr3r1y5EtOmTcOUKVMAANHR0di+fTvWrVuHOXPmAADi4+PveA+NRoMxY8Zgzpw56N+//x2PjYiIwIIFCyq1Z2VloaSk5C7ZGBMEAfn5+RBFEXK5hEvWSqQp58/cmfv95K5V56GFSo/iguvIUWuh0QmwVMrhYqdCCwsZtOo8XLt27e4XqoKfLeDXxeG2Fh3ycrLveE5LKwEDvCyQlJGLghsyWCoV0Oj0EAQRA7zs0dJKi2vXrtU498LCqlcQrykWJomIiCqYNm0aAGDhwoWV9slkMuj1enOHRET1TGFJKf65mg8A6NjcHs62KokjIro3//77L0aMGIHU1FRoNBo89NBDsLe3x9KlS6HRaBAdHW2ye2m1WsTFxSE8PNzQJpfLERwcjNjY2Hu6hiiKmDx5MoYNG4bnnnvurseHh4cjLCzMsF1QUABvb2+4ubnBwcHhDmdWJggCZDIZ3NzcmlyBBmja+TN35n4/uSts8nH4bCZKSvWQQwYLpRKlOgFCjgbWFgo82NHF0GPcXMa6ueOvy3mG3paujipDb0uVUl6r3K2srEwSGwuTREREFTTFoStEVDMn/s2FcHN0FodxU0Myc+ZMBAQEICEhAc2a3ZrD7PHHHzd8MGcq2dnZ0Ov18PDwMGr38PDA2bNn7+kahw4dwtatW9G9e3ds27YNAPDVV1+hW7duVR5vaWkJS0tLREVFISoqyvBholwur1WhQSaT1frcxqAp58/cmXtt2VurkFWohaud5a05Ji2BIo0O1wo1sLdWmf2xtVLJ0a+NK/q1qX5O7JrmbqocWJgkIiK6g5KSEpN9GkhEjcfRS7eGcQf5VT2BPVF9dODAARw+fBgqlXEvX19fX6SlpUkUVfUGDhxYqw8MQ0NDERoaioKCAjg6OtZBZEREVSssKYWrnSVKdHpodQIslPKyHpMQ4WpvicKSUqlDrFdYmCQiIqpAr9dj8eLFiI6ORmZmJs6dO4fWrVtj7ty58PX1xfPPPy91iEQksaPJXPiGGiZBEKqckuTKlSuwt7c36b1cXV2hUCiQmZlp1J6ZmYnmzZub9F4VVewxSURkLrnFpejYwgGiKOJqXgmKtTo42FnC08kKMpkMucV3LkxqdQJOpuYaVtV2tVMhwNcFvXycoVI2vl6sjS8jIiKi+7Ro0SJs2LABy5YtM+pR0rVrV3zxxRcSRkZE9cH2U+n4KzUPANDazRZu9pbSBkRUA8OHD0dkZKRhWyaTQa1WY/78+Rg1apRJ76VSqdC7d2/ExMQY2gRBQExMDPr162fSe1UUGhqKxMREHD9+vE7vQ0RUkaudCppSPVo62yDQzwUPdHBHoJ8LWjrbQKPTw9Wu+nmptToBW46nYmNsCpIyCnGjVI+kjEJsjE3BluOp0Ooa35RT7DFJRERUwcaNG/H555/jwQcfxH/+8x9De48ePe55TiwiapzOpBfg9e8SDNtTBvhJGA1Rza1YsQIjRoxA586dUVJSgmeffRbnz5+Hq6srvvnmmxpfT61W48KFC4bt5ORkxMfHw8XFBT4+PggLC8OkSZMQEBCAwMBAREZGoqioyLBKd11hj0kikkqArwsS0wug1uhgZ3mr7KbW6KAXRAT4Vj/S4mRqLo5cug5PR+tb81PePPfIpeto72GPvq0rTyHTkHtZsjBJRERUQVpaGtq2bVupXRAElJZyThiipiq3SIsXvzqBG6VlhY6xPb3wf0E+EkdFVDPe3t5ISEjA1q1bkZCQALVajeeffx4TJkyAtbV1ja934sQJDB061LBdviL2pEmTsGHDBowbNw5ZWVmYN28eMjIy4O/vj507d1ZaEMfUOMckEUmll48zzmUW4sil65BBhmKtDun5JbhRqkdbN1vo9AK0OqHKguGJlBwoZDKjoiQA2FkqoZDLcCIlp1JhsryX5ZFL16GQyWBjqURSRiES0wtwLrMQz/TxqdfFSRYmiYiIKujcuTMOHDiAVq1aGbX/73//Q8+ePSWKioikpNMLePWbv3A55wYAoHtLRywe2w0ymUziyBqwadOA/HyARSOzKS0tRceOHfHrr79iwoQJmDBhwn1f84EHHoAoinc8Zvr06Zg+ffp934uIqCFQKeV4po8PWrvaYv2hZFzKLoKVUo7WrrawUiqw+VgqLmUXVVkwzFZrYWNZdanORqVEtlpbqb22vSzrCxYmiYiIKpg3bx4mTZqEtLQ0CIKAH374AUlJSdi4cSN+/fVXqcMjIgks+e0sDl7IBlA2d1T0//WGlYVC4qgauPnzpY6gybGwsEBJSYnUYZgFh3ITkZRUSjmUCjksLRR4qJPHPRcMXe1USMoorPKaxVodvJ0r92yvTS/L+qT+9uUkIiKSyGOPPYZffvkFf/zxB2xtbTFv3jycOXMGv/zyCx566CGpwyMiM/vxryv44mAyAEApl+GzCb3h6VTzIa9E9UFoaCiWLl0KnU4ndSh1iovfEJHU7qVgWFGArwv0ogi1xvhv9J3mp6xNL8v6hD0miYiIqjBo0CD8/vvvUodBRBL7+0o+5nz/t2H7vUe7INCv+knrieq748ePIyYmBrt370a3bt1ga2trtP+HH36QKDIiosalNgXD2+enVMhlsFEpUawtK0r2bd0MvXycK51Tm16W9QkLk0RERBUcP34cgiAgKCjIqP3o0aNQKBQICAiQKDIiMqfcIi1e+uoENDoBADA+0BsTuNgNNXBOTk544oknpA6jznEoNxFJrTYFw/L5Kdt72BtW2PZ2tr7jCtv+3k44cD4bV/NuQCeIsFEp4OlkDXsrC+gFEf7eTjhy6Xq9XbGbhUkiIqIKQkND8eabb1YqTKalpWHp0qU4evSoRJERkTn9FJ+Gq/ll8/H18nHCe4924WI3ptSyJZCWBnh5AVeuSB1Nk7F+/XqpQzALrspNRFIL8HVBYnoB1Bod7CrMMVndsGygrDjZt3Wze5oXUqsTcO5aIQpLSpFbVAqlUobcIiDlejFcbC0wursXdidm4MilHGh1AuyslLC3VOJ0Wn69WbFb8tJoVFQUfH19YWVlhaCgIBw7duyOx+fl5SE0NBQtWrSApaUl2rdvjx07dpgpWiIiagoSExPRq1evSu09e/ZEYmKiBBERkRSy1BrD97OC28NSycVuqHHQ6XT4448/8N///heFhWW9ea5evQq1Wi1xZEREjUcvH2f0bd0M6fk3cClbjYyCElzKViM9/0a1w7LvRKsTcOTSdaz68zze+/kfrPrzPL4+8i+OXcpBkF8z9G/bDC2dbOBsq4KnoxVsVEr8lZqL3f9kQqcXYWuphLZUQJZag/wbpTh8IRsnU3PrKPt7J2mPya1btyIsLAzR0dEICgpCZGQkQkJCkJSUBHd390rHa7VaPPTQQ3B3d8f//vc/eHl54d9//4WTk5P5gyciokbL0tISmZmZaN26tVF7eno6lEoONiBqKoq1t4aAVpy4nqih+vfffzFixAikpqZCo9HgoYcegr29PZYuXQqNRoPo6GipQyQiahRqMyy7OlqdgC3HU8vmnpTJYGOpRFJGIZIyC6FSyNHW3R4O1hZo6WxjOOdYynWc+DcXjlZKuNlbljVall0rS60BZKgXK3ZL+gpr5cqVmDZtGqZMmQIAiI6Oxvbt27Fu3TrMmTOn0vHr1q1DTk4ODh8+DAsLCwCAr6+vOUMmIqImYPjw4QgPD8dPP/1kGP6Vl5eHt99+m6tyEzUhJaW3CpM2KvaWpMZh5syZCAgIQEJCApo1u/Vm9PHHH8e0adMkjMy0OMckEdUHNRmWfScnU3Nx5NJ1eDpaG31YejFLjbwbpUjPv2FUlASAwhIdtDoB1hU+XFUp5ZBrZCgs0dWLFbslK0xqtVrExcUhPDzc0CaXyxEcHIzY2Ngqz/n555/Rr18/hIaG4qeffoKbmxueffZZvPXWW1Aoqn6xqNFooNHcGoZTUFAAABAEAYIgmDAjIiJqLH9Xly9fjiFDhqBVq1bo2bMnACA+Ph4eHh746quvJI6OiMzl9h6TLExSY3HgwAEcPnwYKpXKqN3X1xdpaWkSRWV6nGOSiBqTEyk5UMhklUZwOFpbIK+4FFfzSioVJtUaHaxVCpTqBMDS+HoWSjnUGh1c7YyfC6QgWWEyOzsber0eHh4eRu0eHh44e/ZsledcunQJf/75JyZMmIAdO3bgwoULeOWVV1BaWor58+dXeU5ERAQWLFhQqT0rKwslJSX3nwgRERmUz1PV0LVs2RKnTp3Cpk2bkJCQAGtra0yZMgXjx4839Ng3tbS0NLz11lv47bffUFxcjLZt22L9+vWGFcBFUcT8+fOxZs0a5OXlYcCAAVi9ejXatWtXJ/EQEXDjtsKktQULk9Q4CIJQZS/CK1euwN7eXoKIiIjobrLVWthUMa2Mp5M1LucWI/9GqVG7WqODSiGHrZ0CGr0ArU4wGjp+Q6uHSiGvdgEec2pQk+UIggB3d3d8/vnnUCgU6N27N9LS0rB8+fJqC5Ph4eEICwszbBcUFMDb2xtubm5wcHAwV+hERE2ClZWV1CHct9LSUnTs2BG//vorXnzxRbPcMzc3FwMGDMDQoUPx22+/wc3NDefPn4ez860JsZctW4ZPPvkEX375Jfz8/DB37lyEhIQgMTGxUTzuRPXRjduGcluzxyQ1EsOHD0dkZCQ+//xzAIBMJoNarcb8+fMxatQoiaMjIqKquNqpkJRRuRNIC0drONuooNEJuJStho1KiWJt2arfA9q6Ii33Bgo1pcgq1ECulcFCIccNrQ7FWj1GdmtR4wV46oJkhUlXV1coFApkZmYatWdmZqJ58+ZVntOiRQtYWFgYDdvu1KkTMjIyoNVqKw1HAMoWMLC0tKzULpfLIZdLvig5EVGj0hj+rlpYWJi9R/3SpUvh7e2N9evXG9r8/PwM34uiiMjISLz77rt47LHHAAAbN26Eh4cHtm3bhmeeecas8RI1FewxSY3Rhx9+iJCQEHTu3BklJSV49tlncf78ebi6uuKbb76ROjyT4RyTRNSYBPi6IDG9AGqNDna39Zy8UaqHl5MNAv1cUKzVGS2w09XTET/8dQWHL1yHDDIU3iiFWquHhUKOkd3cMfuhDjVagKeuSFaYVKlU6N27N2JiYjBmzBgAZT0iY2JiMH369CrPGTBgADZv3gxBEAxvfs+dO4cWLVpUWZQkIiKqjdDQUCxduhRffPGFWVbh/vnnnxESEoKnnnoK+/btg5eXF1555RXDIgTJycnIyMhAcHCw4RxHR0cEBQUhNja2ysKkuedYFgQBoig2inlGmUv9JEUuRVodAMBCIYNcZrp5dPlzKSO7+U8EINaDx+J+cmlIP8uWLVsiISEBW7duRUJCAtRqNZ5//nlMmDAB1tbWUodnMpxjkogak14+zjiXWVi2KrdcZtQzsn/bZnimj0+VRcaKq4K72qkMRcvTV/NvtdtaoFszwMnFFVYq8xYrJR3KHRYWhkmTJiEgIACBgYGIjIxEUVGRYZXuiRMnwsvLCxEREQCAl19+GatWrcLMmTPx6quv4vz581i8eDFmzJghZRpERNTIHD9+HDExMdi9eze6desGW1tbo/0//PCDSe936dIlrF69GmFhYXj77bdx/PhxzJgxAyqVCpMmTUJGRgYAVDkvc/m+isw9x7IgCMjPz4coig2+5yxzqZ+kyCVHXfZ/xd5SgWvXrpnsuvy5lHETBChuXiPLhI9vbd1PLvV9juVevXohJiYGzs7OWLhwIV5//XVMmDABEyZMkDo0IiK6ByqlvFKRsbxnZC8f52p7Pla1KrhWJ2DL8dSyIqdMBhtLJc5lliAr6wb+LbbAM4GtzNqTUtLC5Lhx45CVlYV58+YhIyMD/v7+2Llzp+GNV2pqqtGLAm9vb+zatQuvvfYaunfvDi8vL8ycORNvvfWWVCkQEVEj5OTkhCeeeMJs9xMEAQEBAVi8eDEAoGfPnjh9+jSio6MxadKkWl3T3HMsC4IAmUwGNze3RlFoYS71jxS55JeUDQF1tbOCu7u7ya7Ln8tNX38NQaOBzNLSpI9vbd1PLvV9rt8zZ86gqKgIzs7OWLBgAf7zn//Axsbm7icSEVG9UVWRsTZOpubiyKXr8HS0vrXKt2gJmUaPo8nX0b65w33foyYkX/xm+vTp1Q7d3rt3b6W2fv364ciRI3UcFRERNWW3z/VoDi1atEDnzp2N2jp16oTvv/8eAAxzL2dmZqJFixaGYzIzM+Hv71/lNaWYY1kmkzWaOZyZS/1kzlxuaPUoKS0bnutsqzL5PflzATBsWN0EdB9qm0t9/zn6+/tjypQpGDhwIERRxIoVK2BnZ1flsfPmzTNzdEREZE4nUnKgkMluFSVvslYqoJCX7W8whUmtVovk5GS0adPGLHNwERERmYtOp8PevXtx8eJFPPvss7C3t8fVq1fh4OBQ7Zu52howYACSkpKM2s6dO4dWrVoBKFsIp3nz5oiJiTEUIgsKCnD06FG8/PLLJo2FiMrkFGsN37vYci5zatg2bNiA+fPn49dff4VMJsNvv/1W5fs3mUzGwiQRUSOXrdbCxrLqGp61SolstbbKfXWlVtXE4uJivPrqq/jyyy8BlL15at26NV599VV4eXlhzpw5Jg2SiIjInP7991+MGDECqamp0Gg0eOihh2Bvb4+lS5dCo9EgOjrapPd77bXX0L9/fyxevBhPP/00jh07hs8//xyff/45gLI3irNmzcIHH3yAdu3awc/PD3PnzoWnp6dhATkiMq3colsvyp1ZmKQGrkOHDtiyZQuAst6dMTEx9WL4PBERmZ+rnQpJGVXPjXxDq4O3s3mn+qjVmIPw8HAkJCRg7969RvOpBAcHY+vWrSYLjoiISAozZ85EQEAAcnNzjVYoffzxxxETE2Py+/Xp0wc//vgjvvnmG3Tt2hXvv/8+IiMjjRYlePPNN/Hqq6/ixRdfRJ8+faBWq7Fz5856P68ZUUOVc1th0sWGhck6sXcvsGtX2VeqU7169UJubi4AYP78+Sbv+V8fRUVFoXPnzujTp4/UoRAR1Sv+3k64VqjBwfNZ2Jt0DceSr+NKXjGKtHroBREBvi5mjadWPSa3bduGrVu3om/fvpDJZIb2Ll264OLFiyYLjoiISAoHDhzA4cOHoVIZFyN8fX2RlpZWJ/d85JFH8Mgjj1S7XyaTYeHChVi4cGGd3J+IjOUWs8dknfu//wPS0gAvL+DKFamjadRuX/xm4cKFePnllxv94jehoaEIDQ1FQUEBHB0dpQ6HiKjOaHUCTqbmGlbrdrVTVbtat1Yn4Ny1QhSWlCK3qBRKpQy5RcC/14vQwxXo07E1evk4mzX+WhUms7Kyquz6X1RUZFSoJCIiaogEQYBer6/UfuXKFdjb20sQERGZ2+3zKznbWEgYCdH94+I3RESNk1YnYMvxVBy5dB0KmQw2lkokZRQiMb0A5zIL8UwfH6PiZFkBMxdBfs1QUFKKq3klKNbqYCEHrC10aOdhV6mYWddqVZgMCAjA9u3b8eqrrwKAoRj5xRdfoF+/fqaLjoiISALDhw9HZGSk0RyParUa8+fPx6hRoySOjojM4UpuseF7TyfrOxxJVP9x8RsiosbpZGoujly6Dk9Ha6NVttUaHY5cuo72HvZGK2yXr8jtYG0BB2sLtCyfT1IUUZCXjYTLeRjU3rxzENeqMLl48WKMHDkSiYmJ0Ol0+Pjjj5GYmIjDhw9j3759po6RiIjIrD788EOEhISgc+fOKCkpwbPPPovz58/D1dUV33zzjdThEZEZpF6/VZhs1axxD3mlxo+L3xARNU7lhUbbCqts21kqoZDLcCIlx6gweacVuS2VCrOvyA3UcvGbgQMHIiEhATqdDt26dcPu3bvh7u6O2NhY9O7d29QxEhERmVXLli2RkJCAd955B6+99hp69uyJJUuW4K+//uIbOaIm4t+cssKkSimHhz0XmaLGQxAEPpcRETUSdyo02qiUlQqNrnYqFGt0VR6v0enhamf+ebVr3GOytLQUL730EubOnYs1a9bURUxERESSOXLkCH755RdotVoMGzYMy5YtkzokIjIzQRCRerMw6eNiA7mcc6hTw/bzzz9j5MiRsLCwwM8//3zHYx999FEzRXVv8vLyEBwcDJ1OB51Oh5kzZ2LatGlSh0VEVC+42qmQlFFY5b5irQ7ezsbT0QT4uiAxvQBqjQ52FYZ+C4KI3mZekRuoRWHSwsIC33//PebOnVsX8RAREUnmf//7H8aNGwdra2tYWFhg5cqVWLp0KV5//XWpQyMiM7pWqIFWJwAAWrlwGDc1fGPGjEFGRgbc3d0xZsyYao+TyWRVLv4mJXt7e+zfvx82NjYoKipC165dMXbsWDRr1uzuJxMRNXJ3KjTqBREBFQqNvXyccS6zsGyxHLkMNiolirU6CIKAAV726OntZOYMajmUe8yYMdi2bZuJQyEiIpJWREQEpk2bhvz8fOTm5uKDDz7A4sWLpQ6LiMzs3+tFhu99OL8kNQK3D98WBKHaf/WtKAkACoUCNjZl/w81Gg1EUYQoihJHRURUP/TycUbf1s2Qnn8Dl7LVyCgowaVsNdLzb6Bv62bo5eNsdLxKKcczfXwwsZ8vOnjYw9pCgQ4e9vi/vr4Y1M7N7CtyA7Vc/KZdu3ZYuHAhDh06hN69e8PW1tZo/4wZM0wSHBERkTklJSVh69atUCgUAIDZs2dj3rx5uHbtGufjImpCyueXBMqGchNR9fbv34/ly5cjLi4O6enp+PHHHyv1yoyKisLy5cuRkZGBHj164NNPP0VgYOA93yMvLw9DhgzB+fPnsXz5cri6upo4CyKihqm80Njewx4nUnKQrdbC29kaAb4u6OXjXGWhUaWUo2/rZkaL4giCgGvXrpkzdINaFSbXrl0LJycnxMXFIS4uzmifTCZjYZKIiBqk4uJiODg4GLZVKhWsrKygVqtZmCRqIpKzixC996JhmytyU2MiCAI2bNiAH374ASkpKZDJZPDz88OTTz6J5557DjJZzedTLSoqQo8ePTB16lSMHTu20v6tW7ciLCwM0dHRCAoKQmRkJEJCQpCUlGR4bvX394dOV3kxht27d8PT0xNOTk5ISEhAZmYmxo4diyeffBIeHh5VxqPRaKDRaAzbBQUFhtwFQahRboIgQBTFGp/XWDTl/Jk7c29IlHIg0NcZgb7Olfbday61yd1Uj1OtCpPJyckmuTkREVF988UXX8DOzs6wrdPpsGHDBqPeGfwAjqhxOnwxGy9/fRL5N0oBAJ6OVujXmj2z6syVK1JH0KSIoohHH30UO3bsQI8ePdCtWzeIoogzZ85g8uTJ+OGHH2o1XdfIkSMxcuTIavevXLkS06ZNw5QpUwAA0dHR2L59O9atW4c5c+YAAOLj4+/pXh4eHujRowcOHDiAJ598sspjIiIisGDBgkrtWVlZKCkpuaf7lBMEAfn5+RBFEXK5+Yc3Sq0p58/cmTtzv7vCwqoX3ampWhUmb1c+v0dtPl0jIiKqT3x8fLBmzRqjtubNm+Orr74ybHNkAFHjtOVYKt7ddho6oey1bQcPe3wxKQDWKoXEkRGZxoYNG7B//37ExMRg6NChRvv+/PNPjBkzBhs3bsTEiRNNdk+tVou4uDiEh4cb2uRyOYKDgxEbG3tP18jMzISNjQ3s7e2Rn5+P/fv34+WXX672+PDwcISFhRm2CwoK4O3tDTc3N6NREfdCEATIZDK4ubk1uSIF0LTzZ+7Mva5z1+oE/HU5D3E3h1+72qnQ29cFPb2dJJnnsTa5W1lZmeTetS5Mbty4EcuXL8f58+cBAO3bt8cbb7yB5557ziSBERERmVtKSorUIRCRmekFERE7zuCLg7dGBA3t4IZPxveEvZWFhJERmdY333yDt99+u1JREgCGDRuGOXPmYNOmTSYtTGZnZ0Ov11cadu3h4YGzZ8/e0zX+/fdfvPjii4ZFb1599VV069at2uMtLS1haWmJqKgoREVFGRb0kcvltSo0yGSyWp/bGDTl/Jk7c68rWp2Ab+OulK2MLZPBxlKJpEw1EjMKcf6aGs/08ZGkOFnT3E31GNWqMLly5UrMnTsX06dPx4ABAwAABw8exH/+8x9kZ2fjtddeM0lwRERERER1Ra3RYeY3fyHm7K3J3qcO8MM7D3eCQs7RQNS4nDp1CsuWLat2/8iRI/HJJ5+YMaJ7ExgYeM9DvW8XGhqK0NBQFBQUwNHR0fSBERHV0snUXBy5dB2ejtawtbxVllNrdDhy6Trae9gbLUzT2NWqMPnpp59i9erVRp+mPfroo+jSpQvee+89FiaJiIiIqF67kluMF748gbMZZfMjKeUyLHysK54N8pE4siZkwQIgPx9wdATmz5c6mkYvJyen2gVjgLJejLm5uSa9p6urKxQKBTIzM43aMzMz0bx5c5Peq6KKPSaJiOqLEyk5UMhkRkVJALCzVEIhl+FESk6TKkzWqt9leno6+vfvX6m9f//+SE9Pv++giIiIiIjqysnUXIyJOmQoSjpYKfHl1EAWJc1tzRrgo4/KvlKd0+v1UCqr75eiUCiqXBn7fqhUKvTu3RsxMTGGNkEQEBMTg379+pn0XhWFhoYiMTERx48fr9P7EBHVVLZaCxvLqv8e26iUyFZrzRyRtGrVY7Jt27b49ttv8fbbbxu1b926Fe3atTNJYEREREREpvZzwlW8/l0CtDoBAODbzAZrJ/dBGzc7iSMjqluiKGLy5MmwtLSscr9Go6nVddVqNS5cuGDYTk5ORnx8PFxcXODj44OwsDBMmjQJAQEBCAwMRGRkJIqKigyrdNcV9pgkovrK1U6FpIyqV7Qu1urg7WxtsntpdQJOpubixG2L7AT4uqCXj7Mk81hWpVaFyQULFmDcuHHYv3+/YY7JQ4cOISYmBt9++61JAyQiIiIiMoXNR1Px9o9/G7b7tnbB6gm94WyrkjAqIvOYNGnSXY+pzcI3J06cMFpQp3xF7EmTJmHDhg0YN24csrKyMG/ePGRkZMDf3x87d+6847ByU+Ack0RUXwX4uiAxvQBqjQ52FeaY1AsiAnxdTHIfrU7AluOpxovsZBQiMb0A5zILJVtkp6JaFSafeOIJHD16FB999BG2bdsGAOjUqROOHTuGnj17mjI+IiIiSVy8eBHr16/HxYsX8fHHH8Pd3R2//fYbfHx80KVLF6nDI6IaWn8oGQt+STRsjwvwxvtjutaLF+RE5rB+/fo6ue4DDzwAURTveMz06dMxffr0Ork/EVFD08vHGecyC8sKhnIZbFRKFGvLipJ9WzdDLx9nk9ynoSyyU6vCJAD07t0bX3/9tSljISIiqhf27duHkSNHYsCAAdi/fz8WLVoEd3d3JCQkYO3atfjf//4ndYhEVAPR+y5iyW9nDdsvDWmNOSM6QibjyttEjRWHchNRfaVSyvFMHx+097A3DLH2drY2+RDrhrLITq0Kkzt27IBCoUBISIhR+65duyAIAkaOHGmS4IiIiKQwZ84cfPDBBwgLC4O9vb2hfdiwYVi1apWEkRFRTYiiiE9iLuCjP84Z2mY82A6vBbdjUZKokeNQbiKqz1RKOfq2blanhcGGsshOrcqwc+bMqfKTJ1EUMWfOnPsOioiISEp///03Hn/88Urt7u7uyM7OliAiIqopURSxbFeSUVHyjZAOCHuoPYuSRERE1Oi52qlQrNEBAPSCiCu5xTiWfB17k64h4XIebmj1hsUApVSrwuT58+fRuXPnSu0dO3Y0WpGNiIioIXJyckJ6enql9r/++gteXl4SRERENSGKIt7/9QxW771oaJv7SGeEDm0rYVREZE5RUVHo3Lkz+vTpI3UoRESSCPB1gV4UkX+jFKev5iPhSh6uq7W4UapHfnEpUq4XYcvxVMmLk7UqTDo6OuLSpUuV2i9cuABbW9v7DoqIiEhKzzzzDN566y1kZGRAJpNBEAQcOnQIr7/+eq1WLCUi8xEEEe9uO411h5INbe+P6YrnB/pJGBURmVtoaCgSExNx/PhxqUMhIpJELx9n9G3dDGfSC5CUUQg5ykaMCKKIDs3t0amFA45cuo6TqbmSxlmrwuRjjz2GWbNm4eLFW59CX7hwAbNnz8ajjz5qsuCIiIiksHjxYnTs2BHe3t5Qq9Xo3LkzBg8ejP79++Pdd9+VOjwiqoYgiHjr+1PYdDQVACCTAcue6I7n+raSODKq0pAhwPDhZV/JrL766isMGDAAnp6e+PfffwEAkZGR+OmnnySOjIiITKV8kR3fZjZwsFLCWqVAMztL9GjphK5ejnC0tjAsgiOlWhUmly1bBltbW3Ts2BF+fn7w8/NDx44d0axZM6xYscLUMRIREZmVSqXCmjVrcPHiRfz666/4+uuvcfbsWXz11VdQKBRSh0dE1dj5Twa+i7sCAFDIZYgc54+n+3hLHBVVa9MmYNeusq9kNqtXr0ZYWBhGjRqFvLw8w9oBTk5OiIyMlDY4IiIyKZVSDmuVEv4+zniggzsC/VzQ0tkGCnlZ78n6sAhOrVbldnR0xOHDh/H7778jISEB1tbW6NGjBwYNGmTq+IiIiMzu4MGDGDhwIHx8fODj4yN1OER0j/48e83w/ZKx3fCYP+eEJaro008/xZo1azBmzBgsWbLE0B4QEIDXX39dwshMKyoqClFRUVUu2kpE1JS42qmQlFFY5b5irQ7eztZmjshYjXpMxsbG4tdffwUAyGQyDB8+HO7u7lixYgWeeOIJvPjii9BoNHUSKBERkbkMGzYMfn5+ePvtt5GYmCh1OER0j44llw1FUinlGN3DU+JoiOqn5ORk9OzZs1K7paUlioqKJIiobnCOSSKiMuWL4KhvrtBdTq3RQS+ICPB1kSiyMjUqTC5cuBD//POPYfvvv//GtGnT8NBDD2HOnDn45ZdfEBERYfIgiYiIzOnq1auYPXs29u3bh65du8Lf3x/Lly/HlStXpA6NiKqRnn8DqTnFAAB/bydYWXDaBaKq+Pn5IT4+vlL7zp070alTJ/MHREREdap8EZz0/Bu4lK1GRkEJLmWrkZ5/A31bN0MvH2dJ46tRYTI+Ph4PPvigYXvLli0IDAzEmjVrEBYWhk8++QTffvutyYMkIiIyJ1dXV0yfPh2HDh3CxYsX8dRTT+HLL7+Er68vhg0bJnV4RFSF8t6SANDXT9pP/ukeDRsGdOlS9pXMJiwsDKGhodi6dStEUcSxY8ewaNEihIeH480335Q6PCIiMrHyRXAm9vNFBw97WFso0MHDHhP7+eKZPj5QKWu1/IzJ1GiOydzcXHh4eBi29+3bh5EjRxq2+/Tpg8uXL5suOiIiIon5+flhzpw56NGjB+bOnYt9+/ZJHRIRVeHIpVuFyUC/ZhJGQvfs3DkgLQ3Iz5c6kiblhRdegLW1Nd59910UFxfj2WefhaenJz7++GM888wzUodnMpxjkojoFpVSjr6tm6Fv6/r3GqlGZVEPDw8kJycDALRaLU6ePIm+ffsa9hcWFsLCwsK0ERIREUnk0KFDeOWVV9CiRQs8++yz6Nq1K7Zv3y51WERUhWPJ1wEASrkMvVo5SRsMUT03YcIEnD9/Hmq1GhkZGbhy5Qqef/55qcMyKc4xSUTUMNSoMDlq1CjMmTMHBw4cQHh4OGxsbIxW4j516hTatGlj8iCJiIjMKTw8HH5+fhg2bBhSU1Px8ccfIyMjA1999RVGjBghdXhEVEG2WoOLWWWLdnRr6QgbVY0GBRE1KcOGDUNeXh4AwMbGBu7u7gCAgoICTldCRERmV6PC5Pvvvw+lUokhQ4ZgzZo1WLNmDVQqlWH/unXrMHz48BoHERUVBV9fX1hZWSEoKAjHjh27p/O2bNkCmUyGMWPG1PieRERE1dm/fz/eeOMNpKWl4ddff8X48eNhY2MjdVhEVIWD57MxYc1Rw3Yg55ckuqO9e/dCq9VWai8pKcGBAwckiIiIiJqyGn2c7Orqiv379yM/Px92dnZQKIxXO/zuu+9gZ2dXowC2bt2KsLAwREdHIygoCJGRkQgJCUFSUpLh07uqpKSk4PXXXzfqsUlERGQKhw4dkjoEIrqL5OwiLNp+Bn+cyTS0qZRyPN7TS8KoiOqvU6dOGb5PTExERkaGYVuv12Pnzp3w8uL/HyIiMq9ajXNxdHSsst3FpeafUK9cuRLTpk3DlClTAADR0dHYvn071q1bhzlz5lR5jl6vx4QJE7BgwQIcOHDAMBSBiIiotn7++WeMHDkSFhYW+Pnnn+947KOPPmqmqIioooIbpVi15yK+jE1BqV40tPdo6Yj5j3ZBx+YOEkZHVH/5+/tDJpNBJpNVOWTb2toan376qQSRERFRUybpBDxarRZxcXEIDw83tMnlcgQHByM2Nrba8xYuXAh3d3c8//zzdx1uoNFooNFoDNsFBQUAAEEQIAjCfWZARES3a8h/V8eMGYOMjAy4u7vfcYoQmUzGFT6JJKAXRPx4KgtrjpxCTnGpod3DwRJvjeiIMf5ekMtlEkZIVL8lJydDFEW0bt0ax44dg5ubm2GfSqWCu7t7pRFxREREdU3SwmR2djb0ej08PDyM2j08PHD27Nkqzzl48CDWrl2L+Pj4e7pHREQEFixYUKk9KysLJSUlNY6ZiIiqV1hYKHUItXZ7UbUhF1iJGqPDF7Kx4NdEJGXc+htjqZTjpcGt8dKQNrC15GI3RHfTqlUrAE3nOS4qKgpRUVH8MJGIqJ5rUK/iCgsL8dxzz2HNmjVwdXW9p3PCw8MRFhZm2C4oKIC3tzfc3Nzg4MChPkREpmRlZSV1CCaxceNGjBs3DpaWlkbtWq0WW7ZswcSJE+v0/kuWLEF4eDhmzpyJyMhIAGWLEsyePRtbtmyBRqNBSEgIPvvss0of7hE1JinZRVi84wx2J2YatY/u4Ym3RnRAS2cuSkVUUxs3brzj/rp+jjOX0NBQhIaGoqCgoNqpyIiISHqSFiZdXV2hUCiQmWn8YjMzMxPNmzevdPzFixeRkpKC0aNHG9rKP/FTKpVISkpCmzZtjM6xtLSs9MYSKBsyLpfXaFFyIiK6i8byd3XKlCkYMWJEpUXYCgsLMWXKlDp903b8+HH897//Rffu3Y3aX3vtNWzfvh3fffcdHB0dMX36dIwdO5YL9VCjVFBSilV/XsD6Q8lG80h28rDBgjHdEejXTMLoyGTmzQPUaqCGi2fS/Zk5c6bRdmlpKYqLi6FSqWBjY9NoCpNERNQwSFqYVKlU6N27N2JiYgzzeQmCgJiYGEyfPr3S8R07dsTff/9t1Pbuu++isLAQH3/8Mby9vc0RNhERNXKiKEImqzxX3ZUrV+q014VarcaECROwZs0afPDBB4b2/Px8rF27Fps3bzYsWLB+/Xp06tQJR44cQd++fessJiJzEkUR3564jGU7k3C9SGtod7e3xBsh7THAywLNPZwljJBM6sUXpY6gScrNza3Udv78ebz88st44403JIiIiIiaMsmHcoeFhWHSpEkICAhAYGAgIiMjUVRUZFile+LEifDy8kJERASsrKzQtWtXo/OdnJwAoFI7ERFRTfXs2dOwYumDDz4IpfLW06Rer0dycjJGjBhRZ/cPDQ3Fww8/jODgYKPCZFxcHEpLSxEcHGxo69ixI3x8fBAbG1tlYdLci78JggBRFBvF3GXMRTof/X4On+65aNhWKeWYNtAP/xnSGtYWcmRlZTWYXO6kof1c7oS53Dq3IWvXrh2WLFmC//u//6t2rn8iIqK6IHlhcty4ccjKysK8efOQkZEBf39/7Ny50zBnVmpqaqMZGkhERPVbee/9+Ph4hISEwO624YUqlQq+vr544okn6uTeW7ZswcmTJ3H8+PFK+zIyMqBSqQwfxpXz8PBARkZGldcz9+JvgiAgPz8foig2+Odt5iKNn05n49M9/xq2H2znjOmDvNDCwRJF+TkobEC53E1D+rncDXMp05AXfyunVCpx9epVqcMgIqImRvLCJABMnz69yqHbALB37947nrthwwbTB0RERE3S/PnzAQC+vr4YN26c2RbzuXz5MmbOnInff//dZPc09+JvgiBAJpPBzc2tURQnmIt57U3KwrI/Uw3bcx/uhCkDfI2OaSi53AvmclN6OqDXAwoF0KJF3QRYA/eTS0Na/O3nn3822hZFEenp6Vi1ahUGDBggUVR3V1xcjE6dOuGpp57CihUrpA6HiIhMpF4UJomIiOqTSZMmmfV+cXFxuHbtGnr16mVo0+v12L9/P1atWoVdu3ZBq9UiLy/PqNdkdYvFAdIs/iaTyRrN4nLMxXxOp+Vj+jd/QS+ULXLz/EA/PD+odZXH1vdcaoK5AAgKAtLSAC8v4MqVugmuhmqbS0P6OZaPDihXXowdNmwYPvzwQ2mCugeLFi3inMpERI0QC5NEREQV6PV6fPTRR/j222+RmpoKrVZrtD8nJ8ek93vwwQcrLe42ZcoUdOzYEW+99Ra8vb1hYWGBmJgYw1DypKQkpKamol+/fiaNhcicLucUY8qG4yjW6gEAI7s2xzujOkkcFVHj1hDnwzx//jzOnj2L0aNH4/Tp01KHQ0REJtRwPtojIiIykwULFmDlypUYN24c8vPzERYWhrFjx0Iul+O9994z+f3s7e3RtWtXo3+2trZo1qwZunbtCkdHRzz//PMICwvDnj17EBcXhylTpqBfv37sPUINVn5xKaZsOI6swrJFmnq3csZH4/whl8skjoyIamL//v0YPXo0PD09IZPJsG3btkrHREVFwdfXF1ZWVggKCsKxY8dqdI/XX38dERERJoqYiIjqE/aYJCIiqmDTpk1Ys2YNHn74Ybz33nsYP3482rRpg+7du+PIkSOYMWOG2WP66KOPIJfL8cQTT0Cj0SAkJASfffaZ2eMgMgWNTo9pX53AhWtqAEBrV1t8MTEAVhYKiSMjapxun3P4blauXFmjaxcVFaFHjx6YOnUqxo4dW2n/1q1bERYWhujoaAQFBSEyMhIhISFISkqCu7s7AMDf3x86na7Subt378bx48fRvn17tG/fHocPH65RbEREVP+xMElERFRBRkYGunXrBgCws7NDfn4+AOCRRx7B3LlzzRJDxcXfrKysEBUVhaioKLPcn6iuCIKI1787hWPJZVMiuNqpsGFKIJxtVRJHRtR4/fXXX/d0nExW8x7LI0eOxMiRI6vdv3LlSkybNg1TpkwBAERHR2P79u1Yt24d5syZAwCIj4+v9vwjR45gy5Yt+O6776BWq1FaWgoHBwfMmzevyuM1Gg00Go1hu6CgAEDZEPaaDmMXBAGiKDbI4e+m0JTzZ+7MvampTe6mepxYmCQiIqqgZcuWSE9Ph4+PD9q0aYPdu3ejV69eOH78eJULyhDRvVu+Owm/JFwFAFhbKLB2Uh/4NLOROCqixm3Pnj2S3Fer1SIuLg7h4eGGNrlcjuDgYMTGxt7TNSIiIgzDuDds2IDTp09XW5QsP37BggWV2rOyslBSUlKj+AVBQH5+PkRRbFALHJlKU86fuTN35n53hYWFJrk3C5NEREQVPP7444iJiUFQUBBeffVV/N///R/Wrl2L1NRUvPbaa1KHR9RgfXMsFav3XgQAyGXAp+N7ooe3k7RBETVhV26uht6yZcs6uX52djb0ej08PDyM2j08PHD27Nk6uWd4eDjCwsKwZs0arFmzBnq9HhcuXICbmxscHBxqdC1BEAyrlje1IgXQtPNn7sydud+dlZWVSe7NwiQREVEFS5YsMXw/btw4+Pj4IDY2Fu3atcPo0aMljIyo4TpwPgvvbru1mu57j3ZBcGePO5xBRHVBEAR88MEH+PDDD6FWl83zam9vj9mzZ+Odd96p12/GJ0+efNdjLC0tYWlpidmzZ2P27NkoKCiAo6Mj5HJ5rXKTyWS1PrcxaMr5M3fm3tTUNHdTPUYsTBIREd1Fv3790K9fP6nDIGqwkjIK8crXJ6EXRADA8wP9MLGfr7RBETVR77zzDtauXYslS5ZgwIABAICDBw/ivffeQ0lJCRYtWmSye7m6ukKhUCAzM9OoPTMzE82bNzfZfapSPi+zXq+v0/sQEdH9YWGSiIgIwM8//3zPxz766KN1GAlR43KtoART1h9DoaZsxd2HOnvg7VGdJI6KqOn68ssv8cUXXxg9l3Xv3h1eXl545ZVXTFqYVKlU6N27N2JiYjBmzBgAZT02Y2JiMH36dJPdpyqhoaEIDQ019JgkIqL6iYVJIiIiwPCG6W5kMhl7XxDdo2KtDs9/eQJX88sWnOje0hEfP+MPhbzmK/9SIxQTA+h0gJJvScwpJycHHTt2rNTesWNH5OTk1Ph6arUaFy5cMGwnJycjPj4eLi4u8PHxQVhYGCZNmoSAgAAEBgYiMjISRUVFhlW66wp7TBIRNQx8FUBERISyHhxEZDp6QcSMb+Lxd1o+AMDLyRpfTAqAjYovP+mmDh2kjqBJ6tGjB1atWoVPPvnEqH3VqlXo0aNHja934sQJDB061LAdFhYGAJg0aRI2bNiAcePGISsrC/PmzUNGRgb8/f2xc+fOSgvimBp7TBIRNQx8ZUhEREREJqPVCbicW4x1B5Pxx5myeeXsLZVYP6UP3O1Ns3ojEdXesmXL8PDDD+OPP/4wzJ8cGxuLy5cvY8eOHTW+3gMPPABRFO94zPTp0+t86DYRETVMLEwSERFVsHDhwjvunzdvnpkiIaqf9IKIq3k3kJxdZPQv5XoRruTeMCxyAwBKuQyr/6832nvYSxgxEZUbMmQIzp07h6ioKJw9exYAMHbsWLzyyivw9PSUODrT4VBuIqKGgYVJIiKiCn788Uej7dLSUiQnJ0OpVKJNmzYsTFKTIIoirhVqcCmrrOB4ewEy9XoxtPp7m/7ggzFdMbCdax1HSw3S5s1AcTFgYwM8+6zU0TQpnp6eJl3kpj7iUG4iooaBhUkiIqIK/vrrr0ptBQUFmDx5Mh5//HEJIiKqO7lFWlzKLkJKeeHxehGSbxYji7U162lkq1LAz80Wvs1s0drVFkM6uKN3K+c6ipwavDffBNLSAC8vFibNaOfOnbCzs8PAgQMBlPUsXLNmDTp37oyoqCg4O/P/LBERmQ8Lk0RERPfAwcEBCxYswOjRo/Hcc89JHQ5Rjag1OqTm3DAuQN78l3+jtEbXUinl8G1mAz9XW/i6lhUgfZvZws/NFm52lpDJuOI2UX32xhtvYOnSpQCAv//+G2FhYZg9ezb27NmDsLAwrF+/XuIITYNDuYmIGgYWJomIiO5Rfn4+8vPzpQ6DqEolpXr8e7341nyP2UW4lK3GpWuFuF6sq9G1FHIZfFxsbhYg7eDnWvbV19UGno7WkMtZfCRqqJKTk9G5c2cAwPfff4/Ro0dj8eLFOHnyJEaNGiVxdKbDodxERA0DC5NEREQVfPLJJ0bboigiPT0dX331FUaOHClRVERAqV7AldwbSM5WIzm7GMnZaqRklxUjr+bfwF0WxjUikwGejtY3ez4aFyBbOlvDQiGvu0SISDIqlQrFxcUAgD/++AMTJ04EALi4uKCgoEDK0IiIGjStTsDJ1FycSMlBtloLVzsVAnxd0MvHGSolX1dVh4VJIiKiCj766COjbblcDjc3N0yaNAnh4eESRUVNhSCISC8oQXJWkXEB8noxLucUQyfUoPoIwMVGiTbu9vBztTUqPrZqZgMrC0UdZUFE9dXAgQMRFhaGAQMG4NixY9i6dSsA4Ny5c2jZsqXE0RERNUxanYAtx1Nx5NJ1KGQy2FgqkZRRiMT0ApzLLMQzfXxYnKwGC5NEREQVJCcnSx0CNQGiKCIxvQCn0/KNej+mXC+CRndvK16Xc7BSws/Nzmi+R79mtvBxscKNgly4u7tDLueLYSICVq1ahVdeeQX/+9//sHr1anh5eQEAfvvtN4wYMULi6EyHc0wSkTmdTM3FkUvX4eloDVvLW6U2tUaHI5euo72HPfq2biZhhPUXC5NEREREZpSSXYSf4q/ip4Q0XMoquufzrC0UN3s92hoWnin/3tnGospFZwRBwA2OzCSi2/j4+ODXX3+t1F5xtEBDxzkmicicTqTkQCGTGRUlAcDOUgmFXIYTKTksTFaDhUkiIqIKSkpK8Omnn2LPnj24du0aBMG499rJkycliowaqqxCDX49dRXb4q8i4XJetcepFHL43Fzx2lCAbGaL1m62cLfnitdEZBp6vR4//vgjzpw5AwDo1KkTxowZA6WSbw+JiGojW62FjWXVf0NtVEpkq7Vmjqjh4DMPERFRBc8//zx2796NJ598EoGBgSwGUa2oNTrsOp2BbfFpOHQhG1VNDRnk54LhXZqjnbsd/Fxt4elkDQVXvCaiOvTPP/9g9OjRyMzMRIcOHQAAS5cuhZubG3755Rd07dpV4giJiBoeVzsVkjIKq9xXrNXB29nazBE1HCxMEhERVfDrr79ix44dGDBggNShUAOj1QnYdy4L2+LT8EdiZpVzRXZq4YAx/p4Y3cMTnk58kUpNWPPmxl/JLF544QV07doVcXFxcHZ2BgDk5uZi8uTJePHFF3H48GGJIzQNzjFJROYU4OuCxPQCqDU62FWYY1IviAjwdZEwuvqNhUkiIqIKvLy8YG9vL3UY1EAIgojjKTn4KeEqdvydjrzi0krHtHS2xmP+nnjM3wvtPfi7RQQAOHFC6giapPj4eJw4ccJQlAQAZ2dnLFq0CH369JEwMtPiHJNEZE69fJxxLrOwbFVuuQw2KiWKtWVFyb6tm6GXj/PdL9JEsTBJRERUwYcffoi33noL0dHRaNWqldThUD11Jr0AP8VfxS8JV5GWd6PSfmcbCzzS3ROP+XuidytnTglARPVC+/btkZmZiS5duhi1X7t2DW3btpUoKiKihk2llOOZPj5o72GPEyk5yFZr4e1sjQBfF/TycYZKKZc6xHqLhUkiIqIKAgICUFJSgtatW8PGxgYWFhZG+3NyciSKjKR2JbcYPydcxU9/XUVSZuV5hKwtFBjexQOP+XtiUDs3WCj4IpSIpFdQUGD4PiIiAjNmzMB7772Hvn37AgCOHDmChQsXYunSpVKFSETU4KmUcvRt3Yyrb9cQC5NEREQVjB8/HmlpaVi8eDE8PDzY060JK9bqkJZ7A0eTc/BTfBqOp+RWOkYhl2FwO1c85u+Fhzp7wLaaFRmJiKTi5ORk9FwmiiKefvppQ5solq3ONXr0aM7JSEREZsVXzkRERBUcPnwYsbGx6NGjh9ShUB0rKdUjLe8GLucU40ruDVzOLcaVnGIkXytApvpvXC/SVntuLx8njOnphYe7tUAzO0szRk3USLz0EpCTA7i4AP/9r9TRNGp79uyROgQiIqIqsTBJRERUQceOHXHjRuU5A6nh0ej0SM8rKSs45t7AldxiXM65+TX3BrIKNTW6Xlt3O4zx98SjPbzg08ymjqImaiK2bwfS0gAvL6kjafSGDBlyT8edPn26jiMhIiIyxsIkERFRBUuWLMHs2bOxaNEidOvWrdIckw4ODhJFRhWV6gVk5JcY93i8rQCZWViCmyMUa0QGwMPBEi2dbeDtYoNWzWwQ3MkDXTwdOLSfiBqVwsJCfPPNN/jiiy8QFxfXaIZyR0VFISoqqtHkQ0TUWLEwSUREVMGIESMAAA8++KBRuyiKkMlkfJNjRnpBREbBbYXHnFuFxyu5N5CefwNCLQqPAOBmb4mWztbwdrYp++pS9tXT0QoW2kK09GwOuZyL1xBR47R//36sXbsW33//PTw9PTF27FhERUVJHZbJhIaGIjQ0FAUFBXB0dJQ6HCIiqgYLk0RERBVwLi7zEQQR1wo1N3s63hpmXd77MT2vBLpaVh6b2arQ0tkaLW8WHMsLkC1vfrWyUFQTk4Br14ruJy0ionopIyMDGzZswNq1a1FQUICnn34aGo0G27ZtQ+fOnaUOj4iImiAWJomIiCq417m46O5EUUSWWmNUcDQUHnOKcTWvBFq9UKtrO9lYVCo4ervcKjzaqPgyh4io3OjRo7F//348/PDDiIyMxIgRI6BQKBAdHS11aERE1ITxFTsREVEF+/fvv+P+wYMHmymS+k8UReQUaZF6vQj//JuDwrPqm8XHsh6Pabk3oNHVrvBob6lESxcbeN/Wy7F8uHVLZ2vYW1nc/SJERAQA+O233zBjxgy8/PLLaNeundThEBGRGWh1Ak6m5uJESg6y1Vq42qkQ4OuCXj7OUCnrx5RF9aIwGRUVheXLlyMjIwM9evTAp59+isDAwCqPXbNmDTZu3GhYMa53795YvHhxtccTERHV1AMPPFCp7fYFTxryHJOnruTBzr7mhUK9IOJaQYnRAjPl8z3eKK3d42GjUsC7Qi9HQwHS2QaONiw8EhGZysGDB7F27Vr07t0bnTp1wnPPPYdnnnlG6rCIiKiOaHUCthxPxZFL16GQyWBjqURSRiES0wtwLrMQz/TxqRfFSckLk1u3bkVYWBiio6MRFBSEyMhIhISEICkpCe7u7pWO37t3L8aPH4/+/fvDysoKS5cuxfDhw/HPP//Ay8tLggyIiKixyc3NNdouLS3FX3/9hblz52LRokUSRWUaz645CrmljVnuZWUhLxteXWWPRxs421hwhWsiIjPp27cv+vbti8jISGzduhXr1q1DWFgYBEHA77//Dm9vb9jb20sdZpV8fX3h4OAAuVwOZ2dnzgVNRHQPTqbm4sil6/B0tIat5a3yn1qjw5FL19Hewx59WzeTMMIykhcmV65ciWnTpmHKlCkAgOjoaGzfvh3r1q3DnDlzKh2/adMmo+0vvvgC33//PWJiYjBx4kSzxExERI1bVat3PvTQQ1CpVAgLC0NcXJwEUdU/KqUcLZ3KFpfxcrKCs4WAjt5uN4uPNnC1U7HwSERUz9ja2mLq1KmYOnUqkpKSsHbtWixZsgRz5szBQw89hJ9//lnqEKt0+PBh2NnZSR0GEVGDcSIlBwqZzKgoCQB2lkoo5DKcSMlhYVKr1SIuLg7h4eGGNrlcjuDgYMTGxt7TNYqLi1FaWgoXF5cq92s0Gmg0GsN2QUEBgLIVNwWhdnNeERFR1Rr731UPDw8kJSVJHcZ9mRDkA0ub2r2xc7VTGfV4dLOzhFxeVngsW8n6Gtzd3SGXSz8khIgagPHjgdxcwNlZ6kiarA4dOmDZsmWIiIjAL7/8gnXr1kkdEhERmUi2Wgsby6rLfjYqJbLVWjNHVDVJC5PZ2dnQ6/Xw8PAwavfw8MDZs2fv6RpvvfUWPD09ERwcXOX+iIgILFiwoFJ7VlYWSkpKah40ERFVq7CwUOoQTOLUqVNG26IoIj09HUuWLIG/v780QZlI+KhOcHBwkDoMIiJg+XKpI6CbFAoFxowZgzFjxtT43P3792P58uWIi4tDeno6fvzxx0rXqcmaAlWRyWQYMmQI5HI5Zs2ahQkTJtQ4TiKipsbVToWkjKrfnxVrdfB2tjZzRFWTfCj3/ViyZAm2bNmCvXv3wsrKqspjwsPDERYWZtguKCiAt7c33Nzc+MaMiMjEqvtb3ND4+/tDJpNBFEWj9r59+7I3CRER0W2KiorQo0cPTJ06FWPHjq20/17WFPD394dOp6t07u7du+Hp6YmDBw/Cy8sL6enpCA4ORrdu3dC9e/c6z42IqCEL8HVBYnoB1Bod7CrMMakXRAT4Vj3y2NwkLUy6urpCoVAgMzPTqD0zMxPNmze/47krVqzAkiVL8Mcff9zxScnS0hKWlpaV2uVyOYeaERGZWGP5u5qcnGy0LZfL4ebm1mgKr0RERKYycuRIjBw5str997KmQHx8/B3vUb7IaYsWLTBq1CicPHmy2veAppzKSxAEiKLY6KeqqU5Tzp+5M/fGwL+lI875ueBo8nUo5DJYq5S4oS0rSvb1awb/lo6GXGuTu6keJ0kLkyqVCr1790ZMTIyhu78gCIiJicH06dOrPW/ZsmVYtGgRdu3ahYCAADNFS0RETUWrVq3Mer+IiAj88MMPOHv2LKytrdG/f38sXboUHTp0MBxTUlKC2bNnY8uWLdBoNAgJCcFnn31WaToUIiKi+sIUawoUFRVBEATY29tDrVbjzz//xNNPP13t8aacyksQBOTn50MUxUbz4WtNNOX8mTtzbyy5D21liVY2Djh/TY2CGxo42CvRzt0erd0skZeTbTiuNrmbahovyYdyh4WFYdKkSQgICEBgYCAiIyNRVFRk+ERt4sSJ8PLyQkREBABg6dKlmDdvHjZv3gxfX19kZGQAAOzs7LhKGxER3Zc///wT06dPx5EjRypN95Gfn4/+/fsjOjoagwYNMul99+3bh9DQUPTp0wc6nQ5vv/02hg8fjsTERNja2gIAXnvtNWzfvh3fffcdHB0dMX36dIwdOxaHDh0yaSx6vR6lpaU1Pk8QBJSWlqKkpKTBv5BjLndnYWEBhUJhsutRE9WxI3D1KuDpCdzj/PLUsJhiTYHMzEw8/vjjAMqeo6ZNm4Y+ffpUe3z5VF5r1qzBmjVroNfrceHChVpN5SUIAmQyGdzc3Br880FtNOX8mTtzb0y5e7UA7vbupTa5m2o0meSFyXHjxiErKwvz5s1DRkYG/P39sXPnTsOTV2pqqtGDsnr1ami1Wjz55JNG15k/fz7ee+89c4ZORESNTGRkJKZNm1blGxdHR0e89NJLWLlypckLkzt37jTa3rBhA9zd3REXF4fBgwcjPz8fa9euxebNmzFs2DAAwPr169GpUyccOXIEffv2rXTNmg5lE0URmZmZyMvLq3UegiA0mgWQmMvdOTk5wcPDAzKZzOTXrkpjGl7FXMrI1GrICgshqtUQ68FjcT+5NIafZX3VunVrJCQk3PPx5VN5zZ49G7Nnz0ZBQQEcHR1rPZWXTCZr0tOANeX8mTtzb2pqmrupHiPJC5MAMH369GqHbu/du9doOyUlpe4DIiKiJikhIQFLly6tdv/w4cOxYsWKOo8jPz8fAODiUjYhdVxcHEpLSxEcHGw4pmPHjvDx8UFsbGyVhcmaDmUrLCyERqOBu7s7rKysalxsKn8zL5fLzVaoqivM5e7XLCkpwbVr11BUVAR7e3uTXPduGtPwKuZSxk0QoLh5jaxr1+omwBq4n1waywcZpnY/awrcr6ioKERFRUGv19fpfYiI6P7Ui8IkERFRfZCZmQkLC4tq9yuVSmRlZdVpDIIgYNasWRgwYAC6du0KAMjIyIBKpYKTk5PRsR4eHoYpTSoqH8pWrqCgAN7e3lUOZdPr9cjJyUHz5s3RrFmzWsdeWlp6x8evIWEud2Zvbw+5XI5r166hWbNmZhnW3ZiGVzGXMrKbx8vlcsPqzFK6n1y4OFrVarumgCmEhoYiNDTU0GOSiIjqJxYmiYiIbvLy8sLp06fRtm3bKvefOnUKLVq0qNMYQkNDcfr0aRw8ePC+rlM+lK2iqoZnaLVayGQy2Nra1rpXnSiKhnMbQy9D5nJ35b8ver3ebEXcxjS8irncdj5uFSmlVttcGsPPsbbUajUuXLhg2E5OTkZ8fDxcXFzg4+Nz1zUF6gp7TBIRNQwsTBIREd00atQozJ07FyNGjKjU++XGjRuYP38+HnnkkTq7//Tp0/Hrr79i//79aNmypaG9efPm0Gq1yMvLM+o1aeqhcA29CEfmxd8XIgKAEydOYOjQoYbt8t76kyZNwoYNG+66pkBdYY9JIqKGgYVJIiKim95991388MMPaN++PaZPn44OHToAAM6ePWvodfHOO++Y/L6iKOLVV1/Fjz/+iL1798LPz89of+/evWFhYYGYmBg88cQTAICkpCSkpqaiX79+Jo+HiIjoXj3wwAMQRfGOx9xpTQEiImraWJgkIiK6ycPDA4cPH8bLL7+M8PBwwxstmUyGkJAQREVF1UkPj9DQUGzevBk//fQT7O3tDfNGOjo6wtraGo6Ojnj++ecRFhYGFxcXODg44NVXX0W/fv2qXPiGiIioqeNQbiKihoGFSSIiotu0atUKO3bsQG5uLi5cuABRFNGuXTs4OzvX2T1Xr14NoKzXye3Wr1+PyZMnAwA++ugjyOVyPPHEE9BoNAgJCcFnn31WZzHR/Xvvvfewbds2xMfHSx0KEVGTw6HcREQNQ9OdpZmIiOgOnJ2d0adPHwQGBtZpURIoG8pd1b/yoiRQtuJrVFQUcnJyUFRUhB9++MGk80s2VFFRUfD19YWVlRWCgoJw7NixOx6/Zs0aDBo0CM7OznB2dkZwcPBdz3nvvffg7+9vwqiJiIiIiAhgYZKIiIgaqK1btyIsLAzz58/HyZMn0aNHD4SEhODatWvVnrN3716MHz8ee/bsQWxsLLy9vTF8+HCkpaWZMfJ7V1paKnUIRHUnOhr49tuyr0QmFhUVhc6dO6NPnz5Sh0JERHfAwiQRERE1SCtXrsS0adMwZcoUdO7cGdHR0bCxscG6deuqPWfTpk145ZVX4O/vj44dO+KLL76AIAiIiYmp8vgNGzZgwYIFSEhIgEwmg0wmw4YNGwAAqampeOyxx2BnZwcHBwc8/fTTyMzMvGPMX3zxBTp16gQrKyt07NjRaDh+SkoKZDIZtm7diiFDhsDKygqbNm3C9evXMX78eHh5ecHGxgbdunXDN998Y3TdBx54ADNmzMCbb74JFxcXNG/eHO+9957RMXl5eXjppZfg4eEBKysrdO3aFb/++qth/8GDBzFo0CBYW1vD29sbM2bMQFFR0R3zIbovjzwCPPVU2VciEwsNDUViYiKOHz8udShERHQHnGOSiIiIqrdyZdm/u+nVC/j+e+O2Rx8FTp68+7lhYWX/akCr1SIuLg7h4eGGNrlcjuDgYMTGxt7zdYqLi1FaWgoXF5cq948bNw6nT5/Gzp078ccffwAoW5RIEARDUXLfvn3Q6XQIDQ3FuHHjsHfv3iqvtWnTJsybNw+rVq1Cz5498ddff2HatGmwtbXFpEmTDMfNmTMHH374IXr27AkrKyuUlJSgd+/eeOutt+Dg4IDt27fjueeeQ5s2bRAYGGg478svv0RYWBiOHj2K2NhYTJ48Gf3798fQoUMhCAJGjhyJwsJCfP3112jTpg0SExOhUCgAABcvXsSIESPwwQcfYN26dcjKyjKsort+/fp7fjyJiIiIiGqChUkiIiKqXkEBcC/DnL29K7dlZd3buQUFNQ4rOzsber2+0irpHh4eOHv27D1f56233oKnpyeCg4Or3G9tbQ07OzsolUqjOT1///13/P3330hOTob3zdw3btyILl264Pjx41UOHZw/fz4+/PBDjB07FgDg5+eHxMRE/Pe//zUqTM6aNctwTLnXX3/d8P2rr76KXbt24dtvvzUqTHbv3h3z588HALRr1w6rVq1CTEwMhg4dij/++APHjh3DmTNn0L59ewBA69atDedGRERgwoQJmDVrluH8Tz75BEOGDMHq1athZWV19weTiIiIiKiGWJgkIiKi6jk4AF5edz/Oza3qtns518Gh5nGZwJIlS7Blyxbs3bu3xoW3M2fOwNvb21CUBIDOnTvDyckJZ86cqVSYLCoqwsWLF/H8889j2rRphnadTldptdiAgACjbb1ej8WLF+Pbb79FWloatFotNBoNbGxsjI7r3r270XaLFi0M823Gx8ejZcuWhqJkRQkJCTh16hQ2bdpkaBNFEYIgIDk5GZ06dbrbQ0JUc3FxgFYLqFRA795SR0ONTFRUFKKioqDX66UOhYiI7oCFSSIiIqrevQ6zFkVApzNu+/nnuokJgKurKxQKRaU5HTMzM+9ptfIVK1ZgyZIl+OOPPyoV9OqCWq0GULYqeFBQkNG+8uHU5WxtbY22ly9fjo8//hiRkZHo1q0bbG1tMWvWLGi1WqPjLCwsjLZlMhlEUQRQ1vPzbvG99NJLmDFjRqV9Pj4+dzyXqNYee6ysV7WXF3DlitTRUCMTGhqK0NBQFBQUVPoAiIiI6g8WJomIiKjBUalU6N27N2JiYjBmzBgAMCxiM3369Dueu2zZMixatAi7du2q1DuxuntV7HHTqVMnXL58GZcvXzb0mkxMTEReXh46d+5c6RoeHh7w9PTEpUuXMGHChHvMssyhQ4fw2GOP4f/+7/8AlOV57ty5Ku9Tne7du+PKlSs4d+5clb0me/XqhcTERLRt27ZGsRERERER3Q8WJomIiKhBCgsLw6RJkxAQEIDAwEBERkaiqKgIU6ZMMRwzceJEeHl5ISIiAgCwdOlSzJs3D5s3b4avry8yMjIAAHZ2drCzs6vyPr6+vkhOTjYMh7a3t0dwcDC6deuGCRMmIDIyEjqdDq+88gqGDBlSbbFzwYIFmDFjBhwdHTFixAhoNBqcOHECubm5CLtDr9R27drhf//7Hw4fPgxnZ2esXLkSmZmZNSpMDhkyBIMHD8YTTzyBlStXom3btjh79ixkMhlGjBiBt956C3379sX06dPxwgsvwNbWFomJifj999+xatWqe74PEREREVFNyKUOgIiIiKg2xo0bhxUrVmDevHnw9/dHfHw8du7cabQgTmpqKtLT0w3bq1evhlarxZNPPokWLVoY/q1YsaLa+zzxxBMYMWIEhg4dCjc3N3zzzTeQyWT46aef4OzsjMGDByM4OBitW7fG1q1bq73OCy+8gC+++ALr169Ht27dMGTIEGzYsAF+fn53zPPdd99Fr169EBISggceeADNmzc39BKtie+//x59+vTB+PHj0blzZ7z55puGnqDdu3fHvn37cO7cOQwaNAg9e/bEvHnz4OnpWeP7EBHVB1FRUejcuXOVi5EREVH9IRPLJx9qIsrnGMnPz4eDRJPtExE1VvwbW3/d6WdTUlKC5ORk+Pn51Xr1ZVEUodPpoFQqIZPJTBGyZJjLvTHF701NCIKAa9euwd3dHXJ5w/5snbnc1LJlvZpj8n5y4fNf/XU/P5vG9H+1Nppy/syduTP3uzPVc1/TeqSJiIiIiIiIiIioXmBhkoiIiIiIiIiIiMyOhUkiIiIiIiIiIiIyOxYmiYiIiIiIiIiIyOxYmCQiIiIiIiIiIiKzU0odABERERERNUFnzgCiCJh4xXgiAIiKikJUVBT0er3UoRAR0R2wxyQREREREZmfvT3g4FD2lcjEQkNDkZiYiOPHj0sdChER3QELk0RERERERERERGR2LEwSERERERERERGR2bEwSURERA1WYWEhZs2ahVatWsHa2hr9+/c3GrYniiLmzZuHFi1awNraGsHBwTh//rxhv0ajwXPPPQcHBwe0b98ef/zxh9H1ly9fjldffdVs+RA1KStXAu+9V/aViIiImiQWJomIiKjBeuGFF/D777/jq6++wt9//43hw4cjODgYaWlpAIBly5bhk08+QXR0NI4ePQpbW1uEhISgpKQEAPD5558jLi4OsbGxePHFF/Hss89CFEUAQHJyMtasWYNFixZJlh9Ro7ZyJbBgAQuTRERETRgLk0RERNQg3bhxA99//z2WLVuGwYMHo23btnjvvffQtm1brF69GqIoIjIyEu+++y4ee+wxdO/eHRs3bsTVq1exbds2AMCZM2fw6KOPokuXLggNDUVWVhays7MBAK+88gqWLl0KBwcHCbMkIqLk5GQMHToUnTt3Rrdu3VBUVCR1SEREZCIsTBIREVGDpNPpoNfrYWVlZdRubW2NgwcPIjk5GRkZGQgODjbsc3R0RFBQEGJjYwEAPXr0wMGDB3Hjxg3s2rULLVq0gKurKzZv3gwrKys8/vjjZs2JiIgqmzx5MhYuXIjExETs27cPlpaWUodEREQmopQ6ACIiIqq/CjWFUGvVRm1WSis4WztDJ+iQVZQFoGwuR51eB6VCCU8HTwBAdnE2SvWlRuc6WTnB2sIaRdoiFGgKjPbZqexgb2l/z7HZ29ujX79+eP/999GpUyd4eHjgm2++QWxsLNq2bYuMjAwAgIeHh9F5Hh4ehn1Tp07FqVOn0LlzZ7i6uuLbb79Fbm4uFi5ciD179uDdd9/Fli1b0KZNG6xbtw5eXl73HB8REd2/f/75BxYWFhg0aBAAwMXFReKIiIjIlFiYJCIiomrFpcdhb8peo7buHt0xttNYFGgK8N+4/wIoK0wKggC5XI4FQxcAALad3YYrBVeMzh3baSy6e3THP1n/YMf5HUb7HvB9AA/4PlCj+L766itMnToVXl5eUCgU6NWrF8aPH4+4uLh7Ot/CwgJRUVFGbVOmTEFoaCj++usvbNu2DQkJCVi2bBlmzJiB77//vkbxERE1dvv378fy5csRFxeH9PR0/PjjjxgzZozRMVFRUVi+fDkyMjLQo0cPfPrppwgMDLyn658/fx52dnYYPXo00tLS8OSTT+Ltt9+ug0yIiEgKLEwSERFRtXq36I0OzToYtVkpy4ZOO1g64KXeLwEw7jFZbkzHMVX2mASALm5d4O3gbbTPTmVX4/jatGmDffv2oaioCAUFBWjRogXGjRuH1q1bo3nz5gCAzMxMtGjRwnBOZmYm/P39q7zenj178M8//2D16tUIDw/HqFGjYGtri6effhqrVq2qcXxERI1dUVERevTogalTp2Ls2LGV9m/duhVhYWGIjo5GUFAQIiMjERISgqSkJLi7uwMA/P39odPpKp27e/du6HQ6HDhwAPHx8XB3d8eIESPQp08fPPTQQ3WeGxER1T0WJomIiKha9pb21Q6vVsqVaGFfVvATRRE6nQ5K5a2XFq42rtVe11ZlC1uVrcnitLW1ha2tLXJzc7Fr1y4sW7YMfn5+aN68OWJiYgyFyIKCAhw9ehQvv/xypWuUlJQgNDQUX3/9NRQKBfR6vWFfaWmp0TYREZUZOXIkRo4cWe3+lStXYtq0aZgyZQoAIDo6Gtu3b8e6deswZ84cAEB8fHy153t5eSEgIADe3mUfZo0aNQrx8fHVFiY1Gg00Go1hu6CgbNoQQRAgCEKNchMEwTAioClqyvkzd+be1NQmd1M9TixM0n3LycnBkCFDcPXqVXh6emLfvn2c+4Xqtfz8fDz88MNITU2Fj48Ptm/fDkdHR6nDIqJa2LVrF0RRRIcOHXDhwgW88cYb6NixI6ZMmQKZTIZZs2bhgw8+QLt27eDn54e5c+fC09Oz0jBDAHj//fcxatQo9OzZEzqdDgMGDMCbb76JKVOmYNWqVRgwYID5EyQiasC0Wi3i4uIQHh5uaJPL5QgODjYsQnY3ffr0wbVr15CbmwtHR0fs378fL730UrXHR0REYMGCBZXas7KyUFJSUqP4BUFAfn4+RFGEXN701o1tyvkzd+bO3O+usLDQJPdmYZLuS/PmzZGZmWnYzsnJQbNmzYwWFiCqT9q2bYuLFy8ati9fvgwnJye0adMGFy5ckDAyIqqN/Px8hIeH48qVK3BxccETTzyBRYsWwcLCAgDw5ptvoqioCC+++CLy8vIwcOBA7Ny5s9JK3qdPn8a3335r1GvnySefxL59+zBo0CB06NABmzdvNmdqREQNXnZ2NvR6fZWLkJ09e/aerqFUKrF48WIMHjwYoihi+PDheOSRR6o9Pjw8HGFhYVizZg3WrFkDvV6PCxcuwM3NDQ4ODjWKXxAEyGQyuLm5NbkiBdC082fuzL0x5q7VCfjrch7iUnKQrdbC1U6F3r4u6OntBKUcNc694uvp2qoXhcmaTob83XffYe7cuUhJSUG7du2wdOlSjBo1yowRE2BclOzbty8WLVqEd955B0eOHEFmZiaaN2/O4iTVK7cXJUeMGIH58+djwYIF2LlzJy5evIi2bduyOEnUwDz99NN4+umnq90vk8mwcOFCLFy48I7X6dq1K86fPw+gbFg6UNar57PPPsNnn31muoCJ6JZevQBvb8DNTepIqJ6723Dx21laWsLS0hKzZ8/G7NmzUVBQAEdHR8jl8loVGmQyWa3PbQyacv7Mnbk3JlqdgG/jruDIpetQyGSwsVQiKVONxIxCnL+mxtO9W9Y4d1M9RpIXJu9lMuTbHT58GOPHj0dERAQeeeQRbN68GWPGjMHJkyfRtWtXCTJomnJycgxFycLCQtjZlS1YEBsbC7VaDXt7e2RmZiInJ4fDuqleyM/PNxQli4qKYGNjAwD47bffUFxcDFtbW1y8eBH5+fkc1k1ERGQOP/8sdQRUx1xdXaFQKIxGWAEwdGKoS1FRUYiKiuL8wEREAE6m5uLIpevwdLSGreWtUqBao8ORS9fRzt0Ofqab/r1GJC9M3stkyLf7+OOPMWLECLzxxhsAyuaD+v3337Fq1SpER0dXOt6Ukx/TLYMHDwYABAUFwcbGxuixtLGxQWBgII4dO4bBgwfj1KlTUoVJZFDeqzokJARWVlZGv7NWVlYYPnw4du/ejVGjRuHAgQNShdng8e8qERERlVOpVOjduzdiYmIMc/sKgoCYmBhMnz69Tu8dGhqK0NBQQ49JIqKm7ERKDhQymVFREgDsLJVQyGWIS8mBX5eaTXdhKpIWJmszGXJsbCzCwsKM2kJCQrBt27Yqjzfl5Md0S1paGgDg9ddfx7Vr1yrtf+211zB+/HikpaVVuZ/I3FJSUgAAr776apW/k6+88gp2796NlJQU/s7eB1NNgExEREQNg1qtNpoKJzk5GfHx8XBxcYGPjw/CwsIwadIkBAQEIDAwEJGRkSgqKjJ0TKkr7DFJRHRLtloLG8uqS4A2KiWy1VozR3SLpIXJ2kyGnJGRUeXx1c1lWD75cbmCggJ4e3vXavJjusXLywt5eXlYsWIFxo4dW2n/Rx99ZDiuqiH5RObm6+uLq1ev4tNPP8WOHTsq7S+fQ87X15e/s/fBVBMgExERUcNw4sQJDB061LBd/t5r0qRJ2LBhA8aNG4esrCzMmzcPGRkZ8Pf3x86dOyu9pzM19pgkIrrF1U6FpIyqO5EUa3XwdrIzc0S3SD6Uu66VT35cUWOczNSc9u/fj2bNmuHo0aMoLi42zDEJlH1qeuzYMcNxfJypPtixYwecnJywa9culJSUGOaYBIDi4mLs3r3bcBx/Z2uPj13DVr7oC9G94O8L3bdHHwWyssoWv+F8kw3WAw88cNe/B9OnT6/zodtERFS9AF8XJKYXQK3Rwa7CHJN6QURvXxcAOklik/QdZG0mQ759Jeh7OZ7qhouLi+FTTnt7ewQFBWHXrl0ICgqCvb09gLKerFz4huoLR0dHtGnTBgBga2uLkJAQHDhwACEhIbC1LZvlt02bNvxEnZokCwsLAGVFeqJ7Vf77Uv77Q1RjJ08CR46UfSUysaioKHTu3Bl9+vSROhQiIsn18nFG39bNkJ5/A5ey1cgoKMGlbDXS82+gb+tm6OntJFlskvaYrM1kyP369UNMTAxmzZplaPv999/Rr18/M0RMt8vIyDAUio8dO4YRI0YY9t1peD2RVC5cuIC2bdvi4sWL2L17t6GXJFBWlLx9fiSipkShUMDJyckwv6qNjQ1kMlmNriGKInQ6HZRKZY3PrW+Yy92vWVxcjGvXrsHJyQkKhcIk1yUiMiUO5SYiukWllOOZPj5o72GPEyk5yFZr4e1sjQBfF/TycYZSwm6Lkg/lvttkyBMnToSXlxciIiIAADNnzsSQIUPw4Ycf4uGHH8aWLVtw4sQJfP7551Km0WRlZGQgJycHQ4YMwdWrV+Hp6Yl9+/axpyTVWxcuXEB+fj4efvhhpKamwsfHB9u3b+cLVmoQoqKisHz5cmRkZKBHjx749NNPERgYaJJrl488qO3iT6IoQhAEyOXyRlHMYy535+TkxBErRERERA2ESilH39bN0Ld1s0r7BEGQIKIykhcm7zYZcmpqqtGcZf3798fmzZvx7rvv4u2330a7du2wbds2dO3aVaoUmjwXFxf8/fffUodBdM8cHR1x8OBBqcMgqpGtW7ciLCwM0dHRCAoKQmRkJEJCQpCUlGSSBZtkMhlatGgBd3d3lJaW1vh8QRBw/fp1NGvWrMHPNcpc7s7CwoI9JYmoXuOq3EREDYPkhUngzpMh7927t1LbU089haeeeqqOoyIiIqo/Vq5ciWnTphlGFERHR2P79u1Yt24d5syZY7L7KBSKWhWcBEGAhYUFrKysGkUxj7kQETVsHMpNRNQw1IvCJBEREVVPq9UiLi4O4eHhhja5XI7g4GDExsZWeY5Go4FGozFsFxQUACgrVNXFUA1BEAzDhhs65lI/MZf66X5ykd38JwIQ68FjcT+5NIafJRERkRRYmCQiIqrnsrOzodfrDdOclPPw8MDZs2erPCciIgILFiyo1J6VlYWSkhKTxygIAvLz8yGKYoPvmcdc6ifmUj/dTy5uggDFzWtk1XJ+W1O6n1wKCwvrKCoiIqLGjYVJIiKiRig8PBxhYWGG7YKCAnh7e8PNzQ0ODg4mv58gCJDJZHBzc2sUhRbmUv8wl/rpfnKR3TxeLpebZK7c+3U/uVhZWdVRVFRbnGOSiKhhaHKFSVEUAdwa0kZERKZT/re1/G8tmYarqysUCgUyMzON2jMzM6tdFdnS0hKWlpaG7fKfiVqtrpNCiCAIUKvVsLa2bhSFFuZS/zCX+um+cikf/iwIgFpt+uBq6H5yUd+Mn89/9Uf5HJP5+flwcnKq1fs/QRBQWFjYZOfpbcr5M3fmztzvzlTv/ZpcYbJ8mIW3t7fEkRARNV6FhYWcaN6EVCoVevfujZiYGIwZMwZA2YuHmJiYahePq4jPf0RUb6WnA43kOYPPf/UPn/+IiOrW/T73ycQm9rGeIAi4evUq7O3tIZPJpA6n0SgfInj58uU6GSJIZGr8na0boiiisLAQnp6eTe5Txrq2detWTJo0Cf/9738RGBiIyMhIfPvttzh79myluSerUvH5r0+fPjh+/LjRMRXb7rRd/n351/v9P1VVPPd6DHNhLsyFuUidC5//6q/7ef/X1F8vNuX8mTtzZ+53Z6rnvibXY1Iul6Nly5ZSh9FoOTg4NLn/wNSw8XfW9NhTpG6MGzcOWVlZmDdvHjIyMuDv74+dO3feU1ESqPz8p1AoKv3uV2y703b59xWPqe3/qariuddjmAtzYS7MpT7kwue/+skU7/+a+uvFppw/c2fuTU1NczfFc1+TK0wSERE1VNOnT7/nodt3Exoaete2O22Xf1/VdUwVz70ew1yYy71gLtW3MxfT5EJEREQ11+SGclPdKCgogKOjI/Lz85vsJwvUsPB3lsi0GtP/KeZSPzGX+om5UGPW1H8nmnL+zJ25M3fz4QQoZBKWlpaYP3++0QqwRPUZf2eJTKsx/Z9iLvUTc6mfmAs1Zk39d6Ip58/cmXtTI2Xu7DFJREREREREREREZscek0RERERERERERGR2LEwSERERERERERGR2bEwSURERERERERERGbHwiQRERERERERERGZHQuTREREREREREREZHYsTDYxkydPxpgxY6QOg8ikJk+eDJlMhiVLlhi1b9u2DTKZTKKoiKg6ycnJGDp0KDp37oxu3bqhqKhI6pBqzdfXF927d4e/vz+GDh0qdTj3rbi4GK1atcLrr78udSi1lpeXh4CAAPj7+6Nr165Ys2aN1CHV2uXLl/HAAw+gc+fO6N69O7777jupQ7ovjz/+OJydnfHkk09KHUqN/frrr+jQoQPatWuHL774QupwyISioqLg6+sLKysrBAUF4dixY3c8/rvvvkPHjh1hZWWFbt26YceOHWaK1PRqkvuaNWswaNAgODs7w9nZGcHBwXd9rOq7mv7sy23ZsgUymazBvq+uad55eXkIDQ1FixYtYGlpifbt2zeZ33sAiIyMRIcOHWBtbQ1vb2+89tprKCkpMVO0prF//36MHj0anp6ekMlk2LZt213P2bt3L3r16gVLS0u0bdsWGzZsqLP4WJgkokbBysoKS5cuRW5urtShENFdTJ48GQsXLkRiYiL27dsHS0tLqUO6L4cPH0Z8fDz27NkjdSj3bdGiRejbt6/UYdwXe3t77N+/H/Hx8Th69CgWL16M69evSx1WrSiVSkRGRiIxMRG7d+/GrFmzGnQhf+bMmdi4caPUYdSYTqdDWFgY/vzzT/z1119Yvnx5g/2dImNbt25FWFgY5s+fj5MnT6JHjx4ICQnBtWvXqjz+8OHDGD9+PJ5//nn89ddfGDNmDMaMGYPTp0+bOfL7V9Pc9+7di/Hjx2PPnj2IjY2Ft7c3hg8fjrS0NDNHbho1zb9cSkoKXn/9dQwaNMhMkZpWTfPWarV46KGHkJKSgv/9739ISkrCmjVr4OXlZebITaOm+W/evBlz5szB/PnzcebMGaxduxZbt27F22+/bebI709RURF69OiBqKioezo+OTkZDz/8MIYOHYr4+HjMmjULL7zwAnbt2lU3AYrUpEyaNEl87LHHqtz3999/iyNGjBBtbW1Fd3d38f/+7//ErKwsw/6CggLx2WefFW1sbMTmzZuLK1euFIcMGSLOnDnTcMzGjRvF3r17i3Z2dqKHh4c4fvx4MTMz0+g+p0+fFh9++GHR3t5etLOzEwcOHCheuHBB3Ldvn6hUKsX09HSj42fOnCkOHDjQZI8BNT6TJk0SH3nkEbFjx47iG2+8YWj/8ccfxdv/zB04cEAcOHCgaGVlJbZs2VJ89dVXRbVaLYqiKH766adily5dKp27evVqQ9uDDz4ovvPOO2bIiKjxOn36tPjggw9KHYbJtGrVSiwsLJQ6DJM4d+6cOHbsWHH9+vXi7NmzpQ7HJK5fvy62atXK6PVMQ9a9e3cxNTVV6jDuy549e8QnnnhC6jBq5NChQ+KYMWMM2zNnzhQ3b94sYURkKoGBgWJoaKhhW6/Xi56enmJERESVxz/99NPiww8/bNQWFBQkvvTSS3UaZ12oae4V6XQ60d7eXvzyyy/rKsQ6VZv8dTqd2L9/f/GLL7644/vq+qymea9evVps3bq1qNVqzRVinapp/qGhoeKwYcOM2sLCwsQBAwbUaZx1CYD4448/3vGYN9980+i9sSiK4rhx48SQkJA6iYk9JglAWffsYcOGoWfPnjhx4gR27tyJzMxMPP3004ZjwsLCcOjQIfz888/4/fffceDAAZw8edLoOqWlpXj//feRkJCAbdu2ISUlBZMnTzbsT0tLw+DBg2FpaYk///wTcXFxmDp1KnQ6HQYPHozWrVvjq6++Mrrepk2bMHXq1Dp/DKhhUygUWLx4MT799FNcuXKl0v6LFy9ixIgReOKJJ3Dq1Cls3boVBw8exPTp0wEAQ4YMQWJiIrKysgAA+/btg6urK/bu3Qug7HcxNjYWDzzwgLlSIpLEvQz1qO3QJwA4f/487OzsMHr0aPTq1QuLFy82YfTG6joXAJDJZBgyZAj69OmDTZs2mSjyysyRy+uvv46IiAgTRVw9c+SSl5eHHj16oGXLlnjjjTfg6upqouiNmSOXcnFxcdDr9fD29r7PqKtmzlzM7X5zu3r1qlHvIC8vrwbbS4xu0Wq1iIuLQ3BwsKFNLpcjODgYsbGxVZ4TGxtrdDwAhISEVHt8fVWb3CsqLi5GaWkpXFxc6irMOlPb/BcuXAh3d3c8//zz5gjT5GqT988//4x+/fohNDQUHh4e6Nq1KxYvXgy9Xm+usE2mNvn3798fcXFxhueES5cuYceOHRg1apRZYpaKuf/WKevkqtTgrFq1Cj179jR6g7hu3Tp4e3vj3LlzaNGiBb788kts3rwZDz74IABg/fr18PT0NLrO7QXE1q1b45NPPkGfPn2gVqthZ2eHqKgoODo6YsuWLbCwsAAAtG/f3nDO888/j/Xr1+ONN94AAPzyyy8oKSkxKpASVefxxx+Hv78/5s+fj7Vr1xrti4iIwIQJEzBr1iwAQLt27fDJJ59gyJAhWL16Nbp27QoXFxfs27cPTz75JPbu3YvZs2fj448/BgAcO3YMpaWl6N+/v7nTIjKr8qEeU6dOxdixYyvtLx8CEx0djaCgIERGRiIkJARJSUlwd3cHAPj7+0On01U6d/fu3dDpdDhw4ADi4+Ph7u6OESNGoE+fPnjooYcaXC6enp44ePAgvLy8kJ6ejuDgYHTr1g3du3dvcLkcP34c7du3R/v27XH48GGTx2/OXDw9PeHk5ISEhARkZmZi7NixePLJJ+Hh4dEgcwGAnJwcTJw4sU7nyzRXLlIwRW7U+GRnZ0Ov11f62+Dh4YGzZ89WeU5GRkaVx2dkZNRZnHWhNrlX9NZbb8HT07NS8aIhqE3+Bw8exNq1axEfH2+GCOtGbfK+dOkS/vzzT0yYMAE7duzAhQsX8Morr6C0tBTz5883R9gmU5v8n332WWRnZ2PgwIEQRRE6nQ7/+c9/GtxQ7pqq7m9dQUEBbty4AWtra9PesE76YVK9VV2X8yeffFK0sLAQbW1tjf4BEHfs2CHGx8eLAMR///3X6LyePXsaDeU+ceKE+Mgjj4je3t6inZ2daGNjIwIQ//nnH1EURXHkyJHixIkTq40vMzNTtLCwEGNjY0VRFMXRo0eLU6dOvf/EqVG7/fd63759okKhEBMTE42GcgcEBIgqlcro97v89zMxMVEURVF8/PHHxdDQUDE3N1dUqVRifn6+6OzsLJ45c0ZctGiR2L9/f6lSJJIEqhjqcb9Dvw4fPiwOHz7csL1s2TJx2bJlJon3Tuoil4pef/11cf369fcR5b2pi1zmzJkjtmzZUmzVqpXYrFkz0cHBQVywYIEpw66SOX4uL7/8svjdd9/dT5j3pK5yKSkpEQcNGiRu3LjRVKHeVV3+XKQeyl2b3Koayr1p0yazxEt1Jy0tTQQgHj582Kj9jTfeEAMDA6s8x8LCotIw/qioKNHd3b3O4qwLtcn9dhEREaKzs7OYkJBQVyHWqZrmX1BQIPr6+oo7duwwtDXEody1+bm3a9dO9Pb2FnU6naHtww8/FJs3b16nsdaF2uS/Z88e0cPDQ1yzZo146tQp8YcffhC9vb3FhQsXmiPkOlHV82BF7dq1ExcvXmzUtn37dhGAWFxcbPKYOJSbAABqtRqjR49GfHy80b/z589j8ODB93SNoqIihISEwMHBAZs2bcLx48fx448/AijrNg3grpV1d3d3jB49GuvXr0dmZiZ+++03DuOmGhk8eDBCQkIQHh5u1K5Wq/HSSy8Z/X4nJCTg/PnzaNOmDQDggQcewN69e3HgwAH07NkTDg4OGDx4MPbu3Yt9+/ZhyJAhUqREVG+YYuhXnz59cO3aNeTm5kIQBOzfvx+dOnWqq5CrZYpcioqKUFhYCKDsb8yff/6JLl261Em8d2KKXCIiInD58mWkpKRgxYoVmDZtGubNm1dXIVfLFLlkZmYafi75+fnYv38/OnToUCfx3okpchFFEZMnT8awYcPw3HPP1VWod2WKXOqre8ktMDAQp0+fRlpaGtRqNX777TeEhIRIFTKZiKurKxQKBTIzM43aMzMz0bx58yrPad68eY2Or69qk3u5FStWYMmSJdi9e3edjBAwh5rmf/HiRaSkpGD06NFQKpVQKpXYuHEjfv75ZyiVSly8eNFcod+X2vzc/7+9Ow+K6krbAP40O7KKK6CIuMEYVhUl2qIOARxFzBglaiIomMIFQSNuo2JAUVKgCToxUYgkFkRMGZe4EVRUqmsswQXRIJsaiYKTMQYDVpDlfH/k88ZmB5tFfX5VXcU9995zznvbounXs5iammLw4MFQV1eXymxsbFBSUiJ9x39ZtCb+devW4f3330dAQABsbW3x9ttvIzIyEps3b0ZNTU17dLtDNPS7ztDQUPWjJcFduen/OTk54caNG7C0tMTAgQOVXnp6erCysoKmpiYyMjKke0pLS5GXlycd37x5Ew8fPsSWLVsgl8thbW1dZ3crOzs7pKeno7KyssG+BAQEIDk5Gbt27cKAAQMwevRo1QdMr7QtW7bg+++/V/qy5OTkhB9//LHOv++BAwdCS0sLwF/rTH777bfSWpLjxo3DqVOnoFAouL4kvfYamwLT3GlsGhoaiIyMxNixY2FnZ4dBgwZh8uTJbdHdRqkilgcPHmDMmDGwt7fHqFGjMGfOHIwYMaItutsoVcTSWagilp9++glyuRz29vaQy+UICgqCra1tW3S3UaqIRaFQIDk5GYcOHYKDgwMcHByQnZ3dFt1tlKr+jbm5uWH69Ok4fvw4+vTp0ymSms2JTUNDAzExMRg/fjwcHBzw4Ycfolu3bh3RXVIhLS0tDBs2DKdPn5bKampqcPr0abi4uNR7j4uLi9L1AJCamtrg9Z1Va2IHgI8//hgRERE4efIkhg8f3h5dbRMtjd/a2hrZ2dlKAxymTJki7VjcVmv/qlpr3vfRo0ejoKBAKQn3bKm3Z9+hXhatif/JkydQU1NOmz1L0v45+PDV1N6/67jG5GuotLS0ztoYH3zwAXbv3o2ZM2dixYoVMDExQUFBAfbt24e4uDgYGBjA19cXoaGhMDExQc+ePREWFgY1NTXIZDIAgIWFBbS0tLB9+3YEBgbi+vXriIiIUGpn8eLF2L59O959912sXr0aRkZGuHDhApydnaXRDM9GXW7cuBHh4eHt8kzo1WJra4vZs2cjNjZWKlu5ciVGjRqFxYsXIyAgAHp6evjxxx+RmpqKHTt2APgzcd61a1ckJSXh6NGjAP5MTC5fvhwymYxJciIVmThxIiZOnNjR3XhhVlZWyMrK6uhuqNzzm9a9jJydnV/qNcCeN2bMmFdqRMapU6c6ugutNmXKFEyZMqWju0EqtmzZMvj6+mL48OFwdnbGJ598gvLycsydOxcAMGfOHJibm0sbgwUHB8PV1RUxMTGYNGkS9u3bh8zMTOzatasjw2iVlsYeFRWF9evXIykpCZaWllLiXl9fH/r6+h0WR2u1JH4dHR288cYbSvcbGxsDQJ3yzq6l7/uCBQuwY8cOBAcHIygoCPn5+YiMjMSSJUs6MoxWa2n8Xl5e2Lp1KxwdHTFy5EgUFBRg3bp18PLyUhpF2tmVlZWhoKBAOr59+zauXr0KExMTWFhYYPXq1bh37x6+/vprAEBgYCB27NiBFStWYN68eThz5gz279+PY8eOtUn/mJh8DZ09exaOjo5KZf7+/lAoFFi5ciXc3d1RUVGBfv36wdPTU/ofgq1btyIwMBCTJ0+GoaEhVqxYgaKiIujo6AAAevTogYSEBKxZswaxsbFwcnJCdHS00h9x3bp1w5kzZxAaGgpXV1eoq6vDwcFBKeGjpqYGPz8/REZGYs6cOe3wROhVFB4ejuTkZOnYzs4O586dw7/+9S/I5XIIITBgwAD4+PhI18hkMsjlchw7dgxjxoyR7jM0NMSQIUOgp6fX7nEQdSYvMvWrs2EsnRNj6ZxepVhqe5Vjo6b5+Pjgl19+wfr161FSUgIHBwecPHlSGkF79+5dpdFSb775JpKSkrB27VqsWbMGgwYNwqFDh1665BTQ8th37tyJp0+f4p133lGqJywsDBs2bGjPrqtES+N/VbQ07r59+yIlJQVLly6FnZ0dzM3NERwcjJUrV3ZUCC+kpfGvXbsWMpkMa9euxb1799CjRw94eXlh06ZNHRVCq2RmZmL8+PHS8bJlywAAvr6+SEhIQHFxMe7evSud79+/P44dO4alS5fi008/RZ8+fRAXF9d2y5iofNVKem2UlZUJIyMjERcXp/K6582bJ7y8vFReLxERNR8a2CRi8eLF0nF1dbUwNzdv9cYk7YWxdE6MpXN6lWKp7VWOjYiI6GXEEZPUbFeuXMHNmzfh7OyM0tJSaZq1t7e3ytooLS1FdnY2kpKScOTIEZXVS0REzdPUVI+mpsB0JoyFsbQ1xtI5Y6ntVY6NiIjopdfRmVF6eVy+fFk4OTkJPT090bVrV+Hm5iauXbum0jZcXV2Frq6uCAkJUWm9RETUPGlpaQJAnZevr690zfbt24WFhYXQ0tISzs7O4sKFCx3X4UYwFsbS1hhL54yltlc5NiIiopedTIhXeCshIiIiIiIiIiIi6pRevdVciYiIiIiIiIiIqNNjYpKIiIiIiIiIiIjaHROTRERERERERERE1O6YmCQiIiIiIiIiIqJ2x8QkERERERERERERtTsmJomIiIiIiIjolePn54epU6d2dDdULisrC1OmTEHPnj2ho6MDS0tL+Pj44L///W9Hd42oxZiYJCIiIiIiIiJ6Cfzyyy/4+9//DhMTE6SkpCAnJwd79uyBmZkZysvL26zdysrKNqubXm9MTBIRERERERHRa+f69euYOHEi9PX10atXL7z//vv43//+J53//fffMXv2bOjp6cHU1BTbtm3DuHHjEBISIl2zd+9eDB8+HAYGBujduzdmzZpVZ+TijRs3MHnyZBgaGsLAwAByuRyFhYU4f/48NDU1UVJSonR9SEgI5HJ5vX1WKBQoLS1FXFwcHB0d0b9/f4wfPx7btm1D//79m2wTAGpqahAeHo4+ffpAW1sbDg4OOHnypHTvnTt3IJPJkJycDFdXV+jo6CAxMREAEBcXBxsbG+jo6MDa2hqfffZZ6x4+0f9jYpKIiIiIiIiIXiu//fYbJkyYAEdHR2RmZuLkyZN48OABZsyYIV2zbNkyKBQKHDlyBKmpqUhPT8fly5eV6qmsrERERASysrJw6NAh3LlzB35+ftL5e/fuYezYsdDW1saZM2dw6dIlzJs3D1VVVRg7diysrKywd+9epfoSExMxb968evvdu3dvVFVV4eDBgxBC1HtNY20CwKeffoqYmBhER0fj2rVr8PDwwJQpU5Cfn69Uz6pVqxAcHIycnBx4eHggMTER69evx6ZNm5CTk4PIyEisW7cOX331VYuePZESQUREREQvjbS0NAFAPHr0qM3acHV1FcHBwW1Wv6oAEAcPHpSOc3JyxMiRI4W2trawt7dvsIyIiF4Pvr6+wtvbu95zERERwt3dXamsqKhIABC5ubni8ePHQlNTU3z77bfS+d9++0106dKl0c/IjIwMAUD8/vvvQgghVq9eLfr37y+ePn1a7/VRUVHCxsZGOj5w4IDQ19cXZWVlDbaxZs0aoaGhIUxMTISnp6f4+OOPRUlJiXS+qTbNzMzEpk2blMpGjBghFi5cKIQQ4vbt2wKA+OSTT5SuGTBggEhKSlIqi4iIEC4uLg32lagpHDFJRERE1Mn85z//gbq6OiZNmtTRXWmWZ1O+rl69+sJ1+fn5QSaTQSaTQVNTE7169cJbb72FL7/8EjU1NUrXFhcXY+LEidJxWFgY9PT0kJubi9OnTzdYRkRElJWVhbS0NOjr60sva2trAEBhYSFu3bqFyspKODs7S/cYGRlhyJAhSvVcunQJXl5esLCwgIGBAVxdXQEAd+/eBQBcvXoVcrkcmpqa9fbDz88PBQUFuHDhAgAgISEBM2bMgJ6eXoN937RpE0pKSvD5559j6NCh+Pzzz2FtbY3s7Owm23z8+DHu37+P0aNHK5WPHj0aOTk5SmXDhw+Xfi4vL0dhYSH8/f2VntnGjRulKeJErcHEJBEREVEnEx8fj6CgIJw/fx7379/v6O60O09PTxQXF+POnTs4ceIExo8fj+DgYEyePFmahgb8OZ1NW1tbOi4sLMSYMWPQr18/dOvWrcGylnr69OmLBURERJ1OWVkZvLy8cPXqVaVXfn4+xo4d26w6ysvL4eHhAUNDQyQmJiIjIwMHDx4E8Ndnh66ubqN19OzZE15eXtizZw8ePHiAEydONDiN+3ndunXD9OnTER0djZycHJiZmSE6OrpZbTbX88nRsrIyAMDu3buVntf169elpCpRazAxSURERNSJlJWVITk5GQsWLMCkSZOQkJBQ73UKhQJ2dnbQ0dHBqFGjcP36dencTz/9BC8vL3Tt2hV6enoYOnQojh8/Lp0/d+4cnJ2doa2tDVNTU6xatUop4VebTCbDoUOHlMqMjY2lvj1bbN/R0REymQzjxo2TrmvNIvna2tro3bs3zM3N4eTkhDVr1uDw4cM4ceKE0vN4vl8ymQyXLl1CeHg4ZDIZNmzYUG8ZABQVFWHGjBkwNjaGiYkJvL29cefOHalePz8/TJ06FZs2bYKZmZk0Oqa590VHR8PU1BTdunXDokWLlHYyraiowMqVK9G3b19oa2tj4MCBiI+Pl843tREDERGphpOTE27cuAFLS0sMHDhQ6aWnpwcrKytoamoiIyNDuqe0tBR5eXnS8c2bN/Hw4UNs2bIFcrkc1tbWdTa+sbOzQ3p6eqO7WgcEBCA5ORm7du3CgAED6oxmbIqWlhYGDBgg7crdWJuGhoYwMzODQqFQKlcoFPjb3/7WYBu9evWCmZkZbt26Ved5Pb/pDlFLMTFJRERE1Ins378f1tbWGDJkCN577z18+eWX9S5uHxoaipiYGGRkZKBHjx7w8vKSvoAsWrQIFRUVOH/+PLKzsxEVFQV9fX0Afy6I/49//AMjRoxAVlYWdu7cifj4eGzcuLHVfb548SIA4NSpUyguLsZ3330HACpdJH/ChAmwt7eX6q6tuLgYQ4cOxYcffoji4mIsX7683rLKykp4eHjAwMAA6enpUCgU0NfXh6enp9LIyNOnTyM3Nxepqak4evRos+9LS0tDYWEh0tLS8NVXXyEhIUEpmTpnzhx88803iI2NRU5ODr744gvpvWnORgxERNQypaWldUZFFhUVYdGiRfj1118xc+ZMZGRkoLCwECkpKZg7dy6qq6thYGAAX19fhIaGIi0tDTdu3IC/vz/U1NQgk8kAABYWFtDS0sL27dtx69YtHDlyBBEREUrtL168GI8fP8a7776LzMxM5OfnY+/evcjNzZWueTbqcuPGjZg7d26j8Rw9ehTvvfcejh49iry8POTm5iI6OhrHjx+Ht7d3s9oMDQ1FVFQUkpOTkZubi1WrVuHq1asIDg5utO2PPvoImzdvRmxsLPLy8pCdnY09e/Zg69atLX5fiCQdvcglEREREf3lzTfflBabr6ysFN27dxdpaWnS+Web3+zbt08qe/jwodDV1RXJyclCCCFsbW3Fhg0b6q1/zZo1YsiQIaKmpkYq+/e//y309fVFdXW1EKLu5jeotcmMEEIYGRmJPXv2CCH+WiT/ypUrSte0ZpH8xjYq8PHxUdogoHa/7O3tRVhYmNI9tcv27t1bJ/6Kigqhq6srUlJSpD706tVLVFRUtPi+fv36iaqqKuma6dOnCx8fHyGEELm5uQKASE1NrTe+pjZiICKilvH19RUA6rz8/f2FEELk5eWJt99+WxgbGwtdXV1hbW0tQkJCpN/1jx8/FrNmzRJdunQRvXv3Flu3bhXOzs5i1apVUhtJSUnC0tJSaGtrCxcXF3HkyJE6n4lZWVnC3d1ddOnSRRgYGAi5XC4KCwuV+rpu3Tqhrq4u7t+/32hMhYWFYv78+WLw4MFCV1dXGBsbixEjRkifyc1ps7q6WmzYsEGYm5sLTU1NYW9vL06cOCHd29DnuhBCJCYmCgcHB6GlpSW6du0qxo4dK7777rsm3wuihmh0SDaUiIiIiOrIzc3FxYsXpfWpNDQ04OPjg/j4eKXp0QDg4uIi/WxiYoIhQ4ZIi9YvWbIECxYswA8//AA3NzdMmzYNdnZ2AICcnBy4uLhIoz2APxe8Lysrw88//wwLCwuVxPL8Ivnz58+XyquqqmBkZNSqOoUQSv1ujaysLBQUFMDAwECp/I8//lBavN/W1hZaWlotvm/o0KFQV1eXjk1NTZU2I1BXV5c2Rqivb882YqitsLAQgwcPbkGkRERUe9R6bYMGDWpwJD4AGBgYIDExUTouLy/HRx99hA8++EAqmzlzJmbOnKl0n6g108HOzg4pKSmN9vXZjAZTU9NGr7OyssKuXbsavaapNtXU1BAWFoawsLB6z1taWtY7WwMAZs2ahVmzZjXZPlFzMTFJRERE1EnEx8ejqqoKZmZmUpkQAtra2tixY0ezE3oBAQHw8PDAsWPH8MMPP2Dz5s2IiYlBUFBQq/olk8nqfEFpbK0sQHmR/JEjRyqdez5x1xI5OTkvvI5VWVkZhg0bpvRF85kePXpIP9feDbW599XeAVUmk0m7iTe1GcGzjRiioqLqnGvqiyoREanelStXcPPmTTg7O6O0tBTh4eEAIE2ZVoXS0lJkZ2cjKSkJR44cUVm9RC8LJiaJiIiIOoGqqip8/fXXiImJgbu7u9K5qVOn4ptvvkFgYKBUduHCBWl046NHj5CXlwcbGxvpfN++fREYGIjAwECsXr0au3fvRlBQEGxsbHDgwAGl0YcKhQIGBgbo06dPvX3r0aMHiouLpeP8/Hw8efJEOn42srC6uloqe36R/NmzZ7f2sUjOnDmD7OxsLF269IXqcXJyQnJyMnr27AlDQ8M2v+95tra2qKmpwblz5+Dm5lZvGwcOHIClpSU0NPhnOhFRZxAdHY3c3FxoaWlh2LBhSE9PR/fu3VVWv7e3Ny5evIjAwEC89dZbKquX6GXBzW+IiIiIOoGjR4/i0aNH8Pf3xxtvvKH0mjZtmtLOzQAQHh6O06dP4/r16/Dz80P37t0xdepUAEBISAhSUlJw+/ZtXL58GWlpaVLScuHChSgqKkJQUBBu3ryJw4cPIywsDMuWLYOaWv1/Gk6YMAE7duzAlStXkJmZicDAQKWRgT179oSurq60WUtpaSmA1i+SX1FRgZKSEty7dw+XL19GZGQkvL29MXnyZMyZM6e1jxgAMHv2bHTv3h3e3t5IT0/H7du3cfbsWSxZsgQ///yzyu97nqWlJXx9fTFv3jwcOnRIqmP//v0A0ORGDERE1L4cHR1x6dIllJWV4ddff0VqaipsbW1V2sbZs2fx5MkTbNu2TaX1Er0smJgkIiIi6gTi4+Ph5uZW73TtadOmITMzE9euXZPKtmzZguDgYAwbNgwlJSX4/vvvlUYuLlq0CDY2NvD09MTgwYPx2WefAQDMzc1x/PhxXLx4Efb29ggMDIS/vz/Wrl3bYN9iYmLQt29fyOVyzJo1C8uXL0eXLl2k8xoaGoiNjcUXX3wBMzMzaYpbQEAA4uLisGfPHtja2sLV1RUJCQlNTsc+efIkTE1NYWlpCU9PT6SlpSE2NhaHDx9u9TTwZ7p06YLz58/DwsIC//znP2FjYwN/f3/88ccfjY6EbO19te3cuRPvvPMOFi5cCGtra8yfPx/l5eUAADMzMygUClRXV8Pd3R22trYICQmBsbFxg0ljIiIiopeZTDS0oikRERERERERERFRG+F/vRIREREREREREVG7Y2KSiIiIiIiIiIiI2h0Tk0RERERERERERNTumJgkIiIiIiIiIiKidsfEJBEREREREREREbU7JiaJiIiIiIiIiIio3TExSURERERERERERO2OiUkiIiIiIiIiIiJqd0xMEhERERERERERUbtjYpKIiIiIiIiIiIjaHROTRERERERERERE1O7+D6FQP3MEUBtJAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "### Visualize FIQA Results\n", + "\n", + "# Comprehensive Visualization\n", + "fig = plt.figure(figsize=(16, 12))\n", + "gs = fig.add_gridspec(3, 3, hspace=0.3, wspace=0.3)\n", + "\n", + "# 1. Scatter: Legacy vs New scores\n", + "ax1 = fig.add_subplot(gs[0, 0])\n", + "ax1.scatter(df_fiqa[\"old_score\"], df_fiqa[\"new_score\"], alpha=0.5, s=30)\n", + "ax1.plot([0, 1], [0, 1], 'r--', label=\"Perfect match\", linewidth=2)\n", + "ax1.set_xlabel(\"Legacy Score\", fontsize=10)\n", + "ax1.set_ylabel(\"New Score\", fontsize=10)\n", + "ax1.set_title(\"Score Correlation\", fontsize=12, fontweight='bold')\n", + "ax1.legend()\n", + "ax1.grid(True, alpha=0.3)\n", + "ax1.set_xlim(-0.05, 1.05)\n", + "ax1.set_ylim(-0.05, 1.05)\n", + "\n", + "# 2. Histogram: Difference distribution\n", + "ax2 = fig.add_subplot(gs[0, 1])\n", + "ax2.hist(df_fiqa[\"diff\"], bins=40, alpha=0.7, edgecolor='black')\n", + "ax2.axvline(x=0, color='r', linestyle='--', linewidth=2, label='Zero diff')\n", + "ax2.axvline(x=df_fiqa[\"diff\"].mean(), color='g', linestyle='--', linewidth=2, \n", + " label=f'Mean: {df_fiqa[\"diff\"].mean():.3f}')\n", + "ax2.set_xlabel(\"Difference (New - Legacy)\", fontsize=10)\n", + "ax2.set_ylabel(\"Frequency\", fontsize=10)\n", + "ax2.set_title(\"Difference Distribution\", fontsize=12, fontweight='bold')\n", + "ax2.legend()\n", + "ax2.grid(True, alpha=0.3)\n", + "\n", + "# 3. Histogram: Absolute difference (log scale for deterministic metrics)\n", + "ax3 = fig.add_subplot(gs[0, 2])\n", + "non_zero_diffs = df_fiqa[df_fiqa[\"abs_diff\"] > 0][\"abs_diff\"]\n", + "if len(non_zero_diffs) > 0:\n", + " ax3.hist(np.log10(non_zero_diffs), bins=40, alpha=0.7, color='orange', edgecolor='black')\n", + " ax3.axvline(x=-10, color='r', linestyle='--', linewidth=2, label='1e-10 tolerance')\n", + " ax3.set_xlabel(\"Log10(Absolute Difference)\", fontsize=10)\n", + "else:\n", + " ax3.text(0.5, 0.5, 'All differences are zero!', ha='center', va='center', fontsize=12)\n", + "ax3.set_ylabel(\"Frequency\", fontsize=10)\n", + "ax3.set_title(\"Absolute Difference Distribution (Log)\", fontsize=12, fontweight='bold')\n", + "ax3.legend()\n", + "ax3.grid(True, alpha=0.3)\n", + "\n", + "# 4. Line plot: Score trends\n", + "ax4 = fig.add_subplot(gs[1, :])\n", + "x = df_fiqa[\"sample_idx\"]\n", + "ax4.plot(x, df_fiqa[\"old_score\"], 'o-', label=\"Legacy\", alpha=0.6, markersize=4)\n", + "ax4.plot(x, df_fiqa[\"new_score\"], 's-', label=\"New\", alpha=0.6, markersize=4)\n", + "ax4.set_xlabel(\"Sample Index\", fontsize=10)\n", + "ax4.set_ylabel(\"Score\", fontsize=10)\n", + "ax4.set_title(\"Score Trends Across Dataset\", fontsize=12, fontweight='bold')\n", + "ax4.legend()\n", + "ax4.grid(True, alpha=0.3)\n", + "ax4.set_ylim(-0.05, 1.05)\n", + "\n", + "# 5. Box plots: Score distributions\n", + "ax5 = fig.add_subplot(gs[2, 0])\n", + "ax5.boxplot([df_fiqa[\"old_score\"], df_fiqa[\"new_score\"]], labels=['Legacy', 'New'])\n", + "ax5.set_ylabel(\"Score\", fontsize=10)\n", + "ax5.set_title(\"Score Distribution Comparison\", fontsize=12, fontweight='bold')\n", + "ax5.grid(True, alpha=0.3, axis='y')\n", + "\n", + "# 6. Cumulative distribution of absolute differences\n", + "ax6 = fig.add_subplot(gs[2, 1])\n", + "sorted_diffs = np.sort(df_fiqa[\"abs_diff\"])\n", + "cumulative = np.arange(1, len(sorted_diffs) + 1) / len(sorted_diffs) * 100\n", + "ax6.plot(sorted_diffs, cumulative, linewidth=2)\n", + "ax6.axvline(x=0.2, color='r', linestyle='--', linewidth=2, label='0.2 tolerance')\n", + "ax6.axhline(y=90, color='g', linestyle='--', linewidth=1, alpha=0.5, label='90%')\n", + "ax6.set_xlabel(\"Absolute Difference\", fontsize=10)\n", + "ax6.set_ylabel(\"Cumulative Percentage\", fontsize=10)\n", + "ax6.set_title(\"Cumulative Distribution\", fontsize=12, fontweight='bold')\n", + "ax6.set_xscale('log')\n", + "ax6.legend()\n", + "ax6.grid(True, alpha=0.3)\n", + "\n", + "# 7. Scatter: Difference vs Legacy score\n", + "ax7 = fig.add_subplot(gs[2, 2])\n", + "ax7.scatter(df_fiqa[\"old_score\"], df_fiqa[\"abs_diff\"], alpha=0.5, s=30)\n", + "ax7.axhline(y=0.2, color='r', linestyle='--', linewidth=2, label='0.2 tolerance')\n", + "ax7.set_xlabel(\"Legacy Score\", fontsize=10)\n", + "ax7.set_ylabel(\"Absolute Difference\", fontsize=10)\n", + "ax7.set_title(\"Difference vs Score\", fontsize=12, fontweight='bold')\n", + "ax7.set_yscale('log')\n", + "ax7.legend()\n", + "ax7.grid(True, alpha=0.3)\n", + "\n", + "plt.suptitle(f\"FIQA Migration Analysis ({len(df_fiqa)} samples)\", \n", + " fontsize=14, fontweight='bold', y=0.995)\n", + "plt.show()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "๐ŸŽฏ FIQA VALIDATION COMPLETE\n", + "======================================================================\n", + " Mean |Diff|: 0.0364\n", + " Within 0.2: 29/30 (96.7%)\n", + " Within 0.3: 29/30 (96.7%)\n", + "\n", + "๐Ÿ“Š Validation Criteria (LLM-based metrics):\n", + " โœ… Mean |diff| < 0.15: 0.0364\n", + " โœ… >90% within 0.2: 96.7%\n", + " โœ… >95% within 0.3: 96.7%\n", + " โœ… No systematic bias (|mean diff| < 0.05): 0.0346\n", + "\n", + "๐Ÿ’ก Domain Generalization Check:\n", + " โœ… Amnesty QA Mean |Diff|: 0.0558\n", + " โœ… FIQA Mean |Diff|: 0.0364\n", + " โœ… Consistent across domains\n" + ] + } + ], + "source": [ + "### Validate FIQA Results\n", + "\n", + "print(\"๐ŸŽฏ FIQA VALIDATION COMPLETE\")\n", + "print(\"=\"*70)\n", + "print(f\" Mean |Diff|: {df_fiqa['abs_diff'].mean():.4f}\")\n", + "print(f\" Within 0.2: {(df_fiqa['abs_diff'] < 0.2).sum()}/{len(df_fiqa)} \"\n", + " f\"({(df_fiqa['abs_diff'] < 0.2).sum()/len(df_fiqa)*100:.1f}%)\")\n", + "print(f\" Within 0.3: {(df_fiqa['abs_diff'] < 0.3).sum()}/{len(df_fiqa)} \"\n", + " f\"({(df_fiqa['abs_diff'] < 0.3).sum()/len(df_fiqa)*100:.1f}%)\")\n", + "\n", + "# Validation criteria for LLM-based metrics\n", + "mean_abs_diff = df_fiqa['abs_diff'].mean()\n", + "pct_within_02 = (df_fiqa['abs_diff'] < 0.2).sum() / len(df_fiqa) * 100\n", + "pct_within_03 = (df_fiqa['abs_diff'] < 0.3).sum() / len(df_fiqa) * 100\n", + "\n", + "print(\"\\n๐Ÿ“Š Validation Criteria (LLM-based metrics):\")\n", + "print(f\" {'โœ…' if mean_abs_diff < 0.15 else 'โŒ'} Mean |diff| < 0.15: {mean_abs_diff:.4f}\")\n", + "print(f\" {'โœ…' if pct_within_02 > 90 else 'โš ๏ธ'} >90% within 0.2: {pct_within_02:.1f}%\")\n", + "print(f\" {'โœ…' if pct_within_03 > 95 else 'โš ๏ธ'} >95% within 0.3: {pct_within_03:.1f}%\")\n", + "print(f\" {'โœ…' if abs(fiqa_result.mean_diff) < 0.05 else 'โš ๏ธ'} \"\n", + " f\"No systematic bias (|mean diff| < 0.05): {abs(fiqa_result.mean_diff):.4f}\")\n", + "\n", + "print(\"\\n๐Ÿ’ก Domain Generalization Check:\")\n", + "print(f\" โœ… Amnesty QA Mean |Diff|: {df_amnesty['abs_diff'].mean():.4f}\")\n", + "print(f\" โœ… FIQA Mean |Diff|: {df_fiqa['abs_diff'].mean():.4f}\")\n", + "print(f\" {'โœ…' if abs(df_amnesty['abs_diff'].mean() - df_fiqa['abs_diff'].mean()) < 0.1 else 'โš ๏ธ'} \"\n", + " f\"Consistent across domains\")\n", + "\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.8" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/tests/e2e/metrics_migration/plan-for-metrics-migration.md b/tests/e2e/metrics_migration/plan-for-metrics-migration.md new file mode 100644 index 000000000..8d144cf69 --- /dev/null +++ b/tests/e2e/metrics_migration/plan-for-metrics-migration.md @@ -0,0 +1,797 @@ +# Comprehensive Generalizable Metrics Migration Plan + +## Overview +This document provides a complete, step-by-step plan for migrating any metric from legacy implementation to the modern collections pattern, incorporating all learnings from Context Recall migration, test infrastructure refactoring, and notebook-based testing approaches. + +--- + +## Phase 0: Pre-Migration Study & Planning + +### Study Existing Migrated Metrics + +**Metrics to analyze**: +1. Answer Relevancy (LLM + Embeddings based) +2. Answer Similarity (Embeddings only) +3. BLEU/ROUGE (No LLM/embeddings) +4. String metrics (Simple comparison) +5. Context Recall (LLM with statement classification) + +**What to look for in legacy metrics** (`src/ragas/metrics/_*.py`): +- [ ] **Core algorithm logic**: How is the score calculated? +- [ ] **LLM/Embeddings usage**: Which components are required? +- [ ] **Prompt structure**: PydanticPrompt classes and examples +- [ ] **Input parameters**: What data does it need? +- [ ] **Edge cases**: How are empty inputs, errors handled? +- [ ] **Ensembling**: Does it run multiple times and aggregate? +- [ ] **Deprecated methods**: Old APIs to maintain compatibility with +- [ ] **Output format**: Float score vs structured output + +**Important patterns from legacy**: +1. `_single_turn_ascore()` is the main method to replicate +2. `MetricWithLLM`, `MetricWithEmbeddings` mixins show dependencies +3. `PydanticPrompt` examples become inline examples in new prompts +4. Score normalization and range validation (0.0-1.0) +5. Error handling and nan score returns + +--- + +## Phase 1: Implement New Metric + +### 1.1 Create Prompt Function +**File**: `src/ragas/prompts/metrics/{metric_name}.py` + +**Structure**: +```python +"""Prompt for {MetricName} evaluation.""" + +import json + +def {metric_name}_prompt(param1: str, param2: str, ...) -> str: + """ + Generate prompt for {metric_name} evaluation. + + Args: + param1: Description + param2: Description + + Returns: + Formatted prompt string for LLM + """ + # Use json.dumps() for safe string escaping + safe_param1 = json.dumps(param1) + safe_param2 = json.dumps(param2) + + return f"""Task description here. + +--------EXAMPLES----------- +Example 1 +Input: {{ + "param1": "example value", + "param2": "example value" +}} +Output: {{ + "result": "expected output format" +}} + +Example 2 +[Add 2-3 examples covering different scenarios] +----------------------------- + +Now perform the same with the following input +Input: {{ + "param1": {safe_param1}, + "param2": {safe_param2} +}} +Output: """ +``` + +**Key points**: +- Use `json.dumps()` for escaping user inputs +- Include 2-3 examples showing different cases +- Clear output format specification +- Match the logic from legacy PydanticPrompt + +### 1.2 Define Output Models +**File**: `src/ragas/metrics/collections/_{metric_name}.py` + +```python +from pydantic import BaseModel +import typing as t + +class {MetricName}Item(BaseModel): + """Single classification/item result.""" + field1: str + field2: int + # ... based on legacy output model + +class {MetricName}Output(BaseModel): + """Complete structured output.""" + items: t.List[{MetricName}Item] + # or whatever structure the LLM returns +``` + +**Guidelines**: +- Match field names from legacy output models +- Use appropriate types (str, int, float, List, etc.) +- Add docstrings for clarity + +### 1.3 Implement Metric Class +**File**: `src/ragas/metrics/collections/_{metric_name}.py` + +```python +"""MetricName v2 - Modern implementation with instructor LLMs.""" + +import typing as t +import numpy as np +from ragas.metrics.collections.base import BaseMetric +from ragas.metrics.result import MetricResult +from ragas.prompts.metrics.{metric_name} import {metric_name}_prompt + +if t.TYPE_CHECKING: + from ragas.llms.base import InstructorBaseRagasLLM + from ragas.embeddings.base import BaseRagasEmbeddings + +class {MetricName}(BaseMetric): + """ + {Metric description - what it measures}. + + This implementation uses modern instructor LLMs with structured output. + Only supports modern components - legacy wrappers rejected with clear errors. + + Usage: + >>> from openai import AsyncOpenAI + >>> from ragas.llms.base import instructor_llm_factory + >>> from ragas.metrics.collections import {MetricName} + >>> + >>> client = AsyncOpenAI() + >>> llm = instructor_llm_factory("openai", client=client, model="gpt-4o-mini") + >>> + >>> metric = {MetricName}(llm=llm) + >>> result = await metric.ascore(param1="value1", param2="value2") + >>> print(f"Score: {result.value}") + + Attributes: + llm: Modern instructor-based LLM (if needed) + embeddings: Modern embeddings (if needed) + name: Metric name + allowed_values: Score range (0.0 to 1.0) + """ + + # Type hints for components + llm: "InstructorBaseRagasLLM" # If LLM-based + embeddings: "BaseRagasEmbeddings" # If embeddings-based + + def __init__( + self, + llm: t.Optional["InstructorBaseRagasLLM"] = None, + embeddings: t.Optional["BaseRagasEmbeddings"] = None, + name: str = "{metric_name}", + **kwargs, + ): + """Initialize metric with required components.""" + # Set attributes before super() for validation + if llm: + self.llm = llm + if embeddings: + self.embeddings = embeddings + + # BaseMetric validates components are modern (not legacy wrappers) + super().__init__(name=name, **kwargs) + + async def ascore( + self, + param1: str, + param2: str, + # ... other parameters based on metric needs + ) -> MetricResult: + """ + Calculate score asynchronously. + + Args: + param1: Description + param2: Description + + Returns: + MetricResult with score (0.0-1.0) + """ + # 1. Validate inputs (handle empty/None cases) + if not param1 or not param2: + return MetricResult(value=0.0) + + # 2. For LLM-based metrics: Generate prompt and get structured output + prompt = {metric_name}_prompt(param1=param1, param2=param2) + output = await self.llm.agenerate(prompt, {MetricName}Output) + + # 3. For embeddings-based metrics: Get embeddings and compute similarity + # embedding1 = await self.embeddings.embed_text(param1) + # embedding2 = await self.embeddings.embed_text(param2) + # score = cosine_similarity(embedding1, embedding2) + + # 4. Calculate score from output (match legacy logic exactly) + score = self._calculate_score(output) + + # 5. Return MetricResult + return MetricResult(value=float(score)) + + def _calculate_score(self, output: {MetricName}Output) -> float: + """Calculate final score from LLM output.""" + # Implement exact logic from legacy _single_turn_ascore + # This is where the core algorithm lives + pass +``` + +**Key patterns**: +- `__init__` sets attributes before `super()` for validation +- `ascore()` is the main public method (not `_single_turn_ascore`) +- Return `MetricResult` not raw float +- Match legacy calculation logic exactly +- Handle edge cases (empty inputs, None values) +- Type hints use `TYPE_CHECKING` for circular imports + +### 1.4 Update Exports +**File**: `src/ragas/metrics/collections/__init__.py` + +```python +from ._metric_name import MetricName + +__all__ = [ + # ... existing exports + "MetricName", +] +``` + +--- + +## Phase 2: Manual Testing with General-Purpose Notebook + +### 2.1 Use General-Purpose Testing Notebook + +**File**: `tests/notebooks/metric_score_diff.ipynb` (already exists - reusable for all metrics) + +**Purpose**: Validate migration on real-world datasets (PRIMARY) and test edge cases (SECONDARY) + +**Testing Priority**: +1. **PRIMARY**: Large-scale dataset testing (amnesty_qa, fiqa) - proves migration quality +2. **SECONDARY**: Hand-crafted edge cases - validates specific behaviors + +**Key Advantage**: This notebook is configuration-driven. You only need to edit ONE cell (Cell 2) with your metric configuration, then run all cells without any other modifications! + +**What the notebook provides**: +- Automatic component creation (LLM/embeddings) based on your needs +- Dynamic metric loading from your configuration +- Dataset-based testing (Amnesty QA + FIQA) +- Comprehensive statistical analysis and visualizations +- Validation criteria checking +- Optional edge case testing + +--- + +### 2.2 Generate Metric Configuration + +The only thing you need to create is the `METRIC_CONFIG` dictionary for Cell 2 of the notebook. Use the template below based on your metric type: + +#### Configuration Template + +```python +METRIC_CONFIG = { + # ===== METRIC IMPORTS ===== + "legacy_import": { + "module": "ragas.metrics._{legacy_module_name}", # e.g., "ragas.metrics._answer_relevance" + "class_name": "{LegacyMetricClassName}", # e.g., "AnswerRelevancy" + }, + "modern_import": { + "module": "ragas.metrics.collections", + "class_name": "{ModernMetricClassName}", # e.g., "AnswerRelevancy" + }, + + # ===== COMPONENT REQUIREMENTS ===== + # Set to False if your metric doesn't need this component + "needs_llm": True, # Does your metric use an LLM? + "needs_embeddings": True, # Does your metric use embeddings? + + # ===== DATASET FIELD MAPPING ===== + # Choose ONE option based on your metric type (uncomment the appropriate one) + + # OPTION 1: Answer-based metrics (AnswerRelevancy, AnswerSimilarity, AnswerCorrectness, etc.) + "dataset_fields": ["user_input", "response"], + + # OPTION 2: Context-based metrics (ContextRecall, ContextPrecision, Faithfulness, etc.) + # "dataset_fields": ["user_input", "retrieved_contexts", "reference"], + + # OPTION 3: Deterministic/Non-LLM metrics (NonLLMContextRecall, etc.) + # "dataset_fields": ["retrieved_contexts", "reference_contexts"], +} +``` + +#### Configuration Examples + +**Example 1: AnswerRelevancy (LLM + Embeddings)** +```python +METRIC_CONFIG = { + "legacy_import": { + "module": "ragas.metrics._answer_relevance", + "class_name": "AnswerRelevancy", + }, + "modern_import": { + "module": "ragas.metrics.collections", + "class_name": "AnswerRelevancy", + }, + "needs_llm": True, + "needs_embeddings": True, + "dataset_fields": ["user_input", "response"], +} +``` + +**Example 2: ContextRecall (LLM only)** +```python +METRIC_CONFIG = { + "legacy_import": { + "module": "ragas.metrics._context_recall", + "class_name": "ContextRecall", + }, + "modern_import": { + "module": "ragas.metrics.collections", + "class_name": "ContextRecall", + }, + "needs_llm": True, + "needs_embeddings": False, + "dataset_fields": ["user_input", "retrieved_contexts", "reference"], +} +``` + +**Example 3: NonLLMContextRecall (No LLM/Embeddings)** +```python +METRIC_CONFIG = { + "legacy_import": { + "module": "ragas.metrics._context_recall", + "class_name": "NonLLMContextRecall", + }, + "modern_import": { + "module": "ragas.metrics.collections", + "class_name": "NonLLMContextRecall", + }, + "needs_llm": False, + "needs_embeddings": False, + "dataset_fields": ["retrieved_contexts", "reference_contexts"], +} +``` + +**Example 4: ContextPrecision (LLM only)** +```python +METRIC_CONFIG = { + "legacy_import": { + "module": "ragas.metrics._context_precision", + "class_name": "ContextPrecision", + }, + "modern_import": { + "module": "ragas.metrics.collections", + "class_name": "ContextPrecision", + }, + "needs_llm": True, + "needs_embeddings": False, + "dataset_fields": ["user_input", "retrieved_contexts", "reference"], +} +``` + +#### How to Choose `dataset_fields` + +The `dataset_fields` list tells the notebook which fields to extract from the test datasets (Amnesty QA, FIQA) for your metric: + +1. **Answer-based metrics**: Use `["user_input", "response"]` + - Metrics that evaluate the quality of generated answers + - Examples: AnswerRelevancy, AnswerSimilarity, AnswerCorrectness + +2. **Context-based metrics**: Use `["user_input", "retrieved_contexts", "reference"]` + - Metrics that evaluate retrieved context quality + - Examples: ContextRecall, ContextPrecision, Faithfulness + +3. **Deterministic metrics**: Use `["retrieved_contexts", "reference_contexts"]` + - Metrics that don't use LLMs and compare contexts directly + - Examples: NonLLMContextRecall + - Note: The notebook will automatically split `retrieved_contexts` to create `reference_contexts` if needed + +**Available dataset fields**: +- **Amnesty QA**: `user_input`, `response`, `retrieved_contexts`, `reference_contexts` +- **FIQA**: `user_input`, `response`, `retrieved_contexts`, `reference` + +--- + +### 2.3 Run Notebook and Analyze Results + +**Steps**: + +1. **Open the notebook**: `tests/notebooks/metric_score_diff.ipynb` + +2. **Edit Cell 2**: Replace the `METRIC_CONFIG` dictionary with your generated configuration from Section 2.2 + +3. **Run all cells**: The notebook handles everything automatically: + - Loads your metric classes dynamically + - Creates only the required components (LLM/embeddings) + - Initializes both legacy and modern metrics + - Loads and transforms datasets based on your `dataset_fields` + - Runs concurrent comparisons on Amnesty QA and FIQA + - Generates comprehensive statistical analysis + - Creates 7-plot visualizations for each dataset + - Validates results against migration criteria + +4. **Review results**: The notebook displays inline: + - Score comparison statistics (mean, std dev, differences) + - Tolerance analysis (% of samples within various thresholds) + - Top 10 largest differences with descriptions + - Comprehensive visualizations (scatter, histograms, trends, distributions) + - Validation criteria checkmarks (โœ…/โŒ) + +5. **Iterate if needed**: + - If scores don't match well, review the problematic cases + - Adjust your metric implementation + - Re-run the notebook to verify improvements + +6. **Document findings**: Note the following for your E2E tests: + - Mean absolute difference + - Percentage of samples within tolerance + - Recommended tolerance level + - Any patterns or anomalies observed + - Edge cases that need special handling + +**No files are saved** - all results are displayed inline for quick validation! + +--- + +--- + +### 2.4 Migration Validation Criteria + +After running the notebook, the migration is considered successful if: + +**Amnesty QA Dataset** (PRIMARY criterion): +- โœ… Mean absolute difference < 0.15 (stricter than per-case tolerance) +- โœ… >90% of samples within 0.2 tolerance for LLM-based metrics +- โœ… >95% of samples within 1e-6 tolerance for deterministic metrics +- โœ… No systematic bias (mean diff close to 0, ideally < 0.05) +- โœ… Similar score distributions (check box plots and histograms) + +**FIQA Dataset** (if available): +- โœ… Similar criteria as amnesty_qa +- โœ… Validates generalization across different domains + +**Edge Cases** (SECONDARY criterion): +- โœ… All edge cases handle gracefully (no crashes) +- โœ… Empty inputs return 0.0 or handle appropriately +- โœ… Special characters don't break the metric + +**Performance**: +- โœ… New implementation not significantly slower (< 2x) +- โœ… Concurrent processing works correctly + +**Documentation**: +For the migration, review and document in the notebook: +- Dataset comparison statistics (displayed inline) +- Top 10 largest differences with analysis (displayed inline) +- Visual analysis with 7 comprehensive plots (displayed inline) +- Any patterns or anomalies observed +- Recommended tolerance for E2E tests + +**This becomes the proof that migration works correctly!** + +**Note**: All results are displayed inline in the notebook - no CSV or PNG files are saved. + +--- + +## Phase 3: Write E2E Migration Tests + +### 3.1 Create Test File +**File**: `tests/e2e/metrics_migration/test_{metric_name}_migration.py` + +**Structure**: +```python +"""E2E tests for {MetricName} migration from v1 to v2.""" + +import pytest + +from ragas.metrics import {LegacyMetricName} +from ragas.metrics.collections import {MetricName} + +from .base_migration_test import BaseMigrationTest + +class Test{MetricName}E2EMigration(BaseMigrationTest): + """E2E compatibility tests between legacy and v2 implementations.""" + + @pytest.fixture + def sample_data(self): + """Test cases for {metric_name} evaluation. + + Based on dataset testing in notebook: tests/notebooks/metric_score_diff.ipynb + + Dataset validation results: + - Amnesty QA: Mean |diff|={mean_diff:.4f}, {pct_within_tolerance}% within tolerance + - FIQA: Mean |diff|={mean_diff:.4f}, {pct_within_tolerance}% within tolerance (if tested) + + These test cases focus on edge cases and specific behaviors not fully covered by datasets. + The primary validation comes from the dataset comparisons documented in the notebook. + """ + return [ + # Edge cases from notebook testing + # Cases with interesting/problematic behavior from dataset analysis + # Specific scenarios requiring validation + { + "param1": "value1", + "param2": "value2", + "description": "Test case description", + }, + ] + + @pytest.mark.asyncio + async def test_legacy_vs_v2_e2e_compatibility( + self, + sample_data, + legacy_llm, # from conftest.py + modern_llm, # from conftest.py + legacy_embeddings, # if needed + modern_embeddings, # if needed + ): + """E2E test that legacy and v2 produce similar scores.""" + await self.run_e2e_compatibility_test( + sample_data=sample_data, + legacy_metric_factory={LegacyMetricName}, + v2_metric_factory={MetricName}, + legacy_components={"llm": legacy_llm, "embeddings": legacy_embeddings}, + v2_components={"llm": modern_llm, "embeddings": modern_embeddings}, + tolerance=0.2, # Adjust based on notebook findings + metric_name="{MetricName}", + additional_info_keys=["param1", "param2"], # For debug output + ) + + @pytest.mark.asyncio + async def test_{metric_specific_behavior}( + self, + legacy_llm, + modern_llm, + ): + """Test metric-specific behavior.""" + + test_cases = [ + { + "param1": "specific case", + "param2": "for testing", + "expected_high": True, # or other expected behavior + "description": "Specific behavior description", + }, + # Add 2-3 cases testing specific behaviors + ] + + def assertion_fn(case, legacy_score, v2_result): + """Custom assertions for metric-specific behavior.""" + if case.get("expected_high"): + assert legacy_score > 0.8 + assert v2_result.value > 0.8 + print(" โœ… High score as expected") + # Add other assertions based on metric logic + + await self.run_metric_specific_test( + test_cases=test_cases, + legacy_metric_factory={LegacyMetricName}, + v2_metric_factory={MetricName}, + legacy_components={"llm": legacy_llm}, + v2_components={"llm": modern_llm}, + test_name="{specific behavior}", + assertion_fn=assertion_fn, + ) + + def test_migration_requirements_documented(self): + """Document requirements for running E2E tests.""" + requirements = { + "llm": "OpenAI GPT or compatible LLM", + "embeddings": "OpenAI embeddings (if needed)", + "environment": "API keys configured", + "purpose": "Verify v2 produces similar scores to legacy", + } + + self.create_requirements_documentation( + metric_name="{MetricName}", + requirements=requirements, + test_file_name="test_{metric_name}_migration.py", + ) + + assert True +``` + +**Key points**: +- Inherit from `BaseMigrationTest` for reusable test methods +- Use fixtures from `conftest.py` (no local fixture definitions) +- `sample_data` comes from notebook testing (working cases) +- Tolerance based on notebook findings +- Add metric-specific behavior tests +- Document requirements + +### 3.2 Run Tests +```bash +# Run the new tests +uv run pytest tests/e2e/metrics_migration/test_{metric_name}_migration.py -v -s + +# Check they collect properly +uv run pytest tests/e2e/metrics_migration/test_{metric_name}_migration.py --collect-only +``` + +--- + +## Phase 4: Code Quality & Finalization + +### 4.1 Run Linting & Formatting +```bash +# Format code +make format + +# Type check +make type + +# Quick health check +make check +``` + +### 4.2 Run All Tests +```bash +# Unit tests +make test + +# E2E tests +make test-e2e + +# Or run specific test +uv run pytest tests/e2e/metrics_migration/ -v +``` + +### 4.3 Update Documentation +**File**: `docs/howtos/migrations/{metric_name}.md` (if needed) + +Document: +- Migration rationale +- API changes +- Usage examples (before/after) +- Breaking changes (if any) + +### 4.4 Create PR Checklist +- [ ] New metric implementation complete +- [ ] Prompt function with examples +- [ ] E2E migration tests passing +- [ ] Notebook testing completed +- [ ] Code formatted and linted +- [ ] Type checking passes +- [ ] Documentation updated +- [ ] Exports added to `__init__.py` + +--- + +## Key Learnings & Best Practices + +### From Context Recall Migration +1. **Components validation**: Base class rejects legacy wrappers automatically +2. **Structured output**: Use Pydantic models with instructor LLMs +3. **Prompt format**: Inline examples with json.dumps() escaping +4. **Score calculation**: Extract to separate method for clarity +5. **Edge cases**: Handle empty inputs gracefully + +### From Test Infrastructure +1. **Use shared fixtures**: `conftest.py` provides llm/embeddings +2. **Base test class**: `BaseMigrationTest` eliminates boilerplate +3. **Test utilities**: `test_utils.py` for common operations +4. **Consistent patterns**: All tests follow same structure +5. **Proper skipping**: Tests skip gracefully without API keys + +### From Notebook Testing +1. **Manual testing first**: Catches issues before E2E tests +2. **User modifications matter**: Inform final test design +3. **Performance tools**: Use optimized `compare_metrics` function +4. **Diverse test cases**: Cover normal, edge, high/low score scenarios +5. **Iteration speed**: Faster to debug in notebook than pytest + +### Tolerance Guidelines +- **LLM-based metrics**: 0.2-0.3 (accounts for randomness) +- **Embeddings-based**: 1e-6 to 1e-10 (deterministic) +- **String/rule-based**: 1e-10 (exact match expected) +- **Adjust based on**: Notebook findings and metric nature + +--- + +## Complete Checklist + +### Pre-Migration +- [ ] Study legacy metric implementation thoroughly +- [ ] Identify required components (LLM/embeddings/neither) +- [ ] Document core algorithm logic +- [ ] Note edge cases and special handling +- [ ] Review existing migrated metrics for patterns + +### Implementation +- [ ] Create prompt function with examples +- [ ] Define Pydantic output models +- [ ] Implement metric class inheriting from BaseMetric +- [ ] Match legacy calculation logic exactly +- [ ] Handle edge cases (empty, None, errors) +- [ ] Update `__init__.py` exports + +### Manual Testing (Notebook) +- [ ] Open general-purpose notebook: `tests/notebooks/metric_score_diff.ipynb` +- [ ] Generate `METRIC_CONFIG` for your metric (Section 2.2) +- [ ] Edit Cell 2 with your configuration +- [ ] Run all cells (no other modifications needed) +- [ ] Review Amnesty QA and FIQA comparison results +- [ ] Iterate on implementation until scores match +- [ ] Document findings (mean |diff|, tolerance, patterns) + +### E2E Testing +- [ ] Create test file inheriting from BaseMigrationTest +- [ ] Use fixtures from conftest.py +- [ ] Copy working test cases from notebook +- [ ] Set appropriate tolerance +- [ ] Add metric-specific behavior tests +- [ ] Document requirements +- [ ] Run tests and verify they pass + +### Quality & Finalization +- [ ] Run `make format` +- [ ] Run `make type` +- [ ] Run `make check` +- [ ] Run `make test` +- [ ] Run `make test-e2e` +- [ ] Update documentation if needed +- [ ] Create PR with checklist + +--- + +## File Structure Reference + +``` +ragas/ +โ”œโ”€โ”€ src/ragas/ +โ”‚ โ”œโ”€โ”€ prompts/metrics/ +โ”‚ โ”‚ โ””โ”€โ”€ {metric_name}.py # NEW: Prompt function +โ”‚ โ””โ”€โ”€ metrics/ +โ”‚ โ”œโ”€โ”€ collections/ +โ”‚ โ”‚ โ”œโ”€โ”€ _{metric_name}.py # NEW: V2 implementation +โ”‚ โ”‚ โ””โ”€โ”€ __init__.py # MODIFIED: Add export +โ”‚ โ””โ”€โ”€ _{metric_name}.py # EXISTING: Legacy implementation +โ”œโ”€โ”€ tests/ +โ”‚ โ”œโ”€โ”€ utils/ # EXISTING: Shared utilities +โ”‚ โ”‚ โ”œโ”€โ”€ __init__.py +โ”‚ โ”‚ โ””โ”€โ”€ llm_setup.py +โ”‚ โ”œโ”€โ”€ notebooks/ +โ”‚ โ”‚ โ””โ”€โ”€ metric_score_diff.ipynb # EXISTING: General-purpose testing notebook +โ”‚ โ””โ”€โ”€ e2e/metrics_migration/ +โ”‚ โ”œโ”€โ”€ conftest.py # EXISTING: Shared fixtures +โ”‚ โ”œโ”€โ”€ test_utils.py # EXISTING: Test utilities +โ”‚ โ”œโ”€โ”€ base_migration_test.py # EXISTING: Base test class +โ”‚ โ””โ”€โ”€ test_{metric_name}_migration.py # NEW: E2E tests +โ””โ”€โ”€ docs/ + โ””โ”€โ”€ howtos/migrations/ + โ””โ”€โ”€ {metric_name}.md # OPTIONAL: Migration guide +``` + +--- + +## Success Criteria + +โœ… **Implementation**: +- New metric produces similar scores to legacy (within tolerance) +- Works only with modern components (rejects legacy wrappers) +- Handles all edge cases properly +- Code is clean, typed, and documented + +โœ… **Testing**: +- E2E tests pass +- Manual notebook testing completed +- User satisfied with score matching +- All code quality checks pass + +โœ… **Documentation**: +- Usage examples clear +- Requirements documented +- Migration path explained (if needed) + +โœ… **Integration**: +- Exports added +- No regressions in existing tests +- Ready for PR and review + +--- + +This plan provides a complete, battle-tested workflow for migrating any metric from legacy to modern implementation, incorporating all learnings from previous migrations and leveraging the full testing infrastructure. diff --git a/tests/notebooks/metric_score_diff.ipynb b/tests/notebooks/metric_score_diff.ipynb deleted file mode 100644 index 18db8402a..000000000 --- a/tests/notebooks/metric_score_diff.ipynb +++ /dev/null @@ -1,923 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Metric Score Diff Checker\n", - "\n", - "This notebook provides utilities to compare scores between different metric versions, algorithms, LLMs, or datasets.\n", - "\n", - "## Dataset\n", - "This notebook uses the amnesty_qa dataset which contains human rights related Q&A pairs. It will attempt to load from HuggingFace and fallback to local samples if unavailable." - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [], - "source": [ - "import asyncio\n", - "import time\n", - "from dataclasses import dataclass\n", - "from typing import Any, Dict, List, Tuple\n", - "\n", - "import numpy as np\n", - "import pandas as pd\n", - "\n", - "# Ragas imports\n", - "from ragas.dataset_schema import SingleTurnSample" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Setup\n", - "\n", - "Make sure you have your OpenAI API key set as an environment variable before running this notebook." - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "โœ“ OpenAI API key found\n" - ] - } - ], - "source": [ - "import os\n", - "import sys\n", - "from pathlib import Path\n", - "\n", - "# Add tests directory to path so we can import from tests.utils\n", - "tests_dir = Path.cwd().parent.parent\n", - "sys.path.insert(0, str(tests_dir))\n", - "\n", - "from tests.utils import check_api_key\n", - "\n", - "# Check for OpenAI API key\n", - "try:\n", - " check_api_key(\"openai\")\n", - " print(\"โœ“ OpenAI API key found\")\n", - "except ValueError as e:\n", - " raise ValueError(str(e))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Utility Functions" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [], - "source": [ - "@dataclass\n", - "class MetricDiffResult:\n", - " \"\"\"Container for metric comparison results.\"\"\"\n", - "\n", - " old_scores: List[float]\n", - " new_scores: List[float]\n", - " diffs: List[float]\n", - " mean_diff: float\n", - " max_diff: float\n", - " min_diff: float\n", - " std_diff: float\n", - " old_mean: float\n", - " new_mean: float\n", - " old_time: float\n", - " new_time: float\n", - "\n", - " def to_dataframe(self) -> pd.DataFrame:\n", - " \"\"\"Convert results to a pandas DataFrame.\"\"\"\n", - " return pd.DataFrame(\n", - " {\n", - " \"old_score\": self.old_scores,\n", - " \"new_score\": self.new_scores,\n", - " \"diff\": self.diffs,\n", - " \"abs_diff\": [abs(d) for d in self.diffs],\n", - " }\n", - " )\n", - "\n", - " def print_summary(self):\n", - " \"\"\"Print a summary of the comparison.\"\"\"\n", - " print(\"=\" * 60)\n", - " print(\"METRIC COMPARISON SUMMARY\")\n", - " print(\"=\" * 60)\n", - " print(\"\\nScore Statistics:\")\n", - " print(f\" Old Metric Mean: {self.old_mean:.4f}\")\n", - " print(f\" New Metric Mean: {self.new_mean:.4f}\")\n", - " print(\"\\nDifference Statistics (new - old):\")\n", - " print(f\" Mean Diff: {self.mean_diff:.4f}\")\n", - " print(f\" Max Diff: {self.max_diff:.4f}\")\n", - " print(f\" Min Diff: {self.min_diff:.4f}\")\n", - " print(f\" Std Dev: {self.std_diff:.4f}\")\n", - " print(\"\\nExecution Time:\")\n", - " print(f\" Old Metric: {self.old_time:.2f}s\")\n", - " print(f\" New Metric: {self.new_time:.2f}s\")\n", - " print(\n", - " f\" Speedup: {self.old_time / self.new_time:.2f}x\"\n", - " if self.new_time > 0\n", - " else \" N/A\"\n", - " )\n", - " print(\"=\" * 60)" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [], - "source": [ - "async def run_metric_on_dataset(\n", - " metric: Any,\n", - " dataset: List[Dict[str, Any]],\n", - " metric_type: str = \"old\",\n", - " max_concurrent: int = 10,\n", - ") -> Tuple[List[float], float]:\n", - " \"\"\"\n", - " Run a metric on a dataset with concurrent processing for better performance.\n", - "\n", - " Args:\n", - " metric: The metric instance (either old or new style)\n", - " dataset: List of dictionaries containing the data samples\n", - " metric_type: \"old\" for legacy metrics, \"new\" for collections metrics\n", - " max_concurrent: Maximum number of concurrent requests (default: 10)\n", - "\n", - " Returns:\n", - " Tuple of (scores list, execution time in seconds)\n", - " \"\"\"\n", - "\n", - " async def score_single_sample(sample_dict: Dict[str, Any]) -> float:\n", - " \"\"\"Score a single sample.\"\"\"\n", - " try:\n", - " if metric_type == \"old\":\n", - " # Old metrics use SingleTurnSample\n", - " sample = SingleTurnSample(**sample_dict)\n", - " score = await metric._single_turn_ascore(sample, callbacks=None)\n", - " else:\n", - " # New metrics use direct kwargs\n", - " result = await metric.ascore(**sample_dict)\n", - " score = result.value\n", - "\n", - " return float(score)\n", - " except Exception as e:\n", - " print(f\"Error processing sample: {e}\")\n", - " return np.nan\n", - "\n", - " start_time = time.time()\n", - "\n", - " # Use semaphore to limit concurrent requests (prevents API rate limiting)\n", - " semaphore = asyncio.Semaphore(max_concurrent)\n", - "\n", - " async def score_with_limit(sample_dict: Dict[str, Any]) -> float:\n", - " \"\"\"Score with concurrency control.\"\"\"\n", - " async with semaphore:\n", - " return await score_single_sample(sample_dict)\n", - "\n", - " # Process all samples concurrently\n", - " scores = await asyncio.gather(*[score_with_limit(s) for s in dataset])\n", - "\n", - " execution_time = time.time() - start_time\n", - " return list(scores), execution_time" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [], - "source": [ - "async def compare_metrics(\n", - " old_metric: Any,\n", - " new_metric: Any,\n", - " dataset: List[Dict[str, Any]],\n", - " old_metric_type: str = \"old\",\n", - " new_metric_type: str = \"new\",\n", - " max_concurrent: int = 10,\n", - " parallel_metrics: bool = True,\n", - ") -> MetricDiffResult:\n", - " \"\"\"\n", - " Compare two metrics on the same dataset with optional parallel execution.\n", - "\n", - " Args:\n", - " old_metric: The baseline/old metric instance\n", - " new_metric: The new/updated metric instance\n", - " dataset: List of dictionaries containing the data samples\n", - " old_metric_type: Type identifier for old metric (\"old\" or \"new\")\n", - " new_metric_type: Type identifier for new metric (\"old\" or \"new\")\n", - " max_concurrent: Maximum number of concurrent requests per metric (default: 10)\n", - " parallel_metrics: If True, run both metrics in parallel. If False, run sequentially\n", - " for more accurate individual timing (default: True)\n", - "\n", - " Returns:\n", - " MetricDiffResult containing comparison statistics\n", - " \"\"\"\n", - " if parallel_metrics:\n", - " print(f\"Running both metrics in parallel on {len(dataset)} samples (max {max_concurrent} concurrent)...\")\n", - " \n", - " # Run both metrics concurrently using asyncio.gather\n", - " (old_scores, old_time), (new_scores, new_time) = await asyncio.gather(\n", - " run_metric_on_dataset(old_metric, dataset, old_metric_type, max_concurrent),\n", - " run_metric_on_dataset(new_metric, dataset, new_metric_type, max_concurrent),\n", - " )\n", - " else:\n", - " # Sequential execution for more accurate individual timing\n", - " print(f\"Running old metric on {len(dataset)} samples (max {max_concurrent} concurrent)...\")\n", - " old_scores, old_time = await run_metric_on_dataset(\n", - " old_metric, dataset, old_metric_type, max_concurrent\n", - " )\n", - "\n", - " print(f\"Running new metric on {len(dataset)} samples (max {max_concurrent} concurrent)...\")\n", - " new_scores, new_time = await run_metric_on_dataset(\n", - " new_metric, dataset, new_metric_type, max_concurrent\n", - " )\n", - "\n", - " # Calculate differences\n", - " diffs = [new - old for old, new in zip(old_scores, new_scores)]\n", - "\n", - " return MetricDiffResult(\n", - " old_scores=old_scores,\n", - " new_scores=new_scores,\n", - " diffs=diffs,\n", - " mean_diff=float(np.mean(diffs)),\n", - " max_diff=float(np.max(diffs)),\n", - " min_diff=float(np.min(diffs)),\n", - " std_diff=float(np.std(diffs)),\n", - " old_mean=float(np.mean(old_scores)),\n", - " new_mean=float(np.mean(new_scores)),\n", - " old_time=old_time,\n", - " new_time=new_time,\n", - " )" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [], - "source": [ - "async def run_metric_on_dataset_with_batching(\n", - " metric: Any,\n", - " dataset: List[Dict[str, Any]],\n", - " metric_type: str = \"new\",\n", - " batch_size: int = 5,\n", - ") -> Tuple[List[float], float]:\n", - " \"\"\"\n", - " Run metric using batch processing if available (for better performance).\n", - " \n", - " This function attempts to use the metric's abatch_score method if available,\n", - " which can be more efficient than individual scoring. Falls back to concurrent\n", - " processing if batching is not supported.\n", - "\n", - " Args:\n", - " metric: The metric instance\n", - " dataset: List of dictionaries containing the data samples\n", - " metric_type: \"old\" or \"new\" - old metrics don't support batching\n", - " batch_size: Number of samples per batch (default: 5)\n", - "\n", - " Returns:\n", - " Tuple of (scores list, execution time in seconds)\n", - " \"\"\"\n", - " # Check if metric supports batching\n", - " has_batch = hasattr(metric, \"abatch_score\")\n", - "\n", - " if not has_batch or metric_type == \"old\":\n", - " # Fall back to concurrent processing\n", - " print(f\" Batching not available, using concurrent processing...\")\n", - " return await run_metric_on_dataset(metric, dataset, metric_type)\n", - "\n", - " start_time = time.time()\n", - " all_scores = []\n", - "\n", - " # Process in batches\n", - " num_batches = (len(dataset) + batch_size - 1) // batch_size\n", - " print(f\" Processing {len(dataset)} samples in {num_batches} batches of {batch_size}...\")\n", - "\n", - " for i in range(0, len(dataset), batch_size):\n", - " batch = dataset[i : i + batch_size]\n", - " try:\n", - " results = await metric.abatch_score(batch)\n", - " scores = [r.value for r in results]\n", - " all_scores.extend(scores)\n", - " except Exception as e:\n", - " print(f\" Warning: Batch {i//batch_size + 1} failed ({e}), falling back to individual processing...\")\n", - " # Fall back to individual processing for this batch\n", - " for sample in batch:\n", - " try:\n", - " result = await metric.ascore(**sample)\n", - " all_scores.append(result.value)\n", - " except Exception as e2:\n", - " print(f\" Error processing sample: {e2}\")\n", - " all_scores.append(np.nan)\n", - "\n", - " execution_time = time.time() - start_time\n", - " return all_scores, execution_time" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Example 1: Compare Answer Relevancy (Old vs New Implementation)\n", - "\n", - "Compare the legacy `AnswerRelevancy` from `ragas.metrics` with the new `AnswerRelevancy` from `ragas.metrics.collections`." - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [], - "source": [ - "# Import setup utilities from shared test utilities\n", - "from tests.utils import (\n", - " create_legacy_embeddings,\n", - " create_legacy_llm,\n", - " create_modern_embeddings,\n", - " create_modern_llm,\n", - ")\n", - "\n", - "# For old metric (legacy) - uses legacy factories\n", - "legacy_llm = create_legacy_llm(model=\"gpt-4o-mini\")\n", - "legacy_embeddings = create_legacy_embeddings(model=\"text-embedding-ada-002\")\n", - "\n", - "# For new metric (modern) - uses modern factories with OpenAI client\n", - "modern_llm = create_modern_llm(provider=\"openai\", model=\"gpt-4o-mini\")\n", - "modern_embeddings = create_modern_embeddings(\n", - " provider=\"openai\", model=\"text-embedding-ada-002\"\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [], - "source": [ - "# Import metrics\n", - "from ragas.metrics._answer_relevance import AnswerRelevancy as OldAnswerRelevancy\n", - "from ragas.metrics.collections._answer_relevancy import (\n", - " AnswerRelevancy as NewAnswerRelevancy,\n", - ")\n", - "\n", - "# Initialize metrics\n", - "old_metric = OldAnswerRelevancy(\n", - " llm=legacy_llm, embeddings=legacy_embeddings, strictness=3\n", - ")\n", - "\n", - "new_metric = NewAnswerRelevancy(\n", - " llm=modern_llm, embeddings=modern_embeddings, strictness=3\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "/Users/jjmachan/workspace/eglabs/ragas-workdir/ragas\n" - ] - } - ], - "source": [ - "import sys\n", - "from pathlib import Path\n", - "\n", - "path = Path.cwd().parent.parent\n", - "print(path)\n", - "sys.path.insert(0, str(path))\n", - "\n", - "from tests.e2e.test_dataset_utils import load_amnesty_dataset_safe" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Test dataset contains 15 samples from amnesty_qa\n", - "\n", - "First sample:\n", - "Question: What are the global implications of the USA Supreme Court ruling on abortion?\n", - "Response: The global implications of the USA Supreme Court ruling on abortion can be significant, as it sets a...\n" - ] - } - ], - "source": [ - "# Add tests directory to path\n", - "tests_dir = Path.cwd().parent if Path.cwd().name == \"notebooks\" else Path.cwd()\n", - "if tests_dir.name == \"tests\":\n", - " sys.path.insert(0, str(tests_dir.parent))\n", - "else:\n", - " sys.path.insert(0, str(tests_dir))\n", - "\n", - "# Load the dataset (will use HuggingFace or fallback to local samples)\n", - "amnesty_dataset = load_amnesty_dataset_safe(\"english_v3\")\n", - "\n", - "# Convert to list of dicts for our utility functions\n", - "# We'll use a subset for faster testing\n", - "test_dataset = []\n", - "for i, sample in enumerate(amnesty_dataset):\n", - " if i >= 15: # Limit to 5 samples for faster testing\n", - " break\n", - " test_dataset.append(\n", - " {\"user_input\": sample[\"user_input\"], \"response\": sample[\"response\"]}\n", - " )\n", - "\n", - "print(f\"Test dataset contains {len(test_dataset)} samples from amnesty_qa\")\n", - "print(\"\\nFirst sample:\")\n", - "print(f\"Question: {test_dataset[0]['user_input']}\")\n", - "print(f\"Response: {test_dataset[0]['response'][:100]}...\")" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Running both metrics in parallel on 15 samples (max 10 concurrent)...\n", - "============================================================\n", - "METRIC COMPARISON SUMMARY\n", - "============================================================\n", - "\n", - "Score Statistics:\n", - " Old Metric Mean: 0.9023\n", - " New Metric Mean: 0.9670\n", - "\n", - "Difference Statistics (new - old):\n", - " Mean Diff: 0.0647\n", - " Max Diff: 0.9992\n", - " Min Diff: -0.0232\n", - " Std Dev: 0.2499\n", - "\n", - "Execution Time:\n", - " Old Metric: 22.33s\n", - " New Metric: 32.67s\n", - " Speedup: 0.68x\n", - "============================================================\n" - ] - } - ], - "source": [ - "# Run comparison\n", - "result = await compare_metrics(\n", - " old_metric=old_metric,\n", - " new_metric=new_metric,\n", - " dataset=test_dataset,\n", - " old_metric_type=\"old\",\n", - " new_metric_type=\"new\",\n", - ")\n", - "\n", - "# Print summary\n", - "result.print_summary()" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \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", - "
user_inputold_scorenew_scorediffabs_diff
0What are the global implications of the USA Su...0.9999991.0000000.0000010.000001
1Which companies are the main contributors to G...0.9652470.9652600.0000130.000013
2Which private companies in the Americas are th...0.9844030.982324-0.0020790.002079
3What action did Amnesty International urge its...0.9887780.983347-0.0054310.005431
4What are the recommendations made by Amnesty I...0.9890840.9890850.0000010.000001
5Who are the target audience of the two books c...0.0000000.9992090.9992090.999209
6Which right guarantees access to comprehensive...0.9658840.9676050.0017200.001720
7Who has the right to be fully informed about h...0.9374200.9413280.0039080.003908
8When can individuals be found guilty under Art...0.8998820.9018580.0019760.001976
9When does the prosecution consider statements ...0.9078750.9084570.0005820.000582
10What factors have contributed to the decline o...1.0000000.998699-0.0013010.001301
11What conditions designate wetlands as Ramsar s...0.9789480.974074-0.0048740.004874
12Where was COP15 held in 2022?0.9999980.976795-0.0232020.023202
13What is the purpose of the agreement known as ...0.9839270.9946370.0107100.010710
14Who failed to explicitly recognize Indigenous ...0.9328970.921576-0.0113210.011321
\n", - "
" - ], - "text/plain": [ - " user_input old_score new_score \\\n", - "0 What are the global implications of the USA Su... 0.999999 1.000000 \n", - "1 Which companies are the main contributors to G... 0.965247 0.965260 \n", - "2 Which private companies in the Americas are th... 0.984403 0.982324 \n", - "3 What action did Amnesty International urge its... 0.988778 0.983347 \n", - "4 What are the recommendations made by Amnesty I... 0.989084 0.989085 \n", - "5 Who are the target audience of the two books c... 0.000000 0.999209 \n", - "6 Which right guarantees access to comprehensive... 0.965884 0.967605 \n", - "7 Who has the right to be fully informed about h... 0.937420 0.941328 \n", - "8 When can individuals be found guilty under Art... 0.899882 0.901858 \n", - "9 When does the prosecution consider statements ... 0.907875 0.908457 \n", - "10 What factors have contributed to the decline o... 1.000000 0.998699 \n", - "11 What conditions designate wetlands as Ramsar s... 0.978948 0.974074 \n", - "12 Where was COP15 held in 2022? 0.999998 0.976795 \n", - "13 What is the purpose of the agreement known as ... 0.983927 0.994637 \n", - "14 Who failed to explicitly recognize Indigenous ... 0.932897 0.921576 \n", - "\n", - " diff abs_diff \n", - "0 0.000001 0.000001 \n", - "1 0.000013 0.000013 \n", - "2 -0.002079 0.002079 \n", - "3 -0.005431 0.005431 \n", - "4 0.000001 0.000001 \n", - "5 0.999209 0.999209 \n", - "6 0.001720 0.001720 \n", - "7 0.003908 0.003908 \n", - "8 0.001976 0.001976 \n", - "9 0.000582 0.000582 \n", - "10 -0.001301 0.001301 \n", - "11 -0.004874 0.004874 \n", - "12 -0.023202 0.023202 \n", - "13 0.010710 0.010710 \n", - "14 -0.011321 0.011321 " - ] - }, - "execution_count": 30, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# View detailed results\n", - "df = result.to_dataframe()\n", - "df[\"user_input\"] = [s[\"user_input\"] for s in test_dataset]\n", - "df = df[[\"user_input\", \"old_score\", \"new_score\", \"diff\", \"abs_diff\"]]\n", - "df" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Visualize the differences\n", - "import matplotlib.pyplot as plt\n", - "\n", - "fig, axes = plt.subplots(1, 2, figsize=(14, 5))\n", - "\n", - "# Plot 1: Score comparison\n", - "x = range(len(result.old_scores))\n", - "axes[0].plot(x, result.old_scores, \"o-\", label=\"Old Metric\", linewidth=2)\n", - "axes[0].plot(x, result.new_scores, \"s-\", label=\"New Metric\", linewidth=2)\n", - "axes[0].set_xlabel(\"Sample Index\")\n", - "axes[0].set_ylabel(\"Score\")\n", - "axes[0].set_title(\"Metric Scores Comparison\")\n", - "axes[0].legend()\n", - "axes[0].grid(True, alpha=0.3)\n", - "\n", - "# Plot 2: Difference distribution\n", - "axes[1].bar(x, result.diffs, alpha=0.7)\n", - "axes[1].axhline(y=0, color=\"r\", linestyle=\"--\", linewidth=1)\n", - "axes[1].set_xlabel(\"Sample Index\")\n", - "axes[1].set_ylabel(\"Difference (New - Old)\")\n", - "axes[1].set_title(\"Score Differences\")\n", - "axes[1].grid(True, alpha=0.3)\n", - "\n", - "plt.tight_layout()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Example 2: Compare Same Metric with Different LLMs\n", - "\n", - "Compare how the same metric performs with different LLM models." - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [], - "source": [ - "# Create two instances with different LLMs using shared utilities\n", - "llm_gpt4_mini = create_modern_llm(provider=\"openai\", model=\"gpt-4o-mini\")\n", - "llm_gpt4 = create_modern_llm(provider=\"openai\", model=\"gpt-4o\")\n", - "\n", - "embeddings = create_modern_embeddings(provider=\"openai\", model=\"text-embedding-ada-002\")\n", - "\n", - "metric_gpt4_mini = NewAnswerRelevancy(\n", - " llm=llm_gpt4_mini, embeddings=embeddings, strictness=3\n", - ")\n", - "\n", - "metric_gpt4 = NewAnswerRelevancy(llm=llm_gpt4, embeddings=embeddings, strictness=3)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Running old metric on 15 samples...\n", - "Running new metric on 15 samples...\n" - ] - } - ], - "source": [ - "# Compare LLMs\n", - "result_llm = await compare_metrics(\n", - " old_metric=metric_gpt4_mini,\n", - " new_metric=metric_gpt4,\n", - " dataset=test_dataset,\n", - " old_metric_type=\"new\",\n", - " new_metric_type=\"new\",\n", - ")\n", - "\n", - "result_llm.print_summary()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Example 3: Compare with Different Datasets\n", - "\n", - "Load different datasets to test metric consistency." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Use different subsets of amnesty dataset\n", - "# First 2 samples\n", - "dataset_subset_1 = test_dataset[:2]\n", - "\n", - "# Next 2 samples (if available)\n", - "dataset_subset_2 = test_dataset[2:4] if len(test_dataset) >= 4 else test_dataset[:2]\n", - "\n", - "print(f\"Subset 1: {len(dataset_subset_1)} samples\")\n", - "print(f\"Subset 2: {len(dataset_subset_2)} samples\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Compare same metric on different dataset subsets\n", - "print(\"\\n=== Dataset Subset 1 ===\")\n", - "scores_subset_1, time_subset_1 = await run_metric_on_dataset(\n", - " new_metric, dataset_subset_1, \"new\"\n", - ")\n", - "print(f\"Mean score: {np.mean(scores_subset_1):.4f}\")\n", - "print(f\"Execution time: {time_subset_1:.2f}s\")\n", - "\n", - "print(\"\\n=== Dataset Subset 2 ===\")\n", - "scores_subset_2, time_subset_2 = await run_metric_on_dataset(\n", - " new_metric, dataset_subset_2, \"new\"\n", - ")\n", - "print(f\"Mean score: {np.mean(scores_subset_2):.4f}\")\n", - "print(f\"Execution time: {time_subset_2:.2f}s\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Utility: Export Results to CSV" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "def export_comparison_results(\n", - " result: MetricDiffResult,\n", - " dataset: List[Dict[str, Any]],\n", - " filename: str = \"metric_comparison_results.csv\",\n", - "):\n", - " \"\"\"Export comparison results to CSV file.\"\"\"\n", - " df = result.to_dataframe()\n", - "\n", - " # Add dataset information\n", - " for key in dataset[0].keys():\n", - " df[key] = [sample[key] for sample in dataset]\n", - "\n", - " # Add summary statistics as a separate row\n", - " summary = pd.DataFrame(\n", - " [\n", - " {\n", - " \"user_input\": \"SUMMARY\",\n", - " \"old_score\": result.old_mean,\n", - " \"new_score\": result.new_mean,\n", - " \"diff\": result.mean_diff,\n", - " \"abs_diff\": np.mean([abs(d) for d in result.diffs]),\n", - " }\n", - " ]\n", - " )\n", - "\n", - " df = pd.concat([df, summary], ignore_index=True)\n", - " df.to_csv(filename, index=False)\n", - " print(f\"Results exported to {filename}\")\n", - "\n", - "\n", - "# Example usage\n", - "export_comparison_results(result, test_dataset, \"answer_relevancy_comparison.csv\")" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": ".venv", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.12.8" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} From 3ea40e7dd6e0ddb8a3e05101b417ff2794bf4fb6 Mon Sep 17 00:00:00 2001 From: jjmachan Date: Wed, 15 Oct 2025 19:45:05 -0700 Subject: [PATCH 5/7] improvements to metrics migration plan --- .../metrics_migration/metric_score_diff.ipynb | 371 ++++++++++-------- .../plan-for-metrics-migration.md | 7 +- .../test_context_recall_migration.py | 158 -------- 3 files changed, 201 insertions(+), 335 deletions(-) delete mode 100644 tests/e2e/metrics_migration/test_context_recall_migration.py diff --git a/tests/e2e/metrics_migration/metric_score_diff.ipynb b/tests/e2e/metrics_migration/metric_score_diff.ipynb index 98b3c2a47..f8a84b1a4 100644 --- a/tests/e2e/metrics_migration/metric_score_diff.ipynb +++ b/tests/e2e/metrics_migration/metric_score_diff.ipynb @@ -30,18 +30,9 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 7, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/jjmachan/workspace/eglabs/ragas-workdir/ragas/.venv/lib/python3.12/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", - " from .autonotebook import tqdm as notebook_tqdm\n" - ] - } - ], + "outputs": [], "source": [ "import asyncio\n", "import time\n", @@ -57,7 +48,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -113,6 +104,33 @@ "print(\"โœ“ Configuration loaded - Edit above for your metric\")" ] }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "METRIC_CONFIG = {\n", + " # ===== METRIC IMPORTS =====\n", + " \"legacy_import\": {\n", + " \"module\": \"ragas.metrics._context_precision\",\n", + " \"class_name\": \"LLMContextPrecisionWithReference\",\n", + " },\n", + " \"modern_import\": {\n", + " \"module\": \"ragas.metrics.collections\",\n", + " \"class_name\": \"ContextPrecision\",\n", + " },\n", + "\n", + " # ===== COMPONENT REQUIREMENTS =====\n", + " \"needs_llm\": True,\n", + " \"needs_embeddings\": False,\n", + "\n", + " # ===== DATASET FIELD MAPPING =====\n", + " # Context-based metric using user_input, retrieved_contexts, and reference\n", + " \"dataset_fields\": [\"user_input\", \"retrieved_contexts\", \"reference\"],\n", + "}\n" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -124,7 +142,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -133,8 +151,8 @@ "text": [ "โœ“ Setup complete\n", "โœ“ Metric classes loaded:\n", - " Legacy: AnswerRelevancy from ragas.metrics._answer_relevance\n", - " Modern: AnswerRelevancy from ragas.metrics.collections\n" + " Legacy: LLMContextPrecisionWithReference from ragas.metrics._context_precision\n", + " Modern: ContextPrecision from ragas.metrics.collections\n" ] } ], @@ -145,7 +163,7 @@ "import importlib\n", "\n", "# Add project root to path\n", - "project_root = Path.cwd().parent.parent\n", + "project_root = Path.cwd().parent.parent.parent\n", "sys.path.insert(0, str(project_root))\n", "\n", "from tests.utils import check_api_key\n", @@ -186,7 +204,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -214,7 +232,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -222,7 +240,6 @@ "output_type": "stream", "text": [ "โœ“ LLM components created\n", - "โœ“ Embeddings components created\n", "โœ“ All required components created\n" ] } @@ -269,7 +286,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -277,9 +294,9 @@ "output_type": "stream", "text": [ "โœ“ Metrics initialized:\n", - " Legacy: answer_relevancy\n", - " Modern: answer_relevancy\n", - " Dataset fields required: ['user_input', 'response']\n" + " Legacy: llm_context_precision_with_reference\n", + " Modern: context_precision\n", + " Dataset fields required: ['user_input', 'retrieved_contexts', 'reference']\n" ] } ], @@ -312,41 +329,6 @@ "print(f\" Dataset fields required: {METRIC_CONFIG['dataset_fields']}\")" ] }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'legacy_llm' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[31m---------------------------------------------------------------------------\u001b[39m", - "\u001b[31mNameError\u001b[39m Traceback (most recent call last)", - "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[8]\u001b[39m\u001b[32m, line 7\u001b[39m\n\u001b[32m 3\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mragas\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mmetrics\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mcollections\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m AnswerRelevancy\n\u001b[32m 5\u001b[39m \u001b[38;5;66;03m# Initialize metrics\u001b[39;00m\n\u001b[32m 6\u001b[39m legacy_metric = LegacyAnswerRelevancy(\n\u001b[32m----> \u001b[39m\u001b[32m7\u001b[39m llm=\u001b[43mlegacy_llm\u001b[49m, embeddings=legacy_embeddings, strictness=\u001b[32m3\u001b[39m\n\u001b[32m 8\u001b[39m )\n\u001b[32m 9\u001b[39m new_metric = AnswerRelevancy(\n\u001b[32m 10\u001b[39m llm=modern_llm, embeddings=modern_embeddings, strictness=\u001b[32m3\u001b[39m\n\u001b[32m 11\u001b[39m )\n\u001b[32m 13\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mLegacy metric: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mlegacy_metric.name\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m)\n", - "\u001b[31mNameError\u001b[39m: name 'legacy_llm' is not defined" - ] - } - ], - "source": [ - "# Import metrics\n", - "from ragas.metrics._answer_relevance import AnswerRelevancy as LegacyAnswerRelevancy\n", - "from ragas.metrics.collections import AnswerRelevancy\n", - "\n", - "# Initialize metrics\n", - "legacy_metric = LegacyAnswerRelevancy(\n", - " llm=legacy_llm, embeddings=legacy_embeddings, strictness=3\n", - ")\n", - "new_metric = AnswerRelevancy(\n", - " llm=modern_llm, embeddings=modern_embeddings, strictness=3\n", - ")\n", - "\n", - "print(f\"Legacy metric: {legacy_metric.name}\")\n", - "print(f\"New metric: {new_metric.name}\")\n", - "print(\"โœ“ Metrics initialized\")" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -360,9 +342,24 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading amnesty_qa dataset...\n", + "โœ“ Loaded 20 samples from amnesty_qa\n", + "โœ“ Prepared 20 samples for testing\n", + "\n", + "First sample fields:\n", + " user_input: What are the global implications of the USA Supreme Court ruling on abortion?...\n", + " retrieved_contexts: 3 item(s)\n", + " reference: The global implications of the USA Supreme Court ruling on abortion are signific...\n" + ] + } + ], "source": [ "from tests.e2e.test_dataset_utils import load_amnesty_dataset_safe\n", "\n", @@ -419,7 +416,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -439,19 +436,19 @@ "============================================================\n", "\n", "Score Statistics:\n", - " Old Metric Mean: 0.9211\n", - " New Metric Mean: 0.9736\n", + " Old Metric Mean: 0.8583\n", + " New Metric Mean: 0.8292\n", "\n", "Difference Statistics (new - old):\n", - " Mean Diff: 0.0525\n", - " Max Diff: 0.9992\n", - " Min Diff: -0.0221\n", - " Std Dev: 0.2174\n", + " Mean Diff: -0.0292\n", + " Max Diff: 0.4167\n", + " Min Diff: -0.5000\n", + " Std Dev: 0.1565\n", "\n", "Execution Time:\n", - " Old Metric: 34.06s\n", - " New Metric: 48.82s\n", - " Speedup: 0.70x\n", + " Old Metric: 10.74s\n", + " New Metric: 10.18s\n", + " Speedup: 1.06x\n", "============================================================\n" ] } @@ -467,7 +464,7 @@ "\n", "amnesty_result = await compare_metrics(\n", " old_metric=legacy_metric,\n", - " new_metric=new_metric,\n", + " new_metric=modern_metric,\n", " dataset=amnesty_test_data,\n", " old_metric_type=\"old\",\n", " new_metric_type=\"new\",\n", @@ -487,7 +484,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -502,57 +499,57 @@ "Dataset: amnesty_qa (20 samples)\n", "\n", "Score Statistics:\n", - " Legacy Mean: 0.9211\n", - " New Mean: 0.9736\n", - " Score Shift: +0.0525\n", + " Legacy Mean: 0.8583\n", + " New Mean: 0.8292\n", + " Score Shift: -0.0292\n", "\n", "Difference Statistics:\n", - " Mean |Diff|: 0.0558\n", - " Std Dev: 0.2174\n", - " Max Diff: 0.9992\n", - " Min Diff: -0.0221\n", - " Median Diff: 0.0026\n", + " Mean |Diff|: 0.0708\n", + " Std Dev: 0.1565\n", + " Max Diff: 0.4167\n", + " Min Diff: -0.5000\n", + " Median Diff: 0.0000\n", "\n", "Tolerance Analysis:\n", - " < 0.10: 19/20 ( 95.0%)\n", - " < 0.15: 19/20 ( 95.0%)\n", - " < 0.20: 19/20 ( 95.0%)\n", - " < 0.25: 19/20 ( 95.0%)\n", - " < 0.30: 19/20 ( 95.0%)\n", + " < 0.10: 15/20 ( 75.0%)\n", + " < 0.15: 15/20 ( 75.0%)\n", + " < 0.20: 18/20 ( 90.0%)\n", + " < 0.25: 18/20 ( 90.0%)\n", + " < 0.30: 18/20 ( 90.0%)\n", "\n", "======================================================================\n", "TOP 10 LARGEST DIFFERENCES\n", "======================================================================\n", "\n", - "#6: Who are the target audience of the two books created by Amne...\n", - " Legacy: 0.0000 | New: 0.9992 | Diff: 0.9992\n", + "#4: What action did Amnesty International urge its supporters to...\n", + " Legacy: 1.0000 | New: 0.5000 | Diff: 0.5000\n", "\n", - "#9: When can individuals be found guilty under Article 207.3 of ...\n", - " Legacy: 0.8999 | New: 0.9259 | Diff: 0.0260\n", + "#20: When did the government of Qatar start repealing restriction...\n", + " Legacy: 0.5833 | New: 1.0000 | Diff: 0.4167\n", "\n", - "#13: Where was COP15 held in 2022?...\n", - " Legacy: 1.0000 | New: 0.9779 | Diff: 0.0221\n", - "\n", - "#8: Who has the right to be fully informed about human rights vi...\n", - " Legacy: 0.9374 | New: 0.9588 | Diff: 0.0214\n", + "#7: Which right guarantees access to comprehensive information a...\n", + " Legacy: 1.0000 | New: 0.8333 | Diff: 0.1667\n", "\n", - "#3: Which private companies in the Americas are the largest GHG ...\n", - " Legacy: 0.9778 | New: 0.9939 | Diff: 0.0161\n", + "#12: What conditions designate wetlands as Ramsar sites?...\n", + " Legacy: 1.0000 | New: 0.8333 | Diff: 0.1667\n", "\n", - "#15: Who failed to explicitly recognize Indigenous Peoples' lands...\n", - " Legacy: 0.9051 | New: 0.9175 | Diff: 0.0124\n", + "#19: What labor abuses were documented by Amnesty International i...\n", + " Legacy: 1.0000 | New: 0.8333 | Diff: 0.1667\n", "\n", "#10: When does the prosecution consider statements contrary to th...\n", - " Legacy: 0.9078 | New: 0.9119 | Diff: 0.0041\n", + " Legacy: 1.0000 | New: 1.0000 | Diff: 0.0000\n", "\n", - "#7: Which right guarantees access to comprehensive information a...\n", - " Legacy: 0.9679 | New: 0.9641 | Diff: 0.0039\n", - "\n", - "#5: What are the recommendations made by Amnesty International t...\n", - " Legacy: 0.9891 | New: 0.9927 | Diff: 0.0036\n", + "#1: What are the global implications of the USA Supreme Court ru...\n", + " Legacy: 1.0000 | New: 1.0000 | Diff: 0.0000\n", "\n", "#2: Which companies are the main contributors to GHG emissions a...\n", - " Legacy: 0.9652 | New: 0.9621 | Diff: 0.0031\n" + " Legacy: 1.0000 | New: 1.0000 | Diff: 0.0000\n", + "\n", + "#3: Which private companies in the Americas are the largest GHG ...\n", + " Legacy: 0.8333 | New: 0.8333 | Diff: 0.0000\n", + "\n", + "#5: What are the recommendations made by Amnesty International t...\n", + " Legacy: 0.5833 | New: 0.5833 | Diff: 0.0000\n" ] } ], @@ -615,20 +612,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/var/folders/2y/02fp70k56p75ldrkgtx7z10r0000gn/T/ipykernel_82228/1485780648.py:59: MatplotlibDeprecationWarning: The 'labels' parameter of boxplot() has been renamed 'tick_labels' since Matplotlib 3.9; support for the old name will be dropped in 3.11.\n", + "/var/folders/2y/02fp70k56p75ldrkgtx7z10r0000gn/T/ipykernel_39797/1485780648.py:59: MatplotlibDeprecationWarning: The 'labels' parameter of boxplot() has been renamed 'tick_labels' since Matplotlib 3.9; support for the old name will be dropped in 3.11.\n", " ax5.boxplot([df_amnesty[\"old_score\"], df_amnesty[\"new_score\"]], labels=['Legacy', 'New'])\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -733,7 +730,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -742,15 +739,15 @@ "text": [ "๐ŸŽฏ AMNESTY QA VALIDATION COMPLETE\n", "======================================================================\n", - " Mean |Diff|: 0.0558\n", - " Within 0.2: 19/20 (95.0%)\n", - " Within 0.3: 19/20 (95.0%)\n", + " Mean |Diff|: 0.0708\n", + " Within 0.2: 18/20 (90.0%)\n", + " Within 0.3: 18/20 (90.0%)\n", "\n", "๐Ÿ“Š Validation Criteria (LLM-based metrics):\n", - " โœ… Mean |diff| < 0.15: 0.0558\n", - " โœ… >90% within 0.2: 95.0%\n", - " โš ๏ธ >95% within 0.3: 95.0%\n", - " โš ๏ธ No systematic bias (|mean diff| < 0.05): 0.0525\n", + " โœ… Mean |diff| < 0.15: 0.0708\n", + " โš ๏ธ >90% within 0.2: 90.0%\n", + " โš ๏ธ >95% within 0.3: 90.0%\n", + " โœ… No systematic bias (|mean diff| < 0.05): 0.0292\n", "\n", "๐Ÿ’ก For deterministic metrics, use stricter criteria:\n", " - Mean |diff| < 1e-10\n", @@ -800,9 +797,28 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "======================================================================\n", + "FIQA DATASET COMPARISON\n", + "======================================================================\n", + "Testing on financial Q&A dataset for domain generalization...\n", + "โœ“ Loaded 30 samples from fiqa\n", + "โœ“ Prepared 30 samples for testing\n", + "\n", + "First sample fields:\n", + " user_input: How to deposit a cheque issued to an associate in my business into my business a...\n", + " retrieved_contexts: 1 item(s)\n", + " reference: [\"Have the check reissued to the proper payee.Just have the associate sign the b...\n" + ] + } + ], "source": [ "### Load FIQA Dataset\n", "\n", @@ -858,7 +874,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "metadata": {}, "outputs": [ { @@ -876,19 +892,19 @@ "============================================================\n", "\n", "Score Statistics:\n", - " Old Metric Mean: 0.7542\n", - " New Metric Mean: 0.7887\n", + " Old Metric Mean: 0.8667\n", + " New Metric Mean: 0.8667\n", "\n", "Difference Statistics (new - old):\n", - " Mean Diff: 0.0346\n", - " Max Diff: 0.9577\n", - " Min Diff: -0.0120\n", - " Std Dev: 0.1716\n", + " Mean Diff: 0.0000\n", + " Max Diff: 1.0000\n", + " Min Diff: -1.0000\n", + " Std Dev: 0.2582\n", "\n", "Execution Time:\n", - " Old Metric: 33.05s\n", - " New Metric: 58.09s\n", - " Speedup: 0.57x\n", + " Old Metric: 5.70s\n", + " New Metric: 6.35s\n", + " Speedup: 0.90x\n", "============================================================\n" ] } @@ -903,7 +919,7 @@ "\n", "fiqa_result = await compare_metrics(\n", " old_metric=legacy_metric,\n", - " new_metric=new_metric,\n", + " new_metric=modern_metric,\n", " dataset=fiqa_test_data,\n", " old_metric_type=\"old\",\n", " new_metric_type=\"new\",\n", @@ -916,7 +932,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 23, "metadata": {}, "outputs": [ { @@ -931,57 +947,57 @@ "Dataset: fiqa (30 samples)\n", "\n", "Score Statistics:\n", - " Legacy Mean: 0.7542\n", - " New Mean: 0.7887\n", - " Score Shift: +0.0346\n", + " Legacy Mean: 0.8667\n", + " New Mean: 0.8667\n", + " Score Shift: +0.0000\n", "\n", "Difference Statistics:\n", - " Mean |Diff|: 0.0364\n", - " Std Dev: 0.1716\n", - " Max Diff: 0.9577\n", - " Min Diff: -0.0120\n", - " Median Diff: 0.0029\n", + " Mean |Diff|: 0.0667\n", + " Std Dev: 0.2582\n", + " Max Diff: 1.0000\n", + " Min Diff: -1.0000\n", + " Median Diff: 0.0000\n", "\n", "Tolerance Analysis:\n", - " < 0.10: 29/30 ( 96.7%)\n", - " < 0.15: 29/30 ( 96.7%)\n", - " < 0.20: 29/30 ( 96.7%)\n", - " < 0.25: 29/30 ( 96.7%)\n", - " < 0.30: 29/30 ( 96.7%)\n", + " < 0.10: 28/30 ( 93.3%)\n", + " < 0.15: 28/30 ( 93.3%)\n", + " < 0.20: 28/30 ( 93.3%)\n", + " < 0.25: 28/30 ( 93.3%)\n", + " < 0.30: 28/30 ( 93.3%)\n", "\n", "======================================================================\n", "TOP 10 LARGEST DIFFERENCES\n", "======================================================================\n", "\n", - "#11: Using credit card points to pay for tax deductible business ...\n", - " Legacy: 0.0000 | New: 0.9577 | Diff: 0.9577\n", + "#5: 401k Transfer After Business Closure...\n", + " Legacy: 1.0000 | New: 0.0000 | Diff: 1.0000\n", "\n", - "#8: Intentions of Deductible Amount for Small Business...\n", - " Legacy: 0.9299 | New: 0.9501 | Diff: 0.0202\n", + "#24: Employer options when setting up 401k for employees...\n", + " Legacy: 0.0000 | New: 1.0000 | Diff: 1.0000\n", "\n", - "#4: Applying for and receiving business credit...\n", - " Legacy: 0.9126 | New: 0.9284 | Diff: 0.0158\n", + "#1: How to deposit a cheque issued to an associate in my busines...\n", + " Legacy: 1.0000 | New: 1.0000 | Diff: 0.0000\n", "\n", "#2: Can I send a money order from USPS as a business?...\n", - " Legacy: 0.9660 | New: 0.9810 | Diff: 0.0151\n", + " Legacy: 1.0000 | New: 1.0000 | Diff: 0.0000\n", "\n", "#3: 1 EIN doing business under multiple business names...\n", - " Legacy: 0.9348 | New: 0.9487 | Diff: 0.0139\n", + " Legacy: 1.0000 | New: 1.0000 | Diff: 0.0000\n", "\n", - "#22: Where to request ACH Direct DEBIT of funds from MY OWN perso...\n", - " Legacy: 0.9821 | New: 0.9701 | Diff: 0.0120\n", + "#4: Applying for and receiving business credit...\n", + " Legacy: 1.0000 | New: 1.0000 | Diff: 0.0000\n", "\n", - "#23: Challenged an apparently bogus credit card charge, what happ...\n", - " Legacy: 0.8674 | New: 0.8777 | Diff: 0.0103\n", + "#6: What are the ins/outs of writing equipment purchases off as ...\n", + " Legacy: 1.0000 | New: 1.0000 | Diff: 0.0000\n", "\n", - "#21: What percentage of my company should I have if I only put mo...\n", - " Legacy: 0.8675 | New: 0.8757 | Diff: 0.0081\n", + "#7: Can a entrepreneur hire a self-employed business owner?...\n", + " Legacy: 1.0000 | New: 1.0000 | Diff: 0.0000\n", "\n", - "#18: Have plenty of cash flow but bad credit...\n", - " Legacy: 0.9158 | New: 0.9222 | Diff: 0.0064\n", + "#8: Intentions of Deductible Amount for Small Business...\n", + " Legacy: 0.0000 | New: 0.0000 | Diff: 0.0000\n", "\n", - "#25: Following an investment guru a good idea?...\n", - " Legacy: 0.9572 | New: 0.9629 | Diff: 0.0057\n" + "#9: How can I deposit a check made out to my business into my pe...\n", + " Legacy: 1.0000 | New: 1.0000 | Diff: 0.0000\n" ] } ], @@ -1032,20 +1048,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/var/folders/2y/02fp70k56p75ldrkgtx7z10r0000gn/T/ipykernel_82228/2878535787.py:59: MatplotlibDeprecationWarning: The 'labels' parameter of boxplot() has been renamed 'tick_labels' since Matplotlib 3.9; support for the old name will be dropped in 3.11.\n", + "/var/folders/2y/02fp70k56p75ldrkgtx7z10r0000gn/T/ipykernel_39797/2878535787.py:59: MatplotlibDeprecationWarning: The 'labels' parameter of boxplot() has been renamed 'tick_labels' since Matplotlib 3.9; support for the old name will be dropped in 3.11.\n", " ax5.boxplot([df_fiqa[\"old_score\"], df_fiqa[\"new_score\"]], labels=['Legacy', 'New'])\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1151,7 +1167,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "metadata": {}, "outputs": [ { @@ -1160,19 +1176,19 @@ "text": [ "๐ŸŽฏ FIQA VALIDATION COMPLETE\n", "======================================================================\n", - " Mean |Diff|: 0.0364\n", - " Within 0.2: 29/30 (96.7%)\n", - " Within 0.3: 29/30 (96.7%)\n", + " Mean |Diff|: 0.0667\n", + " Within 0.2: 28/30 (93.3%)\n", + " Within 0.3: 28/30 (93.3%)\n", "\n", "๐Ÿ“Š Validation Criteria (LLM-based metrics):\n", - " โœ… Mean |diff| < 0.15: 0.0364\n", - " โœ… >90% within 0.2: 96.7%\n", - " โœ… >95% within 0.3: 96.7%\n", - " โœ… No systematic bias (|mean diff| < 0.05): 0.0346\n", + " โœ… Mean |diff| < 0.15: 0.0667\n", + " โœ… >90% within 0.2: 93.3%\n", + " โš ๏ธ >95% within 0.3: 93.3%\n", + " โœ… No systematic bias (|mean diff| < 0.05): 0.0000\n", "\n", "๐Ÿ’ก Domain Generalization Check:\n", - " โœ… Amnesty QA Mean |Diff|: 0.0558\n", - " โœ… FIQA Mean |Diff|: 0.0364\n", + " โœ… Amnesty QA Mean |Diff|: 0.0708\n", + " โœ… FIQA Mean |Diff|: 0.0667\n", " โœ… Consistent across domains\n" ] } @@ -1207,6 +1223,13 @@ " f\"Consistent across domains\")\n", "\n" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { diff --git a/tests/e2e/metrics_migration/plan-for-metrics-migration.md b/tests/e2e/metrics_migration/plan-for-metrics-migration.md index 8d144cf69..d5103b2e9 100644 --- a/tests/e2e/metrics_migration/plan-for-metrics-migration.md +++ b/tests/e2e/metrics_migration/plan-for-metrics-migration.md @@ -268,7 +268,7 @@ __all__ = [ ### 2.2 Generate Metric Configuration -The only thing you need to create is the `METRIC_CONFIG` dictionary for Cell 2 of the notebook. Use the template below based on your metric type: +Generate the `METRIC_CONFIG` dictionary for Cell 2 of the notebook. Print it to console for easy copy-pasting. Use the template below based on your metric type: #### Configuration Template @@ -426,14 +426,15 @@ The `dataset_fields` list tells the notebook which fields to extract from the te - Adjust your metric implementation - Re-run the notebook to verify improvements -6. **Document findings**: Note the following for your E2E tests: +6. **Document findings**: Print a migration summary with the following information: - Mean absolute difference - Percentage of samples within tolerance - Recommended tolerance level - Any patterns or anomalies observed - Edge cases that need special handling + - Key implementation details and algorithm differences -**No files are saved** - all results are displayed inline for quick validation! +**Output approach**: Print the METRIC_CONFIG and migration summary directly to console/output instead of creating files. This allows for easy copy-pasting without cluttering the repository. --- diff --git a/tests/e2e/metrics_migration/test_context_recall_migration.py b/tests/e2e/metrics_migration/test_context_recall_migration.py deleted file mode 100644 index 7d1141dcb..000000000 --- a/tests/e2e/metrics_migration/test_context_recall_migration.py +++ /dev/null @@ -1,158 +0,0 @@ -"""E2E tests for Context Recall metric migration from v1 (class-based) to v2 (class-based with automatic validation).""" - -import pytest - -from ragas.metrics import LLMContextRecall as LegacyContextRecall -from ragas.metrics.collections import ContextRecall - -from .base_migration_test import BaseMigrationTest - - -class TestContextRecallE2EMigration(BaseMigrationTest): - """E2E test compatibility between legacy ContextRecall class and new V2 ContextRecall class with automatic validation.""" - - @pytest.fixture - def sample_data(self): - """Real-world test cases for context recall evaluation.""" - return [ - { - "user_input": "What is the capital of France?", - "retrieved_contexts": [ - "Paris is the capital and largest city of France.", - "France is a country in Western Europe.", - ], - "reference": "Paris is the capital of France. It is located in northern France.", - "description": "Full attribution - all statements should be found in context", - }, - { - "user_input": "Tell me about Albert Einstein", - "retrieved_contexts": [ - "Albert Einstein was born in 1879. He developed the theory of relativity." - ], - "reference": "Einstein was born in 1879. He won the Nobel Prize in 1921. He developed relativity theory.", - "description": "Partial attribution - Nobel Prize not mentioned in context", - }, - { - "user_input": "What are the main causes of climate change?", - "retrieved_contexts": [ - "Climate change is primarily caused by greenhouse gas emissions from burning fossil fuels.", - "Deforestation also contributes to climate change by reducing CO2 absorption.", - ], - "reference": "The main causes include fossil fuel emissions and deforestation.", - "description": "Multiple contexts - all statements attributed", - }, - { - "user_input": "How does photosynthesis work?", - "retrieved_contexts": [ - "Photosynthesis is a process where plants use sunlight to produce glucose." - ], - "reference": "Plants convert sunlight into glucose through photosynthesis. This process also produces oxygen and occurs in chloroplasts.", - "description": "Partial attribution - oxygen and chloroplasts not in context", - }, - { - "user_input": "What is quantum computing?", - "retrieved_contexts": [ - "Quantum computers use quantum bits or qubits instead of classical bits." - ], - "reference": "Quantum computing uses qubits.", - "description": "Simple case - direct attribution", - }, - ] - - @pytest.mark.asyncio - async def test_legacy_context_recall_vs_v2_context_recall_e2e_compatibility( - self, - sample_data, - legacy_llm, - modern_llm, - ): - """E2E test that legacy and v2 implementations produce similar scores with real LLM.""" - await self.run_e2e_compatibility_test( - sample_data=sample_data, - legacy_metric_factory=LegacyContextRecall, - v2_metric_factory=ContextRecall, - legacy_components={"llm": legacy_llm}, - v2_components={"llm": modern_llm}, - tolerance=0.3, - metric_name="Context Recall", - additional_info_keys=["user_input", "reference"], - ) - - @pytest.mark.asyncio - async def test_context_recall_attribution_detection(self, legacy_llm, modern_llm): - """Test that both implementations correctly detect statement attributions.""" - - if legacy_llm is None or modern_llm is None: - pytest.skip("LLM required for E2E testing") - - # Test cases specifically for attribution detection - test_cases = [ - { - "user_input": "What is the capital of France?", - "retrieved_contexts": ["Paris is the capital of France."], - "reference": "Paris is the capital of France.", - "expected_high": True, - "description": "Perfect attribution - should get high score", - }, - { - "user_input": "What is the capital of France?", - "retrieved_contexts": ["France is a European country."], - "reference": "Paris is the capital of France.", - "expected_high": False, - "description": "No attribution - should get low score", - }, - { - "user_input": "Tell me about Einstein", - "retrieved_contexts": ["Einstein was born in 1879."], - "reference": "Einstein was born in 1879. He won the Nobel Prize.", - "expected_high": False, - "description": "Partial attribution - should get medium score (50%)", - }, - ] - - # Define custom assertion function - def assertion_fn(case, legacy_score, v2_result): - print(f" Reference: {case['reference']}") - - if case.get("expected_high"): - # High attribution should get high scores (> 0.8) - assert legacy_score > 0.8, ( - f"Legacy should detect high attribution: {legacy_score}" - ) - assert v2_result.value > 0.8, ( - f"V2 class should detect high attribution: {v2_result.value}" - ) - print(" โœ… All detected high attribution") - else: - # Low/partial attribution should get lower scores - # Note: We don't enforce strict thresholds here as it depends on the specific case - print( - f" โœ… Scores reflect attribution level (Legacy: {legacy_score:.2f}, V2: {v2_result.value:.2f})" - ) - - await self.run_metric_specific_test( - test_cases=test_cases, - legacy_metric_factory=LegacyContextRecall, - v2_metric_factory=ContextRecall, - legacy_components={"llm": legacy_llm}, - v2_components={"llm": modern_llm}, - test_name="attribution detection", - assertion_fn=assertion_fn, - ) - - def test_context_recall_migration_requirements_documented(self): - """Document the requirements for running full E2E context recall tests.""" - - requirements = { - "llm": "OpenAI GPT, Anthropic Claude, or other LangChain-compatible LLM", - "environment": "API keys configured for LLM providers", - "purpose": "Verify that v2 class-based implementation with automatic validation produces similar results to legacy class-based implementation", - } - - self.create_requirements_documentation( - metric_name="Context Recall", - requirements=requirements, - test_file_name="test_context_recall_migration.py", - ) - - assert True From 44034ff906d509d987e956a768cb9469d2983374 Mon Sep 17 00:00:00 2001 From: jjmachan Date: Wed, 15 Oct 2025 20:19:14 -0700 Subject: [PATCH 6/7] fix: format notebook with ruff --- .../metrics_migration/metric_score_diff.ipynb | 306 +++++++++++------- 1 file changed, 182 insertions(+), 124 deletions(-) diff --git a/tests/e2e/metrics_migration/metric_score_diff.ipynb b/tests/e2e/metrics_migration/metric_score_diff.ipynb index f8a84b1a4..38d785855 100644 --- a/tests/e2e/metrics_migration/metric_score_diff.ipynb +++ b/tests/e2e/metrics_migration/metric_score_diff.ipynb @@ -67,28 +67,23 @@ " # ===== METRIC IMPORTS =====\n", " \"legacy_import\": {\n", " \"module\": \"ragas.metrics._answer_relevance\", # e.g., \"ragas.metrics._context_recall\"\n", - " \"class_name\": \"AnswerRelevancy\", # e.g., \"ContextRecall\"\n", + " \"class_name\": \"AnswerRelevancy\", # e.g., \"ContextRecall\"\n", " },\n", " \"modern_import\": {\n", " \"module\": \"ragas.metrics.collections\",\n", " \"class_name\": \"AnswerRelevancy\",\n", " },\n", - " \n", " # ===== COMPONENT REQUIREMENTS =====\n", " # Set to False if your metric doesn't need this component\n", " \"needs_llm\": True,\n", " \"needs_embeddings\": True,\n", - " \n", " # ===== DATASET FIELD MAPPING =====\n", " # Which fields does your metric require from the dataset?\n", " # Choose ONE based on your metric type:\n", - " \n", " # OPTION 1: Answer-based metrics (AnswerRelevancy, AnswerSimilarity, etc.)\n", " \"dataset_fields\": [\"user_input\", \"response\"],\n", - " \n", " # OPTION 2: Context-based metrics (ContextRecall, ContextPrecision, etc.)\n", " # \"dataset_fields\": [\"user_input\", \"retrieved_contexts\", \"reference\"],\n", - " \n", " # OPTION 3: Deterministic metrics (NonLLMContextRecall, etc.)\n", " # \"dataset_fields\": [\"retrieved_contexts\", \"reference_contexts\"],\n", " # \"needs_llm\": False,\n", @@ -120,15 +115,13 @@ " \"module\": \"ragas.metrics.collections\",\n", " \"class_name\": \"ContextPrecision\",\n", " },\n", - "\n", " # ===== COMPONENT REQUIREMENTS =====\n", " \"needs_llm\": True,\n", " \"needs_embeddings\": False,\n", - "\n", " # ===== DATASET FIELD MAPPING =====\n", " # Context-based metric using user_input, retrieved_contexts, and reference\n", " \"dataset_fields\": [\"user_input\", \"retrieved_contexts\", \"reference\"],\n", - "}\n" + "}" ] }, { @@ -172,6 +165,7 @@ "check_api_key(\"openai\")\n", "print(\"โœ“ Setup complete\")\n", "\n", + "\n", "# ===== DYNAMIC METRIC LOADING =====\n", "def load_metric_class(import_config):\n", " \"\"\"Dynamically load a metric class from module and class name.\"\"\"\n", @@ -179,15 +173,22 @@ " module = importlib.import_module(import_config[\"module\"])\n", " return getattr(module, import_config[\"class_name\"])\n", " except (ImportError, AttributeError) as e:\n", - " raise ValueError(f\"Failed to load {import_config['class_name']} from {import_config['module']}: {e}\")\n", + " raise ValueError(\n", + " f\"Failed to load {import_config['class_name']} from {import_config['module']}: {e}\"\n", + " )\n", + "\n", "\n", "# Load metric classes from config\n", "LegacyMetric = load_metric_class(METRIC_CONFIG[\"legacy_import\"])\n", "ModernMetric = load_metric_class(METRIC_CONFIG[\"modern_import\"])\n", "\n", "print(f\"โœ“ Metric classes loaded:\")\n", - "print(f\" Legacy: {METRIC_CONFIG['legacy_import']['class_name']} from {METRIC_CONFIG['legacy_import']['module']}\")\n", - "print(f\" Modern: {METRIC_CONFIG['modern_import']['class_name']} from {METRIC_CONFIG['modern_import']['module']}\")" + "print(\n", + " f\" Legacy: {METRIC_CONFIG['legacy_import']['class_name']} from {METRIC_CONFIG['legacy_import']['module']}\"\n", + ")\n", + "print(\n", + " f\" Modern: {METRIC_CONFIG['modern_import']['class_name']} from {METRIC_CONFIG['modern_import']['module']}\"\n", + ")" ] }, { @@ -262,11 +263,15 @@ "\n", "if METRIC_CONFIG[\"needs_llm\"]:\n", " components_config[\"legacy_llm\"] = create_legacy_llm(model=\"gpt-4o-mini\")\n", - " components_config[\"modern_llm\"] = create_modern_llm(provider=\"openai\", model=\"gpt-4o-mini\")\n", + " components_config[\"modern_llm\"] = create_modern_llm(\n", + " provider=\"openai\", model=\"gpt-4o-mini\"\n", + " )\n", " print(\"โœ“ LLM components created\")\n", "\n", "if METRIC_CONFIG[\"needs_embeddings\"]:\n", - " components_config[\"legacy_embeddings\"] = create_legacy_embeddings(model=\"text-embedding-ada-002\")\n", + " components_config[\"legacy_embeddings\"] = create_legacy_embeddings(\n", + " model=\"text-embedding-ada-002\"\n", + " )\n", " components_config[\"modern_embeddings\"] = create_modern_embeddings(\n", " provider=\"openai\", model=\"text-embedding-ada-002\"\n", " )\n", @@ -305,23 +310,24 @@ "def init_metric(metric_class, components_config, is_legacy=True):\n", " \"\"\"Initialize a metric with available components.\"\"\"\n", " prefix = \"legacy_\" if is_legacy else \"modern_\"\n", - " \n", + "\n", " # Build kwargs from available components\n", " kwargs = {}\n", " if components_config[f\"{prefix}llm\"]:\n", " kwargs[\"llm\"] = components_config[f\"{prefix}llm\"]\n", " if components_config[f\"{prefix}embeddings\"]:\n", " kwargs[\"embeddings\"] = components_config[f\"{prefix}embeddings\"]\n", - " \n", + "\n", " return metric_class(**kwargs)\n", "\n", + "\n", "# Initialize metrics\n", "legacy_metric = init_metric(LegacyMetric, components_config, is_legacy=True)\n", "modern_metric = init_metric(ModernMetric, components_config, is_legacy=False)\n", "\n", "# Display initialized metrics\n", - "legacy_name = getattr(legacy_metric, 'name', legacy_metric.__class__.__name__)\n", - "modern_name = getattr(modern_metric, 'name', modern_metric.__class__.__name__)\n", + "legacy_name = getattr(legacy_metric, \"name\", legacy_metric.__class__.__name__)\n", + "modern_name = getattr(modern_metric, \"name\", modern_metric.__class__.__name__)\n", "\n", "print(f\"โœ“ Metrics initialized:\")\n", "print(f\" Legacy: {legacy_name}\")\n", @@ -372,7 +378,7 @@ "for i, sample in enumerate(amnesty_dataset):\n", " if i >= 20: # Start with 20 samples, adjust as needed\n", " break\n", - " \n", + "\n", " # Extract only configured fields\n", " test_sample = {}\n", " for field in METRIC_CONFIG[\"dataset_fields\"]:\n", @@ -389,8 +395,10 @@ " test_sample[field] = sample.get(\"response\", \"\")\n", " elif field == \"reference\":\n", " # Rename reference_contexts to reference if needed\n", - " test_sample[field] = sample.get(\"reference_contexts\", sample.get(\"reference\", \"\"))\n", - " \n", + " test_sample[field] = sample.get(\n", + " \"reference_contexts\", sample.get(\"reference\", \"\")\n", + " )\n", + "\n", " if test_sample: # Only add if we have data\n", " amnesty_test_data.append(test_sample)\n", "\n", @@ -454,13 +462,12 @@ } ], "source": [ - "\n", - "print(\"\\n\" + \"=\"*70)\n", + "print(\"\\n\" + \"=\" * 70)\n", "print(\"AMNESTY QA DATASET COMPARISON\")\n", - "print(\"=\"*70)\n", + "print(\"=\" * 70)\n", "print(f\"Dataset: {len(amnesty_test_data)} samples\")\n", "print(\"Mode: Concurrent processing + Parallel metrics\")\n", - "print(\"=\"*70)\n", + "print(\"=\" * 70)\n", "\n", "amnesty_result = await compare_metrics(\n", " old_metric=legacy_metric,\n", @@ -554,7 +561,6 @@ } ], "source": [ - "\n", "import pandas as pd\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", @@ -563,6 +569,7 @@ "df_amnesty = amnesty_result.to_dataframe()\n", "df_amnesty[\"sample_idx\"] = range(len(df_amnesty))\n", "\n", + "\n", "# Create description from first available string field in your test data\n", "def get_description(sample):\n", " \"\"\"Extract a short description from sample data.\"\"\"\n", @@ -571,12 +578,13 @@ " return sample[key][:60] + \"...\"\n", " return f\"Sample with {len(sample)} fields\"\n", "\n", + "\n", "df_amnesty[\"description\"] = [get_description(s) for s in amnesty_test_data]\n", "\n", "# Statistical Analysis\n", - "print(\"\\n\" + \"=\"*70)\n", + "print(\"\\n\" + \"=\" * 70)\n", "print(\"DETAILED STATISTICAL ANALYSIS\")\n", - "print(\"=\"*70)\n", + "print(\"=\" * 70)\n", "print(f\"\\nDataset: amnesty_qa ({len(df_amnesty)} samples)\")\n", "print(f\"\\nScore Statistics:\")\n", "print(f\" Legacy Mean: {amnesty_result.old_mean:.4f}\")\n", @@ -601,13 +609,15 @@ " print(f\" < {tol:.2f}: {within:3d}/{len(df_amnesty)} ({pct:5.1f}%)\")\n", "\n", "# Identify problematic cases\n", - "print(\"\\n\" + \"=\"*70)\n", + "print(\"\\n\" + \"=\" * 70)\n", "print(\"TOP 10 LARGEST DIFFERENCES\")\n", - "print(\"=\"*70)\n", + "print(\"=\" * 70)\n", "top_diffs = df_amnesty.nlargest(10, \"abs_diff\")\n", "for idx, row in top_diffs.iterrows():\n", - " print(f\"\\n#{row['sample_idx']+1}: {row['description']}\")\n", - " print(f\" Legacy: {row['old_score']:.4f} | New: {row['new_score']:.4f} | Diff: {row['abs_diff']:.4f}\")" + " print(f\"\\n#{row['sample_idx'] + 1}: {row['description']}\")\n", + " print(\n", + " f\" Legacy: {row['old_score']:.4f} | New: {row['new_score']:.4f} | Diff: {row['abs_diff']:.4f}\"\n", + " )" ] }, { @@ -644,10 +654,10 @@ "# 1. Scatter: Legacy vs New scores\n", "ax1 = fig.add_subplot(gs[0, 0])\n", "ax1.scatter(df_amnesty[\"old_score\"], df_amnesty[\"new_score\"], alpha=0.5, s=30)\n", - "ax1.plot([0, 1], [0, 1], 'r--', label=\"Perfect match\", linewidth=2)\n", + "ax1.plot([0, 1], [0, 1], \"r--\", label=\"Perfect match\", linewidth=2)\n", "ax1.set_xlabel(\"Legacy Score\", fontsize=10)\n", "ax1.set_ylabel(\"New Score\", fontsize=10)\n", - "ax1.set_title(\"Score Correlation\", fontsize=12, fontweight='bold')\n", + "ax1.set_title(\"Score Correlation\", fontsize=12, fontweight=\"bold\")\n", "ax1.legend()\n", "ax1.grid(True, alpha=0.3)\n", "ax1.set_xlim(-0.05, 1.05)\n", @@ -655,13 +665,18 @@ "\n", "# 2. Histogram: Difference distribution\n", "ax2 = fig.add_subplot(gs[0, 1])\n", - "ax2.hist(df_amnesty[\"diff\"], bins=40, alpha=0.7, edgecolor='black')\n", - "ax2.axvline(x=0, color='r', linestyle='--', linewidth=2, label='Zero diff')\n", - "ax2.axvline(x=df_amnesty[\"diff\"].mean(), color='g', linestyle='--', linewidth=2, \n", - " label=f'Mean: {df_amnesty[\"diff\"].mean():.3f}')\n", + "ax2.hist(df_amnesty[\"diff\"], bins=40, alpha=0.7, edgecolor=\"black\")\n", + "ax2.axvline(x=0, color=\"r\", linestyle=\"--\", linewidth=2, label=\"Zero diff\")\n", + "ax2.axvline(\n", + " x=df_amnesty[\"diff\"].mean(),\n", + " color=\"g\",\n", + " linestyle=\"--\",\n", + " linewidth=2,\n", + " label=f\"Mean: {df_amnesty['diff'].mean():.3f}\",\n", + ")\n", "ax2.set_xlabel(\"Difference (New - Legacy)\", fontsize=10)\n", "ax2.set_ylabel(\"Frequency\", fontsize=10)\n", - "ax2.set_title(\"Difference Distribution\", fontsize=12, fontweight='bold')\n", + "ax2.set_title(\"Difference Distribution\", fontsize=12, fontweight=\"bold\")\n", "ax2.legend()\n", "ax2.grid(True, alpha=0.3)\n", "\n", @@ -669,62 +684,72 @@ "ax3 = fig.add_subplot(gs[0, 2])\n", "non_zero_diffs = df_amnesty[df_amnesty[\"abs_diff\"] > 0][\"abs_diff\"]\n", "if len(non_zero_diffs) > 0:\n", - " ax3.hist(np.log10(non_zero_diffs), bins=40, alpha=0.7, color='orange', edgecolor='black')\n", - " ax3.axvline(x=-10, color='r', linestyle='--', linewidth=2, label='1e-10 tolerance')\n", + " ax3.hist(\n", + " np.log10(non_zero_diffs), bins=40, alpha=0.7, color=\"orange\", edgecolor=\"black\"\n", + " )\n", + " ax3.axvline(x=-10, color=\"r\", linestyle=\"--\", linewidth=2, label=\"1e-10 tolerance\")\n", " ax3.set_xlabel(\"Log10(Absolute Difference)\", fontsize=10)\n", "else:\n", - " ax3.text(0.5, 0.5, 'All differences are zero!', ha='center', va='center', fontsize=12)\n", + " ax3.text(\n", + " 0.5, 0.5, \"All differences are zero!\", ha=\"center\", va=\"center\", fontsize=12\n", + " )\n", "ax3.set_ylabel(\"Frequency\", fontsize=10)\n", - "ax3.set_title(\"Absolute Difference Distribution (Log)\", fontsize=12, fontweight='bold')\n", + "ax3.set_title(\"Absolute Difference Distribution (Log)\", fontsize=12, fontweight=\"bold\")\n", "ax3.legend()\n", "ax3.grid(True, alpha=0.3)\n", "\n", "# 4. Line plot: Score trends\n", "ax4 = fig.add_subplot(gs[1, :])\n", "x = df_amnesty[\"sample_idx\"]\n", - "ax4.plot(x, df_amnesty[\"old_score\"], 'o-', label=\"Legacy\", alpha=0.6, markersize=4)\n", - "ax4.plot(x, df_amnesty[\"new_score\"], 's-', label=\"New\", alpha=0.6, markersize=4)\n", + "ax4.plot(x, df_amnesty[\"old_score\"], \"o-\", label=\"Legacy\", alpha=0.6, markersize=4)\n", + "ax4.plot(x, df_amnesty[\"new_score\"], \"s-\", label=\"New\", alpha=0.6, markersize=4)\n", "ax4.set_xlabel(\"Sample Index\", fontsize=10)\n", "ax4.set_ylabel(\"Score\", fontsize=10)\n", - "ax4.set_title(\"Score Trends Across Dataset\", fontsize=12, fontweight='bold')\n", + "ax4.set_title(\"Score Trends Across Dataset\", fontsize=12, fontweight=\"bold\")\n", "ax4.legend()\n", "ax4.grid(True, alpha=0.3)\n", "ax4.set_ylim(-0.05, 1.05)\n", "\n", "# 5. Box plots: Score distributions\n", "ax5 = fig.add_subplot(gs[2, 0])\n", - "ax5.boxplot([df_amnesty[\"old_score\"], df_amnesty[\"new_score\"]], labels=['Legacy', 'New'])\n", + "ax5.boxplot(\n", + " [df_amnesty[\"old_score\"], df_amnesty[\"new_score\"]], labels=[\"Legacy\", \"New\"]\n", + ")\n", "ax5.set_ylabel(\"Score\", fontsize=10)\n", - "ax5.set_title(\"Score Distribution Comparison\", fontsize=12, fontweight='bold')\n", - "ax5.grid(True, alpha=0.3, axis='y')\n", + "ax5.set_title(\"Score Distribution Comparison\", fontsize=12, fontweight=\"bold\")\n", + "ax5.grid(True, alpha=0.3, axis=\"y\")\n", "\n", "# 6. Cumulative distribution of absolute differences\n", "ax6 = fig.add_subplot(gs[2, 1])\n", "sorted_diffs = np.sort(df_amnesty[\"abs_diff\"])\n", "cumulative = np.arange(1, len(sorted_diffs) + 1) / len(sorted_diffs) * 100\n", "ax6.plot(sorted_diffs, cumulative, linewidth=2)\n", - "ax6.axvline(x=0.2, color='r', linestyle='--', linewidth=2, label='0.2 tolerance')\n", - "ax6.axhline(y=90, color='g', linestyle='--', linewidth=1, alpha=0.5, label='90%')\n", + "ax6.axvline(x=0.2, color=\"r\", linestyle=\"--\", linewidth=2, label=\"0.2 tolerance\")\n", + "ax6.axhline(y=90, color=\"g\", linestyle=\"--\", linewidth=1, alpha=0.5, label=\"90%\")\n", "ax6.set_xlabel(\"Absolute Difference\", fontsize=10)\n", "ax6.set_ylabel(\"Cumulative Percentage\", fontsize=10)\n", - "ax6.set_title(\"Cumulative Distribution\", fontsize=12, fontweight='bold')\n", - "ax6.set_xscale('log')\n", + "ax6.set_title(\"Cumulative Distribution\", fontsize=12, fontweight=\"bold\")\n", + "ax6.set_xscale(\"log\")\n", "ax6.legend()\n", "ax6.grid(True, alpha=0.3)\n", "\n", "# 7. Scatter: Difference vs Legacy score\n", "ax7 = fig.add_subplot(gs[2, 2])\n", "ax7.scatter(df_amnesty[\"old_score\"], df_amnesty[\"abs_diff\"], alpha=0.5, s=30)\n", - "ax7.axhline(y=0.2, color='r', linestyle='--', linewidth=2, label='0.2 tolerance')\n", + "ax7.axhline(y=0.2, color=\"r\", linestyle=\"--\", linewidth=2, label=\"0.2 tolerance\")\n", "ax7.set_xlabel(\"Legacy Score\", fontsize=10)\n", "ax7.set_ylabel(\"Absolute Difference\", fontsize=10)\n", - "ax7.set_title(\"Difference vs Score\", fontsize=12, fontweight='bold')\n", - "ax7.set_yscale('log')\n", + "ax7.set_title(\"Difference vs Score\", fontsize=12, fontweight=\"bold\")\n", + "ax7.set_yscale(\"log\")\n", "ax7.legend()\n", "ax7.grid(True, alpha=0.3)\n", "\n", - "plt.suptitle(f\"Amnesty QA Migration Analysis ({len(df_amnesty)} samples)\", \n", - " fontsize=14, fontweight='bold', y=0.995)\n", + "plt.suptitle(\n", + " f\"Amnesty QA Migration Analysis ({len(df_amnesty)} samples)\",\n", + " fontsize=14,\n", + " fontweight=\"bold\",\n", + " y=0.995,\n", + ")\n", "plt.show()" ] }, @@ -759,25 +784,33 @@ "### Validate Amnesty QA Results\n", "\n", "print(\"๐ŸŽฏ AMNESTY QA VALIDATION COMPLETE\")\n", - "print(\"=\"*70)\n", + "print(\"=\" * 70)\n", "print(f\" Mean |Diff|: {df_amnesty['abs_diff'].mean():.4f}\")\n", - "print(f\" Within 0.2: {(df_amnesty['abs_diff'] < 0.2).sum()}/{len(df_amnesty)} \"\n", - " f\"({(df_amnesty['abs_diff'] < 0.2).sum()/len(df_amnesty)*100:.1f}%)\")\n", - "print(f\" Within 0.3: {(df_amnesty['abs_diff'] < 0.3).sum()}/{len(df_amnesty)} \"\n", - " f\"({(df_amnesty['abs_diff'] < 0.3).sum()/len(df_amnesty)*100:.1f}%)\")\n", + "print(\n", + " f\" Within 0.2: {(df_amnesty['abs_diff'] < 0.2).sum()}/{len(df_amnesty)} \"\n", + " f\"({(df_amnesty['abs_diff'] < 0.2).sum() / len(df_amnesty) * 100:.1f}%)\"\n", + ")\n", + "print(\n", + " f\" Within 0.3: {(df_amnesty['abs_diff'] < 0.3).sum()}/{len(df_amnesty)} \"\n", + " f\"({(df_amnesty['abs_diff'] < 0.3).sum() / len(df_amnesty) * 100:.1f}%)\"\n", + ")\n", "\n", "# Validation criteria for LLM-based metrics\n", "# For deterministic metrics, use stricter tolerances (1e-10, 1e-6)\n", - "mean_abs_diff = df_amnesty['abs_diff'].mean()\n", - "pct_within_02 = (df_amnesty['abs_diff'] < 0.2).sum() / len(df_amnesty) * 100\n", - "pct_within_03 = (df_amnesty['abs_diff'] < 0.3).sum() / len(df_amnesty) * 100\n", + "mean_abs_diff = df_amnesty[\"abs_diff\"].mean()\n", + "pct_within_02 = (df_amnesty[\"abs_diff\"] < 0.2).sum() / len(df_amnesty) * 100\n", + "pct_within_03 = (df_amnesty[\"abs_diff\"] < 0.3).sum() / len(df_amnesty) * 100\n", "\n", "print(\"\\n๐Ÿ“Š Validation Criteria (LLM-based metrics):\")\n", - "print(f\" {'โœ…' if mean_abs_diff < 0.15 else 'โŒ'} Mean |diff| < 0.15: {mean_abs_diff:.4f}\")\n", + "print(\n", + " f\" {'โœ…' if mean_abs_diff < 0.15 else 'โŒ'} Mean |diff| < 0.15: {mean_abs_diff:.4f}\"\n", + ")\n", "print(f\" {'โœ…' if pct_within_02 > 90 else 'โš ๏ธ'} >90% within 0.2: {pct_within_02:.1f}%\")\n", "print(f\" {'โœ…' if pct_within_03 > 95 else 'โš ๏ธ'} >95% within 0.3: {pct_within_03:.1f}%\")\n", - "print(f\" {'โœ…' if abs(amnesty_result.mean_diff) < 0.05 else 'โš ๏ธ'} \"\n", - " f\"No systematic bias (|mean diff| < 0.05): {abs(amnesty_result.mean_diff):.4f}\")\n", + "print(\n", + " f\" {'โœ…' if abs(amnesty_result.mean_diff) < 0.05 else 'โš ๏ธ'} \"\n", + " f\"No systematic bias (|mean diff| < 0.05): {abs(amnesty_result.mean_diff):.4f}\"\n", + ")\n", "\n", "print(\"\\n๐Ÿ’ก For deterministic metrics, use stricter criteria:\")\n", "print(\" - Mean |diff| < 1e-10\")\n", @@ -824,9 +857,9 @@ "\n", "from tests.e2e.test_dataset_utils import load_fiqa_dataset_safe\n", "\n", - "print(\"\\n\" + \"=\"*70)\n", + "print(\"\\n\" + \"=\" * 70)\n", "print(\"FIQA DATASET COMPARISON\")\n", - "print(\"=\"*70)\n", + "print(\"=\" * 70)\n", "print(\"Testing on financial Q&A dataset for domain generalization...\")\n", "\n", "fiqa_dataset = load_fiqa_dataset_safe(\"ragas_eval_v3\")\n", @@ -837,7 +870,7 @@ "for i, sample in enumerate(fiqa_dataset):\n", " if i >= 30: # Use up to 30 samples from ragas_eval_v3\n", " break\n", - " \n", + "\n", " # Extract only configured fields (same logic as Amnesty QA)\n", " test_sample = {}\n", " for field in METRIC_CONFIG[\"dataset_fields\"]:\n", @@ -854,8 +887,10 @@ " elif field == \"response\":\n", " test_sample[field] = sample.get(\"response\", \"\")\n", " elif field == \"reference\":\n", - " test_sample[field] = sample.get(\"reference_contexts\", sample.get(\"reference\", \"\"))\n", - " \n", + " test_sample[field] = sample.get(\n", + " \"reference_contexts\", sample.get(\"reference\", \"\")\n", + " )\n", + "\n", " if test_sample: # Only add if we have data\n", " fiqa_test_data.append(test_sample)\n", "\n", @@ -912,10 +947,10 @@ "source": [ "### Compare on FIQA (Optimized & Parallel)\n", "\n", - "print(\"\\n\" + \"=\"*70)\n", + "print(\"\\n\" + \"=\" * 70)\n", "print(f\"Dataset: {len(fiqa_test_data)} samples\")\n", "print(\"Mode: Concurrent processing + Parallel metrics\")\n", - "print(\"=\"*70)\n", + "print(\"=\" * 70)\n", "\n", "fiqa_result = await compare_metrics(\n", " old_metric=legacy_metric,\n", @@ -1010,9 +1045,9 @@ "df_fiqa[\"description\"] = [get_description(s) for s in fiqa_test_data]\n", "\n", "# Statistical Analysis\n", - "print(\"\\n\" + \"=\"*70)\n", + "print(\"\\n\" + \"=\" * 70)\n", "print(\"DETAILED STATISTICAL ANALYSIS\")\n", - "print(\"=\"*70)\n", + "print(\"=\" * 70)\n", "print(f\"\\nDataset: fiqa ({len(df_fiqa)} samples)\")\n", "print(f\"\\nScore Statistics:\")\n", "print(f\" Legacy Mean: {fiqa_result.old_mean:.4f}\")\n", @@ -1037,13 +1072,15 @@ " print(f\" < {tol:.2f}: {within:3d}/{len(df_fiqa)} ({pct:5.1f}%)\")\n", "\n", "# Identify problematic cases\n", - "print(\"\\n\" + \"=\"*70)\n", + "print(\"\\n\" + \"=\" * 70)\n", "print(\"TOP 10 LARGEST DIFFERENCES\")\n", - "print(\"=\"*70)\n", + "print(\"=\" * 70)\n", "top_diffs = df_fiqa.nlargest(10, \"abs_diff\")\n", "for idx, row in top_diffs.iterrows():\n", - " print(f\"\\n#{row['sample_idx']+1}: {row['description']}\")\n", - " print(f\" Legacy: {row['old_score']:.4f} | New: {row['new_score']:.4f} | Diff: {row['abs_diff']:.4f}\")" + " print(f\"\\n#{row['sample_idx'] + 1}: {row['description']}\")\n", + " print(\n", + " f\" Legacy: {row['old_score']:.4f} | New: {row['new_score']:.4f} | Diff: {row['abs_diff']:.4f}\"\n", + " )" ] }, { @@ -1080,10 +1117,10 @@ "# 1. Scatter: Legacy vs New scores\n", "ax1 = fig.add_subplot(gs[0, 0])\n", "ax1.scatter(df_fiqa[\"old_score\"], df_fiqa[\"new_score\"], alpha=0.5, s=30)\n", - "ax1.plot([0, 1], [0, 1], 'r--', label=\"Perfect match\", linewidth=2)\n", + "ax1.plot([0, 1], [0, 1], \"r--\", label=\"Perfect match\", linewidth=2)\n", "ax1.set_xlabel(\"Legacy Score\", fontsize=10)\n", "ax1.set_ylabel(\"New Score\", fontsize=10)\n", - "ax1.set_title(\"Score Correlation\", fontsize=12, fontweight='bold')\n", + "ax1.set_title(\"Score Correlation\", fontsize=12, fontweight=\"bold\")\n", "ax1.legend()\n", "ax1.grid(True, alpha=0.3)\n", "ax1.set_xlim(-0.05, 1.05)\n", @@ -1091,13 +1128,18 @@ "\n", "# 2. Histogram: Difference distribution\n", "ax2 = fig.add_subplot(gs[0, 1])\n", - "ax2.hist(df_fiqa[\"diff\"], bins=40, alpha=0.7, edgecolor='black')\n", - "ax2.axvline(x=0, color='r', linestyle='--', linewidth=2, label='Zero diff')\n", - "ax2.axvline(x=df_fiqa[\"diff\"].mean(), color='g', linestyle='--', linewidth=2, \n", - " label=f'Mean: {df_fiqa[\"diff\"].mean():.3f}')\n", + "ax2.hist(df_fiqa[\"diff\"], bins=40, alpha=0.7, edgecolor=\"black\")\n", + "ax2.axvline(x=0, color=\"r\", linestyle=\"--\", linewidth=2, label=\"Zero diff\")\n", + "ax2.axvline(\n", + " x=df_fiqa[\"diff\"].mean(),\n", + " color=\"g\",\n", + " linestyle=\"--\",\n", + " linewidth=2,\n", + " label=f\"Mean: {df_fiqa['diff'].mean():.3f}\",\n", + ")\n", "ax2.set_xlabel(\"Difference (New - Legacy)\", fontsize=10)\n", "ax2.set_ylabel(\"Frequency\", fontsize=10)\n", - "ax2.set_title(\"Difference Distribution\", fontsize=12, fontweight='bold')\n", + "ax2.set_title(\"Difference Distribution\", fontsize=12, fontweight=\"bold\")\n", "ax2.legend()\n", "ax2.grid(True, alpha=0.3)\n", "\n", @@ -1105,64 +1147,71 @@ "ax3 = fig.add_subplot(gs[0, 2])\n", "non_zero_diffs = df_fiqa[df_fiqa[\"abs_diff\"] > 0][\"abs_diff\"]\n", "if len(non_zero_diffs) > 0:\n", - " ax3.hist(np.log10(non_zero_diffs), bins=40, alpha=0.7, color='orange', edgecolor='black')\n", - " ax3.axvline(x=-10, color='r', linestyle='--', linewidth=2, label='1e-10 tolerance')\n", + " ax3.hist(\n", + " np.log10(non_zero_diffs), bins=40, alpha=0.7, color=\"orange\", edgecolor=\"black\"\n", + " )\n", + " ax3.axvline(x=-10, color=\"r\", linestyle=\"--\", linewidth=2, label=\"1e-10 tolerance\")\n", " ax3.set_xlabel(\"Log10(Absolute Difference)\", fontsize=10)\n", "else:\n", - " ax3.text(0.5, 0.5, 'All differences are zero!', ha='center', va='center', fontsize=12)\n", + " ax3.text(\n", + " 0.5, 0.5, \"All differences are zero!\", ha=\"center\", va=\"center\", fontsize=12\n", + " )\n", "ax3.set_ylabel(\"Frequency\", fontsize=10)\n", - "ax3.set_title(\"Absolute Difference Distribution (Log)\", fontsize=12, fontweight='bold')\n", + "ax3.set_title(\"Absolute Difference Distribution (Log)\", fontsize=12, fontweight=\"bold\")\n", "ax3.legend()\n", "ax3.grid(True, alpha=0.3)\n", "\n", "# 4. Line plot: Score trends\n", "ax4 = fig.add_subplot(gs[1, :])\n", "x = df_fiqa[\"sample_idx\"]\n", - "ax4.plot(x, df_fiqa[\"old_score\"], 'o-', label=\"Legacy\", alpha=0.6, markersize=4)\n", - "ax4.plot(x, df_fiqa[\"new_score\"], 's-', label=\"New\", alpha=0.6, markersize=4)\n", + "ax4.plot(x, df_fiqa[\"old_score\"], \"o-\", label=\"Legacy\", alpha=0.6, markersize=4)\n", + "ax4.plot(x, df_fiqa[\"new_score\"], \"s-\", label=\"New\", alpha=0.6, markersize=4)\n", "ax4.set_xlabel(\"Sample Index\", fontsize=10)\n", "ax4.set_ylabel(\"Score\", fontsize=10)\n", - "ax4.set_title(\"Score Trends Across Dataset\", fontsize=12, fontweight='bold')\n", + "ax4.set_title(\"Score Trends Across Dataset\", fontsize=12, fontweight=\"bold\")\n", "ax4.legend()\n", "ax4.grid(True, alpha=0.3)\n", "ax4.set_ylim(-0.05, 1.05)\n", "\n", "# 5. Box plots: Score distributions\n", "ax5 = fig.add_subplot(gs[2, 0])\n", - "ax5.boxplot([df_fiqa[\"old_score\"], df_fiqa[\"new_score\"]], labels=['Legacy', 'New'])\n", + "ax5.boxplot([df_fiqa[\"old_score\"], df_fiqa[\"new_score\"]], labels=[\"Legacy\", \"New\"])\n", "ax5.set_ylabel(\"Score\", fontsize=10)\n", - "ax5.set_title(\"Score Distribution Comparison\", fontsize=12, fontweight='bold')\n", - "ax5.grid(True, alpha=0.3, axis='y')\n", + "ax5.set_title(\"Score Distribution Comparison\", fontsize=12, fontweight=\"bold\")\n", + "ax5.grid(True, alpha=0.3, axis=\"y\")\n", "\n", "# 6. Cumulative distribution of absolute differences\n", "ax6 = fig.add_subplot(gs[2, 1])\n", "sorted_diffs = np.sort(df_fiqa[\"abs_diff\"])\n", "cumulative = np.arange(1, len(sorted_diffs) + 1) / len(sorted_diffs) * 100\n", "ax6.plot(sorted_diffs, cumulative, linewidth=2)\n", - "ax6.axvline(x=0.2, color='r', linestyle='--', linewidth=2, label='0.2 tolerance')\n", - "ax6.axhline(y=90, color='g', linestyle='--', linewidth=1, alpha=0.5, label='90%')\n", + "ax6.axvline(x=0.2, color=\"r\", linestyle=\"--\", linewidth=2, label=\"0.2 tolerance\")\n", + "ax6.axhline(y=90, color=\"g\", linestyle=\"--\", linewidth=1, alpha=0.5, label=\"90%\")\n", "ax6.set_xlabel(\"Absolute Difference\", fontsize=10)\n", "ax6.set_ylabel(\"Cumulative Percentage\", fontsize=10)\n", - "ax6.set_title(\"Cumulative Distribution\", fontsize=12, fontweight='bold')\n", - "ax6.set_xscale('log')\n", + "ax6.set_title(\"Cumulative Distribution\", fontsize=12, fontweight=\"bold\")\n", + "ax6.set_xscale(\"log\")\n", "ax6.legend()\n", "ax6.grid(True, alpha=0.3)\n", "\n", "# 7. Scatter: Difference vs Legacy score\n", "ax7 = fig.add_subplot(gs[2, 2])\n", "ax7.scatter(df_fiqa[\"old_score\"], df_fiqa[\"abs_diff\"], alpha=0.5, s=30)\n", - "ax7.axhline(y=0.2, color='r', linestyle='--', linewidth=2, label='0.2 tolerance')\n", + "ax7.axhline(y=0.2, color=\"r\", linestyle=\"--\", linewidth=2, label=\"0.2 tolerance\")\n", "ax7.set_xlabel(\"Legacy Score\", fontsize=10)\n", "ax7.set_ylabel(\"Absolute Difference\", fontsize=10)\n", - "ax7.set_title(\"Difference vs Score\", fontsize=12, fontweight='bold')\n", - "ax7.set_yscale('log')\n", + "ax7.set_title(\"Difference vs Score\", fontsize=12, fontweight=\"bold\")\n", + "ax7.set_yscale(\"log\")\n", "ax7.legend()\n", "ax7.grid(True, alpha=0.3)\n", "\n", - "plt.suptitle(f\"FIQA Migration Analysis ({len(df_fiqa)} samples)\", \n", - " fontsize=14, fontweight='bold', y=0.995)\n", - "plt.show()\n", - "\n" + "plt.suptitle(\n", + " f\"FIQA Migration Analysis ({len(df_fiqa)} samples)\",\n", + " fontsize=14,\n", + " fontweight=\"bold\",\n", + " y=0.995,\n", + ")\n", + "plt.show()" ] }, { @@ -1197,31 +1246,40 @@ "### Validate FIQA Results\n", "\n", "print(\"๐ŸŽฏ FIQA VALIDATION COMPLETE\")\n", - "print(\"=\"*70)\n", + "print(\"=\" * 70)\n", "print(f\" Mean |Diff|: {df_fiqa['abs_diff'].mean():.4f}\")\n", - "print(f\" Within 0.2: {(df_fiqa['abs_diff'] < 0.2).sum()}/{len(df_fiqa)} \"\n", - " f\"({(df_fiqa['abs_diff'] < 0.2).sum()/len(df_fiqa)*100:.1f}%)\")\n", - "print(f\" Within 0.3: {(df_fiqa['abs_diff'] < 0.3).sum()}/{len(df_fiqa)} \"\n", - " f\"({(df_fiqa['abs_diff'] < 0.3).sum()/len(df_fiqa)*100:.1f}%)\")\n", + "print(\n", + " f\" Within 0.2: {(df_fiqa['abs_diff'] < 0.2).sum()}/{len(df_fiqa)} \"\n", + " f\"({(df_fiqa['abs_diff'] < 0.2).sum() / len(df_fiqa) * 100:.1f}%)\"\n", + ")\n", + "print(\n", + " f\" Within 0.3: {(df_fiqa['abs_diff'] < 0.3).sum()}/{len(df_fiqa)} \"\n", + " f\"({(df_fiqa['abs_diff'] < 0.3).sum() / len(df_fiqa) * 100:.1f}%)\"\n", + ")\n", "\n", "# Validation criteria for LLM-based metrics\n", - "mean_abs_diff = df_fiqa['abs_diff'].mean()\n", - "pct_within_02 = (df_fiqa['abs_diff'] < 0.2).sum() / len(df_fiqa) * 100\n", - "pct_within_03 = (df_fiqa['abs_diff'] < 0.3).sum() / len(df_fiqa) * 100\n", + "mean_abs_diff = df_fiqa[\"abs_diff\"].mean()\n", + "pct_within_02 = (df_fiqa[\"abs_diff\"] < 0.2).sum() / len(df_fiqa) * 100\n", + "pct_within_03 = (df_fiqa[\"abs_diff\"] < 0.3).sum() / len(df_fiqa) * 100\n", "\n", "print(\"\\n๐Ÿ“Š Validation Criteria (LLM-based metrics):\")\n", - "print(f\" {'โœ…' if mean_abs_diff < 0.15 else 'โŒ'} Mean |diff| < 0.15: {mean_abs_diff:.4f}\")\n", + "print(\n", + " f\" {'โœ…' if mean_abs_diff < 0.15 else 'โŒ'} Mean |diff| < 0.15: {mean_abs_diff:.4f}\"\n", + ")\n", "print(f\" {'โœ…' if pct_within_02 > 90 else 'โš ๏ธ'} >90% within 0.2: {pct_within_02:.1f}%\")\n", "print(f\" {'โœ…' if pct_within_03 > 95 else 'โš ๏ธ'} >95% within 0.3: {pct_within_03:.1f}%\")\n", - "print(f\" {'โœ…' if abs(fiqa_result.mean_diff) < 0.05 else 'โš ๏ธ'} \"\n", - " f\"No systematic bias (|mean diff| < 0.05): {abs(fiqa_result.mean_diff):.4f}\")\n", + "print(\n", + " f\" {'โœ…' if abs(fiqa_result.mean_diff) < 0.05 else 'โš ๏ธ'} \"\n", + " f\"No systematic bias (|mean diff| < 0.05): {abs(fiqa_result.mean_diff):.4f}\"\n", + ")\n", "\n", "print(\"\\n๐Ÿ’ก Domain Generalization Check:\")\n", "print(f\" โœ… Amnesty QA Mean |Diff|: {df_amnesty['abs_diff'].mean():.4f}\")\n", "print(f\" โœ… FIQA Mean |Diff|: {df_fiqa['abs_diff'].mean():.4f}\")\n", - "print(f\" {'โœ…' if abs(df_amnesty['abs_diff'].mean() - df_fiqa['abs_diff'].mean()) < 0.1 else 'โš ๏ธ'} \"\n", - " f\"Consistent across domains\")\n", - "\n" + "print(\n", + " f\" {'โœ…' if abs(df_amnesty['abs_diff'].mean() - df_fiqa['abs_diff'].mean()) < 0.1 else 'โš ๏ธ'} \"\n", + " f\"Consistent across domains\"\n", + ")" ] }, { From 561679ea07670730d9e3293f5bcfc421347a0e2e Mon Sep 17 00:00:00 2001 From: jjmachan Date: Thu, 16 Oct 2025 16:28:20 -0700 Subject: [PATCH 7/7] fix: align Makefile format command with CI and fix notebook linting - Add --exclude src/ragas/_version.py to format and CI commands - This matches GitHub CI behavior which overrides pyproject.toml exclusions - Ensures notebooks are formatted locally, preventing CI failures - Add noqa: E402 comment to notebook for intentional sys.path modification --- Makefile | 18 +++---- .../metrics_migration/metric_score_diff.ipynb | 53 ++++++------------- 2 files changed, 25 insertions(+), 46 deletions(-) diff --git a/Makefile b/Makefile index 9150843db..3e4b4fb19 100644 --- a/Makefile +++ b/Makefile @@ -52,11 +52,11 @@ install: ## Install full dependencies with uv sync (backward compatible - modern format: ## Format and lint all code @echo "Formatting and linting all code..." @echo "(ruff format) Formatting ragas..." - $(Q)uv run --active ruff format src tests docs --config pyproject.toml + $(Q)uv run --active ruff format src tests docs --exclude src/ragas/_version.py --config pyproject.toml @echo "(ruff) Auto-fixing ragas (includes import sorting and unused imports)..." - $(Q)uv run --active ruff check src tests docs --fix-only --config pyproject.toml + $(Q)uv run --active ruff check src tests docs --exclude src/ragas/_version.py --fix-only --config pyproject.toml @echo "(ruff) Final linting check for ragas..." - $(Q)uv run --active ruff check src tests docs --config pyproject.toml + $(Q)uv run --active ruff check src tests docs --exclude src/ragas/_version.py --config pyproject.toml type: ## Type check all code @echo "Type checking all code..." @@ -93,8 +93,8 @@ benchmarks-test: ## Run benchmarks for ragas unit tests run-ci: ## Run complete CI pipeline (mirrors GitHub CI exactly) @echo "Running complete CI pipeline..." @echo "Format check..." - $(Q)uv run --active ruff format --check src tests docs --config pyproject.toml - $(Q)uv run --active ruff check src tests docs --config pyproject.toml + $(Q)uv run --active ruff format --check src tests docs --exclude src/ragas/_version.py --config pyproject.toml + $(Q)uv run --active ruff check src tests docs --exclude src/ragas/_version.py --config pyproject.toml @echo "Type check..." $(Q)$(MAKE) type @echo "Unit tests..." @@ -104,8 +104,8 @@ run-ci: ## Run complete CI pipeline (mirrors GitHub CI exactly) run-ci-format-check: ## Run format check in dry-run mode (like GitHub CI) @echo "Running format check (dry-run, like GitHub CI)..." @echo "Checking ragas formatting..." - $(Q)uv run --active ruff format --check src tests docs --config pyproject.toml - $(Q)uv run --active ruff check src docs tests --config pyproject.toml + $(Q)uv run --active ruff format --check src tests docs --exclude src/ragas/_version.py --config pyproject.toml + $(Q)uv run --active ruff check src docs tests --exclude src/ragas/_version.py --config pyproject.toml run-ci-type: ## Run type checking (matches GitHub CI) @echo "Running type checking (matches GitHub CI)..." @@ -118,8 +118,8 @@ run-ci-tests: ## Run all tests with CI options run-ci-fast: ## Fast CI check for quick local validation (2-3 minutes) @echo "Running fast CI check for quick feedback..." @echo "Format check..." - $(Q)uv run --active ruff format --check src tests docs --config pyproject.toml - $(Q)uv run --active ruff check src docs tests --config pyproject.toml + $(Q)uv run --active ruff format --check src tests docs --exclude src/ragas/_version.py --config pyproject.toml + $(Q)uv run --active ruff check src docs tests --exclude src/ragas/_version.py --config pyproject.toml @echo "Core unit tests (no nbmake for speed)..." $(Q)uv run --active pytest tests/unit --dist loadfile -n auto -x @echo "Fast CI check completed!" diff --git a/tests/e2e/metrics_migration/metric_score_diff.ipynb b/tests/e2e/metrics_migration/metric_score_diff.ipynb index 38d785855..8ec16c5c5 100644 --- a/tests/e2e/metrics_migration/metric_score_diff.ipynb +++ b/tests/e2e/metrics_migration/metric_score_diff.ipynb @@ -34,16 +34,9 @@ "metadata": {}, "outputs": [], "source": [ - "import asyncio\n", - "import time\n", - "from dataclasses import dataclass\n", - "from typing import Any, Dict, List, Tuple\n", - "\n", "import numpy as np\n", - "import pandas as pd\n", "\n", - "# Ragas imports\n", - "from ragas.dataset_schema import SingleTurnSample" + "# Ragas imports" ] }, { @@ -135,31 +128,19 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "โœ“ Setup complete\n", - "โœ“ Metric classes loaded:\n", - " Legacy: LLMContextPrecisionWithReference from ragas.metrics._context_precision\n", - " Modern: ContextPrecision from ragas.metrics.collections\n" - ] - } - ], + "outputs": [], "source": [ - "import os\n", + "import importlib\n", "import sys\n", "from pathlib import Path\n", - "import importlib\n", "\n", "# Add project root to path\n", "project_root = Path.cwd().parent.parent.parent\n", "sys.path.insert(0, str(project_root))\n", "\n", - "from tests.utils import check_api_key\n", + "from tests.utils import check_api_key # noqa: E402\n", "\n", "# Check for OpenAI API key\n", "check_api_key(\"openai\")\n", @@ -182,7 +163,7 @@ "LegacyMetric = load_metric_class(METRIC_CONFIG[\"legacy_import\"])\n", "ModernMetric = load_metric_class(METRIC_CONFIG[\"modern_import\"])\n", "\n", - "print(f\"โœ“ Metric classes loaded:\")\n", + "print(\"โœ“ Metric classes loaded:\")\n", "print(\n", " f\" Legacy: {METRIC_CONFIG['legacy_import']['class_name']} from {METRIC_CONFIG['legacy_import']['module']}\"\n", ")\n", @@ -329,7 +310,7 @@ "legacy_name = getattr(legacy_metric, \"name\", legacy_metric.__class__.__name__)\n", "modern_name = getattr(modern_metric, \"name\", modern_metric.__class__.__name__)\n", "\n", - "print(f\"โœ“ Metrics initialized:\")\n", + "print(\"โœ“ Metrics initialized:\")\n", "print(f\" Legacy: {legacy_name}\")\n", "print(f\" Modern: {modern_name}\")\n", "print(f\" Dataset fields required: {METRIC_CONFIG['dataset_fields']}\")" @@ -404,7 +385,7 @@ "\n", "print(f\"โœ“ Prepared {len(amnesty_test_data)} samples for testing\")\n", "if amnesty_test_data:\n", - " print(f\"\\nFirst sample fields:\")\n", + " print(\"\\nFirst sample fields:\")\n", " first_sample = amnesty_test_data[0]\n", " for key, value in first_sample.items():\n", " if isinstance(value, list):\n", @@ -561,9 +542,7 @@ } ], "source": [ - "import pandas as pd\n", "import matplotlib.pyplot as plt\n", - "import numpy as np\n", "\n", "# Get detailed DataFrame\n", "df_amnesty = amnesty_result.to_dataframe()\n", @@ -586,12 +565,12 @@ "print(\"DETAILED STATISTICAL ANALYSIS\")\n", "print(\"=\" * 70)\n", "print(f\"\\nDataset: amnesty_qa ({len(df_amnesty)} samples)\")\n", - "print(f\"\\nScore Statistics:\")\n", + "print(\"\\nScore Statistics:\")\n", "print(f\" Legacy Mean: {amnesty_result.old_mean:.4f}\")\n", "print(f\" New Mean: {amnesty_result.new_mean:.4f}\")\n", "print(f\" Score Shift: {amnesty_result.mean_diff:+.4f}\")\n", "\n", - "print(f\"\\nDifference Statistics:\")\n", + "print(\"\\nDifference Statistics:\")\n", "print(f\" Mean |Diff|: {df_amnesty['abs_diff'].mean():.4f}\")\n", "print(f\" Std Dev: {amnesty_result.std_diff:.4f}\")\n", "print(f\" Max Diff: {amnesty_result.max_diff:.4f}\")\n", @@ -602,7 +581,7 @@ "# For LLM-based metrics: use [0.1, 0.15, 0.2, 0.25, 0.3]\n", "# For deterministic metrics: use [1e-10, 1e-8, 1e-6, 1e-4, 0.01]\n", "tolerance_levels = [0.1, 0.15, 0.2, 0.25, 0.3]\n", - "print(f\"\\nTolerance Analysis:\")\n", + "print(\"\\nTolerance Analysis:\")\n", "for tol in tolerance_levels:\n", " within = (df_amnesty[\"abs_diff\"] < tol).sum()\n", " pct = within / len(df_amnesty) * 100\n", @@ -896,7 +875,7 @@ "\n", "print(f\"โœ“ Prepared {len(fiqa_test_data)} samples for testing\")\n", "if fiqa_test_data:\n", - " print(f\"\\nFirst sample fields:\")\n", + " print(\"\\nFirst sample fields:\")\n", " first_sample = fiqa_test_data[0]\n", " for key, value in first_sample.items():\n", " if isinstance(value, list):\n", @@ -1049,12 +1028,12 @@ "print(\"DETAILED STATISTICAL ANALYSIS\")\n", "print(\"=\" * 70)\n", "print(f\"\\nDataset: fiqa ({len(df_fiqa)} samples)\")\n", - "print(f\"\\nScore Statistics:\")\n", + "print(\"\\nScore Statistics:\")\n", "print(f\" Legacy Mean: {fiqa_result.old_mean:.4f}\")\n", "print(f\" New Mean: {fiqa_result.new_mean:.4f}\")\n", "print(f\" Score Shift: {fiqa_result.mean_diff:+.4f}\")\n", "\n", - "print(f\"\\nDifference Statistics:\")\n", + "print(\"\\nDifference Statistics:\")\n", "print(f\" Mean |Diff|: {df_fiqa['abs_diff'].mean():.4f}\")\n", "print(f\" Std Dev: {fiqa_result.std_diff:.4f}\")\n", "print(f\" Max Diff: {fiqa_result.max_diff:.4f}\")\n", @@ -1065,7 +1044,7 @@ "# For LLM-based metrics: use [0.1, 0.15, 0.2, 0.25, 0.3]\n", "# For deterministic metrics: use [1e-10, 1e-8, 1e-6, 1e-4, 0.01]\n", "tolerance_levels = [0.1, 0.15, 0.2, 0.25, 0.3]\n", - "print(f\"\\nTolerance Analysis:\")\n", + "print(\"\\nTolerance Analysis:\")\n", "for tol in tolerance_levels:\n", " within = (df_fiqa[\"abs_diff\"] < tol).sum()\n", " pct = within / len(df_fiqa) * 100\n", @@ -1311,4 +1290,4 @@ }, "nbformat": 4, "nbformat_minor": 4 -} +} \ No newline at end of file